{-# LANGUAGE DataKinds #-}
{-# LANGUAGE TypeFamilies #-}
{-# LANGUAGE UndecidableInstances #-}
module System.CPUFeatures.Arm.Constraint.Unsafe
  ( module System.CPUFeatures.Arm.Constraint.Unsafe
  , Dict (Dict)
  ) where
import Data.Type.Equality ((:~:)(Refl))
import System.CPUFeatures.Util
import System.CPUFeatures.Arm.TypeBool
import Unsafe.Coerce (unsafeCoerce)

class FEAT_AES ~ True => HasFEAT_AES
instance FEAT_AES ~ True => HasFEAT_AES

class FEAT_AFP ~ True => HasFEAT_AFP
instance FEAT_AFP ~ True => HasFEAT_AFP

class FEAT_BF16 ~ True => HasFEAT_BF16
instance FEAT_BF16 ~ True => HasFEAT_BF16

class FEAT_BTI ~ True => HasFEAT_BTI
instance FEAT_BTI ~ True => HasFEAT_BTI

class FEAT_CSV2 ~ True => HasFEAT_CSV2
instance FEAT_CSV2 ~ True => HasFEAT_CSV2

class FEAT_CSV3 ~ True => HasFEAT_CSV3
instance FEAT_CSV3 ~ True => HasFEAT_CSV3

class FEAT_DIT ~ True => HasFEAT_DIT
instance FEAT_DIT ~ True => HasFEAT_DIT

class FEAT_DotProd ~ True => HasFEAT_DotProd
instance FEAT_DotProd ~ True => HasFEAT_DotProd

class FEAT_DPB ~ True => HasFEAT_DPB
instance FEAT_DPB ~ True => HasFEAT_DPB

class FEAT_DPB2 ~ True => HasFEAT_DPB2
instance FEAT_DPB2 ~ True => HasFEAT_DPB2

class FEAT_ECV ~ True => HasFEAT_ECV
instance FEAT_ECV ~ True => HasFEAT_ECV

class FEAT_FCMA ~ True => HasFEAT_FCMA
instance FEAT_FCMA ~ True => HasFEAT_FCMA

class FEAT_FHM ~ True => HasFEAT_FHM
instance FEAT_FHM ~ True => HasFEAT_FHM

class FEAT_FlagM ~ True => HasFEAT_FlagM
instance FEAT_FlagM ~ True => HasFEAT_FlagM

class FEAT_FlagM2 ~ True => HasFEAT_FlagM2
instance FEAT_FlagM2 ~ True => HasFEAT_FlagM2

class FEAT_FP16 ~ True => HasFEAT_FP16
instance FEAT_FP16 ~ True => HasFEAT_FP16

class FEAT_FPAC ~ True => HasFEAT_FPAC
instance FEAT_FPAC ~ True => HasFEAT_FPAC

class FEAT_FRINTTS ~ True => HasFEAT_FRINTTS
instance FEAT_FRINTTS ~ True => HasFEAT_FRINTTS

class FEAT_I8MM ~ True => HasFEAT_I8MM
instance FEAT_I8MM ~ True => HasFEAT_I8MM

class FEAT_JSCVT ~ True => HasFEAT_JSCVT
instance FEAT_JSCVT ~ True => HasFEAT_JSCVT

class FEAT_LRCPC ~ True => HasFEAT_LRCPC
instance FEAT_LRCPC ~ True => HasFEAT_LRCPC

class FEAT_LRCPC2 ~ True => HasFEAT_LRCPC2
instance FEAT_LRCPC2 ~ True => HasFEAT_LRCPC2

class FEAT_LSE ~ True => HasFEAT_LSE
instance FEAT_LSE ~ True => HasFEAT_LSE

class FEAT_LSE2 ~ True => HasFEAT_LSE2
instance FEAT_LSE2 ~ True => HasFEAT_LSE2

class FEAT_PAuth ~ True => HasFEAT_PAuth
instance FEAT_PAuth ~ True => HasFEAT_PAuth

class FEAT_PAuth2 ~ True => HasFEAT_PAuth2
instance FEAT_PAuth2 ~ True => HasFEAT_PAuth2

class FEAT_PMULL ~ True => HasFEAT_PMULL
instance FEAT_PMULL ~ True => HasFEAT_PMULL

class FEAT_RDM ~ True => HasFEAT_RDM
instance FEAT_RDM ~ True => HasFEAT_RDM

class FEAT_RPRES ~ True => HasFEAT_RPRES
instance FEAT_RPRES ~ True => HasFEAT_RPRES

class FEAT_SB ~ True => HasFEAT_SB
instance FEAT_SB ~ True => HasFEAT_SB

class FEAT_SHA1 ~ True => HasFEAT_SHA1
instance FEAT_SHA1 ~ True => HasFEAT_SHA1

class FEAT_SHA256 ~ True => HasFEAT_SHA256
instance FEAT_SHA256 ~ True => HasFEAT_SHA256

class FEAT_SHA3 ~ True => HasFEAT_SHA3
instance FEAT_SHA3 ~ True => HasFEAT_SHA3

class FEAT_SHA512 ~ True => HasFEAT_SHA512
instance FEAT_SHA512 ~ True => HasFEAT_SHA512

class FEAT_SME ~ True => HasFEAT_SME
instance FEAT_SME ~ True => HasFEAT_SME

class FEAT_SME_F64F64 ~ True => HasFEAT_SME_F64F64
instance FEAT_SME_F64F64 ~ True => HasFEAT_SME_F64F64

class FEAT_SME_I16I64 ~ True => HasFEAT_SME_I16I64
instance FEAT_SME_I16I64 ~ True => HasFEAT_SME_I16I64

class FEAT_SME2 ~ True => HasFEAT_SME2
instance FEAT_SME2 ~ True => HasFEAT_SME2

class FEAT_SPECRES ~ True => HasFEAT_SPECRES
instance FEAT_SPECRES ~ True => HasFEAT_SPECRES

class FEAT_SSBS ~ True => HasFEAT_SSBS
instance FEAT_SSBS ~ True => HasFEAT_SSBS

class FEAT_SVE ~ True => HasFEAT_SVE
instance FEAT_SVE ~ True => HasFEAT_SVE

class FEAT_SVE2 ~ True => HasFEAT_SVE2
instance FEAT_SVE2 ~ True => HasFEAT_SVE2

class FEAT_WFxT ~ True => HasFEAT_WFxT
instance FEAT_WFxT ~ True => HasFEAT_WFxT

unsafeAssumeFEAT_AES :: (HasFEAT_AES => a) -> a
unsafeAssumeFEAT_AES :: forall a. (HasFEAT_AES => a) -> a
unsafeAssumeFEAT_AES HasFEAT_AES => a
k = case (Any :~: Any) -> FEAT_AES :~: 'True
forall a b. a -> b
unsafeCoerce Any :~: Any
forall {k} (a :: k). a :~: a
Refl :: FEAT_AES :~: True of FEAT_AES :~: 'True
Refl -> a
HasFEAT_AES => a
k

queryFEAT_AES :: Maybe (Dict HasFEAT_AES)
queryFEAT_AES :: Maybe (Dict HasFEAT_AES)
queryFEAT_AES = case SBool FEAT_AES
sFEAT_AES of SBool FEAT_AES
STrue -> (HasFEAT_AES => Maybe (Dict HasFEAT_AES))
-> Maybe (Dict HasFEAT_AES)
forall a. (HasFEAT_AES => a) -> a
unsafeAssumeFEAT_AES (Dict HasFEAT_AES -> Maybe (Dict HasFEAT_AES)
forall a. a -> Maybe a
Just Dict HasFEAT_AES
forall (c :: Constraint). c => Dict c
Dict); SBool FEAT_AES
SFalse -> Maybe (Dict HasFEAT_AES)
forall a. Maybe a
Nothing
{-# NOINLINE queryFEAT_AES #-}

unsafeAssumeFEAT_AFP :: (HasFEAT_AFP => a) -> a
unsafeAssumeFEAT_AFP :: forall a. (HasFEAT_AFP => a) -> a
unsafeAssumeFEAT_AFP HasFEAT_AFP => a
k = case (Any :~: Any) -> FEAT_AFP :~: 'True
forall a b. a -> b
unsafeCoerce Any :~: Any
forall {k} (a :: k). a :~: a
Refl :: FEAT_AFP :~: True of FEAT_AFP :~: 'True
Refl -> a
HasFEAT_AFP => a
k

queryFEAT_AFP :: Maybe (Dict HasFEAT_AFP)
queryFEAT_AFP :: Maybe (Dict HasFEAT_AFP)
queryFEAT_AFP = case SBool FEAT_AFP
sFEAT_AFP of SBool FEAT_AFP
STrue -> (HasFEAT_AFP => Maybe (Dict HasFEAT_AFP))
-> Maybe (Dict HasFEAT_AFP)
forall a. (HasFEAT_AFP => a) -> a
unsafeAssumeFEAT_AFP (Dict HasFEAT_AFP -> Maybe (Dict HasFEAT_AFP)
forall a. a -> Maybe a
Just Dict HasFEAT_AFP
forall (c :: Constraint). c => Dict c
Dict); SBool FEAT_AFP
SFalse -> Maybe (Dict HasFEAT_AFP)
forall a. Maybe a
Nothing
{-# NOINLINE queryFEAT_AFP #-}

unsafeAssumeFEAT_BF16 :: (HasFEAT_BF16 => a) -> a
unsafeAssumeFEAT_BF16 :: forall a. (HasFEAT_BF16 => a) -> a
unsafeAssumeFEAT_BF16 HasFEAT_BF16 => a
k = case (Any :~: Any) -> FEAT_BF16 :~: 'True
forall a b. a -> b
unsafeCoerce Any :~: Any
forall {k} (a :: k). a :~: a
Refl :: FEAT_BF16 :~: True of FEAT_BF16 :~: 'True
Refl -> a
HasFEAT_BF16 => a
k

queryFEAT_BF16 :: Maybe (Dict HasFEAT_BF16)
queryFEAT_BF16 :: Maybe (Dict HasFEAT_BF16)
queryFEAT_BF16 = case SBool FEAT_BF16
sFEAT_BF16 of SBool FEAT_BF16
STrue -> (HasFEAT_BF16 => Maybe (Dict HasFEAT_BF16))
-> Maybe (Dict HasFEAT_BF16)
forall a. (HasFEAT_BF16 => a) -> a
unsafeAssumeFEAT_BF16 (Dict HasFEAT_BF16 -> Maybe (Dict HasFEAT_BF16)
forall a. a -> Maybe a
Just Dict HasFEAT_BF16
forall (c :: Constraint). c => Dict c
Dict); SBool FEAT_BF16
SFalse -> Maybe (Dict HasFEAT_BF16)
forall a. Maybe a
Nothing
{-# NOINLINE queryFEAT_BF16 #-}

unsafeAssumeFEAT_BTI :: (HasFEAT_BTI => a) -> a
unsafeAssumeFEAT_BTI :: forall a. (HasFEAT_BTI => a) -> a
unsafeAssumeFEAT_BTI HasFEAT_BTI => a
k = case (Any :~: Any) -> FEAT_BTI :~: 'True
forall a b. a -> b
unsafeCoerce Any :~: Any
forall {k} (a :: k). a :~: a
Refl :: FEAT_BTI :~: True of FEAT_BTI :~: 'True
Refl -> a
HasFEAT_BTI => a
k

queryFEAT_BTI :: Maybe (Dict HasFEAT_BTI)
queryFEAT_BTI :: Maybe (Dict HasFEAT_BTI)
queryFEAT_BTI = case SBool FEAT_BTI
sFEAT_BTI of SBool FEAT_BTI
STrue -> (HasFEAT_BTI => Maybe (Dict HasFEAT_BTI))
-> Maybe (Dict HasFEAT_BTI)
forall a. (HasFEAT_BTI => a) -> a
unsafeAssumeFEAT_BTI (Dict HasFEAT_BTI -> Maybe (Dict HasFEAT_BTI)
forall a. a -> Maybe a
Just Dict HasFEAT_BTI
forall (c :: Constraint). c => Dict c
Dict); SBool FEAT_BTI
SFalse -> Maybe (Dict HasFEAT_BTI)
forall a. Maybe a
Nothing
{-# NOINLINE queryFEAT_BTI #-}

unsafeAssumeFEAT_CSV2 :: (HasFEAT_CSV2 => a) -> a
unsafeAssumeFEAT_CSV2 :: forall a. (HasFEAT_CSV2 => a) -> a
unsafeAssumeFEAT_CSV2 HasFEAT_CSV2 => a
k = case (Any :~: Any) -> FEAT_CSV2 :~: 'True
forall a b. a -> b
unsafeCoerce Any :~: Any
forall {k} (a :: k). a :~: a
Refl :: FEAT_CSV2 :~: True of FEAT_CSV2 :~: 'True
Refl -> a
HasFEAT_CSV2 => a
k

queryFEAT_CSV2 :: Maybe (Dict HasFEAT_CSV2)
queryFEAT_CSV2 :: Maybe (Dict HasFEAT_CSV2)
queryFEAT_CSV2 = case SBool FEAT_CSV2
sFEAT_CSV2 of SBool FEAT_CSV2
STrue -> (HasFEAT_CSV2 => Maybe (Dict HasFEAT_CSV2))
-> Maybe (Dict HasFEAT_CSV2)
forall a. (HasFEAT_CSV2 => a) -> a
unsafeAssumeFEAT_CSV2 (Dict HasFEAT_CSV2 -> Maybe (Dict HasFEAT_CSV2)
forall a. a -> Maybe a
Just Dict HasFEAT_CSV2
forall (c :: Constraint). c => Dict c
Dict); SBool FEAT_CSV2
SFalse -> Maybe (Dict HasFEAT_CSV2)
forall a. Maybe a
Nothing
{-# NOINLINE queryFEAT_CSV2 #-}

unsafeAssumeFEAT_CSV3 :: (HasFEAT_CSV3 => a) -> a
unsafeAssumeFEAT_CSV3 :: forall a. (HasFEAT_CSV3 => a) -> a
unsafeAssumeFEAT_CSV3 HasFEAT_CSV3 => a
k = case (Any :~: Any) -> FEAT_CSV3 :~: 'True
forall a b. a -> b
unsafeCoerce Any :~: Any
forall {k} (a :: k). a :~: a
Refl :: FEAT_CSV3 :~: True of FEAT_CSV3 :~: 'True
Refl -> a
HasFEAT_CSV3 => a
k

queryFEAT_CSV3 :: Maybe (Dict HasFEAT_CSV3)
queryFEAT_CSV3 :: Maybe (Dict HasFEAT_CSV3)
queryFEAT_CSV3 = case SBool FEAT_CSV3
sFEAT_CSV3 of SBool FEAT_CSV3
STrue -> (HasFEAT_CSV3 => Maybe (Dict HasFEAT_CSV3))
-> Maybe (Dict HasFEAT_CSV3)
forall a. (HasFEAT_CSV3 => a) -> a
unsafeAssumeFEAT_CSV3 (Dict HasFEAT_CSV3 -> Maybe (Dict HasFEAT_CSV3)
forall a. a -> Maybe a
Just Dict HasFEAT_CSV3
forall (c :: Constraint). c => Dict c
Dict); SBool FEAT_CSV3
SFalse -> Maybe (Dict HasFEAT_CSV3)
forall a. Maybe a
Nothing
{-# NOINLINE queryFEAT_CSV3 #-}

unsafeAssumeFEAT_DIT :: (HasFEAT_DIT => a) -> a
unsafeAssumeFEAT_DIT :: forall a. (HasFEAT_DIT => a) -> a
unsafeAssumeFEAT_DIT HasFEAT_DIT => a
k = case (Any :~: Any) -> FEAT_DIT :~: 'True
forall a b. a -> b
unsafeCoerce Any :~: Any
forall {k} (a :: k). a :~: a
Refl :: FEAT_DIT :~: True of FEAT_DIT :~: 'True
Refl -> a
HasFEAT_DIT => a
k

queryFEAT_DIT :: Maybe (Dict HasFEAT_DIT)
queryFEAT_DIT :: Maybe (Dict HasFEAT_DIT)
queryFEAT_DIT = case SBool FEAT_DIT
sFEAT_DIT of SBool FEAT_DIT
STrue -> (HasFEAT_DIT => Maybe (Dict HasFEAT_DIT))
-> Maybe (Dict HasFEAT_DIT)
forall a. (HasFEAT_DIT => a) -> a
unsafeAssumeFEAT_DIT (Dict HasFEAT_DIT -> Maybe (Dict HasFEAT_DIT)
forall a. a -> Maybe a
Just Dict HasFEAT_DIT
forall (c :: Constraint). c => Dict c
Dict); SBool FEAT_DIT
SFalse -> Maybe (Dict HasFEAT_DIT)
forall a. Maybe a
Nothing
{-# NOINLINE queryFEAT_DIT #-}

unsafeAssumeFEAT_DotProd :: (HasFEAT_DotProd => a) -> a
unsafeAssumeFEAT_DotProd :: forall a. (HasFEAT_DotProd => a) -> a
unsafeAssumeFEAT_DotProd HasFEAT_DotProd => a
k = case (Any :~: Any) -> FEAT_DotProd :~: 'True
forall a b. a -> b
unsafeCoerce Any :~: Any
forall {k} (a :: k). a :~: a
Refl :: FEAT_DotProd :~: True of FEAT_DotProd :~: 'True
Refl -> a
HasFEAT_DotProd => a
k

queryFEAT_DotProd :: Maybe (Dict HasFEAT_DotProd)
queryFEAT_DotProd :: Maybe (Dict HasFEAT_DotProd)
queryFEAT_DotProd = case SBool FEAT_DotProd
sFEAT_DotProd of SBool FEAT_DotProd
STrue -> (HasFEAT_DotProd => Maybe (Dict HasFEAT_DotProd))
-> Maybe (Dict HasFEAT_DotProd)
forall a. (HasFEAT_DotProd => a) -> a
unsafeAssumeFEAT_DotProd (Dict HasFEAT_DotProd -> Maybe (Dict HasFEAT_DotProd)
forall a. a -> Maybe a
Just Dict HasFEAT_DotProd
forall (c :: Constraint). c => Dict c
Dict); SBool FEAT_DotProd
SFalse -> Maybe (Dict HasFEAT_DotProd)
forall a. Maybe a
Nothing
{-# NOINLINE queryFEAT_DotProd #-}

unsafeAssumeFEAT_DPB :: (HasFEAT_DPB => a) -> a
unsafeAssumeFEAT_DPB :: forall a. (HasFEAT_DPB => a) -> a
unsafeAssumeFEAT_DPB HasFEAT_DPB => a
k = case (Any :~: Any) -> FEAT_DPB :~: 'True
forall a b. a -> b
unsafeCoerce Any :~: Any
forall {k} (a :: k). a :~: a
Refl :: FEAT_DPB :~: True of FEAT_DPB :~: 'True
Refl -> a
HasFEAT_DPB => a
k

queryFEAT_DPB :: Maybe (Dict HasFEAT_DPB)
queryFEAT_DPB :: Maybe (Dict HasFEAT_DPB)
queryFEAT_DPB = case SBool FEAT_DPB
sFEAT_DPB of SBool FEAT_DPB
STrue -> (HasFEAT_DPB => Maybe (Dict HasFEAT_DPB))
-> Maybe (Dict HasFEAT_DPB)
forall a. (HasFEAT_DPB => a) -> a
unsafeAssumeFEAT_DPB (Dict HasFEAT_DPB -> Maybe (Dict HasFEAT_DPB)
forall a. a -> Maybe a
Just Dict HasFEAT_DPB
forall (c :: Constraint). c => Dict c
Dict); SBool FEAT_DPB
SFalse -> Maybe (Dict HasFEAT_DPB)
forall a. Maybe a
Nothing
{-# NOINLINE queryFEAT_DPB #-}

unsafeAssumeFEAT_DPB2 :: (HasFEAT_DPB2 => a) -> a
unsafeAssumeFEAT_DPB2 :: forall a. (HasFEAT_DPB2 => a) -> a
unsafeAssumeFEAT_DPB2 HasFEAT_DPB2 => a
k = case (Any :~: Any) -> FEAT_DPB2 :~: 'True
forall a b. a -> b
unsafeCoerce Any :~: Any
forall {k} (a :: k). a :~: a
Refl :: FEAT_DPB2 :~: True of FEAT_DPB2 :~: 'True
Refl -> a
HasFEAT_DPB2 => a
k

queryFEAT_DPB2 :: Maybe (Dict HasFEAT_DPB2)
queryFEAT_DPB2 :: Maybe (Dict HasFEAT_DPB2)
queryFEAT_DPB2 = case SBool FEAT_DPB2
sFEAT_DPB2 of SBool FEAT_DPB2
STrue -> (HasFEAT_DPB2 => Maybe (Dict HasFEAT_DPB2))
-> Maybe (Dict HasFEAT_DPB2)
forall a. (HasFEAT_DPB2 => a) -> a
unsafeAssumeFEAT_DPB2 (Dict HasFEAT_DPB2 -> Maybe (Dict HasFEAT_DPB2)
forall a. a -> Maybe a
Just Dict HasFEAT_DPB2
forall (c :: Constraint). c => Dict c
Dict); SBool FEAT_DPB2
SFalse -> Maybe (Dict HasFEAT_DPB2)
forall a. Maybe a
Nothing
{-# NOINLINE queryFEAT_DPB2 #-}

unsafeAssumeFEAT_ECV :: (HasFEAT_ECV => a) -> a
unsafeAssumeFEAT_ECV :: forall a. (HasFEAT_ECV => a) -> a
unsafeAssumeFEAT_ECV HasFEAT_ECV => a
k = case (Any :~: Any) -> FEAT_ECV :~: 'True
forall a b. a -> b
unsafeCoerce Any :~: Any
forall {k} (a :: k). a :~: a
Refl :: FEAT_ECV :~: True of FEAT_ECV :~: 'True
Refl -> a
HasFEAT_ECV => a
k

queryFEAT_ECV :: Maybe (Dict HasFEAT_ECV)
queryFEAT_ECV :: Maybe (Dict HasFEAT_ECV)
queryFEAT_ECV = case SBool FEAT_ECV
sFEAT_ECV of SBool FEAT_ECV
STrue -> (HasFEAT_ECV => Maybe (Dict HasFEAT_ECV))
-> Maybe (Dict HasFEAT_ECV)
forall a. (HasFEAT_ECV => a) -> a
unsafeAssumeFEAT_ECV (Dict HasFEAT_ECV -> Maybe (Dict HasFEAT_ECV)
forall a. a -> Maybe a
Just Dict HasFEAT_ECV
forall (c :: Constraint). c => Dict c
Dict); SBool FEAT_ECV
SFalse -> Maybe (Dict HasFEAT_ECV)
forall a. Maybe a
Nothing
{-# NOINLINE queryFEAT_ECV #-}

unsafeAssumeFEAT_FCMA :: (HasFEAT_FCMA => a) -> a
unsafeAssumeFEAT_FCMA :: forall a. (HasFEAT_FCMA => a) -> a
unsafeAssumeFEAT_FCMA HasFEAT_FCMA => a
k = case (Any :~: Any) -> FEAT_FCMA :~: 'True
forall a b. a -> b
unsafeCoerce Any :~: Any
forall {k} (a :: k). a :~: a
Refl :: FEAT_FCMA :~: True of FEAT_FCMA :~: 'True
Refl -> a
HasFEAT_FCMA => a
k

queryFEAT_FCMA :: Maybe (Dict HasFEAT_FCMA)
queryFEAT_FCMA :: Maybe (Dict HasFEAT_FCMA)
queryFEAT_FCMA = case SBool FEAT_FCMA
sFEAT_FCMA of SBool FEAT_FCMA
STrue -> (HasFEAT_FCMA => Maybe (Dict HasFEAT_FCMA))
-> Maybe (Dict HasFEAT_FCMA)
forall a. (HasFEAT_FCMA => a) -> a
unsafeAssumeFEAT_FCMA (Dict HasFEAT_FCMA -> Maybe (Dict HasFEAT_FCMA)
forall a. a -> Maybe a
Just Dict HasFEAT_FCMA
forall (c :: Constraint). c => Dict c
Dict); SBool FEAT_FCMA
SFalse -> Maybe (Dict HasFEAT_FCMA)
forall a. Maybe a
Nothing
{-# NOINLINE queryFEAT_FCMA #-}

unsafeAssumeFEAT_FHM :: (HasFEAT_FHM => a) -> a
unsafeAssumeFEAT_FHM :: forall a. (HasFEAT_FHM => a) -> a
unsafeAssumeFEAT_FHM HasFEAT_FHM => a
k = case (Any :~: Any) -> FEAT_FHM :~: 'True
forall a b. a -> b
unsafeCoerce Any :~: Any
forall {k} (a :: k). a :~: a
Refl :: FEAT_FHM :~: True of FEAT_FHM :~: 'True
Refl -> a
HasFEAT_FHM => a
k

queryFEAT_FHM :: Maybe (Dict HasFEAT_FHM)
queryFEAT_FHM :: Maybe (Dict HasFEAT_FHM)
queryFEAT_FHM = case SBool FEAT_FHM
sFEAT_FHM of SBool FEAT_FHM
STrue -> (HasFEAT_FHM => Maybe (Dict HasFEAT_FHM))
-> Maybe (Dict HasFEAT_FHM)
forall a. (HasFEAT_FHM => a) -> a
unsafeAssumeFEAT_FHM (Dict HasFEAT_FHM -> Maybe (Dict HasFEAT_FHM)
forall a. a -> Maybe a
Just Dict HasFEAT_FHM
forall (c :: Constraint). c => Dict c
Dict); SBool FEAT_FHM
SFalse -> Maybe (Dict HasFEAT_FHM)
forall a. Maybe a
Nothing
{-# NOINLINE queryFEAT_FHM #-}

unsafeAssumeFEAT_FlagM :: (HasFEAT_FlagM => a) -> a
unsafeAssumeFEAT_FlagM :: forall a. (HasFEAT_FlagM => a) -> a
unsafeAssumeFEAT_FlagM HasFEAT_FlagM => a
k = case (Any :~: Any) -> FEAT_FlagM :~: 'True
forall a b. a -> b
unsafeCoerce Any :~: Any
forall {k} (a :: k). a :~: a
Refl :: FEAT_FlagM :~: True of FEAT_FlagM :~: 'True
Refl -> a
HasFEAT_FlagM => a
k

queryFEAT_FlagM :: Maybe (Dict HasFEAT_FlagM)
queryFEAT_FlagM :: Maybe (Dict HasFEAT_FlagM)
queryFEAT_FlagM = case SBool FEAT_FlagM
sFEAT_FlagM of SBool FEAT_FlagM
STrue -> (HasFEAT_FlagM => Maybe (Dict HasFEAT_FlagM))
-> Maybe (Dict HasFEAT_FlagM)
forall a. (HasFEAT_FlagM => a) -> a
unsafeAssumeFEAT_FlagM (Dict HasFEAT_FlagM -> Maybe (Dict HasFEAT_FlagM)
forall a. a -> Maybe a
Just Dict HasFEAT_FlagM
forall (c :: Constraint). c => Dict c
Dict); SBool FEAT_FlagM
SFalse -> Maybe (Dict HasFEAT_FlagM)
forall a. Maybe a
Nothing
{-# NOINLINE queryFEAT_FlagM #-}

unsafeAssumeFEAT_FlagM2 :: (HasFEAT_FlagM2 => a) -> a
unsafeAssumeFEAT_FlagM2 :: forall a. (HasFEAT_FlagM2 => a) -> a
unsafeAssumeFEAT_FlagM2 HasFEAT_FlagM2 => a
k = case (Any :~: Any) -> FEAT_FlagM2 :~: 'True
forall a b. a -> b
unsafeCoerce Any :~: Any
forall {k} (a :: k). a :~: a
Refl :: FEAT_FlagM2 :~: True of FEAT_FlagM2 :~: 'True
Refl -> a
HasFEAT_FlagM2 => a
k

queryFEAT_FlagM2 :: Maybe (Dict HasFEAT_FlagM2)
queryFEAT_FlagM2 :: Maybe (Dict HasFEAT_FlagM2)
queryFEAT_FlagM2 = case SBool FEAT_FlagM2
sFEAT_FlagM2 of SBool FEAT_FlagM2
STrue -> (HasFEAT_FlagM2 => Maybe (Dict HasFEAT_FlagM2))
-> Maybe (Dict HasFEAT_FlagM2)
forall a. (HasFEAT_FlagM2 => a) -> a
unsafeAssumeFEAT_FlagM2 (Dict HasFEAT_FlagM2 -> Maybe (Dict HasFEAT_FlagM2)
forall a. a -> Maybe a
Just Dict HasFEAT_FlagM2
forall (c :: Constraint). c => Dict c
Dict); SBool FEAT_FlagM2
SFalse -> Maybe (Dict HasFEAT_FlagM2)
forall a. Maybe a
Nothing
{-# NOINLINE queryFEAT_FlagM2 #-}

unsafeAssumeFEAT_FP16 :: (HasFEAT_FP16 => a) -> a
unsafeAssumeFEAT_FP16 :: forall a. (HasFEAT_FP16 => a) -> a
unsafeAssumeFEAT_FP16 HasFEAT_FP16 => a
k = case (Any :~: Any) -> FEAT_FP16 :~: 'True
forall a b. a -> b
unsafeCoerce Any :~: Any
forall {k} (a :: k). a :~: a
Refl :: FEAT_FP16 :~: True of FEAT_FP16 :~: 'True
Refl -> a
HasFEAT_FP16 => a
k

queryFEAT_FP16 :: Maybe (Dict HasFEAT_FP16)
queryFEAT_FP16 :: Maybe (Dict HasFEAT_FP16)
queryFEAT_FP16 = case SBool FEAT_FP16
sFEAT_FP16 of SBool FEAT_FP16
STrue -> (HasFEAT_FP16 => Maybe (Dict HasFEAT_FP16))
-> Maybe (Dict HasFEAT_FP16)
forall a. (HasFEAT_FP16 => a) -> a
unsafeAssumeFEAT_FP16 (Dict HasFEAT_FP16 -> Maybe (Dict HasFEAT_FP16)
forall a. a -> Maybe a
Just Dict HasFEAT_FP16
forall (c :: Constraint). c => Dict c
Dict); SBool FEAT_FP16
SFalse -> Maybe (Dict HasFEAT_FP16)
forall a. Maybe a
Nothing
{-# NOINLINE queryFEAT_FP16 #-}

unsafeAssumeFEAT_FPAC :: (HasFEAT_FPAC => a) -> a
unsafeAssumeFEAT_FPAC :: forall a. (HasFEAT_FPAC => a) -> a
unsafeAssumeFEAT_FPAC HasFEAT_FPAC => a
k = case (Any :~: Any) -> FEAT_FPAC :~: 'True
forall a b. a -> b
unsafeCoerce Any :~: Any
forall {k} (a :: k). a :~: a
Refl :: FEAT_FPAC :~: True of FEAT_FPAC :~: 'True
Refl -> a
HasFEAT_FPAC => a
k

queryFEAT_FPAC :: Maybe (Dict HasFEAT_FPAC)
queryFEAT_FPAC :: Maybe (Dict HasFEAT_FPAC)
queryFEAT_FPAC = case SBool FEAT_FPAC
sFEAT_FPAC of SBool FEAT_FPAC
STrue -> (HasFEAT_FPAC => Maybe (Dict HasFEAT_FPAC))
-> Maybe (Dict HasFEAT_FPAC)
forall a. (HasFEAT_FPAC => a) -> a
unsafeAssumeFEAT_FPAC (Dict HasFEAT_FPAC -> Maybe (Dict HasFEAT_FPAC)
forall a. a -> Maybe a
Just Dict HasFEAT_FPAC
forall (c :: Constraint). c => Dict c
Dict); SBool FEAT_FPAC
SFalse -> Maybe (Dict HasFEAT_FPAC)
forall a. Maybe a
Nothing
{-# NOINLINE queryFEAT_FPAC #-}

unsafeAssumeFEAT_FRINTTS :: (HasFEAT_FRINTTS => a) -> a
unsafeAssumeFEAT_FRINTTS :: forall a. (HasFEAT_FRINTTS => a) -> a
unsafeAssumeFEAT_FRINTTS HasFEAT_FRINTTS => a
k = case (Any :~: Any) -> FEAT_FRINTTS :~: 'True
forall a b. a -> b
unsafeCoerce Any :~: Any
forall {k} (a :: k). a :~: a
Refl :: FEAT_FRINTTS :~: True of FEAT_FRINTTS :~: 'True
Refl -> a
HasFEAT_FRINTTS => a
k

queryFEAT_FRINTTS :: Maybe (Dict HasFEAT_FRINTTS)
queryFEAT_FRINTTS :: Maybe (Dict HasFEAT_FRINTTS)
queryFEAT_FRINTTS = case SBool FEAT_FRINTTS
sFEAT_FRINTTS of SBool FEAT_FRINTTS
STrue -> (HasFEAT_FRINTTS => Maybe (Dict HasFEAT_FRINTTS))
-> Maybe (Dict HasFEAT_FRINTTS)
forall a. (HasFEAT_FRINTTS => a) -> a
unsafeAssumeFEAT_FRINTTS (Dict HasFEAT_FRINTTS -> Maybe (Dict HasFEAT_FRINTTS)
forall a. a -> Maybe a
Just Dict HasFEAT_FRINTTS
forall (c :: Constraint). c => Dict c
Dict); SBool FEAT_FRINTTS
SFalse -> Maybe (Dict HasFEAT_FRINTTS)
forall a. Maybe a
Nothing
{-# NOINLINE queryFEAT_FRINTTS #-}

unsafeAssumeFEAT_I8MM :: (HasFEAT_I8MM => a) -> a
unsafeAssumeFEAT_I8MM :: forall a. (HasFEAT_I8MM => a) -> a
unsafeAssumeFEAT_I8MM HasFEAT_I8MM => a
k = case (Any :~: Any) -> FEAT_I8MM :~: 'True
forall a b. a -> b
unsafeCoerce Any :~: Any
forall {k} (a :: k). a :~: a
Refl :: FEAT_I8MM :~: True of FEAT_I8MM :~: 'True
Refl -> a
HasFEAT_I8MM => a
k

queryFEAT_I8MM :: Maybe (Dict HasFEAT_I8MM)
queryFEAT_I8MM :: Maybe (Dict HasFEAT_I8MM)
queryFEAT_I8MM = case SBool FEAT_I8MM
sFEAT_I8MM of SBool FEAT_I8MM
STrue -> (HasFEAT_I8MM => Maybe (Dict HasFEAT_I8MM))
-> Maybe (Dict HasFEAT_I8MM)
forall a. (HasFEAT_I8MM => a) -> a
unsafeAssumeFEAT_I8MM (Dict HasFEAT_I8MM -> Maybe (Dict HasFEAT_I8MM)
forall a. a -> Maybe a
Just Dict HasFEAT_I8MM
forall (c :: Constraint). c => Dict c
Dict); SBool FEAT_I8MM
SFalse -> Maybe (Dict HasFEAT_I8MM)
forall a. Maybe a
Nothing
{-# NOINLINE queryFEAT_I8MM #-}

unsafeAssumeFEAT_JSCVT :: (HasFEAT_JSCVT => a) -> a
unsafeAssumeFEAT_JSCVT :: forall a. (HasFEAT_JSCVT => a) -> a
unsafeAssumeFEAT_JSCVT HasFEAT_JSCVT => a
k = case (Any :~: Any) -> FEAT_JSCVT :~: 'True
forall a b. a -> b
unsafeCoerce Any :~: Any
forall {k} (a :: k). a :~: a
Refl :: FEAT_JSCVT :~: True of FEAT_JSCVT :~: 'True
Refl -> a
HasFEAT_JSCVT => a
k

queryFEAT_JSCVT :: Maybe (Dict HasFEAT_JSCVT)
queryFEAT_JSCVT :: Maybe (Dict HasFEAT_JSCVT)
queryFEAT_JSCVT = case SBool FEAT_JSCVT
sFEAT_JSCVT of SBool FEAT_JSCVT
STrue -> (HasFEAT_JSCVT => Maybe (Dict HasFEAT_JSCVT))
-> Maybe (Dict HasFEAT_JSCVT)
forall a. (HasFEAT_JSCVT => a) -> a
unsafeAssumeFEAT_JSCVT (Dict HasFEAT_JSCVT -> Maybe (Dict HasFEAT_JSCVT)
forall a. a -> Maybe a
Just Dict HasFEAT_JSCVT
forall (c :: Constraint). c => Dict c
Dict); SBool FEAT_JSCVT
SFalse -> Maybe (Dict HasFEAT_JSCVT)
forall a. Maybe a
Nothing
{-# NOINLINE queryFEAT_JSCVT #-}

unsafeAssumeFEAT_LRCPC :: (HasFEAT_LRCPC => a) -> a
unsafeAssumeFEAT_LRCPC :: forall a. (HasFEAT_LRCPC => a) -> a
unsafeAssumeFEAT_LRCPC HasFEAT_LRCPC => a
k = case (Any :~: Any) -> FEAT_LRCPC :~: 'True
forall a b. a -> b
unsafeCoerce Any :~: Any
forall {k} (a :: k). a :~: a
Refl :: FEAT_LRCPC :~: True of FEAT_LRCPC :~: 'True
Refl -> a
HasFEAT_LRCPC => a
k

queryFEAT_LRCPC :: Maybe (Dict HasFEAT_LRCPC)
queryFEAT_LRCPC :: Maybe (Dict HasFEAT_LRCPC)
queryFEAT_LRCPC = case SBool FEAT_LRCPC
sFEAT_LRCPC of SBool FEAT_LRCPC
STrue -> (HasFEAT_LRCPC => Maybe (Dict HasFEAT_LRCPC))
-> Maybe (Dict HasFEAT_LRCPC)
forall a. (HasFEAT_LRCPC => a) -> a
unsafeAssumeFEAT_LRCPC (Dict HasFEAT_LRCPC -> Maybe (Dict HasFEAT_LRCPC)
forall a. a -> Maybe a
Just Dict HasFEAT_LRCPC
forall (c :: Constraint). c => Dict c
Dict); SBool FEAT_LRCPC
SFalse -> Maybe (Dict HasFEAT_LRCPC)
forall a. Maybe a
Nothing
{-# NOINLINE queryFEAT_LRCPC #-}

unsafeAssumeFEAT_LRCPC2 :: (HasFEAT_LRCPC2 => a) -> a
unsafeAssumeFEAT_LRCPC2 :: forall a. (HasFEAT_LRCPC2 => a) -> a
unsafeAssumeFEAT_LRCPC2 HasFEAT_LRCPC2 => a
k = case (Any :~: Any) -> FEAT_LRCPC2 :~: 'True
forall a b. a -> b
unsafeCoerce Any :~: Any
forall {k} (a :: k). a :~: a
Refl :: FEAT_LRCPC2 :~: True of FEAT_LRCPC2 :~: 'True
Refl -> a
HasFEAT_LRCPC2 => a
k

queryFEAT_LRCPC2 :: Maybe (Dict HasFEAT_LRCPC2)
queryFEAT_LRCPC2 :: Maybe (Dict HasFEAT_LRCPC2)
queryFEAT_LRCPC2 = case SBool FEAT_LRCPC2
sFEAT_LRCPC2 of SBool FEAT_LRCPC2
STrue -> (HasFEAT_LRCPC2 => Maybe (Dict HasFEAT_LRCPC2))
-> Maybe (Dict HasFEAT_LRCPC2)
forall a. (HasFEAT_LRCPC2 => a) -> a
unsafeAssumeFEAT_LRCPC2 (Dict HasFEAT_LRCPC2 -> Maybe (Dict HasFEAT_LRCPC2)
forall a. a -> Maybe a
Just Dict HasFEAT_LRCPC2
forall (c :: Constraint). c => Dict c
Dict); SBool FEAT_LRCPC2
SFalse -> Maybe (Dict HasFEAT_LRCPC2)
forall a. Maybe a
Nothing
{-# NOINLINE queryFEAT_LRCPC2 #-}

unsafeAssumeFEAT_LSE :: (HasFEAT_LSE => a) -> a
unsafeAssumeFEAT_LSE :: forall a. (HasFEAT_LSE => a) -> a
unsafeAssumeFEAT_LSE HasFEAT_LSE => a
k = case (Any :~: Any) -> FEAT_LSE :~: 'True
forall a b. a -> b
unsafeCoerce Any :~: Any
forall {k} (a :: k). a :~: a
Refl :: FEAT_LSE :~: True of FEAT_LSE :~: 'True
Refl -> a
HasFEAT_LSE => a
k

queryFEAT_LSE :: Maybe (Dict HasFEAT_LSE)
queryFEAT_LSE :: Maybe (Dict HasFEAT_LSE)
queryFEAT_LSE = case SBool FEAT_LSE
sFEAT_LSE of SBool FEAT_LSE
STrue -> (HasFEAT_LSE => Maybe (Dict HasFEAT_LSE))
-> Maybe (Dict HasFEAT_LSE)
forall a. (HasFEAT_LSE => a) -> a
unsafeAssumeFEAT_LSE (Dict HasFEAT_LSE -> Maybe (Dict HasFEAT_LSE)
forall a. a -> Maybe a
Just Dict HasFEAT_LSE
forall (c :: Constraint). c => Dict c
Dict); SBool FEAT_LSE
SFalse -> Maybe (Dict HasFEAT_LSE)
forall a. Maybe a
Nothing
{-# NOINLINE queryFEAT_LSE #-}

unsafeAssumeFEAT_LSE2 :: (HasFEAT_LSE2 => a) -> a
unsafeAssumeFEAT_LSE2 :: forall a. (HasFEAT_LSE2 => a) -> a
unsafeAssumeFEAT_LSE2 HasFEAT_LSE2 => a
k = case (Any :~: Any) -> FEAT_LSE2 :~: 'True
forall a b. a -> b
unsafeCoerce Any :~: Any
forall {k} (a :: k). a :~: a
Refl :: FEAT_LSE2 :~: True of FEAT_LSE2 :~: 'True
Refl -> a
HasFEAT_LSE2 => a
k

queryFEAT_LSE2 :: Maybe (Dict HasFEAT_LSE2)
queryFEAT_LSE2 :: Maybe (Dict HasFEAT_LSE2)
queryFEAT_LSE2 = case SBool FEAT_LSE2
sFEAT_LSE2 of SBool FEAT_LSE2
STrue -> (HasFEAT_LSE2 => Maybe (Dict HasFEAT_LSE2))
-> Maybe (Dict HasFEAT_LSE2)
forall a. (HasFEAT_LSE2 => a) -> a
unsafeAssumeFEAT_LSE2 (Dict HasFEAT_LSE2 -> Maybe (Dict HasFEAT_LSE2)
forall a. a -> Maybe a
Just Dict HasFEAT_LSE2
forall (c :: Constraint). c => Dict c
Dict); SBool FEAT_LSE2
SFalse -> Maybe (Dict HasFEAT_LSE2)
forall a. Maybe a
Nothing
{-# NOINLINE queryFEAT_LSE2 #-}

unsafeAssumeFEAT_PAuth :: (HasFEAT_PAuth => a) -> a
unsafeAssumeFEAT_PAuth :: forall a. (HasFEAT_PAuth => a) -> a
unsafeAssumeFEAT_PAuth HasFEAT_PAuth => a
k = case (Any :~: Any) -> FEAT_PAuth :~: 'True
forall a b. a -> b
unsafeCoerce Any :~: Any
forall {k} (a :: k). a :~: a
Refl :: FEAT_PAuth :~: True of FEAT_PAuth :~: 'True
Refl -> a
HasFEAT_PAuth => a
k

queryFEAT_PAuth :: Maybe (Dict HasFEAT_PAuth)
queryFEAT_PAuth :: Maybe (Dict HasFEAT_PAuth)
queryFEAT_PAuth = case SBool FEAT_PAuth
sFEAT_PAuth of SBool FEAT_PAuth
STrue -> (HasFEAT_PAuth => Maybe (Dict HasFEAT_PAuth))
-> Maybe (Dict HasFEAT_PAuth)
forall a. (HasFEAT_PAuth => a) -> a
unsafeAssumeFEAT_PAuth (Dict HasFEAT_PAuth -> Maybe (Dict HasFEAT_PAuth)
forall a. a -> Maybe a
Just Dict HasFEAT_PAuth
forall (c :: Constraint). c => Dict c
Dict); SBool FEAT_PAuth
SFalse -> Maybe (Dict HasFEAT_PAuth)
forall a. Maybe a
Nothing
{-# NOINLINE queryFEAT_PAuth #-}

unsafeAssumeFEAT_PAuth2 :: (HasFEAT_PAuth2 => a) -> a
unsafeAssumeFEAT_PAuth2 :: forall a. (HasFEAT_PAuth2 => a) -> a
unsafeAssumeFEAT_PAuth2 HasFEAT_PAuth2 => a
k = case (Any :~: Any) -> FEAT_PAuth2 :~: 'True
forall a b. a -> b
unsafeCoerce Any :~: Any
forall {k} (a :: k). a :~: a
Refl :: FEAT_PAuth2 :~: True of FEAT_PAuth2 :~: 'True
Refl -> a
HasFEAT_PAuth2 => a
k

queryFEAT_PAuth2 :: Maybe (Dict HasFEAT_PAuth2)
queryFEAT_PAuth2 :: Maybe (Dict HasFEAT_PAuth2)
queryFEAT_PAuth2 = case SBool FEAT_PAuth2
sFEAT_PAuth2 of SBool FEAT_PAuth2
STrue -> (HasFEAT_PAuth2 => Maybe (Dict HasFEAT_PAuth2))
-> Maybe (Dict HasFEAT_PAuth2)
forall a. (HasFEAT_PAuth2 => a) -> a
unsafeAssumeFEAT_PAuth2 (Dict HasFEAT_PAuth2 -> Maybe (Dict HasFEAT_PAuth2)
forall a. a -> Maybe a
Just Dict HasFEAT_PAuth2
forall (c :: Constraint). c => Dict c
Dict); SBool FEAT_PAuth2
SFalse -> Maybe (Dict HasFEAT_PAuth2)
forall a. Maybe a
Nothing
{-# NOINLINE queryFEAT_PAuth2 #-}

unsafeAssumeFEAT_PMULL :: (HasFEAT_PMULL => a) -> a
unsafeAssumeFEAT_PMULL :: forall a. (HasFEAT_PMULL => a) -> a
unsafeAssumeFEAT_PMULL HasFEAT_PMULL => a
k = case (Any :~: Any) -> FEAT_PMULL :~: 'True
forall a b. a -> b
unsafeCoerce Any :~: Any
forall {k} (a :: k). a :~: a
Refl :: FEAT_PMULL :~: True of FEAT_PMULL :~: 'True
Refl -> a
HasFEAT_PMULL => a
k

queryFEAT_PMULL :: Maybe (Dict HasFEAT_PMULL)
queryFEAT_PMULL :: Maybe (Dict HasFEAT_PMULL)
queryFEAT_PMULL = case SBool FEAT_PMULL
sFEAT_PMULL of SBool FEAT_PMULL
STrue -> (HasFEAT_PMULL => Maybe (Dict HasFEAT_PMULL))
-> Maybe (Dict HasFEAT_PMULL)
forall a. (HasFEAT_PMULL => a) -> a
unsafeAssumeFEAT_PMULL (Dict HasFEAT_PMULL -> Maybe (Dict HasFEAT_PMULL)
forall a. a -> Maybe a
Just Dict HasFEAT_PMULL
forall (c :: Constraint). c => Dict c
Dict); SBool FEAT_PMULL
SFalse -> Maybe (Dict HasFEAT_PMULL)
forall a. Maybe a
Nothing
{-# NOINLINE queryFEAT_PMULL #-}

unsafeAssumeFEAT_RDM :: (HasFEAT_RDM => a) -> a
unsafeAssumeFEAT_RDM :: forall a. (HasFEAT_RDM => a) -> a
unsafeAssumeFEAT_RDM HasFEAT_RDM => a
k = case (Any :~: Any) -> FEAT_RDM :~: 'True
forall a b. a -> b
unsafeCoerce Any :~: Any
forall {k} (a :: k). a :~: a
Refl :: FEAT_RDM :~: True of FEAT_RDM :~: 'True
Refl -> a
HasFEAT_RDM => a
k

queryFEAT_RDM :: Maybe (Dict HasFEAT_RDM)
queryFEAT_RDM :: Maybe (Dict HasFEAT_RDM)
queryFEAT_RDM = case SBool FEAT_RDM
sFEAT_RDM of SBool FEAT_RDM
STrue -> (HasFEAT_RDM => Maybe (Dict HasFEAT_RDM))
-> Maybe (Dict HasFEAT_RDM)
forall a. (HasFEAT_RDM => a) -> a
unsafeAssumeFEAT_RDM (Dict HasFEAT_RDM -> Maybe (Dict HasFEAT_RDM)
forall a. a -> Maybe a
Just Dict HasFEAT_RDM
forall (c :: Constraint). c => Dict c
Dict); SBool FEAT_RDM
SFalse -> Maybe (Dict HasFEAT_RDM)
forall a. Maybe a
Nothing
{-# NOINLINE queryFEAT_RDM #-}

unsafeAssumeFEAT_RPRES :: (HasFEAT_RPRES => a) -> a
unsafeAssumeFEAT_RPRES :: forall a. (HasFEAT_RPRES => a) -> a
unsafeAssumeFEAT_RPRES HasFEAT_RPRES => a
k = case (Any :~: Any) -> FEAT_RPRES :~: 'True
forall a b. a -> b
unsafeCoerce Any :~: Any
forall {k} (a :: k). a :~: a
Refl :: FEAT_RPRES :~: True of FEAT_RPRES :~: 'True
Refl -> a
HasFEAT_RPRES => a
k

queryFEAT_RPRES :: Maybe (Dict HasFEAT_RPRES)
queryFEAT_RPRES :: Maybe (Dict HasFEAT_RPRES)
queryFEAT_RPRES = case SBool FEAT_RPRES
sFEAT_RPRES of SBool FEAT_RPRES
STrue -> (HasFEAT_RPRES => Maybe (Dict HasFEAT_RPRES))
-> Maybe (Dict HasFEAT_RPRES)
forall a. (HasFEAT_RPRES => a) -> a
unsafeAssumeFEAT_RPRES (Dict HasFEAT_RPRES -> Maybe (Dict HasFEAT_RPRES)
forall a. a -> Maybe a
Just Dict HasFEAT_RPRES
forall (c :: Constraint). c => Dict c
Dict); SBool FEAT_RPRES
SFalse -> Maybe (Dict HasFEAT_RPRES)
forall a. Maybe a
Nothing
{-# NOINLINE queryFEAT_RPRES #-}

unsafeAssumeFEAT_SB :: (HasFEAT_SB => a) -> a
unsafeAssumeFEAT_SB :: forall a. (HasFEAT_SB => a) -> a
unsafeAssumeFEAT_SB HasFEAT_SB => a
k = case (Any :~: Any) -> FEAT_SB :~: 'True
forall a b. a -> b
unsafeCoerce Any :~: Any
forall {k} (a :: k). a :~: a
Refl :: FEAT_SB :~: True of FEAT_SB :~: 'True
Refl -> a
HasFEAT_SB => a
k

queryFEAT_SB :: Maybe (Dict HasFEAT_SB)
queryFEAT_SB :: Maybe (Dict HasFEAT_SB)
queryFEAT_SB = case SBool FEAT_SB
sFEAT_SB of SBool FEAT_SB
STrue -> (HasFEAT_SB => Maybe (Dict HasFEAT_SB)) -> Maybe (Dict HasFEAT_SB)
forall a. (HasFEAT_SB => a) -> a
unsafeAssumeFEAT_SB (Dict HasFEAT_SB -> Maybe (Dict HasFEAT_SB)
forall a. a -> Maybe a
Just Dict HasFEAT_SB
forall (c :: Constraint). c => Dict c
Dict); SBool FEAT_SB
SFalse -> Maybe (Dict HasFEAT_SB)
forall a. Maybe a
Nothing
{-# NOINLINE queryFEAT_SB #-}

unsafeAssumeFEAT_SHA1 :: (HasFEAT_SHA1 => a) -> a
unsafeAssumeFEAT_SHA1 :: forall a. (HasFEAT_SHA1 => a) -> a
unsafeAssumeFEAT_SHA1 HasFEAT_SHA1 => a
k = case (Any :~: Any) -> FEAT_SHA1 :~: 'True
forall a b. a -> b
unsafeCoerce Any :~: Any
forall {k} (a :: k). a :~: a
Refl :: FEAT_SHA1 :~: True of FEAT_SHA1 :~: 'True
Refl -> a
HasFEAT_SHA1 => a
k

queryFEAT_SHA1 :: Maybe (Dict HasFEAT_SHA1)
queryFEAT_SHA1 :: Maybe (Dict HasFEAT_SHA1)
queryFEAT_SHA1 = case SBool FEAT_SHA1
sFEAT_SHA1 of SBool FEAT_SHA1
STrue -> (HasFEAT_SHA1 => Maybe (Dict HasFEAT_SHA1))
-> Maybe (Dict HasFEAT_SHA1)
forall a. (HasFEAT_SHA1 => a) -> a
unsafeAssumeFEAT_SHA1 (Dict HasFEAT_SHA1 -> Maybe (Dict HasFEAT_SHA1)
forall a. a -> Maybe a
Just Dict HasFEAT_SHA1
forall (c :: Constraint). c => Dict c
Dict); SBool FEAT_SHA1
SFalse -> Maybe (Dict HasFEAT_SHA1)
forall a. Maybe a
Nothing
{-# NOINLINE queryFEAT_SHA1 #-}

unsafeAssumeFEAT_SHA256 :: (HasFEAT_SHA256 => a) -> a
unsafeAssumeFEAT_SHA256 :: forall a. (HasFEAT_SHA256 => a) -> a
unsafeAssumeFEAT_SHA256 HasFEAT_SHA256 => a
k = case (Any :~: Any) -> FEAT_SHA256 :~: 'True
forall a b. a -> b
unsafeCoerce Any :~: Any
forall {k} (a :: k). a :~: a
Refl :: FEAT_SHA256 :~: True of FEAT_SHA256 :~: 'True
Refl -> a
HasFEAT_SHA256 => a
k

queryFEAT_SHA256 :: Maybe (Dict HasFEAT_SHA256)
queryFEAT_SHA256 :: Maybe (Dict HasFEAT_SHA256)
queryFEAT_SHA256 = case SBool FEAT_SHA256
sFEAT_SHA256 of SBool FEAT_SHA256
STrue -> (HasFEAT_SHA256 => Maybe (Dict HasFEAT_SHA256))
-> Maybe (Dict HasFEAT_SHA256)
forall a. (HasFEAT_SHA256 => a) -> a
unsafeAssumeFEAT_SHA256 (Dict HasFEAT_SHA256 -> Maybe (Dict HasFEAT_SHA256)
forall a. a -> Maybe a
Just Dict HasFEAT_SHA256
forall (c :: Constraint). c => Dict c
Dict); SBool FEAT_SHA256
SFalse -> Maybe (Dict HasFEAT_SHA256)
forall a. Maybe a
Nothing
{-# NOINLINE queryFEAT_SHA256 #-}

unsafeAssumeFEAT_SHA3 :: (HasFEAT_SHA3 => a) -> a
unsafeAssumeFEAT_SHA3 :: forall a. (HasFEAT_SHA3 => a) -> a
unsafeAssumeFEAT_SHA3 HasFEAT_SHA3 => a
k = case (Any :~: Any) -> FEAT_SHA3 :~: 'True
forall a b. a -> b
unsafeCoerce Any :~: Any
forall {k} (a :: k). a :~: a
Refl :: FEAT_SHA3 :~: True of FEAT_SHA3 :~: 'True
Refl -> a
HasFEAT_SHA3 => a
k

queryFEAT_SHA3 :: Maybe (Dict HasFEAT_SHA3)
queryFEAT_SHA3 :: Maybe (Dict HasFEAT_SHA3)
queryFEAT_SHA3 = case SBool FEAT_SHA3
sFEAT_SHA3 of SBool FEAT_SHA3
STrue -> (HasFEAT_SHA3 => Maybe (Dict HasFEAT_SHA3))
-> Maybe (Dict HasFEAT_SHA3)
forall a. (HasFEAT_SHA3 => a) -> a
unsafeAssumeFEAT_SHA3 (Dict HasFEAT_SHA3 -> Maybe (Dict HasFEAT_SHA3)
forall a. a -> Maybe a
Just Dict HasFEAT_SHA3
forall (c :: Constraint). c => Dict c
Dict); SBool FEAT_SHA3
SFalse -> Maybe (Dict HasFEAT_SHA3)
forall a. Maybe a
Nothing
{-# NOINLINE queryFEAT_SHA3 #-}

unsafeAssumeFEAT_SHA512 :: (HasFEAT_SHA512 => a) -> a
unsafeAssumeFEAT_SHA512 :: forall a. (HasFEAT_SHA512 => a) -> a
unsafeAssumeFEAT_SHA512 HasFEAT_SHA512 => a
k = case (Any :~: Any) -> FEAT_SHA512 :~: 'True
forall a b. a -> b
unsafeCoerce Any :~: Any
forall {k} (a :: k). a :~: a
Refl :: FEAT_SHA512 :~: True of FEAT_SHA512 :~: 'True
Refl -> a
HasFEAT_SHA512 => a
k

queryFEAT_SHA512 :: Maybe (Dict HasFEAT_SHA512)
queryFEAT_SHA512 :: Maybe (Dict HasFEAT_SHA512)
queryFEAT_SHA512 = case SBool FEAT_SHA512
sFEAT_SHA512 of SBool FEAT_SHA512
STrue -> (HasFEAT_SHA512 => Maybe (Dict HasFEAT_SHA512))
-> Maybe (Dict HasFEAT_SHA512)
forall a. (HasFEAT_SHA512 => a) -> a
unsafeAssumeFEAT_SHA512 (Dict HasFEAT_SHA512 -> Maybe (Dict HasFEAT_SHA512)
forall a. a -> Maybe a
Just Dict HasFEAT_SHA512
forall (c :: Constraint). c => Dict c
Dict); SBool FEAT_SHA512
SFalse -> Maybe (Dict HasFEAT_SHA512)
forall a. Maybe a
Nothing
{-# NOINLINE queryFEAT_SHA512 #-}

unsafeAssumeFEAT_SME :: (HasFEAT_SME => a) -> a
unsafeAssumeFEAT_SME :: forall a. (HasFEAT_SME => a) -> a
unsafeAssumeFEAT_SME HasFEAT_SME => a
k = case (Any :~: Any) -> FEAT_SME :~: 'True
forall a b. a -> b
unsafeCoerce Any :~: Any
forall {k} (a :: k). a :~: a
Refl :: FEAT_SME :~: True of FEAT_SME :~: 'True
Refl -> a
HasFEAT_SME => a
k

queryFEAT_SME :: Maybe (Dict HasFEAT_SME)
queryFEAT_SME :: Maybe (Dict HasFEAT_SME)
queryFEAT_SME = case SBool FEAT_SME
sFEAT_SME of SBool FEAT_SME
STrue -> (HasFEAT_SME => Maybe (Dict HasFEAT_SME))
-> Maybe (Dict HasFEAT_SME)
forall a. (HasFEAT_SME => a) -> a
unsafeAssumeFEAT_SME (Dict HasFEAT_SME -> Maybe (Dict HasFEAT_SME)
forall a. a -> Maybe a
Just Dict HasFEAT_SME
forall (c :: Constraint). c => Dict c
Dict); SBool FEAT_SME
SFalse -> Maybe (Dict HasFEAT_SME)
forall a. Maybe a
Nothing
{-# NOINLINE queryFEAT_SME #-}

unsafeAssumeFEAT_SME_F64F64 :: (HasFEAT_SME_F64F64 => a) -> a
unsafeAssumeFEAT_SME_F64F64 :: forall a. (HasFEAT_SME_F64F64 => a) -> a
unsafeAssumeFEAT_SME_F64F64 HasFEAT_SME_F64F64 => a
k = case (Any :~: Any) -> FEAT_SME_F64F64 :~: 'True
forall a b. a -> b
unsafeCoerce Any :~: Any
forall {k} (a :: k). a :~: a
Refl :: FEAT_SME_F64F64 :~: True of FEAT_SME_F64F64 :~: 'True
Refl -> a
HasFEAT_SME_F64F64 => a
k

queryFEAT_SME_F64F64 :: Maybe (Dict HasFEAT_SME_F64F64)
queryFEAT_SME_F64F64 :: Maybe (Dict HasFEAT_SME_F64F64)
queryFEAT_SME_F64F64 = case SBool FEAT_SME_F64F64
sFEAT_SME_F64F64 of SBool FEAT_SME_F64F64
STrue -> (HasFEAT_SME_F64F64 => Maybe (Dict HasFEAT_SME_F64F64))
-> Maybe (Dict HasFEAT_SME_F64F64)
forall a. (HasFEAT_SME_F64F64 => a) -> a
unsafeAssumeFEAT_SME_F64F64 (Dict HasFEAT_SME_F64F64 -> Maybe (Dict HasFEAT_SME_F64F64)
forall a. a -> Maybe a
Just Dict HasFEAT_SME_F64F64
forall (c :: Constraint). c => Dict c
Dict); SBool FEAT_SME_F64F64
SFalse -> Maybe (Dict HasFEAT_SME_F64F64)
forall a. Maybe a
Nothing
{-# NOINLINE queryFEAT_SME_F64F64 #-}

unsafeAssumeFEAT_SME_I16I64 :: (HasFEAT_SME_I16I64 => a) -> a
unsafeAssumeFEAT_SME_I16I64 :: forall a. (HasFEAT_SME_I16I64 => a) -> a
unsafeAssumeFEAT_SME_I16I64 HasFEAT_SME_I16I64 => a
k = case (Any :~: Any) -> FEAT_SME_I16I64 :~: 'True
forall a b. a -> b
unsafeCoerce Any :~: Any
forall {k} (a :: k). a :~: a
Refl :: FEAT_SME_I16I64 :~: True of FEAT_SME_I16I64 :~: 'True
Refl -> a
HasFEAT_SME_I16I64 => a
k

queryFEAT_SME_I16I64 :: Maybe (Dict HasFEAT_SME_I16I64)
queryFEAT_SME_I16I64 :: Maybe (Dict HasFEAT_SME_I16I64)
queryFEAT_SME_I16I64 = case SBool FEAT_SME_I16I64
sFEAT_SME_I16I64 of SBool FEAT_SME_I16I64
STrue -> (HasFEAT_SME_I16I64 => Maybe (Dict HasFEAT_SME_I16I64))
-> Maybe (Dict HasFEAT_SME_I16I64)
forall a. (HasFEAT_SME_I16I64 => a) -> a
unsafeAssumeFEAT_SME_I16I64 (Dict HasFEAT_SME_I16I64 -> Maybe (Dict HasFEAT_SME_I16I64)
forall a. a -> Maybe a
Just Dict HasFEAT_SME_I16I64
forall (c :: Constraint). c => Dict c
Dict); SBool FEAT_SME_I16I64
SFalse -> Maybe (Dict HasFEAT_SME_I16I64)
forall a. Maybe a
Nothing
{-# NOINLINE queryFEAT_SME_I16I64 #-}

unsafeAssumeFEAT_SME2 :: (HasFEAT_SME2 => a) -> a
unsafeAssumeFEAT_SME2 :: forall a. (HasFEAT_SME2 => a) -> a
unsafeAssumeFEAT_SME2 HasFEAT_SME2 => a
k = case (Any :~: Any) -> FEAT_SME2 :~: 'True
forall a b. a -> b
unsafeCoerce Any :~: Any
forall {k} (a :: k). a :~: a
Refl :: FEAT_SME2 :~: True of FEAT_SME2 :~: 'True
Refl -> a
HasFEAT_SME2 => a
k

queryFEAT_SME2 :: Maybe (Dict HasFEAT_SME2)
queryFEAT_SME2 :: Maybe (Dict HasFEAT_SME2)
queryFEAT_SME2 = case SBool FEAT_SME2
sFEAT_SME2 of SBool FEAT_SME2
STrue -> (HasFEAT_SME2 => Maybe (Dict HasFEAT_SME2))
-> Maybe (Dict HasFEAT_SME2)
forall a. (HasFEAT_SME2 => a) -> a
unsafeAssumeFEAT_SME2 (Dict HasFEAT_SME2 -> Maybe (Dict HasFEAT_SME2)
forall a. a -> Maybe a
Just Dict HasFEAT_SME2
forall (c :: Constraint). c => Dict c
Dict); SBool FEAT_SME2
SFalse -> Maybe (Dict HasFEAT_SME2)
forall a. Maybe a
Nothing
{-# NOINLINE queryFEAT_SME2 #-}

unsafeAssumeFEAT_SPECRES :: (HasFEAT_SPECRES => a) -> a
unsafeAssumeFEAT_SPECRES :: forall a. (HasFEAT_SPECRES => a) -> a
unsafeAssumeFEAT_SPECRES HasFEAT_SPECRES => a
k = case (Any :~: Any) -> FEAT_SPECRES :~: 'True
forall a b. a -> b
unsafeCoerce Any :~: Any
forall {k} (a :: k). a :~: a
Refl :: FEAT_SPECRES :~: True of FEAT_SPECRES :~: 'True
Refl -> a
HasFEAT_SPECRES => a
k

queryFEAT_SPECRES :: Maybe (Dict HasFEAT_SPECRES)
queryFEAT_SPECRES :: Maybe (Dict HasFEAT_SPECRES)
queryFEAT_SPECRES = case SBool FEAT_SPECRES
sFEAT_SPECRES of SBool FEAT_SPECRES
STrue -> (HasFEAT_SPECRES => Maybe (Dict HasFEAT_SPECRES))
-> Maybe (Dict HasFEAT_SPECRES)
forall a. (HasFEAT_SPECRES => a) -> a
unsafeAssumeFEAT_SPECRES (Dict HasFEAT_SPECRES -> Maybe (Dict HasFEAT_SPECRES)
forall a. a -> Maybe a
Just Dict HasFEAT_SPECRES
forall (c :: Constraint). c => Dict c
Dict); SBool FEAT_SPECRES
SFalse -> Maybe (Dict HasFEAT_SPECRES)
forall a. Maybe a
Nothing
{-# NOINLINE queryFEAT_SPECRES #-}

unsafeAssumeFEAT_SSBS :: (HasFEAT_SSBS => a) -> a
unsafeAssumeFEAT_SSBS :: forall a. (HasFEAT_SSBS => a) -> a
unsafeAssumeFEAT_SSBS HasFEAT_SSBS => a
k = case (Any :~: Any) -> FEAT_SSBS :~: 'True
forall a b. a -> b
unsafeCoerce Any :~: Any
forall {k} (a :: k). a :~: a
Refl :: FEAT_SSBS :~: True of FEAT_SSBS :~: 'True
Refl -> a
HasFEAT_SSBS => a
k

queryFEAT_SSBS :: Maybe (Dict HasFEAT_SSBS)
queryFEAT_SSBS :: Maybe (Dict HasFEAT_SSBS)
queryFEAT_SSBS = case SBool FEAT_SSBS
sFEAT_SSBS of SBool FEAT_SSBS
STrue -> (HasFEAT_SSBS => Maybe (Dict HasFEAT_SSBS))
-> Maybe (Dict HasFEAT_SSBS)
forall a. (HasFEAT_SSBS => a) -> a
unsafeAssumeFEAT_SSBS (Dict HasFEAT_SSBS -> Maybe (Dict HasFEAT_SSBS)
forall a. a -> Maybe a
Just Dict HasFEAT_SSBS
forall (c :: Constraint). c => Dict c
Dict); SBool FEAT_SSBS
SFalse -> Maybe (Dict HasFEAT_SSBS)
forall a. Maybe a
Nothing
{-# NOINLINE queryFEAT_SSBS #-}

unsafeAssumeFEAT_SVE :: (HasFEAT_SVE => a) -> a
unsafeAssumeFEAT_SVE :: forall a. (HasFEAT_SVE => a) -> a
unsafeAssumeFEAT_SVE HasFEAT_SVE => a
k = case (Any :~: Any) -> FEAT_SVE :~: 'True
forall a b. a -> b
unsafeCoerce Any :~: Any
forall {k} (a :: k). a :~: a
Refl :: FEAT_SVE :~: True of FEAT_SVE :~: 'True
Refl -> a
HasFEAT_SVE => a
k

queryFEAT_SVE :: Maybe (Dict HasFEAT_SVE)
queryFEAT_SVE :: Maybe (Dict HasFEAT_SVE)
queryFEAT_SVE = case SBool FEAT_SVE
sFEAT_SVE of SBool FEAT_SVE
STrue -> (HasFEAT_SVE => Maybe (Dict HasFEAT_SVE))
-> Maybe (Dict HasFEAT_SVE)
forall a. (HasFEAT_SVE => a) -> a
unsafeAssumeFEAT_SVE (Dict HasFEAT_SVE -> Maybe (Dict HasFEAT_SVE)
forall a. a -> Maybe a
Just Dict HasFEAT_SVE
forall (c :: Constraint). c => Dict c
Dict); SBool FEAT_SVE
SFalse -> Maybe (Dict HasFEAT_SVE)
forall a. Maybe a
Nothing
{-# NOINLINE queryFEAT_SVE #-}

unsafeAssumeFEAT_SVE2 :: (HasFEAT_SVE2 => a) -> a
unsafeAssumeFEAT_SVE2 :: forall a. (HasFEAT_SVE2 => a) -> a
unsafeAssumeFEAT_SVE2 HasFEAT_SVE2 => a
k = case (Any :~: Any) -> FEAT_SVE2 :~: 'True
forall a b. a -> b
unsafeCoerce Any :~: Any
forall {k} (a :: k). a :~: a
Refl :: FEAT_SVE2 :~: True of FEAT_SVE2 :~: 'True
Refl -> a
HasFEAT_SVE2 => a
k

queryFEAT_SVE2 :: Maybe (Dict HasFEAT_SVE2)
queryFEAT_SVE2 :: Maybe (Dict HasFEAT_SVE2)
queryFEAT_SVE2 = case SBool FEAT_SVE2
sFEAT_SVE2 of SBool FEAT_SVE2
STrue -> (HasFEAT_SVE2 => Maybe (Dict HasFEAT_SVE2))
-> Maybe (Dict HasFEAT_SVE2)
forall a. (HasFEAT_SVE2 => a) -> a
unsafeAssumeFEAT_SVE2 (Dict HasFEAT_SVE2 -> Maybe (Dict HasFEAT_SVE2)
forall a. a -> Maybe a
Just Dict HasFEAT_SVE2
forall (c :: Constraint). c => Dict c
Dict); SBool FEAT_SVE2
SFalse -> Maybe (Dict HasFEAT_SVE2)
forall a. Maybe a
Nothing
{-# NOINLINE queryFEAT_SVE2 #-}

unsafeAssumeFEAT_WFxT :: (HasFEAT_WFxT => a) -> a
unsafeAssumeFEAT_WFxT :: forall a. (HasFEAT_WFxT => a) -> a
unsafeAssumeFEAT_WFxT HasFEAT_WFxT => a
k = case (Any :~: Any) -> FEAT_WFxT :~: 'True
forall a b. a -> b
unsafeCoerce Any :~: Any
forall {k} (a :: k). a :~: a
Refl :: FEAT_WFxT :~: True of FEAT_WFxT :~: 'True
Refl -> a
HasFEAT_WFxT => a
k

queryFEAT_WFxT :: Maybe (Dict HasFEAT_WFxT)
queryFEAT_WFxT :: Maybe (Dict HasFEAT_WFxT)
queryFEAT_WFxT = case SBool FEAT_WFxT
sFEAT_WFxT of SBool FEAT_WFxT
STrue -> (HasFEAT_WFxT => Maybe (Dict HasFEAT_WFxT))
-> Maybe (Dict HasFEAT_WFxT)
forall a. (HasFEAT_WFxT => a) -> a
unsafeAssumeFEAT_WFxT (Dict HasFEAT_WFxT -> Maybe (Dict HasFEAT_WFxT)
forall a. a -> Maybe a
Just Dict HasFEAT_WFxT
forall (c :: Constraint). c => Dict c
Dict); SBool FEAT_WFxT
SFalse -> Maybe (Dict HasFEAT_WFxT)
forall a. Maybe a
Nothing
{-# NOINLINE queryFEAT_WFxT #-}