001package org.hl7.fhir.utilities.xhtml;
002
003/*
004  Copyright (c) 2011+, HL7, Inc.
005  All rights reserved.
006
007  Redistribution and use in source and binary forms, with or without modification, 
008  are permitted provided that the following conditions are met:
009
010 * Redistributions of source code must retain the above copyright notice, this 
011     list of conditions and the following disclaimer.
012 * Redistributions in binary form must reproduce the above copyright notice, 
013     this list of conditions and the following disclaimer in the documentation 
014     and/or other materials provided with the distribution.
015 * Neither the name of HL7 nor the names of its contributors may be used to 
016     endorse or promote products derived from this software without specific 
017     prior written permission.
018
019  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND 
020  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 
021  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 
022  IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, 
023  INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 
024  NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR 
025  PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, 
026  WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 
027  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 
028  POSSIBILITY OF SUCH DAMAGE.
029
030 */
031
032
033
034import java.io.IOException;
035import java.io.InputStream;
036import java.io.InputStreamReader;
037import java.io.Reader;
038import java.io.StringReader;
039import java.nio.charset.StandardCharsets;
040import java.util.ArrayList;
041import java.util.HashMap;
042import java.util.HashSet;
043import java.util.List;
044import java.util.Map;
045import java.util.Set;
046
047import org.hl7.fhir.exceptions.FHIRException;
048import org.hl7.fhir.exceptions.FHIRFormatError;
049import org.hl7.fhir.utilities.StringPair;
050import org.hl7.fhir.utilities.FileUtilities;
051import org.hl7.fhir.utilities.Utilities;
052import org.hl7.fhir.utilities.i18n.I18nConstants;
053import org.hl7.fhir.utilities.xhtml.XhtmlNode.Location;
054import org.w3c.dom.Attr;
055import org.w3c.dom.Element;
056import org.w3c.dom.Node;
057import org.xmlpull.v1.XmlPullParser;
058import org.xmlpull.v1.XmlPullParserException;
059
060public class XhtmlParser {
061  public static final String XHTML_NS = "http://www.w3.org/1999/xhtml";
062  private static final char END_OF_CHARS = (char) -1;
063  private static final boolean DEBUG = false;
064
065  public class NamespaceNormalizationMap {
066
067    private String defaultNamespace;
068
069    private String originalNamespacePrefix;
070    private Map<String, String> map = new HashMap<String, String>();
071
072    public NamespaceNormalizationMap(NamespaceNormalizationMap namespaceMap) {
073      if (namespaceMap != null) {
074        map.putAll(namespaceMap.map);
075        this.defaultNamespace = namespaceMap.defaultNamespace;
076        this.originalNamespacePrefix = namespaceMap.originalNamespacePrefix;
077      }
078    }
079
080    public void setDefaultNamespace(String defaultNamespace) {
081      this.defaultNamespace = defaultNamespace;
082    }
083
084    /**
085     * Keeps track of the original namespace this element had before it was normalized
086     *
087     * This way, child elements using that prefix will be able recognize that they
088     * should use the default namespace.
089     *
090     * <namespaceA:parentElement xmlns:namespaceA="http://www.somewhere.org/namespaceA">
091     *   <namespaceA: childElement/>
092     * </namespaceA:parentElement>
093     *
094     * parentElement's namespaceA would become the default namespace.
095     *
096     * When normalizing childElement originalNamespacePrefix would be namespaceA,
097     * so we would know that childElement should use the default namespace.
098     *
099     * <parentElement xmlns="http://www.somewhere.org/namespaceA">
100     *   <childElement/>
101     * </parentElement>
102     *
103     * @param originalNamespacePrefix
104     */
105    public void setOriginalNamespacePrefix(String originalNamespacePrefix) {
106      this.originalNamespacePrefix = originalNamespacePrefix;
107    }
108
109    public void putNamespacePrefix(String prefix, String namespace) {
110      map.put(prefix, namespace);
111    }
112
113    public String getDefaultNamespace() {
114      return defaultNamespace;
115    }
116
117    public boolean hasDefaultNamespace() {
118      return defaultNamespace != null;
119    }
120
121    public String getNamespaceForPrefix(String prefix) {
122      if (originalNamespacePrefix != null && originalNamespacePrefix.equals(prefix)) {
123        return defaultNamespace;
124      }
125      return  map.containsKey(prefix) ? map.get(prefix) : "http://error/undefined-namespace";
126    }
127
128    public Set<Map.Entry<String, String>> getPrefixNamespaceEntrySet() {
129      return map.entrySet();
130    }
131  }
132
133  public class ElementName {
134    private String namespace;
135    private String name;
136
137    public ElementName(String src) {
138      if (src.contains(":")) {
139        namespace = src.substring(0, src.indexOf(":"));
140        name = src.substring(src.indexOf(":")+1);
141      } else {
142        namespace = null;
143        name = src;
144      }
145    }
146
147    public String getName() {
148      return name;
149    }
150
151    public boolean hasNamespace() {
152      return namespace != null;
153    }
154
155    public String getNamespace() {
156      return namespace;
157    }
158
159    @Override
160    public String toString() {
161      return namespace +"::"+name;
162    }
163
164  }
165
166  private Set<String> elements = new HashSet<String>();
167  private Set<String> attributes = new HashSet<String>();  
168  private Map<String, String> definedEntities = new HashMap<>();
169  private Map<String, String> declaredEntities = new HashMap<>();
170
171
172  public XhtmlParser() {
173    super();
174    policy = ParserSecurityPolicy.Accept; // for general parsing
175
176    // set up sets
177    elements.add("p");
178    elements.add("br");
179    elements.add("div");
180    elements.add("h1");
181    elements.add("h2");
182    elements.add("h3");
183    elements.add("h4");
184    elements.add("h5");
185    elements.add("h6");
186    elements.add("a");
187    elements.add("span");
188    elements.add("b");
189    elements.add("em");
190    elements.add("i");
191    elements.add("strong");
192    elements.add("small");
193    elements.add("big");
194    elements.add("tt");
195    elements.add("small");
196    elements.add("dfn");
197    elements.add("q");
198    elements.add("var");
199    elements.add("abbr");
200    elements.add("acronym");
201    elements.add("cite");
202    elements.add("blockquote");
203    elements.add("hr");
204    elements.add("address");
205    elements.add("bdo");
206    elements.add("kbd");
207    elements.add("q");
208    elements.add("sub");
209    elements.add("sup");
210    elements.add("ul");
211    elements.add("ol");
212    elements.add("li");
213    elements.add("dl");
214    elements.add("dt");
215    elements.add("dd");
216    elements.add("pre");
217    elements.add("table");
218    elements.add("caption");
219    elements.add("colgroup");
220    elements.add("col");
221    elements.add("thead");
222    elements.add("tr");
223    elements.add("tfoot");
224    elements.add("tbody");
225    elements.add("th");
226    elements.add("td");
227    elements.add("code");
228    elements.add("samp");
229    elements.add("img");
230    elements.add("map");
231    elements.add("area");
232
233    attributes.add("title");
234    attributes.add("style");
235    attributes.add("class");
236    attributes.add("id");
237    attributes.add("lang");
238    attributes.add("xml:lang");
239    attributes.add("dir");
240    attributes.add("accesskey");
241    attributes.add("tabindex");
242    // tables:
243    attributes.add("span");
244    attributes.add("width");
245    attributes.add("align");
246    attributes.add("valign");
247    attributes.add("char");
248    attributes.add("charoff");
249    attributes.add("abbr");
250    attributes.add("axis");
251    attributes.add("headers");
252    attributes.add("scope");
253    attributes.add("rowspan");
254    attributes.add("colspan");
255
256    attributes.add("a.href");
257    attributes.add("a.name");
258    attributes.add("img.src");
259    attributes.add("img.border");
260    attributes.add("div.xmlns");
261    attributes.add("blockquote.cite");
262    attributes.add("q.cite");
263    attributes.add("a.charset");
264    attributes.add("a.type");
265    attributes.add("a.name");
266    attributes.add("a.href");
267    attributes.add("a.hreflang");
268    attributes.add("a.rel");
269    attributes.add("a.rev");
270    attributes.add("a.shape");
271    attributes.add("a.coords");
272    attributes.add("img.src");
273    attributes.add("img.alt");
274    attributes.add("img.longdesc");
275    attributes.add("img.height");
276    attributes.add("img.width");
277    attributes.add("img.usemap");
278    attributes.add("img.ismap");
279    attributes.add("map.name");
280    attributes.add("area.shape");
281    attributes.add("area.coords");
282    attributes.add("area.href");
283    attributes.add("area.nohref");
284    attributes.add("area.alt");
285    attributes.add("table.summary");
286    attributes.add("table.width");
287    attributes.add("table.border");
288    attributes.add("table.frame");
289    attributes.add("table.rules");
290    attributes.add("table.cellspacing");
291    attributes.add("table.cellpadding");
292
293    defineEntities();
294  }
295
296  public enum ParserSecurityPolicy {
297    Accept,
298    Drop,
299    Reject
300  }
301
302  private ParserSecurityPolicy policy;
303
304  private boolean trimWhitespace;
305  private boolean mustBeWellFormed = true;
306  private List<StringPair> validationIssues = new ArrayList<>();
307
308  public boolean isTrimWhitespace() {
309    return trimWhitespace;
310  }
311
312  public void setTrimWhitespace(boolean trimWhitespace) {
313    this.trimWhitespace = trimWhitespace;
314  }
315
316  public boolean isMustBeWellFormed() {
317    return mustBeWellFormed;
318  }
319
320  public XhtmlParser setMustBeWellFormed(boolean mustBeWellFormed) {
321    this.mustBeWellFormed = mustBeWellFormed;
322    return this;
323  }
324
325  public boolean isXmlMode() {
326    return xmlMode;
327  }
328
329  public XhtmlParser setXmlMode(boolean xmlMode) {
330    this.xmlMode = xmlMode;
331    return this;
332  }
333
334  public ParserSecurityPolicy getPolicy() {
335    return policy;
336  }
337
338  public void setPolicy(ParserSecurityPolicy policy) {
339    this.policy = policy; 
340  }
341
342  public List<StringPair> getValidationIssues() {
343    return validationIssues;
344  }
345
346  public XhtmlNode parseHtmlNode(Element node) throws FHIRFormatError  {
347    return parseHtmlNode(node, null);
348  }
349
350  public XhtmlNode parseHtmlNode(Element node, String defaultNS) throws FHIRFormatError  {
351    XhtmlNode res = parseNode(node, defaultNS);
352    if (res.getNsDecl() == null)
353      res.getAttributes().put("xmlns", XHTML_NS);
354    return res;
355  }
356
357  private XhtmlNode parseNode(Element node, String defaultNS) throws FHIRFormatError  {
358    XhtmlNode res = new XhtmlNode(NodeType.Element);
359    res.setName(node.getLocalName());
360    defaultNS = checkNS(res, node, defaultNS);
361    for (int i = 0; i < node.getAttributes().getLength(); i++) {
362      Attr attr = (Attr) node.getAttributes().item(i);
363      if (attributeIsOk(res.getName(), attr.getName(), attr.getValue()) && !attr.getLocalName().startsWith("xmlns"))
364        res.getAttributes().put(attr.getName(), attr.getValue());
365    }
366    Node child = node.getFirstChild();
367    while (child != null) {
368      if (child.getNodeType() == Node.TEXT_NODE) {
369        res.addText(child.getTextContent());
370      } else if (child.getNodeType() == Node.COMMENT_NODE) {
371        res.addComment(child.getTextContent());
372      } else if (child.getNodeType() == Node.ELEMENT_NODE) {
373        if (elementIsOk(child.getLocalName()))
374          res.addChildNode(parseNode((Element) child, defaultNS));
375      } else
376        throw new FHIRFormatError("Unhandled XHTML feature: "+Integer.toString(child.getNodeType())+descLoc());
377      child = child.getNextSibling();
378    }
379    return res;
380  }  
381
382  private String checkNS(XhtmlNode res, Element node, String defaultNS) {
383    String ns = node.getNamespaceURI();
384    if (ns == null)
385      return null;
386    if (!ns.equals(defaultNS)) {
387      res.getAttributes().put("xmlns", ns);
388      return ns;
389    }
390    return defaultNS;
391  }
392
393  public XhtmlNode parseHtmlNode(XmlPullParser xpp) throws XmlPullParserException, IOException, FHIRFormatError  {
394    XhtmlNode res = parseNode(xpp);
395    if (res.getNsDecl() == null)
396      res.getAttributes().put("xmlns", XHTML_NS);
397    return res;
398
399  }
400  private XhtmlNode parseNode(XmlPullParser xpp) throws XmlPullParserException, IOException, FHIRFormatError  {
401    XhtmlNode res = new XhtmlNode(NodeType.Element);
402    res.setName(xpp.getName());
403
404    for (int i = 0; i < xpp.getAttributeCount(); i++) {
405      String an = "xml".equals(xpp.getAttributePrefix(i)) ? "xml:"+xpp.getAttributeName(i) : xpp.getAttributeName(i);
406      String av = xpp.getAttributeValue(i);
407      if (attributeIsOk(xpp.getName(), an, av)) {
408        res.getAttributes().put(an, av);
409      }
410    }
411    int eventType = xpp.next();
412    while (eventType != XmlPullParser.END_TAG) {
413      if (eventType == XmlPullParser.TEXT) {
414        res.addText(xpp.getText());
415        xpp.next();
416      } else if (eventType == XmlPullParser.COMMENT) {
417        res.addComment(xpp.getText());
418        xpp.next();
419      } else if (eventType == XmlPullParser.START_TAG) {
420        if (elementIsOk(xpp.getName()))
421          res.addChildNode(parseNode(xpp));
422      } else
423        throw new FHIRFormatError("Unhandled XHTML feature: "+Integer.toString(eventType)+descLoc());
424      eventType = xpp.getEventType();
425    }
426    xpp.next();
427    return res;
428  }  
429
430  private boolean attributeIsOk(String elem, String attr, String value) throws FHIRFormatError  {
431    boolean ok = attributes.contains(attr) || attributes.contains(elem+"."+attr);
432    if (ok)
433      return true;
434    else switch (policy) {
435    case Accept: return true;
436    case Drop: return false;
437    case Reject: return error(I18nConstants.XHTML_XHTML_ATTRIBUTE_ILLEGAL, elem+"."+attr);
438    }
439
440    if ((elem+"."+attr).equals("img.src") && !(value.startsWith("#") || value.startsWith("http:") || value.startsWith("https:"))) {
441      switch (policy) {
442      case Accept: return true;
443      case Drop: return false;
444      case Reject: return error(I18nConstants.XHTML_XHTML_Image_Reference_Illegal, value);
445      }
446    }
447    return false;
448  }
449
450  private boolean error(String msg, String param) {
451    validationIssues.add(new StringPair(msg, param));
452    return false;
453  }
454
455  private boolean elementIsOk(String name) throws FHIRFormatError  {
456    boolean ok = elements.contains(name);
457    if (ok)
458      return true;
459    else switch (policy) {
460    case Accept: return true;
461    case Drop: return false;
462    case Reject: return error(I18nConstants.XHTML_XHTML_ELEMENT_ILLEGAL, name);
463    }
464    return false;
465  }
466
467  private String descLoc() {
468    return " at line "+Integer.toString(line)+" column "+Integer.toString(col);
469  }
470
471  private Reader rdr;
472  private String cache = "";
473  private XhtmlNode unwindPoint;
474  private String lastText = "";
475  private int line = 1;
476  private int col = 0;
477  private char lastChar;
478  private Location lastLoc;
479  private boolean xmlMode;
480
481  public XhtmlDocument parse(String source, String entryName) throws FHIRFormatError, IOException  {
482    rdr = new StringReader(source);
483    return parse(entryName);
484  }
485
486  public XhtmlDocument parse(InputStream input, String entryName) throws FHIRFormatError, IOException  {
487    rdr = new InputStreamReader(input, StandardCharsets.UTF_8);
488    return parse(entryName);
489  }
490
491  private XhtmlDocument parse(String entryName) throws FHIRFormatError, IOException 
492  {
493    XhtmlDocument result = new XhtmlDocument();
494    skipWhiteSpaceAndComments(result);
495    if (peekChar() != '<')
496      throw new FHIRFormatError("Unable to Parse HTML - does not start with tag. Found '"+peekChar()+"' "+descLoc());
497    readChar();
498    markLocation();
499    ElementName n = new ElementName(readName().toLowerCase());
500    if ((entryName != null) && !n.getName().equals(entryName))
501      throw new FHIRFormatError("Unable to Parse HTML - starts with '"+n+"' not '"+entryName+"'"+descLoc());
502    XhtmlNode root = result.addTag(n.getName());
503    root.setCheckParaTree(false);
504    root.setLocation(markLocation());
505    parseAttributes(root);
506    markLocation();
507    NamespaceNormalizationMap nsm = normalizeNamespaces(n, root, null, true);
508    if (readChar() == '/') {
509      if (peekChar() != '>')
510        throw new FHIRFormatError("unexpected non-end of element "+n+" "+descLoc());
511      readChar();
512      root.setEmptyExpanded(false);
513    } else {
514      unwindPoint = null;
515      List<XhtmlNode> p = new ArrayList<>();
516      parseElementInner(root, p, nsm);
517      root.setEmptyExpanded(true);
518    }
519    return result;
520  }
521
522  private Location markLocation() {
523    Location res = lastLoc;
524    lastLoc = new Location(line, col);
525    return res;
526  }
527
528  private NamespaceNormalizationMap normalizeNamespaces(ElementName elementName, XhtmlNode node, NamespaceNormalizationMap parentNamespaceMap, boolean nodeIsRoot) {
529    // what we do here is strip out any stated namespace attributes, putting them in the namespace map
530    // then we figure out what the namespace of this element is, and state it explicitly if it's not the default
531
532    NamespaceNormalizationMap nodeNamespaceMap = new NamespaceNormalizationMap(parentNamespaceMap);
533    List<String> namespaceAttributes = new ArrayList<String>();
534    for (String an : node.getAttributes().keySet()) {
535      if (an.equals("xmlns")) {
536        nodeNamespaceMap.setDefaultNamespace(node.getAttribute(an));
537        namespaceAttributes.add(an);
538      }
539      if (an.startsWith("xmlns:")) {
540        nodeNamespaceMap.putNamespacePrefix(an.substring(6), node.getAttribute(an));
541        namespaceAttributes.add(an);
542      }
543    }
544
545    for (String s : namespaceAttributes)
546      node.getAttributes().remove(s);
547    if (elementName.hasNamespace()) {
548      String elementNamespace = nodeNamespaceMap.getNamespaceForPrefix(elementName.getNamespace());
549      if (!elementNamespace.equals(nodeNamespaceMap.getDefaultNamespace())) {
550        node.getAttributes().put("xmlns", elementNamespace);
551        nodeNamespaceMap.setDefaultNamespace(elementNamespace);
552        nodeNamespaceMap.setOriginalNamespacePrefix(elementName.getNamespace());
553        nodeNamespaceMap.map.remove(elementName.getNamespace());
554      }
555    }
556    // Add namespaces back if not defined in parentNamespaceMap (we haven't seen it before, so we need to define it here)
557    if (shouldAddXmlnsNamespaceAttribute(parentNamespaceMap, nodeIsRoot, nodeNamespaceMap)) {
558      node.getAttributes().put("xmlns", nodeNamespaceMap.getDefaultNamespace());
559    }
560    for (Map.Entry<String, String> entry : nodeNamespaceMap.getPrefixNamespaceEntrySet() ) {
561      if (shouldAddXmlnsNamespacePrefixAttribute(parentNamespaceMap, nodeIsRoot, entry.getKey())) {
562        node.getAttributes().put("xmlns:" + entry.getKey(), entry.getValue());
563      }
564    }
565
566    return nodeNamespaceMap;
567  }
568
569  private static boolean shouldAddXmlnsNamespacePrefixAttribute(NamespaceNormalizationMap parentNamespaceMap, boolean nodeIsRoot, String attributeKey) {
570    if (nodeIsRoot) {
571      return true;
572    }
573    return  (!parentNamespaceMap.map.containsKey(attributeKey));
574  }
575
576  private static boolean shouldAddXmlnsNamespaceAttribute(NamespaceNormalizationMap parentNamespaceMap, boolean nodeIsRoot, NamespaceNormalizationMap nodeNamespaceMap) {
577    if (nodeIsRoot) {
578      return nodeNamespaceMap.hasDefaultNamespace();
579    }
580    return nodeNamespaceMap.hasDefaultNamespace() && (parentNamespaceMap == null || !nodeNamespaceMap.getDefaultNamespace().equals(parentNamespaceMap.getDefaultNamespace()));
581  }
582
583  private void addTextNode(XhtmlNode node, StringBuilder s) {
584    String t = isTrimWhitespace() ? s.toString().trim() : s.toString();
585    if (t.length() > 0) {
586      lastText = t;
587      node.addText(t).setLocation(markLocation());
588      s.setLength(0);
589    }
590  }
591  
592  private void parseElementInner(XhtmlNode node, List<XhtmlNode> parents, NamespaceNormalizationMap nsm) throws FHIRFormatError, IOException
593  {
594    StringBuilder s = new StringBuilder();
595    while (peekChar() != END_OF_CHARS && !parents.contains(unwindPoint) && !(node == unwindPoint))
596    {
597      if (peekChar() == '<')
598      {
599        addTextNode(node, s);
600        readChar();
601        if (peekChar() == '!') {
602          readChar();
603          String sc;
604          if (peekChar() == '[') {
605            sc = readCData();
606            node.addCData(sc).setLocation(markLocation());
607          } else {
608            pushChar('!');
609            sc = readToCommentEnd(true);
610            node.addComment(sc).setLocation(markLocation());
611          }
612        } else if (peekChar() == '?')
613          node.addComment(readToTagEnd()).setLocation(markLocation());
614        else if (peekChar() == '/') {
615          readChar();
616          ElementName n = new ElementName(readToTagEnd());
617          if (node.getName().equals(n.getName()))
618            return;
619          else
620          {
621            if (mustBeWellFormed) {
622              throw new FHIRFormatError("Malformed XHTML: Found \"</"+n.getName()+">\" expecting \"</"+node.getName()+">\""+descLoc());
623            }
624            for (int i = parents.size() - 1; i >= 0; i--)
625            {
626              if (parents.get(i).getName().equals(n))
627                unwindPoint = parents.get(i);
628            }
629            if (unwindPoint != null)
630            {
631              for (int i = parents.size(); i > 0; i--)
632              {
633                if (i < parents.size() && parents.get(i) == unwindPoint)
634                  return;
635                if (i == parents.size())
636                {
637                  parents.get(i - 1).addChildNodes(node.getChildNodes());
638                  node.getChildNodes().clear();
639                }
640                else
641                {
642                  parents.get(i - 1).addChildNodes(parents.get(i).getChildNodes());
643                  parents.get(i).getChildNodes().clear();
644                }
645              }
646            }
647          }
648        }
649        else if (Character.isLetterOrDigit(peekChar()))
650        {
651          parseElement(node, parents, nsm);
652        }
653        else
654          throw new FHIRFormatError("Unable to Parse HTML - node '" + node.getName() + "' has unexpected content '"+peekChar()+"' (last text = '"+lastText+"'"+descLoc());
655      }
656      else if (peekChar() == '&') // escaping && 
657      {
658        parseLiteral(s);
659      }
660      else
661        s.append(readChar());
662    }
663    addTextNode(node, s);
664  }
665
666
667  private void parseScriptInner(XhtmlNode node) throws FHIRFormatError, IOException {
668    StringBuilder s = new StringBuilder();
669    while (peekChar() != END_OF_CHARS && !s.toString().endsWith("</script>")) {
670      s.append(readChar());
671    }      
672    String ss = s.toString();
673    if (ss.length() >= 9) {
674      ss = ss.substring(0, ss.length()-9);
675    }
676    String t = isTrimWhitespace() ? ss.trim() : ss;
677    if (t.length() > 0) {
678      lastText = t;
679      node.addText(t).setLocation(markLocation());
680    }
681  }
682
683  private void parseElement(XhtmlNode parent, List<XhtmlNode> parents, NamespaceNormalizationMap namespaceMap) throws IOException, FHIRFormatError
684  {
685    markLocation();
686    ElementName name = new ElementName(readName());
687    XhtmlNode node = parent.addTag(name.getName());
688    node.setLocation(markLocation());
689    List<XhtmlNode> newParents = new ArrayList<XhtmlNode>();
690    newParents.addAll(parents);
691    newParents.add(parent);
692    parseAttributes(node);
693    markLocation();
694    namespaceMap = normalizeNamespaces(name, node, namespaceMap, false);
695    if (readChar() == '/') {
696      if (peekChar() != '>')
697        throw new FHIRFormatError("unexpected non-end of element "+name+" "+descLoc());
698      readChar();
699      node.setEmptyExpanded(false);
700    } else if ("script".equals(name.getName())) {
701      parseScriptInner(node);
702    } else {
703      node.setEmptyExpanded(true);
704      parseElementInner(node, newParents, namespaceMap);
705    }
706  }
707
708  private void parseAttributes(XhtmlNode node) throws FHIRFormatError, IOException 
709  {
710    while (Character.isWhitespace(peekChar()))
711      readChar();
712    while (peekChar() != '>' && peekChar() != '/' && peekChar() != END_OF_CHARS)
713    {
714      String name = readName();
715      if (name.length() == 0)
716      {
717        throw new FHIRFormatError("Unable to read attribute on <"+node.getName()+">"+descLoc());
718      }
719      while (Character.isWhitespace(peekChar()))
720        readChar();
721
722      if (isNameChar(peekChar()) || peekChar() == '>' || peekChar() == '/')
723        node.getAttributes().put(name, null);
724      else if (peekChar() != '=')
725      {
726        throw new FHIRFormatError("Unable to read attribute '"+name+"' value on <"+node.getName()+">"+descLoc());
727      }
728      else
729      {
730        readChar();
731        while (Character.isWhitespace(peekChar()))
732          readChar();
733        if (peekChar() == '"' || peekChar() == '\'')
734          node.getAttributes().put(name, parseAttributeValue(readChar()));
735        else
736          node.getAttributes().put(name, parseAttributeValue(END_OF_CHARS));
737      }
738      while (Character.isWhitespace(peekChar()))
739        readChar();
740    }
741  }
742
743  private String parseAttributeValue(char term) throws IOException, FHIRFormatError 
744  {
745    StringBuilder b = new StringBuilder();
746    while (peekChar() != END_OF_CHARS && peekChar() != '>' && (term != END_OF_CHARS || peekChar() != '/') && peekChar() != term)
747    {
748      if (peekChar() == '&')
749      {
750        parseLiteral(b);
751      }
752      else
753        b.append(readChar());
754    }
755    if (peekChar() == term)
756      readChar();
757    return b.toString();
758  }
759
760
761  private void skipWhiteSpaceAndComments(XhtmlNode focus) throws IOException, FHIRFormatError  {
762    while (Character.isWhitespace(peekChar()) || (peekChar() == 0xfeff))
763      readChar();
764    if (peekChar() == '<')
765    {
766      char ch = readChar();
767      if (peekChar() == '!') {
768        readChar();
769        if (peekChar() == '-') {
770          readChar();
771          if (peekChar() == '-') {
772            readChar();
773            if (peekChar() == ' ')
774              readChar();
775            focus.addComment(readToCommentEnd(false));
776          } else 
777            throw new FHIRFormatError("unrecognised element type <!"+peekChar()+descLoc());
778        } else
779          focus.addDocType(readToDocTypeEnd());
780        skipWhiteSpaceAndComments(focus);
781      } else if (peekChar() == '?') {
782        String r = readToTagEnd();
783        focus.addInstruction(r.substring(1, r.length()-1));
784        skipWhiteSpaceAndComments(focus);
785      } else 
786        pushChar(ch);
787    }
788  }  
789
790  private void skipWhiteSpace() throws IOException {
791    if (trimWhitespace)
792      while (Character.isWhitespace(peekChar()) || (peekChar() == 0xfeff))
793        readChar();
794  }
795
796  private void skipWhiteSpaceInternal() throws IOException {
797    while (Character.isWhitespace(peekChar()) || (peekChar() == 0xfeff))
798      readChar();
799  }
800
801  private void pushChar(char ch) {
802    cache = Character.toString(ch)+cache;    
803  }
804
805  private char peekChar() throws IOException
806  {
807    if (cache.length() > 0)
808      return cache.charAt(0);
809    else if (!rdr.ready())
810      return END_OF_CHARS;
811    else
812    {
813      int i = rdr.read();
814      if (i == -1)       {
815        cache = "";
816        return END_OF_CHARS;
817      }
818      char c = (char) i;
819      cache =  Character.toString(c);
820      return c;
821    }
822  }
823
824  private char readChar() throws IOException
825  {
826    char c;
827    if (cache.length() > 0)
828    {
829      c = cache.charAt(0);
830      cache = cache.length() == 1 ? "" : cache.substring(1);
831    }
832    else if (!rdr.ready())
833      c = END_OF_CHARS;
834    else
835      c = (char)rdr.read();
836    if (c == '\r' || c == '\n') {
837      if (c == '\r' || lastChar != '\r') {
838        line++;
839        col = 0;
840      }  
841      lastChar = c;      
842    }      
843    col++;
844    return c;
845  }
846
847  private String readToTagEnd() throws IOException, FHIRFormatError 
848  {
849    StringBuilder s = new StringBuilder();
850    while (peekChar() != '>' && peekChar() != END_OF_CHARS)
851      s.append(readChar());
852    if (peekChar() != END_OF_CHARS)
853    {
854      readChar();
855      skipWhiteSpace();
856    } else if (mustBeWellFormed)
857      throw new FHIRFormatError("Unexpected termination of html source"+descLoc());
858    return s.toString();
859  }
860
861  private String readToDocTypeEnd() throws IOException, FHIRFormatError 
862  {
863    StringBuilder s = new StringBuilder();
864
865    boolean done = false;
866    while (!done) {
867      char c = peekChar();
868      if (c == '>') {
869        done = true;
870        readChar();
871      } else if (c != END_OF_CHARS)
872        s.append(readChar());
873      else if (mustBeWellFormed)
874        throw new FHIRFormatError("Unexpected termination of html source"+descLoc());
875    }
876    return s.toString();
877  }
878
879  private String readToCommentEnd(boolean simple) throws IOException, FHIRFormatError
880  {
881    if (peekChar() == '!')
882      readChar();
883    StringBuilder s = new StringBuilder();
884    if (peekChar() == '-') {
885      readChar();
886      simple = peekChar() != '-';
887      if (simple)
888        s.append('-');
889      else
890        readChar();
891    }
892
893    boolean doctypeEntities = false;
894
895    boolean done = false;
896    while (!done) {
897      char c = peekChar();
898      if (c == '-') {
899        readChar();
900        if (peekChar() == '-') {
901          readChar();
902          if (peekChar() == '>') {
903            done = true;
904          } else {
905            pushChar('-');
906            s.append("-");
907          }
908        } else 
909          s.append('-');
910      } else if (doctypeEntities && c == ']') {
911        s.append(readChar());
912        if (peekChar() == '>') {
913          done = true;
914        }
915      } else if (simple && peekChar() == '>' && !doctypeEntities) {
916        done = true;
917      } else if (c == '[' && s.toString().startsWith("DOCTYPE ")) {
918        doctypeEntities = true;
919        s.append(readChar());
920      } else if (c != END_OF_CHARS)
921        s.append(readChar());
922      else if (mustBeWellFormed)
923        throw new FHIRFormatError("Unexpected termination of html source"+descLoc());
924    }
925    if (peekChar() != END_OF_CHARS)
926    {
927      readChar();
928      skipWhiteSpace();
929    }
930    if (doctypeEntities) {
931      parseDoctypeEntities(s.toString());
932    }
933    return s.toString();
934  }
935
936  private String readCData() throws IOException, FHIRFormatError {
937    StringBuilder s = new StringBuilder();
938    boolean done = false;
939    while (!done) {
940      s.append(readChar());
941      done = s.toString().endsWith("]]>");
942    }
943    String res = s.toString().substring(7);
944    res = res.substring(0, res.length()-3);
945    return res;
946  }
947
948  private void parseDoctypeEntities(String s) {
949    while (s.contains("<!ENTITY")) {
950      s = s.substring(s.indexOf("<!ENTITY"));
951      int e = s.indexOf(">");
952      String ed = s.substring(0, e+1);
953      s = s.substring(e+1);
954      ed = ed.substring(8).trim();
955      e = ed.indexOf(" ");
956      String n = ed.substring(0, e).trim();
957      ed = ed.substring(e).trim();
958      e = ed.indexOf(" "); // SYSTEM
959      ed = ed.substring(e).trim();
960      String v = ed.substring(0, ed.length()-1);
961      declaredEntities.put(n, v);
962    }
963
964  }
965
966  private boolean isNameChar(char ch)
967  {
968    return Character.isLetterOrDigit(ch) || ch == '_' || ch == '-' || ch == ':' || ch == '.';
969  }
970
971  private String readName() throws IOException
972  {
973    StringBuilder s = new StringBuilder();
974    while (isNameChar(peekChar()))
975      s.append(readChar());
976    return s.toString();
977  }
978
979  private String readUntil(char ch) throws IOException
980  {
981    StringBuilder s = new StringBuilder();
982    while (peekChar() != 0 && peekChar() != ch)
983      s.append(readChar());
984    readChar();
985    return s.toString();
986  }
987
988
989  private String readUntil(String sc) throws IOException
990  {
991    StringBuilder s = new StringBuilder();
992    while (peekChar() != 0 && sc.indexOf(peekChar()) == -1)
993      s.append(readChar());
994    readChar();
995    return s.toString();
996  }
997
998  private void parseLiteral(StringBuilder s) throws IOException, FHIRFormatError {
999    // UInt16 w;
1000    readChar();
1001    String c = readUntil(";&'\"><");
1002    if (c.isEmpty())
1003      throw new FHIRFormatError("Invalid literal declaration following text: " + s);
1004    else if (c.charAt(0) == '#') {
1005      if (isInteger(c.substring(1), 10))
1006        s.append(Character.toString(Integer.parseInt(c.substring(1))));
1007      else if (c.charAt(1) == 'x' && isInteger(c.substring(2), 16))
1008        s.append(Character.toString(Integer.parseInt(c.substring(2), 16)));
1009    } else if (declaredEntities.containsKey(c)) {
1010      s.append(declaredEntities.get(c));
1011    } else {
1012      if (xmlMode) {
1013        if (!Utilities.existsInList(c, "quot", "amp", "apos", "lt", "gt")) {
1014          error(I18nConstants.XHTML_XHTML_Entity_Illegal, "&"+c+";");
1015        }
1016      }
1017      if (definedEntities.containsKey("&"+c+";")) {
1018        s.append(definedEntities.get("&"+c+";"));
1019        // what's going on here? 
1020        // the contents that follow already existed, and then I added the routine to populate the entities 
1021        // which was generated from other code. The code that follows is probably redundant, but I haven't
1022        // cross checked it. some is welcome to do so... (GG 8-Nov 2021)
1023      } else if (c.equals("apos"))
1024        s.append('\'');
1025      else if (c.equals("quot"))
1026        s.append('"');
1027      else if (c.equals("nbsp"))
1028        s.append(XhtmlNode.NBSP);
1029      else if (c.equals("amp"))
1030        s.append('&');
1031      else if (c.equals("lsquo"))
1032        s.append((char) 8216); // right single quotation, U+2019 ISOnum 
1033      else if (c.equals("rsquo"))
1034        s.append((char) 8217); // right single quotation, U+2019 ISOnum 
1035      else if (c.equals("gt"))
1036        s.append('>');
1037      else if (c.equals("lt"))
1038        s.append('<');
1039      else if (c.equals("copy"))
1040        s.append((char) 169);
1041      else if (c.equals("reg"))
1042        s.append((char) 174);
1043      else if (c.equals("sect"))
1044        s.append((char) 0xA7);
1045      else if (c.equals("fnof"))
1046        s.append((char) 402); // latin small f with hook = function = florin, U+0192 ISOtech -->
1047      else if (c.equals("Alpha"))
1048        s.append((char) 913); // greek capital letter alpha, U+0391
1049      else if (c.equals("Beta"))
1050        s.append((char) 914); // greek capital letter beta, U+0392
1051      else if (c.equals("Gamma"))
1052        s.append((char) 915); // greek capital letter gamma, U+0393 ISOgrk3
1053      else if (c.equals("Delta"))
1054        s.append((char) 916); // greek capital letter delta, U+0394 ISOgrk3
1055      else if (c.equals("Epsilon"))
1056        s.append((char) 917); // greek capital letter epsilon, U+0395
1057      else if (c.equals("Zeta"))
1058        s.append((char) 918); // greek capital letter zeta, U+0396
1059      else if (c.equals("Eta"))
1060        s.append((char) 919); // greek capital letter eta, U+0397
1061      else if (c.equals("Theta"))
1062        s.append((char) 920); // greek capital letter theta, U+0398 ISOgrk3
1063      else if (c.equals("Iota"))
1064        s.append((char) 921); // greek capital letter iota, U+0399
1065      else if (c.equals("Kappa"))
1066        s.append((char) 922); // greek capital letter kappa, U+039A
1067      else if (c.equals("Lambda"))
1068        s.append((char) 923); // greek capital letter lambda, U+039B ISOgrk3
1069      else if (c.equals("Mu"))
1070        s.append((char) 924); // greek capital letter mu, U+039C
1071      else if (c.equals("Nu"))
1072        s.append((char) 925); // greek capital letter nu, U+039D
1073      else if (c.equals("Xi"))
1074        s.append((char) 926); // greek capital letter xi, U+039E ISOgrk3
1075      else if (c.equals("Omicron"))
1076        s.append((char) 927); // greek capital letter omicron, U+039F
1077      else if (c.equals("Pi"))
1078        s.append((char) 928); // greek capital letter pi, U+03A0 ISOgrk3
1079      else if (c.equals("Rho"))
1080        s.append((char) 929); // greek capital letter rho, U+03A1
1081      else if (c.equals("Sigma"))
1082        s.append((char) 931); // greek capital letter sigma, U+03A3 ISOgrk3
1083      else if (c.equals("Tau"))
1084        s.append((char) 932); // greek capital letter tau, U+03A4
1085      else if (c.equals("Upsilon"))
1086        s.append((char) 933); // greek capital letter upsilon, U+03A5 ISOgrk3
1087      else if (c.equals("Phi"))
1088        s.append((char) 934); // greek capital letter phi, U+03A6 ISOgrk3
1089      else if (c.equals("Chi"))
1090        s.append((char) 935); // greek capital letter chi, U+03A7
1091      else if (c.equals("Psi"))
1092        s.append((char) 936); // greek capital letter psi, U+03A8 ISOgrk3
1093      else if (c.equals("Omega"))
1094        s.append((char) 937); // greek capital letter omega, U+03A9 ISOgrk3
1095      else if (c.equals("alpha"))
1096        s.append((char) 945); // greek small letter alpha, U+03B1 ISOgrk3
1097      else if (c.equals("beta"))
1098        s.append((char) 946); // greek small letter beta, U+03B2 ISOgrk3
1099      else if (c.equals("gamma"))
1100        s.append((char) 947); // greek small letter gamma, U+03B3 ISOgrk3
1101      else if (c.equals("delta"))
1102        s.append((char) 948); // greek small letter delta, U+03B4 ISOgrk3
1103      else if (c.equals("epsilon"))
1104        s.append((char) 949); // greek small letter epsilon, U+03B5 ISOgrk3
1105      else if (c.equals("zeta"))
1106        s.append((char) 950); // greek small letter zeta, U+03B6 ISOgrk3
1107      else if (c.equals("eta"))
1108        s.append((char) 951); // greek small letter eta, U+03B7 ISOgrk3
1109      else if (c.equals("theta"))
1110        s.append((char) 952); // greek small letter theta, U+03B8 ISOgrk3
1111      else if (c.equals("iota"))
1112        s.append((char) 953); // greek small letter iota, U+03B9 ISOgrk3
1113      else if (c.equals("kappa"))
1114        s.append((char) 954); // greek small letter kappa, U+03BA ISOgrk3
1115      else if (c.equals("lambda"))
1116        s.append((char) 955); // greek small letter lambda, U+03BB ISOgrk3
1117      else if (c.equals("mu"))
1118        s.append((char) 956); // greek small letter mu, U+03BC ISOgrk3
1119      else if (c.equals("nu"))
1120        s.append((char) 957); // greek small letter nu, U+03BD ISOgrk3
1121      else if (c.equals("xi"))
1122        s.append((char) 958); // greek small letter xi, U+03BE ISOgrk3
1123      else if (c.equals("omicron"))
1124        s.append((char) 959); // greek small letter omicron, U+03BF NEW
1125      else if (c.equals("pi"))
1126        s.append((char) 960); // greek small letter pi, U+03C0 ISOgrk3
1127      else if (c.equals("rho"))
1128        s.append((char) 961); // greek small letter rho, U+03C1 ISOgrk3
1129      else if (c.equals("sigmaf"))
1130        s.append((char) 962); // greek small letter final sigma, U+03C2 ISOgrk3
1131      else if (c.equals("sigma"))
1132        s.append((char) 963); // greek small letter sigma, U+03C3 ISOgrk3
1133      else if (c.equals("tau"))
1134        s.append((char) 964); // greek small letter tau, U+03C4 ISOgrk3
1135      else if (c.equals("upsilon"))
1136        s.append((char) 965); // greek small letter upsilon, U+03C5 ISOgrk3
1137      else if (c.equals("phi"))
1138        s.append((char) 966); // greek small letter phi, U+03C6 ISOgrk3
1139      else if (c.equals("chi"))
1140        s.append((char) 967); // greek small letter chi, U+03C7 ISOgrk3
1141      else if (c.equals("psi"))
1142        s.append((char) 968); // greek small letter psi, U+03C8 ISOgrk3
1143      else if (c.equals("omega"))
1144        s.append((char) 969); // greek small letter omega, U+03C9 ISOgrk3
1145      else if (c.equals("thetasym"))
1146        s.append((char) 977); // greek small letter theta symbol, U+03D1 NEW
1147      else if (c.equals("upsih"))
1148        s.append((char) 978); // greek upsilon with hook symbol, U+03D2 NEW
1149      else if (c.equals("piv"))
1150        s.append((char) 982); // greek pi symbol, U+03D6 ISOgrk3
1151      else if (c.equals("bull"))
1152        s.append((char) 8226); // bullet = black small circle, U+2022 ISOpub
1153      else if (c.equals("hellip"))
1154        s.append((char) 8230); // horizontal ellipsis = three dot leader, U+2026 ISOpub
1155      else if (c.equals("prime"))
1156        s.append((char) 8242); // prime = minutes = feet, U+2032 ISOtech
1157      else if (c.equals("Prime"))
1158        s.append((char) 8243); // double prime = seconds = inches, U+2033 ISOtech
1159      else if (c.equals("oline"))
1160        s.append((char) 8254); // overline = spacing overscore, U+203E NEW
1161      else if (c.equals("frasl"))
1162        s.append((char) 8260); // fraction slash, U+2044 NEW
1163      else if (c.equals("weierp"))
1164        s.append((char) 8472); // script capital P = power set = Weierstrass p, U+2118 ISOamso
1165      else if (c.equals("image"))
1166        s.append((char) 8465); // blackletter capital I = imaginary part, U+2111 ISOamso
1167      else if (c.equals("real"))
1168        s.append((char) 8476); // blackletter capital R = real part symbol, U+211C ISOamso
1169      else if (c.equals("trade"))
1170        s.append((char) 8482); // trade mark sign, U+2122 ISOnum
1171      else if (c.equals("alefsym"))
1172        s.append((char) 8501); // alef symbol = first transfinite cardinal, U+2135 NEW
1173      else if (c.equals("larr"))
1174        s.append((char) 8592); // leftwards arrow, U+2190 ISOnum
1175      else if (c.equals("uarr"))
1176        s.append((char) 8593); // upwards arrow, U+2191 ISOnum
1177      else if (c.equals("rarr"))
1178        s.append((char) 8594); // rightwards arrow, U+2192 ISOnum
1179      else if (c.equals("darr"))
1180        s.append((char) 8595); // downwards arrow, U+2193 ISOnum
1181      else if (c.equals("harr"))
1182        s.append((char) 8596); // left right arrow, U+2194 ISOamsa
1183      else if (c.equals("crarr"))
1184        s.append((char) 8629); // downwards arrow with corner leftwards = carriage return, U+21B5 NEW
1185      else if (c.equals("lArr"))
1186        s.append((char) 8656); // leftwards double arrow, U+21D0 ISOtech
1187      else if (c.equals("uArr"))
1188        s.append((char) 8657); // upwards double arrow, U+21D1 ISOamsa
1189      else if (c.equals("rArr"))
1190        s.append((char) 8658); // rightwards double arrow, U+21D2 ISOtech
1191      else if (c.equals("dArr"))
1192        s.append((char) 8659); // downwards double arrow, U+21D3 ISOamsa
1193      else if (c.equals("hArr"))
1194        s.append((char) 8660); // left right double arrow, U+21D4 ISOamsa
1195      else if (c.equals("forall"))
1196        s.append((char) 8704); // for all, U+2200 ISOtech
1197      else if (c.equals("part"))
1198        s.append((char) 8706); // partial differential, U+2202 ISOtech
1199      else if (c.equals("exist"))
1200        s.append((char) 8707); // there exists, U+2203 ISOtech
1201      else if (c.equals("empty"))
1202        s.append((char) 8709); // empty set = null set = diameter, U+2205 ISOamso
1203      else if (c.equals("nabla"))
1204        s.append((char) 8711); // nabla = backward difference, U+2207 ISOtech
1205      else if (c.equals("isin"))
1206        s.append((char) 8712); // element of, U+2208 ISOtech
1207      else if (c.equals("notin"))
1208        s.append((char) 8713); // not an element of, U+2209 ISOtech
1209      else if (c.equals("ni"))
1210        s.append((char) 8715); // contains as member, U+220B ISOtech
1211      else if (c.equals("prod"))
1212        s.append((char) 8719); // n-ary product = product sign, U+220F ISOamsb
1213      else if (c.equals("sum"))
1214        s.append((char) 8721); // n-ary sumation, U+2211 ISOamsb
1215      else if (c.equals("minus"))
1216        s.append((char) 8722); // minus sign, U+2212 ISOtech
1217      else if (c.equals("lowast"))
1218        s.append((char) 8727); // asterisk operator, U+2217 ISOtech
1219      else if (c.equals("radic"))
1220        s.append((char) 8730); // square root = radical sign, U+221A ISOtech
1221      else if (c.equals("prop"))
1222        s.append((char) 8733); // proportional to, U+221D ISOtech
1223      else if (c.equals("infin"))
1224        s.append((char) 8734); // infinity, U+221E ISOtech -->
1225      else if (c.equals("ang"))
1226        s.append((char) 8736); // angle, U+2220 ISOamso
1227      else if (c.equals("and"))
1228        s.append((char) 8743); // logical and = wedge, U+2227 ISOtech
1229      else if (c.equals("or"))
1230        s.append((char) 8744); // logical or = vee, U+2228 ISOtech
1231      else if (c.equals("cap"))
1232        s.append((char) 8745); // intersection = cap, U+2229 ISOtech
1233      else if (c.equals("cup"))
1234        s.append((char) 8746); // union = cup, U+222A ISOtech
1235      else if (c.equals("int"))
1236        s.append((char) 8747); // integral, U+222B ISOtech
1237      else if (c.equals("there4"))
1238        s.append((char) 8756); // therefore, U+2234 ISOtech
1239      else if (c.equals("sim"))
1240        s.append((char) 8764); // tilde operator = varies with = similar t U+223C ISOtech
1241      else if (c.equals("cong"))
1242        s.append((char) 8773); // approximately equal to, U+2245 ISOtec
1243      else if (c.equals("asymp"))
1244        s.append((char) 8776); // almost equal to = asymptotic to, U+2248 ISOamsr
1245      else if (c.equals("ne"))
1246        s.append((char) 8800); // not equal to, U+2260 ISOtech
1247      else if (c.equals("equiv"))
1248        s.append((char) 8801); // identical to, U+2261 ISOtech
1249      else if (c.equals("le"))
1250        s.append((char) 8804); // less-than or equal to, U+2264 ISOtech
1251      else if (c.equals("ge"))
1252        s.append((char) 8805); // greater-than or equal to, U+2265 ISOtech
1253      else if (c.equals("sub"))
1254        s.append((char) 8834); // subset of, U+2282 ISOtech
1255      else if (c.equals("sup"))
1256        s.append((char) 8835); // superset of, U+2283 ISOtech
1257      else if (c.equals("nsub"))
1258        s.append((char) 8836); // not a subset of, U+2284 ISOamsn
1259      else if (c.equals("sube"))
1260        s.append((char) 8838); // subset of or equal to, U+2286 ISOtech
1261      else if (c.equals("supe"))
1262        s.append((char) 8839); // superset of or equal to, U+2287 ISOtech
1263      else if (c.equals("oplus"))
1264        s.append((char) 8853); // circled plus = direct sum, U+2295 ISOamsb
1265      else if (c.equals("otimes"))
1266        s.append((char) 8855); // circled times = vector product, U+2297 ISOamsb -->
1267      else if (c.equals("perp"))
1268        s.append((char) 8869); // up tack = orthogonal to = perpendicular, U+22A5 ISOtech
1269      else if (c.equals("sdot"))
1270        s.append((char) 8901); // dot operator, U+22C5 ISOamsb
1271      else if (c.equals("lceil"))
1272        s.append((char) 8968); // left ceiling = apl upstile, U+2308 ISOamsc
1273      else if (c.equals("rceil"))
1274        s.append((char) 8969); // right ceiling, U+2309 ISOamsc
1275      else if (c.equals("lfloor"))
1276        s.append((char) 8970); // left floor = apl downstile, U+230A ISOamsc
1277      else if (c.equals("rfloor"))
1278        s.append((char) 8971); // right floor, U+230B ISOamsc
1279      else if (c.equals("lang"))
1280        s.append((char) 9001); // left-pointing angle bracket = bra, U+2329 ISOtech
1281      else if (c.equals("rang"))
1282        s.append((char) 9002); // right-pointing angle bracket = ket, U+232A ISOtech
1283      else if (c.equals("loz"))
1284        s.append((char) 9674); // lozenge, U+25CA ISOpub
1285      else if (c.equals("spades"))
1286        s.append((char) 9824); // black spade suit, U+2660 ISOpub
1287      else if (c.equals("clubs"))
1288        s.append((char) 9827); // black club suit = shamrock, U+2663 ISOpub
1289      else if (c.equals("hearts"))
1290        s.append((char) 9829); // black heart suit = valentine, U+2665 ISOpub
1291      else if (c.equals("diams"))
1292        s.append((char) 9830); // black diamond suit, U+2666 ISOpub --
1293      else if (c.equals("ndash"))
1294        s.append((char) 8211); 
1295      else if (c.equals("mdash"))
1296        s.append((char) 8212); 
1297      else if (c.equals("ldquo"))
1298        s.append((char) 8221); 
1299      else if (c.equals("rdquo"))
1300        s.append((char) 201D); 
1301      else if (c.equals("frac14"))
1302        s.append((char) 188); 
1303      else if (!mustBeWellFormed) {
1304        // we guess that this is an accidentally unescaped &
1305        s.append("&"+c);
1306      } else {
1307        throw new FHIRFormatError("unable to parse character reference '" + c + "'' (last text = '" + lastText + "'" + descLoc());
1308      }
1309    }
1310  }
1311
1312  private boolean isInteger(String s, int base) {
1313    try {
1314      Integer.parseInt(s, base);
1315      return true;
1316    } catch (Exception e) {
1317      return false;
1318    }
1319  }
1320
1321  public List<XhtmlNode> parseMDFragment(String source) throws IOException, FHIRException  {
1322    XhtmlNode div = parseFragment( "<div>"+source+"</div>");
1323    return div.getChildNodes();
1324  }
1325  
1326  public List<XhtmlNode> parseMDFragmentStripParas(String source) throws IOException, FHIRException  {
1327    XhtmlNode div = parseFragment( "<div>"+source+"</div>");
1328    List<XhtmlNode> res = new ArrayList<>();
1329    for (XhtmlNode x : div.getChildNodes()) {
1330      res.addAll(x.getChildNodes());
1331    }
1332    return res;
1333  }
1334  
1335  public XhtmlNode parseFragment(String source) throws IOException, FHIRException  {
1336    rdr = new StringReader(source);
1337    try {
1338      return parseFragment();
1339    } catch (Exception e) {
1340      if (DEBUG) {
1341        FileUtilities.stringToFile(source, Utilities.path("[tmp]", "html-fail.xhtml"));
1342      }
1343      throw e;
1344    }
1345  }
1346
1347  public XhtmlNode parseFragment(InputStream input) throws IOException, FHIRException  {
1348    rdr = new InputStreamReader(input);
1349    return parseFragment();
1350  }
1351
1352  private XhtmlNode parseFragment() throws IOException, FHIRException 
1353  {
1354    skipWhiteSpace();
1355    if (peekChar() != '<')
1356      throw new FHIRException("Unable to Parse HTML - does not start with tag. Found "+peekChar()+descLoc());
1357    readChar();
1358    if (peekChar() == '?') {
1359      readToTagEnd();
1360      skipWhiteSpaceInternal();
1361      if (peekChar() != '<')
1362        throw new FHIRException("Unable to Parse HTML - does not start with tag after processing instruction. Found "+peekChar()+descLoc());
1363      readChar();
1364    }
1365    String n = readName().toLowerCase();
1366    readToTagEnd();
1367    XhtmlNode result = new XhtmlNode(NodeType.Element);
1368
1369    int colonIndex = n.indexOf(':');
1370    if (colonIndex != -1) {
1371      n = n.substring(colonIndex + 1);
1372    }
1373
1374    result.setName(n);
1375    unwindPoint = null;
1376    List<XhtmlNode> p = new ArrayList<>();
1377    parseElementInner(result, p, null);
1378
1379    return result;
1380  }
1381
1382  private void defineEntities() {
1383    definedEntities.put("&AElig;", "\u00C6");
1384//    definedEntities.put("&AMP;", "\u0026");
1385    definedEntities.put("&Aacute;", "\u00C1");
1386    definedEntities.put("&Abreve;", "\u0102");
1387    definedEntities.put("&Acirc;", "\u00C2");
1388    definedEntities.put("&Acy;", "\u0410");
1389    definedEntities.put("&Afr;", "\uD835\uDD04");
1390    definedEntities.put("&Agrave;", "\u00C0");
1391    definedEntities.put("&Alpha;", "\u0391");
1392    definedEntities.put("&Amacr;", "\u0100");
1393    definedEntities.put("&And;", "\u2A53");
1394    definedEntities.put("&Aogon;", "\u0104");
1395    definedEntities.put("&Aopf;", "\uD835\uDD38");
1396    definedEntities.put("&ApplyFunction;", "\u2061");
1397    definedEntities.put("&Aring;", "\u00C5");
1398    definedEntities.put("&Ascr;", "\uD835\uDC9C");
1399    definedEntities.put("&Assign;", "\u2254");
1400    definedEntities.put("&Atilde;", "\u00C3");
1401    definedEntities.put("&Auml;", "\u00C4");
1402    definedEntities.put("&Backslash;", "\u2216");
1403    definedEntities.put("&Barv;", "\u2AE7");
1404    definedEntities.put("&Barwed;", "\u2306");
1405    definedEntities.put("&Bcy;", "\u0411");
1406    definedEntities.put("&Because;", "\u2235");
1407    definedEntities.put("&Bernoullis;", "\u212C");
1408    definedEntities.put("&Beta;", "\u0392");
1409    definedEntities.put("&Bfr;", "\uD835\uDD05");
1410    definedEntities.put("&Bopf;", "\uD835\uDD39");
1411    definedEntities.put("&Breve;", "\u02D8");
1412    definedEntities.put("&Bscr;", "\u212C");
1413    definedEntities.put("&Bumpeq;", "\u224E");
1414    definedEntities.put("&CHcy;", "\u0427");
1415    definedEntities.put("&COPY;", "\u00A9");
1416    definedEntities.put("&Cacute;", "\u0106");
1417    definedEntities.put("&Cap;", "\u22D2");
1418    definedEntities.put("&CapitalDifferentialD;", "\u2145");
1419    definedEntities.put("&Cayleys;", "\u212D");
1420    definedEntities.put("&Ccaron;", "\u010C");
1421    definedEntities.put("&Ccedil;", "\u00C7");
1422    definedEntities.put("&Ccirc;", "\u0108");
1423    definedEntities.put("&Cconint;", "\u2230");
1424    definedEntities.put("&Cdot;", "\u010A");
1425    definedEntities.put("&Cedilla;", "\u00B8");
1426    definedEntities.put("&CenterDot;", "\u00B7");
1427    definedEntities.put("&Cfr;", "\u212D");
1428    definedEntities.put("&Chi;", "\u03A7");
1429    definedEntities.put("&CircleDot;", "\u2299");
1430    definedEntities.put("&CircleMinus;", "\u2296");
1431    definedEntities.put("&CirclePlus;", "\u2295");
1432    definedEntities.put("&CircleTimes;", "\u2297");
1433    definedEntities.put("&ClockwiseContourIntegral;", "\u2232");
1434    definedEntities.put("&CloseCurlyDoubleQuote;", "\u201D");
1435    definedEntities.put("&CloseCurlyQuote;", "\u2019");
1436    definedEntities.put("&Colon;", "\u2237");
1437    definedEntities.put("&Colone;", "\u2A74");
1438    definedEntities.put("&Congruent;", "\u2261");
1439    definedEntities.put("&Conint;", "\u222F");
1440    definedEntities.put("&ContourIntegral;", "\u222E");
1441    definedEntities.put("&Copf;", "\u2102");
1442    definedEntities.put("&Coproduct;", "\u2210");
1443    definedEntities.put("&CounterClockwiseContourIntegral;", "\u2233");
1444    definedEntities.put("&Cross;", "\u2A2F");
1445    definedEntities.put("&Cscr;", "\uD835\uDC9E");
1446    definedEntities.put("&Cup;", "\u22D3");
1447    definedEntities.put("&CupCap;", "\u224D");
1448    definedEntities.put("&DD;", "\u2145");
1449    definedEntities.put("&DDotrahd;", "\u2911");
1450    definedEntities.put("&DJcy;", "\u0402");
1451    definedEntities.put("&DScy;", "\u0405");
1452    definedEntities.put("&DZcy;", "\u040F");
1453    definedEntities.put("&Dagger;", "\u2021");
1454    definedEntities.put("&Darr;", "\u21A1");
1455    definedEntities.put("&Dashv;", "\u2AE4");
1456    definedEntities.put("&Dcaron;", "\u010E");
1457    definedEntities.put("&Dcy;", "\u0414");
1458    definedEntities.put("&Del;", "\u2207");
1459    definedEntities.put("&Delta;", "\u0394");
1460    definedEntities.put("&Dfr;", "\uD835\uDD07");
1461    definedEntities.put("&DiacriticalAcute;", "\u00B4");
1462    definedEntities.put("&DiacriticalDot;", "\u02D9");
1463    definedEntities.put("&DiacriticalDoubleAcute;", "\u02DD");
1464    definedEntities.put("&DiacriticalGrave;", "\u0060");
1465    definedEntities.put("&DiacriticalTilde;", "\u02DC");
1466    definedEntities.put("&Diamond;", "\u22C4");
1467    definedEntities.put("&DifferentialD;", "\u2146");
1468    definedEntities.put("&Dopf;", "\uD835\uDD3B");
1469    definedEntities.put("&Dot;", "\u00A8");
1470    definedEntities.put("&DotDot;", "\u20DC");
1471    definedEntities.put("&DotEqual;", "\u2250");
1472    definedEntities.put("&DoubleContourIntegral;", "\u222F");
1473    definedEntities.put("&DoubleDot;", "\u00A8");
1474    definedEntities.put("&DoubleDownArrow;", "\u21D3");
1475    definedEntities.put("&DoubleLeftArrow;", "\u21D0");
1476    definedEntities.put("&DoubleLeftRightArrow;", "\u21D4");
1477    definedEntities.put("&DoubleLeftTee;", "\u2AE4");
1478    definedEntities.put("&DoubleLongLeftArrow;", "\u27F8");
1479    definedEntities.put("&DoubleLongLeftRightArrow;", "\u27FA");
1480    definedEntities.put("&DoubleLongRightArrow;", "\u27F9");
1481    definedEntities.put("&DoubleRightArrow;", "\u21D2");
1482    definedEntities.put("&DoubleRightTee;", "\u22A8");
1483    definedEntities.put("&DoubleUpArrow;", "\u21D1");
1484    definedEntities.put("&DoubleUpDownArrow;", "\u21D5");
1485    definedEntities.put("&DoubleVerticalBar;", "\u2225");
1486    definedEntities.put("&DownArrow;", "\u2193");
1487    definedEntities.put("&DownArrowBar;", "\u2913");
1488    definedEntities.put("&DownArrowUpArrow;", "\u21F5");
1489    definedEntities.put("&DownBreve;", "\u0311");
1490    definedEntities.put("&DownLeftRightVector;", "\u2950");
1491    definedEntities.put("&DownLeftTeeVector;", "\u295E");
1492    definedEntities.put("&DownLeftVector;", "\u21BD");
1493    definedEntities.put("&DownLeftVectorBar;", "\u2956");
1494    definedEntities.put("&DownRightTeeVector;", "\u295F");
1495    definedEntities.put("&DownRightVector;", "\u21C1");
1496    definedEntities.put("&DownRightVectorBar;", "\u2957");
1497    definedEntities.put("&DownTee;", "\u22A4");
1498    definedEntities.put("&DownTeeArrow;", "\u21A7");
1499    definedEntities.put("&Downarrow;", "\u21D3");
1500    definedEntities.put("&Dscr;", "\uD835\uDC9F");
1501    definedEntities.put("&Dstrok;", "\u0110");
1502    definedEntities.put("&ENG;", "\u014A");
1503    definedEntities.put("&ETH;", "\u00D0");
1504    definedEntities.put("&Eacute;", "\u00C9");
1505    definedEntities.put("&Ecaron;", "\u011A");
1506    definedEntities.put("&Ecirc;", "\u00CA");
1507    definedEntities.put("&Ecy;", "\u042D");
1508    definedEntities.put("&Edot;", "\u0116");
1509    definedEntities.put("&Efr;", "\uD835\uDD08");
1510    definedEntities.put("&Egrave;", "\u00C8");
1511    definedEntities.put("&Element;", "\u2208");
1512    definedEntities.put("&Emacr;", "\u0112");
1513    definedEntities.put("&EmptySmallSquare;", "\u25FB");
1514    definedEntities.put("&EmptyVerySmallSquare;", "\u25AB");
1515    definedEntities.put("&Eogon;", "\u0118");
1516    definedEntities.put("&Eopf;", "\uD835\uDD3C");
1517    definedEntities.put("&Epsilon;", "\u0395");
1518    definedEntities.put("&Equal;", "\u2A75");
1519    definedEntities.put("&EqualTilde;", "\u2242");
1520    definedEntities.put("&Equilibrium;", "\u21CC");
1521    definedEntities.put("&Escr;", "\u2130");
1522    definedEntities.put("&Esim;", "\u2A73");
1523    definedEntities.put("&Eta;", "\u0397");
1524    definedEntities.put("&Euml;", "\u00CB");
1525    definedEntities.put("&Exists;", "\u2203");
1526    definedEntities.put("&ExponentialE;", "\u2147");
1527    definedEntities.put("&Fcy;", "\u0424");
1528    definedEntities.put("&Ffr;", "\uD835\uDD09");
1529    definedEntities.put("&FilledSmallSquare;", "\u25FC");
1530    definedEntities.put("&FilledVerySmallSquare;", "\u25AA");
1531    definedEntities.put("&Fopf;", "\uD835\uDD3D");
1532    definedEntities.put("&ForAll;", "\u2200");
1533    definedEntities.put("&Fouriertrf;", "\u2131");
1534    definedEntities.put("&Fscr;", "\u2131");
1535    definedEntities.put("&GJcy;", "\u0403");
1536//    definedEntities.put("&GT;", "\u003E");
1537    definedEntities.put("&Gamma;", "\u0393");
1538    definedEntities.put("&Gammad;", "\u03DC");
1539    definedEntities.put("&Gbreve;", "\u011E");
1540    definedEntities.put("&Gcedil;", "\u0122");
1541    definedEntities.put("&Gcirc;", "\u011C");
1542    definedEntities.put("&Gcy;", "\u0413");
1543    definedEntities.put("&Gdot;", "\u0120");
1544    definedEntities.put("&Gfr;", "\uD835\uDD0A");
1545    definedEntities.put("&Gg;", "\u22D9");
1546    definedEntities.put("&Gopf;", "\uD835\uDD3E");
1547    definedEntities.put("&GreaterEqual;", "\u2265");
1548    definedEntities.put("&GreaterEqualLess;", "\u22DB");
1549    definedEntities.put("&GreaterFullEqual;", "\u2267");
1550    definedEntities.put("&GreaterGreater;", "\u2AA2");
1551    definedEntities.put("&GreaterLess;", "\u2277");
1552    definedEntities.put("&GreaterSlantEqual;", "\u2A7E");
1553    definedEntities.put("&GreaterTilde;", "\u2273");
1554    definedEntities.put("&Gscr;", "\uD835\uDCA2");
1555    definedEntities.put("&Gt;", "\u226B");
1556    definedEntities.put("&HARDcy;", "\u042A");
1557    definedEntities.put("&Hacek;", "\u02C7");
1558    definedEntities.put("&Hat;", "\u005E");
1559    definedEntities.put("&Hcirc;", "\u0124");
1560    definedEntities.put("&Hfr;", "\u210C");
1561    definedEntities.put("&HilbertSpace;", "\u210B");
1562    definedEntities.put("&Hopf;", "\u210D");
1563    definedEntities.put("&HorizontalLine;", "\u2500");
1564    definedEntities.put("&Hscr;", "\u210B");
1565    definedEntities.put("&Hstrok;", "\u0126");
1566    definedEntities.put("&HumpDownHump;", "\u224E");
1567    definedEntities.put("&HumpEqual;", "\u224F");
1568    definedEntities.put("&IEcy;", "\u0415");
1569    definedEntities.put("&IJlig;", "\u0132");
1570    definedEntities.put("&IOcy;", "\u0401");
1571    definedEntities.put("&Iacute;", "\u00CD");
1572    definedEntities.put("&Icirc;", "\u00CE");
1573    definedEntities.put("&Icy;", "\u0418");
1574    definedEntities.put("&Idot;", "\u0130");
1575    definedEntities.put("&Ifr;", "\u2111");
1576    definedEntities.put("&Igrave;", "\u00CC");
1577    definedEntities.put("&Im;", "\u2111");
1578    definedEntities.put("&Imacr;", "\u012A");
1579    definedEntities.put("&ImaginaryI;", "\u2148");
1580    definedEntities.put("&Implies;", "\u21D2");
1581    definedEntities.put("&Int;", "\u222C");
1582    definedEntities.put("&Integral;", "\u222B");
1583    definedEntities.put("&Intersection;", "\u22C2");
1584    definedEntities.put("&InvisibleComma;", "\u2063");
1585    definedEntities.put("&InvisibleTimes;", "\u2062");
1586    definedEntities.put("&Iogon;", "\u012E");
1587    definedEntities.put("&Iopf;", "\uD835\uDD40");
1588    definedEntities.put("&Iota;", "\u0399");
1589    definedEntities.put("&Iscr;", "\u2110");
1590    definedEntities.put("&Itilde;", "\u0128");
1591    definedEntities.put("&Iukcy;", "\u0406");
1592    definedEntities.put("&Iuml;", "\u00CF");
1593    definedEntities.put("&Jcirc;", "\u0134");
1594    definedEntities.put("&Jcy;", "\u0419");
1595    definedEntities.put("&Jfr;", "\uD835\uDD0D");
1596    definedEntities.put("&Jopf;", "\uD835\uDD41");
1597    definedEntities.put("&Jscr;", "\uD835\uDCA5");
1598    definedEntities.put("&Jsercy;", "\u0408");
1599    definedEntities.put("&Jukcy;", "\u0404");
1600    definedEntities.put("&KHcy;", "\u0425");
1601    definedEntities.put("&KJcy;", "\u040C");
1602    definedEntities.put("&Kappa;", "\u039A");
1603    definedEntities.put("&Kcedil;", "\u0136");
1604    definedEntities.put("&Kcy;", "\u041A");
1605    definedEntities.put("&Kfr;", "\uD835\uDD0E");
1606    definedEntities.put("&Kopf;", "\uD835\uDD42");
1607    definedEntities.put("&Kscr;", "\uD835\uDCA6");
1608    definedEntities.put("&LJcy;", "\u0409");
1609//    definedEntities.put("&LT;", "\u003C");
1610    definedEntities.put("&Lacute;", "\u0139");
1611    definedEntities.put("&Lambda;", "\u039B");
1612    definedEntities.put("&Lang;", "\u27EA");
1613    definedEntities.put("&Laplacetrf;", "\u2112");
1614    definedEntities.put("&Larr;", "\u219E");
1615    definedEntities.put("&Lcaron;", "\u013D");
1616    definedEntities.put("&Lcedil;", "\u013B");
1617    definedEntities.put("&Lcy;", "\u041B");
1618    definedEntities.put("&LeftAngleBracket;", "\u27E8");
1619    definedEntities.put("&LeftArrow;", "\u2190");
1620    definedEntities.put("&LeftArrowBar;", "\u21E4");
1621    definedEntities.put("&LeftArrowRightArrow;", "\u21C6");
1622    definedEntities.put("&LeftCeiling;", "\u2308");
1623    definedEntities.put("&LeftDoubleBracket;", "\u27E6");
1624    definedEntities.put("&LeftDownTeeVector;", "\u2961");
1625    definedEntities.put("&LeftDownVector;", "\u21C3");
1626    definedEntities.put("&LeftDownVectorBar;", "\u2959");
1627    definedEntities.put("&LeftFloor;", "\u230A");
1628    definedEntities.put("&LeftRightArrow;", "\u2194");
1629    definedEntities.put("&LeftRightVector;", "\u294E");
1630    definedEntities.put("&LeftTee;", "\u22A3");
1631    definedEntities.put("&LeftTeeArrow;", "\u21A4");
1632    definedEntities.put("&LeftTeeVector;", "\u295A");
1633    definedEntities.put("&LeftTriangle;", "\u22B2");
1634    definedEntities.put("&LeftTriangleBar;", "\u29CF");
1635    definedEntities.put("&LeftTriangleEqual;", "\u22B4");
1636    definedEntities.put("&LeftUpDownVector;", "\u2951");
1637    definedEntities.put("&LeftUpTeeVector;", "\u2960");
1638    definedEntities.put("&LeftUpVector;", "\u21BF");
1639    definedEntities.put("&LeftUpVectorBar;", "\u2958");
1640    definedEntities.put("&LeftVector;", "\u21BC");
1641    definedEntities.put("&LeftVectorBar;", "\u2952");
1642    definedEntities.put("&Leftarrow;", "\u21D0");
1643    definedEntities.put("&Leftrightarrow;", "\u21D4");
1644    definedEntities.put("&LessEqualGreater;", "\u22DA");
1645    definedEntities.put("&LessFullEqual;", "\u2266");
1646    definedEntities.put("&LessGreater;", "\u2276");
1647    definedEntities.put("&LessLess;", "\u2AA1");
1648    definedEntities.put("&LessSlantEqual;", "\u2A7D");
1649    definedEntities.put("&LessTilde;", "\u2272");
1650    definedEntities.put("&Lfr;", "\uD835\uDD0F");
1651    definedEntities.put("&Ll;", "\u22D8");
1652    definedEntities.put("&Lleftarrow;", "\u21DA");
1653    definedEntities.put("&Lmidot;", "\u013F");
1654    definedEntities.put("&LongLeftArrow;", "\u27F5");
1655    definedEntities.put("&LongLeftRightArrow;", "\u27F7");
1656    definedEntities.put("&LongRightArrow;", "\u27F6");
1657    definedEntities.put("&Longleftarrow;", "\u27F8");
1658    definedEntities.put("&Longleftrightarrow;", "\u27FA");
1659    definedEntities.put("&Longrightarrow;", "\u27F9");
1660    definedEntities.put("&Lopf;", "\uD835\uDD43");
1661    definedEntities.put("&LowerLeftArrow;", "\u2199");
1662    definedEntities.put("&LowerRightArrow;", "\u2198");
1663    definedEntities.put("&Lscr;", "\u2112");
1664    definedEntities.put("&Lsh;", "\u21B0");
1665    definedEntities.put("&Lstrok;", "\u0141");
1666    definedEntities.put("&Lt;", "\u226A");
1667    definedEntities.put("&Map;", "\u2905");
1668    definedEntities.put("&Mcy;", "\u041C");
1669    definedEntities.put("&MediumSpace;", "\u205F");
1670    definedEntities.put("&Mellintrf;", "\u2133");
1671    definedEntities.put("&Mfr;", "\uD835\uDD10");
1672    definedEntities.put("&MinusPlus;", "\u2213");
1673    definedEntities.put("&Mopf;", "\uD835\uDD44");
1674    definedEntities.put("&Mscr;", "\u2133");
1675    definedEntities.put("&Mu;", "\u039C");
1676    definedEntities.put("&NJcy;", "\u040A");
1677    definedEntities.put("&Nacute;", "\u0143");
1678    definedEntities.put("&Ncaron;", "\u0147");
1679    definedEntities.put("&Ncedil;", "\u0145");
1680    definedEntities.put("&Ncy;", "\u041D");
1681    definedEntities.put("&NegativeMediumSpace;", "\u200B");
1682    definedEntities.put("&NegativeThickSpace;", "\u200B");
1683    definedEntities.put("&NegativeThinSpace;", "\u200B");
1684    definedEntities.put("&NegativeVeryThinSpace;", "\u200B");
1685    definedEntities.put("&NestedGreaterGreater;", "\u226B");
1686    definedEntities.put("&NestedLessLess;", "\u226A");
1687    definedEntities.put("&NewLine;", "\n");
1688    definedEntities.put("&Nfr;", "\uD835\uDD11");
1689    definedEntities.put("&NoBreak;", "\u2060");
1690    definedEntities.put("&NonBreakingSpace;", "\u00A0");
1691    definedEntities.put("&Nopf;", "\u2115");
1692    definedEntities.put("&Not;", "\u2AEC");
1693    definedEntities.put("&NotCongruent;", "\u2262");
1694    definedEntities.put("&NotCupCap;", "\u226D");
1695    definedEntities.put("&NotDoubleVerticalBar;", "\u2226");
1696    definedEntities.put("&NotElement;", "\u2209");
1697    definedEntities.put("&NotEqual;", "\u2260");
1698    definedEntities.put("&NotEqualTilde;", "\u2242\u0338");
1699    definedEntities.put("&NotExists;", "\u2204");
1700    definedEntities.put("&NotGreater;", "\u226F");
1701    definedEntities.put("&NotGreaterEqual;", "\u2271");
1702    definedEntities.put("&NotGreaterFullEqual;", "\u2267\u0033");
1703    definedEntities.put("&NotGreaterGreater;", "\u226B\u0033");
1704    definedEntities.put("&NotGreaterLess;", "\u2279");
1705    definedEntities.put("&NotGreaterSlantEqual;", "\u2A7E\u0338");
1706    definedEntities.put("&NotGreaterTilde;", "\u2275");
1707    definedEntities.put("&NotHumpDownHump;", "\u224E\u0338");
1708    definedEntities.put("&NotHumpEqual;", "\u224F\u0338");
1709    definedEntities.put("&NotLeftTriangle;", "\u22EA");
1710    definedEntities.put("&NotLeftTriangleBar;", "\u29CF\u0338");
1711    definedEntities.put("&NotLeftTriangleEqual;", "\u22EC");
1712    definedEntities.put("&NotLess;", "\u226E");
1713    definedEntities.put("&NotLessEqual;", "\u2270");
1714    definedEntities.put("&NotLessGreater;", "\u2278");
1715    definedEntities.put("&NotLessLess;", "\u226A\u0338");
1716    definedEntities.put("&NotLessSlantEqual;", "\u2A7D\u0338");
1717    definedEntities.put("&NotLessTilde;", "\u2274");
1718    definedEntities.put("&NotNestedGreaterGreater;", "\u2AA2\u0338");
1719    definedEntities.put("&NotNestedLessLess;", "\u2AA1\u0338");
1720    definedEntities.put("&NotPrecedes;", "\u2280");
1721    definedEntities.put("&NotPrecedesEqual;", "\u2AAF\u0338");
1722    definedEntities.put("&NotPrecedesSlantEqual;", "\u22E0");
1723    definedEntities.put("&NotReverseElement;", "\u220C");
1724    definedEntities.put("&NotRightTriangle;", "\u22EB");
1725    definedEntities.put("&NotRightTriangleBar;", "\u29D0\u0338");
1726    definedEntities.put("&NotRightTriangleEqual;", "\u22ED");
1727    definedEntities.put("&NotSquareSubset;", "\u228F\u0338");
1728    definedEntities.put("&NotSquareSubsetEqual;", "\u22E2");
1729    definedEntities.put("&NotSquareSuperset;", "\u2290\u0338");
1730    definedEntities.put("&NotSquareSupersetEqual;", "\u22E3");
1731    definedEntities.put("&NotSubset;", "\u2282\u20D2");
1732    definedEntities.put("&NotSubsetEqual;", "\u2288");
1733    definedEntities.put("&NotSucceeds;", "\u2281");
1734    definedEntities.put("&NotSucceedsEqual;", "\u2AB0\u0338");
1735    definedEntities.put("&NotSucceedsSlantEqual;", "\u22E1");
1736    definedEntities.put("&NotSucceedsTilde;", "\u227F\u0338");
1737    definedEntities.put("&NotSuperset;", "\u2283\u20D2");
1738    definedEntities.put("&NotSupersetEqual;", "\u2289");
1739    definedEntities.put("&NotTilde;", "\u2241");
1740    definedEntities.put("&NotTildeEqual;", "\u2244");
1741    definedEntities.put("&NotTildeFullEqual;", "\u2247");
1742    definedEntities.put("&NotTildeTilde;", "\u2249");
1743    definedEntities.put("&NotVerticalBar;", "\u2224");
1744    definedEntities.put("&Nscr;", "\uD835\uDCA9");
1745    definedEntities.put("&Ntilde;", "\u00D1");
1746    definedEntities.put("&Nu;", "\u039D");
1747    definedEntities.put("&OElig;", "\u0152");
1748    definedEntities.put("&Oacute;", "\u00D3");
1749    definedEntities.put("&Ocirc;", "\u00D4");
1750    definedEntities.put("&Ocy;", "\u041E");
1751    definedEntities.put("&Odblac;", "\u0150");
1752    definedEntities.put("&Ofr;", "\uD835\uDD12");
1753    definedEntities.put("&Ograve;", "\u00D2");
1754    definedEntities.put("&Omacr;", "\u014C");
1755    definedEntities.put("&Omega;", "\u03A9");
1756    definedEntities.put("&Omicron;", "\u039F");
1757    definedEntities.put("&Oopf;", "\uD835\uDD46");
1758    definedEntities.put("&OpenCurlyDoubleQuote;", "\u201C");
1759    definedEntities.put("&OpenCurlyQuote;", "\u2018");
1760    definedEntities.put("&Or;", "\u2A54");
1761    definedEntities.put("&Oscr;", "\uD835\uDCAA");
1762    definedEntities.put("&Oslash;", "\u00D8");
1763    definedEntities.put("&Otilde;", "\u00D5");
1764    definedEntities.put("&Otimes;", "\u2A37");
1765    definedEntities.put("&Ouml;", "\u00D6");
1766    definedEntities.put("&OverBar;", "\u203E");
1767    definedEntities.put("&OverBrace;", "\u23DE");
1768    definedEntities.put("&OverBracket;", "\u23B4");
1769    definedEntities.put("&OverParenthesis;", "\u23DC");
1770    definedEntities.put("&PartialD;", "\u2202");
1771    definedEntities.put("&Pcy;", "\u041F");
1772    definedEntities.put("&Pfr;", "\uD835\uDD13");
1773    definedEntities.put("&Phi;", "\u03A6");
1774    definedEntities.put("&Pi;", "\u03A0");
1775    definedEntities.put("&PlusMinus;", "\u00B1");
1776    definedEntities.put("&Poincareplane;", "\u210C");
1777    definedEntities.put("&Popf;", "\u2119");
1778    definedEntities.put("&Pr;", "\u2ABB");
1779    definedEntities.put("&Precedes;", "\u227A");
1780    definedEntities.put("&PrecedesEqual;", "\u2AAF");
1781    definedEntities.put("&PrecedesSlantEqual;", "\u227C");
1782    definedEntities.put("&PrecedesTilde;", "\u227E");
1783    definedEntities.put("&Prime;", "\u2033");
1784    definedEntities.put("&Product;", "\u220F");
1785    definedEntities.put("&Proportion;", "\u2237");
1786    definedEntities.put("&Proportional;", "\u221D");
1787    definedEntities.put("&Pscr;", "\uD835\uDCAB");
1788    definedEntities.put("&Psi;", "\u03A8");
1789    //definedEntities.put("&QUOT;", "\\u0022");
1790    definedEntities.put("&Qfr;", "\uD835\uDD14");
1791    definedEntities.put("&Qopf;", "\u211A");
1792    definedEntities.put("&Qscr;", "\uD835\uDCAC");
1793    definedEntities.put("&RBarr;", "\u2910");
1794    definedEntities.put("&REG;", "\u00AE");
1795    definedEntities.put("&Racute;", "\u0154");
1796    definedEntities.put("&Rang;", "\u27EB");
1797    definedEntities.put("&Rarr;", "\u21A0");
1798    definedEntities.put("&Rarrtl;", "\u2916");
1799    definedEntities.put("&Rcaron;", "\u0158");
1800    definedEntities.put("&Rcedil;", "\u0156");
1801    definedEntities.put("&Rcy;", "\u0420");
1802    definedEntities.put("&Re;", "\u211C");
1803    definedEntities.put("&ReverseElement;", "\u220B");
1804    definedEntities.put("&ReverseEquilibrium;", "\u21CB");
1805    definedEntities.put("&ReverseUpEquilibrium;", "\u296F");
1806    definedEntities.put("&Rfr;", "\u211C");
1807    definedEntities.put("&Rho;", "\u03A1");
1808    definedEntities.put("&RightAngleBracket;", "\u27E9");
1809    definedEntities.put("&RightArrow;", "\u2192");
1810    definedEntities.put("&RightArrowBar;", "\u21E5");
1811    definedEntities.put("&RightArrowLeftArrow;", "\u21C4");
1812    definedEntities.put("&RightCeiling;", "\u2309");
1813    definedEntities.put("&RightDoubleBracket;", "\u27E7");
1814    definedEntities.put("&RightDownTeeVector;", "\u295D");
1815    definedEntities.put("&RightDownVector;", "\u21C2");
1816    definedEntities.put("&RightDownVectorBar;", "\u2955");
1817    definedEntities.put("&RightFloor;", "\u230B");
1818    definedEntities.put("&RightTee;", "\u22A2");
1819    definedEntities.put("&RightTeeArrow;", "\u21A6");
1820    definedEntities.put("&RightTeeVector;", "\u295B");
1821    definedEntities.put("&RightTriangle;", "\u22B3");
1822    definedEntities.put("&RightTriangleBar;", "\u29D0");
1823    definedEntities.put("&RightTriangleEqual;", "\u22B5");
1824    definedEntities.put("&RightUpDownVector;", "\u294F");
1825    definedEntities.put("&RightUpTeeVector;", "\u295C");
1826    definedEntities.put("&RightUpVector;", "\u21BE");
1827    definedEntities.put("&RightUpVectorBar;", "\u2954");
1828    definedEntities.put("&RightVector;", "\u21C0");
1829    definedEntities.put("&RightVectorBar;", "\u2953");
1830    definedEntities.put("&Rightarrow;", "\u21D2");
1831    definedEntities.put("&Ropf;", "\u211D");
1832    definedEntities.put("&RoundImplies;", "\u2970");
1833    definedEntities.put("&Rrightarrow;", "\u21DB");
1834    definedEntities.put("&Rscr;", "\u211B");
1835    definedEntities.put("&Rsh;", "\u21B1");
1836    definedEntities.put("&RuleDelayed;", "\u29F4");
1837    definedEntities.put("&SHCHcy;", "\u0429");
1838    definedEntities.put("&SHcy;", "\u0428");
1839    definedEntities.put("&SOFTcy;", "\u042C");
1840    definedEntities.put("&Sacute;", "\u015A");
1841    definedEntities.put("&Sc;", "\u2ABC");
1842    definedEntities.put("&Scaron;", "\u0160");
1843    definedEntities.put("&Scedil;", "\u015E");
1844    definedEntities.put("&Scirc;", "\u015C");
1845    definedEntities.put("&Scy;", "\u0421");
1846    definedEntities.put("&Sfr;", "\uD835\uDD16");
1847    definedEntities.put("&ShortDownArrow;", "\u2193");
1848    definedEntities.put("&ShortLeftArrow;", "\u2190");
1849    definedEntities.put("&ShortRightArrow;", "\u2192");
1850    definedEntities.put("&ShortUpArrow;", "\u2191");
1851    definedEntities.put("&Sigma;", "\u03A3");
1852    definedEntities.put("&SmallCircle;", "\u2218");
1853    definedEntities.put("&Sopf;", "\uD835\uDD4A");
1854    definedEntities.put("&Sqrt;", "\u221A");
1855    definedEntities.put("&Square;", "\u25A1");
1856    definedEntities.put("&SquareIntersection;", "\u2293");
1857    definedEntities.put("&SquareSubset;", "\u228F");
1858    definedEntities.put("&SquareSubsetEqual;", "\u2291");
1859    definedEntities.put("&SquareSuperset;", "\u2290");
1860    definedEntities.put("&SquareSupersetEqual;", "\u2292");
1861    definedEntities.put("&SquareUnion;", "\u2294");
1862    definedEntities.put("&Sscr;", "\uD835\uDCAE");
1863    definedEntities.put("&Star;", "\u22C6");
1864    definedEntities.put("&Sub;", "\u22D0");
1865    definedEntities.put("&Subset;", "\u22D0");
1866    definedEntities.put("&SubsetEqual;", "\u2286");
1867    definedEntities.put("&Succeeds;", "\u227B");
1868    definedEntities.put("&SucceedsEqual;", "\u2AB0");
1869    definedEntities.put("&SucceedsSlantEqual;", "\u227D");
1870    definedEntities.put("&SucceedsTilde;", "\u227F");
1871    definedEntities.put("&SuchThat;", "\u220B");
1872    definedEntities.put("&Sum;", "\u2211");
1873    definedEntities.put("&Sup;", "\u22D1");
1874    definedEntities.put("&Superset;", "\u2283");
1875    definedEntities.put("&SupersetEqual;", "\u2287");
1876    definedEntities.put("&Supset;", "\u22D1");
1877    definedEntities.put("&THORN;", "\u00DE");
1878    definedEntities.put("&TRADE;", "\u2122");
1879    definedEntities.put("&TSHcy;", "\u040B");
1880    definedEntities.put("&TScy;", "\u0426");
1881    definedEntities.put("&Tab;", "\u0009");
1882    definedEntities.put("&Tau;", "\u03A4");
1883    definedEntities.put("&Tcaron;", "\u0164");
1884    definedEntities.put("&Tcedil;", "\u0162");
1885    definedEntities.put("&Tcy;", "\u0422");
1886    definedEntities.put("&Tfr;", "\uD835\uDD17");
1887    definedEntities.put("&Therefore;", "\u2234");
1888    definedEntities.put("&Theta;", "\u0398");
1889    definedEntities.put("&ThickSpace;", "\u205F\u200A");
1890    definedEntities.put("&ThinSpace;", "\u2009");
1891    definedEntities.put("&Tilde;", "\u223C");
1892    definedEntities.put("&TildeEqual;", "\u2243");
1893    definedEntities.put("&TildeFullEqual;", "\u2245");
1894    definedEntities.put("&TildeTilde;", "\u2248");
1895    definedEntities.put("&Topf;", "\uD835\uDD4B");
1896    definedEntities.put("&TripleDot;", "\u20DB");
1897    definedEntities.put("&Tscr;", "\uD835\uDCAF");
1898    definedEntities.put("&Tstrok;", "\u0166");
1899    definedEntities.put("&Uacute;", "\u00DA");
1900    definedEntities.put("&Uarr;", "\u219F");
1901    definedEntities.put("&Uarrocir;", "\u2949");
1902    definedEntities.put("&Ubrcy;", "\u040E");
1903    definedEntities.put("&Ubreve;", "\u016C");
1904    definedEntities.put("&Ucirc;", "\u00DB");
1905    definedEntities.put("&Ucy;", "\u0423");
1906    definedEntities.put("&Udblac;", "\u0170");
1907    definedEntities.put("&Ufr;", "\uD835\uDD18");
1908    definedEntities.put("&Ugrave;", "\u00D9");
1909    definedEntities.put("&Umacr;", "\u016A");
1910    definedEntities.put("&UnderBar;", "\u005F");
1911    definedEntities.put("&UnderBrace;", "\u23DF");
1912    definedEntities.put("&UnderBracket;", "\u23B5");
1913    definedEntities.put("&UnderParenthesis;", "\u23DD");
1914    definedEntities.put("&Union;", "\u22C3");
1915    definedEntities.put("&UnionPlus;", "\u228E");
1916    definedEntities.put("&Uogon;", "\u0172");
1917    definedEntities.put("&Uopf;", "\uD835\uDD4C");
1918    definedEntities.put("&UpArrow;", "\u2191");
1919    definedEntities.put("&UpArrowBar;", "\u2912");
1920    definedEntities.put("&UpArrowDownArrow;", "\u21C5");
1921    definedEntities.put("&UpDownArrow;", "\u2195");
1922    definedEntities.put("&UpEquilibrium;", "\u296E");
1923    definedEntities.put("&UpTee;", "\u22A5");
1924    definedEntities.put("&UpTeeArrow;", "\u21A5");
1925    definedEntities.put("&Uparrow;", "\u21D1");
1926    definedEntities.put("&Updownarrow;", "\u21D5");
1927    definedEntities.put("&UpperLeftArrow;", "\u2196");
1928    definedEntities.put("&UpperRightArrow;", "\u2197");
1929    definedEntities.put("&Upsi;", "\u03D2");
1930    definedEntities.put("&Upsilon;", "\u03A5");
1931    definedEntities.put("&Uring;", "\u016E");
1932    definedEntities.put("&Uscr;", "\uD835\uDCB0");
1933    definedEntities.put("&Utilde;", "\u0168");
1934    definedEntities.put("&Uuml;", "\u00DC");
1935    definedEntities.put("&VDash;", "\u22AB");
1936    definedEntities.put("&Vbar;", "\u2AEB");
1937    definedEntities.put("&Vcy;", "\u0412");
1938    definedEntities.put("&Vdash;", "\u22A9");
1939    definedEntities.put("&Vdashl;", "\u2AE6");
1940    definedEntities.put("&Vee;", "\u22C1");
1941    definedEntities.put("&Verbar;", "\u2016");
1942    definedEntities.put("&Vert;", "\u2016");
1943    definedEntities.put("&VerticalBar;", "\u2223");
1944    definedEntities.put("&VerticalLine;", "\u007C");
1945    definedEntities.put("&VerticalSeparator;", "\u2758");
1946    definedEntities.put("&VerticalTilde;", "\u2240");
1947    definedEntities.put("&VeryThinSpace;", "\u200A");
1948    definedEntities.put("&Vfr;", "\uD835\uDD19");
1949    definedEntities.put("&Vopf;", "\uD835\uDD4D");
1950    definedEntities.put("&Vscr;", "\uD835\uDCB1");
1951    definedEntities.put("&Vvdash;", "\u22AA");
1952    definedEntities.put("&Wcirc;", "\u0174");
1953    definedEntities.put("&Wedge;", "\u22C0");
1954    definedEntities.put("&Wfr;", "\uD835\uDD1A");
1955    definedEntities.put("&Wopf;", "\uD835\uDD4E");
1956    definedEntities.put("&Wscr;", "\uD835\uDCB2");
1957    definedEntities.put("&Xfr;", "\uD835\uDD1B");
1958    definedEntities.put("&Xi;", "\u039E");
1959    definedEntities.put("&Xopf;", "\uD835\uDD4F");
1960    definedEntities.put("&Xscr;", "\uD835\uDCB3");
1961    definedEntities.put("&YAcy;", "\u042F");
1962    definedEntities.put("&YIcy;", "\u0407");
1963    definedEntities.put("&YUcy;", "\u042E");
1964    definedEntities.put("&Yacute;", "\u00DD");
1965    definedEntities.put("&Ycirc;", "\u0176");
1966    definedEntities.put("&Ycy;", "\u042B");
1967    definedEntities.put("&Yfr;", "\uD835\uDD1C");
1968    definedEntities.put("&Yopf;", "\uD835\uDD50");
1969    definedEntities.put("&Yscr;", "\uD835\uDCB4");
1970    definedEntities.put("&Yuml;", "\u0178");
1971    definedEntities.put("&ZHcy;", "\u0416");
1972    definedEntities.put("&Zacute;", "\u0179");
1973    definedEntities.put("&Zcaron;", "\u017D");
1974    definedEntities.put("&Zcy;", "\u0417");
1975    definedEntities.put("&Zdot;", "\u017B");
1976    definedEntities.put("&ZeroWidthSpace;", "\u200B");
1977    definedEntities.put("&Zeta;", "\u0396");
1978    definedEntities.put("&Zfr;", "\u2128");
1979    definedEntities.put("&Zopf;", "\u2124");
1980    definedEntities.put("&Zscr;", "\uD835\uDCB5");
1981    definedEntities.put("&aacute;", "\u00E1");
1982    definedEntities.put("&abreve;", "\u0103");
1983    definedEntities.put("&ac;", "\u223E");
1984    definedEntities.put("&acE;", "\u223E\u0333");
1985    definedEntities.put("&acd;", "\u223F");
1986    definedEntities.put("&acirc;", "\u00E2");
1987    definedEntities.put("&acute;", "\u00B4");
1988    definedEntities.put("&acy;", "\u0430");
1989    definedEntities.put("&aelig;", "\u00E6");
1990    definedEntities.put("&af;", "\u2061");
1991    definedEntities.put("&afr;", "\uD835\uDD1E");
1992    definedEntities.put("&agrave;", "\u00E0");
1993    definedEntities.put("&alefsym;", "\u2135");
1994    definedEntities.put("&aleph;", "\u2135");
1995    definedEntities.put("&alpha;", "\u03B1");
1996    definedEntities.put("&amacr;", "\u0101");
1997    definedEntities.put("&amalg;", "\u2A3F");
1998//    definedEntities.put("&amp;", "\u0026");
1999    definedEntities.put("&and;", "\u2227");
2000    definedEntities.put("&andand;", "\u2A55");
2001    definedEntities.put("&andd;", "\u2A5C");
2002    definedEntities.put("&andslope;", "\u2A58");
2003    definedEntities.put("&andv;", "\u2A5A");
2004    definedEntities.put("&ang;", "\u2220");
2005    definedEntities.put("&ange;", "\u29A4");
2006    definedEntities.put("&angle;", "\u2220");
2007    definedEntities.put("&angmsd;", "\u2221");
2008    definedEntities.put("&angmsdaa;", "\u29A8");
2009    definedEntities.put("&angmsdab;", "\u29A9");
2010    definedEntities.put("&angmsdac;", "\u29AA");
2011    definedEntities.put("&angmsdad;", "\u29AB");
2012    definedEntities.put("&angmsdae;", "\u29AC");
2013    definedEntities.put("&angmsdaf;", "\u29AD");
2014    definedEntities.put("&angmsdag;", "\u29AE");
2015    definedEntities.put("&angmsdah;", "\u29AF");
2016    definedEntities.put("&angrt;", "\u221F");
2017    definedEntities.put("&angrtvb;", "\u22BE");
2018    definedEntities.put("&angrtvbd;", "\u299D");
2019    definedEntities.put("&angsph;", "\u2222");
2020    definedEntities.put("&angst;", "\u00C5");
2021    definedEntities.put("&angzarr;", "\u237C");
2022    definedEntities.put("&aogon;", "\u0105");
2023    definedEntities.put("&aopf;", "\uD835\uDD52");
2024    definedEntities.put("&ap;", "\u2248");
2025    definedEntities.put("&apE;", "\u2A70");
2026    definedEntities.put("&apacir;", "\u2A6F");
2027    definedEntities.put("&ape;", "\u224A");
2028    definedEntities.put("&apid;", "\u224B");
2029//    definedEntities.put("&apos;", "\u0027");
2030    definedEntities.put("&approx;", "\u2248");
2031    definedEntities.put("&approxeq;", "\u224A");
2032    definedEntities.put("&aring;", "\u00E5");
2033    definedEntities.put("&ascr;", "\uD835\uDCB6");
2034    definedEntities.put("&ast;", "\u002A");
2035    definedEntities.put("&asymp;", "\u2248");
2036    definedEntities.put("&asympeq;", "\u224D");
2037    definedEntities.put("&atilde;", "\u00E3");
2038    definedEntities.put("&auml;", "\u00E4");
2039    definedEntities.put("&awconint;", "\u2233");
2040    definedEntities.put("&awint;", "\u2A11");
2041    definedEntities.put("&bNot;", "\u2AED");
2042    definedEntities.put("&backcong;", "\u224C");
2043    definedEntities.put("&backepsilon;", "\u03F6");
2044    definedEntities.put("&backprime;", "\u2035");
2045    definedEntities.put("&backsim;", "\u223D");
2046    definedEntities.put("&backsimeq;", "\u22CD");
2047    definedEntities.put("&barvee;", "\u22BD");
2048    definedEntities.put("&barwed;", "\u2305");
2049    definedEntities.put("&barwedge;", "\u2305");
2050    definedEntities.put("&bbrk;", "\u23B5");
2051    definedEntities.put("&bbrktbrk;", "\u23B6");
2052    definedEntities.put("&bcong;", "\u224C");
2053    definedEntities.put("&bcy;", "\u0431");
2054    definedEntities.put("&bdquo;", "\u201E");
2055    definedEntities.put("&becaus;", "\u2235");
2056    definedEntities.put("&because;", "\u2235");
2057    definedEntities.put("&bemptyv;", "\u29B0");
2058    definedEntities.put("&bepsi;", "\u03F6");
2059    definedEntities.put("&bernou;", "\u212C");
2060    definedEntities.put("&beta;", "\u03B2");
2061    definedEntities.put("&beth;", "\u2136");
2062    definedEntities.put("&between;", "\u226C");
2063    definedEntities.put("&bfr;", "\uD835\uDD1F");
2064    definedEntities.put("&bigcap;", "\u22C2");
2065    definedEntities.put("&bigcirc;", "\u25EF");
2066    definedEntities.put("&bigcup;", "\u22C3");
2067    definedEntities.put("&bigodot;", "\u2A00");
2068    definedEntities.put("&bigoplus;", "\u2A01");
2069    definedEntities.put("&bigotimes;", "\u2A02");
2070    definedEntities.put("&bigsqcup;", "\u2A06");
2071    definedEntities.put("&bigstar;", "\u2605");
2072    definedEntities.put("&bigtriangledown;", "\u25BD");
2073    definedEntities.put("&bigtriangleup;", "\u25B3");
2074    definedEntities.put("&biguplus;", "\u2A04");
2075    definedEntities.put("&bigvee;", "\u22C1");
2076    definedEntities.put("&bigwedge;", "\u22C0");
2077    definedEntities.put("&bkarow;", "\u290D");
2078    definedEntities.put("&blacklozenge;", "\u29EB");
2079    definedEntities.put("&blacksquare;", "\u25AA");
2080    definedEntities.put("&blacktriangle;", "\u25B4");
2081    definedEntities.put("&blacktriangledown;", "\u25BE");
2082    definedEntities.put("&blacktriangleleft;", "\u25C2");
2083    definedEntities.put("&blacktriangleright;", "\u25B8");
2084    definedEntities.put("&blank;", "\u2423");
2085    definedEntities.put("&blk12;", "\u2592");
2086    definedEntities.put("&blk14;", "\u2591");
2087    definedEntities.put("&blk34;", "\u2593");
2088    definedEntities.put("&block;", "\u2588");
2089    definedEntities.put("&bne;", "\u003D\u20E5");
2090    definedEntities.put("&bnequiv;", "\u2261\u20E5");
2091    definedEntities.put("&bnot;", "\u2310");
2092    definedEntities.put("&bopf;", "\uD835\uDD53");
2093    definedEntities.put("&bot;", "\u22A5");
2094    definedEntities.put("&bottom;", "\u22A5");
2095    definedEntities.put("&bowtie;", "\u22C8");
2096    definedEntities.put("&boxDL;", "\u2557");
2097    definedEntities.put("&boxDR;", "\u2554");
2098    definedEntities.put("&boxDl;", "\u2556");
2099    definedEntities.put("&boxDr;", "\u2553");
2100    definedEntities.put("&boxH;", "\u2550");
2101    definedEntities.put("&boxHD;", "\u2566");
2102    definedEntities.put("&boxHU;", "\u2569");
2103    definedEntities.put("&boxHd;", "\u2564");
2104    definedEntities.put("&boxHu;", "\u2567");
2105    definedEntities.put("&boxUL;", "\u255D");
2106    definedEntities.put("&boxUR;", "\u255A");
2107    definedEntities.put("&boxUl;", "\u255C");
2108    definedEntities.put("&boxUr;", "\u2559");
2109    definedEntities.put("&boxV;", "\u2551");
2110    definedEntities.put("&boxVH;", "\u256C");
2111    definedEntities.put("&boxVL;", "\u2563");
2112    definedEntities.put("&boxVR;", "\u2560");
2113    definedEntities.put("&boxVh;", "\u256B");
2114    definedEntities.put("&boxVl;", "\u2562");
2115    definedEntities.put("&boxVr;", "\u255F");
2116    definedEntities.put("&boxbox;", "\u29C9");
2117    definedEntities.put("&boxdL;", "\u2555");
2118    definedEntities.put("&boxdR;", "\u2552");
2119    definedEntities.put("&boxdl;", "\u2510");
2120    definedEntities.put("&boxdr;", "\u250C");
2121    definedEntities.put("&boxh;", "\u2500");
2122    definedEntities.put("&boxhD;", "\u2565");
2123    definedEntities.put("&boxhU;", "\u2568");
2124    definedEntities.put("&boxhd;", "\u252C");
2125    definedEntities.put("&boxhu;", "\u2534");
2126    definedEntities.put("&boxminus;", "\u229F");
2127    definedEntities.put("&boxplus;", "\u229E");
2128    definedEntities.put("&boxtimes;", "\u22A0");
2129    definedEntities.put("&boxuL;", "\u255B");
2130    definedEntities.put("&boxuR;", "\u2558");
2131    definedEntities.put("&boxul;", "\u2518");
2132    definedEntities.put("&boxur;", "\u2514");
2133    definedEntities.put("&boxv;", "\u2502");
2134    definedEntities.put("&boxvH;", "\u256A");
2135    definedEntities.put("&boxvL;", "\u2561");
2136    definedEntities.put("&boxvR;", "\u255E");
2137    definedEntities.put("&boxvh;", "\u253C");
2138    definedEntities.put("&boxvl;", "\u2524");
2139    definedEntities.put("&boxvr;", "\u251C");
2140    definedEntities.put("&bprime;", "\u2035");
2141    definedEntities.put("&breve;", "\u02D8");
2142    definedEntities.put("&brvbar;", "\u00A6");
2143    definedEntities.put("&bscr;", "\uD835\uDCB7");
2144    definedEntities.put("&bsemi;", "\u204F");
2145    definedEntities.put("&bsim;", "\u223D");
2146    definedEntities.put("&bsime;", "\u22CD");
2147    definedEntities.put("&bsol;", "\\u005C");
2148    definedEntities.put("&bsolb;", "\u29C5");
2149    definedEntities.put("&bsolhsub;", "\u27C8");
2150    definedEntities.put("&bull;", "\u2022");
2151    definedEntities.put("&bullet;", "\u2022");
2152    definedEntities.put("&bump;", "\u224E");
2153    definedEntities.put("&bumpE;", "\u2AAE");
2154    definedEntities.put("&bumpe;", "\u224F");
2155    definedEntities.put("&bumpeq;", "\u224F");
2156    definedEntities.put("&cacute;", "\u0107");
2157    definedEntities.put("&cap;", "\u2229");
2158    definedEntities.put("&capand;", "\u2A44");
2159    definedEntities.put("&capbrcup;", "\u2A49");
2160    definedEntities.put("&capcap;", "\u2A4B");
2161    definedEntities.put("&capcup;", "\u2A47");
2162    definedEntities.put("&capdot;", "\u2A40");
2163    definedEntities.put("&caps;", "\u2229\uFE00");
2164    definedEntities.put("&caret;", "\u2041");
2165    definedEntities.put("&caron;", "\u02C7");
2166    definedEntities.put("&ccaps;", "\u2A4D");
2167    definedEntities.put("&ccaron;", "\u010D");
2168    definedEntities.put("&ccedil;", "\u00E7");
2169    definedEntities.put("&ccirc;", "\u0109");
2170    definedEntities.put("&ccups;", "\u2A4C");
2171    definedEntities.put("&ccupssm;", "\u2A50");
2172    definedEntities.put("&cdot;", "\u010B");
2173    definedEntities.put("&cedil;", "\u00B8");
2174    definedEntities.put("&cemptyv;", "\u29B2");
2175    definedEntities.put("&cent;", "\u00A2");
2176    definedEntities.put("&centerdot;", "\u00B7");
2177    definedEntities.put("&cfr;", "\uD835\uDD20");
2178    definedEntities.put("&chcy;", "\u0447");
2179    definedEntities.put("&check;", "\u2713");
2180    definedEntities.put("&checkmark;", "\u2713");
2181    definedEntities.put("&chi;", "\u03C7");
2182    definedEntities.put("&cir;", "\u25CB");
2183    definedEntities.put("&cirE;", "\u29C3");
2184    definedEntities.put("&circ;", "\u02C6");
2185    definedEntities.put("&circeq;", "\u2257");
2186    definedEntities.put("&circlearrowleft;", "\u21BA");
2187    definedEntities.put("&circlearrowright;", "\u21BB");
2188    definedEntities.put("&circledR;", "\u00AE");
2189    definedEntities.put("&circledS;", "\u24C8");
2190    definedEntities.put("&circledast;", "\u229B");
2191    definedEntities.put("&circledcirc;", "\u229A");
2192    definedEntities.put("&circleddash;", "\u229D");
2193    definedEntities.put("&cire;", "\u2257");
2194    definedEntities.put("&cirfnint;", "\u2A10");
2195    definedEntities.put("&cirmid;", "\u2AEF");
2196    definedEntities.put("&cirscir;", "\u29C2");
2197    definedEntities.put("&clubs;", "\u2663");
2198    definedEntities.put("&clubsuit;", "\u2663");
2199    definedEntities.put("&colon;", "\u003A");
2200    definedEntities.put("&colone;", "\u2254");
2201    definedEntities.put("&coloneq;", "\u2254");
2202    definedEntities.put("&comma;", "\u002C");
2203    definedEntities.put("&commat;", "\u0040");
2204    definedEntities.put("&comp;", "\u2201");
2205    definedEntities.put("&compfn;", "\u2218");
2206    definedEntities.put("&complement;", "\u2201");
2207    definedEntities.put("&complexes;", "\u2102");
2208    definedEntities.put("&cong;", "\u2245");
2209    definedEntities.put("&congdot;", "\u2A6D");
2210    definedEntities.put("&conint;", "\u222E");
2211    definedEntities.put("&copf;", "\uD835\uDD54");
2212    definedEntities.put("&coprod;", "\u2210");
2213    definedEntities.put("&copy;", "\u00A9");
2214    definedEntities.put("&copysr;", "\u2117");
2215    definedEntities.put("&crarr;", "\u21B5");
2216    definedEntities.put("&cross;", "\u2717");
2217    definedEntities.put("&cscr;", "\uD835\uDCB8");
2218    definedEntities.put("&csub;", "\u2ACF");
2219    definedEntities.put("&csube;", "\u2AD1");
2220    definedEntities.put("&csup;", "\u2AD0");
2221    definedEntities.put("&csupe;", "\u2AD2");
2222    definedEntities.put("&ctdot;", "\u22EF");
2223    definedEntities.put("&cudarrl;", "\u2938");
2224    definedEntities.put("&cudarrr;", "\u2935");
2225    definedEntities.put("&cuepr;", "\u22DE");
2226    definedEntities.put("&cuesc;", "\u22DF");
2227    definedEntities.put("&cularr;", "\u21B6");
2228    definedEntities.put("&cularrp;", "\u293D");
2229    definedEntities.put("&cup;", "\u222A");
2230    definedEntities.put("&cupbrcap;", "\u2A48");
2231    definedEntities.put("&cupcap;", "\u2A46");
2232    definedEntities.put("&cupcup;", "\u2A4A");
2233    definedEntities.put("&cupdot;", "\u228D");
2234    definedEntities.put("&cupor;", "\u2A45");
2235    definedEntities.put("&cups;", "\u222A\uFE00");
2236    definedEntities.put("&curarr;", "\u21B7");
2237    definedEntities.put("&curarrm;", "\u293C");
2238    definedEntities.put("&curlyeqprec;", "\u22DE");
2239    definedEntities.put("&curlyeqsucc;", "\u22DF");
2240    definedEntities.put("&curlyvee;", "\u22CE");
2241    definedEntities.put("&curlywedge;", "\u22CF");
2242    definedEntities.put("&curren;", "\u00A4");
2243    definedEntities.put("&curvearrowleft;", "\u21B6");
2244    definedEntities.put("&curvearrowright;", "\u21B7");
2245    definedEntities.put("&cuvee;", "\u22CE");
2246    definedEntities.put("&cuwed;", "\u22CF");
2247    definedEntities.put("&cwconint;", "\u2232");
2248    definedEntities.put("&cwint;", "\u2231");
2249    definedEntities.put("&cylcty;", "\u232D");
2250    definedEntities.put("&dArr;", "\u21D3");
2251    definedEntities.put("&dHar;", "\u2965");
2252    definedEntities.put("&dagger;", "\u2020");
2253    definedEntities.put("&daleth;", "\u2138");
2254    definedEntities.put("&darr;", "\u2193");
2255    definedEntities.put("&dash;", "\u2010");
2256    definedEntities.put("&dashv;", "\u22A3");
2257    definedEntities.put("&dbkarow;", "\u290F");
2258    definedEntities.put("&dblac;", "\u02DD");
2259    definedEntities.put("&dcaron;", "\u010F");
2260    definedEntities.put("&dcy;", "\u0434");
2261    definedEntities.put("&dd;", "\u2146");
2262    definedEntities.put("&ddagger;", "\u2021");
2263    definedEntities.put("&ddarr;", "\u21CA");
2264    definedEntities.put("&ddotseq;", "\u2A77");
2265    definedEntities.put("&deg;", "\u00B0");
2266    definedEntities.put("&delta;", "\u03B4");
2267    definedEntities.put("&demptyv;", "\u29B1");
2268    definedEntities.put("&dfisht;", "\u297F");
2269    definedEntities.put("&dfr;", "\uD835\uDD21");
2270    definedEntities.put("&dharl;", "\u21C3");
2271    definedEntities.put("&dharr;", "\u21C2");
2272    definedEntities.put("&diam;", "\u22C4");
2273    definedEntities.put("&diamond;", "\u22C4");
2274    definedEntities.put("&diamondsuit;", "\u2666");
2275    definedEntities.put("&diams;", "\u2666");
2276    definedEntities.put("&die;", "\u00A8");
2277    definedEntities.put("&digamma;", "\u03DD");
2278    definedEntities.put("&disin;", "\u22F2");
2279    definedEntities.put("&div;", "\u00F7");
2280    definedEntities.put("&divide;", "\u00F7");
2281    definedEntities.put("&divideontimes;", "\u22C7");
2282    definedEntities.put("&divonx;", "\u22C7");
2283    definedEntities.put("&djcy;", "\u0452");
2284    definedEntities.put("&dlcorn;", "\u231E");
2285    definedEntities.put("&dlcrop;", "\u230D");
2286    definedEntities.put("&dollar;", "\u0024");
2287    definedEntities.put("&dopf;", "\uD835\uDD55");
2288    definedEntities.put("&dot;", "\u02D9");
2289    definedEntities.put("&doteq;", "\u2250");
2290    definedEntities.put("&doteqdot;", "\u2251");
2291    definedEntities.put("&dotminus;", "\u2238");
2292    definedEntities.put("&dotplus;", "\u2214");
2293    definedEntities.put("&dotsquare;", "\u22A1");
2294    definedEntities.put("&doublebarwedge;", "\u2306");
2295    definedEntities.put("&downarrow;", "\u2193");
2296    definedEntities.put("&downdownarrows;", "\u21CA");
2297    definedEntities.put("&downharpoonleft;", "\u21C3");
2298    definedEntities.put("&downharpoonright;", "\u21C2");
2299    definedEntities.put("&drbkarow;", "\u2910");
2300    definedEntities.put("&drcorn;", "\u231F");
2301    definedEntities.put("&drcrop;", "\u230C");
2302    definedEntities.put("&dscr;", "\uD835\uDCB9");
2303    definedEntities.put("&dscy;", "\u0455");
2304    definedEntities.put("&dsol;", "\u29F6");
2305    definedEntities.put("&dstrok;", "\u0111");
2306    definedEntities.put("&dtdot;", "\u22F1");
2307    definedEntities.put("&dtri;", "\u25BF");
2308    definedEntities.put("&dtrif;", "\u25BE");
2309    definedEntities.put("&duarr;", "\u21F5");
2310    definedEntities.put("&duhar;", "\u296F");
2311    definedEntities.put("&dwangle;", "\u29A6");
2312    definedEntities.put("&dzcy;", "\u045F");
2313    definedEntities.put("&dzigrarr;", "\u27FF");
2314    definedEntities.put("&eDDot;", "\u2A77");
2315    definedEntities.put("&eDot;", "\u2251");
2316    definedEntities.put("&eacute;", "\u00E9");
2317    definedEntities.put("&easter;", "\u2A6E");
2318    definedEntities.put("&ecaron;", "\u011B");
2319    definedEntities.put("&ecir;", "\u2256");
2320    definedEntities.put("&ecirc;", "\u00EA");
2321    definedEntities.put("&ecolon;", "\u2255");
2322    definedEntities.put("&ecy;", "\u044D");
2323    definedEntities.put("&edot;", "\u0117");
2324    definedEntities.put("&ee;", "\u2147");
2325    definedEntities.put("&efDot;", "\u2252");
2326    definedEntities.put("&efr;", "\uD835\uDD22");
2327    definedEntities.put("&eg;", "\u2A9A");
2328    definedEntities.put("&egrave;", "\u00E8");
2329    definedEntities.put("&egs;", "\u2A96");
2330    definedEntities.put("&egsdot;", "\u2A98");
2331    definedEntities.put("&el;", "\u2A99");
2332    definedEntities.put("&elinters;", "\u23E7");
2333    definedEntities.put("&ell;", "\u2113");
2334    definedEntities.put("&els;", "\u2A95");
2335    definedEntities.put("&elsdot;", "\u2A97");
2336    definedEntities.put("&emacr;", "\u0113");
2337    definedEntities.put("&empty;", "\u2205");
2338    definedEntities.put("&emptyset;", "\u2205");
2339    definedEntities.put("&emptyv;", "\u2205");
2340    definedEntities.put("&emsp13;", "\u2004");
2341    definedEntities.put("&emsp14;", "\u2005");
2342    definedEntities.put("&emsp;", "\u2003");
2343    definedEntities.put("&eng;", "\u014B");
2344    definedEntities.put("&ensp;", "\u2002");
2345    definedEntities.put("&eogon;", "\u0119");
2346    definedEntities.put("&eopf;", "\uD835\uDD56");
2347    definedEntities.put("&epar;", "\u22D5");
2348    definedEntities.put("&eparsl;", "\u29E3");
2349    definedEntities.put("&eplus;", "\u2A71");
2350    definedEntities.put("&epsi;", "\u03B5");
2351    definedEntities.put("&epsilon;", "\u03B5");
2352    definedEntities.put("&epsiv;", "\u03F5");
2353    definedEntities.put("&eqcirc;", "\u2256");
2354    definedEntities.put("&eqcolon;", "\u2255");
2355    definedEntities.put("&eqsim;", "\u2242");
2356    definedEntities.put("&eqslantgtr;", "\u2A96");
2357    definedEntities.put("&eqslantless;", "\u2A95");
2358    definedEntities.put("&equals;", "\u003D");
2359    definedEntities.put("&equest;", "\u225F");
2360    definedEntities.put("&equiv;", "\u2261");
2361    definedEntities.put("&equivDD;", "\u2A78");
2362    definedEntities.put("&eqvparsl;", "\u29E5");
2363    definedEntities.put("&erDot;", "\u2253");
2364    definedEntities.put("&erarr;", "\u2971");
2365    definedEntities.put("&escr;", "\u212F");
2366    definedEntities.put("&esdot;", "\u2250");
2367    definedEntities.put("&esim;", "\u2242");
2368    definedEntities.put("&eta;", "\u03B7");
2369    definedEntities.put("&eth;", "\u00F0");
2370    definedEntities.put("&euml;", "\u00EB");
2371    definedEntities.put("&euro;", "\u20AC");
2372    definedEntities.put("&excl;", "\u0021");
2373    definedEntities.put("&exist;", "\u2203");
2374    definedEntities.put("&expectation;", "\u2130");
2375    definedEntities.put("&exponentiale;", "\u2147");
2376    definedEntities.put("&fallingdotseq;", "\u2252");
2377    definedEntities.put("&fcy;", "\u0444");
2378    definedEntities.put("&female;", "\u2640");
2379    definedEntities.put("&ffilig;", "\uFB03");
2380    definedEntities.put("&fflig;", "\uFB00");
2381    definedEntities.put("&ffllig;", "\uFB04");
2382    definedEntities.put("&ffr;", "\uD835\uDD23");
2383    definedEntities.put("&filig;", "\uFB01");
2384    definedEntities.put("&fjlig;", "\u0066\u006A");
2385    definedEntities.put("&flat;", "\u266D");
2386    definedEntities.put("&fllig;", "\uFB02");
2387    definedEntities.put("&fltns;", "\u25B1");
2388    definedEntities.put("&fnof;", "\u0192");
2389    definedEntities.put("&fopf;", "\uD835\uDD57");
2390    definedEntities.put("&forall;", "\u2200");
2391    definedEntities.put("&fork;", "\u22D4");
2392    definedEntities.put("&forkv;", "\u2AD9");
2393    definedEntities.put("&fpartint;", "\u2A0D");
2394    definedEntities.put("&frac12;", "\u00BD");
2395    definedEntities.put("&frac13;", "\u2153");
2396    definedEntities.put("&frac14;", "\u00BC");
2397    definedEntities.put("&frac15;", "\u2155");
2398    definedEntities.put("&frac16;", "\u2159");
2399    definedEntities.put("&frac18;", "\u215B");
2400    definedEntities.put("&frac23;", "\u2154");
2401    definedEntities.put("&frac25;", "\u2156");
2402    definedEntities.put("&frac34;", "\u00BE");
2403    definedEntities.put("&frac35;", "\u2157");
2404    definedEntities.put("&frac38;", "\u215C");
2405    definedEntities.put("&frac45;", "\u2158");
2406    definedEntities.put("&frac56;", "\u215A");
2407    definedEntities.put("&frac58;", "\u215D");
2408    definedEntities.put("&frac78;", "\u215E");
2409    definedEntities.put("&frasl;", "\u2044");
2410    definedEntities.put("&frown;", "\u2322");
2411    definedEntities.put("&fscr;", "\uD835\uDCBB");
2412    definedEntities.put("&gE;", "\u2267");
2413    definedEntities.put("&gEl;", "\u2A8C");
2414    definedEntities.put("&gacute;", "\u01F5");
2415    definedEntities.put("&gamma;", "\u03B3");
2416    definedEntities.put("&gammad;", "\u03DD");
2417    definedEntities.put("&gap;", "\u2A86");
2418    definedEntities.put("&gbreve;", "\u011F");
2419    definedEntities.put("&gcirc;", "\u011D");
2420    definedEntities.put("&gcy;", "\u0433");
2421    definedEntities.put("&gdot;", "\u0121");
2422    definedEntities.put("&ge;", "\u2265");
2423    definedEntities.put("&gel;", "\u22DB");
2424    definedEntities.put("&geq;", "\u2265");
2425    definedEntities.put("&geqq;", "\u2267");
2426    definedEntities.put("&geqslant;", "\u2A7E");
2427    definedEntities.put("&ges;", "\u2A7E");
2428    definedEntities.put("&gescc;", "\u2AA9");
2429    definedEntities.put("&gesdot;", "\u2A80");
2430    definedEntities.put("&gesdoto;", "\u2A82");
2431    definedEntities.put("&gesdotol;", "\u2A84");
2432    definedEntities.put("&gesl;", "\u22DB\uFE00");
2433    definedEntities.put("&gesles;", "\u2A94");
2434    definedEntities.put("&gfr;", "\uD835\uDD24");
2435    definedEntities.put("&gg;", "\u226B");
2436    definedEntities.put("&ggg;", "\u22D9");
2437    definedEntities.put("&gimel;", "\u2137");
2438    definedEntities.put("&gjcy;", "\u0453");
2439    definedEntities.put("&gl;", "\u2277");
2440    definedEntities.put("&glE;", "\u2A92");
2441    definedEntities.put("&gla;", "\u2AA5");
2442    definedEntities.put("&glj;", "\u2AA4");
2443    definedEntities.put("&gnE;", "\u2269");
2444    definedEntities.put("&gnap;", "\u2A8A");
2445    definedEntities.put("&gnapprox;", "\u2A8A");
2446    definedEntities.put("&gne;", "\u2A88");
2447    definedEntities.put("&gneq;", "\u2A88");
2448    definedEntities.put("&gneqq;", "\u2269");
2449    definedEntities.put("&gnsim;", "\u22E7");
2450    definedEntities.put("&gopf;", "\uD835\uDD58");
2451    definedEntities.put("&grave;", "\u0060");
2452    definedEntities.put("&gscr;", "\u210A");
2453    definedEntities.put("&gsim;", "\u2273");
2454    definedEntities.put("&gsime;", "\u2A8E");
2455    definedEntities.put("&gsiml;", "\u2A90");
2456//    definedEntities.put("&gt;", "\u003E");
2457    definedEntities.put("&gtcc;", "\u2AA7");
2458    definedEntities.put("&gtcir;", "\u2A7A");
2459    definedEntities.put("&gtdot;", "\u22D7");
2460    definedEntities.put("&gtlPar;", "\u2995");
2461    definedEntities.put("&gtquest;", "\u2A7C");
2462    definedEntities.put("&gtrapprox;", "\u2A86");
2463    definedEntities.put("&gtrarr;", "\u2978");
2464    definedEntities.put("&gtrdot;", "\u22D7");
2465    definedEntities.put("&gtreqless;", "\u22DB");
2466    definedEntities.put("&gtreqqless;", "\u2A8C");
2467    definedEntities.put("&gtrless;", "\u2277");
2468    definedEntities.put("&gtrsim;", "\u2273");
2469    definedEntities.put("&gvertneqq;", "\u2269\uFE00");
2470    definedEntities.put("&gvnE;", "\u2269\uFE00");
2471    definedEntities.put("&hArr;", "\u21D4");
2472    definedEntities.put("&hairsp;", "\u200A");
2473    definedEntities.put("&half;", "\u00BD");
2474    definedEntities.put("&hamilt;", "\u210B");
2475    definedEntities.put("&hardcy;", "\u044A");
2476    definedEntities.put("&harr;", "\u2194");
2477    definedEntities.put("&harrcir;", "\u2948");
2478    definedEntities.put("&harrw;", "\u21AD");
2479    definedEntities.put("&hbar;", "\u210F");
2480    definedEntities.put("&hcirc;", "\u0125");
2481    definedEntities.put("&hearts;", "\u2665");
2482    definedEntities.put("&heartsuit;", "\u2665");
2483    definedEntities.put("&hellip;", "\u2026");
2484    definedEntities.put("&hercon;", "\u22B9");
2485    definedEntities.put("&hfr;", "\uD835\uDD25");
2486    definedEntities.put("&hksearow;", "\u2925");
2487    definedEntities.put("&hkswarow;", "\u2926");
2488    definedEntities.put("&hoarr;", "\u21FF");
2489    definedEntities.put("&homtht;", "\u223B");
2490    definedEntities.put("&hookleftarrow;", "\u21A9");
2491    definedEntities.put("&hookrightarrow;", "\u21AA");
2492    definedEntities.put("&hopf;", "\uD835\uDD59");
2493    definedEntities.put("&horbar;", "\u2015");
2494    definedEntities.put("&hscr;", "\uD835\uDCBD");
2495    definedEntities.put("&hslash;", "\u210F");
2496    definedEntities.put("&hstrok;", "\u0127");
2497    definedEntities.put("&hybull;", "\u2043");
2498    definedEntities.put("&hyphen;", "\u2010");
2499    definedEntities.put("&iacute;", "\u00ED");
2500    definedEntities.put("&ic;", "\u2063");
2501    definedEntities.put("&icirc;", "\u00EE");
2502    definedEntities.put("&icy;", "\u0438");
2503    definedEntities.put("&iecy;", "\u0435");
2504    definedEntities.put("&iexcl;", "\u00A1");
2505    definedEntities.put("&iff;", "\u21D4");
2506    definedEntities.put("&ifr;", "\uD835\uDD26");
2507    definedEntities.put("&igrave;", "\u00EC");
2508    definedEntities.put("&ii;", "\u2148");
2509    definedEntities.put("&iiiint;", "\u2A0C");
2510    definedEntities.put("&iiint;", "\u222D");
2511    definedEntities.put("&iinfin;", "\u29DC");
2512    definedEntities.put("&iiota;", "\u2129");
2513    definedEntities.put("&ijlig;", "\u0133");
2514    definedEntities.put("&imacr;", "\u012B");
2515    definedEntities.put("&image;", "\u2111");
2516    definedEntities.put("&imagline;", "\u2110");
2517    definedEntities.put("&imagpart;", "\u2111");
2518    definedEntities.put("&imath;", "\u0131");
2519    definedEntities.put("&imof;", "\u22B7");
2520    definedEntities.put("&imped;", "\u01B5");
2521    definedEntities.put("&in;", "\u2208");
2522    definedEntities.put("&incare;", "\u2105");
2523    definedEntities.put("&infin;", "\u221E");
2524    definedEntities.put("&infintie;", "\u29DD");
2525    definedEntities.put("&inodot;", "\u0131");
2526    definedEntities.put("&int;", "\u222B");
2527    definedEntities.put("&intcal;", "\u22BA");
2528    definedEntities.put("&integers;", "\u2124");
2529    definedEntities.put("&intercal;", "\u22BA");
2530    definedEntities.put("&intlarhk;", "\u2A17");
2531    definedEntities.put("&intprod;", "\u2A3C");
2532    definedEntities.put("&iocy;", "\u0451");
2533    definedEntities.put("&iogon;", "\u012F");
2534    definedEntities.put("&iopf;", "\uD835\uDD5A");
2535    definedEntities.put("&iota;", "\u03B9");
2536    definedEntities.put("&iprod;", "\u2A3C");
2537    definedEntities.put("&iquest;", "\u00BF");
2538    definedEntities.put("&iscr;", "\uD835\uDCBE");
2539    definedEntities.put("&isin;", "\u2208");
2540    definedEntities.put("&isinE;", "\u22F9");
2541    definedEntities.put("&isindot;", "\u22F5");
2542    definedEntities.put("&isins;", "\u22F4");
2543    definedEntities.put("&isinsv;", "\u22F3");
2544    definedEntities.put("&isinv;", "\u2208");
2545    definedEntities.put("&it;", "\u2062");
2546    definedEntities.put("&itilde;", "\u0129");
2547    definedEntities.put("&iukcy;", "\u0456");
2548    definedEntities.put("&iuml;", "\u00EF");
2549    definedEntities.put("&jcirc;", "\u0135");
2550    definedEntities.put("&jcy;", "\u0439");
2551    definedEntities.put("&jfr;", "\uD835\uDD27");
2552    definedEntities.put("&jmath;", "\u0237");
2553    definedEntities.put("&jopf;", "\uD835\uDD5B");
2554    definedEntities.put("&jscr;", "\uD835\uDCBF");
2555    definedEntities.put("&jsercy;", "\u0458");
2556    definedEntities.put("&jukcy;", "\u0454");
2557    definedEntities.put("&kappa;", "\u03BA");
2558    definedEntities.put("&kappav;", "\u03F0");
2559    definedEntities.put("&kcedil;", "\u0137");
2560    definedEntities.put("&kcy;", "\u043A");
2561    definedEntities.put("&kfr;", "\uD835\uDD28");
2562    definedEntities.put("&kgreen;", "\u0138");
2563    definedEntities.put("&khcy;", "\u0445");
2564    definedEntities.put("&kjcy;", "\u045C");
2565    definedEntities.put("&kopf;", "\uD835\uDD5C");
2566    definedEntities.put("&kscr;", "\uD835\uDCC0");
2567    definedEntities.put("&lAarr;", "\u21DA");
2568    definedEntities.put("&lArr;", "\u21D0");
2569    definedEntities.put("&lAtail;", "\u291B");
2570    definedEntities.put("&lBarr;", "\u290E");
2571    definedEntities.put("&lE;", "\u2266");
2572    definedEntities.put("&lEg;", "\u2A8B");
2573    definedEntities.put("&lHar;", "\u2962");
2574    definedEntities.put("&lacute;", "\u013A");
2575    definedEntities.put("&laemptyv;", "\u29B4");
2576    definedEntities.put("&lagran;", "\u2112");
2577    definedEntities.put("&lambda;", "\u03BB");
2578    definedEntities.put("&lang;", "\u27E8");
2579    definedEntities.put("&langd;", "\u2991");
2580    definedEntities.put("&langle;", "\u27E8");
2581    definedEntities.put("&lap;", "\u2A85");
2582    definedEntities.put("&laquo;", "\u00AB");
2583    definedEntities.put("&larr;", "\u2190");
2584    definedEntities.put("&larrb;", "\u21E4");
2585    definedEntities.put("&larrbfs;", "\u291F");
2586    definedEntities.put("&larrfs;", "\u291D");
2587    definedEntities.put("&larrhk;", "\u21A9");
2588    definedEntities.put("&larrlp;", "\u21AB");
2589    definedEntities.put("&larrpl;", "\u2939");
2590    definedEntities.put("&larrsim;", "\u2973");
2591    definedEntities.put("&larrtl;", "\u21A2");
2592    definedEntities.put("&lat;", "\u2AAB");
2593    definedEntities.put("&latail;", "\u2919");
2594    definedEntities.put("&late;", "\u2AAD");
2595    definedEntities.put("&lates;", "\u2AAD\uFE00");
2596    definedEntities.put("&lbarr;", "\u290C");
2597    definedEntities.put("&lbbrk;", "\u2772");
2598    definedEntities.put("&lbrace;", "\u007B");
2599    definedEntities.put("&lbrack;", "\u005B");
2600    definedEntities.put("&lbrke;", "\u298B");
2601    definedEntities.put("&lbrksld;", "\u298F");
2602    definedEntities.put("&lbrkslu;", "\u298D");
2603    definedEntities.put("&lcaron;", "\u013E");
2604    definedEntities.put("&lcedil;", "\u013C");
2605    definedEntities.put("&lceil;", "\u2308");
2606    definedEntities.put("&lcub;", "\u007B");
2607    definedEntities.put("&lcy;", "\u043B");
2608    definedEntities.put("&ldca;", "\u2936");
2609    definedEntities.put("&ldquo;", "\u201C");
2610    definedEntities.put("&ldquor;", "\u201E");
2611    definedEntities.put("&ldrdhar;", "\u2967");
2612    definedEntities.put("&ldrushar;", "\u294B");
2613    definedEntities.put("&ldsh;", "\u21B2");
2614    definedEntities.put("&le;", "\u2264");
2615    definedEntities.put("&leftarrow;", "\u2190");
2616    definedEntities.put("&leftarrowtail;", "\u21A2");
2617    definedEntities.put("&leftharpoondown;", "\u21BD");
2618    definedEntities.put("&leftharpoonup;", "\u21BC");
2619    definedEntities.put("&leftleftarrows;", "\u21C7");
2620    definedEntities.put("&leftrightarrow;", "\u2194");
2621    definedEntities.put("&leftrightarrows;", "\u21C6");
2622    definedEntities.put("&leftrightharpoons;", "\u21CB");
2623    definedEntities.put("&leftrightsquigarrow;", "\u21AD");
2624    definedEntities.put("&leftthreetimes;", "\u22CB");
2625    definedEntities.put("&leg;", "\u22DA");
2626    definedEntities.put("&leq;", "\u2264");
2627    definedEntities.put("&leqq;", "\u2266");
2628    definedEntities.put("&leqslant;", "\u2A7D");
2629    definedEntities.put("&les;", "\u2A7D");
2630    definedEntities.put("&lescc;", "\u2AA8");
2631    definedEntities.put("&lesdot;", "\u2A7F");
2632    definedEntities.put("&lesdoto;", "\u2A81");
2633    definedEntities.put("&lesdotor;", "\u2A83");
2634    definedEntities.put("&lesg;", "\u22DA\uFE00");
2635    definedEntities.put("&lesges;", "\u2A93");
2636    definedEntities.put("&lessapprox;", "\u2A85");
2637    definedEntities.put("&lessdot;", "\u22D6");
2638    definedEntities.put("&lesseqgtr;", "\u22DA");
2639    definedEntities.put("&lesseqqgtr;", "\u2A8B");
2640    definedEntities.put("&lessgtr;", "\u2276");
2641    definedEntities.put("&lesssim;", "\u2272");
2642    definedEntities.put("&lfisht;", "\u297C");
2643    definedEntities.put("&lfloor;", "\u230A");
2644    definedEntities.put("&lfr;", "\uD835\uDD29");
2645    definedEntities.put("&lg;", "\u2276");
2646    definedEntities.put("&lgE;", "\u2A91");
2647    definedEntities.put("&lhard;", "\u21BD");
2648    definedEntities.put("&lharu;", "\u21BC");
2649    definedEntities.put("&lharul;", "\u296A");
2650    definedEntities.put("&lhblk;", "\u2584");
2651    definedEntities.put("&ljcy;", "\u0459");
2652    definedEntities.put("&ll;", "\u226A");
2653    definedEntities.put("&llarr;", "\u21C7");
2654    definedEntities.put("&llcorner;", "\u231E");
2655    definedEntities.put("&llhard;", "\u296B");
2656    definedEntities.put("&lltri;", "\u25FA");
2657    definedEntities.put("&lmidot;", "\u0140");
2658    definedEntities.put("&lmoust;", "\u23B0");
2659    definedEntities.put("&lmoustache;", "\u23B0");
2660    definedEntities.put("&lnE;", "\u2268");
2661    definedEntities.put("&lnap;", "\u2A89");
2662    definedEntities.put("&lnapprox;", "\u2A89");
2663    definedEntities.put("&lne;", "\u2A87");
2664    definedEntities.put("&lneq;", "\u2A87");
2665    definedEntities.put("&lneqq;", "\u2268");
2666    definedEntities.put("&lnsim;", "\u22E6");
2667    definedEntities.put("&loang;", "\u27EC");
2668    definedEntities.put("&loarr;", "\u21FD");
2669    definedEntities.put("&lobrk;", "\u27E6");
2670    definedEntities.put("&longleftarrow;", "\u27F5");
2671    definedEntities.put("&longleftrightarrow;", "\u27F7");
2672    definedEntities.put("&longmapsto;", "\u27FC");
2673    definedEntities.put("&longrightarrow;", "\u27F6");
2674    definedEntities.put("&looparrowleft;", "\u21AB");
2675    definedEntities.put("&looparrowright;", "\u21AC");
2676    definedEntities.put("&lopar;", "\u2985");
2677    definedEntities.put("&lopf;", "\uD835\uDD5D");
2678    definedEntities.put("&loplus;", "\u2A2D");
2679    definedEntities.put("&lotimes;", "\u2A34");
2680    definedEntities.put("&lowast;", "\u2217");
2681    definedEntities.put("&lowbar;", "\u005F");
2682    definedEntities.put("&loz;", "\u25CA");
2683    definedEntities.put("&lozenge;", "\u25CA");
2684    definedEntities.put("&lozf;", "\u29EB");
2685    definedEntities.put("&lpar;", "\u0028");
2686    definedEntities.put("&lparlt;", "\u2993");
2687    definedEntities.put("&lrarr;", "\u21C6");
2688    definedEntities.put("&lrcorner;", "\u231F");
2689    definedEntities.put("&lrhar;", "\u21CB");
2690    definedEntities.put("&lrhard;", "\u296D");
2691    definedEntities.put("&lrm;", "\u200E");
2692    definedEntities.put("&lrtri;", "\u22BF");
2693    definedEntities.put("&lsaquo;", "\u2039");
2694    definedEntities.put("&lscr;", "\uD835\uDCC1");
2695    definedEntities.put("&lsh;", "\u21B0");
2696    definedEntities.put("&lsim;", "\u2272");
2697    definedEntities.put("&lsime;", "\u2A8D");
2698    definedEntities.put("&lsimg;", "\u2A8F");
2699    definedEntities.put("&lsqb;", "\u005B");
2700    definedEntities.put("&lsquo;", "\u2018");
2701    definedEntities.put("&lsquor;", "\u201A");
2702    definedEntities.put("&lstrok;", "\u0142");
2703//    definedEntities.put("&lt;", "\u003C");
2704    definedEntities.put("&ltcc;", "\u2AA6");
2705    definedEntities.put("&ltcir;", "\u2A79");
2706    definedEntities.put("&ltdot;", "\u22D6");
2707    definedEntities.put("&lthree;", "\u22CB");
2708    definedEntities.put("&ltimes;", "\u22C9");
2709    definedEntities.put("&ltlarr;", "\u2976");
2710    definedEntities.put("&ltquest;", "\u2A7B");
2711    definedEntities.put("&ltrPar;", "\u2996");
2712    definedEntities.put("&ltri;", "\u25C3");
2713    definedEntities.put("&ltrie;", "\u22B4");
2714    definedEntities.put("&ltrif;", "\u25C2");
2715    definedEntities.put("&lurdshar;", "\u294A");
2716    definedEntities.put("&luruhar;", "\u2966");
2717    definedEntities.put("&lvertneqq;", "\u2268\uFE00");
2718    definedEntities.put("&lvnE;", "\u2268\uFE00");
2719    definedEntities.put("&mDDot;", "\u223A");
2720    definedEntities.put("&macr;", "\u00AF");
2721    definedEntities.put("&male;", "\u2642");
2722    definedEntities.put("&malt;", "\u2720");
2723    definedEntities.put("&maltese;", "\u2720");
2724    definedEntities.put("&map;", "\u21A6");
2725    definedEntities.put("&mapsto;", "\u21A6");
2726    definedEntities.put("&mapstodown;", "\u21A7");
2727    definedEntities.put("&mapstoleft;", "\u21A4");
2728    definedEntities.put("&mapstoup;", "\u21A5");
2729    definedEntities.put("&marker;", "\u25AE");
2730    definedEntities.put("&mcomma;", "\u2A29");
2731    definedEntities.put("&mcy;", "\u043C");
2732    definedEntities.put("&mdash;", "\u2014");
2733    definedEntities.put("&measuredangle;", "\u2221");
2734    definedEntities.put("&mfr;", "\uD835\uDD2A");
2735    definedEntities.put("&mho;", "\u2127");
2736    definedEntities.put("&micro;", "\u00B5");
2737    definedEntities.put("&mid;", "\u2223");
2738    definedEntities.put("&midast;", "\u002A");
2739    definedEntities.put("&midcir;", "\u2AF0");
2740    definedEntities.put("&middot;", "\u00B7");
2741    definedEntities.put("&minus;", "\u2212");
2742    definedEntities.put("&minusb;", "\u229F");
2743    definedEntities.put("&minusd;", "\u2238");
2744    definedEntities.put("&minusdu;", "\u2A2A");
2745    definedEntities.put("&mlcp;", "\u2ADB");
2746    definedEntities.put("&mldr;", "\u2026");
2747    definedEntities.put("&mnplus;", "\u2213");
2748    definedEntities.put("&models;", "\u22A7");
2749    definedEntities.put("&mopf;", "\uD835\uDD5E");
2750    definedEntities.put("&mp;", "\u2213");
2751    definedEntities.put("&mscr;", "\uD835\uDCC2");
2752    definedEntities.put("&mstpos;", "\u223E");
2753    definedEntities.put("&mu;", "\u03BC");
2754    definedEntities.put("&multimap;", "\u22B8");
2755    definedEntities.put("&mumap;", "\u22B8");
2756    definedEntities.put("&nGg;", "\u22D9\u0338");
2757    definedEntities.put("&nGt;", "\u226B\u20D2");
2758    definedEntities.put("&nGtv;", "\u226B\u0338");
2759    definedEntities.put("&nLeftarrow;", "\u21CD");
2760    definedEntities.put("&nLeftrightarrow;", "\u21CE");
2761    definedEntities.put("&nLl;", "\u22D8\u0338");
2762    definedEntities.put("&nLt;", "\u226A\u20D2");
2763    definedEntities.put("&nLtv;", "\u226A\u0338");
2764    definedEntities.put("&nRightarrow;", "\u21CF");
2765    definedEntities.put("&nVDash;", "\u22AF");
2766    definedEntities.put("&nVdash;", "\u22AE");
2767    definedEntities.put("&nabla;", "\u2207");
2768    definedEntities.put("&nacute;", "\u0144");
2769    definedEntities.put("&nang;", "\u2220\u20D2");
2770    definedEntities.put("&nap;", "\u2249");
2771    definedEntities.put("&napE;", "\u2A70\u0338");
2772    definedEntities.put("&napid;", "\u224B\u0338");
2773    definedEntities.put("&napos;", "\u0149");
2774    definedEntities.put("&napprox;", "\u2249");
2775    definedEntities.put("&natur;", "\u266E");
2776    definedEntities.put("&natural;", "\u266E");
2777    definedEntities.put("&naturals;", "\u2115");
2778    definedEntities.put("&nbsp;", "\u00A0");
2779    definedEntities.put("&nbump;", "\u224E\u0338");
2780    definedEntities.put("&nbumpe;", "\u224F\u0338");
2781    definedEntities.put("&ncap;", "\u2A43");
2782    definedEntities.put("&ncaron;", "\u0148");
2783    definedEntities.put("&ncedil;", "\u0146");
2784    definedEntities.put("&ncong;", "\u2247");
2785    definedEntities.put("&ncongdot;", "\u2A6D\u0338");
2786    definedEntities.put("&ncup;", "\u2A42");
2787    definedEntities.put("&ncy;", "\u043D");
2788    definedEntities.put("&ndash;", "\u2013");
2789    definedEntities.put("&ne;", "\u2260");
2790    definedEntities.put("&neArr;", "\u21D7");
2791    definedEntities.put("&nearhk;", "\u2924");
2792    definedEntities.put("&nearr;", "\u2197");
2793    definedEntities.put("&nearrow;", "\u2197");
2794    definedEntities.put("&nedot;", "\u2250\u0338");
2795    definedEntities.put("&nequiv;", "\u2262");
2796    definedEntities.put("&nesear;", "\u2928");
2797    definedEntities.put("&nesim;", "\u2242\u0338");
2798    definedEntities.put("&nexist;", "\u2204");
2799    definedEntities.put("&nexists;", "\u2204");
2800    definedEntities.put("&nfr;", "\uD835\uDD2B");
2801    definedEntities.put("&ngE;", "\u2267\u0338");
2802    definedEntities.put("&nge;", "\u2271");
2803    definedEntities.put("&ngeq;", "\u2271");
2804    definedEntities.put("&ngeqq;", "\u2267\u0338");
2805    definedEntities.put("&ngeqslant;", "\u2A7E\u0338");
2806    definedEntities.put("&nges;", "\u2A7E\u0338");
2807    definedEntities.put("&ngsim;", "\u2275");
2808    definedEntities.put("&ngt;", "\u226F");
2809    definedEntities.put("&ngtr;", "\u226F");
2810    definedEntities.put("&nhArr;", "\u21CE");
2811    definedEntities.put("&nharr;", "\u21AE");
2812    definedEntities.put("&nhpar;", "\u2AF2");
2813    definedEntities.put("&ni;", "\u220B");
2814    definedEntities.put("&nis;", "\u22FC");
2815    definedEntities.put("&nisd;", "\u22FA");
2816    definedEntities.put("&niv;", "\u220B");
2817    definedEntities.put("&njcy;", "\u045A");
2818    definedEntities.put("&nlArr;", "\u21CD");
2819    definedEntities.put("&nlE;", "\u2266\u0338");
2820    definedEntities.put("&nlarr;", "\u219A");
2821    definedEntities.put("&nldr;", "\u2025");
2822    definedEntities.put("&nle;", "\u2270");
2823    definedEntities.put("&nleftarrow;", "\u219A");
2824    definedEntities.put("&nleftrightarrow;", "\u21AE");
2825    definedEntities.put("&nleq;", "\u2270");
2826    definedEntities.put("&nleqq;", "\u2266\u0338");
2827    definedEntities.put("&nleqslant;", "\u2A7D\u0338");
2828    definedEntities.put("&nles;", "\u2A7D\u0338");
2829    definedEntities.put("&nless;", "\u226E");
2830    definedEntities.put("&nlsim;", "\u2274");
2831    definedEntities.put("&nlt;", "\u226E");
2832    definedEntities.put("&nltri;", "\u22EA");
2833    definedEntities.put("&nltrie;", "\u22EC");
2834    definedEntities.put("&nmid;", "\u2224");
2835    definedEntities.put("&nopf;", "\uD835\uDD5F");
2836    definedEntities.put("&not;", "\u00AC");
2837    definedEntities.put("&notin;", "\u2209");
2838    definedEntities.put("&notinE;", "\u22F9\u0338");
2839    definedEntities.put("&notindot;", "\u22F5\u0338");
2840    definedEntities.put("&notinva;", "\u2209");
2841    definedEntities.put("&notinvb;", "\u22F7");
2842    definedEntities.put("&notinvc;", "\u22F6");
2843    definedEntities.put("&notni;", "\u220C");
2844    definedEntities.put("&notniva;", "\u220C");
2845    definedEntities.put("&notnivb;", "\u22FE");
2846    definedEntities.put("&notnivc;", "\u22FD");
2847    definedEntities.put("&npar;", "\u2226");
2848    definedEntities.put("&nparallel;", "\u2226");
2849    definedEntities.put("&nparsl;", "\u2AFD\u20E5");
2850    definedEntities.put("&npart;", "\u2202\u0338");
2851    definedEntities.put("&npolint;", "\u2A14");
2852    definedEntities.put("&npr;", "\u2280");
2853    definedEntities.put("&nprcue;", "\u22E0");
2854    definedEntities.put("&npre;", "\u2AAF\u0338");
2855    definedEntities.put("&nprec;", "\u2280");
2856    definedEntities.put("&npreceq;", "\u2AAF\u0338");
2857    definedEntities.put("&nrArr;", "\u21CF");
2858    definedEntities.put("&nrarr;", "\u219B");
2859    definedEntities.put("&nrarrc;", "\u2933\u0338");
2860    definedEntities.put("&nrarrw;", "\u219D\u0338");
2861    definedEntities.put("&nrightarrow;", "\u219B");
2862    definedEntities.put("&nrtri;", "\u22EB");
2863    definedEntities.put("&nrtrie;", "\u22ED");
2864    definedEntities.put("&nsc;", "\u2281");
2865    definedEntities.put("&nsccue;", "\u22E1");
2866    definedEntities.put("&nsce;", "\u2AB0\u0338");
2867    definedEntities.put("&nscr;", "\uD835\uDCC3");
2868    definedEntities.put("&nshortmid;", "\u2224");
2869    definedEntities.put("&nshortparallel;", "\u2226");
2870    definedEntities.put("&nsim;", "\u2241");
2871    definedEntities.put("&nsime;", "\u2244");
2872    definedEntities.put("&nsimeq;", "\u2244");
2873    definedEntities.put("&nsmid;", "\u2224");
2874    definedEntities.put("&nspar;", "\u2226");
2875    definedEntities.put("&nsqsube;", "\u22E2");
2876    definedEntities.put("&nsqsupe;", "\u22E3");
2877    definedEntities.put("&nsub;", "\u2284");
2878    definedEntities.put("&nsubE;", "\u2AC5\u0338");
2879    definedEntities.put("&nsube;", "\u2288");
2880    definedEntities.put("&nsubset;", "\u2282\u20D2");
2881    definedEntities.put("&nsubseteq;", "\u2288");
2882    definedEntities.put("&nsubseteqq;", "\u2AC5\u0338");
2883    definedEntities.put("&nsucc;", "\u2281");
2884    definedEntities.put("&nsucceq;", "\u2AB0\u0338");
2885    definedEntities.put("&nsup;", "\u2285");
2886    definedEntities.put("&nsupE;", "\u2AC6\u0338");
2887    definedEntities.put("&nsupe;", "\u2289");
2888    definedEntities.put("&nsupset;", "\u2283\u20D2");
2889    definedEntities.put("&nsupseteq;", "\u2289");
2890    definedEntities.put("&nsupseteqq;", "\u2AC6\u0338");
2891    definedEntities.put("&ntgl;", "\u2279");
2892    definedEntities.put("&ntilde;", "\u00F1");
2893    definedEntities.put("&ntlg;", "\u2278");
2894    definedEntities.put("&ntriangleleft;", "\u22EA");
2895    definedEntities.put("&ntrianglelefteq;", "\u22EC");
2896    definedEntities.put("&ntriangleright;", "\u22EB");
2897    definedEntities.put("&ntrianglerighteq;", "\u22ED");
2898    definedEntities.put("&nu;", "\u03BD");
2899    definedEntities.put("&num;", "\u0023");
2900    definedEntities.put("&numero;", "\u2116");
2901    definedEntities.put("&numsp;", "\u2007");
2902    definedEntities.put("&nvDash;", "\u22AD");
2903    definedEntities.put("&nvHarr;", "\u2904");
2904    definedEntities.put("&nvap;", "\u224D\u20D2");
2905    definedEntities.put("&nvdash;", "\u22AC");
2906    definedEntities.put("&nvge;", "\u2265\u20D2");
2907    definedEntities.put("&nvgt;", "\u003E\u20D2");
2908    definedEntities.put("&nvinfin;", "\u29DE");
2909    definedEntities.put("&nvlArr;", "\u2902");
2910    definedEntities.put("&nvle;", "\u2264\u20D2");
2911    definedEntities.put("&nvlt;", "\u003C\u20D2");
2912    definedEntities.put("&nvltrie;", "\u22B4\u20D2");
2913    definedEntities.put("&nvrArr;", "\u2903");
2914    definedEntities.put("&nvrtrie;", "\u22B5\u20D2");
2915    definedEntities.put("&nvsim;", "\u223C\u20D2");
2916    definedEntities.put("&nwArr;", "\u21D6");
2917    definedEntities.put("&nwarhk;", "\u2923");
2918    definedEntities.put("&nwarr;", "\u2196");
2919    definedEntities.put("&nwarrow;", "\u2196");
2920    definedEntities.put("&nwnear;", "\u2927");
2921    definedEntities.put("&oS;", "\u24C8");
2922    definedEntities.put("&oacute;", "\u00F3");
2923    definedEntities.put("&oast;", "\u229B");
2924    definedEntities.put("&ocir;", "\u229A");
2925    definedEntities.put("&ocirc;", "\u00F4");
2926    definedEntities.put("&ocy;", "\u043E");
2927    definedEntities.put("&odash;", "\u229D");
2928    definedEntities.put("&odblac;", "\u0151");
2929    definedEntities.put("&odiv;", "\u2A38");
2930    definedEntities.put("&odot;", "\u2299");
2931    definedEntities.put("&odsold;", "\u29BC");
2932    definedEntities.put("&oelig;", "\u0153");
2933    definedEntities.put("&ofcir;", "\u29BF");
2934    definedEntities.put("&ofr;", "\uD835\uDD2C");
2935    definedEntities.put("&ogon;", "\u02DB");
2936    definedEntities.put("&ograve;", "\u00F2");
2937    definedEntities.put("&ogt;", "\u29C1");
2938    definedEntities.put("&ohbar;", "\u29B5");
2939    definedEntities.put("&ohm;", "\u03A9");
2940    definedEntities.put("&oint;", "\u222E");
2941    definedEntities.put("&olarr;", "\u21BA");
2942    definedEntities.put("&olcir;", "\u29BE");
2943    definedEntities.put("&olcross;", "\u29BB");
2944    definedEntities.put("&oline;", "\u203E");
2945    definedEntities.put("&olt;", "\u29C0");
2946    definedEntities.put("&omacr;", "\u014D");
2947    definedEntities.put("&omega;", "\u03C9");
2948    definedEntities.put("&omicron;", "\u03BF");
2949    definedEntities.put("&omid;", "\u29B6");
2950    definedEntities.put("&ominus;", "\u2296");
2951    definedEntities.put("&oopf;", "\uD835\uDD60");
2952    definedEntities.put("&opar;", "\u29B7");
2953    definedEntities.put("&operp;", "\u29B9");
2954    definedEntities.put("&oplus;", "\u2295");
2955    definedEntities.put("&or;", "\u2228");
2956    definedEntities.put("&orarr;", "\u21BB");
2957    definedEntities.put("&ord;", "\u2A5D");
2958    definedEntities.put("&order;", "\u2134");
2959    definedEntities.put("&orderof;", "\u2134");
2960    definedEntities.put("&ordf;", "\u00AA");
2961    definedEntities.put("&ordm;", "\u00BA");
2962    definedEntities.put("&origof;", "\u22B6");
2963    definedEntities.put("&oror;", "\u2A56");
2964    definedEntities.put("&orslope;", "\u2A57");
2965    definedEntities.put("&orv;", "\u2A5B");
2966    definedEntities.put("&oscr;", "\u2134");
2967    definedEntities.put("&oslash;", "\u00F8");
2968    definedEntities.put("&osol;", "\u2298");
2969    definedEntities.put("&otilde;", "\u00F5");
2970    definedEntities.put("&otimes;", "\u2297");
2971    definedEntities.put("&otimesas;", "\u2A36");
2972    definedEntities.put("&ouml;", "\u00F6");
2973    definedEntities.put("&ovbar;", "\u233D");
2974    definedEntities.put("&par;", "\u2225");
2975    definedEntities.put("&para;", "\u00B6");
2976    definedEntities.put("&parallel;", "\u2225");
2977    definedEntities.put("&parsim;", "\u2AF3");
2978    definedEntities.put("&parsl;", "\u2AFD");
2979    definedEntities.put("&part;", "\u2202");
2980    definedEntities.put("&pcy;", "\u043F");
2981    definedEntities.put("&percnt;", "\u0025");
2982    definedEntities.put("&period;", "\u002E");
2983    definedEntities.put("&permil;", "\u2030");
2984    definedEntities.put("&perp;", "\u22A5");
2985    definedEntities.put("&pertenk;", "\u2031");
2986    definedEntities.put("&pfr;", "\uD835\uDD2D");
2987    definedEntities.put("&phi;", "\u03C6");
2988    definedEntities.put("&phiv;", "\u03D5");
2989    definedEntities.put("&phmmat;", "\u2133");
2990    definedEntities.put("&phone;", "\u260E");
2991    definedEntities.put("&pi;", "\u03C0");
2992    definedEntities.put("&pitchfork;", "\u22D4");
2993    definedEntities.put("&piv;", "\u03D6");
2994    definedEntities.put("&planck;", "\u210F");
2995    definedEntities.put("&planckh;", "\u210E");
2996    definedEntities.put("&plankv;", "\u210F");
2997    definedEntities.put("&plus;", "\u002B");
2998    definedEntities.put("&plusacir;", "\u2A23");
2999    definedEntities.put("&plusb;", "\u229E");
3000    definedEntities.put("&pluscir;", "\u2A22");
3001    definedEntities.put("&plusdo;", "\u2214");
3002    definedEntities.put("&plusdu;", "\u2A25");
3003    definedEntities.put("&pluse;", "\u2A72");
3004    definedEntities.put("&plusmn;", "\u00B1");
3005    definedEntities.put("&plussim;", "\u2A26");
3006    definedEntities.put("&plustwo;", "\u2A27");
3007    definedEntities.put("&pm;", "\u00B1");
3008    definedEntities.put("&pointint;", "\u2A15");
3009    definedEntities.put("&popf;", "\uD835\uDD61");
3010    definedEntities.put("&pound;", "\u00A3");
3011    definedEntities.put("&pr;", "\u227A");
3012    definedEntities.put("&prE;", "\u2AB3");
3013    definedEntities.put("&prap;", "\u2AB7");
3014    definedEntities.put("&prcue;", "\u227C");
3015    definedEntities.put("&pre;", "\u2AAF");
3016    definedEntities.put("&prec;", "\u227A");
3017    definedEntities.put("&precapprox;", "\u2AB7");
3018    definedEntities.put("&preccurlyeq;", "\u227C");
3019    definedEntities.put("&preceq;", "\u2AAF");
3020    definedEntities.put("&precnapprox;", "\u2AB9");
3021    definedEntities.put("&precneqq;", "\u2AB5");
3022    definedEntities.put("&precnsim;", "\u22E8");
3023    definedEntities.put("&precsim;", "\u227E");
3024    definedEntities.put("&prime;", "\u2032");
3025    definedEntities.put("&primes;", "\u2119");
3026    definedEntities.put("&prnE;", "\u2AB5");
3027    definedEntities.put("&prnap;", "\u2AB9");
3028    definedEntities.put("&prnsim;", "\u22E8");
3029    definedEntities.put("&prod;", "\u220F");
3030    definedEntities.put("&profalar;", "\u232E");
3031    definedEntities.put("&profline;", "\u2312");
3032    definedEntities.put("&profsurf;", "\u2313");
3033    definedEntities.put("&prop;", "\u221D");
3034    definedEntities.put("&propto;", "\u221D");
3035    definedEntities.put("&prsim;", "\u227E");
3036    definedEntities.put("&prurel;", "\u22B0");
3037    definedEntities.put("&pscr;", "\uD835\uDCC5");
3038    definedEntities.put("&psi;", "\u03C8");
3039    definedEntities.put("&puncsp;", "\u2008");
3040    definedEntities.put("&qfr;", "\uD835\uDD2E");
3041    definedEntities.put("&qint;", "\u2A0C");
3042    definedEntities.put("&qopf;", "\uD835\uDD62");
3043    definedEntities.put("&qprime;", "\u2057");
3044    definedEntities.put("&qscr;", "\uD835\uDCC6");
3045    definedEntities.put("&quaternions;", "\u210D");
3046    definedEntities.put("&quatint;", "\u2A16");
3047    definedEntities.put("&quest;", "\u003F");
3048    definedEntities.put("&questeq;", "\u225F");
3049//    definedEntities.put("&quot;", "\\u0022");
3050    definedEntities.put("&rAarr;", "\u21DB");
3051    definedEntities.put("&rArr;", "\u21D2");
3052    definedEntities.put("&rAtail;", "\u291C");
3053    definedEntities.put("&rBarr;", "\u290F");
3054    definedEntities.put("&rHar;", "\u2964");
3055    definedEntities.put("&race;", "\u223D\u0331");
3056    definedEntities.put("&racute;", "\u0155");
3057    definedEntities.put("&radic;", "\u221A");
3058    definedEntities.put("&raemptyv;", "\u29B3");
3059    definedEntities.put("&rang;", "\u27E9");
3060    definedEntities.put("&rangd;", "\u2992");
3061    definedEntities.put("&range;", "\u29A5");
3062    definedEntities.put("&rangle;", "\u27E9");
3063    definedEntities.put("&raquo;", "\u00BB");
3064    definedEntities.put("&rarr;", "\u2192");
3065    definedEntities.put("&rarrap;", "\u2975");
3066    definedEntities.put("&rarrb;", "\u21E5");
3067    definedEntities.put("&rarrbfs;", "\u2920");
3068    definedEntities.put("&rarrc;", "\u2933");
3069    definedEntities.put("&rarrfs;", "\u291E");
3070    definedEntities.put("&rarrhk;", "\u21AA");
3071    definedEntities.put("&rarrlp;", "\u21AC");
3072    definedEntities.put("&rarrpl;", "\u2945");
3073    definedEntities.put("&rarrsim;", "\u2974");
3074    definedEntities.put("&rarrtl;", "\u21A3");
3075    definedEntities.put("&rarrw;", "\u219D");
3076    definedEntities.put("&ratail;", "\u291A");
3077    definedEntities.put("&ratio;", "\u2236");
3078    definedEntities.put("&rationals;", "\u211A");
3079    definedEntities.put("&rbarr;", "\u290D");
3080    definedEntities.put("&rbbrk;", "\u2773");
3081    definedEntities.put("&rbrace;", "\u007D");
3082    definedEntities.put("&rbrack;", "\u005D");
3083    definedEntities.put("&rbrke;", "\u298C");
3084    definedEntities.put("&rbrksld;", "\u298E");
3085    definedEntities.put("&rbrkslu;", "\u2990");
3086    definedEntities.put("&rcaron;", "\u0159");
3087    definedEntities.put("&rcedil;", "\u0157");
3088    definedEntities.put("&rceil;", "\u2309");
3089    definedEntities.put("&rcub;", "\u007D");
3090    definedEntities.put("&rcy;", "\u0440");
3091    definedEntities.put("&rdca;", "\u2937");
3092    definedEntities.put("&rdldhar;", "\u2969");
3093    definedEntities.put("&rdquo;", "\u201D");
3094    definedEntities.put("&rdquor;", "\u201D");
3095    definedEntities.put("&rdsh;", "\u21B3");
3096    definedEntities.put("&real;", "\u211C");
3097    definedEntities.put("&realine;", "\u211B");
3098    definedEntities.put("&realpart;", "\u211C");
3099    definedEntities.put("&reals;", "\u211D");
3100    definedEntities.put("&rect;", "\u25AD");
3101    definedEntities.put("&reg;", "\u00AE");
3102    definedEntities.put("&rfisht;", "\u297D");
3103    definedEntities.put("&rfloor;", "\u230B");
3104    definedEntities.put("&rfr;", "\uD835\uDD2F");
3105    definedEntities.put("&rhard;", "\u21C1");
3106    definedEntities.put("&rharu;", "\u21C0");
3107    definedEntities.put("&rharul;", "\u296C");
3108    definedEntities.put("&rho;", "\u03C1");
3109    definedEntities.put("&rhov;", "\u03F1");
3110    definedEntities.put("&rightarrow;", "\u2192");
3111    definedEntities.put("&rightarrowtail;", "\u21A3");
3112    definedEntities.put("&rightharpoondown;", "\u21C1");
3113    definedEntities.put("&rightharpoonup;", "\u21C0");
3114    definedEntities.put("&rightleftarrows;", "\u21C4");
3115    definedEntities.put("&rightleftharpoons;", "\u21CC");
3116    definedEntities.put("&rightrightarrows;", "\u21C9");
3117    definedEntities.put("&rightsquigarrow;", "\u219D");
3118    definedEntities.put("&rightthreetimes;", "\u22CC");
3119    definedEntities.put("&ring;", "\u02DA");
3120    definedEntities.put("&risingdotseq;", "\u2253");
3121    definedEntities.put("&rlarr;", "\u21C4");
3122    definedEntities.put("&rlhar;", "\u21CC");
3123    definedEntities.put("&rlm;", "\u200F");
3124    definedEntities.put("&rmoust;", "\u23B1");
3125    definedEntities.put("&rmoustache;", "\u23B1");
3126    definedEntities.put("&rnmid;", "\u2AEE");
3127    definedEntities.put("&roang;", "\u27ED");
3128    definedEntities.put("&roarr;", "\u21FE");
3129    definedEntities.put("&robrk;", "\u27E7");
3130    definedEntities.put("&ropar;", "\u2986");
3131    definedEntities.put("&ropf;", "\uD835\uDD63");
3132    definedEntities.put("&roplus;", "\u2A2E");
3133    definedEntities.put("&rotimes;", "\u2A35");
3134    definedEntities.put("&rpar;", "\u0029");
3135    definedEntities.put("&rpargt;", "\u2994");
3136    definedEntities.put("&rppolint;", "\u2A12");
3137    definedEntities.put("&rrarr;", "\u21C9");
3138    definedEntities.put("&rsaquo;", "\u203A");
3139    definedEntities.put("&rscr;", "\uD835\uDCC7");
3140    definedEntities.put("&rsh;", "\u21B1");
3141    definedEntities.put("&rsqb;", "\u005D");
3142    definedEntities.put("&rsquo;", "\u2019");
3143    definedEntities.put("&rsquor;", "\u2019");
3144    definedEntities.put("&rthree;", "\u22CC");
3145    definedEntities.put("&rtimes;", "\u22CA");
3146    definedEntities.put("&rtri;", "\u25B9");
3147    definedEntities.put("&rtrie;", "\u22B5");
3148    definedEntities.put("&rtrif;", "\u25B8");
3149    definedEntities.put("&rtriltri;", "\u29CE");
3150    definedEntities.put("&ruluhar;", "\u2968");
3151    definedEntities.put("&rx;", "\u211E");
3152    definedEntities.put("&sacute;", "\u015B");
3153    definedEntities.put("&sbquo;", "\u201A");
3154    definedEntities.put("&sc;", "\u227B");
3155    definedEntities.put("&scE;", "\u2AB4");
3156    definedEntities.put("&scap;", "\u2AB8");
3157    definedEntities.put("&scaron;", "\u0161");
3158    definedEntities.put("&sccue;", "\u227D");
3159    definedEntities.put("&sce;", "\u2AB0");
3160    definedEntities.put("&scedil;", "\u015F");
3161    definedEntities.put("&scirc;", "\u015D");
3162    definedEntities.put("&scnE;", "\u2AB6");
3163    definedEntities.put("&scnap;", "\u2ABA");
3164    definedEntities.put("&scnsim;", "\u22E9");
3165    definedEntities.put("&scpolint;", "\u2A13");
3166    definedEntities.put("&scsim;", "\u227F");
3167    definedEntities.put("&scy;", "\u0441");
3168    definedEntities.put("&sdot;", "\u22C5");
3169    definedEntities.put("&sdotb;", "\u22A1");
3170    definedEntities.put("&sdote;", "\u2A66");
3171    definedEntities.put("&seArr;", "\u21D8");
3172    definedEntities.put("&searhk;", "\u2925");
3173    definedEntities.put("&searr;", "\u2198");
3174    definedEntities.put("&searrow;", "\u2198");
3175    definedEntities.put("&sect;", "\u00A7");
3176    definedEntities.put("&semi;", "\u003B");
3177    definedEntities.put("&seswar;", "\u2929");
3178    definedEntities.put("&setminus;", "\u2216");
3179    definedEntities.put("&setmn;", "\u2216");
3180    definedEntities.put("&sext;", "\u2736");
3181    definedEntities.put("&sfr;", "\uD835\uDD30");
3182    definedEntities.put("&sfrown;", "\u2322");
3183    definedEntities.put("&sharp;", "\u266F");
3184    definedEntities.put("&shchcy;", "\u0449");
3185    definedEntities.put("&shcy;", "\u0448");
3186    definedEntities.put("&shortmid;", "\u2223");
3187    definedEntities.put("&shortparallel;", "\u2225");
3188    definedEntities.put("&shy;", "\u00AD");
3189    definedEntities.put("&sigma;", "\u03C3");
3190    definedEntities.put("&sigmaf;", "\u03C2");
3191    definedEntities.put("&sigmav;", "\u03C2");
3192    definedEntities.put("&sim;", "\u223C");
3193    definedEntities.put("&simdot;", "\u2A6A");
3194    definedEntities.put("&sime;", "\u2243");
3195    definedEntities.put("&simeq;", "\u2243");
3196    definedEntities.put("&simg;", "\u2A9E");
3197    definedEntities.put("&simgE;", "\u2AA0");
3198    definedEntities.put("&siml;", "\u2A9D");
3199    definedEntities.put("&simlE;", "\u2A9F");
3200    definedEntities.put("&simne;", "\u2246");
3201    definedEntities.put("&simplus;", "\u2A24");
3202    definedEntities.put("&simrarr;", "\u2972");
3203    definedEntities.put("&slarr;", "\u2190");
3204    definedEntities.put("&smallsetminus;", "\u2216");
3205    definedEntities.put("&smashp;", "\u2A33");
3206    definedEntities.put("&smeparsl;", "\u29E4");
3207    definedEntities.put("&smid;", "\u2223");
3208    definedEntities.put("&smile;", "\u2323");
3209    definedEntities.put("&smt;", "\u2AAA");
3210    definedEntities.put("&smte;", "\u2AAC");
3211    definedEntities.put("&smtes;", "\u2AAC\uFE00");
3212    definedEntities.put("&softcy;", "\u044C");
3213    definedEntities.put("&sol;", "\u002F");
3214    definedEntities.put("&solb;", "\u29C4");
3215    definedEntities.put("&solbar;", "\u233F");
3216    definedEntities.put("&sopf;", "\uD835\uDD64");
3217    definedEntities.put("&spades;", "\u2660");
3218    definedEntities.put("&spadesuit;", "\u2660");
3219    definedEntities.put("&spar;", "\u2225");
3220    definedEntities.put("&sqcap;", "\u2293");
3221    definedEntities.put("&sqcaps;", "\u2293\uFE00");
3222    definedEntities.put("&sqcup;", "\u2294");
3223    definedEntities.put("&sqcups;", "\u2294\uFE00");
3224    definedEntities.put("&sqsub;", "\u228F");
3225    definedEntities.put("&sqsube;", "\u2291");
3226    definedEntities.put("&sqsubset;", "\u228F");
3227    definedEntities.put("&sqsubseteq;", "\u2291");
3228    definedEntities.put("&sqsup;", "\u2290");
3229    definedEntities.put("&sqsupe;", "\u2292");
3230    definedEntities.put("&sqsupset;", "\u2290");
3231    definedEntities.put("&sqsupseteq;", "\u2292");
3232    definedEntities.put("&squ;", "\u25A1");
3233    definedEntities.put("&square;", "\u25A1");
3234    definedEntities.put("&squarf;", "\u25AA");
3235    definedEntities.put("&squf;", "\u25AA");
3236    definedEntities.put("&srarr;", "\u2192");
3237    definedEntities.put("&sscr;", "\uD835\uDCC8");
3238    definedEntities.put("&ssetmn;", "\u2216");
3239    definedEntities.put("&ssmile;", "\u2323");
3240    definedEntities.put("&sstarf;", "\u22C6");
3241    definedEntities.put("&star;", "\u2606");
3242    definedEntities.put("&starf;", "\u2605");
3243    definedEntities.put("&straightepsilon;", "\u03F5");
3244    definedEntities.put("&straightphi;", "\u03D5");
3245    definedEntities.put("&strns;", "\u00AF");
3246    definedEntities.put("&sub;", "\u2282");
3247    definedEntities.put("&subE;", "\u2AC5");
3248    definedEntities.put("&subdot;", "\u2ABD");
3249    definedEntities.put("&sube;", "\u2286");
3250    definedEntities.put("&subedot;", "\u2AC3");
3251    definedEntities.put("&submult;", "\u2AC1");
3252    definedEntities.put("&subnE;", "\u2ACB");
3253    definedEntities.put("&subne;", "\u228A");
3254    definedEntities.put("&subplus;", "\u2ABF");
3255    definedEntities.put("&subrarr;", "\u2979");
3256    definedEntities.put("&subset;", "\u2282");
3257    definedEntities.put("&subseteq;", "\u2286");
3258    definedEntities.put("&subseteqq;", "\u2AC5");
3259    definedEntities.put("&subsetneq;", "\u228A");
3260    definedEntities.put("&subsetneqq;", "\u2ACB");
3261    definedEntities.put("&subsim;", "\u2AC7");
3262    definedEntities.put("&subsub;", "\u2AD5");
3263    definedEntities.put("&subsup;", "\u2AD3");
3264    definedEntities.put("&succ;", "\u227B");
3265    definedEntities.put("&succapprox;", "\u2AB8");
3266    definedEntities.put("&succcurlyeq;", "\u227D");
3267    definedEntities.put("&succeq;", "\u2AB0");
3268    definedEntities.put("&succnapprox;", "\u2ABA");
3269    definedEntities.put("&succneqq;", "\u2AB6");
3270    definedEntities.put("&succnsim;", "\u22E9");
3271    definedEntities.put("&succsim;", "\u227F");
3272    definedEntities.put("&sum;", "\u2211");
3273    definedEntities.put("&sung;", "\u266A");
3274    definedEntities.put("&sup1;", "\u00B9");
3275    definedEntities.put("&sup2;", "\u00B2");
3276    definedEntities.put("&sup3;", "\u00B3");
3277    definedEntities.put("&sup;", "\u2283");
3278    definedEntities.put("&supE;", "\u2AC6");
3279    definedEntities.put("&supdot;", "\u2ABE");
3280    definedEntities.put("&supdsub;", "\u2AD8");
3281    definedEntities.put("&supe;", "\u2287");
3282    definedEntities.put("&supedot;", "\u2AC4");
3283    definedEntities.put("&suphsol;", "\u27C9");
3284    definedEntities.put("&suphsub;", "\u2AD7");
3285    definedEntities.put("&suplarr;", "\u297B");
3286    definedEntities.put("&supmult;", "\u2AC2");
3287    definedEntities.put("&supnE;", "\u2ACC");
3288    definedEntities.put("&supne;", "\u228B");
3289    definedEntities.put("&supplus;", "\u2AC0");
3290    definedEntities.put("&supset;", "\u2283");
3291    definedEntities.put("&supseteq;", "\u2287");
3292    definedEntities.put("&supseteqq;", "\u2AC6");
3293    definedEntities.put("&supsetneq;", "\u228B");
3294    definedEntities.put("&supsetneqq;", "\u2ACC");
3295    definedEntities.put("&supsim;", "\u2AC8");
3296    definedEntities.put("&supsub;", "\u2AD4");
3297    definedEntities.put("&supsup;", "\u2AD6");
3298    definedEntities.put("&swArr;", "\u21D9");
3299    definedEntities.put("&swarhk;", "\u2926");
3300    definedEntities.put("&swarr;", "\u2199");
3301    definedEntities.put("&swarrow;", "\u2199");
3302    definedEntities.put("&swnwar;", "\u292A");
3303    definedEntities.put("&szlig;", "\u00DF");
3304    definedEntities.put("&target;", "\u2316");
3305    definedEntities.put("&tau;", "\u03C4");
3306    definedEntities.put("&tbrk;", "\u23B4");
3307    definedEntities.put("&tcaron;", "\u0165");
3308    definedEntities.put("&tcedil;", "\u0163");
3309    definedEntities.put("&tcy;", "\u0442");
3310    definedEntities.put("&tdot;", "\u20DB");
3311    definedEntities.put("&telrec;", "\u2315");
3312    definedEntities.put("&tfr;", "\uD835\uDD31");
3313    definedEntities.put("&there4;", "\u2234");
3314    definedEntities.put("&therefore;", "\u2234");
3315    definedEntities.put("&theta;", "\u03B8");
3316    definedEntities.put("&thetasym;", "\u03D1");
3317    definedEntities.put("&thetav;", "\u03D1");
3318    definedEntities.put("&thickapprox;", "\u2248");
3319    definedEntities.put("&thicksim;", "\u223C");
3320    definedEntities.put("&thinsp;", "\u2009");
3321    definedEntities.put("&thkap;", "\u2248");
3322    definedEntities.put("&thksim;", "\u223C");
3323    definedEntities.put("&thorn;", "\u00FE");
3324    definedEntities.put("&tilde;", "\u02DC");
3325    definedEntities.put("&times;", "\u00D7");
3326    definedEntities.put("&timesb;", "\u22A0");
3327    definedEntities.put("&timesbar;", "\u2A31");
3328    definedEntities.put("&timesd;", "\u2A30");
3329    definedEntities.put("&tint;", "\u222D");
3330    definedEntities.put("&toea;", "\u2928");
3331    definedEntities.put("&top;", "\u22A4");
3332    definedEntities.put("&topbot;", "\u2336");
3333    definedEntities.put("&topcir;", "\u2AF1");
3334    definedEntities.put("&topf;", "\uD835\uDD65");
3335    definedEntities.put("&topfork;", "\u2ADA");
3336    definedEntities.put("&tosa;", "\u2929");
3337    definedEntities.put("&tprime;", "\u2034");
3338    definedEntities.put("&trade;", "\u2122");
3339    definedEntities.put("&triangle;", "\u25B5");
3340    definedEntities.put("&triangledown;", "\u25BF");
3341    definedEntities.put("&triangleleft;", "\u25C3");
3342    definedEntities.put("&trianglelefteq;", "\u22B4");
3343    definedEntities.put("&triangleq;", "\u225C");
3344    definedEntities.put("&triangleright;", "\u25B9");
3345    definedEntities.put("&trianglerighteq;", "\u22B5");
3346    definedEntities.put("&tridot;", "\u25EC");
3347    definedEntities.put("&trie;", "\u225C");
3348    definedEntities.put("&triminus;", "\u2A3A");
3349    definedEntities.put("&triplus;", "\u2A39");
3350    definedEntities.put("&trisb;", "\u29CD");
3351    definedEntities.put("&tritime;", "\u2A3B");
3352    definedEntities.put("&trpezium;", "\u23E2");
3353    definedEntities.put("&tscr;", "\uD835\uDCC9");
3354    definedEntities.put("&tscy;", "\u0446");
3355    definedEntities.put("&tshcy;", "\u045B");
3356    definedEntities.put("&tstrok;", "\u0167");
3357    definedEntities.put("&twixt;", "\u226C");
3358    definedEntities.put("&twoheadleftarrow;", "\u219E");
3359    definedEntities.put("&twoheadrightarrow;", "\u21A0");
3360    definedEntities.put("&uArr;", "\u21D1");
3361    definedEntities.put("&uHar;", "\u2963");
3362    definedEntities.put("&uacute;", "\u00FA");
3363    definedEntities.put("&uarr;", "\u2191");
3364    definedEntities.put("&ubrcy;", "\u045E");
3365    definedEntities.put("&ubreve;", "\u016D");
3366    definedEntities.put("&ucirc;", "\u00FB");
3367    definedEntities.put("&ucy;", "\u0443");
3368    definedEntities.put("&udarr;", "\u21C5");
3369    definedEntities.put("&udblac;", "\u0171");
3370    definedEntities.put("&udhar;", "\u296E");
3371    definedEntities.put("&ufisht;", "\u297E");
3372    definedEntities.put("&ufr;", "\uD835\uDD32");
3373    definedEntities.put("&ugrave;", "\u00F9");
3374    definedEntities.put("&uharl;", "\u21BF");
3375    definedEntities.put("&uharr;", "\u21BE");
3376    definedEntities.put("&uhblk;", "\u2580");
3377    definedEntities.put("&ulcorn;", "\u231C");
3378    definedEntities.put("&ulcorner;", "\u231C");
3379    definedEntities.put("&ulcrop;", "\u230F");
3380    definedEntities.put("&ultri;", "\u25F8");
3381    definedEntities.put("&umacr;", "\u016B");
3382    definedEntities.put("&uml;", "\u00A8");
3383    definedEntities.put("&uogon;", "\u0173");
3384    definedEntities.put("&uopf;", "\uD835\uDD66");
3385    definedEntities.put("&uparrow;", "\u2191");
3386    definedEntities.put("&updownarrow;", "\u2195");
3387    definedEntities.put("&upharpoonleft;", "\u21BF");
3388    definedEntities.put("&upharpoonright;", "\u21BE");
3389    definedEntities.put("&uplus;", "\u228E");
3390    definedEntities.put("&upsi;", "\u03C5");
3391    definedEntities.put("&upsih;", "\u03D2");
3392    definedEntities.put("&upsilon;", "\u03C5");
3393    definedEntities.put("&upuparrows;", "\u21C8");
3394    definedEntities.put("&urcorn;", "\u231D");
3395    definedEntities.put("&urcorner;", "\u231D");
3396    definedEntities.put("&urcrop;", "\u230E");
3397    definedEntities.put("&uring;", "\u016F");
3398    definedEntities.put("&urtri;", "\u25F9");
3399    definedEntities.put("&uscr;", "\uD835\uDCCA");
3400    definedEntities.put("&utdot;", "\u22F0");
3401    definedEntities.put("&utilde;", "\u0169");
3402    definedEntities.put("&utri;", "\u25B5");
3403    definedEntities.put("&utrif;", "\u25B4");
3404    definedEntities.put("&uuarr;", "\u21C8");
3405    definedEntities.put("&uuml;", "\u00FC");
3406    definedEntities.put("&uwangle;", "\u29A7");
3407    definedEntities.put("&vArr;", "\u21D5");
3408    definedEntities.put("&vBar;", "\u2AE8");
3409    definedEntities.put("&vBarv;", "\u2AE9");
3410    definedEntities.put("&vDash;", "\u22A8");
3411    definedEntities.put("&vangrt;", "\u299C");
3412    definedEntities.put("&varepsilon;", "\u03F5");
3413    definedEntities.put("&varkappa;", "\u03F0");
3414    definedEntities.put("&varnothing;", "\u2205");
3415    definedEntities.put("&varphi;", "\u03D5");
3416    definedEntities.put("&varpi;", "\u03D6");
3417    definedEntities.put("&varpropto;", "\u221D");
3418    definedEntities.put("&varr;", "\u2195");
3419    definedEntities.put("&varrho;", "\u03F1");
3420    definedEntities.put("&varsigma;", "\u03C2");
3421    definedEntities.put("&varsubsetneq;", "\u228A\uFE00");
3422    definedEntities.put("&varsubsetneqq;", "\u2ACB\uFE00");
3423    definedEntities.put("&varsupsetneq;", "\u228B\uFE00");
3424    definedEntities.put("&varsupsetneqq;", "\u2ACC\uFE00");
3425    definedEntities.put("&vartheta;", "\u03D1");
3426    definedEntities.put("&vartriangleleft;", "\u22B2");
3427    definedEntities.put("&vartriangleright;", "\u22B3");
3428    definedEntities.put("&vcy;", "\u0432");
3429    definedEntities.put("&vdash;", "\u22A2");
3430    definedEntities.put("&vee;", "\u2228");
3431    definedEntities.put("&veebar;", "\u22BB");
3432    definedEntities.put("&veeeq;", "\u225A");
3433    definedEntities.put("&vellip;", "\u22EE");
3434    definedEntities.put("&verbar;", "\u007C");
3435    definedEntities.put("&vert;", "\u007C");
3436    definedEntities.put("&vfr;", "\uD835\uDD33");
3437    definedEntities.put("&vltri;", "\u22B2");
3438    definedEntities.put("&vnsub;", "\u2282\u20D2");
3439    definedEntities.put("&vnsup;", "\u2283\u20D2");
3440    definedEntities.put("&vopf;", "\uD835\uDD67");
3441    definedEntities.put("&vprop;", "\u221D");
3442    definedEntities.put("&vrtri;", "\u22B3");
3443    definedEntities.put("&vscr;", "\uD835\uDCCB");
3444    definedEntities.put("&vsubnE;", "\u2ACB\uFE00");
3445    definedEntities.put("&vsubne;", "\u228A\uFE00");
3446    definedEntities.put("&vsupnE;", "\u2ACC\uFE00");
3447    definedEntities.put("&vsupne;", "\u228B\uFE00");
3448    definedEntities.put("&vzigzag;", "\u299A");
3449    definedEntities.put("&wcirc;", "\u0175");
3450    definedEntities.put("&wedbar;", "\u2A5F");
3451    definedEntities.put("&wedge;", "\u2227");
3452    definedEntities.put("&wedgeq;", "\u2259");
3453    definedEntities.put("&weierp;", "\u2118");
3454    definedEntities.put("&wfr;", "\uD835\uDD34");
3455    definedEntities.put("&wopf;", "\uD835\uDD68");
3456    definedEntities.put("&wp;", "\u2118");
3457    definedEntities.put("&wr;", "\u2240");
3458    definedEntities.put("&wreath;", "\u2240");
3459    definedEntities.put("&wscr;", "\uD835\uDCCC");
3460    definedEntities.put("&xcap;", "\u22C2");
3461    definedEntities.put("&xcirc;", "\u25EF");
3462    definedEntities.put("&xcup;", "\u22C3");
3463    definedEntities.put("&xdtri;", "\u25BD");
3464    definedEntities.put("&xfr;", "\uD835\uDD35");
3465    definedEntities.put("&xhArr;", "\u27FA");
3466    definedEntities.put("&xharr;", "\u27F7");
3467    definedEntities.put("&xi;", "\u03BE");
3468    definedEntities.put("&xlArr;", "\u27F8");
3469    definedEntities.put("&xlarr;", "\u27F5");
3470    definedEntities.put("&xmap;", "\u27FC");
3471    definedEntities.put("&xnis;", "\u22FB");
3472    definedEntities.put("&xodot;", "\u2A00");
3473    definedEntities.put("&xopf;", "\uD835\uDD69");
3474    definedEntities.put("&xoplus;", "\u2A01");
3475    definedEntities.put("&xotime;", "\u2A02");
3476    definedEntities.put("&xrArr;", "\u27F9");
3477    definedEntities.put("&xrarr;", "\u27F6");
3478    definedEntities.put("&xscr;", "\uD835\uDCCD");
3479    definedEntities.put("&xsqcup;", "\u2A06");
3480    definedEntities.put("&xuplus;", "\u2A04");
3481    definedEntities.put("&xutri;", "\u25B3");
3482    definedEntities.put("&xvee;", "\u22C1");
3483    definedEntities.put("&xwedge;", "\u22C0");
3484    definedEntities.put("&yacute;", "\u00FD");
3485    definedEntities.put("&yacy;", "\u044F");
3486    definedEntities.put("&ycirc;", "\u0177");
3487    definedEntities.put("&ycy;", "\u044B");
3488    definedEntities.put("&yen;", "\u00A5");
3489    definedEntities.put("&yfr;", "\uD835\uDD36");
3490    definedEntities.put("&yicy;", "\u0457");
3491    definedEntities.put("&yopf;", "\uD835\uDD6A");
3492    definedEntities.put("&yscr;", "\uD835\uDCCE");
3493    definedEntities.put("&yucy;", "\u044E");
3494    definedEntities.put("&yuml;", "\u00FF");
3495    definedEntities.put("&zacute;", "\u017A");
3496    definedEntities.put("&zcaron;", "\u017E");
3497    definedEntities.put("&zcy;", "\u0437");
3498    definedEntities.put("&zdot;", "\u017C");
3499    definedEntities.put("&zeetrf;", "\u2128");
3500    definedEntities.put("&zeta;", "\u03B6");
3501    definedEntities.put("&zfr;", "\uD835\uDD37");
3502    definedEntities.put("&zhcy;", "\u0436");
3503    definedEntities.put("&zigrarr;", "\u21DD");
3504    definedEntities.put("&zopf;", "\uD835\uDD6B");
3505    definedEntities.put("&zscr;", "\uD835\uDCCF");
3506    definedEntities.put("&zwj;", "\u200D");
3507    definedEntities.put("&zwnj;", "\u200C");
3508  }
3509
3510}