Skip to content

Instantly share code, notes, and snippets.

@Bak-Jin-Hyeong

Bak-Jin-Hyeong/ConvertHTMLEntities.hpp

Last active May 4, 2017 06:43
Show Gist options

  • Select an option

    Learn more about clone URLs
  • Save Bak-Jin-Hyeong/cf8d3ff817b6dce5c8e0648f51a193c5 to your computer and use it in GitHub Desktop.

Select an option

Learn more about clone URLs
Save Bak-Jin-Hyeong/cf8d3ff817b6dce5c8e0648f51a193c5 to your computer and use it in GitHub Desktop.
Download ZIP
Raw
ConvertHTMLEntities.hpp
#include <cstring>
#include <algorithm>
#include <utility>
#include <string>
#include <regex>
template<typename C> class EncodeCodePointToUTF {
public:
C encoded[(4 / sizeof(C)) + 1] = {};
int length = 1;
explicit EncodeCodePointToUTF(unsigned int codePoint) {
EncodeImpl<sizeof(C)>(codePoint);
}
private:
template<size_t> void EncodeImpl(unsigned int codePoint);
template<> void EncodeImpl<4>(unsigned int codePoint) {
encoded[0] = static_cast<C>(codePoint);
encoded[1] = '\0';
length = 1;
}
template<> void EncodeImpl<2>(unsigned int codePoint) {
if (codePoint <= 0xFFFF) {
encoded[0] = static_cast<C>(codePoint);
encoded[1] = '\0';
length = 1;
}
else if (codePoint <= 0x10FFFF) {
const auto x = codePoint - 0x10000;
encoded[0] = static_cast<C>(0xD800 + ((x >> 10) & 0x3FF));
encoded[1] = static_cast<C>(0xDC00 + (x & 0x3FF));
encoded[2] = '\0';
length = 2;
}
else {
encoded[0] = '\0';
length = 0;
}
}
template<> void EncodeImpl<1>(unsigned int codePoint) {
if (codePoint <= 0x7F) {
encoded[0] = static_cast<C>(codePoint);
encoded[1] = '\0';
length = 1;
}
else if (codePoint <= 0x7FF) {
encoded[0] = static_cast<C>(0xC0 + ((codePoint >> 6) & 0x1F));
encoded[1] = static_cast<C>(0x80 + (codePoint & 0x3F));
encoded[2] = '\0';
length = 2;
}
else if (codePoint <= 0xFFFF) {
encoded[0] = static_cast<C>(0xE0 + ((codePoint >> 12) & 0xF));
encoded[1] = static_cast<C>(0x80 + ((codePoint >> 6) & 0x3F));
encoded[2] = static_cast<C>(0x80 + (codePoint & 0x3F));
encoded[3] = '\0';
length = 3;
}
else if (codePoint <= 0x10FFFF) {
encoded[0] = static_cast<C>(0xF0 + ((codePoint >> 18) & 0x7));
encoded[1] = static_cast<C>(0x80 + ((codePoint >> 12) & 0x3F));
encoded[2] = static_cast<C>(0x80 + ((codePoint >> 6) & 0x3F));
encoded[3] = static_cast<C>(0x80 + (codePoint & 0x3F));
encoded[4] = '\0';
length = 4;
}
else {
encoded[0] = '\0';
length = 0;
}
}
};
inline int HTMLEntityNameToCodePoint(const char* name) {
struct Lookup {
const char* name;
int code;
};
struct Compare {
bool operator()(const Lookup& lhs, const Lookup& rhs) const {
return strcmp(lhs.name, rhs.name) < 0;
}
bool operator()(const Lookup& lhs, const char* rhs) const {
return strcmp(lhs.name, rhs) < 0;
}
bool operator()(const char* lhs, const Lookup& rhs) const {
return strcmp(lhs, rhs.name) < 0;
}
};
// CAUTION: Alphabetical ordering should be maintained.
// NOTE: scrabbed from https://dev.w3.org/html5/html-author/charref
static const Lookup lookup_[] = {
{ "AElig", 0x000C6 },
{ "AMP", 0x00026 },
{ "Aacute", 0x000C1 },
{ "Abreve", 0x00102 },
{ "Acirc", 0x000C2 },
{ "Acy", 0x00410 },
{ "Afr", 0x1D504 },
{ "Agrave", 0x000C0 },
{ "Alpha", 0x00391 },
{ "Amacr", 0x00100 },
{ "And", 0x02A53 },
{ "Aogon", 0x00104 },
{ "Aopf", 0x1D538 },
{ "ApplyFunction", 0x02061 },
{ "Aring", 0x000C5 },
{ "Ascr", 0x1D49C },
{ "Assign", 0x02254 },
{ "Atilde", 0x000C3 },
{ "Aum", 0x000C4 },
{ "Backslash", 0x02216 },
{ "Barv", 0x02AE7 },
{ "Barwed", 0x02306 },
{ "Bcy", 0x00411 },
{ "Because", 0x02235 },
{ "Bernoullis", 0x0212C },
{ "Beta", 0x00392 },
{ "Bfr", 0x1D505 },
{ "Bopf", 0x1D539 },
{ "Breve", 0x002D8 },
{ "Bscr", 0x0212C },
{ "Bumpeq", 0x0224E },
{ "CHcy", 0x00427 },
{ "COPY", 0x000A9 },
{ "Cacute", 0x00106 },
{ "Cap", 0x022D2 },
{ "CapitalDifferentialD", 0x02145 },
{ "Cayleys", 0x0212D },
{ "Ccaron", 0x0010C },
{ "Ccedi", 0x000C7 },
{ "Ccirc", 0x00108 },
{ "Cconint", 0x02230 },
{ "Cdot", 0x0010A },
{ "Cedilla", 0x000B8 },
{ "CenterDot", 0x000B7 },
{ "Cfr", 0x0212D },
{ "Chi", 0x003A7 },
{ "CircleDot", 0x02299 },
{ "CircleMinus", 0x02296 },
{ "CirclePlus", 0x02295 },
{ "CircleTimes", 0x02297 },
{ "ClockwiseContourIntegra", 0x02232 },
{ "CloseCurlyDoubleQuote", 0x0201D },
{ "CloseCurlyQuote", 0x02019 },
{ "Colon", 0x02237 },
{ "Colone", 0x02A74 },
{ "Congruent", 0x02261 },
{ "Conint", 0x0222F },
{ "ContourIntegra", 0x0222E },
{ "Copf", 0x02102 },
{ "Coproduct", 0x02210 },
{ "CounterClockwiseContourIntegra", 0x02233 },
{ "Cross", 0x02A2F },
{ "Cscr", 0x1D49E },
{ "Cup", 0x022D3 },
{ "CupCap", 0x0224D },
{ "DD", 0x02145 },
{ "DDotrahd", 0x02911 },
{ "DJcy", 0x00402 },
{ "DScy", 0x00405 },
{ "DZcy", 0x0040F },
{ "Dagger", 0x02021 },
{ "Darr", 0x021A1 },
{ "Dashv", 0x02AE4 },
{ "Dcaron", 0x0010E },
{ "Dcy", 0x00414 },
{ "De", 0x02207 },
{ "Delta", 0x00394 },
{ "Dfr", 0x1D507 },
{ "DiacriticalAcute", 0x000B4 },
{ "DiacriticalDot", 0x002D9 },
{ "DiacriticalDoubleAcute", 0x002DD },
{ "DiacriticalGrave", 0x00060 },
{ "DiacriticalTilde", 0x002DC },
{ "Diamond", 0x022C4 },
{ "DifferentialD", 0x02146 },
{ "Dopf", 0x1D53B },
{ "Dot", 0x000A8 },
{ "DotDot", 0x020DC },
{ "DotEqua", 0x02250 },
{ "DoubleContourIntegra", 0x0222F },
{ "DoubleDot", 0x000A8 },
{ "DoubleDownArrow", 0x021D3 },
{ "DoubleLeftArrow", 0x021D0 },
{ "DoubleLeftRightArrow", 0x021D4 },
{ "DoubleLeftTee", 0x02AE4 },
{ "DoubleLongLeftArrow", 0x027F8 },
{ "DoubleLongLeftRightArrow", 0x027FA },
{ "DoubleLongRightArrow", 0x027F9 },
{ "DoubleRightArrow", 0x021D2 },
{ "DoubleRightTee", 0x022A8 },
{ "DoubleUpArrow", 0x021D1 },
{ "DoubleUpDownArrow", 0x021D5 },
{ "DoubleVerticalBar", 0x02225 },
{ "DownArrow", 0x02193 },
{ "DownArrowBar", 0x02913 },
{ "DownArrowUpArrow", 0x021F5 },
{ "DownBreve", 0x00311 },
{ "DownLeftRightVector", 0x02950 },
{ "DownLeftTeeVector", 0x0295E },
{ "DownLeftVector", 0x021BD },
{ "DownLeftVectorBar", 0x02956 },
{ "DownRightTeeVector", 0x0295F },
{ "DownRightVector", 0x021C1 },
{ "DownRightVectorBar", 0x02957 },
{ "DownTee", 0x022A4 },
{ "DownTeeArrow", 0x021A7 },
{ "Downarrow", 0x021D3 },
{ "Dscr", 0x1D49F },
{ "Dstrok", 0x00110 },
{ "ENG", 0x0014A },
{ "ETH", 0x000D0 },
{ "Eacute", 0x000C9 },
{ "Ecaron", 0x0011A },
{ "Ecirc", 0x000CA },
{ "Ecy", 0x0042D },
{ "Edot", 0x00116 },
{ "Efr", 0x1D508 },
{ "Egrave", 0x000C8 },
{ "Element", 0x02208 },
{ "Emacr", 0x00112 },
{ "EmptySmallSquare", 0x025FB },
{ "EmptyVerySmallSquare", 0x025AB },
{ "Eogon", 0x00118 },
{ "Eopf", 0x1D53C },
{ "Epsilon", 0x00395 },
{ "Equa", 0x02A75 },
{ "EqualTilde", 0x02242 },
{ "Equilibrium", 0x021CC },
{ "Escr", 0x02130 },
{ "Esim", 0x02A73 },
{ "Eta", 0x00397 },
{ "Eum", 0x000CB },
{ "Exists", 0x02203 },
{ "ExponentialE", 0x02147 },
{ "Fcy", 0x00424 },
{ "Ffr", 0x1D509 },
{ "FilledSmallSquare", 0x025FC },
{ "FilledVerySmallSquare", 0x025AA },
{ "Fopf", 0x1D53D },
{ "ForAl", 0x02200 },
{ "Fouriertrf", 0x02131 },
{ "Fscr", 0x02131 },
{ "GJcy", 0x00403 },
{ "GT", 0x0003E },
{ "Gamma", 0x00393 },
{ "Gammad", 0x003DC },
{ "Gbreve", 0x0011E },
{ "Gcedi", 0x00122 },
{ "Gcirc", 0x0011C },
{ "Gcy", 0x00413 },
{ "Gdot", 0x00120 },
{ "Gfr", 0x1D50A },
{ "Gg", 0x022D9 },
{ "Gopf", 0x1D53E },
{ "GreaterEqua", 0x02265 },
{ "GreaterEqualLess", 0x022DB },
{ "GreaterFullEqua", 0x02267 },
{ "GreaterGreater", 0x02AA2 },
{ "GreaterLess", 0x02277 },
{ "GreaterSlantEqua", 0x02A7E },
{ "GreaterTilde", 0x02273 },
{ "Gscr", 0x1D4A2 },
{ "Gt", 0x0226B },
{ "HARDcy", 0x0042A },
{ "Hacek", 0x002C7 },
{ "Hat", 0x0005E },
{ "Hcirc", 0x00124 },
{ "Hfr", 0x0210C },
{ "HilbertSpace", 0x0210B },
{ "Hopf", 0x0210D },
{ "HorizontalLine", 0x02500 },
{ "Hscr", 0x0210B },
{ "Hstrok", 0x00126 },
{ "HumpDownHump", 0x0224E },
{ "HumpEqua", 0x0224F },
{ "IEcy", 0x00415 },
{ "IJlig", 0x00132 },
{ "IOcy", 0x00401 },
{ "Iacute", 0x000CD },
{ "Icirc", 0x000CE },
{ "Icy", 0x00418 },
{ "Idot", 0x00130 },
{ "Ifr", 0x02111 },
{ "Igrave", 0x000CC },
{ "Im", 0x02111 },
{ "Imacr", 0x0012A },
{ "ImaginaryI", 0x02148 },
{ "Implies", 0x021D2 },
{ "Int", 0x0222C },
{ "Integra", 0x0222B },
{ "Intersection", 0x022C2 },
{ "InvisibleComma", 0x02063 },
{ "InvisibleTimes", 0x02062 },
{ "Iogon", 0x0012E },
{ "Iopf", 0x1D540 },
{ "Iota", 0x00399 },
{ "Iscr", 0x02110 },
{ "Itilde", 0x00128 },
{ "Iukcy", 0x00406 },
{ "Ium", 0x000CF },
{ "Jcirc", 0x00134 },
{ "Jcy", 0x00419 },
{ "Jfr", 0x1D50D },
{ "Jopf", 0x1D541 },
{ "Jscr", 0x1D4A5 },
{ "Jsercy", 0x00408 },
{ "Jukcy", 0x00404 },
{ "KHcy", 0x00425 },
{ "KJcy", 0x0040C },
{ "Kappa", 0x0039A },
{ "Kcedi", 0x00136 },
{ "Kcy", 0x0041A },
{ "Kfr", 0x1D50E },
{ "Kopf", 0x1D542 },
{ "Kscr", 0x1D4A6 },
{ "LJcy", 0x00409 },
{ "LT", 0x0003C },
{ "Lacute", 0x00139 },
{ "Lambda", 0x0039B },
{ "Lang", 0x027EA },
{ "Laplacetrf", 0x02112 },
{ "Larr", 0x0219E },
{ "Lcaron", 0x0013D },
{ "Lcedi", 0x0013B },
{ "Lcy", 0x0041B },
{ "LeftAngleBracket", 0x027E8 },
{ "LeftArrow", 0x02190 },
{ "LeftArrowBar", 0x021E4 },
{ "LeftArrowRightArrow", 0x021C6 },
{ "LeftCeiling", 0x02308 },
{ "LeftDoubleBracket", 0x027E6 },
{ "LeftDownTeeVector", 0x02961 },
{ "LeftDownVector", 0x021C3 },
{ "LeftDownVectorBar", 0x02959 },
{ "LeftFloor", 0x0230A },
{ "LeftRightArrow", 0x02194 },
{ "LeftRightVector", 0x0294E },
{ "LeftTee", 0x022A3 },
{ "LeftTeeArrow", 0x021A4 },
{ "LeftTeeVector", 0x0295A },
{ "LeftTriangle", 0x022B2 },
{ "LeftTriangleBar", 0x029CF },
{ "LeftTriangleEqua", 0x022B4 },
{ "LeftUpDownVector", 0x02951 },
{ "LeftUpTeeVector", 0x02960 },
{ "LeftUpVector", 0x021BF },
{ "LeftUpVectorBar", 0x02958 },
{ "LeftVector", 0x021BC },
{ "LeftVectorBar", 0x02952 },
{ "Leftarrow", 0x021D0 },
{ "Leftrightarrow", 0x021D4 },
{ "LessEqualGreater", 0x022DA },
{ "LessFullEqua", 0x02266 },
{ "LessGreater", 0x02276 },
{ "LessLess", 0x02AA1 },
{ "LessSlantEqua", 0x02A7D },
{ "LessTilde", 0x02272 },
{ "Lfr", 0x1D50F },
{ "L", 0x022D8 },
{ "Lleftarrow", 0x021DA },
{ "Lmidot", 0x0013F },
{ "LongLeftArrow", 0x027F5 },
{ "LongLeftRightArrow", 0x027F7 },
{ "LongRightArrow", 0x027F6 },
{ "Longleftarrow", 0x027F8 },
{ "Longleftrightarrow", 0x027FA },
{ "Longrightarrow", 0x027F9 },
{ "Lopf", 0x1D543 },
{ "LowerLeftArrow", 0x02199 },
{ "LowerRightArrow", 0x02198 },
{ "Lscr", 0x02112 },
{ "Lsh", 0x021B0 },
{ "Lstrok", 0x00141 },
{ "Lt", 0x0226A },
{ "Map", 0x02905 },
{ "Mcy", 0x0041C },
{ "MediumSpace", 0x0205F },
{ "Mellintrf", 0x02133 },
{ "Mfr", 0x1D510 },
{ "MinusPlus", 0x02213 },
{ "Mopf", 0x1D544 },
{ "Mscr", 0x02133 },
{ "Mu", 0x0039C },
{ "NJcy", 0x0040A },
{ "Nacute", 0x00143 },
{ "Ncaron", 0x00147 },
{ "Ncedi", 0x00145 },
{ "Ncy", 0x0041D },
{ "NegativeMediumSpace", 0x0200B },
{ "NegativeThickSpace", 0x0200B },
{ "NegativeThinSpace", 0x0200B },
{ "NegativeVeryThinSpace", 0x0200B },
{ "NestedGreaterGreater", 0x0226B },
{ "NestedLessLess", 0x0226A },
{ "NewLine", 0x0000A },
{ "Nfr", 0x1D511 },
{ "NoBreak", 0x02060 },
{ "NonBreakingSpace", 0x000A0 },
{ "Nopf", 0x02115 },
{ "Not", 0x02AEC },
{ "NotCongruent", 0x02262 },
{ "NotCupCap", 0x0226D },
{ "NotDoubleVerticalBar", 0x02226 },
{ "NotElement", 0x02209 },
{ "NotEqua", 0x02260 },
{ "NotExists", 0x02204 },
{ "NotGreater", 0x0226F },
{ "NotGreaterEqua", 0x02271 },
{ "NotGreaterLess", 0x02279 },
{ "NotGreaterTilde", 0x02275 },
{ "NotLeftTriangle", 0x022EA },
{ "NotLeftTriangleEqua", 0x022EC },
{ "NotLess", 0x0226E },
{ "NotLessEqua", 0x02270 },
{ "NotLessGreater", 0x02278 },
{ "NotLessTilde", 0x02274 },
{ "NotPrecedes", 0x02280 },
{ "NotPrecedesSlantEqua", 0x022E0 },
{ "NotReverseElement", 0x0220C },
{ "NotRightTriangle", 0x022EB },
{ "NotRightTriangleEqua", 0x022ED },
{ "NotSquareSubsetEqua", 0x022E2 },
{ "NotSquareSupersetEqua", 0x022E3 },
{ "NotSubsetEqua", 0x02288 },
{ "NotSucceeds", 0x02281 },
{ "NotSucceedsSlantEqua", 0x022E1 },
{ "NotSupersetEqua", 0x02289 },
{ "NotTilde", 0x02241 },
{ "NotTildeEqua", 0x02244 },
{ "NotTildeFullEqua", 0x02247 },
{ "NotTildeTilde", 0x02249 },
{ "NotVerticalBar", 0x02224 },
{ "Nscr", 0x1D4A9 },
{ "Ntilde", 0x000D1 },
{ "Nu", 0x0039D },
{ "OElig", 0x00152 },
{ "Oacute", 0x000D3 },
{ "Ocirc", 0x000D4 },
{ "Ocy", 0x0041E },
{ "Odblac", 0x00150 },
{ "Ofr", 0x1D512 },
{ "Ograve", 0x000D2 },
{ "Omacr", 0x0014C },
{ "Omega", 0x003A9 },
{ "Omicron", 0x0039F },
{ "Oopf", 0x1D546 },
{ "OpenCurlyDoubleQuote", 0x0201C },
{ "OpenCurlyQuote", 0x02018 },
{ "Or", 0x02A54 },
{ "Oscr", 0x1D4AA },
{ "Oslash", 0x000D8 },
{ "Otilde", 0x000D5 },
{ "Otimes", 0x02A37 },
{ "Oum", 0x000D6 },
{ "OverBar", 0x000AF },
{ "OverBrace", 0x023DE },
{ "OverBracket", 0x023B4 },
{ "OverParenthesis", 0x023DC },
{ "PartialD", 0x02202 },
{ "Pcy", 0x0041F },
{ "Pfr", 0x1D513 },
{ "Phi", 0x003A6 },
{ "Pi", 0x003A0 },
{ "PlusMinus", 0x000B1 },
{ "Poincareplane", 0x0210C },
{ "Popf", 0x02119 },
{ "Pr", 0x02ABB },
{ "Precedes", 0x0227A },
{ "PrecedesEqua", 0x02AAF },
{ "PrecedesSlantEqua", 0x0227C },
{ "PrecedesTilde", 0x0227E },
{ "Prime", 0x02033 },
{ "Product", 0x0220F },
{ "Proportion", 0x02237 },
{ "Proportiona", 0x0221D },
{ "Pscr", 0x1D4AB },
{ "Psi", 0x003A8 },
{ "QUOT", 0x00022 },
{ "Qfr", 0x1D514 },
{ "Qopf", 0x0211A },
{ "Qscr", 0x1D4AC },
{ "RBarr", 0x02910 },
{ "REG", 0x000AE },
{ "Racute", 0x00154 },
{ "Rang", 0x027EB },
{ "Rarr", 0x021A0 },
{ "Rarrt", 0x02916 },
{ "Rcaron", 0x00158 },
{ "Rcedi", 0x00156 },
{ "Rcy", 0x00420 },
{ "Re", 0x0211C },
{ "ReverseElement", 0x0220B },
{ "ReverseEquilibrium", 0x021CB },
{ "ReverseUpEquilibrium", 0x0296F },
{ "Rfr", 0x0211C },
{ "Rho", 0x003A1 },
{ "RightAngleBracket", 0x027E9 },
{ "RightArrow", 0x02192 },
{ "RightArrowBar", 0x021E5 },
{ "RightArrowLeftArrow", 0x021C4 },
{ "RightCeiling", 0x02309 },
{ "RightDoubleBracket", 0x027E7 },
{ "RightDownTeeVector", 0x0295D },
{ "RightDownVector", 0x021C2 },
{ "RightDownVectorBar", 0x02955 },
{ "RightFloor", 0x0230B },
{ "RightTee", 0x022A2 },
{ "RightTeeArrow", 0x021A6 },
{ "RightTeeVector", 0x0295B },
{ "RightTriangle", 0x022B3 },
{ "RightTriangleBar", 0x029D0 },
{ "RightTriangleEqua", 0x022B5 },
{ "RightUpDownVector", 0x0294F },
{ "RightUpTeeVector", 0x0295C },
{ "RightUpVector", 0x021BE },
{ "RightUpVectorBar", 0x02954 },
{ "RightVector", 0x021C0 },
{ "RightVectorBar", 0x02953 },
{ "Rightarrow", 0x021D2 },
{ "Ropf", 0x0211D },
{ "RoundImplies", 0x02970 },
{ "Rrightarrow", 0x021DB },
{ "Rscr", 0x0211B },
{ "Rsh", 0x021B1 },
{ "RuleDelayed", 0x029F4 },
{ "SHCHcy", 0x00429 },
{ "SHcy", 0x00428 },
{ "SOFTcy", 0x0042C },
{ "Sacute", 0x0015A },
{ "Sc", 0x02ABC },
{ "Scaron", 0x00160 },
{ "Scedi", 0x0015E },
{ "Scirc", 0x0015C },
{ "Scy", 0x00421 },
{ "Sfr", 0x1D516 },
{ "ShortDownArrow", 0x02193 },
{ "ShortLeftArrow", 0x02190 },
{ "ShortRightArrow", 0x02192 },
{ "ShortUpArrow", 0x02191 },
{ "Sigma", 0x003A3 },
{ "SmallCircle", 0x02218 },
{ "Sopf", 0x1D54A },
{ "Sqrt", 0x0221A },
{ "Square", 0x025A1 },
{ "SquareIntersection", 0x02293 },
{ "SquareSubset", 0x0228F },
{ "SquareSubsetEqua", 0x02291 },
{ "SquareSuperset", 0x02290 },
{ "SquareSupersetEqua", 0x02292 },
{ "SquareUnion", 0x02294 },
{ "Sscr", 0x1D4AE },
{ "Star", 0x022C6 },
{ "Sub", 0x022D0 },
{ "Subset", 0x022D0 },
{ "SubsetEqua", 0x02286 },
{ "Succeeds", 0x0227B },
{ "SucceedsEqua", 0x02AB0 },
{ "SucceedsSlantEqua", 0x0227D },
{ "SucceedsTilde", 0x0227F },
{ "SuchThat", 0x0220B },
{ "Sum", 0x02211 },
{ "Sup", 0x022D1 },
{ "Superset", 0x02283 },
{ "SupersetEqua", 0x02287 },
{ "Supset", 0x022D1 },
{ "THORN", 0x000DE },
{ "TRADE", 0x02122 },
{ "TSHcy", 0x0040B },
{ "TScy", 0x00426 },
{ "Tab", 0x00009 },
{ "Tau", 0x003A4 },
{ "Tcaron", 0x00164 },
{ "Tcedi", 0x00162 },
{ "Tcy", 0x00422 },
{ "Tfr", 0x1D517 },
{ "Therefore", 0x02234 },
{ "Theta", 0x00398 },
{ "ThinSpace", 0x02009 },
{ "Tilde", 0x0223C },
{ "TildeEqua", 0x02243 },
{ "TildeFullEqua", 0x02245 },
{ "TildeTilde", 0x02248 },
{ "Topf", 0x1D54B },
{ "TripleDot", 0x020DB },
{ "Tscr", 0x1D4AF },
{ "Tstrok", 0x00166 },
{ "Uacute", 0x000DA },
{ "Uarr", 0x0219F },
{ "Uarrocir", 0x02949 },
{ "Ubrcy", 0x0040E },
{ "Ubreve", 0x0016C },
{ "Ucirc", 0x000DB },
{ "Ucy", 0x00423 },
{ "Udblac", 0x00170 },
{ "Ufr", 0x1D518 },
{ "Ugrave", 0x000D9 },
{ "Umacr", 0x0016A },
{ "UnderBar", 0x00332 },
{ "UnderBrace", 0x023DF },
{ "UnderBracket", 0x023B5 },
{ "UnderParenthesis", 0x023DD },
{ "Union", 0x022C3 },
{ "UnionPlus", 0x0228E },
{ "Uogon", 0x00172 },
{ "Uopf", 0x1D54C },
{ "UpArrow", 0x02191 },
{ "UpArrowBar", 0x02912 },
{ "UpArrowDownArrow", 0x021C5 },
{ "UpDownArrow", 0x02195 },
{ "UpEquilibrium", 0x0296E },
{ "UpTee", 0x022A5 },
{ "UpTeeArrow", 0x021A5 },
{ "Uparrow", 0x021D1 },
{ "Updownarrow", 0x021D5 },
{ "UpperLeftArrow", 0x02196 },
{ "UpperRightArrow", 0x02197 },
{ "Upsi", 0x003D2 },
{ "Upsilon", 0x003A5 },
{ "Uring", 0x0016E },
{ "Uscr", 0x1D4B0 },
{ "Utilde", 0x00168 },
{ "Uum", 0x000DC },
{ "VDash", 0x022AB },
{ "Vbar", 0x02AEB },
{ "Vcy", 0x00412 },
{ "Vdash", 0x022A9 },
{ "Vdash", 0x02AE6 },
{ "Vee", 0x022C1 },
{ "Verbar", 0x02016 },
{ "Vert", 0x02016 },
{ "VerticalBar", 0x02223 },
{ "VerticalLine", 0x0007C },
{ "VerticalSeparator", 0x02758 },
{ "VerticalTilde", 0x02240 },
{ "VeryThinSpace", 0x0200A },
{ "Vfr", 0x1D519 },
{ "Vopf", 0x1D54D },
{ "Vscr", 0x1D4B1 },
{ "Vvdash", 0x022AA },
{ "Wcirc", 0x00174 },
{ "Wedge", 0x022C0 },
{ "Wfr", 0x1D51A },
{ "Wopf", 0x1D54E },
{ "Wscr", 0x1D4B2 },
{ "Xfr", 0x1D51B },
{ "Xi", 0x0039E },
{ "Xopf", 0x1D54F },
{ "Xscr", 0x1D4B3 },
{ "YAcy", 0x0042F },
{ "YIcy", 0x00407 },
{ "YUcy", 0x0042E },
{ "Yacute", 0x000DD },
{ "Ycirc", 0x00176 },
{ "Ycy", 0x0042B },
{ "Yfr", 0x1D51C },
{ "Yopf", 0x1D550 },
{ "Yscr", 0x1D4B4 },
{ "Yum", 0x00178 },
{ "ZHcy", 0x00416 },
{ "Zacute", 0x00179 },
{ "Zcaron", 0x0017D },
{ "Zcy", 0x00417 },
{ "Zdot", 0x0017B },
{ "ZeroWidthSpace", 0x0200B },
{ "Zeta", 0x00396 },
{ "Zfr", 0x02128 },
{ "Zopf", 0x02124 },
{ "Zscr", 0x1D4B5 },
{ "aacute", 0x000E1 },
{ "abreve", 0x00103 },
{ "ac", 0x0223E },
{ "acd", 0x0223F },
{ "acirc", 0x000E2 },
{ "acute", 0x000B4 },
{ "acy", 0x00430 },
{ "aelig", 0x000E6 },
{ "af", 0x02061 },
{ "afr", 0x1D51E },
{ "agrave", 0x000E0 },
{ "alefsym", 0x02135 },
{ "aleph", 0x02135 },
{ "alpha", 0x003B1 },
{ "amacr", 0x00101 },
{ "amalg", 0x02A3F },
{ "amp", 0x00026 },
{ "and", 0x02227 },
{ "andand", 0x02A55 },
{ "andd", 0x02A5C },
{ "andslope", 0x02A58 },
{ "andv", 0x02A5A },
{ "ang", 0x02220 },
{ "ange", 0x029A4 },
{ "angle", 0x02220 },
{ "angmsd", 0x02221 },
{ "angmsdaa", 0x029A8 },
{ "angmsdab", 0x029A9 },
{ "angmsdac", 0x029AA },
{ "angmsdad", 0x029AB },
{ "angmsdae", 0x029AC },
{ "angmsdaf", 0x029AD },
{ "angmsdag", 0x029AE },
{ "angmsdah", 0x029AF },
{ "angrt", 0x0221F },
{ "angrtvb", 0x022BE },
{ "angrtvbd", 0x0299D },
{ "angsph", 0x02222 },
{ "angst", 0x0212B },
{ "angzarr", 0x0237C },
{ "aogon", 0x00105 },
{ "aopf", 0x1D552 },
{ "ap", 0x02248 },
{ "apE", 0x02A70 },
{ "apacir", 0x02A6F },
{ "ape", 0x0224A },
{ "apid", 0x0224B },
{ "apos", 0x00027 },
{ "approx", 0x02248 },
{ "approxeq", 0x0224A },
{ "aring", 0x000E5 },
{ "ascr", 0x1D4B6 },
{ "ast", 0x0002A },
{ "asymp", 0x02248 },
{ "asympeq", 0x0224D },
{ "atilde", 0x000E3 },
{ "aum", 0x000E4 },
{ "awconint", 0x02233 },
{ "awint", 0x02A11 },
{ "bNot", 0x02AED },
{ "backcong", 0x0224C },
{ "backepsilon", 0x003F6 },
{ "backprime", 0x02035 },
{ "backsim", 0x0223D },
{ "backsimeq", 0x022CD },
{ "barvee", 0x022BD },
{ "barwed", 0x02305 },
{ "barwedge", 0x02305 },
{ "bbrk", 0x023B5 },
{ "bbrktbrk", 0x023B6 },
{ "bcong", 0x0224C },
{ "bcy", 0x00431 },
{ "bdquo", 0x0201E },
{ "becaus", 0x02235 },
{ "because", 0x02235 },
{ "bemptyv", 0x029B0 },
{ "bepsi", 0x003F6 },
{ "bernou", 0x0212C },
{ "beta", 0x003B2 },
{ "beth", 0x02136 },
{ "between", 0x0226C },
{ "bfr", 0x1D51F },
{ "bigcap", 0x022C2 },
{ "bigcirc", 0x025EF },
{ "bigcup", 0x022C3 },
{ "bigodot", 0x02A00 },
{ "bigoplus", 0x02A01 },
{ "bigotimes", 0x02A02 },
{ "bigsqcup", 0x02A06 },
{ "bigstar", 0x02605 },
{ "bigtriangledown", 0x025BD },
{ "bigtriangleup", 0x025B3 },
{ "biguplus", 0x02A04 },
{ "bigvee", 0x022C1 },
{ "bigwedge", 0x022C0 },
{ "bkarow", 0x0290D },
{ "blacklozenge", 0x029EB },
{ "blacksquare", 0x025AA },
{ "blacktriangle", 0x025B4 },
{ "blacktriangledown", 0x025BE },
{ "blacktriangleleft", 0x025C2 },
{ "blacktriangleright", 0x025B8 },
{ "blank", 0x02423 },
{ "blk12", 0x02592 },
{ "blk14", 0x02591 },
{ "blk34", 0x02593 },
{ "block", 0x02588 },
{ "bnot", 0x02310 },
{ "bopf", 0x1D553 },
{ "bot", 0x022A5 },
{ "bottom", 0x022A5 },
{ "bowtie", 0x022C8 },
{ "boxD", 0x02557 },
{ "boxDR", 0x02554 },
{ "boxD", 0x02556 },
{ "boxDr", 0x02553 },
{ "boxH", 0x02550 },
{ "boxHD", 0x02566 },
{ "boxHU", 0x02569 },
{ "boxHd", 0x02564 },
{ "boxHu", 0x02567 },
{ "boxU", 0x0255D },
{ "boxUR", 0x0255A },
{ "boxU", 0x0255C },
{ "boxUr", 0x02559 },
{ "boxV", 0x02551 },
{ "boxVH", 0x0256C },
{ "boxV", 0x02563 },
{ "boxVR", 0x02560 },
{ "boxVh", 0x0256B },
{ "boxV", 0x02562 },
{ "boxVr", 0x0255F },
{ "boxbox", 0x029C9 },
{ "boxd", 0x02555 },
{ "boxdR", 0x02552 },
{ "boxd", 0x02510 },
{ "boxdr", 0x0250C },
{ "boxh", 0x02500 },
{ "boxhD", 0x02565 },
{ "boxhU", 0x02568 },
{ "boxhd", 0x0252C },
{ "boxhu", 0x02534 },
{ "boxminus", 0x0229F },
{ "boxplus", 0x0229E },
{ "boxtimes", 0x022A0 },
{ "boxu", 0x0255B },
{ "boxuR", 0x02558 },
{ "boxu", 0x02518 },
{ "boxur", 0x02514 },
{ "boxv", 0x02502 },
{ "boxvH", 0x0256A },
{ "boxv", 0x02561 },
{ "boxvR", 0x0255E },
{ "boxvh", 0x0253C },
{ "boxv", 0x02524 },
{ "boxvr", 0x0251C },
{ "bprime", 0x02035 },
{ "breve", 0x002D8 },
{ "brvbar", 0x000A6 },
{ "bscr", 0x1D4B7 },
{ "bsemi", 0x0204F },
{ "bsim", 0x0223D },
{ "bsime", 0x022CD },
{ "bso", 0x0005C },
{ "bsolb", 0x029C5 },
{ "bul", 0x02022 },
{ "bullet", 0x02022 },
{ "bump", 0x0224E },
{ "bumpE", 0x02AAE },
{ "bumpe", 0x0224F },
{ "bumpeq", 0x0224F },
{ "cacute", 0x00107 },
{ "cap", 0x02229 },
{ "capand", 0x02A44 },
{ "capbrcup", 0x02A49 },
{ "capcap", 0x02A4B },
{ "capcup", 0x02A47 },
{ "capdot", 0x02A40 },
{ "caret", 0x02041 },
{ "caron", 0x002C7 },
{ "ccaps", 0x02A4D },
{ "ccaron", 0x0010D },
{ "ccedi", 0x000E7 },
{ "ccirc", 0x00109 },
{ "ccups", 0x02A4C },
{ "ccupssm", 0x02A50 },
{ "cdot", 0x0010B },
{ "cedi", 0x000B8 },
{ "cemptyv", 0x029B2 },
{ "cent", 0x000A2 },
{ "centerdot", 0x000B7 },
{ "cfr", 0x1D520 },
{ "chcy", 0x00447 },
{ "check", 0x02713 },
{ "checkmark", 0x02713 },
{ "chi", 0x003C7 },
{ "cir", 0x025CB },
{ "cirE", 0x029C3 },
{ "circ", 0x002C6 },
{ "circeq", 0x02257 },
{ "circlearrowleft", 0x021BA },
{ "circlearrowright", 0x021BB },
{ "circledR", 0x000AE },
{ "circledS", 0x024C8 },
{ "circledast", 0x0229B },
{ "circledcirc", 0x0229A },
{ "circleddash", 0x0229D },
{ "cire", 0x02257 },
{ "cirfnint", 0x02A10 },
{ "cirmid", 0x02AEF },
{ "cirscir", 0x029C2 },
{ "clubs", 0x02663 },
{ "clubsuit", 0x02663 },
{ "colon", 0x0003A },
{ "colone", 0x02254 },
{ "coloneq", 0x02254 },
{ "comma", 0x0002C },
{ "commat", 0x00040 },
{ "comp", 0x02201 },
{ "compfn", 0x02218 },
{ "complement", 0x02201 },
{ "complexes", 0x02102 },
{ "cong", 0x02245 },
{ "congdot", 0x02A6D },
{ "conint", 0x0222E },
{ "copf", 0x1D554 },
{ "coprod", 0x02210 },
{ "copy", 0x000A9 },
{ "copysr", 0x02117 },
{ "crarr", 0x021B5 },
{ "cross", 0x02717 },
{ "cscr", 0x1D4B8 },
{ "csub", 0x02ACF },
{ "csube", 0x02AD1 },
{ "csup", 0x02AD0 },
{ "csupe", 0x02AD2 },
{ "ctdot", 0x022EF },
{ "cudarr", 0x02938 },
{ "cudarrr", 0x02935 },
{ "cuepr", 0x022DE },
{ "cuesc", 0x022DF },
{ "cularr", 0x021B6 },
{ "cularrp", 0x0293D },
{ "cup", 0x0222A },
{ "cupbrcap", 0x02A48 },
{ "cupcap", 0x02A46 },
{ "cupcup", 0x02A4A },
{ "cupdot", 0x0228D },
{ "cupor", 0x02A45 },
{ "curarr", 0x021B7 },
{ "curarrm", 0x0293C },
{ "curlyeqprec", 0x022DE },
{ "curlyeqsucc", 0x022DF },
{ "curlyvee", 0x022CE },
{ "curlywedge", 0x022CF },
{ "curren", 0x000A4 },
{ "curvearrowleft", 0x021B6 },
{ "curvearrowright", 0x021B7 },
{ "cuvee", 0x022CE },
{ "cuwed", 0x022CF },
{ "cwconint", 0x02232 },
{ "cwint", 0x02231 },
{ "cylcty", 0x0232D },
{ "dArr", 0x021D3 },
{ "dHar", 0x02965 },
{ "dagger", 0x02020 },
{ "daleth", 0x02138 },
{ "darr", 0x02193 },
{ "dash", 0x02010 },
{ "dashv", 0x022A3 },
{ "dbkarow", 0x0290F },
{ "dblac", 0x002DD },
{ "dcaron", 0x0010F },
{ "dcy", 0x00434 },
{ "dd", 0x02146 },
{ "ddagger", 0x02021 },
{ "ddarr", 0x021CA },
{ "ddotseq", 0x02A77 },
{ "deg", 0x000B0 },
{ "delta", 0x003B4 },
{ "demptyv", 0x029B1 },
{ "dfisht", 0x0297F },
{ "dfr", 0x1D521 },
{ "dhar", 0x021C3 },
{ "dharr", 0x021C2 },
{ "diam", 0x022C4 },
{ "diamond", 0x022C4 },
{ "diamondsuit", 0x02666 },
{ "diams", 0x02666 },
{ "die", 0x000A8 },
{ "digamma", 0x003DD },
{ "disin", 0x022F2 },
{ "div", 0x000F7 },
{ "divide", 0x000F7 },
{ "divideontimes", 0x022C7 },
{ "divonx", 0x022C7 },
{ "djcy", 0x00452 },
{ "dlcorn", 0x0231E },
{ "dlcrop", 0x0230D },
{ "dollar", 0x00024 },
{ "dopf", 0x1D555 },
{ "dot", 0x002D9 },
{ "doteq", 0x02250 },
{ "doteqdot", 0x02251 },
{ "dotminus", 0x02238 },
{ "dotplus", 0x02214 },
{ "dotsquare", 0x022A1 },
{ "doublebarwedge", 0x02306 },
{ "downarrow", 0x02193 },
{ "downdownarrows", 0x021CA },
{ "downharpoonleft", 0x021C3 },
{ "downharpoonright", 0x021C2 },
{ "drbkarow", 0x02910 },
{ "drcorn", 0x0231F },
{ "drcrop", 0x0230C },
{ "dscr", 0x1D4B9 },
{ "dscy", 0x00455 },
{ "dso", 0x029F6 },
{ "dstrok", 0x00111 },
{ "dtdot", 0x022F1 },
{ "dtri", 0x025BF },
{ "dtrif", 0x025BE },
{ "duarr", 0x021F5 },
{ "duhar", 0x0296F },
{ "dwangle", 0x029A6 },
{ "dzcy", 0x0045F },
{ "dzigrarr", 0x027FF },
{ "eDDot", 0x02A77 },
{ "eDot", 0x02251 },
{ "eacute", 0x000E9 },
{ "easter", 0x02A6E },
{ "ecaron", 0x0011B },
{ "ecir", 0x02256 },
{ "ecirc", 0x000EA },
{ "ecolon", 0x02255 },
{ "ecy", 0x0044D },
{ "edot", 0x00117 },
{ "ee", 0x02147 },
{ "efDot", 0x02252 },
{ "efr", 0x1D522 },
{ "eg", 0x02A9A },
{ "egrave", 0x000E8 },
{ "egs", 0x02A96 },
{ "egsdot", 0x02A98 },
{ "e", 0x02A99 },
{ "elinters", 0x023E7 },
{ "el", 0x02113 },
{ "els", 0x02A95 },
{ "elsdot", 0x02A97 },
{ "emacr", 0x00113 },
{ "empty", 0x02205 },
{ "emptyset", 0x02205 },
{ "emptyv", 0x02205 },
{ "emsp", 0x02003 },
{ "emsp13", 0x02004 },
{ "emsp14", 0x02005 },
{ "eng", 0x0014B },
{ "ensp", 0x02002 },
{ "eogon", 0x00119 },
{ "eopf", 0x1D556 },
{ "epar", 0x022D5 },
{ "epars", 0x029E3 },
{ "eplus", 0x02A71 },
{ "epsi", 0x003F5 },
{ "epsilon", 0x003B5 },
{ "epsiv", 0x003B5 },
{ "eqcirc", 0x02256 },
{ "eqcolon", 0x02255 },
{ "eqsim", 0x02242 },
{ "eqslantgtr", 0x02A96 },
{ "eqslantless", 0x02A95 },
{ "equals", 0x0003D },
{ "equest", 0x0225F },
{ "equiv", 0x02261 },
{ "equivDD", 0x02A78 },
{ "eqvpars", 0x029E5 },
{ "erDot", 0x02253 },
{ "erarr", 0x02971 },
{ "escr", 0x0212F },
{ "esdot", 0x02250 },
{ "esim", 0x02242 },
{ "eta", 0x003B7 },
{ "eth", 0x000F0 },
{ "eum", 0x000EB },
{ "euro", 0x020AC },
{ "exc", 0x00021 },
{ "exist", 0x02203 },
{ "expectation", 0x02130 },
{ "exponentiale", 0x02147 },
{ "fallingdotseq", 0x02252 },
{ "fcy", 0x00444 },
{ "female", 0x02640 },
{ "ffilig", 0x0FB03 },
{ "fflig", 0x0FB00 },
{ "ffllig", 0x0FB04 },
{ "ffr", 0x1D523 },
{ "filig", 0x0FB01 },
{ "flat", 0x0266D },
{ "fllig", 0x0FB02 },
{ "fltns", 0x025B1 },
{ "fnof", 0x00192 },
{ "fopf", 0x1D557 },
{ "foral", 0x02200 },
{ "fork", 0x022D4 },
{ "forkv", 0x02AD9 },
{ "fpartint", 0x02A0D },
{ "frac12", 0x000BD },
{ "frac13", 0x02153 },
{ "frac14", 0x000BC },
{ "frac15", 0x02155 },
{ "frac16", 0x02159 },
{ "frac18", 0x0215B },
{ "frac23", 0x02154 },
{ "frac25", 0x02156 },
{ "frac34", 0x000BE },
{ "frac35", 0x02157 },
{ "frac38", 0x0215C },
{ "frac45", 0x02158 },
{ "frac56", 0x0215A },
{ "frac58", 0x0215D },
{ "frac78", 0x0215E },
{ "fras", 0x02044 },
{ "frown", 0x02322 },
{ "fscr", 0x1D4BB },
{ "gE", 0x02267 },
{ "gE", 0x02A8C },
{ "gacute", 0x001F5 },
{ "gamma", 0x003B3 },
{ "gammad", 0x003DD },
{ "gap", 0x02A86 },
{ "gbreve", 0x0011F },
{ "gcirc", 0x0011D },
{ "gcy", 0x00433 },
{ "gdot", 0x00121 },
{ "ge", 0x02265 },
{ "ge", 0x022DB },
{ "geq", 0x02265 },
{ "geqq", 0x02267 },
{ "geqslant", 0x02A7E },
{ "ges", 0x02A7E },
{ "gescc", 0x02AA9 },
{ "gesdot", 0x02A80 },
{ "gesdoto", 0x02A82 },
{ "gesdoto", 0x02A84 },
{ "gesles", 0x02A94 },
{ "gfr", 0x1D524 },
{ "gg", 0x0226B },
{ "ggg", 0x022D9 },
{ "gime", 0x02137 },
{ "gjcy", 0x00453 },
{ "g", 0x02277 },
{ "glE", 0x02A92 },
{ "gla", 0x02AA5 },
{ "glj", 0x02AA4 },
{ "gnE", 0x02269 },
{ "gnap", 0x02A8A },
{ "gnapprox", 0x02A8A },
{ "gne", 0x02A88 },
{ "gneq", 0x02A88 },
{ "gneqq", 0x02269 },
{ "gnsim", 0x022E7 },
{ "gopf", 0x1D558 },
{ "grave", 0x00060 },
{ "gscr", 0x0210A },
{ "gsim", 0x02273 },
{ "gsime", 0x02A8E },
{ "gsim", 0x02A90 },
{ "gt", 0x0003E },
{ "gtcc", 0x02AA7 },
{ "gtcir", 0x02A7A },
{ "gtdot", 0x022D7 },
{ "gtlPar", 0x02995 },
{ "gtquest", 0x02A7C },
{ "gtrapprox", 0x02A86 },
{ "gtrarr", 0x02978 },
{ "gtrdot", 0x022D7 },
{ "gtreqless", 0x022DB },
{ "gtreqqless", 0x02A8C },
{ "gtrless", 0x02277 },
{ "gtrsim", 0x02273 },
{ "hArr", 0x021D4 },
{ "hairsp", 0x0200A },
{ "half", 0x000BD },
{ "hamilt", 0x0210B },
{ "hardcy", 0x0044A },
{ "harr", 0x02194 },
{ "harrcir", 0x02948 },
{ "harrw", 0x021AD },
{ "hbar", 0x0210F },
{ "hcirc", 0x00125 },
{ "hearts", 0x02665 },
{ "heartsuit", 0x02665 },
{ "hellip", 0x02026 },
{ "hercon", 0x022B9 },
{ "hfr", 0x1D525 },
{ "hksearow", 0x02925 },
{ "hkswarow", 0x02926 },
{ "hoarr", 0x021FF },
{ "homtht", 0x0223B },
{ "hookleftarrow", 0x021A9 },
{ "hookrightarrow", 0x021AA },
{ "hopf", 0x1D559 },
{ "horbar", 0x02015 },
{ "hscr", 0x1D4BD },
{ "hslash", 0x0210F },
{ "hstrok", 0x00127 },
{ "hybul", 0x02043 },
{ "hyphen", 0x02010 },
{ "iacute", 0x000ED },
{ "ic", 0x02063 },
{ "icirc", 0x000EE },
{ "icy", 0x00438 },
{ "iecy", 0x00435 },
{ "iexc", 0x000A1 },
{ "iff", 0x021D4 },
{ "ifr", 0x1D526 },
{ "igrave", 0x000EC },
{ "ii", 0x02148 },
{ "iiiint", 0x02A0C },
{ "iiint", 0x0222D },
{ "iinfin", 0x029DC },
{ "iiota", 0x02129 },
{ "ijlig", 0x00133 },
{ "imacr", 0x0012B },
{ "image", 0x02111 },
{ "imagline", 0x02110 },
{ "imagpart", 0x02111 },
{ "imath", 0x00131 },
{ "imof", 0x022B7 },
{ "imped", 0x001B5 },
{ "in", 0x02208 },
{ "incare", 0x02105 },
{ "infin", 0x0221E },
{ "infintie", 0x029DD },
{ "inodot", 0x00131 },
{ "int", 0x0222B },
{ "intca", 0x022BA },
{ "integers", 0x02124 },
{ "interca", 0x022BA },
{ "intlarhk", 0x02A17 },
{ "intprod", 0x02A3C },
{ "iocy", 0x00451 },
{ "iogon", 0x0012F },
{ "iopf", 0x1D55A },
{ "iota", 0x003B9 },
{ "iprod", 0x02A3C },
{ "iquest", 0x000BF },
{ "iscr", 0x1D4BE },
{ "isin", 0x02208 },
{ "isinE", 0x022F9 },
{ "isindot", 0x022F5 },
{ "isins", 0x022F4 },
{ "isinsv", 0x022F3 },
{ "isinv", 0x02208 },
{ "it", 0x02062 },
{ "itilde", 0x00129 },
{ "iukcy", 0x00456 },
{ "ium", 0x000EF },
{ "jcirc", 0x00135 },
{ "jcy", 0x00439 },
{ "jfr", 0x1D527 },
{ "jmath", 0x00237 },
{ "jopf", 0x1D55B },
{ "jscr", 0x1D4BF },
{ "jsercy", 0x00458 },
{ "jukcy", 0x00454 },
{ "kappa", 0x003BA },
{ "kappav", 0x003F0 },
{ "kcedi", 0x00137 },
{ "kcy", 0x0043A },
{ "kfr", 0x1D528 },
{ "kgreen", 0x00138 },
{ "khcy", 0x00445 },
{ "kjcy", 0x0045C },
{ "kopf", 0x1D55C },
{ "kscr", 0x1D4C0 },
{ "lAarr", 0x021DA },
{ "lArr", 0x021D0 },
{ "lAtai", 0x0291B },
{ "lBarr", 0x0290E },
{ "lE", 0x02266 },
{ "lEg", 0x02A8B },
{ "lHar", 0x02962 },
{ "lacute", 0x0013A },
{ "laemptyv", 0x029B4 },
{ "lagran", 0x02112 },
{ "lambda", 0x003BB },
{ "lang", 0x027E8 },
{ "langd", 0x02991 },
{ "langle", 0x027E8 },
{ "lap", 0x02A85 },
{ "laquo", 0x000AB },
{ "larr", 0x02190 },
{ "larrb", 0x021E4 },
{ "larrbfs", 0x0291F },
{ "larrfs", 0x0291D },
{ "larrhk", 0x021A9 },
{ "larrlp", 0x021AB },
{ "larrp", 0x02939 },
{ "larrsim", 0x02973 },
{ "larrt", 0x021A2 },
{ "lat", 0x02AAB },
{ "latai", 0x02919 },
{ "late", 0x02AAD },
{ "lbarr", 0x0290C },
{ "lbbrk", 0x02772 },
{ "lbrace", 0x0007B },
{ "lbrack", 0x0005B },
{ "lbrke", 0x0298B },
{ "lbrksld", 0x0298F },
{ "lbrkslu", 0x0298D },
{ "lcaron", 0x0013E },
{ "lcedi", 0x0013C },
{ "lcei", 0x02308 },
{ "lcub", 0x0007B },
{ "lcy", 0x0043B },
{ "ldca", 0x02936 },
{ "ldquo", 0x0201C },
{ "ldquor", 0x0201E },
{ "ldrdhar", 0x02967 },
{ "ldrushar", 0x0294B },
{ "ldsh", 0x021B2 },
{ "le", 0x02264 },
{ "leftarrow", 0x02190 },
{ "leftarrowtai", 0x021A2 },
{ "leftharpoondown", 0x021BD },
{ "leftharpoonup", 0x021BC },
{ "leftleftarrows", 0x021C7 },
{ "leftrightarrow", 0x02194 },
{ "leftrightarrows", 0x021C6 },
{ "leftrightharpoons", 0x021CB },
{ "leftrightsquigarrow", 0x021AD },
{ "leftthreetimes", 0x022CB },
{ "leg", 0x022DA },
{ "leq", 0x02264 },
{ "leqq", 0x02266 },
{ "leqslant", 0x02A7D },
{ "les", 0x02A7D },
{ "lescc", 0x02AA8 },
{ "lesdot", 0x02A7F },
{ "lesdoto", 0x02A81 },
{ "lesdotor", 0x02A83 },
{ "lesges", 0x02A93 },
{ "lessapprox", 0x02A85 },
{ "lessdot", 0x022D6 },
{ "lesseqgtr", 0x022DA },
{ "lesseqqgtr", 0x02A8B },
{ "lessgtr", 0x02276 },
{ "lesssim", 0x02272 },
{ "lfisht", 0x0297C },
{ "lfloor", 0x0230A },
{ "lfr", 0x1D529 },
{ "lg", 0x02276 },
{ "lgE", 0x02A91 },
{ "lhard", 0x021BD },
{ "lharu", 0x021BC },
{ "lharu", 0x0296A },
{ "lhblk", 0x02584 },
{ "ljcy", 0x00459 },
{ "l", 0x0226A },
{ "llarr", 0x021C7 },
{ "llcorner", 0x0231E },
{ "llhard", 0x0296B },
{ "lltri", 0x025FA },
{ "lmidot", 0x00140 },
{ "lmoust", 0x023B0 },
{ "lmoustache", 0x023B0 },
{ "lnE", 0x02268 },
{ "lnap", 0x02A89 },
{ "lnapprox", 0x02A89 },
{ "lne", 0x02A87 },
{ "lneq", 0x02A87 },
{ "lneqq", 0x02268 },
{ "lnsim", 0x022E6 },
{ "loang", 0x027EC },
{ "loarr", 0x021FD },
{ "lobrk", 0x027E6 },
{ "longleftarrow", 0x027F5 },
{ "longleftrightarrow", 0x027F7 },
{ "longmapsto", 0x027FC },
{ "longrightarrow", 0x027F6 },
{ "looparrowleft", 0x021AB },
{ "looparrowright", 0x021AC },
{ "lopar", 0x02985 },
{ "lopf", 0x1D55D },
{ "loplus", 0x02A2D },
{ "lotimes", 0x02A34 },
{ "lowast", 0x02217 },
{ "lowbar", 0x0005F },
{ "loz", 0x025CA },
{ "lozenge", 0x025CA },
{ "lozf", 0x029EB },
{ "lpar", 0x00028 },
{ "lparlt", 0x02993 },
{ "lrarr", 0x021C6 },
{ "lrcorner", 0x0231F },
{ "lrhar", 0x021CB },
{ "lrhard", 0x0296D },
{ "lrm", 0x0200E },
{ "lrtri", 0x022BF },
{ "lsaquo", 0x02039 },
{ "lscr", 0x1D4C1 },
{ "lsh", 0x021B0 },
{ "lsim", 0x02272 },
{ "lsime", 0x02A8D },
{ "lsimg", 0x02A8F },
{ "lsqb", 0x0005B },
{ "lsquo", 0x02018 },
{ "lsquor", 0x0201A },
{ "lstrok", 0x00142 },
{ "lt", 0x0003C },
{ "ltcc", 0x02AA6 },
{ "ltcir", 0x02A79 },
{ "ltdot", 0x022D6 },
{ "lthree", 0x022CB },
{ "ltimes", 0x022C9 },
{ "ltlarr", 0x02976 },
{ "ltquest", 0x02A7B },
{ "ltrPar", 0x02996 },
{ "ltri", 0x025C3 },
{ "ltrie", 0x022B4 },
{ "ltrif", 0x025C2 },
{ "lurdshar", 0x0294A },
{ "luruhar", 0x02966 },
{ "mDDot", 0x0223A },
{ "macr", 0x000AF },
{ "male", 0x02642 },
{ "malt", 0x02720 },
{ "maltese", 0x02720 },
{ "map", 0x021A6 },
{ "mapsto", 0x021A6 },
{ "mapstodown", 0x021A7 },
{ "mapstoleft", 0x021A4 },
{ "mapstoup", 0x021A5 },
{ "marker", 0x025AE },
{ "mcomma", 0x02A29 },
{ "mcy", 0x0043C },
{ "mdash", 0x02014 },
{ "measuredangle", 0x02221 },
{ "mfr", 0x1D52A },
{ "mho", 0x02127 },
{ "micro", 0x000B5 },
{ "mid", 0x02223 },
{ "midast", 0x0002A },
{ "midcir", 0x02AF0 },
{ "middot", 0x000B7 },
{ "minus", 0x02212 },
{ "minusb", 0x0229F },
{ "minusd", 0x02238 },
{ "minusdu", 0x02A2A },
{ "mlcp", 0x02ADB },
{ "mldr", 0x02026 },
{ "mnplus", 0x02213 },
{ "models", 0x022A7 },
{ "mopf", 0x1D55E },
{ "mp", 0x02213 },
{ "mscr", 0x1D4C2 },
{ "mstpos", 0x0223E },
{ "mu", 0x003BC },
{ "multimap", 0x022B8 },
{ "mumap", 0x022B8 },
{ "nLeftarrow", 0x021CD },
{ "nLeftrightarrow", 0x021CE },
{ "nRightarrow", 0x021CF },
{ "nVDash", 0x022AF },
{ "nVdash", 0x022AE },
{ "nabla", 0x02207 },
{ "nacute", 0x00144 },
{ "nap", 0x02249 },
{ "napos", 0x00149 },
{ "napprox", 0x02249 },
{ "natur", 0x0266E },
{ "natura", 0x0266E },
{ "naturals", 0x02115 },
{ "nbsp", 0x000A0 },
{ "ncap", 0x02A43 },
{ "ncaron", 0x00148 },
{ "ncedi", 0x00146 },
{ "ncong", 0x02247 },
{ "ncup", 0x02A42 },
{ "ncy", 0x0043D },
{ "ndash", 0x02013 },
{ "ne", 0x02260 },
{ "neArr", 0x021D7 },
{ "nearhk", 0x02924 },
{ "nearr", 0x02197 },
{ "nearrow", 0x02197 },
{ "nequiv", 0x02262 },
{ "nesear", 0x02928 },
{ "nexist", 0x02204 },
{ "nexists", 0x02204 },
{ "nfr", 0x1D52B },
{ "nge", 0x02271 },
{ "ngeq", 0x02271 },
{ "ngsim", 0x02275 },
{ "ngt", 0x0226F },
{ "ngtr", 0x0226F },
{ "nhArr", 0x021CE },
{ "nharr", 0x021AE },
{ "nhpar", 0x02AF2 },
{ "ni", 0x0220B },
{ "nis", 0x022FC },
{ "nisd", 0x022FA },
{ "niv", 0x0220B },
{ "njcy", 0x0045A },
{ "nlArr", 0x021CD },
{ "nlarr", 0x0219A },
{ "nldr", 0x02025 },
{ "nle", 0x02270 },
{ "nleftarrow", 0x0219A },
{ "nleftrightarrow", 0x021AE },
{ "nleq", 0x02270 },
{ "nless", 0x0226E },
{ "nlsim", 0x02274 },
{ "nlt", 0x0226E },
{ "nltri", 0x022EA },
{ "nltrie", 0x022EC },
{ "nmid", 0x02224 },
{ "nopf", 0x1D55F },
{ "not", 0x000AC },
{ "notin", 0x02209 },
{ "notinva", 0x02209 },
{ "notinvb", 0x022F7 },
{ "notinvc", 0x022F6 },
{ "notni", 0x0220C },
{ "notniva", 0x0220C },
{ "notnivb", 0x022FE },
{ "notnivc", 0x022FD },
{ "npar", 0x02226 },
{ "nparalle", 0x02226 },
{ "npolint", 0x02A14 },
{ "npr", 0x02280 },
{ "nprcue", 0x022E0 },
{ "nprec", 0x02280 },
{ "nrArr", 0x021CF },
{ "nrarr", 0x0219B },
{ "nrightarrow", 0x0219B },
{ "nrtri", 0x022EB },
{ "nrtrie", 0x022ED },
{ "nsc", 0x02281 },
{ "nsccue", 0x022E1 },
{ "nscr", 0x1D4C3 },
{ "nshortmid", 0x02224 },
{ "nshortparalle", 0x02226 },
{ "nsim", 0x02241 },
{ "nsime", 0x02244 },
{ "nsimeq", 0x02244 },
{ "nsmid", 0x02224 },
{ "nspar", 0x02226 },
{ "nsqsube", 0x022E2 },
{ "nsqsupe", 0x022E3 },
{ "nsub", 0x02284 },
{ "nsube", 0x02288 },
{ "nsubseteq", 0x02288 },
{ "nsucc", 0x02281 },
{ "nsup", 0x02285 },
{ "nsupe", 0x02289 },
{ "nsupseteq", 0x02289 },
{ "ntg", 0x02279 },
{ "ntilde", 0x000F1 },
{ "ntlg", 0x02278 },
{ "ntriangleleft", 0x022EA },
{ "ntrianglelefteq", 0x022EC },
{ "ntriangleright", 0x022EB },
{ "ntrianglerighteq", 0x022ED },
{ "nu", 0x003BD },
{ "num", 0x00023 },
{ "numero", 0x02116 },
{ "numsp", 0x02007 },
{ "nvDash", 0x022AD },
{ "nvHarr", 0x02904 },
{ "nvdash", 0x022AC },
{ "nvinfin", 0x029DE },
{ "nvlArr", 0x02902 },
{ "nvrArr", 0x02903 },
{ "nwArr", 0x021D6 },
{ "nwarhk", 0x02923 },
{ "nwarr", 0x02196 },
{ "nwarrow", 0x02196 },
{ "nwnear", 0x02927 },
{ "oS", 0x024C8 },
{ "oacute", 0x000F3 },
{ "oast", 0x0229B },
{ "ocir", 0x0229A },
{ "ocirc", 0x000F4 },
{ "ocy", 0x0043E },
{ "odash", 0x0229D },
{ "odblac", 0x00151 },
{ "odiv", 0x02A38 },
{ "odot", 0x02299 },
{ "odsold", 0x029BC },
{ "oelig", 0x00153 },
{ "ofcir", 0x029BF },
{ "ofr", 0x1D52C },
{ "ogon", 0x002DB },
{ "ograve", 0x000F2 },
{ "ogt", 0x029C1 },
{ "ohbar", 0x029B5 },
{ "ohm", 0x02126 },
{ "oint", 0x0222E },
{ "olarr", 0x021BA },
{ "olcir", 0x029BE },
{ "olcross", 0x029BB },
{ "oline", 0x0203E },
{ "olt", 0x029C0 },
{ "omacr", 0x0014D },
{ "omega", 0x003C9 },
{ "omicron", 0x003BF },
{ "omid", 0x029B6 },
{ "ominus", 0x02296 },
{ "oopf", 0x1D560 },
{ "opar", 0x029B7 },
{ "operp", 0x029B9 },
{ "oplus", 0x02295 },
{ "or", 0x02228 },
{ "orarr", 0x021BB },
{ "ord", 0x02A5D },
{ "order", 0x02134 },
{ "orderof", 0x02134 },
{ "ordf", 0x000AA },
{ "ordm", 0x000BA },
{ "origof", 0x022B6 },
{ "oror", 0x02A56 },
{ "orslope", 0x02A57 },
{ "orv", 0x02A5B },
{ "oscr", 0x02134 },
{ "oslash", 0x000F8 },
{ "oso", 0x02298 },
{ "otilde", 0x000F5 },
{ "otimes", 0x02297 },
{ "otimesas", 0x02A36 },
{ "oum", 0x000F6 },
{ "ovbar", 0x0233D },
{ "par", 0x02225 },
{ "para", 0x000B6 },
{ "paralle", 0x02225 },
{ "parsim", 0x02AF3 },
{ "pars", 0x02AFD },
{ "part", 0x02202 },
{ "pcy", 0x0043F },
{ "percnt", 0x00025 },
{ "period", 0x0002E },
{ "permi", 0x02030 },
{ "perp", 0x022A5 },
{ "pertenk", 0x02031 },
{ "pfr", 0x1D52D },
{ "phi", 0x003C6 },
{ "phiv", 0x003C6 },
{ "phmmat", 0x02133 },
{ "phone", 0x0260E },
{ "pi", 0x003C0 },
{ "pitchfork", 0x022D4 },
{ "piv", 0x003D6 },
{ "planck", 0x0210F },
{ "planckh", 0x0210E },
{ "plankv", 0x0210F },
{ "plus", 0x0002B },
{ "plusacir", 0x02A23 },
{ "plusb", 0x0229E },
{ "pluscir", 0x02A22 },
{ "plusdo", 0x02214 },
{ "plusdu", 0x02A25 },
{ "pluse", 0x02A72 },
{ "plusmn", 0x000B1 },
{ "plussim", 0x02A26 },
{ "plustwo", 0x02A27 },
{ "pm", 0x000B1 },
{ "pointint", 0x02A15 },
{ "popf", 0x1D561 },
{ "pound", 0x000A3 },
{ "pr", 0x0227A },
{ "prE", 0x02AB3 },
{ "prap", 0x02AB7 },
{ "prcue", 0x0227C },
{ "pre", 0x02AAF },
{ "prec", 0x0227A },
{ "precapprox", 0x02AB7 },
{ "preccurlyeq", 0x0227C },
{ "preceq", 0x02AAF },
{ "precnapprox", 0x02AB9 },
{ "precneqq", 0x02AB5 },
{ "precnsim", 0x022E8 },
{ "precsim", 0x0227E },
{ "prime", 0x02032 },
{ "primes", 0x02119 },
{ "prnE", 0x02AB5 },
{ "prnap", 0x02AB9 },
{ "prnsim", 0x022E8 },
{ "prod", 0x0220F },
{ "profalar", 0x0232E },
{ "profline", 0x02312 },
{ "profsurf", 0x02313 },
{ "prop", 0x0221D },
{ "propto", 0x0221D },
{ "prsim", 0x0227E },
{ "prure", 0x022B0 },
{ "pscr", 0x1D4C5 },
{ "psi", 0x003C8 },
{ "puncsp", 0x02008 },
{ "qfr", 0x1D52E },
{ "qint", 0x02A0C },
{ "qopf", 0x1D562 },
{ "qprime", 0x02057 },
{ "qscr", 0x1D4C6 },
{ "quaternions", 0x0210D },
{ "quatint", 0x02A16 },
{ "quest", 0x0003F },
{ "questeq", 0x0225F },
{ "quot", 0x00022 },
{ "rAarr", 0x021DB },
{ "rArr", 0x021D2 },
{ "rAtai", 0x0291C },
{ "rBarr", 0x0290F },
{ "rHar", 0x02964 },
{ "race", 0x029DA },
{ "racute", 0x00155 },
{ "radic", 0x0221A },
{ "raemptyv", 0x029B3 },
{ "rang", 0x027E9 },
{ "rangd", 0x02992 },
{ "range", 0x029A5 },
{ "rangle", 0x027E9 },
{ "raquo", 0x000BB },
{ "rarr", 0x02192 },
{ "rarrap", 0x02975 },
{ "rarrb", 0x021E5 },
{ "rarrbfs", 0x02920 },
{ "rarrc", 0x02933 },
{ "rarrfs", 0x0291E },
{ "rarrhk", 0x021AA },
{ "rarrlp", 0x021AC },
{ "rarrp", 0x02945 },
{ "rarrsim", 0x02974 },
{ "rarrt", 0x021A3 },
{ "rarrw", 0x0219D },
{ "ratai", 0x0291A },
{ "ratio", 0x02236 },
{ "rationals", 0x0211A },
{ "rbarr", 0x0290D },
{ "rbbrk", 0x02773 },
{ "rbrace", 0x0007D },
{ "rbrack", 0x0005D },
{ "rbrke", 0x0298C },
{ "rbrksld", 0x0298E },
{ "rbrkslu", 0x02990 },
{ "rcaron", 0x00159 },
{ "rcedi", 0x00157 },
{ "rcei", 0x02309 },
{ "rcub", 0x0007D },
{ "rcy", 0x00440 },
{ "rdca", 0x02937 },
{ "rdldhar", 0x02969 },
{ "rdquo", 0x0201D },
{ "rdquor", 0x0201D },
{ "rdsh", 0x021B3 },
{ "rea", 0x0211C },
{ "realine", 0x0211B },
{ "realpart", 0x0211C },
{ "reals", 0x0211D },
{ "rect", 0x025AD },
{ "reg", 0x000AE },
{ "rfisht", 0x0297D },
{ "rfloor", 0x0230B },
{ "rfr", 0x1D52F },
{ "rhard", 0x021C1 },
{ "rharu", 0x021C0 },
{ "rharu", 0x0296C },
{ "rho", 0x003C1 },
{ "rhov", 0x003F1 },
{ "rightarrow", 0x02192 },
{ "rightarrowtai", 0x021A3 },
{ "rightharpoondown", 0x021C1 },
{ "rightharpoonup", 0x021C0 },
{ "rightleftarrows", 0x021C4 },
{ "rightleftharpoons", 0x021CC },
{ "rightrightarrows", 0x021C9 },
{ "rightsquigarrow", 0x0219D },
{ "rightthreetimes", 0x022CC },
{ "ring", 0x002DA },
{ "risingdotseq", 0x02253 },
{ "rlarr", 0x021C4 },
{ "rlhar", 0x021CC },
{ "rlm", 0x0200F },
{ "rmoust", 0x023B1 },
{ "rmoustache", 0x023B1 },
{ "rnmid", 0x02AEE },
{ "roang", 0x027ED },
{ "roarr", 0x021FE },
{ "robrk", 0x027E7 },
{ "ropar", 0x02986 },
{ "ropf", 0x1D563 },
{ "roplus", 0x02A2E },
{ "rotimes", 0x02A35 },
{ "rpar", 0x00029 },
{ "rpargt", 0x02994 },
{ "rppolint", 0x02A12 },
{ "rrarr", 0x021C9 },
{ "rsaquo", 0x0203A },
{ "rscr", 0x1D4C7 },
{ "rsh", 0x021B1 },
{ "rsqb", 0x0005D },
{ "rsquo", 0x02019 },
{ "rsquor", 0x02019 },
{ "rthree", 0x022CC },
{ "rtimes", 0x022CA },
{ "rtri", 0x025B9 },
{ "rtrie", 0x022B5 },
{ "rtrif", 0x025B8 },
{ "rtriltri", 0x029CE },
{ "ruluhar", 0x02968 },
{ "rx", 0x0211E },
{ "sacute", 0x0015B },
{ "sbquo", 0x0201A },
{ "sc", 0x0227B },
{ "scE", 0x02AB4 },
{ "scap", 0x02AB8 },
{ "scaron", 0x00161 },
{ "sccue", 0x0227D },
{ "sce", 0x02AB0 },
{ "scedi", 0x0015F },
{ "scirc", 0x0015D },
{ "scnE", 0x02AB6 },
{ "scnap", 0x02ABA },
{ "scnsim", 0x022E9 },
{ "scpolint", 0x02A13 },
{ "scsim", 0x0227F },
{ "scy", 0x00441 },
{ "sdot", 0x022C5 },
{ "sdotb", 0x022A1 },
{ "sdote", 0x02A66 },
{ "seArr", 0x021D8 },
{ "searhk", 0x02925 },
{ "searr", 0x02198 },
{ "searrow", 0x02198 },
{ "sect", 0x000A7 },
{ "semi", 0x0003B },
{ "seswar", 0x02929 },
{ "setminus", 0x02216 },
{ "setmn", 0x02216 },
{ "sext", 0x02736 },
{ "sfr", 0x1D530 },
{ "sfrown", 0x02322 },
{ "sharp", 0x0266F },
{ "shchcy", 0x00449 },
{ "shcy", 0x00448 },
{ "shortmid", 0x02223 },
{ "shortparalle", 0x02225 },
{ "shy", 0x000AD },
{ "sigma", 0x003C3 },
{ "sigmaf", 0x003C2 },
{ "sigmav", 0x003C2 },
{ "sim", 0x0223C },
{ "simdot", 0x02A6A },
{ "sime", 0x02243 },
{ "simeq", 0x02243 },
{ "simg", 0x02A9E },
{ "simgE", 0x02AA0 },
{ "sim", 0x02A9D },
{ "simlE", 0x02A9F },
{ "simne", 0x02246 },
{ "simplus", 0x02A24 },
{ "simrarr", 0x02972 },
{ "slarr", 0x02190 },
{ "smallsetminus", 0x02216 },
{ "smashp", 0x02A33 },
{ "smepars", 0x029E4 },
{ "smid", 0x02223 },
{ "smile", 0x02323 },
{ "smt", 0x02AAA },
{ "smte", 0x02AAC },
{ "softcy", 0x0044C },
{ "so", 0x0002F },
{ "solb", 0x029C4 },
{ "solbar", 0x0233F },
{ "sopf", 0x1D564 },
{ "spades", 0x02660 },
{ "spadesuit", 0x02660 },
{ "spar", 0x02225 },
{ "sqcap", 0x02293 },
{ "sqcup", 0x02294 },
{ "sqsub", 0x0228F },
{ "sqsube", 0x02291 },
{ "sqsubset", 0x0228F },
{ "sqsubseteq", 0x02291 },
{ "sqsup", 0x02290 },
{ "sqsupe", 0x02292 },
{ "sqsupset", 0x02290 },
{ "sqsupseteq", 0x02292 },
{ "squ", 0x025A1 },
{ "square", 0x025A1 },
{ "squarf", 0x025AA },
{ "squf", 0x025AA },
{ "srarr", 0x02192 },
{ "sscr", 0x1D4C8 },
{ "ssetmn", 0x02216 },
{ "ssmile", 0x02323 },
{ "sstarf", 0x022C6 },
{ "star", 0x02606 },
{ "starf", 0x02605 },
{ "straightepsilon", 0x003F5 },
{ "straightphi", 0x003D5 },
{ "strns", 0x000AF },
{ "sub", 0x02282 },
{ "subE", 0x02AC5 },
{ "subdot", 0x02ABD },
{ "sube", 0x02286 },
{ "subedot", 0x02AC3 },
{ "submult", 0x02AC1 },
{ "subnE", 0x02ACB },
{ "subne", 0x0228A },
{ "subplus", 0x02ABF },
{ "subrarr", 0x02979 },
{ "subset", 0x02282 },
{ "subseteq", 0x02286 },
{ "subseteqq", 0x02AC5 },
{ "subsetneq", 0x0228A },
{ "subsetneqq", 0x02ACB },
{ "subsim", 0x02AC7 },
{ "subsub", 0x02AD5 },
{ "subsup", 0x02AD3 },
{ "succ", 0x0227B },
{ "succapprox", 0x02AB8 },
{ "succcurlyeq", 0x0227D },
{ "succeq", 0x02AB0 },
{ "succnapprox", 0x02ABA },
{ "succneqq", 0x02AB6 },
{ "succnsim", 0x022E9 },
{ "succsim", 0x0227F },
{ "sum", 0x02211 },
{ "sung", 0x0266A },
{ "sup", 0x02283 },
{ "sup1", 0x000B9 },
{ "sup2", 0x000B2 },
{ "sup3", 0x000B3 },
{ "supE", 0x02AC6 },
{ "supdot", 0x02ABE },
{ "supdsub", 0x02AD8 },
{ "supe", 0x02287 },
{ "supedot", 0x02AC4 },
{ "suphsub", 0x02AD7 },
{ "suplarr", 0x0297B },
{ "supmult", 0x02AC2 },
{ "supnE", 0x02ACC },
{ "supne", 0x0228B },
{ "supplus", 0x02AC0 },
{ "supset", 0x02283 },
{ "supseteq", 0x02287 },
{ "supseteqq", 0x02AC6 },
{ "supsetneq", 0x0228B },
{ "supsetneqq", 0x02ACC },
{ "supsim", 0x02AC8 },
{ "supsub", 0x02AD4 },
{ "supsup", 0x02AD6 },
{ "swArr", 0x021D9 },
{ "swarhk", 0x02926 },
{ "swarr", 0x02199 },
{ "swarrow", 0x02199 },
{ "swnwar", 0x0292A },
{ "szlig", 0x000DF },
{ "target", 0x02316 },
{ "tau", 0x003C4 },
{ "tbrk", 0x023B4 },
{ "tcaron", 0x00165 },
{ "tcedi", 0x00163 },
{ "tcy", 0x00442 },
{ "tdot", 0x020DB },
{ "telrec", 0x02315 },
{ "tfr", 0x1D531 },
{ "there4", 0x02234 },
{ "therefore", 0x02234 },
{ "theta", 0x003B8 },
{ "thetasym", 0x003D1 },
{ "thetav", 0x003D1 },
{ "thickapprox", 0x02248 },
{ "thicksim", 0x0223C },
{ "thinsp", 0x02009 },
{ "thkap", 0x02248 },
{ "thksim", 0x0223C },
{ "thorn", 0x000FE },
{ "tilde", 0x002DC },
{ "times", 0x000D7 },
{ "timesb", 0x022A0 },
{ "timesbar", 0x02A31 },
{ "timesd", 0x02A30 },
{ "tint", 0x0222D },
{ "toea", 0x02928 },
{ "top", 0x022A4 },
{ "topbot", 0x02336 },
{ "topcir", 0x02AF1 },
{ "topf", 0x1D565 },
{ "topfork", 0x02ADA },
{ "tosa", 0x02929 },
{ "tprime", 0x02034 },
{ "trade", 0x02122 },
{ "triangle", 0x025B5 },
{ "triangledown", 0x025BF },
{ "triangleleft", 0x025C3 },
{ "trianglelefteq", 0x022B4 },
{ "triangleq", 0x0225C },
{ "triangleright", 0x025B9 },
{ "trianglerighteq", 0x022B5 },
{ "tridot", 0x025EC },
{ "trie", 0x0225C },
{ "triminus", 0x02A3A },
{ "triplus", 0x02A39 },
{ "trisb", 0x029CD },
{ "tritime", 0x02A3B },
{ "trpezium", 0x023E2 },
{ "tscr", 0x1D4C9 },
{ "tscy", 0x00446 },
{ "tshcy", 0x0045B },
{ "tstrok", 0x00167 },
{ "twixt", 0x0226C },
{ "twoheadleftarrow", 0x0219E },
{ "twoheadrightarrow", 0x021A0 },
{ "uArr", 0x021D1 },
{ "uHar", 0x02963 },
{ "uacute", 0x000FA },
{ "uarr", 0x02191 },
{ "ubrcy", 0x0045E },
{ "ubreve", 0x0016D },
{ "ucirc", 0x000FB },
{ "ucy", 0x00443 },
{ "udarr", 0x021C5 },
{ "udblac", 0x00171 },
{ "udhar", 0x0296E },
{ "ufisht", 0x0297E },
{ "ufr", 0x1D532 },
{ "ugrave", 0x000F9 },
{ "uhar", 0x021BF },
{ "uharr", 0x021BE },
{ "uhblk", 0x02580 },
{ "ulcorn", 0x0231C },
{ "ulcorner", 0x0231C },
{ "ulcrop", 0x0230F },
{ "ultri", 0x025F8 },
{ "umacr", 0x0016B },
{ "um", 0x000A8 },
{ "uogon", 0x00173 },
{ "uopf", 0x1D566 },
{ "uparrow", 0x02191 },
{ "updownarrow", 0x02195 },
{ "upharpoonleft", 0x021BF },
{ "upharpoonright", 0x021BE },
{ "uplus", 0x0228E },
{ "upsi", 0x003C5 },
{ "upsih", 0x003D2 },
{ "upsilon", 0x003C5 },
{ "upuparrows", 0x021C8 },
{ "urcorn", 0x0231D },
{ "urcorner", 0x0231D },
{ "urcrop", 0x0230E },
{ "uring", 0x0016F },
{ "urtri", 0x025F9 },
{ "uscr", 0x1D4CA },
{ "utdot", 0x022F0 },
{ "utilde", 0x00169 },
{ "utri", 0x025B5 },
{ "utrif", 0x025B4 },
{ "uuarr", 0x021C8 },
{ "uum", 0x000FC },
{ "uwangle", 0x029A7 },
{ "vArr", 0x021D5 },
{ "vBar", 0x02AE8 },
{ "vBarv", 0x02AE9 },
{ "vDash", 0x022A8 },
{ "vangrt", 0x0299C },
{ "varepsilon", 0x003B5 },
{ "varkappa", 0x003F0 },
{ "varnothing", 0x02205 },
{ "varphi", 0x003C6 },
{ "varpi", 0x003D6 },
{ "varpropto", 0x0221D },
{ "varr", 0x02195 },
{ "varrho", 0x003F1 },
{ "varsigma", 0x003C2 },
{ "vartheta", 0x003D1 },
{ "vartriangleleft", 0x022B2 },
{ "vartriangleright", 0x022B3 },
{ "vcy", 0x00432 },
{ "vdash", 0x022A2 },
{ "vee", 0x02228 },
{ "veebar", 0x022BB },
{ "veeeq", 0x0225A },
{ "vellip", 0x022EE },
{ "verbar", 0x0007C },
{ "vert", 0x0007C },
{ "vfr", 0x1D533 },
{ "vltri", 0x022B2 },
{ "vopf", 0x1D567 },
{ "vprop", 0x0221D },
{ "vrtri", 0x022B3 },
{ "vscr", 0x1D4CB },
{ "vzigzag", 0x0299A },
{ "wcirc", 0x00175 },
{ "wedbar", 0x02A5F },
{ "wedge", 0x02227 },
{ "wedgeq", 0x02259 },
{ "weierp", 0x02118 },
{ "wfr", 0x1D534 },
{ "wopf", 0x1D568 },
{ "wp", 0x02118 },
{ "wr", 0x02240 },
{ "wreath", 0x02240 },
{ "wscr", 0x1D4CC },
{ "xcap", 0x022C2 },
{ "xcirc", 0x025EF },
{ "xcup", 0x022C3 },
{ "xdtri", 0x025BD },
{ "xfr", 0x1D535 },
{ "xhArr", 0x027FA },
{ "xharr", 0x027F7 },
{ "xi", 0x003BE },
{ "xlArr", 0x027F8 },
{ "xlarr", 0x027F5 },
{ "xmap", 0x027FC },
{ "xnis", 0x022FB },
{ "xodot", 0x02A00 },
{ "xopf", 0x1D569 },
{ "xoplus", 0x02A01 },
{ "xotime", 0x02A02 },
{ "xrArr", 0x027F9 },
{ "xrarr", 0x027F6 },
{ "xscr", 0x1D4CD },
{ "xsqcup", 0x02A06 },
{ "xuplus", 0x02A04 },
{ "xutri", 0x025B3 },
{ "xvee", 0x022C1 },
{ "xwedge", 0x022C0 },
{ "yacute", 0x000FD },
{ "yacy", 0x0044F },
{ "ycirc", 0x00177 },
{ "ycy", 0x0044B },
{ "yen", 0x000A5 },
{ "yfr", 0x1D536 },
{ "yicy", 0x00457 },
{ "yopf", 0x1D56A },
{ "yscr", 0x1D4CE },
{ "yucy", 0x0044E },
{ "yum", 0x000FF },
{ "zacute", 0x0017A },
{ "zcaron", 0x0017E },
{ "zcy", 0x00437 },
{ "zdot", 0x0017C },
{ "zeetrf", 0x02128 },
{ "zeta", 0x003B6 },
{ "zfr", 0x1D537 },
{ "zhcy", 0x00436 },
{ "zigrarr", 0x021DD },
{ "zopf", 0x1D56B },
{ "zscr", 0x1D4CF },
{ "zwj", 0x0200D },
{ "zwnj", 0x0200C },
};
if (!name || name[0] == '\0') {
return -1;
}
const auto e = std::end(lookup_);
const auto i = std::lower_bound(std::begin(lookup_), e, name, Compare{});
if (i != e && strcmp((*i).name, name) == 0) {
return (*i).code;
}
return -1;
}
inline int HTMLEntityNameToCodePoint(const wchar_t* name) {
if (!name || name[0] == '\0') {
return -1;
}
char narrow[32];
// longest entity name : strlen("CounterClockwiseContourIntegral") == 31;
int i = 0;
for (; i < 31; ++i) {
const auto c = name[i];
if (c == '\0' || c < 0 || c >= 0x7F) {
break;
}
narrow[i] = static_cast<char>(name[i]);
}
if (name[i] != '\0') {
return -1;
}
narrow[i] = '\0';
return HTMLEntityNameToCodePoint(narrow);
}
template<typename Char>
inline int HTMLEntityToCodePoint(const Char* entity) {
if (!entity || entity[0] == L'\0') {
return -1;
}
while (*entity == '[' || *entity == '&') {
++entity;
}
if (*entity == '#') {
struct ToULong {
static auto Convert(
const wchar_t* s, wchar_t** endptr, int radix) {
return wcstoul(s, endptr, radix);
}
static auto Convert(
const char* s, char** endptr, int radix) {
return strtoul(s, endptr, radix);
}
};
++entity;
int radix = 10;
if (*entity == 'x') {
++entity;
radix = 16;
}
Char* end = nullptr;
const auto code = ToULong::Convert(entity, &end, radix);
if (end && *end == ';' && code <= 0x10FFFF) {
return static_cast<int>(code);
}
else {
return -1;
}
}
else {
static const size_t max_entity_length = 32;
Char buffer[max_entity_length + 1] = {};
for (size_t i = 0; i < max_entity_length; ++i) {
if (entity[i] == '\0' || entity[i] == ';') {
break;
}
buffer[i] = entity[i];
}
return HTMLEntityNameToCodePoint(buffer);
}
}
template<typename C>
struct HTMLEntityPatterns;
template<> struct HTMLEntityPatterns<char> {
static const std::regex pattern;
};
template<> struct HTMLEntityPatterns<wchar_t> {
static const std::wregex pattern;
};
const std::regex HTMLEntityPatterns<char>::pattern{
"&[a-zA-Z]+?;|"
"&#x[\\da-fA-F]+?;|"
"&#\\d+?;"
};
const std::wregex HTMLEntityPatterns<wchar_t>::pattern{
L"&[a-zA-Z]+?;|"
L"&#x[\\da-fA-F]+?;|"
L"&#\\d+?;"
};
template<typename InIt>
inline auto ConvertHTMLEntities(InIt first, InIt last) {
using C = std::decay<decltype(*first)>::type;
const auto& pattern = HTMLEntityPatterns<C>::pattern;
auto it = std::regex_iterator<InIt>(first, last, pattern);
auto end = std::regex_iterator<InIt>();
std::basic_string<C> result;
result.reserve(std::distance(first, last));
auto last_appended = first;
C temp[64] = {};
const size_t temp_capacity = _countof(temp);
for (; it != end; ++it) {
const auto& match = *it;
for (auto& sub : match) {
if (!sub.matched || sub.length() >= temp_capacity) {
continue;
}
auto z = std::copy(sub.first, sub.second, temp);
*z = '\0';
auto code = HTMLEntityToCodePoint(temp);
if (code >= 0 && code <= 0x10FFFF) {
auto utf = EncodeCodePointToUTF<C>(code);
result.append(last_appended, sub.first);
result.append(utf.encoded);
last_appended = sub.second;
break;
}
}
}
result.append(last_appended, last);
return result;
}
template<typename C>
inline auto ConvertHTMLEntities(const std::basic_string<C>& source) {
return ConvertHTMLEntities(source.cbegin(), source.cend());
}
inline auto ConvertHTMLEntities(const char* source) {
if (!source) return std::string{};
return ConvertHTMLEntities(source, source + strlen(source));
}
inline auto ConvertHTMLEntities(const wchar_t* source) {
if (!source) return std::wstring{};
return ConvertHTMLEntities(source, source + wcslen(source));
}
template <typename InIt>
inline auto UnescapeJsonString(InIt first, InIt last) {
using C = std::decay<decltype(*first)>::type;
auto replacement = [](auto c) -> C {
switch (c) {
case 'b': return '\b';
case 'f': return '\f';
case 'n': return '\n';
case 'r': return '\r';
case 't': return '\t';
default: return c;
}
};
struct CodePointConversion {
int codePoint = -1;
int advance = 0;
CodePointConversion(InIt first, InIt last) {
char temp[16];
size_t i = 0;
for (; i < 15 && first != last; ++i, ++first) {
auto c = *first;
if ((c >= '0' && c <= '9') ||
(c >= 'a' && c <= 'f') || (c >= 'A' && c <= 'F')) {
temp[i] = static_cast<char>(*first);
}
else {
break;
}
}
temp[i] = '\0';
char* end = nullptr;
auto result = strtoul(temp, &end, 16);
while (end - temp > 0 && result > 0x10FFFF) {
--end;
*end = '\0';
end = nullptr;
result = strtoul(temp, &end, 16);
}
codePoint = result;
advance = static_cast<int>(end - temp);
}
};
std::basic_string<C> result;
result.reserve(std::distance(first, last));
auto last_appended = first;
for (auto it = std::find(first, last, '\\'); it != last;) {
auto next = it;
++next;
if (next == last) {
break;
}
auto next_next = next;
++next_next;
auto c = *next;
switch (c) {
case '"': case '\\': case '/':
case 'b': case 'f': case 'n': case 'r': case 't':
result.append(last_appended, it);
result.push_back(replacement(c));
++next;
last_appended = next;
break;
case 'u':
if (next_next != last) {
auto cp = CodePointConversion{next_next, last};
if (cp.advance > 0 && cp.codePoint >= 0 && cp.codePoint <= 0x10FFFF) {
auto utf = EncodeCodePointToUTF<C>(cp.codePoint);
result.append(last_appended, it);
result.append(utf.encoded, utf.encoded + utf.length);
next = next_next;
std::advance(next, cp.advance);
last_appended = next;
}
}
break;
default:
break;
}
it = std::find(next, last, '\\');
}
result.append(last_appended, last);
return result;
}
template <typename Char>
inline auto UnescapeJsonString(const std::basic_string<Char>& source) {
return UnescapeJsonString(source.cbegin(), source.cend());
}
inline auto UnescapeJsonString(const char* source) {
if (!source) return std::string{};
return UnescapeJsonString(source, source + strlen(source));
}
inline auto UnescapeJsonString(const wchar_t* source) {
if (!source) return std::wstring{};
return UnescapeJsonString(source, source + wcslen(source));
}
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment