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

class AESNI ~ True => HasAESNI
instance AESNI ~ True => HasAESNI

class BMI1 ~ True => HasBMI1
instance BMI1 ~ True => HasBMI1

class BMI2 ~ True => HasBMI2
instance BMI2 ~ True => HasBMI2

class GFNI ~ True => HasGFNI
instance GFNI ~ True => HasGFNI

class PCLMULQDQ ~ True => HasPCLMULQDQ
instance PCLMULQDQ ~ True => HasPCLMULQDQ

class POPCNT ~ True => HasPOPCNT
instance POPCNT ~ True => HasPOPCNT

class RDRAND ~ True => HasRDRAND
instance RDRAND ~ True => HasRDRAND

class SHA ~ True => HasSHA
instance SHA ~ True => HasSHA

class SSE3 ~ True => HasSSE3
instance SSE3 ~ True => HasSSE3

class (SSSE3 ~ True, HasSSE3) => HasSSSE3
instance (SSSE3 ~ True, HasSSE3) => HasSSSE3

class (SSE4_1 ~ True, HasSSSE3) => HasSSE4_1
instance (SSE4_1 ~ True, HasSSSE3) => HasSSE4_1

class (SSE4_2 ~ True, HasSSE4_1) => HasSSE4_2
instance (SSE4_2 ~ True, HasSSE4_1) => HasSSE4_2

class (AVX ~ True, HasSSE4_2) => HasAVX
instance (AVX ~ True, HasSSE4_2) => HasAVX

class (AVX2 ~ True, HasAVX) => HasAVX2
instance (AVX2 ~ True, HasAVX) => HasAVX2

class (F16C ~ True, HasAVX) => HasF16C
instance (F16C ~ True, HasAVX) => HasF16C

class (FMA ~ True, HasAVX) => HasFMA
instance (FMA ~ True, HasAVX) => HasFMA

class (AVX_VNNI ~ True, HasAVX2) => HasAVX_VNNI
instance (AVX_VNNI ~ True, HasAVX2) => HasAVX_VNNI

class (AVX512F ~ True, HasAVX2, HasF16C, HasFMA) => HasAVX512F
instance (AVX512F ~ True, HasAVX2, HasF16C, HasFMA) => HasAVX512F

class (AVX512VL ~ True, HasAVX512F) => HasAVX512VL
instance (AVX512VL ~ True, HasAVX512F) => HasAVX512VL

class (AVX512BW ~ True, HasAVX512F) => HasAVX512BW
instance (AVX512BW ~ True, HasAVX512F) => HasAVX512BW

class (AVX512DQ ~ True, HasAVX512F) => HasAVX512DQ
instance (AVX512DQ ~ True, HasAVX512F) => HasAVX512DQ

class (AVX512CD ~ True, HasAVX512F) => HasAVX512CD
instance (AVX512CD ~ True, HasAVX512F) => HasAVX512CD

class (AVX512_BF16 ~ True, HasAVX512BW) => HasAVX512_BF16
instance (AVX512_BF16 ~ True, HasAVX512BW) => HasAVX512_BF16

class (AVX512_BITALG ~ True, HasAVX512BW) => HasAVX512_BITALG
instance (AVX512_BITALG ~ True, HasAVX512BW) => HasAVX512_BITALG

class (AVX512_FP16 ~ True, HasAVX512BW) => HasAVX512_FP16
instance (AVX512_FP16 ~ True, HasAVX512BW) => HasAVX512_FP16

class (AVX512_IFMA ~ True, HasAVX512F) => HasAVX512_IFMA
instance (AVX512_IFMA ~ True, HasAVX512F) => HasAVX512_IFMA

class (AVX512_VBMI ~ True, HasAVX512BW) => HasAVX512_VBMI
instance (AVX512_VBMI ~ True, HasAVX512BW) => HasAVX512_VBMI

class (AVX512_VBMI2 ~ True, HasAVX512BW) => HasAVX512_VBMI2
instance (AVX512_VBMI2 ~ True, HasAVX512BW) => HasAVX512_VBMI2

class (AVX512_VNNI ~ True, HasAVX512F) => HasAVX512_VNNI
instance (AVX512_VNNI ~ True, HasAVX512F) => HasAVX512_VNNI

class (AVX512_VPOPCNTDQ ~ True, HasAVX512F) => HasAVX512_VPOPCNTDQ
instance (AVX512_VPOPCNTDQ ~ True, HasAVX512F) => HasAVX512_VPOPCNTDQ

class (AVX10_1 ~ True, HasAVX2, HasF16C, HasFMA) => HasAVX10_1
instance (AVX10_1 ~ True, HasAVX2, HasF16C, HasFMA) => HasAVX10_1

class (AVX10_2 ~ True, HasAVX10_1) => HasAVX10_2
instance (AVX10_2 ~ True, HasAVX10_1) => HasAVX10_2

class (VAES ~ True, HasAVX2, HasAESNI) => HasVAES
instance (VAES ~ True, HasAVX2, HasAESNI) => HasVAES

class (VPCLMULQDQ ~ True, HasAVX, HasPCLMULQDQ) => HasVPCLMULQDQ
instance (VPCLMULQDQ ~ True, HasAVX, HasPCLMULQDQ) => HasVPCLMULQDQ

class AMX_TILE ~ True => HasAMX_TILE
instance AMX_TILE ~ True => HasAMX_TILE

class (AMX_BF16 ~ True, HasAMX_TILE) => HasAMX_BF16
instance (AMX_BF16 ~ True, HasAMX_TILE) => HasAMX_BF16

class (AMX_FP16 ~ True, HasAMX_TILE) => HasAMX_FP16
instance (AMX_FP16 ~ True, HasAMX_TILE) => HasAMX_FP16

class (AMX_INT8 ~ True, HasAMX_TILE) => HasAMX_INT8
instance (AMX_INT8 ~ True, HasAMX_TILE) => HasAMX_INT8

unsafeAssumeAESNI :: (HasAESNI => a) -> a
unsafeAssumeAESNI :: forall a. (HasAESNI => a) -> a
unsafeAssumeAESNI HasAESNI => a
k = case (Any :~: Any) -> AESNI :~: 'True
forall a b. a -> b
unsafeCoerce Any :~: Any
forall {k} (a :: k). a :~: a
Refl :: AESNI :~: True of AESNI :~: 'True
Refl -> a
HasAESNI => a
k

queryAESNI :: Maybe (Dict HasAESNI)
queryAESNI :: Maybe (Dict HasAESNI)
queryAESNI = case SBool AESNI
sAESNI of SBool AESNI
STrue -> (HasAESNI => Maybe (Dict HasAESNI)) -> Maybe (Dict HasAESNI)
forall a. (HasAESNI => a) -> a
unsafeAssumeAESNI (Dict HasAESNI -> Maybe (Dict HasAESNI)
forall a. a -> Maybe a
Just Dict HasAESNI
forall (c :: Constraint). c => Dict c
Dict); SBool AESNI
SFalse -> Maybe (Dict HasAESNI)
forall a. Maybe a
Nothing
{-# NOINLINE queryAESNI #-}

unsafeAssumeBMI1 :: (HasBMI1 => a) -> a
unsafeAssumeBMI1 :: forall a. (HasBMI1 => a) -> a
unsafeAssumeBMI1 HasBMI1 => a
k = case (Any :~: Any) -> BMI1 :~: 'True
forall a b. a -> b
unsafeCoerce Any :~: Any
forall {k} (a :: k). a :~: a
Refl :: BMI1 :~: True of BMI1 :~: 'True
Refl -> a
HasBMI1 => a
k

queryBMI1 :: Maybe (Dict HasBMI1)
queryBMI1 :: Maybe (Dict HasBMI1)
queryBMI1 = case SBool BMI1
sBMI1 of SBool BMI1
STrue -> (HasBMI1 => Maybe (Dict HasBMI1)) -> Maybe (Dict HasBMI1)
forall a. (HasBMI1 => a) -> a
unsafeAssumeBMI1 (Dict HasBMI1 -> Maybe (Dict HasBMI1)
forall a. a -> Maybe a
Just Dict HasBMI1
forall (c :: Constraint). c => Dict c
Dict); SBool BMI1
SFalse -> Maybe (Dict HasBMI1)
forall a. Maybe a
Nothing
{-# NOINLINE queryBMI1 #-}

unsafeAssumeBMI2 :: (HasBMI2 => a) -> a
unsafeAssumeBMI2 :: forall a. (HasBMI2 => a) -> a
unsafeAssumeBMI2 HasBMI2 => a
k = case (Any :~: Any) -> BMI2 :~: 'True
forall a b. a -> b
unsafeCoerce Any :~: Any
forall {k} (a :: k). a :~: a
Refl :: BMI2 :~: True of BMI2 :~: 'True
Refl -> a
HasBMI2 => a
k

queryBMI2 :: Maybe (Dict HasBMI2)
queryBMI2 :: Maybe (Dict HasBMI2)
queryBMI2 = case SBool BMI2
sBMI2 of SBool BMI2
STrue -> (HasBMI2 => Maybe (Dict HasBMI2)) -> Maybe (Dict HasBMI2)
forall a. (HasBMI2 => a) -> a
unsafeAssumeBMI2 (Dict HasBMI2 -> Maybe (Dict HasBMI2)
forall a. a -> Maybe a
Just Dict HasBMI2
forall (c :: Constraint). c => Dict c
Dict); SBool BMI2
SFalse -> Maybe (Dict HasBMI2)
forall a. Maybe a
Nothing
{-# NOINLINE queryBMI2 #-}

unsafeAssumeGFNI :: (HasGFNI => a) -> a
unsafeAssumeGFNI :: forall a. (HasGFNI => a) -> a
unsafeAssumeGFNI HasGFNI => a
k = case (Any :~: Any) -> GFNI :~: 'True
forall a b. a -> b
unsafeCoerce Any :~: Any
forall {k} (a :: k). a :~: a
Refl :: GFNI :~: True of GFNI :~: 'True
Refl -> a
HasGFNI => a
k

queryGFNI :: Maybe (Dict HasGFNI)
queryGFNI :: Maybe (Dict HasGFNI)
queryGFNI = case SBool GFNI
sGFNI of SBool GFNI
STrue -> (HasGFNI => Maybe (Dict HasGFNI)) -> Maybe (Dict HasGFNI)
forall a. (HasGFNI => a) -> a
unsafeAssumeGFNI (Dict HasGFNI -> Maybe (Dict HasGFNI)
forall a. a -> Maybe a
Just Dict HasGFNI
forall (c :: Constraint). c => Dict c
Dict); SBool GFNI
SFalse -> Maybe (Dict HasGFNI)
forall a. Maybe a
Nothing
{-# NOINLINE queryGFNI #-}

unsafeAssumePCLMULQDQ :: (HasPCLMULQDQ => a) -> a
unsafeAssumePCLMULQDQ :: forall a. (HasPCLMULQDQ => a) -> a
unsafeAssumePCLMULQDQ HasPCLMULQDQ => a
k = case (Any :~: Any) -> PCLMULQDQ :~: 'True
forall a b. a -> b
unsafeCoerce Any :~: Any
forall {k} (a :: k). a :~: a
Refl :: PCLMULQDQ :~: True of PCLMULQDQ :~: 'True
Refl -> a
HasPCLMULQDQ => a
k

queryPCLMULQDQ :: Maybe (Dict HasPCLMULQDQ)
queryPCLMULQDQ :: Maybe (Dict HasPCLMULQDQ)
queryPCLMULQDQ = case SBool PCLMULQDQ
sPCLMULQDQ of SBool PCLMULQDQ
STrue -> (HasPCLMULQDQ => Maybe (Dict HasPCLMULQDQ))
-> Maybe (Dict HasPCLMULQDQ)
forall a. (HasPCLMULQDQ => a) -> a
unsafeAssumePCLMULQDQ (Dict HasPCLMULQDQ -> Maybe (Dict HasPCLMULQDQ)
forall a. a -> Maybe a
Just Dict HasPCLMULQDQ
forall (c :: Constraint). c => Dict c
Dict); SBool PCLMULQDQ
SFalse -> Maybe (Dict HasPCLMULQDQ)
forall a. Maybe a
Nothing
{-# NOINLINE queryPCLMULQDQ #-}

unsafeAssumePOPCNT :: (HasPOPCNT => a) -> a
unsafeAssumePOPCNT :: forall a. (HasPOPCNT => a) -> a
unsafeAssumePOPCNT HasPOPCNT => a
k = case (Any :~: Any) -> POPCNT :~: 'True
forall a b. a -> b
unsafeCoerce Any :~: Any
forall {k} (a :: k). a :~: a
Refl :: POPCNT :~: True of POPCNT :~: 'True
Refl -> a
HasPOPCNT => a
k

queryPOPCNT :: Maybe (Dict HasPOPCNT)
queryPOPCNT :: Maybe (Dict HasPOPCNT)
queryPOPCNT = case SBool POPCNT
sPOPCNT of SBool POPCNT
STrue -> (HasPOPCNT => Maybe (Dict HasPOPCNT)) -> Maybe (Dict HasPOPCNT)
forall a. (HasPOPCNT => a) -> a
unsafeAssumePOPCNT (Dict HasPOPCNT -> Maybe (Dict HasPOPCNT)
forall a. a -> Maybe a
Just Dict HasPOPCNT
forall (c :: Constraint). c => Dict c
Dict); SBool POPCNT
SFalse -> Maybe (Dict HasPOPCNT)
forall a. Maybe a
Nothing
{-# NOINLINE queryPOPCNT #-}

unsafeAssumeRDRAND :: (HasRDRAND => a) -> a
unsafeAssumeRDRAND :: forall a. (HasRDRAND => a) -> a
unsafeAssumeRDRAND HasRDRAND => a
k = case (Any :~: Any) -> RDRAND :~: 'True
forall a b. a -> b
unsafeCoerce Any :~: Any
forall {k} (a :: k). a :~: a
Refl :: RDRAND :~: True of RDRAND :~: 'True
Refl -> a
HasRDRAND => a
k

queryRDRAND :: Maybe (Dict HasRDRAND)
queryRDRAND :: Maybe (Dict HasRDRAND)
queryRDRAND = case SBool RDRAND
sRDRAND of SBool RDRAND
STrue -> (HasRDRAND => Maybe (Dict HasRDRAND)) -> Maybe (Dict HasRDRAND)
forall a. (HasRDRAND => a) -> a
unsafeAssumeRDRAND (Dict HasRDRAND -> Maybe (Dict HasRDRAND)
forall a. a -> Maybe a
Just Dict HasRDRAND
forall (c :: Constraint). c => Dict c
Dict); SBool RDRAND
SFalse -> Maybe (Dict HasRDRAND)
forall a. Maybe a
Nothing
{-# NOINLINE queryRDRAND #-}

unsafeAssumeSHA :: (HasSHA => a) -> a
unsafeAssumeSHA :: forall a. (HasSHA => a) -> a
unsafeAssumeSHA HasSHA => a
k = case (Any :~: Any) -> SHA :~: 'True
forall a b. a -> b
unsafeCoerce Any :~: Any
forall {k} (a :: k). a :~: a
Refl :: SHA :~: True of SHA :~: 'True
Refl -> a
HasSHA => a
k

querySHA :: Maybe (Dict HasSHA)
querySHA :: Maybe (Dict HasSHA)
querySHA = case SBool SHA
sSHA of SBool SHA
STrue -> (HasSHA => Maybe (Dict HasSHA)) -> Maybe (Dict HasSHA)
forall a. (HasSHA => a) -> a
unsafeAssumeSHA (Dict HasSHA -> Maybe (Dict HasSHA)
forall a. a -> Maybe a
Just Dict HasSHA
forall (c :: Constraint). c => Dict c
Dict); SBool SHA
SFalse -> Maybe (Dict HasSHA)
forall a. Maybe a
Nothing
{-# NOINLINE querySHA #-}

unsafeAssumeSSE3 :: (HasSSE3 => a) -> a
unsafeAssumeSSE3 :: forall a. (HasSSE3 => a) -> a
unsafeAssumeSSE3 HasSSE3 => a
k = case (Any :~: Any) -> SSE3 :~: 'True
forall a b. a -> b
unsafeCoerce Any :~: Any
forall {k} (a :: k). a :~: a
Refl :: SSE3 :~: True of SSE3 :~: 'True
Refl -> a
HasSSE3 => a
k

querySSE3 :: Maybe (Dict HasSSE3)
querySSE3 :: Maybe (Dict HasSSE3)
querySSE3 = case SBool SSE3
sSSE3 of SBool SSE3
STrue -> (HasSSE3 => Maybe (Dict HasSSE3)) -> Maybe (Dict HasSSE3)
forall a. (HasSSE3 => a) -> a
unsafeAssumeSSE3 (Dict HasSSE3 -> Maybe (Dict HasSSE3)
forall a. a -> Maybe a
Just Dict HasSSE3
forall (c :: Constraint). c => Dict c
Dict); SBool SSE3
SFalse -> Maybe (Dict HasSSE3)
forall a. Maybe a
Nothing
{-# NOINLINE querySSE3 #-}

unsafeAssumeSSSE3 :: (HasSSSE3 => a) -> a
unsafeAssumeSSSE3 :: forall a. (HasSSSE3 => a) -> a
unsafeAssumeSSSE3 HasSSSE3 => a
k = case (Any :~: Any) -> SSSE3 :~: 'True
forall a b. a -> b
unsafeCoerce Any :~: Any
forall {k} (a :: k). a :~: a
Refl :: SSSE3 :~: True of SSSE3 :~: 'True
Refl -> (HasSSE3 => a) -> a
forall a. (HasSSE3 => a) -> a
unsafeAssumeSSE3 a
HasSSSE3 => a
HasSSE3 => a
k

querySSSE3 :: Maybe (Dict HasSSSE3)
querySSSE3 :: Maybe (Dict HasSSSE3)
querySSSE3 = case SBool SSSE3
sSSSE3 of SBool SSSE3
STrue -> (HasSSSE3 => Maybe (Dict HasSSSE3)) -> Maybe (Dict HasSSSE3)
forall a. (HasSSSE3 => a) -> a
unsafeAssumeSSSE3 (Dict HasSSSE3 -> Maybe (Dict HasSSSE3)
forall a. a -> Maybe a
Just Dict HasSSSE3
forall (c :: Constraint). c => Dict c
Dict); SBool SSSE3
SFalse -> Maybe (Dict HasSSSE3)
forall a. Maybe a
Nothing
{-# NOINLINE querySSSE3 #-}

unsafeAssumeSSE4_1 :: (HasSSE4_1 => a) -> a
unsafeAssumeSSE4_1 :: forall a. (HasSSE4_1 => a) -> a
unsafeAssumeSSE4_1 HasSSE4_1 => a
k = case (Any :~: Any) -> SSE4_1 :~: 'True
forall a b. a -> b
unsafeCoerce Any :~: Any
forall {k} (a :: k). a :~: a
Refl :: SSE4_1 :~: True of SSE4_1 :~: 'True
Refl -> (HasSSSE3 => a) -> a
forall a. (HasSSSE3 => a) -> a
unsafeAssumeSSSE3 a
HasSSE4_1 => a
HasSSSE3 => a
k

querySSE4_1 :: Maybe (Dict HasSSE4_1)
querySSE4_1 :: Maybe (Dict HasSSE4_1)
querySSE4_1 = case SBool SSE4_1
sSSE4_1 of SBool SSE4_1
STrue -> (HasSSE4_1 => Maybe (Dict HasSSE4_1)) -> Maybe (Dict HasSSE4_1)
forall a. (HasSSE4_1 => a) -> a
unsafeAssumeSSE4_1 (Dict HasSSE4_1 -> Maybe (Dict HasSSE4_1)
forall a. a -> Maybe a
Just Dict HasSSE4_1
forall (c :: Constraint). c => Dict c
Dict); SBool SSE4_1
SFalse -> Maybe (Dict HasSSE4_1)
forall a. Maybe a
Nothing
{-# NOINLINE querySSE4_1 #-}

unsafeAssumeSSE4_2 :: (HasSSE4_2 => a) -> a
unsafeAssumeSSE4_2 :: forall a. (HasSSE4_2 => a) -> a
unsafeAssumeSSE4_2 HasSSE4_2 => a
k = case (Any :~: Any) -> SSE4_2 :~: 'True
forall a b. a -> b
unsafeCoerce Any :~: Any
forall {k} (a :: k). a :~: a
Refl :: SSE4_2 :~: True of SSE4_2 :~: 'True
Refl -> (HasSSE4_1 => a) -> a
forall a. (HasSSE4_1 => a) -> a
unsafeAssumeSSE4_1 a
HasSSE4_2 => a
HasSSE4_1 => a
k

querySSE4_2 :: Maybe (Dict HasSSE4_2)
querySSE4_2 :: Maybe (Dict HasSSE4_2)
querySSE4_2 = case SBool SSE4_2
sSSE4_2 of SBool SSE4_2
STrue -> (HasSSE4_2 => Maybe (Dict HasSSE4_2)) -> Maybe (Dict HasSSE4_2)
forall a. (HasSSE4_2 => a) -> a
unsafeAssumeSSE4_2 (Dict HasSSE4_2 -> Maybe (Dict HasSSE4_2)
forall a. a -> Maybe a
Just Dict HasSSE4_2
forall (c :: Constraint). c => Dict c
Dict); SBool SSE4_2
SFalse -> Maybe (Dict HasSSE4_2)
forall a. Maybe a
Nothing
{-# NOINLINE querySSE4_2 #-}

unsafeAssumeAVX :: (HasAVX => a) -> a
unsafeAssumeAVX :: forall a. (HasAVX => a) -> a
unsafeAssumeAVX HasAVX => a
k = case (Any :~: Any) -> AVX :~: 'True
forall a b. a -> b
unsafeCoerce Any :~: Any
forall {k} (a :: k). a :~: a
Refl :: AVX :~: True of AVX :~: 'True
Refl -> (HasSSE4_2 => a) -> a
forall a. (HasSSE4_2 => a) -> a
unsafeAssumeSSE4_2 a
HasAVX => a
HasSSE4_2 => a
k

queryAVX :: Maybe (Dict HasAVX)
queryAVX :: Maybe (Dict HasAVX)
queryAVX = case SBool AVX
sAVX of SBool AVX
STrue -> (HasAVX => Maybe (Dict HasAVX)) -> Maybe (Dict HasAVX)
forall a. (HasAVX => a) -> a
unsafeAssumeAVX (Dict HasAVX -> Maybe (Dict HasAVX)
forall a. a -> Maybe a
Just Dict HasAVX
forall (c :: Constraint). c => Dict c
Dict); SBool AVX
SFalse -> Maybe (Dict HasAVX)
forall a. Maybe a
Nothing
{-# NOINLINE queryAVX #-}

unsafeAssumeAVX2 :: (HasAVX2 => a) -> a
unsafeAssumeAVX2 :: forall a. (HasAVX2 => a) -> a
unsafeAssumeAVX2 HasAVX2 => a
k = case (Any :~: Any) -> AVX2 :~: 'True
forall a b. a -> b
unsafeCoerce Any :~: Any
forall {k} (a :: k). a :~: a
Refl :: AVX2 :~: True of AVX2 :~: 'True
Refl -> (HasAVX => a) -> a
forall a. (HasAVX => a) -> a
unsafeAssumeAVX a
HasAVX2 => a
HasAVX => a
k

queryAVX2 :: Maybe (Dict HasAVX2)
queryAVX2 :: Maybe (Dict HasAVX2)
queryAVX2 = case SBool AVX2
sAVX2 of SBool AVX2
STrue -> (HasAVX2 => Maybe (Dict HasAVX2)) -> Maybe (Dict HasAVX2)
forall a. (HasAVX2 => a) -> a
unsafeAssumeAVX2 (Dict HasAVX2 -> Maybe (Dict HasAVX2)
forall a. a -> Maybe a
Just Dict HasAVX2
forall (c :: Constraint). c => Dict c
Dict); SBool AVX2
SFalse -> Maybe (Dict HasAVX2)
forall a. Maybe a
Nothing
{-# NOINLINE queryAVX2 #-}

unsafeAssumeF16C :: (HasF16C => a) -> a
unsafeAssumeF16C :: forall a. (HasF16C => a) -> a
unsafeAssumeF16C HasF16C => a
k = case (Any :~: Any) -> F16C :~: 'True
forall a b. a -> b
unsafeCoerce Any :~: Any
forall {k} (a :: k). a :~: a
Refl :: F16C :~: True of F16C :~: 'True
Refl -> (HasAVX => a) -> a
forall a. (HasAVX => a) -> a
unsafeAssumeAVX a
HasF16C => a
HasAVX => a
k

queryF16C :: Maybe (Dict HasF16C)
queryF16C :: Maybe (Dict HasF16C)
queryF16C = case SBool F16C
sF16C of SBool F16C
STrue -> (HasF16C => Maybe (Dict HasF16C)) -> Maybe (Dict HasF16C)
forall a. (HasF16C => a) -> a
unsafeAssumeF16C (Dict HasF16C -> Maybe (Dict HasF16C)
forall a. a -> Maybe a
Just Dict HasF16C
forall (c :: Constraint). c => Dict c
Dict); SBool F16C
SFalse -> Maybe (Dict HasF16C)
forall a. Maybe a
Nothing
{-# NOINLINE queryF16C #-}

unsafeAssumeFMA :: (HasFMA => a) -> a
unsafeAssumeFMA :: forall a. (HasFMA => a) -> a
unsafeAssumeFMA HasFMA => a
k = case (Any :~: Any) -> FMA :~: 'True
forall a b. a -> b
unsafeCoerce Any :~: Any
forall {k} (a :: k). a :~: a
Refl :: FMA :~: True of FMA :~: 'True
Refl -> (HasAVX => a) -> a
forall a. (HasAVX => a) -> a
unsafeAssumeAVX a
HasFMA => a
HasAVX => a
k

queryFMA :: Maybe (Dict HasFMA)
queryFMA :: Maybe (Dict HasFMA)
queryFMA = case SBool FMA
sFMA of SBool FMA
STrue -> (HasFMA => Maybe (Dict HasFMA)) -> Maybe (Dict HasFMA)
forall a. (HasFMA => a) -> a
unsafeAssumeFMA (Dict HasFMA -> Maybe (Dict HasFMA)
forall a. a -> Maybe a
Just Dict HasFMA
forall (c :: Constraint). c => Dict c
Dict); SBool FMA
SFalse -> Maybe (Dict HasFMA)
forall a. Maybe a
Nothing
{-# NOINLINE queryFMA #-}

unsafeAssumeAVX_VNNI :: (HasAVX_VNNI => a) -> a
unsafeAssumeAVX_VNNI :: forall a. (HasAVX_VNNI => a) -> a
unsafeAssumeAVX_VNNI HasAVX_VNNI => a
k = case (Any :~: Any) -> AVX_VNNI :~: 'True
forall a b. a -> b
unsafeCoerce Any :~: Any
forall {k} (a :: k). a :~: a
Refl :: AVX_VNNI :~: True of AVX_VNNI :~: 'True
Refl -> (HasAVX2 => a) -> a
forall a. (HasAVX2 => a) -> a
unsafeAssumeAVX2 a
HasAVX_VNNI => a
HasAVX2 => a
k

queryAVX_VNNI :: Maybe (Dict HasAVX_VNNI)
queryAVX_VNNI :: Maybe (Dict HasAVX_VNNI)
queryAVX_VNNI = case SBool AVX_VNNI
sAVX_VNNI of SBool AVX_VNNI
STrue -> (HasAVX_VNNI => Maybe (Dict HasAVX_VNNI))
-> Maybe (Dict HasAVX_VNNI)
forall a. (HasAVX_VNNI => a) -> a
unsafeAssumeAVX_VNNI (Dict HasAVX_VNNI -> Maybe (Dict HasAVX_VNNI)
forall a. a -> Maybe a
Just Dict HasAVX_VNNI
forall (c :: Constraint). c => Dict c
Dict); SBool AVX_VNNI
SFalse -> Maybe (Dict HasAVX_VNNI)
forall a. Maybe a
Nothing
{-# NOINLINE queryAVX_VNNI #-}

unsafeAssumeAVX512F :: (HasAVX512F => a) -> a
unsafeAssumeAVX512F :: forall a. (HasAVX512F => a) -> a
unsafeAssumeAVX512F HasAVX512F => a
k = case (Any :~: Any) -> AVX512F :~: 'True
forall a b. a -> b
unsafeCoerce Any :~: Any
forall {k} (a :: k). a :~: a
Refl :: AVX512F :~: True of AVX512F :~: 'True
Refl -> (HasFMA => a) -> a
forall a. (HasFMA => a) -> a
unsafeAssumeFMA ((HasF16C => a) -> a
forall a. (HasF16C => a) -> a
unsafeAssumeF16C ((HasAVX2 => a) -> a
forall a. (HasAVX2 => a) -> a
unsafeAssumeAVX2 a
HasAVX512F => a
HasAVX2 => a
k))

queryAVX512F :: Maybe (Dict HasAVX512F)
queryAVX512F :: Maybe (Dict HasAVX512F)
queryAVX512F = case SBool AVX512F
sAVX512F of SBool AVX512F
STrue -> (HasAVX512F => Maybe (Dict HasAVX512F)) -> Maybe (Dict HasAVX512F)
forall a. (HasAVX512F => a) -> a
unsafeAssumeAVX512F (Dict HasAVX512F -> Maybe (Dict HasAVX512F)
forall a. a -> Maybe a
Just Dict HasAVX512F
forall (c :: Constraint). c => Dict c
Dict); SBool AVX512F
SFalse -> Maybe (Dict HasAVX512F)
forall a. Maybe a
Nothing
{-# NOINLINE queryAVX512F #-}

unsafeAssumeAVX512VL :: (HasAVX512VL => a) -> a
unsafeAssumeAVX512VL :: forall a. (HasAVX512VL => a) -> a
unsafeAssumeAVX512VL HasAVX512VL => a
k = case (Any :~: Any) -> AVX512VL :~: 'True
forall a b. a -> b
unsafeCoerce Any :~: Any
forall {k} (a :: k). a :~: a
Refl :: AVX512VL :~: True of AVX512VL :~: 'True
Refl -> (HasAVX512F => a) -> a
forall a. (HasAVX512F => a) -> a
unsafeAssumeAVX512F a
HasAVX512VL => a
HasAVX512F => a
k

queryAVX512VL :: Maybe (Dict HasAVX512VL)
queryAVX512VL :: Maybe (Dict HasAVX512VL)
queryAVX512VL = case SBool AVX512VL
sAVX512VL of SBool AVX512VL
STrue -> (HasAVX512VL => Maybe (Dict HasAVX512VL))
-> Maybe (Dict HasAVX512VL)
forall a. (HasAVX512VL => a) -> a
unsafeAssumeAVX512VL (Dict HasAVX512VL -> Maybe (Dict HasAVX512VL)
forall a. a -> Maybe a
Just Dict HasAVX512VL
forall (c :: Constraint). c => Dict c
Dict); SBool AVX512VL
SFalse -> Maybe (Dict HasAVX512VL)
forall a. Maybe a
Nothing
{-# NOINLINE queryAVX512VL #-}

unsafeAssumeAVX512BW :: (HasAVX512BW => a) -> a
unsafeAssumeAVX512BW :: forall a. (HasAVX512BW => a) -> a
unsafeAssumeAVX512BW HasAVX512BW => a
k = case (Any :~: Any) -> AVX512BW :~: 'True
forall a b. a -> b
unsafeCoerce Any :~: Any
forall {k} (a :: k). a :~: a
Refl :: AVX512BW :~: True of AVX512BW :~: 'True
Refl -> (HasAVX512F => a) -> a
forall a. (HasAVX512F => a) -> a
unsafeAssumeAVX512F a
HasAVX512BW => a
HasAVX512F => a
k

queryAVX512BW :: Maybe (Dict HasAVX512BW)
queryAVX512BW :: Maybe (Dict HasAVX512BW)
queryAVX512BW = case SBool AVX512BW
sAVX512BW of SBool AVX512BW
STrue -> (HasAVX512BW => Maybe (Dict HasAVX512BW))
-> Maybe (Dict HasAVX512BW)
forall a. (HasAVX512BW => a) -> a
unsafeAssumeAVX512BW (Dict HasAVX512BW -> Maybe (Dict HasAVX512BW)
forall a. a -> Maybe a
Just Dict HasAVX512BW
forall (c :: Constraint). c => Dict c
Dict); SBool AVX512BW
SFalse -> Maybe (Dict HasAVX512BW)
forall a. Maybe a
Nothing
{-# NOINLINE queryAVX512BW #-}

unsafeAssumeAVX512DQ :: (HasAVX512DQ => a) -> a
unsafeAssumeAVX512DQ :: forall a. (HasAVX512DQ => a) -> a
unsafeAssumeAVX512DQ HasAVX512DQ => a
k = case (Any :~: Any) -> AVX512DQ :~: 'True
forall a b. a -> b
unsafeCoerce Any :~: Any
forall {k} (a :: k). a :~: a
Refl :: AVX512DQ :~: True of AVX512DQ :~: 'True
Refl -> (HasAVX512F => a) -> a
forall a. (HasAVX512F => a) -> a
unsafeAssumeAVX512F a
HasAVX512DQ => a
HasAVX512F => a
k

queryAVX512DQ :: Maybe (Dict HasAVX512DQ)
queryAVX512DQ :: Maybe (Dict HasAVX512DQ)
queryAVX512DQ = case SBool AVX512DQ
sAVX512DQ of SBool AVX512DQ
STrue -> (HasAVX512DQ => Maybe (Dict HasAVX512DQ))
-> Maybe (Dict HasAVX512DQ)
forall a. (HasAVX512DQ => a) -> a
unsafeAssumeAVX512DQ (Dict HasAVX512DQ -> Maybe (Dict HasAVX512DQ)
forall a. a -> Maybe a
Just Dict HasAVX512DQ
forall (c :: Constraint). c => Dict c
Dict); SBool AVX512DQ
SFalse -> Maybe (Dict HasAVX512DQ)
forall a. Maybe a
Nothing
{-# NOINLINE queryAVX512DQ #-}

unsafeAssumeAVX512CD :: (HasAVX512CD => a) -> a
unsafeAssumeAVX512CD :: forall a. (HasAVX512CD => a) -> a
unsafeAssumeAVX512CD HasAVX512CD => a
k = case (Any :~: Any) -> AVX512CD :~: 'True
forall a b. a -> b
unsafeCoerce Any :~: Any
forall {k} (a :: k). a :~: a
Refl :: AVX512CD :~: True of AVX512CD :~: 'True
Refl -> (HasAVX512F => a) -> a
forall a. (HasAVX512F => a) -> a
unsafeAssumeAVX512F a
HasAVX512CD => a
HasAVX512F => a
k

queryAVX512CD :: Maybe (Dict HasAVX512CD)
queryAVX512CD :: Maybe (Dict HasAVX512CD)
queryAVX512CD = case SBool AVX512CD
sAVX512CD of SBool AVX512CD
STrue -> (HasAVX512CD => Maybe (Dict HasAVX512CD))
-> Maybe (Dict HasAVX512CD)
forall a. (HasAVX512CD => a) -> a
unsafeAssumeAVX512CD (Dict HasAVX512CD -> Maybe (Dict HasAVX512CD)
forall a. a -> Maybe a
Just Dict HasAVX512CD
forall (c :: Constraint). c => Dict c
Dict); SBool AVX512CD
SFalse -> Maybe (Dict HasAVX512CD)
forall a. Maybe a
Nothing
{-# NOINLINE queryAVX512CD #-}

unsafeAssumeAVX512_BF16 :: (HasAVX512_BF16 => a) -> a
unsafeAssumeAVX512_BF16 :: forall a. (HasAVX512_BF16 => a) -> a
unsafeAssumeAVX512_BF16 HasAVX512_BF16 => a
k = case (Any :~: Any) -> AVX512_BF16 :~: 'True
forall a b. a -> b
unsafeCoerce Any :~: Any
forall {k} (a :: k). a :~: a
Refl :: AVX512_BF16 :~: True of AVX512_BF16 :~: 'True
Refl -> (HasAVX512BW => a) -> a
forall a. (HasAVX512BW => a) -> a
unsafeAssumeAVX512BW a
HasAVX512_BF16 => a
HasAVX512BW => a
k

queryAVX512_BF16 :: Maybe (Dict HasAVX512_BF16)
queryAVX512_BF16 :: Maybe (Dict HasAVX512_BF16)
queryAVX512_BF16 = case SBool AVX512_BF16
sAVX512_BF16 of SBool AVX512_BF16
STrue -> (HasAVX512_BF16 => Maybe (Dict HasAVX512_BF16))
-> Maybe (Dict HasAVX512_BF16)
forall a. (HasAVX512_BF16 => a) -> a
unsafeAssumeAVX512_BF16 (Dict HasAVX512_BF16 -> Maybe (Dict HasAVX512_BF16)
forall a. a -> Maybe a
Just Dict HasAVX512_BF16
forall (c :: Constraint). c => Dict c
Dict); SBool AVX512_BF16
SFalse -> Maybe (Dict HasAVX512_BF16)
forall a. Maybe a
Nothing
{-# NOINLINE queryAVX512_BF16 #-}

unsafeAssumeAVX512_BITALG :: (HasAVX512_BITALG => a) -> a
unsafeAssumeAVX512_BITALG :: forall a. (HasAVX512_BITALG => a) -> a
unsafeAssumeAVX512_BITALG HasAVX512_BITALG => a
k = case (Any :~: Any) -> AVX512_BITALG :~: 'True
forall a b. a -> b
unsafeCoerce Any :~: Any
forall {k} (a :: k). a :~: a
Refl :: AVX512_BITALG :~: True of AVX512_BITALG :~: 'True
Refl -> (HasAVX512BW => a) -> a
forall a. (HasAVX512BW => a) -> a
unsafeAssumeAVX512BW a
HasAVX512_BITALG => a
HasAVX512BW => a
k

queryAVX512_BITALG :: Maybe (Dict HasAVX512_BITALG)
queryAVX512_BITALG :: Maybe (Dict HasAVX512_BITALG)
queryAVX512_BITALG = case SBool AVX512_BITALG
sAVX512_BITALG of SBool AVX512_BITALG
STrue -> (HasAVX512_BITALG => Maybe (Dict HasAVX512_BITALG))
-> Maybe (Dict HasAVX512_BITALG)
forall a. (HasAVX512_BITALG => a) -> a
unsafeAssumeAVX512_BITALG (Dict HasAVX512_BITALG -> Maybe (Dict HasAVX512_BITALG)
forall a. a -> Maybe a
Just Dict HasAVX512_BITALG
forall (c :: Constraint). c => Dict c
Dict); SBool AVX512_BITALG
SFalse -> Maybe (Dict HasAVX512_BITALG)
forall a. Maybe a
Nothing
{-# NOINLINE queryAVX512_BITALG #-}

unsafeAssumeAVX512_FP16 :: (HasAVX512_FP16 => a) -> a
unsafeAssumeAVX512_FP16 :: forall a. (HasAVX512_FP16 => a) -> a
unsafeAssumeAVX512_FP16 HasAVX512_FP16 => a
k = case (Any :~: Any) -> AVX512_FP16 :~: 'True
forall a b. a -> b
unsafeCoerce Any :~: Any
forall {k} (a :: k). a :~: a
Refl :: AVX512_FP16 :~: True of AVX512_FP16 :~: 'True
Refl -> (HasAVX512BW => a) -> a
forall a. (HasAVX512BW => a) -> a
unsafeAssumeAVX512BW a
HasAVX512_FP16 => a
HasAVX512BW => a
k

queryAVX512_FP16 :: Maybe (Dict HasAVX512_FP16)
queryAVX512_FP16 :: Maybe (Dict HasAVX512_FP16)
queryAVX512_FP16 = case SBool AVX512_FP16
sAVX512_FP16 of SBool AVX512_FP16
STrue -> (HasAVX512_FP16 => Maybe (Dict HasAVX512_FP16))
-> Maybe (Dict HasAVX512_FP16)
forall a. (HasAVX512_FP16 => a) -> a
unsafeAssumeAVX512_FP16 (Dict HasAVX512_FP16 -> Maybe (Dict HasAVX512_FP16)
forall a. a -> Maybe a
Just Dict HasAVX512_FP16
forall (c :: Constraint). c => Dict c
Dict); SBool AVX512_FP16
SFalse -> Maybe (Dict HasAVX512_FP16)
forall a. Maybe a
Nothing
{-# NOINLINE queryAVX512_FP16 #-}

unsafeAssumeAVX512_IFMA :: (HasAVX512_IFMA => a) -> a
unsafeAssumeAVX512_IFMA :: forall a. (HasAVX512_IFMA => a) -> a
unsafeAssumeAVX512_IFMA HasAVX512_IFMA => a
k = case (Any :~: Any) -> AVX512_IFMA :~: 'True
forall a b. a -> b
unsafeCoerce Any :~: Any
forall {k} (a :: k). a :~: a
Refl :: AVX512_IFMA :~: True of AVX512_IFMA :~: 'True
Refl -> (HasAVX512F => a) -> a
forall a. (HasAVX512F => a) -> a
unsafeAssumeAVX512F a
HasAVX512_IFMA => a
HasAVX512F => a
k

queryAVX512_IFMA :: Maybe (Dict HasAVX512_IFMA)
queryAVX512_IFMA :: Maybe (Dict HasAVX512_IFMA)
queryAVX512_IFMA = case SBool AVX512_IFMA
sAVX512_IFMA of SBool AVX512_IFMA
STrue -> (HasAVX512_IFMA => Maybe (Dict HasAVX512_IFMA))
-> Maybe (Dict HasAVX512_IFMA)
forall a. (HasAVX512_IFMA => a) -> a
unsafeAssumeAVX512_IFMA (Dict HasAVX512_IFMA -> Maybe (Dict HasAVX512_IFMA)
forall a. a -> Maybe a
Just Dict HasAVX512_IFMA
forall (c :: Constraint). c => Dict c
Dict); SBool AVX512_IFMA
SFalse -> Maybe (Dict HasAVX512_IFMA)
forall a. Maybe a
Nothing
{-# NOINLINE queryAVX512_IFMA #-}

unsafeAssumeAVX512_VBMI :: (HasAVX512_VBMI => a) -> a
unsafeAssumeAVX512_VBMI :: forall a. (HasAVX512_VBMI => a) -> a
unsafeAssumeAVX512_VBMI HasAVX512_VBMI => a
k = case (Any :~: Any) -> AVX512_VBMI :~: 'True
forall a b. a -> b
unsafeCoerce Any :~: Any
forall {k} (a :: k). a :~: a
Refl :: AVX512_VBMI :~: True of AVX512_VBMI :~: 'True
Refl -> (HasAVX512BW => a) -> a
forall a. (HasAVX512BW => a) -> a
unsafeAssumeAVX512BW a
HasAVX512_VBMI => a
HasAVX512BW => a
k

queryAVX512_VBMI :: Maybe (Dict HasAVX512_VBMI)
queryAVX512_VBMI :: Maybe (Dict HasAVX512_VBMI)
queryAVX512_VBMI = case SBool AVX512_VBMI
sAVX512_VBMI of SBool AVX512_VBMI
STrue -> (HasAVX512_VBMI => Maybe (Dict HasAVX512_VBMI))
-> Maybe (Dict HasAVX512_VBMI)
forall a. (HasAVX512_VBMI => a) -> a
unsafeAssumeAVX512_VBMI (Dict HasAVX512_VBMI -> Maybe (Dict HasAVX512_VBMI)
forall a. a -> Maybe a
Just Dict HasAVX512_VBMI
forall (c :: Constraint). c => Dict c
Dict); SBool AVX512_VBMI
SFalse -> Maybe (Dict HasAVX512_VBMI)
forall a. Maybe a
Nothing
{-# NOINLINE queryAVX512_VBMI #-}

unsafeAssumeAVX512_VBMI2 :: (HasAVX512_VBMI2 => a) -> a
unsafeAssumeAVX512_VBMI2 :: forall a. (HasAVX512_VBMI2 => a) -> a
unsafeAssumeAVX512_VBMI2 HasAVX512_VBMI2 => a
k = case (Any :~: Any) -> AVX512_VBMI2 :~: 'True
forall a b. a -> b
unsafeCoerce Any :~: Any
forall {k} (a :: k). a :~: a
Refl :: AVX512_VBMI2 :~: True of AVX512_VBMI2 :~: 'True
Refl -> (HasAVX512BW => a) -> a
forall a. (HasAVX512BW => a) -> a
unsafeAssumeAVX512BW a
HasAVX512_VBMI2 => a
HasAVX512BW => a
k

queryAVX512_VBMI2 :: Maybe (Dict HasAVX512_VBMI2)
queryAVX512_VBMI2 :: Maybe (Dict HasAVX512_VBMI2)
queryAVX512_VBMI2 = case SBool AVX512_VBMI2
sAVX512_VBMI2 of SBool AVX512_VBMI2
STrue -> (HasAVX512_VBMI2 => Maybe (Dict HasAVX512_VBMI2))
-> Maybe (Dict HasAVX512_VBMI2)
forall a. (HasAVX512_VBMI2 => a) -> a
unsafeAssumeAVX512_VBMI2 (Dict HasAVX512_VBMI2 -> Maybe (Dict HasAVX512_VBMI2)
forall a. a -> Maybe a
Just Dict HasAVX512_VBMI2
forall (c :: Constraint). c => Dict c
Dict); SBool AVX512_VBMI2
SFalse -> Maybe (Dict HasAVX512_VBMI2)
forall a. Maybe a
Nothing
{-# NOINLINE queryAVX512_VBMI2 #-}

unsafeAssumeAVX512_VNNI :: (HasAVX512_VNNI => a) -> a
unsafeAssumeAVX512_VNNI :: forall a. (HasAVX512_VNNI => a) -> a
unsafeAssumeAVX512_VNNI HasAVX512_VNNI => a
k = case (Any :~: Any) -> AVX512_VNNI :~: 'True
forall a b. a -> b
unsafeCoerce Any :~: Any
forall {k} (a :: k). a :~: a
Refl :: AVX512_VNNI :~: True of AVX512_VNNI :~: 'True
Refl -> (HasAVX512F => a) -> a
forall a. (HasAVX512F => a) -> a
unsafeAssumeAVX512F a
HasAVX512_VNNI => a
HasAVX512F => a
k

queryAVX512_VNNI :: Maybe (Dict HasAVX512_VNNI)
queryAVX512_VNNI :: Maybe (Dict HasAVX512_VNNI)
queryAVX512_VNNI = case SBool AVX512_VNNI
sAVX512_VNNI of SBool AVX512_VNNI
STrue -> (HasAVX512_VNNI => Maybe (Dict HasAVX512_VNNI))
-> Maybe (Dict HasAVX512_VNNI)
forall a. (HasAVX512_VNNI => a) -> a
unsafeAssumeAVX512_VNNI (Dict HasAVX512_VNNI -> Maybe (Dict HasAVX512_VNNI)
forall a. a -> Maybe a
Just Dict HasAVX512_VNNI
forall (c :: Constraint). c => Dict c
Dict); SBool AVX512_VNNI
SFalse -> Maybe (Dict HasAVX512_VNNI)
forall a. Maybe a
Nothing
{-# NOINLINE queryAVX512_VNNI #-}

unsafeAssumeAVX512_VPOPCNTDQ :: (HasAVX512_VPOPCNTDQ => a) -> a
unsafeAssumeAVX512_VPOPCNTDQ :: forall a. (HasAVX512_VPOPCNTDQ => a) -> a
unsafeAssumeAVX512_VPOPCNTDQ HasAVX512_VPOPCNTDQ => a
k = case (Any :~: Any) -> AVX512_VPOPCNTDQ :~: 'True
forall a b. a -> b
unsafeCoerce Any :~: Any
forall {k} (a :: k). a :~: a
Refl :: AVX512_VPOPCNTDQ :~: True of AVX512_VPOPCNTDQ :~: 'True
Refl -> (HasAVX512F => a) -> a
forall a. (HasAVX512F => a) -> a
unsafeAssumeAVX512F a
HasAVX512_VPOPCNTDQ => a
HasAVX512F => a
k

queryAVX512_VPOPCNTDQ :: Maybe (Dict HasAVX512_VPOPCNTDQ)
queryAVX512_VPOPCNTDQ :: Maybe (Dict HasAVX512_VPOPCNTDQ)
queryAVX512_VPOPCNTDQ = case SBool AVX512_VPOPCNTDQ
sAVX512_VPOPCNTDQ of SBool AVX512_VPOPCNTDQ
STrue -> (HasAVX512_VPOPCNTDQ => Maybe (Dict HasAVX512_VPOPCNTDQ))
-> Maybe (Dict HasAVX512_VPOPCNTDQ)
forall a. (HasAVX512_VPOPCNTDQ => a) -> a
unsafeAssumeAVX512_VPOPCNTDQ (Dict HasAVX512_VPOPCNTDQ -> Maybe (Dict HasAVX512_VPOPCNTDQ)
forall a. a -> Maybe a
Just Dict HasAVX512_VPOPCNTDQ
forall (c :: Constraint). c => Dict c
Dict); SBool AVX512_VPOPCNTDQ
SFalse -> Maybe (Dict HasAVX512_VPOPCNTDQ)
forall a. Maybe a
Nothing
{-# NOINLINE queryAVX512_VPOPCNTDQ #-}

unsafeAssumeAVX10_1 :: (HasAVX10_1 => a) -> a
unsafeAssumeAVX10_1 :: forall a. (HasAVX10_1 => a) -> a
unsafeAssumeAVX10_1 HasAVX10_1 => a
k = case (Any :~: Any) -> AVX10_1 :~: 'True
forall a b. a -> b
unsafeCoerce Any :~: Any
forall {k} (a :: k). a :~: a
Refl :: AVX10_1 :~: True of AVX10_1 :~: 'True
Refl -> (HasFMA => a) -> a
forall a. (HasFMA => a) -> a
unsafeAssumeFMA ((HasF16C => a) -> a
forall a. (HasF16C => a) -> a
unsafeAssumeF16C ((HasAVX2 => a) -> a
forall a. (HasAVX2 => a) -> a
unsafeAssumeAVX2 a
HasAVX10_1 => a
HasAVX2 => a
k))

queryAVX10_1 :: Maybe (Dict HasAVX10_1)
queryAVX10_1 :: Maybe (Dict HasAVX10_1)
queryAVX10_1 = case SBool AVX10_1
sAVX10_1 of SBool AVX10_1
STrue -> (HasAVX10_1 => Maybe (Dict HasAVX10_1)) -> Maybe (Dict HasAVX10_1)
forall a. (HasAVX10_1 => a) -> a
unsafeAssumeAVX10_1 (Dict HasAVX10_1 -> Maybe (Dict HasAVX10_1)
forall a. a -> Maybe a
Just Dict HasAVX10_1
forall (c :: Constraint). c => Dict c
Dict); SBool AVX10_1
SFalse -> Maybe (Dict HasAVX10_1)
forall a. Maybe a
Nothing
{-# NOINLINE queryAVX10_1 #-}

unsafeAssumeAVX10_2 :: (HasAVX10_2 => a) -> a
unsafeAssumeAVX10_2 :: forall a. (HasAVX10_2 => a) -> a
unsafeAssumeAVX10_2 HasAVX10_2 => a
k = case (Any :~: Any) -> AVX10_2 :~: 'True
forall a b. a -> b
unsafeCoerce Any :~: Any
forall {k} (a :: k). a :~: a
Refl :: AVX10_2 :~: True of AVX10_2 :~: 'True
Refl -> (HasAVX10_1 => a) -> a
forall a. (HasAVX10_1 => a) -> a
unsafeAssumeAVX10_1 a
HasAVX10_2 => a
HasAVX10_1 => a
k

queryAVX10_2 :: Maybe (Dict HasAVX10_2)
queryAVX10_2 :: Maybe (Dict HasAVX10_2)
queryAVX10_2 = case SBool AVX10_2
sAVX10_2 of SBool AVX10_2
STrue -> (HasAVX10_2 => Maybe (Dict HasAVX10_2)) -> Maybe (Dict HasAVX10_2)
forall a. (HasAVX10_2 => a) -> a
unsafeAssumeAVX10_2 (Dict HasAVX10_2 -> Maybe (Dict HasAVX10_2)
forall a. a -> Maybe a
Just Dict HasAVX10_2
forall (c :: Constraint). c => Dict c
Dict); SBool AVX10_2
SFalse -> Maybe (Dict HasAVX10_2)
forall a. Maybe a
Nothing
{-# NOINLINE queryAVX10_2 #-}

unsafeAssumeVAES :: (HasVAES => a) -> a
unsafeAssumeVAES :: forall a. (HasVAES => a) -> a
unsafeAssumeVAES HasVAES => a
k = case (Any :~: Any) -> VAES :~: 'True
forall a b. a -> b
unsafeCoerce Any :~: Any
forall {k} (a :: k). a :~: a
Refl :: VAES :~: True of VAES :~: 'True
Refl -> (HasAESNI => a) -> a
forall a. (HasAESNI => a) -> a
unsafeAssumeAESNI ((HasAVX2 => a) -> a
forall a. (HasAVX2 => a) -> a
unsafeAssumeAVX2 a
HasVAES => a
HasAVX2 => a
k)

queryVAES :: Maybe (Dict HasVAES)
queryVAES :: Maybe (Dict HasVAES)
queryVAES = case SBool VAES
sVAES of SBool VAES
STrue -> (HasVAES => Maybe (Dict HasVAES)) -> Maybe (Dict HasVAES)
forall a. (HasVAES => a) -> a
unsafeAssumeVAES (Dict HasVAES -> Maybe (Dict HasVAES)
forall a. a -> Maybe a
Just Dict HasVAES
forall (c :: Constraint). c => Dict c
Dict); SBool VAES
SFalse -> Maybe (Dict HasVAES)
forall a. Maybe a
Nothing
{-# NOINLINE queryVAES #-}

unsafeAssumeVPCLMULQDQ :: (HasVPCLMULQDQ => a) -> a
unsafeAssumeVPCLMULQDQ :: forall a. (HasVPCLMULQDQ => a) -> a
unsafeAssumeVPCLMULQDQ HasVPCLMULQDQ => a
k = case (Any :~: Any) -> VPCLMULQDQ :~: 'True
forall a b. a -> b
unsafeCoerce Any :~: Any
forall {k} (a :: k). a :~: a
Refl :: VPCLMULQDQ :~: True of VPCLMULQDQ :~: 'True
Refl -> (HasPCLMULQDQ => a) -> a
forall a. (HasPCLMULQDQ => a) -> a
unsafeAssumePCLMULQDQ ((HasAVX => a) -> a
forall a. (HasAVX => a) -> a
unsafeAssumeAVX a
HasVPCLMULQDQ => a
HasAVX => a
k)

queryVPCLMULQDQ :: Maybe (Dict HasVPCLMULQDQ)
queryVPCLMULQDQ :: Maybe (Dict HasVPCLMULQDQ)
queryVPCLMULQDQ = case SBool VPCLMULQDQ
sVPCLMULQDQ of SBool VPCLMULQDQ
STrue -> (HasVPCLMULQDQ => Maybe (Dict HasVPCLMULQDQ))
-> Maybe (Dict HasVPCLMULQDQ)
forall a. (HasVPCLMULQDQ => a) -> a
unsafeAssumeVPCLMULQDQ (Dict HasVPCLMULQDQ -> Maybe (Dict HasVPCLMULQDQ)
forall a. a -> Maybe a
Just Dict HasVPCLMULQDQ
forall (c :: Constraint). c => Dict c
Dict); SBool VPCLMULQDQ
SFalse -> Maybe (Dict HasVPCLMULQDQ)
forall a. Maybe a
Nothing
{-# NOINLINE queryVPCLMULQDQ #-}

unsafeAssumeAMX_TILE :: (HasAMX_TILE => a) -> a
unsafeAssumeAMX_TILE :: forall a. (HasAMX_TILE => a) -> a
unsafeAssumeAMX_TILE HasAMX_TILE => a
k = case (Any :~: Any) -> AMX_TILE :~: 'True
forall a b. a -> b
unsafeCoerce Any :~: Any
forall {k} (a :: k). a :~: a
Refl :: AMX_TILE :~: True of AMX_TILE :~: 'True
Refl -> a
HasAMX_TILE => a
k

queryAMX_TILE :: Maybe (Dict HasAMX_TILE)
queryAMX_TILE :: Maybe (Dict HasAMX_TILE)
queryAMX_TILE = case SBool AMX_TILE
sAMX_TILE of SBool AMX_TILE
STrue -> (HasAMX_TILE => Maybe (Dict HasAMX_TILE))
-> Maybe (Dict HasAMX_TILE)
forall a. (HasAMX_TILE => a) -> a
unsafeAssumeAMX_TILE (Dict HasAMX_TILE -> Maybe (Dict HasAMX_TILE)
forall a. a -> Maybe a
Just Dict HasAMX_TILE
forall (c :: Constraint). c => Dict c
Dict); SBool AMX_TILE
SFalse -> Maybe (Dict HasAMX_TILE)
forall a. Maybe a
Nothing
{-# NOINLINE queryAMX_TILE #-}

unsafeAssumeAMX_BF16 :: (HasAMX_BF16 => a) -> a
unsafeAssumeAMX_BF16 :: forall a. (HasAMX_BF16 => a) -> a
unsafeAssumeAMX_BF16 HasAMX_BF16 => a
k = case (Any :~: Any) -> AMX_BF16 :~: 'True
forall a b. a -> b
unsafeCoerce Any :~: Any
forall {k} (a :: k). a :~: a
Refl :: AMX_BF16 :~: True of AMX_BF16 :~: 'True
Refl -> (HasAMX_TILE => a) -> a
forall a. (HasAMX_TILE => a) -> a
unsafeAssumeAMX_TILE a
HasAMX_BF16 => a
HasAMX_TILE => a
k

queryAMX_BF16 :: Maybe (Dict HasAMX_BF16)
queryAMX_BF16 :: Maybe (Dict HasAMX_BF16)
queryAMX_BF16 = case SBool AMX_BF16
sAMX_BF16 of SBool AMX_BF16
STrue -> (HasAMX_BF16 => Maybe (Dict HasAMX_BF16))
-> Maybe (Dict HasAMX_BF16)
forall a. (HasAMX_BF16 => a) -> a
unsafeAssumeAMX_BF16 (Dict HasAMX_BF16 -> Maybe (Dict HasAMX_BF16)
forall a. a -> Maybe a
Just Dict HasAMX_BF16
forall (c :: Constraint). c => Dict c
Dict); SBool AMX_BF16
SFalse -> Maybe (Dict HasAMX_BF16)
forall a. Maybe a
Nothing
{-# NOINLINE queryAMX_BF16 #-}

unsafeAssumeAMX_FP16 :: (HasAMX_FP16 => a) -> a
unsafeAssumeAMX_FP16 :: forall a. (HasAMX_FP16 => a) -> a
unsafeAssumeAMX_FP16 HasAMX_FP16 => a
k = case (Any :~: Any) -> AMX_FP16 :~: 'True
forall a b. a -> b
unsafeCoerce Any :~: Any
forall {k} (a :: k). a :~: a
Refl :: AMX_FP16 :~: True of AMX_FP16 :~: 'True
Refl -> (HasAMX_TILE => a) -> a
forall a. (HasAMX_TILE => a) -> a
unsafeAssumeAMX_TILE a
HasAMX_FP16 => a
HasAMX_TILE => a
k

queryAMX_FP16 :: Maybe (Dict HasAMX_FP16)
queryAMX_FP16 :: Maybe (Dict HasAMX_FP16)
queryAMX_FP16 = case SBool AMX_FP16
sAMX_FP16 of SBool AMX_FP16
STrue -> (HasAMX_FP16 => Maybe (Dict HasAMX_FP16))
-> Maybe (Dict HasAMX_FP16)
forall a. (HasAMX_FP16 => a) -> a
unsafeAssumeAMX_FP16 (Dict HasAMX_FP16 -> Maybe (Dict HasAMX_FP16)
forall a. a -> Maybe a
Just Dict HasAMX_FP16
forall (c :: Constraint). c => Dict c
Dict); SBool AMX_FP16
SFalse -> Maybe (Dict HasAMX_FP16)
forall a. Maybe a
Nothing
{-# NOINLINE queryAMX_FP16 #-}

unsafeAssumeAMX_INT8 :: (HasAMX_INT8 => a) -> a
unsafeAssumeAMX_INT8 :: forall a. (HasAMX_INT8 => a) -> a
unsafeAssumeAMX_INT8 HasAMX_INT8 => a
k = case (Any :~: Any) -> AMX_INT8 :~: 'True
forall a b. a -> b
unsafeCoerce Any :~: Any
forall {k} (a :: k). a :~: a
Refl :: AMX_INT8 :~: True of AMX_INT8 :~: 'True
Refl -> (HasAMX_TILE => a) -> a
forall a. (HasAMX_TILE => a) -> a
unsafeAssumeAMX_TILE a
HasAMX_INT8 => a
HasAMX_TILE => a
k

queryAMX_INT8 :: Maybe (Dict HasAMX_INT8)
queryAMX_INT8 :: Maybe (Dict HasAMX_INT8)
queryAMX_INT8 = case SBool AMX_INT8
sAMX_INT8 of SBool AMX_INT8
STrue -> (HasAMX_INT8 => Maybe (Dict HasAMX_INT8))
-> Maybe (Dict HasAMX_INT8)
forall a. (HasAMX_INT8 => a) -> a
unsafeAssumeAMX_INT8 (Dict HasAMX_INT8 -> Maybe (Dict HasAMX_INT8)
forall a. a -> Maybe a
Just Dict HasAMX_INT8
forall (c :: Constraint). c => Dict c
Dict); SBool AMX_INT8
SFalse -> Maybe (Dict HasAMX_INT8)
forall a. Maybe a
Nothing
{-# NOINLINE queryAMX_INT8 #-}