3rdpartylibs/fastreports.wpf/FastReport.Base/Utils/Converter.cs

using System;
using System.Collections;
using System.Drawing;
using System.ComponentModel;
using System.Globalization;
using System.IO;
using System.Collections.Specialized;
using System.Text;

namespace FastReport.Utils
{
    /// <summary>
    /// Contains methods that peform string to object and vice versa conversions.
    /// </summary>
    public static partial class Converter
    {
        /// <summary>
        /// Converts an object to a string.
        /// </summary>
        /// <param name="value">The object to convert.</param>
        /// <returns>The string that contains the converted value.</returns>
        public static string ToString(object value)
        {
            if (value == null)
                return "";
            if (value is string)
                return (string)value;
            if (value is float)
                return ((float)value).ToString(CultureInfo.InvariantCulture.NumberFormat);
            if (value is double)
                return ((double)value).ToString(CultureInfo.InvariantCulture.NumberFormat);
            if (value is Enum)
                return Enum.Format(value.GetType(), value, "G");
            if (value is Image)
            {
                using (MemoryStream stream = new MemoryStream())
                {
                    ImageHelper.Save(value as Image, stream);
                    return Convert.ToBase64String(stream.ToArray());
                }
            }
            if (value is Stream)
            {
                Stream stream = value as Stream;
                byte[] bytes = new byte[stream.Length];
                stream.Position = 0;
                stream.Read(bytes, 0, bytes.Length);
                return Convert.ToBase64String(bytes);
            }
            if (value is byte[])
            {
                return Convert.ToBase64String((byte[])value);
            }
            if (value is string[])
            {
                string result = "";
                foreach (string s in (value as string[]))
                {
                    result += s + "\r\n";
                }
                if (result.EndsWith("\r\n"))
                    result = result.Remove(result.Length - 2);
                return result;
            }
            if (value is Type)
            {
                Type type = (Type)value;
                bool shortTypeName = type.Assembly.FullName.StartsWith("mscorlib") ||
                  type.Assembly == typeof(Converter).Assembly || type.Assembly.FullName.StartsWith("System.Private.CoreLib");

                if (shortTypeName)
                    return type.FullName;
                return type.AssemblyQualifiedName;
            }
            if (value is Font)
            {
                return new TypeConverters.FontConverter().ConvertToInvariantString(value);
            }
            if (value is System.Drawing.Imaging.ImageFormat)
            {
                var imageFormat = value as System.Drawing.Imaging.ImageFormat;
                return imageFormat.ToString();
            }
            return TypeDescriptor.GetConverter(value).ConvertToInvariantString(value);
        }

        /// <summary>
        /// Converts a value to a string using the specified converter.
        /// </summary>
        /// <param name="value">The object to convert.</param>
        /// <param name="converterType">The type of converter.</param>
        /// <returns>The string that contains the converted value.</returns>
        public static string ToString(object value, Type converterType)
        {
            TypeConverter converter = Activator.CreateInstance(converterType) as TypeConverter;
            return converter.ConvertToInvariantString(value);
        }

        /// <summary>
        /// Converts a string value to the specified data type.
        /// </summary>
        /// <param name="type">The data type to convert to.</param>
        /// <param name="value">The string to convert from.</param>
        /// <returns>The object of type specified in the <b>type</b> parameter that contains 
        /// a converted value.</returns>
        public static object FromString(Type type, string value)
        {
            if (type == typeof(string))
                return value;
            if (value == null || value == "")
                return null;
            if (type == typeof(float))
                return float.Parse(value, CultureInfo.InvariantCulture.NumberFormat);
            if (type == typeof(double))
                return double.Parse(value, CultureInfo.InvariantCulture.NumberFormat);
            if (type == typeof(Enum))
                return Enum.Parse(type, value);
            if (type == typeof(Image) || type == typeof(Bitmap))
                return ImageHelper.Load(Convert.FromBase64String(value));
            if (type == typeof(Stream))
                return new MemoryStream(Convert.FromBase64String(value));
            if (type == typeof(byte[]))
                return Convert.FromBase64String(value);
            if (type == typeof(Type))
                return Type.GetType(value);
            if (type == typeof(string[]))
            {
                value = value.Replace("\r\n", "\r");
                return value.Split('\r');
            }
            if (type == typeof(Font))
                return new TypeConverters.FontConverter().ConvertFromInvariantString(value) as Font;
            if (type == typeof(Color))
                return new ColorConverter().ConvertFromInvariantString(value);
            return TypeDescriptor.GetConverter(type).ConvertFromInvariantString(value);
        }

        /// <summary>
        /// Converts a string to an object using the specified converter.
        /// </summary>
        /// <param name="value">The string to convert.</param>
        /// <param name="converterType">The type of converter.</param>
        /// <returns>The object that contains the converted value.</returns>
        public static object FromString(string value, Type converterType)
        {
            TypeConverter converter = Activator.CreateInstance(converterType) as TypeConverter;
            return converter.ConvertFromInvariantString(value);
        }

        /// <summary>
        /// Converts a string containing special symbols to the xml-compatible string.
        /// </summary>
        /// <param name="s">The string to convert.</param>
        /// <returns>The result string.</returns>
        /// <remarks>
        /// This method replaces some special symbols like &lt;, &gt; into xml-compatible 
        /// form: &amp;lt;, &amp;gt;. To convert such string back to original form, use the
        /// <see cref="FromXml"/> method.
        /// </remarks>
        public static string ToXml(string s)
        {
            return ToXml(s, true);
        }

        /// <summary>
        /// Converts a string containing special symbols to the xml-compatible string.
        /// </summary>
        /// <param name="s">The string to convert.</param>
        /// <param name="convertCrlf">Determines whether it is necessary to convert cr-lf symbols to xml form.</param>
        /// <returns>The result string.</returns>
        public static string ToXml(string s, bool convertCrlf)
        {
            FastString result = new FastString(s.Length);
            for (int i = 0; i < s.Length; i++)
            {
                switch (s[i])
                {
                    case '\n':
                    case '\r':
                        if (convertCrlf)
                            result.Append("&#" + (int)s[i] + ";");
                        else
                            result.Append(s[i]);
                        break;
                    case '"':
                        result.Append("&quot;");
                        break;
                    case '&':
                        result.Append("&amp;");
                        break;
                    case '<':
                        result.Append("&lt;");
                        break;
                    case '>':
                        result.Append("&gt;");
                        break;
                    default:
                        result.Append(s[i]);
                        break;
                }
            }
            return result.ToString();
        }

        /// <summary>
        /// Converts a value to xml-compatible string.
        /// </summary>
        /// <param name="value">The value to convert.</param>
        /// <returns>The result string.</returns>
        public static string ToXml(object value)
        {
            return ToXml(ToString(value));
        }

        /// <summary>
        /// Convert the xml-compatible string to the regular one.
        /// </summary>
        /// <param name="s">The string to convert.</param>
        /// <returns>The result string.</returns>
        /// <remarks>
        /// This is counterpart to the <see cref="ToXml(string)"/> method.
        /// </remarks>
        public static string FromXml(string s)
        {
            FastString result = new FastString(s.Length);
            int i = 0;
            while (i < s.Length)
            {
                if (s[i] == '&')
                {
                    if (i + 3 < s.Length && s[i + 1] == '#')
                    {
                        int j = i + 3;
                        j = s.IndexOf(";", j, s.Length - j);
                        if (j == -1)
                            throw new FormatException();
                        if (s[i + 2] == 'x')
                        {
                            char hexChar = (char)int.Parse(s.Substring(i + 3, j - i - 3), NumberStyles.AllowHexSpecifier);
                            result.Append(hexChar);
                        }
                        else
                        {
                            result.Append((char)int.Parse(s.Substring(i + 2, j - i - 2)));
                        }

                        i = j;
                    }
                    else if (i + 5 < s.Length && s.Substring(i + 1, 5) == "quot;")
                    {
                        result.Append('"');
                        i += 5;
                    }
                    else if (i + 4 < s.Length && s.Substring(i + 1, 4) == "amp;")
                    {
                        result.Append('&');
                        i += 4;
                    }
                    else if (i + 3 < s.Length && s.Substring(i + 1, 3) == "lt;")
                    {
                        result.Append('<');
                        i += 3;
                    }
                    else if (i + 3 < s.Length && s.Substring(i + 1, 3) == "gt;")
                    {
                        result.Append('>');
                        i += 3;
                    }
                    else
                        result.Append(s[i]);
                }
                else
                    result.Append(s[i]);
                i++;
            }
            return result.ToString();
        }

        /// <summary>
        /// Decreases the precision of floating-point value.
        /// </summary>
        /// <param name="value">The initial value.</param>
        /// <param name="precision">The number of decimal digits in the fraction.</param>
        /// <returns>The value with lesser precision.</returns>
        public static float DecreasePrecision(float value, int precision)
        {
            return (float)Math.Round(value, precision);
        }

        /// <summary>
        /// Converts a string value to the float.
        /// </summary>
        /// <param name="value">The string value to convert.</param>
        /// <returns>The float value.</returns>
        /// <remarks>
        /// Both "." or "," decimal separators are allowed.
        /// </remarks>
        public static float StringToFloat(string value)
        {
            string currentSeparator = CultureInfo.CurrentCulture.NumberFormat.CurrencyDecimalSeparator;
            return StringToFloat(value, currentSeparator);
        }

        /// <summary>
        /// Converts a string value to the float.
        /// </summary>
        /// <param name="value">The string value to convert.</param>
        /// <param name="removeNonDigit">Indicates whether to ignore non-digit symbols.</param>
        /// <returns>The float value.</returns>
        public static float StringToFloat(string value, bool removeNonDigit)
        {
            string currentSeparator = CultureInfo.CurrentCulture.NumberFormat.CurrencyDecimalSeparator;
            return StringToFloat(value, currentSeparator, removeNonDigit);
        }

        /// <summary>
        /// Converts a string value to the float.
        /// </summary>
        /// <param name="value">The string value to convert.</param>
        /// <param name="separator">Decimal separator.</param>
        /// <returns>The float value.</returns>
        public static float StringToFloat(string value, string separator/*, string negativeSign*/)
        {
            return (float)FromString(typeof(float), value.Replace(separator, ".")/*.Replace(negativeSign, "-")*/);
        }

        /// <summary>
        /// Converts a string value to the float.
        /// </summary>
        /// <param name="value">The string value to convert.</param>
        /// <param name="separator">Decimal separator.</param>
        /// <param name="removeNonDigit">Indicates whether to ignore non-digit symbols.</param>
        /// <returns>The float value.</returns>
        public static float StringToFloat(string value, string separator,/* string negativeSign,*/ bool removeNonDigit)
        {
            System.Text.StringBuilder result = new System.Text.StringBuilder();
            int separatorPos = value.IndexOf(separator);
            if (separatorPos == -1)
                separatorPos = value.IndexOf('.');
            if (value.Contains(/*negativeSign*/"-"))
                result.Append('-');
            for (int i = 0; i < value.Length; i++)
            {
                if (value[i] >= '0' && value[i] <= '9')
                    result.Append(value[i]);
                if (i == separatorPos)
                    result.Append('.');
                if (i < separatorPos + separator.Length)
                    continue;
            }
            try
            {
                if (result.Length != 0)
                    return (float)FromString(typeof(float), result.ToString());
            }
            catch
            {
            }
            return 0;
        }

        /// <summary>
        /// Converts the string containing several text lines to a collection of strings.
        /// </summary>
        /// <param name="text">The string to convert.</param>
        /// <param name="list">The collection instance.</param>
        public static void StringToIList(string text, IList list)
        {
            list.Clear();
            string[] lines = text.Split(new string[] { "\r\n" }, StringSplitOptions.None);
            foreach (string s in lines)
            {
                list.Add(s);
            }
        }

        /// <summary>
        /// Converts a collection of strings to a string.
        /// </summary>
        /// <param name="list">The collection to convert.</param>
        /// <returns>The string that contains all lines from the collection.</returns>
        public static string IListToString(IList list)
        {
            string text = "";
            foreach (object obj in list)
            {
                text += obj.ToString() + "\r\n";
            }
            if (text.EndsWith("\r\n"))
                text = text.Remove(text.Length - 2);
            return text;
        }

        /// <summary>
        /// Converts <b>null</b> value to 0, false, empty string, depending on <b>type</b>.
        /// </summary>
        /// <param name="type">The data type.</param>
        /// <returns>The value of the <b>type</b> data type.</returns>
        public static object ConvertNull(Type type)
        {
            if (type == typeof(string))
                return "";
            else if (type == typeof(char))
                return ' ';
            else if (type == typeof(DateTime))
                return DateTime.MinValue;
            else if (type == typeof(TimeSpan))
                return TimeSpan.Zero;
            else if (type == typeof(Guid))
                return Guid.Empty;
            else if (type == typeof(bool))
                return false;
            else if (type == typeof(byte[]))
                return null;
            else if (type.IsClass)
                return null;
            else if (type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Nullable<>))
                return null;
            return Convert.ChangeType(0, type);
        }

        /// <summary>
        /// Converts <b>string</b> value to <b>byte[]</b>.
        /// </summary>
        /// <param name="Str">The string to convert</param>
        /// <returns>The value of the <b>byte[]</b> data type.</returns>
        public static byte[] StringToByteArray(string Str)
        {
            System.Text.ASCIIEncoding encoding = new System.Text.ASCIIEncoding();
            return encoding.GetBytes(Str);
        }


        /// <summary>
        /// Converts a string to NameValueCollection.
        /// </summary>
        /// <param name="text">The string to convert.</param>
        /// <returns>The NameValueCollection that contains the name/value pairs.</returns>
        public static NameValueCollection StringToNameValueCollection(string text)
        {
            NameValueCollection collection = new NameValueCollection();
            int start = 0;
            while (start < text.Length)
            {
                // skip spaces
                for (; start < text.Length && text[start] == ' '; start++)
                {
                }
                // find '='
                int end = start;
                for (; end < text.Length && text[end] != '='; end++)
                {
                }
                // '=' not found, break
                if (end >= text.Length)
                    break;

                // get name/value
                string name = text.Substring(start, end - start);
                string value = "";
                start = end + 1;
                // no value, break
                if (start >= text.Length)
                    break;

                if (text[start] == '"')
                {
                    // value is inside quotes, find trailing '"'
                    start++;
                    for (end = start; end < text.Length && text[end] != '"'; end++)
                    {
                    }
                    // '"' not found, break
                    if (end == text.Length)
                        break;

                    value = text.Substring(start, end - start);
                    start = end + 1;
                }
                else
                {
                    // get the value till ' ' or eol
                    for (end = start; end < text.Length && text[end] != ' '; end++)
                    {
                    }

                    value = text.Substring(start, end - start);
                    start = end;
                }

                collection.Add(name, value);
            }

            return collection;
        }

        /// <summary>
        /// Convert &amp;amp;&amp;Tab;&amp;quot; etc to symbol and return result as string
        /// </summary>
        /// <param name="text">String for processing</param>
        /// <param name="position">Position for processing</param>
        /// <param name="result">Result of processing</param>
        /// <returns>True if successful</returns>
        public static bool FromHtmlEntities(string text, ref int position, out string result)
        {
            StringBuilder fastString = new StringBuilder(2);
            if (FromHtmlEntities(text, ref position, fastString))
            {
                result = fastString.ToString();
                return true;
            }
            else
            {
                result = "";
                return false;
            }
        }

        /// <summary>
        /// Convert &amp;amp;&amp;Tab;&amp;quot; etc to symbol and return result as string
        /// </summary>
        /// <param name="text">String for processing</param>
        /// <param name="position">Position for processing</param>
        /// <param name="result">Append result of processing to FastString</param>
        /// <returns>True if successful</returns>
        public static bool FromHtmlEntities(string text, ref int position, StringBuilder result)
        {
            if (text[position] != '&') return false;
            int end = text.IndexOf(';', position);
            if (end <= position + 1) return false;
            if (text[position + 1] == '#')
            {
                if (text[position + 2] == 'x')
                {
                    //hex
                    StringBuilder fastString = new StringBuilder(end - position);
                    for (int i = position + 3; i < end; i++)
                    {
                        if (!Uri.IsHexDigit(text[i]))
                            return false;
                        fastString.Append(text[i]);
                    }
                    try
                    {
                        int value = Convert.ToInt32(fastString.ToString(), 16);
                        if (value > char.MaxValue)
                            result.Append(Char.ConvertFromUtf32(value));
                        else
                            result.Append((char)value);
                        position = end;
                        return true;
                    }
                    catch
                    {
                        return false;
                    }
                }
                else
                {
                    //dec
                    FastString fastString = new FastString(end - position);
                    for (int i = position + 2; i < end; i++)
                    {
                        if (!Char.IsDigit(text[i]))
                            return false;
                        fastString.Append(text[i]);
                    }
                    try
                    {
                        int value = Convert.ToInt32(fastString.ToString(), 10);
                        if (value > char.MaxValue)
                            result.Append(Char.ConvertFromUtf32(value));
                        else
                            result.Append((char)value);
                        position = end;
                        return true;
                    }
                    catch
                    {
                        return false;
                    }
                }
            }
            int code = GetCode(text.Substring(position, end - position + 1));
            if (code == 0)
                return false;
            if (code > char.MaxValue)
                result.Append(Char.ConvertFromUtf32(code));
            else
                result.Append((char)code);
            position = end;
            return true;
        }

        private static int GetCode(string text)
        {
            switch (text)
            {
                case "&Tab;": return 9;
                case "&NewLine;": return 10;
                case "&excl;": return 33;
                case "&quot;": return 34;
                case "&QUOT;": return 34;
                case "&num;": return 35;
                case "&dollar;": return 36;
                case "&percnt;": return 37;
                case "&amp;": return 38;
                case "&AMP;": return 38;
                case "&apos;": return 39;
                case "&lpar;": return 40;
                case "&rpar;": return 41;
                case "&ast;": return 42;
                case "&midast;": return 42;
                case "&plus;": return 43;
                case "&comma;": return 44;
                case "&period;": return 46;
                case "&sol;": return 47;
                case "&colon;": return 58;
                case "&semi;": return 59;
                case "&lt;": return 60;
                case "&LT;": return 60;
                case "&equals;": return 61;
                case "&gt;": return 62;
                case "&GT;": return 62;
                case "&quest;": return 63;
                case "&commat;": return 64;
                case "&lsqb;": return 91;
                case "&lbrack;": return 91;
                case "&bsol;": return 92;
                case "&rsqb;": return 93;
                case "&rbrack;": return 93;
                case "&Hat;": return 94;
                case "&lowbar;": return 95;
                case "&grave;": return 96;
                case "&DiacriticalGrave;": return 96;
                case "&lcub;": return 123;
                case "&lbrace;": return 123;
                case "&verbar;": return 124;
                case "&vert;": return 124;
                case "&VerticalLine;": return 124;
                case "&rcub;": return 125;
                case "&rbrace;": return 125;
                case "&nbsp;": return 160;
                case "&NonBreakingSpace;": return 160;
                case "&iexcl;": return 161;
                case "&cent;": return 162;
                case "&pound;": return 163;
                case "&curren;": return 164;
                case "&yen;": return 165;
                case "&brvbar;": return 166;
                case "&sect;": return 167;
                case "&Dot;": return 168;
                case "&die;": return 168;
                case "&DoubleDot;": return 168;
                case "&uml;": return 168;
                case "&copy;": return 169;
                case "&COPY;": return 169;
                case "&ordf;": return 170;
                case "&laquo;": return 171;
                case "&not;": return 172;
                case "&shy;": return 173;
                case "&reg;": return 174;
                case "&circledR;": return 174;
                case "&REG;": return 174;
                case "&macr;": return 175;
                case "&OverBar;": return 175;
                case "&strns;": return 175;
                case "&deg;": return 176;
                case "&plusmn;": return 177;
                case "&pm;": return 177;
                case "&PlusMinus;": return 177;
                case "&sup2;": return 178;
                case "&sup3;": return 179;
                case "&acute;": return 180;
                case "&DiacriticalAcute;": return 180;
                case "&micro;": return 181;
                case "&para;": return 182;
                case "&middot;": return 183;
                case "&centerdot;": return 183;
                case "&CenterDot;": return 183;
                case "&cedil;": return 184;
                case "&Cedilla;": return 184;
                case "&sup1;": return 185;
                case "&ordm;": return 186;
                case "&raquo;": return 187;
                case "&frac14;": return 188;
                case "&frac12;": return 189;
                case "&half;": return 189;
                case "&frac34;": return 190;
                case "&iquest;": return 191;
                case "&Agrave;": return 192;
                case "&Aacute;": return 193;
                case "&Acirc;": return 194;
                case "&Atilde;": return 195;
                case "&Auml;": return 196;
                case "&Aring;": return 197;
                case "&AElig;": return 198;
                case "&Ccedil;": return 199;
                case "&Egrave;": return 200;
                case "&Eacute;": return 201;
                case "&Ecirc;": return 202;
                case "&Euml;": return 203;
                case "&Igrave;": return 204;
                case "&Iacute;": return 205;
                case "&Icirc;": return 206;
                case "&Iuml;": return 207;
                case "&ETH;": return 208;
                case "&Ntilde;": return 209;
                case "&Ograve;": return 210;
                case "&Oacute;": return 211;
                case "&Ocirc;": return 212;
                case "&Otilde;": return 213;
                case "&Ouml;": return 214;
                case "&times;": return 215;
                case "&Oslash;": return 216;
                case "&Ugrave;": return 217;
                case "&Uacute;": return 218;
                case "&Ucirc;": return 219;
                case "&Uuml;": return 220;
                case "&Yacute;": return 221;
                case "&THORN;": return 222;
                case "&szlig;": return 223;
                case "&agrave;": return 224;
                case "&aacute;": return 225;
                case "&acirc;": return 226;
                case "&atilde;": return 227;
                case "&auml;": return 228;
                case "&aring;": return 229;
                case "&aelig;": return 230;
                case "&ccedil;": return 231;
                case "&egrave;": return 232;
                case "&eacute;": return 233;
                case "&ecirc;": return 234;
                case "&euml;": return 235;
                case "&igrave;": return 236;
                case "&iacute;": return 237;
                case "&icirc;": return 238;
                case "&iuml;": return 239;
                case "&eth;": return 240;
                case "&ntilde;": return 241;
                case "&ograve;": return 242;
                case "&oacute;": return 243;
                case "&ocirc;": return 244;
                case "&otilde;": return 245;
                case "&ouml;": return 246;
                case "&divide;": return 247;
                case "&div;": return 247;
                case "&oslash;": return 248;
                case "&ugrave;": return 249;
                case "&uacute;": return 250;
                case "&ucirc;": return 251;
                case "&uuml;": return 252;
                case "&yacute;": return 253;
                case "&thorn;": return 254;
                case "&yuml;": return 255;
                case "&Amacr;": return 256;
                case "&amacr;": return 257;
                case "&Abreve;": return 258;
                case "&abreve;": return 259;
                case "&Aogon;": return 260;
                case "&aogon;": return 261;
                case "&Cacute;": return 262;
                case "&cacute;": return 263;
                case "&Ccirc;": return 264;
                case "&ccirc;": return 265;
                case "&Cdot;": return 266;
                case "&cdot;": return 267;
                case "&Ccaron;": return 268;
                case "&ccaron;": return 269;
                case "&Dcaron;": return 270;
                case "&dcaron;": return 271;
                case "&Dstrok;": return 272;
                case "&dstrok;": return 273;
                case "&Emacr;": return 274;
                case "&emacr;": return 275;
                case "&Edot;": return 278;
                case "&edot;": return 279;
                case "&Eogon;": return 280;
                case "&eogon;": return 281;
                case "&Ecaron;": return 282;
                case "&ecaron;": return 283;
                case "&Gcirc;": return 284;
                case "&gcirc;": return 285;
                case "&Gbreve;": return 286;
                case "&gbreve;": return 287;
                case "&Gdot;": return 288;
                case "&gdot;": return 289;
                case "&Gcedil;": return 290;
                case "&Hcirc;": return 292;
                case "&hcirc;": return 293;
                case "&Hstrok;": return 294;
                case "&hstrok;": return 295;
                case "&Itilde;": return 296;
                case "&itilde;": return 297;
                case "&Imacr;": return 298;
                case "&imacr;": return 299;
                case "&Iogon;": return 302;
                case "&iogon;": return 303;
                case "&Idot;": return 304;
                case "&imath;": return 305;
                case "&inodot;": return 305;
                case "&IJlig;": return 306;
                case "&ijlig;": return 307;
                case "&Jcirc;": return 308;
                case "&jcirc;": return 309;
                case "&Kcedil;": return 310;
                case "&kcedil;": return 311;
                case "&kgreen;": return 312;
                case "&Lacute;": return 313;
                case "&lacute;": return 314;
                case "&Lcedil;": return 315;
                case "&lcedil;": return 316;
                case "&Lcaron;": return 317;
                case "&lcaron;": return 318;
                case "&Lmidot;": return 319;
                case "&lmidot;": return 320;
                case "&Lstrok;": return 321;
                case "&lstrok;": return 322;
                case "&Nacute;": return 323;
                case "&nacute;": return 324;
                case "&Ncedil;": return 325;
                case "&ncedil;": return 326;
                case "&Ncaron;": return 327;
                case "&ncaron;": return 328;
                case "&napos;": return 329;
                case "&ENG;": return 330;
                case "&eng;": return 331;
                case "&Omacr;": return 332;
                case "&omacr;": return 333;
                case "&Odblac;": return 336;
                case "&odblac;": return 337;
                case "&OElig;": return 338;
                case "&oelig;": return 339;
                case "&Racute;": return 340;
                case "&racute;": return 341;
                case "&Rcedil;": return 342;
                case "&rcedil;": return 343;
                case "&Rcaron;": return 344;
                case "&rcaron;": return 345;
                case "&Sacute;": return 346;
                case "&sacute;": return 347;
                case "&Scirc;": return 348;
                case "&scirc;": return 349;
                case "&Scedil;": return 350;
                case "&scedil;": return 351;
                case "&Scaron;": return 352;
                case "&scaron;": return 353;
                case "&Tcedil;": return 354;
                case "&tcedil;": return 355;
                case "&Tcaron;": return 356;
                case "&tcaron;": return 357;
                case "&Tstrok;": return 358;
                case "&tstrok;": return 359;
                case "&Utilde;": return 360;
                case "&utilde;": return 361;
                case "&Umacr;": return 362;
                case "&umacr;": return 363;
                case "&Ubreve;": return 364;
                case "&ubreve;": return 365;
                case "&Uring;": return 366;
                case "&uring;": return 367;
                case "&Udblac;": return 368;
                case "&udblac;": return 369;
                case "&Uogon;": return 370;
                case "&uogon;": return 371;
                case "&Wcirc;": return 372;
                case "&wcirc;": return 373;
                case "&Ycirc;": return 374;
                case "&ycirc;": return 375;
                case "&Yuml;": return 376;
                case "&Zacute;": return 377;
                case "&zacute;": return 378;
                case "&Zdot;": return 379;
                case "&zdot;": return 380;
                case "&Zcaron;": return 381;
                case "&zcaron;": return 382;
                case "&fnof;": return 402;
                case "&imped;": return 437;
                case "&gacute;": return 501;
                case "&jmath;": return 567;
                case "&circ;": return 710;
                case "&caron;": return 711;
                case "&Hacek;": return 711;
                case "&breve;": return 728;
                case "&Breve;": return 728;
                case "&dot;": return 729;
                case "&DiacriticalDot;": return 729;
                case "&ring;": return 730;
                case "&ogon;": return 731;
                case "&tilde;": return 732;
                case "&DiacriticalTilde;": return 732;
                case "&dblac;": return 733;
                case "&DiacriticalDoubleAcute;": return 733;
                case "&DownBreve;": return 785;
                case "&UnderBar;": return 818;
                case "&Alpha;": return 913;
                case "&Beta;": return 914;
                case "&Gamma;": return 915;
                case "&Delta;": return 916;
                case "&Epsilon;": return 917;
                case "&Zeta;": return 918;
                case "&Eta;": return 919;
                case "&Theta;": return 920;
                case "&Iota;": return 921;
                case "&Kappa;": return 922;
                case "&Lambda;": return 923;
                case "&Mu;": return 924;
                case "&Nu;": return 925;
                case "&Xi;": return 926;
                case "&Omicron;": return 927;
                case "&Pi;": return 928;
                case "&Rho;": return 929;
                case "&Sigma;": return 931;
                case "&Tau;": return 932;
                case "&Upsilon;": return 933;
                case "&Phi;": return 934;
                case "&Chi;": return 935;
                case "&Psi;": return 936;
                case "&Omega;": return 937;
                case "&alpha;": return 945;
                case "&beta;": return 946;
                case "&gamma;": return 947;
                case "&delta;": return 948;
                case "&epsiv;": return 949;
                case "&varepsilon;": return 949;
                case "&epsilon;": return 949;
                case "&zeta;": return 950;
                case "&eta;": return 951;
                case "&theta;": return 952;
                case "&iota;": return 953;
                case "&kappa;": return 954;
                case "&lambda;": return 955;
                case "&mu;": return 956;
                case "&nu;": return 957;
                case "&xi;": return 958;
                case "&omicron;": return 959;
                case "&pi;": return 960;
                case "&rho;": return 961;
                case "&sigmav;": return 962;
                case "&varsigma;": return 962;
                case "&sigmaf;": return 962;
                case "&sigma;": return 963;
                case "&tau;": return 964;
                case "&upsi;": return 965;
                case "&upsilon;": return 965;
                case "&phi;": return 966;
                case "&phiv;": return 966;
                case "&varphi;": return 966;
                case "&chi;": return 967;
                case "&psi;": return 968;
                case "&omega;": return 969;
                case "&thetav;": return 977;
                case "&vartheta;": return 977;
                case "&thetasym;": return 977;
                case "&Upsi;": return 978;
                case "&upsih;": return 978;
                case "&straightphi;": return 981;
                case "&piv;": return 982;
                case "&varpi;": return 982;
                case "&Gammad;": return 988;
                case "&gammad;": return 989;
                case "&digamma;": return 989;
                case "&kappav;": return 1008;
                case "&varkappa;": return 1008;
                case "&rhov;": return 1009;
                case "&varrho;": return 1009;
                case "&epsi;": return 1013;
                case "&straightepsilon;": return 1013;
                case "&bepsi;": return 1014;
                case "&backepsilon;": return 1014;
                case "&IOcy;": return 1025;
                case "&DJcy;": return 1026;
                case "&GJcy;": return 1027;
                case "&Jukcy;": return 1028;
                case "&DScy;": return 1029;
                case "&Iukcy;": return 1030;
                case "&YIcy;": return 1031;
                case "&Jsercy;": return 1032;
                case "&LJcy;": return 1033;
                case "&NJcy;": return 1034;
                case "&TSHcy;": return 1035;
                case "&KJcy;": return 1036;
                case "&Ubrcy;": return 1038;
                case "&DZcy;": return 1039;
                case "&Acy;": return 1040;
                case "&Bcy;": return 1041;
                case "&Vcy;": return 1042;
                case "&Gcy;": return 1043;
                case "&Dcy;": return 1044;
                case "&IEcy;": return 1045;
                case "&ZHcy;": return 1046;
                case "&Zcy;": return 1047;
                case "&Icy;": return 1048;
                case "&Jcy;": return 1049;
                case "&Kcy;": return 1050;
                case "&Lcy;": return 1051;
                case "&Mcy;": return 1052;
                case "&Ncy;": return 1053;
                case "&Ocy;": return 1054;
                case "&Pcy;": return 1055;
                case "&Rcy;": return 1056;
                case "&Scy;": return 1057;
                case "&Tcy;": return 1058;
                case "&Ucy;": return 1059;
                case "&Fcy;": return 1060;
                case "&KHcy;": return 1061;
                case "&TScy;": return 1062;
                case "&CHcy;": return 1063;
                case "&SHcy;": return 1064;
                case "&SHCHcy;": return 1065;
                case "&HARDcy;": return 1066;
                case "&Ycy;": return 1067;
                case "&SOFTcy;": return 1068;
                case "&Ecy;": return 1069;
                case "&YUcy;": return 1070;
                case "&YAcy;": return 1071;
                case "&acy;": return 1072;
                case "&bcy;": return 1073;
                case "&vcy;": return 1074;
                case "&gcy;": return 1075;
                case "&dcy;": return 1076;
                case "&iecy;": return 1077;
                case "&zhcy;": return 1078;
                case "&zcy;": return 1079;
                case "&icy;": return 1080;
                case "&jcy;": return 1081;
                case "&kcy;": return 1082;
                case "&lcy;": return 1083;
                case "&mcy;": return 1084;
                case "&ncy;": return 1085;
                case "&ocy;": return 1086;
                case "&pcy;": return 1087;
                case "&rcy;": return 1088;
                case "&scy;": return 1089;
                case "&tcy;": return 1090;
                case "&ucy;": return 1091;
                case "&fcy;": return 1092;
                case "&khcy;": return 1093;
                case "&tscy;": return 1094;
                case "&chcy;": return 1095;
                case "&shcy;": return 1096;
                case "&shchcy;": return 1097;
                case "&hardcy;": return 1098;
                case "&ycy;": return 1099;
                case "&softcy;": return 1100;
                case "&ecy;": return 1101;
                case "&yucy;": return 1102;
                case "&yacy;": return 1103;
                case "&iocy;": return 1105;
                case "&djcy;": return 1106;
                case "&gjcy;": return 1107;
                case "&jukcy;": return 1108;
                case "&dscy;": return 1109;
                case "&iukcy;": return 1110;
                case "&yicy;": return 1111;
                case "&jsercy;": return 1112;
                case "&ljcy;": return 1113;
                case "&njcy;": return 1114;
                case "&tshcy;": return 1115;
                case "&kjcy;": return 1116;
                case "&ubrcy;": return 1118;
                case "&dzcy;": return 1119;
                case "&ensp;": return 8194;
                case "&emsp;": return 8195;
                case "&emsp13;": return 8196;
                case "&emsp14;": return 8197;
                case "&numsp;": return 8199;
                case "&puncsp;": return 8200;
                case "&thinsp;": return 8201;
                case "&ThinSpace;": return 8201;
                case "&hairsp;": return 8202;
                case "&VeryThinSpace;": return 8202;
                case "&ZeroWidthSpace;": return 8203;
                case "&NegativeVeryThinSpace;": return 8203;
                case "&NegativeThinSpace;": return 8203;
                case "&NegativeMediumSpace;": return 8203;
                case "&NegativeThickSpace;": return 8203;
                case "&zwnj;": return 8204;
                case "&zwj;": return 8205;
                case "&lrm;": return 8206;
                case "&rlm;": return 8207;
                case "&hyphen;": return 8208;
                case "&dash;": return 8208;
                case "&ndash;": return 8211;
                case "&mdash;": return 8212;
                case "&horbar;": return 8213;
                case "&Verbar;": return 8214;
                case "&Vert;": return 8214;
                case "&lsquo;": return 8216;
                case "&OpenCurlyQuote;": return 8216;
                case "&rsquo;": return 8217;
                case "&rsquor;": return 8217;
                case "&CloseCurlyQuote;": return 8217;
                case "&lsquor;": return 8218;
                case "&sbquo;": return 8218;
                case "&ldquo;": return 8220;
                case "&OpenCurlyDoubleQuote;": return 8220;
                case "&rdquo;": return 8221;
                case "&rdquor;": return 8221;
                case "&CloseCurlyDoubleQuote;": return 8221;
                case "&ldquor;": return 8222;
                case "&bdquo;": return 8222;
                case "&dagger;": return 8224;
                case "&Dagger;": return 8225;
                case "&ddagger;": return 8225;
                case "&bull;": return 8226;
                case "&bullet;": return 8226;
                case "&nldr;": return 8229;
                case "&hellip;": return 8230;
                case "&mldr;": return 8230;
                case "&permil;": return 8240;
                case "&pertenk;": return 8241;
                case "&prime;": return 8242;
                case "&Prime;": return 8243;
                case "&tprime;": return 8244;
                case "&bprime;": return 8245;
                case "&backprime;": return 8245;
                case "&lsaquo;": return 8249;
                case "&rsaquo;": return 8250;
                case "&oline;": return 8254;
                case "&caret;": return 8257;
                case "&hybull;": return 8259;
                case "&frasl;": return 8260;
                case "&bsemi;": return 8271;
                case "&qprime;": return 8279;
                case "&MediumSpace;": return 8287;
                case "&NoBreak;": return 8288;
                case "&ApplyFunction;": return 8289;
                case "&af;": return 8289;
                case "&InvisibleTimes;": return 8290;
                case "&it;": return 8290;
                case "&InvisibleComma;": return 8291;
                case "&ic;": return 8291;
                case "&euro;": return 8364;
                case "&tdot;": return 8411;
                case "&TripleDot;": return 8411;
                case "&DotDot;": return 8412;
                case "&Copf;": return 8450;
                case "&complexes;": return 8450;
                case "&incare;": return 8453;
                case "&gscr;": return 8458;
                case "&hamilt;": return 8459;
                case "&HilbertSpace;": return 8459;
                case "&Hscr;": return 8459;
                case "&Hfr;": return 8460;
                case "&Poincareplane;": return 8460;
                case "&quaternions;": return 8461;
                case "&Hopf;": return 8461;
                case "&planckh;": return 8462;
                case "&planck;": return 8463;
                case "&hbar;": return 8463;
                case "&plankv;": return 8463;
                case "&hslash;": return 8463;
                case "&Iscr;": return 8464;
                case "&imagline;": return 8464;
                case "&image;": return 8465;
                case "&Im;": return 8465;
                case "&imagpart;": return 8465;
                case "&Ifr;": return 8465;
                case "&Lscr;": return 8466;
                case "&lagran;": return 8466;
                case "&Laplacetrf;": return 8466;
                case "&ell;": return 8467;
                case "&Nopf;": return 8469;
                case "&naturals;": return 8469;
                case "&numero;": return 8470;
                case "&copysr;": return 8471;
                case "&weierp;": return 8472;
                case "&wp;": return 8472;
                case "&Popf;": return 8473;
                case "&primes;": return 8473;
                case "&rationals;": return 8474;
                case "&Qopf;": return 8474;
                case "&Rscr;": return 8475;
                case "&realine;": return 8475;
                case "&real;": return 8476;
                case "&Re;": return 8476;
                case "&realpart;": return 8476;
                case "&Rfr;": return 8476;
                case "&reals;": return 8477;
                case "&Ropf;": return 8477;
                case "&rx;": return 8478;
                case "&trade;": return 8482;
                case "&TRADE;": return 8482;
                case "&integers;": return 8484;
                case "&Zopf;": return 8484;
                case "&ohm;": return 8486;
                case "&mho;": return 8487;
                case "&Zfr;": return 8488;
                case "&zeetrf;": return 8488;
                case "&iiota;": return 8489;
                case "&angst;": return 8491;
                case "&bernou;": return 8492;
                case "&Bernoullis;": return 8492;
                case "&Bscr;": return 8492;
                case "&Cfr;": return 8493;
                case "&Cayleys;": return 8493;
                case "&escr;": return 8495;
                case "&Escr;": return 8496;
                case "&expectation;": return 8496;
                case "&Fscr;": return 8497;
                case "&Fouriertrf;": return 8497;
                case "&phmmat;": return 8499;
                case "&Mellintrf;": return 8499;
                case "&Mscr;": return 8499;
                case "&order;": return 8500;
                case "&orderof;": return 8500;
                case "&oscr;": return 8500;
                case "&alefsym;": return 8501;
                case "&aleph;": return 8501;
                case "&beth;": return 8502;
                case "&gimel;": return 8503;
                case "&daleth;": return 8504;
                case "&CapitalDifferentialD;": return 8517;
                case "&DD;": return 8517;
                case "&DifferentialD;": return 8518;
                case "&dd;": return 8518;
                case "&ExponentialE;": return 8519;
                case "&exponentiale;": return 8519;
                case "&ee;": return 8519;
                case "&ImaginaryI;": return 8520;
                case "&ii;": return 8520;
                case "&frac13;": return 8531;
                case "&frac23;": return 8532;
                case "&frac15;": return 8533;
                case "&frac25;": return 8534;
                case "&frac35;": return 8535;
                case "&frac45;": return 8536;
                case "&frac16;": return 8537;
                case "&frac56;": return 8538;
                case "&frac18;": return 8539;
                case "&frac38;": return 8540;
                case "&frac58;": return 8541;
                case "&frac78;": return 8542;
                case "&larr;": return 8592;
                case "&leftarrow;": return 8592;
                case "&LeftArrow;": return 8592;
                case "&slarr;": return 8592;
                case "&ShortLeftArrow;": return 8592;
                case "&uarr;": return 8593;
                case "&uparrow;": return 8593;
                case "&UpArrow;": return 8593;
                case "&ShortUpArrow;": return 8593;
                case "&rarr;": return 8594;
                case "&rightarrow;": return 8594;
                case "&RightArrow;": return 8594;
                case "&srarr;": return 8594;
                case "&ShortRightArrow;": return 8594;
                case "&darr;": return 8595;
                case "&downarrow;": return 8595;
                case "&DownArrow;": return 8595;
                case "&ShortDownArrow;": return 8595;
                case "&harr;": return 8596;
                case "&leftrightarrow;": return 8596;
                case "&LeftRightArrow;": return 8596;
                case "&varr;": return 8597;
                case "&updownarrow;": return 8597;
                case "&UpDownArrow;": return 8597;
                case "&nwarr;": return 8598;
                case "&UpperLeftArrow;": return 8598;
                case "&nwarrow;": return 8598;
                case "&nearr;": return 8599;
                case "&UpperRightArrow;": return 8599;
                case "&nearrow;": return 8599;
                case "&searr;": return 8600;
                case "&searrow;": return 8600;
                case "&LowerRightArrow;": return 8600;
                case "&swarr;": return 8601;
                case "&swarrow;": return 8601;
                case "&LowerLeftArrow;": return 8601;
                case "&nlarr;": return 8602;
                case "&nleftarrow;": return 8602;
                case "&nrarr;": return 8603;
                case "&nrightarrow;": return 8603;
                case "&rarrw;": return 8605;
                case "&rightsquigarrow;": return 8605;
                case "&Larr;": return 8606;
                case "&twoheadleftarrow;": return 8606;
                case "&Uarr;": return 8607;
                case "&Rarr;": return 8608;
                case "&twoheadrightarrow;": return 8608;
                case "&Darr;": return 8609;
                case "&larrtl;": return 8610;
                case "&leftarrowtail;": return 8610;
                case "&rarrtl;": return 8611;
                case "&rightarrowtail;": return 8611;
                case "&LeftTeeArrow;": return 8612;
                case "&mapstoleft;": return 8612;
                case "&UpTeeArrow;": return 8613;
                case "&mapstoup;": return 8613;
                case "&map;": return 8614;
                case "&RightTeeArrow;": return 8614;
                case "&mapsto;": return 8614;
                case "&DownTeeArrow;": return 8615;
                case "&mapstodown;": return 8615;
                case "&larrhk;": return 8617;
                case "&hookleftarrow;": return 8617;
                case "&rarrhk;": return 8618;
                case "&hookrightarrow;": return 8618;
                case "&larrlp;": return 8619;
                case "&looparrowleft;": return 8619;
                case "&rarrlp;": return 8620;
                case "&looparrowright;": return 8620;
                case "&harrw;": return 8621;
                case "&leftrightsquigarrow;": return 8621;
                case "&nharr;": return 8622;
                case "&nleftrightarrow;": return 8622;
                case "&lsh;": return 8624;
                case "&Lsh;": return 8624;
                case "&rsh;": return 8625;
                case "&Rsh;": return 8625;
                case "&ldsh;": return 8626;
                case "&rdsh;": return 8627;
                case "&crarr;": return 8629;
                case "&cularr;": return 8630;
                case "&curvearrowleft;": return 8630;
                case "&curarr;": return 8631;
                case "&curvearrowright;": return 8631;
                case "&olarr;": return 8634;
                case "&circlearrowleft;": return 8634;
                case "&orarr;": return 8635;
                case "&circlearrowright;": return 8635;
                case "&lharu;": return 8636;
                case "&LeftVector;": return 8636;
                case "&leftharpoonup;": return 8636;
                case "&lhard;": return 8637;
                case "&leftharpoondown;": return 8637;
                case "&DownLeftVector;": return 8637;
                case "&uharr;": return 8638;
                case "&upharpoonright;": return 8638;
                case "&RightUpVector;": return 8638;
                case "&uharl;": return 8639;
                case "&upharpoonleft;": return 8639;
                case "&LeftUpVector;": return 8639;
                case "&rharu;": return 8640;
                case "&RightVector;": return 8640;
                case "&rightharpoonup;": return 8640;
                case "&rhard;": return 8641;
                case "&rightharpoondown;": return 8641;
                case "&DownRightVector;": return 8641;
                case "&dharr;": return 8642;
                case "&RightDownVector;": return 8642;
                case "&downharpoonright;": return 8642;
                case "&dharl;": return 8643;
                case "&LeftDownVector;": return 8643;
                case "&downharpoonleft;": return 8643;
                case "&rlarr;": return 8644;
                case "&rightleftarrows;": return 8644;
                case "&RightArrowLeftArrow;": return 8644;
                case "&udarr;": return 8645;
                case "&UpArrowDownArrow;": return 8645;
                case "&lrarr;": return 8646;
                case "&leftrightarrows;": return 8646;
                case "&LeftArrowRightArrow;": return 8646;
                case "&llarr;": return 8647;
                case "&leftleftarrows;": return 8647;
                case "&uuarr;": return 8648;
                case "&upuparrows;": return 8648;
                case "&rrarr;": return 8649;
                case "&rightrightarrows;": return 8649;
                case "&ddarr;": return 8650;
                case "&downdownarrows;": return 8650;
                case "&lrhar;": return 8651;
                case "&ReverseEquilibrium;": return 8651;
                case "&leftrightharpoons;": return 8651;
                case "&rlhar;": return 8652;
                case "&rightleftharpoons;": return 8652;
                case "&Equilibrium;": return 8652;
                case "&nlArr;": return 8653;
                case "&nLeftarrow;": return 8653;
                case "&nhArr;": return 8654;
                case "&nLeftrightarrow;": return 8654;
                case "&nrArr;": return 8655;
                case "&nRightarrow;": return 8655;
                case "&lArr;": return 8656;
                case "&Leftarrow;": return 8656;
                case "&DoubleLeftArrow;": return 8656;
                case "&uArr;": return 8657;
                case "&Uparrow;": return 8657;
                case "&DoubleUpArrow;": return 8657;
                case "&rArr;": return 8658;
                case "&Rightarrow;": return 8658;
                case "&Implies;": return 8658;
                case "&DoubleRightArrow;": return 8658;
                case "&dArr;": return 8659;
                case "&Downarrow;": return 8659;
                case "&DoubleDownArrow;": return 8659;
                case "&hArr;": return 8660;
                case "&Leftrightarrow;": return 8660;
                case "&DoubleLeftRightArrow;": return 8660;
                case "&iff;": return 8660;
                case "&vArr;": return 8661;
                case "&Updownarrow;": return 8661;
                case "&DoubleUpDownArrow;": return 8661;
                case "&nwArr;": return 8662;
                case "&neArr;": return 8663;
                case "&seArr;": return 8664;
                case "&swArr;": return 8665;
                case "&lAarr;": return 8666;
                case "&Lleftarrow;": return 8666;
                case "&rAarr;": return 8667;
                case "&Rrightarrow;": return 8667;
                case "&zigrarr;": return 8669;
                case "&larrb;": return 8676;
                case "&LeftArrowBar;": return 8676;
                case "&rarrb;": return 8677;
                case "&RightArrowBar;": return 8677;
                case "&duarr;": return 8693;
                case "&DownArrowUpArrow;": return 8693;
                case "&loarr;": return 8701;
                case "&roarr;": return 8702;
                case "&hoarr;": return 8703;
                case "&forall;": return 8704;
                case "&ForAll;": return 8704;
                case "&comp;": return 8705;
                case "&complement;": return 8705;
                case "&part;": return 8706;
                case "&PartialD;": return 8706;
                case "&exist;": return 8707;
                case "&Exists;": return 8707;
                case "&nexist;": return 8708;
                case "&NotExists;": return 8708;
                case "&nexists;": return 8708;
                case "&empty;": return 8709;
                case "&emptyset;": return 8709;
                case "&emptyv;": return 8709;
                case "&varnothing;": return 8709;
                case "&nabla;": return 8711;
                case "&Del;": return 8711;
                case "&isin;": return 8712;
                case "&isinv;": return 8712;
                case "&Element;": return 8712;
                case "&in;": return 8712;
                case "&notin;": return 8713;
                case "&NotElement;": return 8713;
                case "&notinva;": return 8713;
                case "&niv;": return 8715;
                case "&ReverseElement;": return 8715;
                case "&ni;": return 8715;
                case "&SuchThat;": return 8715;
                case "&notni;": return 8716;
                case "&notniva;": return 8716;
                case "&NotReverseElement;": return 8716;
                case "&prod;": return 8719;
                case "&Product;": return 8719;
                case "&coprod;": return 8720;
                case "&Coproduct;": return 8720;
                case "&sum;": return 8721;
                case "&Sum;": return 8721;
                case "&minus;": return 8722;
                case "&mnplus;": return 8723;
                case "&mp;": return 8723;
                case "&MinusPlus;": return 8723;
                case "&plusdo;": return 8724;
                case "&dotplus;": return 8724;
                case "&setmn;": return 8726;
                case "&setminus;": return 8726;
                case "&Backslash;": return 8726;
                case "&ssetmn;": return 8726;
                case "&smallsetminus;": return 8726;
                case "&lowast;": return 8727;
                case "&compfn;": return 8728;
                case "&SmallCircle;": return 8728;
                case "&radic;": return 8730;
                case "&Sqrt;": return 8730;
                case "&prop;": return 8733;
                case "&propto;": return 8733;
                case "&Proportional;": return 8733;
                case "&vprop;": return 8733;
                case "&varpropto;": return 8733;
                case "&infin;": return 8734;
                case "&angrt;": return 8735;
                case "&ang;": return 8736;
                case "&angle;": return 8736;
                case "&angmsd;": return 8737;
                case "&measuredangle;": return 8737;
                case "&angsph;": return 8738;
                case "&mid;": return 8739;
                case "&VerticalBar;": return 8739;
                case "&smid;": return 8739;
                case "&shortmid;": return 8739;
                case "&nmid;": return 8740;
                case "&NotVerticalBar;": return 8740;
                case "&nsmid;": return 8740;
                case "&nshortmid;": return 8740;
                case "&par;": return 8741;
                case "&parallel;": return 8741;
                case "&DoubleVerticalBar;": return 8741;
                case "&spar;": return 8741;
                case "&shortparallel;": return 8741;
                case "&npar;": return 8742;
                case "&nparallel;": return 8742;
                case "&NotDoubleVerticalBar;": return 8742;
                case "&nspar;": return 8742;
                case "&nshortparallel;": return 8742;
                case "&and;": return 8743;
                case "&wedge;": return 8743;
                case "&or;": return 8744;
                case "&vee;": return 8744;
                case "&cap;": return 8745;
                case "&cup;": return 8746;
                case "&int;": return 8747;
                case "&Integral;": return 8747;
                case "&Int;": return 8748;
                case "&tint;": return 8749;
                case "&iiint;": return 8749;
                case "&conint;": return 8750;
                case "&oint;": return 8750;
                case "&ContourIntegral;": return 8750;
                case "&Conint;": return 8751;
                case "&DoubleContourIntegral;": return 8751;
                case "&Cconint;": return 8752;
                case "&cwint;": return 8753;
                case "&cwconint;": return 8754;
                case "&ClockwiseContourIntegral;": return 8754;
                case "&awconint;": return 8755;
                case "&CounterClockwiseContourIntegral;": return 8755;
                case "&there4;": return 8756;
                case "&therefore;": return 8756;
                case "&Therefore;": return 8756;
                case "&becaus;": return 8757;
                case "&because;": return 8757;
                case "&Because;": return 8757;
                case "&ratio;": return 8758;
                case "&Colon;": return 8759;
                case "&Proportion;": return 8759;
                case "&minusd;": return 8760;
                case "&dotminus;": return 8760;
                case "&mDDot;": return 8762;
                case "&homtht;": return 8763;
                case "&sim;": return 8764;
                case "&Tilde;": return 8764;
                case "&thksim;": return 8764;
                case "&thicksim;": return 8764;
                case "&bsim;": return 8765;
                case "&backsim;": return 8765;
                case "&ac;": return 8766;
                case "&mstpos;": return 8766;
                case "&acd;": return 8767;
                case "&wreath;": return 8768;
                case "&VerticalTilde;": return 8768;
                case "&wr;": return 8768;
                case "&nsim;": return 8769;
                case "&NotTilde;": return 8769;
                case "&esim;": return 8770;
                case "&EqualTilde;": return 8770;
                case "&eqsim;": return 8770;
                case "&sime;": return 8771;
                case "&TildeEqual;": return 8771;
                case "&simeq;": return 8771;
                case "&nsime;": return 8772;
                case "&nsimeq;": return 8772;
                case "&NotTildeEqual;": return 8772;
                case "&cong;": return 8773;
                case "&TildeFullEqual;": return 8773;
                case "&simne;": return 8774;
                case "&ncong;": return 8775;
                case "&NotTildeFullEqual;": return 8775;
                case "&asymp;": return 8776;
                case "&ap;": return 8776;
                case "&TildeTilde;": return 8776;
                case "&approx;": return 8776;
                case "&thkap;": return 8776;
                case "&thickapprox;": return 8776;
                case "&nap;": return 8777;
                case "&NotTildeTilde;": return 8777;
                case "&napprox;": return 8777;
                case "&ape;": return 8778;
                case "&approxeq;": return 8778;
                case "&apid;": return 8779;
                case "&bcong;": return 8780;
                case "&backcong;": return 8780;
                case "&asympeq;": return 8781;
                case "&CupCap;": return 8781;
                case "&bump;": return 8782;
                case "&HumpDownHump;": return 8782;
                case "&Bumpeq;": return 8782;
                case "&bumpe;": return 8783;
                case "&HumpEqual;": return 8783;
                case "&bumpeq;": return 8783;
                case "&esdot;": return 8784;
                case "&DotEqual;": return 8784;
                case "&doteq;": return 8784;
                case "&eDot;": return 8785;
                case "&doteqdot;": return 8785;
                case "&efDot;": return 8786;
                case "&fallingdotseq;": return 8786;
                case "&erDot;": return 8787;
                case "&risingdotseq;": return 8787;
                case "&colone;": return 8788;
                case "&coloneq;": return 8788;
                case "&Assign;": return 8788;
                case "&ecolon;": return 8789;
                case "&eqcolon;": return 8789;
                case "&ecir;": return 8790;
                case "&eqcirc;": return 8790;
                case "&cire;": return 8791;
                case "&circeq;": return 8791;
                case "&wedgeq;": return 8793;
                case "&veeeq;": return 8794;
                case "&trie;": return 8796;
                case "&triangleq;": return 8796;
                case "&equest;": return 8799;
                case "&questeq;": return 8799;
                case "&ne;": return 8800;
                case "&NotEqual;": return 8800;
                case "&equiv;": return 8801;
                case "&Congruent;": return 8801;
                case "&nequiv;": return 8802;
                case "&NotCongruent;": return 8802;
                case "&le;": return 8804;
                case "&leq;": return 8804;
                case "&ge;": return 8805;
                case "&GreaterEqual;": return 8805;
                case "&geq;": return 8805;
                case "&lE;": return 8806;
                case "&LessFullEqual;": return 8806;
                case "&leqq;": return 8806;
                case "&gE;": return 8807;
                case "&GreaterFullEqual;": return 8807;
                case "&geqq;": return 8807;
                case "&lnE;": return 8808;
                case "&lneqq;": return 8808;
                case "&gnE;": return 8809;
                case "&gneqq;": return 8809;
                case "&Lt;": return 8810;
                case "&NestedLessLess;": return 8810;
                case "&ll;": return 8810;
                case "&Gt;": return 8811;
                case "&NestedGreaterGreater;": return 8811;
                case "&gg;": return 8811;
                case "&twixt;": return 8812;
                case "&between;": return 8812;
                case "&NotCupCap;": return 8813;
                case "&nlt;": return 8814;
                case "&NotLess;": return 8814;
                case "&nless;": return 8814;
                case "&ngt;": return 8815;
                case "&NotGreater;": return 8815;
                case "&ngtr;": return 8815;
                case "&nle;": return 8816;
                case "&NotLessEqual;": return 8816;
                case "&nleq;": return 8816;
                case "&nge;": return 8817;
                case "&NotGreaterEqual;": return 8817;
                case "&ngeq;": return 8817;
                case "&lsim;": return 8818;
                case "&LessTilde;": return 8818;
                case "&lesssim;": return 8818;
                case "&gsim;": return 8819;
                case "&gtrsim;": return 8819;
                case "&GreaterTilde;": return 8819;
                case "&nlsim;": return 8820;
                case "&NotLessTilde;": return 8820;
                case "&ngsim;": return 8821;
                case "&NotGreaterTilde;": return 8821;
                case "&lg;": return 8822;
                case "&lessgtr;": return 8822;
                case "&LessGreater;": return 8822;
                case "&gl;": return 8823;
                case "&gtrless;": return 8823;
                case "&GreaterLess;": return 8823;
                case "&ntlg;": return 8824;
                case "&NotLessGreater;": return 8824;
                case "&ntgl;": return 8825;
                case "&NotGreaterLess;": return 8825;
                case "&pr;": return 8826;
                case "&Precedes;": return 8826;
                case "&prec;": return 8826;
                case "&sc;": return 8827;
                case "&Succeeds;": return 8827;
                case "&succ;": return 8827;
                case "&prcue;": return 8828;
                case "&PrecedesSlantEqual;": return 8828;
                case "&preccurlyeq;": return 8828;
                case "&sccue;": return 8829;
                case "&SucceedsSlantEqual;": return 8829;
                case "&succcurlyeq;": return 8829;
                case "&prsim;": return 8830;
                case "&precsim;": return 8830;
                case "&PrecedesTilde;": return 8830;
                case "&scsim;": return 8831;
                case "&succsim;": return 8831;
                case "&SucceedsTilde;": return 8831;
                case "&npr;": return 8832;
                case "&nprec;": return 8832;
                case "&NotPrecedes;": return 8832;
                case "&nsc;": return 8833;
                case "&nsucc;": return 8833;
                case "&NotSucceeds;": return 8833;
                case "&sub;": return 8834;
                case "&subset;": return 8834;
                case "&sup;": return 8835;
                case "&supset;": return 8835;
                case "&Superset;": return 8835;
                case "&nsub;": return 8836;
                case "&nsup;": return 8837;
                case "&sube;": return 8838;
                case "&SubsetEqual;": return 8838;
                case "&subseteq;": return 8838;
                case "&supe;": return 8839;
                case "&supseteq;": return 8839;
                case "&SupersetEqual;": return 8839;
                case "&nsube;": return 8840;
                case "&nsubseteq;": return 8840;
                case "&NotSubsetEqual;": return 8840;
                case "&nsupe;": return 8841;
                case "&nsupseteq;": return 8841;
                case "&NotSupersetEqual;": return 8841;
                case "&subne;": return 8842;
                case "&subsetneq;": return 8842;
                case "&supne;": return 8843;
                case "&supsetneq;": return 8843;
                case "&cupdot;": return 8845;
                case "&uplus;": return 8846;
                case "&UnionPlus;": return 8846;
                case "&sqsub;": return 8847;
                case "&SquareSubset;": return 8847;
                case "&sqsubset;": return 8847;
                case "&sqsup;": return 8848;
                case "&SquareSuperset;": return 8848;
                case "&sqsupset;": return 8848;
                case "&sqsube;": return 8849;
                case "&SquareSubsetEqual;": return 8849;
                case "&sqsubseteq;": return 8849;
                case "&sqsupe;": return 8850;
                case "&SquareSupersetEqual;": return 8850;
                case "&sqsupseteq;": return 8850;
                case "&sqcap;": return 8851;
                case "&SquareIntersection;": return 8851;
                case "&sqcup;": return 8852;
                case "&SquareUnion;": return 8852;
                case "&oplus;": return 8853;
                case "&CirclePlus;": return 8853;
                case "&ominus;": return 8854;
                case "&CircleMinus;": return 8854;
                case "&otimes;": return 8855;
                case "&CircleTimes;": return 8855;
                case "&osol;": return 8856;
                case "&odot;": return 8857;
                case "&CircleDot;": return 8857;
                case "&ocir;": return 8858;
                case "&circledcirc;": return 8858;
                case "&oast;": return 8859;
                case "&circledast;": return 8859;
                case "&odash;": return 8861;
                case "&circleddash;": return 8861;
                case "&plusb;": return 8862;
                case "&boxplus;": return 8862;
                case "&minusb;": return 8863;
                case "&boxminus;": return 8863;
                case "&timesb;": return 8864;
                case "&boxtimes;": return 8864;
                case "&sdotb;": return 8865;
                case "&dotsquare;": return 8865;
                case "&vdash;": return 8866;
                case "&RightTee;": return 8866;
                case "&dashv;": return 8867;
                case "&LeftTee;": return 8867;
                case "&top;": return 8868;
                case "&DownTee;": return 8868;
                case "&bottom;": return 8869;
                case "&bot;": return 8869;
                case "&perp;": return 8869;
                case "&UpTee;": return 8869;
                case "&models;": return 8871;
                case "&vDash;": return 8872;
                case "&DoubleRightTee;": return 8872;
                case "&Vdash;": return 8873;
                case "&Vvdash;": return 8874;
                case "&VDash;": return 8875;
                case "&nvdash;": return 8876;
                case "&nvDash;": return 8877;
                case "&nVdash;": return 8878;
                case "&nVDash;": return 8879;
                case "&prurel;": return 8880;
                case "&vltri;": return 8882;
                case "&vartriangleleft;": return 8882;
                case "&LeftTriangle;": return 8882;
                case "&vrtri;": return 8883;
                case "&vartriangleright;": return 8883;
                case "&RightTriangle;": return 8883;
                case "&ltrie;": return 8884;
                case "&trianglelefteq;": return 8884;
                case "&LeftTriangleEqual;": return 8884;
                case "&rtrie;": return 8885;
                case "&trianglerighteq;": return 8885;
                case "&RightTriangleEqual;": return 8885;
                case "&origof;": return 8886;
                case "&imof;": return 8887;
                case "&mumap;": return 8888;
                case "&multimap;": return 8888;
                case "&hercon;": return 8889;
                case "&intcal;": return 8890;
                case "&intercal;": return 8890;
                case "&veebar;": return 8891;
                case "&barvee;": return 8893;
                case "&angrtvb;": return 8894;
                case "&lrtri;": return 8895;
                case "&xwedge;": return 8896;
                case "&Wedge;": return 8896;
                case "&bigwedge;": return 8896;
                case "&xvee;": return 8897;
                case "&Vee;": return 8897;
                case "&bigvee;": return 8897;
                case "&xcap;": return 8898;
                case "&Intersection;": return 8898;
                case "&bigcap;": return 8898;
                case "&xcup;": return 8899;
                case "&Union;": return 8899;
                case "&bigcup;": return 8899;
                case "&diam;": return 8900;
                case "&diamond;": return 8900;
                case "&Diamond;": return 8900;
                case "&sdot;": return 8901;
                case "&sstarf;": return 8902;
                case "&Star;": return 8902;
                case "&divonx;": return 8903;
                case "&divideontimes;": return 8903;
                case "&bowtie;": return 8904;
                case "&ltimes;": return 8905;
                case "&rtimes;": return 8906;
                case "&lthree;": return 8907;
                case "&leftthreetimes;": return 8907;
                case "&rthree;": return 8908;
                case "&rightthreetimes;": return 8908;
                case "&bsime;": return 8909;
                case "&backsimeq;": return 8909;
                case "&cuvee;": return 8910;
                case "&curlyvee;": return 8910;
                case "&cuwed;": return 8911;
                case "&curlywedge;": return 8911;
                case "&Sub;": return 8912;
                case "&Subset;": return 8912;
                case "&Sup;": return 8913;
                case "&Supset;": return 8913;
                case "&Cap;": return 8914;
                case "&Cup;": return 8915;
                case "&fork;": return 8916;
                case "&pitchfork;": return 8916;
                case "&epar;": return 8917;
                case "&ltdot;": return 8918;
                case "&lessdot;": return 8918;
                case "&gtdot;": return 8919;
                case "&gtrdot;": return 8919;
                case "&Ll;": return 8920;
                case "&Gg;": return 8921;
                case "&ggg;": return 8921;
                case "&leg;": return 8922;
                case "&LessEqualGreater;": return 8922;
                case "&lesseqgtr;": return 8922;
                case "&gel;": return 8923;
                case "&gtreqless;": return 8923;
                case "&GreaterEqualLess;": return 8923;
                case "&cuepr;": return 8926;
                case "&curlyeqprec;": return 8926;
                case "&cuesc;": return 8927;
                case "&curlyeqsucc;": return 8927;
                case "&nprcue;": return 8928;
                case "&NotPrecedesSlantEqual;": return 8928;
                case "&nsccue;": return 8929;
                case "&NotSucceedsSlantEqual;": return 8929;
                case "&nsqsube;": return 8930;
                case "&NotSquareSubsetEqual;": return 8930;
                case "&nsqsupe;": return 8931;
                case "&NotSquareSupersetEqual;": return 8931;
                case "&lnsim;": return 8934;
                case "&gnsim;": return 8935;
                case "&prnsim;": return 8936;
                case "&precnsim;": return 8936;
                case "&scnsim;": return 8937;
                case "&succnsim;": return 8937;
                case "&nltri;": return 8938;
                case "&ntriangleleft;": return 8938;
                case "&NotLeftTriangle;": return 8938;
                case "&nrtri;": return 8939;
                case "&ntriangleright;": return 8939;
                case "&NotRightTriangle;": return 8939;
                case "&nltrie;": return 8940;
                case "&ntrianglelefteq;": return 8940;
                case "&NotLeftTriangleEqual;": return 8940;
                case "&nrtrie;": return 8941;
                case "&ntrianglerighteq;": return 8941;
                case "&NotRightTriangleEqual;": return 8941;
                case "&vellip;": return 8942;
                case "&ctdot;": return 8943;
                case "&utdot;": return 8944;
                case "&dtdot;": return 8945;
                case "&disin;": return 8946;
                case "&isinsv;": return 8947;
                case "&isins;": return 8948;
                case "&isindot;": return 8949;
                case "&notinvc;": return 8950;
                case "&notinvb;": return 8951;
                case "&isinE;": return 8953;
                case "&nisd;": return 8954;
                case "&xnis;": return 8955;
                case "&nis;": return 8956;
                case "&notnivc;": return 8957;
                case "&notnivb;": return 8958;
                case "&barwed;": return 8965;
                case "&barwedge;": return 8965;
                case "&Barwed;": return 8966;
                case "&doublebarwedge;": return 8966;
                case "&lceil;": return 8968;
                case "&LeftCeiling;": return 8968;
                case "&rceil;": return 8969;
                case "&RightCeiling;": return 8969;
                case "&lfloor;": return 8970;
                case "&LeftFloor;": return 8970;
                case "&rfloor;": return 8971;
                case "&RightFloor;": return 8971;
                case "&drcrop;": return 8972;
                case "&dlcrop;": return 8973;
                case "&urcrop;": return 8974;
                case "&ulcrop;": return 8975;
                case "&bnot;": return 8976;
                case "&profline;": return 8978;
                case "&profsurf;": return 8979;
                case "&telrec;": return 8981;
                case "&target;": return 8982;
                case "&ulcorn;": return 8988;
                case "&ulcorner;": return 8988;
                case "&urcorn;": return 8989;
                case "&urcorner;": return 8989;
                case "&dlcorn;": return 8990;
                case "&llcorner;": return 8990;
                case "&drcorn;": return 8991;
                case "&lrcorner;": return 8991;
                case "&frown;": return 8994;
                case "&sfrown;": return 8994;
                case "&smile;": return 8995;
                case "&ssmile;": return 8995;
                case "&cylcty;": return 9005;
                case "&profalar;": return 9006;
                case "&topbot;": return 9014;
                case "&ovbar;": return 9021;
                case "&solbar;": return 9023;
                case "&angzarr;": return 9084;
                case "&lmoust;": return 9136;
                case "&lmoustache;": return 9136;
                case "&rmoust;": return 9137;
                case "&rmoustache;": return 9137;
                case "&tbrk;": return 9140;
                case "&OverBracket;": return 9140;
                case "&bbrk;": return 9141;
                case "&UnderBracket;": return 9141;
                case "&bbrktbrk;": return 9142;
                case "&OverParenthesis;": return 9180;
                case "&UnderParenthesis;": return 9181;
                case "&OverBrace;": return 9182;
                case "&UnderBrace;": return 9183;
                case "&trpezium;": return 9186;
                case "&elinters;": return 9191;
                case "&blank;": return 9251;
                case "&oS;": return 9416;
                case "&circledS;": return 9416;
                case "&boxh;": return 9472;
                case "&HorizontalLine;": return 9472;
                case "&boxv;": return 9474;
                case "&boxdr;": return 9484;
                case "&boxdl;": return 9488;
                case "&boxur;": return 9492;
                case "&boxul;": return 9496;
                case "&boxvr;": return 9500;
                case "&boxvl;": return 9508;
                case "&boxhd;": return 9516;
                case "&boxhu;": return 9524;
                case "&boxvh;": return 9532;
                case "&boxH;": return 9552;
                case "&boxV;": return 9553;
                case "&boxdR;": return 9554;
                case "&boxDr;": return 9555;
                case "&boxDR;": return 9556;
                case "&boxdL;": return 9557;
                case "&boxDl;": return 9558;
                case "&boxDL;": return 9559;
                case "&boxuR;": return 9560;
                case "&boxUr;": return 9561;
                case "&boxUR;": return 9562;
                case "&boxuL;": return 9563;
                case "&boxUl;": return 9564;
                case "&boxUL;": return 9565;
                case "&boxvR;": return 9566;
                case "&boxVr;": return 9567;
                case "&boxVR;": return 9568;
                case "&boxvL;": return 9569;
                case "&boxVl;": return 9570;
                case "&boxVL;": return 9571;
                case "&boxHd;": return 9572;
                case "&boxhD;": return 9573;
                case "&boxHD;": return 9574;
                case "&boxHu;": return 9575;
                case "&boxhU;": return 9576;
                case "&boxHU;": return 9577;
                case "&boxvH;": return 9578;
                case "&boxVh;": return 9579;
                case "&boxVH;": return 9580;
                case "&uhblk;": return 9600;
                case "&lhblk;": return 9604;
                case "&block;": return 9608;
                case "&blk14;": return 9617;
                case "&blk12;": return 9618;
                case "&blk34;": return 9619;
                case "&squ;": return 9633;
                case "&square;": return 9633;
                case "&Square;": return 9633;
                case "&squf;": return 9642;
                case "&squarf;": return 9642;
                case "&blacksquare;": return 9642;
                case "&FilledVerySmallSquare;": return 9642;
                case "&EmptyVerySmallSquare;": return 9643;
                case "&rect;": return 9645;
                case "&marker;": return 9646;
                case "&fltns;": return 9649;
                case "&xutri;": return 9651;
                case "&bigtriangleup;": return 9651;
                case "&utrif;": return 9652;
                case "&blacktriangle;": return 9652;
                case "&utri;": return 9653;
                case "&triangle;": return 9653;
                case "&rtrif;": return 9656;
                case "&blacktriangleright;": return 9656;
                case "&rtri;": return 9657;
                case "&triangleright;": return 9657;
                case "&xdtri;": return 9661;
                case "&bigtriangledown;": return 9661;
                case "&dtrif;": return 9662;
                case "&blacktriangledown;": return 9662;
                case "&dtri;": return 9663;
                case "&triangledown;": return 9663;
                case "&ltrif;": return 9666;
                case "&blacktriangleleft;": return 9666;
                case "&ltri;": return 9667;
                case "&triangleleft;": return 9667;
                case "&loz;": return 9674;
                case "&lozenge;": return 9674;
                case "&cir;": return 9675;
                case "&tridot;": return 9708;
                case "&xcirc;": return 9711;
                case "&bigcirc;": return 9711;
                case "&ultri;": return 9720;
                case "&urtri;": return 9721;
                case "&lltri;": return 9722;
                case "&EmptySmallSquare;": return 9723;
                case "&FilledSmallSquare;": return 9724;
                case "&starf;": return 9733;
                case "&bigstar;": return 9733;
                case "&star;": return 9734;
                case "&phone;": return 9742;
                case "&female;": return 9792;
                case "&male;": return 9794;
                case "&spades;": return 9824;
                case "&spadesuit;": return 9824;
                case "&clubs;": return 9827;
                case "&clubsuit;": return 9827;
                case "&hearts;": return 9829;
                case "&heartsuit;": return 9829;
                case "&diams;": return 9830;
                case "&diamondsuit;": return 9830;
                case "&sung;": return 9834;
                case "&flat;": return 9837;
                case "&natur;": return 9838;
                case "&natural;": return 9838;
                case "&sharp;": return 9839;
                case "&check;": return 10003;
                case "&checkmark;": return 10003;
                case "&cross;": return 10007;
                case "&malt;": return 10016;
                case "&maltese;": return 10016;
                case "&sext;": return 10038;
                case "&VerticalSeparator;": return 10072;
                case "&lbbrk;": return 10098;
                case "&rbbrk;": return 10099;
                case "&lobrk;": return 10214;
                case "&LeftDoubleBracket;": return 10214;
                case "&robrk;": return 10215;
                case "&RightDoubleBracket;": return 10215;
                case "&lang;": return 10216;
                case "&LeftAngleBracket;": return 10216;
                case "&langle;": return 10216;
                case "&rang;": return 10217;
                case "&RightAngleBracket;": return 10217;
                case "&rangle;": return 10217;
                case "&Lang;": return 10218;
                case "&Rang;": return 10219;
                case "&loang;": return 10220;
                case "&roang;": return 10221;
                case "&xlarr;": return 10229;
                case "&longleftarrow;": return 10229;
                case "&LongLeftArrow;": return 10229;
                case "&xrarr;": return 10230;
                case "&longrightarrow;": return 10230;
                case "&LongRightArrow;": return 10230;
                case "&xharr;": return 10231;
                case "&longleftrightarrow;": return 10231;
                case "&LongLeftRightArrow;": return 10231;
                case "&xlArr;": return 10232;
                case "&Longleftarrow;": return 10232;
                case "&DoubleLongLeftArrow;": return 10232;
                case "&xrArr;": return 10233;
                case "&Longrightarrow;": return 10233;
                case "&DoubleLongRightArrow;": return 10233;
                case "&xhArr;": return 10234;
                case "&Longleftrightarrow;": return 10234;
                case "&DoubleLongLeftRightArrow;": return 10234;
                case "&xmap;": return 10236;
                case "&longmapsto;": return 10236;
                case "&dzigrarr;": return 10239;
                case "&nvlArr;": return 10498;
                case "&nvrArr;": return 10499;
                case "&nvHarr;": return 10500;
                case "&Map;": return 10501;
                case "&lbarr;": return 10508;
                case "&rbarr;": return 10509;
                case "&bkarow;": return 10509;
                case "&lBarr;": return 10510;
                case "&rBarr;": return 10511;
                case "&dbkarow;": return 10511;
                case "&RBarr;": return 10512;
                case "&drbkarow;": return 10512;
                case "&DDotrahd;": return 10513;
                case "&UpArrowBar;": return 10514;
                case "&DownArrowBar;": return 10515;
                case "&Rarrtl;": return 10518;
                case "&latail;": return 10521;
                case "&ratail;": return 10522;
                case "&lAtail;": return 10523;
                case "&rAtail;": return 10524;
                case "&larrfs;": return 10525;
                case "&rarrfs;": return 10526;
                case "&larrbfs;": return 10527;
                case "&rarrbfs;": return 10528;
                case "&nwarhk;": return 10531;
                case "&nearhk;": return 10532;
                case "&searhk;": return 10533;
                case "&hksearow;": return 10533;
                case "&swarhk;": return 10534;
                case "&hkswarow;": return 10534;
                case "&nwnear;": return 10535;
                case "&nesear;": return 10536;
                case "&toea;": return 10536;
                case "&seswar;": return 10537;
                case "&tosa;": return 10537;
                case "&swnwar;": return 10538;
                case "&rarrc;": return 10547;
                case "&cudarrr;": return 10549;
                case "&ldca;": return 10550;
                case "&rdca;": return 10551;
                case "&cudarrl;": return 10552;
                case "&larrpl;": return 10553;
                case "&curarrm;": return 10556;
                case "&cularrp;": return 10557;
                case "&rarrpl;": return 10565;
                case "&harrcir;": return 10568;
                case "&Uarrocir;": return 10569;
                case "&lurdshar;": return 10570;
                case "&ldrushar;": return 10571;
                case "&LeftRightVector;": return 10574;
                case "&RightUpDownVector;": return 10575;
                case "&DownLeftRightVector;": return 10576;
                case "&LeftUpDownVector;": return 10577;
                case "&LeftVectorBar;": return 10578;
                case "&RightVectorBar;": return 10579;
                case "&RightUpVectorBar;": return 10580;
                case "&RightDownVectorBar;": return 10581;
                case "&DownLeftVectorBar;": return 10582;
                case "&DownRightVectorBar;": return 10583;
                case "&LeftUpVectorBar;": return 10584;
                case "&LeftDownVectorBar;": return 10585;
                case "&LeftTeeVector;": return 10586;
                case "&RightTeeVector;": return 10587;
                case "&RightUpTeeVector;": return 10588;
                case "&RightDownTeeVector;": return 10589;
                case "&DownLeftTeeVector;": return 10590;
                case "&DownRightTeeVector;": return 10591;
                case "&LeftUpTeeVector;": return 10592;
                case "&LeftDownTeeVector;": return 10593;
                case "&lHar;": return 10594;
                case "&uHar;": return 10595;
                case "&rHar;": return 10596;
                case "&dHar;": return 10597;
                case "&luruhar;": return 10598;
                case "&ldrdhar;": return 10599;
                case "&ruluhar;": return 10600;
                case "&rdldhar;": return 10601;
                case "&lharul;": return 10602;
                case "&llhard;": return 10603;
                case "&rharul;": return 10604;
                case "&lrhard;": return 10605;
                case "&udhar;": return 10606;
                case "&UpEquilibrium;": return 10606;
                case "&duhar;": return 10607;
                case "&ReverseUpEquilibrium;": return 10607;
                case "&RoundImplies;": return 10608;
                case "&erarr;": return 10609;
                case "&simrarr;": return 10610;
                case "&larrsim;": return 10611;
                case "&rarrsim;": return 10612;
                case "&rarrap;": return 10613;
                case "&ltlarr;": return 10614;
                case "&gtrarr;": return 10616;
                case "&subrarr;": return 10617;
                case "&suplarr;": return 10619;
                case "&lfisht;": return 10620;
                case "&rfisht;": return 10621;
                case "&ufisht;": return 10622;
                case "&dfisht;": return 10623;
                case "&lopar;": return 10629;
                case "&ropar;": return 10630;
                case "&lbrke;": return 10635;
                case "&rbrke;": return 10636;
                case "&lbrkslu;": return 10637;
                case "&rbrksld;": return 10638;
                case "&lbrksld;": return 10639;
                case "&rbrkslu;": return 10640;
                case "&langd;": return 10641;
                case "&rangd;": return 10642;
                case "&lparlt;": return 10643;
                case "&rpargt;": return 10644;
                case "&gtlPar;": return 10645;
                case "&ltrPar;": return 10646;
                case "&vzigzag;": return 10650;
                case "&vangrt;": return 10652;
                case "&angrtvbd;": return 10653;
                case "&ange;": return 10660;
                case "&range;": return 10661;
                case "&dwangle;": return 10662;
                case "&uwangle;": return 10663;
                case "&angmsdaa;": return 10664;
                case "&angmsdab;": return 10665;
                case "&angmsdac;": return 10666;
                case "&angmsdad;": return 10667;
                case "&angmsdae;": return 10668;
                case "&angmsdaf;": return 10669;
                case "&angmsdag;": return 10670;
                case "&angmsdah;": return 10671;
                case "&bemptyv;": return 10672;
                case "&demptyv;": return 10673;
                case "&cemptyv;": return 10674;
                case "&raemptyv;": return 10675;
                case "&laemptyv;": return 10676;
                case "&ohbar;": return 10677;
                case "&omid;": return 10678;
                case "&opar;": return 10679;
                case "&operp;": return 10681;
                case "&olcross;": return 10683;
                case "&odsold;": return 10684;
                case "&olcir;": return 10686;
                case "&ofcir;": return 10687;
                case "&olt;": return 10688;
                case "&ogt;": return 10689;
                case "&cirscir;": return 10690;
                case "&cirE;": return 10691;
                case "&solb;": return 10692;
                case "&bsolb;": return 10693;
                case "&boxbox;": return 10697;
                case "&trisb;": return 10701;
                case "&rtriltri;": return 10702;
                case "&LeftTriangleBar;": return 10703;
                case "&RightTriangleBar;": return 10704;
                case "&race;": return 10714;
                case "&iinfin;": return 10716;
                case "&infintie;": return 10717;
                case "&nvinfin;": return 10718;
                case "&eparsl;": return 10723;
                case "&smeparsl;": return 10724;
                case "&eqvparsl;": return 10725;
                case "&lozf;": return 10731;
                case "&blacklozenge;": return 10731;
                case "&RuleDelayed;": return 10740;
                case "&dsol;": return 10742;
                case "&xodot;": return 10752;
                case "&bigodot;": return 10752;
                case "&xoplus;": return 10753;
                case "&bigoplus;": return 10753;
                case "&xotime;": return 10754;
                case "&bigotimes;": return 10754;
                case "&xuplus;": return 10756;
                case "&biguplus;": return 10756;
                case "&xsqcup;": return 10758;
                case "&bigsqcup;": return 10758;
                case "&qint;": return 10764;
                case "&iiiint;": return 10764;
                case "&fpartint;": return 10765;
                case "&cirfnint;": return 10768;
                case "&awint;": return 10769;
                case "&rppolint;": return 10770;
                case "&scpolint;": return 10771;
                case "&npolint;": return 10772;
                case "&pointint;": return 10773;
                case "&quatint;": return 10774;
                case "&intlarhk;": return 10775;
                case "&pluscir;": return 10786;
                case "&plusacir;": return 10787;
                case "&simplus;": return 10788;
                case "&plusdu;": return 10789;
                case "&plussim;": return 10790;
                case "&plustwo;": return 10791;
                case "&mcomma;": return 10793;
                case "&minusdu;": return 10794;
                case "&loplus;": return 10797;
                case "&roplus;": return 10798;
                case "&Cross;": return 10799;
                case "&timesd;": return 10800;
                case "&timesbar;": return 10801;
                case "&smashp;": return 10803;
                case "&lotimes;": return 10804;
                case "&rotimes;": return 10805;
                case "&otimesas;": return 10806;
                case "&Otimes;": return 10807;
                case "&odiv;": return 10808;
                case "&triplus;": return 10809;
                case "&triminus;": return 10810;
                case "&tritime;": return 10811;
                case "&iprod;": return 10812;
                case "&intprod;": return 10812;
                case "&amalg;": return 10815;
                case "&capdot;": return 10816;
                case "&ncup;": return 10818;
                case "&ncap;": return 10819;
                case "&capand;": return 10820;
                case "&cupor;": return 10821;
                case "&cupcap;": return 10822;
                case "&capcup;": return 10823;
                case "&cupbrcap;": return 10824;
                case "&capbrcup;": return 10825;
                case "&cupcup;": return 10826;
                case "&capcap;": return 10827;
                case "&ccups;": return 10828;
                case "&ccaps;": return 10829;
                case "&ccupssm;": return 10832;
                case "&And;": return 10835;
                case "&Or;": return 10836;
                case "&andand;": return 10837;
                case "&oror;": return 10838;
                case "&orslope;": return 10839;
                case "&andslope;": return 10840;
                case "&andv;": return 10842;
                case "&orv;": return 10843;
                case "&andd;": return 10844;
                case "&ord;": return 10845;
                case "&wedbar;": return 10847;
                case "&sdote;": return 10854;
                case "&simdot;": return 10858;
                case "&congdot;": return 10861;
                case "&easter;": return 10862;
                case "&apacir;": return 10863;
                case "&apE;": return 10864;
                case "&eplus;": return 10865;
                case "&pluse;": return 10866;
                case "&Esim;": return 10867;
                case "&Colone;": return 10868;
                case "&Equal;": return 10869;
                case "&eDDot;": return 10871;
                case "&ddotseq;": return 10871;
                case "&equivDD;": return 10872;
                case "&ltcir;": return 10873;
                case "&gtcir;": return 10874;
                case "&ltquest;": return 10875;
                case "&gtquest;": return 10876;
                case "&les;": return 10877;
                case "&LessSlantEqual;": return 10877;
                case "&leqslant;": return 10877;
                case "&ges;": return 10878;
                case "&GreaterSlantEqual;": return 10878;
                case "&geqslant;": return 10878;
                case "&lesdot;": return 10879;
                case "&gesdot;": return 10880;
                case "&lesdoto;": return 10881;
                case "&gesdoto;": return 10882;
                case "&lesdotor;": return 10883;
                case "&gesdotol;": return 10884;
                case "&lap;": return 10885;
                case "&lessapprox;": return 10885;
                case "&gap;": return 10886;
                case "&gtrapprox;": return 10886;
                case "&lne;": return 10887;
                case "&lneq;": return 10887;
                case "&gne;": return 10888;
                case "&gneq;": return 10888;
                case "&lnap;": return 10889;
                case "&lnapprox;": return 10889;
                case "&gnap;": return 10890;
                case "&gnapprox;": return 10890;
                case "&lEg;": return 10891;
                case "&lesseqqgtr;": return 10891;
                case "&gEl;": return 10892;
                case "&gtreqqless;": return 10892;
                case "&lsime;": return 10893;
                case "&gsime;": return 10894;
                case "&lsimg;": return 10895;
                case "&gsiml;": return 10896;
                case "&lgE;": return 10897;
                case "&glE;": return 10898;
                case "&lesges;": return 10899;
                case "&gesles;": return 10900;
                case "&els;": return 10901;
                case "&eqslantless;": return 10901;
                case "&egs;": return 10902;
                case "&eqslantgtr;": return 10902;
                case "&elsdot;": return 10903;
                case "&egsdot;": return 10904;
                case "&el;": return 10905;
                case "&eg;": return 10906;
                case "&siml;": return 10909;
                case "&simg;": return 10910;
                case "&simlE;": return 10911;
                case "&simgE;": return 10912;
                case "&LessLess;": return 10913;
                case "&GreaterGreater;": return 10914;
                case "&glj;": return 10916;
                case "&gla;": return 10917;
                case "&ltcc;": return 10918;
                case "&gtcc;": return 10919;
                case "&lescc;": return 10920;
                case "&gescc;": return 10921;
                case "&smt;": return 10922;
                case "&lat;": return 10923;
                case "&smte;": return 10924;
                case "&late;": return 10925;
                case "&bumpE;": return 10926;
                case "&pre;": return 10927;
                case "&preceq;": return 10927;
                case "&PrecedesEqual;": return 10927;
                case "&sce;": return 10928;
                case "&succeq;": return 10928;
                case "&SucceedsEqual;": return 10928;
                case "&prE;": return 10931;
                case "&scE;": return 10932;
                case "&prnE;": return 10933;
                case "&precneqq;": return 10933;
                case "&scnE;": return 10934;
                case "&succneqq;": return 10934;
                case "&prap;": return 10935;
                case "&precapprox;": return 10935;
                case "&scap;": return 10936;
                case "&succapprox;": return 10936;
                case "&prnap;": return 10937;
                case "&precnapprox;": return 10937;
                case "&scnap;": return 10938;
                case "&succnapprox;": return 10938;
                case "&Pr;": return 10939;
                case "&Sc;": return 10940;
                case "&subdot;": return 10941;
                case "&supdot;": return 10942;
                case "&subplus;": return 10943;
                case "&supplus;": return 10944;
                case "&submult;": return 10945;
                case "&supmult;": return 10946;
                case "&subedot;": return 10947;
                case "&supedot;": return 10948;
                case "&subE;": return 10949;
                case "&subseteqq;": return 10949;
                case "&supE;": return 10950;
                case "&supseteqq;": return 10950;
                case "&subsim;": return 10951;
                case "&supsim;": return 10952;
                case "&subnE;": return 10955;
                case "&subsetneqq;": return 10955;
                case "&supnE;": return 10956;
                case "&supsetneqq;": return 10956;
                case "&csub;": return 10959;
                case "&csup;": return 10960;
                case "&csube;": return 10961;
                case "&csupe;": return 10962;
                case "&subsup;": return 10963;
                case "&supsub;": return 10964;
                case "&subsub;": return 10965;
                case "&supsup;": return 10966;
                case "&suphsub;": return 10967;
                case "&supdsub;": return 10968;
                case "&forkv;": return 10969;
                case "&topfork;": return 10970;
                case "&mlcp;": return 10971;
                case "&Dashv;": return 10980;
                case "&DoubleLeftTee;": return 10980;
                case "&Vdashl;": return 10982;
                case "&Barv;": return 10983;
                case "&vBar;": return 10984;
                case "&vBarv;": return 10985;
                case "&Vbar;": return 10987;
                case "&Not;": return 10988;
                case "&bNot;": return 10989;
                case "&rnmid;": return 10990;
                case "&cirmid;": return 10991;
                case "&midcir;": return 10992;
                case "&topcir;": return 10993;
                case "&nhpar;": return 10994;
                case "&parsim;": return 10995;
                case "&parsl;": return 11005;
                case "&fflig;": return 64256;
                case "&filig;": return 64257;
                case "&fllig;": return 64258;
                case "&ffilig;": return 64259;
                case "&ffllig;": return 64260;
                case "&Ascr;": return 119964;
                case "&Cscr;": return 119966;
                case "&Dscr;": return 119967;
                case "&Gscr;": return 119970;
                case "&Jscr;": return 119973;
                case "&Kscr;": return 119974;
                case "&Nscr;": return 119977;
                case "&Oscr;": return 119978;
                case "&Pscr;": return 119979;
                case "&Qscr;": return 119980;
                case "&Sscr;": return 119982;
                case "&Tscr;": return 119983;
                case "&Uscr;": return 119984;
                case "&Vscr;": return 119985;
                case "&Wscr;": return 119986;
                case "&Xscr;": return 119987;
                case "&Yscr;": return 119988;
                case "&Zscr;": return 119989;
                case "&ascr;": return 119990;
                case "&bscr;": return 119991;
                case "&cscr;": return 119992;
                case "&dscr;": return 119993;
                case "&fscr;": return 119995;
                case "&hscr;": return 119997;
                case "&iscr;": return 119998;
                case "&jscr;": return 119999;
                case "&kscr;": return 120000;
                case "&lscr;": return 120001;
                case "&mscr;": return 120002;
                case "&nscr;": return 120003;
                case "&pscr;": return 120005;
                case "&qscr;": return 120006;
                case "&rscr;": return 120007;
                case "&sscr;": return 120008;
                case "&tscr;": return 120009;
                case "&uscr;": return 120010;
                case "&vscr;": return 120011;
                case "&wscr;": return 120012;
                case "&xscr;": return 120013;
                case "&yscr;": return 120014;
                case "&zscr;": return 120015;
                case "&Afr;": return 120068;
                case "&Bfr;": return 120069;
                case "&Dfr;": return 120071;
                case "&Efr;": return 120072;
                case "&Ffr;": return 120073;
                case "&Gfr;": return 120074;
                case "&Jfr;": return 120077;
                case "&Kfr;": return 120078;
                case "&Lfr;": return 120079;
                case "&Mfr;": return 120080;
                case "&Nfr;": return 120081;
                case "&Ofr;": return 120082;
                case "&Pfr;": return 120083;
                case "&Qfr;": return 120084;
                case "&Sfr;": return 120086;
                case "&Tfr;": return 120087;
                case "&Ufr;": return 120088;
                case "&Vfr;": return 120089;
                case "&Wfr;": return 120090;
                case "&Xfr;": return 120091;
                case "&Yfr;": return 120092;
                case "&afr;": return 120094;
                case "&bfr;": return 120095;
                case "&cfr;": return 120096;
                case "&dfr;": return 120097;
                case "&efr;": return 120098;
                case "&ffr;": return 120099;
                case "&gfr;": return 120100;
                case "&hfr;": return 120101;
                case "&ifr;": return 120102;
                case "&jfr;": return 120103;
                case "&kfr;": return 120104;
                case "&lfr;": return 120105;
                case "&mfr;": return 120106;
                case "&nfr;": return 120107;
                case "&ofr;": return 120108;
                case "&pfr;": return 120109;
                case "&qfr;": return 120110;
                case "&rfr;": return 120111;
                case "&sfr;": return 120112;
                case "&tfr;": return 120113;
                case "&ufr;": return 120114;
                case "&vfr;": return 120115;
                case "&wfr;": return 120116;
                case "&xfr;": return 120117;
                case "&yfr;": return 120118;
                case "&zfr;": return 120119;
                case "&Aopf;": return 120120;
                case "&Bopf;": return 120121;
                case "&Dopf;": return 120123;
                case "&Eopf;": return 120124;
                case "&Fopf;": return 120125;
                case "&Gopf;": return 120126;
                case "&Iopf;": return 120128;
                case "&Jopf;": return 120129;
                case "&Kopf;": return 120130;
                case "&Lopf;": return 120131;
                case "&Mopf;": return 120132;
                case "&Oopf;": return 120134;
                case "&Sopf;": return 120138;
                case "&Topf;": return 120139;
                case "&Uopf;": return 120140;
                case "&Vopf;": return 120141;
                case "&Wopf;": return 120142;
                case "&Xopf;": return 120143;
                case "&Yopf;": return 120144;
                case "&aopf;": return 120146;
                case "&bopf;": return 120147;
                case "&copf;": return 120148;
                case "&dopf;": return 120149;
                case "&eopf;": return 120150;
                case "&fopf;": return 120151;
                case "&gopf;": return 120152;
                case "&hopf;": return 120153;
                case "&iopf;": return 120154;
                case "&jopf;": return 120155;
                case "&kopf;": return 120156;
                case "&lopf;": return 120157;
                case "&mopf;": return 120158;
                case "&nopf;": return 120159;
                case "&oopf;": return 120160;
                case "&popf;": return 120161;
                case "&qopf;": return 120162;
                case "&ropf;": return 120163;
                case "&sopf;": return 120164;
                case "&topf;": return 120165;
                case "&uopf;": return 120166;
                case "&vopf;": return 120167;
                case "&wopf;": return 120168;
                case "&xopf;": return 120169;
                case "&yopf;": return 120170;
                case "&zopf;": return 120171;
            }
            return 0;
        }
    }
}