#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.GstAudio.Flags
(
AudioChannelMixerFlags(..) ,
AudioConverterFlags(..) ,
AudioFlags(..) ,
AudioFormatFlags(..) ,
AudioPackFlags(..) ,
AudioQuantizeFlags(..) ,
AudioResamplerFlags(..) ,
) 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.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
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 Data.Text as T
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
data AudioResamplerFlags =
AudioResamplerFlagsNone
| AudioResamplerFlagsNonInterleavedIn
| AudioResamplerFlagsNonInterleavedOut
| AudioResamplerFlagsVariableRate
| AnotherAudioResamplerFlags Int
deriving (Int -> AudioResamplerFlags -> ShowS
[AudioResamplerFlags] -> ShowS
AudioResamplerFlags -> String
(Int -> AudioResamplerFlags -> ShowS)
-> (AudioResamplerFlags -> String)
-> ([AudioResamplerFlags] -> ShowS)
-> Show AudioResamplerFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [AudioResamplerFlags] -> ShowS
$cshowList :: [AudioResamplerFlags] -> ShowS
show :: AudioResamplerFlags -> String
$cshow :: AudioResamplerFlags -> String
showsPrec :: Int -> AudioResamplerFlags -> ShowS
$cshowsPrec :: Int -> AudioResamplerFlags -> ShowS
Show, AudioResamplerFlags -> AudioResamplerFlags -> Bool
(AudioResamplerFlags -> AudioResamplerFlags -> Bool)
-> (AudioResamplerFlags -> AudioResamplerFlags -> Bool)
-> Eq AudioResamplerFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: AudioResamplerFlags -> AudioResamplerFlags -> Bool
$c/= :: AudioResamplerFlags -> AudioResamplerFlags -> Bool
== :: AudioResamplerFlags -> AudioResamplerFlags -> Bool
$c== :: AudioResamplerFlags -> AudioResamplerFlags -> Bool
Eq)
instance P.Enum AudioResamplerFlags where
fromEnum :: AudioResamplerFlags -> Int
fromEnum AudioResamplerFlagsNone = 0
fromEnum AudioResamplerFlagsNonInterleavedIn = 1
fromEnum AudioResamplerFlagsNonInterleavedOut = 2
fromEnum AudioResamplerFlagsVariableRate = 4
fromEnum (AnotherAudioResamplerFlags k :: Int
k) = Int
k
toEnum :: Int -> AudioResamplerFlags
toEnum 0 = AudioResamplerFlags
AudioResamplerFlagsNone
toEnum 1 = AudioResamplerFlags
AudioResamplerFlagsNonInterleavedIn
toEnum 2 = AudioResamplerFlags
AudioResamplerFlagsNonInterleavedOut
toEnum 4 = AudioResamplerFlags
AudioResamplerFlagsVariableRate
toEnum k :: Int
k = Int -> AudioResamplerFlags
AnotherAudioResamplerFlags Int
k
instance P.Ord AudioResamplerFlags where
compare :: AudioResamplerFlags -> AudioResamplerFlags -> Ordering
compare a :: AudioResamplerFlags
a b :: AudioResamplerFlags
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (AudioResamplerFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum AudioResamplerFlags
a) (AudioResamplerFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum AudioResamplerFlags
b)
foreign import ccall "gst_audio_resampler_flags_get_type" c_gst_audio_resampler_flags_get_type ::
IO GType
instance BoxedFlags AudioResamplerFlags where
boxedFlagsType :: Proxy AudioResamplerFlags -> IO GType
boxedFlagsType _ = IO GType
c_gst_audio_resampler_flags_get_type
instance IsGFlag AudioResamplerFlags
data AudioQuantizeFlags =
AudioQuantizeFlagsNone
| AudioQuantizeFlagsNonInterleaved
| AnotherAudioQuantizeFlags Int
deriving (Int -> AudioQuantizeFlags -> ShowS
[AudioQuantizeFlags] -> ShowS
AudioQuantizeFlags -> String
(Int -> AudioQuantizeFlags -> ShowS)
-> (AudioQuantizeFlags -> String)
-> ([AudioQuantizeFlags] -> ShowS)
-> Show AudioQuantizeFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [AudioQuantizeFlags] -> ShowS
$cshowList :: [AudioQuantizeFlags] -> ShowS
show :: AudioQuantizeFlags -> String
$cshow :: AudioQuantizeFlags -> String
showsPrec :: Int -> AudioQuantizeFlags -> ShowS
$cshowsPrec :: Int -> AudioQuantizeFlags -> ShowS
Show, AudioQuantizeFlags -> AudioQuantizeFlags -> Bool
(AudioQuantizeFlags -> AudioQuantizeFlags -> Bool)
-> (AudioQuantizeFlags -> AudioQuantizeFlags -> Bool)
-> Eq AudioQuantizeFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: AudioQuantizeFlags -> AudioQuantizeFlags -> Bool
$c/= :: AudioQuantizeFlags -> AudioQuantizeFlags -> Bool
== :: AudioQuantizeFlags -> AudioQuantizeFlags -> Bool
$c== :: AudioQuantizeFlags -> AudioQuantizeFlags -> Bool
Eq)
instance P.Enum AudioQuantizeFlags where
fromEnum :: AudioQuantizeFlags -> Int
fromEnum AudioQuantizeFlagsNone = 0
fromEnum AudioQuantizeFlagsNonInterleaved = 1
fromEnum (AnotherAudioQuantizeFlags k :: Int
k) = Int
k
toEnum :: Int -> AudioQuantizeFlags
toEnum 0 = AudioQuantizeFlags
AudioQuantizeFlagsNone
toEnum 1 = AudioQuantizeFlags
AudioQuantizeFlagsNonInterleaved
toEnum k :: Int
k = Int -> AudioQuantizeFlags
AnotherAudioQuantizeFlags Int
k
instance P.Ord AudioQuantizeFlags where
compare :: AudioQuantizeFlags -> AudioQuantizeFlags -> Ordering
compare a :: AudioQuantizeFlags
a b :: AudioQuantizeFlags
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (AudioQuantizeFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum AudioQuantizeFlags
a) (AudioQuantizeFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum AudioQuantizeFlags
b)
foreign import ccall "gst_audio_quantize_flags_get_type" c_gst_audio_quantize_flags_get_type ::
IO GType
instance BoxedFlags AudioQuantizeFlags where
boxedFlagsType :: Proxy AudioQuantizeFlags -> IO GType
boxedFlagsType _ = IO GType
c_gst_audio_quantize_flags_get_type
instance IsGFlag AudioQuantizeFlags
data AudioPackFlags =
AudioPackFlagsNone
| AudioPackFlagsTruncateRange
| AnotherAudioPackFlags Int
deriving (Int -> AudioPackFlags -> ShowS
[AudioPackFlags] -> ShowS
AudioPackFlags -> String
(Int -> AudioPackFlags -> ShowS)
-> (AudioPackFlags -> String)
-> ([AudioPackFlags] -> ShowS)
-> Show AudioPackFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [AudioPackFlags] -> ShowS
$cshowList :: [AudioPackFlags] -> ShowS
show :: AudioPackFlags -> String
$cshow :: AudioPackFlags -> String
showsPrec :: Int -> AudioPackFlags -> ShowS
$cshowsPrec :: Int -> AudioPackFlags -> ShowS
Show, AudioPackFlags -> AudioPackFlags -> Bool
(AudioPackFlags -> AudioPackFlags -> Bool)
-> (AudioPackFlags -> AudioPackFlags -> Bool) -> Eq AudioPackFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: AudioPackFlags -> AudioPackFlags -> Bool
$c/= :: AudioPackFlags -> AudioPackFlags -> Bool
== :: AudioPackFlags -> AudioPackFlags -> Bool
$c== :: AudioPackFlags -> AudioPackFlags -> Bool
Eq)
instance P.Enum AudioPackFlags where
fromEnum :: AudioPackFlags -> Int
fromEnum AudioPackFlagsNone = 0
fromEnum AudioPackFlagsTruncateRange = 1
fromEnum (AnotherAudioPackFlags k :: Int
k) = Int
k
toEnum :: Int -> AudioPackFlags
toEnum 0 = AudioPackFlags
AudioPackFlagsNone
toEnum 1 = AudioPackFlags
AudioPackFlagsTruncateRange
toEnum k :: Int
k = Int -> AudioPackFlags
AnotherAudioPackFlags Int
k
instance P.Ord AudioPackFlags where
compare :: AudioPackFlags -> AudioPackFlags -> Ordering
compare a :: AudioPackFlags
a b :: AudioPackFlags
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (AudioPackFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum AudioPackFlags
a) (AudioPackFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum AudioPackFlags
b)
foreign import ccall "gst_audio_pack_flags_get_type" c_gst_audio_pack_flags_get_type ::
IO GType
instance BoxedFlags AudioPackFlags where
boxedFlagsType :: Proxy AudioPackFlags -> IO GType
boxedFlagsType _ = IO GType
c_gst_audio_pack_flags_get_type
instance IsGFlag AudioPackFlags
data AudioFormatFlags =
AudioFormatFlagsInteger
| AudioFormatFlagsFloat
| AudioFormatFlagsSigned
| AudioFormatFlagsComplex
| AudioFormatFlagsUnpack
| AnotherAudioFormatFlags Int
deriving (Int -> AudioFormatFlags -> ShowS
[AudioFormatFlags] -> ShowS
AudioFormatFlags -> String
(Int -> AudioFormatFlags -> ShowS)
-> (AudioFormatFlags -> String)
-> ([AudioFormatFlags] -> ShowS)
-> Show AudioFormatFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [AudioFormatFlags] -> ShowS
$cshowList :: [AudioFormatFlags] -> ShowS
show :: AudioFormatFlags -> String
$cshow :: AudioFormatFlags -> String
showsPrec :: Int -> AudioFormatFlags -> ShowS
$cshowsPrec :: Int -> AudioFormatFlags -> ShowS
Show, AudioFormatFlags -> AudioFormatFlags -> Bool
(AudioFormatFlags -> AudioFormatFlags -> Bool)
-> (AudioFormatFlags -> AudioFormatFlags -> Bool)
-> Eq AudioFormatFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: AudioFormatFlags -> AudioFormatFlags -> Bool
$c/= :: AudioFormatFlags -> AudioFormatFlags -> Bool
== :: AudioFormatFlags -> AudioFormatFlags -> Bool
$c== :: AudioFormatFlags -> AudioFormatFlags -> Bool
Eq)
instance P.Enum AudioFormatFlags where
fromEnum :: AudioFormatFlags -> Int
fromEnum AudioFormatFlagsInteger = 1
fromEnum AudioFormatFlagsFloat = 2
fromEnum AudioFormatFlagsSigned = 4
fromEnum AudioFormatFlagsComplex = 16
fromEnum AudioFormatFlagsUnpack = 32
fromEnum (AnotherAudioFormatFlags k :: Int
k) = Int
k
toEnum :: Int -> AudioFormatFlags
toEnum 1 = AudioFormatFlags
AudioFormatFlagsInteger
toEnum 2 = AudioFormatFlags
AudioFormatFlagsFloat
toEnum 4 = AudioFormatFlags
AudioFormatFlagsSigned
toEnum 16 = AudioFormatFlags
AudioFormatFlagsComplex
toEnum 32 = AudioFormatFlags
AudioFormatFlagsUnpack
toEnum k :: Int
k = Int -> AudioFormatFlags
AnotherAudioFormatFlags Int
k
instance P.Ord AudioFormatFlags where
compare :: AudioFormatFlags -> AudioFormatFlags -> Ordering
compare a :: AudioFormatFlags
a b :: AudioFormatFlags
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (AudioFormatFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum AudioFormatFlags
a) (AudioFormatFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum AudioFormatFlags
b)
foreign import ccall "gst_audio_format_flags_get_type" c_gst_audio_format_flags_get_type ::
IO GType
instance BoxedFlags AudioFormatFlags where
boxedFlagsType :: Proxy AudioFormatFlags -> IO GType
boxedFlagsType _ = IO GType
c_gst_audio_format_flags_get_type
instance IsGFlag AudioFormatFlags
data AudioFlags =
AudioFlagsNone
| AudioFlagsUnpositioned
| AnotherAudioFlags Int
deriving (Int -> AudioFlags -> ShowS
[AudioFlags] -> ShowS
AudioFlags -> String
(Int -> AudioFlags -> ShowS)
-> (AudioFlags -> String)
-> ([AudioFlags] -> ShowS)
-> Show AudioFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [AudioFlags] -> ShowS
$cshowList :: [AudioFlags] -> ShowS
show :: AudioFlags -> String
$cshow :: AudioFlags -> String
showsPrec :: Int -> AudioFlags -> ShowS
$cshowsPrec :: Int -> AudioFlags -> ShowS
Show, AudioFlags -> AudioFlags -> Bool
(AudioFlags -> AudioFlags -> Bool)
-> (AudioFlags -> AudioFlags -> Bool) -> Eq AudioFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: AudioFlags -> AudioFlags -> Bool
$c/= :: AudioFlags -> AudioFlags -> Bool
== :: AudioFlags -> AudioFlags -> Bool
$c== :: AudioFlags -> AudioFlags -> Bool
Eq)
instance P.Enum AudioFlags where
fromEnum :: AudioFlags -> Int
fromEnum AudioFlagsNone = 0
fromEnum AudioFlagsUnpositioned = 1
fromEnum (AnotherAudioFlags k :: Int
k) = Int
k
toEnum :: Int -> AudioFlags
toEnum 0 = AudioFlags
AudioFlagsNone
toEnum 1 = AudioFlags
AudioFlagsUnpositioned
toEnum k :: Int
k = Int -> AudioFlags
AnotherAudioFlags Int
k
instance P.Ord AudioFlags where
compare :: AudioFlags -> AudioFlags -> Ordering
compare a :: AudioFlags
a b :: AudioFlags
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (AudioFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum AudioFlags
a) (AudioFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum AudioFlags
b)
foreign import ccall "gst_audio_flags_get_type" c_gst_audio_flags_get_type ::
IO GType
instance BoxedFlags AudioFlags where
boxedFlagsType :: Proxy AudioFlags -> IO GType
boxedFlagsType _ = IO GType
c_gst_audio_flags_get_type
instance IsGFlag AudioFlags
data AudioConverterFlags =
AudioConverterFlagsNone
| AudioConverterFlagsInWritable
| AudioConverterFlagsVariableRate
| AnotherAudioConverterFlags Int
deriving (Int -> AudioConverterFlags -> ShowS
[AudioConverterFlags] -> ShowS
AudioConverterFlags -> String
(Int -> AudioConverterFlags -> ShowS)
-> (AudioConverterFlags -> String)
-> ([AudioConverterFlags] -> ShowS)
-> Show AudioConverterFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [AudioConverterFlags] -> ShowS
$cshowList :: [AudioConverterFlags] -> ShowS
show :: AudioConverterFlags -> String
$cshow :: AudioConverterFlags -> String
showsPrec :: Int -> AudioConverterFlags -> ShowS
$cshowsPrec :: Int -> AudioConverterFlags -> ShowS
Show, AudioConverterFlags -> AudioConverterFlags -> Bool
(AudioConverterFlags -> AudioConverterFlags -> Bool)
-> (AudioConverterFlags -> AudioConverterFlags -> Bool)
-> Eq AudioConverterFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: AudioConverterFlags -> AudioConverterFlags -> Bool
$c/= :: AudioConverterFlags -> AudioConverterFlags -> Bool
== :: AudioConverterFlags -> AudioConverterFlags -> Bool
$c== :: AudioConverterFlags -> AudioConverterFlags -> Bool
Eq)
instance P.Enum AudioConverterFlags where
fromEnum :: AudioConverterFlags -> Int
fromEnum AudioConverterFlagsNone = 0
fromEnum AudioConverterFlagsInWritable = 1
fromEnum AudioConverterFlagsVariableRate = 2
fromEnum (AnotherAudioConverterFlags k :: Int
k) = Int
k
toEnum :: Int -> AudioConverterFlags
toEnum 0 = AudioConverterFlags
AudioConverterFlagsNone
toEnum 1 = AudioConverterFlags
AudioConverterFlagsInWritable
toEnum 2 = AudioConverterFlags
AudioConverterFlagsVariableRate
toEnum k :: Int
k = Int -> AudioConverterFlags
AnotherAudioConverterFlags Int
k
instance P.Ord AudioConverterFlags where
compare :: AudioConverterFlags -> AudioConverterFlags -> Ordering
compare a :: AudioConverterFlags
a b :: AudioConverterFlags
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (AudioConverterFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum AudioConverterFlags
a) (AudioConverterFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum AudioConverterFlags
b)
foreign import ccall "gst_audio_converter_flags_get_type" c_gst_audio_converter_flags_get_type ::
IO GType
instance BoxedFlags AudioConverterFlags where
boxedFlagsType :: Proxy AudioConverterFlags -> IO GType
boxedFlagsType _ = IO GType
c_gst_audio_converter_flags_get_type
instance IsGFlag AudioConverterFlags
data AudioChannelMixerFlags =
AudioChannelMixerFlagsNone
| AudioChannelMixerFlagsNonInterleavedIn
| AudioChannelMixerFlagsNonInterleavedOut
| AudioChannelMixerFlagsUnpositionedIn
| AudioChannelMixerFlagsUnpositionedOut
| AnotherAudioChannelMixerFlags Int
deriving (Int -> AudioChannelMixerFlags -> ShowS
[AudioChannelMixerFlags] -> ShowS
AudioChannelMixerFlags -> String
(Int -> AudioChannelMixerFlags -> ShowS)
-> (AudioChannelMixerFlags -> String)
-> ([AudioChannelMixerFlags] -> ShowS)
-> Show AudioChannelMixerFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [AudioChannelMixerFlags] -> ShowS
$cshowList :: [AudioChannelMixerFlags] -> ShowS
show :: AudioChannelMixerFlags -> String
$cshow :: AudioChannelMixerFlags -> String
showsPrec :: Int -> AudioChannelMixerFlags -> ShowS
$cshowsPrec :: Int -> AudioChannelMixerFlags -> ShowS
Show, AudioChannelMixerFlags -> AudioChannelMixerFlags -> Bool
(AudioChannelMixerFlags -> AudioChannelMixerFlags -> Bool)
-> (AudioChannelMixerFlags -> AudioChannelMixerFlags -> Bool)
-> Eq AudioChannelMixerFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: AudioChannelMixerFlags -> AudioChannelMixerFlags -> Bool
$c/= :: AudioChannelMixerFlags -> AudioChannelMixerFlags -> Bool
== :: AudioChannelMixerFlags -> AudioChannelMixerFlags -> Bool
$c== :: AudioChannelMixerFlags -> AudioChannelMixerFlags -> Bool
Eq)
instance P.Enum AudioChannelMixerFlags where
fromEnum :: AudioChannelMixerFlags -> Int
fromEnum AudioChannelMixerFlagsNone = 0
fromEnum AudioChannelMixerFlagsNonInterleavedIn = 1
fromEnum AudioChannelMixerFlagsNonInterleavedOut = 2
fromEnum AudioChannelMixerFlagsUnpositionedIn = 4
fromEnum AudioChannelMixerFlagsUnpositionedOut = 8
fromEnum (AnotherAudioChannelMixerFlags k :: Int
k) = Int
k
toEnum :: Int -> AudioChannelMixerFlags
toEnum 0 = AudioChannelMixerFlags
AudioChannelMixerFlagsNone
toEnum 1 = AudioChannelMixerFlags
AudioChannelMixerFlagsNonInterleavedIn
toEnum 2 = AudioChannelMixerFlags
AudioChannelMixerFlagsNonInterleavedOut
toEnum 4 = AudioChannelMixerFlags
AudioChannelMixerFlagsUnpositionedIn
toEnum 8 = AudioChannelMixerFlags
AudioChannelMixerFlagsUnpositionedOut
toEnum k :: Int
k = Int -> AudioChannelMixerFlags
AnotherAudioChannelMixerFlags Int
k
instance P.Ord AudioChannelMixerFlags where
compare :: AudioChannelMixerFlags -> AudioChannelMixerFlags -> Ordering
compare a :: AudioChannelMixerFlags
a b :: AudioChannelMixerFlags
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (AudioChannelMixerFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum AudioChannelMixerFlags
a) (AudioChannelMixerFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum AudioChannelMixerFlags
b)
foreign import ccall "gst_audio_channel_mixer_flags_get_type" c_gst_audio_channel_mixer_flags_get_type ::
IO GType
instance BoxedFlags AudioChannelMixerFlags where
boxedFlagsType :: Proxy AudioChannelMixerFlags -> IO GType
boxedFlagsType _ = IO GType
c_gst_audio_channel_mixer_flags_get_type
instance IsGFlag AudioChannelMixerFlags