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

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

12 files changed, 11757 insertions, 0 deletions

diff --git a/starmath/source/mathml/attribute.cxx b/starmath/source/mathml/attribute.cxx
new file mode 100644
index 000000000..a1be708ae
--- /dev/null
+++ b/starmath/source/mathml/attribute.cxx
@@ -0,0 +1,475 @@
+/* -*- 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"");
+            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");
+            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%");
+            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%");
+            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%");
+            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");
+            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 000000000..484dcd665
--- /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 000000000..4f8f2a64f
--- /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 000000000..b55be5092
--- /dev/null
+++ b/starmath/source/mathml/export.cxx
@@ -0,0 +1,1110 @@
+/* -*- 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 model
+    uno::Reference<lang::XComponent> xModelComp = m_xModel;
+    SAL_WARN_IF(xModelComp == nullptr, "starmath", "Missing model component");
+    SmModel* pModel = comphelper::getFromUnoTunnel<SmModel>(m_xModel);
+    SAL_WARN_IF(pModel == nullptr, "starmath", "Failed to get threw uno tunnel");
+    if (xModelComp == nullptr || pModel == nullptr)
+        return false;
+
+    // Get doc shell
+    SmDocShell* pDocShell = static_cast<SmDocShell*>(pModel->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* pMediumItemSet = 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 = pMediumItemSet->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", 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
+                = pMediumItemSet->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, xModelComp, 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, xModelComp, u"content.xml", xContext, xInfoSet,
+                                              u"com.sun.star.comp.Math.XMLContentExporter", 5);
+            else
+                bRet = WriteThroughComponentS(xStg, xModelComp, 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, xModelComp, 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, xModelComp, xContext, xInfoSet,
+                                           u"com.sun.star.comp.Math.XMLContentExporter", 5);
+        else
+            bRet = WriteThroughComponentOS(xOut, xModelComp, 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"";
+
+    //Get model
+    uno::Reference<lang::XComponent> xModelComp = m_xModel;
+    SAL_WARN_IF(xModelComp == nullptr, "starmath", "Missing model component");
+    SmModel* pModel = comphelper::getFromUnoTunnel<SmModel>(m_xModel);
+    SAL_WARN_IF(pModel == nullptr, "starmath", "Failed to get threw uno tunnel");
+    if (xModelComp == nullptr || pModel == nullptr)
+        return u"";
+
+    // Get doc shell
+    SmDocShell* pDocShell = static_cast<SmDocShell*>(pModel->GetObjectShell());
+    if (pDocShell == nullptr)
+    {
+        SAL_WARN("starmath", "Failed to fetch sm document");
+        return u"";
+    }
+
+    // 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 = comphelper::getFromUnoTunnel<SmXMLExport>(xFilter);
+        if (pFilter == nullptr)
+        {
+            SAL_WARN("starmath", "Failed to fetch SmMLExport");
+            return false;
+        }
+        xFilter->filter(aProps);
+        return pFilter->GetSuccess();
+    }
+
+    // filter
+    SmMLExport* pFilter = comphelper::getFromUnoTunnel<SmMLExport>(xFilter);
+
+    // 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(OUString(u"text/xml")));
+
+    // 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"";
+
+    // 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
+/*************************************************************************************************/
+
+sal_Int64 SAL_CALL SmMLExport::getSomething(const uno::Sequence<sal_Int8>& rId)
+{
+    return comphelper::getSomethingImpl(rId, this,
+                                        comphelper::FallbackToGetSomethingOf<SvXMLExport>{});
+}
+
+const uno::Sequence<sal_Int8>& SmMLExport::getUnoTunnelId() noexcept
+{
+    static const comphelper::UnoIdInit theSmMLExportUnoTunnelId;
+    return theSmMLExportUnoTunnelId.getSeq();
+}
+
+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(OUString(u""), 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 000000000..52d47028e
--- /dev/null
+++ b/starmath/source/mathml/import.cxx
@@ -0,0 +1,1430 @@
+/* -*- 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;
+    }
+
+    // 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;
+    }
+
+    // Try to get an XStatusIndicator from the Medium
+    uno::Reference<task::XStatusIndicator> xStatusIndicator;
+
+    // Get model via uno
+    SmModel* pModel = comphelper::getFromUnoTunnel<SmModel>(m_xModel);
+    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
+        SfxItemSet* pSet = rMedium.GetItemSet();
+        if (pSet)
+        {
+            const SfxUnoAnyItem* pItem = pSet->GetItem(SID_PROGRESS_STATUSBAR_CONTROL);
+            if (pItem != nullptr)
+                pItem->GetValue() >>= xStatusIndicator;
+        }
+    }
+
+    // Create property list
+    static const comphelper::PropertyMapEntry aInfoMap[]
+        = { { u"PrivateData", 0, cppu::UnoType<XInterface>::get(),
+              beans::PropertyAttribute::MAYBEVOID, 0 },
+            { u"BaseURI", 0, ::cppu::UnoType<OUString>::get(), beans::PropertyAttribute::MAYBEVOID,
+              0 },
+            { u"StreamRelPath", 0, ::cppu::UnoType<OUString>::get(),
+              beans::PropertyAttribute::MAYBEVOID, 0 },
+            { u"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
+    // 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");
+            if (rMedium.GetItemSet())
+            {
+                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(), xModelComp, u"meta.xml",
+                                              xContext, xInfoSet,
+                                              u"com.sun.star.comp.Math.MLOasisMetaImporter", 6);
+            else
+                nWarn
+                    = ReadThroughComponentS(rMedium.GetStorage(), xModelComp, 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(), xModelComp, u"settings.xml",
+                                          xContext, xInfoSet,
+                                          u"com.sun.star.comp.Math.MLOasisSettingsImporter", 6);
+        else
+            nWarn
+                = ReadThroughComponentS(rMedium.GetStorage(), xModelComp, u"settings.xml", xContext,
+                                        xInfoSet, u"com.sun.star.comp.Math.XMLSettingsImporter", 5);
+
+        // Check if successful
+        if (nWarn == ERRCODE_IO_BROKENPACKAGE)
+        {
+            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(), xModelComp, u"content.xml", xContext,
+                                        xInfoSet, u"com.sun.star.comp.Math.XMLImporter", 5);
+        else
+            nWarn
+                = ReadThroughComponentS(rMedium.GetStorage(), xModelComp, 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, xModelComp, xContext, xInfoSet,
+                                            u"com.sun.star.comp.Math.XMLImporter", false, 5);
+        else
+            nError = ReadThroughComponentIS(xInputStream, xModelComp, 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 = comphelper::getFromUnoTunnel<SmModel>(m_xModel);
+    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", 0, cppu::UnoType<XInterface>::get(),
+              beans::PropertyAttribute::MAYBEVOID, 0 },
+            { u"BaseURI", 0, ::cppu::UnoType<OUString>::get(), beans::PropertyAttribute::MAYBEVOID,
+              0 },
+            { u"StreamRelPath", 0, ::cppu::UnoType<OUString>::get(),
+              beans::PropertyAttribute::MAYBEVOID, 0 },
+            { u"StreamName", 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 = comphelper::getFromUnoTunnel<SmXMLImport>(xFilter);
+            if (pXMlImport != nullptr && pXMlImport->GetSuccess())
+                return ERRCODE_NONE;
+            else
+            {
+                SAL_WARN("starmath", "Filter failed on file input");
+                return ERRCODE_SFX_DOLOADFAILED;
+            }
+        }
+
+        m_pMlImport = comphelper::getFromUnoTunnel<SmMLImport>(xFilter);
+        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%") };
+                }
+                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
+/*************************************************************************************************/
+
+const uno::Sequence<sal_Int8>& SmMLImport::getUnoTunnelId() noexcept
+{
+    static const comphelper::UnoIdInit theSmMLImportUnoTunnelId;
+    return theSmMLImportUnoTunnelId.getSeq();
+}
+
+sal_Int64 SAL_CALL SmMLImport::getSomething(const uno::Sequence<sal_Int8>& rId)
+{
+    return comphelper::getSomethingImpl(rId, this,
+                                        comphelper::FallbackToGetSomethingOf<SvXMLImport>{});
+}
+
+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 const OUStringLiteral sFormula(u"Formula");
+    static const OUStringLiteral sBasicLibraries(u"BasicLibraries");
+    static const 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 000000000..24de35c18
--- /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 000000000..fb76b070e
--- /dev/null
+++ b/starmath/source/mathml/mathmlMo.cxx
@@ -0,0 +1,1127 @@
+/* -*- 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", moOpDF::prefix, 10, 0, 0, moOpDP::fence | moOpDP::nonedp },
+        { u"\u2019", moOpDF::postfix, 10, 0, 0, moOpDP::fence | moOpDP::nonedp },
+        { u"\u201C", moOpDF::prefix, 10, 0, 0, moOpDP::fence | moOpDP::nonedp },
+        { u"\u201D", moOpDF::postfix, 10, 0, 0, moOpDP::fence | moOpDP::nonedp },
+        { u"(", moOpDF::prefix, 20, 0, 0, moOpDP::stretchyfence | moOpDP::symmetric },
+        { u")", moOpDF::postfix, 20, 0, 0, moOpDP::stretchyfence | moOpDP::symmetric },
+        { u"[", moOpDF::prefix, 20, 0, 0, moOpDP::stretchyfence | moOpDP::symmetric },
+        { u"]", moOpDF::postfix, 20, 0, 0, moOpDP::stretchyfence | moOpDP::symmetric },
+        { u"{", moOpDF::prefix, 20, 0, 0, moOpDP::stretchyfence | moOpDP::symmetric },
+        { u"|", moOpDF::prepostfix, 20, 0, 0, moOpDP::stretchyfence | moOpDP::symmetric },
+        { u"||", moOpDF::prepostfix, 20, 0, 0, moOpDP::stretchyfence | moOpDP::symmetric },
+        { u"|||", moOpDF::prepostfix, 20, 0, 0, moOpDP::stretchyfence | moOpDP::symmetric },
+        { u"}", moOpDF::postfix, 20, 0, 0, moOpDP::stretchyfence | moOpDP::symmetric },
+        { u"\u2016", moOpDF::prepostfix, 20, 0, 0, moOpDP::stretchyfence },
+        { u"\u2308", moOpDF::prefix, 20, 0, 0, moOpDP::stretchyfence | moOpDP::symmetric },
+        { u"\u2309", moOpDF::postfix, 20, 0, 0, moOpDP::stretchyfence | moOpDP::symmetric },
+        { u"\u230A", moOpDF::prefix, 20, 0, 0, moOpDP::stretchyfence | moOpDP::symmetric },
+        { u"\u230B", moOpDF::postfix, 20, 0, 0, moOpDP::stretchyfence | moOpDP::symmetric },
+        { u"\u2329", moOpDF::prefix, 20, 0, 0, moOpDP::stretchyfence | moOpDP::symmetric },
+        { u"\u232A", moOpDF::postfix, 20, 0, 0, moOpDP::stretchyfence | moOpDP::symmetric },
+        { u"\u2772", moOpDF::prefix, 20, 0, 0, moOpDP::stretchyfence | moOpDP::symmetric },
+        { u"\u2773", moOpDF::postfix, 20, 0, 0, moOpDP::stretchyfence | moOpDP::symmetric },
+        { u"\u27E6", moOpDF::prefix, 20, 0, 0, moOpDP::stretchyfence | moOpDP::symmetric },
+        { u"\u27E7", moOpDF::postfix, 20, 0, 0, moOpDP::stretchyfence | moOpDP::symmetric },
+        { u"\u27E8", moOpDF::prefix, 20, 0, 0, moOpDP::stretchyfence | moOpDP::symmetric },
+        { u"\u27E9", moOpDF::postfix, 20, 0, 0, moOpDP::stretchyfence | moOpDP::symmetric },
+        { u"\u27EA", moOpDF::prefix, 20, 0, 0, moOpDP::stretchyfence | moOpDP::symmetric },
+        { u"\u27EB", moOpDF::postfix, 20, 0, 0, moOpDP::stretchyfence | moOpDP::symmetric },
+        { u"\u27EC", moOpDF::prefix, 20, 0, 0, moOpDP::stretchyfence | moOpDP::symmetric },
+        { u"\u27ED", moOpDF::postfix, 20, 0, 0, moOpDP::stretchyfence | moOpDP::symmetric },
+        { u"\u27EE", moOpDF::prefix, 20, 0, 0, moOpDP::stretchyfence | moOpDP::symmetric },
+        { u"\u27EF", moOpDF::postfix, 20, 0, 0, moOpDP::stretchyfence | moOpDP::symmetric },
+        { u"\u2980", moOpDF::prepostfix, 20, 0, 0, moOpDP::stretchyfence },
+        { u"\u2983", moOpDF::prefix, 20, 0, 0, moOpDP::stretchyfence | moOpDP::symmetric },
+        { u"\u2984", moOpDF::postfix, 20, 0, 0, moOpDP::stretchyfence | moOpDP::symmetric },
+        { u"\u2985", moOpDF::prefix, 20, 0, 0, moOpDP::stretchyfence | moOpDP::symmetric },
+        { u"\u2986", moOpDF::postfix, 20, 0, 0, moOpDP::stretchyfence | moOpDP::symmetric },
+        { u"\u2987", moOpDF::prefix, 20, 0, 0, moOpDP::stretchyfence | moOpDP::symmetric },
+        { u"\u2988", moOpDF::postfix, 20, 0, 0, moOpDP::stretchyfence | moOpDP::symmetric },
+        { u"\u2989", moOpDF::prefix, 20, 0, 0, moOpDP::stretchyfence | moOpDP::symmetric },
+        { u"\u298A", moOpDF::postfix, 20, 0, 0, moOpDP::stretchyfence | moOpDP::symmetric },
+        { u"\u298B", moOpDF::prefix, 20, 0, 0, moOpDP::stretchyfence | moOpDP::symmetric },
+        { u"\u298C", moOpDF::postfix, 20, 0, 0, moOpDP::stretchyfence | moOpDP::symmetric },
+        { u"\u298D", moOpDF::prefix, 20, 0, 0, moOpDP::stretchyfence | moOpDP::symmetric },
+        { u"\u298E", moOpDF::postfix, 20, 0, 0, moOpDP::stretchyfence | moOpDP::symmetric },
+        { u"\u298F", moOpDF::prefix, 20, 0, 0, moOpDP::stretchyfence | moOpDP::symmetric },
+        { u"\u2990", moOpDF::postfix, 20, 0, 0, moOpDP::stretchyfence | moOpDP::symmetric },
+        { u"\u2991", moOpDF::prefix, 20, 0, 0, moOpDP::stretchyfence | moOpDP::symmetric },
+        { u"\u2992", moOpDF::postfix, 20, 0, 0, moOpDP::stretchyfence | moOpDP::symmetric },
+        { u"\u2993", moOpDF::prefix, 20, 0, 0, moOpDP::stretchyfence | moOpDP::symmetric },
+        { u"\u2994", moOpDF::postfix, 20, 0, 0, moOpDP::stretchyfence | moOpDP::symmetric },
+        { u"\u2995", moOpDF::prefix, 20, 0, 0, moOpDP::stretchyfence | moOpDP::symmetric },
+        { u"\u2996", moOpDF::postfix, 20, 0, 0, moOpDP::stretchyfence | moOpDP::symmetric },
+        { u"\u2997", moOpDF::prefix, 20, 0, 0, moOpDP::stretchyfence | moOpDP::symmetric },
+        { u"\u2998", moOpDF::postfix, 20, 0, 0, moOpDP::stretchyfence | moOpDP::symmetric },
+        { u"\u29FC", moOpDF::prefix, 20, 0, 0, moOpDP::stretchyfence | moOpDP::symmetric },
+        { u"\u29FD", moOpDF::postfix, 20, 0, 0, moOpDP::stretchyfence | moOpDP::symmetric },
+        { u";", moOpDF::infix, 30, 0, 3, moOpDP::separator | moOpDP::linebreakstyleAfter },
+        { u",", moOpDF::infix, 40, 0, 3, moOpDP::separator | moOpDP::linebreakstyleAfter },
+        { u"\u2063", moOpDF::infix, 40, 0, 0, moOpDP::separator | moOpDP::linebreakstyleAfter },
+        { u"\u2234", moOpDF::infix, 70, 5, 5, moOpDP::nonedp },
+        { u"\u2235", moOpDF::infix, 70, 5, 5, moOpDP::nonedp },
+        { u"->", moOpDF::infix, 90, 5, 5, moOpDP::nonedp },
+        { u"..", moOpDF::postfix, 100, 0, 0, moOpDP::nonedp },
+        { u"...", moOpDF::postfix, 100, 0, 0, moOpDP::nonedp },
+        { u":", moOpDF::infix, 100, 1, 2, moOpDP::nonedp },
+        { u"\u03F6", moOpDF::infix, 110, 5, 5, moOpDP::nonedp },
+        { u"\u2026", moOpDF::infix, 150, 0, 0, moOpDP::nonedp },
+        { u"\u22EE", moOpDF::infix, 150, 5, 5, moOpDP::nonedp },
+        { u"\u22EF", moOpDF::infix, 150, 0, 0, moOpDP::nonedp },
+        { u"\u22F1", moOpDF::infix, 150, 5, 5, moOpDP::nonedp },
+        { u"\u220B", moOpDF::infix, 160, 5, 5, moOpDP::nonedp },
+        { u"\u22A2", moOpDF::infix, 170, 5, 5, moOpDP::nonedp },
+        { u"\u22A3", moOpDF::infix, 170, 5, 5, moOpDP::nonedp },
+        { u"\u22A4", moOpDF::infix, 170, 5, 5, moOpDP::nonedp },
+        { u"\u22A8", moOpDF::infix, 170, 5, 5, moOpDP::nonedp },
+        { u"\u22A9", moOpDF::infix, 170, 5, 5, moOpDP::nonedp },
+        { u"\u22AC", moOpDF::infix, 170, 5, 5, moOpDP::nonedp },
+        { u"\u22AD", moOpDF::infix, 170, 5, 5, moOpDP::nonedp },
+        { u"\u22AE", moOpDF::infix, 170, 5, 5, moOpDP::nonedp },
+        { u"\u22AF", moOpDF::infix, 170, 5, 5, moOpDP::nonedp },
+        { u"\u2228", moOpDF::infix, 190, 4, 4, moOpDP::nonedp },
+        { u"&&", moOpDF::infix, 200, 4, 4, moOpDP::nonedp },
+        { u"\u2227", moOpDF::infix, 200, 4, 4, moOpDP::nonedp },
+        { u"\u2200", moOpDF::prefix, 230, 2, 1, moOpDP::nonedp },
+        { u"\u2203", moOpDF::prefix, 230, 2, 1, moOpDP::nonedp },
+        { u"\u2204", moOpDF::prefix, 230, 2, 1, moOpDP::nonedp },
+        { u"\u2201", moOpDF::infix, 240, 1, 2, moOpDP::nonedp },
+        { u"\u2208", moOpDF::infix, 240, 5, 5, moOpDP::nonedp },
+        { u"\u2209", moOpDF::infix, 240, 5, 5, moOpDP::nonedp },
+        { u"\u220C", moOpDF::infix, 240, 5, 5, moOpDP::nonedp },
+        { u"\u2282", moOpDF::infix, 240, 5, 5, moOpDP::nonedp },
+        { u"\u2282\u20D2", moOpDF::infix, 240, 5, 5, moOpDP::nonedp },
+        { u"\u2283", moOpDF::infix, 240, 5, 5, moOpDP::nonedp },
+        { u"\u2283\u20D2", moOpDF::infix, 240, 5, 5, moOpDP::nonedp },
+        { u"\u2284", moOpDF::infix, 240, 5, 5, moOpDP::nonedp },
+        { u"\u2285", moOpDF::infix, 240, 5, 5, moOpDP::nonedp },
+        { u"\u2286", moOpDF::infix, 240, 5, 5, moOpDP::nonedp },
+        { u"\u2287", moOpDF::infix, 240, 5, 5, moOpDP::nonedp },
+        { u"\u2288", moOpDF::infix, 240, 5, 5, moOpDP::nonedp },
+        { u"\u2289", moOpDF::infix, 240, 5, 5, moOpDP::nonedp },
+        { u"\u228A", moOpDF::infix, 240, 5, 5, moOpDP::nonedp },
+        { u"\u228B", moOpDF::infix, 240, 5, 5, moOpDP::nonedp },
+        { u"<=", moOpDF::infix, 241, 5, 5, moOpDP::nonedp },
+        { u"\u2264", moOpDF::infix, 241, 5, 5, moOpDP::nonedp },
+        { u"\u2265", moOpDF::infix, 242, 5, 5, moOpDP::nonedp },
+        { u">", moOpDF::infix, 243, 5, 5, moOpDP::nonedp },
+        { u">=", moOpDF::infix, 243, 5, 5, moOpDP::nonedp },
+        { u"\u226F", moOpDF::infix, 244, 5, 5, moOpDP::nonedp },
+        { u"&lt", moOpDF::infix, 245, 5, 5, moOpDP::nonedp },
+        { u"\u226E", moOpDF::infix, 246, 5, 5, moOpDP::nonedp },
+        { u"\u2248", moOpDF::infix, 247, 5, 5, moOpDP::nonedp },
+        { u"\u223C", moOpDF::infix, 250, 5, 5, moOpDP::nonedp },
+        { u"\u2249", moOpDF::infix, 250, 5, 5, moOpDP::nonedp },
+        { u"\u2262", moOpDF::infix, 252, 5, 5, moOpDP::nonedp },
+        { u"\u2260", moOpDF::infix, 255, 5, 5, moOpDP::nonedp },
+        { u"!=", moOpDF::infix, 260, 4, 4, moOpDP::nonedp },
+        { u"*=", moOpDF::infix, 260, 4, 4, moOpDP::nonedp },
+        { u"+=", moOpDF::infix, 260, 4, 4, moOpDP::nonedp },
+        { u"-=", moOpDF::infix, 260, 4, 4, moOpDP::nonedp },
+        { u"/=", moOpDF::infix, 260, 4, 4, moOpDP::nonedp },
+        { u":=", moOpDF::infix, 260, 4, 4, moOpDP::nonedp },
+        { u"=", moOpDF::infix, 260, 5, 5, moOpDP::nonedp },
+        { u"==", moOpDF::infix, 260, 4, 4, moOpDP::nonedp },
+        { u"\u221D", moOpDF::infix, 260, 5, 5, moOpDP::nonedp },
+        { u"\u2224", moOpDF::infix, 260, 5, 5, moOpDP::nonedp },
+        { u"\u2225", moOpDF::infix, 260, 5, 5, moOpDP::nonedp },
+        { u"\u2226", moOpDF::infix, 260, 5, 5, moOpDP::nonedp },
+        { u"\u2241", moOpDF::infix, 260, 5, 5, moOpDP::nonedp },
+        { u"\u2243", moOpDF::infix, 260, 5, 5, moOpDP::nonedp },
+        { u"\u2244", moOpDF::infix, 260, 5, 5, moOpDP::nonedp },
+        { u"\u2245", moOpDF::infix, 260, 5, 5, moOpDP::nonedp },
+        { u"\u2246", moOpDF::infix, 260, 5, 5, moOpDP::nonedp },
+        { u"\u2247", moOpDF::infix, 260, 5, 5, moOpDP::nonedp },
+        { u"\u224D", moOpDF::infix, 260, 5, 5, moOpDP::nonedp },
+        { u"\u2254", moOpDF::infix, 260, 5, 5, moOpDP::nonedp },
+        { u"\u2257", moOpDF::infix, 260, 5, 5, moOpDP::nonedp },
+        { u"\u2259", moOpDF::infix, 260, 5, 5, moOpDP::nonedp },
+        { u"\u225A", moOpDF::infix, 260, 5, 5, moOpDP::nonedp },
+        { u"\u225B", moOpDF::infix, 260, 5, 5, moOpDP::nonedp },
+        { u"\u225C", moOpDF::infix, 260, 5, 5, moOpDP::nonedp },
+        { u"\u225F", moOpDF::infix, 260, 5, 5, moOpDP::nonedp },
+        { u"\u2261", moOpDF::infix, 260, 5, 5, moOpDP::nonedp },
+        { u"\u2268", moOpDF::infix, 260, 5, 5, moOpDP::nonedp },
+        { u"\u2269", moOpDF::infix, 260, 5, 5, moOpDP::nonedp },
+        { u"\u226A", moOpDF::infix, 260, 5, 5, moOpDP::nonedp },
+        { u"\u226A\u0338", moOpDF::infix, 260, 5, 5, moOpDP::nonedp },
+        { u"\u226B", moOpDF::infix, 260, 5, 5, moOpDP::nonedp },
+        { u"\u226B\u0338", moOpDF::infix, 260, 5, 5, moOpDP::nonedp },
+        { u"\u226D", moOpDF::infix, 260, 5, 5, moOpDP::nonedp },
+        { u"\u2270", moOpDF::infix, 260, 5, 5, moOpDP::nonedp },
+        { u"\u2271", moOpDF::infix, 260, 5, 5, moOpDP::nonedp },
+        { u"\u227A", moOpDF::infix, 260, 5, 5, moOpDP::nonedp },
+        { u"\u227B", moOpDF::infix, 260, 5, 5, moOpDP::nonedp },
+        { u"\u227C", moOpDF::infix, 260, 5, 5, moOpDP::nonedp },
+        { u"\u227D", moOpDF::infix, 260, 5, 5, moOpDP::nonedp },
+        { u"\u2280", moOpDF::infix, 260, 5, 5, moOpDP::nonedp },
+        { u"\u2281", moOpDF::infix, 260, 5, 5, moOpDP::nonedp },
+        { u"\u22A5", moOpDF::infix, 260, 5, 5, moOpDP::nonedp },
+        { u"\u22B4", moOpDF::infix, 260, 5, 5, moOpDP::nonedp },
+        { u"\u22B5", moOpDF::infix, 260, 5, 5, moOpDP::nonedp },
+        { u"\u22C9", moOpDF::infix, 260, 4, 4, moOpDP::nonedp },
+        { u"\u22CA", moOpDF::infix, 260, 4, 4, moOpDP::nonedp },
+        { u"\u22CB", moOpDF::infix, 260, 4, 4, moOpDP::nonedp },
+        { u"\u22CC", moOpDF::infix, 260, 4, 4, moOpDP::nonedp },
+        { u"\u22D4", moOpDF::infix, 260, 5, 5, moOpDP::nonedp },
+        { u"\u22D6", moOpDF::infix, 260, 5, 5, moOpDP::nonedp },
+        { u"\u22D7", moOpDF::infix, 260, 5, 5, moOpDP::nonedp },
+        { u"\u22D8", moOpDF::infix, 260, 5, 5, moOpDP::nonedp },
+        { u"\u22D9", moOpDF::infix, 260, 5, 5, moOpDP::nonedp },
+        { u"\u22EA", moOpDF::infix, 260, 5, 5, moOpDP::nonedp },
+        { u"\u22EB", moOpDF::infix, 260, 5, 5, moOpDP::nonedp },
+        { u"\u22EC", moOpDF::infix, 260, 5, 5, moOpDP::nonedp },
+        { u"\u22ED", moOpDF::infix, 260, 5, 5, moOpDP::nonedp },
+        { u"\u25A0", moOpDF::infix, 260, 3, 3, moOpDP::nonedp },
+        { u"\u25A1", moOpDF::infix, 260, 3, 3, moOpDP::nonedp },
+        { u"\u25AA", moOpDF::infix, 260, 3, 3, moOpDP::nonedp },
+        { u"\u25AB", moOpDF::infix, 260, 3, 3, moOpDP::nonedp },
+        { u"\u25AD", moOpDF::infix, 260, 3, 3, moOpDP::nonedp },
+        { u"\u25AE", moOpDF::infix, 260, 3, 3, moOpDP::nonedp },
+        { u"\u25AF", moOpDF::infix, 260, 3, 3, moOpDP::nonedp },
+        { u"\u25B0", moOpDF::infix, 260, 3, 3, moOpDP::nonedp },
+        { u"\u25B1", moOpDF::infix, 260, 3, 3, moOpDP::nonedp },
+        { u"\u25B3", moOpDF::infix, 260, 4, 4, moOpDP::nonedp },
+        { u"\u25B4", moOpDF::infix, 260, 4, 4, moOpDP::nonedp },
+        { u"\u25B5", moOpDF::infix, 260, 4, 4, moOpDP::nonedp },
+        { u"\u25B6", moOpDF::infix, 260, 4, 4, moOpDP::nonedp },
+        { u"\u25B7", moOpDF::infix, 260, 4, 4, moOpDP::nonedp },
+        { u"\u25B8", moOpDF::infix, 260, 4, 4, moOpDP::nonedp },
+        { u"\u25B9", moOpDF::infix, 260, 4, 4, moOpDP::nonedp },
+        { u"\u25BC", moOpDF::infix, 260, 4, 4, moOpDP::nonedp },
+        { u"\u25BD", moOpDF::infix, 260, 4, 4, moOpDP::nonedp },
+        { u"\u25BE", moOpDF::infix, 260, 4, 4, moOpDP::nonedp },
+        { u"\u25BF", moOpDF::infix, 260, 4, 4, moOpDP::nonedp },
+        { u"\u25C0", moOpDF::infix, 260, 4, 4, moOpDP::nonedp },
+        { u"\u25C1", moOpDF::infix, 260, 4, 4, moOpDP::nonedp },
+        { u"\u25C2", moOpDF::infix, 260, 4, 4, moOpDP::nonedp },
+        { u"\u25C3", moOpDF::infix, 260, 4, 4, moOpDP::nonedp },
+        { u"\u25C4", moOpDF::infix, 260, 4, 4, moOpDP::nonedp },
+        { u"\u25C5", moOpDF::infix, 260, 4, 4, moOpDP::nonedp },
+        { u"\u25C6", moOpDF::infix, 260, 4, 4, moOpDP::nonedp },
+        { u"\u25C7", moOpDF::infix, 260, 4, 4, moOpDP::nonedp },
+        { u"\u25C8", moOpDF::infix, 260, 4, 4, moOpDP::nonedp },
+        { u"\u25C9", moOpDF::infix, 260, 4, 4, moOpDP::nonedp },
+        { u"\u25CC", moOpDF::infix, 260, 4, 4, moOpDP::nonedp },
+        { u"\u25CD", moOpDF::infix, 260, 4, 4, moOpDP::nonedp },
+        { u"\u25CE", moOpDF::infix, 260, 4, 4, moOpDP::nonedp },
+        { u"\u25CF", moOpDF::infix, 260, 4, 4, moOpDP::nonedp },
+        { u"\u25D6", moOpDF::infix, 260, 4, 4, moOpDP::nonedp },
+        { u"\u25D7", moOpDF::infix, 260, 4, 4, moOpDP::nonedp },
+        { u"\u25E6", moOpDF::infix, 260, 4, 4, moOpDP::nonedp },
+        { u"\u29C0", moOpDF::infix, 260, 5, 5, moOpDP::nonedp },
+        { u"\u29C1", moOpDF::infix, 260, 5, 5, moOpDP::nonedp },
+        { u"\u29E3", moOpDF::infix, 260, 5, 5, moOpDP::nonedp },
+        { u"\u29E4", moOpDF::infix, 260, 5, 5, moOpDP::nonedp },
+        { u"\u29E5", moOpDF::infix, 260, 5, 5, moOpDP::nonedp },
+        { u"\u29E6", moOpDF::infix, 260, 5, 5, moOpDP::nonedp },
+        { u"\u29F3", moOpDF::infix, 260, 3, 3, moOpDP::nonedp },
+        { u"\u2A87", moOpDF::infix, 260, 5, 5, moOpDP::nonedp },
+        { u"\u2A88", moOpDF::infix, 260, 5, 5, moOpDP::nonedp },
+        { u"\u2AAF", moOpDF::infix, 260, 5, 5, moOpDP::nonedp },
+        { u"\u2AAF\u0338", moOpDF::infix, 260, 5, 5, moOpDP::nonedp },
+        { u"\u2AB0", moOpDF::infix, 260, 5, 5, moOpDP::nonedp },
+        { u"\u2AB0\u0338", moOpDF::infix, 260, 5, 5, moOpDP::nonedp },
+        { u"\u2044", moOpDF::infix, 265, 4, 4, moOpDP::stretchy },
+        { u"\u2206", moOpDF::infix, 265, 3, 3, moOpDP::nonedp },
+        { u"\u220A", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u220D", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u220E", moOpDF::infix, 265, 3, 3, moOpDP::nonedp },
+        { u"\u2215", moOpDF::infix, 265, 4, 4, moOpDP::stretchy },
+        { u"\u2217", moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u2218", moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u2219", moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u221F", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2223", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2236", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2237", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2238", moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u2239", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u223A", moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u223B", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u223D", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u223D\u0331", moOpDF::infix, 265, 3, 3, moOpDP::nonedp },
+        { u"\u223E", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u223F", moOpDF::infix, 265, 3, 3, moOpDP::nonedp },
+        { u"\u2242", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2242\u0338", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u224A", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u224B", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u224C", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u224E", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u224E\u0338", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u224F", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u224F\u0338", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2250", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2251", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2252", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2253", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2255", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2256", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2258", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u225D", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u225E", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2263", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2266", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2266\u0338", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2267", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u226C", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2272", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2273", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2274", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2275", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2276", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2277", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2278", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2279", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u227E", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u227F", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u227F\u0338", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u228C", moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u228D", moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u228E", moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u228F", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u228F\u0338", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2290", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2290\u0338", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2291", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2292", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2293", moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u2294", moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u229A", moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u229B", moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u229C", moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u229D", moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u22A6", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u22A7", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u22AA", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u22AB", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u22B0", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u22B1", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u22B2", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u22B3", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u22B6", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u22B7", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u22B9", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u22BA", moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u22BB", moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u22BC", moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u22BD", moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u22BE", moOpDF::infix, 265, 3, 3, moOpDP::nonedp },
+        { u"\u22BF", moOpDF::infix, 265, 3, 3, moOpDP::nonedp },
+        { u"\u22C4", moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u22C6", moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u22C7", moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u22C8", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u22CD", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u22CE", moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u22CF", moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u22D0", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u22D1", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u22D2", moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u22D3", moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u22D5", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u22DA", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u22DB", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u22DC", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u22DD", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u22DE", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u22DF", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u22E0", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u22E1", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u22E2", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u22E3", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u22E4", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u22E5", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u22E6", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u22E7", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u22E8", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u22E9", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u22F0", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u22F2", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u22F3", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u22F4", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u22F5", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u22F6", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u22F7", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u22F8", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u22F9", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u22FA", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u22FB", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u22FC", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u22FD", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u22FE", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u22FF", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u25B2", moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u2758", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2981", moOpDF::infix, 265, 3, 3, moOpDP::nonedp },
+        { u"\u2982", moOpDF::infix, 265, 3, 3, moOpDP::nonedp },
+        { u"\u29A0", moOpDF::infix, 265, 3, 3, moOpDP::nonedp },
+        { u"\u29A1", moOpDF::infix, 265, 3, 3, moOpDP::nonedp },
+        { u"\u29A2", moOpDF::infix, 265, 3, 3, moOpDP::nonedp },
+        { u"\u29A3", moOpDF::infix, 265, 3, 3, moOpDP::nonedp },
+        { u"\u29A4", moOpDF::infix, 265, 3, 3, moOpDP::nonedp },
+        { u"\u29A5", moOpDF::infix, 265, 3, 3, moOpDP::nonedp },
+        { u"\u29A6", moOpDF::infix, 265, 3, 3, moOpDP::nonedp },
+        { u"\u29A7", moOpDF::infix, 265, 3, 3, moOpDP::nonedp },
+        { u"\u29A8", moOpDF::infix, 265, 3, 3, moOpDP::nonedp },
+        { u"\u29A9", moOpDF::infix, 265, 3, 3, moOpDP::nonedp },
+        { u"\u29AA", moOpDF::infix, 265, 3, 3, moOpDP::nonedp },
+        { u"\u29AB", moOpDF::infix, 265, 3, 3, moOpDP::nonedp },
+        { u"\u29AC", moOpDF::infix, 265, 3, 3, moOpDP::nonedp },
+        { u"\u29AD", moOpDF::infix, 265, 3, 3, moOpDP::nonedp },
+        { u"\u29AE", moOpDF::infix, 265, 3, 3, moOpDP::nonedp },
+        { u"\u29AF", moOpDF::infix, 265, 3, 3, moOpDP::nonedp },
+        { u"\u29B0", moOpDF::infix, 265, 3, 3, moOpDP::nonedp },
+        { u"\u29B1", moOpDF::infix, 265, 3, 3, moOpDP::nonedp },
+        { u"\u29B2", moOpDF::infix, 265, 3, 3, moOpDP::nonedp },
+        { u"\u29B3", moOpDF::infix, 265, 3, 3, moOpDP::nonedp },
+        { u"\u29B4", moOpDF::infix, 265, 3, 3, moOpDP::nonedp },
+        { u"\u29B5", moOpDF::infix, 265, 3, 3, moOpDP::nonedp },
+        { u"\u29B6", moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u29B7", moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u29B8", moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u29B9", moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u29BA", moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u29BB", moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u29BC", moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u29BD", moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u29BE", moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u29BF", moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u29C2", moOpDF::infix, 265, 3, 3, moOpDP::nonedp },
+        { u"\u29C3", moOpDF::infix, 265, 3, 3, moOpDP::nonedp },
+        { u"\u29C4", moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u29C5", moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u29C6", moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u29C7", moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u29C8", moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u29C9", moOpDF::infix, 265, 3, 3, moOpDP::nonedp },
+        { u"\u29CA", moOpDF::infix, 265, 3, 3, moOpDP::nonedp },
+        { u"\u29CB", moOpDF::infix, 265, 3, 3, moOpDP::nonedp },
+        { u"\u29CC", moOpDF::infix, 265, 3, 3, moOpDP::nonedp },
+        { u"\u29CD", moOpDF::infix, 265, 3, 3, moOpDP::nonedp },
+        { u"\u29CE", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u29CF", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u29CF\u0338", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u29D0", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u29D0\u0338", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u29D1", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u29D2", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u29D3", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u29D4", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u29D5", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u29D6", moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u29D7", moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u29D8", moOpDF::infix, 265, 3, 3, moOpDP::nonedp },
+        { u"\u29D9", moOpDF::infix, 265, 3, 3, moOpDP::nonedp },
+        { u"\u29DB", moOpDF::infix, 265, 3, 3, moOpDP::nonedp },
+        { u"\u29DC", moOpDF::infix, 265, 3, 3, moOpDP::nonedp },
+        { u"\u29DD", moOpDF::infix, 265, 3, 3, moOpDP::nonedp },
+        { u"\u29DE", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u29E0", moOpDF::infix, 265, 3, 3, moOpDP::nonedp },
+        { u"\u29E1", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u29E2", moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u29E7", moOpDF::infix, 265, 3, 3, moOpDP::nonedp },
+        { u"\u29E8", moOpDF::infix, 265, 3, 3, moOpDP::nonedp },
+        { u"\u29E9", moOpDF::infix, 265, 3, 3, moOpDP::nonedp },
+        { u"\u29EA", moOpDF::infix, 265, 3, 3, moOpDP::nonedp },
+        { u"\u29EB", moOpDF::infix, 265, 3, 3, moOpDP::nonedp },
+        { u"\u29EC", moOpDF::infix, 265, 3, 3, moOpDP::nonedp },
+        { u"\u29ED", moOpDF::infix, 265, 3, 3, moOpDP::nonedp },
+        { u"\u29EE", moOpDF::infix, 265, 3, 3, moOpDP::nonedp },
+        { u"\u29F0", moOpDF::infix, 265, 3, 3, moOpDP::nonedp },
+        { u"\u29F1", moOpDF::infix, 265, 3, 3, moOpDP::nonedp },
+        { u"\u29F2", moOpDF::infix, 265, 3, 3, moOpDP::nonedp },
+        { u"\u29F5", moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u29F6", moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u29F7", moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u29F8", moOpDF::infix, 265, 3, 3, moOpDP::nonedp },
+        { u"\u29F9", moOpDF::infix, 265, 3, 3, moOpDP::nonedp },
+        { u"\u29FA", moOpDF::infix, 265, 3, 3, moOpDP::nonedp },
+        { u"\u29FB", moOpDF::infix, 265, 3, 3, moOpDP::nonedp },
+        { u"\u29FE", moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u29FF", moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u2A1D", moOpDF::infix, 265, 3, 3, moOpDP::nonedp },
+        { u"\u2A1E", moOpDF::infix, 265, 3, 3, moOpDP::nonedp },
+        { u"\u2A1F", moOpDF::infix, 265, 3, 3, moOpDP::nonedp },
+        { u"\u2A20", moOpDF::infix, 265, 3, 3, moOpDP::nonedp },
+        { u"\u2A21", moOpDF::infix, 265, 3, 3, moOpDP::nonedp },
+        { u"\u2A22", moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u2A23", moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u2A24", moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u2A25", moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u2A26", moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u2A27", moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u2A28", moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u2A29", moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u2A2A", moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u2A2B", moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u2A2C", moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u2A2D", moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u2A2E", moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u2A30", moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u2A31", moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u2A32", moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u2A33", moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u2A34", moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u2A35", moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u2A36", moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u2A37", moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u2A38", moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u2A39", moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u2A3A", moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u2A3B", moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u2A3C", moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u2A3D", moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u2A3E", moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u2A40", moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u2A41", moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u2A42", moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u2A43", moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u2A44", moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u2A45", moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u2A46", moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u2A47", moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u2A48", moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u2A49", moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u2A4A", moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u2A4B", moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u2A4C", moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u2A4D", moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u2A4E", moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u2A4F", moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u2A50", moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u2A51", moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u2A52", moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u2A53", moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u2A54", moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u2A55", moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u2A56", moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u2A57", moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u2A58", moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u2A59", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2A5A", moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u2A5B", moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u2A5C", moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u2A5D", moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u2A5E", moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u2A5F", moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u2A60", moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u2A61", moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u2A62", moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u2A63", moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u2A64", moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u2A65", moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u2A66", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2A67", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2A68", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2A69", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2A6A", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2A6B", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2A6C", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2A6D", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2A6E", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2A6F", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2A70", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2A71", moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u2A72", moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u2A73", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2A74", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2A75", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2A76", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2A77", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2A78", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2A79", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2A7A", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2A7B", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2A7C", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2A7D", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2A7D\u0338", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2A7E", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2A7E\u0338", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2A7F", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2A80", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2A81", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2A82", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2A83", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2A84", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2A85", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2A86", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2A89", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2A8A", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2A8B", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2A8C", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2A8D", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2A8E", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2A8F", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2A90", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2A91", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2A92", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2A93", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2A94", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2A95", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2A96", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2A97", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2A98", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2A99", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2A9A", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2A9B", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2A9C", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2A9D", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2A9E", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2A9F", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2AA0", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2AA1", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2AA1\u0338", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2AA2", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2AA2\u0338", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2AA3", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2AA4", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2AA5", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2AA6", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2AA7", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2AA8", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2AA9", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2AAA", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2AAB", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2AAC", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2AAD", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2AAE", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2AB1", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2AB2", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2AB3", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2AB4", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2AB5", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2AB6", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2AB7", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2AB8", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2AB9", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2ABA", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2ABB", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2ABC", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2ABD", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2ABE", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2ABF", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2AC0", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2AC1", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2AC2", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2AC3", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2AC4", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2AC5", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2AC6", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2AC7", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2AC8", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2AC9", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2ACA", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2ACB", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2ACC", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2ACD", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2ACE", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2ACF", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2AD0", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2AD1", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2AD2", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2AD3", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2AD4", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2AD5", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2AD6", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2AD7", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2AD8", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2AD9", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2ADA", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2ADB", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2ADD", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2ADD\u0338", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2ADE", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2ADF", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2AE0", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2AE1", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2AE2", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2AE3", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2AE4", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2AE5", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2AE6", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2AE7", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2AE8", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2AE9", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2AEA", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2AEB", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2AEC", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2AED", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2AEE", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2AEF", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2AF0", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2AF1", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2AF2", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2AF3", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2AF4", moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u2AF5", moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u2AF6", moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u2AF7", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2AF8", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2AF9", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2AFA", moOpDF::infix, 265, 5, 5, moOpDP::nonedp },
+        { u"\u2AFB", moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u2AFD", moOpDF::infix, 265, 4, 4, moOpDP::nonedp },
+        { u"\u2AFE", moOpDF::infix, 265, 3, 3, moOpDP::nonedp },
+        { u"|", moOpDF::infix, 270, 2, 2, moOpDP::stretchyfence | moOpDP::symmetric },
+        { u"||", moOpDF::infix, 270, 2, 2, moOpDP::stretchyfence | moOpDP::symmetric },
+        { u"|||", moOpDF::infix, 270, 2, 2, moOpDP::stretchyfence | moOpDP::symmetric },
+        { u"\u2190", moOpDF::infix, 270, 5, 5, moOpDP::stretchy | moOpDP::accent },
+        { u"\u2191", moOpDF::infix, 270, 5, 5, moOpDP::stretchy },
+        { u"\u2192", moOpDF::infix, 270, 5, 5, moOpDP::stretchy | moOpDP::accent },
+        { u"\u2193", moOpDF::infix, 270, 5, 5, moOpDP::stretchy },
+        { u"\u2194", moOpDF::infix, 270, 5, 5, moOpDP::stretchy | moOpDP::accent },
+        { u"\u2195", moOpDF::infix, 270, 5, 5, moOpDP::stretchy },
+        { u"\u2196", moOpDF::infix, 270, 5, 5, moOpDP::stretchy },
+        { u"\u2197", moOpDF::infix, 270, 5, 5, moOpDP::stretchy },
+        { u"\u2198", moOpDF::infix, 270, 5, 5, moOpDP::stretchy },
+        { u"\u2199", moOpDF::infix, 270, 5, 5, moOpDP::stretchy },
+        { u"\u219A", moOpDF::infix, 270, 5, 5, moOpDP::accent },
+        { u"\u219B", moOpDF::infix, 270, 5, 5, moOpDP::accent },
+        { u"\u219C", moOpDF::infix, 270, 5, 5, moOpDP::stretchy | moOpDP::accent },
+        { u"\u219D", moOpDF::infix, 270, 5, 5, moOpDP::stretchy | moOpDP::accent },
+        { u"\u219E", moOpDF::infix, 270, 5, 5, moOpDP::stretchy | moOpDP::accent },
+        { u"\u219F", moOpDF::infix, 270, 5, 5, moOpDP::stretchy | moOpDP::accent },
+        { u"\u21A0", moOpDF::infix, 270, 5, 5, moOpDP::stretchy | moOpDP::accent },
+        { u"\u21A1", moOpDF::infix, 270, 5, 5, moOpDP::stretchy },
+        { u"\u21A2", moOpDF::infix, 270, 5, 5, moOpDP::stretchy | moOpDP::accent },
+        { u"\u21A3", moOpDF::infix, 270, 5, 5, moOpDP::stretchy | moOpDP::accent },
+        { u"\u21A4", moOpDF::infix, 270, 5, 5, moOpDP::stretchy | moOpDP::accent },
+        { u"\u21A5", moOpDF::infix, 270, 5, 5, moOpDP::stretchy },
+        { u"\u21A6", moOpDF::infix, 270, 5, 5, moOpDP::stretchy | moOpDP::accent },
+        { u"\u21A7", moOpDF::infix, 270, 5, 5, moOpDP::stretchy },
+        { u"\u21A8", moOpDF::infix, 270, 5, 5, moOpDP::stretchy },
+        { u"\u21A9", moOpDF::infix, 270, 5, 5, moOpDP::stretchy | moOpDP::accent },
+        { u"\u21AA", moOpDF::infix, 270, 5, 5, moOpDP::stretchy | moOpDP::accent },
+        { u"\u21AB", moOpDF::infix, 270, 5, 5, moOpDP::stretchy | moOpDP::accent },
+        { u"\u21AC", moOpDF::infix, 270, 5, 5, moOpDP::stretchy | moOpDP::accent },
+        { u"\u21AD", moOpDF::infix, 270, 5, 5, moOpDP::stretchy | moOpDP::accent },
+        { u"\u21AE", moOpDF::infix, 270, 5, 5, moOpDP::accent },
+        { u"\u21AF", moOpDF::infix, 270, 5, 5, moOpDP::stretchy },
+        { u"\u21B0", moOpDF::infix, 270, 5, 5, moOpDP::stretchy },
+        { u"\u21B1", moOpDF::infix, 270, 5, 5, moOpDP::stretchy },
+        { u"\u21B2", moOpDF::infix, 270, 5, 5, moOpDP::stretchy },
+        { u"\u21B3", moOpDF::infix, 270, 5, 5, moOpDP::stretchy },
+        { u"\u21B4", moOpDF::infix, 270, 5, 5, moOpDP::stretchy },
+        { u"\u21B5", moOpDF::infix, 270, 5, 5, moOpDP::stretchy },
+        { u"\u21B6", moOpDF::infix, 270, 5, 5, moOpDP::accent },
+        { u"\u21B7", moOpDF::infix, 270, 5, 5, moOpDP::accent },
+        { u"\u21B8", moOpDF::infix, 270, 5, 5, moOpDP::nonedp },
+        { u"\u21B9", moOpDF::infix, 270, 5, 5, moOpDP::stretchy | moOpDP::accent },
+        { u"\u21BA", moOpDF::infix, 270, 5, 5, moOpDP::nonedp },
+        { u"\u21BB", moOpDF::infix, 270, 5, 5, moOpDP::nonedp },
+        { u"\u21BC", moOpDF::infix, 270, 5, 5, moOpDP::stretchy | moOpDP::accent },
+        { u"\u21BD", moOpDF::infix, 270, 5, 5, moOpDP::stretchy | moOpDP::accent },
+        { u"\u21BE", moOpDF::infix, 270, 5, 5, moOpDP::stretchy },
+        { u"\u21BF", moOpDF::infix, 270, 5, 5, moOpDP::stretchy },
+        { u"\u21C0", moOpDF::infix, 270, 5, 5, moOpDP::stretchy | moOpDP::accent },
+        { u"\u21C1", moOpDF::infix, 270, 5, 5, moOpDP::stretchy | moOpDP::accent },
+        { u"\u21C2", moOpDF::infix, 270, 5, 5, moOpDP::stretchy },
+        { u"\u21C3", moOpDF::infix, 270, 5, 5, moOpDP::stretchy },
+        { u"\u21C4", moOpDF::infix, 270, 5, 5, moOpDP::stretchy | moOpDP::accent },
+        { u"\u21C5", moOpDF::infix, 270, 5, 5, moOpDP::stretchy },
+        { u"\u21C6", moOpDF::infix, 270, 5, 5, moOpDP::stretchy | moOpDP::accent },
+        { u"\u21C7", moOpDF::infix, 270, 5, 5, moOpDP::stretchy | moOpDP::accent },
+        { u"\u21C8", moOpDF::infix, 270, 5, 5, moOpDP::stretchy },
+        { u"\u21C9", moOpDF::infix, 270, 5, 5, moOpDP::stretchy | moOpDP::accent },
+        { u"\u21CA", moOpDF::infix, 270, 5, 5, moOpDP::stretchy },
+        { u"\u21CB", moOpDF::infix, 270, 5, 5, moOpDP::stretchy | moOpDP::accent },
+        { u"\u21CC", moOpDF::infix, 270, 5, 5, moOpDP::stretchy | moOpDP::accent },
+        { u"\u21CD", moOpDF::infix, 270, 5, 5, moOpDP::accent },
+        { u"\u21CE", moOpDF::infix, 270, 5, 5, moOpDP::accent },
+        { u"\u21CF", moOpDF::infix, 270, 5, 5, moOpDP::accent },
+        { u"\u21D0", moOpDF::infix, 270, 5, 5, moOpDP::stretchy | moOpDP::accent },
+        { u"\u21D1", moOpDF::infix, 270, 5, 5, moOpDP::stretchy },
+        { u"\u21D2", moOpDF::infix, 270, 5, 5, moOpDP::stretchy | moOpDP::accent },
+        { u"\u21D3", moOpDF::infix, 270, 5, 5, moOpDP::stretchy },
+        { u"\u21D4", moOpDF::infix, 270, 5, 5, moOpDP::stretchy | moOpDP::accent },
+        { u"\u21D5", moOpDF::infix, 270, 5, 5, moOpDP::stretchy },
+        { u"\u21D6", moOpDF::infix, 270, 5, 5, moOpDP::stretchy },
+        { u"\u21D7", moOpDF::infix, 270, 5, 5, moOpDP::stretchy },
+        { u"\u21D8", moOpDF::infix, 270, 5, 5, moOpDP::stretchy },
+        { u"\u21D9", moOpDF::infix, 270, 5, 5, moOpDP::stretchy },
+        { u"\u21DA", moOpDF::infix, 270, 5, 5, moOpDP::stretchy | moOpDP::accent },
+        { u"\u21DB", moOpDF::infix, 270, 5, 5, moOpDP::stretchy | moOpDP::accent },
+        { u"\u21DC", moOpDF::infix, 270, 5, 5, moOpDP::stretchy | moOpDP::accent },
+        { u"\u21DD", moOpDF::infix, 270, 5, 5, moOpDP::stretchy | moOpDP::accent },
+        { u"\u21DE", moOpDF::infix, 270, 5, 5, moOpDP::nonedp },
+        { u"\u21DF", moOpDF::infix, 270, 5, 5, moOpDP::nonedp },
+        { u"\u21E0", moOpDF::infix, 270, 5, 5, moOpDP::stretchy | moOpDP::accent },
+        { u"\u21E1", moOpDF::infix, 270, 5, 5, moOpDP::stretchy },
+        { u"\u21E2", moOpDF::infix, 270, 5, 5, moOpDP::stretchy | moOpDP::accent },
+        { u"\u21E3", moOpDF::infix, 270, 5, 5, moOpDP::stretchy },
+        { u"\u21E4", moOpDF::infix, 270, 5, 5, moOpDP::stretchy | moOpDP::accent },
+        { u"\u21E5", moOpDF::infix, 270, 5, 5, moOpDP::stretchy | moOpDP::accent },
+        { u"\u21E6", moOpDF::infix, 270, 5, 5, moOpDP::stretchy | moOpDP::accent },
+        { u"\u21E7", moOpDF::infix, 270, 5, 5, moOpDP::stretchy },
+        { u"\u21E8", moOpDF::infix, 270, 5, 5, moOpDP::stretchy | moOpDP::accent },
+        { u"\u21E9", moOpDF::infix, 270, 5, 5, moOpDP::stretchy },
+        { u"\u21EA", moOpDF::infix, 270, 5, 5, moOpDP::stretchy },
+        { u"\u21EB", moOpDF::infix, 270, 5, 5, moOpDP::stretchy },
+        { u"\u21EC", moOpDF::infix, 270, 5, 5, moOpDP::stretchy },
+        { u"\u21ED", moOpDF::infix, 270, 5, 5, moOpDP::stretchy },
+        { u"\u21EE", moOpDF::infix, 270, 5, 5, moOpDP::stretchy },
+        { u"\u21EF", moOpDF::infix, 270, 5, 5, moOpDP::stretchy },
+        { u"\u21F0", moOpDF::infix, 270, 5, 5, moOpDP::stretchy | moOpDP::accent },
+        { u"\u21F1", moOpDF::infix, 270, 5, 5, moOpDP::nonedp },
+        { u"\u21F2", moOpDF::infix, 270, 5, 5, moOpDP::nonedp },
+        { u"\u21F3", moOpDF::infix, 270, 5, 5, moOpDP::stretchy },
+        { u"\u21F4", moOpDF::infix, 270, 5, 5, moOpDP::accent },
+        { u"\u21F5", moOpDF::infix, 270, 5, 5, moOpDP::stretchy },
+        { u"\u21F6", moOpDF::infix, 270, 5, 5, moOpDP::stretchy | moOpDP::accent },
+        { u"\u21F7", moOpDF::infix, 270, 5, 5, moOpDP::accent },
+        { u"\u21F8", moOpDF::infix, 270, 5, 5, moOpDP::accent },
+        { u"\u21F9", moOpDF::infix, 270, 5, 5, moOpDP::accent },
+        { u"\u21FA", moOpDF::infix, 270, 5, 5, moOpDP::accent },
+        { u"\u21FB", moOpDF::infix, 270, 5, 5, moOpDP::accent },
+        { u"\u21FC", moOpDF::infix, 270, 5, 5, moOpDP::accent },
+        { u"\u21FD", moOpDF::infix, 270, 5, 5, moOpDP::stretchy | moOpDP::accent },
+        { u"\u21FE", moOpDF::infix, 270, 5, 5, moOpDP::stretchy | moOpDP::accent },
+        { u"\u21FF", moOpDF::infix, 270, 5, 5, moOpDP::stretchy | moOpDP::accent },
+        { u"\u22B8", moOpDF::infix, 270, 5, 5, moOpDP::nonedp },
+        { u"\u27F0", moOpDF::infix, 270, 5, 5, moOpDP::stretchy },
+        { u"\u27F1", moOpDF::infix, 270, 5, 5, moOpDP::stretchy },
+        { u"\u27F5", moOpDF::infix, 270, 5, 5, moOpDP::stretchy | moOpDP::accent },
+        { u"\u27F6", moOpDF::infix, 270, 5, 5, moOpDP::stretchy | moOpDP::accent },
+        { u"\u27F7", moOpDF::infix, 270, 5, 5, moOpDP::stretchy | moOpDP::accent },
+        { u"\u27F8", moOpDF::infix, 270, 5, 5, moOpDP::stretchy | moOpDP::accent },
+        { u"\u27F9", moOpDF::infix, 270, 5, 5, moOpDP::stretchy | moOpDP::accent },
+        { u"\u27FA", moOpDF::infix, 270, 5, 5, moOpDP::stretchy | moOpDP::accent },
+        { u"\u27FB", moOpDF::infix, 270, 5, 5, moOpDP::stretchy | moOpDP::accent },
+        { u"\u27FC", moOpDF::infix, 270, 5, 5, moOpDP::stretchy | moOpDP::accent },
+        { u"\u27FD", moOpDF::infix, 270, 5, 5, moOpDP::stretchy | moOpDP::accent },
+        { u"\u27FE", moOpDF::infix, 270, 5, 5, moOpDP::stretchy | moOpDP::accent },
+        { u"\u27FF", moOpDF::infix, 270, 5, 5, moOpDP::stretchy | moOpDP::accent },
+        { u"\u2900", moOpDF::infix, 270, 5, 5, moOpDP::accent },
+        { u"\u2901", moOpDF::infix, 270, 5, 5, moOpDP::accent },
+        { u"\u2902", moOpDF::infix, 270, 5, 5, moOpDP::accent },
+        { u"\u2903", moOpDF::infix, 270, 5, 5, moOpDP::accent },
+        { u"\u2904", moOpDF::infix, 270, 5, 5, moOpDP::accent },
+        { u"\u2905", moOpDF::infix, 270, 5, 5, moOpDP::accent },
+        { u"\u2906", moOpDF::infix, 270, 5, 5, moOpDP::accent },
+        { u"\u2907", moOpDF::infix, 270, 5, 5, moOpDP::accent },
+        { u"\u2908", moOpDF::infix, 270, 5, 5, moOpDP::nonedp },
+        { u"\u2909", moOpDF::infix, 270, 5, 5, moOpDP::nonedp },
+        { u"\u290A", moOpDF::infix, 270, 5, 5, moOpDP::stretchy },
+        { u"\u290B", moOpDF::infix, 270, 5, 5, moOpDP::stretchy },
+        { u"\u290C", moOpDF::infix, 270, 5, 5, moOpDP::stretchy | moOpDP::accent },
+        { u"\u290D", moOpDF::infix, 270, 5, 5, moOpDP::stretchy | moOpDP::accent },
+        { u"\u290E", moOpDF::infix, 270, 5, 5, moOpDP::stretchy | moOpDP::accent },
+        { u"\u290F", moOpDF::infix, 270, 5, 5, moOpDP::stretchy | moOpDP::accent },
+        { u"\u2910", moOpDF::infix, 270, 5, 5, moOpDP::stretchy | moOpDP::accent },
+        { u"\u2911", moOpDF::infix, 270, 5, 5, moOpDP::accent },
+        { u"\u2912", moOpDF::infix, 270, 5, 5, moOpDP::stretchy },
+        { u"\u2913", moOpDF::infix, 270, 5, 5, moOpDP::stretchy },
+        { u"\u2914", moOpDF::infix, 270, 5, 5, moOpDP::accent },
+        { u"\u2915", moOpDF::infix, 270, 5, 5, moOpDP::accent },
+        { u"\u2916", moOpDF::infix, 270, 5, 5, moOpDP::accent },
+        { u"\u2917", moOpDF::infix, 270, 5, 5, moOpDP::accent },
+        { u"\u2918", moOpDF::infix, 270, 5, 5, moOpDP::accent },
+        { u"\u2919", moOpDF::infix, 270, 5, 5, moOpDP::accent },
+        { u"\u291A", moOpDF::infix, 270, 5, 5, moOpDP::accent },
+        { u"\u291B", moOpDF::infix, 270, 5, 5, moOpDP::accent },
+        { u"\u291C", moOpDF::infix, 270, 5, 5, moOpDP::accent },
+        { u"\u291D", moOpDF::infix, 270, 5, 5, moOpDP::accent },
+        { u"\u291E", moOpDF::infix, 270, 5, 5, moOpDP::accent },
+        { u"\u291F", moOpDF::infix, 270, 5, 5, moOpDP::accent },
+        { u"\u2920", moOpDF::infix, 270, 5, 5, moOpDP::accent },
+        { u"\u2921", moOpDF::infix, 270, 5, 5, moOpDP::stretchy },
+        { u"\u2922", moOpDF::infix, 270, 5, 5, moOpDP::stretchy },
+        { u"\u2923", moOpDF::infix, 270, 5, 5, moOpDP::nonedp },
+        { u"\u2924", moOpDF::infix, 270, 5, 5, moOpDP::nonedp },
+        { u"\u2925", moOpDF::infix, 270, 5, 5, moOpDP::nonedp },
+        { u"\u2926", moOpDF::infix, 270, 5, 5, moOpDP::nonedp },
+        { u"\u2927", moOpDF::infix, 270, 5, 5, moOpDP::nonedp },
+        { u"\u2928", moOpDF::infix, 270, 5, 5, moOpDP::nonedp },
+        { u"\u2929", moOpDF::infix, 270, 5, 5, moOpDP::nonedp },
+        { u"\u292A", moOpDF::infix, 270, 5, 5, moOpDP::nonedp },
+        { u"\u292B", moOpDF::infix, 270, 5, 5, moOpDP::nonedp },
+        { u"\u292C", moOpDF::infix, 270, 5, 5, moOpDP::nonedp },
+        { u"\u292D", moOpDF::infix, 270, 5, 5, moOpDP::nonedp },
+        { u"\u292E", moOpDF::infix, 270, 5, 5, moOpDP::nonedp },
+        { u"\u292F", moOpDF::infix, 270, 5, 5, moOpDP::nonedp },
+        { u"\u2930", moOpDF::infix, 270, 5, 5, moOpDP::nonedp },
+        { u"\u2931", moOpDF::infix, 270, 5, 5, moOpDP::nonedp },
+        { u"\u2932", moOpDF::infix, 270, 5, 5, moOpDP::nonedp },
+        { u"\u2933", moOpDF::infix, 270, 5, 5, moOpDP::accent },
+        { u"\u2934", moOpDF::infix, 270, 5, 5, moOpDP::nonedp },
+        { u"\u2935", moOpDF::infix, 270, 5, 5, moOpDP::nonedp },
+        { u"\u2936", moOpDF::infix, 270, 5, 5, moOpDP::nonedp },
+        { u"\u2937", moOpDF::infix, 270, 5, 5, moOpDP::nonedp },
+        { u"\u2938", moOpDF::infix, 270, 5, 5, moOpDP::nonedp },
+        { u"\u2939", moOpDF::infix, 270, 5, 5, moOpDP::nonedp },
+        { u"\u293A", moOpDF::infix, 270, 5, 5, moOpDP::accent },
+        { u"\u293B", moOpDF::infix, 270, 5, 5, moOpDP::accent },
+        { u"\u293C", moOpDF::infix, 270, 5, 5, moOpDP::accent },
+        { u"\u293D", moOpDF::infix, 270, 5, 5, moOpDP::accent },
+        { u"\u293E", moOpDF::infix, 270, 5, 5, moOpDP::nonedp },
+        { u"\u293F", moOpDF::infix, 270, 5, 5, moOpDP::nonedp },
+        { u"\u2940", moOpDF::infix, 270, 5, 5, moOpDP::nonedp },
+        { u"\u2941", moOpDF::infix, 270, 5, 5, moOpDP::nonedp },
+        { u"\u2942", moOpDF::infix, 270, 5, 5, moOpDP::accent },
+        { u"\u2943", moOpDF::infix, 270, 5, 5, moOpDP::accent },
+        { u"\u2944", moOpDF::infix, 270, 5, 5, moOpDP::accent },
+        { u"\u2945", moOpDF::infix, 270, 5, 5, moOpDP::accent },
+        { u"\u2946", moOpDF::infix, 270, 5, 5, moOpDP::accent },
+        { u"\u2947", moOpDF::infix, 270, 5, 5, moOpDP::accent },
+        { u"\u2948", moOpDF::infix, 270, 5, 5, moOpDP::accent },
+        { u"\u2949", moOpDF::infix, 270, 5, 5, moOpDP::nonedp },
+        { u"\u294A", moOpDF::infix, 270, 5, 5, moOpDP::accent },
+        { u"\u294B", moOpDF::infix, 270, 5, 5, moOpDP::accent },
+        { u"\u294C", moOpDF::infix, 270, 5, 5, moOpDP::nonedp },
+        { u"\u294D", moOpDF::infix, 270, 5, 5, moOpDP::nonedp },
+        { u"\u294E", moOpDF::infix, 270, 5, 5, moOpDP::stretchy | moOpDP::accent },
+        { u"\u294F", moOpDF::infix, 270, 5, 5, moOpDP::stretchy },
+        { u"\u2950", moOpDF::infix, 270, 5, 5, moOpDP::stretchy | moOpDP::accent },
+        { u"\u2951", moOpDF::infix, 270, 5, 5, moOpDP::stretchy },
+        { u"\u2952", moOpDF::infix, 270, 5, 5, moOpDP::stretchy | moOpDP::accent },
+        { u"\u2953", moOpDF::infix, 270, 5, 5, moOpDP::stretchy | moOpDP::accent },
+        { u"\u2954", moOpDF::infix, 270, 5, 5, moOpDP::stretchy },
+        { u"\u2955", moOpDF::infix, 270, 5, 5, moOpDP::stretchy },
+        { u"\u2956", moOpDF::infix, 270, 5, 5, moOpDP::stretchy },
+        { u"\u2957", moOpDF::infix, 270, 5, 5, moOpDP::stretchy },
+        { u"\u2958", moOpDF::infix, 270, 5, 5, moOpDP::stretchy },
+        { u"\u2959", moOpDF::infix, 270, 5, 5, moOpDP::stretchy },
+        { u"\u295A", moOpDF::infix, 270, 5, 5, moOpDP::stretchy | moOpDP::accent },
+        { u"\u295B", moOpDF::infix, 270, 5, 5, moOpDP::stretchy | moOpDP::accent },
+        { u"\u295C", moOpDF::infix, 270, 5, 5, moOpDP::stretchy },
+        { u"\u295D", moOpDF::infix, 270, 5, 5, moOpDP::stretchy },
+        { u"\u295E", moOpDF::infix, 270, 5, 5, moOpDP::stretchy | moOpDP::accent },
+        { u"\u295F", moOpDF::infix, 270, 5, 5, moOpDP::stretchy | moOpDP::accent },
+        { u"\u2960", moOpDF::infix, 270, 5, 5, moOpDP::stretchy },
+        { u"\u2961", moOpDF::infix, 270, 5, 5, moOpDP::stretchy },
+        { u"\u2962", moOpDF::infix, 270, 5, 5, moOpDP::accent },
+        { u"\u2963", moOpDF::infix, 270, 5, 5, moOpDP::nonedp },
+        { u"\u2964", moOpDF::infix, 270, 5, 5, moOpDP::accent },
+        { u"\u2965", moOpDF::infix, 270, 5, 5, moOpDP::nonedp },
+        { u"\u2966", moOpDF::infix, 270, 5, 5, moOpDP::accent },
+        { u"\u2967", moOpDF::infix, 270, 5, 5, moOpDP::accent },
+        { u"\u2968", moOpDF::infix, 270, 5, 5, moOpDP::accent },
+        { u"\u2969", moOpDF::infix, 270, 5, 5, moOpDP::accent },
+        { u"\u296A", moOpDF::infix, 270, 5, 5, moOpDP::accent },
+        { u"\u296B", moOpDF::infix, 270, 5, 5, moOpDP::accent },
+        { u"\u296C", moOpDF::infix, 270, 5, 5, moOpDP::accent },
+        { u"\u296D", moOpDF::infix, 270, 5, 5, moOpDP::accent },
+        { u"\u296E", moOpDF::infix, 270, 5, 5, moOpDP::stretchy },
+        { u"\u296F", moOpDF::infix, 270, 5, 5, moOpDP::stretchy },
+        { u"\u2970", moOpDF::infix, 270, 5, 5, moOpDP::accent },
+        { u"\u2971", moOpDF::infix, 270, 5, 5, moOpDP::accent },
+        { u"\u2972", moOpDF::infix, 270, 5, 5, moOpDP::accent },
+        { u"\u2973", moOpDF::infix, 270, 5, 5, moOpDP::accent },
+        { u"\u2974", moOpDF::infix, 270, 5, 5, moOpDP::accent },
+        { u"\u2975", moOpDF::infix, 270, 5, 5, moOpDP::accent },
+        { u"\u2976", moOpDF::infix, 270, 5, 5, moOpDP::accent },
+        { u"\u2977", moOpDF::infix, 270, 5, 5, moOpDP::accent },
+        { u"\u2978", moOpDF::infix, 270, 5, 5, moOpDP::accent },
+        { u"\u2979", moOpDF::infix, 270, 5, 5, moOpDP::accent },
+        { u"\u297A", moOpDF::infix, 270, 5, 5, moOpDP::accent },
+        { u"\u297B", moOpDF::infix, 270, 5, 5, moOpDP::accent },
+        { u"\u297C", moOpDF::infix, 270, 5, 5, moOpDP::accent },
+        { u"\u297D", moOpDF::infix, 270, 5, 5, moOpDP::accent },
+        { u"\u297E", moOpDF::infix, 270, 5, 5, moOpDP::nonedp },
+        { u"\u297F", moOpDF::infix, 270, 5, 5, moOpDP::nonedp },
+        { u"\u2999", moOpDF::infix, 270, 3, 3, moOpDP::nonedp },
+        { u"\u299A", moOpDF::infix, 270, 3, 3, moOpDP::nonedp },
+        { u"\u299B", moOpDF::infix, 270, 3, 3, moOpDP::nonedp },
+        { u"\u299C", moOpDF::infix, 270, 3, 3, moOpDP::nonedp },
+        { u"\u299D", moOpDF::infix, 270, 3, 3, moOpDP::nonedp },
+        { u"\u299E", moOpDF::infix, 270, 3, 3, moOpDP::nonedp },
+        { u"\u299F", moOpDF::infix, 270, 3, 3, moOpDP::nonedp },
+        { u"\u29DF", moOpDF::infix, 270, 3, 3, moOpDP::nonedp },
+        { u"\u29EF", moOpDF::infix, 270, 3, 3, moOpDP::nonedp },
+        { u"\u29F4", moOpDF::infix, 270, 5, 5, moOpDP::nonedp },
+        { u"\u2B45", moOpDF::infix, 270, 5, 5, moOpDP::stretchy },
+        { u"\u2B46", moOpDF::infix, 270, 5, 5, moOpDP::stretchy },
+        { u"+", moOpDF::infix, 275, 4, 4, moOpDP::nonedp },
+        { u"+", moOpDF::prefix, 275, 0, 1, moOpDP::nonedp },
+        { u"-", moOpDF::infix, 275, 4, 4, moOpDP::nonedp },
+        { u"-", moOpDF::prefix, 275, 0, 1, moOpDP::nonedp },
+        { u"\u00B1", moOpDF::infix, 275, 4, 4, moOpDP::nonedp },
+        { u"\u00B1", moOpDF::prefix, 275, 0, 1, moOpDP::nonedp },
+        { u"\u2212", moOpDF::infix, 275, 4, 4, moOpDP::nonedp },
+        { u"\u2212", moOpDF::prefix, 275, 0, 1, moOpDP::nonedp },
+        { u"\u2213", moOpDF::infix, 275, 4, 4, moOpDP::nonedp },
+        { u"\u2213", moOpDF::prefix, 275, 0, 1, moOpDP::nonedp },
+        { u"\u2214", moOpDF::infix, 275, 4, 4, moOpDP::nonedp },
+        { u"\u229E", moOpDF::infix, 275, 4, 4, moOpDP::nonedp },
+        { u"\u229F", moOpDF::infix, 275, 4, 4, moOpDP::nonedp },
+        { u"\u2211", moOpDF::prefix, 290, 1, 2, moOpDP::movablelargeop | moOpDP::symmetric },
+        { u"\u2A0A", moOpDF::prefix, 290, 1, 2, moOpDP::movablelargeop | moOpDP::symmetric },
+        { u"\u2A0B", moOpDF::prefix, 290, 1, 2, moOpDP::largeop | moOpDP::symmetric },
+        { u"\u222C", moOpDF::prefix, 300, 0, 1, moOpDP::largeop | moOpDP::symmetric },
+        { u"\u222D", moOpDF::prefix, 300, 0, 1, moOpDP::largeop | moOpDP::symmetric },
+        { u"\u2295", moOpDF::infix, 300, 4, 4, moOpDP::nonedp },
+        { u"\u2296", moOpDF::infix, 300, 4, 4, moOpDP::nonedp },
+        { u"\u2298", moOpDF::infix, 300, 4, 4, moOpDP::nonedp },
+        { u"\u2A01", moOpDF::prefix, 300, 1, 2, moOpDP::movablelargeop | moOpDP::symmetric },
+        { u"\u222B", moOpDF::prefix, 310, 0, 1, moOpDP::largeop | moOpDP::symmetric },
+        { u"\u222E", moOpDF::prefix, 310, 0, 1, moOpDP::largeop | moOpDP::symmetric },
+        { u"\u222F", moOpDF::prefix, 310, 0, 1, moOpDP::largeop | moOpDP::symmetric },
+        { u"\u2230", moOpDF::prefix, 310, 0, 1, moOpDP::largeop | moOpDP::symmetric },
+        { u"\u2231", moOpDF::prefix, 310, 0, 1, moOpDP::largeop | moOpDP::symmetric },
+        { u"\u2232", moOpDF::prefix, 310, 0, 1, moOpDP::largeop | moOpDP::symmetric },
+        { u"\u2233", moOpDF::prefix, 310, 0, 1, moOpDP::largeop | moOpDP::symmetric },
+        { u"\u2A0C", moOpDF::prefix, 310, 0, 1, moOpDP::largeop | moOpDP::symmetric },
+        { u"\u2A0D", moOpDF::prefix, 310, 1, 2, moOpDP::largeop | moOpDP::symmetric },
+        { u"\u2A0E", moOpDF::prefix, 310, 1, 2, moOpDP::largeop | moOpDP::symmetric },
+        { u"\u2A0F", moOpDF::prefix, 310, 1, 2, moOpDP::largeop | moOpDP::symmetric },
+        { u"\u2A10", moOpDF::prefix, 310, 1, 2, moOpDP::movablelargeop | moOpDP::symmetric },
+        { u"\u2A11", moOpDF::prefix, 310, 1, 2, moOpDP::movablelargeop | moOpDP::symmetric },
+        { u"\u2A12", moOpDF::prefix, 310, 1, 2, moOpDP::movablelargeop | moOpDP::symmetric },
+        { u"\u2A13", moOpDF::prefix, 310, 1, 2, moOpDP::movablelargeop | moOpDP::symmetric },
+        { u"\u2A14", moOpDF::prefix, 310, 1, 2, moOpDP::movablelargeop | moOpDP::symmetric },
+        { u"\u2A15", moOpDF::prefix, 310, 1, 2, moOpDP::largeop | moOpDP::symmetric },
+        { u"\u2A16", moOpDF::prefix, 310, 1, 2, moOpDP::largeop | moOpDP::symmetric },
+        { u"\u2A17", moOpDF::prefix, 310, 1, 2, moOpDP::largeop | moOpDP::symmetric },
+        { u"\u2A18", moOpDF::prefix, 310, 1, 2, moOpDP::largeop | moOpDP::symmetric },
+        { u"\u2A19", moOpDF::prefix, 310, 1, 2, moOpDP::largeop | moOpDP::symmetric },
+        { u"\u2A1A", moOpDF::prefix, 310, 1, 2, moOpDP::largeop | moOpDP::symmetric },
+        { u"\u2A1B", moOpDF::prefix, 310, 1, 2, moOpDP::largeop | moOpDP::symmetric },
+        { u"\u2A1C", moOpDF::prefix, 310, 1, 2, moOpDP::largeop | moOpDP::symmetric },
+        { u"\u22C3", moOpDF::prefix, 320, 1, 2, moOpDP::movablelargeop | moOpDP::symmetric },
+        { u"\u2A03", moOpDF::prefix, 320, 1, 2, moOpDP::movablelargeop | moOpDP::symmetric },
+        { u"\u2A04", moOpDF::prefix, 320, 1, 2, moOpDP::movablelargeop | moOpDP::symmetric },
+        { u"\u22C0", moOpDF::prefix, 330, 1, 2, moOpDP::movablelargeop | moOpDP::symmetric },
+        { u"\u22C1", moOpDF::prefix, 330, 1, 2, moOpDP::movablelargeop | moOpDP::symmetric },
+        { u"\u22C2", moOpDF::prefix, 330, 1, 2, moOpDP::movablelargeop | moOpDP::symmetric },
+        { u"\u2A00", moOpDF::prefix, 330, 1, 2, moOpDP::movablelargeop | moOpDP::symmetric },
+        { u"\u2A02", moOpDF::prefix, 330, 1, 2, moOpDP::movablelargeop | moOpDP::symmetric },
+        { u"\u2A05", moOpDF::prefix, 330, 1, 2, moOpDP::movablelargeop | moOpDP::symmetric },
+        { u"\u2A06", moOpDF::prefix, 330, 1, 2, moOpDP::movablelargeop | moOpDP::symmetric },
+        { u"\u2A07", moOpDF::prefix, 330, 1, 2, moOpDP::movablelargeop | moOpDP::symmetric },
+        { u"\u2A08", moOpDF::prefix, 330, 1, 2, moOpDP::movablelargeop | moOpDP::symmetric },
+        { u"\u2A09", moOpDF::prefix, 330, 1, 2, moOpDP::movablelargeop | moOpDP::symmetric },
+        { u"\u2AFC", moOpDF::prefix, 330, 1, 2, moOpDP::movablelargeop | moOpDP::symmetric },
+        { u"\u2AFF", moOpDF::prefix, 330, 1, 2, moOpDP::movablelargeop | moOpDP::symmetric },
+        { u"\u2240", moOpDF::infix, 340, 4, 4, moOpDP::nonedp },
+        { u"\u220F", moOpDF::prefix, 350, 1, 2, moOpDP::movablelargeop | moOpDP::symmetric },
+        { u"\u2210", moOpDF::prefix, 350, 1, 2, moOpDP::movablelargeop | moOpDP::symmetric },
+        { u"\u2229", moOpDF::infix, 350, 4, 4, moOpDP::nonedp },
+        { u"\u222A", moOpDF::infix, 350, 4, 4, moOpDP::nonedp },
+        { u"*", moOpDF::infix, 390, 3, 3, moOpDP::nonedp },
+        { u".", moOpDF::infix, 390, 3, 3, moOpDP::nonedp },
+        { u"\u00D7", moOpDF::infix, 390, 4, 4, moOpDP::nonedp },
+        { u"\u2022", moOpDF::infix, 390, 4, 4, moOpDP::nonedp },
+        { u"\u2043", moOpDF::infix, 390, 4, 4, moOpDP::nonedp },
+        { u"\u2062", moOpDF::infix, 390, 0, 0, moOpDP::nonedp },
+        { u"\u22A0", moOpDF::infix, 390, 4, 4, moOpDP::nonedp },
+        { u"\u22A1", moOpDF::infix, 390, 4, 4, moOpDP::nonedp },
+        { u"\u22C5", moOpDF::infix, 390, 4, 4, moOpDP::nonedp },
+        { u"\u2A2F", moOpDF::infix, 390, 4, 4, moOpDP::nonedp },
+        { u"\u2A3F", moOpDF::infix, 390, 4, 4, moOpDP::nonedp },
+        { u"\u00B7", moOpDF::infix, 400, 4, 4, moOpDP::nonedp },
+        { u"\u2297", moOpDF::infix, 410, 4, 4, moOpDP::nonedp },
+        { u"%", moOpDF::infix, 640, 3, 3, moOpDP::nonedp },
+        { u"\\", moOpDF::infix, 650, 0, 0, moOpDP::nonedp },
+        { u"\u2216", moOpDF::infix, 650, 4, 4, moOpDP::nonedp },
+        { u"/", moOpDF::infix, 660, 1, 1, moOpDP::nonedp },
+        { u"\u00F7", moOpDF::infix, 660, 4, 4, moOpDP::nonedp },
+        { u"\u2220", moOpDF::prefix, 670, 0, 0, moOpDP::nonedp },
+        { u"\u2221", moOpDF::prefix, 670, 0, 0, moOpDP::nonedp },
+        { u"\u2222", moOpDF::prefix, 670, 0, 0, moOpDP::nonedp },
+        { u"\u00AC", moOpDF::prefix, 680, 2, 1, moOpDP::nonedp },
+        { u"\u2299", moOpDF::infix, 710, 4, 4, moOpDP::nonedp },
+        { u"\u2202", moOpDF::prefix, 740, 2, 1, moOpDP::nonedp },
+        { u"\u2207", moOpDF::prefix, 740, 2, 1, moOpDP::nonedp },
+        { u"**", moOpDF::infix, 780, 1, 1, moOpDP::nonedp },
+        { u"<>", moOpDF::infix, 780, 1, 1, moOpDP::nonedp },
+        { u"^", moOpDF::infix, 780, 1, 1, moOpDP::nonedp },
+        { u"\u2032", moOpDF::postfix, 800, 0, 0, moOpDP::nonedp },
+        { u"\u266D", moOpDF::postfix, 800, 0, 2, moOpDP::nonedp },
+        { u"\u266E", moOpDF::postfix, 800, 0, 2, moOpDP::nonedp },
+        { u"\u266F", moOpDF::postfix, 800, 0, 2, moOpDP::nonedp },
+        { u"!", moOpDF::postfix, 810, 1, 0, moOpDP::nonedp },
+        { u"!!", moOpDF::postfix, 810, 1, 0, moOpDP::nonedp },
+        { u"//", moOpDF::infix, 820, 1, 1, moOpDP::nonedp },
+        { u"@", moOpDF::infix, 825, 1, 1, moOpDP::nonedp },
+        { u"?", moOpDF::infix, 835, 1, 1, moOpDP::nonedp },
+        { u"\u2145", moOpDF::prefix, 845, 2, 1, moOpDP::nonedp },
+        { u"\u2146", moOpDF::prefix, 845, 2, 0, moOpDP::nonedp },
+        { u"\u221A", moOpDF::prefix, 845, 1, 1, moOpDP::stretchy },
+        { u"\u221B", moOpDF::prefix, 845, 1, 1, moOpDP::nonedp },
+        { u"\u221C", moOpDF::prefix, 845, 1, 1, moOpDP::nonedp },
+        { u"\u2061", moOpDF::infix, 850, 0, 0, moOpDP::nonedp },
+        { u"\"", moOpDF::postfix, 880, 0, 0, moOpDP::accent },
+        { u"&", moOpDF::postfix, 880, 0, 0, moOpDP::nonedp },
+        { u"\'", moOpDF::postfix, 880, 0, 0, moOpDP::accent },
+        { u"++", moOpDF::postfix, 880, 0, 0, moOpDP::nonedp },
+        { u"--", moOpDF::postfix, 880, 0, 0, moOpDP::nonedp },
+        { u"^", moOpDF::postfix, 880, 0, 0, moOpDP::stretchy | moOpDP::accent },
+        { u"_", moOpDF::postfix, 880, 0, 0, moOpDP::stretchy | moOpDP::accent },
+        { u"`", moOpDF::postfix, 880, 0, 00, moOpDP::accent },
+        { u"~", moOpDF::postfix, 880, 0, 0, moOpDP::stretchy | moOpDP::accent },
+        { u"\u00A8", moOpDF::postfix, 880, 0, 0, moOpDP::accent },
+        { u"\u00AA", moOpDF::postfix, 880, 0, 0, moOpDP::accent },
+        { u"\u00AF", moOpDF::postfix, 880, 0, 0, moOpDP::stretchy | moOpDP::accent },
+        { u"\u00B0", moOpDF::postfix, 880, 0, 0, moOpDP::nonedp },
+        { u"\u00B2", moOpDF::postfix, 880, 0, 0, moOpDP::accent },
+        { u"\u00B3", moOpDF::postfix, 880, 0, 0, moOpDP::accent },
+        { u"\u00B4", moOpDF::postfix, 880, 0, 0, moOpDP::accent },
+        { u"\u00B8", moOpDF::postfix, 880, 0, 0, moOpDP::accent },
+        { u"\u00B9", moOpDF::postfix, 880, 0, 0, moOpDP::accent },
+        { u"\u00BA", moOpDF::postfix, 880, 0, 0, moOpDP::accent },
+        { u"\u02C6", moOpDF::postfix, 880, 0, 0, moOpDP::stretchy | moOpDP::accent },
+        { u"\u02C7", moOpDF::postfix, 880, 0, 0, moOpDP::stretchy | moOpDP::accent },
+        { u"\u02C9", moOpDF::postfix, 880, 0, 0, moOpDP::stretchy | moOpDP::accent },
+        { u"\u02CA", moOpDF::postfix, 880, 0, 0, moOpDP::accent },
+        { u"\u02CB", moOpDF::postfix, 880, 0, 0, moOpDP::accent },
+        { u"\u02CD", moOpDF::postfix, 880, 0, 0, moOpDP::stretchy | moOpDP::accent },
+        { u"\u02D8", moOpDF::postfix, 880, 0, 0, moOpDP::accent },
+        { u"\u02D9", moOpDF::postfix, 880, 0, 0, moOpDP::accent },
+        { u"\u02DA", moOpDF::postfix, 880, 0, 0, moOpDP::accent },
+        { u"\u02DC", moOpDF::postfix, 880, 0, 0, moOpDP::stretchy | moOpDP::accent },
+        { u"\u02DD", moOpDF::postfix, 880, 0, 0, moOpDP::accent },
+        { u"\u02F7", moOpDF::postfix, 880, 0, 0, moOpDP::stretchy | moOpDP::accent },
+        { u"\u0302", moOpDF::postfix, 880, 0, 0, moOpDP::stretchy | moOpDP::accent },
+        { u"\u0311", moOpDF::postfix, 880, 0, 0, moOpDP::accent },
+        { u"\u201A", moOpDF::postfix, 880, 0, 0, moOpDP::accent },
+        { u"\u201B", moOpDF::postfix, 880, 0, 0, moOpDP::accent },
+        { u"\u201E", moOpDF::postfix, 880, 0, 0, moOpDP::accent },
+        { u"\u201F", moOpDF::postfix, 880, 0, 0, moOpDP::accent },
+        { u"\u2033", moOpDF::postfix, 880, 0, 0, moOpDP::accent },
+        { u"\u2034", moOpDF::postfix, 880, 0, 0, moOpDP::accent },
+        { u"\u2035", moOpDF::postfix, 880, 0, 0, moOpDP::accent },
+        { u"\u2036", moOpDF::postfix, 880, 0, 0, moOpDP::accent },
+        { u"\u2037", moOpDF::postfix, 880, 0, 0, moOpDP::accent },
+        { u"\u203E", moOpDF::postfix, 880, 0, 0, moOpDP::stretchy | moOpDP::accent },
+        { u"\u2057", moOpDF::postfix, 880, 0, 0, moOpDP::accent },
+        { u"\u2064", moOpDF::infix, 880, 0, 0, moOpDP::nonedp },
+        { u"\u20DB", moOpDF::postfix, 880, 0, 0, moOpDP::accent },
+        { u"\u20DC", moOpDF::postfix, 880, 0, 0, moOpDP::accent },
+        { u"\u23B4", moOpDF::postfix, 880, 0, 0, moOpDP::stretchy | moOpDP::accent },
+        { u"\u23B5", moOpDF::postfix, 880, 0, 0, moOpDP::stretchy | moOpDP::accent },
+        { u"\u23DC", moOpDF::postfix, 880, 0, 0, moOpDP::stretchy | moOpDP::accent },
+        { u"\u23DD", moOpDF::postfix, 880, 0, 0, moOpDP::stretchy | moOpDP::accent },
+        { u"\u23DE", moOpDF::postfix, 880, 0, 0, moOpDP::stretchy | moOpDP::accent },
+        { u"\u23DF", moOpDF::postfix, 880, 0, 0, moOpDP::stretchy | moOpDP::accent },
+        { u"\u23E0", moOpDF::postfix, 880, 0, 0, moOpDP::stretchy | moOpDP::accent },
+        { u"\u23E1", moOpDF::postfix, 880, 0, 0, moOpDP::stretchy | moOpDP::accent },
+        { u"_", 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 000000000..5e54f0d92
--- /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 000000000..187dd1953
--- /dev/null
+++ b/starmath/source/mathml/mathmlexport.cxx
@@ -0,0 +1,1457 @@
+/* -*- 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 <xmloff/attrlist.hxx>
+#include <comphelper/genericpropertyset.hxx>
+#include <comphelper/servicehelper.hxx>
+#include <comphelper/propertysetinfo.hxx>
+#include <tools/diagnose_ex.h>
+#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_Unicode cChar) { return 0xE000 <= cChar && cChar <= 0xF8FF; }
+
+sal_Unicode ConvertMathToMathML(sal_Unicode cChar)
+{
+    sal_Unicode cRes = cChar;
+    if (IsInPrivateUseArea(cChar))
+    {
+        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");
+
+            SfxItemSet* pSet = rMedium.GetItemSet();
+            if (pSet)
+            {
+                const SfxUnoAnyItem* pItem = pSet->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 OUStringLiteral sUsePrettyPrinting(u"UsePrettyPrinting");
+    static constexpr OUStringLiteral sBaseURI(u"BaseURI");
+    static constexpr OUStringLiteral sStreamRelPath(u"StreamRelPath");
+    static constexpr OUStringLiteral sStreamName(u"StreamName");
+
+    // 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;
+            if (rMedium.GetItemSet())
+            {
+                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 = comphelper::getFromUnoTunnel<SmXMLExport>(xFilter);
+    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 const OUStringLiteral sMediaType = u"MediaType";
+    static const OUStringLiteral sTextXml = u"text/xml";
+    xSet->setPropertyValue(sMediaType, Any(OUString(sTextXml)));
+
+    // all streams must be encrypted in encrypted document
+    static const 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)
+{
+}
+
+sal_Int64 SAL_CALL SmXMLExport::getSomething(const uno::Sequence<sal_Int8>& rId)
+{
+    return comphelper::getSomethingImpl(rId, this,
+                                        comphelper::FallbackToGetSomethingOf<SvXMLExport>{});
+}
+
+const uno::Sequence<sal_Int8>& SmXMLExport::getUnoTunnelId() noexcept
+{
+    static const comphelper::UnoIdInit theSmXMLExportUnoTunnelId;
+    return theSmXMLExportUnoTunnelId.getSeq();
+}
+
+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*/
+        SvXMLAttributeList& 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 && !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);
+    }
+    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_uInt16 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));
+    }
+    sal_Unicode nArse = pTemp->GetText()[0];
+    sal_Unicode cTmp = ConvertMathToMathML(nArse);
+    if (cTmp != 0)
+        nArse = cTmp;
+    OSL_ENSURE(nArse != 0xffff, "Non existent symbol");
+    GetDocHandler()->characters(OUString(nArse));
+}
+
+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.00)));
+                    sStrBuf.append('%');
+                    break;
+                case FontSizeType::DIVIDE:
+                    ::sax::Converter::convertDouble(sStrBuf,
+                                                    static_cast<double>(Fraction(100.00) / 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
+                    Fraction aTemp = Sm100th_mmToPts(pFontNode->GetFont().GetFontSize().Height());
+
+                    if (pFontNode->GetSizeType() == FontSizeType::MINUS)
+                        aTemp -= aFrac;
+                    else
+                        aTemp += aFrac;
+
+                    double mytest = static_cast<double>(aTemp);
+
+                    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:
+        {
+            sal_Unicode cTmp = 0;
+            const SmTextNode* pTemp = static_cast<const SmTextNode*>(pNode);
+            if (!pTemp->GetText().isEmpty())
+                cTmp = ConvertMathToMathML(pTemp->GetText()[0]);
+            if (cTmp == 0)
+            {
+                // 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 000000000..44d8cc1e3
--- /dev/null
+++ b/starmath/source/mathml/mathmlimport.cxx
@@ -0,0 +1,2696 @@
+/* -*- 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 <tools/diagnose_ex.h>
+#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());
+
+    //Make a model component from our SmModel
+    uno::Reference<lang::XComponent> xModelComp = xModel;
+    OSL_ENSURE(xModelComp.is(), "XMLReader::Read: got no model");
+
+    // try to get an XStatusIndicator from the Medium
+    uno::Reference<task::XStatusIndicator> xStatusIndicator;
+
+    bool bEmbedded = false;
+    SmModel* pModel = comphelper::getFromUnoTunnel<SmModel>(xModel);
+
+    SmDocShell* pDocShell = pModel ? static_cast<SmDocShell*>(pModel->GetObjectShell()) : nullptr;
+    if (pDocShell)
+    {
+        OSL_ENSURE(pDocShell->GetMedium() == &rMedium, "different SfxMedium found");
+
+        SfxItemSet* pSet = rMedium.GetItemSet();
+        if (pSet)
+        {
+            const SfxUnoAnyItem* pItem = pSet->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");
+            if (rMedium.GetItemSet())
+            {
+                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(), xModelComp, "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(), xModelComp, "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(), xModelComp, "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, xModelComp, 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 = comphelper::getFromUnoTunnel<SmXMLImport>(xFilter);
+        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())
+{
+}
+
+const uno::Sequence<sal_Int8>& SmXMLImport::getUnoTunnelId() noexcept
+{
+    static const comphelper::UnoIdInit theSmXMLImportUnoTunnelId;
+    return theSmXMLImportUnoTunnelId.getSeq();
+}
+
+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));
+}
+
+sal_Int64 SAL_CALL SmXMLImport::getSomething(const uno::Sequence<sal_Int8>& rId)
+{
+    return comphelper::getSomethingImpl(rId, this,
+                                        comphelper::FallbackToGetSomethingOf<SvXMLImport>{});
+}
+
+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 = comphelper::getFromUnoTunnel<SmModel>(xModel);
+
+        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"";
+    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"";
+        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"";
+    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:
+    sal_Unicode cBegin;
+    sal_Unicode 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()[0];
+                break;
+            case XML_CLOSE:
+                cEnd = aIter.toString()[0];
+                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"";
+    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"";
+    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"";
+        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"";
+        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"";
+        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"";
+        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[0]);
+    SmToken bToken;
+    if (bIsFenced)
+    {
+        if (isPrefix)
+            bToken
+                = starmathdatabase::Identify_Prefix_SmXMLOperatorContext_Impl(aToken.cMathChar[0]);
+        else if (isInfix)
+            bToken = SmToken(TMLINE, MS_VERTLINE, "mline", TG::NONE, 0);
+        else if (isPostfix)
+            bToken
+                = starmathdatabase::Identify_Postfix_SmXMLOperatorContext_Impl(aToken.cMathChar[0]);
+        else
+            bToken = starmathdatabase::Identify_PrefixPostfix_SmXMLOperatorContext_Impl(
+                aToken.cMathChar[0]);
+    }
+    else
+        bToken = starmathdatabase::Identify_SmXMLOperatorContext_Impl(aToken.cMathChar[0],
+                                                                      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"";
+    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"";
+    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"";
+    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"";
+    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"";
+    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"";
+    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"";
+    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"";
+            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"";
+
+            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"";
+
+            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"";
+        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"";
+    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 = comphelper::getFromUnoTunnel<SmModel>(xModel);
+
+    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 const OUStringLiteral sFormula(u"Formula");
+    static const OUStringLiteral sBasicLibraries(u"BasicLibraries");
+    static const 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 000000000..66bdf3f34
--- /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(sal_Unicode cChar, bool bIsStretchy)
+{
+    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_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(sal_Unicode cChar)
+{
+    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(sal_Unicode cChar)
+{
+    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(sal_Unicode cChar)
+{
+    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_HTML(sal_uInt32 cColor)
+{
+    for (auto i = std::begin(aColorTokenTableHTML); i < std::end(aColorTokenTableHTML); ++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 000000000..7e0e93ab7
--- /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", u"\u00C6" },
+        { u"AMP", u"\u0026" },
+        { u"Aacute", u"\u00C1" },
+        { u"Abreve", u"\u0102" },
+        { u"Acirc", u"\u00C2" },
+        { u"Acy", u"\u0410" },
+        { u"Afr", u"\U0001D504" },
+        { u"Agrave", u"\u00C0" },
+        { u"Alpha", u"\u0391" },
+        { u"Amacr", u"\u0100" },
+        { u"And", u"\u2A53" },
+        { u"Aogon", u"\u0104" },
+        { u"Aopf", u"\U0001D538" },
+        { u"ApplyFunction", u"\u2061" },
+        { u"Aring", u"\u00C5" },
+        { u"Ascr", u"\U0001D49C" },
+        { u"Assign", u"\u2254" },
+        { u"Atilde", u"\u00C3" },
+        { u"Auml", u"\u00C4" },
+        { u"Backslash", u"\u2216" },
+        { u"Barv", u"\u2AE7" },
+        { u"Barwed", u"\u2306" },
+        { u"Bcy", u"\u0411" },
+        { u"Because", u"\u2235" },
+        { u"Bernoullis", u"\u212C" },
+        { u"Beta", u"\u0392" },
+        { u"Bfr", u"\U0001D505" },
+        { u"Bopf", u"\U0001D539" },
+        { u"Breve", u"\u02D8" },
+        { u"Bscr", u"\u212C" },
+        { u"Bumpeq", u"\u224E" },
+        { u"CHcy", u"\u0427" },
+        { u"COPY", u"\u00A9" },
+        { u"Cacute", u"\u0106" },
+        { u"Cap", u"\u22D2" },
+        { u"CapitalDifferentialD", u"\u2145" },
+        { u"Cayleys", u"\u212D" },
+        { u"Ccaron", u"\u010C" },
+        { u"Ccedil", u"\u00C7" },
+        { u"Ccirc", u"\u0108" },
+        { u"Cconint", u"\u2230" },
+        { u"Cdot", u"\u010A" },
+        { u"Cedilla", u"\u00B8" },
+        { u"CenterDot", u"\u00B7" },
+        { u"Cfr", u"\u212D" },
+        { u"Chi", u"\u03A7" },
+        { u"CircleDot", u"\u2299" },
+        { u"CircleMinus", u"\u2296" },
+        { u"CirclePlus", u"\u2295" },
+        { u"CircleTimes", u"\u2297" },
+        { u"ClockwiseContourIntegral", u"\u2232" },
+        { u"CloseCurlyDoubleQuote", u"\u201D" },
+        { u"CloseCurlyQuote", u"\u2019" },
+        { u"Colon", u"\u2237" },
+        { u"Colone", u"\u2A74" },
+        { u"Congruent", u"\u2261" },
+        { u"Conint", u"\u222F" },
+        { u"ContourIntegral", u"\u222E" },
+        { u"Copf", u"\u2102" },
+        { u"Coproduct", u"\u2210" },
+        { u"CounterClockwiseContourIntegral", u"\u2233" },
+        { u"Cross", u"\u2A2F" },
+        { u"Cscr", u"\U0001D49E" },
+        { u"Cup", u"\u22D3" },
+        { u"CupCap", u"\u224D" },
+        { u"DD", u"\u2145" },
+        { u"DDotrahd", u"\u2911" },
+        { u"DJcy", u"\u0402" },
+        { u"DScy", u"\u0405" },
+        { u"DZcy", u"\u040F" },
+        { u"Dagger", u"\u2021" },
+        { u"Darr", u"\u21A1" },
+        { u"Dashv", u"\u2AE4" },
+        { u"Dcaron", u"\u010E" },
+        { u"Dcy", u"\u0414" },
+        { u"Del", u"\u2207" },
+        { u"Delta", u"\u0394" },
+        { u"Dfr", u"\U0001D507" },
+        { u"DiacriticalAcute", u"\u00B4" },
+        { u"DiacriticalDot", u"\u02D9" },
+        { u"DiacriticalDoubleAcute", u"\u02DD" },
+        { u"DiacriticalGrave", u"\u0060" },
+        { u"DiacriticalTilde", u"\u02DC" },
+        { u"Diamond", u"\u22C4" },
+        { u"DifferentialD", u"\u2146" },
+        { u"Dopf", u"\U0001D53B" },
+        { u"Dot", u"\u00A8" },
+        { u"DotDot", u"\u20DC" },
+        { u"DotEqual", u"\u2250" },
+        { u"DoubleContourIntegral", u"\u222F" },
+        { u"DoubleDot", u"\u00A8" },
+        { u"DoubleDownArrow", u"\u21D3" },
+        { u"DoubleLeftArrow", u"\u21D0" },
+        { u"DoubleLeftRightArrow", u"\u21D4" },
+        { u"DoubleLeftTee", u"\u2AE4" },
+        { u"DoubleLongLeftArrow", u"\u27F8" },
+        { u"DoubleLongLeftRightArrow", u"\u27FA" },
+        { u"DoubleLongRightArrow", u"\u27F9" },
+        { u"DoubleRightArrow", u"\u21D2" },
+        { u"DoubleRightTee", u"\u22A8" },
+        { u"DoubleUpArrow", u"\u21D1" },
+        { u"DoubleUpDownArrow", u"\u21D5" },
+        { u"DoubleVerticalBar", u"\u2225" },
+        { u"DownArrow", u"\u2193" },
+        { u"DownArrowBar", u"\u2913" },
+        { u"DownArrowUpArrow", u"\u21F5" },
+        { u"DownBreve", u"\u0311" },
+        { u"DownLeftRightVector", u"\u2950" },
+        { u"DownLeftTeeVector", u"\u295E" },
+        { u"DownLeftVector", u"\u21BD" },
+        { u"DownLeftVectorBar", u"\u2956" },
+        { u"DownRightTeeVector", u"\u295F" },
+        { u"DownRightVector", u"\u21C1" },
+        { u"DownRightVectorBar", u"\u2957" },
+        { u"DownTee", u"\u22A4" },
+        { u"DownTeeArrow", u"\u21A7" },
+        { u"Downarrow", u"\u21D3" },
+        { u"Dscr", u"\U0001D49F" },
+        { u"Dstrok", u"\u0110" },
+        { u"ENG", u"\u014A" },
+        { u"ETH", u"\u00D0" },
+        { u"Eacute", u"\u00C9" },
+        { u"Ecaron", u"\u011A" },
+        { u"Ecirc", u"\u00CA" },
+        { u"Ecy", u"\u042D" },
+        { u"Edot", u"\u0116" },
+        { u"Efr", u"\U0001D508" },
+        { u"Egrave", u"\u00C8" },
+        { u"Element", u"\u2208" },
+        { u"Emacr", u"\u0112" },
+        { u"EmptySmallSquare", u"\u25FB" },
+        { u"EmptyVerySmallSquare", u"\u25AB" },
+        { u"Eogon", u"\u0118" },
+        { u"Eopf", u"\U0001D53C" },
+        { u"Epsilon", u"\u0395" },
+        { u"Equal", u"\u2A75" },
+        { u"EqualTilde", u"\u2242" },
+        { u"Equilibrium", u"\u21CC" },
+        { u"Escr", u"\u2130" },
+        { u"Esim", u"\u2A73" },
+        { u"Eta", u"\u0397" },
+        { u"Euml", u"\u00CB" },
+        { u"Exists", u"\u2203" },
+        { u"ExponentialE", u"\u2147" },
+        { u"Fcy", u"\u0424" },
+        { u"Ffr", u"\U0001D509" },
+        { u"FilledSmallSquare", u"\u25FC" },
+        { u"FilledVerySmallSquare", u"\u25AA" },
+        { u"Fopf", u"\U0001D53D" },
+        { u"ForAll", u"\u2200" },
+        { u"Fouriertrf", u"\u2131" },
+        { u"Fscr", u"\u2131" },
+        { u"GJcy", u"\u0403" },
+        { u"GT", u"\u003E" },
+        { u"Gamma", u"\u0393" },
+        { u"Gammad", u"\u03DC" },
+        { u"Gbreve", u"\u011E" },
+        { u"Gcedil", u"\u0122" },
+        { u"Gcirc", u"\u011C" },
+        { u"Gcy", u"\u0413" },
+        { u"Gdot", u"\u0120" },
+        { u"Gfr", u"\U0001D50A" },
+        { u"Gg", u"\u22D9" },
+        { u"Gopf", u"\U0001D53E" },
+        { u"GreaterEqual", u"\u2265" },
+        { u"GreaterEqualLess", u"\u22DB" },
+        { u"GreaterFullEqual", u"\u2267" },
+        { u"GreaterGreater", u"\u2AA2" },
+        { u"GreaterLess", u"\u2277" },
+        { u"GreaterSlantEqual", u"\u2A7E" },
+        { u"GreaterTilde", u"\u2273" },
+        { u"Gscr", u"\U0001D4A2" },
+        { u"Gt", u"\u226B" },
+        { u"HARDcy", u"\u042A" },
+        { u"Hacek", u"\u02C7" },
+        { u"Hat", u"\u005E" },
+        { u"Hcirc", u"\u0124" },
+        { u"Hfr", u"\u210C" },
+        { u"HilbertSpace", u"\u210B" },
+        { u"Hopf", u"\u210D" },
+        { u"HorizontalLine", u"\u2500" },
+        { u"Hscr", u"\u210B" },
+        { u"Hstrok", u"\u0126" },
+        { u"HumpDownHump", u"\u224E" },
+        { u"HumpEqual", u"\u224F" },
+        { u"IEcy", u"\u0415" },
+        { u"IJlig", u"\u0132" },
+        { u"IOcy", u"\u0401" },
+        { u"Iacute", u"\u00CD" },
+        { u"Icirc", u"\u00CE" },
+        { u"Icy", u"\u0418" },
+        { u"Idot", u"\u0130" },
+        { u"Ifr", u"\u2111" },
+        { u"Igrave", u"\u00CC" },
+        { u"Im", u"\u2111" },
+        { u"Imacr", u"\u012A" },
+        { u"ImaginaryI", u"\u2148" },
+        { u"Implies", u"\u21D2" },
+        { u"Int", u"\u222C" },
+        { u"Integral", u"\u222B" },
+        { u"Intersection", u"\u22C2" },
+        { u"InvisibleComma", u"\u2063" },
+        { u"InvisibleTimes", u"\u2062" },
+        { u"Iogon", u"\u012E" },
+        { u"Iopf", u"\U0001D540" },
+        { u"Iota", u"\u0399" },
+        { u"Iscr", u"\u2110" },
+        { u"Itilde", u"\u0128" },
+        { u"Iukcy", u"\u0406" },
+        { u"Iuml", u"\u00CF" },
+        { u"Jcirc", u"\u0134" },
+        { u"Jcy", u"\u0419" },
+        { u"Jfr", u"\U0001D50D" },
+        { u"Jopf", u"\U0001D541" },
+        { u"Jscr", u"\U0001D4A5" },
+        { u"Jsercy", u"\u0408" },
+        { u"Jukcy", u"\u0404" },
+        { u"KHcy", u"\u0425" },
+        { u"KJcy", u"\u040C" },
+        { u"Kappa", u"\u039A" },
+        { u"Kcedil", u"\u0136" },
+        { u"Kcy", u"\u041A" },
+        { u"Kfr", u"\U0001D50E" },
+        { u"Kopf", u"\U0001D542" },
+        { u"Kscr", u"\U0001D4A6" },
+        { u"LJcy", u"\u0409" },
+        { u"LT", u"\u003C" },
+        { u"Lacute", u"\u0139" },
+        { u"Lambda", u"\u039B" },
+        { u"Lang", u"\u27EA" },
+        { u"Laplacetrf", u"\u2112" },
+        { u"Larr", u"\u219E" },
+        { u"Lcaron", u"\u013D" },
+        { u"Lcedil", u"\u013B" },
+        { u"Lcy", u"\u041B" },
+        { u"LeftAngleBracket", u"\u27E8" },
+        { u"LeftArrow", u"\u2190" },
+        { u"LeftArrowBar", u"\u21E4" },
+        { u"LeftArrowRightArrow", u"\u21C6" },
+        { u"LeftCeiling", u"\u2308" },
+        { u"LeftDoubleBracket", u"\u27E6" },
+        { u"LeftDownTeeVector", u"\u2961" },
+        { u"LeftDownVector", u"\u21C3" },
+        { u"LeftDownVectorBar", u"\u2959" },
+        { u"LeftFloor", u"\u230A" },
+        { u"LeftRightArrow", u"\u2194" },
+        { u"LeftRightVector", u"\u294E" },
+        { u"LeftTee", u"\u22A3" },
+        { u"LeftTeeArrow", u"\u21A4" },
+        { u"LeftTeeVector", u"\u295A" },
+        { u"LeftTriangle", u"\u22B2" },
+        { u"LeftTriangleBar", u"\u29CF" },
+        { u"LeftTriangleEqual", u"\u22B4" },
+        { u"LeftUpDownVector", u"\u2951" },
+        { u"LeftUpTeeVector", u"\u2960" },
+        { u"LeftUpVector", u"\u21BF" },
+        { u"LeftUpVectorBar", u"\u2958" },
+        { u"LeftVector", u"\u21BC" },
+        { u"LeftVectorBar", u"\u2952" },
+        { u"Leftarrow", u"\u21D0" },
+        { u"Leftrightarrow", u"\u21D4" },
+        { u"LessEqualGreater", u"\u22DA" },
+        { u"LessFullEqual", u"\u2266" },
+        { u"LessGreater", u"\u2276" },
+        { u"LessLess", u"\u2AA1" },
+        { u"LessSlantEqual", u"\u2A7D" },
+        { u"LessTilde", u"\u2272" },
+        { u"Lfr", u"\U0001D50F" },
+        { u"Ll", u"\u22D8" },
+        { u"Lleftarrow", u"\u21DA" },
+        { u"Lmidot", u"\u013F" },
+        { u"LongLeftArrow", u"\u27F5" },
+        { u"LongLeftRightArrow", u"\u27F7" },
+        { u"LongRightArrow", u"\u27F6" },
+        { u"Longleftarrow", u"\u27F8" },
+        { u"Longleftrightarrow", u"\u27FA" },
+        { u"Longrightarrow", u"\u27F9" },
+        { u"Lopf", u"\U0001D543" },
+        { u"LowerLeftArrow", u"\u2199" },
+        { u"LowerRightArrow", u"\u2198" },
+        { u"Lscr", u"\u2112" },
+        { u"Lsh", u"\u21B0" },
+        { u"Lstrok", u"\u0141" },
+        { u"Lt", u"\u226A" },
+        { u"Map", u"\u2905" },
+        { u"Mcy", u"\u041C" },
+        { u"MediumSpace", u"\u205F" },
+        { u"Mellintrf", u"\u2133" },
+        { u"Mfr", u"\U0001D510" },
+        { u"MinusPlus", u"\u2213" },
+        { u"Mopf", u"\U0001D544" },
+        { u"Mscr", u"\u2133" },
+        { u"Mu", u"\u039C" },
+        { u"NJcy", u"\u040A" },
+        { u"Nacute", u"\u0143" },
+        { u"Ncaron", u"\u0147" },
+        { u"Ncedil", u"\u0145" },
+        { u"Ncy", u"\u041D" },
+        { u"NegativeMediumSpace", u"\u200B" },
+        { u"NegativeThickSpace", u"\u200B" },
+        { u"NegativeThinSpace", u"\u200B" },
+        { u"NegativeVeryThinSpace", u"\u200B" },
+        { u"NestedGreaterGreater", u"\u226B" },
+        { u"NestedLessLess", u"\u226A" },
+        { u"NewLine", u"\u000A" },
+        { u"Nfr", u"\U0001D511" },
+        { u"NoBreak", u"\u2060" },
+        { u"NonBreakingSpace", u"\u00A0" },
+        { u"Nopf", u"\u2115" },
+        { u"Not", u"\u2AEC" },
+        { u"NotCongruent", u"\u2262" },
+        { u"NotCupCap", u"\u226D" },
+        { u"NotDoubleVerticalBar", u"\u2226" },
+        { u"NotElement", u"\u2209" },
+        { u"NotEqual", u"\u2260" },
+        { u"NotEqualTilde", u"\u2242\u0338" },
+        { u"NotExists", u"\u2204" },
+        { u"NotGreater", u"\u226F" },
+        { u"NotGreaterEqual", u"\u2271" },
+        { u"NotGreaterFullEqual", u"\u2267\u0338" },
+        { u"NotGreaterGreater", u"\u226B\u0338" },
+        { u"NotGreaterLess", u"\u2279" },
+        { u"NotGreaterSlantEqual", u"\u2A7E\u0338" },
+        { u"NotGreaterTilde", u"\u2275" },
+        { u"NotHumpDownHump", u"\u224E\u0338" },
+        { u"NotHumpEqual", u"\u224F\u0338" },
+        { u"NotLeftTriangle", u"\u22EA" },
+        { u"NotLeftTriangleBar", u"\u29CF\u0338" },
+        { u"NotLeftTriangleEqual", u"\u22EC" },
+        { u"NotLess", u"\u226E" },
+        { u"NotLessEqual", u"\u2270" },
+        { u"NotLessGreater", u"\u2278" },
+        { u"NotLessLess", u"\u226A\u0338" },
+        { u"NotLessSlantEqual", u"\u2A7D\u0338" },
+        { u"NotLessTilde", u"\u2274" },
+        { u"NotNestedGreaterGreater", u"\u2AA2\u0338" },
+        { u"NotNestedLessLess", u"\u2AA1\u0338" },
+        { u"NotPrecedes", u"\u2280" },
+        { u"NotPrecedesEqual", u"\u2AAF\u0338" },
+        { u"NotPrecedesSlantEqual", u"\u22E0" },
+        { u"NotReverseElement", u"\u220C" },
+        { u"NotRightTriangle", u"\u22EB" },
+        { u"NotRightTriangleBar", u"\u29D0\u0338" },
+        { u"NotRightTriangleEqual", u"\u22ED" },
+        { u"NotSquareSubset", u"\u228F\u0338" },
+        { u"NotSquareSubsetEqual", u"\u22E2" },
+        { u"NotSquareSuperset", u"\u2290\u0338" },
+        { u"NotSquareSupersetEqual", u"\u22E3" },
+        { u"NotSubset", u"\u2282\u20D2" },
+        { u"NotSubsetEqual", u"\u2288" },
+        { u"NotSucceeds", u"\u2281" },
+        { u"NotSucceedsEqual", u"\u2AB0\u0338" },
+        { u"NotSucceedsSlantEqual", u"\u22E1" },
+        { u"NotSucceedsTilde", u"\u227F\u0338" },
+        { u"NotSuperset", u"\u2283\u20D2" },
+        { u"NotSupersetEqual", u"\u2289" },
+        { u"NotTilde", u"\u2241" },
+        { u"NotTildeEqual", u"\u2244" },
+        { u"NotTildeFullEqual", u"\u2247" },
+        { u"NotTildeTilde", u"\u2249" },
+        { u"NotVerticalBar", u"\u2224" },
+        { u"Nscr", u"\U0001D4A9" },
+        { u"Ntilde", u"\u00D1" },
+        { u"Nu", u"\u039D" },
+        { u"OElig", u"\u0152" },
+        { u"Oacute", u"\u00D3" },
+        { u"Ocirc", u"\u00D4" },
+        { u"Ocy", u"\u041E" },
+        { u"Odblac", u"\u0150" },
+        { u"Ofr", u"\U0001D512" },
+        { u"Ograve", u"\u00D2" },
+        { u"Omacr", u"\u014C" },
+        { u"Omega", u"\u03A9" },
+        { u"Omicron", u"\u039F" },
+        { u"Oopf", u"\U0001D546" },
+        { u"OpenCurlyDoubleQuote", u"\u201C" },
+        { u"OpenCurlyQuote", u"\u2018" },
+        { u"Or", u"\u2A54" },
+        { u"Oscr", u"\U0001D4AA" },
+        { u"Oslash", u"\u00D8" },
+        { u"Otilde", u"\u00D5" },
+        { u"Otimes", u"\u2A37" },
+        { u"Ouml", u"\u00D6" },
+        { u"OverBar", u"\u203E" },
+        { u"OverBrace", u"\u23DE" },
+        { u"OverBracket", u"\u23B4" },
+        { u"OverParenthesis", u"\u23DC" },
+        { u"PartialD", u"\u2202" },
+        { u"Pcy", u"\u041F" },
+        { u"Pfr", u"\U0001D513" },
+        { u"Phi", u"\u03A6" },
+        { u"Pi", u"\u03A0" },
+        { u"PlusMinus", u"\u00B1" },
+        { u"Poincareplane", u"\u210C" },
+        { u"Popf", u"\u2119" },
+        { u"Pr", u"\u2ABB" },
+        { u"Precedes", u"\u227A" },
+        { u"PrecedesEqual", u"\u2AAF" },
+        { u"PrecedesSlantEqual", u"\u227C" },
+        { u"PrecedesTilde", u"\u227E" },
+        { u"Prime", u"\u2033" },
+        { u"Product", u"\u220F" },
+        { u"Proportion", u"\u2237" },
+        { u"Proportional", u"\u221D" },
+        { u"Pscr", u"\U0001D4AB" },
+        { u"Psi", u"\u03A8" },
+        { u"QUOT", u"\u0022" },
+        { u"Qfr", u"\U0001D514" },
+        { u"Qopf", u"\u211A" },
+        { u"Qscr", u"\U0001D4AC" },
+        { u"RBarr", u"\u2910" },
+        { u"REG", u"\u00AE" },
+        { u"Racute", u"\u0154" },
+        { u"Rang", u"\u27EB" },
+        { u"Rarr", u"\u21A0" },
+        { u"Rarrtl", u"\u2916" },
+        { u"Rcaron", u"\u0158" },
+        { u"Rcedil", u"\u0156" },
+        { u"Rcy", u"\u0420" },
+        { u"Re", u"\u211C" },
+        { u"ReverseElement", u"\u220B" },
+        { u"ReverseEquilibrium", u"\u21CB" },
+        { u"ReverseUpEquilibrium", u"\u296F" },
+        { u"Rfr", u"\u211C" },
+        { u"Rho", u"\u03A1" },
+        { u"RightAngleBracket", u"\u27E9" },
+        { u"RightArrow", u"\u2192" },
+        { u"RightArrowBar", u"\u21E5" },
+        { u"RightArrowLeftArrow", u"\u21C4" },
+        { u"RightCeiling", u"\u2309" },
+        { u"RightDoubleBracket", u"\u27E7" },
+        { u"RightDownTeeVector", u"\u295D" },
+        { u"RightDownVector", u"\u21C2" },
+        { u"RightDownVectorBar", u"\u2955" },
+        { u"RightFloor", u"\u230B" },
+        { u"RightTee", u"\u22A2" },
+        { u"RightTeeArrow", u"\u21A6" },
+        { u"RightTeeVector", u"\u295B" },
+        { u"RightTriangle", u"\u22B3" },
+        { u"RightTriangleBar", u"\u29D0" },
+        { u"RightTriangleEqual", u"\u22B5" },
+        { u"RightUpDownVector", u"\u294F" },
+        { u"RightUpTeeVector", u"\u295C" },
+        { u"RightUpVector", u"\u21BE" },
+        { u"RightUpVectorBar", u"\u2954" },
+        { u"RightVector", u"\u21C0" },
+        { u"RightVectorBar", u"\u2953" },
+        { u"Rightarrow", u"\u21D2" },
+        { u"Ropf", u"\u211D" },
+        { u"RoundImplies", u"\u2970" },
+        { u"Rrightarrow", u"\u21DB" },
+        { u"Rscr", u"\u211B" },
+        { u"Rsh", u"\u21B1" },
+        { u"RuleDelayed", u"\u29F4" },
+        { u"SHCHcy", u"\u0429" },
+        { u"SHcy", u"\u0428" },
+        { u"SOFTcy", u"\u042C" },
+        { u"Sacute", u"\u015A" },
+        { u"Sc", u"\u2ABC" },
+        { u"Scaron", u"\u0160" },
+        { u"Scedil", u"\u015E" },
+        { u"Scirc", u"\u015C" },
+        { u"Scy", u"\u0421" },
+        { u"Sfr", u"\U0001D516" },
+        { u"ShortDownArrow", u"\u2193" },
+        { u"ShortLeftArrow", u"\u2190" },
+        { u"ShortRightArrow", u"\u2192" },
+        { u"ShortUpArrow", u"\u2191" },
+        { u"Sigma", u"\u03A3" },
+        { u"SmallCircle", u"\u2218" },
+        { u"Sopf", u"\U0001D54A" },
+        { u"Sqrt", u"\u221A" },
+        { u"Square", u"\u25A1" },
+        { u"SquareIntersection", u"\u2293" },
+        { u"SquareSubset", u"\u228F" },
+        { u"SquareSubsetEqual", u"\u2291" },
+        { u"SquareSuperset", u"\u2290" },
+        { u"SquareSupersetEqual", u"\u2292" },
+        { u"SquareUnion", u"\u2294" },
+        { u"Sscr", u"\U0001D4AE" },
+        { u"Star", u"\u22C6" },
+        { u"Sub", u"\u22D0" },
+        { u"Subset", u"\u22D0" },
+        { u"SubsetEqual", u"\u2286" },
+        { u"Succeeds", u"\u227B" },
+        { u"SucceedsEqual", u"\u2AB0" },
+        { u"SucceedsSlantEqual", u"\u227D" },
+        { u"SucceedsTilde", u"\u227F" },
+        { u"SuchThat", u"\u220B" },
+        { u"Sum", u"\u2211" },
+        { u"Sup", u"\u22D1" },
+        { u"Superset", u"\u2283" },
+        { u"SupersetEqual", u"\u2287" },
+        { u"Supset", u"\u22D1" },
+        { u"THORN", u"\u00DE" },
+        { u"TRADE", u"\u2122" },
+        { u"TSHcy", u"\u040B" },
+        { u"TScy", u"\u0426" },
+        { u"Tab", u"\u0009" },
+        { u"Tau", u"\u03A4" },
+        { u"Tcaron", u"\u0164" },
+        { u"Tcedil", u"\u0162" },
+        { u"Tcy", u"\u0422" },
+        { u"Tfr", u"\U0001D517" },
+        { u"Therefore", u"\u2234" },
+        { u"Theta", u"\u0398" },
+        { u"ThickSpace", u"\u205F\u200A" },
+        { u"ThinSpace", u"\u2009" },
+        { u"Tilde", u"\u223C" },
+        { u"TildeEqual", u"\u2243" },
+        { u"TildeFullEqual", u"\u2245" },
+        { u"TildeTilde", u"\u2248" },
+        { u"Topf", u"\U0001D54B" },
+        { u"TripleDot", u"\u20DB" },
+        { u"Tscr", u"\U0001D4AF" },
+        { u"Tstrok", u"\u0166" },
+        { u"Uacute", u"\u00DA" },
+        { u"Uarr", u"\u219F" },
+        { u"Uarrocir", u"\u2949" },
+        { u"Ubrcy", u"\u040E" },
+        { u"Ubreve", u"\u016C" },
+        { u"Ucirc", u"\u00DB" },
+        { u"Ucy", u"\u0423" },
+        { u"Udblac", u"\u0170" },
+        { u"Ufr", u"\U0001D518" },
+        { u"Ugrave", u"\u00D9" },
+        { u"Umacr", u"\u016A" },
+        { u"UnderBar", u"\u005F" },
+        { u"UnderBrace", u"\u23DF" },
+        { u"UnderBracket", u"\u23B5" },
+        { u"UnderParenthesis", u"\u23DD" },
+        { u"Union", u"\u22C3" },
+        { u"UnionPlus", u"\u228E" },
+        { u"Uogon", u"\u0172" },
+        { u"Uopf", u"\U0001D54C" },
+        { u"UpArrow", u"\u2191" },
+        { u"UpArrowBar", u"\u2912" },
+        { u"UpArrowDownArrow", u"\u21C5" },
+        { u"UpDownArrow", u"\u2195" },
+        { u"UpEquilibrium", u"\u296E" },
+        { u"UpTee", u"\u22A5" },
+        { u"UpTeeArrow", u"\u21A5" },
+        { u"Uparrow", u"\u21D1" },
+        { u"Updownarrow", u"\u21D5" },
+        { u"UpperLeftArrow", u"\u2196" },
+        { u"UpperRightArrow", u"\u2197" },
+        { u"Upsi", u"\u03D2" },
+        { u"Upsilon", u"\u03A5" },
+        { u"Uring", u"\u016E" },
+        { u"Uscr", u"\U0001D4B0" },
+        { u"Utilde", u"\u0168" },
+        { u"Uuml", u"\u00DC" },
+        { u"VDash", u"\u22AB" },
+        { u"Vbar", u"\u2AEB" },
+        { u"Vcy", u"\u0412" },
+        { u"Vdash", u"\u22A9" },
+        { u"Vdashl", u"\u2AE6" },
+        { u"Vee", u"\u22C1" },
+        { u"Verbar", u"\u2016" },
+        { u"Vert", u"\u2016" },
+        { u"VerticalBar", u"\u2223" },
+        { u"VerticalLine", u"\u007C" },
+        { u"VerticalSeparator", u"\u2758" },
+        { u"VerticalTilde", u"\u2240" },
+        { u"VeryThinSpace", u"\u200A" },
+        { u"Vfr", u"\U0001D519" },
+        { u"Vopf", u"\U0001D54D" },
+        { u"Vscr", u"\U0001D4B1" },
+        { u"Vvdash", u"\u22AA" },
+        { u"Wcirc", u"\u0174" },
+        { u"Wedge", u"\u22C0" },
+        { u"Wfr", u"\U0001D51A" },
+        { u"Wopf", u"\U0001D54E" },
+        { u"Wscr", u"\U0001D4B2" },
+        { u"Xfr", u"\U0001D51B" },
+        { u"Xi", u"\u039E" },
+        { u"Xopf", u"\U0001D54F" },
+        { u"Xscr", u"\U0001D4B3" },
+        { u"YAcy", u"\u042F" },
+        { u"YIcy", u"\u0407" },
+        { u"YUcy", u"\u042E" },
+        { u"Yacute", u"\u00DD" },
+        { u"Ycirc", u"\u0176" },
+        { u"Ycy", u"\u042B" },
+        { u"Yfr", u"\U0001D51C" },
+        { u"Yopf", u"\U0001D550" },
+        { u"Yscr", u"\U0001D4B4" },
+        { u"Yuml", u"\u0178" },
+        { u"ZHcy", u"\u0416" },
+        { u"Zacute", u"\u0179" },
+        { u"Zcaron", u"\u017D" },
+        { u"Zcy", u"\u0417" },
+        { u"Zdot", u"\u017B" },
+        { u"ZeroWidthSpace", u"\u200B" },
+        { u"Zeta", u"\u0396" },
+        { u"Zfr", u"\u2128" },
+        { u"Zopf", u"\u2124" },
+        { u"Zscr", u"\U0001D4B5" },
+        { u"aacute", u"\u00E1" },
+        { u"abreve", u"\u0103" },
+        { u"ac", u"\u223E" },
+        { u"acE", u"\u223E\u0333" },
+        { u"acd", u"\u223F" },
+        { u"acirc", u"\u00E2" },
+        { u"acute", u"\u00B4" },
+        { u"acy", u"\u0430" },
+        { u"aelig", u"\u00E6" },
+        { u"af", u"\u2061" },
+        { u"afr", u"\U0001D51E" },
+        { u"agrave", u"\u00E0" },
+        { u"alefsym", u"\u2135" },
+        { u"aleph", u"\u2135" },
+        { u"alpha", u"\u03B1" },
+        { u"amacr", u"\u0101" },
+        { u"amalg", u"\u2A3F" },
+        { u"amp", u"\u0026" },
+        { u"and", u"\u2227" },
+        { u"andand", u"\u2A55" },
+        { u"andd", u"\u2A5C" },
+        { u"andslope", u"\u2A58" },
+        { u"andv", u"\u2A5A" },
+        { u"ang", u"\u2220" },
+        { u"ange", u"\u29A4" },
+        { u"angle", u"\u2220" },
+        { u"angmsd", u"\u2221" },
+        { u"angmsdaa", u"\u29A8" },
+        { u"angmsdab", u"\u29A9" },
+        { u"angmsdac", u"\u29AA" },
+        { u"angmsdad", u"\u29AB" },
+        { u"angmsdae", u"\u29AC" },
+        { u"angmsdaf", u"\u29AD" },
+        { u"angmsdag", u"\u29AE" },
+        { u"angmsdah", u"\u29AF" },
+        { u"angrt", u"\u221F" },
+        { u"angrtvb", u"\u22BE" },
+        { u"angrtvbd", u"\u299D" },
+        { u"angsph", u"\u2222" },
+        { u"angst", u"\u00C5" },
+        { u"angzarr", u"\u237C" },
+        { u"aogon", u"\u0105" },
+        { u"aopf", u"\U0001D552" },
+        { u"ap", u"\u2248" },
+        { u"apE", u"\u2A70" },
+        { u"apacir", u"\u2A6F" },
+        { u"ape", u"\u224A" },
+        { u"apid", u"\u224B" },
+        { u"apos", u"\u0027" },
+        { u"approx", u"\u2248" },
+        { u"approxeq", u"\u224A" },
+        { u"aring", u"\u00E5" },
+        { u"ascr", u"\U0001D4B6" },
+        { u"ast", u"\u002A" },
+        { u"asymp", u"\u2248" },
+        { u"asympeq", u"\u224D" },
+        { u"atilde", u"\u00E3" },
+        { u"auml", u"\u00E4" },
+        { u"awconint", u"\u2233" },
+        { u"awint", u"\u2A11" },
+        { u"bNot", u"\u2AED" },
+        { u"backcong", u"\u224C" },
+        { u"backepsilon", u"\u03F6" },
+        { u"backprime", u"\u2035" },
+        { u"backsim", u"\u223D" },
+        { u"backsimeq", u"\u22CD" },
+        { u"barvee", u"\u22BD" },
+        { u"barwed", u"\u2305" },
+        { u"barwedge", u"\u2305" },
+        { u"bbrk", u"\u23B5" },
+        { u"bbrktbrk", u"\u23B6" },
+        { u"bcong", u"\u224C" },
+        { u"bcy", u"\u0431" },
+        { u"bdquo", u"\u201E" },
+        { u"becaus", u"\u2235" },
+        { u"because", u"\u2235" },
+        { u"bemptyv", u"\u29B0" },
+        { u"bepsi", u"\u03F6" },
+        { u"bernou", u"\u212C" },
+        { u"beta", u"\u03B2" },
+        { u"beth", u"\u2136" },
+        { u"between", u"\u226C" },
+        { u"bfr", u"\U0001D51F" },
+        { u"bigcap", u"\u22C2" },
+        { u"bigcirc", u"\u25EF" },
+        { u"bigcup", u"\u22C3" },
+        { u"bigodot", u"\u2A00" },
+        { u"bigoplus", u"\u2A01" },
+        { u"bigotimes", u"\u2A02" },
+        { u"bigsqcup", u"\u2A06" },
+        { u"bigstar", u"\u2605" },
+        { u"bigtriangledown", u"\u25BD" },
+        { u"bigtriangleup", u"\u25B3" },
+        { u"biguplus", u"\u2A04" },
+        { u"bigvee", u"\u22C1" },
+        { u"bigwedge", u"\u22C0" },
+        { u"bkarow", u"\u290D" },
+        { u"blacklozenge", u"\u29EB" },
+        { u"blacksquare", u"\u25AA" },
+        { u"blacktriangle", u"\u25B4" },
+        { u"blacktriangledown", u"\u25BE" },
+        { u"blacktriangleleft", u"\u25C2" },
+        { u"blacktriangleright", u"\u25B8" },
+        { u"blank", u"\u2423" },
+        { u"blk12", u"\u2592" },
+        { u"blk14", u"\u2591" },
+        { u"blk34", u"\u2593" },
+        { u"block", u"\u2588" },
+        { u"bne", u"\u003D\u20E5" },
+        { u"bnequiv", u"\u2261\u20E5" },
+        { u"bnot", u"\u2310" },
+        { u"bopf", u"\U0001D553" },
+        { u"bot", u"\u22A5" },
+        { u"bottom", u"\u22A5" },
+        { u"bowtie", u"\u22C8" },
+        { u"boxDL", u"\u2557" },
+        { u"boxDR", u"\u2554" },
+        { u"boxDl", u"\u2556" },
+        { u"boxDr", u"\u2553" },
+        { u"boxH", u"\u2550" },
+        { u"boxHD", u"\u2566" },
+        { u"boxHU", u"\u2569" },
+        { u"boxHd", u"\u2564" },
+        { u"boxHu", u"\u2567" },
+        { u"boxUL", u"\u255D" },
+        { u"boxUR", u"\u255A" },
+        { u"boxUl", u"\u255C" },
+        { u"boxUr", u"\u2559" },
+        { u"boxV", u"\u2551" },
+        { u"boxVH", u"\u256C" },
+        { u"boxVL", u"\u2563" },
+        { u"boxVR", u"\u2560" },
+        { u"boxVh", u"\u256B" },
+        { u"boxVl", u"\u2562" },
+        { u"boxVr", u"\u255F" },
+        { u"boxbox", u"\u29C9" },
+        { u"boxdL", u"\u2555" },
+        { u"boxdR", u"\u2552" },
+        { u"boxdl", u"\u2510" },
+        { u"boxdr", u"\u250C" },
+        { u"boxh", u"\u2500" },
+        { u"boxhD", u"\u2565" },
+        { u"boxhU", u"\u2568" },
+        { u"boxhd", u"\u252C" },
+        { u"boxhu", u"\u2534" },
+        { u"boxminus", u"\u229F" },
+        { u"boxplus", u"\u229E" },
+        { u"boxtimes", u"\u22A0" },
+        { u"boxuL", u"\u255B" },
+        { u"boxuR", u"\u2558" },
+        { u"boxul", u"\u2518" },
+        { u"boxur", u"\u2514" },
+        { u"boxv", u"\u2502" },
+        { u"boxvH", u"\u256A" },
+        { u"boxvL", u"\u2561" },
+        { u"boxvR", u"\u255E" },
+        { u"boxvh", u"\u253C" },
+        { u"boxvl", u"\u2524" },
+        { u"boxvr", u"\u251C" },
+        { u"bprime", u"\u2035" },
+        { u"breve", u"\u02D8" },
+        { u"brvbar", u"\u00A6" },
+        { u"bscr", u"\U0001D4B7" },
+        { u"bsemi", u"\u204F" },
+        { u"bsim", u"\u223D" },
+        { u"bsime", u"\u22CD" },
+        { u"bsol", u"\u005C" },
+        { u"bsolb", u"\u29C5" },
+        { u"bsolhsub", u"\u27C8" },
+        { u"bull", u"\u2022" },
+        { u"bullet", u"\u2022" },
+        { u"bump", u"\u224E" },
+        { u"bumpE", u"\u2AAE" },
+        { u"bumpe", u"\u224F" },
+        { u"bumpeq", u"\u224F" },
+        { u"cacute", u"\u0107" },
+        { u"cap", u"\u2229" },
+        { u"capand", u"\u2A44" },
+        { u"capbrcup", u"\u2A49" },
+        { u"capcap", u"\u2A4B" },
+        { u"capcup", u"\u2A47" },
+        { u"capdot", u"\u2A40" },
+        { u"caps", u"\u2229\uFE00" },
+        { u"caret", u"\u2041" },
+        { u"caron", u"\u02C7" },
+        { u"ccaps", u"\u2A4D" },
+        { u"ccaron", u"\u010D" },
+        { u"ccedil", u"\u00E7" },
+        { u"ccirc", u"\u0109" },
+        { u"ccups", u"\u2A4C" },
+        { u"ccupssm", u"\u2A50" },
+        { u"cdot", u"\u010B" },
+        { u"cedil", u"\u00B8" },
+        { u"cemptyv", u"\u29B2" },
+        { u"cent", u"\u00A2" },
+        { u"centerdot", u"\u00B7" },
+        { u"cfr", u"\U0001D520" },
+        { u"chcy", u"\u0447" },
+        { u"check", u"\u2713" },
+        { u"checkmark", u"\u2713" },
+        { u"chi", u"\u03C7" },
+        { u"cir", u"\u25CB" },
+        { u"cirE", u"\u29C3" },
+        { u"circ", u"\u02C6" },
+        { u"circeq", u"\u2257" },
+        { u"circlearrowleft", u"\u21BA" },
+        { u"circlearrowright", u"\u21BB" },
+        { u"circledR", u"\u00AE" },
+        { u"circledS", u"\u24C8" },
+        { u"circledast", u"\u229B" },
+        { u"circledcirc", u"\u229A" },
+        { u"circleddash", u"\u229D" },
+        { u"cire", u"\u2257" },
+        { u"cirfnint", u"\u2A10" },
+        { u"cirmid", u"\u2AEF" },
+        { u"cirscir", u"\u29C2" },
+        { u"clubs", u"\u2663" },
+        { u"clubsuit", u"\u2663" },
+        { u"colon", u"\u003A" },
+        { u"colone", u"\u2254" },
+        { u"coloneq", u"\u2254" },
+        { u"comma", u"\u002C" },
+        { u"commat", u"\u0040" },
+        { u"comp", u"\u2201" },
+        { u"compfn", u"\u2218" },
+        { u"complement", u"\u2201" },
+        { u"complexes", u"\u2102" },
+        { u"cong", u"\u2245" },
+        { u"congdot", u"\u2A6D" },
+        { u"conint", u"\u222E" },
+        { u"copf", u"\U0001D554" },
+        { u"coprod", u"\u2210" },
+        { u"copy", u"\u00A9" },
+        { u"copysr", u"\u2117" },
+        { u"crarr", u"\u21B5" },
+        { u"cross", u"\u2717" },
+        { u"cscr", u"\U0001D4B8" },
+        { u"csub", u"\u2ACF" },
+        { u"csube", u"\u2AD1" },
+        { u"csup", u"\u2AD0" },
+        { u"csupe", u"\u2AD2" },
+        { u"ctdot", u"\u22EF" },
+        { u"cudarrl", u"\u2938" },
+        { u"cudarrr", u"\u2935" },
+        { u"cuepr", u"\u22DE" },
+        { u"cuesc", u"\u22DF" },
+        { u"cularr", u"\u21B6" },
+        { u"cularrp", u"\u293D" },
+        { u"cup", u"\u222A" },
+        { u"cupbrcap", u"\u2A48" },
+        { u"cupcap", u"\u2A46" },
+        { u"cupcup", u"\u2A4A" },
+        { u"cupdot", u"\u228D" },
+        { u"cupor", u"\u2A45" },
+        { u"cups", u"\u222A\uFE00" },
+        { u"curarr", u"\u21B7" },
+        { u"curarrm", u"\u293C" },
+        { u"curlyeqprec", u"\u22DE" },
+        { u"curlyeqsucc", u"\u22DF" },
+        { u"curlyvee", u"\u22CE" },
+        { u"curlywedge", u"\u22CF" },
+        { u"curren", u"\u00A4" },
+        { u"curvearrowleft", u"\u21B6" },
+        { u"curvearrowright", u"\u21B7" },
+        { u"cuvee", u"\u22CE" },
+        { u"cuwed", u"\u22CF" },
+        { u"cwconint", u"\u2232" },
+        { u"cwint", u"\u2231" },
+        { u"cylcty", u"\u232D" },
+        { u"dArr", u"\u21D3" },
+        { u"dHar", u"\u2965" },
+        { u"dagger", u"\u2020" },
+        { u"daleth", u"\u2138" },
+        { u"darr", u"\u2193" },
+        { u"dash", u"\u2010" },
+        { u"dashv", u"\u22A3" },
+        { u"dbkarow", u"\u290F" },
+        { u"dblac", u"\u02DD" },
+        { u"dcaron", u"\u010F" },
+        { u"dcy", u"\u0434" },
+        { u"dd", u"\u2146" },
+        { u"ddagger", u"\u2021" },
+        { u"ddarr", u"\u21CA" },
+        { u"ddotseq", u"\u2A77" },
+        { u"deg", u"\u00B0" },
+        { u"delta", u"\u03B4" },
+        { u"demptyv", u"\u29B1" },
+        { u"dfisht", u"\u297F" },
+        { u"dfr", u"\U0001D521" },
+        { u"dharl", u"\u21C3" },
+        { u"dharr", u"\u21C2" },
+        { u"diam", u"\u22C4" },
+        { u"diamond", u"\u22C4" },
+        { u"diamondsuit", u"\u2666" },
+        { u"diams", u"\u2666" },
+        { u"die", u"\u00A8" },
+        { u"digamma", u"\u03DD" },
+        { u"disin", u"\u22F2" },
+        { u"div", u"\u00F7" },
+        { u"divide", u"\u00F7" },
+        { u"divideontimes", u"\u22C7" },
+        { u"divonx", u"\u22C7" },
+        { u"djcy", u"\u0452" },
+        { u"dlcorn", u"\u231E" },
+        { u"dlcrop", u"\u230D" },
+        { u"dollar", u"\u0024" },
+        { u"dopf", u"\U0001D555" },
+        { u"dot", u"\u02D9" },
+        { u"doteq", u"\u2250" },
+        { u"doteqdot", u"\u2251" },
+        { u"dotminus", u"\u2238" },
+        { u"dotplus", u"\u2214" },
+        { u"dotsquare", u"\u22A1" },
+        { u"doublebarwedge", u"\u2306" },
+        { u"downarrow", u"\u2193" },
+        { u"downdownarrows", u"\u21CA" },
+        { u"downharpoonleft", u"\u21C3" },
+        { u"downharpoonright", u"\u21C2" },
+        { u"drbkarow", u"\u2910" },
+        { u"drcorn", u"\u231F" },
+        { u"drcrop", u"\u230C" },
+        { u"dscr", u"\U0001D4B9" },
+        { u"dscy", u"\u0455" },
+        { u"dsol", u"\u29F6" },
+        { u"dstrok", u"\u0111" },
+        { u"dtdot", u"\u22F1" },
+        { u"dtri", u"\u25BF" },
+        { u"dtrif", u"\u25BE" },
+        { u"duarr", u"\u21F5" },
+        { u"duhar", u"\u296F" },
+        { u"dwangle", u"\u29A6" },
+        { u"dzcy", u"\u045F" },
+        { u"dzigrarr", u"\u27FF" },
+        { u"eDDot", u"\u2A77" },
+        { u"eDot", u"\u2251" },
+        { u"eacute", u"\u00E9" },
+        { u"easter", u"\u2A6E" },
+        { u"ecaron", u"\u011B" },
+        { u"ecir", u"\u2256" },
+        { u"ecirc", u"\u00EA" },
+        { u"ecolon", u"\u2255" },
+        { u"ecy", u"\u044D" },
+        { u"edot", u"\u0117" },
+        { u"ee", u"\u2147" },
+        { u"efDot", u"\u2252" },
+        { u"efr", u"\U0001D522" },
+        { u"eg", u"\u2A9A" },
+        { u"egrave", u"\u00E8" },
+        { u"egs", u"\u2A96" },
+        { u"egsdot", u"\u2A98" },
+        { u"el", u"\u2A99" },
+        { u"elinters", u"\u23E7" },
+        { u"ell", u"\u2113" },
+        { u"els", u"\u2A95" },
+        { u"elsdot", u"\u2A97" },
+        { u"emacr", u"\u0113" },
+        { u"empty", u"\u2205" },
+        { u"emptyset", u"\u2205" },
+        { u"emptyv", u"\u2205" },
+        { u"emsp", u"\u2003" },
+        { u"emsp13", u"\u2004" },
+        { u"emsp14", u"\u2005" },
+        { u"eng", u"\u014B" },
+        { u"ensp", u"\u2002" },
+        { u"eogon", u"\u0119" },
+        { u"eopf", u"\U0001D556" },
+        { u"epar", u"\u22D5" },
+        { u"eparsl", u"\u29E3" },
+        { u"eplus", u"\u2A71" },
+        { u"epsi", u"\u03B5" },
+        { u"epsilon", u"\u03B5" },
+        { u"epsiv", u"\u03F5" },
+        { u"eqcirc", u"\u2256" },
+        { u"eqcolon", u"\u2255" },
+        { u"eqsim", u"\u2242" },
+        { u"eqslantgtr", u"\u2A96" },
+        { u"eqslantless", u"\u2A95" },
+        { u"equals", u"\u003D" },
+        { u"equest", u"\u225F" },
+        { u"equiv", u"\u2261" },
+        { u"equivDD", u"\u2A78" },
+        { u"eqvparsl", u"\u29E5" },
+        { u"erDot", u"\u2253" },
+        { u"erarr", u"\u2971" },
+        { u"escr", u"\u212F" },
+        { u"esdot", u"\u2250" },
+        { u"esim", u"\u2242" },
+        { u"eta", u"\u03B7" },
+        { u"eth", u"\u00F0" },
+        { u"euml", u"\u00EB" },
+        { u"euro", u"\u20AC" },
+        { u"excl", u"\u0021" },
+        { u"exist", u"\u2203" },
+        { u"expectation", u"\u2130" },
+        { u"exponentiale", u"\u2147" },
+        { u"fallingdotseq", u"\u2252" },
+        { u"fcy", u"\u0444" },
+        { u"female", u"\u2640" },
+        { u"ffilig", u"\uFB03" },
+        { u"fflig", u"\uFB00" },
+        { u"ffllig", u"\uFB04" },
+        { u"ffr", u"\U0001D523" },
+        { u"filig", u"\uFB01" },
+        { u"fjlig", u"\u0066\u006A" },
+        { u"flat", u"\u266D" },
+        { u"fllig", u"\uFB02" },
+        { u"fltns", u"\u25B1" },
+        { u"fnof", u"\u0192" },
+        { u"fopf", u"\U0001D557" },
+        { u"forall", u"\u2200" },
+        { u"fork", u"\u22D4" },
+        { u"forkv", u"\u2AD9" },
+        { u"fpartint", u"\u2A0D" },
+        { u"frac12", u"\u00BD" },
+        { u"frac13", u"\u2153" },
+        { u"frac14", u"\u00BC" },
+        { u"frac15", u"\u2155" },
+        { u"frac16", u"\u2159" },
+        { u"frac18", u"\u215B" },
+        { u"frac23", u"\u2154" },
+        { u"frac25", u"\u2156" },
+        { u"frac34", u"\u00BE" },
+        { u"frac35", u"\u2157" },
+        { u"frac38", u"\u215C" },
+        { u"frac45", u"\u2158" },
+        { u"frac56", u"\u215A" },
+        { u"frac58", u"\u215D" },
+        { u"frac78", u"\u215E" },
+        { u"frasl", u"\u2044" },
+        { u"frown", u"\u2322" },
+        { u"fscr", u"\U0001D4BB" },
+        { u"gE", u"\u2267" },
+        { u"gEl", u"\u2A8C" },
+        { u"gacute", u"\u01F5" },
+        { u"gamma", u"\u03B3" },
+        { u"gammad", u"\u03DD" },
+        { u"gap", u"\u2A86" },
+        { u"gbreve", u"\u011F" },
+        { u"gcirc", u"\u011D" },
+        { u"gcy", u"\u0433" },
+        { u"gdot", u"\u0121" },
+        { u"ge", u"\u2265" },
+        { u"gel", u"\u22DB" },
+        { u"geq", u"\u2265" },
+        { u"geqq", u"\u2267" },
+        { u"geqslant", u"\u2A7E" },
+        { u"ges", u"\u2A7E" },
+        { u"gescc", u"\u2AA9" },
+        { u"gesdot", u"\u2A80" },
+        { u"gesdoto", u"\u2A82" },
+        { u"gesdotol", u"\u2A84" },
+        { u"gesl", u"\u22DB\uFE00" },
+        { u"gesles", u"\u2A94" },
+        { u"gfr", u"\U0001D524" },
+        { u"gg", u"\u226B" },
+        { u"ggg", u"\u22D9" },
+        { u"gimel", u"\u2137" },
+        { u"gjcy", u"\u0453" },
+        { u"gl", u"\u2277" },
+        { u"glE", u"\u2A92" },
+        { u"gla", u"\u2AA5" },
+        { u"glj", u"\u2AA4" },
+        { u"gnE", u"\u2269" },
+        { u"gnap", u"\u2A8A" },
+        { u"gnapprox", u"\u2A8A" },
+        { u"gne", u"\u2A88" },
+        { u"gneq", u"\u2A88" },
+        { u"gneqq", u"\u2269" },
+        { u"gnsim", u"\u22E7" },
+        { u"gopf", u"\U0001D558" },
+        { u"grave", u"\u0060" },
+        { u"gscr", u"\u210A" },
+        { u"gsim", u"\u2273" },
+        { u"gsime", u"\u2A8E" },
+        { u"gsiml", u"\u2A90" },
+        { u"gt", u"\u003E" },
+        { u"gtcc", u"\u2AA7" },
+        { u"gtcir", u"\u2A7A" },
+        { u"gtdot", u"\u22D7" },
+        { u"gtlPar", u"\u2995" },
+        { u"gtquest", u"\u2A7C" },
+        { u"gtrapprox", u"\u2A86" },
+        { u"gtrarr", u"\u2978" },
+        { u"gtrdot", u"\u22D7" },
+        { u"gtreqless", u"\u22DB" },
+        { u"gtreqqless", u"\u2A8C" },
+        { u"gtrless", u"\u2277" },
+        { u"gtrsim", u"\u2273" },
+        { u"gvertneqq", u"\u2269\uFE00" },
+        { u"gvnE", u"\u2269\uFE00" },
+        { u"hArr", u"\u21D4" },
+        { u"hairsp", u"\u200A" },
+        { u"half", u"\u00BD" },
+        { u"hamilt", u"\u210B" },
+        { u"hardcy", u"\u044A" },
+        { u"harr", u"\u2194" },
+        { u"harrcir", u"\u2948" },
+        { u"harrw", u"\u21AD" },
+        { u"hbar", u"\u210F" },
+        { u"hcirc", u"\u0125" },
+        { u"hearts", u"\u2665" },
+        { u"heartsuit", u"\u2665" },
+        { u"hellip", u"\u2026" },
+        { u"hercon", u"\u22B9" },
+        { u"hfr", u"\U0001D525" },
+        { u"hksearow", u"\u2925" },
+        { u"hkswarow", u"\u2926" },
+        { u"hoarr", u"\u21FF" },
+        { u"homtht", u"\u223B" },
+        { u"hookleftarrow", u"\u21A9" },
+        { u"hookrightarrow", u"\u21AA" },
+        { u"hopf", u"\U0001D559" },
+        { u"horbar", u"\u2015" },
+        { u"hscr", u"\U0001D4BD" },
+        { u"hslash", u"\u210F" },
+        { u"hstrok", u"\u0127" },
+        { u"hybull", u"\u2043" },
+        { u"hyphen", u"\u2010" },
+        { u"iacute", u"\u00ED" },
+        { u"ic", u"\u2063" },
+        { u"icirc", u"\u00EE" },
+        { u"icy", u"\u0438" },
+        { u"iecy", u"\u0435" },
+        { u"iexcl", u"\u00A1" },
+        { u"iff", u"\u21D4" },
+        { u"ifr", u"\U0001D526" },
+        { u"igrave", u"\u00EC" },
+        { u"ii", u"\u2148" },
+        { u"iiiint", u"\u2A0C" },
+        { u"iiint", u"\u222D" },
+        { u"iinfin", u"\u29DC" },
+        { u"iiota", u"\u2129" },
+        { u"ijlig", u"\u0133" },
+        { u"imacr", u"\u012B" },
+        { u"image", u"\u2111" },
+        { u"imagline", u"\u2110" },
+        { u"imagpart", u"\u2111" },
+        { u"imath", u"\u0131" },
+        { u"imof", u"\u22B7" },
+        { u"imped", u"\u01B5" },
+        { u"in", u"\u2208" },
+        { u"incare", u"\u2105" },
+        { u"infin", u"\u221E" },
+        { u"infintie", u"\u29DD" },
+        { u"inodot", u"\u0131" },
+        { u"int", u"\u222B" },
+        { u"intcal", u"\u22BA" },
+        { u"integers", u"\u2124" },
+        { u"intercal", u"\u22BA" },
+        { u"intlarhk", u"\u2A17" },
+        { u"intprod", u"\u2A3C" },
+        { u"iocy", u"\u0451" },
+        { u"iogon", u"\u012F" },
+        { u"iopf", u"\U0001D55A" },
+        { u"iota", u"\u03B9" },
+        { u"iprod", u"\u2A3C" },
+        { u"iquest", u"\u00BF" },
+        { u"iscr", u"\U0001D4BE" },
+        { u"isin", u"\u2208" },
+        { u"isinE", u"\u22F9" },
+        { u"isindot", u"\u22F5" },
+        { u"isins", u"\u22F4" },
+        { u"isinsv", u"\u22F3" },
+        { u"isinv", u"\u2208" },
+        { u"it", u"\u2062" },
+        { u"itilde", u"\u0129" },
+        { u"iukcy", u"\u0456" },
+        { u"iuml", u"\u00EF" },
+        { u"jcirc", u"\u0135" },
+        { u"jcy", u"\u0439" },
+        { u"jfr", u"\U0001D527" },
+        { u"jmath", u"\u0237" },
+        { u"jopf", u"\U0001D55B" },
+        { u"jscr", u"\U0001D4BF" },
+        { u"jsercy", u"\u0458" },
+        { u"jukcy", u"\u0454" },
+        { u"kappa", u"\u03BA" },
+        { u"kappav", u"\u03F0" },
+        { u"kcedil", u"\u0137" },
+        { u"kcy", u"\u043A" },
+        { u"kfr", u"\U0001D528" },
+        { u"kgreen", u"\u0138" },
+        { u"khcy", u"\u0445" },
+        { u"kjcy", u"\u045C" },
+        { u"kopf", u"\U0001D55C" },
+        { u"kscr", u"\U0001D4C0" },
+        { u"lAarr", u"\u21DA" },
+        { u"lArr", u"\u21D0" },
+        { u"lAtail", u"\u291B" },
+        { u"lBarr", u"\u290E" },
+        { u"lE", u"\u2266" },
+        { u"lEg", u"\u2A8B" },
+        { u"lHar", u"\u2962" },
+        { u"lacute", u"\u013A" },
+        { u"laemptyv", u"\u29B4" },
+        { u"lagran", u"\u2112" },
+        { u"lambda", u"\u03BB" },
+        { u"lang", u"\u27E8" },
+        { u"langd", u"\u2991" },
+        { u"langle", u"\u27E8" },
+        { u"lap", u"\u2A85" },
+        { u"laquo", u"\u00AB" },
+        { u"larr", u"\u2190" },
+        { u"larrb", u"\u21E4" },
+        { u"larrbfs", u"\u291F" },
+        { u"larrfs", u"\u291D" },
+        { u"larrhk", u"\u21A9" },
+        { u"larrlp", u"\u21AB" },
+        { u"larrpl", u"\u2939" },
+        { u"larrsim", u"\u2973" },
+        { u"larrtl", u"\u21A2" },
+        { u"lat", u"\u2AAB" },
+        { u"latail", u"\u2919" },
+        { u"late", u"\u2AAD" },
+        { u"lates", u"\u2AAD\uFE00" },
+        { u"lbarr", u"\u290C" },
+        { u"lbbrk", u"\u2772" },
+        { u"lbrace", u"\u007B" },
+        { u"lbrack", u"\u005B" },
+        { u"lbrke", u"\u298B" },
+        { u"lbrksld", u"\u298F" },
+        { u"lbrkslu", u"\u298D" },
+        { u"lcaron", u"\u013E" },
+        { u"lcedil", u"\u013C" },
+        { u"lceil", u"\u2308" },
+        { u"lcub", u"\u007B" },
+        { u"lcy", u"\u043B" },
+        { u"ldca", u"\u2936" },
+        { u"ldquo", u"\u201C" },
+        { u"ldquor", u"\u201E" },
+        { u"ldrdhar", u"\u2967" },
+        { u"ldrushar", u"\u294B" },
+        { u"ldsh", u"\u21B2" },
+        { u"le", u"\u2264" },
+        { u"leftarrow", u"\u2190" },
+        { u"leftarrowtail", u"\u21A2" },
+        { u"leftharpoondown", u"\u21BD" },
+        { u"leftharpoonup", u"\u21BC" },
+        { u"leftleftarrows", u"\u21C7" },
+        { u"leftrightarrow", u"\u2194" },
+        { u"leftrightarrows", u"\u21C6" },
+        { u"leftrightharpoons", u"\u21CB" },
+        { u"leftrightsquigarrow", u"\u21AD" },
+        { u"leftthreetimes", u"\u22CB" },
+        { u"leg", u"\u22DA" },
+        { u"leq", u"\u2264" },
+        { u"leqq", u"\u2266" },
+        { u"leqslant", u"\u2A7D" },
+        { u"les", u"\u2A7D" },
+        { u"lescc", u"\u2AA8" },
+        { u"lesdot", u"\u2A7F" },
+        { u"lesdoto", u"\u2A81" },
+        { u"lesdotor", u"\u2A83" },
+        { u"lesg", u"\u22DA\uFE00" },
+        { u"lesges", u"\u2A93" },
+        { u"lessapprox", u"\u2A85" },
+        { u"lessdot", u"\u22D6" },
+        { u"lesseqgtr", u"\u22DA" },
+        { u"lesseqqgtr", u"\u2A8B" },
+        { u"lessgtr", u"\u2276" },
+        { u"lesssim", u"\u2272" },
+        { u"lfisht", u"\u297C" },
+        { u"lfloor", u"\u230A" },
+        { u"lfr", u"\U0001D529" },
+        { u"lg", u"\u2276" },
+        { u"lgE", u"\u2A91" },
+        { u"lhard", u"\u21BD" },
+        { u"lharu", u"\u21BC" },
+        { u"lharul", u"\u296A" },
+        { u"lhblk", u"\u2584" },
+        { u"ljcy", u"\u0459" },
+        { u"ll", u"\u226A" },
+        { u"llarr", u"\u21C7" },
+        { u"llcorner", u"\u231E" },
+        { u"llhard", u"\u296B" },
+        { u"lltri", u"\u25FA" },
+        { u"lmidot", u"\u0140" },
+        { u"lmoust", u"\u23B0" },
+        { u"lmoustache", u"\u23B0" },
+        { u"lnE", u"\u2268" },
+        { u"lnap", u"\u2A89" },
+        { u"lnapprox", u"\u2A89" },
+        { u"lne", u"\u2A87" },
+        { u"lneq", u"\u2A87" },
+        { u"lneqq", u"\u2268" },
+        { u"lnsim", u"\u22E6" },
+        { u"loang", u"\u27EC" },
+        { u"loarr", u"\u21FD" },
+        { u"lobrk", u"\u27E6" },
+        { u"longleftarrow", u"\u27F5" },
+        { u"longleftrightarrow", u"\u27F7" },
+        { u"longmapsto", u"\u27FC" },
+        { u"longrightarrow", u"\u27F6" },
+        { u"looparrowleft", u"\u21AB" },
+        { u"looparrowright", u"\u21AC" },
+        { u"lopar", u"\u2985" },
+        { u"lopf", u"\U0001D55D" },
+        { u"loplus", u"\u2A2D" },
+        { u"lotimes", u"\u2A34" },
+        { u"lowast", u"\u2217" },
+        { u"lowbar", u"\u005F" },
+        { u"loz", u"\u25CA" },
+        { u"lozenge", u"\u25CA" },
+        { u"lozf", u"\u29EB" },
+        { u"lpar", u"\u0028" },
+        { u"lparlt", u"\u2993" },
+        { u"lrarr", u"\u21C6" },
+        { u"lrcorner", u"\u231F" },
+        { u"lrhar", u"\u21CB" },
+        { u"lrhard", u"\u296D" },
+        { u"lrm", u"\u200E" },
+        { u"lrtri", u"\u22BF" },
+        { u"lsaquo", u"\u2039" },
+        { u"lscr", u"\U0001D4C1" },
+        { u"lsh", u"\u21B0" },
+        { u"lsim", u"\u2272" },
+        { u"lsime", u"\u2A8D" },
+        { u"lsimg", u"\u2A8F" },
+        { u"lsqb", u"\u005B" },
+        { u"lsquo", u"\u2018" },
+        { u"lsquor", u"\u201A" },
+        { u"lstrok", u"\u0142" },
+        { u"lt", u"\u003C" },
+        { u"ltcc", u"\u2AA6" },
+        { u"ltcir", u"\u2A79" },
+        { u"ltdot", u"\u22D6" },
+        { u"lthree", u"\u22CB" },
+        { u"ltimes", u"\u22C9" },
+        { u"ltlarr", u"\u2976" },
+        { u"ltquest", u"\u2A7B" },
+        { u"ltrPar", u"\u2996" },
+        { u"ltri", u"\u25C3" },
+        { u"ltrie", u"\u22B4" },
+        { u"ltrif", u"\u25C2" },
+        { u"lurdshar", u"\u294A" },
+        { u"luruhar", u"\u2966" },
+        { u"lvertneqq", u"\u2268\uFE00" },
+        { u"lvnE", u"\u2268\uFE00" },
+        { u"mDDot", u"\u223A" },
+        { u"macr", u"\u00AF" },
+        { u"male", u"\u2642" },
+        { u"malt", u"\u2720" },
+        { u"maltese", u"\u2720" },
+        { u"map", u"\u21A6" },
+        { u"mapsto", u"\u21A6" },
+        { u"mapstodown", u"\u21A7" },
+        { u"mapstoleft", u"\u21A4" },
+        { u"mapstoup", u"\u21A5" },
+        { u"marker", u"\u25AE" },
+        { u"mcomma", u"\u2A29" },
+        { u"mcy", u"\u043C" },
+        { u"mdash", u"\u2014" },
+        { u"measuredangle", u"\u2221" },
+        { u"mfr", u"\U0001D52A" },
+        { u"mho", u"\u2127" },
+        { u"micro", u"\u00B5" },
+        { u"mid", u"\u2223" },
+        { u"midast", u"\u002A" },
+        { u"midcir", u"\u2AF0" },
+        { u"middot", u"\u00B7" },
+        { u"minus", u"\u2212" },
+        { u"minusb", u"\u229F" },
+        { u"minusd", u"\u2238" },
+        { u"minusdu", u"\u2A2A" },
+        { u"mlcp", u"\u2ADB" },
+        { u"mldr", u"\u2026" },
+        { u"mnplus", u"\u2213" },
+        { u"models", u"\u22A7" },
+        { u"mopf", u"\U0001D55E" },
+        { u"mp", u"\u2213" },
+        { u"mscr", u"\U0001D4C2" },
+        { u"mstpos", u"\u223E" },
+        { u"mu", u"\u03BC" },
+        { u"multimap", u"\u22B8" },
+        { u"mumap", u"\u22B8" },
+        { u"nGg", u"\u22D9\u0338" },
+        { u"nGt", u"\u226B\u20D2" },
+        { u"nGtv", u"\u226B\u0338" },
+        { u"nLeftarrow", u"\u21CD" },
+        { u"nLeftrightarrow", u"\u21CE" },
+        { u"nLl", u"\u22D8\u0338" },
+        { u"nLt", u"\u226A\u20D2" },
+        { u"nLtv", u"\u226A\u0338" },
+        { u"nRightarrow", u"\u21CF" },
+        { u"nVDash", u"\u22AF" },
+        { u"nVdash", u"\u22AE" },
+        { u"nabla", u"\u2207" },
+        { u"nacute", u"\u0144" },
+        { u"nang", u"\u2220\u20D2" },
+        { u"nap", u"\u2249" },
+        { u"napE", u"\u2A70\u0338" },
+        { u"napid", u"\u224B\u0338" },
+        { u"napos", u"\u0149" },
+        { u"napprox", u"\u2249" },
+        { u"natur", u"\u266E" },
+        { u"natural", u"\u266E" },
+        { u"naturals", u"\u2115" },
+        { u"nbsp", u"\u00A0" },
+        { u"nbump", u"\u224E\u0338" },
+        { u"nbumpe", u"\u224F\u0338" },
+        { u"ncap", u"\u2A43" },
+        { u"ncaron", u"\u0148" },
+        { u"ncedil", u"\u0146" },
+        { u"ncong", u"\u2247" },
+        { u"ncongdot", u"\u2A6D\u0338" },
+        { u"ncup", u"\u2A42" },
+        { u"ncy", u"\u043D" },
+        { u"ndash", u"\u2013" },
+        { u"ne", u"\u2260" },
+        { u"neArr", u"\u21D7" },
+        { u"nearhk", u"\u2924" },
+        { u"nearr", u"\u2197" },
+        { u"nearrow", u"\u2197" },
+        { u"nedot", u"\u2250\u0338" },
+        { u"nequiv", u"\u2262" },
+        { u"nesear", u"\u2928" },
+        { u"nesim", u"\u2242\u0338" },
+        { u"nexist", u"\u2204" },
+        { u"nexists", u"\u2204" },
+        { u"nfr", u"\U0001D52B" },
+        { u"ngE", u"\u2267\u0338" },
+        { u"nge", u"\u2271" },
+        { u"ngeq", u"\u2271" },
+        { u"ngeqq", u"\u2267\u0338" },
+        { u"ngeqslant", u"\u2A7E\u0338" },
+        { u"nges", u"\u2A7E\u0338" },
+        { u"ngsim", u"\u2275" },
+        { u"ngt", u"\u226F" },
+        { u"ngtr", u"\u226F" },
+        { u"nhArr", u"\u21CE" },
+        { u"nharr", u"\u21AE" },
+        { u"nhpar", u"\u2AF2" },
+        { u"ni", u"\u220B" },
+        { u"nis", u"\u22FC" },
+        { u"nisd", u"\u22FA" },
+        { u"niv", u"\u220B" },
+        { u"njcy", u"\u045A" },
+        { u"nlArr", u"\u21CD" },
+        { u"nlE", u"\u2266\u0338" },
+        { u"nlarr", u"\u219A" },
+        { u"nldr", u"\u2025" },
+        { u"nle", u"\u2270" },
+        { u"nleftarrow", u"\u219A" },
+        { u"nleftrightarrow", u"\u21AE" },
+        { u"nleq", u"\u2270" },
+        { u"nleqq", u"\u2266\u0338" },
+        { u"nleqslant", u"\u2A7D\u0338" },
+        { u"nles", u"\u2A7D\u0338" },
+        { u"nless", u"\u226E" },
+        { u"nlsim", u"\u2274" },
+        { u"nlt", u"\u226E" },
+        { u"nltri", u"\u22EA" },
+        { u"nltrie", u"\u22EC" },
+        { u"nmid", u"\u2224" },
+        { u"nopf", u"\U0001D55F" },
+        { u"not", u"\u00AC" },
+        { u"notin", u"\u2209" },
+        { u"notinE", u"\u22F9\u0338" },
+        { u"notindot", u"\u22F5\u0338" },
+        { u"notinva", u"\u2209" },
+        { u"notinvb", u"\u22F7" },
+        { u"notinvc", u"\u22F6" },
+        { u"notni", u"\u220C" },
+        { u"notniva", u"\u220C" },
+        { u"notnivb", u"\u22FE" },
+        { u"notnivc", u"\u22FD" },
+        { u"npar", u"\u2226" },
+        { u"nparallel", u"\u2226" },
+        { u"nparsl", u"\u2AFD\u20E5" },
+        { u"npart", u"\u2202\u0338" },
+        { u"npolint", u"\u2A14" },
+        { u"npr", u"\u2280" },
+        { u"nprcue", u"\u22E0" },
+        { u"npre", u"\u2AAF\u0338" },
+        { u"nprec", u"\u2280" },
+        { u"npreceq", u"\u2AAF\u0338" },
+        { u"nrArr", u"\u21CF" },
+        { u"nrarr", u"\u219B" },
+        { u"nrarrc", u"\u2933\u0338" },
+        { u"nrarrw", u"\u219D\u0338" },
+        { u"nrightarrow", u"\u219B" },
+        { u"nrtri", u"\u22EB" },
+        { u"nrtrie", u"\u22ED" },
+        { u"nsc", u"\u2281" },
+        { u"nsccue", u"\u22E1" },
+        { u"nsce", u"\u2AB0\u0338" },
+        { u"nscr", u"\U0001D4C3" },
+        { u"nshortmid", u"\u2224" },
+        { u"nshortparallel", u"\u2226" },
+        { u"nsim", u"\u2241" },
+        { u"nsime", u"\u2244" },
+        { u"nsimeq", u"\u2244" },
+        { u"nsmid", u"\u2224" },
+        { u"nspar", u"\u2226" },
+        { u"nsqsube", u"\u22E2" },
+        { u"nsqsupe", u"\u22E3" },
+        { u"nsub", u"\u2284" },
+        { u"nsubE", u"\u2AC5\u0338" },
+        { u"nsube", u"\u2288" },
+        { u"nsubset", u"\u2282\u20D2" },
+        { u"nsubseteq", u"\u2288" },
+        { u"nsubseteqq", u"\u2AC5\u0338" },
+        { u"nsucc", u"\u2281" },
+        { u"nsucceq", u"\u2AB0\u0338" },
+        { u"nsup", u"\u2285" },
+        { u"nsupE", u"\u2AC6\u0338" },
+        { u"nsupe", u"\u2289" },
+        { u"nsupset", u"\u2283\u20D2" },
+        { u"nsupseteq", u"\u2289" },
+        { u"nsupseteqq", u"\u2AC6\u0338" },
+        { u"ntgl", u"\u2279" },
+        { u"ntilde", u"\u00F1" },
+        { u"ntlg", u"\u2278" },
+        { u"ntriangleleft", u"\u22EA" },
+        { u"ntrianglelefteq", u"\u22EC" },
+        { u"ntriangleright", u"\u22EB" },
+        { u"ntrianglerighteq", u"\u22ED" },
+        { u"nu", u"\u03BD" },
+        { u"num", u"\u0023" },
+        { u"numero", u"\u2116" },
+        { u"numsp", u"\u2007" },
+        { u"nvDash", u"\u22AD" },
+        { u"nvHarr", u"\u2904" },
+        { u"nvap", u"\u224D\u20D2" },
+        { u"nvdash", u"\u22AC" },
+        { u"nvge", u"\u2265\u20D2" },
+        { u"nvgt", u"\u003E\u20D2" },
+        { u"nvinfin", u"\u29DE" },
+        { u"nvlArr", u"\u2902" },
+        { u"nvle", u"\u2264\u20D2" },
+        { u"nvlt", u"\u003C\u20D2" },
+        { u"nvltrie", u"\u22B4\u20D2" },
+        { u"nvrArr", u"\u2903" },
+        { u"nvrtrie", u"\u22B5\u20D2" },
+        { u"nvsim", u"\u223C\u20D2" },
+        { u"nwArr", u"\u21D6" },
+        { u"nwarhk", u"\u2923" },
+        { u"nwarr", u"\u2196" },
+        { u"nwarrow", u"\u2196" },
+        { u"nwnear", u"\u2927" },
+        { u"oS", u"\u24C8" },
+        { u"oacute", u"\u00F3" },
+        { u"oast", u"\u229B" },
+        { u"ocir", u"\u229A" },
+        { u"ocirc", u"\u00F4" },
+        { u"ocy", u"\u043E" },
+        { u"odash", u"\u229D" },
+        { u"odblac", u"\u0151" },
+        { u"odiv", u"\u2A38" },
+        { u"odot", u"\u2299" },
+        { u"odsold", u"\u29BC" },
+        { u"oelig", u"\u0153" },
+        { u"ofcir", u"\u29BF" },
+        { u"ofr", u"\U0001D52C" },
+        { u"ogon", u"\u02DB" },
+        { u"ograve", u"\u00F2" },
+        { u"ogt", u"\u29C1" },
+        { u"ohbar", u"\u29B5" },
+        { u"ohm", u"\u03A9" },
+        { u"oint", u"\u222E" },
+        { u"olarr", u"\u21BA" },
+        { u"olcir", u"\u29BE" },
+        { u"olcross", u"\u29BB" },
+        { u"oline", u"\u203E" },
+        { u"olt", u"\u29C0" },
+        { u"omacr", u"\u014D" },
+        { u"omega", u"\u03C9" },
+        { u"omicron", u"\u03BF" },
+        { u"omid", u"\u29B6" },
+        { u"ominus", u"\u2296" },
+        { u"oopf", u"\U0001D560" },
+        { u"opar", u"\u29B7" },
+        { u"operp", u"\u29B9" },
+        { u"oplus", u"\u2295" },
+        { u"or", u"\u2228" },
+        { u"orarr", u"\u21BB" },
+        { u"ord", u"\u2A5D" },
+        { u"order", u"\u2134" },
+        { u"orderof", u"\u2134" },
+        { u"ordf", u"\u00AA" },
+        { u"ordm", u"\u00BA" },
+        { u"origof", u"\u22B6" },
+        { u"oror", u"\u2A56" },
+        { u"orslope", u"\u2A57" },
+        { u"orv", u"\u2A5B" },
+        { u"oscr", u"\u2134" },
+        { u"oslash", u"\u00F8" },
+        { u"osol", u"\u2298" },
+        { u"otilde", u"\u00F5" },
+        { u"otimes", u"\u2297" },
+        { u"otimesas", u"\u2A36" },
+        { u"ouml", u"\u00F6" },
+        { u"ovbar", u"\u233D" },
+        { u"par", u"\u2225" },
+        { u"para", u"\u00B6" },
+        { u"parallel", u"\u2225" },
+        { u"parsim", u"\u2AF3" },
+        { u"parsl", u"\u2AFD" },
+        { u"part", u"\u2202" },
+        { u"pcy", u"\u043F" },
+        { u"percnt", u"\u0025" },
+        { u"period", u"\u002E" },
+        { u"permil", u"\u2030" },
+        { u"perp", u"\u22A5" },
+        { u"pertenk", u"\u2031" },
+        { u"pfr", u"\U0001D52D" },
+        { u"phi", u"\u03C6" },
+        { u"phiv", u"\u03D5" },
+        { u"phmmat", u"\u2133" },
+        { u"phone", u"\u260E" },
+        { u"pi", u"\u03C0" },
+        { u"pitchfork", u"\u22D4" },
+        { u"piv", u"\u03D6" },
+        { u"planck", u"\u210F" },
+        { u"planckh", u"\u210E" },
+        { u"plankv", u"\u210F" },
+        { u"plus", u"\u002B" },
+        { u"plusacir", u"\u2A23" },
+        { u"plusb", u"\u229E" },
+        { u"pluscir", u"\u2A22" },
+        { u"plusdo", u"\u2214" },
+        { u"plusdu", u"\u2A25" },
+        { u"pluse", u"\u2A72" },
+        { u"plusmn", u"\u00B1" },
+        { u"plussim", u"\u2A26" },
+        { u"plustwo", u"\u2A27" },
+        { u"pm", u"\u00B1" },
+        { u"pointint", u"\u2A15" },
+        { u"popf", u"\U0001D561" },
+        { u"pound", u"\u00A3" },
+        { u"pr", u"\u227A" },
+        { u"prE", u"\u2AB3" },
+        { u"prap", u"\u2AB7" },
+        { u"prcue", u"\u227C" },
+        { u"pre", u"\u2AAF" },
+        { u"prec", u"\u227A" },
+        { u"precapprox", u"\u2AB7" },
+        { u"preccurlyeq", u"\u227C" },
+        { u"preceq", u"\u2AAF" },
+        { u"precnapprox", u"\u2AB9" },
+        { u"precneqq", u"\u2AB5" },
+        { u"precnsim", u"\u22E8" },
+        { u"precsim", u"\u227E" },
+        { u"prime", u"\u2032" },
+        { u"primes", u"\u2119" },
+        { u"prnE", u"\u2AB5" },
+        { u"prnap", u"\u2AB9" },
+        { u"prnsim", u"\u22E8" },
+        { u"prod", u"\u220F" },
+        { u"profalar", u"\u232E" },
+        { u"profline", u"\u2312" },
+        { u"profsurf", u"\u2313" },
+        { u"prop", u"\u221D" },
+        { u"propto", u"\u221D" },
+        { u"prsim", u"\u227E" },
+        { u"prurel", u"\u22B0" },
+        { u"pscr", u"\U0001D4C5" },
+        { u"psi", u"\u03C8" },
+        { u"puncsp", u"\u2008" },
+        { u"qfr", u"\U0001D52E" },
+        { u"qint", u"\u2A0C" },
+        { u"qopf", u"\U0001D562" },
+        { u"qprime", u"\u2057" },
+        { u"qscr", u"\U0001D4C6" },
+        { u"quaternions", u"\u210D" },
+        { u"quatint", u"\u2A16" },
+        { u"quest", u"\u003F" },
+        { u"questeq", u"\u225F" },
+        { u"quot", u"\u0022" },
+        { u"rAarr", u"\u21DB" },
+        { u"rArr", u"\u21D2" },
+        { u"rAtail", u"\u291C" },
+        { u"rBarr", u"\u290F" },
+        { u"rHar", u"\u2964" },
+        { u"race", u"\u223D\u0331" },
+        { u"racute", u"\u0155" },
+        { u"radic", u"\u221A" },
+        { u"raemptyv", u"\u29B3" },
+        { u"rang", u"\u27E9" },
+        { u"rangd", u"\u2992" },
+        { u"range", u"\u29A5" },
+        { u"rangle", u"\u27E9" },
+        { u"raquo", u"\u00BB" },
+        { u"rarr", u"\u2192" },
+        { u"rarrap", u"\u2975" },
+        { u"rarrb", u"\u21E5" },
+        { u"rarrbfs", u"\u2920" },
+        { u"rarrc", u"\u2933" },
+        { u"rarrfs", u"\u291E" },
+        { u"rarrhk", u"\u21AA" },
+        { u"rarrlp", u"\u21AC" },
+        { u"rarrpl", u"\u2945" },
+        { u"rarrsim", u"\u2974" },
+        { u"rarrtl", u"\u21A3" },
+        { u"rarrw", u"\u219D" },
+        { u"ratail", u"\u291A" },
+        { u"ratio", u"\u2236" },
+        { u"rationals", u"\u211A" },
+        { u"rbarr", u"\u290D" },
+        { u"rbbrk", u"\u2773" },
+        { u"rbrace", u"\u007D" },
+        { u"rbrack", u"\u005D" },
+        { u"rbrke", u"\u298C" },
+        { u"rbrksld", u"\u298E" },
+        { u"rbrkslu", u"\u2990" },
+        { u"rcaron", u"\u0159" },
+        { u"rcedil", u"\u0157" },
+        { u"rceil", u"\u2309" },
+        { u"rcub", u"\u007D" },
+        { u"rcy", u"\u0440" },
+        { u"rdca", u"\u2937" },
+        { u"rdldhar", u"\u2969" },
+        { u"rdquo", u"\u201D" },
+        { u"rdquor", u"\u201D" },
+        { u"rdsh", u"\u21B3" },
+        { u"real", u"\u211C" },
+        { u"realine", u"\u211B" },
+        { u"realpart", u"\u211C" },
+        { u"reals", u"\u211D" },
+        { u"rect", u"\u25AD" },
+        { u"reg", u"\u00AE" },
+        { u"rfisht", u"\u297D" },
+        { u"rfloor", u"\u230B" },
+        { u"rfr", u"\U0001D52F" },
+        { u"rhard", u"\u21C1" },
+        { u"rharu", u"\u21C0" },
+        { u"rharul", u"\u296C" },
+        { u"rho", u"\u03C1" },
+        { u"rhov", u"\u03F1" },
+        { u"rightarrow", u"\u2192" },
+        { u"rightarrowtail", u"\u21A3" },
+        { u"rightharpoondown", u"\u21C1" },
+        { u"rightharpoonup", u"\u21C0" },
+        { u"rightleftarrows", u"\u21C4" },
+        { u"rightleftharpoons", u"\u21CC" },
+        { u"rightrightarrows", u"\u21C9" },
+        { u"rightsquigarrow", u"\u219D" },
+        { u"rightthreetimes", u"\u22CC" },
+        { u"ring", u"\u02DA" },
+        { u"risingdotseq", u"\u2253" },
+        { u"rlarr", u"\u21C4" },
+        { u"rlhar", u"\u21CC" },
+        { u"rlm", u"\u200F" },
+        { u"rmoust", u"\u23B1" },
+        { u"rmoustache", u"\u23B1" },
+        { u"rnmid", u"\u2AEE" },
+        { u"roang", u"\u27ED" },
+        { u"roarr", u"\u21FE" },
+        { u"robrk", u"\u27E7" },
+        { u"ropar", u"\u2986" },
+        { u"ropf", u"\U0001D563" },
+        { u"roplus", u"\u2A2E" },
+        { u"rotimes", u"\u2A35" },
+        { u"rpar", u"\u0029" },
+        { u"rpargt", u"\u2994" },
+        { u"rppolint", u"\u2A12" },
+        { u"rrarr", u"\u21C9" },
+        { u"rsaquo", u"\u203A" },
+        { u"rscr", u"\U0001D4C7" },
+        { u"rsh", u"\u21B1" },
+        { u"rsqb", u"\u005D" },
+        { u"rsquo", u"\u2019" },
+        { u"rsquor", u"\u2019" },
+        { u"rthree", u"\u22CC" },
+        { u"rtimes", u"\u22CA" },
+        { u"rtri", u"\u25B9" },
+        { u"rtrie", u"\u22B5" },
+        { u"rtrif", u"\u25B8" },
+        { u"rtriltri", u"\u29CE" },
+        { u"ruluhar", u"\u2968" },
+        { u"rx", u"\u211E" },
+        { u"sacute", u"\u015B" },
+        { u"sbquo", u"\u201A" },
+        { u"sc", u"\u227B" },
+        { u"scE", u"\u2AB4" },
+        { u"scap", u"\u2AB8" },
+        { u"scaron", u"\u0161" },
+        { u"sccue", u"\u227D" },
+        { u"sce", u"\u2AB0" },
+        { u"scedil", u"\u015F" },
+        { u"scirc", u"\u015D" },
+        { u"scnE", u"\u2AB6" },
+        { u"scnap", u"\u2ABA" },
+        { u"scnsim", u"\u22E9" },
+        { u"scpolint", u"\u2A13" },
+        { u"scsim", u"\u227F" },
+        { u"scy", u"\u0441" },
+        { u"sdot", u"\u22C5" },
+        { u"sdotb", u"\u22A1" },
+        { u"sdote", u"\u2A66" },
+        { u"seArr", u"\u21D8" },
+        { u"searhk", u"\u2925" },
+        { u"searr", u"\u2198" },
+        { u"searrow", u"\u2198" },
+        { u"sect", u"\u00A7" },
+        { u"semi", u"\u003B" },
+        { u"seswar", u"\u2929" },
+        { u"setminus", u"\u2216" },
+        { u"setmn", u"\u2216" },
+        { u"sext", u"\u2736" },
+        { u"sfr", u"\U0001D530" },
+        { u"sfrown", u"\u2322" },
+        { u"sharp", u"\u266F" },
+        { u"shchcy", u"\u0449" },
+        { u"shcy", u"\u0448" },
+        { u"shortmid", u"\u2223" },
+        { u"shortparallel", u"\u2225" },
+        { u"shy", u"\u00AD" },
+        { u"sigma", u"\u03C3" },
+        { u"sigmaf", u"\u03C2" },
+        { u"sigmav", u"\u03C2" },
+        { u"sim", u"\u223C" },
+        { u"simdot", u"\u2A6A" },
+        { u"sime", u"\u2243" },
+        { u"simeq", u"\u2243" },
+        { u"simg", u"\u2A9E" },
+        { u"simgE", u"\u2AA0" },
+        { u"siml", u"\u2A9D" },
+        { u"simlE", u"\u2A9F" },
+        { u"simne", u"\u2246" },
+        { u"simplus", u"\u2A24" },
+        { u"simrarr", u"\u2972" },
+        { u"slarr", u"\u2190" },
+        { u"smallsetminus", u"\u2216" },
+        { u"smashp", u"\u2A33" },
+        { u"smeparsl", u"\u29E4" },
+        { u"smid", u"\u2223" },
+        { u"smile", u"\u2323" },
+        { u"smt", u"\u2AAA" },
+        { u"smte", u"\u2AAC" },
+        { u"smtes", u"\u2AAC\uFE00" },
+        { u"softcy", u"\u044C" },
+        { u"sol", u"\u002F" },
+        { u"solb", u"\u29C4" },
+        { u"solbar", u"\u233F" },
+        { u"sopf", u"\U0001D564" },
+        { u"spades", u"\u2660" },
+        { u"spadesuit", u"\u2660" },
+        { u"spar", u"\u2225" },
+        { u"sqcap", u"\u2293" },
+        { u"sqcaps", u"\u2293\uFE00" },
+        { u"sqcup", u"\u2294" },
+        { u"sqcups", u"\u2294\uFE00" },
+        { u"sqsub", u"\u228F" },
+        { u"sqsube", u"\u2291" },
+        { u"sqsubset", u"\u228F" },
+        { u"sqsubseteq", u"\u2291" },
+        { u"sqsup", u"\u2290" },
+        { u"sqsupe", u"\u2292" },
+        { u"sqsupset", u"\u2290" },
+        { u"sqsupseteq", u"\u2292" },
+        { u"squ", u"\u25A1" },
+        { u"square", u"\u25A1" },
+        { u"squarf", u"\u25AA" },
+        { u"squf", u"\u25AA" },
+        { u"srarr", u"\u2192" },
+        { u"sscr", u"\U0001D4C8" },
+        { u"ssetmn", u"\u2216" },
+        { u"ssmile", u"\u2323" },
+        { u"sstarf", u"\u22C6" },
+        { u"star", u"\u2606" },
+        { u"starf", u"\u2605" },
+        { u"straightepsilon", u"\u03F5" },
+        { u"straightphi", u"\u03D5" },
+        { u"strns", u"\u00AF" },
+        { u"sub", u"\u2282" },
+        { u"subE", u"\u2AC5" },
+        { u"subdot", u"\u2ABD" },
+        { u"sube", u"\u2286" },
+        { u"subedot", u"\u2AC3" },
+        { u"submult", u"\u2AC1" },
+        { u"subnE", u"\u2ACB" },
+        { u"subne", u"\u228A" },
+        { u"subplus", u"\u2ABF" },
+        { u"subrarr", u"\u2979" },
+        { u"subset", u"\u2282" },
+        { u"subseteq", u"\u2286" },
+        { u"subseteqq", u"\u2AC5" },
+        { u"subsetneq", u"\u228A" },
+        { u"subsetneqq", u"\u2ACB" },
+        { u"subsim", u"\u2AC7" },
+        { u"subsub", u"\u2AD5" },
+        { u"subsup", u"\u2AD3" },
+        { u"succ", u"\u227B" },
+        { u"succapprox", u"\u2AB8" },
+        { u"succcurlyeq", u"\u227D" },
+        { u"succeq", u"\u2AB0" },
+        { u"succnapprox", u"\u2ABA" },
+        { u"succneqq", u"\u2AB6" },
+        { u"succnsim", u"\u22E9" },
+        { u"succsim", u"\u227F" },
+        { u"sum", u"\u2211" },
+        { u"sung", u"\u266A" },
+        { u"sup", u"\u2283" },
+        { u"sup1", u"\u00B9" },
+        { u"sup2", u"\u00B2" },
+        { u"sup3", u"\u00B3" },
+        { u"supE", u"\u2AC6" },
+        { u"supdot", u"\u2ABE" },
+        { u"supdsub", u"\u2AD8" },
+        { u"supe", u"\u2287" },
+        { u"supedot", u"\u2AC4" },
+        { u"suphsol", u"\u27C9" },
+        { u"suphsub", u"\u2AD7" },
+        { u"suplarr", u"\u297B" },
+        { u"supmult", u"\u2AC2" },
+        { u"supnE", u"\u2ACC" },
+        { u"supne", u"\u228B" },
+        { u"supplus", u"\u2AC0" },
+        { u"supset", u"\u2283" },
+        { u"supseteq", u"\u2287" },
+        { u"supseteqq", u"\u2AC6" },
+        { u"supsetneq", u"\u228B" },
+        { u"supsetneqq", u"\u2ACC" },
+        { u"supsim", u"\u2AC8" },
+        { u"supsub", u"\u2AD4" },
+        { u"supsup", u"\u2AD6" },
+        { u"swArr", u"\u21D9" },
+        { u"swarhk", u"\u2926" },
+        { u"swarr", u"\u2199" },
+        { u"swarrow", u"\u2199" },
+        { u"swnwar", u"\u292A" },
+        { u"szlig", u"\u00DF" },
+        { u"target", u"\u2316" },
+        { u"tau", u"\u03C4" },
+        { u"tbrk", u"\u23B4" },
+        { u"tcaron", u"\u0165" },
+        { u"tcedil", u"\u0163" },
+        { u"tcy", u"\u0442" },
+        { u"tdot", u"\u20DB" },
+        { u"telrec", u"\u2315" },
+        { u"tfr", u"\U0001D531" },
+        { u"there4", u"\u2234" },
+        { u"therefore", u"\u2234" },
+        { u"theta", u"\u03B8" },
+        { u"thetasym", u"\u03D1" },
+        { u"thetav", u"\u03D1" },
+        { u"thickapprox", u"\u2248" },
+        { u"thicksim", u"\u223C" },
+        { u"thinsp", u"\u2009" },
+        { u"thkap", u"\u2248" },
+        { u"thksim", u"\u223C" },
+        { u"thorn", u"\u00FE" },
+        { u"tilde", u"\u02DC" },
+        { u"times", u"\u00D7" },
+        { u"timesb", u"\u22A0" },
+        { u"timesbar", u"\u2A31" },
+        { u"timesd", u"\u2A30" },
+        { u"tint", u"\u222D" },
+        { u"toea", u"\u2928" },
+        { u"top", u"\u22A4" },
+        { u"topbot", u"\u2336" },
+        { u"topcir", u"\u2AF1" },
+        { u"topf", u"\U0001D565" },
+        { u"topfork", u"\u2ADA" },
+        { u"tosa", u"\u2929" },
+        { u"tprime", u"\u2034" },
+        { u"trade", u"\u2122" },
+        { u"triangle", u"\u25B5" },
+        { u"triangledown", u"\u25BF" },
+        { u"triangleleft", u"\u25C3" },
+        { u"trianglelefteq", u"\u22B4" },
+        { u"triangleq", u"\u225C" },
+        { u"triangleright", u"\u25B9" },
+        { u"trianglerighteq", u"\u22B5" },
+        { u"tridot", u"\u25EC" },
+        { u"trie", u"\u225C" },
+        { u"triminus", u"\u2A3A" },
+        { u"triplus", u"\u2A39" },
+        { u"trisb", u"\u29CD" },
+        { u"tritime", u"\u2A3B" },
+        { u"trpezium", u"\u23E2" },
+        { u"tscr", u"\U0001D4C9" },
+        { u"tscy", u"\u0446" },
+        { u"tshcy", u"\u045B" },
+        { u"tstrok", u"\u0167" },
+        { u"twixt", u"\u226C" },
+        { u"twoheadleftarrow", u"\u219E" },
+        { u"twoheadrightarrow", u"\u21A0" },
+        { u"uArr", u"\u21D1" },
+        { u"uHar", u"\u2963" },
+        { u"uacute", u"\u00FA" },
+        { u"uarr", u"\u2191" },
+        { u"ubrcy", u"\u045E" },
+        { u"ubreve", u"\u016D" },
+        { u"ucirc", u"\u00FB" },
+        { u"ucy", u"\u0443" },
+        { u"udarr", u"\u21C5" },
+        { u"udblac", u"\u0171" },
+        { u"udhar", u"\u296E" },
+        { u"ufisht", u"\u297E" },
+        { u"ufr", u"\U0001D532" },
+        { u"ugrave", u"\u00F9" },
+        { u"uharl", u"\u21BF" },
+        { u"uharr", u"\u21BE" },
+        { u"uhblk", u"\u2580" },
+        { u"ulcorn", u"\u231C" },
+        { u"ulcorner", u"\u231C" },
+        { u"ulcrop", u"\u230F" },
+        { u"ultri", u"\u25F8" },
+        { u"umacr", u"\u016B" },
+        { u"uml", u"\u00A8" },
+        { u"uogon", u"\u0173" },
+        { u"uopf", u"\U0001D566" },
+        { u"uparrow", u"\u2191" },
+        { u"updownarrow", u"\u2195" },
+        { u"upharpoonleft", u"\u21BF" },
+        { u"upharpoonright", u"\u21BE" },
+        { u"uplus", u"\u228E" },
+        { u"upsi", u"\u03C5" },
+        { u"upsih", u"\u03D2" },
+        { u"upsilon", u"\u03C5" },
+        { u"upuparrows", u"\u21C8" },
+        { u"urcorn", u"\u231D" },
+        { u"urcorner", u"\u231D" },
+        { u"urcrop", u"\u230E" },
+        { u"uring", u"\u016F" },
+        { u"urtri", u"\u25F9" },
+        { u"uscr", u"\U0001D4CA" },
+        { u"utdot", u"\u22F0" },
+        { u"utilde", u"\u0169" },
+        { u"utri", u"\u25B5" },
+        { u"utrif", u"\u25B4" },
+        { u"uuarr", u"\u21C8" },
+        { u"uuml", u"\u00FC" },
+        { u"uwangle", u"\u29A7" },
+        { u"vArr", u"\u21D5" },
+        { u"vBar", u"\u2AE8" },
+        { u"vBarv", u"\u2AE9" },
+        { u"vDash", u"\u22A8" },
+        { u"vangrt", u"\u299C" },
+        { u"varepsilon", u"\u03F5" },
+        { u"varkappa", u"\u03F0" },
+        { u"varnothing", u"\u2205" },
+        { u"varphi", u"\u03D5" },
+        { u"varpi", u"\u03D6" },
+        { u"varpropto", u"\u221D" },
+        { u"varr", u"\u2195" },
+        { u"varrho", u"\u03F1" },
+        { u"varsigma", u"\u03C2" },
+        { u"varsubsetneq", u"\u228A\uFE00" },
+        { u"varsubsetneqq", u"\u2ACB\uFE00" },
+        { u"varsupsetneq", u"\u228B\uFE00" },
+        { u"varsupsetneqq", u"\u2ACC\uFE00" },
+        { u"vartheta", u"\u03D1" },
+        { u"vartriangleleft", u"\u22B2" },
+        { u"vartriangleright", u"\u22B3" },
+        { u"vcy", u"\u0432" },
+        { u"vdash", u"\u22A2" },
+        { u"vee", u"\u2228" },
+        { u"veebar", u"\u22BB" },
+        { u"veeeq", u"\u225A" },
+        { u"vellip", u"\u22EE" },
+        { u"verbar", u"\u007C" },
+        { u"vert", u"\u007C" },
+        { u"vfr", u"\U0001D533" },
+        { u"vltri", u"\u22B2" },
+        { u"vnsub", u"\u2282\u20D2" },
+        { u"vnsup", u"\u2283\u20D2" },
+        { u"vopf", u"\U0001D567" },
+        { u"vprop", u"\u221D" },
+        { u"vrtri", u"\u22B3" },
+        { u"vscr", u"\U0001D4CB" },
+        { u"vsubnE", u"\u2ACB\uFE00" },
+        { u"vsubne", u"\u228A\uFE00" },
+        { u"vsupnE", u"\u2ACC\uFE00" },
+        { u"vsupne", u"\u228B\uFE00" },
+        { u"vzigzag", u"\u299A" },
+        { u"wcirc", u"\u0175" },
+        { u"wedbar", u"\u2A5F" },
+        { u"wedge", u"\u2227" },
+        { u"wedgeq", u"\u2259" },
+        { u"weierp", u"\u2118" },
+        { u"wfr", u"\U0001D534" },
+        { u"wopf", u"\U0001D568" },
+        { u"wp", u"\u2118" },
+        { u"wr", u"\u2240" },
+        { u"wreath", u"\u2240" },
+        { u"wscr", u"\U0001D4CC" },
+        { u"xcap", u"\u22C2" },
+        { u"xcirc", u"\u25EF" },
+        { u"xcup", u"\u22C3" },
+        { u"xdtri", u"\u25BD" },
+        { u"xfr", u"\U0001D535" },
+        { u"xhArr", u"\u27FA" },
+        { u"xharr", u"\u27F7" },
+        { u"xi", u"\u03BE" },
+        { u"xlArr", u"\u27F8" },
+        { u"xlarr", u"\u27F5" },
+        { u"xmap", u"\u27FC" },
+        { u"xnis", u"\u22FB" },
+        { u"xodot", u"\u2A00" },
+        { u"xopf", u"\U0001D569" },
+        { u"xoplus", u"\u2A01" },
+        { u"xotime", u"\u2A02" },
+        { u"xrArr", u"\u27F9" },
+        { u"xrarr", u"\u27F6" },
+        { u"xscr", u"\U0001D4CD" },
+        { u"xsqcup", u"\u2A06" },
+        { u"xuplus", u"\u2A04" },
+        { u"xutri", u"\u25B3" },
+        { u"xvee", u"\u22C1" },
+        { u"xwedge", u"\u22C0" },
+        { u"yacute", u"\u00FD" },
+        { u"yacy", u"\u044F" },
+        { u"ycirc", u"\u0177" },
+        { u"ycy", u"\u044B" },
+        { u"yen", u"\u00A5" },
+        { u"yfr", u"\U0001D536" },
+        { u"yicy", u"\u0457" },
+        { u"yopf", u"\U0001D56A" },
+        { u"yscr", u"\U0001D4CE" },
+        { u"yucy", u"\u044E" },
+        { u"yuml", u"\u00FF" },
+        { u"zacute", u"\u017A" },
+        { u"zcaron", u"\u017E" },
+        { u"zcy", u"\u0437" },
+        { u"zdot", u"\u017C" },
+        { u"zeetrf", u"\u2128" },
+        { u"zeta", u"\u03B6" },
+        { u"zfr", u"\U0001D537" },
+        { u"zhcy", u"\u0436" },
+        { u"zigrarr", u"\u21DD" },
+        { u"zopf", u"\U0001D56B" },
+        { u"zscr", u"\U0001D4CF" },
+        { u"zwj", u"\u200D" },
+        { u"zwnj", u"\u200C" }
+        // 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;", u"\u03C3"},
+        { u"&infin;", u"\u221E"}
+        // 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: */