Unsafe.hs

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

class C ~ True => HasC
instance C ~ True => HasC

class V ~ True => HasV
instance V ~ True => HasV

class Zba ~ True => HasZba
instance Zba ~ True => HasZba

class Zbb ~ True => HasZbb
instance Zbb ~ True => HasZbb

class Zbs ~ True => HasZbs
instance Zbs ~ True => HasZbs

class Zicboz ~ True => HasZicboz
instance Zicboz ~ True => HasZicboz

class Zbc ~ True => HasZbc
instance Zbc ~ True => HasZbc

class Zbkb ~ True => HasZbkb
instance Zbkb ~ True => HasZbkb

class Zbkc ~ True => HasZbkc
instance Zbkc ~ True => HasZbkc

class Zbkx ~ True => HasZbkx
instance Zbkx ~ True => HasZbkx

class Zknd ~ True => HasZknd
instance Zknd ~ True => HasZknd

class Zkne ~ True => HasZkne
instance Zkne ~ True => HasZkne

class Zknh ~ True => HasZknh
instance Zknh ~ True => HasZknh

class Zksed ~ True => HasZksed
instance Zksed ~ True => HasZksed

class Zksh ~ True => HasZksh
instance Zksh ~ True => HasZksh

class Zkt ~ True => HasZkt
instance Zkt ~ True => HasZkt

class Zvbb ~ True => HasZvbb
instance Zvbb ~ True => HasZvbb

class Zvbc ~ True => HasZvbc
instance Zvbc ~ True => HasZvbc

class Zvkb ~ True => HasZvkb
instance Zvkb ~ True => HasZvkb

class Zvkg ~ True => HasZvkg
instance Zvkg ~ True => HasZvkg

class Zvkned ~ True => HasZvkned
instance Zvkned ~ True => HasZvkned

class Zvknha ~ True => HasZvknha
instance Zvknha ~ True => HasZvknha

class Zvknhb ~ True => HasZvknhb
instance Zvknhb ~ True => HasZvknhb

class Zvksed ~ True => HasZvksed
instance Zvksed ~ True => HasZvksed

class Zvksh ~ True => HasZvksh
instance Zvksh ~ True => HasZvksh

class Zvkt ~ True => HasZvkt
instance Zvkt ~ True => HasZvkt

class Zfh ~ True => HasZfh
instance Zfh ~ True => HasZfh

class Zfhmin ~ True => HasZfhmin
instance Zfhmin ~ True => HasZfhmin

class Zihintntl ~ True => HasZihintntl
instance Zihintntl ~ True => HasZihintntl

class Zvfh ~ True => HasZvfh
instance Zvfh ~ True => HasZvfh

class Zvfhmin ~ True => HasZvfhmin
instance Zvfhmin ~ True => HasZvfhmin

class Zfa ~ True => HasZfa
instance Zfa ~ True => HasZfa

class Ztso ~ True => HasZtso
instance Ztso ~ True => HasZtso

class Zacas ~ True => HasZacas
instance Zacas ~ True => HasZacas

class Zicntr ~ True => HasZicntr
instance Zicntr ~ True => HasZicntr

class Zicond ~ True => HasZicond
instance Zicond ~ True => HasZicond

class Zihintpause ~ True => HasZihintpause
instance Zihintpause ~ True => HasZihintpause

class Zihpm ~ True => HasZihpm
instance Zihpm ~ True => HasZihpm

class Zve32x ~ True => HasZve32x
instance Zve32x ~ True => HasZve32x

class Zve32f ~ True => HasZve32f
instance Zve32f ~ True => HasZve32f

class Zve64x ~ True => HasZve64x
instance Zve64x ~ True => HasZve64x

class Zve64f ~ True => HasZve64f
instance Zve64f ~ True => HasZve64f

class Zve64d ~ True => HasZve64d
instance Zve64d ~ True => HasZve64d

class Zimop ~ True => HasZimop
instance Zimop ~ True => HasZimop

class Zca ~ True => HasZca
instance Zca ~ True => HasZca

class Zcb ~ True => HasZcb
instance Zcb ~ True => HasZcb

class Zcd ~ True => HasZcd
instance Zcd ~ True => HasZcd

class Zcf ~ True => HasZcf
instance Zcf ~ True => HasZcf

class Zcmop ~ True => HasZcmop
instance Zcmop ~ True => HasZcmop

class Zawrs ~ True => HasZawrs
instance Zawrs ~ True => HasZawrs

class Zaamo ~ True => HasZaamo
instance Zaamo ~ True => HasZaamo

class Zalrsc ~ True => HasZalrsc
instance Zalrsc ~ True => HasZalrsc

class Supm ~ True => HasSupm
instance Supm ~ True => HasSupm

class Zfbfmin ~ True => HasZfbfmin
instance Zfbfmin ~ True => HasZfbfmin

class Zvfbfmin ~ True => HasZvfbfmin
instance Zvfbfmin ~ True => HasZvfbfmin

class Zvfbfwma ~ True => HasZvfbfwma
instance Zvfbfwma ~ True => HasZvfbfwma

class Zicbom ~ True => HasZicbom
instance Zicbom ~ True => HasZicbom

unsafeAssumeC :: (HasC => a) -> a
unsafeAssumeC k = case unsafeCoerce Refl :: C :~: True of Refl -> k

queryC :: Maybe (Dict HasC)
queryC = case sC of STrue -> unsafeAssumeC (Just Dict); SFalse -> Nothing
{-# NOINLINE queryC #-}

unsafeAssumeV :: (HasV => a) -> a
unsafeAssumeV k = case unsafeCoerce Refl :: V :~: True of Refl -> k

queryV :: Maybe (Dict HasV)
queryV = case sV of STrue -> unsafeAssumeV (Just Dict); SFalse -> Nothing
{-# NOINLINE queryV #-}

unsafeAssumeZba :: (HasZba => a) -> a
unsafeAssumeZba k = case unsafeCoerce Refl :: Zba :~: True of Refl -> k

queryZba :: Maybe (Dict HasZba)
queryZba = case sZba of STrue -> unsafeAssumeZba (Just Dict); SFalse -> Nothing
{-# NOINLINE queryZba #-}

unsafeAssumeZbb :: (HasZbb => a) -> a
unsafeAssumeZbb k = case unsafeCoerce Refl :: Zbb :~: True of Refl -> k

queryZbb :: Maybe (Dict HasZbb)
queryZbb = case sZbb of STrue -> unsafeAssumeZbb (Just Dict); SFalse -> Nothing
{-# NOINLINE queryZbb #-}

unsafeAssumeZbs :: (HasZbs => a) -> a
unsafeAssumeZbs k = case unsafeCoerce Refl :: Zbs :~: True of Refl -> k

queryZbs :: Maybe (Dict HasZbs)
queryZbs = case sZbs of STrue -> unsafeAssumeZbs (Just Dict); SFalse -> Nothing
{-# NOINLINE queryZbs #-}

unsafeAssumeZicboz :: (HasZicboz => a) -> a
unsafeAssumeZicboz k = case unsafeCoerce Refl :: Zicboz :~: True of Refl -> k

queryZicboz :: Maybe (Dict HasZicboz)
queryZicboz = case sZicboz of STrue -> unsafeAssumeZicboz (Just Dict); SFalse -> Nothing
{-# NOINLINE queryZicboz #-}

unsafeAssumeZbc :: (HasZbc => a) -> a
unsafeAssumeZbc k = case unsafeCoerce Refl :: Zbc :~: True of Refl -> k

queryZbc :: Maybe (Dict HasZbc)
queryZbc = case sZbc of STrue -> unsafeAssumeZbc (Just Dict); SFalse -> Nothing
{-# NOINLINE queryZbc #-}

unsafeAssumeZbkb :: (HasZbkb => a) -> a
unsafeAssumeZbkb k = case unsafeCoerce Refl :: Zbkb :~: True of Refl -> k

queryZbkb :: Maybe (Dict HasZbkb)
queryZbkb = case sZbkb of STrue -> unsafeAssumeZbkb (Just Dict); SFalse -> Nothing
{-# NOINLINE queryZbkb #-}

unsafeAssumeZbkc :: (HasZbkc => a) -> a
unsafeAssumeZbkc k = case unsafeCoerce Refl :: Zbkc :~: True of Refl -> k

queryZbkc :: Maybe (Dict HasZbkc)
queryZbkc = case sZbkc of STrue -> unsafeAssumeZbkc (Just Dict); SFalse -> Nothing
{-# NOINLINE queryZbkc #-}

unsafeAssumeZbkx :: (HasZbkx => a) -> a
unsafeAssumeZbkx k = case unsafeCoerce Refl :: Zbkx :~: True of Refl -> k

queryZbkx :: Maybe (Dict HasZbkx)
queryZbkx = case sZbkx of STrue -> unsafeAssumeZbkx (Just Dict); SFalse -> Nothing
{-# NOINLINE queryZbkx #-}

unsafeAssumeZknd :: (HasZknd => a) -> a
unsafeAssumeZknd k = case unsafeCoerce Refl :: Zknd :~: True of Refl -> k

queryZknd :: Maybe (Dict HasZknd)
queryZknd = case sZknd of STrue -> unsafeAssumeZknd (Just Dict); SFalse -> Nothing
{-# NOINLINE queryZknd #-}

unsafeAssumeZkne :: (HasZkne => a) -> a
unsafeAssumeZkne k = case unsafeCoerce Refl :: Zkne :~: True of Refl -> k

queryZkne :: Maybe (Dict HasZkne)
queryZkne = case sZkne of STrue -> unsafeAssumeZkne (Just Dict); SFalse -> Nothing
{-# NOINLINE queryZkne #-}

unsafeAssumeZknh :: (HasZknh => a) -> a
unsafeAssumeZknh k = case unsafeCoerce Refl :: Zknh :~: True of Refl -> k

queryZknh :: Maybe (Dict HasZknh)
queryZknh = case sZknh of STrue -> unsafeAssumeZknh (Just Dict); SFalse -> Nothing
{-# NOINLINE queryZknh #-}

unsafeAssumeZksed :: (HasZksed => a) -> a
unsafeAssumeZksed k = case unsafeCoerce Refl :: Zksed :~: True of Refl -> k

queryZksed :: Maybe (Dict HasZksed)
queryZksed = case sZksed of STrue -> unsafeAssumeZksed (Just Dict); SFalse -> Nothing
{-# NOINLINE queryZksed #-}

unsafeAssumeZksh :: (HasZksh => a) -> a
unsafeAssumeZksh k = case unsafeCoerce Refl :: Zksh :~: True of Refl -> k

queryZksh :: Maybe (Dict HasZksh)
queryZksh = case sZksh of STrue -> unsafeAssumeZksh (Just Dict); SFalse -> Nothing
{-# NOINLINE queryZksh #-}

unsafeAssumeZkt :: (HasZkt => a) -> a
unsafeAssumeZkt k = case unsafeCoerce Refl :: Zkt :~: True of Refl -> k

queryZkt :: Maybe (Dict HasZkt)
queryZkt = case sZkt of STrue -> unsafeAssumeZkt (Just Dict); SFalse -> Nothing
{-# NOINLINE queryZkt #-}

unsafeAssumeZvbb :: (HasZvbb => a) -> a
unsafeAssumeZvbb k = case unsafeCoerce Refl :: Zvbb :~: True of Refl -> k

queryZvbb :: Maybe (Dict HasZvbb)
queryZvbb = case sZvbb of STrue -> unsafeAssumeZvbb (Just Dict); SFalse -> Nothing
{-# NOINLINE queryZvbb #-}

unsafeAssumeZvbc :: (HasZvbc => a) -> a
unsafeAssumeZvbc k = case unsafeCoerce Refl :: Zvbc :~: True of Refl -> k

queryZvbc :: Maybe (Dict HasZvbc)
queryZvbc = case sZvbc of STrue -> unsafeAssumeZvbc (Just Dict); SFalse -> Nothing
{-# NOINLINE queryZvbc #-}

unsafeAssumeZvkb :: (HasZvkb => a) -> a
unsafeAssumeZvkb k = case unsafeCoerce Refl :: Zvkb :~: True of Refl -> k

queryZvkb :: Maybe (Dict HasZvkb)
queryZvkb = case sZvkb of STrue -> unsafeAssumeZvkb (Just Dict); SFalse -> Nothing
{-# NOINLINE queryZvkb #-}

unsafeAssumeZvkg :: (HasZvkg => a) -> a
unsafeAssumeZvkg k = case unsafeCoerce Refl :: Zvkg :~: True of Refl -> k

queryZvkg :: Maybe (Dict HasZvkg)
queryZvkg = case sZvkg of STrue -> unsafeAssumeZvkg (Just Dict); SFalse -> Nothing
{-# NOINLINE queryZvkg #-}

unsafeAssumeZvkned :: (HasZvkned => a) -> a
unsafeAssumeZvkned k = case unsafeCoerce Refl :: Zvkned :~: True of Refl -> k

queryZvkned :: Maybe (Dict HasZvkned)
queryZvkned = case sZvkned of STrue -> unsafeAssumeZvkned (Just Dict); SFalse -> Nothing
{-# NOINLINE queryZvkned #-}

unsafeAssumeZvknha :: (HasZvknha => a) -> a
unsafeAssumeZvknha k = case unsafeCoerce Refl :: Zvknha :~: True of Refl -> k

queryZvknha :: Maybe (Dict HasZvknha)
queryZvknha = case sZvknha of STrue -> unsafeAssumeZvknha (Just Dict); SFalse -> Nothing
{-# NOINLINE queryZvknha #-}

unsafeAssumeZvknhb :: (HasZvknhb => a) -> a
unsafeAssumeZvknhb k = case unsafeCoerce Refl :: Zvknhb :~: True of Refl -> k

queryZvknhb :: Maybe (Dict HasZvknhb)
queryZvknhb = case sZvknhb of STrue -> unsafeAssumeZvknhb (Just Dict); SFalse -> Nothing
{-# NOINLINE queryZvknhb #-}

unsafeAssumeZvksed :: (HasZvksed => a) -> a
unsafeAssumeZvksed k = case unsafeCoerce Refl :: Zvksed :~: True of Refl -> k

queryZvksed :: Maybe (Dict HasZvksed)
queryZvksed = case sZvksed of STrue -> unsafeAssumeZvksed (Just Dict); SFalse -> Nothing
{-# NOINLINE queryZvksed #-}

unsafeAssumeZvksh :: (HasZvksh => a) -> a
unsafeAssumeZvksh k = case unsafeCoerce Refl :: Zvksh :~: True of Refl -> k

queryZvksh :: Maybe (Dict HasZvksh)
queryZvksh = case sZvksh of STrue -> unsafeAssumeZvksh (Just Dict); SFalse -> Nothing
{-# NOINLINE queryZvksh #-}

unsafeAssumeZvkt :: (HasZvkt => a) -> a
unsafeAssumeZvkt k = case unsafeCoerce Refl :: Zvkt :~: True of Refl -> k

queryZvkt :: Maybe (Dict HasZvkt)
queryZvkt = case sZvkt of STrue -> unsafeAssumeZvkt (Just Dict); SFalse -> Nothing
{-# NOINLINE queryZvkt #-}

unsafeAssumeZfh :: (HasZfh => a) -> a
unsafeAssumeZfh k = case unsafeCoerce Refl :: Zfh :~: True of Refl -> k

queryZfh :: Maybe (Dict HasZfh)
queryZfh = case sZfh of STrue -> unsafeAssumeZfh (Just Dict); SFalse -> Nothing
{-# NOINLINE queryZfh #-}

unsafeAssumeZfhmin :: (HasZfhmin => a) -> a
unsafeAssumeZfhmin k = case unsafeCoerce Refl :: Zfhmin :~: True of Refl -> k

queryZfhmin :: Maybe (Dict HasZfhmin)
queryZfhmin = case sZfhmin of STrue -> unsafeAssumeZfhmin (Just Dict); SFalse -> Nothing
{-# NOINLINE queryZfhmin #-}

unsafeAssumeZihintntl :: (HasZihintntl => a) -> a
unsafeAssumeZihintntl k = case unsafeCoerce Refl :: Zihintntl :~: True of Refl -> k

queryZihintntl :: Maybe (Dict HasZihintntl)
queryZihintntl = case sZihintntl of STrue -> unsafeAssumeZihintntl (Just Dict); SFalse -> Nothing
{-# NOINLINE queryZihintntl #-}

unsafeAssumeZvfh :: (HasZvfh => a) -> a
unsafeAssumeZvfh k = case unsafeCoerce Refl :: Zvfh :~: True of Refl -> k

queryZvfh :: Maybe (Dict HasZvfh)
queryZvfh = case sZvfh of STrue -> unsafeAssumeZvfh (Just Dict); SFalse -> Nothing
{-# NOINLINE queryZvfh #-}

unsafeAssumeZvfhmin :: (HasZvfhmin => a) -> a
unsafeAssumeZvfhmin k = case unsafeCoerce Refl :: Zvfhmin :~: True of Refl -> k

queryZvfhmin :: Maybe (Dict HasZvfhmin)
queryZvfhmin = case sZvfhmin of STrue -> unsafeAssumeZvfhmin (Just Dict); SFalse -> Nothing
{-# NOINLINE queryZvfhmin #-}

unsafeAssumeZfa :: (HasZfa => a) -> a
unsafeAssumeZfa k = case unsafeCoerce Refl :: Zfa :~: True of Refl -> k

queryZfa :: Maybe (Dict HasZfa)
queryZfa = case sZfa of STrue -> unsafeAssumeZfa (Just Dict); SFalse -> Nothing
{-# NOINLINE queryZfa #-}

unsafeAssumeZtso :: (HasZtso => a) -> a
unsafeAssumeZtso k = case unsafeCoerce Refl :: Ztso :~: True of Refl -> k

queryZtso :: Maybe (Dict HasZtso)
queryZtso = case sZtso of STrue -> unsafeAssumeZtso (Just Dict); SFalse -> Nothing
{-# NOINLINE queryZtso #-}

unsafeAssumeZacas :: (HasZacas => a) -> a
unsafeAssumeZacas k = case unsafeCoerce Refl :: Zacas :~: True of Refl -> k

queryZacas :: Maybe (Dict HasZacas)
queryZacas = case sZacas of STrue -> unsafeAssumeZacas (Just Dict); SFalse -> Nothing
{-# NOINLINE queryZacas #-}

unsafeAssumeZicntr :: (HasZicntr => a) -> a
unsafeAssumeZicntr k = case unsafeCoerce Refl :: Zicntr :~: True of Refl -> k

queryZicntr :: Maybe (Dict HasZicntr)
queryZicntr = case sZicntr of STrue -> unsafeAssumeZicntr (Just Dict); SFalse -> Nothing
{-# NOINLINE queryZicntr #-}

unsafeAssumeZicond :: (HasZicond => a) -> a
unsafeAssumeZicond k = case unsafeCoerce Refl :: Zicond :~: True of Refl -> k

queryZicond :: Maybe (Dict HasZicond)
queryZicond = case sZicond of STrue -> unsafeAssumeZicond (Just Dict); SFalse -> Nothing
{-# NOINLINE queryZicond #-}

unsafeAssumeZihintpause :: (HasZihintpause => a) -> a
unsafeAssumeZihintpause k = case unsafeCoerce Refl :: Zihintpause :~: True of Refl -> k

queryZihintpause :: Maybe (Dict HasZihintpause)
queryZihintpause = case sZihintpause of STrue -> unsafeAssumeZihintpause (Just Dict); SFalse -> Nothing
{-# NOINLINE queryZihintpause #-}

unsafeAssumeZihpm :: (HasZihpm => a) -> a
unsafeAssumeZihpm k = case unsafeCoerce Refl :: Zihpm :~: True of Refl -> k

queryZihpm :: Maybe (Dict HasZihpm)
queryZihpm = case sZihpm of STrue -> unsafeAssumeZihpm (Just Dict); SFalse -> Nothing
{-# NOINLINE queryZihpm #-}

unsafeAssumeZve32x :: (HasZve32x => a) -> a
unsafeAssumeZve32x k = case unsafeCoerce Refl :: Zve32x :~: True of Refl -> k

queryZve32x :: Maybe (Dict HasZve32x)
queryZve32x = case sZve32x of STrue -> unsafeAssumeZve32x (Just Dict); SFalse -> Nothing
{-# NOINLINE queryZve32x #-}

unsafeAssumeZve32f :: (HasZve32f => a) -> a
unsafeAssumeZve32f k = case unsafeCoerce Refl :: Zve32f :~: True of Refl -> k

queryZve32f :: Maybe (Dict HasZve32f)
queryZve32f = case sZve32f of STrue -> unsafeAssumeZve32f (Just Dict); SFalse -> Nothing
{-# NOINLINE queryZve32f #-}

unsafeAssumeZve64x :: (HasZve64x => a) -> a
unsafeAssumeZve64x k = case unsafeCoerce Refl :: Zve64x :~: True of Refl -> k

queryZve64x :: Maybe (Dict HasZve64x)
queryZve64x = case sZve64x of STrue -> unsafeAssumeZve64x (Just Dict); SFalse -> Nothing
{-# NOINLINE queryZve64x #-}

unsafeAssumeZve64f :: (HasZve64f => a) -> a
unsafeAssumeZve64f k = case unsafeCoerce Refl :: Zve64f :~: True of Refl -> k

queryZve64f :: Maybe (Dict HasZve64f)
queryZve64f = case sZve64f of STrue -> unsafeAssumeZve64f (Just Dict); SFalse -> Nothing
{-# NOINLINE queryZve64f #-}

unsafeAssumeZve64d :: (HasZve64d => a) -> a
unsafeAssumeZve64d k = case unsafeCoerce Refl :: Zve64d :~: True of Refl -> k

queryZve64d :: Maybe (Dict HasZve64d)
queryZve64d = case sZve64d of STrue -> unsafeAssumeZve64d (Just Dict); SFalse -> Nothing
{-# NOINLINE queryZve64d #-}

unsafeAssumeZimop :: (HasZimop => a) -> a
unsafeAssumeZimop k = case unsafeCoerce Refl :: Zimop :~: True of Refl -> k

queryZimop :: Maybe (Dict HasZimop)
queryZimop = case sZimop of STrue -> unsafeAssumeZimop (Just Dict); SFalse -> Nothing
{-# NOINLINE queryZimop #-}

unsafeAssumeZca :: (HasZca => a) -> a
unsafeAssumeZca k = case unsafeCoerce Refl :: Zca :~: True of Refl -> k

queryZca :: Maybe (Dict HasZca)
queryZca = case sZca of STrue -> unsafeAssumeZca (Just Dict); SFalse -> Nothing
{-# NOINLINE queryZca #-}

unsafeAssumeZcb :: (HasZcb => a) -> a
unsafeAssumeZcb k = case unsafeCoerce Refl :: Zcb :~: True of Refl -> k

queryZcb :: Maybe (Dict HasZcb)
queryZcb = case sZcb of STrue -> unsafeAssumeZcb (Just Dict); SFalse -> Nothing
{-# NOINLINE queryZcb #-}

unsafeAssumeZcd :: (HasZcd => a) -> a
unsafeAssumeZcd k = case unsafeCoerce Refl :: Zcd :~: True of Refl -> k

queryZcd :: Maybe (Dict HasZcd)
queryZcd = case sZcd of STrue -> unsafeAssumeZcd (Just Dict); SFalse -> Nothing
{-# NOINLINE queryZcd #-}

unsafeAssumeZcf :: (HasZcf => a) -> a
unsafeAssumeZcf k = case unsafeCoerce Refl :: Zcf :~: True of Refl -> k

queryZcf :: Maybe (Dict HasZcf)
queryZcf = case sZcf of STrue -> unsafeAssumeZcf (Just Dict); SFalse -> Nothing
{-# NOINLINE queryZcf #-}

unsafeAssumeZcmop :: (HasZcmop => a) -> a
unsafeAssumeZcmop k = case unsafeCoerce Refl :: Zcmop :~: True of Refl -> k

queryZcmop :: Maybe (Dict HasZcmop)
queryZcmop = case sZcmop of STrue -> unsafeAssumeZcmop (Just Dict); SFalse -> Nothing
{-# NOINLINE queryZcmop #-}

unsafeAssumeZawrs :: (HasZawrs => a) -> a
unsafeAssumeZawrs k = case unsafeCoerce Refl :: Zawrs :~: True of Refl -> k

queryZawrs :: Maybe (Dict HasZawrs)
queryZawrs = case sZawrs of STrue -> unsafeAssumeZawrs (Just Dict); SFalse -> Nothing
{-# NOINLINE queryZawrs #-}

unsafeAssumeZaamo :: (HasZaamo => a) -> a
unsafeAssumeZaamo k = case unsafeCoerce Refl :: Zaamo :~: True of Refl -> k

queryZaamo :: Maybe (Dict HasZaamo)
queryZaamo = case sZaamo of STrue -> unsafeAssumeZaamo (Just Dict); SFalse -> Nothing
{-# NOINLINE queryZaamo #-}

unsafeAssumeZalrsc :: (HasZalrsc => a) -> a
unsafeAssumeZalrsc k = case unsafeCoerce Refl :: Zalrsc :~: True of Refl -> k

queryZalrsc :: Maybe (Dict HasZalrsc)
queryZalrsc = case sZalrsc of STrue -> unsafeAssumeZalrsc (Just Dict); SFalse -> Nothing
{-# NOINLINE queryZalrsc #-}

unsafeAssumeSupm :: (HasSupm => a) -> a
unsafeAssumeSupm k = case unsafeCoerce Refl :: Supm :~: True of Refl -> k

querySupm :: Maybe (Dict HasSupm)
querySupm = case sSupm of STrue -> unsafeAssumeSupm (Just Dict); SFalse -> Nothing
{-# NOINLINE querySupm #-}

unsafeAssumeZfbfmin :: (HasZfbfmin => a) -> a
unsafeAssumeZfbfmin k = case unsafeCoerce Refl :: Zfbfmin :~: True of Refl -> k

queryZfbfmin :: Maybe (Dict HasZfbfmin)
queryZfbfmin = case sZfbfmin of STrue -> unsafeAssumeZfbfmin (Just Dict); SFalse -> Nothing
{-# NOINLINE queryZfbfmin #-}

unsafeAssumeZvfbfmin :: (HasZvfbfmin => a) -> a
unsafeAssumeZvfbfmin k = case unsafeCoerce Refl :: Zvfbfmin :~: True of Refl -> k

queryZvfbfmin :: Maybe (Dict HasZvfbfmin)
queryZvfbfmin = case sZvfbfmin of STrue -> unsafeAssumeZvfbfmin (Just Dict); SFalse -> Nothing
{-# NOINLINE queryZvfbfmin #-}

unsafeAssumeZvfbfwma :: (HasZvfbfwma => a) -> a
unsafeAssumeZvfbfwma k = case unsafeCoerce Refl :: Zvfbfwma :~: True of Refl -> k

queryZvfbfwma :: Maybe (Dict HasZvfbfwma)
queryZvfbfwma = case sZvfbfwma of STrue -> unsafeAssumeZvfbfwma (Just Dict); SFalse -> Nothing
{-# NOINLINE queryZvfbfwma #-}

unsafeAssumeZicbom :: (HasZicbom => a) -> a
unsafeAssumeZicbom k = case unsafeCoerce Refl :: Zicbom :~: True of Refl -> k

queryZicbom :: Maybe (Dict HasZicbom)
queryZicbom = case sZicbom of STrue -> unsafeAssumeZicbom (Just Dict); SFalse -> Nothing
{-# NOINLINE queryZicbom #-}