{-# 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 :: forall a. (HasC => a) -> a
unsafeAssumeC HasC => a
k = case (Any :~: Any) -> C :~: 'True
forall a b. a -> b
unsafeCoerce Any :~: Any
forall {k} (a :: k). a :~: a
Refl :: C :~: True of C :~: 'True
Refl -> a
HasC => a
k

queryC :: Maybe (Dict HasC)
queryC :: Maybe (Dict HasC)
queryC = case SBool C
sC of SBool C
STrue -> (HasC => Maybe (Dict HasC)) -> Maybe (Dict HasC)
forall a. (HasC => a) -> a
unsafeAssumeC (Dict HasC -> Maybe (Dict HasC)
forall a. a -> Maybe a
Just Dict HasC
forall (c :: Constraint). c => Dict c
Dict); SBool C
SFalse -> Maybe (Dict HasC)
forall a. Maybe a
Nothing
{-# NOINLINE queryC #-}

unsafeAssumeV :: (HasV => a) -> a
unsafeAssumeV :: forall a. (HasV => a) -> a
unsafeAssumeV HasV => a
k = case (Any :~: Any) -> V :~: 'True
forall a b. a -> b
unsafeCoerce Any :~: Any
forall {k} (a :: k). a :~: a
Refl :: V :~: True of V :~: 'True
Refl -> a
HasV => a
k

queryV :: Maybe (Dict HasV)
queryV :: Maybe (Dict HasV)
queryV = case SBool V
sV of SBool V
STrue -> (HasV => Maybe (Dict HasV)) -> Maybe (Dict HasV)
forall a. (HasV => a) -> a
unsafeAssumeV (Dict HasV -> Maybe (Dict HasV)
forall a. a -> Maybe a
Just Dict HasV
forall (c :: Constraint). c => Dict c
Dict); SBool V
SFalse -> Maybe (Dict HasV)
forall a. Maybe a
Nothing
{-# NOINLINE queryV #-}

unsafeAssumeZba :: (HasZba => a) -> a
unsafeAssumeZba :: forall a. (HasZba => a) -> a
unsafeAssumeZba HasZba => a
k = case (Any :~: Any) -> Zba :~: 'True
forall a b. a -> b
unsafeCoerce Any :~: Any
forall {k} (a :: k). a :~: a
Refl :: Zba :~: True of Zba :~: 'True
Refl -> a
HasZba => a
k

queryZba :: Maybe (Dict HasZba)
queryZba :: Maybe (Dict HasZba)
queryZba = case SBool Zba
sZba of SBool Zba
STrue -> (HasZba => Maybe (Dict HasZba)) -> Maybe (Dict HasZba)
forall a. (HasZba => a) -> a
unsafeAssumeZba (Dict HasZba -> Maybe (Dict HasZba)
forall a. a -> Maybe a
Just Dict HasZba
forall (c :: Constraint). c => Dict c
Dict); SBool Zba
SFalse -> Maybe (Dict HasZba)
forall a. Maybe a
Nothing
{-# NOINLINE queryZba #-}

unsafeAssumeZbb :: (HasZbb => a) -> a
unsafeAssumeZbb :: forall a. (HasZbb => a) -> a
unsafeAssumeZbb HasZbb => a
k = case (Any :~: Any) -> Zbb :~: 'True
forall a b. a -> b
unsafeCoerce Any :~: Any
forall {k} (a :: k). a :~: a
Refl :: Zbb :~: True of Zbb :~: 'True
Refl -> a
HasZbb => a
k

queryZbb :: Maybe (Dict HasZbb)
queryZbb :: Maybe (Dict HasZbb)
queryZbb = case SBool Zbb
sZbb of SBool Zbb
STrue -> (HasZbb => Maybe (Dict HasZbb)) -> Maybe (Dict HasZbb)
forall a. (HasZbb => a) -> a
unsafeAssumeZbb (Dict HasZbb -> Maybe (Dict HasZbb)
forall a. a -> Maybe a
Just Dict HasZbb
forall (c :: Constraint). c => Dict c
Dict); SBool Zbb
SFalse -> Maybe (Dict HasZbb)
forall a. Maybe a
Nothing
{-# NOINLINE queryZbb #-}

unsafeAssumeZbs :: (HasZbs => a) -> a
unsafeAssumeZbs :: forall a. (HasZbs => a) -> a
unsafeAssumeZbs HasZbs => a
k = case (Any :~: Any) -> Zbs :~: 'True
forall a b. a -> b
unsafeCoerce Any :~: Any
forall {k} (a :: k). a :~: a
Refl :: Zbs :~: True of Zbs :~: 'True
Refl -> a
HasZbs => a
k

queryZbs :: Maybe (Dict HasZbs)
queryZbs :: Maybe (Dict HasZbs)
queryZbs = case SBool Zbs
sZbs of SBool Zbs
STrue -> (HasZbs => Maybe (Dict HasZbs)) -> Maybe (Dict HasZbs)
forall a. (HasZbs => a) -> a
unsafeAssumeZbs (Dict HasZbs -> Maybe (Dict HasZbs)
forall a. a -> Maybe a
Just Dict HasZbs
forall (c :: Constraint). c => Dict c
Dict); SBool Zbs
SFalse -> Maybe (Dict HasZbs)
forall a. Maybe a
Nothing
{-# NOINLINE queryZbs #-}

unsafeAssumeZicboz :: (HasZicboz => a) -> a
unsafeAssumeZicboz :: forall a. (HasZicboz => a) -> a
unsafeAssumeZicboz HasZicboz => a
k = case (Any :~: Any) -> Zicboz :~: 'True
forall a b. a -> b
unsafeCoerce Any :~: Any
forall {k} (a :: k). a :~: a
Refl :: Zicboz :~: True of Zicboz :~: 'True
Refl -> a
HasZicboz => a
k

queryZicboz :: Maybe (Dict HasZicboz)
queryZicboz :: Maybe (Dict HasZicboz)
queryZicboz = case SBool Zicboz
sZicboz of SBool Zicboz
STrue -> (HasZicboz => Maybe (Dict HasZicboz)) -> Maybe (Dict HasZicboz)
forall a. (HasZicboz => a) -> a
unsafeAssumeZicboz (Dict HasZicboz -> Maybe (Dict HasZicboz)
forall a. a -> Maybe a
Just Dict HasZicboz
forall (c :: Constraint). c => Dict c
Dict); SBool Zicboz
SFalse -> Maybe (Dict HasZicboz)
forall a. Maybe a
Nothing
{-# NOINLINE queryZicboz #-}

unsafeAssumeZbc :: (HasZbc => a) -> a
unsafeAssumeZbc :: forall a. (HasZbc => a) -> a
unsafeAssumeZbc HasZbc => a
k = case (Any :~: Any) -> Zbc :~: 'True
forall a b. a -> b
unsafeCoerce Any :~: Any
forall {k} (a :: k). a :~: a
Refl :: Zbc :~: True of Zbc :~: 'True
Refl -> a
HasZbc => a
k

queryZbc :: Maybe (Dict HasZbc)
queryZbc :: Maybe (Dict HasZbc)
queryZbc = case SBool Zbc
sZbc of SBool Zbc
STrue -> (HasZbc => Maybe (Dict HasZbc)) -> Maybe (Dict HasZbc)
forall a. (HasZbc => a) -> a
unsafeAssumeZbc (Dict HasZbc -> Maybe (Dict HasZbc)
forall a. a -> Maybe a
Just Dict HasZbc
forall (c :: Constraint). c => Dict c
Dict); SBool Zbc
SFalse -> Maybe (Dict HasZbc)
forall a. Maybe a
Nothing
{-# NOINLINE queryZbc #-}

unsafeAssumeZbkb :: (HasZbkb => a) -> a
unsafeAssumeZbkb :: forall a. (HasZbkb => a) -> a
unsafeAssumeZbkb HasZbkb => a
k = case (Any :~: Any) -> Zbkb :~: 'True
forall a b. a -> b
unsafeCoerce Any :~: Any
forall {k} (a :: k). a :~: a
Refl :: Zbkb :~: True of Zbkb :~: 'True
Refl -> a
HasZbkb => a
k

queryZbkb :: Maybe (Dict HasZbkb)
queryZbkb :: Maybe (Dict HasZbkb)
queryZbkb = case SBool Zbkb
sZbkb of SBool Zbkb
STrue -> (HasZbkb => Maybe (Dict HasZbkb)) -> Maybe (Dict HasZbkb)
forall a. (HasZbkb => a) -> a
unsafeAssumeZbkb (Dict HasZbkb -> Maybe (Dict HasZbkb)
forall a. a -> Maybe a
Just Dict HasZbkb
forall (c :: Constraint). c => Dict c
Dict); SBool Zbkb
SFalse -> Maybe (Dict HasZbkb)
forall a. Maybe a
Nothing
{-# NOINLINE queryZbkb #-}

unsafeAssumeZbkc :: (HasZbkc => a) -> a
unsafeAssumeZbkc :: forall a. (HasZbkc => a) -> a
unsafeAssumeZbkc HasZbkc => a
k = case (Any :~: Any) -> Zbkc :~: 'True
forall a b. a -> b
unsafeCoerce Any :~: Any
forall {k} (a :: k). a :~: a
Refl :: Zbkc :~: True of Zbkc :~: 'True
Refl -> a
HasZbkc => a
k

queryZbkc :: Maybe (Dict HasZbkc)
queryZbkc :: Maybe (Dict HasZbkc)
queryZbkc = case SBool Zbkc
sZbkc of SBool Zbkc
STrue -> (HasZbkc => Maybe (Dict HasZbkc)) -> Maybe (Dict HasZbkc)
forall a. (HasZbkc => a) -> a
unsafeAssumeZbkc (Dict HasZbkc -> Maybe (Dict HasZbkc)
forall a. a -> Maybe a
Just Dict HasZbkc
forall (c :: Constraint). c => Dict c
Dict); SBool Zbkc
SFalse -> Maybe (Dict HasZbkc)
forall a. Maybe a
Nothing
{-# NOINLINE queryZbkc #-}

unsafeAssumeZbkx :: (HasZbkx => a) -> a
unsafeAssumeZbkx :: forall a. (HasZbkx => a) -> a
unsafeAssumeZbkx HasZbkx => a
k = case (Any :~: Any) -> Zbkx :~: 'True
forall a b. a -> b
unsafeCoerce Any :~: Any
forall {k} (a :: k). a :~: a
Refl :: Zbkx :~: True of Zbkx :~: 'True
Refl -> a
HasZbkx => a
k

queryZbkx :: Maybe (Dict HasZbkx)
queryZbkx :: Maybe (Dict HasZbkx)
queryZbkx = case SBool Zbkx
sZbkx of SBool Zbkx
STrue -> (HasZbkx => Maybe (Dict HasZbkx)) -> Maybe (Dict HasZbkx)
forall a. (HasZbkx => a) -> a
unsafeAssumeZbkx (Dict HasZbkx -> Maybe (Dict HasZbkx)
forall a. a -> Maybe a
Just Dict HasZbkx
forall (c :: Constraint). c => Dict c
Dict); SBool Zbkx
SFalse -> Maybe (Dict HasZbkx)
forall a. Maybe a
Nothing
{-# NOINLINE queryZbkx #-}

unsafeAssumeZknd :: (HasZknd => a) -> a
unsafeAssumeZknd :: forall a. (HasZknd => a) -> a
unsafeAssumeZknd HasZknd => a
k = case (Any :~: Any) -> Zknd :~: 'True
forall a b. a -> b
unsafeCoerce Any :~: Any
forall {k} (a :: k). a :~: a
Refl :: Zknd :~: True of Zknd :~: 'True
Refl -> a
HasZknd => a
k

queryZknd :: Maybe (Dict HasZknd)
queryZknd :: Maybe (Dict HasZknd)
queryZknd = case SBool Zknd
sZknd of SBool Zknd
STrue -> (HasZknd => Maybe (Dict HasZknd)) -> Maybe (Dict HasZknd)
forall a. (HasZknd => a) -> a
unsafeAssumeZknd (Dict HasZknd -> Maybe (Dict HasZknd)
forall a. a -> Maybe a
Just Dict HasZknd
forall (c :: Constraint). c => Dict c
Dict); SBool Zknd
SFalse -> Maybe (Dict HasZknd)
forall a. Maybe a
Nothing
{-# NOINLINE queryZknd #-}

unsafeAssumeZkne :: (HasZkne => a) -> a
unsafeAssumeZkne :: forall a. (HasZkne => a) -> a
unsafeAssumeZkne HasZkne => a
k = case (Any :~: Any) -> Zkne :~: 'True
forall a b. a -> b
unsafeCoerce Any :~: Any
forall {k} (a :: k). a :~: a
Refl :: Zkne :~: True of Zkne :~: 'True
Refl -> a
HasZkne => a
k

queryZkne :: Maybe (Dict HasZkne)
queryZkne :: Maybe (Dict HasZkne)
queryZkne = case SBool Zkne
sZkne of SBool Zkne
STrue -> (HasZkne => Maybe (Dict HasZkne)) -> Maybe (Dict HasZkne)
forall a. (HasZkne => a) -> a
unsafeAssumeZkne (Dict HasZkne -> Maybe (Dict HasZkne)
forall a. a -> Maybe a
Just Dict HasZkne
forall (c :: Constraint). c => Dict c
Dict); SBool Zkne
SFalse -> Maybe (Dict HasZkne)
forall a. Maybe a
Nothing
{-# NOINLINE queryZkne #-}

unsafeAssumeZknh :: (HasZknh => a) -> a
unsafeAssumeZknh :: forall a. (HasZknh => a) -> a
unsafeAssumeZknh HasZknh => a
k = case (Any :~: Any) -> Zknh :~: 'True
forall a b. a -> b
unsafeCoerce Any :~: Any
forall {k} (a :: k). a :~: a
Refl :: Zknh :~: True of Zknh :~: 'True
Refl -> a
HasZknh => a
k

queryZknh :: Maybe (Dict HasZknh)
queryZknh :: Maybe (Dict HasZknh)
queryZknh = case SBool Zknh
sZknh of SBool Zknh
STrue -> (HasZknh => Maybe (Dict HasZknh)) -> Maybe (Dict HasZknh)
forall a. (HasZknh => a) -> a
unsafeAssumeZknh (Dict HasZknh -> Maybe (Dict HasZknh)
forall a. a -> Maybe a
Just Dict HasZknh
forall (c :: Constraint). c => Dict c
Dict); SBool Zknh
SFalse -> Maybe (Dict HasZknh)
forall a. Maybe a
Nothing
{-# NOINLINE queryZknh #-}

unsafeAssumeZksed :: (HasZksed => a) -> a
unsafeAssumeZksed :: forall a. (HasZksed => a) -> a
unsafeAssumeZksed HasZksed => a
k = case (Any :~: Any) -> Zksed :~: 'True
forall a b. a -> b
unsafeCoerce Any :~: Any
forall {k} (a :: k). a :~: a
Refl :: Zksed :~: True of Zksed :~: 'True
Refl -> a
HasZksed => a
k

queryZksed :: Maybe (Dict HasZksed)
queryZksed :: Maybe (Dict HasZksed)
queryZksed = case SBool Zksed
sZksed of SBool Zksed
STrue -> (HasZksed => Maybe (Dict HasZksed)) -> Maybe (Dict HasZksed)
forall a. (HasZksed => a) -> a
unsafeAssumeZksed (Dict HasZksed -> Maybe (Dict HasZksed)
forall a. a -> Maybe a
Just Dict HasZksed
forall (c :: Constraint). c => Dict c
Dict); SBool Zksed
SFalse -> Maybe (Dict HasZksed)
forall a. Maybe a
Nothing
{-# NOINLINE queryZksed #-}

unsafeAssumeZksh :: (HasZksh => a) -> a
unsafeAssumeZksh :: forall a. (HasZksh => a) -> a
unsafeAssumeZksh HasZksh => a
k = case (Any :~: Any) -> Zksh :~: 'True
forall a b. a -> b
unsafeCoerce Any :~: Any
forall {k} (a :: k). a :~: a
Refl :: Zksh :~: True of Zksh :~: 'True
Refl -> a
HasZksh => a
k

queryZksh :: Maybe (Dict HasZksh)
queryZksh :: Maybe (Dict HasZksh)
queryZksh = case SBool Zksh
sZksh of SBool Zksh
STrue -> (HasZksh => Maybe (Dict HasZksh)) -> Maybe (Dict HasZksh)
forall a. (HasZksh => a) -> a
unsafeAssumeZksh (Dict HasZksh -> Maybe (Dict HasZksh)
forall a. a -> Maybe a
Just Dict HasZksh
forall (c :: Constraint). c => Dict c
Dict); SBool Zksh
SFalse -> Maybe (Dict HasZksh)
forall a. Maybe a
Nothing
{-# NOINLINE queryZksh #-}

unsafeAssumeZkt :: (HasZkt => a) -> a
unsafeAssumeZkt :: forall a. (HasZkt => a) -> a
unsafeAssumeZkt HasZkt => a
k = case (Any :~: Any) -> Zkt :~: 'True
forall a b. a -> b
unsafeCoerce Any :~: Any
forall {k} (a :: k). a :~: a
Refl :: Zkt :~: True of Zkt :~: 'True
Refl -> a
HasZkt => a
k

queryZkt :: Maybe (Dict HasZkt)
queryZkt :: Maybe (Dict HasZkt)
queryZkt = case SBool Zkt
sZkt of SBool Zkt
STrue -> (HasZkt => Maybe (Dict HasZkt)) -> Maybe (Dict HasZkt)
forall a. (HasZkt => a) -> a
unsafeAssumeZkt (Dict HasZkt -> Maybe (Dict HasZkt)
forall a. a -> Maybe a
Just Dict HasZkt
forall (c :: Constraint). c => Dict c
Dict); SBool Zkt
SFalse -> Maybe (Dict HasZkt)
forall a. Maybe a
Nothing
{-# NOINLINE queryZkt #-}

unsafeAssumeZvbb :: (HasZvbb => a) -> a
unsafeAssumeZvbb :: forall a. (HasZvbb => a) -> a
unsafeAssumeZvbb HasZvbb => a
k = case (Any :~: Any) -> Zvbb :~: 'True
forall a b. a -> b
unsafeCoerce Any :~: Any
forall {k} (a :: k). a :~: a
Refl :: Zvbb :~: True of Zvbb :~: 'True
Refl -> a
HasZvbb => a
k

queryZvbb :: Maybe (Dict HasZvbb)
queryZvbb :: Maybe (Dict HasZvbb)
queryZvbb = case SBool Zvbb
sZvbb of SBool Zvbb
STrue -> (HasZvbb => Maybe (Dict HasZvbb)) -> Maybe (Dict HasZvbb)
forall a. (HasZvbb => a) -> a
unsafeAssumeZvbb (Dict HasZvbb -> Maybe (Dict HasZvbb)
forall a. a -> Maybe a
Just Dict HasZvbb
forall (c :: Constraint). c => Dict c
Dict); SBool Zvbb
SFalse -> Maybe (Dict HasZvbb)
forall a. Maybe a
Nothing
{-# NOINLINE queryZvbb #-}

unsafeAssumeZvbc :: (HasZvbc => a) -> a
unsafeAssumeZvbc :: forall a. (HasZvbc => a) -> a
unsafeAssumeZvbc HasZvbc => a
k = case (Any :~: Any) -> Zvbc :~: 'True
forall a b. a -> b
unsafeCoerce Any :~: Any
forall {k} (a :: k). a :~: a
Refl :: Zvbc :~: True of Zvbc :~: 'True
Refl -> a
HasZvbc => a
k

queryZvbc :: Maybe (Dict HasZvbc)
queryZvbc :: Maybe (Dict HasZvbc)
queryZvbc = case SBool Zvbc
sZvbc of SBool Zvbc
STrue -> (HasZvbc => Maybe (Dict HasZvbc)) -> Maybe (Dict HasZvbc)
forall a. (HasZvbc => a) -> a
unsafeAssumeZvbc (Dict HasZvbc -> Maybe (Dict HasZvbc)
forall a. a -> Maybe a
Just Dict HasZvbc
forall (c :: Constraint). c => Dict c
Dict); SBool Zvbc
SFalse -> Maybe (Dict HasZvbc)
forall a. Maybe a
Nothing
{-# NOINLINE queryZvbc #-}

unsafeAssumeZvkb :: (HasZvkb => a) -> a
unsafeAssumeZvkb :: forall a. (HasZvkb => a) -> a
unsafeAssumeZvkb HasZvkb => a
k = case (Any :~: Any) -> Zvkb :~: 'True
forall a b. a -> b
unsafeCoerce Any :~: Any
forall {k} (a :: k). a :~: a
Refl :: Zvkb :~: True of Zvkb :~: 'True
Refl -> a
HasZvkb => a
k

queryZvkb :: Maybe (Dict HasZvkb)
queryZvkb :: Maybe (Dict HasZvkb)
queryZvkb = case SBool Zvkb
sZvkb of SBool Zvkb
STrue -> (HasZvkb => Maybe (Dict HasZvkb)) -> Maybe (Dict HasZvkb)
forall a. (HasZvkb => a) -> a
unsafeAssumeZvkb (Dict HasZvkb -> Maybe (Dict HasZvkb)
forall a. a -> Maybe a
Just Dict HasZvkb
forall (c :: Constraint). c => Dict c
Dict); SBool Zvkb
SFalse -> Maybe (Dict HasZvkb)
forall a. Maybe a
Nothing
{-# NOINLINE queryZvkb #-}

unsafeAssumeZvkg :: (HasZvkg => a) -> a
unsafeAssumeZvkg :: forall a. (HasZvkg => a) -> a
unsafeAssumeZvkg HasZvkg => a
k = case (Any :~: Any) -> Zvkg :~: 'True
forall a b. a -> b
unsafeCoerce Any :~: Any
forall {k} (a :: k). a :~: a
Refl :: Zvkg :~: True of Zvkg :~: 'True
Refl -> a
HasZvkg => a
k

queryZvkg :: Maybe (Dict HasZvkg)
queryZvkg :: Maybe (Dict HasZvkg)
queryZvkg = case SBool Zvkg
sZvkg of SBool Zvkg
STrue -> (HasZvkg => Maybe (Dict HasZvkg)) -> Maybe (Dict HasZvkg)
forall a. (HasZvkg => a) -> a
unsafeAssumeZvkg (Dict HasZvkg -> Maybe (Dict HasZvkg)
forall a. a -> Maybe a
Just Dict HasZvkg
forall (c :: Constraint). c => Dict c
Dict); SBool Zvkg
SFalse -> Maybe (Dict HasZvkg)
forall a. Maybe a
Nothing
{-# NOINLINE queryZvkg #-}

unsafeAssumeZvkned :: (HasZvkned => a) -> a
unsafeAssumeZvkned :: forall a. (HasZvkned => a) -> a
unsafeAssumeZvkned HasZvkned => a
k = case (Any :~: Any) -> Zvkned :~: 'True
forall a b. a -> b
unsafeCoerce Any :~: Any
forall {k} (a :: k). a :~: a
Refl :: Zvkned :~: True of Zvkned :~: 'True
Refl -> a
HasZvkned => a
k

queryZvkned :: Maybe (Dict HasZvkned)
queryZvkned :: Maybe (Dict HasZvkned)
queryZvkned = case SBool Zvkned
sZvkned of SBool Zvkned
STrue -> (HasZvkned => Maybe (Dict HasZvkned)) -> Maybe (Dict HasZvkned)
forall a. (HasZvkned => a) -> a
unsafeAssumeZvkned (Dict HasZvkned -> Maybe (Dict HasZvkned)
forall a. a -> Maybe a
Just Dict HasZvkned
forall (c :: Constraint). c => Dict c
Dict); SBool Zvkned
SFalse -> Maybe (Dict HasZvkned)
forall a. Maybe a
Nothing
{-# NOINLINE queryZvkned #-}

unsafeAssumeZvknha :: (HasZvknha => a) -> a
unsafeAssumeZvknha :: forall a. (HasZvknha => a) -> a
unsafeAssumeZvknha HasZvknha => a
k = case (Any :~: Any) -> Zvknha :~: 'True
forall a b. a -> b
unsafeCoerce Any :~: Any
forall {k} (a :: k). a :~: a
Refl :: Zvknha :~: True of Zvknha :~: 'True
Refl -> a
HasZvknha => a
k

queryZvknha :: Maybe (Dict HasZvknha)
queryZvknha :: Maybe (Dict HasZvknha)
queryZvknha = case SBool Zvknha
sZvknha of SBool Zvknha
STrue -> (HasZvknha => Maybe (Dict HasZvknha)) -> Maybe (Dict HasZvknha)
forall a. (HasZvknha => a) -> a
unsafeAssumeZvknha (Dict HasZvknha -> Maybe (Dict HasZvknha)
forall a. a -> Maybe a
Just Dict HasZvknha
forall (c :: Constraint). c => Dict c
Dict); SBool Zvknha
SFalse -> Maybe (Dict HasZvknha)
forall a. Maybe a
Nothing
{-# NOINLINE queryZvknha #-}

unsafeAssumeZvknhb :: (HasZvknhb => a) -> a
unsafeAssumeZvknhb :: forall a. (HasZvknhb => a) -> a
unsafeAssumeZvknhb HasZvknhb => a
k = case (Any :~: Any) -> Zvknhb :~: 'True
forall a b. a -> b
unsafeCoerce Any :~: Any
forall {k} (a :: k). a :~: a
Refl :: Zvknhb :~: True of Zvknhb :~: 'True
Refl -> a
HasZvknhb => a
k

queryZvknhb :: Maybe (Dict HasZvknhb)
queryZvknhb :: Maybe (Dict HasZvknhb)
queryZvknhb = case SBool Zvknhb
sZvknhb of SBool Zvknhb
STrue -> (HasZvknhb => Maybe (Dict HasZvknhb)) -> Maybe (Dict HasZvknhb)
forall a. (HasZvknhb => a) -> a
unsafeAssumeZvknhb (Dict HasZvknhb -> Maybe (Dict HasZvknhb)
forall a. a -> Maybe a
Just Dict HasZvknhb
forall (c :: Constraint). c => Dict c
Dict); SBool Zvknhb
SFalse -> Maybe (Dict HasZvknhb)
forall a. Maybe a
Nothing
{-# NOINLINE queryZvknhb #-}

unsafeAssumeZvksed :: (HasZvksed => a) -> a
unsafeAssumeZvksed :: forall a. (HasZvksed => a) -> a
unsafeAssumeZvksed HasZvksed => a
k = case (Any :~: Any) -> Zvksed :~: 'True
forall a b. a -> b
unsafeCoerce Any :~: Any
forall {k} (a :: k). a :~: a
Refl :: Zvksed :~: True of Zvksed :~: 'True
Refl -> a
HasZvksed => a
k

queryZvksed :: Maybe (Dict HasZvksed)
queryZvksed :: Maybe (Dict HasZvksed)
queryZvksed = case SBool Zvksed
sZvksed of SBool Zvksed
STrue -> (HasZvksed => Maybe (Dict HasZvksed)) -> Maybe (Dict HasZvksed)
forall a. (HasZvksed => a) -> a
unsafeAssumeZvksed (Dict HasZvksed -> Maybe (Dict HasZvksed)
forall a. a -> Maybe a
Just Dict HasZvksed
forall (c :: Constraint). c => Dict c
Dict); SBool Zvksed
SFalse -> Maybe (Dict HasZvksed)
forall a. Maybe a
Nothing
{-# NOINLINE queryZvksed #-}

unsafeAssumeZvksh :: (HasZvksh => a) -> a
unsafeAssumeZvksh :: forall a. (HasZvksh => a) -> a
unsafeAssumeZvksh HasZvksh => a
k = case (Any :~: Any) -> Zvksh :~: 'True
forall a b. a -> b
unsafeCoerce Any :~: Any
forall {k} (a :: k). a :~: a
Refl :: Zvksh :~: True of Zvksh :~: 'True
Refl -> a
HasZvksh => a
k

queryZvksh :: Maybe (Dict HasZvksh)
queryZvksh :: Maybe (Dict HasZvksh)
queryZvksh = case SBool Zvksh
sZvksh of SBool Zvksh
STrue -> (HasZvksh => Maybe (Dict HasZvksh)) -> Maybe (Dict HasZvksh)
forall a. (HasZvksh => a) -> a
unsafeAssumeZvksh (Dict HasZvksh -> Maybe (Dict HasZvksh)
forall a. a -> Maybe a
Just Dict HasZvksh
forall (c :: Constraint). c => Dict c
Dict); SBool Zvksh
SFalse -> Maybe (Dict HasZvksh)
forall a. Maybe a
Nothing
{-# NOINLINE queryZvksh #-}

unsafeAssumeZvkt :: (HasZvkt => a) -> a
unsafeAssumeZvkt :: forall a. (HasZvkt => a) -> a
unsafeAssumeZvkt HasZvkt => a
k = case (Any :~: Any) -> Zvkt :~: 'True
forall a b. a -> b
unsafeCoerce Any :~: Any
forall {k} (a :: k). a :~: a
Refl :: Zvkt :~: True of Zvkt :~: 'True
Refl -> a
HasZvkt => a
k

queryZvkt :: Maybe (Dict HasZvkt)
queryZvkt :: Maybe (Dict HasZvkt)
queryZvkt = case SBool Zvkt
sZvkt of SBool Zvkt
STrue -> (HasZvkt => Maybe (Dict HasZvkt)) -> Maybe (Dict HasZvkt)
forall a. (HasZvkt => a) -> a
unsafeAssumeZvkt (Dict HasZvkt -> Maybe (Dict HasZvkt)
forall a. a -> Maybe a
Just Dict HasZvkt
forall (c :: Constraint). c => Dict c
Dict); SBool Zvkt
SFalse -> Maybe (Dict HasZvkt)
forall a. Maybe a
Nothing
{-# NOINLINE queryZvkt #-}

unsafeAssumeZfh :: (HasZfh => a) -> a
unsafeAssumeZfh :: forall a. (HasZfh => a) -> a
unsafeAssumeZfh HasZfh => a
k = case (Any :~: Any) -> Zfh :~: 'True
forall a b. a -> b
unsafeCoerce Any :~: Any
forall {k} (a :: k). a :~: a
Refl :: Zfh :~: True of Zfh :~: 'True
Refl -> a
HasZfh => a
k

queryZfh :: Maybe (Dict HasZfh)
queryZfh :: Maybe (Dict HasZfh)
queryZfh = case SBool Zfh
sZfh of SBool Zfh
STrue -> (HasZfh => Maybe (Dict HasZfh)) -> Maybe (Dict HasZfh)
forall a. (HasZfh => a) -> a
unsafeAssumeZfh (Dict HasZfh -> Maybe (Dict HasZfh)
forall a. a -> Maybe a
Just Dict HasZfh
forall (c :: Constraint). c => Dict c
Dict); SBool Zfh
SFalse -> Maybe (Dict HasZfh)
forall a. Maybe a
Nothing
{-# NOINLINE queryZfh #-}

unsafeAssumeZfhmin :: (HasZfhmin => a) -> a
unsafeAssumeZfhmin :: forall a. (HasZfhmin => a) -> a
unsafeAssumeZfhmin HasZfhmin => a
k = case (Any :~: Any) -> Zfhmin :~: 'True
forall a b. a -> b
unsafeCoerce Any :~: Any
forall {k} (a :: k). a :~: a
Refl :: Zfhmin :~: True of Zfhmin :~: 'True
Refl -> a
HasZfhmin => a
k

queryZfhmin :: Maybe (Dict HasZfhmin)
queryZfhmin :: Maybe (Dict HasZfhmin)
queryZfhmin = case SBool Zfhmin
sZfhmin of SBool Zfhmin
STrue -> (HasZfhmin => Maybe (Dict HasZfhmin)) -> Maybe (Dict HasZfhmin)
forall a. (HasZfhmin => a) -> a
unsafeAssumeZfhmin (Dict HasZfhmin -> Maybe (Dict HasZfhmin)
forall a. a -> Maybe a
Just Dict HasZfhmin
forall (c :: Constraint). c => Dict c
Dict); SBool Zfhmin
SFalse -> Maybe (Dict HasZfhmin)
forall a. Maybe a
Nothing
{-# NOINLINE queryZfhmin #-}

unsafeAssumeZihintntl :: (HasZihintntl => a) -> a
unsafeAssumeZihintntl :: forall a. (HasZihintntl => a) -> a
unsafeAssumeZihintntl HasZihintntl => a
k = case (Any :~: Any) -> Zihintntl :~: 'True
forall a b. a -> b
unsafeCoerce Any :~: Any
forall {k} (a :: k). a :~: a
Refl :: Zihintntl :~: True of Zihintntl :~: 'True
Refl -> a
HasZihintntl => a
k

queryZihintntl :: Maybe (Dict HasZihintntl)
queryZihintntl :: Maybe (Dict HasZihintntl)
queryZihintntl = case SBool Zihintntl
sZihintntl of SBool Zihintntl
STrue -> (HasZihintntl => Maybe (Dict HasZihintntl))
-> Maybe (Dict HasZihintntl)
forall a. (HasZihintntl => a) -> a
unsafeAssumeZihintntl (Dict HasZihintntl -> Maybe (Dict HasZihintntl)
forall a. a -> Maybe a
Just Dict HasZihintntl
forall (c :: Constraint). c => Dict c
Dict); SBool Zihintntl
SFalse -> Maybe (Dict HasZihintntl)
forall a. Maybe a
Nothing
{-# NOINLINE queryZihintntl #-}

unsafeAssumeZvfh :: (HasZvfh => a) -> a
unsafeAssumeZvfh :: forall a. (HasZvfh => a) -> a
unsafeAssumeZvfh HasZvfh => a
k = case (Any :~: Any) -> Zvfh :~: 'True
forall a b. a -> b
unsafeCoerce Any :~: Any
forall {k} (a :: k). a :~: a
Refl :: Zvfh :~: True of Zvfh :~: 'True
Refl -> a
HasZvfh => a
k

queryZvfh :: Maybe (Dict HasZvfh)
queryZvfh :: Maybe (Dict HasZvfh)
queryZvfh = case SBool Zvfh
sZvfh of SBool Zvfh
STrue -> (HasZvfh => Maybe (Dict HasZvfh)) -> Maybe (Dict HasZvfh)
forall a. (HasZvfh => a) -> a
unsafeAssumeZvfh (Dict HasZvfh -> Maybe (Dict HasZvfh)
forall a. a -> Maybe a
Just Dict HasZvfh
forall (c :: Constraint). c => Dict c
Dict); SBool Zvfh
SFalse -> Maybe (Dict HasZvfh)
forall a. Maybe a
Nothing
{-# NOINLINE queryZvfh #-}

unsafeAssumeZvfhmin :: (HasZvfhmin => a) -> a
unsafeAssumeZvfhmin :: forall a. (HasZvfhmin => a) -> a
unsafeAssumeZvfhmin HasZvfhmin => a
k = case (Any :~: Any) -> Zvfhmin :~: 'True
forall a b. a -> b
unsafeCoerce Any :~: Any
forall {k} (a :: k). a :~: a
Refl :: Zvfhmin :~: True of Zvfhmin :~: 'True
Refl -> a
HasZvfhmin => a
k

queryZvfhmin :: Maybe (Dict HasZvfhmin)
queryZvfhmin :: Maybe (Dict HasZvfhmin)
queryZvfhmin = case SBool Zvfhmin
sZvfhmin of SBool Zvfhmin
STrue -> (HasZvfhmin => Maybe (Dict HasZvfhmin)) -> Maybe (Dict HasZvfhmin)
forall a. (HasZvfhmin => a) -> a
unsafeAssumeZvfhmin (Dict HasZvfhmin -> Maybe (Dict HasZvfhmin)
forall a. a -> Maybe a
Just Dict HasZvfhmin
forall (c :: Constraint). c => Dict c
Dict); SBool Zvfhmin
SFalse -> Maybe (Dict HasZvfhmin)
forall a. Maybe a
Nothing
{-# NOINLINE queryZvfhmin #-}

unsafeAssumeZfa :: (HasZfa => a) -> a
unsafeAssumeZfa :: forall a. (HasZfa => a) -> a
unsafeAssumeZfa HasZfa => a
k = case (Any :~: Any) -> Zfa :~: 'True
forall a b. a -> b
unsafeCoerce Any :~: Any
forall {k} (a :: k). a :~: a
Refl :: Zfa :~: True of Zfa :~: 'True
Refl -> a
HasZfa => a
k

queryZfa :: Maybe (Dict HasZfa)
queryZfa :: Maybe (Dict HasZfa)
queryZfa = case SBool Zfa
sZfa of SBool Zfa
STrue -> (HasZfa => Maybe (Dict HasZfa)) -> Maybe (Dict HasZfa)
forall a. (HasZfa => a) -> a
unsafeAssumeZfa (Dict HasZfa -> Maybe (Dict HasZfa)
forall a. a -> Maybe a
Just Dict HasZfa
forall (c :: Constraint). c => Dict c
Dict); SBool Zfa
SFalse -> Maybe (Dict HasZfa)
forall a. Maybe a
Nothing
{-# NOINLINE queryZfa #-}

unsafeAssumeZtso :: (HasZtso => a) -> a
unsafeAssumeZtso :: forall a. (HasZtso => a) -> a
unsafeAssumeZtso HasZtso => a
k = case (Any :~: Any) -> Ztso :~: 'True
forall a b. a -> b
unsafeCoerce Any :~: Any
forall {k} (a :: k). a :~: a
Refl :: Ztso :~: True of Ztso :~: 'True
Refl -> a
HasZtso => a
k

queryZtso :: Maybe (Dict HasZtso)
queryZtso :: Maybe (Dict HasZtso)
queryZtso = case SBool Ztso
sZtso of SBool Ztso
STrue -> (HasZtso => Maybe (Dict HasZtso)) -> Maybe (Dict HasZtso)
forall a. (HasZtso => a) -> a
unsafeAssumeZtso (Dict HasZtso -> Maybe (Dict HasZtso)
forall a. a -> Maybe a
Just Dict HasZtso
forall (c :: Constraint). c => Dict c
Dict); SBool Ztso
SFalse -> Maybe (Dict HasZtso)
forall a. Maybe a
Nothing
{-# NOINLINE queryZtso #-}

unsafeAssumeZacas :: (HasZacas => a) -> a
unsafeAssumeZacas :: forall a. (HasZacas => a) -> a
unsafeAssumeZacas HasZacas => a
k = case (Any :~: Any) -> Zacas :~: 'True
forall a b. a -> b
unsafeCoerce Any :~: Any
forall {k} (a :: k). a :~: a
Refl :: Zacas :~: True of Zacas :~: 'True
Refl -> a
HasZacas => a
k

queryZacas :: Maybe (Dict HasZacas)
queryZacas :: Maybe (Dict HasZacas)
queryZacas = case SBool Zacas
sZacas of SBool Zacas
STrue -> (HasZacas => Maybe (Dict HasZacas)) -> Maybe (Dict HasZacas)
forall a. (HasZacas => a) -> a
unsafeAssumeZacas (Dict HasZacas -> Maybe (Dict HasZacas)
forall a. a -> Maybe a
Just Dict HasZacas
forall (c :: Constraint). c => Dict c
Dict); SBool Zacas
SFalse -> Maybe (Dict HasZacas)
forall a. Maybe a
Nothing
{-# NOINLINE queryZacas #-}

unsafeAssumeZicntr :: (HasZicntr => a) -> a
unsafeAssumeZicntr :: forall a. (HasZicntr => a) -> a
unsafeAssumeZicntr HasZicntr => a
k = case (Any :~: Any) -> Zicntr :~: 'True
forall a b. a -> b
unsafeCoerce Any :~: Any
forall {k} (a :: k). a :~: a
Refl :: Zicntr :~: True of Zicntr :~: 'True
Refl -> a
HasZicntr => a
k

queryZicntr :: Maybe (Dict HasZicntr)
queryZicntr :: Maybe (Dict HasZicntr)
queryZicntr = case SBool Zicntr
sZicntr of SBool Zicntr
STrue -> (HasZicntr => Maybe (Dict HasZicntr)) -> Maybe (Dict HasZicntr)
forall a. (HasZicntr => a) -> a
unsafeAssumeZicntr (Dict HasZicntr -> Maybe (Dict HasZicntr)
forall a. a -> Maybe a
Just Dict HasZicntr
forall (c :: Constraint). c => Dict c
Dict); SBool Zicntr
SFalse -> Maybe (Dict HasZicntr)
forall a. Maybe a
Nothing
{-# NOINLINE queryZicntr #-}

unsafeAssumeZicond :: (HasZicond => a) -> a
unsafeAssumeZicond :: forall a. (HasZicond => a) -> a
unsafeAssumeZicond HasZicond => a
k = case (Any :~: Any) -> Zicond :~: 'True
forall a b. a -> b
unsafeCoerce Any :~: Any
forall {k} (a :: k). a :~: a
Refl :: Zicond :~: True of Zicond :~: 'True
Refl -> a
HasZicond => a
k

queryZicond :: Maybe (Dict HasZicond)
queryZicond :: Maybe (Dict HasZicond)
queryZicond = case SBool Zicond
sZicond of SBool Zicond
STrue -> (HasZicond => Maybe (Dict HasZicond)) -> Maybe (Dict HasZicond)
forall a. (HasZicond => a) -> a
unsafeAssumeZicond (Dict HasZicond -> Maybe (Dict HasZicond)
forall a. a -> Maybe a
Just Dict HasZicond
forall (c :: Constraint). c => Dict c
Dict); SBool Zicond
SFalse -> Maybe (Dict HasZicond)
forall a. Maybe a
Nothing
{-# NOINLINE queryZicond #-}

unsafeAssumeZihintpause :: (HasZihintpause => a) -> a
unsafeAssumeZihintpause :: forall a. (HasZihintpause => a) -> a
unsafeAssumeZihintpause HasZihintpause => a
k = case (Any :~: Any) -> Zihintpause :~: 'True
forall a b. a -> b
unsafeCoerce Any :~: Any
forall {k} (a :: k). a :~: a
Refl :: Zihintpause :~: True of Zihintpause :~: 'True
Refl -> a
HasZihintpause => a
k

queryZihintpause :: Maybe (Dict HasZihintpause)
queryZihintpause :: Maybe (Dict HasZihintpause)
queryZihintpause = case SBool Zihintpause
sZihintpause of SBool Zihintpause
STrue -> (HasZihintpause => Maybe (Dict HasZihintpause))
-> Maybe (Dict HasZihintpause)
forall a. (HasZihintpause => a) -> a
unsafeAssumeZihintpause (Dict HasZihintpause -> Maybe (Dict HasZihintpause)
forall a. a -> Maybe a
Just Dict HasZihintpause
forall (c :: Constraint). c => Dict c
Dict); SBool Zihintpause
SFalse -> Maybe (Dict HasZihintpause)
forall a. Maybe a
Nothing
{-# NOINLINE queryZihintpause #-}

unsafeAssumeZihpm :: (HasZihpm => a) -> a
unsafeAssumeZihpm :: forall a. (HasZihpm => a) -> a
unsafeAssumeZihpm HasZihpm => a
k = case (Any :~: Any) -> Zihpm :~: 'True
forall a b. a -> b
unsafeCoerce Any :~: Any
forall {k} (a :: k). a :~: a
Refl :: Zihpm :~: True of Zihpm :~: 'True
Refl -> a
HasZihpm => a
k

queryZihpm :: Maybe (Dict HasZihpm)
queryZihpm :: Maybe (Dict HasZihpm)
queryZihpm = case SBool Zihpm
sZihpm of SBool Zihpm
STrue -> (HasZihpm => Maybe (Dict HasZihpm)) -> Maybe (Dict HasZihpm)
forall a. (HasZihpm => a) -> a
unsafeAssumeZihpm (Dict HasZihpm -> Maybe (Dict HasZihpm)
forall a. a -> Maybe a
Just Dict HasZihpm
forall (c :: Constraint). c => Dict c
Dict); SBool Zihpm
SFalse -> Maybe (Dict HasZihpm)
forall a. Maybe a
Nothing
{-# NOINLINE queryZihpm #-}

unsafeAssumeZve32x :: (HasZve32x => a) -> a
unsafeAssumeZve32x :: forall a. (HasZve32x => a) -> a
unsafeAssumeZve32x HasZve32x => a
k = case (Any :~: Any) -> Zve32x :~: 'True
forall a b. a -> b
unsafeCoerce Any :~: Any
forall {k} (a :: k). a :~: a
Refl :: Zve32x :~: True of Zve32x :~: 'True
Refl -> a
HasZve32x => a
k

queryZve32x :: Maybe (Dict HasZve32x)
queryZve32x :: Maybe (Dict HasZve32x)
queryZve32x = case SBool Zve32x
sZve32x of SBool Zve32x
STrue -> (HasZve32x => Maybe (Dict HasZve32x)) -> Maybe (Dict HasZve32x)
forall a. (HasZve32x => a) -> a
unsafeAssumeZve32x (Dict HasZve32x -> Maybe (Dict HasZve32x)
forall a. a -> Maybe a
Just Dict HasZve32x
forall (c :: Constraint). c => Dict c
Dict); SBool Zve32x
SFalse -> Maybe (Dict HasZve32x)
forall a. Maybe a
Nothing
{-# NOINLINE queryZve32x #-}

unsafeAssumeZve32f :: (HasZve32f => a) -> a
unsafeAssumeZve32f :: forall a. (HasZve32f => a) -> a
unsafeAssumeZve32f HasZve32f => a
k = case (Any :~: Any) -> Zve32f :~: 'True
forall a b. a -> b
unsafeCoerce Any :~: Any
forall {k} (a :: k). a :~: a
Refl :: Zve32f :~: True of Zve32f :~: 'True
Refl -> a
HasZve32f => a
k

queryZve32f :: Maybe (Dict HasZve32f)
queryZve32f :: Maybe (Dict HasZve32f)
queryZve32f = case SBool Zve32f
sZve32f of SBool Zve32f
STrue -> (HasZve32f => Maybe (Dict HasZve32f)) -> Maybe (Dict HasZve32f)
forall a. (HasZve32f => a) -> a
unsafeAssumeZve32f (Dict HasZve32f -> Maybe (Dict HasZve32f)
forall a. a -> Maybe a
Just Dict HasZve32f
forall (c :: Constraint). c => Dict c
Dict); SBool Zve32f
SFalse -> Maybe (Dict HasZve32f)
forall a. Maybe a
Nothing
{-# NOINLINE queryZve32f #-}

unsafeAssumeZve64x :: (HasZve64x => a) -> a
unsafeAssumeZve64x :: forall a. (HasZve64x => a) -> a
unsafeAssumeZve64x HasZve64x => a
k = case (Any :~: Any) -> Zve64x :~: 'True
forall a b. a -> b
unsafeCoerce Any :~: Any
forall {k} (a :: k). a :~: a
Refl :: Zve64x :~: True of Zve64x :~: 'True
Refl -> a
HasZve64x => a
k

queryZve64x :: Maybe (Dict HasZve64x)
queryZve64x :: Maybe (Dict HasZve64x)
queryZve64x = case SBool Zve64x
sZve64x of SBool Zve64x
STrue -> (HasZve64x => Maybe (Dict HasZve64x)) -> Maybe (Dict HasZve64x)
forall a. (HasZve64x => a) -> a
unsafeAssumeZve64x (Dict HasZve64x -> Maybe (Dict HasZve64x)
forall a. a -> Maybe a
Just Dict HasZve64x
forall (c :: Constraint). c => Dict c
Dict); SBool Zve64x
SFalse -> Maybe (Dict HasZve64x)
forall a. Maybe a
Nothing
{-# NOINLINE queryZve64x #-}

unsafeAssumeZve64f :: (HasZve64f => a) -> a
unsafeAssumeZve64f :: forall a. (HasZve64f => a) -> a
unsafeAssumeZve64f HasZve64f => a
k = case (Any :~: Any) -> Zve64f :~: 'True
forall a b. a -> b
unsafeCoerce Any :~: Any
forall {k} (a :: k). a :~: a
Refl :: Zve64f :~: True of Zve64f :~: 'True
Refl -> a
HasZve64f => a
k

queryZve64f :: Maybe (Dict HasZve64f)
queryZve64f :: Maybe (Dict HasZve64f)
queryZve64f = case SBool Zve64f
sZve64f of SBool Zve64f
STrue -> (HasZve64f => Maybe (Dict HasZve64f)) -> Maybe (Dict HasZve64f)
forall a. (HasZve64f => a) -> a
unsafeAssumeZve64f (Dict HasZve64f -> Maybe (Dict HasZve64f)
forall a. a -> Maybe a
Just Dict HasZve64f
forall (c :: Constraint). c => Dict c
Dict); SBool Zve64f
SFalse -> Maybe (Dict HasZve64f)
forall a. Maybe a
Nothing
{-# NOINLINE queryZve64f #-}

unsafeAssumeZve64d :: (HasZve64d => a) -> a
unsafeAssumeZve64d :: forall a. (HasZve64d => a) -> a
unsafeAssumeZve64d HasZve64d => a
k = case (Any :~: Any) -> Zve64d :~: 'True
forall a b. a -> b
unsafeCoerce Any :~: Any
forall {k} (a :: k). a :~: a
Refl :: Zve64d :~: True of Zve64d :~: 'True
Refl -> a
HasZve64d => a
k

queryZve64d :: Maybe (Dict HasZve64d)
queryZve64d :: Maybe (Dict HasZve64d)
queryZve64d = case SBool Zve64d
sZve64d of SBool Zve64d
STrue -> (HasZve64d => Maybe (Dict HasZve64d)) -> Maybe (Dict HasZve64d)
forall a. (HasZve64d => a) -> a
unsafeAssumeZve64d (Dict HasZve64d -> Maybe (Dict HasZve64d)
forall a. a -> Maybe a
Just Dict HasZve64d
forall (c :: Constraint). c => Dict c
Dict); SBool Zve64d
SFalse -> Maybe (Dict HasZve64d)
forall a. Maybe a
Nothing
{-# NOINLINE queryZve64d #-}

unsafeAssumeZimop :: (HasZimop => a) -> a
unsafeAssumeZimop :: forall a. (HasZimop => a) -> a
unsafeAssumeZimop HasZimop => a
k = case (Any :~: Any) -> Zimop :~: 'True
forall a b. a -> b
unsafeCoerce Any :~: Any
forall {k} (a :: k). a :~: a
Refl :: Zimop :~: True of Zimop :~: 'True
Refl -> a
HasZimop => a
k

queryZimop :: Maybe (Dict HasZimop)
queryZimop :: Maybe (Dict HasZimop)
queryZimop = case SBool Zimop
sZimop of SBool Zimop
STrue -> (HasZimop => Maybe (Dict HasZimop)) -> Maybe (Dict HasZimop)
forall a. (HasZimop => a) -> a
unsafeAssumeZimop (Dict HasZimop -> Maybe (Dict HasZimop)
forall a. a -> Maybe a
Just Dict HasZimop
forall (c :: Constraint). c => Dict c
Dict); SBool Zimop
SFalse -> Maybe (Dict HasZimop)
forall a. Maybe a
Nothing
{-# NOINLINE queryZimop #-}

unsafeAssumeZca :: (HasZca => a) -> a
unsafeAssumeZca :: forall a. (HasZca => a) -> a
unsafeAssumeZca HasZca => a
k = case (Any :~: Any) -> Zca :~: 'True
forall a b. a -> b
unsafeCoerce Any :~: Any
forall {k} (a :: k). a :~: a
Refl :: Zca :~: True of Zca :~: 'True
Refl -> a
HasZca => a
k

queryZca :: Maybe (Dict HasZca)
queryZca :: Maybe (Dict HasZca)
queryZca = case SBool Zca
sZca of SBool Zca
STrue -> (HasZca => Maybe (Dict HasZca)) -> Maybe (Dict HasZca)
forall a. (HasZca => a) -> a
unsafeAssumeZca (Dict HasZca -> Maybe (Dict HasZca)
forall a. a -> Maybe a
Just Dict HasZca
forall (c :: Constraint). c => Dict c
Dict); SBool Zca
SFalse -> Maybe (Dict HasZca)
forall a. Maybe a
Nothing
{-# NOINLINE queryZca #-}

unsafeAssumeZcb :: (HasZcb => a) -> a
unsafeAssumeZcb :: forall a. (HasZcb => a) -> a
unsafeAssumeZcb HasZcb => a
k = case (Any :~: Any) -> Zcb :~: 'True
forall a b. a -> b
unsafeCoerce Any :~: Any
forall {k} (a :: k). a :~: a
Refl :: Zcb :~: True of Zcb :~: 'True
Refl -> a
HasZcb => a
k

queryZcb :: Maybe (Dict HasZcb)
queryZcb :: Maybe (Dict HasZcb)
queryZcb = case SBool Zcb
sZcb of SBool Zcb
STrue -> (HasZcb => Maybe (Dict HasZcb)) -> Maybe (Dict HasZcb)
forall a. (HasZcb => a) -> a
unsafeAssumeZcb (Dict HasZcb -> Maybe (Dict HasZcb)
forall a. a -> Maybe a
Just Dict HasZcb
forall (c :: Constraint). c => Dict c
Dict); SBool Zcb
SFalse -> Maybe (Dict HasZcb)
forall a. Maybe a
Nothing
{-# NOINLINE queryZcb #-}

unsafeAssumeZcd :: (HasZcd => a) -> a
unsafeAssumeZcd :: forall a. (HasZcd => a) -> a
unsafeAssumeZcd HasZcd => a
k = case (Any :~: Any) -> Zcd :~: 'True
forall a b. a -> b
unsafeCoerce Any :~: Any
forall {k} (a :: k). a :~: a
Refl :: Zcd :~: True of Zcd :~: 'True
Refl -> a
HasZcd => a
k

queryZcd :: Maybe (Dict HasZcd)
queryZcd :: Maybe (Dict HasZcd)
queryZcd = case SBool Zcd
sZcd of SBool Zcd
STrue -> (HasZcd => Maybe (Dict HasZcd)) -> Maybe (Dict HasZcd)
forall a. (HasZcd => a) -> a
unsafeAssumeZcd (Dict HasZcd -> Maybe (Dict HasZcd)
forall a. a -> Maybe a
Just Dict HasZcd
forall (c :: Constraint). c => Dict c
Dict); SBool Zcd
SFalse -> Maybe (Dict HasZcd)
forall a. Maybe a
Nothing
{-# NOINLINE queryZcd #-}

unsafeAssumeZcf :: (HasZcf => a) -> a
unsafeAssumeZcf :: forall a. (HasZcf => a) -> a
unsafeAssumeZcf HasZcf => a
k = case (Any :~: Any) -> Zcf :~: 'True
forall a b. a -> b
unsafeCoerce Any :~: Any
forall {k} (a :: k). a :~: a
Refl :: Zcf :~: True of Zcf :~: 'True
Refl -> a
HasZcf => a
k

queryZcf :: Maybe (Dict HasZcf)
queryZcf :: Maybe (Dict HasZcf)
queryZcf = case SBool Zcf
sZcf of SBool Zcf
STrue -> (HasZcf => Maybe (Dict HasZcf)) -> Maybe (Dict HasZcf)
forall a. (HasZcf => a) -> a
unsafeAssumeZcf (Dict HasZcf -> Maybe (Dict HasZcf)
forall a. a -> Maybe a
Just Dict HasZcf
forall (c :: Constraint). c => Dict c
Dict); SBool Zcf
SFalse -> Maybe (Dict HasZcf)
forall a. Maybe a
Nothing
{-# NOINLINE queryZcf #-}

unsafeAssumeZcmop :: (HasZcmop => a) -> a
unsafeAssumeZcmop :: forall a. (HasZcmop => a) -> a
unsafeAssumeZcmop HasZcmop => a
k = case (Any :~: Any) -> Zcmop :~: 'True
forall a b. a -> b
unsafeCoerce Any :~: Any
forall {k} (a :: k). a :~: a
Refl :: Zcmop :~: True of Zcmop :~: 'True
Refl -> a
HasZcmop => a
k

queryZcmop :: Maybe (Dict HasZcmop)
queryZcmop :: Maybe (Dict HasZcmop)
queryZcmop = case SBool Zcmop
sZcmop of SBool Zcmop
STrue -> (HasZcmop => Maybe (Dict HasZcmop)) -> Maybe (Dict HasZcmop)
forall a. (HasZcmop => a) -> a
unsafeAssumeZcmop (Dict HasZcmop -> Maybe (Dict HasZcmop)
forall a. a -> Maybe a
Just Dict HasZcmop
forall (c :: Constraint). c => Dict c
Dict); SBool Zcmop
SFalse -> Maybe (Dict HasZcmop)
forall a. Maybe a
Nothing
{-# NOINLINE queryZcmop #-}

unsafeAssumeZawrs :: (HasZawrs => a) -> a
unsafeAssumeZawrs :: forall a. (HasZawrs => a) -> a
unsafeAssumeZawrs HasZawrs => a
k = case (Any :~: Any) -> Zawrs :~: 'True
forall a b. a -> b
unsafeCoerce Any :~: Any
forall {k} (a :: k). a :~: a
Refl :: Zawrs :~: True of Zawrs :~: 'True
Refl -> a
HasZawrs => a
k

queryZawrs :: Maybe (Dict HasZawrs)
queryZawrs :: Maybe (Dict HasZawrs)
queryZawrs = case SBool Zawrs
sZawrs of SBool Zawrs
STrue -> (HasZawrs => Maybe (Dict HasZawrs)) -> Maybe (Dict HasZawrs)
forall a. (HasZawrs => a) -> a
unsafeAssumeZawrs (Dict HasZawrs -> Maybe (Dict HasZawrs)
forall a. a -> Maybe a
Just Dict HasZawrs
forall (c :: Constraint). c => Dict c
Dict); SBool Zawrs
SFalse -> Maybe (Dict HasZawrs)
forall a. Maybe a
Nothing
{-# NOINLINE queryZawrs #-}

unsafeAssumeZaamo :: (HasZaamo => a) -> a
unsafeAssumeZaamo :: forall a. (HasZaamo => a) -> a
unsafeAssumeZaamo HasZaamo => a
k = case (Any :~: Any) -> Zaamo :~: 'True
forall a b. a -> b
unsafeCoerce Any :~: Any
forall {k} (a :: k). a :~: a
Refl :: Zaamo :~: True of Zaamo :~: 'True
Refl -> a
HasZaamo => a
k

queryZaamo :: Maybe (Dict HasZaamo)
queryZaamo :: Maybe (Dict HasZaamo)
queryZaamo = case SBool Zaamo
sZaamo of SBool Zaamo
STrue -> (HasZaamo => Maybe (Dict HasZaamo)) -> Maybe (Dict HasZaamo)
forall a. (HasZaamo => a) -> a
unsafeAssumeZaamo (Dict HasZaamo -> Maybe (Dict HasZaamo)
forall a. a -> Maybe a
Just Dict HasZaamo
forall (c :: Constraint). c => Dict c
Dict); SBool Zaamo
SFalse -> Maybe (Dict HasZaamo)
forall a. Maybe a
Nothing
{-# NOINLINE queryZaamo #-}

unsafeAssumeZalrsc :: (HasZalrsc => a) -> a
unsafeAssumeZalrsc :: forall a. (HasZalrsc => a) -> a
unsafeAssumeZalrsc HasZalrsc => a
k = case (Any :~: Any) -> Zalrsc :~: 'True
forall a b. a -> b
unsafeCoerce Any :~: Any
forall {k} (a :: k). a :~: a
Refl :: Zalrsc :~: True of Zalrsc :~: 'True
Refl -> a
HasZalrsc => a
k

queryZalrsc :: Maybe (Dict HasZalrsc)
queryZalrsc :: Maybe (Dict HasZalrsc)
queryZalrsc = case SBool Zalrsc
sZalrsc of SBool Zalrsc
STrue -> (HasZalrsc => Maybe (Dict HasZalrsc)) -> Maybe (Dict HasZalrsc)
forall a. (HasZalrsc => a) -> a
unsafeAssumeZalrsc (Dict HasZalrsc -> Maybe (Dict HasZalrsc)
forall a. a -> Maybe a
Just Dict HasZalrsc
forall (c :: Constraint). c => Dict c
Dict); SBool Zalrsc
SFalse -> Maybe (Dict HasZalrsc)
forall a. Maybe a
Nothing
{-# NOINLINE queryZalrsc #-}

unsafeAssumeSupm :: (HasSupm => a) -> a
unsafeAssumeSupm :: forall a. (HasSupm => a) -> a
unsafeAssumeSupm HasSupm => a
k = case (Any :~: Any) -> Supm :~: 'True
forall a b. a -> b
unsafeCoerce Any :~: Any
forall {k} (a :: k). a :~: a
Refl :: Supm :~: True of Supm :~: 'True
Refl -> a
HasSupm => a
k

querySupm :: Maybe (Dict HasSupm)
querySupm :: Maybe (Dict HasSupm)
querySupm = case SBool Supm
sSupm of SBool Supm
STrue -> (HasSupm => Maybe (Dict HasSupm)) -> Maybe (Dict HasSupm)
forall a. (HasSupm => a) -> a
unsafeAssumeSupm (Dict HasSupm -> Maybe (Dict HasSupm)
forall a. a -> Maybe a
Just Dict HasSupm
forall (c :: Constraint). c => Dict c
Dict); SBool Supm
SFalse -> Maybe (Dict HasSupm)
forall a. Maybe a
Nothing
{-# NOINLINE querySupm #-}

unsafeAssumeZfbfmin :: (HasZfbfmin => a) -> a
unsafeAssumeZfbfmin :: forall a. (HasZfbfmin => a) -> a
unsafeAssumeZfbfmin HasZfbfmin => a
k = case (Any :~: Any) -> Zfbfmin :~: 'True
forall a b. a -> b
unsafeCoerce Any :~: Any
forall {k} (a :: k). a :~: a
Refl :: Zfbfmin :~: True of Zfbfmin :~: 'True
Refl -> a
HasZfbfmin => a
k

queryZfbfmin :: Maybe (Dict HasZfbfmin)
queryZfbfmin :: Maybe (Dict HasZfbfmin)
queryZfbfmin = case SBool Zfbfmin
sZfbfmin of SBool Zfbfmin
STrue -> (HasZfbfmin => Maybe (Dict HasZfbfmin)) -> Maybe (Dict HasZfbfmin)
forall a. (HasZfbfmin => a) -> a
unsafeAssumeZfbfmin (Dict HasZfbfmin -> Maybe (Dict HasZfbfmin)
forall a. a -> Maybe a
Just Dict HasZfbfmin
forall (c :: Constraint). c => Dict c
Dict); SBool Zfbfmin
SFalse -> Maybe (Dict HasZfbfmin)
forall a. Maybe a
Nothing
{-# NOINLINE queryZfbfmin #-}

unsafeAssumeZvfbfmin :: (HasZvfbfmin => a) -> a
unsafeAssumeZvfbfmin :: forall a. (HasZvfbfmin => a) -> a
unsafeAssumeZvfbfmin HasZvfbfmin => a
k = case (Any :~: Any) -> Zvfbfmin :~: 'True
forall a b. a -> b
unsafeCoerce Any :~: Any
forall {k} (a :: k). a :~: a
Refl :: Zvfbfmin :~: True of Zvfbfmin :~: 'True
Refl -> a
HasZvfbfmin => a
k

queryZvfbfmin :: Maybe (Dict HasZvfbfmin)
queryZvfbfmin :: Maybe (Dict HasZvfbfmin)
queryZvfbfmin = case SBool Zvfbfmin
sZvfbfmin of SBool Zvfbfmin
STrue -> (HasZvfbfmin => Maybe (Dict HasZvfbfmin))
-> Maybe (Dict HasZvfbfmin)
forall a. (HasZvfbfmin => a) -> a
unsafeAssumeZvfbfmin (Dict HasZvfbfmin -> Maybe (Dict HasZvfbfmin)
forall a. a -> Maybe a
Just Dict HasZvfbfmin
forall (c :: Constraint). c => Dict c
Dict); SBool Zvfbfmin
SFalse -> Maybe (Dict HasZvfbfmin)
forall a. Maybe a
Nothing
{-# NOINLINE queryZvfbfmin #-}

unsafeAssumeZvfbfwma :: (HasZvfbfwma => a) -> a
unsafeAssumeZvfbfwma :: forall a. (HasZvfbfwma => a) -> a
unsafeAssumeZvfbfwma HasZvfbfwma => a
k = case (Any :~: Any) -> Zvfbfwma :~: 'True
forall a b. a -> b
unsafeCoerce Any :~: Any
forall {k} (a :: k). a :~: a
Refl :: Zvfbfwma :~: True of Zvfbfwma :~: 'True
Refl -> a
HasZvfbfwma => a
k

queryZvfbfwma :: Maybe (Dict HasZvfbfwma)
queryZvfbfwma :: Maybe (Dict HasZvfbfwma)
queryZvfbfwma = case SBool Zvfbfwma
sZvfbfwma of SBool Zvfbfwma
STrue -> (HasZvfbfwma => Maybe (Dict HasZvfbfwma))
-> Maybe (Dict HasZvfbfwma)
forall a. (HasZvfbfwma => a) -> a
unsafeAssumeZvfbfwma (Dict HasZvfbfwma -> Maybe (Dict HasZvfbfwma)
forall a. a -> Maybe a
Just Dict HasZvfbfwma
forall (c :: Constraint). c => Dict c
Dict); SBool Zvfbfwma
SFalse -> Maybe (Dict HasZvfbfwma)
forall a. Maybe a
Nothing
{-# NOINLINE queryZvfbfwma #-}

unsafeAssumeZicbom :: (HasZicbom => a) -> a
unsafeAssumeZicbom :: forall a. (HasZicbom => a) -> a
unsafeAssumeZicbom HasZicbom => a
k = case (Any :~: Any) -> Zicbom :~: 'True
forall a b. a -> b
unsafeCoerce Any :~: Any
forall {k} (a :: k). a :~: a
Refl :: Zicbom :~: True of Zicbom :~: 'True
Refl -> a
HasZicbom => a
k

queryZicbom :: Maybe (Dict HasZicbom)
queryZicbom :: Maybe (Dict HasZicbom)
queryZicbom = case SBool Zicbom
sZicbom of SBool Zicbom
STrue -> (HasZicbom => Maybe (Dict HasZicbom)) -> Maybe (Dict HasZicbom)
forall a. (HasZicbom => a) -> a
unsafeAssumeZicbom (Dict HasZicbom -> Maybe (Dict HasZicbom)
forall a. a -> Maybe a
Just Dict HasZicbom
forall (c :: Constraint). c => Dict c
Dict); SBool Zicbom
SFalse -> Maybe (Dict HasZicbom)
forall a. Maybe a
Nothing
{-# NOINLINE queryZicbom #-}