Adding upstream version 4:24.2.0.upstream/4%24.2.0

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

12 files changed, 11680 insertions, 0 deletions

diff --git a/starmath/source/mathml/attribute.cxx b/starmath/source/mathml/attribute.cxx
new file mode 100644
index 0000000000..ca4a86290d
--- /dev/null
+++ b/starmath/source/mathml/attribute.cxx
@@ -0,0 +1,479 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4; fill-column: 100 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ */
+
+#include <mathml/attribute.hxx>
+
+void SmMlAttribute::clearPreviousAttributeValue()
+{
+    switch (m_aSmMlAttributeValueType)
+    {
+        case SmMlAttributeValueType::NMlEmpty:
+            break;
+        case SmMlAttributeValueType::MlHref:
+            if (m_aAttributeValue.m_aHref.m_aLnk)
+                delete m_aAttributeValue.m_aHref.m_aLnk;
+            break;
+        case SmMlAttributeValueType::MlLspace:
+            if (m_aAttributeValue.m_aLspace.m_aLengthValue.m_aOriginalText)
+                delete m_aAttributeValue.m_aLspace.m_aLengthValue.m_aOriginalText;
+            break;
+        case SmMlAttributeValueType::MlMathsize:
+            if (m_aAttributeValue.m_aMathsize.m_aLengthValue.m_aOriginalText)
+                delete m_aAttributeValue.m_aMathsize.m_aLengthValue.m_aOriginalText;
+            break;
+        case SmMlAttributeValueType::MlMaxsize:
+            if (m_aAttributeValue.m_aMaxsize.m_aLengthValue.m_aOriginalText)
+                delete m_aAttributeValue.m_aMaxsize.m_aLengthValue.m_aOriginalText;
+            break;
+        case SmMlAttributeValueType::MlMinsize:
+            if (m_aAttributeValue.m_aMinsize.m_aLengthValue.m_aOriginalText)
+                delete m_aAttributeValue.m_aMinsize.m_aLengthValue.m_aOriginalText;
+            break;
+        case SmMlAttributeValueType::MlRspace:
+            if (m_aAttributeValue.m_aRspace.m_aLengthValue.m_aOriginalText)
+                delete m_aAttributeValue.m_aRspace.m_aLengthValue.m_aOriginalText;
+            break;
+        default:
+            break;
+    }
+}
+
+void SmMlAttribute::setDefaultAttributeValue()
+{
+    switch (m_aSmMlAttributeValueType)
+    {
+        case SmMlAttributeValueType::NMlEmpty:
+            break;
+        case SmMlAttributeValueType::MlAccent:
+            m_aAttributeValue.m_aAccent.m_aAccent = SmMlAttributeValueAccent::MlFalse;
+            break;
+        case SmMlAttributeValueType::MlDir:
+            m_aAttributeValue.m_aDir.m_aDir = SmMlAttributeValueDir::MlLtr;
+            break;
+        case SmMlAttributeValueType::MlDisplaystyle:
+            m_aAttributeValue.m_aDisplaystyle.m_aDisplaystyle
+                = SmMlAttributeValueDisplaystyle::MlFalse;
+            break;
+        case SmMlAttributeValueType::MlFence:
+            m_aAttributeValue.m_aFence.m_aFence = SmMlAttributeValueFence::MlFalse;
+            break;
+        case SmMlAttributeValueType::MlForm:
+            m_aAttributeValue.m_aForm.m_aForm = SmMlAttributeValueForm::MlInfix;
+            break;
+        case SmMlAttributeValueType::MlHref:
+            m_aAttributeValue.m_aHref.m_aHref = SmMlAttributeValueHref::NMlEmpty;
+            m_aAttributeValue.m_aHref.m_aLnk = new OUString(u""_ustr);
+            break;
+        case SmMlAttributeValueType::MlLspace:
+            m_aAttributeValue.m_aLspace.m_aLengthValue.m_aLengthUnit = SmLengthUnit::MlEm;
+            m_aAttributeValue.m_aLspace.m_aLengthValue.m_aLengthValue = 5.0 / 18;
+            m_aAttributeValue.m_aLspace.m_aLengthValue.m_aOriginalText
+                = new OUString(u"5/18em"_ustr);
+            break;
+        case SmMlAttributeValueType::MlMathbackground:
+            m_aAttributeValue.m_aMathbackground.m_aMathbackground
+                = SmMlAttributeValueMathbackground::MlTransparent;
+            break;
+        case SmMlAttributeValueType::MlMathcolor:
+            m_aAttributeValue.m_aMathcolor.m_aMathcolor = SmMlAttributeValueMathcolor::MlDefault;
+            break;
+        case SmMlAttributeValueType::MlMathsize:
+            m_aAttributeValue.m_aMathsize.m_aLengthValue.m_aLengthUnit = SmLengthUnit::MlP;
+            m_aAttributeValue.m_aMathsize.m_aLengthValue.m_aLengthValue = 100;
+            m_aAttributeValue.m_aMathsize.m_aLengthValue.m_aOriginalText
+                = new OUString(u"100%"_ustr);
+            break;
+        case SmMlAttributeValueType::MlMathvariant:
+            m_aAttributeValue.m_aMathvariant.m_aMathvariant = SmMlAttributeValueMathvariant::normal;
+            break;
+        case SmMlAttributeValueType::MlMaxsize:
+            m_aAttributeValue.m_aMaxsize.m_aMaxsize = SmMlAttributeValueMaxsize::MlInfinity;
+            m_aAttributeValue.m_aMaxsize.m_aLengthValue.m_aLengthUnit = SmLengthUnit::MlP;
+            m_aAttributeValue.m_aMaxsize.m_aLengthValue.m_aLengthValue = 10000;
+            m_aAttributeValue.m_aMaxsize.m_aLengthValue.m_aOriginalText
+                = new OUString(u"10000%"_ustr);
+            break;
+        case SmMlAttributeValueType::MlMinsize:
+            m_aAttributeValue.m_aMinsize.m_aLengthValue.m_aLengthUnit = SmLengthUnit::MlP;
+            m_aAttributeValue.m_aMinsize.m_aLengthValue.m_aLengthValue = 1;
+            m_aAttributeValue.m_aMinsize.m_aLengthValue.m_aOriginalText = new OUString(u"1%"_ustr);
+            break;
+        case SmMlAttributeValueType::MlMovablelimits:
+            m_aAttributeValue.m_aMovablelimits.m_aMovablelimits
+                = SmMlAttributeValueMovablelimits::MlFalse;
+            break;
+        case SmMlAttributeValueType::MlRspace:
+            m_aAttributeValue.m_aRspace.m_aLengthValue.m_aLengthUnit = SmLengthUnit::MlEm;
+            m_aAttributeValue.m_aRspace.m_aLengthValue.m_aLengthValue = 5.0 / 18;
+            m_aAttributeValue.m_aRspace.m_aLengthValue.m_aOriginalText
+                = new OUString(u"5/18em"_ustr);
+            break;
+        case SmMlAttributeValueType::MlSeparator:
+            m_aAttributeValue.m_aSeparator.m_aSeparator = SmMlAttributeValueSeparator::MlFalse;
+            break;
+        case SmMlAttributeValueType::MlStretchy:
+            m_aAttributeValue.m_aStretchy.m_aStretchy = SmMlAttributeValueStretchy::MlFalse;
+            break;
+        case SmMlAttributeValueType::MlSymmetric:
+            m_aAttributeValue.m_aSymmetric.m_aSymmetric = SmMlAttributeValueSymmetric::MlFalse;
+            break;
+    }
+}
+
+void SmMlAttribute::setAttributeValue(const SmMlAttribute* aAttribute)
+{
+    switch (aAttribute->getMlAttributeValueType())
+    {
+        case SmMlAttributeValueType::NMlEmpty:
+            clearPreviousAttributeValue();
+            m_aSmMlAttributeValueType = SmMlAttributeValueType::NMlEmpty;
+            break;
+        case SmMlAttributeValueType::MlAccent:
+            setMlAccent(aAttribute->getMlAccent());
+            break;
+        case SmMlAttributeValueType::MlDir:
+            setMlDir(aAttribute->getMlDir());
+            break;
+        case SmMlAttributeValueType::MlDisplaystyle:
+            setMlDisplaystyle(aAttribute->getMlDisplaystyle());
+            break;
+        case SmMlAttributeValueType::MlFence:
+            setMlFence(aAttribute->getMlFence());
+            break;
+        case SmMlAttributeValueType::MlForm:
+            setMlForm(aAttribute->getMlForm());
+            break;
+        case SmMlAttributeValueType::MlHref:
+            setMlHref(aAttribute->getMlHref());
+            break;
+        case SmMlAttributeValueType::MlLspace:
+            setMlLspace(aAttribute->getMlLspace());
+            break;
+        case SmMlAttributeValueType::MlMathbackground:
+            setMlMathbackground(aAttribute->getMlMathbackground());
+            break;
+        case SmMlAttributeValueType::MlMathcolor:
+            setMlMathcolor(aAttribute->getMlMathcolor());
+            break;
+        case SmMlAttributeValueType::MlMathsize:
+            setMlMathsize(aAttribute->getMlMathsize());
+            break;
+        case SmMlAttributeValueType::MlMathvariant:
+            setMlMathvariant(aAttribute->getMlMathvariant());
+            break;
+        case SmMlAttributeValueType::MlMaxsize:
+            setMlMaxsize(aAttribute->getMlMaxsize());
+            break;
+        case SmMlAttributeValueType::MlMinsize:
+            setMlMinsize(aAttribute->getMlMinsize());
+            break;
+        case SmMlAttributeValueType::MlMovablelimits:
+            setMlMovablelimits(aAttribute->getMlMovablelimits());
+            break;
+        case SmMlAttributeValueType::MlRspace:
+            setMlRspace(aAttribute->getMlRspace());
+            break;
+        case SmMlAttributeValueType::MlSeparator:
+            setMlSeparator(aAttribute->getMlSeparator());
+            break;
+        case SmMlAttributeValueType::MlStretchy:
+            setMlStretchy(aAttribute->getMlStretchy());
+            break;
+        case SmMlAttributeValueType::MlSymmetric:
+            setMlSymmetric(aAttribute->getMlSymmetric());
+            break;
+    }
+}
+
+/* get values */
+/*************************************************************************************************/
+
+const struct SmMlAccent* SmMlAttribute::getMlAccent() const
+{
+    if (m_aSmMlAttributeValueType == SmMlAttributeValueType::MlAccent)
+        return &m_aAttributeValue.m_aAccent;
+    return nullptr;
+}
+
+const struct SmMlDir* SmMlAttribute::getMlDir() const
+{
+    if (m_aSmMlAttributeValueType == SmMlAttributeValueType::MlDir)
+        return &m_aAttributeValue.m_aDir;
+    return nullptr;
+}
+
+const struct SmMlDisplaystyle* SmMlAttribute::getMlDisplaystyle() const
+{
+    if (m_aSmMlAttributeValueType == SmMlAttributeValueType::MlDisplaystyle)
+        return &m_aAttributeValue.m_aDisplaystyle;
+    return nullptr;
+}
+
+const struct SmMlFence* SmMlAttribute::getMlFence() const
+{
+    if (m_aSmMlAttributeValueType == SmMlAttributeValueType::MlFence)
+        return &m_aAttributeValue.m_aFence;
+    return nullptr;
+}
+
+const struct SmMlForm* SmMlAttribute::getMlForm() const
+{
+    if (m_aSmMlAttributeValueType == SmMlAttributeValueType::MlForm)
+        return &m_aAttributeValue.m_aForm;
+    return nullptr;
+}
+
+const struct SmMlHref* SmMlAttribute::getMlHref() const
+{
+    if (m_aSmMlAttributeValueType == SmMlAttributeValueType::MlHref)
+        return &m_aAttributeValue.m_aHref;
+    return nullptr;
+}
+
+const struct SmMlLspace* SmMlAttribute::getMlLspace() const
+{
+    if (m_aSmMlAttributeValueType == SmMlAttributeValueType::MlLspace)
+        return &m_aAttributeValue.m_aLspace;
+    return nullptr;
+}
+
+const struct SmMlMathbackground* SmMlAttribute::getMlMathbackground() const
+{
+    if (m_aSmMlAttributeValueType == SmMlAttributeValueType::MlMathbackground)
+        return &m_aAttributeValue.m_aMathbackground;
+    return nullptr;
+}
+
+const struct SmMlMathcolor* SmMlAttribute::getMlMathcolor() const
+{
+    if (m_aSmMlAttributeValueType == SmMlAttributeValueType::MlMathcolor)
+        return &m_aAttributeValue.m_aMathcolor;
+    return nullptr;
+}
+
+const struct SmMlMathsize* SmMlAttribute::getMlMathsize() const
+{
+    if (m_aSmMlAttributeValueType == SmMlAttributeValueType::MlAccent)
+        return &m_aAttributeValue.m_aMathsize;
+    return nullptr;
+}
+
+const struct SmMlMathvariant* SmMlAttribute::getMlMathvariant() const
+{
+    if (m_aSmMlAttributeValueType == SmMlAttributeValueType::MlMathvariant)
+        return &m_aAttributeValue.m_aMathvariant;
+    return nullptr;
+}
+
+const struct SmMlMaxsize* SmMlAttribute::getMlMaxsize() const
+{
+    if (m_aSmMlAttributeValueType == SmMlAttributeValueType::MlMaxsize)
+        return &m_aAttributeValue.m_aMaxsize;
+    return nullptr;
+}
+
+const struct SmMlMinsize* SmMlAttribute::getMlMinsize() const
+{
+    if (m_aSmMlAttributeValueType == SmMlAttributeValueType::MlMinsize)
+        return &m_aAttributeValue.m_aMinsize;
+    return nullptr;
+}
+
+const struct SmMlMovablelimits* SmMlAttribute::getMlMovablelimits() const
+{
+    if (m_aSmMlAttributeValueType == SmMlAttributeValueType::MlMovablelimits)
+        return &m_aAttributeValue.m_aMovablelimits;
+    return nullptr;
+}
+
+const struct SmMlRspace* SmMlAttribute::getMlRspace() const
+{
+    if (m_aSmMlAttributeValueType == SmMlAttributeValueType::MlRspace)
+        return &m_aAttributeValue.m_aRspace;
+    return nullptr;
+}
+
+const struct SmMlSeparator* SmMlAttribute::getMlSeparator() const
+{
+    if (m_aSmMlAttributeValueType == SmMlAttributeValueType::MlSeparator)
+        return &m_aAttributeValue.m_aSeparator;
+    return nullptr;
+}
+
+const struct SmMlStretchy* SmMlAttribute::getMlStretchy() const
+{
+    if (m_aSmMlAttributeValueType == SmMlAttributeValueType::MlStretchy)
+        return &m_aAttributeValue.m_aStretchy;
+    return nullptr;
+}
+
+const struct SmMlSymmetric* SmMlAttribute::getMlSymmetric() const
+{
+    if (m_aSmMlAttributeValueType == SmMlAttributeValueType::MlSymmetric)
+        return &m_aAttributeValue.m_aSymmetric;
+    return nullptr;
+}
+
+/* set values */
+/*************************************************************************************************/
+
+void SmMlAttribute::setMlAccent(const SmMlAccent* aAccent)
+{
+    m_bSet = true;
+    clearPreviousAttributeValue();
+    m_aAttributeValue.m_aAccent.m_aAccent = aAccent->m_aAccent;
+}
+
+void SmMlAttribute::setMlDir(const SmMlDir* aDir)
+{
+    m_bSet = true;
+    clearPreviousAttributeValue();
+    m_aAttributeValue.m_aDir.m_aDir = aDir->m_aDir;
+}
+
+void SmMlAttribute::setMlDisplaystyle(const SmMlDisplaystyle* aDisplaystyle)
+{
+    m_bSet = true;
+    clearPreviousAttributeValue();
+    m_aAttributeValue.m_aDisplaystyle.m_aDisplaystyle = aDisplaystyle->m_aDisplaystyle;
+}
+
+void SmMlAttribute::setMlFence(const SmMlFence* aFence)
+{
+    m_bSet = true;
+    clearPreviousAttributeValue();
+    m_aAttributeValue.m_aFence.m_aFence = aFence->m_aFence;
+}
+
+void SmMlAttribute::setMlForm(const SmMlForm* aForm)
+{
+    m_bSet = true;
+    clearPreviousAttributeValue();
+    m_aAttributeValue.m_aForm.m_aForm = aForm->m_aForm;
+}
+
+void SmMlAttribute::setMlHref(const SmMlHref* aHref)
+{
+    m_bSet = true;
+    clearPreviousAttributeValue();
+    m_aAttributeValue.m_aHref.m_aHref = aHref->m_aHref;
+    m_aAttributeValue.m_aHref.m_aLnk = new OUString(*aHref->m_aLnk);
+}
+
+void SmMlAttribute::setMlLspace(const SmMlLspace* aLspace)
+{
+    m_bSet = true;
+    clearPreviousAttributeValue();
+    m_aAttributeValue.m_aLspace.m_aLengthValue.m_aLengthUnit
+        = aLspace->m_aLengthValue.m_aLengthUnit;
+    m_aAttributeValue.m_aLspace.m_aLengthValue.m_aLengthValue
+        = aLspace->m_aLengthValue.m_aLengthValue;
+    m_aAttributeValue.m_aLspace.m_aLengthValue.m_aOriginalText
+        = new OUString(*aLspace->m_aLengthValue.m_aOriginalText);
+}
+
+void SmMlAttribute::setMlMathbackground(const SmMlMathbackground* aMathbackground)
+{
+    m_bSet = true;
+    clearPreviousAttributeValue();
+    m_aAttributeValue.m_aMathbackground.m_aMathbackground = aMathbackground->m_aMathbackground;
+}
+
+void SmMlAttribute::setMlMathcolor(const SmMlMathcolor* aMathcolor)
+{
+    m_bSet = true;
+    clearPreviousAttributeValue();
+    m_aAttributeValue.m_aMathcolor.m_aMathcolor = aMathcolor->m_aMathcolor;
+}
+
+void SmMlAttribute::setMlMathsize(const SmMlMathsize* aMathsize)
+{
+    m_bSet = true;
+    clearPreviousAttributeValue();
+    m_aAttributeValue.m_aMathsize.m_aLengthValue.m_aLengthUnit
+        = aMathsize->m_aLengthValue.m_aLengthUnit;
+    m_aAttributeValue.m_aMathsize.m_aLengthValue.m_aLengthValue
+        = aMathsize->m_aLengthValue.m_aLengthValue;
+    m_aAttributeValue.m_aMathsize.m_aLengthValue.m_aOriginalText
+        = new OUString(*aMathsize->m_aLengthValue.m_aOriginalText);
+}
+
+void SmMlAttribute::setMlMathvariant(const SmMlMathvariant* aMathvariant)
+{
+    m_bSet = true;
+    clearPreviousAttributeValue();
+    m_aAttributeValue.m_aMathvariant.m_aMathvariant = aMathvariant->m_aMathvariant;
+}
+
+void SmMlAttribute::setMlMaxsize(const SmMlMaxsize* aMaxsize)
+{
+    m_bSet = true;
+    clearPreviousAttributeValue();
+    m_aAttributeValue.m_aMaxsize.m_aMaxsize = aMaxsize->m_aMaxsize;
+    m_aAttributeValue.m_aMaxsize.m_aLengthValue.m_aLengthUnit
+        = aMaxsize->m_aLengthValue.m_aLengthUnit;
+    m_aAttributeValue.m_aMaxsize.m_aLengthValue.m_aLengthValue
+        = aMaxsize->m_aLengthValue.m_aLengthValue;
+    m_aAttributeValue.m_aMaxsize.m_aLengthValue.m_aOriginalText
+        = new OUString(*aMaxsize->m_aLengthValue.m_aOriginalText);
+}
+
+void SmMlAttribute::setMlMinsize(const SmMlMinsize* aMinsize)
+{
+    m_bSet = true;
+    clearPreviousAttributeValue();
+    m_aAttributeValue.m_aMinsize.m_aLengthValue.m_aLengthUnit
+        = aMinsize->m_aLengthValue.m_aLengthUnit;
+    m_aAttributeValue.m_aMinsize.m_aLengthValue.m_aLengthValue
+        = aMinsize->m_aLengthValue.m_aLengthValue;
+    m_aAttributeValue.m_aMinsize.m_aLengthValue.m_aOriginalText
+        = new OUString(*aMinsize->m_aLengthValue.m_aOriginalText);
+}
+
+void SmMlAttribute::setMlMovablelimits(const SmMlMovablelimits* aMovablelimits)
+{
+    m_bSet = true;
+    clearPreviousAttributeValue();
+    m_aAttributeValue.m_aMovablelimits.m_aMovablelimits = aMovablelimits->m_aMovablelimits;
+}
+
+void SmMlAttribute::setMlRspace(const SmMlRspace* aRspace)
+{
+    m_bSet = true;
+    clearPreviousAttributeValue();
+    m_aAttributeValue.m_aRspace.m_aLengthValue.m_aLengthUnit
+        = aRspace->m_aLengthValue.m_aLengthUnit;
+    m_aAttributeValue.m_aRspace.m_aLengthValue.m_aLengthValue
+        = aRspace->m_aLengthValue.m_aLengthValue;
+    m_aAttributeValue.m_aRspace.m_aLengthValue.m_aOriginalText
+        = new OUString(*aRspace->m_aLengthValue.m_aOriginalText);
+}
+
+void SmMlAttribute::setMlSeparator(const SmMlSeparator* aSeparator)
+{
+    m_bSet = true;
+    clearPreviousAttributeValue();
+    m_aAttributeValue.m_aSeparator.m_aSeparator = aSeparator->m_aSeparator;
+}
+
+void SmMlAttribute::setMlStretchy(const SmMlStretchy* aStretchy)
+{
+    m_bSet = true;
+    clearPreviousAttributeValue();
+    m_aAttributeValue.m_aStretchy.m_aStretchy = aStretchy->m_aStretchy;
+}
+
+void SmMlAttribute::setMlSymmetric(const SmMlSymmetric* aSymmetric)
+{
+    m_bSet = true;
+    clearPreviousAttributeValue();
+    m_aAttributeValue.m_aSymmetric.m_aSymmetric = aSymmetric->m_aSymmetric;
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab cinoptions=b1,g0,N-s cinkeys+=0=break: */
diff --git a/starmath/source/mathml/def.cxx b/starmath/source/mathml/def.cxx
new file mode 100644
index 0000000000..484dcd6653
--- /dev/null
+++ b/starmath/source/mathml/def.cxx
@@ -0,0 +1,124 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4; fill-column: 100 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ */
+
+#include <mathml/attribute.hxx>
+
+SmMlAttributePos starmathdatabase::MlAttributeListEmpty[] = {
+    // clang-format off
+    { SmMlAttributeValueType::NMlEmpty, 0 }
+    // clang-format on
+};
+
+SmMlAttributePos starmathdatabase::MlAttributeListMath[] = {
+    // clang-format off
+    { SmMlAttributeValueType::NMlEmpty, 0 }
+    // clang-format on
+};
+
+SmMlAttributePos starmathdatabase::MlAttributeListMi[] = {
+    // clang-format off
+    { SmMlAttributeValueType::MlHref, 0 },
+    { SmMlAttributeValueType::MlDir, 1 },
+    { SmMlAttributeValueType::MlMathbackground, 2 },
+    { SmMlAttributeValueType::MlMathcolor, 3 },
+    { SmMlAttributeValueType::MlDisplaystyle, 4 },
+    { SmMlAttributeValueType::MlMathsize, 5 },
+    { SmMlAttributeValueType::MlMathvariant, 6 }
+    // clang-format on
+};
+
+SmMlAttributePos starmathdatabase::MlAttributeListMerror[] = {
+    // clang-format off
+    { SmMlAttributeValueType::MlHref, 0 },
+    { SmMlAttributeValueType::MlMathbackground, 1 },
+    { SmMlAttributeValueType::MlMathcolor, 2 },
+    { SmMlAttributeValueType::MlDisplaystyle, 3 }
+    // clang-format on
+};
+
+SmMlAttributePos starmathdatabase::MlAttributeListMn[] = {
+    // clang-format off
+    { SmMlAttributeValueType::MlHref, 0 },
+    { SmMlAttributeValueType::MlDir, 1 },
+    { SmMlAttributeValueType::MlMathbackground, 2 },
+    { SmMlAttributeValueType::MlMathcolor, 3 },
+    { SmMlAttributeValueType::MlDisplaystyle, 4 },
+    { SmMlAttributeValueType::MlMathsize, 5 },
+    { SmMlAttributeValueType::MlMathvariant, 6 }
+    // clang-format on
+};
+
+SmMlAttributePos starmathdatabase::MlAttributeListMo[] = {
+    // clang-format off
+    { SmMlAttributeValueType::MlHref, 0 },
+    { SmMlAttributeValueType::MlDir, 1 },
+    { SmMlAttributeValueType::MlMathbackground, 2 },
+    { SmMlAttributeValueType::MlMathcolor, 3 },
+    { SmMlAttributeValueType::MlDisplaystyle, 4 },
+    { SmMlAttributeValueType::MlMathsize, 5 },
+    { SmMlAttributeValueType::MlMathvariant, 6 },
+    { SmMlAttributeValueType::MlFence, 7 },
+    { SmMlAttributeValueType::MlForm, 8 },
+    { SmMlAttributeValueType::MlMaxsize, 9 },
+    { SmMlAttributeValueType::MlMinsize, 10 },
+    { SmMlAttributeValueType::MlMovablelimits, 11 },
+    { SmMlAttributeValueType::MlLspace, 12 },
+    { SmMlAttributeValueType::MlRspace, 13 },
+    { SmMlAttributeValueType::MlAccent, 14 },
+    { SmMlAttributeValueType::MlStretchy, 15 },
+    { SmMlAttributeValueType::MlSeparator, 16 },
+    { SmMlAttributeValueType::MlSymmetric, 17 }
+    // clang-format on
+};
+
+SmMlAttributePos starmathdatabase::MlAttributeListMrow[] = {
+    // clang-format off
+    { SmMlAttributeValueType::MlHref, 0 },
+    { SmMlAttributeValueType::MlDir, 1 },
+    { SmMlAttributeValueType::MlMathbackground, 2 },
+    { SmMlAttributeValueType::MlMathcolor, 3 }
+    // clang-format on
+};
+
+SmMlAttributePos starmathdatabase::MlAttributeListMtext[] = {
+    // clang-format off
+    { SmMlAttributeValueType::MlHref, 0 },
+    { SmMlAttributeValueType::MlDir, 1 },
+    { SmMlAttributeValueType::MlMathbackground, 2 },
+    { SmMlAttributeValueType::MlMathcolor, 3 },
+    { SmMlAttributeValueType::MlDisplaystyle, 4 },
+    { SmMlAttributeValueType::MlMathsize, 5 },
+    { SmMlAttributeValueType::MlMathvariant, 6 }
+    // clang-format on
+};
+
+SmMlAttributePos starmathdatabase::MlAttributeListMstyle[] = {
+    // clang-format off
+    { SmMlAttributeValueType::MlHref, 0 },
+    { SmMlAttributeValueType::MlDir, 1 },
+    { SmMlAttributeValueType::MlMathbackground, 2 },
+    { SmMlAttributeValueType::MlMathcolor, 3 },
+    { SmMlAttributeValueType::MlDisplaystyle, 4 },
+    { SmMlAttributeValueType::MlMathsize, 5 },
+    { SmMlAttributeValueType::MlMathvariant, 6 },
+    { SmMlAttributeValueType::MlFence, 7 },
+    { SmMlAttributeValueType::MlForm, 8 },
+    { SmMlAttributeValueType::MlMaxsize, 9 },
+    { SmMlAttributeValueType::MlMinsize, 10 },
+    { SmMlAttributeValueType::MlMovablelimits, 11 },
+    { SmMlAttributeValueType::MlLspace, 12 },
+    { SmMlAttributeValueType::MlRspace, 13 },
+    { SmMlAttributeValueType::MlAccent, 14 },
+    { SmMlAttributeValueType::MlStretchy, 15 },
+    { SmMlAttributeValueType::MlSeparator, 16 },
+    { SmMlAttributeValueType::MlSymmetric, 17 }
+    // clang-format on
+};
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab cinoptions=b1,g0,N-s cinkeys+=0=break: */
diff --git a/starmath/source/mathml/element.cxx b/starmath/source/mathml/element.cxx
new file mode 100644
index 0000000000..4f8f2a64ff
--- /dev/null
+++ b/starmath/source/mathml/element.cxx
@@ -0,0 +1,136 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4; fill-column: 100 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ */
+
+#include <mathml/element.hxx>
+
+void SmMlElement::SmImplAttributeType()
+{
+    switch (m_aElementType)
+    {
+        case SmMlElementType::NMlEmpty:
+            m_aAttributePosList = std::vector<SmMlAttributePos>(0);
+            break;
+        case SmMlElementType::NMlStructural:
+            m_aAttributePosList = std::vector<SmMlAttributePos>(0);
+            break;
+        case SmMlElementType::NMlSmNode:
+            m_aAttributePosList = std::vector<SmMlAttributePos>(0);
+            break;
+        case SmMlElementType::MlMath:
+            m_aAttributePosList = std::vector<SmMlAttributePos>(0);
+            //m_aAttributePosList = std::vector<SmMlAttributePos>(std::begin(starmathdatabase::MlAttributeListMath), std::end(starmathdatabase::MlAttributeListMath));
+            break;
+        case SmMlElementType::MlMi:
+            m_aAttributePosList
+                = std::vector<SmMlAttributePos>(std::begin(starmathdatabase::MlAttributeListMi),
+                                                std::end(starmathdatabase::MlAttributeListMi));
+            break;
+        case SmMlElementType::MlMerror:
+            m_aAttributePosList
+                = std::vector<SmMlAttributePos>(std::begin(starmathdatabase::MlAttributeListMerror),
+                                                std::end(starmathdatabase::MlAttributeListMerror));
+            break;
+        case SmMlElementType::MlMn:
+            m_aAttributePosList
+                = std::vector<SmMlAttributePos>(std::begin(starmathdatabase::MlAttributeListMn),
+                                                std::end(starmathdatabase::MlAttributeListMn));
+            break;
+        case SmMlElementType::MlMo:
+            m_aAttributePosList
+                = std::vector<SmMlAttributePos>(std::begin(starmathdatabase::MlAttributeListMo),
+                                                std::end(starmathdatabase::MlAttributeListMo));
+            break;
+        case SmMlElementType::MlMrow:
+            m_aAttributePosList
+                = std::vector<SmMlAttributePos>(std::begin(starmathdatabase::MlAttributeListMrow),
+                                                std::end(starmathdatabase::MlAttributeListMrow));
+            break;
+        case SmMlElementType::MlMtext:
+            m_aAttributePosList
+                = std::vector<SmMlAttributePos>(std::begin(starmathdatabase::MlAttributeListMtext),
+                                                std::end(starmathdatabase::MlAttributeListMtext));
+            break;
+        case SmMlElementType::MlMstyle:
+            m_aAttributePosList
+                = std::vector<SmMlAttributePos>(std::begin(starmathdatabase::MlAttributeListMstyle),
+                                                std::end(starmathdatabase::MlAttributeListMstyle));
+            break;
+        default:
+            break;
+    }
+    // Create attribute vector with given pattern
+    m_aAttributeList = starmathdatabase::makeMlAttributeList(m_aAttributePosList);
+}
+
+SmMlAttribute SmMlElement::getAttribute(SmMlAttributeValueType aAttributeType) const
+{
+    // Look for the attribute position and return if exists
+    for (size_t i = 0; i < m_aAttributePosList.size(); ++i)
+    {
+        if (m_aAttributePosList[i].m_aAttributeValueType == aAttributeType)
+            return m_aAttributeList[m_aAttributePosList[i].m_nPos];
+    }
+    return SmMlAttribute();
+}
+
+bool SmMlElement::isAttributeSet(SmMlAttributeValueType aAttributeType) const
+{
+    // Look for the attribute position and return if exists
+    for (size_t i = 0; i < m_aAttributePosList.size(); ++i)
+    {
+        if (m_aAttributePosList[i].m_aAttributeValueType == aAttributeType)
+            return m_aAttributeList[m_aAttributePosList[i].m_nPos].isSet();
+    }
+    return false;
+}
+
+void SmMlElement::setAttribute(const SmMlAttribute* aAttribute)
+{
+    // Look for the attribute position and assign if exists
+    for (size_t i = 0; i < m_aAttributePosList.size(); ++i)
+    {
+        if (m_aAttributePosList[i].m_aAttributeValueType == aAttribute->getMlAttributeValueType())
+        {
+            m_aAttributeList[m_aAttributePosList[i].m_nPos].setMlAttributeValue(aAttribute);
+            break;
+        }
+    }
+}
+
+void SmMlElement::setSubElement(size_t nPos, SmMlElement* aElement)
+{
+    // This is the new parent element
+    aElement->setParentElement(this);
+    aElement->setSubElementId(nPos);
+    // Check if the vector is long enough
+    // Careful nOldSize can be 0 and -1 will underflow
+    // We must put something on the empty locations
+    size_t nOldSize = m_aSubElements.size();
+    if (nPos + 1 > nOldSize)
+    {
+        m_aSubElements.resize(nPos + 1);
+        for (; nOldSize < nPos; ++nOldSize)
+            m_aSubElements[nOldSize] = nullptr;
+    }
+    // Assign value
+    m_aSubElements[nPos] = aElement;
+}
+
+std::vector<SmMlAttribute>
+starmathdatabase::makeMlAttributeList(std::vector<SmMlAttributePos> aAttributePosList)
+{
+    std::vector<SmMlAttribute> aAttributeList(aAttributePosList.size());
+    for (size_t i = 0; i < aAttributePosList.size(); ++i)
+    {
+        aAttributeList[i].setMlAttributeValueType(aAttributePosList[i].m_aAttributeValueType);
+    }
+    return aAttributeList;
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab cinoptions=b1,g0,N-s cinkeys+=0=break: */
diff --git a/starmath/source/mathml/export.cxx b/starmath/source/mathml/export.cxx
new file mode 100644
index 0000000000..923668f454
--- /dev/null
+++ b/starmath/source/mathml/export.cxx
@@ -0,0 +1,1090 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+// Our mathml
+#include <mathml/export.hxx>
+#include <mathml/iterator.hxx>
+
+// LO tools to use
+#include <com/sun/star/beans/PropertyAttribute.hpp>
+#include <com/sun/star/embed/ElementModes.hpp>
+#include <com/sun/star/task/XStatusIndicator.hpp>
+#include <com/sun/star/uno/Any.h>
+#include <com/sun/star/util/MeasureUnit.hpp>
+#include <com/sun/star/xml/sax/Writer.hpp>
+
+// Extra LO tools
+#include <comphelper/genericpropertyset.hxx>
+#include <comphelper/processfactory.hxx>
+#include <comphelper/propertysetinfo.hxx>
+#include <sfx2/frame.hxx>
+#include <sfx2/docfile.hxx>
+#include <sfx2/sfxsids.hrc>
+#include <svl/itemset.hxx>
+#include <svl/stritem.hxx>
+#include <unotools/streamwrap.hxx>
+#include <xmloff/namespacemap.hxx>
+
+// Our starmath tools
+#include <document.hxx>
+#include <smmod.hxx>
+#include <strings.hrc>
+#include <unomodel.hxx>
+#include <xparsmlbase.hxx>
+#include <starmathdatabase.hxx>
+
+// Old parser
+#include <mathmlexport.hxx>
+
+using namespace ::com::sun::star;
+using namespace xmloff::token;
+
+using namespace ::com::sun::star::beans;
+using namespace ::com::sun::star::document;
+using namespace ::com::sun::star::lang;
+using namespace ::com::sun::star::uno;
+using namespace ::com::sun::star;
+using namespace ::xmloff::token;
+
+// SmMLExportWrapper
+/*************************************************************************************************/
+
+bool SmMLExportWrapper::Export(SfxMedium& rMedium)
+{
+    bool bRet = true;
+    uno::Reference<uno::XComponentContext> xContext(comphelper::getProcessComponentContext());
+
+    // Check all fine
+    SAL_WARN_IF(m_xModel == nullptr, "starmath", "Missing model");
+    SAL_WARN_IF(xContext == nullptr, "starmath", "Missing context");
+    if (m_xModel == nullptr || xContext == nullptr)
+        return false;
+
+    // Get doc shell
+    SmDocShell* pDocShell = static_cast<SmDocShell*>(m_xModel->GetObjectShell());
+    if (pDocShell == nullptr)
+    {
+        SAL_WARN("starmath", "Failed to fetch sm document");
+        return false;
+    }
+
+    // Check if it is a standalone window or embed object
+    bool bEmbedded = SfxObjectCreateMode::EMBEDDED == pDocShell->GetCreateMode();
+
+    // Medium item set
+    SfxItemSet& rMediumItemSet = rMedium.GetItemSet();
+    if (pDocShell == nullptr)
+    {
+        SAL_WARN("starmath", "Failed to get medium item set");
+        return false;
+    }
+
+    // Progress bar ~
+    uno::Reference<task::XStatusIndicator> xStatusIndicator;
+
+    if (!bEmbedded)
+    {
+        // Extra check to ensure everything is fine
+        if (pDocShell->GetMedium() != &rMedium)
+        {
+            SAL_WARN("starmath", "Input medium and sm document medium do not match");
+            //return false;
+        }
+
+        // Fetch progress bar
+        const SfxUnoAnyItem* pItem = rMediumItemSet.GetItem(SID_PROGRESS_STATUSBAR_CONTROL);
+        if (pItem)
+        {
+            // set progress range and start status indicator
+            pItem->GetValue() >>= xStatusIndicator;
+            xStatusIndicator->start(SmResId(STR_STATSTR_WRITING), 3);
+            xStatusIndicator->setValue(0);
+        }
+    }
+
+    // create XPropertySet with three properties for status indicator
+    static const comphelper::PropertyMapEntry aInfoMap[]{
+        { OUString("UsePrettyPrinting"), 0, cppu::UnoType<bool>::get(),
+          beans::PropertyAttribute::MAYBEVOID, 0 },
+        { OUString("BaseURI"), 0, ::cppu::UnoType<OUString>::get(),
+          beans::PropertyAttribute::MAYBEVOID, 0 },
+        { OUString("StreamRelPath"), 0, ::cppu::UnoType<OUString>::get(),
+          beans::PropertyAttribute::MAYBEVOID, 0 },
+        { OUString("StreamName"), 0, ::cppu::UnoType<OUString>::get(),
+          beans::PropertyAttribute::MAYBEVOID, 0 }
+    };
+    uno::Reference<beans::XPropertySet> xInfoSet(
+        comphelper::GenericPropertySet_CreateInstance(new comphelper::PropertySetInfo(aInfoMap)));
+
+    // Always print pretty
+    xInfoSet->setPropertyValue("UsePrettyPrinting", Any(true));
+
+    // Set base URI
+    xInfoSet->setPropertyValue(u"BaseURI"_ustr, Any(rMedium.GetBaseURL(true)));
+
+    if (!m_bFlat) //Storage (Package) of Stream
+    {
+        // Fetch the output storage
+        uno::Reference<embed::XStorage> xStg = rMedium.GetOutputStorage();
+        if (xStg == nullptr)
+        {
+            SAL_WARN("starmath", "Failed to fetch output storage");
+            return false;
+        }
+
+        // TODO/LATER: handle the case of embedded links gracefully
+        if (bEmbedded) //&& !pStg->IsRoot() )
+        {
+            const SfxStringItem* pDocHierarchItem
+                = rMediumItemSet.GetItem(SID_DOC_HIERARCHICALNAME);
+            if (pDocHierarchItem != nullptr)
+            {
+                OUString aName = pDocHierarchItem->GetValue();
+                if (!aName.isEmpty())
+                    xInfoSet->setPropertyValue("StreamRelPath", Any(aName));
+            }
+        }
+        else
+        {
+            // Write file metadata ( data, LO version ... )
+            // Note: export through an XML exporter component (storage version)
+            if (xStatusIndicator.is())
+                xStatusIndicator->setValue(1);
+
+            bRet = WriteThroughComponentS(xStg, m_xModel, u"meta.xml", xContext, xInfoSet,
+                                          u"com.sun.star.comp.Math.MLOasisMetaExporter", 6);
+        }
+
+        // Write starmath formula
+        // Note: export through an XML exporter component (storage version)
+        if (bRet)
+        {
+            if (xStatusIndicator.is())
+                xStatusIndicator->setValue(2);
+
+            if (pDocShell->GetSmSyntaxVersion() == 5)
+                bRet = WriteThroughComponentS(xStg, m_xModel, u"content.xml", xContext, xInfoSet,
+                                              u"com.sun.star.comp.Math.XMLContentExporter", 5);
+            else
+                bRet = WriteThroughComponentS(xStg, m_xModel, u"content.xml", xContext, xInfoSet,
+                                              u"com.sun.star.comp.Math.MLContentExporter", 6);
+        }
+
+        // Write starmath settings
+        // Note: export through an XML exporter component (storage version)
+        if (bRet)
+        {
+            if (xStatusIndicator.is())
+                xStatusIndicator->setValue(3);
+
+            bRet = WriteThroughComponentS(xStg, m_xModel, u"settings.xml", xContext, xInfoSet,
+                                          u"com.sun.star.comp.Math.MLOasisSettingsExporter", 6);
+        }
+    }
+    else
+    {
+        // Fetch the output stream
+        SvStream* pStream = rMedium.GetOutStream();
+        if (pStream == nullptr)
+        {
+            SAL_WARN("starmath", "Missing output stream");
+            return false;
+        }
+        uno::Reference<io::XOutputStream> xOut(new utl::OOutputStreamWrapper(*pStream));
+
+        if (xStatusIndicator.is())
+            xStatusIndicator->setValue(1);
+
+        // Write everything in the same place
+        // Note: export through an XML exporter component (output stream version)
+        if (pDocShell->GetSmSyntaxVersion() == 5)
+            bRet = WriteThroughComponentOS(xOut, m_xModel, xContext, xInfoSet,
+                                           u"com.sun.star.comp.Math.XMLContentExporter", 5);
+        else
+            bRet = WriteThroughComponentOS(xOut, m_xModel, xContext, xInfoSet,
+                                           u"com.sun.star.comp.Math.MLContentExporter", 6);
+    }
+
+    if (xStatusIndicator.is())
+        xStatusIndicator->end();
+    return bRet;
+}
+
+OUString SmMLExportWrapper::Export(SmMlElement* pElementTree)
+{
+    uno::Reference<uno::XComponentContext> xContext(comphelper::getProcessComponentContext());
+
+    // Check all fine
+    m_pElementTree = nullptr;
+    SAL_WARN_IF(m_xModel == nullptr, "starmath", "Missing model");
+    SAL_WARN_IF(xContext == nullptr, "starmath", "Missing context");
+    if (m_xModel == nullptr || xContext == nullptr)
+        return u""_ustr;
+
+    //Get model
+    uno::Reference<lang::XComponent> xModelComp = m_xModel;
+    SAL_WARN_IF(xModelComp == nullptr, "starmath", "Missing model component");
+    SmModel* pModel = m_xModel.get();
+    SAL_WARN_IF(pModel == nullptr, "starmath", "Failed to get threw uno tunnel");
+    if (xModelComp == nullptr || pModel == nullptr)
+        return u""_ustr;
+
+    // Get doc shell
+    SmDocShell* pDocShell = static_cast<SmDocShell*>(pModel->GetObjectShell());
+    if (pDocShell == nullptr)
+    {
+        SAL_WARN("starmath", "Failed to fetch sm document");
+        return u""_ustr;
+    }
+
+    // create XPropertySet with three properties for status indicator
+    static const comphelper::PropertyMapEntry aInfoMap[]{
+        { OUString("UsePrettyPrinting"), 0, cppu::UnoType<bool>::get(),
+          beans::PropertyAttribute::MAYBEVOID, 0 },
+        { OUString("BaseURI"), 0, ::cppu::UnoType<OUString>::get(),
+          beans::PropertyAttribute::MAYBEVOID, 0 },
+        { OUString("StreamRelPath"), 0, ::cppu::UnoType<OUString>::get(),
+          beans::PropertyAttribute::MAYBEVOID, 0 },
+        { OUString("StreamName"), 0, ::cppu::UnoType<OUString>::get(),
+          beans::PropertyAttribute::MAYBEVOID, 0 }
+    };
+    uno::Reference<beans::XPropertySet> xInfoSet(
+        comphelper::GenericPropertySet_CreateInstance(new comphelper::PropertySetInfo(aInfoMap)));
+
+    // Always print pretty
+    xInfoSet->setPropertyValue("UsePrettyPrinting", Any(true));
+
+    // Fetch mathml tree
+    m_pElementTree = pElementTree;
+
+    // Write stuff
+    // Note: export through an XML exporter component (memory stream version)
+    return WriteThroughComponentMS(xModelComp, xContext, xInfoSet);
+}
+
+// export through an XML exporter component (output stream version)
+bool SmMLExportWrapper::WriteThroughComponentOS(const Reference<io::XOutputStream>& xOutputStream,
+                                                const Reference<XComponent>& xComponent,
+                                                Reference<uno::XComponentContext> const& rxContext,
+                                                Reference<beans::XPropertySet> const& rPropSet,
+                                                const char16_t* pComponentName,
+                                                int_fast16_t nSyntaxVersion)
+{
+    // We need a output stream but it is already checked by caller
+    // We need a component but it is already checked by caller
+    // We need a context but it is already checked by caller
+    // We need a property set but it is already checked by caller
+    // We need a component name but it is already checked by caller
+
+    // get sax writer
+    Reference<xml::sax::XWriter> xSaxWriter = xml::sax::Writer::create(rxContext);
+
+    // connect XML writer to output stream
+    xSaxWriter->setOutputStream(xOutputStream);
+    if (m_bUseHTMLMLEntities)
+        xSaxWriter->setCustomEntityNames(starmathdatabase::icustomMathmlHtmlEntitiesExport);
+
+    // prepare arguments (prepend doc handler to given arguments)
+    Sequence<Any> aArgs{ Any(xSaxWriter), Any(rPropSet) };
+
+    // get filter component
+    auto xExporterData = rxContext->getServiceManager()->createInstanceWithArgumentsAndContext(
+        OUString(pComponentName), aArgs, rxContext);
+    Reference<document::XExporter> xExporter(xExporterData, UNO_QUERY);
+
+    // Check everything is fine
+    if (!xExporter.is())
+    {
+        SAL_WARN("starmath", "can't instantiate export filter component");
+        return false;
+    }
+
+    // connect model and filter
+    xExporter->setSourceDocument(xComponent);
+    Reference<XFilter> xFilter(xExporter, UNO_QUERY);
+    uno::Sequence<PropertyValue> aProps(0);
+
+    // filter
+    if (nSyntaxVersion == 5)
+    {
+        SmXMLExport* pFilter = dynamic_cast<SmXMLExport*>(xFilter.get());
+        if (pFilter == nullptr)
+        {
+            SAL_WARN("starmath", "Failed to fetch SmMLExport");
+            return false;
+        }
+        xFilter->filter(aProps);
+        return pFilter->GetSuccess();
+    }
+
+    // filter
+    SmMLExport* pFilter = dynamic_cast<SmMLExport*>(xFilter.get());
+
+    // Setup filter
+    if (pFilter == nullptr)
+    {
+        SAL_WARN("starmath", "Failed to fetch SmMLExport");
+        return false;
+    }
+    pFilter->setUseExportTag(m_bUseExportTag);
+    pFilter->setElementTree(m_pElementTree);
+
+    // Execute operation
+    xFilter->filter(aProps);
+    return pFilter->getSuccess();
+}
+
+// export through an XML exporter component (storage version)
+bool SmMLExportWrapper::WriteThroughComponentS(const Reference<embed::XStorage>& xStorage,
+                                               const Reference<XComponent>& xComponent,
+                                               const char16_t* pStreamName,
+                                               Reference<uno::XComponentContext> const& rxContext,
+                                               Reference<beans::XPropertySet> const& rPropSet,
+                                               const char16_t* pComponentName,
+                                               int_fast16_t nSyntaxVersion)
+{
+    // We need a storage name but it is already checked by caller
+    // We need a component name but it is already checked by caller
+    // We need a stream name but it is already checked by caller
+    // We need a context but it is already checked by caller
+    // We need a property set but it is already checked by caller
+    // We need a component but it is already checked by caller
+
+    // open stream
+    Reference<io::XStream> xStream;
+    try
+    {
+        xStream = xStorage->openStreamElement(
+            OUString(pStreamName), embed::ElementModes::READWRITE | embed::ElementModes::TRUNCATE);
+    }
+    catch (const uno::Exception&)
+    {
+        SAL_WARN("starmath", "Can't create output stream in package");
+        return false;
+    }
+
+    // Set stream as text / xml
+    uno::Reference<beans::XPropertySet> xSet(xStream, uno::UNO_QUERY);
+    xSet->setPropertyValue("MediaType", Any(u"text/xml"_ustr));
+
+    // all streams must be encrypted in encrypted document
+    xSet->setPropertyValue("UseCommonStoragePasswordEncryption", Any(true));
+
+    // set Base URL
+    rPropSet->setPropertyValue("StreamName", Any(OUString(pStreamName)));
+
+    // write the stuff
+    // Note: export through an XML exporter component (output stream version)
+    return WriteThroughComponentOS(xStream->getOutputStream(), xComponent, rxContext, rPropSet,
+                                   pComponentName, nSyntaxVersion);
+}
+
+// export through an XML exporter component (memory stream version)
+OUString
+SmMLExportWrapper::WriteThroughComponentMS(const Reference<XComponent>& xComponent,
+                                           Reference<uno::XComponentContext> const& rxContext,
+                                           Reference<beans::XPropertySet> const& rPropSet)
+{
+    // We need a component but it is already checked by caller
+    // We need a context but it is already checked by caller
+    // We need a property set it is already checked by caller
+
+    // open stream
+    SvMemoryStream aMemoryStream(8192, 1024);
+    uno::Reference<io::XOutputStream> xStream(new utl::OOutputStreamWrapper(aMemoryStream));
+
+    // Set the stream as text
+    uno::Reference<beans::XPropertySet> xSet(xStream, uno::UNO_QUERY);
+    xSet->setPropertyValue("MediaType", Any(OUString("text/xml")));
+
+    // write the stuff
+    // Note: export through an XML exporter component (output stream version)
+    bool bOk = WriteThroughComponentOS(xStream, xComponent, rxContext, rPropSet,
+                                       u"com.sun.star.comp.Mathml.MLContentExporter", 6);
+
+    // We don't want to read uninitialized data
+    if (!bOk)
+        return u""_ustr;
+
+    // Recover data and generate string
+    OString aString(static_cast<const char*>(aMemoryStream.GetData()),
+                    aMemoryStream.GetSize() / sizeof(char));
+    return OStringToOUString(aString, RTL_TEXTENCODING_UTF8);
+}
+
+// SmMLExport technical
+/*************************************************************************************************/
+
+extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface*
+Math_MLExporter_get_implementation(css::uno::XComponentContext* context,
+                                   css::uno::Sequence<css::uno::Any> const&)
+{
+    return cppu::acquire(new SmMLExport(context, "com.sun.star.comp.Math.XMLExporter",
+                                        SvXMLExportFlags::OASIS | SvXMLExportFlags::ALL));
+}
+
+extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface*
+Math_MLOasisMetaExporter_get_implementation(css::uno::XComponentContext* context,
+                                            css::uno::Sequence<css::uno::Any> const&)
+{
+    return cppu::acquire(new SmMLExport(context, "com.sun.star.comp.Math.XMLOasisMetaExporter",
+                                        SvXMLExportFlags::OASIS | SvXMLExportFlags::META));
+}
+
+extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface*
+Math_MLOasisSettingsExporter_get_implementation(css::uno::XComponentContext* context,
+                                                css::uno::Sequence<css::uno::Any> const&)
+{
+    return cppu::acquire(new SmMLExport(context, "com.sun.star.comp.Math.XMLOasisSettingsExporter",
+                                        SvXMLExportFlags::OASIS | SvXMLExportFlags::SETTINGS));
+}
+
+extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface*
+Math_MLContentExporter_get_implementation(css::uno::XComponentContext* context,
+                                          css::uno::Sequence<css::uno::Any> const&)
+{
+    return cppu::acquire(new SmMLExport(context, "com.sun.star.comp.Math.XMLContentExporter",
+                                        SvXMLExportFlags::OASIS | SvXMLExportFlags::CONTENT));
+}
+
+SmDocShell* SmMLExport::getSmDocShell()
+{
+    SmModel* pModel = comphelper::getFromUnoTunnel<SmModel>(GetModel());
+    if (pModel != nullptr)
+        return static_cast<SmDocShell*>(pModel->GetObjectShell());
+    return nullptr;
+}
+
+ErrCode SmMLExport::exportDoc(enum XMLTokenEnum eClass)
+{
+    if (!(getExportFlags() & SvXMLExportFlags::CONTENT))
+    {
+        // Everything that isn't the formula itself get's default export
+        SvXMLExport::exportDoc(eClass);
+        return ERRCODE_NONE;
+    }
+
+    // Checks if it has to export a particular tree
+    if (m_pElementTree == nullptr)
+    {
+        // Set element tree
+        SmDocShell* pDocShell = getSmDocShell();
+        if (pDocShell != nullptr)
+            m_pElementTree = pDocShell->GetMlElementTree();
+        else
+        {
+            m_bSuccess = false;
+            return SVSTREAM_INVALID_PARAMETER;
+        }
+    }
+
+    // Start document and encrypt if necessary
+    GetDocHandler()->startDocument();
+    addChaffWhenEncryptedStorage();
+
+    // make use of a default namespace
+    // Math doesn't need namespaces from xmloff, since it now uses default namespaces
+    // Because that is common with current MathML usage in the web -> ResetNamespaceMap();
+    GetNamespaceMap_().Add(u""_ustr, GetXMLToken(XML_N_MATH), XML_NAMESPACE_MATH);
+
+    // Add xmlns line
+    if (m_bUseExportTag)
+    {
+        GetAttrList().AddAttribute(GetNamespaceMap().GetAttrNameByKey(XML_NAMESPACE_MATH),
+                                   GetNamespaceMap().GetNameByKey(XML_NAMESPACE_MATH));
+    }
+
+    // Export and close document
+    ExportContent_();
+    GetDocHandler()->endDocument();
+
+    return ERRCODE_NONE;
+}
+
+void SmMLExport::GetViewSettings(Sequence<PropertyValue>& aProps)
+{
+    // Get the document shell
+    SmDocShell* pDocShell = getSmDocShell();
+    if (pDocShell == nullptr)
+    {
+        SAL_WARN("starmath", "Missing document shell so no view settings");
+        return;
+    }
+
+    // Allocate enough memory
+    aProps.realloc(4);
+    PropertyValue* pValue = aProps.getArray();
+
+    // The view settings are the formula display settings
+    tools::Rectangle aRect(pDocShell->GetVisArea());
+
+    pValue[0].Name = "ViewAreaTop";
+    pValue[0].Value <<= aRect.Top();
+
+    pValue[1].Name = "ViewAreaLeft";
+    pValue[1].Value <<= aRect.Left();
+
+    pValue[2].Name = "ViewAreaWidth";
+    pValue[2].Value <<= aRect.GetWidth();
+
+    pValue[3].Name = "ViewAreaHeight";
+    pValue[3].Value <<= aRect.GetHeight();
+}
+
+void SmMLExport::GetConfigurationSettings(Sequence<PropertyValue>& rProps)
+{
+    // Get model property set (settings)
+    Reference<XPropertySet> xProps(GetModel(), UNO_QUERY);
+    if (!xProps.is())
+    {
+        SAL_WARN("starmath", "Missing model properties so no configuration settings");
+        return;
+    }
+
+    // Get model property set info (settings values)
+    Reference<XPropertySetInfo> xPropertySetInfo = xProps->getPropertySetInfo();
+    if (!xPropertySetInfo.is())
+    {
+        SAL_WARN("starmath", "Missing model properties info so no configuration settings");
+        return;
+    }
+
+    // Allocate to store the properties
+    Sequence<Property> aProps = xPropertySetInfo->getProperties();
+    const sal_Int32 nCount = aProps.getLength();
+    rProps.realloc(nCount);
+    auto pProps = rProps.getArray();
+
+    // Copy properties
+    // This needs further revision
+    // Based in code mathmlexport.cxx::GetConfigurationSettings
+    for (sal_Int32 i = 0; i < nCount; ++i)
+    {
+        if (aProps[i].Name != "Formula" && aProps[i].Name != "BasicLibraries"
+            && aProps[i].Name != "DialogLibraries" && aProps[i].Name != "RuntimeUID")
+        {
+            pProps[i].Name = aProps[i].Name;
+            pProps[i].Value = xProps->getPropertyValue(aProps[i].Name);
+        }
+    }
+}
+
+SmMLExport::SmMLExport(const css::uno::Reference<css::uno::XComponentContext>& rContext,
+                       OUString const& implementationName, SvXMLExportFlags nExportFlags)
+    : SvXMLExport(rContext, implementationName, util::MeasureUnit::INCH, XML_MATH, nExportFlags)
+    , m_pElementTree(nullptr)
+    , m_bSuccess(true)
+    , m_bUseExportTag(true)
+{
+}
+
+// SmMLExport
+/*************************************************************************************************/
+
+void SmMLExport::declareMlError()
+{
+    SAL_WARN("starmath", "Invalid use of mathml.");
+    m_bSuccess = false;
+}
+
+void SmMLExport::exportMlAttributeLength(xmloff::token::XMLTokenEnum pAttribute,
+                                         const SmLengthValue& aLengthValue)
+{
+    if (!aLengthValue.m_aOriginalText->isEmpty())
+    {
+        addAttribute(pAttribute, *aLengthValue.m_aOriginalText);
+    }
+    else
+    {
+        OUStringBuffer aSizeBuffer(64);
+        aSizeBuffer.append(aLengthValue.m_aLengthValue);
+        switch (aLengthValue.m_aLengthUnit)
+        {
+            case SmLengthUnit::MlEm:
+                aSizeBuffer.append(u"em");
+                break;
+            case SmLengthUnit::MlEx:
+                aSizeBuffer.append(u"ex");
+                break;
+            case SmLengthUnit::MlPx:
+                aSizeBuffer.append(u"px");
+                break;
+            case SmLengthUnit::MlIn:
+                aSizeBuffer.append(u"in");
+                break;
+            case SmLengthUnit::MlCm:
+                aSizeBuffer.append(u"cm");
+                break;
+            case SmLengthUnit::MlMm:
+                aSizeBuffer.append(u"mm");
+                break;
+            case SmLengthUnit::MlPt:
+                aSizeBuffer.append(u"pt");
+                break;
+            case SmLengthUnit::MlPc:
+                aSizeBuffer.append(u"pc");
+                break;
+            case SmLengthUnit::MlP:
+                aSizeBuffer.append(u"%");
+                break;
+            case SmLengthUnit::MlM:
+                break;
+            default:
+                declareMlError();
+                break;
+        }
+        addAttribute(pAttribute, aSizeBuffer.makeStringAndClear());
+    }
+}
+
+void SmMLExport::exportMlAttributes(const SmMlElement* pMlElement)
+{
+    size_t nAttributeCount = pMlElement->getAttributeCount();
+    for (size_t i = 0; i < nAttributeCount; ++i)
+    {
+        SmMlAttribute aAttribute = pMlElement->getAttribute(i);
+        if (!aAttribute.isSet())
+            continue;
+
+        switch (aAttribute.getMlAttributeValueType())
+        {
+            case SmMlAttributeValueType::MlAccent:
+            {
+                auto aAttributeValue = aAttribute.getMlAccent();
+                switch (aAttributeValue->m_aAccent)
+                {
+                    case SmMlAttributeValueAccent::MlFalse:
+                        addAttribute(XML_ACCENT, XML_FALSE);
+                        break;
+                    case SmMlAttributeValueAccent::MlTrue:
+                        addAttribute(XML_ACCENT, XML_TRUE);
+                        break;
+                    default:
+                        declareMlError();
+                        break;
+                }
+                break;
+            }
+            case SmMlAttributeValueType::MlDir:
+            {
+                auto aAttributeValue = aAttribute.getMlDir();
+                switch (aAttributeValue->m_aDir)
+                {
+                    case SmMlAttributeValueDir::MlLtr:
+                        addAttribute(XML_DIR, XML_LTR);
+                        break;
+                    case SmMlAttributeValueDir::MlRtl:
+                        addAttribute(XML_DIR, XML_RTL);
+                        break;
+                    default:
+                        declareMlError();
+                        break;
+                }
+                break;
+            }
+            case SmMlAttributeValueType::MlDisplaystyle:
+            {
+                auto aAttributeValue = aAttribute.getMlDisplaystyle();
+                switch (aAttributeValue->m_aDisplaystyle)
+                {
+                    case SmMlAttributeValueDisplaystyle::MlTrue:
+                        addAttribute(XML_DISPLAYSTYLE, XML_FALSE);
+                        break;
+                    case SmMlAttributeValueDisplaystyle::MlFalse:
+                        addAttribute(XML_DISPLAYSTYLE, XML_TRUE);
+                        break;
+                    default:
+                        declareMlError();
+                        break;
+                }
+                break;
+            }
+            case SmMlAttributeValueType::MlFence:
+            {
+                auto aAttributeValue = aAttribute.getMlFence();
+                switch (aAttributeValue->m_aFence)
+                {
+                    case SmMlAttributeValueFence::MlTrue:
+                        addAttribute(XML_FENCE, XML_FALSE);
+                        break;
+                    case SmMlAttributeValueFence::MlFalse:
+                        addAttribute(XML_FENCE, XML_TRUE);
+                        break;
+                    default:
+                        declareMlError();
+                        break;
+                }
+                break;
+            }
+            case SmMlAttributeValueType::MlHref:
+            {
+                auto aAttributeValue = aAttribute.getMlHref();
+                switch (aAttributeValue->m_aHref)
+                {
+                    case SmMlAttributeValueHref::NMlEmpty:
+                        break;
+                    case SmMlAttributeValueHref::NMlValid:
+                        addAttribute(XML_HREF, *aAttributeValue->m_aLnk);
+                        break;
+                    default:
+                        declareMlError();
+                        break;
+                }
+                break;
+            }
+            case SmMlAttributeValueType::MlLspace:
+            {
+                auto aSizeData = aAttribute.getMlLspace();
+                auto aLengthData = aSizeData->m_aLengthValue;
+                exportMlAttributeLength(XML_LSPACE, aLengthData);
+                break;
+            }
+            case SmMlAttributeValueType::MlMathbackground:
+            {
+                auto aAttributeValue = aAttribute.getMlMathbackground();
+                switch (aAttributeValue->m_aMathbackground)
+                {
+                    case SmMlAttributeValueMathbackground::MlTransparent:
+                        addAttribute(XML_MATHBACKGROUND, "transparent");
+                        break;
+                    case SmMlAttributeValueMathbackground::MlRgb:
+                    {
+                        const OUString& rTextColor = starmathdatabase::Identify_Color_MATHML(
+                                                         sal_uInt32(aAttributeValue->m_aCol))
+                                                         .aIdent;
+                        addAttribute(XML_MATHBACKGROUND, rTextColor);
+                        break;
+                    }
+                    default:
+                        declareMlError();
+                        break;
+                }
+                break;
+            }
+            case SmMlAttributeValueType::MlMathcolor:
+            {
+                auto aAttributeValue = aAttribute.getMlMathcolor();
+                switch (aAttributeValue->m_aMathcolor)
+                {
+                    case SmMlAttributeValueMathcolor::MlDefault:
+                        break;
+                    case SmMlAttributeValueMathcolor::MlRgb:
+                    {
+                        const OUString& rTextColor = starmathdatabase::Identify_Color_MATHML(
+                                                         sal_uInt32(aAttributeValue->m_aCol))
+                                                         .aIdent;
+                        addAttribute(XML_MATHCOLOR, rTextColor);
+                        break;
+                    }
+                    default:
+                        declareMlError();
+                        break;
+                }
+                break;
+            }
+            case SmMlAttributeValueType::MlMathsize:
+            {
+                auto aSizeData = aAttribute.getMlMathsize();
+                auto aLengthData = aSizeData->m_aLengthValue;
+                exportMlAttributeLength(XML_MATHSIZE, aLengthData);
+                break;
+            }
+            case SmMlAttributeValueType::MlMathvariant:
+            {
+                auto aAttributeValue = aAttribute.getMlMathvariant();
+                switch (aAttributeValue->m_aMathvariant)
+                {
+                    case SmMlAttributeValueMathvariant::normal:
+                        addAttribute(XML_MATHVARIANT, "normal");
+                        break;
+                    case SmMlAttributeValueMathvariant::bold:
+                        addAttribute(XML_MATHVARIANT, "bold");
+                        break;
+                    case SmMlAttributeValueMathvariant::italic:
+                        addAttribute(XML_MATHVARIANT, "italic");
+                        break;
+                    case SmMlAttributeValueMathvariant::double_struck:
+                        addAttribute(XML_MATHVARIANT, "double-struck");
+                        break;
+                    case SmMlAttributeValueMathvariant::script:
+                        addAttribute(XML_MATHVARIANT, "script");
+                        break;
+                    case SmMlAttributeValueMathvariant::fraktur:
+                        addAttribute(XML_MATHVARIANT, "fraktur");
+                        break;
+                    case SmMlAttributeValueMathvariant::sans_serif:
+                        addAttribute(XML_MATHVARIANT, "sans-serif");
+                        break;
+                    case SmMlAttributeValueMathvariant::monospace:
+                        addAttribute(XML_MATHVARIANT, "monospace");
+                        break;
+                    case SmMlAttributeValueMathvariant::bold_italic:
+                        addAttribute(XML_MATHVARIANT, "bold-italic");
+                        break;
+                    case SmMlAttributeValueMathvariant::bold_fraktur:
+                        addAttribute(XML_MATHVARIANT, "bold-fracktur");
+                        break;
+                    case SmMlAttributeValueMathvariant::bold_script:
+                        addAttribute(XML_MATHVARIANT, "bold-script");
+                        break;
+                    case SmMlAttributeValueMathvariant::bold_sans_serif:
+                        addAttribute(XML_MATHVARIANT, "bold-sans-serif");
+                        break;
+                    case SmMlAttributeValueMathvariant::sans_serif_italic:
+                        addAttribute(XML_MATHVARIANT, "sans-serif-italic");
+                        break;
+                    case SmMlAttributeValueMathvariant::sans_serif_bold_italic:
+                        addAttribute(XML_MATHVARIANT, "sans-serif-bold-italic");
+                        break;
+                    case SmMlAttributeValueMathvariant::initial:
+                        addAttribute(XML_MATHVARIANT, "initial");
+                        break;
+                    case SmMlAttributeValueMathvariant::tailed:
+                        addAttribute(XML_MATHVARIANT, "tailed");
+                        break;
+                    case SmMlAttributeValueMathvariant::looped:
+                        addAttribute(XML_MATHVARIANT, "looped");
+                        break;
+                    case SmMlAttributeValueMathvariant::stretched:
+                        addAttribute(XML_MATHVARIANT, "stretched");
+                        break;
+                    default:
+                        declareMlError();
+                        break;
+                }
+                break;
+            }
+            case SmMlAttributeValueType::MlMaxsize:
+            {
+                auto aSizeData = aAttribute.getMlMaxsize();
+                auto aLengthData = aSizeData->m_aLengthValue;
+                switch (aSizeData->m_aMaxsize)
+                {
+                    case SmMlAttributeValueMaxsize::MlInfinity:
+                    {
+                        addAttribute(XML_MAXSIZE, XML_INFINITY);
+                        break;
+                    }
+                    case SmMlAttributeValueMaxsize::MlFinite:
+                    {
+                        exportMlAttributeLength(XML_MAXSIZE, aLengthData);
+                        break;
+                    }
+                }
+                break;
+            }
+            case SmMlAttributeValueType::MlMinsize:
+            {
+                auto aSizeData = aAttribute.getMlMinsize();
+                auto aLengthData = aSizeData->m_aLengthValue;
+                exportMlAttributeLength(XML_MINSIZE, aLengthData);
+                break;
+            }
+            case SmMlAttributeValueType::MlMovablelimits:
+            {
+                auto aAttributeValue = aAttribute.getMlMovablelimits();
+                switch (aAttributeValue->m_aMovablelimits)
+                {
+                    case SmMlAttributeValueMovablelimits::MlFalse:
+                        addAttribute(XML_MOVABLELIMITS, XML_FALSE);
+                        break;
+                    case SmMlAttributeValueMovablelimits::MlTrue:
+                        addAttribute(XML_MOVABLELIMITS, XML_TRUE);
+                        break;
+                    default:
+                        declareMlError();
+                        break;
+                }
+                break;
+            }
+            case SmMlAttributeValueType::MlRspace:
+            {
+                auto aSizeData = aAttribute.getMlRspace();
+                auto aLengthData = aSizeData->m_aLengthValue;
+                exportMlAttributeLength(XML_RSPACE, aLengthData);
+                break;
+            }
+            case SmMlAttributeValueType::MlSeparator:
+            {
+                auto aAttributeValue = aAttribute.getMlSeparator();
+                switch (aAttributeValue->m_aSeparator)
+                {
+                    case SmMlAttributeValueSeparator::MlFalse:
+                        addAttribute(XML_SEPARATOR, XML_FALSE);
+                        break;
+                    case SmMlAttributeValueSeparator::MlTrue:
+                        addAttribute(XML_SEPARATOR, XML_TRUE);
+                        break;
+                    default:
+                        declareMlError();
+                        break;
+                }
+                break;
+            }
+            case SmMlAttributeValueType::MlStretchy:
+            {
+                auto aAttributeValue = aAttribute.getMlStretchy();
+                switch (aAttributeValue->m_aStretchy)
+                {
+                    case SmMlAttributeValueStretchy::MlFalse:
+                        addAttribute(XML_STRETCHY, XML_FALSE);
+                        break;
+                    case SmMlAttributeValueStretchy::MlTrue:
+                        addAttribute(XML_STRETCHY, XML_TRUE);
+                        break;
+                    default:
+                        declareMlError();
+                        break;
+                }
+                break;
+            }
+            case SmMlAttributeValueType::MlSymmetric:
+            {
+                auto aAttributeValue = aAttribute.getMlSymmetric();
+                switch (aAttributeValue->m_aSymmetric)
+                {
+                    case SmMlAttributeValueSymmetric::MlFalse:
+                        addAttribute(XML_SYMMETRIC, XML_FALSE);
+                        break;
+                    case SmMlAttributeValueSymmetric::MlTrue:
+                        addAttribute(XML_SYMMETRIC, XML_TRUE);
+                        break;
+                    default:
+                        declareMlError();
+                        break;
+                }
+                break;
+            }
+            default:
+                declareMlError();
+                break;
+        }
+    }
+}
+
+SvXMLElementExport* SmMLExport::exportMlElement(const SmMlElement* pMlElement)
+{
+    SvXMLElementExport* pElementExport;
+    switch (pMlElement->getMlElementType())
+    {
+        case SmMlElementType::MlMath:
+            pElementExport = createElementExport(XML_MATH);
+            break;
+        case SmMlElementType::MlMi:
+            pElementExport = createElementExport(XML_MI);
+            break;
+        case SmMlElementType::MlMerror:
+            pElementExport = createElementExport(XML_MERROR);
+            break;
+        case SmMlElementType::MlMn:
+            pElementExport = createElementExport(XML_MN);
+            break;
+        case SmMlElementType::MlMo:
+            pElementExport = createElementExport(XML_MO);
+            break;
+        case SmMlElementType::MlMrow:
+            pElementExport = createElementExport(XML_MROW);
+            break;
+        case SmMlElementType::MlMtext:
+            pElementExport = createElementExport(XML_MTEXT);
+            break;
+        case SmMlElementType::MlMstyle:
+            pElementExport = createElementExport(XML_MSTYLE);
+            break;
+        default:
+            pElementExport = nullptr;
+    }
+    const OUString& aElementText = pMlElement->getText();
+    exportMlAttributes(pMlElement);
+    if (aElementText.isEmpty())
+        GetDocHandler()->characters(aElementText);
+    return pElementExport;
+}
+
+namespace
+{
+struct exportMlElementTreeExecData
+{
+private:
+    SmMLExport* m_pSmMLExport;
+    std::vector<SvXMLElementExport*> m_aSvXMLElementExportList;
+    size_t m_nDepth;
+
+public:
+    inline exportMlElementTreeExecData(SmMLExport* pSmMLExport)
+        : m_pSmMLExport(pSmMLExport)
+        , m_aSvXMLElementExportList(1024)
+        , m_nDepth(0)
+    {
+    }
+
+    inline void deleteDepthData()
+    {
+        delete m_aSvXMLElementExportList[m_nDepth];
+        --m_nDepth;
+    }
+
+    inline void setDepthData(SvXMLElementExport* aSvXMLElementExportList)
+    {
+        if (m_nDepth == m_aSvXMLElementExportList.size())
+            m_aSvXMLElementExportList.resize(m_aSvXMLElementExportList.size() + 1024);
+        m_aSvXMLElementExportList[m_nDepth] = aSvXMLElementExportList;
+    }
+
+    inline void incrementDepth() { ++m_nDepth; }
+
+    inline SmMLExport* getSmMLExport() { return m_pSmMLExport; };
+};
+
+} // end unnamed namespace
+
+static inline void exportMlElementTreeExec(SmMlElement* aSmMlElement, void* aData)
+{
+    // Prepare data
+    exportMlElementTreeExecData* pData = static_cast<exportMlElementTreeExecData*>(aData);
+    pData->setDepthData(pData->getSmMLExport()->exportMlElement(aSmMlElement));
+
+    // Prepare for following
+    // If it has sub elements, then it will be the next
+    if (aSmMlElement->getSubElementsCount() != 0)
+        pData->incrementDepth();
+    else // Otherwise remounts up to where it should be
+    {
+        while (aSmMlElement->getParentElement() != nullptr)
+        {
+            // get parent
+            SmMlElement* pParent = aSmMlElement->getParentElement();
+            pData->deleteDepthData();
+            // was this the last branch ?
+            if (aSmMlElement->getSubElementId() + 1 != pParent->getSubElementsCount()) // yes -> up
+                break; // no -> stop going up
+            // Prepare for next round
+            aSmMlElement = pParent;
+        }
+    }
+}
+
+void SmMLExport::exportMlElementTree()
+{
+    exportMlElementTreeExecData* aData = new exportMlElementTreeExecData(this);
+    mathml::SmMlIteratorTopToBottom(m_pElementTree, exportMlElementTreeExec, aData);
+    delete aData;
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/starmath/source/mathml/import.cxx b/starmath/source/mathml/import.cxx
new file mode 100644
index 0000000000..d857e56930
--- /dev/null
+++ b/starmath/source/mathml/import.cxx
@@ -0,0 +1,1405 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4; fill-column: 100 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ */
+
+// Our mathml
+#include <mathml/import.hxx>
+
+// LO tools to use
+#include <com/sun/star/beans/PropertyAttribute.hpp>
+#include <com/sun/star/document/XDocumentPropertiesSupplier.hpp>
+#include <com/sun/star/embed/ElementModes.hpp>
+#include <com/sun/star/packages/WrongPasswordException.hpp>
+#include <com/sun/star/packages/zip/ZipIOException.hpp>
+#include <com/sun/star/task/XStatusIndicator.hpp>
+#include <com/sun/star/xml/sax/FastParser.hpp>
+#include <com/sun/star/xml/sax/InputSource.hpp>
+#include <com/sun/star/xml/sax/Parser.hpp>
+#include <com/sun/star/xml/sax/SAXParseException.hpp>
+
+// Extra LO tools
+#include <comphelper/fileformat.h>
+#include <comphelper/genericpropertyset.hxx>
+#include <comphelper/processfactory.hxx>
+#include <comphelper/propertysetinfo.hxx>
+#include <comphelper/servicehelper.hxx>
+#include <rtl/character.hxx>
+#include <sfx2/docfile.hxx>
+#include <sfx2/frame.hxx>
+#include <sfx2/sfxsids.hrc>
+#include <sot/storage.hxx>
+#include <svtools/sfxecode.hxx>
+#include <svl/itemset.hxx>
+#include <svl/stritem.hxx>
+#include <svx/dialmgr.hxx>
+#include <svx/strings.hrc>
+#include <unotools/streamwrap.hxx>
+#include <xmloff/DocumentSettingsContext.hxx>
+#include <xmloff/xmlmetai.hxx>
+#include <xmloff/xmlnamespace.hxx>
+#include <xmloff/xmltoken.hxx>
+#include <o3tl/string_view.hxx>
+
+// Our starmath tools
+#include <cfgitem.hxx>
+#include <document.hxx>
+#include <xparsmlbase.hxx>
+#include <smmod.hxx>
+#include <starmathdatabase.hxx>
+#include <unomodel.hxx>
+
+// Old parser
+#include <mathmlimport.hxx>
+
+using namespace ::com::sun::star;
+using namespace ::com::sun::star::beans;
+using namespace ::com::sun::star::container;
+using namespace ::com::sun::star::document;
+using namespace ::com::sun::star::lang;
+using namespace ::com::sun::star::uno;
+using namespace com::sun::star::xml::sax;
+using namespace ::xmloff::token;
+
+// SmMLImportContext
+/*************************************************************************************************/
+
+SmMlElement* SmMLImportWrapper::getElementTree()
+{
+    return m_pMlImport == nullptr ? nullptr : m_pMlImport->getElementTree();
+}
+
+ErrCode SmMLImportWrapper::Import(SfxMedium& rMedium)
+{
+    // Fetch context
+    uno::Reference<uno::XComponentContext> xContext(comphelper::getProcessComponentContext());
+    if (!xContext.is())
+    {
+        SAL_WARN("starmath", "Failed to fetch model while file input");
+        return ERRCODE_SFX_DOLOADFAILED;
+    }
+
+    // Check model
+    if (!m_xModel.is())
+    {
+        SAL_WARN("starmath", "Failed to fetch model while file input");
+        return ERRCODE_SFX_DOLOADFAILED;
+    }
+
+    // Try to get an XStatusIndicator from the Medium
+    uno::Reference<task::XStatusIndicator> xStatusIndicator;
+
+    // Get model via uno
+    SmModel* pModel = m_xModel.get();
+    if (pModel == nullptr)
+    {
+        SAL_WARN("starmath", "Failed to fetch sm model while file input");
+        return ERRCODE_SFX_DOLOADFAILED;
+    }
+
+    // Get doc shell
+    m_pDocShell = static_cast<SmDocShell*>(pModel->GetObjectShell());
+    if (m_pDocShell == nullptr)
+    {
+        SAL_WARN("starmath", "Failed to fetch smdoc shell while file input");
+        return ERRCODE_SFX_DOLOADFAILED;
+    }
+
+    // Check if it is an embed object
+    bool bEmbedded = m_pDocShell->GetCreateMode() == SfxObjectCreateMode::EMBEDDED;
+
+    if (!bEmbedded)
+    {
+        // Extra check to ensure everything is fine
+        if (m_pDocShell->GetMedium() != &rMedium)
+        {
+            SAL_WARN("starmath", "Given medium and doc shell medium differ while file input");
+            return ERRCODE_SFX_DOLOADFAILED;
+        }
+
+        // Fetch the item set
+        const SfxUnoAnyItem* pItem = rMedium.GetItemSet().GetItem(SID_PROGRESS_STATUSBAR_CONTROL);
+        if (pItem != nullptr)
+            pItem->GetValue() >>= xStatusIndicator;
+    }
+
+    // Create property list
+    static const comphelper::PropertyMapEntry aInfoMap[]
+        = { { u"PrivateData"_ustr, 0, cppu::UnoType<XInterface>::get(),
+              beans::PropertyAttribute::MAYBEVOID, 0 },
+            { u"BaseURI"_ustr, 0, ::cppu::UnoType<OUString>::get(),
+              beans::PropertyAttribute::MAYBEVOID, 0 },
+            { u"StreamRelPath"_ustr, 0, ::cppu::UnoType<OUString>::get(),
+              beans::PropertyAttribute::MAYBEVOID, 0 },
+            { u"StreamName"_ustr, 0, ::cppu::UnoType<OUString>::get(),
+              beans::PropertyAttribute::MAYBEVOID, 0 } };
+    uno::Reference<beans::XPropertySet> xInfoSet(
+        comphelper::GenericPropertySet_CreateInstance(new comphelper::PropertySetInfo(aInfoMap)));
+
+    // Set base URI
+    // needed for relative URLs; but it's OK to import e.g. MathML from the clipboard without one
+    SAL_INFO_IF(rMedium.GetBaseURL().isEmpty(), "starmath", "SmMLImportWrapper: no base URL");
+    xInfoSet->setPropertyValue("BaseURI", Any(rMedium.GetBaseURL()));
+
+    // Fetch progress range
+    sal_Int32 nProgressRange(rMedium.IsStorage() ? 3 : 1);
+    if (xStatusIndicator.is())
+    {
+        xStatusIndicator->start(SvxResId(RID_SVXSTR_DOC_LOAD), nProgressRange);
+        xStatusIndicator->setValue(0);
+    }
+
+    // Get storage
+    if (rMedium.IsStorage())
+    {
+        // TODO/LATER: handle the case of embedded links gracefully
+        if (bEmbedded) // && !rMedium.GetStorage()->IsRoot() )
+        {
+            OUString aName(u"dummyObjName"_ustr);
+            const SfxStringItem* pDocHierarchItem
+                = rMedium.GetItemSet().GetItem(SID_DOC_HIERARCHICALNAME);
+            if (pDocHierarchItem != nullptr)
+                aName = pDocHierarchItem->GetValue();
+
+            if (!aName.isEmpty())
+                xInfoSet->setPropertyValue("StreamRelPath", Any(aName));
+        }
+
+        // Check if use OASIS ( new document format )
+        bool bOASIS = SotStorage::GetVersion(rMedium.GetStorage()) > SOFFICE_FILEFORMAT_60;
+        if (xStatusIndicator.is())
+            xStatusIndicator->setValue(1);
+
+        // Error code in case of needed
+        ErrCode nWarn = ERRCODE_NONE;
+
+        // Read metadata
+        // read a component from storage
+        if (!bEmbedded)
+        {
+            if (bOASIS)
+                nWarn = ReadThroughComponentS(rMedium.GetStorage(), m_xModel, u"meta.xml", xContext,
+                                              xInfoSet,
+                                              u"com.sun.star.comp.Math.MLOasisMetaImporter", 6);
+            else
+                nWarn
+                    = ReadThroughComponentS(rMedium.GetStorage(), m_xModel, u"meta.xml", xContext,
+                                            xInfoSet, u"com.sun.star.comp.Math.XMLMetaImporter", 5);
+        }
+
+        // Check if successful
+        if (nWarn != ERRCODE_NONE)
+        {
+            if (xStatusIndicator.is())
+                xStatusIndicator->end();
+            SAL_WARN("starmath", "Failed to read file");
+            return nWarn;
+        }
+
+        // Increase success indicator
+        if (xStatusIndicator.is())
+            xStatusIndicator->setValue(2);
+
+        // Read settings
+        // read a component from storage
+        if (bOASIS)
+            nWarn = ReadThroughComponentS(rMedium.GetStorage(), m_xModel, u"settings.xml", xContext,
+                                          xInfoSet,
+                                          u"com.sun.star.comp.Math.MLOasisSettingsImporter", 6);
+        else
+            nWarn
+                = ReadThroughComponentS(rMedium.GetStorage(), m_xModel, u"settings.xml", xContext,
+                                        xInfoSet, u"com.sun.star.comp.Math.XMLSettingsImporter", 5);
+
+        // Check if successful
+        if (nWarn != ERRCODE_NONE)
+        {
+            if (xStatusIndicator.is())
+                xStatusIndicator->end();
+            SAL_WARN("starmath", "Failed to read file");
+            return nWarn;
+        }
+
+        // Increase success indicator
+        if (xStatusIndicator.is())
+            xStatusIndicator->setValue(3);
+
+        // Read document
+        // read a component from storage
+        if (m_pDocShell->GetSmSyntaxVersion() == 5)
+            nWarn = ReadThroughComponentS(rMedium.GetStorage(), m_xModel, u"content.xml", xContext,
+                                          xInfoSet, u"com.sun.star.comp.Math.XMLImporter", 5);
+        else
+            nWarn = ReadThroughComponentS(rMedium.GetStorage(), m_xModel, u"content.xml", xContext,
+                                          xInfoSet, u"com.sun.star.comp.Math.MLImporter", 6);
+        // Check if successful
+        if (nWarn != ERRCODE_NONE)
+        {
+            if (xStatusIndicator.is())
+                xStatusIndicator->end();
+            SAL_WARN("starmath", "Failed to read file");
+            return nWarn;
+        }
+
+        // Finish
+        if (xStatusIndicator.is())
+            xStatusIndicator->end();
+        return ERRCODE_NONE;
+    }
+    else
+    {
+        // Create input stream
+        Reference<io::XInputStream> xInputStream
+            = new utl::OInputStreamWrapper(rMedium.GetInStream());
+
+        // Increase success indicator
+        if (xStatusIndicator.is())
+            xStatusIndicator->setValue(1);
+
+        // Read data
+        // read a component from input stream
+        ErrCode nError = ERRCODE_NONE;
+        if (m_pDocShell->GetSmSyntaxVersion() == 5)
+            nError = ReadThroughComponentIS(xInputStream, m_xModel, xContext, xInfoSet,
+                                            u"com.sun.star.comp.Math.XMLImporter", false, 5);
+        else
+            nError = ReadThroughComponentIS(xInputStream, m_xModel, xContext, xInfoSet,
+                                            u"com.sun.star.comp.Math.MLImporter", false, 6);
+
+        // Finish
+        if (xStatusIndicator.is())
+            xStatusIndicator->end();
+
+        // Declare any error
+        if (nError != ERRCODE_NONE)
+            SAL_WARN("starmath", "Failed to read file");
+
+        return nError;
+    }
+}
+
+ErrCode SmMLImportWrapper::Import(std::u16string_view aSource)
+{
+    // Fetch context
+    uno::Reference<uno::XComponentContext> xContext(comphelper::getProcessComponentContext());
+    if (!xContext.is())
+    {
+        SAL_WARN("starmath", "Failed to fetch model while file input");
+        return ERRCODE_SFX_DOLOADFAILED;
+    }
+
+    // Check model
+    if (!m_xModel.is())
+    {
+        SAL_WARN("starmath", "Failed to fetch model while file input");
+        return ERRCODE_SFX_DOLOADFAILED;
+    }
+
+    // Make a model component from our SmModel
+    uno::Reference<lang::XComponent> xModelComp = m_xModel;
+    if (!xModelComp.is())
+    {
+        SAL_WARN("starmath", "Failed to make model while file input");
+        return ERRCODE_SFX_DOLOADFAILED;
+    }
+
+    // Get model via uno
+    SmModel* pModel = m_xModel.get();
+    if (pModel == nullptr)
+    {
+        SAL_WARN("starmath", "Failed to fetch sm model while file input");
+        return ERRCODE_SFX_DOLOADFAILED;
+    }
+
+    // Get doc shell
+    m_pDocShell = static_cast<SmDocShell*>(pModel->GetObjectShell());
+    if (m_pDocShell == nullptr)
+    {
+        SAL_WARN("starmath", "Failed to fetch smdoc shell while file input");
+        return ERRCODE_SFX_DOLOADFAILED;
+    }
+
+    // Create property list
+    static const comphelper::PropertyMapEntry aInfoMap[]
+        = { { u"PrivateData"_ustr, 0, cppu::UnoType<XInterface>::get(),
+              beans::PropertyAttribute::MAYBEVOID, 0 },
+            { u"BaseURI"_ustr, 0, ::cppu::UnoType<OUString>::get(),
+              beans::PropertyAttribute::MAYBEVOID, 0 },
+            { u"StreamRelPath"_ustr, 0, ::cppu::UnoType<OUString>::get(),
+              beans::PropertyAttribute::MAYBEVOID, 0 },
+            { u"StreamName"_ustr, 0, ::cppu::UnoType<OUString>::get(),
+              beans::PropertyAttribute::MAYBEVOID, 0 } };
+    uno::Reference<beans::XPropertySet> xInfoSet(
+        comphelper::GenericPropertySet_CreateInstance(new comphelper::PropertySetInfo(aInfoMap)));
+
+    // Read data
+    // read a component from text
+    ErrCode nError = ReadThroughComponentMS(aSource, xModelComp, xContext, xInfoSet);
+
+    // Declare any error
+    if (nError != ERRCODE_NONE)
+    {
+        SAL_WARN("starmath", "Failed to read file");
+        return nError;
+    }
+
+    return ERRCODE_NONE;
+}
+
+// read a component from input stream
+ErrCode SmMLImportWrapper::ReadThroughComponentIS(
+    const Reference<io::XInputStream>& xInputStream, const Reference<XComponent>& xModelComponent,
+    Reference<uno::XComponentContext> const& rxContext,
+    Reference<beans::XPropertySet> const& rPropSet, const char16_t* pFilterName, bool bEncrypted,
+    int_fast16_t nSyntaxVersion)
+{
+    // Needs an input stream but checked by caller
+    // Needs a context but checked by caller
+    // Needs property set but checked by caller
+    // Needs a filter name but checked by caller
+
+    // Prepare ParserInputSource
+    xml::sax::InputSource aParserInput;
+    aParserInput.aInputStream = xInputStream;
+
+    // Prepare property list
+    Sequence<Any> aArgs{ Any(rPropSet) };
+
+    // Get filter
+    Reference<XInterface> xFilter
+        = rxContext->getServiceManager()->createInstanceWithArgumentsAndContext(
+            OUString(pFilterName), aArgs, rxContext);
+    if (!xFilter.is())
+    {
+        SAL_WARN("starmath", "Can't instantiate filter component " << OUString(pFilterName));
+        return ERRCODE_SFX_DOLOADFAILED;
+    }
+
+    // Connect model and filter
+    Reference<XImporter> xImporter(xFilter, UNO_QUERY);
+    xImporter->setTargetDocument(xModelComponent);
+
+    // Finally, parser the stream
+    try
+    {
+        Reference<css::xml::sax::XFastParser> xFastParser(xFilter, UNO_QUERY);
+        Reference<css::xml::sax::XFastDocumentHandler> xFastDocHandler(xFilter, UNO_QUERY);
+        if (xFastParser)
+        {
+            xFastParser->setCustomEntityNames(starmathdatabase::icustomMathmlHtmlEntities);
+            xFastParser->parseStream(aParserInput);
+        }
+        else if (xFastDocHandler)
+        {
+            Reference<css::xml::sax::XFastParser> xParser
+                = css::xml::sax::FastParser::create(rxContext);
+            xParser->setCustomEntityNames(starmathdatabase::icustomMathmlHtmlEntities);
+            xParser->setFastDocumentHandler(xFastDocHandler);
+            xParser->parseStream(aParserInput);
+        }
+        else
+        {
+            Reference<css::xml::sax::XDocumentHandler> xDocHandler(xFilter, UNO_QUERY);
+            assert(xDocHandler);
+            Reference<css::xml::sax::XParser> xParser = css::xml::sax::Parser::create(rxContext);
+            xParser->setDocumentHandler(xDocHandler);
+            xParser->parseStream(aParserInput);
+        }
+
+        if (nSyntaxVersion == 5)
+        {
+            SmXMLImport* pXMlImport = dynamic_cast<SmXMLImport*>(xFilter.get());
+            if (pXMlImport != nullptr && pXMlImport->GetSuccess())
+                return ERRCODE_NONE;
+            else
+            {
+                SAL_WARN("starmath", "Filter failed on file input");
+                // However this can not be included since it's not public
+                if (pXMlImport == nullptr)
+                    return ERRCODE_NONE;
+                return ERRCODE_SFX_DOLOADFAILED;
+            }
+        }
+
+        m_pMlImport = dynamic_cast<SmMLImport*>(xFilter.get());
+        if (m_pMlImport != nullptr && m_pMlImport->getSuccess())
+            return ERRCODE_NONE;
+        else
+        {
+            SAL_WARN("starmath", "Filter failed on file input");
+            return ERRCODE_SFX_DOLOADFAILED;
+        }
+    }
+    catch (const xml::sax::SAXParseException& r)
+    {
+        // Sax parser sends wrapped exceptions, try to find the original one
+        xml::sax::SAXException aTmp;
+        xml::sax::SAXException aSaxEx = *static_cast<const xml::sax::SAXException*>(&r);
+        while (aSaxEx.WrappedException >>= aTmp)
+            aSaxEx = aTmp;
+
+        packages::zip::ZipIOException aBrokenPackage;
+        if (aSaxEx.WrappedException >>= aBrokenPackage)
+        {
+            SAL_WARN("starmath", "Failed to read file SAXParseException");
+            return ERRCODE_IO_BROKENPACKAGE;
+        }
+
+        if (bEncrypted)
+        {
+            SAL_WARN("starmath", "Wrong file password SAXParseException");
+            return ERRCODE_SFX_WRONGPASSWORD;
+        }
+    }
+    catch (const xml::sax::SAXException& r)
+    {
+        packages::zip::ZipIOException aBrokenPackage;
+        if (r.WrappedException >>= aBrokenPackage)
+        {
+            SAL_WARN("starmath", "Failed to read file SAXException");
+            return ERRCODE_IO_BROKENPACKAGE;
+        }
+
+        if (bEncrypted)
+        {
+            SAL_WARN("starmath", "Wrong file password SAXException");
+            return ERRCODE_SFX_WRONGPASSWORD;
+        }
+    }
+    catch (const packages::zip::ZipIOException&)
+    {
+        SAL_WARN("starmath", "Failed to unzip file ZipIOException");
+        return ERRCODE_IO_BROKENPACKAGE;
+    }
+    catch (const io::IOException&)
+    {
+        SAL_WARN("starmath", "Failed to read file ZipIOException");
+        return ERRCODE_IO_UNKNOWN;
+    }
+    catch (const std::range_error&)
+    {
+        SAL_WARN("starmath", "Failed to read file");
+        return ERRCODE_ABORT;
+    }
+
+    return ERRCODE_ABORT;
+}
+
+// read a component from storage
+ErrCode SmMLImportWrapper::ReadThroughComponentS(const uno::Reference<embed::XStorage>& xStorage,
+                                                 const Reference<XComponent>& xModelComponent,
+                                                 const char16_t* pStreamName,
+                                                 Reference<uno::XComponentContext> const& rxContext,
+                                                 Reference<beans::XPropertySet> const& rPropSet,
+                                                 const char16_t* pFilterName,
+                                                 int_fast16_t nSyntaxVersion)
+{
+    // Needs a storage but checked by caller
+    // Needs a model but checked by caller
+    // Needs a stream name but checked by caller
+    // Needs a context but checked by caller
+    // Needs a property set but checked by caller
+    // Needs a filter name but checked by caller
+
+    // Get the input stream
+    try
+    {
+        // Create the stream for the event read
+        uno::Reference<io::XStream> xEventsStream
+            = xStorage->openStreamElement(OUString(pStreamName), embed::ElementModes::READ);
+
+        // Determine if stream is encrypted or not
+        uno::Reference<beans::XPropertySet> xProps(xEventsStream, uno::UNO_QUERY);
+        Any aAny = xProps->getPropertyValue("Encrypted");
+        bool bEncrypted = false;
+        aAny >>= bEncrypted;
+
+        // Set base URL and open stream
+        rPropSet->setPropertyValue("StreamName", Any(OUString(pStreamName)));
+        Reference<io::XInputStream> xStream = xEventsStream->getInputStream();
+
+        // Execute read
+        return ReadThroughComponentIS(xStream, xModelComponent, rxContext, rPropSet, pFilterName,
+                                      bEncrypted, nSyntaxVersion);
+    }
+    catch (packages::WrongPasswordException&)
+    {
+        SAL_WARN("starmath", "Wrong file password");
+        return ERRCODE_SFX_WRONGPASSWORD;
+    }
+    catch (packages::zip::ZipIOException&)
+    {
+        SAL_WARN("starmath", "Failed to unzip file");
+        return ERRCODE_IO_BROKENPACKAGE;
+    }
+    catch (uno::Exception&)
+    {
+    }
+
+    return ERRCODE_SFX_DOLOADFAILED;
+}
+
+// read a component from text
+ErrCode SmMLImportWrapper::ReadThroughComponentMS(
+    std::u16string_view aText, const css::uno::Reference<css::lang::XComponent>& xModelComponent,
+    css::uno::Reference<css::uno::XComponentContext> const& rxContext,
+    css::uno::Reference<css::beans::XPropertySet> const& rPropSet)
+{
+    // Needs a storage but checked by caller
+    // Needs a model but checked by caller
+    // Needs a stream name but checked by caller
+    // Needs a context but checked by caller
+    // Needs a property set but checked by caller
+    // Needs a filter name but checked by caller
+
+    // Get the input stream
+    try
+    {
+        // Generate input memory stream
+        SvMemoryStream aMemoryStream;
+        aMemoryStream.WriteOString(OUStringToOString(aText, RTL_TEXTENCODING_UTF8));
+        uno::Reference<io::XInputStream> xStream(new utl::OInputStreamWrapper(aMemoryStream));
+
+        // Execute read
+        return ReadThroughComponentIS(xStream, xModelComponent, rxContext, rPropSet,
+                                      u"com.sun.star.comp.Math.MLImporter", false, 6);
+    }
+    catch (packages::WrongPasswordException&)
+    {
+        SAL_WARN("starmath", "Wrong file password");
+        return ERRCODE_SFX_WRONGPASSWORD;
+    }
+    catch (packages::zip::ZipIOException&)
+    {
+        SAL_WARN("starmath", "Failed to unzip file");
+        return ERRCODE_IO_BROKENPACKAGE;
+    }
+    catch (uno::Exception&)
+    {
+    }
+
+    return ERRCODE_SFX_DOLOADFAILED;
+}
+
+// SmMLImport technical
+/*************************************************************************************************/
+
+extern "C" SAL_DLLPUBLIC_EXPORT uno::XInterface*
+Math_MLImporter_get_implementation(uno::XComponentContext* pCtx,
+                                   uno::Sequence<uno::Any> const& /*rSeq*/)
+{
+    return cppu::acquire(
+        new SmMLImport(pCtx, "com.sun.star.comp.Math.XMLImporter", SvXMLImportFlags::ALL));
+}
+
+extern "C" SAL_DLLPUBLIC_EXPORT uno::XInterface*
+Math_MLOasisMetaImporter_get_implementation(uno::XComponentContext* pCtx,
+                                            uno::Sequence<uno::Any> const& /*rSeq*/)
+{
+    return cppu::acquire(new SmMLImport(pCtx, "com.sun.star.comp.Math.XMLOasisMetaImporter",
+                                        SvXMLImportFlags::META));
+}
+
+extern "C" SAL_DLLPUBLIC_EXPORT uno::XInterface*
+Math_MLOasisSettingsImporter_get_implementation(uno::XComponentContext* pCtx,
+                                                uno::Sequence<uno::Any> const& /*rSeq*/)
+{
+    return cppu::acquire(new SmMLImport(pCtx, "com.sun.star.comp.Math.XMLOasisSettingsImporter",
+                                        SvXMLImportFlags::SETTINGS));
+}
+
+// SmMLImportContext
+/*************************************************************************************************/
+
+namespace
+{
+class SmMLImportContext : public SvXMLImportContext
+{
+private:
+    SmMlElement** m_pParent;
+    SmMlElement* m_pElement;
+    SmMlElement* m_pStyle;
+
+public:
+    SmMLImportContext(SmMLImport& rImport, SmMlElement** pParent)
+        : SvXMLImportContext(rImport)
+        , m_pParent(pParent)
+        , m_pElement(nullptr)
+        , m_pStyle(nullptr)
+    {
+    }
+
+private:
+    void declareMlError();
+
+public:
+    /** Handles characters (text)
+     */
+    virtual void SAL_CALL characters(const OUString& aChars) override;
+
+    /** Starts the mathml element
+     */
+    virtual void SAL_CALL startFastElement(
+        sal_Int32 nElement, const Reference<XFastAttributeList>& aAttributeList) override;
+
+    /** Ends the mathml element
+     */
+    virtual void SAL_CALL endFastElement(sal_Int32 Element) override;
+
+    /** Creates child element
+     */
+    virtual uno::Reference<XFastContextHandler>
+        SAL_CALL createFastChildContext(sal_Int32 nElement,
+                                        const uno::Reference<XFastAttributeList>& Attribs) override;
+
+    /** Inherits the style from it's parents
+    */
+    void inheritStyle();
+
+    /** Inherits the style from it's parents on end
+    */
+    void inheritStyleEnd();
+
+    /** Handle mathml attributes
+    */
+    void handleAttributes(const Reference<XFastAttributeList>& aAttributeList);
+
+    /** Handle mathml length attributes
+    */
+    SmLengthValue handleLengthAttribute(const OUString& aAttribute);
+};
+
+uno::Reference<XFastContextHandler> SAL_CALL
+SmMLImportContext::createFastChildContext(sal_Int32, const uno::Reference<XFastAttributeList>&)
+{
+    uno::Reference<xml::sax::XFastContextHandler> xContext;
+    xContext = new SmMLImportContext(static_cast<SmMLImport&>(GetImport()), &m_pElement);
+    return xContext;
+}
+
+void SmMLImportContext::declareMlError()
+{
+    SmMLImport& aSmMLImport = static_cast<SmMLImport&>(GetImport());
+    aSmMLImport.declareMlError();
+}
+
+void SmMLImportContext::inheritStyle()
+{
+    while ((m_pStyle = m_pStyle->getParentElement()) != nullptr)
+    {
+        if (m_pStyle->getParentElement()->getMlElementType() == SmMlElementType::MlMstyle
+            || m_pStyle->getParentElement()->getMlElementType() == SmMlElementType::MlMath)
+            break;
+    }
+
+    // Parent inheritation
+    // Mathcolor, mathsize, dir and displaystyle are inherited from parent
+    SmMlElement* pParent = *m_pParent;
+    m_pElement->setAttribute(pParent->getAttribute(SmMlAttributeValueType::MlMathcolor));
+    m_pElement->setAttribute(pParent->getAttribute(SmMlAttributeValueType::MlMathsize));
+    m_pElement->setAttribute(pParent->getAttribute(SmMlAttributeValueType::MlDir));
+    m_pElement->setAttribute(pParent->getAttribute(SmMlAttributeValueType::MlDisplaystyle));
+
+    // Inherit operator dictionary overwrites
+    if (m_pStyle != nullptr
+        && (m_pElement->getMlElementType() == SmMlElementType::MlMo
+            || m_pElement->getMlElementType() == SmMlElementType::MlMstyle
+            || m_pElement->getMlElementType() == SmMlElementType::MlMath))
+    {
+        // TODO fetch operator dictionary first and then overwrite
+        if (m_pStyle->isAttributeSet(SmMlAttributeValueType::MlAccent))
+            m_pElement->setAttribute(m_pStyle->getAttribute(SmMlAttributeValueType::MlAccent));
+        if (m_pStyle->isAttributeSet(SmMlAttributeValueType::MlFence))
+            m_pElement->setAttribute(m_pStyle->getAttribute(SmMlAttributeValueType::MlFence));
+        if (m_pStyle->isAttributeSet(SmMlAttributeValueType::MlLspace))
+            m_pElement->setAttribute(m_pStyle->getAttribute(SmMlAttributeValueType::MlLspace));
+        if (m_pStyle->isAttributeSet(SmMlAttributeValueType::MlMaxsize))
+            m_pElement->setAttribute(m_pStyle->getAttribute(SmMlAttributeValueType::MlMaxsize));
+        if (m_pStyle->isAttributeSet(SmMlAttributeValueType::MlMinsize))
+            m_pElement->setAttribute(m_pStyle->getAttribute(SmMlAttributeValueType::MlMinsize));
+        if (m_pStyle->isAttributeSet(SmMlAttributeValueType::MlMovablelimits))
+            m_pElement->setAttribute(
+                m_pStyle->getAttribute(SmMlAttributeValueType::MlMovablelimits));
+        if (m_pStyle->isAttributeSet(SmMlAttributeValueType::MlRspace))
+            m_pElement->setAttribute(m_pStyle->getAttribute(SmMlAttributeValueType::MlRspace));
+        if (m_pStyle->isAttributeSet(SmMlAttributeValueType::MlSeparator))
+            m_pElement->setAttribute(m_pStyle->getAttribute(SmMlAttributeValueType::MlSeparator));
+        if (m_pStyle->isAttributeSet(SmMlAttributeValueType::MlStretchy))
+            m_pElement->setAttribute(m_pStyle->getAttribute(SmMlAttributeValueType::MlStretchy));
+        if (m_pStyle->isAttributeSet(SmMlAttributeValueType::MlSymmetric))
+            m_pElement->setAttribute(m_pStyle->getAttribute(SmMlAttributeValueType::MlSymmetric));
+
+        if (m_pElement->getMlElementType() == SmMlElementType::MlMo)
+        {
+            // Set form based in position
+            SmMlAttribute aAttribute(SmMlAttributeValueType::MlForm);
+            SmMlForm aForm;
+            if (m_pElement->getSubElementId() == 0)
+                aForm = { SmMlAttributeValueForm::MlPrefix };
+            else
+                aForm = { SmMlAttributeValueForm::MlInfix };
+            aAttribute.setMlForm(&aForm);
+            m_pElement->setAttribute(aAttribute);
+        }
+    }
+
+    // Inherit mathvariant
+    if (m_pStyle && m_pStyle->isAttributeSet(SmMlAttributeValueType::MlMathvariant))
+        m_pElement->setAttribute(m_pStyle->getAttribute(SmMlAttributeValueType::MlMathvariant));
+}
+
+void SmMLImportContext::inheritStyleEnd()
+{
+    // Mo: check it is the end: postfix
+    if (m_pElement->getMlElementType() == SmMlElementType::MlMo)
+    {
+        if ((*m_pParent)->getSubElementsCount() == m_pElement->getSubElementId())
+        {
+            // Set form based in position
+            SmMlAttribute aAttribute(SmMlAttributeValueType::MlForm);
+            SmMlForm aForm = { SmMlAttributeValueForm::MlPosfix };
+            aAttribute.setMlForm(&aForm);
+            m_pElement->setAttribute(aAttribute);
+        }
+    }
+
+    // Mi: 1 char -> italic
+    if (m_pElement->getMlElementType() != SmMlElementType::MlMi)
+        return;
+
+    // Inherit mathvariant
+    if (!m_pStyle->isAttributeSet(SmMlAttributeValueType::MlMathvariant))
+    {
+        sal_Int32 nIndexUtf16 = 0;
+        // Check if there is only one code point
+        m_pElement->getText().iterateCodePoints(&nIndexUtf16, 1);
+        // Mathml says that 1 code point -> italic
+        if (nIndexUtf16 == m_pElement->getText().getLength())
+        {
+            SmMlAttribute aAttribute(SmMlAttributeValueType::MlMathvariant);
+            SmMlMathvariant aMathvariant = { SmMlAttributeValueMathvariant::italic };
+            aAttribute.setMlMathvariant(&aMathvariant);
+            aAttribute.setSet(false);
+            m_pElement->setAttribute(aAttribute);
+        }
+    }
+}
+
+SmLengthValue SmMLImportContext::handleLengthAttribute(const OUString& aAttribute)
+{
+    // Locate unit indication
+    int32_t nUnitPos;
+    for (nUnitPos = 0;
+         nUnitPos < aAttribute.getLength()
+         && (rtl::isAsciiHexDigit(aAttribute[nUnitPos]) || aAttribute[nUnitPos] == '.');
+         ++nUnitPos)
+        ;
+
+    // Find unit
+    SmLengthUnit nUnit = SmLengthUnit::MlM;
+    if (nUnitPos != aAttribute.getLength())
+    {
+        OUString aUnit = aAttribute.copy(nUnitPos);
+        if (aUnit.compareToIgnoreAsciiCaseAscii("ex"))
+            nUnit = SmLengthUnit::MlEx;
+        if (aUnit.compareToIgnoreAsciiCaseAscii("px"))
+            nUnit = SmLengthUnit::MlPx;
+        if (aUnit.compareToIgnoreAsciiCaseAscii("in"))
+            nUnit = SmLengthUnit::MlIn;
+        if (aUnit.compareToIgnoreAsciiCaseAscii("cm"))
+            nUnit = SmLengthUnit::MlCm;
+        if (aUnit.compareToIgnoreAsciiCaseAscii("mm"))
+            nUnit = SmLengthUnit::MlMm;
+        if (aUnit.compareToIgnoreAsciiCaseAscii("pt"))
+            nUnit = SmLengthUnit::MlPt;
+        if (aUnit.compareToIgnoreAsciiCaseAscii("pc"))
+            nUnit = SmLengthUnit::MlPc;
+        if (aUnit.compareToIgnoreAsciiCaseAscii("%"))
+            nUnit = SmLengthUnit::MlP;
+        else
+            declareMlError();
+    }
+
+    // Get value
+    std::u16string_view aValue = aAttribute.subView(0, nUnitPos);
+    double nValue = o3tl::toDouble(aValue);
+    if (nValue == 0)
+    {
+        nUnit = SmLengthUnit::MlM;
+        nValue = 1.0;
+        declareMlError();
+    }
+
+    // Return
+    SmLengthValue aLengthValue = { nUnit, nValue, new OUString(aAttribute) };
+    return aLengthValue;
+}
+
+void SmMLImportContext::handleAttributes(const Reference<XFastAttributeList>& aAttributeList)
+{
+    for (auto& aIter : sax_fastparser::castToFastAttributeList(aAttributeList))
+    {
+        SmMlAttribute aAttribute(SmMlAttributeValueType::NMlEmpty);
+        switch (aIter.getToken() & TOKEN_MASK)
+        {
+            case XML_ACCENT:
+            {
+                if (IsXMLToken(aIter, XML_TRUE))
+                {
+                    aAttribute.setMlAttributeValueType(SmMlAttributeValueType::MlAccent);
+                    SmMlAccent aAccent = { SmMlAttributeValueAccent::MlTrue };
+                    aAttribute.setMlAccent(&aAccent);
+                }
+                else if (IsXMLToken(aIter, XML_FALSE))
+                {
+                    aAttribute.setMlAttributeValueType(SmMlAttributeValueType::MlAccent);
+                    SmMlAccent aAccent = { SmMlAttributeValueAccent::MlFalse };
+                    aAttribute.setMlAccent(&aAccent);
+                }
+                else
+                {
+                    declareMlError();
+                }
+                break;
+            }
+            case XML_DIR:
+            {
+                if (IsXMLToken(aIter, XML_RTL))
+                {
+                    aAttribute.setMlAttributeValueType(SmMlAttributeValueType::MlDir);
+                    SmMlDir aDir = { SmMlAttributeValueDir::MlRtl };
+                    aAttribute.setMlDir(&aDir);
+                }
+                else if (IsXMLToken(aIter, XML_LTR))
+                {
+                    aAttribute.setMlAttributeValueType(SmMlAttributeValueType::MlDir);
+                    SmMlDir aDir = { SmMlAttributeValueDir::MlLtr };
+                    aAttribute.setMlDir(&aDir);
+                }
+                else
+                {
+                    declareMlError();
+                }
+                break;
+            }
+            case XML_DISPLAYSTYLE:
+                if (IsXMLToken(aIter, XML_TRUE))
+                {
+                    aAttribute.setMlAttributeValueType(SmMlAttributeValueType::MlDisplaystyle);
+                    SmMlDisplaystyle aDisplaystyle = { SmMlAttributeValueDisplaystyle::MlTrue };
+                    aAttribute.setMlDisplaystyle(&aDisplaystyle);
+                }
+                else if (IsXMLToken(aIter, XML_FALSE))
+                {
+                    aAttribute.setMlAttributeValueType(SmMlAttributeValueType::MlDisplaystyle);
+                    SmMlDisplaystyle aDisplaystyle = { SmMlAttributeValueDisplaystyle::MlFalse };
+                    aAttribute.setMlDisplaystyle(&aDisplaystyle);
+                }
+                else
+                {
+                    declareMlError();
+                }
+                break;
+            case XML_FENCE:
+                if (IsXMLToken(aIter, XML_TRUE))
+                {
+                    aAttribute.setMlAttributeValueType(SmMlAttributeValueType::MlFence);
+                    SmMlFence aFence = { SmMlAttributeValueFence::MlTrue };
+                    aAttribute.setMlFence(&aFence);
+                }
+                else if (IsXMLToken(aIter, XML_FALSE))
+                {
+                    aAttribute.setMlAttributeValueType(SmMlAttributeValueType::MlFence);
+                    SmMlFence aFence = { SmMlAttributeValueFence::MlFalse };
+                    aAttribute.setMlFence(&aFence);
+                }
+                else
+                {
+                    declareMlError();
+                }
+                break;
+            case XML_HREF:
+            {
+                aAttribute.setMlAttributeValueType(SmMlAttributeValueType::MlHref);
+                OUString* aRef = new OUString(aIter.toString());
+                SmMlHref aHref = { SmMlAttributeValueHref::NMlValid, aRef };
+                aAttribute.setMlHref(&aHref);
+                break;
+            }
+            case XML_LSPACE:
+            {
+                SmMlLspace aLspace;
+                aLspace.m_aLengthValue = handleLengthAttribute(aIter.toString());
+                aAttribute.setMlLspace(&aLspace);
+                break;
+            }
+            case XML_MATHBACKGROUND:
+            {
+                if (IsXMLToken(aIter, XML_TRANSPARENT))
+                {
+                    SmMlMathbackground aMathbackground
+                        = { SmMlAttributeValueMathbackground::MlTransparent, COL_TRANSPARENT };
+                    aAttribute.setMlMathbackground(&aMathbackground);
+                }
+                else
+                {
+                    Color aColor
+                        = starmathdatabase::Identify_ColorName_HTML(aIter.toString()).cColor;
+                    SmMlMathbackground aMathbackground
+                        = { SmMlAttributeValueMathbackground::MlRgb, aColor };
+                    aAttribute.setMlMathbackground(&aMathbackground);
+                }
+                break;
+            }
+            case XML_MATHCOLOR:
+            {
+                if (IsXMLToken(aIter, XML_DEFAULT))
+                {
+                    SmMlMathcolor aMathcolor
+                        = { SmMlAttributeValueMathcolor::MlDefault, COL_BLACK };
+                    aAttribute.setMlMathcolor(&aMathcolor);
+                }
+                else
+                {
+                    Color aColor
+                        = starmathdatabase::Identify_ColorName_HTML(aIter.toString()).cColor;
+                    SmMlMathcolor aMathcolor = { SmMlAttributeValueMathcolor::MlRgb, aColor };
+                    aAttribute.setMlMathcolor(&aMathcolor);
+                }
+                break;
+            }
+            case XML_MATHSIZE:
+            {
+                SmMlMathsize aMathsize;
+                aMathsize.m_aLengthValue = handleLengthAttribute(aIter.toString());
+                aAttribute.setMlMathsize(&aMathsize);
+                break;
+            }
+            case XML_MATHVARIANT:
+            {
+                OUString aVariant = aIter.toString();
+                SmMlAttributeValueMathvariant nVariant = SmMlAttributeValueMathvariant::normal;
+                if (aVariant.compareTo(u"normal"))
+                    nVariant = SmMlAttributeValueMathvariant::normal;
+                else if (aVariant.compareTo(u"bold"))
+                    nVariant = SmMlAttributeValueMathvariant::bold;
+                else if (aVariant.compareTo(u"italic"))
+                    nVariant = SmMlAttributeValueMathvariant::italic;
+                else if (aVariant.compareTo(u"double-struck"))
+                    nVariant = SmMlAttributeValueMathvariant::double_struck;
+                else if (aVariant.compareTo(u"script"))
+                    nVariant = SmMlAttributeValueMathvariant::script;
+                else if (aVariant.compareTo(u"fraktur"))
+                    nVariant = SmMlAttributeValueMathvariant::fraktur;
+                else if (aVariant.compareTo(u"sans-serif"))
+                    nVariant = SmMlAttributeValueMathvariant::sans_serif;
+                else if (aVariant.compareTo(u"monospace"))
+                    nVariant = SmMlAttributeValueMathvariant::monospace;
+                else if (aVariant.compareTo(u"bold-italic"))
+                    nVariant = SmMlAttributeValueMathvariant::bold_italic;
+                else if (aVariant.compareTo(u"bold-fracktur"))
+                    nVariant = SmMlAttributeValueMathvariant::bold_fraktur;
+                else if (aVariant.compareTo(u"bold-script"))
+                    nVariant = SmMlAttributeValueMathvariant::bold_script;
+                else if (aVariant.compareTo(u"bold-sans-serif"))
+                    nVariant = SmMlAttributeValueMathvariant::bold_sans_serif;
+                else if (aVariant.compareTo(u"sans-serif-italic"))
+                    nVariant = SmMlAttributeValueMathvariant::sans_serif_italic;
+                else if (aVariant.compareTo(u"sans-serif-bold-italic"))
+                    nVariant = SmMlAttributeValueMathvariant::sans_serif_bold_italic;
+                else if (aVariant.compareTo(u"initial"))
+                    nVariant = SmMlAttributeValueMathvariant::initial;
+                else if (aVariant.compareTo(u"tailed"))
+                    nVariant = SmMlAttributeValueMathvariant::tailed;
+                else if (aVariant.compareTo(u"looped"))
+                    nVariant = SmMlAttributeValueMathvariant::looped;
+                else if (aVariant.compareTo(u"stretched"))
+                    nVariant = SmMlAttributeValueMathvariant::stretched;
+                else
+                    declareMlError();
+                SmMlMathvariant aMathvariant = { nVariant };
+                aAttribute.setMlMathvariant(&aMathvariant);
+                break;
+            }
+            case XML_MAXSIZE:
+            {
+                SmMlMaxsize aMaxsize;
+                if (IsXMLToken(aIter, XML_INFINITY))
+                {
+                    aMaxsize.m_aMaxsize = SmMlAttributeValueMaxsize::MlInfinity;
+                    aMaxsize.m_aLengthValue
+                        = { SmLengthUnit::MlP, 10000, new OUString(u"10000%"_ustr) };
+                }
+                else
+                {
+                    aMaxsize.m_aMaxsize = SmMlAttributeValueMaxsize::MlFinite;
+                    aMaxsize.m_aLengthValue = handleLengthAttribute(aIter.toString());
+                }
+                aAttribute.setMlMaxsize(&aMaxsize);
+                break;
+            }
+            case XML_MINSIZE:
+            {
+                SmMlMinsize aMinsize;
+                aMinsize.m_aLengthValue = handleLengthAttribute(aIter.toString());
+                aAttribute.setMlMinsize(&aMinsize);
+                break;
+            }
+            case XML_MOVABLELIMITS:
+                if (IsXMLToken(aIter, XML_TRUE))
+                {
+                    aAttribute.setMlAttributeValueType(SmMlAttributeValueType::MlMovablelimits);
+                    SmMlMovablelimits aMovablelimits = { SmMlAttributeValueMovablelimits::MlTrue };
+                    aAttribute.setMlMovablelimits(&aMovablelimits);
+                }
+                else if (IsXMLToken(aIter, XML_FALSE))
+                {
+                    aAttribute.setMlAttributeValueType(SmMlAttributeValueType::MlMovablelimits);
+                    SmMlMovablelimits aMovablelimits = { SmMlAttributeValueMovablelimits::MlFalse };
+                    aAttribute.setMlMovablelimits(&aMovablelimits);
+                }
+                else
+                {
+                    declareMlError();
+                }
+                break;
+            case XML_RSPACE:
+            {
+                SmMlRspace aRspace;
+                aRspace.m_aLengthValue = handleLengthAttribute(aIter.toString());
+                aAttribute.setMlRspace(&aRspace);
+                break;
+            }
+            case XML_SEPARATOR:
+                if (IsXMLToken(aIter, XML_TRUE))
+                {
+                    aAttribute.setMlAttributeValueType(SmMlAttributeValueType::MlSeparator);
+                    SmMlSeparator aSeparator = { SmMlAttributeValueSeparator::MlTrue };
+                    aAttribute.setMlSeparator(&aSeparator);
+                }
+                else if (IsXMLToken(aIter, XML_FALSE))
+                {
+                    aAttribute.setMlAttributeValueType(SmMlAttributeValueType::MlSeparator);
+                    SmMlSeparator aSeparator = { SmMlAttributeValueSeparator::MlFalse };
+                    aAttribute.setMlSeparator(&aSeparator);
+                }
+                else
+                {
+                    declareMlError();
+                }
+                break;
+            case XML_STRETCHY:
+                if (IsXMLToken(aIter, XML_TRUE))
+                {
+                    aAttribute.setMlAttributeValueType(SmMlAttributeValueType::MlStretchy);
+                    SmMlStretchy aStretchy = { SmMlAttributeValueStretchy::MlTrue };
+                    aAttribute.setMlStretchy(&aStretchy);
+                }
+                else if (IsXMLToken(aIter, XML_FALSE))
+                {
+                    aAttribute.setMlAttributeValueType(SmMlAttributeValueType::MlStretchy);
+                    SmMlStretchy aStretchy = { SmMlAttributeValueStretchy::MlFalse };
+                    aAttribute.setMlStretchy(&aStretchy);
+                }
+                else
+                {
+                    declareMlError();
+                }
+                break;
+            case XML_SYMMETRIC:
+                if (IsXMLToken(aIter, XML_TRUE))
+                {
+                    aAttribute.setMlAttributeValueType(SmMlAttributeValueType::MlSymmetric);
+                    SmMlSymmetric aSymmetric = { SmMlAttributeValueSymmetric::MlTrue };
+                    aAttribute.setMlSymmetric(&aSymmetric);
+                }
+                else if (IsXMLToken(aIter, XML_FALSE))
+                {
+                    aAttribute.setMlAttributeValueType(SmMlAttributeValueType::MlSymmetric);
+                    SmMlSymmetric aSymmetric = { SmMlAttributeValueSymmetric::MlFalse };
+                    aAttribute.setMlSymmetric(&aSymmetric);
+                }
+                else
+                {
+                    declareMlError();
+                }
+                break;
+            default:
+                declareMlError();
+                break;
+        }
+        if (aAttribute.isNullAttribute())
+            declareMlError();
+        else
+            m_pElement->setAttribute(aAttribute);
+    }
+}
+
+void SmMLImportContext::characters(const OUString& aChars) { m_pElement->setText(aChars); }
+
+void SmMLImportContext::startFastElement(sal_Int32 nElement,
+                                         const Reference<XFastAttributeList>& aAttributeList)
+{
+    switch (nElement)
+    {
+        case XML_ELEMENT(MATH, XML_MATH):
+            m_pElement = new SmMlElement(SmMlElementType::MlMath);
+            break;
+        case XML_ELEMENT(MATH, XML_MI):
+            m_pElement = new SmMlElement(SmMlElementType::MlMi);
+            break;
+        case XML_ELEMENT(MATH, XML_MERROR):
+            m_pElement = new SmMlElement(SmMlElementType::MlMerror);
+            break;
+        case XML_ELEMENT(MATH, XML_MN):
+            m_pElement = new SmMlElement(SmMlElementType::MlMn);
+            break;
+        case XML_ELEMENT(MATH, XML_MO):
+            m_pElement = new SmMlElement(SmMlElementType::MlMo);
+            break;
+        case XML_ELEMENT(MATH, XML_MROW):
+            m_pElement = new SmMlElement(SmMlElementType::MlMrow);
+            break;
+        case XML_ELEMENT(MATH, XML_MTEXT):
+            m_pElement = new SmMlElement(SmMlElementType::MlMtext);
+            break;
+        case XML_ELEMENT(MATH, XML_MSTYLE):
+            m_pElement = new SmMlElement(SmMlElementType::MlMstyle);
+            break;
+        default:
+            m_pElement = new SmMlElement(SmMlElementType::NMlEmpty);
+            declareMlError();
+            break;
+    }
+    SmMlElement* pParent = *m_pParent;
+    pParent->setSubElement(pParent->getSubElementsCount(), m_pElement);
+    inheritStyle();
+    handleAttributes(aAttributeList);
+}
+
+void SmMLImportContext::endFastElement(sal_Int32) { inheritStyleEnd(); }
+}
+
+// SmMLImport
+/*************************************************************************************************/
+
+SvXMLImportContext*
+SmMLImport::CreateFastContext(sal_Int32 nElement,
+                              const uno::Reference<xml::sax::XFastAttributeList>& /*xAttrList*/)
+{
+    SvXMLImportContext* pContext = nullptr;
+
+    switch (nElement)
+    {
+        case XML_ELEMENT(OFFICE, XML_DOCUMENT):
+        {
+            if (m_pElementTree == nullptr)
+                m_pElementTree = new SmMlElement(SmMlElementType::NMlEmpty);
+            uno::Reference<document::XDocumentPropertiesSupplier> xDPS(GetModel(),
+                                                                       uno::UNO_QUERY_THROW);
+            pContext = new SmMLImportContext(*this, &m_pElementTree);
+            break;
+        }
+        case XML_ELEMENT(OFFICE, XML_DOCUMENT_META):
+        {
+            uno::Reference<document::XDocumentPropertiesSupplier> xDPS(GetModel(),
+                                                                       uno::UNO_QUERY_THROW);
+            pContext = new SvXMLMetaDocumentContext(*this, xDPS->getDocumentProperties());
+            break;
+        }
+        case XML_ELEMENT(OFFICE, XML_DOCUMENT_SETTINGS):
+        {
+            uno::Reference<document::XDocumentPropertiesSupplier> xDPS(GetModel(),
+                                                                       uno::UNO_QUERY_THROW);
+            pContext = new XMLDocumentSettingsContext(*this);
+            break;
+        }
+        default:
+            declareMlError();
+            break;
+    }
+    return pContext;
+}
+
+void SmMLImport::endDocument()
+{
+    uno::Reference<frame::XModel> xModel = GetModel();
+    if (!xModel.is())
+    {
+        SAL_WARN("starmath", "Failed to set view settings because missing model");
+        SvXMLImport::endDocument();
+        return;
+    }
+
+    SmModel* pModel = comphelper::getFromUnoTunnel<SmModel>(xModel);
+    if (!pModel)
+    {
+        SAL_WARN("starmath", "Failed to set view settings because missing sm model");
+        SvXMLImport::endDocument();
+        return;
+    }
+
+    SmDocShell* pDocShell = static_cast<SmDocShell*>(pModel->GetObjectShell());
+    if (!pDocShell)
+    {
+        SAL_WARN("starmath", "Failed to set view settings because missing sm doc shell");
+        SvXMLImport::endDocument();
+        return;
+    }
+
+    // Check if there is element tree
+    if (m_pElementTree == nullptr)
+    {
+        m_bSuccess = true;
+        SvXMLImport::endDocument();
+        return;
+    }
+
+    // Get element tree and setup
+
+    if (m_pElementTree->getSubElementsCount() == 0)
+    {
+        delete m_pElementTree;
+        m_pElementTree = nullptr;
+    }
+    else
+    {
+        SmMlElement* pTmpElememt = m_pElementTree->getSubElement(0);
+        delete m_pElementTree;
+        m_pElementTree = pTmpElememt;
+    }
+    pDocShell->SetMlElementTree(m_pElementTree);
+
+    m_bSuccess = true;
+    SvXMLImport::endDocument();
+}
+
+void SmMLImport::SetViewSettings(const Sequence<PropertyValue>& aViewProps)
+{
+    uno::Reference<frame::XModel> xModel = GetModel();
+    if (!xModel.is())
+    {
+        SAL_WARN("starmath", "Failed to set view settings because missing model");
+        return;
+    }
+
+    SmModel* pModel = comphelper::getFromUnoTunnel<SmModel>(xModel);
+    if (!pModel)
+    {
+        SAL_WARN("starmath", "Failed to set view settings because missing sm model");
+        return;
+    }
+
+    SmDocShell* pDocShell = static_cast<SmDocShell*>(pModel->GetObjectShell());
+    if (!pDocShell)
+    {
+        SAL_WARN("starmath", "Failed to set view settings because missing sm doc shell");
+        return;
+    }
+
+    tools::Rectangle aRect(pDocShell->GetVisArea());
+
+    tools::Long nTmp = 0;
+
+    for (const PropertyValue& rValue : aViewProps)
+    {
+        if (rValue.Name == "ViewAreaTop")
+        {
+            rValue.Value >>= nTmp;
+            aRect.SaturatingSetPosY(nTmp);
+        }
+        else if (rValue.Name == "ViewAreaLeft")
+        {
+            rValue.Value >>= nTmp;
+            aRect.SaturatingSetPosX(nTmp);
+        }
+        else if (rValue.Name == "ViewAreaWidth")
+        {
+            rValue.Value >>= nTmp;
+            Size aSize(aRect.GetSize());
+            aSize.setWidth(nTmp);
+            aRect.SaturatingSetSize(aSize);
+        }
+        else if (rValue.Name == "ViewAreaHeight")
+        {
+            rValue.Value >>= nTmp;
+            Size aSize(aRect.GetSize());
+            aSize.setHeight(nTmp);
+            aRect.SaturatingSetSize(aSize);
+        }
+    }
+
+    pDocShell->SetVisArea(aRect);
+}
+
+void SmMLImport::SetConfigurationSettings(const Sequence<PropertyValue>& aConfProps)
+{
+    uno::Reference<frame::XModel> xModel = GetModel();
+    if (!xModel.is())
+    {
+        SAL_WARN("starmath", "Failed to set view settings because missing model");
+        return;
+    }
+
+    uno::Reference<XPropertySet> xProps(xModel, UNO_QUERY);
+    if (!xProps.is())
+    {
+        SAL_WARN("starmath", "Failed to set view settings because missing model properties");
+        return;
+    }
+
+    Reference<XPropertySetInfo> xInfo(xProps->getPropertySetInfo());
+    if (!xInfo.is())
+    {
+        SAL_WARN("starmath",
+                 "Failed to set view settings because missing model properties information");
+        return;
+    }
+
+    static constexpr OUStringLiteral sFormula(u"Formula");
+    static constexpr OUStringLiteral sBasicLibraries(u"BasicLibraries");
+    static constexpr OUStringLiteral sDialogLibraries(u"DialogLibraries");
+    for (const PropertyValue& rValue : aConfProps)
+    {
+        if (rValue.Name != sFormula && rValue.Name != sBasicLibraries
+            && rValue.Name != sDialogLibraries)
+        {
+            try
+            {
+                if (xInfo->hasPropertyByName(rValue.Name))
+                    xProps->setPropertyValue(rValue.Name, rValue.Value);
+            }
+            catch (const beans::PropertyVetoException&)
+            {
+                // dealing with read-only properties here. Nothing to do...
+            }
+            catch (const Exception&)
+            {
+                SAL_WARN("starmath", "Unexpected issue while loading document properties");
+            }
+        }
+    }
+}
+
+SmMLImport::SmMLImport(const css::uno::Reference<css::uno::XComponentContext>& rContext,
+                       OUString const& implementationName, SvXMLImportFlags nImportFlags)
+    : SvXMLImport(rContext, implementationName, nImportFlags)
+    , m_pElementTree(nullptr)
+    , m_bSuccess(false)
+    , m_nSmSyntaxVersion(SM_MOD()->GetConfig()->GetDefaultSmSyntaxVersion())
+{
+}
+
+/** Handles an error on the mathml structure
+ */
+void SmMLImport::declareMlError()
+{
+    m_bSuccess = false;
+    SAL_WARN("starmath", "MathML error");
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab cinoptions=b1,g0,N-s cinkeys+=0=break: */
diff --git a/starmath/source/mathml/iterator.cxx b/starmath/source/mathml/iterator.cxx
new file mode 100644
index 0000000000..24de35c183
--- /dev/null
+++ b/starmath/source/mathml/iterator.cxx
@@ -0,0 +1,77 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4; fill-column: 100 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ */
+
+#include <mathml/iterator.hxx>
+
+/** The purpose of this iterator is to be able to iterate threw an infinite element tree
+  * infinite -> as much as your memory can hold
+  * No call-backs that will end up in out of stack
+  */
+
+namespace mathml
+{
+static inline void deleteElement(SmMlElement* aSmMlElement, void*) { delete aSmMlElement; }
+
+static inline void cloneElement(SmMlElement* aSmMlElement, void* aData)
+{
+    // Prepare data
+    SmMlElement* aNewSmMlElement = new SmMlElement(*aSmMlElement);
+    SmMlElement* aCopyTree = *static_cast<SmMlElement**>(aData);
+
+    // Append data
+    aCopyTree->setSubElement(aCopyTree->getSubElementsCount(), aNewSmMlElement);
+
+    // Prepare for following
+    // If it has sub elements, then it will be the next
+    if (aSmMlElement->getSubElementsCount() != 0)
+        aCopyTree = aNewSmMlElement;
+    else // Otherwise remounts up to where it should be
+    {
+        while (aSmMlElement->getParentElement() != nullptr)
+        {
+            // get parent
+            SmMlElement* pParent = aSmMlElement->getParentElement();
+            aCopyTree = aCopyTree->getParentElement();
+            // was this the last branch ?
+            if (aSmMlElement->getSubElementId() + 1 != pParent->getSubElementsCount())
+                break; // no -> stop going up
+            // Prepare for next round
+            aSmMlElement = pParent;
+        }
+    }
+
+    // Closing extras
+    *static_cast<SmMlElement**>(aData) = aCopyTree;
+}
+
+void SmMlIteratorFree(SmMlElement* pMlElementTree)
+{
+    if (pMlElementTree == nullptr)
+        return;
+    for (size_t i = 0; i < pMlElementTree->getSubElementsCount(); ++i)
+    {
+        SmMlIteratorFree(pMlElementTree->getSubElement(i));
+    }
+    deleteElement(pMlElementTree, nullptr);
+}
+
+SmMlElement* SmMlIteratorCopy(SmMlElement* pMlElementTree)
+{
+    if (pMlElementTree == nullptr)
+        return nullptr;
+    SmMlElement* aDummyElement = new SmMlElement();
+    SmMlIteratorTopToBottom(pMlElementTree, cloneElement, &aDummyElement);
+    SmMlElement* aResultElement = aDummyElement->getSubElement(0);
+    delete aDummyElement;
+    return aResultElement;
+}
+
+} // end namespace mathml
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab cinoptions=b1,g0,N-s cinkeys+=0=break: */
diff --git a/starmath/source/mathml/mathmlMo.cxx b/starmath/source/mathml/mathmlMo.cxx
new file mode 100644
index 0000000000..8ee7536e1c
--- /dev/null
+++ b/starmath/source/mathml/mathmlMo.cxx
@@ -0,0 +1,1128 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#include <mathmlMo.hxx>
+
+static moOperatorData moOperatorDataDictionaryData[starmathdatabase::MATHML_MO_COUNT]
+    = { { u"\u2018"_ustr, moOpDF::prefix, 10, 0, 0, moOpDP::fence | moOpDP::nonedp },
+        { u"\u2019"_ustr, moOpDF::postfix, 10, 0, 0, moOpDP::fence | moOpDP::nonedp },
+        { u"\u201C"_ustr, moOpDF::prefix, 10, 0, 0, moOpDP::fence | moOpDP::nonedp },
+        { u"\u201D"_ustr, moOpDF::postfix, 10, 0, 0, moOpDP::fence | moOpDP::nonedp },
+        { u"("_ustr, moOpDF::prefix, 20, 0, 0, moOpDP::stretchyfence | moOpDP::symmetric },
+        { u")"_ustr, moOpDF::postfix, 20, 0, 0, moOpDP::stretchyfence | moOpDP::symmetric },
+        { u"["_ustr, moOpDF::prefix, 20, 0, 0, moOpDP::stretchyfence | moOpDP::symmetric },
+        { u"]"_ustr, moOpDF::postfix, 20, 0, 0, moOpDP::stretchyfence | moOpDP::symmetric },
+        { u"{"_ustr, moOpDF::prefix, 20, 0, 0, moOpDP::stretchyfence | moOpDP::symmetric },
+        { u"|"_ustr, moOpDF::prepostfix, 20, 0, 0, moOpDP::stretchyfence | moOpDP::symmetric },
+        { u"||"_ustr, moOpDF::prepostfix, 20, 0, 0, moOpDP::stretchyfence | moOpDP::symmetric },
+        { u"|||"_ustr, moOpDF::prepostfix, 20, 0, 0, moOpDP::stretchyfence | moOpDP::symmetric },
+        { u"}"_ustr, moOpDF::postfix, 20, 0, 0, moOpDP::stretchyfence | moOpDP::symmetric },
+        { u"\u2016"_ustr, moOpDF::prepostfix, 20, 0, 0, moOpDP::stretchyfence },
+        { u"\u2308"_ustr, moOpDF::prefix, 20, 0, 0, moOpDP::stretchyfence | moOpDP::symmetric },
+        { u"\u2309"_ustr, moOpDF::postfix, 20, 0, 0, moOpDP::stretchyfence | moOpDP::symmetric },
+        { u"\u230A"_ustr, moOpDF::prefix, 20, 0, 0, moOpDP::stretchyfence | moOpDP::symmetric },
+        { u"\u230B"_ustr, moOpDF::postfix, 20, 0, 0, moOpDP::stretchyfence | moOpDP::symmetric },
+        { u"\u2329"_ustr, moOpDF::prefix, 20, 0, 0, moOpDP::stretchyfence | moOpDP::symmetric },
+        { u"\u232A"_ustr, moOpDF::postfix, 20, 0, 0, moOpDP::stretchyfence | moOpDP::symmetric },
+        { u"\u2772"_ustr, moOpDF::prefix, 20, 0, 0, moOpDP::stretchyfence | moOpDP::symmetric },
+        { u"\u2773"_ustr, moOpDF::postfix, 20, 0, 0, moOpDP::stretchyfence | moOpDP::symmetric },
+        { u"\u27E6"_ustr, moOpDF::prefix, 20, 0, 0, moOpDP::stretchyfence | moOpDP::symmetric },
+        { u"\u27E7"_ustr, moOpDF::postfix, 20, 0, 0, moOpDP::stretchyfence | moOpDP::symmetric },
+        { u"\u27E8"_ustr, moOpDF::prefix, 20, 0, 0, moOpDP::stretchyfence | moOpDP::symmetric },
+        { u"\u27E9"_ustr, moOpDF::postfix, 20, 0, 0, moOpDP::stretchyfence | moOpDP::symmetric },
+        { u"\u27EA"_ustr, moOpDF::prefix, 20, 0, 0, moOpDP::stretchyfence | moOpDP::symmetric },
+        { u"\u27EB"_ustr, moOpDF::postfix, 20, 0, 0, moOpDP::stretchyfence | moOpDP::symmetric },
+        { u"\u27EC"_ustr, moOpDF::prefix, 20, 0, 0, moOpDP::stretchyfence | moOpDP::symmetric },
+        { u"\u27ED"_ustr, moOpDF::postfix, 20, 0, 0, moOpDP::stretchyfence | moOpDP::symmetric },
+        { u"\u27EE"_ustr, moOpDF::prefix, 20, 0, 0, moOpDP::stretchyfence | moOpDP::symmetric },
+        { u"\u27EF"_ustr, moOpDF::postfix, 20, 0, 0, moOpDP::stretchyfence | moOpDP::symmetric },
+        { u"\u2980"_ustr, moOpDF::prepostfix, 20, 0, 0, moOpDP::stretchyfence },
+        { u"\u2983"_ustr, moOpDF::prefix, 20, 0, 0, moOpDP::stretchyfence | moOpDP::symmetric },
+        { u"\u2984"_ustr, moOpDF::postfix, 20, 0, 0, moOpDP::stretchyfence | moOpDP::symmetric },
+        { u"\u2985"_ustr, moOpDF::prefix, 20, 0, 0, moOpDP::stretchyfence | moOpDP::symmetric },
+        { u"\u2986"_ustr, moOpDF::postfix, 20, 0, 0, moOpDP::stretchyfence | moOpDP::symmetric },
+        { u"\u2987"_ustr, moOpDF::prefix, 20, 0, 0, moOpDP::stretchyfence | moOpDP::symmetric },
+        { u"\u2988"_ustr, moOpDF::postfix, 20, 0, 0, moOpDP::stretchyfence | moOpDP::symmetric },
+        { u"\u2989"_ustr, moOpDF::prefix, 20, 0, 0, moOpDP::stretchyfence | moOpDP::symmetric },
+        { u"\u298A"_ustr, moOpDF::postfix, 20, 0, 0, moOpDP::stretchyfence | moOpDP::symmetric },
+        { u"\u298B"_ustr, moOpDF::prefix, 20, 0, 0, moOpDP::stretchyfence | moOpDP::symmetric },
+        { u"\u298C"_ustr, moOpDF::postfix, 20, 0, 0, moOpDP::stretchyfence | moOpDP::symmetric },
+        { u"\u298D"_ustr, moOpDF::prefix, 20, 0, 0, moOpDP::stretchyfence | moOpDP::symmetric },
+        { u"\u298E"_ustr, moOpDF::postfix, 20, 0, 0, moOpDP::stretchyfence | moOpDP::symmetric },
+        { u"\u298F"_ustr, moOpDF::prefix, 20, 0, 0, moOpDP::stretchyfence | moOpDP::symmetric },
+        { u"\u2990"_ustr, moOpDF::postfix, 20, 0, 0, moOpDP::stretchyfence | moOpDP::symmetric },
+        { u"\u2991"_ustr, moOpDF::prefix, 20, 0, 0, moOpDP::stretchyfence | moOpDP::symmetric },
+        { u"\u2992"_ustr, moOpDF::postfix, 20, 0, 0, moOpDP::stretchyfence | moOpDP::symmetric },
+        { u"\u2993"_ustr, moOpDF::prefix, 20, 0, 0, moOpDP::stretchyfence | moOpDP::symmetric },
+        { u"\u2994"_ustr, moOpDF::postfix, 20, 0, 0, moOpDP::stretchyfence | moOpDP::symmetric },
+        { u"\u2995"_ustr, moOpDF::prefix, 20, 0, 0, moOpDP::stretchyfence | moOpDP::symmetric },
+        { u"\u2996"_ustr, moOpDF::postfix, 20, 0, 0, moOpDP::stretchyfence | moOpDP::symmetric },
+        { u"\u2997"_ustr, moOpDF::prefix, 20, 0, 0, moOpDP::stretchyfence | moOpDP::symmetric },
+        { u"\u2998"_ustr, moOpDF::postfix, 20, 0, 0, moOpDP::stretchyfence | moOpDP::symmetric },
+        { u"\u29FC"_ustr, moOpDF::prefix, 20, 0, 0, moOpDP::stretchyfence | moOpDP::symmetric },
+        { u"\u29FD"_ustr, moOpDF::postfix, 20, 0, 0, moOpDP::stretchyfence | moOpDP::symmetric },
+        { u";"_ustr, moOpDF::infix, 30, 0, 3, moOpDP::separator | moOpDP::linebreakstyleAfter },
+        { u","_ustr, moOpDF::infix, 40, 0, 3, moOpDP::separator | moOpDP::linebreakstyleAfter },
+        { u"\u2063"_ustr, moOpDF::infix, 40, 0, 0,
+          moOpDP::separator | moOpDP::linebreakstyleAfter },
+        { u"\u2234"_ustr, moOpDF::infix, 70, 5, 5, moOpDP::nonedp },
+        { u"\u2235"_ustr, moOpDF::infix, 70, 5, 5, moOpDP::nonedp },
+        { u"->"_ustr, moOpDF::infix, 90, 5, 5, moOpDP::nonedp },
+        { u".."_ustr, moOpDF::postfix, 100, 0, 0, moOpDP::nonedp },
+        { u"..."_ustr, moOpDF::postfix, 100, 0, 0, moOpDP::nonedp },
+        { u":"_ustr, moOpDF::infix, 100, 1, 2, moOpDP::nonedp },
+        { u"\u03F6"_ustr, moOpDF::infix, 110, 5, 5, moOpDP::nonedp },
+        { u"\u2026"_ustr, moOpDF::infix, 150, 0, 0, moOpDP::nonedp },
+        { u"\u22EE"_ustr, moOpDF::infix, 150, 5, 5, moOpDP::nonedp },
+        { u"\u22EF"_ustr, moOpDF::infix, 150, 0, 0, moOpDP::nonedp },
+        { u"\u22F1"_ustr, moOpDF::infix, 150, 5, 5, moOpDP::nonedp },
+        { u"\u220B"_ustr, moOpDF::infix, 160, 5, 5, moOpDP::nonedp },
+        { u"\u22A2"_ustr, moOpDF::infix, 170, 5, 5, moOpDP::nonedp },
+        { u"\u22A3"_ustr, moOpDF::infix, 170, 5, 5, moOpDP::nonedp },
+        { u"\u22A4"_ustr, moOpDF::infix, 170, 5, 5, moOpDP::nonedp },
+        { u"\u22A8"_ustr, moOpDF::infix, 170, 5, 5, moOpDP::nonedp },
+        { u"\u22A9"_ustr, moOpDF::infix, 170, 5, 5, moOpDP::nonedp },
+        { u"\u22AC"_ustr, moOpDF::infix, 170, 5, 5, moOpDP::nonedp },
+        { u"\u22AD"_ustr, moOpDF::infix, 170, 5, 5, moOpDP::nonedp },
+        { u"\u22AE"_ustr, moOpDF::infix, 170, 5, 5, moOpDP::nonedp },
+        { u"\u22AF"_ustr, moOpDF::infix, 170, 5, 5, moOpDP::nonedp },
+        { u"\u2228"_ustr, moOpDF::infix, 190, 4, 4, moOpDP::nonedp },
+        { u"&&"_ustr, moOpDF::infix, 200, 4, 4, moOpDP::nonedp },
+        { u"\u2227"_ustr, moOpDF::infix, 200, 4, 4, moOpDP::nonedp },
+        { u"\u2200"_ustr, moOpDF::prefix, 230, 2, 1, moOpDP::nonedp },
+        { u"\u2203"_ustr, moOpDF::prefix, 230, 2, 1, moOpDP::nonedp },
+        { u"\u2204"_ustr, moOpDF::prefix, 230, 2, 1, moOpDP::nonedp },
+        { u"\u2201"_ustr, moOpDF::infix, 240, 1, 2, moOpDP::nonedp },
+        { u"\u2208"_ustr, moOpDF::infix, 240, 5, 5, moOpDP::nonedp },
+        { u"\u2209"_ustr, moOpDF::infix, 240, 5, 5, moOpDP::nonedp },
+        { u"\u220C"_ustr, moOpDF::infix, 240, 5, 5, moOpDP::nonedp },
+        { u"\u2282"_ustr, moOpDF::infix, 240, 5, 5, moOpDP::nonedp },
+        { u"\u2282\u20D2"_ustr, moOpDF::infix, 240, 5, 5, moOpDP::nonedp },
+        { u"\u2283"_ustr, moOpDF::infix, 240, 5, 5, moOpDP::nonedp },
+        { u"\u2283\u20D2"_ustr, moOpDF::infix, 240, 5, 5, moOpDP::nonedp },
+        { u"\u2284"_ustr, moOpDF::infix, 240, 5, 5, moOpDP::nonedp },
+        { u"\u2285"_ustr, moOpDF::infix, 240, 5, 5, moOpDP::nonedp },
+        { u"\u2286"_ustr, moOpDF::infix, 240, 5, 5, moOpDP::nonedp },
+        { u"\u2287"_ustr, moOpDF::infix, 240, 5, 5, moOpDP::nonedp },
+        { u"\u2288"_ustr, moOpDF::infix, 240, 5, 5, moOpDP::nonedp },
+        { u"\u2289"_ustr, moOpDF::infix, 240, 5, 5, moOpDP::nonedp },
+        { u"\u228A"_ustr, moOpDF::infix, 240, 5, 5, moOpDP::nonedp },
+        { u"\u228B"_ustr, moOpDF::infix, 240, 5, 5, moOpDP::nonedp },
+        { u"<="_ustr, moOpDF::infix, 241, 5, 5, moOpDP::nonedp },
+        { u"\u2264"_ustr, moOpDF::infix, 241, 5, 5, moOpDP::nonedp },
+        { u"\u2265"_ustr, moOpDF::infix, 242, 5, 5, moOpDP::nonedp },
+        { u">"_ustr, moOpDF::infix, 243, 5, 5, moOpDP::nonedp },
+        { u">="_ustr, moOpDF::infix, 243, 5, 5, moOpDP::nonedp },
+        { u"\u226F"_ustr, moOpDF::infix, 244, 5, 5, moOpDP::nonedp },
+        { u"&lt"_ustr, moOpDF::infix, 245, 5, 5, moOpDP::nonedp },
+        { u"\u226E"_ustr, moOpDF::infix, 246, 5, 5, moOpDP::nonedp },
+        { u"\u2248"_ustr, moOpDF::infix, 247, 5, 5, moOpDP::nonedp },
+        { u"\u223C"_ustr, moOpDF::infix, 250, 5, 5, moOpDP::nonedp },
+        { u"\u2249"_ustr, moOpDF::infix, 250, 5, 5, moOpDP::nonedp },
+        { u"\u2262"_ustr, moOpDF::infix, 252, 5, 5, moOpDP::nonedp },
+        { u"\u2260"_ustr, moOpDF::infix, 255, 5, 5, moOpDP::nonedp },
+        { u"!="_ustr, moOpDF::infix, 260, 4, 4, moOpDP::nonedp },
+        { u"*="_ustr, moOpDF::infix, 260, 4, 4, moOpDP::nonedp },
+        { u"+="_ustr, moOpDF::infix, 260, 4, 4, moOpDP::nonedp },
+        { u"-="_ustr, moOpDF::infix, 260, 4, 4, moOpDP::nonedp },
+        { u"/="_ustr, moOpDF::infix, 260, 4, 4, moOpDP::nonedp },
+        { u":="_ustr, moOpDF::infix, 260, 4, 4, moOpDP::nonedp },
+        { u"="_ustr, moOpDF::infix, 260, 5, 5, moOpDP::nonedp },
+        { u"=="_ustr, moOpDF::infix, 260, 4, 4, moOpDP::nonedp },
+        { u"\u221D"_ustr, moOpDF::infix, 260, 5, 5, moOpDP::nonedp },
+        { u"\u2224"_ustr, moOpDF::infix, 260, 5, 5, moOpDP::nonedp },
+        { u"\u2225"_ustr, moOpDF::infix, 260, 5, 5, moOpDP::nonedp },
+        { u"\u2226"_ustr, moOpDF::infix, 260, 5, 5, moOpDP::nonedp },
+        { u"\u2241"_ustr, moOpDF::infix, 260, 5, 5, moOpDP::nonedp },
+        { u"\u2243"_ustr, moOpDF::infix, 260, 5, 5, moOpDP::nonedp },
+        { u"\u2244"_ustr, moOpDF::infix, 260, 5, 5, moOpDP::nonedp },
+        { u"\u2245"_ustr, moOpDF::infix, 260, 5, 5, moOpDP::nonedp },
+        { u"\u2246"_ustr, moOpDF::infix, 260, 5, 5, moOpDP::nonedp },
+        { u"\u2247"_ustr, moOpDF::infix, 260, 5, 5, moOpDP::nonedp },
+        { u"\u224D"_ustr, moOpDF::infix, 260, 5, 5, moOpDP::nonedp },
+        { u"\u2254"_ustr, moOpDF::infix, 260, 5, 5, moOpDP::nonedp },
+        { u"\u2257"_ustr, moOpDF::infix, 260, 5, 5, moOpDP::nonedp },
+        { u"\u2259"_ustr, moOpDF::infix, 260, 5, 5, moOpDP::nonedp },
+        { u"\u225A"_ustr, moOpDF::infix, 260, 5, 5, moOpDP::nonedp },
+        { u"\u225B"_ustr, moOpDF::infix, 260, 5, 5, moOpDP::nonedp },
+        { u"\u225C"_ustr, moOpDF::infix, 260, 5, 5, moOpDP::nonedp },
+        { u"\u225F"_ustr, moOpDF::infix, 260, 5, 5, moOpDP::nonedp },
+        { u"\u2261"_ustr, moOpDF::infix, 260, 5, 5, moOpDP::nonedp },
+        { u"\u2268"_ustr, moOpDF::infix, 260, 5, 5, moOpDP::nonedp },
+        { u"\u2269"_ustr, moOpDF::infix, 260, 5, 5, moOpDP::nonedp },
+        { u"\u226A"_ustr, moOpDF::infix, 260, 5, 5, moOpDP::nonedp },
+        { u"\u226A\u0338"_ustr, moOpDF::infix, 260, 5, 5, moOpDP::nonedp },
+        { u"\u226B"_ustr, moOpDF::infix, 260, 5, 5, moOpDP::nonedp },
+        { u"\u226B\u0338"_ustr, moOpDF::infix, 260, 5, 5, moOpDP::nonedp },
+        { u"\u226D"_ustr, moOpDF::infix, 260, 5, 5, moOpDP::nonedp },
+        { u"\u2270"_ustr, moOpDF::infix, 260, 5, 5, moOpDP::nonedp },
+        { u"\u2271"_ustr, moOpDF::infix, 260, 5, 5, moOpDP::nonedp },
+        { u"\u227A"_ustr, moOpDF::infix, 260, 5, 5, moOpDP::nonedp },
+        { u"\u227B"_ustr, moOpDF::infix, 260, 5, 5, moOpDP::nonedp },
+        { u"\u227C"_ustr, moOpDF::infix, 260, 5, 5, moOpDP::nonedp },
+        { u"\u227D"_ustr, moOpDF::infix, 260, 5, 5, moOpDP::nonedp },
+        { u"\u2280"_ustr, moOpDF::infix, 260, 5, 5, moOpDP::nonedp },
+        { u"\u2281"_ustr, moOpDF::infix, 260, 5, 5, moOpDP::nonedp },
+        { u"\u22A5"_ustr, moOpDF::infix, 260, 5, 5, moOpDP::nonedp },
+        { u"\u22B4"_ustr, moOpDF::infix, 260, 5, 5, moOpDP::nonedp },
+        { u"\u22B5"_ustr, moOpDF::infix, 260, 5, 5, moOpDP::nonedp },
+        { u"\u22C9"_ustr, moOpDF::infix, 260, 4, 4, moOpDP::nonedp },
+        { u"\u22CA"_ustr, moOpDF::infix, 260, 4, 4, moOpDP::nonedp },
+        { u"\u22CB"_ustr, moOpDF::infix, 260, 4, 4, moOpDP::nonedp },
+        { u"\u22CC"_ustr, moOpDF::infix, 260, 4, 4, moOpDP::nonedp },
+        { u"\u22D4"_ustr, moOpDF::infix, 260, 5, 5, moOpDP::nonedp },
+        { u"\u22D6"_ustr, moOpDF::infix, 260, 5, 5, moOpDP::nonedp },
+        { u"\u22D7"_ustr, moOpDF::infix, 260, 5, 5, moOpDP::nonedp },
+        { u"\u22D8"_ustr, moOpDF::infix, 260, 5, 5, moOpDP::nonedp },
+        { u"\u22D9"_ustr, moOpDF::infix, 260, 5, 5, moOpDP::nonedp },
+        { u"\u22EA"_ustr, moOpDF::infix, 260, 5, 5, moOpDP::nonedp },
+        { u"\u22EB"_ustr, moOpDF::infix, 260, 5, 5, moOpDP::nonedp },
+        { u"\u22EC"_ustr, moOpDF::infix, 260, 5, 5, moOpDP::nonedp },
+        { u"\u22ED"_ustr, moOpDF::infix, 260, 5, 5, moOpDP::nonedp },
+        { u"\u25A0"_ustr, moOpDF::infix, 260, 3, 3, moOpDP::nonedp },
+        { u"\u25A1"_ustr, moOpDF::infix, 260, 3, 3, moOpDP::nonedp },
+        { u"\u25AA"_ustr, moOpDF::infix, 260, 3, 3, moOpDP::nonedp },
+        { u"\u25AB"_ustr, moOpDF::infix, 260, 3, 3, moOpDP::nonedp },
+        { u"\u25AD"_ustr, moOpDF::infix, 260, 3, 3, moOpDP::nonedp },
+        { u"\u25AE"_ustr, moOpDF::infix, 260, 3, 3, moOpDP::nonedp },
+        { u"\u25AF"_ustr, moOpDF::infix, 260, 3, 3, moOpDP::nonedp },
+        { u"\u25B0"_ustr, moOpDF::infix, 260, 3, 3, moOpDP::nonedp },
+        { u"\u25B1"_ustr, moOpDF::infix, 260, 3, 3, moOpDP::nonedp },
+        { u"\u25B3"_ustr, moOpDF::infix, 260, 4, 4, moOpDP::nonedp },
+        { u"\u25B4"_ustr, moOpDF::infix, 260, 4, 4, moOpDP::nonedp },
+        { u"\u25B5"_ustr, moOpDF::infix, 260, 4, 4, moOpDP::nonedp },
+        { u"\u25B6"_ustr, moOpDF::infix, 260, 4, 4, moOpDP::nonedp },
+        { u"\u25B7"_ustr, moOpDF::infix, 260, 4, 4, moOpDP::nonedp },
+        { u"\u25B8"_ustr, moOpDF::infix, 260, 4, 4, moOpDP::nonedp },
+        { u"\u25B9"_ustr, moOpDF::infix, 260, 4, 4, moOpDP::nonedp },
+        { u"\u25BC"_ustr, moOpDF::infix, 260, 4, 4, moOpDP::nonedp },
+        { u"\u25BD"_ustr, moOpDF::infix, 260, 4, 4, moOpDP::nonedp },
+        { u"\u25BE"_ustr, moOpDF::infix, 260, 4, 4, moOpDP::nonedp },
+        { u"\u25BF"_ustr, moOpDF::infix, 260, 4, 4, moOpDP::nonedp },
+        { u"\u25C0"_ustr, moOpDF::infix, 260, 4, 4, moOpDP::nonedp },
+        { u"\u25C1"_ustr, moOpDF::infix, 260, 4, 4, moOpDP::nonedp },
+        { u"\u25C2"_ustr, moOpDF::infix, 260, 4, 4, moOpDP::nonedp },
+        { u"\u25C3"_ustr, moOpDF::infix, 260, 4, 4, moOpDP::nonedp },
+        { u"\u25C4"_ustr, moOpDF::infix, 260, 4, 4, moOpDP::nonedp },
+        { u"\u25C5"_ustr, moOpDF::infix, 260, 4, 4, moOpDP::nonedp },
+        { u"\u25C6"_ustr, moOpDF::infix, 260, 4, 4, moOpDP::nonedp },
+        { u"\u25C7"_ustr, moOpDF::infix, 260, 4, 4, moOpDP::nonedp },
+        { u"\u25C8"_ustr, moOpDF::infix, 260, 4, 4, moOpDP::nonedp },
+        { u"\u25C9"_ustr, moOpDF::infix, 260, 4, 4, moOpDP::nonedp },
+        { u"\u25CC"_ustr, moOpDF::infix, 260, 4, 4, moOpDP::nonedp },
+        { u"\u25CD"_ustr, moOpDF::infix, 260, 4, 4, moOpDP::nonedp },
+        { u"\u25CE"_ustr, moOpDF::infix, 260, 4, 4, moOpDP::nonedp },
+        { u"\u25CF"_ustr, moOpDF::infix, 260, 4, 4, moOpDP::nonedp },
+        { u"\u25D6"_ustr, moOpDF::infix, 260, 4, 4, moOpDP::nonedp },
+        { u"\u25D7"_ustr, moOpDF::infix, 260, 4, 4, moOpDP::nonedp },
+        { u"\u25E6"_ustr, moOpDF::infix, 260, 4, 4, moOpDP::nonedp },
+        { u"\u29C0"_ustr, moOpDF::infix, 260, 5, 5, moOpDP::nonedp },
+        { u"\u29C1"_ustr, moOpDF::infix, 260, 5, 5, moOpDP::nonedp },
+        { u"\u29E3"_ustr, moOpDF::infix, 260, 5, 5, moOpDP::nonedp },
+        { u"\u29E4"_ustr, moOpDF::infix, 260, 5, 5, moOpDP::nonedp },
+        { u"\u29E5"_ustr, moOpDF::infix, 260, 5, 5, moOpDP::nonedp },
+        { u"\u29E6"_ustr, moOpDF::infix, 260, 5, 5, moOpDP::nonedp },
+        { u"\u29F3"_ustr, moOpDF::infix, 260, 3, 3, moOpDP::nonedp },
+        { u"\u2A87"_ustr, moOpDF::infix, 260, 5, 5, moOpDP::nonedp },
+        { u"\u2A88"_ustr, moOpDF::infix, 260, 5, 5, moOpDP::nonedp },
+        { u"\u2AAF"_ustr, moOpDF::infix, 260, 5, 5, moOpDP::nonedp },
+        { u"\u2AAF\u0338"_ustr, moOpDF::infix, 260, 5, 5, moOpDP::nonedp },
+        { u"\u2AB0"_ustr, moOpDF::infix, 260, 5, 5, moOpDP::nonedp },
+        { u"\u2AB0\u0338"_ustr, moOpDF::infix, 260, 5, 5, moOpDP::nonedp },
+        { u"\u2044"_ustr, moOpDF::infix, 265, 4, 4, moOpDP::stretchy },
+        { u"\u2206"_ustr, moOpDF::infix, 265, 3, 3, moOpDP::nonedp },
+        { u"\u220A"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u220D"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u220E"_ustr, moOpDF::infix, 265, 3, 3, moOpDP::nonedp },
+        { u"\u2215"_ustr, moOpDF::infix, 265, 4, 4, moOpDP::stretchy },
+        { u"\u2217"_ustr, moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u2218"_ustr, moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u2219"_ustr, moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u221F"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2223"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2236"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2237"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2238"_ustr, moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u2239"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u223A"_ustr, moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u223B"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u223D"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u223D\u0331"_ustr, moOpDF::infix, 265, 3, 3, moOpDP::nonedp },
+        { u"\u223E"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u223F"_ustr, moOpDF::infix, 265, 3, 3, moOpDP::nonedp },
+        { u"\u2242"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2242\u0338"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u224A"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u224B"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u224C"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u224E"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u224E\u0338"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u224F"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u224F\u0338"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2250"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2251"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2252"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2253"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2255"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2256"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2258"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u225D"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u225E"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2263"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2266"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2266\u0338"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2267"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u226C"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2272"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2273"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2274"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2275"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2276"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2277"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2278"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2279"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u227E"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u227F"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u227F\u0338"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u228C"_ustr, moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u228D"_ustr, moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u228E"_ustr, moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u228F"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u228F\u0338"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2290"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2290\u0338"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2291"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2292"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2293"_ustr, moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u2294"_ustr, moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u229A"_ustr, moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u229B"_ustr, moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u229C"_ustr, moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u229D"_ustr, moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u22A6"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u22A7"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u22AA"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u22AB"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u22B0"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u22B1"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u22B2"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u22B3"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u22B6"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u22B7"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u22B9"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u22BA"_ustr, moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u22BB"_ustr, moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u22BC"_ustr, moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u22BD"_ustr, moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u22BE"_ustr, moOpDF::infix, 265, 3, 3, moOpDP::nonedp },
+        { u"\u22BF"_ustr, moOpDF::infix, 265, 3, 3, moOpDP::nonedp },
+        { u"\u22C4"_ustr, moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u22C6"_ustr, moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u22C7"_ustr, moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u22C8"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u22CD"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u22CE"_ustr, moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u22CF"_ustr, moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u22D0"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u22D1"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u22D2"_ustr, moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u22D3"_ustr, moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u22D5"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u22DA"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u22DB"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u22DC"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u22DD"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u22DE"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u22DF"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u22E0"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u22E1"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u22E2"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u22E3"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u22E4"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u22E5"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u22E6"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u22E7"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u22E8"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u22E9"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u22F0"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u22F2"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u22F3"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u22F4"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u22F5"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u22F6"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u22F7"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u22F8"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u22F9"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u22FA"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u22FB"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u22FC"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u22FD"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u22FE"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u22FF"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u25B2"_ustr, moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u2758"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2981"_ustr, moOpDF::infix, 265, 3, 3, moOpDP::nonedp },
+        { u"\u2982"_ustr, moOpDF::infix, 265, 3, 3, moOpDP::nonedp },
+        { u"\u29A0"_ustr, moOpDF::infix, 265, 3, 3, moOpDP::nonedp },
+        { u"\u29A1"_ustr, moOpDF::infix, 265, 3, 3, moOpDP::nonedp },
+        { u"\u29A2"_ustr, moOpDF::infix, 265, 3, 3, moOpDP::nonedp },
+        { u"\u29A3"_ustr, moOpDF::infix, 265, 3, 3, moOpDP::nonedp },
+        { u"\u29A4"_ustr, moOpDF::infix, 265, 3, 3, moOpDP::nonedp },
+        { u"\u29A5"_ustr, moOpDF::infix, 265, 3, 3, moOpDP::nonedp },
+        { u"\u29A6"_ustr, moOpDF::infix, 265, 3, 3, moOpDP::nonedp },
+        { u"\u29A7"_ustr, moOpDF::infix, 265, 3, 3, moOpDP::nonedp },
+        { u"\u29A8"_ustr, moOpDF::infix, 265, 3, 3, moOpDP::nonedp },
+        { u"\u29A9"_ustr, moOpDF::infix, 265, 3, 3, moOpDP::nonedp },
+        { u"\u29AA"_ustr, moOpDF::infix, 265, 3, 3, moOpDP::nonedp },
+        { u"\u29AB"_ustr, moOpDF::infix, 265, 3, 3, moOpDP::nonedp },
+        { u"\u29AC"_ustr, moOpDF::infix, 265, 3, 3, moOpDP::nonedp },
+        { u"\u29AD"_ustr, moOpDF::infix, 265, 3, 3, moOpDP::nonedp },
+        { u"\u29AE"_ustr, moOpDF::infix, 265, 3, 3, moOpDP::nonedp },
+        { u"\u29AF"_ustr, moOpDF::infix, 265, 3, 3, moOpDP::nonedp },
+        { u"\u29B0"_ustr, moOpDF::infix, 265, 3, 3, moOpDP::nonedp },
+        { u"\u29B1"_ustr, moOpDF::infix, 265, 3, 3, moOpDP::nonedp },
+        { u"\u29B2"_ustr, moOpDF::infix, 265, 3, 3, moOpDP::nonedp },
+        { u"\u29B3"_ustr, moOpDF::infix, 265, 3, 3, moOpDP::nonedp },
+        { u"\u29B4"_ustr, moOpDF::infix, 265, 3, 3, moOpDP::nonedp },
+        { u"\u29B5"_ustr, moOpDF::infix, 265, 3, 3, moOpDP::nonedp },
+        { u"\u29B6"_ustr, moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u29B7"_ustr, moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u29B8"_ustr, moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u29B9"_ustr, moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u29BA"_ustr, moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u29BB"_ustr, moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u29BC"_ustr, moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u29BD"_ustr, moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u29BE"_ustr, moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u29BF"_ustr, moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u29C2"_ustr, moOpDF::infix, 265, 3, 3, moOpDP::nonedp },
+        { u"\u29C3"_ustr, moOpDF::infix, 265, 3, 3, moOpDP::nonedp },
+        { u"\u29C4"_ustr, moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u29C5"_ustr, moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u29C6"_ustr, moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u29C7"_ustr, moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u29C8"_ustr, moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u29C9"_ustr, moOpDF::infix, 265, 3, 3, moOpDP::nonedp },
+        { u"\u29CA"_ustr, moOpDF::infix, 265, 3, 3, moOpDP::nonedp },
+        { u"\u29CB"_ustr, moOpDF::infix, 265, 3, 3, moOpDP::nonedp },
+        { u"\u29CC"_ustr, moOpDF::infix, 265, 3, 3, moOpDP::nonedp },
+        { u"\u29CD"_ustr, moOpDF::infix, 265, 3, 3, moOpDP::nonedp },
+        { u"\u29CE"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u29CF"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u29CF\u0338"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u29D0"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u29D0\u0338"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u29D1"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u29D2"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u29D3"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u29D4"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u29D5"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u29D6"_ustr, moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u29D7"_ustr, moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u29D8"_ustr, moOpDF::infix, 265, 3, 3, moOpDP::nonedp },
+        { u"\u29D9"_ustr, moOpDF::infix, 265, 3, 3, moOpDP::nonedp },
+        { u"\u29DB"_ustr, moOpDF::infix, 265, 3, 3, moOpDP::nonedp },
+        { u"\u29DC"_ustr, moOpDF::infix, 265, 3, 3, moOpDP::nonedp },
+        { u"\u29DD"_ustr, moOpDF::infix, 265, 3, 3, moOpDP::nonedp },
+        { u"\u29DE"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u29E0"_ustr, moOpDF::infix, 265, 3, 3, moOpDP::nonedp },
+        { u"\u29E1"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u29E2"_ustr, moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u29E7"_ustr, moOpDF::infix, 265, 3, 3, moOpDP::nonedp },
+        { u"\u29E8"_ustr, moOpDF::infix, 265, 3, 3, moOpDP::nonedp },
+        { u"\u29E9"_ustr, moOpDF::infix, 265, 3, 3, moOpDP::nonedp },
+        { u"\u29EA"_ustr, moOpDF::infix, 265, 3, 3, moOpDP::nonedp },
+        { u"\u29EB"_ustr, moOpDF::infix, 265, 3, 3, moOpDP::nonedp },
+        { u"\u29EC"_ustr, moOpDF::infix, 265, 3, 3, moOpDP::nonedp },
+        { u"\u29ED"_ustr, moOpDF::infix, 265, 3, 3, moOpDP::nonedp },
+        { u"\u29EE"_ustr, moOpDF::infix, 265, 3, 3, moOpDP::nonedp },
+        { u"\u29F0"_ustr, moOpDF::infix, 265, 3, 3, moOpDP::nonedp },
+        { u"\u29F1"_ustr, moOpDF::infix, 265, 3, 3, moOpDP::nonedp },
+        { u"\u29F2"_ustr, moOpDF::infix, 265, 3, 3, moOpDP::nonedp },
+        { u"\u29F5"_ustr, moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u29F6"_ustr, moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u29F7"_ustr, moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u29F8"_ustr, moOpDF::infix, 265, 3, 3, moOpDP::nonedp },
+        { u"\u29F9"_ustr, moOpDF::infix, 265, 3, 3, moOpDP::nonedp },
+        { u"\u29FA"_ustr, moOpDF::infix, 265, 3, 3, moOpDP::nonedp },
+        { u"\u29FB"_ustr, moOpDF::infix, 265, 3, 3, moOpDP::nonedp },
+        { u"\u29FE"_ustr, moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u29FF"_ustr, moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u2A1D"_ustr, moOpDF::infix, 265, 3, 3, moOpDP::nonedp },
+        { u"\u2A1E"_ustr, moOpDF::infix, 265, 3, 3, moOpDP::nonedp },
+        { u"\u2A1F"_ustr, moOpDF::infix, 265, 3, 3, moOpDP::nonedp },
+        { u"\u2A20"_ustr, moOpDF::infix, 265, 3, 3, moOpDP::nonedp },
+        { u"\u2A21"_ustr, moOpDF::infix, 265, 3, 3, moOpDP::nonedp },
+        { u"\u2A22"_ustr, moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u2A23"_ustr, moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u2A24"_ustr, moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u2A25"_ustr, moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u2A26"_ustr, moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u2A27"_ustr, moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u2A28"_ustr, moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u2A29"_ustr, moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u2A2A"_ustr, moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u2A2B"_ustr, moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u2A2C"_ustr, moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u2A2D"_ustr, moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u2A2E"_ustr, moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u2A30"_ustr, moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u2A31"_ustr, moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u2A32"_ustr, moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u2A33"_ustr, moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u2A34"_ustr, moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u2A35"_ustr, moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u2A36"_ustr, moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u2A37"_ustr, moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u2A38"_ustr, moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u2A39"_ustr, moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u2A3A"_ustr, moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u2A3B"_ustr, moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u2A3C"_ustr, moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u2A3D"_ustr, moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u2A3E"_ustr, moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u2A40"_ustr, moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u2A41"_ustr, moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u2A42"_ustr, moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u2A43"_ustr, moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u2A44"_ustr, moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u2A45"_ustr, moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u2A46"_ustr, moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u2A47"_ustr, moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u2A48"_ustr, moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u2A49"_ustr, moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u2A4A"_ustr, moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u2A4B"_ustr, moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u2A4C"_ustr, moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u2A4D"_ustr, moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u2A4E"_ustr, moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u2A4F"_ustr, moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u2A50"_ustr, moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u2A51"_ustr, moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u2A52"_ustr, moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u2A53"_ustr, moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u2A54"_ustr, moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u2A55"_ustr, moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u2A56"_ustr, moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u2A57"_ustr, moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u2A58"_ustr, moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u2A59"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2A5A"_ustr, moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u2A5B"_ustr, moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u2A5C"_ustr, moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u2A5D"_ustr, moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u2A5E"_ustr, moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u2A5F"_ustr, moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u2A60"_ustr, moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u2A61"_ustr, moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u2A62"_ustr, moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u2A63"_ustr, moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u2A64"_ustr, moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u2A65"_ustr, moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u2A66"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2A67"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2A68"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2A69"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2A6A"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2A6B"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2A6C"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2A6D"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2A6E"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2A6F"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2A70"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2A71"_ustr, moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u2A72"_ustr, moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u2A73"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2A74"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2A75"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2A76"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2A77"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2A78"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2A79"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2A7A"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2A7B"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2A7C"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2A7D"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2A7D\u0338"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2A7E"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2A7E\u0338"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2A7F"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2A80"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2A81"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2A82"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2A83"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2A84"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2A85"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2A86"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2A89"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2A8A"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2A8B"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2A8C"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2A8D"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2A8E"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2A8F"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2A90"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2A91"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2A92"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2A93"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2A94"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2A95"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2A96"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2A97"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2A98"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2A99"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2A9A"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2A9B"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2A9C"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2A9D"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2A9E"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2A9F"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2AA0"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2AA1"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2AA1\u0338"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2AA2"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2AA2\u0338"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2AA3"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2AA4"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2AA5"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2AA6"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2AA7"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2AA8"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2AA9"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2AAA"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2AAB"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2AAC"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2AAD"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2AAE"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2AB1"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2AB2"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2AB3"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2AB4"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2AB5"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2AB6"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2AB7"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2AB8"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2AB9"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2ABA"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2ABB"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2ABC"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2ABD"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2ABE"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2ABF"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2AC0"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2AC1"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2AC2"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2AC3"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2AC4"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2AC5"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2AC6"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2AC7"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2AC8"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2AC9"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2ACA"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2ACB"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2ACC"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2ACD"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2ACE"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2ACF"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2AD0"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2AD1"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2AD2"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2AD3"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2AD4"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2AD5"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2AD6"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2AD7"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2AD8"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2AD9"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2ADA"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2ADB"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2ADD"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2ADD\u0338"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2ADE"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2ADF"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2AE0"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2AE1"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2AE2"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2AE3"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2AE4"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2AE5"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2AE6"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2AE7"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2AE8"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2AE9"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2AEA"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2AEB"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2AEC"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2AED"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2AEE"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2AEF"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2AF0"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2AF1"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2AF2"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2AF3"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2AF4"_ustr, moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u2AF5"_ustr, moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u2AF6"_ustr, moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u2AF7"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2AF8"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2AF9"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2AFA"_ustr, moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2AFB"_ustr, moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u2AFD"_ustr, moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u2AFE"_ustr, moOpDF::infix, 265, 3, 3, moOpDP::nonedp },
+        { u"|"_ustr, moOpDF::infix, 270, 2, 2, moOpDP::stretchyfence | moOpDP::symmetric },
+        { u"||"_ustr, moOpDF::infix, 270, 2, 2, moOpDP::stretchyfence | moOpDP::symmetric },
+        { u"|||"_ustr, moOpDF::infix, 270, 2, 2, moOpDP::stretchyfence | moOpDP::symmetric },
+        { u"\u2190"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::stretchy | moOpDP::accent },
+        { u"\u2191"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::stretchy },
+        { u"\u2192"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::stretchy | moOpDP::accent },
+        { u"\u2193"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::stretchy },
+        { u"\u2194"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::stretchy | moOpDP::accent },
+        { u"\u2195"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::stretchy },
+        { u"\u2196"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::stretchy },
+        { u"\u2197"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::stretchy },
+        { u"\u2198"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::stretchy },
+        { u"\u2199"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::stretchy },
+        { u"\u219A"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::accent },
+        { u"\u219B"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::accent },
+        { u"\u219C"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::stretchy | moOpDP::accent },
+        { u"\u219D"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::stretchy | moOpDP::accent },
+        { u"\u219E"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::stretchy | moOpDP::accent },
+        { u"\u219F"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::stretchy | moOpDP::accent },
+        { u"\u21A0"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::stretchy | moOpDP::accent },
+        { u"\u21A1"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::stretchy },
+        { u"\u21A2"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::stretchy | moOpDP::accent },
+        { u"\u21A3"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::stretchy | moOpDP::accent },
+        { u"\u21A4"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::stretchy | moOpDP::accent },
+        { u"\u21A5"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::stretchy },
+        { u"\u21A6"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::stretchy | moOpDP::accent },
+        { u"\u21A7"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::stretchy },
+        { u"\u21A8"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::stretchy },
+        { u"\u21A9"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::stretchy | moOpDP::accent },
+        { u"\u21AA"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::stretchy | moOpDP::accent },
+        { u"\u21AB"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::stretchy | moOpDP::accent },
+        { u"\u21AC"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::stretchy | moOpDP::accent },
+        { u"\u21AD"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::stretchy | moOpDP::accent },
+        { u"\u21AE"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::accent },
+        { u"\u21AF"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::stretchy },
+        { u"\u21B0"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::stretchy },
+        { u"\u21B1"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::stretchy },
+        { u"\u21B2"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::stretchy },
+        { u"\u21B3"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::stretchy },
+        { u"\u21B4"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::stretchy },
+        { u"\u21B5"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::stretchy },
+        { u"\u21B6"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::accent },
+        { u"\u21B7"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::accent },
+        { u"\u21B8"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::nonedp },
+        { u"\u21B9"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::stretchy | moOpDP::accent },
+        { u"\u21BA"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::nonedp },
+        { u"\u21BB"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::nonedp },
+        { u"\u21BC"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::stretchy | moOpDP::accent },
+        { u"\u21BD"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::stretchy | moOpDP::accent },
+        { u"\u21BE"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::stretchy },
+        { u"\u21BF"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::stretchy },
+        { u"\u21C0"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::stretchy | moOpDP::accent },
+        { u"\u21C1"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::stretchy | moOpDP::accent },
+        { u"\u21C2"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::stretchy },
+        { u"\u21C3"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::stretchy },
+        { u"\u21C4"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::stretchy | moOpDP::accent },
+        { u"\u21C5"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::stretchy },
+        { u"\u21C6"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::stretchy | moOpDP::accent },
+        { u"\u21C7"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::stretchy | moOpDP::accent },
+        { u"\u21C8"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::stretchy },
+        { u"\u21C9"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::stretchy | moOpDP::accent },
+        { u"\u21CA"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::stretchy },
+        { u"\u21CB"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::stretchy | moOpDP::accent },
+        { u"\u21CC"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::stretchy | moOpDP::accent },
+        { u"\u21CD"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::accent },
+        { u"\u21CE"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::accent },
+        { u"\u21CF"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::accent },
+        { u"\u21D0"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::stretchy | moOpDP::accent },
+        { u"\u21D1"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::stretchy },
+        { u"\u21D2"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::stretchy | moOpDP::accent },
+        { u"\u21D3"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::stretchy },
+        { u"\u21D4"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::stretchy | moOpDP::accent },
+        { u"\u21D5"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::stretchy },
+        { u"\u21D6"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::stretchy },
+        { u"\u21D7"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::stretchy },
+        { u"\u21D8"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::stretchy },
+        { u"\u21D9"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::stretchy },
+        { u"\u21DA"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::stretchy | moOpDP::accent },
+        { u"\u21DB"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::stretchy | moOpDP::accent },
+        { u"\u21DC"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::stretchy | moOpDP::accent },
+        { u"\u21DD"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::stretchy | moOpDP::accent },
+        { u"\u21DE"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::nonedp },
+        { u"\u21DF"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::nonedp },
+        { u"\u21E0"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::stretchy | moOpDP::accent },
+        { u"\u21E1"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::stretchy },
+        { u"\u21E2"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::stretchy | moOpDP::accent },
+        { u"\u21E3"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::stretchy },
+        { u"\u21E4"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::stretchy | moOpDP::accent },
+        { u"\u21E5"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::stretchy | moOpDP::accent },
+        { u"\u21E6"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::stretchy | moOpDP::accent },
+        { u"\u21E7"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::stretchy },
+        { u"\u21E8"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::stretchy | moOpDP::accent },
+        { u"\u21E9"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::stretchy },
+        { u"\u21EA"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::stretchy },
+        { u"\u21EB"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::stretchy },
+        { u"\u21EC"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::stretchy },
+        { u"\u21ED"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::stretchy },
+        { u"\u21EE"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::stretchy },
+        { u"\u21EF"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::stretchy },
+        { u"\u21F0"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::stretchy | moOpDP::accent },
+        { u"\u21F1"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::nonedp },
+        { u"\u21F2"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::nonedp },
+        { u"\u21F3"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::stretchy },
+        { u"\u21F4"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::accent },
+        { u"\u21F5"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::stretchy },
+        { u"\u21F6"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::stretchy | moOpDP::accent },
+        { u"\u21F7"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::accent },
+        { u"\u21F8"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::accent },
+        { u"\u21F9"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::accent },
+        { u"\u21FA"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::accent },
+        { u"\u21FB"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::accent },
+        { u"\u21FC"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::accent },
+        { u"\u21FD"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::stretchy | moOpDP::accent },
+        { u"\u21FE"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::stretchy | moOpDP::accent },
+        { u"\u21FF"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::stretchy | moOpDP::accent },
+        { u"\u22B8"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::nonedp },
+        { u"\u27F0"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::stretchy },
+        { u"\u27F1"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::stretchy },
+        { u"\u27F5"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::stretchy | moOpDP::accent },
+        { u"\u27F6"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::stretchy | moOpDP::accent },
+        { u"\u27F7"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::stretchy | moOpDP::accent },
+        { u"\u27F8"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::stretchy | moOpDP::accent },
+        { u"\u27F9"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::stretchy | moOpDP::accent },
+        { u"\u27FA"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::stretchy | moOpDP::accent },
+        { u"\u27FB"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::stretchy | moOpDP::accent },
+        { u"\u27FC"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::stretchy | moOpDP::accent },
+        { u"\u27FD"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::stretchy | moOpDP::accent },
+        { u"\u27FE"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::stretchy | moOpDP::accent },
+        { u"\u27FF"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::stretchy | moOpDP::accent },
+        { u"\u2900"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::accent },
+        { u"\u2901"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::accent },
+        { u"\u2902"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::accent },
+        { u"\u2903"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::accent },
+        { u"\u2904"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::accent },
+        { u"\u2905"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::accent },
+        { u"\u2906"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::accent },
+        { u"\u2907"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::accent },
+        { u"\u2908"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::nonedp },
+        { u"\u2909"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::nonedp },
+        { u"\u290A"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::stretchy },
+        { u"\u290B"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::stretchy },
+        { u"\u290C"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::stretchy | moOpDP::accent },
+        { u"\u290D"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::stretchy | moOpDP::accent },
+        { u"\u290E"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::stretchy | moOpDP::accent },
+        { u"\u290F"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::stretchy | moOpDP::accent },
+        { u"\u2910"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::stretchy | moOpDP::accent },
+        { u"\u2911"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::accent },
+        { u"\u2912"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::stretchy },
+        { u"\u2913"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::stretchy },
+        { u"\u2914"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::accent },
+        { u"\u2915"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::accent },
+        { u"\u2916"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::accent },
+        { u"\u2917"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::accent },
+        { u"\u2918"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::accent },
+        { u"\u2919"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::accent },
+        { u"\u291A"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::accent },
+        { u"\u291B"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::accent },
+        { u"\u291C"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::accent },
+        { u"\u291D"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::accent },
+        { u"\u291E"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::accent },
+        { u"\u291F"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::accent },
+        { u"\u2920"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::accent },
+        { u"\u2921"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::stretchy },
+        { u"\u2922"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::stretchy },
+        { u"\u2923"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::nonedp },
+        { u"\u2924"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::nonedp },
+        { u"\u2925"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::nonedp },
+        { u"\u2926"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::nonedp },
+        { u"\u2927"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::nonedp },
+        { u"\u2928"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::nonedp },
+        { u"\u2929"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::nonedp },
+        { u"\u292A"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::nonedp },
+        { u"\u292B"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::nonedp },
+        { u"\u292C"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::nonedp },
+        { u"\u292D"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::nonedp },
+        { u"\u292E"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::nonedp },
+        { u"\u292F"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::nonedp },
+        { u"\u2930"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::nonedp },
+        { u"\u2931"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::nonedp },
+        { u"\u2932"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::nonedp },
+        { u"\u2933"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::accent },
+        { u"\u2934"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::nonedp },
+        { u"\u2935"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::nonedp },
+        { u"\u2936"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::nonedp },
+        { u"\u2937"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::nonedp },
+        { u"\u2938"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::nonedp },
+        { u"\u2939"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::nonedp },
+        { u"\u293A"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::accent },
+        { u"\u293B"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::accent },
+        { u"\u293C"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::accent },
+        { u"\u293D"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::accent },
+        { u"\u293E"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::nonedp },
+        { u"\u293F"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::nonedp },
+        { u"\u2940"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::nonedp },
+        { u"\u2941"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::nonedp },
+        { u"\u2942"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::accent },
+        { u"\u2943"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::accent },
+        { u"\u2944"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::accent },
+        { u"\u2945"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::accent },
+        { u"\u2946"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::accent },
+        { u"\u2947"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::accent },
+        { u"\u2948"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::accent },
+        { u"\u2949"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::nonedp },
+        { u"\u294A"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::accent },
+        { u"\u294B"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::accent },
+        { u"\u294C"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::nonedp },
+        { u"\u294D"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::nonedp },
+        { u"\u294E"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::stretchy | moOpDP::accent },
+        { u"\u294F"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::stretchy },
+        { u"\u2950"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::stretchy | moOpDP::accent },
+        { u"\u2951"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::stretchy },
+        { u"\u2952"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::stretchy | moOpDP::accent },
+        { u"\u2953"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::stretchy | moOpDP::accent },
+        { u"\u2954"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::stretchy },
+        { u"\u2955"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::stretchy },
+        { u"\u2956"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::stretchy },
+        { u"\u2957"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::stretchy },
+        { u"\u2958"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::stretchy },
+        { u"\u2959"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::stretchy },
+        { u"\u295A"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::stretchy | moOpDP::accent },
+        { u"\u295B"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::stretchy | moOpDP::accent },
+        { u"\u295C"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::stretchy },
+        { u"\u295D"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::stretchy },
+        { u"\u295E"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::stretchy | moOpDP::accent },
+        { u"\u295F"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::stretchy | moOpDP::accent },
+        { u"\u2960"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::stretchy },
+        { u"\u2961"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::stretchy },
+        { u"\u2962"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::accent },
+        { u"\u2963"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::nonedp },
+        { u"\u2964"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::accent },
+        { u"\u2965"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::nonedp },
+        { u"\u2966"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::accent },
+        { u"\u2967"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::accent },
+        { u"\u2968"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::accent },
+        { u"\u2969"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::accent },
+        { u"\u296A"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::accent },
+        { u"\u296B"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::accent },
+        { u"\u296C"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::accent },
+        { u"\u296D"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::accent },
+        { u"\u296E"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::stretchy },
+        { u"\u296F"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::stretchy },
+        { u"\u2970"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::accent },
+        { u"\u2971"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::accent },
+        { u"\u2972"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::accent },
+        { u"\u2973"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::accent },
+        { u"\u2974"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::accent },
+        { u"\u2975"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::accent },
+        { u"\u2976"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::accent },
+        { u"\u2977"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::accent },
+        { u"\u2978"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::accent },
+        { u"\u2979"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::accent },
+        { u"\u297A"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::accent },
+        { u"\u297B"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::accent },
+        { u"\u297C"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::accent },
+        { u"\u297D"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::accent },
+        { u"\u297E"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::nonedp },
+        { u"\u297F"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::nonedp },
+        { u"\u2999"_ustr, moOpDF::infix, 270, 3, 3, moOpDP::nonedp },
+        { u"\u299A"_ustr, moOpDF::infix, 270, 3, 3, moOpDP::nonedp },
+        { u"\u299B"_ustr, moOpDF::infix, 270, 3, 3, moOpDP::nonedp },
+        { u"\u299C"_ustr, moOpDF::infix, 270, 3, 3, moOpDP::nonedp },
+        { u"\u299D"_ustr, moOpDF::infix, 270, 3, 3, moOpDP::nonedp },
+        { u"\u299E"_ustr, moOpDF::infix, 270, 3, 3, moOpDP::nonedp },
+        { u"\u299F"_ustr, moOpDF::infix, 270, 3, 3, moOpDP::nonedp },
+        { u"\u29DF"_ustr, moOpDF::infix, 270, 3, 3, moOpDP::nonedp },
+        { u"\u29EF"_ustr, moOpDF::infix, 270, 3, 3, moOpDP::nonedp },
+        { u"\u29F4"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::nonedp },
+        { u"\u2B45"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::stretchy },
+        { u"\u2B46"_ustr, moOpDF::infix, 270, 5, 5, moOpDP::stretchy },
+        { u"+"_ustr, moOpDF::infix, 275, 4, 4, moOpDP::nonedp },
+        { u"+"_ustr, moOpDF::prefix, 275, 0, 1, moOpDP::nonedp },
+        { u"-"_ustr, moOpDF::infix, 275, 4, 4, moOpDP::nonedp },
+        { u"-"_ustr, moOpDF::prefix, 275, 0, 1, moOpDP::nonedp },
+        { u"\u00B1"_ustr, moOpDF::infix, 275, 4, 4, moOpDP::nonedp },
+        { u"\u00B1"_ustr, moOpDF::prefix, 275, 0, 1, moOpDP::nonedp },
+        { u"\u2212"_ustr, moOpDF::infix, 275, 4, 4, moOpDP::nonedp },
+        { u"\u2212"_ustr, moOpDF::prefix, 275, 0, 1, moOpDP::nonedp },
+        { u"\u2213"_ustr, moOpDF::infix, 275, 4, 4, moOpDP::nonedp },
+        { u"\u2213"_ustr, moOpDF::prefix, 275, 0, 1, moOpDP::nonedp },
+        { u"\u2214"_ustr, moOpDF::infix, 275, 4, 4, moOpDP::nonedp },
+        { u"\u229E"_ustr, moOpDF::infix, 275, 4, 4, moOpDP::nonedp },
+        { u"\u229F"_ustr, moOpDF::infix, 275, 4, 4, moOpDP::nonedp },
+        { u"\u2211"_ustr, moOpDF::prefix, 290, 1, 2, moOpDP::movablelargeop | moOpDP::symmetric },
+        { u"\u2A0A"_ustr, moOpDF::prefix, 290, 1, 2, moOpDP::movablelargeop | moOpDP::symmetric },
+        { u"\u2A0B"_ustr, moOpDF::prefix, 290, 1, 2, moOpDP::largeop | moOpDP::symmetric },
+        { u"\u222C"_ustr, moOpDF::prefix, 300, 0, 1, moOpDP::largeop | moOpDP::symmetric },
+        { u"\u222D"_ustr, moOpDF::prefix, 300, 0, 1, moOpDP::largeop | moOpDP::symmetric },
+        { u"\u2295"_ustr, moOpDF::infix, 300, 4, 4, moOpDP::nonedp },
+        { u"\u2296"_ustr, moOpDF::infix, 300, 4, 4, moOpDP::nonedp },
+        { u"\u2298"_ustr, moOpDF::infix, 300, 4, 4, moOpDP::nonedp },
+        { u"\u2A01"_ustr, moOpDF::prefix, 300, 1, 2, moOpDP::movablelargeop | moOpDP::symmetric },
+        { u"\u222B"_ustr, moOpDF::prefix, 310, 0, 1, moOpDP::largeop | moOpDP::symmetric },
+        { u"\u222E"_ustr, moOpDF::prefix, 310, 0, 1, moOpDP::largeop | moOpDP::symmetric },
+        { u"\u222F"_ustr, moOpDF::prefix, 310, 0, 1, moOpDP::largeop | moOpDP::symmetric },
+        { u"\u2230"_ustr, moOpDF::prefix, 310, 0, 1, moOpDP::largeop | moOpDP::symmetric },
+        { u"\u2231"_ustr, moOpDF::prefix, 310, 0, 1, moOpDP::largeop | moOpDP::symmetric },
+        { u"\u2232"_ustr, moOpDF::prefix, 310, 0, 1, moOpDP::largeop | moOpDP::symmetric },
+        { u"\u2233"_ustr, moOpDF::prefix, 310, 0, 1, moOpDP::largeop | moOpDP::symmetric },
+        { u"\u2A0C"_ustr, moOpDF::prefix, 310, 0, 1, moOpDP::largeop | moOpDP::symmetric },
+        { u"\u2A0D"_ustr, moOpDF::prefix, 310, 1, 2, moOpDP::largeop | moOpDP::symmetric },
+        { u"\u2A0E"_ustr, moOpDF::prefix, 310, 1, 2, moOpDP::largeop | moOpDP::symmetric },
+        { u"\u2A0F"_ustr, moOpDF::prefix, 310, 1, 2, moOpDP::largeop | moOpDP::symmetric },
+        { u"\u2A10"_ustr, moOpDF::prefix, 310, 1, 2, moOpDP::movablelargeop | moOpDP::symmetric },
+        { u"\u2A11"_ustr, moOpDF::prefix, 310, 1, 2, moOpDP::movablelargeop | moOpDP::symmetric },
+        { u"\u2A12"_ustr, moOpDF::prefix, 310, 1, 2, moOpDP::movablelargeop | moOpDP::symmetric },
+        { u"\u2A13"_ustr, moOpDF::prefix, 310, 1, 2, moOpDP::movablelargeop | moOpDP::symmetric },
+        { u"\u2A14"_ustr, moOpDF::prefix, 310, 1, 2, moOpDP::movablelargeop | moOpDP::symmetric },
+        { u"\u2A15"_ustr, moOpDF::prefix, 310, 1, 2, moOpDP::largeop | moOpDP::symmetric },
+        { u"\u2A16"_ustr, moOpDF::prefix, 310, 1, 2, moOpDP::largeop | moOpDP::symmetric },
+        { u"\u2A17"_ustr, moOpDF::prefix, 310, 1, 2, moOpDP::largeop | moOpDP::symmetric },
+        { u"\u2A18"_ustr, moOpDF::prefix, 310, 1, 2, moOpDP::largeop | moOpDP::symmetric },
+        { u"\u2A19"_ustr, moOpDF::prefix, 310, 1, 2, moOpDP::largeop | moOpDP::symmetric },
+        { u"\u2A1A"_ustr, moOpDF::prefix, 310, 1, 2, moOpDP::largeop | moOpDP::symmetric },
+        { u"\u2A1B"_ustr, moOpDF::prefix, 310, 1, 2, moOpDP::largeop | moOpDP::symmetric },
+        { u"\u2A1C"_ustr, moOpDF::prefix, 310, 1, 2, moOpDP::largeop | moOpDP::symmetric },
+        { u"\u22C3"_ustr, moOpDF::prefix, 320, 1, 2, moOpDP::movablelargeop | moOpDP::symmetric },
+        { u"\u2A03"_ustr, moOpDF::prefix, 320, 1, 2, moOpDP::movablelargeop | moOpDP::symmetric },
+        { u"\u2A04"_ustr, moOpDF::prefix, 320, 1, 2, moOpDP::movablelargeop | moOpDP::symmetric },
+        { u"\u22C0"_ustr, moOpDF::prefix, 330, 1, 2, moOpDP::movablelargeop | moOpDP::symmetric },
+        { u"\u22C1"_ustr, moOpDF::prefix, 330, 1, 2, moOpDP::movablelargeop | moOpDP::symmetric },
+        { u"\u22C2"_ustr, moOpDF::prefix, 330, 1, 2, moOpDP::movablelargeop | moOpDP::symmetric },
+        { u"\u2A00"_ustr, moOpDF::prefix, 330, 1, 2, moOpDP::movablelargeop | moOpDP::symmetric },
+        { u"\u2A02"_ustr, moOpDF::prefix, 330, 1, 2, moOpDP::movablelargeop | moOpDP::symmetric },
+        { u"\u2A05"_ustr, moOpDF::prefix, 330, 1, 2, moOpDP::movablelargeop | moOpDP::symmetric },
+        { u"\u2A06"_ustr, moOpDF::prefix, 330, 1, 2, moOpDP::movablelargeop | moOpDP::symmetric },
+        { u"\u2A07"_ustr, moOpDF::prefix, 330, 1, 2, moOpDP::movablelargeop | moOpDP::symmetric },
+        { u"\u2A08"_ustr, moOpDF::prefix, 330, 1, 2, moOpDP::movablelargeop | moOpDP::symmetric },
+        { u"\u2A09"_ustr, moOpDF::prefix, 330, 1, 2, moOpDP::movablelargeop | moOpDP::symmetric },
+        { u"\u2AFC"_ustr, moOpDF::prefix, 330, 1, 2, moOpDP::movablelargeop | moOpDP::symmetric },
+        { u"\u2AFF"_ustr, moOpDF::prefix, 330, 1, 2, moOpDP::movablelargeop | moOpDP::symmetric },
+        { u"\u2240"_ustr, moOpDF::infix, 340, 4, 4, moOpDP::nonedp },
+        { u"\u220F"_ustr, moOpDF::prefix, 350, 1, 2, moOpDP::movablelargeop | moOpDP::symmetric },
+        { u"\u2210"_ustr, moOpDF::prefix, 350, 1, 2, moOpDP::movablelargeop | moOpDP::symmetric },
+        { u"\u2229"_ustr, moOpDF::infix, 350, 4, 4, moOpDP::nonedp },
+        { u"\u222A"_ustr, moOpDF::infix, 350, 4, 4, moOpDP::nonedp },
+        { u"*"_ustr, moOpDF::infix, 390, 3, 3, moOpDP::nonedp },
+        { u"."_ustr, moOpDF::infix, 390, 3, 3, moOpDP::nonedp },
+        { u"\u00D7"_ustr, moOpDF::infix, 390, 4, 4, moOpDP::nonedp },
+        { u"\u2022"_ustr, moOpDF::infix, 390, 4, 4, moOpDP::nonedp },
+        { u"\u2043"_ustr, moOpDF::infix, 390, 4, 4, moOpDP::nonedp },
+        { u"\u2062"_ustr, moOpDF::infix, 390, 0, 0, moOpDP::nonedp },
+        { u"\u22A0"_ustr, moOpDF::infix, 390, 4, 4, moOpDP::nonedp },
+        { u"\u22A1"_ustr, moOpDF::infix, 390, 4, 4, moOpDP::nonedp },
+        { u"\u22C5"_ustr, moOpDF::infix, 390, 4, 4, moOpDP::nonedp },
+        { u"\u2A2F"_ustr, moOpDF::infix, 390, 4, 4, moOpDP::nonedp },
+        { u"\u2A3F"_ustr, moOpDF::infix, 390, 4, 4, moOpDP::nonedp },
+        { u"\u00B7"_ustr, moOpDF::infix, 400, 4, 4, moOpDP::nonedp },
+        { u"\u2297"_ustr, moOpDF::infix, 410, 4, 4, moOpDP::nonedp },
+        { u"%"_ustr, moOpDF::infix, 640, 3, 3, moOpDP::nonedp },
+        { u"\\"_ustr, moOpDF::infix, 650, 0, 0, moOpDP::nonedp },
+        { u"\u2216"_ustr, moOpDF::infix, 650, 4, 4, moOpDP::nonedp },
+        { u"/"_ustr, moOpDF::infix, 660, 1, 1, moOpDP::nonedp },
+        { u"\u00F7"_ustr, moOpDF::infix, 660, 4, 4, moOpDP::nonedp },
+        { u"\u2220"_ustr, moOpDF::prefix, 670, 0, 0, moOpDP::nonedp },
+        { u"\u2221"_ustr, moOpDF::prefix, 670, 0, 0, moOpDP::nonedp },
+        { u"\u2222"_ustr, moOpDF::prefix, 670, 0, 0, moOpDP::nonedp },
+        { u"\u00AC"_ustr, moOpDF::prefix, 680, 2, 1, moOpDP::nonedp },
+        { u"\u2299"_ustr, moOpDF::infix, 710, 4, 4, moOpDP::nonedp },
+        { u"\u2202"_ustr, moOpDF::prefix, 740, 2, 1, moOpDP::nonedp },
+        { u"\u2207"_ustr, moOpDF::prefix, 740, 2, 1, moOpDP::nonedp },
+        { u"**"_ustr, moOpDF::infix, 780, 1, 1, moOpDP::nonedp },
+        { u"<>"_ustr, moOpDF::infix, 780, 1, 1, moOpDP::nonedp },
+        { u"^"_ustr, moOpDF::infix, 780, 1, 1, moOpDP::nonedp },
+        { u"\u2032"_ustr, moOpDF::postfix, 800, 0, 0, moOpDP::nonedp },
+        { u"\u266D"_ustr, moOpDF::postfix, 800, 0, 2, moOpDP::nonedp },
+        { u"\u266E"_ustr, moOpDF::postfix, 800, 0, 2, moOpDP::nonedp },
+        { u"\u266F"_ustr, moOpDF::postfix, 800, 0, 2, moOpDP::nonedp },
+        { u"!"_ustr, moOpDF::postfix, 810, 1, 0, moOpDP::nonedp },
+        { u"!!"_ustr, moOpDF::postfix, 810, 1, 0, moOpDP::nonedp },
+        { u"//"_ustr, moOpDF::infix, 820, 1, 1, moOpDP::nonedp },
+        { u"@"_ustr, moOpDF::infix, 825, 1, 1, moOpDP::nonedp },
+        { u"?"_ustr, moOpDF::infix, 835, 1, 1, moOpDP::nonedp },
+        { u"\u2145"_ustr, moOpDF::prefix, 845, 2, 1, moOpDP::nonedp },
+        { u"\u2146"_ustr, moOpDF::prefix, 845, 2, 0, moOpDP::nonedp },
+        { u"\u221A"_ustr, moOpDF::prefix, 845, 1, 1, moOpDP::stretchy },
+        { u"\u221B"_ustr, moOpDF::prefix, 845, 1, 1, moOpDP::nonedp },
+        { u"\u221C"_ustr, moOpDF::prefix, 845, 1, 1, moOpDP::nonedp },
+        { u"\u2061"_ustr, moOpDF::infix, 850, 0, 0, moOpDP::nonedp },
+        { u"\""_ustr, moOpDF::postfix, 880, 0, 0, moOpDP::accent },
+        { u"&"_ustr, moOpDF::postfix, 880, 0, 0, moOpDP::nonedp },
+        { u"\'"_ustr, moOpDF::postfix, 880, 0, 0, moOpDP::accent },
+        { u"++"_ustr, moOpDF::postfix, 880, 0, 0, moOpDP::nonedp },
+        { u"--"_ustr, moOpDF::postfix, 880, 0, 0, moOpDP::nonedp },
+        { u"^"_ustr, moOpDF::postfix, 880, 0, 0, moOpDP::stretchy | moOpDP::accent },
+        { u"_"_ustr, moOpDF::postfix, 880, 0, 0, moOpDP::stretchy | moOpDP::accent },
+        { u"`"_ustr, moOpDF::postfix, 880, 0, 00, moOpDP::accent },
+        { u"~"_ustr, moOpDF::postfix, 880, 0, 0, moOpDP::stretchy | moOpDP::accent },
+        { u"\u00A8"_ustr, moOpDF::postfix, 880, 0, 0, moOpDP::accent },
+        { u"\u00AA"_ustr, moOpDF::postfix, 880, 0, 0, moOpDP::accent },
+        { u"\u00AF"_ustr, moOpDF::postfix, 880, 0, 0, moOpDP::stretchy | moOpDP::accent },
+        { u"\u00B0"_ustr, moOpDF::postfix, 880, 0, 0, moOpDP::nonedp },
+        { u"\u00B2"_ustr, moOpDF::postfix, 880, 0, 0, moOpDP::accent },
+        { u"\u00B3"_ustr, moOpDF::postfix, 880, 0, 0, moOpDP::accent },
+        { u"\u00B4"_ustr, moOpDF::postfix, 880, 0, 0, moOpDP::accent },
+        { u"\u00B8"_ustr, moOpDF::postfix, 880, 0, 0, moOpDP::accent },
+        { u"\u00B9"_ustr, moOpDF::postfix, 880, 0, 0, moOpDP::accent },
+        { u"\u00BA"_ustr, moOpDF::postfix, 880, 0, 0, moOpDP::accent },
+        { u"\u02C6"_ustr, moOpDF::postfix, 880, 0, 0, moOpDP::stretchy | moOpDP::accent },
+        { u"\u02C7"_ustr, moOpDF::postfix, 880, 0, 0, moOpDP::stretchy | moOpDP::accent },
+        { u"\u02C9"_ustr, moOpDF::postfix, 880, 0, 0, moOpDP::stretchy | moOpDP::accent },
+        { u"\u02CA"_ustr, moOpDF::postfix, 880, 0, 0, moOpDP::accent },
+        { u"\u02CB"_ustr, moOpDF::postfix, 880, 0, 0, moOpDP::accent },
+        { u"\u02CD"_ustr, moOpDF::postfix, 880, 0, 0, moOpDP::stretchy | moOpDP::accent },
+        { u"\u02D8"_ustr, moOpDF::postfix, 880, 0, 0, moOpDP::accent },
+        { u"\u02D9"_ustr, moOpDF::postfix, 880, 0, 0, moOpDP::accent },
+        { u"\u02DA"_ustr, moOpDF::postfix, 880, 0, 0, moOpDP::accent },
+        { u"\u02DC"_ustr, moOpDF::postfix, 880, 0, 0, moOpDP::stretchy | moOpDP::accent },
+        { u"\u02DD"_ustr, moOpDF::postfix, 880, 0, 0, moOpDP::accent },
+        { u"\u02F7"_ustr, moOpDF::postfix, 880, 0, 0, moOpDP::stretchy | moOpDP::accent },
+        { u"\u0302"_ustr, moOpDF::postfix, 880, 0, 0, moOpDP::stretchy | moOpDP::accent },
+        { u"\u0311"_ustr, moOpDF::postfix, 880, 0, 0, moOpDP::accent },
+        { u"\u201A"_ustr, moOpDF::postfix, 880, 0, 0, moOpDP::accent },
+        { u"\u201B"_ustr, moOpDF::postfix, 880, 0, 0, moOpDP::accent },
+        { u"\u201E"_ustr, moOpDF::postfix, 880, 0, 0, moOpDP::accent },
+        { u"\u201F"_ustr, moOpDF::postfix, 880, 0, 0, moOpDP::accent },
+        { u"\u2033"_ustr, moOpDF::postfix, 880, 0, 0, moOpDP::accent },
+        { u"\u2034"_ustr, moOpDF::postfix, 880, 0, 0, moOpDP::accent },
+        { u"\u2035"_ustr, moOpDF::postfix, 880, 0, 0, moOpDP::accent },
+        { u"\u2036"_ustr, moOpDF::postfix, 880, 0, 0, moOpDP::accent },
+        { u"\u2037"_ustr, moOpDF::postfix, 880, 0, 0, moOpDP::accent },
+        { u"\u203E"_ustr, moOpDF::postfix, 880, 0, 0, moOpDP::stretchy | moOpDP::accent },
+        { u"\u2057"_ustr, moOpDF::postfix, 880, 0, 0, moOpDP::accent },
+        { u"\u2064"_ustr, moOpDF::infix, 880, 0, 0, moOpDP::nonedp },
+        { u"\u20DB"_ustr, moOpDF::postfix, 880, 0, 0, moOpDP::accent },
+        { u"\u20DC"_ustr, moOpDF::postfix, 880, 0, 0, moOpDP::accent },
+        { u"\u23B4"_ustr, moOpDF::postfix, 880, 0, 0, moOpDP::stretchy | moOpDP::accent },
+        { u"\u23B5"_ustr, moOpDF::postfix, 880, 0, 0, moOpDP::stretchy | moOpDP::accent },
+        { u"\u23DC"_ustr, moOpDF::postfix, 880, 0, 0, moOpDP::stretchy | moOpDP::accent },
+        { u"\u23DD"_ustr, moOpDF::postfix, 880, 0, 0, moOpDP::stretchy | moOpDP::accent },
+        { u"\u23DE"_ustr, moOpDF::postfix, 880, 0, 0, moOpDP::stretchy | moOpDP::accent },
+        { u"\u23DF"_ustr, moOpDF::postfix, 880, 0, 0, moOpDP::stretchy | moOpDP::accent },
+        { u"\u23E0"_ustr, moOpDF::postfix, 880, 0, 0, moOpDP::stretchy | moOpDP::accent },
+        { u"\u23E1"_ustr, moOpDF::postfix, 880, 0, 0, moOpDP::stretchy | moOpDP::accent },
+        { u"_"_ustr, moOpDF::infix, 900, 1, 1, moOpDP::nonedp } };
+
+std::vector<moOperatorData> starmathdatabase::moOperatorDataDictionary(
+    moOperatorDataDictionaryData, moOperatorDataDictionaryData + starmathdatabase::MATHML_MO_COUNT);
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/starmath/source/mathml/mathmlattr.cxx b/starmath/source/mathml/mathmlattr.cxx
new file mode 100644
index 0000000000..5e54f0d92e
--- /dev/null
+++ b/starmath/source/mathml/mathmlattr.cxx
@@ -0,0 +1,165 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4; fill-column: 100 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ */
+
+#include <mathmlattr.hxx>
+
+#include <o3tl/safeint.hxx>
+#include <o3tl/string_view.hxx>
+#include <rtl/math.h>
+
+#include <cstddef>
+#include <string_view>
+#include <unordered_map>
+
+static std::size_t ParseMathMLUnsignedNumber(std::u16string_view rStr, Fraction& rUN)
+{
+    auto nLen = rStr.length();
+    std::size_t nDecimalPoint = std::u16string_view::npos;
+    std::size_t nIdx;
+    sal_Int64 nom = 0;
+    sal_Int64 den = 1;
+    bool validNomDen = true;
+    for (nIdx = 0; nIdx < nLen; nIdx++)
+    {
+        auto cD = rStr[nIdx];
+        if (cD == u'.')
+        {
+            if (nDecimalPoint != std::u16string_view::npos)
+                return std::u16string_view::npos;
+            nDecimalPoint = nIdx;
+            continue;
+        }
+        if (cD < u'0' || u'9' < cD)
+            break;
+        if (validNomDen
+            && (o3tl::checked_multiply(nom, sal_Int64(10), nom)
+                || o3tl::checked_add(nom, sal_Int64(cD - u'0'), nom)
+                || nom >= std::numeric_limits<sal_Int32>::max()
+                || (nDecimalPoint != std::u16string_view::npos
+                    && o3tl::checked_multiply(den, sal_Int64(10), den))))
+        {
+            validNomDen = false;
+        }
+    }
+    if (nIdx == 0 || (nIdx == 1 && nDecimalPoint == 0))
+        return std::u16string_view::npos;
+
+    // If the input "xx.yyy" can be represented with nom = xx*10^n + yyy and den = 10^n in sal_Int64
+    // (where n is the length of "yyy"), then use that to create an accurate Fraction (and TODO: we
+    // could even ignore trailing "0" characters in "yyy", for a smaller n and thus a greater chance
+    // of validNomDen); if not, use the less accurate approach of creating a Fraction from double:
+    if (validNomDen)
+    {
+        rUN = Fraction(nom, den);
+    }
+    else
+    {
+        rUN = Fraction(
+            rtl_math_uStringToDouble(rStr.data(), rStr.data() + nIdx, '.', 0, nullptr, nullptr));
+    }
+
+    return nIdx;
+}
+
+static std::size_t ParseMathMLNumber(std::u16string_view rStr, Fraction& rN)
+{
+    if (rStr.empty())
+        return std::u16string_view::npos;
+    bool bNegative = (rStr[0] == '-');
+    std::size_t nOffset = bNegative ? 1 : 0;
+    auto nIdx = ParseMathMLUnsignedNumber(rStr.substr(nOffset), rN);
+    if (nIdx == std::u16string_view::npos || !rN.IsValid())
+        return std::u16string_view::npos;
+    if (bNegative)
+        rN *= -1;
+    return nOffset + nIdx;
+}
+
+bool ParseMathMLAttributeLengthValue(std::u16string_view rStr, MathMLAttributeLengthValue& rV)
+{
+    auto nIdx = ParseMathMLNumber(rStr, rV.aNumber);
+    if (nIdx == std::u16string_view::npos)
+        return false;
+    std::u16string_view sRest = rStr.substr(nIdx);
+    if (sRest.empty())
+    {
+        rV.eUnit = MathMLLengthUnit::None;
+    }
+    if (o3tl::starts_with(sRest, u"em"))
+    {
+        rV.eUnit = MathMLLengthUnit::Em;
+    }
+    if (o3tl::starts_with(sRest, u"ex"))
+    {
+        rV.eUnit = MathMLLengthUnit::Ex;
+    }
+    if (o3tl::starts_with(sRest, u"px"))
+    {
+        rV.eUnit = MathMLLengthUnit::Px;
+    }
+    if (o3tl::starts_with(sRest, u"in"))
+    {
+        rV.eUnit = MathMLLengthUnit::In;
+    }
+    if (o3tl::starts_with(sRest, u"cm"))
+    {
+        rV.eUnit = MathMLLengthUnit::Cm;
+    }
+    if (o3tl::starts_with(sRest, u"mm"))
+    {
+        rV.eUnit = MathMLLengthUnit::Mm;
+    }
+    if (o3tl::starts_with(sRest, u"pt"))
+    {
+        rV.eUnit = MathMLLengthUnit::Pt;
+    }
+    if (o3tl::starts_with(sRest, u"pc"))
+    {
+        rV.eUnit = MathMLLengthUnit::Pc;
+    }
+    if (sRest[0] == u'%')
+    {
+        rV.eUnit = MathMLLengthUnit::Percent;
+    }
+    return true;
+}
+
+bool GetMathMLMathvariantValue(const OUString& rStr, MathMLMathvariantValue& rV)
+{
+    static const std::unordered_map<OUString, MathMLMathvariantValue> aMap{
+        { "normal", MathMLMathvariantValue::Normal },
+        { "bold", MathMLMathvariantValue::Bold },
+        { "italic", MathMLMathvariantValue::Italic },
+        { "bold-italic", MathMLMathvariantValue::BoldItalic },
+        { "double-struck", MathMLMathvariantValue::DoubleStruck },
+        { "bold-fraktur", MathMLMathvariantValue::BoldFraktur },
+        { "script", MathMLMathvariantValue::Script },
+        { "bold-script", MathMLMathvariantValue::BoldScript },
+        { "fraktur", MathMLMathvariantValue::Fraktur },
+        { "sans-serif", MathMLMathvariantValue::SansSerif },
+        { "bold-sans-serif", MathMLMathvariantValue::BoldSansSerif },
+        { "sans-serif-italic", MathMLMathvariantValue::SansSerifItalic },
+        { "sans-serif-bold-italic", MathMLMathvariantValue::SansSerifBoldItalic },
+        { "monospace", MathMLMathvariantValue::Monospace },
+        { "initial", MathMLMathvariantValue::Initial },
+        { "tailed", MathMLMathvariantValue::Tailed },
+        { "looped", MathMLMathvariantValue::Looped },
+        { "stretched", MathMLMathvariantValue::Stretched }
+    };
+
+    auto it = aMap.find(rStr);
+    if (it != aMap.end())
+    {
+        rV = it->second;
+        return true;
+    }
+    return false;
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab cinoptions=b1,g0,N-s cinkeys+=0=break: */
diff --git a/starmath/source/mathml/mathmlexport.cxx b/starmath/source/mathml/mathmlexport.cxx
new file mode 100644
index 0000000000..1c18e716e7
--- /dev/null
+++ b/starmath/source/mathml/mathmlexport.cxx
@@ -0,0 +1,1443 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+/*
+ Warning: The SvXMLElementExport helper class creates the beginning and
+ closing tags of xml elements in its constructor and destructor, so there's
+ hidden stuff going on, on occasion the ordering of these classes declarations
+ may be significant
+*/
+
+#include <com/sun/star/xml/sax/Writer.hpp>
+#include <com/sun/star/beans/PropertyAttribute.hpp>
+#include <com/sun/star/embed/ElementModes.hpp>
+#include <com/sun/star/util/MeasureUnit.hpp>
+#include <com/sun/star/task/XStatusIndicator.hpp>
+#include <com/sun/star/uno/Any.h>
+
+#include <officecfg/Office/Common.hxx>
+#include <rtl/math.hxx>
+#include <sfx2/frame.hxx>
+#include <sfx2/docfile.hxx>
+#include <sfx2/sfxsids.hrc>
+#include <osl/diagnose.h>
+#include <sot/storage.hxx>
+#include <svl/itemset.hxx>
+#include <svl/stritem.hxx>
+#include <comphelper/fileformat.h>
+#include <comphelper/processfactory.hxx>
+#include <unotools/streamwrap.hxx>
+#include <sax/tools/converter.hxx>
+#include <xmloff/xmlnamespace.hxx>
+#include <xmloff/xmltoken.hxx>
+#include <xmloff/namespacemap.hxx>
+#include <comphelper/genericpropertyset.hxx>
+#include <comphelper/servicehelper.hxx>
+#include <comphelper/propertysetinfo.hxx>
+#include <comphelper/diagnose_ex.hxx>
+#include <sal/log.hxx>
+
+#include <stack>
+
+#include <mathmlexport.hxx>
+#include <xparsmlbase.hxx>
+#include <strings.hrc>
+#include <smmod.hxx>
+#include <unomodel.hxx>
+#include <document.hxx>
+#include <utility.hxx>
+#include <cfgitem.hxx>
+#include <starmathdatabase.hxx>
+
+using namespace ::com::sun::star::beans;
+using namespace ::com::sun::star::document;
+using namespace ::com::sun::star::lang;
+using namespace ::com::sun::star::uno;
+using namespace ::com::sun::star;
+using namespace ::xmloff::token;
+
+namespace
+{
+bool IsInPrivateUseArea(sal_uInt32 cChar) { return 0xE000 <= cChar && cChar <= 0xF8FF; }
+
+sal_uInt32 ConvertMathToMathML(std::u16string_view rText, sal_Int32 nIndex = 0)
+{
+    auto cRes = o3tl::iterateCodePoints(rText, &nIndex);
+    if (IsInPrivateUseArea(cRes))
+    {
+        SAL_WARN("starmath", "Error: private use area characters should no longer be in use!");
+        cRes = u'@'; // just some character that should easily be notice as odd in the context
+    }
+    return cRes;
+}
+}
+
+bool SmXMLExportWrapper::Export(SfxMedium& rMedium)
+{
+    bool bRet = true;
+    uno::Reference<uno::XComponentContext> xContext(comphelper::getProcessComponentContext());
+
+    //Get model
+    uno::Reference<lang::XComponent> xModelComp = xModel;
+
+    bool bEmbedded = false;
+    SmModel* pModel = comphelper::getFromUnoTunnel<SmModel>(xModel);
+
+    SmDocShell* pDocShell = pModel ? static_cast<SmDocShell*>(pModel->GetObjectShell()) : nullptr;
+    if (pDocShell && SfxObjectCreateMode::EMBEDDED == pDocShell->GetCreateMode())
+        bEmbedded = true;
+
+    uno::Reference<task::XStatusIndicator> xStatusIndicator;
+    if (!bEmbedded)
+    {
+        if (pDocShell /*&& pDocShell->GetMedium()*/)
+        {
+            OSL_ENSURE(pDocShell->GetMedium() == &rMedium, "different SfxMedium found");
+
+            const SfxUnoAnyItem* pItem
+                = rMedium.GetItemSet().GetItem(SID_PROGRESS_STATUSBAR_CONTROL);
+            if (pItem)
+                pItem->GetValue() >>= xStatusIndicator;
+        }
+
+        // set progress range and start status indicator
+        if (xStatusIndicator.is())
+        {
+            sal_Int32 nProgressRange = bFlat ? 1 : 3;
+            xStatusIndicator->start(SmResId(STR_STATSTR_WRITING), nProgressRange);
+        }
+    }
+
+    static constexpr OUString sUsePrettyPrinting(u"UsePrettyPrinting"_ustr);
+    static constexpr OUString sBaseURI(u"BaseURI"_ustr);
+    static constexpr OUString sStreamRelPath(u"StreamRelPath"_ustr);
+    static constexpr OUString sStreamName(u"StreamName"_ustr);
+
+    // create XPropertySet with three properties for status indicator
+    static const comphelper::PropertyMapEntry aInfoMap[] = {
+        { sUsePrettyPrinting, 0, cppu::UnoType<bool>::get(), beans::PropertyAttribute::MAYBEVOID,
+          0 },
+        { sBaseURI, 0, ::cppu::UnoType<OUString>::get(), beans::PropertyAttribute::MAYBEVOID, 0 },
+        { sStreamRelPath, 0, ::cppu::UnoType<OUString>::get(), beans::PropertyAttribute::MAYBEVOID,
+          0 },
+        { sStreamName, 0, ::cppu::UnoType<OUString>::get(), beans::PropertyAttribute::MAYBEVOID, 0 }
+    };
+    uno::Reference<beans::XPropertySet> xInfoSet(
+        comphelper::GenericPropertySet_CreateInstance(new comphelper::PropertySetInfo(aInfoMap)));
+
+    bool bUsePrettyPrinting
+        = bFlat || officecfg::Office::Common::Save::Document::PrettyPrinting::get();
+    xInfoSet->setPropertyValue(sUsePrettyPrinting, Any(bUsePrettyPrinting));
+
+    // Set base URI
+    xInfoSet->setPropertyValue(sBaseURI, Any(rMedium.GetBaseURL(true)));
+
+    sal_Int32 nSteps = 0;
+    if (xStatusIndicator.is())
+        xStatusIndicator->setValue(nSteps++);
+    if (!bFlat) //Storage (Package) of Stream
+    {
+        uno::Reference<embed::XStorage> xStg = rMedium.GetOutputStorage();
+        bool bOASIS = (SotStorage::GetVersion(xStg) > SOFFICE_FILEFORMAT_60);
+
+        // TODO/LATER: handle the case of embedded links gracefully
+        if (bEmbedded) //&& !pStg->IsRoot() )
+        {
+            OUString aName;
+            const SfxStringItem* pDocHierarchItem
+                = rMedium.GetItemSet().GetItem(SID_DOC_HIERARCHICALNAME);
+            if (pDocHierarchItem)
+                aName = pDocHierarchItem->GetValue();
+
+            if (!aName.isEmpty())
+            {
+                xInfoSet->setPropertyValue(sStreamRelPath, Any(aName));
+            }
+        }
+
+        if (!bEmbedded)
+        {
+            if (xStatusIndicator.is())
+                xStatusIndicator->setValue(nSteps++);
+
+            bRet = WriteThroughComponent(xStg, xModelComp, "meta.xml", xContext, xInfoSet,
+                                         (bOASIS ? "com.sun.star.comp.Math.XMLOasisMetaExporter"
+                                                 : "com.sun.star.comp.Math.XMLMetaExporter"));
+        }
+        if (bRet)
+        {
+            if (xStatusIndicator.is())
+                xStatusIndicator->setValue(nSteps++);
+
+            bRet = WriteThroughComponent(xStg, xModelComp, "content.xml", xContext, xInfoSet,
+                                         "com.sun.star.comp.Math.XMLContentExporter");
+        }
+
+        if (bRet)
+        {
+            if (xStatusIndicator.is())
+                xStatusIndicator->setValue(nSteps++);
+
+            bRet = WriteThroughComponent(xStg, xModelComp, "settings.xml", xContext, xInfoSet,
+                                         (bOASIS ? "com.sun.star.comp.Math.XMLOasisSettingsExporter"
+                                                 : "com.sun.star.comp.Math.XMLSettingsExporter"));
+        }
+    }
+    else
+    {
+        SvStream* pStream = rMedium.GetOutStream();
+        uno::Reference<io::XOutputStream> xOut(new utl::OOutputStreamWrapper(*pStream));
+
+        if (xStatusIndicator.is())
+            xStatusIndicator->setValue(nSteps++);
+
+        bRet = WriteThroughComponent(xOut, xModelComp, xContext, xInfoSet,
+                                     "com.sun.star.comp.Math.XMLContentExporter");
+    }
+
+    if (xStatusIndicator.is())
+        xStatusIndicator->end();
+
+    return bRet;
+}
+
+/// export through an XML exporter component (output stream version)
+bool SmXMLExportWrapper::WriteThroughComponent(const Reference<io::XOutputStream>& xOutputStream,
+                                               const Reference<XComponent>& xComponent,
+                                               Reference<uno::XComponentContext> const& rxContext,
+                                               Reference<beans::XPropertySet> const& rPropSet,
+                                               const char* pComponentName)
+{
+    OSL_ENSURE(xOutputStream.is(), "I really need an output stream!");
+    OSL_ENSURE(xComponent.is(), "Need component!");
+    OSL_ENSURE(nullptr != pComponentName, "Need component name!");
+
+    // get component
+    Reference<xml::sax::XWriter> xSaxWriter = xml::sax::Writer::create(rxContext);
+
+    // connect XML writer to output stream
+    xSaxWriter->setOutputStream(xOutputStream);
+    if (m_bUseHTMLMLEntities)
+        xSaxWriter->setCustomEntityNames(starmathdatabase::icustomMathmlHtmlEntitiesExport);
+
+    // prepare arguments (prepend doc handler to given arguments)
+    Sequence<Any> aArgs{ Any(xSaxWriter), Any(rPropSet) };
+
+    // get filter component
+    Reference<document::XExporter> xExporter(
+        rxContext->getServiceManager()->createInstanceWithArgumentsAndContext(
+            OUString::createFromAscii(pComponentName), aArgs, rxContext),
+        UNO_QUERY);
+    OSL_ENSURE(xExporter.is(), "can't instantiate export filter component");
+    if (!xExporter.is())
+        return false;
+
+    // connect model and filter
+    xExporter->setSourceDocument(xComponent);
+
+    // filter!
+    Reference<XFilter> xFilter(xExporter, UNO_QUERY);
+    uno::Sequence<PropertyValue> aProps(0);
+    xFilter->filter(aProps);
+
+    auto pFilter = dynamic_cast<SmXMLExport*>(xFilter.get());
+    return pFilter == nullptr || pFilter->GetSuccess();
+}
+
+/// export through an XML exporter component (storage version)
+bool SmXMLExportWrapper::WriteThroughComponent(const Reference<embed::XStorage>& xStorage,
+                                               const Reference<XComponent>& xComponent,
+                                               const char* pStreamName,
+                                               Reference<uno::XComponentContext> const& rxContext,
+                                               Reference<beans::XPropertySet> const& rPropSet,
+                                               const char* pComponentName)
+{
+    OSL_ENSURE(xStorage.is(), "Need storage!");
+    OSL_ENSURE(nullptr != pStreamName, "Need stream name!");
+
+    // open stream
+    Reference<io::XStream> xStream;
+    OUString sStreamName = OUString::createFromAscii(pStreamName);
+    try
+    {
+        xStream = xStorage->openStreamElement(sStreamName, embed::ElementModes::READWRITE
+                                                               | embed::ElementModes::TRUNCATE);
+    }
+    catch (const uno::Exception&)
+    {
+        DBG_UNHANDLED_EXCEPTION("starmath", "Can't create output stream in package");
+        return false;
+    }
+
+    uno::Reference<beans::XPropertySet> xSet(xStream, uno::UNO_QUERY);
+    static constexpr OUStringLiteral sMediaType = u"MediaType";
+    static constexpr OUStringLiteral sTextXml = u"text/xml";
+    xSet->setPropertyValue(sMediaType, Any(OUString(sTextXml)));
+
+    // all streams must be encrypted in encrypted document
+    static constexpr OUStringLiteral sUseCommonStoragePasswordEncryption
+        = u"UseCommonStoragePasswordEncryption";
+    xSet->setPropertyValue(sUseCommonStoragePasswordEncryption, Any(true));
+
+    // set Base URL
+    if (rPropSet.is())
+    {
+        rPropSet->setPropertyValue("StreamName", Any(sStreamName));
+    }
+
+    // write the stuff
+    bool bRet = WriteThroughComponent(xStream->getOutputStream(), xComponent, rxContext, rPropSet,
+                                      pComponentName);
+
+    return bRet;
+}
+
+SmXMLExport::SmXMLExport(const css::uno::Reference<css::uno::XComponentContext>& rContext,
+                         OUString const& implementationName, SvXMLExportFlags nExportFlags)
+    : SvXMLExport(rContext, implementationName, util::MeasureUnit::INCH, XML_MATH, nExportFlags)
+    , pTree(nullptr)
+    , bSuccess(false)
+{
+}
+
+extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface*
+Math_XMLExporter_get_implementation(css::uno::XComponentContext* context,
+                                    css::uno::Sequence<css::uno::Any> const&)
+{
+    return cppu::acquire(new SmXMLExport(context, "com.sun.star.comp.Math.XMLExporter",
+                                         SvXMLExportFlags::OASIS | SvXMLExportFlags::ALL));
+}
+
+extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface*
+Math_XMLMetaExporter_get_implementation(css::uno::XComponentContext* context,
+                                        css::uno::Sequence<css::uno::Any> const&)
+{
+    return cppu::acquire(
+        new SmXMLExport(context, "com.sun.star.comp.Math.XMLMetaExporter", SvXMLExportFlags::META));
+}
+
+extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface*
+Math_XMLOasisMetaExporter_get_implementation(css::uno::XComponentContext* context,
+                                             css::uno::Sequence<css::uno::Any> const&)
+{
+    return cppu::acquire(new SmXMLExport(context, "com.sun.star.comp.Math.XMLOasisMetaExporter",
+                                         SvXMLExportFlags::OASIS | SvXMLExportFlags::META));
+}
+
+extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface*
+Math_XMLSettingsExporter_get_implementation(css::uno::XComponentContext* context,
+                                            css::uno::Sequence<css::uno::Any> const&)
+{
+    return cppu::acquire(new SmXMLExport(context, "com.sun.star.comp.Math.XMLSettingsExporter",
+                                         SvXMLExportFlags::SETTINGS));
+}
+
+extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface*
+Math_XMLOasisSettingsExporter_get_implementation(css::uno::XComponentContext* context,
+                                                 css::uno::Sequence<css::uno::Any> const&)
+{
+    return cppu::acquire(new SmXMLExport(context, "com.sun.star.comp.Math.XMLOasisSettingsExporter",
+                                         SvXMLExportFlags::OASIS | SvXMLExportFlags::SETTINGS));
+}
+
+extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface*
+Math_XMLContentExporter_get_implementation(css::uno::XComponentContext* context,
+                                           css::uno::Sequence<css::uno::Any> const&)
+{
+    return cppu::acquire(new SmXMLExport(context, "com.sun.star.comp.Math.XMLContentExporter",
+                                         SvXMLExportFlags::OASIS | SvXMLExportFlags::CONTENT));
+}
+
+ErrCode SmXMLExport::exportDoc(enum XMLTokenEnum eClass)
+{
+    if (!(getExportFlags() & SvXMLExportFlags::CONTENT))
+    {
+        SvXMLExport::exportDoc(eClass);
+    }
+    else
+    {
+        uno::Reference<frame::XModel> xModel = GetModel();
+        SmModel* pModel = comphelper::getFromUnoTunnel<SmModel>(xModel);
+
+        if (pModel)
+        {
+            SmDocShell* pDocShell = static_cast<SmDocShell*>(pModel->GetObjectShell());
+            pTree = pDocShell->GetFormulaTree();
+            aText = pDocShell->GetText();
+        }
+
+        GetDocHandler()->startDocument();
+
+        addChaffWhenEncryptedStorage();
+
+        /*Add xmlns line*/
+        comphelper::AttributeList& rList = GetAttrList();
+
+        // make use of a default namespace
+        ResetNamespaceMap(); // Math doesn't need namespaces from xmloff, since it now uses default namespaces (because that is common with current MathML usage in the web)
+        GetNamespaceMap_().Add(OUString(), GetXMLToken(XML_N_MATH), XML_NAMESPACE_MATH);
+
+        rList.AddAttribute(GetNamespaceMap().GetAttrNameByKey(XML_NAMESPACE_MATH),
+                           GetNamespaceMap().GetNameByKey(XML_NAMESPACE_MATH));
+
+        //I think we need something like ImplExportEntities();
+        ExportContent_();
+        GetDocHandler()->endDocument();
+    }
+
+    bSuccess = true;
+    return ERRCODE_NONE;
+}
+
+void SmXMLExport::ExportContent_()
+{
+    uno::Reference<frame::XModel> xModel = GetModel();
+    SmModel* pModel = comphelper::getFromUnoTunnel<SmModel>(xModel);
+    SmDocShell* pDocShell = pModel ? static_cast<SmDocShell*>(pModel->GetObjectShell()) : nullptr;
+    OSL_ENSURE(pDocShell, "doc shell missing");
+
+    if (pDocShell)
+    {
+        if (!pDocShell->GetFormat().IsTextmode())
+        {
+            // If the Math equation is not in text mode, we attach a display="block"
+            // attribute on the <math> root. We don't do anything if it is in
+            // text mode, the default display="inline" value will be used.
+            AddAttribute(XML_NAMESPACE_MATH, XML_DISPLAY, XML_BLOCK);
+        }
+        if (pDocShell->GetFormat().IsRightToLeft())
+        {
+            // If the Math equation is set right-to-left, we attach a dir="rtl"
+            // attribute on the <math> root. We don't do anything if it is set
+            // left-to-right, the default dir="ltr" value will be used.
+            AddAttribute(XML_NAMESPACE_MATH, XML_DIR, XML_RTL);
+        }
+    }
+
+    SvXMLElementExport aEquation(*this, XML_NAMESPACE_MATH, XML_MATH, true, true);
+    std::unique_ptr<SvXMLElementExport> pSemantics;
+
+    if (!aText.isEmpty())
+    {
+        pSemantics.reset(
+            new SvXMLElementExport(*this, XML_NAMESPACE_MATH, XML_SEMANTICS, true, true));
+    }
+
+    ExportNodes(pTree, 0);
+
+    if (aText.isEmpty())
+        return;
+
+    SmModule* pMod = SM_MOD();
+    sal_Int16 nSmSyntaxVersion = pMod->GetConfig()->GetDefaultSmSyntaxVersion();
+
+    // Convert symbol names
+    if (pDocShell)
+    {
+        nSmSyntaxVersion = pDocShell->GetSmSyntaxVersion();
+        AbstractSmParser* rParser = pDocShell->GetParser();
+        bool bVal = rParser->IsExportSymbolNames();
+        rParser->SetExportSymbolNames(true);
+        auto pTmpTree = rParser->Parse(aText);
+        aText = rParser->GetText();
+        pTmpTree.reset();
+        rParser->SetExportSymbolNames(bVal);
+    }
+
+    OUStringBuffer sStrBuf(12);
+    sStrBuf.append(u"StarMath ");
+    if (nSmSyntaxVersion == 5)
+        sStrBuf.append(u"5.0");
+    else
+        sStrBuf.append(static_cast<sal_Int32>(nSmSyntaxVersion));
+
+    AddAttribute(XML_NAMESPACE_MATH, XML_ENCODING, sStrBuf.makeStringAndClear());
+    SvXMLElementExport aAnnotation(*this, XML_NAMESPACE_MATH, XML_ANNOTATION, true, false);
+    GetDocHandler()->characters(aText);
+}
+
+void SmXMLExport::GetViewSettings(Sequence<PropertyValue>& aProps)
+{
+    uno::Reference<frame::XModel> xModel = GetModel();
+    if (!xModel.is())
+        return;
+
+    SmModel* pModel = comphelper::getFromUnoTunnel<SmModel>(xModel);
+
+    if (!pModel)
+        return;
+
+    SmDocShell* pDocShell = static_cast<SmDocShell*>(pModel->GetObjectShell());
+    if (!pDocShell)
+        return;
+
+    aProps.realloc(4);
+    PropertyValue* pValue = aProps.getArray();
+    sal_Int32 nIndex = 0;
+
+    tools::Rectangle aRect(pDocShell->GetVisArea());
+
+    pValue[nIndex].Name = "ViewAreaTop";
+    pValue[nIndex++].Value <<= aRect.Top();
+
+    pValue[nIndex].Name = "ViewAreaLeft";
+    pValue[nIndex++].Value <<= aRect.Left();
+
+    pValue[nIndex].Name = "ViewAreaWidth";
+    pValue[nIndex++].Value <<= aRect.GetWidth();
+
+    pValue[nIndex].Name = "ViewAreaHeight";
+    pValue[nIndex++].Value <<= aRect.GetHeight();
+}
+
+void SmXMLExport::GetConfigurationSettings(Sequence<PropertyValue>& rProps)
+{
+    Reference<XPropertySet> xProps(GetModel(), UNO_QUERY);
+    if (!xProps.is())
+        return;
+
+    Reference<XPropertySetInfo> xPropertySetInfo = xProps->getPropertySetInfo();
+    if (!xPropertySetInfo.is())
+        return;
+
+    const Sequence<Property> aProps = xPropertySetInfo->getProperties();
+    const sal_Int32 nCount = aProps.getLength();
+    if (!nCount)
+        return;
+
+    rProps.realloc(nCount);
+    SmMathConfig* pConfig = SM_MOD()->GetConfig();
+    const bool bUsedSymbolsOnly = pConfig && pConfig->IsSaveOnlyUsedSymbols();
+
+    std::transform(aProps.begin(), aProps.end(), rProps.getArray(),
+                   [bUsedSymbolsOnly, &xProps](const Property& prop) {
+                       PropertyValue aRet;
+                       if (prop.Name != "Formula" && prop.Name != "BasicLibraries"
+                           && prop.Name != "DialogLibraries" && prop.Name != "RuntimeUID")
+                       {
+                           aRet.Name = prop.Name;
+                           OUString aActualName(prop.Name);
+                           // handle 'save used symbols only'
+                           static constexpr OUStringLiteral sUserDefinedSymbolsInUse
+                               = u"UserDefinedSymbolsInUse";
+                           if (bUsedSymbolsOnly && prop.Name == "Symbols")
+                               aActualName = sUserDefinedSymbolsInUse;
+                           aRet.Value = xProps->getPropertyValue(aActualName);
+                       }
+                       return aRet;
+                   });
+}
+
+void SmXMLExport::ExportLine(const SmNode* pNode, int nLevel) { ExportExpression(pNode, nLevel); }
+
+void SmXMLExport::ExportBinaryHorizontal(const SmNode* pNode, int nLevel)
+{
+    TG nGroup = pNode->GetToken().nGroup;
+
+    SvXMLElementExport aRow(*this, XML_NAMESPACE_MATH, XML_MROW, true, true);
+
+    // Unfold the binary tree structure as long as the nodes are SmBinHorNode
+    // with the same nGroup. This will reduce the number of nested <mrow>
+    // elements e.g. we only need three <mrow> levels to export
+
+    // "a*b*c*d+e*f*g*h+i*j*k*l = a*b*c*d+e*f*g*h+i*j*k*l =
+    //  a*b*c*d+e*f*g*h+i*j*k*l = a*b*c*d+e*f*g*h+i*j*k*l"
+
+    // See https://www.libreoffice.org/bugzilla/show_bug.cgi?id=66081
+    ::std::stack<const SmNode*> s;
+    s.push(pNode);
+    while (!s.empty())
+    {
+        const SmNode* node = s.top();
+        s.pop();
+        if (node->GetType() != SmNodeType::BinHor || node->GetToken().nGroup != nGroup)
+        {
+            ExportNodes(node, nLevel + 1);
+            continue;
+        }
+        const SmBinHorNode* binNode = static_cast<const SmBinHorNode*>(node);
+        s.push(binNode->RightOperand());
+        s.push(binNode->Symbol());
+        s.push(binNode->LeftOperand());
+    }
+}
+
+void SmXMLExport::ExportUnaryHorizontal(const SmNode* pNode, int nLevel)
+{
+    ExportExpression(pNode, nLevel);
+}
+
+void SmXMLExport::ExportExpression(const SmNode* pNode, int nLevel,
+                                   bool bNoMrowContainer /*=false*/)
+{
+    std::unique_ptr<SvXMLElementExport> pRow;
+    size_t nSize = pNode->GetNumSubNodes();
+
+    // #i115443: nodes of type expression always need to be grouped with mrow statement
+    if (!bNoMrowContainer && (nSize > 1 || pNode->GetType() == SmNodeType::Expression))
+        pRow.reset(new SvXMLElementExport(*this, XML_NAMESPACE_MATH, XML_MROW, true, true));
+
+    for (size_t i = 0; i < nSize; ++i)
+    {
+        if (const SmNode* pTemp = pNode->GetSubNode(i))
+            ExportNodes(pTemp, nLevel + 1);
+    }
+}
+
+void SmXMLExport::ExportBinaryVertical(const SmNode* pNode, int nLevel)
+{
+    assert(pNode->GetNumSubNodes() == 3);
+    const SmNode* pNum = pNode->GetSubNode(0);
+    const SmNode* pDenom = pNode->GetSubNode(2);
+    if (pNum->GetType() == SmNodeType::Align && pNum->GetToken().eType != TALIGNC)
+    {
+        // A left or right alignment is specified on the numerator:
+        // attach the corresponding numalign attribute.
+        AddAttribute(XML_NAMESPACE_MATH, XML_NUMALIGN,
+                     pNum->GetToken().eType == TALIGNL ? XML_LEFT : XML_RIGHT);
+    }
+    if (pDenom->GetType() == SmNodeType::Align && pDenom->GetToken().eType != TALIGNC)
+    {
+        // A left or right alignment is specified on the denominator:
+        // attach the corresponding denomalign attribute.
+        AddAttribute(XML_NAMESPACE_MATH, XML_DENOMALIGN,
+                     pDenom->GetToken().eType == TALIGNL ? XML_LEFT : XML_RIGHT);
+    }
+    SvXMLElementExport aFraction(*this, XML_NAMESPACE_MATH, XML_MFRAC, true, true);
+    ExportNodes(pNum, nLevel);
+    ExportNodes(pDenom, nLevel);
+}
+
+void SmXMLExport::ExportBinaryDiagonal(const SmNode* pNode, int nLevel)
+{
+    assert(pNode->GetNumSubNodes() == 3);
+
+    if (pNode->GetToken().eType == TWIDESLASH)
+    {
+        // wideslash
+        // export the node as <mfrac bevelled="true">
+        AddAttribute(XML_NAMESPACE_MATH, XML_BEVELLED, XML_TRUE);
+        SvXMLElementExport aFraction(*this, XML_NAMESPACE_MATH, XML_MFRAC, true, true);
+        ExportNodes(pNode->GetSubNode(0), nLevel);
+        ExportNodes(pNode->GetSubNode(1), nLevel);
+    }
+    else
+    {
+        // widebslash
+        // We can not use <mfrac> to a backslash, so just use <mo>\</mo>
+        SvXMLElementExport aRow(*this, XML_NAMESPACE_MATH, XML_MROW, true, true);
+
+        ExportNodes(pNode->GetSubNode(0), nLevel);
+
+        { // Scoping for <mo> creation
+            SvXMLElementExport aMo(*this, XML_NAMESPACE_MATH, XML_MO, true, true);
+            GetDocHandler()->characters(OUStringChar(MS_BACKSLASH));
+        }
+
+        ExportNodes(pNode->GetSubNode(1), nLevel);
+    }
+}
+
+void SmXMLExport::ExportTable(const SmNode* pNode, int nLevel)
+{
+    std::unique_ptr<SvXMLElementExport> pTable;
+
+    size_t nSize = pNode->GetNumSubNodes();
+
+    //If the list ends in newline then the last entry has
+    //no subnodes, the newline is superfluous so we just drop
+    //the last node, inclusion would create a bad MathML
+    //table
+    if (nSize >= 1)
+    {
+        const SmNode* pLine = pNode->GetSubNode(nSize - 1);
+        if (pLine->GetType() == SmNodeType::Line && pLine->GetNumSubNodes() == 1
+            && pLine->GetSubNode(0) != nullptr
+            && pLine->GetSubNode(0)->GetToken().eType == TNEWLINE)
+            --nSize;
+    }
+
+    // try to avoid creating a mtable element when the formula consists only
+    // of a single output line
+    if (nLevel || (nSize > 1))
+        pTable.reset(new SvXMLElementExport(*this, XML_NAMESPACE_MATH, XML_MTABLE, true, true));
+
+    for (size_t i = 0; i < nSize; ++i)
+    {
+        if (const SmNode* pTemp = pNode->GetSubNode(i))
+        {
+            std::unique_ptr<SvXMLElementExport> pRow;
+            std::unique_ptr<SvXMLElementExport> pCell;
+            if (pTable)
+            {
+                pRow.reset(new SvXMLElementExport(*this, XML_NAMESPACE_MATH, XML_MTR, true, true));
+                SmTokenType eAlign = TALIGNC;
+                if (pTemp->GetType() == SmNodeType::Align)
+                {
+                    // For Binom() and Stack() constructions, the SmNodeType::Align nodes
+                    // are direct children.
+                    // binom{alignl ...}{alignr ...} and
+                    // stack{alignl ... ## alignr ... ## ...}
+                    eAlign = pTemp->GetToken().eType;
+                }
+                else if (pTemp->GetType() == SmNodeType::Line && pTemp->GetNumSubNodes() == 1
+                         && pTemp->GetSubNode(0)
+                         && pTemp->GetSubNode(0)->GetType() == SmNodeType::Align)
+                {
+                    // For the Table() construction, the SmNodeType::Align node is a child
+                    // of an SmNodeType::Line node.
+                    // alignl ... newline alignr ... newline ...
+                    eAlign = pTemp->GetSubNode(0)->GetToken().eType;
+                }
+                if (eAlign != TALIGNC)
+                {
+                    // If a left or right alignment is specified on this line,
+                    // attach the corresponding columnalign attribute.
+                    AddAttribute(XML_NAMESPACE_MATH, XML_COLUMNALIGN,
+                                 eAlign == TALIGNL ? XML_LEFT : XML_RIGHT);
+                }
+                pCell.reset(new SvXMLElementExport(*this, XML_NAMESPACE_MATH, XML_MTD, true, true));
+            }
+            ExportNodes(pTemp, nLevel + 1);
+        }
+    }
+}
+
+void SmXMLExport::ExportMath(const SmNode* pNode)
+{
+    const SmTextNode* pTemp = static_cast<const SmTextNode*>(pNode);
+    std::unique_ptr<SvXMLElementExport> pMath;
+
+    if (pNode->GetType() == SmNodeType::Math || pNode->GetType() == SmNodeType::GlyphSpecial)
+    {
+        // Export SmNodeType::Math and SmNodeType::GlyphSpecial symbols as <mo> elements
+        pMath.reset(new SvXMLElementExport(*this, XML_NAMESPACE_MATH, XML_MO, true, false));
+    }
+    else if (pNode->GetType() == SmNodeType::Special)
+    {
+        bool bIsItalic = IsItalic(pNode->GetFont());
+        if (!bIsItalic)
+            AddAttribute(XML_NAMESPACE_MATH, XML_MATHVARIANT, XML_NORMAL);
+        pMath.reset(new SvXMLElementExport(*this, XML_NAMESPACE_MATH, XML_MI, true, false));
+    }
+    else
+    {
+        // Export SmNodeType::MathIdent and SmNodeType::Place symbols as <mi> elements:
+        // - These math symbols should not be drawn slanted. Hence we should
+        // attach a mathvariant="normal" attribute to single-char <mi> elements
+        // that are not mathematical alphanumeric symbol. For simplicity and to
+        // work around browser limitations, we always attach such an attribute.
+        // - The MathML specification suggests to use empty <mi> elements as
+        // placeholders but they won't be visible in most MathML rendering
+        // engines so let's use an empty square for SmNodeType::Place instead.
+        AddAttribute(XML_NAMESPACE_MATH, XML_MATHVARIANT, XML_NORMAL);
+        pMath.reset(new SvXMLElementExport(*this, XML_NAMESPACE_MATH, XML_MI, true, false));
+    }
+    auto nArse = ConvertMathToMathML(pTemp->GetText());
+    OSL_ENSURE(nArse != 0xffff, "Non existent symbol");
+    GetDocHandler()->characters(OUString(&nArse, 1));
+}
+
+void SmXMLExport::ExportText(const SmNode* pNode)
+{
+    std::unique_ptr<SvXMLElementExport> pText;
+    const SmTextNode* pTemp = static_cast<const SmTextNode*>(pNode);
+    switch (pNode->GetToken().eType)
+    {
+        default:
+        case TIDENT:
+        {
+            //Note that we change the fontstyle to italic for strings that
+            //are italic and longer than a single character.
+            bool bIsItalic = IsItalic(pTemp->GetFont());
+            if ((pTemp->GetText().getLength() > 1) && bIsItalic)
+                AddAttribute(XML_NAMESPACE_MATH, XML_MATHVARIANT, XML_ITALIC);
+            else if ((pTemp->GetText().getLength() == 1) && !bIsItalic)
+                AddAttribute(XML_NAMESPACE_MATH, XML_MATHVARIANT, XML_NORMAL);
+            pText.reset(new SvXMLElementExport(*this, XML_NAMESPACE_MATH, XML_MI, true, false));
+            break;
+        }
+        case TNUMBER:
+            pText.reset(new SvXMLElementExport(*this, XML_NAMESPACE_MATH, XML_MN, true, false));
+            break;
+        case TTEXT:
+            pText.reset(new SvXMLElementExport(*this, XML_NAMESPACE_MATH, XML_MTEXT, true, false));
+            break;
+    }
+    GetDocHandler()->characters(pTemp->GetText());
+}
+
+void SmXMLExport::ExportBlank(const SmNode* pNode)
+{
+    const SmBlankNode* pTemp = static_cast<const SmBlankNode*>(pNode);
+    //!! exports an <mspace> element. Note that for example "~_~" is allowed in
+    //!! Math (so it has no sense at all) but must not result in an empty
+    //!! <msub> tag in MathML !!
+
+    if (pTemp->GetBlankNum() != 0)
+    {
+        // Attach a width attribute. We choose the (somewhat arbitrary) values
+        // ".5em" for a small gap '`' and "2em" for a large gap '~'.
+        // (see SmBlankNode::IncreaseBy for how pTemp->mnNum is set).
+        OUStringBuffer sStrBuf;
+        ::sax::Converter::convertDouble(sStrBuf, pTemp->GetBlankNum() * .5);
+        sStrBuf.append("em");
+        AddAttribute(XML_NAMESPACE_MATH, XML_WIDTH, sStrBuf.makeStringAndClear());
+    }
+
+    SvXMLElementExport aTextExport(*this, XML_NAMESPACE_MATH, XML_MSPACE, true, false);
+
+    GetDocHandler()->characters(OUString());
+}
+
+void SmXMLExport::ExportSubSupScript(const SmNode* pNode, int nLevel)
+{
+    const SmNode* pSub = nullptr;
+    const SmNode* pSup = nullptr;
+    const SmNode* pCSub = nullptr;
+    const SmNode* pCSup = nullptr;
+    const SmNode* pLSub = nullptr;
+    const SmNode* pLSup = nullptr;
+    std::unique_ptr<SvXMLElementExport> pThing2;
+
+    //if we have prescripts at all then we must use the tensor notation
+
+    //This is one of those excellent locations where scope is vital to
+    //arrange the construction and destruction of the element helper
+    //classes correctly
+    pLSub = pNode->GetSubNode(LSUB + 1);
+    pLSup = pNode->GetSubNode(LSUP + 1);
+    if (pLSub || pLSup)
+    {
+        SvXMLElementExport aMultiScripts(*this, XML_NAMESPACE_MATH, XML_MMULTISCRIPTS, true, true);
+
+        if (nullptr != (pCSub = pNode->GetSubNode(CSUB + 1))
+            && nullptr != (pCSup = pNode->GetSubNode(CSUP + 1)))
+        {
+            pThing2.reset(
+                new SvXMLElementExport(*this, XML_NAMESPACE_MATH, XML_MUNDEROVER, true, true));
+        }
+        else if (nullptr != (pCSub = pNode->GetSubNode(CSUB + 1)))
+        {
+            pThing2.reset(
+                new SvXMLElementExport(*this, XML_NAMESPACE_MATH, XML_MUNDER, true, true));
+        }
+        else if (nullptr != (pCSup = pNode->GetSubNode(CSUP + 1)))
+        {
+            pThing2.reset(new SvXMLElementExport(*this, XML_NAMESPACE_MATH, XML_MOVER, true, true));
+        }
+
+        ExportNodes(pNode->GetSubNode(0), nLevel + 1); //Main Term
+
+        if (pCSub)
+            ExportNodes(pCSub, nLevel + 1);
+        if (pCSup)
+            ExportNodes(pCSup, nLevel + 1);
+        pThing2.reset();
+
+        pSub = pNode->GetSubNode(RSUB + 1);
+        pSup = pNode->GetSubNode(RSUP + 1);
+        if (pSub || pSup)
+        {
+            if (pSub)
+                ExportNodes(pSub, nLevel + 1);
+            else
+            {
+                SvXMLElementExport aNone(*this, XML_NAMESPACE_MATH, XML_NONE, true, true);
+            }
+            if (pSup)
+                ExportNodes(pSup, nLevel + 1);
+            else
+            {
+                SvXMLElementExport aNone(*this, XML_NAMESPACE_MATH, XML_NONE, true, true);
+            }
+        }
+
+        //Separator element between suffix and prefix sub/sup pairs
+        {
+            SvXMLElementExport aPrescripts(*this, XML_NAMESPACE_MATH, XML_MPRESCRIPTS, true, true);
+        }
+
+        if (pLSub)
+            ExportNodes(pLSub, nLevel + 1);
+        else
+        {
+            SvXMLElementExport aNone(*this, XML_NAMESPACE_MATH, XML_NONE, true, true);
+        }
+        if (pLSup)
+            ExportNodes(pLSup, nLevel + 1);
+        else
+        {
+            SvXMLElementExport aNone(*this, XML_NAMESPACE_MATH, XML_NONE, true, true);
+        }
+    }
+    else
+    {
+        std::unique_ptr<SvXMLElementExport> pThing;
+        if (nullptr != (pSub = pNode->GetSubNode(RSUB + 1))
+            && nullptr != (pSup = pNode->GetSubNode(RSUP + 1)))
+        {
+            pThing.reset(
+                new SvXMLElementExport(*this, XML_NAMESPACE_MATH, XML_MSUBSUP, true, true));
+        }
+        else if (nullptr != (pSub = pNode->GetSubNode(RSUB + 1)))
+        {
+            pThing.reset(new SvXMLElementExport(*this, XML_NAMESPACE_MATH, XML_MSUB, true, true));
+        }
+        else if (nullptr != (pSup = pNode->GetSubNode(RSUP + 1)))
+        {
+            pThing.reset(new SvXMLElementExport(*this, XML_NAMESPACE_MATH, XML_MSUP, true, true));
+        }
+
+        if (nullptr != (pCSub = pNode->GetSubNode(CSUB + 1))
+            && nullptr != (pCSup = pNode->GetSubNode(CSUP + 1)))
+        {
+            pThing2.reset(
+                new SvXMLElementExport(*this, XML_NAMESPACE_MATH, XML_MUNDEROVER, true, true));
+        }
+        else if (nullptr != (pCSub = pNode->GetSubNode(CSUB + 1)))
+        {
+            pThing2.reset(
+                new SvXMLElementExport(*this, XML_NAMESPACE_MATH, XML_MUNDER, true, true));
+        }
+        else if (nullptr != (pCSup = pNode->GetSubNode(CSUP + 1)))
+        {
+            pThing2.reset(new SvXMLElementExport(*this, XML_NAMESPACE_MATH, XML_MOVER, true, true));
+        }
+        ExportNodes(pNode->GetSubNode(0), nLevel + 1); //Main Term
+
+        if (pCSub)
+            ExportNodes(pCSub, nLevel + 1);
+        if (pCSup)
+            ExportNodes(pCSup, nLevel + 1);
+        pThing2.reset();
+
+        if (pSub)
+            ExportNodes(pSub, nLevel + 1);
+        if (pSup)
+            ExportNodes(pSup, nLevel + 1);
+        pThing.reset();
+    }
+}
+
+void SmXMLExport::ExportBrace(const SmNode* pNode, int nLevel)
+{
+    const SmNode* pTemp;
+    const SmNode* pLeft = pNode->GetSubNode(0);
+    const SmNode* pRight = pNode->GetSubNode(2);
+
+    // This used to generate <mfenced> or <mrow>+<mo> elements according to
+    // the stretchiness of fences. The MathML recommendation defines an
+    // <mrow>+<mo> construction that is equivalent to the <mfenced> element:
+    // http://www.w3.org/TR/MathML3/chapter3.html#presm.mfenced
+    // To simplify our code and avoid issues with mfenced implementations in
+    // MathML rendering engines, we now always generate <mrow>+<mo> elements.
+    // See #fdo 66282.
+
+    // <mrow>
+    SvXMLElementExport aRow(*this, XML_NAMESPACE_MATH, XML_MROW, true, true);
+
+    //   <mo fence="true"> opening-fence </mo>
+    if (pLeft && (pLeft->GetToken().eType != TNONE))
+    {
+        AddAttribute(XML_NAMESPACE_MATH, XML_FENCE, XML_TRUE);
+        AddAttribute(XML_NAMESPACE_MATH, XML_FORM, XML_PREFIX);
+        if (pNode->GetScaleMode() == SmScaleMode::Height)
+            AddAttribute(XML_NAMESPACE_MATH, XML_STRETCHY, XML_TRUE);
+        else
+            AddAttribute(XML_NAMESPACE_MATH, XML_STRETCHY, XML_FALSE);
+        ExportNodes(pLeft, nLevel + 1);
+    }
+
+    if (nullptr != (pTemp = pNode->GetSubNode(1)))
+    {
+        // <mrow>
+        SvXMLElementExport aRowExport(*this, XML_NAMESPACE_MATH, XML_MROW, true, true);
+        ExportNodes(pTemp, nLevel + 1);
+        // </mrow>
+    }
+
+    //   <mo fence="true"> closing-fence </mo>
+    if (pRight && (pRight->GetToken().eType != TNONE))
+    {
+        AddAttribute(XML_NAMESPACE_MATH, XML_FENCE, XML_TRUE);
+        AddAttribute(XML_NAMESPACE_MATH, XML_FORM, XML_POSTFIX);
+        if (pNode->GetScaleMode() == SmScaleMode::Height)
+            AddAttribute(XML_NAMESPACE_MATH, XML_STRETCHY, XML_TRUE);
+        else
+            AddAttribute(XML_NAMESPACE_MATH, XML_STRETCHY, XML_FALSE);
+        ExportNodes(pRight, nLevel + 1);
+    }
+
+    // </mrow>
+}
+
+void SmXMLExport::ExportRoot(const SmNode* pNode, int nLevel)
+{
+    if (pNode->GetSubNode(0))
+    {
+        SvXMLElementExport aRoot(*this, XML_NAMESPACE_MATH, XML_MROOT, true, true);
+        ExportNodes(pNode->GetSubNode(2), nLevel + 1);
+        ExportNodes(pNode->GetSubNode(0), nLevel + 1);
+    }
+    else
+    {
+        SvXMLElementExport aSqrt(*this, XML_NAMESPACE_MATH, XML_MSQRT, true, true);
+        ExportNodes(pNode->GetSubNode(2), nLevel + 1);
+    }
+}
+
+void SmXMLExport::ExportOperator(const SmNode* pNode, int nLevel)
+{
+    /*we need to either use content or font and size attributes
+     *here*/
+    SvXMLElementExport aRow(*this, XML_NAMESPACE_MATH, XML_MROW, true, true);
+    ExportNodes(pNode->GetSubNode(0), nLevel + 1);
+    ExportNodes(pNode->GetSubNode(1), nLevel + 1);
+}
+
+void SmXMLExport::ExportAttributes(const SmNode* pNode, int nLevel)
+{
+    std::unique_ptr<SvXMLElementExport> pElement;
+
+    if (pNode->GetToken().eType == TUNDERLINE)
+    {
+        AddAttribute(XML_NAMESPACE_MATH, XML_ACCENTUNDER, XML_TRUE);
+        pElement.reset(new SvXMLElementExport(*this, XML_NAMESPACE_MATH, XML_MUNDER, true, true));
+    }
+    else if (pNode->GetToken().eType == TOVERSTRIKE)
+    {
+        // export as <menclose notation="horizontalstrike">
+        AddAttribute(XML_NAMESPACE_MATH, XML_NOTATION, XML_HORIZONTALSTRIKE);
+        pElement.reset(new SvXMLElementExport(*this, XML_NAMESPACE_MATH, XML_MENCLOSE, true, true));
+    }
+    else
+    {
+        AddAttribute(XML_NAMESPACE_MATH, XML_ACCENT, XML_TRUE);
+        pElement.reset(new SvXMLElementExport(*this, XML_NAMESPACE_MATH, XML_MOVER, true, true));
+    }
+
+    ExportNodes(pNode->GetSubNode(1), nLevel + 1);
+    switch (pNode->GetToken().eType)
+    {
+        case TOVERLINE:
+        {
+            //proper entity support required
+            SvXMLElementExport aMath(*this, XML_NAMESPACE_MATH, XML_MO, true, true);
+            static constexpr OUStringLiteral nArse = u"\u00AF";
+            GetDocHandler()->characters(nArse);
+        }
+        break;
+        case TUNDERLINE:
+        {
+            //proper entity support required
+            SvXMLElementExport aMath(*this, XML_NAMESPACE_MATH, XML_MO, true, true);
+            static constexpr OUStringLiteral nArse = u"\u0332";
+            GetDocHandler()->characters(nArse);
+        }
+        break;
+        case TOVERSTRIKE:
+            break;
+        case TWIDETILDE:
+        case TWIDEHAT:
+        case TWIDEVEC:
+        case TWIDEHARPOON:
+        {
+            // make these wide accents stretchy
+            AddAttribute(XML_NAMESPACE_MATH, XML_STRETCHY, XML_TRUE);
+            ExportNodes(pNode->GetSubNode(0), nLevel + 1);
+        }
+        break;
+        default:
+            ExportNodes(pNode->GetSubNode(0), nLevel + 1);
+            break;
+    }
+}
+
+static bool lcl_HasEffectOnMathvariant(const SmTokenType eType)
+{
+    return eType == TBOLD || eType == TNBOLD || eType == TITALIC || eType == TNITALIC
+           || eType == TSANS || eType == TSERIF || eType == TFIXED;
+}
+
+void SmXMLExport::ExportFont(const SmNode* pNode, int nLevel)
+{
+    // gather the mathvariant attribute relevant data from all
+    // successively following SmFontNodes...
+
+    int nBold = -1; // for the following variables: -1 = yet undefined; 0 = false; 1 = true;
+    int nItalic = -1; // for the following variables: -1 = yet undefined; 0 = false; 1 = true;
+    int nSansSerifFixed = -1;
+    SmTokenType eNodeType = TUNKNOWN;
+
+    for (;;)
+    {
+        eNodeType = pNode->GetToken().eType;
+        if (!lcl_HasEffectOnMathvariant(eNodeType))
+            break;
+        switch (eNodeType)
+        {
+            case TBOLD:
+                nBold = 1;
+                break;
+            case TNBOLD:
+                nBold = 0;
+                break;
+            case TITALIC:
+                nItalic = 1;
+                break;
+            case TNITALIC:
+                nItalic = 0;
+                break;
+            case TSANS:
+                nSansSerifFixed = 0;
+                break;
+            case TSERIF:
+                nSansSerifFixed = 1;
+                break;
+            case TFIXED:
+                nSansSerifFixed = 2;
+                break;
+            default:
+                SAL_WARN("starmath", "unexpected case");
+        }
+        // According to the parser every node that is to be evaluated here
+        // has a single non-zero subnode at index 1!! Thus we only need to check
+        // that single node for follow-up nodes that have an effect on the attribute.
+        if (pNode->GetNumSubNodes() > 1 && pNode->GetSubNode(1)
+            && lcl_HasEffectOnMathvariant(pNode->GetSubNode(1)->GetToken().eType))
+        {
+            pNode = pNode->GetSubNode(1);
+        }
+        else
+            break;
+    }
+
+    sal_uInt32 nc;
+    switch (pNode->GetToken().eType)
+    {
+        case TPHANTOM:
+            // No attribute needed. An <mphantom> element will be used below.
+            break;
+        case TMATHMLCOL:
+        {
+            nc = pNode->GetToken().cMathChar.toUInt32(16);
+            const OUString& sssStr = starmathdatabase::Identify_Color_MATHML(nc).aIdent;
+            AddAttribute(XML_NAMESPACE_MATH, XML_MATHCOLOR, sssStr);
+        }
+        break;
+        case TRGB:
+        case TRGBA:
+        case THEX:
+        case THTMLCOL:
+        case TDVIPSNAMESCOL:
+        case TICONICCOL:
+        {
+            nc = pNode->GetToken().cMathChar.toUInt32(16);
+            OUString ssStr("#" + Color(ColorTransparency, nc).AsRGBHEXString());
+            AddAttribute(XML_NAMESPACE_MATH, XML_MATHCOLOR, ssStr);
+        }
+        break;
+        case TSIZE:
+        {
+            const SmFontNode* pFontNode = static_cast<const SmFontNode*>(pNode);
+            const Fraction& aFrac = pFontNode->GetSizeParameter();
+
+            OUStringBuffer sStrBuf;
+            switch (pFontNode->GetSizeType())
+            {
+                case FontSizeType::MULTIPLY:
+                    ::sax::Converter::convertDouble(sStrBuf,
+                                                    static_cast<double>(aFrac * Fraction(100, 1)));
+                    sStrBuf.append('%');
+                    break;
+                case FontSizeType::DIVIDE:
+                    ::sax::Converter::convertDouble(sStrBuf,
+                                                    static_cast<double>(Fraction(100, 1) / aFrac));
+                    sStrBuf.append('%');
+                    break;
+                case FontSizeType::ABSOLUT:
+                    ::sax::Converter::convertDouble(sStrBuf, static_cast<double>(aFrac));
+                    sStrBuf.append(GetXMLToken(XML_UNIT_PT));
+                    break;
+                default:
+                {
+                    //The problem here is that the wheels fall off because
+                    //font size is stored in 100th's of a mm not pts, and
+                    //rounding errors take their toll on the original
+                    //value specified in points.
+
+                    //Must fix StarMath to retain the original pt values
+                    double mytest
+                        = o3tl::convert<double>(pFontNode->GetFont().GetFontSize().Height(),
+                                                SmO3tlLengthUnit(), o3tl::Length::pt);
+
+                    if (pFontNode->GetSizeType() == FontSizeType::MINUS)
+                        mytest -= static_cast<double>(aFrac);
+                    else
+                        mytest += static_cast<double>(aFrac);
+
+                    mytest = ::rtl::math::round(mytest, 1);
+                    ::sax::Converter::convertDouble(sStrBuf, mytest);
+                    sStrBuf.append(GetXMLToken(XML_UNIT_PT));
+                }
+                break;
+            }
+
+            OUString sStr(sStrBuf.makeStringAndClear());
+            AddAttribute(XML_NAMESPACE_MATH, XML_MATHSIZE, sStr);
+        }
+        break;
+        case TBOLD:
+        case TITALIC:
+        case TNBOLD:
+        case TNITALIC:
+        case TFIXED:
+        case TSANS:
+        case TSERIF:
+        {
+            // nBold:   -1 = yet undefined; 0 = false; 1 = true;
+            // nItalic: -1 = yet undefined; 0 = false; 1 = true;
+            // nSansSerifFixed: -1 = undefined; 0 = sans; 1 = serif; 2 = fixed;
+            const char* pText = "normal";
+            if (nSansSerifFixed == -1 || nSansSerifFixed == 1)
+            {
+                pText = "normal";
+                if (nBold == 1 && nItalic != 1)
+                    pText = "bold";
+                else if (nBold != 1 && nItalic == 1)
+                    pText = "italic";
+                else if (nBold == 1 && nItalic == 1)
+                    pText = "bold-italic";
+            }
+            else if (nSansSerifFixed == 0)
+            {
+                pText = "sans-serif";
+                if (nBold == 1 && nItalic != 1)
+                    pText = "bold-sans-serif";
+                else if (nBold != 1 && nItalic == 1)
+                    pText = "sans-serif-italic";
+                else if (nBold == 1 && nItalic == 1)
+                    pText = "sans-serif-bold-italic";
+            }
+            else if (nSansSerifFixed == 2)
+                pText = "monospace"; // no modifiers allowed for monospace ...
+            else
+            {
+                SAL_WARN("starmath", "unexpected case");
+            }
+            AddAttribute(XML_NAMESPACE_MATH, XML_MATHVARIANT, OUString::createFromAscii(pText));
+        }
+        break;
+        default:
+            break;
+    }
+    {
+        // Wrap everything in an <mphantom> or <mstyle> element. These elements
+        // are mrow-like, so ExportExpression doesn't need to add an explicit
+        // <mrow> element. See #fdo 66283.
+        SvXMLElementExport aElement(*this, XML_NAMESPACE_MATH,
+                                    pNode->GetToken().eType == TPHANTOM ? XML_MPHANTOM : XML_MSTYLE,
+                                    true, true);
+        ExportExpression(pNode, nLevel, true);
+    }
+}
+
+void SmXMLExport::ExportVerticalBrace(const SmVerticalBraceNode* pNode, int nLevel)
+{
+    // "[body] overbrace [script]"
+
+    // Position body, overbrace and script vertically. First place the overbrace
+    // OVER the body and then the script OVER this expression.
+
+    //      [script]
+    //   --[overbrace]--
+    // XXXXXX[body]XXXXXXX
+
+    // Similarly for the underbrace construction.
+
+    XMLTokenEnum which;
+
+    switch (pNode->GetToken().eType)
+    {
+        case TOVERBRACE:
+        default:
+            which = XML_MOVER;
+            break;
+        case TUNDERBRACE:
+            which = XML_MUNDER;
+            break;
+    }
+
+    SvXMLElementExport aOver1(*this, XML_NAMESPACE_MATH, which, true, true);
+    { //Scoping
+        // using accents will draw the over-/underbraces too close to the base
+        // see http://www.w3.org/TR/MathML2/chapter3.html#id.3.4.5.2
+        // also XML_ACCENT is illegal with XML_MUNDER. Thus no XML_ACCENT attribute here!
+        SvXMLElementExport aOver2(*this, XML_NAMESPACE_MATH, which, true, true);
+        ExportNodes(pNode->Body(), nLevel);
+        AddAttribute(XML_NAMESPACE_MATH, XML_STRETCHY, XML_TRUE);
+        ExportNodes(pNode->Brace(), nLevel);
+    }
+    ExportNodes(pNode->Script(), nLevel);
+}
+
+void SmXMLExport::ExportMatrix(const SmNode* pNode, int nLevel)
+{
+    SvXMLElementExport aTable(*this, XML_NAMESPACE_MATH, XML_MTABLE, true, true);
+    const SmMatrixNode* pMatrix = static_cast<const SmMatrixNode*>(pNode);
+    size_t i = 0;
+    for (sal_uInt16 y = 0; y < pMatrix->GetNumRows(); y++)
+    {
+        SvXMLElementExport aRow(*this, XML_NAMESPACE_MATH, XML_MTR, true, true);
+        for (sal_uInt16 x = 0; x < pMatrix->GetNumCols(); x++)
+        {
+            if (const SmNode* pTemp = pNode->GetSubNode(i++))
+            {
+                if (pTemp->GetType() == SmNodeType::Align && pTemp->GetToken().eType != TALIGNC)
+                {
+                    // A left or right alignment is specified on this cell,
+                    // attach the corresponding columnalign attribute.
+                    AddAttribute(XML_NAMESPACE_MATH, XML_COLUMNALIGN,
+                                 pTemp->GetToken().eType == TALIGNL ? XML_LEFT : XML_RIGHT);
+                }
+                SvXMLElementExport aCell(*this, XML_NAMESPACE_MATH, XML_MTD, true, true);
+                ExportNodes(pTemp, nLevel + 1);
+            }
+        }
+    }
+}
+
+void SmXMLExport::ExportNodes(const SmNode* pNode, int nLevel)
+{
+    if (!pNode)
+        return;
+    switch (pNode->GetType())
+    {
+        case SmNodeType::Table:
+            ExportTable(pNode, nLevel);
+            break;
+        case SmNodeType::Align:
+        case SmNodeType::Bracebody:
+        case SmNodeType::Expression:
+            ExportExpression(pNode, nLevel);
+            break;
+        case SmNodeType::Line:
+            ExportLine(pNode, nLevel);
+            break;
+        case SmNodeType::Text:
+            ExportText(pNode);
+            break;
+        case SmNodeType::GlyphSpecial:
+        case SmNodeType::Math:
+        {
+            const SmTextNode* pTemp = static_cast<const SmTextNode*>(pNode);
+            if (pTemp->GetText().isEmpty())
+            {
+                // no conversion to MathML implemented -> export it as text
+                // thus at least it will not vanish into nothing
+                ExportText(pNode);
+            }
+            else
+            {
+                switch (pNode->GetToken().eType)
+                {
+                    case TINTD:
+                        AddAttribute(XML_NAMESPACE_MATH, XML_STRETCHY, XML_TRUE);
+                        break;
+                    default:
+                        break;
+                }
+                //To fully handle generic MathML we need to implement the full
+                //operator dictionary, we will generate MathML with explicit
+                //stretchiness for now.
+                sal_Int16 nLength = GetAttrList().getLength();
+                bool bAddStretch = true;
+                for (sal_Int16 i = 0; i < nLength; i++)
+                {
+                    OUString sLocalName;
+                    sal_uInt16 nPrefix = GetNamespaceMap().GetKeyByAttrName(
+                        GetAttrList().getNameByIndex(i), &sLocalName);
+
+                    if ((XML_NAMESPACE_MATH == nPrefix) && IsXMLToken(sLocalName, XML_STRETCHY))
+                    {
+                        bAddStretch = false;
+                        break;
+                    }
+                }
+                if (bAddStretch)
+                {
+                    AddAttribute(XML_NAMESPACE_MATH, XML_STRETCHY, XML_FALSE);
+                }
+                ExportMath(pNode);
+            }
+        }
+        break;
+        case SmNodeType::
+            Special: //SmNodeType::Special requires some sort of Entity preservation in the XML engine.
+        case SmNodeType::MathIdent:
+        case SmNodeType::Place:
+            ExportMath(pNode);
+            break;
+        case SmNodeType::BinHor:
+            ExportBinaryHorizontal(pNode, nLevel);
+            break;
+        case SmNodeType::UnHor:
+            ExportUnaryHorizontal(pNode, nLevel);
+            break;
+        case SmNodeType::Brace:
+            ExportBrace(pNode, nLevel);
+            break;
+        case SmNodeType::BinVer:
+            ExportBinaryVertical(pNode, nLevel);
+            break;
+        case SmNodeType::BinDiagonal:
+            ExportBinaryDiagonal(pNode, nLevel);
+            break;
+        case SmNodeType::SubSup:
+            ExportSubSupScript(pNode, nLevel);
+            break;
+        case SmNodeType::Root:
+            ExportRoot(pNode, nLevel);
+            break;
+        case SmNodeType::Oper:
+            ExportOperator(pNode, nLevel);
+            break;
+        case SmNodeType::Attribute:
+            ExportAttributes(pNode, nLevel);
+            break;
+        case SmNodeType::Font:
+            ExportFont(pNode, nLevel);
+            break;
+        case SmNodeType::VerticalBrace:
+            ExportVerticalBrace(static_cast<const SmVerticalBraceNode*>(pNode), nLevel);
+            break;
+        case SmNodeType::Matrix:
+            ExportMatrix(pNode, nLevel);
+            break;
+        case SmNodeType::Blank:
+            ExportBlank(pNode);
+            break;
+        default:
+            SAL_WARN("starmath", "Warning: failed to export a node?");
+            break;
+    }
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/starmath/source/mathml/mathmlimport.cxx b/starmath/source/mathml/mathmlimport.cxx
new file mode 100644
index 0000000000..7bc3e5b913
--- /dev/null
+++ b/starmath/source/mathml/mathmlimport.cxx
@@ -0,0 +1,2673 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+/*todo: Change characters and tcharacters to accumulate the characters together
+into one string, xml parser hands them to us line by line rather than all in
+one go*/
+
+#include <com/sun/star/xml/sax/InputSource.hpp>
+#include <com/sun/star/xml/sax/FastParser.hpp>
+#include <com/sun/star/xml/sax/Parser.hpp>
+#include <com/sun/star/xml/sax/SAXParseException.hpp>
+#include <com/sun/star/document/XDocumentPropertiesSupplier.hpp>
+#include <com/sun/star/packages/WrongPasswordException.hpp>
+#include <com/sun/star/packages/zip/ZipIOException.hpp>
+#include <com/sun/star/beans/PropertyAttribute.hpp>
+#include <com/sun/star/embed/ElementModes.hpp>
+#include <com/sun/star/uno/Any.h>
+#include <com/sun/star/task/XStatusIndicator.hpp>
+
+#include <comphelper/fileformat.h>
+#include <comphelper/genericpropertyset.hxx>
+#include <comphelper/processfactory.hxx>
+#include <comphelper/servicehelper.hxx>
+#include <comphelper/propertysetinfo.hxx>
+#include <rtl/character.hxx>
+#include <sal/log.hxx>
+#include <sfx2/frame.hxx>
+#include <sfx2/docfile.hxx>
+#include <sfx2/sfxsids.hrc>
+#include <sfx2/sfxmodelfactory.hxx>
+#include <osl/diagnose.h>
+#include <sot/storage.hxx>
+#include <svtools/sfxecode.hxx>
+#include <svl/itemset.hxx>
+#include <svl/stritem.hxx>
+#include <unotools/streamwrap.hxx>
+#include <sax/tools/converter.hxx>
+#include <xmloff/DocumentSettingsContext.hxx>
+#include <xmloff/xmlnamespace.hxx>
+#include <xmloff/xmltoken.hxx>
+#include <xmloff/xmluconv.hxx>
+#include <xmloff/xmlmetai.hxx>
+#include <svx/dialmgr.hxx>
+#include <svx/strings.hrc>
+#include <comphelper/diagnose_ex.hxx>
+#include <o3tl/string_view.hxx>
+
+#include <mathmlattr.hxx>
+#include <xparsmlbase.hxx>
+#include <mathmlimport.hxx>
+#include <document.hxx>
+#include <smdll.hxx>
+#include <unomodel.hxx>
+#include <utility.hxx>
+#include <visitors.hxx>
+#include <starmathdatabase.hxx>
+#include <smmod.hxx>
+#include <cfgitem.hxx>
+
+using namespace ::com::sun::star::beans;
+using namespace ::com::sun::star::container;
+using namespace ::com::sun::star::document;
+using namespace ::com::sun::star::lang;
+using namespace ::com::sun::star::uno;
+using namespace ::com::sun::star;
+using namespace ::xmloff::token;
+
+namespace
+{
+std::unique_ptr<SmNode> popOrZero(SmNodeStack& rStack)
+{
+    if (rStack.empty())
+        return nullptr;
+    auto pTmp = std::move(rStack.front());
+    rStack.pop_front();
+    return pTmp;
+}
+}
+
+ErrCode SmXMLImportWrapper::Import(SfxMedium& rMedium)
+{
+    ErrCode nError = ERRCODE_SFX_DOLOADFAILED;
+
+    uno::Reference<uno::XComponentContext> xContext(comphelper::getProcessComponentContext());
+
+    OSL_ENSURE(m_xModel.is(), "XMLReader::Read: got no model");
+
+    // try to get an XStatusIndicator from the Medium
+    uno::Reference<task::XStatusIndicator> xStatusIndicator;
+
+    bool bEmbedded = false;
+    SmModel* pModel = m_xModel.get();
+
+    SmDocShell* pDocShell = pModel ? static_cast<SmDocShell*>(pModel->GetObjectShell()) : nullptr;
+    if (pDocShell)
+    {
+        OSL_ENSURE(pDocShell->GetMedium() == &rMedium, "different SfxMedium found");
+
+        const SfxUnoAnyItem* pItem = rMedium.GetItemSet().GetItem(SID_PROGRESS_STATUSBAR_CONTROL);
+        if (pItem)
+            pItem->GetValue() >>= xStatusIndicator;
+
+        if (SfxObjectCreateMode::EMBEDDED == pDocShell->GetCreateMode())
+            bEmbedded = true;
+    }
+
+    static const comphelper::PropertyMapEntry aInfoMap[]
+        = { { OUString("PrivateData"), 0, cppu::UnoType<XInterface>::get(),
+              beans::PropertyAttribute::MAYBEVOID, 0 },
+            { OUString("BaseURI"), 0, ::cppu::UnoType<OUString>::get(),
+              beans::PropertyAttribute::MAYBEVOID, 0 },
+            { OUString("StreamRelPath"), 0, ::cppu::UnoType<OUString>::get(),
+              beans::PropertyAttribute::MAYBEVOID, 0 },
+            { OUString("StreamName"), 0, ::cppu::UnoType<OUString>::get(),
+              beans::PropertyAttribute::MAYBEVOID, 0 } };
+    uno::Reference<beans::XPropertySet> xInfoSet(
+        comphelper::GenericPropertySet_CreateInstance(new comphelper::PropertySetInfo(aInfoMap)));
+
+    // Set base URI
+    OUString const baseURI(rMedium.GetBaseURL());
+    // needed for relative URLs; but it's OK to import e.g. MathML from the
+    // clipboard without one
+    SAL_INFO_IF(baseURI.isEmpty(), "starmath", "SmXMLImportWrapper: no base URL");
+    xInfoSet->setPropertyValue("BaseURI", Any(baseURI));
+
+    sal_Int32 nSteps = 3;
+    if (!(rMedium.IsStorage()))
+        nSteps = 1;
+
+    sal_Int32 nProgressRange(nSteps);
+    if (xStatusIndicator.is())
+    {
+        xStatusIndicator->start(SvxResId(RID_SVXSTR_DOC_LOAD), nProgressRange);
+    }
+
+    nSteps = 0;
+    if (xStatusIndicator.is())
+        xStatusIndicator->setValue(nSteps++);
+
+    if (rMedium.IsStorage())
+    {
+        // TODO/LATER: handle the case of embedded links gracefully
+        if (bEmbedded) // && !rMedium.GetStorage()->IsRoot() )
+        {
+            OUString aName("dummyObjName");
+            const SfxStringItem* pDocHierarchItem
+                = rMedium.GetItemSet().GetItem(SID_DOC_HIERARCHICALNAME);
+            if (pDocHierarchItem)
+                aName = pDocHierarchItem->GetValue();
+
+            if (!aName.isEmpty())
+            {
+                xInfoSet->setPropertyValue("StreamRelPath", Any(aName));
+            }
+        }
+
+        bool bOASIS = (SotStorage::GetVersion(rMedium.GetStorage()) > SOFFICE_FILEFORMAT_60);
+        if (xStatusIndicator.is())
+            xStatusIndicator->setValue(nSteps++);
+
+        auto nWarn
+            = ReadThroughComponent(rMedium.GetStorage(), m_xModel, "meta.xml", xContext, xInfoSet,
+                                   (bOASIS ? "com.sun.star.comp.Math.XMLOasisMetaImporter"
+                                           : "com.sun.star.comp.Math.XMLMetaImporter"),
+                                   m_bUseHTMLMLEntities);
+
+        if (nWarn != ERRCODE_IO_BROKENPACKAGE)
+        {
+            if (xStatusIndicator.is())
+                xStatusIndicator->setValue(nSteps++);
+
+            nWarn = ReadThroughComponent(rMedium.GetStorage(), m_xModel, "settings.xml", xContext,
+                                         xInfoSet,
+                                         (bOASIS ? "com.sun.star.comp.Math.XMLOasisSettingsImporter"
+                                                 : "com.sun.star.comp.Math.XMLSettingsImporter"),
+                                         m_bUseHTMLMLEntities);
+
+            if (nWarn != ERRCODE_IO_BROKENPACKAGE)
+            {
+                if (xStatusIndicator.is())
+                    xStatusIndicator->setValue(nSteps++);
+
+                nError = ReadThroughComponent(
+                    rMedium.GetStorage(), m_xModel, "content.xml", xContext, xInfoSet,
+                    "com.sun.star.comp.Math.XMLImporter", m_bUseHTMLMLEntities);
+            }
+            else
+                nError = ERRCODE_IO_BROKENPACKAGE;
+        }
+        else
+            nError = ERRCODE_IO_BROKENPACKAGE;
+    }
+    else
+    {
+        Reference<io::XInputStream> xInputStream
+            = new utl::OInputStreamWrapper(rMedium.GetInStream());
+
+        if (xStatusIndicator.is())
+            xStatusIndicator->setValue(nSteps++);
+
+        nError = ReadThroughComponent(xInputStream, m_xModel, xContext, xInfoSet,
+                                      "com.sun.star.comp.Math.XMLImporter", false,
+                                      m_bUseHTMLMLEntities);
+    }
+
+    if (xStatusIndicator.is())
+        xStatusIndicator->end();
+    return nError;
+}
+
+/// read a component (file + filter version)
+ErrCode SmXMLImportWrapper::ReadThroughComponent(const Reference<io::XInputStream>& xInputStream,
+                                                 const Reference<XComponent>& xModelComponent,
+                                                 Reference<uno::XComponentContext> const& rxContext,
+                                                 Reference<beans::XPropertySet> const& rPropSet,
+                                                 const char* pFilterName, bool bEncrypted,
+                                                 bool bUseHTMLMLEntities)
+{
+    ErrCode nError = ERRCODE_SFX_DOLOADFAILED;
+    OSL_ENSURE(xInputStream.is(), "input stream missing");
+    OSL_ENSURE(xModelComponent.is(), "document missing");
+    OSL_ENSURE(rxContext.is(), "factory missing");
+    OSL_ENSURE(nullptr != pFilterName, "I need a service name for the component!");
+
+    // prepare ParserInputSource
+    xml::sax::InputSource aParserInput;
+    aParserInput.aInputStream = xInputStream;
+
+    Sequence<Any> aArgs{ Any(rPropSet) };
+
+    // get filter
+    Reference<XInterface> xFilter
+        = rxContext->getServiceManager()->createInstanceWithArgumentsAndContext(
+            OUString::createFromAscii(pFilterName), aArgs, rxContext);
+    SAL_WARN_IF(!xFilter, "starmath", "Can't instantiate filter component " << pFilterName);
+    if (!xFilter.is())
+        return nError;
+
+    // connect model and filter
+    Reference<XImporter> xImporter(xFilter, UNO_QUERY);
+    xImporter->setTargetDocument(xModelComponent);
+
+    // finally, parser the stream
+    try
+    {
+        Reference<css::xml::sax::XFastParser> xFastParser(xFilter, UNO_QUERY);
+        Reference<css::xml::sax::XFastDocumentHandler> xFastDocHandler(xFilter, UNO_QUERY);
+        if (xFastParser)
+        {
+            if (bUseHTMLMLEntities)
+                xFastParser->setCustomEntityNames(starmathdatabase::icustomMathmlHtmlEntities);
+            xFastParser->parseStream(aParserInput);
+        }
+        else if (xFastDocHandler)
+        {
+            Reference<css::xml::sax::XFastParser> xParser
+                = css::xml::sax::FastParser::create(rxContext);
+            if (bUseHTMLMLEntities)
+                xParser->setCustomEntityNames(starmathdatabase::icustomMathmlHtmlEntities);
+            xParser->setFastDocumentHandler(xFastDocHandler);
+            xParser->parseStream(aParserInput);
+        }
+        else
+        {
+            Reference<css::xml::sax::XDocumentHandler> xDocHandler(xFilter, UNO_QUERY);
+            assert(xDocHandler);
+            Reference<css::xml::sax::XParser> xParser = css::xml::sax::Parser::create(rxContext);
+            xParser->setDocumentHandler(xDocHandler);
+            xParser->parseStream(aParserInput);
+        }
+
+        auto pFilter = dynamic_cast<SmXMLImport*>(xFilter.get());
+        if (pFilter && pFilter->GetSuccess())
+            nError = ERRCODE_NONE;
+    }
+    catch (const xml::sax::SAXParseException& r)
+    {
+        // sax parser sends wrapped exceptions,
+        // try to find the original one
+        xml::sax::SAXException aSaxEx = *static_cast<const xml::sax::SAXException*>(&r);
+        bool bTryChild = true;
+
+        while (bTryChild)
+        {
+            xml::sax::SAXException aTmp;
+            if (aSaxEx.WrappedException >>= aTmp)
+                aSaxEx = aTmp;
+            else
+                bTryChild = false;
+        }
+
+        packages::zip::ZipIOException aBrokenPackage;
+        if (aSaxEx.WrappedException >>= aBrokenPackage)
+            return ERRCODE_IO_BROKENPACKAGE;
+
+        if (bEncrypted)
+            nError = ERRCODE_SFX_WRONGPASSWORD;
+    }
+    catch (const xml::sax::SAXException& r)
+    {
+        packages::zip::ZipIOException aBrokenPackage;
+        if (r.WrappedException >>= aBrokenPackage)
+            return ERRCODE_IO_BROKENPACKAGE;
+
+        if (bEncrypted)
+            nError = ERRCODE_SFX_WRONGPASSWORD;
+    }
+    catch (const packages::zip::ZipIOException&)
+    {
+        nError = ERRCODE_IO_BROKENPACKAGE;
+    }
+    catch (const io::IOException&)
+    {
+    }
+    catch (const std::range_error&)
+    {
+    }
+
+    return nError;
+}
+
+ErrCode SmXMLImportWrapper::ReadThroughComponent(const uno::Reference<embed::XStorage>& xStorage,
+                                                 const Reference<XComponent>& xModelComponent,
+                                                 const char* pStreamName,
+                                                 Reference<uno::XComponentContext> const& rxContext,
+                                                 Reference<beans::XPropertySet> const& rPropSet,
+                                                 const char* pFilterName, bool bUseHTMLMLEntities)
+{
+    OSL_ENSURE(xStorage.is(), "Need storage!");
+    OSL_ENSURE(nullptr != pStreamName, "Please, please, give me a name!");
+
+    // open stream (and set parser input)
+    OUString sStreamName = OUString::createFromAscii(pStreamName);
+
+    // get input stream
+    try
+    {
+        uno::Reference<io::XStream> xEventsStream
+            = xStorage->openStreamElement(sStreamName, embed::ElementModes::READ);
+
+        // determine if stream is encrypted or not
+        uno::Reference<beans::XPropertySet> xProps(xEventsStream, uno::UNO_QUERY);
+        Any aAny = xProps->getPropertyValue("Encrypted");
+        bool bEncrypted = false;
+        if (aAny.getValueType() == cppu::UnoType<bool>::get())
+            aAny >>= bEncrypted;
+
+        // set Base URL
+        if (rPropSet.is())
+        {
+            rPropSet->setPropertyValue("StreamName", Any(sStreamName));
+        }
+
+        Reference<io::XInputStream> xStream = xEventsStream->getInputStream();
+        return ReadThroughComponent(xStream, xModelComponent, rxContext, rPropSet, pFilterName,
+                                    bEncrypted, bUseHTMLMLEntities);
+    }
+    catch (packages::WrongPasswordException&)
+    {
+        return ERRCODE_SFX_WRONGPASSWORD;
+    }
+    catch (packages::zip::ZipIOException&)
+    {
+        return ERRCODE_IO_BROKENPACKAGE;
+    }
+    catch (uno::Exception&)
+    {
+    }
+
+    return ERRCODE_SFX_DOLOADFAILED;
+}
+
+SmXMLImport::SmXMLImport(const css::uno::Reference<css::uno::XComponentContext>& rContext,
+                         OUString const& implementationName, SvXMLImportFlags nImportFlags)
+    : SvXMLImport(rContext, implementationName, nImportFlags)
+    , bSuccess(false)
+    , nParseDepth(0)
+    , mnSmSyntaxVersion(SM_MOD()->GetConfig()->GetDefaultSmSyntaxVersion())
+{
+}
+
+extern "C" SAL_DLLPUBLIC_EXPORT uno::XInterface*
+Math_XMLImporter_get_implementation(uno::XComponentContext* pCtx,
+                                    uno::Sequence<uno::Any> const& /*rSeq*/)
+{
+    return cppu::acquire(
+        new SmXMLImport(pCtx, "com.sun.star.comp.Math.XMLImporter", SvXMLImportFlags::ALL));
+}
+
+extern "C" SAL_DLLPUBLIC_EXPORT uno::XInterface*
+Math_XMLOasisMetaImporter_get_implementation(uno::XComponentContext* pCtx,
+                                             uno::Sequence<uno::Any> const& /*rSeq*/)
+{
+    return cppu::acquire(new SmXMLImport(pCtx, "com.sun.star.comp.Math.XMLOasisMetaImporter",
+                                         SvXMLImportFlags::META));
+}
+
+extern "C" SAL_DLLPUBLIC_EXPORT uno::XInterface*
+Math_XMLOasisSettingsImporter_get_implementation(uno::XComponentContext* pCtx,
+                                                 uno::Sequence<uno::Any> const& /*rSeq*/)
+{
+    return cppu::acquire(new SmXMLImport(pCtx, "com.sun.star.comp.Math.XMLOasisSettingsImporter",
+                                         SvXMLImportFlags::SETTINGS));
+}
+
+void SmXMLImport::endDocument()
+{
+    //Set the resulted tree into the SmDocShell where it belongs
+    std::unique_ptr<SmNode> pTree = popOrZero(aNodeStack);
+    if (pTree && pTree->GetType() == SmNodeType::Table)
+    {
+        uno::Reference<frame::XModel> xModel = GetModel();
+        SmModel* pModel = dynamic_cast<SmModel*>(xModel.get());
+
+        if (pModel)
+        {
+            SmDocShell* pDocShell = static_cast<SmDocShell*>(pModel->GetObjectShell());
+            auto pTreeTmp = pTree.get();
+            pDocShell->SetFormulaTree(static_cast<SmTableNode*>(pTree.release()));
+            if (aText.isEmpty()) //If we picked up no annotation text
+            {
+                // Get text from imported formula
+                SmNodeToTextVisitor tmpvisitor(pTreeTmp, aText);
+            }
+
+            // Convert symbol names
+            AbstractSmParser* rParser = pDocShell->GetParser();
+            bool bVal = rParser->IsImportSymbolNames();
+            rParser->SetImportSymbolNames(true);
+            auto pTmpTree = rParser->Parse(aText);
+            aText = rParser->GetText();
+            pTmpTree.reset();
+            rParser->SetImportSymbolNames(bVal);
+
+            pDocShell->SetText(aText);
+            pDocShell->SetSmSyntaxVersion(mnSmSyntaxVersion);
+        }
+        OSL_ENSURE(pModel, "So there *was* a UNO problem after all");
+
+        bSuccess = true;
+    }
+
+    SvXMLImport::endDocument();
+}
+
+namespace
+{
+class SmXMLImportContext : public SvXMLImportContext
+{
+public:
+    SmXMLImportContext(SmXMLImport& rImport)
+        : SvXMLImportContext(rImport)
+    {
+        GetSmImport().IncParseDepth();
+    }
+
+    virtual ~SmXMLImportContext() override { GetSmImport().DecParseDepth(); }
+
+    SmXMLImport& GetSmImport() { return static_cast<SmXMLImport&>(GetImport()); }
+
+    virtual void TCharacters(const OUString& /*rChars*/);
+    virtual void SAL_CALL characters(const OUString& rChars) override;
+    virtual void SAL_CALL startFastElement(
+        sal_Int32 /*nElement*/,
+        const css::uno::Reference<css::xml::sax::XFastAttributeList>& /*rAttrList*/) override
+    {
+        if (GetSmImport().TooDeep())
+            throw std::range_error("too deep");
+    }
+};
+}
+
+void SmXMLImportContext::TCharacters(const OUString& /*rChars*/) {}
+
+void SmXMLImportContext::characters(const OUString& rChars)
+{
+    /*
+    Whitespace occurring within the content of token elements is "trimmed"
+    from the ends (i.e. all whitespace at the beginning and end of the
+    content is removed), and "collapsed" internally (i.e. each sequence of
+    1 or more whitespace characters is replaced with one blank character).
+    */
+    //collapsing not done yet!
+    const OUString& rChars2 = rChars.trim();
+    if (!rChars2.isEmpty())
+        TCharacters(rChars2 /*.collapse()*/);
+}
+
+namespace
+{
+struct SmXMLContext_Helper
+{
+    sal_Int8 nIsBold;
+    sal_Int8 nIsItalic;
+    double nFontSize;
+    OUString sFontFamily;
+    OUString sColor;
+
+    SmXMLImportContext& rContext;
+
+    explicit SmXMLContext_Helper(SmXMLImportContext& rImport)
+        : nIsBold(-1)
+        , nIsItalic(-1)
+        , nFontSize(0.0)
+        , rContext(rImport)
+    {
+    }
+
+    bool IsFontNodeNeeded() const;
+    void RetrieveAttrs(const uno::Reference<xml::sax::XFastAttributeList>& xAttrList);
+    void ApplyAttrs();
+};
+}
+
+bool SmXMLContext_Helper::IsFontNodeNeeded() const
+{
+    return nIsBold != -1 || nIsItalic != -1 || nFontSize != 0.0 || !sFontFamily.isEmpty()
+           || !sColor.isEmpty();
+}
+
+void SmXMLContext_Helper::RetrieveAttrs(
+    const uno::Reference<xml::sax::XFastAttributeList>& xAttrList)
+{
+    bool bMvFound = false;
+    for (auto& aIter : sax_fastparser::castToFastAttributeList(xAttrList))
+    {
+        // sometimes they have namespace, sometimes not?
+        switch (aIter.getToken() & TOKEN_MASK)
+        {
+            case XML_FONTWEIGHT:
+                nIsBold = sal_Int8(IsXMLToken(aIter, XML_BOLD));
+                break;
+            case XML_FONTSTYLE:
+                nIsItalic = sal_Int8(IsXMLToken(aIter, XML_ITALIC));
+                break;
+            case XML_FONTSIZE:
+            case XML_MATHSIZE:
+            {
+                OUString sValue = aIter.toString();
+                ::sax::Converter::convertDouble(nFontSize, sValue);
+                rContext.GetSmImport().GetMM100UnitConverter().SetXMLMeasureUnit(
+                    util::MeasureUnit::POINT);
+                if (-1 == sValue.indexOf(GetXMLToken(XML_UNIT_PT)))
+                {
+                    if (-1 == sValue.indexOf('%'))
+                        nFontSize = 0.0;
+                    else
+                    {
+                        rContext.GetSmImport().GetMM100UnitConverter().SetXMLMeasureUnit(
+                            util::MeasureUnit::PERCENT);
+                    }
+                }
+                break;
+            }
+            case XML_FONTFAMILY:
+                sFontFamily = aIter.toString();
+                break;
+            case XML_COLOR:
+                sColor = aIter.toString();
+                break;
+            case XML_MATHCOLOR:
+                sColor = aIter.toString();
+                break;
+            case XML_MATHVARIANT:
+                bMvFound = true;
+                break;
+            default:
+                XMLOFF_WARN_UNKNOWN("starmath", aIter);
+                break;
+        }
+    }
+
+    if (bMvFound)
+    {
+        // Ignore deprecated attributes fontfamily, fontweight, and fontstyle
+        // in favor of mathvariant, as specified in
+        // <https://www.w3.org/TR/MathML3/chapter3.html#presm.deprecatt>.
+        sFontFamily.clear();
+        nIsBold = -1;
+        nIsItalic = -1;
+    }
+}
+
+void SmXMLContext_Helper::ApplyAttrs()
+{
+    SmNodeStack& rNodeStack = rContext.GetSmImport().GetNodeStack();
+
+    if (!IsFontNodeNeeded())
+        return;
+
+    SmToken aToken;
+    aToken.cMathChar = u""_ustr;
+    aToken.nLevel = 5;
+
+    if (nIsBold != -1)
+    {
+        if (nIsBold)
+            aToken.eType = TBOLD;
+        else
+            aToken.eType = TNBOLD;
+        std::unique_ptr<SmFontNode> pFontNode(new SmFontNode(aToken));
+        pFontNode->SetSubNodes(nullptr, popOrZero(rNodeStack));
+        rNodeStack.push_front(std::move(pFontNode));
+    }
+    if (nIsItalic != -1)
+    {
+        if (nIsItalic)
+            aToken.eType = TITALIC;
+        else
+            aToken.eType = TNITALIC;
+        std::unique_ptr<SmFontNode> pFontNode(new SmFontNode(aToken));
+        pFontNode->SetSubNodes(nullptr, popOrZero(rNodeStack));
+        rNodeStack.push_front(std::move(pFontNode));
+    }
+    if (nFontSize != 0.0)
+    {
+        aToken.eType = TSIZE;
+        std::unique_ptr<SmFontNode> pFontNode(new SmFontNode(aToken));
+
+        if (util::MeasureUnit::PERCENT
+            == rContext.GetSmImport().GetMM100UnitConverter().GetXMLMeasureUnit())
+        {
+            if (nFontSize < 100.00)
+                pFontNode->SetSizeParameter(Fraction(100.00 / nFontSize), FontSizeType::DIVIDE);
+            else
+                pFontNode->SetSizeParameter(Fraction(nFontSize / 100.00), FontSizeType::MULTIPLY);
+        }
+        else
+            pFontNode->SetSizeParameter(Fraction(nFontSize), FontSizeType::ABSOLUT);
+
+        pFontNode->SetSubNodes(nullptr, popOrZero(rNodeStack));
+        rNodeStack.push_front(std::move(pFontNode));
+    }
+    if (!sColor.isEmpty())
+    {
+        SmColorTokenTableEntry aSmColorTokenTableEntry;
+        aSmColorTokenTableEntry = starmathdatabase::Identify_ColorName_HTML(sColor);
+        if (aSmColorTokenTableEntry.eType == TRGB)
+            aSmColorTokenTableEntry = starmathdatabase::Identify_Color_Parser(
+                sal_uInt32(aSmColorTokenTableEntry.cColor));
+        if (aSmColorTokenTableEntry.eType != TERROR)
+        {
+            aToken = aSmColorTokenTableEntry;
+            std::unique_ptr<SmFontNode> pFontNode(new SmFontNode(aToken));
+            pFontNode->SetSubNodes(nullptr, popOrZero(rNodeStack));
+            rNodeStack.push_front(std::move(pFontNode));
+        }
+        // If not known, not implemented yet. Giving up.
+    }
+    if (sFontFamily.isEmpty())
+        return;
+
+    if (sFontFamily.equalsIgnoreAsciiCase(GetXMLToken(XML_FIXED)))
+        aToken.eType = TFIXED;
+    else if (sFontFamily.equalsIgnoreAsciiCase("sans"))
+        aToken.eType = TSANS;
+    else if (sFontFamily.equalsIgnoreAsciiCase("serif"))
+        aToken.eType = TSERIF;
+    else //Just give up, we need to extend our font mechanism to be
+        //more general
+        return;
+
+    aToken.aText = sFontFamily;
+    std::unique_ptr<SmFontNode> pFontNode(new SmFontNode(aToken));
+    pFontNode->SetSubNodes(nullptr, popOrZero(rNodeStack));
+    rNodeStack.push_front(std::move(pFontNode));
+}
+
+namespace
+{
+class SmXMLTokenAttrHelper
+{
+    SmXMLImportContext& mrContext;
+    MathMLMathvariantValue meMv;
+    bool mbMvFound;
+
+public:
+    SmXMLTokenAttrHelper(SmXMLImportContext& rContext)
+        : mrContext(rContext)
+        , meMv(MathMLMathvariantValue::Normal)
+        , mbMvFound(false)
+    {
+    }
+
+    void RetrieveAttrs(const uno::Reference<xml::sax::XFastAttributeList>& xAttrList);
+    void ApplyAttrs(MathMLMathvariantValue eDefaultMv);
+};
+}
+
+void SmXMLTokenAttrHelper::RetrieveAttrs(
+    const uno::Reference<xml::sax::XFastAttributeList>& xAttrList)
+{
+    for (auto& aIter : sax_fastparser::castToFastAttributeList(xAttrList))
+    {
+        OUString sValue = aIter.toString();
+        switch (aIter.getToken())
+        {
+            case XML_MATHVARIANT:
+                if (!GetMathMLMathvariantValue(sValue, meMv))
+                    SAL_WARN("starmath", "failed to recognize mathvariant: " << sValue);
+                mbMvFound = true;
+                break;
+            default:
+                XMLOFF_WARN_UNKNOWN("starmath", aIter);
+                break;
+        }
+    }
+}
+
+void SmXMLTokenAttrHelper::ApplyAttrs(MathMLMathvariantValue eDefaultMv)
+{
+    assert(eDefaultMv == MathMLMathvariantValue::Normal
+           || eDefaultMv == MathMLMathvariantValue::Italic);
+
+    std::vector<SmTokenType> vVariant;
+    MathMLMathvariantValue eMv = mbMvFound ? meMv : eDefaultMv;
+    switch (eMv)
+    {
+        case MathMLMathvariantValue::Normal:
+            vVariant.push_back(TNITALIC);
+            break;
+        case MathMLMathvariantValue::Bold:
+            vVariant.push_back(TBOLD);
+            break;
+        case MathMLMathvariantValue::Italic:
+            // nothing to do
+            break;
+        case MathMLMathvariantValue::BoldItalic:
+            vVariant.push_back(TITALIC);
+            vVariant.push_back(TBOLD);
+            break;
+        case MathMLMathvariantValue::DoubleStruck:
+            // TODO
+            break;
+        case MathMLMathvariantValue::BoldFraktur:
+            // TODO: Fraktur
+            vVariant.push_back(TBOLD);
+            break;
+        case MathMLMathvariantValue::Script:
+            // TODO
+            break;
+        case MathMLMathvariantValue::BoldScript:
+            // TODO: Script
+            vVariant.push_back(TBOLD);
+            break;
+        case MathMLMathvariantValue::Fraktur:
+            // TODO
+            break;
+        case MathMLMathvariantValue::SansSerif:
+            vVariant.push_back(TSANS);
+            break;
+        case MathMLMathvariantValue::BoldSansSerif:
+            vVariant.push_back(TSANS);
+            vVariant.push_back(TBOLD);
+            break;
+        case MathMLMathvariantValue::SansSerifItalic:
+            vVariant.push_back(TITALIC);
+            vVariant.push_back(TSANS);
+            break;
+        case MathMLMathvariantValue::SansSerifBoldItalic:
+            vVariant.push_back(TITALIC);
+            vVariant.push_back(TBOLD);
+            vVariant.push_back(TSANS);
+            break;
+        case MathMLMathvariantValue::Monospace:
+            vVariant.push_back(TFIXED);
+            break;
+        case MathMLMathvariantValue::Initial:
+        case MathMLMathvariantValue::Tailed:
+        case MathMLMathvariantValue::Looped:
+        case MathMLMathvariantValue::Stretched:
+            // TODO
+            break;
+    }
+    if (vVariant.empty())
+        return;
+    SmNodeStack& rNodeStack = mrContext.GetSmImport().GetNodeStack();
+    for (auto eType : vVariant)
+    {
+        SmToken aToken;
+        aToken.eType = eType;
+        aToken.cMathChar = u""_ustr;
+        aToken.nLevel = 5;
+        std::unique_ptr<SmFontNode> pFontNode(new SmFontNode(aToken));
+        pFontNode->SetSubNodes(nullptr, popOrZero(rNodeStack));
+        rNodeStack.push_front(std::move(pFontNode));
+    }
+}
+
+namespace
+{
+class SmXMLDocContext_Impl : public SmXMLImportContext
+{
+public:
+    SmXMLDocContext_Impl(SmXMLImport& rImport)
+        : SmXMLImportContext(rImport)
+    {
+    }
+
+    virtual uno::Reference<xml::sax::XFastContextHandler> SAL_CALL createFastChildContext(
+        sal_Int32 nElement, const uno::Reference<xml::sax::XFastAttributeList>& xAttrList) override;
+
+    void SAL_CALL endFastElement(sal_Int32 nElement) override;
+};
+
+/*avert the gaze from the originator*/
+class SmXMLRowContext_Impl : public SmXMLDocContext_Impl
+{
+protected:
+    size_t nElementCount;
+
+public:
+    SmXMLRowContext_Impl(SmXMLImport& rImport)
+        : SmXMLDocContext_Impl(rImport)
+        , nElementCount(GetSmImport().GetNodeStack().size())
+    {
+    }
+
+    virtual uno::Reference<xml::sax::XFastContextHandler> SAL_CALL createFastChildContext(
+        sal_Int32 nElement, const uno::Reference<xml::sax::XFastAttributeList>& xAttrList) override;
+
+    uno::Reference<xml::sax::XFastContextHandler> StrictCreateChildContext(sal_Int32 nElement);
+
+    virtual void SAL_CALL endFastElement(sal_Int32 nElement) override;
+};
+
+class SmXMLEncloseContext_Impl : public SmXMLRowContext_Impl
+{
+public:
+    // TODO/LATER: convert <menclose notation="horizontalstrike"> into
+    // "overstrike{}" and extend the Math syntax to support more notations
+    SmXMLEncloseContext_Impl(SmXMLImport& rImport)
+        : SmXMLRowContext_Impl(rImport)
+    {
+    }
+
+    void SAL_CALL endFastElement(sal_Int32 nElement) override;
+};
+}
+
+void SmXMLEncloseContext_Impl::endFastElement(sal_Int32 nElement)
+{
+    /*
+    <menclose> accepts any number of arguments; if this number is not 1, its
+    contents are treated as a single "inferred <mrow>" containing its
+    arguments
+    */
+    if (GetSmImport().GetNodeStack().size() - nElementCount != 1)
+        SmXMLRowContext_Impl::endFastElement(nElement);
+}
+
+namespace
+{
+class SmXMLFracContext_Impl : public SmXMLRowContext_Impl
+{
+public:
+    // TODO/LATER: convert <mfrac bevelled="true"> into "wideslash{}{}"
+    SmXMLFracContext_Impl(SmXMLImport& rImport)
+        : SmXMLRowContext_Impl(rImport)
+    {
+    }
+
+    void SAL_CALL endFastElement(sal_Int32 nElement) override;
+};
+
+class SmXMLSqrtContext_Impl : public SmXMLRowContext_Impl
+{
+public:
+    SmXMLSqrtContext_Impl(SmXMLImport& rImport)
+        : SmXMLRowContext_Impl(rImport)
+    {
+    }
+
+    void SAL_CALL endFastElement(sal_Int32 nElement) override;
+};
+
+class SmXMLRootContext_Impl : public SmXMLRowContext_Impl
+{
+public:
+    SmXMLRootContext_Impl(SmXMLImport& rImport)
+        : SmXMLRowContext_Impl(rImport)
+    {
+    }
+
+    void SAL_CALL endFastElement(sal_Int32 nElement) override;
+};
+
+class SmXMLStyleContext_Impl : public SmXMLRowContext_Impl
+{
+protected:
+    SmXMLContext_Helper aStyleHelper;
+
+public:
+    /*Right now the style tag is completely ignored*/
+    SmXMLStyleContext_Impl(SmXMLImport& rImport)
+        : SmXMLRowContext_Impl(rImport)
+        , aStyleHelper(*this)
+    {
+    }
+
+    void SAL_CALL endFastElement(sal_Int32 nElement) override;
+    void SAL_CALL startFastElement(
+        sal_Int32 nElement, const uno::Reference<xml::sax::XFastAttributeList>& xAttrList) override;
+};
+}
+
+void SmXMLStyleContext_Impl::startFastElement(
+    sal_Int32 /*nElement*/, const uno::Reference<xml::sax::XFastAttributeList>& xAttrList)
+{
+    aStyleHelper.RetrieveAttrs(xAttrList);
+}
+
+void SmXMLStyleContext_Impl::endFastElement(sal_Int32 nElement)
+{
+    /*
+    <mstyle> accepts any number of arguments; if this number is not 1, its
+    contents are treated as a single "inferred <mrow>" containing its
+    arguments
+    */
+    SmNodeStack& rNodeStack = GetSmImport().GetNodeStack();
+    if (rNodeStack.size() - nElementCount != 1)
+        SmXMLRowContext_Impl::endFastElement(nElement);
+    aStyleHelper.ApplyAttrs();
+}
+
+namespace
+{
+class SmXMLPaddedContext_Impl : public SmXMLRowContext_Impl
+{
+public:
+    /*Right now the style tag is completely ignored*/
+    SmXMLPaddedContext_Impl(SmXMLImport& rImport)
+        : SmXMLRowContext_Impl(rImport)
+    {
+    }
+
+    void SAL_CALL endFastElement(sal_Int32 nElement) override;
+};
+}
+
+void SmXMLPaddedContext_Impl::endFastElement(sal_Int32 nElement)
+{
+    /*
+    <mpadded> accepts any number of arguments; if this number is not 1, its
+    contents are treated as a single "inferred <mrow>" containing its
+    arguments
+    */
+    if (GetSmImport().GetNodeStack().size() - nElementCount != 1)
+        SmXMLRowContext_Impl::endFastElement(nElement);
+}
+
+namespace
+{
+class SmXMLPhantomContext_Impl : public SmXMLRowContext_Impl
+{
+public:
+    /*Right now the style tag is completely ignored*/
+    SmXMLPhantomContext_Impl(SmXMLImport& rImport)
+        : SmXMLRowContext_Impl(rImport)
+    {
+    }
+
+    void SAL_CALL endFastElement(sal_Int32 nElement) override;
+};
+}
+
+void SmXMLPhantomContext_Impl::endFastElement(sal_Int32 nElement)
+{
+    /*
+    <mphantom> accepts any number of arguments; if this number is not 1, its
+    contents are treated as a single "inferred <mrow>" containing its
+    arguments
+    */
+    if (GetSmImport().GetNodeStack().size() - nElementCount != 1)
+        SmXMLRowContext_Impl::endFastElement(nElement);
+
+    SmToken aToken;
+    aToken.cMathChar = u""_ustr;
+    aToken.nLevel = 5;
+    aToken.eType = TPHANTOM;
+
+    std::unique_ptr<SmFontNode> pPhantom(new SmFontNode(aToken));
+    SmNodeStack& rNodeStack = GetSmImport().GetNodeStack();
+    pPhantom->SetSubNodes(nullptr, popOrZero(rNodeStack));
+    rNodeStack.push_front(std::move(pPhantom));
+}
+
+namespace
+{
+class SmXMLFencedContext_Impl : public SmXMLRowContext_Impl
+{
+protected:
+    OUString cBegin;
+    OUString cEnd;
+    bool bIsStretchy;
+
+public:
+    SmXMLFencedContext_Impl(SmXMLImport& rImport)
+        : SmXMLRowContext_Impl(rImport)
+        , cBegin('(')
+        , cEnd(')')
+        , bIsStretchy(false)
+    {
+    }
+
+    void SAL_CALL startFastElement(
+        sal_Int32 nElement, const uno::Reference<xml::sax::XFastAttributeList>& xAttrList) override;
+    void SAL_CALL endFastElement(sal_Int32 nElement) override;
+};
+}
+
+void SmXMLFencedContext_Impl::startFastElement(
+    sal_Int32 /*nElement*/, const uno::Reference<xml::sax::XFastAttributeList>& xAttrList)
+{
+    for (auto& aIter : sax_fastparser::castToFastAttributeList(xAttrList))
+    {
+        switch (aIter.getToken())
+        {
+            //temp, starmath cannot handle multichar brackets (I think)
+            case XML_OPEN:
+                cBegin = aIter.toString();
+                break;
+            case XML_CLOSE:
+                cEnd = aIter.toString();
+                break;
+            case XML_STRETCHY:
+                bIsStretchy = IsXMLToken(aIter, XML_TRUE);
+                break;
+            default:
+                XMLOFF_WARN_UNKNOWN("starmath", aIter);
+                /*Go to superclass*/
+                break;
+        }
+    }
+}
+
+void SmXMLFencedContext_Impl::endFastElement(sal_Int32 /*nElement*/)
+{
+    SmToken aToken;
+    aToken.cMathChar = u""_ustr;
+    aToken.aText = ",";
+    aToken.nLevel = 5;
+
+    std::unique_ptr<SmStructureNode> pSNode(new SmBraceNode(aToken));
+    if (bIsStretchy)
+        aToken = starmathdatabase::Identify_PrefixPostfix_SmXMLOperatorContext_Impl(cBegin);
+    else
+        aToken = starmathdatabase::Identify_Prefix_SmXMLOperatorContext_Impl(cBegin);
+    if (aToken.eType == TERROR)
+        aToken = SmToken(TLPARENT, MS_LPARENT, "(", TG::LBrace, 5);
+    std::unique_ptr<SmNode> pLeft(new SmMathSymbolNode(aToken));
+    if (bIsStretchy)
+        aToken = starmathdatabase::Identify_PrefixPostfix_SmXMLOperatorContext_Impl(cEnd);
+    else
+        aToken = starmathdatabase::Identify_Postfix_SmXMLOperatorContext_Impl(cEnd);
+    if (aToken.eType == TERROR)
+        aToken = SmToken(TRPARENT, MS_RPARENT, ")", TG::LBrace, 5);
+    std::unique_ptr<SmNode> pRight(new SmMathSymbolNode(aToken));
+
+    SmNodeArray aRelationArray;
+    SmNodeStack& rNodeStack = GetSmImport().GetNodeStack();
+    aToken.cMathChar = u""_ustr;
+    aToken.eType = TIDENT;
+
+    auto i = rNodeStack.size() - nElementCount;
+    if (rNodeStack.size() - nElementCount > 1)
+        i += rNodeStack.size() - 1 - nElementCount;
+    aRelationArray.resize(i);
+    while (rNodeStack.size() > nElementCount)
+    {
+        auto pNode = std::move(rNodeStack.front());
+        rNodeStack.pop_front();
+        aRelationArray[--i] = pNode.release();
+        if (i > 1 && rNodeStack.size() > 1)
+            aRelationArray[--i] = new SmGlyphSpecialNode(aToken);
+    }
+
+    SmToken aDummy;
+    std::unique_ptr<SmStructureNode> pBody(new SmExpressionNode(aDummy));
+    pBody->SetSubNodes(std::move(aRelationArray));
+
+    pSNode->SetSubNodes(std::move(pLeft), std::move(pBody), std::move(pRight));
+    // mfenced is always scalable. Stretchy keyword is not official, but in case of been in there
+    // can be used as a hint.
+    pSNode->SetScaleMode(SmScaleMode::Height);
+    GetSmImport().GetNodeStack().push_front(std::move(pSNode));
+}
+
+namespace
+{
+class SmXMLErrorContext_Impl : public SmXMLRowContext_Impl
+{
+public:
+    SmXMLErrorContext_Impl(SmXMLImport& rImport)
+        : SmXMLRowContext_Impl(rImport)
+    {
+    }
+
+    void SAL_CALL endFastElement(sal_Int32 nElement) override;
+};
+}
+
+void SmXMLErrorContext_Impl::endFastElement(sal_Int32 /*nElement*/)
+{
+    /*Right now the error tag is completely ignored, what
+     can I do with it in starmath, ?, maybe we need a
+     report window ourselves, do a test for validity of
+     the xml input, use mirrors, and then generate
+     the markup inside the merror with a big red colour
+     of something. For now just throw them all away.
+     */
+    SmNodeStack& rNodeStack = GetSmImport().GetNodeStack();
+    while (rNodeStack.size() > nElementCount)
+    {
+        rNodeStack.pop_front();
+    }
+}
+
+namespace
+{
+class SmXMLNumberContext_Impl : public SmXMLImportContext
+{
+protected:
+    SmToken aToken;
+
+public:
+    SmXMLNumberContext_Impl(SmXMLImport& rImport)
+        : SmXMLImportContext(rImport)
+    {
+        aToken.cMathChar = u""_ustr;
+        aToken.nLevel = 5;
+        aToken.eType = TNUMBER;
+    }
+
+    virtual void TCharacters(const OUString& rChars) override;
+
+    void SAL_CALL endFastElement(sal_Int32 nElement) override;
+};
+}
+
+void SmXMLNumberContext_Impl::TCharacters(const OUString& rChars) { aToken.aText = rChars; }
+
+void SmXMLNumberContext_Impl::endFastElement(sal_Int32)
+{
+    GetSmImport().GetNodeStack().push_front(std::make_unique<SmTextNode>(aToken, FNT_NUMBER));
+}
+
+namespace
+{
+class SmXMLAnnotationContext_Impl : public SmXMLImportContext
+{
+    sal_uInt8 mnStarMathVersion;
+
+public:
+    SmXMLAnnotationContext_Impl(SmXMLImport& rImport)
+        : SmXMLImportContext(rImport)
+        , mnStarMathVersion(0)
+    {
+    }
+
+    void SAL_CALL characters(const OUString& rChars) override;
+
+    void SAL_CALL startFastElement(
+        sal_Int32 nElement, const uno::Reference<xml::sax::XFastAttributeList>& xAttrList) override;
+};
+}
+
+void SmXMLAnnotationContext_Impl::startFastElement(
+    sal_Int32 /*nElement*/, const uno::Reference<xml::sax::XFastAttributeList>& xAttrList)
+{
+    for (auto& aIter : sax_fastparser::castToFastAttributeList(xAttrList))
+    {
+        // sometimes they have namespace, sometimes not?
+        switch (aIter.getToken() & TOKEN_MASK)
+        {
+            case XML_ENCODING:
+                mnStarMathVersion
+                    = aIter.toView() == "StarMath 5.0" ? 5 : aIter.toView() == "StarMath 6" ? 6 : 0;
+                break;
+            default:
+                XMLOFF_WARN_UNKNOWN("starmath", aIter);
+                break;
+        }
+    }
+}
+
+void SmXMLAnnotationContext_Impl::characters(const OUString& rChars)
+{
+    if (mnStarMathVersion)
+    {
+        GetSmImport().SetText(GetSmImport().GetText() + rChars);
+        GetSmImport().SetSmSyntaxVersion(mnStarMathVersion);
+    }
+}
+
+namespace
+{
+class SmXMLTextContext_Impl : public SmXMLImportContext
+{
+protected:
+    SmToken aToken;
+
+public:
+    SmXMLTextContext_Impl(SmXMLImport& rImport)
+        : SmXMLImportContext(rImport)
+    {
+        aToken.cMathChar = u""_ustr;
+        aToken.nLevel = 5;
+        aToken.eType = TTEXT;
+    }
+
+    virtual void TCharacters(const OUString& rChars) override;
+
+    void SAL_CALL endFastElement(sal_Int32 nElement) override;
+};
+}
+
+void SmXMLTextContext_Impl::TCharacters(const OUString& rChars) { aToken.aText = rChars; }
+
+void SmXMLTextContext_Impl::endFastElement(sal_Int32)
+{
+    GetSmImport().GetNodeStack().push_front(std::make_unique<SmTextNode>(aToken, FNT_TEXT));
+}
+
+namespace
+{
+class SmXMLStringContext_Impl : public SmXMLImportContext
+{
+protected:
+    SmToken aToken;
+
+public:
+    SmXMLStringContext_Impl(SmXMLImport& rImport)
+        : SmXMLImportContext(rImport)
+    {
+        aToken.cMathChar = u""_ustr;
+        aToken.nLevel = 5;
+        aToken.eType = TTEXT;
+    }
+
+    virtual void TCharacters(const OUString& rChars) override;
+
+    void SAL_CALL endFastElement(sal_Int32 nElement) override;
+};
+}
+
+void SmXMLStringContext_Impl::TCharacters(const OUString& rChars)
+{
+    /*
+    The content of <ms> elements should be rendered with visible "escaping" of
+    certain characters in the content, including at least "double quote"
+    itself, and preferably whitespace other than individual blanks. The intent
+    is for the viewer to see that the expression is a string literal, and to
+    see exactly which characters form its content. For example, <ms>double
+    quote is "</ms> might be rendered as "double quote is \"".
+
+    Obviously this isn't fully done here.
+    */
+    aToken.aText = "\"" + rChars + "\"";
+}
+
+void SmXMLStringContext_Impl::endFastElement(sal_Int32)
+{
+    GetSmImport().GetNodeStack().push_front(std::make_unique<SmTextNode>(aToken, FNT_FIXED));
+}
+
+namespace
+{
+class SmXMLIdentifierContext_Impl : public SmXMLImportContext
+{
+    SmXMLTokenAttrHelper maTokenAttrHelper;
+    SmXMLContext_Helper aStyleHelper;
+    SmToken aToken;
+
+public:
+    SmXMLIdentifierContext_Impl(SmXMLImport& rImport)
+        : SmXMLImportContext(rImport)
+        , maTokenAttrHelper(*this)
+        , aStyleHelper(*this)
+    {
+        aToken.cMathChar = u""_ustr;
+        aToken.nLevel = 5;
+        aToken.eType = TIDENT;
+    }
+
+    void TCharacters(const OUString& rChars) override;
+    void SAL_CALL
+    startFastElement(sal_Int32 /*nElement*/,
+                     const uno::Reference<xml::sax::XFastAttributeList>& xAttrList) override
+    {
+        maTokenAttrHelper.RetrieveAttrs(xAttrList);
+        aStyleHelper.RetrieveAttrs(xAttrList);
+    };
+    void SAL_CALL endFastElement(sal_Int32 nElement) override;
+};
+}
+
+void SmXMLIdentifierContext_Impl::endFastElement(sal_Int32)
+{
+    std::unique_ptr<SmTextNode> pNode;
+    //we will handle identifier italic/normal here instead of with a standalone
+    //font node
+    if (((aStyleHelper.nIsItalic == -1) && (aToken.aText.getLength() > 1))
+        || ((aStyleHelper.nIsItalic == 0) && (aToken.aText.getLength() == 1)))
+    {
+        pNode.reset(new SmTextNode(aToken, FNT_FUNCTION));
+        pNode->GetFont().SetItalic(ITALIC_NONE);
+        aStyleHelper.nIsItalic = -1;
+    }
+    else
+        pNode.reset(new SmTextNode(aToken, FNT_VARIABLE));
+    if (aStyleHelper.nIsItalic != -1)
+    {
+        if (aStyleHelper.nIsItalic)
+            pNode->GetFont().SetItalic(ITALIC_NORMAL);
+        else
+            pNode->GetFont().SetItalic(ITALIC_NONE);
+        aStyleHelper.nIsItalic = -1;
+    }
+    GetSmImport().GetNodeStack().push_front(std::move(pNode));
+    aStyleHelper.ApplyAttrs();
+
+    maTokenAttrHelper.ApplyAttrs((aToken.aText.getLength() == 1) ? MathMLMathvariantValue::Italic
+                                                                 : MathMLMathvariantValue::Normal);
+}
+
+void SmXMLIdentifierContext_Impl::TCharacters(const OUString& rChars) { aToken.aText = rChars; }
+
+namespace
+{
+class SmXMLOperatorContext_Impl : public SmXMLImportContext
+{
+    SmXMLTokenAttrHelper maTokenAttrHelper;
+    bool bIsStretchy;
+    bool bIsFenced;
+    bool isPrefix;
+    bool isInfix;
+    bool isPostfix;
+    SmToken aToken;
+
+public:
+    SmXMLOperatorContext_Impl(SmXMLImport& rImport)
+        : SmXMLImportContext(rImport)
+        , maTokenAttrHelper(*this)
+        , bIsStretchy(false)
+        , bIsFenced(false)
+        , isPrefix(false)
+        , isInfix(false)
+        , isPostfix(false)
+    {
+        aToken.eType = TSPECIAL;
+        aToken.nLevel = 5;
+    }
+
+    void TCharacters(const OUString& rChars) override;
+    void SAL_CALL startFastElement(
+        sal_Int32 nElement, const uno::Reference<xml::sax::XFastAttributeList>& xAttrList) override;
+    void SAL_CALL endFastElement(sal_Int32 nElement) override;
+};
+}
+
+void SmXMLOperatorContext_Impl::TCharacters(const OUString& rChars)
+{
+    aToken.setChar(rChars);
+    SmToken bToken;
+    if (bIsFenced)
+    {
+        if (isPrefix)
+            bToken = starmathdatabase::Identify_Prefix_SmXMLOperatorContext_Impl(aToken.cMathChar);
+        else if (isInfix)
+            bToken = SmToken(TMLINE, MS_VERTLINE, "mline", TG::NONE, 0);
+        else if (isPostfix)
+            bToken = starmathdatabase::Identify_Postfix_SmXMLOperatorContext_Impl(aToken.cMathChar);
+        else
+            bToken = starmathdatabase::Identify_PrefixPostfix_SmXMLOperatorContext_Impl(
+                aToken.cMathChar);
+    }
+    else
+        bToken
+            = starmathdatabase::Identify_SmXMLOperatorContext_Impl(aToken.cMathChar, bIsStretchy);
+    if (bToken.eType != TERROR)
+        aToken = bToken;
+}
+
+void SmXMLOperatorContext_Impl::endFastElement(sal_Int32)
+{
+    std::unique_ptr<SmMathSymbolNode> pNode(new SmMathSymbolNode(aToken));
+    //For stretchy scaling the scaling must be retrieved from this node
+    //and applied to the expression itself so as to get the expression
+    //to scale the operator to the height of the expression itself
+    if (bIsStretchy)
+        pNode->SetScaleMode(SmScaleMode::Height);
+    GetSmImport().GetNodeStack().push_front(std::move(pNode));
+
+    // TODO: apply to non-alphabetic characters too
+    if (rtl::isAsciiAlpha(aToken.cMathChar[0]))
+        maTokenAttrHelper.ApplyAttrs(MathMLMathvariantValue::Normal);
+}
+
+void SmXMLOperatorContext_Impl::startFastElement(
+    sal_Int32 /*nElement*/, const uno::Reference<xml::sax::XFastAttributeList>& xAttrList)
+{
+    maTokenAttrHelper.RetrieveAttrs(xAttrList);
+
+    for (auto& aIter : sax_fastparser::castToFastAttributeList(xAttrList))
+    {
+        switch (aIter.getToken())
+        {
+            case XML_STRETCHY:
+                bIsStretchy = IsXMLToken(aIter, XML_TRUE);
+                break;
+            case XML_FENCE:
+                bIsFenced = IsXMLToken(aIter, XML_TRUE);
+                break;
+            case XML_FORM:
+                isPrefix = IsXMLToken(aIter, XML_PREFIX); // <
+                isInfix = IsXMLToken(aIter, XML_INFIX); // |
+                isPostfix = IsXMLToken(aIter, XML_POSTFIX); // >
+                break;
+            default:
+                XMLOFF_WARN_UNKNOWN("starmath", aIter);
+                break;
+        }
+    }
+}
+
+namespace
+{
+class SmXMLSpaceContext_Impl : public SmXMLImportContext
+{
+public:
+    SmXMLSpaceContext_Impl(SmXMLImport& rImport)
+        : SmXMLImportContext(rImport)
+    {
+    }
+
+    void SAL_CALL startFastElement(
+        sal_Int32 nElement, const uno::Reference<xml::sax::XFastAttributeList>& xAttrList) override;
+};
+
+bool lcl_CountBlanks(const MathMLAttributeLengthValue& rLV, sal_Int32* pWide, sal_Int32* pNarrow)
+{
+    assert(pWide);
+    assert(pNarrow);
+    if (rLV.aNumber.GetNumerator() == 0)
+    {
+        *pWide = *pNarrow = 0;
+        return true;
+    }
+    // TODO: honor other units than em
+    if (rLV.eUnit != MathMLLengthUnit::Em)
+        return false;
+    if (rLV.aNumber.GetNumerator() < 0)
+        return false;
+    const Fraction aTwo(2, 1);
+    auto aWide = rLV.aNumber / aTwo;
+    auto nWide = static_cast<sal_Int32>(static_cast<tools::Long>(aWide));
+    if (nWide < 0)
+        return false;
+    const Fraction aPointFive(1, 2);
+    auto aNarrow = (rLV.aNumber - Fraction(nWide, 1) * aTwo) / aPointFive;
+    auto nNarrow = static_cast<sal_Int32>(static_cast<tools::Long>(aNarrow));
+    if (nNarrow < 0)
+        return false;
+    *pWide = nWide;
+    *pNarrow = nNarrow;
+    return true;
+}
+}
+
+void SmXMLSpaceContext_Impl::startFastElement(
+    sal_Int32 /*nElement*/, const uno::Reference<xml::sax::XFastAttributeList>& xAttrList)
+{
+    // There is no syntax in Math to specify blank nodes of arbitrary size yet.
+    MathMLAttributeLengthValue aLV;
+    sal_Int32 nWide = 0, nNarrow = 0;
+
+    for (auto& aIter : sax_fastparser::castToFastAttributeList(xAttrList))
+    {
+        OUString sValue = aIter.toString();
+        switch (aIter.getToken())
+        {
+            case XML_WIDTH:
+                if (!ParseMathMLAttributeLengthValue(o3tl::trim(sValue), aLV)
+                    || !lcl_CountBlanks(aLV, &nWide, &nNarrow))
+                    SAL_WARN("starmath", "ignore mspace's width: " << sValue);
+                break;
+            default:
+                XMLOFF_WARN_UNKNOWN("starmath", aIter);
+                break;
+        }
+    }
+    SmToken aToken;
+    aToken.eType = TBLANK;
+    aToken.cMathChar = u""_ustr;
+    aToken.nGroup = TG::Blank;
+    aToken.nLevel = 5;
+    std::unique_ptr<SmBlankNode> pBlank(new SmBlankNode(aToken));
+    if (nWide > 0)
+        pBlank->IncreaseBy(aToken, nWide);
+    if (nNarrow > 0)
+    {
+        aToken.eType = TSBLANK;
+        pBlank->IncreaseBy(aToken, nNarrow);
+    }
+    GetSmImport().GetNodeStack().push_front(std::move(pBlank));
+}
+
+namespace
+{
+class SmXMLSubContext_Impl : public SmXMLRowContext_Impl
+{
+protected:
+    void GenericEndElement(SmTokenType eType, SmSubSup aSubSup);
+
+public:
+    SmXMLSubContext_Impl(SmXMLImport& rImport)
+        : SmXMLRowContext_Impl(rImport)
+    {
+    }
+
+    void SAL_CALL endFastElement(sal_Int32) override { GenericEndElement(TRSUB, RSUB); }
+};
+}
+
+void SmXMLSubContext_Impl::GenericEndElement(SmTokenType eType, SmSubSup eSubSup)
+{
+    /*The <msub> element requires exactly 2 arguments.*/
+    const bool bNodeCheck = GetSmImport().GetNodeStack().size() - nElementCount == 2;
+    OSL_ENSURE(bNodeCheck, "Sub has not two arguments");
+    if (!bNodeCheck)
+        return;
+
+    SmToken aToken;
+    aToken.cMathChar = u""_ustr;
+    aToken.eType = eType;
+    std::unique_ptr<SmSubSupNode> pNode(new SmSubSupNode(aToken));
+    SmNodeStack& rNodeStack = GetSmImport().GetNodeStack();
+
+    // initialize subnodes array
+    SmNodeArray aSubNodes;
+    aSubNodes.resize(1 + SUBSUP_NUM_ENTRIES);
+    for (size_t i = 1; i < aSubNodes.size(); i++)
+        aSubNodes[i] = nullptr;
+
+    aSubNodes[eSubSup + 1] = popOrZero(rNodeStack).release();
+    aSubNodes[0] = popOrZero(rNodeStack).release();
+    pNode->SetSubNodes(std::move(aSubNodes));
+    rNodeStack.push_front(std::move(pNode));
+}
+
+namespace
+{
+class SmXMLSupContext_Impl : public SmXMLSubContext_Impl
+{
+public:
+    SmXMLSupContext_Impl(SmXMLImport& rImport)
+        : SmXMLSubContext_Impl(rImport)
+    {
+    }
+
+    void SAL_CALL endFastElement(sal_Int32) override { GenericEndElement(TRSUP, RSUP); }
+};
+
+class SmXMLSubSupContext_Impl : public SmXMLRowContext_Impl
+{
+protected:
+    void GenericEndElement(SmTokenType eType, SmSubSup aSub, SmSubSup aSup);
+
+public:
+    SmXMLSubSupContext_Impl(SmXMLImport& rImport)
+        : SmXMLRowContext_Impl(rImport)
+    {
+    }
+
+    void SAL_CALL endFastElement(sal_Int32) override { GenericEndElement(TRSUB, RSUB, RSUP); }
+};
+}
+
+void SmXMLSubSupContext_Impl::GenericEndElement(SmTokenType eType, SmSubSup aSub, SmSubSup aSup)
+{
+    /*The <msub> element requires exactly 3 arguments.*/
+    const bool bNodeCheck = GetSmImport().GetNodeStack().size() - nElementCount == 3;
+    OSL_ENSURE(bNodeCheck, "SubSup has not three arguments");
+    if (!bNodeCheck)
+        return;
+
+    SmToken aToken;
+    aToken.cMathChar = u""_ustr;
+    aToken.eType = eType;
+    std::unique_ptr<SmSubSupNode> pNode(new SmSubSupNode(aToken));
+    SmNodeStack& rNodeStack = GetSmImport().GetNodeStack();
+
+    // initialize subnodes array
+    SmNodeArray aSubNodes;
+    aSubNodes.resize(1 + SUBSUP_NUM_ENTRIES);
+    for (size_t i = 1; i < aSubNodes.size(); i++)
+        aSubNodes[i] = nullptr;
+
+    aSubNodes[aSup + 1] = popOrZero(rNodeStack).release();
+    aSubNodes[aSub + 1] = popOrZero(rNodeStack).release();
+    aSubNodes[0] = popOrZero(rNodeStack).release();
+    pNode->SetSubNodes(std::move(aSubNodes));
+    rNodeStack.push_front(std::move(pNode));
+}
+
+namespace
+{
+class SmXMLUnderContext_Impl : public SmXMLSubContext_Impl
+{
+protected:
+    sal_Int16 nAttrCount;
+
+public:
+    SmXMLUnderContext_Impl(SmXMLImport& rImport)
+        : SmXMLSubContext_Impl(rImport)
+        , nAttrCount(0)
+    {
+    }
+
+    void SAL_CALL startFastElement(
+        sal_Int32 nElement, const uno::Reference<xml::sax::XFastAttributeList>& xAttrList) override;
+    void SAL_CALL endFastElement(sal_Int32 nElement) override;
+    void HandleAccent();
+};
+}
+
+void SmXMLUnderContext_Impl::startFastElement(
+    sal_Int32 /*nElement*/, const uno::Reference<xml::sax::XFastAttributeList>& xAttrList)
+{
+    sax_fastparser::FastAttributeList& rAttribList
+        = sax_fastparser::castToFastAttributeList(xAttrList);
+    nAttrCount = rAttribList.getFastAttributeTokens().size();
+}
+
+void SmXMLUnderContext_Impl::HandleAccent()
+{
+    const bool bNodeCheck = GetSmImport().GetNodeStack().size() - nElementCount == 2;
+    OSL_ENSURE(bNodeCheck, "Sub has not two arguments");
+    if (!bNodeCheck)
+        return;
+
+    /*Just one special case for the underline thing*/
+    SmNodeStack& rNodeStack = GetSmImport().GetNodeStack();
+    std::unique_ptr<SmNode> pTest = popOrZero(rNodeStack);
+    SmToken aToken;
+    aToken.cMathChar = u""_ustr;
+    aToken.eType = TUNDERLINE;
+
+    std::unique_ptr<SmNode> pFirst;
+    std::unique_ptr<SmStructureNode> pNode(new SmAttributeNode(aToken));
+    if ((pTest->GetToken().cMathChar[0] & 0x0FFF) == 0x0332)
+    {
+        pFirst.reset(new SmRectangleNode(aToken));
+    }
+    else
+        pFirst = std::move(pTest);
+
+    std::unique_ptr<SmNode> pSecond = popOrZero(rNodeStack);
+    pNode->SetSubNodes(std::move(pFirst), std::move(pSecond));
+    pNode->SetScaleMode(SmScaleMode::Width);
+    rNodeStack.push_front(std::move(pNode));
+}
+
+void SmXMLUnderContext_Impl::endFastElement(sal_Int32)
+{
+    if (!nAttrCount)
+        GenericEndElement(TCSUB, CSUB);
+    else
+        HandleAccent();
+}
+
+namespace
+{
+class SmXMLOverContext_Impl : public SmXMLSubContext_Impl
+{
+protected:
+    sal_Int16 nAttrCount;
+
+public:
+    SmXMLOverContext_Impl(SmXMLImport& rImport)
+        : SmXMLSubContext_Impl(rImport)
+        , nAttrCount(0)
+    {
+    }
+
+    void SAL_CALL endFastElement(sal_Int32 nElement) override;
+    void SAL_CALL startFastElement(
+        sal_Int32 nElement, const uno::Reference<xml::sax::XFastAttributeList>& xAttrList) override;
+    void HandleAccent();
+};
+}
+
+void SmXMLOverContext_Impl::startFastElement(
+    sal_Int32 /*nElement*/, const uno::Reference<xml::sax::XFastAttributeList>& xAttrList)
+{
+    sax_fastparser::FastAttributeList& rAttribList
+        = sax_fastparser::castToFastAttributeList(xAttrList);
+    nAttrCount = rAttribList.getFastAttributeTokens().size();
+}
+
+void SmXMLOverContext_Impl::endFastElement(sal_Int32)
+{
+    if (!nAttrCount)
+        GenericEndElement(TCSUP, CSUP);
+    else
+        HandleAccent();
+}
+
+void SmXMLOverContext_Impl::HandleAccent()
+{
+    const bool bNodeCheck = GetSmImport().GetNodeStack().size() - nElementCount == 2;
+    OSL_ENSURE(bNodeCheck, "Sub has not two arguments");
+    if (!bNodeCheck)
+        return;
+
+    SmToken aToken;
+    aToken.cMathChar = u""_ustr;
+    aToken.eType = TACUTE;
+
+    std::unique_ptr<SmAttributeNode> pNode(new SmAttributeNode(aToken));
+    SmNodeStack& rNodeStack = GetSmImport().GetNodeStack();
+
+    std::unique_ptr<SmNode> pFirst = popOrZero(rNodeStack);
+    std::unique_ptr<SmNode> pSecond = popOrZero(rNodeStack);
+    pNode->SetSubNodes(std::move(pFirst), std::move(pSecond));
+    pNode->SetScaleMode(SmScaleMode::Width);
+    rNodeStack.push_front(std::move(pNode));
+}
+
+namespace
+{
+class SmXMLUnderOverContext_Impl : public SmXMLSubSupContext_Impl
+{
+public:
+    SmXMLUnderOverContext_Impl(SmXMLImport& rImport)
+        : SmXMLSubSupContext_Impl(rImport)
+    {
+    }
+
+    void SAL_CALL endFastElement(sal_Int32) override { GenericEndElement(TCSUB, CSUB, CSUP); }
+};
+
+class SmXMLMultiScriptsContext_Impl : public SmXMLSubSupContext_Impl
+{
+    bool bHasPrescripts;
+
+    void ProcessSubSupPairs(bool bIsPrescript);
+
+public:
+    SmXMLMultiScriptsContext_Impl(SmXMLImport& rImport)
+        : SmXMLSubSupContext_Impl(rImport)
+        , bHasPrescripts(false)
+    {
+    }
+
+    void SAL_CALL endFastElement(sal_Int32 nElement) override;
+    virtual uno::Reference<xml::sax::XFastContextHandler> SAL_CALL createFastChildContext(
+        sal_Int32 nElement, const uno::Reference<xml::sax::XFastAttributeList>& xAttrList) override;
+};
+
+class SmXMLNoneContext_Impl : public SmXMLImportContext
+{
+public:
+    SmXMLNoneContext_Impl(SmXMLImport& rImport)
+        : SmXMLImportContext(rImport)
+    {
+    }
+
+    void SAL_CALL endFastElement(sal_Int32 nElement) override;
+};
+}
+
+void SmXMLNoneContext_Impl::endFastElement(sal_Int32)
+{
+    SmToken aToken;
+    aToken.cMathChar = u""_ustr;
+    aToken.aText.clear();
+    aToken.nLevel = 5;
+    aToken.eType = TIDENT;
+    GetSmImport().GetNodeStack().push_front(std::make_unique<SmTextNode>(aToken, FNT_VARIABLE));
+}
+
+namespace
+{
+class SmXMLPrescriptsContext_Impl : public SmXMLImportContext
+{
+public:
+    SmXMLPrescriptsContext_Impl(SmXMLImport& rImport)
+        : SmXMLImportContext(rImport)
+    {
+    }
+};
+
+class SmXMLTableRowContext_Impl : public SmXMLRowContext_Impl
+{
+public:
+    SmXMLTableRowContext_Impl(SmXMLImport& rImport)
+        : SmXMLRowContext_Impl(rImport)
+    {
+    }
+
+    virtual uno::Reference<xml::sax::XFastContextHandler> SAL_CALL createFastChildContext(
+        sal_Int32 nElement, const uno::Reference<xml::sax::XFastAttributeList>& xAttrList) override;
+};
+
+class SmXMLTableContext_Impl : public SmXMLTableRowContext_Impl
+{
+public:
+    SmXMLTableContext_Impl(SmXMLImport& rImport)
+        : SmXMLTableRowContext_Impl(rImport)
+    {
+    }
+
+    void SAL_CALL endFastElement(sal_Int32 nElement) override;
+    virtual uno::Reference<xml::sax::XFastContextHandler> SAL_CALL createFastChildContext(
+        sal_Int32 nElement, const uno::Reference<xml::sax::XFastAttributeList>& xAttrList) override;
+};
+
+class SmXMLTableCellContext_Impl : public SmXMLRowContext_Impl
+{
+public:
+    SmXMLTableCellContext_Impl(SmXMLImport& rImport)
+        : SmXMLRowContext_Impl(rImport)
+    {
+    }
+};
+
+class SmXMLAlignGroupContext_Impl : public SmXMLRowContext_Impl
+{
+public:
+    SmXMLAlignGroupContext_Impl(SmXMLImport& rImport)
+        : SmXMLRowContext_Impl(rImport)
+    {
+    }
+
+    /*Don't do anything with alignment for now*/
+};
+
+class SmXMLActionContext_Impl : public SmXMLRowContext_Impl
+{
+    size_t mnSelection; // 1-based
+
+public:
+    SmXMLActionContext_Impl(SmXMLImport& rImport)
+        : SmXMLRowContext_Impl(rImport)
+        , mnSelection(1)
+    {
+    }
+
+    void SAL_CALL startFastElement(
+        sal_Int32 nElement, const uno::Reference<xml::sax::XFastAttributeList>& xAttrList) override;
+    void SAL_CALL endFastElement(sal_Int32 nElement) override;
+};
+
+// NB: virtually inherit so we can multiply inherit properly
+//     in SmXMLFlatDocContext_Impl
+class SmXMLOfficeContext_Impl : public virtual SvXMLImportContext
+{
+public:
+    SmXMLOfficeContext_Impl(SmXMLImport& rImport)
+        : SvXMLImportContext(rImport)
+    {
+    }
+
+    virtual css::uno::Reference<css::xml::sax::XFastContextHandler> SAL_CALL createFastChildContext(
+        sal_Int32 nElement,
+        const css::uno::Reference<css::xml::sax::XFastAttributeList>& xAttrList) override;
+};
+}
+
+uno::Reference<xml::sax::XFastContextHandler> SmXMLOfficeContext_Impl::createFastChildContext(
+    sal_Int32 nElement, const uno::Reference<xml::sax::XFastAttributeList>& /*xAttrList*/)
+{
+    if (nElement == XML_ELEMENT(OFFICE, XML_META))
+    {
+        SAL_WARN("starmath",
+                 "XML_TOK_DOC_META: should not have come here, maybe document is invalid?");
+    }
+    else if (nElement == XML_ELEMENT(OFFICE, XML_SETTINGS))
+    {
+        return new XMLDocumentSettingsContext(GetImport());
+    }
+    return nullptr;
+}
+
+namespace
+{
+// context for flat file xml format
+class SmXMLFlatDocContext_Impl : public SmXMLOfficeContext_Impl, public SvXMLMetaDocumentContext
+{
+public:
+    SmXMLFlatDocContext_Impl(SmXMLImport& i_rImport,
+                             const uno::Reference<document::XDocumentProperties>& i_xDocProps);
+
+    virtual css::uno::Reference<css::xml::sax::XFastContextHandler> SAL_CALL createFastChildContext(
+        sal_Int32 nElement,
+        const css::uno::Reference<css::xml::sax::XFastAttributeList>& xAttrList) override;
+};
+}
+
+SmXMLFlatDocContext_Impl::SmXMLFlatDocContext_Impl(
+    SmXMLImport& i_rImport, const uno::Reference<document::XDocumentProperties>& i_xDocProps)
+    : SvXMLImportContext(i_rImport)
+    , SmXMLOfficeContext_Impl(i_rImport)
+    , SvXMLMetaDocumentContext(i_rImport, i_xDocProps)
+{
+}
+
+uno::Reference<xml::sax::XFastContextHandler>
+    SAL_CALL SmXMLFlatDocContext_Impl::createFastChildContext(
+        sal_Int32 nElement, const uno::Reference<xml::sax::XFastAttributeList>& xAttrList)
+{
+    // behave like meta base class iff we encounter office:meta
+    if (nElement == XML_ELEMENT(OFFICE, XML_META))
+    {
+        return SvXMLMetaDocumentContext::createFastChildContext(nElement, xAttrList);
+    }
+    else
+    {
+        return SmXMLOfficeContext_Impl::createFastChildContext(nElement, xAttrList);
+    }
+}
+
+uno::Reference<xml::sax::XFastContextHandler> SmXMLDocContext_Impl::createFastChildContext(
+    sal_Int32 nElement, const uno::Reference<xml::sax::XFastAttributeList>& /*xAttrList*/)
+{
+    uno::Reference<xml::sax::XFastContextHandler> xContext;
+
+    switch (nElement)
+    {
+        //Consider semantics a dummy except for any starmath annotations
+        case XML_ELEMENT(MATH, XML_SEMANTICS):
+            xContext = new SmXMLRowContext_Impl(GetSmImport());
+            break;
+        /*General Layout Schemata*/
+        case XML_ELEMENT(MATH, XML_MROW):
+            xContext = new SmXMLRowContext_Impl(GetSmImport());
+            break;
+        case XML_ELEMENT(MATH, XML_MENCLOSE):
+            xContext = new SmXMLEncloseContext_Impl(GetSmImport());
+            break;
+        case XML_ELEMENT(MATH, XML_MFRAC):
+            xContext = new SmXMLFracContext_Impl(GetSmImport());
+            break;
+        case XML_ELEMENT(MATH, XML_MSQRT):
+            xContext = new SmXMLSqrtContext_Impl(GetSmImport());
+            break;
+        case XML_ELEMENT(MATH, XML_MROOT):
+            xContext = new SmXMLRootContext_Impl(GetSmImport());
+            break;
+        case XML_ELEMENT(MATH, XML_MSTYLE):
+            xContext = new SmXMLStyleContext_Impl(GetSmImport());
+            break;
+        case XML_ELEMENT(MATH, XML_MERROR):
+            xContext = new SmXMLErrorContext_Impl(GetSmImport());
+            break;
+        case XML_ELEMENT(MATH, XML_MPADDED):
+            xContext = new SmXMLPaddedContext_Impl(GetSmImport());
+            break;
+        case XML_ELEMENT(MATH, XML_MPHANTOM):
+            xContext = new SmXMLPhantomContext_Impl(GetSmImport());
+            break;
+        case XML_ELEMENT(MATH, XML_MFENCED):
+            xContext = new SmXMLFencedContext_Impl(GetSmImport());
+            break;
+        /*Script and Limit Schemata*/
+        case XML_ELEMENT(MATH, XML_MSUB):
+            xContext = new SmXMLSubContext_Impl(GetSmImport());
+            break;
+        case XML_ELEMENT(MATH, XML_MSUP):
+            xContext = new SmXMLSupContext_Impl(GetSmImport());
+            break;
+        case XML_ELEMENT(MATH, XML_MSUBSUP):
+            xContext = new SmXMLSubSupContext_Impl(GetSmImport());
+            break;
+        case XML_ELEMENT(MATH, XML_MUNDER):
+            xContext = new SmXMLUnderContext_Impl(GetSmImport());
+            break;
+        case XML_ELEMENT(MATH, XML_MOVER):
+            xContext = new SmXMLOverContext_Impl(GetSmImport());
+            break;
+        case XML_ELEMENT(MATH, XML_MUNDEROVER):
+            xContext = new SmXMLUnderOverContext_Impl(GetSmImport());
+            break;
+        case XML_ELEMENT(MATH, XML_MMULTISCRIPTS):
+            xContext = new SmXMLMultiScriptsContext_Impl(GetSmImport());
+            break;
+        case XML_ELEMENT(MATH, XML_MTABLE):
+            xContext = new SmXMLTableContext_Impl(GetSmImport());
+            break;
+        case XML_ELEMENT(MATH, XML_MACTION):
+            xContext = new SmXMLActionContext_Impl(GetSmImport());
+            break;
+        default:
+            /*Basically there's an implicit mrow around certain bare
+             *elements, use a RowContext to see if this is one of
+             *those ones*/
+            rtl::Reference<SmXMLRowContext_Impl> aTempContext(
+                new SmXMLRowContext_Impl(GetSmImport()));
+
+            xContext = aTempContext->StrictCreateChildContext(nElement);
+            break;
+    }
+    return xContext;
+}
+
+void SmXMLDocContext_Impl::endFastElement(sal_Int32)
+{
+    SmNodeStack& rNodeStack = GetSmImport().GetNodeStack();
+
+    std::unique_ptr<SmNode> pContextNode = popOrZero(rNodeStack);
+
+    SmToken aDummy;
+    std::unique_ptr<SmStructureNode> pSNode(new SmLineNode(aDummy));
+    pSNode->SetSubNodes(std::move(pContextNode), nullptr);
+    rNodeStack.push_front(std::move(pSNode));
+
+    SmNodeArray LineArray;
+    auto n = rNodeStack.size();
+    LineArray.resize(n);
+    for (size_t j = 0; j < n; j++)
+    {
+        auto pNode = std::move(rNodeStack.front());
+        rNodeStack.pop_front();
+        LineArray[n - (j + 1)] = pNode.release();
+    }
+    std::unique_ptr<SmStructureNode> pSNode2(new SmTableNode(aDummy));
+    pSNode2->SetSubNodes(std::move(LineArray));
+    rNodeStack.push_front(std::move(pSNode2));
+}
+
+void SmXMLFracContext_Impl::endFastElement(sal_Int32)
+{
+    SmNodeStack& rNodeStack = GetSmImport().GetNodeStack();
+    const bool bNodeCheck = rNodeStack.size() - nElementCount == 2;
+    OSL_ENSURE(bNodeCheck, "Fraction (mfrac) tag is missing component");
+    if (!bNodeCheck)
+        return;
+
+    SmToken aToken;
+    aToken.cMathChar = u""_ustr;
+    aToken.eType = TFRAC;
+    std::unique_ptr<SmStructureNode> pSNode(new SmBinVerNode(aToken));
+    std::unique_ptr<SmNode> pOper(new SmRectangleNode(aToken));
+    std::unique_ptr<SmNode> pSecond = popOrZero(rNodeStack);
+    std::unique_ptr<SmNode> pFirst = popOrZero(rNodeStack);
+    pSNode->SetSubNodes(std::move(pFirst), std::move(pOper), std::move(pSecond));
+    rNodeStack.push_front(std::move(pSNode));
+}
+
+void SmXMLRootContext_Impl::endFastElement(sal_Int32)
+{
+    /*The <mroot> element requires exactly 2 arguments.*/
+    const bool bNodeCheck = GetSmImport().GetNodeStack().size() - nElementCount == 2;
+    OSL_ENSURE(bNodeCheck, "Root tag is missing component");
+    if (!bNodeCheck)
+        return;
+
+    SmToken aToken;
+    aToken.setChar(MS_SQRT); //Temporary: alert, based on StarSymbol font
+    aToken.eType = TNROOT;
+    std::unique_ptr<SmStructureNode> pSNode(new SmRootNode(aToken));
+    std::unique_ptr<SmNode> pOper(new SmRootSymbolNode(aToken));
+    SmNodeStack& rNodeStack = GetSmImport().GetNodeStack();
+    std::unique_ptr<SmNode> pIndex = popOrZero(rNodeStack);
+    std::unique_ptr<SmNode> pBase = popOrZero(rNodeStack);
+    pSNode->SetSubNodes(std::move(pIndex), std::move(pOper), std::move(pBase));
+    rNodeStack.push_front(std::move(pSNode));
+}
+
+void SmXMLSqrtContext_Impl::endFastElement(sal_Int32 nElement)
+{
+    /*
+    <msqrt> accepts any number of arguments; if this number is not 1, its
+    contents are treated as a single "inferred <mrow>" containing its
+    arguments
+    */
+    if (GetSmImport().GetNodeStack().size() - nElementCount != 1)
+        SmXMLRowContext_Impl::endFastElement(nElement);
+
+    SmToken aToken;
+    aToken.setChar(MS_SQRT); //Temporary: alert, based on StarSymbol font
+    aToken.eType = TSQRT;
+    std::unique_ptr<SmStructureNode> pSNode(new SmRootNode(aToken));
+    std::unique_ptr<SmNode> pOper(new SmRootSymbolNode(aToken));
+    SmNodeStack& rNodeStack = GetSmImport().GetNodeStack();
+    pSNode->SetSubNodes(nullptr, std::move(pOper), popOrZero(rNodeStack));
+    rNodeStack.push_front(std::move(pSNode));
+}
+
+void SmXMLRowContext_Impl::endFastElement(sal_Int32)
+{
+    SmNodeArray aRelationArray;
+    SmNodeStack& rNodeStack = GetSmImport().GetNodeStack();
+
+    if (rNodeStack.size() > nElementCount)
+    {
+        auto nSize = rNodeStack.size() - nElementCount;
+
+        aRelationArray.resize(nSize);
+        for (auto j = nSize; j > 0; j--)
+        {
+            auto pNode = std::move(rNodeStack.front());
+            rNodeStack.pop_front();
+            aRelationArray[j - 1] = pNode.release();
+        }
+
+        //If the first or last element is an operator with stretchyness
+        //set then we must create a brace node here from those elements,
+        //removing the stretchness from the operators and applying it to
+        //ourselves, and creating the appropriate dummy StarMath none bracket
+        //to balance the arrangement
+        if (((aRelationArray[0]->GetScaleMode() == SmScaleMode::Height)
+             && (aRelationArray[0]->GetType() == SmNodeType::Math))
+            || ((aRelationArray[nSize - 1]->GetScaleMode() == SmScaleMode::Height)
+                && (aRelationArray[nSize - 1]->GetType() == SmNodeType::Math)))
+        {
+            SmToken aToken;
+            aToken.cMathChar = u""_ustr;
+            aToken.nLevel = 5;
+
+            int nLeft = 0, nRight = 0;
+            if ((aRelationArray[0]->GetScaleMode() == SmScaleMode::Height)
+                && (aRelationArray[0]->GetType() == SmNodeType::Math))
+            {
+                aToken = aRelationArray[0]->GetToken();
+                nLeft = 1;
+            }
+            else
+                aToken.cMathChar = u""_ustr;
+
+            aToken.eType = TLPARENT;
+            std::unique_ptr<SmNode> pLeft(new SmMathSymbolNode(aToken));
+
+            if ((aRelationArray[nSize - 1]->GetScaleMode() == SmScaleMode::Height)
+                && (aRelationArray[nSize - 1]->GetType() == SmNodeType::Math))
+            {
+                aToken = aRelationArray[nSize - 1]->GetToken();
+                nRight = 1;
+            }
+            else
+                aToken.cMathChar = u""_ustr;
+
+            aToken.eType = TRPARENT;
+            std::unique_ptr<SmNode> pRight(new SmMathSymbolNode(aToken));
+
+            SmNodeArray aRelationArray2;
+
+            //!! nSize-nLeft-nRight may be < 0 !!
+            int nRelArrSize = nSize - nLeft - nRight;
+            if (nRelArrSize > 0)
+            {
+                aRelationArray2.resize(nRelArrSize);
+                for (int i = 0; i < nRelArrSize; i++)
+                {
+                    aRelationArray2[i] = aRelationArray[i + nLeft];
+                    aRelationArray[i + nLeft] = nullptr;
+                }
+            }
+
+            SmToken aDummy;
+            std::unique_ptr<SmStructureNode> pSNode(new SmBraceNode(aToken));
+            std::unique_ptr<SmStructureNode> pBody(new SmExpressionNode(aDummy));
+            pBody->SetSubNodes(std::move(aRelationArray2));
+
+            pSNode->SetSubNodes(std::move(pLeft), std::move(pBody), std::move(pRight));
+            pSNode->SetScaleMode(SmScaleMode::Height);
+            rNodeStack.push_front(std::move(pSNode));
+
+            for (auto a : aRelationArray)
+                delete a;
+
+            return;
+        }
+    }
+    else
+    {
+        // The elements msqrt, mstyle, merror, menclose, mpadded, mphantom, mtd, and math
+        // treat their content as a single inferred mrow in case their content is empty.
+        // Here an empty group {} is used to catch those cases and transform them without error
+        // to StarMath.
+        aRelationArray.resize(2);
+        SmToken aToken;
+        aToken.setChar(MS_LBRACE);
+        aToken.nLevel = 5;
+        aToken.eType = TLGROUP;
+        aToken.nGroup = TG::NONE;
+        aToken.aText = "{";
+        aRelationArray[0] = new SmLineNode(aToken);
+
+        aToken.setChar(MS_RBRACE);
+        aToken.nLevel = 0;
+        aToken.eType = TRGROUP;
+        aToken.nGroup = TG::NONE;
+        aToken.aText = "}";
+        aRelationArray[1] = new SmLineNode(aToken);
+    }
+
+    SmToken aDummy;
+    std::unique_ptr<SmStructureNode> pSNode(new SmExpressionNode(aDummy));
+    pSNode->SetSubNodes(std::move(aRelationArray));
+    rNodeStack.push_front(std::move(pSNode));
+}
+
+uno::Reference<xml::sax::XFastContextHandler>
+SmXMLRowContext_Impl::StrictCreateChildContext(sal_Int32 nElement)
+{
+    uno::Reference<xml::sax::XFastContextHandler> pContext;
+
+    switch (nElement)
+    {
+        /*Note that these should accept malignmark subelements, but do not*/
+        case XML_ELEMENT(MATH, XML_MN):
+            pContext = new SmXMLNumberContext_Impl(GetSmImport());
+            break;
+        case XML_ELEMENT(MATH, XML_MI):
+            pContext = new SmXMLIdentifierContext_Impl(GetSmImport());
+            break;
+        case XML_ELEMENT(MATH, XML_MO):
+            pContext = new SmXMLOperatorContext_Impl(GetSmImport());
+            break;
+        case XML_ELEMENT(MATH, XML_MTEXT):
+            pContext = new SmXMLTextContext_Impl(GetSmImport());
+            break;
+        case XML_ELEMENT(MATH, XML_MSPACE):
+            pContext = new SmXMLSpaceContext_Impl(GetSmImport());
+            break;
+        case XML_ELEMENT(MATH, XML_MS):
+            pContext = new SmXMLStringContext_Impl(GetSmImport());
+            break;
+
+        /*Note: The maligngroup should only be seen when the row
+         * (or descendants) are in a table*/
+        case XML_ELEMENT(MATH, XML_MALIGNGROUP):
+            pContext = new SmXMLAlignGroupContext_Impl(GetSmImport());
+            break;
+
+        case XML_ELEMENT(MATH, XML_ANNOTATION):
+            pContext = new SmXMLAnnotationContext_Impl(GetSmImport());
+            break;
+
+        default:
+            break;
+    }
+    return pContext;
+}
+
+uno::Reference<xml::sax::XFastContextHandler> SmXMLRowContext_Impl::createFastChildContext(
+    sal_Int32 nElement, const uno::Reference<xml::sax::XFastAttributeList>& xAttrList)
+{
+    uno::Reference<xml::sax::XFastContextHandler> xContext = StrictCreateChildContext(nElement);
+
+    if (!xContext)
+    {
+        //Hmm, unrecognized for this level, check to see if it's
+        //an element that can have an implicit schema around it
+        xContext = SmXMLDocContext_Impl::createFastChildContext(nElement, xAttrList);
+    }
+    return xContext;
+}
+
+uno::Reference<xml::sax::XFastContextHandler> SmXMLMultiScriptsContext_Impl::createFastChildContext(
+    sal_Int32 nElement, const uno::Reference<xml::sax::XFastAttributeList>& xAttrList)
+{
+    uno::Reference<xml::sax::XFastContextHandler> xContext;
+
+    switch (nElement)
+    {
+        case XML_ELEMENT(MATH, XML_MPRESCRIPTS):
+            bHasPrescripts = true;
+            ProcessSubSupPairs(false);
+            xContext = new SmXMLPrescriptsContext_Impl(GetSmImport());
+            break;
+        case XML_ELEMENT(MATH, XML_NONE):
+            xContext = new SmXMLNoneContext_Impl(GetSmImport());
+            break;
+        default:
+            xContext = SmXMLRowContext_Impl::createFastChildContext(nElement, xAttrList);
+            break;
+    }
+    return xContext;
+}
+
+void SmXMLMultiScriptsContext_Impl::ProcessSubSupPairs(bool bIsPrescript)
+{
+    SmNodeStack& rNodeStack = GetSmImport().GetNodeStack();
+
+    if (rNodeStack.size() <= nElementCount)
+        return;
+
+    auto nCount = rNodeStack.size() - nElementCount - 1;
+    if (nCount == 0)
+        return;
+
+    if (nCount % 2 == 0)
+    {
+        SmToken aToken;
+        aToken.cMathChar = u""_ustr;
+        aToken.eType = bIsPrescript ? TLSUB : TRSUB;
+
+        SmNodeStack aReverseStack;
+        for (size_t i = 0; i < nCount + 1; i++)
+        {
+            auto pNode = std::move(rNodeStack.front());
+            rNodeStack.pop_front();
+            aReverseStack.push_front(std::move(pNode));
+        }
+
+        SmSubSup eSub = bIsPrescript ? LSUB : RSUB;
+        SmSubSup eSup = bIsPrescript ? LSUP : RSUP;
+
+        for (size_t i = 0; i < nCount; i += 2)
+        {
+            std::unique_ptr<SmSubSupNode> pNode(new SmSubSupNode(aToken));
+
+            // initialize subnodes array
+            SmNodeArray aSubNodes(1 + SUBSUP_NUM_ENTRIES);
+
+            /*On each loop the base and its sub sup pair becomes the
+             base for the next loop to which the next sub sup pair is
+             attached, i.e. wheels within wheels*/
+            aSubNodes[0] = popOrZero(aReverseStack).release();
+
+            std::unique_ptr<SmNode> pScriptNode = popOrZero(aReverseStack);
+
+            if (pScriptNode
+                && ((pScriptNode->GetToken().eType != TIDENT)
+                    || (!pScriptNode->GetToken().aText.isEmpty())))
+                aSubNodes[eSub + 1] = pScriptNode.release();
+            pScriptNode = popOrZero(aReverseStack);
+            if (pScriptNode
+                && ((pScriptNode->GetToken().eType != TIDENT)
+                    || (!pScriptNode->GetToken().aText.isEmpty())))
+                aSubNodes[eSup + 1] = pScriptNode.release();
+
+            pNode->SetSubNodes(std::move(aSubNodes));
+            aReverseStack.push_front(std::move(pNode));
+        }
+        assert(!aReverseStack.empty());
+        auto pNode = std::move(aReverseStack.front());
+        aReverseStack.pop_front();
+        rNodeStack.push_front(std::move(pNode));
+    }
+    else
+    {
+        // Ignore odd number of elements.
+        for (size_t i = 0; i < nCount; i++)
+        {
+            rNodeStack.pop_front();
+        }
+    }
+}
+
+void SmXMLTableContext_Impl::endFastElement(sal_Int32)
+{
+    SmNodeArray aExpressionArray;
+    SmNodeStack& rNodeStack = GetSmImport().GetNodeStack();
+    SmNodeStack aReverseStack;
+    aExpressionArray.resize(rNodeStack.size() - nElementCount);
+
+    size_t nRows = rNodeStack.size() - nElementCount;
+    size_t nCols = 0;
+
+    for (size_t i = nRows; i > 0; --i)
+    {
+        SmNode* pArray = rNodeStack.front().release();
+        rNodeStack.pop_front();
+        if (pArray->GetNumSubNodes() == 0)
+        {
+            //This is a little tricky, it is possible that there was
+            //be elements that were not inside a <mtd> pair, in which
+            //case they will not be in a row, i.e. they will not have
+            //SubNodes, so we have to wait until here before we can
+            //resolve the situation. Implicit surrounding tags are
+            //surprisingly difficult to get right within this
+            //architecture
+
+            SmNodeArray aRelationArray;
+            aRelationArray.resize(1);
+            aRelationArray[0] = pArray;
+            SmToken aDummy;
+            SmExpressionNode* pExprNode = new SmExpressionNode(aDummy);
+            pExprNode->SetSubNodes(std::move(aRelationArray));
+            pArray = pExprNode;
+        }
+
+        nCols = std::max(nCols, pArray->GetNumSubNodes());
+        aReverseStack.push_front(std::unique_ptr<SmNode>(pArray));
+    }
+    if (nCols > SAL_MAX_UINT16)
+        throw std::range_error("column limit");
+    if (nRows > SAL_MAX_UINT16)
+        throw std::range_error("row limit");
+    aExpressionArray.resize(nCols * nRows);
+    size_t j = 0;
+    for (auto& elem : aReverseStack)
+    {
+        std::unique_ptr<SmStructureNode> xArray(static_cast<SmStructureNode*>(elem.release()));
+        for (size_t i = 0; i < xArray->GetNumSubNodes(); ++i)
+            aExpressionArray[j++] = xArray->GetSubNode(i);
+        xArray->ClearSubNodes();
+    }
+    aReverseStack.clear();
+
+    SmToken aToken;
+    aToken.cMathChar = u""_ustr;
+    aToken.eType = TMATRIX;
+    std::unique_ptr<SmMatrixNode> pSNode(new SmMatrixNode(aToken));
+    pSNode->SetSubNodes(std::move(aExpressionArray));
+    pSNode->SetRowCol(nRows, nCols);
+    rNodeStack.push_front(std::move(pSNode));
+}
+
+uno::Reference<xml::sax::XFastContextHandler> SmXMLTableRowContext_Impl::createFastChildContext(
+    sal_Int32 nElement, const uno::Reference<xml::sax::XFastAttributeList>& xAttrList)
+{
+    uno::Reference<xml::sax::XFastContextHandler> xContext;
+
+    switch (nElement)
+    {
+        case XML_ELEMENT(MATH, XML_MTD):
+            xContext = new SmXMLTableCellContext_Impl(GetSmImport());
+            break;
+        default:
+            xContext = SmXMLRowContext_Impl::createFastChildContext(nElement, xAttrList);
+            break;
+    }
+    return xContext;
+}
+
+uno::Reference<xml::sax::XFastContextHandler> SmXMLTableContext_Impl::createFastChildContext(
+    sal_Int32 nElement, const uno::Reference<xml::sax::XFastAttributeList>& xAttrList)
+{
+    uno::Reference<xml::sax::XFastContextHandler> xContext;
+
+    switch (nElement)
+    {
+        case XML_ELEMENT(MATH, XML_MTR):
+            xContext = new SmXMLTableRowContext_Impl(GetSmImport());
+            break;
+        default:
+            xContext = SmXMLTableRowContext_Impl::createFastChildContext(nElement, xAttrList);
+            break;
+    }
+    return xContext;
+}
+
+void SmXMLMultiScriptsContext_Impl::endFastElement(sal_Int32)
+{
+    ProcessSubSupPairs(bHasPrescripts);
+}
+
+void SmXMLActionContext_Impl::startFastElement(
+    sal_Int32 /*nElement*/, const uno::Reference<xml::sax::XFastAttributeList>& xAttrList)
+{
+    for (auto& aIter : sax_fastparser::castToFastAttributeList(xAttrList))
+    {
+        switch (aIter.getToken())
+        {
+            case XML_SELECTION:
+            {
+                sal_Int32 n = aIter.toInt32();
+                if (n > 0)
+                    mnSelection = static_cast<size_t>(n);
+            }
+            break;
+            default:
+                XMLOFF_WARN_UNKNOWN("starmath", aIter);
+                break;
+        }
+    }
+}
+
+void SmXMLActionContext_Impl::endFastElement(sal_Int32)
+{
+    SmNodeStack& rNodeStack = GetSmImport().GetNodeStack();
+    auto nSize = rNodeStack.size();
+    if (nSize <= nElementCount)
+    {
+        // not compliant to maction's specification, e.g., no subexpressions
+        return;
+    }
+    assert(mnSelection > 0);
+    if (nSize < nElementCount + mnSelection)
+    {
+        // No selected subexpression exists, which is a MathML error;
+        // fallback to selecting the first
+        mnSelection = 1;
+    }
+    assert(nSize >= nElementCount + mnSelection);
+    for (auto i = nSize - (nElementCount + mnSelection); i > 0; i--)
+    {
+        rNodeStack.pop_front();
+    }
+    auto pSelected = std::move(rNodeStack.front());
+    rNodeStack.pop_front();
+    for (auto i = rNodeStack.size() - nElementCount; i > 0; i--)
+    {
+        rNodeStack.pop_front();
+    }
+    rNodeStack.push_front(std::move(pSelected));
+}
+
+SvXMLImportContext*
+SmXMLImport::CreateFastContext(sal_Int32 nElement,
+                               const uno::Reference<xml::sax::XFastAttributeList>& /*xAttrList*/)
+{
+    SvXMLImportContext* pContext = nullptr;
+
+    switch (nElement)
+    {
+        case XML_ELEMENT(OFFICE, XML_DOCUMENT):
+        case XML_ELEMENT(OFFICE, XML_DOCUMENT_META):
+        {
+            uno::Reference<document::XDocumentPropertiesSupplier> xDPS(GetModel(),
+                                                                       uno::UNO_QUERY_THROW);
+            pContext = ((nElement & TOKEN_MASK) == XML_DOCUMENT_META)
+                           ? new SvXMLMetaDocumentContext(*this, xDPS->getDocumentProperties())
+                           // flat OpenDocument file format -- this has not been tested...
+                           : new SmXMLFlatDocContext_Impl(*this, xDPS->getDocumentProperties());
+        }
+        break;
+        default:
+            if (IsTokenInNamespace(nElement, XML_NAMESPACE_OFFICE))
+                pContext = new SmXMLOfficeContext_Impl(*this);
+            else
+                pContext = new SmXMLDocContext_Impl(*this);
+    }
+    return pContext;
+}
+
+SmXMLImport::~SmXMLImport() noexcept { cleanup(); }
+
+void SmXMLImport::SetViewSettings(const Sequence<PropertyValue>& aViewProps)
+{
+    uno::Reference<frame::XModel> xModel = GetModel();
+    if (!xModel.is())
+        return;
+
+    SmModel* pModel = dynamic_cast<SmModel*>(xModel.get());
+
+    if (!pModel)
+        return;
+
+    SmDocShell* pDocShell = static_cast<SmDocShell*>(pModel->GetObjectShell());
+    if (!pDocShell)
+        return;
+
+    tools::Rectangle aRect(pDocShell->GetVisArea());
+
+    tools::Long nTmp = 0;
+
+    for (const PropertyValue& rValue : aViewProps)
+    {
+        if (rValue.Name == "ViewAreaTop")
+        {
+            rValue.Value >>= nTmp;
+            aRect.SaturatingSetPosY(nTmp);
+        }
+        else if (rValue.Name == "ViewAreaLeft")
+        {
+            rValue.Value >>= nTmp;
+            aRect.SaturatingSetPosX(nTmp);
+        }
+        else if (rValue.Name == "ViewAreaWidth")
+        {
+            rValue.Value >>= nTmp;
+            Size aSize(aRect.GetSize());
+            aSize.setWidth(nTmp);
+            aRect.SaturatingSetSize(aSize);
+        }
+        else if (rValue.Name == "ViewAreaHeight")
+        {
+            rValue.Value >>= nTmp;
+            Size aSize(aRect.GetSize());
+            aSize.setHeight(nTmp);
+            aRect.SaturatingSetSize(aSize);
+        }
+    }
+
+    pDocShell->SetVisArea(aRect);
+}
+
+void SmXMLImport::SetConfigurationSettings(const Sequence<PropertyValue>& aConfProps)
+{
+    uno::Reference<XPropertySet> xProps(GetModel(), UNO_QUERY);
+    if (!xProps.is())
+        return;
+
+    Reference<XPropertySetInfo> xInfo(xProps->getPropertySetInfo());
+    if (!xInfo.is())
+        return;
+
+    static constexpr OUStringLiteral sFormula(u"Formula");
+    static constexpr OUStringLiteral sBasicLibraries(u"BasicLibraries");
+    static constexpr OUStringLiteral sDialogLibraries(u"DialogLibraries");
+    for (const PropertyValue& rValue : aConfProps)
+    {
+        if (rValue.Name != sFormula && rValue.Name != sBasicLibraries
+            && rValue.Name != sDialogLibraries)
+        {
+            try
+            {
+                if (xInfo->hasPropertyByName(rValue.Name))
+                    xProps->setPropertyValue(rValue.Name, rValue.Value);
+            }
+            catch (const beans::PropertyVetoException&)
+            {
+                // dealing with read-only properties here. Nothing to do...
+            }
+            catch (const Exception&)
+            {
+                DBG_UNHANDLED_EXCEPTION("starmath");
+            }
+        }
+    }
+}
+
+extern "C" SAL_DLLPUBLIC_EXPORT bool TestImportMML(SvStream& rStream)
+{
+    SmGlobals::ensure();
+
+    SfxObjectShellLock xDocSh(new SmDocShell(SfxModelFlags::EMBEDDED_OBJECT));
+    xDocSh->DoInitNew();
+    uno::Reference<frame::XModel> xModel(xDocSh->GetModel());
+
+    uno::Reference<beans::XPropertySet> xInfoSet;
+    uno::Reference<uno::XComponentContext> xContext(comphelper::getProcessComponentContext());
+    uno::Reference<io::XInputStream> xStream(new utl::OSeekableInputStreamWrapper(rStream));
+
+    //SetLoading hack because the document properties will be re-initted
+    //by the xml filter and during the init, while it's considered uninitialized,
+    //setting a property will inform the document it's modified, which attempts
+    //to update the properties, which throws cause the properties are uninitialized
+    xDocSh->SetLoading(SfxLoadedFlags::NONE);
+
+    ErrCode nRet = ERRCODE_SFX_DOLOADFAILED;
+
+    try
+    {
+        nRet = SmXMLImportWrapper::ReadThroughComponent(xStream, xModel, xContext, xInfoSet,
+                                                        "com.sun.star.comp.Math.XMLImporter", false,
+                                                        false);
+    }
+    catch (...)
+    {
+    }
+
+    xDocSh->SetLoading(SfxLoadedFlags::ALL);
+
+    xDocSh->DoClose();
+
+    return nRet != ERRCODE_NONE;
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/starmath/source/mathml/starmathdatabase.cxx b/starmath/source/mathml/starmathdatabase.cxx
new file mode 100644
index 0000000000..6eb6d209c8
--- /dev/null
+++ b/starmath/source/mathml/starmathdatabase.cxx
@@ -0,0 +1,794 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#include <starmathdatabase.hxx>
+#include <types.hxx>
+
+SmToken starmathdatabase::Identify_SmXMLOperatorContext_Impl(std::u16string_view rText,
+                                                             bool bIsStretchy, sal_Int32 nIndex)
+{
+    auto cChar = o3tl::iterateCodePoints(rText, &nIndex);
+    switch (cChar)
+    {
+        case MS_COPROD:
+            return SmToken(TCOPROD, MS_COPROD, "coprod", TG::Oper, 5);
+        case MS_IIINT:
+            return SmToken(TIIINT, MS_IIINT, "iiint", TG::Oper, 5);
+        case MS_IINT:
+            return SmToken(TIINT, MS_IINT, "iint", TG::Oper, 5);
+        case MS_INT:
+            if (bIsStretchy)
+                return SmToken(TINTD, MS_INT, "intd", TG::Oper, 5);
+            else
+                return SmToken(TINT, MS_INT, "int", TG::Oper, 5);
+        case MS_LINT:
+            return SmToken(TLINT, MS_LINT, "lint", TG::Oper, 5);
+        case MS_LLINT:
+            return SmToken(TLLINT, MS_LLINT, "llint", TG::Oper, 5);
+        case MS_LLLINT:
+            return SmToken(TLLLINT, MS_LLLINT, "lllint", TG::Oper, 5);
+        case MS_PROD:
+            return SmToken(TPROD, MS_PROD, "prod", TG::Oper, 5);
+        case MS_SUM:
+            return SmToken(TSUM, MS_SUM, "sum", TG::Oper, 5);
+        case MS_MAJ:
+            return SmToken(TSUM, MS_MAJ, "maj", TG::Oper, 5);
+        case MS_FACT:
+            return SmToken(TFACT, MS_FACT, "!", TG::UnOper, 5);
+        case MS_NEG:
+            return SmToken(TNEG, MS_NEG, "neg", TG::UnOper, 5);
+        case MS_OMINUS:
+            return SmToken(TOMINUS, MS_OMINUS, "ominus", TG::Sum, 0);
+        case MS_OPLUS:
+            return SmToken(TOPLUS, MS_OPLUS, "oplus", TG::Sum, 0);
+        case MS_UNION:
+            return SmToken(TUNION, MS_UNION, "union", TG::Sum, 0);
+        case MS_OR:
+            return SmToken(TOR, MS_OR, "|", TG::Sum, 5);
+        case MS_PLUSMINUS:
+            return SmToken(TPLUSMINUS, MS_PLUSMINUS, "+-", TG::Sum | TG::UnOper, 5);
+        case MS_MINUSPLUS:
+            return SmToken(TMINUSPLUS, MS_MINUSPLUS, "-+", TG::Sum | TG::UnOper, 5);
+        case 0xe083:
+        case MS_PLUS:
+            return SmToken(TPLUS, MS_PLUS, "+", TG::Sum | TG::UnOper, 5);
+        case MS_MINUS:
+            return SmToken(TMINUS, MS_MINUS, "-", TG::Sum | TG::UnOper, 5);
+        case 0x2022:
+        case MS_CDOT:
+            return SmToken(TCDOT, MS_CDOT, "cdot", TG::Product, 0);
+        case MS_DIV:
+            return SmToken(TDIV, MS_DIV, "div", TG::Product, 0);
+        case MS_TIMES:
+            return SmToken(TTIMES, MS_TIMES, "times", TG::Product, 0);
+        case MS_INTERSECT:
+            return SmToken(TINTERSECT, MS_INTERSECT, "intersection", TG::Product, 0);
+        case MS_ODIVIDE:
+            return SmToken(TODIVIDE, MS_ODIVIDE, "odivide", TG::Product, 0);
+        case MS_ODOT:
+            return SmToken(TODOT, MS_ODOT, "odot", TG::Product, 0);
+        case MS_OTIMES:
+            return SmToken(TOTIMES, MS_OTIMES, "otimes", TG::Product, 0);
+        case MS_AND:
+            return SmToken(TAND, MS_AND, "&", TG::Product, 0);
+        case MS_MULTIPLY:
+            return SmToken(TMULTIPLY, MS_MULTIPLY, "*", TG::Product, 0);
+        case MS_SLASH:
+            if (bIsStretchy)
+                return SmToken(TWIDESLASH, MS_SLASH, "wideslash", TG::Product, 0);
+            else
+                return SmToken(TSLASH, MS_SLASH, "slash", TG::Product, 0);
+        case MS_BACKSLASH:
+            if (bIsStretchy)
+                return SmToken(TWIDEBACKSLASH, MS_BACKSLASH, "widebslash", TG::Product, 0);
+            else
+                return SmToken(TBACKSLASH, MS_BACKSLASH, "bslash", TG::Product, 0);
+        case MS_DEF:
+            return SmToken(TDEF, MS_DEF, "def", TG::Relation, 0);
+        case MS_LINE:
+            return SmToken(TDIVIDES, MS_LINE, "divides", TG::Relation, 0);
+        case MS_EQUIV:
+            return SmToken(TEQUIV, MS_EQUIV, "equiv", TG::Relation, 0);
+        case MS_GE:
+            return SmToken(TGE, MS_GE, ">=", TG::Relation, 0);
+        case MS_GESLANT:
+            return SmToken(TGESLANT, MS_GESLANT, "geslant", TG::Relation, 0);
+        case MS_GG:
+            return SmToken(TGG, MS_GG, ">>", TG::Relation, 0);
+        case MS_GT:
+            return SmToken(TGT, MS_GT, ">", TG::Relation, 0);
+        case MS_IN:
+            return SmToken(TIN, MS_IN, "in", TG::Relation, 0);
+        case MS_LE:
+            return SmToken(TLE, MS_LE, "<=", TG::Relation, 0);
+        case MS_LESLANT:
+            return SmToken(TLESLANT, MS_LESLANT, "leslant", TG::Relation, 0);
+        case MS_LL:
+            return SmToken(TLL, MS_LL, "<<", TG::Relation, 0);
+        case MS_LT:
+            return SmToken(TLT, MS_LT, "<", TG::Relation, 0);
+        case MS_NDIVIDES:
+            return SmToken(TNDIVIDES, MS_NDIVIDES, "ndivides", TG::Relation, 0);
+        case MS_NEQ:
+            return SmToken(TNEQ, MS_NEQ, "<>", TG::Relation, 0);
+        case MS_NOTIN:
+            return SmToken(TNOTIN, MS_NOTIN, "notin", TG::Relation, 0);
+        case MS_NOTPRECEDES:
+            return SmToken(TNOTPRECEDES, MS_NOTPRECEDES, "nprec", TG::Relation, 0);
+        case MS_NSUBSET:
+            return SmToken(TNSUBSET, MS_NSUBSET, "nsubset", TG::Relation, 0);
+        case MS_NSUBSETEQ:
+            return SmToken(TNSUBSETEQ, MS_NSUBSETEQ, "nsubseteq", TG::Relation, 0);
+        case MS_NOTSUCCEEDS:
+            return SmToken(TNOTSUCCEEDS, MS_NOTSUCCEEDS, "nsucc", TG::Relation, 0);
+        case MS_NSUPSET:
+            return SmToken(TNSUPSET, MS_NSUPSET, "nsupset", TG::Relation, 0);
+        case MS_NSUPSETEQ:
+            return SmToken(TNSUPSETEQ, MS_NSUPSETEQ, "nsupseteq", TG::Relation, 0);
+        case MS_ORTHO:
+            return SmToken(TORTHO, MS_ORTHO, "ortho", TG::Relation, 0);
+        case MS_NI:
+            return SmToken(TNI, MS_NI, "owns", TG::Relation, 0);
+        case MS_DLINE:
+            return SmToken(TPARALLEL, MS_DLINE, "parallel", TG::Relation, 0);
+        case MS_PRECEDES:
+            return SmToken(TPRECEDES, MS_PRECEDES, "prec", TG::Relation, 0);
+        case MS_PRECEDESEQUAL:
+            return SmToken(TPRECEDESEQUAL, MS_PRECEDESEQUAL, "preccurlyeq", TG::Relation, 0);
+        case MS_PRECEDESEQUIV:
+            return SmToken(TPRECEDESEQUIV, MS_PRECEDESEQUIV, "precsim", TG::Relation, 0);
+        case MS_PROP:
+            return SmToken(TPROP, MS_PROP, "prop", TG::Relation, 0);
+        case MS_SIM:
+            return SmToken(TSIM, MS_SIM, "sim", TG::Relation, 0);
+        case 0x2245:
+        case MS_SIMEQ:
+            return SmToken(TSIMEQ, MS_SIMEQ, "simeq", TG::Relation, 0);
+        case MS_SUBSET:
+            return SmToken(TSUBSET, MS_SUBSET, "subset", TG::Relation, 0);
+        case MS_SUBSETEQ:
+            return SmToken(TSUBSETEQ, MS_SUBSETEQ, "subseteq", TG::Relation, 0);
+        case MS_SUCCEEDS:
+            return SmToken(TSUCCEEDS, MS_SUCCEEDS, "succ", TG::Relation, 0);
+        case MS_SUCCEEDSEQUAL:
+            return SmToken(TSUCCEEDSEQUAL, MS_SUCCEEDSEQUAL, "succcurlyeq", TG::Relation, 0);
+        case MS_SUCCEEDSEQUIV:
+            return SmToken(TSUCCEEDSEQUIV, MS_SUCCEEDSEQUIV, "succsim", TG::Relation, 0);
+        case MS_SUPSET:
+            return SmToken(TSUPSET, MS_SUPSET, "supset", TG::Relation, 0);
+        case MS_SUPSETEQ:
+            return SmToken(TSUPSETEQ, MS_SUPSETEQ, "supseteq", TG::Relation, 0);
+        case MS_RIGHTARROW:
+            return SmToken(TTOWARD, MS_RIGHTARROW, "toward", TG::Relation, 0);
+        case MS_TRANSL:
+            return SmToken(TTRANSL, MS_TRANSL, "transl", TG::Relation, 0);
+        case MS_TRANSR:
+            return SmToken(TTRANSR, MS_TRANSR, "transr", TG::Relation, 0);
+        case MS_ASSIGN:
+            return SmToken(TASSIGN, MS_ASSIGN, "=", TG::Relation, 0);
+        case MS_LANGLE:
+            return SmToken(TLANGLE, MS_LMATHANGLE, "langle", TG::LBrace, 5);
+        case MS_LMATHANGLE:
+            return SmToken(TLANGLE, MS_LMATHANGLE, "langle", TG::LBrace, 5);
+        case MS_LBRACE:
+            return SmToken(TLBRACE, MS_LBRACE, "lbrace", TG::LBrace, 5);
+        case MS_LCEIL:
+            return SmToken(TLCEIL, MS_LCEIL, "lceil", TG::LBrace, 5);
+        case MS_LFLOOR:
+            return SmToken(TLFLOOR, MS_LFLOOR, "lfloor", TG::LBrace, 5);
+        case MS_LDBRACKET:
+            return SmToken(TLDBRACKET, MS_LDBRACKET, "ldbracket", TG::LBrace, 5);
+        case MS_LBRACKET:
+            return SmToken(TLBRACKET, MS_LBRACKET, "[", TG::LBrace, 5);
+        case MS_LPARENT:
+            return SmToken(TLPARENT, MS_LPARENT, "(", TG::LBrace, 5);
+        case MS_RANGLE:
+            return SmToken(TRANGLE, MS_RMATHANGLE, "rangle", TG::RBrace, 5);
+        case MS_RMATHANGLE:
+            return SmToken(TRANGLE, MS_RMATHANGLE, "rangle", TG::RBrace, 5);
+        case MS_RBRACE:
+            return SmToken(TRBRACE, MS_RBRACE, "rbrace", TG::RBrace, 5);
+        case MS_RCEIL:
+            return SmToken(TRCEIL, MS_RCEIL, "rceil", TG::RBrace, 5);
+        case MS_RFLOOR:
+            return SmToken(TRFLOOR, MS_RFLOOR, "rfloor", TG::RBrace, 5);
+        case MS_RDBRACKET:
+            return SmToken(TRDBRACKET, MS_RDBRACKET, "rdbracket", TG::RBrace, 5);
+        case MS_RBRACKET:
+            return SmToken(TRBRACKET, MS_RBRACKET, "]", TG::RBrace, 5);
+        case MS_RPARENT:
+            return SmToken(TRPARENT, MS_RPARENT, ")", TG::RBrace, 5);
+        case MS_NONE:
+            return SmToken(TNONE, MS_NONE, "none", TG::RBrace | TG::LBrace, 5);
+        default:
+            return SmToken(TERROR, MS_NONE, "", TG::NONE, SAL_MAX_UINT16);
+    }
+}
+
+SmToken starmathdatabase::Identify_Prefix_SmXMLOperatorContext_Impl(std::u16string_view rText,
+                                                                    sal_Int32 nIndex)
+{
+    auto cChar = o3tl::iterateCodePoints(rText, &nIndex);
+    switch (cChar)
+    {
+        case MS_VERTLINE:
+            return SmToken(TLLINE, MS_VERTLINE, "lline", TG::LBrace, 5);
+        case MS_DVERTLINE:
+            return SmToken(TLDLINE, MS_DVERTLINE, "ldline", TG::LBrace, 5);
+        case MS_LANGLE:
+            return SmToken(TLANGLE, MS_LMATHANGLE, "langle", TG::LBrace, 5);
+        case MS_LMATHANGLE:
+            return SmToken(TLANGLE, MS_LMATHANGLE, "langle", TG::LBrace, 5);
+        case MS_LBRACE:
+            return SmToken(TLBRACE, MS_LBRACE, "lbrace", TG::LBrace, 5);
+        case MS_LCEIL:
+            return SmToken(TLCEIL, MS_LCEIL, "lceil", TG::LBrace, 5);
+        case MS_LFLOOR:
+            return SmToken(TLFLOOR, MS_LFLOOR, "lfloor", TG::LBrace, 5);
+        case MS_LDBRACKET:
+            return SmToken(TLDBRACKET, MS_LDBRACKET, "ldbracket", TG::LBrace, 5);
+        case MS_LBRACKET:
+            return SmToken(TLBRACKET, MS_LBRACKET, "[", TG::LBrace, 5);
+        case MS_LPARENT:
+            return SmToken(TLPARENT, MS_LPARENT, "(", TG::LBrace, 5);
+        case MS_RANGLE:
+            return SmToken(TRANGLE, MS_RMATHANGLE, "rangle", TG::RBrace, 5);
+        case MS_RMATHANGLE:
+            return SmToken(TRANGLE, MS_RMATHANGLE, "rangle", TG::RBrace, 5);
+        case MS_RBRACE:
+            return SmToken(TRBRACE, MS_RBRACE, "rbrace", TG::RBrace, 5);
+        case MS_RCEIL:
+            return SmToken(TRCEIL, MS_RCEIL, "rceil", TG::RBrace, 5);
+        case MS_RFLOOR:
+            return SmToken(TRFLOOR, MS_RFLOOR, "rfloor", TG::RBrace, 5);
+        case MS_RDBRACKET:
+            return SmToken(TRDBRACKET, MS_RDBRACKET, "rdbracket", TG::RBrace, 5);
+        case MS_RBRACKET:
+            return SmToken(TRBRACKET, MS_RBRACKET, "]", TG::RBrace, 5);
+        case MS_RPARENT:
+            return SmToken(TRPARENT, MS_RPARENT, ")", TG::RBrace, 5);
+        case MS_NONE:
+            return SmToken(TNONE, MS_NONE, "none", TG::LBrace | TG::RBrace, 5);
+        default:
+            return SmToken(TERROR, MS_NONE, "", TG::NONE, SAL_MAX_UINT16);
+    }
+}
+
+SmToken starmathdatabase::Identify_Postfix_SmXMLOperatorContext_Impl(std::u16string_view rText,
+                                                                     sal_Int32 nIndex)
+{
+    auto cChar = o3tl::iterateCodePoints(rText, &nIndex);
+    switch (cChar)
+    {
+        case MS_VERTLINE:
+            return SmToken(TRLINE, MS_VERTLINE, "rline", TG::RBrace, 5);
+        case MS_DVERTLINE:
+            return SmToken(TRDLINE, MS_DVERTLINE, "rdline", TG::RBrace, 5);
+        case MS_LANGLE:
+            return SmToken(TLANGLE, MS_LMATHANGLE, "langle", TG::LBrace, 5);
+        case MS_LMATHANGLE:
+            return SmToken(TLANGLE, MS_LMATHANGLE, "langle", TG::LBrace, 5);
+        case MS_LBRACE:
+            return SmToken(TLBRACE, MS_LBRACE, "lbrace", TG::LBrace, 5);
+        case MS_LCEIL:
+            return SmToken(TLCEIL, MS_LCEIL, "lceil", TG::LBrace, 5);
+        case MS_LFLOOR:
+            return SmToken(TLFLOOR, MS_LFLOOR, "lfloor", TG::LBrace, 5);
+        case MS_LDBRACKET:
+            return SmToken(TLDBRACKET, MS_LDBRACKET, "ldbracket", TG::LBrace, 5);
+        case MS_LBRACKET:
+            return SmToken(TLBRACKET, MS_LBRACKET, "[", TG::LBrace, 5);
+        case MS_LPARENT:
+            return SmToken(TLPARENT, MS_LPARENT, "(", TG::LBrace, 5);
+        case MS_RANGLE:
+            return SmToken(TRANGLE, MS_RMATHANGLE, "rangle", TG::RBrace, 5);
+        case MS_RMATHANGLE:
+            return SmToken(TRANGLE, MS_RMATHANGLE, "rangle", TG::RBrace, 5);
+        case MS_RBRACE:
+            return SmToken(TRBRACE, MS_RBRACE, "rbrace", TG::RBrace, 5);
+        case MS_RCEIL:
+            return SmToken(TRCEIL, MS_RCEIL, "rceil", TG::RBrace, 5);
+        case MS_RFLOOR:
+            return SmToken(TRFLOOR, MS_RFLOOR, "rfloor", TG::RBrace, 5);
+        case MS_RDBRACKET:
+            return SmToken(TRDBRACKET, MS_RDBRACKET, "rdbracket", TG::RBrace, 5);
+        case MS_RBRACKET:
+            return SmToken(TRBRACKET, MS_RBRACKET, "]", TG::RBrace, 5);
+        case MS_RPARENT:
+            return SmToken(TRPARENT, MS_RPARENT, ")", TG::RBrace, 5);
+        case MS_NONE:
+            return SmToken(TNONE, MS_NONE, "none", TG::LBrace | TG::RBrace, 5);
+        default:
+            return SmToken(TERROR, MS_NONE, "", TG::NONE, SAL_MAX_UINT16);
+    }
+}
+
+SmToken
+starmathdatabase::Identify_PrefixPostfix_SmXMLOperatorContext_Impl(std::u16string_view rText,
+                                                                   sal_Int32 nIndex)
+{
+    auto cChar = o3tl::iterateCodePoints(rText, &nIndex);
+    switch (cChar)
+    {
+        case MS_VERTLINE:
+            return SmToken(TLRLINE, MS_VERTLINE, "lrline", TG::LBrace | TG::RBrace, 5);
+        case MS_DVERTLINE:
+            return SmToken(TLRDLINE, MS_DVERTLINE, "lrdline", TG::LBrace | TG::RBrace, 5);
+        case MS_LANGLE:
+            return SmToken(TLANGLE, MS_LMATHANGLE, "langle", TG::LBrace, 5);
+        case MS_LMATHANGLE:
+            return SmToken(TLANGLE, MS_LMATHANGLE, "langle", TG::LBrace, 5);
+        case MS_LBRACE:
+            return SmToken(TLBRACE, MS_LBRACE, "lbrace", TG::LBrace, 5);
+        case MS_LCEIL:
+            return SmToken(TLCEIL, MS_LCEIL, "lceil", TG::LBrace, 5);
+        case MS_LFLOOR:
+            return SmToken(TLFLOOR, MS_LFLOOR, "lfloor", TG::LBrace, 5);
+        case MS_LDBRACKET:
+            return SmToken(TLDBRACKET, MS_LDBRACKET, "ldbracket", TG::LBrace, 5);
+        case MS_LBRACKET:
+            return SmToken(TLBRACKET, MS_LBRACKET, "[", TG::LBrace, 5);
+        case MS_LPARENT:
+            return SmToken(TLPARENT, MS_LPARENT, "(", TG::LBrace, 5);
+        case MS_RANGLE:
+            return SmToken(TRANGLE, MS_RMATHANGLE, "rangle", TG::RBrace, 5);
+        case MS_RMATHANGLE:
+            return SmToken(TRANGLE, MS_RMATHANGLE, "rangle", TG::RBrace, 5);
+        case MS_RBRACE:
+            return SmToken(TRBRACE, MS_RBRACE, "rbrace", TG::RBrace, 5);
+        case MS_RCEIL:
+            return SmToken(TRCEIL, MS_RCEIL, "rceil", TG::RBrace, 5);
+        case MS_RFLOOR:
+            return SmToken(TRFLOOR, MS_RFLOOR, "rfloor", TG::RBrace, 5);
+        case MS_RDBRACKET:
+            return SmToken(TRDBRACKET, MS_RDBRACKET, "rdbracket", TG::RBrace, 5);
+        case MS_RBRACKET:
+            return SmToken(TRBRACKET, MS_RBRACKET, "]", TG::RBrace, 5);
+        case MS_RPARENT:
+            return SmToken(TRPARENT, MS_RPARENT, ")", TG::RBrace, 5);
+        case MS_NONE:
+            return SmToken(TNONE, MS_NONE, "none", TG::LBrace | TG::RBrace, 5);
+        default:
+            return SmToken(TERROR, MS_NONE, "", TG::NONE, SAL_MAX_UINT16);
+    }
+}
+
+const SmColorTokenTableEntry starmathdatabase::aColorTokenTableParse[]
+    = { { "aliceblue", THTMLCOL, COL_SM_ALICEBLUE },
+        { "antiquewhite", THTMLCOL, COL_SM_ANTIQUEWHITE },
+        { "aqua", TMATHMLCOL, COL_SM_AQUA },
+        { "aquamarine", THTMLCOL, COL_SM_AQUAMARINE },
+        { "azure", THTMLCOL, COL_SM_AZURE },
+        { "beige", THTMLCOL, COL_SM_BEIGE },
+        { "bisque", THTMLCOL, COL_SM_BISQUE },
+        { "black", TMATHMLCOL, COL_SM_BLACK },
+        { "blanchedalmond", THTMLCOL, COL_SM_BLANCHEDALMOND },
+        { "blue", TMATHMLCOL, COL_SM_BLUE },
+        { "blueviolet", THTMLCOL, COL_SM_BLUEVIOLET },
+        { "brown", THTMLCOL, COL_SM_BROWN },
+        { "burlywood", THTMLCOL, COL_SM_BURLYWOOD },
+        { "cadetblue", THTMLCOL, COL_SM_CADETBLUE },
+        { "chartreuse", THTMLCOL, COL_SM_CHARTREUSE },
+        { "chocolate", THTMLCOL, COL_SM_CHOCOLATE },
+        { "coral", THTMLCOL, COL_SM_CORAL },
+        { "cornflowerblue", THTMLCOL, COL_SM_CORNFLOWERBLUE },
+        { "cornsilk", THTMLCOL, COL_SM_CORNSILK },
+        { "crimson", THTMLCOL, COL_SM_CRIMSON },
+        { "cyan", TMATHMLCOL, COL_SM_CYAN },
+        { "darkblue", THTMLCOL, COL_SM_DARKBLUE },
+        { "darkcyan", THTMLCOL, COL_SM_DARKCYAN },
+        { "darkgoldenrod", THTMLCOL, COL_SM_DARKGOLDENROD },
+        { "darkgray", THTMLCOL, COL_SM_DARKGRAY },
+        { "darkgreen", THTMLCOL, COL_SM_DARKGREEN },
+        { "darkgrey", THTMLCOL, COL_SM_DARKGREY },
+        { "darkkhaki", THTMLCOL, COL_SM_DARKKHAKI },
+        { "darkmagenta", THTMLCOL, COL_SM_DARKMAGENTA },
+        { "darkolivegreen", THTMLCOL, COL_SM_DARKOLIVEGREEN },
+        { "darkorange", THTMLCOL, COL_SM_DARKORANGE },
+        { "darkorchid", THTMLCOL, COL_SM_DARKORCHID },
+        { "darkred", THTMLCOL, COL_SM_DARKRED },
+        { "darksalmon", THTMLCOL, COL_SM_DARKSALMON },
+        { "darkseagreen", THTMLCOL, COL_SM_DARKSEAGREEN },
+        { "darkslateblue", THTMLCOL, COL_SM_DARKSLATEBLUE },
+        { "darkslategray", THTMLCOL, COL_SM_DARKSLATEGRAY },
+        { "darkslategrey", THTMLCOL, COL_SM_DARKSLATEGREY },
+        { "darkturquoise", THTMLCOL, COL_SM_DARKTURQUOISE },
+        { "darkviolet", THTMLCOL, COL_SM_DARKVIOLET },
+        { "debian", TICONICCOL, COL_SM_DEBIAN_MAGENTA },
+        { "deeppink", THTMLCOL, COL_SM_DEEPPINK },
+        { "deepskyblue", THTMLCOL, COL_SM_DEEPSKYBLUE },
+        { "dimgray", THTMLCOL, COL_SM_DIMGRAY },
+        { "dimgrey", THTMLCOL, COL_SM_DIMGREY },
+        { "dodgerblue", THTMLCOL, COL_SM_DODGERBLUE },
+        { "dvip", TDVIPSNAMESCOL, COL_SM_BLACK },
+        { "firebrick", THTMLCOL, COL_SM_FIREBRICK },
+        { "floralwhite", THTMLCOL, COL_SM_FLORALWHITE },
+        { "forestgreen", THTMLCOL, COL_SM_FORESTGREEN },
+        { "fuchsia", TMATHMLCOL, COL_SM_FUCHSIA },
+        { "gainsboro", THTMLCOL, COL_SM_GAINSBORO },
+        { "ghostwhite", THTMLCOL, COL_SM_GHOSTWHITE },
+        { "gold", THTMLCOL, COL_SM_GOLD },
+        { "goldenrod", THTMLCOL, COL_SM_GOLDENROD },
+        { "gray", TMATHMLCOL, COL_SM_GRAY },
+        { "green", TMATHMLCOL, COL_SM_GREEN },
+        { "greenyellow", THTMLCOL, COL_SM_GREENYELLOW },
+        { "grey", THTMLCOL, COL_SM_GREY },
+        { "hex", THEX, COL_SM_BLACK },
+        { "honeydew", THTMLCOL, COL_SM_HONEYDEW },
+        { "hotpink", THTMLCOL, COL_SM_HOTPINK },
+        { "indianred", THTMLCOL, COL_SM_INDIANRED },
+        { "indigo", THTMLCOL, COL_SM_INDIGO },
+        { "ivory", THTMLCOL, COL_SM_IVORY },
+        { "khaki", THTMLCOL, COL_SM_KHAKI },
+        { "lavender", THTMLCOL, COL_SM_LAVENDER },
+        { "lavenderblush", THTMLCOL, COL_SM_LAVENDERBLUSH },
+        { "lawngreen", THTMLCOL, COL_SM_LAWNGREEN },
+        { "lemonchiffon", THTMLCOL, COL_SM_LEMONCHIFFON },
+        { "lightblue", THTMLCOL, COL_SM_LIGHTBLUE },
+        { "lightcoral", THTMLCOL, COL_SM_LIGHTCORAL },
+        { "lightcyan", THTMLCOL, COL_SM_LIGHTCYAN },
+        { "lightgoldenrodyellow", THTMLCOL, COL_SM_LIGHTGOLDENRODYELLOW },
+        { "lightgray", THTMLCOL, COL_SM_LIGHTGRAY },
+        { "lightgreen", THTMLCOL, COL_SM_LIGHTGREEN },
+        { "lightgrey", THTMLCOL, COL_SM_LIGHTGREY },
+        { "lightpink", THTMLCOL, COL_SM_LIGHTPINK },
+        { "lightsalmon", THTMLCOL, COL_SM_LIGHTSALMON },
+        { "lightseagreen", THTMLCOL, COL_SM_LIGHTSEAGREEN },
+        { "lightskyblue", THTMLCOL, COL_SM_LIGHTSKYBLUE },
+        { "lightslategray", THTMLCOL, COL_SM_LIGHTSLATEGRAY },
+        { "lightslategrey", THTMLCOL, COL_SM_LIGHTSLATEGREY },
+        { "lightsteelblue", THTMLCOL, COL_SM_LIGHTSTEELBLUE },
+        { "lightyellow", THTMLCOL, COL_SM_LIGHTYELLOW },
+        { "lime", TMATHMLCOL, COL_SM_LIME },
+        { "limegreen", THTMLCOL, COL_SM_LIMEGREEN },
+        { "linen", THTMLCOL, COL_SM_LINEN },
+        { "lo", TICONICCOL, COL_SM_LO_GREEN },
+        { "magenta", TMATHMLCOL, COL_SM_MAGENTA },
+        { "maroon", TMATHMLCOL, COL_SM_MAROON },
+        { "mediumaquamarine", THTMLCOL, COL_SM_MEDIUMAQUAMARINE },
+        { "mediumblue", THTMLCOL, COL_SM_MEDIUMBLUE },
+        { "mediumorchid", THTMLCOL, COL_SM_MEDIUMORCHID },
+        { "mediumpurple", THTMLCOL, COL_SM_MEDIUMPURPLE },
+        { "mediumseagreen", THTMLCOL, COL_SM_MEDIUMSEAGREEN },
+        { "mediumslateblue", THTMLCOL, COL_SM_MEDIUMSLATEBLUE },
+        { "mediumspringgreen", THTMLCOL, COL_SM_MEDIUMSPRINGGREEN },
+        { "mediumturquoise", THTMLCOL, COL_SM_MEDIUMTURQUOISE },
+        { "mediumvioletred", THTMLCOL, COL_SM_MEDIUMVIOLETRED },
+        { "midnightblue", THTMLCOL, COL_SM_MIDNIGHTBLUE },
+        { "mintcream", THTMLCOL, COL_SM_MINTCREAM },
+        { "mistyrose", THTMLCOL, COL_SM_MISTYROSE },
+        { "moccasin", THTMLCOL, COL_SM_MOCCASIN },
+        { "navajowhite", THTMLCOL, COL_SM_NAVAJOWHITE },
+        { "navy", TMATHMLCOL, COL_SM_NAVY },
+        { "oldlace", THTMLCOL, COL_SM_OLDLACE },
+        { "olive", TMATHMLCOL, COL_SM_OLIVE },
+        { "olivedrab", THTMLCOL, COL_SM_OLIVEDRAB },
+        { "orange", THTMLCOL, COL_SM_ORANGE },
+        { "orangered", THTMLCOL, COL_SM_ORANGERED },
+        { "orchid", THTMLCOL, COL_SM_ORCHID },
+        { "palegoldenrod", THTMLCOL, COL_SM_PALEGOLDENROD },
+        { "palegreen", THTMLCOL, COL_SM_PALEGREEN },
+        { "paleturquoise", THTMLCOL, COL_SM_PALETURQUOISE },
+        { "palevioletred", THTMLCOL, COL_SM_PALEVIOLETRED },
+        { "papayawhip", THTMLCOL, COL_SM_PAPAYAWHIP },
+        { "peachpuff", THTMLCOL, COL_SM_PEACHPUFF },
+        { "peru", THTMLCOL, COL_SM_PERU },
+        { "pink", THTMLCOL, COL_SM_PINK },
+        { "plum", THTMLCOL, COL_SM_PLUM },
+        { "powderblue", THTMLCOL, COL_SM_POWDERBLUE },
+        { "purple", TMATHMLCOL, COL_SM_PURPLE },
+        { "rebeccapurple", THTMLCOL, COL_SM_REBECCAPURPLE },
+        { "red", TMATHMLCOL, COL_SM_RED },
+        { "rgb", TRGB, COL_AUTO },
+        { "rgba", TRGBA, COL_AUTO },
+        { "rosybrown", THTMLCOL, COL_SM_ROSYBROWN },
+        { "royalblue", THTMLCOL, COL_SM_ROYALBLUE },
+        { "saddlebrown", THTMLCOL, COL_SM_SADDLEBROWN },
+        { "salmon", THTMLCOL, COL_SM_SALMON },
+        { "sandybrown", THTMLCOL, COL_SM_SANDYBROWN },
+        { "seagreen", THTMLCOL, COL_SM_SEAGREEN },
+        { "seashell", THTMLCOL, COL_SM_SEASHELL },
+        { "sienna", THTMLCOL, COL_SM_SIENNA },
+        { "silver", TMATHMLCOL, COL_SM_SILVER },
+        { "skyblue", THTMLCOL, COL_SM_SKYBLUE },
+        { "slateblue", THTMLCOL, COL_SM_SLATEBLUE },
+        { "slategray", THTMLCOL, COL_SM_SLATEGRAY },
+        { "slategrey", THTMLCOL, COL_SM_SLATEGREY },
+        { "snow", THTMLCOL, COL_SM_SNOW },
+        { "springgreen", THTMLCOL, COL_SM_SPRINGGREEN },
+        { "steelblue", THTMLCOL, COL_SM_STEELBLUE },
+        { "tan", THTMLCOL, COL_SM_TAN },
+        { "teal", TMATHMLCOL, COL_SM_TEAL },
+        { "thistle", THTMLCOL, COL_SM_THISTLE },
+        { "tomato", THTMLCOL, COL_SM_TOMATO },
+        { "turquoise", THTMLCOL, COL_SM_TURQUOISE },
+        { "ubuntu", TICONICCOL, COL_SM_UBUNTU_ORANGE },
+        { "violet", THTMLCOL, COL_SM_VIOLET },
+        { "wheat", THTMLCOL, COL_SM_WHEAT },
+        { "white", TMATHMLCOL, COL_SM_WHITE },
+        { "whitesmoke", THTMLCOL, COL_SM_WHITESMOKE },
+        { "yellow", TMATHMLCOL, COL_SM_YELLOW },
+        { "yellowgreen", THTMLCOL, COL_SM_YELLOWGREEN } };
+
+const SmColorTokenTableEntry starmathdatabase::aColorTokenTableHTML[]
+    = { { "aliceblue", THTMLCOL, COL_SM_ALICEBLUE },
+        { "antiquewhite", THTMLCOL, COL_SM_ANTIQUEWHITE },
+        { "aqua", TMATHMLCOL, COL_SM_AQUA },
+        { "aquamarine", THTMLCOL, COL_SM_AQUAMARINE },
+        { "azure", THTMLCOL, COL_SM_AZURE },
+        { "beige", THTMLCOL, COL_SM_BEIGE },
+        { "bisque", THTMLCOL, COL_SM_BISQUE },
+        { "black", TMATHMLCOL, COL_SM_BLACK },
+        { "blanchedalmond", THTMLCOL, COL_SM_BLANCHEDALMOND },
+        { "blue", TMATHMLCOL, COL_SM_BLUE },
+        { "blueviolet", THTMLCOL, COL_SM_BLUEVIOLET },
+        { "brown", THTMLCOL, COL_SM_BROWN },
+        { "burlywood", THTMLCOL, COL_SM_BURLYWOOD },
+        { "cadetblue", THTMLCOL, COL_SM_CADETBLUE },
+        { "chartreuse", THTMLCOL, COL_SM_CHARTREUSE },
+        { "chocolate", THTMLCOL, COL_SM_CHOCOLATE },
+        { "coral", THTMLCOL, COL_SM_CORAL },
+        { "cornflowerblue", THTMLCOL, COL_SM_CORNFLOWERBLUE },
+        { "cornsilk", THTMLCOL, COL_SM_CORNSILK },
+        { "crimson", THTMLCOL, COL_SM_CRIMSON },
+        { "cyan", TMATHMLCOL, COL_SM_CYAN },
+        { "darkblue", THTMLCOL, COL_SM_DARKBLUE },
+        { "darkcyan", THTMLCOL, COL_SM_DARKCYAN },
+        { "darkgoldenrod", THTMLCOL, COL_SM_DARKGOLDENROD },
+        { "darkgray", THTMLCOL, COL_SM_DARKGRAY },
+        { "darkgreen", THTMLCOL, COL_SM_DARKGREEN },
+        { "darkgrey", THTMLCOL, COL_SM_DARKGREY },
+        { "darkkhaki", THTMLCOL, COL_SM_DARKKHAKI },
+        { "darkmagenta", THTMLCOL, COL_SM_DARKMAGENTA },
+        { "darkolivegreen", THTMLCOL, COL_SM_DARKOLIVEGREEN },
+        { "darkorange", THTMLCOL, COL_SM_DARKORANGE },
+        { "darkorchid", THTMLCOL, COL_SM_DARKORCHID },
+        { "darkred", THTMLCOL, COL_SM_DARKRED },
+        { "darksalmon", THTMLCOL, COL_SM_DARKSALMON },
+        { "darkseagreen", THTMLCOL, COL_SM_DARKSEAGREEN },
+        { "darkslateblue", THTMLCOL, COL_SM_DARKSLATEBLUE },
+        { "darkslategray", THTMLCOL, COL_SM_DARKSLATEGRAY },
+        { "darkslategrey", THTMLCOL, COL_SM_DARKSLATEGREY },
+        { "darkturquoise", THTMLCOL, COL_SM_DARKTURQUOISE },
+        { "darkviolet", THTMLCOL, COL_SM_DARKVIOLET },
+        { "deeppink", THTMLCOL, COL_SM_DEEPPINK },
+        { "deepskyblue", THTMLCOL, COL_SM_DEEPSKYBLUE },
+        { "dimgray", THTMLCOL, COL_SM_DIMGRAY },
+        { "dimgrey", THTMLCOL, COL_SM_DIMGREY },
+        { "dodgerblue", THTMLCOL, COL_SM_DODGERBLUE },
+        { "firebrick", THTMLCOL, COL_SM_FIREBRICK },
+        { "floralwhite", THTMLCOL, COL_SM_FLORALWHITE },
+        { "forestgreen", THTMLCOL, COL_SM_FORESTGREEN },
+        { "fuchsia", TMATHMLCOL, COL_SM_FUCHSIA },
+        { "gainsboro", THTMLCOL, COL_SM_GAINSBORO },
+        { "ghostwhite", THTMLCOL, COL_SM_GHOSTWHITE },
+        { "gold", THTMLCOL, COL_SM_GOLD },
+        { "goldenrod", THTMLCOL, COL_SM_GOLDENROD },
+        { "gray", TMATHMLCOL, COL_SM_GRAY },
+        { "green", TMATHMLCOL, COL_SM_GREEN },
+        { "greenyellow", THTMLCOL, COL_SM_GREENYELLOW },
+        { "grey", THTMLCOL, COL_SM_GREY },
+        { "honeydew", THTMLCOL, COL_SM_HONEYDEW },
+        { "hotpink", THTMLCOL, COL_SM_HOTPINK },
+        { "indianred", THTMLCOL, COL_SM_INDIANRED },
+        { "indigo", THTMLCOL, COL_SM_INDIGO },
+        { "ivory", THTMLCOL, COL_SM_IVORY },
+        { "khaki", THTMLCOL, COL_SM_KHAKI },
+        { "lavender", THTMLCOL, COL_SM_LAVENDER },
+        { "lavenderblush", THTMLCOL, COL_SM_LAVENDERBLUSH },
+        { "lawngreen", THTMLCOL, COL_SM_LAWNGREEN },
+        { "lemonchiffon", THTMLCOL, COL_SM_LEMONCHIFFON },
+        { "lightblue", THTMLCOL, COL_SM_LIGHTBLUE },
+        { "lightcoral", THTMLCOL, COL_SM_LIGHTCORAL },
+        { "lightcyan", THTMLCOL, COL_SM_LIGHTCYAN },
+        { "lightgoldenrodyellow", THTMLCOL, COL_SM_LIGHTGOLDENRODYELLOW },
+        { "lightgray", THTMLCOL, COL_SM_LIGHTGRAY },
+        { "lightgreen", THTMLCOL, COL_SM_LIGHTGREEN },
+        { "lightgrey", THTMLCOL, COL_SM_LIGHTGREY },
+        { "lightpink", THTMLCOL, COL_SM_LIGHTPINK },
+        { "lightsalmon", THTMLCOL, COL_SM_LIGHTSALMON },
+        { "lightseagreen", THTMLCOL, COL_SM_LIGHTSEAGREEN },
+        { "lightskyblue", THTMLCOL, COL_SM_LIGHTSKYBLUE },
+        { "lightslategray", THTMLCOL, COL_SM_LIGHTSLATEGRAY },
+        { "lightslategrey", THTMLCOL, COL_SM_LIGHTSLATEGREY },
+        { "lightsteelblue", THTMLCOL, COL_SM_LIGHTSTEELBLUE },
+        { "lightyellow", THTMLCOL, COL_SM_LIGHTYELLOW },
+        { "lime", TMATHMLCOL, COL_SM_LIME },
+        { "limegreen", THTMLCOL, COL_SM_LIMEGREEN },
+        { "linen", THTMLCOL, COL_SM_LINEN },
+        { "magenta", TMATHMLCOL, COL_SM_MAGENTA },
+        { "maroon", TMATHMLCOL, COL_SM_MAROON },
+        { "mediumaquamarine", THTMLCOL, COL_SM_MEDIUMAQUAMARINE },
+        { "mediumblue", THTMLCOL, COL_SM_MEDIUMBLUE },
+        { "mediumorchid", THTMLCOL, COL_SM_MEDIUMORCHID },
+        { "mediumpurple", THTMLCOL, COL_SM_MEDIUMPURPLE },
+        { "mediumseagreen", THTMLCOL, COL_SM_MEDIUMSEAGREEN },
+        { "mediumslateblue", THTMLCOL, COL_SM_MEDIUMSLATEBLUE },
+        { "mediumspringgreen", THTMLCOL, COL_SM_MEDIUMSPRINGGREEN },
+        { "mediumturquoise", THTMLCOL, COL_SM_MEDIUMTURQUOISE },
+        { "mediumvioletred", THTMLCOL, COL_SM_MEDIUMVIOLETRED },
+        { "midnightblue", THTMLCOL, COL_SM_MIDNIGHTBLUE },
+        { "mintcream", THTMLCOL, COL_SM_MINTCREAM },
+        { "mistyrose", THTMLCOL, COL_SM_MISTYROSE },
+        { "moccasin", THTMLCOL, COL_SM_MOCCASIN },
+        { "navajowhite", THTMLCOL, COL_SM_NAVAJOWHITE },
+        { "navy", TMATHMLCOL, COL_SM_NAVY },
+        { "oldlace", THTMLCOL, COL_SM_OLDLACE },
+        { "olive", TMATHMLCOL, COL_SM_OLIVE },
+        { "olivedrab", THTMLCOL, COL_SM_OLIVEDRAB },
+        { "orange", THTMLCOL, COL_SM_ORANGE },
+        { "orangered", THTMLCOL, COL_SM_ORANGERED },
+        { "orchid", THTMLCOL, COL_SM_ORCHID },
+        { "palegoldenrod", THTMLCOL, COL_SM_PALEGOLDENROD },
+        { "palegreen", THTMLCOL, COL_SM_PALEGREEN },
+        { "paleturquoise", THTMLCOL, COL_SM_PALETURQUOISE },
+        { "palevioletred", THTMLCOL, COL_SM_PALEVIOLETRED },
+        { "papayawhip", THTMLCOL, COL_SM_PAPAYAWHIP },
+        { "peachpuff", THTMLCOL, COL_SM_PEACHPUFF },
+        { "peru", THTMLCOL, COL_SM_PERU },
+        { "pink", THTMLCOL, COL_SM_PINK },
+        { "plum", THTMLCOL, COL_SM_PLUM },
+        { "powderblue", THTMLCOL, COL_SM_POWDERBLUE },
+        { "purple", TMATHMLCOL, COL_SM_PURPLE },
+        { "rebeccapurple", THTMLCOL, COL_SM_REBECCAPURPLE },
+        { "red", TMATHMLCOL, COL_SM_RED },
+        { "rosybrown", THTMLCOL, COL_SM_ROSYBROWN },
+        { "royalblue", THTMLCOL, COL_SM_ROYALBLUE },
+        { "saddlebrown", THTMLCOL, COL_SM_SADDLEBROWN },
+        { "salmon", THTMLCOL, COL_SM_SALMON },
+        { "sandybrown", THTMLCOL, COL_SM_SANDYBROWN },
+        { "seagreen", THTMLCOL, COL_SM_SEAGREEN },
+        { "seashell", THTMLCOL, COL_SM_SEASHELL },
+        { "sienna", THTMLCOL, COL_SM_SIENNA },
+        { "silver", TMATHMLCOL, COL_SM_SILVER },
+        { "skyblue", THTMLCOL, COL_SM_SKYBLUE },
+        { "slateblue", THTMLCOL, COL_SM_SLATEBLUE },
+        { "slategray", THTMLCOL, COL_SM_SLATEGRAY },
+        { "slategrey", THTMLCOL, COL_SM_SLATEGREY },
+        { "snow", THTMLCOL, COL_SM_SNOW },
+        { "springgreen", THTMLCOL, COL_SM_SPRINGGREEN },
+        { "steelblue", THTMLCOL, COL_SM_STEELBLUE },
+        { "tan", THTMLCOL, COL_SM_TAN },
+        { "teal", TMATHMLCOL, COL_SM_TEAL },
+        { "thistle", THTMLCOL, COL_SM_THISTLE },
+        { "tomato", THTMLCOL, COL_SM_TOMATO },
+        { "turquoise", THTMLCOL, COL_SM_TURQUOISE },
+        { "violet", THTMLCOL, COL_SM_VIOLET },
+        { "wheat", THTMLCOL, COL_SM_WHEAT },
+        { "white", TMATHMLCOL, COL_SM_WHITE },
+        { "whitesmoke", THTMLCOL, COL_SM_WHITESMOKE },
+        { "yellow", TMATHMLCOL, COL_SM_YELLOW },
+        { "yellowgreen", THTMLCOL, COL_SM_YELLOWGREEN } };
+
+const SmColorTokenTableEntry starmathdatabase::aColorTokenTableDVIPS[]
+    = { { "apricot", TDVIPSNAMESCOL, COL_SM_DIV_APRICOT },
+        { "aquamarine", TDVIPSNAMESCOL, COL_SM_DIV_AQUAMARINE },
+        { "bittersweet", TDVIPSNAMESCOL, COL_SM_DIV_BITTERSWEET },
+        { "black", TDVIPSNAMESCOL, COL_SM_BLACK },
+        { "blue", TDVIPSNAMESCOL, COL_SM_BLACK } };
+
+const SmColorTokenTableEntry starmathdatabase::aColorTokenTableMATHML[] = {
+    // clang-format off
+        { "aqua", TMATHMLCOL, COL_SM_AQUA },
+        { "black", TMATHMLCOL, COL_SM_BLACK },
+        { "blue", TMATHMLCOL, COL_SM_BLUE },
+        { "fuchsia", TMATHMLCOL, COL_SM_FUCHSIA },
+        { "gray", TMATHMLCOL, COL_SM_GRAY },
+        { "green", TMATHMLCOL, COL_SM_GREEN },
+        { "lime", TMATHMLCOL, COL_SM_LIME },
+        { "maroon", TMATHMLCOL, COL_SM_MAROON },
+        { "navy", TMATHMLCOL, COL_SM_NAVY },
+        { "olive", TMATHMLCOL, COL_SM_OLIVE },
+        { "purple", TMATHMLCOL, COL_SM_PURPLE },
+        { "red", TMATHMLCOL, COL_SM_RED },
+        { "silver", TMATHMLCOL, COL_SM_SILVER },
+        { "teal", TMATHMLCOL, COL_SM_TEAL },
+        { "white", TMATHMLCOL, COL_SM_WHITE },
+        { "yellow", TMATHMLCOL, COL_SM_YELLOW }
+    // clang-format on
+};
+
+const SmColorTokenTableEntry starmathdatabase::aColorTokenTableERROR[]
+    = { { "", TERROR, COL_SM_BLACK } };
+
+SmColorTokenTableEntry starmathdatabase::Identify_Color_Parser(sal_uInt32 cColor)
+{
+    for (auto i = std::begin(aColorTokenTableParse); i < std::end(aColorTokenTableParse); ++i)
+        if (i->equals(cColor))
+            return i;
+    for (auto i = std::begin(aColorTokenTableDVIPS); i < std::end(aColorTokenTableDVIPS); ++i)
+        if (i->equals(cColor))
+            return i;
+    if ((cColor & 0x00FFFFFF) == cColor)
+        return SmColorTokenTableEntry("", TRGB, cColor);
+    else
+        return SmColorTokenTableEntry("", TRGBA, cColor);
+}
+
+SmColorTokenTableEntry starmathdatabase::Identify_Color_MATHML(sal_uInt32 cColor)
+{
+    for (auto i = std::begin(aColorTokenTableMATHML); i < std::end(aColorTokenTableMATHML); ++i)
+        if (i->equals(cColor))
+            return i;
+    if ((cColor & 0x00FFFFFF) == cColor)
+        return SmColorTokenTableEntry("", TRGB, cColor);
+    else
+        return SmColorTokenTableEntry("", TRGBA, cColor);
+}
+
+SmColorTokenTableEntry starmathdatabase::Identify_Color_DVIPSNAMES(sal_uInt32 cColor)
+{
+    for (auto i = std::begin(aColorTokenTableDVIPS); i < std::end(aColorTokenTableDVIPS); ++i)
+        if (i->equals(cColor))
+            return i;
+    if ((cColor & 0x00FFFFFF) == cColor)
+        return SmColorTokenTableEntry("", TRGB, cColor);
+    else
+        return SmColorTokenTableEntry("", TRGBA, cColor);
+}
+
+const SmColorTokenTableEntry*
+starmathdatabase::Identify_ColorName_Parser(std::u16string_view colorname)
+{
+    if (colorname.empty())
+        return &aColorTokenTableERROR[0];
+    for (auto i = std::begin(aColorTokenTableParse); i < std::end(aColorTokenTableParse); ++i)
+    {
+        sal_Int32 matches = o3tl::compareToIgnoreAsciiCase(colorname, i->aIdent);
+        if (matches == 0)
+            return i;
+        if (matches < 0)
+            break;
+    }
+    return &aColorTokenTableERROR[0];
+}
+SmColorTokenTableEntry starmathdatabase::Identify_ColorName_HTML(std::u16string_view colorname)
+{
+    if (colorname.empty())
+        return SmColorTokenTableEntry("", TERROR, COL_SM_BLACK);
+    if (colorname[0] == '#')
+    {
+        Color col = Color::STRtoRGB(colorname);
+        return SmColorTokenTableEntry("", TRGB, col);
+    }
+    for (auto i = std::begin(aColorTokenTableHTML); i < std::end(aColorTokenTableHTML); ++i)
+    {
+        sal_Int32 matches = o3tl::compareToIgnoreAsciiCase(colorname, i->aIdent);
+        if (matches == 0)
+            return i;
+        if (matches < 0)
+            break;
+    }
+    return SmColorTokenTableEntry("", TERROR, COL_SM_BLACK);
+}
+const SmColorTokenTableEntry*
+starmathdatabase::Identify_ColorName_DVIPSNAMES(std::u16string_view colorname)
+{
+    if (colorname.empty())
+        return &aColorTokenTableERROR[0];
+    for (auto i = std::begin(aColorTokenTableDVIPS); i < std::end(aColorTokenTableDVIPS); ++i)
+    {
+        sal_Int32 matches = o3tl::compareToIgnoreAsciiCase(colorname, i->aIdent);
+        if (matches == 0)
+            return i;
+        if (matches < 0)
+            break;
+    }
+    return &aColorTokenTableERROR[0];
+}
diff --git a/starmath/source/mathml/xparsmlbase.cxx b/starmath/source/mathml/xparsmlbase.cxx
new file mode 100644
index 0000000000..ccfcf0049e
--- /dev/null
+++ b/starmath/source/mathml/xparsmlbase.cxx
@@ -0,0 +1,2166 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+#include <xparsmlbase.hxx>
+
+static ::css::beans::Pair<::rtl::OUString, ::rtl::OUString>
+    icustomMathmlHtmlEntitiesData[starmathdatabase::STARMATH_MATHMLHTML_ENTITY_NUMBER] = {
+        // clang-format off
+        { u"AElig"_ustr, u"\u00C6"_ustr },
+        { u"AMP"_ustr, u"\u0026"_ustr },
+        { u"Aacute"_ustr, u"\u00C1"_ustr },
+        { u"Abreve"_ustr, u"\u0102"_ustr },
+        { u"Acirc"_ustr, u"\u00C2"_ustr },
+        { u"Acy"_ustr, u"\u0410"_ustr },
+        { u"Afr"_ustr, u"\U0001D504"_ustr },
+        { u"Agrave"_ustr, u"\u00C0"_ustr },
+        { u"Alpha"_ustr, u"\u0391"_ustr },
+        { u"Amacr"_ustr, u"\u0100"_ustr },
+        { u"And"_ustr, u"\u2A53"_ustr },
+        { u"Aogon"_ustr, u"\u0104"_ustr },
+        { u"Aopf"_ustr, u"\U0001D538"_ustr },
+        { u"ApplyFunction"_ustr, u"\u2061"_ustr },
+        { u"Aring"_ustr, u"\u00C5"_ustr },
+        { u"Ascr"_ustr, u"\U0001D49C"_ustr },
+        { u"Assign"_ustr, u"\u2254"_ustr },
+        { u"Atilde"_ustr, u"\u00C3"_ustr },
+        { u"Auml"_ustr, u"\u00C4"_ustr },
+        { u"Backslash"_ustr, u"\u2216"_ustr },
+        { u"Barv"_ustr, u"\u2AE7"_ustr },
+        { u"Barwed"_ustr, u"\u2306"_ustr },
+        { u"Bcy"_ustr, u"\u0411"_ustr },
+        { u"Because"_ustr, u"\u2235"_ustr },
+        { u"Bernoullis"_ustr, u"\u212C"_ustr },
+        { u"Beta"_ustr, u"\u0392"_ustr },
+        { u"Bfr"_ustr, u"\U0001D505"_ustr },
+        { u"Bopf"_ustr, u"\U0001D539"_ustr },
+        { u"Breve"_ustr, u"\u02D8"_ustr },
+        { u"Bscr"_ustr, u"\u212C"_ustr },
+        { u"Bumpeq"_ustr, u"\u224E"_ustr },
+        { u"CHcy"_ustr, u"\u0427"_ustr },
+        { u"COPY"_ustr, u"\u00A9"_ustr },
+        { u"Cacute"_ustr, u"\u0106"_ustr },
+        { u"Cap"_ustr, u"\u22D2"_ustr },
+        { u"CapitalDifferentialD"_ustr, u"\u2145"_ustr },
+        { u"Cayleys"_ustr, u"\u212D"_ustr },
+        { u"Ccaron"_ustr, u"\u010C"_ustr },
+        { u"Ccedil"_ustr, u"\u00C7"_ustr },
+        { u"Ccirc"_ustr, u"\u0108"_ustr },
+        { u"Cconint"_ustr, u"\u2230"_ustr },
+        { u"Cdot"_ustr, u"\u010A"_ustr },
+        { u"Cedilla"_ustr, u"\u00B8"_ustr },
+        { u"CenterDot"_ustr, u"\u00B7"_ustr },
+        { u"Cfr"_ustr, u"\u212D"_ustr },
+        { u"Chi"_ustr, u"\u03A7"_ustr },
+        { u"CircleDot"_ustr, u"\u2299"_ustr },
+        { u"CircleMinus"_ustr, u"\u2296"_ustr },
+        { u"CirclePlus"_ustr, u"\u2295"_ustr },
+        { u"CircleTimes"_ustr, u"\u2297"_ustr },
+        { u"ClockwiseContourIntegral"_ustr, u"\u2232"_ustr },
+        { u"CloseCurlyDoubleQuote"_ustr, u"\u201D"_ustr },
+        { u"CloseCurlyQuote"_ustr, u"\u2019"_ustr },
+        { u"Colon"_ustr, u"\u2237"_ustr },
+        { u"Colone"_ustr, u"\u2A74"_ustr },
+        { u"Congruent"_ustr, u"\u2261"_ustr },
+        { u"Conint"_ustr, u"\u222F"_ustr },
+        { u"ContourIntegral"_ustr, u"\u222E"_ustr },
+        { u"Copf"_ustr, u"\u2102"_ustr },
+        { u"Coproduct"_ustr, u"\u2210"_ustr },
+        { u"CounterClockwiseContourIntegral"_ustr, u"\u2233"_ustr },
+        { u"Cross"_ustr, u"\u2A2F"_ustr },
+        { u"Cscr"_ustr, u"\U0001D49E"_ustr },
+        { u"Cup"_ustr, u"\u22D3"_ustr },
+        { u"CupCap"_ustr, u"\u224D"_ustr },
+        { u"DD"_ustr, u"\u2145"_ustr },
+        { u"DDotrahd"_ustr, u"\u2911"_ustr },
+        { u"DJcy"_ustr, u"\u0402"_ustr },
+        { u"DScy"_ustr, u"\u0405"_ustr },
+        { u"DZcy"_ustr, u"\u040F"_ustr },
+        { u"Dagger"_ustr, u"\u2021"_ustr },
+        { u"Darr"_ustr, u"\u21A1"_ustr },
+        { u"Dashv"_ustr, u"\u2AE4"_ustr },
+        { u"Dcaron"_ustr, u"\u010E"_ustr },
+        { u"Dcy"_ustr, u"\u0414"_ustr },
+        { u"Del"_ustr, u"\u2207"_ustr },
+        { u"Delta"_ustr, u"\u0394"_ustr },
+        { u"Dfr"_ustr, u"\U0001D507"_ustr },
+        { u"DiacriticalAcute"_ustr, u"\u00B4"_ustr },
+        { u"DiacriticalDot"_ustr, u"\u02D9"_ustr },
+        { u"DiacriticalDoubleAcute"_ustr, u"\u02DD"_ustr },
+        { u"DiacriticalGrave"_ustr, u"\u0060"_ustr },
+        { u"DiacriticalTilde"_ustr, u"\u02DC"_ustr },
+        { u"Diamond"_ustr, u"\u22C4"_ustr },
+        { u"DifferentialD"_ustr, u"\u2146"_ustr },
+        { u"Dopf"_ustr, u"\U0001D53B"_ustr },
+        { u"Dot"_ustr, u"\u00A8"_ustr },
+        { u"DotDot"_ustr, u"\u20DC"_ustr },
+        { u"DotEqual"_ustr, u"\u2250"_ustr },
+        { u"DoubleContourIntegral"_ustr, u"\u222F"_ustr },
+        { u"DoubleDot"_ustr, u"\u00A8"_ustr },
+        { u"DoubleDownArrow"_ustr, u"\u21D3"_ustr },
+        { u"DoubleLeftArrow"_ustr, u"\u21D0"_ustr },
+        { u"DoubleLeftRightArrow"_ustr, u"\u21D4"_ustr },
+        { u"DoubleLeftTee"_ustr, u"\u2AE4"_ustr },
+        { u"DoubleLongLeftArrow"_ustr, u"\u27F8"_ustr },
+        { u"DoubleLongLeftRightArrow"_ustr, u"\u27FA"_ustr },
+        { u"DoubleLongRightArrow"_ustr, u"\u27F9"_ustr },
+        { u"DoubleRightArrow"_ustr, u"\u21D2"_ustr },
+        { u"DoubleRightTee"_ustr, u"\u22A8"_ustr },
+        { u"DoubleUpArrow"_ustr, u"\u21D1"_ustr },
+        { u"DoubleUpDownArrow"_ustr, u"\u21D5"_ustr },
+        { u"DoubleVerticalBar"_ustr, u"\u2225"_ustr },
+        { u"DownArrow"_ustr, u"\u2193"_ustr },
+        { u"DownArrowBar"_ustr, u"\u2913"_ustr },
+        { u"DownArrowUpArrow"_ustr, u"\u21F5"_ustr },
+        { u"DownBreve"_ustr, u"\u0311"_ustr },
+        { u"DownLeftRightVector"_ustr, u"\u2950"_ustr },
+        { u"DownLeftTeeVector"_ustr, u"\u295E"_ustr },
+        { u"DownLeftVector"_ustr, u"\u21BD"_ustr },
+        { u"DownLeftVectorBar"_ustr, u"\u2956"_ustr },
+        { u"DownRightTeeVector"_ustr, u"\u295F"_ustr },
+        { u"DownRightVector"_ustr, u"\u21C1"_ustr },
+        { u"DownRightVectorBar"_ustr, u"\u2957"_ustr },
+        { u"DownTee"_ustr, u"\u22A4"_ustr },
+        { u"DownTeeArrow"_ustr, u"\u21A7"_ustr },
+        { u"Downarrow"_ustr, u"\u21D3"_ustr },
+        { u"Dscr"_ustr, u"\U0001D49F"_ustr },
+        { u"Dstrok"_ustr, u"\u0110"_ustr },
+        { u"ENG"_ustr, u"\u014A"_ustr },
+        { u"ETH"_ustr, u"\u00D0"_ustr },
+        { u"Eacute"_ustr, u"\u00C9"_ustr },
+        { u"Ecaron"_ustr, u"\u011A"_ustr },
+        { u"Ecirc"_ustr, u"\u00CA"_ustr },
+        { u"Ecy"_ustr, u"\u042D"_ustr },
+        { u"Edot"_ustr, u"\u0116"_ustr },
+        { u"Efr"_ustr, u"\U0001D508"_ustr },
+        { u"Egrave"_ustr, u"\u00C8"_ustr },
+        { u"Element"_ustr, u"\u2208"_ustr },
+        { u"Emacr"_ustr, u"\u0112"_ustr },
+        { u"EmptySmallSquare"_ustr, u"\u25FB"_ustr },
+        { u"EmptyVerySmallSquare"_ustr, u"\u25AB"_ustr },
+        { u"Eogon"_ustr, u"\u0118"_ustr },
+        { u"Eopf"_ustr, u"\U0001D53C"_ustr },
+        { u"Epsilon"_ustr, u"\u0395"_ustr },
+        { u"Equal"_ustr, u"\u2A75"_ustr },
+        { u"EqualTilde"_ustr, u"\u2242"_ustr },
+        { u"Equilibrium"_ustr, u"\u21CC"_ustr },
+        { u"Escr"_ustr, u"\u2130"_ustr },
+        { u"Esim"_ustr, u"\u2A73"_ustr },
+        { u"Eta"_ustr, u"\u0397"_ustr },
+        { u"Euml"_ustr, u"\u00CB"_ustr },
+        { u"Exists"_ustr, u"\u2203"_ustr },
+        { u"ExponentialE"_ustr, u"\u2147"_ustr },
+        { u"Fcy"_ustr, u"\u0424"_ustr },
+        { u"Ffr"_ustr, u"\U0001D509"_ustr },
+        { u"FilledSmallSquare"_ustr, u"\u25FC"_ustr },
+        { u"FilledVerySmallSquare"_ustr, u"\u25AA"_ustr },
+        { u"Fopf"_ustr, u"\U0001D53D"_ustr },
+        { u"ForAll"_ustr, u"\u2200"_ustr },
+        { u"Fouriertrf"_ustr, u"\u2131"_ustr },
+        { u"Fscr"_ustr, u"\u2131"_ustr },
+        { u"GJcy"_ustr, u"\u0403"_ustr },
+        { u"GT"_ustr, u"\u003E"_ustr },
+        { u"Gamma"_ustr, u"\u0393"_ustr },
+        { u"Gammad"_ustr, u"\u03DC"_ustr },
+        { u"Gbreve"_ustr, u"\u011E"_ustr },
+        { u"Gcedil"_ustr, u"\u0122"_ustr },
+        { u"Gcirc"_ustr, u"\u011C"_ustr },
+        { u"Gcy"_ustr, u"\u0413"_ustr },
+        { u"Gdot"_ustr, u"\u0120"_ustr },
+        { u"Gfr"_ustr, u"\U0001D50A"_ustr },
+        { u"Gg"_ustr, u"\u22D9"_ustr },
+        { u"Gopf"_ustr, u"\U0001D53E"_ustr },
+        { u"GreaterEqual"_ustr, u"\u2265"_ustr },
+        { u"GreaterEqualLess"_ustr, u"\u22DB"_ustr },
+        { u"GreaterFullEqual"_ustr, u"\u2267"_ustr },
+        { u"GreaterGreater"_ustr, u"\u2AA2"_ustr },
+        { u"GreaterLess"_ustr, u"\u2277"_ustr },
+        { u"GreaterSlantEqual"_ustr, u"\u2A7E"_ustr },
+        { u"GreaterTilde"_ustr, u"\u2273"_ustr },
+        { u"Gscr"_ustr, u"\U0001D4A2"_ustr },
+        { u"Gt"_ustr, u"\u226B"_ustr },
+        { u"HARDcy"_ustr, u"\u042A"_ustr },
+        { u"Hacek"_ustr, u"\u02C7"_ustr },
+        { u"Hat"_ustr, u"\u005E"_ustr },
+        { u"Hcirc"_ustr, u"\u0124"_ustr },
+        { u"Hfr"_ustr, u"\u210C"_ustr },
+        { u"HilbertSpace"_ustr, u"\u210B"_ustr },
+        { u"Hopf"_ustr, u"\u210D"_ustr },
+        { u"HorizontalLine"_ustr, u"\u2500"_ustr },
+        { u"Hscr"_ustr, u"\u210B"_ustr },
+        { u"Hstrok"_ustr, u"\u0126"_ustr },
+        { u"HumpDownHump"_ustr, u"\u224E"_ustr },
+        { u"HumpEqual"_ustr, u"\u224F"_ustr },
+        { u"IEcy"_ustr, u"\u0415"_ustr },
+        { u"IJlig"_ustr, u"\u0132"_ustr },
+        { u"IOcy"_ustr, u"\u0401"_ustr },
+        { u"Iacute"_ustr, u"\u00CD"_ustr },
+        { u"Icirc"_ustr, u"\u00CE"_ustr },
+        { u"Icy"_ustr, u"\u0418"_ustr },
+        { u"Idot"_ustr, u"\u0130"_ustr },
+        { u"Ifr"_ustr, u"\u2111"_ustr },
+        { u"Igrave"_ustr, u"\u00CC"_ustr },
+        { u"Im"_ustr, u"\u2111"_ustr },
+        { u"Imacr"_ustr, u"\u012A"_ustr },
+        { u"ImaginaryI"_ustr, u"\u2148"_ustr },
+        { u"Implies"_ustr, u"\u21D2"_ustr },
+        { u"Int"_ustr, u"\u222C"_ustr },
+        { u"Integral"_ustr, u"\u222B"_ustr },
+        { u"Intersection"_ustr, u"\u22C2"_ustr },
+        { u"InvisibleComma"_ustr, u"\u2063"_ustr },
+        { u"InvisibleTimes"_ustr, u"\u2062"_ustr },
+        { u"Iogon"_ustr, u"\u012E"_ustr },
+        { u"Iopf"_ustr, u"\U0001D540"_ustr },
+        { u"Iota"_ustr, u"\u0399"_ustr },
+        { u"Iscr"_ustr, u"\u2110"_ustr },
+        { u"Itilde"_ustr, u"\u0128"_ustr },
+        { u"Iukcy"_ustr, u"\u0406"_ustr },
+        { u"Iuml"_ustr, u"\u00CF"_ustr },
+        { u"Jcirc"_ustr, u"\u0134"_ustr },
+        { u"Jcy"_ustr, u"\u0419"_ustr },
+        { u"Jfr"_ustr, u"\U0001D50D"_ustr },
+        { u"Jopf"_ustr, u"\U0001D541"_ustr },
+        { u"Jscr"_ustr, u"\U0001D4A5"_ustr },
+        { u"Jsercy"_ustr, u"\u0408"_ustr },
+        { u"Jukcy"_ustr, u"\u0404"_ustr },
+        { u"KHcy"_ustr, u"\u0425"_ustr },
+        { u"KJcy"_ustr, u"\u040C"_ustr },
+        { u"Kappa"_ustr, u"\u039A"_ustr },
+        { u"Kcedil"_ustr, u"\u0136"_ustr },
+        { u"Kcy"_ustr, u"\u041A"_ustr },
+        { u"Kfr"_ustr, u"\U0001D50E"_ustr },
+        { u"Kopf"_ustr, u"\U0001D542"_ustr },
+        { u"Kscr"_ustr, u"\U0001D4A6"_ustr },
+        { u"LJcy"_ustr, u"\u0409"_ustr },
+        { u"LT"_ustr, u"\u003C"_ustr },
+        { u"Lacute"_ustr, u"\u0139"_ustr },
+        { u"Lambda"_ustr, u"\u039B"_ustr },
+        { u"Lang"_ustr, u"\u27EA"_ustr },
+        { u"Laplacetrf"_ustr, u"\u2112"_ustr },
+        { u"Larr"_ustr, u"\u219E"_ustr },
+        { u"Lcaron"_ustr, u"\u013D"_ustr },
+        { u"Lcedil"_ustr, u"\u013B"_ustr },
+        { u"Lcy"_ustr, u"\u041B"_ustr },
+        { u"LeftAngleBracket"_ustr, u"\u27E8"_ustr },
+        { u"LeftArrow"_ustr, u"\u2190"_ustr },
+        { u"LeftArrowBar"_ustr, u"\u21E4"_ustr },
+        { u"LeftArrowRightArrow"_ustr, u"\u21C6"_ustr },
+        { u"LeftCeiling"_ustr, u"\u2308"_ustr },
+        { u"LeftDoubleBracket"_ustr, u"\u27E6"_ustr },
+        { u"LeftDownTeeVector"_ustr, u"\u2961"_ustr },
+        { u"LeftDownVector"_ustr, u"\u21C3"_ustr },
+        { u"LeftDownVectorBar"_ustr, u"\u2959"_ustr },
+        { u"LeftFloor"_ustr, u"\u230A"_ustr },
+        { u"LeftRightArrow"_ustr, u"\u2194"_ustr },
+        { u"LeftRightVector"_ustr, u"\u294E"_ustr },
+        { u"LeftTee"_ustr, u"\u22A3"_ustr },
+        { u"LeftTeeArrow"_ustr, u"\u21A4"_ustr },
+        { u"LeftTeeVector"_ustr, u"\u295A"_ustr },
+        { u"LeftTriangle"_ustr, u"\u22B2"_ustr },
+        { u"LeftTriangleBar"_ustr, u"\u29CF"_ustr },
+        { u"LeftTriangleEqual"_ustr, u"\u22B4"_ustr },
+        { u"LeftUpDownVector"_ustr, u"\u2951"_ustr },
+        { u"LeftUpTeeVector"_ustr, u"\u2960"_ustr },
+        { u"LeftUpVector"_ustr, u"\u21BF"_ustr },
+        { u"LeftUpVectorBar"_ustr, u"\u2958"_ustr },
+        { u"LeftVector"_ustr, u"\u21BC"_ustr },
+        { u"LeftVectorBar"_ustr, u"\u2952"_ustr },
+        { u"Leftarrow"_ustr, u"\u21D0"_ustr },
+        { u"Leftrightarrow"_ustr, u"\u21D4"_ustr },
+        { u"LessEqualGreater"_ustr, u"\u22DA"_ustr },
+        { u"LessFullEqual"_ustr, u"\u2266"_ustr },
+        { u"LessGreater"_ustr, u"\u2276"_ustr },
+        { u"LessLess"_ustr, u"\u2AA1"_ustr },
+        { u"LessSlantEqual"_ustr, u"\u2A7D"_ustr },
+        { u"LessTilde"_ustr, u"\u2272"_ustr },
+        { u"Lfr"_ustr, u"\U0001D50F"_ustr },
+        { u"Ll"_ustr, u"\u22D8"_ustr },
+        { u"Lleftarrow"_ustr, u"\u21DA"_ustr },
+        { u"Lmidot"_ustr, u"\u013F"_ustr },
+        { u"LongLeftArrow"_ustr, u"\u27F5"_ustr },
+        { u"LongLeftRightArrow"_ustr, u"\u27F7"_ustr },
+        { u"LongRightArrow"_ustr, u"\u27F6"_ustr },
+        { u"Longleftarrow"_ustr, u"\u27F8"_ustr },
+        { u"Longleftrightarrow"_ustr, u"\u27FA"_ustr },
+        { u"Longrightarrow"_ustr, u"\u27F9"_ustr },
+        { u"Lopf"_ustr, u"\U0001D543"_ustr },
+        { u"LowerLeftArrow"_ustr, u"\u2199"_ustr },
+        { u"LowerRightArrow"_ustr, u"\u2198"_ustr },
+        { u"Lscr"_ustr, u"\u2112"_ustr },
+        { u"Lsh"_ustr, u"\u21B0"_ustr },
+        { u"Lstrok"_ustr, u"\u0141"_ustr },
+        { u"Lt"_ustr, u"\u226A"_ustr },
+        { u"Map"_ustr, u"\u2905"_ustr },
+        { u"Mcy"_ustr, u"\u041C"_ustr },
+        { u"MediumSpace"_ustr, u"\u205F"_ustr },
+        { u"Mellintrf"_ustr, u"\u2133"_ustr },
+        { u"Mfr"_ustr, u"\U0001D510"_ustr },
+        { u"MinusPlus"_ustr, u"\u2213"_ustr },
+        { u"Mopf"_ustr, u"\U0001D544"_ustr },
+        { u"Mscr"_ustr, u"\u2133"_ustr },
+        { u"Mu"_ustr, u"\u039C"_ustr },
+        { u"NJcy"_ustr, u"\u040A"_ustr },
+        { u"Nacute"_ustr, u"\u0143"_ustr },
+        { u"Ncaron"_ustr, u"\u0147"_ustr },
+        { u"Ncedil"_ustr, u"\u0145"_ustr },
+        { u"Ncy"_ustr, u"\u041D"_ustr },
+        { u"NegativeMediumSpace"_ustr, u"\u200B"_ustr },
+        { u"NegativeThickSpace"_ustr, u"\u200B"_ustr },
+        { u"NegativeThinSpace"_ustr, u"\u200B"_ustr },
+        { u"NegativeVeryThinSpace"_ustr, u"\u200B"_ustr },
+        { u"NestedGreaterGreater"_ustr, u"\u226B"_ustr },
+        { u"NestedLessLess"_ustr, u"\u226A"_ustr },
+        { u"NewLine"_ustr, u"\u000A"_ustr },
+        { u"Nfr"_ustr, u"\U0001D511"_ustr },
+        { u"NoBreak"_ustr, u"\u2060"_ustr },
+        { u"NonBreakingSpace"_ustr, u"\u00A0"_ustr },
+        { u"Nopf"_ustr, u"\u2115"_ustr },
+        { u"Not"_ustr, u"\u2AEC"_ustr },
+        { u"NotCongruent"_ustr, u"\u2262"_ustr },
+        { u"NotCupCap"_ustr, u"\u226D"_ustr },
+        { u"NotDoubleVerticalBar"_ustr, u"\u2226"_ustr },
+        { u"NotElement"_ustr, u"\u2209"_ustr },
+        { u"NotEqual"_ustr, u"\u2260"_ustr },
+        { u"NotEqualTilde"_ustr, u"\u2242\u0338"_ustr },
+        { u"NotExists"_ustr, u"\u2204"_ustr },
+        { u"NotGreater"_ustr, u"\u226F"_ustr },
+        { u"NotGreaterEqual"_ustr, u"\u2271"_ustr },
+        { u"NotGreaterFullEqual"_ustr, u"\u2267\u0338"_ustr },
+        { u"NotGreaterGreater"_ustr, u"\u226B\u0338"_ustr },
+        { u"NotGreaterLess"_ustr, u"\u2279"_ustr },
+        { u"NotGreaterSlantEqual"_ustr, u"\u2A7E\u0338"_ustr },
+        { u"NotGreaterTilde"_ustr, u"\u2275"_ustr },
+        { u"NotHumpDownHump"_ustr, u"\u224E\u0338"_ustr },
+        { u"NotHumpEqual"_ustr, u"\u224F\u0338"_ustr },
+        { u"NotLeftTriangle"_ustr, u"\u22EA"_ustr },
+        { u"NotLeftTriangleBar"_ustr, u"\u29CF\u0338"_ustr },
+        { u"NotLeftTriangleEqual"_ustr, u"\u22EC"_ustr },
+        { u"NotLess"_ustr, u"\u226E"_ustr },
+        { u"NotLessEqual"_ustr, u"\u2270"_ustr },
+        { u"NotLessGreater"_ustr, u"\u2278"_ustr },
+        { u"NotLessLess"_ustr, u"\u226A\u0338"_ustr },
+        { u"NotLessSlantEqual"_ustr, u"\u2A7D\u0338"_ustr },
+        { u"NotLessTilde"_ustr, u"\u2274"_ustr },
+        { u"NotNestedGreaterGreater"_ustr, u"\u2AA2\u0338"_ustr },
+        { u"NotNestedLessLess"_ustr, u"\u2AA1\u0338"_ustr },
+        { u"NotPrecedes"_ustr, u"\u2280"_ustr },
+        { u"NotPrecedesEqual"_ustr, u"\u2AAF\u0338"_ustr },
+        { u"NotPrecedesSlantEqual"_ustr, u"\u22E0"_ustr },
+        { u"NotReverseElement"_ustr, u"\u220C"_ustr },
+        { u"NotRightTriangle"_ustr, u"\u22EB"_ustr },
+        { u"NotRightTriangleBar"_ustr, u"\u29D0\u0338"_ustr },
+        { u"NotRightTriangleEqual"_ustr, u"\u22ED"_ustr },
+        { u"NotSquareSubset"_ustr, u"\u228F\u0338"_ustr },
+        { u"NotSquareSubsetEqual"_ustr, u"\u22E2"_ustr },
+        { u"NotSquareSuperset"_ustr, u"\u2290\u0338"_ustr },
+        { u"NotSquareSupersetEqual"_ustr, u"\u22E3"_ustr },
+        { u"NotSubset"_ustr, u"\u2282\u20D2"_ustr },
+        { u"NotSubsetEqual"_ustr, u"\u2288"_ustr },
+        { u"NotSucceeds"_ustr, u"\u2281"_ustr },
+        { u"NotSucceedsEqual"_ustr, u"\u2AB0\u0338"_ustr },
+        { u"NotSucceedsSlantEqual"_ustr, u"\u22E1"_ustr },
+        { u"NotSucceedsTilde"_ustr, u"\u227F\u0338"_ustr },
+        { u"NotSuperset"_ustr, u"\u2283\u20D2"_ustr },
+        { u"NotSupersetEqual"_ustr, u"\u2289"_ustr },
+        { u"NotTilde"_ustr, u"\u2241"_ustr },
+        { u"NotTildeEqual"_ustr, u"\u2244"_ustr },
+        { u"NotTildeFullEqual"_ustr, u"\u2247"_ustr },
+        { u"NotTildeTilde"_ustr, u"\u2249"_ustr },
+        { u"NotVerticalBar"_ustr, u"\u2224"_ustr },
+        { u"Nscr"_ustr, u"\U0001D4A9"_ustr },
+        { u"Ntilde"_ustr, u"\u00D1"_ustr },
+        { u"Nu"_ustr, u"\u039D"_ustr },
+        { u"OElig"_ustr, u"\u0152"_ustr },
+        { u"Oacute"_ustr, u"\u00D3"_ustr },
+        { u"Ocirc"_ustr, u"\u00D4"_ustr },
+        { u"Ocy"_ustr, u"\u041E"_ustr },
+        { u"Odblac"_ustr, u"\u0150"_ustr },
+        { u"Ofr"_ustr, u"\U0001D512"_ustr },
+        { u"Ograve"_ustr, u"\u00D2"_ustr },
+        { u"Omacr"_ustr, u"\u014C"_ustr },
+        { u"Omega"_ustr, u"\u03A9"_ustr },
+        { u"Omicron"_ustr, u"\u039F"_ustr },
+        { u"Oopf"_ustr, u"\U0001D546"_ustr },
+        { u"OpenCurlyDoubleQuote"_ustr, u"\u201C"_ustr },
+        { u"OpenCurlyQuote"_ustr, u"\u2018"_ustr },
+        { u"Or"_ustr, u"\u2A54"_ustr },
+        { u"Oscr"_ustr, u"\U0001D4AA"_ustr },
+        { u"Oslash"_ustr, u"\u00D8"_ustr },
+        { u"Otilde"_ustr, u"\u00D5"_ustr },
+        { u"Otimes"_ustr, u"\u2A37"_ustr },
+        { u"Ouml"_ustr, u"\u00D6"_ustr },
+        { u"OverBar"_ustr, u"\u203E"_ustr },
+        { u"OverBrace"_ustr, u"\u23DE"_ustr },
+        { u"OverBracket"_ustr, u"\u23B4"_ustr },
+        { u"OverParenthesis"_ustr, u"\u23DC"_ustr },
+        { u"PartialD"_ustr, u"\u2202"_ustr },
+        { u"Pcy"_ustr, u"\u041F"_ustr },
+        { u"Pfr"_ustr, u"\U0001D513"_ustr },
+        { u"Phi"_ustr, u"\u03A6"_ustr },
+        { u"Pi"_ustr, u"\u03A0"_ustr },
+        { u"PlusMinus"_ustr, u"\u00B1"_ustr },
+        { u"Poincareplane"_ustr, u"\u210C"_ustr },
+        { u"Popf"_ustr, u"\u2119"_ustr },
+        { u"Pr"_ustr, u"\u2ABB"_ustr },
+        { u"Precedes"_ustr, u"\u227A"_ustr },
+        { u"PrecedesEqual"_ustr, u"\u2AAF"_ustr },
+        { u"PrecedesSlantEqual"_ustr, u"\u227C"_ustr },
+        { u"PrecedesTilde"_ustr, u"\u227E"_ustr },
+        { u"Prime"_ustr, u"\u2033"_ustr },
+        { u"Product"_ustr, u"\u220F"_ustr },
+        { u"Proportion"_ustr, u"\u2237"_ustr },
+        { u"Proportional"_ustr, u"\u221D"_ustr },
+        { u"Pscr"_ustr, u"\U0001D4AB"_ustr },
+        { u"Psi"_ustr, u"\u03A8"_ustr },
+        { u"QUOT"_ustr, u"\u0022"_ustr },
+        { u"Qfr"_ustr, u"\U0001D514"_ustr },
+        { u"Qopf"_ustr, u"\u211A"_ustr },
+        { u"Qscr"_ustr, u"\U0001D4AC"_ustr },
+        { u"RBarr"_ustr, u"\u2910"_ustr },
+        { u"REG"_ustr, u"\u00AE"_ustr },
+        { u"Racute"_ustr, u"\u0154"_ustr },
+        { u"Rang"_ustr, u"\u27EB"_ustr },
+        { u"Rarr"_ustr, u"\u21A0"_ustr },
+        { u"Rarrtl"_ustr, u"\u2916"_ustr },
+        { u"Rcaron"_ustr, u"\u0158"_ustr },
+        { u"Rcedil"_ustr, u"\u0156"_ustr },
+        { u"Rcy"_ustr, u"\u0420"_ustr },
+        { u"Re"_ustr, u"\u211C"_ustr },
+        { u"ReverseElement"_ustr, u"\u220B"_ustr },
+        { u"ReverseEquilibrium"_ustr, u"\u21CB"_ustr },
+        { u"ReverseUpEquilibrium"_ustr, u"\u296F"_ustr },
+        { u"Rfr"_ustr, u"\u211C"_ustr },
+        { u"Rho"_ustr, u"\u03A1"_ustr },
+        { u"RightAngleBracket"_ustr, u"\u27E9"_ustr },
+        { u"RightArrow"_ustr, u"\u2192"_ustr },
+        { u"RightArrowBar"_ustr, u"\u21E5"_ustr },
+        { u"RightArrowLeftArrow"_ustr, u"\u21C4"_ustr },
+        { u"RightCeiling"_ustr, u"\u2309"_ustr },
+        { u"RightDoubleBracket"_ustr, u"\u27E7"_ustr },
+        { u"RightDownTeeVector"_ustr, u"\u295D"_ustr },
+        { u"RightDownVector"_ustr, u"\u21C2"_ustr },
+        { u"RightDownVectorBar"_ustr, u"\u2955"_ustr },
+        { u"RightFloor"_ustr, u"\u230B"_ustr },
+        { u"RightTee"_ustr, u"\u22A2"_ustr },
+        { u"RightTeeArrow"_ustr, u"\u21A6"_ustr },
+        { u"RightTeeVector"_ustr, u"\u295B"_ustr },
+        { u"RightTriangle"_ustr, u"\u22B3"_ustr },
+        { u"RightTriangleBar"_ustr, u"\u29D0"_ustr },
+        { u"RightTriangleEqual"_ustr, u"\u22B5"_ustr },
+        { u"RightUpDownVector"_ustr, u"\u294F"_ustr },
+        { u"RightUpTeeVector"_ustr, u"\u295C"_ustr },
+        { u"RightUpVector"_ustr, u"\u21BE"_ustr },
+        { u"RightUpVectorBar"_ustr, u"\u2954"_ustr },
+        { u"RightVector"_ustr, u"\u21C0"_ustr },
+        { u"RightVectorBar"_ustr, u"\u2953"_ustr },
+        { u"Rightarrow"_ustr, u"\u21D2"_ustr },
+        { u"Ropf"_ustr, u"\u211D"_ustr },
+        { u"RoundImplies"_ustr, u"\u2970"_ustr },
+        { u"Rrightarrow"_ustr, u"\u21DB"_ustr },
+        { u"Rscr"_ustr, u"\u211B"_ustr },
+        { u"Rsh"_ustr, u"\u21B1"_ustr },
+        { u"RuleDelayed"_ustr, u"\u29F4"_ustr },
+        { u"SHCHcy"_ustr, u"\u0429"_ustr },
+        { u"SHcy"_ustr, u"\u0428"_ustr },
+        { u"SOFTcy"_ustr, u"\u042C"_ustr },
+        { u"Sacute"_ustr, u"\u015A"_ustr },
+        { u"Sc"_ustr, u"\u2ABC"_ustr },
+        { u"Scaron"_ustr, u"\u0160"_ustr },
+        { u"Scedil"_ustr, u"\u015E"_ustr },
+        { u"Scirc"_ustr, u"\u015C"_ustr },
+        { u"Scy"_ustr, u"\u0421"_ustr },
+        { u"Sfr"_ustr, u"\U0001D516"_ustr },
+        { u"ShortDownArrow"_ustr, u"\u2193"_ustr },
+        { u"ShortLeftArrow"_ustr, u"\u2190"_ustr },
+        { u"ShortRightArrow"_ustr, u"\u2192"_ustr },
+        { u"ShortUpArrow"_ustr, u"\u2191"_ustr },
+        { u"Sigma"_ustr, u"\u03A3"_ustr },
+        { u"SmallCircle"_ustr, u"\u2218"_ustr },
+        { u"Sopf"_ustr, u"\U0001D54A"_ustr },
+        { u"Sqrt"_ustr, u"\u221A"_ustr },
+        { u"Square"_ustr, u"\u25A1"_ustr },
+        { u"SquareIntersection"_ustr, u"\u2293"_ustr },
+        { u"SquareSubset"_ustr, u"\u228F"_ustr },
+        { u"SquareSubsetEqual"_ustr, u"\u2291"_ustr },
+        { u"SquareSuperset"_ustr, u"\u2290"_ustr },
+        { u"SquareSupersetEqual"_ustr, u"\u2292"_ustr },
+        { u"SquareUnion"_ustr, u"\u2294"_ustr },
+        { u"Sscr"_ustr, u"\U0001D4AE"_ustr },
+        { u"Star"_ustr, u"\u22C6"_ustr },
+        { u"Sub"_ustr, u"\u22D0"_ustr },
+        { u"Subset"_ustr, u"\u22D0"_ustr },
+        { u"SubsetEqual"_ustr, u"\u2286"_ustr },
+        { u"Succeeds"_ustr, u"\u227B"_ustr },
+        { u"SucceedsEqual"_ustr, u"\u2AB0"_ustr },
+        { u"SucceedsSlantEqual"_ustr, u"\u227D"_ustr },
+        { u"SucceedsTilde"_ustr, u"\u227F"_ustr },
+        { u"SuchThat"_ustr, u"\u220B"_ustr },
+        { u"Sum"_ustr, u"\u2211"_ustr },
+        { u"Sup"_ustr, u"\u22D1"_ustr },
+        { u"Superset"_ustr, u"\u2283"_ustr },
+        { u"SupersetEqual"_ustr, u"\u2287"_ustr },
+        { u"Supset"_ustr, u"\u22D1"_ustr },
+        { u"THORN"_ustr, u"\u00DE"_ustr },
+        { u"TRADE"_ustr, u"\u2122"_ustr },
+        { u"TSHcy"_ustr, u"\u040B"_ustr },
+        { u"TScy"_ustr, u"\u0426"_ustr },
+        { u"Tab"_ustr, u"\u0009"_ustr },
+        { u"Tau"_ustr, u"\u03A4"_ustr },
+        { u"Tcaron"_ustr, u"\u0164"_ustr },
+        { u"Tcedil"_ustr, u"\u0162"_ustr },
+        { u"Tcy"_ustr, u"\u0422"_ustr },
+        { u"Tfr"_ustr, u"\U0001D517"_ustr },
+        { u"Therefore"_ustr, u"\u2234"_ustr },
+        { u"Theta"_ustr, u"\u0398"_ustr },
+        { u"ThickSpace"_ustr, u"\u205F\u200A"_ustr },
+        { u"ThinSpace"_ustr, u"\u2009"_ustr },
+        { u"Tilde"_ustr, u"\u223C"_ustr },
+        { u"TildeEqual"_ustr, u"\u2243"_ustr },
+        { u"TildeFullEqual"_ustr, u"\u2245"_ustr },
+        { u"TildeTilde"_ustr, u"\u2248"_ustr },
+        { u"Topf"_ustr, u"\U0001D54B"_ustr },
+        { u"TripleDot"_ustr, u"\u20DB"_ustr },
+        { u"Tscr"_ustr, u"\U0001D4AF"_ustr },
+        { u"Tstrok"_ustr, u"\u0166"_ustr },
+        { u"Uacute"_ustr, u"\u00DA"_ustr },
+        { u"Uarr"_ustr, u"\u219F"_ustr },
+        { u"Uarrocir"_ustr, u"\u2949"_ustr },
+        { u"Ubrcy"_ustr, u"\u040E"_ustr },
+        { u"Ubreve"_ustr, u"\u016C"_ustr },
+        { u"Ucirc"_ustr, u"\u00DB"_ustr },
+        { u"Ucy"_ustr, u"\u0423"_ustr },
+        { u"Udblac"_ustr, u"\u0170"_ustr },
+        { u"Ufr"_ustr, u"\U0001D518"_ustr },
+        { u"Ugrave"_ustr, u"\u00D9"_ustr },
+        { u"Umacr"_ustr, u"\u016A"_ustr },
+        { u"UnderBar"_ustr, u"\u005F"_ustr },
+        { u"UnderBrace"_ustr, u"\u23DF"_ustr },
+        { u"UnderBracket"_ustr, u"\u23B5"_ustr },
+        { u"UnderParenthesis"_ustr, u"\u23DD"_ustr },
+        { u"Union"_ustr, u"\u22C3"_ustr },
+        { u"UnionPlus"_ustr, u"\u228E"_ustr },
+        { u"Uogon"_ustr, u"\u0172"_ustr },
+        { u"Uopf"_ustr, u"\U0001D54C"_ustr },
+        { u"UpArrow"_ustr, u"\u2191"_ustr },
+        { u"UpArrowBar"_ustr, u"\u2912"_ustr },
+        { u"UpArrowDownArrow"_ustr, u"\u21C5"_ustr },
+        { u"UpDownArrow"_ustr, u"\u2195"_ustr },
+        { u"UpEquilibrium"_ustr, u"\u296E"_ustr },
+        { u"UpTee"_ustr, u"\u22A5"_ustr },
+        { u"UpTeeArrow"_ustr, u"\u21A5"_ustr },
+        { u"Uparrow"_ustr, u"\u21D1"_ustr },
+        { u"Updownarrow"_ustr, u"\u21D5"_ustr },
+        { u"UpperLeftArrow"_ustr, u"\u2196"_ustr },
+        { u"UpperRightArrow"_ustr, u"\u2197"_ustr },
+        { u"Upsi"_ustr, u"\u03D2"_ustr },
+        { u"Upsilon"_ustr, u"\u03A5"_ustr },
+        { u"Uring"_ustr, u"\u016E"_ustr },
+        { u"Uscr"_ustr, u"\U0001D4B0"_ustr },
+        { u"Utilde"_ustr, u"\u0168"_ustr },
+        { u"Uuml"_ustr, u"\u00DC"_ustr },
+        { u"VDash"_ustr, u"\u22AB"_ustr },
+        { u"Vbar"_ustr, u"\u2AEB"_ustr },
+        { u"Vcy"_ustr, u"\u0412"_ustr },
+        { u"Vdash"_ustr, u"\u22A9"_ustr },
+        { u"Vdashl"_ustr, u"\u2AE6"_ustr },
+        { u"Vee"_ustr, u"\u22C1"_ustr },
+        { u"Verbar"_ustr, u"\u2016"_ustr },
+        { u"Vert"_ustr, u"\u2016"_ustr },
+        { u"VerticalBar"_ustr, u"\u2223"_ustr },
+        { u"VerticalLine"_ustr, u"\u007C"_ustr },
+        { u"VerticalSeparator"_ustr, u"\u2758"_ustr },
+        { u"VerticalTilde"_ustr, u"\u2240"_ustr },
+        { u"VeryThinSpace"_ustr, u"\u200A"_ustr },
+        { u"Vfr"_ustr, u"\U0001D519"_ustr },
+        { u"Vopf"_ustr, u"\U0001D54D"_ustr },
+        { u"Vscr"_ustr, u"\U0001D4B1"_ustr },
+        { u"Vvdash"_ustr, u"\u22AA"_ustr },
+        { u"Wcirc"_ustr, u"\u0174"_ustr },
+        { u"Wedge"_ustr, u"\u22C0"_ustr },
+        { u"Wfr"_ustr, u"\U0001D51A"_ustr },
+        { u"Wopf"_ustr, u"\U0001D54E"_ustr },
+        { u"Wscr"_ustr, u"\U0001D4B2"_ustr },
+        { u"Xfr"_ustr, u"\U0001D51B"_ustr },
+        { u"Xi"_ustr, u"\u039E"_ustr },
+        { u"Xopf"_ustr, u"\U0001D54F"_ustr },
+        { u"Xscr"_ustr, u"\U0001D4B3"_ustr },
+        { u"YAcy"_ustr, u"\u042F"_ustr },
+        { u"YIcy"_ustr, u"\u0407"_ustr },
+        { u"YUcy"_ustr, u"\u042E"_ustr },
+        { u"Yacute"_ustr, u"\u00DD"_ustr },
+        { u"Ycirc"_ustr, u"\u0176"_ustr },
+        { u"Ycy"_ustr, u"\u042B"_ustr },
+        { u"Yfr"_ustr, u"\U0001D51C"_ustr },
+        { u"Yopf"_ustr, u"\U0001D550"_ustr },
+        { u"Yscr"_ustr, u"\U0001D4B4"_ustr },
+        { u"Yuml"_ustr, u"\u0178"_ustr },
+        { u"ZHcy"_ustr, u"\u0416"_ustr },
+        { u"Zacute"_ustr, u"\u0179"_ustr },
+        { u"Zcaron"_ustr, u"\u017D"_ustr },
+        { u"Zcy"_ustr, u"\u0417"_ustr },
+        { u"Zdot"_ustr, u"\u017B"_ustr },
+        { u"ZeroWidthSpace"_ustr, u"\u200B"_ustr },
+        { u"Zeta"_ustr, u"\u0396"_ustr },
+        { u"Zfr"_ustr, u"\u2128"_ustr },
+        { u"Zopf"_ustr, u"\u2124"_ustr },
+        { u"Zscr"_ustr, u"\U0001D4B5"_ustr },
+        { u"aacute"_ustr, u"\u00E1"_ustr },
+        { u"abreve"_ustr, u"\u0103"_ustr },
+        { u"ac"_ustr, u"\u223E"_ustr },
+        { u"acE"_ustr, u"\u223E\u0333"_ustr },
+        { u"acd"_ustr, u"\u223F"_ustr },
+        { u"acirc"_ustr, u"\u00E2"_ustr },
+        { u"acute"_ustr, u"\u00B4"_ustr },
+        { u"acy"_ustr, u"\u0430"_ustr },
+        { u"aelig"_ustr, u"\u00E6"_ustr },
+        { u"af"_ustr, u"\u2061"_ustr },
+        { u"afr"_ustr, u"\U0001D51E"_ustr },
+        { u"agrave"_ustr, u"\u00E0"_ustr },
+        { u"alefsym"_ustr, u"\u2135"_ustr },
+        { u"aleph"_ustr, u"\u2135"_ustr },
+        { u"alpha"_ustr, u"\u03B1"_ustr },
+        { u"amacr"_ustr, u"\u0101"_ustr },
+        { u"amalg"_ustr, u"\u2A3F"_ustr },
+        { u"amp"_ustr, u"\u0026"_ustr },
+        { u"and"_ustr, u"\u2227"_ustr },
+        { u"andand"_ustr, u"\u2A55"_ustr },
+        { u"andd"_ustr, u"\u2A5C"_ustr },
+        { u"andslope"_ustr, u"\u2A58"_ustr },
+        { u"andv"_ustr, u"\u2A5A"_ustr },
+        { u"ang"_ustr, u"\u2220"_ustr },
+        { u"ange"_ustr, u"\u29A4"_ustr },
+        { u"angle"_ustr, u"\u2220"_ustr },
+        { u"angmsd"_ustr, u"\u2221"_ustr },
+        { u"angmsdaa"_ustr, u"\u29A8"_ustr },
+        { u"angmsdab"_ustr, u"\u29A9"_ustr },
+        { u"angmsdac"_ustr, u"\u29AA"_ustr },
+        { u"angmsdad"_ustr, u"\u29AB"_ustr },
+        { u"angmsdae"_ustr, u"\u29AC"_ustr },
+        { u"angmsdaf"_ustr, u"\u29AD"_ustr },
+        { u"angmsdag"_ustr, u"\u29AE"_ustr },
+        { u"angmsdah"_ustr, u"\u29AF"_ustr },
+        { u"angrt"_ustr, u"\u221F"_ustr },
+        { u"angrtvb"_ustr, u"\u22BE"_ustr },
+        { u"angrtvbd"_ustr, u"\u299D"_ustr },
+        { u"angsph"_ustr, u"\u2222"_ustr },
+        { u"angst"_ustr, u"\u00C5"_ustr },
+        { u"angzarr"_ustr, u"\u237C"_ustr },
+        { u"aogon"_ustr, u"\u0105"_ustr },
+        { u"aopf"_ustr, u"\U0001D552"_ustr },
+        { u"ap"_ustr, u"\u2248"_ustr },
+        { u"apE"_ustr, u"\u2A70"_ustr },
+        { u"apacir"_ustr, u"\u2A6F"_ustr },
+        { u"ape"_ustr, u"\u224A"_ustr },
+        { u"apid"_ustr, u"\u224B"_ustr },
+        { u"apos"_ustr, u"\u0027"_ustr },
+        { u"approx"_ustr, u"\u2248"_ustr },
+        { u"approxeq"_ustr, u"\u224A"_ustr },
+        { u"aring"_ustr, u"\u00E5"_ustr },
+        { u"ascr"_ustr, u"\U0001D4B6"_ustr },
+        { u"ast"_ustr, u"\u002A"_ustr },
+        { u"asymp"_ustr, u"\u2248"_ustr },
+        { u"asympeq"_ustr, u"\u224D"_ustr },
+        { u"atilde"_ustr, u"\u00E3"_ustr },
+        { u"auml"_ustr, u"\u00E4"_ustr },
+        { u"awconint"_ustr, u"\u2233"_ustr },
+        { u"awint"_ustr, u"\u2A11"_ustr },
+        { u"bNot"_ustr, u"\u2AED"_ustr },
+        { u"backcong"_ustr, u"\u224C"_ustr },
+        { u"backepsilon"_ustr, u"\u03F6"_ustr },
+        { u"backprime"_ustr, u"\u2035"_ustr },
+        { u"backsim"_ustr, u"\u223D"_ustr },
+        { u"backsimeq"_ustr, u"\u22CD"_ustr },
+        { u"barvee"_ustr, u"\u22BD"_ustr },
+        { u"barwed"_ustr, u"\u2305"_ustr },
+        { u"barwedge"_ustr, u"\u2305"_ustr },
+        { u"bbrk"_ustr, u"\u23B5"_ustr },
+        { u"bbrktbrk"_ustr, u"\u23B6"_ustr },
+        { u"bcong"_ustr, u"\u224C"_ustr },
+        { u"bcy"_ustr, u"\u0431"_ustr },
+        { u"bdquo"_ustr, u"\u201E"_ustr },
+        { u"becaus"_ustr, u"\u2235"_ustr },
+        { u"because"_ustr, u"\u2235"_ustr },
+        { u"bemptyv"_ustr, u"\u29B0"_ustr },
+        { u"bepsi"_ustr, u"\u03F6"_ustr },
+        { u"bernou"_ustr, u"\u212C"_ustr },
+        { u"beta"_ustr, u"\u03B2"_ustr },
+        { u"beth"_ustr, u"\u2136"_ustr },
+        { u"between"_ustr, u"\u226C"_ustr },
+        { u"bfr"_ustr, u"\U0001D51F"_ustr },
+        { u"bigcap"_ustr, u"\u22C2"_ustr },
+        { u"bigcirc"_ustr, u"\u25EF"_ustr },
+        { u"bigcup"_ustr, u"\u22C3"_ustr },
+        { u"bigodot"_ustr, u"\u2A00"_ustr },
+        { u"bigoplus"_ustr, u"\u2A01"_ustr },
+        { u"bigotimes"_ustr, u"\u2A02"_ustr },
+        { u"bigsqcup"_ustr, u"\u2A06"_ustr },
+        { u"bigstar"_ustr, u"\u2605"_ustr },
+        { u"bigtriangledown"_ustr, u"\u25BD"_ustr },
+        { u"bigtriangleup"_ustr, u"\u25B3"_ustr },
+        { u"biguplus"_ustr, u"\u2A04"_ustr },
+        { u"bigvee"_ustr, u"\u22C1"_ustr },
+        { u"bigwedge"_ustr, u"\u22C0"_ustr },
+        { u"bkarow"_ustr, u"\u290D"_ustr },
+        { u"blacklozenge"_ustr, u"\u29EB"_ustr },
+        { u"blacksquare"_ustr, u"\u25AA"_ustr },
+        { u"blacktriangle"_ustr, u"\u25B4"_ustr },
+        { u"blacktriangledown"_ustr, u"\u25BE"_ustr },
+        { u"blacktriangleleft"_ustr, u"\u25C2"_ustr },
+        { u"blacktriangleright"_ustr, u"\u25B8"_ustr },
+        { u"blank"_ustr, u"\u2423"_ustr },
+        { u"blk12"_ustr, u"\u2592"_ustr },
+        { u"blk14"_ustr, u"\u2591"_ustr },
+        { u"blk34"_ustr, u"\u2593"_ustr },
+        { u"block"_ustr, u"\u2588"_ustr },
+        { u"bne"_ustr, u"\u003D\u20E5"_ustr },
+        { u"bnequiv"_ustr, u"\u2261\u20E5"_ustr },
+        { u"bnot"_ustr, u"\u2310"_ustr },
+        { u"bopf"_ustr, u"\U0001D553"_ustr },
+        { u"bot"_ustr, u"\u22A5"_ustr },
+        { u"bottom"_ustr, u"\u22A5"_ustr },
+        { u"bowtie"_ustr, u"\u22C8"_ustr },
+        { u"boxDL"_ustr, u"\u2557"_ustr },
+        { u"boxDR"_ustr, u"\u2554"_ustr },
+        { u"boxDl"_ustr, u"\u2556"_ustr },
+        { u"boxDr"_ustr, u"\u2553"_ustr },
+        { u"boxH"_ustr, u"\u2550"_ustr },
+        { u"boxHD"_ustr, u"\u2566"_ustr },
+        { u"boxHU"_ustr, u"\u2569"_ustr },
+        { u"boxHd"_ustr, u"\u2564"_ustr },
+        { u"boxHu"_ustr, u"\u2567"_ustr },
+        { u"boxUL"_ustr, u"\u255D"_ustr },
+        { u"boxUR"_ustr, u"\u255A"_ustr },
+        { u"boxUl"_ustr, u"\u255C"_ustr },
+        { u"boxUr"_ustr, u"\u2559"_ustr },
+        { u"boxV"_ustr, u"\u2551"_ustr },
+        { u"boxVH"_ustr, u"\u256C"_ustr },
+        { u"boxVL"_ustr, u"\u2563"_ustr },
+        { u"boxVR"_ustr, u"\u2560"_ustr },
+        { u"boxVh"_ustr, u"\u256B"_ustr },
+        { u"boxVl"_ustr, u"\u2562"_ustr },
+        { u"boxVr"_ustr, u"\u255F"_ustr },
+        { u"boxbox"_ustr, u"\u29C9"_ustr },
+        { u"boxdL"_ustr, u"\u2555"_ustr },
+        { u"boxdR"_ustr, u"\u2552"_ustr },
+        { u"boxdl"_ustr, u"\u2510"_ustr },
+        { u"boxdr"_ustr, u"\u250C"_ustr },
+        { u"boxh"_ustr, u"\u2500"_ustr },
+        { u"boxhD"_ustr, u"\u2565"_ustr },
+        { u"boxhU"_ustr, u"\u2568"_ustr },
+        { u"boxhd"_ustr, u"\u252C"_ustr },
+        { u"boxhu"_ustr, u"\u2534"_ustr },
+        { u"boxminus"_ustr, u"\u229F"_ustr },
+        { u"boxplus"_ustr, u"\u229E"_ustr },
+        { u"boxtimes"_ustr, u"\u22A0"_ustr },
+        { u"boxuL"_ustr, u"\u255B"_ustr },
+        { u"boxuR"_ustr, u"\u2558"_ustr },
+        { u"boxul"_ustr, u"\u2518"_ustr },
+        { u"boxur"_ustr, u"\u2514"_ustr },
+        { u"boxv"_ustr, u"\u2502"_ustr },
+        { u"boxvH"_ustr, u"\u256A"_ustr },
+        { u"boxvL"_ustr, u"\u2561"_ustr },
+        { u"boxvR"_ustr, u"\u255E"_ustr },
+        { u"boxvh"_ustr, u"\u253C"_ustr },
+        { u"boxvl"_ustr, u"\u2524"_ustr },
+        { u"boxvr"_ustr, u"\u251C"_ustr },
+        { u"bprime"_ustr, u"\u2035"_ustr },
+        { u"breve"_ustr, u"\u02D8"_ustr },
+        { u"brvbar"_ustr, u"\u00A6"_ustr },
+        { u"bscr"_ustr, u"\U0001D4B7"_ustr },
+        { u"bsemi"_ustr, u"\u204F"_ustr },
+        { u"bsim"_ustr, u"\u223D"_ustr },
+        { u"bsime"_ustr, u"\u22CD"_ustr },
+        { u"bsol"_ustr, u"\u005C"_ustr },
+        { u"bsolb"_ustr, u"\u29C5"_ustr },
+        { u"bsolhsub"_ustr, u"\u27C8"_ustr },
+        { u"bull"_ustr, u"\u2022"_ustr },
+        { u"bullet"_ustr, u"\u2022"_ustr },
+        { u"bump"_ustr, u"\u224E"_ustr },
+        { u"bumpE"_ustr, u"\u2AAE"_ustr },
+        { u"bumpe"_ustr, u"\u224F"_ustr },
+        { u"bumpeq"_ustr, u"\u224F"_ustr },
+        { u"cacute"_ustr, u"\u0107"_ustr },
+        { u"cap"_ustr, u"\u2229"_ustr },
+        { u"capand"_ustr, u"\u2A44"_ustr },
+        { u"capbrcup"_ustr, u"\u2A49"_ustr },
+        { u"capcap"_ustr, u"\u2A4B"_ustr },
+        { u"capcup"_ustr, u"\u2A47"_ustr },
+        { u"capdot"_ustr, u"\u2A40"_ustr },
+        { u"caps"_ustr, u"\u2229\uFE00"_ustr },
+        { u"caret"_ustr, u"\u2041"_ustr },
+        { u"caron"_ustr, u"\u02C7"_ustr },
+        { u"ccaps"_ustr, u"\u2A4D"_ustr },
+        { u"ccaron"_ustr, u"\u010D"_ustr },
+        { u"ccedil"_ustr, u"\u00E7"_ustr },
+        { u"ccirc"_ustr, u"\u0109"_ustr },
+        { u"ccups"_ustr, u"\u2A4C"_ustr },
+        { u"ccupssm"_ustr, u"\u2A50"_ustr },
+        { u"cdot"_ustr, u"\u010B"_ustr },
+        { u"cedil"_ustr, u"\u00B8"_ustr },
+        { u"cemptyv"_ustr, u"\u29B2"_ustr },
+        { u"cent"_ustr, u"\u00A2"_ustr },
+        { u"centerdot"_ustr, u"\u00B7"_ustr },
+        { u"cfr"_ustr, u"\U0001D520"_ustr },
+        { u"chcy"_ustr, u"\u0447"_ustr },
+        { u"check"_ustr, u"\u2713"_ustr },
+        { u"checkmark"_ustr, u"\u2713"_ustr },
+        { u"chi"_ustr, u"\u03C7"_ustr },
+        { u"cir"_ustr, u"\u25CB"_ustr },
+        { u"cirE"_ustr, u"\u29C3"_ustr },
+        { u"circ"_ustr, u"\u02C6"_ustr },
+        { u"circeq"_ustr, u"\u2257"_ustr },
+        { u"circlearrowleft"_ustr, u"\u21BA"_ustr },
+        { u"circlearrowright"_ustr, u"\u21BB"_ustr },
+        { u"circledR"_ustr, u"\u00AE"_ustr },
+        { u"circledS"_ustr, u"\u24C8"_ustr },
+        { u"circledast"_ustr, u"\u229B"_ustr },
+        { u"circledcirc"_ustr, u"\u229A"_ustr },
+        { u"circleddash"_ustr, u"\u229D"_ustr },
+        { u"cire"_ustr, u"\u2257"_ustr },
+        { u"cirfnint"_ustr, u"\u2A10"_ustr },
+        { u"cirmid"_ustr, u"\u2AEF"_ustr },
+        { u"cirscir"_ustr, u"\u29C2"_ustr },
+        { u"clubs"_ustr, u"\u2663"_ustr },
+        { u"clubsuit"_ustr, u"\u2663"_ustr },
+        { u"colon"_ustr, u"\u003A"_ustr },
+        { u"colone"_ustr, u"\u2254"_ustr },
+        { u"coloneq"_ustr, u"\u2254"_ustr },
+        { u"comma"_ustr, u"\u002C"_ustr },
+        { u"commat"_ustr, u"\u0040"_ustr },
+        { u"comp"_ustr, u"\u2201"_ustr },
+        { u"compfn"_ustr, u"\u2218"_ustr },
+        { u"complement"_ustr, u"\u2201"_ustr },
+        { u"complexes"_ustr, u"\u2102"_ustr },
+        { u"cong"_ustr, u"\u2245"_ustr },
+        { u"congdot"_ustr, u"\u2A6D"_ustr },
+        { u"conint"_ustr, u"\u222E"_ustr },
+        { u"copf"_ustr, u"\U0001D554"_ustr },
+        { u"coprod"_ustr, u"\u2210"_ustr },
+        { u"copy"_ustr, u"\u00A9"_ustr },
+        { u"copysr"_ustr, u"\u2117"_ustr },
+        { u"crarr"_ustr, u"\u21B5"_ustr },
+        { u"cross"_ustr, u"\u2717"_ustr },
+        { u"cscr"_ustr, u"\U0001D4B8"_ustr },
+        { u"csub"_ustr, u"\u2ACF"_ustr },
+        { u"csube"_ustr, u"\u2AD1"_ustr },
+        { u"csup"_ustr, u"\u2AD0"_ustr },
+        { u"csupe"_ustr, u"\u2AD2"_ustr },
+        { u"ctdot"_ustr, u"\u22EF"_ustr },
+        { u"cudarrl"_ustr, u"\u2938"_ustr },
+        { u"cudarrr"_ustr, u"\u2935"_ustr },
+        { u"cuepr"_ustr, u"\u22DE"_ustr },
+        { u"cuesc"_ustr, u"\u22DF"_ustr },
+        { u"cularr"_ustr, u"\u21B6"_ustr },
+        { u"cularrp"_ustr, u"\u293D"_ustr },
+        { u"cup"_ustr, u"\u222A"_ustr },
+        { u"cupbrcap"_ustr, u"\u2A48"_ustr },
+        { u"cupcap"_ustr, u"\u2A46"_ustr },
+        { u"cupcup"_ustr, u"\u2A4A"_ustr },
+        { u"cupdot"_ustr, u"\u228D"_ustr },
+        { u"cupor"_ustr, u"\u2A45"_ustr },
+        { u"cups"_ustr, u"\u222A\uFE00"_ustr },
+        { u"curarr"_ustr, u"\u21B7"_ustr },
+        { u"curarrm"_ustr, u"\u293C"_ustr },
+        { u"curlyeqprec"_ustr, u"\u22DE"_ustr },
+        { u"curlyeqsucc"_ustr, u"\u22DF"_ustr },
+        { u"curlyvee"_ustr, u"\u22CE"_ustr },
+        { u"curlywedge"_ustr, u"\u22CF"_ustr },
+        { u"curren"_ustr, u"\u00A4"_ustr },
+        { u"curvearrowleft"_ustr, u"\u21B6"_ustr },
+        { u"curvearrowright"_ustr, u"\u21B7"_ustr },
+        { u"cuvee"_ustr, u"\u22CE"_ustr },
+        { u"cuwed"_ustr, u"\u22CF"_ustr },
+        { u"cwconint"_ustr, u"\u2232"_ustr },
+        { u"cwint"_ustr, u"\u2231"_ustr },
+        { u"cylcty"_ustr, u"\u232D"_ustr },
+        { u"dArr"_ustr, u"\u21D3"_ustr },
+        { u"dHar"_ustr, u"\u2965"_ustr },
+        { u"dagger"_ustr, u"\u2020"_ustr },
+        { u"daleth"_ustr, u"\u2138"_ustr },
+        { u"darr"_ustr, u"\u2193"_ustr },
+        { u"dash"_ustr, u"\u2010"_ustr },
+        { u"dashv"_ustr, u"\u22A3"_ustr },
+        { u"dbkarow"_ustr, u"\u290F"_ustr },
+        { u"dblac"_ustr, u"\u02DD"_ustr },
+        { u"dcaron"_ustr, u"\u010F"_ustr },
+        { u"dcy"_ustr, u"\u0434"_ustr },
+        { u"dd"_ustr, u"\u2146"_ustr },
+        { u"ddagger"_ustr, u"\u2021"_ustr },
+        { u"ddarr"_ustr, u"\u21CA"_ustr },
+        { u"ddotseq"_ustr, u"\u2A77"_ustr },
+        { u"deg"_ustr, u"\u00B0"_ustr },
+        { u"delta"_ustr, u"\u03B4"_ustr },
+        { u"demptyv"_ustr, u"\u29B1"_ustr },
+        { u"dfisht"_ustr, u"\u297F"_ustr },
+        { u"dfr"_ustr, u"\U0001D521"_ustr },
+        { u"dharl"_ustr, u"\u21C3"_ustr },
+        { u"dharr"_ustr, u"\u21C2"_ustr },
+        { u"diam"_ustr, u"\u22C4"_ustr },
+        { u"diamond"_ustr, u"\u22C4"_ustr },
+        { u"diamondsuit"_ustr, u"\u2666"_ustr },
+        { u"diams"_ustr, u"\u2666"_ustr },
+        { u"die"_ustr, u"\u00A8"_ustr },
+        { u"digamma"_ustr, u"\u03DD"_ustr },
+        { u"disin"_ustr, u"\u22F2"_ustr },
+        { u"div"_ustr, u"\u00F7"_ustr },
+        { u"divide"_ustr, u"\u00F7"_ustr },
+        { u"divideontimes"_ustr, u"\u22C7"_ustr },
+        { u"divonx"_ustr, u"\u22C7"_ustr },
+        { u"djcy"_ustr, u"\u0452"_ustr },
+        { u"dlcorn"_ustr, u"\u231E"_ustr },
+        { u"dlcrop"_ustr, u"\u230D"_ustr },
+        { u"dollar"_ustr, u"\u0024"_ustr },
+        { u"dopf"_ustr, u"\U0001D555"_ustr },
+        { u"dot"_ustr, u"\u02D9"_ustr },
+        { u"doteq"_ustr, u"\u2250"_ustr },
+        { u"doteqdot"_ustr, u"\u2251"_ustr },
+        { u"dotminus"_ustr, u"\u2238"_ustr },
+        { u"dotplus"_ustr, u"\u2214"_ustr },
+        { u"dotsquare"_ustr, u"\u22A1"_ustr },
+        { u"doublebarwedge"_ustr, u"\u2306"_ustr },
+        { u"downarrow"_ustr, u"\u2193"_ustr },
+        { u"downdownarrows"_ustr, u"\u21CA"_ustr },
+        { u"downharpoonleft"_ustr, u"\u21C3"_ustr },
+        { u"downharpoonright"_ustr, u"\u21C2"_ustr },
+        { u"drbkarow"_ustr, u"\u2910"_ustr },
+        { u"drcorn"_ustr, u"\u231F"_ustr },
+        { u"drcrop"_ustr, u"\u230C"_ustr },
+        { u"dscr"_ustr, u"\U0001D4B9"_ustr },
+        { u"dscy"_ustr, u"\u0455"_ustr },
+        { u"dsol"_ustr, u"\u29F6"_ustr },
+        { u"dstrok"_ustr, u"\u0111"_ustr },
+        { u"dtdot"_ustr, u"\u22F1"_ustr },
+        { u"dtri"_ustr, u"\u25BF"_ustr },
+        { u"dtrif"_ustr, u"\u25BE"_ustr },
+        { u"duarr"_ustr, u"\u21F5"_ustr },
+        { u"duhar"_ustr, u"\u296F"_ustr },
+        { u"dwangle"_ustr, u"\u29A6"_ustr },
+        { u"dzcy"_ustr, u"\u045F"_ustr },
+        { u"dzigrarr"_ustr, u"\u27FF"_ustr },
+        { u"eDDot"_ustr, u"\u2A77"_ustr },
+        { u"eDot"_ustr, u"\u2251"_ustr },
+        { u"eacute"_ustr, u"\u00E9"_ustr },
+        { u"easter"_ustr, u"\u2A6E"_ustr },
+        { u"ecaron"_ustr, u"\u011B"_ustr },
+        { u"ecir"_ustr, u"\u2256"_ustr },
+        { u"ecirc"_ustr, u"\u00EA"_ustr },
+        { u"ecolon"_ustr, u"\u2255"_ustr },
+        { u"ecy"_ustr, u"\u044D"_ustr },
+        { u"edot"_ustr, u"\u0117"_ustr },
+        { u"ee"_ustr, u"\u2147"_ustr },
+        { u"efDot"_ustr, u"\u2252"_ustr },
+        { u"efr"_ustr, u"\U0001D522"_ustr },
+        { u"eg"_ustr, u"\u2A9A"_ustr },
+        { u"egrave"_ustr, u"\u00E8"_ustr },
+        { u"egs"_ustr, u"\u2A96"_ustr },
+        { u"egsdot"_ustr, u"\u2A98"_ustr },
+        { u"el"_ustr, u"\u2A99"_ustr },
+        { u"elinters"_ustr, u"\u23E7"_ustr },
+        { u"ell"_ustr, u"\u2113"_ustr },
+        { u"els"_ustr, u"\u2A95"_ustr },
+        { u"elsdot"_ustr, u"\u2A97"_ustr },
+        { u"emacr"_ustr, u"\u0113"_ustr },
+        { u"empty"_ustr, u"\u2205"_ustr },
+        { u"emptyset"_ustr, u"\u2205"_ustr },
+        { u"emptyv"_ustr, u"\u2205"_ustr },
+        { u"emsp"_ustr, u"\u2003"_ustr },
+        { u"emsp13"_ustr, u"\u2004"_ustr },
+        { u"emsp14"_ustr, u"\u2005"_ustr },
+        { u"eng"_ustr, u"\u014B"_ustr },
+        { u"ensp"_ustr, u"\u2002"_ustr },
+        { u"eogon"_ustr, u"\u0119"_ustr },
+        { u"eopf"_ustr, u"\U0001D556"_ustr },
+        { u"epar"_ustr, u"\u22D5"_ustr },
+        { u"eparsl"_ustr, u"\u29E3"_ustr },
+        { u"eplus"_ustr, u"\u2A71"_ustr },
+        { u"epsi"_ustr, u"\u03B5"_ustr },
+        { u"epsilon"_ustr, u"\u03B5"_ustr },
+        { u"epsiv"_ustr, u"\u03F5"_ustr },
+        { u"eqcirc"_ustr, u"\u2256"_ustr },
+        { u"eqcolon"_ustr, u"\u2255"_ustr },
+        { u"eqsim"_ustr, u"\u2242"_ustr },
+        { u"eqslantgtr"_ustr, u"\u2A96"_ustr },
+        { u"eqslantless"_ustr, u"\u2A95"_ustr },
+        { u"equals"_ustr, u"\u003D"_ustr },
+        { u"equest"_ustr, u"\u225F"_ustr },
+        { u"equiv"_ustr, u"\u2261"_ustr },
+        { u"equivDD"_ustr, u"\u2A78"_ustr },
+        { u"eqvparsl"_ustr, u"\u29E5"_ustr },
+        { u"erDot"_ustr, u"\u2253"_ustr },
+        { u"erarr"_ustr, u"\u2971"_ustr },
+        { u"escr"_ustr, u"\u212F"_ustr },
+        { u"esdot"_ustr, u"\u2250"_ustr },
+        { u"esim"_ustr, u"\u2242"_ustr },
+        { u"eta"_ustr, u"\u03B7"_ustr },
+        { u"eth"_ustr, u"\u00F0"_ustr },
+        { u"euml"_ustr, u"\u00EB"_ustr },
+        { u"euro"_ustr, u"\u20AC"_ustr },
+        { u"excl"_ustr, u"\u0021"_ustr },
+        { u"exist"_ustr, u"\u2203"_ustr },
+        { u"expectation"_ustr, u"\u2130"_ustr },
+        { u"exponentiale"_ustr, u"\u2147"_ustr },
+        { u"fallingdotseq"_ustr, u"\u2252"_ustr },
+        { u"fcy"_ustr, u"\u0444"_ustr },
+        { u"female"_ustr, u"\u2640"_ustr },
+        { u"ffilig"_ustr, u"\uFB03"_ustr },
+        { u"fflig"_ustr, u"\uFB00"_ustr },
+        { u"ffllig"_ustr, u"\uFB04"_ustr },
+        { u"ffr"_ustr, u"\U0001D523"_ustr },
+        { u"filig"_ustr, u"\uFB01"_ustr },
+        { u"fjlig"_ustr, u"\u0066\u006A"_ustr },
+        { u"flat"_ustr, u"\u266D"_ustr },
+        { u"fllig"_ustr, u"\uFB02"_ustr },
+        { u"fltns"_ustr, u"\u25B1"_ustr },
+        { u"fnof"_ustr, u"\u0192"_ustr },
+        { u"fopf"_ustr, u"\U0001D557"_ustr },
+        { u"forall"_ustr, u"\u2200"_ustr },
+        { u"fork"_ustr, u"\u22D4"_ustr },
+        { u"forkv"_ustr, u"\u2AD9"_ustr },
+        { u"fpartint"_ustr, u"\u2A0D"_ustr },
+        { u"frac12"_ustr, u"\u00BD"_ustr },
+        { u"frac13"_ustr, u"\u2153"_ustr },
+        { u"frac14"_ustr, u"\u00BC"_ustr },
+        { u"frac15"_ustr, u"\u2155"_ustr },
+        { u"frac16"_ustr, u"\u2159"_ustr },
+        { u"frac18"_ustr, u"\u215B"_ustr },
+        { u"frac23"_ustr, u"\u2154"_ustr },
+        { u"frac25"_ustr, u"\u2156"_ustr },
+        { u"frac34"_ustr, u"\u00BE"_ustr },
+        { u"frac35"_ustr, u"\u2157"_ustr },
+        { u"frac38"_ustr, u"\u215C"_ustr },
+        { u"frac45"_ustr, u"\u2158"_ustr },
+        { u"frac56"_ustr, u"\u215A"_ustr },
+        { u"frac58"_ustr, u"\u215D"_ustr },
+        { u"frac78"_ustr, u"\u215E"_ustr },
+        { u"frasl"_ustr, u"\u2044"_ustr },
+        { u"frown"_ustr, u"\u2322"_ustr },
+        { u"fscr"_ustr, u"\U0001D4BB"_ustr },
+        { u"gE"_ustr, u"\u2267"_ustr },
+        { u"gEl"_ustr, u"\u2A8C"_ustr },
+        { u"gacute"_ustr, u"\u01F5"_ustr },
+        { u"gamma"_ustr, u"\u03B3"_ustr },
+        { u"gammad"_ustr, u"\u03DD"_ustr },
+        { u"gap"_ustr, u"\u2A86"_ustr },
+        { u"gbreve"_ustr, u"\u011F"_ustr },
+        { u"gcirc"_ustr, u"\u011D"_ustr },
+        { u"gcy"_ustr, u"\u0433"_ustr },
+        { u"gdot"_ustr, u"\u0121"_ustr },
+        { u"ge"_ustr, u"\u2265"_ustr },
+        { u"gel"_ustr, u"\u22DB"_ustr },
+        { u"geq"_ustr, u"\u2265"_ustr },
+        { u"geqq"_ustr, u"\u2267"_ustr },
+        { u"geqslant"_ustr, u"\u2A7E"_ustr },
+        { u"ges"_ustr, u"\u2A7E"_ustr },
+        { u"gescc"_ustr, u"\u2AA9"_ustr },
+        { u"gesdot"_ustr, u"\u2A80"_ustr },
+        { u"gesdoto"_ustr, u"\u2A82"_ustr },
+        { u"gesdotol"_ustr, u"\u2A84"_ustr },
+        { u"gesl"_ustr, u"\u22DB\uFE00"_ustr },
+        { u"gesles"_ustr, u"\u2A94"_ustr },
+        { u"gfr"_ustr, u"\U0001D524"_ustr },
+        { u"gg"_ustr, u"\u226B"_ustr },
+        { u"ggg"_ustr, u"\u22D9"_ustr },
+        { u"gimel"_ustr, u"\u2137"_ustr },
+        { u"gjcy"_ustr, u"\u0453"_ustr },
+        { u"gl"_ustr, u"\u2277"_ustr },
+        { u"glE"_ustr, u"\u2A92"_ustr },
+        { u"gla"_ustr, u"\u2AA5"_ustr },
+        { u"glj"_ustr, u"\u2AA4"_ustr },
+        { u"gnE"_ustr, u"\u2269"_ustr },
+        { u"gnap"_ustr, u"\u2A8A"_ustr },
+        { u"gnapprox"_ustr, u"\u2A8A"_ustr },
+        { u"gne"_ustr, u"\u2A88"_ustr },
+        { u"gneq"_ustr, u"\u2A88"_ustr },
+        { u"gneqq"_ustr, u"\u2269"_ustr },
+        { u"gnsim"_ustr, u"\u22E7"_ustr },
+        { u"gopf"_ustr, u"\U0001D558"_ustr },
+        { u"grave"_ustr, u"\u0060"_ustr },
+        { u"gscr"_ustr, u"\u210A"_ustr },
+        { u"gsim"_ustr, u"\u2273"_ustr },
+        { u"gsime"_ustr, u"\u2A8E"_ustr },
+        { u"gsiml"_ustr, u"\u2A90"_ustr },
+        { u"gt"_ustr, u"\u003E"_ustr },
+        { u"gtcc"_ustr, u"\u2AA7"_ustr },
+        { u"gtcir"_ustr, u"\u2A7A"_ustr },
+        { u"gtdot"_ustr, u"\u22D7"_ustr },
+        { u"gtlPar"_ustr, u"\u2995"_ustr },
+        { u"gtquest"_ustr, u"\u2A7C"_ustr },
+        { u"gtrapprox"_ustr, u"\u2A86"_ustr },
+        { u"gtrarr"_ustr, u"\u2978"_ustr },
+        { u"gtrdot"_ustr, u"\u22D7"_ustr },
+        { u"gtreqless"_ustr, u"\u22DB"_ustr },
+        { u"gtreqqless"_ustr, u"\u2A8C"_ustr },
+        { u"gtrless"_ustr, u"\u2277"_ustr },
+        { u"gtrsim"_ustr, u"\u2273"_ustr },
+        { u"gvertneqq"_ustr, u"\u2269\uFE00"_ustr },
+        { u"gvnE"_ustr, u"\u2269\uFE00"_ustr },
+        { u"hArr"_ustr, u"\u21D4"_ustr },
+        { u"hairsp"_ustr, u"\u200A"_ustr },
+        { u"half"_ustr, u"\u00BD"_ustr },
+        { u"hamilt"_ustr, u"\u210B"_ustr },
+        { u"hardcy"_ustr, u"\u044A"_ustr },
+        { u"harr"_ustr, u"\u2194"_ustr },
+        { u"harrcir"_ustr, u"\u2948"_ustr },
+        { u"harrw"_ustr, u"\u21AD"_ustr },
+        { u"hbar"_ustr, u"\u210F"_ustr },
+        { u"hcirc"_ustr, u"\u0125"_ustr },
+        { u"hearts"_ustr, u"\u2665"_ustr },
+        { u"heartsuit"_ustr, u"\u2665"_ustr },
+        { u"hellip"_ustr, u"\u2026"_ustr },
+        { u"hercon"_ustr, u"\u22B9"_ustr },
+        { u"hfr"_ustr, u"\U0001D525"_ustr },
+        { u"hksearow"_ustr, u"\u2925"_ustr },
+        { u"hkswarow"_ustr, u"\u2926"_ustr },
+        { u"hoarr"_ustr, u"\u21FF"_ustr },
+        { u"homtht"_ustr, u"\u223B"_ustr },
+        { u"hookleftarrow"_ustr, u"\u21A9"_ustr },
+        { u"hookrightarrow"_ustr, u"\u21AA"_ustr },
+        { u"hopf"_ustr, u"\U0001D559"_ustr },
+        { u"horbar"_ustr, u"\u2015"_ustr },
+        { u"hscr"_ustr, u"\U0001D4BD"_ustr },
+        { u"hslash"_ustr, u"\u210F"_ustr },
+        { u"hstrok"_ustr, u"\u0127"_ustr },
+        { u"hybull"_ustr, u"\u2043"_ustr },
+        { u"hyphen"_ustr, u"\u2010"_ustr },
+        { u"iacute"_ustr, u"\u00ED"_ustr },
+        { u"ic"_ustr, u"\u2063"_ustr },
+        { u"icirc"_ustr, u"\u00EE"_ustr },
+        { u"icy"_ustr, u"\u0438"_ustr },
+        { u"iecy"_ustr, u"\u0435"_ustr },
+        { u"iexcl"_ustr, u"\u00A1"_ustr },
+        { u"iff"_ustr, u"\u21D4"_ustr },
+        { u"ifr"_ustr, u"\U0001D526"_ustr },
+        { u"igrave"_ustr, u"\u00EC"_ustr },
+        { u"ii"_ustr, u"\u2148"_ustr },
+        { u"iiiint"_ustr, u"\u2A0C"_ustr },
+        { u"iiint"_ustr, u"\u222D"_ustr },
+        { u"iinfin"_ustr, u"\u29DC"_ustr },
+        { u"iiota"_ustr, u"\u2129"_ustr },
+        { u"ijlig"_ustr, u"\u0133"_ustr },
+        { u"imacr"_ustr, u"\u012B"_ustr },
+        { u"image"_ustr, u"\u2111"_ustr },
+        { u"imagline"_ustr, u"\u2110"_ustr },
+        { u"imagpart"_ustr, u"\u2111"_ustr },
+        { u"imath"_ustr, u"\u0131"_ustr },
+        { u"imof"_ustr, u"\u22B7"_ustr },
+        { u"imped"_ustr, u"\u01B5"_ustr },
+        { u"in"_ustr, u"\u2208"_ustr },
+        { u"incare"_ustr, u"\u2105"_ustr },
+        { u"infin"_ustr, u"\u221E"_ustr },
+        { u"infintie"_ustr, u"\u29DD"_ustr },
+        { u"inodot"_ustr, u"\u0131"_ustr },
+        { u"int"_ustr, u"\u222B"_ustr },
+        { u"intcal"_ustr, u"\u22BA"_ustr },
+        { u"integers"_ustr, u"\u2124"_ustr },
+        { u"intercal"_ustr, u"\u22BA"_ustr },
+        { u"intlarhk"_ustr, u"\u2A17"_ustr },
+        { u"intprod"_ustr, u"\u2A3C"_ustr },
+        { u"iocy"_ustr, u"\u0451"_ustr },
+        { u"iogon"_ustr, u"\u012F"_ustr },
+        { u"iopf"_ustr, u"\U0001D55A"_ustr },
+        { u"iota"_ustr, u"\u03B9"_ustr },
+        { u"iprod"_ustr, u"\u2A3C"_ustr },
+        { u"iquest"_ustr, u"\u00BF"_ustr },
+        { u"iscr"_ustr, u"\U0001D4BE"_ustr },
+        { u"isin"_ustr, u"\u2208"_ustr },
+        { u"isinE"_ustr, u"\u22F9"_ustr },
+        { u"isindot"_ustr, u"\u22F5"_ustr },
+        { u"isins"_ustr, u"\u22F4"_ustr },
+        { u"isinsv"_ustr, u"\u22F3"_ustr },
+        { u"isinv"_ustr, u"\u2208"_ustr },
+        { u"it"_ustr, u"\u2062"_ustr },
+        { u"itilde"_ustr, u"\u0129"_ustr },
+        { u"iukcy"_ustr, u"\u0456"_ustr },
+        { u"iuml"_ustr, u"\u00EF"_ustr },
+        { u"jcirc"_ustr, u"\u0135"_ustr },
+        { u"jcy"_ustr, u"\u0439"_ustr },
+        { u"jfr"_ustr, u"\U0001D527"_ustr },
+        { u"jmath"_ustr, u"\u0237"_ustr },
+        { u"jopf"_ustr, u"\U0001D55B"_ustr },
+        { u"jscr"_ustr, u"\U0001D4BF"_ustr },
+        { u"jsercy"_ustr, u"\u0458"_ustr },
+        { u"jukcy"_ustr, u"\u0454"_ustr },
+        { u"kappa"_ustr, u"\u03BA"_ustr },
+        { u"kappav"_ustr, u"\u03F0"_ustr },
+        { u"kcedil"_ustr, u"\u0137"_ustr },
+        { u"kcy"_ustr, u"\u043A"_ustr },
+        { u"kfr"_ustr, u"\U0001D528"_ustr },
+        { u"kgreen"_ustr, u"\u0138"_ustr },
+        { u"khcy"_ustr, u"\u0445"_ustr },
+        { u"kjcy"_ustr, u"\u045C"_ustr },
+        { u"kopf"_ustr, u"\U0001D55C"_ustr },
+        { u"kscr"_ustr, u"\U0001D4C0"_ustr },
+        { u"lAarr"_ustr, u"\u21DA"_ustr },
+        { u"lArr"_ustr, u"\u21D0"_ustr },
+        { u"lAtail"_ustr, u"\u291B"_ustr },
+        { u"lBarr"_ustr, u"\u290E"_ustr },
+        { u"lE"_ustr, u"\u2266"_ustr },
+        { u"lEg"_ustr, u"\u2A8B"_ustr },
+        { u"lHar"_ustr, u"\u2962"_ustr },
+        { u"lacute"_ustr, u"\u013A"_ustr },
+        { u"laemptyv"_ustr, u"\u29B4"_ustr },
+        { u"lagran"_ustr, u"\u2112"_ustr },
+        { u"lambda"_ustr, u"\u03BB"_ustr },
+        { u"lang"_ustr, u"\u27E8"_ustr },
+        { u"langd"_ustr, u"\u2991"_ustr },
+        { u"langle"_ustr, u"\u27E8"_ustr },
+        { u"lap"_ustr, u"\u2A85"_ustr },
+        { u"laquo"_ustr, u"\u00AB"_ustr },
+        { u"larr"_ustr, u"\u2190"_ustr },
+        { u"larrb"_ustr, u"\u21E4"_ustr },
+        { u"larrbfs"_ustr, u"\u291F"_ustr },
+        { u"larrfs"_ustr, u"\u291D"_ustr },
+        { u"larrhk"_ustr, u"\u21A9"_ustr },
+        { u"larrlp"_ustr, u"\u21AB"_ustr },
+        { u"larrpl"_ustr, u"\u2939"_ustr },
+        { u"larrsim"_ustr, u"\u2973"_ustr },
+        { u"larrtl"_ustr, u"\u21A2"_ustr },
+        { u"lat"_ustr, u"\u2AAB"_ustr },
+        { u"latail"_ustr, u"\u2919"_ustr },
+        { u"late"_ustr, u"\u2AAD"_ustr },
+        { u"lates"_ustr, u"\u2AAD\uFE00"_ustr },
+        { u"lbarr"_ustr, u"\u290C"_ustr },
+        { u"lbbrk"_ustr, u"\u2772"_ustr },
+        { u"lbrace"_ustr, u"\u007B"_ustr },
+        { u"lbrack"_ustr, u"\u005B"_ustr },
+        { u"lbrke"_ustr, u"\u298B"_ustr },
+        { u"lbrksld"_ustr, u"\u298F"_ustr },
+        { u"lbrkslu"_ustr, u"\u298D"_ustr },
+        { u"lcaron"_ustr, u"\u013E"_ustr },
+        { u"lcedil"_ustr, u"\u013C"_ustr },
+        { u"lceil"_ustr, u"\u2308"_ustr },
+        { u"lcub"_ustr, u"\u007B"_ustr },
+        { u"lcy"_ustr, u"\u043B"_ustr },
+        { u"ldca"_ustr, u"\u2936"_ustr },
+        { u"ldquo"_ustr, u"\u201C"_ustr },
+        { u"ldquor"_ustr, u"\u201E"_ustr },
+        { u"ldrdhar"_ustr, u"\u2967"_ustr },
+        { u"ldrushar"_ustr, u"\u294B"_ustr },
+        { u"ldsh"_ustr, u"\u21B2"_ustr },
+        { u"le"_ustr, u"\u2264"_ustr },
+        { u"leftarrow"_ustr, u"\u2190"_ustr },
+        { u"leftarrowtail"_ustr, u"\u21A2"_ustr },
+        { u"leftharpoondown"_ustr, u"\u21BD"_ustr },
+        { u"leftharpoonup"_ustr, u"\u21BC"_ustr },
+        { u"leftleftarrows"_ustr, u"\u21C7"_ustr },
+        { u"leftrightarrow"_ustr, u"\u2194"_ustr },
+        { u"leftrightarrows"_ustr, u"\u21C6"_ustr },
+        { u"leftrightharpoons"_ustr, u"\u21CB"_ustr },
+        { u"leftrightsquigarrow"_ustr, u"\u21AD"_ustr },
+        { u"leftthreetimes"_ustr, u"\u22CB"_ustr },
+        { u"leg"_ustr, u"\u22DA"_ustr },
+        { u"leq"_ustr, u"\u2264"_ustr },
+        { u"leqq"_ustr, u"\u2266"_ustr },
+        { u"leqslant"_ustr, u"\u2A7D"_ustr },
+        { u"les"_ustr, u"\u2A7D"_ustr },
+        { u"lescc"_ustr, u"\u2AA8"_ustr },
+        { u"lesdot"_ustr, u"\u2A7F"_ustr },
+        { u"lesdoto"_ustr, u"\u2A81"_ustr },
+        { u"lesdotor"_ustr, u"\u2A83"_ustr },
+        { u"lesg"_ustr, u"\u22DA\uFE00"_ustr },
+        { u"lesges"_ustr, u"\u2A93"_ustr },
+        { u"lessapprox"_ustr, u"\u2A85"_ustr },
+        { u"lessdot"_ustr, u"\u22D6"_ustr },
+        { u"lesseqgtr"_ustr, u"\u22DA"_ustr },
+        { u"lesseqqgtr"_ustr, u"\u2A8B"_ustr },
+        { u"lessgtr"_ustr, u"\u2276"_ustr },
+        { u"lesssim"_ustr, u"\u2272"_ustr },
+        { u"lfisht"_ustr, u"\u297C"_ustr },
+        { u"lfloor"_ustr, u"\u230A"_ustr },
+        { u"lfr"_ustr, u"\U0001D529"_ustr },
+        { u"lg"_ustr, u"\u2276"_ustr },
+        { u"lgE"_ustr, u"\u2A91"_ustr },
+        { u"lhard"_ustr, u"\u21BD"_ustr },
+        { u"lharu"_ustr, u"\u21BC"_ustr },
+        { u"lharul"_ustr, u"\u296A"_ustr },
+        { u"lhblk"_ustr, u"\u2584"_ustr },
+        { u"ljcy"_ustr, u"\u0459"_ustr },
+        { u"ll"_ustr, u"\u226A"_ustr },
+        { u"llarr"_ustr, u"\u21C7"_ustr },
+        { u"llcorner"_ustr, u"\u231E"_ustr },
+        { u"llhard"_ustr, u"\u296B"_ustr },
+        { u"lltri"_ustr, u"\u25FA"_ustr },
+        { u"lmidot"_ustr, u"\u0140"_ustr },
+        { u"lmoust"_ustr, u"\u23B0"_ustr },
+        { u"lmoustache"_ustr, u"\u23B0"_ustr },
+        { u"lnE"_ustr, u"\u2268"_ustr },
+        { u"lnap"_ustr, u"\u2A89"_ustr },
+        { u"lnapprox"_ustr, u"\u2A89"_ustr },
+        { u"lne"_ustr, u"\u2A87"_ustr },
+        { u"lneq"_ustr, u"\u2A87"_ustr },
+        { u"lneqq"_ustr, u"\u2268"_ustr },
+        { u"lnsim"_ustr, u"\u22E6"_ustr },
+        { u"loang"_ustr, u"\u27EC"_ustr },
+        { u"loarr"_ustr, u"\u21FD"_ustr },
+        { u"lobrk"_ustr, u"\u27E6"_ustr },
+        { u"longleftarrow"_ustr, u"\u27F5"_ustr },
+        { u"longleftrightarrow"_ustr, u"\u27F7"_ustr },
+        { u"longmapsto"_ustr, u"\u27FC"_ustr },
+        { u"longrightarrow"_ustr, u"\u27F6"_ustr },
+        { u"looparrowleft"_ustr, u"\u21AB"_ustr },
+        { u"looparrowright"_ustr, u"\u21AC"_ustr },
+        { u"lopar"_ustr, u"\u2985"_ustr },
+        { u"lopf"_ustr, u"\U0001D55D"_ustr },
+        { u"loplus"_ustr, u"\u2A2D"_ustr },
+        { u"lotimes"_ustr, u"\u2A34"_ustr },
+        { u"lowast"_ustr, u"\u2217"_ustr },
+        { u"lowbar"_ustr, u"\u005F"_ustr },
+        { u"loz"_ustr, u"\u25CA"_ustr },
+        { u"lozenge"_ustr, u"\u25CA"_ustr },
+        { u"lozf"_ustr, u"\u29EB"_ustr },
+        { u"lpar"_ustr, u"\u0028"_ustr },
+        { u"lparlt"_ustr, u"\u2993"_ustr },
+        { u"lrarr"_ustr, u"\u21C6"_ustr },
+        { u"lrcorner"_ustr, u"\u231F"_ustr },
+        { u"lrhar"_ustr, u"\u21CB"_ustr },
+        { u"lrhard"_ustr, u"\u296D"_ustr },
+        { u"lrm"_ustr, u"\u200E"_ustr },
+        { u"lrtri"_ustr, u"\u22BF"_ustr },
+        { u"lsaquo"_ustr, u"\u2039"_ustr },
+        { u"lscr"_ustr, u"\U0001D4C1"_ustr },
+        { u"lsh"_ustr, u"\u21B0"_ustr },
+        { u"lsim"_ustr, u"\u2272"_ustr },
+        { u"lsime"_ustr, u"\u2A8D"_ustr },
+        { u"lsimg"_ustr, u"\u2A8F"_ustr },
+        { u"lsqb"_ustr, u"\u005B"_ustr },
+        { u"lsquo"_ustr, u"\u2018"_ustr },
+        { u"lsquor"_ustr, u"\u201A"_ustr },
+        { u"lstrok"_ustr, u"\u0142"_ustr },
+        { u"lt"_ustr, u"\u003C"_ustr },
+        { u"ltcc"_ustr, u"\u2AA6"_ustr },
+        { u"ltcir"_ustr, u"\u2A79"_ustr },
+        { u"ltdot"_ustr, u"\u22D6"_ustr },
+        { u"lthree"_ustr, u"\u22CB"_ustr },
+        { u"ltimes"_ustr, u"\u22C9"_ustr },
+        { u"ltlarr"_ustr, u"\u2976"_ustr },
+        { u"ltquest"_ustr, u"\u2A7B"_ustr },
+        { u"ltrPar"_ustr, u"\u2996"_ustr },
+        { u"ltri"_ustr, u"\u25C3"_ustr },
+        { u"ltrie"_ustr, u"\u22B4"_ustr },
+        { u"ltrif"_ustr, u"\u25C2"_ustr },
+        { u"lurdshar"_ustr, u"\u294A"_ustr },
+        { u"luruhar"_ustr, u"\u2966"_ustr },
+        { u"lvertneqq"_ustr, u"\u2268\uFE00"_ustr },
+        { u"lvnE"_ustr, u"\u2268\uFE00"_ustr },
+        { u"mDDot"_ustr, u"\u223A"_ustr },
+        { u"macr"_ustr, u"\u00AF"_ustr },
+        { u"male"_ustr, u"\u2642"_ustr },
+        { u"malt"_ustr, u"\u2720"_ustr },
+        { u"maltese"_ustr, u"\u2720"_ustr },
+        { u"map"_ustr, u"\u21A6"_ustr },
+        { u"mapsto"_ustr, u"\u21A6"_ustr },
+        { u"mapstodown"_ustr, u"\u21A7"_ustr },
+        { u"mapstoleft"_ustr, u"\u21A4"_ustr },
+        { u"mapstoup"_ustr, u"\u21A5"_ustr },
+        { u"marker"_ustr, u"\u25AE"_ustr },
+        { u"mcomma"_ustr, u"\u2A29"_ustr },
+        { u"mcy"_ustr, u"\u043C"_ustr },
+        { u"mdash"_ustr, u"\u2014"_ustr },
+        { u"measuredangle"_ustr, u"\u2221"_ustr },
+        { u"mfr"_ustr, u"\U0001D52A"_ustr },
+        { u"mho"_ustr, u"\u2127"_ustr },
+        { u"micro"_ustr, u"\u00B5"_ustr },
+        { u"mid"_ustr, u"\u2223"_ustr },
+        { u"midast"_ustr, u"\u002A"_ustr },
+        { u"midcir"_ustr, u"\u2AF0"_ustr },
+        { u"middot"_ustr, u"\u00B7"_ustr },
+        { u"minus"_ustr, u"\u2212"_ustr },
+        { u"minusb"_ustr, u"\u229F"_ustr },
+        { u"minusd"_ustr, u"\u2238"_ustr },
+        { u"minusdu"_ustr, u"\u2A2A"_ustr },
+        { u"mlcp"_ustr, u"\u2ADB"_ustr },
+        { u"mldr"_ustr, u"\u2026"_ustr },
+        { u"mnplus"_ustr, u"\u2213"_ustr },
+        { u"models"_ustr, u"\u22A7"_ustr },
+        { u"mopf"_ustr, u"\U0001D55E"_ustr },
+        { u"mp"_ustr, u"\u2213"_ustr },
+        { u"mscr"_ustr, u"\U0001D4C2"_ustr },
+        { u"mstpos"_ustr, u"\u223E"_ustr },
+        { u"mu"_ustr, u"\u03BC"_ustr },
+        { u"multimap"_ustr, u"\u22B8"_ustr },
+        { u"mumap"_ustr, u"\u22B8"_ustr },
+        { u"nGg"_ustr, u"\u22D9\u0338"_ustr },
+        { u"nGt"_ustr, u"\u226B\u20D2"_ustr },
+        { u"nGtv"_ustr, u"\u226B\u0338"_ustr },
+        { u"nLeftarrow"_ustr, u"\u21CD"_ustr },
+        { u"nLeftrightarrow"_ustr, u"\u21CE"_ustr },
+        { u"nLl"_ustr, u"\u22D8\u0338"_ustr },
+        { u"nLt"_ustr, u"\u226A\u20D2"_ustr },
+        { u"nLtv"_ustr, u"\u226A\u0338"_ustr },
+        { u"nRightarrow"_ustr, u"\u21CF"_ustr },
+        { u"nVDash"_ustr, u"\u22AF"_ustr },
+        { u"nVdash"_ustr, u"\u22AE"_ustr },
+        { u"nabla"_ustr, u"\u2207"_ustr },
+        { u"nacute"_ustr, u"\u0144"_ustr },
+        { u"nang"_ustr, u"\u2220\u20D2"_ustr },
+        { u"nap"_ustr, u"\u2249"_ustr },
+        { u"napE"_ustr, u"\u2A70\u0338"_ustr },
+        { u"napid"_ustr, u"\u224B\u0338"_ustr },
+        { u"napos"_ustr, u"\u0149"_ustr },
+        { u"napprox"_ustr, u"\u2249"_ustr },
+        { u"natur"_ustr, u"\u266E"_ustr },
+        { u"natural"_ustr, u"\u266E"_ustr },
+        { u"naturals"_ustr, u"\u2115"_ustr },
+        { u"nbsp"_ustr, u"\u00A0"_ustr },
+        { u"nbump"_ustr, u"\u224E\u0338"_ustr },
+        { u"nbumpe"_ustr, u"\u224F\u0338"_ustr },
+        { u"ncap"_ustr, u"\u2A43"_ustr },
+        { u"ncaron"_ustr, u"\u0148"_ustr },
+        { u"ncedil"_ustr, u"\u0146"_ustr },
+        { u"ncong"_ustr, u"\u2247"_ustr },
+        { u"ncongdot"_ustr, u"\u2A6D\u0338"_ustr },
+        { u"ncup"_ustr, u"\u2A42"_ustr },
+        { u"ncy"_ustr, u"\u043D"_ustr },
+        { u"ndash"_ustr, u"\u2013"_ustr },
+        { u"ne"_ustr, u"\u2260"_ustr },
+        { u"neArr"_ustr, u"\u21D7"_ustr },
+        { u"nearhk"_ustr, u"\u2924"_ustr },
+        { u"nearr"_ustr, u"\u2197"_ustr },
+        { u"nearrow"_ustr, u"\u2197"_ustr },
+        { u"nedot"_ustr, u"\u2250\u0338"_ustr },
+        { u"nequiv"_ustr, u"\u2262"_ustr },
+        { u"nesear"_ustr, u"\u2928"_ustr },
+        { u"nesim"_ustr, u"\u2242\u0338"_ustr },
+        { u"nexist"_ustr, u"\u2204"_ustr },
+        { u"nexists"_ustr, u"\u2204"_ustr },
+        { u"nfr"_ustr, u"\U0001D52B"_ustr },
+        { u"ngE"_ustr, u"\u2267\u0338"_ustr },
+        { u"nge"_ustr, u"\u2271"_ustr },
+        { u"ngeq"_ustr, u"\u2271"_ustr },
+        { u"ngeqq"_ustr, u"\u2267\u0338"_ustr },
+        { u"ngeqslant"_ustr, u"\u2A7E\u0338"_ustr },
+        { u"nges"_ustr, u"\u2A7E\u0338"_ustr },
+        { u"ngsim"_ustr, u"\u2275"_ustr },
+        { u"ngt"_ustr, u"\u226F"_ustr },
+        { u"ngtr"_ustr, u"\u226F"_ustr },
+        { u"nhArr"_ustr, u"\u21CE"_ustr },
+        { u"nharr"_ustr, u"\u21AE"_ustr },
+        { u"nhpar"_ustr, u"\u2AF2"_ustr },
+        { u"ni"_ustr, u"\u220B"_ustr },
+        { u"nis"_ustr, u"\u22FC"_ustr },
+        { u"nisd"_ustr, u"\u22FA"_ustr },
+        { u"niv"_ustr, u"\u220B"_ustr },
+        { u"njcy"_ustr, u"\u045A"_ustr },
+        { u"nlArr"_ustr, u"\u21CD"_ustr },
+        { u"nlE"_ustr, u"\u2266\u0338"_ustr },
+        { u"nlarr"_ustr, u"\u219A"_ustr },
+        { u"nldr"_ustr, u"\u2025"_ustr },
+        { u"nle"_ustr, u"\u2270"_ustr },
+        { u"nleftarrow"_ustr, u"\u219A"_ustr },
+        { u"nleftrightarrow"_ustr, u"\u21AE"_ustr },
+        { u"nleq"_ustr, u"\u2270"_ustr },
+        { u"nleqq"_ustr, u"\u2266\u0338"_ustr },
+        { u"nleqslant"_ustr, u"\u2A7D\u0338"_ustr },
+        { u"nles"_ustr, u"\u2A7D\u0338"_ustr },
+        { u"nless"_ustr, u"\u226E"_ustr },
+        { u"nlsim"_ustr, u"\u2274"_ustr },
+        { u"nlt"_ustr, u"\u226E"_ustr },
+        { u"nltri"_ustr, u"\u22EA"_ustr },
+        { u"nltrie"_ustr, u"\u22EC"_ustr },
+        { u"nmid"_ustr, u"\u2224"_ustr },
+        { u"nopf"_ustr, u"\U0001D55F"_ustr },
+        { u"not"_ustr, u"\u00AC"_ustr },
+        { u"notin"_ustr, u"\u2209"_ustr },
+        { u"notinE"_ustr, u"\u22F9\u0338"_ustr },
+        { u"notindot"_ustr, u"\u22F5\u0338"_ustr },
+        { u"notinva"_ustr, u"\u2209"_ustr },
+        { u"notinvb"_ustr, u"\u22F7"_ustr },
+        { u"notinvc"_ustr, u"\u22F6"_ustr },
+        { u"notni"_ustr, u"\u220C"_ustr },
+        { u"notniva"_ustr, u"\u220C"_ustr },
+        { u"notnivb"_ustr, u"\u22FE"_ustr },
+        { u"notnivc"_ustr, u"\u22FD"_ustr },
+        { u"npar"_ustr, u"\u2226"_ustr },
+        { u"nparallel"_ustr, u"\u2226"_ustr },
+        { u"nparsl"_ustr, u"\u2AFD\u20E5"_ustr },
+        { u"npart"_ustr, u"\u2202\u0338"_ustr },
+        { u"npolint"_ustr, u"\u2A14"_ustr },
+        { u"npr"_ustr, u"\u2280"_ustr },
+        { u"nprcue"_ustr, u"\u22E0"_ustr },
+        { u"npre"_ustr, u"\u2AAF\u0338"_ustr },
+        { u"nprec"_ustr, u"\u2280"_ustr },
+        { u"npreceq"_ustr, u"\u2AAF\u0338"_ustr },
+        { u"nrArr"_ustr, u"\u21CF"_ustr },
+        { u"nrarr"_ustr, u"\u219B"_ustr },
+        { u"nrarrc"_ustr, u"\u2933\u0338"_ustr },
+        { u"nrarrw"_ustr, u"\u219D\u0338"_ustr },
+        { u"nrightarrow"_ustr, u"\u219B"_ustr },
+        { u"nrtri"_ustr, u"\u22EB"_ustr },
+        { u"nrtrie"_ustr, u"\u22ED"_ustr },
+        { u"nsc"_ustr, u"\u2281"_ustr },
+        { u"nsccue"_ustr, u"\u22E1"_ustr },
+        { u"nsce"_ustr, u"\u2AB0\u0338"_ustr },
+        { u"nscr"_ustr, u"\U0001D4C3"_ustr },
+        { u"nshortmid"_ustr, u"\u2224"_ustr },
+        { u"nshortparallel"_ustr, u"\u2226"_ustr },
+        { u"nsim"_ustr, u"\u2241"_ustr },
+        { u"nsime"_ustr, u"\u2244"_ustr },
+        { u"nsimeq"_ustr, u"\u2244"_ustr },
+        { u"nsmid"_ustr, u"\u2224"_ustr },
+        { u"nspar"_ustr, u"\u2226"_ustr },
+        { u"nsqsube"_ustr, u"\u22E2"_ustr },
+        { u"nsqsupe"_ustr, u"\u22E3"_ustr },
+        { u"nsub"_ustr, u"\u2284"_ustr },
+        { u"nsubE"_ustr, u"\u2AC5\u0338"_ustr },
+        { u"nsube"_ustr, u"\u2288"_ustr },
+        { u"nsubset"_ustr, u"\u2282\u20D2"_ustr },
+        { u"nsubseteq"_ustr, u"\u2288"_ustr },
+        { u"nsubseteqq"_ustr, u"\u2AC5\u0338"_ustr },
+        { u"nsucc"_ustr, u"\u2281"_ustr },
+        { u"nsucceq"_ustr, u"\u2AB0\u0338"_ustr },
+        { u"nsup"_ustr, u"\u2285"_ustr },
+        { u"nsupE"_ustr, u"\u2AC6\u0338"_ustr },
+        { u"nsupe"_ustr, u"\u2289"_ustr },
+        { u"nsupset"_ustr, u"\u2283\u20D2"_ustr },
+        { u"nsupseteq"_ustr, u"\u2289"_ustr },
+        { u"nsupseteqq"_ustr, u"\u2AC6\u0338"_ustr },
+        { u"ntgl"_ustr, u"\u2279"_ustr },
+        { u"ntilde"_ustr, u"\u00F1"_ustr },
+        { u"ntlg"_ustr, u"\u2278"_ustr },
+        { u"ntriangleleft"_ustr, u"\u22EA"_ustr },
+        { u"ntrianglelefteq"_ustr, u"\u22EC"_ustr },
+        { u"ntriangleright"_ustr, u"\u22EB"_ustr },
+        { u"ntrianglerighteq"_ustr, u"\u22ED"_ustr },
+        { u"nu"_ustr, u"\u03BD"_ustr },
+        { u"num"_ustr, u"\u0023"_ustr },
+        { u"numero"_ustr, u"\u2116"_ustr },
+        { u"numsp"_ustr, u"\u2007"_ustr },
+        { u"nvDash"_ustr, u"\u22AD"_ustr },
+        { u"nvHarr"_ustr, u"\u2904"_ustr },
+        { u"nvap"_ustr, u"\u224D\u20D2"_ustr },
+        { u"nvdash"_ustr, u"\u22AC"_ustr },
+        { u"nvge"_ustr, u"\u2265\u20D2"_ustr },
+        { u"nvgt"_ustr, u"\u003E\u20D2"_ustr },
+        { u"nvinfin"_ustr, u"\u29DE"_ustr },
+        { u"nvlArr"_ustr, u"\u2902"_ustr },
+        { u"nvle"_ustr, u"\u2264\u20D2"_ustr },
+        { u"nvlt"_ustr, u"\u003C\u20D2"_ustr },
+        { u"nvltrie"_ustr, u"\u22B4\u20D2"_ustr },
+        { u"nvrArr"_ustr, u"\u2903"_ustr },
+        { u"nvrtrie"_ustr, u"\u22B5\u20D2"_ustr },
+        { u"nvsim"_ustr, u"\u223C\u20D2"_ustr },
+        { u"nwArr"_ustr, u"\u21D6"_ustr },
+        { u"nwarhk"_ustr, u"\u2923"_ustr },
+        { u"nwarr"_ustr, u"\u2196"_ustr },
+        { u"nwarrow"_ustr, u"\u2196"_ustr },
+        { u"nwnear"_ustr, u"\u2927"_ustr },
+        { u"oS"_ustr, u"\u24C8"_ustr },
+        { u"oacute"_ustr, u"\u00F3"_ustr },
+        { u"oast"_ustr, u"\u229B"_ustr },
+        { u"ocir"_ustr, u"\u229A"_ustr },
+        { u"ocirc"_ustr, u"\u00F4"_ustr },
+        { u"ocy"_ustr, u"\u043E"_ustr },
+        { u"odash"_ustr, u"\u229D"_ustr },
+        { u"odblac"_ustr, u"\u0151"_ustr },
+        { u"odiv"_ustr, u"\u2A38"_ustr },
+        { u"odot"_ustr, u"\u2299"_ustr },
+        { u"odsold"_ustr, u"\u29BC"_ustr },
+        { u"oelig"_ustr, u"\u0153"_ustr },
+        { u"ofcir"_ustr, u"\u29BF"_ustr },
+        { u"ofr"_ustr, u"\U0001D52C"_ustr },
+        { u"ogon"_ustr, u"\u02DB"_ustr },
+        { u"ograve"_ustr, u"\u00F2"_ustr },
+        { u"ogt"_ustr, u"\u29C1"_ustr },
+        { u"ohbar"_ustr, u"\u29B5"_ustr },
+        { u"ohm"_ustr, u"\u03A9"_ustr },
+        { u"oint"_ustr, u"\u222E"_ustr },
+        { u"olarr"_ustr, u"\u21BA"_ustr },
+        { u"olcir"_ustr, u"\u29BE"_ustr },
+        { u"olcross"_ustr, u"\u29BB"_ustr },
+        { u"oline"_ustr, u"\u203E"_ustr },
+        { u"olt"_ustr, u"\u29C0"_ustr },
+        { u"omacr"_ustr, u"\u014D"_ustr },
+        { u"omega"_ustr, u"\u03C9"_ustr },
+        { u"omicron"_ustr, u"\u03BF"_ustr },
+        { u"omid"_ustr, u"\u29B6"_ustr },
+        { u"ominus"_ustr, u"\u2296"_ustr },
+        { u"oopf"_ustr, u"\U0001D560"_ustr },
+        { u"opar"_ustr, u"\u29B7"_ustr },
+        { u"operp"_ustr, u"\u29B9"_ustr },
+        { u"oplus"_ustr, u"\u2295"_ustr },
+        { u"or"_ustr, u"\u2228"_ustr },
+        { u"orarr"_ustr, u"\u21BB"_ustr },
+        { u"ord"_ustr, u"\u2A5D"_ustr },
+        { u"order"_ustr, u"\u2134"_ustr },
+        { u"orderof"_ustr, u"\u2134"_ustr },
+        { u"ordf"_ustr, u"\u00AA"_ustr },
+        { u"ordm"_ustr, u"\u00BA"_ustr },
+        { u"origof"_ustr, u"\u22B6"_ustr },
+        { u"oror"_ustr, u"\u2A56"_ustr },
+        { u"orslope"_ustr, u"\u2A57"_ustr },
+        { u"orv"_ustr, u"\u2A5B"_ustr },
+        { u"oscr"_ustr, u"\u2134"_ustr },
+        { u"oslash"_ustr, u"\u00F8"_ustr },
+        { u"osol"_ustr, u"\u2298"_ustr },
+        { u"otilde"_ustr, u"\u00F5"_ustr },
+        { u"otimes"_ustr, u"\u2297"_ustr },
+        { u"otimesas"_ustr, u"\u2A36"_ustr },
+        { u"ouml"_ustr, u"\u00F6"_ustr },
+        { u"ovbar"_ustr, u"\u233D"_ustr },
+        { u"par"_ustr, u"\u2225"_ustr },
+        { u"para"_ustr, u"\u00B6"_ustr },
+        { u"parallel"_ustr, u"\u2225"_ustr },
+        { u"parsim"_ustr, u"\u2AF3"_ustr },
+        { u"parsl"_ustr, u"\u2AFD"_ustr },
+        { u"part"_ustr, u"\u2202"_ustr },
+        { u"pcy"_ustr, u"\u043F"_ustr },
+        { u"percnt"_ustr, u"\u0025"_ustr },
+        { u"period"_ustr, u"\u002E"_ustr },
+        { u"permil"_ustr, u"\u2030"_ustr },
+        { u"perp"_ustr, u"\u22A5"_ustr },
+        { u"pertenk"_ustr, u"\u2031"_ustr },
+        { u"pfr"_ustr, u"\U0001D52D"_ustr },
+        { u"phi"_ustr, u"\u03C6"_ustr },
+        { u"phiv"_ustr, u"\u03D5"_ustr },
+        { u"phmmat"_ustr, u"\u2133"_ustr },
+        { u"phone"_ustr, u"\u260E"_ustr },
+        { u"pi"_ustr, u"\u03C0"_ustr },
+        { u"pitchfork"_ustr, u"\u22D4"_ustr },
+        { u"piv"_ustr, u"\u03D6"_ustr },
+        { u"planck"_ustr, u"\u210F"_ustr },
+        { u"planckh"_ustr, u"\u210E"_ustr },
+        { u"plankv"_ustr, u"\u210F"_ustr },
+        { u"plus"_ustr, u"\u002B"_ustr },
+        { u"plusacir"_ustr, u"\u2A23"_ustr },
+        { u"plusb"_ustr, u"\u229E"_ustr },
+        { u"pluscir"_ustr, u"\u2A22"_ustr },
+        { u"plusdo"_ustr, u"\u2214"_ustr },
+        { u"plusdu"_ustr, u"\u2A25"_ustr },
+        { u"pluse"_ustr, u"\u2A72"_ustr },
+        { u"plusmn"_ustr, u"\u00B1"_ustr },
+        { u"plussim"_ustr, u"\u2A26"_ustr },
+        { u"plustwo"_ustr, u"\u2A27"_ustr },
+        { u"pm"_ustr, u"\u00B1"_ustr },
+        { u"pointint"_ustr, u"\u2A15"_ustr },
+        { u"popf"_ustr, u"\U0001D561"_ustr },
+        { u"pound"_ustr, u"\u00A3"_ustr },
+        { u"pr"_ustr, u"\u227A"_ustr },
+        { u"prE"_ustr, u"\u2AB3"_ustr },
+        { u"prap"_ustr, u"\u2AB7"_ustr },
+        { u"prcue"_ustr, u"\u227C"_ustr },
+        { u"pre"_ustr, u"\u2AAF"_ustr },
+        { u"prec"_ustr, u"\u227A"_ustr },
+        { u"precapprox"_ustr, u"\u2AB7"_ustr },
+        { u"preccurlyeq"_ustr, u"\u227C"_ustr },
+        { u"preceq"_ustr, u"\u2AAF"_ustr },
+        { u"precnapprox"_ustr, u"\u2AB9"_ustr },
+        { u"precneqq"_ustr, u"\u2AB5"_ustr },
+        { u"precnsim"_ustr, u"\u22E8"_ustr },
+        { u"precsim"_ustr, u"\u227E"_ustr },
+        { u"prime"_ustr, u"\u2032"_ustr },
+        { u"primes"_ustr, u"\u2119"_ustr },
+        { u"prnE"_ustr, u"\u2AB5"_ustr },
+        { u"prnap"_ustr, u"\u2AB9"_ustr },
+        { u"prnsim"_ustr, u"\u22E8"_ustr },
+        { u"prod"_ustr, u"\u220F"_ustr },
+        { u"profalar"_ustr, u"\u232E"_ustr },
+        { u"profline"_ustr, u"\u2312"_ustr },
+        { u"profsurf"_ustr, u"\u2313"_ustr },
+        { u"prop"_ustr, u"\u221D"_ustr },
+        { u"propto"_ustr, u"\u221D"_ustr },
+        { u"prsim"_ustr, u"\u227E"_ustr },
+        { u"prurel"_ustr, u"\u22B0"_ustr },
+        { u"pscr"_ustr, u"\U0001D4C5"_ustr },
+        { u"psi"_ustr, u"\u03C8"_ustr },
+        { u"puncsp"_ustr, u"\u2008"_ustr },
+        { u"qfr"_ustr, u"\U0001D52E"_ustr },
+        { u"qint"_ustr, u"\u2A0C"_ustr },
+        { u"qopf"_ustr, u"\U0001D562"_ustr },
+        { u"qprime"_ustr, u"\u2057"_ustr },
+        { u"qscr"_ustr, u"\U0001D4C6"_ustr },
+        { u"quaternions"_ustr, u"\u210D"_ustr },
+        { u"quatint"_ustr, u"\u2A16"_ustr },
+        { u"quest"_ustr, u"\u003F"_ustr },
+        { u"questeq"_ustr, u"\u225F"_ustr },
+        { u"quot"_ustr, u"\u0022"_ustr },
+        { u"rAarr"_ustr, u"\u21DB"_ustr },
+        { u"rArr"_ustr, u"\u21D2"_ustr },
+        { u"rAtail"_ustr, u"\u291C"_ustr },
+        { u"rBarr"_ustr, u"\u290F"_ustr },
+        { u"rHar"_ustr, u"\u2964"_ustr },
+        { u"race"_ustr, u"\u223D\u0331"_ustr },
+        { u"racute"_ustr, u"\u0155"_ustr },
+        { u"radic"_ustr, u"\u221A"_ustr },
+        { u"raemptyv"_ustr, u"\u29B3"_ustr },
+        { u"rang"_ustr, u"\u27E9"_ustr },
+        { u"rangd"_ustr, u"\u2992"_ustr },
+        { u"range"_ustr, u"\u29A5"_ustr },
+        { u"rangle"_ustr, u"\u27E9"_ustr },
+        { u"raquo"_ustr, u"\u00BB"_ustr },
+        { u"rarr"_ustr, u"\u2192"_ustr },
+        { u"rarrap"_ustr, u"\u2975"_ustr },
+        { u"rarrb"_ustr, u"\u21E5"_ustr },
+        { u"rarrbfs"_ustr, u"\u2920"_ustr },
+        { u"rarrc"_ustr, u"\u2933"_ustr },
+        { u"rarrfs"_ustr, u"\u291E"_ustr },
+        { u"rarrhk"_ustr, u"\u21AA"_ustr },
+        { u"rarrlp"_ustr, u"\u21AC"_ustr },
+        { u"rarrpl"_ustr, u"\u2945"_ustr },
+        { u"rarrsim"_ustr, u"\u2974"_ustr },
+        { u"rarrtl"_ustr, u"\u21A3"_ustr },
+        { u"rarrw"_ustr, u"\u219D"_ustr },
+        { u"ratail"_ustr, u"\u291A"_ustr },
+        { u"ratio"_ustr, u"\u2236"_ustr },
+        { u"rationals"_ustr, u"\u211A"_ustr },
+        { u"rbarr"_ustr, u"\u290D"_ustr },
+        { u"rbbrk"_ustr, u"\u2773"_ustr },
+        { u"rbrace"_ustr, u"\u007D"_ustr },
+        { u"rbrack"_ustr, u"\u005D"_ustr },
+        { u"rbrke"_ustr, u"\u298C"_ustr },
+        { u"rbrksld"_ustr, u"\u298E"_ustr },
+        { u"rbrkslu"_ustr, u"\u2990"_ustr },
+        { u"rcaron"_ustr, u"\u0159"_ustr },
+        { u"rcedil"_ustr, u"\u0157"_ustr },
+        { u"rceil"_ustr, u"\u2309"_ustr },
+        { u"rcub"_ustr, u"\u007D"_ustr },
+        { u"rcy"_ustr, u"\u0440"_ustr },
+        { u"rdca"_ustr, u"\u2937"_ustr },
+        { u"rdldhar"_ustr, u"\u2969"_ustr },
+        { u"rdquo"_ustr, u"\u201D"_ustr },
+        { u"rdquor"_ustr, u"\u201D"_ustr },
+        { u"rdsh"_ustr, u"\u21B3"_ustr },
+        { u"real"_ustr, u"\u211C"_ustr },
+        { u"realine"_ustr, u"\u211B"_ustr },
+        { u"realpart"_ustr, u"\u211C"_ustr },
+        { u"reals"_ustr, u"\u211D"_ustr },
+        { u"rect"_ustr, u"\u25AD"_ustr },
+        { u"reg"_ustr, u"\u00AE"_ustr },
+        { u"rfisht"_ustr, u"\u297D"_ustr },
+        { u"rfloor"_ustr, u"\u230B"_ustr },
+        { u"rfr"_ustr, u"\U0001D52F"_ustr },
+        { u"rhard"_ustr, u"\u21C1"_ustr },
+        { u"rharu"_ustr, u"\u21C0"_ustr },
+        { u"rharul"_ustr, u"\u296C"_ustr },
+        { u"rho"_ustr, u"\u03C1"_ustr },
+        { u"rhov"_ustr, u"\u03F1"_ustr },
+        { u"rightarrow"_ustr, u"\u2192"_ustr },
+        { u"rightarrowtail"_ustr, u"\u21A3"_ustr },
+        { u"rightharpoondown"_ustr, u"\u21C1"_ustr },
+        { u"rightharpoonup"_ustr, u"\u21C0"_ustr },
+        { u"rightleftarrows"_ustr, u"\u21C4"_ustr },
+        { u"rightleftharpoons"_ustr, u"\u21CC"_ustr },
+        { u"rightrightarrows"_ustr, u"\u21C9"_ustr },
+        { u"rightsquigarrow"_ustr, u"\u219D"_ustr },
+        { u"rightthreetimes"_ustr, u"\u22CC"_ustr },
+        { u"ring"_ustr, u"\u02DA"_ustr },
+        { u"risingdotseq"_ustr, u"\u2253"_ustr },
+        { u"rlarr"_ustr, u"\u21C4"_ustr },
+        { u"rlhar"_ustr, u"\u21CC"_ustr },
+        { u"rlm"_ustr, u"\u200F"_ustr },
+        { u"rmoust"_ustr, u"\u23B1"_ustr },
+        { u"rmoustache"_ustr, u"\u23B1"_ustr },
+        { u"rnmid"_ustr, u"\u2AEE"_ustr },
+        { u"roang"_ustr, u"\u27ED"_ustr },
+        { u"roarr"_ustr, u"\u21FE"_ustr },
+        { u"robrk"_ustr, u"\u27E7"_ustr },
+        { u"ropar"_ustr, u"\u2986"_ustr },
+        { u"ropf"_ustr, u"\U0001D563"_ustr },
+        { u"roplus"_ustr, u"\u2A2E"_ustr },
+        { u"rotimes"_ustr, u"\u2A35"_ustr },
+        { u"rpar"_ustr, u"\u0029"_ustr },
+        { u"rpargt"_ustr, u"\u2994"_ustr },
+        { u"rppolint"_ustr, u"\u2A12"_ustr },
+        { u"rrarr"_ustr, u"\u21C9"_ustr },
+        { u"rsaquo"_ustr, u"\u203A"_ustr },
+        { u"rscr"_ustr, u"\U0001D4C7"_ustr },
+        { u"rsh"_ustr, u"\u21B1"_ustr },
+        { u"rsqb"_ustr, u"\u005D"_ustr },
+        { u"rsquo"_ustr, u"\u2019"_ustr },
+        { u"rsquor"_ustr, u"\u2019"_ustr },
+        { u"rthree"_ustr, u"\u22CC"_ustr },
+        { u"rtimes"_ustr, u"\u22CA"_ustr },
+        { u"rtri"_ustr, u"\u25B9"_ustr },
+        { u"rtrie"_ustr, u"\u22B5"_ustr },
+        { u"rtrif"_ustr, u"\u25B8"_ustr },
+        { u"rtriltri"_ustr, u"\u29CE"_ustr },
+        { u"ruluhar"_ustr, u"\u2968"_ustr },
+        { u"rx"_ustr, u"\u211E"_ustr },
+        { u"sacute"_ustr, u"\u015B"_ustr },
+        { u"sbquo"_ustr, u"\u201A"_ustr },
+        { u"sc"_ustr, u"\u227B"_ustr },
+        { u"scE"_ustr, u"\u2AB4"_ustr },
+        { u"scap"_ustr, u"\u2AB8"_ustr },
+        { u"scaron"_ustr, u"\u0161"_ustr },
+        { u"sccue"_ustr, u"\u227D"_ustr },
+        { u"sce"_ustr, u"\u2AB0"_ustr },
+        { u"scedil"_ustr, u"\u015F"_ustr },
+        { u"scirc"_ustr, u"\u015D"_ustr },
+        { u"scnE"_ustr, u"\u2AB6"_ustr },
+        { u"scnap"_ustr, u"\u2ABA"_ustr },
+        { u"scnsim"_ustr, u"\u22E9"_ustr },
+        { u"scpolint"_ustr, u"\u2A13"_ustr },
+        { u"scsim"_ustr, u"\u227F"_ustr },
+        { u"scy"_ustr, u"\u0441"_ustr },
+        { u"sdot"_ustr, u"\u22C5"_ustr },
+        { u"sdotb"_ustr, u"\u22A1"_ustr },
+        { u"sdote"_ustr, u"\u2A66"_ustr },
+        { u"seArr"_ustr, u"\u21D8"_ustr },
+        { u"searhk"_ustr, u"\u2925"_ustr },
+        { u"searr"_ustr, u"\u2198"_ustr },
+        { u"searrow"_ustr, u"\u2198"_ustr },
+        { u"sect"_ustr, u"\u00A7"_ustr },
+        { u"semi"_ustr, u"\u003B"_ustr },
+        { u"seswar"_ustr, u"\u2929"_ustr },
+        { u"setminus"_ustr, u"\u2216"_ustr },
+        { u"setmn"_ustr, u"\u2216"_ustr },
+        { u"sext"_ustr, u"\u2736"_ustr },
+        { u"sfr"_ustr, u"\U0001D530"_ustr },
+        { u"sfrown"_ustr, u"\u2322"_ustr },
+        { u"sharp"_ustr, u"\u266F"_ustr },
+        { u"shchcy"_ustr, u"\u0449"_ustr },
+        { u"shcy"_ustr, u"\u0448"_ustr },
+        { u"shortmid"_ustr, u"\u2223"_ustr },
+        { u"shortparallel"_ustr, u"\u2225"_ustr },
+        { u"shy"_ustr, u"\u00AD"_ustr },
+        { u"sigma"_ustr, u"\u03C3"_ustr },
+        { u"sigmaf"_ustr, u"\u03C2"_ustr },
+        { u"sigmav"_ustr, u"\u03C2"_ustr },
+        { u"sim"_ustr, u"\u223C"_ustr },
+        { u"simdot"_ustr, u"\u2A6A"_ustr },
+        { u"sime"_ustr, u"\u2243"_ustr },
+        { u"simeq"_ustr, u"\u2243"_ustr },
+        { u"simg"_ustr, u"\u2A9E"_ustr },
+        { u"simgE"_ustr, u"\u2AA0"_ustr },
+        { u"siml"_ustr, u"\u2A9D"_ustr },
+        { u"simlE"_ustr, u"\u2A9F"_ustr },
+        { u"simne"_ustr, u"\u2246"_ustr },
+        { u"simplus"_ustr, u"\u2A24"_ustr },
+        { u"simrarr"_ustr, u"\u2972"_ustr },
+        { u"slarr"_ustr, u"\u2190"_ustr },
+        { u"smallsetminus"_ustr, u"\u2216"_ustr },
+        { u"smashp"_ustr, u"\u2A33"_ustr },
+        { u"smeparsl"_ustr, u"\u29E4"_ustr },
+        { u"smid"_ustr, u"\u2223"_ustr },
+        { u"smile"_ustr, u"\u2323"_ustr },
+        { u"smt"_ustr, u"\u2AAA"_ustr },
+        { u"smte"_ustr, u"\u2AAC"_ustr },
+        { u"smtes"_ustr, u"\u2AAC\uFE00"_ustr },
+        { u"softcy"_ustr, u"\u044C"_ustr },
+        { u"sol"_ustr, u"\u002F"_ustr },
+        { u"solb"_ustr, u"\u29C4"_ustr },
+        { u"solbar"_ustr, u"\u233F"_ustr },
+        { u"sopf"_ustr, u"\U0001D564"_ustr },
+        { u"spades"_ustr, u"\u2660"_ustr },
+        { u"spadesuit"_ustr, u"\u2660"_ustr },
+        { u"spar"_ustr, u"\u2225"_ustr },
+        { u"sqcap"_ustr, u"\u2293"_ustr },
+        { u"sqcaps"_ustr, u"\u2293\uFE00"_ustr },
+        { u"sqcup"_ustr, u"\u2294"_ustr },
+        { u"sqcups"_ustr, u"\u2294\uFE00"_ustr },
+        { u"sqsub"_ustr, u"\u228F"_ustr },
+        { u"sqsube"_ustr, u"\u2291"_ustr },
+        { u"sqsubset"_ustr, u"\u228F"_ustr },
+        { u"sqsubseteq"_ustr, u"\u2291"_ustr },
+        { u"sqsup"_ustr, u"\u2290"_ustr },
+        { u"sqsupe"_ustr, u"\u2292"_ustr },
+        { u"sqsupset"_ustr, u"\u2290"_ustr },
+        { u"sqsupseteq"_ustr, u"\u2292"_ustr },
+        { u"squ"_ustr, u"\u25A1"_ustr },
+        { u"square"_ustr, u"\u25A1"_ustr },
+        { u"squarf"_ustr, u"\u25AA"_ustr },
+        { u"squf"_ustr, u"\u25AA"_ustr },
+        { u"srarr"_ustr, u"\u2192"_ustr },
+        { u"sscr"_ustr, u"\U0001D4C8"_ustr },
+        { u"ssetmn"_ustr, u"\u2216"_ustr },
+        { u"ssmile"_ustr, u"\u2323"_ustr },
+        { u"sstarf"_ustr, u"\u22C6"_ustr },
+        { u"star"_ustr, u"\u2606"_ustr },
+        { u"starf"_ustr, u"\u2605"_ustr },
+        { u"straightepsilon"_ustr, u"\u03F5"_ustr },
+        { u"straightphi"_ustr, u"\u03D5"_ustr },
+        { u"strns"_ustr, u"\u00AF"_ustr },
+        { u"sub"_ustr, u"\u2282"_ustr },
+        { u"subE"_ustr, u"\u2AC5"_ustr },
+        { u"subdot"_ustr, u"\u2ABD"_ustr },
+        { u"sube"_ustr, u"\u2286"_ustr },
+        { u"subedot"_ustr, u"\u2AC3"_ustr },
+        { u"submult"_ustr, u"\u2AC1"_ustr },
+        { u"subnE"_ustr, u"\u2ACB"_ustr },
+        { u"subne"_ustr, u"\u228A"_ustr },
+        { u"subplus"_ustr, u"\u2ABF"_ustr },
+        { u"subrarr"_ustr, u"\u2979"_ustr },
+        { u"subset"_ustr, u"\u2282"_ustr },
+        { u"subseteq"_ustr, u"\u2286"_ustr },
+        { u"subseteqq"_ustr, u"\u2AC5"_ustr },
+        { u"subsetneq"_ustr, u"\u228A"_ustr },
+        { u"subsetneqq"_ustr, u"\u2ACB"_ustr },
+        { u"subsim"_ustr, u"\u2AC7"_ustr },
+        { u"subsub"_ustr, u"\u2AD5"_ustr },
+        { u"subsup"_ustr, u"\u2AD3"_ustr },
+        { u"succ"_ustr, u"\u227B"_ustr },
+        { u"succapprox"_ustr, u"\u2AB8"_ustr },
+        { u"succcurlyeq"_ustr, u"\u227D"_ustr },
+        { u"succeq"_ustr, u"\u2AB0"_ustr },
+        { u"succnapprox"_ustr, u"\u2ABA"_ustr },
+        { u"succneqq"_ustr, u"\u2AB6"_ustr },
+        { u"succnsim"_ustr, u"\u22E9"_ustr },
+        { u"succsim"_ustr, u"\u227F"_ustr },
+        { u"sum"_ustr, u"\u2211"_ustr },
+        { u"sung"_ustr, u"\u266A"_ustr },
+        { u"sup"_ustr, u"\u2283"_ustr },
+        { u"sup1"_ustr, u"\u00B9"_ustr },
+        { u"sup2"_ustr, u"\u00B2"_ustr },
+        { u"sup3"_ustr, u"\u00B3"_ustr },
+        { u"supE"_ustr, u"\u2AC6"_ustr },
+        { u"supdot"_ustr, u"\u2ABE"_ustr },
+        { u"supdsub"_ustr, u"\u2AD8"_ustr },
+        { u"supe"_ustr, u"\u2287"_ustr },
+        { u"supedot"_ustr, u"\u2AC4"_ustr },
+        { u"suphsol"_ustr, u"\u27C9"_ustr },
+        { u"suphsub"_ustr, u"\u2AD7"_ustr },
+        { u"suplarr"_ustr, u"\u297B"_ustr },
+        { u"supmult"_ustr, u"\u2AC2"_ustr },
+        { u"supnE"_ustr, u"\u2ACC"_ustr },
+        { u"supne"_ustr, u"\u228B"_ustr },
+        { u"supplus"_ustr, u"\u2AC0"_ustr },
+        { u"supset"_ustr, u"\u2283"_ustr },
+        { u"supseteq"_ustr, u"\u2287"_ustr },
+        { u"supseteqq"_ustr, u"\u2AC6"_ustr },
+        { u"supsetneq"_ustr, u"\u228B"_ustr },
+        { u"supsetneqq"_ustr, u"\u2ACC"_ustr },
+        { u"supsim"_ustr, u"\u2AC8"_ustr },
+        { u"supsub"_ustr, u"\u2AD4"_ustr },
+        { u"supsup"_ustr, u"\u2AD6"_ustr },
+        { u"swArr"_ustr, u"\u21D9"_ustr },
+        { u"swarhk"_ustr, u"\u2926"_ustr },
+        { u"swarr"_ustr, u"\u2199"_ustr },
+        { u"swarrow"_ustr, u"\u2199"_ustr },
+        { u"swnwar"_ustr, u"\u292A"_ustr },
+        { u"szlig"_ustr, u"\u00DF"_ustr },
+        { u"target"_ustr, u"\u2316"_ustr },
+        { u"tau"_ustr, u"\u03C4"_ustr },
+        { u"tbrk"_ustr, u"\u23B4"_ustr },
+        { u"tcaron"_ustr, u"\u0165"_ustr },
+        { u"tcedil"_ustr, u"\u0163"_ustr },
+        { u"tcy"_ustr, u"\u0442"_ustr },
+        { u"tdot"_ustr, u"\u20DB"_ustr },
+        { u"telrec"_ustr, u"\u2315"_ustr },
+        { u"tfr"_ustr, u"\U0001D531"_ustr },
+        { u"there4"_ustr, u"\u2234"_ustr },
+        { u"therefore"_ustr, u"\u2234"_ustr },
+        { u"theta"_ustr, u"\u03B8"_ustr },
+        { u"thetasym"_ustr, u"\u03D1"_ustr },
+        { u"thetav"_ustr, u"\u03D1"_ustr },
+        { u"thickapprox"_ustr, u"\u2248"_ustr },
+        { u"thicksim"_ustr, u"\u223C"_ustr },
+        { u"thinsp"_ustr, u"\u2009"_ustr },
+        { u"thkap"_ustr, u"\u2248"_ustr },
+        { u"thksim"_ustr, u"\u223C"_ustr },
+        { u"thorn"_ustr, u"\u00FE"_ustr },
+        { u"tilde"_ustr, u"\u02DC"_ustr },
+        { u"times"_ustr, u"\u00D7"_ustr },
+        { u"timesb"_ustr, u"\u22A0"_ustr },
+        { u"timesbar"_ustr, u"\u2A31"_ustr },
+        { u"timesd"_ustr, u"\u2A30"_ustr },
+        { u"tint"_ustr, u"\u222D"_ustr },
+        { u"toea"_ustr, u"\u2928"_ustr },
+        { u"top"_ustr, u"\u22A4"_ustr },
+        { u"topbot"_ustr, u"\u2336"_ustr },
+        { u"topcir"_ustr, u"\u2AF1"_ustr },
+        { u"topf"_ustr, u"\U0001D565"_ustr },
+        { u"topfork"_ustr, u"\u2ADA"_ustr },
+        { u"tosa"_ustr, u"\u2929"_ustr },
+        { u"tprime"_ustr, u"\u2034"_ustr },
+        { u"trade"_ustr, u"\u2122"_ustr },
+        { u"triangle"_ustr, u"\u25B5"_ustr },
+        { u"triangledown"_ustr, u"\u25BF"_ustr },
+        { u"triangleleft"_ustr, u"\u25C3"_ustr },
+        { u"trianglelefteq"_ustr, u"\u22B4"_ustr },
+        { u"triangleq"_ustr, u"\u225C"_ustr },
+        { u"triangleright"_ustr, u"\u25B9"_ustr },
+        { u"trianglerighteq"_ustr, u"\u22B5"_ustr },
+        { u"tridot"_ustr, u"\u25EC"_ustr },
+        { u"trie"_ustr, u"\u225C"_ustr },
+        { u"triminus"_ustr, u"\u2A3A"_ustr },
+        { u"triplus"_ustr, u"\u2A39"_ustr },
+        { u"trisb"_ustr, u"\u29CD"_ustr },
+        { u"tritime"_ustr, u"\u2A3B"_ustr },
+        { u"trpezium"_ustr, u"\u23E2"_ustr },
+        { u"tscr"_ustr, u"\U0001D4C9"_ustr },
+        { u"tscy"_ustr, u"\u0446"_ustr },
+        { u"tshcy"_ustr, u"\u045B"_ustr },
+        { u"tstrok"_ustr, u"\u0167"_ustr },
+        { u"twixt"_ustr, u"\u226C"_ustr },
+        { u"twoheadleftarrow"_ustr, u"\u219E"_ustr },
+        { u"twoheadrightarrow"_ustr, u"\u21A0"_ustr },
+        { u"uArr"_ustr, u"\u21D1"_ustr },
+        { u"uHar"_ustr, u"\u2963"_ustr },
+        { u"uacute"_ustr, u"\u00FA"_ustr },
+        { u"uarr"_ustr, u"\u2191"_ustr },
+        { u"ubrcy"_ustr, u"\u045E"_ustr },
+        { u"ubreve"_ustr, u"\u016D"_ustr },
+        { u"ucirc"_ustr, u"\u00FB"_ustr },
+        { u"ucy"_ustr, u"\u0443"_ustr },
+        { u"udarr"_ustr, u"\u21C5"_ustr },
+        { u"udblac"_ustr, u"\u0171"_ustr },
+        { u"udhar"_ustr, u"\u296E"_ustr },
+        { u"ufisht"_ustr, u"\u297E"_ustr },
+        { u"ufr"_ustr, u"\U0001D532"_ustr },
+        { u"ugrave"_ustr, u"\u00F9"_ustr },
+        { u"uharl"_ustr, u"\u21BF"_ustr },
+        { u"uharr"_ustr, u"\u21BE"_ustr },
+        { u"uhblk"_ustr, u"\u2580"_ustr },
+        { u"ulcorn"_ustr, u"\u231C"_ustr },
+        { u"ulcorner"_ustr, u"\u231C"_ustr },
+        { u"ulcrop"_ustr, u"\u230F"_ustr },
+        { u"ultri"_ustr, u"\u25F8"_ustr },
+        { u"umacr"_ustr, u"\u016B"_ustr },
+        { u"uml"_ustr, u"\u00A8"_ustr },
+        { u"uogon"_ustr, u"\u0173"_ustr },
+        { u"uopf"_ustr, u"\U0001D566"_ustr },
+        { u"uparrow"_ustr, u"\u2191"_ustr },
+        { u"updownarrow"_ustr, u"\u2195"_ustr },
+        { u"upharpoonleft"_ustr, u"\u21BF"_ustr },
+        { u"upharpoonright"_ustr, u"\u21BE"_ustr },
+        { u"uplus"_ustr, u"\u228E"_ustr },
+        { u"upsi"_ustr, u"\u03C5"_ustr },
+        { u"upsih"_ustr, u"\u03D2"_ustr },
+        { u"upsilon"_ustr, u"\u03C5"_ustr },
+        { u"upuparrows"_ustr, u"\u21C8"_ustr },
+        { u"urcorn"_ustr, u"\u231D"_ustr },
+        { u"urcorner"_ustr, u"\u231D"_ustr },
+        { u"urcrop"_ustr, u"\u230E"_ustr },
+        { u"uring"_ustr, u"\u016F"_ustr },
+        { u"urtri"_ustr, u"\u25F9"_ustr },
+        { u"uscr"_ustr, u"\U0001D4CA"_ustr },
+        { u"utdot"_ustr, u"\u22F0"_ustr },
+        { u"utilde"_ustr, u"\u0169"_ustr },
+        { u"utri"_ustr, u"\u25B5"_ustr },
+        { u"utrif"_ustr, u"\u25B4"_ustr },
+        { u"uuarr"_ustr, u"\u21C8"_ustr },
+        { u"uuml"_ustr, u"\u00FC"_ustr },
+        { u"uwangle"_ustr, u"\u29A7"_ustr },
+        { u"vArr"_ustr, u"\u21D5"_ustr },
+        { u"vBar"_ustr, u"\u2AE8"_ustr },
+        { u"vBarv"_ustr, u"\u2AE9"_ustr },
+        { u"vDash"_ustr, u"\u22A8"_ustr },
+        { u"vangrt"_ustr, u"\u299C"_ustr },
+        { u"varepsilon"_ustr, u"\u03F5"_ustr },
+        { u"varkappa"_ustr, u"\u03F0"_ustr },
+        { u"varnothing"_ustr, u"\u2205"_ustr },
+        { u"varphi"_ustr, u"\u03D5"_ustr },
+        { u"varpi"_ustr, u"\u03D6"_ustr },
+        { u"varpropto"_ustr, u"\u221D"_ustr },
+        { u"varr"_ustr, u"\u2195"_ustr },
+        { u"varrho"_ustr, u"\u03F1"_ustr },
+        { u"varsigma"_ustr, u"\u03C2"_ustr },
+        { u"varsubsetneq"_ustr, u"\u228A\uFE00"_ustr },
+        { u"varsubsetneqq"_ustr, u"\u2ACB\uFE00"_ustr },
+        { u"varsupsetneq"_ustr, u"\u228B\uFE00"_ustr },
+        { u"varsupsetneqq"_ustr, u"\u2ACC\uFE00"_ustr },
+        { u"vartheta"_ustr, u"\u03D1"_ustr },
+        { u"vartriangleleft"_ustr, u"\u22B2"_ustr },
+        { u"vartriangleright"_ustr, u"\u22B3"_ustr },
+        { u"vcy"_ustr, u"\u0432"_ustr },
+        { u"vdash"_ustr, u"\u22A2"_ustr },
+        { u"vee"_ustr, u"\u2228"_ustr },
+        { u"veebar"_ustr, u"\u22BB"_ustr },
+        { u"veeeq"_ustr, u"\u225A"_ustr },
+        { u"vellip"_ustr, u"\u22EE"_ustr },
+        { u"verbar"_ustr, u"\u007C"_ustr },
+        { u"vert"_ustr, u"\u007C"_ustr },
+        { u"vfr"_ustr, u"\U0001D533"_ustr },
+        { u"vltri"_ustr, u"\u22B2"_ustr },
+        { u"vnsub"_ustr, u"\u2282\u20D2"_ustr },
+        { u"vnsup"_ustr, u"\u2283\u20D2"_ustr },
+        { u"vopf"_ustr, u"\U0001D567"_ustr },
+        { u"vprop"_ustr, u"\u221D"_ustr },
+        { u"vrtri"_ustr, u"\u22B3"_ustr },
+        { u"vscr"_ustr, u"\U0001D4CB"_ustr },
+        { u"vsubnE"_ustr, u"\u2ACB\uFE00"_ustr },
+        { u"vsubne"_ustr, u"\u228A\uFE00"_ustr },
+        { u"vsupnE"_ustr, u"\u2ACC\uFE00"_ustr },
+        { u"vsupne"_ustr, u"\u228B\uFE00"_ustr },
+        { u"vzigzag"_ustr, u"\u299A"_ustr },
+        { u"wcirc"_ustr, u"\u0175"_ustr },
+        { u"wedbar"_ustr, u"\u2A5F"_ustr },
+        { u"wedge"_ustr, u"\u2227"_ustr },
+        { u"wedgeq"_ustr, u"\u2259"_ustr },
+        { u"weierp"_ustr, u"\u2118"_ustr },
+        { u"wfr"_ustr, u"\U0001D534"_ustr },
+        { u"wopf"_ustr, u"\U0001D568"_ustr },
+        { u"wp"_ustr, u"\u2118"_ustr },
+        { u"wr"_ustr, u"\u2240"_ustr },
+        { u"wreath"_ustr, u"\u2240"_ustr },
+        { u"wscr"_ustr, u"\U0001D4CC"_ustr },
+        { u"xcap"_ustr, u"\u22C2"_ustr },
+        { u"xcirc"_ustr, u"\u25EF"_ustr },
+        { u"xcup"_ustr, u"\u22C3"_ustr },
+        { u"xdtri"_ustr, u"\u25BD"_ustr },
+        { u"xfr"_ustr, u"\U0001D535"_ustr },
+        { u"xhArr"_ustr, u"\u27FA"_ustr },
+        { u"xharr"_ustr, u"\u27F7"_ustr },
+        { u"xi"_ustr, u"\u03BE"_ustr },
+        { u"xlArr"_ustr, u"\u27F8"_ustr },
+        { u"xlarr"_ustr, u"\u27F5"_ustr },
+        { u"xmap"_ustr, u"\u27FC"_ustr },
+        { u"xnis"_ustr, u"\u22FB"_ustr },
+        { u"xodot"_ustr, u"\u2A00"_ustr },
+        { u"xopf"_ustr, u"\U0001D569"_ustr },
+        { u"xoplus"_ustr, u"\u2A01"_ustr },
+        { u"xotime"_ustr, u"\u2A02"_ustr },
+        { u"xrArr"_ustr, u"\u27F9"_ustr },
+        { u"xrarr"_ustr, u"\u27F6"_ustr },
+        { u"xscr"_ustr, u"\U0001D4CD"_ustr },
+        { u"xsqcup"_ustr, u"\u2A06"_ustr },
+        { u"xuplus"_ustr, u"\u2A04"_ustr },
+        { u"xutri"_ustr, u"\u25B3"_ustr },
+        { u"xvee"_ustr, u"\u22C1"_ustr },
+        { u"xwedge"_ustr, u"\u22C0"_ustr },
+        { u"yacute"_ustr, u"\u00FD"_ustr },
+        { u"yacy"_ustr, u"\u044F"_ustr },
+        { u"ycirc"_ustr, u"\u0177"_ustr },
+        { u"ycy"_ustr, u"\u044B"_ustr },
+        { u"yen"_ustr, u"\u00A5"_ustr },
+        { u"yfr"_ustr, u"\U0001D536"_ustr },
+        { u"yicy"_ustr, u"\u0457"_ustr },
+        { u"yopf"_ustr, u"\U0001D56A"_ustr },
+        { u"yscr"_ustr, u"\U0001D4CE"_ustr },
+        { u"yucy"_ustr, u"\u044E"_ustr },
+        { u"yuml"_ustr, u"\u00FF"_ustr },
+        { u"zacute"_ustr, u"\u017A"_ustr },
+        { u"zcaron"_ustr, u"\u017E"_ustr },
+        { u"zcy"_ustr, u"\u0437"_ustr },
+        { u"zdot"_ustr, u"\u017C"_ustr },
+        { u"zeetrf"_ustr, u"\u2128"_ustr },
+        { u"zeta"_ustr, u"\u03B6"_ustr },
+        { u"zfr"_ustr, u"\U0001D537"_ustr },
+        { u"zhcy"_ustr, u"\u0436"_ustr },
+        { u"zigrarr"_ustr, u"\u21DD"_ustr },
+        { u"zopf"_ustr, u"\U0001D56B"_ustr },
+        { u"zscr"_ustr, u"\U0001D4CF"_ustr },
+        { u"zwj"_ustr, u"\u200D"_ustr },
+        { u"zwnj"_ustr, u"\u200C"_ustr }
+        // clang-format on
+    };
+
+const ::css::uno::Sequence<::css::beans::Pair<OUString, OUString>>
+    starmathdatabase::icustomMathmlHtmlEntities(
+        icustomMathmlHtmlEntitiesData, starmathdatabase::STARMATH_MATHMLHTML_ENTITY_NUMBER);
+
+static ::css::beans::Pair<::rtl::OUString, ::rtl::OUString>
+    icustomMathmlHtmlEntitiesNamesExportData[2] = {
+        // clang-format off
+        { u"&sigma;"_ustr, u"\u03C3"_ustr},
+        { u"&infin;"_ustr, u"\u221E"_ustr}
+        // clang-format on
+    };
+const ::css::uno::Sequence<::css::beans::Pair<::rtl::OUString, ::rtl::OUString>>
+    starmathdatabase::icustomMathmlHtmlEntitiesExport(icustomMathmlHtmlEntitiesNamesExportData, 2);
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */