content: {-# 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 k = case unsafeCoerce Refl :: FEAT_AES :~: True of Refl -> k
  
  queryFEAT_AES :: Maybe (Dict HasFEAT_AES)
  queryFEAT_AES = case sFEAT_AES of STrue -> unsafeAssumeFEAT_AES (Just Dict); SFalse -> Nothing
  {-# NOINLINE queryFEAT_AES #-}
  
  unsafeAssumeFEAT_AFP :: (HasFEAT_AFP => a) -> a
  unsafeAssumeFEAT_AFP k = case unsafeCoerce Refl :: FEAT_AFP :~: True of Refl -> k
  
  queryFEAT_AFP :: Maybe (Dict HasFEAT_AFP)
  queryFEAT_AFP = case sFEAT_AFP of STrue -> unsafeAssumeFEAT_AFP (Just Dict); SFalse -> Nothing
  {-# NOINLINE queryFEAT_AFP #-}
  
  unsafeAssumeFEAT_BF16 :: (HasFEAT_BF16 => a) -> a
  unsafeAssumeFEAT_BF16 k = case unsafeCoerce Refl :: FEAT_BF16 :~: True of Refl -> k
  
  queryFEAT_BF16 :: Maybe (Dict HasFEAT_BF16)
  queryFEAT_BF16 = case sFEAT_BF16 of STrue -> unsafeAssumeFEAT_BF16 (Just Dict); SFalse -> Nothing
  {-# NOINLINE queryFEAT_BF16 #-}
  
  unsafeAssumeFEAT_BTI :: (HasFEAT_BTI => a) -> a
  unsafeAssumeFEAT_BTI k = case unsafeCoerce Refl :: FEAT_BTI :~: True of Refl -> k
  
  queryFEAT_BTI :: Maybe (Dict HasFEAT_BTI)
  queryFEAT_BTI = case sFEAT_BTI of STrue -> unsafeAssumeFEAT_BTI (Just Dict); SFalse -> Nothing
  {-# NOINLINE queryFEAT_BTI #-}
  
  unsafeAssumeFEAT_CSV2 :: (HasFEAT_CSV2 => a) -> a
  unsafeAssumeFEAT_CSV2 k = case unsafeCoerce Refl :: FEAT_CSV2 :~: True of Refl -> k
  
  queryFEAT_CSV2 :: Maybe (Dict HasFEAT_CSV2)
  queryFEAT_CSV2 = case sFEAT_CSV2 of STrue -> unsafeAssumeFEAT_CSV2 (Just Dict); SFalse -> Nothing
  {-# NOINLINE queryFEAT_CSV2 #-}
  
  unsafeAssumeFEAT_CSV3 :: (HasFEAT_CSV3 => a) -> a
  unsafeAssumeFEAT_CSV3 k = case unsafeCoerce Refl :: FEAT_CSV3 :~: True of Refl -> k
  
  queryFEAT_CSV3 :: Maybe (Dict HasFEAT_CSV3)
  queryFEAT_CSV3 = case sFEAT_CSV3 of STrue -> unsafeAssumeFEAT_CSV3 (Just Dict); SFalse -> Nothing
  {-# NOINLINE queryFEAT_CSV3 #-}
  
  unsafeAssumeFEAT_DIT :: (HasFEAT_DIT => a) -> a
  unsafeAssumeFEAT_DIT k = case unsafeCoerce Refl :: FEAT_DIT :~: True of Refl -> k
  
  queryFEAT_DIT :: Maybe (Dict HasFEAT_DIT)
  queryFEAT_DIT = case sFEAT_DIT of STrue -> unsafeAssumeFEAT_DIT (Just Dict); SFalse -> Nothing
  {-# NOINLINE queryFEAT_DIT #-}
  
  unsafeAssumeFEAT_DotProd :: (HasFEAT_DotProd => a) -> a
  unsafeAssumeFEAT_DotProd k = case unsafeCoerce Refl :: FEAT_DotProd :~: True of Refl -> k
  
  queryFEAT_DotProd :: Maybe (Dict HasFEAT_DotProd)
  queryFEAT_DotProd = case sFEAT_DotProd of STrue -> unsafeAssumeFEAT_DotProd (Just Dict); SFalse -> Nothing
  {-# NOINLINE queryFEAT_DotProd #-}
  
  unsafeAssumeFEAT_DPB :: (HasFEAT_DPB => a) -> a
  unsafeAssumeFEAT_DPB k = case unsafeCoerce Refl :: FEAT_DPB :~: True of Refl -> k
  
  queryFEAT_DPB :: Maybe (Dict HasFEAT_DPB)
  queryFEAT_DPB = case sFEAT_DPB of STrue -> unsafeAssumeFEAT_DPB (Just Dict); SFalse -> Nothing
  {-# NOINLINE queryFEAT_DPB #-}
  
  unsafeAssumeFEAT_DPB2 :: (HasFEAT_DPB2 => a) -> a
  unsafeAssumeFEAT_DPB2 k = case unsafeCoerce Refl :: FEAT_DPB2 :~: True of Refl -> k
  
  queryFEAT_DPB2 :: Maybe (Dict HasFEAT_DPB2)
  queryFEAT_DPB2 = case sFEAT_DPB2 of STrue -> unsafeAssumeFEAT_DPB2 (Just Dict); SFalse -> Nothing
  {-# NOINLINE queryFEAT_DPB2 #-}
  
  unsafeAssumeFEAT_ECV :: (HasFEAT_ECV => a) -> a
  unsafeAssumeFEAT_ECV k = case unsafeCoerce Refl :: FEAT_ECV :~: True of Refl -> k
  
  queryFEAT_ECV :: Maybe (Dict HasFEAT_ECV)
  queryFEAT_ECV = case sFEAT_ECV of STrue -> unsafeAssumeFEAT_ECV (Just Dict); SFalse -> Nothing
  {-# NOINLINE queryFEAT_ECV #-}
  
  unsafeAssumeFEAT_FCMA :: (HasFEAT_FCMA => a) -> a
  unsafeAssumeFEAT_FCMA k = case unsafeCoerce Refl :: FEAT_FCMA :~: True of Refl -> k
  
  queryFEAT_FCMA :: Maybe (Dict HasFEAT_FCMA)
  queryFEAT_FCMA = case sFEAT_FCMA of STrue -> unsafeAssumeFEAT_FCMA (Just Dict); SFalse -> Nothing
  {-# NOINLINE queryFEAT_FCMA #-}
  
  unsafeAssumeFEAT_FHM :: (HasFEAT_FHM => a) -> a
  unsafeAssumeFEAT_FHM k = case unsafeCoerce Refl :: FEAT_FHM :~: True of Refl -> k
  
  queryFEAT_FHM :: Maybe (Dict HasFEAT_FHM)
  queryFEAT_FHM = case sFEAT_FHM of STrue -> unsafeAssumeFEAT_FHM (Just Dict); SFalse -> Nothing
  {-# NOINLINE queryFEAT_FHM #-}
  
  unsafeAssumeFEAT_FlagM :: (HasFEAT_FlagM => a) -> a
  unsafeAssumeFEAT_FlagM k = case unsafeCoerce Refl :: FEAT_FlagM :~: True of Refl -> k
  
  queryFEAT_FlagM :: Maybe (Dict HasFEAT_FlagM)
  queryFEAT_FlagM = case sFEAT_FlagM of STrue -> unsafeAssumeFEAT_FlagM (Just Dict); SFalse -> Nothing
  {-# NOINLINE queryFEAT_FlagM #-}
  
  unsafeAssumeFEAT_FlagM2 :: (HasFEAT_FlagM2 => a) -> a
  unsafeAssumeFEAT_FlagM2 k = case unsafeCoerce Refl :: FEAT_FlagM2 :~: True of Refl -> k
  
  queryFEAT_FlagM2 :: Maybe (Dict HasFEAT_FlagM2)
  queryFEAT_FlagM2 = case sFEAT_FlagM2 of STrue -> unsafeAssumeFEAT_FlagM2 (Just Dict); SFalse -> Nothing
  {-# NOINLINE queryFEAT_FlagM2 #-}
  
  unsafeAssumeFEAT_FP16 :: (HasFEAT_FP16 => a) -> a
  unsafeAssumeFEAT_FP16 k = case unsafeCoerce Refl :: FEAT_FP16 :~: True of Refl -> k
  
  queryFEAT_FP16 :: Maybe (Dict HasFEAT_FP16)
  queryFEAT_FP16 = case sFEAT_FP16 of STrue -> unsafeAssumeFEAT_FP16 (Just Dict); SFalse -> Nothing
  {-# NOINLINE queryFEAT_FP16 #-}
  
  unsafeAssumeFEAT_FPAC :: (HasFEAT_FPAC => a) -> a
  unsafeAssumeFEAT_FPAC k = case unsafeCoerce Refl :: FEAT_FPAC :~: True of Refl -> k
  
  queryFEAT_FPAC :: Maybe (Dict HasFEAT_FPAC)
  queryFEAT_FPAC = case sFEAT_FPAC of STrue -> unsafeAssumeFEAT_FPAC (Just Dict); SFalse -> Nothing
  {-# NOINLINE queryFEAT_FPAC #-}
  
  unsafeAssumeFEAT_FRINTTS :: (HasFEAT_FRINTTS => a) -> a
  unsafeAssumeFEAT_FRINTTS k = case unsafeCoerce Refl :: FEAT_FRINTTS :~: True of Refl -> k
  
  queryFEAT_FRINTTS :: Maybe (Dict HasFEAT_FRINTTS)
  queryFEAT_FRINTTS = case sFEAT_FRINTTS of STrue -> unsafeAssumeFEAT_FRINTTS (Just Dict); SFalse -> Nothing
  {-# NOINLINE queryFEAT_FRINTTS #-}
  
  unsafeAssumeFEAT_I8MM :: (HasFEAT_I8MM => a) -> a
  unsafeAssumeFEAT_I8MM k = case unsafeCoerce Refl :: FEAT_I8MM :~: True of Refl -> k
  
  queryFEAT_I8MM :: Maybe (Dict HasFEAT_I8MM)
  queryFEAT_I8MM = case sFEAT_I8MM of STrue -> unsafeAssumeFEAT_I8MM (Just Dict); SFalse -> Nothing
  {-# NOINLINE queryFEAT_I8MM #-}
  
  unsafeAssumeFEAT_JSCVT :: (HasFEAT_JSCVT => a) -> a
  unsafeAssumeFEAT_JSCVT k = case unsafeCoerce Refl :: FEAT_JSCVT :~: True of Refl -> k
  
  queryFEAT_JSCVT :: Maybe (Dict HasFEAT_JSCVT)
  queryFEAT_JSCVT = case sFEAT_JSCVT of STrue -> unsafeAssumeFEAT_JSCVT (Just Dict); SFalse -> Nothing
  {-# NOINLINE queryFEAT_JSCVT #-}
  
  unsafeAssumeFEAT_LRCPC :: (HasFEAT_LRCPC => a) -> a
  unsafeAssumeFEAT_LRCPC k = case unsafeCoerce Refl :: FEAT_LRCPC :~: True of Refl -> k
  
  queryFEAT_LRCPC :: Maybe (Dict HasFEAT_LRCPC)
  queryFEAT_LRCPC = case sFEAT_LRCPC of STrue -> unsafeAssumeFEAT_LRCPC (Just Dict); SFalse -> Nothing
  {-# NOINLINE queryFEAT_LRCPC #-}
  
  unsafeAssumeFEAT_LRCPC2 :: (HasFEAT_LRCPC2 => a) -> a
  unsafeAssumeFEAT_LRCPC2 k = case unsafeCoerce Refl :: FEAT_LRCPC2 :~: True of Refl -> k
  
  queryFEAT_LRCPC2 :: Maybe (Dict HasFEAT_LRCPC2)
  queryFEAT_LRCPC2 = case sFEAT_LRCPC2 of STrue -> unsafeAssumeFEAT_LRCPC2 (Just Dict); SFalse -> Nothing
  {-# NOINLINE queryFEAT_LRCPC2 #-}
  
  unsafeAssumeFEAT_LSE :: (HasFEAT_LSE => a) -> a
  unsafeAssumeFEAT_LSE k = case unsafeCoerce Refl :: FEAT_LSE :~: True of Refl -> k
  
  queryFEAT_LSE :: Maybe (Dict HasFEAT_LSE)
  queryFEAT_LSE = case sFEAT_LSE of STrue -> unsafeAssumeFEAT_LSE (Just Dict); SFalse -> Nothing
  {-# NOINLINE queryFEAT_LSE #-}
  
  unsafeAssumeFEAT_LSE2 :: (HasFEAT_LSE2 => a) -> a
  unsafeAssumeFEAT_LSE2 k = case unsafeCoerce Refl :: FEAT_LSE2 :~: True of Refl -> k
  
  queryFEAT_LSE2 :: Maybe (Dict HasFEAT_LSE2)
  queryFEAT_LSE2 = case sFEAT_LSE2 of STrue -> unsafeAssumeFEAT_LSE2 (Just Dict); SFalse -> Nothing
  {-# NOINLINE queryFEAT_LSE2 #-}
  
  unsafeAssumeFEAT_PAuth :: (HasFEAT_PAuth => a) -> a
  unsafeAssumeFEAT_PAuth k = case unsafeCoerce Refl :: FEAT_PAuth :~: True of Refl -> k
  
  queryFEAT_PAuth :: Maybe (Dict HasFEAT_PAuth)
  queryFEAT_PAuth = case sFEAT_PAuth of STrue -> unsafeAssumeFEAT_PAuth (Just Dict); SFalse -> Nothing
  {-# NOINLINE queryFEAT_PAuth #-}
  
  unsafeAssumeFEAT_PAuth2 :: (HasFEAT_PAuth2 => a) -> a
  unsafeAssumeFEAT_PAuth2 k = case unsafeCoerce Refl :: FEAT_PAuth2 :~: True of Refl -> k
  
  queryFEAT_PAuth2 :: Maybe (Dict HasFEAT_PAuth2)
  queryFEAT_PAuth2 = case sFEAT_PAuth2 of STrue -> unsafeAssumeFEAT_PAuth2 (Just Dict); SFalse -> Nothing
  {-# NOINLINE queryFEAT_PAuth2 #-}
  
  unsafeAssumeFEAT_PMULL :: (HasFEAT_PMULL => a) -> a
  unsafeAssumeFEAT_PMULL k = case unsafeCoerce Refl :: FEAT_PMULL :~: True of Refl -> k
  
  queryFEAT_PMULL :: Maybe (Dict HasFEAT_PMULL)
  queryFEAT_PMULL = case sFEAT_PMULL of STrue -> unsafeAssumeFEAT_PMULL (Just Dict); SFalse -> Nothing
  {-# NOINLINE queryFEAT_PMULL #-}
  
  unsafeAssumeFEAT_RDM :: (HasFEAT_RDM => a) -> a
  unsafeAssumeFEAT_RDM k = case unsafeCoerce Refl :: FEAT_RDM :~: True of Refl -> k
  
  queryFEAT_RDM :: Maybe (Dict HasFEAT_RDM)
  queryFEAT_RDM = case sFEAT_RDM of STrue -> unsafeAssumeFEAT_RDM (Just Dict); SFalse -> Nothing
  {-# NOINLINE queryFEAT_RDM #-}
  
  unsafeAssumeFEAT_RPRES :: (HasFEAT_RPRES => a) -> a
  unsafeAssumeFEAT_RPRES k = case unsafeCoerce Refl :: FEAT_RPRES :~: True of Refl -> k
  
  queryFEAT_RPRES :: Maybe (Dict HasFEAT_RPRES)
  queryFEAT_RPRES = case sFEAT_RPRES of STrue -> unsafeAssumeFEAT_RPRES (Just Dict); SFalse -> Nothing
  {-# NOINLINE queryFEAT_RPRES #-}
  
  unsafeAssumeFEAT_SB :: (HasFEAT_SB => a) -> a
  unsafeAssumeFEAT_SB k = case unsafeCoerce Refl :: FEAT_SB :~: True of Refl -> k
  
  queryFEAT_SB :: Maybe (Dict HasFEAT_SB)
  queryFEAT_SB = case sFEAT_SB of STrue -> unsafeAssumeFEAT_SB (Just Dict); SFalse -> Nothing
  {-# NOINLINE queryFEAT_SB #-}
  
  unsafeAssumeFEAT_SHA1 :: (HasFEAT_SHA1 => a) -> a
  unsafeAssumeFEAT_SHA1 k = case unsafeCoerce Refl :: FEAT_SHA1 :~: True of Refl -> k
  
  queryFEAT_SHA1 :: Maybe (Dict HasFEAT_SHA1)
  queryFEAT_SHA1 = case sFEAT_SHA1 of STrue -> unsafeAssumeFEAT_SHA1 (Just Dict); SFalse -> Nothing
  {-# NOINLINE queryFEAT_SHA1 #-}
  
  unsafeAssumeFEAT_SHA256 :: (HasFEAT_SHA256 => a) -> a
  unsafeAssumeFEAT_SHA256 k = case unsafeCoerce Refl :: FEAT_SHA256 :~: True of Refl -> k
  
  queryFEAT_SHA256 :: Maybe (Dict HasFEAT_SHA256)
  queryFEAT_SHA256 = case sFEAT_SHA256 of STrue -> unsafeAssumeFEAT_SHA256 (Just Dict); SFalse -> Nothing
  {-# NOINLINE queryFEAT_SHA256 #-}
  
  unsafeAssumeFEAT_SHA3 :: (HasFEAT_SHA3 => a) -> a
  unsafeAssumeFEAT_SHA3 k = case unsafeCoerce Refl :: FEAT_SHA3 :~: True of Refl -> k
  
  queryFEAT_SHA3 :: Maybe (Dict HasFEAT_SHA3)
  queryFEAT_SHA3 = case sFEAT_SHA3 of STrue -> unsafeAssumeFEAT_SHA3 (Just Dict); SFalse -> Nothing
  {-# NOINLINE queryFEAT_SHA3 #-}
  
  unsafeAssumeFEAT_SHA512 :: (HasFEAT_SHA512 => a) -> a
  unsafeAssumeFEAT_SHA512 k = case unsafeCoerce Refl :: FEAT_SHA512 :~: True of Refl -> k
  
  queryFEAT_SHA512 :: Maybe (Dict HasFEAT_SHA512)
  queryFEAT_SHA512 = case sFEAT_SHA512 of STrue -> unsafeAssumeFEAT_SHA512 (Just Dict); SFalse -> Nothing
  {-# NOINLINE queryFEAT_SHA512 #-}
  
  unsafeAssumeFEAT_SME :: (HasFEAT_SME => a) -> a
  unsafeAssumeFEAT_SME k = case unsafeCoerce Refl :: FEAT_SME :~: True of Refl -> k
  
  queryFEAT_SME :: Maybe (Dict HasFEAT_SME)
  queryFEAT_SME = case sFEAT_SME of STrue -> unsafeAssumeFEAT_SME (Just Dict); SFalse -> Nothing
  {-# NOINLINE queryFEAT_SME #-}
  
  unsafeAssumeFEAT_SME_F64F64 :: (HasFEAT_SME_F64F64 => a) -> a
  unsafeAssumeFEAT_SME_F64F64 k = case unsafeCoerce Refl :: FEAT_SME_F64F64 :~: True of Refl -> k
  
  queryFEAT_SME_F64F64 :: Maybe (Dict HasFEAT_SME_F64F64)
  queryFEAT_SME_F64F64 = case sFEAT_SME_F64F64 of STrue -> unsafeAssumeFEAT_SME_F64F64 (Just Dict); SFalse -> Nothing
  {-# NOINLINE queryFEAT_SME_F64F64 #-}
  
  unsafeAssumeFEAT_SME_I16I64 :: (HasFEAT_SME_I16I64 => a) -> a
  unsafeAssumeFEAT_SME_I16I64 k = case unsafeCoerce Refl :: FEAT_SME_I16I64 :~: True of Refl -> k
  
  queryFEAT_SME_I16I64 :: Maybe (Dict HasFEAT_SME_I16I64)
  queryFEAT_SME_I16I64 = case sFEAT_SME_I16I64 of STrue -> unsafeAssumeFEAT_SME_I16I64 (Just Dict); SFalse -> Nothing
  {-# NOINLINE queryFEAT_SME_I16I64 #-}
  
  unsafeAssumeFEAT_SME2 :: (HasFEAT_SME2 => a) -> a
  unsafeAssumeFEAT_SME2 k = case unsafeCoerce Refl :: FEAT_SME2 :~: True of Refl -> k
  
  queryFEAT_SME2 :: Maybe (Dict HasFEAT_SME2)
  queryFEAT_SME2 = case sFEAT_SME2 of STrue -> unsafeAssumeFEAT_SME2 (Just Dict); SFalse -> Nothing
  {-# NOINLINE queryFEAT_SME2 #-}
  
  unsafeAssumeFEAT_SPECRES :: (HasFEAT_SPECRES => a) -> a
  unsafeAssumeFEAT_SPECRES k = case unsafeCoerce Refl :: FEAT_SPECRES :~: True of Refl -> k
  
  queryFEAT_SPECRES :: Maybe (Dict HasFEAT_SPECRES)
  queryFEAT_SPECRES = case sFEAT_SPECRES of STrue -> unsafeAssumeFEAT_SPECRES (Just Dict); SFalse -> Nothing
  {-# NOINLINE queryFEAT_SPECRES #-}
  
  unsafeAssumeFEAT_SSBS :: (HasFEAT_SSBS => a) -> a
  unsafeAssumeFEAT_SSBS k = case unsafeCoerce Refl :: FEAT_SSBS :~: True of Refl -> k
  
  queryFEAT_SSBS :: Maybe (Dict HasFEAT_SSBS)
  queryFEAT_SSBS = case sFEAT_SSBS of STrue -> unsafeAssumeFEAT_SSBS (Just Dict); SFalse -> Nothing
  {-# NOINLINE queryFEAT_SSBS #-}
  
  unsafeAssumeFEAT_SVE :: (HasFEAT_SVE => a) -> a
  unsafeAssumeFEAT_SVE k = case unsafeCoerce Refl :: FEAT_SVE :~: True of Refl -> k
  
  queryFEAT_SVE :: Maybe (Dict HasFEAT_SVE)
  queryFEAT_SVE = case sFEAT_SVE of STrue -> unsafeAssumeFEAT_SVE (Just Dict); SFalse -> Nothing
  {-# NOINLINE queryFEAT_SVE #-}
  
  unsafeAssumeFEAT_SVE2 :: (HasFEAT_SVE2 => a) -> a
  unsafeAssumeFEAT_SVE2 k = case unsafeCoerce Refl :: FEAT_SVE2 :~: True of Refl -> k
  
  queryFEAT_SVE2 :: Maybe (Dict HasFEAT_SVE2)
  queryFEAT_SVE2 = case sFEAT_SVE2 of STrue -> unsafeAssumeFEAT_SVE2 (Just Dict); SFalse -> Nothing
  {-# NOINLINE queryFEAT_SVE2 #-}
  
  unsafeAssumeFEAT_WFxT :: (HasFEAT_WFxT => a) -> a
  unsafeAssumeFEAT_WFxT k = case unsafeCoerce Refl :: FEAT_WFxT :~: True of Refl -> k
  
  queryFEAT_WFxT :: Maybe (Dict HasFEAT_WFxT)
  queryFEAT_WFxT = case sFEAT_WFxT of STrue -> unsafeAssumeFEAT_WFxT (Just Dict); SFalse -> Nothing
  {-# NOINLINE queryFEAT_WFxT #-}
  