module Data.SpirV.Enum.Op where

import Data.String (IsString(..))
import Data.Word (Word32)
import Foreign (Storable(..))
import GHC.Read (Read(..))
import Text.ParserCombinators.ReadPrec (pfail)
import qualified GHC.Read as Read
import qualified Text.Read.Lex as Lex

newtype Op = Op Word32
  deriving (Op -> Op -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Op -> Op -> Bool
$c/= :: Op -> Op -> Bool
== :: Op -> Op -> Bool
$c== :: Op -> Op -> Bool
Eq, Eq Op
Op -> Op -> Bool
Op -> Op -> Ordering
Op -> Op -> Op
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: Op -> Op -> Op
$cmin :: Op -> Op -> Op
max :: Op -> Op -> Op
$cmax :: Op -> Op -> Op
>= :: Op -> Op -> Bool
$c>= :: Op -> Op -> Bool
> :: Op -> Op -> Bool
$c> :: Op -> Op -> Bool
<= :: Op -> Op -> Bool
$c<= :: Op -> Op -> Bool
< :: Op -> Op -> Bool
$c< :: Op -> Op -> Bool
compare :: Op -> Op -> Ordering
$ccompare :: Op -> Op -> Ordering
Ord, Ptr Op -> IO Op
Ptr Op -> Int -> IO Op
Ptr Op -> Int -> Op -> IO ()
Ptr Op -> Op -> IO ()
Op -> Int
forall b. Ptr b -> Int -> IO Op
forall b. Ptr b -> Int -> Op -> IO ()
forall a.
(a -> Int)
-> (a -> Int)
-> (Ptr a -> Int -> IO a)
-> (Ptr a -> Int -> a -> IO ())
-> (forall b. Ptr b -> Int -> IO a)
-> (forall b. Ptr b -> Int -> a -> IO ())
-> (Ptr a -> IO a)
-> (Ptr a -> a -> IO ())
-> Storable a
poke :: Ptr Op -> Op -> IO ()
$cpoke :: Ptr Op -> Op -> IO ()
peek :: Ptr Op -> IO Op
$cpeek :: Ptr Op -> IO Op
pokeByteOff :: forall b. Ptr b -> Int -> Op -> IO ()
$cpokeByteOff :: forall b. Ptr b -> Int -> Op -> IO ()
peekByteOff :: forall b. Ptr b -> Int -> IO Op
$cpeekByteOff :: forall b. Ptr b -> Int -> IO Op
pokeElemOff :: Ptr Op -> Int -> Op -> IO ()
$cpokeElemOff :: Ptr Op -> Int -> Op -> IO ()
peekElemOff :: Ptr Op -> Int -> IO Op
$cpeekElemOff :: Ptr Op -> Int -> IO Op
alignment :: Op -> Int
$calignment :: Op -> Int
sizeOf :: Op -> Int
$csizeOf :: Op -> Int
Storable)

pattern OpNop :: Op
pattern $bOpNop :: Op
$mOpNop :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpNop = Op 0

pattern OpUndef :: Op
pattern $bOpUndef :: Op
$mOpUndef :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpUndef = Op 1

pattern OpSourceContinued :: Op
pattern $bOpSourceContinued :: Op
$mOpSourceContinued :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpSourceContinued = Op 2

pattern OpSource :: Op
pattern $bOpSource :: Op
$mOpSource :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpSource = Op 3

pattern OpSourceExtension :: Op
pattern $bOpSourceExtension :: Op
$mOpSourceExtension :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpSourceExtension = Op 4

pattern OpName :: Op
pattern $bOpName :: Op
$mOpName :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpName = Op 5

pattern OpMemberName :: Op
pattern $bOpMemberName :: Op
$mOpMemberName :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpMemberName = Op 6

pattern OpString :: Op
pattern $bOpString :: Op
$mOpString :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpString = Op 7

pattern OpLine :: Op
pattern $bOpLine :: Op
$mOpLine :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpLine = Op 8

pattern OpExtension :: Op
pattern $bOpExtension :: Op
$mOpExtension :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpExtension = Op 10

pattern OpExtInstImport :: Op
pattern $bOpExtInstImport :: Op
$mOpExtInstImport :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpExtInstImport = Op 11

pattern OpExtInst :: Op
pattern $bOpExtInst :: Op
$mOpExtInst :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpExtInst = Op 12

pattern OpMemoryModel :: Op
pattern $bOpMemoryModel :: Op
$mOpMemoryModel :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpMemoryModel = Op 14

pattern OpEntryPoint :: Op
pattern $bOpEntryPoint :: Op
$mOpEntryPoint :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpEntryPoint = Op 15

pattern OpExecutionMode :: Op
pattern $bOpExecutionMode :: Op
$mOpExecutionMode :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpExecutionMode = Op 16

pattern OpCapability :: Op
pattern $bOpCapability :: Op
$mOpCapability :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpCapability = Op 17

pattern OpTypeVoid :: Op
pattern $bOpTypeVoid :: Op
$mOpTypeVoid :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpTypeVoid = Op 19

pattern OpTypeBool :: Op
pattern $bOpTypeBool :: Op
$mOpTypeBool :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpTypeBool = Op 20

pattern OpTypeInt :: Op
pattern $bOpTypeInt :: Op
$mOpTypeInt :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpTypeInt = Op 21

pattern OpTypeFloat :: Op
pattern $bOpTypeFloat :: Op
$mOpTypeFloat :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpTypeFloat = Op 22

pattern OpTypeVector :: Op
pattern $bOpTypeVector :: Op
$mOpTypeVector :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpTypeVector = Op 23

pattern OpTypeMatrix :: Op
pattern $bOpTypeMatrix :: Op
$mOpTypeMatrix :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpTypeMatrix = Op 24

pattern OpTypeImage :: Op
pattern $bOpTypeImage :: Op
$mOpTypeImage :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpTypeImage = Op 25

pattern OpTypeSampler :: Op
pattern $bOpTypeSampler :: Op
$mOpTypeSampler :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpTypeSampler = Op 26

pattern OpTypeSampledImage :: Op
pattern $bOpTypeSampledImage :: Op
$mOpTypeSampledImage :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpTypeSampledImage = Op 27

pattern OpTypeArray :: Op
pattern $bOpTypeArray :: Op
$mOpTypeArray :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpTypeArray = Op 28

pattern OpTypeRuntimeArray :: Op
pattern $bOpTypeRuntimeArray :: Op
$mOpTypeRuntimeArray :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpTypeRuntimeArray = Op 29

pattern OpTypeStruct :: Op
pattern $bOpTypeStruct :: Op
$mOpTypeStruct :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpTypeStruct = Op 30

pattern OpTypeOpaque :: Op
pattern $bOpTypeOpaque :: Op
$mOpTypeOpaque :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpTypeOpaque = Op 31

pattern OpTypePointer :: Op
pattern $bOpTypePointer :: Op
$mOpTypePointer :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpTypePointer = Op 32

pattern OpTypeFunction :: Op
pattern $bOpTypeFunction :: Op
$mOpTypeFunction :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpTypeFunction = Op 33

pattern OpTypeEvent :: Op
pattern $bOpTypeEvent :: Op
$mOpTypeEvent :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpTypeEvent = Op 34

pattern OpTypeDeviceEvent :: Op
pattern $bOpTypeDeviceEvent :: Op
$mOpTypeDeviceEvent :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpTypeDeviceEvent = Op 35

pattern OpTypeReserveId :: Op
pattern $bOpTypeReserveId :: Op
$mOpTypeReserveId :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpTypeReserveId = Op 36

pattern OpTypeQueue :: Op
pattern $bOpTypeQueue :: Op
$mOpTypeQueue :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpTypeQueue = Op 37

pattern OpTypePipe :: Op
pattern $bOpTypePipe :: Op
$mOpTypePipe :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpTypePipe = Op 38

pattern OpTypeForwardPointer :: Op
pattern $bOpTypeForwardPointer :: Op
$mOpTypeForwardPointer :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpTypeForwardPointer = Op 39

pattern OpConstantTrue :: Op
pattern $bOpConstantTrue :: Op
$mOpConstantTrue :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpConstantTrue = Op 41

pattern OpConstantFalse :: Op
pattern $bOpConstantFalse :: Op
$mOpConstantFalse :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpConstantFalse = Op 42

pattern OpConstant :: Op
pattern $bOpConstant :: Op
$mOpConstant :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpConstant = Op 43

pattern OpConstantComposite :: Op
pattern $bOpConstantComposite :: Op
$mOpConstantComposite :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpConstantComposite = Op 44

pattern OpConstantSampler :: Op
pattern $bOpConstantSampler :: Op
$mOpConstantSampler :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpConstantSampler = Op 45

pattern OpConstantNull :: Op
pattern $bOpConstantNull :: Op
$mOpConstantNull :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpConstantNull = Op 46

pattern OpSpecConstantTrue :: Op
pattern $bOpSpecConstantTrue :: Op
$mOpSpecConstantTrue :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpSpecConstantTrue = Op 48

pattern OpSpecConstantFalse :: Op
pattern $bOpSpecConstantFalse :: Op
$mOpSpecConstantFalse :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpSpecConstantFalse = Op 49

pattern OpSpecConstant :: Op
pattern $bOpSpecConstant :: Op
$mOpSpecConstant :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpSpecConstant = Op 50

pattern OpSpecConstantComposite :: Op
pattern $bOpSpecConstantComposite :: Op
$mOpSpecConstantComposite :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpSpecConstantComposite = Op 51

pattern OpSpecConstantOp :: Op
pattern $bOpSpecConstantOp :: Op
$mOpSpecConstantOp :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpSpecConstantOp = Op 52

pattern OpFunction :: Op
pattern $bOpFunction :: Op
$mOpFunction :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpFunction = Op 54

pattern OpFunctionParameter :: Op
pattern $bOpFunctionParameter :: Op
$mOpFunctionParameter :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpFunctionParameter = Op 55

pattern OpFunctionEnd :: Op
pattern $bOpFunctionEnd :: Op
$mOpFunctionEnd :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpFunctionEnd = Op 56

pattern OpFunctionCall :: Op
pattern $bOpFunctionCall :: Op
$mOpFunctionCall :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpFunctionCall = Op 57

pattern OpVariable :: Op
pattern $bOpVariable :: Op
$mOpVariable :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpVariable = Op 59

pattern OpImageTexelPointer :: Op
pattern $bOpImageTexelPointer :: Op
$mOpImageTexelPointer :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpImageTexelPointer = Op 60

pattern OpLoad :: Op
pattern $bOpLoad :: Op
$mOpLoad :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpLoad = Op 61

pattern OpStore :: Op
pattern $bOpStore :: Op
$mOpStore :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpStore = Op 62

pattern OpCopyMemory :: Op
pattern $bOpCopyMemory :: Op
$mOpCopyMemory :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpCopyMemory = Op 63

pattern OpCopyMemorySized :: Op
pattern $bOpCopyMemorySized :: Op
$mOpCopyMemorySized :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpCopyMemorySized = Op 64

pattern OpAccessChain :: Op
pattern $bOpAccessChain :: Op
$mOpAccessChain :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpAccessChain = Op 65

pattern OpInBoundsAccessChain :: Op
pattern $bOpInBoundsAccessChain :: Op
$mOpInBoundsAccessChain :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpInBoundsAccessChain = Op 66

pattern OpPtrAccessChain :: Op
pattern $bOpPtrAccessChain :: Op
$mOpPtrAccessChain :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpPtrAccessChain = Op 67

pattern OpArrayLength :: Op
pattern $bOpArrayLength :: Op
$mOpArrayLength :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpArrayLength = Op 68

pattern OpGenericPtrMemSemantics :: Op
pattern $bOpGenericPtrMemSemantics :: Op
$mOpGenericPtrMemSemantics :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpGenericPtrMemSemantics = Op 69

pattern OpInBoundsPtrAccessChain :: Op
pattern $bOpInBoundsPtrAccessChain :: Op
$mOpInBoundsPtrAccessChain :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpInBoundsPtrAccessChain = Op 70

pattern OpDecorate :: Op
pattern $bOpDecorate :: Op
$mOpDecorate :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpDecorate = Op 71

pattern OpMemberDecorate :: Op
pattern $bOpMemberDecorate :: Op
$mOpMemberDecorate :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpMemberDecorate = Op 72

pattern OpDecorationGroup :: Op
pattern $bOpDecorationGroup :: Op
$mOpDecorationGroup :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpDecorationGroup = Op 73

pattern OpGroupDecorate :: Op
pattern $bOpGroupDecorate :: Op
$mOpGroupDecorate :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpGroupDecorate = Op 74

pattern OpGroupMemberDecorate :: Op
pattern $bOpGroupMemberDecorate :: Op
$mOpGroupMemberDecorate :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpGroupMemberDecorate = Op 75

pattern OpVectorExtractDynamic :: Op
pattern $bOpVectorExtractDynamic :: Op
$mOpVectorExtractDynamic :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpVectorExtractDynamic = Op 77

pattern OpVectorInsertDynamic :: Op
pattern $bOpVectorInsertDynamic :: Op
$mOpVectorInsertDynamic :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpVectorInsertDynamic = Op 78

pattern OpVectorShuffle :: Op
pattern $bOpVectorShuffle :: Op
$mOpVectorShuffle :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpVectorShuffle = Op 79

pattern OpCompositeConstruct :: Op
pattern $bOpCompositeConstruct :: Op
$mOpCompositeConstruct :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpCompositeConstruct = Op 80

pattern OpCompositeExtract :: Op
pattern $bOpCompositeExtract :: Op
$mOpCompositeExtract :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpCompositeExtract = Op 81

pattern OpCompositeInsert :: Op
pattern $bOpCompositeInsert :: Op
$mOpCompositeInsert :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpCompositeInsert = Op 82

pattern OpCopyObject :: Op
pattern $bOpCopyObject :: Op
$mOpCopyObject :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpCopyObject = Op 83

pattern OpTranspose :: Op
pattern $bOpTranspose :: Op
$mOpTranspose :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpTranspose = Op 84

pattern OpSampledImage :: Op
pattern $bOpSampledImage :: Op
$mOpSampledImage :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpSampledImage = Op 86

pattern OpImageSampleImplicitLod :: Op
pattern $bOpImageSampleImplicitLod :: Op
$mOpImageSampleImplicitLod :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpImageSampleImplicitLod = Op 87

pattern OpImageSampleExplicitLod :: Op
pattern $bOpImageSampleExplicitLod :: Op
$mOpImageSampleExplicitLod :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpImageSampleExplicitLod = Op 88

pattern OpImageSampleDrefImplicitLod :: Op
pattern $bOpImageSampleDrefImplicitLod :: Op
$mOpImageSampleDrefImplicitLod :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpImageSampleDrefImplicitLod = Op 89

pattern OpImageSampleDrefExplicitLod :: Op
pattern $bOpImageSampleDrefExplicitLod :: Op
$mOpImageSampleDrefExplicitLod :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpImageSampleDrefExplicitLod = Op 90

pattern OpImageSampleProjImplicitLod :: Op
pattern $bOpImageSampleProjImplicitLod :: Op
$mOpImageSampleProjImplicitLod :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpImageSampleProjImplicitLod = Op 91

pattern OpImageSampleProjExplicitLod :: Op
pattern $bOpImageSampleProjExplicitLod :: Op
$mOpImageSampleProjExplicitLod :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpImageSampleProjExplicitLod = Op 92

pattern OpImageSampleProjDrefImplicitLod :: Op
pattern $bOpImageSampleProjDrefImplicitLod :: Op
$mOpImageSampleProjDrefImplicitLod :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpImageSampleProjDrefImplicitLod = Op 93

pattern OpImageSampleProjDrefExplicitLod :: Op
pattern $bOpImageSampleProjDrefExplicitLod :: Op
$mOpImageSampleProjDrefExplicitLod :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpImageSampleProjDrefExplicitLod = Op 94

pattern OpImageFetch :: Op
pattern $bOpImageFetch :: Op
$mOpImageFetch :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpImageFetch = Op 95

pattern OpImageGather :: Op
pattern $bOpImageGather :: Op
$mOpImageGather :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpImageGather = Op 96

pattern OpImageDrefGather :: Op
pattern $bOpImageDrefGather :: Op
$mOpImageDrefGather :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpImageDrefGather = Op 97

pattern OpImageRead :: Op
pattern $bOpImageRead :: Op
$mOpImageRead :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpImageRead = Op 98

pattern OpImageWrite :: Op
pattern $bOpImageWrite :: Op
$mOpImageWrite :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpImageWrite = Op 99

pattern OpImage :: Op
pattern $bOpImage :: Op
$mOpImage :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpImage = Op 100

pattern OpImageQueryFormat :: Op
pattern $bOpImageQueryFormat :: Op
$mOpImageQueryFormat :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpImageQueryFormat = Op 101

pattern OpImageQueryOrder :: Op
pattern $bOpImageQueryOrder :: Op
$mOpImageQueryOrder :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpImageQueryOrder = Op 102

pattern OpImageQuerySizeLod :: Op
pattern $bOpImageQuerySizeLod :: Op
$mOpImageQuerySizeLod :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpImageQuerySizeLod = Op 103

pattern OpImageQuerySize :: Op
pattern $bOpImageQuerySize :: Op
$mOpImageQuerySize :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpImageQuerySize = Op 104

pattern OpImageQueryLod :: Op
pattern $bOpImageQueryLod :: Op
$mOpImageQueryLod :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpImageQueryLod = Op 105

pattern OpImageQueryLevels :: Op
pattern $bOpImageQueryLevels :: Op
$mOpImageQueryLevels :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpImageQueryLevels = Op 106

pattern OpImageQuerySamples :: Op
pattern $bOpImageQuerySamples :: Op
$mOpImageQuerySamples :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpImageQuerySamples = Op 107

pattern OpConvertFToU :: Op
pattern $bOpConvertFToU :: Op
$mOpConvertFToU :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpConvertFToU = Op 109

pattern OpConvertFToS :: Op
pattern $bOpConvertFToS :: Op
$mOpConvertFToS :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpConvertFToS = Op 110

pattern OpConvertSToF :: Op
pattern $bOpConvertSToF :: Op
$mOpConvertSToF :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpConvertSToF = Op 111

pattern OpConvertUToF :: Op
pattern $bOpConvertUToF :: Op
$mOpConvertUToF :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpConvertUToF = Op 112

pattern OpUConvert :: Op
pattern $bOpUConvert :: Op
$mOpUConvert :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpUConvert = Op 113

pattern OpSConvert :: Op
pattern $bOpSConvert :: Op
$mOpSConvert :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpSConvert = Op 114

pattern OpFConvert :: Op
pattern $bOpFConvert :: Op
$mOpFConvert :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpFConvert = Op 115

pattern OpQuantizeToF16 :: Op
pattern $bOpQuantizeToF16 :: Op
$mOpQuantizeToF16 :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpQuantizeToF16 = Op 116

pattern OpConvertPtrToU :: Op
pattern $bOpConvertPtrToU :: Op
$mOpConvertPtrToU :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpConvertPtrToU = Op 117

pattern OpSatConvertSToU :: Op
pattern $bOpSatConvertSToU :: Op
$mOpSatConvertSToU :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpSatConvertSToU = Op 118

pattern OpSatConvertUToS :: Op
pattern $bOpSatConvertUToS :: Op
$mOpSatConvertUToS :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpSatConvertUToS = Op 119

pattern OpConvertUToPtr :: Op
pattern $bOpConvertUToPtr :: Op
$mOpConvertUToPtr :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpConvertUToPtr = Op 120

pattern OpPtrCastToGeneric :: Op
pattern $bOpPtrCastToGeneric :: Op
$mOpPtrCastToGeneric :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpPtrCastToGeneric = Op 121

pattern OpGenericCastToPtr :: Op
pattern $bOpGenericCastToPtr :: Op
$mOpGenericCastToPtr :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpGenericCastToPtr = Op 122

pattern OpGenericCastToPtrExplicit :: Op
pattern $bOpGenericCastToPtrExplicit :: Op
$mOpGenericCastToPtrExplicit :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpGenericCastToPtrExplicit = Op 123

pattern OpBitcast :: Op
pattern $bOpBitcast :: Op
$mOpBitcast :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpBitcast = Op 124

pattern OpSNegate :: Op
pattern $bOpSNegate :: Op
$mOpSNegate :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpSNegate = Op 126

pattern OpFNegate :: Op
pattern $bOpFNegate :: Op
$mOpFNegate :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpFNegate = Op 127

pattern OpIAdd :: Op
pattern $bOpIAdd :: Op
$mOpIAdd :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpIAdd = Op 128

pattern OpFAdd :: Op
pattern $bOpFAdd :: Op
$mOpFAdd :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpFAdd = Op 129

pattern OpISub :: Op
pattern $bOpISub :: Op
$mOpISub :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpISub = Op 130

pattern OpFSub :: Op
pattern $bOpFSub :: Op
$mOpFSub :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpFSub = Op 131

pattern OpIMul :: Op
pattern $bOpIMul :: Op
$mOpIMul :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpIMul = Op 132

pattern OpFMul :: Op
pattern $bOpFMul :: Op
$mOpFMul :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpFMul = Op 133

pattern OpUDiv :: Op
pattern $bOpUDiv :: Op
$mOpUDiv :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpUDiv = Op 134

pattern OpSDiv :: Op
pattern $bOpSDiv :: Op
$mOpSDiv :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpSDiv = Op 135

pattern OpFDiv :: Op
pattern $bOpFDiv :: Op
$mOpFDiv :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpFDiv = Op 136

pattern OpUMod :: Op
pattern $bOpUMod :: Op
$mOpUMod :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpUMod = Op 137

pattern OpSRem :: Op
pattern $bOpSRem :: Op
$mOpSRem :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpSRem = Op 138

pattern OpSMod :: Op
pattern $bOpSMod :: Op
$mOpSMod :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpSMod = Op 139

pattern OpFRem :: Op
pattern $bOpFRem :: Op
$mOpFRem :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpFRem = Op 140

pattern OpFMod :: Op
pattern $bOpFMod :: Op
$mOpFMod :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpFMod = Op 141

pattern OpVectorTimesScalar :: Op
pattern $bOpVectorTimesScalar :: Op
$mOpVectorTimesScalar :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpVectorTimesScalar = Op 142

pattern OpMatrixTimesScalar :: Op
pattern $bOpMatrixTimesScalar :: Op
$mOpMatrixTimesScalar :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpMatrixTimesScalar = Op 143

pattern OpVectorTimesMatrix :: Op
pattern $bOpVectorTimesMatrix :: Op
$mOpVectorTimesMatrix :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpVectorTimesMatrix = Op 144

pattern OpMatrixTimesVector :: Op
pattern $bOpMatrixTimesVector :: Op
$mOpMatrixTimesVector :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpMatrixTimesVector = Op 145

pattern OpMatrixTimesMatrix :: Op
pattern $bOpMatrixTimesMatrix :: Op
$mOpMatrixTimesMatrix :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpMatrixTimesMatrix = Op 146

pattern OpOuterProduct :: Op
pattern $bOpOuterProduct :: Op
$mOpOuterProduct :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpOuterProduct = Op 147

pattern OpDot :: Op
pattern $bOpDot :: Op
$mOpDot :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpDot = Op 148

pattern OpIAddCarry :: Op
pattern $bOpIAddCarry :: Op
$mOpIAddCarry :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpIAddCarry = Op 149

pattern OpISubBorrow :: Op
pattern $bOpISubBorrow :: Op
$mOpISubBorrow :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpISubBorrow = Op 150

pattern OpUMulExtended :: Op
pattern $bOpUMulExtended :: Op
$mOpUMulExtended :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpUMulExtended = Op 151

pattern OpSMulExtended :: Op
pattern $bOpSMulExtended :: Op
$mOpSMulExtended :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpSMulExtended = Op 152

pattern OpAny :: Op
pattern $bOpAny :: Op
$mOpAny :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpAny = Op 154

pattern OpAll :: Op
pattern $bOpAll :: Op
$mOpAll :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpAll = Op 155

pattern OpIsNan :: Op
pattern $bOpIsNan :: Op
$mOpIsNan :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpIsNan = Op 156

pattern OpIsInf :: Op
pattern $bOpIsInf :: Op
$mOpIsInf :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpIsInf = Op 157

pattern OpIsFinite :: Op
pattern $bOpIsFinite :: Op
$mOpIsFinite :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpIsFinite = Op 158

pattern OpIsNormal :: Op
pattern $bOpIsNormal :: Op
$mOpIsNormal :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpIsNormal = Op 159

pattern OpSignBitSet :: Op
pattern $bOpSignBitSet :: Op
$mOpSignBitSet :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpSignBitSet = Op 160

pattern OpLessOrGreater :: Op
pattern $bOpLessOrGreater :: Op
$mOpLessOrGreater :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpLessOrGreater = Op 161

pattern OpOrdered :: Op
pattern $bOpOrdered :: Op
$mOpOrdered :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpOrdered = Op 162

pattern OpUnordered :: Op
pattern $bOpUnordered :: Op
$mOpUnordered :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpUnordered = Op 163

pattern OpLogicalEqual :: Op
pattern $bOpLogicalEqual :: Op
$mOpLogicalEqual :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpLogicalEqual = Op 164

pattern OpLogicalNotEqual :: Op
pattern $bOpLogicalNotEqual :: Op
$mOpLogicalNotEqual :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpLogicalNotEqual = Op 165

pattern OpLogicalOr :: Op
pattern $bOpLogicalOr :: Op
$mOpLogicalOr :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpLogicalOr = Op 166

pattern OpLogicalAnd :: Op
pattern $bOpLogicalAnd :: Op
$mOpLogicalAnd :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpLogicalAnd = Op 167

pattern OpLogicalNot :: Op
pattern $bOpLogicalNot :: Op
$mOpLogicalNot :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpLogicalNot = Op 168

pattern OpSelect :: Op
pattern $bOpSelect :: Op
$mOpSelect :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpSelect = Op 169

pattern OpIEqual :: Op
pattern $bOpIEqual :: Op
$mOpIEqual :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpIEqual = Op 170

pattern OpINotEqual :: Op
pattern $bOpINotEqual :: Op
$mOpINotEqual :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpINotEqual = Op 171

pattern OpUGreaterThan :: Op
pattern $bOpUGreaterThan :: Op
$mOpUGreaterThan :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpUGreaterThan = Op 172

pattern OpSGreaterThan :: Op
pattern $bOpSGreaterThan :: Op
$mOpSGreaterThan :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpSGreaterThan = Op 173

pattern OpUGreaterThanEqual :: Op
pattern $bOpUGreaterThanEqual :: Op
$mOpUGreaterThanEqual :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpUGreaterThanEqual = Op 174

pattern OpSGreaterThanEqual :: Op
pattern $bOpSGreaterThanEqual :: Op
$mOpSGreaterThanEqual :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpSGreaterThanEqual = Op 175

pattern OpULessThan :: Op
pattern $bOpULessThan :: Op
$mOpULessThan :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpULessThan = Op 176

pattern OpSLessThan :: Op
pattern $bOpSLessThan :: Op
$mOpSLessThan :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpSLessThan = Op 177

pattern OpULessThanEqual :: Op
pattern $bOpULessThanEqual :: Op
$mOpULessThanEqual :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpULessThanEqual = Op 178

pattern OpSLessThanEqual :: Op
pattern $bOpSLessThanEqual :: Op
$mOpSLessThanEqual :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpSLessThanEqual = Op 179

pattern OpFOrdEqual :: Op
pattern $bOpFOrdEqual :: Op
$mOpFOrdEqual :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpFOrdEqual = Op 180

pattern OpFUnordEqual :: Op
pattern $bOpFUnordEqual :: Op
$mOpFUnordEqual :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpFUnordEqual = Op 181

pattern OpFOrdNotEqual :: Op
pattern $bOpFOrdNotEqual :: Op
$mOpFOrdNotEqual :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpFOrdNotEqual = Op 182

pattern OpFUnordNotEqual :: Op
pattern $bOpFUnordNotEqual :: Op
$mOpFUnordNotEqual :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpFUnordNotEqual = Op 183

pattern OpFOrdLessThan :: Op
pattern $bOpFOrdLessThan :: Op
$mOpFOrdLessThan :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpFOrdLessThan = Op 184

pattern OpFUnordLessThan :: Op
pattern $bOpFUnordLessThan :: Op
$mOpFUnordLessThan :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpFUnordLessThan = Op 185

pattern OpFOrdGreaterThan :: Op
pattern $bOpFOrdGreaterThan :: Op
$mOpFOrdGreaterThan :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpFOrdGreaterThan = Op 186

pattern OpFUnordGreaterThan :: Op
pattern $bOpFUnordGreaterThan :: Op
$mOpFUnordGreaterThan :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpFUnordGreaterThan = Op 187

pattern OpFOrdLessThanEqual :: Op
pattern $bOpFOrdLessThanEqual :: Op
$mOpFOrdLessThanEqual :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpFOrdLessThanEqual = Op 188

pattern OpFUnordLessThanEqual :: Op
pattern $bOpFUnordLessThanEqual :: Op
$mOpFUnordLessThanEqual :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpFUnordLessThanEqual = Op 189

pattern OpFOrdGreaterThanEqual :: Op
pattern $bOpFOrdGreaterThanEqual :: Op
$mOpFOrdGreaterThanEqual :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpFOrdGreaterThanEqual = Op 190

pattern OpFUnordGreaterThanEqual :: Op
pattern $bOpFUnordGreaterThanEqual :: Op
$mOpFUnordGreaterThanEqual :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpFUnordGreaterThanEqual = Op 191

pattern OpShiftRightLogical :: Op
pattern $bOpShiftRightLogical :: Op
$mOpShiftRightLogical :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpShiftRightLogical = Op 194

pattern OpShiftRightArithmetic :: Op
pattern $bOpShiftRightArithmetic :: Op
$mOpShiftRightArithmetic :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpShiftRightArithmetic = Op 195

pattern OpShiftLeftLogical :: Op
pattern $bOpShiftLeftLogical :: Op
$mOpShiftLeftLogical :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpShiftLeftLogical = Op 196

pattern OpBitwiseOr :: Op
pattern $bOpBitwiseOr :: Op
$mOpBitwiseOr :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpBitwiseOr = Op 197

pattern OpBitwiseXor :: Op
pattern $bOpBitwiseXor :: Op
$mOpBitwiseXor :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpBitwiseXor = Op 198

pattern OpBitwiseAnd :: Op
pattern $bOpBitwiseAnd :: Op
$mOpBitwiseAnd :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpBitwiseAnd = Op 199

pattern OpNot :: Op
pattern $bOpNot :: Op
$mOpNot :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpNot = Op 200

pattern OpBitFieldInsert :: Op
pattern $bOpBitFieldInsert :: Op
$mOpBitFieldInsert :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpBitFieldInsert = Op 201

pattern OpBitFieldSExtract :: Op
pattern $bOpBitFieldSExtract :: Op
$mOpBitFieldSExtract :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpBitFieldSExtract = Op 202

pattern OpBitFieldUExtract :: Op
pattern $bOpBitFieldUExtract :: Op
$mOpBitFieldUExtract :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpBitFieldUExtract = Op 203

pattern OpBitReverse :: Op
pattern $bOpBitReverse :: Op
$mOpBitReverse :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpBitReverse = Op 204

pattern OpBitCount :: Op
pattern $bOpBitCount :: Op
$mOpBitCount :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpBitCount = Op 205

pattern OpDPdx :: Op
pattern $bOpDPdx :: Op
$mOpDPdx :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpDPdx = Op 207

pattern OpDPdy :: Op
pattern $bOpDPdy :: Op
$mOpDPdy :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpDPdy = Op 208

pattern OpFwidth :: Op
pattern $bOpFwidth :: Op
$mOpFwidth :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpFwidth = Op 209

pattern OpDPdxFine :: Op
pattern $bOpDPdxFine :: Op
$mOpDPdxFine :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpDPdxFine = Op 210

pattern OpDPdyFine :: Op
pattern $bOpDPdyFine :: Op
$mOpDPdyFine :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpDPdyFine = Op 211

pattern OpFwidthFine :: Op
pattern $bOpFwidthFine :: Op
$mOpFwidthFine :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpFwidthFine = Op 212

pattern OpDPdxCoarse :: Op
pattern $bOpDPdxCoarse :: Op
$mOpDPdxCoarse :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpDPdxCoarse = Op 213

pattern OpDPdyCoarse :: Op
pattern $bOpDPdyCoarse :: Op
$mOpDPdyCoarse :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpDPdyCoarse = Op 214

pattern OpFwidthCoarse :: Op
pattern $bOpFwidthCoarse :: Op
$mOpFwidthCoarse :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpFwidthCoarse = Op 215

pattern OpEmitVertex :: Op
pattern $bOpEmitVertex :: Op
$mOpEmitVertex :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpEmitVertex = Op 218

pattern OpEndPrimitive :: Op
pattern $bOpEndPrimitive :: Op
$mOpEndPrimitive :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpEndPrimitive = Op 219

pattern OpEmitStreamVertex :: Op
pattern $bOpEmitStreamVertex :: Op
$mOpEmitStreamVertex :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpEmitStreamVertex = Op 220

pattern OpEndStreamPrimitive :: Op
pattern $bOpEndStreamPrimitive :: Op
$mOpEndStreamPrimitive :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpEndStreamPrimitive = Op 221

pattern OpControlBarrier :: Op
pattern $bOpControlBarrier :: Op
$mOpControlBarrier :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpControlBarrier = Op 224

pattern OpMemoryBarrier :: Op
pattern $bOpMemoryBarrier :: Op
$mOpMemoryBarrier :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpMemoryBarrier = Op 225

pattern OpAtomicLoad :: Op
pattern $bOpAtomicLoad :: Op
$mOpAtomicLoad :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpAtomicLoad = Op 227

pattern OpAtomicStore :: Op
pattern $bOpAtomicStore :: Op
$mOpAtomicStore :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpAtomicStore = Op 228

pattern OpAtomicExchange :: Op
pattern $bOpAtomicExchange :: Op
$mOpAtomicExchange :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpAtomicExchange = Op 229

pattern OpAtomicCompareExchange :: Op
pattern $bOpAtomicCompareExchange :: Op
$mOpAtomicCompareExchange :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpAtomicCompareExchange = Op 230

pattern OpAtomicCompareExchangeWeak :: Op
pattern $bOpAtomicCompareExchangeWeak :: Op
$mOpAtomicCompareExchangeWeak :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpAtomicCompareExchangeWeak = Op 231

pattern OpAtomicIIncrement :: Op
pattern $bOpAtomicIIncrement :: Op
$mOpAtomicIIncrement :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpAtomicIIncrement = Op 232

pattern OpAtomicIDecrement :: Op
pattern $bOpAtomicIDecrement :: Op
$mOpAtomicIDecrement :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpAtomicIDecrement = Op 233

pattern OpAtomicIAdd :: Op
pattern $bOpAtomicIAdd :: Op
$mOpAtomicIAdd :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpAtomicIAdd = Op 234

pattern OpAtomicISub :: Op
pattern $bOpAtomicISub :: Op
$mOpAtomicISub :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpAtomicISub = Op 235

pattern OpAtomicSMin :: Op
pattern $bOpAtomicSMin :: Op
$mOpAtomicSMin :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpAtomicSMin = Op 236

pattern OpAtomicUMin :: Op
pattern $bOpAtomicUMin :: Op
$mOpAtomicUMin :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpAtomicUMin = Op 237

pattern OpAtomicSMax :: Op
pattern $bOpAtomicSMax :: Op
$mOpAtomicSMax :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpAtomicSMax = Op 238

pattern OpAtomicUMax :: Op
pattern $bOpAtomicUMax :: Op
$mOpAtomicUMax :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpAtomicUMax = Op 239

pattern OpAtomicAnd :: Op
pattern $bOpAtomicAnd :: Op
$mOpAtomicAnd :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpAtomicAnd = Op 240

pattern OpAtomicOr :: Op
pattern $bOpAtomicOr :: Op
$mOpAtomicOr :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpAtomicOr = Op 241

pattern OpAtomicXor :: Op
pattern $bOpAtomicXor :: Op
$mOpAtomicXor :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpAtomicXor = Op 242

pattern OpPhi :: Op
pattern $bOpPhi :: Op
$mOpPhi :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpPhi = Op 245

pattern OpLoopMerge :: Op
pattern $bOpLoopMerge :: Op
$mOpLoopMerge :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpLoopMerge = Op 246

pattern OpSelectionMerge :: Op
pattern $bOpSelectionMerge :: Op
$mOpSelectionMerge :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpSelectionMerge = Op 247

pattern OpLabel :: Op
pattern $bOpLabel :: Op
$mOpLabel :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpLabel = Op 248

pattern OpBranch :: Op
pattern $bOpBranch :: Op
$mOpBranch :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpBranch = Op 249

pattern OpBranchConditional :: Op
pattern $bOpBranchConditional :: Op
$mOpBranchConditional :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpBranchConditional = Op 250

pattern OpSwitch :: Op
pattern $bOpSwitch :: Op
$mOpSwitch :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpSwitch = Op 251

pattern OpKill :: Op
pattern $bOpKill :: Op
$mOpKill :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpKill = Op 252

pattern OpReturn :: Op
pattern $bOpReturn :: Op
$mOpReturn :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpReturn = Op 253

pattern OpReturnValue :: Op
pattern $bOpReturnValue :: Op
$mOpReturnValue :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpReturnValue = Op 254

pattern OpUnreachable :: Op
pattern $bOpUnreachable :: Op
$mOpUnreachable :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpUnreachable = Op 255

pattern OpLifetimeStart :: Op
pattern $bOpLifetimeStart :: Op
$mOpLifetimeStart :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpLifetimeStart = Op 256

pattern OpLifetimeStop :: Op
pattern $bOpLifetimeStop :: Op
$mOpLifetimeStop :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpLifetimeStop = Op 257

pattern OpGroupAsyncCopy :: Op
pattern $bOpGroupAsyncCopy :: Op
$mOpGroupAsyncCopy :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpGroupAsyncCopy = Op 259

pattern OpGroupWaitEvents :: Op
pattern $bOpGroupWaitEvents :: Op
$mOpGroupWaitEvents :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpGroupWaitEvents = Op 260

pattern OpGroupAll :: Op
pattern $bOpGroupAll :: Op
$mOpGroupAll :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpGroupAll = Op 261

pattern OpGroupAny :: Op
pattern $bOpGroupAny :: Op
$mOpGroupAny :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpGroupAny = Op 262

pattern OpGroupBroadcast :: Op
pattern $bOpGroupBroadcast :: Op
$mOpGroupBroadcast :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpGroupBroadcast = Op 263

pattern OpGroupIAdd :: Op
pattern $bOpGroupIAdd :: Op
$mOpGroupIAdd :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpGroupIAdd = Op 264

pattern OpGroupFAdd :: Op
pattern $bOpGroupFAdd :: Op
$mOpGroupFAdd :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpGroupFAdd = Op 265

pattern OpGroupFMin :: Op
pattern $bOpGroupFMin :: Op
$mOpGroupFMin :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpGroupFMin = Op 266

pattern OpGroupUMin :: Op
pattern $bOpGroupUMin :: Op
$mOpGroupUMin :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpGroupUMin = Op 267

pattern OpGroupSMin :: Op
pattern $bOpGroupSMin :: Op
$mOpGroupSMin :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpGroupSMin = Op 268

pattern OpGroupFMax :: Op
pattern $bOpGroupFMax :: Op
$mOpGroupFMax :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpGroupFMax = Op 269

pattern OpGroupUMax :: Op
pattern $bOpGroupUMax :: Op
$mOpGroupUMax :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpGroupUMax = Op 270

pattern OpGroupSMax :: Op
pattern $bOpGroupSMax :: Op
$mOpGroupSMax :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpGroupSMax = Op 271

pattern OpReadPipe :: Op
pattern $bOpReadPipe :: Op
$mOpReadPipe :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpReadPipe = Op 274

pattern OpWritePipe :: Op
pattern $bOpWritePipe :: Op
$mOpWritePipe :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpWritePipe = Op 275

pattern OpReservedReadPipe :: Op
pattern $bOpReservedReadPipe :: Op
$mOpReservedReadPipe :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpReservedReadPipe = Op 276

pattern OpReservedWritePipe :: Op
pattern $bOpReservedWritePipe :: Op
$mOpReservedWritePipe :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpReservedWritePipe = Op 277

pattern OpReserveReadPipePackets :: Op
pattern $bOpReserveReadPipePackets :: Op
$mOpReserveReadPipePackets :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpReserveReadPipePackets = Op 278

pattern OpReserveWritePipePackets :: Op
pattern $bOpReserveWritePipePackets :: Op
$mOpReserveWritePipePackets :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpReserveWritePipePackets = Op 279

pattern OpCommitReadPipe :: Op
pattern $bOpCommitReadPipe :: Op
$mOpCommitReadPipe :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpCommitReadPipe = Op 280

pattern OpCommitWritePipe :: Op
pattern $bOpCommitWritePipe :: Op
$mOpCommitWritePipe :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpCommitWritePipe = Op 281

pattern OpIsValidReserveId :: Op
pattern $bOpIsValidReserveId :: Op
$mOpIsValidReserveId :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpIsValidReserveId = Op 282

pattern OpGetNumPipePackets :: Op
pattern $bOpGetNumPipePackets :: Op
$mOpGetNumPipePackets :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpGetNumPipePackets = Op 283

pattern OpGetMaxPipePackets :: Op
pattern $bOpGetMaxPipePackets :: Op
$mOpGetMaxPipePackets :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpGetMaxPipePackets = Op 284

pattern OpGroupReserveReadPipePackets :: Op
pattern $bOpGroupReserveReadPipePackets :: Op
$mOpGroupReserveReadPipePackets :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpGroupReserveReadPipePackets = Op 285

pattern OpGroupReserveWritePipePackets :: Op
pattern $bOpGroupReserveWritePipePackets :: Op
$mOpGroupReserveWritePipePackets :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpGroupReserveWritePipePackets = Op 286

pattern OpGroupCommitReadPipe :: Op
pattern $bOpGroupCommitReadPipe :: Op
$mOpGroupCommitReadPipe :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpGroupCommitReadPipe = Op 287

pattern OpGroupCommitWritePipe :: Op
pattern $bOpGroupCommitWritePipe :: Op
$mOpGroupCommitWritePipe :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpGroupCommitWritePipe = Op 288

pattern OpEnqueueMarker :: Op
pattern $bOpEnqueueMarker :: Op
$mOpEnqueueMarker :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpEnqueueMarker = Op 291

pattern OpEnqueueKernel :: Op
pattern $bOpEnqueueKernel :: Op
$mOpEnqueueKernel :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpEnqueueKernel = Op 292

pattern OpGetKernelNDrangeSubGroupCount :: Op
pattern $bOpGetKernelNDrangeSubGroupCount :: Op
$mOpGetKernelNDrangeSubGroupCount :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpGetKernelNDrangeSubGroupCount = Op 293

pattern OpGetKernelNDrangeMaxSubGroupSize :: Op
pattern $bOpGetKernelNDrangeMaxSubGroupSize :: Op
$mOpGetKernelNDrangeMaxSubGroupSize :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpGetKernelNDrangeMaxSubGroupSize = Op 294

pattern OpGetKernelWorkGroupSize :: Op
pattern $bOpGetKernelWorkGroupSize :: Op
$mOpGetKernelWorkGroupSize :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpGetKernelWorkGroupSize = Op 295

pattern OpGetKernelPreferredWorkGroupSizeMultiple :: Op
pattern $bOpGetKernelPreferredWorkGroupSizeMultiple :: Op
$mOpGetKernelPreferredWorkGroupSizeMultiple :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpGetKernelPreferredWorkGroupSizeMultiple = Op 296

pattern OpRetainEvent :: Op
pattern $bOpRetainEvent :: Op
$mOpRetainEvent :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpRetainEvent = Op 297

pattern OpReleaseEvent :: Op
pattern $bOpReleaseEvent :: Op
$mOpReleaseEvent :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpReleaseEvent = Op 298

pattern OpCreateUserEvent :: Op
pattern $bOpCreateUserEvent :: Op
$mOpCreateUserEvent :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpCreateUserEvent = Op 299

pattern OpIsValidEvent :: Op
pattern $bOpIsValidEvent :: Op
$mOpIsValidEvent :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpIsValidEvent = Op 300

pattern OpSetUserEventStatus :: Op
pattern $bOpSetUserEventStatus :: Op
$mOpSetUserEventStatus :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpSetUserEventStatus = Op 301

pattern OpCaptureEventProfilingInfo :: Op
pattern $bOpCaptureEventProfilingInfo :: Op
$mOpCaptureEventProfilingInfo :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpCaptureEventProfilingInfo = Op 302

pattern OpGetDefaultQueue :: Op
pattern $bOpGetDefaultQueue :: Op
$mOpGetDefaultQueue :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpGetDefaultQueue = Op 303

pattern OpBuildNDRange :: Op
pattern $bOpBuildNDRange :: Op
$mOpBuildNDRange :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpBuildNDRange = Op 304

pattern OpImageSparseSampleImplicitLod :: Op
pattern $bOpImageSparseSampleImplicitLod :: Op
$mOpImageSparseSampleImplicitLod :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpImageSparseSampleImplicitLod = Op 305

pattern OpImageSparseSampleExplicitLod :: Op
pattern $bOpImageSparseSampleExplicitLod :: Op
$mOpImageSparseSampleExplicitLod :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpImageSparseSampleExplicitLod = Op 306

pattern OpImageSparseSampleDrefImplicitLod :: Op
pattern $bOpImageSparseSampleDrefImplicitLod :: Op
$mOpImageSparseSampleDrefImplicitLod :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpImageSparseSampleDrefImplicitLod = Op 307

pattern OpImageSparseSampleDrefExplicitLod :: Op
pattern $bOpImageSparseSampleDrefExplicitLod :: Op
$mOpImageSparseSampleDrefExplicitLod :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpImageSparseSampleDrefExplicitLod = Op 308

pattern OpImageSparseSampleProjImplicitLod :: Op
pattern $bOpImageSparseSampleProjImplicitLod :: Op
$mOpImageSparseSampleProjImplicitLod :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpImageSparseSampleProjImplicitLod = Op 309

pattern OpImageSparseSampleProjExplicitLod :: Op
pattern $bOpImageSparseSampleProjExplicitLod :: Op
$mOpImageSparseSampleProjExplicitLod :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpImageSparseSampleProjExplicitLod = Op 310

pattern OpImageSparseSampleProjDrefImplicitLod :: Op
pattern $bOpImageSparseSampleProjDrefImplicitLod :: Op
$mOpImageSparseSampleProjDrefImplicitLod :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpImageSparseSampleProjDrefImplicitLod = Op 311

pattern OpImageSparseSampleProjDrefExplicitLod :: Op
pattern $bOpImageSparseSampleProjDrefExplicitLod :: Op
$mOpImageSparseSampleProjDrefExplicitLod :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpImageSparseSampleProjDrefExplicitLod = Op 312

pattern OpImageSparseFetch :: Op
pattern $bOpImageSparseFetch :: Op
$mOpImageSparseFetch :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpImageSparseFetch = Op 313

pattern OpImageSparseGather :: Op
pattern $bOpImageSparseGather :: Op
$mOpImageSparseGather :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpImageSparseGather = Op 314

pattern OpImageSparseDrefGather :: Op
pattern $bOpImageSparseDrefGather :: Op
$mOpImageSparseDrefGather :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpImageSparseDrefGather = Op 315

pattern OpImageSparseTexelsResident :: Op
pattern $bOpImageSparseTexelsResident :: Op
$mOpImageSparseTexelsResident :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpImageSparseTexelsResident = Op 316

pattern OpNoLine :: Op
pattern $bOpNoLine :: Op
$mOpNoLine :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpNoLine = Op 317

pattern OpAtomicFlagTestAndSet :: Op
pattern $bOpAtomicFlagTestAndSet :: Op
$mOpAtomicFlagTestAndSet :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpAtomicFlagTestAndSet = Op 318

pattern OpAtomicFlagClear :: Op
pattern $bOpAtomicFlagClear :: Op
$mOpAtomicFlagClear :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpAtomicFlagClear = Op 319

pattern OpImageSparseRead :: Op
pattern $bOpImageSparseRead :: Op
$mOpImageSparseRead :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpImageSparseRead = Op 320

pattern OpSizeOf :: Op
pattern $bOpSizeOf :: Op
$mOpSizeOf :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpSizeOf = Op 321

pattern OpTypePipeStorage :: Op
pattern $bOpTypePipeStorage :: Op
$mOpTypePipeStorage :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpTypePipeStorage = Op 322

pattern OpConstantPipeStorage :: Op
pattern $bOpConstantPipeStorage :: Op
$mOpConstantPipeStorage :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpConstantPipeStorage = Op 323

pattern OpCreatePipeFromPipeStorage :: Op
pattern $bOpCreatePipeFromPipeStorage :: Op
$mOpCreatePipeFromPipeStorage :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpCreatePipeFromPipeStorage = Op 324

pattern OpGetKernelLocalSizeForSubgroupCount :: Op
pattern $bOpGetKernelLocalSizeForSubgroupCount :: Op
$mOpGetKernelLocalSizeForSubgroupCount :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpGetKernelLocalSizeForSubgroupCount = Op 325

pattern OpGetKernelMaxNumSubgroups :: Op
pattern $bOpGetKernelMaxNumSubgroups :: Op
$mOpGetKernelMaxNumSubgroups :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpGetKernelMaxNumSubgroups = Op 326

pattern OpTypeNamedBarrier :: Op
pattern $bOpTypeNamedBarrier :: Op
$mOpTypeNamedBarrier :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpTypeNamedBarrier = Op 327

pattern OpNamedBarrierInitialize :: Op
pattern $bOpNamedBarrierInitialize :: Op
$mOpNamedBarrierInitialize :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpNamedBarrierInitialize = Op 328

pattern OpMemoryNamedBarrier :: Op
pattern $bOpMemoryNamedBarrier :: Op
$mOpMemoryNamedBarrier :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpMemoryNamedBarrier = Op 329

pattern OpModuleProcessed :: Op
pattern $bOpModuleProcessed :: Op
$mOpModuleProcessed :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpModuleProcessed = Op 330

pattern OpExecutionModeId :: Op
pattern $bOpExecutionModeId :: Op
$mOpExecutionModeId :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpExecutionModeId = Op 331

pattern OpDecorateId :: Op
pattern $bOpDecorateId :: Op
$mOpDecorateId :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpDecorateId = Op 332

pattern OpGroupNonUniformElect :: Op
pattern $bOpGroupNonUniformElect :: Op
$mOpGroupNonUniformElect :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpGroupNonUniformElect = Op 333

pattern OpGroupNonUniformAll :: Op
pattern $bOpGroupNonUniformAll :: Op
$mOpGroupNonUniformAll :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpGroupNonUniformAll = Op 334

pattern OpGroupNonUniformAny :: Op
pattern $bOpGroupNonUniformAny :: Op
$mOpGroupNonUniformAny :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpGroupNonUniformAny = Op 335

pattern OpGroupNonUniformAllEqual :: Op
pattern $bOpGroupNonUniformAllEqual :: Op
$mOpGroupNonUniformAllEqual :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpGroupNonUniformAllEqual = Op 336

pattern OpGroupNonUniformBroadcast :: Op
pattern $bOpGroupNonUniformBroadcast :: Op
$mOpGroupNonUniformBroadcast :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpGroupNonUniformBroadcast = Op 337

pattern OpGroupNonUniformBroadcastFirst :: Op
pattern $bOpGroupNonUniformBroadcastFirst :: Op
$mOpGroupNonUniformBroadcastFirst :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpGroupNonUniformBroadcastFirst = Op 338

pattern OpGroupNonUniformBallot :: Op
pattern $bOpGroupNonUniformBallot :: Op
$mOpGroupNonUniformBallot :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpGroupNonUniformBallot = Op 339

pattern OpGroupNonUniformInverseBallot :: Op
pattern $bOpGroupNonUniformInverseBallot :: Op
$mOpGroupNonUniformInverseBallot :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpGroupNonUniformInverseBallot = Op 340

pattern OpGroupNonUniformBallotBitExtract :: Op
pattern $bOpGroupNonUniformBallotBitExtract :: Op
$mOpGroupNonUniformBallotBitExtract :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpGroupNonUniformBallotBitExtract = Op 341

pattern OpGroupNonUniformBallotBitCount :: Op
pattern $bOpGroupNonUniformBallotBitCount :: Op
$mOpGroupNonUniformBallotBitCount :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpGroupNonUniformBallotBitCount = Op 342

pattern OpGroupNonUniformBallotFindLSB :: Op
pattern $bOpGroupNonUniformBallotFindLSB :: Op
$mOpGroupNonUniformBallotFindLSB :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpGroupNonUniformBallotFindLSB = Op 343

pattern OpGroupNonUniformBallotFindMSB :: Op
pattern $bOpGroupNonUniformBallotFindMSB :: Op
$mOpGroupNonUniformBallotFindMSB :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpGroupNonUniformBallotFindMSB = Op 344

pattern OpGroupNonUniformShuffle :: Op
pattern $bOpGroupNonUniformShuffle :: Op
$mOpGroupNonUniformShuffle :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpGroupNonUniformShuffle = Op 345

pattern OpGroupNonUniformShuffleXor :: Op
pattern $bOpGroupNonUniformShuffleXor :: Op
$mOpGroupNonUniformShuffleXor :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpGroupNonUniformShuffleXor = Op 346

pattern OpGroupNonUniformShuffleUp :: Op
pattern $bOpGroupNonUniformShuffleUp :: Op
$mOpGroupNonUniformShuffleUp :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpGroupNonUniformShuffleUp = Op 347

pattern OpGroupNonUniformShuffleDown :: Op
pattern $bOpGroupNonUniformShuffleDown :: Op
$mOpGroupNonUniformShuffleDown :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpGroupNonUniformShuffleDown = Op 348

pattern OpGroupNonUniformIAdd :: Op
pattern $bOpGroupNonUniformIAdd :: Op
$mOpGroupNonUniformIAdd :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpGroupNonUniformIAdd = Op 349

pattern OpGroupNonUniformFAdd :: Op
pattern $bOpGroupNonUniformFAdd :: Op
$mOpGroupNonUniformFAdd :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpGroupNonUniformFAdd = Op 350

pattern OpGroupNonUniformIMul :: Op
pattern $bOpGroupNonUniformIMul :: Op
$mOpGroupNonUniformIMul :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpGroupNonUniformIMul = Op 351

pattern OpGroupNonUniformFMul :: Op
pattern $bOpGroupNonUniformFMul :: Op
$mOpGroupNonUniformFMul :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpGroupNonUniformFMul = Op 352

pattern OpGroupNonUniformSMin :: Op
pattern $bOpGroupNonUniformSMin :: Op
$mOpGroupNonUniformSMin :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpGroupNonUniformSMin = Op 353

pattern OpGroupNonUniformUMin :: Op
pattern $bOpGroupNonUniformUMin :: Op
$mOpGroupNonUniformUMin :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpGroupNonUniformUMin = Op 354

pattern OpGroupNonUniformFMin :: Op
pattern $bOpGroupNonUniformFMin :: Op
$mOpGroupNonUniformFMin :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpGroupNonUniformFMin = Op 355

pattern OpGroupNonUniformSMax :: Op
pattern $bOpGroupNonUniformSMax :: Op
$mOpGroupNonUniformSMax :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpGroupNonUniformSMax = Op 356

pattern OpGroupNonUniformUMax :: Op
pattern $bOpGroupNonUniformUMax :: Op
$mOpGroupNonUniformUMax :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpGroupNonUniformUMax = Op 357

pattern OpGroupNonUniformFMax :: Op
pattern $bOpGroupNonUniformFMax :: Op
$mOpGroupNonUniformFMax :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpGroupNonUniformFMax = Op 358

pattern OpGroupNonUniformBitwiseAnd :: Op
pattern $bOpGroupNonUniformBitwiseAnd :: Op
$mOpGroupNonUniformBitwiseAnd :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpGroupNonUniformBitwiseAnd = Op 359

pattern OpGroupNonUniformBitwiseOr :: Op
pattern $bOpGroupNonUniformBitwiseOr :: Op
$mOpGroupNonUniformBitwiseOr :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpGroupNonUniformBitwiseOr = Op 360

pattern OpGroupNonUniformBitwiseXor :: Op
pattern $bOpGroupNonUniformBitwiseXor :: Op
$mOpGroupNonUniformBitwiseXor :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpGroupNonUniformBitwiseXor = Op 361

pattern OpGroupNonUniformLogicalAnd :: Op
pattern $bOpGroupNonUniformLogicalAnd :: Op
$mOpGroupNonUniformLogicalAnd :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpGroupNonUniformLogicalAnd = Op 362

pattern OpGroupNonUniformLogicalOr :: Op
pattern $bOpGroupNonUniformLogicalOr :: Op
$mOpGroupNonUniformLogicalOr :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpGroupNonUniformLogicalOr = Op 363

pattern OpGroupNonUniformLogicalXor :: Op
pattern $bOpGroupNonUniformLogicalXor :: Op
$mOpGroupNonUniformLogicalXor :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpGroupNonUniformLogicalXor = Op 364

pattern OpGroupNonUniformQuadBroadcast :: Op
pattern $bOpGroupNonUniformQuadBroadcast :: Op
$mOpGroupNonUniformQuadBroadcast :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpGroupNonUniformQuadBroadcast = Op 365

pattern OpGroupNonUniformQuadSwap :: Op
pattern $bOpGroupNonUniformQuadSwap :: Op
$mOpGroupNonUniformQuadSwap :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpGroupNonUniformQuadSwap = Op 366

pattern OpCopyLogical :: Op
pattern $bOpCopyLogical :: Op
$mOpCopyLogical :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpCopyLogical = Op 400

pattern OpPtrEqual :: Op
pattern $bOpPtrEqual :: Op
$mOpPtrEqual :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpPtrEqual = Op 401

pattern OpPtrNotEqual :: Op
pattern $bOpPtrNotEqual :: Op
$mOpPtrNotEqual :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpPtrNotEqual = Op 402

pattern OpPtrDiff :: Op
pattern $bOpPtrDiff :: Op
$mOpPtrDiff :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpPtrDiff = Op 403

pattern OpTerminateInvocation :: Op
pattern $bOpTerminateInvocation :: Op
$mOpTerminateInvocation :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpTerminateInvocation = Op 4416

pattern OpSubgroupBallotKHR :: Op
pattern $bOpSubgroupBallotKHR :: Op
$mOpSubgroupBallotKHR :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpSubgroupBallotKHR = Op 4421

pattern OpSubgroupFirstInvocationKHR :: Op
pattern $bOpSubgroupFirstInvocationKHR :: Op
$mOpSubgroupFirstInvocationKHR :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpSubgroupFirstInvocationKHR = Op 4422

pattern OpSubgroupAllKHR :: Op
pattern $bOpSubgroupAllKHR :: Op
$mOpSubgroupAllKHR :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpSubgroupAllKHR = Op 4428

pattern OpSubgroupAnyKHR :: Op
pattern $bOpSubgroupAnyKHR :: Op
$mOpSubgroupAnyKHR :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpSubgroupAnyKHR = Op 4429

pattern OpSubgroupAllEqualKHR :: Op
pattern $bOpSubgroupAllEqualKHR :: Op
$mOpSubgroupAllEqualKHR :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpSubgroupAllEqualKHR = Op 4430

pattern OpGroupNonUniformRotateKHR :: Op
pattern $bOpGroupNonUniformRotateKHR :: Op
$mOpGroupNonUniformRotateKHR :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpGroupNonUniformRotateKHR = Op 4431

pattern OpSubgroupReadInvocationKHR :: Op
pattern $bOpSubgroupReadInvocationKHR :: Op
$mOpSubgroupReadInvocationKHR :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpSubgroupReadInvocationKHR = Op 4432

pattern OpTraceRayKHR :: Op
pattern $bOpTraceRayKHR :: Op
$mOpTraceRayKHR :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpTraceRayKHR = Op 4445

pattern OpExecuteCallableKHR :: Op
pattern $bOpExecuteCallableKHR :: Op
$mOpExecuteCallableKHR :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpExecuteCallableKHR = Op 4446

pattern OpConvertUToAccelerationStructureKHR :: Op
pattern $bOpConvertUToAccelerationStructureKHR :: Op
$mOpConvertUToAccelerationStructureKHR :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpConvertUToAccelerationStructureKHR = Op 4447

pattern OpIgnoreIntersectionKHR :: Op
pattern $bOpIgnoreIntersectionKHR :: Op
$mOpIgnoreIntersectionKHR :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpIgnoreIntersectionKHR = Op 4448

pattern OpTerminateRayKHR :: Op
pattern $bOpTerminateRayKHR :: Op
$mOpTerminateRayKHR :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpTerminateRayKHR = Op 4449

pattern OpSDot :: Op
pattern $bOpSDot :: Op
$mOpSDot :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpSDot = Op 4450

pattern OpSDotKHR :: Op
pattern $bOpSDotKHR :: Op
$mOpSDotKHR :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpSDotKHR = Op 4450

pattern OpUDot :: Op
pattern $bOpUDot :: Op
$mOpUDot :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpUDot = Op 4451

pattern OpUDotKHR :: Op
pattern $bOpUDotKHR :: Op
$mOpUDotKHR :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpUDotKHR = Op 4451

pattern OpSUDot :: Op
pattern $bOpSUDot :: Op
$mOpSUDot :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpSUDot = Op 4452

pattern OpSUDotKHR :: Op
pattern $bOpSUDotKHR :: Op
$mOpSUDotKHR :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpSUDotKHR = Op 4452

pattern OpSDotAccSat :: Op
pattern $bOpSDotAccSat :: Op
$mOpSDotAccSat :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpSDotAccSat = Op 4453

pattern OpSDotAccSatKHR :: Op
pattern $bOpSDotAccSatKHR :: Op
$mOpSDotAccSatKHR :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpSDotAccSatKHR = Op 4453

pattern OpUDotAccSat :: Op
pattern $bOpUDotAccSat :: Op
$mOpUDotAccSat :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpUDotAccSat = Op 4454

pattern OpUDotAccSatKHR :: Op
pattern $bOpUDotAccSatKHR :: Op
$mOpUDotAccSatKHR :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpUDotAccSatKHR = Op 4454

pattern OpSUDotAccSat :: Op
pattern $bOpSUDotAccSat :: Op
$mOpSUDotAccSat :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpSUDotAccSat = Op 4455

pattern OpSUDotAccSatKHR :: Op
pattern $bOpSUDotAccSatKHR :: Op
$mOpSUDotAccSatKHR :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpSUDotAccSatKHR = Op 4455

pattern OpTypeRayQueryKHR :: Op
pattern $bOpTypeRayQueryKHR :: Op
$mOpTypeRayQueryKHR :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpTypeRayQueryKHR = Op 4472

pattern OpRayQueryInitializeKHR :: Op
pattern $bOpRayQueryInitializeKHR :: Op
$mOpRayQueryInitializeKHR :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpRayQueryInitializeKHR = Op 4473

pattern OpRayQueryTerminateKHR :: Op
pattern $bOpRayQueryTerminateKHR :: Op
$mOpRayQueryTerminateKHR :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpRayQueryTerminateKHR = Op 4474

pattern OpRayQueryGenerateIntersectionKHR :: Op
pattern $bOpRayQueryGenerateIntersectionKHR :: Op
$mOpRayQueryGenerateIntersectionKHR :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpRayQueryGenerateIntersectionKHR = Op 4475

pattern OpRayQueryConfirmIntersectionKHR :: Op
pattern $bOpRayQueryConfirmIntersectionKHR :: Op
$mOpRayQueryConfirmIntersectionKHR :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpRayQueryConfirmIntersectionKHR = Op 4476

pattern OpRayQueryProceedKHR :: Op
pattern $bOpRayQueryProceedKHR :: Op
$mOpRayQueryProceedKHR :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpRayQueryProceedKHR = Op 4477

pattern OpRayQueryGetIntersectionTypeKHR :: Op
pattern $bOpRayQueryGetIntersectionTypeKHR :: Op
$mOpRayQueryGetIntersectionTypeKHR :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpRayQueryGetIntersectionTypeKHR = Op 4479

pattern OpGroupIAddNonUniformAMD :: Op
pattern $bOpGroupIAddNonUniformAMD :: Op
$mOpGroupIAddNonUniformAMD :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpGroupIAddNonUniformAMD = Op 5000

pattern OpGroupFAddNonUniformAMD :: Op
pattern $bOpGroupFAddNonUniformAMD :: Op
$mOpGroupFAddNonUniformAMD :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpGroupFAddNonUniformAMD = Op 5001

pattern OpGroupFMinNonUniformAMD :: Op
pattern $bOpGroupFMinNonUniformAMD :: Op
$mOpGroupFMinNonUniformAMD :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpGroupFMinNonUniformAMD = Op 5002

pattern OpGroupUMinNonUniformAMD :: Op
pattern $bOpGroupUMinNonUniformAMD :: Op
$mOpGroupUMinNonUniformAMD :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpGroupUMinNonUniformAMD = Op 5003

pattern OpGroupSMinNonUniformAMD :: Op
pattern $bOpGroupSMinNonUniformAMD :: Op
$mOpGroupSMinNonUniformAMD :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpGroupSMinNonUniformAMD = Op 5004

pattern OpGroupFMaxNonUniformAMD :: Op
pattern $bOpGroupFMaxNonUniformAMD :: Op
$mOpGroupFMaxNonUniformAMD :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpGroupFMaxNonUniformAMD = Op 5005

pattern OpGroupUMaxNonUniformAMD :: Op
pattern $bOpGroupUMaxNonUniformAMD :: Op
$mOpGroupUMaxNonUniformAMD :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpGroupUMaxNonUniformAMD = Op 5006

pattern OpGroupSMaxNonUniformAMD :: Op
pattern $bOpGroupSMaxNonUniformAMD :: Op
$mOpGroupSMaxNonUniformAMD :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpGroupSMaxNonUniformAMD = Op 5007

pattern OpFragmentMaskFetchAMD :: Op
pattern $bOpFragmentMaskFetchAMD :: Op
$mOpFragmentMaskFetchAMD :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpFragmentMaskFetchAMD = Op 5011

pattern OpFragmentFetchAMD :: Op
pattern $bOpFragmentFetchAMD :: Op
$mOpFragmentFetchAMD :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpFragmentFetchAMD = Op 5012

pattern OpReadClockKHR :: Op
pattern $bOpReadClockKHR :: Op
$mOpReadClockKHR :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpReadClockKHR = Op 5056

pattern OpHitObjectRecordHitMotionNV :: Op
pattern $bOpHitObjectRecordHitMotionNV :: Op
$mOpHitObjectRecordHitMotionNV :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpHitObjectRecordHitMotionNV = Op 5249

pattern OpHitObjectRecordHitWithIndexMotionNV :: Op
pattern $bOpHitObjectRecordHitWithIndexMotionNV :: Op
$mOpHitObjectRecordHitWithIndexMotionNV :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpHitObjectRecordHitWithIndexMotionNV = Op 5250

pattern OpHitObjectRecordMissMotionNV :: Op
pattern $bOpHitObjectRecordMissMotionNV :: Op
$mOpHitObjectRecordMissMotionNV :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpHitObjectRecordMissMotionNV = Op 5251

pattern OpHitObjectGetWorldToObjectNV :: Op
pattern $bOpHitObjectGetWorldToObjectNV :: Op
$mOpHitObjectGetWorldToObjectNV :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpHitObjectGetWorldToObjectNV = Op 5252

pattern OpHitObjectGetObjectToWorldNV :: Op
pattern $bOpHitObjectGetObjectToWorldNV :: Op
$mOpHitObjectGetObjectToWorldNV :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpHitObjectGetObjectToWorldNV = Op 5253

pattern OpHitObjectGetObjectRayDirectionNV :: Op
pattern $bOpHitObjectGetObjectRayDirectionNV :: Op
$mOpHitObjectGetObjectRayDirectionNV :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpHitObjectGetObjectRayDirectionNV = Op 5254

pattern OpHitObjectGetObjectRayOriginNV :: Op
pattern $bOpHitObjectGetObjectRayOriginNV :: Op
$mOpHitObjectGetObjectRayOriginNV :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpHitObjectGetObjectRayOriginNV = Op 5255

pattern OpHitObjectTraceRayMotionNV :: Op
pattern $bOpHitObjectTraceRayMotionNV :: Op
$mOpHitObjectTraceRayMotionNV :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpHitObjectTraceRayMotionNV = Op 5256

pattern OpHitObjectGetShaderRecordBufferHandleNV :: Op
pattern $bOpHitObjectGetShaderRecordBufferHandleNV :: Op
$mOpHitObjectGetShaderRecordBufferHandleNV :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpHitObjectGetShaderRecordBufferHandleNV = Op 5257

pattern OpHitObjectGetShaderBindingTableRecordIndexNV :: Op
pattern $bOpHitObjectGetShaderBindingTableRecordIndexNV :: Op
$mOpHitObjectGetShaderBindingTableRecordIndexNV :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpHitObjectGetShaderBindingTableRecordIndexNV = Op 5258

pattern OpHitObjectRecordEmptyNV :: Op
pattern $bOpHitObjectRecordEmptyNV :: Op
$mOpHitObjectRecordEmptyNV :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpHitObjectRecordEmptyNV = Op 5259

pattern OpHitObjectTraceRayNV :: Op
pattern $bOpHitObjectTraceRayNV :: Op
$mOpHitObjectTraceRayNV :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpHitObjectTraceRayNV = Op 5260

pattern OpHitObjectRecordHitNV :: Op
pattern $bOpHitObjectRecordHitNV :: Op
$mOpHitObjectRecordHitNV :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpHitObjectRecordHitNV = Op 5261

pattern OpHitObjectRecordHitWithIndexNV :: Op
pattern $bOpHitObjectRecordHitWithIndexNV :: Op
$mOpHitObjectRecordHitWithIndexNV :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpHitObjectRecordHitWithIndexNV = Op 5262

pattern OpHitObjectRecordMissNV :: Op
pattern $bOpHitObjectRecordMissNV :: Op
$mOpHitObjectRecordMissNV :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpHitObjectRecordMissNV = Op 5263

pattern OpHitObjectExecuteShaderNV :: Op
pattern $bOpHitObjectExecuteShaderNV :: Op
$mOpHitObjectExecuteShaderNV :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpHitObjectExecuteShaderNV = Op 5264

pattern OpHitObjectGetCurrentTimeNV :: Op
pattern $bOpHitObjectGetCurrentTimeNV :: Op
$mOpHitObjectGetCurrentTimeNV :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpHitObjectGetCurrentTimeNV = Op 5265

pattern OpHitObjectGetAttributesNV :: Op
pattern $bOpHitObjectGetAttributesNV :: Op
$mOpHitObjectGetAttributesNV :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpHitObjectGetAttributesNV = Op 5266

pattern OpHitObjectGetHitKindNV :: Op
pattern $bOpHitObjectGetHitKindNV :: Op
$mOpHitObjectGetHitKindNV :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpHitObjectGetHitKindNV = Op 5267

pattern OpHitObjectGetPrimitiveIndexNV :: Op
pattern $bOpHitObjectGetPrimitiveIndexNV :: Op
$mOpHitObjectGetPrimitiveIndexNV :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpHitObjectGetPrimitiveIndexNV = Op 5268

pattern OpHitObjectGetGeometryIndexNV :: Op
pattern $bOpHitObjectGetGeometryIndexNV :: Op
$mOpHitObjectGetGeometryIndexNV :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpHitObjectGetGeometryIndexNV = Op 5269

pattern OpHitObjectGetInstanceIdNV :: Op
pattern $bOpHitObjectGetInstanceIdNV :: Op
$mOpHitObjectGetInstanceIdNV :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpHitObjectGetInstanceIdNV = Op 5270

pattern OpHitObjectGetInstanceCustomIndexNV :: Op
pattern $bOpHitObjectGetInstanceCustomIndexNV :: Op
$mOpHitObjectGetInstanceCustomIndexNV :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpHitObjectGetInstanceCustomIndexNV = Op 5271

pattern OpHitObjectGetWorldRayDirectionNV :: Op
pattern $bOpHitObjectGetWorldRayDirectionNV :: Op
$mOpHitObjectGetWorldRayDirectionNV :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpHitObjectGetWorldRayDirectionNV = Op 5272

pattern OpHitObjectGetWorldRayOriginNV :: Op
pattern $bOpHitObjectGetWorldRayOriginNV :: Op
$mOpHitObjectGetWorldRayOriginNV :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpHitObjectGetWorldRayOriginNV = Op 5273

pattern OpHitObjectGetRayTMaxNV :: Op
pattern $bOpHitObjectGetRayTMaxNV :: Op
$mOpHitObjectGetRayTMaxNV :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpHitObjectGetRayTMaxNV = Op 5274

pattern OpHitObjectGetRayTMinNV :: Op
pattern $bOpHitObjectGetRayTMinNV :: Op
$mOpHitObjectGetRayTMinNV :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpHitObjectGetRayTMinNV = Op 5275

pattern OpHitObjectIsEmptyNV :: Op
pattern $bOpHitObjectIsEmptyNV :: Op
$mOpHitObjectIsEmptyNV :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpHitObjectIsEmptyNV = Op 5276

pattern OpHitObjectIsHitNV :: Op
pattern $bOpHitObjectIsHitNV :: Op
$mOpHitObjectIsHitNV :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpHitObjectIsHitNV = Op 5277

pattern OpHitObjectIsMissNV :: Op
pattern $bOpHitObjectIsMissNV :: Op
$mOpHitObjectIsMissNV :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpHitObjectIsMissNV = Op 5278

pattern OpReorderThreadWithHitObjectNV :: Op
pattern $bOpReorderThreadWithHitObjectNV :: Op
$mOpReorderThreadWithHitObjectNV :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpReorderThreadWithHitObjectNV = Op 5279

pattern OpReorderThreadWithHintNV :: Op
pattern $bOpReorderThreadWithHintNV :: Op
$mOpReorderThreadWithHintNV :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpReorderThreadWithHintNV = Op 5280

pattern OpTypeHitObjectNV :: Op
pattern $bOpTypeHitObjectNV :: Op
$mOpTypeHitObjectNV :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpTypeHitObjectNV = Op 5281

pattern OpImageSampleFootprintNV :: Op
pattern $bOpImageSampleFootprintNV :: Op
$mOpImageSampleFootprintNV :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpImageSampleFootprintNV = Op 5283

pattern OpEmitMeshTasksEXT :: Op
pattern $bOpEmitMeshTasksEXT :: Op
$mOpEmitMeshTasksEXT :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpEmitMeshTasksEXT = Op 5294

pattern OpSetMeshOutputsEXT :: Op
pattern $bOpSetMeshOutputsEXT :: Op
$mOpSetMeshOutputsEXT :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpSetMeshOutputsEXT = Op 5295

pattern OpGroupNonUniformPartitionNV :: Op
pattern $bOpGroupNonUniformPartitionNV :: Op
$mOpGroupNonUniformPartitionNV :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpGroupNonUniformPartitionNV = Op 5296

pattern OpWritePackedPrimitiveIndices4x8NV :: Op
pattern $bOpWritePackedPrimitiveIndices4x8NV :: Op
$mOpWritePackedPrimitiveIndices4x8NV :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpWritePackedPrimitiveIndices4x8NV = Op 5299

pattern OpReportIntersectionKHR :: Op
pattern $bOpReportIntersectionKHR :: Op
$mOpReportIntersectionKHR :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpReportIntersectionKHR = Op 5334

pattern OpReportIntersectionNV :: Op
pattern $bOpReportIntersectionNV :: Op
$mOpReportIntersectionNV :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpReportIntersectionNV = Op 5334

pattern OpIgnoreIntersectionNV :: Op
pattern $bOpIgnoreIntersectionNV :: Op
$mOpIgnoreIntersectionNV :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpIgnoreIntersectionNV = Op 5335

pattern OpTerminateRayNV :: Op
pattern $bOpTerminateRayNV :: Op
$mOpTerminateRayNV :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpTerminateRayNV = Op 5336

pattern OpTraceNV :: Op
pattern $bOpTraceNV :: Op
$mOpTraceNV :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpTraceNV = Op 5337

pattern OpTraceMotionNV :: Op
pattern $bOpTraceMotionNV :: Op
$mOpTraceMotionNV :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpTraceMotionNV = Op 5338

pattern OpTraceRayMotionNV :: Op
pattern $bOpTraceRayMotionNV :: Op
$mOpTraceRayMotionNV :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpTraceRayMotionNV = Op 5339

pattern OpTypeAccelerationStructureKHR :: Op
pattern $bOpTypeAccelerationStructureKHR :: Op
$mOpTypeAccelerationStructureKHR :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpTypeAccelerationStructureKHR = Op 5341

pattern OpTypeAccelerationStructureNV :: Op
pattern $bOpTypeAccelerationStructureNV :: Op
$mOpTypeAccelerationStructureNV :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpTypeAccelerationStructureNV = Op 5341

pattern OpExecuteCallableNV :: Op
pattern $bOpExecuteCallableNV :: Op
$mOpExecuteCallableNV :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpExecuteCallableNV = Op 5344

pattern OpTypeCooperativeMatrixNV :: Op
pattern $bOpTypeCooperativeMatrixNV :: Op
$mOpTypeCooperativeMatrixNV :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpTypeCooperativeMatrixNV = Op 5358

pattern OpCooperativeMatrixLoadNV :: Op
pattern $bOpCooperativeMatrixLoadNV :: Op
$mOpCooperativeMatrixLoadNV :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpCooperativeMatrixLoadNV = Op 5359

pattern OpCooperativeMatrixStoreNV :: Op
pattern $bOpCooperativeMatrixStoreNV :: Op
$mOpCooperativeMatrixStoreNV :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpCooperativeMatrixStoreNV = Op 5360

pattern OpCooperativeMatrixMulAddNV :: Op
pattern $bOpCooperativeMatrixMulAddNV :: Op
$mOpCooperativeMatrixMulAddNV :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpCooperativeMatrixMulAddNV = Op 5361

pattern OpCooperativeMatrixLengthNV :: Op
pattern $bOpCooperativeMatrixLengthNV :: Op
$mOpCooperativeMatrixLengthNV :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpCooperativeMatrixLengthNV = Op 5362

pattern OpBeginInvocationInterlockEXT :: Op
pattern $bOpBeginInvocationInterlockEXT :: Op
$mOpBeginInvocationInterlockEXT :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpBeginInvocationInterlockEXT = Op 5364

pattern OpEndInvocationInterlockEXT :: Op
pattern $bOpEndInvocationInterlockEXT :: Op
$mOpEndInvocationInterlockEXT :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpEndInvocationInterlockEXT = Op 5365

pattern OpDemoteToHelperInvocation :: Op
pattern $bOpDemoteToHelperInvocation :: Op
$mOpDemoteToHelperInvocation :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpDemoteToHelperInvocation = Op 5380

pattern OpDemoteToHelperInvocationEXT :: Op
pattern $bOpDemoteToHelperInvocationEXT :: Op
$mOpDemoteToHelperInvocationEXT :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpDemoteToHelperInvocationEXT = Op 5380

pattern OpIsHelperInvocationEXT :: Op
pattern $bOpIsHelperInvocationEXT :: Op
$mOpIsHelperInvocationEXT :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpIsHelperInvocationEXT = Op 5381

pattern OpConvertUToImageNV :: Op
pattern $bOpConvertUToImageNV :: Op
$mOpConvertUToImageNV :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpConvertUToImageNV = Op 5391

pattern OpConvertUToSamplerNV :: Op
pattern $bOpConvertUToSamplerNV :: Op
$mOpConvertUToSamplerNV :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpConvertUToSamplerNV = Op 5392

pattern OpConvertImageToUNV :: Op
pattern $bOpConvertImageToUNV :: Op
$mOpConvertImageToUNV :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpConvertImageToUNV = Op 5393

pattern OpConvertSamplerToUNV :: Op
pattern $bOpConvertSamplerToUNV :: Op
$mOpConvertSamplerToUNV :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpConvertSamplerToUNV = Op 5394

pattern OpConvertUToSampledImageNV :: Op
pattern $bOpConvertUToSampledImageNV :: Op
$mOpConvertUToSampledImageNV :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpConvertUToSampledImageNV = Op 5395

pattern OpConvertSampledImageToUNV :: Op
pattern $bOpConvertSampledImageToUNV :: Op
$mOpConvertSampledImageToUNV :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpConvertSampledImageToUNV = Op 5396

pattern OpSamplerImageAddressingModeNV :: Op
pattern $bOpSamplerImageAddressingModeNV :: Op
$mOpSamplerImageAddressingModeNV :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpSamplerImageAddressingModeNV = Op 5397

pattern OpSubgroupShuffleINTEL :: Op
pattern $bOpSubgroupShuffleINTEL :: Op
$mOpSubgroupShuffleINTEL :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpSubgroupShuffleINTEL = Op 5571

pattern OpSubgroupShuffleDownINTEL :: Op
pattern $bOpSubgroupShuffleDownINTEL :: Op
$mOpSubgroupShuffleDownINTEL :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpSubgroupShuffleDownINTEL = Op 5572

pattern OpSubgroupShuffleUpINTEL :: Op
pattern $bOpSubgroupShuffleUpINTEL :: Op
$mOpSubgroupShuffleUpINTEL :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpSubgroupShuffleUpINTEL = Op 5573

pattern OpSubgroupShuffleXorINTEL :: Op
pattern $bOpSubgroupShuffleXorINTEL :: Op
$mOpSubgroupShuffleXorINTEL :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpSubgroupShuffleXorINTEL = Op 5574

pattern OpSubgroupBlockReadINTEL :: Op
pattern $bOpSubgroupBlockReadINTEL :: Op
$mOpSubgroupBlockReadINTEL :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpSubgroupBlockReadINTEL = Op 5575

pattern OpSubgroupBlockWriteINTEL :: Op
pattern $bOpSubgroupBlockWriteINTEL :: Op
$mOpSubgroupBlockWriteINTEL :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpSubgroupBlockWriteINTEL = Op 5576

pattern OpSubgroupImageBlockReadINTEL :: Op
pattern $bOpSubgroupImageBlockReadINTEL :: Op
$mOpSubgroupImageBlockReadINTEL :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpSubgroupImageBlockReadINTEL = Op 5577

pattern OpSubgroupImageBlockWriteINTEL :: Op
pattern $bOpSubgroupImageBlockWriteINTEL :: Op
$mOpSubgroupImageBlockWriteINTEL :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpSubgroupImageBlockWriteINTEL = Op 5578

pattern OpSubgroupImageMediaBlockReadINTEL :: Op
pattern $bOpSubgroupImageMediaBlockReadINTEL :: Op
$mOpSubgroupImageMediaBlockReadINTEL :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpSubgroupImageMediaBlockReadINTEL = Op 5580

pattern OpSubgroupImageMediaBlockWriteINTEL :: Op
pattern $bOpSubgroupImageMediaBlockWriteINTEL :: Op
$mOpSubgroupImageMediaBlockWriteINTEL :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpSubgroupImageMediaBlockWriteINTEL = Op 5581

pattern OpUCountLeadingZerosINTEL :: Op
pattern $bOpUCountLeadingZerosINTEL :: Op
$mOpUCountLeadingZerosINTEL :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpUCountLeadingZerosINTEL = Op 5585

pattern OpUCountTrailingZerosINTEL :: Op
pattern $bOpUCountTrailingZerosINTEL :: Op
$mOpUCountTrailingZerosINTEL :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpUCountTrailingZerosINTEL = Op 5586

pattern OpAbsISubINTEL :: Op
pattern $bOpAbsISubINTEL :: Op
$mOpAbsISubINTEL :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpAbsISubINTEL = Op 5587

pattern OpAbsUSubINTEL :: Op
pattern $bOpAbsUSubINTEL :: Op
$mOpAbsUSubINTEL :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpAbsUSubINTEL = Op 5588

pattern OpIAddSatINTEL :: Op
pattern $bOpIAddSatINTEL :: Op
$mOpIAddSatINTEL :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpIAddSatINTEL = Op 5589

pattern OpUAddSatINTEL :: Op
pattern $bOpUAddSatINTEL :: Op
$mOpUAddSatINTEL :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpUAddSatINTEL = Op 5590

pattern OpIAverageINTEL :: Op
pattern $bOpIAverageINTEL :: Op
$mOpIAverageINTEL :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpIAverageINTEL = Op 5591

pattern OpUAverageINTEL :: Op
pattern $bOpUAverageINTEL :: Op
$mOpUAverageINTEL :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpUAverageINTEL = Op 5592

pattern OpIAverageRoundedINTEL :: Op
pattern $bOpIAverageRoundedINTEL :: Op
$mOpIAverageRoundedINTEL :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpIAverageRoundedINTEL = Op 5593

pattern OpUAverageRoundedINTEL :: Op
pattern $bOpUAverageRoundedINTEL :: Op
$mOpUAverageRoundedINTEL :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpUAverageRoundedINTEL = Op 5594

pattern OpISubSatINTEL :: Op
pattern $bOpISubSatINTEL :: Op
$mOpISubSatINTEL :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpISubSatINTEL = Op 5595

pattern OpUSubSatINTEL :: Op
pattern $bOpUSubSatINTEL :: Op
$mOpUSubSatINTEL :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpUSubSatINTEL = Op 5596

pattern OpIMul32x16INTEL :: Op
pattern $bOpIMul32x16INTEL :: Op
$mOpIMul32x16INTEL :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpIMul32x16INTEL = Op 5597

pattern OpUMul32x16INTEL :: Op
pattern $bOpUMul32x16INTEL :: Op
$mOpUMul32x16INTEL :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpUMul32x16INTEL = Op 5598

pattern OpConstantFunctionPointerINTEL :: Op
pattern $bOpConstantFunctionPointerINTEL :: Op
$mOpConstantFunctionPointerINTEL :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpConstantFunctionPointerINTEL = Op 5600

pattern OpFunctionPointerCallINTEL :: Op
pattern $bOpFunctionPointerCallINTEL :: Op
$mOpFunctionPointerCallINTEL :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpFunctionPointerCallINTEL = Op 5601

pattern OpAsmTargetINTEL :: Op
pattern $bOpAsmTargetINTEL :: Op
$mOpAsmTargetINTEL :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpAsmTargetINTEL = Op 5609

pattern OpAsmINTEL :: Op
pattern $bOpAsmINTEL :: Op
$mOpAsmINTEL :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpAsmINTEL = Op 5610

pattern OpAsmCallINTEL :: Op
pattern $bOpAsmCallINTEL :: Op
$mOpAsmCallINTEL :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpAsmCallINTEL = Op 5611

pattern OpAtomicFMinEXT :: Op
pattern $bOpAtomicFMinEXT :: Op
$mOpAtomicFMinEXT :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpAtomicFMinEXT = Op 5614

pattern OpAtomicFMaxEXT :: Op
pattern $bOpAtomicFMaxEXT :: Op
$mOpAtomicFMaxEXT :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpAtomicFMaxEXT = Op 5615

pattern OpAssumeTrueKHR :: Op
pattern $bOpAssumeTrueKHR :: Op
$mOpAssumeTrueKHR :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpAssumeTrueKHR = Op 5630

pattern OpExpectKHR :: Op
pattern $bOpExpectKHR :: Op
$mOpExpectKHR :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpExpectKHR = Op 5631

pattern OpDecorateString :: Op
pattern $bOpDecorateString :: Op
$mOpDecorateString :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpDecorateString = Op 5632

pattern OpDecorateStringGOOGLE :: Op
pattern $bOpDecorateStringGOOGLE :: Op
$mOpDecorateStringGOOGLE :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpDecorateStringGOOGLE = Op 5632

pattern OpMemberDecorateString :: Op
pattern $bOpMemberDecorateString :: Op
$mOpMemberDecorateString :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpMemberDecorateString = Op 5633

pattern OpMemberDecorateStringGOOGLE :: Op
pattern $bOpMemberDecorateStringGOOGLE :: Op
$mOpMemberDecorateStringGOOGLE :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpMemberDecorateStringGOOGLE = Op 5633

pattern OpVmeImageINTEL :: Op
pattern $bOpVmeImageINTEL :: Op
$mOpVmeImageINTEL :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpVmeImageINTEL = Op 5699

pattern OpTypeVmeImageINTEL :: Op
pattern $bOpTypeVmeImageINTEL :: Op
$mOpTypeVmeImageINTEL :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpTypeVmeImageINTEL = Op 5700

pattern OpTypeAvcImePayloadINTEL :: Op
pattern $bOpTypeAvcImePayloadINTEL :: Op
$mOpTypeAvcImePayloadINTEL :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpTypeAvcImePayloadINTEL = Op 5701

pattern OpTypeAvcRefPayloadINTEL :: Op
pattern $bOpTypeAvcRefPayloadINTEL :: Op
$mOpTypeAvcRefPayloadINTEL :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpTypeAvcRefPayloadINTEL = Op 5702

pattern OpTypeAvcSicPayloadINTEL :: Op
pattern $bOpTypeAvcSicPayloadINTEL :: Op
$mOpTypeAvcSicPayloadINTEL :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpTypeAvcSicPayloadINTEL = Op 5703

pattern OpTypeAvcMcePayloadINTEL :: Op
pattern $bOpTypeAvcMcePayloadINTEL :: Op
$mOpTypeAvcMcePayloadINTEL :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpTypeAvcMcePayloadINTEL = Op 5704

pattern OpTypeAvcMceResultINTEL :: Op
pattern $bOpTypeAvcMceResultINTEL :: Op
$mOpTypeAvcMceResultINTEL :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpTypeAvcMceResultINTEL = Op 5705

pattern OpTypeAvcImeResultINTEL :: Op
pattern $bOpTypeAvcImeResultINTEL :: Op
$mOpTypeAvcImeResultINTEL :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpTypeAvcImeResultINTEL = Op 5706

pattern OpTypeAvcImeResultSingleReferenceStreamoutINTEL :: Op
pattern $bOpTypeAvcImeResultSingleReferenceStreamoutINTEL :: Op
$mOpTypeAvcImeResultSingleReferenceStreamoutINTEL :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpTypeAvcImeResultSingleReferenceStreamoutINTEL = Op 5707

pattern OpTypeAvcImeResultDualReferenceStreamoutINTEL :: Op
pattern $bOpTypeAvcImeResultDualReferenceStreamoutINTEL :: Op
$mOpTypeAvcImeResultDualReferenceStreamoutINTEL :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpTypeAvcImeResultDualReferenceStreamoutINTEL = Op 5708

pattern OpTypeAvcImeSingleReferenceStreaminINTEL :: Op
pattern $bOpTypeAvcImeSingleReferenceStreaminINTEL :: Op
$mOpTypeAvcImeSingleReferenceStreaminINTEL :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpTypeAvcImeSingleReferenceStreaminINTEL = Op 5709

pattern OpTypeAvcImeDualReferenceStreaminINTEL :: Op
pattern $bOpTypeAvcImeDualReferenceStreaminINTEL :: Op
$mOpTypeAvcImeDualReferenceStreaminINTEL :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpTypeAvcImeDualReferenceStreaminINTEL = Op 5710

pattern OpTypeAvcRefResultINTEL :: Op
pattern $bOpTypeAvcRefResultINTEL :: Op
$mOpTypeAvcRefResultINTEL :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpTypeAvcRefResultINTEL = Op 5711

pattern OpTypeAvcSicResultINTEL :: Op
pattern $bOpTypeAvcSicResultINTEL :: Op
$mOpTypeAvcSicResultINTEL :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpTypeAvcSicResultINTEL = Op 5712

pattern OpSubgroupAvcMceGetDefaultInterBaseMultiReferencePenaltyINTEL :: Op
pattern $bOpSubgroupAvcMceGetDefaultInterBaseMultiReferencePenaltyINTEL :: Op
$mOpSubgroupAvcMceGetDefaultInterBaseMultiReferencePenaltyINTEL :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpSubgroupAvcMceGetDefaultInterBaseMultiReferencePenaltyINTEL = Op 5713

pattern OpSubgroupAvcMceSetInterBaseMultiReferencePenaltyINTEL :: Op
pattern $bOpSubgroupAvcMceSetInterBaseMultiReferencePenaltyINTEL :: Op
$mOpSubgroupAvcMceSetInterBaseMultiReferencePenaltyINTEL :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpSubgroupAvcMceSetInterBaseMultiReferencePenaltyINTEL = Op 5714

pattern OpSubgroupAvcMceGetDefaultInterShapePenaltyINTEL :: Op
pattern $bOpSubgroupAvcMceGetDefaultInterShapePenaltyINTEL :: Op
$mOpSubgroupAvcMceGetDefaultInterShapePenaltyINTEL :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpSubgroupAvcMceGetDefaultInterShapePenaltyINTEL = Op 5715

pattern OpSubgroupAvcMceSetInterShapePenaltyINTEL :: Op
pattern $bOpSubgroupAvcMceSetInterShapePenaltyINTEL :: Op
$mOpSubgroupAvcMceSetInterShapePenaltyINTEL :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpSubgroupAvcMceSetInterShapePenaltyINTEL = Op 5716

pattern OpSubgroupAvcMceGetDefaultInterDirectionPenaltyINTEL :: Op
pattern $bOpSubgroupAvcMceGetDefaultInterDirectionPenaltyINTEL :: Op
$mOpSubgroupAvcMceGetDefaultInterDirectionPenaltyINTEL :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpSubgroupAvcMceGetDefaultInterDirectionPenaltyINTEL = Op 5717

pattern OpSubgroupAvcMceSetInterDirectionPenaltyINTEL :: Op
pattern $bOpSubgroupAvcMceSetInterDirectionPenaltyINTEL :: Op
$mOpSubgroupAvcMceSetInterDirectionPenaltyINTEL :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpSubgroupAvcMceSetInterDirectionPenaltyINTEL = Op 5718

pattern OpSubgroupAvcMceGetDefaultIntraLumaShapePenaltyINTEL :: Op
pattern $bOpSubgroupAvcMceGetDefaultIntraLumaShapePenaltyINTEL :: Op
$mOpSubgroupAvcMceGetDefaultIntraLumaShapePenaltyINTEL :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpSubgroupAvcMceGetDefaultIntraLumaShapePenaltyINTEL = Op 5719

pattern OpSubgroupAvcMceGetDefaultInterMotionVectorCostTableINTEL :: Op
pattern $bOpSubgroupAvcMceGetDefaultInterMotionVectorCostTableINTEL :: Op
$mOpSubgroupAvcMceGetDefaultInterMotionVectorCostTableINTEL :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpSubgroupAvcMceGetDefaultInterMotionVectorCostTableINTEL = Op 5720

pattern OpSubgroupAvcMceGetDefaultHighPenaltyCostTableINTEL :: Op
pattern $bOpSubgroupAvcMceGetDefaultHighPenaltyCostTableINTEL :: Op
$mOpSubgroupAvcMceGetDefaultHighPenaltyCostTableINTEL :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpSubgroupAvcMceGetDefaultHighPenaltyCostTableINTEL = Op 5721

pattern OpSubgroupAvcMceGetDefaultMediumPenaltyCostTableINTEL :: Op
pattern $bOpSubgroupAvcMceGetDefaultMediumPenaltyCostTableINTEL :: Op
$mOpSubgroupAvcMceGetDefaultMediumPenaltyCostTableINTEL :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpSubgroupAvcMceGetDefaultMediumPenaltyCostTableINTEL = Op 5722

pattern OpSubgroupAvcMceGetDefaultLowPenaltyCostTableINTEL :: Op
pattern $bOpSubgroupAvcMceGetDefaultLowPenaltyCostTableINTEL :: Op
$mOpSubgroupAvcMceGetDefaultLowPenaltyCostTableINTEL :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpSubgroupAvcMceGetDefaultLowPenaltyCostTableINTEL = Op 5723

pattern OpSubgroupAvcMceSetMotionVectorCostFunctionINTEL :: Op
pattern $bOpSubgroupAvcMceSetMotionVectorCostFunctionINTEL :: Op
$mOpSubgroupAvcMceSetMotionVectorCostFunctionINTEL :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpSubgroupAvcMceSetMotionVectorCostFunctionINTEL = Op 5724

pattern OpSubgroupAvcMceGetDefaultIntraLumaModePenaltyINTEL :: Op
pattern $bOpSubgroupAvcMceGetDefaultIntraLumaModePenaltyINTEL :: Op
$mOpSubgroupAvcMceGetDefaultIntraLumaModePenaltyINTEL :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpSubgroupAvcMceGetDefaultIntraLumaModePenaltyINTEL = Op 5725

pattern OpSubgroupAvcMceGetDefaultNonDcLumaIntraPenaltyINTEL :: Op
pattern $bOpSubgroupAvcMceGetDefaultNonDcLumaIntraPenaltyINTEL :: Op
$mOpSubgroupAvcMceGetDefaultNonDcLumaIntraPenaltyINTEL :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpSubgroupAvcMceGetDefaultNonDcLumaIntraPenaltyINTEL = Op 5726

pattern OpSubgroupAvcMceGetDefaultIntraChromaModeBasePenaltyINTEL :: Op
pattern $bOpSubgroupAvcMceGetDefaultIntraChromaModeBasePenaltyINTEL :: Op
$mOpSubgroupAvcMceGetDefaultIntraChromaModeBasePenaltyINTEL :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpSubgroupAvcMceGetDefaultIntraChromaModeBasePenaltyINTEL = Op 5727

pattern OpSubgroupAvcMceSetAcOnlyHaarINTEL :: Op
pattern $bOpSubgroupAvcMceSetAcOnlyHaarINTEL :: Op
$mOpSubgroupAvcMceSetAcOnlyHaarINTEL :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpSubgroupAvcMceSetAcOnlyHaarINTEL = Op 5728

pattern OpSubgroupAvcMceSetSourceInterlacedFieldPolarityINTEL :: Op
pattern $bOpSubgroupAvcMceSetSourceInterlacedFieldPolarityINTEL :: Op
$mOpSubgroupAvcMceSetSourceInterlacedFieldPolarityINTEL :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpSubgroupAvcMceSetSourceInterlacedFieldPolarityINTEL = Op 5729

pattern OpSubgroupAvcMceSetSingleReferenceInterlacedFieldPolarityINTEL :: Op
pattern $bOpSubgroupAvcMceSetSingleReferenceInterlacedFieldPolarityINTEL :: Op
$mOpSubgroupAvcMceSetSingleReferenceInterlacedFieldPolarityINTEL :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpSubgroupAvcMceSetSingleReferenceInterlacedFieldPolarityINTEL = Op 5730

pattern OpSubgroupAvcMceSetDualReferenceInterlacedFieldPolaritiesINTEL :: Op
pattern $bOpSubgroupAvcMceSetDualReferenceInterlacedFieldPolaritiesINTEL :: Op
$mOpSubgroupAvcMceSetDualReferenceInterlacedFieldPolaritiesINTEL :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpSubgroupAvcMceSetDualReferenceInterlacedFieldPolaritiesINTEL = Op 5731

pattern OpSubgroupAvcMceConvertToImePayloadINTEL :: Op
pattern $bOpSubgroupAvcMceConvertToImePayloadINTEL :: Op
$mOpSubgroupAvcMceConvertToImePayloadINTEL :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpSubgroupAvcMceConvertToImePayloadINTEL = Op 5732

pattern OpSubgroupAvcMceConvertToImeResultINTEL :: Op
pattern $bOpSubgroupAvcMceConvertToImeResultINTEL :: Op
$mOpSubgroupAvcMceConvertToImeResultINTEL :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpSubgroupAvcMceConvertToImeResultINTEL = Op 5733

pattern OpSubgroupAvcMceConvertToRefPayloadINTEL :: Op
pattern $bOpSubgroupAvcMceConvertToRefPayloadINTEL :: Op
$mOpSubgroupAvcMceConvertToRefPayloadINTEL :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpSubgroupAvcMceConvertToRefPayloadINTEL = Op 5734

pattern OpSubgroupAvcMceConvertToRefResultINTEL :: Op
pattern $bOpSubgroupAvcMceConvertToRefResultINTEL :: Op
$mOpSubgroupAvcMceConvertToRefResultINTEL :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpSubgroupAvcMceConvertToRefResultINTEL = Op 5735

pattern OpSubgroupAvcMceConvertToSicPayloadINTEL :: Op
pattern $bOpSubgroupAvcMceConvertToSicPayloadINTEL :: Op
$mOpSubgroupAvcMceConvertToSicPayloadINTEL :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpSubgroupAvcMceConvertToSicPayloadINTEL = Op 5736

pattern OpSubgroupAvcMceConvertToSicResultINTEL :: Op
pattern $bOpSubgroupAvcMceConvertToSicResultINTEL :: Op
$mOpSubgroupAvcMceConvertToSicResultINTEL :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpSubgroupAvcMceConvertToSicResultINTEL = Op 5737

pattern OpSubgroupAvcMceGetMotionVectorsINTEL :: Op
pattern $bOpSubgroupAvcMceGetMotionVectorsINTEL :: Op
$mOpSubgroupAvcMceGetMotionVectorsINTEL :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpSubgroupAvcMceGetMotionVectorsINTEL = Op 5738

pattern OpSubgroupAvcMceGetInterDistortionsINTEL :: Op
pattern $bOpSubgroupAvcMceGetInterDistortionsINTEL :: Op
$mOpSubgroupAvcMceGetInterDistortionsINTEL :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpSubgroupAvcMceGetInterDistortionsINTEL = Op 5739

pattern OpSubgroupAvcMceGetBestInterDistortionsINTEL :: Op
pattern $bOpSubgroupAvcMceGetBestInterDistortionsINTEL :: Op
$mOpSubgroupAvcMceGetBestInterDistortionsINTEL :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpSubgroupAvcMceGetBestInterDistortionsINTEL = Op 5740

pattern OpSubgroupAvcMceGetInterMajorShapeINTEL :: Op
pattern $bOpSubgroupAvcMceGetInterMajorShapeINTEL :: Op
$mOpSubgroupAvcMceGetInterMajorShapeINTEL :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpSubgroupAvcMceGetInterMajorShapeINTEL = Op 5741

pattern OpSubgroupAvcMceGetInterMinorShapeINTEL :: Op
pattern $bOpSubgroupAvcMceGetInterMinorShapeINTEL :: Op
$mOpSubgroupAvcMceGetInterMinorShapeINTEL :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpSubgroupAvcMceGetInterMinorShapeINTEL = Op 5742

pattern OpSubgroupAvcMceGetInterDirectionsINTEL :: Op
pattern $bOpSubgroupAvcMceGetInterDirectionsINTEL :: Op
$mOpSubgroupAvcMceGetInterDirectionsINTEL :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpSubgroupAvcMceGetInterDirectionsINTEL = Op 5743

pattern OpSubgroupAvcMceGetInterMotionVectorCountINTEL :: Op
pattern $bOpSubgroupAvcMceGetInterMotionVectorCountINTEL :: Op
$mOpSubgroupAvcMceGetInterMotionVectorCountINTEL :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpSubgroupAvcMceGetInterMotionVectorCountINTEL = Op 5744

pattern OpSubgroupAvcMceGetInterReferenceIdsINTEL :: Op
pattern $bOpSubgroupAvcMceGetInterReferenceIdsINTEL :: Op
$mOpSubgroupAvcMceGetInterReferenceIdsINTEL :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpSubgroupAvcMceGetInterReferenceIdsINTEL = Op 5745

pattern OpSubgroupAvcMceGetInterReferenceInterlacedFieldPolaritiesINTEL :: Op
pattern $bOpSubgroupAvcMceGetInterReferenceInterlacedFieldPolaritiesINTEL :: Op
$mOpSubgroupAvcMceGetInterReferenceInterlacedFieldPolaritiesINTEL :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpSubgroupAvcMceGetInterReferenceInterlacedFieldPolaritiesINTEL = Op 5746

pattern OpSubgroupAvcImeInitializeINTEL :: Op
pattern $bOpSubgroupAvcImeInitializeINTEL :: Op
$mOpSubgroupAvcImeInitializeINTEL :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpSubgroupAvcImeInitializeINTEL = Op 5747

pattern OpSubgroupAvcImeSetSingleReferenceINTEL :: Op
pattern $bOpSubgroupAvcImeSetSingleReferenceINTEL :: Op
$mOpSubgroupAvcImeSetSingleReferenceINTEL :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpSubgroupAvcImeSetSingleReferenceINTEL = Op 5748

pattern OpSubgroupAvcImeSetDualReferenceINTEL :: Op
pattern $bOpSubgroupAvcImeSetDualReferenceINTEL :: Op
$mOpSubgroupAvcImeSetDualReferenceINTEL :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpSubgroupAvcImeSetDualReferenceINTEL = Op 5749

pattern OpSubgroupAvcImeRefWindowSizeINTEL :: Op
pattern $bOpSubgroupAvcImeRefWindowSizeINTEL :: Op
$mOpSubgroupAvcImeRefWindowSizeINTEL :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpSubgroupAvcImeRefWindowSizeINTEL = Op 5750

pattern OpSubgroupAvcImeAdjustRefOffsetINTEL :: Op
pattern $bOpSubgroupAvcImeAdjustRefOffsetINTEL :: Op
$mOpSubgroupAvcImeAdjustRefOffsetINTEL :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpSubgroupAvcImeAdjustRefOffsetINTEL = Op 5751

pattern OpSubgroupAvcImeConvertToMcePayloadINTEL :: Op
pattern $bOpSubgroupAvcImeConvertToMcePayloadINTEL :: Op
$mOpSubgroupAvcImeConvertToMcePayloadINTEL :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpSubgroupAvcImeConvertToMcePayloadINTEL = Op 5752

pattern OpSubgroupAvcImeSetMaxMotionVectorCountINTEL :: Op
pattern $bOpSubgroupAvcImeSetMaxMotionVectorCountINTEL :: Op
$mOpSubgroupAvcImeSetMaxMotionVectorCountINTEL :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpSubgroupAvcImeSetMaxMotionVectorCountINTEL = Op 5753

pattern OpSubgroupAvcImeSetUnidirectionalMixDisableINTEL :: Op
pattern $bOpSubgroupAvcImeSetUnidirectionalMixDisableINTEL :: Op
$mOpSubgroupAvcImeSetUnidirectionalMixDisableINTEL :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpSubgroupAvcImeSetUnidirectionalMixDisableINTEL = Op 5754

pattern OpSubgroupAvcImeSetEarlySearchTerminationThresholdINTEL :: Op
pattern $bOpSubgroupAvcImeSetEarlySearchTerminationThresholdINTEL :: Op
$mOpSubgroupAvcImeSetEarlySearchTerminationThresholdINTEL :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpSubgroupAvcImeSetEarlySearchTerminationThresholdINTEL = Op 5755

pattern OpSubgroupAvcImeSetWeightedSadINTEL :: Op
pattern $bOpSubgroupAvcImeSetWeightedSadINTEL :: Op
$mOpSubgroupAvcImeSetWeightedSadINTEL :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpSubgroupAvcImeSetWeightedSadINTEL = Op 5756

pattern OpSubgroupAvcImeEvaluateWithSingleReferenceINTEL :: Op
pattern $bOpSubgroupAvcImeEvaluateWithSingleReferenceINTEL :: Op
$mOpSubgroupAvcImeEvaluateWithSingleReferenceINTEL :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpSubgroupAvcImeEvaluateWithSingleReferenceINTEL = Op 5757

pattern OpSubgroupAvcImeEvaluateWithDualReferenceINTEL :: Op
pattern $bOpSubgroupAvcImeEvaluateWithDualReferenceINTEL :: Op
$mOpSubgroupAvcImeEvaluateWithDualReferenceINTEL :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpSubgroupAvcImeEvaluateWithDualReferenceINTEL = Op 5758

pattern OpSubgroupAvcImeEvaluateWithSingleReferenceStreaminINTEL :: Op
pattern $bOpSubgroupAvcImeEvaluateWithSingleReferenceStreaminINTEL :: Op
$mOpSubgroupAvcImeEvaluateWithSingleReferenceStreaminINTEL :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpSubgroupAvcImeEvaluateWithSingleReferenceStreaminINTEL = Op 5759

pattern OpSubgroupAvcImeEvaluateWithDualReferenceStreaminINTEL :: Op
pattern $bOpSubgroupAvcImeEvaluateWithDualReferenceStreaminINTEL :: Op
$mOpSubgroupAvcImeEvaluateWithDualReferenceStreaminINTEL :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpSubgroupAvcImeEvaluateWithDualReferenceStreaminINTEL = Op 5760

pattern OpSubgroupAvcImeEvaluateWithSingleReferenceStreamoutINTEL :: Op
pattern $bOpSubgroupAvcImeEvaluateWithSingleReferenceStreamoutINTEL :: Op
$mOpSubgroupAvcImeEvaluateWithSingleReferenceStreamoutINTEL :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpSubgroupAvcImeEvaluateWithSingleReferenceStreamoutINTEL = Op 5761

pattern OpSubgroupAvcImeEvaluateWithDualReferenceStreamoutINTEL :: Op
pattern $bOpSubgroupAvcImeEvaluateWithDualReferenceStreamoutINTEL :: Op
$mOpSubgroupAvcImeEvaluateWithDualReferenceStreamoutINTEL :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpSubgroupAvcImeEvaluateWithDualReferenceStreamoutINTEL = Op 5762

pattern OpSubgroupAvcImeEvaluateWithSingleReferenceStreaminoutINTEL :: Op
pattern $bOpSubgroupAvcImeEvaluateWithSingleReferenceStreaminoutINTEL :: Op
$mOpSubgroupAvcImeEvaluateWithSingleReferenceStreaminoutINTEL :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpSubgroupAvcImeEvaluateWithSingleReferenceStreaminoutINTEL = Op 5763

pattern OpSubgroupAvcImeEvaluateWithDualReferenceStreaminoutINTEL :: Op
pattern $bOpSubgroupAvcImeEvaluateWithDualReferenceStreaminoutINTEL :: Op
$mOpSubgroupAvcImeEvaluateWithDualReferenceStreaminoutINTEL :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpSubgroupAvcImeEvaluateWithDualReferenceStreaminoutINTEL = Op 5764

pattern OpSubgroupAvcImeConvertToMceResultINTEL :: Op
pattern $bOpSubgroupAvcImeConvertToMceResultINTEL :: Op
$mOpSubgroupAvcImeConvertToMceResultINTEL :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpSubgroupAvcImeConvertToMceResultINTEL = Op 5765

pattern OpSubgroupAvcImeGetSingleReferenceStreaminINTEL :: Op
pattern $bOpSubgroupAvcImeGetSingleReferenceStreaminINTEL :: Op
$mOpSubgroupAvcImeGetSingleReferenceStreaminINTEL :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpSubgroupAvcImeGetSingleReferenceStreaminINTEL = Op 5766

pattern OpSubgroupAvcImeGetDualReferenceStreaminINTEL :: Op
pattern $bOpSubgroupAvcImeGetDualReferenceStreaminINTEL :: Op
$mOpSubgroupAvcImeGetDualReferenceStreaminINTEL :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpSubgroupAvcImeGetDualReferenceStreaminINTEL = Op 5767

pattern OpSubgroupAvcImeStripSingleReferenceStreamoutINTEL :: Op
pattern $bOpSubgroupAvcImeStripSingleReferenceStreamoutINTEL :: Op
$mOpSubgroupAvcImeStripSingleReferenceStreamoutINTEL :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpSubgroupAvcImeStripSingleReferenceStreamoutINTEL = Op 5768

pattern OpSubgroupAvcImeStripDualReferenceStreamoutINTEL :: Op
pattern $bOpSubgroupAvcImeStripDualReferenceStreamoutINTEL :: Op
$mOpSubgroupAvcImeStripDualReferenceStreamoutINTEL :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpSubgroupAvcImeStripDualReferenceStreamoutINTEL = Op 5769

pattern OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeMotionVectorsINTEL :: Op
pattern $bOpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeMotionVectorsINTEL :: Op
$mOpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeMotionVectorsINTEL :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeMotionVectorsINTEL = Op 5770

pattern OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeDistortionsINTEL :: Op
pattern $bOpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeDistortionsINTEL :: Op
$mOpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeDistortionsINTEL :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeDistortionsINTEL = Op 5771

pattern OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeReferenceIdsINTEL :: Op
pattern $bOpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeReferenceIdsINTEL :: Op
$mOpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeReferenceIdsINTEL :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeReferenceIdsINTEL = Op 5772

pattern OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeMotionVectorsINTEL :: Op
pattern $bOpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeMotionVectorsINTEL :: Op
$mOpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeMotionVectorsINTEL :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeMotionVectorsINTEL = Op 5773

pattern OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeDistortionsINTEL :: Op
pattern $bOpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeDistortionsINTEL :: Op
$mOpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeDistortionsINTEL :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeDistortionsINTEL = Op 5774

pattern OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeReferenceIdsINTEL :: Op
pattern $bOpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeReferenceIdsINTEL :: Op
$mOpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeReferenceIdsINTEL :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeReferenceIdsINTEL = Op 5775

pattern OpSubgroupAvcImeGetBorderReachedINTEL :: Op
pattern $bOpSubgroupAvcImeGetBorderReachedINTEL :: Op
$mOpSubgroupAvcImeGetBorderReachedINTEL :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpSubgroupAvcImeGetBorderReachedINTEL = Op 5776

pattern OpSubgroupAvcImeGetTruncatedSearchIndicationINTEL :: Op
pattern $bOpSubgroupAvcImeGetTruncatedSearchIndicationINTEL :: Op
$mOpSubgroupAvcImeGetTruncatedSearchIndicationINTEL :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpSubgroupAvcImeGetTruncatedSearchIndicationINTEL = Op 5777

pattern OpSubgroupAvcImeGetUnidirectionalEarlySearchTerminationINTEL :: Op
pattern $bOpSubgroupAvcImeGetUnidirectionalEarlySearchTerminationINTEL :: Op
$mOpSubgroupAvcImeGetUnidirectionalEarlySearchTerminationINTEL :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpSubgroupAvcImeGetUnidirectionalEarlySearchTerminationINTEL = Op 5778

pattern OpSubgroupAvcImeGetWeightingPatternMinimumMotionVectorINTEL :: Op
pattern $bOpSubgroupAvcImeGetWeightingPatternMinimumMotionVectorINTEL :: Op
$mOpSubgroupAvcImeGetWeightingPatternMinimumMotionVectorINTEL :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpSubgroupAvcImeGetWeightingPatternMinimumMotionVectorINTEL = Op 5779

pattern OpSubgroupAvcImeGetWeightingPatternMinimumDistortionINTEL :: Op
pattern $bOpSubgroupAvcImeGetWeightingPatternMinimumDistortionINTEL :: Op
$mOpSubgroupAvcImeGetWeightingPatternMinimumDistortionINTEL :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpSubgroupAvcImeGetWeightingPatternMinimumDistortionINTEL = Op 5780

pattern OpSubgroupAvcFmeInitializeINTEL :: Op
pattern $bOpSubgroupAvcFmeInitializeINTEL :: Op
$mOpSubgroupAvcFmeInitializeINTEL :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpSubgroupAvcFmeInitializeINTEL = Op 5781

pattern OpSubgroupAvcBmeInitializeINTEL :: Op
pattern $bOpSubgroupAvcBmeInitializeINTEL :: Op
$mOpSubgroupAvcBmeInitializeINTEL :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpSubgroupAvcBmeInitializeINTEL = Op 5782

pattern OpSubgroupAvcRefConvertToMcePayloadINTEL :: Op
pattern $bOpSubgroupAvcRefConvertToMcePayloadINTEL :: Op
$mOpSubgroupAvcRefConvertToMcePayloadINTEL :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpSubgroupAvcRefConvertToMcePayloadINTEL = Op 5783

pattern OpSubgroupAvcRefSetBidirectionalMixDisableINTEL :: Op
pattern $bOpSubgroupAvcRefSetBidirectionalMixDisableINTEL :: Op
$mOpSubgroupAvcRefSetBidirectionalMixDisableINTEL :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpSubgroupAvcRefSetBidirectionalMixDisableINTEL = Op 5784

pattern OpSubgroupAvcRefSetBilinearFilterEnableINTEL :: Op
pattern $bOpSubgroupAvcRefSetBilinearFilterEnableINTEL :: Op
$mOpSubgroupAvcRefSetBilinearFilterEnableINTEL :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpSubgroupAvcRefSetBilinearFilterEnableINTEL = Op 5785

pattern OpSubgroupAvcRefEvaluateWithSingleReferenceINTEL :: Op
pattern $bOpSubgroupAvcRefEvaluateWithSingleReferenceINTEL :: Op
$mOpSubgroupAvcRefEvaluateWithSingleReferenceINTEL :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpSubgroupAvcRefEvaluateWithSingleReferenceINTEL = Op 5786

pattern OpSubgroupAvcRefEvaluateWithDualReferenceINTEL :: Op
pattern $bOpSubgroupAvcRefEvaluateWithDualReferenceINTEL :: Op
$mOpSubgroupAvcRefEvaluateWithDualReferenceINTEL :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpSubgroupAvcRefEvaluateWithDualReferenceINTEL = Op 5787

pattern OpSubgroupAvcRefEvaluateWithMultiReferenceINTEL :: Op
pattern $bOpSubgroupAvcRefEvaluateWithMultiReferenceINTEL :: Op
$mOpSubgroupAvcRefEvaluateWithMultiReferenceINTEL :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpSubgroupAvcRefEvaluateWithMultiReferenceINTEL = Op 5788

pattern OpSubgroupAvcRefEvaluateWithMultiReferenceInterlacedINTEL :: Op
pattern $bOpSubgroupAvcRefEvaluateWithMultiReferenceInterlacedINTEL :: Op
$mOpSubgroupAvcRefEvaluateWithMultiReferenceInterlacedINTEL :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpSubgroupAvcRefEvaluateWithMultiReferenceInterlacedINTEL = Op 5789

pattern OpSubgroupAvcRefConvertToMceResultINTEL :: Op
pattern $bOpSubgroupAvcRefConvertToMceResultINTEL :: Op
$mOpSubgroupAvcRefConvertToMceResultINTEL :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpSubgroupAvcRefConvertToMceResultINTEL = Op 5790

pattern OpSubgroupAvcSicInitializeINTEL :: Op
pattern $bOpSubgroupAvcSicInitializeINTEL :: Op
$mOpSubgroupAvcSicInitializeINTEL :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpSubgroupAvcSicInitializeINTEL = Op 5791

pattern OpSubgroupAvcSicConfigureSkcINTEL :: Op
pattern $bOpSubgroupAvcSicConfigureSkcINTEL :: Op
$mOpSubgroupAvcSicConfigureSkcINTEL :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpSubgroupAvcSicConfigureSkcINTEL = Op 5792

pattern OpSubgroupAvcSicConfigureIpeLumaINTEL :: Op
pattern $bOpSubgroupAvcSicConfigureIpeLumaINTEL :: Op
$mOpSubgroupAvcSicConfigureIpeLumaINTEL :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpSubgroupAvcSicConfigureIpeLumaINTEL = Op 5793

pattern OpSubgroupAvcSicConfigureIpeLumaChromaINTEL :: Op
pattern $bOpSubgroupAvcSicConfigureIpeLumaChromaINTEL :: Op
$mOpSubgroupAvcSicConfigureIpeLumaChromaINTEL :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpSubgroupAvcSicConfigureIpeLumaChromaINTEL = Op 5794

pattern OpSubgroupAvcSicGetMotionVectorMaskINTEL :: Op
pattern $bOpSubgroupAvcSicGetMotionVectorMaskINTEL :: Op
$mOpSubgroupAvcSicGetMotionVectorMaskINTEL :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpSubgroupAvcSicGetMotionVectorMaskINTEL = Op 5795

pattern OpSubgroupAvcSicConvertToMcePayloadINTEL :: Op
pattern $bOpSubgroupAvcSicConvertToMcePayloadINTEL :: Op
$mOpSubgroupAvcSicConvertToMcePayloadINTEL :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpSubgroupAvcSicConvertToMcePayloadINTEL = Op 5796

pattern OpSubgroupAvcSicSetIntraLumaShapePenaltyINTEL :: Op
pattern $bOpSubgroupAvcSicSetIntraLumaShapePenaltyINTEL :: Op
$mOpSubgroupAvcSicSetIntraLumaShapePenaltyINTEL :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpSubgroupAvcSicSetIntraLumaShapePenaltyINTEL = Op 5797

pattern OpSubgroupAvcSicSetIntraLumaModeCostFunctionINTEL :: Op
pattern $bOpSubgroupAvcSicSetIntraLumaModeCostFunctionINTEL :: Op
$mOpSubgroupAvcSicSetIntraLumaModeCostFunctionINTEL :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpSubgroupAvcSicSetIntraLumaModeCostFunctionINTEL = Op 5798

pattern OpSubgroupAvcSicSetIntraChromaModeCostFunctionINTEL :: Op
pattern $bOpSubgroupAvcSicSetIntraChromaModeCostFunctionINTEL :: Op
$mOpSubgroupAvcSicSetIntraChromaModeCostFunctionINTEL :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpSubgroupAvcSicSetIntraChromaModeCostFunctionINTEL = Op 5799

pattern OpSubgroupAvcSicSetBilinearFilterEnableINTEL :: Op
pattern $bOpSubgroupAvcSicSetBilinearFilterEnableINTEL :: Op
$mOpSubgroupAvcSicSetBilinearFilterEnableINTEL :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpSubgroupAvcSicSetBilinearFilterEnableINTEL = Op 5800

pattern OpSubgroupAvcSicSetSkcForwardTransformEnableINTEL :: Op
pattern $bOpSubgroupAvcSicSetSkcForwardTransformEnableINTEL :: Op
$mOpSubgroupAvcSicSetSkcForwardTransformEnableINTEL :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpSubgroupAvcSicSetSkcForwardTransformEnableINTEL = Op 5801

pattern OpSubgroupAvcSicSetBlockBasedRawSkipSadINTEL :: Op
pattern $bOpSubgroupAvcSicSetBlockBasedRawSkipSadINTEL :: Op
$mOpSubgroupAvcSicSetBlockBasedRawSkipSadINTEL :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpSubgroupAvcSicSetBlockBasedRawSkipSadINTEL = Op 5802

pattern OpSubgroupAvcSicEvaluateIpeINTEL :: Op
pattern $bOpSubgroupAvcSicEvaluateIpeINTEL :: Op
$mOpSubgroupAvcSicEvaluateIpeINTEL :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpSubgroupAvcSicEvaluateIpeINTEL = Op 5803

pattern OpSubgroupAvcSicEvaluateWithSingleReferenceINTEL :: Op
pattern $bOpSubgroupAvcSicEvaluateWithSingleReferenceINTEL :: Op
$mOpSubgroupAvcSicEvaluateWithSingleReferenceINTEL :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpSubgroupAvcSicEvaluateWithSingleReferenceINTEL = Op 5804

pattern OpSubgroupAvcSicEvaluateWithDualReferenceINTEL :: Op
pattern $bOpSubgroupAvcSicEvaluateWithDualReferenceINTEL :: Op
$mOpSubgroupAvcSicEvaluateWithDualReferenceINTEL :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpSubgroupAvcSicEvaluateWithDualReferenceINTEL = Op 5805

pattern OpSubgroupAvcSicEvaluateWithMultiReferenceINTEL :: Op
pattern $bOpSubgroupAvcSicEvaluateWithMultiReferenceINTEL :: Op
$mOpSubgroupAvcSicEvaluateWithMultiReferenceINTEL :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpSubgroupAvcSicEvaluateWithMultiReferenceINTEL = Op 5806

pattern OpSubgroupAvcSicEvaluateWithMultiReferenceInterlacedINTEL :: Op
pattern $bOpSubgroupAvcSicEvaluateWithMultiReferenceInterlacedINTEL :: Op
$mOpSubgroupAvcSicEvaluateWithMultiReferenceInterlacedINTEL :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpSubgroupAvcSicEvaluateWithMultiReferenceInterlacedINTEL = Op 5807

pattern OpSubgroupAvcSicConvertToMceResultINTEL :: Op
pattern $bOpSubgroupAvcSicConvertToMceResultINTEL :: Op
$mOpSubgroupAvcSicConvertToMceResultINTEL :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpSubgroupAvcSicConvertToMceResultINTEL = Op 5808

pattern OpSubgroupAvcSicGetIpeLumaShapeINTEL :: Op
pattern $bOpSubgroupAvcSicGetIpeLumaShapeINTEL :: Op
$mOpSubgroupAvcSicGetIpeLumaShapeINTEL :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpSubgroupAvcSicGetIpeLumaShapeINTEL = Op 5809

pattern OpSubgroupAvcSicGetBestIpeLumaDistortionINTEL :: Op
pattern $bOpSubgroupAvcSicGetBestIpeLumaDistortionINTEL :: Op
$mOpSubgroupAvcSicGetBestIpeLumaDistortionINTEL :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpSubgroupAvcSicGetBestIpeLumaDistortionINTEL = Op 5810

pattern OpSubgroupAvcSicGetBestIpeChromaDistortionINTEL :: Op
pattern $bOpSubgroupAvcSicGetBestIpeChromaDistortionINTEL :: Op
$mOpSubgroupAvcSicGetBestIpeChromaDistortionINTEL :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpSubgroupAvcSicGetBestIpeChromaDistortionINTEL = Op 5811

pattern OpSubgroupAvcSicGetPackedIpeLumaModesINTEL :: Op
pattern $bOpSubgroupAvcSicGetPackedIpeLumaModesINTEL :: Op
$mOpSubgroupAvcSicGetPackedIpeLumaModesINTEL :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpSubgroupAvcSicGetPackedIpeLumaModesINTEL = Op 5812

pattern OpSubgroupAvcSicGetIpeChromaModeINTEL :: Op
pattern $bOpSubgroupAvcSicGetIpeChromaModeINTEL :: Op
$mOpSubgroupAvcSicGetIpeChromaModeINTEL :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpSubgroupAvcSicGetIpeChromaModeINTEL = Op 5813

pattern OpSubgroupAvcSicGetPackedSkcLumaCountThresholdINTEL :: Op
pattern $bOpSubgroupAvcSicGetPackedSkcLumaCountThresholdINTEL :: Op
$mOpSubgroupAvcSicGetPackedSkcLumaCountThresholdINTEL :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpSubgroupAvcSicGetPackedSkcLumaCountThresholdINTEL = Op 5814

pattern OpSubgroupAvcSicGetPackedSkcLumaSumThresholdINTEL :: Op
pattern $bOpSubgroupAvcSicGetPackedSkcLumaSumThresholdINTEL :: Op
$mOpSubgroupAvcSicGetPackedSkcLumaSumThresholdINTEL :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpSubgroupAvcSicGetPackedSkcLumaSumThresholdINTEL = Op 5815

pattern OpSubgroupAvcSicGetInterRawSadsINTEL :: Op
pattern $bOpSubgroupAvcSicGetInterRawSadsINTEL :: Op
$mOpSubgroupAvcSicGetInterRawSadsINTEL :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpSubgroupAvcSicGetInterRawSadsINTEL = Op 5816

pattern OpVariableLengthArrayINTEL :: Op
pattern $bOpVariableLengthArrayINTEL :: Op
$mOpVariableLengthArrayINTEL :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpVariableLengthArrayINTEL = Op 5818

pattern OpSaveMemoryINTEL :: Op
pattern $bOpSaveMemoryINTEL :: Op
$mOpSaveMemoryINTEL :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpSaveMemoryINTEL = Op 5819

pattern OpRestoreMemoryINTEL :: Op
pattern $bOpRestoreMemoryINTEL :: Op
$mOpRestoreMemoryINTEL :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpRestoreMemoryINTEL = Op 5820

pattern OpArbitraryFloatSinCosPiINTEL :: Op
pattern $bOpArbitraryFloatSinCosPiINTEL :: Op
$mOpArbitraryFloatSinCosPiINTEL :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpArbitraryFloatSinCosPiINTEL = Op 5840

pattern OpArbitraryFloatCastINTEL :: Op
pattern $bOpArbitraryFloatCastINTEL :: Op
$mOpArbitraryFloatCastINTEL :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpArbitraryFloatCastINTEL = Op 5841

pattern OpArbitraryFloatCastFromIntINTEL :: Op
pattern $bOpArbitraryFloatCastFromIntINTEL :: Op
$mOpArbitraryFloatCastFromIntINTEL :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpArbitraryFloatCastFromIntINTEL = Op 5842

pattern OpArbitraryFloatCastToIntINTEL :: Op
pattern $bOpArbitraryFloatCastToIntINTEL :: Op
$mOpArbitraryFloatCastToIntINTEL :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpArbitraryFloatCastToIntINTEL = Op 5843

pattern OpArbitraryFloatAddINTEL :: Op
pattern $bOpArbitraryFloatAddINTEL :: Op
$mOpArbitraryFloatAddINTEL :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpArbitraryFloatAddINTEL = Op 5846

pattern OpArbitraryFloatSubINTEL :: Op
pattern $bOpArbitraryFloatSubINTEL :: Op
$mOpArbitraryFloatSubINTEL :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpArbitraryFloatSubINTEL = Op 5847

pattern OpArbitraryFloatMulINTEL :: Op
pattern $bOpArbitraryFloatMulINTEL :: Op
$mOpArbitraryFloatMulINTEL :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpArbitraryFloatMulINTEL = Op 5848

pattern OpArbitraryFloatDivINTEL :: Op
pattern $bOpArbitraryFloatDivINTEL :: Op
$mOpArbitraryFloatDivINTEL :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpArbitraryFloatDivINTEL = Op 5849

pattern OpArbitraryFloatGTINTEL :: Op
pattern $bOpArbitraryFloatGTINTEL :: Op
$mOpArbitraryFloatGTINTEL :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpArbitraryFloatGTINTEL = Op 5850

pattern OpArbitraryFloatGEINTEL :: Op
pattern $bOpArbitraryFloatGEINTEL :: Op
$mOpArbitraryFloatGEINTEL :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpArbitraryFloatGEINTEL = Op 5851

pattern OpArbitraryFloatLTINTEL :: Op
pattern $bOpArbitraryFloatLTINTEL :: Op
$mOpArbitraryFloatLTINTEL :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpArbitraryFloatLTINTEL = Op 5852

pattern OpArbitraryFloatLEINTEL :: Op
pattern $bOpArbitraryFloatLEINTEL :: Op
$mOpArbitraryFloatLEINTEL :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpArbitraryFloatLEINTEL = Op 5853

pattern OpArbitraryFloatEQINTEL :: Op
pattern $bOpArbitraryFloatEQINTEL :: Op
$mOpArbitraryFloatEQINTEL :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpArbitraryFloatEQINTEL = Op 5854

pattern OpArbitraryFloatRecipINTEL :: Op
pattern $bOpArbitraryFloatRecipINTEL :: Op
$mOpArbitraryFloatRecipINTEL :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpArbitraryFloatRecipINTEL = Op 5855

pattern OpArbitraryFloatRSqrtINTEL :: Op
pattern $bOpArbitraryFloatRSqrtINTEL :: Op
$mOpArbitraryFloatRSqrtINTEL :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpArbitraryFloatRSqrtINTEL = Op 5856

pattern OpArbitraryFloatCbrtINTEL :: Op
pattern $bOpArbitraryFloatCbrtINTEL :: Op
$mOpArbitraryFloatCbrtINTEL :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpArbitraryFloatCbrtINTEL = Op 5857

pattern OpArbitraryFloatHypotINTEL :: Op
pattern $bOpArbitraryFloatHypotINTEL :: Op
$mOpArbitraryFloatHypotINTEL :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpArbitraryFloatHypotINTEL = Op 5858

pattern OpArbitraryFloatSqrtINTEL :: Op
pattern $bOpArbitraryFloatSqrtINTEL :: Op
$mOpArbitraryFloatSqrtINTEL :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpArbitraryFloatSqrtINTEL = Op 5859

pattern OpArbitraryFloatLogINTEL :: Op
pattern $bOpArbitraryFloatLogINTEL :: Op
$mOpArbitraryFloatLogINTEL :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpArbitraryFloatLogINTEL = Op 5860

pattern OpArbitraryFloatLog2INTEL :: Op
pattern $bOpArbitraryFloatLog2INTEL :: Op
$mOpArbitraryFloatLog2INTEL :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpArbitraryFloatLog2INTEL = Op 5861

pattern OpArbitraryFloatLog10INTEL :: Op
pattern $bOpArbitraryFloatLog10INTEL :: Op
$mOpArbitraryFloatLog10INTEL :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpArbitraryFloatLog10INTEL = Op 5862

pattern OpArbitraryFloatLog1pINTEL :: Op
pattern $bOpArbitraryFloatLog1pINTEL :: Op
$mOpArbitraryFloatLog1pINTEL :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpArbitraryFloatLog1pINTEL = Op 5863

pattern OpArbitraryFloatExpINTEL :: Op
pattern $bOpArbitraryFloatExpINTEL :: Op
$mOpArbitraryFloatExpINTEL :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpArbitraryFloatExpINTEL = Op 5864

pattern OpArbitraryFloatExp2INTEL :: Op
pattern $bOpArbitraryFloatExp2INTEL :: Op
$mOpArbitraryFloatExp2INTEL :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpArbitraryFloatExp2INTEL = Op 5865

pattern OpArbitraryFloatExp10INTEL :: Op
pattern $bOpArbitraryFloatExp10INTEL :: Op
$mOpArbitraryFloatExp10INTEL :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpArbitraryFloatExp10INTEL = Op 5866

pattern OpArbitraryFloatExpm1INTEL :: Op
pattern $bOpArbitraryFloatExpm1INTEL :: Op
$mOpArbitraryFloatExpm1INTEL :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpArbitraryFloatExpm1INTEL = Op 5867

pattern OpArbitraryFloatSinINTEL :: Op
pattern $bOpArbitraryFloatSinINTEL :: Op
$mOpArbitraryFloatSinINTEL :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpArbitraryFloatSinINTEL = Op 5868

pattern OpArbitraryFloatCosINTEL :: Op
pattern $bOpArbitraryFloatCosINTEL :: Op
$mOpArbitraryFloatCosINTEL :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpArbitraryFloatCosINTEL = Op 5869

pattern OpArbitraryFloatSinCosINTEL :: Op
pattern $bOpArbitraryFloatSinCosINTEL :: Op
$mOpArbitraryFloatSinCosINTEL :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpArbitraryFloatSinCosINTEL = Op 5870

pattern OpArbitraryFloatSinPiINTEL :: Op
pattern $bOpArbitraryFloatSinPiINTEL :: Op
$mOpArbitraryFloatSinPiINTEL :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpArbitraryFloatSinPiINTEL = Op 5871

pattern OpArbitraryFloatCosPiINTEL :: Op
pattern $bOpArbitraryFloatCosPiINTEL :: Op
$mOpArbitraryFloatCosPiINTEL :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpArbitraryFloatCosPiINTEL = Op 5872

pattern OpArbitraryFloatASinINTEL :: Op
pattern $bOpArbitraryFloatASinINTEL :: Op
$mOpArbitraryFloatASinINTEL :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpArbitraryFloatASinINTEL = Op 5873

pattern OpArbitraryFloatASinPiINTEL :: Op
pattern $bOpArbitraryFloatASinPiINTEL :: Op
$mOpArbitraryFloatASinPiINTEL :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpArbitraryFloatASinPiINTEL = Op 5874

pattern OpArbitraryFloatACosINTEL :: Op
pattern $bOpArbitraryFloatACosINTEL :: Op
$mOpArbitraryFloatACosINTEL :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpArbitraryFloatACosINTEL = Op 5875

pattern OpArbitraryFloatACosPiINTEL :: Op
pattern $bOpArbitraryFloatACosPiINTEL :: Op
$mOpArbitraryFloatACosPiINTEL :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpArbitraryFloatACosPiINTEL = Op 5876

pattern OpArbitraryFloatATanINTEL :: Op
pattern $bOpArbitraryFloatATanINTEL :: Op
$mOpArbitraryFloatATanINTEL :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpArbitraryFloatATanINTEL = Op 5877

pattern OpArbitraryFloatATanPiINTEL :: Op
pattern $bOpArbitraryFloatATanPiINTEL :: Op
$mOpArbitraryFloatATanPiINTEL :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpArbitraryFloatATanPiINTEL = Op 5878

pattern OpArbitraryFloatATan2INTEL :: Op
pattern $bOpArbitraryFloatATan2INTEL :: Op
$mOpArbitraryFloatATan2INTEL :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpArbitraryFloatATan2INTEL = Op 5879

pattern OpArbitraryFloatPowINTEL :: Op
pattern $bOpArbitraryFloatPowINTEL :: Op
$mOpArbitraryFloatPowINTEL :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpArbitraryFloatPowINTEL = Op 5880

pattern OpArbitraryFloatPowRINTEL :: Op
pattern $bOpArbitraryFloatPowRINTEL :: Op
$mOpArbitraryFloatPowRINTEL :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpArbitraryFloatPowRINTEL = Op 5881

pattern OpArbitraryFloatPowNINTEL :: Op
pattern $bOpArbitraryFloatPowNINTEL :: Op
$mOpArbitraryFloatPowNINTEL :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpArbitraryFloatPowNINTEL = Op 5882

pattern OpLoopControlINTEL :: Op
pattern $bOpLoopControlINTEL :: Op
$mOpLoopControlINTEL :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpLoopControlINTEL = Op 5887

pattern OpAliasDomainDeclINTEL :: Op
pattern $bOpAliasDomainDeclINTEL :: Op
$mOpAliasDomainDeclINTEL :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpAliasDomainDeclINTEL = Op 5911

pattern OpAliasScopeDeclINTEL :: Op
pattern $bOpAliasScopeDeclINTEL :: Op
$mOpAliasScopeDeclINTEL :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpAliasScopeDeclINTEL = Op 5912

pattern OpAliasScopeListDeclINTEL :: Op
pattern $bOpAliasScopeListDeclINTEL :: Op
$mOpAliasScopeListDeclINTEL :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpAliasScopeListDeclINTEL = Op 5913

pattern OpFixedSqrtINTEL :: Op
pattern $bOpFixedSqrtINTEL :: Op
$mOpFixedSqrtINTEL :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpFixedSqrtINTEL = Op 5923

pattern OpFixedRecipINTEL :: Op
pattern $bOpFixedRecipINTEL :: Op
$mOpFixedRecipINTEL :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpFixedRecipINTEL = Op 5924

pattern OpFixedRsqrtINTEL :: Op
pattern $bOpFixedRsqrtINTEL :: Op
$mOpFixedRsqrtINTEL :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpFixedRsqrtINTEL = Op 5925

pattern OpFixedSinINTEL :: Op
pattern $bOpFixedSinINTEL :: Op
$mOpFixedSinINTEL :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpFixedSinINTEL = Op 5926

pattern OpFixedCosINTEL :: Op
pattern $bOpFixedCosINTEL :: Op
$mOpFixedCosINTEL :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpFixedCosINTEL = Op 5927

pattern OpFixedSinCosINTEL :: Op
pattern $bOpFixedSinCosINTEL :: Op
$mOpFixedSinCosINTEL :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpFixedSinCosINTEL = Op 5928

pattern OpFixedSinPiINTEL :: Op
pattern $bOpFixedSinPiINTEL :: Op
$mOpFixedSinPiINTEL :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpFixedSinPiINTEL = Op 5929

pattern OpFixedCosPiINTEL :: Op
pattern $bOpFixedCosPiINTEL :: Op
$mOpFixedCosPiINTEL :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpFixedCosPiINTEL = Op 5930

pattern OpFixedSinCosPiINTEL :: Op
pattern $bOpFixedSinCosPiINTEL :: Op
$mOpFixedSinCosPiINTEL :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpFixedSinCosPiINTEL = Op 5931

pattern OpFixedLogINTEL :: Op
pattern $bOpFixedLogINTEL :: Op
$mOpFixedLogINTEL :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpFixedLogINTEL = Op 5932

pattern OpFixedExpINTEL :: Op
pattern $bOpFixedExpINTEL :: Op
$mOpFixedExpINTEL :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpFixedExpINTEL = Op 5933

pattern OpPtrCastToCrossWorkgroupINTEL :: Op
pattern $bOpPtrCastToCrossWorkgroupINTEL :: Op
$mOpPtrCastToCrossWorkgroupINTEL :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpPtrCastToCrossWorkgroupINTEL = Op 5934

pattern OpCrossWorkgroupCastToPtrINTEL :: Op
pattern $bOpCrossWorkgroupCastToPtrINTEL :: Op
$mOpCrossWorkgroupCastToPtrINTEL :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpCrossWorkgroupCastToPtrINTEL = Op 5938

pattern OpReadPipeBlockingINTEL :: Op
pattern $bOpReadPipeBlockingINTEL :: Op
$mOpReadPipeBlockingINTEL :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpReadPipeBlockingINTEL = Op 5946

pattern OpWritePipeBlockingINTEL :: Op
pattern $bOpWritePipeBlockingINTEL :: Op
$mOpWritePipeBlockingINTEL :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpWritePipeBlockingINTEL = Op 5947

pattern OpFPGARegINTEL :: Op
pattern $bOpFPGARegINTEL :: Op
$mOpFPGARegINTEL :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpFPGARegINTEL = Op 5949

pattern OpRayQueryGetRayTMinKHR :: Op
pattern $bOpRayQueryGetRayTMinKHR :: Op
$mOpRayQueryGetRayTMinKHR :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpRayQueryGetRayTMinKHR = Op 6016

pattern OpRayQueryGetRayFlagsKHR :: Op
pattern $bOpRayQueryGetRayFlagsKHR :: Op
$mOpRayQueryGetRayFlagsKHR :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpRayQueryGetRayFlagsKHR = Op 6017

pattern OpRayQueryGetIntersectionTKHR :: Op
pattern $bOpRayQueryGetIntersectionTKHR :: Op
$mOpRayQueryGetIntersectionTKHR :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpRayQueryGetIntersectionTKHR = Op 6018

pattern OpRayQueryGetIntersectionInstanceCustomIndexKHR :: Op
pattern $bOpRayQueryGetIntersectionInstanceCustomIndexKHR :: Op
$mOpRayQueryGetIntersectionInstanceCustomIndexKHR :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpRayQueryGetIntersectionInstanceCustomIndexKHR = Op 6019

pattern OpRayQueryGetIntersectionInstanceIdKHR :: Op
pattern $bOpRayQueryGetIntersectionInstanceIdKHR :: Op
$mOpRayQueryGetIntersectionInstanceIdKHR :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpRayQueryGetIntersectionInstanceIdKHR = Op 6020

pattern OpRayQueryGetIntersectionInstanceShaderBindingTableRecordOffsetKHR :: Op
pattern $bOpRayQueryGetIntersectionInstanceShaderBindingTableRecordOffsetKHR :: Op
$mOpRayQueryGetIntersectionInstanceShaderBindingTableRecordOffsetKHR :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpRayQueryGetIntersectionInstanceShaderBindingTableRecordOffsetKHR = Op 6021

pattern OpRayQueryGetIntersectionGeometryIndexKHR :: Op
pattern $bOpRayQueryGetIntersectionGeometryIndexKHR :: Op
$mOpRayQueryGetIntersectionGeometryIndexKHR :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpRayQueryGetIntersectionGeometryIndexKHR = Op 6022

pattern OpRayQueryGetIntersectionPrimitiveIndexKHR :: Op
pattern $bOpRayQueryGetIntersectionPrimitiveIndexKHR :: Op
$mOpRayQueryGetIntersectionPrimitiveIndexKHR :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpRayQueryGetIntersectionPrimitiveIndexKHR = Op 6023

pattern OpRayQueryGetIntersectionBarycentricsKHR :: Op
pattern $bOpRayQueryGetIntersectionBarycentricsKHR :: Op
$mOpRayQueryGetIntersectionBarycentricsKHR :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpRayQueryGetIntersectionBarycentricsKHR = Op 6024

pattern OpRayQueryGetIntersectionFrontFaceKHR :: Op
pattern $bOpRayQueryGetIntersectionFrontFaceKHR :: Op
$mOpRayQueryGetIntersectionFrontFaceKHR :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpRayQueryGetIntersectionFrontFaceKHR = Op 6025

pattern OpRayQueryGetIntersectionCandidateAABBOpaqueKHR :: Op
pattern $bOpRayQueryGetIntersectionCandidateAABBOpaqueKHR :: Op
$mOpRayQueryGetIntersectionCandidateAABBOpaqueKHR :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpRayQueryGetIntersectionCandidateAABBOpaqueKHR = Op 6026

pattern OpRayQueryGetIntersectionObjectRayDirectionKHR :: Op
pattern $bOpRayQueryGetIntersectionObjectRayDirectionKHR :: Op
$mOpRayQueryGetIntersectionObjectRayDirectionKHR :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpRayQueryGetIntersectionObjectRayDirectionKHR = Op 6027

pattern OpRayQueryGetIntersectionObjectRayOriginKHR :: Op
pattern $bOpRayQueryGetIntersectionObjectRayOriginKHR :: Op
$mOpRayQueryGetIntersectionObjectRayOriginKHR :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpRayQueryGetIntersectionObjectRayOriginKHR = Op 6028

pattern OpRayQueryGetWorldRayDirectionKHR :: Op
pattern $bOpRayQueryGetWorldRayDirectionKHR :: Op
$mOpRayQueryGetWorldRayDirectionKHR :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpRayQueryGetWorldRayDirectionKHR = Op 6029

pattern OpRayQueryGetWorldRayOriginKHR :: Op
pattern $bOpRayQueryGetWorldRayOriginKHR :: Op
$mOpRayQueryGetWorldRayOriginKHR :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpRayQueryGetWorldRayOriginKHR = Op 6030

pattern OpRayQueryGetIntersectionObjectToWorldKHR :: Op
pattern $bOpRayQueryGetIntersectionObjectToWorldKHR :: Op
$mOpRayQueryGetIntersectionObjectToWorldKHR :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpRayQueryGetIntersectionObjectToWorldKHR = Op 6031

pattern OpRayQueryGetIntersectionWorldToObjectKHR :: Op
pattern $bOpRayQueryGetIntersectionWorldToObjectKHR :: Op
$mOpRayQueryGetIntersectionWorldToObjectKHR :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpRayQueryGetIntersectionWorldToObjectKHR = Op 6032

pattern OpAtomicFAddEXT :: Op
pattern $bOpAtomicFAddEXT :: Op
$mOpAtomicFAddEXT :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpAtomicFAddEXT = Op 6035

pattern OpTypeBufferSurfaceINTEL :: Op
pattern $bOpTypeBufferSurfaceINTEL :: Op
$mOpTypeBufferSurfaceINTEL :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpTypeBufferSurfaceINTEL = Op 6086

pattern OpTypeStructContinuedINTEL :: Op
pattern $bOpTypeStructContinuedINTEL :: Op
$mOpTypeStructContinuedINTEL :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpTypeStructContinuedINTEL = Op 6090

pattern OpConstantCompositeContinuedINTEL :: Op
pattern $bOpConstantCompositeContinuedINTEL :: Op
$mOpConstantCompositeContinuedINTEL :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpConstantCompositeContinuedINTEL = Op 6091

pattern OpSpecConstantCompositeContinuedINTEL :: Op
pattern $bOpSpecConstantCompositeContinuedINTEL :: Op
$mOpSpecConstantCompositeContinuedINTEL :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpSpecConstantCompositeContinuedINTEL = Op 6092

pattern OpControlBarrierArriveINTEL :: Op
pattern $bOpControlBarrierArriveINTEL :: Op
$mOpControlBarrierArriveINTEL :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpControlBarrierArriveINTEL = Op 6142

pattern OpControlBarrierWaitINTEL :: Op
pattern $bOpControlBarrierWaitINTEL :: Op
$mOpControlBarrierWaitINTEL :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpControlBarrierWaitINTEL = Op 6143

pattern OpGroupIMulKHR :: Op
pattern $bOpGroupIMulKHR :: Op
$mOpGroupIMulKHR :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpGroupIMulKHR = Op 6401

pattern OpGroupFMulKHR :: Op
pattern $bOpGroupFMulKHR :: Op
$mOpGroupFMulKHR :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpGroupFMulKHR = Op 6402

pattern OpGroupBitwiseAndKHR :: Op
pattern $bOpGroupBitwiseAndKHR :: Op
$mOpGroupBitwiseAndKHR :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpGroupBitwiseAndKHR = Op 6403

pattern OpGroupBitwiseOrKHR :: Op
pattern $bOpGroupBitwiseOrKHR :: Op
$mOpGroupBitwiseOrKHR :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpGroupBitwiseOrKHR = Op 6404

pattern OpGroupBitwiseXorKHR :: Op
pattern $bOpGroupBitwiseXorKHR :: Op
$mOpGroupBitwiseXorKHR :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpGroupBitwiseXorKHR = Op 6405

pattern OpGroupLogicalAndKHR :: Op
pattern $bOpGroupLogicalAndKHR :: Op
$mOpGroupLogicalAndKHR :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpGroupLogicalAndKHR = Op 6406

pattern OpGroupLogicalOrKHR :: Op
pattern $bOpGroupLogicalOrKHR :: Op
$mOpGroupLogicalOrKHR :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpGroupLogicalOrKHR = Op 6407

pattern OpGroupLogicalXorKHR :: Op
pattern $bOpGroupLogicalXorKHR :: Op
$mOpGroupLogicalXorKHR :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpGroupLogicalXorKHR = Op 6408

toName :: IsString a => Op -> a
toName :: forall a. IsString a => Op -> a
toName Op
x = case Op
x of
  Op
OpNop -> a
"OpNop"
  Op
OpUndef -> a
"OpUndef"
  Op
OpSourceContinued -> a
"OpSourceContinued"
  Op
OpSource -> a
"OpSource"
  Op
OpSourceExtension -> a
"OpSourceExtension"
  Op
OpName -> a
"OpName"
  Op
OpMemberName -> a
"OpMemberName"
  Op
OpString -> a
"OpString"
  Op
OpLine -> a
"OpLine"
  Op
OpExtension -> a
"OpExtension"
  Op
OpExtInstImport -> a
"OpExtInstImport"
  Op
OpExtInst -> a
"OpExtInst"
  Op
OpMemoryModel -> a
"OpMemoryModel"
  Op
OpEntryPoint -> a
"OpEntryPoint"
  Op
OpExecutionMode -> a
"OpExecutionMode"
  Op
OpCapability -> a
"OpCapability"
  Op
OpTypeVoid -> a
"OpTypeVoid"
  Op
OpTypeBool -> a
"OpTypeBool"
  Op
OpTypeInt -> a
"OpTypeInt"
  Op
OpTypeFloat -> a
"OpTypeFloat"
  Op
OpTypeVector -> a
"OpTypeVector"
  Op
OpTypeMatrix -> a
"OpTypeMatrix"
  Op
OpTypeImage -> a
"OpTypeImage"
  Op
OpTypeSampler -> a
"OpTypeSampler"
  Op
OpTypeSampledImage -> a
"OpTypeSampledImage"
  Op
OpTypeArray -> a
"OpTypeArray"
  Op
OpTypeRuntimeArray -> a
"OpTypeRuntimeArray"
  Op
OpTypeStruct -> a
"OpTypeStruct"
  Op
OpTypeOpaque -> a
"OpTypeOpaque"
  Op
OpTypePointer -> a
"OpTypePointer"
  Op
OpTypeFunction -> a
"OpTypeFunction"
  Op
OpTypeEvent -> a
"OpTypeEvent"
  Op
OpTypeDeviceEvent -> a
"OpTypeDeviceEvent"
  Op
OpTypeReserveId -> a
"OpTypeReserveId"
  Op
OpTypeQueue -> a
"OpTypeQueue"
  Op
OpTypePipe -> a
"OpTypePipe"
  Op
OpTypeForwardPointer -> a
"OpTypeForwardPointer"
  Op
OpConstantTrue -> a
"OpConstantTrue"
  Op
OpConstantFalse -> a
"OpConstantFalse"
  Op
OpConstant -> a
"OpConstant"
  Op
OpConstantComposite -> a
"OpConstantComposite"
  Op
OpConstantSampler -> a
"OpConstantSampler"
  Op
OpConstantNull -> a
"OpConstantNull"
  Op
OpSpecConstantTrue -> a
"OpSpecConstantTrue"
  Op
OpSpecConstantFalse -> a
"OpSpecConstantFalse"
  Op
OpSpecConstant -> a
"OpSpecConstant"
  Op
OpSpecConstantComposite -> a
"OpSpecConstantComposite"
  Op
OpSpecConstantOp -> a
"OpSpecConstantOp"
  Op
OpFunction -> a
"OpFunction"
  Op
OpFunctionParameter -> a
"OpFunctionParameter"
  Op
OpFunctionEnd -> a
"OpFunctionEnd"
  Op
OpFunctionCall -> a
"OpFunctionCall"
  Op
OpVariable -> a
"OpVariable"
  Op
OpImageTexelPointer -> a
"OpImageTexelPointer"
  Op
OpLoad -> a
"OpLoad"
  Op
OpStore -> a
"OpStore"
  Op
OpCopyMemory -> a
"OpCopyMemory"
  Op
OpCopyMemorySized -> a
"OpCopyMemorySized"
  Op
OpAccessChain -> a
"OpAccessChain"
  Op
OpInBoundsAccessChain -> a
"OpInBoundsAccessChain"
  Op
OpPtrAccessChain -> a
"OpPtrAccessChain"
  Op
OpArrayLength -> a
"OpArrayLength"
  Op
OpGenericPtrMemSemantics -> a
"OpGenericPtrMemSemantics"
  Op
OpInBoundsPtrAccessChain -> a
"OpInBoundsPtrAccessChain"
  Op
OpDecorate -> a
"OpDecorate"
  Op
OpMemberDecorate -> a
"OpMemberDecorate"
  Op
OpDecorationGroup -> a
"OpDecorationGroup"
  Op
OpGroupDecorate -> a
"OpGroupDecorate"
  Op
OpGroupMemberDecorate -> a
"OpGroupMemberDecorate"
  Op
OpVectorExtractDynamic -> a
"OpVectorExtractDynamic"
  Op
OpVectorInsertDynamic -> a
"OpVectorInsertDynamic"
  Op
OpVectorShuffle -> a
"OpVectorShuffle"
  Op
OpCompositeConstruct -> a
"OpCompositeConstruct"
  Op
OpCompositeExtract -> a
"OpCompositeExtract"
  Op
OpCompositeInsert -> a
"OpCompositeInsert"
  Op
OpCopyObject -> a
"OpCopyObject"
  Op
OpTranspose -> a
"OpTranspose"
  Op
OpSampledImage -> a
"OpSampledImage"
  Op
OpImageSampleImplicitLod -> a
"OpImageSampleImplicitLod"
  Op
OpImageSampleExplicitLod -> a
"OpImageSampleExplicitLod"
  Op
OpImageSampleDrefImplicitLod -> a
"OpImageSampleDrefImplicitLod"
  Op
OpImageSampleDrefExplicitLod -> a
"OpImageSampleDrefExplicitLod"
  Op
OpImageSampleProjImplicitLod -> a
"OpImageSampleProjImplicitLod"
  Op
OpImageSampleProjExplicitLod -> a
"OpImageSampleProjExplicitLod"
  Op
OpImageSampleProjDrefImplicitLod -> a
"OpImageSampleProjDrefImplicitLod"
  Op
OpImageSampleProjDrefExplicitLod -> a
"OpImageSampleProjDrefExplicitLod"
  Op
OpImageFetch -> a
"OpImageFetch"
  Op
OpImageGather -> a
"OpImageGather"
  Op
OpImageDrefGather -> a
"OpImageDrefGather"
  Op
OpImageRead -> a
"OpImageRead"
  Op
OpImageWrite -> a
"OpImageWrite"
  Op
OpImage -> a
"OpImage"
  Op
OpImageQueryFormat -> a
"OpImageQueryFormat"
  Op
OpImageQueryOrder -> a
"OpImageQueryOrder"
  Op
OpImageQuerySizeLod -> a
"OpImageQuerySizeLod"
  Op
OpImageQuerySize -> a
"OpImageQuerySize"
  Op
OpImageQueryLod -> a
"OpImageQueryLod"
  Op
OpImageQueryLevels -> a
"OpImageQueryLevels"
  Op
OpImageQuerySamples -> a
"OpImageQuerySamples"
  Op
OpConvertFToU -> a
"OpConvertFToU"
  Op
OpConvertFToS -> a
"OpConvertFToS"
  Op
OpConvertSToF -> a
"OpConvertSToF"
  Op
OpConvertUToF -> a
"OpConvertUToF"
  Op
OpUConvert -> a
"OpUConvert"
  Op
OpSConvert -> a
"OpSConvert"
  Op
OpFConvert -> a
"OpFConvert"
  Op
OpQuantizeToF16 -> a
"OpQuantizeToF16"
  Op
OpConvertPtrToU -> a
"OpConvertPtrToU"
  Op
OpSatConvertSToU -> a
"OpSatConvertSToU"
  Op
OpSatConvertUToS -> a
"OpSatConvertUToS"
  Op
OpConvertUToPtr -> a
"OpConvertUToPtr"
  Op
OpPtrCastToGeneric -> a
"OpPtrCastToGeneric"
  Op
OpGenericCastToPtr -> a
"OpGenericCastToPtr"
  Op
OpGenericCastToPtrExplicit -> a
"OpGenericCastToPtrExplicit"
  Op
OpBitcast -> a
"OpBitcast"
  Op
OpSNegate -> a
"OpSNegate"
  Op
OpFNegate -> a
"OpFNegate"
  Op
OpIAdd -> a
"OpIAdd"
  Op
OpFAdd -> a
"OpFAdd"
  Op
OpISub -> a
"OpISub"
  Op
OpFSub -> a
"OpFSub"
  Op
OpIMul -> a
"OpIMul"
  Op
OpFMul -> a
"OpFMul"
  Op
OpUDiv -> a
"OpUDiv"
  Op
OpSDiv -> a
"OpSDiv"
  Op
OpFDiv -> a
"OpFDiv"
  Op
OpUMod -> a
"OpUMod"
  Op
OpSRem -> a
"OpSRem"
  Op
OpSMod -> a
"OpSMod"
  Op
OpFRem -> a
"OpFRem"
  Op
OpFMod -> a
"OpFMod"
  Op
OpVectorTimesScalar -> a
"OpVectorTimesScalar"
  Op
OpMatrixTimesScalar -> a
"OpMatrixTimesScalar"
  Op
OpVectorTimesMatrix -> a
"OpVectorTimesMatrix"
  Op
OpMatrixTimesVector -> a
"OpMatrixTimesVector"
  Op
OpMatrixTimesMatrix -> a
"OpMatrixTimesMatrix"
  Op
OpOuterProduct -> a
"OpOuterProduct"
  Op
OpDot -> a
"OpDot"
  Op
OpIAddCarry -> a
"OpIAddCarry"
  Op
OpISubBorrow -> a
"OpISubBorrow"
  Op
OpUMulExtended -> a
"OpUMulExtended"
  Op
OpSMulExtended -> a
"OpSMulExtended"
  Op
OpAny -> a
"OpAny"
  Op
OpAll -> a
"OpAll"
  Op
OpIsNan -> a
"OpIsNan"
  Op
OpIsInf -> a
"OpIsInf"
  Op
OpIsFinite -> a
"OpIsFinite"
  Op
OpIsNormal -> a
"OpIsNormal"
  Op
OpSignBitSet -> a
"OpSignBitSet"
  Op
OpLessOrGreater -> a
"OpLessOrGreater"
  Op
OpOrdered -> a
"OpOrdered"
  Op
OpUnordered -> a
"OpUnordered"
  Op
OpLogicalEqual -> a
"OpLogicalEqual"
  Op
OpLogicalNotEqual -> a
"OpLogicalNotEqual"
  Op
OpLogicalOr -> a
"OpLogicalOr"
  Op
OpLogicalAnd -> a
"OpLogicalAnd"
  Op
OpLogicalNot -> a
"OpLogicalNot"
  Op
OpSelect -> a
"OpSelect"
  Op
OpIEqual -> a
"OpIEqual"
  Op
OpINotEqual -> a
"OpINotEqual"
  Op
OpUGreaterThan -> a
"OpUGreaterThan"
  Op
OpSGreaterThan -> a
"OpSGreaterThan"
  Op
OpUGreaterThanEqual -> a
"OpUGreaterThanEqual"
  Op
OpSGreaterThanEqual -> a
"OpSGreaterThanEqual"
  Op
OpULessThan -> a
"OpULessThan"
  Op
OpSLessThan -> a
"OpSLessThan"
  Op
OpULessThanEqual -> a
"OpULessThanEqual"
  Op
OpSLessThanEqual -> a
"OpSLessThanEqual"
  Op
OpFOrdEqual -> a
"OpFOrdEqual"
  Op
OpFUnordEqual -> a
"OpFUnordEqual"
  Op
OpFOrdNotEqual -> a
"OpFOrdNotEqual"
  Op
OpFUnordNotEqual -> a
"OpFUnordNotEqual"
  Op
OpFOrdLessThan -> a
"OpFOrdLessThan"
  Op
OpFUnordLessThan -> a
"OpFUnordLessThan"
  Op
OpFOrdGreaterThan -> a
"OpFOrdGreaterThan"
  Op
OpFUnordGreaterThan -> a
"OpFUnordGreaterThan"
  Op
OpFOrdLessThanEqual -> a
"OpFOrdLessThanEqual"
  Op
OpFUnordLessThanEqual -> a
"OpFUnordLessThanEqual"
  Op
OpFOrdGreaterThanEqual -> a
"OpFOrdGreaterThanEqual"
  Op
OpFUnordGreaterThanEqual -> a
"OpFUnordGreaterThanEqual"
  Op
OpShiftRightLogical -> a
"OpShiftRightLogical"
  Op
OpShiftRightArithmetic -> a
"OpShiftRightArithmetic"
  Op
OpShiftLeftLogical -> a
"OpShiftLeftLogical"
  Op
OpBitwiseOr -> a
"OpBitwiseOr"
  Op
OpBitwiseXor -> a
"OpBitwiseXor"
  Op
OpBitwiseAnd -> a
"OpBitwiseAnd"
  Op
OpNot -> a
"OpNot"
  Op
OpBitFieldInsert -> a
"OpBitFieldInsert"
  Op
OpBitFieldSExtract -> a
"OpBitFieldSExtract"
  Op
OpBitFieldUExtract -> a
"OpBitFieldUExtract"
  Op
OpBitReverse -> a
"OpBitReverse"
  Op
OpBitCount -> a
"OpBitCount"
  Op
OpDPdx -> a
"OpDPdx"
  Op
OpDPdy -> a
"OpDPdy"
  Op
OpFwidth -> a
"OpFwidth"
  Op
OpDPdxFine -> a
"OpDPdxFine"
  Op
OpDPdyFine -> a
"OpDPdyFine"
  Op
OpFwidthFine -> a
"OpFwidthFine"
  Op
OpDPdxCoarse -> a
"OpDPdxCoarse"
  Op
OpDPdyCoarse -> a
"OpDPdyCoarse"
  Op
OpFwidthCoarse -> a
"OpFwidthCoarse"
  Op
OpEmitVertex -> a
"OpEmitVertex"
  Op
OpEndPrimitive -> a
"OpEndPrimitive"
  Op
OpEmitStreamVertex -> a
"OpEmitStreamVertex"
  Op
OpEndStreamPrimitive -> a
"OpEndStreamPrimitive"
  Op
OpControlBarrier -> a
"OpControlBarrier"
  Op
OpMemoryBarrier -> a
"OpMemoryBarrier"
  Op
OpAtomicLoad -> a
"OpAtomicLoad"
  Op
OpAtomicStore -> a
"OpAtomicStore"
  Op
OpAtomicExchange -> a
"OpAtomicExchange"
  Op
OpAtomicCompareExchange -> a
"OpAtomicCompareExchange"
  Op
OpAtomicCompareExchangeWeak -> a
"OpAtomicCompareExchangeWeak"
  Op
OpAtomicIIncrement -> a
"OpAtomicIIncrement"
  Op
OpAtomicIDecrement -> a
"OpAtomicIDecrement"
  Op
OpAtomicIAdd -> a
"OpAtomicIAdd"
  Op
OpAtomicISub -> a
"OpAtomicISub"
  Op
OpAtomicSMin -> a
"OpAtomicSMin"
  Op
OpAtomicUMin -> a
"OpAtomicUMin"
  Op
OpAtomicSMax -> a
"OpAtomicSMax"
  Op
OpAtomicUMax -> a
"OpAtomicUMax"
  Op
OpAtomicAnd -> a
"OpAtomicAnd"
  Op
OpAtomicOr -> a
"OpAtomicOr"
  Op
OpAtomicXor -> a
"OpAtomicXor"
  Op
OpPhi -> a
"OpPhi"
  Op
OpLoopMerge -> a
"OpLoopMerge"
  Op
OpSelectionMerge -> a
"OpSelectionMerge"
  Op
OpLabel -> a
"OpLabel"
  Op
OpBranch -> a
"OpBranch"
  Op
OpBranchConditional -> a
"OpBranchConditional"
  Op
OpSwitch -> a
"OpSwitch"
  Op
OpKill -> a
"OpKill"
  Op
OpReturn -> a
"OpReturn"
  Op
OpReturnValue -> a
"OpReturnValue"
  Op
OpUnreachable -> a
"OpUnreachable"
  Op
OpLifetimeStart -> a
"OpLifetimeStart"
  Op
OpLifetimeStop -> a
"OpLifetimeStop"
  Op
OpGroupAsyncCopy -> a
"OpGroupAsyncCopy"
  Op
OpGroupWaitEvents -> a
"OpGroupWaitEvents"
  Op
OpGroupAll -> a
"OpGroupAll"
  Op
OpGroupAny -> a
"OpGroupAny"
  Op
OpGroupBroadcast -> a
"OpGroupBroadcast"
  Op
OpGroupIAdd -> a
"OpGroupIAdd"
  Op
OpGroupFAdd -> a
"OpGroupFAdd"
  Op
OpGroupFMin -> a
"OpGroupFMin"
  Op
OpGroupUMin -> a
"OpGroupUMin"
  Op
OpGroupSMin -> a
"OpGroupSMin"
  Op
OpGroupFMax -> a
"OpGroupFMax"
  Op
OpGroupUMax -> a
"OpGroupUMax"
  Op
OpGroupSMax -> a
"OpGroupSMax"
  Op
OpReadPipe -> a
"OpReadPipe"
  Op
OpWritePipe -> a
"OpWritePipe"
  Op
OpReservedReadPipe -> a
"OpReservedReadPipe"
  Op
OpReservedWritePipe -> a
"OpReservedWritePipe"
  Op
OpReserveReadPipePackets -> a
"OpReserveReadPipePackets"
  Op
OpReserveWritePipePackets -> a
"OpReserveWritePipePackets"
  Op
OpCommitReadPipe -> a
"OpCommitReadPipe"
  Op
OpCommitWritePipe -> a
"OpCommitWritePipe"
  Op
OpIsValidReserveId -> a
"OpIsValidReserveId"
  Op
OpGetNumPipePackets -> a
"OpGetNumPipePackets"
  Op
OpGetMaxPipePackets -> a
"OpGetMaxPipePackets"
  Op
OpGroupReserveReadPipePackets -> a
"OpGroupReserveReadPipePackets"
  Op
OpGroupReserveWritePipePackets -> a
"OpGroupReserveWritePipePackets"
  Op
OpGroupCommitReadPipe -> a
"OpGroupCommitReadPipe"
  Op
OpGroupCommitWritePipe -> a
"OpGroupCommitWritePipe"
  Op
OpEnqueueMarker -> a
"OpEnqueueMarker"
  Op
OpEnqueueKernel -> a
"OpEnqueueKernel"
  Op
OpGetKernelNDrangeSubGroupCount -> a
"OpGetKernelNDrangeSubGroupCount"
  Op
OpGetKernelNDrangeMaxSubGroupSize -> a
"OpGetKernelNDrangeMaxSubGroupSize"
  Op
OpGetKernelWorkGroupSize -> a
"OpGetKernelWorkGroupSize"
  Op
OpGetKernelPreferredWorkGroupSizeMultiple -> a
"OpGetKernelPreferredWorkGroupSizeMultiple"
  Op
OpRetainEvent -> a
"OpRetainEvent"
  Op
OpReleaseEvent -> a
"OpReleaseEvent"
  Op
OpCreateUserEvent -> a
"OpCreateUserEvent"
  Op
OpIsValidEvent -> a
"OpIsValidEvent"
  Op
OpSetUserEventStatus -> a
"OpSetUserEventStatus"
  Op
OpCaptureEventProfilingInfo -> a
"OpCaptureEventProfilingInfo"
  Op
OpGetDefaultQueue -> a
"OpGetDefaultQueue"
  Op
OpBuildNDRange -> a
"OpBuildNDRange"
  Op
OpImageSparseSampleImplicitLod -> a
"OpImageSparseSampleImplicitLod"
  Op
OpImageSparseSampleExplicitLod -> a
"OpImageSparseSampleExplicitLod"
  Op
OpImageSparseSampleDrefImplicitLod -> a
"OpImageSparseSampleDrefImplicitLod"
  Op
OpImageSparseSampleDrefExplicitLod -> a
"OpImageSparseSampleDrefExplicitLod"
  Op
OpImageSparseSampleProjImplicitLod -> a
"OpImageSparseSampleProjImplicitLod"
  Op
OpImageSparseSampleProjExplicitLod -> a
"OpImageSparseSampleProjExplicitLod"
  Op
OpImageSparseSampleProjDrefImplicitLod -> a
"OpImageSparseSampleProjDrefImplicitLod"
  Op
OpImageSparseSampleProjDrefExplicitLod -> a
"OpImageSparseSampleProjDrefExplicitLod"
  Op
OpImageSparseFetch -> a
"OpImageSparseFetch"
  Op
OpImageSparseGather -> a
"OpImageSparseGather"
  Op
OpImageSparseDrefGather -> a
"OpImageSparseDrefGather"
  Op
OpImageSparseTexelsResident -> a
"OpImageSparseTexelsResident"
  Op
OpNoLine -> a
"OpNoLine"
  Op
OpAtomicFlagTestAndSet -> a
"OpAtomicFlagTestAndSet"
  Op
OpAtomicFlagClear -> a
"OpAtomicFlagClear"
  Op
OpImageSparseRead -> a
"OpImageSparseRead"
  Op
OpSizeOf -> a
"OpSizeOf"
  Op
OpTypePipeStorage -> a
"OpTypePipeStorage"
  Op
OpConstantPipeStorage -> a
"OpConstantPipeStorage"
  Op
OpCreatePipeFromPipeStorage -> a
"OpCreatePipeFromPipeStorage"
  Op
OpGetKernelLocalSizeForSubgroupCount -> a
"OpGetKernelLocalSizeForSubgroupCount"
  Op
OpGetKernelMaxNumSubgroups -> a
"OpGetKernelMaxNumSubgroups"
  Op
OpTypeNamedBarrier -> a
"OpTypeNamedBarrier"
  Op
OpNamedBarrierInitialize -> a
"OpNamedBarrierInitialize"
  Op
OpMemoryNamedBarrier -> a
"OpMemoryNamedBarrier"
  Op
OpModuleProcessed -> a
"OpModuleProcessed"
  Op
OpExecutionModeId -> a
"OpExecutionModeId"
  Op
OpDecorateId -> a
"OpDecorateId"
  Op
OpGroupNonUniformElect -> a
"OpGroupNonUniformElect"
  Op
OpGroupNonUniformAll -> a
"OpGroupNonUniformAll"
  Op
OpGroupNonUniformAny -> a
"OpGroupNonUniformAny"
  Op
OpGroupNonUniformAllEqual -> a
"OpGroupNonUniformAllEqual"
  Op
OpGroupNonUniformBroadcast -> a
"OpGroupNonUniformBroadcast"
  Op
OpGroupNonUniformBroadcastFirst -> a
"OpGroupNonUniformBroadcastFirst"
  Op
OpGroupNonUniformBallot -> a
"OpGroupNonUniformBallot"
  Op
OpGroupNonUniformInverseBallot -> a
"OpGroupNonUniformInverseBallot"
  Op
OpGroupNonUniformBallotBitExtract -> a
"OpGroupNonUniformBallotBitExtract"
  Op
OpGroupNonUniformBallotBitCount -> a
"OpGroupNonUniformBallotBitCount"
  Op
OpGroupNonUniformBallotFindLSB -> a
"OpGroupNonUniformBallotFindLSB"
  Op
OpGroupNonUniformBallotFindMSB -> a
"OpGroupNonUniformBallotFindMSB"
  Op
OpGroupNonUniformShuffle -> a
"OpGroupNonUniformShuffle"
  Op
OpGroupNonUniformShuffleXor -> a
"OpGroupNonUniformShuffleXor"
  Op
OpGroupNonUniformShuffleUp -> a
"OpGroupNonUniformShuffleUp"
  Op
OpGroupNonUniformShuffleDown -> a
"OpGroupNonUniformShuffleDown"
  Op
OpGroupNonUniformIAdd -> a
"OpGroupNonUniformIAdd"
  Op
OpGroupNonUniformFAdd -> a
"OpGroupNonUniformFAdd"
  Op
OpGroupNonUniformIMul -> a
"OpGroupNonUniformIMul"
  Op
OpGroupNonUniformFMul -> a
"OpGroupNonUniformFMul"
  Op
OpGroupNonUniformSMin -> a
"OpGroupNonUniformSMin"
  Op
OpGroupNonUniformUMin -> a
"OpGroupNonUniformUMin"
  Op
OpGroupNonUniformFMin -> a
"OpGroupNonUniformFMin"
  Op
OpGroupNonUniformSMax -> a
"OpGroupNonUniformSMax"
  Op
OpGroupNonUniformUMax -> a
"OpGroupNonUniformUMax"
  Op
OpGroupNonUniformFMax -> a
"OpGroupNonUniformFMax"
  Op
OpGroupNonUniformBitwiseAnd -> a
"OpGroupNonUniformBitwiseAnd"
  Op
OpGroupNonUniformBitwiseOr -> a
"OpGroupNonUniformBitwiseOr"
  Op
OpGroupNonUniformBitwiseXor -> a
"OpGroupNonUniformBitwiseXor"
  Op
OpGroupNonUniformLogicalAnd -> a
"OpGroupNonUniformLogicalAnd"
  Op
OpGroupNonUniformLogicalOr -> a
"OpGroupNonUniformLogicalOr"
  Op
OpGroupNonUniformLogicalXor -> a
"OpGroupNonUniformLogicalXor"
  Op
OpGroupNonUniformQuadBroadcast -> a
"OpGroupNonUniformQuadBroadcast"
  Op
OpGroupNonUniformQuadSwap -> a
"OpGroupNonUniformQuadSwap"
  Op
OpCopyLogical -> a
"OpCopyLogical"
  Op
OpPtrEqual -> a
"OpPtrEqual"
  Op
OpPtrNotEqual -> a
"OpPtrNotEqual"
  Op
OpPtrDiff -> a
"OpPtrDiff"
  Op
OpTerminateInvocation -> a
"OpTerminateInvocation"
  Op
OpSubgroupBallotKHR -> a
"OpSubgroupBallotKHR"
  Op
OpSubgroupFirstInvocationKHR -> a
"OpSubgroupFirstInvocationKHR"
  Op
OpSubgroupAllKHR -> a
"OpSubgroupAllKHR"
  Op
OpSubgroupAnyKHR -> a
"OpSubgroupAnyKHR"
  Op
OpSubgroupAllEqualKHR -> a
"OpSubgroupAllEqualKHR"
  Op
OpGroupNonUniformRotateKHR -> a
"OpGroupNonUniformRotateKHR"
  Op
OpSubgroupReadInvocationKHR -> a
"OpSubgroupReadInvocationKHR"
  Op
OpTraceRayKHR -> a
"OpTraceRayKHR"
  Op
OpExecuteCallableKHR -> a
"OpExecuteCallableKHR"
  Op
OpConvertUToAccelerationStructureKHR -> a
"OpConvertUToAccelerationStructureKHR"
  Op
OpIgnoreIntersectionKHR -> a
"OpIgnoreIntersectionKHR"
  Op
OpTerminateRayKHR -> a
"OpTerminateRayKHR"
  Op
OpSDot -> a
"OpSDot"
  Op
OpSDotKHR -> a
"OpSDotKHR"
  Op
OpUDot -> a
"OpUDot"
  Op
OpUDotKHR -> a
"OpUDotKHR"
  Op
OpSUDot -> a
"OpSUDot"
  Op
OpSUDotKHR -> a
"OpSUDotKHR"
  Op
OpSDotAccSat -> a
"OpSDotAccSat"
  Op
OpSDotAccSatKHR -> a
"OpSDotAccSatKHR"
  Op
OpUDotAccSat -> a
"OpUDotAccSat"
  Op
OpUDotAccSatKHR -> a
"OpUDotAccSatKHR"
  Op
OpSUDotAccSat -> a
"OpSUDotAccSat"
  Op
OpSUDotAccSatKHR -> a
"OpSUDotAccSatKHR"
  Op
OpTypeRayQueryKHR -> a
"OpTypeRayQueryKHR"
  Op
OpRayQueryInitializeKHR -> a
"OpRayQueryInitializeKHR"
  Op
OpRayQueryTerminateKHR -> a
"OpRayQueryTerminateKHR"
  Op
OpRayQueryGenerateIntersectionKHR -> a
"OpRayQueryGenerateIntersectionKHR"
  Op
OpRayQueryConfirmIntersectionKHR -> a
"OpRayQueryConfirmIntersectionKHR"
  Op
OpRayQueryProceedKHR -> a
"OpRayQueryProceedKHR"
  Op
OpRayQueryGetIntersectionTypeKHR -> a
"OpRayQueryGetIntersectionTypeKHR"
  Op
OpGroupIAddNonUniformAMD -> a
"OpGroupIAddNonUniformAMD"
  Op
OpGroupFAddNonUniformAMD -> a
"OpGroupFAddNonUniformAMD"
  Op
OpGroupFMinNonUniformAMD -> a
"OpGroupFMinNonUniformAMD"
  Op
OpGroupUMinNonUniformAMD -> a
"OpGroupUMinNonUniformAMD"
  Op
OpGroupSMinNonUniformAMD -> a
"OpGroupSMinNonUniformAMD"
  Op
OpGroupFMaxNonUniformAMD -> a
"OpGroupFMaxNonUniformAMD"
  Op
OpGroupUMaxNonUniformAMD -> a
"OpGroupUMaxNonUniformAMD"
  Op
OpGroupSMaxNonUniformAMD -> a
"OpGroupSMaxNonUniformAMD"
  Op
OpFragmentMaskFetchAMD -> a
"OpFragmentMaskFetchAMD"
  Op
OpFragmentFetchAMD -> a
"OpFragmentFetchAMD"
  Op
OpReadClockKHR -> a
"OpReadClockKHR"
  Op
OpHitObjectRecordHitMotionNV -> a
"OpHitObjectRecordHitMotionNV"
  Op
OpHitObjectRecordHitWithIndexMotionNV -> a
"OpHitObjectRecordHitWithIndexMotionNV"
  Op
OpHitObjectRecordMissMotionNV -> a
"OpHitObjectRecordMissMotionNV"
  Op
OpHitObjectGetWorldToObjectNV -> a
"OpHitObjectGetWorldToObjectNV"
  Op
OpHitObjectGetObjectToWorldNV -> a
"OpHitObjectGetObjectToWorldNV"
  Op
OpHitObjectGetObjectRayDirectionNV -> a
"OpHitObjectGetObjectRayDirectionNV"
  Op
OpHitObjectGetObjectRayOriginNV -> a
"OpHitObjectGetObjectRayOriginNV"
  Op
OpHitObjectTraceRayMotionNV -> a
"OpHitObjectTraceRayMotionNV"
  Op
OpHitObjectGetShaderRecordBufferHandleNV -> a
"OpHitObjectGetShaderRecordBufferHandleNV"
  Op
OpHitObjectGetShaderBindingTableRecordIndexNV -> a
"OpHitObjectGetShaderBindingTableRecordIndexNV"
  Op
OpHitObjectRecordEmptyNV -> a
"OpHitObjectRecordEmptyNV"
  Op
OpHitObjectTraceRayNV -> a
"OpHitObjectTraceRayNV"
  Op
OpHitObjectRecordHitNV -> a
"OpHitObjectRecordHitNV"
  Op
OpHitObjectRecordHitWithIndexNV -> a
"OpHitObjectRecordHitWithIndexNV"
  Op
OpHitObjectRecordMissNV -> a
"OpHitObjectRecordMissNV"
  Op
OpHitObjectExecuteShaderNV -> a
"OpHitObjectExecuteShaderNV"
  Op
OpHitObjectGetCurrentTimeNV -> a
"OpHitObjectGetCurrentTimeNV"
  Op
OpHitObjectGetAttributesNV -> a
"OpHitObjectGetAttributesNV"
  Op
OpHitObjectGetHitKindNV -> a
"OpHitObjectGetHitKindNV"
  Op
OpHitObjectGetPrimitiveIndexNV -> a
"OpHitObjectGetPrimitiveIndexNV"
  Op
OpHitObjectGetGeometryIndexNV -> a
"OpHitObjectGetGeometryIndexNV"
  Op
OpHitObjectGetInstanceIdNV -> a
"OpHitObjectGetInstanceIdNV"
  Op
OpHitObjectGetInstanceCustomIndexNV -> a
"OpHitObjectGetInstanceCustomIndexNV"
  Op
OpHitObjectGetWorldRayDirectionNV -> a
"OpHitObjectGetWorldRayDirectionNV"
  Op
OpHitObjectGetWorldRayOriginNV -> a
"OpHitObjectGetWorldRayOriginNV"
  Op
OpHitObjectGetRayTMaxNV -> a
"OpHitObjectGetRayTMaxNV"
  Op
OpHitObjectGetRayTMinNV -> a
"OpHitObjectGetRayTMinNV"
  Op
OpHitObjectIsEmptyNV -> a
"OpHitObjectIsEmptyNV"
  Op
OpHitObjectIsHitNV -> a
"OpHitObjectIsHitNV"
  Op
OpHitObjectIsMissNV -> a
"OpHitObjectIsMissNV"
  Op
OpReorderThreadWithHitObjectNV -> a
"OpReorderThreadWithHitObjectNV"
  Op
OpReorderThreadWithHintNV -> a
"OpReorderThreadWithHintNV"
  Op
OpTypeHitObjectNV -> a
"OpTypeHitObjectNV"
  Op
OpImageSampleFootprintNV -> a
"OpImageSampleFootprintNV"
  Op
OpEmitMeshTasksEXT -> a
"OpEmitMeshTasksEXT"
  Op
OpSetMeshOutputsEXT -> a
"OpSetMeshOutputsEXT"
  Op
OpGroupNonUniformPartitionNV -> a
"OpGroupNonUniformPartitionNV"
  Op
OpWritePackedPrimitiveIndices4x8NV -> a
"OpWritePackedPrimitiveIndices4x8NV"
  Op
OpReportIntersectionKHR -> a
"OpReportIntersectionKHR"
  Op
OpReportIntersectionNV -> a
"OpReportIntersectionNV"
  Op
OpIgnoreIntersectionNV -> a
"OpIgnoreIntersectionNV"
  Op
OpTerminateRayNV -> a
"OpTerminateRayNV"
  Op
OpTraceNV -> a
"OpTraceNV"
  Op
OpTraceMotionNV -> a
"OpTraceMotionNV"
  Op
OpTraceRayMotionNV -> a
"OpTraceRayMotionNV"
  Op
OpTypeAccelerationStructureKHR -> a
"OpTypeAccelerationStructureKHR"
  Op
OpTypeAccelerationStructureNV -> a
"OpTypeAccelerationStructureNV"
  Op
OpExecuteCallableNV -> a
"OpExecuteCallableNV"
  Op
OpTypeCooperativeMatrixNV -> a
"OpTypeCooperativeMatrixNV"
  Op
OpCooperativeMatrixLoadNV -> a
"OpCooperativeMatrixLoadNV"
  Op
OpCooperativeMatrixStoreNV -> a
"OpCooperativeMatrixStoreNV"
  Op
OpCooperativeMatrixMulAddNV -> a
"OpCooperativeMatrixMulAddNV"
  Op
OpCooperativeMatrixLengthNV -> a
"OpCooperativeMatrixLengthNV"
  Op
OpBeginInvocationInterlockEXT -> a
"OpBeginInvocationInterlockEXT"
  Op
OpEndInvocationInterlockEXT -> a
"OpEndInvocationInterlockEXT"
  Op
OpDemoteToHelperInvocation -> a
"OpDemoteToHelperInvocation"
  Op
OpDemoteToHelperInvocationEXT -> a
"OpDemoteToHelperInvocationEXT"
  Op
OpIsHelperInvocationEXT -> a
"OpIsHelperInvocationEXT"
  Op
OpConvertUToImageNV -> a
"OpConvertUToImageNV"
  Op
OpConvertUToSamplerNV -> a
"OpConvertUToSamplerNV"
  Op
OpConvertImageToUNV -> a
"OpConvertImageToUNV"
  Op
OpConvertSamplerToUNV -> a
"OpConvertSamplerToUNV"
  Op
OpConvertUToSampledImageNV -> a
"OpConvertUToSampledImageNV"
  Op
OpConvertSampledImageToUNV -> a
"OpConvertSampledImageToUNV"
  Op
OpSamplerImageAddressingModeNV -> a
"OpSamplerImageAddressingModeNV"
  Op
OpSubgroupShuffleINTEL -> a
"OpSubgroupShuffleINTEL"
  Op
OpSubgroupShuffleDownINTEL -> a
"OpSubgroupShuffleDownINTEL"
  Op
OpSubgroupShuffleUpINTEL -> a
"OpSubgroupShuffleUpINTEL"
  Op
OpSubgroupShuffleXorINTEL -> a
"OpSubgroupShuffleXorINTEL"
  Op
OpSubgroupBlockReadINTEL -> a
"OpSubgroupBlockReadINTEL"
  Op
OpSubgroupBlockWriteINTEL -> a
"OpSubgroupBlockWriteINTEL"
  Op
OpSubgroupImageBlockReadINTEL -> a
"OpSubgroupImageBlockReadINTEL"
  Op
OpSubgroupImageBlockWriteINTEL -> a
"OpSubgroupImageBlockWriteINTEL"
  Op
OpSubgroupImageMediaBlockReadINTEL -> a
"OpSubgroupImageMediaBlockReadINTEL"
  Op
OpSubgroupImageMediaBlockWriteINTEL -> a
"OpSubgroupImageMediaBlockWriteINTEL"
  Op
OpUCountLeadingZerosINTEL -> a
"OpUCountLeadingZerosINTEL"
  Op
OpUCountTrailingZerosINTEL -> a
"OpUCountTrailingZerosINTEL"
  Op
OpAbsISubINTEL -> a
"OpAbsISubINTEL"
  Op
OpAbsUSubINTEL -> a
"OpAbsUSubINTEL"
  Op
OpIAddSatINTEL -> a
"OpIAddSatINTEL"
  Op
OpUAddSatINTEL -> a
"OpUAddSatINTEL"
  Op
OpIAverageINTEL -> a
"OpIAverageINTEL"
  Op
OpUAverageINTEL -> a
"OpUAverageINTEL"
  Op
OpIAverageRoundedINTEL -> a
"OpIAverageRoundedINTEL"
  Op
OpUAverageRoundedINTEL -> a
"OpUAverageRoundedINTEL"
  Op
OpISubSatINTEL -> a
"OpISubSatINTEL"
  Op
OpUSubSatINTEL -> a
"OpUSubSatINTEL"
  Op
OpIMul32x16INTEL -> a
"OpIMul32x16INTEL"
  Op
OpUMul32x16INTEL -> a
"OpUMul32x16INTEL"
  Op
OpConstantFunctionPointerINTEL -> a
"OpConstantFunctionPointerINTEL"
  Op
OpFunctionPointerCallINTEL -> a
"OpFunctionPointerCallINTEL"
  Op
OpAsmTargetINTEL -> a
"OpAsmTargetINTEL"
  Op
OpAsmINTEL -> a
"OpAsmINTEL"
  Op
OpAsmCallINTEL -> a
"OpAsmCallINTEL"
  Op
OpAtomicFMinEXT -> a
"OpAtomicFMinEXT"
  Op
OpAtomicFMaxEXT -> a
"OpAtomicFMaxEXT"
  Op
OpAssumeTrueKHR -> a
"OpAssumeTrueKHR"
  Op
OpExpectKHR -> a
"OpExpectKHR"
  Op
OpDecorateString -> a
"OpDecorateString"
  Op
OpDecorateStringGOOGLE -> a
"OpDecorateStringGOOGLE"
  Op
OpMemberDecorateString -> a
"OpMemberDecorateString"
  Op
OpMemberDecorateStringGOOGLE -> a
"OpMemberDecorateStringGOOGLE"
  Op
OpVmeImageINTEL -> a
"OpVmeImageINTEL"
  Op
OpTypeVmeImageINTEL -> a
"OpTypeVmeImageINTEL"
  Op
OpTypeAvcImePayloadINTEL -> a
"OpTypeAvcImePayloadINTEL"
  Op
OpTypeAvcRefPayloadINTEL -> a
"OpTypeAvcRefPayloadINTEL"
  Op
OpTypeAvcSicPayloadINTEL -> a
"OpTypeAvcSicPayloadINTEL"
  Op
OpTypeAvcMcePayloadINTEL -> a
"OpTypeAvcMcePayloadINTEL"
  Op
OpTypeAvcMceResultINTEL -> a
"OpTypeAvcMceResultINTEL"
  Op
OpTypeAvcImeResultINTEL -> a
"OpTypeAvcImeResultINTEL"
  Op
OpTypeAvcImeResultSingleReferenceStreamoutINTEL -> a
"OpTypeAvcImeResultSingleReferenceStreamoutINTEL"
  Op
OpTypeAvcImeResultDualReferenceStreamoutINTEL -> a
"OpTypeAvcImeResultDualReferenceStreamoutINTEL"
  Op
OpTypeAvcImeSingleReferenceStreaminINTEL -> a
"OpTypeAvcImeSingleReferenceStreaminINTEL"
  Op
OpTypeAvcImeDualReferenceStreaminINTEL -> a
"OpTypeAvcImeDualReferenceStreaminINTEL"
  Op
OpTypeAvcRefResultINTEL -> a
"OpTypeAvcRefResultINTEL"
  Op
OpTypeAvcSicResultINTEL -> a
"OpTypeAvcSicResultINTEL"
  Op
OpSubgroupAvcMceGetDefaultInterBaseMultiReferencePenaltyINTEL -> a
"OpSubgroupAvcMceGetDefaultInterBaseMultiReferencePenaltyINTEL"
  Op
OpSubgroupAvcMceSetInterBaseMultiReferencePenaltyINTEL -> a
"OpSubgroupAvcMceSetInterBaseMultiReferencePenaltyINTEL"
  Op
OpSubgroupAvcMceGetDefaultInterShapePenaltyINTEL -> a
"OpSubgroupAvcMceGetDefaultInterShapePenaltyINTEL"
  Op
OpSubgroupAvcMceSetInterShapePenaltyINTEL -> a
"OpSubgroupAvcMceSetInterShapePenaltyINTEL"
  Op
OpSubgroupAvcMceGetDefaultInterDirectionPenaltyINTEL -> a
"OpSubgroupAvcMceGetDefaultInterDirectionPenaltyINTEL"
  Op
OpSubgroupAvcMceSetInterDirectionPenaltyINTEL -> a
"OpSubgroupAvcMceSetInterDirectionPenaltyINTEL"
  Op
OpSubgroupAvcMceGetDefaultIntraLumaShapePenaltyINTEL -> a
"OpSubgroupAvcMceGetDefaultIntraLumaShapePenaltyINTEL"
  Op
OpSubgroupAvcMceGetDefaultInterMotionVectorCostTableINTEL -> a
"OpSubgroupAvcMceGetDefaultInterMotionVectorCostTableINTEL"
  Op
OpSubgroupAvcMceGetDefaultHighPenaltyCostTableINTEL -> a
"OpSubgroupAvcMceGetDefaultHighPenaltyCostTableINTEL"
  Op
OpSubgroupAvcMceGetDefaultMediumPenaltyCostTableINTEL -> a
"OpSubgroupAvcMceGetDefaultMediumPenaltyCostTableINTEL"
  Op
OpSubgroupAvcMceGetDefaultLowPenaltyCostTableINTEL -> a
"OpSubgroupAvcMceGetDefaultLowPenaltyCostTableINTEL"
  Op
OpSubgroupAvcMceSetMotionVectorCostFunctionINTEL -> a
"OpSubgroupAvcMceSetMotionVectorCostFunctionINTEL"
  Op
OpSubgroupAvcMceGetDefaultIntraLumaModePenaltyINTEL -> a
"OpSubgroupAvcMceGetDefaultIntraLumaModePenaltyINTEL"
  Op
OpSubgroupAvcMceGetDefaultNonDcLumaIntraPenaltyINTEL -> a
"OpSubgroupAvcMceGetDefaultNonDcLumaIntraPenaltyINTEL"
  Op
OpSubgroupAvcMceGetDefaultIntraChromaModeBasePenaltyINTEL -> a
"OpSubgroupAvcMceGetDefaultIntraChromaModeBasePenaltyINTEL"
  Op
OpSubgroupAvcMceSetAcOnlyHaarINTEL -> a
"OpSubgroupAvcMceSetAcOnlyHaarINTEL"
  Op
OpSubgroupAvcMceSetSourceInterlacedFieldPolarityINTEL -> a
"OpSubgroupAvcMceSetSourceInterlacedFieldPolarityINTEL"
  Op
OpSubgroupAvcMceSetSingleReferenceInterlacedFieldPolarityINTEL -> a
"OpSubgroupAvcMceSetSingleReferenceInterlacedFieldPolarityINTEL"
  Op
OpSubgroupAvcMceSetDualReferenceInterlacedFieldPolaritiesINTEL -> a
"OpSubgroupAvcMceSetDualReferenceInterlacedFieldPolaritiesINTEL"
  Op
OpSubgroupAvcMceConvertToImePayloadINTEL -> a
"OpSubgroupAvcMceConvertToImePayloadINTEL"
  Op
OpSubgroupAvcMceConvertToImeResultINTEL -> a
"OpSubgroupAvcMceConvertToImeResultINTEL"
  Op
OpSubgroupAvcMceConvertToRefPayloadINTEL -> a
"OpSubgroupAvcMceConvertToRefPayloadINTEL"
  Op
OpSubgroupAvcMceConvertToRefResultINTEL -> a
"OpSubgroupAvcMceConvertToRefResultINTEL"
  Op
OpSubgroupAvcMceConvertToSicPayloadINTEL -> a
"OpSubgroupAvcMceConvertToSicPayloadINTEL"
  Op
OpSubgroupAvcMceConvertToSicResultINTEL -> a
"OpSubgroupAvcMceConvertToSicResultINTEL"
  Op
OpSubgroupAvcMceGetMotionVectorsINTEL -> a
"OpSubgroupAvcMceGetMotionVectorsINTEL"
  Op
OpSubgroupAvcMceGetInterDistortionsINTEL -> a
"OpSubgroupAvcMceGetInterDistortionsINTEL"
  Op
OpSubgroupAvcMceGetBestInterDistortionsINTEL -> a
"OpSubgroupAvcMceGetBestInterDistortionsINTEL"
  Op
OpSubgroupAvcMceGetInterMajorShapeINTEL -> a
"OpSubgroupAvcMceGetInterMajorShapeINTEL"
  Op
OpSubgroupAvcMceGetInterMinorShapeINTEL -> a
"OpSubgroupAvcMceGetInterMinorShapeINTEL"
  Op
OpSubgroupAvcMceGetInterDirectionsINTEL -> a
"OpSubgroupAvcMceGetInterDirectionsINTEL"
  Op
OpSubgroupAvcMceGetInterMotionVectorCountINTEL -> a
"OpSubgroupAvcMceGetInterMotionVectorCountINTEL"
  Op
OpSubgroupAvcMceGetInterReferenceIdsINTEL -> a
"OpSubgroupAvcMceGetInterReferenceIdsINTEL"
  Op
OpSubgroupAvcMceGetInterReferenceInterlacedFieldPolaritiesINTEL -> a
"OpSubgroupAvcMceGetInterReferenceInterlacedFieldPolaritiesINTEL"
  Op
OpSubgroupAvcImeInitializeINTEL -> a
"OpSubgroupAvcImeInitializeINTEL"
  Op
OpSubgroupAvcImeSetSingleReferenceINTEL -> a
"OpSubgroupAvcImeSetSingleReferenceINTEL"
  Op
OpSubgroupAvcImeSetDualReferenceINTEL -> a
"OpSubgroupAvcImeSetDualReferenceINTEL"
  Op
OpSubgroupAvcImeRefWindowSizeINTEL -> a
"OpSubgroupAvcImeRefWindowSizeINTEL"
  Op
OpSubgroupAvcImeAdjustRefOffsetINTEL -> a
"OpSubgroupAvcImeAdjustRefOffsetINTEL"
  Op
OpSubgroupAvcImeConvertToMcePayloadINTEL -> a
"OpSubgroupAvcImeConvertToMcePayloadINTEL"
  Op
OpSubgroupAvcImeSetMaxMotionVectorCountINTEL -> a
"OpSubgroupAvcImeSetMaxMotionVectorCountINTEL"
  Op
OpSubgroupAvcImeSetUnidirectionalMixDisableINTEL -> a
"OpSubgroupAvcImeSetUnidirectionalMixDisableINTEL"
  Op
OpSubgroupAvcImeSetEarlySearchTerminationThresholdINTEL -> a
"OpSubgroupAvcImeSetEarlySearchTerminationThresholdINTEL"
  Op
OpSubgroupAvcImeSetWeightedSadINTEL -> a
"OpSubgroupAvcImeSetWeightedSadINTEL"
  Op
OpSubgroupAvcImeEvaluateWithSingleReferenceINTEL -> a
"OpSubgroupAvcImeEvaluateWithSingleReferenceINTEL"
  Op
OpSubgroupAvcImeEvaluateWithDualReferenceINTEL -> a
"OpSubgroupAvcImeEvaluateWithDualReferenceINTEL"
  Op
OpSubgroupAvcImeEvaluateWithSingleReferenceStreaminINTEL -> a
"OpSubgroupAvcImeEvaluateWithSingleReferenceStreaminINTEL"
  Op
OpSubgroupAvcImeEvaluateWithDualReferenceStreaminINTEL -> a
"OpSubgroupAvcImeEvaluateWithDualReferenceStreaminINTEL"
  Op
OpSubgroupAvcImeEvaluateWithSingleReferenceStreamoutINTEL -> a
"OpSubgroupAvcImeEvaluateWithSingleReferenceStreamoutINTEL"
  Op
OpSubgroupAvcImeEvaluateWithDualReferenceStreamoutINTEL -> a
"OpSubgroupAvcImeEvaluateWithDualReferenceStreamoutINTEL"
  Op
OpSubgroupAvcImeEvaluateWithSingleReferenceStreaminoutINTEL -> a
"OpSubgroupAvcImeEvaluateWithSingleReferenceStreaminoutINTEL"
  Op
OpSubgroupAvcImeEvaluateWithDualReferenceStreaminoutINTEL -> a
"OpSubgroupAvcImeEvaluateWithDualReferenceStreaminoutINTEL"
  Op
OpSubgroupAvcImeConvertToMceResultINTEL -> a
"OpSubgroupAvcImeConvertToMceResultINTEL"
  Op
OpSubgroupAvcImeGetSingleReferenceStreaminINTEL -> a
"OpSubgroupAvcImeGetSingleReferenceStreaminINTEL"
  Op
OpSubgroupAvcImeGetDualReferenceStreaminINTEL -> a
"OpSubgroupAvcImeGetDualReferenceStreaminINTEL"
  Op
OpSubgroupAvcImeStripSingleReferenceStreamoutINTEL -> a
"OpSubgroupAvcImeStripSingleReferenceStreamoutINTEL"
  Op
OpSubgroupAvcImeStripDualReferenceStreamoutINTEL -> a
"OpSubgroupAvcImeStripDualReferenceStreamoutINTEL"
  Op
OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeMotionVectorsINTEL -> a
"OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeMotionVectorsINTEL"
  Op
OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeDistortionsINTEL -> a
"OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeDistortionsINTEL"
  Op
OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeReferenceIdsINTEL -> a
"OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeReferenceIdsINTEL"
  Op
OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeMotionVectorsINTEL -> a
"OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeMotionVectorsINTEL"
  Op
OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeDistortionsINTEL -> a
"OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeDistortionsINTEL"
  Op
OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeReferenceIdsINTEL -> a
"OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeReferenceIdsINTEL"
  Op
OpSubgroupAvcImeGetBorderReachedINTEL -> a
"OpSubgroupAvcImeGetBorderReachedINTEL"
  Op
OpSubgroupAvcImeGetTruncatedSearchIndicationINTEL -> a
"OpSubgroupAvcImeGetTruncatedSearchIndicationINTEL"
  Op
OpSubgroupAvcImeGetUnidirectionalEarlySearchTerminationINTEL -> a
"OpSubgroupAvcImeGetUnidirectionalEarlySearchTerminationINTEL"
  Op
OpSubgroupAvcImeGetWeightingPatternMinimumMotionVectorINTEL -> a
"OpSubgroupAvcImeGetWeightingPatternMinimumMotionVectorINTEL"
  Op
OpSubgroupAvcImeGetWeightingPatternMinimumDistortionINTEL -> a
"OpSubgroupAvcImeGetWeightingPatternMinimumDistortionINTEL"
  Op
OpSubgroupAvcFmeInitializeINTEL -> a
"OpSubgroupAvcFmeInitializeINTEL"
  Op
OpSubgroupAvcBmeInitializeINTEL -> a
"OpSubgroupAvcBmeInitializeINTEL"
  Op
OpSubgroupAvcRefConvertToMcePayloadINTEL -> a
"OpSubgroupAvcRefConvertToMcePayloadINTEL"
  Op
OpSubgroupAvcRefSetBidirectionalMixDisableINTEL -> a
"OpSubgroupAvcRefSetBidirectionalMixDisableINTEL"
  Op
OpSubgroupAvcRefSetBilinearFilterEnableINTEL -> a
"OpSubgroupAvcRefSetBilinearFilterEnableINTEL"
  Op
OpSubgroupAvcRefEvaluateWithSingleReferenceINTEL -> a
"OpSubgroupAvcRefEvaluateWithSingleReferenceINTEL"
  Op
OpSubgroupAvcRefEvaluateWithDualReferenceINTEL -> a
"OpSubgroupAvcRefEvaluateWithDualReferenceINTEL"
  Op
OpSubgroupAvcRefEvaluateWithMultiReferenceINTEL -> a
"OpSubgroupAvcRefEvaluateWithMultiReferenceINTEL"
  Op
OpSubgroupAvcRefEvaluateWithMultiReferenceInterlacedINTEL -> a
"OpSubgroupAvcRefEvaluateWithMultiReferenceInterlacedINTEL"
  Op
OpSubgroupAvcRefConvertToMceResultINTEL -> a
"OpSubgroupAvcRefConvertToMceResultINTEL"
  Op
OpSubgroupAvcSicInitializeINTEL -> a
"OpSubgroupAvcSicInitializeINTEL"
  Op
OpSubgroupAvcSicConfigureSkcINTEL -> a
"OpSubgroupAvcSicConfigureSkcINTEL"
  Op
OpSubgroupAvcSicConfigureIpeLumaINTEL -> a
"OpSubgroupAvcSicConfigureIpeLumaINTEL"
  Op
OpSubgroupAvcSicConfigureIpeLumaChromaINTEL -> a
"OpSubgroupAvcSicConfigureIpeLumaChromaINTEL"
  Op
OpSubgroupAvcSicGetMotionVectorMaskINTEL -> a
"OpSubgroupAvcSicGetMotionVectorMaskINTEL"
  Op
OpSubgroupAvcSicConvertToMcePayloadINTEL -> a
"OpSubgroupAvcSicConvertToMcePayloadINTEL"
  Op
OpSubgroupAvcSicSetIntraLumaShapePenaltyINTEL -> a
"OpSubgroupAvcSicSetIntraLumaShapePenaltyINTEL"
  Op
OpSubgroupAvcSicSetIntraLumaModeCostFunctionINTEL -> a
"OpSubgroupAvcSicSetIntraLumaModeCostFunctionINTEL"
  Op
OpSubgroupAvcSicSetIntraChromaModeCostFunctionINTEL -> a
"OpSubgroupAvcSicSetIntraChromaModeCostFunctionINTEL"
  Op
OpSubgroupAvcSicSetBilinearFilterEnableINTEL -> a
"OpSubgroupAvcSicSetBilinearFilterEnableINTEL"
  Op
OpSubgroupAvcSicSetSkcForwardTransformEnableINTEL -> a
"OpSubgroupAvcSicSetSkcForwardTransformEnableINTEL"
  Op
OpSubgroupAvcSicSetBlockBasedRawSkipSadINTEL -> a
"OpSubgroupAvcSicSetBlockBasedRawSkipSadINTEL"
  Op
OpSubgroupAvcSicEvaluateIpeINTEL -> a
"OpSubgroupAvcSicEvaluateIpeINTEL"
  Op
OpSubgroupAvcSicEvaluateWithSingleReferenceINTEL -> a
"OpSubgroupAvcSicEvaluateWithSingleReferenceINTEL"
  Op
OpSubgroupAvcSicEvaluateWithDualReferenceINTEL -> a
"OpSubgroupAvcSicEvaluateWithDualReferenceINTEL"
  Op
OpSubgroupAvcSicEvaluateWithMultiReferenceINTEL -> a
"OpSubgroupAvcSicEvaluateWithMultiReferenceINTEL"
  Op
OpSubgroupAvcSicEvaluateWithMultiReferenceInterlacedINTEL -> a
"OpSubgroupAvcSicEvaluateWithMultiReferenceInterlacedINTEL"
  Op
OpSubgroupAvcSicConvertToMceResultINTEL -> a
"OpSubgroupAvcSicConvertToMceResultINTEL"
  Op
OpSubgroupAvcSicGetIpeLumaShapeINTEL -> a
"OpSubgroupAvcSicGetIpeLumaShapeINTEL"
  Op
OpSubgroupAvcSicGetBestIpeLumaDistortionINTEL -> a
"OpSubgroupAvcSicGetBestIpeLumaDistortionINTEL"
  Op
OpSubgroupAvcSicGetBestIpeChromaDistortionINTEL -> a
"OpSubgroupAvcSicGetBestIpeChromaDistortionINTEL"
  Op
OpSubgroupAvcSicGetPackedIpeLumaModesINTEL -> a
"OpSubgroupAvcSicGetPackedIpeLumaModesINTEL"
  Op
OpSubgroupAvcSicGetIpeChromaModeINTEL -> a
"OpSubgroupAvcSicGetIpeChromaModeINTEL"
  Op
OpSubgroupAvcSicGetPackedSkcLumaCountThresholdINTEL -> a
"OpSubgroupAvcSicGetPackedSkcLumaCountThresholdINTEL"
  Op
OpSubgroupAvcSicGetPackedSkcLumaSumThresholdINTEL -> a
"OpSubgroupAvcSicGetPackedSkcLumaSumThresholdINTEL"
  Op
OpSubgroupAvcSicGetInterRawSadsINTEL -> a
"OpSubgroupAvcSicGetInterRawSadsINTEL"
  Op
OpVariableLengthArrayINTEL -> a
"OpVariableLengthArrayINTEL"
  Op
OpSaveMemoryINTEL -> a
"OpSaveMemoryINTEL"
  Op
OpRestoreMemoryINTEL -> a
"OpRestoreMemoryINTEL"
  Op
OpArbitraryFloatSinCosPiINTEL -> a
"OpArbitraryFloatSinCosPiINTEL"
  Op
OpArbitraryFloatCastINTEL -> a
"OpArbitraryFloatCastINTEL"
  Op
OpArbitraryFloatCastFromIntINTEL -> a
"OpArbitraryFloatCastFromIntINTEL"
  Op
OpArbitraryFloatCastToIntINTEL -> a
"OpArbitraryFloatCastToIntINTEL"
  Op
OpArbitraryFloatAddINTEL -> a
"OpArbitraryFloatAddINTEL"
  Op
OpArbitraryFloatSubINTEL -> a
"OpArbitraryFloatSubINTEL"
  Op
OpArbitraryFloatMulINTEL -> a
"OpArbitraryFloatMulINTEL"
  Op
OpArbitraryFloatDivINTEL -> a
"OpArbitraryFloatDivINTEL"
  Op
OpArbitraryFloatGTINTEL -> a
"OpArbitraryFloatGTINTEL"
  Op
OpArbitraryFloatGEINTEL -> a
"OpArbitraryFloatGEINTEL"
  Op
OpArbitraryFloatLTINTEL -> a
"OpArbitraryFloatLTINTEL"
  Op
OpArbitraryFloatLEINTEL -> a
"OpArbitraryFloatLEINTEL"
  Op
OpArbitraryFloatEQINTEL -> a
"OpArbitraryFloatEQINTEL"
  Op
OpArbitraryFloatRecipINTEL -> a
"OpArbitraryFloatRecipINTEL"
  Op
OpArbitraryFloatRSqrtINTEL -> a
"OpArbitraryFloatRSqrtINTEL"
  Op
OpArbitraryFloatCbrtINTEL -> a
"OpArbitraryFloatCbrtINTEL"
  Op
OpArbitraryFloatHypotINTEL -> a
"OpArbitraryFloatHypotINTEL"
  Op
OpArbitraryFloatSqrtINTEL -> a
"OpArbitraryFloatSqrtINTEL"
  Op
OpArbitraryFloatLogINTEL -> a
"OpArbitraryFloatLogINTEL"
  Op
OpArbitraryFloatLog2INTEL -> a
"OpArbitraryFloatLog2INTEL"
  Op
OpArbitraryFloatLog10INTEL -> a
"OpArbitraryFloatLog10INTEL"
  Op
OpArbitraryFloatLog1pINTEL -> a
"OpArbitraryFloatLog1pINTEL"
  Op
OpArbitraryFloatExpINTEL -> a
"OpArbitraryFloatExpINTEL"
  Op
OpArbitraryFloatExp2INTEL -> a
"OpArbitraryFloatExp2INTEL"
  Op
OpArbitraryFloatExp10INTEL -> a
"OpArbitraryFloatExp10INTEL"
  Op
OpArbitraryFloatExpm1INTEL -> a
"OpArbitraryFloatExpm1INTEL"
  Op
OpArbitraryFloatSinINTEL -> a
"OpArbitraryFloatSinINTEL"
  Op
OpArbitraryFloatCosINTEL -> a
"OpArbitraryFloatCosINTEL"
  Op
OpArbitraryFloatSinCosINTEL -> a
"OpArbitraryFloatSinCosINTEL"
  Op
OpArbitraryFloatSinPiINTEL -> a
"OpArbitraryFloatSinPiINTEL"
  Op
OpArbitraryFloatCosPiINTEL -> a
"OpArbitraryFloatCosPiINTEL"
  Op
OpArbitraryFloatASinINTEL -> a
"OpArbitraryFloatASinINTEL"
  Op
OpArbitraryFloatASinPiINTEL -> a
"OpArbitraryFloatASinPiINTEL"
  Op
OpArbitraryFloatACosINTEL -> a
"OpArbitraryFloatACosINTEL"
  Op
OpArbitraryFloatACosPiINTEL -> a
"OpArbitraryFloatACosPiINTEL"
  Op
OpArbitraryFloatATanINTEL -> a
"OpArbitraryFloatATanINTEL"
  Op
OpArbitraryFloatATanPiINTEL -> a
"OpArbitraryFloatATanPiINTEL"
  Op
OpArbitraryFloatATan2INTEL -> a
"OpArbitraryFloatATan2INTEL"
  Op
OpArbitraryFloatPowINTEL -> a
"OpArbitraryFloatPowINTEL"
  Op
OpArbitraryFloatPowRINTEL -> a
"OpArbitraryFloatPowRINTEL"
  Op
OpArbitraryFloatPowNINTEL -> a
"OpArbitraryFloatPowNINTEL"
  Op
OpLoopControlINTEL -> a
"OpLoopControlINTEL"
  Op
OpAliasDomainDeclINTEL -> a
"OpAliasDomainDeclINTEL"
  Op
OpAliasScopeDeclINTEL -> a
"OpAliasScopeDeclINTEL"
  Op
OpAliasScopeListDeclINTEL -> a
"OpAliasScopeListDeclINTEL"
  Op
OpFixedSqrtINTEL -> a
"OpFixedSqrtINTEL"
  Op
OpFixedRecipINTEL -> a
"OpFixedRecipINTEL"
  Op
OpFixedRsqrtINTEL -> a
"OpFixedRsqrtINTEL"
  Op
OpFixedSinINTEL -> a
"OpFixedSinINTEL"
  Op
OpFixedCosINTEL -> a
"OpFixedCosINTEL"
  Op
OpFixedSinCosINTEL -> a
"OpFixedSinCosINTEL"
  Op
OpFixedSinPiINTEL -> a
"OpFixedSinPiINTEL"
  Op
OpFixedCosPiINTEL -> a
"OpFixedCosPiINTEL"
  Op
OpFixedSinCosPiINTEL -> a
"OpFixedSinCosPiINTEL"
  Op
OpFixedLogINTEL -> a
"OpFixedLogINTEL"
  Op
OpFixedExpINTEL -> a
"OpFixedExpINTEL"
  Op
OpPtrCastToCrossWorkgroupINTEL -> a
"OpPtrCastToCrossWorkgroupINTEL"
  Op
OpCrossWorkgroupCastToPtrINTEL -> a
"OpCrossWorkgroupCastToPtrINTEL"
  Op
OpReadPipeBlockingINTEL -> a
"OpReadPipeBlockingINTEL"
  Op
OpWritePipeBlockingINTEL -> a
"OpWritePipeBlockingINTEL"
  Op
OpFPGARegINTEL -> a
"OpFPGARegINTEL"
  Op
OpRayQueryGetRayTMinKHR -> a
"OpRayQueryGetRayTMinKHR"
  Op
OpRayQueryGetRayFlagsKHR -> a
"OpRayQueryGetRayFlagsKHR"
  Op
OpRayQueryGetIntersectionTKHR -> a
"OpRayQueryGetIntersectionTKHR"
  Op
OpRayQueryGetIntersectionInstanceCustomIndexKHR -> a
"OpRayQueryGetIntersectionInstanceCustomIndexKHR"
  Op
OpRayQueryGetIntersectionInstanceIdKHR -> a
"OpRayQueryGetIntersectionInstanceIdKHR"
  Op
OpRayQueryGetIntersectionInstanceShaderBindingTableRecordOffsetKHR -> a
"OpRayQueryGetIntersectionInstanceShaderBindingTableRecordOffsetKHR"
  Op
OpRayQueryGetIntersectionGeometryIndexKHR -> a
"OpRayQueryGetIntersectionGeometryIndexKHR"
  Op
OpRayQueryGetIntersectionPrimitiveIndexKHR -> a
"OpRayQueryGetIntersectionPrimitiveIndexKHR"
  Op
OpRayQueryGetIntersectionBarycentricsKHR -> a
"OpRayQueryGetIntersectionBarycentricsKHR"
  Op
OpRayQueryGetIntersectionFrontFaceKHR -> a
"OpRayQueryGetIntersectionFrontFaceKHR"
  Op
OpRayQueryGetIntersectionCandidateAABBOpaqueKHR -> a
"OpRayQueryGetIntersectionCandidateAABBOpaqueKHR"
  Op
OpRayQueryGetIntersectionObjectRayDirectionKHR -> a
"OpRayQueryGetIntersectionObjectRayDirectionKHR"
  Op
OpRayQueryGetIntersectionObjectRayOriginKHR -> a
"OpRayQueryGetIntersectionObjectRayOriginKHR"
  Op
OpRayQueryGetWorldRayDirectionKHR -> a
"OpRayQueryGetWorldRayDirectionKHR"
  Op
OpRayQueryGetWorldRayOriginKHR -> a
"OpRayQueryGetWorldRayOriginKHR"
  Op
OpRayQueryGetIntersectionObjectToWorldKHR -> a
"OpRayQueryGetIntersectionObjectToWorldKHR"
  Op
OpRayQueryGetIntersectionWorldToObjectKHR -> a
"OpRayQueryGetIntersectionWorldToObjectKHR"
  Op
OpAtomicFAddEXT -> a
"OpAtomicFAddEXT"
  Op
OpTypeBufferSurfaceINTEL -> a
"OpTypeBufferSurfaceINTEL"
  Op
OpTypeStructContinuedINTEL -> a
"OpTypeStructContinuedINTEL"
  Op
OpConstantCompositeContinuedINTEL -> a
"OpConstantCompositeContinuedINTEL"
  Op
OpSpecConstantCompositeContinuedINTEL -> a
"OpSpecConstantCompositeContinuedINTEL"
  Op
OpControlBarrierArriveINTEL -> a
"OpControlBarrierArriveINTEL"
  Op
OpControlBarrierWaitINTEL -> a
"OpControlBarrierWaitINTEL"
  Op
OpGroupIMulKHR -> a
"OpGroupIMulKHR"
  Op
OpGroupFMulKHR -> a
"OpGroupFMulKHR"
  Op
OpGroupBitwiseAndKHR -> a
"OpGroupBitwiseAndKHR"
  Op
OpGroupBitwiseOrKHR -> a
"OpGroupBitwiseOrKHR"
  Op
OpGroupBitwiseXorKHR -> a
"OpGroupBitwiseXorKHR"
  Op
OpGroupLogicalAndKHR -> a
"OpGroupLogicalAndKHR"
  Op
OpGroupLogicalOrKHR -> a
"OpGroupLogicalOrKHR"
  Op
OpGroupLogicalXorKHR -> a
"OpGroupLogicalXorKHR"
  Op
unknown -> forall a. IsString a => [Char] -> a
fromString forall a b. (a -> b) -> a -> b
$ [Char]
"Op " forall a. [a] -> [a] -> [a]
++ forall a. Show a => a -> [Char]
show Op
unknown

instance Show Op where
  show :: Op -> [Char]
show = forall a. IsString a => Op -> a
toName

fromName :: (IsString a, Eq a) => a -> Maybe Op
fromName :: forall a. (IsString a, Eq a) => a -> Maybe Op
fromName a
x = case a
x of
  a
"OpNop" -> forall a. a -> Maybe a
Just Op
OpNop
  a
"OpUndef" -> forall a. a -> Maybe a
Just Op
OpUndef
  a
"OpSourceContinued" -> forall a. a -> Maybe a
Just Op
OpSourceContinued
  a
"OpSource" -> forall a. a -> Maybe a
Just Op
OpSource
  a
"OpSourceExtension" -> forall a. a -> Maybe a
Just Op
OpSourceExtension
  a
"OpName" -> forall a. a -> Maybe a
Just Op
OpName
  a
"OpMemberName" -> forall a. a -> Maybe a
Just Op
OpMemberName
  a
"OpString" -> forall a. a -> Maybe a
Just Op
OpString
  a
"OpLine" -> forall a. a -> Maybe a
Just Op
OpLine
  a
"OpExtension" -> forall a. a -> Maybe a
Just Op
OpExtension
  a
"OpExtInstImport" -> forall a. a -> Maybe a
Just Op
OpExtInstImport
  a
"OpExtInst" -> forall a. a -> Maybe a
Just Op
OpExtInst
  a
"OpMemoryModel" -> forall a. a -> Maybe a
Just Op
OpMemoryModel
  a
"OpEntryPoint" -> forall a. a -> Maybe a
Just Op
OpEntryPoint
  a
"OpExecutionMode" -> forall a. a -> Maybe a
Just Op
OpExecutionMode
  a
"OpCapability" -> forall a. a -> Maybe a
Just Op
OpCapability
  a
"OpTypeVoid" -> forall a. a -> Maybe a
Just Op
OpTypeVoid
  a
"OpTypeBool" -> forall a. a -> Maybe a
Just Op
OpTypeBool
  a
"OpTypeInt" -> forall a. a -> Maybe a
Just Op
OpTypeInt
  a
"OpTypeFloat" -> forall a. a -> Maybe a
Just Op
OpTypeFloat
  a
"OpTypeVector" -> forall a. a -> Maybe a
Just Op
OpTypeVector
  a
"OpTypeMatrix" -> forall a. a -> Maybe a
Just Op
OpTypeMatrix
  a
"OpTypeImage" -> forall a. a -> Maybe a
Just Op
OpTypeImage
  a
"OpTypeSampler" -> forall a. a -> Maybe a
Just Op
OpTypeSampler
  a
"OpTypeSampledImage" -> forall a. a -> Maybe a
Just Op
OpTypeSampledImage
  a
"OpTypeArray" -> forall a. a -> Maybe a
Just Op
OpTypeArray
  a
"OpTypeRuntimeArray" -> forall a. a -> Maybe a
Just Op
OpTypeRuntimeArray
  a
"OpTypeStruct" -> forall a. a -> Maybe a
Just Op
OpTypeStruct
  a
"OpTypeOpaque" -> forall a. a -> Maybe a
Just Op
OpTypeOpaque
  a
"OpTypePointer" -> forall a. a -> Maybe a
Just Op
OpTypePointer
  a
"OpTypeFunction" -> forall a. a -> Maybe a
Just Op
OpTypeFunction
  a
"OpTypeEvent" -> forall a. a -> Maybe a
Just Op
OpTypeEvent
  a
"OpTypeDeviceEvent" -> forall a. a -> Maybe a
Just Op
OpTypeDeviceEvent
  a
"OpTypeReserveId" -> forall a. a -> Maybe a
Just Op
OpTypeReserveId
  a
"OpTypeQueue" -> forall a. a -> Maybe a
Just Op
OpTypeQueue
  a
"OpTypePipe" -> forall a. a -> Maybe a
Just Op
OpTypePipe
  a
"OpTypeForwardPointer" -> forall a. a -> Maybe a
Just Op
OpTypeForwardPointer
  a
"OpConstantTrue" -> forall a. a -> Maybe a
Just Op
OpConstantTrue
  a
"OpConstantFalse" -> forall a. a -> Maybe a
Just Op
OpConstantFalse
  a
"OpConstant" -> forall a. a -> Maybe a
Just Op
OpConstant
  a
"OpConstantComposite" -> forall a. a -> Maybe a
Just Op
OpConstantComposite
  a
"OpConstantSampler" -> forall a. a -> Maybe a
Just Op
OpConstantSampler
  a
"OpConstantNull" -> forall a. a -> Maybe a
Just Op
OpConstantNull
  a
"OpSpecConstantTrue" -> forall a. a -> Maybe a
Just Op
OpSpecConstantTrue
  a
"OpSpecConstantFalse" -> forall a. a -> Maybe a
Just Op
OpSpecConstantFalse
  a
"OpSpecConstant" -> forall a. a -> Maybe a
Just Op
OpSpecConstant
  a
"OpSpecConstantComposite" -> forall a. a -> Maybe a
Just Op
OpSpecConstantComposite
  a
"OpSpecConstantOp" -> forall a. a -> Maybe a
Just Op
OpSpecConstantOp
  a
"OpFunction" -> forall a. a -> Maybe a
Just Op
OpFunction
  a
"OpFunctionParameter" -> forall a. a -> Maybe a
Just Op
OpFunctionParameter
  a
"OpFunctionEnd" -> forall a. a -> Maybe a
Just Op
OpFunctionEnd
  a
"OpFunctionCall" -> forall a. a -> Maybe a
Just Op
OpFunctionCall
  a
"OpVariable" -> forall a. a -> Maybe a
Just Op
OpVariable
  a
"OpImageTexelPointer" -> forall a. a -> Maybe a
Just Op
OpImageTexelPointer
  a
"OpLoad" -> forall a. a -> Maybe a
Just Op
OpLoad
  a
"OpStore" -> forall a. a -> Maybe a
Just Op
OpStore
  a
"OpCopyMemory" -> forall a. a -> Maybe a
Just Op
OpCopyMemory
  a
"OpCopyMemorySized" -> forall a. a -> Maybe a
Just Op
OpCopyMemorySized
  a
"OpAccessChain" -> forall a. a -> Maybe a
Just Op
OpAccessChain
  a
"OpInBoundsAccessChain" -> forall a. a -> Maybe a
Just Op
OpInBoundsAccessChain
  a
"OpPtrAccessChain" -> forall a. a -> Maybe a
Just Op
OpPtrAccessChain
  a
"OpArrayLength" -> forall a. a -> Maybe a
Just Op
OpArrayLength
  a
"OpGenericPtrMemSemantics" -> forall a. a -> Maybe a
Just Op
OpGenericPtrMemSemantics
  a
"OpInBoundsPtrAccessChain" -> forall a. a -> Maybe a
Just Op
OpInBoundsPtrAccessChain
  a
"OpDecorate" -> forall a. a -> Maybe a
Just Op
OpDecorate
  a
"OpMemberDecorate" -> forall a. a -> Maybe a
Just Op
OpMemberDecorate
  a
"OpDecorationGroup" -> forall a. a -> Maybe a
Just Op
OpDecorationGroup
  a
"OpGroupDecorate" -> forall a. a -> Maybe a
Just Op
OpGroupDecorate
  a
"OpGroupMemberDecorate" -> forall a. a -> Maybe a
Just Op
OpGroupMemberDecorate
  a
"OpVectorExtractDynamic" -> forall a. a -> Maybe a
Just Op
OpVectorExtractDynamic
  a
"OpVectorInsertDynamic" -> forall a. a -> Maybe a
Just Op
OpVectorInsertDynamic
  a
"OpVectorShuffle" -> forall a. a -> Maybe a
Just Op
OpVectorShuffle
  a
"OpCompositeConstruct" -> forall a. a -> Maybe a
Just Op
OpCompositeConstruct
  a
"OpCompositeExtract" -> forall a. a -> Maybe a
Just Op
OpCompositeExtract
  a
"OpCompositeInsert" -> forall a. a -> Maybe a
Just Op
OpCompositeInsert
  a
"OpCopyObject" -> forall a. a -> Maybe a
Just Op
OpCopyObject
  a
"OpTranspose" -> forall a. a -> Maybe a
Just Op
OpTranspose
  a
"OpSampledImage" -> forall a. a -> Maybe a
Just Op
OpSampledImage
  a
"OpImageSampleImplicitLod" -> forall a. a -> Maybe a
Just Op
OpImageSampleImplicitLod
  a
"OpImageSampleExplicitLod" -> forall a. a -> Maybe a
Just Op
OpImageSampleExplicitLod
  a
"OpImageSampleDrefImplicitLod" -> forall a. a -> Maybe a
Just Op
OpImageSampleDrefImplicitLod
  a
"OpImageSampleDrefExplicitLod" -> forall a. a -> Maybe a
Just Op
OpImageSampleDrefExplicitLod
  a
"OpImageSampleProjImplicitLod" -> forall a. a -> Maybe a
Just Op
OpImageSampleProjImplicitLod
  a
"OpImageSampleProjExplicitLod" -> forall a. a -> Maybe a
Just Op
OpImageSampleProjExplicitLod
  a
"OpImageSampleProjDrefImplicitLod" -> forall a. a -> Maybe a
Just Op
OpImageSampleProjDrefImplicitLod
  a
"OpImageSampleProjDrefExplicitLod" -> forall a. a -> Maybe a
Just Op
OpImageSampleProjDrefExplicitLod
  a
"OpImageFetch" -> forall a. a -> Maybe a
Just Op
OpImageFetch
  a
"OpImageGather" -> forall a. a -> Maybe a
Just Op
OpImageGather
  a
"OpImageDrefGather" -> forall a. a -> Maybe a
Just Op
OpImageDrefGather
  a
"OpImageRead" -> forall a. a -> Maybe a
Just Op
OpImageRead
  a
"OpImageWrite" -> forall a. a -> Maybe a
Just Op
OpImageWrite
  a
"OpImage" -> forall a. a -> Maybe a
Just Op
OpImage
  a
"OpImageQueryFormat" -> forall a. a -> Maybe a
Just Op
OpImageQueryFormat
  a
"OpImageQueryOrder" -> forall a. a -> Maybe a
Just Op
OpImageQueryOrder
  a
"OpImageQuerySizeLod" -> forall a. a -> Maybe a
Just Op
OpImageQuerySizeLod
  a
"OpImageQuerySize" -> forall a. a -> Maybe a
Just Op
OpImageQuerySize
  a
"OpImageQueryLod" -> forall a. a -> Maybe a
Just Op
OpImageQueryLod
  a
"OpImageQueryLevels" -> forall a. a -> Maybe a
Just Op
OpImageQueryLevels
  a
"OpImageQuerySamples" -> forall a. a -> Maybe a
Just Op
OpImageQuerySamples
  a
"OpConvertFToU" -> forall a. a -> Maybe a
Just Op
OpConvertFToU
  a
"OpConvertFToS" -> forall a. a -> Maybe a
Just Op
OpConvertFToS
  a
"OpConvertSToF" -> forall a. a -> Maybe a
Just Op
OpConvertSToF
  a
"OpConvertUToF" -> forall a. a -> Maybe a
Just Op
OpConvertUToF
  a
"OpUConvert" -> forall a. a -> Maybe a
Just Op
OpUConvert
  a
"OpSConvert" -> forall a. a -> Maybe a
Just Op
OpSConvert
  a
"OpFConvert" -> forall a. a -> Maybe a
Just Op
OpFConvert
  a
"OpQuantizeToF16" -> forall a. a -> Maybe a
Just Op
OpQuantizeToF16
  a
"OpConvertPtrToU" -> forall a. a -> Maybe a
Just Op
OpConvertPtrToU
  a
"OpSatConvertSToU" -> forall a. a -> Maybe a
Just Op
OpSatConvertSToU
  a
"OpSatConvertUToS" -> forall a. a -> Maybe a
Just Op
OpSatConvertUToS
  a
"OpConvertUToPtr" -> forall a. a -> Maybe a
Just Op
OpConvertUToPtr
  a
"OpPtrCastToGeneric" -> forall a. a -> Maybe a
Just Op
OpPtrCastToGeneric
  a
"OpGenericCastToPtr" -> forall a. a -> Maybe a
Just Op
OpGenericCastToPtr
  a
"OpGenericCastToPtrExplicit" -> forall a. a -> Maybe a
Just Op
OpGenericCastToPtrExplicit
  a
"OpBitcast" -> forall a. a -> Maybe a
Just Op
OpBitcast
  a
"OpSNegate" -> forall a. a -> Maybe a
Just Op
OpSNegate
  a
"OpFNegate" -> forall a. a -> Maybe a
Just Op
OpFNegate
  a
"OpIAdd" -> forall a. a -> Maybe a
Just Op
OpIAdd
  a
"OpFAdd" -> forall a. a -> Maybe a
Just Op
OpFAdd
  a
"OpISub" -> forall a. a -> Maybe a
Just Op
OpISub
  a
"OpFSub" -> forall a. a -> Maybe a
Just Op
OpFSub
  a
"OpIMul" -> forall a. a -> Maybe a
Just Op
OpIMul
  a
"OpFMul" -> forall a. a -> Maybe a
Just Op
OpFMul
  a
"OpUDiv" -> forall a. a -> Maybe a
Just Op
OpUDiv
  a
"OpSDiv" -> forall a. a -> Maybe a
Just Op
OpSDiv
  a
"OpFDiv" -> forall a. a -> Maybe a
Just Op
OpFDiv
  a
"OpUMod" -> forall a. a -> Maybe a
Just Op
OpUMod
  a
"OpSRem" -> forall a. a -> Maybe a
Just Op
OpSRem
  a
"OpSMod" -> forall a. a -> Maybe a
Just Op
OpSMod
  a
"OpFRem" -> forall a. a -> Maybe a
Just Op
OpFRem
  a
"OpFMod" -> forall a. a -> Maybe a
Just Op
OpFMod
  a
"OpVectorTimesScalar" -> forall a. a -> Maybe a
Just Op
OpVectorTimesScalar
  a
"OpMatrixTimesScalar" -> forall a. a -> Maybe a
Just Op
OpMatrixTimesScalar
  a
"OpVectorTimesMatrix" -> forall a. a -> Maybe a
Just Op
OpVectorTimesMatrix
  a
"OpMatrixTimesVector" -> forall a. a -> Maybe a
Just Op
OpMatrixTimesVector
  a
"OpMatrixTimesMatrix" -> forall a. a -> Maybe a
Just Op
OpMatrixTimesMatrix
  a
"OpOuterProduct" -> forall a. a -> Maybe a
Just Op
OpOuterProduct
  a
"OpDot" -> forall a. a -> Maybe a
Just Op
OpDot
  a
"OpIAddCarry" -> forall a. a -> Maybe a
Just Op
OpIAddCarry
  a
"OpISubBorrow" -> forall a. a -> Maybe a
Just Op
OpISubBorrow
  a
"OpUMulExtended" -> forall a. a -> Maybe a
Just Op
OpUMulExtended
  a
"OpSMulExtended" -> forall a. a -> Maybe a
Just Op
OpSMulExtended
  a
"OpAny" -> forall a. a -> Maybe a
Just Op
OpAny
  a
"OpAll" -> forall a. a -> Maybe a
Just Op
OpAll
  a
"OpIsNan" -> forall a. a -> Maybe a
Just Op
OpIsNan
  a
"OpIsInf" -> forall a. a -> Maybe a
Just Op
OpIsInf
  a
"OpIsFinite" -> forall a. a -> Maybe a
Just Op
OpIsFinite
  a
"OpIsNormal" -> forall a. a -> Maybe a
Just Op
OpIsNormal
  a
"OpSignBitSet" -> forall a. a -> Maybe a
Just Op
OpSignBitSet
  a
"OpLessOrGreater" -> forall a. a -> Maybe a
Just Op
OpLessOrGreater
  a
"OpOrdered" -> forall a. a -> Maybe a
Just Op
OpOrdered
  a
"OpUnordered" -> forall a. a -> Maybe a
Just Op
OpUnordered
  a
"OpLogicalEqual" -> forall a. a -> Maybe a
Just Op
OpLogicalEqual
  a
"OpLogicalNotEqual" -> forall a. a -> Maybe a
Just Op
OpLogicalNotEqual
  a
"OpLogicalOr" -> forall a. a -> Maybe a
Just Op
OpLogicalOr
  a
"OpLogicalAnd" -> forall a. a -> Maybe a
Just Op
OpLogicalAnd
  a
"OpLogicalNot" -> forall a. a -> Maybe a
Just Op
OpLogicalNot
  a
"OpSelect" -> forall a. a -> Maybe a
Just Op
OpSelect
  a
"OpIEqual" -> forall a. a -> Maybe a
Just Op
OpIEqual
  a
"OpINotEqual" -> forall a. a -> Maybe a
Just Op
OpINotEqual
  a
"OpUGreaterThan" -> forall a. a -> Maybe a
Just Op
OpUGreaterThan
  a
"OpSGreaterThan" -> forall a. a -> Maybe a
Just Op
OpSGreaterThan
  a
"OpUGreaterThanEqual" -> forall a. a -> Maybe a
Just Op
OpUGreaterThanEqual
  a
"OpSGreaterThanEqual" -> forall a. a -> Maybe a
Just Op
OpSGreaterThanEqual
  a
"OpULessThan" -> forall a. a -> Maybe a
Just Op
OpULessThan
  a
"OpSLessThan" -> forall a. a -> Maybe a
Just Op
OpSLessThan
  a
"OpULessThanEqual" -> forall a. a -> Maybe a
Just Op
OpULessThanEqual
  a
"OpSLessThanEqual" -> forall a. a -> Maybe a
Just Op
OpSLessThanEqual
  a
"OpFOrdEqual" -> forall a. a -> Maybe a
Just Op
OpFOrdEqual
  a
"OpFUnordEqual" -> forall a. a -> Maybe a
Just Op
OpFUnordEqual
  a
"OpFOrdNotEqual" -> forall a. a -> Maybe a
Just Op
OpFOrdNotEqual
  a
"OpFUnordNotEqual" -> forall a. a -> Maybe a
Just Op
OpFUnordNotEqual
  a
"OpFOrdLessThan" -> forall a. a -> Maybe a
Just Op
OpFOrdLessThan
  a
"OpFUnordLessThan" -> forall a. a -> Maybe a
Just Op
OpFUnordLessThan
  a
"OpFOrdGreaterThan" -> forall a. a -> Maybe a
Just Op
OpFOrdGreaterThan
  a
"OpFUnordGreaterThan" -> forall a. a -> Maybe a
Just Op
OpFUnordGreaterThan
  a
"OpFOrdLessThanEqual" -> forall a. a -> Maybe a
Just Op
OpFOrdLessThanEqual
  a
"OpFUnordLessThanEqual" -> forall a. a -> Maybe a
Just Op
OpFUnordLessThanEqual
  a
"OpFOrdGreaterThanEqual" -> forall a. a -> Maybe a
Just Op
OpFOrdGreaterThanEqual
  a
"OpFUnordGreaterThanEqual" -> forall a. a -> Maybe a
Just Op
OpFUnordGreaterThanEqual
  a
"OpShiftRightLogical" -> forall a. a -> Maybe a
Just Op
OpShiftRightLogical
  a
"OpShiftRightArithmetic" -> forall a. a -> Maybe a
Just Op
OpShiftRightArithmetic
  a
"OpShiftLeftLogical" -> forall a. a -> Maybe a
Just Op
OpShiftLeftLogical
  a
"OpBitwiseOr" -> forall a. a -> Maybe a
Just Op
OpBitwiseOr
  a
"OpBitwiseXor" -> forall a. a -> Maybe a
Just Op
OpBitwiseXor
  a
"OpBitwiseAnd" -> forall a. a -> Maybe a
Just Op
OpBitwiseAnd
  a
"OpNot" -> forall a. a -> Maybe a
Just Op
OpNot
  a
"OpBitFieldInsert" -> forall a. a -> Maybe a
Just Op
OpBitFieldInsert
  a
"OpBitFieldSExtract" -> forall a. a -> Maybe a
Just Op
OpBitFieldSExtract
  a
"OpBitFieldUExtract" -> forall a. a -> Maybe a
Just Op
OpBitFieldUExtract
  a
"OpBitReverse" -> forall a. a -> Maybe a
Just Op
OpBitReverse
  a
"OpBitCount" -> forall a. a -> Maybe a
Just Op
OpBitCount
  a
"OpDPdx" -> forall a. a -> Maybe a
Just Op
OpDPdx
  a
"OpDPdy" -> forall a. a -> Maybe a
Just Op
OpDPdy
  a
"OpFwidth" -> forall a. a -> Maybe a
Just Op
OpFwidth
  a
"OpDPdxFine" -> forall a. a -> Maybe a
Just Op
OpDPdxFine
  a
"OpDPdyFine" -> forall a. a -> Maybe a
Just Op
OpDPdyFine
  a
"OpFwidthFine" -> forall a. a -> Maybe a
Just Op
OpFwidthFine
  a
"OpDPdxCoarse" -> forall a. a -> Maybe a
Just Op
OpDPdxCoarse
  a
"OpDPdyCoarse" -> forall a. a -> Maybe a
Just Op
OpDPdyCoarse
  a
"OpFwidthCoarse" -> forall a. a -> Maybe a
Just Op
OpFwidthCoarse
  a
"OpEmitVertex" -> forall a. a -> Maybe a
Just Op
OpEmitVertex
  a
"OpEndPrimitive" -> forall a. a -> Maybe a
Just Op
OpEndPrimitive
  a
"OpEmitStreamVertex" -> forall a. a -> Maybe a
Just Op
OpEmitStreamVertex
  a
"OpEndStreamPrimitive" -> forall a. a -> Maybe a
Just Op
OpEndStreamPrimitive
  a
"OpControlBarrier" -> forall a. a -> Maybe a
Just Op
OpControlBarrier
  a
"OpMemoryBarrier" -> forall a. a -> Maybe a
Just Op
OpMemoryBarrier
  a
"OpAtomicLoad" -> forall a. a -> Maybe a
Just Op
OpAtomicLoad
  a
"OpAtomicStore" -> forall a. a -> Maybe a
Just Op
OpAtomicStore
  a
"OpAtomicExchange" -> forall a. a -> Maybe a
Just Op
OpAtomicExchange
  a
"OpAtomicCompareExchange" -> forall a. a -> Maybe a
Just Op
OpAtomicCompareExchange
  a
"OpAtomicCompareExchangeWeak" -> forall a. a -> Maybe a
Just Op
OpAtomicCompareExchangeWeak
  a
"OpAtomicIIncrement" -> forall a. a -> Maybe a
Just Op
OpAtomicIIncrement
  a
"OpAtomicIDecrement" -> forall a. a -> Maybe a
Just Op
OpAtomicIDecrement
  a
"OpAtomicIAdd" -> forall a. a -> Maybe a
Just Op
OpAtomicIAdd
  a
"OpAtomicISub" -> forall a. a -> Maybe a
Just Op
OpAtomicISub
  a
"OpAtomicSMin" -> forall a. a -> Maybe a
Just Op
OpAtomicSMin
  a
"OpAtomicUMin" -> forall a. a -> Maybe a
Just Op
OpAtomicUMin
  a
"OpAtomicSMax" -> forall a. a -> Maybe a
Just Op
OpAtomicSMax
  a
"OpAtomicUMax" -> forall a. a -> Maybe a
Just Op
OpAtomicUMax
  a
"OpAtomicAnd" -> forall a. a -> Maybe a
Just Op
OpAtomicAnd
  a
"OpAtomicOr" -> forall a. a -> Maybe a
Just Op
OpAtomicOr
  a
"OpAtomicXor" -> forall a. a -> Maybe a
Just Op
OpAtomicXor
  a
"OpPhi" -> forall a. a -> Maybe a
Just Op
OpPhi
  a
"OpLoopMerge" -> forall a. a -> Maybe a
Just Op
OpLoopMerge
  a
"OpSelectionMerge" -> forall a. a -> Maybe a
Just Op
OpSelectionMerge
  a
"OpLabel" -> forall a. a -> Maybe a
Just Op
OpLabel
  a
"OpBranch" -> forall a. a -> Maybe a
Just Op
OpBranch
  a
"OpBranchConditional" -> forall a. a -> Maybe a
Just Op
OpBranchConditional
  a
"OpSwitch" -> forall a. a -> Maybe a
Just Op
OpSwitch
  a
"OpKill" -> forall a. a -> Maybe a
Just Op
OpKill
  a
"OpReturn" -> forall a. a -> Maybe a
Just Op
OpReturn
  a
"OpReturnValue" -> forall a. a -> Maybe a
Just Op
OpReturnValue
  a
"OpUnreachable" -> forall a. a -> Maybe a
Just Op
OpUnreachable
  a
"OpLifetimeStart" -> forall a. a -> Maybe a
Just Op
OpLifetimeStart
  a
"OpLifetimeStop" -> forall a. a -> Maybe a
Just Op
OpLifetimeStop
  a
"OpGroupAsyncCopy" -> forall a. a -> Maybe a
Just Op
OpGroupAsyncCopy
  a
"OpGroupWaitEvents" -> forall a. a -> Maybe a
Just Op
OpGroupWaitEvents
  a
"OpGroupAll" -> forall a. a -> Maybe a
Just Op
OpGroupAll
  a
"OpGroupAny" -> forall a. a -> Maybe a
Just Op
OpGroupAny
  a
"OpGroupBroadcast" -> forall a. a -> Maybe a
Just Op
OpGroupBroadcast
  a
"OpGroupIAdd" -> forall a. a -> Maybe a
Just Op
OpGroupIAdd
  a
"OpGroupFAdd" -> forall a. a -> Maybe a
Just Op
OpGroupFAdd
  a
"OpGroupFMin" -> forall a. a -> Maybe a
Just Op
OpGroupFMin
  a
"OpGroupUMin" -> forall a. a -> Maybe a
Just Op
OpGroupUMin
  a
"OpGroupSMin" -> forall a. a -> Maybe a
Just Op
OpGroupSMin
  a
"OpGroupFMax" -> forall a. a -> Maybe a
Just Op
OpGroupFMax
  a
"OpGroupUMax" -> forall a. a -> Maybe a
Just Op
OpGroupUMax
  a
"OpGroupSMax" -> forall a. a -> Maybe a
Just Op
OpGroupSMax
  a
"OpReadPipe" -> forall a. a -> Maybe a
Just Op
OpReadPipe
  a
"OpWritePipe" -> forall a. a -> Maybe a
Just Op
OpWritePipe
  a
"OpReservedReadPipe" -> forall a. a -> Maybe a
Just Op
OpReservedReadPipe
  a
"OpReservedWritePipe" -> forall a. a -> Maybe a
Just Op
OpReservedWritePipe
  a
"OpReserveReadPipePackets" -> forall a. a -> Maybe a
Just Op
OpReserveReadPipePackets
  a
"OpReserveWritePipePackets" -> forall a. a -> Maybe a
Just Op
OpReserveWritePipePackets
  a
"OpCommitReadPipe" -> forall a. a -> Maybe a
Just Op
OpCommitReadPipe
  a
"OpCommitWritePipe" -> forall a. a -> Maybe a
Just Op
OpCommitWritePipe
  a
"OpIsValidReserveId" -> forall a. a -> Maybe a
Just Op
OpIsValidReserveId
  a
"OpGetNumPipePackets" -> forall a. a -> Maybe a
Just Op
OpGetNumPipePackets
  a
"OpGetMaxPipePackets" -> forall a. a -> Maybe a
Just Op
OpGetMaxPipePackets
  a
"OpGroupReserveReadPipePackets" -> forall a. a -> Maybe a
Just Op
OpGroupReserveReadPipePackets
  a
"OpGroupReserveWritePipePackets" -> forall a. a -> Maybe a
Just Op
OpGroupReserveWritePipePackets
  a
"OpGroupCommitReadPipe" -> forall a. a -> Maybe a
Just Op
OpGroupCommitReadPipe
  a
"OpGroupCommitWritePipe" -> forall a. a -> Maybe a
Just Op
OpGroupCommitWritePipe
  a
"OpEnqueueMarker" -> forall a. a -> Maybe a
Just Op
OpEnqueueMarker
  a
"OpEnqueueKernel" -> forall a. a -> Maybe a
Just Op
OpEnqueueKernel
  a
"OpGetKernelNDrangeSubGroupCount" -> forall a. a -> Maybe a
Just Op
OpGetKernelNDrangeSubGroupCount
  a
"OpGetKernelNDrangeMaxSubGroupSize" -> forall a. a -> Maybe a
Just Op
OpGetKernelNDrangeMaxSubGroupSize
  a
"OpGetKernelWorkGroupSize" -> forall a. a -> Maybe a
Just Op
OpGetKernelWorkGroupSize
  a
"OpGetKernelPreferredWorkGroupSizeMultiple" -> forall a. a -> Maybe a
Just Op
OpGetKernelPreferredWorkGroupSizeMultiple
  a
"OpRetainEvent" -> forall a. a -> Maybe a
Just Op
OpRetainEvent
  a
"OpReleaseEvent" -> forall a. a -> Maybe a
Just Op
OpReleaseEvent
  a
"OpCreateUserEvent" -> forall a. a -> Maybe a
Just Op
OpCreateUserEvent
  a
"OpIsValidEvent" -> forall a. a -> Maybe a
Just Op
OpIsValidEvent
  a
"OpSetUserEventStatus" -> forall a. a -> Maybe a
Just Op
OpSetUserEventStatus
  a
"OpCaptureEventProfilingInfo" -> forall a. a -> Maybe a
Just Op
OpCaptureEventProfilingInfo
  a
"OpGetDefaultQueue" -> forall a. a -> Maybe a
Just Op
OpGetDefaultQueue
  a
"OpBuildNDRange" -> forall a. a -> Maybe a
Just Op
OpBuildNDRange
  a
"OpImageSparseSampleImplicitLod" -> forall a. a -> Maybe a
Just Op
OpImageSparseSampleImplicitLod
  a
"OpImageSparseSampleExplicitLod" -> forall a. a -> Maybe a
Just Op
OpImageSparseSampleExplicitLod
  a
"OpImageSparseSampleDrefImplicitLod" -> forall a. a -> Maybe a
Just Op
OpImageSparseSampleDrefImplicitLod
  a
"OpImageSparseSampleDrefExplicitLod" -> forall a. a -> Maybe a
Just Op
OpImageSparseSampleDrefExplicitLod
  a
"OpImageSparseSampleProjImplicitLod" -> forall a. a -> Maybe a
Just Op
OpImageSparseSampleProjImplicitLod
  a
"OpImageSparseSampleProjExplicitLod" -> forall a. a -> Maybe a
Just Op
OpImageSparseSampleProjExplicitLod
  a
"OpImageSparseSampleProjDrefImplicitLod" -> forall a. a -> Maybe a
Just Op
OpImageSparseSampleProjDrefImplicitLod
  a
"OpImageSparseSampleProjDrefExplicitLod" -> forall a. a -> Maybe a
Just Op
OpImageSparseSampleProjDrefExplicitLod
  a
"OpImageSparseFetch" -> forall a. a -> Maybe a
Just Op
OpImageSparseFetch
  a
"OpImageSparseGather" -> forall a. a -> Maybe a
Just Op
OpImageSparseGather
  a
"OpImageSparseDrefGather" -> forall a. a -> Maybe a
Just Op
OpImageSparseDrefGather
  a
"OpImageSparseTexelsResident" -> forall a. a -> Maybe a
Just Op
OpImageSparseTexelsResident
  a
"OpNoLine" -> forall a. a -> Maybe a
Just Op
OpNoLine
  a
"OpAtomicFlagTestAndSet" -> forall a. a -> Maybe a
Just Op
OpAtomicFlagTestAndSet
  a
"OpAtomicFlagClear" -> forall a. a -> Maybe a
Just Op
OpAtomicFlagClear
  a
"OpImageSparseRead" -> forall a. a -> Maybe a
Just Op
OpImageSparseRead
  a
"OpSizeOf" -> forall a. a -> Maybe a
Just Op
OpSizeOf
  a
"OpTypePipeStorage" -> forall a. a -> Maybe a
Just Op
OpTypePipeStorage
  a
"OpConstantPipeStorage" -> forall a. a -> Maybe a
Just Op
OpConstantPipeStorage
  a
"OpCreatePipeFromPipeStorage" -> forall a. a -> Maybe a
Just Op
OpCreatePipeFromPipeStorage
  a
"OpGetKernelLocalSizeForSubgroupCount" -> forall a. a -> Maybe a
Just Op
OpGetKernelLocalSizeForSubgroupCount
  a
"OpGetKernelMaxNumSubgroups" -> forall a. a -> Maybe a
Just Op
OpGetKernelMaxNumSubgroups
  a
"OpTypeNamedBarrier" -> forall a. a -> Maybe a
Just Op
OpTypeNamedBarrier
  a
"OpNamedBarrierInitialize" -> forall a. a -> Maybe a
Just Op
OpNamedBarrierInitialize
  a
"OpMemoryNamedBarrier" -> forall a. a -> Maybe a
Just Op
OpMemoryNamedBarrier
  a
"OpModuleProcessed" -> forall a. a -> Maybe a
Just Op
OpModuleProcessed
  a
"OpExecutionModeId" -> forall a. a -> Maybe a
Just Op
OpExecutionModeId
  a
"OpDecorateId" -> forall a. a -> Maybe a
Just Op
OpDecorateId
  a
"OpGroupNonUniformElect" -> forall a. a -> Maybe a
Just Op
OpGroupNonUniformElect
  a
"OpGroupNonUniformAll" -> forall a. a -> Maybe a
Just Op
OpGroupNonUniformAll
  a
"OpGroupNonUniformAny" -> forall a. a -> Maybe a
Just Op
OpGroupNonUniformAny
  a
"OpGroupNonUniformAllEqual" -> forall a. a -> Maybe a
Just Op
OpGroupNonUniformAllEqual
  a
"OpGroupNonUniformBroadcast" -> forall a. a -> Maybe a
Just Op
OpGroupNonUniformBroadcast
  a
"OpGroupNonUniformBroadcastFirst" -> forall a. a -> Maybe a
Just Op
OpGroupNonUniformBroadcastFirst
  a
"OpGroupNonUniformBallot" -> forall a. a -> Maybe a
Just Op
OpGroupNonUniformBallot
  a
"OpGroupNonUniformInverseBallot" -> forall a. a -> Maybe a
Just Op
OpGroupNonUniformInverseBallot
  a
"OpGroupNonUniformBallotBitExtract" -> forall a. a -> Maybe a
Just Op
OpGroupNonUniformBallotBitExtract
  a
"OpGroupNonUniformBallotBitCount" -> forall a. a -> Maybe a
Just Op
OpGroupNonUniformBallotBitCount
  a
"OpGroupNonUniformBallotFindLSB" -> forall a. a -> Maybe a
Just Op
OpGroupNonUniformBallotFindLSB
  a
"OpGroupNonUniformBallotFindMSB" -> forall a. a -> Maybe a
Just Op
OpGroupNonUniformBallotFindMSB
  a
"OpGroupNonUniformShuffle" -> forall a. a -> Maybe a
Just Op
OpGroupNonUniformShuffle
  a
"OpGroupNonUniformShuffleXor" -> forall a. a -> Maybe a
Just Op
OpGroupNonUniformShuffleXor
  a
"OpGroupNonUniformShuffleUp" -> forall a. a -> Maybe a
Just Op
OpGroupNonUniformShuffleUp
  a
"OpGroupNonUniformShuffleDown" -> forall a. a -> Maybe a
Just Op
OpGroupNonUniformShuffleDown
  a
"OpGroupNonUniformIAdd" -> forall a. a -> Maybe a
Just Op
OpGroupNonUniformIAdd
  a
"OpGroupNonUniformFAdd" -> forall a. a -> Maybe a
Just Op
OpGroupNonUniformFAdd
  a
"OpGroupNonUniformIMul" -> forall a. a -> Maybe a
Just Op
OpGroupNonUniformIMul
  a
"OpGroupNonUniformFMul" -> forall a. a -> Maybe a
Just Op
OpGroupNonUniformFMul
  a
"OpGroupNonUniformSMin" -> forall a. a -> Maybe a
Just Op
OpGroupNonUniformSMin
  a
"OpGroupNonUniformUMin" -> forall a. a -> Maybe a
Just Op
OpGroupNonUniformUMin
  a
"OpGroupNonUniformFMin" -> forall a. a -> Maybe a
Just Op
OpGroupNonUniformFMin
  a
"OpGroupNonUniformSMax" -> forall a. a -> Maybe a
Just Op
OpGroupNonUniformSMax
  a
"OpGroupNonUniformUMax" -> forall a. a -> Maybe a
Just Op
OpGroupNonUniformUMax
  a
"OpGroupNonUniformFMax" -> forall a. a -> Maybe a
Just Op
OpGroupNonUniformFMax
  a
"OpGroupNonUniformBitwiseAnd" -> forall a. a -> Maybe a
Just Op
OpGroupNonUniformBitwiseAnd
  a
"OpGroupNonUniformBitwiseOr" -> forall a. a -> Maybe a
Just Op
OpGroupNonUniformBitwiseOr
  a
"OpGroupNonUniformBitwiseXor" -> forall a. a -> Maybe a
Just Op
OpGroupNonUniformBitwiseXor
  a
"OpGroupNonUniformLogicalAnd" -> forall a. a -> Maybe a
Just Op
OpGroupNonUniformLogicalAnd
  a
"OpGroupNonUniformLogicalOr" -> forall a. a -> Maybe a
Just Op
OpGroupNonUniformLogicalOr
  a
"OpGroupNonUniformLogicalXor" -> forall a. a -> Maybe a
Just Op
OpGroupNonUniformLogicalXor
  a
"OpGroupNonUniformQuadBroadcast" -> forall a. a -> Maybe a
Just Op
OpGroupNonUniformQuadBroadcast
  a
"OpGroupNonUniformQuadSwap" -> forall a. a -> Maybe a
Just Op
OpGroupNonUniformQuadSwap
  a
"OpCopyLogical" -> forall a. a -> Maybe a
Just Op
OpCopyLogical
  a
"OpPtrEqual" -> forall a. a -> Maybe a
Just Op
OpPtrEqual
  a
"OpPtrNotEqual" -> forall a. a -> Maybe a
Just Op
OpPtrNotEqual
  a
"OpPtrDiff" -> forall a. a -> Maybe a
Just Op
OpPtrDiff
  a
"OpTerminateInvocation" -> forall a. a -> Maybe a
Just Op
OpTerminateInvocation
  a
"OpSubgroupBallotKHR" -> forall a. a -> Maybe a
Just Op
OpSubgroupBallotKHR
  a
"OpSubgroupFirstInvocationKHR" -> forall a. a -> Maybe a
Just Op
OpSubgroupFirstInvocationKHR
  a
"OpSubgroupAllKHR" -> forall a. a -> Maybe a
Just Op
OpSubgroupAllKHR
  a
"OpSubgroupAnyKHR" -> forall a. a -> Maybe a
Just Op
OpSubgroupAnyKHR
  a
"OpSubgroupAllEqualKHR" -> forall a. a -> Maybe a
Just Op
OpSubgroupAllEqualKHR
  a
"OpGroupNonUniformRotateKHR" -> forall a. a -> Maybe a
Just Op
OpGroupNonUniformRotateKHR
  a
"OpSubgroupReadInvocationKHR" -> forall a. a -> Maybe a
Just Op
OpSubgroupReadInvocationKHR
  a
"OpTraceRayKHR" -> forall a. a -> Maybe a
Just Op
OpTraceRayKHR
  a
"OpExecuteCallableKHR" -> forall a. a -> Maybe a
Just Op
OpExecuteCallableKHR
  a
"OpConvertUToAccelerationStructureKHR" -> forall a. a -> Maybe a
Just Op
OpConvertUToAccelerationStructureKHR
  a
"OpIgnoreIntersectionKHR" -> forall a. a -> Maybe a
Just Op
OpIgnoreIntersectionKHR
  a
"OpTerminateRayKHR" -> forall a. a -> Maybe a
Just Op
OpTerminateRayKHR
  a
"OpSDot" -> forall a. a -> Maybe a
Just Op
OpSDot
  a
"OpSDotKHR" -> forall a. a -> Maybe a
Just Op
OpSDotKHR
  a
"OpUDot" -> forall a. a -> Maybe a
Just Op
OpUDot
  a
"OpUDotKHR" -> forall a. a -> Maybe a
Just Op
OpUDotKHR
  a
"OpSUDot" -> forall a. a -> Maybe a
Just Op
OpSUDot
  a
"OpSUDotKHR" -> forall a. a -> Maybe a
Just Op
OpSUDotKHR
  a
"OpSDotAccSat" -> forall a. a -> Maybe a
Just Op
OpSDotAccSat
  a
"OpSDotAccSatKHR" -> forall a. a -> Maybe a
Just Op
OpSDotAccSatKHR
  a
"OpUDotAccSat" -> forall a. a -> Maybe a
Just Op
OpUDotAccSat
  a
"OpUDotAccSatKHR" -> forall a. a -> Maybe a
Just Op
OpUDotAccSatKHR
  a
"OpSUDotAccSat" -> forall a. a -> Maybe a
Just Op
OpSUDotAccSat
  a
"OpSUDotAccSatKHR" -> forall a. a -> Maybe a
Just Op
OpSUDotAccSatKHR
  a
"OpTypeRayQueryKHR" -> forall a. a -> Maybe a
Just Op
OpTypeRayQueryKHR
  a
"OpRayQueryInitializeKHR" -> forall a. a -> Maybe a
Just Op
OpRayQueryInitializeKHR
  a
"OpRayQueryTerminateKHR" -> forall a. a -> Maybe a
Just Op
OpRayQueryTerminateKHR
  a
"OpRayQueryGenerateIntersectionKHR" -> forall a. a -> Maybe a
Just Op
OpRayQueryGenerateIntersectionKHR
  a
"OpRayQueryConfirmIntersectionKHR" -> forall a. a -> Maybe a
Just Op
OpRayQueryConfirmIntersectionKHR
  a
"OpRayQueryProceedKHR" -> forall a. a -> Maybe a
Just Op
OpRayQueryProceedKHR
  a
"OpRayQueryGetIntersectionTypeKHR" -> forall a. a -> Maybe a
Just Op
OpRayQueryGetIntersectionTypeKHR
  a
"OpGroupIAddNonUniformAMD" -> forall a. a -> Maybe a
Just Op
OpGroupIAddNonUniformAMD
  a
"OpGroupFAddNonUniformAMD" -> forall a. a -> Maybe a
Just Op
OpGroupFAddNonUniformAMD
  a
"OpGroupFMinNonUniformAMD" -> forall a. a -> Maybe a
Just Op
OpGroupFMinNonUniformAMD
  a
"OpGroupUMinNonUniformAMD" -> forall a. a -> Maybe a
Just Op
OpGroupUMinNonUniformAMD
  a
"OpGroupSMinNonUniformAMD" -> forall a. a -> Maybe a
Just Op
OpGroupSMinNonUniformAMD
  a
"OpGroupFMaxNonUniformAMD" -> forall a. a -> Maybe a
Just Op
OpGroupFMaxNonUniformAMD
  a
"OpGroupUMaxNonUniformAMD" -> forall a. a -> Maybe a
Just Op
OpGroupUMaxNonUniformAMD
  a
"OpGroupSMaxNonUniformAMD" -> forall a. a -> Maybe a
Just Op
OpGroupSMaxNonUniformAMD
  a
"OpFragmentMaskFetchAMD" -> forall a. a -> Maybe a
Just Op
OpFragmentMaskFetchAMD
  a
"OpFragmentFetchAMD" -> forall a. a -> Maybe a
Just Op
OpFragmentFetchAMD
  a
"OpReadClockKHR" -> forall a. a -> Maybe a
Just Op
OpReadClockKHR
  a
"OpHitObjectRecordHitMotionNV" -> forall a. a -> Maybe a
Just Op
OpHitObjectRecordHitMotionNV
  a
"OpHitObjectRecordHitWithIndexMotionNV" -> forall a. a -> Maybe a
Just Op
OpHitObjectRecordHitWithIndexMotionNV
  a
"OpHitObjectRecordMissMotionNV" -> forall a. a -> Maybe a
Just Op
OpHitObjectRecordMissMotionNV
  a
"OpHitObjectGetWorldToObjectNV" -> forall a. a -> Maybe a
Just Op
OpHitObjectGetWorldToObjectNV
  a
"OpHitObjectGetObjectToWorldNV" -> forall a. a -> Maybe a
Just Op
OpHitObjectGetObjectToWorldNV
  a
"OpHitObjectGetObjectRayDirectionNV" -> forall a. a -> Maybe a
Just Op
OpHitObjectGetObjectRayDirectionNV
  a
"OpHitObjectGetObjectRayOriginNV" -> forall a. a -> Maybe a
Just Op
OpHitObjectGetObjectRayOriginNV
  a
"OpHitObjectTraceRayMotionNV" -> forall a. a -> Maybe a
Just Op
OpHitObjectTraceRayMotionNV
  a
"OpHitObjectGetShaderRecordBufferHandleNV" -> forall a. a -> Maybe a
Just Op
OpHitObjectGetShaderRecordBufferHandleNV
  a
"OpHitObjectGetShaderBindingTableRecordIndexNV" -> forall a. a -> Maybe a
Just Op
OpHitObjectGetShaderBindingTableRecordIndexNV
  a
"OpHitObjectRecordEmptyNV" -> forall a. a -> Maybe a
Just Op
OpHitObjectRecordEmptyNV
  a
"OpHitObjectTraceRayNV" -> forall a. a -> Maybe a
Just Op
OpHitObjectTraceRayNV
  a
"OpHitObjectRecordHitNV" -> forall a. a -> Maybe a
Just Op
OpHitObjectRecordHitNV
  a
"OpHitObjectRecordHitWithIndexNV" -> forall a. a -> Maybe a
Just Op
OpHitObjectRecordHitWithIndexNV
  a
"OpHitObjectRecordMissNV" -> forall a. a -> Maybe a
Just Op
OpHitObjectRecordMissNV
  a
"OpHitObjectExecuteShaderNV" -> forall a. a -> Maybe a
Just Op
OpHitObjectExecuteShaderNV
  a
"OpHitObjectGetCurrentTimeNV" -> forall a. a -> Maybe a
Just Op
OpHitObjectGetCurrentTimeNV
  a
"OpHitObjectGetAttributesNV" -> forall a. a -> Maybe a
Just Op
OpHitObjectGetAttributesNV
  a
"OpHitObjectGetHitKindNV" -> forall a. a -> Maybe a
Just Op
OpHitObjectGetHitKindNV
  a
"OpHitObjectGetPrimitiveIndexNV" -> forall a. a -> Maybe a
Just Op
OpHitObjectGetPrimitiveIndexNV
  a
"OpHitObjectGetGeometryIndexNV" -> forall a. a -> Maybe a
Just Op
OpHitObjectGetGeometryIndexNV
  a
"OpHitObjectGetInstanceIdNV" -> forall a. a -> Maybe a
Just Op
OpHitObjectGetInstanceIdNV
  a
"OpHitObjectGetInstanceCustomIndexNV" -> forall a. a -> Maybe a
Just Op
OpHitObjectGetInstanceCustomIndexNV
  a
"OpHitObjectGetWorldRayDirectionNV" -> forall a. a -> Maybe a
Just Op
OpHitObjectGetWorldRayDirectionNV
  a
"OpHitObjectGetWorldRayOriginNV" -> forall a. a -> Maybe a
Just Op
OpHitObjectGetWorldRayOriginNV
  a
"OpHitObjectGetRayTMaxNV" -> forall a. a -> Maybe a
Just Op
OpHitObjectGetRayTMaxNV
  a
"OpHitObjectGetRayTMinNV" -> forall a. a -> Maybe a
Just Op
OpHitObjectGetRayTMinNV
  a
"OpHitObjectIsEmptyNV" -> forall a. a -> Maybe a
Just Op
OpHitObjectIsEmptyNV
  a
"OpHitObjectIsHitNV" -> forall a. a -> Maybe a
Just Op
OpHitObjectIsHitNV
  a
"OpHitObjectIsMissNV" -> forall a. a -> Maybe a
Just Op
OpHitObjectIsMissNV
  a
"OpReorderThreadWithHitObjectNV" -> forall a. a -> Maybe a
Just Op
OpReorderThreadWithHitObjectNV
  a
"OpReorderThreadWithHintNV" -> forall a. a -> Maybe a
Just Op
OpReorderThreadWithHintNV
  a
"OpTypeHitObjectNV" -> forall a. a -> Maybe a
Just Op
OpTypeHitObjectNV
  a
"OpImageSampleFootprintNV" -> forall a. a -> Maybe a
Just Op
OpImageSampleFootprintNV
  a
"OpEmitMeshTasksEXT" -> forall a. a -> Maybe a
Just Op
OpEmitMeshTasksEXT
  a
"OpSetMeshOutputsEXT" -> forall a. a -> Maybe a
Just Op
OpSetMeshOutputsEXT
  a
"OpGroupNonUniformPartitionNV" -> forall a. a -> Maybe a
Just Op
OpGroupNonUniformPartitionNV
  a
"OpWritePackedPrimitiveIndices4x8NV" -> forall a. a -> Maybe a
Just Op
OpWritePackedPrimitiveIndices4x8NV
  a
"OpReportIntersectionKHR" -> forall a. a -> Maybe a
Just Op
OpReportIntersectionKHR
  a
"OpReportIntersectionNV" -> forall a. a -> Maybe a
Just Op
OpReportIntersectionNV
  a
"OpIgnoreIntersectionNV" -> forall a. a -> Maybe a
Just Op
OpIgnoreIntersectionNV
  a
"OpTerminateRayNV" -> forall a. a -> Maybe a
Just Op
OpTerminateRayNV
  a
"OpTraceNV" -> forall a. a -> Maybe a
Just Op
OpTraceNV
  a
"OpTraceMotionNV" -> forall a. a -> Maybe a
Just Op
OpTraceMotionNV
  a
"OpTraceRayMotionNV" -> forall a. a -> Maybe a
Just Op
OpTraceRayMotionNV
  a
"OpTypeAccelerationStructureKHR" -> forall a. a -> Maybe a
Just Op
OpTypeAccelerationStructureKHR
  a
"OpTypeAccelerationStructureNV" -> forall a. a -> Maybe a
Just Op
OpTypeAccelerationStructureNV
  a
"OpExecuteCallableNV" -> forall a. a -> Maybe a
Just Op
OpExecuteCallableNV
  a
"OpTypeCooperativeMatrixNV" -> forall a. a -> Maybe a
Just Op
OpTypeCooperativeMatrixNV
  a
"OpCooperativeMatrixLoadNV" -> forall a. a -> Maybe a
Just Op
OpCooperativeMatrixLoadNV
  a
"OpCooperativeMatrixStoreNV" -> forall a. a -> Maybe a
Just Op
OpCooperativeMatrixStoreNV
  a
"OpCooperativeMatrixMulAddNV" -> forall a. a -> Maybe a
Just Op
OpCooperativeMatrixMulAddNV
  a
"OpCooperativeMatrixLengthNV" -> forall a. a -> Maybe a
Just Op
OpCooperativeMatrixLengthNV
  a
"OpBeginInvocationInterlockEXT" -> forall a. a -> Maybe a
Just Op
OpBeginInvocationInterlockEXT
  a
"OpEndInvocationInterlockEXT" -> forall a. a -> Maybe a
Just Op
OpEndInvocationInterlockEXT
  a
"OpDemoteToHelperInvocation" -> forall a. a -> Maybe a
Just Op
OpDemoteToHelperInvocation
  a
"OpDemoteToHelperInvocationEXT" -> forall a. a -> Maybe a
Just Op
OpDemoteToHelperInvocationEXT
  a
"OpIsHelperInvocationEXT" -> forall a. a -> Maybe a
Just Op
OpIsHelperInvocationEXT
  a
"OpConvertUToImageNV" -> forall a. a -> Maybe a
Just Op
OpConvertUToImageNV
  a
"OpConvertUToSamplerNV" -> forall a. a -> Maybe a
Just Op
OpConvertUToSamplerNV
  a
"OpConvertImageToUNV" -> forall a. a -> Maybe a
Just Op
OpConvertImageToUNV
  a
"OpConvertSamplerToUNV" -> forall a. a -> Maybe a
Just Op
OpConvertSamplerToUNV
  a
"OpConvertUToSampledImageNV" -> forall a. a -> Maybe a
Just Op
OpConvertUToSampledImageNV
  a
"OpConvertSampledImageToUNV" -> forall a. a -> Maybe a
Just Op
OpConvertSampledImageToUNV
  a
"OpSamplerImageAddressingModeNV" -> forall a. a -> Maybe a
Just Op
OpSamplerImageAddressingModeNV
  a
"OpSubgroupShuffleINTEL" -> forall a. a -> Maybe a
Just Op
OpSubgroupShuffleINTEL
  a
"OpSubgroupShuffleDownINTEL" -> forall a. a -> Maybe a
Just Op
OpSubgroupShuffleDownINTEL
  a
"OpSubgroupShuffleUpINTEL" -> forall a. a -> Maybe a
Just Op
OpSubgroupShuffleUpINTEL
  a
"OpSubgroupShuffleXorINTEL" -> forall a. a -> Maybe a
Just Op
OpSubgroupShuffleXorINTEL
  a
"OpSubgroupBlockReadINTEL" -> forall a. a -> Maybe a
Just Op
OpSubgroupBlockReadINTEL
  a
"OpSubgroupBlockWriteINTEL" -> forall a. a -> Maybe a
Just Op
OpSubgroupBlockWriteINTEL
  a
"OpSubgroupImageBlockReadINTEL" -> forall a. a -> Maybe a
Just Op
OpSubgroupImageBlockReadINTEL
  a
"OpSubgroupImageBlockWriteINTEL" -> forall a. a -> Maybe a
Just Op
OpSubgroupImageBlockWriteINTEL
  a
"OpSubgroupImageMediaBlockReadINTEL" -> forall a. a -> Maybe a
Just Op
OpSubgroupImageMediaBlockReadINTEL
  a
"OpSubgroupImageMediaBlockWriteINTEL" -> forall a. a -> Maybe a
Just Op
OpSubgroupImageMediaBlockWriteINTEL
  a
"OpUCountLeadingZerosINTEL" -> forall a. a -> Maybe a
Just Op
OpUCountLeadingZerosINTEL
  a
"OpUCountTrailingZerosINTEL" -> forall a. a -> Maybe a
Just Op
OpUCountTrailingZerosINTEL
  a
"OpAbsISubINTEL" -> forall a. a -> Maybe a
Just Op
OpAbsISubINTEL
  a
"OpAbsUSubINTEL" -> forall a. a -> Maybe a
Just Op
OpAbsUSubINTEL
  a
"OpIAddSatINTEL" -> forall a. a -> Maybe a
Just Op
OpIAddSatINTEL
  a
"OpUAddSatINTEL" -> forall a. a -> Maybe a
Just Op
OpUAddSatINTEL
  a
"OpIAverageINTEL" -> forall a. a -> Maybe a
Just Op
OpIAverageINTEL
  a
"OpUAverageINTEL" -> forall a. a -> Maybe a
Just Op
OpUAverageINTEL
  a
"OpIAverageRoundedINTEL" -> forall a. a -> Maybe a
Just Op
OpIAverageRoundedINTEL
  a
"OpUAverageRoundedINTEL" -> forall a. a -> Maybe a
Just Op
OpUAverageRoundedINTEL
  a
"OpISubSatINTEL" -> forall a. a -> Maybe a
Just Op
OpISubSatINTEL
  a
"OpUSubSatINTEL" -> forall a. a -> Maybe a
Just Op
OpUSubSatINTEL
  a
"OpIMul32x16INTEL" -> forall a. a -> Maybe a
Just Op
OpIMul32x16INTEL
  a
"OpUMul32x16INTEL" -> forall a. a -> Maybe a
Just Op
OpUMul32x16INTEL
  a
"OpConstantFunctionPointerINTEL" -> forall a. a -> Maybe a
Just Op
OpConstantFunctionPointerINTEL
  a
"OpFunctionPointerCallINTEL" -> forall a. a -> Maybe a
Just Op
OpFunctionPointerCallINTEL
  a
"OpAsmTargetINTEL" -> forall a. a -> Maybe a
Just Op
OpAsmTargetINTEL
  a
"OpAsmINTEL" -> forall a. a -> Maybe a
Just Op
OpAsmINTEL
  a
"OpAsmCallINTEL" -> forall a. a -> Maybe a
Just Op
OpAsmCallINTEL
  a
"OpAtomicFMinEXT" -> forall a. a -> Maybe a
Just Op
OpAtomicFMinEXT
  a
"OpAtomicFMaxEXT" -> forall a. a -> Maybe a
Just Op
OpAtomicFMaxEXT
  a
"OpAssumeTrueKHR" -> forall a. a -> Maybe a
Just Op
OpAssumeTrueKHR
  a
"OpExpectKHR" -> forall a. a -> Maybe a
Just Op
OpExpectKHR
  a
"OpDecorateString" -> forall a. a -> Maybe a
Just Op
OpDecorateString
  a
"OpDecorateStringGOOGLE" -> forall a. a -> Maybe a
Just Op
OpDecorateStringGOOGLE
  a
"OpMemberDecorateString" -> forall a. a -> Maybe a
Just Op
OpMemberDecorateString
  a
"OpMemberDecorateStringGOOGLE" -> forall a. a -> Maybe a
Just Op
OpMemberDecorateStringGOOGLE
  a
"OpVmeImageINTEL" -> forall a. a -> Maybe a
Just Op
OpVmeImageINTEL
  a
"OpTypeVmeImageINTEL" -> forall a. a -> Maybe a
Just Op
OpTypeVmeImageINTEL
  a
"OpTypeAvcImePayloadINTEL" -> forall a. a -> Maybe a
Just Op
OpTypeAvcImePayloadINTEL
  a
"OpTypeAvcRefPayloadINTEL" -> forall a. a -> Maybe a
Just Op
OpTypeAvcRefPayloadINTEL
  a
"OpTypeAvcSicPayloadINTEL" -> forall a. a -> Maybe a
Just Op
OpTypeAvcSicPayloadINTEL
  a
"OpTypeAvcMcePayloadINTEL" -> forall a. a -> Maybe a
Just Op
OpTypeAvcMcePayloadINTEL
  a
"OpTypeAvcMceResultINTEL" -> forall a. a -> Maybe a
Just Op
OpTypeAvcMceResultINTEL
  a
"OpTypeAvcImeResultINTEL" -> forall a. a -> Maybe a
Just Op
OpTypeAvcImeResultINTEL
  a
"OpTypeAvcImeResultSingleReferenceStreamoutINTEL" -> forall a. a -> Maybe a
Just Op
OpTypeAvcImeResultSingleReferenceStreamoutINTEL
  a
"OpTypeAvcImeResultDualReferenceStreamoutINTEL" -> forall a. a -> Maybe a
Just Op
OpTypeAvcImeResultDualReferenceStreamoutINTEL
  a
"OpTypeAvcImeSingleReferenceStreaminINTEL" -> forall a. a -> Maybe a
Just Op
OpTypeAvcImeSingleReferenceStreaminINTEL
  a
"OpTypeAvcImeDualReferenceStreaminINTEL" -> forall a. a -> Maybe a
Just Op
OpTypeAvcImeDualReferenceStreaminINTEL
  a
"OpTypeAvcRefResultINTEL" -> forall a. a -> Maybe a
Just Op
OpTypeAvcRefResultINTEL
  a
"OpTypeAvcSicResultINTEL" -> forall a. a -> Maybe a
Just Op
OpTypeAvcSicResultINTEL
  a
"OpSubgroupAvcMceGetDefaultInterBaseMultiReferencePenaltyINTEL" -> forall a. a -> Maybe a
Just Op
OpSubgroupAvcMceGetDefaultInterBaseMultiReferencePenaltyINTEL
  a
"OpSubgroupAvcMceSetInterBaseMultiReferencePenaltyINTEL" -> forall a. a -> Maybe a
Just Op
OpSubgroupAvcMceSetInterBaseMultiReferencePenaltyINTEL
  a
"OpSubgroupAvcMceGetDefaultInterShapePenaltyINTEL" -> forall a. a -> Maybe a
Just Op
OpSubgroupAvcMceGetDefaultInterShapePenaltyINTEL
  a
"OpSubgroupAvcMceSetInterShapePenaltyINTEL" -> forall a. a -> Maybe a
Just Op
OpSubgroupAvcMceSetInterShapePenaltyINTEL
  a
"OpSubgroupAvcMceGetDefaultInterDirectionPenaltyINTEL" -> forall a. a -> Maybe a
Just Op
OpSubgroupAvcMceGetDefaultInterDirectionPenaltyINTEL
  a
"OpSubgroupAvcMceSetInterDirectionPenaltyINTEL" -> forall a. a -> Maybe a
Just Op
OpSubgroupAvcMceSetInterDirectionPenaltyINTEL
  a
"OpSubgroupAvcMceGetDefaultIntraLumaShapePenaltyINTEL" -> forall a. a -> Maybe a
Just Op
OpSubgroupAvcMceGetDefaultIntraLumaShapePenaltyINTEL
  a
"OpSubgroupAvcMceGetDefaultInterMotionVectorCostTableINTEL" -> forall a. a -> Maybe a
Just Op
OpSubgroupAvcMceGetDefaultInterMotionVectorCostTableINTEL
  a
"OpSubgroupAvcMceGetDefaultHighPenaltyCostTableINTEL" -> forall a. a -> Maybe a
Just Op
OpSubgroupAvcMceGetDefaultHighPenaltyCostTableINTEL
  a
"OpSubgroupAvcMceGetDefaultMediumPenaltyCostTableINTEL" -> forall a. a -> Maybe a
Just Op
OpSubgroupAvcMceGetDefaultMediumPenaltyCostTableINTEL
  a
"OpSubgroupAvcMceGetDefaultLowPenaltyCostTableINTEL" -> forall a. a -> Maybe a
Just Op
OpSubgroupAvcMceGetDefaultLowPenaltyCostTableINTEL
  a
"OpSubgroupAvcMceSetMotionVectorCostFunctionINTEL" -> forall a. a -> Maybe a
Just Op
OpSubgroupAvcMceSetMotionVectorCostFunctionINTEL
  a
"OpSubgroupAvcMceGetDefaultIntraLumaModePenaltyINTEL" -> forall a. a -> Maybe a
Just Op
OpSubgroupAvcMceGetDefaultIntraLumaModePenaltyINTEL
  a
"OpSubgroupAvcMceGetDefaultNonDcLumaIntraPenaltyINTEL" -> forall a. a -> Maybe a
Just Op
OpSubgroupAvcMceGetDefaultNonDcLumaIntraPenaltyINTEL
  a
"OpSubgroupAvcMceGetDefaultIntraChromaModeBasePenaltyINTEL" -> forall a. a -> Maybe a
Just Op
OpSubgroupAvcMceGetDefaultIntraChromaModeBasePenaltyINTEL
  a
"OpSubgroupAvcMceSetAcOnlyHaarINTEL" -> forall a. a -> Maybe a
Just Op
OpSubgroupAvcMceSetAcOnlyHaarINTEL
  a
"OpSubgroupAvcMceSetSourceInterlacedFieldPolarityINTEL" -> forall a. a -> Maybe a
Just Op
OpSubgroupAvcMceSetSourceInterlacedFieldPolarityINTEL
  a
"OpSubgroupAvcMceSetSingleReferenceInterlacedFieldPolarityINTEL" -> forall a. a -> Maybe a
Just Op
OpSubgroupAvcMceSetSingleReferenceInterlacedFieldPolarityINTEL
  a
"OpSubgroupAvcMceSetDualReferenceInterlacedFieldPolaritiesINTEL" -> forall a. a -> Maybe a
Just Op
OpSubgroupAvcMceSetDualReferenceInterlacedFieldPolaritiesINTEL
  a
"OpSubgroupAvcMceConvertToImePayloadINTEL" -> forall a. a -> Maybe a
Just Op
OpSubgroupAvcMceConvertToImePayloadINTEL
  a
"OpSubgroupAvcMceConvertToImeResultINTEL" -> forall a. a -> Maybe a
Just Op
OpSubgroupAvcMceConvertToImeResultINTEL
  a
"OpSubgroupAvcMceConvertToRefPayloadINTEL" -> forall a. a -> Maybe a
Just Op
OpSubgroupAvcMceConvertToRefPayloadINTEL
  a
"OpSubgroupAvcMceConvertToRefResultINTEL" -> forall a. a -> Maybe a
Just Op
OpSubgroupAvcMceConvertToRefResultINTEL
  a
"OpSubgroupAvcMceConvertToSicPayloadINTEL" -> forall a. a -> Maybe a
Just Op
OpSubgroupAvcMceConvertToSicPayloadINTEL
  a
"OpSubgroupAvcMceConvertToSicResultINTEL" -> forall a. a -> Maybe a
Just Op
OpSubgroupAvcMceConvertToSicResultINTEL
  a
"OpSubgroupAvcMceGetMotionVectorsINTEL" -> forall a. a -> Maybe a
Just Op
OpSubgroupAvcMceGetMotionVectorsINTEL
  a
"OpSubgroupAvcMceGetInterDistortionsINTEL" -> forall a. a -> Maybe a
Just Op
OpSubgroupAvcMceGetInterDistortionsINTEL
  a
"OpSubgroupAvcMceGetBestInterDistortionsINTEL" -> forall a. a -> Maybe a
Just Op
OpSubgroupAvcMceGetBestInterDistortionsINTEL
  a
"OpSubgroupAvcMceGetInterMajorShapeINTEL" -> forall a. a -> Maybe a
Just Op
OpSubgroupAvcMceGetInterMajorShapeINTEL
  a
"OpSubgroupAvcMceGetInterMinorShapeINTEL" -> forall a. a -> Maybe a
Just Op
OpSubgroupAvcMceGetInterMinorShapeINTEL
  a
"OpSubgroupAvcMceGetInterDirectionsINTEL" -> forall a. a -> Maybe a
Just Op
OpSubgroupAvcMceGetInterDirectionsINTEL
  a
"OpSubgroupAvcMceGetInterMotionVectorCountINTEL" -> forall a. a -> Maybe a
Just Op
OpSubgroupAvcMceGetInterMotionVectorCountINTEL
  a
"OpSubgroupAvcMceGetInterReferenceIdsINTEL" -> forall a. a -> Maybe a
Just Op
OpSubgroupAvcMceGetInterReferenceIdsINTEL
  a
"OpSubgroupAvcMceGetInterReferenceInterlacedFieldPolaritiesINTEL" -> forall a. a -> Maybe a
Just Op
OpSubgroupAvcMceGetInterReferenceInterlacedFieldPolaritiesINTEL
  a
"OpSubgroupAvcImeInitializeINTEL" -> forall a. a -> Maybe a
Just Op
OpSubgroupAvcImeInitializeINTEL
  a
"OpSubgroupAvcImeSetSingleReferenceINTEL" -> forall a. a -> Maybe a
Just Op
OpSubgroupAvcImeSetSingleReferenceINTEL
  a
"OpSubgroupAvcImeSetDualReferenceINTEL" -> forall a. a -> Maybe a
Just Op
OpSubgroupAvcImeSetDualReferenceINTEL
  a
"OpSubgroupAvcImeRefWindowSizeINTEL" -> forall a. a -> Maybe a
Just Op
OpSubgroupAvcImeRefWindowSizeINTEL
  a
"OpSubgroupAvcImeAdjustRefOffsetINTEL" -> forall a. a -> Maybe a
Just Op
OpSubgroupAvcImeAdjustRefOffsetINTEL
  a
"OpSubgroupAvcImeConvertToMcePayloadINTEL" -> forall a. a -> Maybe a
Just Op
OpSubgroupAvcImeConvertToMcePayloadINTEL
  a
"OpSubgroupAvcImeSetMaxMotionVectorCountINTEL" -> forall a. a -> Maybe a
Just Op
OpSubgroupAvcImeSetMaxMotionVectorCountINTEL
  a
"OpSubgroupAvcImeSetUnidirectionalMixDisableINTEL" -> forall a. a -> Maybe a
Just Op
OpSubgroupAvcImeSetUnidirectionalMixDisableINTEL
  a
"OpSubgroupAvcImeSetEarlySearchTerminationThresholdINTEL" -> forall a. a -> Maybe a
Just Op
OpSubgroupAvcImeSetEarlySearchTerminationThresholdINTEL
  a
"OpSubgroupAvcImeSetWeightedSadINTEL" -> forall a. a -> Maybe a
Just Op
OpSubgroupAvcImeSetWeightedSadINTEL
  a
"OpSubgroupAvcImeEvaluateWithSingleReferenceINTEL" -> forall a. a -> Maybe a
Just Op
OpSubgroupAvcImeEvaluateWithSingleReferenceINTEL
  a
"OpSubgroupAvcImeEvaluateWithDualReferenceINTEL" -> forall a. a -> Maybe a
Just Op
OpSubgroupAvcImeEvaluateWithDualReferenceINTEL
  a
"OpSubgroupAvcImeEvaluateWithSingleReferenceStreaminINTEL" -> forall a. a -> Maybe a
Just Op
OpSubgroupAvcImeEvaluateWithSingleReferenceStreaminINTEL
  a
"OpSubgroupAvcImeEvaluateWithDualReferenceStreaminINTEL" -> forall a. a -> Maybe a
Just Op
OpSubgroupAvcImeEvaluateWithDualReferenceStreaminINTEL
  a
"OpSubgroupAvcImeEvaluateWithSingleReferenceStreamoutINTEL" -> forall a. a -> Maybe a
Just Op
OpSubgroupAvcImeEvaluateWithSingleReferenceStreamoutINTEL
  a
"OpSubgroupAvcImeEvaluateWithDualReferenceStreamoutINTEL" -> forall a. a -> Maybe a
Just Op
OpSubgroupAvcImeEvaluateWithDualReferenceStreamoutINTEL
  a
"OpSubgroupAvcImeEvaluateWithSingleReferenceStreaminoutINTEL" -> forall a. a -> Maybe a
Just Op
OpSubgroupAvcImeEvaluateWithSingleReferenceStreaminoutINTEL
  a
"OpSubgroupAvcImeEvaluateWithDualReferenceStreaminoutINTEL" -> forall a. a -> Maybe a
Just Op
OpSubgroupAvcImeEvaluateWithDualReferenceStreaminoutINTEL
  a
"OpSubgroupAvcImeConvertToMceResultINTEL" -> forall a. a -> Maybe a
Just Op
OpSubgroupAvcImeConvertToMceResultINTEL
  a
"OpSubgroupAvcImeGetSingleReferenceStreaminINTEL" -> forall a. a -> Maybe a
Just Op
OpSubgroupAvcImeGetSingleReferenceStreaminINTEL
  a
"OpSubgroupAvcImeGetDualReferenceStreaminINTEL" -> forall a. a -> Maybe a
Just Op
OpSubgroupAvcImeGetDualReferenceStreaminINTEL
  a
"OpSubgroupAvcImeStripSingleReferenceStreamoutINTEL" -> forall a. a -> Maybe a
Just Op
OpSubgroupAvcImeStripSingleReferenceStreamoutINTEL
  a
"OpSubgroupAvcImeStripDualReferenceStreamoutINTEL" -> forall a. a -> Maybe a
Just Op
OpSubgroupAvcImeStripDualReferenceStreamoutINTEL
  a
"OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeMotionVectorsINTEL" -> forall a. a -> Maybe a
Just Op
OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeMotionVectorsINTEL
  a
"OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeDistortionsINTEL" -> forall a. a -> Maybe a
Just Op
OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeDistortionsINTEL
  a
"OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeReferenceIdsINTEL" -> forall a. a -> Maybe a
Just Op
OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeReferenceIdsINTEL
  a
"OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeMotionVectorsINTEL" -> forall a. a -> Maybe a
Just Op
OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeMotionVectorsINTEL
  a
"OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeDistortionsINTEL" -> forall a. a -> Maybe a
Just Op
OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeDistortionsINTEL
  a
"OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeReferenceIdsINTEL" -> forall a. a -> Maybe a
Just Op
OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeReferenceIdsINTEL
  a
"OpSubgroupAvcImeGetBorderReachedINTEL" -> forall a. a -> Maybe a
Just Op
OpSubgroupAvcImeGetBorderReachedINTEL
  a
"OpSubgroupAvcImeGetTruncatedSearchIndicationINTEL" -> forall a. a -> Maybe a
Just Op
OpSubgroupAvcImeGetTruncatedSearchIndicationINTEL
  a
"OpSubgroupAvcImeGetUnidirectionalEarlySearchTerminationINTEL" -> forall a. a -> Maybe a
Just Op
OpSubgroupAvcImeGetUnidirectionalEarlySearchTerminationINTEL
  a
"OpSubgroupAvcImeGetWeightingPatternMinimumMotionVectorINTEL" -> forall a. a -> Maybe a
Just Op
OpSubgroupAvcImeGetWeightingPatternMinimumMotionVectorINTEL
  a
"OpSubgroupAvcImeGetWeightingPatternMinimumDistortionINTEL" -> forall a. a -> Maybe a
Just Op
OpSubgroupAvcImeGetWeightingPatternMinimumDistortionINTEL
  a
"OpSubgroupAvcFmeInitializeINTEL" -> forall a. a -> Maybe a
Just Op
OpSubgroupAvcFmeInitializeINTEL
  a
"OpSubgroupAvcBmeInitializeINTEL" -> forall a. a -> Maybe a
Just Op
OpSubgroupAvcBmeInitializeINTEL
  a
"OpSubgroupAvcRefConvertToMcePayloadINTEL" -> forall a. a -> Maybe a
Just Op
OpSubgroupAvcRefConvertToMcePayloadINTEL
  a
"OpSubgroupAvcRefSetBidirectionalMixDisableINTEL" -> forall a. a -> Maybe a
Just Op
OpSubgroupAvcRefSetBidirectionalMixDisableINTEL
  a
"OpSubgroupAvcRefSetBilinearFilterEnableINTEL" -> forall a. a -> Maybe a
Just Op
OpSubgroupAvcRefSetBilinearFilterEnableINTEL
  a
"OpSubgroupAvcRefEvaluateWithSingleReferenceINTEL" -> forall a. a -> Maybe a
Just Op
OpSubgroupAvcRefEvaluateWithSingleReferenceINTEL
  a
"OpSubgroupAvcRefEvaluateWithDualReferenceINTEL" -> forall a. a -> Maybe a
Just Op
OpSubgroupAvcRefEvaluateWithDualReferenceINTEL
  a
"OpSubgroupAvcRefEvaluateWithMultiReferenceINTEL" -> forall a. a -> Maybe a
Just Op
OpSubgroupAvcRefEvaluateWithMultiReferenceINTEL
  a
"OpSubgroupAvcRefEvaluateWithMultiReferenceInterlacedINTEL" -> forall a. a -> Maybe a
Just Op
OpSubgroupAvcRefEvaluateWithMultiReferenceInterlacedINTEL
  a
"OpSubgroupAvcRefConvertToMceResultINTEL" -> forall a. a -> Maybe a
Just Op
OpSubgroupAvcRefConvertToMceResultINTEL
  a
"OpSubgroupAvcSicInitializeINTEL" -> forall a. a -> Maybe a
Just Op
OpSubgroupAvcSicInitializeINTEL
  a
"OpSubgroupAvcSicConfigureSkcINTEL" -> forall a. a -> Maybe a
Just Op
OpSubgroupAvcSicConfigureSkcINTEL
  a
"OpSubgroupAvcSicConfigureIpeLumaINTEL" -> forall a. a -> Maybe a
Just Op
OpSubgroupAvcSicConfigureIpeLumaINTEL
  a
"OpSubgroupAvcSicConfigureIpeLumaChromaINTEL" -> forall a. a -> Maybe a
Just Op
OpSubgroupAvcSicConfigureIpeLumaChromaINTEL
  a
"OpSubgroupAvcSicGetMotionVectorMaskINTEL" -> forall a. a -> Maybe a
Just Op
OpSubgroupAvcSicGetMotionVectorMaskINTEL
  a
"OpSubgroupAvcSicConvertToMcePayloadINTEL" -> forall a. a -> Maybe a
Just Op
OpSubgroupAvcSicConvertToMcePayloadINTEL
  a
"OpSubgroupAvcSicSetIntraLumaShapePenaltyINTEL" -> forall a. a -> Maybe a
Just Op
OpSubgroupAvcSicSetIntraLumaShapePenaltyINTEL
  a
"OpSubgroupAvcSicSetIntraLumaModeCostFunctionINTEL" -> forall a. a -> Maybe a
Just Op
OpSubgroupAvcSicSetIntraLumaModeCostFunctionINTEL
  a
"OpSubgroupAvcSicSetIntraChromaModeCostFunctionINTEL" -> forall a. a -> Maybe a
Just Op
OpSubgroupAvcSicSetIntraChromaModeCostFunctionINTEL
  a
"OpSubgroupAvcSicSetBilinearFilterEnableINTEL" -> forall a. a -> Maybe a
Just Op
OpSubgroupAvcSicSetBilinearFilterEnableINTEL
  a
"OpSubgroupAvcSicSetSkcForwardTransformEnableINTEL" -> forall a. a -> Maybe a
Just Op
OpSubgroupAvcSicSetSkcForwardTransformEnableINTEL
  a
"OpSubgroupAvcSicSetBlockBasedRawSkipSadINTEL" -> forall a. a -> Maybe a
Just Op
OpSubgroupAvcSicSetBlockBasedRawSkipSadINTEL
  a
"OpSubgroupAvcSicEvaluateIpeINTEL" -> forall a. a -> Maybe a
Just Op
OpSubgroupAvcSicEvaluateIpeINTEL
  a
"OpSubgroupAvcSicEvaluateWithSingleReferenceINTEL" -> forall a. a -> Maybe a
Just Op
OpSubgroupAvcSicEvaluateWithSingleReferenceINTEL
  a
"OpSubgroupAvcSicEvaluateWithDualReferenceINTEL" -> forall a. a -> Maybe a
Just Op
OpSubgroupAvcSicEvaluateWithDualReferenceINTEL
  a
"OpSubgroupAvcSicEvaluateWithMultiReferenceINTEL" -> forall a. a -> Maybe a
Just Op
OpSubgroupAvcSicEvaluateWithMultiReferenceINTEL
  a
"OpSubgroupAvcSicEvaluateWithMultiReferenceInterlacedINTEL" -> forall a. a -> Maybe a
Just Op
OpSubgroupAvcSicEvaluateWithMultiReferenceInterlacedINTEL
  a
"OpSubgroupAvcSicConvertToMceResultINTEL" -> forall a. a -> Maybe a
Just Op
OpSubgroupAvcSicConvertToMceResultINTEL
  a
"OpSubgroupAvcSicGetIpeLumaShapeINTEL" -> forall a. a -> Maybe a
Just Op
OpSubgroupAvcSicGetIpeLumaShapeINTEL
  a
"OpSubgroupAvcSicGetBestIpeLumaDistortionINTEL" -> forall a. a -> Maybe a
Just Op
OpSubgroupAvcSicGetBestIpeLumaDistortionINTEL
  a
"OpSubgroupAvcSicGetBestIpeChromaDistortionINTEL" -> forall a. a -> Maybe a
Just Op
OpSubgroupAvcSicGetBestIpeChromaDistortionINTEL
  a
"OpSubgroupAvcSicGetPackedIpeLumaModesINTEL" -> forall a. a -> Maybe a
Just Op
OpSubgroupAvcSicGetPackedIpeLumaModesINTEL
  a
"OpSubgroupAvcSicGetIpeChromaModeINTEL" -> forall a. a -> Maybe a
Just Op
OpSubgroupAvcSicGetIpeChromaModeINTEL
  a
"OpSubgroupAvcSicGetPackedSkcLumaCountThresholdINTEL" -> forall a. a -> Maybe a
Just Op
OpSubgroupAvcSicGetPackedSkcLumaCountThresholdINTEL
  a
"OpSubgroupAvcSicGetPackedSkcLumaSumThresholdINTEL" -> forall a. a -> Maybe a
Just Op
OpSubgroupAvcSicGetPackedSkcLumaSumThresholdINTEL
  a
"OpSubgroupAvcSicGetInterRawSadsINTEL" -> forall a. a -> Maybe a
Just Op
OpSubgroupAvcSicGetInterRawSadsINTEL
  a
"OpVariableLengthArrayINTEL" -> forall a. a -> Maybe a
Just Op
OpVariableLengthArrayINTEL
  a
"OpSaveMemoryINTEL" -> forall a. a -> Maybe a
Just Op
OpSaveMemoryINTEL
  a
"OpRestoreMemoryINTEL" -> forall a. a -> Maybe a
Just Op
OpRestoreMemoryINTEL
  a
"OpArbitraryFloatSinCosPiINTEL" -> forall a. a -> Maybe a
Just Op
OpArbitraryFloatSinCosPiINTEL
  a
"OpArbitraryFloatCastINTEL" -> forall a. a -> Maybe a
Just Op
OpArbitraryFloatCastINTEL
  a
"OpArbitraryFloatCastFromIntINTEL" -> forall a. a -> Maybe a
Just Op
OpArbitraryFloatCastFromIntINTEL
  a
"OpArbitraryFloatCastToIntINTEL" -> forall a. a -> Maybe a
Just Op
OpArbitraryFloatCastToIntINTEL
  a
"OpArbitraryFloatAddINTEL" -> forall a. a -> Maybe a
Just Op
OpArbitraryFloatAddINTEL
  a
"OpArbitraryFloatSubINTEL" -> forall a. a -> Maybe a
Just Op
OpArbitraryFloatSubINTEL
  a
"OpArbitraryFloatMulINTEL" -> forall a. a -> Maybe a
Just Op
OpArbitraryFloatMulINTEL
  a
"OpArbitraryFloatDivINTEL" -> forall a. a -> Maybe a
Just Op
OpArbitraryFloatDivINTEL
  a
"OpArbitraryFloatGTINTEL" -> forall a. a -> Maybe a
Just Op
OpArbitraryFloatGTINTEL
  a
"OpArbitraryFloatGEINTEL" -> forall a. a -> Maybe a
Just Op
OpArbitraryFloatGEINTEL
  a
"OpArbitraryFloatLTINTEL" -> forall a. a -> Maybe a
Just Op
OpArbitraryFloatLTINTEL
  a
"OpArbitraryFloatLEINTEL" -> forall a. a -> Maybe a
Just Op
OpArbitraryFloatLEINTEL
  a
"OpArbitraryFloatEQINTEL" -> forall a. a -> Maybe a
Just Op
OpArbitraryFloatEQINTEL
  a
"OpArbitraryFloatRecipINTEL" -> forall a. a -> Maybe a
Just Op
OpArbitraryFloatRecipINTEL
  a
"OpArbitraryFloatRSqrtINTEL" -> forall a. a -> Maybe a
Just Op
OpArbitraryFloatRSqrtINTEL
  a
"OpArbitraryFloatCbrtINTEL" -> forall a. a -> Maybe a
Just Op
OpArbitraryFloatCbrtINTEL
  a
"OpArbitraryFloatHypotINTEL" -> forall a. a -> Maybe a
Just Op
OpArbitraryFloatHypotINTEL
  a
"OpArbitraryFloatSqrtINTEL" -> forall a. a -> Maybe a
Just Op
OpArbitraryFloatSqrtINTEL
  a
"OpArbitraryFloatLogINTEL" -> forall a. a -> Maybe a
Just Op
OpArbitraryFloatLogINTEL
  a
"OpArbitraryFloatLog2INTEL" -> forall a. a -> Maybe a
Just Op
OpArbitraryFloatLog2INTEL
  a
"OpArbitraryFloatLog10INTEL" -> forall a. a -> Maybe a
Just Op
OpArbitraryFloatLog10INTEL
  a
"OpArbitraryFloatLog1pINTEL" -> forall a. a -> Maybe a
Just Op
OpArbitraryFloatLog1pINTEL
  a
"OpArbitraryFloatExpINTEL" -> forall a. a -> Maybe a
Just Op
OpArbitraryFloatExpINTEL
  a
"OpArbitraryFloatExp2INTEL" -> forall a. a -> Maybe a
Just Op
OpArbitraryFloatExp2INTEL
  a
"OpArbitraryFloatExp10INTEL" -> forall a. a -> Maybe a
Just Op
OpArbitraryFloatExp10INTEL
  a
"OpArbitraryFloatExpm1INTEL" -> forall a. a -> Maybe a
Just Op
OpArbitraryFloatExpm1INTEL
  a
"OpArbitraryFloatSinINTEL" -> forall a. a -> Maybe a
Just Op
OpArbitraryFloatSinINTEL
  a
"OpArbitraryFloatCosINTEL" -> forall a. a -> Maybe a
Just Op
OpArbitraryFloatCosINTEL
  a
"OpArbitraryFloatSinCosINTEL" -> forall a. a -> Maybe a
Just Op
OpArbitraryFloatSinCosINTEL
  a
"OpArbitraryFloatSinPiINTEL" -> forall a. a -> Maybe a
Just Op
OpArbitraryFloatSinPiINTEL
  a
"OpArbitraryFloatCosPiINTEL" -> forall a. a -> Maybe a
Just Op
OpArbitraryFloatCosPiINTEL
  a
"OpArbitraryFloatASinINTEL" -> forall a. a -> Maybe a
Just Op
OpArbitraryFloatASinINTEL
  a
"OpArbitraryFloatASinPiINTEL" -> forall a. a -> Maybe a
Just Op
OpArbitraryFloatASinPiINTEL
  a
"OpArbitraryFloatACosINTEL" -> forall a. a -> Maybe a
Just Op
OpArbitraryFloatACosINTEL
  a
"OpArbitraryFloatACosPiINTEL" -> forall a. a -> Maybe a
Just Op
OpArbitraryFloatACosPiINTEL
  a
"OpArbitraryFloatATanINTEL" -> forall a. a -> Maybe a
Just Op
OpArbitraryFloatATanINTEL
  a
"OpArbitraryFloatATanPiINTEL" -> forall a. a -> Maybe a
Just Op
OpArbitraryFloatATanPiINTEL
  a
"OpArbitraryFloatATan2INTEL" -> forall a. a -> Maybe a
Just Op
OpArbitraryFloatATan2INTEL
  a
"OpArbitraryFloatPowINTEL" -> forall a. a -> Maybe a
Just Op
OpArbitraryFloatPowINTEL
  a
"OpArbitraryFloatPowRINTEL" -> forall a. a -> Maybe a
Just Op
OpArbitraryFloatPowRINTEL
  a
"OpArbitraryFloatPowNINTEL" -> forall a. a -> Maybe a
Just Op
OpArbitraryFloatPowNINTEL
  a
"OpLoopControlINTEL" -> forall a. a -> Maybe a
Just Op
OpLoopControlINTEL
  a
"OpAliasDomainDeclINTEL" -> forall a. a -> Maybe a
Just Op
OpAliasDomainDeclINTEL
  a
"OpAliasScopeDeclINTEL" -> forall a. a -> Maybe a
Just Op
OpAliasScopeDeclINTEL
  a
"OpAliasScopeListDeclINTEL" -> forall a. a -> Maybe a
Just Op
OpAliasScopeListDeclINTEL
  a
"OpFixedSqrtINTEL" -> forall a. a -> Maybe a
Just Op
OpFixedSqrtINTEL
  a
"OpFixedRecipINTEL" -> forall a. a -> Maybe a
Just Op
OpFixedRecipINTEL
  a
"OpFixedRsqrtINTEL" -> forall a. a -> Maybe a
Just Op
OpFixedRsqrtINTEL
  a
"OpFixedSinINTEL" -> forall a. a -> Maybe a
Just Op
OpFixedSinINTEL
  a
"OpFixedCosINTEL" -> forall a. a -> Maybe a
Just Op
OpFixedCosINTEL
  a
"OpFixedSinCosINTEL" -> forall a. a -> Maybe a
Just Op
OpFixedSinCosINTEL
  a
"OpFixedSinPiINTEL" -> forall a. a -> Maybe a
Just Op
OpFixedSinPiINTEL
  a
"OpFixedCosPiINTEL" -> forall a. a -> Maybe a
Just Op
OpFixedCosPiINTEL
  a
"OpFixedSinCosPiINTEL" -> forall a. a -> Maybe a
Just Op
OpFixedSinCosPiINTEL
  a
"OpFixedLogINTEL" -> forall a. a -> Maybe a
Just Op
OpFixedLogINTEL
  a
"OpFixedExpINTEL" -> forall a. a -> Maybe a
Just Op
OpFixedExpINTEL
  a
"OpPtrCastToCrossWorkgroupINTEL" -> forall a. a -> Maybe a
Just Op
OpPtrCastToCrossWorkgroupINTEL
  a
"OpCrossWorkgroupCastToPtrINTEL" -> forall a. a -> Maybe a
Just Op
OpCrossWorkgroupCastToPtrINTEL
  a
"OpReadPipeBlockingINTEL" -> forall a. a -> Maybe a
Just Op
OpReadPipeBlockingINTEL
  a
"OpWritePipeBlockingINTEL" -> forall a. a -> Maybe a
Just Op
OpWritePipeBlockingINTEL
  a
"OpFPGARegINTEL" -> forall a. a -> Maybe a
Just Op
OpFPGARegINTEL
  a
"OpRayQueryGetRayTMinKHR" -> forall a. a -> Maybe a
Just Op
OpRayQueryGetRayTMinKHR
  a
"OpRayQueryGetRayFlagsKHR" -> forall a. a -> Maybe a
Just Op
OpRayQueryGetRayFlagsKHR
  a
"OpRayQueryGetIntersectionTKHR" -> forall a. a -> Maybe a
Just Op
OpRayQueryGetIntersectionTKHR
  a
"OpRayQueryGetIntersectionInstanceCustomIndexKHR" -> forall a. a -> Maybe a
Just Op
OpRayQueryGetIntersectionInstanceCustomIndexKHR
  a
"OpRayQueryGetIntersectionInstanceIdKHR" -> forall a. a -> Maybe a
Just Op
OpRayQueryGetIntersectionInstanceIdKHR
  a
"OpRayQueryGetIntersectionInstanceShaderBindingTableRecordOffsetKHR" -> forall a. a -> Maybe a
Just Op
OpRayQueryGetIntersectionInstanceShaderBindingTableRecordOffsetKHR
  a
"OpRayQueryGetIntersectionGeometryIndexKHR" -> forall a. a -> Maybe a
Just Op
OpRayQueryGetIntersectionGeometryIndexKHR
  a
"OpRayQueryGetIntersectionPrimitiveIndexKHR" -> forall a. a -> Maybe a
Just Op
OpRayQueryGetIntersectionPrimitiveIndexKHR
  a
"OpRayQueryGetIntersectionBarycentricsKHR" -> forall a. a -> Maybe a
Just Op
OpRayQueryGetIntersectionBarycentricsKHR
  a
"OpRayQueryGetIntersectionFrontFaceKHR" -> forall a. a -> Maybe a
Just Op
OpRayQueryGetIntersectionFrontFaceKHR
  a
"OpRayQueryGetIntersectionCandidateAABBOpaqueKHR" -> forall a. a -> Maybe a
Just Op
OpRayQueryGetIntersectionCandidateAABBOpaqueKHR
  a
"OpRayQueryGetIntersectionObjectRayDirectionKHR" -> forall a. a -> Maybe a
Just Op
OpRayQueryGetIntersectionObjectRayDirectionKHR
  a
"OpRayQueryGetIntersectionObjectRayOriginKHR" -> forall a. a -> Maybe a
Just Op
OpRayQueryGetIntersectionObjectRayOriginKHR
  a
"OpRayQueryGetWorldRayDirectionKHR" -> forall a. a -> Maybe a
Just Op
OpRayQueryGetWorldRayDirectionKHR
  a
"OpRayQueryGetWorldRayOriginKHR" -> forall a. a -> Maybe a
Just Op
OpRayQueryGetWorldRayOriginKHR
  a
"OpRayQueryGetIntersectionObjectToWorldKHR" -> forall a. a -> Maybe a
Just Op
OpRayQueryGetIntersectionObjectToWorldKHR
  a
"OpRayQueryGetIntersectionWorldToObjectKHR" -> forall a. a -> Maybe a
Just Op
OpRayQueryGetIntersectionWorldToObjectKHR
  a
"OpAtomicFAddEXT" -> forall a. a -> Maybe a
Just Op
OpAtomicFAddEXT
  a
"OpTypeBufferSurfaceINTEL" -> forall a. a -> Maybe a
Just Op
OpTypeBufferSurfaceINTEL
  a
"OpTypeStructContinuedINTEL" -> forall a. a -> Maybe a
Just Op
OpTypeStructContinuedINTEL
  a
"OpConstantCompositeContinuedINTEL" -> forall a. a -> Maybe a
Just Op
OpConstantCompositeContinuedINTEL
  a
"OpSpecConstantCompositeContinuedINTEL" -> forall a. a -> Maybe a
Just Op
OpSpecConstantCompositeContinuedINTEL
  a
"OpControlBarrierArriveINTEL" -> forall a. a -> Maybe a
Just Op
OpControlBarrierArriveINTEL
  a
"OpControlBarrierWaitINTEL" -> forall a. a -> Maybe a
Just Op
OpControlBarrierWaitINTEL
  a
"OpGroupIMulKHR" -> forall a. a -> Maybe a
Just Op
OpGroupIMulKHR
  a
"OpGroupFMulKHR" -> forall a. a -> Maybe a
Just Op
OpGroupFMulKHR
  a
"OpGroupBitwiseAndKHR" -> forall a. a -> Maybe a
Just Op
OpGroupBitwiseAndKHR
  a
"OpGroupBitwiseOrKHR" -> forall a. a -> Maybe a
Just Op
OpGroupBitwiseOrKHR
  a
"OpGroupBitwiseXorKHR" -> forall a. a -> Maybe a
Just Op
OpGroupBitwiseXorKHR
  a
"OpGroupLogicalAndKHR" -> forall a. a -> Maybe a
Just Op
OpGroupLogicalAndKHR
  a
"OpGroupLogicalOrKHR" -> forall a. a -> Maybe a
Just Op
OpGroupLogicalOrKHR
  a
"OpGroupLogicalXorKHR" -> forall a. a -> Maybe a
Just Op
OpGroupLogicalXorKHR
  a
_unknown -> forall a. Maybe a
Nothing

instance Read Op where
  readPrec :: ReadPrec Op
readPrec = forall a. ReadPrec a -> ReadPrec a
Read.parens do
    Lex.Ident [Char]
s <- ReadPrec Lexeme
Read.lexP
    forall b a. b -> (a -> b) -> Maybe a -> b
maybe forall a. ReadPrec a
pfail forall (f :: * -> *) a. Applicative f => a -> f a
pure forall a b. (a -> b) -> a -> b
$ forall a. (IsString a, Eq a) => a -> Maybe Op
fromName [Char]
s