{-# OPTIONS_GHC -optc-DCOMMA=, #-}
{-# OPTIONS_GHC -optc-DOR_TT=T #-}
{-# OPTIONS_GHC -optc-DOR_TF=T #-}
{-# OPTIONS_GHC -optc-DOR_FT=T #-}
{-# OPTIONS_GHC -optc-DOR_FF=F #-}
{-# LINE 1 "src/LLVM/Internal/FFI/LLVMCTypes.hsc" #-}
{-# LANGUAGE
  GeneralizedNewtypeDeriving,
  PatternSynonyms
  #-}
-- | Define types which correspond cleanly with some simple types on the C/C++ side.
-- Encapsulate hsc macro weirdness here, supporting higher-level tricks elsewhere.
module LLVM.Internal.FFI.LLVMCTypes where

import LLVM.Prelude


{-# LINE 14 "src/LLVM/Internal/FFI/LLVMCTypes.hsc" #-}




















import Language.Haskell.TH.Quote

import Data.Bits
import Foreign.C
import Foreign.Storable






pattern DwOp_and :: Word64
pattern $mDwOp_and :: forall {r}. Word64 -> ((# #) -> r) -> ((# #) -> r) -> r
$bDwOp_and :: Word64
DwOp_and =   26
pattern DwOp_bregx :: Word64
pattern $mDwOp_bregx :: forall {r}. Word64 -> ((# #) -> r) -> ((# #) -> r) -> r
$bDwOp_bregx :: Word64
DwOp_bregx =   146
pattern DwOp_constu :: Word64
pattern $mDwOp_constu :: forall {r}. Word64 -> ((# #) -> r) -> ((# #) -> r) -> r
$bDwOp_constu :: Word64
DwOp_constu =   16
pattern DwOp_deref :: Word64
pattern $mDwOp_deref :: forall {r}. Word64 -> ((# #) -> r) -> ((# #) -> r) -> r
$bDwOp_deref :: Word64
DwOp_deref =   6
pattern DwOp_div :: Word64
pattern $mDwOp_div :: forall {r}. Word64 -> ((# #) -> r) -> ((# #) -> r) -> r
$bDwOp_div :: Word64
DwOp_div =   27
pattern DwOp_dup :: Word64
pattern $mDwOp_dup :: forall {r}. Word64 -> ((# #) -> r) -> ((# #) -> r) -> r
$bDwOp_dup :: Word64
DwOp_dup =   18
pattern DwOp_lit0 :: Word64
pattern $mDwOp_lit0 :: forall {r}. Word64 -> ((# #) -> r) -> ((# #) -> r) -> r
$bDwOp_lit0 :: Word64
DwOp_lit0 =   48
pattern DwOp_LLVM_fragment :: Word64
pattern $mDwOp_LLVM_fragment :: forall {r}. Word64 -> ((# #) -> r) -> ((# #) -> r) -> r
$bDwOp_LLVM_fragment :: Word64
DwOp_LLVM_fragment =   4096
pattern DwOp_minus :: Word64
pattern $mDwOp_minus :: forall {r}. Word64 -> ((# #) -> r) -> ((# #) -> r) -> r
$bDwOp_minus :: Word64
DwOp_minus =   28
pattern DwOp_mod :: Word64
pattern $mDwOp_mod :: forall {r}. Word64 -> ((# #) -> r) -> ((# #) -> r) -> r
$bDwOp_mod :: Word64
DwOp_mod =   29
pattern DwOp_mul :: Word64
pattern $mDwOp_mul :: forall {r}. Word64 -> ((# #) -> r) -> ((# #) -> r) -> r
$bDwOp_mul :: Word64
DwOp_mul =   30
pattern DwOp_not :: Word64
pattern $mDwOp_not :: forall {r}. Word64 -> ((# #) -> r) -> ((# #) -> r) -> r
$bDwOp_not :: Word64
DwOp_not =   32
pattern DwOp_or :: Word64
pattern $mDwOp_or :: forall {r}. Word64 -> ((# #) -> r) -> ((# #) -> r) -> r
$bDwOp_or :: Word64
DwOp_or =   33
pattern DwOp_plus :: Word64
pattern $mDwOp_plus :: forall {r}. Word64 -> ((# #) -> r) -> ((# #) -> r) -> r
$bDwOp_plus :: Word64
DwOp_plus =   34
pattern DwOp_plus_uconst :: Word64
pattern $mDwOp_plus_uconst :: forall {r}. Word64 -> ((# #) -> r) -> ((# #) -> r) -> r
$bDwOp_plus_uconst :: Word64
DwOp_plus_uconst =   35
pattern DwOp_push_object_address :: Word64
pattern DwOp_push_object_address =   151
pattern DwOp_shl :: Word64
pattern $mDwOp_shl :: forall {r}. Word64 -> ((# #) -> r) -> ((# #) -> r) -> r
$bDwOp_shl :: Word64
DwOp_shl =   36
pattern DwOp_shr :: Word64
pattern $mDwOp_shr :: forall {r}. Word64 -> ((# #) -> r) -> ((# #) -> r) -> r
$bDwOp_shr :: Word64
DwOp_shr =   37
pattern DwOp_shra :: Word64
pattern DwOp_shra =   38
pattern DwOp_stack_value :: Word64
pattern $mDwOp_stack_value :: forall {r}. Word64 -> ((# #) -> r) -> ((# #) -> r) -> r
$bDwOp_stack_value :: Word64
DwOp_stack_value =   159
pattern DwOp_swap :: Word64
pattern DwOp_swap =   22
pattern DwOp_xderef :: Word64
pattern DwOp_xderef =   24
pattern DwOp_xor :: Word64
pattern DwOp_xor =   39

{-# LINE 74 "src/LLVM/Internal/FFI/LLVMCTypes.hsc" #-}

newtype Encoding = Encoding CUInt
  deriving (Data, Show)


pattern DwAtE_address :: Encoding
pattern DwAtE_address =  Encoding 1
pattern DwAtE_boolean :: Encoding
pattern DwAtE_boolean =  Encoding 2
pattern DwAtE_complex_float :: Encoding
pattern DwAtE_complex_float =  Encoding 3
pattern DwAtE_float :: Encoding
pattern DwAtE_float =  Encoding 4
pattern DwAtE_signed :: Encoding
pattern DwAtE_signed =  Encoding 5
pattern DwAtE_signed_char :: Encoding
pattern DwAtE_signed_char =  Encoding 6
pattern DwAtE_unsigned :: Encoding
pattern DwAtE_unsigned =  Encoding 7
pattern DwAtE_unsigned_char :: Encoding
pattern $mDwAtE_unsigned_char :: forall {r}. Encoding -> ((# #) -> r) -> ((# #) -> r) -> r
$bDwAtE_unsigned_char :: Encoding
DwAtE_unsigned_char =  Encoding 8
pattern DwAtE_imaginary_float :: Encoding
pattern $mDwAtE_imaginary_float :: forall {r}. Encoding -> ((# #) -> r) -> ((# #) -> r) -> r
$bDwAtE_imaginary_float :: Encoding
DwAtE_imaginary_float =  Encoding 9
pattern DwAtE_packed_decimal :: Encoding
pattern $mDwAtE_packed_decimal :: forall {r}. Encoding -> ((# #) -> r) -> ((# #) -> r) -> r
$bDwAtE_packed_decimal :: Encoding
DwAtE_packed_decimal =  Encoding 10
pattern DwAtE_numeric_string :: Encoding
pattern $mDwAtE_numeric_string :: forall {r}. Encoding -> ((# #) -> r) -> ((# #) -> r) -> r
$bDwAtE_numeric_string :: Encoding
DwAtE_numeric_string =  Encoding 11
pattern DwAtE_edited :: Encoding
pattern $mDwAtE_edited :: forall {r}. Encoding -> ((# #) -> r) -> ((# #) -> r) -> r
$bDwAtE_edited :: Encoding
DwAtE_edited =  Encoding 12
pattern DwAtE_signed_fixed :: Encoding
pattern DwAtE_signed_fixed =  Encoding 13
pattern DwAtE_unsigned_fixed :: Encoding
pattern $mDwAtE_unsigned_fixed :: forall {r}. Encoding -> ((# #) -> r) -> ((# #) -> r) -> r
$bDwAtE_unsigned_fixed :: Encoding
DwAtE_unsigned_fixed =  Encoding 14
pattern DwAtE_decimal_float :: Encoding
pattern $mDwAtE_decimal_float :: forall {r}. Encoding -> ((# #) -> r) -> ((# #) -> r) -> r
$bDwAtE_decimal_float :: Encoding
DwAtE_decimal_float =  Encoding 15
pattern DwAtE_UTF :: Encoding
pattern $mDwAtE_UTF :: forall {r}. Encoding -> ((# #) -> r) -> ((# #) -> r) -> r
$bDwAtE_UTF :: Encoding
DwAtE_UTF =  Encoding 16
pattern DwAtE_UCS :: Encoding
pattern $mDwAtE_UCS :: forall {r}. Encoding -> ((# #) -> r) -> ((# #) -> r) -> r
$bDwAtE_UCS :: Encoding
DwAtE_UCS =  Encoding 17
pattern DwAtE_ASCII :: Encoding
pattern DwAtE_ASCII =  Encoding 18

{-# LINE 80 "src/LLVM/Internal/FFI/LLVMCTypes.hsc" #-}

newtype DwTag = DwTag Word16
  deriving (Data, Show)


pattern DwTag_imported_module :: DwTag
pattern DwTag_imported_module =  DwTag 58
pattern DwTag_imported_declaration :: DwTag
pattern DwTag_imported_declaration =  DwTag 8
pattern DwTag_typedef :: DwTag
pattern DwTag_typedef =  DwTag 22
pattern DwTag_pointer_type :: DwTag
pattern DwTag_pointer_type =  DwTag 15
pattern DwTag_ptr_to_member_type :: DwTag
pattern DwTag_ptr_to_member_type =  DwTag 31
pattern DwTag_reference_type :: DwTag
pattern DwTag_reference_type =  DwTag 16
pattern DwTag_rvalue_reference_type :: DwTag
pattern DwTag_rvalue_reference_type =  DwTag 66
pattern DwTag_const_type :: DwTag
pattern DwTag_const_type =  DwTag 38
pattern DwTag_volatile_type :: DwTag
pattern DwTag_volatile_type =  DwTag 53
pattern DwTag_restrict_type :: DwTag
pattern DwTag_restrict_type =  DwTag 55
pattern DwTag_atomic_type :: DwTag
pattern DwTag_atomic_type =  DwTag 71
pattern DwTag_member :: DwTag
pattern DwTag_member =  DwTag 13
pattern DwTag_inheritance :: DwTag
pattern DwTag_inheritance =  DwTag 28
pattern DwTag_friend :: DwTag
pattern DwTag_friend =  DwTag 42
pattern DwTag_base_type :: DwTag
pattern DwTag_base_type =  DwTag 36
pattern DwTag_unspecified_type :: DwTag
pattern DwTag_unspecified_type =  DwTag 59
pattern DwTag_template_value_parameter :: DwTag
pattern DwTag_template_value_parameter =  DwTag 48
pattern DwTag_GNU_template_template_param :: DwTag
pattern DwTag_GNU_template_template_param =  DwTag 16646
pattern DwTag_GNU_template_parameter_pack :: DwTag
pattern DwTag_GNU_template_parameter_pack =  DwTag 16647
pattern DwTag_array_type :: DwTag
pattern DwTag_array_type =  DwTag 1
pattern DwTag_enumeration_type :: DwTag
pattern DwTag_enumeration_type =  DwTag 4
pattern DwTag_structure_type :: DwTag
pattern DwTag_structure_type =  DwTag 19
pattern DwTag_class_type :: DwTag
pattern DwTag_class_type =  DwTag 2
pattern DwTag_union_type :: DwTag
pattern DwTag_union_type =  DwTag 23

{-# LINE 86 "src/LLVM/Internal/FFI/LLVMCTypes.hsc" #-}

newtype DwVirtuality = DwVirtuality Word8
  deriving (Data, Show)


pattern DwVirtuality_none :: DwVirtuality
pattern DwVirtuality_none =  DwVirtuality 0
pattern DwVirtuality_virtual :: DwVirtuality
pattern DwVirtuality_virtual =  DwVirtuality 1
pattern DwVirtuality_pure_virtual :: DwVirtuality
pattern DwVirtuality_pure_virtual =  DwVirtuality 2

{-# LINE 92 "src/LLVM/Internal/FFI/LLVMCTypes.hsc" #-}

deriving instance Data CUInt

newtype LLVMBool = LLVMBool CUInt

-- | If an FFI function returns a value wrapped in 'OwnerTransfered',
-- this value needs to be freed after it has been processed. Usually
-- this is done automatically in the 'DecodeM' instance.
newtype OwnerTransfered a = OwnerTransfered a
  deriving (Eq, Storable)

newtype NothingAsMinusOne h = NothingAsMinusOne CInt
  deriving (Storable)

newtype NothingAsEmptyString c = NothingAsEmptyString c
  deriving (Storable)

newtype CPPOpcode = CPPOpcode CUInt
  deriving (Eq, Ord, Show, Typeable, Data, Generic)

newtype ICmpPredicate = ICmpPredicate CUInt
  deriving (Eq, Ord, Show, Typeable, Data, Generic)
iCmpPredEQ  :: ICmpPredicate
iCmpPredEQ  = ICmpPredicate 32
iCmpPredNE  :: ICmpPredicate
iCmpPredNE  = ICmpPredicate 33
iCmpPredUGT  :: ICmpPredicate
iCmpPredUGT  = ICmpPredicate 34
iCmpPredUGE  :: ICmpPredicate
iCmpPredUGE  = ICmpPredicate 35
iCmpPredULT  :: ICmpPredicate
iCmpPredULT  = ICmpPredicate 36
iCmpPredULE  :: ICmpPredicate
iCmpPredULE  = ICmpPredicate 37
iCmpPredSGT  :: ICmpPredicate
iCmpPredSGT  = ICmpPredicate 38
iCmpPredSGE  :: ICmpPredicate
iCmpPredSGE  = ICmpPredicate 39
iCmpPredSLT  :: ICmpPredicate
iCmpPredSLT  = ICmpPredicate 40
iCmpPredSLE  :: ICmpPredicate
iCmpPredSLE  = ICmpPredicate 41

{-# LINE 126 "src/LLVM/Internal/FFI/LLVMCTypes.hsc" #-}

newtype FCmpPredicate = FCmpPredicate CUInt
  deriving (Eq, Ord, Show, Typeable, Data, Generic)
fCmpPredFalse  :: FCmpPredicate
fCmpPredFalse  = FCmpPredicate 0
fCmpPredOEQ  :: FCmpPredicate
fCmpPredOEQ  = FCmpPredicate 1
fCmpPredOGT  :: FCmpPredicate
fCmpPredOGT  = FCmpPredicate 2
fCmpPredOGE  :: FCmpPredicate
fCmpPredOGE :: FCmpPredicate
fCmpPredOGE  = CUInt -> FCmpPredicate
FCmpPredicate CUInt
3
fCmpPredOLT  :: FCmpPredicate
fCmpPredOLT :: FCmpPredicate
fCmpPredOLT  = CUInt -> FCmpPredicate
FCmpPredicate CUInt
4
fCmpPredOLE  :: FCmpPredicate
fCmpPredOLE :: FCmpPredicate
fCmpPredOLE  = CUInt -> FCmpPredicate
FCmpPredicate CUInt
5
fCmpPredONE  :: FCmpPredicate
fCmpPredONE :: FCmpPredicate
fCmpPredONE  = CUInt -> FCmpPredicate
FCmpPredicate CUInt
6
fCmpPredORD  :: FCmpPredicate
fCmpPredORD :: FCmpPredicate
fCmpPredORD  = CUInt -> FCmpPredicate
FCmpPredicate CUInt
7
fCmpPredUNO  :: FCmpPredicate
fCmpPredUNO :: FCmpPredicate
fCmpPredUNO  = CUInt -> FCmpPredicate
FCmpPredicate CUInt
8
fCmpPredUEQ  :: FCmpPredicate
fCmpPredUEQ :: FCmpPredicate
fCmpPredUEQ  = CUInt -> FCmpPredicate
FCmpPredicate CUInt
9
fCmpPredUGT  :: FCmpPredicate
fCmpPredUGT :: FCmpPredicate
fCmpPredUGT  = CUInt -> FCmpPredicate
FCmpPredicate CUInt
10
fCmpPredUGE  :: FCmpPredicate
fCmpPredUGE :: FCmpPredicate
fCmpPredUGE  = CUInt -> FCmpPredicate
FCmpPredicate CUInt
11
fCmpPredULT  :: FCmpPredicate
fCmpPredULT :: FCmpPredicate
fCmpPredULT  = FCmpPredicate 12
fCmpPredULE  :: FCmpPredicate
fCmpPredULE :: FCmpPredicate
fCmpPredULE  = FCmpPredicate 13
fCmpPredUNE  :: FCmpPredicate
fCmpPredUNE :: FCmpPredicate
fCmpPredUNE  = FCmpPredicate 14
fcmpPredTrue  :: FCmpPredicate
fcmpPredTrue :: FCmpPredicate
fcmpPredTrue  = CUInt -> FCmpPredicate
FCmpPredicate CUInt
15

{-# LINE 147 "src/LLVM/Internal/FFI/LLVMCTypes.hsc" #-}

newtype MDKindID = MDKindID CUInt
  deriving (Storable)

newtype MDSubclassID = MDSubclassID CUInt
  deriving (Eq, Read, Show, Typeable, Data, Generic)

mdSubclassIdMDString :: MDSubclassID
mdSubclassIdMDString = MDSubclassID 0
mdSubclassIdConstantAsMetadata :: MDSubclassID
mdSubclassIdConstantAsMetadata = MDSubclassID 1
mdSubclassIdLocalAsMetadata :: MDSubclassID
mdSubclassIdLocalAsMetadata = MDSubclassID 2
mdSubclassIdDistinctMDOperandPlaceholder :: MDSubclassID
mdSubclassIdDistinctMDOperandPlaceholder = MDSubclassID 3
mdSubclassIdMDTuple :: MDSubclassID
mdSubclassIdMDTuple :: MDSubclassID
mdSubclassIdMDTuple = CUInt -> MDSubclassID
MDSubclassID CUInt
4
mdSubclassIdDILocation :: MDSubclassID
mdSubclassIdDILocation :: MDSubclassID
mdSubclassIdDILocation = MDSubclassID 5
mdSubclassIdDIExpression :: MDSubclassID
mdSubclassIdDIExpression :: MDSubclassID
mdSubclassIdDIExpression = MDSubclassID 6
mdSubclassIdDIGlobalVariableExpression :: MDSubclassID
mdSubclassIdDIGlobalVariableExpression :: MDSubclassID
mdSubclassIdDIGlobalVariableExpression = CUInt -> MDSubclassID
MDSubclassID CUInt
7
mdSubclassIdGenericDINode :: MDSubclassID
mdSubclassIdGenericDINode :: MDSubclassID
mdSubclassIdGenericDINode = MDSubclassID CUInt
8
mdSubclassIdDISubrange :: MDSubclassID
mdSubclassIdDISubrange :: MDSubclassID
mdSubclassIdDISubrange = CUInt -> MDSubclassID
MDSubclassID CUInt
9
mdSubclassIdDIEnumerator :: MDSubclassID
mdSubclassIdDIEnumerator :: MDSubclassID
mdSubclassIdDIEnumerator = CUInt -> MDSubclassID
MDSubclassID CUInt
10
mdSubclassIdDIBasicType :: MDSubclassID
mdSubclassIdDIBasicType = MDSubclassID 11
mdSubclassIdDIDerivedType :: MDSubclassID
mdSubclassIdDIDerivedType = MDSubclassID 12
mdSubclassIdDICompositeType :: MDSubclassID
mdSubclassIdDICompositeType = MDSubclassID 13
mdSubclassIdDISubroutineType :: MDSubclassID
mdSubclassIdDISubroutineType :: MDSubclassID
mdSubclassIdDISubroutineType = CUInt -> MDSubclassID
MDSubclassID CUInt
14
mdSubclassIdDIFile :: MDSubclassID
mdSubclassIdDIFile = MDSubclassID 15
mdSubclassIdDICompileUnit :: MDSubclassID
mdSubclassIdDICompileUnit = MDSubclassID 16
mdSubclassIdDISubprogram :: MDSubclassID
mdSubclassIdDISubprogram = MDSubclassID 17
mdSubclassIdDILexicalBlock :: MDSubclassID
mdSubclassIdDILexicalBlock = MDSubclassID 18
mdSubclassIdDILexicalBlockFile :: MDSubclassID
mdSubclassIdDILexicalBlockFile = MDSubclassID 19
mdSubclassIdDINamespace :: MDSubclassID
mdSubclassIdDINamespace = MDSubclassID 20
mdSubclassIdDIModule :: MDSubclassID
mdSubclassIdDIModule = MDSubclassID 21
mdSubclassIdDITemplateTypeParameter :: MDSubclassID
mdSubclassIdDITemplateTypeParameter = MDSubclassID 22
mdSubclassIdDITemplateValueParameter :: MDSubclassID
mdSubclassIdDITemplateValueParameter = MDSubclassID 23
mdSubclassIdDIGlobalVariable :: MDSubclassID
mdSubclassIdDIGlobalVariable = MDSubclassID 24
mdSubclassIdDILocalVariable :: MDSubclassID
mdSubclassIdDILocalVariable = MDSubclassID 25
mdSubclassIdDIObjCProperty :: MDSubclassID
mdSubclassIdDIObjCProperty = MDSubclassID 27
mdSubclassIdDIImportedEntity :: MDSubclassID
mdSubclassIdDIImportedEntity = MDSubclassID 28
mdSubclassIdDIMacro :: MDSubclassID
mdSubclassIdDIMacro = MDSubclassID 29
mdSubclassIdDIMacroFile :: MDSubclassID
mdSubclassIdDIMacroFile = MDSubclassID 30
mdSubclassIdP :: QuasiQuoter
mdSubclassIdP = QuasiQuoter {
  quoteExp = undefined,
  quotePat = \s -> dataToPatQ (const Nothing) $ case s of
    "MDString" -> mdSubclassIdMDString
    "ConstantAsMetadata" -> mdSubclassIdConstantAsMetadata
    "LocalAsMetadata" -> mdSubclassIdLocalAsMetadata
    "DistinctMDOperandPlaceholder" -> mdSubclassIdDistinctMDOperandPlaceholder
    "MDTuple" -> mdSubclassIdMDTuple
    "DILocation" -> mdSubclassIdDILocation
    "DIExpression" -> mdSubclassIdDIExpression
    "DIGlobalVariableExpression" -> mdSubclassIdDIGlobalVariableExpression
    "GenericDINode" -> mdSubclassIdGenericDINode
    "DISubrange" -> mdSubclassIdDISubrange
    "DIEnumerator" -> mdSubclassIdDIEnumerator
    "DIBasicType" -> mdSubclassIdDIBasicType
    "DIDerivedType" -> mdSubclassIdDIDerivedType
    "DICompositeType" -> mdSubclassIdDICompositeType
    "DISubroutineType" -> mdSubclassIdDISubroutineType
    "DIFile" -> mdSubclassIdDIFile
    "DICompileUnit" -> mdSubclassIdDICompileUnit
    "DISubprogram" -> mdSubclassIdDISubprogram
    "DILexicalBlock" -> mdSubclassIdDILexicalBlock
    "DILexicalBlockFile" -> mdSubclassIdDILexicalBlockFile
    "DINamespace" -> mdSubclassIdDINamespace
    "DIModule" -> mdSubclassIdDIModule
    "DITemplateTypeParameter" -> mdSubclassIdDITemplateTypeParameter
    "DITemplateValueParameter" -> mdSubclassIdDITemplateValueParameter
    "DIGlobalVariable" -> mdSubclassIdDIGlobalVariable
    "DILocalVariable" -> mdSubclassIdDILocalVariable
    "DIObjCProperty" -> mdSubclassIdDIObjCProperty
    "DIImportedEntity" -> mdSubclassIdDIImportedEntity
    "DIMacro" -> mdSubclassIdDIMacro
    "DIMacroFile" -> mdSubclassIdDIMacroFile
    x -> error $ "bad quasiquoted FFI constant for mdSubclassId: " ++ x,
  quoteType = undefined,
  quoteDec = undefined
 }

{-# LINE 155 "src/LLVM/Internal/FFI/LLVMCTypes.hsc" #-}

newtype FastMathFlags = FastMathFlags CUInt
  deriving (Eq, Ord, Show, Typeable, Data, Num, Bits, Generic)

fastMathFlagsAllowReassoc :: FastMathFlags
fastMathFlagsAllowReassoc = FastMathFlags 1
fastMathFlagsNoNaNs :: FastMathFlags
fastMathFlagsNoNaNs = FastMathFlags 2
fastMathFlagsNoInfs :: FastMathFlags
fastMathFlagsNoInfs = FastMathFlags 4
fastMathFlagsNoSignedZeros :: FastMathFlags
fastMathFlagsNoSignedZeros = FastMathFlags 8
fastMathFlagsAllowReciprocal :: FastMathFlags
fastMathFlagsAllowReciprocal = FastMathFlags 16
fastMathFlagsAllowContract :: FastMathFlags
fastMathFlagsAllowContract = FastMathFlags 32
fastMathFlagsApproxFunc :: FastMathFlags
fastMathFlagsApproxFunc = FastMathFlags 64
fastMathFlagsP :: QuasiQuoter
fastMathFlagsP = QuasiQuoter {
  quoteExp = undefined,
  quotePat = \s -> dataToPatQ (const Nothing) $ case s of
    "AllowReassoc" -> fastMathFlagsAllowReassoc
    "NoNaNs" -> fastMathFlagsNoNaNs
    "NoInfs" -> fastMathFlagsNoInfs
    "NoSignedZeros" -> fastMathFlagsNoSignedZeros
    "AllowReciprocal" -> fastMathFlagsAllowReciprocal
    "AllowContract" -> fastMathFlagsAllowContract
    "ApproxFunc" -> fastMathFlagsApproxFunc
    x -> error $ "bad quasiquoted FFI constant for fastMathFlags: " ++ x,
  quoteType = undefined,
  quoteDec = undefined
 }

{-# LINE 160 "src/LLVM/Internal/FFI/LLVMCTypes.hsc" #-}

newtype MemoryOrdering = MemoryOrdering CUInt
  deriving (Eq, Show, Typeable, Data, Generic)

memoryOrderingNotAtomic :: MemoryOrdering
memoryOrderingNotAtomic = MemoryOrdering 0
memoryOrderingUnordered :: MemoryOrdering
memoryOrderingUnordered = MemoryOrdering 1
memoryOrderingMonotonic :: MemoryOrdering
memoryOrderingMonotonic = MemoryOrdering 2
memoryOrderingAcquire :: MemoryOrdering
memoryOrderingAcquire = MemoryOrdering 4
memoryOrderingRelease :: MemoryOrdering
memoryOrderingRelease = MemoryOrdering 5
memoryOrderingAcquireRelease :: MemoryOrdering
memoryOrderingAcquireRelease = MemoryOrdering 6
memoryOrderingSequentiallyConsistent :: MemoryOrdering
memoryOrderingSequentiallyConsistent = MemoryOrdering 7
memoryOrderingP :: QuasiQuoter
memoryOrderingP = QuasiQuoter {
  quoteExp = undefined,
  quotePat = \s -> dataToPatQ (const Nothing) $ case s of
    "NotAtomic" -> memoryOrderingNotAtomic
    "Unordered" -> memoryOrderingUnordered
    "Monotonic" -> memoryOrderingMonotonic
    "Acquire" -> memoryOrderingAcquire
    "Release" -> memoryOrderingRelease
    "AcquireRelease" -> memoryOrderingAcquireRelease
    "SequentiallyConsistent" -> memoryOrderingSequentiallyConsistent
    x -> error $ "bad quasiquoted FFI constant for memoryOrdering: " ++ x,
  quoteType = undefined,
  quoteDec = undefined
 }

{-# LINE 165 "src/LLVM/Internal/FFI/LLVMCTypes.hsc" #-}

newtype UnnamedAddr = UnnamedAddr CUInt
  deriving (Eq, Show, Typeable, Data, Generic)

unnamedAddrNo :: UnnamedAddr
unnamedAddrNo = UnnamedAddr 0
unnamedAddrLocal :: UnnamedAddr
unnamedAddrLocal = UnnamedAddr 1
unnamedAddrGlobal :: UnnamedAddr
unnamedAddrGlobal = UnnamedAddr 2
unnamedAddrP :: QuasiQuoter
unnamedAddrP = QuasiQuoter {
  quoteExp = undefined,
  quotePat = \s -> dataToPatQ (const Nothing) $ case s of
    "No" -> unnamedAddrNo
    "Local" -> unnamedAddrLocal
    "Global" -> unnamedAddrGlobal
    x -> error $ "bad quasiquoted FFI constant for unnamedAddr: " ++ x,
  quoteType = undefined,
  quoteDec = undefined
 }

{-# LINE 170 "src/LLVM/Internal/FFI/LLVMCTypes.hsc" #-}

newtype SynchronizationScope = SynchronizationScope CUInt
  deriving (Eq, Show, Typeable, Data, Generic)

synchronizationScopeSingleThread :: SynchronizationScope
synchronizationScopeSingleThread = SynchronizationScope 0
synchronizationScopeSystem :: SynchronizationScope
synchronizationScopeSystem = SynchronizationScope 1
synchronizationScopeP :: QuasiQuoter
synchronizationScopeP = QuasiQuoter {
  quoteExp = undefined,
  quotePat = \s -> dataToPatQ (const Nothing) $ case s of
    "SingleThread" -> synchronizationScopeSingleThread
    "System" -> synchronizationScopeSystem
    x -> error $ "bad quasiquoted FFI constant for synchronizationScope: " ++ x,
  quoteType = undefined,
  quoteDec = undefined
 }

{-# LINE 175 "src/LLVM/Internal/FFI/LLVMCTypes.hsc" #-}

newtype TailCallKind = TailCallKind CUInt
  deriving (Eq, Show, Typeable, Data, Generic)

tailCallKindNone :: TailCallKind
tailCallKindNone = TailCallKind 0
tailCallKindTail :: TailCallKind
tailCallKindTail = TailCallKind 1
tailCallKindMustTail :: TailCallKind
tailCallKindMustTail = TailCallKind 2
tailCallKindNoTail :: TailCallKind
tailCallKindNoTail = TailCallKind 3
tailCallKindP :: QuasiQuoter
tailCallKindP = QuasiQuoter {
  quoteExp = undefined,
  quotePat = \s -> dataToPatQ (const Nothing) $ case s of
    "None" -> tailCallKindNone
    "Tail" -> tailCallKindTail
    "MustTail" -> tailCallKindMustTail
    "NoTail" -> tailCallKindNoTail
    x -> error $ "bad quasiquoted FFI constant for tailCallKind: " ++ x,
  quoteType = undefined,
  quoteDec = undefined
 }

{-# LINE 180 "src/LLVM/Internal/FFI/LLVMCTypes.hsc" #-}

newtype Linkage = Linkage CUInt
  deriving (Eq, Read, Show, Typeable, Data, Generic)

linkageExternal :: Linkage
linkageExternal = Linkage 0
linkageAvailableExternally :: Linkage
linkageAvailableExternally = Linkage 1
linkageLinkOnceAny :: Linkage
linkageLinkOnceAny = Linkage 2
linkageLinkOnceODR :: Linkage
linkageLinkOnceODR = Linkage 3
linkageWeakAny :: Linkage
linkageWeakAny = Linkage 5
linkageWeakODR :: Linkage
linkageWeakODR = Linkage 6
linkageAppending :: Linkage
linkageAppending = Linkage 7
linkageInternal :: Linkage
linkageInternal = Linkage 8
linkagePrivate :: Linkage
linkagePrivate = Linkage 9
linkageExternalWeak :: Linkage
linkageExternalWeak = Linkage 12
linkageCommon :: Linkage
linkageCommon = Linkage 14
linkageP :: QuasiQuoter
linkageP = QuasiQuoter {
  quoteExp = undefined,
  quotePat = \s -> dataToPatQ (const Nothing) $ case s of
    "External" -> linkageExternal
    "AvailableExternally" -> linkageAvailableExternally
    "LinkOnceAny" -> linkageLinkOnceAny
    "LinkOnceODR" -> linkageLinkOnceODR
    "WeakAny" -> linkageWeakAny
    "WeakODR" -> linkageWeakODR
    "Appending" -> linkageAppending
    "Internal" -> linkageInternal
    "Private" -> linkagePrivate
    "ExternalWeak" -> linkageExternalWeak
    "Common" -> linkageCommon
    x -> error $ "bad quasiquoted FFI constant for linkage: " ++ x,
  quoteType = undefined,
  quoteDec = undefined
 }

{-# LINE 185 "src/LLVM/Internal/FFI/LLVMCTypes.hsc" #-}

newtype Visibility = Visibility CUInt
  deriving (Eq, Read, Show, Typeable, Data, Generic)

visibilityDefault :: Visibility
visibilityDefault = Visibility 0
visibilityHidden :: Visibility
visibilityHidden = Visibility 1
visibilityProtected :: Visibility
visibilityProtected = Visibility 2
visibilityP :: QuasiQuoter
visibilityP = QuasiQuoter {
  quoteExp = undefined,
  quotePat = \s -> dataToPatQ (const Nothing) $ case s of
    "Default" -> visibilityDefault
    "Hidden" -> visibilityHidden
    "Protected" -> visibilityProtected
    x -> error $ "bad quasiquoted FFI constant for visibility: " ++ x,
  quoteType = undefined,
  quoteDec = undefined
 }

{-# LINE 190 "src/LLVM/Internal/FFI/LLVMCTypes.hsc" #-}

newtype COMDATSelectionKind = COMDATSelectionKind CUInt
  deriving (Eq, Read, Show, Typeable, Data, Generic)

comdatSelectionKindAny :: COMDATSelectionKind
comdatSelectionKindAny = COMDATSelectionKind 0
comdatSelectionKindExactMatch :: COMDATSelectionKind
comdatSelectionKindExactMatch = COMDATSelectionKind 1
comdatSelectionKindLargest :: COMDATSelectionKind
comdatSelectionKindLargest = COMDATSelectionKind 2
comdatSelectionKindNoDuplicates :: COMDATSelectionKind
comdatSelectionKindNoDuplicates = COMDATSelectionKind 3
comdatSelectionKindSameSize :: COMDATSelectionKind
comdatSelectionKindSameSize = COMDATSelectionKind 4
comdatSelectionKindP :: QuasiQuoter
comdatSelectionKindP = QuasiQuoter {
  quoteExp = undefined,
  quotePat = \s -> dataToPatQ (const Nothing) $ case s of
    "Any" -> comdatSelectionKindAny
    "ExactMatch" -> comdatSelectionKindExactMatch
    "Largest" -> comdatSelectionKindLargest
    "NoDuplicates" -> comdatSelectionKindNoDuplicates
    "SameSize" -> comdatSelectionKindSameSize
    x -> error $ "bad quasiquoted FFI constant for comdatSelectionKind: " ++ x,
  quoteType = undefined,
  quoteDec = undefined
 }

{-# LINE 195 "src/LLVM/Internal/FFI/LLVMCTypes.hsc" #-}

newtype DLLStorageClass = DLLStorageClass CUInt
  deriving (Eq, Read, Show, Typeable, Data, Generic)

dllStorageClassDefault :: DLLStorageClass
dllStorageClassDefault = DLLStorageClass 0
dllStorageClassDLLImport :: DLLStorageClass
dllStorageClassDLLImport = DLLStorageClass 1
dllStorageClassDLLExport :: DLLStorageClass
dllStorageClassDLLExport = DLLStorageClass 2
dllStorageClassP :: QuasiQuoter
dllStorageClassP = QuasiQuoter {
  quoteExp = undefined,
  quotePat = \s -> dataToPatQ (const Nothing) $ case s of
    "Default" -> dllStorageClassDefault
    "DLLImport" -> dllStorageClassDLLImport
    "DLLExport" -> dllStorageClassDLLExport
    x -> error $ "bad quasiquoted FFI constant for dllStorageClass: " ++ x,
  quoteType = undefined,
  quoteDec = undefined
 }

{-# LINE 200 "src/LLVM/Internal/FFI/LLVMCTypes.hsc" #-}

newtype CallingConvention = CallingConvention CUInt
  deriving (Eq, Read, Show, Typeable, Data, Generic)

callingConventionC :: CallingConvention
callingConventionC = CallingConvention 0
callingConventionFast :: CallingConvention
callingConventionFast = CallingConvention 8
callingConventionCold :: CallingConvention
callingConventionCold = CallingConvention 9
callingConventionGHC :: CallingConvention
callingConventionGHC = CallingConvention 10
callingConventionHiPE :: CallingConvention
callingConventionHiPE = CallingConvention 11
callingConventionWebKit_JS :: CallingConvention
callingConventionWebKit_JS = CallingConvention 12
callingConventionAnyReg :: CallingConvention
callingConventionAnyReg = CallingConvention 13
callingConventionPreserveMost :: CallingConvention
callingConventionPreserveMost = CallingConvention 14
callingConventionPreserveAll :: CallingConvention
callingConventionPreserveAll = CallingConvention 15
callingConventionSwift :: CallingConvention
callingConventionSwift = CallingConvention 16
callingConventionCXX_FAST_TLS :: CallingConvention
callingConventionCXX_FAST_TLS = CallingConvention 17
callingConventionX86_StdCall :: CallingConvention
callingConventionX86_StdCall = CallingConvention 64
callingConventionX86_FastCall :: CallingConvention
callingConventionX86_FastCall = CallingConvention 65
callingConventionARM_APCS :: CallingConvention
callingConventionARM_APCS = CallingConvention 66
callingConventionARM_AAPCS :: CallingConvention
callingConventionARM_AAPCS = CallingConvention 67
callingConventionARM_AAPCS_VFP :: CallingConvention
callingConventionARM_AAPCS_VFP = CallingConvention 68
callingConventionMSP430_INTR :: CallingConvention
callingConventionMSP430_INTR = CallingConvention 69
callingConventionX86_ThisCall :: CallingConvention
callingConventionX86_ThisCall = CallingConvention 70
callingConventionPTX_Kernel :: CallingConvention
callingConventionPTX_Kernel = CallingConvention 71
callingConventionPTX_Device :: CallingConvention
callingConventionPTX_Device = CallingConvention 72
callingConventionSPIR_FUNC :: CallingConvention
callingConventionSPIR_FUNC = CallingConvention 75
callingConventionSPIR_KERNEL :: CallingConvention
callingConventionSPIR_KERNEL = CallingConvention 76
callingConventionIntel_OCL_BI :: CallingConvention
callingConventionIntel_OCL_BI = CallingConvention 77
callingConventionX86_64_SysV :: CallingConvention
callingConventionX86_64_SysV = CallingConvention 78
callingConventionWin64 :: CallingConvention
callingConventionWin64 = CallingConvention 79
callingConventionX86_VectorCall :: CallingConvention
callingConventionX86_VectorCall = CallingConvention 80
callingConventionHHVM :: CallingConvention
callingConventionHHVM = CallingConvention 81
callingConventionHHVM_C :: CallingConvention
callingConventionHHVM_C = CallingConvention 82
callingConventionX86_INTR :: CallingConvention
callingConventionX86_INTR = CallingConvention 83
callingConventionAVR_INTR :: CallingConvention
callingConventionAVR_INTR = CallingConvention 84
callingConventionAVR_SIGNAL :: CallingConvention
callingConventionAVR_SIGNAL = CallingConvention 85
callingConventionAVR_BUILTIN :: CallingConvention
callingConventionAVR_BUILTIN = CallingConvention 86
callingConventionAMDGPU_VS :: CallingConvention
callingConventionAMDGPU_VS = CallingConvention 87
callingConventionAMDGPU_GS :: CallingConvention
callingConventionAMDGPU_GS = CallingConvention 88
callingConventionAMDGPU_PS :: CallingConvention
callingConventionAMDGPU_PS = CallingConvention 89
callingConventionAMDGPU_CS :: CallingConvention
callingConventionAMDGPU_CS = CallingConvention 90
callingConventionAMDGPU_KERNEL :: CallingConvention
callingConventionAMDGPU_KERNEL = CallingConvention 91
callingConventionX86_RegCall :: CallingConvention
callingConventionX86_RegCall = CallingConvention 92
callingConventionAMDGPU_HS :: CallingConvention
callingConventionAMDGPU_HS = CallingConvention 93
callingConventionMSP430_BUILTIN :: CallingConvention
callingConventionMSP430_BUILTIN :: CallingConvention
callingConventionMSP430_BUILTIN = CUInt -> CallingConvention
CallingConvention CUInt
94
callingConventionP :: QuasiQuoter
callingConventionP = QuasiQuoter {
  quoteExp = undefined,
  quotePat = \s -> dataToPatQ (const Nothing) $ case s of
    "C" -> callingConventionC
    "Fast" -> callingConventionFast
    "Cold" -> callingConventionCold
    "GHC" -> callingConventionGHC
    "HiPE" -> callingConventionHiPE
    "WebKit_JS" -> callingConventionWebKit_JS
    "AnyReg" -> callingConventionAnyReg
    "PreserveMost" -> callingConventionPreserveMost
    "PreserveAll" -> callingConventionPreserveAll
    "Swift" -> callingConventionSwift
    "CXX_FAST_TLS" -> callingConventionCXX_FAST_TLS
    "X86_StdCall" -> callingConventionX86_StdCall
    "X86_FastCall" -> callingConventionX86_FastCall
    "ARM_APCS" -> callingConventionARM_APCS
    "ARM_AAPCS" -> callingConventionARM_AAPCS
    "ARM_AAPCS_VFP" -> callingConventionARM_AAPCS_VFP
    "MSP430_INTR" -> callingConventionMSP430_INTR
    "X86_ThisCall" -> callingConventionX86_ThisCall
    "PTX_Kernel" -> callingConventionPTX_Kernel
    "PTX_Device" -> callingConventionPTX_Device
    "SPIR_FUNC" -> callingConventionSPIR_FUNC
    "SPIR_KERNEL" -> callingConventionSPIR_KERNEL
    "Intel_OCL_BI" -> callingConventionIntel_OCL_BI
    "X86_64_SysV" -> callingConventionX86_64_SysV
    "Win64" -> callingConventionWin64
    "X86_VectorCall" -> callingConventionX86_VectorCall
    "HHVM" -> callingConventionHHVM
    "HHVM_C" -> callingConventionHHVM_C
    "X86_INTR" -> callingConventionX86_INTR
    "AVR_INTR" -> callingConventionAVR_INTR
    "AVR_SIGNAL" -> callingConventionAVR_SIGNAL
    "AVR_BUILTIN" -> callingConventionAVR_BUILTIN
    "AMDGPU_VS" -> callingConventionAMDGPU_VS
    "AMDGPU_GS" -> callingConventionAMDGPU_GS
    "AMDGPU_PS" -> callingConventionAMDGPU_PS
    "AMDGPU_CS" -> callingConventionAMDGPU_CS
    "AMDGPU_KERNEL" -> callingConventionAMDGPU_KERNEL
    "X86_RegCall" -> callingConventionX86_RegCall
    "AMDGPU_HS" -> callingConventionAMDGPU_HS
    "MSP430_BUILTIN" -> callingConventionMSP430_BUILTIN
    x -> error $ "bad quasiquoted FFI constant for callingConvention: " ++ x,
  quoteType = undefined,
  quoteDec = undefined
 }

{-# LINE 205 "src/LLVM/Internal/FFI/LLVMCTypes.hsc" #-}

newtype ThreadLocalMode = ThreadLocalMode CUInt
  deriving (Eq, Read, Show, Typeable, Data, Generic)

threadLocalModeNotThreadLocal :: ThreadLocalMode
threadLocalModeNotThreadLocal = ThreadLocalMode 0
threadLocalModeGeneralDynamicTLSModel :: ThreadLocalMode
threadLocalModeGeneralDynamicTLSModel = ThreadLocalMode 1
threadLocalModeLocalDynamicTLSModel :: ThreadLocalMode
threadLocalModeLocalDynamicTLSModel = ThreadLocalMode 2
threadLocalModeInitialExecTLSModel :: ThreadLocalMode
threadLocalModeInitialExecTLSModel = ThreadLocalMode 3
threadLocalModeLocalExecTLSModel :: ThreadLocalMode
threadLocalModeLocalExecTLSModel = ThreadLocalMode 4
threadLocalModeP :: QuasiQuoter
threadLocalModeP = QuasiQuoter {
  quoteExp = undefined,
  quotePat = \s -> dataToPatQ (const Nothing) $ case s of
    "NotThreadLocal" -> threadLocalModeNotThreadLocal
    "GeneralDynamicTLSModel" -> threadLocalModeGeneralDynamicTLSModel
    "LocalDynamicTLSModel" -> threadLocalModeLocalDynamicTLSModel
    "InitialExecTLSModel" -> threadLocalModeInitialExecTLSModel
    "LocalExecTLSModel" -> threadLocalModeLocalExecTLSModel
    x -> error $ "bad quasiquoted FFI constant for threadLocalMode: " ++ x,
  quoteType = undefined,
  quoteDec = undefined
 }

{-# LINE 210 "src/LLVM/Internal/FFI/LLVMCTypes.hsc" #-}

newtype ValueSubclassId = ValueSubclassId CUInt
  deriving (Eq, Read, Show, Typeable, Data, Generic)

valueSubclassIdArgument :: ValueSubclassId
valueSubclassIdArgument = ValueSubclassId 0
valueSubclassIdBasicBlock :: ValueSubclassId
valueSubclassIdBasicBlock = ValueSubclassId 1
valueSubclassIdFunction :: ValueSubclassId
valueSubclassIdFunction = ValueSubclassId 2
valueSubclassIdGlobalAlias :: ValueSubclassId
valueSubclassIdGlobalAlias = ValueSubclassId 3
valueSubclassIdGlobalVariable :: ValueSubclassId
valueSubclassIdGlobalVariable = ValueSubclassId 4
valueSubclassIdUndefValue :: ValueSubclassId
valueSubclassIdUndefValue = ValueSubclassId 5
valueSubclassIdBlockAddress :: ValueSubclassId
valueSubclassIdBlockAddress = ValueSubclassId 6
valueSubclassIdConstantExpr :: ValueSubclassId
valueSubclassIdConstantExpr = ValueSubclassId 7
valueSubclassIdConstantAggregateZero :: ValueSubclassId
valueSubclassIdConstantAggregateZero = ValueSubclassId 8
valueSubclassIdConstantDataArray :: ValueSubclassId
valueSubclassIdConstantDataArray = ValueSubclassId 9
valueSubclassIdConstantDataVector :: ValueSubclassId
valueSubclassIdConstantDataVector = ValueSubclassId 10
valueSubclassIdConstantInt :: ValueSubclassId
valueSubclassIdConstantInt = ValueSubclassId 11
valueSubclassIdConstantFP :: ValueSubclassId
valueSubclassIdConstantFP = ValueSubclassId 12
valueSubclassIdConstantArray :: ValueSubclassId
valueSubclassIdConstantArray = ValueSubclassId 13
valueSubclassIdConstantStruct :: ValueSubclassId
valueSubclassIdConstantStruct = ValueSubclassId 14
valueSubclassIdConstantTokenNone :: ValueSubclassId
valueSubclassIdConstantTokenNone = ValueSubclassId 15
valueSubclassIdConstantVector :: ValueSubclassId
valueSubclassIdConstantVector = ValueSubclassId 16
valueSubclassIdConstantPointerNull :: ValueSubclassId
valueSubclassIdConstantPointerNull = ValueSubclassId 17
valueSubclassIdInlineAsm :: ValueSubclassId
valueSubclassIdInlineAsm = ValueSubclassId 18
valueSubclassIdInstruction :: ValueSubclassId
valueSubclassIdInstruction = ValueSubclassId 19
valueSubclassIdP :: QuasiQuoter
valueSubclassIdP = QuasiQuoter {
  quoteExp = undefined,
  quotePat = \s -> dataToPatQ (const Nothing) $ case s of
    "Argument" -> valueSubclassIdArgument
    "BasicBlock" -> valueSubclassIdBasicBlock
    "Function" -> valueSubclassIdFunction
    "GlobalAlias" -> valueSubclassIdGlobalAlias
    "GlobalVariable" -> valueSubclassIdGlobalVariable
    "UndefValue" -> valueSubclassIdUndefValue
    "BlockAddress" -> valueSubclassIdBlockAddress
    "ConstantExpr" -> valueSubclassIdConstantExpr
    "ConstantAggregateZero" -> valueSubclassIdConstantAggregateZero
    "ConstantDataArray" -> valueSubclassIdConstantDataArray
    "ConstantDataVector" -> valueSubclassIdConstantDataVector
    "ConstantInt" -> valueSubclassIdConstantInt
    "ConstantFP" -> valueSubclassIdConstantFP
    "ConstantArray" -> valueSubclassIdConstantArray
    "ConstantStruct" -> valueSubclassIdConstantStruct
    "ConstantTokenNone" -> valueSubclassIdConstantTokenNone
    "ConstantVector" -> valueSubclassIdConstantVector
    "ConstantPointerNull" -> valueSubclassIdConstantPointerNull
    "InlineAsm" -> valueSubclassIdInlineAsm
    "Instruction" -> valueSubclassIdInstruction
    x -> error $ "bad quasiquoted FFI constant for valueSubclassId: " ++ x,
  quoteType = undefined,
  quoteDec = undefined
 }

{-# LINE 215 "src/LLVM/Internal/FFI/LLVMCTypes.hsc" #-}

newtype DiagnosticKind = DiagnosticKind CUInt
  deriving (Eq, Read, Show, Typeable, Data, Generic)

diagnosticKindError :: DiagnosticKind
diagnosticKindError = DiagnosticKind 0
diagnosticKindWarning :: DiagnosticKind
diagnosticKindWarning = DiagnosticKind 1
diagnosticKindNote :: DiagnosticKind
diagnosticKindNote = DiagnosticKind 2
diagnosticKindP :: QuasiQuoter
diagnosticKindP = QuasiQuoter {
  quoteExp = undefined,
  quotePat = \s -> dataToPatQ (const Nothing) $ case s of
    "Error" -> diagnosticKindError
    "Warning" -> diagnosticKindWarning
    "Note" -> diagnosticKindNote
    x -> error $ "bad quasiquoted FFI constant for diagnosticKind: " ++ x,
  quoteType = undefined,
  quoteDec = undefined
 }

{-# LINE 220 "src/LLVM/Internal/FFI/LLVMCTypes.hsc" #-}

newtype AsmDialect = AsmDialect CUInt
  deriving (Eq, Read, Show, Typeable, Data, Generic)

asmDialectATT :: AsmDialect
asmDialectATT = AsmDialect 0
asmDialectIntel :: AsmDialect
asmDialectIntel = AsmDialect 1
asmDialectP :: QuasiQuoter
asmDialectP = QuasiQuoter {
  quoteExp = undefined,
  quotePat = \s -> dataToPatQ (const Nothing) $ case s of
    "ATT" -> asmDialectATT
    "Intel" -> asmDialectIntel
    x -> error $ "bad quasiquoted FFI constant for asmDialect: " ++ x,
  quoteType = undefined,
  quoteDec = undefined
 }

{-# LINE 225 "src/LLVM/Internal/FFI/LLVMCTypes.hsc" #-}

newtype RMWOperation = RMWOperation CUInt
  deriving (Eq, Read, Show, Typeable, Data, Generic)

rmwOperationXchg :: RMWOperation
rmwOperationXchg = RMWOperation 0
rmwOperationAdd :: RMWOperation
rmwOperationAdd = RMWOperation 1
rmwOperationSub :: RMWOperation
rmwOperationSub = RMWOperation 2
rmwOperationAnd :: RMWOperation
rmwOperationAnd = RMWOperation 3
rmwOperationNand :: RMWOperation
rmwOperationNand = RMWOperation 4
rmwOperationOr :: RMWOperation
rmwOperationOr = RMWOperation 5
rmwOperationXor :: RMWOperation
rmwOperationXor = RMWOperation 6
rmwOperationMax :: RMWOperation
rmwOperationMax = RMWOperation 7
rmwOperationMin :: RMWOperation
rmwOperationMin = RMWOperation 8
rmwOperationUMax :: RMWOperation
rmwOperationUMax = RMWOperation 9
rmwOperationUMin :: RMWOperation
rmwOperationUMin = RMWOperation 10
rmwOperationFAdd :: RMWOperation
rmwOperationFAdd = RMWOperation 11
rmwOperationFSub :: RMWOperation
rmwOperationFSub = RMWOperation 12
rmwOperationP :: QuasiQuoter
rmwOperationP = QuasiQuoter {
  quoteExp = undefined,
  quotePat = \s -> dataToPatQ (const Nothing) $ case s of
    "Xchg" -> rmwOperationXchg
    "Add" -> rmwOperationAdd
    "Sub" -> rmwOperationSub
    "And" -> rmwOperationAnd
    "Nand" -> rmwOperationNand
    "Or" -> rmwOperationOr
    "Xor" -> rmwOperationXor
    "Max" -> rmwOperationMax
    "Min" -> rmwOperationMin
    "UMax" -> rmwOperationUMax
    "UMin" -> rmwOperationUMin
    "FAdd" -> rmwOperationFAdd
    "FSub" -> rmwOperationFSub
    x -> error $ "bad quasiquoted FFI constant for rmwOperation: " ++ x,
  quoteType = undefined,
  quoteDec = undefined
 }

{-# LINE 230 "src/LLVM/Internal/FFI/LLVMCTypes.hsc" #-}

newtype RelocModel = RelocModel CUInt
  deriving (Eq, Read, Show, Typeable, Data, Generic)

relocModelDefault :: RelocModel
relocModelDefault = RelocModel 0
relocModelStatic :: RelocModel
relocModelStatic = RelocModel 1
relocModelPIC :: RelocModel
relocModelPIC = RelocModel 2
relocModelDynamicNoPic :: RelocModel
relocModelDynamicNoPic = RelocModel 3
relocModelP :: QuasiQuoter
relocModelP = QuasiQuoter {
  quoteExp = undefined,
  quotePat = \s -> dataToPatQ (const Nothing) $ case s of
    "Default" -> relocModelDefault
    "Static" -> relocModelStatic
    "PIC" -> relocModelPIC
    "DynamicNoPic" -> relocModelDynamicNoPic
    x -> error $ "bad quasiquoted FFI constant for relocModel: " ++ x,
  quoteType = undefined,
  quoteDec = undefined
 }

{-# LINE 235 "src/LLVM/Internal/FFI/LLVMCTypes.hsc" #-}

newtype CodeModel = CodeModel CUInt
  deriving (Eq, Read, Show, Typeable, Data, Generic)

codeModelDefault :: CodeModel
codeModelDefault = CodeModel 0
codeModelJITDefault :: CodeModel
codeModelJITDefault = CodeModel 1
codeModelSmall :: CodeModel
codeModelSmall = CodeModel 3
codeModelKernel :: CodeModel
codeModelKernel = CodeModel 4
codeModelMedium :: CodeModel
codeModelMedium = CodeModel 5
codeModelLarge :: CodeModel
codeModelLarge = CodeModel 6
codeModelP :: QuasiQuoter
codeModelP = QuasiQuoter {
  quoteExp = undefined,
  quotePat = \s -> dataToPatQ (const Nothing) $ case s of
    "Default" -> codeModelDefault
    "JITDefault" -> codeModelJITDefault
    "Small" -> codeModelSmall
    "Kernel" -> codeModelKernel
    "Medium" -> codeModelMedium
    "Large" -> codeModelLarge
    x -> error $ "bad quasiquoted FFI constant for codeModel: " ++ x,
  quoteType = undefined,
  quoteDec = undefined
 }

{-# LINE 240 "src/LLVM/Internal/FFI/LLVMCTypes.hsc" #-}

newtype CodeGenOptLevel = CodeGenOptLevel CUInt
  deriving (Eq, Read, Show, Typeable, Data, Generic)

codeGenOptLevelNone :: CodeGenOptLevel
codeGenOptLevelNone = CodeGenOptLevel 0
codeGenOptLevelLess :: CodeGenOptLevel
codeGenOptLevelLess = CodeGenOptLevel 1
codeGenOptLevelDefault :: CodeGenOptLevel
codeGenOptLevelDefault = CodeGenOptLevel 2
codeGenOptLevelAggressive :: CodeGenOptLevel
codeGenOptLevelAggressive = CodeGenOptLevel 3
codeGenOptLevelP :: QuasiQuoter
codeGenOptLevelP = QuasiQuoter {
  quoteExp = undefined,
  quotePat = \s -> dataToPatQ (const Nothing) $ case s of
    "None" -> codeGenOptLevelNone
    "Less" -> codeGenOptLevelLess
    "Default" -> codeGenOptLevelDefault
    "Aggressive" -> codeGenOptLevelAggressive
    x -> error $ "bad quasiquoted FFI constant for codeGenOptLevel: " ++ x,
  quoteType = undefined,
  quoteDec = undefined
 }

{-# LINE 245 "src/LLVM/Internal/FFI/LLVMCTypes.hsc" #-}

newtype CodeGenFileType = CodeGenFileType CUInt
  deriving (Eq, Read, Show, Typeable, Data, Generic)

codeGenFileTypeAssembly :: CodeGenFileType
codeGenFileTypeAssembly = CodeGenFileType 0
codeGenFileTypeObject :: CodeGenFileType
codeGenFileTypeObject = CodeGenFileType 1
codeGenFileTypeP :: QuasiQuoter
codeGenFileTypeP = QuasiQuoter {
  quoteExp = undefined,
  quotePat = \s -> dataToPatQ (const Nothing) $ case s of
    "Assembly" -> codeGenFileTypeAssembly
    "Object" -> codeGenFileTypeObject
    x -> error $ "bad quasiquoted FFI constant for codeGenFileType: " ++ x,
  quoteType = undefined,
  quoteDec = undefined
 }

{-# LINE 250 "src/LLVM/Internal/FFI/LLVMCTypes.hsc" #-}

newtype FloatABIType = FloatABIType CUInt
  deriving (Eq, Read, Show, Typeable, Data, Generic)

floatABIDefault :: FloatABIType
floatABIDefault = FloatABIType 0
floatABISoft :: FloatABIType
floatABISoft = FloatABIType 1
floatABIHard :: FloatABIType
floatABIHard = FloatABIType 2
floatABIP :: QuasiQuoter
floatABIP = QuasiQuoter {
  quoteExp = undefined,
  quotePat = \s -> dataToPatQ (const Nothing) $ case s of
    "Default" -> floatABIDefault
    "Soft" -> floatABISoft
    "Hard" -> floatABIHard
    x -> error $ "bad quasiquoted FFI constant for floatABI: " ++ x,
  quoteType = undefined,
  quoteDec = undefined
 }

{-# LINE 255 "src/LLVM/Internal/FFI/LLVMCTypes.hsc" #-}

newtype FPOpFusionMode = FPOpFusionMode CUInt
  deriving (Eq, Read, Show, Typeable, Data, Generic)

fpOpFusionModeFast :: FPOpFusionMode
fpOpFusionModeFast = FPOpFusionMode 0
fpOpFusionModeStandard :: FPOpFusionMode
fpOpFusionModeStandard = FPOpFusionMode 1
fpOpFusionModeStrict :: FPOpFusionMode
fpOpFusionModeStrict = FPOpFusionMode 2
fpOpFusionModeP :: QuasiQuoter
fpOpFusionModeP = QuasiQuoter {
  quoteExp = undefined,
  quotePat = \s -> dataToPatQ (const Nothing) $ case s of
    "Fast" -> fpOpFusionModeFast
    "Standard" -> fpOpFusionModeStandard
    "Strict" -> fpOpFusionModeStrict
    x -> error $ "bad quasiquoted FFI constant for fpOpFusionMode: " ++ x,
  quoteType = undefined,
  quoteDec = undefined
 }

{-# LINE 260 "src/LLVM/Internal/FFI/LLVMCTypes.hsc" #-}

newtype ThreadModel = ThreadModel CUInt
  deriving (Eq, Read, Show, Typeable, Data, Generic)

threadModelPOSIX :: ThreadModel
threadModelPOSIX = ThreadModel 0
threadModelSingle :: ThreadModel
threadModelSingle = ThreadModel 1
threadModelP :: QuasiQuoter
threadModelP = QuasiQuoter {
  quoteExp = undefined,
  quotePat = \s -> dataToPatQ (const Nothing) $ case s of
    "POSIX" -> threadModelPOSIX
    "Single" -> threadModelSingle
    x -> error $ "bad quasiquoted FFI constant for threadModel: " ++ x,
  quoteType = undefined,
  quoteDec = undefined
 }

{-# LINE 265 "src/LLVM/Internal/FFI/LLVMCTypes.hsc" #-}

newtype EABI = EABI CUInt
  deriving (Eq, Read, Show, Typeable, Data, Generic)

eabiVersionUnknown :: EABI
eabiVersionUnknown = EABI 0
eabiVersionDefault :: EABI
eabiVersionDefault = EABI 1
eabiVersionEABI4 :: EABI
eabiVersionEABI4 = EABI 2
eabiVersionEABI5 :: EABI
eabiVersionEABI5 = EABI 3
eabiVersionGNU :: EABI
eabiVersionGNU = EABI 4
eabiVersionP :: QuasiQuoter
eabiVersionP = QuasiQuoter {
  quoteExp = undefined,
  quotePat = \s -> dataToPatQ (const Nothing) $ case s of
    "Unknown" -> eabiVersionUnknown
    "Default" -> eabiVersionDefault
    "EABI4" -> eabiVersionEABI4
    "EABI5" -> eabiVersionEABI5
    "GNU" -> eabiVersionGNU
    x -> error $ "bad quasiquoted FFI constant for eabiVersion: " ++ x,
  quoteType = undefined,
  quoteDec = undefined
 }

{-# LINE 270 "src/LLVM/Internal/FFI/LLVMCTypes.hsc" #-}

newtype DebuggerKind = DebuggerKind CUInt
  deriving (Eq, Read, Show, Typeable, Data, Generic)

debuggerKindDefault :: DebuggerKind
debuggerKindDefault = DebuggerKind 0
debuggerKindGDB :: DebuggerKind
debuggerKindGDB = DebuggerKind 1
debuggerKindLLDB :: DebuggerKind
debuggerKindLLDB = DebuggerKind 2
debuggerKindSCE :: DebuggerKind
debuggerKindSCE = DebuggerKind 3
debuggerKindP :: QuasiQuoter
debuggerKindP = QuasiQuoter {
  quoteExp = undefined,
  quotePat = \s -> dataToPatQ (const Nothing) $ case s of
    "Default" -> debuggerKindDefault
    "GDB" -> debuggerKindGDB
    "LLDB" -> debuggerKindLLDB
    "SCE" -> debuggerKindSCE
    x -> error $ "bad quasiquoted FFI constant for debuggerKind: " ++ x,
  quoteType = undefined,
  quoteDec = undefined
 }

{-# LINE 275 "src/LLVM/Internal/FFI/LLVMCTypes.hsc" #-}

newtype FPDenormalMode = FPDenormalMode CUInt
  deriving (Eq, Read, Show, Typeable, Data, Generic)

fpDenormalModeIEEE :: FPDenormalMode
fpDenormalModeIEEE = FPDenormalMode 0
fpDenormalModePreserveSign :: FPDenormalMode
fpDenormalModePreserveSign = FPDenormalMode 1
fpDenormalModePositiveZero :: FPDenormalMode
fpDenormalModePositiveZero = FPDenormalMode 2
fpDenormalModeP :: QuasiQuoter
fpDenormalModeP = QuasiQuoter {
  quoteExp = undefined,
  quotePat = \s -> dataToPatQ (const Nothing) $ case s of
    "IEEE" -> fpDenormalModeIEEE
    "PreserveSign" -> fpDenormalModePreserveSign
    "PositiveZero" -> fpDenormalModePositiveZero
    x -> error $ "bad quasiquoted FFI constant for fpDenormalMode: " ++ x,
  quoteType = undefined,
  quoteDec = undefined
 }

{-# LINE 280 "src/LLVM/Internal/FFI/LLVMCTypes.hsc" #-}

newtype ExceptionHandling = ExceptionHandling CUInt
  deriving (Eq, Read, Show, Typeable, Data, Generic)

exceptionHandlingNone :: ExceptionHandling
exceptionHandlingNone = ExceptionHandling 0
exceptionHandlingDwarfCFI :: ExceptionHandling
exceptionHandlingDwarfCFI = ExceptionHandling 1
exceptionHandlingSjLj :: ExceptionHandling
exceptionHandlingSjLj = ExceptionHandling 2
exceptionHandlingARM :: ExceptionHandling
exceptionHandlingARM = ExceptionHandling 3
exceptionHandlingWinEH :: ExceptionHandling
exceptionHandlingWinEH = ExceptionHandling 4
exceptionHandlingP :: QuasiQuoter
exceptionHandlingP = QuasiQuoter {
  quoteExp = undefined,
  quotePat = \s -> dataToPatQ (const Nothing) $ case s of
    "None" -> exceptionHandlingNone
    "DwarfCFI" -> exceptionHandlingDwarfCFI
    "SjLj" -> exceptionHandlingSjLj
    "ARM" -> exceptionHandlingARM
    "WinEH" -> exceptionHandlingWinEH
    x -> error $ "bad quasiquoted FFI constant for exceptionHandling: " ++ x,
  quoteType = undefined,
  quoteDec = undefined
 }

{-# LINE 285 "src/LLVM/Internal/FFI/LLVMCTypes.hsc" #-}

newtype TargetOptionFlag = TargetOptionFlag CUInt
  deriving (Eq, Read, Show, Typeable, Data, Generic)

targetOptionFlagUnsafeFPMath :: TargetOptionFlag
targetOptionFlagUnsafeFPMath = TargetOptionFlag 0
targetOptionFlagNoInfsFPMath :: TargetOptionFlag
targetOptionFlagNoInfsFPMath = TargetOptionFlag 1
targetOptionFlagNoNaNsFPMath :: TargetOptionFlag
targetOptionFlagNoNaNsFPMath = TargetOptionFlag 2
targetOptionFlagNoTrappingFPMath :: TargetOptionFlag
targetOptionFlagNoTrappingFPMath = TargetOptionFlag 3
targetOptionFlagNoSignedZerosFPMath :: TargetOptionFlag
targetOptionFlagNoSignedZerosFPMath = TargetOptionFlag 4
targetOptionFlagHonorSignDependentRoundingFPMathOption :: TargetOptionFlag
targetOptionFlagHonorSignDependentRoundingFPMathOption = TargetOptionFlag 5
targetOptionFlagNoZerosInBSS :: TargetOptionFlag
targetOptionFlagNoZerosInBSS = TargetOptionFlag 6
targetOptionFlagGuaranteedTailCallOpt :: TargetOptionFlag
targetOptionFlagGuaranteedTailCallOpt = TargetOptionFlag 7
targetOptionFlagStackSymbolOrdering :: TargetOptionFlag
targetOptionFlagStackSymbolOrdering = TargetOptionFlag 8
targetOptionFlagEnableFastISel :: TargetOptionFlag
targetOptionFlagEnableFastISel = TargetOptionFlag 9
targetOptionFlagEnableGlobalISel :: TargetOptionFlag
targetOptionFlagEnableGlobalISel = TargetOptionFlag 10
targetOptionFlagUseInitArray :: TargetOptionFlag
targetOptionFlagUseInitArray = TargetOptionFlag 11
targetOptionFlagDisableIntegratedAS :: TargetOptionFlag
targetOptionFlagDisableIntegratedAS = TargetOptionFlag 12
targetOptionFlagRelaxELFRelocations :: TargetOptionFlag
targetOptionFlagRelaxELFRelocations = TargetOptionFlag 13
targetOptionFlagFunctionSections :: TargetOptionFlag
targetOptionFlagFunctionSections = TargetOptionFlag 14
targetOptionFlagDataSections :: TargetOptionFlag
targetOptionFlagDataSections = TargetOptionFlag 15
targetOptionFlagIgnoreXCOFFVisibility :: TargetOptionFlag
targetOptionFlagIgnoreXCOFFVisibility = TargetOptionFlag 16
targetOptionFlagUniqueSectionNames :: TargetOptionFlag
targetOptionFlagUniqueSectionNames = TargetOptionFlag 17
targetOptionFlagUniqueBasicBlockSectionNames :: TargetOptionFlag
targetOptionFlagUniqueBasicBlockSectionNames = TargetOptionFlag 18
targetOptionFlagTrapUnreachable :: TargetOptionFlag
targetOptionFlagTrapUnreachable = TargetOptionFlag 19
targetOptionFlagNoTrapAfterNoreturn :: TargetOptionFlag
targetOptionFlagNoTrapAfterNoreturn = TargetOptionFlag 20
targetOptionFlagEmulatedTLS :: TargetOptionFlag
targetOptionFlagEmulatedTLS = TargetOptionFlag 21
targetOptionFlagExplicitEmulatedTLS :: TargetOptionFlag
targetOptionFlagExplicitEmulatedTLS = TargetOptionFlag 22
targetOptionFlagEnableIPRA :: TargetOptionFlag
targetOptionFlagEnableIPRA = TargetOptionFlag 23
targetOptionFlagEmitStackSizeSection :: TargetOptionFlag
targetOptionFlagEmitStackSizeSection :: TargetOptionFlag
targetOptionFlagEmitStackSizeSection = TargetOptionFlag CUInt
24
targetOptionFlagEnableMachineOutliner :: TargetOptionFlag
targetOptionFlagEnableMachineOutliner :: TargetOptionFlag
targetOptionFlagEnableMachineOutliner = TargetOptionFlag CUInt
25
targetOptionFlagEnableMachineFunctionSplitter :: TargetOptionFlag
targetOptionFlagEnableMachineFunctionSplitter = TargetOptionFlag 26
targetOptionFlagSupportsDefaultOutlining :: TargetOptionFlag
targetOptionFlagSupportsDefaultOutlining = TargetOptionFlag 27
targetOptionFlagEmitAddrsig :: TargetOptionFlag
targetOptionFlagEmitAddrsig = TargetOptionFlag 28
targetOptionFlagEmitCallSiteInfo :: TargetOptionFlag
targetOptionFlagEmitCallSiteInfo = TargetOptionFlag 29
targetOptionFlagSupportsDebugEntryValues :: TargetOptionFlag
targetOptionFlagSupportsDebugEntryValues :: TargetOptionFlag
targetOptionFlagSupportsDebugEntryValues = TargetOptionFlag CUInt
30
targetOptionFlagEnableDebugEntryValues :: TargetOptionFlag
targetOptionFlagEnableDebugEntryValues :: TargetOptionFlag
targetOptionFlagEnableDebugEntryValues = CUInt -> TargetOptionFlag
TargetOptionFlag CUInt
31
targetOptionFlagValueTrackingVariableLocations :: TargetOptionFlag
targetOptionFlagValueTrackingVariableLocations :: TargetOptionFlag
targetOptionFlagValueTrackingVariableLocations = CUInt -> TargetOptionFlag
TargetOptionFlag CUInt
32
targetOptionFlagForceDwarfFrameSection :: TargetOptionFlag
targetOptionFlagForceDwarfFrameSection :: TargetOptionFlag
targetOptionFlagForceDwarfFrameSection = CUInt -> TargetOptionFlag
TargetOptionFlag CUInt
33
targetOptionFlagXRayOmitFunctionIndex :: TargetOptionFlag
targetOptionFlagXRayOmitFunctionIndex :: TargetOptionFlag
targetOptionFlagXRayOmitFunctionIndex CUInt
= TargetOptionFlag CUInt
34
targetOptionFlagP :: QuasiQuoter
targetOptionFlagP = QuasiQuoter {
  quoteExp = undefined,
  quotePat = \s -> dataToPatQ (const Nothing) $ case s of
    "UnsafeFPMath" -> targetOptionFlagUnsafeFPMath
    "NoInfsFPMath" -> targetOptionFlagNoInfsFPMath
    "NoNaNsFPMath" -> targetOptionFlagNoNaNsFPMath
    "NoTrappingFPMath" -> targetOptionFlagNoTrappingFPMath
    "NoSignedZerosFPMath" -> targetOptionFlagNoSignedZerosFPMath
    "HonorSignDependentRoundingFPMathOption" -> targetOptionFlagHonorSignDependentRoundingFPMathOption
    "NoZerosInBSS" -> targetOptionFlagNoZerosInBSS
    "GuaranteedTailCallOpt" -> targetOptionFlagGuaranteedTailCallOpt
    "StackSymbolOrdering" -> targetOptionFlagStackSymbolOrdering
    "EnableFastISel" -> targetOptionFlagEnableFastISel
    "EnableGlobalISel" -> targetOptionFlagEnableGlobalISel
    "UseInitArray" -> targetOptionFlagUseInitArray
    "DisableIntegratedAS" -> targetOptionFlagDisableIntegratedAS
    "RelaxELFRelocations" -> targetOptionFlagRelaxELFRelocations
    "FunctionSections" -> targetOptionFlagFunctionSections
    "DataSections" -> targetOptionFlagDataSections
    "IgnoreXCOFFVisibility" -> targetOptionFlagIgnoreXCOFFVisibility
    "UniqueSectionNames" -> targetOptionFlagUniqueSectionNames
    "UniqueBasicBlockSectionNames" -> targetOptionFlagUniqueBasicBlockSectionNames
    "TrapUnreachable" -> targetOptionFlagTrapUnreachable
    "NoTrapAfterNoreturn" -> targetOptionFlagNoTrapAfterNoreturn
    "EmulatedTLS" -> targetOptionFlagEmulatedTLS
    "ExplicitEmulatedTLS" -> targetOptionFlagExplicitEmulatedTLS
    "EnableIPRA" -> targetOptionFlagEnableIPRA
    "EmitStackSizeSection" -> targetOptionFlagEmitStackSizeSection
    "EnableMachineOutliner" -> targetOptionFlagEnableMachineOutliner
    "EnableMachineFunctionSplitter" -> targetOptionFlagEnableMachineFunctionSplitter
    "SupportsDefaultOutlining" -> targetOptionFlagSupportsDefaultOutlining
    "EmitAddrsig" -> targetOptionFlagEmitAddrsig
    "EmitCallSiteInfo" -> targetOptionFlagEmitCallSiteInfo
    "SupportsDebugEntryValues" -> targetOptionFlagSupportsDebugEntryValues
    "EnableDebugEntryValues" -> targetOptionFlagEnableDebugEntryValues
    "ValueTrackingVariableLocations" -> targetOptionFlagValueTrackingVariableLocations
    "ForceDwarfFrameSection" -> targetOptionFlagForceDwarfFrameSection
    "XRayOmitFunctionIndex" -> targetOptionFlagXRayOmitFunctionIndex
    x -> error $ "bad quasiquoted FFI constant for targetOptionFlag: " ++ x,
  quoteType = undefined,
  quoteDec = undefined
 }

{-# LINE 290 "src/LLVM/Internal/FFI/LLVMCTypes.hsc" #-}

newtype MCTargetOptionFlag = MCTargetOptionFlag CUInt
  deriving (Eq, Read, Show, Typeable, Data, Generic)

mcTargetOptionFlagMCRelaxAll :: MCTargetOptionFlag
mcTargetOptionFlagMCRelaxAll = MCTargetOptionFlag 0
mcTargetOptionFlagMCNoExecStack :: MCTargetOptionFlag
mcTargetOptionFlagMCNoExecStack = MCTargetOptionFlag 1
mcTargetOptionFlagMCFatalWarnings :: MCTargetOptionFlag
mcTargetOptionFlagMCFatalWarnings = MCTargetOptionFlag 2
mcTargetOptionFlagMCNoWarn :: MCTargetOptionFlag
mcTargetOptionFlagMCNoWarn = MCTargetOptionFlag 3
mcTargetOptionFlagMCNoDeprecatedWarn :: MCTargetOptionFlag
mcTargetOptionFlagMCNoDeprecatedWarn = MCTargetOptionFlag 4
mcTargetOptionFlagMCSaveTempLabels :: MCTargetOptionFlag
mcTargetOptionFlagMCSaveTempLabels = MCTargetOptionFlag 5
mcTargetOptionFlagMCUseDwarfDirectory :: MCTargetOptionFlag
mcTargetOptionFlagMCUseDwarfDirectory = MCTargetOptionFlag 6
mcTargetOptionFlagMCIncrementalLinkerCompatible :: MCTargetOptionFlag
mcTargetOptionFlagMCIncrementalLinkerCompatible = MCTargetOptionFlag 7
mcTargetOptionFlagShowMCEncoding :: MCTargetOptionFlag
mcTargetOptionFlagShowMCEncoding = MCTargetOptionFlag 8
mcTargetOptionFlagShowMCInst :: MCTargetOptionFlag
mcTargetOptionFlagShowMCInst = MCTargetOptionFlag 9
mcTargetOptionFlagAsmVerbose :: MCTargetOptionFlag
mcTargetOptionFlagAsmVerbose = MCTargetOptionFlag 10
mcTargetOptionFlagPreserveAsmComments :: MCTargetOptionFlag
mcTargetOptionFlagPreserveAsmComments = MCTargetOptionFlag 11
mcTargetOptionFlagP :: QuasiQuoter
mcTargetOptionFlagP = QuasiQuoter {
  quoteExp = undefined,
  quotePat = \s -> dataToPatQ (const Nothing) $ case s of
    "MCRelaxAll" -> mcTargetOptionFlagMCRelaxAll
    "MCNoExecStack" -> mcTargetOptionFlagMCNoExecStack
    "MCFatalWarnings" -> mcTargetOptionFlagMCFatalWarnings
    "MCNoWarn" -> mcTargetOptionFlagMCNoWarn
    "MCNoDeprecatedWarn" -> mcTargetOptionFlagMCNoDeprecatedWarn
    "MCSaveTempLabels" -> mcTargetOptionFlagMCSaveTempLabels
    "MCUseDwarfDirectory" -> mcTargetOptionFlagMCUseDwarfDirectory
    "MCIncrementalLinkerCompatible" -> mcTargetOptionFlagMCIncrementalLinkerCompatible
    "ShowMCEncoding" -> mcTargetOptionFlagShowMCEncoding
    "ShowMCInst" -> mcTargetOptionFlagShowMCInst
    "AsmVerbose" -> mcTargetOptionFlagAsmVerbose
    "PreserveAsmComments" -> mcTargetOptionFlagPreserveAsmComments
    x -> error $ "bad quasiquoted FFI constant for mcTargetOptionFlag: " ++ x,
  quoteType = undefined,
  quoteDec = undefined
 }

{-# LINE 295 "src/LLVM/Internal/FFI/LLVMCTypes.hsc" #-}

newtype DebugCompressionType = DebugCompressionType CUInt
  deriving (Eq, Read, Show, Typeable, Data, Generic)

debugCompressionTypeNone :: DebugCompressionType
debugCompressionTypeNone = DebugCompressionType 0
debugCompressionTypeGNU :: DebugCompressionType
debugCompressionTypeGNU = DebugCompressionType 1
debugCompressionTypeZ :: DebugCompressionType
debugCompressionTypeZ = DebugCompressionType 2
debugCompressionTypeP :: QuasiQuoter
debugCompressionTypeP = QuasiQuoter {
  quoteExp = undefined,
  quotePat = \s -> dataToPatQ (const Nothing) $ case s of
    "None" -> debugCompressionTypeNone
    "GNU" -> debugCompressionTypeGNU
    "Z" -> debugCompressionTypeZ
    x -> error $ "bad quasiquoted FFI constant for debugCompressionType: " ++ x,
  quoteType = undefined,
  quoteDec = undefined
 }

{-# LINE 300 "src/LLVM/Internal/FFI/LLVMCTypes.hsc" #-}

newtype TypeKind = TypeKind CUInt
  deriving (Eq, Read, Show, Typeable, Data, Generic)

typeKindVoid :: TypeKind
typeKindVoid = TypeKind 0
typeKindHalf :: TypeKind
typeKindHalf = TypeKind 1
typeKindFloat :: TypeKind
typeKindFloat = TypeKind 2
typeKindDouble :: TypeKind
typeKindDouble = TypeKind 3
typeKindX86_FP80 :: TypeKind
typeKindX86_FP80 = TypeKind 4
typeKindFP128 :: TypeKind
typeKindFP128 = TypeKind 5
typeKindPPC_FP128 :: TypeKind
typeKindPPC_FP128 = TypeKind 6
typeKindLabel :: TypeKind
typeKindLabel = TypeKind 7
typeKindInteger :: TypeKind
typeKindInteger = TypeKind 8
typeKindFunction :: TypeKind
typeKindFunction = TypeKind 9
typeKindStruct :: TypeKind
typeKindStruct = TypeKind 10
typeKindArray :: TypeKind
typeKindArray = TypeKind 11
typeKindPointer :: TypeKind
typeKindPointer = TypeKind 12
typeKindVector :: TypeKind
typeKindVector = TypeKind 13
typeKindMetadata :: TypeKind
typeKindMetadata = TypeKind 14
typeKindX86_MMX :: TypeKind
typeKindX86_MMX = TypeKind 15
typeKindToken :: TypeKind
typeKindToken = TypeKind 16
typeKindP :: QuasiQuoter
typeKindP = QuasiQuoter {
  quoteExp = undefined,
  quotePat = \s -> dataToPatQ (const Nothing) $ case s of
    "Void" -> typeKindVoid
    "Half" -> typeKindHalf
    "Float" -> typeKindFloat
    "Double" -> typeKindDouble
    "X86_FP80" -> typeKindX86_FP80
    "FP128" -> typeKindFP128
    "PPC_FP128" -> typeKindPPC_FP128
    "Label" -> typeKindLabel
    "Integer" -> typeKindInteger
    "Function" -> typeKindFunction
    "Struct" -> typeKindStruct
    "Array" -> typeKindArray
    "Pointer" -> typeKindPointer
    "Vector" -> typeKindVector
    "Metadata" -> typeKindMetadata
    "X86_MMX" -> typeKindX86_MMX
    "Token" -> typeKindToken
    x -> error $ "bad quasiquoted FFI constant for typeKind: " ++ x,
  quoteType = undefined,
  quoteDec = undefined
 }

{-# LINE 305 "src/LLVM/Internal/FFI/LLVMCTypes.hsc" #-}











newtype ParameterAttributeKind = ParameterAttributeKind CUInt
  deriving (Eq, Read, Show, Typeable, Data, Generic)

parameterAttributeKindImmArg :: ParameterAttributeKind
parameterAttributeKindImmArg = ParameterAttributeKind 7
parameterAttributeKindInAlloca :: ParameterAttributeKind
parameterAttributeKindInAlloca = ParameterAttributeKind 8
parameterAttributeKindInReg :: ParameterAttributeKind
parameterAttributeKindInReg = ParameterAttributeKind 9
parameterAttributeKindNest :: ParameterAttributeKind
parameterAttributeKindNest = ParameterAttributeKind 16
parameterAttributeKindNoAlias :: ParameterAttributeKind
parameterAttributeKindNoAlias = ParameterAttributeKind 17
parameterAttributeKindNoCapture :: ParameterAttributeKind
parameterAttributeKindNoCapture = ParameterAttributeKind 20
parameterAttributeKindNoFree :: ParameterAttributeKind
parameterAttributeKindNoFree = ParameterAttributeKind 23
parameterAttributeKindNonNull :: ParameterAttributeKind
parameterAttributeKindNonNull = ParameterAttributeKind 35
parameterAttributeKindNullPointerIsValid :: ParameterAttributeKind
parameterAttributeKindNullPointerIsValid = ParameterAttributeKind 36
parameterAttributeKindReadNone :: ParameterAttributeKind
parameterAttributeKindReadNone = ParameterAttributeKind 40
parameterAttributeKindReadOnly :: ParameterAttributeKind
parameterAttributeKindReadOnly = ParameterAttributeKind 41
parameterAttributeKindReturned :: ParameterAttributeKind
parameterAttributeKindReturned = ParameterAttributeKind 42
parameterAttributeKindSExt :: ParameterAttributeKind
parameterAttributeKindSExt = ParameterAttributeKind 44
parameterAttributeKindSwiftError :: ParameterAttributeKind
parameterAttributeKindSwiftError = ParameterAttributeKind 58
parameterAttributeKindSwiftSelf :: ParameterAttributeKind
parameterAttributeKindSwiftSelf = ParameterAttributeKind 59
parameterAttributeKindWriteOnly :: ParameterAttributeKind
parameterAttributeKindWriteOnly = ParameterAttributeKind 62
parameterAttributeKindZExt :: ParameterAttributeKind
parameterAttributeKindZExt = ParameterAttributeKind 63
parameterAttributeKindByRef :: ParameterAttributeKind
parameterAttributeKindByRef = ParameterAttributeKind 64
parameterAttributeKindByVal :: ParameterAttributeKind
parameterAttributeKindByVal = ParameterAttributeKind 65
parameterAttributeKindStructRet :: ParameterAttributeKind
parameterAttributeKindStructRet = ParameterAttributeKind 68
parameterAttributeKindAlignment :: ParameterAttributeKind
parameterAttributeKindAlignment = ParameterAttributeKind 69
parameterAttributeKindDereferenceable :: ParameterAttributeKind
parameterAttributeKindDereferenceable = ParameterAttributeKind 71
parameterAttributeKindDereferenceableOrNull :: ParameterAttributeKind
parameterAttributeKindDereferenceableOrNull = ParameterAttributeKind 72
parameterAttributeKindP :: QuasiQuoter
parameterAttributeKindP = QuasiQuoter {
  quoteExp = undefined,
  quotePat = \s -> dataToPatQ (const Nothing) $ case s of
    "ImmArg" -> parameterAttributeKindImmArg
    "InAlloca" -> parameterAttributeKindInAlloca
    "InReg" -> parameterAttributeKindInReg
    "Nest" -> parameterAttributeKindNest
    "NoAlias" -> parameterAttributeKindNoAlias
    "NoCapture" -> parameterAttributeKindNoCapture
    "NoFree" -> parameterAttributeKindNoFree
    "NonNull" -> parameterAttributeKindNonNull
    "NullPointerIsValid" -> parameterAttributeKindNullPointerIsValid
    "ReadNone" -> parameterAttributeKindReadNone
    "ReadOnly" -> parameterAttributeKindReadOnly
    "Returned" -> parameterAttributeKindReturned
    "SExt" -> parameterAttributeKindSExt
    "SwiftError" -> parameterAttributeKindSwiftError
    "SwiftSelf" -> parameterAttributeKindSwiftSelf
    "WriteOnly" -> parameterAttributeKindWriteOnly
    "ZExt" -> parameterAttributeKindZExt
    "ByRef" -> parameterAttributeKindByRef
    "ByVal" -> parameterAttributeKindByVal
    "StructRet" -> parameterAttributeKindStructRet
    "Alignment" -> parameterAttributeKindAlignment
    "Dereferenceable" -> parameterAttributeKindDereferenceable
    "DereferenceableOrNull" -> parameterAttributeKindDereferenceableOrNull
    x -> error $ "bad quasiquoted FFI constant for parameterAttributeKind: " ++ x,
  quoteType = undefined,
  quoteDec = undefined
 }

{-# LINE 320 "src/LLVM/Internal/FFI/LLVMCTypes.hsc" #-}

newtype FunctionAttributeKind = FunctionAttributeKind CUInt
  deriving (Eq, Read, Show, Typeable, Data, Generic)

functionAttributeKindAlwaysInline :: FunctionAttributeKind
functionAttributeKindAlwaysInline = FunctionAttributeKind 1
functionAttributeKindArgMemOnly :: FunctionAttributeKind
functionAttributeKindArgMemOnly = FunctionAttributeKind 2
functionAttributeKindBuiltin :: FunctionAttributeKind
functionAttributeKindBuiltin = FunctionAttributeKind 3
functionAttributeKindCold :: FunctionAttributeKind
functionAttributeKindCold = FunctionAttributeKind 4
functionAttributeKindConvergent :: FunctionAttributeKind
functionAttributeKindConvergent = FunctionAttributeKind 5
functionAttributeKindHot :: FunctionAttributeKind
functionAttributeKindHot = FunctionAttributeKind 6
functionAttributeKindInaccessibleMemOnly :: FunctionAttributeKind
functionAttributeKindInaccessibleMemOnly = FunctionAttributeKind 10
functionAttributeKindInaccessibleMemOrArgMemOnly :: FunctionAttributeKind
functionAttributeKindInaccessibleMemOrArgMemOnly = FunctionAttributeKind 11
functionAttributeKindInlineHint :: FunctionAttributeKind
functionAttributeKindInlineHint = FunctionAttributeKind 12
functionAttributeKindJumpTable :: FunctionAttributeKind
functionAttributeKindJumpTable = FunctionAttributeKind 13
functionAttributeKindMinSize :: FunctionAttributeKind
functionAttributeKindMinSize = FunctionAttributeKind 14
functionAttributeKindNaked :: FunctionAttributeKind
functionAttributeKindNaked = FunctionAttributeKind 15
functionAttributeKindNoBuiltin :: FunctionAttributeKind
functionAttributeKindNoBuiltin = FunctionAttributeKind 18
functionAttributeKindNoCallback :: FunctionAttributeKind
functionAttributeKindNoCallback = FunctionAttributeKind 19
functionAttributeKindNoCfCheck :: FunctionAttributeKind
functionAttributeKindNoCfCheck = FunctionAttributeKind 21
functionAttributeKindNoDuplicate :: FunctionAttributeKind
functionAttributeKindNoDuplicate = FunctionAttributeKind 22
functionAttributeKindNoFree :: FunctionAttributeKind
functionAttributeKindNoFree = FunctionAttributeKind 23
functionAttributeKindNoImplicitFloat :: FunctionAttributeKind
functionAttributeKindNoImplicitFloat = FunctionAttributeKind 24
functionAttributeKindNoInline :: FunctionAttributeKind
functionAttributeKindNoInline = FunctionAttributeKind 25
functionAttributeKindNoMerge :: FunctionAttributeKind
functionAttributeKindNoMerge = FunctionAttributeKind 26
functionAttributeKindNoProfile :: FunctionAttributeKind
functionAttributeKindNoProfile = FunctionAttributeKind 27
functionAttributeKindNoRecurse :: FunctionAttributeKind
functionAttributeKindNoRecurse = FunctionAttributeKind 28
functionAttributeKindNoRedZone :: FunctionAttributeKind
functionAttributeKindNoRedZone = FunctionAttributeKind 29
functionAttributeKindNoReturn :: FunctionAttributeKind
functionAttributeKindNoReturn = FunctionAttributeKind 30
functionAttributeKindNoSync :: FunctionAttributeKind
functionAttributeKindNoSync = FunctionAttributeKind 31
functionAttributeKindNoUndef :: FunctionAttributeKind
functionAttributeKindNoUndef = FunctionAttributeKind 32
functionAttributeKindNoUnwind :: FunctionAttributeKind
functionAttributeKindNoUnwind = FunctionAttributeKind 33
functionAttributeKindNonLazyBind :: FunctionAttributeKind
functionAttributeKindNonLazyBind = FunctionAttributeKind 34
functionAttributeKindOptForFuzzing :: FunctionAttributeKind
functionAttributeKindOptForFuzzing = FunctionAttributeKind 37
functionAttributeKindOptimizeForSize :: FunctionAttributeKind
functionAttributeKindOptimizeForSize = FunctionAttributeKind 38
functionAttributeKindOptimizeNone :: FunctionAttributeKind
functionAttributeKindOptimizeNone = FunctionAttributeKind 39
functionAttributeKindReadNone :: FunctionAttributeKind
functionAttributeKindReadNone = FunctionAttributeKind 40
functionAttributeKindReadOnly :: FunctionAttributeKind
functionAttributeKindReadOnly = FunctionAttributeKind 41
functionAttributeKindReturnsTwice :: FunctionAttributeKind
functionAttributeKindReturnsTwice = FunctionAttributeKind 43
functionAttributeKindSafeStack :: FunctionAttributeKind
functionAttributeKindSafeStack = FunctionAttributeKind 45
functionAttributeKindSanitizeAddress :: FunctionAttributeKind
functionAttributeKindSanitizeAddress = FunctionAttributeKind 46
functionAttributeKindSanitizeHWAddress :: FunctionAttributeKind
functionAttributeKindSanitizeHWAddress = FunctionAttributeKind 47
functionAttributeKindSanitizeMemTag :: FunctionAttributeKind
functionAttributeKindSanitizeMemTag = FunctionAttributeKind 48
functionAttributeKindSanitizeMemory :: FunctionAttributeKind
functionAttributeKindSanitizeMemory = FunctionAttributeKind 49
functionAttributeKindSanitizeThread :: FunctionAttributeKind
functionAttributeKindSanitizeThread = FunctionAttributeKind 50
functionAttributeKindShadowCallStack :: FunctionAttributeKind
functionAttributeKindShadowCallStack :: FunctionAttributeKind
functionAttributeKindShadowCallStack = CUInt -> FunctionAttributeKind
FunctionAttributeKind CUInt
51
functionAttributeKindSpeculatable :: FunctionAttributeKind
functionAttributeKindSpeculatable :: FunctionAttributeKind
functionAttributeKindSpeculatable = CUInt -> FunctionAttributeKind
FunctionAttributeKind CUInt
52
functionAttributeKindSpeculativeLoadHardening :: FunctionAttributeKind
functionAttributeKindSpeculativeLoadHardening :: FunctionAttributeKind
functionAttributeKindSpeculativeLoadHardening = CUInt -> FunctionAttributeKind
FunctionAttributeKind CUInt
53
functionAttributeKindStackProtect :: FunctionAttributeKind
functionAttributeKindStackProtect :: FunctionAttributeKind
functionAttributeKindStackProtect = CUInt -> FunctionAttributeKind
FunctionAttributeKind CUInt
54
functionAttributeKindStackProtectReq :: FunctionAttributeKind
functionAttributeKindStackProtectReq :: FunctionAttributeKind
functionAttributeKindStackProtectReq = CUInt -> FunctionAttributeKind
FunctionAttributeKind CUInt
55
functionAttributeKindStackProtectStrong :: FunctionAttributeKind
functionAttributeKindStackProtectStrong :: FunctionAttributeKind
functionAttributeKindStackProtectStrong = CUInt -> FunctionAttributeKind
FunctionAttributeKind CUInt
56
functionAttributeKindStrictFP :: FunctionAttributeKind
functionAttributeKindStrictFP :: FunctionAttributeKind
functionAttributeKindStrictFP = CUInt -> FunctionAttributeKind
FunctionAttributeKind CUInt
57
LibFunc
functionAttributeKindUWTable :: FunctionAttributeKind
functionAttributeKindUWTable :: FunctionAttributeKind
functionAttributeKindUWTable = CUInt -> FunctionAttributeKind
FunctionAttributeKind CUInt
60
functionAttributeKindWillReturn :: FunctionAttributeKind
functionAttributeKindWillReturn :: FunctionAttributeKind
functionAttributeKindWillReturn = CUInt -> FunctionAttributeKind
FunctionAttributeKind CUInt
61
functionAttributeKindWriteOnly :: FunctionAttributeKind
functionAttributeKindWriteOnly :: FunctionAttributeKind
functionAttributeKindWriteOnly = CUInt -> FunctionAttributeKind
FunctionAttributeKind CUInt
62
functionAttributeKindMustProgress :: FunctionAttributeKind
functionAttributeKindMustProgress :: FunctionAttributeKind
functionAttributeKindMustProgress = CUInt -> FunctionAttributeKind
FunctionAttributeKind CUInt
66
functionAttributeKindPreallocated :: FunctionAttributeKind
functionAttributeKindPreallocated :: FunctionAttributeKind
functionAttributeKindPreallocated = CUInt -> FunctionAttributeKind
FunctionAttributeKind CUInt
67
functionAttributeKindAllocSize :: FunctionAttributeKind
functionAttributeKindAllocSize :: FunctionAttributeKind
functionAttributeKindAllocSize = CUInt -> FunctionAttributeKind
FunctionAttributeKind CUInt
70
functionAttributeKindStackAlignment :: FunctionAttributeKind
functionAttributeKindStackAlignment :: FunctionAttributeKind
functionAttributeKindStackAlignment = CUInt -> FunctionAttributeKind
FunctionAttributeKind CUInt
73
functionAttributeKindP :: QuasiQuoter
functionAttributeKindP :: QuasiQuoter
functionAttributeKindP = QuasiQuoter {
  quoteExp = undefined,
  quotePat :: String -> Q Pat
quotePat = \String
s -> (forall b. Data b => b -> Maybe (Q Pat))
-> FunctionAttributeKind -> Q Pat
forall (m :: * -> *) a.
(Quote m, Data a) =>
(forall b. Data b => b -> Maybe (m Pat)) -> a -> m Pat
dataToPatQ (Maybe (Q Pat) -> b -> Maybe (Q Pat)
forall a b. a -> b -> a
const Maybe (Q Pat)
forall a. Maybe a
Nothing) (FunctionAttributeKind -> Q Pat) -> FunctionAttributeKind -> Q Pat
forall a b. (a -> b) -> a -> b
$ case String
s of
    String
"AlwaysInline" -> FunctionAttributeKind
functionAttributeKindAlwaysInline
    String
"ArgMemOnly" -> FunctionAttributeKind
functionAttributeKindArgMemOnly
    String
"Builtin" -> FunctionAttributeKind
functionAttributeKindBuiltin
    String
"Cold" -> FunctionAttributeKind
functionAttributeKindCold
    String
"Convergent" -> FunctionAttributeKind
functionAttributeKindConvergent
    String
"Hot" -> FunctionAttributeKind
functionAttributeKindHot
    String
"InaccessibleMemOnly" -> FunctionAttributeKind
functionAttributeKindInaccessibleMemOnly
    String
"InaccessibleMemOrArgMemOnly" -> FunctionAttributeKind
functionAttributeKindInaccessibleMemOrArgMemOnly
    String
"InlineHint" -> FunctionAttributeKind
functionAttributeKindInlineHint
    String
"JumpTable" -> FunctionAttributeKind
functionAttributeKindJumpTable
    String
"MinSize" -> FunctionAttributeKind
functionAttributeKindMinSize
    String
"Naked" -> FunctionAttributeKind
functionAttributeKindNaked
    String
"NoBuiltin" -> FunctionAttributeKind
functionAttributeKindNoBuiltin
    String
"NoCallback" -> FunctionAttributeKind
functionAttributeKindNoCallback
    String
"NoCfCheck" -> FunctionAttributeKind
functionAttributeKindNoCfCheck
    String
"NoDuplicate" -> FunctionAttributeKind
functionAttributeKindNoDuplicate
    String
"NoFree" -> FunctionAttributeKind
functionAttributeKindNoFree
    String
"NoImplicitFloat" -> FunctionAttributeKind
functionAttributeKindNoImplicitFloat
    String
"NoInline" -> FunctionAttributeKind
functionAttributeKindNoInline
    String
"NoMerge" -> FunctionAttributeKind
functionAttributeKindNoMerge
    String
"NoProfile" -> FunctionAttributeKind
functionAttributeKindNoProfile
    String
"NoRecurse" -> FunctionAttributeKind
functionAttributeKindNoRecurse
    String
"NoRedZone" -> FunctionAttributeKind
functionAttributeKindNoRedZone
    String
"NoReturn" -> FunctionAttributeKind
functionAttributeKindNoReturn
    String
"NoSync" -> FunctionAttributeKind
functionAttributeKindNoSync
    String
"NoUndef" -> FunctionAttributeKind
functionAttributeKindNoUndef
    String
"NoUnwind" -> FunctionAttributeKind
functionAttributeKindNoUnwind
    String
"NonLazyBind" -> FunctionAttributeKind
functionAttributeKindNonLazyBind
    String
"OptForFuzzing" -> FunctionAttributeKind
functionAttributeKindOptForFuzzing
    String
"OptimizeForSize" -> FunctionAttributeKind
functionAttributeKindOptimizeForSize
    String
"OptimizeNone" -> FunctionAttributeKind
functionAttributeKindOptimizeNone
    String
"ReadNone" -> FunctionAttributeKind
functionAttributeKindReadNone
    String
"ReadOnly" -> FunctionAttributeKind
functionAttributeKindReadOnly
    String
"ReturnsTwice" -> FunctionAttributeKind
functionAttributeKindReturnsTwice
    String
"SafeStack" -> FunctionAttributeKind
functionAttributeKindSafeStack
    String
"SanitizeAddress" -> FunctionAttributeKind
functionAttributeKindSanitizeAddress
    String
"SanitizeHWAddress" -> FunctionAttributeKind
functionAttributeKindSanitizeHWAddress
    String
"SanitizeMemTag" -> FunctionAttributeKind
functionAttributeKindSanitizeMemTag
    String
"SanitizeMemory" -> FunctionAttributeKind
functionAttributeKindSanitizeMemory
    String
"SanitizeThread" -> FunctionAttributeKind
functionAttributeKindSanitizeThread
    String
"ShadowCallStack" -> FunctionAttributeKind
functionAttributeKindShadowCallStack
    String
"Speculatable" -> FunctionAttributeKind
functionAttributeKindSpeculatable
    String
"SpeculativeLoadHardening" -> FunctionAttributeKind
functionAttributeKindSpeculativeLoadHardening
    String
"StackProtect" -> FunctionAttributeKind
functionAttributeKindStackProtect
    String
"StackProtectReq" -> FunctionAttributeKind
functionAttributeKindStackProtectReq
    String
"StackProtectStrong" -> FunctionAttributeKind
functionAttributeKindStackProtectStrong
    String
"StrictFP" -> FunctionAttributeKind
functionAttributeKindStrictFP
    String
"UWTable" -> FunctionAttributeKind
functionAttributeKindUWTable
    String
"WillReturn" -> FunctionAttributeKind
functionAttributeKindWillReturn
    String
"WriteOnly" -> FunctionAttributeKind
functionAttributeKindWriteOnly
    String
"MustProgress" -> FunctionAttributeKind
functionAttributeKindMustProgress
    String
"Preallocated" -> FunctionAttributeKind
functionAttributeKindPreallocated
    String
"AllocSize" -> FunctionAttributeKind
functionAttributeKindAllocSize
    String
"StackAlignment" -> FunctionAttributeKind
functionAttributeKindStackAlignment
    String
x -> String -> FunctionAttributeKind
forall a. HasCallStack => String -> a
error (String -> FunctionAttributeKind)
-> String -> FunctionAttributeKind
forall a b. (a -> b) -> a -> b
$ String
"bad quasiquoted FFI constant for functionAttributeKind: " String -> ShowS
forall a. [a] -> [a] -> [a]
++ String
x,
  quoteType = undefined,
  quoteDec = undefined
 }

{-# LINE 325 "src/LLVM/Internal/FFI/LLVMCTypes.hsc" #-}

newtype FloatSemantics = FloatSemantics CUInt
  deriving (Eq, Read, Show, Typeable, Data, Generic)

floatSemanticsIEEEhalf :: FloatSemantics
floatSemanticsIEEEhalf = FloatSemantics 0
floatSemanticsIEEEsingle :: FloatSemantics
floatSemanticsIEEEsingle = FloatSemantics 1
floatSemanticsIEEEdouble :: FloatSemantics
floatSemanticsIEEEdouble = FloatSemantics 2
floatSemanticsIEEEquad :: FloatSemantics
floatSemanticsIEEEquad = FloatSemantics 3
floatSemanticsPPCDoubleDouble :: FloatSemantics
floatSemanticsPPCDoubleDouble = FloatSemantics 4
floatSemanticsx87DoubleExtended :: FloatSemantics
floatSemanticsx87DoubleExtended = FloatSemantics 5
floatSemanticsBogus :: FloatSemantics
floatSemanticsBogus = FloatSemantics 6
floatSemanticsP :: QuasiQuoter
floatSemanticsP = QuasiQuoter {
  quoteExp = undefined,
  quotePat = \s -> dataToPatQ (const Nothing) $ case s of
    "IEEEhalf" -> floatSemanticsIEEEhalf
    "IEEEsingle" -> floatSemanticsIEEEsingle
    "IEEEdouble" -> floatSemanticsIEEEdouble
    "IEEEquad" -> floatSemanticsIEEEquad
    "PPCDoubleDouble" -> floatSemanticsPPCDoubleDouble
    "x87DoubleExtended" -> floatSemanticsx87DoubleExtended
    "Bogus" -> floatSemanticsBogus
    x -> error $ "bad quasiquoted FFI constant for floatSemantics: " ++ x,
  quoteType = undefined,
  quoteDec = undefined
 }

{-# LINE 330 "src/LLVM/Internal/FFI/LLVMCTypes.hsc" #-}

newtype VerifierFailureAction = VerifierFailureAction CUInt
  deriving (Eq, Read, Show, Bits, Typeable, Data, Num, Generic)

verifierFailureActionAbortProcess :: VerifierFailureAction
verifierFailureActionAbortProcess = VerifierFailureAction 0
verifierFailureActionPrintMessage :: VerifierFailureAction
verifierFailureActionPrintMessage = VerifierFailureAction 1
verifierFailureActionReturnStatus :: VerifierFailureAction
verifierFailureActionReturnStatus = VerifierFailureAction 2
verifierFailureActionP :: QuasiQuoter
verifierFailureActionP = QuasiQuoter {
  quoteExp = undefined,
  quotePat = \s -> dataToPatQ (const Nothing) $ case s of
    "AbortProcess" -> verifierFailureActionAbortProcess
    "PrintMessage" -> verifierFailureActionPrintMessage
    "ReturnStatus" -> verifierFailureActionReturnStatus
    x -> error $ "bad quasiquoted FFI constant for verifierFailureAction: " ++ x,
  quoteType = undefined,
  quoteDec = undefined
 }

{-# LINE 335 "src/LLVM/Internal/FFI/LLVMCTypes.hsc" #-}

newtype LibFunc = LibFunc CUInt
  deriving (Eq, Read, Show, Bits, Typeable, Data, Num, Storable, Generic)

libFunc__under_IO_getc :: LibFunc
libFunc__under_IO_getc = LibFunc 0
libFunc__under_IO_putc :: LibFunc
libFunc__under_IO_putc = LibFunc 1
libFunc__ZdaPv :: LibFunc
libFunc__ZdaPv = LibFunc 2
libFunc__ZdaPvRKSt9nothrow_t :: LibFunc
libFunc__ZdaPvRKSt9nothrow_t = LibFunc 3
libFunc__ZdlPv :: LibFunc
libFunc__ZdlPv = LibFunc 4
libFunc__ZdlPvRKSt9nothrow_t :: LibFunc
libFunc__ZdlPvRKSt9nothrow_t = LibFunc 5
libFunc__Znaj :: LibFunc
libFunc__Znaj = LibFunc 6
libFunc__ZnajRKSt9nothrow_t :: LibFunc
libFunc__ZnajRKSt9nothrow_t = LibFunc 7
libFunc__Znam :: LibFunc
libFunc__Znam = LibFunc 8
libFunc__ZnamRKSt9nothrow_t :: LibFunc
libFunc__ZnamRKSt9nothrow_t = LibFunc 9
libFunc__Znwj :: LibFunc
libFunc__Znwj = LibFunc 10
libFunc__ZnwjRKSt9nothrow_t :: LibFunc
libFunc__ZnwjRKSt9nothrow_t = LibFunc 11
libFunc__Znwm :: LibFunc
libFunc__Znwm = LibFunc 12
libFunc__ZnwmRKSt9nothrow_t :: LibFunc
libFunc__ZnwmRKSt9nothrow_t = LibFunc 13
libFunc__cospi :: LibFunc
libFunc__cospi = LibFunc 14
libFunc__cospif :: LibFunc
libFunc__cospif = LibFunc 15
libFunc__cxa_atexit :: LibFunc
libFunc__cxa_atexit = LibFunc 16
libFunc__cxa_guard_abort :: LibFunc
libFunc__cxa_guard_abort = LibFunc 17
libFunc__cxa_guard_acquire :: LibFunc
libFunc__cxa_guard_acquire = LibFunc 18
libFunc__cxa_guard_release :: LibFunc
libFunc__cxa_guard_release = LibFunc 19
libFunc__dunder_isoc99_scanf :: LibFunc
libFunc__dunder_isoc99_scanf = LibFunc 20
libFunc__dunder_isoc99_sscanf :: LibFunc
libFunc__dunder_isoc99_sscanf = LibFunc 21
libFunc__memcpy_chk :: LibFunc
libFunc__memcpy_chk = LibFunc 22
libFunc__sincospi_stret :: LibFunc
libFunc__sincospi_stret = LibFunc 23
libFunc__sincospif_stret :: LibFunc
libFunc__sincospif_stret = LibFunc 24
libFunc__sinpi :: LibFunc
libFunc__sinpi = LibFunc 25
libFunc__sinpif :: LibFunc
libFunc__sinpif = LibFunc 26
libFunc__sqrt_finite :: LibFunc
libFunc__sqrt_finite = LibFunc 27
libFunc__sqrtf_finite :: LibFunc
libFunc__sqrtf_finite = LibFunc 28
libFunc__sqrtl_finite :: LibFunc
libFunc__sqrtl_finite = LibFunc 29
libFunc__dunder_strdup :: LibFunc
libFunc__dunder_strdup = LibFunc 30
libFunc__dunder_strndup :: LibFunc
libFunc__dunder_strndup = LibFunc 31
libFunc__dunder_strtok_r :: LibFunc
libFunc__dunder_strtok_r = LibFunc 32
libFunc__abs :: LibFunc
libFunc__abs = LibFunc 33
libFunc__access :: LibFunc
libFunc__access = LibFunc 34
libFunc__acos :: LibFunc
libFunc__acos = LibFunc 35
libFunc__acosf :: LibFunc
libFunc__acosf = LibFunc 36
libFunc__acosh :: LibFunc
libFunc__acosh = LibFunc 37
libFunc__acoshf :: LibFunc
libFunc__acoshf = LibFunc 38
libFunc__acoshl :: LibFunc
libFunc__acoshl = LibFunc 39
libFunc__acosl :: LibFunc
libFunc__acosl = LibFunc 40
libFunc__asin :: LibFunc
libFunc__asin = LibFunc 41
libFunc__asinf :: LibFunc
libFunc__asinf = LibFunc 42
libFunc__asinh :: LibFunc
libFunc__asinh = LibFunc 43
libFunc__asinhf :: LibFunc
libFunc__asinhf = LibFunc 44
libFunc__asinhl :: LibFunc
libFunc__asinhl = LibFunc 45
libFunc__asinl :: LibFunc
libFunc__asinl = LibFunc 46
libFunc__atan :: LibFunc
libFunc__atan = LibFunc 47
libFunc__atan2 :: LibFunc
libFunc__atan2 = LibFunc 48
libFunc__atan2f :: LibFunc
libFunc__atan2f = LibFunc 49
libFunc__atan2l :: LibFunc
libFunc__atan2l = LibFunc 50
libFunc__atanf :: LibFunc
libFunc__atanf = LibFunc 51
libFunc__atanh :: LibFunc
libFunc__atanh = LibFunc 52
libFunc__atanhf :: LibFunc
libFunc__atanhf = LibFunc 53
libFunc__atanhl :: LibFunc
libFunc__atanhl = LibFunc 54
libFunc__atanl :: LibFunc
libFunc__atanl = LibFunc 55
libFunc__atof :: LibFunc
libFunc__atof = LibFunc 56
libFunc__atoi :: LibFunc
libFunc__atoi = LibFunc 57
libFunc__atol :: LibFunc
libFunc__atol = LibFunc 58
libFunc__atoll :: LibFunc
libFunc__atoll = LibFunc 59
libFunc__bcmp :: LibFunc
libFunc__bcmp = LibFunc 60
libFunc__bcopy :: LibFunc
libFunc__bcopy = LibFunc 61
libFunc__bzero :: LibFunc
libFunc__bzero = LibFunc 62
libFunc__calloc :: LibFunc
libFunc__calloc = LibFunc 63
libFunc__cbrt :: LibFunc
libFunc__cbrt = LibFunc 64
libFunc__cbrtf :: LibFunc
libFunc__cbrtf = LibFunc 65
libFunc__cbrtl :: LibFunc
libFunc__cbrtl = LibFunc 66
libFunc__ceil :: LibFunc
libFunc__ceil = LibFunc 67
libFunc__ceilf :: LibFunc
libFunc__ceilf = LibFunc 68
libFunc__ceill :: LibFunc
libFunc__ceill = LibFunc 69
libFunc__chmod :: LibFunc
libFunc__chmod = LibFunc 70
libFunc__chown :: LibFunc
libFunc__chown = LibFunc 71
libFunc__clearerr :: LibFunc
libFunc__clearerr = LibFunc 72
libFunc__closedir :: LibFunc
libFunc__closedir = LibFunc 73
libFunc__copysign :: LibFunc
libFunc__copysign = LibFunc 74
libFunc__copysignf :: LibFunc
libFunc__copysignf = LibFunc 75
libFunc__copysignl :: LibFunc
libFunc__copysignl = LibFunc 76
libFunc__cos :: LibFunc
libFunc__cos = LibFunc 77
libFunc__cosf :: LibFunc
libFunc__cosf :: LibFunc
libFunc__cosf = CUInt -> LibFunc
LibFunc CUInt
78
libFunc__cosh :: LibFunc
libFunc__cosh :: LibFunc
libFunc__cosh = CUInt -> LibFunc
LibFunc CUInt
79
libFunc__coshf :: LibFunc
libFunc__coshf :: LibFunc
libFunc__coshf = CUInt -> LibFunc
LibFunc CUInt
80
libFunc__coshl :: LibFunc
libFunc__coshl :: LibFunc
libFunc__coshl = CUInt -> LibFunc
LibFunc CUInt
81
libFunc__cosl :: LibFunc
libFunc__cosl :: LibFunc
libFunc__cosl = CUInt -> LibFunc
LibFunc CUInt
82
libFunc__ctermid :: LibFunc
libFunc__ctermid :: LibFunc
libFunc__ctermid = CUInt -> LibFunc
LibFunc CUInt
83
libFunc__exp :: LibFunc
libFunc__exp :: LibFunc
libFunc__exp = CUInt -> LibFunc
LibFunc CUInt
84
libFunc__exp10 :: LibFunc
libFunc__exp10 :: LibFunc
libFunc__exp10 = CUInt -> LibFunc
LibFunc CUInt
85
libFunc__exp10f :: LibFunc
libFunc__exp10f :: LibFunc
libFunc__exp10f = CUInt -> LibFunc
LibFunc CUInt
86
libFunc__exp10l :: LibFunc
libFunc__exp10l :: LibFunc
libFunc__exp10l = CUInt -> LibFunc
LibFunc CUInt
87
libFunc__exp2 :: LibFunc
libFunc__exp2 :: LibFunc
libFunc__exp2 = CUInt -> LibFunc
LibFunc CUInt
88
libFunc__exp2f :: LibFunc
libFunc__exp2f :: LibFunc
libFunc__exp2f = CUInt -> LibFunc
LibFunc CUInt
89
libFunc__exp2l :: LibFunc
libFunc__exp2l :: LibFunc
libFunc__exp2l = CUInt -> LibFunc
LibFunc CUInt
90
libFunc__expf :: LibFunc
libFunc__expf :: LibFunc
libFunc__expf = CUInt -> LibFunc
LibFunc CUInt
91
libFunc__expl :: LibFunc
libFunc__expl :: LibFunc
libFunc__expl = CUInt -> LibFunc
LibFunc CUInt
92
libFunc__expm1 :: LibFunc
libFunc__expm1 :: LibFunc
libFunc__expm1 = CUInt -> LibFunc
LibFunc CUInt
93
libFunc__expm1f :: LibFunc
libFunc__expm1f :: LibFunc
libFunc__expm1f = CUInt -> LibFunc
LibFunc CUInt
94
libFunc__expm1l :: LibFunc
libFunc__expm1l :: LibFunc
libFunc__expm1l = CUInt -> LibFunc
LibFunc CUInt
95
libFunc__fabs :: LibFunc
libFunc__fabs :: LibFunc
libFunc__fabs = CUInt -> LibFunc
LibFunc CUInt
96
libFunc__fabsf :: LibFunc
libFunc__fabsf :: LibFunc
libFunc__fabsf = CUInt -> LibFunc
LibFunc CUInt
97
libFunc__fabsl :: LibFunc
libFunc__fabsl :: LibFunc
libFunc__fabsl = CUInt -> LibFunc
LibFunc CUInt
98
libFunc__fclose :: LibFunc
libFunc__fclose :: LibFunc
libFunc__fclose = CUInt -> LibFunc
LibFunc CUInt
99
libFunc__fdopen :: LibFunc
libFunc__fdopen :: LibFunc
libFunc__fdopen = CUInt -> LibFunc
LibFunc CUInt
100
libFunc__feof :: LibFunc
libFunc__feof :: LibFunc
libFunc__feof = CUInt -> LibFunc
LibFunc CUInt
101
libFunc__ferror :: LibFunc
libFunc__ferror :: LibFunc
libFunc__ferror = CUInt -> LibFunc
LibFunc CUInt
102
libFunc__fflush :: LibFunc
libFunc__fflush :: LibFunc
libFunc__fflush = CUInt -> LibFunc
LibFunc CUInt
103
libFunc__ffs :: LibFunc
libFunc__ffs :: LibFunc
libFunc__ffs = CUInt -> LibFunc
LibFunc CUInt
104
libFunc__ffsl :: LibFunc
libFunc__ffsl :: LibFunc
libFunc__ffsl = CUInt -> LibFunc
LibFunc CUInt
105
libFunc__ffsll :: LibFunc
libFunc__ffsll :: LibFunc
libFunc__ffsll = CUInt -> LibFunc
LibFunc CUInt
106
libFunc__fgetc :: LibFunc
libFunc__fgetc :: LibFunc
libFunc__fgetc = CUInt -> LibFunc
LibFunc CUInt
107
libFunc__fgetpos :: LibFunc
libFunc__fgetpos :: LibFunc
libFunc__fgetpos = CUInt -> LibFunc
LibFunc CUInt
108
libFunc__fgets :: LibFunc
libFunc__fgets :: LibFunc
libFunc__fgets = CUInt -> LibFunc
LibFunc CUInt
109
libFunc__fileno :: LibFunc
libFunc__fileno :: LibFunc
libFunc__fileno = CUInt -> LibFunc
LibFunc CUInt
110
libFunc__fiprintf :: LibFunc
libFunc__fiprintf :: LibFunc
libFunc__fiprintf = CUInt -> LibFunc
LibFunc CUInt
111
libFunc__flockfile :: LibFunc
libFunc__flockfile :: LibFunc
libFunc__flockfile = CUInt -> LibFunc
LibFunc CUInt
112
libFunc__floor :: LibFunc
libFunc__floor :: LibFunc
libFunc__floor = CUInt -> LibFunc
LibFunc CUInt
113
libFunc__floorf :: LibFunc
libFunc__floorf :: LibFunc
libFunc__floorf = CUInt -> LibFunc
LibFunc CUInt
114
libFunc__floorl :: LibFunc
libFunc__floorl :: LibFunc
libFunc__floorl = CUInt -> LibFunc
LibFunc CUInt
115
libFunc__fmax :: LibFunc
libFunc__fmax :: LibFunc
libFunc__fmax = CUInt -> LibFunc
LibFunc CUInt
116
libFunc__fmaxf :: LibFunc
libFunc__fmaxf :: LibFunc
libFunc__fmaxf = CUInt -> LibFunc
LibFunc CUInt
117
libFunc__fmaxl :: LibFunc
libFunc__fmaxl :: LibFunc
libFunc__fmaxl = CUInt -> LibFunc
LibFunc CUInt
118
libFunc__fmin :: LibFunc
libFunc__fmin :: LibFunc
libFunc__fmin = CUInt -> LibFunc
LibFunc CUInt
119
libFunc__fminf :: LibFunc
libFunc__fminf :: LibFunc
libFunc__fminf = CUInt -> LibFunc
LibFunc CUInt
120
libFunc__fminl :: LibFunc
libFunc__fminl :: LibFunc
libFunc__fminl = CUInt -> LibFunc
LibFunc CUInt
121
libFunc__fmod :: LibFunc
libFunc__fmod :: LibFunc
libFunc__fmod = CUInt -> LibFunc
LibFunc CUInt
122
libFunc__fmodf :: LibFunc
libFunc__fmodf :: LibFunc
libFunc__fmodf = CUInt -> LibFunc
LibFunc CUInt
123
libFunc__fmodl :: LibFunc
libFunc__fmodl :: LibFunc
libFunc__fmodl = CUInt -> LibFunc
LibFunc CUInt
124
libFunc__fopen :: LibFunc
libFunc__fopen :: LibFunc
libFunc__fopen = CUInt -> LibFunc
LibFunc CUInt
125
libFunc__fopen64 :: LibFunc
libFunc__fopen64 :: LibFunc
libFunc__fopen64 = CUInt -> LibFunc
LibFunc CUInt
126
libFunc__fprintf :: LibFunc
libFunc__fprintf :: LibFunc
libFunc__fprintf = CUInt -> LibFunc
LibFunc CUInt
127
libFunc__fputc :: LibFunc
libFunc__fputc :: LibFunc
libFunc__fputc = CUInt -> LibFunc
LibFunc CUInt
128
libFunc__fputs :: LibFunc
libFunc__fputs :: LibFunc
libFunc__fputs = CUInt -> LibFunc
LibFunc CUInt
129
libFunc__fread :: LibFunc
libFunc__fread :: LibFunc
libFunc__fread = CUInt -> LibFunc
LibFunc CUInt
130
libFunc__free :: LibFunc
libFunc__free :: LibFunc
libFunc__free = CUInt -> LibFunc
LibFunc CUInt
131
libFunc__frexp :: LibFunc
libFunc__frexp :: LibFunc
libFunc__frexp = CUInt -> LibFunc
LibFunc CUInt
132
libFunc__frexpf :: LibFunc
libFunc__frexpf :: LibFunc
libFunc__frexpf = CUInt -> LibFunc
LibFunc CUInt
133
libFunc__frexpl :: LibFunc
libFunc__frexpl :: LibFunc
libFunc__frexpl = CUInt -> LibFunc
LibFunc CUInt
134
libFunc__fscanf :: LibFunc
libFunc__fscanf :: LibFunc
libFunc__fscanf = CUInt -> LibFunc
LibFunc CUInt
135
libFunc__fseek :: LibFunc
libFunc__fseek :: LibFunc
libFunc__fseek = CUInt -> LibFunc
LibFunc CUInt
136
libFunc__fseeko :: LibFunc
libFunc__fseeko :: LibFunc
libFunc__fseeko = CUInt -> LibFunc
LibFunc CUInt
137
libFunc__fseeko64 :: LibFunc
libFunc__fseeko64 :: LibFunc
libFunc__fseeko64 = CUInt -> LibFunc
LibFunc CUInt
138
libFunc__fsetpos :: LibFunc
libFunc__fsetpos :: LibFunc
libFunc__fsetpos = CUInt -> LibFunc
LibFunc CUInt
139
libFunc__fstat :: LibFunc
libFunc__fstat :: LibFunc
libFunc__fstat = CUInt -> LibFunc
LibFunc CUInt
140
libFunc__fstat64 :: LibFunc
libFunc__fstat64 :: LibFunc
libFunc__fstat64 = CUInt -> LibFunc
LibFunc CUInt
141
libFunc__fstatvfs :: LibFunc
libFunc__fstatvfs :: LibFunc
libFunc__fstatvfs = CUInt -> LibFunc
LibFunc CUInt
142
libFunc__fstatvfs64 :: LibFunc
libFunc__fstatvfs64 :: LibFunc
libFunc__fstatvfs64 = CUInt -> LibFunc
LibFunc CUInt
143
libFunc__ftell :: LibFunc
libFunc__ftell :: LibFunc
libFunc__ftell = CUInt -> LibFunc
LibFunc CUInt
144
libFunc__ftello :: LibFunc
libFunc__ftello :: LibFunc
libFunc__ftello = CUInt -> LibFunc
LibFunc CUInt
145
libFunc__ftello64 :: LibFunc
libFunc__ftello64 :: LibFunc
libFunc__ftello64 = CUInt -> LibFunc
LibFunc CUInt
146
libFunc__ftrylockfile :: LibFunc
libFunc__ftrylockfile :: LibFunc
libFunc__ftrylockfile = CUInt -> LibFunc
LibFunc CUInt
147
libFunc__funlockfile :: LibFunc
libFunc__funlockfile :: LibFunc
libFunc__funlockfile = CUInt -> LibFunc
LibFunc CUInt
148
libFunc__fwrite :: LibFunc
libFunc__fwrite :: LibFunc
libFunc__fwrite = CUInt -> LibFunc
LibFunc CUInt
149
libFunc__getc :: LibFunc
libFunc__getc :: LibFunc
libFunc__getc = CUInt -> LibFunc
LibFunc CUInt
150
libFunc__getc_unlocked :: LibFunc
libFunc__getc_unlocked :: LibFunc
libFunc__getc_unlocked = CUInt -> LibFunc
LibFunc CUInt
151
libFunc__getchar :: LibFunc
libFunc__getchar :: LibFunc
libFunc__getchar = CUInt -> LibFunc
LibFunc CUInt
152
libFunc__getenv :: LibFunc
libFunc__getenv :: LibFunc
libFunc__getenv = CUInt -> LibFunc
LibFunc CUInt
153
libFunc__getitimer :: LibFunc
libFunc__getitimer :: LibFunc
libFunc__getitimer = CUInt -> LibFunc
LibFunc CUInt
154
libFunc__getlogin_r :: LibFunc
libFunc__getlogin_r :: LibFunc
libFunc__getlogin_r = CUInt -> LibFunc
LibFunc CUInt
155
libFunc__getpwnam :: LibFunc
libFunc__getpwnam :: LibFunc
libFunc__getpwnam = CUInt -> LibFunc
LibFunc CUInt
156
libFunc__gets :: LibFunc
libFunc__gets :: LibFunc
libFunc__gets = CUInt -> LibFunc
LibFunc CUInt
157
libFunc__gettimeofday :: LibFunc
libFunc__gettimeofday :: LibFunc
libFunc__gettimeofday = CUInt -> LibFunc
LibFunc CUInt
158
libFunc__htonl :: LibFunc
libFunc__htonl :: LibFunc
libFunc__htonl = CUInt -> LibFunc
LibFunc CUInt
159
libFunc__htons :: LibFunc
libFunc__htons :: LibFunc
libFunc__htons = CUInt -> LibFunc
LibFunc CUInt
160
libFunc__iprintf :: LibFunc
libFunc__iprintf :: LibFunc
libFunc__iprintf = CUInt -> LibFunc
LibFunc CUInt
161
libFunc__isascii :: LibFunc
libFunc__isascii :: LibFunc
libFunc__isascii = CUInt -> LibFunc
LibFunc CUInt
162
libFunc__isdigit :: LibFunc
libFunc__isdigit :: LibFunc
libFunc__isdigit = CUInt -> LibFunc
LibFunc CUInt
163
libFunc__labs :: LibFunc
libFunc__labs :: LibFunc
libFunc__labs = CUInt -> LibFunc
LibFunc CUInt
164
libFunc__lchown :: LibFunc
libFunc__lchown :: LibFunc
libFunc__lchown = CUInt -> LibFunc
LibFunc CUInt
165
libFunc__ldexp :: LibFunc
libFunc__ldexp :: LibFunc
libFunc__ldexp = CUInt -> LibFunc
LibFunc CUInt
166
libFunc__ldexpf :: LibFunc
libFunc__ldexpf :: LibFunc
libFunc__ldexpf = CUInt -> LibFunc
LibFunc CUInt
167
libFunc__ldexpl :: LibFunc
libFunc__ldexpl :: LibFunc
libFunc__ldexpl = CUInt -> LibFunc
LibFunc CUInt
168
libFunc__llabs :: LibFunc
libFunc__llabs :: LibFunc
libFunc__llabs = CUInt -> LibFunc
LibFunc CUInt
169
libFunc__log :: LibFunc
libFunc__log :: LibFunc
libFunc__log = CUInt -> LibFunc
LibFunc CUInt
170
libFunc__log10 :: LibFunc
libFunc__log10 :: LibFunc
libFunc__log10 = CUInt -> LibFunc
LibFunc CUInt
171
libFunc__log10f :: LibFunc
libFunc__log10f :: LibFunc
libFunc__log10f = CUInt -> LibFunc
LibFunc CUInt
172
libFunc__log10l :: LibFunc
libFunc__log10l :: LibFunc
libFunc__log10l = CUInt -> LibFunc
LibFunc CUInt
173
libFunc__log1p :: LibFunc
libFunc__log1p :: LibFunc
libFunc__log1p = CUInt -> LibFunc
LibFunc CUInt
174
libFunc__log1pf :: LibFunc
libFunc__log1pf :: LibFunc
libFunc__log1pf = CUInt -> LibFunc
LibFunc CUInt
175
libFunc__log1pl :: LibFunc
libFunc__log1pl :: LibFunc
libFunc__log1pl = CUInt -> LibFunc
LibFunc CUInt
176
libFunc__log2 :: LibFunc
libFunc__log2 :: LibFunc
libFunc__log2 = CUInt -> LibFunc
LibFunc CUInt
177
libFunc__log2f :: LibFunc
libFunc__log2f :: LibFunc
libFunc__log2f = CUInt -> LibFunc
LibFunc CUInt
178
libFunc__log2l :: LibFunc
libFunc__log2l :: LibFunc
libFunc__log2l = CUInt -> LibFunc
LibFunc CUInt
179
libFunc__logb :: LibFunc
libFunc__logb :: LibFunc
libFunc__logb = CUInt -> LibFunc
LibFunc CUInt
180
libFunc__logbf :: LibFunc
libFunc__logbf :: LibFunc
libFunc__logbf = CUInt -> LibFunc
LibFunc CUInt
181
libFunc__logbl :: LibFunc
libFunc__logbl :: LibFunc
libFunc__logbl = CUInt -> LibFunc
LibFunc CUInt
182
libFunc__logf :: LibFunc
libFunc__logf :: LibFunc
libFunc__logf = CUInt -> LibFunc
LibFunc CUInt
183
libFunc__logl :: LibFunc
libFunc__logl :: LibFunc
libFunc__logl = CUInt -> LibFunc
LibFunc CUInt
184
libFunc__lstat :: LibFunc
libFunc__lstat :: LibFunc
libFunc__lstat = CUInt -> LibFunc
LibFunc CUInt
185
libFunc__lstat64 :: LibFunc
libFunc__lstat64 :: LibFunc
libFunc__lstat64 = CUInt -> LibFunc
LibFunc CUInt
186
libFunc__malloc :: LibFunc
libFunc__malloc :: LibFunc
libFunc__malloc = CUInt -> LibFunc
LibFunc CUInt
187
libFunc__memalign :: LibFunc
libFunc__memalign :: LibFunc
libFunc__memalign = CUInt -> LibFunc
LibFunc CUInt
188
libFunc__memccpy :: LibFunc
libFunc__memccpy :: LibFunc
libFunc__memccpy = CUInt -> LibFunc
LibFunc CUInt
189
libFunc__memchr :: LibFunc
libFunc__memchr :: LibFunc
libFunc__memchr = CUInt -> LibFunc
LibFunc CUInt
190
libFunc__memcmp :: LibFunc
libFunc__memcmp :: LibFunc
libFunc__memcmp = CUInt -> LibFunc
LibFunc CUInt
191
libFunc__memcpy :: LibFunc
libFunc__memcpy :: LibFunc
libFunc__memcpy = CUInt -> LibFunc
LibFunc CUInt
192
libFunc__memmove :: LibFunc
libFunc__memmove :: LibFunc
libFunc__memmove = CUInt -> LibFunc
LibFunc CUInt
193
libFunc__memrchr :: LibFunc
libFunc__memrchr :: LibFunc
libFunc__memrchr = CUInt -> LibFunc
LibFunc CUInt
194
libFunc__memset :: LibFunc
libFunc__memset :: LibFunc
libFunc__memset = CUInt -> LibFunc
LibFunc CUInt
195
libFunc__memset_pattern16 :: LibFunc
libFunc__memset_pattern16 :: LibFunc
libFunc__memset_pattern16 = CUInt -> LibFunc
LibFunc CUInt
196
libFunc__mkdir :: LibFunc
libFunc__mkdir :: LibFunc
libFunc__mkdir = CUInt -> LibFunc
LibFunc CUInt
197
libFunc__mktime :: LibFunc
libFunc__mktime :: LibFunc
libFunc__mktime = CUInt -> LibFunc
LibFunc CUInt
198
libFunc__modf :: LibFunc
libFunc__modf :: LibFunc
libFunc__modf = CUInt -> LibFunc
LibFunc CUInt
199
libFunc__modff :: LibFunc
libFunc__modff :: LibFunc
libFunc__modff = CUInt -> LibFunc
LibFunc CUInt
200
libFunc__modfl :: LibFunc
libFunc__modfl :: LibFunc
libFunc__modfl = CUInt -> LibFunc
LibFunc CUInt
201
libFunc__nearbyint :: LibFunc
libFunc__nearbyint :: LibFunc
libFunc__nearbyint = CUInt -> LibFunc
LibFunc CUInt
202
libFunc__nearbyintf :: LibFunc
libFunc__nearbyintf :: LibFunc
libFunc__nearbyintf = CUInt -> LibFunc
LibFunc CUInt
203
libFunc__nearbyintl :: LibFunc
libFunc__nearbyintl :: LibFunc
libFunc__nearbyintl = CUInt -> LibFunc
LibFunc CUInt
204
libFunc__ntohl :: LibFunc
libFunc__ntohl :: LibFunc
libFunc__ntohl = CUInt -> LibFunc
LibFunc CUInt
205
libFunc__ntohs :: LibFunc
libFunc__ntohs :: LibFunc
libFunc__ntohs = CUInt -> LibFunc
LibFunc CUInt
206
libFunc__open :: LibFunc
libFunc__open :: LibFunc
libFunc__open = CUInt -> LibFunc
LibFunc CUInt
207
libFunc__open64 :: LibFunc
libFunc__open64 :: LibFunc
libFunc__open64 = CUInt -> LibFunc
LibFunc CUInt
208
libFunc__opendir :: LibFunc
libFunc__opendir :: LibFunc
libFunc__opendir = CUInt -> LibFunc
LibFunc CUInt
209
libFunc__pclose :: LibFunc
libFunc__pclose :: LibFunc
libFunc__pclose = CUInt -> LibFunc
LibFunc CUInt
210
libFunc__perror :: LibFunc
libFunc__perror :: LibFunc
libFunc__perror = CUInt -> LibFunc
LibFunc CUInt
211
libFunc__popen :: LibFunc
libFunc__popen :: LibFunc
libFunc__popen = CUInt -> LibFunc
LibFunc CUInt
212
libFunc__posix_memalign :: LibFunc
libFunc__posix_memalign :: LibFunc
libFunc__posix_memalign = CUInt -> LibFunc
LibFunc CUInt
213
libFunc__pow :: LibFunc
libFunc__pow :: LibFunc
libFunc__pow = CUInt -> LibFunc
LibFunc CUInt
214
libFunc__powf :: LibFunc
libFunc__powf :: LibFunc
libFunc__powf = CUInt -> LibFunc
LibFunc CUInt
215
libFunc__powl :: LibFunc
libFunc__powl :: LibFunc
libFunc__powl = CUInt -> LibFunc
LibFunc CUInt
216
libFunc__pread :: LibFunc
libFunc__pread :: LibFunc
libFunc__pread = CUInt -> LibFunc
LibFunc CUInt
217
libFunc__printf :: LibFunc
libFunc__printf :: LibFunc
libFunc__printf = CUInt -> LibFunc
LibFunc CUInt
218
libFunc__putc :: LibFunc
libFunc__putc :: LibFunc
libFunc__putc = CUInt -> LibFunc
LibFunc CUInt
219
libFunc__putchar :: LibFunc
libFunc__putchar :: LibFunc
libFunc__putchar = CUInt -> LibFunc
LibFunc CUInt
220
libFunc__puts :: LibFunc
libFunc__puts :: LibFunc
libFunc__puts = CUInt -> LibFunc
LibFunc CUInt
221
libFunc__pwrite :: LibFunc
libFunc__pwrite :: LibFunc
libFunc__pwrite = CUInt -> LibFunc
LibFunc CUInt
222
libFunc__qsort :: LibFunc
libFunc__qsort :: LibFunc
libFunc__qsort = CUInt -> LibFunc
LibFunc CUInt
223
libFunc__read :: LibFunc
libFunc__read :: LibFunc
libFunc__read = CUInt -> LibFunc
LibFunc CUInt
224
libFunc__readlink :: LibFunc
libFunc__readlink :: LibFunc
libFunc__readlink = CUInt -> LibFunc
LibFunc CUInt
225
libFunc__realloc :: LibFunc
libFunc__realloc :: LibFunc
libFunc__realloc = CUInt -> LibFunc
LibFunc CUInt
226
libFunc__reallocf :: LibFunc
libFunc__reallocf :: LibFunc
libFunc__reallocf = CUInt -> LibFunc
LibFunc CUInt
227
libFunc__realpath :: LibFunc
libFunc__realpath :: LibFunc
libFunc__realpath = CUInt -> LibFunc
LibFunc CUInt
228
libFunc__remove :: LibFunc
libFunc__remove :: LibFunc
libFunc__remove = CUInt -> LibFunc
LibFunc CUInt
229
libFunc__rename :: LibFunc
libFunc__rename :: LibFunc
libFunc__rename = CUInt -> LibFunc
LibFunc CUInt
230
libFunc__rewind :: LibFunc
libFunc__rewind :: LibFunc
libFunc__rewind = CUInt -> LibFunc
LibFunc CUInt
231
libFunc__rint :: LibFunc
libFunc__rint :: LibFunc
libFunc__rint = CUInt -> LibFunc
LibFunc CUInt
232
libFunc__rintf :: LibFunc
libFunc__rintf :: LibFunc
libFunc__rintf = CUInt -> LibFunc
LibFunc CUInt
233
libFunc__rintl :: LibFunc
libFunc__rintl :: LibFunc
libFunc__rintl = CUInt -> LibFunc
LibFunc CUInt
234
libFunc__rmdir :: LibFunc
libFunc__rmdir :: LibFunc
libFunc__rmdir = CUInt -> LibFunc
LibFunc CUInt
235
libFunc__round :: LibFunc
libFunc__round :: LibFunc
libFunc__round = CUInt -> LibFunc
LibFunc CUInt
236
libFunc__roundf :: LibFunc
libFunc__roundf :: LibFunc
libFunc__roundf = CUInt -> LibFunc
LibFunc CUInt
237
libFunc__roundl :: LibFunc
libFunc__roundl :: LibFunc
libFunc__roundl = CUInt -> LibFunc
LibFunc CUInt
238
libFunc__scanf :: LibFunc
libFunc__scanf :: LibFunc
libFunc__scanf = CUInt -> LibFunc
LibFunc CUInt
239
libFunc__setbuf :: LibFunc
libFunc__setbuf :: LibFunc
libFunc__setbuf = CUInt -> LibFunc
LibFunc CUInt
240
libFunc__setitimer :: LibFunc
libFunc__setitimer :: LibFunc
libFunc__setitimer = CUInt -> LibFunc
LibFunc CUInt
241
libFunc__setvbuf :: LibFunc
libFunc__setvbuf :: LibFunc
libFunc__setvbuf = CUInt -> LibFunc
LibFunc CUInt
242
libFunc__sin :: LibFunc
libFunc__sin :: LibFunc
libFunc__sin = CUInt -> LibFunc
LibFunc CUInt
243
libFunc__sinf :: LibFunc
libFunc__sinf :: LibFunc
libFunc__sinf = CUInt -> LibFunc
LibFunc CUInt
244
libFunc__sinh :: LibFunc
libFunc__sinh :: LibFunc
libFunc__sinh = CUInt -> LibFunc
LibFunc CUInt
245
libFunc__sinhf :: LibFunc
libFunc__sinhf :: LibFunc
libFunc__sinhf = CUInt -> LibFunc
LibFunc CUInt
246
libFunc__sinhl :: LibFunc
libFunc__sinhl :: LibFunc
libFunc__sinhl = CUInt -> LibFunc
LibFunc CUInt
247
libFunc__sinl :: LibFunc
libFunc__sinl :: LibFunc
libFunc__sinl = CUInt -> LibFunc
LibFunc CUInt
248
libFunc__siprintf :: LibFunc
libFunc__siprintf :: LibFunc
libFunc__siprintf = CUInt -> LibFunc
LibFunc CUInt
249
libFunc__snprintf :: LibFunc
libFunc__snprintf :: LibFunc
libFunc__snprintf = CUInt -> LibFunc
LibFunc CUInt
250
libFunc__sprintf :: LibFunc
libFunc__sprintf :: LibFunc
libFunc__sprintf = CUInt -> LibFunc
LibFunc CUInt
251
libFunc__sqrt :: LibFunc
libFunc__sqrt :: LibFunc
libFunc__sqrt = CUInt -> LibFunc
LibFunc CUInt
252
libFunc__sqrtf :: LibFunc
libFunc__sqrtf :: LibFunc
libFunc__sqrtf = CUInt -> LibFunc
LibFunc CUInt
253
libFunc__sqrtl :: LibFunc
libFunc__sqrtl :: LibFunc
libFunc__sqrtl = CUInt -> LibFunc
LibFunc CUInt
254
libFunc__sscanf :: LibFunc
libFunc__sscanf :: LibFunc
libFunc__sscanf = CUInt -> LibFunc
LibFunc CUInt
255
libFunc__stat :: LibFunc
libFunc__stat :: LibFunc
libFunc__stat = CUInt -> LibFunc
LibFunc CUInt
256
libFunc__stat64 :: LibFunc
libFunc__stat64 :: LibFunc
libFunc__stat64 = CUInt -> LibFunc
LibFunc CUInt
257
libFunc__statvfs :: LibFunc
libFunc__statvfs :: LibFunc
libFunc__statvfs = CUInt -> LibFunc
LibFunc CUInt
258
libFunc__statvfs64 :: LibFunc
libFunc__statvfs64 :: LibFunc
libFunc__statvfs64 = CUInt -> LibFunc
LibFunc CUInt
259
libFunc__stpcpy :: LibFunc
libFunc__stpcpy :: LibFunc
libFunc__stpcpy = CUInt -> LibFunc
LibFunc CUInt
260
libFunc__stpncpy :: LibFunc
libFunc__stpncpy :: LibFunc
libFunc__stpncpy = CUInt -> LibFunc
LibFunc CUInt
261
libFunc__strcasecmp :: LibFunc
libFunc__strcasecmp :: LibFunc
libFunc__strcasecmp = CUInt -> LibFunc
LibFunc CUInt
262
libFunc__strcat :: LibFunc
libFunc__strcat :: LibFunc
libFunc__strcat = CUInt -> LibFunc
LibFunc CUInt
263
libFunc__strchr :: LibFunc
libFunc__strchr :: LibFunc
libFunc__strchr = CUInt -> LibFunc
LibFunc CUInt
264
libFunc__strcmp :: LibFunc
libFunc__strcmp :: LibFunc
libFunc__strcmp = CUInt -> LibFunc
LibFunc CUInt
265
libFunc__strcoll :: LibFunc
libFunc__strcoll :: LibFunc
libFunc__strcoll = CUInt -> LibFunc
LibFunc CUInt
266
libFunc__strcpy :: LibFunc
libFunc__strcpy :: LibFunc
libFunc__strcpy = CUInt -> LibFunc
LibFunc CUInt
267
libFunc__strcspn :: LibFunc
libFunc__strcspn :: LibFunc
libFunc__strcspn = CUInt -> LibFunc
LibFunc CUInt
268
libFunc__strdup :: LibFunc
libFunc__strdup :: LibFunc
libFunc__strdup = CUInt -> LibFunc
LibFunc CUInt
269
libFunc__strlen :: LibFunc
libFunc__strlen :: LibFunc
libFunc__strlen = CUInt -> LibFunc
LibFunc CUInt
270
libFunc__strncasecmp :: LibFunc
libFunc__strncasecmp :: LibFunc
libFunc__strncasecmp = CUInt -> LibFunc
LibFunc CUInt
271
libFunc__strncat :: LibFunc
libFunc__strncat :: LibFunc
libFunc__strncat = CUInt -> LibFunc
LibFunc CUInt
272
libFunc__strncmp :: LibFunc
libFunc__strncmp :: LibFunc
libFunc__strncmp = CUInt -> LibFunc
LibFunc CUInt
273
libFunc__strncpy :: LibFunc
libFunc__strncpy :: LibFunc
libFunc__strncpy = CUInt -> LibFunc
LibFunc CUInt
274
libFunc__strndup :: LibFunc
libFunc__strndup :: LibFunc
libFunc__strndup = CUInt -> LibFunc
LibFunc CUInt
275
libFunc__strnlen :: LibFunc
libFunc__strnlen :: LibFunc
libFunc__strnlen = CUInt -> LibFunc
LibFunc CUInt
276
libFunc__strpbrk :: LibFunc
libFunc__strpbrk :: LibFunc
libFunc__strpbrk = CUInt -> LibFunc
LibFunc CUInt
277
libFunc__strrchr :: LibFunc
libFunc__strrchr :: LibFunc
libFunc__strrchr = CUInt -> LibFunc
LibFunc CUInt
278
libFunc__strspn :: LibFunc
libFunc__strspn :: LibFunc
libFunc__strspn = CUInt -> LibFunc
LibFunc CUInt
279
libFunc__strstr :: LibFunc
libFunc__strstr :: LibFunc
libFunc__strstr = CUInt -> LibFunc
LibFunc CUInt
280
libFunc__strtod :: LibFunc
libFunc__strtod :: LibFunc
libFunc__strtod = CUInt -> LibFunc
LibFunc CUInt
281
libFunc__strtof :: LibFunc
libFunc__strtof :: LibFunc
libFunc__strtof = CUInt -> LibFunc
LibFunc CUInt
282
libFunc__strtok :: LibFunc
libFunc__strtok :: LibFunc
libFunc__strtok = CUInt -> LibFunc
LibFunc CUInt
283
libFunc__strtok_r :: LibFunc
libFunc__strtok_r :: LibFunc
libFunc__strtok_r = CUInt -> LibFunc
LibFunc CUInt
284
libFunc__strtol :: LibFunc
libFunc__strtol :: LibFunc
libFunc__strtol = CUInt -> LibFunc
LibFunc CUInt
285
libFunc__strtold :: LibFunc
libFunc__strtold :: LibFunc
libFunc__strtold = CUInt -> LibFunc
LibFunc CUInt
286
libFunc__strtoll :: LibFunc
libFunc__strtoll :: LibFunc
libFunc__strtoll = CUInt -> LibFunc
LibFunc CUInt
287
libFunc__strtoul :: LibFunc
libFunc__strtoul :: LibFunc
libFunc__strtoul = CUInt -> LibFunc
LibFunc CUInt
288
libFunc__strtoull :: LibFunc
libFunc__strtoull :: LibFunc
libFunc__strtoull = CUInt -> LibFunc
LibFunc CUInt
289
libFunc__strxfrm :: LibFunc
libFunc__strxfrm :: LibFunc
libFunc__strxfrm = CUInt -> LibFunc
LibFunc CUInt
290
libFunc__system :: LibFunc
libFunc__system :: LibFunc
libFunc__system = CUInt -> LibFunc
LibFunc CUInt
291
libFunc__tan :: LibFunc
libFunc__tan :: LibFunc
libFunc__tan = CUInt -> LibFunc
LibFunc CUInt
292
libFunc__tanf :: LibFunc
libFunc__tanf :: LibFunc
libFunc__tanf = CUInt -> LibFunc
LibFunc CUInt
293
libFunc__tanh :: LibFunc
libFunc__tanh :: LibFunc
libFunc__tanh = CUInt -> LibFunc
LibFunc CUInt
294
libFunc__tanhf :: LibFunc
libFunc__tanhf :: LibFunc
libFunc__tanhf = CUInt -> LibFunc
LibFunc CUInt
295
libFunc__tanhl :: LibFunc
libFunc__tanhl :: LibFunc
libFunc__tanhl = CUInt -> LibFunc
LibFunc CUInt
296
libFunc__tanl :: LibFunc
libFunc__tanl :: LibFunc
libFunc__tanl = CUInt -> LibFunc
LibFunc CUInt
297
libFunc__times :: LibFunc
libFunc__times :: LibFunc
libFunc__times = CUInt -> LibFunc
LibFunc CUInt
298
libFunc__tmpfile :: LibFunc
libFunc__tmpfile :: LibFunc
libFunc__tmpfile = CUInt -> LibFunc
LibFunc CUInt
299
libFunc__tmpfile64 :: LibFunc
libFunc__tmpfile64 :: LibFunc
libFunc__tmpfile64 = CUInt -> LibFunc
LibFunc CUInt
300
libFunc__toascii :: LibFunc
libFunc__toascii :: LibFunc
libFunc__toascii = CUInt -> LibFunc
LibFunc CUInt
301
libFunc__trunc :: LibFunc
libFunc__trunc :: LibFunc
libFunc__trunc = CUInt -> LibFunc
LibFunc CUInt
302
libFunc__truncf :: LibFunc
libFunc__truncf :: LibFunc
libFunc__truncf = CUInt -> LibFunc
LibFunc CUInt
303
libFunc__truncl :: LibFunc
libFunc__truncl :: LibFunc
libFunc__truncl = CUInt -> LibFunc
LibFunc CUInt
304
libFunc__uname :: LibFunc
libFunc__uname :: LibFunc
libFunc__uname = CUInt -> LibFunc
LibFunc CUInt
305
libFunc__ungetc :: LibFunc
libFunc__ungetc :: LibFunc
libFunc__ungetc = CUInt -> LibFunc
LibFunc CUInt
306
libFunc__unlink :: LibFunc
libFunc__unlink :: LibFunc
libFunc__unlink = CUInt -> LibFunc
LibFunc CUInt
307
libFunc__unsetenv :: LibFunc
libFunc__unsetenv :: LibFunc
libFunc__unsetenv = CUInt -> LibFunc
LibFunc CUInt
308
libFunc__utime :: LibFunc
libFunc__utime :: LibFunc
libFunc__utime = CUInt -> LibFunc
LibFunc CUInt
309
libFunc__utimes :: LibFunc
libFunc__utimes :: LibFunc
libFunc__utimes = CUInt -> LibFunc
LibFunc CUInt
310
libFunc__valloc :: LibFunc
libFunc__valloc :: LibFunc
libFunc__valloc = CUInt -> LibFunc
LibFunc CUInt
311
libFunc__vfprintf :: LibFunc
libFunc__vfprintf :: LibFunc
libFunc__vfprintf = CUInt -> LibFunc
LibFunc CUInt
312
libFunc__vfscanf :: LibFunc
libFunc__vfscanf :: LibFunc
libFunc__vfscanf = CUInt -> LibFunc
LibFunc CUInt
313
libFunc__vprintf :: LibFunc
libFunc__vprintf :: LibFunc
libFunc__vprintf = CUInt -> LibFunc
LibFunc CUInt
314
libFunc__vscanf :: LibFunc
libFunc__vscanf :: LibFunc
libFunc__vscanf = CUInt -> LibFunc
LibFunc CUInt
315
libFunc__vsnprintf :: LibFunc
libFunc__vsnprintf :: LibFunc
libFunc__vsnprintf = CUInt -> LibFunc
LibFunc CUInt
316
libFunc__vsprintf :: LibFunc
libFunc__vsprintf :: LibFunc
libFunc__vsprintf = CUInt -> LibFunc
LibFunc CUInt
317
libFunc__vsscanf :: LibFunc
libFunc__vsscanf :: LibFunc
libFunc__vsscanf = CUInt -> LibFunc
LibFunc CUInt
318
libFunc__write :: LibFunc
libFunc__write :: LibFunc
libFunc__write = CUInt -> LibFunc
LibFunc CUInt
319
libFunc__P :: QuasiQuoter
libFunc__P :: QuasiQuoter
libFunc__P = QuasiQuoter {
  quoteExp :: String -> Q Exp
quoteExp = String -> Q Exp
forall a. HasCallStack => a
undefined,
  quotePat :: String -> Q Pat
quotePat = \String
s -> (forall b. Data b => b -> Maybe (Q Pat)) -> LibFunc -> Q Pat
forall (m :: * -> *) a.
(Quote m, Data a) =>
(forall b. Data b => b -> Maybe (m Pat)) -> a -> m Pat
dataToPatQ (Maybe (Q Pat) -> b -> Maybe (Q Pat)
forall a b. a -> b -> a
const Maybe (Q Pat)
forall a. Maybe a
Nothing) (LibFunc -> Q Pat) -> LibFunc -> Q Pat
forall a b. (a -> b) -> a -> b
$ case String
s of
    String
"under_IO_getc" -> LibFunc
libFunc__under_IO_getc
    String
"under_IO_putc" -> LibFunc
libFunc__under_IO_putc
    String
"ZdaPv" -> LibFunc
libFunc__ZdaPv
    String
"ZdaPvRKSt9nothrow_t" -> LibFunc
libFunc__ZdaPvRKSt9nothrow_t
    String
"ZdlPv" -> LibFunc
libFunc__ZdlPv
    String
"ZdlPvRKSt9nothrow_t" -> LibFunc
libFunc__ZdlPvRKSt9nothrow_t
    String
"Znaj" -> LibFunc
libFunc__Znaj
    String
"ZnajRKSt9nothrow_t" -> LibFunc
libFunc__ZnajRKSt9nothrow_t
    String
"Znam" -> LibFunc
libFunc__Znam
    String
"ZnamRKSt9nothrow_t" -> LibFunc
libFunc__ZnamRKSt9nothrow_t
    String
"Znwj" -> LibFunc
libFunc__Znwj
    String
"ZnwjRKSt9nothrow_t" -> LibFunc
libFunc__ZnwjRKSt9nothrow_t
    String
"Znwm" -> LibFunc
libFunc__Znwm
    String
"ZnwmRKSt9nothrow_t" -> LibFunc
libFunc__ZnwmRKSt9nothrow_t
    String
"cospi" -> LibFunc
libFunc__cospi
    String
"cospif" -> LibFunc
libFunc__cospif
    String
"cxa_atexit" -> LibFunc
libFunc__cxa_atexit
    String
"cxa_guard_abort" -> LibFunc
libFunc__cxa_guard_abort
    String
"cxa_guard_acquire" -> LibFunc
libFunc__cxa_guard_acquire
    String
"cxa_guard_release" -> LibFunc
libFunc__cxa_guard_release
    String
"dunder_isoc99_scanf" -> LibFunc
libFunc__dunder_isoc99_scanf
    String
"dunder_isoc99_sscanf" -> LibFunc
libFunc__dunder_isoc99_sscanf
    String
"memcpy_chk" -> LibFunc
libFunc__memcpy_chk
    String
"sincospi_stret" -> LibFunc
libFunc__sincospi_stret
    String
"sincospif_stret" -> LibFunc
libFunc__sincospif_stret
    String
"sinpi" -> LibFunc
libFunc__sinpi
    String
"sinpif" -> LibFunc
libFunc__sinpif
    String
"sqrt_finite" -> LibFunc
libFunc__sqrt_finite
    String
"sqrtf_finite" -> LibFunc
libFunc__sqrtf_finite
    String
"sqrtl_finite" -> LibFunc
libFunc__sqrtl_finite
    String
"dunder_strdup" -> LibFunc
libFunc__dunder_strdup
    String
"dunder_strndup" -> LibFunc
libFunc__dunder_strndup
    String
"dunder_strtok_r" -> LibFunc
libFunc__dunder_strtok_r
    String
"abs" -> LibFunc
libFunc__abs
    String
"access" -> LibFunc
libFunc__access
    String
"acos" -> LibFunc
libFunc__acos
    String
"acosf" -> LibFunc
libFunc__acosf
    String
"acosh" -> LibFunc
libFunc__acosh
    String
"acoshf" -> LibFunc
libFunc__acoshf
    String
"acoshl" -> LibFunc
libFunc__acoshl
    String
"acosl" -> LibFunc
libFunc__acosl
    String
"asin" -> LibFunc
libFunc__asin
    String
"asinf" -> LibFunc
libFunc__asinf
    String
"asinh" -> LibFunc
libFunc__asinh
    String
"asinhf" -> LibFunc
libFunc__asinhf
    String
"asinhl" -> LibFunc
libFunc__asinhl
    String
"asinl" -> LibFunc
libFunc__asinl
    String
"atan" -> LibFunc
libFunc__atan
    String
"atan2" -> LibFunc
libFunc__atan2
    String
"atan2f" -> LibFunc
libFunc__atan2f
    String
"atan2l" -> LibFunc
libFunc__atan2l
    String
"atanf" -> LibFunc
libFunc__atanf
    String
"atanh" -> LibFunc
libFunc__atanh
    String
"atanhf" -> LibFunc
libFunc__atanhf
    String
"atanhl" -> LibFunc
libFunc__atanhl
    String
"atanl" -> LibFunc
libFunc__atanl
    String
"atof" -> LibFunc
libFunc__atof
    String
"atoi" -> LibFunc
libFunc__atoi
    String
"atol" -> LibFunc
libFunc__atol
    String
"atoll" -> LibFunc
libFunc__atoll
    String
"bcmp" -> LibFunc
libFunc__bcmp
    String
"bcopy" -> LibFunc
libFunc__bcopy
    String
"bzero" -> LibFunc
libFunc__bzero
    String
"calloc" -> LibFunc
libFunc__calloc
    String
"cbrt" -> LibFunc
libFunc__cbrt
    String
"cbrtf" -> LibFunc
libFunc__cbrtf
    String
"cbrtl" -> LibFunc
libFunc__cbrtl
    String
"ceil" -> LibFunc
libFunc__ceil
    String
"ceilf" -> LibFunc
libFunc__ceilf
    String
"ceill" -> LibFunc
libFunc__ceill
    String
"chmod" -> LibFunc
libFunc__chmod
    String
"chown" -> LibFunc
libFunc__chown
    String
"clearerr" -> LibFunc
libFunc__clearerr
    String
"closedir" -> LibFunc
libFunc__closedir
    String
"copysign" -> LibFunc
libFunc__copysign
    String
"copysignf" -> LibFunc
libFunc__copysignf
    String
"copysignl" -> LibFunc
libFunc__copysignl
    String
"cos" -> LibFunc
libFunc__cos
    String
"cosf" -> LibFunc
libFunc__cosf
    String
"cosh" -> LibFunc
libFunc__cosh
    String
"coshf" -> LibFunc
libFunc__coshf
    String
"coshl" -> LibFunc
libFunc__coshl
    String
"cosl" -> LibFunc
libFunc__cosl
    String
"ctermid" -> LibFunc
libFunc__ctermid
    String
"exp" -> LibFunc
libFunc__exp
    String
"exp10" -> LibFunc
libFunc__exp10
    String
"exp10f" -> LibFunc
libFunc__exp10f
    String
"exp10l" -> LibFunc
libFunc__exp10l
    String
"exp2" -> LibFunc
libFunc__exp2
    String
"exp2f" -> LibFunc
libFunc__exp2f
    String
"exp2l" -> LibFunc
libFunc__exp2l
    String
"expf" -> LibFunc
libFunc__expf
    String
"expl" -> LibFunc
libFunc__expl
    String
"expm1" -> LibFunc
libFunc__expm1
    String
"expm1f" -> LibFunc
libFunc__expm1f
    String
"expm1l" -> LibFunc
libFunc__expm1l
    String
"fabs" -> LibFunc
libFunc__fabs
    String
"fabsf" -> LibFunc
libFunc__fabsf
    String
"fabsl" -> LibFunc
libFunc__fabsl
    String
"fclose" -> LibFunc
libFunc__fclose
    String
"fdopen" -> LibFunc
libFunc__fdopen
    String
"feof" -> LibFunc
libFunc__feof
    String
"ferror" -> LibFunc
libFunc__ferror
    String
"fflush" -> LibFunc
libFunc__fflush
    String
"ffs" -> LibFunc
libFunc__ffs
    String
"ffsl" -> LibFunc
libFunc__ffsl
    String
"ffsll" -> LibFunc
libFunc__ffsll
    String
"fgetc" -> LibFunc
libFunc__fgetc
    String
"fgetpos" -> LibFunc
libFunc__fgetpos
    String
"fgets" -> LibFunc
libFunc__fgets
    String
"fileno" -> LibFunc
libFunc__fileno
    String
"fiprintf" -> LibFunc
libFunc__fiprintf
    String
"flockfile" -> LibFunc
libFunc__flockfile
    String
"floor" -> LibFunc
libFunc__floor
    String
"floorf" -> LibFunc
libFunc__floorf
    String
"floorl" -> LibFunc
libFunc__floorl
    String
"fmax" -> LibFunc
libFunc__fmax
    String
"fmaxf" -> LibFunc
libFunc__fmaxf
    String
"fmaxl" -> LibFunc
libFunc__fmaxl
    String
"fmin" -> LibFunc
libFunc__fmin
    String
"fminf" -> LibFunc
libFunc__fminf
    String
"fminl" -> LibFunc
libFunc__fminl
    String
"fmod" -> LibFunc
libFunc__fmod
    String
"fmodf" -> LibFunc
libFunc__fmodf
    String
"fmodl" -> LibFunc
libFunc__fmodl
    String
"fopen" -> LibFunc
libFunc__fopen
    String
"fopen64" -> LibFunc
libFunc__fopen64
    String
"fprintf" -> LibFunc
libFunc__fprintf
    String
"fputc" -> LibFunc
libFunc__fputc
    String
"fputs" -> LibFunc
libFunc__fputs
    String
"fread" -> LibFunc
libFunc__fread
    String
"free" -> LibFunc
libFunc__free
    String
"frexp" -> LibFunc
libFunc__frexp
    String
"frexpf" -> LibFunc
libFunc__frexpf
    String
"frexpl" -> LibFunc
libFunc__frexpl
    String
"fscanf" -> LibFunc
libFunc__fscanf
    String
"fseek" -> LibFunc
libFunc__fseek
    String
"fseeko" -> LibFunc
libFunc__fseeko
    String
"fseeko64" -> LibFunc
libFunc__fseeko64
    String
"fsetpos" -> LibFunc
libFunc__fsetpos
    String
"fstat" -> LibFunc
libFunc__fstat
    String
"fstat64" -> LibFunc
libFunc__fstat64
    String
"fstatvfs" -> LibFunc
libFunc__fstatvfs
    String
"fstatvfs64" -> LibFunc
libFunc__fstatvfs64
    String
"ftell" -> LibFunc
libFunc__ftell
    String
"ftello" -> LibFunc
libFunc__ftello
    String
"ftello64" -> LibFunc
libFunc__ftello64
    String
"ftrylockfile" -> LibFunc
libFunc__ftrylockfile
    String
"funlockfile" -> LibFunc
libFunc__funlockfile
    String
"fwrite" -> LibFunc
libFunc__fwrite
    String
"getc" -> LibFunc
libFunc__getc
    String
"getc_unlocked" -> LibFunc
libFunc__getc_unlocked
    String
"getchar" -> LibFunc
libFunc__getchar
    String
"getenv" -> LibFunc
libFunc__getenv
    String
"getitimer" -> LibFunc
libFunc__getitimer
    String
"getlogin_r" -> LibFunc
libFunc__getlogin_r
    String
"getpwnam" -> LibFunc
libFunc__getpwnam
    String
"gets" -> LibFunc
libFunc__gets
    String
"gettimeofday" -> LibFunc
libFunc__gettimeofday
    String
"htonl" -> LibFunc
libFunc__htonl
    String
"htons" -> LibFunc
libFunc__htons
    String
"iprintf" -> LibFunc
libFunc__iprintf
    String
"isascii" -> LibFunc
libFunc__isascii
    String
"isdigit" -> LibFunc
libFunc__isdigit
    String
"labs" -> LibFunc
libFunc__labs
    String
"lchown" -> LibFunc
libFunc__lchown
    String
"ldexp" -> LibFunc
libFunc__ldexp
    String
"ldexpf" -> LibFunc
libFunc__ldexpf
    String
"ldexpl" -> LibFunc
libFunc__ldexpl
    String
"llabs" -> LibFunc
libFunc__llabs
    String
"log" -> LibFunc
libFunc__log
    String
"log10" -> LibFunc
libFunc__log10
    String
"log10f" -> LibFunc
libFunc__log10f
    String
"log10l" -> LibFunc
libFunc__log10l
    String
"log1p" -> LibFunc
libFunc__log1p
    String
"log1pf" -> LibFunc
libFunc__log1pf
    String
"log1pl" -> LibFunc
libFunc__log1pl
    String
"log2" -> LibFunc
libFunc__log2
    String
"log2f" -> LibFunc
libFunc__log2f
    String
"log2l" -> LibFunc
libFunc__log2l
    String
"logb" -> LibFunc
libFunc__logb
    String
"logbf" -> LibFunc
libFunc__logbf
    String
"logbl" -> LibFunc
libFunc__logbl
    String
"logf" -> LibFunc
libFunc__logf
    String
"logl" -> LibFunc
libFunc__logl
    String
"lstat" -> LibFunc
libFunc__lstat
    String
"lstat64" -> LibFunc
libFunc__lstat64
    String
"malloc" -> LibFunc
libFunc__malloc
    String
"memalign" -> LibFunc
libFunc__memalign
    String
"memccpy" -> LibFunc
libFunc__memccpy
    String
"memchr" -> LibFunc
libFunc__memchr
    String
"memcmp" -> LibFunc
libFunc__memcmp
    String
"memcpy" -> LibFunc
libFunc__memcpy
    String
"memmove" -> LibFunc
libFunc__memmove
    String
"memrchr" -> LibFunc
libFunc__memrchr
    String
"memset" -> LibFunc
libFunc__memset
    String
"memset_pattern16" -> LibFunc
libFunc__memset_pattern16
    String
"mkdir" -> LibFunc
libFunc__mkdir
    String
"mktime" -> LibFunc
libFunc__mktime
    String
"modf" -> LibFunc
libFunc__modf
    String
"modff" -> LibFunc
libFunc__modff
    String
"modfl" -> LibFunc
libFunc__modfl
    String
"nearbyint" -> LibFunc
libFunc__nearbyint
    String
"nearbyintf" -> LibFunc
libFunc__nearbyintf
    String
"nearbyintl" -> LibFunc
libFunc__nearbyintl
    String
"ntohl" -> LibFunc
libFunc__ntohl
    String
"ntohs" -> LibFunc
libFunc__ntohs
    String
"open" -> LibFunc
libFunc__open
    String
"open64" -> LibFunc
libFunc__open64
    String
"opendir" -> LibFunc
libFunc__opendir
    String
"pclose" -> LibFunc
libFunc__pclose
    String
"perror" -> LibFunc
libFunc__perror
    String
"popen" -> LibFunc
libFunc__popen
    String
"posix_memalign" -> LibFunc
libFunc__posix_memalign
    String
"pow" -> LibFunc
libFunc__pow
    String
"powf" -> LibFunc
libFunc__powf
    String
"powl" -> LibFunc
libFunc__powl
    String
"pread" -> LibFunc
libFunc__pread
    String
"printf" -> LibFunc
libFunc__printf
    String
"putc" -> LibFunc
libFunc__putc
    String
"putchar" -> LibFunc
libFunc__putchar
    String
"puts" -> LibFunc
libFunc__puts
    String
"pwrite" -> LibFunc
libFunc__pwrite
    String
"qsort" -> LibFunc
libFunc__qsort
    String
"read" -> LibFunc
libFunc__read
    String
"readlink" -> LibFunc
libFunc__readlink
    String
"realloc" -> LibFunc
libFunc__realloc
    String
"reallocf" -> LibFunc
libFunc__reallocf
    String
"realpath" -> LibFunc
libFunc__realpath
    String
"remove" -> LibFunc
libFunc__remove
    String
"rename" -> LibFunc
libFunc__rename
    String
"rewind" -> LibFunc
libFunc__rewind
    String
"rint" -> LibFunc
libFunc__rint
    String
"rintf" -> LibFunc
libFunc__rintf
    String
"rintl" -> LibFunc
libFunc__rintl
    String
"rmdir" -> LibFunc
libFunc__rmdir
    String
"round" -> LibFunc
libFunc__round
    String
"roundf" -> LibFunc
libFunc__roundf
    String
"roundl" -> LibFunc
libFunc__roundl
    String
"scanf" -> LibFunc
libFunc__scanf
    String
"setbuf" -> LibFunc
libFunc__setbuf
    String
"setitimer" -> LibFunc
libFunc__setitimer
    String
"setvbuf" -> LibFunc
libFunc__setvbuf
    String
"sin" -> LibFunc
libFunc__sin
    String
"sinf" -> LibFunc
libFunc__sinf
    String
"sinh" -> LibFunc
libFunc__sinh
    String
"sinhf" -> LibFunc
libFunc__sinhf
    String
"sinhl" -> LibFunc
libFunc__sinhl
    String
"sinl" -> LibFunc
libFunc__sinl
    String
"siprintf" -> LibFunc
libFunc__siprintf
    String
"snprintf" -> LibFunc
libFunc__snprintf
    String
"sprintf" -> LibFunc
libFunc__sprintf
    String
"sqrt" -> LibFunc
libFunc__sqrt
    String
"sqrtf" -> LibFunc
libFunc__sqrtf
    String
"sqrtl" -> LibFunc
libFunc__sqrtl
    String
"sscanf" -> LibFunc
libFunc__sscanf
    String
"stat" -> LibFunc
libFunc__stat
    String
"stat64" -> LibFunc
libFunc__stat64
    String
"statvfs" -> LibFunc
libFunc__statvfs
    String
"statvfs64" -> LibFunc
libFunc__statvfs64
    String
"stpcpy" -> LibFunc
libFunc__stpcpy
    String
"stpncpy" -> LibFunc
libFunc__stpncpy
    String
"strcasecmp" -> LibFunc
libFunc__strcasecmp
    String
"strcat" -> LibFunc
libFunc__strcat
    String
"strchr" -> LibFunc
libFunc__strchr
    String
"strcmp" -> LibFunc
libFunc__strcmp
    String
"strcoll" -> LibFunc
libFunc__strcoll
    String
"strcpy" -> LibFunc
libFunc__strcpy
    String
"strcspn" -> LibFunc
libFunc__strcspn
    String
"strdup" -> LibFunc
libFunc__strdup
    String
"strlen" -> LibFunc
libFunc__strlen
    String
"strncasecmp" -> LibFunc
libFunc__strncasecmp
    String
"strncat" -> LibFunc
libFunc__strncat
    String
"strncmp" -> LibFunc
libFunc__strncmp
    String
"strncpy" -> LibFunc
libFunc__strncpy
    String
"strndup" -> LibFunc
libFunc__strndup
    String
"strnlen" -> LibFunc
libFunc__strnlen
    String
"strpbrk" -> LibFunc
libFunc__strpbrk
    String
"strrchr" -> LibFunc
libFunc__strrchr
    String
"strspn" -> LibFunc
libFunc__strspn
    String
"strstr" -> LibFunc
libFunc__strstr
    String
"strtod" -> LibFunc
libFunc__strtod
    String
"strtof" -> LibFunc
libFunc__strtof
    String
"strtok" -> LibFunc
libFunc__strtok
    String
"strtok_r" -> LibFunc
libFunc__strtok_r
    String
"strtol" -> LibFunc
libFunc__strtol
    String
"strtold" -> LibFunc
libFunc__strtold
    String
"strtoll" -> LibFunc
libFunc__strtoll
    String
"strtoul" -> LibFunc
libFunc__strtoul
    String
"strtoull" -> LibFunc
libFunc__strtoull
    String
"strxfrm" -> LibFunc
libFunc__strxfrm
    String
"system" -> LibFunc
libFunc__system
    String
"tan" -> LibFunc
libFunc__tan
    String
"tanf" -> LibFunc
libFunc__tanf
    String
"tanh" -> LibFunc
libFunc__tanh
    String
"tanhf" -> LibFunc
libFunc__tanhf
    String
"tanhl" -> LibFunc
libFunc__tanhl
    String
"tanl" -> LibFunc
libFunc__tanl
    String
"times" -> LibFunc
libFunc__times
    String
"tmpfile" -> LibFunc
libFunc__tmpfile
    String
"tmpfile64" -> LibFunc
libFunc__tmpfile64
    String
"toascii" -> LibFunc
libFunc__toascii
    String
"trunc" -> LibFunc
libFunc__trunc
    String
"truncf" -> LibFunc
libFunc__truncf
    String
"truncl" -> LibFunc
libFunc__truncl
    String
"uname" -> LibFunc
libFunc__uname
    String
"ungetc" -> LibFunc
libFunc__ungetc
    String
"unlink" -> LibFunc
libFunc__unlink
    String
"unsetenv" -> LibFunc
libFunc__unsetenv
    String
"utime" -> LibFunc
libFunc__utime
    String
"utimes" -> LibFunc
libFunc__utimes
    String
"valloc" -> LibFunc
libFunc__valloc
    String
"vfprintf" -> LibFunc
libFunc__vfprintf
    String
"vfscanf" -> LibFunc
libFunc__vfscanf
    String
"vprintf" -> LibFunc
libFunc__vprintf
    String
"vscanf" -> LibFunc
libFunc__vscanf
    String
"vsnprintf" -> LibFunc
libFunc__vsnprintf
    String
"vsprintf" -> LibFunc
libFunc__vsprintf
    String
"vsscanf" -> LibFunc
libFunc__vsscanf
    String
"write" -> LibFunc
libFunc__write
    String
x -> String -> LibFunc
forall a. HasCallStack => String -> a
error (String -> LibFunc) -> String -> LibFunc
forall a b. (a -> b) -> a -> b
$ String
"bad quasiquoted FFI constant for libFunc__: " String -> ShowS
forall a. [a] -> [a] -> [a]
++ String
x,
  quoteType :: String -> Q Type
quoteType = String -> Q Type
forall a. HasCallStack => a
undefined,
  quoteDec :: String -> Q [Dec]
quoteDec = String -> Q [Dec]
forall a. HasCallStack => a
undefined
 }

{-# LINE 340 "src/LLVM/Internal/FFI/LLVMCTypes.hsc" #-}

newtype JITSymbolFlags = JITSymbolFlags CUInt
  deriving (Eq, Read, Show, Bits, Typeable, Data, Num, Storable, Generic)


jitSymbolFlagsNone :: JITSymbolFlags
jitSymbolFlagsNone = JITSymbolFlags 0
jitSymbolFlagsHasError :: JITSymbolFlags
jitSymbolFlagsHasError = JITSymbolFlags 1
jitSymbolFlagsWeak :: JITSymbolFlags
jitSymbolFlagsWeak = JITSymbolFlags 2
jitSymbolFlagsCommon :: JITSymbolFlags
jitSymbolFlagsCommon = JITSymbolFlags 4
jitSymbolFlagsAbsolute :: JITSymbolFlags
jitSymbolFlagsAbsolute = JITSymbolFlags 8
jitSymbolFlagsExported :: JITSymbolFlags
jitSymbolFlagsExported = JITSymbolFlags 16
jitSymbolFlagsCallable :: JITSymbolFlags
jitSymbolFlagsCallable = JITSymbolFlags 32
jitSymbolFlagsMaterializationSideEffectsOnly :: JITSymbolFlags
jitSymbolFlagsMaterializationSideEffectsOnly = JITSymbolFlags 64
jitSymbolFlagsP :: QuasiQuoter
jitSymbolFlagsP = QuasiQuoter {
  quoteExp = undefined,
  quotePat = \s -> dataToPatQ (const Nothing) $ case s of
    "None" -> jitSymbolFlagsNone
    "HasError" -> jitSymbolFlagsHasError
    "Weak" -> jitSymbolFlagsWeak
    "Common" -> jitSymbolFlagsCommon
    "Absolute" -> jitSymbolFlagsAbsolute
    "Exported" -> jitSymbolFlagsExported
    "Callable" -> jitSymbolFlagsCallable
    "MaterializationSideEffectsOnly" -> jitSymbolFlagsMaterializationSideEffectsOnly
    x -> error $ "bad quasiquoted FFI constant for jitSymbolFlags: " ++ x,
  quoteType = undefined,
  quoteDec = undefined
 }

{-# LINE 346 "src/LLVM/Internal/FFI/LLVMCTypes.hsc" #-}

newtype ChecksumKind = ChecksumKind CUInt
  deriving (Data, Show)

newtype Macinfo = Macinfo CUInt
  deriving (Data, Show)

pattern DW_Macinfo_Define :: Macinfo
pattern DW_Macinfo_Define = Macinfo 0x01
pattern DW_Macinfo_Undef :: Macinfo
pattern DW_Macinfo_Undef = Macinfo 0x02

newtype DebugEmissionKind = DebugEmissionKind CUInt
  deriving (Data, Show)

pattern NoDebug :: DebugEmissionKind
pattern NoDebug = DebugEmissionKind 0
pattern FullDebug :: DebugEmissionKind
pattern FullDebug = DebugEmissionKind 1
pattern LineTablesOnly :: DebugEmissionKind
pattern LineTablesOnly = DebugEmissionKind 2

newtype DebugNameTableKind = DebugNameTableKind CUInt
  deriving (Data, Show)

pattern NameTableKindDefault :: DebugNameTableKind
pattern NameTableKindDefault = DebugNameTableKind 0

pattern NameTableKindGNU :: DebugNameTableKind
pattern NameTableKindGNU = DebugNameTableKind 1

pattern NameTableKindNone :: DebugNameTableKind
pattern NameTableKindNone = DebugNameTableKind 2