diff --git a/Project.toml b/Project.toml
index 2b4002b..286502d 100644
--- a/Project.toml
+++ b/Project.toml
@@ -5,12 +5,15 @@ version = "0.4.1"
 
 [deps]
 REPL = "3fa0cd96-eef1-5676-8a61-b3b8758bbffb"
+UnPack = "3a884ed6-31ef-47d7-9d2a-63182c4928ed"
 
 [compat]
+UnPack = "1.0.2"
 julia = "1"
 
 [extras]
 Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40"
+UnPack = "3a884ed6-31ef-47d7-9d2a-63182c4928ed"
 
 [targets]
-test = ["Test"]
+test = ["Test", "UnPack"]
diff --git a/README.md b/README.md
index 1d6b0af..7716a5f 100644
--- a/README.md
+++ b/README.md
@@ -35,6 +35,21 @@ to_frakture
 to_latex
 ```
 
+There are additional styling commands and functions in the `UnicodeMath` submodule. The submodule has its own README.
+```julia-repl
+julia> to_latex("\\symtt{mono}")
+"𝚖𝚘𝚗𝚘"
+```
+Normalization can be enabled with the `to_latex` function so that latin and greek letters adhere to certain styling standards:
+```julia-repl
+julia> glyphstring = "BX 𝐵𝑋 ∇ 𝛁 𝜕 𝝏 𝜶𝜷 αβ 𝚪𝚵 𝜵 az 𝑎𝑧 𝛤𝛯 𝛻 ∂ 𝛛 ΓΞ 𝛼𝛽 1 𝜞𝜩 𝛂𝛃"
+julia> to_latex(glyphstring; normalize=true) # `:tex` standard
+"𝐵𝑋 𝐵𝑋 ∇ 𝛁 𝜕 𝝏 𝜶𝜷 𝛼𝛽 𝚪𝚵 𝛁 𝑎𝑧 𝑎𝑧 ΓΞ ∇ 𝜕 𝝏 ΓΞ 𝛼𝛽 1 𝚪𝚵 𝜶𝜷"
+julia> UnicodeFun.global_config!(; math_style_spec=:iso)
+"𝐵𝑋 𝐵𝑋 ∇ 𝛁 𝜕 𝝏 𝜶𝜷 𝛼𝛽 𝜞𝜩 𝛁 𝑎𝑧 𝑎𝑧 𝛤𝛯 ∇ 𝜕 𝝏 𝛤𝛯 𝛼𝛽 1 𝜞𝜩 𝜶𝜷"
+```
 
 Lookup tables taken from:
 https://github.com/ypsu/latex-to-unicode/tree/master/data
+
+An extra lookup table has been generated from the source file `unicode-math-table.tex` of the `unicode-math` LaTeX package, https://github.com/latex3/unicode-math
\ No newline at end of file
diff --git a/src/UnicodeFun.jl b/src/UnicodeFun.jl
index 25d9066..22b08fa 100644
--- a/src/UnicodeFun.jl
+++ b/src/UnicodeFun.jl
@@ -2,11 +2,64 @@ module UnicodeFun
 
 using REPL
 
+include("UnicodeMath/src/UnicodeMath.jl")
+import .UnicodeMath
+const UCM = UnicodeMath
+import .UnicodeMath: UCMConfig, global_config!
+import .UnicodeMath:
+    symbf, 
+    symsf, 
+    symbfsf,
+    symup,
+    symit,
+    symbfup,
+    symbfit,
+    symsfup,
+    symsfit,
+    symbfsfup,
+    symtt,
+    symbb,
+    symbbit,
+    symcal,
+    symbfcal,
+    symfrak,
+    symbffrak
+
 # Here, we collect and reverse the REPL's latex autocompletion map.
-const symbols_unsorted = [k[2:end] => v[1] for (k, v) in REPL.REPLCompletions.latex_symbols]
+const repl_symbols_unsorted = Dict(
+    k[2:end] => v[1] for (k, v) in REPL.REPLCompletions.latex_symbols
+)
+# Also collect extra symbols defined by submodule UnicodeMath.
+const ucm_symbols_dict = Dict(
+    ucm_cmd.latex_cmd[2:end] => ucm_cmd.glyph for ucm_cmd in values(UCM.extra_commands)
+)
 
+# Collect all symbols, giving precedence to REPL definitions:
+const symbols_unsorted = merge(ucm_symbols_dict, repl_symbols_unsorted) |> pairs |> collect
+# Build substitution list for `to_latex`:
 const latex_symbol_map = sort!(symbols_unsorted, by=(x)-> length(x[1]), rev=true)
 
+# Style modifiers supported by submodule UnicodeMath, sorted:
+const ucm_modifiers = (
+    "symbf",
+    "symsf",
+    "symup",
+    "symit",
+    "symtt",
+    "symbb",
+    "symcal",
+    "symbfsf",
+    "symbfup",
+    "symbfit",
+    "symsfup",
+    "symsfit",
+    "symbbit",
+    "symfrak",
+    "symbfcal",
+    "symbfsfup",
+    "symbffrak",
+)
+
 include("sub_super_scripts.jl")
 export to_superscript, to_subscript
 export to_fraction, to_fraction_nl
diff --git a/src/UnicodeMath/README.md b/src/UnicodeMath/README.md
new file mode 100644
index 0000000..9f796c5
--- /dev/null
+++ b/src/UnicodeMath/README.md
@@ -0,0 +1,139 @@
+# UnicodeMath
+
+A small Julia module inspired by the great LaTeX package 
+[`unicode-math`](https://ctan.org/pkg/unicode-math?lang=en) that is available under 
+[the LaTeX Project Public License 1.3c](https://ctan.org/license/lppl1.3c).
+
+This project is not affiliated to `unicode-math`, the authors of `unicode-math` are 
+not responsible for this code, and do not offer support.
+
+## About
+This module offers configurable Unicode glyph substitutions for Julia `Char`s or `AbstractString`s.
+Specifically, the commands 
+```
+symup           # upright shape
+symit           # italic/slanted shape
+symbfup         # bold upright
+symbfit         # bold italic
+symsfup         # sans-serif upright
+symsfit         # sans-serif italic
+symbfsfup       # bold sans-serif upright
+symtt           # mono spaced
+symbb           # blackboard
+symbbit         # blackboard italic
+symcal             # caligraphic
+symbfcal           # bold caligraphic
+symfrak            # frakture
+symbffrak          # bold frakture
+```
+take as input a `Char` and, if applicable, return the correspondingly styled `Char`, e.g., as defined in the
+[Alphanumeric Symbols Unicode block](https://en.wikipedia.org/wiki/Mathematical_operators_and_symbols_in_Unicode#Mathematical_Alphanumeric_Symbols_block).
+These commands have direct equivalents in the LaTeX package `unicode-math` and are similar to commands in 
+[`UnicodeFun.jl`](https://github.com/SimonDanisch/UnicodeFun.jl):
+```
+to_blackboardbold
+to_boldface
+to_italic
+to_caligraphic
+to_frakture
+to_latex
+```
+
+If there is no symbol defined for the requested style, the input `Char` is returned.
+Input strings are parsed one `Char` at a time.
+
+Internally, we define **alphabets**, e.g.
+```
+:latin      # lower case latin letters
+:Latin      # upper case latin letters
+:greek      # lower case greek letters
+:Greek      # upper case greek letters
+:num        # digits 0-9
+```
+Not every style is available for every character of every alphabet.
+Please refer to the `unicode-math` manual for details, especially Table 7, or check the source file `apply_style.jl`.
+
+Besides the direct substitution commands, there are also 
+```
+_sym        # normalization
+symbf       # bold
+symsf       # sans-serif
+symbfsf     # bold sans-serif
+```
+These commands depend on a style configuration.
+For example, `symbf` could return bold upright glyphs (`:bold_style=:upright`),
+bold italic glyphs (`:bold_style=:italic`) or bold glyphs for which the shape is 
+chosen according to the input shape (`:bold_style=:literal`).
+
+The configuration is expressed by an `UCMConfig` object and is hierarchical.
+The `math_style_spec` value (`:tex` (default), `:iso`, `:french`, `:upright`, `:literal`) induces
+preconfigured values for `normal_style_spec`, `bold_style_spec`, `sans_style` as well as styling
+information for the `:nabla` and `:partial` glyphs.
+Both `normal_style_spec` and `bold_style_spec` in turn define a `normal_style` or `bold_style` 
+values for the latin and greek alphabets.  
+The defaults can be overwritten with the corresponding keyword arguments of the `UCMConfig`
+constructor.
+The following values are valid:
+* `math_style_spec`: `:tex, :iso, :french, :upright, :literal`
+* `normal_style_spec`: `:iso, :tex, :french, :upright, :literal` 
+  or a `NamedTuple` with fields `:Greek, :greek, :Latin, :latin` and values `:upright, :italic, :literal`.
+* `bold_style_spec`: `:iso, :tex, :upright, :literal`
+  or a `NamedTuple` with fields `:Greek, :greek, :Latin, :latin` and values `:upright, :italic, :literal`.
+* `sans_style`, `partial`, `nabla`: `:upright, :italic, :literal`
+
+For `_sym` and the `sym` commands, a global configuration is set via `global_config!(cfg)`
+or `global_config!(; kwargs...)`.
+Alternatively, the lower level `apply_style` function can be called with configuration directly, as shown in the examples.
+
+## Examples
+
+### Basic Formatting
+Use `apply_style` to format a `Char` or an `AbstractString` according to some configuration:
+```julia-repl
+julia> import UnicodeMath as UCM
+julia> src = "BX 𝐵𝑋 ∇ 𝛁 𝜕 𝝏 𝜶𝜷 αβ 𝚪𝚵 𝜵 az 𝑎𝑧 𝛤𝛯 𝛻 ∂ 𝛛 ΓΞ 𝛼𝛽 1 𝜞𝜩 𝛂𝛃"
+julia> cfg_tex = UCM.UCMConfig(; math_style_spec=:tex)
+julia> UCM.apply_style(src, cfg_tex)
+"𝐵𝑋 𝐵𝑋 ∇ 𝛁 𝜕 𝝏 𝜶𝜷 𝛼𝛽 𝚪𝚵 𝛁 𝑎𝑧 𝑎𝑧 ΓΞ ∇ 𝜕 𝝏 ΓΞ 𝛼𝛽 1 𝚪𝚵 𝜶𝜷"
+```
+
+The same keyword arguments that define `UCMConfig` can be given to apply style directly:
+```julia-repl
+julia> UCM.apply_style(src; math_style_spec=:iso)
+"𝐵𝑋 𝐵𝑋 ∇ 𝛁 𝜕 𝝏 𝜶𝜷 𝛼𝛽 𝜞𝜩 𝛁 𝑎𝑧 𝑎𝑧 𝛤𝛯 ∇ 𝜕 𝝏 𝛤𝛯 𝛼𝛽 1 𝜞𝜩 𝜶𝜷"
+julia> UCM.apply_style(src; math_style_spec=:upright)
+"BX BX ∇ 𝛁 ∂ 𝛛 𝛂𝛃 αβ 𝚪𝚵 𝛁 az az ΓΞ ∇ ∂ 𝛛 ΓΞ αβ 1 𝚪𝚵 𝛂𝛃"
+julia> UCM.apply_style(src; math_style_spec=:french)
+"BX BX ∇ 𝛁 ∂ 𝛛 𝛂𝛃 αβ 𝚪𝚵 𝛁 𝑎𝑧 𝑎𝑧 ΓΞ ∇ ∂ 𝛛 ΓΞ αβ 1 𝚪𝚵 𝛂𝛃"
+```
+
+### Target Style
+
+A target style can be forced. 
+```julia-repl
+julia> UCM.apply_style(src, :bfup; math_style_spec=:iso)
+"𝐁𝐗 𝐁𝐗 𝛁 𝛁 𝛛 𝛛 𝛂𝛃 𝛂𝛃 𝚪𝚵 𝛁 𝐚𝐳 𝐚𝐳 𝚪𝚵 𝛁 𝛛 𝛛 𝚪𝚵 𝛂𝛃 𝟏 𝚪𝚵 𝛂𝛃"
+```
+
+The styles `:bf`, `:sf` and `:bfsf` still depend on the configuration:
+```julia-repl
+julia> UCM.apply_style(src, :bf; math_style_spec=:iso)
+"𝑩𝑿 𝑩𝑿 𝛁 𝛁 𝝏 𝝏 𝜶𝜷 𝜶𝜷 𝚪𝚵 𝜵 𝒂𝒛 𝒂𝒛 𝜞𝜩 𝛁 𝝏 𝛛 𝜞𝜩 𝜶𝜷 𝟏 𝜞𝜩 𝛂𝛃"
+```
+In this example, bold glyphs have not been changed, otherwise bold italic glyphs for latin and greek letters are used.
+
+### Global Commands
+Apply default styling (`math_style_spec=:tex`), i.e., italic regular-weight letters, except for uppercase Greek letters, which are printed upright, and upright bold-weight letters, except for lowercase greek, which are printed slanted:
+```julia-repl
+julia>UCM._sym(src)
+"𝐵𝑋 𝐵𝑋 ∇ 𝛁 𝜕 𝝏 𝜶𝜷 𝛼𝛽 𝚪𝚵 𝛁 𝑎𝑧 𝑎𝑧 ΓΞ ∇ 𝜕 𝝏 ΓΞ 𝛼𝛽 1 𝚪𝚵 𝜶𝜷"
+```
+Change the configuration:
+```julia-repl
+julia>UCM.global_config!(;normal_style_spec=:upright)
+```
+Now regular-weight letters are all upright:
+```julia-repl
+julia>UCM._sym(src)
+"BX BX ∇ 𝛁 𝜕 𝝏 𝜶𝜷 αβ 𝚪𝚵 𝛁 az az ΓΞ ∇ 𝜕 𝝏 ΓΞ αβ 1 𝚪𝚵 𝜶𝜷"
+```
\ No newline at end of file
diff --git a/src/UnicodeMath/src/UnicodeMath.jl b/src/UnicodeMath/src/UnicodeMath.jl
new file mode 100644
index 0000000..d90dbae
--- /dev/null
+++ b/src/UnicodeMath/src/UnicodeMath.jl
@@ -0,0 +1,197 @@
+"""
+    UnicodeMath
+
+A Julia package inspired by the great LaTeX package `unicode-math`.
+As a user you should care mainly about [`apply_style`](@ref) and the globally
+configured functions [`_sym`](@ref) and `symbf`, `symit`, etc.
+The latter are configured with [`global_config!`](@ref)
+"""
+module UnicodeMath
+#=
+# Typography Terminology
+
+When it comes to typography, common concepts have different names in different contexts.
+Here is what Wikipedia has to say about “typeface” and “font”:
+
+> A typeface (or font family) is a design of letters, numbers and other symbols, 
+> to be used in printing or for electronic display.
+> Most typefaces include variations in size (e.g., 24 point), weight (e.g., light, bold), 
+> slope (e.g., italic), width (e.g., condensed), and so on. 
+> Each of these variations of the typeface is a font.
+
+  Wikipedia contributors, "Typeface," Wikipedia, The Free Encyclopedia, 
+  https://en.wikipedia.org/w/index.php?title=Typeface&oldid=1309901840 
+  (accessed September 24, 2025).
+
+E.g., “Times” is a typeface family, and “Times Roman” and “Times Italic” are 
+typefaces/font families within that typeface, and “Times Roman 10” is a font within 
+the typeface “Times Roman”.
+
+According to https://texdoc.org/serve/fntguide/0, LaTeX uses 
+* “family” to refer to a typeface/font family, e.g. “CMU Serif”,
+* “series” for weight and spacing,
+* “shape” is the form of the letters, e.g., “italic” or “upright”.
+Together with “size”, a font can be selected.
+
+For maths, commands such as `\mathbf` are defined via
+`\DeclareMathAlphabet {⟨math-alph⟩} {⟨encoding⟩} {⟨family⟩} {⟨series⟩} {⟨shape⟩}`.
+Hence, a “math-alphabet” is really just a specific font 
+(that has glyphs for a subset of mathematical characters).
+In `unicode-math`, the new wrapper command is aptly named `\setmathfontface`.
+It is okay to use “alphabet” in a hand-wavy manner, because even Wikipedia and 
+package documentation does so.
+
+> Every typeface is a collection of glyphs, each of which represents an individual 
+> letter, number, punctuation mark, or other symbol. 
+> The same glyph may be used for characters from different writing systems, 
+> e.g. Roman uppercase A looks the same as Cyrillic uppercase А and Greek uppercase alpha (Α). 
+> There are typefaces tailored for special applications, such as cartography, astrology or mathematics.
+
+  Wikipedia contributors, "Typeface," Wikipedia, The Free Encyclopedia, 
+  https://en.wikipedia.org/w/index.php?title=Typeface&oldid=1309901840 
+  (accessed September 24, 2025).
+
+In accordance with https://en.wikipedia.org/wiki/Glyph, the concept of a letter, number, etc.
+is a grapheme-like unit, or an (abstract) character.
+A glyph is its graphical representation.
+
+In Unicode, collections of characters often form 
+[scripts](https://en.wikipedia.org/wiki/Script_(Unicode)),
+and usually, style information is not encoded in scripts.
+
+Except for math charactes, **which do not constitute a script**.
+Unicode has various styles for many mathematical characters.
+For example, the abstract character “A” has styled variants
+“𝐀” (MATHEMATICAL BOLD CAPITAL A) or “𝐴” (MATHEMATICAL ITALIC CAPITAL A).
+Usually style variants (series or shape) would be provided by different fontfaces,
+but math fonts contain these stylized variants themselves.
+
+The LaTeX package `unicode-math` has commands like `\symbf` that map between different
+styles and emulate legacy commands, but do not switch fontfaces for mathematical characters
+that have style variants.
+
+# ## Package Naming Conventions 
+
+We mimic some of the functionality of `unicode-math` for string formatting in Julia.
+To this end, we define our own “alphabets”, which are sets of abstract characters.
+E.g. `:num` are numbers, `:latin` are lowercase Latin characters, and `:Greek` 
+are uppercase Greek characters. 
+There are also singleton sets to allow for granular configuration.
+
+Within an alphabet each abstract character has a unique “name”, i.e. "1" or "a" or "Alpha".
+
+Then there are styles, i.e., combinations of series and shape properties.
+A math font can provide glyphs for styles defined in `base_styles` for the characters in our 
+alphabets.
+There are styles like `:bf` (bold) or `:sf` (sans-serif) for which the mapping is 
+more complicated.
+We might wish to have bold italic letters by default, i.e., `:bf` should alias `:bfit`
+depending on a (global) configuration.
+
+For us, specific fonts are not relevant, so we call the Unicode characters that are mapped 
+“glyphs”.
+It is unavoidable that sometimes the terms “character”/“glyph”/“symbol” are used 
+synonymously, but hopefully context disolves confusion.
+It doesn't help that Julia has types `Symbol` and `Char`.
+Indeed, a glyph is represented by a `Char`.
+=#
+
+# # Simple Global Definitions
+# External Dependencies:
+import UnPack: @unpack
+
+# Simple Type Constants:
+const Nothymbol = Union{Nothing, Symbol}
+const SpecTup = @NamedTuple{Greek::Symbol, greek::Symbol, Latin::Symbol, latin::Symbol}
+
+# # Extra LaTeX Commands
+# Include standalone file defining `extra_commands::Dict{Symbol,UCMCommand}`.
+# The dict has custom commands defined in `unicode-math` 
+# which are extracted from the LaTeX source code.  
+include("extra_commands.jl")  # `extra_commands`
+
+# # Styling
+# Symbols for base styles  (excluding derived styles like `bf`, `sf`, `bfsfup`):
+const base_styles = (
+    :up, :it,  
+    :bfup, :bfit, 
+    :sfup, :sfit, 
+    :bfsfup, :bfsfit, 
+    :tt, 
+    :bb, :bbit,
+    :cal, :bfcal, 
+    :frak, :bffrak
+)
+
+# Symbols for every possible style:
+const all_styles = (base_styles..., :bf, :sf, :bfsf)
+
+# Alphabet definitions:
+include("ucmchars.jl")
+const Glyph = Union{Char, UCMChar}
+
+# A nested dict that is needed for mapping between styles:
+const ucmchars_by_alphabet_style_name = all_ucmchars()
+# A dict mapping `Char`s to `UCMChar`s (which store meta data):
+const chars_to_ucmchars = inverse_ucm_dict(ucmchars_by_alphabet_style_name)
+
+# The basic styling command, needing configuration:
+include("apply_style.jl")
+
+# ## Global Styling Commands
+# Prepare defaults for global styling commands:
+const default_config_dicts = config_dicts()
+const default_substitutions = default_config_dicts.substitutions
+const default_aliases = default_config_dicts.aliases
+
+# Store internal references so that the actual config dicts can be modified:
+const default_substitutions_ref = Ref(default_substitutions)
+const default_aliases_ref = Ref(default_aliases)
+
+"""
+    global_config!(; kwargs...)
+    global_config!(cfg::UCMConfig)
+
+Configure how styling functions such as `symbf` act.
+Take the same keyword arguments as [`UCMConfig`](@ref).
+"""
+function global_config!(; kwargs...)
+    global default_substitutions_ref, default_aliases_ref
+    s, a = config_dicts(; kwargs...)
+    default_substitutions_ref[] = s
+    default_aliases_ref[] = a
+    return nothing
+end
+
+function global_config!(cfg::UCMConfig)
+    @unpack math_style_spec, normal_style_spec, bold_style_spec, sans_style, partial, nabla = cfg
+    return global_config!(; 
+        math_style_spec, normal_style_spec, bold_style_spec, sans_style, partial, nabla)
+end
+
+# Basic global styling command:
+"""
+    _sym(glyph::Union{Char, UCMChar, AbstractString})
+    _sym(glyph::Union{Char, UCMChar, AbstractString}, trgt_style::Symbol)
+
+Try to style `glyph` according to global configuration, which is set by 
+[`global_config!`](@ref).
+"""
+function _sym(x::Union{AbstractString,Glyph}, trgt_style::Symbol...)
+    global default_substitutions_ref, default_aliases_ref
+
+    return apply_style(
+        x,
+        default_substitutions_ref[],
+        default_aliases_ref[],
+        trgt_style...
+    )
+end
+
+# Derive specific styling functions like `symbf`:
+for sn in all_styles
+    f = Symbol("sym", sn)
+    @eval $f(x::Union{AbstractString, Glyph}) = _sym(x, $(Meta.quot(sn)))
+end
+
+end#module
\ No newline at end of file
diff --git a/src/UnicodeMath/src/apply_style.jl b/src/UnicodeMath/src/apply_style.jl
new file mode 100644
index 0000000..e58dba7
--- /dev/null
+++ b/src/UnicodeMath/src/apply_style.jl
@@ -0,0 +1,527 @@
+const EMPTY_DICT = Base.ImmutableDict{Nothing, Nothing}()
+
+# There are several parameters that influence how glyphs are mapped.
+
+# A **normal style** defines how a user typed character in a standard style 
+# (`:up` or `it`) is mapped to glyphs.
+# `:italic` forces italic glyphs, `:upright` forces upright glyphs,
+# `:literal` does not change style.
+# Similarly, a **bold style** specifies whether or not bold glyphs are upright or
+# slanted. Same for **sans style**.
+# Special alphabets (`partial`, `nabla`) can be configured, too. 
+#
+# A normal style specification (:iso, :tex, ...) assigns normal styles to glyphs from 
+# certain alphabets, and a bold style specification assigns bold styles to glyphs from 
+# certain alphabets.
+#
+# On the top level, a math style specification sets normal and bold style specifications 
+# and styles for the other alphabets.
+
+"""
+    UCMConfig(; math_style_spec = :tex, kwargs...)
+
+Styling configuration. The keywords `normal_style_spec`, `bold_style_spec`, `sans_style`,
+`partial` and `nabla` can be used to override defaults set by `math_style_spec`.
+"""
+Base.@kwdef struct UCMConfig
+    math_style_spec :: Nothymbol = :tex
+    ## overrides
+    normal_style_spec :: Union{SpecTup,Nothymbol} = nothing
+    bold_style_spec :: Union{SpecTup,Nothymbol} = nothing
+    sans_style :: Nothymbol = nothing
+    partial :: Nothymbol = nothing
+    nabla :: Nothymbol = nothing
+end
+
+"""
+    apply_style(cfg::UCMConfig, glyph::Char)
+    apply_style(cfg::UCMConfig, glyph::Char, trgt_style::Symbol)
+    apply_style(glyph::Char; kwargs...)
+    apply_style(glyph::Char, trgt_style::Symbol; kwargs...)
+
+Stylize glyph according to configuration `cfg` or keyword arguments."""
+function apply_style(ch::Char, args...; kwargs...)
+    ucm_ch = get(chars_to_ucmchars, ch, nothing)
+    isnothing(ucm_ch) && return ch
+    _ucm_ch = apply_style(ucm_ch, args...; kwargs...)
+    return _ucm_ch.glyph
+end
+
+function apply_style(
+    ucm_ch::UCMChar, cfg::UCMConfig, trgt_style::Symbol...
+)
+    @unpack math_style_spec, normal_style_spec, bold_style_spec, sans_style, partial, nabla = cfg
+    @unpack substitutions, aliases = config_dicts(; 
+        math_style_spec, normal_style_spec, bold_style_spec, sans_style, partial, nabla)
+    return apply_style(ucm_ch, substitutions, aliases, trgt_style...)
+end
+
+function apply_style(ucm_ch::UCMChar, trgt_style::Symbol...; kwargs...)
+    cfg = UCMConfig(; kwargs...)
+    return apply_style(ucm_ch, cfg, trgt_style...)
+end
+
+function apply_style(
+    ucm_ch::UCMChar, substitutions::AbstractDict, aliases::AbstractDict
+)
+    trgt_style = _typed_style(ucm_ch.style)
+    return apply_style(ucm_ch, substitutions, aliases, trgt_style)
+end
+
+function _typed_style(symb)
+    _symb = if symb == :up
+        ## check normal style 
+        :UP
+    elseif symb == :it
+        ## check normal style 
+        :IT
+    elseif symb == :bfup
+        ## check bold style 
+        :BFUP
+    elseif symb == :bfit
+        ## check bold style 
+        :BFIT
+    elseif symb == :sfup
+        ## check sans style 
+        :SFUP
+    elseif symb == :sfit
+        ## check sans style 
+        :SFIT
+    elseif symb == :bfsfup
+        ## check sans style 
+        :BFSFUP
+    elseif symb == :bfsfit
+        ## check sans style 
+        :BFSFIT
+    else
+        symb
+    end
+    return _symb
+end
+
+function apply_style(
+    ucm_ch::UCMChar, substitutions::AbstractDict, aliases::AbstractDict, trgt_style::Symbol
+)
+    subs_alphabet = get(substitutions, ucm_ch.alphabet, EMPTY_DICT)
+    subs_current_style = get(subs_alphabet, ucm_ch.style, EMPTY_DICT)
+    trgt_style = get(subs_current_style, trgt_style, trgt_style)
+    
+    alisaes_alphabet = get(aliases, ucm_ch.alphabet, EMPTY_DICT)
+    trgt_style = get(alisaes_alphabet, trgt_style, trgt_style)
+    
+    return _choose_style(ucm_ch, trgt_style)
+end
+
+function apply_style(
+    io::IO, ch::Glyph, args...; kwargs...
+)
+    print(io, apply_style(ch, args...; kwargs...))
+end
+
+function apply_style(io::IO, str::AbstractString, args...; kwargs...)
+    cls = ch -> apply_style(ch, args...; kwargs...)
+    for ch in str
+        print(io, cls(ch))
+    end
+end
+
+function apply_style(str::AbstractString, args...; kwargs...)
+    sprint() do io
+        apply_style(io, str, args...; kwargs...)
+    end
+end
+
+## helper function -- given `ucm_ch::UCMChar` and a target style like `:bf`,
+## return the corresponding `UCMChar` from the styled alphabet, if it is available for `ucm_ch`.
+function _choose_style(ucm_ch, style_symb)
+    _ucm_ch = _choose_style(ucm_ch.name, ucm_ch.alphabet, style_symb)
+    isnothing(_ucm_ch) && return ucm_ch
+    return _ucm_ch
+end
+
+function _choose_style(name_str, alphabet_symb, style_symb)
+    global ucmchars_by_alphabet_style_name
+    ## check if the alphabet is key for outer dict:
+    ucmchars_by_style_name = get(ucmchars_by_alphabet_style_name, alphabet_symb, nothing)
+    isnothing(ucmchars_by_style_name) && return nothing
+
+    ## check if target style is key in 2nd level:
+    ucmchars_by_name = get(ucmchars_by_style_name, style_symb, nothing)
+    isnothing(ucmchars_by_name) && return nothing
+
+    ## inner dict has `name => UCMChar` entries for target style.
+    ## return value if it exists
+    ucm_ch = get(ucmchars_by_name, name_str, nothing)
+    return ucm_ch
+end
+
+function parse_config(;
+    math_style_spec=:tex,
+    normal_style_spec=nothing,
+    bold_style_spec=nothing,
+    sans_style=nothing,
+    partial=nothing,
+    nabla=nothing
+)
+    cfg = if math_style_spec == :iso
+        (;
+            nabla = :upright,
+            partial = :italic,
+            normal_style_spec = :iso,
+            bold_style_spec = :iso,
+            sans_style = :italic
+        )
+    elseif math_style_spec == :tex
+        (;
+            nabla = :upright,
+            partial = :italic,
+            normal_style_spec = :tex,
+            bold_style_spec = :tex,
+            sans_style = :upright
+        )
+     elseif math_style_spec == :french
+        (;
+            nabla = :upright,
+            partial = :upright,
+            normal_style_spec = :french,
+            bold_style_spec = :upright,
+            sans_style = :upright
+        )
+    elseif math_style_spec == :upright
+        (;
+            nabla = :upright,
+            partial = :upright,
+            normal_style_spec = :upright,
+            bold_style_spec = :upright,
+            sans_style = :upright
+        )
+   else
+        (;
+            nabla = :literal,
+            partial = :literal,
+            normal_style_spec = :literal,
+            bold_style_spec = :literal,
+            sans_style = :literal
+        )
+    end
+    normal_style_spec = isnothing(normal_style_spec) ? cfg.normal_style_spec : normal_style_spec
+    bold_style_spec = isnothing(bold_style_spec) ? cfg.bold_style_spec : bold_style_spec
+    sans_style = isnothing(sans_style) ? cfg.sans_style : sans_style
+    partial = isnothing(partial) ? cfg.partial : partial
+    nabla = isnothing(nabla) ? cfg.nabla : nabla
+    return (; nabla, partial, normal_style_spec, bold_style_spec, sans_style)
+end
+
+function config_dicts(; kwargs...)
+    cfg = parse_config(; kwargs...)
+    substitutions = alphabet_substitutions(; cfg...)
+
+    aliases_num = Dict(
+        :it => :up,
+        :bf => :bfup,
+        :bfit => :bfup,
+        :sf => :sfup,
+        :sfit => :sfup,
+        :bfsf => :bfsfup,
+        :bfsfit => :bfsfup,
+        :bbit => :bb    # this is different from LaTeX package
+    )
+    aliases = Dict(
+        :num => aliases_num
+    )
+    
+    return (; substitutions, aliases)
+end
+
+# For a given alphabet, we generate a “substitutions dict (of dicts)” to map between styles.
+# It is a bit verbose, but simple and we avoid recursion this way:
+function alphabet_substitutions(;
+    normal_style_spec,
+    bold_style_spec,
+    sans_style,
+    partial,
+    nabla
+)
+    ns = parse_normal_style_spec(normal_style_spec)
+    bs = parse_bold_style_spec(bold_style_spec)
+    subs = Dict(
+        :num => _subtitutions_dict(; normal_style=:upright, bold_style=:upright, sans_style=:upright),
+        :Greek => _subtitutions_dict(; normal_style=ns.Greek, bold_style=bs.Greek, sans_style),
+        :greek => _subtitutions_dict(; normal_style=ns.greek, bold_style=bs.greek, sans_style),
+        :Latin => _subtitutions_dict(; normal_style=ns.Latin, bold_style=bs.Latin, sans_style),
+        :latin => _subtitutions_dict(; normal_style=ns.latin, bold_style=bs.latin, sans_style),
+        :partial => _subtitutions_dict(; normal_style=partial, bold_style=partial, sans_style=partial),
+        :Nabla => _subtitutions_dict(; normal_style=nabla, bold_style=nabla, sans_style=nabla),
+    )
+    subs[:dotless] = subs[:latin]
+    
+    return subs
+end
+
+# A normal style (:iso, :tex, :french, :upright) assigns normal style specification to alphabets:
+function parse_normal_style_spec(normal_style_spec::Symbol)
+    normal_style_ntup = if normal_style_spec == :iso
+        (;
+            Greek = :italic,
+            greek = :italic,
+            Latin = :italic,
+            latin = :italic
+        )
+    elseif normal_style_spec == :tex
+        (;
+            Greek = :upright,
+            greek = :italic,
+            Latin = :italic,
+            latin = :italic
+        )
+    elseif normal_style_spec == :french
+        (;
+            Greek = :upright,
+            greek = :upright,
+            Latin = :upright,
+            latin = :italic
+        )
+    elseif normal_style_spec == :upright
+        (;
+            Greek = :upright,
+            greek = :upright,
+            Latin = :upright,
+            latin = :upright,
+        )
+    else
+        (;
+            Greek = :literal,
+            greek = :literal,
+            Latin = :literal,
+            latin = :literal,
+        )
+    end
+    return normal_style_ntup
+end
+function parse_normal_style_spec(spec::SpecTup)
+    for symb in values(spec)
+        @assert symb in (:literal, :upright, :italic)
+    end
+    return spec
+end
+function parse_normal_style_spec(spec)
+    error("Normal style specification must be a symbol or of type $(SpecTup)")
+end
+
+function parse_bold_style_spec(
+    bold_style_spec::Symbol
+)
+    bold_style_ntup = if bold_style_spec == :iso
+        (;
+            Greek = :italic,
+            greek = :italic,
+            Latin = :italic,
+            latin = :italic
+        )
+    elseif bold_style_spec == :tex
+        (;
+            Greek = :upright,
+            greek = :italic,
+            Latin = :upright,
+            latin = :upright
+        )
+    elseif bold_style_spec == :upright
+        (;
+            Greek = :upright,
+            greek = :upright,
+            Latin = :upright,
+            latin = :upright,
+        )
+    else
+        (;
+            Greek = :literal,
+            greek = :literal,
+            Latin = :literal,
+            latin = :literal,
+        )
+    end
+    return bold_style_ntup
+end
+function parse_bold_style_spec(spec::SpecTup)
+    for symb in values(spec)
+        @assert symb in (:literal, :upright, :italic)
+    end
+    return spec
+end
+function parse_bold_style_spec(spec)
+    error("Bold style specification must be a symbol or of type $(SpecTup)")
+end
+
+function _subtitutions_dict(;
+    normal_style=:literal,
+    bold_style=:literal,
+    sans_style=:literal
+)
+    ## `subs_up`: how glyphs with an upright style should be transformed if we request
+    ## a certain style, which are keys of this dict
+    subs_up = Dict( sn => sn for sn = base_styles )
+    subs_up[:UP] = normal_style == :italic ? :it : (normal_style == :upright ? :up : :up)
+    subs_up[:bf] = if bold_style == :upright   ### expanded for illustration purposes
+        ### bold_style forces upright bold 
+        :bfup 
+    elseif bold_style == :italic 
+        ### bold_style forces italic bold 
+        :bfit 
+    else
+        ### bold_style does not care about slanting, we have an `:up` glyph, so keep it that way
+        :bfup
+    end
+    subs_up[:sf] = sans_style == :upright ? :sfup : (sans_style == :italic ? :sfit : :sfup)
+    subs_up[:bfsf] = sans_style == :upright ? :bfsfup : (sans_style == :italic ? :bfsfit : :bfsfup)
+
+    ## `subs_it`: transformations for italic glyphs
+    subs_it = Dict( sn => sn for sn = base_styles )
+    subs_it[:IT] = normal_style == :italic ? :it : (normal_style == :upright ? :up : :it)
+    subs_it[:bf] = bold_style == :upright ? :bfup : (bold_style == :italic ? :bfit : :bfit)
+    subs_it[:sf] = sans_style == :upright ? :sfup : (sans_style == :italic ? :sfit : :sfit)
+    subs_it[:bfsf] = sans_style == :upright ? :bfsfup : (sans_style == :italic ? :bfsfit : :bfsfit)
+    #subs_it[:bb] = :bbit   # `blackboard_style`?
+   
+    ## `sub_bfup`: transformations for bold upright glyphs
+    subs_bfup = Dict(
+        :up => :bfup,   # no-op
+        :bfup => :bfup, # no-op
+        :bf => :bfup,   # no-op
+        :it => :bfit,
+        :bfit => :bfit,
+        :sfup => :bfsfup,
+        :bfsfup => :bfsfup,
+        :sfit => :bfsfit,
+        :bfsfit => :bfsfit,
+        :cal => :bfcal,
+        :frak => :bffrak
+    )
+    subs_bfup[:BFUP] = bold_style == :upright ? :bfup : (bold_style == :italic ? :bfit : :bfup)
+    subs_bfup[:bfsf] = subs_bfup[:sf] = sans_style == :upright ? :bfsfup : (sans_style == :italic ? :bfsfit : :bfsfup)
+
+    ## `sub_bfit`: transformations for bold italic glyphs
+    subs_bfit = Dict(
+        :bf => :bf,     # no-op
+        :bfit => :bfit, # no-op
+        :it => :bfit,   # no-op
+        :up => :bfup,   # undo italization
+        :bfup => :bfup, # undo italization
+        :sfit => :bfsfit,
+        :bfsfit => :bfsfit,
+        :sfup => :bfsfup,
+        :bfsfup => :bfsfup,
+    )
+    subs_bfit[:BFIT] = bold_style == :upright ? :bfup : (bold_style == :italic ? :bfit : :bfit)
+    subs_bfit[:bfsf] = subs_bfit[:sf] = sans_style == :upright ? :bfsfup : (sans_style == :italic ? :bfsfit : :bfsfit)
+
+    ## `sub_bfit`: transformations for sans-serif upright glyphs
+    subs_sfup = Dict(
+        :sf => :sfup,   # no-op
+        :sfup => :sfup, # no-op
+        :up => :sfup,   # no-op
+        :it => :sfit,
+        :sfit => :sfit,
+        :bfup => :bfsfup,
+        :bfsfup => :bfsfup,
+        :bfit => :bfsfit,
+        :bfsfit => :bfsfit,
+    )
+    subs_sfup[:SFUP] = sans_style == :upright ? :sfup : (sans_style == :italic ? :sfit : :sfup)
+    subs_sfup[:bfsf] = subs_sfup[:bf] = sans_style == :upright ? :bfsfup : (sans_style == :italic ? :bfsfit : :bfsfup)
+
+    ## `sub_bfit`: transformations for sans-serif italic glyphs
+    subs_sfit = Dict(
+        :sf => :sfit,   # no-op
+        :sfit => :sfit, # no-op
+        :it => :sfit,   # no-op
+        :up => :sfup,
+        :sfup => :sfup,
+        :bfit => :bfsfit,
+        :bfsfit => :bfsfit,
+        :bfup => :bfsfup,
+        :bfsfup => :bfsfup,
+    )
+    subs_sfit[:SFIT] = sans_style == :upright ? :sfup : (sans_style == :italic ? :sfit : :sfit)
+    subs_sfit[:bfsf] = subs_sfit[:bf] = sans_style == :upright ? :bfsfup : (sans_style == :italic ? :bfsfit : :bfsfit)
+
+    ## `sub_bfsfup`: transformations for bold sans-serif upright glyphs
+    subs_bfsfup = Dict(
+        ## no-ops:
+        :up => :bfsfup,
+        :bf => :bfsfup,
+        :sf => :bfsfup,
+        :bfup => :bfsfup,
+        :sfup => :bfsfup,
+        :bfsfup => :bfsfup,
+        ## other:
+        :it => :bfsfit,
+        :sfit => :bfsfit,
+        :bfsfit => :bfsfit
+    )
+    subs_bfsfup[:BFSFUP] = sans_style == :upright ? :bfsfup : (sans_style == :italic ? :bfsfit : :bfsfup)
+    
+    ## `sub_bfsfit`: transformations for bold sans-serif italic glyphs
+    subs_bfsfit = Dict(
+        ## no-ops:
+        :it => :bfsfit,
+        :bf => :bfsfit,
+        :sf => :bfsfit,
+        :bfit => :bfsfit,
+        :sfit => :bfsfit,
+        :bfsfit => :bfsfit,
+        ## other:
+        :up => :bfsfup,
+        :sfup => :bfsfup,
+        :bfsfup => :bfsfup
+    )
+    subs_bfsfit[:BFSFIT] = sans_style == :upright ? :bfsfup : (sans_style == :italic ? :bfsfit : :bfsfit)
+
+    ## other
+    subs_tt = Dict(
+        :tt => :tt,
+        :up => :tt,
+    )
+    subs_bb = Dict(
+        :bb => :bb,
+        :up => :bb,
+        :it => :bbit
+    )
+    subs_bbit = Dict(
+        :bb => :bbit,
+        :it => :bbit,
+        :up => :bb
+    )
+
+    subs_cal = Dict(
+        :cal => :cal,
+        :up => :cal,
+        :bf => :bfcal,
+    )
+    subs_frak = Dict(
+        :frak => :frak,
+        :up => :frak,
+        :bf => :bffrak
+    )
+    subs_bffrak = Dict(
+        :frak => :bffrak,
+        :up => :bffrak,
+        :bf => :bffrak
+    )
+  
+    return Dict(
+        :up => subs_up,
+        :bfup => subs_bfup,
+        :it => subs_it,
+        :bfit => subs_bfit,
+        :sfup => subs_sfup,
+        :bfsfup => subs_bfsfup,
+        :sfit => subs_sfit,
+        :bfsfit => subs_bfsfit,
+        :tt => subs_tt,
+        :bb => subs_bb,
+        :bbit => subs_bbit,
+        :cal => subs_cal,
+        :frak => subs_frak,
+        :bffrak => subs_bffrak
+    )
+end
\ No newline at end of file
diff --git a/src/UnicodeMath/src/extra_commands.jl b/src/UnicodeMath/src/extra_commands.jl
new file mode 100644
index 0000000..a7458d3
--- /dev/null
+++ b/src/UnicodeMath/src/extra_commands.jl
@@ -0,0 +1,2461 @@
+# This file contains LaTeX commands originally
+# defined in source file `unicode-math-table.tex`
+# of the UNICODE-MATH package  <wspr.io/unicode-math>
+
+struct UCMCommand 
+    latex_cmd :: String
+    glyph :: Char
+    group :: Symbol
+    desc :: String
+end
+
+const extra_commands = Dict{Symbol, UCMCommand}(
+  :mathexclam => UCMCommand("\\mathexclam", '!', :mathclose, "exclamation mark"),
+  :mathoctothorpe => UCMCommand("\\mathoctothorpe", '#', :mathord, "number sign"),
+  :mathdollar => UCMCommand("\\mathdollar", '$', :mathord, "dollar sign"),
+  :mathpercent => UCMCommand("\\mathpercent", '%', :mathord, "percent sign"),
+  :mathampersand => UCMCommand("\\mathampersand", '&', :mathord, "ampersand"),
+  :lparen => UCMCommand("\\lparen", '(', :mathopen, "left parenthesis"),
+  :rparen => UCMCommand("\\rparen", ')', :mathclose, "right parenthesis"),
+  :mathplus => UCMCommand("\\mathplus", '+', :mathbin, "plus sign b:"),
+  :mathcomma => UCMCommand("\\mathcomma", ',', :mathpunct, "comma"),
+  :mathperiod => UCMCommand("\\mathperiod", '.', :mathord, "full stop, period"),
+  :mathslash => UCMCommand("\\mathslash", '/', :mathord, "solidus"),
+  :mathcolon => UCMCommand("\\mathcolon", ':', :mathpunct, "colon"),
+  :mathsemicolon => UCMCommand("\\mathsemicolon", ';', :mathpunct, "semicolon p:"),
+  :less => UCMCommand("\\less", '<', :mathrel, "less-than sign r:"),
+  :equal => UCMCommand("\\equal", '=', :mathrel, "equals sign r:"),
+  :greater => UCMCommand("\\greater", '>', :mathrel, "greater-than sign r:"),
+  :mathquestion => UCMCommand("\\mathquestion", '?', :mathord, "question mark"),
+  :mathatsign => UCMCommand("\\mathatsign", '@', :mathord, "commercial at"),
+  :lbrack => UCMCommand("\\lbrack", '[', :mathopen, "left square bracket"),
+  :backslash => UCMCommand("\\backslash", '\\', :mathord, "reverse solidus"),
+  :rbrack => UCMCommand("\\rbrack", ']', :mathclose, "right square bracket"),
+  :lbrace => UCMCommand("\\lbrace", '{', :mathopen, "left curly bracket"),
+  :vert => UCMCommand("\\vert", '|', :mathfence, "vertical bar"),
+  :rbrace => UCMCommand("\\rbrace", '}', :mathclose, "right curly bracket"),
+  :mathsterling => UCMCommand("\\mathsterling", '£', :mathord, "pound sign"),
+  :mathyen => UCMCommand("\\mathyen", '¥', :mathord, "yen sign"),
+  :mathsection => UCMCommand("\\mathsection", '§', :mathord, "section symbol"),
+  :neg => UCMCommand("\\neg", '¬', :mathord, "/neg /lnot not sign"),
+  :pm => UCMCommand("\\pm", '±', :mathbin, "plus-or-minus sign"),
+  :mathparagraph => UCMCommand("\\mathparagraph", '¶', :mathord, "paragraph symbol"),
+  :cdotp => UCMCommand("\\cdotp", '·', :mathbin, "/centerdot b: middle dot"),
+  :times => UCMCommand("\\times", '×', :mathbin, "multiply sign"),
+  :matheth => UCMCommand("\\matheth", 'ð', :mathalpha, "eth"),
+  :div => UCMCommand("\\div", '÷', :mathbin, "divide sign"),
+  :Zbar => UCMCommand("\\Zbar", 'Ƶ', :mathord, "impedance (latin capital letter z with stroke)"),
+  :grave => UCMCommand("\\grave", '̀', :mathaccent, "grave accent"),
+  :acute => UCMCommand("\\acute", '́', :mathaccent, "acute accent"),
+  :hat => UCMCommand("\\hat", '̂', :mathaccent, "circumflex accent"),
+  :widehat => UCMCommand("\\widehat", '̂', :mathaccentwide, "circumflex accent"),
+  :tilde => UCMCommand("\\tilde", '̃', :mathaccent, "tilde"),
+  :widetilde => UCMCommand("\\widetilde", '̃', :mathaccentwide, "tilde"),
+  :bar => UCMCommand("\\bar", '̄', :mathaccent, "macron"),
+  :overbar => UCMCommand("\\overbar", '̅', :mathaccent, "overbar embellishment"),
+  :wideoverbar => UCMCommand("\\wideoverbar", '̅', :mathaccentwide, "stretchy overbar embellishment"),
+  :breve => UCMCommand("\\breve", '̆', :mathaccent, "breve"),
+  :widebreve => UCMCommand("\\widebreve", '̆', :mathaccentwide, "stretchy breve"),
+  :dot => UCMCommand("\\dot", '̇', :mathaccent, "dot above"),
+  :ddot => UCMCommand("\\ddot", '̈', :mathaccent, "dieresis"),
+  :ovhook => UCMCommand("\\ovhook", '̉', :mathaccent, "combining hook above"),
+  :ocirc => UCMCommand("\\ocirc", '̊', :mathaccent, "ring"),
+  :check => UCMCommand("\\check", '̌', :mathaccent, "caron"),
+  :widecheck => UCMCommand("\\widecheck", '̌', :mathaccentwide, "stretchy caron"),
+  :candra => UCMCommand("\\candra", '̐', :mathaccent, "candrabindu (non-spacing)"),
+  :oturnedcomma => UCMCommand("\\oturnedcomma", '̒', :mathaccent, "combining turned comma above"),
+  :ocommatopright => UCMCommand("\\ocommatopright", '̕', :mathaccent, "combining comma above right"),
+  :droang => UCMCommand("\\droang", '̚', :mathaccent, "left angle above (non-spacing)"),
+  :wideutilde => UCMCommand("\\wideutilde", '̰', :mathbotaccentwide, "under tilde accent (multiple characters and non-spacing)"),
+  :mathunderbar => UCMCommand("\\mathunderbar", '̲', :mathbotaccentwide, "combining low line"),
+  :notaccent => UCMCommand("\\notaccent", '̸', :mathaccentoverlay, "combining long solidus overlay"),
+  :underleftrightarrow => UCMCommand("\\underleftrightarrow", '͍', :mathbotaccentwide, "underleftrightarrow accent"),
+  :mupAlpha => UCMCommand("\\mupAlpha", 'Α', :mathalpha, "capital alpha, greek"),
+  :mupBeta => UCMCommand("\\mupBeta", 'Β', :mathalpha, "capital beta, greek"),
+  :mupGamma => UCMCommand("\\mupGamma", 'Γ', :mathalpha, "capital gamma, greek"),
+  :mupDelta => UCMCommand("\\mupDelta", 'Δ', :mathalpha, "capital delta, greek"),
+  :mupEpsilon => UCMCommand("\\mupEpsilon", 'Ε', :mathalpha, "capital epsilon, greek"),
+  :mupZeta => UCMCommand("\\mupZeta", 'Ζ', :mathalpha, "capital zeta, greek"),
+  :mupEta => UCMCommand("\\mupEta", 'Η', :mathalpha, "capital eta, greek"),
+  :mupTheta => UCMCommand("\\mupTheta", 'Θ', :mathalpha, "capital theta, greek"),
+  :mupIota => UCMCommand("\\mupIota", 'Ι', :mathalpha, "capital iota, greek"),
+  :mupKappa => UCMCommand("\\mupKappa", 'Κ', :mathalpha, "capital kappa, greek"),
+  :mupLambda => UCMCommand("\\mupLambda", 'Λ', :mathalpha, "capital lambda, greek"),
+  :mupMu => UCMCommand("\\mupMu", 'Μ', :mathalpha, "capital mu, greek"),
+  :mupNu => UCMCommand("\\mupNu", 'Ν', :mathalpha, "capital nu, greek"),
+  :mupXi => UCMCommand("\\mupXi", 'Ξ', :mathalpha, "capital xi, greek"),
+  :mupOmicron => UCMCommand("\\mupOmicron", 'Ο', :mathalpha, "capital omicron, greek"),
+  :mupPi => UCMCommand("\\mupPi", 'Π', :mathalpha, "capital pi, greek"),
+  :mupRho => UCMCommand("\\mupRho", 'Ρ', :mathalpha, "capital rho, greek"),
+  :mupSigma => UCMCommand("\\mupSigma", 'Σ', :mathalpha, "capital sigma, greek"),
+  :mupTau => UCMCommand("\\mupTau", 'Τ', :mathalpha, "capital tau, greek"),
+  :mupUpsilon => UCMCommand("\\mupUpsilon", 'Υ', :mathalpha, "capital upsilon, greek"),
+  :mupPhi => UCMCommand("\\mupPhi", 'Φ', :mathalpha, "capital phi, greek"),
+  :mupChi => UCMCommand("\\mupChi", 'Χ', :mathalpha, "capital chi, greek"),
+  :mupPsi => UCMCommand("\\mupPsi", 'Ψ', :mathalpha, "capital psi, greek"),
+  :mupOmega => UCMCommand("\\mupOmega", 'Ω', :mathalpha, "capital omega, greek"),
+  :mupalpha => UCMCommand("\\mupalpha", 'α', :mathalpha, "small alpha, greek"),
+  :mupbeta => UCMCommand("\\mupbeta", 'β', :mathalpha, "small beta, greek"),
+  :mupgamma => UCMCommand("\\mupgamma", 'γ', :mathalpha, "small gamma, greek"),
+  :mupdelta => UCMCommand("\\mupdelta", 'δ', :mathalpha, "small delta, greek"),
+  :mupvarepsilon => UCMCommand("\\mupvarepsilon", 'ε', :mathalpha, "rounded small varepsilon, greek"),
+  :mupzeta => UCMCommand("\\mupzeta", 'ζ', :mathalpha, "small zeta, greek"),
+  :mupeta => UCMCommand("\\mupeta", 'η', :mathalpha, "small eta, greek"),
+  :muptheta => UCMCommand("\\muptheta", 'θ', :mathalpha, "straight theta, small theta, greek"),
+  :mupiota => UCMCommand("\\mupiota", 'ι', :mathalpha, "small iota, greek"),
+  :mupkappa => UCMCommand("\\mupkappa", 'κ', :mathalpha, "small kappa, greek"),
+  :muplambda => UCMCommand("\\muplambda", 'λ', :mathalpha, "small lambda, greek"),
+  :mupmu => UCMCommand("\\mupmu", 'μ', :mathalpha, "small mu, greek"),
+  :mupnu => UCMCommand("\\mupnu", 'ν', :mathalpha, "small nu, greek"),
+  :mupxi => UCMCommand("\\mupxi", 'ξ', :mathalpha, "small xi, greek"),
+  :mupomicron => UCMCommand("\\mupomicron", 'ο', :mathalpha, "small omicron, greek"),
+  :muppi => UCMCommand("\\muppi", 'π', :mathalpha, "small pi, greek"),
+  :muprho => UCMCommand("\\muprho", 'ρ', :mathalpha, "small rho, greek"),
+  :mupvarsigma => UCMCommand("\\mupvarsigma", 'ς', :mathalpha, "terminal sigma, greek"),
+  :mupsigma => UCMCommand("\\mupsigma", 'σ', :mathalpha, "small sigma, greek"),
+  :muptau => UCMCommand("\\muptau", 'τ', :mathalpha, "small tau, greek"),
+  :mupupsilon => UCMCommand("\\mupupsilon", 'υ', :mathalpha, "small upsilon, greek"),
+  :mupvarphi => UCMCommand("\\mupvarphi", 'φ', :mathalpha, "curly or open small phi, greek"),
+  :mupchi => UCMCommand("\\mupchi", 'χ', :mathalpha, "small chi, greek"),
+  :muppsi => UCMCommand("\\muppsi", 'ψ', :mathalpha, "small psi, greek"),
+  :mupomega => UCMCommand("\\mupomega", 'ω', :mathalpha, "small omega, greek"),
+  :mupvartheta => UCMCommand("\\mupvartheta", 'ϑ', :mathalpha, "/vartheta - curly or open theta"),
+  :mupphi => UCMCommand("\\mupphi", 'ϕ', :mathalpha, "/straightphi - small phi, greek"),
+  :mupvarpi => UCMCommand("\\mupvarpi", 'ϖ', :mathalpha, "rounded small pi (pomega), greek"),
+  :upDigamma => UCMCommand("\\upDigamma", 'Ϝ', :mathalpha, "capital digamma"),
+  :updigamma => UCMCommand("\\updigamma", 'ϝ', :mathalpha, "old greek small letter digamma"),
+  :mupvarkappa => UCMCommand("\\mupvarkappa", 'ϰ', :mathalpha, "rounded small kappa, greek"),
+  :mupvarrho => UCMCommand("\\mupvarrho", 'ϱ', :mathalpha, "rounded small rho, greek"),
+  :mupvarTheta => UCMCommand("\\mupvarTheta", 'ϴ', :mathalpha, "greek capital theta symbol"),
+  :mupepsilon => UCMCommand("\\mupepsilon", 'ϵ', :mathalpha, "greek lunate varepsilon symbol"),
+  :upbackepsilon => UCMCommand("\\upbackepsilon", '϶', :mathord, "greek reversed lunate epsilon symbol"),
+  :mathhyphen => UCMCommand("\\mathhyphen", '‐', :mathalpha, "hyphen"),
+  :horizbar => UCMCommand("\\horizbar", '―', :mathord, "horizontal bar"),
+  :Vert => UCMCommand("\\Vert", '‖', :mathfence, "double vertical bar"),
+  :twolowline => UCMCommand("\\twolowline", '‗', :mathord, "double low line (spacing)"),
+  :dagger => UCMCommand("\\dagger", '†', :mathbin, "dagger relation"),
+  :ddagger => UCMCommand("\\ddagger", '‡', :mathbin, "double dagger relation"),
+  :smblkcircle => UCMCommand("\\smblkcircle", '•', :mathbin, "/bullet b: round bullet, filled"),
+  :enleadertwodots => UCMCommand("\\enleadertwodots", '‥', :mathord, "double baseline dot (en leader)"),
+  :unicodeellipsis => UCMCommand("\\unicodeellipsis", '…', :mathord, "ellipsis (horizontal)"),
+  :prime => UCMCommand("\\prime", '′', :mathord, "prime or minute, not superscripted"),
+  :dprime => UCMCommand("\\dprime", '″', :mathord, "double prime or second, not superscripted"),
+  :trprime => UCMCommand("\\trprime", '‴', :mathord, "triple prime (not superscripted)"),
+  :backprime => UCMCommand("\\backprime", '‵', :mathord, "reverse prime, not superscripted"),
+  :backdprime => UCMCommand("\\backdprime", '‶', :mathord, "double reverse prime, not superscripted"),
+  :backtrprime => UCMCommand("\\backtrprime", '‷', :mathord, "triple reverse prime, not superscripted"),
+  :caretinsert => UCMCommand("\\caretinsert", '‸', :mathord, "caret (insertion mark)"),
+  :Exclam => UCMCommand("\\Exclam", '‼', :mathord, "double exclamation mark"),
+  :tieconcat => UCMCommand("\\tieconcat", '⁀', :mathbin, "character tie, z notation sequence concatenation"),
+  :hyphenbullet => UCMCommand("\\hyphenbullet", '⁃', :mathord, "rectangle, filled (hyphen bullet)"),
+  :fracslash => UCMCommand("\\fracslash", '⁄', :mathbin, "fraction slash"),
+  :Question => UCMCommand("\\Question", '⁇', :mathord, "double question mark"),
+  :closure => UCMCommand("\\closure", '⁐', :mathrel, "close up"),
+  :qprime => UCMCommand("\\qprime", '⁗', :mathord, "quadruple prime, not superscripted"),
+  :euro => UCMCommand("\\euro", '€', :mathord, "euro sign"),
+  :leftharpoonaccent => UCMCommand("\\leftharpoonaccent", '⃐', :mathaccent, "combining left harpoon above"),
+  :overleftharpoon => UCMCommand("\\overleftharpoon", '⃐', :mathaccentwide, "combining left harpoon above"),
+  :rightharpoonaccent => UCMCommand("\\rightharpoonaccent", '⃑', :mathaccent, "combining right harpoon above"),
+  :overrightharpoon => UCMCommand("\\overrightharpoon", '⃑', :mathaccentwide, "combining right harpoon above"),
+  :vertoverlay => UCMCommand("\\vertoverlay", '⃒', :mathaccent, "combining long vertical line overlay"),
+  :overleftarrow => UCMCommand("\\overleftarrow", '⃖', :mathaccentwide, "combining left arrow above"),
+  :overrightarrow => UCMCommand("\\overrightarrow", '⃗', :mathaccentwide, "combining left arrow above"),
+  :vec => UCMCommand("\\vec", '⃗', :mathaccent, "combining right arrow above"),
+  :dddot => UCMCommand("\\dddot", '⃛', :mathaccent, "combining three dots above"),
+  :ddddot => UCMCommand("\\ddddot", '⃜', :mathaccent, "combining four dots above"),
+  :enclosecircle => UCMCommand("\\enclosecircle", '⃝', :mathord, "combining enclosing circle"),
+  :enclosesquare => UCMCommand("\\enclosesquare", '⃞', :mathord, "combining enclosing square"),
+  :enclosediamond => UCMCommand("\\enclosediamond", '⃟', :mathord, "combining enclosing diamond"),
+  :overleftrightarrow => UCMCommand("\\overleftrightarrow", '⃡', :mathaccentwide, "combining left right arrow above"),
+  :enclosetriangle => UCMCommand("\\enclosetriangle", '⃤', :mathord, "combining enclosing upward pointing triangle"),
+  :annuity => UCMCommand("\\annuity", '⃧', :mathaccent, "combining annuity symbol"),
+  :threeunderdot => UCMCommand("\\threeunderdot", '⃨', :mathbotaccent, "combining triple underdot"),
+  :widebridgeabove => UCMCommand("\\widebridgeabove", '⃩', :mathaccent, "combining wide bridge above"),
+  :underrightharpoondown => UCMCommand("\\underrightharpoondown", '⃬', :mathbotaccentwide, "combining rightwards harpoon with barb downwards"),
+  :underleftharpoondown => UCMCommand("\\underleftharpoondown", '⃭', :mathbotaccentwide, "combining leftwards harpoon with barb downwards"),
+  :underleftarrow => UCMCommand("\\underleftarrow", '⃮', :mathbotaccentwide, "combining left arrow below"),
+  :underrightarrow => UCMCommand("\\underrightarrow", '⃯', :mathbotaccentwide, "combining right arrow below"),
+  :asteraccent => UCMCommand("\\asteraccent", '⃰', :mathaccent, "combining asterisk above"),
+  :BbbC => UCMCommand("\\BbbC", 'ℂ', :mathalpha, "/bbb c, open face c"),
+  :Eulerconst => UCMCommand("\\Eulerconst", 'ℇ', :mathord, "euler constant"),
+  :mscrg => UCMCommand("\\mscrg", 'ℊ', :mathalpha, "/scr g, script letter g"),
+  :mscrH => UCMCommand("\\mscrH", 'ℋ', :mathalpha, "hamiltonian (script capital h)"),
+  :mfrakH => UCMCommand("\\mfrakH", 'ℌ', :mathalpha, "/frak h, upper case h"),
+  :BbbH => UCMCommand("\\BbbH", 'ℍ', :mathalpha, "/bbb h, open face h"),
+  :Planckconst => UCMCommand("\\Planckconst", 'ℎ', :mathord, "planck constant"),
+  :hslash => UCMCommand("\\hslash", 'ℏ', :mathalpha, "/hslash - variant planck's over 2pi"),
+  :mscrI => UCMCommand("\\mscrI", 'ℐ', :mathalpha, "/scr i, script letter i"),
+  :Im => UCMCommand("\\Im", 'ℑ', :mathalpha, "imaginary part"),
+  :mscrL => UCMCommand("\\mscrL", 'ℒ', :mathalpha, "lagrangian (script capital l)"),
+  :ell => UCMCommand("\\ell", 'ℓ', :mathalpha, "cursive small l"),
+  :BbbN => UCMCommand("\\BbbN", 'ℕ', :mathalpha, "/bbb n, open face n"),
+  :wp => UCMCommand("\\wp", '℘', :mathalpha, "weierstrass p"),
+  :BbbP => UCMCommand("\\BbbP", 'ℙ', :mathalpha, "/bbb p, open face p"),
+  :BbbQ => UCMCommand("\\BbbQ", 'ℚ', :mathalpha, "/bbb q, open face q"),
+  :mscrR => UCMCommand("\\mscrR", 'ℛ', :mathalpha, "/scr r, script letter r"),
+  :Re => UCMCommand("\\Re", 'ℜ', :mathalpha, "real part"),
+  :BbbR => UCMCommand("\\BbbR", 'ℝ', :mathalpha, "/bbb r, open face r"),
+  :BbbZ => UCMCommand("\\BbbZ", 'ℤ', :mathalpha, "/bbb z, open face z"),
+  :mho => UCMCommand("\\mho", '℧', :mathord, "conductance"),
+  :mfrakZ => UCMCommand("\\mfrakZ", 'ℨ', :mathalpha, "/frak z, upper case z"),
+  :turnediota => UCMCommand("\\turnediota", '℩', :mathalpha, "turned iota"),
+  :Angstrom => UCMCommand("\\Angstrom", 'Å', :mathalpha, "angstrom capital a, ring"),
+  :mscrB => UCMCommand("\\mscrB", 'ℬ', :mathalpha, "bernoulli function (script capital b)"),
+  :mfrakC => UCMCommand("\\mfrakC", 'ℭ', :mathalpha, "black-letter capital c"),
+  :mscre => UCMCommand("\\mscre", 'ℯ', :mathalpha, "/scr e, script letter e"),
+  :mscrE => UCMCommand("\\mscrE", 'ℰ', :mathalpha, "/scr e, script letter e"),
+  :mscrF => UCMCommand("\\mscrF", 'ℱ', :mathalpha, "/scr f, script letter f"),
+  :Finv => UCMCommand("\\Finv", 'Ⅎ', :mathord, "turned capital f"),
+  :mscrM => UCMCommand("\\mscrM", 'ℳ', :mathalpha, "physics m-matrix (script capital m)"),
+  :mscro => UCMCommand("\\mscro", 'ℴ', :mathalpha, "order of (script small o)"),
+  :aleph => UCMCommand("\\aleph", 'ℵ', :mathalpha, "aleph, hebrew"),
+  :beth => UCMCommand("\\beth", 'ℶ', :mathalpha, "beth, hebrew"),
+  :gimel => UCMCommand("\\gimel", 'ℷ', :mathalpha, "gimel, hebrew"),
+  :daleth => UCMCommand("\\daleth", 'ℸ', :mathalpha, "daleth, hebrew"),
+  :Bbbpi => UCMCommand("\\Bbbpi", 'ℼ', :mathord, "double-struck small pi"),
+  :Bbbgamma => UCMCommand("\\Bbbgamma", 'ℽ', :mathalpha, "double-struck small gamma"),
+  :BbbGamma => UCMCommand("\\BbbGamma", 'ℾ', :mathalpha, "double-struck capital gamma"),
+  :BbbPi => UCMCommand("\\BbbPi", 'ℿ', :mathalpha, "double-struck capital pi"),
+  :Bbbsum => UCMCommand("\\Bbbsum", '⅀', :mathop, "double-struck n-ary summation"),
+  :Game => UCMCommand("\\Game", '⅁', :mathord, "turned sans-serif capital g"),
+  :sansLturned => UCMCommand("\\sansLturned", '⅂', :mathord, "turned sans-serif capital l"),
+  :sansLmirrored => UCMCommand("\\sansLmirrored", '⅃', :mathord, "reversed sans-serif capital l"),
+  :Yup => UCMCommand("\\Yup", '⅄', :mathord, "turned sans-serif capital y"),
+  :mitBbbD => UCMCommand("\\mitBbbD", 'ⅅ', :mathord, "double-struck italic capital d"),
+  :mitBbbd => UCMCommand("\\mitBbbd", 'ⅆ', :mathord, "double-struck italic small d"),
+  :mitBbbe => UCMCommand("\\mitBbbe", 'ⅇ', :mathord, "double-struck italic small e"),
+  :mitBbbi => UCMCommand("\\mitBbbi", 'ⅈ', :mathord, "double-struck italic small i"),
+  :mitBbbj => UCMCommand("\\mitBbbj", 'ⅉ', :mathord, "double-struck italic small j"),
+  :PropertyLine => UCMCommand("\\PropertyLine", '⅊', :mathord, "property line"),
+  :upand => UCMCommand("\\upand", '⅋', :mathbin, "turned ampersand"),
+  :leftarrow => UCMCommand("\\leftarrow", '←', :mathrel, "/leftarrow /gets a: leftward arrow"),
+  :uparrow => UCMCommand("\\uparrow", '↑', :mathrel, "upward arrow"),
+  :rightarrow => UCMCommand("\\rightarrow", '→', :mathrel, "/rightarrow /to a: rightward arrow"),
+  :downarrow => UCMCommand("\\downarrow", '↓', :mathrel, "downward arrow"),
+  :leftrightarrow => UCMCommand("\\leftrightarrow", '↔', :mathrel, "left and right arrow"),
+  :updownarrow => UCMCommand("\\updownarrow", '↕', :mathrel, "up and down arrow"),
+  :nwarrow => UCMCommand("\\nwarrow", '↖', :mathrel, "nw pointing arrow"),
+  :nearrow => UCMCommand("\\nearrow", '↗', :mathrel, "ne pointing arrow"),
+  :searrow => UCMCommand("\\searrow", '↘', :mathrel, "se pointing arrow"),
+  :swarrow => UCMCommand("\\swarrow", '↙', :mathrel, "sw pointing arrow"),
+  :nleftarrow => UCMCommand("\\nleftarrow", '↚', :mathrel, "not left arrow"),
+  :nrightarrow => UCMCommand("\\nrightarrow", '↛', :mathrel, "not right arrow"),
+  :leftwavearrow => UCMCommand("\\leftwavearrow", '↜', :mathrel, "left arrow-wavy"),
+  :rightwavearrow => UCMCommand("\\rightwavearrow", '↝', :mathrel, "right arrow-wavy"),
+  :twoheadleftarrow => UCMCommand("\\twoheadleftarrow", '↞', :mathrel, "left two-headed arrow"),
+  :twoheaduparrow => UCMCommand("\\twoheaduparrow", '↟', :mathrel, "up two-headed arrow"),
+  :twoheadrightarrow => UCMCommand("\\twoheadrightarrow", '↠', :mathrel, "right two-headed arrow"),
+  :twoheaddownarrow => UCMCommand("\\twoheaddownarrow", '↡', :mathrel, "down two-headed arrow"),
+  :leftarrowtail => UCMCommand("\\leftarrowtail", '↢', :mathrel, "left arrow-tailed"),
+  :rightarrowtail => UCMCommand("\\rightarrowtail", '↣', :mathrel, "right arrow-tailed"),
+  :mapsfrom => UCMCommand("\\mapsfrom", '↤', :mathrel, "maps to, leftward"),
+  :mapsup => UCMCommand("\\mapsup", '↥', :mathrel, "maps to, upward"),
+  :mapsto => UCMCommand("\\mapsto", '↦', :mathrel, "maps to, rightward"),
+  :mapsdown => UCMCommand("\\mapsdown", '↧', :mathrel, "maps to, downward"),
+  :updownarrowbar => UCMCommand("\\updownarrowbar", '↨', :mathord, "up down arrow with base (perpendicular)"),
+  :hookleftarrow => UCMCommand("\\hookleftarrow", '↩', :mathrel, "left arrow-hooked"),
+  :hookrightarrow => UCMCommand("\\hookrightarrow", '↪', :mathrel, "right arrow-hooked"),
+  :looparrowleft => UCMCommand("\\looparrowleft", '↫', :mathrel, "left arrow-looped"),
+  :looparrowright => UCMCommand("\\looparrowright", '↬', :mathrel, "right arrow-looped"),
+  :leftrightsquigarrow => UCMCommand("\\leftrightsquigarrow", '↭', :mathrel, "left and right arr-wavy"),
+  :nleftrightarrow => UCMCommand("\\nleftrightarrow", '↮', :mathrel, "not left and right arrow"),
+  :downzigzagarrow => UCMCommand("\\downzigzagarrow", '↯', :mathrel, "downwards zigzag arrow"),
+  :Lsh => UCMCommand("\\Lsh", '↰', :mathrel, "/lsh a:"),
+  :Rsh => UCMCommand("\\Rsh", '↱', :mathrel, "/rsh a:"),
+  :Ldsh => UCMCommand("\\Ldsh", '↲', :mathrel, "left down angled arrow"),
+  :Rdsh => UCMCommand("\\Rdsh", '↳', :mathrel, "right down angled arrow"),
+  :linefeed => UCMCommand("\\linefeed", '↴', :mathord, "rightwards arrow with corner downwards"),
+  :carriagereturn => UCMCommand("\\carriagereturn", '↵', :mathord, "downwards arrow with corner leftward = carriage return"),
+  :curvearrowleft => UCMCommand("\\curvearrowleft", '↶', :mathrel, "left curved arrow"),
+  :curvearrowright => UCMCommand("\\curvearrowright", '↷', :mathrel, "right curved arrow"),
+  :barovernorthwestarrow => UCMCommand("\\barovernorthwestarrow", '↸', :mathord, "north west arrow to long bar"),
+  :barleftarrowrightarrowbar => UCMCommand("\\barleftarrowrightarrowbar", '↹', :mathord, "leftwards arrow to bar over rightwards arrow to bar"),
+  :acwopencirclearrow => UCMCommand("\\acwopencirclearrow", '↺', :mathord, "anticlockwise open circle arrow"),
+  :cwopencirclearrow => UCMCommand("\\cwopencirclearrow", '↻', :mathord, "clockwise open circle arrow"),
+  :leftharpoonup => UCMCommand("\\leftharpoonup", '↼', :mathrel, "left harpoon-up"),
+  :leftharpoondown => UCMCommand("\\leftharpoondown", '↽', :mathrel, "left harpoon-down"),
+  :upharpoonright => UCMCommand("\\upharpoonright", '↾', :mathrel, "/upharpoonright /restriction a: up harpoon-right"),
+  :upharpoonleft => UCMCommand("\\upharpoonleft", '↿', :mathrel, "up harpoon-left"),
+  :rightharpoonup => UCMCommand("\\rightharpoonup", '⇀', :mathrel, "right harpoon-up"),
+  :rightharpoondown => UCMCommand("\\rightharpoondown", '⇁', :mathrel, "right harpoon-down"),
+  :downharpoonright => UCMCommand("\\downharpoonright", '⇂', :mathrel, "down harpoon-right"),
+  :downharpoonleft => UCMCommand("\\downharpoonleft", '⇃', :mathrel, "down harpoon-left"),
+  :rightleftarrows => UCMCommand("\\rightleftarrows", '⇄', :mathrel, "right arrow over left arrow"),
+  :updownarrows => UCMCommand("\\updownarrows", '⇅', :mathrel, "up arrow, down arrow"),
+  :leftrightarrows => UCMCommand("\\leftrightarrows", '⇆', :mathrel, "left arrow over right arrow"),
+  :leftleftarrows => UCMCommand("\\leftleftarrows", '⇇', :mathrel, "two left arrows"),
+  :upuparrows => UCMCommand("\\upuparrows", '⇈', :mathrel, "two up arrows"),
+  :rightrightarrows => UCMCommand("\\rightrightarrows", '⇉', :mathrel, "two right arrows"),
+  :downdownarrows => UCMCommand("\\downdownarrows", '⇊', :mathrel, "two down arrows"),
+  :leftrightharpoons => UCMCommand("\\leftrightharpoons", '⇋', :mathrel, "left harpoon over right"),
+  :rightleftharpoons => UCMCommand("\\rightleftharpoons", '⇌', :mathrel, "right harpoon over left"),
+  :nLeftarrow => UCMCommand("\\nLeftarrow", '⇍', :mathrel, "not implied by"),
+  :nLeftrightarrow => UCMCommand("\\nLeftrightarrow", '⇎', :mathrel, "not left and right double arrows"),
+  :nRightarrow => UCMCommand("\\nRightarrow", '⇏', :mathrel, "not implies"),
+  :Leftarrow => UCMCommand("\\Leftarrow", '⇐', :mathrel, "is implied by"),
+  :Uparrow => UCMCommand("\\Uparrow", '⇑', :mathrel, "up double arrow"),
+  :Rightarrow => UCMCommand("\\Rightarrow", '⇒', :mathrel, "implies"),
+  :Downarrow => UCMCommand("\\Downarrow", '⇓', :mathrel, "down double arrow"),
+  :Leftrightarrow => UCMCommand("\\Leftrightarrow", '⇔', :mathrel, "left and right double arrow"),
+  :Updownarrow => UCMCommand("\\Updownarrow", '⇕', :mathrel, "up and down double arrow"),
+  :Nwarrow => UCMCommand("\\Nwarrow", '⇖', :mathrel, "nw pointing double arrow"),
+  :Nearrow => UCMCommand("\\Nearrow", '⇗', :mathrel, "ne pointing double arrow"),
+  :Searrow => UCMCommand("\\Searrow", '⇘', :mathrel, "se pointing double arrow"),
+  :Swarrow => UCMCommand("\\Swarrow", '⇙', :mathrel, "sw pointing double arrow"),
+  :Lleftarrow => UCMCommand("\\Lleftarrow", '⇚', :mathrel, "left triple arrow"),
+  :Rrightarrow => UCMCommand("\\Rrightarrow", '⇛', :mathrel, "right triple arrow"),
+  :leftsquigarrow => UCMCommand("\\leftsquigarrow", '⇜', :mathrel, "leftwards squiggle arrow"),
+  :rightsquigarrow => UCMCommand("\\rightsquigarrow", '⇝', :mathrel, "rightwards squiggle arrow"),
+  :nHuparrow => UCMCommand("\\nHuparrow", '⇞', :mathord, "upwards arrow with double stroke"),
+  :nHdownarrow => UCMCommand("\\nHdownarrow", '⇟', :mathord, "downwards arrow with double stroke"),
+  :leftdasharrow => UCMCommand("\\leftdasharrow", '⇠', :mathord, "leftwards dashed arrow"),
+  :updasharrow => UCMCommand("\\updasharrow", '⇡', :mathord, "upwards dashed arrow"),
+  :rightdasharrow => UCMCommand("\\rightdasharrow", '⇢', :mathord, "rightwards dashed arrow"),
+  :downdasharrow => UCMCommand("\\downdasharrow", '⇣', :mathord, "downwards dashed arrow"),
+  :barleftarrow => UCMCommand("\\barleftarrow", '⇤', :mathrel, "leftwards arrow to bar"),
+  :rightarrowbar => UCMCommand("\\rightarrowbar", '⇥', :mathrel, "rightwards arrow to bar"),
+  :leftwhitearrow => UCMCommand("\\leftwhitearrow", '⇦', :mathord, "leftwards white arrow"),
+  :upwhitearrow => UCMCommand("\\upwhitearrow", '⇧', :mathord, "upwards white arrow"),
+  :rightwhitearrow => UCMCommand("\\rightwhitearrow", '⇨', :mathord, "rightwards white arrow"),
+  :downwhitearrow => UCMCommand("\\downwhitearrow", '⇩', :mathord, "downwards white arrow"),
+  :whitearrowupfrombar => UCMCommand("\\whitearrowupfrombar", '⇪', :mathord, "upwards white arrow from bar"),
+  :circleonrightarrow => UCMCommand("\\circleonrightarrow", '⇴', :mathrel, "right arrow with small circle"),
+  :downuparrows => UCMCommand("\\downuparrows", '⇵', :mathrel, "downwards arrow leftwards of upwards arrow"),
+  :rightthreearrows => UCMCommand("\\rightthreearrows", '⇶', :mathrel, "three rightwards arrows"),
+  :nvleftarrow => UCMCommand("\\nvleftarrow", '⇷', :mathrel, "leftwards arrow with vertical stroke"),
+  :nvrightarrow => UCMCommand("\\nvrightarrow", '⇸', :mathrel, "rightwards arrow with vertical stroke"),
+  :nvleftrightarrow => UCMCommand("\\nvleftrightarrow", '⇹', :mathrel, "left right arrow with vertical stroke"),
+  :nVleftarrow => UCMCommand("\\nVleftarrow", '⇺', :mathrel, "leftwards arrow with double vertical stroke"),
+  :nVrightarrow => UCMCommand("\\nVrightarrow", '⇻', :mathrel, "rightwards arrow with double vertical stroke"),
+  :nVleftrightarrow => UCMCommand("\\nVleftrightarrow", '⇼', :mathrel, "left right arrow with double vertical stroke"),
+  :leftarrowtriangle => UCMCommand("\\leftarrowtriangle", '⇽', :mathrel, "leftwards open-headed arrow"),
+  :rightarrowtriangle => UCMCommand("\\rightarrowtriangle", '⇾', :mathrel, "rightwards open-headed arrow"),
+  :leftrightarrowtriangle => UCMCommand("\\leftrightarrowtriangle", '⇿', :mathrel, "left right open-headed arrow"),
+  :forall => UCMCommand("\\forall", '∀', :mathord, "for all"),
+  :complement => UCMCommand("\\complement", '∁', :mathord, "complement sign"),
+  :partial => UCMCommand("\\partial", '∂', :mathalpha, "partial differential"),
+  :exists => UCMCommand("\\exists", '∃', :mathord, "at least one exists"),
+  :nexists => UCMCommand("\\nexists", '∄', :mathord, "negated exists"),
+  :varnothing => UCMCommand("\\varnothing", '∅', :mathord, "circle, slash"),
+  :increment => UCMCommand("\\increment", '∆', :mathord, "laplacian (delta; nabla\\string^2)"),
+  :nabla => UCMCommand("\\nabla", '∇', :mathalpha, "nabla, del, hamilton operator"),
+  :in => UCMCommand("\\in", '∈', :mathrel, "set membership, variant"),
+  :notin => UCMCommand("\\notin", '∉', :mathrel, "negated set membership"),
+  :smallin => UCMCommand("\\smallin", '∊', :mathrel, "set membership (small set membership)"),
+  :ni => UCMCommand("\\ni", '∋', :mathrel, "contains, variant"),
+  :nni => UCMCommand("\\nni", '∌', :mathrel, "negated contains, variant"),
+  :smallni => UCMCommand("\\smallni", '∍', :mathrel, "/ni /owns r: contains (small contains as member)"),
+  :QED => UCMCommand("\\QED", '∎', :mathord, "end of proof"),
+  :prod => UCMCommand("\\prod", '∏', :mathop, "product operator"),
+  :coprod => UCMCommand("\\coprod", '∐', :mathop, "coproduct operator"),
+  :sum => UCMCommand("\\sum", '∑', :mathop, "summation operator"),
+  :minus => UCMCommand("\\minus", '−', :mathbin, "minus sign"),
+  :mp => UCMCommand("\\mp", '∓', :mathbin, "minus-or-plus sign"),
+  :dotplus => UCMCommand("\\dotplus", '∔', :mathbin, "plus sign, dot above"),
+  :divslash => UCMCommand("\\divslash", '∕', :mathbin, "division slash"),
+  :setminus => UCMCommand("\\setminus", '∖', :mathbin, "set minus (cf. reverse solidus)"),
+  :ast => UCMCommand("\\ast", '∗', :mathbin, "centered asterisk"),
+  :vysmwhtcircle => UCMCommand("\\vysmwhtcircle", '∘', :mathbin, "composite function (small circle)"),
+  :vysmblkcircle => UCMCommand("\\vysmblkcircle", '∙', :mathbin, "bullet operator"),
+  :sqrt => UCMCommand("\\sqrt", '√', :mathopen, "radical"),
+  :surd => UCMCommand("\\surd", '√', :mathord, "radical"),
+  :cuberoot => UCMCommand("\\cuberoot", '∛', :mathopen, "cube root"),
+  :fourthroot => UCMCommand("\\fourthroot", '∜', :mathopen, "fourth root"),
+  :propto => UCMCommand("\\propto", '∝', :mathrel, "is proportional to"),
+  :infty => UCMCommand("\\infty", '∞', :mathord, "infinity"),
+  :rightangle => UCMCommand("\\rightangle", '∟', :mathord, "right (90 degree) angle"),
+  :angle => UCMCommand("\\angle", '∠', :mathord, "angle"),
+  :measuredangle => UCMCommand("\\measuredangle", '∡', :mathord, "angle-measured"),
+  :sphericalangle => UCMCommand("\\sphericalangle", '∢', :mathord, "angle-spherical"),
+  :mid => UCMCommand("\\mid", '∣', :mathrel, "/mid r:"),
+  :nmid => UCMCommand("\\nmid", '∤', :mathrel, "negated mid"),
+  :parallel => UCMCommand("\\parallel", '∥', :mathrel, "parallel"),
+  :nparallel => UCMCommand("\\nparallel", '∦', :mathrel, "not parallel"),
+  :wedge => UCMCommand("\\wedge", '∧', :mathbin, "/wedge /land b: logical and"),
+  :vee => UCMCommand("\\vee", '∨', :mathbin, "/vee /lor b: logical or"),
+  :cap => UCMCommand("\\cap", '∩', :mathbin, "intersection"),
+  :cup => UCMCommand("\\cup", '∪', :mathbin, "union or logical sum"),
+  :int => UCMCommand("\\int", '∫', :mathop, "integral operator"),
+  :iint => UCMCommand("\\iint", '∬', :mathop, "double integral operator"),
+  :iiint => UCMCommand("\\iiint", '∭', :mathop, "triple integral operator"),
+  :oint => UCMCommand("\\oint", '∮', :mathop, "contour integral operator"),
+  :oiint => UCMCommand("\\oiint", '∯', :mathop, "double contour integral operator"),
+  :oiiint => UCMCommand("\\oiiint", '∰', :mathop, "triple contour integral operator"),
+  :intclockwise => UCMCommand("\\intclockwise", '∱', :mathop, "clockwise integral"),
+  :varointclockwise => UCMCommand("\\varointclockwise", '∲', :mathop, "contour integral, clockwise"),
+  :ointctrclockwise => UCMCommand("\\ointctrclockwise", '∳', :mathop, "contour integral, anticlockwise"),
+  :therefore => UCMCommand("\\therefore", '∴', :mathord, "therefore"),
+  :because => UCMCommand("\\because", '∵', :mathord, "because"),
+  :mathratio => UCMCommand("\\mathratio", '∶', :mathrel, "ratio"),
+  :Colon => UCMCommand("\\Colon", '∷', :mathrel, "two colons"),
+  :dotminus => UCMCommand("\\dotminus", '∸', :mathbin, "minus sign, dot above"),
+  :dashcolon => UCMCommand("\\dashcolon", '∹', :mathrel, "excess (-:)"),
+  :dotsminusdots => UCMCommand("\\dotsminusdots", '∺', :mathrel, "minus with four dots, geometric properties"),
+  :kernelcontraction => UCMCommand("\\kernelcontraction", '∻', :mathrel, "homothetic"),
+  :sim => UCMCommand("\\sim", '∼', :mathrel, "similar"),
+  :backsim => UCMCommand("\\backsim", '∽', :mathrel, "reverse similar"),
+  :invlazys => UCMCommand("\\invlazys", '∾', :mathbin, "most positive [inverted lazy s]"),
+  :sinewave => UCMCommand("\\sinewave", '∿', :mathord, "sine wave"),
+  :wr => UCMCommand("\\wr", '≀', :mathbin, "wreath product"),
+  :nsim => UCMCommand("\\nsim", '≁', :mathrel, "not similar"),
+  :eqsim => UCMCommand("\\eqsim", '≂', :mathrel, "equals, similar"),
+  :simeq => UCMCommand("\\simeq", '≃', :mathrel, "similar, equals"),
+  :nsime => UCMCommand("\\nsime", '≄', :mathrel, "not similar, equals"),
+  :sime => UCMCommand("\\sime", '≃', :mathrel, "similar, equals (alias)"),
+  :nsimeq => UCMCommand("\\nsimeq", '≄', :mathrel, "not similar, equals (alias)"),
+  :cong => UCMCommand("\\cong", '≅', :mathrel, "congruent with"),
+  :simneqq => UCMCommand("\\simneqq", '≆', :mathrel, "similar, not equals [vert only for 9573 entity]"),
+  :ncong => UCMCommand("\\ncong", '≇', :mathrel, "not congruent with"),
+  :approx => UCMCommand("\\approx", '≈', :mathrel, "approximate"),
+  :napprox => UCMCommand("\\napprox", '≉', :mathrel, "not approximate"),
+  :approxeq => UCMCommand("\\approxeq", '≊', :mathrel, "approximate, equals"),
+  :approxident => UCMCommand("\\approxident", '≋', :mathrel, "approximately identical to"),
+  :backcong => UCMCommand("\\backcong", '≌', :mathrel, "all equal to"),
+  :asymp => UCMCommand("\\asymp", '≍', :mathrel, "asymptotically equal to"),
+  :Bumpeq => UCMCommand("\\Bumpeq", '≎', :mathrel, "bumpy equals"),
+  :bumpeq => UCMCommand("\\bumpeq", '≏', :mathrel, "bumpy equals, equals"),
+  :doteq => UCMCommand("\\doteq", '≐', :mathrel, "equals, single dot above"),
+  :Doteq => UCMCommand("\\Doteq", '≑', :mathrel, "/doteqdot /doteq r: equals, even dots"),
+  :fallingdotseq => UCMCommand("\\fallingdotseq", '≒', :mathrel, "equals, falling dots"),
+  :risingdotseq => UCMCommand("\\risingdotseq", '≓', :mathrel, "equals, rising dots"),
+  :coloneq => UCMCommand("\\coloneq", '≔', :mathrel, "colon, equals"),
+  :eqcolon => UCMCommand("\\eqcolon", '≕', :mathrel, "equals, colon"),
+  :eqcirc => UCMCommand("\\eqcirc", '≖', :mathrel, "circle on equals sign"),
+  :circeq => UCMCommand("\\circeq", '≗', :mathrel, "circle, equals"),
+  :arceq => UCMCommand("\\arceq", '≘', :mathrel, "arc, equals; corresponds to"),
+  :wedgeq => UCMCommand("\\wedgeq", '≙', :mathrel, "corresponds to (wedge, equals)"),
+  :veeeq => UCMCommand("\\veeeq", '≚', :mathrel, "logical or, equals"),
+  :stareq => UCMCommand("\\stareq", '≛', :mathrel, "star equals"),
+  :triangleq => UCMCommand("\\triangleq", '≜', :mathrel, "triangle, equals"),
+  :eqdef => UCMCommand("\\eqdef", '≝', :mathrel, "equals by definition"),
+  :measeq => UCMCommand("\\measeq", '≞', :mathrel, "measured by (m over equals)"),
+  :questeq => UCMCommand("\\questeq", '≟', :mathrel, "equal with questionmark"),
+  :ne => UCMCommand("\\ne", '≠', :mathrel, "/ne /neq r: not equal"),
+  :equiv => UCMCommand("\\equiv", '≡', :mathrel, "identical with"),
+  :nequiv => UCMCommand("\\nequiv", '≢', :mathrel, "not identical with"),
+  :Equiv => UCMCommand("\\Equiv", '≣', :mathrel, "strict equivalence (4 lines)"),
+  :leq => UCMCommand("\\leq", '≤', :mathrel, "/leq /le r: less-than-or-equal"),
+  :geq => UCMCommand("\\geq", '≥', :mathrel, "/geq /ge r: greater-than-or-equal"),
+  :leqq => UCMCommand("\\leqq", '≦', :mathrel, "less, double equals"),
+  :geqq => UCMCommand("\\geqq", '≧', :mathrel, "greater, double equals"),
+  :lneqq => UCMCommand("\\lneqq", '≨', :mathrel, "less, not double equals"),
+  :gneqq => UCMCommand("\\gneqq", '≩', :mathrel, "greater, not double equals"),
+  :ll => UCMCommand("\\ll", '≪', :mathrel, "much less than, type 2"),
+  :gg => UCMCommand("\\gg", '≫', :mathrel, "much greater than, type 2"),
+  :between => UCMCommand("\\between", '≬', :mathrel, "between"),
+  :nasymp => UCMCommand("\\nasymp", '≭', :mathrel, "not asymptotically equal to"),
+  :nless => UCMCommand("\\nless", '≮', :mathrel, "not less-than"),
+  :ngtr => UCMCommand("\\ngtr", '≯', :mathrel, "not greater-than"),
+  :nleq => UCMCommand("\\nleq", '≰', :mathrel, "not less-than-or-equal"),
+  :ngeq => UCMCommand("\\ngeq", '≱', :mathrel, "not greater-than-or-equal"),
+  :lesssim => UCMCommand("\\lesssim", '≲', :mathrel, "less, similar"),
+  :gtrsim => UCMCommand("\\gtrsim", '≳', :mathrel, "greater, similar"),
+  :nlesssim => UCMCommand("\\nlesssim", '≴', :mathrel, "not less, similar"),
+  :ngtrsim => UCMCommand("\\ngtrsim", '≵', :mathrel, "not greater, similar"),
+  :lessgtr => UCMCommand("\\lessgtr", '≶', :mathrel, "less, greater"),
+  :gtrless => UCMCommand("\\gtrless", '≷', :mathrel, "greater, less"),
+  :nlessgtr => UCMCommand("\\nlessgtr", '≸', :mathrel, "not less, greater"),
+  :ngtrless => UCMCommand("\\ngtrless", '≹', :mathrel, "not greater, less"),
+  :prec => UCMCommand("\\prec", '≺', :mathrel, "precedes"),
+  :succ => UCMCommand("\\succ", '≻', :mathrel, "succeeds"),
+  :preccurlyeq => UCMCommand("\\preccurlyeq", '≼', :mathrel, "precedes, curly equals"),
+  :succcurlyeq => UCMCommand("\\succcurlyeq", '≽', :mathrel, "succeeds, curly equals"),
+  :precsim => UCMCommand("\\precsim", '≾', :mathrel, "precedes, similar"),
+  :succsim => UCMCommand("\\succsim", '≿', :mathrel, "succeeds, similar"),
+  :nprec => UCMCommand("\\nprec", '⊀', :mathrel, "not precedes"),
+  :nsucc => UCMCommand("\\nsucc", '⊁', :mathrel, "not succeeds"),
+  :subset => UCMCommand("\\subset", '⊂', :mathrel, "subset or is implied by"),
+  :supset => UCMCommand("\\supset", '⊃', :mathrel, "superset or implies"),
+  :nsubset => UCMCommand("\\nsubset", '⊄', :mathrel, "not subset, variant [slash negation]"),
+  :nsupset => UCMCommand("\\nsupset", '⊅', :mathrel, "not superset, variant [slash negation]"),
+  :subseteq => UCMCommand("\\subseteq", '⊆', :mathrel, "subset, equals"),
+  :supseteq => UCMCommand("\\supseteq", '⊇', :mathrel, "superset, equals"),
+  :nsubseteq => UCMCommand("\\nsubseteq", '⊈', :mathrel, "not subset, equals"),
+  :nsupseteq => UCMCommand("\\nsupseteq", '⊉', :mathrel, "not superset, equals"),
+  :subsetneq => UCMCommand("\\subsetneq", '⊊', :mathrel, "subset, not equals"),
+  :supsetneq => UCMCommand("\\supsetneq", '⊋', :mathrel, "superset, not equals"),
+  :cupleftarrow => UCMCommand("\\cupleftarrow", '⊌', :mathbin, "multiset"),
+  :cupdot => UCMCommand("\\cupdot", '⊍', :mathbin, "union, with dot"),
+  :uplus => UCMCommand("\\uplus", '⊎', :mathbin, "plus sign in union"),
+  :sqsubset => UCMCommand("\\sqsubset", '⊏', :mathrel, "square subset"),
+  :sqsupset => UCMCommand("\\sqsupset", '⊐', :mathrel, "square superset"),
+  :sqsubseteq => UCMCommand("\\sqsubseteq", '⊑', :mathrel, "square subset, equals"),
+  :sqsupseteq => UCMCommand("\\sqsupseteq", '⊒', :mathrel, "square superset, equals"),
+  :sqcap => UCMCommand("\\sqcap", '⊓', :mathbin, "square intersection"),
+  :sqcup => UCMCommand("\\sqcup", '⊔', :mathbin, "square union"),
+  :oplus => UCMCommand("\\oplus", '⊕', :mathbin, "plus sign in circle"),
+  :ominus => UCMCommand("\\ominus", '⊖', :mathbin, "minus sign in circle"),
+  :otimes => UCMCommand("\\otimes", '⊗', :mathbin, "multiply sign in circle"),
+  :oslash => UCMCommand("\\oslash", '⊘', :mathbin, "solidus in circle"),
+  :odot => UCMCommand("\\odot", '⊙', :mathbin, "middle dot in circle"),
+  :circledcirc => UCMCommand("\\circledcirc", '⊚', :mathbin, "small circle in circle"),
+  :circledast => UCMCommand("\\circledast", '⊛', :mathbin, "asterisk in circle"),
+  :circledequal => UCMCommand("\\circledequal", '⊜', :mathbin, "equal in circle"),
+  :circleddash => UCMCommand("\\circleddash", '⊝', :mathbin, "hyphen in circle"),
+  :boxplus => UCMCommand("\\boxplus", '⊞', :mathbin, "plus sign in box"),
+  :boxminus => UCMCommand("\\boxminus", '⊟', :mathbin, "minus sign in box"),
+  :boxtimes => UCMCommand("\\boxtimes", '⊠', :mathbin, "multiply sign in box"),
+  :boxdot => UCMCommand("\\boxdot", '⊡', :mathbin, "/dotsquare /boxdot b: small dot in box"),
+  :vdash => UCMCommand("\\vdash", '⊢', :mathrel, "vertical, dash"),
+  :dashv => UCMCommand("\\dashv", '⊣', :mathrel, "dash, vertical"),
+  :top => UCMCommand("\\top", '⊤', :mathord, "top"),
+  :bot => UCMCommand("\\bot", '⊥', :mathord, "bottom"),
+  :assert => UCMCommand("\\assert", '⊦', :mathrel, "assertion (vertical, short dash)"),
+  :models => UCMCommand("\\models", '⊧', :mathrel, "models (vertical, short double dash)"),
+  :vDash => UCMCommand("\\vDash", '⊨', :mathrel, "vertical, double dash"),
+  :Vdash => UCMCommand("\\Vdash", '⊩', :mathrel, "double vertical, dash"),
+  :Vvdash => UCMCommand("\\Vvdash", '⊪', :mathrel, "triple vertical, dash"),
+  :VDash => UCMCommand("\\VDash", '⊫', :mathrel, "double vert, double dash"),
+  :nvdash => UCMCommand("\\nvdash", '⊬', :mathrel, "not vertical, dash"),
+  :nvDash => UCMCommand("\\nvDash", '⊭', :mathrel, "not vertical, double dash"),
+  :nVdash => UCMCommand("\\nVdash", '⊮', :mathrel, "not double vertical, dash"),
+  :nVDash => UCMCommand("\\nVDash", '⊯', :mathrel, "not double vert, double dash"),
+  :prurel => UCMCommand("\\prurel", '⊰', :mathrel, "element precedes under relation"),
+  :scurel => UCMCommand("\\scurel", '⊱', :mathrel, "succeeds under relation"),
+  :vartriangleleft => UCMCommand("\\vartriangleleft", '⊲', :mathrel, "left triangle, open, variant"),
+  :vartriangleright => UCMCommand("\\vartriangleright", '⊳', :mathrel, "right triangle, open, variant"),
+  :trianglelefteq => UCMCommand("\\trianglelefteq", '⊴', :mathrel, "left triangle, equals"),
+  :trianglerighteq => UCMCommand("\\trianglerighteq", '⊵', :mathrel, "right triangle, equals"),
+  :origof => UCMCommand("\\origof", '⊶', :mathrel, "original of"),
+  :imageof => UCMCommand("\\imageof", '⊷', :mathrel, "image of"),
+  :multimap => UCMCommand("\\multimap", '⊸', :mathrel, "/multimap a:"),
+  :hermitmatrix => UCMCommand("\\hermitmatrix", '⊹', :mathord, "hermitian conjugate matrix"),
+  :intercal => UCMCommand("\\intercal", '⊺', :mathbin, "intercal"),
+  :veebar => UCMCommand("\\veebar", '⊻', :mathbin, "logical or, bar below (large vee); exclusive disjunction"),
+  :barwedge => UCMCommand("\\barwedge", '⊼', :mathbin, "bar, wedge (large wedge)"),
+  :barvee => UCMCommand("\\barvee", '⊽', :mathbin, "bar, vee (large vee)"),
+  :measuredrightangle => UCMCommand("\\measuredrightangle", '⊾', :mathord, "right angle-measured [with arc]"),
+  :varlrtriangle => UCMCommand("\\varlrtriangle", '⊿', :mathord, "right triangle"),
+  :bigwedge => UCMCommand("\\bigwedge", '⋀', :mathop, "logical and operator"),
+  :bigvee => UCMCommand("\\bigvee", '⋁', :mathop, "logical or operator"),
+  :bigcap => UCMCommand("\\bigcap", '⋂', :mathop, "intersection operator"),
+  :bigcup => UCMCommand("\\bigcup", '⋃', :mathop, "union operator"),
+  :smwhtdiamond => UCMCommand("\\smwhtdiamond", '⋄', :mathbin, "white diamond"),
+  :cdot => UCMCommand("\\cdot", '⋅', :mathbin, "small middle dot"),
+  :star => UCMCommand("\\star", '⋆', :mathbin, "small star, filled, low"),
+  :divideontimes => UCMCommand("\\divideontimes", '⋇', :mathbin, "division on times"),
+  :bowtie => UCMCommand("\\bowtie", '⋈', :mathrel, "bowtie"),
+  :ltimes => UCMCommand("\\ltimes", '⋉', :mathbin, "times sign, left closed"),
+  :rtimes => UCMCommand("\\rtimes", '⋊', :mathbin, "times sign, right closed"),
+  :leftthreetimes => UCMCommand("\\leftthreetimes", '⋋', :mathbin, "left semidirect product"),
+  :rightthreetimes => UCMCommand("\\rightthreetimes", '⋌', :mathbin, "right semidirect product"),
+  :backsimeq => UCMCommand("\\backsimeq", '⋍', :mathrel, "reverse similar, equals"),
+  :curlyvee => UCMCommand("\\curlyvee", '⋎', :mathbin, "curly logical or"),
+  :curlywedge => UCMCommand("\\curlywedge", '⋏', :mathbin, "curly logical and"),
+  :Subset => UCMCommand("\\Subset", '⋐', :mathrel, "double subset"),
+  :Supset => UCMCommand("\\Supset", '⋑', :mathrel, "double superset"),
+  :Cap => UCMCommand("\\Cap", '⋒', :mathbin, "/cap /doublecap b: double intersection"),
+  :Cup => UCMCommand("\\Cup", '⋓', :mathbin, "/cup /doublecup b: double union"),
+  :pitchfork => UCMCommand("\\pitchfork", '⋔', :mathrel, "pitchfork"),
+  :equalparallel => UCMCommand("\\equalparallel", '⋕', :mathrel, "parallel, equal; equal or parallel"),
+  :lessdot => UCMCommand("\\lessdot", '⋖', :mathrel, "less than, with dot"),
+  :gtrdot => UCMCommand("\\gtrdot", '⋗', :mathrel, "greater than, with dot"),
+  :lll => UCMCommand("\\lll", '⋘', :mathrel, "/ll /lll /llless r: triple less-than"),
+  :ggg => UCMCommand("\\ggg", '⋙', :mathrel, "/ggg /gg /gggtr r: triple greater-than"),
+  :lesseqgtr => UCMCommand("\\lesseqgtr", '⋚', :mathrel, "less, equals, greater"),
+  :gtreqless => UCMCommand("\\gtreqless", '⋛', :mathrel, "greater, equals, less"),
+  :eqless => UCMCommand("\\eqless", '⋜', :mathrel, "equal-or-less"),
+  :eqgtr => UCMCommand("\\eqgtr", '⋝', :mathrel, "equal-or-greater"),
+  :curlyeqprec => UCMCommand("\\curlyeqprec", '⋞', :mathrel, "curly equals, precedes"),
+  :curlyeqsucc => UCMCommand("\\curlyeqsucc", '⋟', :mathrel, "curly equals, succeeds"),
+  :npreccurlyeq => UCMCommand("\\npreccurlyeq", '⋠', :mathrel, "not precedes, curly equals"),
+  :nsucccurlyeq => UCMCommand("\\nsucccurlyeq", '⋡', :mathrel, "not succeeds, curly equals"),
+  :nsqsubseteq => UCMCommand("\\nsqsubseteq", '⋢', :mathrel, "not, square subset, equals"),
+  :nsqsupseteq => UCMCommand("\\nsqsupseteq", '⋣', :mathrel, "not, square superset, equals"),
+  :sqsubsetneq => UCMCommand("\\sqsubsetneq", '⋤', :mathrel, "square subset, not equals"),
+  :sqsupsetneq => UCMCommand("\\sqsupsetneq", '⋥', :mathrel, "square superset, not equals"),
+  :lnsim => UCMCommand("\\lnsim", '⋦', :mathrel, "less, not similar"),
+  :gnsim => UCMCommand("\\gnsim", '⋧', :mathrel, "greater, not similar"),
+  :precnsim => UCMCommand("\\precnsim", '⋨', :mathrel, "precedes, not similar"),
+  :succnsim => UCMCommand("\\succnsim", '⋩', :mathrel, "succeeds, not similar"),
+  :nvartriangleleft => UCMCommand("\\nvartriangleleft", '⋪', :mathrel, "not left triangle"),
+  :nvartriangleright => UCMCommand("\\nvartriangleright", '⋫', :mathrel, "not right triangle"),
+  :ntrianglelefteq => UCMCommand("\\ntrianglelefteq", '⋬', :mathrel, "not left triangle, equals"),
+  :ntrianglerighteq => UCMCommand("\\ntrianglerighteq", '⋭', :mathrel, "not right triangle, equals"),
+  :vdots => UCMCommand("\\vdots", '⋮', :mathrel, "vertical ellipsis"),
+  :unicodecdots => UCMCommand("\\unicodecdots", '⋯', :mathord, "three dots, centered"),
+  :adots => UCMCommand("\\adots", '⋰', :mathrel, "three dots, ascending"),
+  :ddots => UCMCommand("\\ddots", '⋱', :mathrel, "three dots, descending"),
+  :disin => UCMCommand("\\disin", '⋲', :mathrel, "element of with long horizontal stroke"),
+  :varisins => UCMCommand("\\varisins", '⋳', :mathrel, "element of with vertical bar at end of horizontal stroke"),
+  :isins => UCMCommand("\\isins", '⋴', :mathrel, "small element of with vertical bar at end of horizontal stroke"),
+  :isindot => UCMCommand("\\isindot", '⋵', :mathrel, "element of with dot above"),
+  :varisinobar => UCMCommand("\\varisinobar", '⋶', :mathrel, "element of with overbar"),
+  :isinobar => UCMCommand("\\isinobar", '⋷', :mathrel, "small element of with overbar"),
+  :isinvb => UCMCommand("\\isinvb", '⋸', :mathrel, "element of with underbar"),
+  :isinE => UCMCommand("\\isinE", '⋹', :mathrel, "element of with two horizontal strokes"),
+  :nisd => UCMCommand("\\nisd", '⋺', :mathrel, "contains with long horizontal stroke"),
+  :varnis => UCMCommand("\\varnis", '⋻', :mathrel, "contains with vertical bar at end of horizontal stroke"),
+  :nis => UCMCommand("\\nis", '⋼', :mathrel, "small contains with vertical bar at end of horizontal stroke"),
+  :varniobar => UCMCommand("\\varniobar", '⋽', :mathrel, "contains with overbar"),
+  :niobar => UCMCommand("\\niobar", '⋾', :mathrel, "small contains with overbar"),
+  :bagmember => UCMCommand("\\bagmember", '⋿', :mathrel, "z notation bag membership"),
+  :diameter => UCMCommand("\\diameter", '⌀', :mathord, "diameter sign"),
+  :house => UCMCommand("\\house", '⌂', :mathord, "house"),
+  :varbarwedge => UCMCommand("\\varbarwedge", '⌅', :mathbin, "/barwedge b: logical and, bar above [projective (bar over small wedge)]"),
+  :vardoublebarwedge => UCMCommand("\\vardoublebarwedge", '⌆', :mathbin, "/doublebarwedge b: logical and, double bar above [perspective (double bar over small wedge)]"),
+  :lceil => UCMCommand("\\lceil", '⌈', :mathopen, "left ceiling"),
+  :rceil => UCMCommand("\\rceil", '⌉', :mathclose, "right ceiling"),
+  :lfloor => UCMCommand("\\lfloor", '⌊', :mathopen, "left floor"),
+  :rfloor => UCMCommand("\\rfloor", '⌋', :mathclose, "right floor"),
+  :invnot => UCMCommand("\\invnot", '⌐', :mathord, "reverse not"),
+  :sqlozenge => UCMCommand("\\sqlozenge", '⌑', :mathord, "square lozenge"),
+  :profline => UCMCommand("\\profline", '⌒', :mathord, "profile of a line"),
+  :profsurf => UCMCommand("\\profsurf", '⌓', :mathord, "profile of a surface"),
+  :viewdata => UCMCommand("\\viewdata", '⌗', :mathord, "viewdata square"),
+  :turnednot => UCMCommand("\\turnednot", '⌙', :mathord, "turned not sign"),
+  :ulcorner => UCMCommand("\\ulcorner", '⌜', :mathopen, "upper left corner"),
+  :urcorner => UCMCommand("\\urcorner", '⌝', :mathclose, "upper right corner"),
+  :llcorner => UCMCommand("\\llcorner", '⌞', :mathopen, "lower left corner"),
+  :lrcorner => UCMCommand("\\lrcorner", '⌟', :mathclose, "lower right corner"),
+  :inttop => UCMCommand("\\inttop", '⌠', :mathord, "top half integral"),
+  :intbottom => UCMCommand("\\intbottom", '⌡', :mathord, "bottom half integral"),
+  :frown => UCMCommand("\\frown", '⌢', :mathrel, "down curve"),
+  :smile => UCMCommand("\\smile", '⌣', :mathrel, "up curve"),
+  :varhexagonlrbonds => UCMCommand("\\varhexagonlrbonds", '⌬', :mathord, "six carbon ring, corner down, double bonds lower right etc"),
+  :conictaper => UCMCommand("\\conictaper", '⌲', :mathord, "conical taper "),
+  :topbot => UCMCommand("\\topbot", '⌶', :mathord, "top and bottom"),
+  :obar => UCMCommand("\\obar", '⌽', :mathbin, "circle with vertical bar"),
+  :APLnotslash => UCMCommand("\\APLnotslash", '⌿', :mathrel, "solidus, bar through (apl functional symbol slash bar)"),
+  :APLnotbackslash => UCMCommand("\\APLnotbackslash", '⍀', :mathord, "apl functional symbol backslash bar"),
+  :APLboxupcaret => UCMCommand("\\APLboxupcaret", '⍓', :mathord, "boxed up caret"),
+  :APLboxquestion => UCMCommand("\\APLboxquestion", '⍰', :mathord, "boxed question mark"),
+  :rangledownzigzagarrow => UCMCommand("\\rangledownzigzagarrow", '⍼', :mathord, "right angle with downwards zigzag arrow"),
+  :hexagon => UCMCommand("\\hexagon", '⎔', :mathord, "horizontal benzene ring [hexagon flat open]"),
+  :lparenuend => UCMCommand("\\lparenuend", '⎛', :mathord, "left parenthesis upper hook"),
+  :lparenextender => UCMCommand("\\lparenextender", '⎜', :mathord, "left parenthesis extension"),
+  :lparenlend => UCMCommand("\\lparenlend", '⎝', :mathord, "left parenthesis lower hook"),
+  :rparenuend => UCMCommand("\\rparenuend", '⎞', :mathord, "right parenthesis upper hook"),
+  :rparenextender => UCMCommand("\\rparenextender", '⎟', :mathord, "right parenthesis extension"),
+  :rparenlend => UCMCommand("\\rparenlend", '⎠', :mathord, "right parenthesis lower hook"),
+  :lbrackuend => UCMCommand("\\lbrackuend", '⎡', :mathord, "left square bracket upper corner"),
+  :lbrackextender => UCMCommand("\\lbrackextender", '⎢', :mathord, "left square bracket extension"),
+  :lbracklend => UCMCommand("\\lbracklend", '⎣', :mathord, "left square bracket lower corner"),
+  :rbrackuend => UCMCommand("\\rbrackuend", '⎤', :mathord, "right square bracket upper corner"),
+  :rbrackextender => UCMCommand("\\rbrackextender", '⎥', :mathord, "right square bracket extension"),
+  :rbracklend => UCMCommand("\\rbracklend", '⎦', :mathord, "right square bracket lower corner"),
+  :lbraceuend => UCMCommand("\\lbraceuend", '⎧', :mathord, "left curly bracket upper hook"),
+  :lbracemid => UCMCommand("\\lbracemid", '⎨', :mathord, "left curly bracket middle piece"),
+  :lbracelend => UCMCommand("\\lbracelend", '⎩', :mathord, "left curly bracket lower hook"),
+  :vbraceextender => UCMCommand("\\vbraceextender", '⎪', :mathord, "curly bracket extension"),
+  :rbraceuend => UCMCommand("\\rbraceuend", '⎫', :mathord, "right curly bracket upper hook"),
+  :rbracemid => UCMCommand("\\rbracemid", '⎬', :mathord, "right curly bracket middle piece"),
+  :rbracelend => UCMCommand("\\rbracelend", '⎭', :mathord, "right curly bracket lower hook"),
+  :intextender => UCMCommand("\\intextender", '⎮', :mathord, "integral extension"),
+  :harrowextender => UCMCommand("\\harrowextender", '⎯', :mathord, "horizontal line extension (used to extend arrows)"),
+  :lmoustache => UCMCommand("\\lmoustache", '⎰', :mathopen, "upper left or lower right curly bracket section"),
+  :rmoustache => UCMCommand("\\rmoustache", '⎱', :mathclose, "upper right or lower left curly bracket section"),
+  :sumtop => UCMCommand("\\sumtop", '⎲', :mathord, "summation top"),
+  :sumbottom => UCMCommand("\\sumbottom", '⎳', :mathord, "summation bottom"),
+  :overbracket => UCMCommand("\\overbracket", '⎴', :mathover, "top square bracket"),
+  :underbracket => UCMCommand("\\underbracket", '⎵', :mathunder, "bottom square bracket"),
+  :bbrktbrk => UCMCommand("\\bbrktbrk", '⎶', :mathord, "bottom square bracket over top square bracket"),
+  :sqrtbottom => UCMCommand("\\sqrtbottom", '⎷', :mathord, "radical symbol bottom"),
+  :lvboxline => UCMCommand("\\lvboxline", '⎸', :mathord, "left vertical box line"),
+  :rvboxline => UCMCommand("\\rvboxline", '⎹', :mathord, "right vertical box line"),
+  :varcarriagereturn => UCMCommand("\\varcarriagereturn", '⏎', :mathord, "return symbol"),
+  :overparen => UCMCommand("\\overparen", '⏜', :mathover, "top parenthesis (mathematical use)"),
+  :underparen => UCMCommand("\\underparen", '⏝', :mathunder, "bottom parenthesis (mathematical use)"),
+  :overbrace => UCMCommand("\\overbrace", '⏞', :mathover, "top curly bracket (mathematical use)"),
+  :underbrace => UCMCommand("\\underbrace", '⏟', :mathunder, "bottom curly bracket (mathematical use)"),
+  :obrbrak => UCMCommand("\\obrbrak", '⏠', :mathord, "top tortoise shell bracket (mathematical use)"),
+  :ubrbrak => UCMCommand("\\ubrbrak", '⏡', :mathord, "bottom tortoise shell bracket (mathematical use)"),
+  :trapezium => UCMCommand("\\trapezium", '⏢', :mathord, "white trapezium"),
+  :benzenr => UCMCommand("\\benzenr", '⏣', :mathord, "benzene ring with circle"),
+  :strns => UCMCommand("\\strns", '⏤', :mathord, "straightness"),
+  :fltns => UCMCommand("\\fltns", '⏥', :mathord, "flatness"),
+  :accurrent => UCMCommand("\\accurrent", '⏦', :mathord, "ac current"),
+  :elinters => UCMCommand("\\elinters", '⏧', :mathord, "electrical intersection"),
+  :blanksymbol => UCMCommand("\\blanksymbol", '␢', :mathord, "blank symbol"),
+  :mathvisiblespace => UCMCommand("\\mathvisiblespace", '␣', :mathord, "open box"),
+  :bdtriplevdash => UCMCommand("\\bdtriplevdash", '┆', :mathord, "doubly broken vert"),
+  :blockuphalf => UCMCommand("\\blockuphalf", '▀', :mathord, "upper half block"),
+  :blocklowhalf => UCMCommand("\\blocklowhalf", '▄', :mathord, "lower half block"),
+  :blockfull => UCMCommand("\\blockfull", '█', :mathord, "full block"),
+  :blocklefthalf => UCMCommand("\\blocklefthalf", '▌', :mathord, "left half block"),
+  :blockrighthalf => UCMCommand("\\blockrighthalf", '▐', :mathord, "right half block"),
+  :blockqtrshaded => UCMCommand("\\blockqtrshaded", '░', :mathord, "25\\% shaded block"),
+  :blockhalfshaded => UCMCommand("\\blockhalfshaded", '▒', :mathord, "50\\% shaded block"),
+  :blockthreeqtrshaded => UCMCommand("\\blockthreeqtrshaded", '▓', :mathord, "75\\% shaded block"),
+  :mdlgblksquare => UCMCommand("\\mdlgblksquare", '■', :mathord, "square, filled"),
+  :mdlgwhtsquare => UCMCommand("\\mdlgwhtsquare", '□', :mathord, "square, open"),
+  :squoval => UCMCommand("\\squoval", '▢', :mathord, "white square with rounded corners"),
+  :blackinwhitesquare => UCMCommand("\\blackinwhitesquare", '▣', :mathord, "white square containing black small square"),
+  :squarehfill => UCMCommand("\\squarehfill", '▤', :mathord, "square, horizontal rule filled"),
+  :squarevfill => UCMCommand("\\squarevfill", '▥', :mathord, "square, vertical rule filled"),
+  :squarehvfill => UCMCommand("\\squarehvfill", '▦', :mathord, "square with orthogonal crosshatch fill"),
+  :squarenwsefill => UCMCommand("\\squarenwsefill", '▧', :mathord, "square, nw-to-se rule filled"),
+  :squareneswfill => UCMCommand("\\squareneswfill", '▨', :mathord, "square, ne-to-sw rule filled"),
+  :squarecrossfill => UCMCommand("\\squarecrossfill", '▩', :mathord, "square with diagonal crosshatch fill"),
+  :smblksquare => UCMCommand("\\smblksquare", '▪', :mathord, "/blacksquare - sq bullet, filled"),
+  :smwhtsquare => UCMCommand("\\smwhtsquare", '▫', :mathord, "white small square"),
+  :hrectangleblack => UCMCommand("\\hrectangleblack", '▬', :mathord, "black rectangle"),
+  :hrectangle => UCMCommand("\\hrectangle", '▭', :mathord, "horizontal rectangle, open"),
+  :vrectangleblack => UCMCommand("\\vrectangleblack", '▮', :mathord, "black vertical rectangle"),
+  :vrectangle => UCMCommand("\\vrectangle", '▯', :mathord, "rectangle, white (vertical)"),
+  :parallelogramblack => UCMCommand("\\parallelogramblack", '▰', :mathord, "black parallelogram"),
+  :parallelogram => UCMCommand("\\parallelogram", '▱', :mathord, "parallelogram, open"),
+  :bigblacktriangleup => UCMCommand("\\bigblacktriangleup", '▲', :mathord, "black up-pointing triangle"),
+  :bigtriangleup => UCMCommand("\\bigtriangleup", '△', :mathbin, "big up triangle, open"),
+  :blacktriangle => UCMCommand("\\blacktriangle", '▴', :mathord, "up triangle, filled"),
+  :vartriangle => UCMCommand("\\vartriangle", '▵', :mathrel, "/triangle - up triangle, open"),
+  :blacktriangleright => UCMCommand("\\blacktriangleright", '▶', :mathord, "(large) right triangle, filled"),
+  :triangleright => UCMCommand("\\triangleright", '▷', :mathbin, "(large) right triangle, open; z notation range restriction"),
+  :smallblacktriangleright => UCMCommand("\\smallblacktriangleright", '▸', :mathord, "right triangle, filled"),
+  :smalltriangleright => UCMCommand("\\smalltriangleright", '▹', :mathord, "right triangle, open"),
+  :blackpointerright => UCMCommand("\\blackpointerright", '►', :mathord, "black right-pointing pointer"),
+  :whitepointerright => UCMCommand("\\whitepointerright", '▻', :mathord, "white right-pointing pointer"),
+  :bigblacktriangledown => UCMCommand("\\bigblacktriangledown", '▼', :mathord, "big down triangle, filled"),
+  :bigtriangledown => UCMCommand("\\bigtriangledown", '▽', :mathord, "big down triangle, open"),
+  :blacktriangledown => UCMCommand("\\blacktriangledown", '▾', :mathord, "down triangle, filled"),
+  :triangledown => UCMCommand("\\triangledown", '▿', :mathord, "down triangle, open"),
+  :blacktriangleleft => UCMCommand("\\blacktriangleleft", '◀', :mathord, "(large) left triangle, filled"),
+  :triangleleft => UCMCommand("\\triangleleft", '◁', :mathbin, "(large) left triangle, open; z notation domain restriction"),
+  :smallblacktriangleleft => UCMCommand("\\smallblacktriangleleft", '◂', :mathord, "left triangle, filled"),
+  :smalltriangleleft => UCMCommand("\\smalltriangleleft", '◃', :mathord, "left triangle, open"),
+  :blackpointerleft => UCMCommand("\\blackpointerleft", '◄', :mathord, "black left-pointing pointer"),
+  :whitepointerleft => UCMCommand("\\whitepointerleft", '◅', :mathord, "white left-pointing pointer"),
+  :mdlgblkdiamond => UCMCommand("\\mdlgblkdiamond", '◆', :mathord, "black diamond"),
+  :mdlgwhtdiamond => UCMCommand("\\mdlgwhtdiamond", '◇', :mathord, "white diamond; diamond, open"),
+  :blackinwhitediamond => UCMCommand("\\blackinwhitediamond", '◈', :mathord, "white diamond containing black small diamond"),
+  :fisheye => UCMCommand("\\fisheye", '◉', :mathord, "fisheye"),
+  :mdlgwhtlozenge => UCMCommand("\\mdlgwhtlozenge", '◊', :mathord, "lozenge or total mark"),
+  :mdlgwhtcircle => UCMCommand("\\mdlgwhtcircle", '○', :mathbin, "medium large circle"),
+  :dottedcircle => UCMCommand("\\dottedcircle", '◌', :mathord, "dotted circle"),
+  :circlevertfill => UCMCommand("\\circlevertfill", '◍', :mathord, "circle with vertical fill"),
+  :bullseye => UCMCommand("\\bullseye", '◎', :mathord, "bullseye"),
+  :mdlgblkcircle => UCMCommand("\\mdlgblkcircle", '●', :mathord, "circle, filled"),
+  :circlelefthalfblack => UCMCommand("\\circlelefthalfblack", '◐', :mathord, "circle, filled left half [harvey ball]"),
+  :circlerighthalfblack => UCMCommand("\\circlerighthalfblack", '◑', :mathord, "circle, filled right half"),
+  :circlebottomhalfblack => UCMCommand("\\circlebottomhalfblack", '◒', :mathord, "circle, filled bottom half"),
+  :circletophalfblack => UCMCommand("\\circletophalfblack", '◓', :mathord, "circle, filled top half"),
+  :circleurquadblack => UCMCommand("\\circleurquadblack", '◔', :mathord, "circle with upper right quadrant black"),
+  :blackcircleulquadwhite => UCMCommand("\\blackcircleulquadwhite", '◕', :mathord, "circle with all but upper left quadrant black"),
+  :blacklefthalfcircle => UCMCommand("\\blacklefthalfcircle", '◖', :mathord, "left half black circle"),
+  :blackrighthalfcircle => UCMCommand("\\blackrighthalfcircle", '◗', :mathord, "right half black circle"),
+  :inversebullet => UCMCommand("\\inversebullet", '◘', :mathord, "inverse bullet "),
+  :inversewhitecircle => UCMCommand("\\inversewhitecircle", '◙', :mathord, "inverse white circle"),
+  :invwhiteupperhalfcircle => UCMCommand("\\invwhiteupperhalfcircle", '◚', :mathord, "upper half inverse white circle"),
+  :invwhitelowerhalfcircle => UCMCommand("\\invwhitelowerhalfcircle", '◛', :mathord, "lower half inverse white circle"),
+  :ularc => UCMCommand("\\ularc", '◜', :mathord, "upper left quadrant circular arc"),
+  :urarc => UCMCommand("\\urarc", '◝', :mathord, "upper right quadrant circular arc"),
+  :lrarc => UCMCommand("\\lrarc", '◞', :mathord, "lower right quadrant circular arc"),
+  :llarc => UCMCommand("\\llarc", '◟', :mathord, "lower left quadrant circular arc"),
+  :topsemicircle => UCMCommand("\\topsemicircle", '◠', :mathord, "upper half circle"),
+  :botsemicircle => UCMCommand("\\botsemicircle", '◡', :mathord, "lower half circle"),
+  :lrblacktriangle => UCMCommand("\\lrblacktriangle", '◢', :mathord, "lower right triangle, filled"),
+  :llblacktriangle => UCMCommand("\\llblacktriangle", '◣', :mathord, "lower left triangle, filled"),
+  :ulblacktriangle => UCMCommand("\\ulblacktriangle", '◤', :mathord, "upper left triangle, filled"),
+  :urblacktriangle => UCMCommand("\\urblacktriangle", '◥', :mathord, "upper right triangle, filled"),
+  :smwhtcircle => UCMCommand("\\smwhtcircle", '◦', :mathord, "white bullet"),
+  :squareleftblack => UCMCommand("\\squareleftblack", '◧', :mathord, "square, filled left half"),
+  :squarerightblack => UCMCommand("\\squarerightblack", '◨', :mathord, "square, filled right half"),
+  :squareulblack => UCMCommand("\\squareulblack", '◩', :mathord, "square, filled top left corner"),
+  :squarelrblack => UCMCommand("\\squarelrblack", '◪', :mathord, "square, filled bottom right corner"),
+  :boxbar => UCMCommand("\\boxbar", '◫', :mathbin, "vertical bar in box"),
+  :trianglecdot => UCMCommand("\\trianglecdot", '◬', :mathord, "triangle with centered dot"),
+  :triangleleftblack => UCMCommand("\\triangleleftblack", '◭', :mathord, "up-pointing triangle with left half black"),
+  :trianglerightblack => UCMCommand("\\trianglerightblack", '◮', :mathord, "up-pointing triangle with right half black"),
+  :lgwhtcircle => UCMCommand("\\lgwhtcircle", '◯', :mathord, "large circle"),
+  :squareulquad => UCMCommand("\\squareulquad", '◰', :mathord, "white square with upper left quadrant"),
+  :squarellquad => UCMCommand("\\squarellquad", '◱', :mathord, "white square with lower left quadrant"),
+  :squarelrquad => UCMCommand("\\squarelrquad", '◲', :mathord, "white square with lower right quadrant"),
+  :squareurquad => UCMCommand("\\squareurquad", '◳', :mathord, "white square with upper right quadrant"),
+  :circleulquad => UCMCommand("\\circleulquad", '◴', :mathord, "white circle with upper left quadrant"),
+  :circlellquad => UCMCommand("\\circlellquad", '◵', :mathord, "white circle with lower left quadrant"),
+  :circlelrquad => UCMCommand("\\circlelrquad", '◶', :mathord, "white circle with lower right quadrant"),
+  :circleurquad => UCMCommand("\\circleurquad", '◷', :mathord, "white circle with upper right quadrant"),
+  :ultriangle => UCMCommand("\\ultriangle", '◸', :mathord, "upper left triangle"),
+  :urtriangle => UCMCommand("\\urtriangle", '◹', :mathord, "upper right triangle"),
+  :lltriangle => UCMCommand("\\lltriangle", '◺', :mathord, "lower left triangle"),
+  :mdwhtsquare => UCMCommand("\\mdwhtsquare", '◻', :mathord, "white medium square"),
+  :mdblksquare => UCMCommand("\\mdblksquare", '◼', :mathord, "black medium square"),
+  :mdsmwhtsquare => UCMCommand("\\mdsmwhtsquare", '◽', :mathord, "white medium small square"),
+  :mdsmblksquare => UCMCommand("\\mdsmblksquare", '◾', :mathord, "black medium small square"),
+  :lrtriangle => UCMCommand("\\lrtriangle", '◿', :mathord, "lower right triangle"),
+  :bigstar => UCMCommand("\\bigstar", '★', :mathord, "star, filled"),
+  :bigwhitestar => UCMCommand("\\bigwhitestar", '☆', :mathord, "star, open"),
+  :astrosun => UCMCommand("\\astrosun", '☉', :mathord, "sun"),
+  :danger => UCMCommand("\\danger", '☡', :mathord, "dangerous bend (caution sign)"),
+  :blacksmiley => UCMCommand("\\blacksmiley", '☻', :mathord, "black smiling face"),
+  :sun => UCMCommand("\\sun", '☼', :mathord, "white sun with rays"),
+  :rightmoon => UCMCommand("\\rightmoon", '☽', :mathord, "first quarter moon"),
+  :leftmoon => UCMCommand("\\leftmoon", '☾', :mathord, "last quarter moon"),
+  :female => UCMCommand("\\female", '♀', :mathord, "venus, female"),
+  :male => UCMCommand("\\male", '♂', :mathord, "mars, male"),
+  :spadesuit => UCMCommand("\\spadesuit", '♠', :mathord, "spades suit symbol"),
+  :heartsuit => UCMCommand("\\heartsuit", '♡', :mathord, "heart suit symbol"),
+  :diamondsuit => UCMCommand("\\diamondsuit", '♢', :mathord, "diamond suit symbol"),
+  :clubsuit => UCMCommand("\\clubsuit", '♣', :mathord, "club suit symbol"),
+  :varspadesuit => UCMCommand("\\varspadesuit", '♤', :mathord, "spade, white (card suit)"),
+  :varheartsuit => UCMCommand("\\varheartsuit", '♥', :mathord, "filled heart (card suit)"),
+  :vardiamondsuit => UCMCommand("\\vardiamondsuit", '♦', :mathord, "filled diamond (card suit)"),
+  :varclubsuit => UCMCommand("\\varclubsuit", '♧', :mathord, "club, white (card suit)"),
+  :quarternote => UCMCommand("\\quarternote", '♩', :mathord, "music note (sung text sign)"),
+  :eighthnote => UCMCommand("\\eighthnote", '♪', :mathord, "eighth note"),
+  :twonotes => UCMCommand("\\twonotes", '♫', :mathord, "beamed eighth notes"),
+  :flat => UCMCommand("\\flat", '♭', :mathord, "musical flat"),
+  :natural => UCMCommand("\\natural", '♮', :mathord, "music natural"),
+  :sharp => UCMCommand("\\sharp", '♯', :mathord, "musical sharp"),
+  :acidfree => UCMCommand("\\acidfree", '♾', :mathord, "permanent paper sign"),
+  :dicei => UCMCommand("\\dicei", '⚀', :mathord, "die face-1"),
+  :diceii => UCMCommand("\\diceii", '⚁', :mathord, "die face-2"),
+  :diceiii => UCMCommand("\\diceiii", '⚂', :mathord, "die face-3"),
+  :diceiv => UCMCommand("\\diceiv", '⚃', :mathord, "die face-4"),
+  :dicev => UCMCommand("\\dicev", '⚄', :mathord, "die face-5"),
+  :dicevi => UCMCommand("\\dicevi", '⚅', :mathord, "die face-6"),
+  :circledrightdot => UCMCommand("\\circledrightdot", '⚆', :mathord, "white circle with dot right"),
+  :circledtwodots => UCMCommand("\\circledtwodots", '⚇', :mathord, "white circle with two dots"),
+  :blackcircledrightdot => UCMCommand("\\blackcircledrightdot", '⚈', :mathord, "black circle with white dot right"),
+  :blackcircledtwodots => UCMCommand("\\blackcircledtwodots", '⚉', :mathord, "black circle with two white dots"),
+  :Hermaphrodite => UCMCommand("\\Hermaphrodite", '⚥', :mathord, "male and female sign"),
+  :mdwhtcircle => UCMCommand("\\mdwhtcircle", '⚪', :mathord, "medium white circle"),
+  :mdblkcircle => UCMCommand("\\mdblkcircle", '⚫', :mathord, "medium black circle"),
+  :mdsmwhtcircle => UCMCommand("\\mdsmwhtcircle", '⚬', :mathord, "medium small white circle"),
+  :neuter => UCMCommand("\\neuter", '⚲', :mathord, "neuter"),
+  :checkmark => UCMCommand("\\checkmark", '✓', :mathord, "tick, check mark"),
+  :maltese => UCMCommand("\\maltese", '✠', :mathord, "maltese cross"),
+  :circledstar => UCMCommand("\\circledstar", '✪', :mathord, "circled white star"),
+  :varstar => UCMCommand("\\varstar", '✶', :mathord, "six pointed black star"),
+  :dingasterisk => UCMCommand("\\dingasterisk", '✽', :mathord, "heavy teardrop-spoked asterisk"),
+  :lbrbrak => UCMCommand("\\lbrbrak", '❲', :mathopen, "light left tortoise shell bracket ornament"),
+  :rbrbrak => UCMCommand("\\rbrbrak", '❳', :mathclose, "light right tortoise shell bracket ornament"),
+  :draftingarrow => UCMCommand("\\draftingarrow", '➛', :mathord, "right arrow with bold head (drafting)"),
+  :threedangle => UCMCommand("\\threedangle", '⟀', :mathord, "three dimensional angle"),
+  :whiteinwhitetriangle => UCMCommand("\\whiteinwhitetriangle", '⟁', :mathord, "white triangle containing small white triangle"),
+  :perp => UCMCommand("\\perp", '⟂', :mathrel, "perpendicular"),
+  :subsetcirc => UCMCommand("\\subsetcirc", '⟃', :mathord, "open subset"),
+  :supsetcirc => UCMCommand("\\supsetcirc", '⟄', :mathord, "open superset"),
+  :lbag => UCMCommand("\\lbag", '⟅', :mathopen, "left s-shaped bag delimiter"),
+  :rbag => UCMCommand("\\rbag", '⟆', :mathclose, "right s-shaped bag delimiter"),
+  :veedot => UCMCommand("\\veedot", '⟇', :mathbin, "or with dot inside"),
+  :bsolhsub => UCMCommand("\\bsolhsub", '⟈', :mathrel, "reverse solidus preceding subset"),
+  :suphsol => UCMCommand("\\suphsol", '⟉', :mathrel, "superset preceding solidus"),
+  :diagup => UCMCommand("\\diagup", '⟋', :mathord, "mathematical rising diagonal"),
+  :longdivision => UCMCommand("\\longdivision", '⟌', :mathopen, "long division"),
+  :diagdown => UCMCommand("\\diagdown", '⟍', :mathord, "mathematical falling diagonal"),
+  :diamondcdot => UCMCommand("\\diamondcdot", '⟐', :mathord, "white diamond with centred dot"),
+  :wedgedot => UCMCommand("\\wedgedot", '⟑', :mathbin, "and with dot"),
+  :upin => UCMCommand("\\upin", '⟒', :mathrel, "element of opening upwards"),
+  :pullback => UCMCommand("\\pullback", '⟓', :mathrel, "lower right corner with dot"),
+  :pushout => UCMCommand("\\pushout", '⟔', :mathrel, "upper left corner with dot"),
+  :leftouterjoin => UCMCommand("\\leftouterjoin", '⟕', :mathop, "left outer join"),
+  :rightouterjoin => UCMCommand("\\rightouterjoin", '⟖', :mathop, "right outer join"),
+  :fullouterjoin => UCMCommand("\\fullouterjoin", '⟗', :mathop, "full outer join"),
+  :bigbot => UCMCommand("\\bigbot", '⟘', :mathop, "large up tack"),
+  :bigtop => UCMCommand("\\bigtop", '⟙', :mathop, "large down tack"),
+  :DashVDash => UCMCommand("\\DashVDash", '⟚', :mathrel, "left and right double turnstile"),
+  :dashVdash => UCMCommand("\\dashVdash", '⟛', :mathrel, "left and right tack"),
+  :multimapinv => UCMCommand("\\multimapinv", '⟜', :mathrel, "left multimap"),
+  :vlongdash => UCMCommand("\\vlongdash", '⟝', :mathrel, "long left tack"),
+  :longdashv => UCMCommand("\\longdashv", '⟞', :mathrel, "long right tack"),
+  :cirbot => UCMCommand("\\cirbot", '⟟', :mathrel, "up tack with circle above"),
+  :lozengeminus => UCMCommand("\\lozengeminus", '⟠', :mathbin, "lozenge divided by horizontal rule"),
+  :concavediamond => UCMCommand("\\concavediamond", '⟡', :mathbin, "white concave-sided diamond"),
+  :concavediamondtickleft => UCMCommand("\\concavediamondtickleft", '⟢', :mathbin, "white concave-sided diamond with leftwards tick"),
+  :concavediamondtickright => UCMCommand("\\concavediamondtickright", '⟣', :mathbin, "white concave-sided diamond with rightwards tick"),
+  :whitesquaretickleft => UCMCommand("\\whitesquaretickleft", '⟤', :mathbin, "white square with leftwards tick"),
+  :whitesquaretickright => UCMCommand("\\whitesquaretickright", '⟥', :mathbin, "white square with rightwards tick"),
+  :lBrack => UCMCommand("\\lBrack", '⟦', :mathopen, "mathematical left white square bracket"),
+  :rBrack => UCMCommand("\\rBrack", '⟧', :mathclose, "mathematical right white square bracket"),
+  :langle => UCMCommand("\\langle", '⟨', :mathopen, "mathematical left angle bracket"),
+  :rangle => UCMCommand("\\rangle", '⟩', :mathclose, "mathematical right angle bracket"),
+  :lAngle => UCMCommand("\\lAngle", '⟪', :mathopen, "mathematical left double angle bracket"),
+  :rAngle => UCMCommand("\\rAngle", '⟫', :mathclose, "mathematical right double angle bracket"),
+  :Lbrbrak => UCMCommand("\\Lbrbrak", '⟬', :mathopen, "mathematical left white tortoise shell bracket"),
+  :Rbrbrak => UCMCommand("\\Rbrbrak", '⟭', :mathclose, "mathematical right white tortoise shell bracket"),
+  :lgroup => UCMCommand("\\lgroup", '⟮', :mathopen, "mathematical left flattened parenthesis"),
+  :rgroup => UCMCommand("\\rgroup", '⟯', :mathclose, "mathematical right flattened parenthesis"),
+  :UUparrow => UCMCommand("\\UUparrow", '⟰', :mathrel, "upwards quadruple arrow"),
+  :DDownarrow => UCMCommand("\\DDownarrow", '⟱', :mathrel, "downwards quadruple arrow"),
+  :acwgapcirclearrow => UCMCommand("\\acwgapcirclearrow", '⟲', :mathrel, "anticlockwise gapped circle arrow"),
+  :cwgapcirclearrow => UCMCommand("\\cwgapcirclearrow", '⟳', :mathrel, "clockwise gapped circle arrow"),
+  :rightarrowonoplus => UCMCommand("\\rightarrowonoplus", '⟴', :mathrel, "right arrow with circled plus"),
+  :longleftarrow => UCMCommand("\\longleftarrow", '⟵', :mathrel, "long leftwards arrow"),
+  :longrightarrow => UCMCommand("\\longrightarrow", '⟶', :mathrel, "long rightwards arrow"),
+  :longleftrightarrow => UCMCommand("\\longleftrightarrow", '⟷', :mathrel, "long left right arrow"),
+  :Longleftarrow => UCMCommand("\\Longleftarrow", '⟸', :mathrel, "long leftwards double arrow"),
+  :Longrightarrow => UCMCommand("\\Longrightarrow", '⟹', :mathrel, "long rightwards double arrow"),
+  :Longleftrightarrow => UCMCommand("\\Longleftrightarrow", '⟺', :mathrel, "long left right double arrow"),
+  :longmapsfrom => UCMCommand("\\longmapsfrom", '⟻', :mathrel, "long leftwards arrow from bar"),
+  :longmapsto => UCMCommand("\\longmapsto", '⟼', :mathrel, "long rightwards arrow from bar"),
+  :Longmapsfrom => UCMCommand("\\Longmapsfrom", '⟽', :mathrel, "long leftwards double arrow from bar"),
+  :Longmapsto => UCMCommand("\\Longmapsto", '⟾', :mathrel, "long rightwards double arrow from bar"),
+  :longrightsquigarrow => UCMCommand("\\longrightsquigarrow", '⟿', :mathrel, "long rightwards squiggle arrow"),
+  :nvtwoheadrightarrow => UCMCommand("\\nvtwoheadrightarrow", '⤀', :mathrel, "rightwards two-headed arrow with vertical stroke"),
+  :nVtwoheadrightarrow => UCMCommand("\\nVtwoheadrightarrow", '⤁', :mathrel, "rightwards two-headed arrow with double vertical stroke"),
+  :nvLeftarrow => UCMCommand("\\nvLeftarrow", '⤂', :mathrel, "leftwards double arrow with vertical stroke"),
+  :nvRightarrow => UCMCommand("\\nvRightarrow", '⤃', :mathrel, "rightwards double arrow with vertical stroke"),
+  :nvLeftrightarrow => UCMCommand("\\nvLeftrightarrow", '⤄', :mathrel, "left right double arrow with vertical stroke"),
+  :twoheadmapsto => UCMCommand("\\twoheadmapsto", '⤅', :mathrel, "rightwards two-headed arrow from bar"),
+  :Mapsfrom => UCMCommand("\\Mapsfrom", '⤆', :mathrel, "leftwards double arrow from bar"),
+  :Mapsto => UCMCommand("\\Mapsto", '⤇', :mathrel, "rightwards double arrow from bar"),
+  :downarrowbarred => UCMCommand("\\downarrowbarred", '⤈', :mathrel, "downwards arrow with horizontal stroke"),
+  :uparrowbarred => UCMCommand("\\uparrowbarred", '⤉', :mathrel, "upwards arrow with horizontal stroke"),
+  :Uuparrow => UCMCommand("\\Uuparrow", '⤊', :mathrel, "upwards triple arrow"),
+  :Ddownarrow => UCMCommand("\\Ddownarrow", '⤋', :mathrel, "downwards triple arrow"),
+  :leftbkarrow => UCMCommand("\\leftbkarrow", '⤌', :mathrel, "leftwards double dash arrow"),
+  :rightbkarrow => UCMCommand("\\rightbkarrow", '⤍', :mathrel, "rightwards double dash arrow"),
+  :leftdbkarrow => UCMCommand("\\leftdbkarrow", '⤎', :mathrel, "leftwards triple dash arrow"),
+  :dbkarrow => UCMCommand("\\dbkarrow", '⤏', :mathrel, "rightwards triple dash arrow"),
+  :drbkarrow => UCMCommand("\\drbkarrow", '⤐', :mathrel, "rightwards two-headed triple dash arrow"),
+  :rightdotarrow => UCMCommand("\\rightdotarrow", '⤑', :mathrel, "rightwards arrow with dotted stem"),
+  :baruparrow => UCMCommand("\\baruparrow", '⤒', :mathrel, "upwards arrow to bar"),
+  :downarrowbar => UCMCommand("\\downarrowbar", '⤓', :mathrel, "downwards arrow to bar"),
+  :nvrightarrowtail => UCMCommand("\\nvrightarrowtail", '⤔', :mathrel, "rightwards arrow with tail with vertical stroke"),
+  :nVrightarrowtail => UCMCommand("\\nVrightarrowtail", '⤕', :mathrel, "rightwards arrow with tail with double vertical stroke"),
+  :twoheadrightarrowtail => UCMCommand("\\twoheadrightarrowtail", '⤖', :mathrel, "rightwards two-headed arrow with tail"),
+  :nvtwoheadrightarrowtail => UCMCommand("\\nvtwoheadrightarrowtail", '⤗', :mathrel, "rightwards two-headed arrow with tail with vertical stroke"),
+  :nVtwoheadrightarrowtail => UCMCommand("\\nVtwoheadrightarrowtail", '⤘', :mathrel, "rightwards two-headed arrow with tail with double vertical stroke"),
+  :lefttail => UCMCommand("\\lefttail", '⤙', :mathrel, "leftwards arrow-tail"),
+  :righttail => UCMCommand("\\righttail", '⤚', :mathrel, "rightwards arrow-tail"),
+  :leftdbltail => UCMCommand("\\leftdbltail", '⤛', :mathrel, "leftwards double arrow-tail"),
+  :rightdbltail => UCMCommand("\\rightdbltail", '⤜', :mathrel, "rightwards double arrow-tail"),
+  :diamondleftarrow => UCMCommand("\\diamondleftarrow", '⤝', :mathrel, "leftwards arrow to black diamond"),
+  :rightarrowdiamond => UCMCommand("\\rightarrowdiamond", '⤞', :mathrel, "rightwards arrow to black diamond"),
+  :diamondleftarrowbar => UCMCommand("\\diamondleftarrowbar", '⤟', :mathrel, "leftwards arrow from bar to black diamond"),
+  :barrightarrowdiamond => UCMCommand("\\barrightarrowdiamond", '⤠', :mathrel, "rightwards arrow from bar to black diamond"),
+  :nwsearrow => UCMCommand("\\nwsearrow", '⤡', :mathrel, "north west and south east arrow"),
+  :neswarrow => UCMCommand("\\neswarrow", '⤢', :mathrel, "north east and south west arrow"),
+  :hknwarrow => UCMCommand("\\hknwarrow", '⤣', :mathrel, "north west arrow with hook"),
+  :hknearrow => UCMCommand("\\hknearrow", '⤤', :mathrel, "north east arrow with hook"),
+  :hksearrow => UCMCommand("\\hksearrow", '⤥', :mathrel, "south east arrow with hook"),
+  :hkswarrow => UCMCommand("\\hkswarrow", '⤦', :mathrel, "south west arrow with hook"),
+  :tona => UCMCommand("\\tona", '⤧', :mathrel, "north west arrow and north east arrow"),
+  :toea => UCMCommand("\\toea", '⤨', :mathrel, "north east arrow and south east arrow"),
+  :tosa => UCMCommand("\\tosa", '⤩', :mathrel, "south east arrow and south west arrow"),
+  :towa => UCMCommand("\\towa", '⤪', :mathrel, "south west arrow and north west arrow"),
+  :rdiagovfdiag => UCMCommand("\\rdiagovfdiag", '⤫', :mathord, "rising diagonal crossing falling diagonal"),
+  :fdiagovrdiag => UCMCommand("\\fdiagovrdiag", '⤬', :mathord, "falling diagonal crossing rising diagonal"),
+  :seovnearrow => UCMCommand("\\seovnearrow", '⤭', :mathord, "south east arrow crossing north east arrow"),
+  :neovsearrow => UCMCommand("\\neovsearrow", '⤮', :mathord, "north east arrow crossing south east arrow"),
+  :fdiagovnearrow => UCMCommand("\\fdiagovnearrow", '⤯', :mathord, "falling diagonal crossing north east arrow"),
+  :rdiagovsearrow => UCMCommand("\\rdiagovsearrow", '⤰', :mathord, "rising diagonal crossing south east arrow"),
+  :neovnwarrow => UCMCommand("\\neovnwarrow", '⤱', :mathord, "north east arrow crossing north west arrow"),
+  :nwovnearrow => UCMCommand("\\nwovnearrow", '⤲', :mathord, "north west arrow crossing north east arrow"),
+  :rightcurvedarrow => UCMCommand("\\rightcurvedarrow", '⤳', :mathrel, "wave arrow pointing directly right"),
+  :uprightcurvearrow => UCMCommand("\\uprightcurvearrow", '⤴', :mathord, "arrow pointing rightwards then curving upwards"),
+  :downrightcurvedarrow => UCMCommand("\\downrightcurvedarrow", '⤵', :mathord, "arrow pointing rightwards then curving downwards"),
+  :leftdowncurvedarrow => UCMCommand("\\leftdowncurvedarrow", '⤶', :mathrel, "arrow pointing downwards then curving leftwards"),
+  :rightdowncurvedarrow => UCMCommand("\\rightdowncurvedarrow", '⤷', :mathrel, "arrow pointing downwards then curving rightwards"),
+  :cwrightarcarrow => UCMCommand("\\cwrightarcarrow", '⤸', :mathrel, "right-side arc clockwise arrow"),
+  :acwleftarcarrow => UCMCommand("\\acwleftarcarrow", '⤹', :mathrel, "left-side arc anticlockwise arrow"),
+  :acwoverarcarrow => UCMCommand("\\acwoverarcarrow", '⤺', :mathrel, "top arc anticlockwise arrow"),
+  :acwunderarcarrow => UCMCommand("\\acwunderarcarrow", '⤻', :mathrel, "bottom arc anticlockwise arrow"),
+  :curvearrowrightminus => UCMCommand("\\curvearrowrightminus", '⤼', :mathrel, "top arc clockwise arrow with minus"),
+  :curvearrowleftplus => UCMCommand("\\curvearrowleftplus", '⤽', :mathrel, "top arc anticlockwise arrow with plus"),
+  :cwundercurvearrow => UCMCommand("\\cwundercurvearrow", '⤾', :mathrel, "lower right semicircular clockwise arrow"),
+  :ccwundercurvearrow => UCMCommand("\\ccwundercurvearrow", '⤿', :mathrel, "lower left semicircular anticlockwise arrow"),
+  :acwcirclearrow => UCMCommand("\\acwcirclearrow", '⥀', :mathrel, "anticlockwise closed circle arrow"),
+  :cwcirclearrow => UCMCommand("\\cwcirclearrow", '⥁', :mathrel, "clockwise closed circle arrow"),
+  :rightarrowshortleftarrow => UCMCommand("\\rightarrowshortleftarrow", '⥂', :mathrel, "rightwards arrow above short leftwards arrow"),
+  :leftarrowshortrightarrow => UCMCommand("\\leftarrowshortrightarrow", '⥃', :mathrel, "leftwards arrow above short rightwards arrow"),
+  :shortrightarrowleftarrow => UCMCommand("\\shortrightarrowleftarrow", '⥄', :mathrel, "short rightwards arrow above leftwards arrow"),
+  :rightarrowplus => UCMCommand("\\rightarrowplus", '⥅', :mathrel, "rightwards arrow with plus below"),
+  :leftarrowplus => UCMCommand("\\leftarrowplus", '⥆', :mathrel, "leftwards arrow with plus below"),
+  :rightarrowx => UCMCommand("\\rightarrowx", '⥇', :mathrel, "rightwards arrow through x"),
+  :leftrightarrowcircle => UCMCommand("\\leftrightarrowcircle", '⥈', :mathrel, "left right arrow through small circle"),
+  :twoheaduparrowcircle => UCMCommand("\\twoheaduparrowcircle", '⥉', :mathrel, "upwards two-headed arrow from small circle"),
+  :leftrightharpoonupdown => UCMCommand("\\leftrightharpoonupdown", '⥊', :mathrel, "left barb up right barb down harpoon"),
+  :leftrightharpoondownup => UCMCommand("\\leftrightharpoondownup", '⥋', :mathrel, "left barb down right barb up harpoon"),
+  :updownharpoonrightleft => UCMCommand("\\updownharpoonrightleft", '⥌', :mathrel, "up barb right down barb left harpoon"),
+  :updownharpoonleftright => UCMCommand("\\updownharpoonleftright", '⥍', :mathrel, "up barb left down barb right harpoon"),
+  :leftrightharpoonupup => UCMCommand("\\leftrightharpoonupup", '⥎', :mathrel, "left barb up right barb up harpoon"),
+  :updownharpoonrightright => UCMCommand("\\updownharpoonrightright", '⥏', :mathrel, "up barb right down barb right harpoon"),
+  :leftrightharpoondowndown => UCMCommand("\\leftrightharpoondowndown", '⥐', :mathrel, "left barb down right barb down harpoon"),
+  :updownharpoonleftleft => UCMCommand("\\updownharpoonleftleft", '⥑', :mathrel, "up barb left down barb left harpoon"),
+  :barleftharpoonup => UCMCommand("\\barleftharpoonup", '⥒', :mathrel, "leftwards harpoon with barb up to bar"),
+  :rightharpoonupbar => UCMCommand("\\rightharpoonupbar", '⥓', :mathrel, "rightwards harpoon with barb up to bar"),
+  :barupharpoonright => UCMCommand("\\barupharpoonright", '⥔', :mathrel, "upwards harpoon with barb right to bar"),
+  :downharpoonrightbar => UCMCommand("\\downharpoonrightbar", '⥕', :mathrel, "downwards harpoon with barb right to bar"),
+  :barleftharpoondown => UCMCommand("\\barleftharpoondown", '⥖', :mathrel, "leftwards harpoon with barb down to bar"),
+  :rightharpoondownbar => UCMCommand("\\rightharpoondownbar", '⥗', :mathrel, "rightwards harpoon with barb down to bar"),
+  :barupharpoonleft => UCMCommand("\\barupharpoonleft", '⥘', :mathrel, "upwards harpoon with barb left to bar"),
+  :downharpoonleftbar => UCMCommand("\\downharpoonleftbar", '⥙', :mathrel, "downwards harpoon with barb left to bar"),
+  :leftharpoonupbar => UCMCommand("\\leftharpoonupbar", '⥚', :mathrel, "leftwards harpoon with barb up from bar"),
+  :barrightharpoonup => UCMCommand("\\barrightharpoonup", '⥛', :mathrel, "rightwards harpoon with barb up from bar"),
+  :upharpoonrightbar => UCMCommand("\\upharpoonrightbar", '⥜', :mathrel, "upwards harpoon with barb right from bar"),
+  :bardownharpoonright => UCMCommand("\\bardownharpoonright", '⥝', :mathrel, "downwards harpoon with barb right from bar"),
+  :leftharpoondownbar => UCMCommand("\\leftharpoondownbar", '⥞', :mathrel, "leftwards harpoon with barb down from bar"),
+  :barrightharpoondown => UCMCommand("\\barrightharpoondown", '⥟', :mathrel, "rightwards harpoon with barb down from bar"),
+  :upharpoonleftbar => UCMCommand("\\upharpoonleftbar", '⥠', :mathrel, "upwards harpoon with barb left from bar"),
+  :bardownharpoonleft => UCMCommand("\\bardownharpoonleft", '⥡', :mathrel, "downwards harpoon with barb left from bar"),
+  :leftharpoonsupdown => UCMCommand("\\leftharpoonsupdown", '⥢', :mathrel, "leftwards harpoon with barb up above leftwards harpoon with barb down"),
+  :upharpoonsleftright => UCMCommand("\\upharpoonsleftright", '⥣', :mathrel, "upwards harpoon with barb left beside upwards harpoon with barb right"),
+  :rightharpoonsupdown => UCMCommand("\\rightharpoonsupdown", '⥤', :mathrel, "rightwards harpoon with barb up above rightwards harpoon with barb down"),
+  :downharpoonsleftright => UCMCommand("\\downharpoonsleftright", '⥥', :mathrel, "downwards harpoon with barb left beside downwards harpoon with barb right"),
+  :leftrightharpoonsup => UCMCommand("\\leftrightharpoonsup", '⥦', :mathrel, "leftwards harpoon with barb up above rightwards harpoon with barb up"),
+  :leftrightharpoonsdown => UCMCommand("\\leftrightharpoonsdown", '⥧', :mathrel, "leftwards harpoon with barb down above rightwards harpoon with barb down"),
+  :rightleftharpoonsup => UCMCommand("\\rightleftharpoonsup", '⥨', :mathrel, "rightwards harpoon with barb up above leftwards harpoon with barb up"),
+  :rightleftharpoonsdown => UCMCommand("\\rightleftharpoonsdown", '⥩', :mathrel, "rightwards harpoon with barb down above leftwards harpoon with barb down"),
+  :leftharpoonupdash => UCMCommand("\\leftharpoonupdash", '⥪', :mathrel, "leftwards harpoon with barb up above long dash"),
+  :dashleftharpoondown => UCMCommand("\\dashleftharpoondown", '⥫', :mathrel, "leftwards harpoon with barb down below long dash"),
+  :rightharpoonupdash => UCMCommand("\\rightharpoonupdash", '⥬', :mathrel, "rightwards harpoon with barb up above long dash"),
+  :dashrightharpoondown => UCMCommand("\\dashrightharpoondown", '⥭', :mathrel, "rightwards harpoon with barb down below long dash"),
+  :updownharpoonsleftright => UCMCommand("\\updownharpoonsleftright", '⥮', :mathrel, "upwards harpoon with barb left beside downwards harpoon with barb right"),
+  :downupharpoonsleftright => UCMCommand("\\downupharpoonsleftright", '⥯', :mathrel, "downwards harpoon with barb left beside upwards harpoon with barb right"),
+  :rightimply => UCMCommand("\\rightimply", '⥰', :mathrel, "right double arrow with rounded head"),
+  :equalrightarrow => UCMCommand("\\equalrightarrow", '⥱', :mathrel, "equals sign above rightwards arrow"),
+  :similarrightarrow => UCMCommand("\\similarrightarrow", '⥲', :mathrel, "tilde operator above rightwards arrow"),
+  :leftarrowsimilar => UCMCommand("\\leftarrowsimilar", '⥳', :mathrel, "leftwards arrow above tilde operator"),
+  :rightarrowsimilar => UCMCommand("\\rightarrowsimilar", '⥴', :mathrel, "rightwards arrow above tilde operator"),
+  :rightarrowapprox => UCMCommand("\\rightarrowapprox", '⥵', :mathrel, "rightwards arrow above almost equal to"),
+  :ltlarr => UCMCommand("\\ltlarr", '⥶', :mathrel, "less-than above leftwards arrow"),
+  :leftarrowless => UCMCommand("\\leftarrowless", '⥷', :mathrel, "leftwards arrow through less-than"),
+  :gtrarr => UCMCommand("\\gtrarr", '⥸', :mathrel, "greater-than above rightwards arrow"),
+  :subrarr => UCMCommand("\\subrarr", '⥹', :mathrel, "subset above rightwards arrow"),
+  :leftarrowsubset => UCMCommand("\\leftarrowsubset", '⥺', :mathrel, "leftwards arrow through subset"),
+  :suplarr => UCMCommand("\\suplarr", '⥻', :mathrel, "superset above leftwards arrow"),
+  :leftfishtail => UCMCommand("\\leftfishtail", '⥼', :mathrel, "left fish tail"),
+  :rightfishtail => UCMCommand("\\rightfishtail", '⥽', :mathrel, "right fish tail"),
+  :upfishtail => UCMCommand("\\upfishtail", '⥾', :mathrel, "up fish tail"),
+  :downfishtail => UCMCommand("\\downfishtail", '⥿', :mathrel, "down fish tail"),
+  :Vvert => UCMCommand("\\Vvert", '⦀', :mathfence, "triple vertical bar delimiter"),
+  :mdsmblkcircle => UCMCommand("\\mdsmblkcircle", '⦁', :mathord, "z notation spot"),
+  :typecolon => UCMCommand("\\typecolon", '⦂', :mathrel, "z notation type colon"),
+  :lBrace => UCMCommand("\\lBrace", '⦃', :mathopen, "left white curly bracket"),
+  :rBrace => UCMCommand("\\rBrace", '⦄', :mathclose, "right white curly bracket"),
+  :lParen => UCMCommand("\\lParen", '⦅', :mathopen, "left white parenthesis"),
+  :rParen => UCMCommand("\\rParen", '⦆', :mathclose, "right white parenthesis"),
+  :llparenthesis => UCMCommand("\\llparenthesis", '⦇', :mathopen, "z notation left image bracket"),
+  :rrparenthesis => UCMCommand("\\rrparenthesis", '⦈', :mathclose, "z notation right image bracket"),
+  :llangle => UCMCommand("\\llangle", '⦉', :mathopen, "z notation left binding bracket"),
+  :rrangle => UCMCommand("\\rrangle", '⦊', :mathclose, "z notation right binding bracket"),
+  :lbrackubar => UCMCommand("\\lbrackubar", '⦋', :mathopen, "left square bracket with underbar"),
+  :rbrackubar => UCMCommand("\\rbrackubar", '⦌', :mathclose, "right square bracket with underbar"),
+  :lbrackultick => UCMCommand("\\lbrackultick", '⦍', :mathopen, "left square bracket with tick in top corner"),
+  :rbracklrtick => UCMCommand("\\rbracklrtick", '⦎', :mathclose, "right square bracket with tick in bottom corner"),
+  :lbracklltick => UCMCommand("\\lbracklltick", '⦏', :mathopen, "left square bracket with tick in bottom corner"),
+  :rbrackurtick => UCMCommand("\\rbrackurtick", '⦐', :mathclose, "right square bracket with tick in top corner"),
+  :langledot => UCMCommand("\\langledot", '⦑', :mathopen, "left angle bracket with dot"),
+  :rangledot => UCMCommand("\\rangledot", '⦒', :mathclose, "right angle bracket with dot"),
+  :lparenless => UCMCommand("\\lparenless", '⦓', :mathopen, "left arc less-than bracket"),
+  :rparengtr => UCMCommand("\\rparengtr", '⦔', :mathclose, "right arc greater-than bracket"),
+  :Lparengtr => UCMCommand("\\Lparengtr", '⦕', :mathopen, "double left arc greater-than bracket"),
+  :Rparenless => UCMCommand("\\Rparenless", '⦖', :mathclose, "double right arc less-than bracket"),
+  :lblkbrbrak => UCMCommand("\\lblkbrbrak", '⦗', :mathopen, "left black tortoise shell bracket"),
+  :rblkbrbrak => UCMCommand("\\rblkbrbrak", '⦘', :mathclose, "right black tortoise shell bracket"),
+  :fourvdots => UCMCommand("\\fourvdots", '⦙', :mathord, "dotted fence"),
+  :vzigzag => UCMCommand("\\vzigzag", '⦚', :mathord, "vertical zigzag line"),
+  :measuredangleleft => UCMCommand("\\measuredangleleft", '⦛', :mathord, "measured angle opening left"),
+  :rightanglesqr => UCMCommand("\\rightanglesqr", '⦜', :mathord, "right angle variant with square"),
+  :rightanglemdot => UCMCommand("\\rightanglemdot", '⦝', :mathord, "measured right angle with dot"),
+  :angles => UCMCommand("\\angles", '⦞', :mathord, "angle with s inside"),
+  :angdnr => UCMCommand("\\angdnr", '⦟', :mathord, "acute angle"),
+  :gtlpar => UCMCommand("\\gtlpar", '⦠', :mathord, "spherical angle opening left"),
+  :sphericalangleup => UCMCommand("\\sphericalangleup", '⦡', :mathord, "spherical angle opening up"),
+  :turnangle => UCMCommand("\\turnangle", '⦢', :mathord, "turned angle"),
+  :revangle => UCMCommand("\\revangle", '⦣', :mathord, "reversed angle"),
+  :angleubar => UCMCommand("\\angleubar", '⦤', :mathord, "angle with underbar"),
+  :revangleubar => UCMCommand("\\revangleubar", '⦥', :mathord, "reversed angle with underbar"),
+  :wideangledown => UCMCommand("\\wideangledown", '⦦', :mathord, "oblique angle opening up"),
+  :wideangleup => UCMCommand("\\wideangleup", '⦧', :mathord, "oblique angle opening down"),
+  :measanglerutone => UCMCommand("\\measanglerutone", '⦨', :mathord, "measured angle with open arm ending in arrow pointing up and right"),
+  :measanglelutonw => UCMCommand("\\measanglelutonw", '⦩', :mathord, "measured angle with open arm ending in arrow pointing up and left"),
+  :measanglerdtose => UCMCommand("\\measanglerdtose", '⦪', :mathord, "measured angle with open arm ending in arrow pointing down and right"),
+  :measangleldtosw => UCMCommand("\\measangleldtosw", '⦫', :mathord, "measured angle with open arm ending in arrow pointing down and left"),
+  :measangleurtone => UCMCommand("\\measangleurtone", '⦬', :mathord, "measured angle with open arm ending in arrow pointing right and up"),
+  :measangleultonw => UCMCommand("\\measangleultonw", '⦭', :mathord, "measured angle with open arm ending in arrow pointing left and up"),
+  :measangledrtose => UCMCommand("\\measangledrtose", '⦮', :mathord, "measured angle with open arm ending in arrow pointing right and down"),
+  :measangledltosw => UCMCommand("\\measangledltosw", '⦯', :mathord, "measured angle with open arm ending in arrow pointing left and down"),
+  :revemptyset => UCMCommand("\\revemptyset", '⦰', :mathord, "reversed empty set"),
+  :emptysetobar => UCMCommand("\\emptysetobar", '⦱', :mathord, "empty set with overbar"),
+  :emptysetocirc => UCMCommand("\\emptysetocirc", '⦲', :mathord, "empty set with small circle above"),
+  :emptysetoarr => UCMCommand("\\emptysetoarr", '⦳', :mathord, "empty set with right arrow above"),
+  :emptysetoarrl => UCMCommand("\\emptysetoarrl", '⦴', :mathord, "empty set with left arrow above"),
+  :circlehbar => UCMCommand("\\circlehbar", '⦵', :mathbin, "circle with horizontal bar"),
+  :circledvert => UCMCommand("\\circledvert", '⦶', :mathbin, "circled vertical bar"),
+  :circledparallel => UCMCommand("\\circledparallel", '⦷', :mathbin, "circled parallel"),
+  :obslash => UCMCommand("\\obslash", '⦸', :mathbin, "circled reverse solidus"),
+  :operp => UCMCommand("\\operp", '⦹', :mathbin, "circled perpendicular"),
+  :obot => UCMCommand("\\obot", '⦺', :mathord, "circle divided by horizontal bar and top half divided by vertical bar"),
+  :olcross => UCMCommand("\\olcross", '⦻', :mathord, "circle with superimposed x"),
+  :odotslashdot => UCMCommand("\\odotslashdot", '⦼', :mathord, "circled anticlockwise-rotated division sign"),
+  :uparrowoncircle => UCMCommand("\\uparrowoncircle", '⦽', :mathord, "up arrow through circle"),
+  :circledwhitebullet => UCMCommand("\\circledwhitebullet", '⦾', :mathord, "circled white bullet"),
+  :circledbullet => UCMCommand("\\circledbullet", '⦿', :mathord, "circled bullet"),
+  :olessthan => UCMCommand("\\olessthan", '⧀', :mathbin, "circled less-than"),
+  :ogreaterthan => UCMCommand("\\ogreaterthan", '⧁', :mathbin, "circled greater-than"),
+  :cirscir => UCMCommand("\\cirscir", '⧂', :mathord, "circle with small circle to the right"),
+  :cirE => UCMCommand("\\cirE", '⧃', :mathord, "circle with two horizontal strokes to the right"),
+  :boxdiag => UCMCommand("\\boxdiag", '⧄', :mathbin, "squared rising diagonal slash"),
+  :boxbslash => UCMCommand("\\boxbslash", '⧅', :mathbin, "squared falling diagonal slash"),
+  :boxast => UCMCommand("\\boxast", '⧆', :mathbin, "squared asterisk"),
+  :boxcircle => UCMCommand("\\boxcircle", '⧇', :mathbin, "squared small circle"),
+  :boxbox => UCMCommand("\\boxbox", '⧈', :mathbin, "squared square"),
+  :boxonbox => UCMCommand("\\boxonbox", '⧉', :mathord, "two joined squares"),
+  :triangleodot => UCMCommand("\\triangleodot", '⧊', :mathord, "triangle with dot above"),
+  :triangleubar => UCMCommand("\\triangleubar", '⧋', :mathord, "triangle with underbar"),
+  :triangles => UCMCommand("\\triangles", '⧌', :mathord, "s in triangle"),
+  :triangleserifs => UCMCommand("\\triangleserifs", '⧍', :mathbin, "triangle with serifs at bottom"),
+  :rtriltri => UCMCommand("\\rtriltri", '⧎', :mathrel, "right triangle above left triangle"),
+  :ltrivb => UCMCommand("\\ltrivb", '⧏', :mathrel, "left triangle beside vertical bar"),
+  :vbrtri => UCMCommand("\\vbrtri", '⧐', :mathrel, "vertical bar beside right triangle"),
+  :lfbowtie => UCMCommand("\\lfbowtie", '⧑', :mathrel, "left black bowtie"),
+  :rfbowtie => UCMCommand("\\rfbowtie", '⧒', :mathrel, "right black bowtie"),
+  :fbowtie => UCMCommand("\\fbowtie", '⧓', :mathrel, "black bowtie"),
+  :lftimes => UCMCommand("\\lftimes", '⧔', :mathrel, "left black times"),
+  :rftimes => UCMCommand("\\rftimes", '⧕', :mathrel, "right black times"),
+  :hourglass => UCMCommand("\\hourglass", '⧖', :mathbin, "white hourglass"),
+  :blackhourglass => UCMCommand("\\blackhourglass", '⧗', :mathbin, "black hourglass"),
+  :lvzigzag => UCMCommand("\\lvzigzag", '⧘', :mathopen, "left wiggly fence"),
+  :rvzigzag => UCMCommand("\\rvzigzag", '⧙', :mathclose, "right wiggly fence"),
+  :Lvzigzag => UCMCommand("\\Lvzigzag", '⧚', :mathopen, "left double wiggly fence"),
+  :Rvzigzag => UCMCommand("\\Rvzigzag", '⧛', :mathclose, "right double wiggly fence"),
+  :iinfin => UCMCommand("\\iinfin", '⧜', :mathord, "incomplete infinity"),
+  :tieinfty => UCMCommand("\\tieinfty", '⧝', :mathord, "tie over infinity"),
+  :nvinfty => UCMCommand("\\nvinfty", '⧞', :mathord, "infinity negated with vertical bar"),
+  :dualmap => UCMCommand("\\dualmap", '⧟', :mathrel, "double-ended multimap"),
+  :laplac => UCMCommand("\\laplac", '⧠', :mathord, "square with contoured outline"),
+  :lrtriangleeq => UCMCommand("\\lrtriangleeq", '⧡', :mathrel, "increases as"),
+  :shuffle => UCMCommand("\\shuffle", '⧢', :mathbin, "shuffle product"),
+  :eparsl => UCMCommand("\\eparsl", '⧣', :mathrel, "equals sign and slanted parallel"),
+  :smeparsl => UCMCommand("\\smeparsl", '⧤', :mathrel, "equals sign and slanted parallel with tilde above"),
+  :eqvparsl => UCMCommand("\\eqvparsl", '⧥', :mathrel, "identical to and slanted parallel"),
+  :gleichstark => UCMCommand("\\gleichstark", '⧦', :mathrel, "gleich stark"),
+  :thermod => UCMCommand("\\thermod", '⧧', :mathord, "thermodynamic"),
+  :downtriangleleftblack => UCMCommand("\\downtriangleleftblack", '⧨', :mathord, "down-pointing triangle with left half black"),
+  :downtrianglerightblack => UCMCommand("\\downtrianglerightblack", '⧩', :mathord, "down-pointing triangle with right half black"),
+  :blackdiamonddownarrow => UCMCommand("\\blackdiamonddownarrow", '⧪', :mathord, "black diamond with down arrow"),
+  :mdlgblklozenge => UCMCommand("\\mdlgblklozenge", '⧫', :mathbin, "black lozenge"),
+  :circledownarrow => UCMCommand("\\circledownarrow", '⧬', :mathord, "white circle with down arrow"),
+  :blackcircledownarrow => UCMCommand("\\blackcircledownarrow", '⧭', :mathord, "black circle with down arrow"),
+  :errbarsquare => UCMCommand("\\errbarsquare", '⧮', :mathord, "error-barred white square"),
+  :errbarblacksquare => UCMCommand("\\errbarblacksquare", '⧯', :mathord, "error-barred black square"),
+  :errbardiamond => UCMCommand("\\errbardiamond", '⧰', :mathord, "error-barred white diamond"),
+  :errbarblackdiamond => UCMCommand("\\errbarblackdiamond", '⧱', :mathord, "error-barred black diamond"),
+  :errbarcircle => UCMCommand("\\errbarcircle", '⧲', :mathord, "error-barred white circle"),
+  :errbarblackcircle => UCMCommand("\\errbarblackcircle", '⧳', :mathord, "error-barred black circle"),
+  :ruledelayed => UCMCommand("\\ruledelayed", '⧴', :mathrel, "rule-delayed"),
+  :reversesolidus => UCMCommand("\\reversesolidus", '⧵', :mathbin, "reverse solidus"),
+  :dsol => UCMCommand("\\dsol", '⧶', :mathbin, "solidus with overbar"),
+  :rsolbar => UCMCommand("\\rsolbar", '⧷', :mathbin, "reverse solidus with horizontal stroke"),
+  :xsol => UCMCommand("\\xsol", '⧸', :mathop, "big solidus"),
+  :xbsol => UCMCommand("\\xbsol", '⧹', :mathop, "big reverse solidus"),
+  :doubleplus => UCMCommand("\\doubleplus", '⧺', :mathbin, "double plus"),
+  :tripleplus => UCMCommand("\\tripleplus", '⧻', :mathbin, "triple plus"),
+  :lcurvyangle => UCMCommand("\\lcurvyangle", '⧼', :mathopen, "left pointing curved angle bracket"),
+  :rcurvyangle => UCMCommand("\\rcurvyangle", '⧽', :mathclose, "right pointing curved angle bracket"),
+  :tplus => UCMCommand("\\tplus", '⧾', :mathbin, "tiny"),
+  :tminus => UCMCommand("\\tminus", '⧿', :mathbin, "miny"),
+  :bigodot => UCMCommand("\\bigodot", '⨀', :mathop, "n-ary circled dot operator"),
+  :bigoplus => UCMCommand("\\bigoplus", '⨁', :mathop, "n-ary circled plus operator"),
+  :bigotimes => UCMCommand("\\bigotimes", '⨂', :mathop, "n-ary circled times operator"),
+  :bigcupdot => UCMCommand("\\bigcupdot", '⨃', :mathop, "n-ary union operator with dot"),
+  :biguplus => UCMCommand("\\biguplus", '⨄', :mathop, "n-ary union operator with plus"),
+  :bigsqcap => UCMCommand("\\bigsqcap", '⨅', :mathop, "n-ary square intersection operator"),
+  :bigsqcup => UCMCommand("\\bigsqcup", '⨆', :mathop, "n-ary square union operator"),
+  :conjquant => UCMCommand("\\conjquant", '⨇', :mathop, "two logical and operator"),
+  :disjquant => UCMCommand("\\disjquant", '⨈', :mathop, "two logical or operator"),
+  :bigtimes => UCMCommand("\\bigtimes", '⨉', :mathop, "n-ary times operator"),
+  :modtwosum => UCMCommand("\\modtwosum", '⨊', :mathop, "modulo two sum"),
+  :sumint => UCMCommand("\\sumint", '⨋', :mathop, "summation with integral"),
+  :iiiint => UCMCommand("\\iiiint", '⨌', :mathop, "quadruple integral operator"),
+  :intbar => UCMCommand("\\intbar", '⨍', :mathop, "finite part integral"),
+  :intBar => UCMCommand("\\intBar", '⨎', :mathop, "integral with double stroke"),
+  :fint => UCMCommand("\\fint", '⨏', :mathop, "integral average with slash"),
+  :cirfnint => UCMCommand("\\cirfnint", '⨐', :mathop, "circulation function"),
+  :awint => UCMCommand("\\awint", '⨑', :mathop, "anticlockwise integration"),
+  :rppolint => UCMCommand("\\rppolint", '⨒', :mathop, "line integration with rectangular path around pole"),
+  :scpolint => UCMCommand("\\scpolint", '⨓', :mathop, "line integration with semicircular path around pole"),
+  :npolint => UCMCommand("\\npolint", '⨔', :mathop, "line integration not including the pole"),
+  :pointint => UCMCommand("\\pointint", '⨕', :mathop, "integral around a point operator"),
+  :sqint => UCMCommand("\\sqint", '⨖', :mathop, "quaternion integral operator"),
+  :intlarhk => UCMCommand("\\intlarhk", '⨗', :mathop, "integral with leftwards arrow with hook"),
+  :intx => UCMCommand("\\intx", '⨘', :mathop, "integral with times sign"),
+  :intcap => UCMCommand("\\intcap", '⨙', :mathop, "integral with intersection"),
+  :intcup => UCMCommand("\\intcup", '⨚', :mathop, "integral with union"),
+  :upint => UCMCommand("\\upint", '⨛', :mathop, "integral with overbar"),
+  :lowint => UCMCommand("\\lowint", '⨜', :mathop, "integral with underbar"),
+  :Join => UCMCommand("\\Join", '⨝', :mathop, "join"),
+  :bigtriangleleft => UCMCommand("\\bigtriangleleft", '⨞', :mathop, "large left triangle operator"),
+  :zcmp => UCMCommand("\\zcmp", '⨟', :mathop, "z notation schema composition"),
+  :zpipe => UCMCommand("\\zpipe", '⨠', :mathop, "z notation schema piping"),
+  :zproject => UCMCommand("\\zproject", '⨡', :mathop, "z notation schema projection"),
+  :ringplus => UCMCommand("\\ringplus", '⨢', :mathbin, "plus sign with small circle above"),
+  :plushat => UCMCommand("\\plushat", '⨣', :mathbin, "plus sign with circumflex accent above"),
+  :simplus => UCMCommand("\\simplus", '⨤', :mathbin, "plus sign with tilde above"),
+  :plusdot => UCMCommand("\\plusdot", '⨥', :mathbin, "plus sign with dot below"),
+  :plussim => UCMCommand("\\plussim", '⨦', :mathbin, "plus sign with tilde below"),
+  :plussubtwo => UCMCommand("\\plussubtwo", '⨧', :mathbin, "plus sign with subscript two"),
+  :plustrif => UCMCommand("\\plustrif", '⨨', :mathbin, "plus sign with black triangle"),
+  :commaminus => UCMCommand("\\commaminus", '⨩', :mathbin, "minus sign with comma above"),
+  :minusdot => UCMCommand("\\minusdot", '⨪', :mathbin, "minus sign with dot below"),
+  :minusfdots => UCMCommand("\\minusfdots", '⨫', :mathbin, "minus sign with falling dots"),
+  :minusrdots => UCMCommand("\\minusrdots", '⨬', :mathbin, "minus sign with rising dots"),
+  :opluslhrim => UCMCommand("\\opluslhrim", '⨭', :mathbin, "plus sign in left half circle"),
+  :oplusrhrim => UCMCommand("\\oplusrhrim", '⨮', :mathbin, "plus sign in right half circle"),
+  :vectimes => UCMCommand("\\vectimes", '⨯', :mathbin, "vector or cross product"),
+  :dottimes => UCMCommand("\\dottimes", '⨰', :mathbin, "multiplication sign with dot above"),
+  :timesbar => UCMCommand("\\timesbar", '⨱', :mathbin, "multiplication sign with underbar"),
+  :btimes => UCMCommand("\\btimes", '⨲', :mathbin, "semidirect product with bottom closed"),
+  :smashtimes => UCMCommand("\\smashtimes", '⨳', :mathbin, "smash product"),
+  :otimeslhrim => UCMCommand("\\otimeslhrim", '⨴', :mathbin, "multiplication sign in left half circle"),
+  :otimesrhrim => UCMCommand("\\otimesrhrim", '⨵', :mathbin, "multiplication sign in right half circle"),
+  :otimeshat => UCMCommand("\\otimeshat", '⨶', :mathbin, "circled multiplication sign with circumflex accent"),
+  :Otimes => UCMCommand("\\Otimes", '⨷', :mathbin, "multiplication sign in double circle"),
+  :odiv => UCMCommand("\\odiv", '⨸', :mathbin, "circled division sign"),
+  :triangleplus => UCMCommand("\\triangleplus", '⨹', :mathbin, "plus sign in triangle"),
+  :triangleminus => UCMCommand("\\triangleminus", '⨺', :mathbin, "minus sign in triangle"),
+  :triangletimes => UCMCommand("\\triangletimes", '⨻', :mathbin, "multiplication sign in triangle"),
+  :intprod => UCMCommand("\\intprod", '⨼', :mathbin, "interior product"),
+  :intprodr => UCMCommand("\\intprodr", '⨽', :mathbin, "righthand interior product"),
+  :fcmp => UCMCommand("\\fcmp", '⨾', :mathbin, "z notation relational composition"),
+  :amalg => UCMCommand("\\amalg", '⨿', :mathbin, "amalgamation or coproduct"),
+  :capdot => UCMCommand("\\capdot", '⩀', :mathbin, "intersection with dot"),
+  :uminus => UCMCommand("\\uminus", '⩁', :mathbin, "union with minus sign"),
+  :barcup => UCMCommand("\\barcup", '⩂', :mathbin, "union with overbar"),
+  :barcap => UCMCommand("\\barcap", '⩃', :mathbin, "intersection with overbar"),
+  :capwedge => UCMCommand("\\capwedge", '⩄', :mathbin, "intersection with logical and"),
+  :cupvee => UCMCommand("\\cupvee", '⩅', :mathbin, "union with logical or"),
+  :cupovercap => UCMCommand("\\cupovercap", '⩆', :mathbin, "union above intersection"),
+  :capovercup => UCMCommand("\\capovercup", '⩇', :mathbin, "intersection above union"),
+  :cupbarcap => UCMCommand("\\cupbarcap", '⩈', :mathbin, "union above bar above intersection"),
+  :capbarcup => UCMCommand("\\capbarcup", '⩉', :mathbin, "intersection above bar above union"),
+  :twocups => UCMCommand("\\twocups", '⩊', :mathbin, "union beside and joined with union"),
+  :twocaps => UCMCommand("\\twocaps", '⩋', :mathbin, "intersection beside and joined with intersection"),
+  :closedvarcup => UCMCommand("\\closedvarcup", '⩌', :mathbin, "closed union with serifs"),
+  :closedvarcap => UCMCommand("\\closedvarcap", '⩍', :mathbin, "closed intersection with serifs"),
+  :Sqcap => UCMCommand("\\Sqcap", '⩎', :mathbin, "double square intersection"),
+  :Sqcup => UCMCommand("\\Sqcup", '⩏', :mathbin, "double square union"),
+  :closedvarcupsmashprod => UCMCommand("\\closedvarcupsmashprod", '⩐', :mathbin, "closed union with serifs and smash product"),
+  :wedgeodot => UCMCommand("\\wedgeodot", '⩑', :mathbin, "logical and with dot above"),
+  :veeodot => UCMCommand("\\veeodot", '⩒', :mathbin, "logical or with dot above"),
+  :Wedge => UCMCommand("\\Wedge", '⩓', :mathbin, "double logical and"),
+  :Vee => UCMCommand("\\Vee", '⩔', :mathbin, "double logical or"),
+  :wedgeonwedge => UCMCommand("\\wedgeonwedge", '⩕', :mathbin, "two intersecting logical and"),
+  :veeonvee => UCMCommand("\\veeonvee", '⩖', :mathbin, "two intersecting logical or"),
+  :bigslopedvee => UCMCommand("\\bigslopedvee", '⩗', :mathbin, "sloping large or"),
+  :bigslopedwedge => UCMCommand("\\bigslopedwedge", '⩘', :mathbin, "sloping large and"),
+  :veeonwedge => UCMCommand("\\veeonwedge", '⩙', :mathrel, "logical or overlapping logical and"),
+  :wedgemidvert => UCMCommand("\\wedgemidvert", '⩚', :mathbin, "logical and with middle stem"),
+  :veemidvert => UCMCommand("\\veemidvert", '⩛', :mathbin, "logical or with middle stem"),
+  :midbarwedge => UCMCommand("\\midbarwedge", '⩜', :mathbin, "ogical and with horizontal dash"),
+  :midbarvee => UCMCommand("\\midbarvee", '⩝', :mathbin, "logical or with horizontal dash"),
+  :doublebarwedge => UCMCommand("\\doublebarwedge", '⩞', :mathbin, "logical and with double overbar"),
+  :wedgebar => UCMCommand("\\wedgebar", '⩟', :mathbin, "logical and with underbar"),
+  :wedgedoublebar => UCMCommand("\\wedgedoublebar", '⩠', :mathbin, "logical and with double underbar"),
+  :varveebar => UCMCommand("\\varveebar", '⩡', :mathbin, "small vee with underbar"),
+  :doublebarvee => UCMCommand("\\doublebarvee", '⩢', :mathbin, "logical or with double overbar"),
+  :veedoublebar => UCMCommand("\\veedoublebar", '⩣', :mathbin, "logical or with double underbar"),
+  :dsub => UCMCommand("\\dsub", '⩤', :mathbin, "z notation domain antirestriction"),
+  :rsub => UCMCommand("\\rsub", '⩥', :mathbin, "z notation range antirestriction"),
+  :eqdot => UCMCommand("\\eqdot", '⩦', :mathrel, "equals sign with dot below"),
+  :dotequiv => UCMCommand("\\dotequiv", '⩧', :mathrel, "identical with dot above"),
+  :equivVert => UCMCommand("\\equivVert", '⩨', :mathrel, "triple horizontal bar with double vertical stroke"),
+  :equivVvert => UCMCommand("\\equivVvert", '⩩', :mathrel, "triple horizontal bar with triple vertical stroke"),
+  :dotsim => UCMCommand("\\dotsim", '⩪', :mathrel, "tilde operator with dot above"),
+  :simrdots => UCMCommand("\\simrdots", '⩫', :mathrel, "tilde operator with rising dots"),
+  :simminussim => UCMCommand("\\simminussim", '⩬', :mathrel, "similar minus similar"),
+  :congdot => UCMCommand("\\congdot", '⩭', :mathrel, "congruent with dot above"),
+  :asteq => UCMCommand("\\asteq", '⩮', :mathrel, "equals with asterisk"),
+  :hatapprox => UCMCommand("\\hatapprox", '⩯', :mathrel, "almost equal to with circumflex accent"),
+  :approxeqq => UCMCommand("\\approxeqq", '⩰', :mathrel, "approximately equal or equal to"),
+  :eqqplus => UCMCommand("\\eqqplus", '⩱', :mathbin, "equals sign above plus sign"),
+  :pluseqq => UCMCommand("\\pluseqq", '⩲', :mathbin, "plus sign above equals sign"),
+  :eqqsim => UCMCommand("\\eqqsim", '⩳', :mathrel, "equals sign above tilde operator"),
+  :Coloneq => UCMCommand("\\Coloneq", '⩴', :mathrel, "double colon equal"),
+  :eqeq => UCMCommand("\\eqeq", '⩵', :mathrel, "two consecutive equals signs"),
+  :eqeqeq => UCMCommand("\\eqeqeq", '⩶', :mathrel, "three consecutive equals signs"),
+  :ddotseq => UCMCommand("\\ddotseq", '⩷', :mathrel, "equals sign with two dots above and two dots below"),
+  :equivDD => UCMCommand("\\equivDD", '⩸', :mathrel, "equivalent with four dots above"),
+  :ltcir => UCMCommand("\\ltcir", '⩹', :mathrel, "less-than with circle inside"),
+  :gtcir => UCMCommand("\\gtcir", '⩺', :mathrel, "greater-than with circle inside"),
+  :ltquest => UCMCommand("\\ltquest", '⩻', :mathrel, "less-than with question mark above"),
+  :gtquest => UCMCommand("\\gtquest", '⩼', :mathrel, "greater-than with question mark above"),
+  :leqslant => UCMCommand("\\leqslant", '⩽', :mathrel, "less-than or slanted equal to"),
+  :geqslant => UCMCommand("\\geqslant", '⩾', :mathrel, "greater-than or slanted equal to"),
+  :lesdot => UCMCommand("\\lesdot", '⩿', :mathrel, "less-than or slanted equal to with dot inside"),
+  :gesdot => UCMCommand("\\gesdot", '⪀', :mathrel, "greater-than or slanted equal to with dot inside"),
+  :lesdoto => UCMCommand("\\lesdoto", '⪁', :mathrel, "less-than or slanted equal to with dot above"),
+  :gesdoto => UCMCommand("\\gesdoto", '⪂', :mathrel, "greater-than or slanted equal to with dot above"),
+  :lesdotor => UCMCommand("\\lesdotor", '⪃', :mathrel, "less-than or slanted equal to with dot above right"),
+  :gesdotol => UCMCommand("\\gesdotol", '⪄', :mathrel, "greater-than or slanted equal to with dot above left"),
+  :lessapprox => UCMCommand("\\lessapprox", '⪅', :mathrel, "less-than or approximate"),
+  :gtrapprox => UCMCommand("\\gtrapprox", '⪆', :mathrel, "greater-than or approximate"),
+  :lneq => UCMCommand("\\lneq", '⪇', :mathrel, "less-than and single-line not equal to"),
+  :gneq => UCMCommand("\\gneq", '⪈', :mathrel, "greater-than and single-line not equal to"),
+  :lnapprox => UCMCommand("\\lnapprox", '⪉', :mathrel, "less-than and not approximate"),
+  :gnapprox => UCMCommand("\\gnapprox", '⪊', :mathrel, "greater-than and not approximate"),
+  :lesseqqgtr => UCMCommand("\\lesseqqgtr", '⪋', :mathrel, "less-than above double-line equal above greater-than"),
+  :gtreqqless => UCMCommand("\\gtreqqless", '⪌', :mathrel, "greater-than above double-line equal above less-than"),
+  :lsime => UCMCommand("\\lsime", '⪍', :mathrel, "less-than above similar or equal"),
+  :gsime => UCMCommand("\\gsime", '⪎', :mathrel, "greater-than above similar or equal"),
+  :lsimg => UCMCommand("\\lsimg", '⪏', :mathrel, "less-than above similar above greater-than"),
+  :gsiml => UCMCommand("\\gsiml", '⪐', :mathrel, "greater-than above similar above less-than"),
+  :lgE => UCMCommand("\\lgE", '⪑', :mathrel, "less-than above greater-than above double-line equal"),
+  :glE => UCMCommand("\\glE", '⪒', :mathrel, "greater-than above less-than above double-line equal"),
+  :lesges => UCMCommand("\\lesges", '⪓', :mathrel, "less-than above slanted equal above greater-than above slanted equal"),
+  :gesles => UCMCommand("\\gesles", '⪔', :mathrel, "greater-than above slanted equal above less-than above slanted equal"),
+  :eqslantless => UCMCommand("\\eqslantless", '⪕', :mathrel, "slanted equal to or less-than"),
+  :eqslantgtr => UCMCommand("\\eqslantgtr", '⪖', :mathrel, "slanted equal to or greater-than"),
+  :elsdot => UCMCommand("\\elsdot", '⪗', :mathrel, "slanted equal to or less-than with dot inside"),
+  :egsdot => UCMCommand("\\egsdot", '⪘', :mathrel, "slanted equal to or greater-than with dot inside"),
+  :eqqless => UCMCommand("\\eqqless", '⪙', :mathrel, "double-line equal to or less-than"),
+  :eqqgtr => UCMCommand("\\eqqgtr", '⪚', :mathrel, "double-line equal to or greater-than"),
+  :eqqslantless => UCMCommand("\\eqqslantless", '⪛', :mathrel, "double-line slanted equal to or less-than"),
+  :eqqslantgtr => UCMCommand("\\eqqslantgtr", '⪜', :mathrel, "double-line slanted equal to or greater-than"),
+  :simless => UCMCommand("\\simless", '⪝', :mathrel, "similar or less-than"),
+  :simgtr => UCMCommand("\\simgtr", '⪞', :mathrel, "similar or greater-than"),
+  :simlE => UCMCommand("\\simlE", '⪟', :mathrel, "similar above less-than above equals sign"),
+  :simgE => UCMCommand("\\simgE", '⪠', :mathrel, "similar above greater-than above equals sign"),
+  :Lt => UCMCommand("\\Lt", '⪡', :mathrel, "double nested less-than"),
+  :Gt => UCMCommand("\\Gt", '⪢', :mathrel, "double nested greater-than"),
+  :partialmeetcontraction => UCMCommand("\\partialmeetcontraction", '⪣', :mathrel, "double less-than with underbar"),
+  :glj => UCMCommand("\\glj", '⪤', :mathrel, "greater-than overlapping less-than"),
+  :gla => UCMCommand("\\gla", '⪥', :mathrel, "greater-than beside less-than"),
+  :ltcc => UCMCommand("\\ltcc", '⪦', :mathrel, "less-than closed by curve"),
+  :gtcc => UCMCommand("\\gtcc", '⪧', :mathrel, "greater-than closed by curve"),
+  :lescc => UCMCommand("\\lescc", '⪨', :mathrel, "less-than closed by curve above slanted equal"),
+  :gescc => UCMCommand("\\gescc", '⪩', :mathrel, "greater-than closed by curve above slanted equal"),
+  :smt => UCMCommand("\\smt", '⪪', :mathrel, "smaller than"),
+  :lat => UCMCommand("\\lat", '⪫', :mathrel, "larger than"),
+  :smte => UCMCommand("\\smte", '⪬', :mathrel, "smaller than or equal to"),
+  :late => UCMCommand("\\late", '⪭', :mathrel, "larger than or equal to"),
+  :bumpeqq => UCMCommand("\\bumpeqq", '⪮', :mathrel, "equals sign with bumpy above"),
+  :preceq => UCMCommand("\\preceq", '⪯', :mathrel, "precedes above single-line equals sign"),
+  :succeq => UCMCommand("\\succeq", '⪰', :mathrel, "succeeds above single-line equals sign"),
+  :precneq => UCMCommand("\\precneq", '⪱', :mathrel, "precedes above single-line not equal to"),
+  :succneq => UCMCommand("\\succneq", '⪲', :mathrel, "succeeds above single-line not equal to"),
+  :preceqq => UCMCommand("\\preceqq", '⪳', :mathrel, "precedes above equals sign"),
+  :succeqq => UCMCommand("\\succeqq", '⪴', :mathrel, "succeeds above equals sign"),
+  :precneqq => UCMCommand("\\precneqq", '⪵', :mathrel, "precedes above not equal to"),
+  :succneqq => UCMCommand("\\succneqq", '⪶', :mathrel, "succeeds above not equal to"),
+  :precapprox => UCMCommand("\\precapprox", '⪷', :mathrel, "precedes above almost equal to"),
+  :succapprox => UCMCommand("\\succapprox", '⪸', :mathrel, "succeeds above almost equal to"),
+  :precnapprox => UCMCommand("\\precnapprox", '⪹', :mathrel, "precedes above not almost equal to"),
+  :succnapprox => UCMCommand("\\succnapprox", '⪺', :mathrel, "succeeds above not almost equal to"),
+  :Prec => UCMCommand("\\Prec", '⪻', :mathrel, "double precedes"),
+  :Succ => UCMCommand("\\Succ", '⪼', :mathrel, "double succeeds"),
+  :subsetdot => UCMCommand("\\subsetdot", '⪽', :mathrel, "subset with dot"),
+  :supsetdot => UCMCommand("\\supsetdot", '⪾', :mathrel, "superset with dot"),
+  :subsetplus => UCMCommand("\\subsetplus", '⪿', :mathrel, "subset with plus sign below"),
+  :supsetplus => UCMCommand("\\supsetplus", '⫀', :mathrel, "superset with plus sign below"),
+  :submult => UCMCommand("\\submult", '⫁', :mathrel, "subset with multiplication sign below"),
+  :supmult => UCMCommand("\\supmult", '⫂', :mathrel, "superset with multiplication sign below"),
+  :subedot => UCMCommand("\\subedot", '⫃', :mathrel, "subset of or equal to with dot above"),
+  :supedot => UCMCommand("\\supedot", '⫄', :mathrel, "superset of or equal to with dot above"),
+  :subseteqq => UCMCommand("\\subseteqq", '⫅', :mathrel, "subset of above equals sign"),
+  :supseteqq => UCMCommand("\\supseteqq", '⫆', :mathrel, "superset of above equals sign"),
+  :subsim => UCMCommand("\\subsim", '⫇', :mathrel, "subset of above tilde operator"),
+  :supsim => UCMCommand("\\supsim", '⫈', :mathrel, "superset of above tilde operator"),
+  :subsetapprox => UCMCommand("\\subsetapprox", '⫉', :mathrel, "subset of above almost equal to"),
+  :supsetapprox => UCMCommand("\\supsetapprox", '⫊', :mathrel, "superset of above almost equal to"),
+  :subsetneqq => UCMCommand("\\subsetneqq", '⫋', :mathrel, "subset of above not equal to"),
+  :supsetneqq => UCMCommand("\\supsetneqq", '⫌', :mathrel, "superset of above not equal to"),
+  :lsqhook => UCMCommand("\\lsqhook", '⫍', :mathrel, "square left open box operator"),
+  :rsqhook => UCMCommand("\\rsqhook", '⫎', :mathrel, "square right open box operator"),
+  :csub => UCMCommand("\\csub", '⫏', :mathrel, "closed subset"),
+  :csup => UCMCommand("\\csup", '⫐', :mathrel, "closed superset"),
+  :csube => UCMCommand("\\csube", '⫑', :mathrel, "closed subset or equal to"),
+  :csupe => UCMCommand("\\csupe", '⫒', :mathrel, "closed superset or equal to"),
+  :subsup => UCMCommand("\\subsup", '⫓', :mathrel, "subset above superset"),
+  :supsub => UCMCommand("\\supsub", '⫔', :mathrel, "superset above subset"),
+  :subsub => UCMCommand("\\subsub", '⫕', :mathrel, "subset above subset"),
+  :supsup => UCMCommand("\\supsup", '⫖', :mathrel, "superset above superset"),
+  :suphsub => UCMCommand("\\suphsub", '⫗', :mathrel, "superset beside subset"),
+  :supdsub => UCMCommand("\\supdsub", '⫘', :mathrel, "superset beside and joined by dash with subset"),
+  :forkv => UCMCommand("\\forkv", '⫙', :mathrel, "element of opening downwards"),
+  :topfork => UCMCommand("\\topfork", '⫚', :mathrel, "pitchfork with tee top"),
+  :mlcp => UCMCommand("\\mlcp", '⫛', :mathrel, "transversal intersection"),
+  :forks => UCMCommand("\\forks", '⫝̸', :mathrel, "forking"),
+  :forksnot => UCMCommand("\\forksnot", '⫝', :mathrel, "nonforking"),
+  :shortlefttack => UCMCommand("\\shortlefttack", '⫞', :mathrel, "short left tack"),
+  :shortdowntack => UCMCommand("\\shortdowntack", '⫟', :mathrel, "short down tack"),
+  :shortuptack => UCMCommand("\\shortuptack", '⫠', :mathrel, "short up tack"),
+  :perps => UCMCommand("\\perps", '⫡', :mathord, "perpendicular with s"),
+  :vDdash => UCMCommand("\\vDdash", '⫢', :mathrel, "vertical bar triple right turnstile"),
+  :dashV => UCMCommand("\\dashV", '⫣', :mathrel, "double vertical bar left turnstile"),
+  :Dashv => UCMCommand("\\Dashv", '⫤', :mathrel, "vertical bar double left turnstile"),
+  :DashV => UCMCommand("\\DashV", '⫥', :mathrel, "double vertical bar double left turnstile"),
+  :varVdash => UCMCommand("\\varVdash", '⫦', :mathrel, "long dash from left member of double vertical"),
+  :Barv => UCMCommand("\\Barv", '⫧', :mathrel, "short down tack with overbar"),
+  :vBar => UCMCommand("\\vBar", '⫨', :mathrel, "short up tack with underbar"),
+  :vBarv => UCMCommand("\\vBarv", '⫩', :mathrel, "short up tack above short down tack"),
+  :barV => UCMCommand("\\barV", '⫪', :mathrel, "double down tack"),
+  :Vbar => UCMCommand("\\Vbar", '⫫', :mathrel, "double up tack"),
+  :Not => UCMCommand("\\Not", '⫬', :mathrel, "double stroke not sign"),
+  :bNot => UCMCommand("\\bNot", '⫭', :mathrel, "reversed double stroke not sign"),
+  :revnmid => UCMCommand("\\revnmid", '⫮', :mathrel, "does not divide with reversed negation slash"),
+  :cirmid => UCMCommand("\\cirmid", '⫯', :mathrel, "vertical line with circle above"),
+  :midcir => UCMCommand("\\midcir", '⫰', :mathrel, "vertical line with circle below"),
+  :topcir => UCMCommand("\\topcir", '⫱', :mathord, "down tack with circle below"),
+  :nhpar => UCMCommand("\\nhpar", '⫲', :mathrel, "parallel with horizontal stroke"),
+  :parsim => UCMCommand("\\parsim", '⫳', :mathrel, "parallel with tilde operator"),
+  :interleave => UCMCommand("\\interleave", '⫴', :mathbin, "triple vertical bar binary relation"),
+  :nhVvert => UCMCommand("\\nhVvert", '⫵', :mathbin, "triple vertical bar with horizontal stroke"),
+  :threedotcolon => UCMCommand("\\threedotcolon", '⫶', :mathbin, "triple colon operator"),
+  :lllnest => UCMCommand("\\lllnest", '⫷', :mathrel, "stacked very much less-than"),
+  :gggnest => UCMCommand("\\gggnest", '⫸', :mathrel, "stacked very much greater-than"),
+  :leqqslant => UCMCommand("\\leqqslant", '⫹', :mathrel, "double-line slanted less-than or equal to"),
+  :geqqslant => UCMCommand("\\geqqslant", '⫺', :mathrel, "double-line slanted greater-than or equal to"),
+  :trslash => UCMCommand("\\trslash", '⫻', :mathbin, "triple solidus binary relation"),
+  :biginterleave => UCMCommand("\\biginterleave", '⫼', :mathop, "large triple vertical bar operator"),
+  :sslash => UCMCommand("\\sslash", '⫽', :mathbin, "double solidus operator"),
+  :talloblong => UCMCommand("\\talloblong", '⫾', :mathbin, "white vertical bar"),
+  :bigtalloblong => UCMCommand("\\bigtalloblong", '⫿', :mathop, "n-ary white vertical bar"),
+  :squaretopblack => UCMCommand("\\squaretopblack", '⬒', :mathord, "square with top half black"),
+  :squarebotblack => UCMCommand("\\squarebotblack", '⬓', :mathord, "square with bottom half black"),
+  :squareurblack => UCMCommand("\\squareurblack", '⬔', :mathord, "square with upper right diagonal half black"),
+  :squarellblack => UCMCommand("\\squarellblack", '⬕', :mathord, "square with lower left diagonal half black"),
+  :diamondleftblack => UCMCommand("\\diamondleftblack", '⬖', :mathord, "diamond with left half black"),
+  :diamondrightblack => UCMCommand("\\diamondrightblack", '⬗', :mathord, "diamond with right half black"),
+  :diamondtopblack => UCMCommand("\\diamondtopblack", '⬘', :mathord, "diamond with top half black"),
+  :diamondbotblack => UCMCommand("\\diamondbotblack", '⬙', :mathord, "diamond with bottom half black"),
+  :dottedsquare => UCMCommand("\\dottedsquare", '⬚', :mathord, "dotted square"),
+  :lgblksquare => UCMCommand("\\lgblksquare", '⬛', :mathord, "black large square"),
+  :lgwhtsquare => UCMCommand("\\lgwhtsquare", '⬜', :mathord, "white large square"),
+  :vysmblksquare => UCMCommand("\\vysmblksquare", '⬝', :mathord, "black very small square"),
+  :vysmwhtsquare => UCMCommand("\\vysmwhtsquare", '⬞', :mathord, "white very small square"),
+  :pentagonblack => UCMCommand("\\pentagonblack", '⬟', :mathord, "black pentagon"),
+  :pentagon => UCMCommand("\\pentagon", '⬠', :mathord, "white pentagon"),
+  :varhexagon => UCMCommand("\\varhexagon", '⬡', :mathord, "white hexagon"),
+  :varhexagonblack => UCMCommand("\\varhexagonblack", '⬢', :mathord, "black hexagon"),
+  :hexagonblack => UCMCommand("\\hexagonblack", '⬣', :mathord, "horizontal black hexagon"),
+  :lgblkcircle => UCMCommand("\\lgblkcircle", '⬤', :mathord, "black large circle"),
+  :mdblkdiamond => UCMCommand("\\mdblkdiamond", '⬥', :mathord, "black medium diamond"),
+  :mdwhtdiamond => UCMCommand("\\mdwhtdiamond", '⬦', :mathord, "white medium diamond"),
+  :mdblklozenge => UCMCommand("\\mdblklozenge", '⬧', :mathord, "black medium lozenge"),
+  :mdwhtlozenge => UCMCommand("\\mdwhtlozenge", '⬨', :mathord, "white medium lozenge"),
+  :smblkdiamond => UCMCommand("\\smblkdiamond", '⬩', :mathord, "black small diamond"),
+  :smblklozenge => UCMCommand("\\smblklozenge", '⬪', :mathord, "black small lozenge"),
+  :smwhtlozenge => UCMCommand("\\smwhtlozenge", '⬫', :mathord, "white small lozenge"),
+  :blkhorzoval => UCMCommand("\\blkhorzoval", '⬬', :mathord, "black horizontal ellipse"),
+  :whthorzoval => UCMCommand("\\whthorzoval", '⬭', :mathord, "white horizontal ellipse"),
+  :blkvertoval => UCMCommand("\\blkvertoval", '⬮', :mathord, "black vertical ellipse"),
+  :whtvertoval => UCMCommand("\\whtvertoval", '⬯', :mathord, "white vertical ellipse"),
+  :circleonleftarrow => UCMCommand("\\circleonleftarrow", '⬰', :mathrel, "left arrow with small circle"),
+  :leftthreearrows => UCMCommand("\\leftthreearrows", '⬱', :mathrel, "three leftwards arrows"),
+  :leftarrowonoplus => UCMCommand("\\leftarrowonoplus", '⬲', :mathrel, "left arrow with circled plus"),
+  :longleftsquigarrow => UCMCommand("\\longleftsquigarrow", '⬳', :mathrel, "long leftwards squiggle arrow"),
+  :nvtwoheadleftarrow => UCMCommand("\\nvtwoheadleftarrow", '⬴', :mathrel, "leftwards two-headed arrow with vertical stroke"),
+  :nVtwoheadleftarrow => UCMCommand("\\nVtwoheadleftarrow", '⬵', :mathrel, "leftwards two-headed arrow with double vertical stroke"),
+  :twoheadmapsfrom => UCMCommand("\\twoheadmapsfrom", '⬶', :mathrel, "leftwards two-headed arrow from bar"),
+  :twoheadleftdbkarrow => UCMCommand("\\twoheadleftdbkarrow", '⬷', :mathrel, "leftwards two-headed triple-dash arrow"),
+  :leftdotarrow => UCMCommand("\\leftdotarrow", '⬸', :mathrel, "leftwards arrow with dotted stem"),
+  :nvleftarrowtail => UCMCommand("\\nvleftarrowtail", '⬹', :mathrel, "leftwards arrow with tail with vertical stroke"),
+  :nVleftarrowtail => UCMCommand("\\nVleftarrowtail", '⬺', :mathrel, "leftwards arrow with tail with double vertical stroke"),
+  :twoheadleftarrowtail => UCMCommand("\\twoheadleftarrowtail", '⬻', :mathrel, "leftwards two-headed arrow with tail"),
+  :nvtwoheadleftarrowtail => UCMCommand("\\nvtwoheadleftarrowtail", '⬼', :mathrel, "leftwards two-headed arrow with tail with vertical stroke"),
+  :nVtwoheadleftarrowtail => UCMCommand("\\nVtwoheadleftarrowtail", '⬽', :mathrel, "leftwards two-headed arrow with tail with double vertical stroke"),
+  :leftarrowx => UCMCommand("\\leftarrowx", '⬾', :mathrel, "leftwards arrow through x"),
+  :leftcurvedarrow => UCMCommand("\\leftcurvedarrow", '⬿', :mathrel, "wave arrow pointing directly left"),
+  :equalleftarrow => UCMCommand("\\equalleftarrow", '⭀', :mathrel, "equals sign above leftwards arrow"),
+  :bsimilarleftarrow => UCMCommand("\\bsimilarleftarrow", '⭁', :mathrel, "reverse tilde operator above leftwards arrow"),
+  :leftarrowbackapprox => UCMCommand("\\leftarrowbackapprox", '⭂', :mathrel, "leftwards arrow above reverse almost equal to"),
+  :rightarrowgtr => UCMCommand("\\rightarrowgtr", '⭃', :mathrel, "rightwards arrow through greater-than"),
+  :rightarrowsupset => UCMCommand("\\rightarrowsupset", '⭄', :mathrel, "rightwards arrow through subset"),
+  :LLeftarrow => UCMCommand("\\LLeftarrow", '⭅', :mathrel, "leftwards quadruple arrow"),
+  :RRightarrow => UCMCommand("\\RRightarrow", '⭆', :mathrel, "rightwards quadruple arrow"),
+  :bsimilarrightarrow => UCMCommand("\\bsimilarrightarrow", '⭇', :mathrel, "reverse tilde operator above rightwards arrow"),
+  :rightarrowbackapprox => UCMCommand("\\rightarrowbackapprox", '⭈', :mathrel, "rightwards arrow above reverse almost equal to"),
+  :similarleftarrow => UCMCommand("\\similarleftarrow", '⭉', :mathrel, "tilde operator above leftwards arrow"),
+  :leftarrowapprox => UCMCommand("\\leftarrowapprox", '⭊', :mathrel, "leftwards arrow above almost equal to"),
+  :leftarrowbsimilar => UCMCommand("\\leftarrowbsimilar", '⭋', :mathrel, "leftwards arrow above reverse tilde operator"),
+  :rightarrowbsimilar => UCMCommand("\\rightarrowbsimilar", '⭌', :mathrel, "righttwards arrow above reverse tilde operator"),
+  :medwhitestar => UCMCommand("\\medwhitestar", '⭐', :mathord, "white medium star"),
+  :medblackstar => UCMCommand("\\medblackstar", '⭑', :mathord, "black medium star"),
+  :smwhitestar => UCMCommand("\\smwhitestar", '⭒', :mathord, "white small star"),
+  :rightpentagonblack => UCMCommand("\\rightpentagonblack", '⭓', :mathord, "black right-pointing pentagon"),
+  :rightpentagon => UCMCommand("\\rightpentagon", '⭔', :mathord, "white right-pointing pentagon"),
+  :postalmark => UCMCommand("\\postalmark", '〒', :mathord, "postal mark"),
+  :hzigzag => UCMCommand("\\hzigzag", '〰', :mathord, "zigzag"),
+  :mbfA => UCMCommand("\\mbfA", '𝐀', :mathalpha, "mathematical bold capital a"),
+  :mbfB => UCMCommand("\\mbfB", '𝐁', :mathalpha, "mathematical bold capital b"),
+  :mbfC => UCMCommand("\\mbfC", '𝐂', :mathalpha, "mathematical bold capital c"),
+  :mbfD => UCMCommand("\\mbfD", '𝐃', :mathalpha, "mathematical bold capital d"),
+  :mbfE => UCMCommand("\\mbfE", '𝐄', :mathalpha, "mathematical bold capital e"),
+  :mbfF => UCMCommand("\\mbfF", '𝐅', :mathalpha, "mathematical bold capital f"),
+  :mbfG => UCMCommand("\\mbfG", '𝐆', :mathalpha, "mathematical bold capital g"),
+  :mbfH => UCMCommand("\\mbfH", '𝐇', :mathalpha, "mathematical bold capital h"),
+  :mbfI => UCMCommand("\\mbfI", '𝐈', :mathalpha, "mathematical bold capital i"),
+  :mbfJ => UCMCommand("\\mbfJ", '𝐉', :mathalpha, "mathematical bold capital j"),
+  :mbfK => UCMCommand("\\mbfK", '𝐊', :mathalpha, "mathematical bold capital k"),
+  :mbfL => UCMCommand("\\mbfL", '𝐋', :mathalpha, "mathematical bold capital l"),
+  :mbfM => UCMCommand("\\mbfM", '𝐌', :mathalpha, "mathematical bold capital m"),
+  :mbfN => UCMCommand("\\mbfN", '𝐍', :mathalpha, "mathematical bold capital n"),
+  :mbfO => UCMCommand("\\mbfO", '𝐎', :mathalpha, "mathematical bold capital o"),
+  :mbfP => UCMCommand("\\mbfP", '𝐏', :mathalpha, "mathematical bold capital p"),
+  :mbfQ => UCMCommand("\\mbfQ", '𝐐', :mathalpha, "mathematical bold capital q"),
+  :mbfR => UCMCommand("\\mbfR", '𝐑', :mathalpha, "mathematical bold capital r"),
+  :mbfS => UCMCommand("\\mbfS", '𝐒', :mathalpha, "mathematical bold capital s"),
+  :mbfT => UCMCommand("\\mbfT", '𝐓', :mathalpha, "mathematical bold capital t"),
+  :mbfU => UCMCommand("\\mbfU", '𝐔', :mathalpha, "mathematical bold capital u"),
+  :mbfV => UCMCommand("\\mbfV", '𝐕', :mathalpha, "mathematical bold capital v"),
+  :mbfW => UCMCommand("\\mbfW", '𝐖', :mathalpha, "mathematical bold capital w"),
+  :mbfX => UCMCommand("\\mbfX", '𝐗', :mathalpha, "mathematical bold capital x"),
+  :mbfY => UCMCommand("\\mbfY", '𝐘', :mathalpha, "mathematical bold capital y"),
+  :mbfZ => UCMCommand("\\mbfZ", '𝐙', :mathalpha, "mathematical bold capital z"),
+  :mbfa => UCMCommand("\\mbfa", '𝐚', :mathalpha, "mathematical bold small a"),
+  :mbfb => UCMCommand("\\mbfb", '𝐛', :mathalpha, "mathematical bold small b"),
+  :mbfc => UCMCommand("\\mbfc", '𝐜', :mathalpha, "mathematical bold small c"),
+  :mbfd => UCMCommand("\\mbfd", '𝐝', :mathalpha, "mathematical bold small d"),
+  :mbfe => UCMCommand("\\mbfe", '𝐞', :mathalpha, "mathematical bold small e"),
+  :mbff => UCMCommand("\\mbff", '𝐟', :mathalpha, "mathematical bold small f"),
+  :mbfg => UCMCommand("\\mbfg", '𝐠', :mathalpha, "mathematical bold small g"),
+  :mbfh => UCMCommand("\\mbfh", '𝐡', :mathalpha, "mathematical bold small h"),
+  :mbfi => UCMCommand("\\mbfi", '𝐢', :mathalpha, "mathematical bold small i"),
+  :mbfj => UCMCommand("\\mbfj", '𝐣', :mathalpha, "mathematical bold small j"),
+  :mbfk => UCMCommand("\\mbfk", '𝐤', :mathalpha, "mathematical bold small k"),
+  :mbfl => UCMCommand("\\mbfl", '𝐥', :mathalpha, "mathematical bold small l"),
+  :mbfm => UCMCommand("\\mbfm", '𝐦', :mathalpha, "mathematical bold small m"),
+  :mbfn => UCMCommand("\\mbfn", '𝐧', :mathalpha, "mathematical bold small n"),
+  :mbfo => UCMCommand("\\mbfo", '𝐨', :mathalpha, "mathematical bold small o"),
+  :mbfp => UCMCommand("\\mbfp", '𝐩', :mathalpha, "mathematical bold small p"),
+  :mbfq => UCMCommand("\\mbfq", '𝐪', :mathalpha, "mathematical bold small q"),
+  :mbfr => UCMCommand("\\mbfr", '𝐫', :mathalpha, "mathematical bold small r"),
+  :mbfs => UCMCommand("\\mbfs", '𝐬', :mathalpha, "mathematical bold small s"),
+  :mbft => UCMCommand("\\mbft", '𝐭', :mathalpha, "mathematical bold small t"),
+  :mbfu => UCMCommand("\\mbfu", '𝐮', :mathalpha, "mathematical bold small u"),
+  :mbfv => UCMCommand("\\mbfv", '𝐯', :mathalpha, "mathematical bold small v"),
+  :mbfw => UCMCommand("\\mbfw", '𝐰', :mathalpha, "mathematical bold small w"),
+  :mbfx => UCMCommand("\\mbfx", '𝐱', :mathalpha, "mathematical bold small x"),
+  :mbfy => UCMCommand("\\mbfy", '𝐲', :mathalpha, "mathematical bold small y"),
+  :mbfz => UCMCommand("\\mbfz", '𝐳', :mathalpha, "mathematical bold small z"),
+  :mitA => UCMCommand("\\mitA", '𝐴', :mathalpha, "mathematical italic capital a"),
+  :mitB => UCMCommand("\\mitB", '𝐵', :mathalpha, "mathematical italic capital b"),
+  :mitC => UCMCommand("\\mitC", '𝐶', :mathalpha, "mathematical italic capital c"),
+  :mitD => UCMCommand("\\mitD", '𝐷', :mathalpha, "mathematical italic capital d"),
+  :mitE => UCMCommand("\\mitE", '𝐸', :mathalpha, "mathematical italic capital e"),
+  :mitF => UCMCommand("\\mitF", '𝐹', :mathalpha, "mathematical italic capital f"),
+  :mitG => UCMCommand("\\mitG", '𝐺', :mathalpha, "mathematical italic capital g"),
+  :mitH => UCMCommand("\\mitH", '𝐻', :mathalpha, "mathematical italic capital h"),
+  :mitI => UCMCommand("\\mitI", '𝐼', :mathalpha, "mathematical italic capital i"),
+  :mitJ => UCMCommand("\\mitJ", '𝐽', :mathalpha, "mathematical italic capital j"),
+  :mitK => UCMCommand("\\mitK", '𝐾', :mathalpha, "mathematical italic capital k"),
+  :mitL => UCMCommand("\\mitL", '𝐿', :mathalpha, "mathematical italic capital l"),
+  :mitM => UCMCommand("\\mitM", '𝑀', :mathalpha, "mathematical italic capital m"),
+  :mitN => UCMCommand("\\mitN", '𝑁', :mathalpha, "mathematical italic capital n"),
+  :mitO => UCMCommand("\\mitO", '𝑂', :mathalpha, "mathematical italic capital o"),
+  :mitP => UCMCommand("\\mitP", '𝑃', :mathalpha, "mathematical italic capital p"),
+  :mitQ => UCMCommand("\\mitQ", '𝑄', :mathalpha, "mathematical italic capital q"),
+  :mitR => UCMCommand("\\mitR", '𝑅', :mathalpha, "mathematical italic capital r"),
+  :mitS => UCMCommand("\\mitS", '𝑆', :mathalpha, "mathematical italic capital s"),
+  :mitT => UCMCommand("\\mitT", '𝑇', :mathalpha, "mathematical italic capital t"),
+  :mitU => UCMCommand("\\mitU", '𝑈', :mathalpha, "mathematical italic capital u"),
+  :mitV => UCMCommand("\\mitV", '𝑉', :mathalpha, "mathematical italic capital v"),
+  :mitW => UCMCommand("\\mitW", '𝑊', :mathalpha, "mathematical italic capital w"),
+  :mitX => UCMCommand("\\mitX", '𝑋', :mathalpha, "mathematical italic capital x"),
+  :mitY => UCMCommand("\\mitY", '𝑌', :mathalpha, "mathematical italic capital y"),
+  :mitZ => UCMCommand("\\mitZ", '𝑍', :mathalpha, "mathematical italic capital z"),
+  :mita => UCMCommand("\\mita", '𝑎', :mathalpha, "mathematical italic small a"),
+  :mitb => UCMCommand("\\mitb", '𝑏', :mathalpha, "mathematical italic small b"),
+  :mitc => UCMCommand("\\mitc", '𝑐', :mathalpha, "mathematical italic small c"),
+  :mitd => UCMCommand("\\mitd", '𝑑', :mathalpha, "mathematical italic small d"),
+  :mite => UCMCommand("\\mite", '𝑒', :mathalpha, "mathematical italic small e"),
+  :mitf => UCMCommand("\\mitf", '𝑓', :mathalpha, "mathematical italic small f"),
+  :mitg => UCMCommand("\\mitg", '𝑔', :mathalpha, "mathematical italic small g"),
+  :miti => UCMCommand("\\miti", '𝑖', :mathalpha, "mathematical italic small i"),
+  :mitj => UCMCommand("\\mitj", '𝑗', :mathalpha, "mathematical italic small j"),
+  :mitk => UCMCommand("\\mitk", '𝑘', :mathalpha, "mathematical italic small k"),
+  :mitl => UCMCommand("\\mitl", '𝑙', :mathalpha, "mathematical italic small l"),
+  :mitm => UCMCommand("\\mitm", '𝑚', :mathalpha, "mathematical italic small m"),
+  :mitn => UCMCommand("\\mitn", '𝑛', :mathalpha, "mathematical italic small n"),
+  :mito => UCMCommand("\\mito", '𝑜', :mathalpha, "mathematical italic small o"),
+  :mitp => UCMCommand("\\mitp", '𝑝', :mathalpha, "mathematical italic small p"),
+  :mitq => UCMCommand("\\mitq", '𝑞', :mathalpha, "mathematical italic small q"),
+  :mitr => UCMCommand("\\mitr", '𝑟', :mathalpha, "mathematical italic small r"),
+  :mits => UCMCommand("\\mits", '𝑠', :mathalpha, "mathematical italic small s"),
+  :mitt => UCMCommand("\\mitt", '𝑡', :mathalpha, "mathematical italic small t"),
+  :mitu => UCMCommand("\\mitu", '𝑢', :mathalpha, "mathematical italic small u"),
+  :mitv => UCMCommand("\\mitv", '𝑣', :mathalpha, "mathematical italic small v"),
+  :mitw => UCMCommand("\\mitw", '𝑤', :mathalpha, "mathematical italic small w"),
+  :mitx => UCMCommand("\\mitx", '𝑥', :mathalpha, "mathematical italic small x"),
+  :mity => UCMCommand("\\mity", '𝑦', :mathalpha, "mathematical italic small y"),
+  :mitz => UCMCommand("\\mitz", '𝑧', :mathalpha, "mathematical italic small z"),
+  :mbfitA => UCMCommand("\\mbfitA", '𝑨', :mathalpha, "mathematical bold italic capital a"),
+  :mbfitB => UCMCommand("\\mbfitB", '𝑩', :mathalpha, "mathematical bold italic capital b"),
+  :mbfitC => UCMCommand("\\mbfitC", '𝑪', :mathalpha, "mathematical bold italic capital c"),
+  :mbfitD => UCMCommand("\\mbfitD", '𝑫', :mathalpha, "mathematical bold italic capital d"),
+  :mbfitE => UCMCommand("\\mbfitE", '𝑬', :mathalpha, "mathematical bold italic capital e"),
+  :mbfitF => UCMCommand("\\mbfitF", '𝑭', :mathalpha, "mathematical bold italic capital f"),
+  :mbfitG => UCMCommand("\\mbfitG", '𝑮', :mathalpha, "mathematical bold italic capital g"),
+  :mbfitH => UCMCommand("\\mbfitH", '𝑯', :mathalpha, "mathematical bold italic capital h"),
+  :mbfitI => UCMCommand("\\mbfitI", '𝑰', :mathalpha, "mathematical bold italic capital i"),
+  :mbfitJ => UCMCommand("\\mbfitJ", '𝑱', :mathalpha, "mathematical bold italic capital j"),
+  :mbfitK => UCMCommand("\\mbfitK", '𝑲', :mathalpha, "mathematical bold italic capital k"),
+  :mbfitL => UCMCommand("\\mbfitL", '𝑳', :mathalpha, "mathematical bold italic capital l"),
+  :mbfitM => UCMCommand("\\mbfitM", '𝑴', :mathalpha, "mathematical bold italic capital m"),
+  :mbfitN => UCMCommand("\\mbfitN", '𝑵', :mathalpha, "mathematical bold italic capital n"),
+  :mbfitO => UCMCommand("\\mbfitO", '𝑶', :mathalpha, "mathematical bold italic capital o"),
+  :mbfitP => UCMCommand("\\mbfitP", '𝑷', :mathalpha, "mathematical bold italic capital p"),
+  :mbfitQ => UCMCommand("\\mbfitQ", '𝑸', :mathalpha, "mathematical bold italic capital q"),
+  :mbfitR => UCMCommand("\\mbfitR", '𝑹', :mathalpha, "mathematical bold italic capital r"),
+  :mbfitS => UCMCommand("\\mbfitS", '𝑺', :mathalpha, "mathematical bold italic capital s"),
+  :mbfitT => UCMCommand("\\mbfitT", '𝑻', :mathalpha, "mathematical bold italic capital t"),
+  :mbfitU => UCMCommand("\\mbfitU", '𝑼', :mathalpha, "mathematical bold italic capital u"),
+  :mbfitV => UCMCommand("\\mbfitV", '𝑽', :mathalpha, "mathematical bold italic capital v"),
+  :mbfitW => UCMCommand("\\mbfitW", '𝑾', :mathalpha, "mathematical bold italic capital w"),
+  :mbfitX => UCMCommand("\\mbfitX", '𝑿', :mathalpha, "mathematical bold italic capital x"),
+  :mbfitY => UCMCommand("\\mbfitY", '𝒀', :mathalpha, "mathematical bold italic capital y"),
+  :mbfitZ => UCMCommand("\\mbfitZ", '𝒁', :mathalpha, "mathematical bold italic capital z"),
+  :mbfita => UCMCommand("\\mbfita", '𝒂', :mathalpha, "mathematical bold italic small a"),
+  :mbfitb => UCMCommand("\\mbfitb", '𝒃', :mathalpha, "mathematical bold italic small b"),
+  :mbfitc => UCMCommand("\\mbfitc", '𝒄', :mathalpha, "mathematical bold italic small c"),
+  :mbfitd => UCMCommand("\\mbfitd", '𝒅', :mathalpha, "mathematical bold italic small d"),
+  :mbfite => UCMCommand("\\mbfite", '𝒆', :mathalpha, "mathematical bold italic small e"),
+  :mbfitf => UCMCommand("\\mbfitf", '𝒇', :mathalpha, "mathematical bold italic small f"),
+  :mbfitg => UCMCommand("\\mbfitg", '𝒈', :mathalpha, "mathematical bold italic small g"),
+  :mbfith => UCMCommand("\\mbfith", '𝒉', :mathalpha, "mathematical bold italic small h"),
+  :mbfiti => UCMCommand("\\mbfiti", '𝒊', :mathalpha, "mathematical bold italic small i"),
+  :mbfitj => UCMCommand("\\mbfitj", '𝒋', :mathalpha, "mathematical bold italic small j"),
+  :mbfitk => UCMCommand("\\mbfitk", '𝒌', :mathalpha, "mathematical bold italic small k"),
+  :mbfitl => UCMCommand("\\mbfitl", '𝒍', :mathalpha, "mathematical bold italic small l"),
+  :mbfitm => UCMCommand("\\mbfitm", '𝒎', :mathalpha, "mathematical bold italic small m"),
+  :mbfitn => UCMCommand("\\mbfitn", '𝒏', :mathalpha, "mathematical bold italic small n"),
+  :mbfito => UCMCommand("\\mbfito", '𝒐', :mathalpha, "mathematical bold italic small o"),
+  :mbfitp => UCMCommand("\\mbfitp", '𝒑', :mathalpha, "mathematical bold italic small p"),
+  :mbfitq => UCMCommand("\\mbfitq", '𝒒', :mathalpha, "mathematical bold italic small q"),
+  :mbfitr => UCMCommand("\\mbfitr", '𝒓', :mathalpha, "mathematical bold italic small r"),
+  :mbfits => UCMCommand("\\mbfits", '𝒔', :mathalpha, "mathematical bold italic small s"),
+  :mbfitt => UCMCommand("\\mbfitt", '𝒕', :mathalpha, "mathematical bold italic small t"),
+  :mbfitu => UCMCommand("\\mbfitu", '𝒖', :mathalpha, "mathematical bold italic small u"),
+  :mbfitv => UCMCommand("\\mbfitv", '𝒗', :mathalpha, "mathematical bold italic small v"),
+  :mbfitw => UCMCommand("\\mbfitw", '𝒘', :mathalpha, "mathematical bold italic small w"),
+  :mbfitx => UCMCommand("\\mbfitx", '𝒙', :mathalpha, "mathematical bold italic small x"),
+  :mbfity => UCMCommand("\\mbfity", '𝒚', :mathalpha, "mathematical bold italic small y"),
+  :mbfitz => UCMCommand("\\mbfitz", '𝒛', :mathalpha, "mathematical bold italic small z"),
+  :mscrA => UCMCommand("\\mscrA", '𝒜', :mathalpha, "mathematical script capital a"),
+  :mscrC => UCMCommand("\\mscrC", '𝒞', :mathalpha, "mathematical script capital c"),
+  :mscrD => UCMCommand("\\mscrD", '𝒟', :mathalpha, "mathematical script capital d"),
+  :mscrG => UCMCommand("\\mscrG", '𝒢', :mathalpha, "mathematical script capital g"),
+  :mscrJ => UCMCommand("\\mscrJ", '𝒥', :mathalpha, "mathematical script capital j"),
+  :mscrK => UCMCommand("\\mscrK", '𝒦', :mathalpha, "mathematical script capital k"),
+  :mscrN => UCMCommand("\\mscrN", '𝒩', :mathalpha, "mathematical script capital n"),
+  :mscrO => UCMCommand("\\mscrO", '𝒪', :mathalpha, "mathematical script capital o"),
+  :mscrP => UCMCommand("\\mscrP", '𝒫', :mathalpha, "mathematical script capital p"),
+  :mscrQ => UCMCommand("\\mscrQ", '𝒬', :mathalpha, "mathematical script capital q"),
+  :mscrS => UCMCommand("\\mscrS", '𝒮', :mathalpha, "mathematical script capital s"),
+  :mscrT => UCMCommand("\\mscrT", '𝒯', :mathalpha, "mathematical script capital t"),
+  :mscrU => UCMCommand("\\mscrU", '𝒰', :mathalpha, "mathematical script capital u"),
+  :mscrV => UCMCommand("\\mscrV", '𝒱', :mathalpha, "mathematical script capital v"),
+  :mscrW => UCMCommand("\\mscrW", '𝒲', :mathalpha, "mathematical script capital w"),
+  :mscrX => UCMCommand("\\mscrX", '𝒳', :mathalpha, "mathematical script capital x"),
+  :mscrY => UCMCommand("\\mscrY", '𝒴', :mathalpha, "mathematical script capital y"),
+  :mscrZ => UCMCommand("\\mscrZ", '𝒵', :mathalpha, "mathematical script capital z"),
+  :mscra => UCMCommand("\\mscra", '𝒶', :mathalpha, "mathematical script small a"),
+  :mscrb => UCMCommand("\\mscrb", '𝒷', :mathalpha, "mathematical script small b"),
+  :mscrc => UCMCommand("\\mscrc", '𝒸', :mathalpha, "mathematical script small c"),
+  :mscrd => UCMCommand("\\mscrd", '𝒹', :mathalpha, "mathematical script small d"),
+  :mscrf => UCMCommand("\\mscrf", '𝒻', :mathalpha, "mathematical script small f"),
+  :mscrh => UCMCommand("\\mscrh", '𝒽', :mathalpha, "mathematical script small h"),
+  :mscri => UCMCommand("\\mscri", '𝒾', :mathalpha, "mathematical script small i"),
+  :mscrj => UCMCommand("\\mscrj", '𝒿', :mathalpha, "mathematical script small j"),
+  :mscrk => UCMCommand("\\mscrk", '𝓀', :mathalpha, "mathematical script small k"),
+  :mscrl => UCMCommand("\\mscrl", '𝓁', :mathalpha, "mathematical script small l"),
+  :mscrm => UCMCommand("\\mscrm", '𝓂', :mathalpha, "mathematical script small m"),
+  :mscrn => UCMCommand("\\mscrn", '𝓃', :mathalpha, "mathematical script small n"),
+  :mscrp => UCMCommand("\\mscrp", '𝓅', :mathalpha, "mathematical script small p"),
+  :mscrq => UCMCommand("\\mscrq", '𝓆', :mathalpha, "mathematical script small q"),
+  :mscrr => UCMCommand("\\mscrr", '𝓇', :mathalpha, "mathematical script small r"),
+  :mscrs => UCMCommand("\\mscrs", '𝓈', :mathalpha, "mathematical script small s"),
+  :mscrt => UCMCommand("\\mscrt", '𝓉', :mathalpha, "mathematical script small t"),
+  :mscru => UCMCommand("\\mscru", '𝓊', :mathalpha, "mathematical script small u"),
+  :mscrv => UCMCommand("\\mscrv", '𝓋', :mathalpha, "mathematical script small v"),
+  :mscrw => UCMCommand("\\mscrw", '𝓌', :mathalpha, "mathematical script small w"),
+  :mscrx => UCMCommand("\\mscrx", '𝓍', :mathalpha, "mathematical script small x"),
+  :mscry => UCMCommand("\\mscry", '𝓎', :mathalpha, "mathematical script small y"),
+  :mscrz => UCMCommand("\\mscrz", '𝓏', :mathalpha, "mathematical script small z"),
+  :mbfscrA => UCMCommand("\\mbfscrA", '𝓐', :mathalpha, "mathematical bold script capital a"),
+  :mbfscrB => UCMCommand("\\mbfscrB", '𝓑', :mathalpha, "mathematical bold script capital b"),
+  :mbfscrC => UCMCommand("\\mbfscrC", '𝓒', :mathalpha, "mathematical bold script capital c"),
+  :mbfscrD => UCMCommand("\\mbfscrD", '𝓓', :mathalpha, "mathematical bold script capital d"),
+  :mbfscrE => UCMCommand("\\mbfscrE", '𝓔', :mathalpha, "mathematical bold script capital e"),
+  :mbfscrF => UCMCommand("\\mbfscrF", '𝓕', :mathalpha, "mathematical bold script capital f"),
+  :mbfscrG => UCMCommand("\\mbfscrG", '𝓖', :mathalpha, "mathematical bold script capital g"),
+  :mbfscrH => UCMCommand("\\mbfscrH", '𝓗', :mathalpha, "mathematical bold script capital h"),
+  :mbfscrI => UCMCommand("\\mbfscrI", '𝓘', :mathalpha, "mathematical bold script capital i"),
+  :mbfscrJ => UCMCommand("\\mbfscrJ", '𝓙', :mathalpha, "mathematical bold script capital j"),
+  :mbfscrK => UCMCommand("\\mbfscrK", '𝓚', :mathalpha, "mathematical bold script capital k"),
+  :mbfscrL => UCMCommand("\\mbfscrL", '𝓛', :mathalpha, "mathematical bold script capital l"),
+  :mbfscrM => UCMCommand("\\mbfscrM", '𝓜', :mathalpha, "mathematical bold script capital m"),
+  :mbfscrN => UCMCommand("\\mbfscrN", '𝓝', :mathalpha, "mathematical bold script capital n"),
+  :mbfscrO => UCMCommand("\\mbfscrO", '𝓞', :mathalpha, "mathematical bold script capital o"),
+  :mbfscrP => UCMCommand("\\mbfscrP", '𝓟', :mathalpha, "mathematical bold script capital p"),
+  :mbfscrQ => UCMCommand("\\mbfscrQ", '𝓠', :mathalpha, "mathematical bold script capital q"),
+  :mbfscrR => UCMCommand("\\mbfscrR", '𝓡', :mathalpha, "mathematical bold script capital r"),
+  :mbfscrS => UCMCommand("\\mbfscrS", '𝓢', :mathalpha, "mathematical bold script capital s"),
+  :mbfscrT => UCMCommand("\\mbfscrT", '𝓣', :mathalpha, "mathematical bold script capital t"),
+  :mbfscrU => UCMCommand("\\mbfscrU", '𝓤', :mathalpha, "mathematical bold script capital u"),
+  :mbfscrV => UCMCommand("\\mbfscrV", '𝓥', :mathalpha, "mathematical bold script capital v"),
+  :mbfscrW => UCMCommand("\\mbfscrW", '𝓦', :mathalpha, "mathematical bold script capital w"),
+  :mbfscrX => UCMCommand("\\mbfscrX", '𝓧', :mathalpha, "mathematical bold script capital x"),
+  :mbfscrY => UCMCommand("\\mbfscrY", '𝓨', :mathalpha, "mathematical bold script capital y"),
+  :mbfscrZ => UCMCommand("\\mbfscrZ", '𝓩', :mathalpha, "mathematical bold script capital z"),
+  :mbfscra => UCMCommand("\\mbfscra", '𝓪', :mathalpha, "mathematical bold script small a"),
+  :mbfscrb => UCMCommand("\\mbfscrb", '𝓫', :mathalpha, "mathematical bold script small b"),
+  :mbfscrc => UCMCommand("\\mbfscrc", '𝓬', :mathalpha, "mathematical bold script small c"),
+  :mbfscrd => UCMCommand("\\mbfscrd", '𝓭', :mathalpha, "mathematical bold script small d"),
+  :mbfscre => UCMCommand("\\mbfscre", '𝓮', :mathalpha, "mathematical bold script small e"),
+  :mbfscrf => UCMCommand("\\mbfscrf", '𝓯', :mathalpha, "mathematical bold script small f"),
+  :mbfscrg => UCMCommand("\\mbfscrg", '𝓰', :mathalpha, "mathematical bold script small g"),
+  :mbfscrh => UCMCommand("\\mbfscrh", '𝓱', :mathalpha, "mathematical bold script small h"),
+  :mbfscri => UCMCommand("\\mbfscri", '𝓲', :mathalpha, "mathematical bold script small i"),
+  :mbfscrj => UCMCommand("\\mbfscrj", '𝓳', :mathalpha, "mathematical bold script small j"),
+  :mbfscrk => UCMCommand("\\mbfscrk", '𝓴', :mathalpha, "mathematical bold script small k"),
+  :mbfscrl => UCMCommand("\\mbfscrl", '𝓵', :mathalpha, "mathematical bold script small l"),
+  :mbfscrm => UCMCommand("\\mbfscrm", '𝓶', :mathalpha, "mathematical bold script small m"),
+  :mbfscrn => UCMCommand("\\mbfscrn", '𝓷', :mathalpha, "mathematical bold script small n"),
+  :mbfscro => UCMCommand("\\mbfscro", '𝓸', :mathalpha, "mathematical bold script small o"),
+  :mbfscrp => UCMCommand("\\mbfscrp", '𝓹', :mathalpha, "mathematical bold script small p"),
+  :mbfscrq => UCMCommand("\\mbfscrq", '𝓺', :mathalpha, "mathematical bold script small q"),
+  :mbfscrr => UCMCommand("\\mbfscrr", '𝓻', :mathalpha, "mathematical bold script small r"),
+  :mbfscrs => UCMCommand("\\mbfscrs", '𝓼', :mathalpha, "mathematical bold script small s"),
+  :mbfscrt => UCMCommand("\\mbfscrt", '𝓽', :mathalpha, "mathematical bold script small t"),
+  :mbfscru => UCMCommand("\\mbfscru", '𝓾', :mathalpha, "mathematical bold script small u"),
+  :mbfscrv => UCMCommand("\\mbfscrv", '𝓿', :mathalpha, "mathematical bold script small v"),
+  :mbfscrw => UCMCommand("\\mbfscrw", '𝔀', :mathalpha, "mathematical bold script small w"),
+  :mbfscrx => UCMCommand("\\mbfscrx", '𝔁', :mathalpha, "mathematical bold script small x"),
+  :mbfscry => UCMCommand("\\mbfscry", '𝔂', :mathalpha, "mathematical bold script small y"),
+  :mbfscrz => UCMCommand("\\mbfscrz", '𝔃', :mathalpha, "mathematical bold script small z"),
+  :mfrakA => UCMCommand("\\mfrakA", '𝔄', :mathalpha, "mathematical fraktur capital a"),
+  :mfrakB => UCMCommand("\\mfrakB", '𝔅', :mathalpha, "mathematical fraktur capital b"),
+  :mfrakD => UCMCommand("\\mfrakD", '𝔇', :mathalpha, "mathematical fraktur capital d"),
+  :mfrakE => UCMCommand("\\mfrakE", '𝔈', :mathalpha, "mathematical fraktur capital e"),
+  :mfrakF => UCMCommand("\\mfrakF", '𝔉', :mathalpha, "mathematical fraktur capital f"),
+  :mfrakG => UCMCommand("\\mfrakG", '𝔊', :mathalpha, "mathematical fraktur capital g"),
+  :mfrakJ => UCMCommand("\\mfrakJ", '𝔍', :mathalpha, "mathematical fraktur capital j"),
+  :mfrakK => UCMCommand("\\mfrakK", '𝔎', :mathalpha, "mathematical fraktur capital k"),
+  :mfrakL => UCMCommand("\\mfrakL", '𝔏', :mathalpha, "mathematical fraktur capital l"),
+  :mfrakM => UCMCommand("\\mfrakM", '𝔐', :mathalpha, "mathematical fraktur capital m"),
+  :mfrakN => UCMCommand("\\mfrakN", '𝔑', :mathalpha, "mathematical fraktur capital n"),
+  :mfrakO => UCMCommand("\\mfrakO", '𝔒', :mathalpha, "mathematical fraktur capital o"),
+  :mfrakP => UCMCommand("\\mfrakP", '𝔓', :mathalpha, "mathematical fraktur capital p"),
+  :mfrakQ => UCMCommand("\\mfrakQ", '𝔔', :mathalpha, "mathematical fraktur capital q"),
+  :mfrakS => UCMCommand("\\mfrakS", '𝔖', :mathalpha, "mathematical fraktur capital s"),
+  :mfrakT => UCMCommand("\\mfrakT", '𝔗', :mathalpha, "mathematical fraktur capital t"),
+  :mfrakU => UCMCommand("\\mfrakU", '𝔘', :mathalpha, "mathematical fraktur capital u"),
+  :mfrakV => UCMCommand("\\mfrakV", '𝔙', :mathalpha, "mathematical fraktur capital v"),
+  :mfrakW => UCMCommand("\\mfrakW", '𝔚', :mathalpha, "mathematical fraktur capital w"),
+  :mfrakX => UCMCommand("\\mfrakX", '𝔛', :mathalpha, "mathematical fraktur capital x"),
+  :mfrakY => UCMCommand("\\mfrakY", '𝔜', :mathalpha, "mathematical fraktur capital y"),
+  :mfraka => UCMCommand("\\mfraka", '𝔞', :mathalpha, "mathematical fraktur small a"),
+  :mfrakb => UCMCommand("\\mfrakb", '𝔟', :mathalpha, "mathematical fraktur small b"),
+  :mfrakc => UCMCommand("\\mfrakc", '𝔠', :mathalpha, "mathematical fraktur small c"),
+  :mfrakd => UCMCommand("\\mfrakd", '𝔡', :mathalpha, "mathematical fraktur small d"),
+  :mfrake => UCMCommand("\\mfrake", '𝔢', :mathalpha, "mathematical fraktur small e"),
+  :mfrakf => UCMCommand("\\mfrakf", '𝔣', :mathalpha, "mathematical fraktur small f"),
+  :mfrakg => UCMCommand("\\mfrakg", '𝔤', :mathalpha, "mathematical fraktur small g"),
+  :mfrakh => UCMCommand("\\mfrakh", '𝔥', :mathalpha, "mathematical fraktur small h"),
+  :mfraki => UCMCommand("\\mfraki", '𝔦', :mathalpha, "mathematical fraktur small i"),
+  :mfrakj => UCMCommand("\\mfrakj", '𝔧', :mathalpha, "mathematical fraktur small j"),
+  :mfrakk => UCMCommand("\\mfrakk", '𝔨', :mathalpha, "mathematical fraktur small k"),
+  :mfrakl => UCMCommand("\\mfrakl", '𝔩', :mathalpha, "mathematical fraktur small l"),
+  :mfrakm => UCMCommand("\\mfrakm", '𝔪', :mathalpha, "mathematical fraktur small m"),
+  :mfrakn => UCMCommand("\\mfrakn", '𝔫', :mathalpha, "mathematical fraktur small n"),
+  :mfrako => UCMCommand("\\mfrako", '𝔬', :mathalpha, "mathematical fraktur small o"),
+  :mfrakp => UCMCommand("\\mfrakp", '𝔭', :mathalpha, "mathematical fraktur small p"),
+  :mfrakq => UCMCommand("\\mfrakq", '𝔮', :mathalpha, "mathematical fraktur small q"),
+  :mfrakr => UCMCommand("\\mfrakr", '𝔯', :mathalpha, "mathematical fraktur small r"),
+  :mfraks => UCMCommand("\\mfraks", '𝔰', :mathalpha, "mathematical fraktur small s"),
+  :mfrakt => UCMCommand("\\mfrakt", '𝔱', :mathalpha, "mathematical fraktur small t"),
+  :mfraku => UCMCommand("\\mfraku", '𝔲', :mathalpha, "mathematical fraktur small u"),
+  :mfrakv => UCMCommand("\\mfrakv", '𝔳', :mathalpha, "mathematical fraktur small v"),
+  :mfrakw => UCMCommand("\\mfrakw", '𝔴', :mathalpha, "mathematical fraktur small w"),
+  :mfrakx => UCMCommand("\\mfrakx", '𝔵', :mathalpha, "mathematical fraktur small x"),
+  :mfraky => UCMCommand("\\mfraky", '𝔶', :mathalpha, "mathematical fraktur small y"),
+  :mfrakz => UCMCommand("\\mfrakz", '𝔷', :mathalpha, "mathematical fraktur small z"),
+  :BbbA => UCMCommand("\\BbbA", '𝔸', :mathalpha, "mathematical double-struck capital a"),
+  :BbbB => UCMCommand("\\BbbB", '𝔹', :mathalpha, "mathematical double-struck capital b"),
+  :BbbD => UCMCommand("\\BbbD", '𝔻', :mathalpha, "mathematical double-struck capital d"),
+  :BbbE => UCMCommand("\\BbbE", '𝔼', :mathalpha, "mathematical double-struck capital e"),
+  :BbbF => UCMCommand("\\BbbF", '𝔽', :mathalpha, "mathematical double-struck capital f"),
+  :BbbG => UCMCommand("\\BbbG", '𝔾', :mathalpha, "mathematical double-struck capital g"),
+  :BbbI => UCMCommand("\\BbbI", '𝕀', :mathalpha, "mathematical double-struck capital i"),
+  :BbbJ => UCMCommand("\\BbbJ", '𝕁', :mathalpha, "mathematical double-struck capital j"),
+  :BbbK => UCMCommand("\\BbbK", '𝕂', :mathalpha, "mathematical double-struck capital k"),
+  :BbbL => UCMCommand("\\BbbL", '𝕃', :mathalpha, "mathematical double-struck capital l"),
+  :BbbM => UCMCommand("\\BbbM", '𝕄', :mathalpha, "mathematical double-struck capital m"),
+  :BbbO => UCMCommand("\\BbbO", '𝕆', :mathalpha, "mathematical double-struck capital o"),
+  :BbbS => UCMCommand("\\BbbS", '𝕊', :mathalpha, "mathematical double-struck capital s"),
+  :BbbT => UCMCommand("\\BbbT", '𝕋', :mathalpha, "mathematical double-struck capital t"),
+  :BbbU => UCMCommand("\\BbbU", '𝕌', :mathalpha, "mathematical double-struck capital u"),
+  :BbbV => UCMCommand("\\BbbV", '𝕍', :mathalpha, "mathematical double-struck capital v"),
+  :BbbW => UCMCommand("\\BbbW", '𝕎', :mathalpha, "mathematical double-struck capital w"),
+  :BbbX => UCMCommand("\\BbbX", '𝕏', :mathalpha, "mathematical double-struck capital x"),
+  :BbbY => UCMCommand("\\BbbY", '𝕐', :mathalpha, "mathematical double-struck capital y"),
+  :Bbba => UCMCommand("\\Bbba", '𝕒', :mathalpha, "mathematical double-struck small a"),
+  :Bbbb => UCMCommand("\\Bbbb", '𝕓', :mathalpha, "mathematical double-struck small b"),
+  :Bbbc => UCMCommand("\\Bbbc", '𝕔', :mathalpha, "mathematical double-struck small c"),
+  :Bbbd => UCMCommand("\\Bbbd", '𝕕', :mathalpha, "mathematical double-struck small d"),
+  :Bbbe => UCMCommand("\\Bbbe", '𝕖', :mathalpha, "mathematical double-struck small e"),
+  :Bbbf => UCMCommand("\\Bbbf", '𝕗', :mathalpha, "mathematical double-struck small f"),
+  :Bbbg => UCMCommand("\\Bbbg", '𝕘', :mathalpha, "mathematical double-struck small g"),
+  :Bbbh => UCMCommand("\\Bbbh", '𝕙', :mathalpha, "mathematical double-struck small h"),
+  :Bbbi => UCMCommand("\\Bbbi", '𝕚', :mathalpha, "mathematical double-struck small i"),
+  :Bbbj => UCMCommand("\\Bbbj", '𝕛', :mathalpha, "mathematical double-struck small j"),
+  :Bbbk => UCMCommand("\\Bbbk", '𝕜', :mathalpha, "mathematical double-struck small k"),
+  :Bbbl => UCMCommand("\\Bbbl", '𝕝', :mathalpha, "mathematical double-struck small l"),
+  :Bbbm => UCMCommand("\\Bbbm", '𝕞', :mathalpha, "mathematical double-struck small m"),
+  :Bbbn => UCMCommand("\\Bbbn", '𝕟', :mathalpha, "mathematical double-struck small n"),
+  :Bbbo => UCMCommand("\\Bbbo", '𝕠', :mathalpha, "mathematical double-struck small o"),
+  :Bbbp => UCMCommand("\\Bbbp", '𝕡', :mathalpha, "mathematical double-struck small p"),
+  :Bbbq => UCMCommand("\\Bbbq", '𝕢', :mathalpha, "mathematical double-struck small q"),
+  :Bbbr => UCMCommand("\\Bbbr", '𝕣', :mathalpha, "mathematical double-struck small r"),
+  :Bbbs => UCMCommand("\\Bbbs", '𝕤', :mathalpha, "mathematical double-struck small s"),
+  :Bbbt => UCMCommand("\\Bbbt", '𝕥', :mathalpha, "mathematical double-struck small t"),
+  :Bbbu => UCMCommand("\\Bbbu", '𝕦', :mathalpha, "mathematical double-struck small u"),
+  :Bbbv => UCMCommand("\\Bbbv", '𝕧', :mathalpha, "mathematical double-struck small v"),
+  :Bbbw => UCMCommand("\\Bbbw", '𝕨', :mathalpha, "mathematical double-struck small w"),
+  :Bbbx => UCMCommand("\\Bbbx", '𝕩', :mathalpha, "mathematical double-struck small x"),
+  :Bbby => UCMCommand("\\Bbby", '𝕪', :mathalpha, "mathematical double-struck small y"),
+  :Bbbz => UCMCommand("\\Bbbz", '𝕫', :mathalpha, "mathematical double-struck small z"),
+  :mbffrakA => UCMCommand("\\mbffrakA", '𝕬', :mathalpha, "mathematical bold fraktur capital a"),
+  :mbffrakB => UCMCommand("\\mbffrakB", '𝕭', :mathalpha, "mathematical bold fraktur capital b"),
+  :mbffrakC => UCMCommand("\\mbffrakC", '𝕮', :mathalpha, "mathematical bold fraktur capital c"),
+  :mbffrakD => UCMCommand("\\mbffrakD", '𝕯', :mathalpha, "mathematical bold fraktur capital d"),
+  :mbffrakE => UCMCommand("\\mbffrakE", '𝕰', :mathalpha, "mathematical bold fraktur capital e"),
+  :mbffrakF => UCMCommand("\\mbffrakF", '𝕱', :mathalpha, "mathematical bold fraktur capital f"),
+  :mbffrakG => UCMCommand("\\mbffrakG", '𝕲', :mathalpha, "mathematical bold fraktur capital g"),
+  :mbffrakH => UCMCommand("\\mbffrakH", '𝕳', :mathalpha, "mathematical bold fraktur capital h"),
+  :mbffrakI => UCMCommand("\\mbffrakI", '𝕴', :mathalpha, "mathematical bold fraktur capital i"),
+  :mbffrakJ => UCMCommand("\\mbffrakJ", '𝕵', :mathalpha, "mathematical bold fraktur capital j"),
+  :mbffrakK => UCMCommand("\\mbffrakK", '𝕶', :mathalpha, "mathematical bold fraktur capital k"),
+  :mbffrakL => UCMCommand("\\mbffrakL", '𝕷', :mathalpha, "mathematical bold fraktur capital l"),
+  :mbffrakM => UCMCommand("\\mbffrakM", '𝕸', :mathalpha, "mathematical bold fraktur capital m"),
+  :mbffrakN => UCMCommand("\\mbffrakN", '𝕹', :mathalpha, "mathematical bold fraktur capital n"),
+  :mbffrakO => UCMCommand("\\mbffrakO", '𝕺', :mathalpha, "mathematical bold fraktur capital o"),
+  :mbffrakP => UCMCommand("\\mbffrakP", '𝕻', :mathalpha, "mathematical bold fraktur capital p"),
+  :mbffrakQ => UCMCommand("\\mbffrakQ", '𝕼', :mathalpha, "mathematical bold fraktur capital q"),
+  :mbffrakR => UCMCommand("\\mbffrakR", '𝕽', :mathalpha, "mathematical bold fraktur capital r"),
+  :mbffrakS => UCMCommand("\\mbffrakS", '𝕾', :mathalpha, "mathematical bold fraktur capital s"),
+  :mbffrakT => UCMCommand("\\mbffrakT", '𝕿', :mathalpha, "mathematical bold fraktur capital t"),
+  :mbffrakU => UCMCommand("\\mbffrakU", '𝖀', :mathalpha, "mathematical bold fraktur capital u"),
+  :mbffrakV => UCMCommand("\\mbffrakV", '𝖁', :mathalpha, "mathematical bold fraktur capital v"),
+  :mbffrakW => UCMCommand("\\mbffrakW", '𝖂', :mathalpha, "mathematical bold fraktur capital w"),
+  :mbffrakX => UCMCommand("\\mbffrakX", '𝖃', :mathalpha, "mathematical bold fraktur capital x"),
+  :mbffrakY => UCMCommand("\\mbffrakY", '𝖄', :mathalpha, "mathematical bold fraktur capital y"),
+  :mbffrakZ => UCMCommand("\\mbffrakZ", '𝖅', :mathalpha, "mathematical bold fraktur capital z"),
+  :mbffraka => UCMCommand("\\mbffraka", '𝖆', :mathalpha, "mathematical bold fraktur small a"),
+  :mbffrakb => UCMCommand("\\mbffrakb", '𝖇', :mathalpha, "mathematical bold fraktur small b"),
+  :mbffrakc => UCMCommand("\\mbffrakc", '𝖈', :mathalpha, "mathematical bold fraktur small c"),
+  :mbffrakd => UCMCommand("\\mbffrakd", '𝖉', :mathalpha, "mathematical bold fraktur small d"),
+  :mbffrake => UCMCommand("\\mbffrake", '𝖊', :mathalpha, "mathematical bold fraktur small e"),
+  :mbffrakf => UCMCommand("\\mbffrakf", '𝖋', :mathalpha, "mathematical bold fraktur small f"),
+  :mbffrakg => UCMCommand("\\mbffrakg", '𝖌', :mathalpha, "mathematical bold fraktur small g"),
+  :mbffrakh => UCMCommand("\\mbffrakh", '𝖍', :mathalpha, "mathematical bold fraktur small h"),
+  :mbffraki => UCMCommand("\\mbffraki", '𝖎', :mathalpha, "mathematical bold fraktur small i"),
+  :mbffrakj => UCMCommand("\\mbffrakj", '𝖏', :mathalpha, "mathematical bold fraktur small j"),
+  :mbffrakk => UCMCommand("\\mbffrakk", '𝖐', :mathalpha, "mathematical bold fraktur small k"),
+  :mbffrakl => UCMCommand("\\mbffrakl", '𝖑', :mathalpha, "mathematical bold fraktur small l"),
+  :mbffrakm => UCMCommand("\\mbffrakm", '𝖒', :mathalpha, "mathematical bold fraktur small m"),
+  :mbffrakn => UCMCommand("\\mbffrakn", '𝖓', :mathalpha, "mathematical bold fraktur small n"),
+  :mbffrako => UCMCommand("\\mbffrako", '𝖔', :mathalpha, "mathematical bold fraktur small o"),
+  :mbffrakp => UCMCommand("\\mbffrakp", '𝖕', :mathalpha, "mathematical bold fraktur small p"),
+  :mbffrakq => UCMCommand("\\mbffrakq", '𝖖', :mathalpha, "mathematical bold fraktur small q"),
+  :mbffrakr => UCMCommand("\\mbffrakr", '𝖗', :mathalpha, "mathematical bold fraktur small r"),
+  :mbffraks => UCMCommand("\\mbffraks", '𝖘', :mathalpha, "mathematical bold fraktur small s"),
+  :mbffrakt => UCMCommand("\\mbffrakt", '𝖙', :mathalpha, "mathematical bold fraktur small t"),
+  :mbffraku => UCMCommand("\\mbffraku", '𝖚', :mathalpha, "mathematical bold fraktur small u"),
+  :mbffrakv => UCMCommand("\\mbffrakv", '𝖛', :mathalpha, "mathematical bold fraktur small v"),
+  :mbffrakw => UCMCommand("\\mbffrakw", '𝖜', :mathalpha, "mathematical bold fraktur small w"),
+  :mbffrakx => UCMCommand("\\mbffrakx", '𝖝', :mathalpha, "mathematical bold fraktur small x"),
+  :mbffraky => UCMCommand("\\mbffraky", '𝖞', :mathalpha, "mathematical bold fraktur small y"),
+  :mbffrakz => UCMCommand("\\mbffrakz", '𝖟', :mathalpha, "mathematical bold fraktur small z"),
+  :msansA => UCMCommand("\\msansA", '𝖠', :mathalpha, "mathematical sans-serif capital a"),
+  :msansB => UCMCommand("\\msansB", '𝖡', :mathalpha, "mathematical sans-serif capital b"),
+  :msansC => UCMCommand("\\msansC", '𝖢', :mathalpha, "mathematical sans-serif capital c"),
+  :msansD => UCMCommand("\\msansD", '𝖣', :mathalpha, "mathematical sans-serif capital d"),
+  :msansE => UCMCommand("\\msansE", '𝖤', :mathalpha, "mathematical sans-serif capital e"),
+  :msansF => UCMCommand("\\msansF", '𝖥', :mathalpha, "mathematical sans-serif capital f"),
+  :msansG => UCMCommand("\\msansG", '𝖦', :mathalpha, "mathematical sans-serif capital g"),
+  :msansH => UCMCommand("\\msansH", '𝖧', :mathalpha, "mathematical sans-serif capital h"),
+  :msansI => UCMCommand("\\msansI", '𝖨', :mathalpha, "mathematical sans-serif capital i"),
+  :msansJ => UCMCommand("\\msansJ", '𝖩', :mathalpha, "mathematical sans-serif capital j"),
+  :msansK => UCMCommand("\\msansK", '𝖪', :mathalpha, "mathematical sans-serif capital k"),
+  :msansL => UCMCommand("\\msansL", '𝖫', :mathalpha, "mathematical sans-serif capital l"),
+  :msansM => UCMCommand("\\msansM", '𝖬', :mathalpha, "mathematical sans-serif capital m"),
+  :msansN => UCMCommand("\\msansN", '𝖭', :mathalpha, "mathematical sans-serif capital n"),
+  :msansO => UCMCommand("\\msansO", '𝖮', :mathalpha, "mathematical sans-serif capital o"),
+  :msansP => UCMCommand("\\msansP", '𝖯', :mathalpha, "mathematical sans-serif capital p"),
+  :msansQ => UCMCommand("\\msansQ", '𝖰', :mathalpha, "mathematical sans-serif capital q"),
+  :msansR => UCMCommand("\\msansR", '𝖱', :mathalpha, "mathematical sans-serif capital r"),
+  :msansS => UCMCommand("\\msansS", '𝖲', :mathalpha, "mathematical sans-serif capital s"),
+  :msansT => UCMCommand("\\msansT", '𝖳', :mathalpha, "mathematical sans-serif capital t"),
+  :msansU => UCMCommand("\\msansU", '𝖴', :mathalpha, "mathematical sans-serif capital u"),
+  :msansV => UCMCommand("\\msansV", '𝖵', :mathalpha, "mathematical sans-serif capital v"),
+  :msansW => UCMCommand("\\msansW", '𝖶', :mathalpha, "mathematical sans-serif capital w"),
+  :msansX => UCMCommand("\\msansX", '𝖷', :mathalpha, "mathematical sans-serif capital x"),
+  :msansY => UCMCommand("\\msansY", '𝖸', :mathalpha, "mathematical sans-serif capital y"),
+  :msansZ => UCMCommand("\\msansZ", '𝖹', :mathalpha, "mathematical sans-serif capital z"),
+  :msansa => UCMCommand("\\msansa", '𝖺', :mathalpha, "mathematical sans-serif small a"),
+  :msansb => UCMCommand("\\msansb", '𝖻', :mathalpha, "mathematical sans-serif small b"),
+  :msansc => UCMCommand("\\msansc", '𝖼', :mathalpha, "mathematical sans-serif small c"),
+  :msansd => UCMCommand("\\msansd", '𝖽', :mathalpha, "mathematical sans-serif small d"),
+  :msanse => UCMCommand("\\msanse", '𝖾', :mathalpha, "mathematical sans-serif small e"),
+  :msansf => UCMCommand("\\msansf", '𝖿', :mathalpha, "mathematical sans-serif small f"),
+  :msansg => UCMCommand("\\msansg", '𝗀', :mathalpha, "mathematical sans-serif small g"),
+  :msansh => UCMCommand("\\msansh", '𝗁', :mathalpha, "mathematical sans-serif small h"),
+  :msansi => UCMCommand("\\msansi", '𝗂', :mathalpha, "mathematical sans-serif small i"),
+  :msansj => UCMCommand("\\msansj", '𝗃', :mathalpha, "mathematical sans-serif small j"),
+  :msansk => UCMCommand("\\msansk", '𝗄', :mathalpha, "mathematical sans-serif small k"),
+  :msansl => UCMCommand("\\msansl", '𝗅', :mathalpha, "mathematical sans-serif small l"),
+  :msansm => UCMCommand("\\msansm", '𝗆', :mathalpha, "mathematical sans-serif small m"),
+  :msansn => UCMCommand("\\msansn", '𝗇', :mathalpha, "mathematical sans-serif small n"),
+  :msanso => UCMCommand("\\msanso", '𝗈', :mathalpha, "mathematical sans-serif small o"),
+  :msansp => UCMCommand("\\msansp", '𝗉', :mathalpha, "mathematical sans-serif small p"),
+  :msansq => UCMCommand("\\msansq", '𝗊', :mathalpha, "mathematical sans-serif small q"),
+  :msansr => UCMCommand("\\msansr", '𝗋', :mathalpha, "mathematical sans-serif small r"),
+  :msanss => UCMCommand("\\msanss", '𝗌', :mathalpha, "mathematical sans-serif small s"),
+  :msanst => UCMCommand("\\msanst", '𝗍', :mathalpha, "mathematical sans-serif small t"),
+  :msansu => UCMCommand("\\msansu", '𝗎', :mathalpha, "mathematical sans-serif small u"),
+  :msansv => UCMCommand("\\msansv", '𝗏', :mathalpha, "mathematical sans-serif small v"),
+  :msansw => UCMCommand("\\msansw", '𝗐', :mathalpha, "mathematical sans-serif small w"),
+  :msansx => UCMCommand("\\msansx", '𝗑', :mathalpha, "mathematical sans-serif small x"),
+  :msansy => UCMCommand("\\msansy", '𝗒', :mathalpha, "mathematical sans-serif small y"),
+  :msansz => UCMCommand("\\msansz", '𝗓', :mathalpha, "mathematical sans-serif small z"),
+  :mbfsansA => UCMCommand("\\mbfsansA", '𝗔', :mathalpha, "mathematical sans-serif bold capital a"),
+  :mbfsansB => UCMCommand("\\mbfsansB", '𝗕', :mathalpha, "mathematical sans-serif bold capital b"),
+  :mbfsansC => UCMCommand("\\mbfsansC", '𝗖', :mathalpha, "mathematical sans-serif bold capital c"),
+  :mbfsansD => UCMCommand("\\mbfsansD", '𝗗', :mathalpha, "mathematical sans-serif bold capital d"),
+  :mbfsansE => UCMCommand("\\mbfsansE", '𝗘', :mathalpha, "mathematical sans-serif bold capital e"),
+  :mbfsansF => UCMCommand("\\mbfsansF", '𝗙', :mathalpha, "mathematical sans-serif bold capital f"),
+  :mbfsansG => UCMCommand("\\mbfsansG", '𝗚', :mathalpha, "mathematical sans-serif bold capital g"),
+  :mbfsansH => UCMCommand("\\mbfsansH", '𝗛', :mathalpha, "mathematical sans-serif bold capital h"),
+  :mbfsansI => UCMCommand("\\mbfsansI", '𝗜', :mathalpha, "mathematical sans-serif bold capital i"),
+  :mbfsansJ => UCMCommand("\\mbfsansJ", '𝗝', :mathalpha, "mathematical sans-serif bold capital j"),
+  :mbfsansK => UCMCommand("\\mbfsansK", '𝗞', :mathalpha, "mathematical sans-serif bold capital k"),
+  :mbfsansL => UCMCommand("\\mbfsansL", '𝗟', :mathalpha, "mathematical sans-serif bold capital l"),
+  :mbfsansM => UCMCommand("\\mbfsansM", '𝗠', :mathalpha, "mathematical sans-serif bold capital m"),
+  :mbfsansN => UCMCommand("\\mbfsansN", '𝗡', :mathalpha, "mathematical sans-serif bold capital n"),
+  :mbfsansO => UCMCommand("\\mbfsansO", '𝗢', :mathalpha, "mathematical sans-serif bold capital o"),
+  :mbfsansP => UCMCommand("\\mbfsansP", '𝗣', :mathalpha, "mathematical sans-serif bold capital p"),
+  :mbfsansQ => UCMCommand("\\mbfsansQ", '𝗤', :mathalpha, "mathematical sans-serif bold capital q"),
+  :mbfsansR => UCMCommand("\\mbfsansR", '𝗥', :mathalpha, "mathematical sans-serif bold capital r"),
+  :mbfsansS => UCMCommand("\\mbfsansS", '𝗦', :mathalpha, "mathematical sans-serif bold capital s"),
+  :mbfsansT => UCMCommand("\\mbfsansT", '𝗧', :mathalpha, "mathematical sans-serif bold capital t"),
+  :mbfsansU => UCMCommand("\\mbfsansU", '𝗨', :mathalpha, "mathematical sans-serif bold capital u"),
+  :mbfsansV => UCMCommand("\\mbfsansV", '𝗩', :mathalpha, "mathematical sans-serif bold capital v"),
+  :mbfsansW => UCMCommand("\\mbfsansW", '𝗪', :mathalpha, "mathematical sans-serif bold capital w"),
+  :mbfsansX => UCMCommand("\\mbfsansX", '𝗫', :mathalpha, "mathematical sans-serif bold capital x"),
+  :mbfsansY => UCMCommand("\\mbfsansY", '𝗬', :mathalpha, "mathematical sans-serif bold capital y"),
+  :mbfsansZ => UCMCommand("\\mbfsansZ", '𝗭', :mathalpha, "mathematical sans-serif bold capital z"),
+  :mbfsansa => UCMCommand("\\mbfsansa", '𝗮', :mathalpha, "mathematical sans-serif bold small a"),
+  :mbfsansb => UCMCommand("\\mbfsansb", '𝗯', :mathalpha, "mathematical sans-serif bold small b"),
+  :mbfsansc => UCMCommand("\\mbfsansc", '𝗰', :mathalpha, "mathematical sans-serif bold small c"),
+  :mbfsansd => UCMCommand("\\mbfsansd", '𝗱', :mathalpha, "mathematical sans-serif bold small d"),
+  :mbfsanse => UCMCommand("\\mbfsanse", '𝗲', :mathalpha, "mathematical sans-serif bold small e"),
+  :mbfsansf => UCMCommand("\\mbfsansf", '𝗳', :mathalpha, "mathematical sans-serif bold small f"),
+  :mbfsansg => UCMCommand("\\mbfsansg", '𝗴', :mathalpha, "mathematical sans-serif bold small g"),
+  :mbfsansh => UCMCommand("\\mbfsansh", '𝗵', :mathalpha, "mathematical sans-serif bold small h"),
+  :mbfsansi => UCMCommand("\\mbfsansi", '𝗶', :mathalpha, "mathematical sans-serif bold small i"),
+  :mbfsansj => UCMCommand("\\mbfsansj", '𝗷', :mathalpha, "mathematical sans-serif bold small j"),
+  :mbfsansk => UCMCommand("\\mbfsansk", '𝗸', :mathalpha, "mathematical sans-serif bold small k"),
+  :mbfsansl => UCMCommand("\\mbfsansl", '𝗹', :mathalpha, "mathematical sans-serif bold small l"),
+  :mbfsansm => UCMCommand("\\mbfsansm", '𝗺', :mathalpha, "mathematical sans-serif bold small m"),
+  :mbfsansn => UCMCommand("\\mbfsansn", '𝗻', :mathalpha, "mathematical sans-serif bold small n"),
+  :mbfsanso => UCMCommand("\\mbfsanso", '𝗼', :mathalpha, "mathematical sans-serif bold small o"),
+  :mbfsansp => UCMCommand("\\mbfsansp", '𝗽', :mathalpha, "mathematical sans-serif bold small p"),
+  :mbfsansq => UCMCommand("\\mbfsansq", '𝗾', :mathalpha, "mathematical sans-serif bold small q"),
+  :mbfsansr => UCMCommand("\\mbfsansr", '𝗿', :mathalpha, "mathematical sans-serif bold small r"),
+  :mbfsanss => UCMCommand("\\mbfsanss", '𝘀', :mathalpha, "mathematical sans-serif bold small s"),
+  :mbfsanst => UCMCommand("\\mbfsanst", '𝘁', :mathalpha, "mathematical sans-serif bold small t"),
+  :mbfsansu => UCMCommand("\\mbfsansu", '𝘂', :mathalpha, "mathematical sans-serif bold small u"),
+  :mbfsansv => UCMCommand("\\mbfsansv", '𝘃', :mathalpha, "mathematical sans-serif bold small v"),
+  :mbfsansw => UCMCommand("\\mbfsansw", '𝘄', :mathalpha, "mathematical sans-serif bold small w"),
+  :mbfsansx => UCMCommand("\\mbfsansx", '𝘅', :mathalpha, "mathematical sans-serif bold small x"),
+  :mbfsansy => UCMCommand("\\mbfsansy", '𝘆', :mathalpha, "mathematical sans-serif bold small y"),
+  :mbfsansz => UCMCommand("\\mbfsansz", '𝘇', :mathalpha, "mathematical sans-serif bold small z"),
+  :mitsansA => UCMCommand("\\mitsansA", '𝘈', :mathalpha, "mathematical sans-serif italic capital a"),
+  :mitsansB => UCMCommand("\\mitsansB", '𝘉', :mathalpha, "mathematical sans-serif italic capital b"),
+  :mitsansC => UCMCommand("\\mitsansC", '𝘊', :mathalpha, "mathematical sans-serif italic capital c"),
+  :mitsansD => UCMCommand("\\mitsansD", '𝘋', :mathalpha, "mathematical sans-serif italic capital d"),
+  :mitsansE => UCMCommand("\\mitsansE", '𝘌', :mathalpha, "mathematical sans-serif italic capital e"),
+  :mitsansF => UCMCommand("\\mitsansF", '𝘍', :mathalpha, "mathematical sans-serif italic capital f"),
+  :mitsansG => UCMCommand("\\mitsansG", '𝘎', :mathalpha, "mathematical sans-serif italic capital g"),
+  :mitsansH => UCMCommand("\\mitsansH", '𝘏', :mathalpha, "mathematical sans-serif italic capital h"),
+  :mitsansI => UCMCommand("\\mitsansI", '𝘐', :mathalpha, "mathematical sans-serif italic capital i"),
+  :mitsansJ => UCMCommand("\\mitsansJ", '𝘑', :mathalpha, "mathematical sans-serif italic capital j"),
+  :mitsansK => UCMCommand("\\mitsansK", '𝘒', :mathalpha, "mathematical sans-serif italic capital k"),
+  :mitsansL => UCMCommand("\\mitsansL", '𝘓', :mathalpha, "mathematical sans-serif italic capital l"),
+  :mitsansM => UCMCommand("\\mitsansM", '𝘔', :mathalpha, "mathematical sans-serif italic capital m"),
+  :mitsansN => UCMCommand("\\mitsansN", '𝘕', :mathalpha, "mathematical sans-serif italic capital n"),
+  :mitsansO => UCMCommand("\\mitsansO", '𝘖', :mathalpha, "mathematical sans-serif italic capital o"),
+  :mitsansP => UCMCommand("\\mitsansP", '𝘗', :mathalpha, "mathematical sans-serif italic capital p"),
+  :mitsansQ => UCMCommand("\\mitsansQ", '𝘘', :mathalpha, "mathematical sans-serif italic capital q"),
+  :mitsansR => UCMCommand("\\mitsansR", '𝘙', :mathalpha, "mathematical sans-serif italic capital r"),
+  :mitsansS => UCMCommand("\\mitsansS", '𝘚', :mathalpha, "mathematical sans-serif italic capital s"),
+  :mitsansT => UCMCommand("\\mitsansT", '𝘛', :mathalpha, "mathematical sans-serif italic capital t"),
+  :mitsansU => UCMCommand("\\mitsansU", '𝘜', :mathalpha, "mathematical sans-serif italic capital u"),
+  :mitsansV => UCMCommand("\\mitsansV", '𝘝', :mathalpha, "mathematical sans-serif italic capital v"),
+  :mitsansW => UCMCommand("\\mitsansW", '𝘞', :mathalpha, "mathematical sans-serif italic capital w"),
+  :mitsansX => UCMCommand("\\mitsansX", '𝘟', :mathalpha, "mathematical sans-serif italic capital x"),
+  :mitsansY => UCMCommand("\\mitsansY", '𝘠', :mathalpha, "mathematical sans-serif italic capital y"),
+  :mitsansZ => UCMCommand("\\mitsansZ", '𝘡', :mathalpha, "mathematical sans-serif italic capital z"),
+  :mitsansa => UCMCommand("\\mitsansa", '𝘢', :mathalpha, "mathematical sans-serif italic small a"),
+  :mitsansb => UCMCommand("\\mitsansb", '𝘣', :mathalpha, "mathematical sans-serif italic small b"),
+  :mitsansc => UCMCommand("\\mitsansc", '𝘤', :mathalpha, "mathematical sans-serif italic small c"),
+  :mitsansd => UCMCommand("\\mitsansd", '𝘥', :mathalpha, "mathematical sans-serif italic small d"),
+  :mitsanse => UCMCommand("\\mitsanse", '𝘦', :mathalpha, "mathematical sans-serif italic small e"),
+  :mitsansf => UCMCommand("\\mitsansf", '𝘧', :mathalpha, "mathematical sans-serif italic small f"),
+  :mitsansg => UCMCommand("\\mitsansg", '𝘨', :mathalpha, "mathematical sans-serif italic small g"),
+  :mitsansh => UCMCommand("\\mitsansh", '𝘩', :mathalpha, "mathematical sans-serif italic small h"),
+  :mitsansi => UCMCommand("\\mitsansi", '𝘪', :mathalpha, "mathematical sans-serif italic small i"),
+  :mitsansj => UCMCommand("\\mitsansj", '𝘫', :mathalpha, "mathematical sans-serif italic small j"),
+  :mitsansk => UCMCommand("\\mitsansk", '𝘬', :mathalpha, "mathematical sans-serif italic small k"),
+  :mitsansl => UCMCommand("\\mitsansl", '𝘭', :mathalpha, "mathematical sans-serif italic small l"),
+  :mitsansm => UCMCommand("\\mitsansm", '𝘮', :mathalpha, "mathematical sans-serif italic small m"),
+  :mitsansn => UCMCommand("\\mitsansn", '𝘯', :mathalpha, "mathematical sans-serif italic small n"),
+  :mitsanso => UCMCommand("\\mitsanso", '𝘰', :mathalpha, "mathematical sans-serif italic small o"),
+  :mitsansp => UCMCommand("\\mitsansp", '𝘱', :mathalpha, "mathematical sans-serif italic small p"),
+  :mitsansq => UCMCommand("\\mitsansq", '𝘲', :mathalpha, "mathematical sans-serif italic small q"),
+  :mitsansr => UCMCommand("\\mitsansr", '𝘳', :mathalpha, "mathematical sans-serif italic small r"),
+  :mitsanss => UCMCommand("\\mitsanss", '𝘴', :mathalpha, "mathematical sans-serif italic small s"),
+  :mitsanst => UCMCommand("\\mitsanst", '𝘵', :mathalpha, "mathematical sans-serif italic small t"),
+  :mitsansu => UCMCommand("\\mitsansu", '𝘶', :mathalpha, "mathematical sans-serif italic small u"),
+  :mitsansv => UCMCommand("\\mitsansv", '𝘷', :mathalpha, "mathematical sans-serif italic small v"),
+  :mitsansw => UCMCommand("\\mitsansw", '𝘸', :mathalpha, "mathematical sans-serif italic small w"),
+  :mitsansx => UCMCommand("\\mitsansx", '𝘹', :mathalpha, "mathematical sans-serif italic small x"),
+  :mitsansy => UCMCommand("\\mitsansy", '𝘺', :mathalpha, "mathematical sans-serif italic small y"),
+  :mitsansz => UCMCommand("\\mitsansz", '𝘻', :mathalpha, "mathematical sans-serif italic small z"),
+  :mbfitsansA => UCMCommand("\\mbfitsansA", '𝘼', :mathalpha, "mathematical sans-serif bold italic capital a"),
+  :mbfitsansB => UCMCommand("\\mbfitsansB", '𝘽', :mathalpha, "mathematical sans-serif bold italic capital b"),
+  :mbfitsansC => UCMCommand("\\mbfitsansC", '𝘾', :mathalpha, "mathematical sans-serif bold italic capital c"),
+  :mbfitsansD => UCMCommand("\\mbfitsansD", '𝘿', :mathalpha, "mathematical sans-serif bold italic capital d"),
+  :mbfitsansE => UCMCommand("\\mbfitsansE", '𝙀', :mathalpha, "mathematical sans-serif bold italic capital e"),
+  :mbfitsansF => UCMCommand("\\mbfitsansF", '𝙁', :mathalpha, "mathematical sans-serif bold italic capital f"),
+  :mbfitsansG => UCMCommand("\\mbfitsansG", '𝙂', :mathalpha, "mathematical sans-serif bold italic capital g"),
+  :mbfitsansH => UCMCommand("\\mbfitsansH", '𝙃', :mathalpha, "mathematical sans-serif bold italic capital h"),
+  :mbfitsansI => UCMCommand("\\mbfitsansI", '𝙄', :mathalpha, "mathematical sans-serif bold italic capital i"),
+  :mbfitsansJ => UCMCommand("\\mbfitsansJ", '𝙅', :mathalpha, "mathematical sans-serif bold italic capital j"),
+  :mbfitsansK => UCMCommand("\\mbfitsansK", '𝙆', :mathalpha, "mathematical sans-serif bold italic capital k"),
+  :mbfitsansL => UCMCommand("\\mbfitsansL", '𝙇', :mathalpha, "mathematical sans-serif bold italic capital l"),
+  :mbfitsansM => UCMCommand("\\mbfitsansM", '𝙈', :mathalpha, "mathematical sans-serif bold italic capital m"),
+  :mbfitsansN => UCMCommand("\\mbfitsansN", '𝙉', :mathalpha, "mathematical sans-serif bold italic capital n"),
+  :mbfitsansO => UCMCommand("\\mbfitsansO", '𝙊', :mathalpha, "mathematical sans-serif bold italic capital o"),
+  :mbfitsansP => UCMCommand("\\mbfitsansP", '𝙋', :mathalpha, "mathematical sans-serif bold italic capital p"),
+  :mbfitsansQ => UCMCommand("\\mbfitsansQ", '𝙌', :mathalpha, "mathematical sans-serif bold italic capital q"),
+  :mbfitsansR => UCMCommand("\\mbfitsansR", '𝙍', :mathalpha, "mathematical sans-serif bold italic capital r"),
+  :mbfitsansS => UCMCommand("\\mbfitsansS", '𝙎', :mathalpha, "mathematical sans-serif bold italic capital s"),
+  :mbfitsansT => UCMCommand("\\mbfitsansT", '𝙏', :mathalpha, "mathematical sans-serif bold italic capital t"),
+  :mbfitsansU => UCMCommand("\\mbfitsansU", '𝙐', :mathalpha, "mathematical sans-serif bold italic capital u"),
+  :mbfitsansV => UCMCommand("\\mbfitsansV", '𝙑', :mathalpha, "mathematical sans-serif bold italic capital v"),
+  :mbfitsansW => UCMCommand("\\mbfitsansW", '𝙒', :mathalpha, "mathematical sans-serif bold italic capital w"),
+  :mbfitsansX => UCMCommand("\\mbfitsansX", '𝙓', :mathalpha, "mathematical sans-serif bold italic capital x"),
+  :mbfitsansY => UCMCommand("\\mbfitsansY", '𝙔', :mathalpha, "mathematical sans-serif bold italic capital y"),
+  :mbfitsansZ => UCMCommand("\\mbfitsansZ", '𝙕', :mathalpha, "mathematical sans-serif bold italic capital z"),
+  :mbfitsansa => UCMCommand("\\mbfitsansa", '𝙖', :mathalpha, "mathematical sans-serif bold italic small a"),
+  :mbfitsansb => UCMCommand("\\mbfitsansb", '𝙗', :mathalpha, "mathematical sans-serif bold italic small b"),
+  :mbfitsansc => UCMCommand("\\mbfitsansc", '𝙘', :mathalpha, "mathematical sans-serif bold italic small c"),
+  :mbfitsansd => UCMCommand("\\mbfitsansd", '𝙙', :mathalpha, "mathematical sans-serif bold italic small d"),
+  :mbfitsanse => UCMCommand("\\mbfitsanse", '𝙚', :mathalpha, "mathematical sans-serif bold italic small e"),
+  :mbfitsansf => UCMCommand("\\mbfitsansf", '𝙛', :mathalpha, "mathematical sans-serif bold italic small f"),
+  :mbfitsansg => UCMCommand("\\mbfitsansg", '𝙜', :mathalpha, "mathematical sans-serif bold italic small g"),
+  :mbfitsansh => UCMCommand("\\mbfitsansh", '𝙝', :mathalpha, "mathematical sans-serif bold italic small h"),
+  :mbfitsansi => UCMCommand("\\mbfitsansi", '𝙞', :mathalpha, "mathematical sans-serif bold italic small i"),
+  :mbfitsansj => UCMCommand("\\mbfitsansj", '𝙟', :mathalpha, "mathematical sans-serif bold italic small j"),
+  :mbfitsansk => UCMCommand("\\mbfitsansk", '𝙠', :mathalpha, "mathematical sans-serif bold italic small k"),
+  :mbfitsansl => UCMCommand("\\mbfitsansl", '𝙡', :mathalpha, "mathematical sans-serif bold italic small l"),
+  :mbfitsansm => UCMCommand("\\mbfitsansm", '𝙢', :mathalpha, "mathematical sans-serif bold italic small m"),
+  :mbfitsansn => UCMCommand("\\mbfitsansn", '𝙣', :mathalpha, "mathematical sans-serif bold italic small n"),
+  :mbfitsanso => UCMCommand("\\mbfitsanso", '𝙤', :mathalpha, "mathematical sans-serif bold italic small o"),
+  :mbfitsansp => UCMCommand("\\mbfitsansp", '𝙥', :mathalpha, "mathematical sans-serif bold italic small p"),
+  :mbfitsansq => UCMCommand("\\mbfitsansq", '𝙦', :mathalpha, "mathematical sans-serif bold italic small q"),
+  :mbfitsansr => UCMCommand("\\mbfitsansr", '𝙧', :mathalpha, "mathematical sans-serif bold italic small r"),
+  :mbfitsanss => UCMCommand("\\mbfitsanss", '𝙨', :mathalpha, "mathematical sans-serif bold italic small s"),
+  :mbfitsanst => UCMCommand("\\mbfitsanst", '𝙩', :mathalpha, "mathematical sans-serif bold italic small t"),
+  :mbfitsansu => UCMCommand("\\mbfitsansu", '𝙪', :mathalpha, "mathematical sans-serif bold italic small u"),
+  :mbfitsansv => UCMCommand("\\mbfitsansv", '𝙫', :mathalpha, "mathematical sans-serif bold italic small v"),
+  :mbfitsansw => UCMCommand("\\mbfitsansw", '𝙬', :mathalpha, "mathematical sans-serif bold italic small w"),
+  :mbfitsansx => UCMCommand("\\mbfitsansx", '𝙭', :mathalpha, "mathematical sans-serif bold italic small x"),
+  :mbfitsansy => UCMCommand("\\mbfitsansy", '𝙮', :mathalpha, "mathematical sans-serif bold italic small y"),
+  :mbfitsansz => UCMCommand("\\mbfitsansz", '𝙯', :mathalpha, "mathematical sans-serif bold italic small z"),
+  :mttA => UCMCommand("\\mttA", '𝙰', :mathalpha, "mathematical monospace capital a"),
+  :mttB => UCMCommand("\\mttB", '𝙱', :mathalpha, "mathematical monospace capital b"),
+  :mttC => UCMCommand("\\mttC", '𝙲', :mathalpha, "mathematical monospace capital c"),
+  :mttD => UCMCommand("\\mttD", '𝙳', :mathalpha, "mathematical monospace capital d"),
+  :mttE => UCMCommand("\\mttE", '𝙴', :mathalpha, "mathematical monospace capital e"),
+  :mttF => UCMCommand("\\mttF", '𝙵', :mathalpha, "mathematical monospace capital f"),
+  :mttG => UCMCommand("\\mttG", '𝙶', :mathalpha, "mathematical monospace capital g"),
+  :mttH => UCMCommand("\\mttH", '𝙷', :mathalpha, "mathematical monospace capital h"),
+  :mttI => UCMCommand("\\mttI", '𝙸', :mathalpha, "mathematical monospace capital i"),
+  :mttJ => UCMCommand("\\mttJ", '𝙹', :mathalpha, "mathematical monospace capital j"),
+  :mttK => UCMCommand("\\mttK", '𝙺', :mathalpha, "mathematical monospace capital k"),
+  :mttL => UCMCommand("\\mttL", '𝙻', :mathalpha, "mathematical monospace capital l"),
+  :mttM => UCMCommand("\\mttM", '𝙼', :mathalpha, "mathematical monospace capital m"),
+  :mttN => UCMCommand("\\mttN", '𝙽', :mathalpha, "mathematical monospace capital n"),
+  :mttO => UCMCommand("\\mttO", '𝙾', :mathalpha, "mathematical monospace capital o"),
+  :mttP => UCMCommand("\\mttP", '𝙿', :mathalpha, "mathematical monospace capital p"),
+  :mttQ => UCMCommand("\\mttQ", '𝚀', :mathalpha, "mathematical monospace capital q"),
+  :mttR => UCMCommand("\\mttR", '𝚁', :mathalpha, "mathematical monospace capital r"),
+  :mttS => UCMCommand("\\mttS", '𝚂', :mathalpha, "mathematical monospace capital s"),
+  :mttT => UCMCommand("\\mttT", '𝚃', :mathalpha, "mathematical monospace capital t"),
+  :mttU => UCMCommand("\\mttU", '𝚄', :mathalpha, "mathematical monospace capital u"),
+  :mttV => UCMCommand("\\mttV", '𝚅', :mathalpha, "mathematical monospace capital v"),
+  :mttW => UCMCommand("\\mttW", '𝚆', :mathalpha, "mathematical monospace capital w"),
+  :mttX => UCMCommand("\\mttX", '𝚇', :mathalpha, "mathematical monospace capital x"),
+  :mttY => UCMCommand("\\mttY", '𝚈', :mathalpha, "mathematical monospace capital y"),
+  :mttZ => UCMCommand("\\mttZ", '𝚉', :mathalpha, "mathematical monospace capital z"),
+  :mtta => UCMCommand("\\mtta", '𝚊', :mathalpha, "mathematical monospace small a"),
+  :mttb => UCMCommand("\\mttb", '𝚋', :mathalpha, "mathematical monospace small b"),
+  :mttc => UCMCommand("\\mttc", '𝚌', :mathalpha, "mathematical monospace small c"),
+  :mttd => UCMCommand("\\mttd", '𝚍', :mathalpha, "mathematical monospace small d"),
+  :mtte => UCMCommand("\\mtte", '𝚎', :mathalpha, "mathematical monospace small e"),
+  :mttf => UCMCommand("\\mttf", '𝚏', :mathalpha, "mathematical monospace small f"),
+  :mttg => UCMCommand("\\mttg", '𝚐', :mathalpha, "mathematical monospace small g"),
+  :mtth => UCMCommand("\\mtth", '𝚑', :mathalpha, "mathematical monospace small h"),
+  :mtti => UCMCommand("\\mtti", '𝚒', :mathalpha, "mathematical monospace small i"),
+  :mttj => UCMCommand("\\mttj", '𝚓', :mathalpha, "mathematical monospace small j"),
+  :mttk => UCMCommand("\\mttk", '𝚔', :mathalpha, "mathematical monospace small k"),
+  :mttl => UCMCommand("\\mttl", '𝚕', :mathalpha, "mathematical monospace small l"),
+  :mttm => UCMCommand("\\mttm", '𝚖', :mathalpha, "mathematical monospace small m"),
+  :mttn => UCMCommand("\\mttn", '𝚗', :mathalpha, "mathematical monospace small n"),
+  :mtto => UCMCommand("\\mtto", '𝚘', :mathalpha, "mathematical monospace small o"),
+  :mttp => UCMCommand("\\mttp", '𝚙', :mathalpha, "mathematical monospace small p"),
+  :mttq => UCMCommand("\\mttq", '𝚚', :mathalpha, "mathematical monospace small q"),
+  :mttr => UCMCommand("\\mttr", '𝚛', :mathalpha, "mathematical monospace small r"),
+  :mtts => UCMCommand("\\mtts", '𝚜', :mathalpha, "mathematical monospace small s"),
+  :mttt => UCMCommand("\\mttt", '𝚝', :mathalpha, "mathematical monospace small t"),
+  :mttu => UCMCommand("\\mttu", '𝚞', :mathalpha, "mathematical monospace small u"),
+  :mttv => UCMCommand("\\mttv", '𝚟', :mathalpha, "mathematical monospace small v"),
+  :mttw => UCMCommand("\\mttw", '𝚠', :mathalpha, "mathematical monospace small w"),
+  :mttx => UCMCommand("\\mttx", '𝚡', :mathalpha, "mathematical monospace small x"),
+  :mtty => UCMCommand("\\mtty", '𝚢', :mathalpha, "mathematical monospace small y"),
+  :mttz => UCMCommand("\\mttz", '𝚣', :mathalpha, "mathematical monospace small z"),
+  :imath => UCMCommand("\\imath", '𝚤', :mathalpha, "mathematical italic small dotless i"),
+  :jmath => UCMCommand("\\jmath", '𝚥', :mathalpha, "mathematical italic small dotless j"),
+  :mbfAlpha => UCMCommand("\\mbfAlpha", '𝚨', :mathalpha, "mathematical bold capital alpha"),
+  :mbfBeta => UCMCommand("\\mbfBeta", '𝚩', :mathalpha, "mathematical bold capital beta"),
+  :mbfGamma => UCMCommand("\\mbfGamma", '𝚪', :mathalpha, "mathematical bold capital gamma"),
+  :mbfDelta => UCMCommand("\\mbfDelta", '𝚫', :mathalpha, "mathematical bold capital delta"),
+  :mbfEpsilon => UCMCommand("\\mbfEpsilon", '𝚬', :mathalpha, "mathematical bold capital epsilon"),
+  :mbfZeta => UCMCommand("\\mbfZeta", '𝚭', :mathalpha, "mathematical bold capital zeta"),
+  :mbfEta => UCMCommand("\\mbfEta", '𝚮', :mathalpha, "mathematical bold capital eta"),
+  :mbfTheta => UCMCommand("\\mbfTheta", '𝚯', :mathalpha, "mathematical bold capital theta"),
+  :mbfIota => UCMCommand("\\mbfIota", '𝚰', :mathalpha, "mathematical bold capital iota"),
+  :mbfKappa => UCMCommand("\\mbfKappa", '𝚱', :mathalpha, "mathematical bold capital kappa"),
+  :mbfLambda => UCMCommand("\\mbfLambda", '𝚲', :mathalpha, "mathematical bold capital lambda"),
+  :mbfMu => UCMCommand("\\mbfMu", '𝚳', :mathalpha, "mathematical bold capital mu"),
+  :mbfNu => UCMCommand("\\mbfNu", '𝚴', :mathalpha, "mathematical bold capital nu"),
+  :mbfXi => UCMCommand("\\mbfXi", '𝚵', :mathalpha, "mathematical bold capital xi"),
+  :mbfOmicron => UCMCommand("\\mbfOmicron", '𝚶', :mathalpha, "mathematical bold capital omicron"),
+  :mbfPi => UCMCommand("\\mbfPi", '𝚷', :mathalpha, "mathematical bold capital pi"),
+  :mbfRho => UCMCommand("\\mbfRho", '𝚸', :mathalpha, "mathematical bold capital rho"),
+  :mbfvarTheta => UCMCommand("\\mbfvarTheta", '𝚹', :mathalpha, "mathematical bold capital theta symbol"),
+  :mbfSigma => UCMCommand("\\mbfSigma", '𝚺', :mathalpha, "mathematical bold capital sigma"),
+  :mbfTau => UCMCommand("\\mbfTau", '𝚻', :mathalpha, "mathematical bold capital tau"),
+  :mbfUpsilon => UCMCommand("\\mbfUpsilon", '𝚼', :mathalpha, "mathematical bold capital upsilon"),
+  :mbfPhi => UCMCommand("\\mbfPhi", '𝚽', :mathalpha, "mathematical bold capital phi"),
+  :mbfChi => UCMCommand("\\mbfChi", '𝚾', :mathalpha, "mathematical bold capital chi"),
+  :mbfPsi => UCMCommand("\\mbfPsi", '𝚿', :mathalpha, "mathematical bold capital psi"),
+  :mbfOmega => UCMCommand("\\mbfOmega", '𝛀', :mathalpha, "mathematical bold capital omega"),
+  :mbfnabla => UCMCommand("\\mbfnabla", '𝛁', :mathalpha, "mathematical bold nabla"),
+  :mbfalpha => UCMCommand("\\mbfalpha", '𝛂', :mathalpha, "mathematical bold small alpha"),
+  :mbfbeta => UCMCommand("\\mbfbeta", '𝛃', :mathalpha, "mathematical bold small beta"),
+  :mbfgamma => UCMCommand("\\mbfgamma", '𝛄', :mathalpha, "mathematical bold small gamma"),
+  :mbfdelta => UCMCommand("\\mbfdelta", '𝛅', :mathalpha, "mathematical bold small delta"),
+  :mbfvarepsilon => UCMCommand("\\mbfvarepsilon", '𝛆', :mathalpha, "mathematical bold small varepsilon"),
+  :mbfzeta => UCMCommand("\\mbfzeta", '𝛇', :mathalpha, "mathematical bold small zeta"),
+  :mbfeta => UCMCommand("\\mbfeta", '𝛈', :mathalpha, "mathematical bold small eta"),
+  :mbftheta => UCMCommand("\\mbftheta", '𝛉', :mathalpha, "mathematical bold small theta"),
+  :mbfiota => UCMCommand("\\mbfiota", '𝛊', :mathalpha, "mathematical bold small iota"),
+  :mbfkappa => UCMCommand("\\mbfkappa", '𝛋', :mathalpha, "mathematical bold small kappa"),
+  :mbflambda => UCMCommand("\\mbflambda", '𝛌', :mathalpha, "mathematical bold small lambda"),
+  :mbfmu => UCMCommand("\\mbfmu", '𝛍', :mathalpha, "mathematical bold small mu"),
+  :mbfnu => UCMCommand("\\mbfnu", '𝛎', :mathalpha, "mathematical bold small nu"),
+  :mbfxi => UCMCommand("\\mbfxi", '𝛏', :mathalpha, "mathematical bold small xi"),
+  :mbfomicron => UCMCommand("\\mbfomicron", '𝛐', :mathalpha, "mathematical bold small omicron"),
+  :mbfpi => UCMCommand("\\mbfpi", '𝛑', :mathalpha, "mathematical bold small pi"),
+  :mbfrho => UCMCommand("\\mbfrho", '𝛒', :mathalpha, "mathematical bold small rho"),
+  :mbfvarsigma => UCMCommand("\\mbfvarsigma", '𝛓', :mathalpha, "mathematical bold small final sigma"),
+  :mbfsigma => UCMCommand("\\mbfsigma", '𝛔', :mathalpha, "mathematical bold small sigma"),
+  :mbftau => UCMCommand("\\mbftau", '𝛕', :mathalpha, "mathematical bold small tau"),
+  :mbfupsilon => UCMCommand("\\mbfupsilon", '𝛖', :mathalpha, "mathematical bold small upsilon"),
+  :mbfvarphi => UCMCommand("\\mbfvarphi", '𝛗', :mathalpha, "mathematical bold small phi"),
+  :mbfchi => UCMCommand("\\mbfchi", '𝛘', :mathalpha, "mathematical bold small chi"),
+  :mbfpsi => UCMCommand("\\mbfpsi", '𝛙', :mathalpha, "mathematical bold small psi"),
+  :mbfomega => UCMCommand("\\mbfomega", '𝛚', :mathalpha, "mathematical bold small omega"),
+  :mbfpartial => UCMCommand("\\mbfpartial", '𝛛', :mathalpha, "mathematical bold partial differential"),
+  :mbfepsilon => UCMCommand("\\mbfepsilon", '𝛜', :mathalpha, "mathematical bold varepsilon symbol"),
+  :mbfvartheta => UCMCommand("\\mbfvartheta", '𝛝', :mathalpha, "mathematical bold theta symbol"),
+  :mbfvarkappa => UCMCommand("\\mbfvarkappa", '𝛞', :mathalpha, "mathematical bold kappa symbol"),
+  :mbfphi => UCMCommand("\\mbfphi", '𝛟', :mathalpha, "mathematical bold phi symbol"),
+  :mbfvarrho => UCMCommand("\\mbfvarrho", '𝛠', :mathalpha, "mathematical bold rho symbol"),
+  :mbfvarpi => UCMCommand("\\mbfvarpi", '𝛡', :mathalpha, "mathematical bold pi symbol"),
+  :mitAlpha => UCMCommand("\\mitAlpha", '𝛢', :mathalpha, "mathematical italic capital alpha"),
+  :mitBeta => UCMCommand("\\mitBeta", '𝛣', :mathalpha, "mathematical italic capital beta"),
+  :mitGamma => UCMCommand("\\mitGamma", '𝛤', :mathalpha, "mathematical italic capital gamma"),
+  :mitDelta => UCMCommand("\\mitDelta", '𝛥', :mathalpha, "mathematical italic capital delta"),
+  :mitEpsilon => UCMCommand("\\mitEpsilon", '𝛦', :mathalpha, "mathematical italic capital epsilon"),
+  :mitZeta => UCMCommand("\\mitZeta", '𝛧', :mathalpha, "mathematical italic capital zeta"),
+  :mitEta => UCMCommand("\\mitEta", '𝛨', :mathalpha, "mathematical italic capital eta"),
+  :mitTheta => UCMCommand("\\mitTheta", '𝛩', :mathalpha, "mathematical italic capital theta"),
+  :mitIota => UCMCommand("\\mitIota", '𝛪', :mathalpha, "mathematical italic capital iota"),
+  :mitKappa => UCMCommand("\\mitKappa", '𝛫', :mathalpha, "mathematical italic capital kappa"),
+  :mitLambda => UCMCommand("\\mitLambda", '𝛬', :mathalpha, "mathematical italic capital lambda"),
+  :mitMu => UCMCommand("\\mitMu", '𝛭', :mathalpha, "mathematical italic capital mu"),
+  :mitNu => UCMCommand("\\mitNu", '𝛮', :mathalpha, "mathematical italic capital nu"),
+  :mitXi => UCMCommand("\\mitXi", '𝛯', :mathalpha, "mathematical italic capital xi"),
+  :mitOmicron => UCMCommand("\\mitOmicron", '𝛰', :mathalpha, "mathematical italic capital omicron"),
+  :mitPi => UCMCommand("\\mitPi", '𝛱', :mathalpha, "mathematical italic capital pi"),
+  :mitRho => UCMCommand("\\mitRho", '𝛲', :mathalpha, "mathematical italic capital rho"),
+  :mitvarTheta => UCMCommand("\\mitvarTheta", '𝛳', :mathalpha, "mathematical italic capital theta symbol"),
+  :mitSigma => UCMCommand("\\mitSigma", '𝛴', :mathalpha, "mathematical italic capital sigma"),
+  :mitTau => UCMCommand("\\mitTau", '𝛵', :mathalpha, "mathematical italic capital tau"),
+  :mitUpsilon => UCMCommand("\\mitUpsilon", '𝛶', :mathalpha, "mathematical italic capital upsilon"),
+  :mitPhi => UCMCommand("\\mitPhi", '𝛷', :mathalpha, "mathematical italic capital phi"),
+  :mitChi => UCMCommand("\\mitChi", '𝛸', :mathalpha, "mathematical italic capital chi"),
+  :mitPsi => UCMCommand("\\mitPsi", '𝛹', :mathalpha, "mathematical italic capital psi"),
+  :mitOmega => UCMCommand("\\mitOmega", '𝛺', :mathalpha, "mathematical italic capital omega"),
+  :mitnabla => UCMCommand("\\mitnabla", '𝛻', :mathalpha, "mathematical italic nabla"),
+  :mitalpha => UCMCommand("\\mitalpha", '𝛼', :mathalpha, "mathematical italic small alpha"),
+  :mitbeta => UCMCommand("\\mitbeta", '𝛽', :mathalpha, "mathematical italic small beta"),
+  :mitgamma => UCMCommand("\\mitgamma", '𝛾', :mathalpha, "mathematical italic small gamma"),
+  :mitdelta => UCMCommand("\\mitdelta", '𝛿', :mathalpha, "mathematical italic small delta"),
+  :mitvarepsilon => UCMCommand("\\mitvarepsilon", '𝜀', :mathalpha, "mathematical italic small varepsilon"),
+  :mitzeta => UCMCommand("\\mitzeta", '𝜁', :mathalpha, "mathematical italic small zeta"),
+  :miteta => UCMCommand("\\miteta", '𝜂', :mathalpha, "mathematical italic small eta"),
+  :mittheta => UCMCommand("\\mittheta", '𝜃', :mathalpha, "mathematical italic small theta"),
+  :mitiota => UCMCommand("\\mitiota", '𝜄', :mathalpha, "mathematical italic small iota"),
+  :mitkappa => UCMCommand("\\mitkappa", '𝜅', :mathalpha, "mathematical italic small kappa"),
+  :mitlambda => UCMCommand("\\mitlambda", '𝜆', :mathalpha, "mathematical italic small lambda"),
+  :mitmu => UCMCommand("\\mitmu", '𝜇', :mathalpha, "mathematical italic small mu"),
+  :mitnu => UCMCommand("\\mitnu", '𝜈', :mathalpha, "mathematical italic small nu"),
+  :mitxi => UCMCommand("\\mitxi", '𝜉', :mathalpha, "mathematical italic small xi"),
+  :mitomicron => UCMCommand("\\mitomicron", '𝜊', :mathalpha, "mathematical italic small omicron"),
+  :mitpi => UCMCommand("\\mitpi", '𝜋', :mathalpha, "mathematical italic small pi"),
+  :mitrho => UCMCommand("\\mitrho", '𝜌', :mathalpha, "mathematical italic small rho"),
+  :mitvarsigma => UCMCommand("\\mitvarsigma", '𝜍', :mathalpha, "mathematical italic small final sigma"),
+  :mitsigma => UCMCommand("\\mitsigma", '𝜎', :mathalpha, "mathematical italic small sigma"),
+  :mittau => UCMCommand("\\mittau", '𝜏', :mathalpha, "mathematical italic small tau"),
+  :mitupsilon => UCMCommand("\\mitupsilon", '𝜐', :mathalpha, "mathematical italic small upsilon"),
+  :mitvarphi => UCMCommand("\\mitvarphi", '𝜑', :mathalpha, "mathematical italic small phi"),
+  :mitchi => UCMCommand("\\mitchi", '𝜒', :mathalpha, "mathematical italic small chi"),
+  :mitpsi => UCMCommand("\\mitpsi", '𝜓', :mathalpha, "mathematical italic small psi"),
+  :mitomega => UCMCommand("\\mitomega", '𝜔', :mathalpha, "mathematical italic small omega"),
+  :mitpartial => UCMCommand("\\mitpartial", '𝜕', :mathalpha, "mathematical italic partial differential"),
+  :mitepsilon => UCMCommand("\\mitepsilon", '𝜖', :mathalpha, "mathematical italic varepsilon symbol"),
+  :mitvartheta => UCMCommand("\\mitvartheta", '𝜗', :mathalpha, "mathematical italic theta symbol"),
+  :mitvarkappa => UCMCommand("\\mitvarkappa", '𝜘', :mathalpha, "mathematical italic kappa symbol"),
+  :mitphi => UCMCommand("\\mitphi", '𝜙', :mathalpha, "mathematical italic phi symbol"),
+  :mitvarrho => UCMCommand("\\mitvarrho", '𝜚', :mathalpha, "mathematical italic rho symbol"),
+  :mitvarpi => UCMCommand("\\mitvarpi", '𝜛', :mathalpha, "mathematical italic pi symbol"),
+  :mbfitAlpha => UCMCommand("\\mbfitAlpha", '𝜜', :mathalpha, "mathematical bold italic capital alpha"),
+  :mbfitBeta => UCMCommand("\\mbfitBeta", '𝜝', :mathalpha, "mathematical bold italic capital beta"),
+  :mbfitGamma => UCMCommand("\\mbfitGamma", '𝜞', :mathalpha, "mathematical bold italic capital gamma"),
+  :mbfitDelta => UCMCommand("\\mbfitDelta", '𝜟', :mathalpha, "mathematical bold italic capital delta"),
+  :mbfitEpsilon => UCMCommand("\\mbfitEpsilon", '𝜠', :mathalpha, "mathematical bold italic capital epsilon"),
+  :mbfitZeta => UCMCommand("\\mbfitZeta", '𝜡', :mathalpha, "mathematical bold italic capital zeta"),
+  :mbfitEta => UCMCommand("\\mbfitEta", '𝜢', :mathalpha, "mathematical bold italic capital eta"),
+  :mbfitTheta => UCMCommand("\\mbfitTheta", '𝜣', :mathalpha, "mathematical bold italic capital theta"),
+  :mbfitIota => UCMCommand("\\mbfitIota", '𝜤', :mathalpha, "mathematical bold italic capital iota"),
+  :mbfitKappa => UCMCommand("\\mbfitKappa", '𝜥', :mathalpha, "mathematical bold italic capital kappa"),
+  :mbfitLambda => UCMCommand("\\mbfitLambda", '𝜦', :mathalpha, "mathematical bold italic capital lambda"),
+  :mbfitMu => UCMCommand("\\mbfitMu", '𝜧', :mathalpha, "mathematical bold italic capital mu"),
+  :mbfitNu => UCMCommand("\\mbfitNu", '𝜨', :mathalpha, "mathematical bold italic capital nu"),
+  :mbfitXi => UCMCommand("\\mbfitXi", '𝜩', :mathalpha, "mathematical bold italic capital xi"),
+  :mbfitOmicron => UCMCommand("\\mbfitOmicron", '𝜪', :mathalpha, "mathematical bold italic capital omicron"),
+  :mbfitPi => UCMCommand("\\mbfitPi", '𝜫', :mathalpha, "mathematical bold italic capital pi"),
+  :mbfitRho => UCMCommand("\\mbfitRho", '𝜬', :mathalpha, "mathematical bold italic capital rho"),
+  :mbfitvarTheta => UCMCommand("\\mbfitvarTheta", '𝜭', :mathalpha, "mathematical bold italic capital theta symbol"),
+  :mbfitSigma => UCMCommand("\\mbfitSigma", '𝜮', :mathalpha, "mathematical bold italic capital sigma"),
+  :mbfitTau => UCMCommand("\\mbfitTau", '𝜯', :mathalpha, "mathematical bold italic capital tau"),
+  :mbfitUpsilon => UCMCommand("\\mbfitUpsilon", '𝜰', :mathalpha, "mathematical bold italic capital upsilon"),
+  :mbfitPhi => UCMCommand("\\mbfitPhi", '𝜱', :mathalpha, "mathematical bold italic capital phi"),
+  :mbfitChi => UCMCommand("\\mbfitChi", '𝜲', :mathalpha, "mathematical bold italic capital chi"),
+  :mbfitPsi => UCMCommand("\\mbfitPsi", '𝜳', :mathalpha, "mathematical bold italic capital psi"),
+  :mbfitOmega => UCMCommand("\\mbfitOmega", '𝜴', :mathalpha, "mathematical bold italic capital omega"),
+  :mbfitnabla => UCMCommand("\\mbfitnabla", '𝜵', :mathalpha, "mathematical bold italic nabla"),
+  :mbfitalpha => UCMCommand("\\mbfitalpha", '𝜶', :mathalpha, "mathematical bold italic small alpha"),
+  :mbfitbeta => UCMCommand("\\mbfitbeta", '𝜷', :mathalpha, "mathematical bold italic small beta"),
+  :mbfitgamma => UCMCommand("\\mbfitgamma", '𝜸', :mathalpha, "mathematical bold italic small gamma"),
+  :mbfitdelta => UCMCommand("\\mbfitdelta", '𝜹', :mathalpha, "mathematical bold italic small delta"),
+  :mbfitvarepsilon => UCMCommand("\\mbfitvarepsilon", '𝜺', :mathalpha, "mathematical bold italic small varepsilon"),
+  :mbfitzeta => UCMCommand("\\mbfitzeta", '𝜻', :mathalpha, "mathematical bold italic small zeta"),
+  :mbfiteta => UCMCommand("\\mbfiteta", '𝜼', :mathalpha, "mathematical bold italic small eta"),
+  :mbfittheta => UCMCommand("\\mbfittheta", '𝜽', :mathalpha, "mathematical bold italic small theta"),
+  :mbfitiota => UCMCommand("\\mbfitiota", '𝜾', :mathalpha, "mathematical bold italic small iota"),
+  :mbfitkappa => UCMCommand("\\mbfitkappa", '𝜿', :mathalpha, "mathematical bold italic small kappa"),
+  :mbfitlambda => UCMCommand("\\mbfitlambda", '𝝀', :mathalpha, "mathematical bold italic small lambda"),
+  :mbfitmu => UCMCommand("\\mbfitmu", '𝝁', :mathalpha, "mathematical bold italic small mu"),
+  :mbfitnu => UCMCommand("\\mbfitnu", '𝝂', :mathalpha, "mathematical bold italic small nu"),
+  :mbfitxi => UCMCommand("\\mbfitxi", '𝝃', :mathalpha, "mathematical bold italic small xi"),
+  :mbfitomicron => UCMCommand("\\mbfitomicron", '𝝄', :mathalpha, "mathematical bold italic small omicron"),
+  :mbfitpi => UCMCommand("\\mbfitpi", '𝝅', :mathalpha, "mathematical bold italic small pi"),
+  :mbfitrho => UCMCommand("\\mbfitrho", '𝝆', :mathalpha, "mathematical bold italic small rho"),
+  :mbfitvarsigma => UCMCommand("\\mbfitvarsigma", '𝝇', :mathalpha, "mathematical bold italic small final sigma"),
+  :mbfitsigma => UCMCommand("\\mbfitsigma", '𝝈', :mathalpha, "mathematical bold italic small sigma"),
+  :mbfittau => UCMCommand("\\mbfittau", '𝝉', :mathalpha, "mathematical bold italic small tau"),
+  :mbfitupsilon => UCMCommand("\\mbfitupsilon", '𝝊', :mathalpha, "mathematical bold italic small upsilon"),
+  :mbfitvarphi => UCMCommand("\\mbfitvarphi", '𝝋', :mathalpha, "mathematical bold italic small phi"),
+  :mbfitchi => UCMCommand("\\mbfitchi", '𝝌', :mathalpha, "mathematical bold italic small chi"),
+  :mbfitpsi => UCMCommand("\\mbfitpsi", '𝝍', :mathalpha, "mathematical bold italic small psi"),
+  :mbfitomega => UCMCommand("\\mbfitomega", '𝝎', :mathalpha, "mathematical bold italic small omega"),
+  :mbfitpartial => UCMCommand("\\mbfitpartial", '𝝏', :mathalpha, "mathematical bold italic partial differential"),
+  :mbfitepsilon => UCMCommand("\\mbfitepsilon", '𝝐', :mathalpha, "mathematical bold italic varepsilon symbol"),
+  :mbfitvartheta => UCMCommand("\\mbfitvartheta", '𝝑', :mathalpha, "mathematical bold italic theta symbol"),
+  :mbfitvarkappa => UCMCommand("\\mbfitvarkappa", '𝝒', :mathalpha, "mathematical bold italic kappa symbol"),
+  :mbfitphi => UCMCommand("\\mbfitphi", '𝝓', :mathalpha, "mathematical bold italic phi symbol"),
+  :mbfitvarrho => UCMCommand("\\mbfitvarrho", '𝝔', :mathalpha, "mathematical bold italic rho symbol"),
+  :mbfitvarpi => UCMCommand("\\mbfitvarpi", '𝝕', :mathalpha, "mathematical bold italic pi symbol"),
+  :mbfsansAlpha => UCMCommand("\\mbfsansAlpha", '𝝖', :mathalpha, "mathematical sans-serif bold capital alpha"),
+  :mbfsansBeta => UCMCommand("\\mbfsansBeta", '𝝗', :mathalpha, "mathematical sans-serif bold capital beta"),
+  :mbfsansGamma => UCMCommand("\\mbfsansGamma", '𝝘', :mathalpha, "mathematical sans-serif bold capital gamma"),
+  :mbfsansDelta => UCMCommand("\\mbfsansDelta", '𝝙', :mathalpha, "mathematical sans-serif bold capital delta"),
+  :mbfsansEpsilon => UCMCommand("\\mbfsansEpsilon", '𝝚', :mathalpha, "mathematical sans-serif bold capital epsilon"),
+  :mbfsansZeta => UCMCommand("\\mbfsansZeta", '𝝛', :mathalpha, "mathematical sans-serif bold capital zeta"),
+  :mbfsansEta => UCMCommand("\\mbfsansEta", '𝝜', :mathalpha, "mathematical sans-serif bold capital eta"),
+  :mbfsansTheta => UCMCommand("\\mbfsansTheta", '𝝝', :mathalpha, "mathematical sans-serif bold capital theta"),
+  :mbfsansIota => UCMCommand("\\mbfsansIota", '𝝞', :mathalpha, "mathematical sans-serif bold capital iota"),
+  :mbfsansKappa => UCMCommand("\\mbfsansKappa", '𝝟', :mathalpha, "mathematical sans-serif bold capital kappa"),
+  :mbfsansLambda => UCMCommand("\\mbfsansLambda", '𝝠', :mathalpha, "mathematical sans-serif bold capital lambda"),
+  :mbfsansMu => UCMCommand("\\mbfsansMu", '𝝡', :mathalpha, "mathematical sans-serif bold capital mu"),
+  :mbfsansNu => UCMCommand("\\mbfsansNu", '𝝢', :mathalpha, "mathematical sans-serif bold capital nu"),
+  :mbfsansXi => UCMCommand("\\mbfsansXi", '𝝣', :mathalpha, "mathematical sans-serif bold capital xi"),
+  :mbfsansOmicron => UCMCommand("\\mbfsansOmicron", '𝝤', :mathalpha, "mathematical sans-serif bold capital omicron"),
+  :mbfsansPi => UCMCommand("\\mbfsansPi", '𝝥', :mathalpha, "mathematical sans-serif bold capital pi"),
+  :mbfsansRho => UCMCommand("\\mbfsansRho", '𝝦', :mathalpha, "mathematical sans-serif bold capital rho"),
+  :mbfsansvarTheta => UCMCommand("\\mbfsansvarTheta", '𝝧', :mathalpha, "mathematical sans-serif bold capital theta symbol"),
+  :mbfsansSigma => UCMCommand("\\mbfsansSigma", '𝝨', :mathalpha, "mathematical sans-serif bold capital sigma"),
+  :mbfsansTau => UCMCommand("\\mbfsansTau", '𝝩', :mathalpha, "mathematical sans-serif bold capital tau"),
+  :mbfsansUpsilon => UCMCommand("\\mbfsansUpsilon", '𝝪', :mathalpha, "mathematical sans-serif bold capital upsilon"),
+  :mbfsansPhi => UCMCommand("\\mbfsansPhi", '𝝫', :mathalpha, "mathematical sans-serif bold capital phi"),
+  :mbfsansChi => UCMCommand("\\mbfsansChi", '𝝬', :mathalpha, "mathematical sans-serif bold capital chi"),
+  :mbfsansPsi => UCMCommand("\\mbfsansPsi", '𝝭', :mathalpha, "mathematical sans-serif bold capital psi"),
+  :mbfsansOmega => UCMCommand("\\mbfsansOmega", '𝝮', :mathalpha, "mathematical sans-serif bold capital omega"),
+  :mbfsansnabla => UCMCommand("\\mbfsansnabla", '𝝯', :mathalpha, "mathematical sans-serif bold nabla"),
+  :mbfsansalpha => UCMCommand("\\mbfsansalpha", '𝝰', :mathalpha, "mathematical sans-serif bold small alpha"),
+  :mbfsansbeta => UCMCommand("\\mbfsansbeta", '𝝱', :mathalpha, "mathematical sans-serif bold small beta"),
+  :mbfsansgamma => UCMCommand("\\mbfsansgamma", '𝝲', :mathalpha, "mathematical sans-serif bold small gamma"),
+  :mbfsansdelta => UCMCommand("\\mbfsansdelta", '𝝳', :mathalpha, "mathematical sans-serif bold small delta"),
+  :mbfsansvarepsilon => UCMCommand("\\mbfsansvarepsilon", '𝝴', :mathalpha, "mathematical sans-serif bold small varepsilon"),
+  :mbfsanszeta => UCMCommand("\\mbfsanszeta", '𝝵', :mathalpha, "mathematical sans-serif bold small zeta"),
+  :mbfsanseta => UCMCommand("\\mbfsanseta", '𝝶', :mathalpha, "mathematical sans-serif bold small eta"),
+  :mbfsanstheta => UCMCommand("\\mbfsanstheta", '𝝷', :mathalpha, "mathematical sans-serif bold small theta"),
+  :mbfsansiota => UCMCommand("\\mbfsansiota", '𝝸', :mathalpha, "mathematical sans-serif bold small iota"),
+  :mbfsanskappa => UCMCommand("\\mbfsanskappa", '𝝹', :mathalpha, "mathematical sans-serif bold small kappa"),
+  :mbfsanslambda => UCMCommand("\\mbfsanslambda", '𝝺', :mathalpha, "mathematical sans-serif bold small lambda"),
+  :mbfsansmu => UCMCommand("\\mbfsansmu", '𝝻', :mathalpha, "mathematical sans-serif bold small mu"),
+  :mbfsansnu => UCMCommand("\\mbfsansnu", '𝝼', :mathalpha, "mathematical sans-serif bold small nu"),
+  :mbfsansxi => UCMCommand("\\mbfsansxi", '𝝽', :mathalpha, "mathematical sans-serif bold small xi"),
+  :mbfsansomicron => UCMCommand("\\mbfsansomicron", '𝝾', :mathalpha, "mathematical sans-serif bold small omicron"),
+  :mbfsanspi => UCMCommand("\\mbfsanspi", '𝝿', :mathalpha, "mathematical sans-serif bold small pi"),
+  :mbfsansrho => UCMCommand("\\mbfsansrho", '𝞀', :mathalpha, "mathematical sans-serif bold small rho"),
+  :mbfsansvarsigma => UCMCommand("\\mbfsansvarsigma", '𝞁', :mathalpha, "mathematical sans-serif bold small final sigma"),
+  :mbfsanssigma => UCMCommand("\\mbfsanssigma", '𝞂', :mathalpha, "mathematical sans-serif bold small sigma"),
+  :mbfsanstau => UCMCommand("\\mbfsanstau", '𝞃', :mathalpha, "mathematical sans-serif bold small tau"),
+  :mbfsansupsilon => UCMCommand("\\mbfsansupsilon", '𝞄', :mathalpha, "mathematical sans-serif bold small upsilon"),
+  :mbfsansvarphi => UCMCommand("\\mbfsansvarphi", '𝞅', :mathalpha, "mathematical sans-serif bold small phi"),
+  :mbfsanschi => UCMCommand("\\mbfsanschi", '𝞆', :mathalpha, "mathematical sans-serif bold small chi"),
+  :mbfsanspsi => UCMCommand("\\mbfsanspsi", '𝞇', :mathalpha, "mathematical sans-serif bold small psi"),
+  :mbfsansomega => UCMCommand("\\mbfsansomega", '𝞈', :mathalpha, "mathematical sans-serif bold small omega"),
+  :mbfsanspartial => UCMCommand("\\mbfsanspartial", '𝞉', :mathalpha, "mathematical sans-serif bold partial differential"),
+  :mbfsansepsilon => UCMCommand("\\mbfsansepsilon", '𝞊', :mathalpha, "mathematical sans-serif bold varepsilon symbol"),
+  :mbfsansvartheta => UCMCommand("\\mbfsansvartheta", '𝞋', :mathalpha, "mathematical sans-serif bold theta symbol"),
+  :mbfsansvarkappa => UCMCommand("\\mbfsansvarkappa", '𝞌', :mathalpha, "mathematical sans-serif bold kappa symbol"),
+  :mbfsansphi => UCMCommand("\\mbfsansphi", '𝞍', :mathalpha, "mathematical sans-serif bold phi symbol"),
+  :mbfsansvarrho => UCMCommand("\\mbfsansvarrho", '𝞎', :mathalpha, "mathematical sans-serif bold rho symbol"),
+  :mbfsansvarpi => UCMCommand("\\mbfsansvarpi", '𝞏', :mathalpha, "mathematical sans-serif bold pi symbol"),
+  :mbfitsansAlpha => UCMCommand("\\mbfitsansAlpha", '𝞐', :mathalpha, "mathematical sans-serif bold italic capital alpha"),
+  :mbfitsansBeta => UCMCommand("\\mbfitsansBeta", '𝞑', :mathalpha, "mathematical sans-serif bold italic capital beta"),
+  :mbfitsansGamma => UCMCommand("\\mbfitsansGamma", '𝞒', :mathalpha, "mathematical sans-serif bold italic capital gamma"),
+  :mbfitsansDelta => UCMCommand("\\mbfitsansDelta", '𝞓', :mathalpha, "mathematical sans-serif bold italic capital delta"),
+  :mbfitsansEpsilon => UCMCommand("\\mbfitsansEpsilon", '𝞔', :mathalpha, "mathematical sans-serif bold italic capital epsilon"),
+  :mbfitsansZeta => UCMCommand("\\mbfitsansZeta", '𝞕', :mathalpha, "mathematical sans-serif bold italic capital zeta"),
+  :mbfitsansEta => UCMCommand("\\mbfitsansEta", '𝞖', :mathalpha, "mathematical sans-serif bold italic capital eta"),
+  :mbfitsansTheta => UCMCommand("\\mbfitsansTheta", '𝞗', :mathalpha, "mathematical sans-serif bold italic capital theta"),
+  :mbfitsansIota => UCMCommand("\\mbfitsansIota", '𝞘', :mathalpha, "mathematical sans-serif bold italic capital iota"),
+  :mbfitsansKappa => UCMCommand("\\mbfitsansKappa", '𝞙', :mathalpha, "mathematical sans-serif bold italic capital kappa"),
+  :mbfitsansLambda => UCMCommand("\\mbfitsansLambda", '𝞚', :mathalpha, "mathematical sans-serif bold italic capital lambda"),
+  :mbfitsansMu => UCMCommand("\\mbfitsansMu", '𝞛', :mathalpha, "mathematical sans-serif bold italic capital mu"),
+  :mbfitsansNu => UCMCommand("\\mbfitsansNu", '𝞜', :mathalpha, "mathematical sans-serif bold italic capital nu"),
+  :mbfitsansXi => UCMCommand("\\mbfitsansXi", '𝞝', :mathalpha, "mathematical sans-serif bold italic capital xi"),
+  :mbfitsansOmicron => UCMCommand("\\mbfitsansOmicron", '𝞞', :mathalpha, "mathematical sans-serif bold italic capital omicron"),
+  :mbfitsansPi => UCMCommand("\\mbfitsansPi", '𝞟', :mathalpha, "mathematical sans-serif bold italic capital pi"),
+  :mbfitsansRho => UCMCommand("\\mbfitsansRho", '𝞠', :mathalpha, "mathematical sans-serif bold italic capital rho"),
+  :mbfitsansvarTheta => UCMCommand("\\mbfitsansvarTheta", '𝞡', :mathalpha, "mathematical sans-serif bold italic capital theta symbol"),
+  :mbfitsansSigma => UCMCommand("\\mbfitsansSigma", '𝞢', :mathalpha, "mathematical sans-serif bold italic capital sigma"),
+  :mbfitsansTau => UCMCommand("\\mbfitsansTau", '𝞣', :mathalpha, "mathematical sans-serif bold italic capital tau"),
+  :mbfitsansUpsilon => UCMCommand("\\mbfitsansUpsilon", '𝞤', :mathalpha, "mathematical sans-serif bold italic capital upsilon"),
+  :mbfitsansPhi => UCMCommand("\\mbfitsansPhi", '𝞥', :mathalpha, "mathematical sans-serif bold italic capital phi"),
+  :mbfitsansChi => UCMCommand("\\mbfitsansChi", '𝞦', :mathalpha, "mathematical sans-serif bold italic capital chi"),
+  :mbfitsansPsi => UCMCommand("\\mbfitsansPsi", '𝞧', :mathalpha, "mathematical sans-serif bold italic capital psi"),
+  :mbfitsansOmega => UCMCommand("\\mbfitsansOmega", '𝞨', :mathalpha, "mathematical sans-serif bold italic capital omega"),
+  :mbfitsansnabla => UCMCommand("\\mbfitsansnabla", '𝞩', :mathalpha, "mathematical sans-serif bold italic nabla"),
+  :mbfitsansalpha => UCMCommand("\\mbfitsansalpha", '𝞪', :mathalpha, "mathematical sans-serif bold italic small alpha"),
+  :mbfitsansbeta => UCMCommand("\\mbfitsansbeta", '𝞫', :mathalpha, "mathematical sans-serif bold italic small beta"),
+  :mbfitsansgamma => UCMCommand("\\mbfitsansgamma", '𝞬', :mathalpha, "mathematical sans-serif bold italic small gamma"),
+  :mbfitsansdelta => UCMCommand("\\mbfitsansdelta", '𝞭', :mathalpha, "mathematical sans-serif bold italic small delta"),
+  :mbfitsansvarepsilon => UCMCommand("\\mbfitsansvarepsilon", '𝞮', :mathalpha, "mathematical sans-serif bold italic small varepsilon"),
+  :mbfitsanszeta => UCMCommand("\\mbfitsanszeta", '𝞯', :mathalpha, "mathematical sans-serif bold italic small zeta"),
+  :mbfitsanseta => UCMCommand("\\mbfitsanseta", '𝞰', :mathalpha, "mathematical sans-serif bold italic small eta"),
+  :mbfitsanstheta => UCMCommand("\\mbfitsanstheta", '𝞱', :mathalpha, "mathematical sans-serif bold italic small theta"),
+  :mbfitsansiota => UCMCommand("\\mbfitsansiota", '𝞲', :mathalpha, "mathematical sans-serif bold italic small iota"),
+  :mbfitsanskappa => UCMCommand("\\mbfitsanskappa", '𝞳', :mathalpha, "mathematical sans-serif bold italic small kappa"),
+  :mbfitsanslambda => UCMCommand("\\mbfitsanslambda", '𝞴', :mathalpha, "mathematical sans-serif bold italic small lambda"),
+  :mbfitsansmu => UCMCommand("\\mbfitsansmu", '𝞵', :mathalpha, "mathematical sans-serif bold italic small mu"),
+  :mbfitsansnu => UCMCommand("\\mbfitsansnu", '𝞶', :mathalpha, "mathematical sans-serif bold italic small nu"),
+  :mbfitsansxi => UCMCommand("\\mbfitsansxi", '𝞷', :mathalpha, "mathematical sans-serif bold italic small xi"),
+  :mbfitsansomicron => UCMCommand("\\mbfitsansomicron", '𝞸', :mathalpha, "mathematical sans-serif bold italic small omicron"),
+  :mbfitsanspi => UCMCommand("\\mbfitsanspi", '𝞹', :mathalpha, "mathematical sans-serif bold italic small pi"),
+  :mbfitsansrho => UCMCommand("\\mbfitsansrho", '𝞺', :mathalpha, "mathematical sans-serif bold italic small rho"),
+  :mbfitsansvarsigma => UCMCommand("\\mbfitsansvarsigma", '𝞻', :mathalpha, "mathematical sans-serif bold italic small final sigma"),
+  :mbfitsanssigma => UCMCommand("\\mbfitsanssigma", '𝞼', :mathalpha, "mathematical sans-serif bold italic small sigma"),
+  :mbfitsanstau => UCMCommand("\\mbfitsanstau", '𝞽', :mathalpha, "mathematical sans-serif bold italic small tau"),
+  :mbfitsansupsilon => UCMCommand("\\mbfitsansupsilon", '𝞾', :mathalpha, "mathematical sans-serif bold italic small upsilon"),
+  :mbfitsansvarphi => UCMCommand("\\mbfitsansvarphi", '𝞿', :mathalpha, "mathematical sans-serif bold italic small phi"),
+  :mbfitsanschi => UCMCommand("\\mbfitsanschi", '𝟀', :mathalpha, "mathematical sans-serif bold italic small chi"),
+  :mbfitsanspsi => UCMCommand("\\mbfitsanspsi", '𝟁', :mathalpha, "mathematical sans-serif bold italic small psi"),
+  :mbfitsansomega => UCMCommand("\\mbfitsansomega", '𝟂', :mathalpha, "mathematical sans-serif bold italic small omega"),
+  :mbfitsanspartial => UCMCommand("\\mbfitsanspartial", '𝟃', :mathalpha, "mathematical sans-serif bold italic partial differential"),
+  :mbfitsansepsilon => UCMCommand("\\mbfitsansepsilon", '𝟄', :mathalpha, "mathematical sans-serif bold italic varepsilon symbol"),
+  :mbfitsansvartheta => UCMCommand("\\mbfitsansvartheta", '𝟅', :mathalpha, "mathematical sans-serif bold italic theta symbol"),
+  :mbfitsansvarkappa => UCMCommand("\\mbfitsansvarkappa", '𝟆', :mathalpha, "mathematical sans-serif bold italic kappa symbol"),
+  :mbfitsansphi => UCMCommand("\\mbfitsansphi", '𝟇', :mathalpha, "mathematical sans-serif bold italic phi symbol"),
+  :mbfitsansvarrho => UCMCommand("\\mbfitsansvarrho", '𝟈', :mathalpha, "mathematical sans-serif bold italic rho symbol"),
+  :mbfitsansvarpi => UCMCommand("\\mbfitsansvarpi", '𝟉', :mathalpha, "mathematical sans-serif bold italic pi symbol"),
+  :mbfDigamma => UCMCommand("\\mbfDigamma", '𝟊', :mathalpha, "mathematical bold capital digamma"),
+  :mbfdigamma => UCMCommand("\\mbfdigamma", '𝟋', :mathalpha, "mathematical bold small digamma"),
+  :mbfzero => UCMCommand("\\mbfzero", '𝟎', :mathord, "mathematical bold digit 0"),
+  :mbfone => UCMCommand("\\mbfone", '𝟏', :mathord, "mathematical bold digit 1"),
+  :mbftwo => UCMCommand("\\mbftwo", '𝟐', :mathord, "mathematical bold digit 2"),
+  :mbfthree => UCMCommand("\\mbfthree", '𝟑', :mathord, "mathematical bold digit 3"),
+  :mbffour => UCMCommand("\\mbffour", '𝟒', :mathord, "mathematical bold digit 4"),
+  :mbffive => UCMCommand("\\mbffive", '𝟓', :mathord, "mathematical bold digit 5"),
+  :mbfsix => UCMCommand("\\mbfsix", '𝟔', :mathord, "mathematical bold digit 6"),
+  :mbfseven => UCMCommand("\\mbfseven", '𝟕', :mathord, "mathematical bold digit 7"),
+  :mbfeight => UCMCommand("\\mbfeight", '𝟖', :mathord, "mathematical bold digit 8"),
+  :mbfnine => UCMCommand("\\mbfnine", '𝟗', :mathord, "mathematical bold digit 9"),
+  :Bbbzero => UCMCommand("\\Bbbzero", '𝟘', :mathord, "mathematical double-struck digit 0"),
+  :Bbbone => UCMCommand("\\Bbbone", '𝟙', :mathord, "mathematical double-struck digit 1"),
+  :Bbbtwo => UCMCommand("\\Bbbtwo", '𝟚', :mathord, "mathematical double-struck digit 2"),
+  :Bbbthree => UCMCommand("\\Bbbthree", '𝟛', :mathord, "mathematical double-struck digit 3"),
+  :Bbbfour => UCMCommand("\\Bbbfour", '𝟜', :mathord, "mathematical double-struck digit 4"),
+  :Bbbfive => UCMCommand("\\Bbbfive", '𝟝', :mathord, "mathematical double-struck digit 5"),
+  :Bbbsix => UCMCommand("\\Bbbsix", '𝟞', :mathord, "mathematical double-struck digit 6"),
+  :Bbbseven => UCMCommand("\\Bbbseven", '𝟟', :mathord, "mathematical double-struck digit 7"),
+  :Bbbeight => UCMCommand("\\Bbbeight", '𝟠', :mathord, "mathematical double-struck digit 8"),
+  :Bbbnine => UCMCommand("\\Bbbnine", '𝟡', :mathord, "mathematical double-struck digit 9"),
+  :msanszero => UCMCommand("\\msanszero", '𝟢', :mathord, "mathematical sans-serif digit 0"),
+  :msansone => UCMCommand("\\msansone", '𝟣', :mathord, "mathematical sans-serif digit 1"),
+  :msanstwo => UCMCommand("\\msanstwo", '𝟤', :mathord, "mathematical sans-serif digit 2"),
+  :msansthree => UCMCommand("\\msansthree", '𝟥', :mathord, "mathematical sans-serif digit 3"),
+  :msansfour => UCMCommand("\\msansfour", '𝟦', :mathord, "mathematical sans-serif digit 4"),
+  :msansfive => UCMCommand("\\msansfive", '𝟧', :mathord, "mathematical sans-serif digit 5"),
+  :msanssix => UCMCommand("\\msanssix", '𝟨', :mathord, "mathematical sans-serif digit 6"),
+  :msansseven => UCMCommand("\\msansseven", '𝟩', :mathord, "mathematical sans-serif digit 7"),
+  :msanseight => UCMCommand("\\msanseight", '𝟪', :mathord, "mathematical sans-serif digit 8"),
+  :msansnine => UCMCommand("\\msansnine", '𝟫', :mathord, "mathematical sans-serif digit 9"),
+  :mbfsanszero => UCMCommand("\\mbfsanszero", '𝟬', :mathord, "mathematical sans-serif bold digit 0"),
+  :mbfsansone => UCMCommand("\\mbfsansone", '𝟭', :mathord, "mathematical sans-serif bold digit 1"),
+  :mbfsanstwo => UCMCommand("\\mbfsanstwo", '𝟮', :mathord, "mathematical sans-serif bold digit 2"),
+  :mbfsansthree => UCMCommand("\\mbfsansthree", '𝟯', :mathord, "mathematical sans-serif bold digit 3"),
+  :mbfsansfour => UCMCommand("\\mbfsansfour", '𝟰', :mathord, "mathematical sans-serif bold digit 4"),
+  :mbfsansfive => UCMCommand("\\mbfsansfive", '𝟱', :mathord, "mathematical sans-serif bold digit 5"),
+  :mbfsanssix => UCMCommand("\\mbfsanssix", '𝟲', :mathord, "mathematical sans-serif bold digit 6"),
+  :mbfsansseven => UCMCommand("\\mbfsansseven", '𝟳', :mathord, "mathematical sans-serif bold digit 7"),
+  :mbfsanseight => UCMCommand("\\mbfsanseight", '𝟴', :mathord, "mathematical sans-serif bold digit 8"),
+  :mbfsansnine => UCMCommand("\\mbfsansnine", '𝟵', :mathord, "mathematical sans-serif bold digit 9"),
+  :mttzero => UCMCommand("\\mttzero", '𝟶', :mathord, "mathematical monospace digit 0"),
+  :mttone => UCMCommand("\\mttone", '𝟷', :mathord, "mathematical monospace digit 1"),
+  :mtttwo => UCMCommand("\\mtttwo", '𝟸', :mathord, "mathematical monospace digit 2"),
+  :mttthree => UCMCommand("\\mttthree", '𝟹', :mathord, "mathematical monospace digit 3"),
+  :mttfour => UCMCommand("\\mttfour", '𝟺', :mathord, "mathematical monospace digit 4"),
+  :mttfive => UCMCommand("\\mttfive", '𝟻', :mathord, "mathematical monospace digit 5"),
+  :mttsix => UCMCommand("\\mttsix", '𝟼', :mathord, "mathematical monospace digit 6"),
+  :mttseven => UCMCommand("\\mttseven", '𝟽', :mathord, "mathematical monospace digit 7"),
+  :mtteight => UCMCommand("\\mtteight", '𝟾', :mathord, "mathematical monospace digit 8"),
+  :mttnine => UCMCommand("\\mttnine", '𝟿', :mathord, "mathematical monospace digit 9"),
+  :arabicmaj => UCMCommand("\\arabicmaj", '𞻰', :mathop, "arabic mathematical operator meem with hah with tatweel"),
+  :arabichad => UCMCommand("\\arabichad", '𞻱', :mathop, "arabic mathematical operator hah with dal"),
+)
\ No newline at end of file
diff --git a/src/UnicodeMath/src/ucmchars.jl b/src/UnicodeMath/src/ucmchars.jl
new file mode 100644
index 0000000..ba15fab
--- /dev/null
+++ b/src/UnicodeMath/src/ucmchars.jl
@@ -0,0 +1,413 @@
+# This file takes inspiration from source file `um-code-usv.dtx`
+# of the UNICODE-MATH package  <wspr.io/unicode-math>
+
+# We generate two mappings in here:
+#
+# `const ucmchars_by_alphabet_style_name = all_chars()`
+#
+# `ucmchars_by_alphabet_style_name` is a dict-of-dict-of-dict (?)
+# * alphabet (:Greek, :greek, :Latin, …)
+#   => style (:up, :bfup, …) 
+#     => name ("a", "Gamma", "1", … )
+#        => ucm_ch::UCMChar
+#
+# `const chars_to_ucmchars = inverse_ucm_dict(ucmchars_by_alphabet_style_name)`
+#
+# `chars_to_ucmchars` is an inverse look-up dict, mapping 
+# glyphs of type `Char` to UCMChars (if they are defined in `ucmchars_by_alphabet_style_name`)
+
+"""
+    UCMChar(; name, alphabet, style, glyph)
+
+Internal type decorating a `glyph::Char` with meta data."""
+Base.@kwdef struct UCMChar
+    name :: String
+    alphabet :: Symbol
+    style :: Symbol
+    glyph :: Char
+end
+
+function Base.show(io::IO, ucmchar::UCMChar)
+    print(io, "UCMChar('$(ucmchar.glyph)')")
+end
+
+## helper: "theta" ↦ "Theta", "vartheta" ↦ "varTheta" …
+_cap(n) = startswith(n, "var") ? "var" * uppercasefirst(n[4:end]) : uppercasefirst(n)
+## helper: "Theta" ↦ "theta", "varTheta" ↦ "vartheta" …
+_decap(n) = startswith(n, "var") ? "var" * lowercasefirst(n[4:end]) : lowercasefirst(n)
+
+# ## Greek Alphabet
+const names_Greek = (
+    "Alpha", "Beta", "Gamma", "Delta", "Epsilon", 
+    "Zeta", "Eta", "Theta", "Iota", "Kappa",
+    "Lambda", "Mu", "Nu", "Xi", "Omicron",
+    "Pi", "Rho", "varTheta", "Sigma", "Tau", 
+    "Upsilon", "Phi", "Chi", "Psi", "Omega",
+)
+
+## starting indices for glyph ranges in unicode
+const usv_Greek = Dict(
+    :up => 0x391,
+    :it => 0x1D6E2,
+    :bfup => 0x1D6A8,
+    :bfit => 0x1D71C,
+    :bfsfup => 0x1D756,
+    :bfsfit => 0x1D790
+)
+
+## additional glyphs
+const extras_Greek = Dict(
+    :up => Dict(
+        "varTheta" => 0x3F4,
+        "Digamma" => 0x3DC,
+    ),
+    :bfup => Dict(
+        "varTheta" => 0x1D6B9,
+        "Digamma" => 0x1D7CA,
+    ),
+    :it => Dict(
+        "varTheta" => 0x1D6F3,
+    ),
+    :bfit => Dict(
+        "varTheta" => 0x1D72D,
+    ),
+    :bfsfit => Dict(
+        "varTheta" => 0x1D7A1,
+    ),
+    :bb => Dict(
+        "Gamma" => 0x213E,
+        "Pi" => 0x0213F,
+    )
+)
+
+# ## greek Alphabet
+
+## generate lowercase names
+const names_greek = begin 
+    ng = _decap.(names_Greek) |> collect
+
+    # rename according to LaTeX conventions:
+    for i in eachindex(ng)
+        if ng[i] == "phi" || ng[i] == "epsilon"
+            ng[i] = "var" * ng[i]
+        end
+    end
+    tuple(ng...)
+end
+
+const usv_greek = Dict(
+    :up => 0x3B1,
+    :it => 0x1D6FC,
+    :bfup => 0x1D6C2,
+    :bfit => 0x1D736,
+    :bfsfup => 0x1D770,
+    :bfsfit => 0x1D7AA,
+)
+
+const extras_greek = Dict(
+    :up => Dict(
+        "epsilon" => 0x3F5,
+        "vartheta" => 0x3D1,
+        "varkappa" => 0x3F0,
+        "phi" => 0x3D5,
+        "varrho" => 0x3F1,
+        "varpi" => 0x3D6,
+        "digamma" => 0x3DD,
+    ),
+    :it => Dict(
+        "epsilon" => 0x1D716,
+        "vartheta" => 0x1D717,
+        "varkappa" => 0x1D718,
+        "phi" =>      0x1D719,
+        "varrho" =>   0x1D71A,
+        "varpi" =>    0x1D71B,
+    ),
+    :bfit => Dict(
+        "epsilon" => 0x1D750,
+        "vartheta" => 0x1D751,
+        "varkappa" => 0x1D752,
+        "phi" => 0x1D753,
+        "varrho" => 0x1D754,
+        "varpi" => 0x1D755,
+    ),
+    :bfup => Dict(
+        "epsilon" => 0x1D6DC,
+        "vartheta" => 0x1D6DD,
+        "varkappa" => 0x1D6DE,
+        "phi" => 0x1D6DF,
+        "varrho" => 0x1D6E0,
+        "varpi" => 0x1D6E1,
+        "digamma" => 0x1D7CB,
+    ),
+    :bfsfup => Dict(
+        "epsilon" =>  0x1D78A,
+        "vartheta" => 0x1D78B,
+        "varkappa" => 0x1D78C,
+        "phi" =>      0x1D78D,
+        "varrho" =>   0x1D78E,
+        "varpi" =>    0x1D78F,
+    ),
+    :bfsfit => Dict(
+        "epsilon" =>  0x1D7C4,
+        "vartheta" => 0x1D7C5,
+        "varkappa" => 0x1D7C6,
+        "phi" =>      0x1D7C7,
+        "varrho" =>   0x1D7C8,
+        "varpi" =>    0x1D7C9,
+    ),
+    :bb => Dict(
+        "gamma" => 0x0213D,
+        "pi" => 0x0213C,
+    )
+)
+
+# ## Latin
+const names_Latin = (
+    "A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", "N", "O", "P", "Q", "R",
+    "S", "T", "U", "V", "W", "X", "Y", "Z"
+)
+
+const usv_Latin = Dict(
+    :up => 65,
+    :it => 0x1D434,
+    :bb => 0x1D538,
+    :cal => 0x1D49C,
+    :frak => 0x1D504,
+    :sfup => 0x1D5A0,
+    :sfit => 0x1D608,
+    :tt => 0x1D670,
+    :bfup => 0x1D400,
+    :bfit => 0x1D468,
+    :bffrak => 0x1D56C,
+    :bfcal => 0x1D4D0,
+    :bfsfup => 0x1D5D4,
+    :bfsfit => 0x1D63C,
+)
+
+extras_Latin = Dict(
+    :cal => Dict(
+        "B" => 0x212C,
+        "E" => 0x2130,
+        "F" => 0x2131,
+        "H" => 0x210B,
+        "I" => 0x2110,
+        "L" => 0x2112,
+        "M" => 0x2133,
+        "R" => 0x211B,
+    ),
+    :bb => Dict(
+        "C" =>          0x2102,
+        "H" =>          0x210D,
+        "N" =>          0x2115,
+        "P" =>          0x2119,
+        "Q" =>          0x211A,
+        "R" =>          0x211D,
+        "Z" =>          0x2124,
+    ),
+    :frak => Dict(
+        "C" => 0x212D,
+        "H" => 0x210C,
+        "I" => 0x2111,
+        "R" => 0x211C,
+        "Z" => 0x2128,
+    ),
+    :bbit => Dict(
+        "D" => 0x2145
+    )
+)
+
+# ## latin Alphabet
+const names_latin = _decap.(names_Latin)
+
+const extras_latin = Dict(
+    :cal => Dict(
+        "e" => 0x212F,
+        "g" => 0x210A,
+        "o" => 0x2134
+    ),
+    :it => Dict(
+        "h" => 0x0210E,
+    ),
+    :bbit => Dict(
+        "d" => 0x2146,
+        "e" => 0x2147,
+        "i" => 0x2148,
+        "j" => 0x2149,
+    )
+)
+const usv_latin = Dict(
+    :up => 97,
+    :it => 0x1D44E,
+    :bb => 0x1D552,
+    :cal => 0x1D4B6,
+    :frak => 0x1D51E,
+    :sfup => 0x1D5BA,
+    :sfit => 0x1D622,
+    :tt => 0x1D68A,
+    :bfup => 0x1D41A,
+    :bfit => 0x1D482,
+    :bffrak => 0x1D586,
+    :bfcal => 0x1D4EA,
+    :bfsfup => 0x1D5EE,
+    :bfsfit => 0x1D656
+)
+
+# ## Numbers
+const names_num = ("0", "1", "2", "3", "4", "5", "6", "7", "8", "9")
+const usv_num = Dict(
+    :up => 48,
+    :bb => 0x1D7D8,
+    :sfup => 0x1D7E2,
+    :tt => 0x1D7F6,
+    :bfup => 0x1D7CE,
+    :bfsfup => 0x1D7EC
+)
+
+# ## Singletons
+# ### partial
+const names_partial = ("partial",)
+const usv_partial = Dict(
+    :up => 0x02202,
+    :it => 0x1D715,
+    :bfup => 0x1D6DB,
+    :bfit => 0x1D74F,
+    :bfsfup => 0x1D789,
+    :bfsfit => 0x1D7C3,
+)
+# ### Nabla
+const names_Nabla = ("Nabla",)
+const usv_Nabla = Dict(
+    :up => 0x02207,
+    :it => 0x1D6FB,
+    :bfup => 0x1D6C1,
+    :bfit => 0x1D735,
+    :bfsfup => 0x1D76F,
+    :bfsfit => 0x1D7A9,
+)
+
+# ### dotless
+const names_dotless = ("dotlessi", "dotlessj")
+const usv_dotless = Dict(
+    :up => 0x00131,
+    :it => 0x1D6A4
+)
+const extras_dotless = Dict(
+    :up => Dict(
+        "dotlessj" => 0x00237,
+    ),
+    :it => Dict(
+        "dotlessi" => 0x1D6A4,
+    )
+)
+
+const ucmchars_dotless = Dict(
+    :up => Dict(
+        "dotlessi" => UCMChar(; name="dotlessi", glyph=Char(0x00131), alphabet=:dotless, style=:up),
+        "dotlessj" => UCMChar(; name="dotlessi", glyph=Char(0x00237), alphabet=:dotless, style=:up)
+    ),
+    :it => Dict(
+        "dotlessi" => UCMChar(; name="dotlessi", glyph=Char(0x1D6A4), alphabet=:dotless, style=:it),
+        "dotlessj" => UCMChar(; name="dotlessi", glyph=Char(0x1D6A5), alphabet=:dotless, style=:it),
+    )
+)
+
+"""
+    all_ucmchars()
+
+Internal helper function to generate/collect all nested dict of available `UCMChars`."""
+function all_ucmchars()
+    global ucmchars_dotless
+    ucmchars_Greek = collect_ucmchars(names_Greek, usv_Greek, extras_Greek; alphabet=:Greek)
+    ucmchars_greek = collect_ucmchars(names_greek, usv_greek, extras_greek; alphabet=:greek)
+
+    ucmchars_Latin = collect_ucmchars(names_Latin, usv_Latin, extras_Latin; alphabet=:Latin)
+    ucmchars_latin = collect_ucmchars(names_latin, usv_latin, extras_latin; alphabet=:latin)
+    ucmchars_num = collect_ucmchars(names_num, usv_num; alphabet=:num)
+
+    ucmchars_Nabla = collect_ucmchars(names_Nabla, usv_Nabla; alphabet=:Nabla)
+    ucmchars_partial = collect_ucmchars(names_partial, usv_partial; alphabet=:partial)
+
+    return Dict(
+        :Greek => ucmchars_Greek,
+        :greek => ucmchars_greek,
+        :Latin => ucmchars_Latin,
+        :latin => ucmchars_latin,
+        :num => ucmchars_num,
+        :Nabla => ucmchars_Nabla,
+        :partial => ucmchars_partial,
+        :dotless => ucmchars_dotless
+    )
+end
+
+"""
+    collect_ucmchars(
+        char_names, usv_dict, extras_dict=Dict(); 
+        alphabet, fixes=Dict())
+
+Given a vector of character names `char_names::AbstractVector{String}`, 
+and a dictionary mapping style symbols (`:up`, `:it`) to unicode points, 
+collect all the glyphs as `UCMChar` objects.
+The returned dict has structure `Dict(style_symb => Dict(name => ucm_char))`.
+
+* `fixes` is a global `Char`-to-`Char` dict, overwriting characters independent of style.
+* `extras_dict` can be used to overwrite characters or define additional symbols.
+"""
+function collect_ucmchars(
+    char_names,
+    usv_dict,
+    extras_dict=Dict();
+    alphabet=:UnknownAlphabet,
+    fixes=Dict{Char,Char}()
+)
+    ucm_dict = Dict{Symbol, Dict{String, UCMChar}}()
+
+    for (sn, cp) in pairs(usv_dict)
+        dict_sn = Dict(
+            n => let ch = Char(cp + i - 1);
+                UCMChar(;
+                    name=n, glyph=get(fixes, ch, ch), style=sn, alphabet)
+            end for (i, n) = enumerate(char_names) 
+        )
+        ucm_dict[sn] = dict_sn
+    end
+
+    for (sn, extras) in pairs(extras_dict)
+        if !haskey(ucm_dict, sn)
+            dict_sn = Dict{String, UCMChar}()
+            ucm_dict[sn] = dict_sn
+        else
+            dict_sn = ucm_dict[sn]
+        end
+        for (n, cp) in pairs(extras)
+            if haskey(dict_sn, n)
+                @unpack name, style = dict_sn[n]
+                dict_sn[n] = UCMChar(;
+                    glyph=Char(cp), alphabet=dict_sn[n].alphabet, name, style)
+            else
+                dict_sn[n] = UCMChar(;
+                    name=n, glyph=Char(cp), style=sn, alphabet)
+            end
+        end
+    end
+    return ucm_dict
+end
+
+function inverse_ucm_dict(ucm_dict)
+    d = Dict{Char, UCMChar}()
+    for (rn, chd) = pairs(ucm_dict)
+        for (sn, ucms) = pairs(chd)
+            for (n, uch) = pairs(ucms)
+                ch = uch.glyph
+                if haskey(d, ch)
+                    @warn """
+                    '$(ch)' already assigned:
+                    is : alphabet=$(d[ch].alphabet), style=$(d[ch].style),
+                    new: alphabet=$(uch.alphabet), style=$(uch.style)"""
+                else
+                    d[ch] = uch
+                end
+            end
+        end
+    end
+    return d
+end
\ No newline at end of file
diff --git a/src/latex.jl b/src/latex.jl
index bd672f4..2bc1099 100644
--- a/src/latex.jl
+++ b/src/latex.jl
@@ -18,9 +18,55 @@ function print_modifier(io, mod, substring)
     elseif mod == "mono"
         to_mono(io, substring) # leave unmodified for now
     else
-        error("Modifier $mod not supported")
+        _substring = try_sym_modifier(mod, substring) # we could also directly `io` and use `UCM.apply_style` instead of the `sym` commands in `try_sym_modifier`
+        if isnothing(_substring)
+            error("Modifier $mod not supported")
+        end
+        print(io, _substring)
     end
 end
+
+function try_sym_modifier(mod, substring)
+    _substring = if mod == "symbf"
+        symbf(substring)
+    elseif mod == "symsf"
+        symsf(substring)
+    elseif mod=="symup"
+        symup(substring)
+    elseif mod=="symit"
+        symit(substring)
+    elseif mod=="symtt"
+        symtt(substring)
+    elseif mod=="symbb"
+        symbb(substring)
+    elseif mod=="symcal"
+        symcal(substring)
+    elseif mod=="symbfsf"
+        symbfsf(substring)
+    elseif mod=="symbfup"
+        symbfup(substring)
+    elseif mod=="symbfit"
+        symbfit(substring)
+    elseif mod=="symsfup"
+        symsfup(substring)
+    elseif mod=="symsfit"
+        symsfit(substring)
+    elseif mod=="symbbit"
+        symbbit(substring)
+    elseif mod=="symfrak"
+        symfrak(substring)
+    elseif mod=="symbfcal"
+        symbfcal(substring)
+    elseif mod=="symbfsfup"
+        symbfsfup(substring)
+    elseif mod=="symbffrak"
+        symbffrak(substring)
+    else
+        nothing
+    end
+    return _substring
+end
+
 """
 Base findnext doesn't handle utf8 strings correctly
 """
@@ -35,7 +81,7 @@ function utf8_findnext(A::AbstractString, v::Char, idx::Integer)
     0
 end
 
-function to_latex(text)
+function to_latex(text; normalize=false)
     io = IOBuffer()
     charidx = iterate(text)
     charidx === nothing && return ""
@@ -56,6 +102,12 @@ function to_latex(text)
                         break
                     end
                 end
+                for mod_candidate in ucm_modifiers
+                    if startswith(ss, mod_candidate)
+                        mod = mod_candidate
+                        break
+                    end
+                end
                 if mod == "\\" # no match was found
                     # is this a latex symbol?
                     for (k, v) in latex_symbol_map
@@ -86,7 +138,11 @@ function to_latex(text)
                 print_modifier(io, mod, char)
             end
         else
-            print(io, char)
+            if normalize
+                print(io, UCM._sym(char))
+            else
+                print(io, char)
+            end
         end
     end
     return String(take!(io))
diff --git a/test/UnicodeMath.jl b/test/UnicodeMath.jl
new file mode 100644
index 0000000..a8dba85
--- /dev/null
+++ b/test/UnicodeMath.jl
@@ -0,0 +1,385 @@
+import UnicodeFun: UCM
+import UnPack: @unpack
+
+function test_parse_cfg(cfg::UCM.UCMConfig)
+    @unpack math_style_spec, normal_style_spec, bold_style_spec, sans_style, partial, nabla = cfg
+    return UCM.parse_config(;
+        math_style_spec, normal_style_spec, bold_style_spec, sans_style, partial, nabla
+    )
+end
+
+@testset "UnicodeMath Defaults" begin
+    @test UCM.UCMConfig() == UCM.UCMConfig(; 
+        math_style_spec=:tex, 
+        normal_style_spec=nothing,
+        bold_style_spec=nothing,
+        sans_style=nothing,
+        partial=nothing,
+        nabla=nothing,
+    )
+
+    for normal_style_spec in (nothing, :tex, :iso, :french, :upright, :literal)
+    for bold_style_spec in (nothing, :tex, :iso, :upright, :literal)
+    for sans_style in (nothing, :upright, :italic, :literal)
+    for partial in (nothing, :upright, :italic, :literal)
+    for nabla in (nothing, :upright, :italic, :literal)
+        overrides = (;normal_style_spec, bold_style_spec, sans_style, partial, nabla)
+        cfg_tex = UCM.UCMConfig(; math_style_spec=:tex, overrides...)
+        cfg_iso = UCM.UCMConfig(; math_style_spec=:iso, overrides...)
+        cfg_french = UCM.UCMConfig(; math_style_spec=:french, overrides...)
+        cfg_upright = UCM.UCMConfig(; math_style_spec=:upright, overrides...)
+        cfg_literal = UCM.UCMConfig(; math_style_spec=:literal, overrides...)
+
+        ntup_tex = test_parse_cfg(cfg_tex)
+        ntup_iso = test_parse_cfg(cfg_iso)
+        ntup_french = test_parse_cfg(cfg_french)
+        ntup_upright = test_parse_cfg(cfg_upright)
+        ntup_literal = test_parse_cfg(cfg_literal)
+
+        ns = if isnothing(normal_style_spec)
+            identity
+        else
+            symb -> normal_style_spec
+        end
+        bs = if isnothing(bold_style_spec)
+            identity
+        else
+            symb -> bold_style_spec
+        end
+        ss = if isnothing(sans_style)
+            identity
+        else
+            symb -> sans_style
+        end
+        p = if isnothing(partial)
+            identity
+        else
+            symb -> partial
+        end
+        n = if isnothing(nabla)
+            identity
+        else
+            symb -> nabla
+        end
+        @test ntup_tex == (;
+            nabla = n(:upright),
+            partial = p(:italic),
+            normal_style_spec = ns(:tex),
+            bold_style_spec = bs(:tex),
+            sans_style = ss(:upright)
+        )
+
+        @test ntup_iso == (;
+            nabla = n(:upright),
+            partial = p(:italic),
+            normal_style_spec = ns(:iso),
+            bold_style_spec = bs(:iso),
+            sans_style = ss(:italic)
+        )
+
+        @test ntup_french == (;
+            nabla = n(:upright),
+            partial = p(:upright),
+            normal_style_spec = ns(:french),
+            bold_style_spec = bs(:upright),
+            sans_style = ss(:upright)
+        )
+
+        @test ntup_upright == (;
+            nabla = n(:upright),
+            partial = p(:upright),
+            normal_style_spec = ns(:upright),
+            bold_style_spec = bs(:upright),
+            sans_style = ss(:upright)
+        )
+
+        @test ntup_literal == (;
+            nabla = n(:literal),
+            partial = p(:literal),
+            normal_style_spec = ns(:literal),
+            bold_style_spec = bs(:literal),
+            sans_style = ss(:literal)
+        )
+    end
+    end
+    end
+    end
+    end
+
+    @test UCM.parse_normal_style_spec(:iso) == (;
+        Greek = :italic,
+        greek = :italic,
+        Latin = :italic,
+        latin = :italic
+    )
+    @test UCM.parse_normal_style_spec(:tex) == (;
+        Greek = :upright,
+        greek = :italic,
+        Latin = :italic,
+        latin = :italic
+    )
+    @test UCM.parse_normal_style_spec(:french) == (;
+        Greek = :upright,
+        greek = :upright,
+        Latin = :upright,
+        latin = :italic
+    )
+    @test UCM.parse_normal_style_spec(:upright) == (;
+        Greek = :upright,
+        greek = :upright,
+        Latin = :upright,
+        latin = :upright,
+    )
+    @test UCM.parse_normal_style_spec(:literal) == (;
+        Greek = :literal,
+        greek = :literal,
+        Latin = :literal,
+        latin = :literal,
+    )
+
+    @test UCM.parse_bold_style_spec(:iso) == (;
+        Greek = :italic,
+        greek = :italic,
+        Latin = :italic,
+        latin = :italic
+    )
+    @test UCM.parse_bold_style_spec(:tex) == (;
+        Greek = :upright,
+        greek = :italic,
+        Latin = :upright,
+        latin = :upright
+    )
+    @test UCM.parse_bold_style_spec(:upright) == (;
+        Greek = :upright,
+        greek = :upright,
+        Latin = :upright,
+        latin = :upright,
+    )
+    @test UCM.parse_bold_style_spec(:literal) == (;
+        Greek = :literal,
+        greek = :literal,
+        Latin = :literal,
+        latin = :literal,
+    )
+end
+
+const test_strings = Dict(
+    :num_up => "1",
+    :latin_up => "az",
+    :Latin_up => "BX",
+    :latin_it => "𝑎𝑧",
+    :Latin_it => "𝐵𝑋",
+    :Latin_bfit => "𝑨𝒁",
+    :latin_bfit => "𝒂𝒛",
+    :Latin_bfup => "𝐀𝐙",
+    :latin_bfup => "𝐚𝐳",
+    :greek_up => "αβ",
+    :Greek_up => "ΓΞ",
+    :greek_it => "𝛼𝛽",
+    :Greek_it => "𝛤𝛯",
+    :greek_bfit => "𝜶𝜷",
+    :Greek_bfit => "𝜞𝜩",
+    :greek_bfup => "𝛂𝛃",
+    :Greek_bfup => "𝚪𝚵",
+    :Nabla_up => "∇",
+    :Nabla_it => "𝛻",
+    :Nabla_bfup => "𝛁",
+    :Nabla_bfit => "𝜵",
+    :partial_up => "∂",
+    :partial_it => "𝜕",
+    :partial_bfup => "𝛛",
+    :partial_bfit => "𝝏",
+)
+
+@testset "UnicodeMath String Styling with `math_style_spec`" begin
+    
+    results_tex = Dict(
+        :num_up => :num_up,
+        :latin_up => :latin_it,
+        :Latin_up => :Latin_it,
+        :latin_it => :latin_it,
+        :Latin_it => :Latin_it,
+        :Latin_bfit => :Latin_bfup,
+        :Latin_bfup => :Latin_bfup,
+        :latin_bfit => :latin_bfup,
+        :latin_bfup => :latin_bfup,
+        :greek_up => :greek_it,
+        :Greek_up => :Greek_up,
+        :greek_it => :greek_it,
+        :Greek_it => :Greek_up,
+        :greek_bfit => :greek_bfit,
+        :Greek_bfit => :Greek_bfup,
+        :greek_bfup => :greek_bfit,
+        :Greek_bfup => :Greek_bfup,
+        :Nabla_up => :Nabla_up,
+        :Nabla_it => :Nabla_up,
+        :Nabla_bfup => :Nabla_bfup,
+        :Nabla_bfit => :Nabla_bfup,
+        :partial_up => :partial_it,
+        :partial_it => :partial_it,
+        :partial_bfup => :partial_bfit,
+        :partial_bfit => :partial_bfit,
+    )
+
+    results_iso = Dict(
+        :num_up => :num_up,
+        :latin_up => :latin_it,
+        :Latin_up => :Latin_it,
+        :latin_it => :latin_it,
+        :Latin_it => :Latin_it,
+        :Latin_bfit => :Latin_bfit,
+        :Latin_bfup => :Latin_bfit,
+        :latin_bfit => :latin_bfit,
+        :latin_bfup => :latin_bfit,
+        :greek_up => :greek_it,
+        :Greek_up => :Greek_it,
+        :greek_it => :greek_it,
+        :Greek_it => :Greek_it,
+        :greek_bfit => :greek_bfit,
+        :Greek_bfit => :Greek_bfit,
+        :greek_bfup => :greek_bfit,
+        :Greek_bfup => :Greek_bfit,
+        :Nabla_up => :Nabla_up,
+        :Nabla_it => :Nabla_up,
+        :Nabla_bfup => :Nabla_bfup,
+        :Nabla_bfit => :Nabla_bfup,
+        :partial_up => :partial_it,
+        :partial_it => :partial_it,
+        :partial_bfup => :partial_bfit,
+        :partial_bfit => :partial_bfit,
+    )
+
+    results_upright = Dict(
+        :num_up => :num_up,
+        :latin_up => :latin_up,
+        :Latin_up => :Latin_up,
+        :latin_it => :latin_up,
+        :Latin_it => :Latin_up,
+        :Latin_bfit => :Latin_bfup,
+        :Latin_bfup => :Latin_bfup,
+        :latin_bfit => :latin_bfup,
+        :latin_bfup => :latin_bfup,
+        :greek_up => :greek_up,
+        :Greek_up => :Greek_up,
+        :greek_it => :greek_up,
+        :Greek_it => :Greek_up,
+        :greek_bfit => :greek_bfup,
+        :Greek_bfit => :Greek_bfup,
+        :greek_bfup => :greek_bfup,
+        :Greek_bfup => :Greek_bfup,
+        :Nabla_up => :Nabla_up,
+        :Nabla_it => :Nabla_up,
+        :Nabla_bfup => :Nabla_bfup,
+        :Nabla_bfit => :Nabla_bfup,
+        :partial_up => :partial_up,
+        :partial_it => :partial_up,
+        :partial_bfup => :partial_bfup,
+        :partial_bfit => :partial_bfup,
+    )
+
+    results_french = Dict(
+        :num_up => :num_up,
+        :latin_up => :latin_it,
+        :Latin_up => :Latin_up,
+        :latin_it => :latin_it,
+        :Latin_it => :Latin_up,
+        :Latin_bfit => :Latin_bfit,
+        :Latin_bfup => :Latin_bfup,
+        :latin_bfit => :latin_bfit,
+        :latin_bfup => :latin_bfup,
+        :greek_up => :greek_up,
+        :Greek_up => :Greek_up,
+        :greek_it => :greek_up,
+        :Greek_it => :Greek_up,
+        :greek_bfit => :greek_bfup,
+        :Greek_bfit => :Greek_bfup,
+        :greek_bfup => :greek_bfup,
+        :Greek_bfup => :Greek_bfup,
+        :Nabla_up => :Nabla_up,
+        :Nabla_it => :Nabla_up,
+        :Nabla_bfup => :Nabla_bfup,
+        :Nabla_bfit => :Nabla_bfup,
+        :partial_up => :partial_up,
+        :partial_it => :partial_up,
+        :partial_bfup => :partial_bfup,
+        :partial_bfit => :partial_bfup,
+    )
+
+    results_literal = Dict(k => k for k = keys(test_strings))
+    cfg_tex = UCM.UCMConfig(; math_style_spec=:tex)
+    cfg_iso = UCM.UCMConfig(; math_style_spec=:iso)
+    cfg_upright = UCM.UCMConfig(; math_style_spec=:iso)
+    cfg_french = UCM.UCMConfig(; math_style_spec=:french)
+    cfg_literal = UCM.UCMConfig(; math_style_spec=:literal)
+    for (cfg, res) = (
+        (cfg_iso, results_iso), 
+        (cfg_tex, results_tex), 
+        (cfg_upright, results_upright),
+        (cfg_french, results_french),
+        (cfg_literal, results_literal)
+    )
+        for (k, _str) = pairs(test_strings)
+            _styled = test_strings[results_iso[k]]
+            @test UCM.apply_style(_str, cfg_iso) == _styled
+        end
+    end
+
+end
+
+@testset "UnicodeMath granular overrides" begin
+    normal_style_spec = (;
+        Greek = :literal,
+        greek = :upright,
+        Latin = :upright,
+        latin = :italic
+    )
+    str_in = test_strings[:Greek_it] * 
+        test_strings[:Greek_up] * 
+        test_strings[:greek_it] * 
+        test_strings[:greek_up] *
+        test_strings[:Latin_it] *
+        test_strings[:Latin_up] *
+        test_strings[:latin_it] *
+        test_strings[:latin_up]
+
+    str_out = test_strings[:Greek_it] *
+        test_strings[:Greek_up] * 
+        test_strings[:greek_up] * 
+        test_strings[:greek_up] * 
+        test_strings[:Latin_up] * 
+        test_strings[:Latin_up] * 
+        test_strings[:latin_it] * 
+        test_strings[:latin_it] 
+    
+    cfg = UCM.UCMConfig(; normal_style_spec)
+
+    @test UCM.apply_style(str_in, cfg) == str_out
+
+    bold_style_spec = (;
+        Greek = :literal,
+        greek = :upright,
+        Latin = :upright,
+        latin = :italic
+    )
+    str_in = test_strings[:Greek_bfit] * 
+        test_strings[:Greek_bfup] * 
+        test_strings[:greek_bfit] * 
+        test_strings[:greek_bfup] *
+        test_strings[:Latin_bfit] *
+        test_strings[:Latin_bfup] *
+        test_strings[:latin_bfit] *
+        test_strings[:latin_bfup]
+
+    str_out = test_strings[:Greek_bfit] *
+        test_strings[:Greek_bfup] * 
+        test_strings[:greek_bfup] * 
+        test_strings[:greek_bfup] * 
+        test_strings[:Latin_bfup] * 
+        test_strings[:Latin_bfup] * 
+        test_strings[:latin_bfit] * 
+        test_strings[:latin_bfit] 
+    
+    cfg = UCM.UCMConfig(; bold_style_spec)
+
+    @test UCM.apply_style(str_in, cfg) == str_out
+end
\ No newline at end of file
diff --git a/test/runtests.jl b/test/runtests.jl
index dd24946..04444c2 100644
--- a/test/runtests.jl
+++ b/test/runtests.jl
@@ -28,3 +28,15 @@ latexstring = "\\bf{boldface} \\it{italic} \\bb{blackboard} \\cal{calligraphic}
 @test to_root(17,"542") == "¹⁷√5̅4̅2̅"
 @test to_root(1, "1") == "1"
 @test to_root(1, "-1") == "-1"
+
+include("UnicodeMath.jl")
+## UCM.extra_commands:
+@test to_latex("\\mathexclam") == "!"
+## Normalization (same as calling `UCM._sym`)
+glyphstring = "BX 𝐵𝑋 ∇ 𝛁 𝜕 𝝏 𝜶𝜷 αβ 𝚪𝚵 𝜵 az 𝑎𝑧 𝛤𝛯 𝛻 ∂ 𝛛 ΓΞ 𝛼𝛽 1 𝜞𝜩 𝛂𝛃"
+@test to_latex(glyphstring) == glyphstring
+@test to_latex(glyphstring; normalize=true) == "𝐵𝑋 𝐵𝑋 ∇ 𝛁 𝜕 𝝏 𝜶𝜷 𝛼𝛽 𝚪𝚵 𝛁 𝑎𝑧 𝑎𝑧 ΓΞ ∇ 𝜕 𝝏 ΓΞ 𝛼𝛽 1 𝚪𝚵 𝜶𝜷"
+UnicodeFun.global_config!(; math_style_spec=:iso)
+@test to_latex(glyphstring; normalize=true) == "𝐵𝑋 𝐵𝑋 ∇ 𝛁 𝜕 𝝏 𝜶𝜷 𝛼𝛽 𝜞𝜩 𝛁 𝑎𝑧 𝑎𝑧 𝛤𝛯 ∇ 𝜕 𝝏 𝛤𝛯 𝛼𝛽 1 𝜞𝜩 𝜶𝜷"
+## Additional styling modifiers:
+@test to_latex("\\symit{a}") == "𝑎"
\ No newline at end of file