{-# LANGUAGE DeriveDataTypeable, DeriveGeneric, PatternSynonyms, OverloadedStrings, 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
  ) where

import Prelude hiding (LT, GT)

import Control.DeepSeq(NFData)

import Data.Bits((.|.))
import Data.Char(chr, ord, toLower, toUpper)
import Data.Char.Core(UnicodeText(fromUnicodeText, toUnicodeText, isInTextRange), mapToEnumSafe)
import Data.Char.Enclosed(regionalIndicatorUppercase')
import Data.Data(Data)
import Data.Function(on)
import Data.Hashable(Hashable)
import Data.Maybe(fromJust)
import Data.Text(Text, pack, unpack)

import GHC.Enum(fromEnumError, toEnumError)
import GHC.Generics(Generic)

import Test.QuickCheck.Arbitrary(Arbitrary(arbitrary), arbitraryBoundedEnum)

_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
Flag -> DataType
Flag -> Constr
(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)
gmapMo :: 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
gmapMp :: forall (m :: * -> *).
MonadPlus 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
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Flag -> m Flag
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Flag -> m Flag
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Flag -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Flag -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> Flag -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Flag -> [u]
gmapQr :: 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
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Flag -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Flag -> r
gmapT :: (forall b. Data b => b -> b) -> Flag -> Flag
$cgmapT :: (forall b. Data b => b -> b) -> Flag -> Flag
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Flag)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Flag)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Flag)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Flag)
dataTypeOf :: Flag -> DataType
$cdataTypeOf :: Flag -> DataType
toConstr :: Flag -> Constr
$ctoConstr :: Flag -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Flag
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Flag
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Flag -> c Flag
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Flag -> c Flag
Data, Flag -> Flag -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Flag -> Flag -> Bool
$c/= :: Flag -> Flag -> Bool
== :: Flag -> Flag -> Bool
$c== :: Flag -> Flag -> Bool
Eq, 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
$cto :: forall x. Rep Flag x -> Flag
$cfrom :: forall x. Flag -> Rep Flag x
Generic, Eq 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
min :: Flag -> Flag -> Flag
$cmin :: Flag -> Flag -> Flag
max :: Flag -> Flag -> Flag
$cmax :: Flag -> Flag -> Flag
>= :: Flag -> Flag -> Bool
$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
compare :: Flag -> Flag -> Ordering
$ccompare :: Flag -> Flag -> Ordering
Ord, ReadPrec [Flag]
ReadPrec Flag
Int -> ReadS Flag
ReadS [Flag]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Flag]
$creadListPrec :: ReadPrec [Flag]
readPrec :: ReadPrec Flag
$creadPrec :: ReadPrec Flag
readList :: ReadS [Flag]
$creadList :: ReadS [Flag]
readsPrec :: Int -> ReadS Flag
$creadsPrec :: Int -> ReadS Flag
Read, Int -> Flag -> ShowS
[Flag] -> ShowS
Flag -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Flag] -> ShowS
$cshowList :: [Flag] -> ShowS
show :: Flag -> String
$cshow :: Flag -> String
showsPrec :: Int -> Flag -> ShowS
$cshowsPrec :: Int -> 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 Char deriving (Typeable SubFlag
SubFlag -> DataType
SubFlag -> Constr
(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)
gmapMo :: 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
gmapMp :: forall (m :: * -> *).
MonadPlus 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
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> SubFlag -> m SubFlag
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> SubFlag -> m SubFlag
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> SubFlag -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> SubFlag -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> SubFlag -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> SubFlag -> [u]
gmapQr :: 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
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SubFlag -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SubFlag -> r
gmapT :: (forall b. Data b => b -> b) -> SubFlag -> SubFlag
$cgmapT :: (forall b. Data b => b -> b) -> SubFlag -> SubFlag
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SubFlag)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SubFlag)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SubFlag)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SubFlag)
dataTypeOf :: SubFlag -> DataType
$cdataTypeOf :: SubFlag -> DataType
toConstr :: SubFlag -> Constr
$ctoConstr :: SubFlag -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SubFlag
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SubFlag
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SubFlag -> c SubFlag
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SubFlag -> c SubFlag
Data, SubFlag -> SubFlag -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: SubFlag -> SubFlag -> Bool
$c/= :: SubFlag -> SubFlag -> Bool
== :: SubFlag -> SubFlag -> Bool
$c== :: SubFlag -> SubFlag -> Bool
Eq, 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
$cto :: forall x. Rep SubFlag x -> SubFlag
$cfrom :: forall x. SubFlag -> Rep SubFlag x
Generic, Eq 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
min :: SubFlag -> SubFlag -> SubFlag
$cmin :: SubFlag -> SubFlag -> SubFlag
max :: SubFlag -> SubFlag -> SubFlag
$cmax :: SubFlag -> SubFlag -> SubFlag
>= :: SubFlag -> SubFlag -> Bool
$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
compare :: SubFlag -> SubFlag -> Ordering
$ccompare :: SubFlag -> SubFlag -> Ordering
Ord, ReadPrec [SubFlag]
ReadPrec SubFlag
Int -> ReadS SubFlag
ReadS [SubFlag]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [SubFlag]
$creadListPrec :: ReadPrec [SubFlag]
readPrec :: ReadPrec SubFlag
$creadPrec :: ReadPrec SubFlag
readList :: ReadS [SubFlag]
$creadList :: ReadS [SubFlag]
readsPrec :: Int -> ReadS SubFlag
$creadsPrec :: Int -> ReadS SubFlag
Read, Int -> SubFlag -> ShowS
[SubFlag] -> ShowS
SubFlag -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [SubFlag] -> ShowS
$cshowList :: [SubFlag] -> ShowS
show :: SubFlag -> String
$cshow :: SubFlag -> String
showsPrec :: Int -> SubFlag -> ShowS
$cshowsPrec :: Int -> 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
  :: Char  -- ^ The first character of the ISO 3166 Alpha-2 standard.
  -> Char  -- ^ The second character of the ISO 3166 Alpha-2 standard.
  -> Maybe Flag  -- ^ A 'Flag' object wrapped in a 'Just' data constructor, given such flag exists; 'Nothing' otherwise.
flag :: Char -> Char -> Maybe Flag
flag Char
ca Char
cb
    | Char -> Char -> Bool
_validFlagEmoji Char
a Char
b = forall a. a -> Maybe a
Just (Char -> Char -> Flag
Flag Char
a Char
b)
    | Bool
otherwise = 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'
  :: Char  -- ^ The first character of the ISO 3166 Alpha-2 standard.
  -> Char  -- ^ The second character of the ISO 3166 Alpha-2 standard.
  -> Flag  -- ^ The equivalent 'Flag' object.
flag' :: Char -> Char -> Flag
flag' Char
ca = forall a. HasCallStack => Maybe a -> a
fromJust 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
  :: Flag  -- ^ The given 'Flag' to convert to a 2-tuple of 'Char'acters.
  -> (Char, Char)  -- ^ A 2-tuple that contains upper case 'Char'acters for the given 'Flag'.
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 $bAC :: Flag
$mAC :: forall {r}. Flag -> ((# #) -> r) -> ((# #) -> r) -> r
AC = Flag 'A' 'C'

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

instance Bounded SubFlag where
    minBound :: SubFlag
minBound = SubFlag
ENG
    maxBound :: SubFlag
maxBound = SubFlag
WLS


-- | 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'
  :: Char  -- ^ The first 'Char'acter of the ISO3166 Alpha-2 code.
  -> Char  -- ^ The second 'Char'acter of the ISO3166 Alpha-2 code.
  -> Text  -- ^ A 'Text' object that consists of two characters, where the two characters form a flag emoji, if the given flag exists.
iso3166Alpha2ToFlag' :: Char -> Char -> Text
iso3166Alpha2ToFlag' Char
ca Char
cb = String -> Text
pack (forall a b. (a -> b) -> [a] -> [b]
map (Char -> Char
regionalIndicatorUppercase' 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
  :: Char  -- ^ The first 'Char'acter of the ISO3166 Alpha-2 code.
  -> Char  -- ^ The second 'Char'acter of the ISO3166 Alpha-2 code.
  -> Maybe Text  -- ^ 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.
iso3166Alpha2ToFlag :: Char -> Char -> Maybe Text
iso3166Alpha2ToFlag Char
ca Char
cb
  | Char -> Char -> Bool
validFlagEmoji Char
ca Char
cb = forall a. a -> Maybe a
Just (Char -> Char -> Text
iso3166Alpha2ToFlag' Char
ca Char
cb)
  | Bool
otherwise = 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 = forall a. a -> Maybe a
Just (Char -> Char -> Flag
Flag Char
a Char
b)
    | Bool
otherwise = forall a. Maybe a
Nothing
    where shft :: Char -> Maybe Char
shft = 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
  :: Char  -- ^ The first 'Char'acter of the ISO3166 Alpha-2 code.
  -> Char  -- ^ The second 'Char'acter of the ISO3166 Alpha-2 code.
  -> Bool  -- ^ 'True' if a flag emoji exists for the given characters; 'False' otherwise.
validFlagEmoji :: Char -> Char -> Bool
validFlagEmoji = 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 = forall a. (Bounded a, Enum a) => Gen a
arbitraryBoundedEnum

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

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 = 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 = forall a b. Show a => String -> Int -> (a, a) -> b
toEnumError String
"Flag" Int
i (forall a. Bounded a => a
minBound :: Flag, forall a. Bounded a => a
maxBound)
    enumFrom :: Flag -> [Flag]
enumFrom = (forall a. Enum a => a -> a -> [a]
`enumFromTo` forall a. Bounded a => a
maxBound)
    enumFromThen :: Flag -> Flag -> [Flag]
enumFromThen Flag
x Flag
y = forall a. Enum a => a -> a -> a -> [a]
enumFromThenTo Flag
x Flag
y forall a. Bounded a => a
maxBound

instance Enum SubFlag where
    fromEnum :: SubFlag -> Int
fromEnum SubFlag
ENG = Int
0
    fromEnum SubFlag
SCT = Int
1
    fromEnum SubFlag
WLS = Int
2
    fromEnum SubFlag
s = forall a b. Show a => String -> a -> b
fromEnumError String
"SubFlag" SubFlag
s
    toEnum :: Int -> SubFlag
toEnum Int
0 = SubFlag
ENG
    toEnum Int
1 = SubFlag
SCT
    toEnum Int
2 = SubFlag
WLS
    toEnum Int
i = forall a b. Show a => String -> Int -> (a, a) -> b
toEnumError String
"SubFlag" Int
i (forall a. Bounded a => a
minBound :: SubFlag, forall a. Bounded a => a
maxBound)
    enumFrom :: SubFlag -> [SubFlag]
enumFrom = (forall a. Enum a => a -> a -> [a]
`enumFromTo` forall a. Bounded a => a
maxBound)
    enumFromThen :: SubFlag -> SubFlag -> [SubFlag]
enumFromThen SubFlag
x SubFlag
y = forall a. Enum a => a -> a -> a -> [a]
enumFromThenTo SubFlag
x SubFlag
y 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 = 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 Char
ce) = String -> Text
pack (Char
'\x1f3f4' forall a. a -> [a] -> [a]
: Char -> Char
go' Char
ca forall a. a -> [a] -> [a]
: Char -> Char
go' Char
cb forall a. a -> [a] -> [a]
: forall a b. (a -> b) -> [a] -> [b]
map Char -> Char
go [Char
cc, Char
cd, Char
ce, Char
'\DEL'])
        where go :: Char -> Char
go = Int -> Char
chr forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Int
0xe0000 forall a. Bits a => a -> a -> a
.|.) forall b c a. (b -> c) -> (a -> b) -> a -> c
. Char -> Int
ord
              go' :: Char -> Char
go' = Char -> Char
go forall b c a. (b -> c) -> (a -> b) -> a -> c
. Char -> Char
toLower
    fromUnicodeText :: Text -> Maybe SubFlag
fromUnicodeText Text
t
        | [Char
'\x1f3f4', Char
'\xe0067', Char
'\xe0062', Char
sa, Char
sb, Char
sc, Char
'\xe007f'] <- Text -> String
unpack Text
t = Char -> Char -> Char -> Maybe SubFlag
go Char
sa Char
sb Char
sc
        | Bool
otherwise = forall a. Maybe a
Nothing
        where go :: Char -> Char -> Char -> Maybe SubFlag
go Char
'\xe0065' Char
'\xe006e' Char
'\xe0067' = forall a. a -> Maybe a
Just SubFlag
ENG
              go Char
'\xe0073' Char
'\xe0063' Char
'\xe0074' = forall a. a -> Maybe a
Just SubFlag
SCT
              go Char
'\xe0077' Char
'\xe006c' Char
'\xe0073' = forall a. a -> Maybe a
Just SubFlag
WLS
              go Char
_ Char
_ Char
_ = forall a. Maybe a
Nothing
    isInTextRange :: Text -> Bool
isInTextRange Text
"\x1f3f4\xe0067\xe0062\xe0065\xe006e\xe0067\xe007f" = Bool
True
    isInTextRange Text
"\x1f3f4\xe0067\xe0062\xe0073\xe0063\xe0074\xe007f" = Bool
True
    isInTextRange Text
"\x1f3f4\xe0067\xe0062\xe0077\xe006c\xe0073\xe007f" = Bool
True
    isInTextRange Text
_ = Bool
False

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

instance Arbitrary ExtraFlag where
  arbitrary :: Gen ExtraFlag
arbitrary = 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" = forall a. a -> Maybe a
Just ExtraFlag
ChequeredFlag
  fromUnicodeText Text
"\x1f6a9" = forall a. a -> Maybe a
Just ExtraFlag
TriangularFlagOnPost
  fromUnicodeText Text
"\x1f38c" = forall a. a -> Maybe a
Just ExtraFlag
CrossedFlags
  fromUnicodeText Text
"\x1f3f4" = forall a. a -> Maybe a
Just ExtraFlag
BlackFlag
  fromUnicodeText Text
"\x1f3f3\xfe0f" = forall a. a -> Maybe a
Just ExtraFlag
WavingWhiteFlag
  fromUnicodeText Text
"\x1f3f3\xfe0f\x200d\x1f308" = forall a. a -> Maybe a
Just ExtraFlag
RainbowFlag
  fromUnicodeText Text
"\x1f3f3\xfe0f\x200d\x26a7\xfe0f" = forall a. a -> Maybe a
Just ExtraFlag
TransgenderFlag
  fromUnicodeText Text
"\x1f3f4\x200d\x2620\xfe0f" = forall a. a -> Maybe a
Just ExtraFlag
PirateFlag
  fromUnicodeText Text
_ = 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