    {-# LANGUAGE TypeApplications #-}

    -- | Copyright  : Will Thompson and Iñaki García Etxebarria
    -- License    : LGPL-2.1
    -- Maintainer : Iñaki García Etxebarria
    --
    -- A t'GI.Gdk.Structs.KeymapKey.KeymapKey' is a hardware key that can be mapped to a keyval.

    #if !defined(__HADDOCK_VERSION__)
    #define ENABLE_OVERLOADING
    #endif

    module GI.Gdk.Structs.KeymapKey
        (

    -- * Exported types
        KeymapKey(..)                           ,
        newZeroKeymapKey                        ,

     -- * Methods

    #if defined(ENABLE_OVERLOADING)
        ResolveKeymapKeyMethod                  ,
    #endif

     -- * Properties

    -- ** group #attr:group#
    -- | indicates movement in a horizontal direction. Usually groups are used
    --   for two different languages. In group 0, a key might have two English
    --   characters, and in group 1 it might have two Hebrew characters. The Hebrew
    --   characters will be printed on the key next to the English characters.

        getKeymapKeyGroup                       ,
    #if defined(ENABLE_OVERLOADING)
        keymapKey_group                         ,
    #endif
        setKeymapKeyGroup                       ,

    -- ** keycode #attr:keycode#
    -- | the hardware keycode. This is an identifying number for a
    --   physical key.

        getKeymapKeyKeycode                     ,
    #if defined(ENABLE_OVERLOADING)
        keymapKey_keycode                       ,
    #endif
        setKeymapKeyKeycode                     ,

    -- ** level #attr:level#
    -- | indicates which symbol on the key will be used, in a vertical direction.
    --   So on a standard US keyboard, the key with the number “1” on it also has the
    --   exclamation point (\"!\") character on it. The level indicates whether to use
    --   the “1” or the “!” symbol. The letter keys are considered to have a lowercase
    --   letter at level 0, and an uppercase letter at level 1, though only the
    --   uppercase letter is printed.

        getKeymapKeyLevel                       ,
    #if defined(ENABLE_OVERLOADING)
        keymapKey_level                         ,
    #endif
        setKeymapKeyLevel                       ,

        ) where

    import Data.GI.Base.ShortPrelude
    import qualified Data.GI.Base.ShortPrelude as SP
    import qualified Data.GI.Base.Overloading as O
    import qualified Prelude as P

    import qualified Data.GI.Base.Attributes as GI.Attributes
    import qualified Data.GI.Base.BasicTypes as B.Types
    import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
    import qualified Data.GI.Base.GArray as B.GArray
    import qualified Data.GI.Base.GClosure as B.GClosure
    import qualified Data.GI.Base.GError as B.GError
    import qualified Data.GI.Base.GHashTable as B.GHT
    import qualified Data.GI.Base.GVariant as B.GVariant
    import qualified Data.GI.Base.GValue as B.GValue
    import qualified Data.GI.Base.GParamSpec as B.GParamSpec
    import qualified Data.GI.Base.CallStack as B.CallStack
    import qualified Data.GI.Base.Properties as B.Properties
    import qualified Data.GI.Base.Signals as B.Signals
    import qualified Control.Monad.IO.Class as MIO
    import qualified Data.Coerce as Coerce
    import qualified Data.Text as T
    import qualified Data.Kind as DK
    import qualified Data.ByteString.Char8 as B
    import qualified Data.Map as Map
    import qualified Foreign.Ptr as FP
    import qualified GHC.OverloadedLabels as OL
    import qualified GHC.Records as R
    import qualified Data.Word as DW
    import qualified Data.Int as DI
    import qualified System.Posix.Types as SPT
    import qualified Foreign.C.Types as FCT

    -- Workaround for https://gitlab.haskell.org/ghc/ghc/-/issues/23392
    #if MIN_VERSION_base(4,18,0)

    #else

    #endif

    -- | Memory-managed wrapper type.
    newtype KeymapKey = KeymapKey (SP.ManagedPtr KeymapKey)
        deriving (KeymapKey -> KeymapKey -> Bool
    (KeymapKey -> KeymapKey -> Bool)
    -> (KeymapKey -> KeymapKey -> Bool) -> Eq KeymapKey
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: KeymapKey -> KeymapKey -> Bool
    == :: KeymapKey -> KeymapKey -> Bool
    $c/= :: KeymapKey -> KeymapKey -> Bool
    /= :: KeymapKey -> KeymapKey -> Bool
    Eq)

    instance SP.ManagedPtrNewtype KeymapKey where
        toManagedPtr :: KeymapKey -> ManagedPtr KeymapKey
    toManagedPtr (KeymapKey ManagedPtr KeymapKey
    p) = ManagedPtr KeymapKey
    p

    instance BoxedPtr KeymapKey where
        boxedPtrCopy :: KeymapKey -> IO KeymapKey
    boxedPtrCopy = \KeymapKey
    p -> KeymapKey -> (Ptr KeymapKey -> IO KeymapKey) -> IO KeymapKey
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    B.ManagedPtr.withManagedPtr KeymapKey
    p (Int -> Ptr KeymapKey -> IO (Ptr KeymapKey)
    forall a. (HasCallStack, CallocPtr a) => Int -> Ptr a -> IO (Ptr a)
    copyBytes Int
    12 (Ptr KeymapKey -> IO (Ptr KeymapKey))
    -> (Ptr KeymapKey -> IO KeymapKey) -> Ptr KeymapKey -> IO KeymapKey
    forall (m :: * -> *) a b c.
    Monad m =>
    (a -> m b) -> (b -> m c) -> a -> m c
    >=> (ManagedPtr KeymapKey -> KeymapKey)
    -> Ptr KeymapKey -> IO KeymapKey
    forall a.
    (HasCallStack, BoxedPtr a) =>
    (ManagedPtr a -> a) -> Ptr a -> IO a
    B.ManagedPtr.wrapPtr ManagedPtr KeymapKey -> KeymapKey
    KeymapKey)
        boxedPtrFree :: KeymapKey -> IO ()
    boxedPtrFree = \KeymapKey
    x -> KeymapKey -> (Ptr KeymapKey -> IO ()) -> IO ()
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    SP.withManagedPtr KeymapKey
    x Ptr KeymapKey -> IO ()
    forall a. Ptr a -> IO ()
    SP.freeMem
    instance CallocPtr KeymapKey where
        boxedPtrCalloc :: IO (Ptr KeymapKey)
    boxedPtrCalloc = Int -> IO (Ptr KeymapKey)
    forall a. Int -> IO (Ptr a)
    callocBytes Int
    12

    -- | Construct a t'KeymapKey' struct initialized to zero.
    newZeroKeymapKey :: MonadIO m => m KeymapKey
    newZeroKeymapKey :: forall (m :: * -> *). MonadIO m => m KeymapKey
    newZeroKeymapKey = IO KeymapKey -> m KeymapKey
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO KeymapKey -> m KeymapKey) -> IO KeymapKey -> m KeymapKey
    forall a b. (a -> b) -> a -> b
    $ IO (Ptr KeymapKey)
    forall a. CallocPtr a => IO (Ptr a)
    boxedPtrCalloc IO (Ptr KeymapKey)
    -> (Ptr KeymapKey -> IO KeymapKey) -> IO KeymapKey
    forall a b. IO a -> (a -> IO b) -> IO b
    forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
    >>= (ManagedPtr KeymapKey -> KeymapKey)
    -> Ptr KeymapKey -> IO KeymapKey
    forall a.
    (HasCallStack, BoxedPtr a) =>
    (ManagedPtr a -> a) -> Ptr a -> IO a
    wrapPtr ManagedPtr KeymapKey -> KeymapKey
    KeymapKey

    instance tag ~ 'AttrSet => Constructible KeymapKey tag where
        new :: forall (m :: * -> *).
    MonadIO m =>
    (ManagedPtr KeymapKey -> KeymapKey)
    -> [AttrOp KeymapKey tag] -> m KeymapKey
    new ManagedPtr KeymapKey -> KeymapKey
    _ [AttrOp KeymapKey tag]
    attrs = do
            o <- m KeymapKey
    forall (m :: * -> *). MonadIO m => m KeymapKey
    newZeroKeymapKey
            GI.Attributes.set o attrs
            return o

    -- | Get the value of the “@keycode@” field.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.get' keymapKey #keycode
    -- @
    getKeymapKeyKeycode :: MonadIO m => KeymapKey -> m Word32
    getKeymapKeyKeycode :: forall (m :: * -> *). MonadIO m => KeymapKey -> m Word32
    getKeymapKeyKeycode KeymapKey
    s = IO Word32 -> m Word32
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Word32 -> m Word32) -> IO Word32 -> m Word32
    forall a b. (a -> b) -> a -> b
    $ KeymapKey -> (Ptr KeymapKey -> IO Word32) -> IO Word32
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr KeymapKey
    s ((Ptr KeymapKey -> IO Word32) -> IO Word32)
    -> (Ptr KeymapKey -> IO Word32) -> IO Word32
    forall a b. (a -> b) -> a -> b
    $ \Ptr KeymapKey
    ptr -> do
        val <- Ptr Word32 -> IO Word32
    forall a. Storable a => Ptr a -> IO a
    peek (Ptr KeymapKey
    ptr Ptr KeymapKey -> Int -> Ptr Word32
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    0) :: IO Word32
        return val

    -- | Set the value of the “@keycode@” field.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.set' keymapKey [ #keycode 'Data.GI.Base.Attributes.:=' value ]
    -- @
    setKeymapKeyKeycode :: MonadIO m => KeymapKey -> Word32 -> m ()
    setKeymapKeyKeycode :: forall (m :: * -> *). MonadIO m => KeymapKey -> Word32 -> m ()
    setKeymapKeyKeycode KeymapKey
    s Word32
    val = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ KeymapKey -> (Ptr KeymapKey -> IO ()) -> IO ()
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr KeymapKey
    s ((Ptr KeymapKey -> IO ()) -> IO ())
    -> (Ptr KeymapKey -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \Ptr KeymapKey
    ptr -> do
        Ptr Word32 -> Word32 -> IO ()
    forall a. Storable a => Ptr a -> a -> IO ()
    poke (Ptr KeymapKey
    ptr Ptr KeymapKey -> Int -> Ptr Word32
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    0) (Word32
    val :: Word32)

    #if defined(ENABLE_OVERLOADING)
    data KeymapKeyKeycodeFieldInfo
    instance AttrInfo KeymapKeyKeycodeFieldInfo where
        type AttrBaseTypeConstraint KeymapKeyKeycodeFieldInfo = (~) KeymapKey
        type AttrAllowedOps KeymapKeyKeycodeFieldInfo = '[ 'AttrSet, 'AttrGet]
        type AttrSetTypeConstraint KeymapKeyKeycodeFieldInfo = (~) Word32
        type AttrTransferTypeConstraint KeymapKeyKeycodeFieldInfo = (~)Word32
        type AttrTransferType KeymapKeyKeycodeFieldInfo = Word32
        type AttrGetType KeymapKeyKeycodeFieldInfo = Word32
        type AttrLabel KeymapKeyKeycodeFieldInfo = "keycode"
        type AttrOrigin KeymapKeyKeycodeFieldInfo = KeymapKey
        attrGet = getKeymapKeyKeycode
        attrSet = setKeymapKeyKeycode
        attrConstruct = undefined
        attrClear = undefined
        attrTransfer _ v = do
            return v
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gdk.Structs.KeymapKey.keycode"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gdk3-3.0.30/docs/GI-Gdk-Structs-KeymapKey.html#g:attr:keycode"
            })

    keymapKey_keycode :: AttrLabelProxy "keycode"
    keymapKey_keycode = AttrLabelProxy

    #endif

    -- | Get the value of the “@group@” field.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.get' keymapKey #group
    -- @
    getKeymapKeyGroup :: MonadIO m => KeymapKey -> m Int32
    getKeymapKeyGroup :: forall (m :: * -> *). MonadIO m => KeymapKey -> m Int32
    getKeymapKeyGroup KeymapKey
    s = IO Int32 -> m Int32
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
    forall a b. (a -> b) -> a -> b
    $ KeymapKey -> (Ptr KeymapKey -> IO Int32) -> IO Int32
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr KeymapKey
    s ((Ptr KeymapKey -> IO Int32) -> IO Int32)
    -> (Ptr KeymapKey -> IO Int32) -> IO Int32
    forall a b. (a -> b) -> a -> b
    $ \Ptr KeymapKey
    ptr -> do
        val <- Ptr Int32 -> IO Int32
    forall a. Storable a => Ptr a -> IO a
    peek (Ptr KeymapKey
    ptr Ptr KeymapKey -> Int -> Ptr Int32
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    4) :: IO Int32
        return val

    -- | Set the value of the “@group@” field.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.set' keymapKey [ #group 'Data.GI.Base.Attributes.:=' value ]
    -- @
    setKeymapKeyGroup :: MonadIO m => KeymapKey -> Int32 -> m ()
    setKeymapKeyGroup :: forall (m :: * -> *). MonadIO m => KeymapKey -> Int32 -> m ()
    setKeymapKeyGroup KeymapKey
    s Int32
    val = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ KeymapKey -> (Ptr KeymapKey -> IO ()) -> IO ()
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr KeymapKey
    s ((Ptr KeymapKey -> IO ()) -> IO ())
    -> (Ptr KeymapKey -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \Ptr KeymapKey
    ptr -> do
        Ptr Int32 -> Int32 -> IO ()
    forall a. Storable a => Ptr a -> a -> IO ()
    poke (Ptr KeymapKey
    ptr Ptr KeymapKey -> Int -> Ptr Int32
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    4) (Int32
    val :: Int32)

    #if defined(ENABLE_OVERLOADING)
    data KeymapKeyGroupFieldInfo
    instance AttrInfo KeymapKeyGroupFieldInfo where
        type AttrBaseTypeConstraint KeymapKeyGroupFieldInfo = (~) KeymapKey
        type AttrAllowedOps KeymapKeyGroupFieldInfo = '[ 'AttrSet, 'AttrGet]
        type AttrSetTypeConstraint KeymapKeyGroupFieldInfo = (~) Int32
        type AttrTransferTypeConstraint KeymapKeyGroupFieldInfo = (~)Int32
        type AttrTransferType KeymapKeyGroupFieldInfo = Int32
        type AttrGetType KeymapKeyGroupFieldInfo = Int32
        type AttrLabel KeymapKeyGroupFieldInfo = "group"
        type AttrOrigin KeymapKeyGroupFieldInfo = KeymapKey
        attrGet = getKeymapKeyGroup
        attrSet = setKeymapKeyGroup
        attrConstruct = undefined
        attrClear = undefined
        attrTransfer _ v = do
            return v
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gdk.Structs.KeymapKey.group"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gdk3-3.0.30/docs/GI-Gdk-Structs-KeymapKey.html#g:attr:group"
            })

    keymapKey_group :: AttrLabelProxy "group"
    keymapKey_group = AttrLabelProxy

    #endif

    -- | Get the value of the “@level@” field.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.get' keymapKey #level
    -- @
    getKeymapKeyLevel :: MonadIO m => KeymapKey -> m Int32
    getKeymapKeyLevel :: forall (m :: * -> *). MonadIO m => KeymapKey -> m Int32
    getKeymapKeyLevel KeymapKey
    s = IO Int32 -> m Int32
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
    forall a b. (a -> b) -> a -> b
    $ KeymapKey -> (Ptr KeymapKey -> IO Int32) -> IO Int32
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr KeymapKey
    s ((Ptr KeymapKey -> IO Int32) -> IO Int32)
    -> (Ptr KeymapKey -> IO Int32) -> IO Int32
    forall a b. (a -> b) -> a -> b
    $ \Ptr KeymapKey
    ptr -> do
        val <- Ptr Int32 -> IO Int32
    forall a. Storable a => Ptr a -> IO a
    peek (Ptr KeymapKey
    ptr Ptr KeymapKey -> Int -> Ptr Int32
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    8) :: IO Int32
        return val

    -- | Set the value of the “@level@” field.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.set' keymapKey [ #level 'Data.GI.Base.Attributes.:=' value ]
    -- @
    setKeymapKeyLevel :: MonadIO m => KeymapKey -> Int32 -> m ()
    setKeymapKeyLevel :: forall (m :: * -> *). MonadIO m => KeymapKey -> Int32 -> m ()
    setKeymapKeyLevel KeymapKey
    s Int32
    val = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ KeymapKey -> (Ptr KeymapKey -> IO ()) -> IO ()
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr KeymapKey
    s ((Ptr KeymapKey -> IO ()) -> IO ())
    -> (Ptr KeymapKey -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \Ptr KeymapKey
    ptr -> do
        Ptr Int32 -> Int32 -> IO ()
    forall a. Storable a => Ptr a -> a -> IO ()
    poke (Ptr KeymapKey
    ptr Ptr KeymapKey -> Int -> Ptr Int32
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    8) (Int32
    val :: Int32)

    #if defined(ENABLE_OVERLOADING)
    data KeymapKeyLevelFieldInfo
    instance AttrInfo KeymapKeyLevelFieldInfo where
        type AttrBaseTypeConstraint KeymapKeyLevelFieldInfo = (~) KeymapKey
        type AttrAllowedOps KeymapKeyLevelFieldInfo = '[ 'AttrSet, 'AttrGet]
        type AttrSetTypeConstraint KeymapKeyLevelFieldInfo = (~) Int32
        type AttrTransferTypeConstraint KeymapKeyLevelFieldInfo = (~)Int32
        type AttrTransferType KeymapKeyLevelFieldInfo = Int32
        type AttrGetType KeymapKeyLevelFieldInfo = Int32
        type AttrLabel KeymapKeyLevelFieldInfo = "level"
        type AttrOrigin KeymapKeyLevelFieldInfo = KeymapKey
        attrGet = getKeymapKeyLevel
        attrSet = setKeymapKeyLevel
        attrConstruct = undefined
        attrClear = undefined
        attrTransfer _ v = do
            return v
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gdk.Structs.KeymapKey.level"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gdk3-3.0.30/docs/GI-Gdk-Structs-KeymapKey.html#g:attr:level"
            })

    keymapKey_level :: AttrLabelProxy "level"
    keymapKey_level = AttrLabelProxy

    #endif

    #if defined(ENABLE_OVERLOADING)
    instance O.HasAttributeList KeymapKey
    type instance O.AttributeList KeymapKey = KeymapKeyAttributeList
    type KeymapKeyAttributeList = ('[ '("keycode", KeymapKeyKeycodeFieldInfo), '("group", KeymapKeyGroupFieldInfo), '("level", KeymapKeyLevelFieldInfo)] :: [(Symbol, DK.Type)])
    #endif

    #if defined(ENABLE_OVERLOADING)
    type family ResolveKeymapKeyMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where
        ResolveKeymapKeyMethod l o = O.MethodResolutionFailed l o

    instance (info ~ ResolveKeymapKeyMethod t KeymapKey, O.OverloadedMethod info KeymapKey p) => OL.IsLabel t (KeymapKey -> p) where
    #if MIN_VERSION_base(4,10,0)
        fromLabel = O.overloadedMethod @info
    #else
        fromLabel _ = O.overloadedMethod @info
    #endif

    #if MIN_VERSION_base(4,13,0)
    instance (info ~ ResolveKeymapKeyMethod t KeymapKey, O.OverloadedMethod info KeymapKey p, R.HasField t KeymapKey p) => R.HasField t KeymapKey p where
        getField = O.overloadedMethod @info

    #endif

    instance (info ~ ResolveKeymapKeyMethod t KeymapKey, O.OverloadedMethodInfo info KeymapKey) => OL.IsLabel t (O.MethodProxy info KeymapKey) where
    #if MIN_VERSION_base(4,10,0)
        fromLabel = O.MethodProxy
    #else
        fromLabel _ = O.MethodProxy
    #endif

    #endif