module Data.SpirV.Reflect.Enums.SpirvOp where

import Data.SpirV.Reflect.Enums.Common

newtype Op = Op Int32
  deriving newtype (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, Int -> Op -> ShowS
[Op] -> ShowS
Op -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Op] -> ShowS
$cshowList :: [Op] -> ShowS
show :: Op -> String
$cshow :: Op -> String
showsPrec :: Int -> Op -> ShowS
$cshowsPrec :: Int -> Op -> ShowS
Show, Int -> Op
Op -> Int
Op -> [Op]
Op -> Op
Op -> Op -> [Op]
Op -> Op -> Op -> [Op]
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
enumFromThenTo :: Op -> Op -> Op -> [Op]
$cenumFromThenTo :: Op -> Op -> Op -> [Op]
enumFromTo :: Op -> Op -> [Op]
$cenumFromTo :: Op -> Op -> [Op]
enumFromThen :: Op -> Op -> [Op]
$cenumFromThen :: Op -> Op -> [Op]
enumFrom :: Op -> [Op]
$cenumFrom :: Op -> [Op]
fromEnum :: Op -> Int
$cfromEnum :: Op -> Int
toEnum :: Int -> Op
$ctoEnum :: Int -> Op
pred :: Op -> Op
$cpred :: Op -> Op
succ :: Op -> Op
$csucc :: Op -> Op
Enum, Op
forall a. a -> a -> Bounded a
maxBound :: Op
$cmaxBound :: Op
minBound :: Op
$cminBound :: Op
Bounded)

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 OpImageSampleFootprintNV :: Op
pattern $bOpImageSampleFootprintNV :: Op
$mOpImageSampleFootprintNV :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpImageSampleFootprintNV = Op 5283

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

pattern OpMax :: Op
pattern $bOpMax :: Op
$mOpMax :: forall {r}. Op -> ((# #) -> r) -> ((# #) -> r) -> r
OpMax = Op 0x7fffffff