hello world

6 files changed, 18603 insertions, 0 deletions

diff --git a/src/emitter.rs b/src/emitter.rs
new file mode 100644
index 0000000..5bf1e0a
--- /dev/null
+++ b/src/emitter.rs
@@ -0,0 +1,493 @@
+use std::collections::BTreeMap;
+use std::collections::BTreeSet;
+use std::collections::VecDeque;
+use std::mem;
+
+use crate::Error;
+
+/// An emitter is an object providing methods to the tokenizer to produce tokens.
+///
+/// Domain-specific applications of the HTML tokenizer can manually implement this trait to
+/// customize per-token allocations, or avoid them altogether.
+///
+/// An emitter is assumed to have these internal states:
+///
+/// * _last start tag_: The most recently emitted start tag's name
+/// * _current token_: Can be a tag, doctype or comment token. There's only one current token.
+/// * _current attribute_: The currently processed HTML attribute, consisting of two strings for name and value.
+///
+/// The following methods are describing what kind of behavior the WHATWG spec expects, but that
+/// doesn't mean you need to follow it. For example:
+///
+/// * If your usage of the tokenizer will ignore all errors, none of the error handling and
+///   validation requirements apply to you. You can implement `emit_error` as noop and omit all
+///   checks that would emit errors.
+///
+/// * If you don't care about attributes at all, you can make all related methods a noop.
+///
+/// The state machine needs to have a functional implementation of
+/// `current_is_appropriate_end_tag_token` to do correct transitions, however.
+pub trait Emitter {
+    /// The token type emitted by this emitter. This controls what type of values the [`crate::Tokenizer`]
+    /// yields when used as an iterator.
+    type Token;
+
+    /// Set the name of the _last start tag_.
+    ///
+    /// This is primarily for testing purposes. This is *not* supposed to override the tag name of
+    /// the current tag.
+    fn set_last_start_tag(&mut self, last_start_tag: Option<&str>);
+
+    /// The state machine has reached the end of the file. It will soon call `pop_token` for the
+    /// last time.
+    fn emit_eof(&mut self);
+
+    /// A (probably recoverable) parsing error has occured.
+    fn emit_error(&mut self, error: Error);
+
+    /// After every state change, the tokenizer calls this method to retrieve a new token that can
+    /// be returned via the tokenizer's iterator interface.
+    fn pop_token(&mut self) -> Option<Self::Token>;
+
+    /// Emit a bunch of plain characters as character tokens.
+    fn emit_string(&mut self, c: &str);
+
+    /// Set the _current token_ to a start tag.
+    fn init_start_tag(&mut self);
+
+    /// Set the _current token_ to an end tag.
+    fn init_end_tag(&mut self);
+
+    /// Set the _current token_ to a comment.
+    fn init_comment(&mut self);
+
+    /// Emit the _current token_, assuming it is a tag.
+    ///
+    /// Also get the current attribute and append it to the to-be-emitted tag. See docstring for
+    /// [`Emitter::init_attribute`] for how duplicates should be handled.
+    ///
+    /// If a start tag is emitted, update the _last start tag_.
+    ///
+    /// If the current token is not a start/end tag, this method may panic.
+    fn emit_current_tag(&mut self);
+
+    /// Emit the _current token_, assuming it is a comment.
+    ///
+    /// If the current token is not a comment, this method may panic.
+    fn emit_current_comment(&mut self);
+
+    /// Emit the _current token_, assuming it is a doctype.
+    ///
+    /// If the current token is not a doctype, this method may panic.
+    fn emit_current_doctype(&mut self);
+
+    /// Assuming the _current token_ is a start tag, set the self-closing flag.
+    ///
+    /// If the current token is not a start or end tag, this method may panic.
+    ///
+    /// If the current token is an end tag, the emitter should emit the
+    /// [`crate::Error::EndTagWithTrailingSolidus`] error.
+    fn set_self_closing(&mut self);
+
+    /// Assuming the _current token_ is a doctype, set its "force quirks" flag to true.
+    ///
+    /// If the current token is not a doctype, this method pay panic.
+    fn set_force_quirks(&mut self);
+
+    /// Assuming the _current token_ is a start/end tag, append a string to the current tag's name.
+    ///
+    /// If the current token is not a start or end tag, this method may panic.
+    fn push_tag_name(&mut self, s: &str);
+
+    /// Assuming the _current token_ is a comment, append a string to the comment's contents.
+    ///
+    /// If the current token is not a comment, this method may panic.
+    fn push_comment(&mut self, s: &str);
+
+    /// Assuming the _current token_ is a doctype, append a string to the doctype's name.
+    ///
+    /// If the current token is not a doctype, this method may panic.
+    fn push_doctype_name(&mut self, s: &str);
+
+    /// Set the _current token_ to a new doctype token:
+    ///
+    /// * the name should be empty
+    /// * the "public identifier" should be null (different from empty)
+    /// * the "system identifier" should be null (different from empty)
+    /// * the "force quirks" flag should be `false`
+    fn init_doctype(&mut self);
+
+    /// Set the _current attribute_ to a new one, starting with empty name and value strings.
+    ///
+    /// The old attribute, if any, should be put on the _current token_. If an attribute with that
+    /// name already exists, WHATWG says the new one should be ignored and a
+    /// [`crate::Error::DuplicateAttribute`] error should be emitted.
+    ///
+    /// If the current token is an end tag token, a [`crate::Error::EndTagWithAttributes`] error should be
+    /// emitted.
+    ///
+    /// If the current token is no tag at all, this method may panic.
+    fn init_attribute(&mut self);
+
+    /// Append a string to the current attribute's name.
+    ///
+    /// If there is no current attribute, this method may panic.
+    fn push_attribute_name(&mut self, s: &str);
+
+    /// Append a string to the current attribute's value.
+    ///
+    /// If there is no current attribute, this method may panic.
+    fn push_attribute_value(&mut self, s: &str);
+
+    /// Assuming the _current token_ is a doctype, set its "public identifier" to the given string.
+    ///
+    /// If the current token is not a doctype, this method may panic.
+    fn set_doctype_public_identifier(&mut self, value: &str);
+
+    /// Assuming the _current token_ is a doctype, set its "system identifier" to the given string.
+    ///
+    /// If the current token is not a doctype, this method may panic.
+    fn set_doctype_system_identifier(&mut self, value: &str);
+
+    /// Assuming the _current token_ is a doctype, append a string to its "public identifier" to the given string.
+    ///
+    /// If the current token is not a doctype, this method may panic.
+    fn push_doctype_public_identifier(&mut self, s: &str);
+
+    /// Assuming the _current token_ is a doctype, append a string to its "system identifier" to the given string.
+    ///
+    /// If the current token is not a doctype, this method may panic.
+    fn push_doctype_system_identifier(&mut self, s: &str);
+
+    /// Return true if all of these hold. Return false otherwise.
+    ///
+    /// * the _current token_ is an end tag
+    /// * the _last start tag_ exists
+    /// * the current end tag token's name equals to the last start tag's name.
+    ///
+    /// See also [WHATWG's definition of "appropriate end tag
+    /// token"](https://html.spec.whatwg.org/#appropriate-end-tag-token).
+    fn current_is_appropriate_end_tag_token(&mut self) -> bool;
+}
+
+/// The default implementation of [`crate::Emitter`], used to produce ("emit") tokens.
+pub struct DefaultEmitter {
+    current_characters: String,
+    current_token: Option<Token>,
+    last_start_tag: String,
+    current_attribute: Option<(String, String)>,
+    seen_attributes: BTreeSet<String>,
+    emitted_tokens: VecDeque<Token>,
+}
+
+impl Default for DefaultEmitter {
+    fn default() -> Self {
+        DefaultEmitter {
+            current_characters: String::new(),
+            current_token: None,
+            last_start_tag: String::new(),
+            current_attribute: None,
+            seen_attributes: BTreeSet::new(),
+            emitted_tokens: VecDeque::new(),
+        }
+    }
+}
+
+impl DefaultEmitter {
+    fn emit_token(&mut self, token: Token) {
+        self.flush_current_characters();
+        self.emitted_tokens.push_front(token);
+    }
+
+    fn flush_current_attribute(&mut self) {
+        if let Some((k, v)) = self.current_attribute.take() {
+            match self.current_token {
+                Some(Token::StartTag(ref mut tag)) => {
+                    let mut error = None;
+                    tag.attributes
+                        .entry(k)
+                        .and_modify(|_| {
+                            error = Some(Error::DuplicateAttribute);
+                        })
+                        .or_insert(v);
+
+                    if let Some(e) = error {
+                        self.emit_error(e);
+                    }
+                }
+                Some(Token::EndTag(_)) => {
+                    if !self.seen_attributes.insert(k) {
+                        self.emit_error(Error::DuplicateAttribute);
+                    }
+                }
+                _ => {
+                    debug_assert!(false);
+                }
+            }
+        }
+    }
+
+    fn flush_current_characters(&mut self) {
+        if self.current_characters.is_empty() {
+            return;
+        }
+
+        let s = mem::take(&mut self.current_characters);
+        self.emit_token(Token::String(s));
+    }
+}
+
+impl Emitter for DefaultEmitter {
+    type Token = Token;
+
+    fn set_last_start_tag(&mut self, last_start_tag: Option<&str>) {
+        self.last_start_tag.clear();
+        self.last_start_tag
+            .push_str(last_start_tag.unwrap_or_default());
+    }
+
+    fn emit_eof(&mut self) {
+        self.flush_current_characters();
+    }
+
+    fn emit_error(&mut self, error: Error) {
+        // bypass character flushing in self.emit_token: we don't need the error location to be
+        // that exact
+        self.emitted_tokens.push_front(Token::Error(error));
+    }
+
+    fn pop_token(&mut self) -> Option<Self::Token> {
+        self.emitted_tokens.pop_back()
+    }
+
+    fn emit_string(&mut self, s: &str) {
+        self.current_characters.push_str(s);
+    }
+
+    fn init_start_tag(&mut self) {
+        self.current_token = Some(Token::StartTag(Default::default()));
+    }
+    fn init_end_tag(&mut self) {
+        self.current_token = Some(Token::EndTag(Default::default()));
+        self.seen_attributes.clear();
+    }
+
+    fn init_comment(&mut self) {
+        self.current_token = Some(Token::Comment(String::new()));
+    }
+    fn emit_current_tag(&mut self) {
+        self.flush_current_attribute();
+        let mut token = self.current_token.take().unwrap();
+        match token {
+            Token::EndTag(_) => {
+                if !self.seen_attributes.is_empty() {
+                    self.emit_error(Error::EndTagWithAttributes);
+                }
+                self.seen_attributes.clear();
+            }
+            Token::StartTag(ref mut _tag) => {
+                self.set_last_start_tag(Some(&_tag.name));
+            }
+            _ => debug_assert!(false),
+        }
+        self.emit_token(token);
+    }
+    fn emit_current_comment(&mut self) {
+        let comment = self.current_token.take().unwrap();
+        debug_assert!(matches!(comment, Token::Comment(_)));
+        self.emit_token(comment);
+    }
+
+    fn emit_current_doctype(&mut self) {
+        let doctype = self.current_token.take().unwrap();
+        debug_assert!(matches!(doctype, Token::Doctype(_)));
+        self.emit_token(doctype);
+    }
+
+    fn set_self_closing(&mut self) {
+        let tag = self.current_token.as_mut().unwrap();
+        match tag {
+            Token::StartTag(StartTag {
+                ref mut self_closing,
+                ..
+            }) => {
+                *self_closing = true;
+            }
+            Token::EndTag(_) => {
+                self.emit_error(Error::EndTagWithTrailingSolidus);
+            }
+            _ => {
+                debug_assert!(false);
+            }
+        }
+    }
+    fn set_force_quirks(&mut self) {
+        match self.current_token {
+            Some(Token::Doctype(ref mut doctype)) => doctype.force_quirks = true,
+            _ => debug_assert!(false),
+        }
+    }
+    fn push_tag_name(&mut self, s: &str) {
+        match self.current_token {
+            Some(Token::StartTag(StartTag { ref mut name, .. })) => {
+                name.push_str(s);
+            }
+            Some(Token::EndTag(EndTag { ref mut name, .. })) => {
+                name.push_str(s);
+            }
+            _ => debug_assert!(false),
+        }
+    }
+
+    fn push_comment(&mut self, s: &str) {
+        match self.current_token {
+            Some(Token::Comment(ref mut data)) => data.push_str(s),
+            _ => debug_assert!(false),
+        }
+    }
+
+    fn push_doctype_name(&mut self, s: &str) {
+        match self.current_token {
+            Some(Token::Doctype(ref mut doctype)) => doctype.name.push_str(s),
+            _ => debug_assert!(false),
+        }
+    }
+    fn init_doctype(&mut self) {
+        self.current_token = Some(Token::Doctype(Doctype {
+            name: String::new(),
+            force_quirks: false,
+            public_identifier: None,
+            system_identifier: None,
+        }));
+    }
+
+    fn init_attribute(&mut self) {
+        self.flush_current_attribute();
+        self.current_attribute = Some((String::new(), String::new()));
+    }
+    fn push_attribute_name(&mut self, s: &str) {
+        self.current_attribute.as_mut().unwrap().0.push_str(s);
+    }
+    fn push_attribute_value(&mut self, s: &str) {
+        self.current_attribute.as_mut().unwrap().1.push_str(s);
+    }
+    fn set_doctype_public_identifier(&mut self, value: &str) {
+        if let Some(Token::Doctype(Doctype {
+            ref mut public_identifier,
+            ..
+        })) = self.current_token
+        {
+            *public_identifier = Some(value.to_owned());
+        } else {
+            debug_assert!(false);
+        }
+    }
+    fn set_doctype_system_identifier(&mut self, value: &str) {
+        if let Some(Token::Doctype(Doctype {
+            ref mut system_identifier,
+            ..
+        })) = self.current_token
+        {
+            *system_identifier = Some(value.to_owned());
+        } else {
+            debug_assert!(false);
+        }
+    }
+    fn push_doctype_public_identifier(&mut self, s: &str) {
+        if let Some(Token::Doctype(Doctype {
+            public_identifier: Some(ref mut id),
+            ..
+        })) = self.current_token
+        {
+            id.push_str(s);
+        } else {
+            debug_assert!(false);
+        }
+    }
+    fn push_doctype_system_identifier(&mut self, s: &str) {
+        if let Some(Token::Doctype(Doctype {
+            system_identifier: Some(ref mut id),
+            ..
+        })) = self.current_token
+        {
+            id.push_str(s);
+        } else {
+            debug_assert!(false);
+        }
+    }
+
+    fn current_is_appropriate_end_tag_token(&mut self) -> bool {
+        match self.current_token {
+            Some(Token::EndTag(ref tag)) => {
+                !self.last_start_tag.is_empty() && self.last_start_tag == tag.name
+            }
+            _ => false,
+        }
+    }
+}
+
+/// A HTML end/close tag, such as `<p>` or `<a>`.
+#[derive(Debug, Default, Eq, PartialEq)]
+pub struct StartTag {
+    /// Whether this tag is self-closing. If it is self-closing, no following [`EndTag`] should be
+    /// expected.
+    pub self_closing: bool,
+
+    /// The start tag's name, such as `"p"` or `"a"`.
+    pub name: String,
+
+    /// A mapping for any HTML attributes this start tag may have.
+    ///
+    /// Duplicate attributes are ignored after the first one as per WHATWG spec. Implement your own
+    /// [`Emitter`] to tweak this behavior.
+    pub attributes: BTreeMap<String, String>,
+}
+
+/// A HTML end/close tag, such as `</p>` or `</a>`.
+#[derive(Debug, Default, Eq, PartialEq)]
+pub struct EndTag {
+    /// The ending tag's name, such as `"p"` or `"a"`.
+    pub name: String,
+}
+
+/// A doctype. Some examples:
+///
+/// * `<!DOCTYPE {name}>`
+/// * `<!DOCTYPE {name} PUBLIC '{public_identifier}'>`
+/// * `<!DOCTYPE {name} SYSTEM '{system_identifier}'>`
+/// * `<!DOCTYPE {name} PUBLIC '{public_identifier}' '{system_identifier}'>`
+#[derive(Debug, Eq, PartialEq)]
+pub struct Doctype {
+    /// The ["force quirks"](https://html.spec.whatwg.org/#force-quirks-flag) flag.
+    pub force_quirks: bool,
+
+    /// The doctype's name. For HTML documents this is "html".
+    pub name: String,
+
+    /// The doctype's public identifier.
+    pub public_identifier: Option<String>,
+
+    /// The doctype's system identifier.
+    pub system_identifier: Option<String>,
+}
+
+/// The token type used by default. You can define your own token type by implementing the
+/// [`crate::Emitter`] trait and using [`crate::Tokenizer::new_with_emitter`].
+#[derive(Debug, Eq, PartialEq)]
+pub enum Token {
+    /// A HTML start tag.
+    StartTag(StartTag),
+    /// A HTML end tag.
+    EndTag(EndTag),
+    /// A literal string.
+    String(String),
+    /// A HTML comment.
+    Comment(String),
+    /// A HTML doctype declaration.
+    Doctype(Doctype),
+    /// A HTML parsing error.
+    ///
+    /// Can be skipped over, the tokenizer is supposed to recover from the error and continues with
+    /// more tokens afterward.
+    Error(Error),
+}
diff --git a/src/entities.rs b/src/entities.rs
new file mode 100644
index 0000000..1ab3ffb
--- /dev/null
+++ b/src/entities.rs
@@ -0,0 +1,15633 @@
+// @generated
+// this file is autogenerated by
+// curl https://html.spec.whatwg.org/entities.json | python generate_entities.py
+
+pub struct CharRef {
+    /// Name as it appears escaped in HTML
+    pub name: &'static str,
+    /// Unescaped character codepoints
+    pub characters: &'static str,
+}
+
+pub fn try_read_character_reference(
+    first_char: char,
+    mut try_read: impl FnMut(&str) -> bool,
+) -> Option<CharRef> {
+    if first_char == 'C' && try_read("ounterClockwiseContourIntegral;") {
+        return Some(CharRef {
+            name: "ounterClockwiseContourIntegral;",
+            characters: "\u{2233}",
+        });
+    }
+
+    if first_char == 'C' && try_read("lockwiseContourIntegral;") {
+        return Some(CharRef {
+            name: "lockwiseContourIntegral;",
+            characters: "\u{2232}",
+        });
+    }
+
+    if first_char == 'D' && try_read("oubleLongLeftRightArrow;") {
+        return Some(CharRef {
+            name: "oubleLongLeftRightArrow;",
+            characters: "\u{27fa}",
+        });
+    }
+
+    if first_char == 'N' && try_read("otNestedGreaterGreater;") {
+        return Some(CharRef {
+            name: "otNestedGreaterGreater;",
+            characters: "\u{2aa2}\u{338}",
+        });
+    }
+
+    if first_char == 'D' && try_read("iacriticalDoubleAcute;") {
+        return Some(CharRef {
+            name: "iacriticalDoubleAcute;",
+            characters: "\u{2dd}",
+        });
+    }
+
+    if first_char == 'N' && try_read("otSquareSupersetEqual;") {
+        return Some(CharRef {
+            name: "otSquareSupersetEqual;",
+            characters: "\u{22e3}",
+        });
+    }
+
+    if first_char == 'C' && try_read("loseCurlyDoubleQuote;") {
+        return Some(CharRef {
+            name: "loseCurlyDoubleQuote;",
+            characters: "\u{201d}",
+        });
+    }
+
+    if first_char == 'D' && try_read("oubleContourIntegral;") {
+        return Some(CharRef {
+            name: "oubleContourIntegral;",
+            characters: "\u{222f}",
+        });
+    }
+
+    if first_char == 'F' && try_read("illedVerySmallSquare;") {
+        return Some(CharRef {
+            name: "illedVerySmallSquare;",
+            characters: "\u{25aa}",
+        });
+    }
+
+    if first_char == 'N' && try_read("egativeVeryThinSpace;") {
+        return Some(CharRef {
+            name: "egativeVeryThinSpace;",
+            characters: "\u{200b}",
+        });
+    }
+
+    if first_char == 'N' && try_read("otPrecedesSlantEqual;") {
+        return Some(CharRef {
+            name: "otPrecedesSlantEqual;",
+            characters: "\u{22e0}",
+        });
+    }
+
+    if first_char == 'N' && try_read("otRightTriangleEqual;") {
+        return Some(CharRef {
+            name: "otRightTriangleEqual;",
+            characters: "\u{22ed}",
+        });
+    }
+
+    if first_char == 'N' && try_read("otSucceedsSlantEqual;") {
+        return Some(CharRef {
+            name: "otSucceedsSlantEqual;",
+            characters: "\u{22e1}",
+        });
+    }
+
+    if first_char == 'C' && try_read("apitalDifferentialD;") {
+        return Some(CharRef {
+            name: "apitalDifferentialD;",
+            characters: "\u{2145}",
+        });
+    }
+
+    if first_char == 'D' && try_read("oubleLeftRightArrow;") {
+        return Some(CharRef {
+            name: "oubleLeftRightArrow;",
+            characters: "\u{21d4}",
+        });
+    }
+
+    if first_char == 'D' && try_read("oubleLongRightArrow;") {
+        return Some(CharRef {
+            name: "oubleLongRightArrow;",
+            characters: "\u{27f9}",
+        });
+    }
+
+    if first_char == 'E' && try_read("mptyVerySmallSquare;") {
+        return Some(CharRef {
+            name: "mptyVerySmallSquare;",
+            characters: "\u{25ab}",
+        });
+    }
+
+    if first_char == 'N' && try_read("estedGreaterGreater;") {
+        return Some(CharRef {
+            name: "estedGreaterGreater;",
+            characters: "\u{226b}",
+        });
+    }
+
+    if first_char == 'N' && try_read("otDoubleVerticalBar;") {
+        return Some(CharRef {
+            name: "otDoubleVerticalBar;",
+            characters: "\u{2226}",
+        });
+    }
+
+    if first_char == 'N' && try_read("otGreaterSlantEqual;") {
+        return Some(CharRef {
+            name: "otGreaterSlantEqual;",
+            characters: "\u{2a7e}\u{338}",
+        });
+    }
+
+    if first_char == 'N' && try_read("otLeftTriangleEqual;") {
+        return Some(CharRef {
+            name: "otLeftTriangleEqual;",
+            characters: "\u{22ec}",
+        });
+    }
+
+    if first_char == 'N' && try_read("otSquareSubsetEqual;") {
+        return Some(CharRef {
+            name: "otSquareSubsetEqual;",
+            characters: "\u{22e2}",
+        });
+    }
+
+    if first_char == 'O' && try_read("penCurlyDoubleQuote;") {
+        return Some(CharRef {
+            name: "penCurlyDoubleQuote;",
+            characters: "\u{201c}",
+        });
+    }
+
+    if first_char == 'R' && try_read("everseUpEquilibrium;") {
+        return Some(CharRef {
+            name: "everseUpEquilibrium;",
+            characters: "\u{296f}",
+        });
+    }
+
+    if first_char == 'D' && try_read("oubleLongLeftArrow;") {
+        return Some(CharRef {
+            name: "oubleLongLeftArrow;",
+            characters: "\u{27f8}",
+        });
+    }
+
+    if first_char == 'D' && try_read("ownLeftRightVector;") {
+        return Some(CharRef {
+            name: "ownLeftRightVector;",
+            characters: "\u{2950}",
+        });
+    }
+
+    if first_char == 'L' && try_read("eftArrowRightArrow;") {
+        return Some(CharRef {
+            name: "eftArrowRightArrow;",
+            characters: "\u{21c6}",
+        });
+    }
+
+    if first_char == 'N' && try_read("egativeMediumSpace;") {
+        return Some(CharRef {
+            name: "egativeMediumSpace;",
+            characters: "\u{200b}",
+        });
+    }
+
+    if first_char == 'N' && try_read("otGreaterFullEqual;") {
+        return Some(CharRef {
+            name: "otGreaterFullEqual;",
+            characters: "\u{2267}\u{338}",
+        });
+    }
+
+    if first_char == 'N' && try_read("otRightTriangleBar;") {
+        return Some(CharRef {
+            name: "otRightTriangleBar;",
+            characters: "\u{29d0}\u{338}",
+        });
+    }
+
+    if first_char == 'R' && try_read("ightArrowLeftArrow;") {
+        return Some(CharRef {
+            name: "ightArrowLeftArrow;",
+            characters: "\u{21c4}",
+        });
+    }
+
+    if first_char == 'S' && try_read("quareSupersetEqual;") {
+        return Some(CharRef {
+            name: "quareSupersetEqual;",
+            characters: "\u{2292}",
+        });
+    }
+
+    if first_char == 'l' && try_read("eftrightsquigarrow;") {
+        return Some(CharRef {
+            name: "eftrightsquigarrow;",
+            characters: "\u{21ad}",
+        });
+    }
+
+    if first_char == 'D' && try_read("ownRightTeeVector;") {
+        return Some(CharRef {
+            name: "ownRightTeeVector;",
+            characters: "\u{295f}",
+        });
+    }
+
+    if first_char == 'D' && try_read("ownRightVectorBar;") {
+        return Some(CharRef {
+            name: "ownRightVectorBar;",
+            characters: "\u{2957}",
+        });
+    }
+
+    if first_char == 'L' && try_read("ongLeftRightArrow;") {
+        return Some(CharRef {
+            name: "ongLeftRightArrow;",
+            characters: "\u{27f7}",
+        });
+    }
+
+    if first_char == 'L' && try_read("ongleftrightarrow;") {
+        return Some(CharRef {
+            name: "ongleftrightarrow;",
+            characters: "\u{27fa}",
+        });
+    }
+
+    if first_char == 'N' && try_read("egativeThickSpace;") {
+        return Some(CharRef {
+            name: "egativeThickSpace;",
+            characters: "\u{200b}",
+        });
+    }
+
+    if first_char == 'N' && try_read("otLeftTriangleBar;") {
+        return Some(CharRef {
+            name: "otLeftTriangleBar;",
+            characters: "\u{29cf}\u{338}",
+        });
+    }
+
+    if first_char == 'P' && try_read("recedesSlantEqual;") {
+        return Some(CharRef {
+            name: "recedesSlantEqual;",
+            characters: "\u{227c}",
+        });
+    }
+
+    if first_char == 'R' && try_read("everseEquilibrium;") {
+        return Some(CharRef {
+            name: "everseEquilibrium;",
+            characters: "\u{21cb}",
+        });
+    }
+
+    if first_char == 'R' && try_read("ightDoubleBracket;") {
+        return Some(CharRef {
+            name: "ightDoubleBracket;",
+            characters: "\u{27e7}",
+        });
+    }
+
+    if first_char == 'R' && try_read("ightDownTeeVector;") {
+        return Some(CharRef {
+            name: "ightDownTeeVector;",
+            characters: "\u{295d}",
+        });
+    }
+
+    if first_char == 'R' && try_read("ightDownVectorBar;") {
+        return Some(CharRef {
+            name: "ightDownVectorBar;",
+            characters: "\u{2955}",
+        });
+    }
+
+    if first_char == 'R' && try_read("ightTriangleEqual;") {
+        return Some(CharRef {
+            name: "ightTriangleEqual;",
+            characters: "\u{22b5}",
+        });
+    }
+
+    if first_char == 'S' && try_read("quareIntersection;") {
+        return Some(CharRef {
+            name: "quareIntersection;",
+            characters: "\u{2293}",
+        });
+    }
+
+    if first_char == 'S' && try_read("ucceedsSlantEqual;") {
+        return Some(CharRef {
+            name: "ucceedsSlantEqual;",
+            characters: "\u{227d}",
+        });
+    }
+
+    if first_char == 'b' && try_read("lacktriangleright;") {
+        return Some(CharRef {
+            name: "lacktriangleright;",
+            characters: "\u{25b8}",
+        });
+    }
+
+    if first_char == 'l' && try_read("ongleftrightarrow;") {
+        return Some(CharRef {
+            name: "ongleftrightarrow;",
+            characters: "\u{27f7}",
+        });
+    }
+
+    if first_char == 'D' && try_read("oubleUpDownArrow;") {
+        return Some(CharRef {
+            name: "oubleUpDownArrow;",
+            characters: "\u{21d5}",
+        });
+    }
+
+    if first_char == 'D' && try_read("oubleVerticalBar;") {
+        return Some(CharRef {
+            name: "oubleVerticalBar;",
+            characters: "\u{2225}",
+        });
+    }
+
+    if first_char == 'D' && try_read("ownLeftTeeVector;") {
+        return Some(CharRef {
+            name: "ownLeftTeeVector;",
+            characters: "\u{295e}",
+        });
+    }
+
+    if first_char == 'D' && try_read("ownLeftVectorBar;") {
+        return Some(CharRef {
+            name: "ownLeftVectorBar;",
+            characters: "\u{2956}",
+        });
+    }
+
+    if first_char == 'F' && try_read("illedSmallSquare;") {
+        return Some(CharRef {
+            name: "illedSmallSquare;",
+            characters: "\u{25fc}",
+        });
+    }
+
+    if first_char == 'G' && try_read("reaterSlantEqual;") {
+        return Some(CharRef {
+            name: "reaterSlantEqual;",
+            characters: "\u{2a7e}",
+        });
+    }
+
+    if first_char == 'L' && try_read("eftDoubleBracket;") {
+        return Some(CharRef {
+            name: "eftDoubleBracket;",
+            characters: "\u{27e6}",
+        });
+    }
+
+    if first_char == 'L' && try_read("eftDownTeeVector;") {
+        return Some(CharRef {
+            name: "eftDownTeeVector;",
+            characters: "\u{2961}",
+        });
+    }
+
+    if first_char == 'L' && try_read("eftDownVectorBar;") {
+        return Some(CharRef {
+            name: "eftDownVectorBar;",
+            characters: "\u{2959}",
+        });
+    }
+
+    if first_char == 'L' && try_read("eftTriangleEqual;") {
+        return Some(CharRef {
+            name: "eftTriangleEqual;",
+            characters: "\u{22b4}",
+        });
+    }
+
+    if first_char == 'N' && try_read("egativeThinSpace;") {
+        return Some(CharRef {
+            name: "egativeThinSpace;",
+            characters: "\u{200b}",
+        });
+    }
+
+    if first_char == 'N' && try_read("otGreaterGreater;") {
+        return Some(CharRef {
+            name: "otGreaterGreater;",
+            characters: "\u{226b}\u{338}",
+        });
+    }
+
+    if first_char == 'N' && try_read("otLessSlantEqual;") {
+        return Some(CharRef {
+            name: "otLessSlantEqual;",
+            characters: "\u{2a7d}\u{338}",
+        });
+    }
+
+    if first_char == 'N' && try_read("otNestedLessLess;") {
+        return Some(CharRef {
+            name: "otNestedLessLess;",
+            characters: "\u{2aa1}\u{338}",
+        });
+    }
+
+    if first_char == 'N' && try_read("otReverseElement;") {
+        return Some(CharRef {
+            name: "otReverseElement;",
+            characters: "\u{220c}",
+        });
+    }
+
+    if first_char == 'N' && try_read("otSquareSuperset;") {
+        return Some(CharRef {
+            name: "otSquareSuperset;",
+            characters: "\u{2290}\u{338}",
+        });
+    }
+
+    if first_char == 'N' && try_read("otTildeFullEqual;") {
+        return Some(CharRef {
+            name: "otTildeFullEqual;",
+            characters: "\u{2247}",
+        });
+    }
+
+    if first_char == 'R' && try_read("ightAngleBracket;") {
+        return Some(CharRef {
+            name: "ightAngleBracket;",
+            characters: "\u{27e9}",
+        });
+    }
+
+    if first_char == 'R' && try_read("ightUpDownVector;") {
+        return Some(CharRef {
+            name: "ightUpDownVector;",
+            characters: "\u{294f}",
+        });
+    }
+
+    if first_char == 'S' && try_read("quareSubsetEqual;") {
+        return Some(CharRef {
+            name: "quareSubsetEqual;",
+            characters: "\u{2291}",
+        });
+    }
+
+    if first_char == 'V' && try_read("erticalSeparator;") {
+        return Some(CharRef {
+            name: "erticalSeparator;",
+            characters: "\u{2758}",
+        });
+    }
+
+    if first_char == 'b' && try_read("lacktriangledown;") {
+        return Some(CharRef {
+            name: "lacktriangledown;",
+            characters: "\u{25be}",
+        });
+    }
+
+    if first_char == 'b' && try_read("lacktriangleleft;") {
+        return Some(CharRef {
+            name: "lacktriangleleft;",
+            characters: "\u{25c2}",
+        });
+    }
+
+    if first_char == 'l' && try_read("eftrightharpoons;") {
+        return Some(CharRef {
+            name: "eftrightharpoons;",
+            characters: "\u{21cb}",
+        });
+    }
+
+    if first_char == 'r' && try_read("ightleftharpoons;") {
+        return Some(CharRef {
+            name: "ightleftharpoons;",
+            characters: "\u{21cc}",
+        });
+    }
+
+    if first_char == 't' && try_read("woheadrightarrow;") {
+        return Some(CharRef {
+            name: "woheadrightarrow;",
+            characters: "\u{21a0}",
+        });
+    }
+
+    if first_char == 'D' && try_read("iacriticalAcute;") {
+        return Some(CharRef {
+            name: "iacriticalAcute;",
+            characters: "\u{b4}",
+        });
+    }
+
+    if first_char == 'D' && try_read("iacriticalGrave;") {
+        return Some(CharRef {
+            name: "iacriticalGrave;",
+            characters: "\u{60}",
+        });
+    }
+
+    if first_char == 'D' && try_read("iacriticalTilde;") {
+        return Some(CharRef {
+            name: "iacriticalTilde;",
+            characters: "\u{2dc}",
+        });
+    }
+
+    if first_char == 'D' && try_read("oubleRightArrow;") {
+        return Some(CharRef {
+            name: "oubleRightArrow;",
+            characters: "\u{21d2}",
+        });
+    }
+
+    if first_char == 'D' && try_read("ownArrowUpArrow;") {
+        return Some(CharRef {
+            name: "ownArrowUpArrow;",
+            characters: "\u{21f5}",
+        });
+    }
+
+    if first_char == 'E' && try_read("mptySmallSquare;") {
+        return Some(CharRef {
+            name: "mptySmallSquare;",
+            characters: "\u{25fb}",
+        });
+    }
+
+    if first_char == 'G' && try_read("reaterEqualLess;") {
+        return Some(CharRef {
+            name: "reaterEqualLess;",
+            characters: "\u{22db}",
+        });
+    }
+
+    if first_char == 'G' && try_read("reaterFullEqual;") {
+        return Some(CharRef {
+            name: "reaterFullEqual;",
+            characters: "\u{2267}",
+        });
+    }
+
+    if first_char == 'L' && try_read("eftAngleBracket;") {
+        return Some(CharRef {
+            name: "eftAngleBracket;",
+            characters: "\u{27e8}",
+        });
+    }
+
+    if first_char == 'L' && try_read("eftUpDownVector;") {
+        return Some(CharRef {
+            name: "eftUpDownVector;",
+            characters: "\u{2951}",
+        });
+    }
+
+    if first_char == 'L' && try_read("essEqualGreater;") {
+        return Some(CharRef {
+            name: "essEqualGreater;",
+            characters: "\u{22da}",
+        });
+    }
+
+    if first_char == 'N' && try_read("onBreakingSpace;") {
+        return Some(CharRef {
+            name: "onBreakingSpace;",
+            characters: "\u{a0}",
+        });
+    }
+
+    if first_char == 'N' && try_read("otPrecedesEqual;") {
+        return Some(CharRef {
+            name: "otPrecedesEqual;",
+            characters: "\u{2aaf}\u{338}",
+        });
+    }
+
+    if first_char == 'N' && try_read("otRightTriangle;") {
+        return Some(CharRef {
+            name: "otRightTriangle;",
+            characters: "\u{22eb}",
+        });
+    }
+
+    if first_char == 'N' && try_read("otSucceedsEqual;") {
+        return Some(CharRef {
+            name: "otSucceedsEqual;",
+            characters: "\u{2ab0}\u{338}",
+        });
+    }
+
+    if first_char == 'N' && try_read("otSucceedsTilde;") {
+        return Some(CharRef {
+            name: "otSucceedsTilde;",
+            characters: "\u{227f}\u{338}",
+        });
+    }
+
+    if first_char == 'N' && try_read("otSupersetEqual;") {
+        return Some(CharRef {
+            name: "otSupersetEqual;",
+            characters: "\u{2289}",
+        });
+    }
+
+    if first_char == 'R' && try_read("ightTriangleBar;") {
+        return Some(CharRef {
+            name: "ightTriangleBar;",
+            characters: "\u{29d0}",
+        });
+    }
+
+    if first_char == 'R' && try_read("ightUpTeeVector;") {
+        return Some(CharRef {
+            name: "ightUpTeeVector;",
+            characters: "\u{295c}",
+        });
+    }
+
+    if first_char == 'R' && try_read("ightUpVectorBar;") {
+        return Some(CharRef {
+            name: "ightUpVectorBar;",
+            characters: "\u{2954}",
+        });
+    }
+
+    if first_char == 'U' && try_read("nderParenthesis;") {
+        return Some(CharRef {
+            name: "nderParenthesis;",
+            characters: "\u{23dd}",
+        });
+    }
+
+    if first_char == 'U' && try_read("pArrowDownArrow;") {
+        return Some(CharRef {
+            name: "pArrowDownArrow;",
+            characters: "\u{21c5}",
+        });
+    }
+
+    if first_char == 'c' && try_read("irclearrowright;") {
+        return Some(CharRef {
+            name: "irclearrowright;",
+            characters: "\u{21bb}",
+        });
+    }
+
+    if first_char == 'd' && try_read("ownharpoonright;") {
+        return Some(CharRef {
+            name: "ownharpoonright;",
+            characters: "\u{21c2}",
+        });
+    }
+
+    if first_char == 'n' && try_read("trianglerighteq;") {
+        return Some(CharRef {
+            name: "trianglerighteq;",
+            characters: "\u{22ed}",
+        });
+    }
+
+    if first_char == 'r' && try_read("ightharpoondown;") {
+        return Some(CharRef {
+            name: "ightharpoondown;",
+            characters: "\u{21c1}",
+        });
+    }
+
+    if first_char == 'r' && try_read("ightrightarrows;") {
+        return Some(CharRef {
+            name: "ightrightarrows;",
+            characters: "\u{21c9}",
+        });
+    }
+
+    if first_char == 't' && try_read("woheadleftarrow;") {
+        return Some(CharRef {
+            name: "woheadleftarrow;",
+            characters: "\u{219e}",
+        });
+    }
+
+    if first_char == 'v' && try_read("artriangleright;") {
+        return Some(CharRef {
+            name: "artriangleright;",
+            characters: "\u{22b3}",
+        });
+    }
+
+    if first_char == 'C' && try_read("loseCurlyQuote;") {
+        return Some(CharRef {
+            name: "loseCurlyQuote;",
+            characters: "\u{2019}",
+        });
+    }
+
+    if first_char == 'C' && try_read("ontourIntegral;") {
+        return Some(CharRef {
+            name: "ontourIntegral;",
+            characters: "\u{222e}",
+        });
+    }
+
+    if first_char == 'D' && try_read("oubleDownArrow;") {
+        return Some(CharRef {
+            name: "oubleDownArrow;",
+            characters: "\u{21d3}",
+        });
+    }
+
+    if first_char == 'D' && try_read("oubleLeftArrow;") {
+        return Some(CharRef {
+            name: "oubleLeftArrow;",
+            characters: "\u{21d0}",
+        });
+    }
+
+    if first_char == 'D' && try_read("ownRightVector;") {
+        return Some(CharRef {
+            name: "ownRightVector;",
+            characters: "\u{21c1}",
+        });
+    }
+
+    if first_char == 'L' && try_read("eftRightVector;") {
+        return Some(CharRef {
+            name: "eftRightVector;",
+            characters: "\u{294e}",
+        });
+    }
+
+    if first_char == 'L' && try_read("eftTriangleBar;") {
+        return Some(CharRef {
+            name: "eftTriangleBar;",
+            characters: "\u{29cf}",
+        });
+    }
+
+    if first_char == 'L' && try_read("eftUpTeeVector;") {
+        return Some(CharRef {
+            name: "eftUpTeeVector;",
+            characters: "\u{2960}",
+        });
+    }
+
+    if first_char == 'L' && try_read("eftUpVectorBar;") {
+        return Some(CharRef {
+            name: "eftUpVectorBar;",
+            characters: "\u{2958}",
+        });
+    }
+
+    if first_char == 'L' && try_read("owerRightArrow;") {
+        return Some(CharRef {
+            name: "owerRightArrow;",
+            characters: "\u{2198}",
+        });
+    }
+
+    if first_char == 'N' && try_read("otGreaterEqual;") {
+        return Some(CharRef {
+            name: "otGreaterEqual;",
+            characters: "\u{2271}",
+        });
+    }
+
+    if first_char == 'N' && try_read("otGreaterTilde;") {
+        return Some(CharRef {
+            name: "otGreaterTilde;",
+            characters: "\u{2275}",
+        });
+    }
+
+    if first_char == 'N' && try_read("otHumpDownHump;") {
+        return Some(CharRef {
+            name: "otHumpDownHump;",
+            characters: "\u{224e}\u{338}",
+        });
+    }
+
+    if first_char == 'N' && try_read("otLeftTriangle;") {
+        return Some(CharRef {
+            name: "otLeftTriangle;",
+            characters: "\u{22ea}",
+        });
+    }
+
+    if first_char == 'N' && try_read("otSquareSubset;") {
+        return Some(CharRef {
+            name: "otSquareSubset;",
+            characters: "\u{228f}\u{338}",
+        });
+    }
+
+    if first_char == 'O' && try_read("verParenthesis;") {
+        return Some(CharRef {
+            name: "verParenthesis;",
+            characters: "\u{23dc}",
+        });
+    }
+
+    if first_char == 'R' && try_read("ightDownVector;") {
+        return Some(CharRef {
+            name: "ightDownVector;",
+            characters: "\u{21c2}",
+        });
+    }
+
+    if first_char == 'S' && try_read("hortRightArrow;") {
+        return Some(CharRef {
+            name: "hortRightArrow;",
+            characters: "\u{2192}",
+        });
+    }
+
+    if first_char == 'U' && try_read("pperRightArrow;") {
+        return Some(CharRef {
+            name: "pperRightArrow;",
+            characters: "\u{2197}",
+        });
+    }
+
+    if first_char == 'b' && try_read("igtriangledown;") {
+        return Some(CharRef {
+            name: "igtriangledown;",
+            characters: "\u{25bd}",
+        });
+    }
+
+    if first_char == 'c' && try_read("irclearrowleft;") {
+        return Some(CharRef {
+            name: "irclearrowleft;",
+            characters: "\u{21ba}",
+        });
+    }
+
+    if first_char == 'c' && try_read("urvearrowright;") {
+        return Some(CharRef {
+            name: "urvearrowright;",
+            characters: "\u{21b7}",
+        });
+    }
+
+    if first_char == 'd' && try_read("ownharpoonleft;") {
+        return Some(CharRef {
+            name: "ownharpoonleft;",
+            characters: "\u{21c3}",
+        });
+    }
+
+    if first_char == 'l' && try_read("eftharpoondown;") {
+        return Some(CharRef {
+            name: "eftharpoondown;",
+            characters: "\u{21bd}",
+        });
+    }
+
+    if first_char == 'l' && try_read("eftrightarrows;") {
+        return Some(CharRef {
+            name: "eftrightarrows;",
+            characters: "\u{21c6}",
+        });
+    }
+
+    if first_char == 'n' && try_read("Leftrightarrow;") {
+        return Some(CharRef {
+            name: "Leftrightarrow;",
+            characters: "\u{21ce}",
+        });
+    }
+
+    if first_char == 'n' && try_read("leftrightarrow;") {
+        return Some(CharRef {
+            name: "leftrightarrow;",
+            characters: "\u{21ae}",
+        });
+    }
+
+    if first_char == 'n' && try_read("trianglelefteq;") {
+        return Some(CharRef {
+            name: "trianglelefteq;",
+            characters: "\u{22ec}",
+        });
+    }
+
+    if first_char == 'r' && try_read("ightleftarrows;") {
+        return Some(CharRef {
+            name: "ightleftarrows;",
+            characters: "\u{21c4}",
+        });
+    }
+
+    if first_char == 'r' && try_read("ightsquigarrow;") {
+        return Some(CharRef {
+            name: "ightsquigarrow;",
+            characters: "\u{219d}",
+        });
+    }
+
+    if first_char == 'r' && try_read("ightthreetimes;") {
+        return Some(CharRef {
+            name: "ightthreetimes;",
+            characters: "\u{22cc}",
+        });
+    }
+
+    if first_char == 's' && try_read("traightepsilon;") {
+        return Some(CharRef {
+            name: "traightepsilon;",
+            characters: "\u{3f5}",
+        });
+    }
+
+    if first_char == 't' && try_read("rianglerighteq;") {
+        return Some(CharRef {
+            name: "rianglerighteq;",
+            characters: "\u{22b5}",
+        });
+    }
+
+    if first_char == 'v' && try_read("artriangleleft;") {
+        return Some(CharRef {
+            name: "artriangleleft;",
+            characters: "\u{22b2}",
+        });
+    }
+
+    if first_char == 'D' && try_read("iacriticalDot;") {
+        return Some(CharRef {
+            name: "iacriticalDot;",
+            characters: "\u{2d9}",
+        });
+    }
+
+    if first_char == 'D' && try_read("oubleRightTee;") {
+        return Some(CharRef {
+            name: "oubleRightTee;",
+            characters: "\u{22a8}",
+        });
+    }
+
+    if first_char == 'D' && try_read("ownLeftVector;") {
+        return Some(CharRef {
+            name: "ownLeftVector;",
+            characters: "\u{21bd}",
+        });
+    }
+
+    if first_char == 'G' && try_read("reaterGreater;") {
+        return Some(CharRef {
+            name: "reaterGreater;",
+            characters: "\u{2aa2}",
+        });
+    }
+
+    if first_char == 'H' && try_read("orizontalLine;") {
+        return Some(CharRef {
+            name: "orizontalLine;",
+            characters: "\u{2500}",
+        });
+    }
+
+    if first_char == 'I' && try_read("nvisibleComma;") {
+        return Some(CharRef {
+            name: "nvisibleComma;",
+            characters: "\u{2063}",
+        });
+    }
+
+    if first_char == 'I' && try_read("nvisibleTimes;") {
+        return Some(CharRef {
+            name: "nvisibleTimes;",
+            characters: "\u{2062}",
+        });
+    }
+
+    if first_char == 'L' && try_read("eftDownVector;") {
+        return Some(CharRef {
+            name: "eftDownVector;",
+            characters: "\u{21c3}",
+        });
+    }
+
+    if first_char == 'L' && try_read("eftRightArrow;") {
+        return Some(CharRef {
+            name: "eftRightArrow;",
+            characters: "\u{2194}",
+        });
+    }
+
+    if first_char == 'L' && try_read("eftrightarrow;") {
+        return Some(CharRef {
+            name: "eftrightarrow;",
+            characters: "\u{21d4}",
+        });
+    }
+
+    if first_char == 'L' && try_read("essSlantEqual;") {
+        return Some(CharRef {
+            name: "essSlantEqual;",
+            characters: "\u{2a7d}",
+        });
+    }
+
+    if first_char == 'L' && try_read("ongRightArrow;") {
+        return Some(CharRef {
+            name: "ongRightArrow;",
+            characters: "\u{27f6}",
+        });
+    }
+
+    if first_char == 'L' && try_read("ongrightarrow;") {
+        return Some(CharRef {
+            name: "ongrightarrow;",
+            characters: "\u{27f9}",
+        });
+    }
+
+    if first_char == 'L' && try_read("owerLeftArrow;") {
+        return Some(CharRef {
+            name: "owerLeftArrow;",
+            characters: "\u{2199}",
+        });
+    }
+
+    if first_char == 'N' && try_read("estedLessLess;") {
+        return Some(CharRef {
+            name: "estedLessLess;",
+            characters: "\u{226a}",
+        });
+    }
+
+    if first_char == 'N' && try_read("otGreaterLess;") {
+        return Some(CharRef {
+            name: "otGreaterLess;",
+            characters: "\u{2279}",
+        });
+    }
+
+    if first_char == 'N' && try_read("otLessGreater;") {
+        return Some(CharRef {
+            name: "otLessGreater;",
+            characters: "\u{2278}",
+        });
+    }
+
+    if first_char == 'N' && try_read("otSubsetEqual;") {
+        return Some(CharRef {
+            name: "otSubsetEqual;",
+            characters: "\u{2288}",
+        });
+    }
+
+    if first_char == 'N' && try_read("otVerticalBar;") {
+        return Some(CharRef {
+            name: "otVerticalBar;",
+            characters: "\u{2224}",
+        });
+    }
+
+    if first_char == 'O' && try_read("penCurlyQuote;") {
+        return Some(CharRef {
+            name: "penCurlyQuote;",
+            characters: "\u{2018}",
+        });
+    }
+
+    if first_char == 'R' && try_read("everseElement;") {
+        return Some(CharRef {
+            name: "everseElement;",
+            characters: "\u{220b}",
+        });
+    }
+
+    if first_char == 'R' && try_read("ightTeeVector;") {
+        return Some(CharRef {
+            name: "ightTeeVector;",
+            characters: "\u{295b}",
+        });
+    }
+
+    if first_char == 'R' && try_read("ightVectorBar;") {
+        return Some(CharRef {
+            name: "ightVectorBar;",
+            characters: "\u{2953}",
+        });
+    }
+
+    if first_char == 'S' && try_read("hortDownArrow;") {
+        return Some(CharRef {
+            name: "hortDownArrow;",
+            characters: "\u{2193}",
+        });
+    }
+
+    if first_char == 'S' && try_read("hortLeftArrow;") {
+        return Some(CharRef {
+            name: "hortLeftArrow;",
+            characters: "\u{2190}",
+        });
+    }
+
+    if first_char == 'S' && try_read("quareSuperset;") {
+        return Some(CharRef {
+            name: "quareSuperset;",
+            characters: "\u{2290}",
+        });
+    }
+
+    if first_char == 'T' && try_read("ildeFullEqual;") {
+        return Some(CharRef {
+            name: "ildeFullEqual;",
+            characters: "\u{2245}",
+        });
+    }
+
+    if first_char == 'U' && try_read("pperLeftArrow;") {
+        return Some(CharRef {
+            name: "pperLeftArrow;",
+            characters: "\u{2196}",
+        });
+    }
+
+    if first_char == 'Z' && try_read("eroWidthSpace;") {
+        return Some(CharRef {
+            name: "eroWidthSpace;",
+            characters: "\u{200b}",
+        });
+    }
+
+    if first_char == 'c' && try_read("urvearrowleft;") {
+        return Some(CharRef {
+            name: "urvearrowleft;",
+            characters: "\u{21b6}",
+        });
+    }
+
+    if first_char == 'd' && try_read("oublebarwedge;") {
+        return Some(CharRef {
+            name: "oublebarwedge;",
+            characters: "\u{2306}",
+        });
+    }
+
+    if first_char == 'd' && try_read("owndownarrows;") {
+        return Some(CharRef {
+            name: "owndownarrows;",
+            characters: "\u{21ca}",
+        });
+    }
+
+    if first_char == 'h' && try_read("ookrightarrow;") {
+        return Some(CharRef {
+            name: "ookrightarrow;",
+            characters: "\u{21aa}",
+        });
+    }
+
+    if first_char == 'l' && try_read("eftleftarrows;") {
+        return Some(CharRef {
+            name: "eftleftarrows;",
+            characters: "\u{21c7}",
+        });
+    }
+
+    if first_char == 'l' && try_read("eftrightarrow;") {
+        return Some(CharRef {
+            name: "eftrightarrow;",
+            characters: "\u{2194}",
+        });
+    }
+
+    if first_char == 'l' && try_read("eftthreetimes;") {
+        return Some(CharRef {
+            name: "eftthreetimes;",
+            characters: "\u{22cb}",
+        });
+    }
+
+    if first_char == 'l' && try_read("ongrightarrow;") {
+        return Some(CharRef {
+            name: "ongrightarrow;",
+            characters: "\u{27f6}",
+        });
+    }
+
+    if first_char == 'l' && try_read("ooparrowright;") {
+        return Some(CharRef {
+            name: "ooparrowright;",
+            characters: "\u{21ac}",
+        });
+    }
+
+    if first_char == 'n' && try_read("shortparallel;") {
+        return Some(CharRef {
+            name: "shortparallel;",
+            characters: "\u{2226}",
+        });
+    }
+
+    if first_char == 'n' && try_read("triangleright;") {
+        return Some(CharRef {
+            name: "triangleright;",
+            characters: "\u{22eb}",
+        });
+    }
+
+    if first_char == 'r' && try_read("ightarrowtail;") {
+        return Some(CharRef {
+            name: "ightarrowtail;",
+            characters: "\u{21a3}",
+        });
+    }
+
+    if first_char == 'r' && try_read("ightharpoonup;") {
+        return Some(CharRef {
+            name: "ightharpoonup;",
+            characters: "\u{21c0}",
+        });
+    }
+
+    if first_char == 't' && try_read("rianglelefteq;") {
+        return Some(CharRef {
+            name: "rianglelefteq;",
+            characters: "\u{22b4}",
+        });
+    }
+
+    if first_char == 'u' && try_read("pharpoonright;") {
+        return Some(CharRef {
+            name: "pharpoonright;",
+            characters: "\u{21be}",
+        });
+    }
+
+    if first_char == 'A' && try_read("pplyFunction;") {
+        return Some(CharRef {
+            name: "pplyFunction;",
+            characters: "\u{2061}",
+        });
+    }
+
+    if first_char == 'D' && try_read("ifferentialD;") {
+        return Some(CharRef {
+            name: "ifferentialD;",
+            characters: "\u{2146}",
+        });
+    }
+
+    if first_char == 'D' && try_read("oubleLeftTee;") {
+        return Some(CharRef {
+            name: "oubleLeftTee;",
+            characters: "\u{2ae4}",
+        });
+    }
+
+    if first_char == 'D' && try_read("oubleUpArrow;") {
+        return Some(CharRef {
+            name: "oubleUpArrow;",
+            characters: "\u{21d1}",
+        });
+    }
+
+    if first_char == 'L' && try_read("eftTeeVector;") {
+        return Some(CharRef {
+            name: "eftTeeVector;",
+            characters: "\u{295a}",
+        });
+    }
+
+    if first_char == 'L' && try_read("eftVectorBar;") {
+        return Some(CharRef {
+            name: "eftVectorBar;",
+            characters: "\u{2952}",
+        });
+    }
+
+    if first_char == 'L' && try_read("essFullEqual;") {
+        return Some(CharRef {
+            name: "essFullEqual;",
+            characters: "\u{2266}",
+        });
+    }
+
+    if first_char == 'L' && try_read("ongLeftArrow;") {
+        return Some(CharRef {
+            name: "ongLeftArrow;",
+            characters: "\u{27f5}",
+        });
+    }
+
+    if first_char == 'L' && try_read("ongleftarrow;") {
+        return Some(CharRef {
+            name: "ongleftarrow;",
+            characters: "\u{27f8}",
+        });
+    }
+
+    if first_char == 'N' && try_read("otEqualTilde;") {
+        return Some(CharRef {
+            name: "otEqualTilde;",
+            characters: "\u{2242}\u{338}",
+        });
+    }
+
+    if first_char == 'N' && try_read("otTildeEqual;") {
+        return Some(CharRef {
+            name: "otTildeEqual;",
+            characters: "\u{2244}",
+        });
+    }
+
+    if first_char == 'N' && try_read("otTildeTilde;") {
+        return Some(CharRef {
+            name: "otTildeTilde;",
+            characters: "\u{2249}",
+        });
+    }
+
+    if first_char == 'P' && try_read("oincareplane;") {
+        return Some(CharRef {
+            name: "oincareplane;",
+            characters: "\u{210c}",
+        });
+    }
+
+    if first_char == 'P' && try_read("recedesEqual;") {
+        return Some(CharRef {
+            name: "recedesEqual;",
+            characters: "\u{2aaf}",
+        });
+    }
+
+    if first_char == 'P' && try_read("recedesTilde;") {
+        return Some(CharRef {
+            name: "recedesTilde;",
+            characters: "\u{227e}",
+        });
+    }
+
+    if first_char == 'R' && try_read("ightArrowBar;") {
+        return Some(CharRef {
+            name: "ightArrowBar;",
+            characters: "\u{21e5}",
+        });
+    }
+
+    if first_char == 'R' && try_read("ightTeeArrow;") {
+        return Some(CharRef {
+            name: "ightTeeArrow;",
+            characters: "\u{21a6}",
+        });
+    }
+
+    if first_char == 'R' && try_read("ightTriangle;") {
+        return Some(CharRef {
+            name: "ightTriangle;",
+            characters: "\u{22b3}",
+        });
+    }
+
+    if first_char == 'R' && try_read("ightUpVector;") {
+        return Some(CharRef {
+            name: "ightUpVector;",
+            characters: "\u{21be}",
+        });
+    }
+
+    if first_char == 'S' && try_read("ucceedsEqual;") {
+        return Some(CharRef {
+            name: "ucceedsEqual;",
+            characters: "\u{2ab0}",
+        });
+    }
+
+    if first_char == 'S' && try_read("ucceedsTilde;") {
+        return Some(CharRef {
+            name: "ucceedsTilde;",
+            characters: "\u{227f}",
+        });
+    }
+
+    if first_char == 'S' && try_read("upersetEqual;") {
+        return Some(CharRef {
+            name: "upersetEqual;",
+            characters: "\u{2287}",
+        });
+    }
+
+    if first_char == 'U' && try_read("pEquilibrium;") {
+        return Some(CharRef {
+            name: "pEquilibrium;",
+            characters: "\u{296e}",
+        });
+    }
+
+    if first_char == 'V' && try_read("erticalTilde;") {
+        return Some(CharRef {
+            name: "erticalTilde;",
+            characters: "\u{2240}",
+        });
+    }
+
+    if first_char == 'V' && try_read("eryThinSpace;") {
+        return Some(CharRef {
+            name: "eryThinSpace;",
+            characters: "\u{200a}",
+        });
+    }
+
+    if first_char == 'b' && try_read("igtriangleup;") {
+        return Some(CharRef {
+            name: "igtriangleup;",
+            characters: "\u{25b3}",
+        });
+    }
+
+    if first_char == 'b' && try_read("lacktriangle;") {
+        return Some(CharRef {
+            name: "lacktriangle;",
+            characters: "\u{25b4}",
+        });
+    }
+
+    if first_char == 'd' && try_read("ivideontimes;") {
+        return Some(CharRef {
+            name: "ivideontimes;",
+            characters: "\u{22c7}",
+        });
+    }
+
+    if first_char == 'f' && try_read("allingdotseq;") {
+        return Some(CharRef {
+            name: "allingdotseq;",
+            characters: "\u{2252}",
+        });
+    }
+
+    if first_char == 'h' && try_read("ookleftarrow;") {
+        return Some(CharRef {
+            name: "ookleftarrow;",
+            characters: "\u{21a9}",
+        });
+    }
+
+    if first_char == 'l' && try_read("eftarrowtail;") {
+        return Some(CharRef {
+            name: "eftarrowtail;",
+            characters: "\u{21a2}",
+        });
+    }
+
+    if first_char == 'l' && try_read("eftharpoonup;") {
+        return Some(CharRef {
+            name: "eftharpoonup;",
+            characters: "\u{21bc}",
+        });
+    }
+
+    if first_char == 'l' && try_read("ongleftarrow;") {
+        return Some(CharRef {
+            name: "ongleftarrow;",
+            characters: "\u{27f5}",
+        });
+    }
+
+    if first_char == 'l' && try_read("ooparrowleft;") {
+        return Some(CharRef {
+            name: "ooparrowleft;",
+            characters: "\u{21ab}",
+        });
+    }
+
+    if first_char == 'm' && try_read("easuredangle;") {
+        return Some(CharRef {
+            name: "easuredangle;",
+            characters: "\u{2221}",
+        });
+    }
+
+    if first_char == 'n' && try_read("triangleleft;") {
+        return Some(CharRef {
+            name: "triangleleft;",
+            characters: "\u{22ea}",
+        });
+    }
+
+    if first_char == 's' && try_read("hortparallel;") {
+        return Some(CharRef {
+            name: "hortparallel;",
+            characters: "\u{2225}",
+        });
+    }
+
+    if first_char == 's' && try_read("mallsetminus;") {
+        return Some(CharRef {
+            name: "mallsetminus;",
+            characters: "\u{2216}",
+        });
+    }
+
+    if first_char == 't' && try_read("riangleright;") {
+        return Some(CharRef {
+            name: "riangleright;",
+            characters: "\u{25b9}",
+        });
+    }
+
+    if first_char == 'u' && try_read("pharpoonleft;") {
+        return Some(CharRef {
+            name: "pharpoonleft;",
+            characters: "\u{21bf}",
+        });
+    }
+
+    if first_char == 'v' && try_read("arsubsetneqq;") {
+        return Some(CharRef {
+            name: "arsubsetneqq;",
+            characters: "\u{2acb}\u{fe00}",
+        });
+    }
+
+    if first_char == 'v' && try_read("arsupsetneqq;") {
+        return Some(CharRef {
+            name: "arsupsetneqq;",
+            characters: "\u{2acc}\u{fe00}",
+        });
+    }
+
+    if first_char == 'D' && try_read("ownArrowBar;") {
+        return Some(CharRef {
+            name: "ownArrowBar;",
+            characters: "\u{2913}",
+        });
+    }
+
+    if first_char == 'D' && try_read("ownTeeArrow;") {
+        return Some(CharRef {
+            name: "ownTeeArrow;",
+            characters: "\u{21a7}",
+        });
+    }
+
+    if first_char == 'E' && try_read("xponentialE;") {
+        return Some(CharRef {
+            name: "xponentialE;",
+            characters: "\u{2147}",
+        });
+    }
+
+    if first_char == 'G' && try_read("reaterEqual;") {
+        return Some(CharRef {
+            name: "reaterEqual;",
+            characters: "\u{2265}",
+        });
+    }
+
+    if first_char == 'G' && try_read("reaterTilde;") {
+        return Some(CharRef {
+            name: "reaterTilde;",
+            characters: "\u{2273}",
+        });
+    }
+
+    if first_char == 'H' && try_read("ilbertSpace;") {
+        return Some(CharRef {
+            name: "ilbertSpace;",
+            characters: "\u{210b}",
+        });
+    }
+
+    if first_char == 'H' && try_read("umpDownHump;") {
+        return Some(CharRef {
+            name: "umpDownHump;",
+            characters: "\u{224e}",
+        });
+    }
+
+    if first_char == 'I' && try_read("ntersection;") {
+        return Some(CharRef {
+            name: "ntersection;",
+            characters: "\u{22c2}",
+        });
+    }
+
+    if first_char == 'L' && try_read("eftArrowBar;") {
+        return Some(CharRef {
+            name: "eftArrowBar;",
+            characters: "\u{21e4}",
+        });
+    }
+
+    if first_char == 'L' && try_read("eftTeeArrow;") {
+        return Some(CharRef {
+            name: "eftTeeArrow;",
+            characters: "\u{21a4}",
+        });
+    }
+
+    if first_char == 'L' && try_read("eftTriangle;") {
+        return Some(CharRef {
+            name: "eftTriangle;",
+            characters: "\u{22b2}",
+        });
+    }
+
+    if first_char == 'L' && try_read("eftUpVector;") {
+        return Some(CharRef {
+            name: "eftUpVector;",
+            characters: "\u{21bf}",
+        });
+    }
+
+    if first_char == 'N' && try_read("otCongruent;") {
+        return Some(CharRef {
+            name: "otCongruent;",
+            characters: "\u{2262}",
+        });
+    }
+
+    if first_char == 'N' && try_read("otHumpEqual;") {
+        return Some(CharRef {
+            name: "otHumpEqual;",
+            characters: "\u{224f}\u{338}",
+        });
+    }
+
+    if first_char == 'N' && try_read("otLessEqual;") {
+        return Some(CharRef {
+            name: "otLessEqual;",
+            characters: "\u{2270}",
+        });
+    }
+
+    if first_char == 'N' && try_read("otLessTilde;") {
+        return Some(CharRef {
+            name: "otLessTilde;",
+            characters: "\u{2274}",
+        });
+    }
+
+    if first_char == 'P' && try_read("roportional;") {
+        return Some(CharRef {
+            name: "roportional;",
+            characters: "\u{221d}",
+        });
+    }
+
+    if first_char == 'R' && try_read("ightCeiling;") {
+        return Some(CharRef {
+            name: "ightCeiling;",
+            characters: "\u{2309}",
+        });
+    }
+
+    if first_char == 'R' && try_read("oundImplies;") {
+        return Some(CharRef {
+            name: "oundImplies;",
+            characters: "\u{2970}",
+        });
+    }
+
+    if first_char == 'S' && try_read("hortUpArrow;") {
+        return Some(CharRef {
+            name: "hortUpArrow;",
+            characters: "\u{2191}",
+        });
+    }
+
+    if first_char == 'S' && try_read("quareSubset;") {
+        return Some(CharRef {
+            name: "quareSubset;",
+            characters: "\u{228f}",
+        });
+    }
+
+    if first_char == 'U' && try_read("nderBracket;") {
+        return Some(CharRef {
+            name: "nderBracket;",
+            characters: "\u{23b5}",
+        });
+    }
+
+    if first_char == 'V' && try_read("erticalLine;") {
+        return Some(CharRef {
+            name: "erticalLine;",
+            characters: "\u{7c}",
+        });
+    }
+
+    if first_char == 'b' && try_read("lacklozenge;") {
+        return Some(CharRef {
+            name: "lacklozenge;",
+            characters: "\u{29eb}",
+        });
+    }
+
+    if first_char == 'e' && try_read("xponentiale;") {
+        return Some(CharRef {
+            name: "xponentiale;",
+            characters: "\u{2147}",
+        });
+    }
+
+    if first_char == 'r' && try_read("isingdotseq;") {
+        return Some(CharRef {
+            name: "isingdotseq;",
+            characters: "\u{2253}",
+        });
+    }
+
+    if first_char == 't' && try_read("riangledown;") {
+        return Some(CharRef {
+            name: "riangledown;",
+            characters: "\u{25bf}",
+        });
+    }
+
+    if first_char == 't' && try_read("riangleleft;") {
+        return Some(CharRef {
+            name: "riangleleft;",
+            characters: "\u{25c3}",
+        });
+    }
+
+    if first_char == 'v' && try_read("arsubsetneq;") {
+        return Some(CharRef {
+            name: "arsubsetneq;",
+            characters: "\u{228a}\u{fe00}",
+        });
+    }
+
+    if first_char == 'v' && try_read("arsupsetneq;") {
+        return Some(CharRef {
+            name: "arsupsetneq;",
+            characters: "\u{228b}\u{fe00}",
+        });
+    }
+
+    if first_char == 'C' && try_read("ircleMinus;") {
+        return Some(CharRef {
+            name: "ircleMinus;",
+            characters: "\u{2296}",
+        });
+    }
+
+    if first_char == 'C' && try_read("ircleTimes;") {
+        return Some(CharRef {
+            name: "ircleTimes;",
+            characters: "\u{2297}",
+        });
+    }
+
+    if first_char == 'E' && try_read("quilibrium;") {
+        return Some(CharRef {
+            name: "quilibrium;",
+            characters: "\u{21cc}",
+        });
+    }
+
+    if first_char == 'G' && try_read("reaterLess;") {
+        return Some(CharRef {
+            name: "reaterLess;",
+            characters: "\u{2277}",
+        });
+    }
+
+    if first_char == 'L' && try_read("eftCeiling;") {
+        return Some(CharRef {
+            name: "eftCeiling;",
+            characters: "\u{2308}",
+        });
+    }
+
+    if first_char == 'L' && try_read("essGreater;") {
+        return Some(CharRef {
+            name: "essGreater;",
+            characters: "\u{2276}",
+        });
+    }
+
+    if first_char == 'M' && try_read("ediumSpace;") {
+        return Some(CharRef {
+            name: "ediumSpace;",
+            characters: "\u{205f}",
+        });
+    }
+
+    if first_char == 'N' && try_read("otLessLess;") {
+        return Some(CharRef {
+            name: "otLessLess;",
+            characters: "\u{226a}\u{338}",
+        });
+    }
+
+    if first_char == 'N' && try_read("otPrecedes;") {
+        return Some(CharRef {
+            name: "otPrecedes;",
+            characters: "\u{2280}",
+        });
+    }
+
+    if first_char == 'N' && try_read("otSucceeds;") {
+        return Some(CharRef {
+            name: "otSucceeds;",
+            characters: "\u{2281}",
+        });
+    }
+
+    if first_char == 'N' && try_read("otSuperset;") {
+        return Some(CharRef {
+            name: "otSuperset;",
+            characters: "\u{2283}\u{20d2}",
+        });
+    }
+
+    if first_char == 'O' && try_read("verBracket;") {
+        return Some(CharRef {
+            name: "verBracket;",
+            characters: "\u{23b4}",
+        });
+    }
+
+    if first_char == 'R' && try_read("ightVector;") {
+        return Some(CharRef {
+            name: "ightVector;",
+            characters: "\u{21c0}",
+        });
+    }
+
+    if first_char == 'R' && try_read("rightarrow;") {
+        return Some(CharRef {
+            name: "rightarrow;",
+            characters: "\u{21db}",
+        });
+    }
+
+    if first_char == 'R' && try_read("uleDelayed;") {
+        return Some(CharRef {
+            name: "uleDelayed;",
+            characters: "\u{29f4}",
+        });
+    }
+
+    if first_char == 'S' && try_read("mallCircle;") {
+        return Some(CharRef {
+            name: "mallCircle;",
+            characters: "\u{2218}",
+        });
+    }
+
+    if first_char == 'S' && try_read("quareUnion;") {
+        return Some(CharRef {
+            name: "quareUnion;",
+            characters: "\u{2294}",
+        });
+    }
+
+    if first_char == 'S' && try_read("ubsetEqual;") {
+        return Some(CharRef {
+            name: "ubsetEqual;",
+            characters: "\u{2286}",
+        });
+    }
+
+    if first_char == 'U' && try_read("pDownArrow;") {
+        return Some(CharRef {
+            name: "pDownArrow;",
+            characters: "\u{2195}",
+        });
+    }
+
+    if first_char == 'U' && try_read("pdownarrow;") {
+        return Some(CharRef {
+            name: "pdownarrow;",
+            characters: "\u{21d5}",
+        });
+    }
+
+    if first_char == 'V' && try_read("erticalBar;") {
+        return Some(CharRef {
+            name: "erticalBar;",
+            characters: "\u{2223}",
+        });
+    }
+
+    if first_char == 'b' && try_read("ackepsilon;") {
+        return Some(CharRef {
+            name: "ackepsilon;",
+            characters: "\u{3f6}",
+        });
+    }
+
+    if first_char == 'b' && try_read("lacksquare;") {
+        return Some(CharRef {
+            name: "lacksquare;",
+            characters: "\u{25aa}",
+        });
+    }
+
+    if first_char == 'c' && try_read("ircledcirc;") {
+        return Some(CharRef {
+            name: "ircledcirc;",
+            characters: "\u{229a}",
+        });
+    }
+
+    if first_char == 'c' && try_read("ircleddash;") {
+        return Some(CharRef {
+            name: "ircleddash;",
+            characters: "\u{229d}",
+        });
+    }
+
+    if first_char == 'c' && try_read("urlyeqprec;") {
+        return Some(CharRef {
+            name: "urlyeqprec;",
+            characters: "\u{22de}",
+        });
+    }
+
+    if first_char == 'c' && try_read("urlyeqsucc;") {
+        return Some(CharRef {
+            name: "urlyeqsucc;",
+            characters: "\u{22df}",
+        });
+    }
+
+    if first_char == 'd' && try_read("iamondsuit;") {
+        return Some(CharRef {
+            name: "iamondsuit;",
+            characters: "\u{2666}",
+        });
+    }
+
+    if first_char == 'e' && try_read("qslantless;") {
+        return Some(CharRef {
+            name: "qslantless;",
+            characters: "\u{2a95}",
+        });
+    }
+
+    if first_char == 'e' && try_read("xpectation;") {
+        return Some(CharRef {
+            name: "xpectation;",
+            characters: "\u{2130}",
+        });
+    }
+
+    if first_char == 'n' && try_read("Rightarrow;") {
+        return Some(CharRef {
+            name: "Rightarrow;",
+            characters: "\u{21cf}",
+        });
+    }
+
+    if first_char == 'n' && try_read("rightarrow;") {
+        return Some(CharRef {
+            name: "rightarrow;",
+            characters: "\u{219b}",
+        });
+    }
+
+    if first_char == 'p' && try_read("reccurlyeq;") {
+        return Some(CharRef {
+            name: "reccurlyeq;",
+            characters: "\u{227c}",
+        });
+    }
+
+    if first_char == 'p' && try_read("recnapprox;") {
+        return Some(CharRef {
+            name: "recnapprox;",
+            characters: "\u{2ab9}",
+        });
+    }
+
+    if first_char == 'q' && try_read("uaternions;") {
+        return Some(CharRef {
+            name: "uaternions;",
+            characters: "\u{210d}",
+        });
+    }
+
+    if first_char == 's' && try_read("traightphi;") {
+        return Some(CharRef {
+            name: "traightphi;",
+            characters: "\u{3d5}",
+        });
+    }
+
+    if first_char == 's' && try_read("ucccurlyeq;") {
+        return Some(CharRef {
+            name: "ucccurlyeq;",
+            characters: "\u{227d}",
+        });
+    }
+
+    if first_char == 's' && try_read("uccnapprox;") {
+        return Some(CharRef {
+            name: "uccnapprox;",
+            characters: "\u{2aba}",
+        });
+    }
+
+    if first_char == 't' && try_read("hickapprox;") {
+        return Some(CharRef {
+            name: "hickapprox;",
+            characters: "\u{2248}",
+        });
+    }
+
+    if first_char == 'u' && try_read("pdownarrow;") {
+        return Some(CharRef {
+            name: "pdownarrow;",
+            characters: "\u{2195}",
+        });
+    }
+
+    if first_char == 'B' && try_read("ernoullis;") {
+        return Some(CharRef {
+            name: "ernoullis;",
+            characters: "\u{212c}",
+        });
+    }
+
+    if first_char == 'C' && try_read("irclePlus;") {
+        return Some(CharRef {
+            name: "irclePlus;",
+            characters: "\u{2295}",
+        });
+    }
+
+    if first_char == 'E' && try_read("qualTilde;") {
+        return Some(CharRef {
+            name: "qualTilde;",
+            characters: "\u{2242}",
+        });
+    }
+
+    if first_char == 'F' && try_read("ouriertrf;") {
+        return Some(CharRef {
+            name: "ouriertrf;",
+            characters: "\u{2131}",
+        });
+    }
+
+    if first_char == 'I' && try_read("maginaryI;") {
+        return Some(CharRef {
+            name: "maginaryI;",
+            characters: "\u{2148}",
+        });
+    }
+
+    if first_char == 'L' && try_read("aplacetrf;") {
+        return Some(CharRef {
+            name: "aplacetrf;",
+            characters: "\u{2112}",
+        });
+    }
+
+    if first_char == 'L' && try_read("eftVector;") {
+        return Some(CharRef {
+            name: "eftVector;",
+            characters: "\u{21bc}",
+        });
+    }
+
+    if first_char == 'L' && try_read("leftarrow;") {
+        return Some(CharRef {
+            name: "leftarrow;",
+            characters: "\u{21da}",
+        });
+    }
+
+    if first_char == 'N' && try_read("otElement;") {
+        return Some(CharRef {
+            name: "otElement;",
+            characters: "\u{2209}",
+        });
+    }
+
+    if first_char == 'N' && try_read("otGreater;") {
+        return Some(CharRef {
+            name: "otGreater;",
+            characters: "\u{226f}",
+        });
+    }
+
+    if first_char == 'P' && try_read("roportion;") {
+        return Some(CharRef {
+            name: "roportion;",
+            characters: "\u{2237}",
+        });
+    }
+
+    if first_char == 'R' && try_read("ightArrow;") {
+        return Some(CharRef {
+            name: "ightArrow;",
+            characters: "\u{2192}",
+        });
+    }
+
+    if first_char == 'R' && try_read("ightFloor;") {
+        return Some(CharRef {
+            name: "ightFloor;",
+            characters: "\u{230b}",
+        });
+    }
+
+    if first_char == 'R' && try_read("ightarrow;") {
+        return Some(CharRef {
+            name: "ightarrow;",
+            characters: "\u{21d2}",
+        });
+    }
+
+    if first_char == 'T' && try_read("hickSpace;") {
+        return Some(CharRef {
+            name: "hickSpace;",
+            characters: "\u{205f}\u{200a}",
+        });
+    }
+
+    if first_char == 'T' && try_read("ildeEqual;") {
+        return Some(CharRef {
+            name: "ildeEqual;",
+            characters: "\u{2243}",
+        });
+    }
+
+    if first_char == 'T' && try_read("ildeTilde;") {
+        return Some(CharRef {
+            name: "ildeTilde;",
+            characters: "\u{2248}",
+        });
+    }
+
+    if first_char == 'U' && try_read("nderBrace;") {
+        return Some(CharRef {
+            name: "nderBrace;",
+            characters: "\u{23df}",
+        });
+    }
+
+    if first_char == 'U' && try_read("pArrowBar;") {
+        return Some(CharRef {
+            name: "pArrowBar;",
+            characters: "\u{2912}",
+        });
+    }
+
+    if first_char == 'U' && try_read("pTeeArrow;") {
+        return Some(CharRef {
+            name: "pTeeArrow;",
+            characters: "\u{21a5}",
+        });
+    }
+
+    if first_char == 'c' && try_read("ircledast;") {
+        return Some(CharRef {
+            name: "ircledast;",
+            characters: "\u{229b}",
+        });
+    }
+
+    if first_char == 'c' && try_read("omplement;") {
+        return Some(CharRef {
+            name: "omplement;",
+            characters: "\u{2201}",
+        });
+    }
+
+    if first_char == 'c' && try_read("urlywedge;") {
+        return Some(CharRef {
+            name: "urlywedge;",
+            characters: "\u{22cf}",
+        });
+    }
+
+    if first_char == 'e' && try_read("qslantgtr;") {
+        return Some(CharRef {
+            name: "qslantgtr;",
+            characters: "\u{2a96}",
+        });
+    }
+
+    if first_char == 'g' && try_read("treqqless;") {
+        return Some(CharRef {
+            name: "treqqless;",
+            characters: "\u{2a8c}",
+        });
+    }
+
+    if first_char == 'l' && try_read("essapprox;") {
+        return Some(CharRef {
+            name: "essapprox;",
+            characters: "\u{2a85}",
+        });
+    }
+
+    if first_char == 'l' && try_read("esseqqgtr;") {
+        return Some(CharRef {
+            name: "esseqqgtr;",
+            characters: "\u{2a8b}",
+        });
+    }
+
+    if first_char == 'l' && try_read("moustache;") {
+        return Some(CharRef {
+            name: "moustache;",
+            characters: "\u{23b0}",
+        });
+    }
+
+    if first_char == 'l' && try_read("ongmapsto;") {
+        return Some(CharRef {
+            name: "ongmapsto;",
+            characters: "\u{27fc}",
+        });
+    }
+
+    if first_char == 'm' && try_read("apstodown;") {
+        return Some(CharRef {
+            name: "apstodown;",
+            characters: "\u{21a7}",
+        });
+    }
+
+    if first_char == 'm' && try_read("apstoleft;") {
+        return Some(CharRef {
+            name: "apstoleft;",
+            characters: "\u{21a4}",
+        });
+    }
+
+    if first_char == 'n' && try_read("Leftarrow;") {
+        return Some(CharRef {
+            name: "Leftarrow;",
+            characters: "\u{21cd}",
+        });
+    }
+
+    if first_char == 'n' && try_read("leftarrow;") {
+        return Some(CharRef {
+            name: "leftarrow;",
+            characters: "\u{219a}",
+        });
+    }
+
+    if first_char == 'n' && try_read("subseteqq;") {
+        return Some(CharRef {
+            name: "subseteqq;",
+            characters: "\u{2ac5}\u{338}",
+        });
+    }
+
+    if first_char == 'n' && try_read("supseteqq;") {
+        return Some(CharRef {
+            name: "supseteqq;",
+            characters: "\u{2ac6}\u{338}",
+        });
+    }
+
+    if first_char == 'p' && try_read("recapprox;") {
+        return Some(CharRef {
+            name: "recapprox;",
+            characters: "\u{2ab7}",
+        });
+    }
+
+    if first_char == 'r' && try_read("ightarrow;") {
+        return Some(CharRef {
+            name: "ightarrow;",
+            characters: "\u{2192}",
+        });
+    }
+
+    if first_char == 'r' && try_read("moustache;") {
+        return Some(CharRef {
+            name: "moustache;",
+            characters: "\u{23b1}",
+        });
+    }
+
+    if first_char == 's' && try_read("qsubseteq;") {
+        return Some(CharRef {
+            name: "qsubseteq;",
+            characters: "\u{2291}",
+        });
+    }
+
+    if first_char == 's' && try_read("qsupseteq;") {
+        return Some(CharRef {
+            name: "qsupseteq;",
+            characters: "\u{2292}",
+        });
+    }
+
+    if first_char == 's' && try_read("ubsetneqq;") {
+        return Some(CharRef {
+            name: "ubsetneqq;",
+            characters: "\u{2acb}",
+        });
+    }
+
+    if first_char == 's' && try_read("uccapprox;") {
+        return Some(CharRef {
+            name: "uccapprox;",
+            characters: "\u{2ab8}",
+        });
+    }
+
+    if first_char == 's' && try_read("upsetneqq;") {
+        return Some(CharRef {
+            name: "upsetneqq;",
+            characters: "\u{2acc}",
+        });
+    }
+
+    if first_char == 'u' && try_read("puparrows;") {
+        return Some(CharRef {
+            name: "puparrows;",
+            characters: "\u{21c8}",
+        });
+    }
+
+    if first_char == 'v' && try_read("arepsilon;") {
+        return Some(CharRef {
+            name: "arepsilon;",
+            characters: "\u{3f5}",
+        });
+    }
+
+    if first_char == 'v' && try_read("arnothing;") {
+        return Some(CharRef {
+            name: "arnothing;",
+            characters: "\u{2205}",
+        });
+    }
+
+    if first_char == 'B' && try_read("ackslash;") {
+        return Some(CharRef {
+            name: "ackslash;",
+            characters: "\u{2216}",
+        });
+    }
+
+    if first_char == 'C' && try_read("enterDot;") {
+        return Some(CharRef {
+            name: "enterDot;",
+            characters: "\u{b7}",
+        });
+    }
+
+    if first_char == 'C' && try_read("ircleDot;") {
+        return Some(CharRef {
+            name: "ircleDot;",
+            characters: "\u{2299}",
+        });
+    }
+
+    if first_char == 'C' && try_read("ongruent;") {
+        return Some(CharRef {
+            name: "ongruent;",
+            characters: "\u{2261}",
+        });
+    }
+
+    if first_char == 'C' && try_read("oproduct;") {
+        return Some(CharRef {
+            name: "oproduct;",
+            characters: "\u{2210}",
+        });
+    }
+
+    if first_char == 'D' && try_read("oubleDot;") {
+        return Some(CharRef {
+            name: "oubleDot;",
+            characters: "\u{a8}",
+        });
+    }
+
+    if first_char == 'D' && try_read("ownArrow;") {
+        return Some(CharRef {
+            name: "ownArrow;",
+            characters: "\u{2193}",
+        });
+    }
+
+    if first_char == 'D' && try_read("ownBreve;") {
+        return Some(CharRef {
+            name: "ownBreve;",
+            characters: "\u{311}",
+        });
+    }
+
+    if first_char == 'D' && try_read("ownarrow;") {
+        return Some(CharRef {
+            name: "ownarrow;",
+            characters: "\u{21d3}",
+        });
+    }
+
+    if first_char == 'H' && try_read("umpEqual;") {
+        return Some(CharRef {
+            name: "umpEqual;",
+            characters: "\u{224f}",
+        });
+    }
+
+    if first_char == 'L' && try_read("eftArrow;") {
+        return Some(CharRef {
+            name: "eftArrow;",
+            characters: "\u{2190}",
+        });
+    }
+
+    if first_char == 'L' && try_read("eftFloor;") {
+        return Some(CharRef {
+            name: "eftFloor;",
+            characters: "\u{230a}",
+        });
+    }
+
+    if first_char == 'L' && try_read("eftarrow;") {
+        return Some(CharRef {
+            name: "eftarrow;",
+            characters: "\u{21d0}",
+        });
+    }
+
+    if first_char == 'L' && try_read("essTilde;") {
+        return Some(CharRef {
+            name: "essTilde;",
+            characters: "\u{2272}",
+        });
+    }
+
+    if first_char == 'M' && try_read("ellintrf;") {
+        return Some(CharRef {
+            name: "ellintrf;",
+            characters: "\u{2133}",
+        });
+    }
+
+    if first_char == 'M' && try_read("inusPlus;") {
+        return Some(CharRef {
+            name: "inusPlus;",
+            characters: "\u{2213}",
+        });
+    }
+
+    if first_char == 'N' && try_read("otCupCap;") {
+        return Some(CharRef {
+            name: "otCupCap;",
+            characters: "\u{226d}",
+        });
+    }
+
+    if first_char == 'N' && try_read("otExists;") {
+        return Some(CharRef {
+            name: "otExists;",
+            characters: "\u{2204}",
+        });
+    }
+
+    if first_char == 'N' && try_read("otSubset;") {
+        return Some(CharRef {
+            name: "otSubset;",
+            characters: "\u{2282}\u{20d2}",
+        });
+    }
+
+    if first_char == 'O' && try_read("verBrace;") {
+        return Some(CharRef {
+            name: "verBrace;",
+            characters: "\u{23de}",
+        });
+    }
+
+    if first_char == 'P' && try_read("lusMinus;") {
+        return Some(CharRef {
+            name: "lusMinus;",
+            characters: "\u{b1}",
+        });
+    }
+
+    if first_char == 'T' && try_read("herefore;") {
+        return Some(CharRef {
+            name: "herefore;",
+            characters: "\u{2234}",
+        });
+    }
+
+    if first_char == 'T' && try_read("hinSpace;") {
+        return Some(CharRef {
+            name: "hinSpace;",
+            characters: "\u{2009}",
+        });
+    }
+
+    if first_char == 'T' && try_read("ripleDot;") {
+        return Some(CharRef {
+            name: "ripleDot;",
+            characters: "\u{20db}",
+        });
+    }
+
+    if first_char == 'U' && try_read("nionPlus;") {
+        return Some(CharRef {
+            name: "nionPlus;",
+            characters: "\u{228e}",
+        });
+    }
+
+    if first_char == 'b' && try_read("ackprime;") {
+        return Some(CharRef {
+            name: "ackprime;",
+            characters: "\u{2035}",
+        });
+    }
+
+    if first_char == 'b' && try_read("acksimeq;") {
+        return Some(CharRef {
+            name: "acksimeq;",
+            characters: "\u{22cd}",
+        });
+    }
+
+    if first_char == 'b' && try_read("igotimes;") {
+        return Some(CharRef {
+            name: "igotimes;",
+            characters: "\u{2a02}",
+        });
+    }
+
+    if first_char == 'c' && try_read("enterdot;") {
+        return Some(CharRef {
+            name: "enterdot;",
+            characters: "\u{b7}",
+        });
+    }
+
+    if first_char == 'c' && try_read("heckmark;") {
+        return Some(CharRef {
+            name: "heckmark;",
+            characters: "\u{2713}",
+        });
+    }
+
+    if first_char == 'c' && try_read("omplexes;") {
+        return Some(CharRef {
+            name: "omplexes;",
+            characters: "\u{2102}",
+        });
+    }
+
+    if first_char == 'd' && try_read("otsquare;") {
+        return Some(CharRef {
+            name: "otsquare;",
+            characters: "\u{22a1}",
+        });
+    }
+
+    if first_char == 'd' && try_read("ownarrow;") {
+        return Some(CharRef {
+            name: "ownarrow;",
+            characters: "\u{2193}",
+        });
+    }
+
+    if first_char == 'g' && try_read("trapprox;") {
+        return Some(CharRef {
+            name: "trapprox;",
+            characters: "\u{2a86}",
+        });
+    }
+
+    if first_char == 'g' && try_read("treqless;") {
+        return Some(CharRef {
+            name: "treqless;",
+            characters: "\u{22db}",
+        });
+    }
+
+    if first_char == 'g' && try_read("vertneqq;") {
+        return Some(CharRef {
+            name: "vertneqq;",
+            characters: "\u{2269}\u{fe00}",
+        });
+    }
+
+    if first_char == 'h' && try_read("eartsuit;") {
+        return Some(CharRef {
+            name: "eartsuit;",
+            characters: "\u{2665}",
+        });
+    }
+
+    if first_char == 'l' && try_read("eftarrow;") {
+        return Some(CharRef {
+            name: "eftarrow;",
+            characters: "\u{2190}",
+        });
+    }
+
+    if first_char == 'l' && try_read("esseqgtr;") {
+        return Some(CharRef {
+            name: "esseqgtr;",
+            characters: "\u{22da}",
+        });
+    }
+
+    if first_char == 'l' && try_read("vertneqq;") {
+        return Some(CharRef {
+            name: "vertneqq;",
+            characters: "\u{2268}\u{fe00}",
+        });
+    }
+
+    if first_char == 'n' && try_read("geqslant;") {
+        return Some(CharRef {
+            name: "geqslant;",
+            characters: "\u{2a7e}\u{338}",
+        });
+    }
+
+    if first_char == 'n' && try_read("leqslant;") {
+        return Some(CharRef {
+            name: "leqslant;",
+            characters: "\u{2a7d}\u{338}",
+        });
+    }
+
+    if first_char == 'n' && try_read("parallel;") {
+        return Some(CharRef {
+            name: "parallel;",
+            characters: "\u{2226}",
+        });
+    }
+
+    if first_char == 'n' && try_read("shortmid;") {
+        return Some(CharRef {
+            name: "shortmid;",
+            characters: "\u{2224}",
+        });
+    }
+
+    if first_char == 'n' && try_read("subseteq;") {
+        return Some(CharRef {
+            name: "subseteq;",
+            characters: "\u{2288}",
+        });
+    }
+
+    if first_char == 'n' && try_read("supseteq;") {
+        return Some(CharRef {
+            name: "supseteq;",
+            characters: "\u{2289}",
+        });
+    }
+
+    if first_char == 'p' && try_read("itchfork;") {
+        return Some(CharRef {
+            name: "itchfork;",
+            characters: "\u{22d4}",
+        });
+    }
+
+    if first_char == 'r' && try_read("ationals;") {
+        return Some(CharRef {
+            name: "ationals;",
+            characters: "\u{211a}",
+        });
+    }
+
+    if first_char == 's' && try_read("padesuit;") {
+        return Some(CharRef {
+            name: "padesuit;",
+            characters: "\u{2660}",
+        });
+    }
+
+    if first_char == 's' && try_read("ubseteqq;") {
+        return Some(CharRef {
+            name: "ubseteqq;",
+            characters: "\u{2ac5}",
+        });
+    }
+
+    if first_char == 's' && try_read("ubsetneq;") {
+        return Some(CharRef {
+            name: "ubsetneq;",
+            characters: "\u{228a}",
+        });
+    }
+
+    if first_char == 's' && try_read("upseteqq;") {
+        return Some(CharRef {
+            name: "upseteqq;",
+            characters: "\u{2ac6}",
+        });
+    }
+
+    if first_char == 's' && try_read("upsetneq;") {
+        return Some(CharRef {
+            name: "upsetneq;",
+            characters: "\u{228b}",
+        });
+    }
+
+    if first_char == 't' && try_read("herefore;") {
+        return Some(CharRef {
+            name: "herefore;",
+            characters: "\u{2234}",
+        });
+    }
+
+    if first_char == 't' && try_read("riangleq;") {
+        return Some(CharRef {
+            name: "riangleq;",
+            characters: "\u{225c}",
+        });
+    }
+
+    if first_char == 'v' && try_read("arpropto;") {
+        return Some(CharRef {
+            name: "arpropto;",
+            characters: "\u{221d}",
+        });
+    }
+
+    if first_char == 'D' && try_read("Dotrahd;") {
+        return Some(CharRef {
+            name: "Dotrahd;",
+            characters: "\u{2911}",
+        });
+    }
+
+    if first_char == 'D' && try_read("otEqual;") {
+        return Some(CharRef {
+            name: "otEqual;",
+            characters: "\u{2250}",
+        });
+    }
+
+    if first_char == 'I' && try_read("ntegral;") {
+        return Some(CharRef {
+            name: "ntegral;",
+            characters: "\u{222b}",
+        });
+    }
+
+    if first_char == 'L' && try_read("essLess;") {
+        return Some(CharRef {
+            name: "essLess;",
+            characters: "\u{2aa1}",
+        });
+    }
+
+    if first_char == 'N' && try_read("otEqual;") {
+        return Some(CharRef {
+            name: "otEqual;",
+            characters: "\u{2260}",
+        });
+    }
+
+    if first_char == 'N' && try_read("otTilde;") {
+        return Some(CharRef {
+            name: "otTilde;",
+            characters: "\u{2241}",
+        });
+    }
+
+    if first_char == 'P' && try_read("artialD;") {
+        return Some(CharRef {
+            name: "artialD;",
+            characters: "\u{2202}",
+        });
+    }
+
+    if first_char == 'P' && try_read("recedes;") {
+        return Some(CharRef {
+            name: "recedes;",
+            characters: "\u{227a}",
+        });
+    }
+
+    if first_char == 'R' && try_read("ightTee;") {
+        return Some(CharRef {
+            name: "ightTee;",
+            characters: "\u{22a2}",
+        });
+    }
+
+    if first_char == 'S' && try_read("ucceeds;") {
+        return Some(CharRef {
+            name: "ucceeds;",
+            characters: "\u{227b}",
+        });
+    }
+
+    if first_char == 'S' && try_read("uchThat;") {
+        return Some(CharRef {
+            name: "uchThat;",
+            characters: "\u{220b}",
+        });
+    }
+
+    if first_char == 'S' && try_read("uperset;") {
+        return Some(CharRef {
+            name: "uperset;",
+            characters: "\u{2283}",
+        });
+    }
+
+    if first_char == 'U' && try_read("arrocir;") {
+        return Some(CharRef {
+            name: "arrocir;",
+            characters: "\u{2949}",
+        });
+    }
+
+    if first_char == 'U' && try_read("nderBar;") {
+        return Some(CharRef {
+            name: "nderBar;",
+            characters: "\u{5f}",
+        });
+    }
+
+    if first_char == 'a' && try_read("ndslope;") {
+        return Some(CharRef {
+            name: "ndslope;",
+            characters: "\u{2a58}",
+        });
+    }
+
+    if first_char == 'a' && try_read("ngmsdaa;") {
+        return Some(CharRef {
+            name: "ngmsdaa;",
+            characters: "\u{29a8}",
+        });
+    }
+
+    if first_char == 'a' && try_read("ngmsdab;") {
+        return Some(CharRef {
+            name: "ngmsdab;",
+            characters: "\u{29a9}",
+        });
+    }
+
+    if first_char == 'a' && try_read("ngmsdac;") {
+        return Some(CharRef {
+            name: "ngmsdac;",
+            characters: "\u{29aa}",
+        });
+    }
+
+    if first_char == 'a' && try_read("ngmsdad;") {
+        return Some(CharRef {
+            name: "ngmsdad;",
+            characters: "\u{29ab}",
+        });
+    }
+
+    if first_char == 'a' && try_read("ngmsdae;") {
+        return Some(CharRef {
+            name: "ngmsdae;",
+            characters: "\u{29ac}",
+        });
+    }
+
+    if first_char == 'a' && try_read("ngmsdaf;") {
+        return Some(CharRef {
+            name: "ngmsdaf;",
+            characters: "\u{29ad}",
+        });
+    }
+
+    if first_char == 'a' && try_read("ngmsdag;") {
+        return Some(CharRef {
+            name: "ngmsdag;",
+            characters: "\u{29ae}",
+        });
+    }
+
+    if first_char == 'a' && try_read("ngmsdah;") {
+        return Some(CharRef {
+            name: "ngmsdah;",
+            characters: "\u{29af}",
+        });
+    }
+
+    if first_char == 'a' && try_read("ngrtvbd;") {
+        return Some(CharRef {
+            name: "ngrtvbd;",
+            characters: "\u{299d}",
+        });
+    }
+
+    if first_char == 'a' && try_read("pproxeq;") {
+        return Some(CharRef {
+            name: "pproxeq;",
+            characters: "\u{224a}",
+        });
+    }
+
+    if first_char == 'a' && try_read("wconint;") {
+        return Some(CharRef {
+            name: "wconint;",
+            characters: "\u{2233}",
+        });
+    }
+
+    if first_char == 'b' && try_read("ackcong;") {
+        return Some(CharRef {
+            name: "ackcong;",
+            characters: "\u{224c}",
+        });
+    }
+
+    if first_char == 'b' && try_read("arwedge;") {
+        return Some(CharRef {
+            name: "arwedge;",
+            characters: "\u{2305}",
+        });
+    }
+
+    if first_char == 'b' && try_read("brktbrk;") {
+        return Some(CharRef {
+            name: "brktbrk;",
+            characters: "\u{23b6}",
+        });
+    }
+
+    if first_char == 'b' && try_read("igoplus;") {
+        return Some(CharRef {
+            name: "igoplus;",
+            characters: "\u{2a01}",
+        });
+    }
+
+    if first_char == 'b' && try_read("igsqcup;") {
+        return Some(CharRef {
+            name: "igsqcup;",
+            characters: "\u{2a06}",
+        });
+    }
+
+    if first_char == 'b' && try_read("iguplus;") {
+        return Some(CharRef {
+            name: "iguplus;",
+            characters: "\u{2a04}",
+        });
+    }
+
+    if first_char == 'b' && try_read("igwedge;") {
+        return Some(CharRef {
+            name: "igwedge;",
+            characters: "\u{22c0}",
+        });
+    }
+
+    if first_char == 'b' && try_read("oxminus;") {
+        return Some(CharRef {
+            name: "oxminus;",
+            characters: "\u{229f}",
+        });
+    }
+
+    if first_char == 'b' && try_read("oxtimes;") {
+        return Some(CharRef {
+            name: "oxtimes;",
+            characters: "\u{22a0}",
+        });
+    }
+
+    if first_char == 'b' && try_read("solhsub;") {
+        return Some(CharRef {
+            name: "solhsub;",
+            characters: "\u{27c8}",
+        });
+    }
+
+    if first_char == 'c' && try_read("apbrcup;") {
+        return Some(CharRef {
+            name: "apbrcup;",
+            characters: "\u{2a49}",
+        });
+    }
+
+    if first_char == 'c' && try_read("ircledR;") {
+        return Some(CharRef {
+            name: "ircledR;",
+            characters: "\u{ae}",
+        });
+    }
+
+    if first_char == 'c' && try_read("ircledS;") {
+        return Some(CharRef {
+            name: "ircledS;",
+            characters: "\u{24c8}",
+        });
+    }
+
+    if first_char == 'c' && try_read("irfnint;") {
+        return Some(CharRef {
+            name: "irfnint;",
+            characters: "\u{2a10}",
+        });
+    }
+
+    if first_char == 'c' && try_read("lubsuit;") {
+        return Some(CharRef {
+            name: "lubsuit;",
+            characters: "\u{2663}",
+        });
+    }
+
+    if first_char == 'c' && try_read("upbrcap;") {
+        return Some(CharRef {
+            name: "upbrcap;",
+            characters: "\u{2a48}",
+        });
+    }
+
+    if first_char == 'c' && try_read("urlyvee;") {
+        return Some(CharRef {
+            name: "urlyvee;",
+            characters: "\u{22ce}",
+        });
+    }
+
+    if first_char == 'c' && try_read("wconint;") {
+        return Some(CharRef {
+            name: "wconint;",
+            characters: "\u{2232}",
+        });
+    }
+
+    if first_char == 'd' && try_read("oteqdot;") {
+        return Some(CharRef {
+            name: "oteqdot;",
+            characters: "\u{2251}",
+        });
+    }
+
+    if first_char == 'd' && try_read("otminus;") {
+        return Some(CharRef {
+            name: "otminus;",
+            characters: "\u{2238}",
+        });
+    }
+
+    if first_char == 'd' && try_read("rbkarow;") {
+        return Some(CharRef {
+            name: "rbkarow;",
+            characters: "\u{2910}",
+        });
+    }
+
+    if first_char == 'd' && try_read("zigrarr;") {
+        return Some(CharRef {
+            name: "zigrarr;",
+            characters: "\u{27ff}",
+        });
+    }
+
+    if first_char == 'e' && try_read("linters;") {
+        return Some(CharRef {
+            name: "linters;",
+            characters: "\u{23e7}",
+        });
+    }
+
+    if first_char == 'e' && try_read("mptyset;") {
+        return Some(CharRef {
+            name: "mptyset;",
+            characters: "\u{2205}",
+        });
+    }
+
+    if first_char == 'e' && try_read("qvparsl;") {
+        return Some(CharRef {
+            name: "qvparsl;",
+            characters: "\u{29e5}",
+        });
+    }
+
+    if first_char == 'f' && try_read("partint;") {
+        return Some(CharRef {
+            name: "partint;",
+            characters: "\u{2a0d}",
+        });
+    }
+
+    if first_char == 'g' && try_read("eqslant;") {
+        return Some(CharRef {
+            name: "eqslant;",
+            characters: "\u{2a7e}",
+        });
+    }
+
+    if first_char == 'g' && try_read("esdotol;") {
+        return Some(CharRef {
+            name: "esdotol;",
+            characters: "\u{2a84}",
+        });
+    }
+
+    if first_char == 'g' && try_read("napprox;") {
+        return Some(CharRef {
+            name: "napprox;",
+            characters: "\u{2a8a}",
+        });
+    }
+
+    if first_char == 'h' && try_read("ksearow;") {
+        return Some(CharRef {
+            name: "ksearow;",
+            characters: "\u{2925}",
+        });
+    }
+
+    if first_char == 'h' && try_read("kswarow;") {
+        return Some(CharRef {
+            name: "kswarow;",
+            characters: "\u{2926}",
+        });
+    }
+
+    if first_char == 'i' && try_read("magline;") {
+        return Some(CharRef {
+            name: "magline;",
+            characters: "\u{2110}",
+        });
+    }
+
+    if first_char == 'i' && try_read("magpart;") {
+        return Some(CharRef {
+            name: "magpart;",
+            characters: "\u{2111}",
+        });
+    }
+
+    if first_char == 'i' && try_read("nfintie;") {
+        return Some(CharRef {
+            name: "nfintie;",
+            characters: "\u{29dd}",
+        });
+    }
+
+    if first_char == 'i' && try_read("ntegers;") {
+        return Some(CharRef {
+            name: "ntegers;",
+            characters: "\u{2124}",
+        });
+    }
+
+    if first_char == 'i' && try_read("ntercal;") {
+        return Some(CharRef {
+            name: "ntercal;",
+            characters: "\u{22ba}",
+        });
+    }
+
+    if first_char == 'i' && try_read("ntlarhk;") {
+        return Some(CharRef {
+            name: "ntlarhk;",
+            characters: "\u{2a17}",
+        });
+    }
+
+    if first_char == 'l' && try_read("aemptyv;") {
+        return Some(CharRef {
+            name: "aemptyv;",
+            characters: "\u{29b4}",
+        });
+    }
+
+    if first_char == 'l' && try_read("drushar;") {
+        return Some(CharRef {
+            name: "drushar;",
+            characters: "\u{294b}",
+        });
+    }
+
+    if first_char == 'l' && try_read("eqslant;") {
+        return Some(CharRef {
+            name: "eqslant;",
+            characters: "\u{2a7d}",
+        });
+    }
+
+    if first_char == 'l' && try_read("esdotor;") {
+        return Some(CharRef {
+            name: "esdotor;",
+            characters: "\u{2a83}",
+        });
+    }
+
+    if first_char == 'l' && try_read("lcorner;") {
+        return Some(CharRef {
+            name: "lcorner;",
+            characters: "\u{231e}",
+        });
+    }
+
+    if first_char == 'l' && try_read("napprox;") {
+        return Some(CharRef {
+            name: "napprox;",
+            characters: "\u{2a89}",
+        });
+    }
+
+    if first_char == 'l' && try_read("rcorner;") {
+        return Some(CharRef {
+            name: "rcorner;",
+            characters: "\u{231f}",
+        });
+    }
+
+    if first_char == 'l' && try_read("urdshar;") {
+        return Some(CharRef {
+            name: "urdshar;",
+            characters: "\u{294a}",
+        });
+    }
+
+    if first_char == 'm' && try_read("apstoup;") {
+        return Some(CharRef {
+            name: "apstoup;",
+            characters: "\u{21a5}",
+        });
+    }
+
+    if first_char == 'm' && try_read("ultimap;") {
+        return Some(CharRef {
+            name: "ultimap;",
+            characters: "\u{22b8}",
+        });
+    }
+
+    if first_char == 'n' && try_read("aturals;") {
+        return Some(CharRef {
+            name: "aturals;",
+            characters: "\u{2115}",
+        });
+    }
+
+    if first_char == 'n' && try_read("congdot;") {
+        return Some(CharRef {
+            name: "congdot;",
+            characters: "\u{2a6d}\u{338}",
+        });
+    }
+
+    if first_char == 'n' && try_read("otindot;") {
+        return Some(CharRef {
+            name: "otindot;",
+            characters: "\u{22f5}\u{338}",
+        });
+    }
+
+    if first_char == 'o' && try_read("timesas;") {
+        return Some(CharRef {
+            name: "timesas;",
+            characters: "\u{2a36}",
+        });
+    }
+
+    if first_char == 'p' && try_read("arallel;") {
+        return Some(CharRef {
+            name: "arallel;",
+            characters: "\u{2225}",
+        });
+    }
+
+    if first_char == 'p' && try_read("lusacir;") {
+        return Some(CharRef {
+            name: "lusacir;",
+            characters: "\u{2a23}",
+        });
+    }
+
+    if first_char == 'p' && try_read("ointint;") {
+        return Some(CharRef {
+            name: "ointint;",
+            characters: "\u{2a15}",
+        });
+    }
+
+    if first_char == 'p' && try_read("recneqq;") {
+        return Some(CharRef {
+            name: "recneqq;",
+            characters: "\u{2ab5}",
+        });
+    }
+
+    if first_char == 'p' && try_read("recnsim;") {
+        return Some(CharRef {
+            name: "recnsim;",
+            characters: "\u{22e8}",
+        });
+    }
+
+    if first_char == 'p' && try_read("rofalar;") {
+        return Some(CharRef {
+            name: "rofalar;",
+            characters: "\u{232e}",
+        });
+    }
+
+    if first_char == 'p' && try_read("rofline;") {
+        return Some(CharRef {
+            name: "rofline;",
+            characters: "\u{2312}",
+        });
+    }
+
+    if first_char == 'p' && try_read("rofsurf;") {
+        return Some(CharRef {
+            name: "rofsurf;",
+            characters: "\u{2313}",
+        });
+    }
+
+    if first_char == 'r' && try_read("aemptyv;") {
+        return Some(CharRef {
+            name: "aemptyv;",
+            characters: "\u{29b3}",
+        });
+    }
+
+    if first_char == 'r' && try_read("ealpart;") {
+        return Some(CharRef {
+            name: "ealpart;",
+            characters: "\u{211c}",
+        });
+    }
+
+    if first_char == 'r' && try_read("ppolint;") {
+        return Some(CharRef {
+            name: "ppolint;",
+            characters: "\u{2a12}",
+        });
+    }
+
+    if first_char == 'r' && try_read("triltri;") {
+        return Some(CharRef {
+            name: "triltri;",
+            characters: "\u{29ce}",
+        });
+    }
+
+    if first_char == 's' && try_read("cpolint;") {
+        return Some(CharRef {
+            name: "cpolint;",
+            characters: "\u{2a13}",
+        });
+    }
+
+    if first_char == 's' && try_read("etminus;") {
+        return Some(CharRef {
+            name: "etminus;",
+            characters: "\u{2216}",
+        });
+    }
+
+    if first_char == 's' && try_read("hortmid;") {
+        return Some(CharRef {
+            name: "hortmid;",
+            characters: "\u{2223}",
+        });
+    }
+
+    if first_char == 's' && try_read("meparsl;") {
+        return Some(CharRef {
+            name: "meparsl;",
+            characters: "\u{29e4}",
+        });
+    }
+
+    if first_char == 's' && try_read("qsubset;") {
+        return Some(CharRef {
+            name: "qsubset;",
+            characters: "\u{228f}",
+        });
+    }
+
+    if first_char == 's' && try_read("qsupset;") {
+        return Some(CharRef {
+            name: "qsupset;",
+            characters: "\u{2290}",
+        });
+    }
+
+    if first_char == 's' && try_read("ubseteq;") {
+        return Some(CharRef {
+            name: "ubseteq;",
+            characters: "\u{2286}",
+        });
+    }
+
+    if first_char == 's' && try_read("uccneqq;") {
+        return Some(CharRef {
+            name: "uccneqq;",
+            characters: "\u{2ab6}",
+        });
+    }
+
+    if first_char == 's' && try_read("uccnsim;") {
+        return Some(CharRef {
+            name: "uccnsim;",
+            characters: "\u{22e9}",
+        });
+    }
+
+    if first_char == 's' && try_read("upseteq;") {
+        return Some(CharRef {
+            name: "upseteq;",
+            characters: "\u{2287}",
+        });
+    }
+
+    if first_char == 't' && try_read("hetasym;") {
+        return Some(CharRef {
+            name: "hetasym;",
+            characters: "\u{3d1}",
+        });
+    }
+
+    if first_char == 't' && try_read("hicksim;") {
+        return Some(CharRef {
+            name: "hicksim;",
+            characters: "\u{223c}",
+        });
+    }
+
+    if first_char == 't' && try_read("imesbar;") {
+        return Some(CharRef {
+            name: "imesbar;",
+            characters: "\u{2a31}",
+        });
+    }
+
+    if first_char == 't' && try_read("riangle;") {
+        return Some(CharRef {
+            name: "riangle;",
+            characters: "\u{25b5}",
+        });
+    }
+
+    if first_char == 't' && try_read("riminus;") {
+        return Some(CharRef {
+            name: "riminus;",
+            characters: "\u{2a3a}",
+        });
+    }
+
+    if first_char == 't' && try_read("rpezium;") {
+        return Some(CharRef {
+            name: "rpezium;",
+            characters: "\u{23e2}",
+        });
+    }
+
+    if first_char == 'u' && try_read("lcorner;") {
+        return Some(CharRef {
+            name: "lcorner;",
+            characters: "\u{231c}",
+        });
+    }
+
+    if first_char == 'u' && try_read("rcorner;") {
+        return Some(CharRef {
+            name: "rcorner;",
+            characters: "\u{231d}",
+        });
+    }
+
+    if first_char == 'v' && try_read("arkappa;") {
+        return Some(CharRef {
+            name: "arkappa;",
+            characters: "\u{3f0}",
+        });
+    }
+
+    if first_char == 'v' && try_read("arsigma;") {
+        return Some(CharRef {
+            name: "arsigma;",
+            characters: "\u{3c2}",
+        });
+    }
+
+    if first_char == 'v' && try_read("artheta;") {
+        return Some(CharRef {
+            name: "artheta;",
+            characters: "\u{3d1}",
+        });
+    }
+
+    if first_char == 'B' && try_read("ecause;") {
+        return Some(CharRef {
+            name: "ecause;",
+            characters: "\u{2235}",
+        });
+    }
+
+    if first_char == 'C' && try_read("ayleys;") {
+        return Some(CharRef {
+            name: "ayleys;",
+            characters: "\u{212d}",
+        });
+    }
+
+    if first_char == 'C' && try_read("conint;") {
+        return Some(CharRef {
+            name: "conint;",
+            characters: "\u{2230}",
+        });
+    }
+
+    if first_char == 'C' && try_read("edilla;") {
+        return Some(CharRef {
+            name: "edilla;",
+            characters: "\u{b8}",
+        });
+    }
+
+    if first_char == 'D' && try_read("iamond;") {
+        return Some(CharRef {
+            name: "iamond;",
+            characters: "\u{22c4}",
+        });
+    }
+
+    if first_char == 'D' && try_read("ownTee;") {
+        return Some(CharRef {
+            name: "ownTee;",
+            characters: "\u{22a4}",
+        });
+    }
+
+    if first_char == 'E' && try_read("lement;") {
+        return Some(CharRef {
+            name: "lement;",
+            characters: "\u{2208}",
+        });
+    }
+
+    if first_char == 'E' && try_read("psilon;") {
+        return Some(CharRef {
+            name: "psilon;",
+            characters: "\u{395}",
+        });
+    }
+
+    if first_char == 'I' && try_read("mplies;") {
+        return Some(CharRef {
+            name: "mplies;",
+            characters: "\u{21d2}",
+        });
+    }
+
+    if first_char == 'L' && try_read("eftTee;") {
+        return Some(CharRef {
+            name: "eftTee;",
+            characters: "\u{22a3}",
+        });
+    }
+
+    if first_char == 'N' && try_read("ewLine;") {
+        return Some(CharRef {
+            name: "ewLine;",
+            characters: "\u{a}",
+        });
+    }
+
+    if first_char == 'N' && try_read("oBreak;") {
+        return Some(CharRef {
+            name: "oBreak;",
+            characters: "\u{2060}",
+        });
+    }
+
+    if first_char == 'N' && try_read("otLess;") {
+        return Some(CharRef {
+            name: "otLess;",
+            characters: "\u{226e}",
+        });
+    }
+
+    if first_char == 'O' && try_read("micron;") {
+        return Some(CharRef {
+            name: "micron;",
+            characters: "\u{39f}",
+        });
+    }
+
+    if first_char == 'O' && try_read("verBar;") {
+        return Some(CharRef {
+            name: "verBar;",
+            characters: "\u{203e}",
+        });
+    }
+
+    if first_char == 'P' && try_read("roduct;") {
+        return Some(CharRef {
+            name: "roduct;",
+            characters: "\u{220f}",
+        });
+    }
+
+    if first_char == 'U' && try_read("pArrow;") {
+        return Some(CharRef {
+            name: "pArrow;",
+            characters: "\u{2191}",
+        });
+    }
+
+    if first_char == 'U' && try_read("parrow;") {
+        return Some(CharRef {
+            name: "parrow;",
+            characters: "\u{21d1}",
+        });
+    }
+
+    if first_char == 'U' && try_read("psilon;") {
+        return Some(CharRef {
+            name: "psilon;",
+            characters: "\u{3a5}",
+        });
+    }
+
+    if first_char == 'a' && try_read("lefsym;") {
+        return Some(CharRef {
+            name: "lefsym;",
+            characters: "\u{2135}",
+        });
+    }
+
+    if first_char == 'a' && try_read("ngrtvb;") {
+        return Some(CharRef {
+            name: "ngrtvb;",
+            characters: "\u{22be}",
+        });
+    }
+
+    if first_char == 'a' && try_read("ngzarr;") {
+        return Some(CharRef {
+            name: "ngzarr;",
+            characters: "\u{237c}",
+        });
+    }
+
+    if first_char == 'a' && try_read("sympeq;") {
+        return Some(CharRef {
+            name: "sympeq;",
+            characters: "\u{224d}",
+        });
+    }
+
+    if first_char == 'b' && try_read("acksim;") {
+        return Some(CharRef {
+            name: "acksim;",
+            characters: "\u{223d}",
+        });
+    }
+
+    if first_char == 'b' && try_read("ecause;") {
+        return Some(CharRef {
+            name: "ecause;",
+            characters: "\u{2235}",
+        });
+    }
+
+    if first_char == 'b' && try_read("emptyv;") {
+        return Some(CharRef {
+            name: "emptyv;",
+            characters: "\u{29b0}",
+        });
+    }
+
+    if first_char == 'b' && try_read("etween;") {
+        return Some(CharRef {
+            name: "etween;",
+            characters: "\u{226c}",
+        });
+    }
+
+    if first_char == 'b' && try_read("igcirc;") {
+        return Some(CharRef {
+            name: "igcirc;",
+            characters: "\u{25ef}",
+        });
+    }
+
+    if first_char == 'b' && try_read("igodot;") {
+        return Some(CharRef {
+            name: "igodot;",
+            characters: "\u{2a00}",
+        });
+    }
+
+    if first_char == 'b' && try_read("igstar;") {
+        return Some(CharRef {
+            name: "igstar;",
+            characters: "\u{2605}",
+        });
+    }
+
+    if first_char == 'b' && try_read("nequiv;") {
+        return Some(CharRef {
+            name: "nequiv;",
+            characters: "\u{2261}\u{20e5}",
+        });
+    }
+
+    if first_char == 'b' && try_read("oxplus;") {
+        return Some(CharRef {
+            name: "oxplus;",
+            characters: "\u{229e}",
+        });
+    }
+
+    if first_char == 'c' && try_read("cupssm;") {
+        return Some(CharRef {
+            name: "cupssm;",
+            characters: "\u{2a50}",
+        });
+    }
+
+    if first_char == 'c' && try_read("emptyv;") {
+        return Some(CharRef {
+            name: "emptyv;",
+            characters: "\u{29b2}",
+        });
+    }
+
+    if first_char == 'c' && try_read("irscir;") {
+        return Some(CharRef {
+            name: "irscir;",
+            characters: "\u{29c2}",
+        });
+    }
+
+    if first_char == 'c' && try_read("oloneq;") {
+        return Some(CharRef {
+            name: "oloneq;",
+            characters: "\u{2254}",
+        });
+    }
+
+    if first_char == 'c' && try_read("ongdot;") {
+        return Some(CharRef {
+            name: "ongdot;",
+            characters: "\u{2a6d}",
+        });
+    }
+
+    if first_char == 'c' && try_read("udarrl;") {
+        return Some(CharRef {
+            name: "udarrl;",
+            characters: "\u{2938}",
+        });
+    }
+
+    if first_char == 'c' && try_read("udarrr;") {
+        return Some(CharRef {
+            name: "udarrr;",
+            characters: "\u{2935}",
+        });
+    }
+
+    if first_char == 'c' && try_read("ularrp;") {
+        return Some(CharRef {
+            name: "ularrp;",
+            characters: "\u{293d}",
+        });
+    }
+
+    if first_char == 'c' && try_read("urarrm;") {
+        return Some(CharRef {
+            name: "urarrm;",
+            characters: "\u{293c}",
+        });
+    }
+
+    if first_char == 'd' && try_read("bkarow;") {
+        return Some(CharRef {
+            name: "bkarow;",
+            characters: "\u{290f}",
+        });
+    }
+
+    if first_char == 'd' && try_read("dagger;") {
+        return Some(CharRef {
+            name: "dagger;",
+            characters: "\u{2021}",
+        });
+    }
+
+    if first_char == 'd' && try_read("dotseq;") {
+        return Some(CharRef {
+            name: "dotseq;",
+            characters: "\u{2a77}",
+        });
+    }
+
+    if first_char == 'd' && try_read("emptyv;") {
+        return Some(CharRef {
+            name: "emptyv;",
+            characters: "\u{29b1}",
+        });
+    }
+
+    if first_char == 'd' && try_read("iamond;") {
+        return Some(CharRef {
+            name: "iamond;",
+            characters: "\u{22c4}",
+        });
+    }
+
+    if first_char == 'd' && try_read("igamma;") {
+        return Some(CharRef {
+            name: "igamma;",
+            characters: "\u{3dd}",
+        });
+    }
+
+    if first_char == 'd' && try_read("otplus;") {
+        return Some(CharRef {
+            name: "otplus;",
+            characters: "\u{2214}",
+        });
+    }
+
+    if first_char == 'd' && try_read("wangle;") {
+        return Some(CharRef {
+            name: "wangle;",
+            characters: "\u{29a6}",
+        });
+    }
+
+    if first_char == 'e' && try_read("psilon;") {
+        return Some(CharRef {
+            name: "psilon;",
+            characters: "\u{3b5}",
+        });
+    }
+
+    if first_char == 'e' && try_read("qcolon;") {
+        return Some(CharRef {
+            name: "qcolon;",
+            characters: "\u{2255}",
+        });
+    }
+
+    if first_char == 'e' && try_read("quivDD;") {
+        return Some(CharRef {
+            name: "quivDD;",
+            characters: "\u{2a78}",
+        });
+    }
+
+    if first_char == 'g' && try_read("esdoto;") {
+        return Some(CharRef {
+            name: "esdoto;",
+            characters: "\u{2a82}",
+        });
+    }
+
+    if first_char == 'g' && try_read("tquest;") {
+        return Some(CharRef {
+            name: "tquest;",
+            characters: "\u{2a7c}",
+        });
+    }
+
+    if first_char == 'g' && try_read("trless;") {
+        return Some(CharRef {
+            name: "trless;",
+            characters: "\u{2277}",
+        });
+    }
+
+    if first_char == 'h' && try_read("arrcir;") {
+        return Some(CharRef {
+            name: "arrcir;",
+            characters: "\u{2948}",
+        });
+    }
+
+    if first_char == 'i' && try_read("ntprod;") {
+        return Some(CharRef {
+            name: "ntprod;",
+            characters: "\u{2a3c}",
+        });
+    }
+
+    if first_char == 'i' && try_read("sindot;") {
+        return Some(CharRef {
+            name: "sindot;",
+            characters: "\u{22f5}",
+        });
+    }
+
+    if first_char == 'l' && try_read("arrbfs;") {
+        return Some(CharRef {
+            name: "arrbfs;",
+            characters: "\u{291f}",
+        });
+    }
+
+    if first_char == 'l' && try_read("arrsim;") {
+        return Some(CharRef {
+            name: "arrsim;",
+            characters: "\u{2973}",
+        });
+    }
+
+    if first_char == 'l' && try_read("brksld;") {
+        return Some(CharRef {
+            name: "brksld;",
+            characters: "\u{298f}",
+        });
+    }
+
+    if first_char == 'l' && try_read("brkslu;") {
+        return Some(CharRef {
+            name: "brkslu;",
+            characters: "\u{298d}",
+        });
+    }
+
+    if first_char == 'l' && try_read("drdhar;") {
+        return Some(CharRef {
+            name: "drdhar;",
+            characters: "\u{2967}",
+        });
+    }
+
+    if first_char == 'l' && try_read("esdoto;") {
+        return Some(CharRef {
+            name: "esdoto;",
+            characters: "\u{2a81}",
+        });
+    }
+
+    if first_char == 'l' && try_read("essdot;") {
+        return Some(CharRef {
+            name: "essdot;",
+            characters: "\u{22d6}",
+        });
+    }
+
+    if first_char == 'l' && try_read("essgtr;") {
+        return Some(CharRef {
+            name: "essgtr;",
+            characters: "\u{2276}",
+        });
+    }
+
+    if first_char == 'l' && try_read("esssim;") {
+        return Some(CharRef {
+            name: "esssim;",
+            characters: "\u{2272}",
+        });
+    }
+
+    if first_char == 'l' && try_read("otimes;") {
+        return Some(CharRef {
+            name: "otimes;",
+            characters: "\u{2a34}",
+        });
+    }
+
+    if first_char == 'l' && try_read("ozenge;") {
+        return Some(CharRef {
+            name: "ozenge;",
+            characters: "\u{25ca}",
+        });
+    }
+
+    if first_char == 'l' && try_read("tquest;") {
+        return Some(CharRef {
+            name: "tquest;",
+            characters: "\u{2a7b}",
+        });
+    }
+
+    if first_char == 'l' && try_read("uruhar;") {
+        return Some(CharRef {
+            name: "uruhar;",
+            characters: "\u{2966}",
+        });
+    }
+
+    if first_char == 'm' && try_read("altese;") {
+        return Some(CharRef {
+            name: "altese;",
+            characters: "\u{2720}",
+        });
+    }
+
+    if first_char == 'm' && try_read("inusdu;") {
+        return Some(CharRef {
+            name: "inusdu;",
+            characters: "\u{2a2a}",
+        });
+    }
+
+    if first_char == 'n' && try_read("approx;") {
+        return Some(CharRef {
+            name: "approx;",
+            characters: "\u{2249}",
+        });
+    }
+
+    if first_char == 'n' && try_read("atural;") {
+        return Some(CharRef {
+            name: "atural;",
+            characters: "\u{266e}",
+        });
+    }
+
+    if first_char == 'n' && try_read("earrow;") {
+        return Some(CharRef {
+            name: "earrow;",
+            characters: "\u{2197}",
+        });
+    }
+
+    if first_char == 'n' && try_read("exists;") {
+        return Some(CharRef {
+            name: "exists;",
+            characters: "\u{2204}",
+        });
+    }
+
+    if first_char == 'n' && try_read("otinva;") {
+        return Some(CharRef {
+            name: "otinva;",
+            characters: "\u{2209}",
+        });
+    }
+
+    if first_char == 'n' && try_read("otinvb;") {
+        return Some(CharRef {
+            name: "otinvb;",
+            characters: "\u{22f7}",
+        });
+    }
+
+    if first_char == 'n' && try_read("otinvc;") {
+        return Some(CharRef {
+            name: "otinvc;",
+            characters: "\u{22f6}",
+        });
+    }
+
+    if first_char == 'n' && try_read("otniva;") {
+        return Some(CharRef {
+            name: "otniva;",
+            characters: "\u{220c}",
+        });
+    }
+
+    if first_char == 'n' && try_read("otnivb;") {
+        return Some(CharRef {
+            name: "otnivb;",
+            characters: "\u{22fe}",
+        });
+    }
+
+    if first_char == 'n' && try_read("otnivc;") {
+        return Some(CharRef {
+            name: "otnivc;",
+            characters: "\u{22fd}",
+        });
+    }
+
+    if first_char == 'n' && try_read("polint;") {
+        return Some(CharRef {
+            name: "polint;",
+            characters: "\u{2a14}",
+        });
+    }
+
+    if first_char == 'n' && try_read("preceq;") {
+        return Some(CharRef {
+            name: "preceq;",
+            characters: "\u{2aaf}\u{338}",
+        });
+    }
+
+    if first_char == 'n' && try_read("sqsube;") {
+        return Some(CharRef {
+            name: "sqsube;",
+            characters: "\u{22e2}",
+        });
+    }
+
+    if first_char == 'n' && try_read("sqsupe;") {
+        return Some(CharRef {
+            name: "sqsupe;",
+            characters: "\u{22e3}",
+        });
+    }
+
+    if first_char == 'n' && try_read("subset;") {
+        return Some(CharRef {
+            name: "subset;",
+            characters: "\u{2282}\u{20d2}",
+        });
+    }
+
+    if first_char == 'n' && try_read("succeq;") {
+        return Some(CharRef {
+            name: "succeq;",
+            characters: "\u{2ab0}\u{338}",
+        });
+    }
+
+    if first_char == 'n' && try_read("supset;") {
+        return Some(CharRef {
+            name: "supset;",
+            characters: "\u{2283}\u{20d2}",
+        });
+    }
+
+    if first_char == 'n' && try_read("vinfin;") {
+        return Some(CharRef {
+            name: "vinfin;",
+            characters: "\u{29de}",
+        });
+    }
+
+    if first_char == 'n' && try_read("vltrie;") {
+        return Some(CharRef {
+            name: "vltrie;",
+            characters: "\u{22b4}\u{20d2}",
+        });
+    }
+
+    if first_char == 'n' && try_read("vrtrie;") {
+        return Some(CharRef {
+            name: "vrtrie;",
+            characters: "\u{22b5}\u{20d2}",
+        });
+    }
+
+    if first_char == 'n' && try_read("warrow;") {
+        return Some(CharRef {
+            name: "warrow;",
+            characters: "\u{2196}",
+        });
+    }
+
+    if first_char == 'o' && try_read("lcross;") {
+        return Some(CharRef {
+            name: "lcross;",
+            characters: "\u{29bb}",
+        });
+    }
+
+    if first_char == 'o' && try_read("micron;") {
+        return Some(CharRef {
+            name: "micron;",
+            characters: "\u{3bf}",
+        });
+    }
+
+    if first_char == 'o' && try_read("rderof;") {
+        return Some(CharRef {
+            name: "rderof;",
+            characters: "\u{2134}",
+        });
+    }
+
+    if first_char == 'o' && try_read("rslope;") {
+        return Some(CharRef {
+            name: "rslope;",
+            characters: "\u{2a57}",
+        });
+    }
+
+    if first_char == 'p' && try_read("ertenk;") {
+        return Some(CharRef {
+            name: "ertenk;",
+            characters: "\u{2031}",
+        });
+    }
+
+    if first_char == 'p' && try_read("lanckh;") {
+        return Some(CharRef {
+            name: "lanckh;",
+            characters: "\u{210e}",
+        });
+    }
+
+    if first_char == 'p' && try_read("luscir;") {
+        return Some(CharRef {
+            name: "luscir;",
+            characters: "\u{2a22}",
+        });
+    }
+
+    if first_char == 'p' && try_read("lussim;") {
+        return Some(CharRef {
+            name: "lussim;",
+            characters: "\u{2a26}",
+        });
+    }
+
+    if first_char == 'p' && try_read("lustwo;") {
+        return Some(CharRef {
+            name: "lustwo;",
+            characters: "\u{2a27}",
+        });
+    }
+
+    if first_char == 'p' && try_read("recsim;") {
+        return Some(CharRef {
+            name: "recsim;",
+            characters: "\u{227e}",
+        });
+    }
+
+    if first_char == 'q' && try_read("uatint;") {
+        return Some(CharRef {
+            name: "uatint;",
+            characters: "\u{2a16}",
+        });
+    }
+
+    if first_char == 'q' && try_read("uesteq;") {
+        return Some(CharRef {
+            name: "uesteq;",
+            characters: "\u{225f}",
+        });
+    }
+
+    if first_char == 'r' && try_read("arrbfs;") {
+        return Some(CharRef {
+            name: "arrbfs;",
+            characters: "\u{2920}",
+        });
+    }
+
+    if first_char == 'r' && try_read("arrsim;") {
+        return Some(CharRef {
+            name: "arrsim;",
+            characters: "\u{2974}",
+        });
+    }
+
+    if first_char == 'r' && try_read("brksld;") {
+        return Some(CharRef {
+            name: "brksld;",
+            characters: "\u{298e}",
+        });
+    }
+
+    if first_char == 'r' && try_read("brkslu;") {
+        return Some(CharRef {
+            name: "brkslu;",
+            characters: "\u{2990}",
+        });
+    }
+
+    if first_char == 'r' && try_read("dldhar;") {
+        return Some(CharRef {
+            name: "dldhar;",
+            characters: "\u{2969}",
+        });
+    }
+
+    if first_char == 'r' && try_read("ealine;") {
+        return Some(CharRef {
+            name: "ealine;",
+            characters: "\u{211b}",
+        });
+    }
+
+    if first_char == 'r' && try_read("otimes;") {
+        return Some(CharRef {
+            name: "otimes;",
+            characters: "\u{2a35}",
+        });
+    }
+
+    if first_char == 'r' && try_read("uluhar;") {
+        return Some(CharRef {
+            name: "uluhar;",
+            characters: "\u{2968}",
+        });
+    }
+
+    if first_char == 's' && try_read("earrow;") {
+        return Some(CharRef {
+            name: "earrow;",
+            characters: "\u{2198}",
+        });
+    }
+
+    if first_char == 's' && try_read("implus;") {
+        return Some(CharRef {
+            name: "implus;",
+            characters: "\u{2a24}",
+        });
+    }
+
+    if first_char == 's' && try_read("imrarr;") {
+        return Some(CharRef {
+            name: "imrarr;",
+            characters: "\u{2972}",
+        });
+    }
+
+    if first_char == 's' && try_read("ubedot;") {
+        return Some(CharRef {
+            name: "ubedot;",
+            characters: "\u{2ac3}",
+        });
+    }
+
+    if first_char == 's' && try_read("ubmult;") {
+        return Some(CharRef {
+            name: "ubmult;",
+            characters: "\u{2ac1}",
+        });
+    }
+
+    if first_char == 's' && try_read("ubplus;") {
+        return Some(CharRef {
+            name: "ubplus;",
+            characters: "\u{2abf}",
+        });
+    }
+
+    if first_char == 's' && try_read("ubrarr;") {
+        return Some(CharRef {
+            name: "ubrarr;",
+            characters: "\u{2979}",
+        });
+    }
+
+    if first_char == 's' && try_read("uccsim;") {
+        return Some(CharRef {
+            name: "uccsim;",
+            characters: "\u{227f}",
+        });
+    }
+
+    if first_char == 's' && try_read("updsub;") {
+        return Some(CharRef {
+            name: "updsub;",
+            characters: "\u{2ad8}",
+        });
+    }
+
+    if first_char == 's' && try_read("upedot;") {
+        return Some(CharRef {
+            name: "upedot;",
+            characters: "\u{2ac4}",
+        });
+    }
+
+    if first_char == 's' && try_read("uphsol;") {
+        return Some(CharRef {
+            name: "uphsol;",
+            characters: "\u{27c9}",
+        });
+    }
+
+    if first_char == 's' && try_read("uphsub;") {
+        return Some(CharRef {
+            name: "uphsub;",
+            characters: "\u{2ad7}",
+        });
+    }
+
+    if first_char == 's' && try_read("uplarr;") {
+        return Some(CharRef {
+            name: "uplarr;",
+            characters: "\u{297b}",
+        });
+    }
+
+    if first_char == 's' && try_read("upmult;") {
+        return Some(CharRef {
+            name: "upmult;",
+            characters: "\u{2ac2}",
+        });
+    }
+
+    if first_char == 's' && try_read("upplus;") {
+        return Some(CharRef {
+            name: "upplus;",
+            characters: "\u{2ac0}",
+        });
+    }
+
+    if first_char == 's' && try_read("warrow;") {
+        return Some(CharRef {
+            name: "warrow;",
+            characters: "\u{2199}",
+        });
+    }
+
+    if first_char == 't' && try_read("opfork;") {
+        return Some(CharRef {
+            name: "opfork;",
+            characters: "\u{2ada}",
+        });
+    }
+
+    if first_char == 't' && try_read("riplus;") {
+        return Some(CharRef {
+            name: "riplus;",
+            characters: "\u{2a39}",
+        });
+    }
+
+    if first_char == 't' && try_read("ritime;") {
+        return Some(CharRef {
+            name: "ritime;",
+            characters: "\u{2a3b}",
+        });
+    }
+
+    if first_char == 'u' && try_read("parrow;") {
+        return Some(CharRef {
+            name: "parrow;",
+            characters: "\u{2191}",
+        });
+    }
+
+    if first_char == 'u' && try_read("psilon;") {
+        return Some(CharRef {
+            name: "psilon;",
+            characters: "\u{3c5}",
+        });
+    }
+
+    if first_char == 'u' && try_read("wangle;") {
+        return Some(CharRef {
+            name: "wangle;",
+            characters: "\u{29a7}",
+        });
+    }
+
+    if first_char == 'v' && try_read("zigzag;") {
+        return Some(CharRef {
+            name: "zigzag;",
+            characters: "\u{299a}",
+        });
+    }
+
+    if first_char == 'z' && try_read("igrarr;") {
+        return Some(CharRef {
+            name: "igrarr;",
+            characters: "\u{21dd}",
+        });
+    }
+
+    if first_char == 'A' && try_read("acute;") {
+        return Some(CharRef {
+            name: "acute;",
+            characters: "\u{c1}",
+        });
+    }
+
+    if first_char == 'A' && try_read("breve;") {
+        return Some(CharRef {
+            name: "breve;",
+            characters: "\u{102}",
+        });
+    }
+
+    if first_char == 'A' && try_read("grave;") {
+        return Some(CharRef {
+            name: "grave;",
+            characters: "\u{c0}",
+        });
+    }
+
+    if first_char == 'A' && try_read("ssign;") {
+        return Some(CharRef {
+            name: "ssign;",
+            characters: "\u{2254}",
+        });
+    }
+
+    if first_char == 'A' && try_read("tilde;") {
+        return Some(CharRef {
+            name: "tilde;",
+            characters: "\u{c3}",
+        });
+    }
+
+    if first_char == 'B' && try_read("arwed;") {
+        return Some(CharRef {
+            name: "arwed;",
+            characters: "\u{2306}",
+        });
+    }
+
+    if first_char == 'B' && try_read("umpeq;") {
+        return Some(CharRef {
+            name: "umpeq;",
+            characters: "\u{224e}",
+        });
+    }
+
+    if first_char == 'C' && try_read("acute;") {
+        return Some(CharRef {
+            name: "acute;",
+            characters: "\u{106}",
+        });
+    }
+
+    if first_char == 'C' && try_read("caron;") {
+        return Some(CharRef {
+            name: "caron;",
+            characters: "\u{10c}",
+        });
+    }
+
+    if first_char == 'C' && try_read("cedil;") {
+        return Some(CharRef {
+            name: "cedil;",
+            characters: "\u{c7}",
+        });
+    }
+
+    if first_char == 'C' && try_read("olone;") {
+        return Some(CharRef {
+            name: "olone;",
+            characters: "\u{2a74}",
+        });
+    }
+
+    if first_char == 'C' && try_read("onint;") {
+        return Some(CharRef {
+            name: "onint;",
+            characters: "\u{222f}",
+        });
+    }
+
+    if first_char == 'C' && try_read("upCap;") {
+        return Some(CharRef {
+            name: "upCap;",
+            characters: "\u{224d}",
+        });
+    }
+
+    if first_char == 'D' && try_read("agger;") {
+        return Some(CharRef {
+            name: "agger;",
+            characters: "\u{2021}",
+        });
+    }
+
+    if first_char == 'D' && try_read("caron;") {
+        return Some(CharRef {
+            name: "caron;",
+            characters: "\u{10e}",
+        });
+    }
+
+    if first_char == 'D' && try_read("otDot;") {
+        return Some(CharRef {
+            name: "otDot;",
+            characters: "\u{20dc}",
+        });
+    }
+
+    if first_char == 'D' && try_read("strok;") {
+        return Some(CharRef {
+            name: "strok;",
+            characters: "\u{110}",
+        });
+    }
+
+    if first_char == 'E' && try_read("acute;") {
+        return Some(CharRef {
+            name: "acute;",
+            characters: "\u{c9}",
+        });
+    }
+
+    if first_char == 'E' && try_read("caron;") {
+        return Some(CharRef {
+            name: "caron;",
+            characters: "\u{11a}",
+        });
+    }
+
+    if first_char == 'E' && try_read("grave;") {
+        return Some(CharRef {
+            name: "grave;",
+            characters: "\u{c8}",
+        });
+    }
+
+    if first_char == 'E' && try_read("xists;") {
+        return Some(CharRef {
+            name: "xists;",
+            characters: "\u{2203}",
+        });
+    }
+
+    if first_char == 'F' && try_read("orAll;") {
+        return Some(CharRef {
+            name: "orAll;",
+            characters: "\u{2200}",
+        });
+    }
+
+    if first_char == 'G' && try_read("ammad;") {
+        return Some(CharRef {
+            name: "ammad;",
+            characters: "\u{3dc}",
+        });
+    }
+
+    if first_char == 'G' && try_read("breve;") {
+        return Some(CharRef {
+            name: "breve;",
+            characters: "\u{11e}",
+        });
+    }
+
+    if first_char == 'G' && try_read("cedil;") {
+        return Some(CharRef {
+            name: "cedil;",
+            characters: "\u{122}",
+        });
+    }
+
+    if first_char == 'H' && try_read("ARDcy;") {
+        return Some(CharRef {
+            name: "ARDcy;",
+            characters: "\u{42a}",
+        });
+    }
+
+    if first_char == 'H' && try_read("strok;") {
+        return Some(CharRef {
+            name: "strok;",
+            characters: "\u{126}",
+        });
+    }
+
+    if first_char == 'I' && try_read("acute;") {
+        return Some(CharRef {
+            name: "acute;",
+            characters: "\u{cd}",
+        });
+    }
+
+    if first_char == 'I' && try_read("grave;") {
+        return Some(CharRef {
+            name: "grave;",
+            characters: "\u{cc}",
+        });
+    }
+
+    if first_char == 'I' && try_read("tilde;") {
+        return Some(CharRef {
+            name: "tilde;",
+            characters: "\u{128}",
+        });
+    }
+
+    if first_char == 'J' && try_read("sercy;") {
+        return Some(CharRef {
+            name: "sercy;",
+            characters: "\u{408}",
+        });
+    }
+
+    if first_char == 'K' && try_read("cedil;") {
+        return Some(CharRef {
+            name: "cedil;",
+            characters: "\u{136}",
+        });
+    }
+
+    if first_char == 'L' && try_read("acute;") {
+        return Some(CharRef {
+            name: "acute;",
+            characters: "\u{139}",
+        });
+    }
+
+    if first_char == 'L' && try_read("ambda;") {
+        return Some(CharRef {
+            name: "ambda;",
+            characters: "\u{39b}",
+        });
+    }
+
+    if first_char == 'L' && try_read("caron;") {
+        return Some(CharRef {
+            name: "caron;",
+            characters: "\u{13d}",
+        });
+    }
+
+    if first_char == 'L' && try_read("cedil;") {
+        return Some(CharRef {
+            name: "cedil;",
+            characters: "\u{13b}",
+        });
+    }
+
+    if first_char == 'L' && try_read("midot;") {
+        return Some(CharRef {
+            name: "midot;",
+            characters: "\u{13f}",
+        });
+    }
+
+    if first_char == 'L' && try_read("strok;") {
+        return Some(CharRef {
+            name: "strok;",
+            characters: "\u{141}",
+        });
+    }
+
+    if first_char == 'N' && try_read("acute;") {
+        return Some(CharRef {
+            name: "acute;",
+            characters: "\u{143}",
+        });
+    }
+
+    if first_char == 'N' && try_read("caron;") {
+        return Some(CharRef {
+            name: "caron;",
+            characters: "\u{147}",
+        });
+    }
+
+    if first_char == 'N' && try_read("cedil;") {
+        return Some(CharRef {
+            name: "cedil;",
+            characters: "\u{145}",
+        });
+    }
+
+    if first_char == 'N' && try_read("tilde;") {
+        return Some(CharRef {
+            name: "tilde;",
+            characters: "\u{d1}",
+        });
+    }
+
+    if first_char == 'O' && try_read("acute;") {
+        return Some(CharRef {
+            name: "acute;",
+            characters: "\u{d3}",
+        });
+    }
+
+    if first_char == 'O' && try_read("dblac;") {
+        return Some(CharRef {
+            name: "dblac;",
+            characters: "\u{150}",
+        });
+    }
+
+    if first_char == 'O' && try_read("grave;") {
+        return Some(CharRef {
+            name: "grave;",
+            characters: "\u{d2}",
+        });
+    }
+
+    if first_char == 'O' && try_read("slash;") {
+        return Some(CharRef {
+            name: "slash;",
+            characters: "\u{d8}",
+        });
+    }
+
+    if first_char == 'O' && try_read("tilde;") {
+        return Some(CharRef {
+            name: "tilde;",
+            characters: "\u{d5}",
+        });
+    }
+
+    if first_char == 'O' && try_read("times;") {
+        return Some(CharRef {
+            name: "times;",
+            characters: "\u{2a37}",
+        });
+    }
+
+    if first_char == 'R' && try_read("acute;") {
+        return Some(CharRef {
+            name: "acute;",
+            characters: "\u{154}",
+        });
+    }
+
+    if first_char == 'R' && try_read("arrtl;") {
+        return Some(CharRef {
+            name: "arrtl;",
+            characters: "\u{2916}",
+        });
+    }
+
+    if first_char == 'R' && try_read("caron;") {
+        return Some(CharRef {
+            name: "caron;",
+            characters: "\u{158}",
+        });
+    }
+
+    if first_char == 'R' && try_read("cedil;") {
+        return Some(CharRef {
+            name: "cedil;",
+            characters: "\u{156}",
+        });
+    }
+
+    if first_char == 'S' && try_read("HCHcy;") {
+        return Some(CharRef {
+            name: "HCHcy;",
+            characters: "\u{429}",
+        });
+    }
+
+    if first_char == 'S' && try_read("OFTcy;") {
+        return Some(CharRef {
+            name: "OFTcy;",
+            characters: "\u{42c}",
+        });
+    }
+
+    if first_char == 'S' && try_read("acute;") {
+        return Some(CharRef {
+            name: "acute;",
+            characters: "\u{15a}",
+        });
+    }
+
+    if first_char == 'S' && try_read("caron;") {
+        return Some(CharRef {
+            name: "caron;",
+            characters: "\u{160}",
+        });
+    }
+
+    if first_char == 'S' && try_read("cedil;") {
+        return Some(CharRef {
+            name: "cedil;",
+            characters: "\u{15e}",
+        });
+    }
+
+    if first_char == 'S' && try_read("quare;") {
+        return Some(CharRef {
+            name: "quare;",
+            characters: "\u{25a1}",
+        });
+    }
+
+    if first_char == 'S' && try_read("ubset;") {
+        return Some(CharRef {
+            name: "ubset;",
+            characters: "\u{22d0}",
+        });
+    }
+
+    if first_char == 'S' && try_read("upset;") {
+        return Some(CharRef {
+            name: "upset;",
+            characters: "\u{22d1}",
+        });
+    }
+
+    if first_char == 'T' && try_read("caron;") {
+        return Some(CharRef {
+            name: "caron;",
+            characters: "\u{164}",
+        });
+    }
+
+    if first_char == 'T' && try_read("cedil;") {
+        return Some(CharRef {
+            name: "cedil;",
+            characters: "\u{162}",
+        });
+    }
+
+    if first_char == 'T' && try_read("strok;") {
+        return Some(CharRef {
+            name: "strok;",
+            characters: "\u{166}",
+        });
+    }
+
+    if first_char == 'U' && try_read("acute;") {
+        return Some(CharRef {
+            name: "acute;",
+            characters: "\u{da}",
+        });
+    }
+
+    if first_char == 'U' && try_read("breve;") {
+        return Some(CharRef {
+            name: "breve;",
+            characters: "\u{16c}",
+        });
+    }
+
+    if first_char == 'U' && try_read("dblac;") {
+        return Some(CharRef {
+            name: "dblac;",
+            characters: "\u{170}",
+        });
+    }
+
+    if first_char == 'U' && try_read("grave;") {
+        return Some(CharRef {
+            name: "grave;",
+            characters: "\u{d9}",
+        });
+    }
+
+    if first_char == 'U' && try_read("tilde;") {
+        return Some(CharRef {
+            name: "tilde;",
+            characters: "\u{168}",
+        });
+    }
+
+    if first_char == 'V' && try_read("dashl;") {
+        return Some(CharRef {
+            name: "dashl;",
+            characters: "\u{2ae6}",
+        });
+    }
+
+    if first_char == 'V' && try_read("erbar;") {
+        return Some(CharRef {
+            name: "erbar;",
+            characters: "\u{2016}",
+        });
+    }
+
+    if first_char == 'V' && try_read("vdash;") {
+        return Some(CharRef {
+            name: "vdash;",
+            characters: "\u{22aa}",
+        });
+    }
+
+    if first_char == 'Y' && try_read("acute;") {
+        return Some(CharRef {
+            name: "acute;",
+            characters: "\u{dd}",
+        });
+    }
+
+    if first_char == 'Z' && try_read("acute;") {
+        return Some(CharRef {
+            name: "acute;",
+            characters: "\u{179}",
+        });
+    }
+
+    if first_char == 'Z' && try_read("caron;") {
+        return Some(CharRef {
+            name: "caron;",
+            characters: "\u{17d}",
+        });
+    }
+
+    if first_char == 'a' && try_read("acute;") {
+        return Some(CharRef {
+            name: "acute;",
+            characters: "\u{e1}",
+        });
+    }
+
+    if first_char == 'a' && try_read("breve;") {
+        return Some(CharRef {
+            name: "breve;",
+            characters: "\u{103}",
+        });
+    }
+
+    if first_char == 'a' && try_read("grave;") {
+        return Some(CharRef {
+            name: "grave;",
+            characters: "\u{e0}",
+        });
+    }
+
+    if first_char == 'a' && try_read("ndand;") {
+        return Some(CharRef {
+            name: "ndand;",
+            characters: "\u{2a55}",
+        });
+    }
+
+    if first_char == 'a' && try_read("ngmsd;") {
+        return Some(CharRef {
+            name: "ngmsd;",
+            characters: "\u{2221}",
+        });
+    }
+
+    if first_char == 'a' && try_read("ngsph;") {
+        return Some(CharRef {
+            name: "ngsph;",
+            characters: "\u{2222}",
+        });
+    }
+
+    if first_char == 'a' && try_read("pacir;") {
+        return Some(CharRef {
+            name: "pacir;",
+            characters: "\u{2a6f}",
+        });
+    }
+
+    if first_char == 'a' && try_read("pprox;") {
+        return Some(CharRef {
+            name: "pprox;",
+            characters: "\u{2248}",
+        });
+    }
+
+    if first_char == 'a' && try_read("tilde;") {
+        return Some(CharRef {
+            name: "tilde;",
+            characters: "\u{e3}",
+        });
+    }
+
+    if first_char == 'b' && try_read("arvee;") {
+        return Some(CharRef {
+            name: "arvee;",
+            characters: "\u{22bd}",
+        });
+    }
+
+    if first_char == 'b' && try_read("arwed;") {
+        return Some(CharRef {
+            name: "arwed;",
+            characters: "\u{2305}",
+        });
+    }
+
+    if first_char == 'b' && try_read("ecaus;") {
+        return Some(CharRef {
+            name: "ecaus;",
+            characters: "\u{2235}",
+        });
+    }
+
+    if first_char == 'b' && try_read("ernou;") {
+        return Some(CharRef {
+            name: "ernou;",
+            characters: "\u{212c}",
+        });
+    }
+
+    if first_char == 'b' && try_read("igcap;") {
+        return Some(CharRef {
+            name: "igcap;",
+            characters: "\u{22c2}",
+        });
+    }
+
+    if first_char == 'b' && try_read("igcup;") {
+        return Some(CharRef {
+            name: "igcup;",
+            characters: "\u{22c3}",
+        });
+    }
+
+    if first_char == 'b' && try_read("igvee;") {
+        return Some(CharRef {
+            name: "igvee;",
+            characters: "\u{22c1}",
+        });
+    }
+
+    if first_char == 'b' && try_read("karow;") {
+        return Some(CharRef {
+            name: "karow;",
+            characters: "\u{290d}",
+        });
+    }
+
+    if first_char == 'b' && try_read("ottom;") {
+        return Some(CharRef {
+            name: "ottom;",
+            characters: "\u{22a5}",
+        });
+    }
+
+    if first_char == 'b' && try_read("owtie;") {
+        return Some(CharRef {
+            name: "owtie;",
+            characters: "\u{22c8}",
+        });
+    }
+
+    if first_char == 'b' && try_read("oxbox;") {
+        return Some(CharRef {
+            name: "oxbox;",
+            characters: "\u{29c9}",
+        });
+    }
+
+    if first_char == 'b' && try_read("prime;") {
+        return Some(CharRef {
+            name: "prime;",
+            characters: "\u{2035}",
+        });
+    }
+
+    if first_char == 'b' && try_read("rvbar;") {
+        return Some(CharRef {
+            name: "rvbar;",
+            characters: "\u{a6}",
+        });
+    }
+
+    if first_char == 'b' && try_read("ullet;") {
+        return Some(CharRef {
+            name: "ullet;",
+            characters: "\u{2022}",
+        });
+    }
+
+    if first_char == 'b' && try_read("umpeq;") {
+        return Some(CharRef {
+            name: "umpeq;",
+            characters: "\u{224f}",
+        });
+    }
+
+    if first_char == 'c' && try_read("acute;") {
+        return Some(CharRef {
+            name: "acute;",
+            characters: "\u{107}",
+        });
+    }
+
+    if first_char == 'c' && try_read("apand;") {
+        return Some(CharRef {
+            name: "apand;",
+            characters: "\u{2a44}",
+        });
+    }
+
+    if first_char == 'c' && try_read("apcap;") {
+        return Some(CharRef {
+            name: "apcap;",
+            characters: "\u{2a4b}",
+        });
+    }
+
+    if first_char == 'c' && try_read("apcup;") {
+        return Some(CharRef {
+            name: "apcup;",
+            characters: "\u{2a47}",
+        });
+    }
+
+    if first_char == 'c' && try_read("apdot;") {
+        return Some(CharRef {
+            name: "apdot;",
+            characters: "\u{2a40}",
+        });
+    }
+
+    if first_char == 'c' && try_read("caron;") {
+        return Some(CharRef {
+            name: "caron;",
+            characters: "\u{10d}",
+        });
+    }
+
+    if first_char == 'c' && try_read("cedil;") {
+        return Some(CharRef {
+            name: "cedil;",
+            characters: "\u{e7}",
+        });
+    }
+
+    if first_char == 'c' && try_read("irceq;") {
+        return Some(CharRef {
+            name: "irceq;",
+            characters: "\u{2257}",
+        });
+    }
+
+    if first_char == 'c' && try_read("irmid;") {
+        return Some(CharRef {
+            name: "irmid;",
+            characters: "\u{2aef}",
+        });
+    }
+
+    if first_char == 'c' && try_read("olone;") {
+        return Some(CharRef {
+            name: "olone;",
+            characters: "\u{2254}",
+        });
+    }
+
+    if first_char == 'c' && try_read("ommat;") {
+        return Some(CharRef {
+            name: "ommat;",
+            characters: "\u{40}",
+        });
+    }
+
+    if first_char == 'c' && try_read("ompfn;") {
+        return Some(CharRef {
+            name: "ompfn;",
+            characters: "\u{2218}",
+        });
+    }
+
+    if first_char == 'c' && try_read("onint;") {
+        return Some(CharRef {
+            name: "onint;",
+            characters: "\u{222e}",
+        });
+    }
+
+    if first_char == 'c' && try_read("oprod;") {
+        return Some(CharRef {
+            name: "oprod;",
+            characters: "\u{2210}",
+        });
+    }
+
+    if first_char == 'c' && try_read("opysr;") {
+        return Some(CharRef {
+            name: "opysr;",
+            characters: "\u{2117}",
+        });
+    }
+
+    if first_char == 'c' && try_read("ularr;") {
+        return Some(CharRef {
+            name: "ularr;",
+            characters: "\u{21b6}",
+        });
+    }
+
+    if first_char == 'c' && try_read("upcap;") {
+        return Some(CharRef {
+            name: "upcap;",
+            characters: "\u{2a46}",
+        });
+    }
+
+    if first_char == 'c' && try_read("upcup;") {
+        return Some(CharRef {
+            name: "upcup;",
+            characters: "\u{2a4a}",
+        });
+    }
+
+    if first_char == 'c' && try_read("updot;") {
+        return Some(CharRef {
+            name: "updot;",
+            characters: "\u{228d}",
+        });
+    }
+
+    if first_char == 'c' && try_read("urarr;") {
+        return Some(CharRef {
+            name: "urarr;",
+            characters: "\u{21b7}",
+        });
+    }
+
+    if first_char == 'c' && try_read("urren;") {
+        return Some(CharRef {
+            name: "urren;",
+            characters: "\u{a4}",
+        });
+    }
+
+    if first_char == 'c' && try_read("ylcty;") {
+        return Some(CharRef {
+            name: "ylcty;",
+            characters: "\u{232d}",
+        });
+    }
+
+    if first_char == 'd' && try_read("agger;") {
+        return Some(CharRef {
+            name: "agger;",
+            characters: "\u{2020}",
+        });
+    }
+
+    if first_char == 'd' && try_read("aleth;") {
+        return Some(CharRef {
+            name: "aleth;",
+            characters: "\u{2138}",
+        });
+    }
+
+    if first_char == 'd' && try_read("caron;") {
+        return Some(CharRef {
+            name: "caron;",
+            characters: "\u{10f}",
+        });
+    }
+
+    if first_char == 'd' && try_read("fisht;") {
+        return Some(CharRef {
+            name: "fisht;",
+            characters: "\u{297f}",
+        });
+    }
+
+    if first_char == 'd' && try_read("ivide;") {
+        return Some(CharRef {
+            name: "ivide;",
+            characters: "\u{f7}",
+        });
+    }
+
+    if first_char == 'd' && try_read("ivonx;") {
+        return Some(CharRef {
+            name: "ivonx;",
+            characters: "\u{22c7}",
+        });
+    }
+
+    if first_char == 'd' && try_read("lcorn;") {
+        return Some(CharRef {
+            name: "lcorn;",
+            characters: "\u{231e}",
+        });
+    }
+
+    if first_char == 'd' && try_read("lcrop;") {
+        return Some(CharRef {
+            name: "lcrop;",
+            characters: "\u{230d}",
+        });
+    }
+
+    if first_char == 'd' && try_read("ollar;") {
+        return Some(CharRef {
+            name: "ollar;",
+            characters: "\u{24}",
+        });
+    }
+
+    if first_char == 'd' && try_read("rcorn;") {
+        return Some(CharRef {
+            name: "rcorn;",
+            characters: "\u{231f}",
+        });
+    }
+
+    if first_char == 'd' && try_read("rcrop;") {
+        return Some(CharRef {
+            name: "rcrop;",
+            characters: "\u{230c}",
+        });
+    }
+
+    if first_char == 'd' && try_read("strok;") {
+        return Some(CharRef {
+            name: "strok;",
+            characters: "\u{111}",
+        });
+    }
+
+    if first_char == 'e' && try_read("acute;") {
+        return Some(CharRef {
+            name: "acute;",
+            characters: "\u{e9}",
+        });
+    }
+
+    if first_char == 'e' && try_read("aster;") {
+        return Some(CharRef {
+            name: "aster;",
+            characters: "\u{2a6e}",
+        });
+    }
+
+    if first_char == 'e' && try_read("caron;") {
+        return Some(CharRef {
+            name: "caron;",
+            characters: "\u{11b}",
+        });
+    }
+
+    if first_char == 'e' && try_read("colon;") {
+        return Some(CharRef {
+            name: "colon;",
+            characters: "\u{2255}",
+        });
+    }
+
+    if first_char == 'e' && try_read("grave;") {
+        return Some(CharRef {
+            name: "grave;",
+            characters: "\u{e8}",
+        });
+    }
+
+    if first_char == 'e' && try_read("gsdot;") {
+        return Some(CharRef {
+            name: "gsdot;",
+            characters: "\u{2a98}",
+        });
+    }
+
+    if first_char == 'e' && try_read("lsdot;") {
+        return Some(CharRef {
+            name: "lsdot;",
+            characters: "\u{2a97}",
+        });
+    }
+
+    if first_char == 'e' && try_read("mptyv;") {
+        return Some(CharRef {
+            name: "mptyv;",
+            characters: "\u{2205}",
+        });
+    }
+
+    if first_char == 'e' && try_read("msp13;") {
+        return Some(CharRef {
+            name: "msp13;",
+            characters: "\u{2004}",
+        });
+    }
+
+    if first_char == 'e' && try_read("msp14;") {
+        return Some(CharRef {
+            name: "msp14;",
+            characters: "\u{2005}",
+        });
+    }
+
+    if first_char == 'e' && try_read("parsl;") {
+        return Some(CharRef {
+            name: "parsl;",
+            characters: "\u{29e3}",
+        });
+    }
+
+    if first_char == 'e' && try_read("qcirc;") {
+        return Some(CharRef {
+            name: "qcirc;",
+            characters: "\u{2256}",
+        });
+    }
+
+    if first_char == 'e' && try_read("quals;") {
+        return Some(CharRef {
+            name: "quals;",
+            characters: "\u{3d}",
+        });
+    }
+
+    if first_char == 'e' && try_read("quest;") {
+        return Some(CharRef {
+            name: "quest;",
+            characters: "\u{225f}",
+        });
+    }
+
+    if first_char == 'f' && try_read("emale;") {
+        return Some(CharRef {
+            name: "emale;",
+            characters: "\u{2640}",
+        });
+    }
+
+    if first_char == 'f' && try_read("filig;") {
+        return Some(CharRef {
+            name: "filig;",
+            characters: "\u{fb03}",
+        });
+    }
+
+    if first_char == 'f' && try_read("fllig;") {
+        return Some(CharRef {
+            name: "fllig;",
+            characters: "\u{fb04}",
+        });
+    }
+
+    if first_char == 'f' && try_read("orall;") {
+        return Some(CharRef {
+            name: "orall;",
+            characters: "\u{2200}",
+        });
+    }
+
+    if first_char == 'f' && try_read("rac12;") {
+        return Some(CharRef {
+            name: "rac12;",
+            characters: "\u{bd}",
+        });
+    }
+
+    if first_char == 'f' && try_read("rac13;") {
+        return Some(CharRef {
+            name: "rac13;",
+            characters: "\u{2153}",
+        });
+    }
+
+    if first_char == 'f' && try_read("rac14;") {
+        return Some(CharRef {
+            name: "rac14;",
+            characters: "\u{bc}",
+        });
+    }
+
+    if first_char == 'f' && try_read("rac15;") {
+        return Some(CharRef {
+            name: "rac15;",
+            characters: "\u{2155}",
+        });
+    }
+
+    if first_char == 'f' && try_read("rac16;") {
+        return Some(CharRef {
+            name: "rac16;",
+            characters: "\u{2159}",
+        });
+    }
+
+    if first_char == 'f' && try_read("rac18;") {
+        return Some(CharRef {
+            name: "rac18;",
+            characters: "\u{215b}",
+        });
+    }
+
+    if first_char == 'f' && try_read("rac23;") {
+        return Some(CharRef {
+            name: "rac23;",
+            characters: "\u{2154}",
+        });
+    }
+
+    if first_char == 'f' && try_read("rac25;") {
+        return Some(CharRef {
+            name: "rac25;",
+            characters: "\u{2156}",
+        });
+    }
+
+    if first_char == 'f' && try_read("rac34;") {
+        return Some(CharRef {
+            name: "rac34;",
+            characters: "\u{be}",
+        });
+    }
+
+    if first_char == 'f' && try_read("rac35;") {
+        return Some(CharRef {
+            name: "rac35;",
+            characters: "\u{2157}",
+        });
+    }
+
+    if first_char == 'f' && try_read("rac38;") {
+        return Some(CharRef {
+            name: "rac38;",
+            characters: "\u{215c}",
+        });
+    }
+
+    if first_char == 'f' && try_read("rac45;") {
+        return Some(CharRef {
+            name: "rac45;",
+            characters: "\u{2158}",
+        });
+    }
+
+    if first_char == 'f' && try_read("rac56;") {
+        return Some(CharRef {
+            name: "rac56;",
+            characters: "\u{215a}",
+        });
+    }
+
+    if first_char == 'f' && try_read("rac58;") {
+        return Some(CharRef {
+            name: "rac58;",
+            characters: "\u{215d}",
+        });
+    }
+
+    if first_char == 'f' && try_read("rac78;") {
+        return Some(CharRef {
+            name: "rac78;",
+            characters: "\u{215e}",
+        });
+    }
+
+    if first_char == 'g' && try_read("acute;") {
+        return Some(CharRef {
+            name: "acute;",
+            characters: "\u{1f5}",
+        });
+    }
+
+    if first_char == 'g' && try_read("ammad;") {
+        return Some(CharRef {
+            name: "ammad;",
+            characters: "\u{3dd}",
+        });
+    }
+
+    if first_char == 'g' && try_read("breve;") {
+        return Some(CharRef {
+            name: "breve;",
+            characters: "\u{11f}",
+        });
+    }
+
+    if first_char == 'g' && try_read("esdot;") {
+        return Some(CharRef {
+            name: "esdot;",
+            characters: "\u{2a80}",
+        });
+    }
+
+    if first_char == 'g' && try_read("esles;") {
+        return Some(CharRef {
+            name: "esles;",
+            characters: "\u{2a94}",
+        });
+    }
+
+    if first_char == 'g' && try_read("tlPar;") {
+        return Some(CharRef {
+            name: "tlPar;",
+            characters: "\u{2995}",
+        });
+    }
+
+    if first_char == 'g' && try_read("trarr;") {
+        return Some(CharRef {
+            name: "trarr;",
+            characters: "\u{2978}",
+        });
+    }
+
+    if first_char == 'g' && try_read("trdot;") {
+        return Some(CharRef {
+            name: "trdot;",
+            characters: "\u{22d7}",
+        });
+    }
+
+    if first_char == 'g' && try_read("trsim;") {
+        return Some(CharRef {
+            name: "trsim;",
+            characters: "\u{2273}",
+        });
+    }
+
+    if first_char == 'h' && try_read("airsp;") {
+        return Some(CharRef {
+            name: "airsp;",
+            characters: "\u{200a}",
+        });
+    }
+
+    if first_char == 'h' && try_read("amilt;") {
+        return Some(CharRef {
+            name: "amilt;",
+            characters: "\u{210b}",
+        });
+    }
+
+    if first_char == 'h' && try_read("ardcy;") {
+        return Some(CharRef {
+            name: "ardcy;",
+            characters: "\u{44a}",
+        });
+    }
+
+    if first_char == 'h' && try_read("earts;") {
+        return Some(CharRef {
+            name: "earts;",
+            characters: "\u{2665}",
+        });
+    }
+
+    if first_char == 'h' && try_read("ellip;") {
+        return Some(CharRef {
+            name: "ellip;",
+            characters: "\u{2026}",
+        });
+    }
+
+    if first_char == 'h' && try_read("ercon;") {
+        return Some(CharRef {
+            name: "ercon;",
+            characters: "\u{22b9}",
+        });
+    }
+
+    if first_char == 'h' && try_read("omtht;") {
+        return Some(CharRef {
+            name: "omtht;",
+            characters: "\u{223b}",
+        });
+    }
+
+    if first_char == 'h' && try_read("orbar;") {
+        return Some(CharRef {
+            name: "orbar;",
+            characters: "\u{2015}",
+        });
+    }
+
+    if first_char == 'h' && try_read("slash;") {
+        return Some(CharRef {
+            name: "slash;",
+            characters: "\u{210f}",
+        });
+    }
+
+    if first_char == 'h' && try_read("strok;") {
+        return Some(CharRef {
+            name: "strok;",
+            characters: "\u{127}",
+        });
+    }
+
+    if first_char == 'h' && try_read("ybull;") {
+        return Some(CharRef {
+            name: "ybull;",
+            characters: "\u{2043}",
+        });
+    }
+
+    if first_char == 'h' && try_read("yphen;") {
+        return Some(CharRef {
+            name: "yphen;",
+            characters: "\u{2010}",
+        });
+    }
+
+    if first_char == 'i' && try_read("acute;") {
+        return Some(CharRef {
+            name: "acute;",
+            characters: "\u{ed}",
+        });
+    }
+
+    if first_char == 'i' && try_read("grave;") {
+        return Some(CharRef {
+            name: "grave;",
+            characters: "\u{ec}",
+        });
+    }
+
+    if first_char == 'i' && try_read("iiint;") {
+        return Some(CharRef {
+            name: "iiint;",
+            characters: "\u{2a0c}",
+        });
+    }
+
+    if first_char == 'i' && try_read("infin;") {
+        return Some(CharRef {
+            name: "infin;",
+            characters: "\u{29dc}",
+        });
+    }
+
+    if first_char == 'i' && try_read("ncare;") {
+        return Some(CharRef {
+            name: "ncare;",
+            characters: "\u{2105}",
+        });
+    }
+
+    if first_char == 'i' && try_read("nodot;") {
+        return Some(CharRef {
+            name: "nodot;",
+            characters: "\u{131}",
+        });
+    }
+
+    if first_char == 'i' && try_read("ntcal;") {
+        return Some(CharRef {
+            name: "ntcal;",
+            characters: "\u{22ba}",
+        });
+    }
+
+    if first_char == 'i' && try_read("quest;") {
+        return Some(CharRef {
+            name: "quest;",
+            characters: "\u{bf}",
+        });
+    }
+
+    if first_char == 'i' && try_read("sinsv;") {
+        return Some(CharRef {
+            name: "sinsv;",
+            characters: "\u{22f3}",
+        });
+    }
+
+    if first_char == 'i' && try_read("tilde;") {
+        return Some(CharRef {
+            name: "tilde;",
+            characters: "\u{129}",
+        });
+    }
+
+    if first_char == 'j' && try_read("sercy;") {
+        return Some(CharRef {
+            name: "sercy;",
+            characters: "\u{458}",
+        });
+    }
+
+    if first_char == 'k' && try_read("appav;") {
+        return Some(CharRef {
+            name: "appav;",
+            characters: "\u{3f0}",
+        });
+    }
+
+    if first_char == 'k' && try_read("cedil;") {
+        return Some(CharRef {
+            name: "cedil;",
+            characters: "\u{137}",
+        });
+    }
+
+    if first_char == 'k' && try_read("green;") {
+        return Some(CharRef {
+            name: "green;",
+            characters: "\u{138}",
+        });
+    }
+
+    if first_char == 'l' && try_read("Atail;") {
+        return Some(CharRef {
+            name: "Atail;",
+            characters: "\u{291b}",
+        });
+    }
+
+    if first_char == 'l' && try_read("acute;") {
+        return Some(CharRef {
+            name: "acute;",
+            characters: "\u{13a}",
+        });
+    }
+
+    if first_char == 'l' && try_read("agran;") {
+        return Some(CharRef {
+            name: "agran;",
+            characters: "\u{2112}",
+        });
+    }
+
+    if first_char == 'l' && try_read("ambda;") {
+        return Some(CharRef {
+            name: "ambda;",
+            characters: "\u{3bb}",
+        });
+    }
+
+    if first_char == 'l' && try_read("angle;") {
+        return Some(CharRef {
+            name: "angle;",
+            characters: "\u{27e8}",
+        });
+    }
+
+    if first_char == 'l' && try_read("arrfs;") {
+        return Some(CharRef {
+            name: "arrfs;",
+            characters: "\u{291d}",
+        });
+    }
+
+    if first_char == 'l' && try_read("arrhk;") {
+        return Some(CharRef {
+            name: "arrhk;",
+            characters: "\u{21a9}",
+        });
+    }
+
+    if first_char == 'l' && try_read("arrlp;") {
+        return Some(CharRef {
+            name: "arrlp;",
+            characters: "\u{21ab}",
+        });
+    }
+
+    if first_char == 'l' && try_read("arrpl;") {
+        return Some(CharRef {
+            name: "arrpl;",
+            characters: "\u{2939}",
+        });
+    }
+
+    if first_char == 'l' && try_read("arrtl;") {
+        return Some(CharRef {
+            name: "arrtl;",
+            characters: "\u{21a2}",
+        });
+    }
+
+    if first_char == 'l' && try_read("atail;") {
+        return Some(CharRef {
+            name: "atail;",
+            characters: "\u{2919}",
+        });
+    }
+
+    if first_char == 'l' && try_read("brace;") {
+        return Some(CharRef {
+            name: "brace;",
+            characters: "\u{7b}",
+        });
+    }
+
+    if first_char == 'l' && try_read("brack;") {
+        return Some(CharRef {
+            name: "brack;",
+            characters: "\u{5b}",
+        });
+    }
+
+    if first_char == 'l' && try_read("caron;") {
+        return Some(CharRef {
+            name: "caron;",
+            characters: "\u{13e}",
+        });
+    }
+
+    if first_char == 'l' && try_read("cedil;") {
+        return Some(CharRef {
+            name: "cedil;",
+            characters: "\u{13c}",
+        });
+    }
+
+    if first_char == 'l' && try_read("dquor;") {
+        return Some(CharRef {
+            name: "dquor;",
+            characters: "\u{201e}",
+        });
+    }
+
+    if first_char == 'l' && try_read("esdot;") {
+        return Some(CharRef {
+            name: "esdot;",
+            characters: "\u{2a7f}",
+        });
+    }
+
+    if first_char == 'l' && try_read("esges;") {
+        return Some(CharRef {
+            name: "esges;",
+            characters: "\u{2a93}",
+        });
+    }
+
+    if first_char == 'l' && try_read("fisht;") {
+        return Some(CharRef {
+            name: "fisht;",
+            characters: "\u{297c}",
+        });
+    }
+
+    if first_char == 'l' && try_read("floor;") {
+        return Some(CharRef {
+            name: "floor;",
+            characters: "\u{230a}",
+        });
+    }
+
+    if first_char == 'l' && try_read("harul;") {
+        return Some(CharRef {
+            name: "harul;",
+            characters: "\u{296a}",
+        });
+    }
+
+    if first_char == 'l' && try_read("lhard;") {
+        return Some(CharRef {
+            name: "lhard;",
+            characters: "\u{296b}",
+        });
+    }
+
+    if first_char == 'l' && try_read("midot;") {
+        return Some(CharRef {
+            name: "midot;",
+            characters: "\u{140}",
+        });
+    }
+
+    if first_char == 'l' && try_read("moust;") {
+        return Some(CharRef {
+            name: "moust;",
+            characters: "\u{23b0}",
+        });
+    }
+
+    if first_char == 'l' && try_read("oplus;") {
+        return Some(CharRef {
+            name: "oplus;",
+            characters: "\u{2a2d}",
+        });
+    }
+
+    if first_char == 'l' && try_read("owast;") {
+        return Some(CharRef {
+            name: "owast;",
+            characters: "\u{2217}",
+        });
+    }
+
+    if first_char == 'l' && try_read("owbar;") {
+        return Some(CharRef {
+            name: "owbar;",
+            characters: "\u{5f}",
+        });
+    }
+
+    if first_char == 'l' && try_read("parlt;") {
+        return Some(CharRef {
+            name: "parlt;",
+            characters: "\u{2993}",
+        });
+    }
+
+    if first_char == 'l' && try_read("rhard;") {
+        return Some(CharRef {
+            name: "rhard;",
+            characters: "\u{296d}",
+        });
+    }
+
+    if first_char == 'l' && try_read("saquo;") {
+        return Some(CharRef {
+            name: "saquo;",
+            characters: "\u{2039}",
+        });
+    }
+
+    if first_char == 'l' && try_read("squor;") {
+        return Some(CharRef {
+            name: "squor;",
+            characters: "\u{201a}",
+        });
+    }
+
+    if first_char == 'l' && try_read("strok;") {
+        return Some(CharRef {
+            name: "strok;",
+            characters: "\u{142}",
+        });
+    }
+
+    if first_char == 'l' && try_read("three;") {
+        return Some(CharRef {
+            name: "three;",
+            characters: "\u{22cb}",
+        });
+    }
+
+    if first_char == 'l' && try_read("times;") {
+        return Some(CharRef {
+            name: "times;",
+            characters: "\u{22c9}",
+        });
+    }
+
+    if first_char == 'l' && try_read("tlarr;") {
+        return Some(CharRef {
+            name: "tlarr;",
+            characters: "\u{2976}",
+        });
+    }
+
+    if first_char == 'l' && try_read("trPar;") {
+        return Some(CharRef {
+            name: "trPar;",
+            characters: "\u{2996}",
+        });
+    }
+
+    if first_char == 'm' && try_read("apsto;") {
+        return Some(CharRef {
+            name: "apsto;",
+            characters: "\u{21a6}",
+        });
+    }
+
+    if first_char == 'm' && try_read("arker;") {
+        return Some(CharRef {
+            name: "arker;",
+            characters: "\u{25ae}",
+        });
+    }
+
+    if first_char == 'm' && try_read("comma;") {
+        return Some(CharRef {
+            name: "comma;",
+            characters: "\u{2a29}",
+        });
+    }
+
+    if first_char == 'm' && try_read("idast;") {
+        return Some(CharRef {
+            name: "idast;",
+            characters: "\u{2a}",
+        });
+    }
+
+    if first_char == 'm' && try_read("idcir;") {
+        return Some(CharRef {
+            name: "idcir;",
+            characters: "\u{2af0}",
+        });
+    }
+
+    if first_char == 'm' && try_read("iddot;") {
+        return Some(CharRef {
+            name: "iddot;",
+            characters: "\u{b7}",
+        });
+    }
+
+    if first_char == 'm' && try_read("inusb;") {
+        return Some(CharRef {
+            name: "inusb;",
+            characters: "\u{229f}",
+        });
+    }
+
+    if first_char == 'm' && try_read("inusd;") {
+        return Some(CharRef {
+            name: "inusd;",
+            characters: "\u{2238}",
+        });
+    }
+
+    if first_char == 'm' && try_read("nplus;") {
+        return Some(CharRef {
+            name: "nplus;",
+            characters: "\u{2213}",
+        });
+    }
+
+    if first_char == 'm' && try_read("odels;") {
+        return Some(CharRef {
+            name: "odels;",
+            characters: "\u{22a7}",
+        });
+    }
+
+    if first_char == 'm' && try_read("stpos;") {
+        return Some(CharRef {
+            name: "stpos;",
+            characters: "\u{223e}",
+        });
+    }
+
+    if first_char == 'n' && try_read("VDash;") {
+        return Some(CharRef {
+            name: "VDash;",
+            characters: "\u{22af}",
+        });
+    }
+
+    if first_char == 'n' && try_read("Vdash;") {
+        return Some(CharRef {
+            name: "Vdash;",
+            characters: "\u{22ae}",
+        });
+    }
+
+    if first_char == 'n' && try_read("acute;") {
+        return Some(CharRef {
+            name: "acute;",
+            characters: "\u{144}",
+        });
+    }
+
+    if first_char == 'n' && try_read("bumpe;") {
+        return Some(CharRef {
+            name: "bumpe;",
+            characters: "\u{224f}\u{338}",
+        });
+    }
+
+    if first_char == 'n' && try_read("caron;") {
+        return Some(CharRef {
+            name: "caron;",
+            characters: "\u{148}",
+        });
+    }
+
+    if first_char == 'n' && try_read("cedil;") {
+        return Some(CharRef {
+            name: "cedil;",
+            characters: "\u{146}",
+        });
+    }
+
+    if first_char == 'n' && try_read("earhk;") {
+        return Some(CharRef {
+            name: "earhk;",
+            characters: "\u{2924}",
+        });
+    }
+
+    if first_char == 'n' && try_read("equiv;") {
+        return Some(CharRef {
+            name: "equiv;",
+            characters: "\u{2262}",
+        });
+    }
+
+    if first_char == 'n' && try_read("esear;") {
+        return Some(CharRef {
+            name: "esear;",
+            characters: "\u{2928}",
+        });
+    }
+
+    if first_char == 'n' && try_read("exist;") {
+        return Some(CharRef {
+            name: "exist;",
+            characters: "\u{2204}",
+        });
+    }
+
+    if first_char == 'n' && try_read("ltrie;") {
+        return Some(CharRef {
+            name: "ltrie;",
+            characters: "\u{22ec}",
+        });
+    }
+
+    if first_char == 'n' && try_read("otinE;") {
+        return Some(CharRef {
+            name: "otinE;",
+            characters: "\u{22f9}\u{338}",
+        });
+    }
+
+    if first_char == 'n' && try_read("parsl;") {
+        return Some(CharRef {
+            name: "parsl;",
+            characters: "\u{2afd}\u{20e5}",
+        });
+    }
+
+    if first_char == 'n' && try_read("prcue;") {
+        return Some(CharRef {
+            name: "prcue;",
+            characters: "\u{22e0}",
+        });
+    }
+
+    if first_char == 'n' && try_read("rarrc;") {
+        return Some(CharRef {
+            name: "rarrc;",
+            characters: "\u{2933}\u{338}",
+        });
+    }
+
+    if first_char == 'n' && try_read("rarrw;") {
+        return Some(CharRef {
+            name: "rarrw;",
+            characters: "\u{219d}\u{338}",
+        });
+    }
+
+    if first_char == 'n' && try_read("rtrie;") {
+        return Some(CharRef {
+            name: "rtrie;",
+            characters: "\u{22ed}",
+        });
+    }
+
+    if first_char == 'n' && try_read("sccue;") {
+        return Some(CharRef {
+            name: "sccue;",
+            characters: "\u{22e1}",
+        });
+    }
+
+    if first_char == 'n' && try_read("simeq;") {
+        return Some(CharRef {
+            name: "simeq;",
+            characters: "\u{2244}",
+        });
+    }
+
+    if first_char == 'n' && try_read("tilde;") {
+        return Some(CharRef {
+            name: "tilde;",
+            characters: "\u{f1}",
+        });
+    }
+
+    if first_char == 'n' && try_read("umero;") {
+        return Some(CharRef {
+            name: "umero;",
+            characters: "\u{2116}",
+        });
+    }
+
+    if first_char == 'n' && try_read("vDash;") {
+        return Some(CharRef {
+            name: "vDash;",
+            characters: "\u{22ad}",
+        });
+    }
+
+    if first_char == 'n' && try_read("vHarr;") {
+        return Some(CharRef {
+            name: "vHarr;",
+            characters: "\u{2904}",
+        });
+    }
+
+    if first_char == 'n' && try_read("vdash;") {
+        return Some(CharRef {
+            name: "vdash;",
+            characters: "\u{22ac}",
+        });
+    }
+
+    if first_char == 'n' && try_read("vlArr;") {
+        return Some(CharRef {
+            name: "vlArr;",
+            characters: "\u{2902}",
+        });
+    }
+
+    if first_char == 'n' && try_read("vrArr;") {
+        return Some(CharRef {
+            name: "vrArr;",
+            characters: "\u{2903}",
+        });
+    }
+
+    if first_char == 'n' && try_read("warhk;") {
+        return Some(CharRef {
+            name: "warhk;",
+            characters: "\u{2923}",
+        });
+    }
+
+    if first_char == 'n' && try_read("wnear;") {
+        return Some(CharRef {
+            name: "wnear;",
+            characters: "\u{2927}",
+        });
+    }
+
+    if first_char == 'o' && try_read("acute;") {
+        return Some(CharRef {
+            name: "acute;",
+            characters: "\u{f3}",
+        });
+    }
+
+    if first_char == 'o' && try_read("dblac;") {
+        return Some(CharRef {
+            name: "dblac;",
+            characters: "\u{151}",
+        });
+    }
+
+    if first_char == 'o' && try_read("dsold;") {
+        return Some(CharRef {
+            name: "dsold;",
+            characters: "\u{29bc}",
+        });
+    }
+
+    if first_char == 'o' && try_read("grave;") {
+        return Some(CharRef {
+            name: "grave;",
+            characters: "\u{f2}",
+        });
+    }
+
+    if first_char == 'o' && try_read("minus;") {
+        return Some(CharRef {
+            name: "minus;",
+            characters: "\u{2296}",
+        });
+    }
+
+    if first_char == 'o' && try_read("rigof;") {
+        return Some(CharRef {
+            name: "rigof;",
+            characters: "\u{22b6}",
+        });
+    }
+
+    if first_char == 'o' && try_read("slash;") {
+        return Some(CharRef {
+            name: "slash;",
+            characters: "\u{f8}",
+        });
+    }
+
+    if first_char == 'o' && try_read("tilde;") {
+        return Some(CharRef {
+            name: "tilde;",
+            characters: "\u{f5}",
+        });
+    }
+
+    if first_char == 'o' && try_read("times;") {
+        return Some(CharRef {
+            name: "times;",
+            characters: "\u{2297}",
+        });
+    }
+
+    if first_char == 'p' && try_read("arsim;") {
+        return Some(CharRef {
+            name: "arsim;",
+            characters: "\u{2af3}",
+        });
+    }
+
+    if first_char == 'p' && try_read("ercnt;") {
+        return Some(CharRef {
+            name: "ercnt;",
+            characters: "\u{25}",
+        });
+    }
+
+    if first_char == 'p' && try_read("eriod;") {
+        return Some(CharRef {
+            name: "eriod;",
+            characters: "\u{2e}",
+        });
+    }
+
+    if first_char == 'p' && try_read("ermil;") {
+        return Some(CharRef {
+            name: "ermil;",
+            characters: "\u{2030}",
+        });
+    }
+
+    if first_char == 'p' && try_read("hmmat;") {
+        return Some(CharRef {
+            name: "hmmat;",
+            characters: "\u{2133}",
+        });
+    }
+
+    if first_char == 'p' && try_read("lanck;") {
+        return Some(CharRef {
+            name: "lanck;",
+            characters: "\u{210f}",
+        });
+    }
+
+    if first_char == 'p' && try_read("lankv;") {
+        return Some(CharRef {
+            name: "lankv;",
+            characters: "\u{210f}",
+        });
+    }
+
+    if first_char == 'p' && try_read("lusdo;") {
+        return Some(CharRef {
+            name: "lusdo;",
+            characters: "\u{2214}",
+        });
+    }
+
+    if first_char == 'p' && try_read("lusdu;") {
+        return Some(CharRef {
+            name: "lusdu;",
+            characters: "\u{2a25}",
+        });
+    }
+
+    if first_char == 'p' && try_read("lusmn;") {
+        return Some(CharRef {
+            name: "lusmn;",
+            characters: "\u{b1}",
+        });
+    }
+
+    if first_char == 'p' && try_read("receq;") {
+        return Some(CharRef {
+            name: "receq;",
+            characters: "\u{2aaf}",
+        });
+    }
+
+    if first_char == 'p' && try_read("rimes;") {
+        return Some(CharRef {
+            name: "rimes;",
+            characters: "\u{2119}",
+        });
+    }
+
+    if first_char == 'p' && try_read("rnsim;") {
+        return Some(CharRef {
+            name: "rnsim;",
+            characters: "\u{22e8}",
+        });
+    }
+
+    if first_char == 'p' && try_read("ropto;") {
+        return Some(CharRef {
+            name: "ropto;",
+            characters: "\u{221d}",
+        });
+    }
+
+    if first_char == 'p' && try_read("rurel;") {
+        return Some(CharRef {
+            name: "rurel;",
+            characters: "\u{22b0}",
+        });
+    }
+
+    if first_char == 'p' && try_read("uncsp;") {
+        return Some(CharRef {
+            name: "uncsp;",
+            characters: "\u{2008}",
+        });
+    }
+
+    if first_char == 'q' && try_read("prime;") {
+        return Some(CharRef {
+            name: "prime;",
+            characters: "\u{2057}",
+        });
+    }
+
+    if first_char == 'r' && try_read("Atail;") {
+        return Some(CharRef {
+            name: "Atail;",
+            characters: "\u{291c}",
+        });
+    }
+
+    if first_char == 'r' && try_read("acute;") {
+        return Some(CharRef {
+            name: "acute;",
+            characters: "\u{155}",
+        });
+    }
+
+    if first_char == 'r' && try_read("angle;") {
+        return Some(CharRef {
+            name: "angle;",
+            characters: "\u{27e9}",
+        });
+    }
+
+    if first_char == 'r' && try_read("arrap;") {
+        return Some(CharRef {
+            name: "arrap;",
+            characters: "\u{2975}",
+        });
+    }
+
+    if first_char == 'r' && try_read("arrfs;") {
+        return Some(CharRef {
+            name: "arrfs;",
+            characters: "\u{291e}",
+        });
+    }
+
+    if first_char == 'r' && try_read("arrhk;") {
+        return Some(CharRef {
+            name: "arrhk;",
+            characters: "\u{21aa}",
+        });
+    }
+
+    if first_char == 'r' && try_read("arrlp;") {
+        return Some(CharRef {
+            name: "arrlp;",
+            characters: "\u{21ac}",
+        });
+    }
+
+    if first_char == 'r' && try_read("arrpl;") {
+        return Some(CharRef {
+            name: "arrpl;",
+            characters: "\u{2945}",
+        });
+    }
+
+    if first_char == 'r' && try_read("arrtl;") {
+        return Some(CharRef {
+            name: "arrtl;",
+            characters: "\u{21a3}",
+        });
+    }
+
+    if first_char == 'r' && try_read("atail;") {
+        return Some(CharRef {
+            name: "atail;",
+            characters: "\u{291a}",
+        });
+    }
+
+    if first_char == 'r' && try_read("brace;") {
+        return Some(CharRef {
+            name: "brace;",
+            characters: "\u{7d}",
+        });
+    }
+
+    if first_char == 'r' && try_read("brack;") {
+        return Some(CharRef {
+            name: "brack;",
+            characters: "\u{5d}",
+        });
+    }
+
+    if first_char == 'r' && try_read("caron;") {
+        return Some(CharRef {
+            name: "caron;",
+            characters: "\u{159}",
+        });
+    }
+
+    if first_char == 'r' && try_read("cedil;") {
+        return Some(CharRef {
+            name: "cedil;",
+            characters: "\u{157}",
+        });
+    }
+
+    if first_char == 'r' && try_read("dquor;") {
+        return Some(CharRef {
+            name: "dquor;",
+            characters: "\u{201d}",
+        });
+    }
+
+    if first_char == 'r' && try_read("fisht;") {
+        return Some(CharRef {
+            name: "fisht;",
+            characters: "\u{297d}",
+        });
+    }
+
+    if first_char == 'r' && try_read("floor;") {
+        return Some(CharRef {
+            name: "floor;",
+            characters: "\u{230b}",
+        });
+    }
+
+    if first_char == 'r' && try_read("harul;") {
+        return Some(CharRef {
+            name: "harul;",
+            characters: "\u{296c}",
+        });
+    }
+
+    if first_char == 'r' && try_read("moust;") {
+        return Some(CharRef {
+            name: "moust;",
+            characters: "\u{23b1}",
+        });
+    }
+
+    if first_char == 'r' && try_read("oplus;") {
+        return Some(CharRef {
+            name: "oplus;",
+            characters: "\u{2a2e}",
+        });
+    }
+
+    if first_char == 'r' && try_read("pargt;") {
+        return Some(CharRef {
+            name: "pargt;",
+            characters: "\u{2994}",
+        });
+    }
+
+    if first_char == 'r' && try_read("saquo;") {
+        return Some(CharRef {
+            name: "saquo;",
+            characters: "\u{203a}",
+        });
+    }
+
+    if first_char == 'r' && try_read("squor;") {
+        return Some(CharRef {
+            name: "squor;",
+            characters: "\u{2019}",
+        });
+    }
+
+    if first_char == 'r' && try_read("three;") {
+        return Some(CharRef {
+            name: "three;",
+            characters: "\u{22cc}",
+        });
+    }
+
+    if first_char == 'r' && try_read("times;") {
+        return Some(CharRef {
+            name: "times;",
+            characters: "\u{22ca}",
+        });
+    }
+
+    if first_char == 's' && try_read("acute;") {
+        return Some(CharRef {
+            name: "acute;",
+            characters: "\u{15b}",
+        });
+    }
+
+    if first_char == 's' && try_read("caron;") {
+        return Some(CharRef {
+            name: "caron;",
+            characters: "\u{161}",
+        });
+    }
+
+    if first_char == 's' && try_read("cedil;") {
+        return Some(CharRef {
+            name: "cedil;",
+            characters: "\u{15f}",
+        });
+    }
+
+    if first_char == 's' && try_read("cnsim;") {
+        return Some(CharRef {
+            name: "cnsim;",
+            characters: "\u{22e9}",
+        });
+    }
+
+    if first_char == 's' && try_read("earhk;") {
+        return Some(CharRef {
+            name: "earhk;",
+            characters: "\u{2925}",
+        });
+    }
+
+    if first_char == 's' && try_read("eswar;") {
+        return Some(CharRef {
+            name: "eswar;",
+            characters: "\u{2929}",
+        });
+    }
+
+    if first_char == 's' && try_read("frown;") {
+        return Some(CharRef {
+            name: "frown;",
+            characters: "\u{2322}",
+        });
+    }
+
+    if first_char == 's' && try_read("hchcy;") {
+        return Some(CharRef {
+            name: "hchcy;",
+            characters: "\u{449}",
+        });
+    }
+
+    if first_char == 's' && try_read("igmaf;") {
+        return Some(CharRef {
+            name: "igmaf;",
+            characters: "\u{3c2}",
+        });
+    }
+
+    if first_char == 's' && try_read("igmav;") {
+        return Some(CharRef {
+            name: "igmav;",
+            characters: "\u{3c2}",
+        });
+    }
+
+    if first_char == 's' && try_read("imdot;") {
+        return Some(CharRef {
+            name: "imdot;",
+            characters: "\u{2a6a}",
+        });
+    }
+
+    if first_char == 's' && try_read("mashp;") {
+        return Some(CharRef {
+            name: "mashp;",
+            characters: "\u{2a33}",
+        });
+    }
+
+    if first_char == 's' && try_read("oftcy;") {
+        return Some(CharRef {
+            name: "oftcy;",
+            characters: "\u{44c}",
+        });
+    }
+
+    if first_char == 's' && try_read("olbar;") {
+        return Some(CharRef {
+            name: "olbar;",
+            characters: "\u{233f}",
+        });
+    }
+
+    if first_char == 's' && try_read("pades;") {
+        return Some(CharRef {
+            name: "pades;",
+            characters: "\u{2660}",
+        });
+    }
+
+    if first_char == 's' && try_read("qcaps;") {
+        return Some(CharRef {
+            name: "qcaps;",
+            characters: "\u{2293}\u{fe00}",
+        });
+    }
+
+    if first_char == 's' && try_read("qcups;") {
+        return Some(CharRef {
+            name: "qcups;",
+            characters: "\u{2294}\u{fe00}",
+        });
+    }
+
+    if first_char == 's' && try_read("qsube;") {
+        return Some(CharRef {
+            name: "qsube;",
+            characters: "\u{2291}",
+        });
+    }
+
+    if first_char == 's' && try_read("qsupe;") {
+        return Some(CharRef {
+            name: "qsupe;",
+            characters: "\u{2292}",
+        });
+    }
+
+    if first_char == 's' && try_read("quare;") {
+        return Some(CharRef {
+            name: "quare;",
+            characters: "\u{25a1}",
+        });
+    }
+
+    if first_char == 's' && try_read("quarf;") {
+        return Some(CharRef {
+            name: "quarf;",
+            characters: "\u{25aa}",
+        });
+    }
+
+    if first_char == 's' && try_read("setmn;") {
+        return Some(CharRef {
+            name: "setmn;",
+            characters: "\u{2216}",
+        });
+    }
+
+    if first_char == 's' && try_read("smile;") {
+        return Some(CharRef {
+            name: "smile;",
+            characters: "\u{2323}",
+        });
+    }
+
+    if first_char == 's' && try_read("starf;") {
+        return Some(CharRef {
+            name: "starf;",
+            characters: "\u{22c6}",
+        });
+    }
+
+    if first_char == 's' && try_read("ubdot;") {
+        return Some(CharRef {
+            name: "ubdot;",
+            characters: "\u{2abd}",
+        });
+    }
+
+    if first_char == 's' && try_read("ubset;") {
+        return Some(CharRef {
+            name: "ubset;",
+            characters: "\u{2282}",
+        });
+    }
+
+    if first_char == 's' && try_read("ubsim;") {
+        return Some(CharRef {
+            name: "ubsim;",
+            characters: "\u{2ac7}",
+        });
+    }
+
+    if first_char == 's' && try_read("ubsub;") {
+        return Some(CharRef {
+            name: "ubsub;",
+            characters: "\u{2ad5}",
+        });
+    }
+
+    if first_char == 's' && try_read("ubsup;") {
+        return Some(CharRef {
+            name: "ubsup;",
+            characters: "\u{2ad3}",
+        });
+    }
+
+    if first_char == 's' && try_read("ucceq;") {
+        return Some(CharRef {
+            name: "ucceq;",
+            characters: "\u{2ab0}",
+        });
+    }
+
+    if first_char == 's' && try_read("updot;") {
+        return Some(CharRef {
+            name: "updot;",
+            characters: "\u{2abe}",
+        });
+    }
+
+    if first_char == 's' && try_read("upset;") {
+        return Some(CharRef {
+            name: "upset;",
+            characters: "\u{2283}",
+        });
+    }
+
+    if first_char == 's' && try_read("upsim;") {
+        return Some(CharRef {
+            name: "upsim;",
+            characters: "\u{2ac8}",
+        });
+    }
+
+    if first_char == 's' && try_read("upsub;") {
+        return Some(CharRef {
+            name: "upsub;",
+            characters: "\u{2ad4}",
+        });
+    }
+
+    if first_char == 's' && try_read("upsup;") {
+        return Some(CharRef {
+            name: "upsup;",
+            characters: "\u{2ad6}",
+        });
+    }
+
+    if first_char == 's' && try_read("warhk;") {
+        return Some(CharRef {
+            name: "warhk;",
+            characters: "\u{2926}",
+        });
+    }
+
+    if first_char == 's' && try_read("wnwar;") {
+        return Some(CharRef {
+            name: "wnwar;",
+            characters: "\u{292a}",
+        });
+    }
+
+    if first_char == 't' && try_read("arget;") {
+        return Some(CharRef {
+            name: "arget;",
+            characters: "\u{2316}",
+        });
+    }
+
+    if first_char == 't' && try_read("caron;") {
+        return Some(CharRef {
+            name: "caron;",
+            characters: "\u{165}",
+        });
+    }
+
+    if first_char == 't' && try_read("cedil;") {
+        return Some(CharRef {
+            name: "cedil;",
+            characters: "\u{163}",
+        });
+    }
+
+    if first_char == 't' && try_read("elrec;") {
+        return Some(CharRef {
+            name: "elrec;",
+            characters: "\u{2315}",
+        });
+    }
+
+    if first_char == 't' && try_read("here4;") {
+        return Some(CharRef {
+            name: "here4;",
+            characters: "\u{2234}",
+        });
+    }
+
+    if first_char == 't' && try_read("hetav;") {
+        return Some(CharRef {
+            name: "hetav;",
+            characters: "\u{3d1}",
+        });
+    }
+
+    if first_char == 't' && try_read("hinsp;") {
+        return Some(CharRef {
+            name: "hinsp;",
+            characters: "\u{2009}",
+        });
+    }
+
+    if first_char == 't' && try_read("hksim;") {
+        return Some(CharRef {
+            name: "hksim;",
+            characters: "\u{223c}",
+        });
+    }
+
+    if first_char == 't' && try_read("imesb;") {
+        return Some(CharRef {
+            name: "imesb;",
+            characters: "\u{22a0}",
+        });
+    }
+
+    if first_char == 't' && try_read("imesd;") {
+        return Some(CharRef {
+            name: "imesd;",
+            characters: "\u{2a30}",
+        });
+    }
+
+    if first_char == 't' && try_read("opbot;") {
+        return Some(CharRef {
+            name: "opbot;",
+            characters: "\u{2336}",
+        });
+    }
+
+    if first_char == 't' && try_read("opcir;") {
+        return Some(CharRef {
+            name: "opcir;",
+            characters: "\u{2af1}",
+        });
+    }
+
+    if first_char == 't' && try_read("prime;") {
+        return Some(CharRef {
+            name: "prime;",
+            characters: "\u{2034}",
+        });
+    }
+
+    if first_char == 't' && try_read("ridot;") {
+        return Some(CharRef {
+            name: "ridot;",
+            characters: "\u{25ec}",
+        });
+    }
+
+    if first_char == 't' && try_read("strok;") {
+        return Some(CharRef {
+            name: "strok;",
+            characters: "\u{167}",
+        });
+    }
+
+    if first_char == 'u' && try_read("acute;") {
+        return Some(CharRef {
+            name: "acute;",
+            characters: "\u{fa}",
+        });
+    }
+
+    if first_char == 'u' && try_read("breve;") {
+        return Some(CharRef {
+            name: "breve;",
+            characters: "\u{16d}",
+        });
+    }
+
+    if first_char == 'u' && try_read("dblac;") {
+        return Some(CharRef {
+            name: "dblac;",
+            characters: "\u{171}",
+        });
+    }
+
+    if first_char == 'u' && try_read("fisht;") {
+        return Some(CharRef {
+            name: "fisht;",
+            characters: "\u{297e}",
+        });
+    }
+
+    if first_char == 'u' && try_read("grave;") {
+        return Some(CharRef {
+            name: "grave;",
+            characters: "\u{f9}",
+        });
+    }
+
+    if first_char == 'u' && try_read("lcorn;") {
+        return Some(CharRef {
+            name: "lcorn;",
+            characters: "\u{231c}",
+        });
+    }
+
+    if first_char == 'u' && try_read("lcrop;") {
+        return Some(CharRef {
+            name: "lcrop;",
+            characters: "\u{230f}",
+        });
+    }
+
+    if first_char == 'u' && try_read("rcorn;") {
+        return Some(CharRef {
+            name: "rcorn;",
+            characters: "\u{231d}",
+        });
+    }
+
+    if first_char == 'u' && try_read("rcrop;") {
+        return Some(CharRef {
+            name: "rcrop;",
+            characters: "\u{230e}",
+        });
+    }
+
+    if first_char == 'u' && try_read("tilde;") {
+        return Some(CharRef {
+            name: "tilde;",
+            characters: "\u{169}",
+        });
+    }
+
+    if first_char == 'v' && try_read("angrt;") {
+        return Some(CharRef {
+            name: "angrt;",
+            characters: "\u{299c}",
+        });
+    }
+
+    if first_char == 'v' && try_read("arphi;") {
+        return Some(CharRef {
+            name: "arphi;",
+            characters: "\u{3d5}",
+        });
+    }
+
+    if first_char == 'v' && try_read("arrho;") {
+        return Some(CharRef {
+            name: "arrho;",
+            characters: "\u{3f1}",
+        });
+    }
+
+    if first_char == 'v' && try_read("eebar;") {
+        return Some(CharRef {
+            name: "eebar;",
+            characters: "\u{22bb}",
+        });
+    }
+
+    if first_char == 'v' && try_read("ellip;") {
+        return Some(CharRef {
+            name: "ellip;",
+            characters: "\u{22ee}",
+        });
+    }
+
+    if first_char == 'v' && try_read("erbar;") {
+        return Some(CharRef {
+            name: "erbar;",
+            characters: "\u{7c}",
+        });
+    }
+
+    if first_char == 'v' && try_read("subnE;") {
+        return Some(CharRef {
+            name: "subnE;",
+            characters: "\u{2acb}\u{fe00}",
+        });
+    }
+
+    if first_char == 'v' && try_read("subne;") {
+        return Some(CharRef {
+            name: "subne;",
+            characters: "\u{228a}\u{fe00}",
+        });
+    }
+
+    if first_char == 'v' && try_read("supnE;") {
+        return Some(CharRef {
+            name: "supnE;",
+            characters: "\u{2acc}\u{fe00}",
+        });
+    }
+
+    if first_char == 'v' && try_read("supne;") {
+        return Some(CharRef {
+            name: "supne;",
+            characters: "\u{228b}\u{fe00}",
+        });
+    }
+
+    if first_char == 'w' && try_read("edbar;") {
+        return Some(CharRef {
+            name: "edbar;",
+            characters: "\u{2a5f}",
+        });
+    }
+
+    if first_char == 'w' && try_read("edgeq;") {
+        return Some(CharRef {
+            name: "edgeq;",
+            characters: "\u{2259}",
+        });
+    }
+
+    if first_char == 'w' && try_read("eierp;") {
+        return Some(CharRef {
+            name: "eierp;",
+            characters: "\u{2118}",
+        });
+    }
+
+    if first_char == 'w' && try_read("reath;") {
+        return Some(CharRef {
+            name: "reath;",
+            characters: "\u{2240}",
+        });
+    }
+
+    if first_char == 'x' && try_read("oplus;") {
+        return Some(CharRef {
+            name: "oplus;",
+            characters: "\u{2a01}",
+        });
+    }
+
+    if first_char == 'x' && try_read("otime;") {
+        return Some(CharRef {
+            name: "otime;",
+            characters: "\u{2a02}",
+        });
+    }
+
+    if first_char == 'x' && try_read("sqcup;") {
+        return Some(CharRef {
+            name: "sqcup;",
+            characters: "\u{2a06}",
+        });
+    }
+
+    if first_char == 'x' && try_read("uplus;") {
+        return Some(CharRef {
+            name: "uplus;",
+            characters: "\u{2a04}",
+        });
+    }
+
+    if first_char == 'x' && try_read("wedge;") {
+        return Some(CharRef {
+            name: "wedge;",
+            characters: "\u{22c0}",
+        });
+    }
+
+    if first_char == 'y' && try_read("acute;") {
+        return Some(CharRef {
+            name: "acute;",
+            characters: "\u{fd}",
+        });
+    }
+
+    if first_char == 'z' && try_read("acute;") {
+        return Some(CharRef {
+            name: "acute;",
+            characters: "\u{17a}",
+        });
+    }
+
+    if first_char == 'z' && try_read("caron;") {
+        return Some(CharRef {
+            name: "caron;",
+            characters: "\u{17e}",
+        });
+    }
+
+    if first_char == 'z' && try_read("eetrf;") {
+        return Some(CharRef {
+            name: "eetrf;",
+            characters: "\u{2128}",
+        });
+    }
+
+    if first_char == 'A' && try_read("Elig;") {
+        return Some(CharRef {
+            name: "Elig;",
+            characters: "\u{c6}",
+        });
+    }
+
+    if first_char == 'A' && try_read("acute") {
+        return Some(CharRef {
+            name: "acute",
+            characters: "\u{c1}",
+        });
+    }
+
+    if first_char == 'A' && try_read("circ;") {
+        return Some(CharRef {
+            name: "circ;",
+            characters: "\u{c2}",
+        });
+    }
+
+    if first_char == 'A' && try_read("grave") {
+        return Some(CharRef {
+            name: "grave",
+            characters: "\u{c0}",
+        });
+    }
+
+    if first_char == 'A' && try_read("lpha;") {
+        return Some(CharRef {
+            name: "lpha;",
+            characters: "\u{391}",
+        });
+    }
+
+    if first_char == 'A' && try_read("macr;") {
+        return Some(CharRef {
+            name: "macr;",
+            characters: "\u{100}",
+        });
+    }
+
+    if first_char == 'A' && try_read("ogon;") {
+        return Some(CharRef {
+            name: "ogon;",
+            characters: "\u{104}",
+        });
+    }
+
+    if first_char == 'A' && try_read("ring;") {
+        return Some(CharRef {
+            name: "ring;",
+            characters: "\u{c5}",
+        });
+    }
+
+    if first_char == 'A' && try_read("tilde") {
+        return Some(CharRef {
+            name: "tilde",
+            characters: "\u{c3}",
+        });
+    }
+
+    if first_char == 'B' && try_read("reve;") {
+        return Some(CharRef {
+            name: "reve;",
+            characters: "\u{2d8}",
+        });
+    }
+
+    if first_char == 'C' && try_read("cedil") {
+        return Some(CharRef {
+            name: "cedil",
+            characters: "\u{c7}",
+        });
+    }
+
+    if first_char == 'C' && try_read("circ;") {
+        return Some(CharRef {
+            name: "circ;",
+            characters: "\u{108}",
+        });
+    }
+
+    if first_char == 'C' && try_read("olon;") {
+        return Some(CharRef {
+            name: "olon;",
+            characters: "\u{2237}",
+        });
+    }
+
+    if first_char == 'C' && try_read("ross;") {
+        return Some(CharRef {
+            name: "ross;",
+            characters: "\u{2a2f}",
+        });
+    }
+
+    if first_char == 'D' && try_read("ashv;") {
+        return Some(CharRef {
+            name: "ashv;",
+            characters: "\u{2ae4}",
+        });
+    }
+
+    if first_char == 'D' && try_read("elta;") {
+        return Some(CharRef {
+            name: "elta;",
+            characters: "\u{394}",
+        });
+    }
+
+    if first_char == 'E' && try_read("acute") {
+        return Some(CharRef {
+            name: "acute",
+            characters: "\u{c9}",
+        });
+    }
+
+    if first_char == 'E' && try_read("circ;") {
+        return Some(CharRef {
+            name: "circ;",
+            characters: "\u{ca}",
+        });
+    }
+
+    if first_char == 'E' && try_read("grave") {
+        return Some(CharRef {
+            name: "grave",
+            characters: "\u{c8}",
+        });
+    }
+
+    if first_char == 'E' && try_read("macr;") {
+        return Some(CharRef {
+            name: "macr;",
+            characters: "\u{112}",
+        });
+    }
+
+    if first_char == 'E' && try_read("ogon;") {
+        return Some(CharRef {
+            name: "ogon;",
+            characters: "\u{118}",
+        });
+    }
+
+    if first_char == 'E' && try_read("qual;") {
+        return Some(CharRef {
+            name: "qual;",
+            characters: "\u{2a75}",
+        });
+    }
+
+    if first_char == 'G' && try_read("amma;") {
+        return Some(CharRef {
+            name: "amma;",
+            characters: "\u{393}",
+        });
+    }
+
+    if first_char == 'G' && try_read("circ;") {
+        return Some(CharRef {
+            name: "circ;",
+            characters: "\u{11c}",
+        });
+    }
+
+    if first_char == 'H' && try_read("acek;") {
+        return Some(CharRef {
+            name: "acek;",
+            characters: "\u{2c7}",
+        });
+    }
+
+    if first_char == 'H' && try_read("circ;") {
+        return Some(CharRef {
+            name: "circ;",
+            characters: "\u{124}",
+        });
+    }
+
+    if first_char == 'I' && try_read("Jlig;") {
+        return Some(CharRef {
+            name: "Jlig;",
+            characters: "\u{132}",
+        });
+    }
+
+    if first_char == 'I' && try_read("acute") {
+        return Some(CharRef {
+            name: "acute",
+            characters: "\u{cd}",
+        });
+    }
+
+    if first_char == 'I' && try_read("circ;") {
+        return Some(CharRef {
+            name: "circ;",
+            characters: "\u{ce}",
+        });
+    }
+
+    if first_char == 'I' && try_read("grave") {
+        return Some(CharRef {
+            name: "grave",
+            characters: "\u{cc}",
+        });
+    }
+
+    if first_char == 'I' && try_read("macr;") {
+        return Some(CharRef {
+            name: "macr;",
+            characters: "\u{12a}",
+        });
+    }
+
+    if first_char == 'I' && try_read("ogon;") {
+        return Some(CharRef {
+            name: "ogon;",
+            characters: "\u{12e}",
+        });
+    }
+
+    if first_char == 'I' && try_read("ukcy;") {
+        return Some(CharRef {
+            name: "ukcy;",
+            characters: "\u{406}",
+        });
+    }
+
+    if first_char == 'J' && try_read("circ;") {
+        return Some(CharRef {
+            name: "circ;",
+            characters: "\u{134}",
+        });
+    }
+
+    if first_char == 'J' && try_read("ukcy;") {
+        return Some(CharRef {
+            name: "ukcy;",
+            characters: "\u{404}",
+        });
+    }
+
+    if first_char == 'K' && try_read("appa;") {
+        return Some(CharRef {
+            name: "appa;",
+            characters: "\u{39a}",
+        });
+    }
+
+    if first_char == 'N' && try_read("tilde") {
+        return Some(CharRef {
+            name: "tilde",
+            characters: "\u{d1}",
+        });
+    }
+
+    if first_char == 'O' && try_read("Elig;") {
+        return Some(CharRef {
+            name: "Elig;",
+            characters: "\u{152}",
+        });
+    }
+
+    if first_char == 'O' && try_read("acute") {
+        return Some(CharRef {
+            name: "acute",
+            characters: "\u{d3}",
+        });
+    }
+
+    if first_char == 'O' && try_read("circ;") {
+        return Some(CharRef {
+            name: "circ;",
+            characters: "\u{d4}",
+        });
+    }
+
+    if first_char == 'O' && try_read("grave") {
+        return Some(CharRef {
+            name: "grave",
+            characters: "\u{d2}",
+        });
+    }
+
+    if first_char == 'O' && try_read("macr;") {
+        return Some(CharRef {
+            name: "macr;",
+            characters: "\u{14c}",
+        });
+    }
+
+    if first_char == 'O' && try_read("mega;") {
+        return Some(CharRef {
+            name: "mega;",
+            characters: "\u{3a9}",
+        });
+    }
+
+    if first_char == 'O' && try_read("slash") {
+        return Some(CharRef {
+            name: "slash",
+            characters: "\u{d8}",
+        });
+    }
+
+    if first_char == 'O' && try_read("tilde") {
+        return Some(CharRef {
+            name: "tilde",
+            characters: "\u{d5}",
+        });
+    }
+
+    if first_char == 'P' && try_read("rime;") {
+        return Some(CharRef {
+            name: "rime;",
+            characters: "\u{2033}",
+        });
+    }
+
+    if first_char == 'R' && try_read("Barr;") {
+        return Some(CharRef {
+            name: "Barr;",
+            characters: "\u{2910}",
+        });
+    }
+
+    if first_char == 'S' && try_read("circ;") {
+        return Some(CharRef {
+            name: "circ;",
+            characters: "\u{15c}",
+        });
+    }
+
+    if first_char == 'S' && try_read("igma;") {
+        return Some(CharRef {
+            name: "igma;",
+            characters: "\u{3a3}",
+        });
+    }
+
+    if first_char == 'T' && try_read("HORN;") {
+        return Some(CharRef {
+            name: "HORN;",
+            characters: "\u{de}",
+        });
+    }
+
+    if first_char == 'T' && try_read("RADE;") {
+        return Some(CharRef {
+            name: "RADE;",
+            characters: "\u{2122}",
+        });
+    }
+
+    if first_char == 'T' && try_read("SHcy;") {
+        return Some(CharRef {
+            name: "SHcy;",
+            characters: "\u{40b}",
+        });
+    }
+
+    if first_char == 'T' && try_read("heta;") {
+        return Some(CharRef {
+            name: "heta;",
+            characters: "\u{398}",
+        });
+    }
+
+    if first_char == 'T' && try_read("ilde;") {
+        return Some(CharRef {
+            name: "ilde;",
+            characters: "\u{223c}",
+        });
+    }
+
+    if first_char == 'U' && try_read("acute") {
+        return Some(CharRef {
+            name: "acute",
+            characters: "\u{da}",
+        });
+    }
+
+    if first_char == 'U' && try_read("brcy;") {
+        return Some(CharRef {
+            name: "brcy;",
+            characters: "\u{40e}",
+        });
+    }
+
+    if first_char == 'U' && try_read("circ;") {
+        return Some(CharRef {
+            name: "circ;",
+            characters: "\u{db}",
+        });
+    }
+
+    if first_char == 'U' && try_read("grave") {
+        return Some(CharRef {
+            name: "grave",
+            characters: "\u{d9}",
+        });
+    }
+
+    if first_char == 'U' && try_read("macr;") {
+        return Some(CharRef {
+            name: "macr;",
+            characters: "\u{16a}",
+        });
+    }
+
+    if first_char == 'U' && try_read("nion;") {
+        return Some(CharRef {
+            name: "nion;",
+            characters: "\u{22c3}",
+        });
+    }
+
+    if first_char == 'U' && try_read("ogon;") {
+        return Some(CharRef {
+            name: "ogon;",
+            characters: "\u{172}",
+        });
+    }
+
+    if first_char == 'U' && try_read("pTee;") {
+        return Some(CharRef {
+            name: "pTee;",
+            characters: "\u{22a5}",
+        });
+    }
+
+    if first_char == 'U' && try_read("ring;") {
+        return Some(CharRef {
+            name: "ring;",
+            characters: "\u{16e}",
+        });
+    }
+
+    if first_char == 'V' && try_read("Dash;") {
+        return Some(CharRef {
+            name: "Dash;",
+            characters: "\u{22ab}",
+        });
+    }
+
+    if first_char == 'V' && try_read("dash;") {
+        return Some(CharRef {
+            name: "dash;",
+            characters: "\u{22a9}",
+        });
+    }
+
+    if first_char == 'W' && try_read("circ;") {
+        return Some(CharRef {
+            name: "circ;",
+            characters: "\u{174}",
+        });
+    }
+
+    if first_char == 'W' && try_read("edge;") {
+        return Some(CharRef {
+            name: "edge;",
+            characters: "\u{22c0}",
+        });
+    }
+
+    if first_char == 'Y' && try_read("acute") {
+        return Some(CharRef {
+            name: "acute",
+            characters: "\u{dd}",
+        });
+    }
+
+    if first_char == 'Y' && try_read("circ;") {
+        return Some(CharRef {
+            name: "circ;",
+            characters: "\u{176}",
+        });
+    }
+
+    if first_char == 'a' && try_read("acute") {
+        return Some(CharRef {
+            name: "acute",
+            characters: "\u{e1}",
+        });
+    }
+
+    if first_char == 'a' && try_read("circ;") {
+        return Some(CharRef {
+            name: "circ;",
+            characters: "\u{e2}",
+        });
+    }
+
+    if first_char == 'a' && try_read("cute;") {
+        return Some(CharRef {
+            name: "cute;",
+            characters: "\u{b4}",
+        });
+    }
+
+    if first_char == 'a' && try_read("elig;") {
+        return Some(CharRef {
+            name: "elig;",
+            characters: "\u{e6}",
+        });
+    }
+
+    if first_char == 'a' && try_read("grave") {
+        return Some(CharRef {
+            name: "grave",
+            characters: "\u{e0}",
+        });
+    }
+
+    if first_char == 'a' && try_read("leph;") {
+        return Some(CharRef {
+            name: "leph;",
+            characters: "\u{2135}",
+        });
+    }
+
+    if first_char == 'a' && try_read("lpha;") {
+        return Some(CharRef {
+            name: "lpha;",
+            characters: "\u{3b1}",
+        });
+    }
+
+    if first_char == 'a' && try_read("macr;") {
+        return Some(CharRef {
+            name: "macr;",
+            characters: "\u{101}",
+        });
+    }
+
+    if first_char == 'a' && try_read("malg;") {
+        return Some(CharRef {
+            name: "malg;",
+            characters: "\u{2a3f}",
+        });
+    }
+
+    if first_char == 'a' && try_read("ngle;") {
+        return Some(CharRef {
+            name: "ngle;",
+            characters: "\u{2220}",
+        });
+    }
+
+    if first_char == 'a' && try_read("ngrt;") {
+        return Some(CharRef {
+            name: "ngrt;",
+            characters: "\u{221f}",
+        });
+    }
+
+    if first_char == 'a' && try_read("ngst;") {
+        return Some(CharRef {
+            name: "ngst;",
+            characters: "\u{c5}",
+        });
+    }
+
+    if first_char == 'a' && try_read("ogon;") {
+        return Some(CharRef {
+            name: "ogon;",
+            characters: "\u{105}",
+        });
+    }
+
+    if first_char == 'a' && try_read("ring;") {
+        return Some(CharRef {
+            name: "ring;",
+            characters: "\u{e5}",
+        });
+    }
+
+    if first_char == 'a' && try_read("symp;") {
+        return Some(CharRef {
+            name: "symp;",
+            characters: "\u{2248}",
+        });
+    }
+
+    if first_char == 'a' && try_read("tilde") {
+        return Some(CharRef {
+            name: "tilde",
+            characters: "\u{e3}",
+        });
+    }
+
+    if first_char == 'a' && try_read("wint;") {
+        return Some(CharRef {
+            name: "wint;",
+            characters: "\u{2a11}",
+        });
+    }
+
+    if first_char == 'b' && try_read("cong;") {
+        return Some(CharRef {
+            name: "cong;",
+            characters: "\u{224c}",
+        });
+    }
+
+    if first_char == 'b' && try_read("dquo;") {
+        return Some(CharRef {
+            name: "dquo;",
+            characters: "\u{201e}",
+        });
+    }
+
+    if first_char == 'b' && try_read("epsi;") {
+        return Some(CharRef {
+            name: "epsi;",
+            characters: "\u{3f6}",
+        });
+    }
+
+    if first_char == 'b' && try_read("lank;") {
+        return Some(CharRef {
+            name: "lank;",
+            characters: "\u{2423}",
+        });
+    }
+
+    if first_char == 'b' && try_read("lk12;") {
+        return Some(CharRef {
+            name: "lk12;",
+            characters: "\u{2592}",
+        });
+    }
+
+    if first_char == 'b' && try_read("lk14;") {
+        return Some(CharRef {
+            name: "lk14;",
+            characters: "\u{2591}",
+        });
+    }
+
+    if first_char == 'b' && try_read("lk34;") {
+        return Some(CharRef {
+            name: "lk34;",
+            characters: "\u{2593}",
+        });
+    }
+
+    if first_char == 'b' && try_read("lock;") {
+        return Some(CharRef {
+            name: "lock;",
+            characters: "\u{2588}",
+        });
+    }
+
+    if first_char == 'b' && try_read("oxDL;") {
+        return Some(CharRef {
+            name: "oxDL;",
+            characters: "\u{2557}",
+        });
+    }
+
+    if first_char == 'b' && try_read("oxDR;") {
+        return Some(CharRef {
+            name: "oxDR;",
+            characters: "\u{2554}",
+        });
+    }
+
+    if first_char == 'b' && try_read("oxDl;") {
+        return Some(CharRef {
+            name: "oxDl;",
+            characters: "\u{2556}",
+        });
+    }
+
+    if first_char == 'b' && try_read("oxDr;") {
+        return Some(CharRef {
+            name: "oxDr;",
+            characters: "\u{2553}",
+        });
+    }
+
+    if first_char == 'b' && try_read("oxHD;") {
+        return Some(CharRef {
+            name: "oxHD;",
+            characters: "\u{2566}",
+        });
+    }
+
+    if first_char == 'b' && try_read("oxHU;") {
+        return Some(CharRef {
+            name: "oxHU;",
+            characters: "\u{2569}",
+        });
+    }
+
+    if first_char == 'b' && try_read("oxHd;") {
+        return Some(CharRef {
+            name: "oxHd;",
+            characters: "\u{2564}",
+        });
+    }
+
+    if first_char == 'b' && try_read("oxHu;") {
+        return Some(CharRef {
+            name: "oxHu;",
+            characters: "\u{2567}",
+        });
+    }
+
+    if first_char == 'b' && try_read("oxUL;") {
+        return Some(CharRef {
+            name: "oxUL;",
+            characters: "\u{255d}",
+        });
+    }
+
+    if first_char == 'b' && try_read("oxUR;") {
+        return Some(CharRef {
+            name: "oxUR;",
+            characters: "\u{255a}",
+        });
+    }
+
+    if first_char == 'b' && try_read("oxUl;") {
+        return Some(CharRef {
+            name: "oxUl;",
+            characters: "\u{255c}",
+        });
+    }
+
+    if first_char == 'b' && try_read("oxUr;") {
+        return Some(CharRef {
+            name: "oxUr;",
+            characters: "\u{2559}",
+        });
+    }
+
+    if first_char == 'b' && try_read("oxVH;") {
+        return Some(CharRef {
+            name: "oxVH;",
+            characters: "\u{256c}",
+        });
+    }
+
+    if first_char == 'b' && try_read("oxVL;") {
+        return Some(CharRef {
+            name: "oxVL;",
+            characters: "\u{2563}",
+        });
+    }
+
+    if first_char == 'b' && try_read("oxVR;") {
+        return Some(CharRef {
+            name: "oxVR;",
+            characters: "\u{2560}",
+        });
+    }
+
+    if first_char == 'b' && try_read("oxVh;") {
+        return Some(CharRef {
+            name: "oxVh;",
+            characters: "\u{256b}",
+        });
+    }
+
+    if first_char == 'b' && try_read("oxVl;") {
+        return Some(CharRef {
+            name: "oxVl;",
+            characters: "\u{2562}",
+        });
+    }
+
+    if first_char == 'b' && try_read("oxVr;") {
+        return Some(CharRef {
+            name: "oxVr;",
+            characters: "\u{255f}",
+        });
+    }
+
+    if first_char == 'b' && try_read("oxdL;") {
+        return Some(CharRef {
+            name: "oxdL;",
+            characters: "\u{2555}",
+        });
+    }
+
+    if first_char == 'b' && try_read("oxdR;") {
+        return Some(CharRef {
+            name: "oxdR;",
+            characters: "\u{2552}",
+        });
+    }
+
+    if first_char == 'b' && try_read("oxdl;") {
+        return Some(CharRef {
+            name: "oxdl;",
+            characters: "\u{2510}",
+        });
+    }
+
+    if first_char == 'b' && try_read("oxdr;") {
+        return Some(CharRef {
+            name: "oxdr;",
+            characters: "\u{250c}",
+        });
+    }
+
+    if first_char == 'b' && try_read("oxhD;") {
+        return Some(CharRef {
+            name: "oxhD;",
+            characters: "\u{2565}",
+        });
+    }
+
+    if first_char == 'b' && try_read("oxhU;") {
+        return Some(CharRef {
+            name: "oxhU;",
+            characters: "\u{2568}",
+        });
+    }
+
+    if first_char == 'b' && try_read("oxhd;") {
+        return Some(CharRef {
+            name: "oxhd;",
+            characters: "\u{252c}",
+        });
+    }
+
+    if first_char == 'b' && try_read("oxhu;") {
+        return Some(CharRef {
+            name: "oxhu;",
+            characters: "\u{2534}",
+        });
+    }
+
+    if first_char == 'b' && try_read("oxuL;") {
+        return Some(CharRef {
+            name: "oxuL;",
+            characters: "\u{255b}",
+        });
+    }
+
+    if first_char == 'b' && try_read("oxuR;") {
+        return Some(CharRef {
+            name: "oxuR;",
+            characters: "\u{2558}",
+        });
+    }
+
+    if first_char == 'b' && try_read("oxul;") {
+        return Some(CharRef {
+            name: "oxul;",
+            characters: "\u{2518}",
+        });
+    }
+
+    if first_char == 'b' && try_read("oxur;") {
+        return Some(CharRef {
+            name: "oxur;",
+            characters: "\u{2514}",
+        });
+    }
+
+    if first_char == 'b' && try_read("oxvH;") {
+        return Some(CharRef {
+            name: "oxvH;",
+            characters: "\u{256a}",
+        });
+    }
+
+    if first_char == 'b' && try_read("oxvL;") {
+        return Some(CharRef {
+            name: "oxvL;",
+            characters: "\u{2561}",
+        });
+    }
+
+    if first_char == 'b' && try_read("oxvR;") {
+        return Some(CharRef {
+            name: "oxvR;",
+            characters: "\u{255e}",
+        });
+    }
+
+    if first_char == 'b' && try_read("oxvh;") {
+        return Some(CharRef {
+            name: "oxvh;",
+            characters: "\u{253c}",
+        });
+    }
+
+    if first_char == 'b' && try_read("oxvl;") {
+        return Some(CharRef {
+            name: "oxvl;",
+            characters: "\u{2524}",
+        });
+    }
+
+    if first_char == 'b' && try_read("oxvr;") {
+        return Some(CharRef {
+            name: "oxvr;",
+            characters: "\u{251c}",
+        });
+    }
+
+    if first_char == 'b' && try_read("reve;") {
+        return Some(CharRef {
+            name: "reve;",
+            characters: "\u{2d8}",
+        });
+    }
+
+    if first_char == 'b' && try_read("rvbar") {
+        return Some(CharRef {
+            name: "rvbar",
+            characters: "\u{a6}",
+        });
+    }
+
+    if first_char == 'b' && try_read("semi;") {
+        return Some(CharRef {
+            name: "semi;",
+            characters: "\u{204f}",
+        });
+    }
+
+    if first_char == 'b' && try_read("sime;") {
+        return Some(CharRef {
+            name: "sime;",
+            characters: "\u{22cd}",
+        });
+    }
+
+    if first_char == 'b' && try_read("solb;") {
+        return Some(CharRef {
+            name: "solb;",
+            characters: "\u{29c5}",
+        });
+    }
+
+    if first_char == 'b' && try_read("umpE;") {
+        return Some(CharRef {
+            name: "umpE;",
+            characters: "\u{2aae}",
+        });
+    }
+
+    if first_char == 'b' && try_read("umpe;") {
+        return Some(CharRef {
+            name: "umpe;",
+            characters: "\u{224f}",
+        });
+    }
+
+    if first_char == 'c' && try_read("aret;") {
+        return Some(CharRef {
+            name: "aret;",
+            characters: "\u{2041}",
+        });
+    }
+
+    if first_char == 'c' && try_read("aron;") {
+        return Some(CharRef {
+            name: "aron;",
+            characters: "\u{2c7}",
+        });
+    }
+
+    if first_char == 'c' && try_read("caps;") {
+        return Some(CharRef {
+            name: "caps;",
+            characters: "\u{2a4d}",
+        });
+    }
+
+    if first_char == 'c' && try_read("cedil") {
+        return Some(CharRef {
+            name: "cedil",
+            characters: "\u{e7}",
+        });
+    }
+
+    if first_char == 'c' && try_read("circ;") {
+        return Some(CharRef {
+            name: "circ;",
+            characters: "\u{109}",
+        });
+    }
+
+    if first_char == 'c' && try_read("cups;") {
+        return Some(CharRef {
+            name: "cups;",
+            characters: "\u{2a4c}",
+        });
+    }
+
+    if first_char == 'c' && try_read("edil;") {
+        return Some(CharRef {
+            name: "edil;",
+            characters: "\u{b8}",
+        });
+    }
+
+    if first_char == 'c' && try_read("heck;") {
+        return Some(CharRef {
+            name: "heck;",
+            characters: "\u{2713}",
+        });
+    }
+
+    if first_char == 'c' && try_read("lubs;") {
+        return Some(CharRef {
+            name: "lubs;",
+            characters: "\u{2663}",
+        });
+    }
+
+    if first_char == 'c' && try_read("olon;") {
+        return Some(CharRef {
+            name: "olon;",
+            characters: "\u{3a}",
+        });
+    }
+
+    if first_char == 'c' && try_read("omma;") {
+        return Some(CharRef {
+            name: "omma;",
+            characters: "\u{2c}",
+        });
+    }
+
+    if first_char == 'c' && try_read("rarr;") {
+        return Some(CharRef {
+            name: "rarr;",
+            characters: "\u{21b5}",
+        });
+    }
+
+    if first_char == 'c' && try_read("ross;") {
+        return Some(CharRef {
+            name: "ross;",
+            characters: "\u{2717}",
+        });
+    }
+
+    if first_char == 'c' && try_read("sube;") {
+        return Some(CharRef {
+            name: "sube;",
+            characters: "\u{2ad1}",
+        });
+    }
+
+    if first_char == 'c' && try_read("supe;") {
+        return Some(CharRef {
+            name: "supe;",
+            characters: "\u{2ad2}",
+        });
+    }
+
+    if first_char == 'c' && try_read("tdot;") {
+        return Some(CharRef {
+            name: "tdot;",
+            characters: "\u{22ef}",
+        });
+    }
+
+    if first_char == 'c' && try_read("uepr;") {
+        return Some(CharRef {
+            name: "uepr;",
+            characters: "\u{22de}",
+        });
+    }
+
+    if first_char == 'c' && try_read("uesc;") {
+        return Some(CharRef {
+            name: "uesc;",
+            characters: "\u{22df}",
+        });
+    }
+
+    if first_char == 'c' && try_read("upor;") {
+        return Some(CharRef {
+            name: "upor;",
+            characters: "\u{2a45}",
+        });
+    }
+
+    if first_char == 'c' && try_read("urren") {
+        return Some(CharRef {
+            name: "urren",
+            characters: "\u{a4}",
+        });
+    }
+
+    if first_char == 'c' && try_read("uvee;") {
+        return Some(CharRef {
+            name: "uvee;",
+            characters: "\u{22ce}",
+        });
+    }
+
+    if first_char == 'c' && try_read("uwed;") {
+        return Some(CharRef {
+            name: "uwed;",
+            characters: "\u{22cf}",
+        });
+    }
+
+    if first_char == 'c' && try_read("wint;") {
+        return Some(CharRef {
+            name: "wint;",
+            characters: "\u{2231}",
+        });
+    }
+
+    if first_char == 'd' && try_read("ashv;") {
+        return Some(CharRef {
+            name: "ashv;",
+            characters: "\u{22a3}",
+        });
+    }
+
+    if first_char == 'd' && try_read("blac;") {
+        return Some(CharRef {
+            name: "blac;",
+            characters: "\u{2dd}",
+        });
+    }
+
+    if first_char == 'd' && try_read("darr;") {
+        return Some(CharRef {
+            name: "darr;",
+            characters: "\u{21ca}",
+        });
+    }
+
+    if first_char == 'd' && try_read("elta;") {
+        return Some(CharRef {
+            name: "elta;",
+            characters: "\u{3b4}",
+        });
+    }
+
+    if first_char == 'd' && try_read("harl;") {
+        return Some(CharRef {
+            name: "harl;",
+            characters: "\u{21c3}",
+        });
+    }
+
+    if first_char == 'd' && try_read("harr;") {
+        return Some(CharRef {
+            name: "harr;",
+            characters: "\u{21c2}",
+        });
+    }
+
+    if first_char == 'd' && try_read("iams;") {
+        return Some(CharRef {
+            name: "iams;",
+            characters: "\u{2666}",
+        });
+    }
+
+    if first_char == 'd' && try_read("isin;") {
+        return Some(CharRef {
+            name: "isin;",
+            characters: "\u{22f2}",
+        });
+    }
+
+    if first_char == 'd' && try_read("ivide") {
+        return Some(CharRef {
+            name: "ivide",
+            characters: "\u{f7}",
+        });
+    }
+
+    if first_char == 'd' && try_read("oteq;") {
+        return Some(CharRef {
+            name: "oteq;",
+            characters: "\u{2250}",
+        });
+    }
+
+    if first_char == 'd' && try_read("tdot;") {
+        return Some(CharRef {
+            name: "tdot;",
+            characters: "\u{22f1}",
+        });
+    }
+
+    if first_char == 'd' && try_read("trif;") {
+        return Some(CharRef {
+            name: "trif;",
+            characters: "\u{25be}",
+        });
+    }
+
+    if first_char == 'd' && try_read("uarr;") {
+        return Some(CharRef {
+            name: "uarr;",
+            characters: "\u{21f5}",
+        });
+    }
+
+    if first_char == 'd' && try_read("uhar;") {
+        return Some(CharRef {
+            name: "uhar;",
+            characters: "\u{296f}",
+        });
+    }
+
+    if first_char == 'e' && try_read("DDot;") {
+        return Some(CharRef {
+            name: "DDot;",
+            characters: "\u{2a77}",
+        });
+    }
+
+    if first_char == 'e' && try_read("acute") {
+        return Some(CharRef {
+            name: "acute",
+            characters: "\u{e9}",
+        });
+    }
+
+    if first_char == 'e' && try_read("circ;") {
+        return Some(CharRef {
+            name: "circ;",
+            characters: "\u{ea}",
+        });
+    }
+
+    if first_char == 'e' && try_read("fDot;") {
+        return Some(CharRef {
+            name: "fDot;",
+            characters: "\u{2252}",
+        });
+    }
+
+    if first_char == 'e' && try_read("grave") {
+        return Some(CharRef {
+            name: "grave",
+            characters: "\u{e8}",
+        });
+    }
+
+    if first_char == 'e' && try_read("macr;") {
+        return Some(CharRef {
+            name: "macr;",
+            characters: "\u{113}",
+        });
+    }
+
+    if first_char == 'e' && try_read("mpty;") {
+        return Some(CharRef {
+            name: "mpty;",
+            characters: "\u{2205}",
+        });
+    }
+
+    if first_char == 'e' && try_read("ogon;") {
+        return Some(CharRef {
+            name: "ogon;",
+            characters: "\u{119}",
+        });
+    }
+
+    if first_char == 'e' && try_read("plus;") {
+        return Some(CharRef {
+            name: "plus;",
+            characters: "\u{2a71}",
+        });
+    }
+
+    if first_char == 'e' && try_read("psiv;") {
+        return Some(CharRef {
+            name: "psiv;",
+            characters: "\u{3f5}",
+        });
+    }
+
+    if first_char == 'e' && try_read("qsim;") {
+        return Some(CharRef {
+            name: "qsim;",
+            characters: "\u{2242}",
+        });
+    }
+
+    if first_char == 'e' && try_read("quiv;") {
+        return Some(CharRef {
+            name: "quiv;",
+            characters: "\u{2261}",
+        });
+    }
+
+    if first_char == 'e' && try_read("rDot;") {
+        return Some(CharRef {
+            name: "rDot;",
+            characters: "\u{2253}",
+        });
+    }
+
+    if first_char == 'e' && try_read("rarr;") {
+        return Some(CharRef {
+            name: "rarr;",
+            characters: "\u{2971}",
+        });
+    }
+
+    if first_char == 'e' && try_read("sdot;") {
+        return Some(CharRef {
+            name: "sdot;",
+            characters: "\u{2250}",
+        });
+    }
+
+    if first_char == 'e' && try_read("xist;") {
+        return Some(CharRef {
+            name: "xist;",
+            characters: "\u{2203}",
+        });
+    }
+
+    if first_char == 'f' && try_read("flig;") {
+        return Some(CharRef {
+            name: "flig;",
+            characters: "\u{fb00}",
+        });
+    }
+
+    if first_char == 'f' && try_read("ilig;") {
+        return Some(CharRef {
+            name: "ilig;",
+            characters: "\u{fb01}",
+        });
+    }
+
+    if first_char == 'f' && try_read("jlig;") {
+        return Some(CharRef {
+            name: "jlig;",
+            characters: "\u{66}\u{6a}",
+        });
+    }
+
+    if first_char == 'f' && try_read("llig;") {
+        return Some(CharRef {
+            name: "llig;",
+            characters: "\u{fb02}",
+        });
+    }
+
+    if first_char == 'f' && try_read("ltns;") {
+        return Some(CharRef {
+            name: "ltns;",
+            characters: "\u{25b1}",
+        });
+    }
+
+    if first_char == 'f' && try_read("orkv;") {
+        return Some(CharRef {
+            name: "orkv;",
+            characters: "\u{2ad9}",
+        });
+    }
+
+    if first_char == 'f' && try_read("rac12") {
+        return Some(CharRef {
+            name: "rac12",
+            characters: "\u{bd}",
+        });
+    }
+
+    if first_char == 'f' && try_read("rac14") {
+        return Some(CharRef {
+            name: "rac14",
+            characters: "\u{bc}",
+        });
+    }
+
+    if first_char == 'f' && try_read("rac34") {
+        return Some(CharRef {
+            name: "rac34",
+            characters: "\u{be}",
+        });
+    }
+
+    if first_char == 'f' && try_read("rasl;") {
+        return Some(CharRef {
+            name: "rasl;",
+            characters: "\u{2044}",
+        });
+    }
+
+    if first_char == 'f' && try_read("rown;") {
+        return Some(CharRef {
+            name: "rown;",
+            characters: "\u{2322}",
+        });
+    }
+
+    if first_char == 'g' && try_read("amma;") {
+        return Some(CharRef {
+            name: "amma;",
+            characters: "\u{3b3}",
+        });
+    }
+
+    if first_char == 'g' && try_read("circ;") {
+        return Some(CharRef {
+            name: "circ;",
+            characters: "\u{11d}",
+        });
+    }
+
+    if first_char == 'g' && try_read("escc;") {
+        return Some(CharRef {
+            name: "escc;",
+            characters: "\u{2aa9}",
+        });
+    }
+
+    if first_char == 'g' && try_read("imel;") {
+        return Some(CharRef {
+            name: "imel;",
+            characters: "\u{2137}",
+        });
+    }
+
+    if first_char == 'g' && try_read("neqq;") {
+        return Some(CharRef {
+            name: "neqq;",
+            characters: "\u{2269}",
+        });
+    }
+
+    if first_char == 'g' && try_read("nsim;") {
+        return Some(CharRef {
+            name: "nsim;",
+            characters: "\u{22e7}",
+        });
+    }
+
+    if first_char == 'g' && try_read("rave;") {
+        return Some(CharRef {
+            name: "rave;",
+            characters: "\u{60}",
+        });
+    }
+
+    if first_char == 'g' && try_read("sime;") {
+        return Some(CharRef {
+            name: "sime;",
+            characters: "\u{2a8e}",
+        });
+    }
+
+    if first_char == 'g' && try_read("siml;") {
+        return Some(CharRef {
+            name: "siml;",
+            characters: "\u{2a90}",
+        });
+    }
+
+    if first_char == 'g' && try_read("tcir;") {
+        return Some(CharRef {
+            name: "tcir;",
+            characters: "\u{2a7a}",
+        });
+    }
+
+    if first_char == 'g' && try_read("tdot;") {
+        return Some(CharRef {
+            name: "tdot;",
+            characters: "\u{22d7}",
+        });
+    }
+
+    if first_char == 'h' && try_read("arrw;") {
+        return Some(CharRef {
+            name: "arrw;",
+            characters: "\u{21ad}",
+        });
+    }
+
+    if first_char == 'h' && try_read("circ;") {
+        return Some(CharRef {
+            name: "circ;",
+            characters: "\u{125}",
+        });
+    }
+
+    if first_char == 'h' && try_read("oarr;") {
+        return Some(CharRef {
+            name: "oarr;",
+            characters: "\u{21ff}",
+        });
+    }
+
+    if first_char == 'i' && try_read("acute") {
+        return Some(CharRef {
+            name: "acute",
+            characters: "\u{ed}",
+        });
+    }
+
+    if first_char == 'i' && try_read("circ;") {
+        return Some(CharRef {
+            name: "circ;",
+            characters: "\u{ee}",
+        });
+    }
+
+    if first_char == 'i' && try_read("excl;") {
+        return Some(CharRef {
+            name: "excl;",
+            characters: "\u{a1}",
+        });
+    }
+
+    if first_char == 'i' && try_read("grave") {
+        return Some(CharRef {
+            name: "grave",
+            characters: "\u{ec}",
+        });
+    }
+
+    if first_char == 'i' && try_read("iint;") {
+        return Some(CharRef {
+            name: "iint;",
+            characters: "\u{222d}",
+        });
+    }
+
+    if first_char == 'i' && try_read("iota;") {
+        return Some(CharRef {
+            name: "iota;",
+            characters: "\u{2129}",
+        });
+    }
+
+    if first_char == 'i' && try_read("jlig;") {
+        return Some(CharRef {
+            name: "jlig;",
+            characters: "\u{133}",
+        });
+    }
+
+    if first_char == 'i' && try_read("macr;") {
+        return Some(CharRef {
+            name: "macr;",
+            characters: "\u{12b}",
+        });
+    }
+
+    if first_char == 'i' && try_read("mage;") {
+        return Some(CharRef {
+            name: "mage;",
+            characters: "\u{2111}",
+        });
+    }
+
+    if first_char == 'i' && try_read("math;") {
+        return Some(CharRef {
+            name: "math;",
+            characters: "\u{131}",
+        });
+    }
+
+    if first_char == 'i' && try_read("mped;") {
+        return Some(CharRef {
+            name: "mped;",
+            characters: "\u{1b5}",
+        });
+    }
+
+    if first_char == 'i' && try_read("nfin;") {
+        return Some(CharRef {
+            name: "nfin;",
+            characters: "\u{221e}",
+        });
+    }
+
+    if first_char == 'i' && try_read("ogon;") {
+        return Some(CharRef {
+            name: "ogon;",
+            characters: "\u{12f}",
+        });
+    }
+
+    if first_char == 'i' && try_read("prod;") {
+        return Some(CharRef {
+            name: "prod;",
+            characters: "\u{2a3c}",
+        });
+    }
+
+    if first_char == 'i' && try_read("quest") {
+        return Some(CharRef {
+            name: "quest",
+            characters: "\u{bf}",
+        });
+    }
+
+    if first_char == 'i' && try_read("sinE;") {
+        return Some(CharRef {
+            name: "sinE;",
+            characters: "\u{22f9}",
+        });
+    }
+
+    if first_char == 'i' && try_read("sins;") {
+        return Some(CharRef {
+            name: "sins;",
+            characters: "\u{22f4}",
+        });
+    }
+
+    if first_char == 'i' && try_read("sinv;") {
+        return Some(CharRef {
+            name: "sinv;",
+            characters: "\u{2208}",
+        });
+    }
+
+    if first_char == 'i' && try_read("ukcy;") {
+        return Some(CharRef {
+            name: "ukcy;",
+            characters: "\u{456}",
+        });
+    }
+
+    if first_char == 'j' && try_read("circ;") {
+        return Some(CharRef {
+            name: "circ;",
+            characters: "\u{135}",
+        });
+    }
+
+    if first_char == 'j' && try_read("math;") {
+        return Some(CharRef {
+            name: "math;",
+            characters: "\u{237}",
+        });
+    }
+
+    if first_char == 'j' && try_read("ukcy;") {
+        return Some(CharRef {
+            name: "ukcy;",
+            characters: "\u{454}",
+        });
+    }
+
+    if first_char == 'k' && try_read("appa;") {
+        return Some(CharRef {
+            name: "appa;",
+            characters: "\u{3ba}",
+        });
+    }
+
+    if first_char == 'l' && try_read("Aarr;") {
+        return Some(CharRef {
+            name: "Aarr;",
+            characters: "\u{21da}",
+        });
+    }
+
+    if first_char == 'l' && try_read("Barr;") {
+        return Some(CharRef {
+            name: "Barr;",
+            characters: "\u{290e}",
+        });
+    }
+
+    if first_char == 'l' && try_read("angd;") {
+        return Some(CharRef {
+            name: "angd;",
+            characters: "\u{2991}",
+        });
+    }
+
+    if first_char == 'l' && try_read("aquo;") {
+        return Some(CharRef {
+            name: "aquo;",
+            characters: "\u{ab}",
+        });
+    }
+
+    if first_char == 'l' && try_read("arrb;") {
+        return Some(CharRef {
+            name: "arrb;",
+            characters: "\u{21e4}",
+        });
+    }
+
+    if first_char == 'l' && try_read("ates;") {
+        return Some(CharRef {
+            name: "ates;",
+            characters: "\u{2aad}\u{fe00}",
+        });
+    }
+
+    if first_char == 'l' && try_read("barr;") {
+        return Some(CharRef {
+            name: "barr;",
+            characters: "\u{290c}",
+        });
+    }
+
+    if first_char == 'l' && try_read("bbrk;") {
+        return Some(CharRef {
+            name: "bbrk;",
+            characters: "\u{2772}",
+        });
+    }
+
+    if first_char == 'l' && try_read("brke;") {
+        return Some(CharRef {
+            name: "brke;",
+            characters: "\u{298b}",
+        });
+    }
+
+    if first_char == 'l' && try_read("ceil;") {
+        return Some(CharRef {
+            name: "ceil;",
+            characters: "\u{2308}",
+        });
+    }
+
+    if first_char == 'l' && try_read("dquo;") {
+        return Some(CharRef {
+            name: "dquo;",
+            characters: "\u{201c}",
+        });
+    }
+
+    if first_char == 'l' && try_read("escc;") {
+        return Some(CharRef {
+            name: "escc;",
+            characters: "\u{2aa8}",
+        });
+    }
+
+    if first_char == 'l' && try_read("hard;") {
+        return Some(CharRef {
+            name: "hard;",
+            characters: "\u{21bd}",
+        });
+    }
+
+    if first_char == 'l' && try_read("haru;") {
+        return Some(CharRef {
+            name: "haru;",
+            characters: "\u{21bc}",
+        });
+    }
+
+    if first_char == 'l' && try_read("hblk;") {
+        return Some(CharRef {
+            name: "hblk;",
+            characters: "\u{2584}",
+        });
+    }
+
+    if first_char == 'l' && try_read("larr;") {
+        return Some(CharRef {
+            name: "larr;",
+            characters: "\u{21c7}",
+        });
+    }
+
+    if first_char == 'l' && try_read("ltri;") {
+        return Some(CharRef {
+            name: "ltri;",
+            characters: "\u{25fa}",
+        });
+    }
+
+    if first_char == 'l' && try_read("neqq;") {
+        return Some(CharRef {
+            name: "neqq;",
+            characters: "\u{2268}",
+        });
+    }
+
+    if first_char == 'l' && try_read("nsim;") {
+        return Some(CharRef {
+            name: "nsim;",
+            characters: "\u{22e6}",
+        });
+    }
+
+    if first_char == 'l' && try_read("oang;") {
+        return Some(CharRef {
+            name: "oang;",
+            characters: "\u{27ec}",
+        });
+    }
+
+    if first_char == 'l' && try_read("oarr;") {
+        return Some(CharRef {
+            name: "oarr;",
+            characters: "\u{21fd}",
+        });
+    }
+
+    if first_char == 'l' && try_read("obrk;") {
+        return Some(CharRef {
+            name: "obrk;",
+            characters: "\u{27e6}",
+        });
+    }
+
+    if first_char == 'l' && try_read("opar;") {
+        return Some(CharRef {
+            name: "opar;",
+            characters: "\u{2985}",
+        });
+    }
+
+    if first_char == 'l' && try_read("rarr;") {
+        return Some(CharRef {
+            name: "rarr;",
+            characters: "\u{21c6}",
+        });
+    }
+
+    if first_char == 'l' && try_read("rhar;") {
+        return Some(CharRef {
+            name: "rhar;",
+            characters: "\u{21cb}",
+        });
+    }
+
+    if first_char == 'l' && try_read("rtri;") {
+        return Some(CharRef {
+            name: "rtri;",
+            characters: "\u{22bf}",
+        });
+    }
+
+    if first_char == 'l' && try_read("sime;") {
+        return Some(CharRef {
+            name: "sime;",
+            characters: "\u{2a8d}",
+        });
+    }
+
+    if first_char == 'l' && try_read("simg;") {
+        return Some(CharRef {
+            name: "simg;",
+            characters: "\u{2a8f}",
+        });
+    }
+
+    if first_char == 'l' && try_read("squo;") {
+        return Some(CharRef {
+            name: "squo;",
+            characters: "\u{2018}",
+        });
+    }
+
+    if first_char == 'l' && try_read("tcir;") {
+        return Some(CharRef {
+            name: "tcir;",
+            characters: "\u{2a79}",
+        });
+    }
+
+    if first_char == 'l' && try_read("tdot;") {
+        return Some(CharRef {
+            name: "tdot;",
+            characters: "\u{22d6}",
+        });
+    }
+
+    if first_char == 'l' && try_read("trie;") {
+        return Some(CharRef {
+            name: "trie;",
+            characters: "\u{22b4}",
+        });
+    }
+
+    if first_char == 'l' && try_read("trif;") {
+        return Some(CharRef {
+            name: "trif;",
+            characters: "\u{25c2}",
+        });
+    }
+
+    if first_char == 'm' && try_read("DDot;") {
+        return Some(CharRef {
+            name: "DDot;",
+            characters: "\u{223a}",
+        });
+    }
+
+    if first_char == 'm' && try_read("dash;") {
+        return Some(CharRef {
+            name: "dash;",
+            characters: "\u{2014}",
+        });
+    }
+
+    if first_char == 'm' && try_read("icro;") {
+        return Some(CharRef {
+            name: "icro;",
+            characters: "\u{b5}",
+        });
+    }
+
+    if first_char == 'm' && try_read("iddot") {
+        return Some(CharRef {
+            name: "iddot",
+            characters: "\u{b7}",
+        });
+    }
+
+    if first_char == 'm' && try_read("inus;") {
+        return Some(CharRef {
+            name: "inus;",
+            characters: "\u{2212}",
+        });
+    }
+
+    if first_char == 'm' && try_read("umap;") {
+        return Some(CharRef {
+            name: "umap;",
+            characters: "\u{22b8}",
+        });
+    }
+
+    if first_char == 'n' && try_read("abla;") {
+        return Some(CharRef {
+            name: "abla;",
+            characters: "\u{2207}",
+        });
+    }
+
+    if first_char == 'n' && try_read("apid;") {
+        return Some(CharRef {
+            name: "apid;",
+            characters: "\u{224b}\u{338}",
+        });
+    }
+
+    if first_char == 'n' && try_read("apos;") {
+        return Some(CharRef {
+            name: "apos;",
+            characters: "\u{149}",
+        });
+    }
+
+    if first_char == 'n' && try_read("atur;") {
+        return Some(CharRef {
+            name: "atur;",
+            characters: "\u{266e}",
+        });
+    }
+
+    if first_char == 'n' && try_read("bump;") {
+        return Some(CharRef {
+            name: "bump;",
+            characters: "\u{224e}\u{338}",
+        });
+    }
+
+    if first_char == 'n' && try_read("cong;") {
+        return Some(CharRef {
+            name: "cong;",
+            characters: "\u{2247}",
+        });
+    }
+
+    if first_char == 'n' && try_read("dash;") {
+        return Some(CharRef {
+            name: "dash;",
+            characters: "\u{2013}",
+        });
+    }
+
+    if first_char == 'n' && try_read("eArr;") {
+        return Some(CharRef {
+            name: "eArr;",
+            characters: "\u{21d7}",
+        });
+    }
+
+    if first_char == 'n' && try_read("earr;") {
+        return Some(CharRef {
+            name: "earr;",
+            characters: "\u{2197}",
+        });
+    }
+
+    if first_char == 'n' && try_read("edot;") {
+        return Some(CharRef {
+            name: "edot;",
+            characters: "\u{2250}\u{338}",
+        });
+    }
+
+    if first_char == 'n' && try_read("esim;") {
+        return Some(CharRef {
+            name: "esim;",
+            characters: "\u{2242}\u{338}",
+        });
+    }
+
+    if first_char == 'n' && try_read("geqq;") {
+        return Some(CharRef {
+            name: "geqq;",
+            characters: "\u{2267}\u{338}",
+        });
+    }
+
+    if first_char == 'n' && try_read("gsim;") {
+        return Some(CharRef {
+            name: "gsim;",
+            characters: "\u{2275}",
+        });
+    }
+
+    if first_char == 'n' && try_read("hArr;") {
+        return Some(CharRef {
+            name: "hArr;",
+            characters: "\u{21ce}",
+        });
+    }
+
+    if first_char == 'n' && try_read("harr;") {
+        return Some(CharRef {
+            name: "harr;",
+            characters: "\u{21ae}",
+        });
+    }
+
+    if first_char == 'n' && try_read("hpar;") {
+        return Some(CharRef {
+            name: "hpar;",
+            characters: "\u{2af2}",
+        });
+    }
+
+    if first_char == 'n' && try_read("lArr;") {
+        return Some(CharRef {
+            name: "lArr;",
+            characters: "\u{21cd}",
+        });
+    }
+
+    if first_char == 'n' && try_read("larr;") {
+        return Some(CharRef {
+            name: "larr;",
+            characters: "\u{219a}",
+        });
+    }
+
+    if first_char == 'n' && try_read("leqq;") {
+        return Some(CharRef {
+            name: "leqq;",
+            characters: "\u{2266}\u{338}",
+        });
+    }
+
+    if first_char == 'n' && try_read("less;") {
+        return Some(CharRef {
+            name: "less;",
+            characters: "\u{226e}",
+        });
+    }
+
+    if first_char == 'n' && try_read("lsim;") {
+        return Some(CharRef {
+            name: "lsim;",
+            characters: "\u{2274}",
+        });
+    }
+
+    if first_char == 'n' && try_read("ltri;") {
+        return Some(CharRef {
+            name: "ltri;",
+            characters: "\u{22ea}",
+        });
+    }
+
+    if first_char == 'n' && try_read("otin;") {
+        return Some(CharRef {
+            name: "otin;",
+            characters: "\u{2209}",
+        });
+    }
+
+    if first_char == 'n' && try_read("otni;") {
+        return Some(CharRef {
+            name: "otni;",
+            characters: "\u{220c}",
+        });
+    }
+
+    if first_char == 'n' && try_read("part;") {
+        return Some(CharRef {
+            name: "part;",
+            characters: "\u{2202}\u{338}",
+        });
+    }
+
+    if first_char == 'n' && try_read("prec;") {
+        return Some(CharRef {
+            name: "prec;",
+            characters: "\u{2280}",
+        });
+    }
+
+    if first_char == 'n' && try_read("rArr;") {
+        return Some(CharRef {
+            name: "rArr;",
+            characters: "\u{21cf}",
+        });
+    }
+
+    if first_char == 'n' && try_read("rarr;") {
+        return Some(CharRef {
+            name: "rarr;",
+            characters: "\u{219b}",
+        });
+    }
+
+    if first_char == 'n' && try_read("rtri;") {
+        return Some(CharRef {
+            name: "rtri;",
+            characters: "\u{22eb}",
+        });
+    }
+
+    if first_char == 'n' && try_read("sime;") {
+        return Some(CharRef {
+            name: "sime;",
+            characters: "\u{2244}",
+        });
+    }
+
+    if first_char == 'n' && try_read("smid;") {
+        return Some(CharRef {
+            name: "smid;",
+            characters: "\u{2224}",
+        });
+    }
+
+    if first_char == 'n' && try_read("spar;") {
+        return Some(CharRef {
+            name: "spar;",
+            characters: "\u{2226}",
+        });
+    }
+
+    if first_char == 'n' && try_read("subE;") {
+        return Some(CharRef {
+            name: "subE;",
+            characters: "\u{2ac5}\u{338}",
+        });
+    }
+
+    if first_char == 'n' && try_read("sube;") {
+        return Some(CharRef {
+            name: "sube;",
+            characters: "\u{2288}",
+        });
+    }
+
+    if first_char == 'n' && try_read("succ;") {
+        return Some(CharRef {
+            name: "succ;",
+            characters: "\u{2281}",
+        });
+    }
+
+    if first_char == 'n' && try_read("supE;") {
+        return Some(CharRef {
+            name: "supE;",
+            characters: "\u{2ac6}\u{338}",
+        });
+    }
+
+    if first_char == 'n' && try_read("supe;") {
+        return Some(CharRef {
+            name: "supe;",
+            characters: "\u{2289}",
+        });
+    }
+
+    if first_char == 'n' && try_read("tilde") {
+        return Some(CharRef {
+            name: "tilde",
+            characters: "\u{f1}",
+        });
+    }
+
+    if first_char == 'n' && try_read("umsp;") {
+        return Some(CharRef {
+            name: "umsp;",
+            characters: "\u{2007}",
+        });
+    }
+
+    if first_char == 'n' && try_read("vsim;") {
+        return Some(CharRef {
+            name: "vsim;",
+            characters: "\u{223c}\u{20d2}",
+        });
+    }
+
+    if first_char == 'n' && try_read("wArr;") {
+        return Some(CharRef {
+            name: "wArr;",
+            characters: "\u{21d6}",
+        });
+    }
+
+    if first_char == 'n' && try_read("warr;") {
+        return Some(CharRef {
+            name: "warr;",
+            characters: "\u{2196}",
+        });
+    }
+
+    if first_char == 'o' && try_read("acute") {
+        return Some(CharRef {
+            name: "acute",
+            characters: "\u{f3}",
+        });
+    }
+
+    if first_char == 'o' && try_read("circ;") {
+        return Some(CharRef {
+            name: "circ;",
+            characters: "\u{f4}",
+        });
+    }
+
+    if first_char == 'o' && try_read("dash;") {
+        return Some(CharRef {
+            name: "dash;",
+            characters: "\u{229d}",
+        });
+    }
+
+    if first_char == 'o' && try_read("elig;") {
+        return Some(CharRef {
+            name: "elig;",
+            characters: "\u{153}",
+        });
+    }
+
+    if first_char == 'o' && try_read("fcir;") {
+        return Some(CharRef {
+            name: "fcir;",
+            characters: "\u{29bf}",
+        });
+    }
+
+    if first_char == 'o' && try_read("grave") {
+        return Some(CharRef {
+            name: "grave",
+            characters: "\u{f2}",
+        });
+    }
+
+    if first_char == 'o' && try_read("hbar;") {
+        return Some(CharRef {
+            name: "hbar;",
+            characters: "\u{29b5}",
+        });
+    }
+
+    if first_char == 'o' && try_read("larr;") {
+        return Some(CharRef {
+            name: "larr;",
+            characters: "\u{21ba}",
+        });
+    }
+
+    if first_char == 'o' && try_read("lcir;") {
+        return Some(CharRef {
+            name: "lcir;",
+            characters: "\u{29be}",
+        });
+    }
+
+    if first_char == 'o' && try_read("line;") {
+        return Some(CharRef {
+            name: "line;",
+            characters: "\u{203e}",
+        });
+    }
+
+    if first_char == 'o' && try_read("macr;") {
+        return Some(CharRef {
+            name: "macr;",
+            characters: "\u{14d}",
+        });
+    }
+
+    if first_char == 'o' && try_read("mega;") {
+        return Some(CharRef {
+            name: "mega;",
+            characters: "\u{3c9}",
+        });
+    }
+
+    if first_char == 'o' && try_read("perp;") {
+        return Some(CharRef {
+            name: "perp;",
+            characters: "\u{29b9}",
+        });
+    }
+
+    if first_char == 'o' && try_read("plus;") {
+        return Some(CharRef {
+            name: "plus;",
+            characters: "\u{2295}",
+        });
+    }
+
+    if first_char == 'o' && try_read("rarr;") {
+        return Some(CharRef {
+            name: "rarr;",
+            characters: "\u{21bb}",
+        });
+    }
+
+    if first_char == 'o' && try_read("rder;") {
+        return Some(CharRef {
+            name: "rder;",
+            characters: "\u{2134}",
+        });
+    }
+
+    if first_char == 'o' && try_read("slash") {
+        return Some(CharRef {
+            name: "slash",
+            characters: "\u{f8}",
+        });
+    }
+
+    if first_char == 'o' && try_read("tilde") {
+        return Some(CharRef {
+            name: "tilde",
+            characters: "\u{f5}",
+        });
+    }
+
+    if first_char == 'o' && try_read("vbar;") {
+        return Some(CharRef {
+            name: "vbar;",
+            characters: "\u{233d}",
+        });
+    }
+
+    if first_char == 'p' && try_read("arsl;") {
+        return Some(CharRef {
+            name: "arsl;",
+            characters: "\u{2afd}",
+        });
+    }
+
+    if first_char == 'p' && try_read("hone;") {
+        return Some(CharRef {
+            name: "hone;",
+            characters: "\u{260e}",
+        });
+    }
+
+    if first_char == 'p' && try_read("lusb;") {
+        return Some(CharRef {
+            name: "lusb;",
+            characters: "\u{229e}",
+        });
+    }
+
+    if first_char == 'p' && try_read("luse;") {
+        return Some(CharRef {
+            name: "luse;",
+            characters: "\u{2a72}",
+        });
+    }
+
+    if first_char == 'p' && try_read("lusmn") {
+        return Some(CharRef {
+            name: "lusmn",
+            characters: "\u{b1}",
+        });
+    }
+
+    if first_char == 'p' && try_read("ound;") {
+        return Some(CharRef {
+            name: "ound;",
+            characters: "\u{a3}",
+        });
+    }
+
+    if first_char == 'p' && try_read("rcue;") {
+        return Some(CharRef {
+            name: "rcue;",
+            characters: "\u{227c}",
+        });
+    }
+
+    if first_char == 'p' && try_read("rime;") {
+        return Some(CharRef {
+            name: "rime;",
+            characters: "\u{2032}",
+        });
+    }
+
+    if first_char == 'p' && try_read("rnap;") {
+        return Some(CharRef {
+            name: "rnap;",
+            characters: "\u{2ab9}",
+        });
+    }
+
+    if first_char == 'p' && try_read("rsim;") {
+        return Some(CharRef {
+            name: "rsim;",
+            characters: "\u{227e}",
+        });
+    }
+
+    if first_char == 'q' && try_read("uest;") {
+        return Some(CharRef {
+            name: "uest;",
+            characters: "\u{3f}",
+        });
+    }
+
+    if first_char == 'r' && try_read("Aarr;") {
+        return Some(CharRef {
+            name: "Aarr;",
+            characters: "\u{21db}",
+        });
+    }
+
+    if first_char == 'r' && try_read("Barr;") {
+        return Some(CharRef {
+            name: "Barr;",
+            characters: "\u{290f}",
+        });
+    }
+
+    if first_char == 'r' && try_read("adic;") {
+        return Some(CharRef {
+            name: "adic;",
+            characters: "\u{221a}",
+        });
+    }
+
+    if first_char == 'r' && try_read("angd;") {
+        return Some(CharRef {
+            name: "angd;",
+            characters: "\u{2992}",
+        });
+    }
+
+    if first_char == 'r' && try_read("ange;") {
+        return Some(CharRef {
+            name: "ange;",
+            characters: "\u{29a5}",
+        });
+    }
+
+    if first_char == 'r' && try_read("aquo;") {
+        return Some(CharRef {
+            name: "aquo;",
+            characters: "\u{bb}",
+        });
+    }
+
+    if first_char == 'r' && try_read("arrb;") {
+        return Some(CharRef {
+            name: "arrb;",
+            characters: "\u{21e5}",
+        });
+    }
+
+    if first_char == 'r' && try_read("arrc;") {
+        return Some(CharRef {
+            name: "arrc;",
+            characters: "\u{2933}",
+        });
+    }
+
+    if first_char == 'r' && try_read("arrw;") {
+        return Some(CharRef {
+            name: "arrw;",
+            characters: "\u{219d}",
+        });
+    }
+
+    if first_char == 'r' && try_read("atio;") {
+        return Some(CharRef {
+            name: "atio;",
+            characters: "\u{2236}",
+        });
+    }
+
+    if first_char == 'r' && try_read("barr;") {
+        return Some(CharRef {
+            name: "barr;",
+            characters: "\u{290d}",
+        });
+    }
+
+    if first_char == 'r' && try_read("bbrk;") {
+        return Some(CharRef {
+            name: "bbrk;",
+            characters: "\u{2773}",
+        });
+    }
+
+    if first_char == 'r' && try_read("brke;") {
+        return Some(CharRef {
+            name: "brke;",
+            characters: "\u{298c}",
+        });
+    }
+
+    if first_char == 'r' && try_read("ceil;") {
+        return Some(CharRef {
+            name: "ceil;",
+            characters: "\u{2309}",
+        });
+    }
+
+    if first_char == 'r' && try_read("dquo;") {
+        return Some(CharRef {
+            name: "dquo;",
+            characters: "\u{201d}",
+        });
+    }
+
+    if first_char == 'r' && try_read("eals;") {
+        return Some(CharRef {
+            name: "eals;",
+            characters: "\u{211d}",
+        });
+    }
+
+    if first_char == 'r' && try_read("hard;") {
+        return Some(CharRef {
+            name: "hard;",
+            characters: "\u{21c1}",
+        });
+    }
+
+    if first_char == 'r' && try_read("haru;") {
+        return Some(CharRef {
+            name: "haru;",
+            characters: "\u{21c0}",
+        });
+    }
+
+    if first_char == 'r' && try_read("larr;") {
+        return Some(CharRef {
+            name: "larr;",
+            characters: "\u{21c4}",
+        });
+    }
+
+    if first_char == 'r' && try_read("lhar;") {
+        return Some(CharRef {
+            name: "lhar;",
+            characters: "\u{21cc}",
+        });
+    }
+
+    if first_char == 'r' && try_read("nmid;") {
+        return Some(CharRef {
+            name: "nmid;",
+            characters: "\u{2aee}",
+        });
+    }
+
+    if first_char == 'r' && try_read("oang;") {
+        return Some(CharRef {
+            name: "oang;",
+            characters: "\u{27ed}",
+        });
+    }
+
+    if first_char == 'r' && try_read("oarr;") {
+        return Some(CharRef {
+            name: "oarr;",
+            characters: "\u{21fe}",
+        });
+    }
+
+    if first_char == 'r' && try_read("obrk;") {
+        return Some(CharRef {
+            name: "obrk;",
+            characters: "\u{27e7}",
+        });
+    }
+
+    if first_char == 'r' && try_read("opar;") {
+        return Some(CharRef {
+            name: "opar;",
+            characters: "\u{2986}",
+        });
+    }
+
+    if first_char == 'r' && try_read("rarr;") {
+        return Some(CharRef {
+            name: "rarr;",
+            characters: "\u{21c9}",
+        });
+    }
+
+    if first_char == 'r' && try_read("squo;") {
+        return Some(CharRef {
+            name: "squo;",
+            characters: "\u{2019}",
+        });
+    }
+
+    if first_char == 'r' && try_read("trie;") {
+        return Some(CharRef {
+            name: "trie;",
+            characters: "\u{22b5}",
+        });
+    }
+
+    if first_char == 'r' && try_read("trif;") {
+        return Some(CharRef {
+            name: "trif;",
+            characters: "\u{25b8}",
+        });
+    }
+
+    if first_char == 's' && try_read("bquo;") {
+        return Some(CharRef {
+            name: "bquo;",
+            characters: "\u{201a}",
+        });
+    }
+
+    if first_char == 's' && try_read("ccue;") {
+        return Some(CharRef {
+            name: "ccue;",
+            characters: "\u{227d}",
+        });
+    }
+
+    if first_char == 's' && try_read("circ;") {
+        return Some(CharRef {
+            name: "circ;",
+            characters: "\u{15d}",
+        });
+    }
+
+    if first_char == 's' && try_read("cnap;") {
+        return Some(CharRef {
+            name: "cnap;",
+            characters: "\u{2aba}",
+        });
+    }
+
+    if first_char == 's' && try_read("csim;") {
+        return Some(CharRef {
+            name: "csim;",
+            characters: "\u{227f}",
+        });
+    }
+
+    if first_char == 's' && try_read("dotb;") {
+        return Some(CharRef {
+            name: "dotb;",
+            characters: "\u{22a1}",
+        });
+    }
+
+    if first_char == 's' && try_read("dote;") {
+        return Some(CharRef {
+            name: "dote;",
+            characters: "\u{2a66}",
+        });
+    }
+
+    if first_char == 's' && try_read("eArr;") {
+        return Some(CharRef {
+            name: "eArr;",
+            characters: "\u{21d8}",
+        });
+    }
+
+    if first_char == 's' && try_read("earr;") {
+        return Some(CharRef {
+            name: "earr;",
+            characters: "\u{2198}",
+        });
+    }
+
+    if first_char == 's' && try_read("etmn;") {
+        return Some(CharRef {
+            name: "etmn;",
+            characters: "\u{2216}",
+        });
+    }
+
+    if first_char == 's' && try_read("harp;") {
+        return Some(CharRef {
+            name: "harp;",
+            characters: "\u{266f}",
+        });
+    }
+
+    if first_char == 's' && try_read("igma;") {
+        return Some(CharRef {
+            name: "igma;",
+            characters: "\u{3c3}",
+        });
+    }
+
+    if first_char == 's' && try_read("imeq;") {
+        return Some(CharRef {
+            name: "imeq;",
+            characters: "\u{2243}",
+        });
+    }
+
+    if first_char == 's' && try_read("imgE;") {
+        return Some(CharRef {
+            name: "imgE;",
+            characters: "\u{2aa0}",
+        });
+    }
+
+    if first_char == 's' && try_read("imlE;") {
+        return Some(CharRef {
+            name: "imlE;",
+            characters: "\u{2a9f}",
+        });
+    }
+
+    if first_char == 's' && try_read("imne;") {
+        return Some(CharRef {
+            name: "imne;",
+            characters: "\u{2246}",
+        });
+    }
+
+    if first_char == 's' && try_read("larr;") {
+        return Some(CharRef {
+            name: "larr;",
+            characters: "\u{2190}",
+        });
+    }
+
+    if first_char == 's' && try_read("mile;") {
+        return Some(CharRef {
+            name: "mile;",
+            characters: "\u{2323}",
+        });
+    }
+
+    if first_char == 's' && try_read("mtes;") {
+        return Some(CharRef {
+            name: "mtes;",
+            characters: "\u{2aac}\u{fe00}",
+        });
+    }
+
+    if first_char == 's' && try_read("qcap;") {
+        return Some(CharRef {
+            name: "qcap;",
+            characters: "\u{2293}",
+        });
+    }
+
+    if first_char == 's' && try_read("qcup;") {
+        return Some(CharRef {
+            name: "qcup;",
+            characters: "\u{2294}",
+        });
+    }
+
+    if first_char == 's' && try_read("qsub;") {
+        return Some(CharRef {
+            name: "qsub;",
+            characters: "\u{228f}",
+        });
+    }
+
+    if first_char == 's' && try_read("qsup;") {
+        return Some(CharRef {
+            name: "qsup;",
+            characters: "\u{2290}",
+        });
+    }
+
+    if first_char == 's' && try_read("rarr;") {
+        return Some(CharRef {
+            name: "rarr;",
+            characters: "\u{2192}",
+        });
+    }
+
+    if first_char == 's' && try_read("tarf;") {
+        return Some(CharRef {
+            name: "tarf;",
+            characters: "\u{2605}",
+        });
+    }
+
+    if first_char == 's' && try_read("trns;") {
+        return Some(CharRef {
+            name: "trns;",
+            characters: "\u{af}",
+        });
+    }
+
+    if first_char == 's' && try_read("ubnE;") {
+        return Some(CharRef {
+            name: "ubnE;",
+            characters: "\u{2acb}",
+        });
+    }
+
+    if first_char == 's' && try_read("ubne;") {
+        return Some(CharRef {
+            name: "ubne;",
+            characters: "\u{228a}",
+        });
+    }
+
+    if first_char == 's' && try_read("upnE;") {
+        return Some(CharRef {
+            name: "upnE;",
+            characters: "\u{2acc}",
+        });
+    }
+
+    if first_char == 's' && try_read("upne;") {
+        return Some(CharRef {
+            name: "upne;",
+            characters: "\u{228b}",
+        });
+    }
+
+    if first_char == 's' && try_read("wArr;") {
+        return Some(CharRef {
+            name: "wArr;",
+            characters: "\u{21d9}",
+        });
+    }
+
+    if first_char == 's' && try_read("warr;") {
+        return Some(CharRef {
+            name: "warr;",
+            characters: "\u{2199}",
+        });
+    }
+
+    if first_char == 's' && try_read("zlig;") {
+        return Some(CharRef {
+            name: "zlig;",
+            characters: "\u{df}",
+        });
+    }
+
+    if first_char == 't' && try_read("heta;") {
+        return Some(CharRef {
+            name: "heta;",
+            characters: "\u{3b8}",
+        });
+    }
+
+    if first_char == 't' && try_read("hkap;") {
+        return Some(CharRef {
+            name: "hkap;",
+            characters: "\u{2248}",
+        });
+    }
+
+    if first_char == 't' && try_read("horn;") {
+        return Some(CharRef {
+            name: "horn;",
+            characters: "\u{fe}",
+        });
+    }
+
+    if first_char == 't' && try_read("ilde;") {
+        return Some(CharRef {
+            name: "ilde;",
+            characters: "\u{2dc}",
+        });
+    }
+
+    if first_char == 't' && try_read("imes;") {
+        return Some(CharRef {
+            name: "imes;",
+            characters: "\u{d7}",
+        });
+    }
+
+    if first_char == 't' && try_read("rade;") {
+        return Some(CharRef {
+            name: "rade;",
+            characters: "\u{2122}",
+        });
+    }
+
+    if first_char == 't' && try_read("risb;") {
+        return Some(CharRef {
+            name: "risb;",
+            characters: "\u{29cd}",
+        });
+    }
+
+    if first_char == 't' && try_read("shcy;") {
+        return Some(CharRef {
+            name: "shcy;",
+            characters: "\u{45b}",
+        });
+    }
+
+    if first_char == 't' && try_read("wixt;") {
+        return Some(CharRef {
+            name: "wixt;",
+            characters: "\u{226c}",
+        });
+    }
+
+    if first_char == 'u' && try_read("acute") {
+        return Some(CharRef {
+            name: "acute",
+            characters: "\u{fa}",
+        });
+    }
+
+    if first_char == 'u' && try_read("brcy;") {
+        return Some(CharRef {
+            name: "brcy;",
+            characters: "\u{45e}",
+        });
+    }
+
+    if first_char == 'u' && try_read("circ;") {
+        return Some(CharRef {
+            name: "circ;",
+            characters: "\u{fb}",
+        });
+    }
+
+    if first_char == 'u' && try_read("darr;") {
+        return Some(CharRef {
+            name: "darr;",
+            characters: "\u{21c5}",
+        });
+    }
+
+    if first_char == 'u' && try_read("dhar;") {
+        return Some(CharRef {
+            name: "dhar;",
+            characters: "\u{296e}",
+        });
+    }
+
+    if first_char == 'u' && try_read("grave") {
+        return Some(CharRef {
+            name: "grave",
+            characters: "\u{f9}",
+        });
+    }
+
+    if first_char == 'u' && try_read("harl;") {
+        return Some(CharRef {
+            name: "harl;",
+            characters: "\u{21bf}",
+        });
+    }
+
+    if first_char == 'u' && try_read("harr;") {
+        return Some(CharRef {
+            name: "harr;",
+            characters: "\u{21be}",
+        });
+    }
+
+    if first_char == 'u' && try_read("hblk;") {
+        return Some(CharRef {
+            name: "hblk;",
+            characters: "\u{2580}",
+        });
+    }
+
+    if first_char == 'u' && try_read("ltri;") {
+        return Some(CharRef {
+            name: "ltri;",
+            characters: "\u{25f8}",
+        });
+    }
+
+    if first_char == 'u' && try_read("macr;") {
+        return Some(CharRef {
+            name: "macr;",
+            characters: "\u{16b}",
+        });
+    }
+
+    if first_char == 'u' && try_read("ogon;") {
+        return Some(CharRef {
+            name: "ogon;",
+            characters: "\u{173}",
+        });
+    }
+
+    if first_char == 'u' && try_read("plus;") {
+        return Some(CharRef {
+            name: "plus;",
+            characters: "\u{228e}",
+        });
+    }
+
+    if first_char == 'u' && try_read("psih;") {
+        return Some(CharRef {
+            name: "psih;",
+            characters: "\u{3d2}",
+        });
+    }
+
+    if first_char == 'u' && try_read("ring;") {
+        return Some(CharRef {
+            name: "ring;",
+            characters: "\u{16f}",
+        });
+    }
+
+    if first_char == 'u' && try_read("rtri;") {
+        return Some(CharRef {
+            name: "rtri;",
+            characters: "\u{25f9}",
+        });
+    }
+
+    if first_char == 'u' && try_read("tdot;") {
+        return Some(CharRef {
+            name: "tdot;",
+            characters: "\u{22f0}",
+        });
+    }
+
+    if first_char == 'u' && try_read("trif;") {
+        return Some(CharRef {
+            name: "trif;",
+            characters: "\u{25b4}",
+        });
+    }
+
+    if first_char == 'u' && try_read("uarr;") {
+        return Some(CharRef {
+            name: "uarr;",
+            characters: "\u{21c8}",
+        });
+    }
+
+    if first_char == 'v' && try_read("Barv;") {
+        return Some(CharRef {
+            name: "Barv;",
+            characters: "\u{2ae9}",
+        });
+    }
+
+    if first_char == 'v' && try_read("Dash;") {
+        return Some(CharRef {
+            name: "Dash;",
+            characters: "\u{22a8}",
+        });
+    }
+
+    if first_char == 'v' && try_read("arpi;") {
+        return Some(CharRef {
+            name: "arpi;",
+            characters: "\u{3d6}",
+        });
+    }
+
+    if first_char == 'v' && try_read("dash;") {
+        return Some(CharRef {
+            name: "dash;",
+            characters: "\u{22a2}",
+        });
+    }
+
+    if first_char == 'v' && try_read("eeeq;") {
+        return Some(CharRef {
+            name: "eeeq;",
+            characters: "\u{225a}",
+        });
+    }
+
+    if first_char == 'v' && try_read("ltri;") {
+        return Some(CharRef {
+            name: "ltri;",
+            characters: "\u{22b2}",
+        });
+    }
+
+    if first_char == 'v' && try_read("nsub;") {
+        return Some(CharRef {
+            name: "nsub;",
+            characters: "\u{2282}\u{20d2}",
+        });
+    }
+
+    if first_char == 'v' && try_read("nsup;") {
+        return Some(CharRef {
+            name: "nsup;",
+            characters: "\u{2283}\u{20d2}",
+        });
+    }
+
+    if first_char == 'v' && try_read("prop;") {
+        return Some(CharRef {
+            name: "prop;",
+            characters: "\u{221d}",
+        });
+    }
+
+    if first_char == 'v' && try_read("rtri;") {
+        return Some(CharRef {
+            name: "rtri;",
+            characters: "\u{22b3}",
+        });
+    }
+
+    if first_char == 'w' && try_read("circ;") {
+        return Some(CharRef {
+            name: "circ;",
+            characters: "\u{175}",
+        });
+    }
+
+    if first_char == 'w' && try_read("edge;") {
+        return Some(CharRef {
+            name: "edge;",
+            characters: "\u{2227}",
+        });
+    }
+
+    if first_char == 'x' && try_read("circ;") {
+        return Some(CharRef {
+            name: "circ;",
+            characters: "\u{25ef}",
+        });
+    }
+
+    if first_char == 'x' && try_read("dtri;") {
+        return Some(CharRef {
+            name: "dtri;",
+            characters: "\u{25bd}",
+        });
+    }
+
+    if first_char == 'x' && try_read("hArr;") {
+        return Some(CharRef {
+            name: "hArr;",
+            characters: "\u{27fa}",
+        });
+    }
+
+    if first_char == 'x' && try_read("harr;") {
+        return Some(CharRef {
+            name: "harr;",
+            characters: "\u{27f7}",
+        });
+    }
+
+    if first_char == 'x' && try_read("lArr;") {
+        return Some(CharRef {
+            name: "lArr;",
+            characters: "\u{27f8}",
+        });
+    }
+
+    if first_char == 'x' && try_read("larr;") {
+        return Some(CharRef {
+            name: "larr;",
+            characters: "\u{27f5}",
+        });
+    }
+
+    if first_char == 'x' && try_read("odot;") {
+        return Some(CharRef {
+            name: "odot;",
+            characters: "\u{2a00}",
+        });
+    }
+
+    if first_char == 'x' && try_read("rArr;") {
+        return Some(CharRef {
+            name: "rArr;",
+            characters: "\u{27f9}",
+        });
+    }
+
+    if first_char == 'x' && try_read("rarr;") {
+        return Some(CharRef {
+            name: "rarr;",
+            characters: "\u{27f6}",
+        });
+    }
+
+    if first_char == 'x' && try_read("utri;") {
+        return Some(CharRef {
+            name: "utri;",
+            characters: "\u{25b3}",
+        });
+    }
+
+    if first_char == 'y' && try_read("acute") {
+        return Some(CharRef {
+            name: "acute",
+            characters: "\u{fd}",
+        });
+    }
+
+    if first_char == 'y' && try_read("circ;") {
+        return Some(CharRef {
+            name: "circ;",
+            characters: "\u{177}",
+        });
+    }
+
+    if first_char == 'A' && try_read("Elig") {
+        return Some(CharRef {
+            name: "Elig",
+            characters: "\u{c6}",
+        });
+    }
+
+    if first_char == 'A' && try_read("circ") {
+        return Some(CharRef {
+            name: "circ",
+            characters: "\u{c2}",
+        });
+    }
+
+    if first_char == 'A' && try_read("opf;") {
+        return Some(CharRef {
+            name: "opf;",
+            characters: "\u{1d538}",
+        });
+    }
+
+    if first_char == 'A' && try_read("ring") {
+        return Some(CharRef {
+            name: "ring",
+            characters: "\u{c5}",
+        });
+    }
+
+    if first_char == 'A' && try_read("scr;") {
+        return Some(CharRef {
+            name: "scr;",
+            characters: "\u{1d49c}",
+        });
+    }
+
+    if first_char == 'A' && try_read("uml;") {
+        return Some(CharRef {
+            name: "uml;",
+            characters: "\u{c4}",
+        });
+    }
+
+    if first_char == 'B' && try_read("arv;") {
+        return Some(CharRef {
+            name: "arv;",
+            characters: "\u{2ae7}",
+        });
+    }
+
+    if first_char == 'B' && try_read("eta;") {
+        return Some(CharRef {
+            name: "eta;",
+            characters: "\u{392}",
+        });
+    }
+
+    if first_char == 'B' && try_read("opf;") {
+        return Some(CharRef {
+            name: "opf;",
+            characters: "\u{1d539}",
+        });
+    }
+
+    if first_char == 'B' && try_read("scr;") {
+        return Some(CharRef {
+            name: "scr;",
+            characters: "\u{212c}",
+        });
+    }
+
+    if first_char == 'C' && try_read("Hcy;") {
+        return Some(CharRef {
+            name: "Hcy;",
+            characters: "\u{427}",
+        });
+    }
+
+    if first_char == 'C' && try_read("OPY;") {
+        return Some(CharRef {
+            name: "OPY;",
+            characters: "\u{a9}",
+        });
+    }
+
+    if first_char == 'C' && try_read("dot;") {
+        return Some(CharRef {
+            name: "dot;",
+            characters: "\u{10a}",
+        });
+    }
+
+    if first_char == 'C' && try_read("opf;") {
+        return Some(CharRef {
+            name: "opf;",
+            characters: "\u{2102}",
+        });
+    }
+
+    if first_char == 'C' && try_read("scr;") {
+        return Some(CharRef {
+            name: "scr;",
+            characters: "\u{1d49e}",
+        });
+    }
+
+    if first_char == 'D' && try_read("Jcy;") {
+        return Some(CharRef {
+            name: "Jcy;",
+            characters: "\u{402}",
+        });
+    }
+
+    if first_char == 'D' && try_read("Scy;") {
+        return Some(CharRef {
+            name: "Scy;",
+            characters: "\u{405}",
+        });
+    }
+
+    if first_char == 'D' && try_read("Zcy;") {
+        return Some(CharRef {
+            name: "Zcy;",
+            characters: "\u{40f}",
+        });
+    }
+
+    if first_char == 'D' && try_read("arr;") {
+        return Some(CharRef {
+            name: "arr;",
+            characters: "\u{21a1}",
+        });
+    }
+
+    if first_char == 'D' && try_read("opf;") {
+        return Some(CharRef {
+            name: "opf;",
+            characters: "\u{1d53b}",
+        });
+    }
+
+    if first_char == 'D' && try_read("scr;") {
+        return Some(CharRef {
+            name: "scr;",
+            characters: "\u{1d49f}",
+        });
+    }
+
+    if first_char == 'E' && try_read("circ") {
+        return Some(CharRef {
+            name: "circ",
+            characters: "\u{ca}",
+        });
+    }
+
+    if first_char == 'E' && try_read("dot;") {
+        return Some(CharRef {
+            name: "dot;",
+            characters: "\u{116}",
+        });
+    }
+
+    if first_char == 'E' && try_read("opf;") {
+        return Some(CharRef {
+            name: "opf;",
+            characters: "\u{1d53c}",
+        });
+    }
+
+    if first_char == 'E' && try_read("scr;") {
+        return Some(CharRef {
+            name: "scr;",
+            characters: "\u{2130}",
+        });
+    }
+
+    if first_char == 'E' && try_read("sim;") {
+        return Some(CharRef {
+            name: "sim;",
+            characters: "\u{2a73}",
+        });
+    }
+
+    if first_char == 'E' && try_read("uml;") {
+        return Some(CharRef {
+            name: "uml;",
+            characters: "\u{cb}",
+        });
+    }
+
+    if first_char == 'F' && try_read("opf;") {
+        return Some(CharRef {
+            name: "opf;",
+            characters: "\u{1d53d}",
+        });
+    }
+
+    if first_char == 'F' && try_read("scr;") {
+        return Some(CharRef {
+            name: "scr;",
+            characters: "\u{2131}",
+        });
+    }
+
+    if first_char == 'G' && try_read("Jcy;") {
+        return Some(CharRef {
+            name: "Jcy;",
+            characters: "\u{403}",
+        });
+    }
+
+    if first_char == 'G' && try_read("dot;") {
+        return Some(CharRef {
+            name: "dot;",
+            characters: "\u{120}",
+        });
+    }
+
+    if first_char == 'G' && try_read("opf;") {
+        return Some(CharRef {
+            name: "opf;",
+            characters: "\u{1d53e}",
+        });
+    }
+
+    if first_char == 'G' && try_read("scr;") {
+        return Some(CharRef {
+            name: "scr;",
+            characters: "\u{1d4a2}",
+        });
+    }
+
+    if first_char == 'H' && try_read("opf;") {
+        return Some(CharRef {
+            name: "opf;",
+            characters: "\u{210d}",
+        });
+    }
+
+    if first_char == 'H' && try_read("scr;") {
+        return Some(CharRef {
+            name: "scr;",
+            characters: "\u{210b}",
+        });
+    }
+
+    if first_char == 'I' && try_read("Ecy;") {
+        return Some(CharRef {
+            name: "Ecy;",
+            characters: "\u{415}",
+        });
+    }
+
+    if first_char == 'I' && try_read("Ocy;") {
+        return Some(CharRef {
+            name: "Ocy;",
+            characters: "\u{401}",
+        });
+    }
+
+    if first_char == 'I' && try_read("circ") {
+        return Some(CharRef {
+            name: "circ",
+            characters: "\u{ce}",
+        });
+    }
+
+    if first_char == 'I' && try_read("dot;") {
+        return Some(CharRef {
+            name: "dot;",
+            characters: "\u{130}",
+        });
+    }
+
+    if first_char == 'I' && try_read("opf;") {
+        return Some(CharRef {
+            name: "opf;",
+            characters: "\u{1d540}",
+        });
+    }
+
+    if first_char == 'I' && try_read("ota;") {
+        return Some(CharRef {
+            name: "ota;",
+            characters: "\u{399}",
+        });
+    }
+
+    if first_char == 'I' && try_read("scr;") {
+        return Some(CharRef {
+            name: "scr;",
+            characters: "\u{2110}",
+        });
+    }
+
+    if first_char == 'I' && try_read("uml;") {
+        return Some(CharRef {
+            name: "uml;",
+            characters: "\u{cf}",
+        });
+    }
+
+    if first_char == 'J' && try_read("opf;") {
+        return Some(CharRef {
+            name: "opf;",
+            characters: "\u{1d541}",
+        });
+    }
+
+    if first_char == 'J' && try_read("scr;") {
+        return Some(CharRef {
+            name: "scr;",
+            characters: "\u{1d4a5}",
+        });
+    }
+
+    if first_char == 'K' && try_read("Hcy;") {
+        return Some(CharRef {
+            name: "Hcy;",
+            characters: "\u{425}",
+        });
+    }
+
+    if first_char == 'K' && try_read("Jcy;") {
+        return Some(CharRef {
+            name: "Jcy;",
+            characters: "\u{40c}",
+        });
+    }
+
+    if first_char == 'K' && try_read("opf;") {
+        return Some(CharRef {
+            name: "opf;",
+            characters: "\u{1d542}",
+        });
+    }
+
+    if first_char == 'K' && try_read("scr;") {
+        return Some(CharRef {
+            name: "scr;",
+            characters: "\u{1d4a6}",
+        });
+    }
+
+    if first_char == 'L' && try_read("Jcy;") {
+        return Some(CharRef {
+            name: "Jcy;",
+            characters: "\u{409}",
+        });
+    }
+
+    if first_char == 'L' && try_read("ang;") {
+        return Some(CharRef {
+            name: "ang;",
+            characters: "\u{27ea}",
+        });
+    }
+
+    if first_char == 'L' && try_read("arr;") {
+        return Some(CharRef {
+            name: "arr;",
+            characters: "\u{219e}",
+        });
+    }
+
+    if first_char == 'L' && try_read("opf;") {
+        return Some(CharRef {
+            name: "opf;",
+            characters: "\u{1d543}",
+        });
+    }
+
+    if first_char == 'L' && try_read("scr;") {
+        return Some(CharRef {
+            name: "scr;",
+            characters: "\u{2112}",
+        });
+    }
+
+    if first_char == 'M' && try_read("opf;") {
+        return Some(CharRef {
+            name: "opf;",
+            characters: "\u{1d544}",
+        });
+    }
+
+    if first_char == 'M' && try_read("scr;") {
+        return Some(CharRef {
+            name: "scr;",
+            characters: "\u{2133}",
+        });
+    }
+
+    if first_char == 'N' && try_read("Jcy;") {
+        return Some(CharRef {
+            name: "Jcy;",
+            characters: "\u{40a}",
+        });
+    }
+
+    if first_char == 'N' && try_read("opf;") {
+        return Some(CharRef {
+            name: "opf;",
+            characters: "\u{2115}",
+        });
+    }
+
+    if first_char == 'N' && try_read("scr;") {
+        return Some(CharRef {
+            name: "scr;",
+            characters: "\u{1d4a9}",
+        });
+    }
+
+    if first_char == 'O' && try_read("circ") {
+        return Some(CharRef {
+            name: "circ",
+            characters: "\u{d4}",
+        });
+    }
+
+    if first_char == 'O' && try_read("opf;") {
+        return Some(CharRef {
+            name: "opf;",
+            characters: "\u{1d546}",
+        });
+    }
+
+    if first_char == 'O' && try_read("scr;") {
+        return Some(CharRef {
+            name: "scr;",
+            characters: "\u{1d4aa}",
+        });
+    }
+
+    if first_char == 'O' && try_read("uml;") {
+        return Some(CharRef {
+            name: "uml;",
+            characters: "\u{d6}",
+        });
+    }
+
+    if first_char == 'P' && try_read("opf;") {
+        return Some(CharRef {
+            name: "opf;",
+            characters: "\u{2119}",
+        });
+    }
+
+    if first_char == 'P' && try_read("scr;") {
+        return Some(CharRef {
+            name: "scr;",
+            characters: "\u{1d4ab}",
+        });
+    }
+
+    if first_char == 'Q' && try_read("UOT;") {
+        return Some(CharRef {
+            name: "UOT;",
+            characters: "\u{22}",
+        });
+    }
+
+    if first_char == 'Q' && try_read("opf;") {
+        return Some(CharRef {
+            name: "opf;",
+            characters: "\u{211a}",
+        });
+    }
+
+    if first_char == 'Q' && try_read("scr;") {
+        return Some(CharRef {
+            name: "scr;",
+            characters: "\u{1d4ac}",
+        });
+    }
+
+    if first_char == 'R' && try_read("ang;") {
+        return Some(CharRef {
+            name: "ang;",
+            characters: "\u{27eb}",
+        });
+    }
+
+    if first_char == 'R' && try_read("arr;") {
+        return Some(CharRef {
+            name: "arr;",
+            characters: "\u{21a0}",
+        });
+    }
+
+    if first_char == 'R' && try_read("opf;") {
+        return Some(CharRef {
+            name: "opf;",
+            characters: "\u{211d}",
+        });
+    }
+
+    if first_char == 'R' && try_read("scr;") {
+        return Some(CharRef {
+            name: "scr;",
+            characters: "\u{211b}",
+        });
+    }
+
+    if first_char == 'S' && try_read("Hcy;") {
+        return Some(CharRef {
+            name: "Hcy;",
+            characters: "\u{428}",
+        });
+    }
+
+    if first_char == 'S' && try_read("opf;") {
+        return Some(CharRef {
+            name: "opf;",
+            characters: "\u{1d54a}",
+        });
+    }
+
+    if first_char == 'S' && try_read("qrt;") {
+        return Some(CharRef {
+            name: "qrt;",
+            characters: "\u{221a}",
+        });
+    }
+
+    if first_char == 'S' && try_read("scr;") {
+        return Some(CharRef {
+            name: "scr;",
+            characters: "\u{1d4ae}",
+        });
+    }
+
+    if first_char == 'S' && try_read("tar;") {
+        return Some(CharRef {
+            name: "tar;",
+            characters: "\u{22c6}",
+        });
+    }
+
+    if first_char == 'T' && try_read("HORN") {
+        return Some(CharRef {
+            name: "HORN",
+            characters: "\u{de}",
+        });
+    }
+
+    if first_char == 'T' && try_read("Scy;") {
+        return Some(CharRef {
+            name: "Scy;",
+            characters: "\u{426}",
+        });
+    }
+
+    if first_char == 'T' && try_read("opf;") {
+        return Some(CharRef {
+            name: "opf;",
+            characters: "\u{1d54b}",
+        });
+    }
+
+    if first_char == 'T' && try_read("scr;") {
+        return Some(CharRef {
+            name: "scr;",
+            characters: "\u{1d4af}",
+        });
+    }
+
+    if first_char == 'U' && try_read("arr;") {
+        return Some(CharRef {
+            name: "arr;",
+            characters: "\u{219f}",
+        });
+    }
+
+    if first_char == 'U' && try_read("circ") {
+        return Some(CharRef {
+            name: "circ",
+            characters: "\u{db}",
+        });
+    }
+
+    if first_char == 'U' && try_read("opf;") {
+        return Some(CharRef {
+            name: "opf;",
+            characters: "\u{1d54c}",
+        });
+    }
+
+    if first_char == 'U' && try_read("psi;") {
+        return Some(CharRef {
+            name: "psi;",
+            characters: "\u{3d2}",
+        });
+    }
+
+    if first_char == 'U' && try_read("scr;") {
+        return Some(CharRef {
+            name: "scr;",
+            characters: "\u{1d4b0}",
+        });
+    }
+
+    if first_char == 'U' && try_read("uml;") {
+        return Some(CharRef {
+            name: "uml;",
+            characters: "\u{dc}",
+        });
+    }
+
+    if first_char == 'V' && try_read("bar;") {
+        return Some(CharRef {
+            name: "bar;",
+            characters: "\u{2aeb}",
+        });
+    }
+
+    if first_char == 'V' && try_read("ert;") {
+        return Some(CharRef {
+            name: "ert;",
+            characters: "\u{2016}",
+        });
+    }
+
+    if first_char == 'V' && try_read("opf;") {
+        return Some(CharRef {
+            name: "opf;",
+            characters: "\u{1d54d}",
+        });
+    }
+
+    if first_char == 'V' && try_read("scr;") {
+        return Some(CharRef {
+            name: "scr;",
+            characters: "\u{1d4b1}",
+        });
+    }
+
+    if first_char == 'W' && try_read("opf;") {
+        return Some(CharRef {
+            name: "opf;",
+            characters: "\u{1d54e}",
+        });
+    }
+
+    if first_char == 'W' && try_read("scr;") {
+        return Some(CharRef {
+            name: "scr;",
+            characters: "\u{1d4b2}",
+        });
+    }
+
+    if first_char == 'X' && try_read("opf;") {
+        return Some(CharRef {
+            name: "opf;",
+            characters: "\u{1d54f}",
+        });
+    }
+
+    if first_char == 'X' && try_read("scr;") {
+        return Some(CharRef {
+            name: "scr;",
+            characters: "\u{1d4b3}",
+        });
+    }
+
+    if first_char == 'Y' && try_read("Acy;") {
+        return Some(CharRef {
+            name: "Acy;",
+            characters: "\u{42f}",
+        });
+    }
+
+    if first_char == 'Y' && try_read("Icy;") {
+        return Some(CharRef {
+            name: "Icy;",
+            characters: "\u{407}",
+        });
+    }
+
+    if first_char == 'Y' && try_read("Ucy;") {
+        return Some(CharRef {
+            name: "Ucy;",
+            characters: "\u{42e}",
+        });
+    }
+
+    if first_char == 'Y' && try_read("opf;") {
+        return Some(CharRef {
+            name: "opf;",
+            characters: "\u{1d550}",
+        });
+    }
+
+    if first_char == 'Y' && try_read("scr;") {
+        return Some(CharRef {
+            name: "scr;",
+            characters: "\u{1d4b4}",
+        });
+    }
+
+    if first_char == 'Y' && try_read("uml;") {
+        return Some(CharRef {
+            name: "uml;",
+            characters: "\u{178}",
+        });
+    }
+
+    if first_char == 'Z' && try_read("Hcy;") {
+        return Some(CharRef {
+            name: "Hcy;",
+            characters: "\u{416}",
+        });
+    }
+
+    if first_char == 'Z' && try_read("dot;") {
+        return Some(CharRef {
+            name: "dot;",
+            characters: "\u{17b}",
+        });
+    }
+
+    if first_char == 'Z' && try_read("eta;") {
+        return Some(CharRef {
+            name: "eta;",
+            characters: "\u{396}",
+        });
+    }
+
+    if first_char == 'Z' && try_read("opf;") {
+        return Some(CharRef {
+            name: "opf;",
+            characters: "\u{2124}",
+        });
+    }
+
+    if first_char == 'Z' && try_read("scr;") {
+        return Some(CharRef {
+            name: "scr;",
+            characters: "\u{1d4b5}",
+        });
+    }
+
+    if first_char == 'a' && try_read("circ") {
+        return Some(CharRef {
+            name: "circ",
+            characters: "\u{e2}",
+        });
+    }
+
+    if first_char == 'a' && try_read("cute") {
+        return Some(CharRef {
+            name: "cute",
+            characters: "\u{b4}",
+        });
+    }
+
+    if first_char == 'a' && try_read("elig") {
+        return Some(CharRef {
+            name: "elig",
+            characters: "\u{e6}",
+        });
+    }
+
+    if first_char == 'a' && try_read("ndd;") {
+        return Some(CharRef {
+            name: "ndd;",
+            characters: "\u{2a5c}",
+        });
+    }
+
+    if first_char == 'a' && try_read("ndv;") {
+        return Some(CharRef {
+            name: "ndv;",
+            characters: "\u{2a5a}",
+        });
+    }
+
+    if first_char == 'a' && try_read("nge;") {
+        return Some(CharRef {
+            name: "nge;",
+            characters: "\u{29a4}",
+        });
+    }
+
+    if first_char == 'a' && try_read("opf;") {
+        return Some(CharRef {
+            name: "opf;",
+            characters: "\u{1d552}",
+        });
+    }
+
+    if first_char == 'a' && try_read("pid;") {
+        return Some(CharRef {
+            name: "pid;",
+            characters: "\u{224b}",
+        });
+    }
+
+    if first_char == 'a' && try_read("pos;") {
+        return Some(CharRef {
+            name: "pos;",
+            characters: "\u{27}",
+        });
+    }
+
+    if first_char == 'a' && try_read("ring") {
+        return Some(CharRef {
+            name: "ring",
+            characters: "\u{e5}",
+        });
+    }
+
+    if first_char == 'a' && try_read("scr;") {
+        return Some(CharRef {
+            name: "scr;",
+            characters: "\u{1d4b6}",
+        });
+    }
+
+    if first_char == 'a' && try_read("uml;") {
+        return Some(CharRef {
+            name: "uml;",
+            characters: "\u{e4}",
+        });
+    }
+
+    if first_char == 'b' && try_read("Not;") {
+        return Some(CharRef {
+            name: "Not;",
+            characters: "\u{2aed}",
+        });
+    }
+
+    if first_char == 'b' && try_read("brk;") {
+        return Some(CharRef {
+            name: "brk;",
+            characters: "\u{23b5}",
+        });
+    }
+
+    if first_char == 'b' && try_read("eta;") {
+        return Some(CharRef {
+            name: "eta;",
+            characters: "\u{3b2}",
+        });
+    }
+
+    if first_char == 'b' && try_read("eth;") {
+        return Some(CharRef {
+            name: "eth;",
+            characters: "\u{2136}",
+        });
+    }
+
+    if first_char == 'b' && try_read("not;") {
+        return Some(CharRef {
+            name: "not;",
+            characters: "\u{2310}",
+        });
+    }
+
+    if first_char == 'b' && try_read("opf;") {
+        return Some(CharRef {
+            name: "opf;",
+            characters: "\u{1d553}",
+        });
+    }
+
+    if first_char == 'b' && try_read("oxH;") {
+        return Some(CharRef {
+            name: "oxH;",
+            characters: "\u{2550}",
+        });
+    }
+
+    if first_char == 'b' && try_read("oxV;") {
+        return Some(CharRef {
+            name: "oxV;",
+            characters: "\u{2551}",
+        });
+    }
+
+    if first_char == 'b' && try_read("oxh;") {
+        return Some(CharRef {
+            name: "oxh;",
+            characters: "\u{2500}",
+        });
+    }
+
+    if first_char == 'b' && try_read("oxv;") {
+        return Some(CharRef {
+            name: "oxv;",
+            characters: "\u{2502}",
+        });
+    }
+
+    if first_char == 'b' && try_read("scr;") {
+        return Some(CharRef {
+            name: "scr;",
+            characters: "\u{1d4b7}",
+        });
+    }
+
+    if first_char == 'b' && try_read("sim;") {
+        return Some(CharRef {
+            name: "sim;",
+            characters: "\u{223d}",
+        });
+    }
+
+    if first_char == 'b' && try_read("sol;") {
+        return Some(CharRef {
+            name: "sol;",
+            characters: "\u{5c}",
+        });
+    }
+
+    if first_char == 'b' && try_read("ull;") {
+        return Some(CharRef {
+            name: "ull;",
+            characters: "\u{2022}",
+        });
+    }
+
+    if first_char == 'b' && try_read("ump;") {
+        return Some(CharRef {
+            name: "ump;",
+            characters: "\u{224e}",
+        });
+    }
+
+    if first_char == 'c' && try_read("aps;") {
+        return Some(CharRef {
+            name: "aps;",
+            characters: "\u{2229}\u{fe00}",
+        });
+    }
+
+    if first_char == 'c' && try_read("dot;") {
+        return Some(CharRef {
+            name: "dot;",
+            characters: "\u{10b}",
+        });
+    }
+
+    if first_char == 'c' && try_read("edil") {
+        return Some(CharRef {
+            name: "edil",
+            characters: "\u{b8}",
+        });
+    }
+
+    if first_char == 'c' && try_read("ent;") {
+        return Some(CharRef {
+            name: "ent;",
+            characters: "\u{a2}",
+        });
+    }
+
+    if first_char == 'c' && try_read("hcy;") {
+        return Some(CharRef {
+            name: "hcy;",
+            characters: "\u{447}",
+        });
+    }
+
+    if first_char == 'c' && try_read("irE;") {
+        return Some(CharRef {
+            name: "irE;",
+            characters: "\u{29c3}",
+        });
+    }
+
+    if first_char == 'c' && try_read("irc;") {
+        return Some(CharRef {
+            name: "irc;",
+            characters: "\u{2c6}",
+        });
+    }
+
+    if first_char == 'c' && try_read("ire;") {
+        return Some(CharRef {
+            name: "ire;",
+            characters: "\u{2257}",
+        });
+    }
+
+    if first_char == 'c' && try_read("omp;") {
+        return Some(CharRef {
+            name: "omp;",
+            characters: "\u{2201}",
+        });
+    }
+
+    if first_char == 'c' && try_read("ong;") {
+        return Some(CharRef {
+            name: "ong;",
+            characters: "\u{2245}",
+        });
+    }
+
+    if first_char == 'c' && try_read("opf;") {
+        return Some(CharRef {
+            name: "opf;",
+            characters: "\u{1d554}",
+        });
+    }
+
+    if first_char == 'c' && try_read("opy;") {
+        return Some(CharRef {
+            name: "opy;",
+            characters: "\u{a9}",
+        });
+    }
+
+    if first_char == 'c' && try_read("scr;") {
+        return Some(CharRef {
+            name: "scr;",
+            characters: "\u{1d4b8}",
+        });
+    }
+
+    if first_char == 'c' && try_read("sub;") {
+        return Some(CharRef {
+            name: "sub;",
+            characters: "\u{2acf}",
+        });
+    }
+
+    if first_char == 'c' && try_read("sup;") {
+        return Some(CharRef {
+            name: "sup;",
+            characters: "\u{2ad0}",
+        });
+    }
+
+    if first_char == 'c' && try_read("ups;") {
+        return Some(CharRef {
+            name: "ups;",
+            characters: "\u{222a}\u{fe00}",
+        });
+    }
+
+    if first_char == 'd' && try_read("Arr;") {
+        return Some(CharRef {
+            name: "Arr;",
+            characters: "\u{21d3}",
+        });
+    }
+
+    if first_char == 'd' && try_read("Har;") {
+        return Some(CharRef {
+            name: "Har;",
+            characters: "\u{2965}",
+        });
+    }
+
+    if first_char == 'd' && try_read("arr;") {
+        return Some(CharRef {
+            name: "arr;",
+            characters: "\u{2193}",
+        });
+    }
+
+    if first_char == 'd' && try_read("ash;") {
+        return Some(CharRef {
+            name: "ash;",
+            characters: "\u{2010}",
+        });
+    }
+
+    if first_char == 'd' && try_read("iam;") {
+        return Some(CharRef {
+            name: "iam;",
+            characters: "\u{22c4}",
+        });
+    }
+
+    if first_char == 'd' && try_read("jcy;") {
+        return Some(CharRef {
+            name: "jcy;",
+            characters: "\u{452}",
+        });
+    }
+
+    if first_char == 'd' && try_read("opf;") {
+        return Some(CharRef {
+            name: "opf;",
+            characters: "\u{1d555}",
+        });
+    }
+
+    if first_char == 'd' && try_read("scr;") {
+        return Some(CharRef {
+            name: "scr;",
+            characters: "\u{1d4b9}",
+        });
+    }
+
+    if first_char == 'd' && try_read("scy;") {
+        return Some(CharRef {
+            name: "scy;",
+            characters: "\u{455}",
+        });
+    }
+
+    if first_char == 'd' && try_read("sol;") {
+        return Some(CharRef {
+            name: "sol;",
+            characters: "\u{29f6}",
+        });
+    }
+
+    if first_char == 'd' && try_read("tri;") {
+        return Some(CharRef {
+            name: "tri;",
+            characters: "\u{25bf}",
+        });
+    }
+
+    if first_char == 'd' && try_read("zcy;") {
+        return Some(CharRef {
+            name: "zcy;",
+            characters: "\u{45f}",
+        });
+    }
+
+    if first_char == 'e' && try_read("Dot;") {
+        return Some(CharRef {
+            name: "Dot;",
+            characters: "\u{2251}",
+        });
+    }
+
+    if first_char == 'e' && try_read("cir;") {
+        return Some(CharRef {
+            name: "cir;",
+            characters: "\u{2256}",
+        });
+    }
+
+    if first_char == 'e' && try_read("circ") {
+        return Some(CharRef {
+            name: "circ",
+            characters: "\u{ea}",
+        });
+    }
+
+    if first_char == 'e' && try_read("dot;") {
+        return Some(CharRef {
+            name: "dot;",
+            characters: "\u{117}",
+        });
+    }
+
+    if first_char == 'e' && try_read("msp;") {
+        return Some(CharRef {
+            name: "msp;",
+            characters: "\u{2003}",
+        });
+    }
+
+    if first_char == 'e' && try_read("nsp;") {
+        return Some(CharRef {
+            name: "nsp;",
+            characters: "\u{2002}",
+        });
+    }
+
+    if first_char == 'e' && try_read("opf;") {
+        return Some(CharRef {
+            name: "opf;",
+            characters: "\u{1d556}",
+        });
+    }
+
+    if first_char == 'e' && try_read("par;") {
+        return Some(CharRef {
+            name: "par;",
+            characters: "\u{22d5}",
+        });
+    }
+
+    if first_char == 'e' && try_read("psi;") {
+        return Some(CharRef {
+            name: "psi;",
+            characters: "\u{3b5}",
+        });
+    }
+
+    if first_char == 'e' && try_read("scr;") {
+        return Some(CharRef {
+            name: "scr;",
+            characters: "\u{212f}",
+        });
+    }
+
+    if first_char == 'e' && try_read("sim;") {
+        return Some(CharRef {
+            name: "sim;",
+            characters: "\u{2242}",
+        });
+    }
+
+    if first_char == 'e' && try_read("uml;") {
+        return Some(CharRef {
+            name: "uml;",
+            characters: "\u{eb}",
+        });
+    }
+
+    if first_char == 'e' && try_read("uro;") {
+        return Some(CharRef {
+            name: "uro;",
+            characters: "\u{20ac}",
+        });
+    }
+
+    if first_char == 'e' && try_read("xcl;") {
+        return Some(CharRef {
+            name: "xcl;",
+            characters: "\u{21}",
+        });
+    }
+
+    if first_char == 'f' && try_read("lat;") {
+        return Some(CharRef {
+            name: "lat;",
+            characters: "\u{266d}",
+        });
+    }
+
+    if first_char == 'f' && try_read("nof;") {
+        return Some(CharRef {
+            name: "nof;",
+            characters: "\u{192}",
+        });
+    }
+
+    if first_char == 'f' && try_read("opf;") {
+        return Some(CharRef {
+            name: "opf;",
+            characters: "\u{1d557}",
+        });
+    }
+
+    if first_char == 'f' && try_read("ork;") {
+        return Some(CharRef {
+            name: "ork;",
+            characters: "\u{22d4}",
+        });
+    }
+
+    if first_char == 'f' && try_read("scr;") {
+        return Some(CharRef {
+            name: "scr;",
+            characters: "\u{1d4bb}",
+        });
+    }
+
+    if first_char == 'g' && try_read("dot;") {
+        return Some(CharRef {
+            name: "dot;",
+            characters: "\u{121}",
+        });
+    }
+
+    if first_char == 'g' && try_read("eqq;") {
+        return Some(CharRef {
+            name: "eqq;",
+            characters: "\u{2267}",
+        });
+    }
+
+    if first_char == 'g' && try_read("esl;") {
+        return Some(CharRef {
+            name: "esl;",
+            characters: "\u{22db}\u{fe00}",
+        });
+    }
+
+    if first_char == 'g' && try_read("jcy;") {
+        return Some(CharRef {
+            name: "jcy;",
+            characters: "\u{453}",
+        });
+    }
+
+    if first_char == 'g' && try_read("nap;") {
+        return Some(CharRef {
+            name: "nap;",
+            characters: "\u{2a8a}",
+        });
+    }
+
+    if first_char == 'g' && try_read("neq;") {
+        return Some(CharRef {
+            name: "neq;",
+            characters: "\u{2a88}",
+        });
+    }
+
+    if first_char == 'g' && try_read("opf;") {
+        return Some(CharRef {
+            name: "opf;",
+            characters: "\u{1d558}",
+        });
+    }
+
+    if first_char == 'g' && try_read("scr;") {
+        return Some(CharRef {
+            name: "scr;",
+            characters: "\u{210a}",
+        });
+    }
+
+    if first_char == 'g' && try_read("sim;") {
+        return Some(CharRef {
+            name: "sim;",
+            characters: "\u{2273}",
+        });
+    }
+
+    if first_char == 'g' && try_read("tcc;") {
+        return Some(CharRef {
+            name: "tcc;",
+            characters: "\u{2aa7}",
+        });
+    }
+
+    if first_char == 'g' && try_read("vnE;") {
+        return Some(CharRef {
+            name: "vnE;",
+            characters: "\u{2269}\u{fe00}",
+        });
+    }
+
+    if first_char == 'h' && try_read("Arr;") {
+        return Some(CharRef {
+            name: "Arr;",
+            characters: "\u{21d4}",
+        });
+    }
+
+    if first_char == 'h' && try_read("alf;") {
+        return Some(CharRef {
+            name: "alf;",
+            characters: "\u{bd}",
+        });
+    }
+
+    if first_char == 'h' && try_read("arr;") {
+        return Some(CharRef {
+            name: "arr;",
+            characters: "\u{2194}",
+        });
+    }
+
+    if first_char == 'h' && try_read("bar;") {
+        return Some(CharRef {
+            name: "bar;",
+            characters: "\u{210f}",
+        });
+    }
+
+    if first_char == 'h' && try_read("opf;") {
+        return Some(CharRef {
+            name: "opf;",
+            characters: "\u{1d559}",
+        });
+    }
+
+    if first_char == 'h' && try_read("scr;") {
+        return Some(CharRef {
+            name: "scr;",
+            characters: "\u{1d4bd}",
+        });
+    }
+
+    if first_char == 'i' && try_read("circ") {
+        return Some(CharRef {
+            name: "circ",
+            characters: "\u{ee}",
+        });
+    }
+
+    if first_char == 'i' && try_read("ecy;") {
+        return Some(CharRef {
+            name: "ecy;",
+            characters: "\u{435}",
+        });
+    }
+
+    if first_char == 'i' && try_read("excl") {
+        return Some(CharRef {
+            name: "excl",
+            characters: "\u{a1}",
+        });
+    }
+
+    if first_char == 'i' && try_read("mof;") {
+        return Some(CharRef {
+            name: "mof;",
+            characters: "\u{22b7}",
+        });
+    }
+
+    if first_char == 'i' && try_read("ocy;") {
+        return Some(CharRef {
+            name: "ocy;",
+            characters: "\u{451}",
+        });
+    }
+
+    if first_char == 'i' && try_read("opf;") {
+        return Some(CharRef {
+            name: "opf;",
+            characters: "\u{1d55a}",
+        });
+    }
+
+    if first_char == 'i' && try_read("ota;") {
+        return Some(CharRef {
+            name: "ota;",
+            characters: "\u{3b9}",
+        });
+    }
+
+    if first_char == 'i' && try_read("scr;") {
+        return Some(CharRef {
+            name: "scr;",
+            characters: "\u{1d4be}",
+        });
+    }
+
+    if first_char == 'i' && try_read("sin;") {
+        return Some(CharRef {
+            name: "sin;",
+            characters: "\u{2208}",
+        });
+    }
+
+    if first_char == 'i' && try_read("uml;") {
+        return Some(CharRef {
+            name: "uml;",
+            characters: "\u{ef}",
+        });
+    }
+
+    if first_char == 'j' && try_read("opf;") {
+        return Some(CharRef {
+            name: "opf;",
+            characters: "\u{1d55b}",
+        });
+    }
+
+    if first_char == 'j' && try_read("scr;") {
+        return Some(CharRef {
+            name: "scr;",
+            characters: "\u{1d4bf}",
+        });
+    }
+
+    if first_char == 'k' && try_read("hcy;") {
+        return Some(CharRef {
+            name: "hcy;",
+            characters: "\u{445}",
+        });
+    }
+
+    if first_char == 'k' && try_read("jcy;") {
+        return Some(CharRef {
+            name: "jcy;",
+            characters: "\u{45c}",
+        });
+    }
+
+    if first_char == 'k' && try_read("opf;") {
+        return Some(CharRef {
+            name: "opf;",
+            characters: "\u{1d55c}",
+        });
+    }
+
+    if first_char == 'k' && try_read("scr;") {
+        return Some(CharRef {
+            name: "scr;",
+            characters: "\u{1d4c0}",
+        });
+    }
+
+    if first_char == 'l' && try_read("Arr;") {
+        return Some(CharRef {
+            name: "Arr;",
+            characters: "\u{21d0}",
+        });
+    }
+
+    if first_char == 'l' && try_read("Har;") {
+        return Some(CharRef {
+            name: "Har;",
+            characters: "\u{2962}",
+        });
+    }
+
+    if first_char == 'l' && try_read("ang;") {
+        return Some(CharRef {
+            name: "ang;",
+            characters: "\u{27e8}",
+        });
+    }
+
+    if first_char == 'l' && try_read("aquo") {
+        return Some(CharRef {
+            name: "aquo",
+            characters: "\u{ab}",
+        });
+    }
+
+    if first_char == 'l' && try_read("arr;") {
+        return Some(CharRef {
+            name: "arr;",
+            characters: "\u{2190}",
+        });
+    }
+
+    if first_char == 'l' && try_read("ate;") {
+        return Some(CharRef {
+            name: "ate;",
+            characters: "\u{2aad}",
+        });
+    }
+
+    if first_char == 'l' && try_read("cub;") {
+        return Some(CharRef {
+            name: "cub;",
+            characters: "\u{7b}",
+        });
+    }
+
+    if first_char == 'l' && try_read("dca;") {
+        return Some(CharRef {
+            name: "dca;",
+            characters: "\u{2936}",
+        });
+    }
+
+    if first_char == 'l' && try_read("dsh;") {
+        return Some(CharRef {
+            name: "dsh;",
+            characters: "\u{21b2}",
+        });
+    }
+
+    if first_char == 'l' && try_read("eqq;") {
+        return Some(CharRef {
+            name: "eqq;",
+            characters: "\u{2266}",
+        });
+    }
+
+    if first_char == 'l' && try_read("esg;") {
+        return Some(CharRef {
+            name: "esg;",
+            characters: "\u{22da}\u{fe00}",
+        });
+    }
+
+    if first_char == 'l' && try_read("jcy;") {
+        return Some(CharRef {
+            name: "jcy;",
+            characters: "\u{459}",
+        });
+    }
+
+    if first_char == 'l' && try_read("nap;") {
+        return Some(CharRef {
+            name: "nap;",
+            characters: "\u{2a89}",
+        });
+    }
+
+    if first_char == 'l' && try_read("neq;") {
+        return Some(CharRef {
+            name: "neq;",
+            characters: "\u{2a87}",
+        });
+    }
+
+    if first_char == 'l' && try_read("opf;") {
+        return Some(CharRef {
+            name: "opf;",
+            characters: "\u{1d55d}",
+        });
+    }
+
+    if first_char == 'l' && try_read("ozf;") {
+        return Some(CharRef {
+            name: "ozf;",
+            characters: "\u{29eb}",
+        });
+    }
+
+    if first_char == 'l' && try_read("par;") {
+        return Some(CharRef {
+            name: "par;",
+            characters: "\u{28}",
+        });
+    }
+
+    if first_char == 'l' && try_read("scr;") {
+        return Some(CharRef {
+            name: "scr;",
+            characters: "\u{1d4c1}",
+        });
+    }
+
+    if first_char == 'l' && try_read("sim;") {
+        return Some(CharRef {
+            name: "sim;",
+            characters: "\u{2272}",
+        });
+    }
+
+    if first_char == 'l' && try_read("sqb;") {
+        return Some(CharRef {
+            name: "sqb;",
+            characters: "\u{5b}",
+        });
+    }
+
+    if first_char == 'l' && try_read("tcc;") {
+        return Some(CharRef {
+            name: "tcc;",
+            characters: "\u{2aa6}",
+        });
+    }
+
+    if first_char == 'l' && try_read("tri;") {
+        return Some(CharRef {
+            name: "tri;",
+            characters: "\u{25c3}",
+        });
+    }
+
+    if first_char == 'l' && try_read("vnE;") {
+        return Some(CharRef {
+            name: "vnE;",
+            characters: "\u{2268}\u{fe00}",
+        });
+    }
+
+    if first_char == 'm' && try_read("acr;") {
+        return Some(CharRef {
+            name: "acr;",
+            characters: "\u{af}",
+        });
+    }
+
+    if first_char == 'm' && try_read("ale;") {
+        return Some(CharRef {
+            name: "ale;",
+            characters: "\u{2642}",
+        });
+    }
+
+    if first_char == 'm' && try_read("alt;") {
+        return Some(CharRef {
+            name: "alt;",
+            characters: "\u{2720}",
+        });
+    }
+
+    if first_char == 'm' && try_read("icro") {
+        return Some(CharRef {
+            name: "icro",
+            characters: "\u{b5}",
+        });
+    }
+
+    if first_char == 'm' && try_read("lcp;") {
+        return Some(CharRef {
+            name: "lcp;",
+            characters: "\u{2adb}",
+        });
+    }
+
+    if first_char == 'm' && try_read("ldr;") {
+        return Some(CharRef {
+            name: "ldr;",
+            characters: "\u{2026}",
+        });
+    }
+
+    if first_char == 'm' && try_read("opf;") {
+        return Some(CharRef {
+            name: "opf;",
+            characters: "\u{1d55e}",
+        });
+    }
+
+    if first_char == 'm' && try_read("scr;") {
+        return Some(CharRef {
+            name: "scr;",
+            characters: "\u{1d4c2}",
+        });
+    }
+
+    if first_char == 'n' && try_read("Gtv;") {
+        return Some(CharRef {
+            name: "Gtv;",
+            characters: "\u{226b}\u{338}",
+        });
+    }
+
+    if first_char == 'n' && try_read("Ltv;") {
+        return Some(CharRef {
+            name: "Ltv;",
+            characters: "\u{226a}\u{338}",
+        });
+    }
+
+    if first_char == 'n' && try_read("ang;") {
+        return Some(CharRef {
+            name: "ang;",
+            characters: "\u{2220}\u{20d2}",
+        });
+    }
+
+    if first_char == 'n' && try_read("apE;") {
+        return Some(CharRef {
+            name: "apE;",
+            characters: "\u{2a70}\u{338}",
+        });
+    }
+
+    if first_char == 'n' && try_read("bsp;") {
+        return Some(CharRef {
+            name: "bsp;",
+            characters: "\u{a0}",
+        });
+    }
+
+    if first_char == 'n' && try_read("cap;") {
+        return Some(CharRef {
+            name: "cap;",
+            characters: "\u{2a43}",
+        });
+    }
+
+    if first_char == 'n' && try_read("cup;") {
+        return Some(CharRef {
+            name: "cup;",
+            characters: "\u{2a42}",
+        });
+    }
+
+    if first_char == 'n' && try_read("geq;") {
+        return Some(CharRef {
+            name: "geq;",
+            characters: "\u{2271}",
+        });
+    }
+
+    if first_char == 'n' && try_read("ges;") {
+        return Some(CharRef {
+            name: "ges;",
+            characters: "\u{2a7e}\u{338}",
+        });
+    }
+
+    if first_char == 'n' && try_read("gtr;") {
+        return Some(CharRef {
+            name: "gtr;",
+            characters: "\u{226f}",
+        });
+    }
+
+    if first_char == 'n' && try_read("isd;") {
+        return Some(CharRef {
+            name: "isd;",
+            characters: "\u{22fa}",
+        });
+    }
+
+    if first_char == 'n' && try_read("jcy;") {
+        return Some(CharRef {
+            name: "jcy;",
+            characters: "\u{45a}",
+        });
+    }
+
+    if first_char == 'n' && try_read("ldr;") {
+        return Some(CharRef {
+            name: "ldr;",
+            characters: "\u{2025}",
+        });
+    }
+
+    if first_char == 'n' && try_read("leq;") {
+        return Some(CharRef {
+            name: "leq;",
+            characters: "\u{2270}",
+        });
+    }
+
+    if first_char == 'n' && try_read("les;") {
+        return Some(CharRef {
+            name: "les;",
+            characters: "\u{2a7d}\u{338}",
+        });
+    }
+
+    if first_char == 'n' && try_read("mid;") {
+        return Some(CharRef {
+            name: "mid;",
+            characters: "\u{2224}",
+        });
+    }
+
+    if first_char == 'n' && try_read("opf;") {
+        return Some(CharRef {
+            name: "opf;",
+            characters: "\u{1d55f}",
+        });
+    }
+
+    if first_char == 'n' && try_read("par;") {
+        return Some(CharRef {
+            name: "par;",
+            characters: "\u{2226}",
+        });
+    }
+
+    if first_char == 'n' && try_read("pre;") {
+        return Some(CharRef {
+            name: "pre;",
+            characters: "\u{2aaf}\u{338}",
+        });
+    }
+
+    if first_char == 'n' && try_read("sce;") {
+        return Some(CharRef {
+            name: "sce;",
+            characters: "\u{2ab0}\u{338}",
+        });
+    }
+
+    if first_char == 'n' && try_read("scr;") {
+        return Some(CharRef {
+            name: "scr;",
+            characters: "\u{1d4c3}",
+        });
+    }
+
+    if first_char == 'n' && try_read("sim;") {
+        return Some(CharRef {
+            name: "sim;",
+            characters: "\u{2241}",
+        });
+    }
+
+    if first_char == 'n' && try_read("sub;") {
+        return Some(CharRef {
+            name: "sub;",
+            characters: "\u{2284}",
+        });
+    }
+
+    if first_char == 'n' && try_read("sup;") {
+        return Some(CharRef {
+            name: "sup;",
+            characters: "\u{2285}",
+        });
+    }
+
+    if first_char == 'n' && try_read("tgl;") {
+        return Some(CharRef {
+            name: "tgl;",
+            characters: "\u{2279}",
+        });
+    }
+
+    if first_char == 'n' && try_read("tlg;") {
+        return Some(CharRef {
+            name: "tlg;",
+            characters: "\u{2278}",
+        });
+    }
+
+    if first_char == 'n' && try_read("vap;") {
+        return Some(CharRef {
+            name: "vap;",
+            characters: "\u{224d}\u{20d2}",
+        });
+    }
+
+    if first_char == 'n' && try_read("vge;") {
+        return Some(CharRef {
+            name: "vge;",
+            characters: "\u{2265}\u{20d2}",
+        });
+    }
+
+    if first_char == 'n' && try_read("vgt;") {
+        return Some(CharRef {
+            name: "vgt;",
+            characters: "\u{3e}\u{20d2}",
+        });
+    }
+
+    if first_char == 'n' && try_read("vle;") {
+        return Some(CharRef {
+            name: "vle;",
+            characters: "\u{2264}\u{20d2}",
+        });
+    }
+
+    if first_char == 'n' && try_read("vlt;") {
+        return Some(CharRef {
+            name: "vlt;",
+            characters: "\u{3c}\u{20d2}",
+        });
+    }
+
+    if first_char == 'o' && try_read("ast;") {
+        return Some(CharRef {
+            name: "ast;",
+            characters: "\u{229b}",
+        });
+    }
+
+    if first_char == 'o' && try_read("cir;") {
+        return Some(CharRef {
+            name: "cir;",
+            characters: "\u{229a}",
+        });
+    }
+
+    if first_char == 'o' && try_read("circ") {
+        return Some(CharRef {
+            name: "circ",
+            characters: "\u{f4}",
+        });
+    }
+
+    if first_char == 'o' && try_read("div;") {
+        return Some(CharRef {
+            name: "div;",
+            characters: "\u{2a38}",
+        });
+    }
+
+    if first_char == 'o' && try_read("dot;") {
+        return Some(CharRef {
+            name: "dot;",
+            characters: "\u{2299}",
+        });
+    }
+
+    if first_char == 'o' && try_read("gon;") {
+        return Some(CharRef {
+            name: "gon;",
+            characters: "\u{2db}",
+        });
+    }
+
+    if first_char == 'o' && try_read("int;") {
+        return Some(CharRef {
+            name: "int;",
+            characters: "\u{222e}",
+        });
+    }
+
+    if first_char == 'o' && try_read("mid;") {
+        return Some(CharRef {
+            name: "mid;",
+            characters: "\u{29b6}",
+        });
+    }
+
+    if first_char == 'o' && try_read("opf;") {
+        return Some(CharRef {
+            name: "opf;",
+            characters: "\u{1d560}",
+        });
+    }
+
+    if first_char == 'o' && try_read("par;") {
+        return Some(CharRef {
+            name: "par;",
+            characters: "\u{29b7}",
+        });
+    }
+
+    if first_char == 'o' && try_read("rdf;") {
+        return Some(CharRef {
+            name: "rdf;",
+            characters: "\u{aa}",
+        });
+    }
+
+    if first_char == 'o' && try_read("rdm;") {
+        return Some(CharRef {
+            name: "rdm;",
+            characters: "\u{ba}",
+        });
+    }
+
+    if first_char == 'o' && try_read("ror;") {
+        return Some(CharRef {
+            name: "ror;",
+            characters: "\u{2a56}",
+        });
+    }
+
+    if first_char == 'o' && try_read("scr;") {
+        return Some(CharRef {
+            name: "scr;",
+            characters: "\u{2134}",
+        });
+    }
+
+    if first_char == 'o' && try_read("sol;") {
+        return Some(CharRef {
+            name: "sol;",
+            characters: "\u{2298}",
+        });
+    }
+
+    if first_char == 'o' && try_read("uml;") {
+        return Some(CharRef {
+            name: "uml;",
+            characters: "\u{f6}",
+        });
+    }
+
+    if first_char == 'p' && try_read("ara;") {
+        return Some(CharRef {
+            name: "ara;",
+            characters: "\u{b6}",
+        });
+    }
+
+    if first_char == 'p' && try_read("art;") {
+        return Some(CharRef {
+            name: "art;",
+            characters: "\u{2202}",
+        });
+    }
+
+    if first_char == 'p' && try_read("erp;") {
+        return Some(CharRef {
+            name: "erp;",
+            characters: "\u{22a5}",
+        });
+    }
+
+    if first_char == 'p' && try_read("hiv;") {
+        return Some(CharRef {
+            name: "hiv;",
+            characters: "\u{3d5}",
+        });
+    }
+
+    if first_char == 'p' && try_read("lus;") {
+        return Some(CharRef {
+            name: "lus;",
+            characters: "\u{2b}",
+        });
+    }
+
+    if first_char == 'p' && try_read("opf;") {
+        return Some(CharRef {
+            name: "opf;",
+            characters: "\u{1d561}",
+        });
+    }
+
+    if first_char == 'p' && try_read("ound") {
+        return Some(CharRef {
+            name: "ound",
+            characters: "\u{a3}",
+        });
+    }
+
+    if first_char == 'p' && try_read("rap;") {
+        return Some(CharRef {
+            name: "rap;",
+            characters: "\u{2ab7}",
+        });
+    }
+
+    if first_char == 'p' && try_read("rec;") {
+        return Some(CharRef {
+            name: "rec;",
+            characters: "\u{227a}",
+        });
+    }
+
+    if first_char == 'p' && try_read("rnE;") {
+        return Some(CharRef {
+            name: "rnE;",
+            characters: "\u{2ab5}",
+        });
+    }
+
+    if first_char == 'p' && try_read("rod;") {
+        return Some(CharRef {
+            name: "rod;",
+            characters: "\u{220f}",
+        });
+    }
+
+    if first_char == 'p' && try_read("rop;") {
+        return Some(CharRef {
+            name: "rop;",
+            characters: "\u{221d}",
+        });
+    }
+
+    if first_char == 'p' && try_read("scr;") {
+        return Some(CharRef {
+            name: "scr;",
+            characters: "\u{1d4c5}",
+        });
+    }
+
+    if first_char == 'q' && try_read("int;") {
+        return Some(CharRef {
+            name: "int;",
+            characters: "\u{2a0c}",
+        });
+    }
+
+    if first_char == 'q' && try_read("opf;") {
+        return Some(CharRef {
+            name: "opf;",
+            characters: "\u{1d562}",
+        });
+    }
+
+    if first_char == 'q' && try_read("scr;") {
+        return Some(CharRef {
+            name: "scr;",
+            characters: "\u{1d4c6}",
+        });
+    }
+
+    if first_char == 'q' && try_read("uot;") {
+        return Some(CharRef {
+            name: "uot;",
+            characters: "\u{22}",
+        });
+    }
+
+    if first_char == 'r' && try_read("Arr;") {
+        return Some(CharRef {
+            name: "Arr;",
+            characters: "\u{21d2}",
+        });
+    }
+
+    if first_char == 'r' && try_read("Har;") {
+        return Some(CharRef {
+            name: "Har;",
+            characters: "\u{2964}",
+        });
+    }
+
+    if first_char == 'r' && try_read("ace;") {
+        return Some(CharRef {
+            name: "ace;",
+            characters: "\u{223d}\u{331}",
+        });
+    }
+
+    if first_char == 'r' && try_read("ang;") {
+        return Some(CharRef {
+            name: "ang;",
+            characters: "\u{27e9}",
+        });
+    }
+
+    if first_char == 'r' && try_read("aquo") {
+        return Some(CharRef {
+            name: "aquo",
+            characters: "\u{bb}",
+        });
+    }
+
+    if first_char == 'r' && try_read("arr;") {
+        return Some(CharRef {
+            name: "arr;",
+            characters: "\u{2192}",
+        });
+    }
+
+    if first_char == 'r' && try_read("cub;") {
+        return Some(CharRef {
+            name: "cub;",
+            characters: "\u{7d}",
+        });
+    }
+
+    if first_char == 'r' && try_read("dca;") {
+        return Some(CharRef {
+            name: "dca;",
+            characters: "\u{2937}",
+        });
+    }
+
+    if first_char == 'r' && try_read("dsh;") {
+        return Some(CharRef {
+            name: "dsh;",
+            characters: "\u{21b3}",
+        });
+    }
+
+    if first_char == 'r' && try_read("eal;") {
+        return Some(CharRef {
+            name: "eal;",
+            characters: "\u{211c}",
+        });
+    }
+
+    if first_char == 'r' && try_read("ect;") {
+        return Some(CharRef {
+            name: "ect;",
+            characters: "\u{25ad}",
+        });
+    }
+
+    if first_char == 'r' && try_read("hov;") {
+        return Some(CharRef {
+            name: "hov;",
+            characters: "\u{3f1}",
+        });
+    }
+
+    if first_char == 'r' && try_read("ing;") {
+        return Some(CharRef {
+            name: "ing;",
+            characters: "\u{2da}",
+        });
+    }
+
+    if first_char == 'r' && try_read("opf;") {
+        return Some(CharRef {
+            name: "opf;",
+            characters: "\u{1d563}",
+        });
+    }
+
+    if first_char == 'r' && try_read("par;") {
+        return Some(CharRef {
+            name: "par;",
+            characters: "\u{29}",
+        });
+    }
+
+    if first_char == 'r' && try_read("scr;") {
+        return Some(CharRef {
+            name: "scr;",
+            characters: "\u{1d4c7}",
+        });
+    }
+
+    if first_char == 'r' && try_read("sqb;") {
+        return Some(CharRef {
+            name: "sqb;",
+            characters: "\u{5d}",
+        });
+    }
+
+    if first_char == 'r' && try_read("tri;") {
+        return Some(CharRef {
+            name: "tri;",
+            characters: "\u{25b9}",
+        });
+    }
+
+    if first_char == 's' && try_read("cap;") {
+        return Some(CharRef {
+            name: "cap;",
+            characters: "\u{2ab8}",
+        });
+    }
+
+    if first_char == 's' && try_read("cnE;") {
+        return Some(CharRef {
+            name: "cnE;",
+            characters: "\u{2ab6}",
+        });
+    }
+
+    if first_char == 's' && try_read("dot;") {
+        return Some(CharRef {
+            name: "dot;",
+            characters: "\u{22c5}",
+        });
+    }
+
+    if first_char == 's' && try_read("ect;") {
+        return Some(CharRef {
+            name: "ect;",
+            characters: "\u{a7}",
+        });
+    }
+
+    if first_char == 's' && try_read("emi;") {
+        return Some(CharRef {
+            name: "emi;",
+            characters: "\u{3b}",
+        });
+    }
+
+    if first_char == 's' && try_read("ext;") {
+        return Some(CharRef {
+            name: "ext;",
+            characters: "\u{2736}",
+        });
+    }
+
+    if first_char == 's' && try_read("hcy;") {
+        return Some(CharRef {
+            name: "hcy;",
+            characters: "\u{448}",
+        });
+    }
+
+    if first_char == 's' && try_read("ime;") {
+        return Some(CharRef {
+            name: "ime;",
+            characters: "\u{2243}",
+        });
+    }
+
+    if first_char == 's' && try_read("img;") {
+        return Some(CharRef {
+            name: "img;",
+            characters: "\u{2a9e}",
+        });
+    }
+
+    if first_char == 's' && try_read("iml;") {
+        return Some(CharRef {
+            name: "iml;",
+            characters: "\u{2a9d}",
+        });
+    }
+
+    if first_char == 's' && try_read("mid;") {
+        return Some(CharRef {
+            name: "mid;",
+            characters: "\u{2223}",
+        });
+    }
+
+    if first_char == 's' && try_read("mte;") {
+        return Some(CharRef {
+            name: "mte;",
+            characters: "\u{2aac}",
+        });
+    }
+
+    if first_char == 's' && try_read("olb;") {
+        return Some(CharRef {
+            name: "olb;",
+            characters: "\u{29c4}",
+        });
+    }
+
+    if first_char == 's' && try_read("opf;") {
+        return Some(CharRef {
+            name: "opf;",
+            characters: "\u{1d564}",
+        });
+    }
+
+    if first_char == 's' && try_read("par;") {
+        return Some(CharRef {
+            name: "par;",
+            characters: "\u{2225}",
+        });
+    }
+
+    if first_char == 's' && try_read("quf;") {
+        return Some(CharRef {
+            name: "quf;",
+            characters: "\u{25aa}",
+        });
+    }
+
+    if first_char == 's' && try_read("scr;") {
+        return Some(CharRef {
+            name: "scr;",
+            characters: "\u{1d4c8}",
+        });
+    }
+
+    if first_char == 's' && try_read("tar;") {
+        return Some(CharRef {
+            name: "tar;",
+            characters: "\u{2606}",
+        });
+    }
+
+    if first_char == 's' && try_read("ubE;") {
+        return Some(CharRef {
+            name: "ubE;",
+            characters: "\u{2ac5}",
+        });
+    }
+
+    if first_char == 's' && try_read("ube;") {
+        return Some(CharRef {
+            name: "ube;",
+            characters: "\u{2286}",
+        });
+    }
+
+    if first_char == 's' && try_read("ucc;") {
+        return Some(CharRef {
+            name: "ucc;",
+            characters: "\u{227b}",
+        });
+    }
+
+    if first_char == 's' && try_read("ung;") {
+        return Some(CharRef {
+            name: "ung;",
+            characters: "\u{266a}",
+        });
+    }
+
+    if first_char == 's' && try_read("up1;") {
+        return Some(CharRef {
+            name: "up1;",
+            characters: "\u{b9}",
+        });
+    }
+
+    if first_char == 's' && try_read("up2;") {
+        return Some(CharRef {
+            name: "up2;",
+            characters: "\u{b2}",
+        });
+    }
+
+    if first_char == 's' && try_read("up3;") {
+        return Some(CharRef {
+            name: "up3;",
+            characters: "\u{b3}",
+        });
+    }
+
+    if first_char == 's' && try_read("upE;") {
+        return Some(CharRef {
+            name: "upE;",
+            characters: "\u{2ac6}",
+        });
+    }
+
+    if first_char == 's' && try_read("upe;") {
+        return Some(CharRef {
+            name: "upe;",
+            characters: "\u{2287}",
+        });
+    }
+
+    if first_char == 's' && try_read("zlig") {
+        return Some(CharRef {
+            name: "zlig",
+            characters: "\u{df}",
+        });
+    }
+
+    if first_char == 't' && try_read("brk;") {
+        return Some(CharRef {
+            name: "brk;",
+            characters: "\u{23b4}",
+        });
+    }
+
+    if first_char == 't' && try_read("dot;") {
+        return Some(CharRef {
+            name: "dot;",
+            characters: "\u{20db}",
+        });
+    }
+
+    if first_char == 't' && try_read("horn") {
+        return Some(CharRef {
+            name: "horn",
+            characters: "\u{fe}",
+        });
+    }
+
+    if first_char == 't' && try_read("imes") {
+        return Some(CharRef {
+            name: "imes",
+            characters: "\u{d7}",
+        });
+    }
+
+    if first_char == 't' && try_read("int;") {
+        return Some(CharRef {
+            name: "int;",
+            characters: "\u{222d}",
+        });
+    }
+
+    if first_char == 't' && try_read("oea;") {
+        return Some(CharRef {
+            name: "oea;",
+            characters: "\u{2928}",
+        });
+    }
+
+    if first_char == 't' && try_read("opf;") {
+        return Some(CharRef {
+            name: "opf;",
+            characters: "\u{1d565}",
+        });
+    }
+
+    if first_char == 't' && try_read("osa;") {
+        return Some(CharRef {
+            name: "osa;",
+            characters: "\u{2929}",
+        });
+    }
+
+    if first_char == 't' && try_read("rie;") {
+        return Some(CharRef {
+            name: "rie;",
+            characters: "\u{225c}",
+        });
+    }
+
+    if first_char == 't' && try_read("scr;") {
+        return Some(CharRef {
+            name: "scr;",
+            characters: "\u{1d4c9}",
+        });
+    }
+
+    if first_char == 't' && try_read("scy;") {
+        return Some(CharRef {
+            name: "scy;",
+            characters: "\u{446}",
+        });
+    }
+
+    if first_char == 'u' && try_read("Arr;") {
+        return Some(CharRef {
+            name: "Arr;",
+            characters: "\u{21d1}",
+        });
+    }
+
+    if first_char == 'u' && try_read("Har;") {
+        return Some(CharRef {
+            name: "Har;",
+            characters: "\u{2963}",
+        });
+    }
+
+    if first_char == 'u' && try_read("arr;") {
+        return Some(CharRef {
+            name: "arr;",
+            characters: "\u{2191}",
+        });
+    }
+
+    if first_char == 'u' && try_read("circ") {
+        return Some(CharRef {
+            name: "circ",
+            characters: "\u{fb}",
+        });
+    }
+
+    if first_char == 'u' && try_read("opf;") {
+        return Some(CharRef {
+            name: "opf;",
+            characters: "\u{1d566}",
+        });
+    }
+
+    if first_char == 'u' && try_read("psi;") {
+        return Some(CharRef {
+            name: "psi;",
+            characters: "\u{3c5}",
+        });
+    }
+
+    if first_char == 'u' && try_read("scr;") {
+        return Some(CharRef {
+            name: "scr;",
+            characters: "\u{1d4ca}",
+        });
+    }
+
+    if first_char == 'u' && try_read("tri;") {
+        return Some(CharRef {
+            name: "tri;",
+            characters: "\u{25b5}",
+        });
+    }
+
+    if first_char == 'u' && try_read("uml;") {
+        return Some(CharRef {
+            name: "uml;",
+            characters: "\u{fc}",
+        });
+    }
+
+    if first_char == 'v' && try_read("Arr;") {
+        return Some(CharRef {
+            name: "Arr;",
+            characters: "\u{21d5}",
+        });
+    }
+
+    if first_char == 'v' && try_read("Bar;") {
+        return Some(CharRef {
+            name: "Bar;",
+            characters: "\u{2ae8}",
+        });
+    }
+
+    if first_char == 'v' && try_read("arr;") {
+        return Some(CharRef {
+            name: "arr;",
+            characters: "\u{2195}",
+        });
+    }
+
+    if first_char == 'v' && try_read("ert;") {
+        return Some(CharRef {
+            name: "ert;",
+            characters: "\u{7c}",
+        });
+    }
+
+    if first_char == 'v' && try_read("opf;") {
+        return Some(CharRef {
+            name: "opf;",
+            characters: "\u{1d567}",
+        });
+    }
+
+    if first_char == 'v' && try_read("scr;") {
+        return Some(CharRef {
+            name: "scr;",
+            characters: "\u{1d4cb}",
+        });
+    }
+
+    if first_char == 'w' && try_read("opf;") {
+        return Some(CharRef {
+            name: "opf;",
+            characters: "\u{1d568}",
+        });
+    }
+
+    if first_char == 'w' && try_read("scr;") {
+        return Some(CharRef {
+            name: "scr;",
+            characters: "\u{1d4cc}",
+        });
+    }
+
+    if first_char == 'x' && try_read("cap;") {
+        return Some(CharRef {
+            name: "cap;",
+            characters: "\u{22c2}",
+        });
+    }
+
+    if first_char == 'x' && try_read("cup;") {
+        return Some(CharRef {
+            name: "cup;",
+            characters: "\u{22c3}",
+        });
+    }
+
+    if first_char == 'x' && try_read("map;") {
+        return Some(CharRef {
+            name: "map;",
+            characters: "\u{27fc}",
+        });
+    }
+
+    if first_char == 'x' && try_read("nis;") {
+        return Some(CharRef {
+            name: "nis;",
+            characters: "\u{22fb}",
+        });
+    }
+
+    if first_char == 'x' && try_read("opf;") {
+        return Some(CharRef {
+            name: "opf;",
+            characters: "\u{1d569}",
+        });
+    }
+
+    if first_char == 'x' && try_read("scr;") {
+        return Some(CharRef {
+            name: "scr;",
+            characters: "\u{1d4cd}",
+        });
+    }
+
+    if first_char == 'x' && try_read("vee;") {
+        return Some(CharRef {
+            name: "vee;",
+            characters: "\u{22c1}",
+        });
+    }
+
+    if first_char == 'y' && try_read("acy;") {
+        return Some(CharRef {
+            name: "acy;",
+            characters: "\u{44f}",
+        });
+    }
+
+    if first_char == 'y' && try_read("icy;") {
+        return Some(CharRef {
+            name: "icy;",
+            characters: "\u{457}",
+        });
+    }
+
+    if first_char == 'y' && try_read("opf;") {
+        return Some(CharRef {
+            name: "opf;",
+            characters: "\u{1d56a}",
+        });
+    }
+
+    if first_char == 'y' && try_read("scr;") {
+        return Some(CharRef {
+            name: "scr;",
+            characters: "\u{1d4ce}",
+        });
+    }
+
+    if first_char == 'y' && try_read("ucy;") {
+        return Some(CharRef {
+            name: "ucy;",
+            characters: "\u{44e}",
+        });
+    }
+
+    if first_char == 'y' && try_read("uml;") {
+        return Some(CharRef {
+            name: "uml;",
+            characters: "\u{ff}",
+        });
+    }
+
+    if first_char == 'z' && try_read("dot;") {
+        return Some(CharRef {
+            name: "dot;",
+            characters: "\u{17c}",
+        });
+    }
+
+    if first_char == 'z' && try_read("eta;") {
+        return Some(CharRef {
+            name: "eta;",
+            characters: "\u{3b6}",
+        });
+    }
+
+    if first_char == 'z' && try_read("hcy;") {
+        return Some(CharRef {
+            name: "hcy;",
+            characters: "\u{436}",
+        });
+    }
+
+    if first_char == 'z' && try_read("opf;") {
+        return Some(CharRef {
+            name: "opf;",
+            characters: "\u{1d56b}",
+        });
+    }
+
+    if first_char == 'z' && try_read("scr;") {
+        return Some(CharRef {
+            name: "scr;",
+            characters: "\u{1d4cf}",
+        });
+    }
+
+    if first_char == 'z' && try_read("wnj;") {
+        return Some(CharRef {
+            name: "wnj;",
+            characters: "\u{200c}",
+        });
+    }
+
+    if first_char == 'A' && try_read("MP;") {
+        return Some(CharRef {
+            name: "MP;",
+            characters: "\u{26}",
+        });
+    }
+
+    if first_char == 'A' && try_read("cy;") {
+        return Some(CharRef {
+            name: "cy;",
+            characters: "\u{410}",
+        });
+    }
+
+    if first_char == 'A' && try_read("fr;") {
+        return Some(CharRef {
+            name: "fr;",
+            characters: "\u{1d504}",
+        });
+    }
+
+    if first_char == 'A' && try_read("nd;") {
+        return Some(CharRef {
+            name: "nd;",
+            characters: "\u{2a53}",
+        });
+    }
+
+    if first_char == 'A' && try_read("uml") {
+        return Some(CharRef {
+            name: "uml",
+            characters: "\u{c4}",
+        });
+    }
+
+    if first_char == 'B' && try_read("cy;") {
+        return Some(CharRef {
+            name: "cy;",
+            characters: "\u{411}",
+        });
+    }
+
+    if first_char == 'B' && try_read("fr;") {
+        return Some(CharRef {
+            name: "fr;",
+            characters: "\u{1d505}",
+        });
+    }
+
+    if first_char == 'C' && try_read("OPY") {
+        return Some(CharRef {
+            name: "OPY",
+            characters: "\u{a9}",
+        });
+    }
+
+    if first_char == 'C' && try_read("ap;") {
+        return Some(CharRef {
+            name: "ap;",
+            characters: "\u{22d2}",
+        });
+    }
+
+    if first_char == 'C' && try_read("fr;") {
+        return Some(CharRef {
+            name: "fr;",
+            characters: "\u{212d}",
+        });
+    }
+
+    if first_char == 'C' && try_read("hi;") {
+        return Some(CharRef {
+            name: "hi;",
+            characters: "\u{3a7}",
+        });
+    }
+
+    if first_char == 'C' && try_read("up;") {
+        return Some(CharRef {
+            name: "up;",
+            characters: "\u{22d3}",
+        });
+    }
+
+    if first_char == 'D' && try_read("cy;") {
+        return Some(CharRef {
+            name: "cy;",
+            characters: "\u{414}",
+        });
+    }
+
+    if first_char == 'D' && try_read("el;") {
+        return Some(CharRef {
+            name: "el;",
+            characters: "\u{2207}",
+        });
+    }
+
+    if first_char == 'D' && try_read("fr;") {
+        return Some(CharRef {
+            name: "fr;",
+            characters: "\u{1d507}",
+        });
+    }
+
+    if first_char == 'D' && try_read("ot;") {
+        return Some(CharRef {
+            name: "ot;",
+            characters: "\u{a8}",
+        });
+    }
+
+    if first_char == 'E' && try_read("NG;") {
+        return Some(CharRef {
+            name: "NG;",
+            characters: "\u{14a}",
+        });
+    }
+
+    if first_char == 'E' && try_read("TH;") {
+        return Some(CharRef {
+            name: "TH;",
+            characters: "\u{d0}",
+        });
+    }
+
+    if first_char == 'E' && try_read("cy;") {
+        return Some(CharRef {
+            name: "cy;",
+            characters: "\u{42d}",
+        });
+    }
+
+    if first_char == 'E' && try_read("fr;") {
+        return Some(CharRef {
+            name: "fr;",
+            characters: "\u{1d508}",
+        });
+    }
+
+    if first_char == 'E' && try_read("ta;") {
+        return Some(CharRef {
+            name: "ta;",
+            characters: "\u{397}",
+        });
+    }
+
+    if first_char == 'E' && try_read("uml") {
+        return Some(CharRef {
+            name: "uml",
+            characters: "\u{cb}",
+        });
+    }
+
+    if first_char == 'F' && try_read("cy;") {
+        return Some(CharRef {
+            name: "cy;",
+            characters: "\u{424}",
+        });
+    }
+
+    if first_char == 'F' && try_read("fr;") {
+        return Some(CharRef {
+            name: "fr;",
+            characters: "\u{1d509}",
+        });
+    }
+
+    if first_char == 'G' && try_read("cy;") {
+        return Some(CharRef {
+            name: "cy;",
+            characters: "\u{413}",
+        });
+    }
+
+    if first_char == 'G' && try_read("fr;") {
+        return Some(CharRef {
+            name: "fr;",
+            characters: "\u{1d50a}",
+        });
+    }
+
+    if first_char == 'H' && try_read("at;") {
+        return Some(CharRef {
+            name: "at;",
+            characters: "\u{5e}",
+        });
+    }
+
+    if first_char == 'H' && try_read("fr;") {
+        return Some(CharRef {
+            name: "fr;",
+            characters: "\u{210c}",
+        });
+    }
+
+    if first_char == 'I' && try_read("cy;") {
+        return Some(CharRef {
+            name: "cy;",
+            characters: "\u{418}",
+        });
+    }
+
+    if first_char == 'I' && try_read("fr;") {
+        return Some(CharRef {
+            name: "fr;",
+            characters: "\u{2111}",
+        });
+    }
+
+    if first_char == 'I' && try_read("nt;") {
+        return Some(CharRef {
+            name: "nt;",
+            characters: "\u{222c}",
+        });
+    }
+
+    if first_char == 'I' && try_read("uml") {
+        return Some(CharRef {
+            name: "uml",
+            characters: "\u{cf}",
+        });
+    }
+
+    if first_char == 'J' && try_read("cy;") {
+        return Some(CharRef {
+            name: "cy;",
+            characters: "\u{419}",
+        });
+    }
+
+    if first_char == 'J' && try_read("fr;") {
+        return Some(CharRef {
+            name: "fr;",
+            characters: "\u{1d50d}",
+        });
+    }
+
+    if first_char == 'K' && try_read("cy;") {
+        return Some(CharRef {
+            name: "cy;",
+            characters: "\u{41a}",
+        });
+    }
+
+    if first_char == 'K' && try_read("fr;") {
+        return Some(CharRef {
+            name: "fr;",
+            characters: "\u{1d50e}",
+        });
+    }
+
+    if first_char == 'L' && try_read("cy;") {
+        return Some(CharRef {
+            name: "cy;",
+            characters: "\u{41b}",
+        });
+    }
+
+    if first_char == 'L' && try_read("fr;") {
+        return Some(CharRef {
+            name: "fr;",
+            characters: "\u{1d50f}",
+        });
+    }
+
+    if first_char == 'L' && try_read("sh;") {
+        return Some(CharRef {
+            name: "sh;",
+            characters: "\u{21b0}",
+        });
+    }
+
+    if first_char == 'M' && try_read("ap;") {
+        return Some(CharRef {
+            name: "ap;",
+            characters: "\u{2905}",
+        });
+    }
+
+    if first_char == 'M' && try_read("cy;") {
+        return Some(CharRef {
+            name: "cy;",
+            characters: "\u{41c}",
+        });
+    }
+
+    if first_char == 'M' && try_read("fr;") {
+        return Some(CharRef {
+            name: "fr;",
+            characters: "\u{1d510}",
+        });
+    }
+
+    if first_char == 'N' && try_read("cy;") {
+        return Some(CharRef {
+            name: "cy;",
+            characters: "\u{41d}",
+        });
+    }
+
+    if first_char == 'N' && try_read("fr;") {
+        return Some(CharRef {
+            name: "fr;",
+            characters: "\u{1d511}",
+        });
+    }
+
+    if first_char == 'N' && try_read("ot;") {
+        return Some(CharRef {
+            name: "ot;",
+            characters: "\u{2aec}",
+        });
+    }
+
+    if first_char == 'O' && try_read("cy;") {
+        return Some(CharRef {
+            name: "cy;",
+            characters: "\u{41e}",
+        });
+    }
+
+    if first_char == 'O' && try_read("fr;") {
+        return Some(CharRef {
+            name: "fr;",
+            characters: "\u{1d512}",
+        });
+    }
+
+    if first_char == 'O' && try_read("uml") {
+        return Some(CharRef {
+            name: "uml",
+            characters: "\u{d6}",
+        });
+    }
+
+    if first_char == 'P' && try_read("cy;") {
+        return Some(CharRef {
+            name: "cy;",
+            characters: "\u{41f}",
+        });
+    }
+
+    if first_char == 'P' && try_read("fr;") {
+        return Some(CharRef {
+            name: "fr;",
+            characters: "\u{1d513}",
+        });
+    }
+
+    if first_char == 'P' && try_read("hi;") {
+        return Some(CharRef {
+            name: "hi;",
+            characters: "\u{3a6}",
+        });
+    }
+
+    if first_char == 'P' && try_read("si;") {
+        return Some(CharRef {
+            name: "si;",
+            characters: "\u{3a8}",
+        });
+    }
+
+    if first_char == 'Q' && try_read("UOT") {
+        return Some(CharRef {
+            name: "UOT",
+            characters: "\u{22}",
+        });
+    }
+
+    if first_char == 'Q' && try_read("fr;") {
+        return Some(CharRef {
+            name: "fr;",
+            characters: "\u{1d514}",
+        });
+    }
+
+    if first_char == 'R' && try_read("EG;") {
+        return Some(CharRef {
+            name: "EG;",
+            characters: "\u{ae}",
+        });
+    }
+
+    if first_char == 'R' && try_read("cy;") {
+        return Some(CharRef {
+            name: "cy;",
+            characters: "\u{420}",
+        });
+    }
+
+    if first_char == 'R' && try_read("fr;") {
+        return Some(CharRef {
+            name: "fr;",
+            characters: "\u{211c}",
+        });
+    }
+
+    if first_char == 'R' && try_read("ho;") {
+        return Some(CharRef {
+            name: "ho;",
+            characters: "\u{3a1}",
+        });
+    }
+
+    if first_char == 'R' && try_read("sh;") {
+        return Some(CharRef {
+            name: "sh;",
+            characters: "\u{21b1}",
+        });
+    }
+
+    if first_char == 'S' && try_read("cy;") {
+        return Some(CharRef {
+            name: "cy;",
+            characters: "\u{421}",
+        });
+    }
+
+    if first_char == 'S' && try_read("fr;") {
+        return Some(CharRef {
+            name: "fr;",
+            characters: "\u{1d516}",
+        });
+    }
+
+    if first_char == 'S' && try_read("ub;") {
+        return Some(CharRef {
+            name: "ub;",
+            characters: "\u{22d0}",
+        });
+    }
+
+    if first_char == 'S' && try_read("um;") {
+        return Some(CharRef {
+            name: "um;",
+            characters: "\u{2211}",
+        });
+    }
+
+    if first_char == 'S' && try_read("up;") {
+        return Some(CharRef {
+            name: "up;",
+            characters: "\u{22d1}",
+        });
+    }
+
+    if first_char == 'T' && try_read("ab;") {
+        return Some(CharRef {
+            name: "ab;",
+            characters: "\u{9}",
+        });
+    }
+
+    if first_char == 'T' && try_read("au;") {
+        return Some(CharRef {
+            name: "au;",
+            characters: "\u{3a4}",
+        });
+    }
+
+    if first_char == 'T' && try_read("cy;") {
+        return Some(CharRef {
+            name: "cy;",
+            characters: "\u{422}",
+        });
+    }
+
+    if first_char == 'T' && try_read("fr;") {
+        return Some(CharRef {
+            name: "fr;",
+            characters: "\u{1d517}",
+        });
+    }
+
+    if first_char == 'U' && try_read("cy;") {
+        return Some(CharRef {
+            name: "cy;",
+            characters: "\u{423}",
+        });
+    }
+
+    if first_char == 'U' && try_read("fr;") {
+        return Some(CharRef {
+            name: "fr;",
+            characters: "\u{1d518}",
+        });
+    }
+
+    if first_char == 'U' && try_read("uml") {
+        return Some(CharRef {
+            name: "uml",
+            characters: "\u{dc}",
+        });
+    }
+
+    if first_char == 'V' && try_read("cy;") {
+        return Some(CharRef {
+            name: "cy;",
+            characters: "\u{412}",
+        });
+    }
+
+    if first_char == 'V' && try_read("ee;") {
+        return Some(CharRef {
+            name: "ee;",
+            characters: "\u{22c1}",
+        });
+    }
+
+    if first_char == 'V' && try_read("fr;") {
+        return Some(CharRef {
+            name: "fr;",
+            characters: "\u{1d519}",
+        });
+    }
+
+    if first_char == 'W' && try_read("fr;") {
+        return Some(CharRef {
+            name: "fr;",
+            characters: "\u{1d51a}",
+        });
+    }
+
+    if first_char == 'X' && try_read("fr;") {
+        return Some(CharRef {
+            name: "fr;",
+            characters: "\u{1d51b}",
+        });
+    }
+
+    if first_char == 'Y' && try_read("cy;") {
+        return Some(CharRef {
+            name: "cy;",
+            characters: "\u{42b}",
+        });
+    }
+
+    if first_char == 'Y' && try_read("fr;") {
+        return Some(CharRef {
+            name: "fr;",
+            characters: "\u{1d51c}",
+        });
+    }
+
+    if first_char == 'Z' && try_read("cy;") {
+        return Some(CharRef {
+            name: "cy;",
+            characters: "\u{417}",
+        });
+    }
+
+    if first_char == 'Z' && try_read("fr;") {
+        return Some(CharRef {
+            name: "fr;",
+            characters: "\u{2128}",
+        });
+    }
+
+    if first_char == 'a' && try_read("cE;") {
+        return Some(CharRef {
+            name: "cE;",
+            characters: "\u{223e}\u{333}",
+        });
+    }
+
+    if first_char == 'a' && try_read("cd;") {
+        return Some(CharRef {
+            name: "cd;",
+            characters: "\u{223f}",
+        });
+    }
+
+    if first_char == 'a' && try_read("cy;") {
+        return Some(CharRef {
+            name: "cy;",
+            characters: "\u{430}",
+        });
+    }
+
+    if first_char == 'a' && try_read("fr;") {
+        return Some(CharRef {
+            name: "fr;",
+            characters: "\u{1d51e}",
+        });
+    }
+
+    if first_char == 'a' && try_read("mp;") {
+        return Some(CharRef {
+            name: "mp;",
+            characters: "\u{26}",
+        });
+    }
+
+    if first_char == 'a' && try_read("nd;") {
+        return Some(CharRef {
+            name: "nd;",
+            characters: "\u{2227}",
+        });
+    }
+
+    if first_char == 'a' && try_read("ng;") {
+        return Some(CharRef {
+            name: "ng;",
+            characters: "\u{2220}",
+        });
+    }
+
+    if first_char == 'a' && try_read("pE;") {
+        return Some(CharRef {
+            name: "pE;",
+            characters: "\u{2a70}",
+        });
+    }
+
+    if first_char == 'a' && try_read("pe;") {
+        return Some(CharRef {
+            name: "pe;",
+            characters: "\u{224a}",
+        });
+    }
+
+    if first_char == 'a' && try_read("st;") {
+        return Some(CharRef {
+            name: "st;",
+            characters: "\u{2a}",
+        });
+    }
+
+    if first_char == 'a' && try_read("uml") {
+        return Some(CharRef {
+            name: "uml",
+            characters: "\u{e4}",
+        });
+    }
+
+    if first_char == 'b' && try_read("cy;") {
+        return Some(CharRef {
+            name: "cy;",
+            characters: "\u{431}",
+        });
+    }
+
+    if first_char == 'b' && try_read("fr;") {
+        return Some(CharRef {
+            name: "fr;",
+            characters: "\u{1d51f}",
+        });
+    }
+
+    if first_char == 'b' && try_read("ne;") {
+        return Some(CharRef {
+            name: "ne;",
+            characters: "\u{3d}\u{20e5}",
+        });
+    }
+
+    if first_char == 'b' && try_read("ot;") {
+        return Some(CharRef {
+            name: "ot;",
+            characters: "\u{22a5}",
+        });
+    }
+
+    if first_char == 'c' && try_read("ap;") {
+        return Some(CharRef {
+            name: "ap;",
+            characters: "\u{2229}",
+        });
+    }
+
+    if first_char == 'c' && try_read("ent") {
+        return Some(CharRef {
+            name: "ent",
+            characters: "\u{a2}",
+        });
+    }
+
+    if first_char == 'c' && try_read("fr;") {
+        return Some(CharRef {
+            name: "fr;",
+            characters: "\u{1d520}",
+        });
+    }
+
+    if first_char == 'c' && try_read("hi;") {
+        return Some(CharRef {
+            name: "hi;",
+            characters: "\u{3c7}",
+        });
+    }
+
+    if first_char == 'c' && try_read("ir;") {
+        return Some(CharRef {
+            name: "ir;",
+            characters: "\u{25cb}",
+        });
+    }
+
+    if first_char == 'c' && try_read("opy") {
+        return Some(CharRef {
+            name: "opy",
+            characters: "\u{a9}",
+        });
+    }
+
+    if first_char == 'c' && try_read("up;") {
+        return Some(CharRef {
+            name: "up;",
+            characters: "\u{222a}",
+        });
+    }
+
+    if first_char == 'd' && try_read("cy;") {
+        return Some(CharRef {
+            name: "cy;",
+            characters: "\u{434}",
+        });
+    }
+
+    if first_char == 'd' && try_read("eg;") {
+        return Some(CharRef {
+            name: "eg;",
+            characters: "\u{b0}",
+        });
+    }
+
+    if first_char == 'd' && try_read("fr;") {
+        return Some(CharRef {
+            name: "fr;",
+            characters: "\u{1d521}",
+        });
+    }
+
+    if first_char == 'd' && try_read("ie;") {
+        return Some(CharRef {
+            name: "ie;",
+            characters: "\u{a8}",
+        });
+    }
+
+    if first_char == 'd' && try_read("iv;") {
+        return Some(CharRef {
+            name: "iv;",
+            characters: "\u{f7}",
+        });
+    }
+
+    if first_char == 'd' && try_read("ot;") {
+        return Some(CharRef {
+            name: "ot;",
+            characters: "\u{2d9}",
+        });
+    }
+
+    if first_char == 'e' && try_read("cy;") {
+        return Some(CharRef {
+            name: "cy;",
+            characters: "\u{44d}",
+        });
+    }
+
+    if first_char == 'e' && try_read("fr;") {
+        return Some(CharRef {
+            name: "fr;",
+            characters: "\u{1d522}",
+        });
+    }
+
+    if first_char == 'e' && try_read("gs;") {
+        return Some(CharRef {
+            name: "gs;",
+            characters: "\u{2a96}",
+        });
+    }
+
+    if first_char == 'e' && try_read("ll;") {
+        return Some(CharRef {
+            name: "ll;",
+            characters: "\u{2113}",
+        });
+    }
+
+    if first_char == 'e' && try_read("ls;") {
+        return Some(CharRef {
+            name: "ls;",
+            characters: "\u{2a95}",
+        });
+    }
+
+    if first_char == 'e' && try_read("ng;") {
+        return Some(CharRef {
+            name: "ng;",
+            characters: "\u{14b}",
+        });
+    }
+
+    if first_char == 'e' && try_read("ta;") {
+        return Some(CharRef {
+            name: "ta;",
+            characters: "\u{3b7}",
+        });
+    }
+
+    if first_char == 'e' && try_read("th;") {
+        return Some(CharRef {
+            name: "th;",
+            characters: "\u{f0}",
+        });
+    }
+
+    if first_char == 'e' && try_read("uml") {
+        return Some(CharRef {
+            name: "uml",
+            characters: "\u{eb}",
+        });
+    }
+
+    if first_char == 'f' && try_read("cy;") {
+        return Some(CharRef {
+            name: "cy;",
+            characters: "\u{444}",
+        });
+    }
+
+    if first_char == 'f' && try_read("fr;") {
+        return Some(CharRef {
+            name: "fr;",
+            characters: "\u{1d523}",
+        });
+    }
+
+    if first_char == 'g' && try_read("El;") {
+        return Some(CharRef {
+            name: "El;",
+            characters: "\u{2a8c}",
+        });
+    }
+
+    if first_char == 'g' && try_read("ap;") {
+        return Some(CharRef {
+            name: "ap;",
+            characters: "\u{2a86}",
+        });
+    }
+
+    if first_char == 'g' && try_read("cy;") {
+        return Some(CharRef {
+            name: "cy;",
+            characters: "\u{433}",
+        });
+    }
+
+    if first_char == 'g' && try_read("el;") {
+        return Some(CharRef {
+            name: "el;",
+            characters: "\u{22db}",
+        });
+    }
+
+    if first_char == 'g' && try_read("eq;") {
+        return Some(CharRef {
+            name: "eq;",
+            characters: "\u{2265}",
+        });
+    }
+
+    if first_char == 'g' && try_read("es;") {
+        return Some(CharRef {
+            name: "es;",
+            characters: "\u{2a7e}",
+        });
+    }
+
+    if first_char == 'g' && try_read("fr;") {
+        return Some(CharRef {
+            name: "fr;",
+            characters: "\u{1d524}",
+        });
+    }
+
+    if first_char == 'g' && try_read("gg;") {
+        return Some(CharRef {
+            name: "gg;",
+            characters: "\u{22d9}",
+        });
+    }
+
+    if first_char == 'g' && try_read("lE;") {
+        return Some(CharRef {
+            name: "lE;",
+            characters: "\u{2a92}",
+        });
+    }
+
+    if first_char == 'g' && try_read("la;") {
+        return Some(CharRef {
+            name: "la;",
+            characters: "\u{2aa5}",
+        });
+    }
+
+    if first_char == 'g' && try_read("lj;") {
+        return Some(CharRef {
+            name: "lj;",
+            characters: "\u{2aa4}",
+        });
+    }
+
+    if first_char == 'g' && try_read("nE;") {
+        return Some(CharRef {
+            name: "nE;",
+            characters: "\u{2269}",
+        });
+    }
+
+    if first_char == 'g' && try_read("ne;") {
+        return Some(CharRef {
+            name: "ne;",
+            characters: "\u{2a88}",
+        });
+    }
+
+    if first_char == 'h' && try_read("fr;") {
+        return Some(CharRef {
+            name: "fr;",
+            characters: "\u{1d525}",
+        });
+    }
+
+    if first_char == 'i' && try_read("cy;") {
+        return Some(CharRef {
+            name: "cy;",
+            characters: "\u{438}",
+        });
+    }
+
+    if first_char == 'i' && try_read("ff;") {
+        return Some(CharRef {
+            name: "ff;",
+            characters: "\u{21d4}",
+        });
+    }
+
+    if first_char == 'i' && try_read("fr;") {
+        return Some(CharRef {
+            name: "fr;",
+            characters: "\u{1d526}",
+        });
+    }
+
+    if first_char == 'i' && try_read("nt;") {
+        return Some(CharRef {
+            name: "nt;",
+            characters: "\u{222b}",
+        });
+    }
+
+    if first_char == 'i' && try_read("uml") {
+        return Some(CharRef {
+            name: "uml",
+            characters: "\u{ef}",
+        });
+    }
+
+    if first_char == 'j' && try_read("cy;") {
+        return Some(CharRef {
+            name: "cy;",
+            characters: "\u{439}",
+        });
+    }
+
+    if first_char == 'j' && try_read("fr;") {
+        return Some(CharRef {
+            name: "fr;",
+            characters: "\u{1d527}",
+        });
+    }
+
+    if first_char == 'k' && try_read("cy;") {
+        return Some(CharRef {
+            name: "cy;",
+            characters: "\u{43a}",
+        });
+    }
+
+    if first_char == 'k' && try_read("fr;") {
+        return Some(CharRef {
+            name: "fr;",
+            characters: "\u{1d528}",
+        });
+    }
+
+    if first_char == 'l' && try_read("Eg;") {
+        return Some(CharRef {
+            name: "Eg;",
+            characters: "\u{2a8b}",
+        });
+    }
+
+    if first_char == 'l' && try_read("ap;") {
+        return Some(CharRef {
+            name: "ap;",
+            characters: "\u{2a85}",
+        });
+    }
+
+    if first_char == 'l' && try_read("at;") {
+        return Some(CharRef {
+            name: "at;",
+            characters: "\u{2aab}",
+        });
+    }
+
+    if first_char == 'l' && try_read("cy;") {
+        return Some(CharRef {
+            name: "cy;",
+            characters: "\u{43b}",
+        });
+    }
+
+    if first_char == 'l' && try_read("eg;") {
+        return Some(CharRef {
+            name: "eg;",
+            characters: "\u{22da}",
+        });
+    }
+
+    if first_char == 'l' && try_read("eq;") {
+        return Some(CharRef {
+            name: "eq;",
+            characters: "\u{2264}",
+        });
+    }
+
+    if first_char == 'l' && try_read("es;") {
+        return Some(CharRef {
+            name: "es;",
+            characters: "\u{2a7d}",
+        });
+    }
+
+    if first_char == 'l' && try_read("fr;") {
+        return Some(CharRef {
+            name: "fr;",
+            characters: "\u{1d529}",
+        });
+    }
+
+    if first_char == 'l' && try_read("gE;") {
+        return Some(CharRef {
+            name: "gE;",
+            characters: "\u{2a91}",
+        });
+    }
+
+    if first_char == 'l' && try_read("nE;") {
+        return Some(CharRef {
+            name: "nE;",
+            characters: "\u{2268}",
+        });
+    }
+
+    if first_char == 'l' && try_read("ne;") {
+        return Some(CharRef {
+            name: "ne;",
+            characters: "\u{2a87}",
+        });
+    }
+
+    if first_char == 'l' && try_read("oz;") {
+        return Some(CharRef {
+            name: "oz;",
+            characters: "\u{25ca}",
+        });
+    }
+
+    if first_char == 'l' && try_read("rm;") {
+        return Some(CharRef {
+            name: "rm;",
+            characters: "\u{200e}",
+        });
+    }
+
+    if first_char == 'l' && try_read("sh;") {
+        return Some(CharRef {
+            name: "sh;",
+            characters: "\u{21b0}",
+        });
+    }
+
+    if first_char == 'm' && try_read("acr") {
+        return Some(CharRef {
+            name: "acr",
+            characters: "\u{af}",
+        });
+    }
+
+    if first_char == 'm' && try_read("ap;") {
+        return Some(CharRef {
+            name: "ap;",
+            characters: "\u{21a6}",
+        });
+    }
+
+    if first_char == 'm' && try_read("cy;") {
+        return Some(CharRef {
+            name: "cy;",
+            characters: "\u{43c}",
+        });
+    }
+
+    if first_char == 'm' && try_read("fr;") {
+        return Some(CharRef {
+            name: "fr;",
+            characters: "\u{1d52a}",
+        });
+    }
+
+    if first_char == 'm' && try_read("ho;") {
+        return Some(CharRef {
+            name: "ho;",
+            characters: "\u{2127}",
+        });
+    }
+
+    if first_char == 'm' && try_read("id;") {
+        return Some(CharRef {
+            name: "id;",
+            characters: "\u{2223}",
+        });
+    }
+
+    if first_char == 'n' && try_read("Gg;") {
+        return Some(CharRef {
+            name: "Gg;",
+            characters: "\u{22d9}\u{338}",
+        });
+    }
+
+    if first_char == 'n' && try_read("Gt;") {
+        return Some(CharRef {
+            name: "Gt;",
+            characters: "\u{226b}\u{20d2}",
+        });
+    }
+
+    if first_char == 'n' && try_read("Ll;") {
+        return Some(CharRef {
+            name: "Ll;",
+            characters: "\u{22d8}\u{338}",
+        });
+    }
+
+    if first_char == 'n' && try_read("Lt;") {
+        return Some(CharRef {
+            name: "Lt;",
+            characters: "\u{226a}\u{20d2}",
+        });
+    }
+
+    if first_char == 'n' && try_read("ap;") {
+        return Some(CharRef {
+            name: "ap;",
+            characters: "\u{2249}",
+        });
+    }
+
+    if first_char == 'n' && try_read("bsp") {
+        return Some(CharRef {
+            name: "bsp",
+            characters: "\u{a0}",
+        });
+    }
+
+    if first_char == 'n' && try_read("cy;") {
+        return Some(CharRef {
+            name: "cy;",
+            characters: "\u{43d}",
+        });
+    }
+
+    if first_char == 'n' && try_read("fr;") {
+        return Some(CharRef {
+            name: "fr;",
+            characters: "\u{1d52b}",
+        });
+    }
+
+    if first_char == 'n' && try_read("gE;") {
+        return Some(CharRef {
+            name: "gE;",
+            characters: "\u{2267}\u{338}",
+        });
+    }
+
+    if first_char == 'n' && try_read("ge;") {
+        return Some(CharRef {
+            name: "ge;",
+            characters: "\u{2271}",
+        });
+    }
+
+    if first_char == 'n' && try_read("gt;") {
+        return Some(CharRef {
+            name: "gt;",
+            characters: "\u{226f}",
+        });
+    }
+
+    if first_char == 'n' && try_read("is;") {
+        return Some(CharRef {
+            name: "is;",
+            characters: "\u{22fc}",
+        });
+    }
+
+    if first_char == 'n' && try_read("iv;") {
+        return Some(CharRef {
+            name: "iv;",
+            characters: "\u{220b}",
+        });
+    }
+
+    if first_char == 'n' && try_read("lE;") {
+        return Some(CharRef {
+            name: "lE;",
+            characters: "\u{2266}\u{338}",
+        });
+    }
+
+    if first_char == 'n' && try_read("le;") {
+        return Some(CharRef {
+            name: "le;",
+            characters: "\u{2270}",
+        });
+    }
+
+    if first_char == 'n' && try_read("lt;") {
+        return Some(CharRef {
+            name: "lt;",
+            characters: "\u{226e}",
+        });
+    }
+
+    if first_char == 'n' && try_read("ot;") {
+        return Some(CharRef {
+            name: "ot;",
+            characters: "\u{ac}",
+        });
+    }
+
+    if first_char == 'n' && try_read("pr;") {
+        return Some(CharRef {
+            name: "pr;",
+            characters: "\u{2280}",
+        });
+    }
+
+    if first_char == 'n' && try_read("sc;") {
+        return Some(CharRef {
+            name: "sc;",
+            characters: "\u{2281}",
+        });
+    }
+
+    if first_char == 'n' && try_read("um;") {
+        return Some(CharRef {
+            name: "um;",
+            characters: "\u{23}",
+        });
+    }
+
+    if first_char == 'o' && try_read("cy;") {
+        return Some(CharRef {
+            name: "cy;",
+            characters: "\u{43e}",
+        });
+    }
+
+    if first_char == 'o' && try_read("fr;") {
+        return Some(CharRef {
+            name: "fr;",
+            characters: "\u{1d52c}",
+        });
+    }
+
+    if first_char == 'o' && try_read("gt;") {
+        return Some(CharRef {
+            name: "gt;",
+            characters: "\u{29c1}",
+        });
+    }
+
+    if first_char == 'o' && try_read("hm;") {
+        return Some(CharRef {
+            name: "hm;",
+            characters: "\u{3a9}",
+        });
+    }
+
+    if first_char == 'o' && try_read("lt;") {
+        return Some(CharRef {
+            name: "lt;",
+            characters: "\u{29c0}",
+        });
+    }
+
+    if first_char == 'o' && try_read("rd;") {
+        return Some(CharRef {
+            name: "rd;",
+            characters: "\u{2a5d}",
+        });
+    }
+
+    if first_char == 'o' && try_read("rdf") {
+        return Some(CharRef {
+            name: "rdf",
+            characters: "\u{aa}",
+        });
+    }
+
+    if first_char == 'o' && try_read("rdm") {
+        return Some(CharRef {
+            name: "rdm",
+            characters: "\u{ba}",
+        });
+    }
+
+    if first_char == 'o' && try_read("rv;") {
+        return Some(CharRef {
+            name: "rv;",
+            characters: "\u{2a5b}",
+        });
+    }
+
+    if first_char == 'o' && try_read("uml") {
+        return Some(CharRef {
+            name: "uml",
+            characters: "\u{f6}",
+        });
+    }
+
+    if first_char == 'p' && try_read("ar;") {
+        return Some(CharRef {
+            name: "ar;",
+            characters: "\u{2225}",
+        });
+    }
+
+    if first_char == 'p' && try_read("ara") {
+        return Some(CharRef {
+            name: "ara",
+            characters: "\u{b6}",
+        });
+    }
+
+    if first_char == 'p' && try_read("cy;") {
+        return Some(CharRef {
+            name: "cy;",
+            characters: "\u{43f}",
+        });
+    }
+
+    if first_char == 'p' && try_read("fr;") {
+        return Some(CharRef {
+            name: "fr;",
+            characters: "\u{1d52d}",
+        });
+    }
+
+    if first_char == 'p' && try_read("hi;") {
+        return Some(CharRef {
+            name: "hi;",
+            characters: "\u{3c6}",
+        });
+    }
+
+    if first_char == 'p' && try_read("iv;") {
+        return Some(CharRef {
+            name: "iv;",
+            characters: "\u{3d6}",
+        });
+    }
+
+    if first_char == 'p' && try_read("rE;") {
+        return Some(CharRef {
+            name: "rE;",
+            characters: "\u{2ab3}",
+        });
+    }
+
+    if first_char == 'p' && try_read("re;") {
+        return Some(CharRef {
+            name: "re;",
+            characters: "\u{2aaf}",
+        });
+    }
+
+    if first_char == 'p' && try_read("si;") {
+        return Some(CharRef {
+            name: "si;",
+            characters: "\u{3c8}",
+        });
+    }
+
+    if first_char == 'q' && try_read("fr;") {
+        return Some(CharRef {
+            name: "fr;",
+            characters: "\u{1d52e}",
+        });
+    }
+
+    if first_char == 'q' && try_read("uot") {
+        return Some(CharRef {
+            name: "uot",
+            characters: "\u{22}",
+        });
+    }
+
+    if first_char == 'r' && try_read("cy;") {
+        return Some(CharRef {
+            name: "cy;",
+            characters: "\u{440}",
+        });
+    }
+
+    if first_char == 'r' && try_read("eg;") {
+        return Some(CharRef {
+            name: "eg;",
+            characters: "\u{ae}",
+        });
+    }
+
+    if first_char == 'r' && try_read("fr;") {
+        return Some(CharRef {
+            name: "fr;",
+            characters: "\u{1d52f}",
+        });
+    }
+
+    if first_char == 'r' && try_read("ho;") {
+        return Some(CharRef {
+            name: "ho;",
+            characters: "\u{3c1}",
+        });
+    }
+
+    if first_char == 'r' && try_read("lm;") {
+        return Some(CharRef {
+            name: "lm;",
+            characters: "\u{200f}",
+        });
+    }
+
+    if first_char == 'r' && try_read("sh;") {
+        return Some(CharRef {
+            name: "sh;",
+            characters: "\u{21b1}",
+        });
+    }
+
+    if first_char == 's' && try_read("cE;") {
+        return Some(CharRef {
+            name: "cE;",
+            characters: "\u{2ab4}",
+        });
+    }
+
+    if first_char == 's' && try_read("ce;") {
+        return Some(CharRef {
+            name: "ce;",
+            characters: "\u{2ab0}",
+        });
+    }
+
+    if first_char == 's' && try_read("cy;") {
+        return Some(CharRef {
+            name: "cy;",
+            characters: "\u{441}",
+        });
+    }
+
+    if first_char == 's' && try_read("ect") {
+        return Some(CharRef {
+            name: "ect",
+            characters: "\u{a7}",
+        });
+    }
+
+    if first_char == 's' && try_read("fr;") {
+        return Some(CharRef {
+            name: "fr;",
+            characters: "\u{1d530}",
+        });
+    }
+
+    if first_char == 's' && try_read("hy;") {
+        return Some(CharRef {
+            name: "hy;",
+            characters: "\u{ad}",
+        });
+    }
+
+    if first_char == 's' && try_read("im;") {
+        return Some(CharRef {
+            name: "im;",
+            characters: "\u{223c}",
+        });
+    }
+
+    if first_char == 's' && try_read("mt;") {
+        return Some(CharRef {
+            name: "mt;",
+            characters: "\u{2aaa}",
+        });
+    }
+
+    if first_char == 's' && try_read("ol;") {
+        return Some(CharRef {
+            name: "ol;",
+            characters: "\u{2f}",
+        });
+    }
+
+    if first_char == 's' && try_read("qu;") {
+        return Some(CharRef {
+            name: "qu;",
+            characters: "\u{25a1}",
+        });
+    }
+
+    if first_char == 's' && try_read("ub;") {
+        return Some(CharRef {
+            name: "ub;",
+            characters: "\u{2282}",
+        });
+    }
+
+    if first_char == 's' && try_read("um;") {
+        return Some(CharRef {
+            name: "um;",
+            characters: "\u{2211}",
+        });
+    }
+
+    if first_char == 's' && try_read("up1") {
+        return Some(CharRef {
+            name: "up1",
+            characters: "\u{b9}",
+        });
+    }
+
+    if first_char == 's' && try_read("up2") {
+        return Some(CharRef {
+            name: "up2",
+            characters: "\u{b2}",
+        });
+    }
+
+    if first_char == 's' && try_read("up3") {
+        return Some(CharRef {
+            name: "up3",
+            characters: "\u{b3}",
+        });
+    }
+
+    if first_char == 's' && try_read("up;") {
+        return Some(CharRef {
+            name: "up;",
+            characters: "\u{2283}",
+        });
+    }
+
+    if first_char == 't' && try_read("au;") {
+        return Some(CharRef {
+            name: "au;",
+            characters: "\u{3c4}",
+        });
+    }
+
+    if first_char == 't' && try_read("cy;") {
+        return Some(CharRef {
+            name: "cy;",
+            characters: "\u{442}",
+        });
+    }
+
+    if first_char == 't' && try_read("fr;") {
+        return Some(CharRef {
+            name: "fr;",
+            characters: "\u{1d531}",
+        });
+    }
+
+    if first_char == 't' && try_read("op;") {
+        return Some(CharRef {
+            name: "op;",
+            characters: "\u{22a4}",
+        });
+    }
+
+    if first_char == 'u' && try_read("cy;") {
+        return Some(CharRef {
+            name: "cy;",
+            characters: "\u{443}",
+        });
+    }
+
+    if first_char == 'u' && try_read("fr;") {
+        return Some(CharRef {
+            name: "fr;",
+            characters: "\u{1d532}",
+        });
+    }
+
+    if first_char == 'u' && try_read("ml;") {
+        return Some(CharRef {
+            name: "ml;",
+            characters: "\u{a8}",
+        });
+    }
+
+    if first_char == 'u' && try_read("uml") {
+        return Some(CharRef {
+            name: "uml",
+            characters: "\u{fc}",
+        });
+    }
+
+    if first_char == 'v' && try_read("cy;") {
+        return Some(CharRef {
+            name: "cy;",
+            characters: "\u{432}",
+        });
+    }
+
+    if first_char == 'v' && try_read("ee;") {
+        return Some(CharRef {
+            name: "ee;",
+            characters: "\u{2228}",
+        });
+    }
+
+    if first_char == 'v' && try_read("fr;") {
+        return Some(CharRef {
+            name: "fr;",
+            characters: "\u{1d533}",
+        });
+    }
+
+    if first_char == 'w' && try_read("fr;") {
+        return Some(CharRef {
+            name: "fr;",
+            characters: "\u{1d534}",
+        });
+    }
+
+    if first_char == 'x' && try_read("fr;") {
+        return Some(CharRef {
+            name: "fr;",
+            characters: "\u{1d535}",
+        });
+    }
+
+    if first_char == 'y' && try_read("cy;") {
+        return Some(CharRef {
+            name: "cy;",
+            characters: "\u{44b}",
+        });
+    }
+
+    if first_char == 'y' && try_read("en;") {
+        return Some(CharRef {
+            name: "en;",
+            characters: "\u{a5}",
+        });
+    }
+
+    if first_char == 'y' && try_read("fr;") {
+        return Some(CharRef {
+            name: "fr;",
+            characters: "\u{1d536}",
+        });
+    }
+
+    if first_char == 'y' && try_read("uml") {
+        return Some(CharRef {
+            name: "uml",
+            characters: "\u{ff}",
+        });
+    }
+
+    if first_char == 'z' && try_read("cy;") {
+        return Some(CharRef {
+            name: "cy;",
+            characters: "\u{437}",
+        });
+    }
+
+    if first_char == 'z' && try_read("fr;") {
+        return Some(CharRef {
+            name: "fr;",
+            characters: "\u{1d537}",
+        });
+    }
+
+    if first_char == 'z' && try_read("wj;") {
+        return Some(CharRef {
+            name: "wj;",
+            characters: "\u{200d}",
+        });
+    }
+
+    if first_char == 'A' && try_read("MP") {
+        return Some(CharRef {
+            name: "MP",
+            characters: "\u{26}",
+        });
+    }
+
+    if first_char == 'D' && try_read("D;") {
+        return Some(CharRef {
+            name: "D;",
+            characters: "\u{2145}",
+        });
+    }
+
+    if first_char == 'E' && try_read("TH") {
+        return Some(CharRef {
+            name: "TH",
+            characters: "\u{d0}",
+        });
+    }
+
+    if first_char == 'G' && try_read("T;") {
+        return Some(CharRef {
+            name: "T;",
+            characters: "\u{3e}",
+        });
+    }
+
+    if first_char == 'G' && try_read("g;") {
+        return Some(CharRef {
+            name: "g;",
+            characters: "\u{22d9}",
+        });
+    }
+
+    if first_char == 'G' && try_read("t;") {
+        return Some(CharRef {
+            name: "t;",
+            characters: "\u{226b}",
+        });
+    }
+
+    if first_char == 'I' && try_read("m;") {
+        return Some(CharRef {
+            name: "m;",
+            characters: "\u{2111}",
+        });
+    }
+
+    if first_char == 'L' && try_read("T;") {
+        return Some(CharRef {
+            name: "T;",
+            characters: "\u{3c}",
+        });
+    }
+
+    if first_char == 'L' && try_read("l;") {
+        return Some(CharRef {
+            name: "l;",
+            characters: "\u{22d8}",
+        });
+    }
+
+    if first_char == 'L' && try_read("t;") {
+        return Some(CharRef {
+            name: "t;",
+            characters: "\u{226a}",
+        });
+    }
+
+    if first_char == 'M' && try_read("u;") {
+        return Some(CharRef {
+            name: "u;",
+            characters: "\u{39c}",
+        });
+    }
+
+    if first_char == 'N' && try_read("u;") {
+        return Some(CharRef {
+            name: "u;",
+            characters: "\u{39d}",
+        });
+    }
+
+    if first_char == 'O' && try_read("r;") {
+        return Some(CharRef {
+            name: "r;",
+            characters: "\u{2a54}",
+        });
+    }
+
+    if first_char == 'P' && try_read("i;") {
+        return Some(CharRef {
+            name: "i;",
+            characters: "\u{3a0}",
+        });
+    }
+
+    if first_char == 'P' && try_read("r;") {
+        return Some(CharRef {
+            name: "r;",
+            characters: "\u{2abb}",
+        });
+    }
+
+    if first_char == 'R' && try_read("EG") {
+        return Some(CharRef {
+            name: "EG",
+            characters: "\u{ae}",
+        });
+    }
+
+    if first_char == 'R' && try_read("e;") {
+        return Some(CharRef {
+            name: "e;",
+            characters: "\u{211c}",
+        });
+    }
+
+    if first_char == 'S' && try_read("c;") {
+        return Some(CharRef {
+            name: "c;",
+            characters: "\u{2abc}",
+        });
+    }
+
+    if first_char == 'X' && try_read("i;") {
+        return Some(CharRef {
+            name: "i;",
+            characters: "\u{39e}",
+        });
+    }
+
+    if first_char == 'a' && try_read("c;") {
+        return Some(CharRef {
+            name: "c;",
+            characters: "\u{223e}",
+        });
+    }
+
+    if first_char == 'a' && try_read("f;") {
+        return Some(CharRef {
+            name: "f;",
+            characters: "\u{2061}",
+        });
+    }
+
+    if first_char == 'a' && try_read("mp") {
+        return Some(CharRef {
+            name: "mp",
+            characters: "\u{26}",
+        });
+    }
+
+    if first_char == 'a' && try_read("p;") {
+        return Some(CharRef {
+            name: "p;",
+            characters: "\u{2248}",
+        });
+    }
+
+    if first_char == 'd' && try_read("d;") {
+        return Some(CharRef {
+            name: "d;",
+            characters: "\u{2146}",
+        });
+    }
+
+    if first_char == 'd' && try_read("eg") {
+        return Some(CharRef {
+            name: "eg",
+            characters: "\u{b0}",
+        });
+    }
+
+    if first_char == 'e' && try_read("e;") {
+        return Some(CharRef {
+            name: "e;",
+            characters: "\u{2147}",
+        });
+    }
+
+    if first_char == 'e' && try_read("g;") {
+        return Some(CharRef {
+            name: "g;",
+            characters: "\u{2a9a}",
+        });
+    }
+
+    if first_char == 'e' && try_read("l;") {
+        return Some(CharRef {
+            name: "l;",
+            characters: "\u{2a99}",
+        });
+    }
+
+    if first_char == 'e' && try_read("th") {
+        return Some(CharRef {
+            name: "th",
+            characters: "\u{f0}",
+        });
+    }
+
+    if first_char == 'g' && try_read("E;") {
+        return Some(CharRef {
+            name: "E;",
+            characters: "\u{2267}",
+        });
+    }
+
+    if first_char == 'g' && try_read("e;") {
+        return Some(CharRef {
+            name: "e;",
+            characters: "\u{2265}",
+        });
+    }
+
+    if first_char == 'g' && try_read("g;") {
+        return Some(CharRef {
+            name: "g;",
+            characters: "\u{226b}",
+        });
+    }
+
+    if first_char == 'g' && try_read("l;") {
+        return Some(CharRef {
+            name: "l;",
+            characters: "\u{2277}",
+        });
+    }
+
+    if first_char == 'g' && try_read("t;") {
+        return Some(CharRef {
+            name: "t;",
+            characters: "\u{3e}",
+        });
+    }
+
+    if first_char == 'i' && try_read("c;") {
+        return Some(CharRef {
+            name: "c;",
+            characters: "\u{2063}",
+        });
+    }
+
+    if first_char == 'i' && try_read("i;") {
+        return Some(CharRef {
+            name: "i;",
+            characters: "\u{2148}",
+        });
+    }
+
+    if first_char == 'i' && try_read("n;") {
+        return Some(CharRef {
+            name: "n;",
+            characters: "\u{2208}",
+        });
+    }
+
+    if first_char == 'i' && try_read("t;") {
+        return Some(CharRef {
+            name: "t;",
+            characters: "\u{2062}",
+        });
+    }
+
+    if first_char == 'l' && try_read("E;") {
+        return Some(CharRef {
+            name: "E;",
+            characters: "\u{2266}",
+        });
+    }
+
+    if first_char == 'l' && try_read("e;") {
+        return Some(CharRef {
+            name: "e;",
+            characters: "\u{2264}",
+        });
+    }
+
+    if first_char == 'l' && try_read("g;") {
+        return Some(CharRef {
+            name: "g;",
+            characters: "\u{2276}",
+        });
+    }
+
+    if first_char == 'l' && try_read("l;") {
+        return Some(CharRef {
+            name: "l;",
+            characters: "\u{226a}",
+        });
+    }
+
+    if first_char == 'l' && try_read("t;") {
+        return Some(CharRef {
+            name: "t;",
+            characters: "\u{3c}",
+        });
+    }
+
+    if first_char == 'm' && try_read("p;") {
+        return Some(CharRef {
+            name: "p;",
+            characters: "\u{2213}",
+        });
+    }
+
+    if first_char == 'm' && try_read("u;") {
+        return Some(CharRef {
+            name: "u;",
+            characters: "\u{3bc}",
+        });
+    }
+
+    if first_char == 'n' && try_read("e;") {
+        return Some(CharRef {
+            name: "e;",
+            characters: "\u{2260}",
+        });
+    }
+
+    if first_char == 'n' && try_read("i;") {
+        return Some(CharRef {
+            name: "i;",
+            characters: "\u{220b}",
+        });
+    }
+
+    if first_char == 'n' && try_read("ot") {
+        return Some(CharRef {
+            name: "ot",
+            characters: "\u{ac}",
+        });
+    }
+
+    if first_char == 'n' && try_read("u;") {
+        return Some(CharRef {
+            name: "u;",
+            characters: "\u{3bd}",
+        });
+    }
+
+    if first_char == 'o' && try_read("S;") {
+        return Some(CharRef {
+            name: "S;",
+            characters: "\u{24c8}",
+        });
+    }
+
+    if first_char == 'o' && try_read("r;") {
+        return Some(CharRef {
+            name: "r;",
+            characters: "\u{2228}",
+        });
+    }
+
+    if first_char == 'p' && try_read("i;") {
+        return Some(CharRef {
+            name: "i;",
+            characters: "\u{3c0}",
+        });
+    }
+
+    if first_char == 'p' && try_read("m;") {
+        return Some(CharRef {
+            name: "m;",
+            characters: "\u{b1}",
+        });
+    }
+
+    if first_char == 'p' && try_read("r;") {
+        return Some(CharRef {
+            name: "r;",
+            characters: "\u{227a}",
+        });
+    }
+
+    if first_char == 'r' && try_read("eg") {
+        return Some(CharRef {
+            name: "eg",
+            characters: "\u{ae}",
+        });
+    }
+
+    if first_char == 'r' && try_read("x;") {
+        return Some(CharRef {
+            name: "x;",
+            characters: "\u{211e}",
+        });
+    }
+
+    if first_char == 's' && try_read("c;") {
+        return Some(CharRef {
+            name: "c;",
+            characters: "\u{227b}",
+        });
+    }
+
+    if first_char == 's' && try_read("hy") {
+        return Some(CharRef {
+            name: "hy",
+            characters: "\u{ad}",
+        });
+    }
+
+    if first_char == 'u' && try_read("ml") {
+        return Some(CharRef {
+            name: "ml",
+            characters: "\u{a8}",
+        });
+    }
+
+    if first_char == 'w' && try_read("p;") {
+        return Some(CharRef {
+            name: "p;",
+            characters: "\u{2118}",
+        });
+    }
+
+    if first_char == 'w' && try_read("r;") {
+        return Some(CharRef {
+            name: "r;",
+            characters: "\u{2240}",
+        });
+    }
+
+    if first_char == 'x' && try_read("i;") {
+        return Some(CharRef {
+            name: "i;",
+            characters: "\u{3be}",
+        });
+    }
+
+    if first_char == 'y' && try_read("en") {
+        return Some(CharRef {
+            name: "en",
+            characters: "\u{a5}",
+        });
+    }
+
+    if first_char == 'G' && try_read("T") {
+        return Some(CharRef {
+            name: "T",
+            characters: "\u{3e}",
+        });
+    }
+
+    if first_char == 'L' && try_read("T") {
+        return Some(CharRef {
+            name: "T",
+            characters: "\u{3c}",
+        });
+    }
+
+    if first_char == 'g' && try_read("t") {
+        return Some(CharRef {
+            name: "t",
+            characters: "\u{3e}",
+        });
+    }
+
+    if first_char == 'l' && try_read("t") {
+        return Some(CharRef {
+            name: "t",
+            characters: "\u{3c}",
+        });
+    }
+    None
+}
diff --git a/src/error.rs b/src/error.rs
new file mode 100644
index 0000000..6090fdf
--- /dev/null
+++ b/src/error.rs
@@ -0,0 +1,87 @@
+macro_rules! impl_error {
+    ($(
+        $string:literal <=> $variant:ident,
+    )*) => {
+        /// All [parsing errors](https://html.spec.whatwg.org/#parse-errors) this tokenizer can emit.
+        #[derive(Debug, Eq, PartialEq)]
+        pub enum Error {
+            $(
+                #[doc = "This error corresponds to the `$literal` error found in the WHATWG spec."]
+                $variant
+            ),*
+        }
+        impl std::str::FromStr for Error {
+            type Err = ();
+
+            /// Parse a `kebap-case` error code as typically written in the WHATWG spec into an
+            /// enum variant.
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    $( $string => Ok(Self::$variant), )*
+                    _ => Err(())
+                }
+            }
+        }
+
+        impl std::fmt::Display for Error {
+            /// Convert an enum variant back into the `kebap-case` error code as typically written
+            /// in the WHATWG spec.
+            fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                match *self {
+                    $( Self::$variant => $string.fmt(f), )*
+                }
+            }
+        }
+    }
+}
+
+impl_error! {
+    "abrupt-closing-of-empty-comment" <=> AbruptClosingOfEmptyComment,
+    "abrupt-doctype-public-identifier" <=> AbruptDoctypePublicIdentifier,
+    "abrupt-doctype-system-identifier" <=> AbruptDoctypeSystemIdentifier,
+    "absence-of-digits-in-numeric-character-reference" <=> AbsenceOfDigitsInNumericCharacterReference,
+    "cdata-in-html-content" <=> CdataInHtmlContent,
+    "character-reference-outside-unicode-range" <=> CharacterReferenceOutsideUnicodeRange,
+    "control-character-reference" <=> ControlCharacterReference,
+    "end-tag-with-attributes" <=> EndTagWithAttributes,
+    "end-tag-with-trailing-solidus" <=> EndTagWithTrailingSolidus,
+    "eof-before-tag-name" <=> EofBeforeTagName,
+    "eof-in-cdata" <=> EofInCdata,
+    "eof-in-comment" <=> EofInComment,
+    "eof-in-doctype" <=> EofInDoctype,
+    "eof-in-script-html-comment-like-text" <=> EofInScriptHtmlCommentLikeText,
+    "eof-in-tag" <=> EofInTag,
+    "incorrectly-closed-comment" <=> IncorrectlyClosedComment,
+    "incorrectly-opened-comment" <=> IncorrectlyOpenedComment,
+    "invalid-character-sequence-after-doctype-name" <=> InvalidCharacterSequenceAfterDoctypeName,
+    "invalid-first-character-of-tag-name" <=> InvalidFirstCharacterOfTagName,
+    "missing-attribute-value" <=> MissingAttributeValue,
+    "missing-doctype-name" <=> MissingDoctypeName,
+    "missing-doctype-public-identifier" <=> MissingDoctypePublicIdentifier,
+    "missing-doctype-system-identifier" <=> MissingDoctypeSystemIdentifier,
+    "missing-end-tag-name" <=> MissingEndTagName,
+    "missing-quote-before-doctype-public-identifier" <=> MissingQuoteBeforeDoctypePublicIdentifier,
+    "missing-quote-before-doctype-system-identifier" <=> MissingQuoteBeforeDoctypeSystemIdentifier,
+    "missing-semicolon-after-character-reference" <=> MissingSemicolonAfterCharacterReference,
+    "missing-whitespace-after-doctype-public-keyword" <=> MissingWhitespaceAfterDoctypePublicKeyword,
+    "missing-whitespace-after-doctype-system-keyword" <=> MissingWhitespaceAfterDoctypeSystemKeyword,
+    "missing-whitespace-before-doctype-name" <=> MissingWhitespaceBeforeDoctypeName,
+    "missing-whitespace-between-attributes" <=> MissingWhitespaceBetweenAttributes,
+    "missing-whitespace-between-doctype-public-and-system-identifiers" <=> MissingWhitespaceBetweenDoctypePublicAndSystemIdentifiers,
+    "nested-comment" <=> NestedComment,
+    "noncharacter-character-reference" <=> NoncharacterCharacterReference,
+    "noncharacter-in-input-stream" <=> NoncharacterInInputStream,
+    "null-character-reference" <=> NullCharacterReference,
+    "surrogate-character-reference" <=> SurrogateCharacterReference,
+    "surrogate-in-input-stream" <=> SurrogateInInputStream,
+    "unexpected-character-after-doctype-system-identifier" <=> UnexpectedCharacterAfterDoctypeSystemIdentifier,
+    "unexpected-character-in-attribute-name" <=> UnexpectedCharacterInAttributeName,
+    "unexpected-character-in-unquoted-attribute-value" <=> UnexpectedCharacterInUnquotedAttributeValue,
+    "unexpected-equals-sign-before-attribute-name" <=> UnexpectedEqualsSignBeforeAttributeName,
+    "unexpected-null-character" <=> UnexpectedNullCharacter,
+    "unexpected-question-mark-instead-of-tag-name" <=> UnexpectedQuestionMarkInsteadOfTagName,
+    "unexpected-solidus-in-tag" <=> UnexpectedSolidusInTag,
+    "unknown-named-character-reference" <=> UnknownNamedCharacterReference,
+    "duplicate-attribute" <=> DuplicateAttribute,
+    "control-character-in-input-stream" <=> ControlCharacterInInputStream,
+}
diff --git a/src/lib.rs b/src/lib.rs
new file mode 100644
index 0000000..ef6c9a2
--- /dev/null
+++ b/src/lib.rs
@@ -0,0 +1,2112 @@
+#![deny(missing_docs)]
+// This is an HTML parser. HTML can be untrusted input from the internet.
+#![forbid(unsafe_code)]
+#![doc = include_str!("../README.md")]
+
+mod emitter;
+mod entities;
+mod error;
+mod machine;
+mod reader;
+
+#[cfg(feature = "integration-tests")]
+pub use machine::State;
+#[cfg(not(feature = "integration-tests"))]
+use machine::State;
+
+use machine::{
+    ascii_digit_pat, control_pat, noncharacter_pat, surrogate_pat, whitespace_pat, ControlToken,
+};
+
+pub use emitter::{DefaultEmitter, Doctype, Emitter, EndTag, StartTag, Token};
+pub use reader::{Readable, Reader, StringReader};
+
+pub use error::Error;
+
+macro_rules! ctostr {
+    ($c:expr) => {
+        &*$c.encode_utf8(&mut [0; 4])
+    };
+}
+
+/// A HTML tokenizer. See crate-level docs for basic usage.
+pub struct Tokenizer<R: Reader, E: Emitter = DefaultEmitter> {
+    eof: bool,
+    state: State,
+    emitter: E,
+    temporary_buffer: String,
+    reader: R,
+    to_reconsume: Option<Option<char>>,
+    character_reference_code: u32,
+    return_state: Option<State>,
+}
+
+impl<R: Reader> Tokenizer<R> {
+    /// Create a new tokenizer from some input.
+    ///
+    /// `input` can be `&String` or `&str` at the moment, as those are the types for which
+    /// [`crate::Readable`] is implemented, but you can implement that trait on your own types.
+    ///
+    /// Patches are welcome for providing an efficient implementation over async streams,
+    /// iterators, files, etc, as long as any dependencies come behind featureflags.
+    pub fn new<'a, S: Readable<'a, Reader = R>>(input: S) -> Self {
+        Tokenizer::<S::Reader>::new_with_emitter(input, DefaultEmitter::default())
+    }
+}
+
+impl<R: Reader, E: Emitter> Tokenizer<R, E> {
+    /// Construct a new tokenizer from some input and a custom emitter.
+    ///
+    /// Use this method over [`Tokenizer::new`] when you want to have more control over string allocation for
+    /// tokens.
+    pub fn new_with_emitter<'a, S: Readable<'a, Reader = R>>(input: S, emitter: E) -> Self {
+        Tokenizer {
+            eof: false,
+            state: State::Data,
+            emitter,
+            temporary_buffer: String::new(),
+            to_reconsume: None,
+            reader: input.to_reader(),
+            character_reference_code: 0,
+            return_state: None,
+        }
+    }
+
+    #[cfg(feature = "integration-tests")]
+    /// Test-internal function to override internal state.
+    ///
+    /// Only available with the `integration-tests` feature which is not public API.
+    pub fn set_state(&mut self, state: State) {
+        self.state = state;
+    }
+
+    /// Set the statemachine to start/continue in [plaintext
+    /// state](https://html.spec.whatwg.org/#plaintext-state).
+    ///
+    /// This tokenizer never gets into that state naturally.
+    pub fn set_plaintext_state(&mut self) {
+        self.state = State::PlainText;
+    }
+
+    #[cfg(feature = "integration-tests")]
+    /// Test-internal function to override internal state.
+    ///
+    /// Only available with the `integration-tests` feature which is not public API.
+    pub fn set_last_start_tag(&mut self, last_start_tag: Option<&str>) {
+        self.emitter.set_last_start_tag(last_start_tag);
+    }
+
+    #[inline]
+    fn unread_char(&mut self, c: Option<char>) {
+        self.to_reconsume = Some(c);
+    }
+
+    #[inline]
+    fn validate_char(&mut self, c: char) {
+        match c as u32 {
+            surrogate_pat!() => {
+                self.emitter.emit_error(Error::SurrogateInInputStream);
+            }
+            noncharacter_pat!() => {
+                self.emitter.emit_error(Error::NoncharacterInInputStream);
+            }
+            // control without whitespace or nul
+            x @ control_pat!()
+                if !matches!(x, 0x0000 | 0x0009 | 0x000a | 0x000c | 0x000d | 0x0020) =>
+            {
+                self.emitter
+                    .emit_error(Error::ControlCharacterInInputStream);
+            }
+            _ => (),
+        }
+    }
+
+    fn read_char(&mut self) -> Option<char> {
+        if let Some(c) = self.to_reconsume.take() {
+            return c;
+        }
+
+        let c = self.reader.read_char()?;
+        self.validate_char(c);
+        Some(c)
+    }
+
+    #[inline]
+    fn try_read_string(&mut self, s: &str, case_sensitive: bool) -> bool {
+        debug_assert!(!s.is_empty());
+        debug_assert!(self.to_reconsume.is_none());
+        self.reader.try_read_string(s, case_sensitive)
+    }
+
+    fn is_consumed_as_part_of_an_attribute(&self) -> bool {
+        matches!(
+            self.return_state,
+            Some(
+                State::AttributeValueDoubleQuoted
+                    | State::AttributeValueSingleQuoted
+                    | State::AttributeValueUnquoted
+            )
+        )
+    }
+
+    fn flush_code_points_consumed_as_character_reference(&mut self) {
+        if self.is_consumed_as_part_of_an_attribute() {
+            self.emitter.push_attribute_value(&self.temporary_buffer);
+            self.temporary_buffer.clear();
+        } else {
+            self.flush_buffer_characters();
+        }
+    }
+
+    fn next_input_character(&mut self) -> Option<char> {
+        let rv = self.read_char();
+        self.unread_char(rv);
+        rv
+    }
+
+    fn flush_buffer_characters(&mut self) {
+        self.emitter.emit_string(&self.temporary_buffer);
+        self.temporary_buffer.clear();
+    }
+
+    fn consume(&mut self) -> ControlToken {
+        macro_rules! mutate_character_reference {
+            (* $mul:literal + $x:ident - $sub:literal) => {
+                match self
+                    .character_reference_code
+                    .checked_mul($mul)
+                    .and_then(|cr| cr.checked_add($x as u32 - $sub))
+                {
+                    Some(cr) => self.character_reference_code = cr,
+                    None => {
+                        // provoke err
+                        self.character_reference_code = 0x110000;
+                    }
+                };
+            };
+        }
+
+        match self.state {
+            State::Data => match self.read_char() {
+                Some('&') => {
+                    self.return_state = Some(self.state);
+                    self.state = State::CharacterReference;
+                    ControlToken::Continue
+                }
+                Some('<') => {
+                    self.state = State::TagOpen;
+                    ControlToken::Continue
+                }
+                Some('\0') => {
+                    self.emitter.emit_error(Error::UnexpectedNullCharacter);
+                    self.emitter.emit_string("\0");
+                    ControlToken::Continue
+                }
+                Some(x) => {
+                    self.emitter.emit_string(ctostr!(x));
+                    ControlToken::Continue
+                }
+                None => ControlToken::Eof,
+            },
+            State::RcData => match self.read_char() {
+                Some('&') => {
+                    self.return_state = Some(State::RcData);
+                    self.state = State::CharacterReference;
+                    ControlToken::Continue
+                }
+                Some('<') => {
+                    self.state = State::RcDataLessThanSign;
+                    ControlToken::Continue
+                }
+                Some('\0') => {
+                    self.emitter.emit_error(Error::UnexpectedNullCharacter);
+                    self.emitter.emit_string("\u{fffd}");
+                    ControlToken::Continue
+                }
+                Some(x) => {
+                    self.emitter.emit_string(ctostr!(x));
+                    ControlToken::Continue
+                }
+                None => ControlToken::Eof,
+            },
+            State::RawText => match self.read_char() {
+                Some('<') => {
+                    self.state = State::RawTextLessThanSign;
+                    ControlToken::Continue
+                }
+                Some('\0') => {
+                    self.emitter.emit_error(Error::UnexpectedNullCharacter);
+                    self.emitter.emit_string("\u{fffd}");
+                    ControlToken::Continue
+                }
+                Some(x) => {
+                    self.emitter.emit_string(ctostr!(x));
+                    ControlToken::Continue
+                }
+                None => ControlToken::Eof,
+            },
+            State::ScriptData => match self.read_char() {
+                Some('<') => {
+                    self.state = State::ScriptDataLessThanSign;
+                    ControlToken::Continue
+                }
+                Some('\0') => {
+                    self.emitter.emit_error(Error::UnexpectedNullCharacter);
+                    self.emitter.emit_string("\u{fffd}");
+                    ControlToken::Continue
+                }
+                Some(x) => {
+                    self.emitter.emit_string(ctostr!(x));
+                    ControlToken::Continue
+                }
+                None => ControlToken::Eof,
+            },
+            State::PlainText => match self.read_char() {
+                Some('\0') => {
+                    self.emitter.emit_error(Error::UnexpectedNullCharacter);
+                    self.emitter.emit_string("\u{fffd}");
+                    ControlToken::Continue
+                }
+                Some(x) => {
+                    self.emitter.emit_string(ctostr!(x));
+                    ControlToken::Continue
+                }
+                None => ControlToken::Eof,
+            },
+            State::TagOpen => match self.read_char() {
+                Some('!') => {
+                    self.state = State::MarkupDeclarationOpen;
+                    ControlToken::Continue
+                }
+                Some('/') => {
+                    self.state = State::EndTagOpen;
+                    ControlToken::Continue
+                }
+                Some(x) if x.is_ascii_alphabetic() => {
+                    self.emitter.init_start_tag();
+                    self.state = State::TagName;
+                    self.unread_char(Some(x));
+                    ControlToken::Continue
+                }
+                c @ Some('?') => {
+                    self.emitter
+                        .emit_error(Error::UnexpectedQuestionMarkInsteadOfTagName);
+                    self.emitter.init_comment();
+                    self.state = State::BogusComment;
+                    self.unread_char(c);
+                    ControlToken::Continue
+                }
+                None => {
+                    self.emitter.emit_error(Error::EofBeforeTagName);
+                    self.emitter.emit_string("<");
+                    ControlToken::Eof
+                }
+                c @ Some(_) => {
+                    self.emitter
+                        .emit_error(Error::InvalidFirstCharacterOfTagName);
+                    self.state = State::Data;
+                    self.emitter.emit_string("<");
+                    self.unread_char(c);
+                    ControlToken::Continue
+                }
+            },
+            State::EndTagOpen => match self.read_char() {
+                Some(x) if x.is_ascii_alphabetic() => {
+                    self.emitter.init_end_tag();
+                    self.state = State::TagName;
+                    self.unread_char(Some(x));
+                    ControlToken::Continue
+                }
+                Some('>') => {
+                    self.emitter.emit_error(Error::MissingEndTagName);
+                    self.state = State::Data;
+                    ControlToken::Continue
+                }
+                None => {
+                    self.emitter.emit_error(Error::EofBeforeTagName);
+                    self.emitter.emit_string("</");
+                    ControlToken::Eof
+                }
+                Some(x) => {
+                    self.emitter
+                        .emit_error(Error::InvalidFirstCharacterOfTagName);
+                    self.emitter.init_comment();
+                    self.state = State::BogusComment;
+                    self.unread_char(Some(x));
+                    ControlToken::Continue
+                }
+            },
+            State::TagName => match self.read_char() {
+                Some(whitespace_pat!()) => {
+                    self.state = State::BeforeAttributeName;
+                    ControlToken::Continue
+                }
+                Some('/') => {
+                    self.state = State::SelfClosingStartTag;
+                    ControlToken::Continue
+                }
+                Some('>') => {
+                    self.state = State::Data;
+                    self.emitter.emit_current_tag();
+                    ControlToken::Continue
+                }
+                Some('\0') => {
+                    self.emitter.emit_error(Error::UnexpectedNullCharacter);
+                    self.emitter.push_tag_name("\u{fffd}");
+                    ControlToken::Continue
+                }
+                Some(x) => {
+                    self.emitter.push_tag_name(ctostr!(x.to_ascii_lowercase()));
+                    ControlToken::Continue
+                }
+                None => {
+                    self.emitter.emit_error(Error::EofInTag);
+                    ControlToken::Eof
+                }
+            },
+            State::RcDataLessThanSign => match self.read_char() {
+                Some('/') => {
+                    self.temporary_buffer.clear();
+                    self.state = State::RcDataEndTagOpen;
+                    ControlToken::Continue
+                }
+                c => {
+                    self.emitter.emit_string("<");
+                    self.state = State::RcData;
+                    self.unread_char(c);
+                    ControlToken::Continue
+                }
+            },
+            State::RcDataEndTagOpen => match self.read_char() {
+                Some(x) if x.is_ascii_alphabetic() => {
+                    self.emitter.init_end_tag();
+                    self.state = State::RcDataEndTagName;
+                    self.unread_char(Some(x));
+                    ControlToken::Continue
+                }
+                c => {
+                    self.emitter.emit_string("</");
+                    self.state = State::RcData;
+                    self.unread_char(c);
+                    ControlToken::Continue
+                }
+            },
+            State::RcDataEndTagName => match self.read_char() {
+                Some(whitespace_pat!()) if self.emitter.current_is_appropriate_end_tag_token() => {
+                    self.state = State::BeforeAttributeName;
+                    ControlToken::Continue
+                }
+                Some('/') if self.emitter.current_is_appropriate_end_tag_token() => {
+                    self.state = State::SelfClosingStartTag;
+                    ControlToken::Continue
+                }
+                Some('>') if self.emitter.current_is_appropriate_end_tag_token() => {
+                    self.state = State::Data;
+                    self.emitter.emit_current_tag();
+                    ControlToken::Continue
+                }
+                Some(x) if x.is_ascii_alphabetic() => {
+                    self.emitter.push_tag_name(ctostr!(x.to_ascii_lowercase()));
+                    self.temporary_buffer.push(x);
+                    ControlToken::Continue
+                }
+                c => {
+                    self.emitter.emit_string("</");
+                    self.flush_buffer_characters();
+
+                    self.state = State::RcData;
+                    self.unread_char(c);
+                    ControlToken::Continue
+                }
+            },
+            State::RawTextLessThanSign => match self.read_char() {
+                Some('/') => {
+                    self.temporary_buffer.clear();
+                    self.state = State::RawTextEndTagOpen;
+                    ControlToken::Continue
+                }
+                c => {
+                    self.emitter.emit_string("<");
+                    self.state = State::RawText;
+                    self.unread_char(c);
+                    ControlToken::Continue
+                }
+            },
+            State::RawTextEndTagOpen => match self.read_char() {
+                Some(x) if x.is_ascii_alphabetic() => {
+                    self.emitter.init_end_tag();
+                    self.state = State::RawTextEndTagName;
+                    self.unread_char(Some(x));
+                    ControlToken::Continue
+                }
+                c => {
+                    self.emitter.emit_string("</");
+                    self.state = State::RawText;
+                    self.unread_char(c);
+                    ControlToken::Continue
+                }
+            },
+            State::RawTextEndTagName => match self.read_char() {
+                Some(whitespace_pat!()) if self.emitter.current_is_appropriate_end_tag_token() => {
+                    self.state = State::BeforeAttributeName;
+                    ControlToken::Continue
+                }
+                Some('/') if self.emitter.current_is_appropriate_end_tag_token() => {
+                    self.state = State::SelfClosingStartTag;
+                    ControlToken::Continue
+                }
+                Some('>') if self.emitter.current_is_appropriate_end_tag_token() => {
+                    self.state = State::Data;
+                    self.emitter.emit_current_tag();
+                    ControlToken::Continue
+                }
+                Some(x) if x.is_ascii_alphabetic() => {
+                    self.emitter.push_tag_name(ctostr!(x.to_ascii_lowercase()));
+                    self.temporary_buffer.push(x);
+                    ControlToken::Continue
+                }
+                c => {
+                    self.emitter.emit_string("</");
+                    self.flush_buffer_characters();
+
+                    self.state = State::RawText;
+                    self.unread_char(c);
+                    ControlToken::Continue
+                }
+            },
+            State::ScriptDataLessThanSign => match self.read_char() {
+                Some('/') => {
+                    self.temporary_buffer.clear();
+                    self.state = State::ScriptDataEndTagOpen;
+                    ControlToken::Continue
+                }
+                Some('!') => {
+                    self.state = State::ScriptDataEscapeStart;
+                    self.emitter.emit_string("<!");
+                    ControlToken::Continue
+                }
+                c => {
+                    self.emitter.emit_string("<");
+                    self.state = State::Data;
+                    self.unread_char(c);
+                    ControlToken::Continue
+                }
+            },
+            State::ScriptDataEndTagOpen => match self.read_char() {
+                Some(x) if x.is_ascii_alphabetic() => {
+                    self.emitter.init_end_tag();
+                    self.state = State::ScriptDataEndTagName;
+                    self.unread_char(Some(x));
+                    ControlToken::Continue
+                }
+                c => {
+                    self.emitter.emit_string("</");
+                    self.state = State::ScriptData;
+                    self.unread_char(c);
+                    ControlToken::Continue
+                }
+            },
+            State::ScriptDataEndTagName => match self.read_char() {
+                Some(whitespace_pat!()) if self.emitter.current_is_appropriate_end_tag_token() => {
+                    self.state = State::BeforeAttributeName;
+                    ControlToken::Continue
+                }
+                Some('/') if self.emitter.current_is_appropriate_end_tag_token() => {
+                    self.state = State::SelfClosingStartTag;
+                    ControlToken::Continue
+                }
+                Some('>') if self.emitter.current_is_appropriate_end_tag_token() => {
+                    self.state = State::Data;
+                    self.emitter.emit_current_tag();
+                    ControlToken::Continue
+                }
+                Some(x) if x.is_ascii_alphabetic() => {
+                    self.emitter.push_tag_name(ctostr!(x.to_ascii_lowercase()));
+                    self.temporary_buffer.push(x.to_ascii_lowercase());
+                    ControlToken::Continue
+                }
+                c => {
+                    self.emitter.emit_string("</");
+                    self.flush_buffer_characters();
+                    self.state = State::Data;
+                    self.unread_char(c);
+                    ControlToken::Continue
+                }
+            },
+            State::ScriptDataEscapeStart => match self.read_char() {
+                Some('-') => {
+                    self.state = State::ScriptDataEscapeStartDash;
+                    self.emitter.emit_string("-");
+                    ControlToken::Continue
+                }
+                c => {
+                    self.state = State::ScriptData;
+                    self.unread_char(c);
+                    ControlToken::Continue
+                }
+            },
+            State::ScriptDataEscapeStartDash => match self.read_char() {
+                Some('-') => {
+                    self.state = State::ScriptDataEscapedDashDash;
+                    self.emitter.emit_string("-");
+                    ControlToken::Continue
+                }
+                c => {
+                    self.state = State::ScriptData;
+                    self.unread_char(c);
+                    ControlToken::Continue
+                }
+            },
+            State::ScriptDataEscaped => match self.read_char() {
+                Some('-') => {
+                    self.state = State::ScriptDataEscapedDash;
+                    self.emitter.emit_string("-");
+                    ControlToken::Continue
+                }
+                Some('<') => {
+                    self.state = State::ScriptDataEscapedLessThanSign;
+                    ControlToken::Continue
+                }
+                Some('\0') => {
+                    self.emitter.emit_error(Error::UnexpectedNullCharacter);
+                    self.emitter.emit_string("\u{fffd}");
+                    ControlToken::Continue
+                }
+                None => {
+                    self.emitter
+                        .emit_error(Error::EofInScriptHtmlCommentLikeText);
+                    ControlToken::Eof
+                }
+                Some(x) => {
+                    self.emitter.emit_string(ctostr!(x));
+                    ControlToken::Continue
+                }
+            },
+            State::ScriptDataEscapedDash => match self.read_char() {
+                Some('-') => {
+                    self.state = State::ScriptDataEscapedDashDash;
+                    self.emitter.emit_string("-");
+                    ControlToken::Continue
+                }
+                Some('<') => {
+                    self.state = State::ScriptDataEscapedLessThanSign;
+                    ControlToken::Continue
+                }
+                Some('\0') => {
+                    self.emitter.emit_error(Error::UnexpectedNullCharacter);
+                    self.state = State::ScriptDataEscaped;
+                    self.emitter.emit_string("\u{fffd}");
+                    ControlToken::Continue
+                }
+                None => {
+                    self.emitter
+                        .emit_error(Error::EofInScriptHtmlCommentLikeText);
+                    ControlToken::Eof
+                }
+                Some(x) => {
+                    self.state = State::ScriptDataEscaped;
+                    self.emitter.emit_string(ctostr!(x));
+                    ControlToken::Continue
+                }
+            },
+            State::ScriptDataEscapedDashDash => match self.read_char() {
+                Some('-') => {
+                    self.emitter.emit_string("-");
+                    ControlToken::Continue
+                }
+                Some('<') => {
+                    self.state = State::ScriptDataEscapedLessThanSign;
+                    ControlToken::Continue
+                }
+                Some('>') => {
+                    self.state = State::ScriptData;
+                    self.emitter.emit_string(">");
+                    ControlToken::Continue
+                }
+                Some('\0') => {
+                    self.emitter.emit_error(Error::UnexpectedNullCharacter);
+                    self.state = State::ScriptDataEscaped;
+                    self.emitter.emit_string("\u{fffd}");
+                    ControlToken::Continue
+                }
+                None => {
+                    self.emitter
+                        .emit_error(Error::EofInScriptHtmlCommentLikeText);
+                    ControlToken::Eof
+                }
+                Some(x) => {
+                    self.state = State::ScriptDataEscaped;
+                    self.emitter.emit_string(ctostr!(x));
+                    ControlToken::Continue
+                }
+            },
+            State::ScriptDataEscapedLessThanSign => match self.read_char() {
+                Some('/') => {
+                    self.temporary_buffer.clear();
+                    self.state = State::ScriptDataEscapedEndTagOpen;
+                    ControlToken::Continue
+                }
+                Some(x) if x.is_ascii_alphabetic() => {
+                    self.temporary_buffer.clear();
+                    self.emitter.emit_string("<");
+                    self.state = State::ScriptDataDoubleEscapeStart;
+                    self.unread_char(Some(x));
+                    ControlToken::Continue
+                }
+                c => {
+                    self.emitter.emit_string("<");
+                    self.state = State::ScriptDataEscaped;
+                    self.unread_char(c);
+                    ControlToken::Continue
+                }
+            },
+            State::ScriptDataEscapedEndTagOpen => match self.read_char() {
+                Some(x) if x.is_ascii_alphabetic() => {
+                    self.emitter.init_end_tag();
+                    self.state = State::ScriptDataEscapedEndTagName;
+                    self.unread_char(Some(x));
+                    ControlToken::Continue
+                }
+                c => {
+                    self.emitter.emit_string("</");
+                    self.unread_char(c);
+                    self.state = State::ScriptDataEscaped;
+                    ControlToken::Continue
+                }
+            },
+            State::ScriptDataEscapedEndTagName => match self.read_char() {
+                Some(whitespace_pat!()) if self.emitter.current_is_appropriate_end_tag_token() => {
+                    self.state = State::BeforeAttributeName;
+                    ControlToken::Continue
+                }
+                Some('/') if self.emitter.current_is_appropriate_end_tag_token() => {
+                    self.state = State::SelfClosingStartTag;
+                    ControlToken::Continue
+                }
+                Some('>') if self.emitter.current_is_appropriate_end_tag_token() => {
+                    self.state = State::Data;
+                    self.emitter.emit_current_tag();
+                    ControlToken::Continue
+                }
+                Some(x) if x.is_ascii_alphabetic() => {
+                    self.emitter.push_tag_name(ctostr!(x.to_ascii_lowercase()));
+                    self.temporary_buffer.push(x);
+                    ControlToken::Continue
+                }
+                c => {
+                    self.emitter.emit_string("</");
+                    self.flush_buffer_characters();
+                    self.state = State::ScriptDataEscaped;
+                    self.unread_char(c);
+                    ControlToken::Continue
+                }
+            },
+            State::ScriptDataDoubleEscapeStart => match self.read_char() {
+                Some(x @ whitespace_pat!() | x @ '/' | x @ '>') => {
+                    if self.temporary_buffer == "script" {
+                        self.state = State::ScriptDataDoubleEscaped;
+                    } else {
+                        self.state = State::ScriptDataEscaped;
+                    }
+                    self.emitter.emit_string(ctostr!(x));
+                    ControlToken::Continue
+                }
+                Some(x) if x.is_ascii_alphabetic() => {
+                    self.temporary_buffer.push(x.to_ascii_lowercase());
+                    self.emitter.emit_string(ctostr!(x));
+                    ControlToken::Continue
+                }
+                c => {
+                    self.state = State::ScriptDataEscaped;
+                    self.unread_char(c);
+                    ControlToken::Continue
+                }
+            },
+            State::ScriptDataDoubleEscaped => match self.read_char() {
+                Some('-') => {
+                    self.state = State::ScriptDataDoubleEscapedDash;
+                    self.emitter.emit_string("-");
+                    ControlToken::Continue
+                }
+                Some('<') => {
+                    self.state = State::ScriptDataDoubleEscapedLessThanSign;
+                    self.emitter.emit_string("<");
+                    ControlToken::Continue
+                }
+                Some('\0') => {
+                    self.emitter.emit_error(Error::UnexpectedNullCharacter);
+                    self.emitter.emit_string("\u{fffd}");
+                    ControlToken::Continue
+                }
+                None => {
+                    self.emitter
+                        .emit_error(Error::EofInScriptHtmlCommentLikeText);
+                    ControlToken::Eof
+                }
+                Some(x) => {
+                    self.emitter.emit_string(ctostr!(x));
+                    ControlToken::Continue
+                }
+            },
+            State::ScriptDataDoubleEscapedDash => match self.read_char() {
+                Some('-') => {
+                    self.state = State::ScriptDataDoubleEscapedDashDash;
+                    self.emitter.emit_string("-");
+                    ControlToken::Continue
+                }
+                Some('<') => {
+                    self.state = State::ScriptDataDoubleEscapedLessThanSign;
+                    self.emitter.emit_string("<");
+                    ControlToken::Continue
+                }
+                Some('\0') => {
+                    self.emitter.emit_error(Error::UnexpectedNullCharacter);
+                    self.state = State::ScriptDataDoubleEscaped;
+                    self.emitter.emit_string("\u{fffd}");
+                    ControlToken::Continue
+                }
+                None => {
+                    self.emitter
+                        .emit_error(Error::EofInScriptHtmlCommentLikeText);
+                    ControlToken::Eof
+                }
+                Some(x) => {
+                    self.state = State::ScriptDataDoubleEscaped;
+                    self.emitter.emit_string(ctostr!(x));
+                    ControlToken::Continue
+                }
+            },
+            State::ScriptDataDoubleEscapedDashDash => match self.read_char() {
+                Some('-') => {
+                    self.emitter.emit_string("-");
+                    ControlToken::Continue
+                }
+                Some('<') => {
+                    self.emitter.emit_string("<");
+                    self.state = State::ScriptDataDoubleEscapedLessThanSign;
+                    ControlToken::Continue
+                }
+                Some('>') => {
+                    self.emitter.emit_string(">");
+                    self.state = State::ScriptData;
+                    ControlToken::Continue
+                }
+                Some('\0') => {
+                    self.emitter.emit_error(Error::UnexpectedNullCharacter);
+                    self.state = State::ScriptDataDoubleEscaped;
+                    self.emitter.emit_string("\u{fffd}");
+                    ControlToken::Continue
+                }
+                None => {
+                    self.emitter
+                        .emit_error(Error::EofInScriptHtmlCommentLikeText);
+                    ControlToken::Eof
+                }
+                Some(x) => {
+                    self.state = State::ScriptDataDoubleEscaped;
+                    self.emitter.emit_string(ctostr!(x));
+                    ControlToken::Continue
+                }
+            },
+            State::ScriptDataDoubleEscapedLessThanSign => match self.read_char() {
+                Some('/') => {
+                    self.temporary_buffer.clear();
+                    self.state = State::ScriptDataDoubleEscapeEnd;
+                    self.emitter.emit_string("/");
+                    ControlToken::Continue
+                }
+                c => {
+                    self.state = State::ScriptDataDoubleEscaped;
+                    self.unread_char(c);
+                    ControlToken::Continue
+                }
+            },
+            State::ScriptDataDoubleEscapeEnd => match self.read_char() {
+                Some(x @ whitespace_pat!() | x @ '/' | x @ '>') => {
+                    if self.temporary_buffer == "script" {
+                        self.state = State::ScriptDataEscaped;
+                    } else {
+                        self.state = State::ScriptDataDoubleEscaped;
+                    }
+
+                    self.emitter.emit_string(ctostr!(x));
+                    ControlToken::Continue
+                }
+                Some(x) if x.is_ascii_alphabetic() => {
+                    self.temporary_buffer.push(x.to_ascii_lowercase());
+                    self.emitter.emit_string(ctostr!(x));
+                    ControlToken::Continue
+                }
+                c => {
+                    self.state = State::ScriptDataDoubleEscaped;
+                    self.unread_char(c);
+                    ControlToken::Continue
+                }
+            },
+            State::BeforeAttributeName => match self.read_char() {
+                Some(whitespace_pat!()) => ControlToken::Continue,
+                c @ Some('/' | '>') | c @ None => {
+                    self.state = State::AfterAttributeName;
+                    self.unread_char(c);
+                    ControlToken::Continue
+                }
+                Some('=') => {
+                    self.emitter
+                        .emit_error(Error::UnexpectedEqualsSignBeforeAttributeName);
+                    self.emitter.init_attribute();
+                    self.emitter.push_attribute_name("=");
+                    self.state = State::AttributeName;
+                    ControlToken::Continue
+                }
+                Some(x) => {
+                    self.emitter.init_attribute();
+                    self.state = State::AttributeName;
+                    self.unread_char(Some(x));
+                    ControlToken::Continue
+                }
+            },
+            State::AttributeName => match self.read_char() {
+                c @ Some(whitespace_pat!() | '/' | '>') | c @ None => {
+                    self.state = State::AfterAttributeName;
+                    self.unread_char(c);
+                    ControlToken::Continue
+                }
+                Some('=') => {
+                    self.state = State::BeforeAttributeValue;
+                    ControlToken::Continue
+                }
+                Some('\0') => {
+                    self.emitter.emit_error(Error::UnexpectedNullCharacter);
+                    self.emitter.push_attribute_name("\u{fffd}");
+                    ControlToken::Continue
+                }
+                Some(x @ '"' | x @ '\'' | x @ '<') => {
+                    self.emitter
+                        .emit_error(Error::UnexpectedCharacterInAttributeName);
+                    self.emitter
+                        .push_attribute_name(ctostr!(x.to_ascii_lowercase()));
+                    ControlToken::Continue
+                }
+                Some(x) => {
+                    self.emitter
+                        .push_attribute_name(ctostr!(x.to_ascii_lowercase()));
+                    ControlToken::Continue
+                }
+            },
+            State::AfterAttributeName => match self.read_char() {
+                Some(whitespace_pat!()) => ControlToken::Continue,
+                Some('/') => {
+                    self.state = State::SelfClosingStartTag;
+                    ControlToken::Continue
+                }
+                Some('=') => {
+                    self.state = State::BeforeAttributeValue;
+                    ControlToken::Continue
+                }
+                Some('>') => {
+                    self.state = State::Data;
+                    self.emitter.emit_current_tag();
+                    ControlToken::Continue
+                }
+                None => {
+                    self.emitter.emit_error(Error::EofInTag);
+                    ControlToken::Eof
+                }
+                Some(x) => {
+                    self.emitter.init_attribute();
+                    self.state = State::AttributeName;
+                    self.unread_char(Some(x));
+                    ControlToken::Continue
+                }
+            },
+            State::BeforeAttributeValue => match self.read_char() {
+                Some(whitespace_pat!()) => ControlToken::Continue,
+                Some('"') => {
+                    self.state = State::AttributeValueDoubleQuoted;
+                    ControlToken::Continue
+                }
+                Some('\'') => {
+                    self.state = State::AttributeValueSingleQuoted;
+                    ControlToken::Continue
+                }
+                Some('>') => {
+                    self.emitter.emit_error(Error::MissingAttributeValue);
+                    self.state = State::Data;
+                    self.emitter.emit_current_tag();
+                    ControlToken::Continue
+                }
+                c => {
+                    self.state = State::AttributeValueUnquoted;
+                    self.unread_char(c);
+                    ControlToken::Continue
+                }
+            },
+            State::AttributeValueDoubleQuoted => match self.read_char() {
+                Some('"') => {
+                    self.state = State::AfterAttributeValueQuoted;
+                    ControlToken::Continue
+                }
+                Some('&') => {
+                    self.return_state = Some(State::AttributeValueDoubleQuoted);
+                    self.state = State::CharacterReference;
+                    ControlToken::Continue
+                }
+                Some('\0') => {
+                    self.emitter.emit_error(Error::UnexpectedNullCharacter);
+                    self.emitter.push_attribute_value("\u{fffd}");
+                    ControlToken::Continue
+                }
+                None => {
+                    self.emitter.emit_error(Error::EofInTag);
+                    ControlToken::Eof
+                }
+                Some(x) => {
+                    self.emitter.push_attribute_value(ctostr!(x));
+                    ControlToken::Continue
+                }
+            },
+            State::AttributeValueSingleQuoted => match self.read_char() {
+                Some('\'') => {
+                    self.state = State::AfterAttributeValueQuoted;
+                    ControlToken::Continue
+                }
+                Some('&') => {
+                    self.return_state = Some(State::AttributeValueSingleQuoted);
+                    self.state = State::CharacterReference;
+                    ControlToken::Continue
+                }
+                Some('\0') => {
+                    self.emitter.emit_error(Error::UnexpectedNullCharacter);
+                    self.emitter.push_attribute_value("\u{fffd}");
+                    ControlToken::Continue
+                }
+                None => {
+                    self.emitter.emit_error(Error::EofInTag);
+                    ControlToken::Eof
+                }
+                Some(x) => {
+                    self.emitter.push_attribute_value(ctostr!(x));
+                    ControlToken::Continue
+                }
+            },
+            State::AttributeValueUnquoted => match self.read_char() {
+                Some(whitespace_pat!()) => {
+                    self.state = State::BeforeAttributeName;
+                    ControlToken::Continue
+                }
+                Some('&') => {
+                    self.return_state = Some(State::AttributeValueUnquoted);
+                    self.state = State::CharacterReference;
+                    ControlToken::Continue
+                }
+                Some('>') => {
+                    self.state = State::Data;
+                    self.emitter.emit_current_tag();
+                    ControlToken::Continue
+                }
+                Some('\0') => {
+                    self.emitter.emit_error(Error::UnexpectedNullCharacter);
+                    self.emitter.push_attribute_value("\u{fffd}");
+                    ControlToken::Continue
+                }
+                Some(x @ '"' | x @ '\'' | x @ '<' | x @ '=' | x @ '\u{60}') => {
+                    self.emitter
+                        .emit_error(Error::UnexpectedCharacterInUnquotedAttributeValue);
+                    self.emitter.push_attribute_value(ctostr!(x));
+                    ControlToken::Continue
+                }
+                None => {
+                    self.emitter.emit_error(Error::EofInTag);
+                    ControlToken::Eof
+                }
+                Some(x) => {
+                    self.emitter.push_attribute_value(ctostr!(x));
+                    ControlToken::Continue
+                }
+            },
+            State::AfterAttributeValueQuoted => match self.read_char() {
+                Some(whitespace_pat!()) => {
+                    self.state = State::BeforeAttributeName;
+                    ControlToken::Continue
+                }
+                Some('/') => {
+                    self.state = State::SelfClosingStartTag;
+                    ControlToken::Continue
+                }
+                Some('>') => {
+                    self.state = State::Data;
+                    self.emitter.emit_current_tag();
+                    ControlToken::Continue
+                }
+                None => {
+                    self.emitter.emit_error(Error::EofInTag);
+                    ControlToken::Eof
+                }
+                Some(x) => {
+                    self.emitter
+                        .emit_error(Error::MissingWhitespaceBetweenAttributes);
+                    self.state = State::BeforeAttributeName;
+                    self.unread_char(Some(x));
+                    ControlToken::Continue
+                }
+            },
+            State::SelfClosingStartTag => match self.read_char() {
+                Some('>') => {
+                    self.emitter.set_self_closing();
+                    self.state = State::Data;
+                    self.emitter.emit_current_tag();
+                    ControlToken::Continue
+                }
+                None => {
+                    self.emitter.emit_error(Error::EofInTag);
+                    ControlToken::Eof
+                }
+                Some(x) => {
+                    self.emitter.emit_error(Error::UnexpectedSolidusInTag);
+                    self.state = State::BeforeAttributeName;
+                    self.unread_char(Some(x));
+                    ControlToken::Continue
+                }
+            },
+            State::BogusComment => match self.read_char() {
+                Some('>') => {
+                    self.state = State::Data;
+                    self.emitter.emit_current_comment();
+                    ControlToken::Continue
+                }
+                None => {
+                    self.emitter.emit_current_comment();
+                    ControlToken::Eof
+                }
+                Some('\0') => {
+                    self.emitter.emit_error(Error::UnexpectedNullCharacter);
+                    self.emitter.push_comment("\u{fffd}");
+                    ControlToken::Continue
+                }
+                Some(x) => {
+                    self.emitter.push_comment(ctostr!(x));
+                    ControlToken::Continue
+                }
+            },
+            State::MarkupDeclarationOpen => match self.read_char() {
+                Some('-') if self.try_read_string("-", true) => {
+                    self.emitter.init_comment();
+                    self.state = State::CommentStart;
+                    ControlToken::Continue
+                }
+                Some('d' | 'D') if self.try_read_string("octype", false) => {
+                    self.state = State::Doctype;
+                    ControlToken::Continue
+                }
+                Some('[') if self.try_read_string("CDATA[", true) => {
+                    // missing: check for adjusted current element: we don't have an element stack
+                    // at all
+                    //
+                    // missing: cdata transition
+                    //
+                    // let's hope that bogus comment can just sort of skip over cdata
+                    self.emitter.emit_error(Error::CdataInHtmlContent);
+
+                    self.emitter.init_comment();
+                    self.emitter.push_comment("[CDATA[");
+                    self.state = State::BogusComment;
+                    ControlToken::Continue
+                }
+                c => {
+                    self.emitter.emit_error(Error::IncorrectlyOpenedComment);
+                    self.emitter.init_comment();
+                    self.state = State::BogusComment;
+                    self.unread_char(c);
+                    ControlToken::Continue
+                }
+            },
+            State::CommentStart => match self.read_char() {
+                Some('-') => {
+                    self.state = State::CommentStartDash;
+                    ControlToken::Continue
+                }
+                Some('>') => {
+                    self.emitter.emit_error(Error::AbruptClosingOfEmptyComment);
+                    self.state = State::Data;
+                    self.emitter.emit_current_comment();
+                    ControlToken::Continue
+                }
+                c => {
+                    self.unread_char(c);
+                    self.state = State::Comment;
+                    ControlToken::Continue
+                }
+            },
+            State::CommentStartDash => match self.read_char() {
+                Some('-') => {
+                    self.state = State::CommentEnd;
+                    ControlToken::Continue
+                }
+                Some('>') => {
+                    self.emitter.emit_error(Error::AbruptClosingOfEmptyComment);
+                    self.state = State::Data;
+                    self.emitter.emit_current_comment();
+                    ControlToken::Continue
+                }
+                None => {
+                    self.emitter.emit_error(Error::EofInComment);
+                    self.emitter.emit_current_comment();
+                    ControlToken::Eof
+                }
+                c @ Some(_) => {
+                    self.emitter.push_comment("-");
+                    self.unread_char(c);
+                    self.state = State::Comment;
+                    ControlToken::Continue
+                }
+            },
+            State::Comment => match self.read_char() {
+                Some('<') => {
+                    self.emitter.push_comment("<");
+                    self.state = State::CommentLessThanSign;
+                    ControlToken::Continue
+                }
+                Some('-') => {
+                    self.state = State::CommentEndDash;
+                    ControlToken::Continue
+                }
+                Some('\0') => {
+                    self.emitter.emit_error(Error::UnexpectedNullCharacter);
+                    self.emitter.push_comment("\u{fffd}");
+                    ControlToken::Continue
+                }
+                None => {
+                    self.emitter.emit_error(Error::EofInComment);
+                    self.emitter.emit_current_comment();
+                    ControlToken::Eof
+                }
+                Some(x) => {
+                    self.emitter.push_comment(ctostr!(x));
+                    ControlToken::Continue
+                }
+            },
+            State::CommentLessThanSign => match self.read_char() {
+                Some('!') => {
+                    self.emitter.push_comment("!");
+                    self.state = State::CommentLessThanSignBang;
+                    ControlToken::Continue
+                }
+                Some('<') => {
+                    self.emitter.push_comment("<");
+                    ControlToken::Continue
+                }
+                c => {
+                    self.unread_char(c);
+                    self.state = State::Comment;
+                    ControlToken::Continue
+                }
+            },
+            State::CommentLessThanSignBang => match self.read_char() {
+                Some('-') => {
+                    self.state = State::CommentLessThanSignBangDash;
+                    ControlToken::Continue
+                }
+                c => {
+                    self.unread_char(c);
+                    self.state = State::Comment;
+                    ControlToken::Continue
+                }
+            },
+            State::CommentLessThanSignBangDash => match self.read_char() {
+                Some('-') => {
+                    self.state = State::CommentLessThanSignBangDashDash;
+                    ControlToken::Continue
+                }
+                c => {
+                    self.unread_char(c);
+                    self.state = State::CommentEndDash;
+                    ControlToken::Continue
+                }
+            },
+            State::CommentLessThanSignBangDashDash => match self.read_char() {
+                c @ Some('>') | c @ None => {
+                    self.unread_char(c);
+                    self.state = State::CommentEnd;
+                    ControlToken::Continue
+                }
+                c => {
+                    self.emitter.emit_error(Error::NestedComment);
+                    self.unread_char(c);
+                    self.state = State::CommentEnd;
+                    ControlToken::Continue
+                }
+            },
+            State::CommentEndDash => match self.read_char() {
+                Some('-') => {
+                    self.state = State::CommentEnd;
+                    ControlToken::Continue
+                }
+                None => {
+                    self.emitter.emit_error(Error::EofInComment);
+                    self.emitter.emit_current_comment();
+                    ControlToken::Eof
+                }
+                c => {
+                    self.emitter.push_comment("-");
+                    self.unread_char(c);
+                    self.state = State::Comment;
+                    ControlToken::Continue
+                }
+            },
+            State::CommentEnd => match self.read_char() {
+                Some('>') => {
+                    self.state = State::Data;
+                    self.emitter.emit_current_comment();
+                    ControlToken::Continue
+                }
+                Some('!') => {
+                    self.state = State::CommentEndBang;
+                    ControlToken::Continue
+                }
+                Some('-') => {
+                    self.emitter.push_comment("-");
+                    ControlToken::Continue
+                }
+                None => {
+                    self.emitter.emit_error(Error::EofInComment);
+                    self.emitter.emit_current_comment();
+                    ControlToken::Eof
+                }
+                c @ Some(_) => {
+                    self.emitter.push_comment("-");
+                    self.emitter.push_comment("-");
+                    self.unread_char(c);
+                    self.state = State::Comment;
+                    ControlToken::Continue
+                }
+            },
+            State::CommentEndBang => match self.read_char() {
+                Some('-') => {
+                    self.emitter.push_comment("-");
+                    self.emitter.push_comment("-");
+                    self.emitter.push_comment("!");
+                    self.state = State::CommentEndDash;
+                    ControlToken::Continue
+                }
+                Some('>') => {
+                    self.emitter.emit_error(Error::IncorrectlyClosedComment);
+                    self.state = State::Data;
+                    self.emitter.emit_current_comment();
+                    ControlToken::Continue
+                }
+                None => {
+                    self.emitter.emit_error(Error::EofInComment);
+                    self.emitter.emit_current_comment();
+                    ControlToken::Eof
+                }
+                c @ Some(_) => {
+                    self.emitter.push_comment("-");
+                    self.emitter.push_comment("-");
+                    self.emitter.push_comment("!");
+                    self.state = State::Comment;
+                    self.unread_char(c);
+                    ControlToken::Continue
+                }
+            },
+            State::Doctype => match self.read_char() {
+                Some(whitespace_pat!()) => {
+                    self.state = State::BeforeDoctypeName;
+                    ControlToken::Continue
+                }
+                c @ Some('>') => {
+                    self.unread_char(c);
+                    self.state = State::BeforeDoctypeName;
+                    ControlToken::Continue
+                }
+                None => {
+                    self.emitter.emit_error(Error::EofInDoctype);
+                    self.emitter.init_doctype();
+                    self.emitter.set_force_quirks();
+                    self.emitter.emit_current_doctype();
+                    ControlToken::Eof
+                }
+                c @ Some(_) => {
+                    self.emitter
+                        .emit_error(Error::MissingWhitespaceBeforeDoctypeName);
+                    self.unread_char(c);
+                    self.state = State::BeforeDoctypeName;
+                    ControlToken::Continue
+                }
+            },
+            State::BeforeDoctypeName => match self.read_char() {
+                Some(whitespace_pat!()) => ControlToken::Continue,
+                Some('\0') => {
+                    self.emitter.emit_error(Error::UnexpectedNullCharacter);
+                    self.emitter.init_doctype();
+                    self.emitter.push_doctype_name("\u{fffd}");
+                    self.state = State::DoctypeName;
+                    ControlToken::Continue
+                }
+                Some('>') => {
+                    self.emitter.emit_error(Error::MissingDoctypeName);
+                    self.emitter.init_doctype();
+                    self.emitter.set_force_quirks();
+                    self.state = State::Data;
+                    self.emitter.emit_current_doctype();
+                    ControlToken::Continue
+                }
+                None => {
+                    self.emitter.emit_error(Error::EofInDoctype);
+                    self.emitter.init_doctype();
+                    self.emitter.set_force_quirks();
+                    self.emitter.emit_current_doctype();
+                    ControlToken::Eof
+                }
+                Some(x) => {
+                    self.emitter.init_doctype();
+                    self.emitter
+                        .push_doctype_name(ctostr!(x.to_ascii_lowercase()));
+                    self.state = State::DoctypeName;
+                    ControlToken::Continue
+                }
+            },
+            State::DoctypeName => match self.read_char() {
+                Some(whitespace_pat!()) => {
+                    self.state = State::AfterDoctypeName;
+                    ControlToken::Continue
+                }
+                Some('>') => {
+                    self.state = State::Data;
+                    self.emitter.emit_current_doctype();
+                    ControlToken::Continue
+                }
+                Some('\0') => {
+                    self.emitter.emit_error(Error::UnexpectedNullCharacter);
+                    self.emitter.push_doctype_name("\u{fffd}");
+                    ControlToken::Continue
+                }
+                None => {
+                    self.emitter.emit_error(Error::EofInDoctype);
+                    self.emitter.set_force_quirks();
+                    self.emitter.emit_current_doctype();
+                    ControlToken::Eof
+                }
+                Some(x) => {
+                    self.emitter
+                        .push_doctype_name(ctostr!(x.to_ascii_lowercase()));
+                    ControlToken::Continue
+                }
+            },
+            State::AfterDoctypeName => match self.read_char() {
+                Some(whitespace_pat!()) => ControlToken::Continue,
+                Some('>') => {
+                    self.state = State::Data;
+                    self.emitter.emit_current_doctype();
+                    ControlToken::Continue
+                }
+                None => {
+                    self.emitter.emit_error(Error::EofInDoctype);
+                    self.emitter.set_force_quirks();
+                    self.emitter.emit_current_doctype();
+                    ControlToken::Eof
+                }
+                Some('p' | 'P') if self.try_read_string("ublic", false) => {
+                    self.state = State::AfterDoctypePublicKeyword;
+                    ControlToken::Continue
+                }
+                Some('s' | 'S') if self.try_read_string("ystem", false) => {
+                    self.state = State::AfterDoctypeSystemKeyword;
+                    ControlToken::Continue
+                }
+                c @ Some(_) => {
+                    self.emitter
+                        .emit_error(Error::InvalidCharacterSequenceAfterDoctypeName);
+                    self.emitter.set_force_quirks();
+                    self.unread_char(c);
+                    self.state = State::BogusDoctype;
+                    ControlToken::Continue
+                }
+            },
+            State::AfterDoctypePublicKeyword => match self.read_char() {
+                Some(whitespace_pat!()) => {
+                    self.state = State::BeforeDoctypePublicIdentifier;
+                    ControlToken::Continue
+                }
+                Some('"') => {
+                    self.emitter
+                        .emit_error(Error::MissingWhitespaceAfterDoctypePublicKeyword);
+                    self.emitter.set_doctype_public_identifier("");
+                    self.state = State::DoctypePublicIdentifierDoubleQuoted;
+                    ControlToken::Continue
+                }
+                Some('\'') => {
+                    self.emitter
+                        .emit_error(Error::MissingWhitespaceAfterDoctypePublicKeyword);
+                    self.emitter.set_doctype_public_identifier("");
+                    self.state = State::DoctypePublicIdentifierSingleQuoted;
+                    ControlToken::Continue
+                }
+                Some('>') => {
+                    self.emitter
+                        .emit_error(Error::MissingDoctypePublicIdentifier);
+                    self.emitter.set_force_quirks();
+                    self.state = State::Data;
+                    self.emitter.emit_current_doctype();
+                    ControlToken::Continue
+                }
+                None => {
+                    self.emitter.emit_error(Error::EofInDoctype);
+                    self.emitter.set_force_quirks();
+                    self.emitter.emit_current_doctype();
+                    ControlToken::Eof
+                }
+                c @ Some(_) => {
+                    self.emitter
+                        .emit_error(Error::MissingQuoteBeforeDoctypePublicIdentifier);
+                    self.emitter.set_force_quirks();
+                    self.unread_char(c);
+                    self.state = State::BogusDoctype;
+                    ControlToken::Continue
+                }
+            },
+            State::BeforeDoctypePublicIdentifier => match self.read_char() {
+                Some(whitespace_pat!()) => ControlToken::Continue,
+                Some('"') => {
+                    self.emitter.set_doctype_public_identifier("");
+                    self.state = State::DoctypePublicIdentifierDoubleQuoted;
+                    ControlToken::Continue
+                }
+                Some('\'') => {
+                    self.emitter.set_doctype_public_identifier("");
+                    self.state = State::DoctypePublicIdentifierSingleQuoted;
+                    ControlToken::Continue
+                }
+                Some('>') => {
+                    self.emitter
+                        .emit_error(Error::MissingDoctypePublicIdentifier);
+                    self.emitter.set_force_quirks();
+                    self.state = State::Data;
+                    self.emitter.emit_current_doctype();
+                    ControlToken::Continue
+                }
+                None => {
+                    self.emitter.emit_error(Error::EofInDoctype);
+                    self.emitter.set_force_quirks();
+                    self.emitter.emit_current_doctype();
+                    ControlToken::Eof
+                }
+                c @ Some(_) => {
+                    self.emitter
+                        .emit_error(Error::MissingQuoteBeforeDoctypePublicIdentifier);
+                    self.emitter.set_force_quirks();
+                    self.unread_char(c);
+                    self.state = State::BogusDoctype;
+                    ControlToken::Continue
+                }
+            },
+            State::DoctypePublicIdentifierDoubleQuoted => match self.read_char() {
+                Some('"') => {
+                    self.state = State::AfterDoctypePublicIdentifier;
+                    ControlToken::Continue
+                }
+                Some('\0') => {
+                    self.emitter.emit_error(Error::UnexpectedNullCharacter);
+                    self.emitter.push_doctype_public_identifier("\u{fffd}");
+                    ControlToken::Continue
+                }
+                Some('>') => {
+                    self.emitter
+                        .emit_error(Error::AbruptDoctypePublicIdentifier);
+                    self.emitter.set_force_quirks();
+                    self.state = State::Data;
+                    self.emitter.emit_current_doctype();
+                    ControlToken::Continue
+                }
+                None => {
+                    self.emitter.emit_error(Error::EofInDoctype);
+                    self.emitter.set_force_quirks();
+                    self.emitter.emit_current_doctype();
+                    ControlToken::Eof
+                }
+                Some(x) => {
+                    self.emitter.push_doctype_public_identifier(ctostr!(x));
+                    ControlToken::Continue
+                }
+            },
+            State::DoctypePublicIdentifierSingleQuoted => match self.read_char() {
+                Some('\'') => {
+                    self.state = State::AfterDoctypePublicIdentifier;
+                    ControlToken::Continue
+                }
+                Some('\0') => {
+                    self.emitter.emit_error(Error::UnexpectedNullCharacter);
+                    self.emitter.push_doctype_public_identifier("\u{fffd}");
+                    ControlToken::Continue
+                }
+                Some('>') => {
+                    self.emitter
+                        .emit_error(Error::AbruptDoctypePublicIdentifier);
+                    self.emitter.set_force_quirks();
+                    self.state = State::Data;
+                    self.emitter.emit_current_doctype();
+                    ControlToken::Continue
+                }
+                None => {
+                    self.emitter.emit_error(Error::EofInDoctype);
+                    self.emitter.set_force_quirks();
+                    self.emitter.emit_current_doctype();
+                    ControlToken::Eof
+                }
+                Some(x) => {
+                    self.emitter.push_doctype_public_identifier(ctostr!(x));
+                    ControlToken::Continue
+                }
+            },
+            State::AfterDoctypePublicIdentifier => match self.read_char() {
+                Some(whitespace_pat!()) => {
+                    self.state = State::BetweenDoctypePublicAndSystemIdentifiers;
+                    ControlToken::Continue
+                }
+                Some('>') => {
+                    self.state = State::Data;
+                    self.emitter.emit_current_doctype();
+                    ControlToken::Continue
+                }
+                Some('"') => {
+                    self.emitter.emit_error(
+                        Error::MissingWhitespaceBetweenDoctypePublicAndSystemIdentifiers,
+                    );
+                    self.emitter.set_doctype_system_identifier("");
+                    self.state = State::DoctypeSystemIdentifierDoubleQuoted;
+                    ControlToken::Continue
+                }
+                Some('\'') => {
+                    self.emitter.emit_error(
+                        Error::MissingWhitespaceBetweenDoctypePublicAndSystemIdentifiers,
+                    );
+                    self.emitter.set_doctype_system_identifier("");
+                    self.state = State::DoctypeSystemIdentifierSingleQuoted;
+                    ControlToken::Continue
+                }
+                None => {
+                    self.emitter.emit_error(Error::EofInDoctype);
+                    self.emitter.set_force_quirks();
+                    self.emitter.emit_current_doctype();
+                    ControlToken::Eof
+                }
+                c @ Some(_) => {
+                    self.emitter
+                        .emit_error(Error::MissingQuoteBeforeDoctypeSystemIdentifier);
+                    self.emitter.set_force_quirks();
+                    self.unread_char(c);
+                    self.state = State::BogusDoctype;
+                    ControlToken::Continue
+                }
+            },
+            State::BetweenDoctypePublicAndSystemIdentifiers => match self.read_char() {
+                Some(whitespace_pat!()) => ControlToken::Continue,
+                Some('>') => {
+                    self.state = State::Data;
+                    self.emitter.emit_current_doctype();
+                    ControlToken::Continue
+                }
+                Some('"') => {
+                    self.emitter.set_doctype_system_identifier("");
+                    self.state = State::DoctypeSystemIdentifierDoubleQuoted;
+                    ControlToken::Continue
+                }
+                Some('\'') => {
+                    self.emitter.set_doctype_system_identifier("");
+                    self.state = State::DoctypeSystemIdentifierSingleQuoted;
+                    ControlToken::Continue
+                }
+                None => {
+                    self.emitter.emit_error(Error::EofInDoctype);
+                    self.emitter.set_force_quirks();
+                    self.emitter.emit_current_doctype();
+                    ControlToken::Eof
+                }
+                c @ Some(_) => {
+                    self.emitter
+                        .emit_error(Error::MissingQuoteBeforeDoctypeSystemIdentifier);
+                    self.emitter.set_force_quirks();
+                    self.state = State::BogusDoctype;
+                    self.unread_char(c);
+                    ControlToken::Continue
+                }
+            },
+            State::AfterDoctypeSystemKeyword => match self.read_char() {
+                Some(whitespace_pat!()) => {
+                    self.state = State::BeforeDoctypeSystemIdentifier;
+                    ControlToken::Continue
+                }
+                Some('"') => {
+                    self.emitter
+                        .emit_error(Error::MissingWhitespaceAfterDoctypeSystemKeyword);
+                    self.emitter.set_doctype_system_identifier("");
+                    self.state = State::DoctypeSystemIdentifierDoubleQuoted;
+                    ControlToken::Continue
+                }
+                Some('\'') => {
+                    self.emitter
+                        .emit_error(Error::MissingWhitespaceAfterDoctypeSystemKeyword);
+                    self.emitter.set_doctype_system_identifier("");
+                    self.state = State::DoctypeSystemIdentifierSingleQuoted;
+                    ControlToken::Continue
+                }
+                Some('>') => {
+                    self.emitter
+                        .emit_error(Error::MissingDoctypeSystemIdentifier);
+                    self.emitter.set_force_quirks();
+                    self.state = State::Data;
+                    self.emitter.emit_current_doctype();
+                    ControlToken::Continue
+                }
+                None => {
+                    self.emitter.emit_error(Error::EofInDoctype);
+                    self.emitter.set_force_quirks();
+                    self.emitter.emit_current_doctype();
+                    ControlToken::Eof
+                }
+                c @ Some(_) => {
+                    self.emitter
+                        .emit_error(Error::MissingQuoteBeforeDoctypeSystemIdentifier);
+                    self.emitter.set_force_quirks();
+                    self.state = State::BogusDoctype;
+                    self.unread_char(c);
+                    ControlToken::Continue
+                }
+            },
+            State::BeforeDoctypeSystemIdentifier => match self.read_char() {
+                Some(whitespace_pat!()) => ControlToken::Continue,
+                Some('"') => {
+                    self.emitter.set_doctype_system_identifier("");
+                    self.state = State::DoctypeSystemIdentifierDoubleQuoted;
+                    ControlToken::Continue
+                }
+                Some('\'') => {
+                    self.emitter.set_doctype_system_identifier("");
+                    self.state = State::DoctypeSystemIdentifierSingleQuoted;
+                    ControlToken::Continue
+                }
+                Some('>') => {
+                    self.emitter
+                        .emit_error(Error::MissingDoctypeSystemIdentifier);
+                    self.emitter.set_force_quirks();
+                    self.state = State::Data;
+                    self.emitter.emit_current_doctype();
+                    ControlToken::Continue
+                }
+                None => {
+                    self.emitter.emit_error(Error::EofInDoctype);
+                    self.emitter.set_force_quirks();
+                    self.emitter.emit_current_doctype();
+                    ControlToken::Eof
+                }
+                c @ Some(_) => {
+                    self.emitter
+                        .emit_error(Error::MissingQuoteBeforeDoctypeSystemIdentifier);
+                    self.emitter.set_force_quirks();
+                    self.state = State::BogusDoctype;
+                    self.unread_char(c);
+                    ControlToken::Continue
+                }
+            },
+            State::DoctypeSystemIdentifierDoubleQuoted => match self.read_char() {
+                Some('"') => {
+                    self.state = State::AfterDoctypeSystemIdentifier;
+                    ControlToken::Continue
+                }
+                Some('\0') => {
+                    self.emitter.emit_error(Error::UnexpectedNullCharacter);
+                    self.emitter.push_doctype_system_identifier("\u{fffd}");
+                    ControlToken::Continue
+                }
+                Some('>') => {
+                    self.emitter
+                        .emit_error(Error::AbruptDoctypeSystemIdentifier);
+                    self.emitter.set_force_quirks();
+                    self.state = State::Data;
+                    self.emitter.emit_current_doctype();
+                    ControlToken::Continue
+                }
+                None => {
+                    self.emitter.emit_error(Error::EofInDoctype);
+                    self.emitter.set_force_quirks();
+                    self.emitter.emit_current_doctype();
+                    ControlToken::Eof
+                }
+                Some(x) => {
+                    self.emitter.push_doctype_system_identifier(ctostr!(x));
+                    ControlToken::Continue
+                }
+            },
+            State::DoctypeSystemIdentifierSingleQuoted => match self.read_char() {
+                Some('\'') => {
+                    self.state = State::AfterDoctypeSystemIdentifier;
+                    ControlToken::Continue
+                }
+                Some('\0') => {
+                    self.emitter.emit_error(Error::UnexpectedNullCharacter);
+                    self.emitter.push_doctype_system_identifier("\u{fffd}");
+                    ControlToken::Continue
+                }
+                Some('>') => {
+                    self.emitter
+                        .emit_error(Error::AbruptDoctypeSystemIdentifier);
+                    self.emitter.set_force_quirks();
+                    self.state = State::Data;
+                    self.emitter.emit_current_doctype();
+                    ControlToken::Continue
+                }
+                None => {
+                    self.emitter.emit_error(Error::EofInDoctype);
+                    self.emitter.set_force_quirks();
+                    self.emitter.emit_current_doctype();
+                    ControlToken::Eof
+                }
+                Some(x) => {
+                    self.emitter.push_doctype_system_identifier(ctostr!(x));
+                    ControlToken::Continue
+                }
+            },
+            State::AfterDoctypeSystemIdentifier => match self.read_char() {
+                Some(whitespace_pat!()) => ControlToken::Continue,
+                Some('>') => {
+                    self.state = State::Data;
+                    self.emitter.emit_current_doctype();
+                    ControlToken::Continue
+                }
+                None => {
+                    self.emitter.emit_error(Error::EofInDoctype);
+                    self.emitter.set_force_quirks();
+                    self.emitter.emit_current_doctype();
+                    ControlToken::Eof
+                }
+                c @ Some(_) => {
+                    self.emitter
+                        .emit_error(Error::UnexpectedCharacterAfterDoctypeSystemIdentifier);
+                    self.unread_char(c);
+                    self.state = State::BogusDoctype;
+                    ControlToken::Continue
+                }
+            },
+            State::BogusDoctype => match self.read_char() {
+                Some('>') => {
+                    self.state = State::Data;
+                    self.emitter.emit_current_doctype();
+                    ControlToken::Continue
+                }
+                Some('\0') => {
+                    self.emitter.emit_error(Error::UnexpectedNullCharacter);
+                    ControlToken::Continue
+                }
+                None => {
+                    self.emitter.emit_current_doctype();
+                    ControlToken::Eof
+                }
+                Some(_) => ControlToken::Continue,
+            },
+            State::CdataSection => match self.read_char() {
+                Some(']') => {
+                    self.state = State::CdataSectionBracket;
+                    ControlToken::Continue
+                }
+                None => {
+                    self.emitter.emit_error(Error::EofInCdata);
+                    ControlToken::Eof
+                }
+                Some(x) => {
+                    self.emitter.emit_string(ctostr!(x));
+                    ControlToken::Continue
+                }
+            },
+            State::CdataSectionBracket => match self.read_char() {
+                Some(']') => {
+                    self.state = State::CdataSectionEnd;
+                    ControlToken::Continue
+                }
+                c => {
+                    self.emitter.emit_string("]");
+                    self.state = State::CdataSection;
+                    self.unread_char(c);
+                    ControlToken::Continue
+                }
+            },
+            State::CdataSectionEnd => match self.read_char() {
+                Some(']') => {
+                    self.emitter.emit_string("]");
+                    ControlToken::Continue
+                }
+                Some('>') => {
+                    self.state = State::Data;
+                    ControlToken::Continue
+                }
+                c => {
+                    self.emitter.emit_string("]]");
+                    self.unread_char(c);
+                    self.state = State::CdataSection;
+                    ControlToken::Continue
+                }
+            },
+            State::CharacterReference => {
+                self.temporary_buffer.clear();
+                self.temporary_buffer.push('&');
+                match self.read_char() {
+                    Some(x) if x.is_ascii_alphanumeric() => {
+                        self.unread_char(Some(x));
+                        self.state = State::NamedCharacterReference;
+                        ControlToken::Continue
+                    }
+                    Some('#') => {
+                        self.temporary_buffer.push('#');
+                        self.state = State::NumericCharacterReference;
+                        ControlToken::Continue
+                    }
+                    c => {
+                        self.flush_code_points_consumed_as_character_reference();
+                        self.state = self.return_state.take().unwrap();
+                        self.unread_char(c);
+                        ControlToken::Continue
+                    }
+                }
+            }
+            State::NamedCharacterReference => {
+                let c = self.read_char();
+
+                let char_ref = c.and_then(|x| {
+                    Some((
+                        x,
+                        entities::try_read_character_reference(x, |x| {
+                            self.try_read_string(x, true)
+                        })?,
+                    ))
+                });
+
+                if let Some((x, char_ref)) = char_ref {
+                    self.temporary_buffer.push(x);
+                    self.temporary_buffer.push_str(char_ref.name);
+                    let char_ref_name_last_character = char_ref.name.chars().last();
+                    let next_character = self.next_input_character();
+                    if self.is_consumed_as_part_of_an_attribute()
+                        && char_ref_name_last_character != Some(';')
+                        && matches!(next_character, Some(x) if x == '=' || x.is_ascii_alphanumeric())
+                    {
+                        self.flush_code_points_consumed_as_character_reference();
+                        self.state = self.return_state.take().unwrap();
+                        ControlToken::Continue
+                    } else {
+                        if char_ref_name_last_character != Some(';') {
+                            self.emitter
+                                .emit_error(Error::MissingSemicolonAfterCharacterReference);
+                        }
+
+                        self.temporary_buffer.clear();
+                        self.temporary_buffer.push_str(char_ref.characters);
+                        self.flush_code_points_consumed_as_character_reference();
+                        self.state = self.return_state.take().unwrap();
+                        ControlToken::Continue
+                    }
+                } else {
+                    self.unread_char(c);
+                    self.flush_code_points_consumed_as_character_reference();
+                    self.state = State::AmbiguousAmpersand;
+                    ControlToken::Continue
+                }
+            }
+            State::AmbiguousAmpersand => match self.read_char() {
+                Some(x) if x.is_ascii_alphanumeric() => {
+                    if self.is_consumed_as_part_of_an_attribute() {
+                        self.emitter.push_attribute_value(ctostr!(x));
+                    } else {
+                        self.emitter.emit_string(ctostr!(x));
+                    }
+
+                    ControlToken::Continue
+                }
+                c @ Some(';') => {
+                    self.emitter
+                        .emit_error(Error::UnknownNamedCharacterReference);
+                    self.unread_char(c);
+                    self.state = self.return_state.take().unwrap();
+                    ControlToken::Continue
+                }
+                c => {
+                    self.unread_char(c);
+                    self.state = self.return_state.take().unwrap();
+                    ControlToken::Continue
+                }
+            },
+            State::NumericCharacterReference => {
+                self.character_reference_code = 0;
+                match self.read_char() {
+                    Some(x @ 'x' | x @ 'X') => {
+                        self.temporary_buffer.push(x);
+                        self.state = State::HexadecimalCharacterReferenceStart;
+                        ControlToken::Continue
+                    }
+                    c => {
+                        self.unread_char(c);
+                        self.state = State::DecimalCharacterReferenceStart;
+                        ControlToken::Continue
+                    }
+                }
+            }
+            State::HexadecimalCharacterReferenceStart => match self.read_char() {
+                c @ Some('0'..='9' | 'A'..='F' | 'a'..='f') => {
+                    self.unread_char(c);
+                    self.state = State::HexadecimalCharacterReference;
+                    ControlToken::Continue
+                }
+                c => {
+                    self.emitter
+                        .emit_error(Error::AbsenceOfDigitsInNumericCharacterReference);
+                    self.flush_code_points_consumed_as_character_reference();
+                    self.unread_char(c);
+                    self.state = self.return_state.take().unwrap();
+                    ControlToken::Continue
+                }
+            },
+            State::DecimalCharacterReferenceStart => match self.read_char() {
+                Some(x @ ascii_digit_pat!()) => {
+                    self.unread_char(Some(x));
+                    self.state = State::DecimalCharacterReference;
+                    ControlToken::Continue
+                }
+                c => {
+                    self.emitter
+                        .emit_error(Error::AbsenceOfDigitsInNumericCharacterReference);
+                    self.flush_code_points_consumed_as_character_reference();
+                    self.unread_char(c);
+                    self.state = self.return_state.take().unwrap();
+                    ControlToken::Continue
+                }
+            },
+            State::HexadecimalCharacterReference => match self.read_char() {
+                Some(x @ ascii_digit_pat!()) => {
+                    mutate_character_reference!(*16 + x - 0x0030);
+                    ControlToken::Continue
+                }
+                Some(x @ 'A'..='F') => {
+                    mutate_character_reference!(*16 + x - 0x0037);
+                    ControlToken::Continue
+                }
+                Some(x @ 'a'..='f') => {
+                    mutate_character_reference!(*16 + x - 0x0057);
+                    ControlToken::Continue
+                }
+                Some(';') => {
+                    self.state = State::NumericCharacterReferenceEnd;
+                    ControlToken::Continue
+                }
+                c => {
+                    self.emitter
+                        .emit_error(Error::MissingSemicolonAfterCharacterReference);
+                    self.unread_char(c);
+                    self.state = State::NumericCharacterReferenceEnd;
+                    ControlToken::Continue
+                }
+            },
+            State::DecimalCharacterReference => match self.read_char() {
+                Some(x @ ascii_digit_pat!()) => {
+                    mutate_character_reference!(*10 + x - 0x0030);
+                    ControlToken::Continue
+                }
+                Some(';') => {
+                    self.state = State::NumericCharacterReferenceEnd;
+                    ControlToken::Continue
+                }
+                c => {
+                    self.emitter
+                        .emit_error(Error::MissingSemicolonAfterCharacterReference);
+                    self.unread_char(c);
+                    self.state = State::NumericCharacterReferenceEnd;
+                    ControlToken::Continue
+                }
+            },
+            State::NumericCharacterReferenceEnd => {
+                match self.character_reference_code {
+                    0x00 => {
+                        self.emitter.emit_error(Error::NullCharacterReference);
+                        self.character_reference_code = 0xfffd;
+                    }
+                    0x110000.. => {
+                        self.emitter
+                            .emit_error(Error::CharacterReferenceOutsideUnicodeRange);
+                        self.character_reference_code = 0xfffd;
+                    }
+                    surrogate_pat!() => {
+                        self.emitter.emit_error(Error::SurrogateCharacterReference);
+                        self.character_reference_code = 0xfffd;
+                    }
+                    // noncharacter
+                    noncharacter_pat!() => {
+                        self.emitter
+                            .emit_error(Error::NoncharacterCharacterReference);
+                    }
+                    // 0x000d, or a control that is not whitespace
+                    x @ 0x000d | x @ control_pat!()
+                        if !matches!(x, 0x0009 | 0x000a | 0x000c | 0x0020) =>
+                    {
+                        self.emitter.emit_error(Error::ControlCharacterReference);
+                        self.character_reference_code = match x {
+                            0x80 => 0x20AC, // EURO SIGN (€)
+                            0x82 => 0x201A, // SINGLE LOW-9 QUOTATION MARK (‚)
+                            0x83 => 0x0192, // LATIN SMALL LETTER F WITH HOOK (ƒ)
+                            0x84 => 0x201E, // DOUBLE LOW-9 QUOTATION MARK („)
+                            0x85 => 0x2026, // HORIZONTAL ELLIPSIS (…)
+                            0x86 => 0x2020, // DAGGER (†)
+                            0x87 => 0x2021, // DOUBLE DAGGER (‡)
+                            0x88 => 0x02C6, // MODIFIER LETTER CIRCUMFLEX ACCENT (ˆ)
+                            0x89 => 0x2030, // PER MILLE SIGN (‰)
+                            0x8A => 0x0160, // LATIN CAPITAL LETTER S WITH CARON (Š)
+                            0x8B => 0x2039, // SINGLE LEFT-POINTING ANGLE QUOTATION MARK (‹)
+                            0x8C => 0x0152, // LATIN CAPITAL LIGATURE OE (Œ)
+                            0x8E => 0x017D, // LATIN CAPITAL LETTER Z WITH CARON (Ž)
+                            0x91 => 0x2018, // LEFT SINGLE QUOTATION MARK (‘)
+                            0x92 => 0x2019, // RIGHT SINGLE QUOTATION MARK (’)
+                            0x93 => 0x201C, // LEFT DOUBLE QUOTATION MARK (“)
+                            0x94 => 0x201D, // RIGHT DOUBLE QUOTATION MARK (”)
+                            0x95 => 0x2022, // BULLET (•)
+                            0x96 => 0x2013, // EN DASH (–)
+                            0x97 => 0x2014, // EM DASH (—)
+                            0x98 => 0x02DC, // SMALL TILDE (˜)
+                            0x99 => 0x2122, // TRADE MARK SIGN (™)
+                            0x9A => 0x0161, // LATIN SMALL LETTER S WITH CARON (š)
+                            0x9B => 0x203A, // SINGLE RIGHT-POINTING ANGLE QUOTATION MARK (›)
+                            0x9C => 0x0153, // LATIN SMALL LIGATURE OE (œ)
+                            0x9E => 0x017E, // LATIN SMALL LETTER Z WITH CARON (ž)
+                            0x9F => 0x0178, // LATIN CAPITAL LETTER Y WITH DIAERESIS (Ÿ)
+                            _ => self.character_reference_code,
+                        };
+                    }
+                    _ => (),
+                }
+
+                self.temporary_buffer.clear();
+                self.temporary_buffer
+                    .push(std::char::from_u32(self.character_reference_code).unwrap());
+                self.flush_code_points_consumed_as_character_reference();
+                self.state = self.return_state.take().unwrap();
+                ControlToken::Continue
+            }
+        }
+    }
+}
+
+impl<R: Reader, E: Emitter> Iterator for Tokenizer<R, E> {
+    type Item = E::Token;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        loop {
+            if let Some(token) = self.emitter.pop_token() {
+                break Some(token);
+            } else if !self.eof {
+                match self.consume() {
+                    ControlToken::Continue => (),
+                    ControlToken::Eof => {
+                        self.eof = true;
+                        self.emitter.emit_eof();
+                    }
+                }
+            } else {
+                break None;
+            }
+        }
+    }
+}
diff --git a/src/machine.rs b/src/machine.rs
new file mode 100644
index 0000000..67db1b9
--- /dev/null
+++ b/src/machine.rs
@@ -0,0 +1,164 @@
+macro_rules! surrogate_pat {
+    () => {
+        0xd800..=0xdfff
+    };
+}
+
+pub(crate) use surrogate_pat;
+
+macro_rules! control_pat {
+    () => (0x0d | 0x0000..=0x001f | 0x007f..=0x009f)
+}
+
+pub(crate) use control_pat;
+
+macro_rules! ascii_digit_pat {
+    () => {
+        '0'..='9'
+    };
+}
+
+pub(crate) use ascii_digit_pat;
+
+macro_rules! whitespace_pat {
+    () => {
+        '\t' | '\u{0A}' | '\u{0C}' | ' '
+    };
+}
+
+pub(crate) use whitespace_pat;
+
+macro_rules! noncharacter_pat {
+    () => {
+        0xfdd0
+            ..=0xfdef
+                | 0xfffe
+                | 0xffff
+                | 0x1fffe
+                | 0x1ffff
+                | 0x2fffe
+                | 0x2ffff
+                | 0x3fffe
+                | 0x3ffff
+                | 0x4fffe
+                | 0x4ffff
+                | 0x5fffe
+                | 0x5ffff
+                | 0x6fffe
+                | 0x6ffff
+                | 0x7fffe
+                | 0x7ffff
+                | 0x8fffe
+                | 0x8ffff
+                | 0x9fffe
+                | 0x9ffff
+                | 0xafffe
+                | 0xaffff
+                | 0xbfffe
+                | 0xbffff
+                | 0xcfffe
+                | 0xcffff
+                | 0xdfffe
+                | 0xdffff
+                | 0xefffe
+                | 0xeffff
+                | 0xffffe
+                | 0xfffff
+                | 0x10fffe
+                | 0x10ffff
+    };
+}
+
+pub(crate) use noncharacter_pat;
+
+// When integration tests are running, this enum is public and we get warnings about missing docs.
+// However, it's not actually part of public API.
+#[allow(missing_docs)]
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub enum State {
+    Data,
+    RcData,
+    RawText,
+    ScriptData,
+    PlainText,
+    TagOpen,
+    EndTagOpen,
+    TagName,
+    RcDataLessThanSign,
+    RcDataEndTagOpen,
+    RcDataEndTagName,
+    RawTextLessThanSign,
+    RawTextEndTagOpen,
+    RawTextEndTagName,
+    ScriptDataLessThanSign,
+    ScriptDataEndTagOpen,
+    ScriptDataEndTagName,
+    ScriptDataEscapeStart,
+    ScriptDataEscapeStartDash,
+    ScriptDataEscaped,
+    ScriptDataEscapedDash,
+    ScriptDataEscapedDashDash,
+    ScriptDataEscapedLessThanSign,
+    ScriptDataEscapedEndTagOpen,
+    ScriptDataEscapedEndTagName,
+    ScriptDataDoubleEscapeStart,
+    ScriptDataDoubleEscaped,
+    ScriptDataDoubleEscapedDash,
+    ScriptDataDoubleEscapedDashDash,
+    ScriptDataDoubleEscapedLessThanSign,
+    ScriptDataDoubleEscapeEnd,
+    BeforeAttributeName,
+    AttributeName,
+    AfterAttributeName,
+    BeforeAttributeValue,
+    AttributeValueDoubleQuoted,
+    AttributeValueSingleQuoted,
+    AttributeValueUnquoted,
+    AfterAttributeValueQuoted,
+    SelfClosingStartTag,
+    BogusComment,
+    MarkupDeclarationOpen,
+    CommentStart,
+    CommentStartDash,
+    Comment,
+    CommentLessThanSign,
+    CommentLessThanSignBang,
+    CommentLessThanSignBangDash,
+    CommentLessThanSignBangDashDash,
+    CommentEndDash,
+    CommentEnd,
+    CommentEndBang,
+    Doctype,
+    BeforeDoctypeName,
+    DoctypeName,
+    AfterDoctypeName,
+    AfterDoctypePublicKeyword,
+    BeforeDoctypePublicIdentifier,
+    DoctypePublicIdentifierDoubleQuoted,
+    DoctypePublicIdentifierSingleQuoted,
+    AfterDoctypePublicIdentifier,
+    BetweenDoctypePublicAndSystemIdentifiers,
+    AfterDoctypeSystemKeyword,
+    BeforeDoctypeSystemIdentifier,
+    DoctypeSystemIdentifierDoubleQuoted,
+    DoctypeSystemIdentifierSingleQuoted,
+    AfterDoctypeSystemIdentifier,
+    BogusDoctype,
+    CdataSection,
+    CdataSectionBracket,
+    CdataSectionEnd,
+    CharacterReference,
+    NamedCharacterReference,
+    AmbiguousAmpersand,
+    NumericCharacterReference,
+    HexadecimalCharacterReferenceStart,
+    DecimalCharacterReferenceStart,
+    HexadecimalCharacterReference,
+    DecimalCharacterReference,
+    NumericCharacterReferenceEnd,
+}
+
+pub enum ControlToken {
+    Eof,
+    Continue,
+}
diff --git a/src/reader.rs b/src/reader.rs
new file mode 100644
index 0000000..d2cae92
--- /dev/null
+++ b/src/reader.rs
@@ -0,0 +1,114 @@
+/// An object that provides characters to the tokenizer.
+///
+/// See [`crate::Tokenizer::new`] for more information.
+pub trait Reader {
+    /// Return a new character from the input stream.
+    ///
+    /// Newlines have to be normalized as described in [Preprocessing the input
+    /// stream](https://html.spec.whatwg.org/#preprocessing-the-input-stream), however error
+    /// emission is done within the tokenizer.
+    fn read_char(&mut self) -> Option<char>;
+
+    /// Attempt to read an entire string at once, either case-insensitively or not.
+    ///
+    /// `case_sensitive=false` means that characters of the input stream should be compared while
+    /// ignoring ASCII-casing.
+    ///
+    /// It can be assumed that this function is never called with a string that contains `\r` or
+    /// `\n`.
+    ///
+    /// If the next characters equal to `s`, this function consumes the respective characters from
+    /// the input stream and returns `true`. If not, it does nothing and returns `false`.
+    fn try_read_string(&mut self, s: &str, case_sensitive: bool) -> bool;
+}
+
+/// An object that can be converted into a [`crate::Reader`].
+///
+/// For example, any utf8-string can be converted into a `StringReader`, such that
+/// `Tokenizer::new("mystring")` and `Tokenizer::new(&String::new("foo"))` work.
+pub trait Readable<'a> {
+    /// The reader type to which this type should be converted.
+    type Reader: Reader + 'a;
+
+    /// Convert self to some sort of reader.
+    fn to_reader(self) -> Self::Reader;
+}
+
+impl<'a, R: 'a + Reader> Readable<'a> for R {
+    type Reader = Self;
+
+    fn to_reader(self) -> Self::Reader {
+        self
+    }
+}
+
+/// A helper struct to seek forwards and backwards in strings. Used by the tokenizer to read HTML
+/// from strings.
+pub struct StringReader<'a> {
+    input: &'a str,
+    pos: usize,
+}
+
+impl<'a> StringReader<'a> {
+    fn new(input: &'a str) -> Self {
+        StringReader { input, pos: 0 }
+    }
+
+    fn peek_char(&self) -> Option<char> {
+        self.input.get(self.pos..)?.chars().next()
+    }
+}
+
+impl<'a> Reader for StringReader<'a> {
+    fn read_char(&mut self) -> Option<char> {
+        let mut r1 = match self.peek_char() {
+            Some(x) => x,
+            None => {
+                self.pos += 1;
+                return None;
+            }
+        };
+
+        self.pos += r1.len_utf8();
+
+        if r1 == '\r' {
+            r1 = '\n';
+            let r2 = self.peek_char();
+            if r2 == Some('\n') {
+                self.pos += r2.map(char::len_utf8).unwrap_or(0);
+            }
+        }
+
+        Some(r1)
+    }
+
+    fn try_read_string(&mut self, s1: &str, case_sensitive: bool) -> bool {
+        // we do not need to call validate_char here because `s` hopefully does not contain invalid
+        // characters
+
+        if let Some(s2) = self.input.get(self.pos..self.pos + s1.len()) {
+            if s1 == s2 || (!case_sensitive && s1.eq_ignore_ascii_case(s2)) {
+                self.pos += s1.len();
+                return true;
+            }
+        }
+
+        false
+    }
+}
+
+impl<'a> Readable<'a> for &'a str {
+    type Reader = StringReader<'a>;
+
+    fn to_reader(self) -> Self::Reader {
+        StringReader::new(self)
+    }
+}
+
+impl<'a> Readable<'a> for &'a String {
+    type Reader = StringReader<'a>;
+
+    fn to_reader(self) -> Self::Reader {
+        StringReader::new(self.as_str())
+    }
+}