diff --git a/assets/fonts/TeXGyrePagellaMTE/TexGyrePagellaMTE-Bold.otf b/assets/fonts/TeXGyrePagellaMTE/TeXGyrePagellaMTE-Bold.otf similarity index 100% rename from assets/fonts/TeXGyrePagellaMTE/TexGyrePagellaMTE-Bold.otf rename to assets/fonts/TeXGyrePagellaMTE/TeXGyrePagellaMTE-Bold.otf diff --git a/assets/fonts/TeXGyrePagellaMTE/TexGyrePagellaMTE-BoldItalic.otf b/assets/fonts/TeXGyrePagellaMTE/TeXGyrePagellaMTE-BoldItalic.otf similarity index 100% rename from assets/fonts/TeXGyrePagellaMTE/TexGyrePagellaMTE-BoldItalic.otf rename to assets/fonts/TeXGyrePagellaMTE/TeXGyrePagellaMTE-BoldItalic.otf diff --git a/assets/fonts/TeXGyrePagellaMTE/TexGyrePagellaMTE-Italic.otf b/assets/fonts/TeXGyrePagellaMTE/TeXGyrePagellaMTE-Italic.otf similarity index 100% rename from assets/fonts/TeXGyrePagellaMTE/TexGyrePagellaMTE-Italic.otf rename to assets/fonts/TeXGyrePagellaMTE/TeXGyrePagellaMTE-Italic.otf diff --git a/assets/fonts/TeXGyrePagellaMTE/TexGyrePagellaMTE-Math.otf b/assets/fonts/TeXGyrePagellaMTE/TeXGyrePagellaMTE-Math.otf similarity index 100% rename from assets/fonts/TeXGyrePagellaMTE/TexGyrePagellaMTE-Math.otf rename to assets/fonts/TeXGyrePagellaMTE/TeXGyrePagellaMTE-Math.otf diff --git a/assets/fonts/TeXGyrePagellaMTE/TexGyrePagellaMTE-Regular.otf b/assets/fonts/TeXGyrePagellaMTE/TeXGyrePagellaMTE-Regular.otf similarity index 100% rename from assets/fonts/TeXGyrePagellaMTE/TexGyrePagellaMTE-Regular.otf rename to assets/fonts/TeXGyrePagellaMTE/TeXGyrePagellaMTE-Regular.otf diff --git a/src/MathTeXEngine.jl b/src/MathTeXEngine.jl index ffb03f3..20b63e5 100644 --- a/src/MathTeXEngine.jl +++ b/src/MathTeXEngine.jl @@ -41,4 +41,163 @@ include("engine/layout_context.jl") include("engine/texelements.jl") include("engine/layout.jl") +include("UnicodeMath/UnicodeMath.jl") +import .UnicodeMath as UCM + +# ## UnicodeMath +const _unicode_math_sym_commands_ref = Ref(true) +const _unicode_math_substitutions_ref = Ref(true) + +# ### Fonts +# Define a mapping to use math font for most of the typesetting: +const _ucm_font_mapping = Dict( + :text => :regular, + :delimiter => :math, + :digit => :math, + :function => :regular, + :punctuation => :math, + :symbol => :math, + :char => :math +) + +""" + unicode_math_fonts!(font_family) + +Convenience function to configure math font to be used for anything but text and functions.""" +function unicode_math_fonts!(ffm=nothing;) + global _ucm_font_mapping + _ffm = isnothing(ffm) ? get_texfont_family() : ffm + for (k, v) in pairs(_ucm_font_mapping) + _ffm.font_mapping[k] = v + end + if !isnothing(ffm) + set_texfont_family!(_ffm) + end + return _ffm +end + +""" + unicode_math_config!(; + enable_sym_commands=true, + enable_substitutions=true, + math_style=:tex, + normal_style=nothing, + bold_style=nothing, + sans_style=nothing, + partial=nothing, + nabla=nothing + ) +Convenience function to globally configure the substitutions unicode character +substitutions performed by `UnicodeMath`. +Substitutions +`math_style` sets defaults which can be overriden individually using the other +keyword argument.""" +function unicode_math_config!(; + enable_sym_commands=true, + enable_substitutions=true, + math_style=:tex, + normal_style=nothing, + bold_style=nothing, + sans_style=nothing, + partial=nothing, + nabla=nothing +) + global _unicode_math_substitutions_ref, _unicode_math_sym_commands_ref + _unicode_math_sym_commands_ref[] = enable_sym_commands + _unicode_math_substitutions_ref[] = enable_substitutions + UCM.global_config!(; math_style, normal_style, bold_style, sans_style, partial, nabla) + return nothing +end + +# ### Command Registration +# #### Style Commands + +# command_definitions["\\_"] = (TeXExpr(:punctuation, '_'), 0) + +for style_symb in UCM.all_styles + com_str = "\\sym$(style_symb)" + command_definitions[com_str] = (TeXExpr(:sym, style_symb), 1) +end + +for (cmd_symb, ucm_char) in pairs(UCM.extra_commands) + symbol = ucm_char.char + symbol_expr = TeXExpr(:symbol, symbol) + + if !haskey(symbol_to_canonical, symbol) + symbol_to_canonical[symbol] = symbol_expr + end + + com_str = "\\$(cmd_symb)" + # Separate case for symbols that have multiple valid commands + if !haskey(command_definitions, com_str) + command_definitions[com_str] = (symbol_expr, 0) + end +end + +### Parser -- TeXExpr +function TeXExpr(head::Symbol, args::Vector) + global _unicode_math_sym_commands_ref + + ## like with `\mathbf` etc. recursively apply `\symbf` etc. at parse time: + if _unicode_math_sym_commands_ref[] && ( + head == :sym && + length(args) == 2 && + args[1] in UCM.all_styles + ) + style_symb, content = args + return leafmap(content) do leaf + sym = only(leaf.args) + return TeXExpr(:ucm_symbol, UCM.sym_style(sym, style_symb)) + end + end + + #= + ## we can also stylize other characters at parse-time; + ## feels a bit hacky as `_ucm_stylize` takes into account the font-family to determine + ## which symbols to investigate; + ## alternatively, change `TeXChar` in the layouting phase; + ## this would require marking symbols stylized by `\symXX` commands so that they are + ## not changed anymore... + if length(args) == 1 + arg = only(args) + if arg isa Char + arg = _ucm_stylize(head, arg) + args = [arg,] + end + end + + Disabled because we want to distinguish normal characters (not wrapped by `\symXXX`) + depending on state, and only stylize with `:inline_math`. + To not change symbols already stylized, we use `:ucm_symbol` above. + This is a new (internal) leaf type that is respected in `TeXChar`. + =# + + ## redirect to original method: + return Base.invoke(TeXExpr, Tuple{Any, Vector}, head, args) +end + +#= +function TeXExpr(head::Symbol, arg::Char) + #= + ## stylize unicode characters at parse-time: + arg = _ucm_stylize(head, arg) + =# + return Base.invoke(TeXExpr, Tuple{Any, Any}, head, arg) +end +=# + +function _ucm_stylize(head, char, _ffm = nothing) + global _unicode_math_substitutions_ref + + !(_unicode_math_substitutions_ref[]) && return char + + if head in (:char, :delimiter, :digit, :punctuation, :symbol) + ffm = isnothing(_ffm) ? get_texfont_family() : _ffm + if get(ffm.font_mapping, head, :notmath) == :math + char = UCM.sym_style(char) + end + end + return char +end + end # module diff --git a/src/UnicodeMath/UnicodeMath.jl b/src/UnicodeMath/UnicodeMath.jl new file mode 100644 index 0000000..a6cd0ed --- /dev/null +++ b/src/UnicodeMath/UnicodeMath.jl @@ -0,0 +1,484 @@ +module UnicodeMath +#import DataStructures: OrderedDict +#const SpecialDict = OrderedDict +const SpecialDict = Dict + +include("extra_commands.jl") # `extra_commands` + +include("character_ranges.jl") # `chars_by_range_style_name` + # `chars_to_ucmchars` + +## native 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 +) + +const all_styles = (base_styles..., :bf, :sf, :bfsf) + +## 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) + ## check if the range is key for outer dict: + chars_by_style_name = get(chars_by_range_style_name, ucm_ch.char_range, nothing) + isnothing(chars_by_style_name) && return ucm_ch + + ## check if target style is key in 2nd level: + chars_by_name = get(chars_by_style_name, style_symb, nothing) + isnothing(chars_by_name) && return ucm_ch + + ## inner dict has `name => UCMChar` entries for target style. + ## return value if it exists + ucm_ch = get(chars_by_name, ucm_ch.name, ucm_ch) + return ucm_ch +end + +function _normal_style_mapping(normal_style=:italic) + @assert normal_style in (:italic, :upright, :literal) + return Dict( + :up => normal_style == :italic ? :it : (normal_style == :upright ? :up : :up), + :it => normal_style == :italic ? :it : (normal_style == :upright ? :up : :it) + ) +end + +const 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 +) + +function config_dicts(; + math_style=:tex, + normal_style=nothing, + bold_style=nothing, + sans_style=nothing, + partial=nothing, + nabla=nothing +) + cfg = if math_style == :iso + (; + nabla = :upright, + partial = :italic, + normal_style = :iso, + bold_style = :iso, + sans_style = :italic + ) + elseif math_style == :tex + (; + nabla = :upright, + partial = :italic, + normal_style = :tex, + bold_style = :tex, + sans_style = :upright + ) + elseif math_style == :french + (; + nabla = :upright, + partial = :upright, + normal_style = :french, + bold_style = :french, + sans_style = :upright + ) + elseif math_style == :upright + (; + nabla = :upright, + partial = :upright, + normal_style = :upright, + bold_style = :upright, + sans_style = :upright + ) + else + (; + nabla = :literal, + partial = :literal, + normal_style = :literal, + bold_style = :literal, + sans_style = :literal + ) + end + normal_style = isnothing(normal_style) ? cfg.normal_style : normal_style + bold_style = isnothing(bold_style) ? cfg.bold_style : bold_style + sans_style = isnothing(sans_style) ? cfg.sans_style : sans_style + partial = isnothing(partial) ? cfg.partial : partial + nabla = isnothing(nabla) ? cfg.nabla : nabla + + normal_styles = preconfigured_normal_styles(normal_style; partial, nabla) + substitutions = preconfigured_substitutions(bold_style; sans_style, partial, nabla) + + aliases = Dict( + :num => aliases_num + ) + + return normal_styles, substitutions, aliases +end + +function preconfigured_normal_styles( + normal_style_flavor; + partial = :literal, nabla = :literal +) + nt = if normal_style_flavor == :iso + (; + Greek = :italic, + greek = :italic, + Latin = :italic, + latin = :italic + ) + elseif normal_style_flavor == :tex + (; + Greek = :upright, + greek = :italic, + Latin = :italic, + latin = :italic + ) + elseif normal_style_flavor == :french + (; + Greek = :upright, + greek = :upright, + Latin = :upright, + latin = :italic + ) + elseif normal_style_flavor == :upright + (; + Greek = :upright, + greek = :upright, + Latin = :upright, + latin = :upright, + ) + else + (; + Greek = :literal, + greek = :literal, + Latin = :literal, + latin = :literal, + ) + end + + ns = Dict( + :num => _normal_style_mapping(:upright), + :Greek => _normal_style_mapping(nt.Greek), + :greek => _normal_style_mapping(nt.greek), + :Latin => _normal_style_mapping(nt.Latin), + :latin => _normal_style_mapping(nt.latin), + :partial => _normal_style_mapping(partial), + :Nabla => _normal_style_mapping(nabla) + ) + ns[:dotless] = ns[:latin] + + return ns +end + +function preconfigured_substitutions( + bold_style_flavor; + sans_style = :literal, + partial = :literal, nabla = :literal +) + nt = if bold_style_flavor == :iso + (; + Greek = :italic, + greek = :italic, + Latin = :italic, + latin = :italic + ) + elseif bold_style_flavor == :tex + (; + Greek = :upright, + greek = :italic, + Latin = :upright, + latin = :upright + ) + elseif bold_style_flavor == :upright + (; + Greek = :upright, + greek = :upright, + Latin = :upright, + latin = :upright, + ) + else + (; + Greek = :literal, + greek = :literal, + Latin = :literal, + latin = :literal, + ) + end + + bs = Dict( + :num => _subtitutions_dict(; bold_style=:upright, sans_style=:upright), + :Greek => _subtitutions_dict(; bold_style=nt.Greek, sans_style), + :greek => _subtitutions_dict(; bold_style=nt.greek, sans_style), + :Latin => _subtitutions_dict(; bold_style=nt.Latin, sans_style), + :latin => _subtitutions_dict(; bold_style=nt.latin, sans_style), + :partial => _subtitutions_dict(; bold_style=partial, sans_style=partial), + :Nabla => _subtitutions_dict(; bold_style=nabla, sans_style=nabla), + ) + bs[:dotless] = bs[:latin] + + return bs +end + +function _subtitutions_dict(; + bold_style=:literal, + sans_style=:italic, +) + subs_up = Dict( sn => sn for sn = base_styles ) + subs_up[:bf] = bold_style == :upright ? :bfup : (bold_style == :italic ? :bfit : :bfup) + 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 = Dict( sn => sn for sn = base_styles ) + #subs_it[:bb] = :bbit # `blackboard_style`? + 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_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[:bfsf] = subs_bfup[:sf] = sans_style == :upright ? :bfsfup : (sans_style == :italic ? :bfsfit : :bfsfup) + + 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[:bfsf] = subs_bfit[:sf] = sans_style == :upright ? :bfsfup : (sans_style == :italic ? :bfsfit : :bfsfit) + + 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[:bfsf] = subs_sfup[:bf] = sans_style == :upright ? :bfsfup : (sans_style == :italic ? :bfsfit : :bfsfup) + + 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[:bfsf] = subs_sfit[:bf] = sans_style == :upright ? :bfsfup : (sans_style == :italic ? :bfsfit : :bfsfit) + + 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_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_bfsfit = Dict( + ## no-ops: + :it => :bfsfit, + :bf => :bfsfit, + :sf => :bfsfit, + :bfit => :bfsfit, + :sfit => :bfsfit, + :bfsfit => :bfsfit, + ## other: + :up => :bfsfup, + :sfup => :bfsfup, + :bfsfup => :bfsfup + ) + 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 + +const (default_normal_styles, default_substitutions, default_aliases) = config_dicts() + +const default_normal_styles_ref = Ref(default_normal_styles) +const default_substitutions_ref = Ref(default_substitutions) +const default_aliases_ref = Ref(default_aliases) + +function global_config!(; kwargs...) + global default_normal_styles_ref, default_substitutions_ref, default_aliases_ref + ns, s, a = config_dicts(; kwargs...) + default_normal_styles_ref[] = ns + default_substitutions_ref[] = s + default_aliases_ref[] = a + return (; normal_styles=ns, substitutions=s, aliases=a) +end + +for fn in (:apply_style, :apply_spec_style) + @eval function $(fn)(ch::Char, trgt_style::Symbol... ; kwargs...) + ucm_ch = get(chars_to_ucmchars, ch, nothing) + isnothing(ucm_ch) && return ch + ucm_ch = $(fn)(ucm_ch, trgt_style...; kwargs...) + return ucm_ch.char + end +end + +function sym_style(ch::Union{Char, UCMChar}, trgt_style...) + global default_normal_styles_ref, default_substitutions_ref, default_aliases_ref + + return apply_style(ch, trgt_style...; + normal_styles = default_normal_styles_ref[], + substitutions = default_substitutions_ref[], + aliases = default_aliases_ref[] + ) +end +sym_style(io::IO, ch::Union{Char, UCMChar}, trgt_style...)=print(io, sym_style(ch, trgt_style...)) +function sym_style(io::IO, x::AbstractString, trgt_style...) + _sym_style = ch -> apply_style( + ch, trgt_style...; + normal_styles = default_normal_styles_ref[], + substitutions = default_substitutions_ref[], + aliases = default_aliases_ref[] + ) + for char in x + print(io, _sym_style(char)) + end +end +sym_style(x::AbstractString, trgt_style...) = sprint() do io + sym_style(io, x, trgt_style...) +end + +for sn in all_styles + f = Symbol("sym", sn) + @eval begin + $f(ch::Char) = sym_style(ch, $(Meta.quot(sn))) + $f(x::AbstractString) = sym_style(x, $(Meta.quot(sn))) + + $f(io::IO, x::Char) = sym_style(io, x, $(Meta.quot(sn))) + $f(io::IO, x::AbstractString) = sym_style(io, x, $(Meta.quot(sn))) + end +end + +function apply_style( + ucm_ch::UCMChar; + normal_styles = default_normal_styles, + kwargs... +) + if isa(normal_styles, AbstractDict) + if haskey(normal_styles, ucm_ch.char_range) + trgt_normal_style = get(normal_styles[ucm_ch.char_range], ucm_ch.style, nothing) + if !isnothing(trgt_normal_style) + ucm_ch = _choose_style(ucm_ch, trgt_normal_style) + end + end + end + return ucm_ch +end + +function apply_style( + ucm_ch::UCMChar, trgt_style::Symbol; + substitutions = default_substitutions, + aliases = default_aliases, + kwargs... +) + ucm_ch = apply_style(ucm_ch; kwargs...) + if isa(substitutions, AbstractDict) && haskey(substitutions, ucm_ch.char_range) + substitutions_range = substitutions[ucm_ch.char_range] + if haskey(substitutions_range, ucm_ch.style) + trgt_style = get(substitutions_range[ucm_ch.style], trgt_style, trgt_style) + end + end + if isa(aliases, AbstractDict) && haskey(aliases, ucm_ch.char_range) + trgt_style = get(aliases[ucm_ch.char_range], trgt_style, trgt_style) + end + return _choose_style(ucm_ch, trgt_style) +end + +function apply_spec_style( + ucm_ch::UCMChar, trgt_style::Symbol...; + math_style=:tex, + normal_style=nothing, + bold_style=nothing, + sans_style=nothing, + partial=nothing, + nabla=nothing +) + normal_styles, substitutions, aliases = config_dicts(; + math_style, normal_style, bold_style, sans_style, partial, nabla) + return apply_style(ucm_ch, trgt_style...; normal_styles, substitutions, aliases) +end + +end#module \ No newline at end of file diff --git a/src/UnicodeMath/character_ranges.jl b/src/UnicodeMath/character_ranges.jl new file mode 100644 index 0000000..13a3b12 --- /dev/null +++ b/src/UnicodeMath/character_ranges.jl @@ -0,0 +1,432 @@ +# This file takes inspiration from source file `um-code-usv.dtx` +# of the UNICODE-MATH package +# +# Find below the original license statement: + +# /© +# +# ------------------------------------------------ +# The UNICODE-MATH package +# ------------------------------------------------ +# This package is free software and may be redistributed and/or modified under +# the conditions of the LaTeX Project Public License, version 1.3c or higher +# (your choice): . +# ------------------------------------------------ +# Copyright 2006-2019 Will Robertson, LPPL "maintainer" +# Copyright 2010-2017 Philipp Stephani +# Copyright 2011-2017 Joseph Wright +# Copyright 2012-2015 Khaled Hosny +# ------------------------------------------------ +# +# ©/ + +# For this Julia file, the copyright statement is: +# Copyright 2025 M. Berkemeier + +# We generate two "tables" in here: +# +# `const chars_by_range_style_name = all_chars()` +# `const chars_to_ucmchars = inverse_char_dict(chars_by_range_style_name)` +# +# `chars_by_range_style_name` is a dict-of-dict-of-dict (?) +# * char_range (:Greek, :greek, :Latin, …) +# => style (:up, :bfup, …) +# => name ("a", "Gamma", "1", … ) +# => ucm_ch::UCMChar +# +# `chars_to_ucmchars` is an inverse look-up dict, mapping +# Chars to UCMChars, if they are defined in `chars_by_range_style_name`. + + +mutable struct UCMChar + name :: String + char :: Char + char_range :: Symbol + style :: Symbol +end + +function Base.show(io::IO, ucmchar::UCMChar) + print(io, "UCMChar('$(ucmchar.char)')") +end + +function UCMChar(; name, char, char_range, style) + name = string(name) + return UCMChar( + name, char, char_range, style + ) +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) + +""" + collect_chars( + char_names, usv_dict, extras_dict=Dict(); + char_range, 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 chars 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_chars( + char_names, + usv_dict, + extras_dict=Dict(); + char_range=:UnknownRange, + fixes=Dict{Char,Char}() +) + chars_dict = SpecialDict{Symbol, SpecialDict{String, UCMChar}}() + + for (sn, cp) in pairs(usv_dict) + dict_sn = SpecialDict( + n => let ch = Char(cp + i - 1); + UCMChar(; + name=n, char=get(fixes, ch, ch), style=sn, char_range) + end for (i, n) = enumerate(char_names) + ) + chars_dict[sn] = dict_sn + end + + for (sn, extras) in pairs(extras_dict) + if !haskey(chars_dict, sn) + dict_sn = SpecialDict{String, UCMChar}() + chars_dict[sn] = dict_sn + else + dict_sn = chars_dict[sn] + end + for (n, cp) in pairs(extras) + if haskey(dict_sn, n) + dict_sn[n].char = Char(cp) + else + dict_sn[n] = UCMChar(; + name=n, char=Char(cp), style=sn, char_range) + end + end + end + return chars_dict +end + +#%% +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", +) + +const usv_Greek = Dict( + :up => 0x391, + :it => 0x1D6E2, + :bfup => 0x1D6A8, + :bfit => 0x1D71C, + :bfsfup => 0x1D756, + :bfsfit => 0x1D790 +) + +const extras_Greek = Dict( + :up => SpecialDict( + "varTheta" => 0x3F4, + "Digamma" => 0x3DC, + ), + :bfup => SpecialDict( + "varTheta" => 0x1D6B9, + "Digamma" => 0x1D7CA, + ), + :it => SpecialDict( + "varTheta" => 0x1D6F3, + ), + :bfit => SpecialDict( + "varTheta" => 0x1D72D, + ), + :bfsfit => SpecialDict( + "varTheta" => 0x1D7A1, + ), + :bb => SpecialDict( + "Gamma" => 0x1D6E4, + "Pi" => 0x0213F, + ) +) + +const names_greek = begin + ng = _decap.(names_Greek) |> collect + + # rename lowercase symbols 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 => SpecialDict( + "epsilon" => 0x3F5, + "vartheta" => 0x3D1, + "varkappa" => 0x3F0, + "phi" => 0x3D5, + "varrho" => 0x3F1, + "varpi" => 0x3D6, + "digamma" => 0x3DD, + ), + :it => SpecialDict( + "epsilon" => 0x1D716, + "vartheta" => 0x1D717, + "varkappa" => 0x1D718, + "phi" => 0x1D719, + "varrho" => 0x1D71A, + "varpi" => 0x1D71B, + ), + :bfit => SpecialDict( + "epsilon" => 0x1D750, + "vartheta" => 0x1D751, + "varkappa" => 0x1D752, + "phi" => 0x1D753, + "varrho" => 0x1D754, + "varpi" => 0x1D755, + ), + :bfup => SpecialDict( + "epsilon" => 0x1D6DC, + "vartheta" => 0x1D6DD, + "varkappa" => 0x1D6DE, + "phi" => 0x1D6DF, + "varrho" => 0x1D6E0, + "varpi" => 0x1D6E1, + "digamma" => 0x1D7CB, + ), + :bfsfup => SpecialDict( + "epsilon" => 0x1D78A, + "vartheta" => 0x1D78B, + "varkappa" => 0x1D78C, + "phi" => 0x1D78D, + "varrho" => 0x1D78E, + "varpi" => 0x1D78F, + ), + :bfsfit => SpecialDict( + "epsilon" => 0x1D7C4, + "vartheta" => 0x1D7C5, + "varkappa" => 0x1D7C6, + "phi" => 0x1D7C7, + "varrho" => 0x1D7C8, + "varpi" => 0x1D7C9, + ), + :bb => SpecialDict( + "gamma" => 0x0213D, + "pi" => 0x0213C, + ) +) + +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 names_latin = _decap.(names_Latin) +const names_num = ("0", "1", "2", "3", "4", "5", "6", "7", "8", "9") + +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 => SpecialDict( + "B" => 0x212C, + "E" => 0x2130, + "F" => 0x2131, + "H" => 0x210B, + "I" => 0x2110, + "L" => 0x2112, + "M" => 0x2133, + "R" => 0x211B, + ), + :bb => SpecialDict( + "C" => 0x2102, + "H" => 0x210D, + "N" => 0x2115, + "P" => 0x2119, + "Q" => 0x211A, + "R" => 0x211D, + "Z" => 0x2124, + ), + :frak => SpecialDict( + "C" => 0x212D, + "H" => 0x210C, + "I" => 0x2111, + "R" => 0x211C, + "Z" => 0x2128, + ), + :bbit => SpecialDict( + "D" => 0x2145 + ) +) + +const extras_latin = Dict( + :cal => SpecialDict( + "e" => 0x212F, + "g" => 0x210A, + "o" => 0x2134 + ), + :it => SpecialDict( + "h" => 0x0210E, + ), + :bbit => SpecialDict( + "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 +) + +const usv_num = Dict( + :up => 48, + :bb => 0x1D7D8, + :sfup => 0x1D7E2, + :tt => 0x1D7F6, + :bfup => 0x1D7CE, + :bfsfup => 0x1D7EC +) +const names_partial = ("partial",) +const usv_partial = Dict( + :up => 0x02202, + :it => 0x1D715, + :bfup => 0x1D6DB, + :bfit => 0x1D74F, + :bfsfup => 0x1D789, + :bfsfit => 0x1D7C3, +) + +const names_Nabla = ("Nabla",) +const usv_Nabla = Dict( + :up => 0x02207, + :it => 0x1D6FB, + :bfup => 0x1D6C1, + :bfit => 0x1D735, + :bfsfup => 0x1D76F, + :bfsfit => 0x1D7A9, +) + +const names_dotless = ("dotlessi", "dotlessj") +const usv_dotless = Dict( + :up => 0x00131, + :it => 0x1D6A4 +) +const extras_dotless = Dict( + :up => SpecialDict( + "dotlessj" => 0x00237, + ), + :it => SpecialDict( + "dotlessi" => 0x1D6A4, + ) +) + +const chars_dotless = Dict( + :up => SpecialDict( + "dotlessi" => UCMChar("dotlessi", Char(0x00131), :dotless, :up), + "dotlessj" => UCMChar("dotlessi", Char(0x00237), :dotless, :up) + ), + :it => SpecialDict( + "dotlessi" => UCMChar("dotlessi", Char(0x1D6A4), :dotless, :it), + "dotlessj" => UCMChar("dotlessi", Char(0x1D6A5), :dotless, :it), + ) +) + +function all_chars() + chars_Greek = collect_chars(names_Greek, usv_Greek, extras_Greek; char_range=:Greek) + chars_greek = collect_chars(names_greek, usv_greek, extras_greek; char_range=:greek) + + chars_Latin = collect_chars(names_Latin, usv_Latin, extras_Latin; char_range=:Latin) + chars_latin = collect_chars(names_latin, usv_latin, extras_latin; char_range=:latin) + chars_num = collect_chars(names_num, usv_num; char_range=:num) + + chars_Nabla = collect_chars(names_Nabla, usv_Nabla; char_range=:Nabla) + chars_partial = collect_chars(names_partial, usv_partial; char_range=:partial) + + return Dict( + :Greek => chars_Greek, + :greek => chars_greek, + :Latin => chars_Latin, + :latin => chars_latin, + :num => chars_num, + :Nabla => chars_Nabla, + :partial => chars_partial, + :dotless => chars_dotless + ) +end + +function inverse_char_dict(all_chars_dict) + d = SpecialDict{Char, UCMChar}() + for (rn, chd) = pairs(all_chars_dict) + for (sn, ucms) = pairs(chd) + for (n, uch) = pairs(ucms) + ch = uch.char + if haskey(d, ch) + @warn """ + '$(ch)' already assigned: + is : range=$(d[ch].char_range), style=$(d[ch].style), + new: range=$(uch.char_range), style=$(uch.style)""" + else + d[ch] = uch + end + end + end + end + return d +end + +const chars_by_range_style_name = all_chars() +const chars_to_ucmchars = inverse_char_dict(chars_by_range_style_name) +#= +import Unicode as U +for (rn, chd) = pairs(ucm_chars) + for (sn, ucms) = pairs(chd) + for (n, uch) = pairs(ucms) + U.isassigned(uch.char) && continue + @show rn, sn, n + end + end +end +=# \ No newline at end of file diff --git a/src/UnicodeMath/extra_commands.jl b/src/UnicodeMath/extra_commands.jl new file mode 100644 index 0000000..5620d0e --- /dev/null +++ b/src/UnicodeMath/extra_commands.jl @@ -0,0 +1,2483 @@ +# This file contains LaTeX commands originally +# defined in source file `unicode-math-table.tex` +# of the UNICODE-MATH package + +# Find below the original license statement: + +# /© +# +# ------------------------------------------------ +# The UNICODE-MATH package +# ------------------------------------------------ +# This package is free software and may be redistributed and/or modified under +# the conditions of the LaTeX Project Public License, version 1.3c or higher +# (your choice): . +# ------------------------------------------------ +# Copyright 2006-2019 Will Robertson, LPPL "maintainer" +# Copyright 2010-2017 Philipp Stephani +# Copyright 2011-2017 Joseph Wright +# Copyright 2012-2015 Khaled Hosny +# ------------------------------------------------ +# +# ©/ + +# For this Julia file, the copyright statement is: +# Copyright 2025 M. Berkemeier + +struct UCMCommand + latex_cmd :: String + char :: 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/engine/texelements.jl b/src/engine/texelements.jl index 2d32932..493efe1 100644 --- a/src/engine/texelements.jl +++ b/src/engine/texelements.jl @@ -157,6 +157,14 @@ function TeXChar(char::Char, state::LayoutState, char_type) return TeXChar(id, font, font_family, false, char) end + if state.tex_mode == :inline_math && char_type != :ucm_symbol + char = _ucm_stylize(char_type, char, font_family) + end + + if char_type == :ucm_symbol + char_type = :symbol + end + font = get_font(state, char_type) return TeXChar( diff --git a/src/parser/texexpr.jl b/src/parser/texexpr.jl index acc29ea..b5fb772 100644 --- a/src/parser/texexpr.jl +++ b/src/parser/texexpr.jl @@ -102,7 +102,7 @@ manual_texexpr(any) = any head(texexpr::TeXExpr) = texexpr.head head(::Char) = :char -isleaf(texexpr::TeXExpr) = texexpr.head in (:char, :delimiter, :digit, :punctuation, :symbol) +isleaf(texexpr::TeXExpr) = texexpr.head in (:char, :delimiter, :digit, :punctuation, :symbol, :ucm_symbol) isleaf(::Nothing) = true function AbstractTrees.children(texexpr::TeXExpr)