lib

entities.cc

00001 //
00002 // Created: Tue Aug 29 16:20:33 2006
00003 //      by: bynames.py
00004 //    from: byalpha.html
00005 //
00006 // WARNING! All changes made in this file will be lost!
00007 
00008 /* This file is part of the KDE project
00009    Copyright (C) 2006 Alfredo Beaumont Sainz <alfredo.beaumont@gmail.com>
00010 
00011    This library is free software; you can redistribute it and/or
00012    modify it under the terms of the GNU Library General Public
00013    License as published by the Free Software Foundation; either
00014    version 2 of the License, or (at your option) any later version.
00015  
00016    This library is distributed in the hope that it will be useful,
00017    but WITHOUT ANY WARRANTY; without even the implied warranty of
00018    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
00019    Library General Public License for more details.
00020  
00021    You should have received a copy of the GNU Library General Public License
00022    along with this library; see the file COPYING.LIB.  If not, write to
00023    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
00024  * Boston, MA 02110-1301, USA.
00025 */
00026 
00027 
00028 #include "entities.h"
00029 
00030 KFORMULA_NAMESPACE_BEGIN
00031 
00032 const entityMap entities[] = {
00033      {"AElig", 0x000C6} ,
00034      {"Aacute", 0x000C1} ,
00035      {"Abreve", 0x00102} ,
00036      {"Acirc", 0x000C2} ,
00037      {"Acy", 0x00410} ,
00038      {"Afr", 0x1D504} ,
00039      {"Agrave", 0x000C0} ,
00040      {"Amacr", 0x00100} ,
00041      {"And", 0x02A53} ,
00042      {"Aogon", 0x00104} ,
00043      {"Aopf", 0x1D538} ,
00044      {"ApplyFunction", 0x02061} ,
00045      {"Aring", 0x000C5} ,
00046      {"Ascr", 0x1D49C} ,
00047      {"Assign", 0x02254} ,
00048      {"Atilde", 0x000C3} ,
00049      {"Auml", 0x000C4} ,
00050      {"Backslash", 0x02216} ,
00051      {"Barv", 0x02AE7} ,
00052      {"Barwed", 0x02306} ,
00053      {"Bcy", 0x00411} ,
00054      {"Because", 0x02235} ,
00055      {"Bernoullis", 0x0212C} ,
00056      {"Bfr", 0x1D505} ,
00057      {"Bopf", 0x1D539} ,
00058      {"Breve", 0x002D8} ,
00059      {"Bscr", 0x0212C} ,
00060      {"Bumpeq", 0x0224E} ,
00061      {"CHcy", 0x00427} ,
00062      {"Cacute", 0x00106} ,
00063      {"Cap", 0x022D2} ,
00064      {"CapitalDifferentialD", 0x02145} ,
00065      {"Cayleys", 0x0212D} ,
00066      {"Ccaron", 0x0010C} ,
00067      {"Ccedil", 0x000C7} ,
00068      {"Ccirc", 0x00108} ,
00069      {"Cconint", 0x02230} ,
00070      {"Cdot", 0x0010A} ,
00071      {"Cedilla", 0x000B8} ,
00072      {"CenterDot", 0x000B7} ,
00073      {"Cfr", 0x0212D} ,
00074      {"CircleDot", 0x02299} ,
00075      {"CircleMinus", 0x02296} ,
00076      {"CirclePlus", 0x02295} ,
00077      {"CircleTimes", 0x02297} ,
00078      {"ClockwiseContourIntegral", 0x02232} ,
00079      {"CloseCurlyDoubleQuote", 0x0201D} ,
00080      {"CloseCurlyQuote", 0x02019} ,
00081      {"Colon", 0x02237} ,
00082      {"Colone", 0x02A74} ,
00083      {"Congruent", 0x02261} ,
00084      {"Conint", 0x0222F} ,
00085      {"ContourIntegral", 0x0222E} ,
00086      {"Copf", 0x02102} ,
00087      {"Coproduct", 0x02210} ,
00088      {"CounterClockwiseContourIntegral", 0x02233} ,
00089      {"Cross", 0x02A2F} ,
00090      {"Cscr", 0x1D49E} ,
00091      {"Cup", 0x022D3} ,
00092      {"CupCap", 0x0224D} ,
00093      {"DD", 0x02145} ,
00094      {"DDotrahd", 0x02911} ,
00095      {"DJcy", 0x00402} ,
00096      {"DScy", 0x00405} ,
00097      {"DZcy", 0x0040F} ,
00098      {"Dagger", 0x02021} ,
00099      {"Dagger", 0x02021} ,
00100      {"Darr", 0x021A1} ,
00101      {"Dashv", 0x02AE4} ,
00102      {"Dcaron", 0x0010E} ,
00103      {"Dcy", 0x00414} ,
00104      {"Del", 0x02207} ,
00105      {"Delta", 0x00394} ,
00106      {"Dfr", 0x1D507} ,
00107      {"DiacriticalAcute", 0x000B4} ,
00108      {"DiacriticalDot", 0x002D9} ,
00109      {"DiacriticalDoubleAcute", 0x002DD} ,
00110      {"DiacriticalGrave", 0x00060} ,
00111      {"DiacriticalTilde", 0x002DC} ,
00112      {"Diamond", 0x022C4} ,
00113      {"DifferentialD", 0x02146} ,
00114      {"Dopf", 0x1D53B} ,
00115      {"Dot", 0x000A8} ,
00116      {"DotDot", 0x020DC} ,
00117      {"DotEqual", 0x02250} ,
00118      {"DoubleContourIntegral", 0x0222F} ,
00119      {"DoubleDot", 0x000A8} ,
00120      {"DoubleDownArrow", 0x021D3} ,
00121      {"DoubleLeftArrow", 0x021D0} ,
00122      {"DoubleLeftRightArrow", 0x021D4} ,
00123      {"DoubleLeftTee", 0x02AE4} ,
00124      {"DoubleLongLeftArrow", 0x027F8} ,
00125      {"DoubleLongLeftRightArrow", 0x027FA} ,
00126      {"DoubleLongRightArrow", 0x027F9} ,
00127      {"DoubleRightArrow", 0x021D2} ,
00128      {"DoubleRightTee", 0x022A8} ,
00129      {"DoubleUpArrow", 0x021D1} ,
00130      {"DoubleUpDownArrow", 0x021D5} ,
00131      {"DoubleVerticalBar", 0x02225} ,
00132      {"DownArrow", 0x02193} ,
00133      {"DownArrowBar", 0x02913} ,
00134      {"DownArrowUpArrow", 0x021F5} ,
00135      {"DownBreve", 0x00311} ,
00136      {"DownLeftRightVector", 0x02950} ,
00137      {"DownLeftTeeVector", 0x0295E} ,
00138      {"DownLeftVector", 0x021BD} ,
00139      {"DownLeftVectorBar", 0x02956} ,
00140      {"DownRightTeeVector", 0x0295F} ,
00141      {"DownRightVector", 0x021C1} ,
00142      {"DownRightVectorBar", 0x02957} ,
00143      {"DownTee", 0x022A4} ,
00144      {"DownTeeArrow", 0x021A7} ,
00145      {"Downarrow", 0x021D3} ,
00146      {"Dscr", 0x1D49F} ,
00147      {"Dstrok", 0x00110} ,
00148      {"ENG", 0x0014A} ,
00149      {"ETH", 0x000D0} ,
00150      {"Eacute", 0x000C9} ,
00151      {"Ecaron", 0x0011A} ,
00152      {"Ecirc", 0x000CA} ,
00153      {"Ecy", 0x0042D} ,
00154      {"Edot", 0x00116} ,
00155      {"Efr", 0x1D508} ,
00156      {"Egrave", 0x000C8} ,
00157      {"Element", 0x02208} ,
00158      {"Emacr", 0x00112} ,
00159      {"EmptySmallSquare", 0x025FB} ,
00160      {"EmptyVerySmallSquare", 0x025AB} ,
00161      {"Eogon", 0x00118} ,
00162      {"Eopf", 0x1D53C} ,
00163      {"Equal", 0x02A75} ,
00164      {"EqualTilde", 0x02242} ,
00165      {"Equilibrium", 0x021CC} ,
00166      {"Escr", 0x02130} ,
00167      {"Esim", 0x02A73} ,
00168      {"Euml", 0x000CB} ,
00169      {"Exists", 0x02203} ,
00170      {"ExponentialE", 0x02147} ,
00171      {"Fcy", 0x00424} ,
00172      {"Ffr", 0x1D509} ,
00173      {"FilledSmallSquare", 0x025FC} ,
00174      {"FilledVerySmallSquare", 0x025AA} ,
00175      {"Fopf", 0x1D53D} ,
00176      {"ForAll", 0x02200} ,
00177      {"Fouriertrf", 0x02131} ,
00178      {"Fscr", 0x02131} ,
00179      {"GJcy", 0x00403} ,
00180      {"Gamma", 0x00393} ,
00181      {"Gammad", 0x003DC} ,
00182      {"Gbreve", 0x0011E} ,
00183      {"Gcedil", 0x00122} ,
00184      {"Gcirc", 0x0011C} ,
00185      {"Gcy", 0x00413} ,
00186      {"Gdot", 0x00120} ,
00187      {"Gfr", 0x1D50A} ,
00188      {"Gg", 0x022D9} ,
00189      {"Gopf", 0x1D53E} ,
00190      {"GreaterEqual", 0x02265} ,
00191      {"GreaterEqualLess", 0x022DB} ,
00192      {"GreaterFullEqual", 0x02267} ,
00193      {"GreaterGreater", 0x02AA2} ,
00194      {"GreaterLess", 0x02277} ,
00195      {"GreaterSlantEqual", 0x02A7E} ,
00196      {"GreaterTilde", 0x02273} ,
00197      {"Gscr", 0x1D4A2} ,
00198      {"Gt", 0x0226B} ,
00199      {"HARDcy", 0x0042A} ,
00200      {"Hacek", 0x002C7} ,
00201      {"Hat", 0x0005E} ,
00202      {"Hcirc", 0x00124} ,
00203      {"Hfr", 0x0210C} ,
00204      {"HilbertSpace", 0x0210B} ,
00205      {"Hopf", 0x0210D} ,
00206      {"HorizontalLine", 0x02500} ,
00207      {"Hscr", 0x0210B} ,
00208      {"Hstrok", 0x00126} ,
00209      {"HumpDownHump", 0x0224E} ,
00210      {"HumpEqual", 0x0224F} ,
00211      {"IEcy", 0x00415} ,
00212      {"IJlig", 0x00132} ,
00213      {"IOcy", 0x00401} ,
00214      {"Iacute", 0x000CD} ,
00215      {"Icirc", 0x000CE} ,
00216      {"Icy", 0x00418} ,
00217      {"Idot", 0x00130} ,
00218      {"Ifr", 0x02111} ,
00219      {"Igrave", 0x000CC} ,
00220      {"Im", 0x02111} ,
00221      {"Imacr", 0x0012A} ,
00222      {"ImaginaryI", 0x02148} ,
00223      {"Implies", 0x021D2} ,
00224      {"Int", 0x0222C} ,
00225      {"Integral", 0x0222B} ,
00226      {"Intersection", 0x022C2} ,
00227      {"InvisibleComma", 0x02063} ,
00228      {"InvisibleTimes", 0x02062} ,
00229      {"Iogon", 0x0012E} ,
00230      {"Iopf", 0x1D540} ,
00231      {"Iscr", 0x02110} ,
00232      {"Itilde", 0x00128} ,
00233      {"Iukcy", 0x00406} ,
00234      {"Iuml", 0x000CF} ,
00235      {"Jcirc", 0x00134} ,
00236      {"Jcy", 0x00419} ,
00237      {"Jfr", 0x1D50D} ,
00238      {"Jopf", 0x1D541} ,
00239      {"Jscr", 0x1D4A5} ,
00240      {"Jsercy", 0x00408} ,
00241      {"Jukcy", 0x00404} ,
00242      {"KHcy", 0x00425} ,
00243      {"KJcy", 0x0040C} ,
00244      {"Kcedil", 0x00136} ,
00245      {"Kcy", 0x0041A} ,
00246      {"Kfr", 0x1D50E} ,
00247      {"Kopf", 0x1D542} ,
00248      {"Kscr", 0x1D4A6} ,
00249      {"LJcy", 0x00409} ,
00250      {"Lacute", 0x00139} ,
00251      {"Lambda", 0x0039B} ,
00252      {"Lang", 0x0300A} ,
00253      {"Laplacetrf", 0x02112} ,
00254      {"Larr", 0x0219E} ,
00255      {"Lcaron", 0x0013D} ,
00256      {"Lcedil", 0x0013B} ,
00257      {"Lcy", 0x0041B} ,
00258      {"LeftAngleBracket", 0x02329} ,
00259      {"LeftArrow", 0x02190} ,
00260      {"LeftArrowBar", 0x021E4} ,
00261      {"LeftArrowRightArrow", 0x021C6} ,
00262      {"LeftCeiling", 0x02308} ,
00263      {"LeftDoubleBracket", 0x0301A} ,
00264      {"LeftDownTeeVector", 0x02961} ,
00265      {"LeftDownVector", 0x021C3} ,
00266      {"LeftDownVectorBar", 0x02959} ,
00267      {"LeftFloor", 0x0230A} ,
00268      {"LeftRightArrow", 0x02194} ,
00269      {"LeftRightVector", 0x0294E} ,
00270      {"LeftTee", 0x022A3} ,
00271      {"LeftTeeArrow", 0x021A4} ,
00272      {"LeftTeeVector", 0x0295A} ,
00273      {"LeftTriangle", 0x022B2} ,
00274      {"LeftTriangleBar", 0x029CF} ,
00275      {"LeftTriangleEqual", 0x022B4} ,
00276      {"LeftUpDownVector", 0x02951} ,
00277      {"LeftUpTeeVector", 0x02960} ,
00278      {"LeftUpVector", 0x021BF} ,
00279      {"LeftUpVectorBar", 0x02958} ,
00280      {"LeftVector", 0x021BC} ,
00281      {"LeftVectorBar", 0x02952} ,
00282      {"Leftarrow", 0x021D0} ,
00283      {"Leftrightarrow", 0x021D4} ,
00284      {"LessEqualGreater", 0x022DA} ,
00285      {"LessFullEqual", 0x02266} ,
00286      {"LessGreater", 0x02276} ,
00287      {"LessLess", 0x02AA1} ,
00288      {"LessSlantEqual", 0x02A7D} ,
00289      {"LessTilde", 0x02272} ,
00290      {"Lfr", 0x1D50F} ,
00291      {"Ll", 0x022D8} ,
00292      {"Lleftarrow", 0x021DA} ,
00293      {"Lmidot", 0x0013F} ,
00294      {"LongLeftArrow", 0x027F5} ,
00295      {"LongLeftRightArrow", 0x027F7} ,
00296      {"LongRightArrow", 0x027F6} ,
00297      {"Longleftarrow", 0x027F8} ,
00298      {"Longleftrightarrow", 0x027FA} ,
00299      {"Longrightarrow", 0x027F9} ,
00300      {"Lopf", 0x1D543} ,
00301      {"LowerLeftArrow", 0x02199} ,
00302      {"LowerRightArrow", 0x02198} ,
00303      {"Lscr", 0x02112} ,
00304      {"Lsh", 0x021B0} ,
00305      {"Lstrok", 0x00141} ,
00306      {"Lt", 0x0226A} ,
00307      {"Map", 0x02905} ,
00308      {"Mcy", 0x0041C} ,
00309      {"MediumSpace", 0x0205F} ,
00310      {"Mellintrf", 0x02133} ,
00311      {"Mfr", 0x1D510} ,
00312      {"MinusPlus", 0x02213} ,
00313      {"Mopf", 0x1D544} ,
00314      {"Mscr", 0x02133} ,
00315      {"NJcy", 0x0040A} ,
00316      {"Nacute", 0x00143} ,
00317      {"Ncaron", 0x00147} ,
00318      {"Ncedil", 0x00145} ,
00319      {"Ncy", 0x0041D} ,
00320      {"NegativeMediumSpace", 0x0200B} ,
00321      {"NegativeThickSpace", 0x0200B} ,
00322      {"NegativeThinSpace", 0x0200B} ,
00323      {"NegativeVeryThinSpace", 0x0200B} ,
00324      {"NestedGreaterGreater", 0x0226B} ,
00325      {"NestedLessLess", 0x0226A} ,
00326      {"NewLine", 0x0000A} ,
00327      {"Nfr", 0x1D511} ,
00328      {"NoBreak", 0x02060} ,
00329      {"NonBreakingSpace", 0x000A0} ,
00330      {"Nopf", 0x02115} ,
00331      {"Not", 0x02AEC} ,
00332      {"NotCongruent", 0x02262} ,
00333      {"NotCupCap", 0x0226D} ,
00334      {"NotDoubleVerticalBar", 0x02226} ,
00335      {"NotElement", 0x02209} ,
00336      {"NotEqual", 0x02260} ,
00337      {"NotExists", 0x02204} ,
00338      {"NotGreater", 0x0226F} ,
00339      {"NotGreaterEqual", 0x02271} ,
00340      {"NotGreaterLess", 0x02279} ,
00341      {"NotGreaterTilde", 0x02275} ,
00342      {"NotLeftTriangle", 0x022EA} ,
00343      {"NotLeftTriangleEqual", 0x022EC} ,
00344      {"NotLess", 0x0226E} ,
00345      {"NotLessEqual", 0x02270} ,
00346      {"NotLessGreater", 0x02278} ,
00347      {"NotLessTilde", 0x02274} ,
00348      {"NotPrecedes", 0x02280} ,
00349      {"NotPrecedesSlantEqual", 0x022E0} ,
00350      {"NotReverseElement", 0x0220C} ,
00351      {"NotRightTriangle", 0x022EB} ,
00352      {"NotRightTriangleEqual", 0x022ED} ,
00353      {"NotSquareSubsetEqual", 0x022E2} ,
00354      {"NotSquareSupersetEqual", 0x022E3} ,
00355      {"NotSubsetEqual", 0x02288} ,
00356      {"NotSucceeds", 0x02281} ,
00357      {"NotSucceedsSlantEqual", 0x022E1} ,
00358      {"NotSupersetEqual", 0x02289} ,
00359      {"NotTilde", 0x02241} ,
00360      {"NotTildeEqual", 0x02244} ,
00361      {"NotTildeFullEqual", 0x02247} ,
00362      {"NotTildeTilde", 0x02249} ,
00363      {"NotVerticalBar", 0x02224} ,
00364      {"Nscr", 0x1D4A9} ,
00365      {"Ntilde", 0x000D1} ,
00366      {"OElig", 0x00152} ,
00367      {"Oacute", 0x000D3} ,
00368      {"Ocirc", 0x000D4} ,
00369      {"Ocy", 0x0041E} ,
00370      {"Odblac", 0x00150} ,
00371      {"Ofr", 0x1D512} ,
00372      {"Ograve", 0x000D2} ,
00373      {"Omacr", 0x0014C} ,
00374      {"Omega", 0x003A9} ,
00375      {"Oopf", 0x1D546} ,
00376      {"OpenCurlyDoubleQuote", 0x0201C} ,
00377      {"OpenCurlyQuote", 0x02018} ,
00378      {"Or", 0x02A54} ,
00379      {"Oscr", 0x1D4AA} ,
00380      {"Oslash", 0x000D8} ,
00381      {"Otilde", 0x000D5} ,
00382      {"Otimes", 0x02A37} ,
00383      {"Ouml", 0x000D6} ,
00384      {"OverBar", 0x000AF} ,
00385      {"OverBrace", 0x0FE37} ,
00386      {"OverBracket", 0x023B4} ,
00387      {"OverParenthesis", 0x0FE35} ,
00388      {"PartialD", 0x02202} ,
00389      {"Pcy", 0x0041F} ,
00390      {"Pfr", 0x1D513} ,
00391      {"Phi", 0x003A6} ,
00392      {"Pi", 0x003A0} ,
00393      {"PlusMinus", 0x000B1} ,
00394      {"Poincareplane", 0x0210C} ,
00395      {"Popf", 0x02119} ,
00396      {"Pr", 0x02ABB} ,
00397      {"Precedes", 0x0227A} ,
00398      {"PrecedesEqual", 0x02AAF} ,
00399      {"PrecedesSlantEqual", 0x0227C} ,
00400      {"PrecedesTilde", 0x0227E} ,
00401      {"Prime", 0x02033} ,
00402      {"Product", 0x0220F} ,
00403      {"Proportion", 0x02237} ,
00404      {"Proportional", 0x0221D} ,
00405      {"Pscr", 0x1D4AB} ,
00406      {"Psi", 0x003A8} ,
00407      {"Qfr", 0x1D514} ,
00408      {"Qopf", 0x0211A} ,
00409      {"Qscr", 0x1D4AC} ,
00410      {"RBarr", 0x02910} ,
00411      {"Racute", 0x00154} ,
00412      {"Rang", 0x0300B} ,
00413      {"Rarr", 0x021A0} ,
00414      {"Rarrtl", 0x02916} ,
00415      {"Rcaron", 0x00158} ,
00416      {"Rcedil", 0x00156} ,
00417      {"Rcy", 0x00420} ,
00418      {"Re", 0x0211C} ,
00419      {"ReverseElement", 0x0220B} ,
00420      {"ReverseEquilibrium", 0x021CB} ,
00421      {"ReverseUpEquilibrium", 0x0296F} ,
00422      {"Rfr", 0x0211C} ,
00423      {"RightAngleBracket", 0x0232A} ,
00424      {"RightArrow", 0x02192} ,
00425      {"RightArrowBar", 0x021E5} ,
00426      {"RightArrowLeftArrow", 0x021C4} ,
00427      {"RightCeiling", 0x02309} ,
00428      {"RightDoubleBracket", 0x0301B} ,
00429      {"RightDownTeeVector", 0x0295D} ,
00430      {"RightDownVector", 0x021C2} ,
00431      {"RightDownVectorBar", 0x02955} ,
00432      {"RightFloor", 0x0230B} ,
00433      {"RightTee", 0x022A2} ,
00434      {"RightTeeArrow", 0x021A6} ,
00435      {"RightTeeVector", 0x0295B} ,
00436      {"RightTriangle", 0x022B3} ,
00437      {"RightTriangleBar", 0x029D0} ,
00438      {"RightTriangleEqual", 0x022B5} ,
00439      {"RightUpDownVector", 0x0294F} ,
00440      {"RightUpTeeVector", 0x0295C} ,
00441      {"RightUpVector", 0x021BE} ,
00442      {"RightUpVectorBar", 0x02954} ,
00443      {"RightVector", 0x021C0} ,
00444      {"RightVectorBar", 0x02953} ,
00445      {"Rightarrow", 0x021D2} ,
00446      {"Ropf", 0x0211D} ,
00447      {"RoundImplies", 0x02970} ,
00448      {"Rrightarrow", 0x021DB} ,
00449      {"Rscr", 0x0211B} ,
00450      {"Rsh", 0x021B1} ,
00451      {"RuleDelayed", 0x029F4} ,
00452      {"SHCHcy", 0x00429} ,
00453      {"SHcy", 0x00428} ,
00454      {"SOFTcy", 0x0042C} ,
00455      {"Sacute", 0x0015A} ,
00456      {"Sc", 0x02ABC} ,
00457      {"Scaron", 0x00160} ,
00458      {"Scedil", 0x0015E} ,
00459      {"Scirc", 0x0015C} ,
00460      {"Scy", 0x00421} ,
00461      {"Sfr", 0x1D516} ,
00462      {"ShortDownArrow", 0x02193} ,
00463      {"ShortLeftArrow", 0x02190} ,
00464      {"ShortRightArrow", 0x02192} ,
00465      {"ShortUpArrow", 0x02191} ,
00466      {"Sigma", 0x003A3} ,
00467      {"SmallCircle", 0x02218} ,
00468      {"Sopf", 0x1D54A} ,
00469      {"Sqrt", 0x0221A} ,
00470      {"Square", 0x025A1} ,
00471      {"SquareIntersection", 0x02293} ,
00472      {"SquareSubset", 0x0228F} ,
00473      {"SquareSubsetEqual", 0x02291} ,
00474      {"SquareSuperset", 0x02290} ,
00475      {"SquareSupersetEqual", 0x02292} ,
00476      {"SquareUnion", 0x02294} ,
00477      {"Sscr", 0x1D4AE} ,
00478      {"Star", 0x022C6} ,
00479      {"Sub", 0x022D0} ,
00480      {"Subset", 0x022D0} ,
00481      {"SubsetEqual", 0x02286} ,
00482      {"Succeeds", 0x0227B} ,
00483      {"SucceedsEqual", 0x02AB0} ,
00484      {"SucceedsSlantEqual", 0x0227D} ,
00485      {"SucceedsTilde", 0x0227F} ,
00486      {"SuchThat", 0x0220B} ,
00487      {"Sum", 0x02211} ,
00488      {"Sup", 0x022D1} ,
00489      {"Superset", 0x02283} ,
00490      {"SupersetEqual", 0x02287} ,
00491      {"Supset", 0x022D1} ,
00492      {"THORN", 0x000DE} ,
00493      {"TSHcy", 0x0040B} ,
00494      {"TScy", 0x00426} ,
00495      {"Tab", 0x00009} ,
00496      {"Tcaron", 0x00164} ,
00497      {"Tcedil", 0x00162} ,
00498      {"Tcy", 0x00422} ,
00499      {"Tfr", 0x1D517} ,
00500      {"Therefore", 0x02234} ,
00501      {"Theta", 0x00398} ,
00502      {"ThinSpace", 0x02009} ,
00503      {"Tilde", 0x0223C} ,
00504      {"TildeEqual", 0x02243} ,
00505      {"TildeFullEqual", 0x02245} ,
00506      {"TildeTilde", 0x02248} ,
00507      {"Topf", 0x1D54B} ,
00508      {"TripleDot", 0x020DB} ,
00509      {"Tscr", 0x1D4AF} ,
00510      {"Tstrok", 0x00166} ,
00511      {"Uacute", 0x000DA} ,
00512      {"Uarr", 0x0219F} ,
00513      {"Uarrocir", 0x02949} ,
00514      {"Ubrcy", 0x0040E} ,
00515      {"Ubreve", 0x0016C} ,
00516      {"Ucirc", 0x000DB} ,
00517      {"Ucy", 0x00423} ,
00518      {"Udblac", 0x00170} ,
00519      {"Ufr", 0x1D518} ,
00520      {"Ugrave", 0x000D9} ,
00521      {"Umacr", 0x0016A} ,
00522      {"UnderBar", 0x00332} ,
00523      {"UnderBrace", 0x0FE38} ,
00524      {"UnderBracket", 0x023B5} ,
00525      {"UnderParenthesis", 0x0FE36} ,
00526      {"Union", 0x022C3} ,
00527      {"UnionPlus", 0x0228E} ,
00528      {"Uogon", 0x00172} ,
00529      {"Uopf", 0x1D54C} ,
00530      {"UpArrow", 0x02191} ,
00531      {"UpArrowBar", 0x02912} ,
00532      {"UpArrowDownArrow", 0x021C5} ,
00533      {"UpDownArrow", 0x02195} ,
00534      {"UpEquilibrium", 0x0296E} ,
00535      {"UpTee", 0x022A5} ,
00536      {"UpTeeArrow", 0x021A5} ,
00537      {"Uparrow", 0x021D1} ,
00538      {"Updownarrow", 0x021D5} ,
00539      {"UpperLeftArrow", 0x02196} ,
00540      {"UpperRightArrow", 0x02197} ,
00541      {"Upsi", 0x003D2} ,
00542      {"Upsilon", 0x003A5} ,
00543      {"Uring", 0x0016E} ,
00544      {"Uscr", 0x1D4B0} ,
00545      {"Utilde", 0x00168} ,
00546      {"Uuml", 0x000DC} ,
00547      {"VDash", 0x022AB} ,
00548      {"Vbar", 0x02AEB} ,
00549      {"Vcy", 0x00412} ,
00550      {"Vdash", 0x022A9} ,
00551      {"Vdashl", 0x02AE6} ,
00552      {"Vee", 0x022C1} ,
00553      {"Verbar", 0x02016} ,
00554      {"Vert", 0x02016} ,
00555      {"VerticalBar", 0x02223} ,
00556      {"VerticalLine", 0x0007C} ,
00557      {"VerticalSeparator", 0x02758} ,
00558      {"VerticalTilde", 0x02240} ,
00559      {"VeryThinSpace", 0x0200A} ,
00560      {"Vfr", 0x1D519} ,
00561      {"Vopf", 0x1D54D} ,
00562      {"Vscr", 0x1D4B1} ,
00563      {"Vvdash", 0x022AA} ,
00564      {"Wcirc", 0x00174} ,
00565      {"Wedge", 0x022C0} ,
00566      {"Wfr", 0x1D51A} ,
00567      {"Wopf", 0x1D54E} ,
00568      {"Wscr", 0x1D4B2} ,
00569      {"Xfr", 0x1D51B} ,
00570      {"Xi", 0x0039E} ,
00571      {"Xopf", 0x1D54F} ,
00572      {"Xscr", 0x1D4B3} ,
00573      {"YAcy", 0x0042F} ,
00574      {"YIcy", 0x00407} ,
00575      {"YUcy", 0x0042E} ,
00576      {"Yacute", 0x000DD} ,
00577      {"Ycirc", 0x00176} ,
00578      {"Ycy", 0x0042B} ,
00579      {"Yfr", 0x1D51C} ,
00580      {"Yopf", 0x1D550} ,
00581      {"Yscr", 0x1D4B4} ,
00582      {"Yuml", 0x00178} ,
00583      {"ZHcy", 0x00416} ,
00584      {"Zacute", 0x00179} ,
00585      {"Zcaron", 0x0017D} ,
00586      {"Zcy", 0x00417} ,
00587      {"Zdot", 0x0017B} ,
00588      {"ZeroWidthSpace", 0x0200B} ,
00589      {"Zfr", 0x02128} ,
00590      {"Zopf", 0x02124} ,
00591      {"Zscr", 0x1D4B5} ,
00592      {"aacute", 0x000E1} ,
00593      {"abreve", 0x00103} ,
00594      {"ac", 0x0223E} ,
00595      {"acd", 0x0223F} ,
00596      {"acirc", 0x000E2} ,
00597      {"acute", 0x000B4} ,
00598      {"acy", 0x00430} ,
00599      {"aelig", 0x000E6} ,
00600      {"af", 0x02061} ,
00601      {"afr", 0x1D51E} ,
00602      {"agrave", 0x000E0} ,
00603      {"aleph", 0x02135} ,
00604      {"alpha", 0x003B1} ,
00605      {"amacr", 0x00101} ,
00606      {"amalg", 0x02A3F} ,
00607      {"amp", 0x00026} ,
00608      {"and", 0x02227} ,
00609      {"andand", 0x02A55} ,
00610      {"andd", 0x02A5C} ,
00611      {"andslope", 0x02A58} ,
00612      {"andv", 0x02A5A} ,
00613      {"ang", 0x02220} ,
00614      {"ange", 0x029A4} ,
00615      {"angle", 0x02220} ,
00616      {"angmsd", 0x02221} ,
00617      {"angmsdaa", 0x029A8} ,
00618      {"angmsdab", 0x029A9} ,
00619      {"angmsdac", 0x029AA} ,
00620      {"angmsdad", 0x029AB} ,
00621      {"angmsdae", 0x029AC} ,
00622      {"angmsdaf", 0x029AD} ,
00623      {"angmsdag", 0x029AE} ,
00624      {"angmsdah", 0x029AF} ,
00625      {"angrt", 0x0221F} ,
00626      {"angrtvb", 0x022BE} ,
00627      {"angrtvbd", 0x0299D} ,
00628      {"angsph", 0x02222} ,
00629      {"angst", 0x0212B} ,
00630      {"angzarr", 0x0237C} ,
00631      {"aogon", 0x00105} ,
00632      {"aopf", 0x1D552} ,
00633      {"ap", 0x02248} ,
00634      {"apE", 0x02A70} ,
00635      {"apacir", 0x02A6F} ,
00636      {"ape", 0x0224A} ,
00637      {"apid", 0x0224B} ,
00638      {"apos", 0x00027} ,
00639      {"approx", 0x02248} ,
00640      {"approxeq", 0x0224A} ,
00641      {"aring", 0x000E5} ,
00642      {"ascr", 0x1D4B6} ,
00643      {"ast", 0x0002A} ,
00644      {"asymp", 0x02248} ,
00645      {"asympeq", 0x0224D} ,
00646      {"atilde", 0x000E3} ,
00647      {"auml", 0x000E4} ,
00648      {"awconint", 0x02233} ,
00649      {"awint", 0x02A11} ,
00650      {"bNot", 0x02AED} ,
00651      {"backcong", 0x0224C} ,
00652      {"backepsilon", 0x003F6} ,
00653      {"backprime", 0x02035} ,
00654      {"backsim", 0x0223D} ,
00655      {"backsimeq", 0x022CD} ,
00656      {"barvee", 0x022BD} ,
00657      {"barwed", 0x02305} ,
00658      {"barwedge", 0x02305} ,
00659      {"bbrk", 0x023B5} ,
00660      {"bbrktbrk", 0x023B6} ,
00661      {"bcong", 0x0224C} ,
00662      {"bcy", 0x00431} ,
00663      {"becaus", 0x02235} ,
00664      {"because", 0x02235} ,
00665      {"bemptyv", 0x029B0} ,
00666      {"bepsi", 0x003F6} ,
00667      {"bernou", 0x0212C} ,
00668      {"beta", 0x003B2} ,
00669      {"beth", 0x02136} ,
00670      {"between", 0x0226C} ,
00671      {"bfr", 0x1D51F} ,
00672      {"bigcap", 0x022C2} ,
00673      {"bigcirc", 0x025EF} ,
00674      {"bigcup", 0x022C3} ,
00675      {"bigodot", 0x02A00} ,
00676      {"bigoplus", 0x02A01} ,
00677      {"bigotimes", 0x02A02} ,
00678      {"bigsqcup", 0x02A06} ,
00679      {"bigstar", 0x02605} ,
00680      {"bigtriangledown", 0x025BD} ,
00681      {"bigtriangleup", 0x025B3} ,
00682      {"biguplus", 0x02A04} ,
00683      {"bigvee", 0x022C1} ,
00684      {"bigwedge", 0x022C0} ,
00685      {"bkarow", 0x0290D} ,
00686      {"blacklozenge", 0x029EB} ,
00687      {"blacksquare", 0x025AA} ,
00688      {"blacktriangle", 0x025B4} ,
00689      {"blacktriangledown", 0x025BE} ,
00690      {"blacktriangleleft", 0x025C2} ,
00691      {"blacktriangleright", 0x025B8} ,
00692      {"blank", 0x02423} ,
00693      {"blk12", 0x02592} ,
00694      {"blk14", 0x02591} ,
00695      {"blk34", 0x02593} ,
00696      {"block", 0x02588} ,
00697      {"bnot", 0x02310} ,
00698      {"bopf", 0x1D553} ,
00699      {"bot", 0x022A5} ,
00700      {"bottom", 0x022A5} ,
00701      {"bowtie", 0x022C8} ,
00702      {"boxDL", 0x02557} ,
00703      {"boxDR", 0x02554} ,
00704      {"boxDl", 0x02556} ,
00705      {"boxDr", 0x02553} ,
00706      {"boxH", 0x02550} ,
00707      {"boxHD", 0x02566} ,
00708      {"boxHU", 0x02569} ,
00709      {"boxHd", 0x02564} ,
00710      {"boxHu", 0x02567} ,
00711      {"boxUL", 0x0255D} ,
00712      {"boxUR", 0x0255A} ,
00713      {"boxUl", 0x0255C} ,
00714      {"boxUr", 0x02559} ,
00715      {"boxV", 0x02551} ,
00716      {"boxVH", 0x0256C} ,
00717      {"boxVL", 0x02563} ,
00718      {"boxVR", 0x02560} ,
00719      {"boxVh", 0x0256B} ,
00720      {"boxVl", 0x02562} ,
00721      {"boxVr", 0x0255F} ,
00722      {"boxbox", 0x029C9} ,
00723      {"boxdL", 0x02555} ,
00724      {"boxdR", 0x02552} ,
00725      {"boxdl", 0x02510} ,
00726      {"boxdr", 0x0250C} ,
00727      {"boxh", 0x02500} ,
00728      {"boxhD", 0x02565} ,
00729      {"boxhU", 0x02568} ,
00730      {"boxhd", 0x0252C} ,
00731      {"boxhu", 0x02534} ,
00732      {"boxminus", 0x0229F} ,
00733      {"boxplus", 0x0229E} ,
00734      {"boxtimes", 0x022A0} ,
00735      {"boxuL", 0x0255B} ,
00736      {"boxuR", 0x02558} ,
00737      {"boxul", 0x02518} ,
00738      {"boxur", 0x02514} ,
00739      {"boxv", 0x02502} ,
00740      {"boxvH", 0x0256A} ,
00741      {"boxvL", 0x02561} ,
00742      {"boxvR", 0x0255E} ,
00743      {"boxvh", 0x0253C} ,
00744      {"boxvl", 0x02524} ,
00745      {"boxvr", 0x0251C} ,
00746      {"bprime", 0x02035} ,
00747      {"breve", 0x002D8} ,
00748      {"brvbar", 0x000A6} ,
00749      {"bscr", 0x1D4B7} ,
00750      {"bsemi", 0x0204F} ,
00751      {"bsim", 0x0223D} ,
00752      {"bsime", 0x022CD} ,
00753      {"bsol", 0x0005C} ,
00754      {"bsolb", 0x029C5} ,
00755      {"bull", 0x02022} ,
00756      {"bullet", 0x02022} ,
00757      {"bump", 0x0224E} ,
00758      {"bumpE", 0x02AAE} ,
00759      {"bumpe", 0x0224F} ,
00760      {"bumpeq", 0x0224F} ,
00761      {"cacute", 0x00107} ,
00762      {"cap", 0x02229} ,
00763      {"capand", 0x02A44} ,
00764      {"capbrcup", 0x02A49} ,
00765      {"capcap", 0x02A4B} ,
00766      {"capcup", 0x02A47} ,
00767      {"capdot", 0x02A40} ,
00768      {"caret", 0x02041} ,
00769      {"caron", 0x002C7} ,
00770      {"ccaps", 0x02A4D} ,
00771      {"ccaron", 0x0010D} ,
00772      {"ccedil", 0x000E7} ,
00773      {"ccirc", 0x00109} ,
00774      {"ccups", 0x02A4C} ,
00775      {"ccupssm", 0x02A50} ,
00776      {"cdot", 0x0010B} ,
00777      {"cedil", 0x000B8} ,
00778      {"cemptyv", 0x029B2} ,
00779      {"cent", 0x000A2} ,
00780      {"centerdot", 0x000B7} ,
00781      {"cfr", 0x1D520} ,
00782      {"chcy", 0x00447} ,
00783      {"check", 0x02713} ,
00784      {"checkmark", 0x02713} ,
00785      {"chi", 0x003C7} ,
00786      {"cir", 0x025CB} ,
00787      {"cirE", 0x029C3} ,
00788      {"circ", 0x002C6} ,
00789      {"circeq", 0x02257} ,
00790      {"circlearrowleft", 0x021BA} ,
00791      {"circlearrowright", 0x021BB} ,
00792      {"circledR", 0x000AE} ,
00793      {"circledS", 0x024C8} ,
00794      {"circledast", 0x0229B} ,
00795      {"circledcirc", 0x0229A} ,
00796      {"circleddash", 0x0229D} ,
00797      {"cire", 0x02257} ,
00798      {"cirfnint", 0x02A10} ,
00799      {"cirmid", 0x02AEF} ,
00800      {"cirscir", 0x029C2} ,
00801      {"clubs", 0x02663} ,
00802      {"clubsuit", 0x02663} ,
00803      {"colon", 0x0003A} ,
00804      {"colone", 0x02254} ,
00805      {"coloneq", 0x02254} ,
00806      {"comma", 0x0002C} ,
00807      {"commat", 0x00040} ,
00808      {"comp", 0x02201} ,
00809      {"compfn", 0x02218} ,
00810      {"complement", 0x02201} ,
00811      {"complexes", 0x02102} ,
00812      {"cong", 0x02245} ,
00813      {"congdot", 0x02A6D} ,
00814      {"conint", 0x0222E} ,
00815      {"copf", 0x1D554} ,
00816      {"coprod", 0x02210} ,
00817      {"copy", 0x000A9} ,
00818      {"copysr", 0x02117} ,
00819      {"cross", 0x02717} ,
00820      {"cscr", 0x1D4B8} ,
00821      {"csub", 0x02ACF} ,
00822      {"csube", 0x02AD1} ,
00823      {"csup", 0x02AD0} ,
00824      {"csupe", 0x02AD2} ,
00825      {"ctdot", 0x022EF} ,
00826      {"cudarrl", 0x02938} ,
00827      {"cudarrr", 0x02935} ,
00828      {"cuepr", 0x022DE} ,
00829      {"cuesc", 0x022DF} ,
00830      {"cularr", 0x021B6} ,
00831      {"cularrp", 0x0293D} ,
00832      {"cup", 0x0222A} ,
00833      {"cupbrcap", 0x02A48} ,
00834      {"cupcap", 0x02A46} ,
00835      {"cupcup", 0x02A4A} ,
00836      {"cupdot", 0x0228D} ,
00837      {"cupor", 0x02A45} ,
00838      {"curarr", 0x021B7} ,
00839      {"curarrm", 0x0293C} ,
00840      {"curlyeqprec", 0x022DE} ,
00841      {"curlyeqsucc", 0x022DF} ,
00842      {"curlyvee", 0x022CE} ,
00843      {"curlywedge", 0x022CF} ,
00844      {"curren", 0x000A4} ,
00845      {"curvearrowleft", 0x021B6} ,
00846      {"curvearrowright", 0x021B7} ,
00847      {"cuvee", 0x022CE} ,
00848      {"cuwed", 0x022CF} ,
00849      {"cwconint", 0x02232} ,
00850      {"cwint", 0x02231} ,
00851      {"cylcty", 0x0232D} ,
00852      {"dArr", 0x021D3} ,
00853      {"dHar", 0x02965} ,
00854      {"dagger", 0x02020} ,
00855      {"dagger", 0x02020} ,
00856      {"daleth", 0x02138} ,
00857      {"darr", 0x02193} ,
00858      {"dash", 0x02010} ,
00859      {"dashv", 0x022A3} ,
00860      {"dbkarow", 0x0290F} ,
00861      {"dblac", 0x002DD} ,
00862      {"dcaron", 0x0010F} ,
00863      {"dcy", 0x00434} ,
00864      {"dd", 0x02146} ,
00865      {"ddagger", 0x02021} ,
00866      {"ddarr", 0x021CA} ,
00867      {"ddotseq", 0x02A77} ,
00868      {"deg", 0x000B0} ,
00869      {"delta", 0x003B4} ,
00870      {"demptyv", 0x029B1} ,
00871      {"dfisht", 0x0297F} ,
00872      {"dfr", 0x1D521} ,
00873      {"dharl", 0x021C3} ,
00874      {"dharr", 0x021C2} ,
00875      {"diam", 0x022C4} ,
00876      {"diamond", 0x022C4} ,
00877      {"diamondsuit", 0x02666} ,
00878      {"diams", 0x02666} ,
00879      {"die", 0x000A8} ,
00880      {"digamma", 0x003DD} ,
00881      {"disin", 0x022F2} ,
00882      {"div", 0x000F7} ,
00883      {"divide", 0x000F7} ,
00884      {"divideontimes", 0x022C7} ,
00885      {"divonx", 0x022C7} ,
00886      {"djcy", 0x00452} ,
00887      {"dlcorn", 0x0231E} ,
00888      {"dlcrop", 0x0230D} ,
00889      {"dollar", 0x00024} ,
00890      {"dopf", 0x1D555} ,
00891      {"dot", 0x002D9} ,
00892      {"doteq", 0x02250} ,
00893      {"doteqdot", 0x02251} ,
00894      {"dotminus", 0x02238} ,
00895      {"dotplus", 0x02214} ,
00896      {"dotsquare", 0x022A1} ,
00897      {"doublebarwedge", 0x02306} ,
00898      {"downarrow", 0x02193} ,
00899      {"downdownarrows", 0x021CA} ,
00900      {"downharpoonleft", 0x021C3} ,
00901      {"downharpoonright", 0x021C2} ,
00902      {"drbkarow", 0x02910} ,
00903      {"drcorn", 0x0231F} ,
00904      {"drcrop", 0x0230C} ,
00905      {"dscr", 0x1D4B9} ,
00906      {"dscy", 0x00455} ,
00907      {"dsol", 0x029F6} ,
00908      {"dstrok", 0x00111} ,
00909      {"dtdot", 0x022F1} ,
00910      {"dtri", 0x025BF} ,
00911      {"dtrif", 0x025BE} ,
00912      {"duarr", 0x021F5} ,
00913      {"duhar", 0x0296F} ,
00914      {"dwangle", 0x029A6} ,
00915      {"dzcy", 0x0045F} ,
00916      {"dzigrarr", 0x027FF} ,
00917      {"eDDot", 0x02A77} ,
00918      {"eDot", 0x02251} ,
00919      {"eacute", 0x000E9} ,
00920      {"easter", 0x02A6E} ,
00921      {"ecaron", 0x0011B} ,
00922      {"ecir", 0x02256} ,
00923      {"ecirc", 0x000EA} ,
00924      {"ecolon", 0x02255} ,
00925      {"ecy", 0x0044D} ,
00926      {"edot", 0x00117} ,
00927      {"ee", 0x02147} ,
00928      {"efDot", 0x02252} ,
00929      {"efr", 0x1D522} ,
00930      {"eg", 0x02A9A} ,
00931      {"egrave", 0x000E8} ,
00932      {"egs", 0x02A96} ,
00933      {"egsdot", 0x02A98} ,
00934      {"el", 0x02A99} ,
00935      {"elinters", 0x0FFFD} ,
00936      {"ell", 0x02113} ,
00937      {"els", 0x02A95} ,
00938      {"elsdot", 0x02A97} ,
00939      {"emacr", 0x00113} ,
00940      {"empty", 0x02205} ,
00941      {"emptyset", 0x02205} ,
00942      {"emptyv", 0x02205} ,
00943      {"emsp", 0x02003} ,
00944      {"emsp13", 0x02004} ,
00945      {"emsp14", 0x02005} ,
00946      {"eng", 0x0014B} ,
00947      {"ensp", 0x02002} ,
00948      {"eogon", 0x00119} ,
00949      {"eopf", 0x1D556} ,
00950      {"epar", 0x022D5} ,
00951      {"eparsl", 0x029E3} ,
00952      {"eplus", 0x02A71} ,
00953      {"epsi", 0x003F5} ,
00954      {"epsiv", 0x003B5} ,
00955      {"eqcirc", 0x02256} ,
00956      {"eqcolon", 0x02255} ,
00957      {"eqsim", 0x02242} ,
00958      {"eqslantgtr", 0x02A96} ,
00959      {"eqslantless", 0x02A95} ,
00960      {"equals", 0x0003D} ,
00961      {"equest", 0x0225F} ,
00962      {"equiv", 0x02261} ,
00963      {"equivDD", 0x02A78} ,
00964      {"eqvparsl", 0x029E5} ,
00965      {"erDot", 0x02253} ,
00966      {"erarr", 0x02971} ,
00967      {"escr", 0x0212F} ,
00968      {"esdot", 0x02250} ,
00969      {"esim", 0x02242} ,
00970      {"eta", 0x003B7} ,
00971      {"eth", 0x000F0} ,
00972      {"euml", 0x000EB} ,
00973      {"excl", 0x00021} ,
00974      {"exist", 0x02203} ,
00975      {"expectation", 0x02130} ,
00976      {"exponentiale", 0x02147} ,
00977      {"fallingdotseq", 0x02252} ,
00978      {"fcy", 0x00444} ,
00979      {"female", 0x02640} ,
00980      {"ffilig", 0x0FB03} ,
00981      {"fflig", 0x0FB00} ,
00982      {"ffllig", 0x0FB04} ,
00983      {"ffr", 0x1D523} ,
00984      {"filig", 0x0FB01} ,
00985      {"flat", 0x0266D} ,
00986      {"fllig", 0x0FB02} ,
00987      {"fltns", 0x025B1} ,
00988      {"fnof", 0x00192} ,
00989      {"fopf", 0x1D557} ,
00990      {"forall", 0x02200} ,
00991      {"fork", 0x022D4} ,
00992      {"forkv", 0x02AD9} ,
00993      {"fpartint", 0x02A0D} ,
00994      {"frac12", 0x000BD} ,
00995      {"frac13", 0x02153} ,
00996      {"frac14", 0x000BC} ,
00997      {"frac15", 0x02155} ,
00998      {"frac16", 0x02159} ,
00999      {"frac18", 0x0215B} ,
01000      {"frac23", 0x02154} ,
01001      {"frac25", 0x02156} ,
01002      {"frac34", 0x000BE} ,
01003      {"frac35", 0x02157} ,
01004      {"frac38", 0x0215C} ,
01005      {"frac45", 0x02158} ,
01006      {"frac56", 0x0215A} ,
01007      {"frac58", 0x0215D} ,
01008      {"frac78", 0x0215E} ,
01009      {"frown", 0x02322} ,
01010      {"fscr", 0x1D4BB} ,
01011      {"gE", 0x02267} ,
01012      {"gEl", 0x02A8C} ,
01013      {"gacute", 0x001F5} ,
01014      {"gamma", 0x003B3} ,
01015      {"gammad", 0x003DD} ,
01016      {"gap", 0x02A86} ,
01017      {"gbreve", 0x0011F} ,
01018      {"gcirc", 0x0011D} ,
01019      {"gcy", 0x00433} ,
01020      {"gdot", 0x00121} ,
01021      {"ge", 0x02265} ,
01022      {"gel", 0x022DB} ,
01023      {"geq", 0x02265} ,
01024      {"geqq", 0x02267} ,
01025      {"geqslant", 0x02A7E} ,
01026      {"ges", 0x02A7E} ,
01027      {"gescc", 0x02AA9} ,
01028      {"gesdot", 0x02A80} ,
01029      {"gesdoto", 0x02A82} ,
01030      {"gesdotol", 0x02A84} ,
01031      {"gesles", 0x02A94} ,
01032      {"gfr", 0x1D524} ,
01033      {"gg", 0x0226B} ,
01034      {"ggg", 0x022D9} ,
01035      {"gimel", 0x02137} ,
01036      {"gjcy", 0x00453} ,
01037      {"gl", 0x02277} ,
01038      {"glE", 0x02A92} ,
01039      {"gla", 0x02AA5} ,
01040      {"glj", 0x02AA4} ,
01041      {"gnE", 0x02269} ,
01042      {"gnap", 0x02A8A} ,
01043      {"gnapprox", 0x02A8A} ,
01044      {"gne", 0x02A88} ,
01045      {"gneq", 0x02A88} ,
01046      {"gneqq", 0x02269} ,
01047      {"gnsim", 0x022E7} ,
01048      {"gopf", 0x1D558} ,
01049      {"grave", 0x00060} ,
01050      {"gscr", 0x0210A} ,
01051      {"gsim", 0x02273} ,
01052      {"gsime", 0x02A8E} ,
01053      {"gsiml", 0x02A90} ,
01054      {"gt", 0x0003E} ,
01055      {"gtcc", 0x02AA7} ,
01056      {"gtcir", 0x02A7A} ,
01057      {"gtdot", 0x022D7} ,
01058      {"gtlPar", 0x02995} ,
01059      {"gtquest", 0x02A7C} ,
01060      {"gtrapprox", 0x02A86} ,
01061      {"gtrarr", 0x02978} ,
01062      {"gtrdot", 0x022D7} ,
01063      {"gtreqless", 0x022DB} ,
01064      {"gtreqqless", 0x02A8C} ,
01065      {"gtrless", 0x02277} ,
01066      {"gtrsim", 0x02273} ,
01067      {"hArr", 0x021D4} ,
01068      {"hairsp", 0x0200A} ,
01069      {"half", 0x000BD} ,
01070      {"hamilt", 0x0210B} ,
01071      {"hardcy", 0x0044A} ,
01072      {"harr", 0x02194} ,
01073      {"harrcir", 0x02948} ,
01074      {"harrw", 0x021AD} ,
01075      {"hbar", 0x0210F} ,
01076      {"hcirc", 0x00125} ,
01077      {"hearts", 0x02665} ,
01078      {"heartsuit", 0x02665} ,
01079      {"hellip", 0x02026} ,
01080      {"hercon", 0x022B9} ,
01081      {"hfr", 0x1D525} ,
01082      {"hksearow", 0x02925} ,
01083      {"hkswarow", 0x02926} ,
01084      {"hoarr", 0x021FF} ,
01085      {"homtht", 0x0223B} ,
01086      {"hookleftarrow", 0x021A9} ,
01087      {"hookrightarrow", 0x021AA} ,
01088      {"hopf", 0x1D559} ,
01089      {"horbar", 0x02015} ,
01090      {"hscr", 0x1D4BD} ,
01091      {"hslash", 0x0210F} ,
01092      {"hstrok", 0x00127} ,
01093      {"hybull", 0x02043} ,
01094      {"hyphen", 0x02010} ,
01095      {"iacute", 0x000ED} ,
01096      {"ic", 0x02063} ,
01097      {"icirc", 0x000EE} ,
01098      {"icy", 0x00438} ,
01099      {"iecy", 0x00435} ,
01100      {"iexcl", 0x000A1} ,
01101      {"iff", 0x021D4} ,
01102      {"ifr", 0x1D526} ,
01103      {"igrave", 0x000EC} ,
01104      {"ii", 0x02148} ,
01105      {"iiiint", 0x02A0C} ,
01106      {"iiint", 0x0222D} ,
01107      {"iinfin", 0x029DC} ,
01108      {"iiota", 0x02129} ,
01109      {"ijlig", 0x00133} ,
01110      {"imacr", 0x0012B} ,
01111      {"image", 0x02111} ,
01112      {"imagline", 0x02110} ,
01113      {"imagpart", 0x02111} ,
01114      {"imath", 0x00131} ,
01115      {"imof", 0x022B7} ,
01116      {"imped", 0x001B5} ,
01117      {"in", 0x02208} ,
01118      {"incare", 0x02105} ,
01119      {"infin", 0x0221E} ,
01120      {"infintie", 0x029DD} ,
01121      {"inodot", 0x00131} ,
01122      {"int", 0x0222B} ,
01123      {"intcal", 0x022BA} ,
01124      {"integers", 0x02124} ,
01125      {"intercal", 0x022BA} ,
01126      {"intlarhk", 0x02A17} ,
01127      {"intprod", 0x02A3C} ,
01128      {"iocy", 0x00451} ,
01129      {"iogon", 0x0012F} ,
01130      {"iopf", 0x1D55A} ,
01131      {"iota", 0x003B9} ,
01132      {"iprod", 0x02A3C} ,
01133      {"iquest", 0x000BF} ,
01134      {"iscr", 0x1D4BE} ,
01135      {"isin", 0x02208} ,
01136      {"isinE", 0x022F9} ,
01137      {"isindot", 0x022F5} ,
01138      {"isins", 0x022F4} ,
01139      {"isinsv", 0x022F3} ,
01140      {"isinv", 0x02208} ,
01141      {"it", 0x02062} ,
01142      {"itilde", 0x00129} ,
01143      {"iukcy", 0x00456} ,
01144      {"iuml", 0x000EF} ,
01145      {"jcirc", 0x00135} ,
01146      {"jcy", 0x00439} ,
01147      {"jfr", 0x1D527} ,
01148      {"jmath", 0x0006A} ,
01149      {"jopf", 0x1D55B} ,
01150      {"jscr", 0x1D4BF} ,
01151      {"jsercy", 0x00458} ,
01152      {"jukcy", 0x00454} ,
01153      {"kappa", 0x003BA} ,
01154      {"kappav", 0x003F0} ,
01155      {"kcedil", 0x00137} ,
01156      {"kcy", 0x0043A} ,
01157      {"kfr", 0x1D528} ,
01158      {"kgreen", 0x00138} ,
01159      {"khcy", 0x00445} ,
01160      {"kjcy", 0x0045C} ,
01161      {"kopf", 0x1D55C} ,
01162      {"kscr", 0x1D4C0} ,
01163      {"lAarr", 0x021DA} ,
01164      {"lArr", 0x021D0} ,
01165      {"lAtail", 0x0291B} ,
01166      {"lBarr", 0x0290E} ,
01167      {"lE", 0x02266} ,
01168      {"lEg", 0x02A8B} ,
01169      {"lHar", 0x02962} ,
01170      {"lacute", 0x0013A} ,
01171      {"laemptyv", 0x029B4} ,
01172      {"lagran", 0x02112} ,
01173      {"lambda", 0x003BB} ,
01174      {"lang", 0x02329} ,
01175      {"langd", 0x02991} ,
01176      {"langle", 0x02329} ,
01177      {"lap", 0x02A85} ,
01178      {"laquo", 0x000AB} ,
01179      {"larr", 0x02190} ,
01180      {"larrb", 0x021E4} ,
01181      {"larrbfs", 0x0291F} ,
01182      {"larrfs", 0x0291D} ,
01183      {"larrhk", 0x021A9} ,
01184      {"larrlp", 0x021AB} ,
01185      {"larrpl", 0x02939} ,
01186      {"larrsim", 0x02973} ,
01187      {"larrtl", 0x021A2} ,
01188      {"lat", 0x02AAB} ,
01189      {"latail", 0x02919} ,
01190      {"late", 0x02AAD} ,
01191      {"lbarr", 0x0290C} ,
01192      {"lbbrk", 0x03014} ,
01193      {"lbrace", 0x0007B} ,
01194      {"lbrack", 0x0005B} ,
01195      {"lbrke", 0x0298B} ,
01196      {"lbrksld", 0x0298F} ,
01197      {"lbrkslu", 0x0298D} ,
01198      {"lcaron", 0x0013E} ,
01199      {"lcedil", 0x0013C} ,
01200      {"lceil", 0x02308} ,
01201      {"lcub", 0x0007B} ,
01202      {"lcy", 0x0043B} ,
01203      {"ldca", 0x02936} ,
01204      {"ldquo", 0x0201C} ,
01205      {"ldquor", 0x0201E} ,
01206      {"ldrdhar", 0x02967} ,
01207      {"ldrushar", 0x0294B} ,
01208      {"ldsh", 0x021B2} ,
01209      {"le", 0x02264} ,
01210      {"leftarrow", 0x02190} ,
01211      {"leftarrowtail", 0x021A2} ,
01212      {"leftharpoondown", 0x021BD} ,
01213      {"leftharpoonup", 0x021BC} ,
01214      {"leftleftarrows", 0x021C7} ,
01215      {"leftrightarrow", 0x02194} ,
01216      {"leftrightarrows", 0x021C6} ,
01217      {"leftrightharpoons", 0x021CB} ,
01218      {"leftrightsquigarrow", 0x021AD} ,
01219      {"leftthreetimes", 0x022CB} ,
01220      {"leg", 0x022DA} ,
01221      {"leq", 0x02264} ,
01222      {"leqq", 0x02266} ,
01223      {"leqslant", 0x02A7D} ,
01224      {"les", 0x02A7D} ,
01225      {"lescc", 0x02AA8} ,
01226      {"lesdot", 0x02A7F} ,
01227      {"lesdoto", 0x02A81} ,
01228      {"lesdotor", 0x02A83} ,
01229      {"lesges", 0x02A93} ,
01230      {"lessapprox", 0x02A85} ,
01231      {"lessdot", 0x022D6} ,
01232      {"lesseqgtr", 0x022DA} ,
01233      {"lesseqqgtr", 0x02A8B} ,
01234      {"lessgtr", 0x02276} ,
01235      {"lesssim", 0x02272} ,
01236      {"lfisht", 0x0297C} ,
01237      {"lfloor", 0x0230A} ,
01238      {"lfr", 0x1D529} ,
01239      {"lg", 0x02276} ,
01240      {"lgE", 0x02A91} ,
01241      {"lhard", 0x021BD} ,
01242      {"lharu", 0x021BC} ,
01243      {"lharul", 0x0296A} ,
01244      {"lhblk", 0x02584} ,
01245      {"ljcy", 0x00459} ,
01246      {"ll", 0x0226A} ,
01247      {"llarr", 0x021C7} ,
01248      {"llcorner", 0x0231E} ,
01249      {"llhard", 0x0296B} ,
01250      {"lltri", 0x025FA} ,
01251      {"lmidot", 0x00140} ,
01252      {"lmoust", 0x023B0} ,
01253      {"lmoustache", 0x023B0} ,
01254      {"lnE", 0x02268} ,
01255      {"lnap", 0x02A89} ,
01256      {"lnapprox", 0x02A89} ,
01257      {"lne", 0x02A87} ,
01258      {"lneq", 0x02A87} ,
01259      {"lneqq", 0x02268} ,
01260      {"lnsim", 0x022E6} ,
01261      {"loang", 0x03018} ,
01262      {"loarr", 0x021FD} ,
01263      {"lobrk", 0x0301A} ,
01264      {"longleftarrow", 0x027F5} ,
01265      {"longleftrightarrow", 0x027F7} ,
01266      {"longmapsto", 0x027FC} ,
01267      {"longrightarrow", 0x027F6} ,
01268      {"looparrowleft", 0x021AB} ,
01269      {"looparrowright", 0x021AC} ,
01270      {"lopar", 0x02985} ,
01271      {"lopf", 0x1D55D} ,
01272      {"loplus", 0x02A2D} ,
01273      {"lotimes", 0x02A34} ,
01274      {"lowast", 0x02217} ,
01275      {"lowbar", 0x0005F} ,
01276      {"loz", 0x025CA} ,
01277      {"lozenge", 0x025CA} ,
01278      {"lozf", 0x029EB} ,
01279      {"lpar", 0x00028} ,
01280      {"lparlt", 0x02993} ,
01281      {"lrarr", 0x021C6} ,
01282      {"lrcorner", 0x0231F} ,
01283      {"lrhar", 0x021CB} ,
01284      {"lrhard", 0x0296D} ,
01285      {"lrtri", 0x022BF} ,
01286      {"lscr", 0x1D4C1} ,
01287      {"lsh", 0x021B0} ,
01288      {"lsim", 0x02272} ,
01289      {"lsime", 0x02A8D} ,
01290      {"lsimg", 0x02A8F} ,
01291      {"lsqb", 0x0005B} ,
01292      {"lsquo", 0x02018} ,
01293      {"lsquor", 0x0201A} ,
01294      {"lstrok", 0x00142} ,
01295      {"lt", 0x0003C} ,
01296      {"ltcc", 0x02AA6} ,
01297      {"ltcir", 0x02A79} ,
01298      {"ltdot", 0x022D6} ,
01299      {"lthree", 0x022CB} ,
01300      {"ltimes", 0x022C9} ,
01301      {"ltlarr", 0x02976} ,
01302      {"ltquest", 0x02A7B} ,
01303      {"ltrPar", 0x02996} ,
01304      {"ltri", 0x025C3} ,
01305      {"ltrie", 0x022B4} ,
01306      {"ltrif", 0x025C2} ,
01307      {"lurdshar", 0x0294A} ,
01308      {"luruhar", 0x02966} ,
01309      {"mDDot", 0x0223A} ,
01310      {"macr", 0x000AF} ,
01311      {"male", 0x02642} ,
01312      {"malt", 0x02720} ,
01313      {"maltese", 0x02720} ,
01314      {"map", 0x021A6} ,
01315      {"mapsto", 0x021A6} ,
01316      {"mapstodown", 0x021A7} ,
01317      {"mapstoleft", 0x021A4} ,
01318      {"mapstoup", 0x021A5} ,
01319      {"marker", 0x025AE} ,
01320      {"mcomma", 0x02A29} ,
01321      {"mcy", 0x0043C} ,
01322      {"mdash", 0x02014} ,
01323      {"measuredangle", 0x02221} ,
01324      {"mfr", 0x1D52A} ,
01325      {"mho", 0x02127} ,
01326      {"micro", 0x000B5} ,
01327      {"mid", 0x02223} ,
01328      {"midast", 0x0002A} ,
01329      {"midcir", 0x02AF0} ,
01330      {"middot", 0x000B7} ,
01331      {"minus", 0x02212} ,
01332      {"minusb", 0x0229F} ,
01333      {"minusd", 0x02238} ,
01334      {"minusdu", 0x02A2A} ,
01335      {"mlcp", 0x02ADB} ,
01336      {"mldr", 0x02026} ,
01337      {"mnplus", 0x02213} ,
01338      {"models", 0x022A7} ,
01339      {"mopf", 0x1D55E} ,
01340      {"mp", 0x02213} ,
01341      {"mscr", 0x1D4C2} ,
01342      {"mstpos", 0x0223E} ,
01343      {"mu", 0x003BC} ,
01344      {"multimap", 0x022B8} ,
01345      {"mumap", 0x022B8} ,
01346      {"nLeftarrow", 0x021CD} ,
01347      {"nLeftrightarrow", 0x021CE} ,
01348      {"nRightarrow", 0x021CF} ,
01349      {"nVDash", 0x022AF} ,
01350      {"nVdash", 0x022AE} ,
01351      {"nabla", 0x02207} ,
01352      {"nacute", 0x00144} ,
01353      {"nap", 0x02249} ,
01354      {"napos", 0x00149} ,
01355      {"napprox", 0x02249} ,
01356      {"natur", 0x0266E} ,
01357      {"natural", 0x0266E} ,
01358      {"naturals", 0x02115} ,
01359      {"nbsp", 0x000A0} ,
01360      {"ncap", 0x02A43} ,
01361      {"ncaron", 0x00148} ,
01362      {"ncedil", 0x00146} ,
01363      {"ncong", 0x02247} ,
01364      {"ncup", 0x02A42} ,
01365      {"ncy", 0x0043D} ,
01366      {"ndash", 0x02013} ,
01367      {"ne", 0x02260} ,
01368      {"neArr", 0x021D7} ,
01369      {"nearhk", 0x02924} ,
01370      {"nearr", 0x02197} ,
01371      {"nearrow", 0x02197} ,
01372      {"nequiv", 0x02262} ,
01373      {"nesear", 0x02928} ,
01374      {"nexist", 0x02204} ,
01375      {"nexists", 0x02204} ,
01376      {"nfr", 0x1D52B} ,
01377      {"nge", 0x02271} ,
01378      {"ngeq", 0x02271} ,
01379      {"ngsim", 0x02275} ,
01380      {"ngt", 0x0226F} ,
01381      {"ngtr", 0x0226F} ,
01382      {"nhArr", 0x021CE} ,
01383      {"nharr", 0x021AE} ,
01384      {"nhpar", 0x02AF2} ,
01385      {"ni", 0x0220B} ,
01386      {"nis", 0x022FC} ,
01387      {"nisd", 0x022FA} ,
01388      {"niv", 0x0220B} ,
01389      {"njcy", 0x0045A} ,
01390      {"nlArr", 0x021CD} ,
01391      {"nlarr", 0x0219A} ,
01392      {"nldr", 0x02025} ,
01393      {"nle", 0x02270} ,
01394      {"nleftarrow", 0x0219A} ,
01395      {"nleftrightarrow", 0x021AE} ,
01396      {"nleq", 0x02270} ,
01397      {"nless", 0x0226E} ,
01398      {"nlsim", 0x02274} ,
01399      {"nlt", 0x0226E} ,
01400      {"nltri", 0x022EA} ,
01401      {"nltrie", 0x022EC} ,
01402      {"nmid", 0x02224} ,
01403      {"nopf", 0x1D55F} ,
01404      {"not", 0x000AC} ,
01405      {"notin", 0x02209} ,
01406      {"notinva", 0x02209} ,
01407      {"notinvb", 0x022F7} ,
01408      {"notinvc", 0x022F6} ,
01409      {"notni", 0x0220C} ,
01410      {"notniva", 0x0220C} ,
01411      {"notnivb", 0x022FE} ,
01412      {"notnivc", 0x022FD} ,
01413      {"npar", 0x02226} ,
01414      {"nparallel", 0x02226} ,
01415      {"npolint", 0x02A14} ,
01416      {"npr", 0x02280} ,
01417      {"nprcue", 0x022E0} ,
01418      {"nprec", 0x02280} ,
01419      {"nrArr", 0x021CF} ,
01420      {"nrarr", 0x0219B} ,
01421      {"nrightarrow", 0x0219B} ,
01422      {"nrtri", 0x022EB} ,
01423      {"nrtrie", 0x022ED} ,
01424      {"nsc", 0x02281} ,
01425      {"nsccue", 0x022E1} ,
01426      {"nscr", 0x1D4C3} ,
01427      {"nshortmid", 0x02224} ,
01428      {"nshortparallel", 0x02226} ,
01429      {"nsim", 0x02241} ,
01430      {"nsime", 0x02244} ,
01431      {"nsimeq", 0x02244} ,
01432      {"nsmid", 0x02224} ,
01433      {"nspar", 0x02226} ,
01434      {"nsqsube", 0x022E2} ,
01435      {"nsqsupe", 0x022E3} ,
01436      {"nsub", 0x02284} ,
01437      {"nsube", 0x02288} ,
01438      {"nsubseteq", 0x02288} ,
01439      {"nsucc", 0x02281} ,
01440      {"nsup", 0x02285} ,
01441      {"nsupe", 0x02289} ,
01442      {"nsupseteq", 0x02289} ,
01443      {"ntgl", 0x02279} ,
01444      {"ntilde", 0x000F1} ,
01445      {"ntlg", 0x02278} ,
01446      {"ntriangleleft", 0x022EA} ,
01447      {"ntrianglelefteq", 0x022EC} ,
01448      {"ntriangleright", 0x022EB} ,
01449      {"ntrianglerighteq", 0x022ED} ,
01450      {"nu", 0x003BD} ,
01451      {"num", 0x00023} ,
01452      {"numero", 0x02116} ,
01453      {"numsp", 0x02007} ,
01454      {"nvDash", 0x022AD} ,
01455      {"nvHarr", 0x02904} ,
01456      {"nvdash", 0x022AC} ,
01457      {"nvinfin", 0x029DE} ,
01458      {"nvlArr", 0x02902} ,
01459      {"nvrArr", 0x02903} ,
01460      {"nwArr", 0x021D6} ,
01461      {"nwarhk", 0x02923} ,
01462      {"nwarr", 0x02196} ,
01463      {"nwarrow", 0x02196} ,
01464      {"nwnear", 0x02927} ,
01465      {"oS", 0x024C8} ,
01466      {"oacute", 0x000F3} ,
01467      {"oast", 0x0229B} ,
01468      {"ocir", 0x0229A} ,
01469      {"ocirc", 0x000F4} ,
01470      {"ocy", 0x0043E} ,
01471      {"odash", 0x0229D} ,
01472      {"odblac", 0x00151} ,
01473      {"odiv", 0x02A38} ,
01474      {"odot", 0x02299} ,
01475      {"odsold", 0x029BC} ,
01476      {"oelig", 0x00153} ,
01477      {"ofcir", 0x029BF} ,
01478      {"ofr", 0x1D52C} ,
01479      {"ogon", 0x002DB} ,
01480      {"ograve", 0x000F2} ,
01481      {"ogt", 0x029C1} ,
01482      {"ohbar", 0x029B5} ,
01483      {"ohm", 0x02126} ,
01484      {"oint", 0x0222E} ,
01485      {"olarr", 0x021BA} ,
01486      {"olcir", 0x029BE} ,
01487      {"olcross", 0x029BB} ,
01488      {"olt", 0x029C0} ,
01489      {"omacr", 0x0014D} ,
01490      {"omega", 0x003C9} ,
01491      {"omid", 0x029B6} ,
01492      {"ominus", 0x02296} ,
01493      {"oopf", 0x1D560} ,
01494      {"opar", 0x029B7} ,
01495      {"operp", 0x029B9} ,
01496      {"oplus", 0x02295} ,
01497      {"or", 0x02228} ,
01498      {"orarr", 0x021BB} ,
01499      {"ord", 0x02A5D} ,
01500      {"order", 0x02134} ,
01501      {"orderof", 0x02134} ,
01502      {"ordf", 0x000AA} ,
01503      {"ordm", 0x000BA} ,
01504      {"origof", 0x022B6} ,
01505      {"oror", 0x02A56} ,
01506      {"orslope", 0x02A57} ,
01507      {"orv", 0x02A5B} ,
01508      {"oscr", 0x02134} ,
01509      {"oslash", 0x000F8} ,
01510      {"osol", 0x02298} ,
01511      {"otilde", 0x000F5} ,
01512      {"otimes", 0x02297} ,
01513      {"otimesas", 0x02A36} ,
01514      {"ouml", 0x000F6} ,
01515      {"ovbar", 0x0233D} ,
01516      {"par", 0x02225} ,
01517      {"para", 0x000B6} ,
01518      {"parallel", 0x02225} ,
01519      {"parsim", 0x02AF3} ,
01520      {"parsl", 0x02AFD} ,
01521      {"part", 0x02202} ,
01522      {"pcy", 0x0043F} ,
01523      {"percnt", 0x00025} ,
01524      {"period", 0x0002E} ,
01525      {"permil", 0x02030} ,
01526      {"perp", 0x022A5} ,
01527      {"pertenk", 0x02031} ,
01528      {"pfr", 0x1D52D} ,
01529      {"phi", 0x003D5} ,
01530      {"phiv", 0x003C6} ,
01531      {"phmmat", 0x02133} ,
01532      {"phone", 0x0260E} ,
01533      {"pi", 0x003C0} ,
01534      {"pitchfork", 0x022D4} ,
01535      {"piv", 0x003D6} ,
01536      {"planck", 0x0210F} ,
01537      {"planckh", 0x0210E} ,
01538      {"plankv", 0x0210F} ,
01539      {"plus", 0x0002B} ,
01540      {"plusacir", 0x02A23} ,
01541      {"plusb", 0x0229E} ,
01542      {"pluscir", 0x02A22} ,
01543      {"plusdo", 0x02214} ,
01544      {"plusdu", 0x02A25} ,
01545      {"pluse", 0x02A72} ,
01546      {"plusmn", 0x000B1} ,
01547      {"plussim", 0x02A26} ,
01548      {"plustwo", 0x02A27} ,
01549      {"pm", 0x000B1} ,
01550      {"pointint", 0x02A15} ,
01551      {"popf", 0x1D561} ,
01552      {"pound", 0x000A3} ,
01553      {"pr", 0x0227A} ,
01554      {"prE", 0x02AB3} ,
01555      {"prap", 0x02AB7} ,
01556      {"prcue", 0x0227C} ,
01557      {"pre", 0x02AAF} ,
01558      {"prec", 0x0227A} ,
01559      {"precapprox", 0x02AB7} ,
01560      {"preccurlyeq", 0x0227C} ,
01561      {"preceq", 0x02AAF} ,
01562      {"precnapprox", 0x02AB9} ,
01563      {"precneqq", 0x02AB5} ,
01564      {"precnsim", 0x022E8} ,
01565      {"precsim", 0x0227E} ,
01566      {"prime", 0x02032} ,
01567      {"primes", 0x02119} ,
01568      {"prnE", 0x02AB5} ,
01569      {"prnap", 0x02AB9} ,
01570      {"prnsim", 0x022E8} ,
01571      {"prod", 0x0220F} ,
01572      {"profalar", 0x0232E} ,
01573      {"profline", 0x02312} ,
01574      {"profsurf", 0x02313} ,
01575      {"prop", 0x0221D} ,
01576      {"propto", 0x0221D} ,
01577      {"prsim", 0x0227E} ,
01578      {"prurel", 0x022B0} ,
01579      {"pscr", 0x1D4C5} ,
01580      {"psi", 0x003C8} ,
01581      {"puncsp", 0x02008} ,
01582      {"qfr", 0x1D52E} ,
01583      {"qint", 0x02A0C} ,
01584      {"qopf", 0x1D562} ,
01585      {"qprime", 0x02057} ,
01586      {"qscr", 0x1D4C6} ,
01587      {"quaternions", 0x0210D} ,
01588      {"quatint", 0x02A16} ,
01589      {"quest", 0x0003F} ,
01590      {"questeq", 0x0225F} ,
01591      {"quot", 0x00022} ,
01592      {"rAarr", 0x021DB} ,
01593      {"rArr", 0x021D2} ,
01594      {"rAtail", 0x0291C} ,
01595      {"rBarr", 0x0290F} ,
01596      {"rHar", 0x02964} ,
01597      {"race", 0x029DA} ,
01598      {"racute", 0x00155} ,
01599      {"radic", 0x0221A} ,
01600      {"raemptyv", 0x029B3} ,
01601      {"rang", 0x0232A} ,
01602      {"rangd", 0x02992} ,
01603      {"range", 0x029A5} ,
01604      {"rangle", 0x0232A} ,
01605      {"raquo", 0x000BB} ,
01606      {"rarr", 0x02192} ,
01607      {"rarrap", 0x02975} ,
01608      {"rarrb", 0x021E5} ,
01609      {"rarrbfs", 0x02920} ,
01610      {"rarrc", 0x02933} ,
01611      {"rarrfs", 0x0291E} ,
01612      {"rarrhk", 0x021AA} ,
01613      {"rarrlp", 0x021AC} ,
01614      {"rarrpl", 0x02945} ,
01615      {"rarrsim", 0x02974} ,
01616      {"rarrtl", 0x021A3} ,
01617      {"rarrw", 0x0219D} ,
01618      {"ratail", 0x0291A} ,
01619      {"ratio", 0x02236} ,
01620      {"rationals", 0x0211A} ,
01621      {"rbarr", 0x0290D} ,
01622      {"rbbrk", 0x03015} ,
01623      {"rbrace", 0x0007D} ,
01624      {"rbrack", 0x0005D} ,
01625      {"rbrke", 0x0298C} ,
01626      {"rbrksld", 0x0298E} ,
01627      {"rbrkslu", 0x02990} ,
01628      {"rcaron", 0x00159} ,
01629      {"rcedil", 0x00157} ,
01630      {"rceil", 0x02309} ,
01631      {"rcub", 0x0007D} ,
01632      {"rcy", 0x00440} ,
01633      {"rdca", 0x02937} ,
01634      {"rdldhar", 0x02969} ,
01635      {"rdquo", 0x0201D} ,
01636      {"rdquor", 0x0201D} ,
01637      {"rdsh", 0x021B3} ,
01638      {"real", 0x0211C} ,
01639      {"realine", 0x0211B} ,
01640      {"realpart", 0x0211C} ,
01641      {"reals", 0x0211D} ,
01642      {"rect", 0x025AD} ,
01643      {"reg", 0x000AE} ,
01644      {"rfisht", 0x0297D} ,
01645      {"rfloor", 0x0230B} ,
01646      {"rfr", 0x1D52F} ,
01647      {"rhard", 0x021C1} ,
01648      {"rharu", 0x021C0} ,
01649      {"rharul", 0x0296C} ,
01650      {"rho", 0x003C1} ,
01651      {"rhov", 0x003F1} ,
01652      {"rightarrow", 0x02192} ,
01653      {"rightarrowtail", 0x021A3} ,
01654      {"rightharpoondown", 0x021C1} ,
01655      {"rightharpoonup", 0x021C0} ,
01656      {"rightleftarrows", 0x021C4} ,
01657      {"rightleftharpoons", 0x021CC} ,
01658      {"rightrightarrows", 0x021C9} ,
01659      {"rightsquigarrow", 0x0219D} ,
01660      {"rightthreetimes", 0x022CC} ,
01661      {"ring", 0x002DA} ,
01662      {"risingdotseq", 0x02253} ,
01663      {"rlarr", 0x021C4} ,
01664      {"rlhar", 0x021CC} ,
01665      {"rmoust", 0x023B1} ,
01666      {"rmoustache", 0x023B1} ,
01667      {"rnmid", 0x02AEE} ,
01668      {"roang", 0x03019} ,
01669      {"roarr", 0x021FE} ,
01670      {"robrk", 0x0301B} ,
01671      {"ropar", 0x02986} ,
01672      {"ropf", 0x1D563} ,
01673      {"roplus", 0x02A2E} ,
01674      {"rotimes", 0x02A35} ,
01675      {"rpar", 0x00029} ,
01676      {"rpargt", 0x02994} ,
01677      {"rppolint", 0x02A12} ,
01678      {"rrarr", 0x021C9} ,
01679      {"rscr", 0x1D4C7} ,
01680      {"rsh", 0x021B1} ,
01681      {"rsqb", 0x0005D} ,
01682      {"rsquo", 0x02019} ,
01683      {"rsquor", 0x02019} ,
01684      {"rthree", 0x022CC} ,
01685      {"rtimes", 0x022CA} ,
01686      {"rtri", 0x025B9} ,
01687      {"rtrie", 0x022B5} ,
01688      {"rtrif", 0x025B8} ,
01689      {"rtriltri", 0x029CE} ,
01690      {"ruluhar", 0x02968} ,
01691      {"rx", 0x0211E} ,
01692      {"sacute", 0x0015B} ,
01693      {"sc", 0x0227B} ,
01694      {"scE", 0x02AB4} ,
01695      {"scap", 0x02AB8} ,
01696      {"scaron", 0x00161} ,
01697      {"sccue", 0x0227D} ,
01698      {"sce", 0x02AB0} ,
01699      {"scedil", 0x0015F} ,
01700      {"scirc", 0x0015D} ,
01701      {"scnE", 0x02AB6} ,
01702      {"scnap", 0x02ABA} ,
01703      {"scnsim", 0x022E9} ,
01704      {"scpolint", 0x02A13} ,
01705      {"scsim", 0x0227F} ,
01706      {"scy", 0x00441} ,
01707      {"sdot", 0x022C5} ,
01708      {"sdotb", 0x022A1} ,
01709      {"sdote", 0x02A66} ,
01710      {"seArr", 0x021D8} ,
01711      {"searhk", 0x02925} ,
01712      {"searr", 0x02198} ,
01713      {"searrow", 0x02198} ,
01714      {"sect", 0x000A7} ,
01715      {"semi", 0x0003B} ,
01716      {"seswar", 0x02929} ,
01717      {"setminus", 0x02216} ,
01718      {"setmn", 0x02216} ,
01719      {"sext", 0x02736} ,
01720      {"sfr", 0x1D530} ,
01721      {"sfrown", 0x02322} ,
01722      {"sharp", 0x0266F} ,
01723      {"shchcy", 0x00449} ,
01724      {"shcy", 0x00448} ,
01725      {"shortmid", 0x02223} ,
01726      {"shortparallel", 0x02225} ,
01727      {"shy", 0x000AD} ,
01728      {"sigma", 0x003C3} ,
01729      {"sigmav", 0x003C2} ,
01730      {"sim", 0x0223C} ,
01731      {"simdot", 0x02A6A} ,
01732      {"sime", 0x02243} ,
01733      {"simeq", 0x02243} ,
01734      {"simg", 0x02A9E} ,
01735      {"simgE", 0x02AA0} ,
01736      {"siml", 0x02A9D} ,
01737      {"simlE", 0x02A9F} ,
01738      {"simne", 0x02246} ,
01739      {"simplus", 0x02A24} ,
01740      {"simrarr", 0x02972} ,
01741      {"slarr", 0x02190} ,
01742      {"smallsetminus", 0x02216} ,
01743      {"smashp", 0x02A33} ,
01744      {"smeparsl", 0x029E4} ,
01745      {"smid", 0x02223} ,
01746      {"smile", 0x02323} ,
01747      {"smt", 0x02AAA} ,
01748      {"smte", 0x02AAC} ,
01749      {"softcy", 0x0044C} ,
01750      {"sol", 0x0002F} ,
01751      {"solb", 0x029C4} ,
01752      {"solbar", 0x0233F} ,
01753      {"sopf", 0x1D564} ,
01754      {"spades", 0x02660} ,
01755      {"spadesuit", 0x02660} ,
01756      {"spar", 0x02225} ,
01757      {"sqcap", 0x02293} ,
01758      {"sqcup", 0x02294} ,
01759      {"sqsub", 0x0228F} ,
01760      {"sqsube", 0x02291} ,
01761      {"sqsubset", 0x0228F} ,
01762      {"sqsubseteq", 0x02291} ,
01763      {"sqsup", 0x02290} ,
01764      {"sqsupe", 0x02292} ,
01765      {"sqsupset", 0x02290} ,
01766      {"sqsupseteq", 0x02292} ,
01767      {"squ", 0x025A1} ,
01768      {"square", 0x025A1} ,
01769      {"squarf", 0x025AA} ,
01770      {"squf", 0x025AA} ,
01771      {"srarr", 0x02192} ,
01772      {"sscr", 0x1D4C8} ,
01773      {"ssetmn", 0x02216} ,
01774      {"ssmile", 0x02323} ,
01775      {"sstarf", 0x022C6} ,
01776      {"star", 0x02606} ,
01777      {"starf", 0x02605} ,
01778      {"straightepsilon", 0x003F5} ,
01779      {"straightphi", 0x003D5} ,
01780      {"strns", 0x000AF} ,
01781      {"sub", 0x02282} ,
01782      {"subE", 0x02AC5} ,
01783      {"subdot", 0x02ABD} ,
01784      {"sube", 0x02286} ,
01785      {"subedot", 0x02AC3} ,
01786      {"submult", 0x02AC1} ,
01787      {"subnE", 0x02ACB} ,
01788      {"subne", 0x0228A} ,
01789      {"subplus", 0x02ABF} ,
01790      {"subrarr", 0x02979} ,
01791      {"subset", 0x02282} ,
01792      {"subseteq", 0x02286} ,
01793      {"subseteqq", 0x02AC5} ,
01794      {"subsetneq", 0x0228A} ,
01795      {"subsetneqq", 0x02ACB} ,
01796      {"subsim", 0x02AC7} ,
01797      {"subsub", 0x02AD5} ,
01798      {"subsup", 0x02AD3} ,
01799      {"succ", 0x0227B} ,
01800      {"succapprox", 0x02AB8} ,
01801      {"succcurlyeq", 0x0227D} ,
01802      {"succeq", 0x02AB0} ,
01803      {"succnapprox", 0x02ABA} ,
01804      {"succneqq", 0x02AB6} ,
01805      {"succnsim", 0x022E9} ,
01806      {"succsim", 0x0227F} ,
01807      {"sum", 0x02211} ,
01808      {"sung", 0x0266A} ,
01809      {"sup", 0x02283} ,
01810      {"sup1", 0x000B9} ,
01811      {"sup2", 0x000B2} ,
01812      {"sup3", 0x000B3} ,
01813      {"supE", 0x02AC6} ,
01814      {"supdot", 0x02ABE} ,
01815      {"supdsub", 0x02AD8} ,
01816      {"supe", 0x02287} ,
01817      {"supedot", 0x02AC4} ,
01818      {"suphsub", 0x02AD7} ,
01819      {"suplarr", 0x0297B} ,
01820      {"supmult", 0x02AC2} ,
01821      {"supnE", 0x02ACC} ,
01822      {"supne", 0x0228B} ,
01823      {"supplus", 0x02AC0} ,
01824      {"supset", 0x02283} ,
01825      {"supseteq", 0x02287} ,
01826      {"supseteqq", 0x02AC6} ,
01827      {"supsetneq", 0x0228B} ,
01828      {"supsetneqq", 0x02ACC} ,
01829      {"supsim", 0x02AC8} ,
01830      {"supsub", 0x02AD4} ,
01831      {"supsup", 0x02AD6} ,
01832      {"swArr", 0x021D9} ,
01833      {"swarhk", 0x02926} ,
01834      {"swarr", 0x02199} ,
01835      {"swarrow", 0x02199} ,
01836      {"swnwar", 0x0292A} ,
01837      {"szlig", 0x000DF} ,
01838      {"target", 0x02316} ,
01839      {"tau", 0x003C4} ,
01840      {"tbrk", 0x023B4} ,
01841      {"tcaron", 0x00165} ,
01842      {"tcedil", 0x00163} ,
01843      {"tcy", 0x00442} ,
01844      {"tdot", 0x020DB} ,
01845      {"telrec", 0x02315} ,
01846      {"tfr", 0x1D531} ,
01847      {"there4", 0x02234} ,
01848      {"therefore", 0x02234} ,
01849      {"theta", 0x003B8} ,
01850      {"thetav", 0x003D1} ,
01851      {"thickapprox", 0x02248} ,
01852      {"thicksim", 0x0223C} ,
01853      {"thinsp", 0x02009} ,
01854      {"thkap", 0x02248} ,
01855      {"thksim", 0x0223C} ,
01856      {"thorn", 0x000FE} ,
01857      {"tilde", 0x002DC} ,
01858      {"times", 0x000D7} ,
01859      {"timesb", 0x022A0} ,
01860      {"timesbar", 0x02A31} ,
01861      {"timesd", 0x02A30} ,
01862      {"tint", 0x0222D} ,
01863      {"toea", 0x02928} ,
01864      {"top", 0x022A4} ,
01865      {"topbot", 0x02336} ,
01866      {"topcir", 0x02AF1} ,
01867      {"topf", 0x1D565} ,
01868      {"topfork", 0x02ADA} ,
01869      {"tosa", 0x02929} ,
01870      {"tprime", 0x02034} ,
01871      {"trade", 0x02122} ,
01872      {"triangle", 0x025B5} ,
01873      {"triangledown", 0x025BF} ,
01874      {"triangleleft", 0x025C3} ,
01875      {"trianglelefteq", 0x022B4} ,
01876      {"triangleq", 0x0225C} ,
01877      {"triangleright", 0x025B9} ,
01878      {"trianglerighteq", 0x022B5} ,
01879      {"tridot", 0x025EC} ,
01880      {"trie", 0x0225C} ,
01881      {"triminus", 0x02A3A} ,
01882      {"triplus", 0x02A39} ,
01883      {"trisb", 0x029CD} ,
01884      {"tritime", 0x02A3B} ,
01885      {"trpezium", 0x0FFFD} ,
01886      {"tscr", 0x1D4C9} ,
01887      {"tscy", 0x00446} ,
01888      {"tshcy", 0x0045B} ,
01889      {"tstrok", 0x00167} ,
01890      {"twixt", 0x0226C} ,
01891      {"twoheadleftarrow", 0x0219E} ,
01892      {"twoheadrightarrow", 0x021A0} ,
01893      {"uArr", 0x021D1} ,
01894      {"uHar", 0x02963} ,
01895      {"uacute", 0x000FA} ,
01896      {"uarr", 0x02191} ,
01897      {"ubrcy", 0x0045E} ,
01898      {"ubreve", 0x0016D} ,
01899      {"ucirc", 0x000FB} ,
01900      {"ucy", 0x00443} ,
01901      {"udarr", 0x021C5} ,
01902      {"udblac", 0x00171} ,
01903      {"udhar", 0x0296E} ,
01904      {"ufisht", 0x0297E} ,
01905      {"ufr", 0x1D532} ,
01906      {"ugrave", 0x000F9} ,
01907      {"uharl", 0x021BF} ,
01908      {"uharr", 0x021BE} ,
01909      {"uhblk", 0x02580} ,
01910      {"ulcorn", 0x0231C} ,
01911      {"ulcorner", 0x0231C} ,
01912      {"ulcrop", 0x0230F} ,
01913      {"ultri", 0x025F8} ,
01914      {"umacr", 0x0016B} ,
01915      {"uml", 0x000A8} ,
01916      {"uogon", 0x00173} ,
01917      {"uopf", 0x1D566} ,
01918      {"uparrow", 0x02191} ,
01919      {"updownarrow", 0x02195} ,
01920      {"upharpoonleft", 0x021BF} ,
01921      {"upharpoonright", 0x021BE} ,
01922      {"uplus", 0x0228E} ,
01923      {"upsi", 0x003C5} ,
01924      {"upsilon", 0x003C5} ,
01925      {"upuparrows", 0x021C8} ,
01926      {"urcorn", 0x0231D} ,
01927      {"urcorner", 0x0231D} ,
01928      {"urcrop", 0x0230E} ,
01929      {"uring", 0x0016F} ,
01930      {"urtri", 0x025F9} ,
01931      {"uscr", 0x1D4CA} ,
01932      {"utdot", 0x022F0} ,
01933      {"utilde", 0x00169} ,
01934      {"utri", 0x025B5} ,
01935      {"utrif", 0x025B4} ,
01936      {"uuarr", 0x021C8} ,
01937      {"uuml", 0x000FC} ,
01938      {"uwangle", 0x029A7} ,
01939      {"vArr", 0x021D5} ,
01940      {"vBar", 0x02AE8} ,
01941      {"vBarv", 0x02AE9} ,
01942      {"vDash", 0x022A8} ,
01943      {"vangrt", 0x0299C} ,
01944      {"varepsilon", 0x003B5} ,
01945      {"varkappa", 0x003F0} ,
01946      {"varnothing", 0x02205} ,
01947      {"varphi", 0x003C6} ,
01948      {"varpi", 0x003D6} ,
01949      {"varpropto", 0x0221D} ,
01950      {"varr", 0x02195} ,
01951      {"varrho", 0x003F1} ,
01952      {"varsigma", 0x003C2} ,
01953      {"vartheta", 0x003D1} ,
01954      {"vartriangleleft", 0x022B2} ,
01955      {"vartriangleright", 0x022B3} ,
01956      {"vcy", 0x00432} ,
01957      {"vdash", 0x022A2} ,
01958      {"vee", 0x02228} ,
01959      {"veebar", 0x022BB} ,
01960      {"veeeq", 0x0225A} ,
01961      {"vellip", 0x022EE} ,
01962      {"verbar", 0x0007C} ,
01963      {"vert", 0x0007C} ,
01964      {"vfr", 0x1D533} ,
01965      {"vltri", 0x022B2} ,
01966      {"vopf", 0x1D567} ,
01967      {"vprop", 0x0221D} ,
01968      {"vrtri", 0x022B3} ,
01969      {"vscr", 0x1D4CB} ,
01970      {"vzigzag", 0x0299A} ,
01971      {"wcirc", 0x00175} ,
01972      {"wedbar", 0x02A5F} ,
01973      {"wedge", 0x02227} ,
01974      {"wedgeq", 0x02259} ,
01975      {"weierp", 0x02118} ,
01976      {"wfr", 0x1D534} ,
01977      {"wopf", 0x1D568} ,
01978      {"wp", 0x02118} ,
01979      {"wr", 0x02240} ,
01980      {"wreath", 0x02240} ,
01981      {"wscr", 0x1D4CC} ,
01982      {"xcap", 0x022C2} ,
01983      {"xcirc", 0x025EF} ,
01984      {"xcup", 0x022C3} ,
01985      {"xdtri", 0x025BD} ,
01986      {"xfr", 0x1D535} ,
01987      {"xhArr", 0x027FA} ,
01988      {"xharr", 0x027F7} ,
01989      {"xi", 0x003BE} ,
01990      {"xlArr", 0x027F8} ,
01991      {"xlarr", 0x027F5} ,
01992      {"xmap", 0x027FC} ,
01993      {"xnis", 0x022FB} ,
01994      {"xodot", 0x02A00} ,
01995      {"xopf", 0x1D569} ,
01996      {"xoplus", 0x02A01} ,
01997      {"xotime", 0x02A02} ,
01998      {"xrArr", 0x027F9} ,
01999      {"xrarr", 0x027F6} ,
02000      {"xscr", 0x1D4CD} ,
02001      {"xsqcup", 0x02A06} ,
02002      {"xuplus", 0x02A04} ,
02003      {"xutri", 0x025B3} ,
02004      {"xvee", 0x022C1} ,
02005      {"xwedge", 0x022C0} ,
02006      {"yacute", 0x000FD} ,
02007      {"yacy", 0x0044F} ,
02008      {"ycirc", 0x00177} ,
02009      {"ycy", 0x0044B} ,
02010      {"yen", 0x000A5} ,
02011      {"yfr", 0x1D536} ,
02012      {"yicy", 0x00457} ,
02013      {"yopf", 0x1D56A} ,
02014      {"yscr", 0x1D4CE} ,
02015      {"yucy", 0x0044E} ,
02016      {"yuml", 0x000FF} ,
02017      {"zacute", 0x0017A} ,
02018      {"zcaron", 0x0017E} ,
02019      {"zcy", 0x00437} ,
02020      {"zdot", 0x0017C} ,
02021      {"zeetrf", 0x02128} ,
02022      {"zeta", 0x003B6} ,
02023      {"zfr", 0x1D537} ,
02024      {"zhcy", 0x00436} ,
02025      {"zigrarr", 0x021DD} ,
02026      {"zopf", 0x1D56B} ,
02027      {"zscr", 0x1D4CF} 
02028 };
02029 
02030 // Needed since sizeof is a macro and we cannot be used until size is known
02031 int entityMap::size()
02032 {
02033     return sizeof( entities ) / sizeof( entityMap );
02034 }
02035 
02036 KFORMULA_NAMESPACE_END
02037     
KDE Home | KDE Accessibility Home | Description of Access Keys