Unsafe.hs

{-# 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 k = case unsafeCoerce Refl :: AESNI :~: True of Refl -> k

queryAESNI :: Maybe (Dict HasAESNI)
queryAESNI = case sAESNI of STrue -> unsafeAssumeAESNI (Just Dict); SFalse -> Nothing
{-# NOINLINE queryAESNI #-}

unsafeAssumeBMI1 :: (HasBMI1 => a) -> a
unsafeAssumeBMI1 k = case unsafeCoerce Refl :: BMI1 :~: True of Refl -> k

queryBMI1 :: Maybe (Dict HasBMI1)
queryBMI1 = case sBMI1 of STrue -> unsafeAssumeBMI1 (Just Dict); SFalse -> Nothing
{-# NOINLINE queryBMI1 #-}

unsafeAssumeBMI2 :: (HasBMI2 => a) -> a
unsafeAssumeBMI2 k = case unsafeCoerce Refl :: BMI2 :~: True of Refl -> k

queryBMI2 :: Maybe (Dict HasBMI2)
queryBMI2 = case sBMI2 of STrue -> unsafeAssumeBMI2 (Just Dict); SFalse -> Nothing
{-# NOINLINE queryBMI2 #-}

unsafeAssumeGFNI :: (HasGFNI => a) -> a
unsafeAssumeGFNI k = case unsafeCoerce Refl :: GFNI :~: True of Refl -> k

queryGFNI :: Maybe (Dict HasGFNI)
queryGFNI = case sGFNI of STrue -> unsafeAssumeGFNI (Just Dict); SFalse -> Nothing
{-# NOINLINE queryGFNI #-}

unsafeAssumePCLMULQDQ :: (HasPCLMULQDQ => a) -> a
unsafeAssumePCLMULQDQ k = case unsafeCoerce Refl :: PCLMULQDQ :~: True of Refl -> k

queryPCLMULQDQ :: Maybe (Dict HasPCLMULQDQ)
queryPCLMULQDQ = case sPCLMULQDQ of STrue -> unsafeAssumePCLMULQDQ (Just Dict); SFalse -> Nothing
{-# NOINLINE queryPCLMULQDQ #-}

unsafeAssumePOPCNT :: (HasPOPCNT => a) -> a
unsafeAssumePOPCNT k = case unsafeCoerce Refl :: POPCNT :~: True of Refl -> k

queryPOPCNT :: Maybe (Dict HasPOPCNT)
queryPOPCNT = case sPOPCNT of STrue -> unsafeAssumePOPCNT (Just Dict); SFalse -> Nothing
{-# NOINLINE queryPOPCNT #-}

unsafeAssumeRDRAND :: (HasRDRAND => a) -> a
unsafeAssumeRDRAND k = case unsafeCoerce Refl :: RDRAND :~: True of Refl -> k

queryRDRAND :: Maybe (Dict HasRDRAND)
queryRDRAND = case sRDRAND of STrue -> unsafeAssumeRDRAND (Just Dict); SFalse -> Nothing
{-# NOINLINE queryRDRAND #-}

unsafeAssumeSHA :: (HasSHA => a) -> a
unsafeAssumeSHA k = case unsafeCoerce Refl :: SHA :~: True of Refl -> k

querySHA :: Maybe (Dict HasSHA)
querySHA = case sSHA of STrue -> unsafeAssumeSHA (Just Dict); SFalse -> Nothing
{-# NOINLINE querySHA #-}

unsafeAssumeSSE3 :: (HasSSE3 => a) -> a
unsafeAssumeSSE3 k = case unsafeCoerce Refl :: SSE3 :~: True of Refl -> k

querySSE3 :: Maybe (Dict HasSSE3)
querySSE3 = case sSSE3 of STrue -> unsafeAssumeSSE3 (Just Dict); SFalse -> Nothing
{-# NOINLINE querySSE3 #-}

unsafeAssumeSSSE3 :: (HasSSSE3 => a) -> a
unsafeAssumeSSSE3 k = case unsafeCoerce Refl :: SSSE3 :~: True of Refl -> unsafeAssumeSSE3 k

querySSSE3 :: Maybe (Dict HasSSSE3)
querySSSE3 = case sSSSE3 of STrue -> unsafeAssumeSSSE3 (Just Dict); SFalse -> Nothing
{-# NOINLINE querySSSE3 #-}

unsafeAssumeSSE4_1 :: (HasSSE4_1 => a) -> a
unsafeAssumeSSE4_1 k = case unsafeCoerce Refl :: SSE4_1 :~: True of Refl -> unsafeAssumeSSSE3 k

querySSE4_1 :: Maybe (Dict HasSSE4_1)
querySSE4_1 = case sSSE4_1 of STrue -> unsafeAssumeSSE4_1 (Just Dict); SFalse -> Nothing
{-# NOINLINE querySSE4_1 #-}

unsafeAssumeSSE4_2 :: (HasSSE4_2 => a) -> a
unsafeAssumeSSE4_2 k = case unsafeCoerce Refl :: SSE4_2 :~: True of Refl -> unsafeAssumeSSE4_1 k

querySSE4_2 :: Maybe (Dict HasSSE4_2)
querySSE4_2 = case sSSE4_2 of STrue -> unsafeAssumeSSE4_2 (Just Dict); SFalse -> Nothing
{-# NOINLINE querySSE4_2 #-}

unsafeAssumeAVX :: (HasAVX => a) -> a
unsafeAssumeAVX k = case unsafeCoerce Refl :: AVX :~: True of Refl -> unsafeAssumeSSE4_2 k

queryAVX :: Maybe (Dict HasAVX)
queryAVX = case sAVX of STrue -> unsafeAssumeAVX (Just Dict); SFalse -> Nothing
{-# NOINLINE queryAVX #-}

unsafeAssumeAVX2 :: (HasAVX2 => a) -> a
unsafeAssumeAVX2 k = case unsafeCoerce Refl :: AVX2 :~: True of Refl -> unsafeAssumeAVX k

queryAVX2 :: Maybe (Dict HasAVX2)
queryAVX2 = case sAVX2 of STrue -> unsafeAssumeAVX2 (Just Dict); SFalse -> Nothing
{-# NOINLINE queryAVX2 #-}

unsafeAssumeF16C :: (HasF16C => a) -> a
unsafeAssumeF16C k = case unsafeCoerce Refl :: F16C :~: True of Refl -> unsafeAssumeAVX k

queryF16C :: Maybe (Dict HasF16C)
queryF16C = case sF16C of STrue -> unsafeAssumeF16C (Just Dict); SFalse -> Nothing
{-# NOINLINE queryF16C #-}

unsafeAssumeFMA :: (HasFMA => a) -> a
unsafeAssumeFMA k = case unsafeCoerce Refl :: FMA :~: True of Refl -> unsafeAssumeAVX k

queryFMA :: Maybe (Dict HasFMA)
queryFMA = case sFMA of STrue -> unsafeAssumeFMA (Just Dict); SFalse -> Nothing
{-# NOINLINE queryFMA #-}

unsafeAssumeAVX_VNNI :: (HasAVX_VNNI => a) -> a
unsafeAssumeAVX_VNNI k = case unsafeCoerce Refl :: AVX_VNNI :~: True of Refl -> unsafeAssumeAVX2 k

queryAVX_VNNI :: Maybe (Dict HasAVX_VNNI)
queryAVX_VNNI = case sAVX_VNNI of STrue -> unsafeAssumeAVX_VNNI (Just Dict); SFalse -> Nothing
{-# NOINLINE queryAVX_VNNI #-}

unsafeAssumeAVX512F :: (HasAVX512F => a) -> a
unsafeAssumeAVX512F k = case unsafeCoerce Refl :: AVX512F :~: True of Refl -> unsafeAssumeFMA (unsafeAssumeF16C (unsafeAssumeAVX2 k))

queryAVX512F :: Maybe (Dict HasAVX512F)
queryAVX512F = case sAVX512F of STrue -> unsafeAssumeAVX512F (Just Dict); SFalse -> Nothing
{-# NOINLINE queryAVX512F #-}

unsafeAssumeAVX512VL :: (HasAVX512VL => a) -> a
unsafeAssumeAVX512VL k = case unsafeCoerce Refl :: AVX512VL :~: True of Refl -> unsafeAssumeAVX512F k

queryAVX512VL :: Maybe (Dict HasAVX512VL)
queryAVX512VL = case sAVX512VL of STrue -> unsafeAssumeAVX512VL (Just Dict); SFalse -> Nothing
{-# NOINLINE queryAVX512VL #-}

unsafeAssumeAVX512BW :: (HasAVX512BW => a) -> a
unsafeAssumeAVX512BW k = case unsafeCoerce Refl :: AVX512BW :~: True of Refl -> unsafeAssumeAVX512F k

queryAVX512BW :: Maybe (Dict HasAVX512BW)
queryAVX512BW = case sAVX512BW of STrue -> unsafeAssumeAVX512BW (Just Dict); SFalse -> Nothing
{-# NOINLINE queryAVX512BW #-}

unsafeAssumeAVX512DQ :: (HasAVX512DQ => a) -> a
unsafeAssumeAVX512DQ k = case unsafeCoerce Refl :: AVX512DQ :~: True of Refl -> unsafeAssumeAVX512F k

queryAVX512DQ :: Maybe (Dict HasAVX512DQ)
queryAVX512DQ = case sAVX512DQ of STrue -> unsafeAssumeAVX512DQ (Just Dict); SFalse -> Nothing
{-# NOINLINE queryAVX512DQ #-}

unsafeAssumeAVX512CD :: (HasAVX512CD => a) -> a
unsafeAssumeAVX512CD k = case unsafeCoerce Refl :: AVX512CD :~: True of Refl -> unsafeAssumeAVX512F k

queryAVX512CD :: Maybe (Dict HasAVX512CD)
queryAVX512CD = case sAVX512CD of STrue -> unsafeAssumeAVX512CD (Just Dict); SFalse -> Nothing
{-# NOINLINE queryAVX512CD #-}

unsafeAssumeAVX512_BF16 :: (HasAVX512_BF16 => a) -> a
unsafeAssumeAVX512_BF16 k = case unsafeCoerce Refl :: AVX512_BF16 :~: True of Refl -> unsafeAssumeAVX512BW k

queryAVX512_BF16 :: Maybe (Dict HasAVX512_BF16)
queryAVX512_BF16 = case sAVX512_BF16 of STrue -> unsafeAssumeAVX512_BF16 (Just Dict); SFalse -> Nothing
{-# NOINLINE queryAVX512_BF16 #-}

unsafeAssumeAVX512_BITALG :: (HasAVX512_BITALG => a) -> a
unsafeAssumeAVX512_BITALG k = case unsafeCoerce Refl :: AVX512_BITALG :~: True of Refl -> unsafeAssumeAVX512BW k

queryAVX512_BITALG :: Maybe (Dict HasAVX512_BITALG)
queryAVX512_BITALG = case sAVX512_BITALG of STrue -> unsafeAssumeAVX512_BITALG (Just Dict); SFalse -> Nothing
{-# NOINLINE queryAVX512_BITALG #-}

unsafeAssumeAVX512_FP16 :: (HasAVX512_FP16 => a) -> a
unsafeAssumeAVX512_FP16 k = case unsafeCoerce Refl :: AVX512_FP16 :~: True of Refl -> unsafeAssumeAVX512BW k

queryAVX512_FP16 :: Maybe (Dict HasAVX512_FP16)
queryAVX512_FP16 = case sAVX512_FP16 of STrue -> unsafeAssumeAVX512_FP16 (Just Dict); SFalse -> Nothing
{-# NOINLINE queryAVX512_FP16 #-}

unsafeAssumeAVX512_IFMA :: (HasAVX512_IFMA => a) -> a
unsafeAssumeAVX512_IFMA k = case unsafeCoerce Refl :: AVX512_IFMA :~: True of Refl -> unsafeAssumeAVX512F k

queryAVX512_IFMA :: Maybe (Dict HasAVX512_IFMA)
queryAVX512_IFMA = case sAVX512_IFMA of STrue -> unsafeAssumeAVX512_IFMA (Just Dict); SFalse -> Nothing
{-# NOINLINE queryAVX512_IFMA #-}

unsafeAssumeAVX512_VBMI :: (HasAVX512_VBMI => a) -> a
unsafeAssumeAVX512_VBMI k = case unsafeCoerce Refl :: AVX512_VBMI :~: True of Refl -> unsafeAssumeAVX512BW k

queryAVX512_VBMI :: Maybe (Dict HasAVX512_VBMI)
queryAVX512_VBMI = case sAVX512_VBMI of STrue -> unsafeAssumeAVX512_VBMI (Just Dict); SFalse -> Nothing
{-# NOINLINE queryAVX512_VBMI #-}

unsafeAssumeAVX512_VBMI2 :: (HasAVX512_VBMI2 => a) -> a
unsafeAssumeAVX512_VBMI2 k = case unsafeCoerce Refl :: AVX512_VBMI2 :~: True of Refl -> unsafeAssumeAVX512BW k

queryAVX512_VBMI2 :: Maybe (Dict HasAVX512_VBMI2)
queryAVX512_VBMI2 = case sAVX512_VBMI2 of STrue -> unsafeAssumeAVX512_VBMI2 (Just Dict); SFalse -> Nothing
{-# NOINLINE queryAVX512_VBMI2 #-}

unsafeAssumeAVX512_VNNI :: (HasAVX512_VNNI => a) -> a
unsafeAssumeAVX512_VNNI k = case unsafeCoerce Refl :: AVX512_VNNI :~: True of Refl -> unsafeAssumeAVX512F k

queryAVX512_VNNI :: Maybe (Dict HasAVX512_VNNI)
queryAVX512_VNNI = case sAVX512_VNNI of STrue -> unsafeAssumeAVX512_VNNI (Just Dict); SFalse -> Nothing
{-# NOINLINE queryAVX512_VNNI #-}

unsafeAssumeAVX512_VPOPCNTDQ :: (HasAVX512_VPOPCNTDQ => a) -> a
unsafeAssumeAVX512_VPOPCNTDQ k = case unsafeCoerce Refl :: AVX512_VPOPCNTDQ :~: True of Refl -> unsafeAssumeAVX512F k

queryAVX512_VPOPCNTDQ :: Maybe (Dict HasAVX512_VPOPCNTDQ)
queryAVX512_VPOPCNTDQ = case sAVX512_VPOPCNTDQ of STrue -> unsafeAssumeAVX512_VPOPCNTDQ (Just Dict); SFalse -> Nothing
{-# NOINLINE queryAVX512_VPOPCNTDQ #-}

unsafeAssumeAVX10_1 :: (HasAVX10_1 => a) -> a
unsafeAssumeAVX10_1 k = case unsafeCoerce Refl :: AVX10_1 :~: True of Refl -> unsafeAssumeFMA (unsafeAssumeF16C (unsafeAssumeAVX2 k))

queryAVX10_1 :: Maybe (Dict HasAVX10_1)
queryAVX10_1 = case sAVX10_1 of STrue -> unsafeAssumeAVX10_1 (Just Dict); SFalse -> Nothing
{-# NOINLINE queryAVX10_1 #-}

unsafeAssumeAVX10_2 :: (HasAVX10_2 => a) -> a
unsafeAssumeAVX10_2 k = case unsafeCoerce Refl :: AVX10_2 :~: True of Refl -> unsafeAssumeAVX10_1 k

queryAVX10_2 :: Maybe (Dict HasAVX10_2)
queryAVX10_2 = case sAVX10_2 of STrue -> unsafeAssumeAVX10_2 (Just Dict); SFalse -> Nothing
{-# NOINLINE queryAVX10_2 #-}

unsafeAssumeVAES :: (HasVAES => a) -> a
unsafeAssumeVAES k = case unsafeCoerce Refl :: VAES :~: True of Refl -> unsafeAssumeAESNI (unsafeAssumeAVX2 k)

queryVAES :: Maybe (Dict HasVAES)
queryVAES = case sVAES of STrue -> unsafeAssumeVAES (Just Dict); SFalse -> Nothing
{-# NOINLINE queryVAES #-}

unsafeAssumeVPCLMULQDQ :: (HasVPCLMULQDQ => a) -> a
unsafeAssumeVPCLMULQDQ k = case unsafeCoerce Refl :: VPCLMULQDQ :~: True of Refl -> unsafeAssumePCLMULQDQ (unsafeAssumeAVX k)

queryVPCLMULQDQ :: Maybe (Dict HasVPCLMULQDQ)
queryVPCLMULQDQ = case sVPCLMULQDQ of STrue -> unsafeAssumeVPCLMULQDQ (Just Dict); SFalse -> Nothing
{-# NOINLINE queryVPCLMULQDQ #-}

unsafeAssumeAMX_TILE :: (HasAMX_TILE => a) -> a
unsafeAssumeAMX_TILE k = case unsafeCoerce Refl :: AMX_TILE :~: True of Refl -> k

queryAMX_TILE :: Maybe (Dict HasAMX_TILE)
queryAMX_TILE = case sAMX_TILE of STrue -> unsafeAssumeAMX_TILE (Just Dict); SFalse -> Nothing
{-# NOINLINE queryAMX_TILE #-}

unsafeAssumeAMX_BF16 :: (HasAMX_BF16 => a) -> a
unsafeAssumeAMX_BF16 k = case unsafeCoerce Refl :: AMX_BF16 :~: True of Refl -> unsafeAssumeAMX_TILE k

queryAMX_BF16 :: Maybe (Dict HasAMX_BF16)
queryAMX_BF16 = case sAMX_BF16 of STrue -> unsafeAssumeAMX_BF16 (Just Dict); SFalse -> Nothing
{-# NOINLINE queryAMX_BF16 #-}

unsafeAssumeAMX_FP16 :: (HasAMX_FP16 => a) -> a
unsafeAssumeAMX_FP16 k = case unsafeCoerce Refl :: AMX_FP16 :~: True of Refl -> unsafeAssumeAMX_TILE k

queryAMX_FP16 :: Maybe (Dict HasAMX_FP16)
queryAMX_FP16 = case sAMX_FP16 of STrue -> unsafeAssumeAMX_FP16 (Just Dict); SFalse -> Nothing
{-# NOINLINE queryAMX_FP16 #-}

unsafeAssumeAMX_INT8 :: (HasAMX_INT8 => a) -> a
unsafeAssumeAMX_INT8 k = case unsafeCoerce Refl :: AMX_INT8 :~: True of Refl -> unsafeAssumeAMX_TILE k

queryAMX_INT8 :: Maybe (Dict HasAMX_INT8)
queryAMX_INT8 = case sAMX_INT8 of STrue -> unsafeAssumeAMX_INT8 (Just Dict); SFalse -> Nothing
{-# NOINLINE queryAMX_INT8 #-}