/// A number of constants to give a name to all characters in this block.
mod constants {
    /// \u{a6a0}: 'ꚠ'
    pub const LETTER_A: char = 'ꚠ';
    /// \u{a6a1}: 'ꚡ'
    pub const LETTER_KA: char = 'ꚡ';
    /// \u{a6a2}: 'ꚢ'
    pub const LETTER_U: char = 'ꚢ';
    /// \u{a6a3}: 'ꚣ'
    pub const LETTER_KU: char = 'ꚣ';
    /// \u{a6a4}: 'ꚤ'
    pub const LETTER_EE: char = 'ꚤ';
    /// \u{a6a5}: 'ꚥ'
    pub const LETTER_REE: char = 'ꚥ';
    /// \u{a6a6}: 'ꚦ'
    pub const LETTER_TAE: char = 'ꚦ';
    /// \u{a6a7}: 'ꚧ'
    pub const LETTER_O: char = 'ꚧ';
    /// \u{a6a8}: 'ꚨ'
    pub const LETTER_NYI: char = 'ꚨ';
    /// \u{a6a9}: 'ꚩ'
    pub const LETTER_I: char = 'ꚩ';
    /// \u{a6aa}: 'ꚪ'
    pub const LETTER_LA: char = 'ꚪ';
    /// \u{a6ab}: 'ꚫ'
    pub const LETTER_PA: char = 'ꚫ';
    /// \u{a6ac}: 'ꚬ'
    pub const LETTER_RII: char = 'ꚬ';
    /// \u{a6ad}: 'ꚭ'
    pub const LETTER_RIEE: char = 'ꚭ';
    /// \u{a6ae}: 'ꚮ'
    pub const LETTER_LEEEE: char = 'ꚮ';
    /// \u{a6af}: 'ꚯ'
    pub const LETTER_MEEEE: char = 'ꚯ';
    /// \u{a6b0}: 'ꚰ'
    pub const LETTER_TAA: char = 'ꚰ';
    /// \u{a6b1}: 'ꚱ'
    pub const LETTER_NDAA: char = 'ꚱ';
    /// \u{a6b2}: 'ꚲ'
    pub const LETTER_NJAEM: char = 'ꚲ';
    /// \u{a6b3}: 'ꚳ'
    pub const LETTER_M: char = 'ꚳ';
    /// \u{a6b4}: 'ꚴ'
    pub const LETTER_SUU: char = 'ꚴ';
    /// \u{a6b5}: 'ꚵ'
    pub const LETTER_MU: char = 'ꚵ';
    /// \u{a6b6}: 'ꚶ'
    pub const LETTER_SHII: char = 'ꚶ';
    /// \u{a6b7}: 'ꚷ'
    pub const LETTER_SI: char = 'ꚷ';
    /// \u{a6b8}: 'ꚸ'
    pub const LETTER_SHEUX: char = 'ꚸ';
    /// \u{a6b9}: 'ꚹ'
    pub const LETTER_SEUX: char = 'ꚹ';
    /// \u{a6ba}: 'ꚺ'
    pub const LETTER_KYEE: char = 'ꚺ';
    /// \u{a6bb}: 'ꚻ'
    pub const LETTER_KET: char = 'ꚻ';
    /// \u{a6bc}: 'ꚼ'
    pub const LETTER_NUAE: char = 'ꚼ';
    /// \u{a6bd}: 'ꚽ'
    pub const LETTER_NU: char = 'ꚽ';
    /// \u{a6be}: 'ꚾ'
    pub const LETTER_NJUAE: char = 'ꚾ';
    /// \u{a6bf}: 'ꚿ'
    pub const LETTER_YOQ: char = 'ꚿ';
    /// \u{a6c0}: 'ꛀ'
    pub const LETTER_SHU: char = 'ꛀ';
    /// \u{a6c1}: 'ꛁ'
    pub const LETTER_YUQ: char = 'ꛁ';
    /// \u{a6c2}: 'ꛂ'
    pub const LETTER_YA: char = 'ꛂ';
    /// \u{a6c3}: 'ꛃ'
    pub const LETTER_NSHA: char = 'ꛃ';
    /// \u{a6c4}: 'ꛄ'
    pub const LETTER_KEUX: char = 'ꛄ';
    /// \u{a6c5}: 'ꛅ'
    pub const LETTER_PEUX: char = 'ꛅ';
    /// \u{a6c6}: 'ꛆ'
    pub const LETTER_NJEE: char = 'ꛆ';
    /// \u{a6c7}: 'ꛇ'
    pub const LETTER_NTEE: char = 'ꛇ';
    /// \u{a6c8}: 'ꛈ'
    pub const LETTER_PUE: char = 'ꛈ';
    /// \u{a6c9}: 'ꛉ'
    pub const LETTER_WUE: char = 'ꛉ';
    /// \u{a6ca}: 'ꛊ'
    pub const LETTER_PEE: char = 'ꛊ';
    /// \u{a6cb}: 'ꛋ'
    pub const LETTER_FEE: char = 'ꛋ';
    /// \u{a6cc}: 'ꛌ'
    pub const LETTER_RU: char = 'ꛌ';
    /// \u{a6cd}: 'ꛍ'
    pub const LETTER_LU: char = 'ꛍ';
    /// \u{a6ce}: 'ꛎ'
    pub const LETTER_MI: char = 'ꛎ';
    /// \u{a6cf}: 'ꛏ'
    pub const LETTER_NI: char = 'ꛏ';
    /// \u{a6d0}: 'ꛐ'
    pub const LETTER_REUX: char = 'ꛐ';
    /// \u{a6d1}: 'ꛑ'
    pub const LETTER_RAE: char = 'ꛑ';
    /// \u{a6d2}: 'ꛒ'
    pub const LETTER_KEN: char = 'ꛒ';
    /// \u{a6d3}: 'ꛓ'
    pub const LETTER_NGKWAEN: char = 'ꛓ';
    /// \u{a6d4}: 'ꛔ'
    pub const LETTER_NGGA: char = 'ꛔ';
    /// \u{a6d5}: 'ꛕ'
    pub const LETTER_NGA: char = 'ꛕ';
    /// \u{a6d6}: 'ꛖ'
    pub const LETTER_SHO: char = 'ꛖ';
    /// \u{a6d7}: 'ꛗ'
    pub const LETTER_PUAE: char = 'ꛗ';
    /// \u{a6d8}: 'ꛘ'
    pub const LETTER_FU: char = 'ꛘ';
    /// \u{a6d9}: 'ꛙ'
    pub const LETTER_FOM: char = 'ꛙ';
    /// \u{a6da}: 'ꛚ'
    pub const LETTER_WA: char = 'ꛚ';
    /// \u{a6db}: 'ꛛ'
    pub const LETTER_NA: char = 'ꛛ';
    /// \u{a6dc}: 'ꛜ'
    pub const LETTER_LI: char = 'ꛜ';
    /// \u{a6dd}: 'ꛝ'
    pub const LETTER_PI: char = 'ꛝ';
    /// \u{a6de}: 'ꛞ'
    pub const LETTER_LOQ: char = 'ꛞ';
    /// \u{a6df}: 'ꛟ'
    pub const LETTER_KO: char = 'ꛟ';
    /// \u{a6e0}: 'ꛠ'
    pub const LETTER_MBEN: char = 'ꛠ';
    /// \u{a6e1}: 'ꛡ'
    pub const LETTER_REN: char = 'ꛡ';
    /// \u{a6e2}: 'ꛢ'
    pub const LETTER_MEN: char = 'ꛢ';
    /// \u{a6e3}: 'ꛣ'
    pub const LETTER_MA: char = 'ꛣ';
    /// \u{a6e4}: 'ꛤ'
    pub const LETTER_TI: char = 'ꛤ';
    /// \u{a6e5}: 'ꛥ'
    pub const LETTER_KI: char = 'ꛥ';
    /// \u{a6e6}: 'ꛦ'
    pub const LETTER_MO: char = 'ꛦ';
    /// \u{a6e7}: 'ꛧ'
    pub const LETTER_MBAA: char = 'ꛧ';
    /// \u{a6e8}: 'ꛨ'
    pub const LETTER_TET: char = 'ꛨ';
    /// \u{a6e9}: 'ꛩ'
    pub const LETTER_KPA: char = 'ꛩ';
    /// \u{a6ea}: 'ꛪ'
    pub const LETTER_TEN: char = 'ꛪ';
    /// \u{a6eb}: 'ꛫ'
    pub const LETTER_NTUU: char = 'ꛫ';
    /// \u{a6ec}: 'ꛬ'
    pub const LETTER_SAMBA: char = 'ꛬ';
    /// \u{a6ed}: 'ꛭ'
    pub const LETTER_FAAMAE: char = 'ꛭ';
    /// \u{a6ee}: 'ꛮ'
    pub const LETTER_KOVUU: char = 'ꛮ';
    /// \u{a6ef}: 'ꛯ'
    pub const LETTER_KOGHOM: char = 'ꛯ';
    /// \u{a6f0}: '꛰'
    pub const COMBINING_MARK_KOQNDON: char = '꛰';
    /// \u{a6f1}: '꛱'
    pub const COMBINING_MARK_TUKWENTIS: char = '꛱';
    /// \u{a6f2}: '꛲'
    pub const NJAEMLI: char = '꛲';
    /// \u{a6f3}: '꛳'
    pub const FULL_STOP: char = '꛳';
    /// \u{a6f4}: '꛴'
    pub const COLON: char = '꛴';
    /// \u{a6f5}: '꛵'
    pub const COMMA: char = '꛵';
    /// \u{a6f6}: '꛶'
    pub const SEMICOLON: char = '꛶';
    /// \u{a6f7}: '꛷'
    pub const QUESTION_MARK: char = '꛷';
}

/// An enum to represent all characters in the Bamum block.
#[derive(Debug, Clone, Copy, Hash, PartialEq, Eq)]
pub enum Bamum {
    /// \u{a6a0}: 'ꚠ'
    LetterA,
    /// \u{a6a1}: 'ꚡ'
    LetterKa,
    /// \u{a6a2}: 'ꚢ'
    LetterU,
    /// \u{a6a3}: 'ꚣ'
    LetterKu,
    /// \u{a6a4}: 'ꚤ'
    LetterEe,
    /// \u{a6a5}: 'ꚥ'
    LetterRee,
    /// \u{a6a6}: 'ꚦ'
    LetterTae,
    /// \u{a6a7}: 'ꚧ'
    LetterO,
    /// \u{a6a8}: 'ꚨ'
    LetterNyi,
    /// \u{a6a9}: 'ꚩ'
    LetterI,
    /// \u{a6aa}: 'ꚪ'
    LetterLa,
    /// \u{a6ab}: 'ꚫ'
    LetterPa,
    /// \u{a6ac}: 'ꚬ'
    LetterRii,
    /// \u{a6ad}: 'ꚭ'
    LetterRiee,
    /// \u{a6ae}: 'ꚮ'
    LetterLeeee,
    /// \u{a6af}: 'ꚯ'
    LetterMeeee,
    /// \u{a6b0}: 'ꚰ'
    LetterTaa,
    /// \u{a6b1}: 'ꚱ'
    LetterNdaa,
    /// \u{a6b2}: 'ꚲ'
    LetterNjaem,
    /// \u{a6b3}: 'ꚳ'
    LetterM,
    /// \u{a6b4}: 'ꚴ'
    LetterSuu,
    /// \u{a6b5}: 'ꚵ'
    LetterMu,
    /// \u{a6b6}: 'ꚶ'
    LetterShii,
    /// \u{a6b7}: 'ꚷ'
    LetterSi,
    /// \u{a6b8}: 'ꚸ'
    LetterSheux,
    /// \u{a6b9}: 'ꚹ'
    LetterSeux,
    /// \u{a6ba}: 'ꚺ'
    LetterKyee,
    /// \u{a6bb}: 'ꚻ'
    LetterKet,
    /// \u{a6bc}: 'ꚼ'
    LetterNuae,
    /// \u{a6bd}: 'ꚽ'
    LetterNu,
    /// \u{a6be}: 'ꚾ'
    LetterNjuae,
    /// \u{a6bf}: 'ꚿ'
    LetterYoq,
    /// \u{a6c0}: 'ꛀ'
    LetterShu,
    /// \u{a6c1}: 'ꛁ'
    LetterYuq,
    /// \u{a6c2}: 'ꛂ'
    LetterYa,
    /// \u{a6c3}: 'ꛃ'
    LetterNsha,
    /// \u{a6c4}: 'ꛄ'
    LetterKeux,
    /// \u{a6c5}: 'ꛅ'
    LetterPeux,
    /// \u{a6c6}: 'ꛆ'
    LetterNjee,
    /// \u{a6c7}: 'ꛇ'
    LetterNtee,
    /// \u{a6c8}: 'ꛈ'
    LetterPue,
    /// \u{a6c9}: 'ꛉ'
    LetterWue,
    /// \u{a6ca}: 'ꛊ'
    LetterPee,
    /// \u{a6cb}: 'ꛋ'
    LetterFee,
    /// \u{a6cc}: 'ꛌ'
    LetterRu,
    /// \u{a6cd}: 'ꛍ'
    LetterLu,
    /// \u{a6ce}: 'ꛎ'
    LetterMi,
    /// \u{a6cf}: 'ꛏ'
    LetterNi,
    /// \u{a6d0}: 'ꛐ'
    LetterReux,
    /// \u{a6d1}: 'ꛑ'
    LetterRae,
    /// \u{a6d2}: 'ꛒ'
    LetterKen,
    /// \u{a6d3}: 'ꛓ'
    LetterNgkwaen,
    /// \u{a6d4}: 'ꛔ'
    LetterNgga,
    /// \u{a6d5}: 'ꛕ'
    LetterNga,
    /// \u{a6d6}: 'ꛖ'
    LetterSho,
    /// \u{a6d7}: 'ꛗ'
    LetterPuae,
    /// \u{a6d8}: 'ꛘ'
    LetterFu,
    /// \u{a6d9}: 'ꛙ'
    LetterFom,
    /// \u{a6da}: 'ꛚ'
    LetterWa,
    /// \u{a6db}: 'ꛛ'
    LetterNa,
    /// \u{a6dc}: 'ꛜ'
    LetterLi,
    /// \u{a6dd}: 'ꛝ'
    LetterPi,
    /// \u{a6de}: 'ꛞ'
    LetterLoq,
    /// \u{a6df}: 'ꛟ'
    LetterKo,
    /// \u{a6e0}: 'ꛠ'
    LetterMben,
    /// \u{a6e1}: 'ꛡ'
    LetterRen,
    /// \u{a6e2}: 'ꛢ'
    LetterMen,
    /// \u{a6e3}: 'ꛣ'
    LetterMa,
    /// \u{a6e4}: 'ꛤ'
    LetterTi,
    /// \u{a6e5}: 'ꛥ'
    LetterKi,
    /// \u{a6e6}: 'ꛦ'
    LetterMo,
    /// \u{a6e7}: 'ꛧ'
    LetterMbaa,
    /// \u{a6e8}: 'ꛨ'
    LetterTet,
    /// \u{a6e9}: 'ꛩ'
    LetterKpa,
    /// \u{a6ea}: 'ꛪ'
    LetterTen,
    /// \u{a6eb}: 'ꛫ'
    LetterNtuu,
    /// \u{a6ec}: 'ꛬ'
    LetterSamba,
    /// \u{a6ed}: 'ꛭ'
    LetterFaamae,
    /// \u{a6ee}: 'ꛮ'
    LetterKovuu,
    /// \u{a6ef}: 'ꛯ'
    LetterKoghom,
    /// \u{a6f0}: '꛰'
    CombiningMarkKoqndon,
    /// \u{a6f1}: '꛱'
    CombiningMarkTukwentis,
    /// \u{a6f2}: '꛲'
    Njaemli,
    /// \u{a6f3}: '꛳'
    FullStop,
    /// \u{a6f4}: '꛴'
    Colon,
    /// \u{a6f5}: '꛵'
    Comma,
    /// \u{a6f6}: '꛶'
    Semicolon,
    /// \u{a6f7}: '꛷'
    QuestionMark,
}

impl Into<char> for Bamum {
    fn into(self) -> char {
        use constants::*;
        match self {
            Bamum::LetterA => LETTER_A,
            Bamum::LetterKa => LETTER_KA,
            Bamum::LetterU => LETTER_U,
            Bamum::LetterKu => LETTER_KU,
            Bamum::LetterEe => LETTER_EE,
            Bamum::LetterRee => LETTER_REE,
            Bamum::LetterTae => LETTER_TAE,
            Bamum::LetterO => LETTER_O,
            Bamum::LetterNyi => LETTER_NYI,
            Bamum::LetterI => LETTER_I,
            Bamum::LetterLa => LETTER_LA,
            Bamum::LetterPa => LETTER_PA,
            Bamum::LetterRii => LETTER_RII,
            Bamum::LetterRiee => LETTER_RIEE,
            Bamum::LetterLeeee => LETTER_LEEEE,
            Bamum::LetterMeeee => LETTER_MEEEE,
            Bamum::LetterTaa => LETTER_TAA,
            Bamum::LetterNdaa => LETTER_NDAA,
            Bamum::LetterNjaem => LETTER_NJAEM,
            Bamum::LetterM => LETTER_M,
            Bamum::LetterSuu => LETTER_SUU,
            Bamum::LetterMu => LETTER_MU,
            Bamum::LetterShii => LETTER_SHII,
            Bamum::LetterSi => LETTER_SI,
            Bamum::LetterSheux => LETTER_SHEUX,
            Bamum::LetterSeux => LETTER_SEUX,
            Bamum::LetterKyee => LETTER_KYEE,
            Bamum::LetterKet => LETTER_KET,
            Bamum::LetterNuae => LETTER_NUAE,
            Bamum::LetterNu => LETTER_NU,
            Bamum::LetterNjuae => LETTER_NJUAE,
            Bamum::LetterYoq => LETTER_YOQ,
            Bamum::LetterShu => LETTER_SHU,
            Bamum::LetterYuq => LETTER_YUQ,
            Bamum::LetterYa => LETTER_YA,
            Bamum::LetterNsha => LETTER_NSHA,
            Bamum::LetterKeux => LETTER_KEUX,
            Bamum::LetterPeux => LETTER_PEUX,
            Bamum::LetterNjee => LETTER_NJEE,
            Bamum::LetterNtee => LETTER_NTEE,
            Bamum::LetterPue => LETTER_PUE,
            Bamum::LetterWue => LETTER_WUE,
            Bamum::LetterPee => LETTER_PEE,
            Bamum::LetterFee => LETTER_FEE,
            Bamum::LetterRu => LETTER_RU,
            Bamum::LetterLu => LETTER_LU,
            Bamum::LetterMi => LETTER_MI,
            Bamum::LetterNi => LETTER_NI,
            Bamum::LetterReux => LETTER_REUX,
            Bamum::LetterRae => LETTER_RAE,
            Bamum::LetterKen => LETTER_KEN,
            Bamum::LetterNgkwaen => LETTER_NGKWAEN,
            Bamum::LetterNgga => LETTER_NGGA,
            Bamum::LetterNga => LETTER_NGA,
            Bamum::LetterSho => LETTER_SHO,
            Bamum::LetterPuae => LETTER_PUAE,
            Bamum::LetterFu => LETTER_FU,
            Bamum::LetterFom => LETTER_FOM,
            Bamum::LetterWa => LETTER_WA,
            Bamum::LetterNa => LETTER_NA,
            Bamum::LetterLi => LETTER_LI,
            Bamum::LetterPi => LETTER_PI,
            Bamum::LetterLoq => LETTER_LOQ,
            Bamum::LetterKo => LETTER_KO,
            Bamum::LetterMben => LETTER_MBEN,
            Bamum::LetterRen => LETTER_REN,
            Bamum::LetterMen => LETTER_MEN,
            Bamum::LetterMa => LETTER_MA,
            Bamum::LetterTi => LETTER_TI,
            Bamum::LetterKi => LETTER_KI,
            Bamum::LetterMo => LETTER_MO,
            Bamum::LetterMbaa => LETTER_MBAA,
            Bamum::LetterTet => LETTER_TET,
            Bamum::LetterKpa => LETTER_KPA,
            Bamum::LetterTen => LETTER_TEN,
            Bamum::LetterNtuu => LETTER_NTUU,
            Bamum::LetterSamba => LETTER_SAMBA,
            Bamum::LetterFaamae => LETTER_FAAMAE,
            Bamum::LetterKovuu => LETTER_KOVUU,
            Bamum::LetterKoghom => LETTER_KOGHOM,
            Bamum::CombiningMarkKoqndon => COMBINING_MARK_KOQNDON,
            Bamum::CombiningMarkTukwentis => COMBINING_MARK_TUKWENTIS,
            Bamum::Njaemli => NJAEMLI,
            Bamum::FullStop => FULL_STOP,
            Bamum::Colon => COLON,
            Bamum::Comma => COMMA,
            Bamum::Semicolon => SEMICOLON,
            Bamum::QuestionMark => QUESTION_MARK,
        }
    }
}

impl std::convert::TryFrom<char> for Bamum {
    type Error = ();
    fn try_from(c: char) -> Result<Self, Self::Error> {
        use constants::*;
        match c {
            LETTER_A => Ok(Bamum::LetterA),
            LETTER_KA => Ok(Bamum::LetterKa),
            LETTER_U => Ok(Bamum::LetterU),
            LETTER_KU => Ok(Bamum::LetterKu),
            LETTER_EE => Ok(Bamum::LetterEe),
            LETTER_REE => Ok(Bamum::LetterRee),
            LETTER_TAE => Ok(Bamum::LetterTae),
            LETTER_O => Ok(Bamum::LetterO),
            LETTER_NYI => Ok(Bamum::LetterNyi),
            LETTER_I => Ok(Bamum::LetterI),
            LETTER_LA => Ok(Bamum::LetterLa),
            LETTER_PA => Ok(Bamum::LetterPa),
            LETTER_RII => Ok(Bamum::LetterRii),
            LETTER_RIEE => Ok(Bamum::LetterRiee),
            LETTER_LEEEE => Ok(Bamum::LetterLeeee),
            LETTER_MEEEE => Ok(Bamum::LetterMeeee),
            LETTER_TAA => Ok(Bamum::LetterTaa),
            LETTER_NDAA => Ok(Bamum::LetterNdaa),
            LETTER_NJAEM => Ok(Bamum::LetterNjaem),
            LETTER_M => Ok(Bamum::LetterM),
            LETTER_SUU => Ok(Bamum::LetterSuu),
            LETTER_MU => Ok(Bamum::LetterMu),
            LETTER_SHII => Ok(Bamum::LetterShii),
            LETTER_SI => Ok(Bamum::LetterSi),
            LETTER_SHEUX => Ok(Bamum::LetterSheux),
            LETTER_SEUX => Ok(Bamum::LetterSeux),
            LETTER_KYEE => Ok(Bamum::LetterKyee),
            LETTER_KET => Ok(Bamum::LetterKet),
            LETTER_NUAE => Ok(Bamum::LetterNuae),
            LETTER_NU => Ok(Bamum::LetterNu),
            LETTER_NJUAE => Ok(Bamum::LetterNjuae),
            LETTER_YOQ => Ok(Bamum::LetterYoq),
            LETTER_SHU => Ok(Bamum::LetterShu),
            LETTER_YUQ => Ok(Bamum::LetterYuq),
            LETTER_YA => Ok(Bamum::LetterYa),
            LETTER_NSHA => Ok(Bamum::LetterNsha),
            LETTER_KEUX => Ok(Bamum::LetterKeux),
            LETTER_PEUX => Ok(Bamum::LetterPeux),
            LETTER_NJEE => Ok(Bamum::LetterNjee),
            LETTER_NTEE => Ok(Bamum::LetterNtee),
            LETTER_PUE => Ok(Bamum::LetterPue),
            LETTER_WUE => Ok(Bamum::LetterWue),
            LETTER_PEE => Ok(Bamum::LetterPee),
            LETTER_FEE => Ok(Bamum::LetterFee),
            LETTER_RU => Ok(Bamum::LetterRu),
            LETTER_LU => Ok(Bamum::LetterLu),
            LETTER_MI => Ok(Bamum::LetterMi),
            LETTER_NI => Ok(Bamum::LetterNi),
            LETTER_REUX => Ok(Bamum::LetterReux),
            LETTER_RAE => Ok(Bamum::LetterRae),
            LETTER_KEN => Ok(Bamum::LetterKen),
            LETTER_NGKWAEN => Ok(Bamum::LetterNgkwaen),
            LETTER_NGGA => Ok(Bamum::LetterNgga),
            LETTER_NGA => Ok(Bamum::LetterNga),
            LETTER_SHO => Ok(Bamum::LetterSho),
            LETTER_PUAE => Ok(Bamum::LetterPuae),
            LETTER_FU => Ok(Bamum::LetterFu),
            LETTER_FOM => Ok(Bamum::LetterFom),
            LETTER_WA => Ok(Bamum::LetterWa),
            LETTER_NA => Ok(Bamum::LetterNa),
            LETTER_LI => Ok(Bamum::LetterLi),
            LETTER_PI => Ok(Bamum::LetterPi),
            LETTER_LOQ => Ok(Bamum::LetterLoq),
            LETTER_KO => Ok(Bamum::LetterKo),
            LETTER_MBEN => Ok(Bamum::LetterMben),
            LETTER_REN => Ok(Bamum::LetterRen),
            LETTER_MEN => Ok(Bamum::LetterMen),
            LETTER_MA => Ok(Bamum::LetterMa),
            LETTER_TI => Ok(Bamum::LetterTi),
            LETTER_KI => Ok(Bamum::LetterKi),
            LETTER_MO => Ok(Bamum::LetterMo),
            LETTER_MBAA => Ok(Bamum::LetterMbaa),
            LETTER_TET => Ok(Bamum::LetterTet),
            LETTER_KPA => Ok(Bamum::LetterKpa),
            LETTER_TEN => Ok(Bamum::LetterTen),
            LETTER_NTUU => Ok(Bamum::LetterNtuu),
            LETTER_SAMBA => Ok(Bamum::LetterSamba),
            LETTER_FAAMAE => Ok(Bamum::LetterFaamae),
            LETTER_KOVUU => Ok(Bamum::LetterKovuu),
            LETTER_KOGHOM => Ok(Bamum::LetterKoghom),
            COMBINING_MARK_KOQNDON => Ok(Bamum::CombiningMarkKoqndon),
            COMBINING_MARK_TUKWENTIS => Ok(Bamum::CombiningMarkTukwentis),
            NJAEMLI => Ok(Bamum::Njaemli),
            FULL_STOP => Ok(Bamum::FullStop),
            COLON => Ok(Bamum::Colon),
            COMMA => Ok(Bamum::Comma),
            SEMICOLON => Ok(Bamum::Semicolon),
            QUESTION_MARK => Ok(Bamum::QuestionMark),
            _ => Err(()),
        }
    }
}

impl Into<u32> for Bamum {
    fn into(self) -> u32 {
        let c: char = self.into();
        let hex = c
            .escape_unicode()
            .to_string()
            .replace("\\u{", "")
            .replace("}", "");
        u32::from_str_radix(&hex, 16).unwrap()
    }
}

impl std::convert::TryFrom<u32> for Bamum {
    type Error = ();
    fn try_from(u: u32) -> Result<Self, Self::Error> {
        if let Ok(c) = char::try_from(u) {
            Self::try_from(c)
        } else {
            Err(())
        }
    }
}

impl Iterator for Bamum {
    type Item = Self;
    fn next(&mut self) -> Option<Self> {
        let index: u32 = (*self).into();
        use std::convert::TryFrom;
        Self::try_from(index + 1).ok()
    }
}

impl Bamum {
    /// The character with the lowest index in this unicode block
    pub fn new() -> Self {
        Bamum::LetterA
    }

    /// The character's name, all lowercase and space-separated
    pub fn name(&self) -> &str {
        match self {
            Bamum::LetterA => "bamum letter a",
            Bamum::LetterKa => "bamum letter ka",
            Bamum::LetterU => "bamum letter u",
            Bamum::LetterKu => "bamum letter ku",
            Bamum::LetterEe => "bamum letter ee",
            Bamum::LetterRee => "bamum letter ree",
            Bamum::LetterTae => "bamum letter tae",
            Bamum::LetterO => "bamum letter o",
            Bamum::LetterNyi => "bamum letter nyi",
            Bamum::LetterI => "bamum letter i",
            Bamum::LetterLa => "bamum letter la",
            Bamum::LetterPa => "bamum letter pa",
            Bamum::LetterRii => "bamum letter rii",
            Bamum::LetterRiee => "bamum letter riee",
            Bamum::LetterLeeee => "bamum letter leeee",
            Bamum::LetterMeeee => "bamum letter meeee",
            Bamum::LetterTaa => "bamum letter taa",
            Bamum::LetterNdaa => "bamum letter ndaa",
            Bamum::LetterNjaem => "bamum letter njaem",
            Bamum::LetterM => "bamum letter m",
            Bamum::LetterSuu => "bamum letter suu",
            Bamum::LetterMu => "bamum letter mu",
            Bamum::LetterShii => "bamum letter shii",
            Bamum::LetterSi => "bamum letter si",
            Bamum::LetterSheux => "bamum letter sheux",
            Bamum::LetterSeux => "bamum letter seux",
            Bamum::LetterKyee => "bamum letter kyee",
            Bamum::LetterKet => "bamum letter ket",
            Bamum::LetterNuae => "bamum letter nuae",
            Bamum::LetterNu => "bamum letter nu",
            Bamum::LetterNjuae => "bamum letter njuae",
            Bamum::LetterYoq => "bamum letter yoq",
            Bamum::LetterShu => "bamum letter shu",
            Bamum::LetterYuq => "bamum letter yuq",
            Bamum::LetterYa => "bamum letter ya",
            Bamum::LetterNsha => "bamum letter nsha",
            Bamum::LetterKeux => "bamum letter keux",
            Bamum::LetterPeux => "bamum letter peux",
            Bamum::LetterNjee => "bamum letter njee",
            Bamum::LetterNtee => "bamum letter ntee",
            Bamum::LetterPue => "bamum letter pue",
            Bamum::LetterWue => "bamum letter wue",
            Bamum::LetterPee => "bamum letter pee",
            Bamum::LetterFee => "bamum letter fee",
            Bamum::LetterRu => "bamum letter ru",
            Bamum::LetterLu => "bamum letter lu",
            Bamum::LetterMi => "bamum letter mi",
            Bamum::LetterNi => "bamum letter ni",
            Bamum::LetterReux => "bamum letter reux",
            Bamum::LetterRae => "bamum letter rae",
            Bamum::LetterKen => "bamum letter ken",
            Bamum::LetterNgkwaen => "bamum letter ngkwaen",
            Bamum::LetterNgga => "bamum letter ngga",
            Bamum::LetterNga => "bamum letter nga",
            Bamum::LetterSho => "bamum letter sho",
            Bamum::LetterPuae => "bamum letter puae",
            Bamum::LetterFu => "bamum letter fu",
            Bamum::LetterFom => "bamum letter fom",
            Bamum::LetterWa => "bamum letter wa",
            Bamum::LetterNa => "bamum letter na",
            Bamum::LetterLi => "bamum letter li",
            Bamum::LetterPi => "bamum letter pi",
            Bamum::LetterLoq => "bamum letter loq",
            Bamum::LetterKo => "bamum letter ko",
            Bamum::LetterMben => "bamum letter mben",
            Bamum::LetterRen => "bamum letter ren",
            Bamum::LetterMen => "bamum letter men",
            Bamum::LetterMa => "bamum letter ma",
            Bamum::LetterTi => "bamum letter ti",
            Bamum::LetterKi => "bamum letter ki",
            Bamum::LetterMo => "bamum letter mo",
            Bamum::LetterMbaa => "bamum letter mbaa",
            Bamum::LetterTet => "bamum letter tet",
            Bamum::LetterKpa => "bamum letter kpa",
            Bamum::LetterTen => "bamum letter ten",
            Bamum::LetterNtuu => "bamum letter ntuu",
            Bamum::LetterSamba => "bamum letter samba",
            Bamum::LetterFaamae => "bamum letter faamae",
            Bamum::LetterKovuu => "bamum letter kovuu",
            Bamum::LetterKoghom => "bamum letter koghom",
            Bamum::CombiningMarkKoqndon => "bamum combining mark koqndon",
            Bamum::CombiningMarkTukwentis => "bamum combining mark tukwentis",
            Bamum::Njaemli => "bamum njaemli",
            Bamum::FullStop => "bamum full stop",
            Bamum::Colon => "bamum colon",
            Bamum::Comma => "bamum comma",
            Bamum::Semicolon => "bamum semicolon",
            Bamum::QuestionMark => "bamum question mark",
        }
    }
}