{-# LANGUAGE DeriveDataTypeable #-}
{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE PatternSynonyms #-}
{-# LANGUAGE Safe #-}

-- |
-- Module      : Data.Char.Emoji.Core
-- Description : A module that defines the /flag/ Emoji.
-- Maintainer  : hapytexeu+gh@gmail.com
-- Stability   : experimental
-- Portability : POSIX
--
-- A module that defines the /flag/ emoji. There are basically three types of flags:
-- flags for nations, flags for subnations (like England, Scotland and Wales); and
-- 'ExtraFlag's that contain a list of flags used for occassions and political purposes.
module Data.Char.Emoji.Flag
  ( -- * Flag emoji
    Flag,
    flag,
    flag',
    flagChars,
    iso3166Alpha2ToFlag,
    iso3166Alpha2ToFlag',
    validFlagEmoji,

    -- * Subregional flag emoji
    SubFlag,
    ExtraFlag (ChequeredFlag, TriangularFlagOnPost, CrossedFlags, BlackFlag, WavingWhiteFlag, RainbowFlag, TransgenderFlag, PirateFlag),

    -- * Pattern symbols for 'Flag's
    pattern AC,
    pattern AD,
    pattern AE,
    pattern AF,
    pattern AG,
    pattern AI,
    pattern AL,
    pattern AM,
    pattern AO,
    pattern AQ,
    pattern AR,
    pattern AS,
    pattern AT,
    pattern AU,
    pattern AW,
    pattern AX,
    pattern AZ,
    pattern BA,
    pattern BB,
    pattern BD,
    pattern BE,
    pattern BF,
    pattern BG,
    pattern BH,
    pattern BI,
    pattern BJ,
    pattern BL,
    pattern BM,
    pattern BN,
    pattern BO,
    pattern BQ,
    pattern BR,
    pattern BS,
    pattern BT,
    pattern BV,
    pattern BW,
    pattern BY,
    pattern BZ,
    pattern CA,
    pattern CC,
    pattern CD,
    pattern CF,
    pattern CG,
    pattern CH,
    pattern CI,
    pattern CK,
    pattern CL,
    pattern CM,
    pattern CN,
    pattern CO,
    pattern CP,
    pattern CR,
    pattern CU,
    pattern CV,
    pattern CW,
    pattern CX,
    pattern CY,
    pattern CZ,
    pattern DE,
    pattern DG,
    pattern DJ,
    pattern DK,
    pattern DM,
    pattern DO,
    pattern DZ,
    pattern EA,
    pattern EC,
    pattern EE,
    pattern EG,
    pattern EH,
    pattern ER,
    pattern ES,
    pattern ET,
    pattern EU,
    pattern FI,
    pattern FJ,
    pattern FK,
    pattern FM,
    pattern FO,
    pattern FR,
    pattern GA,
    pattern GB,
    pattern GD,
    pattern GE,
    pattern GF,
    pattern GG,
    pattern GH,
    pattern GI,
    pattern GL,
    pattern GM,
    pattern GN,
    pattern GP,
    pattern GQ,
    pattern GR,
    pattern GS,
    pattern GT,
    pattern GU,
    pattern GW,
    pattern GY,
    pattern HK,
    pattern HM,
    pattern HN,
    pattern HR,
    pattern HT,
    pattern HU,
    pattern IC,
    pattern ID,
    pattern IE,
    pattern IL,
    pattern IM,
    pattern IN,
    pattern IO,
    pattern IQ,
    pattern IR,
    pattern IS,
    pattern IT,
    pattern JE,
    pattern JM,
    pattern JO,
    pattern JP,
    pattern KE,
    pattern KG,
    pattern KH,
    pattern KI,
    pattern KM,
    pattern KN,
    pattern KP,
    pattern KR,
    pattern KW,
    pattern KY,
    pattern KZ,
    pattern LA,
    pattern LB,
    pattern LC,
    pattern LI,
    pattern LK,
    pattern LR,
    pattern LS,
    pattern LT,
    pattern LU,
    pattern LV,
    pattern LY,
    pattern MA,
    pattern MC,
    pattern MD,
    pattern ME,
    pattern MF,
    pattern MG,
    pattern MH,
    pattern MK,
    pattern ML,
    pattern MM,
    pattern MN,
    pattern MO,
    pattern MP,
    pattern MQ,
    pattern MR,
    pattern MS,
    pattern MT,
    pattern MU,
    pattern MV,
    pattern MW,
    pattern MX,
    pattern MY,
    pattern MZ,
    pattern NA,
    pattern NC,
    pattern NE,
    pattern NF,
    pattern NG,
    pattern NI,
    pattern NL,
    pattern NO,
    pattern NP,
    pattern NR,
    pattern NU,
    pattern NZ,
    pattern OM,
    pattern PA,
    pattern PE,
    pattern PF,
    pattern PG,
    pattern PH,
    pattern PK,
    pattern PL,
    pattern PM,
    pattern PN,
    pattern PR,
    pattern PS,
    pattern PT,
    pattern PW,
    pattern PY,
    pattern QA,
    pattern RE,
    pattern RO,
    pattern RS,
    pattern RU,
    pattern RW,
    pattern SA,
    pattern SB,
    pattern SC,
    pattern SD,
    pattern SE,
    pattern SG,
    pattern SH,
    pattern SI,
    pattern SJ,
    pattern SK,
    pattern SL,
    pattern SM,
    pattern SN,
    pattern SO,
    pattern SR,
    pattern SS,
    pattern ST,
    pattern SV,
    pattern SX,
    pattern SY,
    pattern SZ,
    pattern TA,
    pattern TC,
    pattern TD,
    pattern TF,
    pattern TG,
    pattern TH,
    pattern TJ,
    pattern TK,
    pattern TL,
    pattern TM,
    pattern TN,
    pattern TO,
    pattern TR,
    pattern TT,
    pattern TV,
    pattern TW,
    pattern TZ,
    pattern UA,
    pattern UG,
    pattern UM,
    pattern UN,
    pattern US,
    pattern UY,
    pattern UZ,
    pattern VA,
    pattern VC,
    pattern VE,
    pattern VG,
    pattern VI,
    pattern VN,
    pattern VU,
    pattern WF,
    pattern WS,
    pattern XK,
    pattern YE,
    pattern YT,
    pattern ZA,
    pattern ZM,
    pattern ZW,

    -- * Pattern synonyms for 'SubFlag's
    pattern ENG,
    pattern SCT,
    pattern WLS,
    pattern USAL,
    pattern USAK,
    pattern USAS,
    pattern USAZ,
    pattern USAR,
    pattern USCA,
    pattern USCO,
    pattern USCT,
    pattern USDE,
    pattern USFL,
    pattern USGA,
    pattern USGU,
    pattern USHI,
    pattern USID,
    pattern USIL,
    pattern USIN,
    pattern USIA,
    pattern USKS,
    pattern USKY,
    pattern USLA,
    pattern USME,
    pattern USMD,
    pattern USMA,
    pattern USMI,
    pattern USMN,
    pattern USMS,
    pattern USMO,
    pattern USMT,
    pattern USNE,
    pattern USNV,
    pattern USNH,
    pattern USNJ,
    pattern USNM,
    pattern USNY,
    pattern USNC,
    pattern USND,
    pattern USMP,
    pattern USOH,
    pattern USOK,
    pattern USOR,
    pattern USPA,
    pattern USPR,
    pattern USRI,
    pattern USSC,
    pattern USSD,
    pattern USTN,
    pattern USUM,
    pattern USVI,
    pattern USUT,
    pattern USVT,
    pattern USVA,
    pattern USWA,
    pattern USDC,
    pattern USWV,
    pattern USWI,
    pattern USWY,
  )
where

import Control.DeepSeq (NFData)
import Data.Bits ((.|.))
import Data.Char (chr, ord, toLower, toUpper)
import Data.Char.Core (UnicodeText (fromUnicodeText, isInTextRange, toUnicodeText), mapToEnumSafe)
import Data.Char.Enclosed (regionalIndicatorUppercase')
import Data.Data (Data)
import Data.Function (on)
import Data.Hashable (Hashable)
import Data.List (elemIndex)
import Data.Maybe (fromJust, fromMaybe, listToMaybe)
import Data.Text (Text, pack, unpack)
import GHC.Enum (fromEnumError, toEnumError)
import GHC.Generics (Generic)
import Test.QuickCheck.Arbitrary (Arbitrary (arbitrary), arbitraryBoundedEnum)
import Test.QuickCheck.Gen (elements)
import Prelude hiding (GT, LT)

_flagCharOffset :: Int
_flagCharOffset :: Int
_flagCharOffset = Int
0x1f1a5

-- | A data type that stores a (country) flag by the two characters of the ISO
-- 3166 Alpa-2 standard. The data constructor is hidden to prevent making flags
-- with a combination of characters that is invalid.
-- Besides the countries defined in the ISO-3166 Alpha-2 standard, only the
-- Antarctica (AQ), the European Union (EU) and the United Nations (UN) have a
-- flag. Deprecated territories like the Soviet Union (SU) and Yugoslavia (YU)
-- have no corresponding flag.
data Flag = Flag Char Char deriving (Typeable Flag
Typeable Flag
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Flag -> c Flag)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Flag)
-> (Flag -> Constr)
-> (Flag -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Flag))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Flag))
-> ((forall b. Data b => b -> b) -> Flag -> Flag)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Flag -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Flag -> r)
-> (forall u. (forall d. Data d => d -> u) -> Flag -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Flag -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Flag -> m Flag)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Flag -> m Flag)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Flag -> m Flag)
-> Data Flag
Flag -> Constr
Flag -> DataType
(forall b. Data b => b -> b) -> Flag -> Flag
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Flag -> u
forall u. (forall d. Data d => d -> u) -> Flag -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Flag -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Flag -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Flag -> m Flag
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Flag -> m Flag
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Flag
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Flag -> c Flag
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Flag)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Flag)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Flag -> c Flag
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Flag -> c Flag
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Flag
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Flag
$ctoConstr :: Flag -> Constr
toConstr :: Flag -> Constr
$cdataTypeOf :: Flag -> DataType
dataTypeOf :: Flag -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Flag)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Flag)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Flag)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Flag)
$cgmapT :: (forall b. Data b => b -> b) -> Flag -> Flag
gmapT :: (forall b. Data b => b -> b) -> Flag -> Flag
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Flag -> r
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Flag -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Flag -> r
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Flag -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Flag -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> Flag -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Flag -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Flag -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Flag -> m Flag
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Flag -> m Flag
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Flag -> m Flag
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Flag -> m Flag
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Flag -> m Flag
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Flag -> m Flag
Data, Flag -> Flag -> Bool
(Flag -> Flag -> Bool) -> (Flag -> Flag -> Bool) -> Eq Flag
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Flag -> Flag -> Bool
== :: Flag -> Flag -> Bool
$c/= :: Flag -> Flag -> Bool
/= :: Flag -> Flag -> Bool
Eq, (forall x. Flag -> Rep Flag x)
-> (forall x. Rep Flag x -> Flag) -> Generic Flag
forall x. Rep Flag x -> Flag
forall x. Flag -> Rep Flag x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. Flag -> Rep Flag x
from :: forall x. Flag -> Rep Flag x
$cto :: forall x. Rep Flag x -> Flag
to :: forall x. Rep Flag x -> Flag
Generic, Eq Flag
Eq Flag
-> (Flag -> Flag -> Ordering)
-> (Flag -> Flag -> Bool)
-> (Flag -> Flag -> Bool)
-> (Flag -> Flag -> Bool)
-> (Flag -> Flag -> Bool)
-> (Flag -> Flag -> Flag)
-> (Flag -> Flag -> Flag)
-> Ord Flag
Flag -> Flag -> Bool
Flag -> Flag -> Ordering
Flag -> Flag -> Flag
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Flag -> Flag -> Ordering
compare :: Flag -> Flag -> Ordering
$c< :: Flag -> Flag -> Bool
< :: Flag -> Flag -> Bool
$c<= :: Flag -> Flag -> Bool
<= :: Flag -> Flag -> Bool
$c> :: Flag -> Flag -> Bool
> :: Flag -> Flag -> Bool
$c>= :: Flag -> Flag -> Bool
>= :: Flag -> Flag -> Bool
$cmax :: Flag -> Flag -> Flag
max :: Flag -> Flag -> Flag
$cmin :: Flag -> Flag -> Flag
min :: Flag -> Flag -> Flag
Ord, ReadPrec [Flag]
ReadPrec Flag
Int -> ReadS Flag
ReadS [Flag]
(Int -> ReadS Flag)
-> ReadS [Flag] -> ReadPrec Flag -> ReadPrec [Flag] -> Read Flag
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Flag
readsPrec :: Int -> ReadS Flag
$creadList :: ReadS [Flag]
readList :: ReadS [Flag]
$creadPrec :: ReadPrec Flag
readPrec :: ReadPrec Flag
$creadListPrec :: ReadPrec [Flag]
readListPrec :: ReadPrec [Flag]
Read, Int -> Flag -> ShowS
[Flag] -> ShowS
Flag -> String
(Int -> Flag -> ShowS)
-> (Flag -> String) -> ([Flag] -> ShowS) -> Show Flag
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Flag -> ShowS
showsPrec :: Int -> Flag -> ShowS
$cshow :: Flag -> String
show :: Flag -> String
$cshowList :: [Flag] -> ShowS
showList :: [Flag] -> ShowS
Show)

instance Hashable Flag

instance NFData Flag

-- | A data type to store a subregion flag. This is specified by the /parent/
-- flag, and three characters of the subregion. At the moment, the only three
-- subregional flags are /England/ (eng), /Scotland/ (sct) and /Wales/ (wls),
-- all beloning under the /United Kingdom/ flag (GB).
-- The data constructor is made private to prevent making non-existing subflags.
data SubFlag = SubFlag Flag Char Char (Maybe Char) deriving (Typeable SubFlag
Typeable SubFlag
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> SubFlag -> c SubFlag)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c SubFlag)
-> (SubFlag -> Constr)
-> (SubFlag -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c SubFlag))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SubFlag))
-> ((forall b. Data b => b -> b) -> SubFlag -> SubFlag)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> SubFlag -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> SubFlag -> r)
-> (forall u. (forall d. Data d => d -> u) -> SubFlag -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> SubFlag -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> SubFlag -> m SubFlag)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> SubFlag -> m SubFlag)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> SubFlag -> m SubFlag)
-> Data SubFlag
SubFlag -> Constr
SubFlag -> DataType
(forall b. Data b => b -> b) -> SubFlag -> SubFlag
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> SubFlag -> u
forall u. (forall d. Data d => d -> u) -> SubFlag -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SubFlag -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SubFlag -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> SubFlag -> m SubFlag
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SubFlag -> m SubFlag
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SubFlag
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SubFlag -> c SubFlag
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SubFlag)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SubFlag)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SubFlag -> c SubFlag
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SubFlag -> c SubFlag
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SubFlag
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SubFlag
$ctoConstr :: SubFlag -> Constr
toConstr :: SubFlag -> Constr
$cdataTypeOf :: SubFlag -> DataType
dataTypeOf :: SubFlag -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SubFlag)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SubFlag)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SubFlag)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SubFlag)
$cgmapT :: (forall b. Data b => b -> b) -> SubFlag -> SubFlag
gmapT :: (forall b. Data b => b -> b) -> SubFlag -> SubFlag
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SubFlag -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SubFlag -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SubFlag -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SubFlag -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> SubFlag -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> SubFlag -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> SubFlag -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> SubFlag -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> SubFlag -> m SubFlag
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> SubFlag -> m SubFlag
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SubFlag -> m SubFlag
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SubFlag -> m SubFlag
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SubFlag -> m SubFlag
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SubFlag -> m SubFlag
Data, SubFlag -> SubFlag -> Bool
(SubFlag -> SubFlag -> Bool)
-> (SubFlag -> SubFlag -> Bool) -> Eq SubFlag
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: SubFlag -> SubFlag -> Bool
== :: SubFlag -> SubFlag -> Bool
$c/= :: SubFlag -> SubFlag -> Bool
/= :: SubFlag -> SubFlag -> Bool
Eq, (forall x. SubFlag -> Rep SubFlag x)
-> (forall x. Rep SubFlag x -> SubFlag) -> Generic SubFlag
forall x. Rep SubFlag x -> SubFlag
forall x. SubFlag -> Rep SubFlag x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. SubFlag -> Rep SubFlag x
from :: forall x. SubFlag -> Rep SubFlag x
$cto :: forall x. Rep SubFlag x -> SubFlag
to :: forall x. Rep SubFlag x -> SubFlag
Generic, Eq SubFlag
Eq SubFlag
-> (SubFlag -> SubFlag -> Ordering)
-> (SubFlag -> SubFlag -> Bool)
-> (SubFlag -> SubFlag -> Bool)
-> (SubFlag -> SubFlag -> Bool)
-> (SubFlag -> SubFlag -> Bool)
-> (SubFlag -> SubFlag -> SubFlag)
-> (SubFlag -> SubFlag -> SubFlag)
-> Ord SubFlag
SubFlag -> SubFlag -> Bool
SubFlag -> SubFlag -> Ordering
SubFlag -> SubFlag -> SubFlag
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: SubFlag -> SubFlag -> Ordering
compare :: SubFlag -> SubFlag -> Ordering
$c< :: SubFlag -> SubFlag -> Bool
< :: SubFlag -> SubFlag -> Bool
$c<= :: SubFlag -> SubFlag -> Bool
<= :: SubFlag -> SubFlag -> Bool
$c> :: SubFlag -> SubFlag -> Bool
> :: SubFlag -> SubFlag -> Bool
$c>= :: SubFlag -> SubFlag -> Bool
>= :: SubFlag -> SubFlag -> Bool
$cmax :: SubFlag -> SubFlag -> SubFlag
max :: SubFlag -> SubFlag -> SubFlag
$cmin :: SubFlag -> SubFlag -> SubFlag
min :: SubFlag -> SubFlag -> SubFlag
Ord, ReadPrec [SubFlag]
ReadPrec SubFlag
Int -> ReadS SubFlag
ReadS [SubFlag]
(Int -> ReadS SubFlag)
-> ReadS [SubFlag]
-> ReadPrec SubFlag
-> ReadPrec [SubFlag]
-> Read SubFlag
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS SubFlag
readsPrec :: Int -> ReadS SubFlag
$creadList :: ReadS [SubFlag]
readList :: ReadS [SubFlag]
$creadPrec :: ReadPrec SubFlag
readPrec :: ReadPrec SubFlag
$creadListPrec :: ReadPrec [SubFlag]
readListPrec :: ReadPrec [SubFlag]
Read, Int -> SubFlag -> ShowS
[SubFlag] -> ShowS
SubFlag -> String
(Int -> SubFlag -> ShowS)
-> (SubFlag -> String) -> ([SubFlag] -> ShowS) -> Show SubFlag
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> SubFlag -> ShowS
showsPrec :: Int -> SubFlag -> ShowS
$cshow :: SubFlag -> String
show :: SubFlag -> String
$cshowList :: [SubFlag] -> ShowS
showList :: [SubFlag] -> ShowS
Show)

instance Bounded Flag where
  minBound :: Flag
minBound = Flag
AC
  maxBound :: Flag
maxBound = Flag
ZW

instance Hashable SubFlag

instance NFData SubFlag

-- | Convert the given two characters that represent a flag according to the ISO
-- 3166 Alpha-2 standard to a 'Flag' wrapped in a 'Just' data constructor, if
-- that flag exists; 'Nothing' otherwise.
-- One can pass characters in upper case (@A-Z@) and lower case (@a-z@). The
-- flag will hold the upper case variant.
-- The Emoji have flags for the countries defined by the ISO 3166 Alpha-2
-- standard without deprecated regions like the Soviet Union (SU) and Yugoslavia
-- (YU). Furthermore there are Emoji for the flags of Antarctica (AQ), the
-- European Union (EU) and the United Nations (UN).
flag ::
  -- | The first character of the ISO 3166 Alpha-2 standard.
  Char ->
  -- | The second character of the ISO 3166 Alpha-2 standard.
  Char ->
  -- | A 'Flag' object wrapped in a 'Just' data constructor, given such flag exists; 'Nothing' otherwise.
  Maybe Flag
flag :: Char -> Char -> Maybe Flag
flag Char
ca Char
cb
  | Char -> Char -> Bool
_validFlagEmoji Char
a Char
b = Flag -> Maybe Flag
forall a. a -> Maybe a
Just (Char -> Char -> Flag
Flag Char
a Char
b)
  | Bool
otherwise = Maybe Flag
forall a. Maybe a
Nothing
  where
    a :: Char
a = Char -> Char
toUpper Char
ca
    b :: Char
b = Char -> Char
toUpper Char
cb

-- | Convert the given two characters that represent a flag according to the ISO
-- 3166 Alpha-2 standard to a 'Flag'. If the flag does not exists, then the
-- result is unspecified.
-- One can pass characters in upper case (@A-Z@) and lower case (@a-z@). The
-- flag will hold the upper case variant.
-- The Emoji have flags for the countries defined by the ISO 3166 Alpha-2
-- standard without deprecated regions like the Soviet Union (SU) and Yugoslavia
-- (YU). Furthermore there are Emoji for the flags of Antarctica (AQ), the
-- European Union (EU) and the United Nations (UN).
flag' ::
  -- | The first character of the ISO 3166 Alpha-2 standard.
  Char ->
  -- | The second character of the ISO 3166 Alpha-2 standard.
  Char ->
  -- | The equivalent 'Flag' object.
  Flag
flag' :: Char -> Char -> Flag
flag' Char
ca = Maybe Flag -> Flag
forall a. HasCallStack => Maybe a -> a
fromJust (Maybe Flag -> Flag) -> (Char -> Maybe Flag) -> Char -> Flag
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Char -> Char -> Maybe Flag
flag Char
ca

-- | Obtain the two-characters that specify the given 'Flag'. These two
-- characters are always upper case (@A-Z@).
flagChars ::
  -- | The given 'Flag' to convert to a 2-tuple of 'Char'acters.
  Flag ->
  -- | A 2-tuple that contains upper case 'Char'acters for the given 'Flag'.
  (Char, Char)
flagChars :: Flag -> (Char, Char)
flagChars (Flag Char
ca Char
cb) = (Char
ca, Char
cb)

-- | The 'Flag' pattern used for /Ascension Island/ denoted with /AC/.
pattern AC :: Flag
pattern $mAC :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bAC :: Flag
AC = Flag 'A' 'C'

-- | The 'Flag' pattern used for /Andorra/ denoted with /AD/.
pattern AD :: Flag
pattern $mAD :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bAD :: Flag
AD = Flag 'A' 'D'

-- | The 'Flag' pattern used for the /United Arab Emirates/ denoted with /AE/.
pattern AE :: Flag
pattern $mAE :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bAE :: Flag
AE = Flag 'A' 'E'

-- | The 'Flag' pattern used for /Afghanistan/ denoted with /AF/.
pattern AF :: Flag
pattern $mAF :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bAF :: Flag
AF = Flag 'A' 'F'

-- | The 'Flag' pattern used for /Antigua & Barbuda/ denoted with /AG/.
pattern AG :: Flag
pattern $mAG :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bAG :: Flag
AG = Flag 'A' 'G'

-- | The 'Flag' pattern used for /Anguilla/ denoted with /AI/.
pattern AI :: Flag
pattern $mAI :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bAI :: Flag
AI = Flag 'A' 'I'

-- | The 'Flag' pattern used for /Albania/ denoted with /AL/.
pattern AL :: Flag
pattern $mAL :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bAL :: Flag
AL = Flag 'A' 'L'

-- | The 'Flag' pattern used for /Armenia/ denoted with /AM/.
pattern AM :: Flag
pattern $mAM :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bAM :: Flag
AM = Flag 'A' 'M'

-- | The 'Flag' pattern used for /Angola/ denoted with /AO/.
pattern AO :: Flag
pattern $mAO :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bAO :: Flag
AO = Flag 'A' 'O'

-- | The 'Flag' pattern used for /Antarctica/ denoted with /AQ/.
pattern AQ :: Flag
pattern $mAQ :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bAQ :: Flag
AQ = Flag 'A' 'Q'

-- | The 'Flag' pattern used for /Argentina/ denoted with /AR/.
pattern AR :: Flag
pattern $mAR :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bAR :: Flag
AR = Flag 'A' 'R'

-- | The 'Flag' pattern used for /American Samoa/ denoted with /AS/.
pattern AS :: Flag
pattern $mAS :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bAS :: Flag
AS = Flag 'A' 'S'

-- | The 'Flag' pattern used for /Austria/ denoted with /AT/.
pattern AT :: Flag
pattern $mAT :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bAT :: Flag
AT = Flag 'A' 'T'

-- | The 'Flag' pattern used for /Australia/ denoted with /AU/.
pattern AU :: Flag
pattern $mAU :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bAU :: Flag
AU = Flag 'A' 'U'

-- | The 'Flag' pattern used for /Aruba/ denoted with /AW/.
pattern AW :: Flag
pattern $mAW :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bAW :: Flag
AW = Flag 'A' 'W'

-- | The 'Flag' pattern used for the /Åland Islands/ denoted with /AX/.
pattern AX :: Flag
pattern $mAX :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bAX :: Flag
AX = Flag 'A' 'X'

-- | The 'Flag' pattern used for /Azerbaijan/ denoted with /AZ/.
pattern AZ :: Flag
pattern $mAZ :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bAZ :: Flag
AZ = Flag 'A' 'Z'

-- | The 'Flag' pattern used for /Bosnia & Herzegovina/ denoted with /BA/.
pattern BA :: Flag
pattern $mBA :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bBA :: Flag
BA = Flag 'B' 'A'

-- | The 'Flag' pattern used for /Barbados/ denoted with /BB/.
pattern BB :: Flag
pattern $mBB :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bBB :: Flag
BB = Flag 'B' 'B'

-- | The 'Flag' pattern used for /Bangladesh/ denoted with /BD/.
pattern BD :: Flag
pattern $mBD :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bBD :: Flag
BD = Flag 'B' 'D'

-- | The 'Flag' pattern used for /Belgium/ denoted with /BE/.
pattern BE :: Flag
pattern $mBE :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bBE :: Flag
BE = Flag 'B' 'E'

-- | The 'Flag' pattern used for /Burkina Faso/ denoted with /BF/.
pattern BF :: Flag
pattern $mBF :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bBF :: Flag
BF = Flag 'B' 'F'

-- | The 'Flag' pattern used for /Bulgaria/ denoted with /BG/.
pattern BG :: Flag
pattern $mBG :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bBG :: Flag
BG = Flag 'B' 'G'

-- | The 'Flag' pattern used for /Bahrain/ denoted with /BH/.
pattern BH :: Flag
pattern $mBH :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bBH :: Flag
BH = Flag 'B' 'H'

-- | The 'Flag' pattern used for /Burundi/ denoted with /BI/.
pattern BI :: Flag
pattern $mBI :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bBI :: Flag
BI = Flag 'B' 'I'

-- | The 'Flag' pattern used for /Benin/ denoted with /BJ/.
pattern BJ :: Flag
pattern $mBJ :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bBJ :: Flag
BJ = Flag 'B' 'J'

-- | The 'Flag' pattern used for /St. Barthélemy/ denoted with /BL/.
pattern BL :: Flag
pattern $mBL :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bBL :: Flag
BL = Flag 'B' 'L'

-- | The 'Flag' pattern used for /Bermuda/ denoted with /BM/.
pattern BM :: Flag
pattern $mBM :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bBM :: Flag
BM = Flag 'B' 'M'

-- | The 'Flag' pattern used for /Brunei/ denoted with /BN/.
pattern BN :: Flag
pattern $mBN :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bBN :: Flag
BN = Flag 'B' 'N'

-- | The 'Flag' pattern used for /Bolivia/ denoted with /BO/.
pattern BO :: Flag
pattern $mBO :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bBO :: Flag
BO = Flag 'B' 'O'

-- | The 'Flag' pattern used for the /Caribbean Netherlands/ denoted with /BQ/.
pattern BQ :: Flag
pattern $mBQ :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bBQ :: Flag
BQ = Flag 'B' 'Q'

-- | The 'Flag' pattern used for /Brazil/ denoted with /BR/.
pattern BR :: Flag
pattern $mBR :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bBR :: Flag
BR = Flag 'B' 'R'

-- | The 'Flag' pattern used for the /Bahamas/ denoted with /BS/.
pattern BS :: Flag
pattern $mBS :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bBS :: Flag
BS = Flag 'B' 'S'

-- | The 'Flag' pattern used for /Bhutan/ denoted with /BT/.
pattern BT :: Flag
pattern $mBT :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bBT :: Flag
BT = Flag 'B' 'T'

-- | The 'Flag' pattern used for /Bouvet Island/ denoted with /BV/.
pattern BV :: Flag
pattern $mBV :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bBV :: Flag
BV = Flag 'B' 'V'

-- | The 'Flag' pattern used for /Botswana/ denoted with /BW/.
pattern BW :: Flag
pattern $mBW :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bBW :: Flag
BW = Flag 'B' 'W'

-- | The 'Flag' pattern used for /Belarus/ denoted with /BY/.
pattern BY :: Flag
pattern $mBY :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bBY :: Flag
BY = Flag 'B' 'Y'

-- | The 'Flag' pattern used for /Belize/ denoted with /BZ/.
pattern BZ :: Flag
pattern $mBZ :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bBZ :: Flag
BZ = Flag 'B' 'Z'

-- | The 'Flag' pattern used for /Canada/ denoted with /CA/.
pattern CA :: Flag
pattern $mCA :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bCA :: Flag
CA = Flag 'C' 'A'

-- | The 'Flag' pattern used for the /Cocos (Keeling) Islands/ denoted with /CC/.
pattern CC :: Flag
pattern $mCC :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bCC :: Flag
CC = Flag 'C' 'C'

-- | The 'Flag' pattern used for /Congo - Kinshasa/ denoted with /CD/.
pattern CD :: Flag
pattern $mCD :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bCD :: Flag
CD = Flag 'C' 'D'

-- | The 'Flag' pattern used for /Central African Republic/ denoted with /CF/.
pattern CF :: Flag
pattern $mCF :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bCF :: Flag
CF = Flag 'C' 'F'

-- | The 'Flag' pattern used for /Congo - Brazzaville/ denoted with /CG/.
pattern CG :: Flag
pattern $mCG :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bCG :: Flag
CG = Flag 'C' 'G'

-- | The 'Flag' pattern used for /Switzerland/ denoted with /CH/.
pattern CH :: Flag
pattern $mCH :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bCH :: Flag
CH = Flag 'C' 'H'

-- | The 'Flag' pattern used for /Côte d’Ivoire/ denoted with /CI/.
pattern CI :: Flag
pattern $mCI :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bCI :: Flag
CI = Flag 'C' 'I'

-- | The 'Flag' pattern used for the /Cook Islands/ denoted with /CK/.
pattern CK :: Flag
pattern $mCK :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bCK :: Flag
CK = Flag 'C' 'K'

-- | The 'Flag' pattern used for /Chile/ denoted with /CL/.
pattern CL :: Flag
pattern $mCL :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bCL :: Flag
CL = Flag 'C' 'L'

-- | The 'Flag' pattern used for /Cameroon/ denoted with /CM/.
pattern CM :: Flag
pattern $mCM :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bCM :: Flag
CM = Flag 'C' 'M'

-- | The 'Flag' pattern used for /China/ denoted with /CN/.
pattern CN :: Flag
pattern $mCN :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bCN :: Flag
CN = Flag 'C' 'N'

-- | The 'Flag' pattern used for /Colombia/ denoted with /CO/.
pattern CO :: Flag
pattern $mCO :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bCO :: Flag
CO = Flag 'C' 'O'

-- | The 'Flag' pattern used for /Clipperton Island/ denoted with /CP/.
pattern CP :: Flag
pattern $mCP :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bCP :: Flag
CP = Flag 'C' 'P'

-- | The 'Flag' pattern used for /Costa Rica/ denoted with /CR/.
pattern CR :: Flag
pattern $mCR :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bCR :: Flag
CR = Flag 'C' 'R'

-- | The 'Flag' pattern used for /Cuba/ denoted with /CU/.
pattern CU :: Flag
pattern $mCU :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bCU :: Flag
CU = Flag 'C' 'U'

-- | The 'Flag' pattern used for /Cape Verde/ denoted with /CV/.
pattern CV :: Flag
pattern $mCV :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bCV :: Flag
CV = Flag 'C' 'V'

-- | The 'Flag' pattern used for /Curaçao/ denoted with /CW/.
pattern CW :: Flag
pattern $mCW :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bCW :: Flag
CW = Flag 'C' 'W'

-- | The 'Flag' pattern used for /Christmas Island/ denoted with /CX/.
pattern CX :: Flag
pattern $mCX :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bCX :: Flag
CX = Flag 'C' 'X'

-- | The 'Flag' pattern used for /Cyprus/ denoted with /CY/.
pattern CY :: Flag
pattern $mCY :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bCY :: Flag
CY = Flag 'C' 'Y'

-- | The 'Flag' pattern used for /Czechia/ denoted with /CZ/.
pattern CZ :: Flag
pattern $mCZ :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bCZ :: Flag
CZ = Flag 'C' 'Z'

-- | The 'Flag' pattern used for /Germany/ denoted with /DE/.
pattern DE :: Flag
pattern $mDE :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bDE :: Flag
DE = Flag 'D' 'E'

-- | The 'Flag' pattern used for /Diego Garcia/ denoted with /DG/.
pattern DG :: Flag
pattern $mDG :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bDG :: Flag
DG = Flag 'D' 'G'

-- | The 'Flag' pattern used for /Djibouti/ denoted with /DJ/.
pattern DJ :: Flag
pattern $mDJ :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bDJ :: Flag
DJ = Flag 'D' 'J'

-- | The 'Flag' pattern used for /Denmark/ denoted with /DK/.
pattern DK :: Flag
pattern $mDK :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bDK :: Flag
DK = Flag 'D' 'K'

-- | The 'Flag' pattern used for /Dominica/ denoted with /DM/.
pattern DM :: Flag
pattern $mDM :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bDM :: Flag
DM = Flag 'D' 'M'

-- | The 'Flag' pattern used for /Dominican Republic/ denoted with /DO/.
pattern DO :: Flag
pattern $mDO :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bDO :: Flag
DO = Flag 'D' 'O'

-- | The 'Flag' pattern used for /Algeria/ denoted with /DZ/.
pattern DZ :: Flag
pattern $mDZ :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bDZ :: Flag
DZ = Flag 'D' 'Z'

-- | The 'Flag' pattern used for /Ceuta & Melilla/ denoted with /EA/.
pattern EA :: Flag
pattern $mEA :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bEA :: Flag
EA = Flag 'E' 'A'

-- | The 'Flag' pattern used for /Ecuador/ denoted with /EC/.
pattern EC :: Flag
pattern $mEC :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bEC :: Flag
EC = Flag 'E' 'C'

-- | The 'Flag' pattern used for /Estonia/ denoted with /EE/.
pattern EE :: Flag
pattern $mEE :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bEE :: Flag
EE = Flag 'E' 'E'

-- | The 'Flag' pattern used for /Egypt/ denoted with /EG/.
pattern EG :: Flag
pattern $mEG :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bEG :: Flag
EG = Flag 'E' 'G'

-- | The 'Flag' pattern used for /Western Sahara/ denoted with /EH/.
pattern EH :: Flag
pattern $mEH :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bEH :: Flag
EH = Flag 'E' 'H'

-- | The 'Flag' pattern used for /Eritrea/ denoted with /ER/.
pattern ER :: Flag
pattern $mER :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bER :: Flag
ER = Flag 'E' 'R'

-- | The 'Flag' pattern used for /Spain/ denoted with /ES/.
pattern ES :: Flag
pattern $mES :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bES :: Flag
ES = Flag 'E' 'S'

-- | The 'Flag' pattern used for /Ethiopia/ denoted with /ET/.
pattern ET :: Flag
pattern $mET :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bET :: Flag
ET = Flag 'E' 'T'

-- | The 'Flag' pattern used for the /European Union/ denoted with /EU/.
pattern EU :: Flag
pattern $mEU :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bEU :: Flag
EU = Flag 'E' 'U'

-- | The 'Flag' pattern used for /Finland/ denoted with /FI/.
pattern FI :: Flag
pattern $mFI :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bFI :: Flag
FI = Flag 'F' 'I'

-- | The 'Flag' pattern used for /Fiji/ denoted with /FJ/.
pattern FJ :: Flag
pattern $mFJ :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bFJ :: Flag
FJ = Flag 'F' 'J'

-- | The 'Flag' pattern used for the /Falkland Islands/ denoted with /FK/.
pattern FK :: Flag
pattern $mFK :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bFK :: Flag
FK = Flag 'F' 'K'

-- | The 'Flag' pattern used for /Micronesia/ denoted with /FM/.
pattern FM :: Flag
pattern $mFM :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bFM :: Flag
FM = Flag 'F' 'M'

-- | The 'Flag' pattern used for the /Faroe Islands/ denoted with /FO/.
pattern FO :: Flag
pattern $mFO :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bFO :: Flag
FO = Flag 'F' 'O'

-- | The 'Flag' pattern used for /France/ denoted with /FR/.
pattern FR :: Flag
pattern $mFR :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bFR :: Flag
FR = Flag 'F' 'R'

-- | The 'Flag' pattern used for /Gabon/ denoted with /GA/.
pattern GA :: Flag
pattern $mGA :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bGA :: Flag
GA = Flag 'G' 'A'

-- | The 'Flag' pattern used for /United Kingdom/ denoted with /GB/.
pattern GB :: Flag
pattern $mGB :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bGB :: Flag
GB = Flag 'G' 'B'

-- | The 'Flag' pattern used for /Grenada/ denoted with /GD/.
pattern GD :: Flag
pattern $mGD :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bGD :: Flag
GD = Flag 'G' 'D'

-- | The 'Flag' pattern used for /Georgia/ denoted with /GE/.
pattern GE :: Flag
pattern $mGE :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bGE :: Flag
GE = Flag 'G' 'E'

-- | The 'Flag' pattern used for /French Guiana/ denoted with /GF/.
pattern GF :: Flag
pattern $mGF :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bGF :: Flag
GF = Flag 'G' 'F'

-- | The 'Flag' pattern used for /Guernsey/ denoted with /GG/.
pattern GG :: Flag
pattern $mGG :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bGG :: Flag
GG = Flag 'G' 'G'

-- | The 'Flag' pattern used for /Ghana/ denoted with /GH/.
pattern GH :: Flag
pattern $mGH :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bGH :: Flag
GH = Flag 'G' 'H'

-- | The 'Flag' pattern used for /Gibraltar/ denoted with /GI/.
pattern GI :: Flag
pattern $mGI :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bGI :: Flag
GI = Flag 'G' 'I'

-- | The 'Flag' pattern used for /Greenland/ denoted with /GL/.
pattern GL :: Flag
pattern $mGL :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bGL :: Flag
GL = Flag 'G' 'L'

-- | The 'Flag' pattern used for /Gambia/ denoted with /GM/.
pattern GM :: Flag
pattern $mGM :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bGM :: Flag
GM = Flag 'G' 'M'

-- | The 'Flag' pattern used for /Guinea/ denoted with /GN/.
pattern GN :: Flag
pattern $mGN :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bGN :: Flag
GN = Flag 'G' 'N'

-- | The 'Flag' pattern used for /Guadeloupe/ denoted with /GP/.
pattern GP :: Flag
pattern $mGP :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bGP :: Flag
GP = Flag 'G' 'P'

-- | The 'Flag' pattern used for /Equatorial Guinea/ denoted with /GQ/.
pattern GQ :: Flag
pattern $mGQ :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bGQ :: Flag
GQ = Flag 'G' 'Q'

-- | The 'Flag' pattern used for /Greece/ denoted with /GR/.
pattern GR :: Flag
pattern $mGR :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bGR :: Flag
GR = Flag 'G' 'R'

-- | The 'Flag' pattern used for the /South Georgia & South Sandwich Islands/ denoted with /GS/.
pattern GS :: Flag
pattern $mGS :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bGS :: Flag
GS = Flag 'G' 'S'

-- | The 'Flag' pattern used for /Guatemala/ denoted with /GT/.
pattern GT :: Flag
pattern $mGT :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bGT :: Flag
GT = Flag 'G' 'T'

-- | The 'Flag' pattern used for /Guam/ denoted with /GU/.
pattern GU :: Flag
pattern $mGU :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bGU :: Flag
GU = Flag 'G' 'U'

-- | The 'Flag' pattern used for /Guinea-Bissau/ denoted with /GW/.
pattern GW :: Flag
pattern $mGW :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bGW :: Flag
GW = Flag 'G' 'W'

-- | The 'Flag' pattern used for /Guyana/ denoted with /GY/.
pattern GY :: Flag
pattern $mGY :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bGY :: Flag
GY = Flag 'G' 'Y'

-- | The 'Flag' pattern used for /Hong Kong SAR China/ denoted with /HK/.
pattern HK :: Flag
pattern $mHK :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bHK :: Flag
HK = Flag 'H' 'K'

-- | The 'Flag' pattern used for the /Heard & McDonald Islands/ denoted with /HM/.
pattern HM :: Flag
pattern $mHM :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bHM :: Flag
HM = Flag 'H' 'M'

-- | The 'Flag' pattern used for /Honduras/ denoted with /HN/.
pattern HN :: Flag
pattern $mHN :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bHN :: Flag
HN = Flag 'H' 'N'

-- | The 'Flag' pattern used for /Croatia/ denoted with /HR/.
pattern HR :: Flag
pattern $mHR :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bHR :: Flag
HR = Flag 'H' 'R'

-- | The 'Flag' pattern used for /Haiti/ denoted with /HT/.
pattern HT :: Flag
pattern $mHT :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bHT :: Flag
HT = Flag 'H' 'T'

-- | The 'Flag' pattern used for /Hungary/ denoted with /HU/.
pattern HU :: Flag
pattern $mHU :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bHU :: Flag
HU = Flag 'H' 'U'

-- | The 'Flag' pattern used for the /Canary Islands/ denoted with /IC/.
pattern IC :: Flag
pattern $mIC :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bIC :: Flag
IC = Flag 'I' 'C'

-- | The 'Flag' pattern used for /Indonesia/ denoted with /ID/.
pattern ID :: Flag
pattern $mID :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bID :: Flag
ID = Flag 'I' 'D'

-- | The 'Flag' pattern used for /Ireland/ denoted with /IE/.
pattern IE :: Flag
pattern $mIE :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bIE :: Flag
IE = Flag 'I' 'E'

-- | The 'Flag' pattern used for /Israel/ denoted with /IL/.
pattern IL :: Flag
pattern $mIL :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bIL :: Flag
IL = Flag 'I' 'L'

-- | The 'Flag' pattern used for /Isle of Man/ denoted with /IM/.
pattern IM :: Flag
pattern $mIM :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bIM :: Flag
IM = Flag 'I' 'M'

-- | The 'Flag' pattern used for /India/ denoted with /IN/.
pattern IN :: Flag
pattern $mIN :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bIN :: Flag
IN = Flag 'I' 'N'

-- | The 'Flag' pattern used for /British Indian Ocean Territory/ denoted with /IO/.
pattern IO :: Flag
pattern $mIO :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bIO :: Flag
IO = Flag 'I' 'O'

-- | The 'Flag' pattern used for /Iraq/ denoted with /IQ/.
pattern IQ :: Flag
pattern $mIQ :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bIQ :: Flag
IQ = Flag 'I' 'Q'

-- | The 'Flag' pattern used for /Iran/ denoted with /IR/.
pattern IR :: Flag
pattern $mIR :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bIR :: Flag
IR = Flag 'I' 'R'

-- | The 'Flag' pattern used for /Iceland/ denoted with /IS/.
pattern IS :: Flag
pattern $mIS :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bIS :: Flag
IS = Flag 'I' 'S'

-- | The 'Flag' pattern used for /Italy/ denoted with /IT/.
pattern IT :: Flag
pattern $mIT :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bIT :: Flag
IT = Flag 'I' 'T'

-- | The 'Flag' pattern used for /Jersey/ denoted with /JE/.
pattern JE :: Flag
pattern $mJE :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bJE :: Flag
JE = Flag 'J' 'E'

-- | The 'Flag' pattern used for /Jamaica/ denoted with /JM/.
pattern JM :: Flag
pattern $mJM :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bJM :: Flag
JM = Flag 'J' 'M'

-- | The 'Flag' pattern used for /Jordan/ denoted with /JO/.
pattern JO :: Flag
pattern $mJO :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bJO :: Flag
JO = Flag 'J' 'O'

-- | The 'Flag' pattern used for /Japan/ denoted with /JP/.
pattern JP :: Flag
pattern $mJP :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bJP :: Flag
JP = Flag 'J' 'P'

-- | The 'Flag' pattern used for /Kenya/ denoted with /KE/.
pattern KE :: Flag
pattern $mKE :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bKE :: Flag
KE = Flag 'K' 'E'

-- | The 'Flag' pattern used for /Kyrgyzstan/ denoted with /KG/.
pattern KG :: Flag
pattern $mKG :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bKG :: Flag
KG = Flag 'K' 'G'

-- | The 'Flag' pattern used for /Cambodia/ denoted with /KH/.
pattern KH :: Flag
pattern $mKH :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bKH :: Flag
KH = Flag 'K' 'H'

-- | The 'Flag' pattern used for /Kiribati/ denoted with /KI/.
pattern KI :: Flag
pattern $mKI :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bKI :: Flag
KI = Flag 'K' 'I'

-- | The 'Flag' pattern used for the /Comoros/ denoted with /KM/.
pattern KM :: Flag
pattern $mKM :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bKM :: Flag
KM = Flag 'K' 'M'

-- | The 'Flag' pattern used for /St. Kitts & Nevis/ denoted with /KN/.
pattern KN :: Flag
pattern $mKN :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bKN :: Flag
KN = Flag 'K' 'N'

-- | The 'Flag' pattern used for /North Korea/ denoted with /KP/.
pattern KP :: Flag
pattern $mKP :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bKP :: Flag
KP = Flag 'K' 'P'

-- | The 'Flag' pattern used for /South Korea/ denoted with /KR/.
pattern KR :: Flag
pattern $mKR :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bKR :: Flag
KR = Flag 'K' 'R'

-- | The 'Flag' pattern used for /Kuwait/ denoted with /KW/.
pattern KW :: Flag
pattern $mKW :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bKW :: Flag
KW = Flag 'K' 'W'

-- | The 'Flag' pattern used for the /Cayman Islands/ denoted with /KY/.
pattern KY :: Flag
pattern $mKY :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bKY :: Flag
KY = Flag 'K' 'Y'

-- | The 'Flag' pattern used for /Kazakhstan/ denoted with /KZ/.
pattern KZ :: Flag
pattern $mKZ :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bKZ :: Flag
KZ = Flag 'K' 'Z'

-- | The 'Flag' pattern used for /Laos/ denoted with /LA/.
pattern LA :: Flag
pattern $mLA :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bLA :: Flag
LA = Flag 'L' 'A'

-- | The 'Flag' pattern used for /Lebanon/ denoted with /LB/.
pattern LB :: Flag
pattern $mLB :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bLB :: Flag
LB = Flag 'L' 'B'

-- | The 'Flag' pattern used for /St. Lucia/ denoted with /LC/.
pattern LC :: Flag
pattern $mLC :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bLC :: Flag
LC = Flag 'L' 'C'

-- | The 'Flag' pattern used for /Liechtenstein/ denoted with /LI/.
pattern LI :: Flag
pattern $mLI :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bLI :: Flag
LI = Flag 'L' 'I'

-- | The 'Flag' pattern used for /Sri Lanka/ denoted with /LK/.
pattern LK :: Flag
pattern $mLK :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bLK :: Flag
LK = Flag 'L' 'K'

-- | The 'Flag' pattern used for /Liberia/ denoted with /LR/.
pattern LR :: Flag
pattern $mLR :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bLR :: Flag
LR = Flag 'L' 'R'

-- | The 'Flag' pattern used for /Lesotho/ denoted with /LS/.
pattern LS :: Flag
pattern $mLS :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bLS :: Flag
LS = Flag 'L' 'S'

-- | The 'Flag' pattern used for /Lithuania/ denoted with /LT/.
pattern LT :: Flag
pattern $mLT :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bLT :: Flag
LT = Flag 'L' 'T'

-- | The 'Flag' pattern used for /Luxembourg/ denoted with /LU/.
pattern LU :: Flag
pattern $mLU :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bLU :: Flag
LU = Flag 'L' 'U'

-- | The 'Flag' pattern used for /Latvia/ denoted with /LV/.
pattern LV :: Flag
pattern $mLV :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bLV :: Flag
LV = Flag 'L' 'V'

-- | The 'Flag' pattern used for /Libya/ denoted with /LY/.
pattern LY :: Flag
pattern $mLY :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bLY :: Flag
LY = Flag 'L' 'Y'

-- | The 'Flag' pattern used for /Morocco/ denoted with /MA/.
pattern MA :: Flag
pattern $mMA :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bMA :: Flag
MA = Flag 'M' 'A'

-- | The 'Flag' pattern used for /Monaco/ denoted with /MC/.
pattern MC :: Flag
pattern $mMC :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bMC :: Flag
MC = Flag 'M' 'C'

-- | The 'Flag' pattern used for /Moldova/ denoted with /MD/.
pattern MD :: Flag
pattern $mMD :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bMD :: Flag
MD = Flag 'M' 'D'

-- | The 'Flag' pattern used for /Montenegro/ denoted with /ME/.
pattern ME :: Flag
pattern $mME :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bME :: Flag
ME = Flag 'M' 'E'

-- | The 'Flag' pattern used for /St. Martin/ denoted with /MF/.
pattern MF :: Flag
pattern $mMF :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bMF :: Flag
MF = Flag 'M' 'F'

-- | The 'Flag' pattern used for /Madagascar/ denoted with /MG/.
pattern MG :: Flag
pattern $mMG :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bMG :: Flag
MG = Flag 'M' 'G'

-- | The 'Flag' pattern used for the /Marshall Islands/ denoted with /MH/.
pattern MH :: Flag
pattern $mMH :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bMH :: Flag
MH = Flag 'M' 'H'

-- | The 'Flag' pattern used for /North Macedonia/ denoted with /MK/.
pattern MK :: Flag
pattern $mMK :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bMK :: Flag
MK = Flag 'M' 'K'

-- | The 'Flag' pattern used for /Mali/ denoted with /ML/.
pattern ML :: Flag
pattern $mML :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bML :: Flag
ML = Flag 'M' 'L'

-- | The 'Flag' pattern used for /Myanmar (Burma)/ denoted with /MM/.
pattern MM :: Flag
pattern $mMM :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bMM :: Flag
MM = Flag 'M' 'M'

-- | The 'Flag' pattern used for /Mongolia/ denoted with /MN/.
pattern MN :: Flag
pattern $mMN :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bMN :: Flag
MN = Flag 'M' 'N'

-- | The 'Flag' pattern used for /Macao SAR China/ denoted with /MO/.
pattern MO :: Flag
pattern $mMO :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bMO :: Flag
MO = Flag 'M' 'O'

-- | The 'Flag' pattern used for the /Northern Mariana Islands/ denoted with /MP/.
pattern MP :: Flag
pattern $mMP :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bMP :: Flag
MP = Flag 'M' 'P'

-- | The 'Flag' pattern used for /Martinique/ denoted with /MQ/.
pattern MQ :: Flag
pattern $mMQ :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bMQ :: Flag
MQ = Flag 'M' 'Q'

-- | The 'Flag' pattern used for /Mauritania/ denoted with /MR/.
pattern MR :: Flag
pattern $mMR :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bMR :: Flag
MR = Flag 'M' 'R'

-- | The 'Flag' pattern used for /Montserrat/ denoted with /MS/.
pattern MS :: Flag
pattern $mMS :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bMS :: Flag
MS = Flag 'M' 'S'

-- | The 'Flag' pattern used for /Malta/ denoted with /MT/.
pattern MT :: Flag
pattern $mMT :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bMT :: Flag
MT = Flag 'M' 'T'

-- | The 'Flag' pattern used for /Mauritius/ denoted with /MU/.
pattern MU :: Flag
pattern $mMU :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bMU :: Flag
MU = Flag 'M' 'U'

-- | The 'Flag' pattern used for the /Maldives/ denoted with /MV/.
pattern MV :: Flag
pattern $mMV :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bMV :: Flag
MV = Flag 'M' 'V'

-- | The 'Flag' pattern used for /Malawi/ denoted with /MW/.
pattern MW :: Flag
pattern $mMW :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bMW :: Flag
MW = Flag 'M' 'W'

-- | The 'Flag' pattern used for /Mexico/ denoted with /MX/.
pattern MX :: Flag
pattern $mMX :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bMX :: Flag
MX = Flag 'M' 'X'

-- | The 'Flag' pattern used for /Malaysia/ denoted with /MY/.
pattern MY :: Flag
pattern $mMY :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bMY :: Flag
MY = Flag 'M' 'Y'

-- | The 'Flag' pattern used for /Mozambique/ denoted with /MZ/.
pattern MZ :: Flag
pattern $mMZ :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bMZ :: Flag
MZ = Flag 'M' 'Z'

-- | The 'Flag' pattern used for /Namibia/ denoted with /NA/.
pattern NA :: Flag
pattern $mNA :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bNA :: Flag
NA = Flag 'N' 'A'

-- | The 'Flag' pattern used for /New Caledonia/ denoted with /NC/.
pattern NC :: Flag
pattern $mNC :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bNC :: Flag
NC = Flag 'N' 'C'

-- | The 'Flag' pattern used for /Niger/ denoted with /NE/.
pattern NE :: Flag
pattern $mNE :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bNE :: Flag
NE = Flag 'N' 'E'

-- | The 'Flag' pattern used for /Norfolk Island/ denoted with /NF/.
pattern NF :: Flag
pattern $mNF :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bNF :: Flag
NF = Flag 'N' 'F'

-- | The 'Flag' pattern used for /Nigeria/ denoted with /NG/.
pattern NG :: Flag
pattern $mNG :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bNG :: Flag
NG = Flag 'N' 'G'

-- | The 'Flag' pattern used for /Nicaragua/ denoted with /NI/.
pattern NI :: Flag
pattern $mNI :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bNI :: Flag
NI = Flag 'N' 'I'

-- | The 'Flag' pattern used for the /Netherlands/ denoted with /NL/.
pattern NL :: Flag
pattern $mNL :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bNL :: Flag
NL = Flag 'N' 'L'

-- | The 'Flag' pattern used for /Norway/ denoted with /NO/.
pattern NO :: Flag
pattern $mNO :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bNO :: Flag
NO = Flag 'N' 'O'

-- | The 'Flag' pattern used for /Nepal/ denoted with /NP/.
pattern NP :: Flag
pattern $mNP :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bNP :: Flag
NP = Flag 'N' 'P'

-- | The 'Flag' pattern used for /Nauru/ denoted with /NR/.
pattern NR :: Flag
pattern $mNR :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bNR :: Flag
NR = Flag 'N' 'R'

-- | The 'Flag' pattern used for /Niue/ denoted with /NU/.
pattern NU :: Flag
pattern $mNU :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bNU :: Flag
NU = Flag 'N' 'U'

-- | The 'Flag' pattern used for /New Zealand/ denoted with /NZ/.
pattern NZ :: Flag
pattern $mNZ :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bNZ :: Flag
NZ = Flag 'N' 'Z'

-- | The 'Flag' pattern used for /Oman/ denoted with /OM/.
pattern OM :: Flag
pattern $mOM :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bOM :: Flag
OM = Flag 'O' 'M'

-- | The 'Flag' pattern used for /Panama/ denoted with /PA/.
pattern PA :: Flag
pattern $mPA :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bPA :: Flag
PA = Flag 'P' 'A'

-- | The 'Flag' pattern used for /Peru/ denoted with /PE/.
pattern PE :: Flag
pattern $mPE :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bPE :: Flag
PE = Flag 'P' 'E'

-- | The 'Flag' pattern used for /French Polynesia/ denoted with /PF/.
pattern PF :: Flag
pattern $mPF :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bPF :: Flag
PF = Flag 'P' 'F'

-- | The 'Flag' pattern used for /Papua New Guinea/ denoted with /PG/.
pattern PG :: Flag
pattern $mPG :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bPG :: Flag
PG = Flag 'P' 'G'

-- | The 'Flag' pattern used for the /Philippines/ denoted with /PH/.
pattern PH :: Flag
pattern $mPH :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bPH :: Flag
PH = Flag 'P' 'H'

-- | The 'Flag' pattern used for /Pakistan/ denoted with /PK/.
pattern PK :: Flag
pattern $mPK :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bPK :: Flag
PK = Flag 'P' 'K'

-- | The 'Flag' pattern used for /Poland/ denoted with /PL/.
pattern PL :: Flag
pattern $mPL :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bPL :: Flag
PL = Flag 'P' 'L'

-- | The 'Flag' pattern used for /St. Pierre & Miquelon/ denoted with /PM/.
pattern PM :: Flag
pattern $mPM :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bPM :: Flag
PM = Flag 'P' 'M'

-- | The 'Flag' pattern used for the /Pitcairn Islands/ denoted with /PN/.
pattern PN :: Flag
pattern $mPN :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bPN :: Flag
PN = Flag 'P' 'N'

-- | The 'Flag' pattern used for /Puerto Rico/ denoted with /PR/.
pattern PR :: Flag
pattern $mPR :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bPR :: Flag
PR = Flag 'P' 'R'

-- | The 'Flag' pattern used for the /Palestinian Territories/ denoted with /PS/.
pattern PS :: Flag
pattern $mPS :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bPS :: Flag
PS = Flag 'P' 'S'

-- | The 'Flag' pattern used for /Portugal/ denoted with /PT/.
pattern PT :: Flag
pattern $mPT :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bPT :: Flag
PT = Flag 'P' 'T'

-- | The 'Flag' pattern used for /Palau/ denoted with /PW/.
pattern PW :: Flag
pattern $mPW :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bPW :: Flag
PW = Flag 'P' 'W'

-- | The 'Flag' pattern used for /Paraguay/ denoted with /PY/.
pattern PY :: Flag
pattern $mPY :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bPY :: Flag
PY = Flag 'P' 'Y'

-- | The 'Flag' pattern used for /Qatar/ denoted with /QA/.
pattern QA :: Flag
pattern $mQA :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bQA :: Flag
QA = Flag 'Q' 'A'

-- | The 'Flag' pattern used for /Réunion/ denoted with /RE/.
pattern RE :: Flag
pattern $mRE :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bRE :: Flag
RE = Flag 'R' 'E'

-- | The 'Flag' pattern used for /Romania/ denoted with /RO/.
pattern RO :: Flag
pattern $mRO :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bRO :: Flag
RO = Flag 'R' 'O'

-- | The 'Flag' pattern used for /Serbia/ denoted with /RS/.
pattern RS :: Flag
pattern $mRS :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bRS :: Flag
RS = Flag 'R' 'S'

-- | The 'Flag' pattern used for /Russia/ denoted with /RU/.
pattern RU :: Flag
pattern $mRU :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bRU :: Flag
RU = Flag 'R' 'U'

-- | The 'Flag' pattern used for /Rwanda/ denoted with /RW/.
pattern RW :: Flag
pattern $mRW :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bRW :: Flag
RW = Flag 'R' 'W'

-- | The 'Flag' pattern used for /Saudi Arabia/ denoted with /SA/.
pattern SA :: Flag
pattern $mSA :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bSA :: Flag
SA = Flag 'S' 'A'

-- | The 'Flag' pattern used for the /Solomon Islands/ denoted with /SB/.
pattern SB :: Flag
pattern $mSB :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bSB :: Flag
SB = Flag 'S' 'B'

-- | The 'Flag' pattern used for /Seychelles/ denoted with /SC/.
pattern SC :: Flag
pattern $mSC :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bSC :: Flag
SC = Flag 'S' 'C'

-- | The 'Flag' pattern used for /Sudan/ denoted with /SD/.
pattern SD :: Flag
pattern $mSD :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bSD :: Flag
SD = Flag 'S' 'D'

-- | The 'Flag' pattern used for /Sweden/ denoted with /SE/.
pattern SE :: Flag
pattern $mSE :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bSE :: Flag
SE = Flag 'S' 'E'

-- | The 'Flag' pattern used for /Singapore/ denoted with /SG/.
pattern SG :: Flag
pattern $mSG :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bSG :: Flag
SG = Flag 'S' 'G'

-- | The 'Flag' pattern used for /St. Helena/ denoted with /SH/.
pattern SH :: Flag
pattern $mSH :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bSH :: Flag
SH = Flag 'S' 'H'

-- | The 'Flag' pattern used for /Slovenia/ denoted with /SI/.
pattern SI :: Flag
pattern $mSI :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bSI :: Flag
SI = Flag 'S' 'I'

-- | The 'Flag' pattern used for /Svalbard & Jan Mayen/ denoted with /SJ/.
pattern SJ :: Flag
pattern $mSJ :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bSJ :: Flag
SJ = Flag 'S' 'J'

-- | The 'Flag' pattern used for /Slovakia/ denoted with /SK/.
pattern SK :: Flag
pattern $mSK :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bSK :: Flag
SK = Flag 'S' 'K'

-- | The 'Flag' pattern used for /Sierra Leone/ denoted with /SL/.
pattern SL :: Flag
pattern $mSL :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bSL :: Flag
SL = Flag 'S' 'L'

-- | The 'Flag' pattern used for /San Marino/ denoted with /SM/.
pattern SM :: Flag
pattern $mSM :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bSM :: Flag
SM = Flag 'S' 'M'

-- | The 'Flag' pattern used for /Senegal/ denoted with /SN/.
pattern SN :: Flag
pattern $mSN :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bSN :: Flag
SN = Flag 'S' 'N'

-- | The 'Flag' pattern used for /Somalia/ denoted with /SO/.
pattern SO :: Flag
pattern $mSO :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bSO :: Flag
SO = Flag 'S' 'O'

-- | The 'Flag' pattern used for /Suriname/ denoted with /SR/.
pattern SR :: Flag
pattern $mSR :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bSR :: Flag
SR = Flag 'S' 'R'

-- | The 'Flag' pattern used for /South Sudan/ denoted with /SS/.
pattern SS :: Flag
pattern $mSS :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bSS :: Flag
SS = Flag 'S' 'S'

-- | The 'Flag' pattern used for /São Tomé & Príncipe/ denoted with /ST/.
pattern ST :: Flag
pattern $mST :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bST :: Flag
ST = Flag 'S' 'T'

-- | The 'Flag' pattern used for /El Salvador/ denoted with /SV/.
pattern SV :: Flag
pattern $mSV :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bSV :: Flag
SV = Flag 'S' 'V'

-- | The 'Flag' pattern used for /Sint Maarten/ denoted with /SX/.
pattern SX :: Flag
pattern $mSX :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bSX :: Flag
SX = Flag 'S' 'X'

-- | The 'Flag' pattern used for /Syria/ denoted with /SY/.
pattern SY :: Flag
pattern $mSY :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bSY :: Flag
SY = Flag 'S' 'Y'

-- | The 'Flag' pattern used for /Eswatini/ denoted with /SZ/.
pattern SZ :: Flag
pattern $mSZ :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bSZ :: Flag
SZ = Flag 'S' 'Z'

-- | The 'Flag' pattern used for /Tristan da Cunha/ denoted with /TA/.
pattern TA :: Flag
pattern $mTA :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bTA :: Flag
TA = Flag 'T' 'A'

-- | The 'Flag' pattern used for the /Turks & Caicos Islands/ denoted with /TC/.
pattern TC :: Flag
pattern $mTC :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bTC :: Flag
TC = Flag 'T' 'C'

-- | The 'Flag' pattern used for /Chad/ denoted with /TD/.
pattern TD :: Flag
pattern $mTD :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bTD :: Flag
TD = Flag 'T' 'D'

-- | The 'Flag' pattern used for the /French Southern Territories/ denoted with /TF/.
pattern TF :: Flag
pattern $mTF :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bTF :: Flag
TF = Flag 'T' 'F'

-- | The 'Flag' pattern used for /Togo/ denoted with /TG/.
pattern TG :: Flag
pattern $mTG :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bTG :: Flag
TG = Flag 'T' 'G'

-- | The 'Flag' pattern used for /Thailand/ denoted with /TH/.
pattern TH :: Flag
pattern $mTH :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bTH :: Flag
TH = Flag 'T' 'H'

-- | The 'Flag' pattern used for /Tajikistan/ denoted with /TJ/.
pattern TJ :: Flag
pattern $mTJ :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bTJ :: Flag
TJ = Flag 'T' 'J'

-- | The 'Flag' pattern used for /Tokelau/ denoted with /TK/.
pattern TK :: Flag
pattern $mTK :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bTK :: Flag
TK = Flag 'T' 'K'

-- | The 'Flag' pattern used for /Timor-Leste/ denoted with /TL/.
pattern TL :: Flag
pattern $mTL :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bTL :: Flag
TL = Flag 'T' 'L'

-- | The 'Flag' pattern used for /Turkmenistan/ denoted with /TM/.
pattern TM :: Flag
pattern $mTM :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bTM :: Flag
TM = Flag 'T' 'M'

-- | The 'Flag' pattern used for /Tunisia/ denoted with /TN/.
pattern TN :: Flag
pattern $mTN :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bTN :: Flag
TN = Flag 'T' 'N'

-- | The 'Flag' pattern used for /Tonga/ denoted with /TO/.
pattern TO :: Flag
pattern $mTO :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bTO :: Flag
TO = Flag 'T' 'O'

-- | The 'Flag' pattern used for /Turkey/ denoted with /TR/.
pattern TR :: Flag
pattern $mTR :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bTR :: Flag
TR = Flag 'T' 'R'

-- | The 'Flag' pattern used for /Trinidad & Tobago/ denoted with /TT/.
pattern TT :: Flag
pattern $mTT :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bTT :: Flag
TT = Flag 'T' 'T'

-- | The 'Flag' pattern used for /Tuvalu/ denoted with /TV/.
pattern TV :: Flag
pattern $mTV :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bTV :: Flag
TV = Flag 'T' 'V'

-- | The 'Flag' pattern used for /Taiwan/ denoted with /TW/.
pattern TW :: Flag
pattern $mTW :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bTW :: Flag
TW = Flag 'T' 'W'

-- | The 'Flag' pattern used for /Tanzania/ denoted with /TZ/.
pattern TZ :: Flag
pattern $mTZ :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bTZ :: Flag
TZ = Flag 'T' 'Z'

-- | The 'Flag' pattern used for /Ukraine/ denoted with /UA/.
pattern UA :: Flag
pattern $mUA :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bUA :: Flag
UA = Flag 'U' 'A'

-- | The 'Flag' pattern used for /Uganda/ denoted with /UG/.
pattern UG :: Flag
pattern $mUG :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bUG :: Flag
UG = Flag 'U' 'G'

-- | The 'Flag' pattern used for the /U.S. Outlying Islands/ denoted with /UM/.
pattern UM :: Flag
pattern $mUM :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bUM :: Flag
UM = Flag 'U' 'M'

-- | The 'Flag' pattern used for the /United Nations/ denoted with /UN/.
pattern UN :: Flag
pattern $mUN :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bUN :: Flag
UN = Flag 'U' 'N'

-- | The 'Flag' pattern used for the /United States/ denoted with /US/.
pattern US :: Flag
pattern $mUS :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bUS :: Flag
US = Flag 'U' 'S'

-- | The 'Flag' pattern used for /Uruguay/ denoted with /UY/.
pattern UY :: Flag
pattern $mUY :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bUY :: Flag
UY = Flag 'U' 'Y'

-- | The 'Flag' pattern used for /Uzbekistan/ denoted with /UZ/.
pattern UZ :: Flag
pattern $mUZ :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bUZ :: Flag
UZ = Flag 'U' 'Z'

-- | The 'Flag' pattern used for /Vatican City/ denoted with /VA/.
pattern VA :: Flag
pattern $mVA :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bVA :: Flag
VA = Flag 'V' 'A'

-- | The 'Flag' pattern used for /St. Vincent & Grenadines/ denoted with /VC/.
pattern VC :: Flag
pattern $mVC :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bVC :: Flag
VC = Flag 'V' 'C'

-- | The 'Flag' pattern used for /Venezuela/ denoted with /VE/.
pattern VE :: Flag
pattern $mVE :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bVE :: Flag
VE = Flag 'V' 'E'

-- | The 'Flag' pattern used for the /British Virgin Islands/ denoted with /VG/.
pattern VG :: Flag
pattern $mVG :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bVG :: Flag
VG = Flag 'V' 'G'

-- | The 'Flag' pattern used for the /U.S. Virgin Islands/ denoted with /VI/.
pattern VI :: Flag
pattern $mVI :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bVI :: Flag
VI = Flag 'V' 'I'

-- | The 'Flag' pattern used for /Vietnam/ denoted with /VN/.
pattern VN :: Flag
pattern $mVN :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bVN :: Flag
VN = Flag 'V' 'N'

-- | The 'Flag' pattern used for /Vanuatu/ denoted with /VU/.
pattern VU :: Flag
pattern $mVU :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bVU :: Flag
VU = Flag 'V' 'U'

-- | The 'Flag' pattern used for /Wallis & Futuna/ denoted with /WF/.
pattern WF :: Flag
pattern $mWF :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bWF :: Flag
WF = Flag 'W' 'F'

-- | The 'Flag' pattern used for /Samoa/ denoted with /WS/.
pattern WS :: Flag
pattern $mWS :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bWS :: Flag
WS = Flag 'W' 'S'

-- | The 'Flag' pattern used for /Kosovo/ denoted with /XK/.
pattern XK :: Flag
pattern $mXK :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bXK :: Flag
XK = Flag 'X' 'K'

-- | The 'Flag' pattern used for /Yemen/ denoted with /YE/.
pattern YE :: Flag
pattern $mYE :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bYE :: Flag
YE = Flag 'Y' 'E'

-- | The 'Flag' pattern used for /Mayotte/ denoted with /YT/.
pattern YT :: Flag
pattern $mYT :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bYT :: Flag
YT = Flag 'Y' 'T'

-- | The 'Flag' pattern used for /South Africa/ denoted with /ZA/.
pattern ZA :: Flag
pattern $mZA :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bZA :: Flag
ZA = Flag 'Z' 'A'

-- | The 'Flag' pattern used for /Zambia/ denoted with /ZM/.
pattern ZM :: Flag
pattern $mZM :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bZM :: Flag
ZM = Flag 'Z' 'M'

-- | The 'Flag' pattern used for /Zimbabwe/ denoted with /ZW/.
pattern ZW :: Flag
pattern $mZW :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
$bZW :: Flag
ZW = Flag 'Z' 'W'

pattern GBSubFlag :: Char -> Char -> Char -> SubFlag
pattern $mGBSubFlag :: forall {r}.
SubFlag -> (Char -> Char -> Char -> r) -> ((# #) -> r) -> r
$bGBSubFlag :: Char -> Char -> Char -> SubFlag
GBSubFlag a b c = SubFlag GB a b (Just c)

pattern USSubFlag :: Char -> Char -> SubFlag
pattern $mUSSubFlag :: forall {r}. SubFlag -> (Char -> Char -> r) -> ((# #) -> r) -> r
$bUSSubFlag :: Char -> Char -> SubFlag
USSubFlag a b = SubFlag US a b Nothing

-- | The 'SubFlag' pattern used for /England/ denoted with /GB-ENG/ or /ENG/.
pattern ENG :: SubFlag
pattern $mENG :: forall {r}. SubFlag -> ((# #) -> r) -> ((# #) -> r) -> r
$bENG :: SubFlag
ENG = GBSubFlag 'e' 'n' 'g'

-- | The 'SubFlag' pattern used for /Scotland/ denoted with /GB-SCT/ or /SCT/.
pattern SCT :: SubFlag
pattern $mSCT :: forall {r}. SubFlag -> ((# #) -> r) -> ((# #) -> r) -> r
$bSCT :: SubFlag
SCT = GBSubFlag 's' 'c' 't'

-- | The 'SubFlag' pattern used for /Wales/ denoted with /GB-WLS/ or /WLS/.
pattern WLS :: SubFlag
pattern $mWLS :: forall {r}. SubFlag -> ((# #) -> r) -> ((# #) -> r) -> r
$bWLS :: SubFlag
WLS = GBSubFlag 'w' 'l' 's'

-- | The 'SubFlag' pattern used for /Alabama/ denoted with /US-AL/ or /AL/
pattern USAL :: SubFlag
pattern $mUSAL :: forall {r}. SubFlag -> ((# #) -> r) -> ((# #) -> r) -> r
$bUSAL :: SubFlag
USAL = USSubFlag 'a' 'l'

-- | The 'SubFlag' pattern used for /Alaska/ denoted with /US-AK/ or /AK/
pattern USAK :: SubFlag
pattern $mUSAK :: forall {r}. SubFlag -> ((# #) -> r) -> ((# #) -> r) -> r
$bUSAK :: SubFlag
USAK = USSubFlag 'a' 'k'

-- | The 'SubFlag' pattern used for /American Samoa/ denoted with /US-AS/ or /AS/
pattern USAS :: SubFlag
pattern $mUSAS :: forall {r}. SubFlag -> ((# #) -> r) -> ((# #) -> r) -> r
$bUSAS :: SubFlag
USAS = USSubFlag 'a' 's'

-- | The 'SubFlag' pattern used for /Arizona/ denoted with /US-AZ/ or /AZ/
pattern USAZ :: SubFlag
pattern $mUSAZ :: forall {r}. SubFlag -> ((# #) -> r) -> ((# #) -> r) -> r
$bUSAZ :: SubFlag
USAZ = USSubFlag 'a' 'z'

-- | The 'SubFlag' pattern used for /Arkansas/ denoted with /US-AR/ or /AR/
pattern USAR :: SubFlag
pattern $mUSAR :: forall {r}. SubFlag -> ((# #) -> r) -> ((# #) -> r) -> r
$bUSAR :: SubFlag
USAR = USSubFlag 'a' 'r'

-- | The 'SubFlag' pattern used for /California/ denoted with /US-CA/ or /CA/
pattern USCA :: SubFlag
pattern $mUSCA :: forall {r}. SubFlag -> ((# #) -> r) -> ((# #) -> r) -> r
$bUSCA :: SubFlag
USCA = USSubFlag 'c' 'a'

-- | The 'SubFlag' pattern used for /Colorado/ denoted with /US-CO/ or /CO/
pattern USCO :: SubFlag
pattern $mUSCO :: forall {r}. SubFlag -> ((# #) -> r) -> ((# #) -> r) -> r
$bUSCO :: SubFlag
USCO = USSubFlag 'c' 'o'

-- | The 'SubFlag' pattern used for /Connecticut/ denoted with /US-CT/ or /CT/
pattern USCT :: SubFlag
pattern $mUSCT :: forall {r}. SubFlag -> ((# #) -> r) -> ((# #) -> r) -> r
$bUSCT :: SubFlag
USCT = USSubFlag 'c' 't'

-- | The 'SubFlag' pattern used for /Delaware/ denoted with /US-DE/ or /DE/
pattern USDE :: SubFlag
pattern $mUSDE :: forall {r}. SubFlag -> ((# #) -> r) -> ((# #) -> r) -> r
$bUSDE :: SubFlag
USDE = USSubFlag 'd' 'e'

-- | The 'SubFlag' pattern used for /Florida/ denoted with /US-FL/ or /FL/
pattern USFL :: SubFlag
pattern $mUSFL :: forall {r}. SubFlag -> ((# #) -> r) -> ((# #) -> r) -> r
$bUSFL :: SubFlag
USFL = USSubFlag 'f' 'l'

-- | The 'SubFlag' pattern used for /Georgia/ denoted with /US-GA/ or /GA/
pattern USGA :: SubFlag
pattern $mUSGA :: forall {r}. SubFlag -> ((# #) -> r) -> ((# #) -> r) -> r
$bUSGA :: SubFlag
USGA = USSubFlag 'g' 'a'

-- | The 'SubFlag' pattern used for /Guam/ denoted with /US-GU/ or /GU/
pattern USGU :: SubFlag
pattern $mUSGU :: forall {r}. SubFlag -> ((# #) -> r) -> ((# #) -> r) -> r
$bUSGU :: SubFlag
USGU = USSubFlag 'g' 'u'

-- | The 'SubFlag' pattern used for /Hawaii/ denoted with /US-HI/ or /HI/
pattern USHI :: SubFlag
pattern $mUSHI :: forall {r}. SubFlag -> ((# #) -> r) -> ((# #) -> r) -> r
$bUSHI :: SubFlag
USHI = USSubFlag 'h' 'i'

-- | The 'SubFlag' pattern used for /Idaho/ denoted with /US-ID/ or /ID/
pattern USID :: SubFlag
pattern $mUSID :: forall {r}. SubFlag -> ((# #) -> r) -> ((# #) -> r) -> r
$bUSID :: SubFlag
USID = USSubFlag 'i' 'd'

-- | The 'SubFlag' pattern used for /Illinois/ denoted with /US-IL/ or /IL/
pattern USIL :: SubFlag
pattern $mUSIL :: forall {r}. SubFlag -> ((# #) -> r) -> ((# #) -> r) -> r
$bUSIL :: SubFlag
USIL = USSubFlag 'i' 'l'

-- | The 'SubFlag' pattern used for /Indiana/ denoted with /US-IN/ or /IN/
pattern USIN :: SubFlag
pattern $mUSIN :: forall {r}. SubFlag -> ((# #) -> r) -> ((# #) -> r) -> r
$bUSIN :: SubFlag
USIN = USSubFlag 'i' 'n'

-- | The 'SubFlag' pattern used for /Iowa/ denoted with /US-IA/ or /IA/
pattern USIA :: SubFlag
pattern $mUSIA :: forall {r}. SubFlag -> ((# #) -> r) -> ((# #) -> r) -> r
$bUSIA :: SubFlag
USIA = USSubFlag 'i' 'a'

-- | The 'SubFlag' pattern used for /Kansas/ denoted with /US-KS/ or /KS/
pattern USKS :: SubFlag
pattern $mUSKS :: forall {r}. SubFlag -> ((# #) -> r) -> ((# #) -> r) -> r
$bUSKS :: SubFlag
USKS = USSubFlag 'k' 's'

-- | The 'SubFlag' pattern used for /Kentucky/ denoted with /US-KY/ or /KY/
pattern USKY :: SubFlag
pattern $mUSKY :: forall {r}. SubFlag -> ((# #) -> r) -> ((# #) -> r) -> r
$bUSKY :: SubFlag
USKY = USSubFlag 'k' 'y'

-- | The 'SubFlag' pattern used for /Louisiana/ denoted with /US-LA/ or /LA/
pattern USLA :: SubFlag
pattern $mUSLA :: forall {r}. SubFlag -> ((# #) -> r) -> ((# #) -> r) -> r
$bUSLA :: SubFlag
USLA = USSubFlag 'l' 'a'

-- | The 'SubFlag' pattern used for /Maine/ denoted with /US-ME/ or /ME/
pattern USME :: SubFlag
pattern $mUSME :: forall {r}. SubFlag -> ((# #) -> r) -> ((# #) -> r) -> r
$bUSME :: SubFlag
USME = USSubFlag 'm' 'e'

-- | The 'SubFlag' pattern used for /Maryland/ denoted with /US-MD/ or /MD/
pattern USMD :: SubFlag
pattern $mUSMD :: forall {r}. SubFlag -> ((# #) -> r) -> ((# #) -> r) -> r
$bUSMD :: SubFlag
USMD = USSubFlag 'm' 'd'

-- | The 'SubFlag' pattern used for /Massachusetts/ denoted with /US-MA/ or /MA/
pattern USMA :: SubFlag
pattern $mUSMA :: forall {r}. SubFlag -> ((# #) -> r) -> ((# #) -> r) -> r
$bUSMA :: SubFlag
USMA = USSubFlag 'm' 'a'

-- | The 'SubFlag' pattern used for /Michigan/ denoted with /US-MI/ or /MI/
pattern USMI :: SubFlag
pattern $mUSMI :: forall {r}. SubFlag -> ((# #) -> r) -> ((# #) -> r) -> r
$bUSMI :: SubFlag
USMI = USSubFlag 'm' 'i'

-- | The 'SubFlag' pattern used for /Minnesota/ denoted with /US-MN/ or /MN/
pattern USMN :: SubFlag
pattern $mUSMN :: forall {r}. SubFlag -> ((# #) -> r) -> ((# #) -> r) -> r
$bUSMN :: SubFlag
USMN = USSubFlag 'm' 'n'

-- | The 'SubFlag' pattern used for /Mississippi/ denoted with /US-MS/ or /MS/
pattern USMS :: SubFlag
pattern $mUSMS :: forall {r}. SubFlag -> ((# #) -> r) -> ((# #) -> r) -> r
$bUSMS :: SubFlag
USMS = USSubFlag 'm' 's'

-- | The 'SubFlag' pattern used for /Missouri/ denoted with /US-MO/ or /MO/
pattern USMO :: SubFlag
pattern $mUSMO :: forall {r}. SubFlag -> ((# #) -> r) -> ((# #) -> r) -> r
$bUSMO :: SubFlag
USMO = USSubFlag 'm' 'o'

-- | The 'SubFlag' pattern used for /Montana/ denoted with /US-MT/ or /MT/
pattern USMT :: SubFlag
pattern $mUSMT :: forall {r}. SubFlag -> ((# #) -> r) -> ((# #) -> r) -> r
$bUSMT :: SubFlag
USMT = USSubFlag 'm' 't'

-- | The 'SubFlag' pattern used for /Nebraska/ denoted with /US-NE/ or /NE/
pattern USNE :: SubFlag
pattern $mUSNE :: forall {r}. SubFlag -> ((# #) -> r) -> ((# #) -> r) -> r
$bUSNE :: SubFlag
USNE = USSubFlag 'n' 'e'

-- | The 'SubFlag' pattern used for /Nevada/ denoted with /US-NV/ or /NV/
pattern USNV :: SubFlag
pattern $mUSNV :: forall {r}. SubFlag -> ((# #) -> r) -> ((# #) -> r) -> r
$bUSNV :: SubFlag
USNV = USSubFlag 'n' 'v'

-- | The 'SubFlag' pattern used for /New Hampshire/ denoted with /US-NH/ or /NH/
pattern USNH :: SubFlag
pattern $mUSNH :: forall {r}. SubFlag -> ((# #) -> r) -> ((# #) -> r) -> r
$bUSNH :: SubFlag
USNH = USSubFlag 'n' 'h'

-- | The 'SubFlag' pattern used for /New Jersey/ denoted with /US-NJ/ or /NJ/
pattern USNJ :: SubFlag
pattern $mUSNJ :: forall {r}. SubFlag -> ((# #) -> r) -> ((# #) -> r) -> r
$bUSNJ :: SubFlag
USNJ = USSubFlag 'n' 'j'

-- | The 'SubFlag' pattern used for /New Mexico/ denoted with /US-NM/ or /NM/
pattern USNM :: SubFlag
pattern $mUSNM :: forall {r}. SubFlag -> ((# #) -> r) -> ((# #) -> r) -> r
$bUSNM :: SubFlag
USNM = USSubFlag 'n' 'm'

-- | The 'SubFlag' pattern used for /New York/ denoted with /US-NY/ or /NY/
pattern USNY :: SubFlag
pattern $mUSNY :: forall {r}. SubFlag -> ((# #) -> r) -> ((# #) -> r) -> r
$bUSNY :: SubFlag
USNY = USSubFlag 'n' 'y'

-- | The 'SubFlag' pattern used for /North Carolina/ denoted with /US-NC/ or /NC/
pattern USNC :: SubFlag
pattern $mUSNC :: forall {r}. SubFlag -> ((# #) -> r) -> ((# #) -> r) -> r
$bUSNC :: SubFlag
USNC = USSubFlag 'n' 'c'

-- | The 'SubFlag' pattern used for /North Dakota/ denoted with /US-ND/ or /ND/
pattern USND :: SubFlag
pattern $mUSND :: forall {r}. SubFlag -> ((# #) -> r) -> ((# #) -> r) -> r
$bUSND :: SubFlag
USND = USSubFlag 'n' 'd'

-- | The 'SubFlag' pattern used for /Northern Mariana Islands/ denoted with /US-MP/ or /MP/
pattern USMP :: SubFlag
pattern $mUSMP :: forall {r}. SubFlag -> ((# #) -> r) -> ((# #) -> r) -> r
$bUSMP :: SubFlag
USMP = USSubFlag 'm' 'p'

-- | The 'SubFlag' pattern used for /Ohio/ denoted with /US-OH/ or /OH/
pattern USOH :: SubFlag
pattern $mUSOH :: forall {r}. SubFlag -> ((# #) -> r) -> ((# #) -> r) -> r
$bUSOH :: SubFlag
USOH = USSubFlag 'o' 'h'

-- | The 'SubFlag' pattern used for /Oklahoma/ denoted with /US-OK/ or /OK/
pattern USOK :: SubFlag
pattern $mUSOK :: forall {r}. SubFlag -> ((# #) -> r) -> ((# #) -> r) -> r
$bUSOK :: SubFlag
USOK = USSubFlag 'o' 'k'

-- | The 'SubFlag' pattern used for /Oregon/ denoted with /US-OR/ or /OR/
pattern USOR :: SubFlag
pattern $mUSOR :: forall {r}. SubFlag -> ((# #) -> r) -> ((# #) -> r) -> r
$bUSOR :: SubFlag
USOR = USSubFlag 'o' 'r'

-- | The 'SubFlag' pattern used for /Pennsylvania/ denoted with /US-PA/ or /PA/
pattern USPA :: SubFlag
pattern $mUSPA :: forall {r}. SubFlag -> ((# #) -> r) -> ((# #) -> r) -> r
$bUSPA :: SubFlag
USPA = USSubFlag 'p' 'a'

-- | The 'SubFlag' pattern used for /Puerto Rico/ denoted with /US-PR/ or /PR/
pattern USPR :: SubFlag
pattern $mUSPR :: forall {r}. SubFlag -> ((# #) -> r) -> ((# #) -> r) -> r
$bUSPR :: SubFlag
USPR = USSubFlag 'p' 'r'

-- | The 'SubFlag' pattern used for /Rhode Island/ denoted with /US-RI/ or /RI/
pattern USRI :: SubFlag
pattern $mUSRI :: forall {r}. SubFlag -> ((# #) -> r) -> ((# #) -> r) -> r
$bUSRI :: SubFlag
USRI = USSubFlag 'r' 'i'

-- | The 'SubFlag' pattern used for /South Carolina/ denoted with /US-SC/ or /SC/
pattern USSC :: SubFlag
pattern $mUSSC :: forall {r}. SubFlag -> ((# #) -> r) -> ((# #) -> r) -> r
$bUSSC :: SubFlag
USSC = USSubFlag 's' 'c'

-- | The 'SubFlag' pattern used for /South Dakota/ denoted with /US-SD/ or /SD/
pattern USSD :: SubFlag
pattern $mUSSD :: forall {r}. SubFlag -> ((# #) -> r) -> ((# #) -> r) -> r
$bUSSD :: SubFlag
USSD = USSubFlag 's' 'd'

-- | The 'SubFlag' pattern used for /Tennessee/ denoted with /US-TN/ or /TN/
pattern USTN :: SubFlag
pattern $mUSTN :: forall {r}. SubFlag -> ((# #) -> r) -> ((# #) -> r) -> r
$bUSTN :: SubFlag
USTN = USSubFlag 't' 'n'

-- | The 'SubFlag' pattern used for /U.S. Outlying Islands/ denoted with /US-UM/ or /UM/
pattern USUM :: SubFlag
pattern $mUSUM :: forall {r}. SubFlag -> ((# #) -> r) -> ((# #) -> r) -> r
$bUSUM :: SubFlag
USUM = USSubFlag 'u' 'm'

-- | The 'SubFlag' pattern used for /U.S. Virgin Islands/ denoted with /US-VI/ or /VI/
pattern USVI :: SubFlag
pattern $mUSVI :: forall {r}. SubFlag -> ((# #) -> r) -> ((# #) -> r) -> r
$bUSVI :: SubFlag
USVI = USSubFlag 'v' 'i'

-- | The 'SubFlag' pattern used for /Utah/ denoted with /US-UT/ or /UT/
pattern USUT :: SubFlag
pattern $mUSUT :: forall {r}. SubFlag -> ((# #) -> r) -> ((# #) -> r) -> r
$bUSUT :: SubFlag
USUT = USSubFlag 'u' 't'

-- | The 'SubFlag' pattern used for /Vermont/ denoted with /US-VT/ or /VT/
pattern USVT :: SubFlag
pattern $mUSVT :: forall {r}. SubFlag -> ((# #) -> r) -> ((# #) -> r) -> r
$bUSVT :: SubFlag
USVT = USSubFlag 'v' 't'

-- | The 'SubFlag' pattern used for /Virginia/ denoted with /US-VA/ or /VA/
pattern USVA :: SubFlag
pattern $mUSVA :: forall {r}. SubFlag -> ((# #) -> r) -> ((# #) -> r) -> r
$bUSVA :: SubFlag
USVA = USSubFlag 'v' 'a'

-- | The 'SubFlag' pattern used for /Washington/ denoted with /US-WA/ or /WA/
pattern USWA :: SubFlag
pattern $mUSWA :: forall {r}. SubFlag -> ((# #) -> r) -> ((# #) -> r) -> r
$bUSWA :: SubFlag
USWA = USSubFlag 'w' 'a'

-- | The 'SubFlag' pattern used for /Washington DC/ denoted with /US-DC/ or /DC/
pattern USDC :: SubFlag
pattern $mUSDC :: forall {r}. SubFlag -> ((# #) -> r) -> ((# #) -> r) -> r
$bUSDC :: SubFlag
USDC = USSubFlag 'd' 'c'

-- | The 'SubFlag' pattern used for /West Virginia/ denoted with /US-WV/ or /WV/
pattern USWV :: SubFlag
pattern $mUSWV :: forall {r}. SubFlag -> ((# #) -> r) -> ((# #) -> r) -> r
$bUSWV :: SubFlag
USWV = USSubFlag 'w' 'v'

-- | The 'SubFlag' pattern used for /Wisconsin/ denoted with /US-WI/ or /WI/
pattern USWI :: SubFlag
pattern $mUSWI :: forall {r}. SubFlag -> ((# #) -> r) -> ((# #) -> r) -> r
$bUSWI :: SubFlag
USWI = USSubFlag 'w' 'i'

-- | The 'SubFlag' pattern used for /Wyoming/ denoted with /US-WY/ or /WY/
pattern USWY :: SubFlag
pattern $mUSWY :: forall {r}. SubFlag -> ((# #) -> r) -> ((# #) -> r) -> r
$bUSWY :: SubFlag
USWY = USSubFlag 'w' 'y'

instance Bounded SubFlag where
  minBound :: SubFlag
minBound = [SubFlag] -> SubFlag
forall a. HasCallStack => [a] -> a
head [SubFlag]
_subflags
  maxBound :: SubFlag
maxBound = [SubFlag] -> SubFlag
forall a. HasCallStack => [a] -> a
last [SubFlag]
_subflags

-- | Convert the given two 'Char'acters of the ISO3166-1 Alpha-2 standard to an
-- Emoji that renders the flag of the corresponding country or terroitory.
-- Deprecated regions, such as SU (Soviet Union) and YU (Yugoslavia) have no
-- flag. The European Union (EU), Antarctica (AQ) and United Nations (UN)
-- are included as marcoregion flags. This function does not check if the
-- two characters map to a valid flag token.
iso3166Alpha2ToFlag' ::
  -- | The first 'Char'acter of the ISO3166 Alpha-2 code.
  Char ->
  -- | The second 'Char'acter of the ISO3166 Alpha-2 code.
  Char ->
  -- | A 'Text' object that consists of two characters, where the two characters form a flag emoji, if the given flag exists.
  Text
iso3166Alpha2ToFlag' :: Char -> Char -> Text
iso3166Alpha2ToFlag' Char
ca Char
cb = String -> Text
pack ((Char -> Char) -> ShowS
forall a b. (a -> b) -> [a] -> [b]
map (Char -> Char
regionalIndicatorUppercase' (Char -> Char) -> (Char -> Char) -> Char -> Char
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Char -> Char
toUpper) [Char
ca, Char
cb])

-- | Convert the given two 'Char'acters of the ISO3166-1 Alpha-2 standard to an
-- Emoji that renders the flag of the corresponding country or terroitory
-- wrapped in a 'Just' data constructor. Deprecated regions, such as SU
-- (Soviet Union) and YU (Yugoslavia) have no flag. The European Union (EU),
-- Antarctica (AQ) and United Nations (UN) are included as marcoregion flags.
-- If the flag does not exists, 'Nothing' is returned.
iso3166Alpha2ToFlag ::
  -- | The first 'Char'acter of the ISO3166 Alpha-2 code.
  Char ->
  -- | The second 'Char'acter of the ISO3166 Alpha-2 code.
  Char ->
  -- | A 'Text' object that consists of two characters, where the two characters form a flag emoji wrapped in a 'Just', if the given flag exists; 'Nothing' otherwise.
  Maybe Text
iso3166Alpha2ToFlag :: Char -> Char -> Maybe Text
iso3166Alpha2ToFlag Char
ca Char
cb
  | Char -> Char -> Bool
validFlagEmoji Char
ca Char
cb = Text -> Maybe Text
forall a. a -> Maybe a
Just (Char -> Char -> Text
iso3166Alpha2ToFlag' Char
ca Char
cb)
  | Bool
otherwise = Maybe Text
forall a. Maybe a
Nothing

-- | Convert the given 'Text' object to its equivalent 'Flag' object wrapped in
-- a 'Just' data constructor if it exists; 'Nothing' otherwise.
fromFlag :: Text -> Maybe Flag
fromFlag :: Text -> Maybe Flag
fromFlag Text
t
  | [Char
a', Char
b'] <- Text -> String
unpack Text
t, Just Char
a <- Char -> Maybe Char
shft Char
a', Just Char
b <- Char -> Maybe Char
shft Char
b', Char -> Char -> Bool
_validFlagEmoji Char
a Char
b = Flag -> Maybe Flag
forall a. a -> Maybe a
Just (Char -> Char -> Flag
Flag Char
a Char
b)
  | Bool
otherwise = Maybe Flag
forall a. Maybe a
Nothing
  where
    shft :: Char -> Maybe Char
shft = Int -> Char -> Maybe Char
forall a. (Bounded a, Enum a) => Int -> Char -> Maybe a
mapToEnumSafe Int
_flagCharOffset

-- | Check if for the given two 'Char'acters, a flag emoji exists. The two
-- character combinations for which a flag exist are defined in the ISO3166-1
-- Alpha-2 standard where deprecated reagions, such as SU and YU have no flag,
-- and the European Union (EU), Antarctica (AQ), and the United Nations (UN)
-- have a flag. The characters can be upper case (@A-Z@) or lower case (@a-z@).
validFlagEmoji ::
  -- | The first 'Char'acter of the ISO3166 Alpha-2 code.
  Char ->
  -- | The second 'Char'acter of the ISO3166 Alpha-2 code.
  Char ->
  -- | 'True' if a flag emoji exists for the given characters; 'False' otherwise.
  Bool
validFlagEmoji :: Char -> Char -> Bool
validFlagEmoji = (Char -> Char -> Bool) -> (Char -> Char) -> Char -> Char -> Bool
forall b c a. (b -> b -> c) -> (a -> b) -> a -> a -> c
on Char -> Char -> Bool
_validFlagEmoji Char -> Char
toUpper

_validFlagEmoji :: Char -> Char -> Bool
_validFlagEmoji :: Char -> Char -> Bool
_validFlagEmoji Char
'A' Char
'C' = Bool
True
_validFlagEmoji Char
'A' Char
'D' = Bool
True
_validFlagEmoji Char
'A' Char
'E' = Bool
True
_validFlagEmoji Char
'A' Char
'F' = Bool
True
_validFlagEmoji Char
'A' Char
'G' = Bool
True
_validFlagEmoji Char
'A' Char
'I' = Bool
True
_validFlagEmoji Char
'A' Char
'L' = Bool
True
_validFlagEmoji Char
'A' Char
'M' = Bool
True
_validFlagEmoji Char
'A' Char
'O' = Bool
True
_validFlagEmoji Char
'A' Char
'Q' = Bool
True
_validFlagEmoji Char
'A' Char
'R' = Bool
True
_validFlagEmoji Char
'A' Char
'S' = Bool
True
_validFlagEmoji Char
'A' Char
'T' = Bool
True
_validFlagEmoji Char
'A' Char
'U' = Bool
True
_validFlagEmoji Char
'A' Char
'W' = Bool
True
_validFlagEmoji Char
'A' Char
'X' = Bool
True
_validFlagEmoji Char
'A' Char
'Z' = Bool
True
_validFlagEmoji Char
'B' Char
'A' = Bool
True
_validFlagEmoji Char
'B' Char
'B' = Bool
True
_validFlagEmoji Char
'B' Char
'D' = Bool
True
_validFlagEmoji Char
'B' Char
'E' = Bool
True
_validFlagEmoji Char
'B' Char
'F' = Bool
True
_validFlagEmoji Char
'B' Char
'G' = Bool
True
_validFlagEmoji Char
'B' Char
'H' = Bool
True
_validFlagEmoji Char
'B' Char
'I' = Bool
True
_validFlagEmoji Char
'B' Char
'J' = Bool
True
_validFlagEmoji Char
'B' Char
'L' = Bool
True
_validFlagEmoji Char
'B' Char
'M' = Bool
True
_validFlagEmoji Char
'B' Char
'N' = Bool
True
_validFlagEmoji Char
'B' Char
'O' = Bool
True
_validFlagEmoji Char
'B' Char
'Q' = Bool
True
_validFlagEmoji Char
'B' Char
'R' = Bool
True
_validFlagEmoji Char
'B' Char
'S' = Bool
True
_validFlagEmoji Char
'B' Char
'T' = Bool
True
_validFlagEmoji Char
'B' Char
'V' = Bool
True
_validFlagEmoji Char
'B' Char
'W' = Bool
True
_validFlagEmoji Char
'B' Char
'Y' = Bool
True
_validFlagEmoji Char
'B' Char
'Z' = Bool
True
_validFlagEmoji Char
'C' Char
'A' = Bool
True
_validFlagEmoji Char
'C' Char
'C' = Bool
True
_validFlagEmoji Char
'C' Char
'D' = Bool
True
_validFlagEmoji Char
'C' Char
'F' = Bool
True
_validFlagEmoji Char
'C' Char
'G' = Bool
True
_validFlagEmoji Char
'C' Char
'H' = Bool
True
_validFlagEmoji Char
'C' Char
'I' = Bool
True
_validFlagEmoji Char
'C' Char
'K' = Bool
True
_validFlagEmoji Char
'C' Char
'L' = Bool
True
_validFlagEmoji Char
'C' Char
'M' = Bool
True
_validFlagEmoji Char
'C' Char
'N' = Bool
True
_validFlagEmoji Char
'C' Char
'O' = Bool
True
_validFlagEmoji Char
'C' Char
'P' = Bool
True
_validFlagEmoji Char
'C' Char
'R' = Bool
True
_validFlagEmoji Char
'C' Char
'U' = Bool
True
_validFlagEmoji Char
'C' Char
'V' = Bool
True
_validFlagEmoji Char
'C' Char
'W' = Bool
True
_validFlagEmoji Char
'C' Char
'X' = Bool
True
_validFlagEmoji Char
'C' Char
'Y' = Bool
True
_validFlagEmoji Char
'C' Char
'Z' = Bool
True
_validFlagEmoji Char
'D' Char
'E' = Bool
True
_validFlagEmoji Char
'D' Char
'G' = Bool
True
_validFlagEmoji Char
'D' Char
'J' = Bool
True
_validFlagEmoji Char
'D' Char
'K' = Bool
True
_validFlagEmoji Char
'D' Char
'M' = Bool
True
_validFlagEmoji Char
'D' Char
'O' = Bool
True
_validFlagEmoji Char
'D' Char
'Z' = Bool
True
_validFlagEmoji Char
'E' Char
'A' = Bool
True
_validFlagEmoji Char
'E' Char
'C' = Bool
True
_validFlagEmoji Char
'E' Char
'E' = Bool
True
_validFlagEmoji Char
'E' Char
'G' = Bool
True
_validFlagEmoji Char
'E' Char
'H' = Bool
True
_validFlagEmoji Char
'E' Char
'R' = Bool
True
_validFlagEmoji Char
'E' Char
'S' = Bool
True
_validFlagEmoji Char
'E' Char
'T' = Bool
True
_validFlagEmoji Char
'E' Char
'U' = Bool
True
_validFlagEmoji Char
'F' Char
'I' = Bool
True
_validFlagEmoji Char
'F' Char
'J' = Bool
True
_validFlagEmoji Char
'F' Char
'K' = Bool
True
_validFlagEmoji Char
'F' Char
'M' = Bool
True
_validFlagEmoji Char
'F' Char
'O' = Bool
True
_validFlagEmoji Char
'F' Char
'R' = Bool
True
_validFlagEmoji Char
'G' Char
'A' = Bool
True
_validFlagEmoji Char
'G' Char
'B' = Bool
True
_validFlagEmoji Char
'G' Char
'D' = Bool
True
_validFlagEmoji Char
'G' Char
'E' = Bool
True
_validFlagEmoji Char
'G' Char
'F' = Bool
True
_validFlagEmoji Char
'G' Char
'G' = Bool
True
_validFlagEmoji Char
'G' Char
'H' = Bool
True
_validFlagEmoji Char
'G' Char
'I' = Bool
True
_validFlagEmoji Char
'G' Char
'L' = Bool
True
_validFlagEmoji Char
'G' Char
'M' = Bool
True
_validFlagEmoji Char
'G' Char
'N' = Bool
True
_validFlagEmoji Char
'G' Char
'P' = Bool
True
_validFlagEmoji Char
'G' Char
'Q' = Bool
True
_validFlagEmoji Char
'G' Char
'R' = Bool
True
_validFlagEmoji Char
'G' Char
'S' = Bool
True
_validFlagEmoji Char
'G' Char
'T' = Bool
True
_validFlagEmoji Char
'G' Char
'U' = Bool
True
_validFlagEmoji Char
'G' Char
'W' = Bool
True
_validFlagEmoji Char
'G' Char
'Y' = Bool
True
_validFlagEmoji Char
'H' Char
'K' = Bool
True
_validFlagEmoji Char
'H' Char
'M' = Bool
True
_validFlagEmoji Char
'H' Char
'N' = Bool
True
_validFlagEmoji Char
'H' Char
'R' = Bool
True
_validFlagEmoji Char
'H' Char
'T' = Bool
True
_validFlagEmoji Char
'H' Char
'U' = Bool
True
_validFlagEmoji Char
'I' Char
'C' = Bool
True
_validFlagEmoji Char
'I' Char
'D' = Bool
True
_validFlagEmoji Char
'I' Char
'E' = Bool
True
_validFlagEmoji Char
'I' Char
'L' = Bool
True
_validFlagEmoji Char
'I' Char
'M' = Bool
True
_validFlagEmoji Char
'I' Char
'N' = Bool
True
_validFlagEmoji Char
'I' Char
'O' = Bool
True
_validFlagEmoji Char
'I' Char
'Q' = Bool
True
_validFlagEmoji Char
'I' Char
'R' = Bool
True
_validFlagEmoji Char
'I' Char
'S' = Bool
True
_validFlagEmoji Char
'I' Char
'T' = Bool
True
_validFlagEmoji Char
'J' Char
'E' = Bool
True
_validFlagEmoji Char
'J' Char
'M' = Bool
True
_validFlagEmoji Char
'J' Char
'O' = Bool
True
_validFlagEmoji Char
'J' Char
'P' = Bool
True
_validFlagEmoji Char
'K' Char
'E' = Bool
True
_validFlagEmoji Char
'K' Char
'G' = Bool
True
_validFlagEmoji Char
'K' Char
'H' = Bool
True
_validFlagEmoji Char
'K' Char
'I' = Bool
True
_validFlagEmoji Char
'K' Char
'M' = Bool
True
_validFlagEmoji Char
'K' Char
'N' = Bool
True
_validFlagEmoji Char
'K' Char
'P' = Bool
True
_validFlagEmoji Char
'K' Char
'R' = Bool
True
_validFlagEmoji Char
'K' Char
'W' = Bool
True
_validFlagEmoji Char
'K' Char
'Y' = Bool
True
_validFlagEmoji Char
'K' Char
'Z' = Bool
True
_validFlagEmoji Char
'L' Char
'A' = Bool
True
_validFlagEmoji Char
'L' Char
'B' = Bool
True
_validFlagEmoji Char
'L' Char
'C' = Bool
True
_validFlagEmoji Char
'L' Char
'I' = Bool
True
_validFlagEmoji Char
'L' Char
'K' = Bool
True
_validFlagEmoji Char
'L' Char
'R' = Bool
True
_validFlagEmoji Char
'L' Char
'S' = Bool
True
_validFlagEmoji Char
'L' Char
'T' = Bool
True
_validFlagEmoji Char
'L' Char
'U' = Bool
True
_validFlagEmoji Char
'L' Char
'V' = Bool
True
_validFlagEmoji Char
'L' Char
'Y' = Bool
True
_validFlagEmoji Char
'M' Char
'A' = Bool
True
_validFlagEmoji Char
'M' Char
'C' = Bool
True
_validFlagEmoji Char
'M' Char
'D' = Bool
True
_validFlagEmoji Char
'M' Char
'E' = Bool
True
_validFlagEmoji Char
'M' Char
'F' = Bool
True
_validFlagEmoji Char
'M' Char
'G' = Bool
True
_validFlagEmoji Char
'M' Char
'H' = Bool
True
_validFlagEmoji Char
'M' Char
'K' = Bool
True
_validFlagEmoji Char
'M' Char
'L' = Bool
True
_validFlagEmoji Char
'M' Char
'M' = Bool
True
_validFlagEmoji Char
'M' Char
'N' = Bool
True
_validFlagEmoji Char
'M' Char
'O' = Bool
True
_validFlagEmoji Char
'M' Char
'P' = Bool
True
_validFlagEmoji Char
'M' Char
'Q' = Bool
True
_validFlagEmoji Char
'M' Char
'R' = Bool
True
_validFlagEmoji Char
'M' Char
'S' = Bool
True
_validFlagEmoji Char
'M' Char
'T' = Bool
True
_validFlagEmoji Char
'M' Char
'U' = Bool
True
_validFlagEmoji Char
'M' Char
'V' = Bool
True
_validFlagEmoji Char
'M' Char
'W' = Bool
True
_validFlagEmoji Char
'M' Char
'X' = Bool
True
_validFlagEmoji Char
'M' Char
'Y' = Bool
True
_validFlagEmoji Char
'M' Char
'Z' = Bool
True
_validFlagEmoji Char
'N' Char
'A' = Bool
True
_validFlagEmoji Char
'N' Char
'C' = Bool
True
_validFlagEmoji Char
'N' Char
'E' = Bool
True
_validFlagEmoji Char
'N' Char
'F' = Bool
True
_validFlagEmoji Char
'N' Char
'G' = Bool
True
_validFlagEmoji Char
'N' Char
'I' = Bool
True
_validFlagEmoji Char
'N' Char
'L' = Bool
True
_validFlagEmoji Char
'N' Char
'O' = Bool
True
_validFlagEmoji Char
'N' Char
'P' = Bool
True
_validFlagEmoji Char
'N' Char
'R' = Bool
True
_validFlagEmoji Char
'N' Char
'U' = Bool
True
_validFlagEmoji Char
'N' Char
'Z' = Bool
True
_validFlagEmoji Char
'O' Char
'M' = Bool
True
_validFlagEmoji Char
'P' Char
'A' = Bool
True
_validFlagEmoji Char
'P' Char
'E' = Bool
True
_validFlagEmoji Char
'P' Char
'F' = Bool
True
_validFlagEmoji Char
'P' Char
'G' = Bool
True
_validFlagEmoji Char
'P' Char
'H' = Bool
True
_validFlagEmoji Char
'P' Char
'K' = Bool
True
_validFlagEmoji Char
'P' Char
'L' = Bool
True
_validFlagEmoji Char
'P' Char
'M' = Bool
True
_validFlagEmoji Char
'P' Char
'N' = Bool
True
_validFlagEmoji Char
'P' Char
'R' = Bool
True
_validFlagEmoji Char
'P' Char
'S' = Bool
True
_validFlagEmoji Char
'P' Char
'T' = Bool
True
_validFlagEmoji Char
'P' Char
'W' = Bool
True
_validFlagEmoji Char
'P' Char
'Y' = Bool
True
_validFlagEmoji Char
'Q' Char
'A' = Bool
True
_validFlagEmoji Char
'R' Char
'E' = Bool
True
_validFlagEmoji Char
'R' Char
'O' = Bool
True
_validFlagEmoji Char
'R' Char
'S' = Bool
True
_validFlagEmoji Char
'R' Char
'U' = Bool
True
_validFlagEmoji Char
'R' Char
'W' = Bool
True
_validFlagEmoji Char
'S' Char
'A' = Bool
True
_validFlagEmoji Char
'S' Char
'B' = Bool
True
_validFlagEmoji Char
'S' Char
'C' = Bool
True
_validFlagEmoji Char
'S' Char
'D' = Bool
True
_validFlagEmoji Char
'S' Char
'E' = Bool
True
_validFlagEmoji Char
'S' Char
'G' = Bool
True
_validFlagEmoji Char
'S' Char
'H' = Bool
True
_validFlagEmoji Char
'S' Char
'I' = Bool
True
_validFlagEmoji Char
'S' Char
'J' = Bool
True
_validFlagEmoji Char
'S' Char
'K' = Bool
True
_validFlagEmoji Char
'S' Char
'L' = Bool
True
_validFlagEmoji Char
'S' Char
'M' = Bool
True
_validFlagEmoji Char
'S' Char
'N' = Bool
True
_validFlagEmoji Char
'S' Char
'O' = Bool
True
_validFlagEmoji Char
'S' Char
'R' = Bool
True
_validFlagEmoji Char
'S' Char
'S' = Bool
True
_validFlagEmoji Char
'S' Char
'T' = Bool
True
_validFlagEmoji Char
'S' Char
'V' = Bool
True
_validFlagEmoji Char
'S' Char
'X' = Bool
True
_validFlagEmoji Char
'S' Char
'Y' = Bool
True
_validFlagEmoji Char
'S' Char
'Z' = Bool
True
_validFlagEmoji Char
'T' Char
'A' = Bool
True
_validFlagEmoji Char
'T' Char
'C' = Bool
True
_validFlagEmoji Char
'T' Char
'D' = Bool
True
_validFlagEmoji Char
'T' Char
'F' = Bool
True
_validFlagEmoji Char
'T' Char
'G' = Bool
True
_validFlagEmoji Char
'T' Char
'H' = Bool
True
_validFlagEmoji Char
'T' Char
'J' = Bool
True
_validFlagEmoji Char
'T' Char
'K' = Bool
True
_validFlagEmoji Char
'T' Char
'L' = Bool
True
_validFlagEmoji Char
'T' Char
'M' = Bool
True
_validFlagEmoji Char
'T' Char
'N' = Bool
True
_validFlagEmoji Char
'T' Char
'O' = Bool
True
_validFlagEmoji Char
'T' Char
'R' = Bool
True
_validFlagEmoji Char
'T' Char
'T' = Bool
True
_validFlagEmoji Char
'T' Char
'V' = Bool
True
_validFlagEmoji Char
'T' Char
'W' = Bool
True
_validFlagEmoji Char
'T' Char
'Z' = Bool
True
_validFlagEmoji Char
'U' Char
'A' = Bool
True
_validFlagEmoji Char
'U' Char
'G' = Bool
True
_validFlagEmoji Char
'U' Char
'M' = Bool
True
_validFlagEmoji Char
'U' Char
'N' = Bool
True
_validFlagEmoji Char
'U' Char
'S' = Bool
True
_validFlagEmoji Char
'U' Char
'Y' = Bool
True
_validFlagEmoji Char
'U' Char
'Z' = Bool
True
_validFlagEmoji Char
'V' Char
'A' = Bool
True
_validFlagEmoji Char
'V' Char
'C' = Bool
True
_validFlagEmoji Char
'V' Char
'E' = Bool
True
_validFlagEmoji Char
'V' Char
'G' = Bool
True
_validFlagEmoji Char
'V' Char
'I' = Bool
True
_validFlagEmoji Char
'V' Char
'N' = Bool
True
_validFlagEmoji Char
'V' Char
'U' = Bool
True
_validFlagEmoji Char
'W' Char
'F' = Bool
True
_validFlagEmoji Char
'W' Char
'S' = Bool
True
_validFlagEmoji Char
'X' Char
'K' = Bool
True
_validFlagEmoji Char
'Y' Char
'E' = Bool
True
_validFlagEmoji Char
'Y' Char
'T' = Bool
True
_validFlagEmoji Char
'Z' Char
'A' = Bool
True
_validFlagEmoji Char
'Z' Char
'M' = Bool
True
_validFlagEmoji Char
'Z' Char
'W' = Bool
True
_validFlagEmoji Char
_ Char
_ = Bool
False

instance Arbitrary Flag where
  arbitrary :: Gen Flag
arbitrary = Gen Flag
forall a. (Bounded a, Enum a) => Gen a
arbitraryBoundedEnum

instance Arbitrary SubFlag where
  arbitrary :: Gen SubFlag
arbitrary = [SubFlag] -> Gen SubFlag
forall a. [a] -> Gen a
elements [SubFlag]
_subflags

instance Enum Flag where
  fromEnum :: Flag -> Int
fromEnum Flag
AC = Int
0
  fromEnum Flag
AD = Int
1
  fromEnum Flag
AE = Int
2
  fromEnum Flag
AF = Int
3
  fromEnum Flag
AG = Int
4
  fromEnum Flag
AI = Int
5
  fromEnum Flag
AL = Int
6
  fromEnum Flag
AM = Int
7
  fromEnum Flag
AO = Int
8
  fromEnum Flag
AQ = Int
9
  fromEnum Flag
AR = Int
10
  fromEnum Flag
AS = Int
11
  fromEnum Flag
AT = Int
12
  fromEnum Flag
AU = Int
13
  fromEnum Flag
AW = Int
14
  fromEnum Flag
AX = Int
15
  fromEnum Flag
AZ = Int
16
  fromEnum Flag
BA = Int
17
  fromEnum Flag
BB = Int
18
  fromEnum Flag
BD = Int
19
  fromEnum Flag
BE = Int
20
  fromEnum Flag
BF = Int
21
  fromEnum Flag
BG = Int
22
  fromEnum Flag
BH = Int
23
  fromEnum Flag
BI = Int
24
  fromEnum Flag
BJ = Int
25
  fromEnum Flag
BL = Int
26
  fromEnum Flag
BM = Int
27
  fromEnum Flag
BN = Int
28
  fromEnum Flag
BO = Int
29
  fromEnum Flag
BQ = Int
30
  fromEnum Flag
BR = Int
31
  fromEnum Flag
BS = Int
32
  fromEnum Flag
BT = Int
33
  fromEnum Flag
BV = Int
34
  fromEnum Flag
BW = Int
35
  fromEnum Flag
BY = Int
36
  fromEnum Flag
BZ = Int
37
  fromEnum Flag
CA = Int
38
  fromEnum Flag
CC = Int
39
  fromEnum Flag
CD = Int
40
  fromEnum Flag
CF = Int
41
  fromEnum Flag
CG = Int
42
  fromEnum Flag
CH = Int
43
  fromEnum Flag
CI = Int
44
  fromEnum Flag
CK = Int
45
  fromEnum Flag
CL = Int
46
  fromEnum Flag
CM = Int
47
  fromEnum Flag
CN = Int
48
  fromEnum Flag
CO = Int
49
  fromEnum Flag
CP = Int
50
  fromEnum Flag
CR = Int
51
  fromEnum Flag
CU = Int
52
  fromEnum Flag
CV = Int
53
  fromEnum Flag
CW = Int
54
  fromEnum Flag
CX = Int
55
  fromEnum Flag
CY = Int
56
  fromEnum Flag
CZ = Int
57
  fromEnum Flag
DE = Int
58
  fromEnum Flag
DG = Int
59
  fromEnum Flag
DJ = Int
60
  fromEnum Flag
DK = Int
61
  fromEnum Flag
DM = Int
62
  fromEnum Flag
DO = Int
63
  fromEnum Flag
DZ = Int
64
  fromEnum Flag
EA = Int
65
  fromEnum Flag
EC = Int
66
  fromEnum Flag
EE = Int
67
  fromEnum Flag
EG = Int
68
  fromEnum Flag
EH = Int
69
  fromEnum Flag
ER = Int
70
  fromEnum Flag
ES = Int
71
  fromEnum Flag
ET = Int
72
  fromEnum Flag
EU = Int
73
  fromEnum Flag
FI = Int
74
  fromEnum Flag
FJ = Int
75
  fromEnum Flag
FK = Int
76
  fromEnum Flag
FM = Int
77
  fromEnum Flag
FO = Int
78
  fromEnum Flag
FR = Int
79
  fromEnum Flag
GA = Int
80
  fromEnum Flag
GB = Int
81
  fromEnum Flag
GD = Int
82
  fromEnum Flag
GE = Int
83
  fromEnum Flag
GF = Int
84
  fromEnum Flag
GG = Int
85
  fromEnum Flag
GH = Int
86
  fromEnum Flag
GI = Int
87
  fromEnum Flag
GL = Int
88
  fromEnum Flag
GM = Int
89
  fromEnum Flag
GN = Int
90
  fromEnum Flag
GP = Int
91
  fromEnum Flag
GQ = Int
92
  fromEnum Flag
GR = Int
93
  fromEnum Flag
GS = Int
94
  fromEnum Flag
GT = Int
95
  fromEnum Flag
GU = Int
96
  fromEnum Flag
GW = Int
97
  fromEnum Flag
GY = Int
98
  fromEnum Flag
HK = Int
99
  fromEnum Flag
HM = Int
100
  fromEnum Flag
HN = Int
101
  fromEnum Flag
HR = Int
102
  fromEnum Flag
HT = Int
103
  fromEnum Flag
HU = Int
104
  fromEnum Flag
IC = Int
105
  fromEnum Flag
ID = Int
106
  fromEnum Flag
IE = Int
107
  fromEnum Flag
IL = Int
108
  fromEnum Flag
IM = Int
109
  fromEnum Flag
IN = Int
110
  fromEnum Flag
IO = Int
111
  fromEnum Flag
IQ = Int
112
  fromEnum Flag
IR = Int
113
  fromEnum Flag
IS = Int
114
  fromEnum Flag
IT = Int
115
  fromEnum Flag
JE = Int
116
  fromEnum Flag
JM = Int
117
  fromEnum Flag
JO = Int
118
  fromEnum Flag
JP = Int
119
  fromEnum Flag
KE = Int
120
  fromEnum Flag
KG = Int
121
  fromEnum Flag
KH = Int
122
  fromEnum Flag
KI = Int
123
  fromEnum Flag
KM = Int
124
  fromEnum Flag
KN = Int
125
  fromEnum Flag
KP = Int
126
  fromEnum Flag
KR = Int
127
  fromEnum Flag
KW = Int
128
  fromEnum Flag
KY = Int
129
  fromEnum Flag
KZ = Int
130
  fromEnum Flag
LA = Int
131
  fromEnum Flag
LB = Int
132
  fromEnum Flag
LC = Int
133
  fromEnum Flag
LI = Int
134
  fromEnum Flag
LK = Int
135
  fromEnum Flag
LR = Int
136
  fromEnum Flag
LS = Int
137
  fromEnum Flag
LT = Int
138
  fromEnum Flag
LU = Int
139
  fromEnum Flag
LV = Int
140
  fromEnum Flag
LY = Int
141
  fromEnum Flag
MA = Int
142
  fromEnum Flag
MC = Int
143
  fromEnum Flag
MD = Int
144
  fromEnum Flag
ME = Int
145
  fromEnum Flag
MF = Int
146
  fromEnum Flag
MG = Int
147
  fromEnum Flag
MH = Int
148
  fromEnum Flag
MK = Int
149
  fromEnum Flag
ML = Int
150
  fromEnum Flag
MM = Int
151
  fromEnum Flag
MN = Int
152
  fromEnum Flag
MO = Int
153
  fromEnum Flag
MP = Int
154
  fromEnum Flag
MQ = Int
155
  fromEnum Flag
MR = Int
156
  fromEnum Flag
MS = Int
157
  fromEnum Flag
MT = Int
158
  fromEnum Flag
MU = Int
159
  fromEnum Flag
MV = Int
160
  fromEnum Flag
MW = Int
161
  fromEnum Flag
MX = Int
162
  fromEnum Flag
MY = Int
163
  fromEnum Flag
MZ = Int
164
  fromEnum Flag
NA = Int
165
  fromEnum Flag
NC = Int
166
  fromEnum Flag
NE = Int
167
  fromEnum Flag
NF = Int
168
  fromEnum Flag
NG = Int
169
  fromEnum Flag
NI = Int
170
  fromEnum Flag
NL = Int
171
  fromEnum Flag
NO = Int
172
  fromEnum Flag
NP = Int
173
  fromEnum Flag
NR = Int
174
  fromEnum Flag
NU = Int
175
  fromEnum Flag
NZ = Int
176
  fromEnum Flag
OM = Int
177
  fromEnum Flag
PA = Int
178
  fromEnum Flag
PE = Int
179
  fromEnum Flag
PF = Int
180
  fromEnum Flag
PG = Int
181
  fromEnum Flag
PH = Int
182
  fromEnum Flag
PK = Int
183
  fromEnum Flag
PL = Int
184
  fromEnum Flag
PM = Int
185
  fromEnum Flag
PN = Int
186
  fromEnum Flag
PR = Int
187
  fromEnum Flag
PS = Int
188
  fromEnum Flag
PT = Int
189
  fromEnum Flag
PW = Int
190
  fromEnum Flag
PY = Int
191
  fromEnum Flag
QA = Int
192
  fromEnum Flag
RE = Int
193
  fromEnum Flag
RO = Int
194
  fromEnum Flag
RS = Int
195
  fromEnum Flag
RU = Int
196
  fromEnum Flag
RW = Int
197
  fromEnum Flag
SA = Int
198
  fromEnum Flag
SB = Int
199
  fromEnum Flag
SC = Int
200
  fromEnum Flag
SD = Int
201
  fromEnum Flag
SE = Int
202
  fromEnum Flag
SG = Int
203
  fromEnum Flag
SH = Int
204
  fromEnum Flag
SI = Int
205
  fromEnum Flag
SJ = Int
206
  fromEnum Flag
SK = Int
207
  fromEnum Flag
SL = Int
208
  fromEnum Flag
SM = Int
209
  fromEnum Flag
SN = Int
210
  fromEnum Flag
SO = Int
211
  fromEnum Flag
SR = Int
212
  fromEnum Flag
SS = Int
213
  fromEnum Flag
ST = Int
214
  fromEnum Flag
SV = Int
215
  fromEnum Flag
SX = Int
216
  fromEnum Flag
SY = Int
217
  fromEnum Flag
SZ = Int
218
  fromEnum Flag
TA = Int
219
  fromEnum Flag
TC = Int
220
  fromEnum Flag
TD = Int
221
  fromEnum Flag
TF = Int
222
  fromEnum Flag
TG = Int
223
  fromEnum Flag
TH = Int
224
  fromEnum Flag
TJ = Int
225
  fromEnum Flag
TK = Int
226
  fromEnum Flag
TL = Int
227
  fromEnum Flag
TM = Int
228
  fromEnum Flag
TN = Int
229
  fromEnum Flag
TO = Int
230
  fromEnum Flag
TR = Int
231
  fromEnum Flag
TT = Int
232
  fromEnum Flag
TV = Int
233
  fromEnum Flag
TW = Int
234
  fromEnum Flag
TZ = Int
235
  fromEnum Flag
UA = Int
236
  fromEnum Flag
UG = Int
237
  fromEnum Flag
UM = Int
238
  fromEnum Flag
UN = Int
239
  fromEnum Flag
US = Int
240
  fromEnum Flag
UY = Int
241
  fromEnum Flag
UZ = Int
242
  fromEnum Flag
VA = Int
243
  fromEnum Flag
VC = Int
244
  fromEnum Flag
VE = Int
245
  fromEnum Flag
VG = Int
246
  fromEnum Flag
VI = Int
247
  fromEnum Flag
VN = Int
248
  fromEnum Flag
VU = Int
249
  fromEnum Flag
WF = Int
250
  fromEnum Flag
WS = Int
251
  fromEnum Flag
XK = Int
252
  fromEnum Flag
YE = Int
253
  fromEnum Flag
YT = Int
254
  fromEnum Flag
ZA = Int
255
  fromEnum Flag
ZM = Int
256
  fromEnum Flag
ZW = Int
257
  fromEnum Flag
f = String -> Flag -> Int
forall a b. Show a => String -> a -> b
fromEnumError String
"Flag" Flag
f
  toEnum :: Int -> Flag
toEnum Int
0 = Flag
AC
  toEnum Int
1 = Flag
AD
  toEnum Int
2 = Flag
AE
  toEnum Int
3 = Flag
AF
  toEnum Int
4 = Flag
AG
  toEnum Int
5 = Flag
AI
  toEnum Int
6 = Flag
AL
  toEnum Int
7 = Flag
AM
  toEnum Int
8 = Flag
AO
  toEnum Int
9 = Flag
AQ
  toEnum Int
10 = Flag
AR
  toEnum Int
11 = Flag
AS
  toEnum Int
12 = Flag
AT
  toEnum Int
13 = Flag
AU
  toEnum Int
14 = Flag
AW
  toEnum Int
15 = Flag
AX
  toEnum Int
16 = Flag
AZ
  toEnum Int
17 = Flag
BA
  toEnum Int
18 = Flag
BB
  toEnum Int
19 = Flag
BD
  toEnum Int
20 = Flag
BE
  toEnum Int
21 = Flag
BF
  toEnum Int
22 = Flag
BG
  toEnum Int
23 = Flag
BH
  toEnum Int
24 = Flag
BI
  toEnum Int
25 = Flag
BJ
  toEnum Int
26 = Flag
BL
  toEnum Int
27 = Flag
BM
  toEnum Int
28 = Flag
BN
  toEnum Int
29 = Flag
BO
  toEnum Int
30 = Flag
BQ
  toEnum Int
31 = Flag
BR
  toEnum Int
32 = Flag
BS
  toEnum Int
33 = Flag
BT
  toEnum Int
34 = Flag
BV
  toEnum Int
35 = Flag
BW
  toEnum Int
36 = Flag
BY
  toEnum Int
37 = Flag
BZ
  toEnum Int
38 = Flag
CA
  toEnum Int
39 = Flag
CC
  toEnum Int
40 = Flag
CD
  toEnum Int
41 = Flag
CF
  toEnum Int
42 = Flag
CG
  toEnum Int
43 = Flag
CH
  toEnum Int
44 = Flag
CI
  toEnum Int
45 = Flag
CK
  toEnum Int
46 = Flag
CL
  toEnum Int
47 = Flag
CM
  toEnum Int
48 = Flag
CN
  toEnum Int
49 = Flag
CO
  toEnum Int
50 = Flag
CP
  toEnum Int
51 = Flag
CR
  toEnum Int
52 = Flag
CU
  toEnum Int
53 = Flag
CV
  toEnum Int
54 = Flag
CW
  toEnum Int
55 = Flag
CX
  toEnum Int
56 = Flag
CY
  toEnum Int
57 = Flag
CZ
  toEnum Int
58 = Flag
DE
  toEnum Int
59 = Flag
DG
  toEnum Int
60 = Flag
DJ
  toEnum Int
61 = Flag
DK
  toEnum Int
62 = Flag
DM
  toEnum Int
63 = Flag
DO
  toEnum Int
64 = Flag
DZ
  toEnum Int
65 = Flag
EA
  toEnum Int
66 = Flag
EC
  toEnum Int
67 = Flag
EE
  toEnum Int
68 = Flag
EG
  toEnum Int
69 = Flag
EH
  toEnum Int
70 = Flag
ER
  toEnum Int
71 = Flag
ES
  toEnum Int
72 = Flag
ET
  toEnum Int
73 = Flag
EU
  toEnum Int
74 = Flag
FI
  toEnum Int
75 = Flag
FJ
  toEnum Int
76 = Flag
FK
  toEnum Int
77 = Flag
FM
  toEnum Int
78 = Flag
FO
  toEnum Int
79 = Flag
FR
  toEnum Int
80 = Flag
GA
  toEnum Int
81 = Flag
GB
  toEnum Int
82 = Flag
GD
  toEnum Int
83 = Flag
GE
  toEnum Int
84 = Flag
GF
  toEnum Int
85 = Flag
GG
  toEnum Int
86 = Flag
GH
  toEnum Int
87 = Flag
GI
  toEnum Int
88 = Flag
GL
  toEnum Int
89 = Flag
GM
  toEnum Int
90 = Flag
GN
  toEnum Int
91 = Flag
GP
  toEnum Int
92 = Flag
GQ
  toEnum Int
93 = Flag
GR
  toEnum Int
94 = Flag
GS
  toEnum Int
95 = Flag
GT
  toEnum Int
96 = Flag
GU
  toEnum Int
97 = Flag
GW
  toEnum Int
98 = Flag
GY
  toEnum Int
99 = Flag
HK
  toEnum Int
100 = Flag
HM
  toEnum Int
101 = Flag
HN
  toEnum Int
102 = Flag
HR
  toEnum Int
103 = Flag
HT
  toEnum Int
104 = Flag
HU
  toEnum Int
105 = Flag
IC
  toEnum Int
106 = Flag
ID
  toEnum Int
107 = Flag
IE
  toEnum Int
108 = Flag
IL
  toEnum Int
109 = Flag
IM
  toEnum Int
110 = Flag
IN
  toEnum Int
111 = Flag
IO
  toEnum Int
112 = Flag
IQ
  toEnum Int
113 = Flag
IR
  toEnum Int
114 = Flag
IS
  toEnum Int
115 = Flag
IT
  toEnum Int
116 = Flag
JE
  toEnum Int
117 = Flag
JM
  toEnum Int
118 = Flag
JO
  toEnum Int
119 = Flag
JP
  toEnum Int
120 = Flag
KE
  toEnum Int
121 = Flag
KG
  toEnum Int
122 = Flag
KH
  toEnum Int
123 = Flag
KI
  toEnum Int
124 = Flag
KM
  toEnum Int
125 = Flag
KN
  toEnum Int
126 = Flag
KP
  toEnum Int
127 = Flag
KR
  toEnum Int
128 = Flag
KW
  toEnum Int
129 = Flag
KY
  toEnum Int
130 = Flag
KZ
  toEnum Int
131 = Flag
LA
  toEnum Int
132 = Flag
LB
  toEnum Int
133 = Flag
LC
  toEnum Int
134 = Flag
LI
  toEnum Int
135 = Flag
LK
  toEnum Int
136 = Flag
LR
  toEnum Int
137 = Flag
LS
  toEnum Int
138 = Flag
LT
  toEnum Int
139 = Flag
LU
  toEnum Int
140 = Flag
LV
  toEnum Int
141 = Flag
LY
  toEnum Int
142 = Flag
MA
  toEnum Int
143 = Flag
MC
  toEnum Int
144 = Flag
MD
  toEnum Int
145 = Flag
ME
  toEnum Int
146 = Flag
MF
  toEnum Int
147 = Flag
MG
  toEnum Int
148 = Flag
MH
  toEnum Int
149 = Flag
MK
  toEnum Int
150 = Flag
ML
  toEnum Int
151 = Flag
MM
  toEnum Int
152 = Flag
MN
  toEnum Int
153 = Flag
MO
  toEnum Int
154 = Flag
MP
  toEnum Int
155 = Flag
MQ
  toEnum Int
156 = Flag
MR
  toEnum Int
157 = Flag
MS
  toEnum Int
158 = Flag
MT
  toEnum Int
159 = Flag
MU
  toEnum Int
160 = Flag
MV
  toEnum Int
161 = Flag
MW
  toEnum Int
162 = Flag
MX
  toEnum Int
163 = Flag
MY
  toEnum Int
164 = Flag
MZ
  toEnum Int
165 = Flag
NA
  toEnum Int
166 = Flag
NC
  toEnum Int
167 = Flag
NE
  toEnum Int
168 = Flag
NF
  toEnum Int
169 = Flag
NG
  toEnum Int
170 = Flag
NI
  toEnum Int
171 = Flag
NL
  toEnum Int
172 = Flag
NO
  toEnum Int
173 = Flag
NP
  toEnum Int
174 = Flag
NR
  toEnum Int
175 = Flag
NU
  toEnum Int
176 = Flag
NZ
  toEnum Int
177 = Flag
OM
  toEnum Int
178 = Flag
PA
  toEnum Int
179 = Flag
PE
  toEnum Int
180 = Flag
PF
  toEnum Int
181 = Flag
PG
  toEnum Int
182 = Flag
PH
  toEnum Int
183 = Flag
PK
  toEnum Int
184 = Flag
PL
  toEnum Int
185 = Flag
PM
  toEnum Int
186 = Flag
PN
  toEnum Int
187 = Flag
PR
  toEnum Int
188 = Flag
PS
  toEnum Int
189 = Flag
PT
  toEnum Int
190 = Flag
PW
  toEnum Int
191 = Flag
PY
  toEnum Int
192 = Flag
QA
  toEnum Int
193 = Flag
RE
  toEnum Int
194 = Flag
RO
  toEnum Int
195 = Flag
RS
  toEnum Int
196 = Flag
RU
  toEnum Int
197 = Flag
RW
  toEnum Int
198 = Flag
SA
  toEnum Int
199 = Flag
SB
  toEnum Int
200 = Flag
SC
  toEnum Int
201 = Flag
SD
  toEnum Int
202 = Flag
SE
  toEnum Int
203 = Flag
SG
  toEnum Int
204 = Flag
SH
  toEnum Int
205 = Flag
SI
  toEnum Int
206 = Flag
SJ
  toEnum Int
207 = Flag
SK
  toEnum Int
208 = Flag
SL
  toEnum Int
209 = Flag
SM
  toEnum Int
210 = Flag
SN
  toEnum Int
211 = Flag
SO
  toEnum Int
212 = Flag
SR
  toEnum Int
213 = Flag
SS
  toEnum Int
214 = Flag
ST
  toEnum Int
215 = Flag
SV
  toEnum Int
216 = Flag
SX
  toEnum Int
217 = Flag
SY
  toEnum Int
218 = Flag
SZ
  toEnum Int
219 = Flag
TA
  toEnum Int
220 = Flag
TC
  toEnum Int
221 = Flag
TD
  toEnum Int
222 = Flag
TF
  toEnum Int
223 = Flag
TG
  toEnum Int
224 = Flag
TH
  toEnum Int
225 = Flag
TJ
  toEnum Int
226 = Flag
TK
  toEnum Int
227 = Flag
TL
  toEnum Int
228 = Flag
TM
  toEnum Int
229 = Flag
TN
  toEnum Int
230 = Flag
TO
  toEnum Int
231 = Flag
TR
  toEnum Int
232 = Flag
TT
  toEnum Int
233 = Flag
TV
  toEnum Int
234 = Flag
TW
  toEnum Int
235 = Flag
TZ
  toEnum Int
236 = Flag
UA
  toEnum Int
237 = Flag
UG
  toEnum Int
238 = Flag
UM
  toEnum Int
239 = Flag
UN
  toEnum Int
240 = Flag
US
  toEnum Int
241 = Flag
UY
  toEnum Int
242 = Flag
UZ
  toEnum Int
243 = Flag
VA
  toEnum Int
244 = Flag
VC
  toEnum Int
245 = Flag
VE
  toEnum Int
246 = Flag
VG
  toEnum Int
247 = Flag
VI
  toEnum Int
248 = Flag
VN
  toEnum Int
249 = Flag
VU
  toEnum Int
250 = Flag
WF
  toEnum Int
251 = Flag
WS
  toEnum Int
252 = Flag
XK
  toEnum Int
253 = Flag
YE
  toEnum Int
254 = Flag
YT
  toEnum Int
255 = Flag
ZA
  toEnum Int
256 = Flag
ZM
  toEnum Int
257 = Flag
ZW
  toEnum Int
i = String -> Int -> (Flag, Flag) -> Flag
forall a b. Show a => String -> Int -> (a, a) -> b
toEnumError String
"Flag" Int
i (Flag
forall a. Bounded a => a
minBound :: Flag, Flag
forall a. Bounded a => a
maxBound)
  enumFrom :: Flag -> [Flag]
enumFrom = (Flag -> Flag -> [Flag]
forall a. Enum a => a -> a -> [a]
`enumFromTo` Flag
forall a. Bounded a => a
maxBound)
  enumFromThen :: Flag -> Flag -> [Flag]
enumFromThen Flag
x Flag
y = Flag -> Flag -> Flag -> [Flag]
forall a. Enum a => a -> a -> a -> [a]
enumFromThenTo Flag
x Flag
y Flag
forall a. Bounded a => a
maxBound

_subflags :: [SubFlag]
_subflags :: [SubFlag]
_subflags = [SubFlag
ENG, SubFlag
SCT, SubFlag
WLS, SubFlag
USAL, SubFlag
USAK, SubFlag
USAS, SubFlag
USAZ, SubFlag
USAR, SubFlag
USCA, SubFlag
USCO, SubFlag
USCT, SubFlag
USDE, SubFlag
USFL, SubFlag
USGA, SubFlag
USGU, SubFlag
USHI, SubFlag
USID, SubFlag
USIL, SubFlag
USIN, SubFlag
USIA, SubFlag
USKS, SubFlag
USKY, SubFlag
USLA, SubFlag
USME, SubFlag
USMD, SubFlag
USMA, SubFlag
USMI, SubFlag
USMN, SubFlag
USMS, SubFlag
USMO, SubFlag
USMT, SubFlag
USNE, SubFlag
USNV, SubFlag
USNH, SubFlag
USNJ, SubFlag
USNM, SubFlag
USNY, SubFlag
USNC, SubFlag
USND, SubFlag
USMP, SubFlag
USOH, SubFlag
USOK, SubFlag
USOR, SubFlag
USPA, SubFlag
USPR, SubFlag
USRI, SubFlag
USSC, SubFlag
USSD, SubFlag
USTN, SubFlag
USUM, SubFlag
USVI, SubFlag
USUT, SubFlag
USVT, SubFlag
USVA, SubFlag
USWA, SubFlag
USDC, SubFlag
USWV, SubFlag
USWI, SubFlag
USWY]

(?!) :: Int -> [a] -> Maybe a
?! :: forall a. Int -> [a] -> Maybe a
(?!) Int
n
  | Int
n Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
< Int
0 = Maybe a -> [a] -> Maybe a
forall a b. a -> b -> a
const Maybe a
forall a. Maybe a
Nothing
  | Bool
otherwise = Int -> [a] -> Maybe a
forall {t} {a}. (Eq t, Num t) => t -> [a] -> Maybe a
go Int
n
  where
    go :: t -> [a] -> Maybe a
go t
0 (a
x : [a]
_) = a -> Maybe a
forall a. a -> Maybe a
Just a
x
    go t
i (a
_ : [a]
xs) = t -> [a] -> Maybe a
go (t
i t -> t -> t
forall a. Num a => a -> a -> a
- t
1) [a]
xs
    go t
_ [] = Maybe a
forall a. Maybe a
Nothing

instance Enum SubFlag where
  fromEnum :: SubFlag -> Int
fromEnum SubFlag
s = Int -> Maybe Int -> Int
forall a. a -> Maybe a -> a
fromMaybe (String -> SubFlag -> Int
forall a b. Show a => String -> a -> b
fromEnumError String
"SubFlag" SubFlag
s) (SubFlag -> [SubFlag] -> Maybe Int
forall a. Eq a => a -> [a] -> Maybe Int
elemIndex SubFlag
s [SubFlag]
_subflags)
  toEnum :: Int -> SubFlag
toEnum Int
i = SubFlag -> Maybe SubFlag -> SubFlag
forall a. a -> Maybe a -> a
fromMaybe (String -> Int -> (SubFlag, SubFlag) -> SubFlag
forall a b. Show a => String -> Int -> (a, a) -> b
toEnumError String
"SubFlag" Int
i (SubFlag
forall a. Bounded a => a
minBound :: SubFlag, SubFlag
forall a. Bounded a => a
maxBound)) (Int
i Int -> [SubFlag] -> Maybe SubFlag
forall a. Int -> [a] -> Maybe a
?! [SubFlag]
_subflags)
  enumFrom :: SubFlag -> [SubFlag]
enumFrom = (SubFlag -> SubFlag -> [SubFlag]
forall a. Enum a => a -> a -> [a]
`enumFromTo` SubFlag
forall a. Bounded a => a
maxBound)
  enumFromThen :: SubFlag -> SubFlag -> [SubFlag]
enumFromThen SubFlag
x SubFlag
y = SubFlag -> SubFlag -> SubFlag -> [SubFlag]
forall a. Enum a => a -> a -> a -> [a]
enumFromThenTo SubFlag
x SubFlag
y SubFlag
forall a. Bounded a => a
maxBound

instance UnicodeText Flag where
  toUnicodeText :: Flag -> Text
toUnicodeText (Flag Char
ca Char
cb) = Char -> Char -> Text
iso3166Alpha2ToFlag' Char
ca Char
cb
  fromUnicodeText :: Text -> Maybe Flag
fromUnicodeText = Text -> Maybe Flag
fromFlag
  isInTextRange :: Text -> Bool
isInTextRange Text
c
    | [Char
ca, Char
cb] <- Text -> String
unpack Text
c, Just Char
a <- Char -> Maybe Char
shft Char
ca, Just Char
b <- Char -> Maybe Char
shft Char
cb = Char -> Char -> Bool
_validFlagEmoji Char
a Char
b
    | Bool
otherwise = Bool
False
    where
      shft :: Char -> Maybe Char
shft = Int -> Char -> Maybe Char
forall a. (Bounded a, Enum a) => Int -> Char -> Maybe a
mapToEnumSafe Int
_flagCharOffset

instance UnicodeText SubFlag where
  toUnicodeText :: SubFlag -> Text
toUnicodeText (SubFlag (Flag Char
ca Char
cb) Char
cc Char
cd Maybe Char
ce) = String -> Text
pack (Char
'\x1f3f4' Char -> ShowS
forall a. a -> [a] -> [a]
: Char -> Char
go' Char
ca Char -> ShowS
forall a. a -> [a] -> [a]
: Char -> Char
go' Char
cb Char -> ShowS
forall a. a -> [a] -> [a]
: (Char -> Char) -> ShowS
forall a b. (a -> b) -> [a] -> [b]
map Char -> Char
go (Char
cc Char -> ShowS
forall a. a -> [a] -> [a]
: Char
cd Char -> ShowS
forall a. a -> [a] -> [a]
: ShowS -> (Char -> ShowS) -> Maybe Char -> ShowS
forall b a. b -> (a -> b) -> Maybe a -> b
maybe ShowS
forall a. a -> a
id (:) Maybe Char
ce String
"\DEL"))
    where
      go :: Char -> Char
go = Int -> Char
chr (Int -> Char) -> (Char -> Int) -> Char -> Char
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Int
0xe0000 Int -> Int -> Int
forall a. Bits a => a -> a -> a
.|.) (Int -> Int) -> (Char -> Int) -> Char -> Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Char -> Int
ord
      go' :: Char -> Char
go' = Char -> Char
go (Char -> Char) -> (Char -> Char) -> Char -> Char
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Char -> Char
toLower
  fromUnicodeText :: Text -> Maybe SubFlag
fromUnicodeText Text
t = [SubFlag] -> Maybe SubFlag
forall a. [a] -> Maybe a
listToMaybe [SubFlag
sf | SubFlag
sf <- [SubFlag]
_subflags, Text
t Text -> Text -> Bool
forall a. Eq a => a -> a -> Bool
== SubFlag -> Text
forall a. UnicodeText a => a -> Text
toUnicodeText SubFlag
sf]
  isInTextRange :: Text -> Bool
isInTextRange = (Text -> [Text] -> Bool
forall a. Eq a => a -> [a] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` (SubFlag -> Text) -> [SubFlag] -> [Text]
forall a b. (a -> b) -> [a] -> [b]
map SubFlag -> Text
forall a. UnicodeText a => a -> Text
toUnicodeText [SubFlag]
_subflags)

-- | A data type to represent additional non-regional flags defined by the Unicode standard.
data ExtraFlag
  = -- | A flag with black and white square like in a checkerboard pattern. These are often used to signal the start or end of a car race. This is rendered as 🏁.
    ChequeredFlag
  | -- | A triangular flag that is often used for golf. This is rendered as 🚩.
    TriangularFlagOnPost
  | -- | This emoji depicts two /Japanese/ flags crossed at the base. Older versions of Samsung use two South Korean flags. This is rendered as 🎌.
    CrossedFlags
  | -- | A waving black flag. This is rendered as 🏴.
    BlackFlag
  | -- | A waving white flag. This is often used as a sign of /surrender/. This is rendered as 🏳️.
    WavingWhiteFlag
  | -- | A flag with six colors of the rainbow that usually include red, orange, yellow, green, blue and purple. This is rendered as 🏳️‍🌈.
    RainbowFlag
  | -- | A flag with horizontal pale blue and pale pink stripes and a single white stripe in the middle. This is used as a /transgender/ pride flag. This is rendered as 🏳️‍⚧️.
    TransgenderFlag
  | -- | A /skull and crossbones/ displayed on a black flag. On pirate ships this is known as the Jolly Roger. This is rendered as 🏴‍☠️.
    PirateFlag
  deriving (ExtraFlag
ExtraFlag -> ExtraFlag -> Bounded ExtraFlag
forall a. a -> a -> Bounded a
$cminBound :: ExtraFlag
minBound :: ExtraFlag
$cmaxBound :: ExtraFlag
maxBound :: ExtraFlag
Bounded, Typeable ExtraFlag
Typeable ExtraFlag
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> ExtraFlag -> c ExtraFlag)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c ExtraFlag)
-> (ExtraFlag -> Constr)
-> (ExtraFlag -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c ExtraFlag))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ExtraFlag))
-> ((forall b. Data b => b -> b) -> ExtraFlag -> ExtraFlag)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ExtraFlag -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ExtraFlag -> r)
-> (forall u. (forall d. Data d => d -> u) -> ExtraFlag -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> ExtraFlag -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> ExtraFlag -> m ExtraFlag)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ExtraFlag -> m ExtraFlag)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ExtraFlag -> m ExtraFlag)
-> Data ExtraFlag
ExtraFlag -> Constr
ExtraFlag -> DataType
(forall b. Data b => b -> b) -> ExtraFlag -> ExtraFlag
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> ExtraFlag -> u
forall u. (forall d. Data d => d -> u) -> ExtraFlag -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ExtraFlag -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ExtraFlag -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ExtraFlag -> m ExtraFlag
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ExtraFlag -> m ExtraFlag
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ExtraFlag
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ExtraFlag -> c ExtraFlag
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ExtraFlag)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ExtraFlag)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ExtraFlag -> c ExtraFlag
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ExtraFlag -> c ExtraFlag
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ExtraFlag
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ExtraFlag
$ctoConstr :: ExtraFlag -> Constr
toConstr :: ExtraFlag -> Constr
$cdataTypeOf :: ExtraFlag -> DataType
dataTypeOf :: ExtraFlag -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ExtraFlag)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ExtraFlag)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ExtraFlag)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ExtraFlag)
$cgmapT :: (forall b. Data b => b -> b) -> ExtraFlag -> ExtraFlag
gmapT :: (forall b. Data b => b -> b) -> ExtraFlag -> ExtraFlag
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ExtraFlag -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ExtraFlag -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ExtraFlag -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ExtraFlag -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> ExtraFlag -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> ExtraFlag -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ExtraFlag -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ExtraFlag -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ExtraFlag -> m ExtraFlag
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ExtraFlag -> m ExtraFlag
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ExtraFlag -> m ExtraFlag
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ExtraFlag -> m ExtraFlag
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ExtraFlag -> m ExtraFlag
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ExtraFlag -> m ExtraFlag
Data, Int -> ExtraFlag
ExtraFlag -> Int
ExtraFlag -> [ExtraFlag]
ExtraFlag -> ExtraFlag
ExtraFlag -> ExtraFlag -> [ExtraFlag]
ExtraFlag -> ExtraFlag -> ExtraFlag -> [ExtraFlag]
(ExtraFlag -> ExtraFlag)
-> (ExtraFlag -> ExtraFlag)
-> (Int -> ExtraFlag)
-> (ExtraFlag -> Int)
-> (ExtraFlag -> [ExtraFlag])
-> (ExtraFlag -> ExtraFlag -> [ExtraFlag])
-> (ExtraFlag -> ExtraFlag -> [ExtraFlag])
-> (ExtraFlag -> ExtraFlag -> ExtraFlag -> [ExtraFlag])
-> Enum ExtraFlag
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
$csucc :: ExtraFlag -> ExtraFlag
succ :: ExtraFlag -> ExtraFlag
$cpred :: ExtraFlag -> ExtraFlag
pred :: ExtraFlag -> ExtraFlag
$ctoEnum :: Int -> ExtraFlag
toEnum :: Int -> ExtraFlag
$cfromEnum :: ExtraFlag -> Int
fromEnum :: ExtraFlag -> Int
$cenumFrom :: ExtraFlag -> [ExtraFlag]
enumFrom :: ExtraFlag -> [ExtraFlag]
$cenumFromThen :: ExtraFlag -> ExtraFlag -> [ExtraFlag]
enumFromThen :: ExtraFlag -> ExtraFlag -> [ExtraFlag]
$cenumFromTo :: ExtraFlag -> ExtraFlag -> [ExtraFlag]
enumFromTo :: ExtraFlag -> ExtraFlag -> [ExtraFlag]
$cenumFromThenTo :: ExtraFlag -> ExtraFlag -> ExtraFlag -> [ExtraFlag]
enumFromThenTo :: ExtraFlag -> ExtraFlag -> ExtraFlag -> [ExtraFlag]
Enum, ExtraFlag -> ExtraFlag -> Bool
(ExtraFlag -> ExtraFlag -> Bool)
-> (ExtraFlag -> ExtraFlag -> Bool) -> Eq ExtraFlag
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ExtraFlag -> ExtraFlag -> Bool
== :: ExtraFlag -> ExtraFlag -> Bool
$c/= :: ExtraFlag -> ExtraFlag -> Bool
/= :: ExtraFlag -> ExtraFlag -> Bool
Eq, (forall x. ExtraFlag -> Rep ExtraFlag x)
-> (forall x. Rep ExtraFlag x -> ExtraFlag) -> Generic ExtraFlag
forall x. Rep ExtraFlag x -> ExtraFlag
forall x. ExtraFlag -> Rep ExtraFlag x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. ExtraFlag -> Rep ExtraFlag x
from :: forall x. ExtraFlag -> Rep ExtraFlag x
$cto :: forall x. Rep ExtraFlag x -> ExtraFlag
to :: forall x. Rep ExtraFlag x -> ExtraFlag
Generic, Eq ExtraFlag
Eq ExtraFlag
-> (ExtraFlag -> ExtraFlag -> Ordering)
-> (ExtraFlag -> ExtraFlag -> Bool)
-> (ExtraFlag -> ExtraFlag -> Bool)
-> (ExtraFlag -> ExtraFlag -> Bool)
-> (ExtraFlag -> ExtraFlag -> Bool)
-> (ExtraFlag -> ExtraFlag -> ExtraFlag)
-> (ExtraFlag -> ExtraFlag -> ExtraFlag)
-> Ord ExtraFlag
ExtraFlag -> ExtraFlag -> Bool
ExtraFlag -> ExtraFlag -> Ordering
ExtraFlag -> ExtraFlag -> ExtraFlag
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: ExtraFlag -> ExtraFlag -> Ordering
compare :: ExtraFlag -> ExtraFlag -> Ordering
$c< :: ExtraFlag -> ExtraFlag -> Bool
< :: ExtraFlag -> ExtraFlag -> Bool
$c<= :: ExtraFlag -> ExtraFlag -> Bool
<= :: ExtraFlag -> ExtraFlag -> Bool
$c> :: ExtraFlag -> ExtraFlag -> Bool
> :: ExtraFlag -> ExtraFlag -> Bool
$c>= :: ExtraFlag -> ExtraFlag -> Bool
>= :: ExtraFlag -> ExtraFlag -> Bool
$cmax :: ExtraFlag -> ExtraFlag -> ExtraFlag
max :: ExtraFlag -> ExtraFlag -> ExtraFlag
$cmin :: ExtraFlag -> ExtraFlag -> ExtraFlag
min :: ExtraFlag -> ExtraFlag -> ExtraFlag
Ord, ReadPrec [ExtraFlag]
ReadPrec ExtraFlag
Int -> ReadS ExtraFlag
ReadS [ExtraFlag]
(Int -> ReadS ExtraFlag)
-> ReadS [ExtraFlag]
-> ReadPrec ExtraFlag
-> ReadPrec [ExtraFlag]
-> Read ExtraFlag
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS ExtraFlag
readsPrec :: Int -> ReadS ExtraFlag
$creadList :: ReadS [ExtraFlag]
readList :: ReadS [ExtraFlag]
$creadPrec :: ReadPrec ExtraFlag
readPrec :: ReadPrec ExtraFlag
$creadListPrec :: ReadPrec [ExtraFlag]
readListPrec :: ReadPrec [ExtraFlag]
Read, Int -> ExtraFlag -> ShowS
[ExtraFlag] -> ShowS
ExtraFlag -> String
(Int -> ExtraFlag -> ShowS)
-> (ExtraFlag -> String)
-> ([ExtraFlag] -> ShowS)
-> Show ExtraFlag
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ExtraFlag -> ShowS
showsPrec :: Int -> ExtraFlag -> ShowS
$cshow :: ExtraFlag -> String
show :: ExtraFlag -> String
$cshowList :: [ExtraFlag] -> ShowS
showList :: [ExtraFlag] -> ShowS
Show)

instance Arbitrary ExtraFlag where
  arbitrary :: Gen ExtraFlag
arbitrary = Gen ExtraFlag
forall a. (Bounded a, Enum a) => Gen a
arbitraryBoundedEnum

instance Hashable ExtraFlag

instance NFData ExtraFlag

instance UnicodeText ExtraFlag where
  toUnicodeText :: ExtraFlag -> Text
toUnicodeText ExtraFlag
ChequeredFlag = Text
"\x1f3c1"
  toUnicodeText ExtraFlag
TriangularFlagOnPost = Text
"\x1f6a9"
  toUnicodeText ExtraFlag
CrossedFlags = Text
"\x1f38c"
  toUnicodeText ExtraFlag
BlackFlag = Text
"\x1f3f4"
  toUnicodeText ExtraFlag
WavingWhiteFlag = Text
"\x1f3f3\xfe0f"
  toUnicodeText ExtraFlag
RainbowFlag = Text
"\x1f3f3\xfe0f\x200d\x1f308"
  toUnicodeText ExtraFlag
TransgenderFlag = Text
"\x1f3f3\xfe0f\x200d\x26a7\xfe0f"
  toUnicodeText ExtraFlag
PirateFlag = Text
"\x1f3f4\x200d\x2620\xfe0f"
  fromUnicodeText :: Text -> Maybe ExtraFlag
fromUnicodeText Text
"\x1f3c1" = ExtraFlag -> Maybe ExtraFlag
forall a. a -> Maybe a
Just ExtraFlag
ChequeredFlag
  fromUnicodeText Text
"\x1f6a9" = ExtraFlag -> Maybe ExtraFlag
forall a. a -> Maybe a
Just ExtraFlag
TriangularFlagOnPost
  fromUnicodeText Text
"\x1f38c" = ExtraFlag -> Maybe ExtraFlag
forall a. a -> Maybe a
Just ExtraFlag
CrossedFlags
  fromUnicodeText Text
"\x1f3f4" = ExtraFlag -> Maybe ExtraFlag
forall a. a -> Maybe a
Just ExtraFlag
BlackFlag
  fromUnicodeText Text
"\x1f3f3\xfe0f" = ExtraFlag -> Maybe ExtraFlag
forall a. a -> Maybe a
Just ExtraFlag
WavingWhiteFlag
  fromUnicodeText Text
"\x1f3f3\xfe0f\x200d\x1f308" = ExtraFlag -> Maybe ExtraFlag
forall a. a -> Maybe a
Just ExtraFlag
RainbowFlag
  fromUnicodeText Text
"\x1f3f3\xfe0f\x200d\x26a7\xfe0f" = ExtraFlag -> Maybe ExtraFlag
forall a. a -> Maybe a
Just ExtraFlag
TransgenderFlag
  fromUnicodeText Text
"\x1f3f4\x200d\x2620\xfe0f" = ExtraFlag -> Maybe ExtraFlag
forall a. a -> Maybe a
Just ExtraFlag
PirateFlag
  fromUnicodeText Text
_ = Maybe ExtraFlag
forall a. Maybe a
Nothing
  isInTextRange :: Text -> Bool
isInTextRange Text
"\x1f3c1" = Bool
True
  isInTextRange Text
"\x1f6a9" = Bool
True
  isInTextRange Text
"\x1f38c" = Bool
True
  isInTextRange Text
"\x1f3f4" = Bool
True
  isInTextRange Text
"\x1f3f3\xfe0f" = Bool
True
  isInTextRange Text
"\x1f3f3\xfe0f\x200d\x1f308" = Bool
True
  isInTextRange Text
"\x1f3f3\xfe0f\x200d\x26a7\xfe0f" = Bool
True
  isInTextRange Text
"\x1f3f4\x200d\x2620\xfe0f" = Bool
True
  isInTextRange Text
_ = Bool
False