From 607578a90b1fa1ee3ad13bbc6e073ac620ecfd4b Mon Sep 17 00:00:00 2001
From: jzy <928294064@qq.com>
Date: Sat, 1 Nov 2025 00:35:32 +0800
Subject: [PATCH] =?UTF-8?q?=E6=94=AF=E6=8C=81word=E8=A7=A3=E6=9E=90?=
 =?UTF-8?q?=E6=96=87=E5=AD=97=EF=BC=8C=E5=85=AC=E5=BC=8F=EF=BC=8C=E5=9B=BE?=
 =?UTF-8?q?=E7=89=87?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 ruoyi-api/pom.xml                                  |   27 +
 .../com/ruoyi/api/controller/MathMLController.java |  175 +
 .../com/ruoyi/api/controller/MathMLConverter.java  |  100 +
 ruoyi-api/src/main/resources/MML2OMML.XSL          | 3822 ++++++++++++++++++++
 ruoyi-api/src/main/resources/OMML2MML.XSL          | 2076 +++++++++++
 ruoyi-api/src/main/resources/OMML2MML1.XSL         | 2068 +++++++++++
 6 files changed, 8268 insertions(+)
 create mode 100644 ruoyi-api/src/main/java/com/ruoyi/api/controller/MathMLController.java
 create mode 100644 ruoyi-api/src/main/java/com/ruoyi/api/controller/MathMLConverter.java
 create mode 100644 ruoyi-api/src/main/resources/MML2OMML.XSL
 create mode 100644 ruoyi-api/src/main/resources/OMML2MML.XSL
 create mode 100644 ruoyi-api/src/main/resources/OMML2MML1.XSL

diff --git a/ruoyi-api/pom.xml b/ruoyi-api/pom.xml
index d22a709..d9cb68e 100644
--- a/ruoyi-api/pom.xml
+++ b/ruoyi-api/pom.xml
@@ -31,6 +31,33 @@
     <dependencies>
         <!-- 通用工具-->
         <dependency>
+            <groupId>net.sf.saxon</groupId>
+            <artifactId>Saxon-HE</artifactId>
+            <version>12.5</version>
+        </dependency>
+        <dependency>
+            <groupId>org.apache.poi</groupId>
+            <artifactId>poi</artifactId>
+            <version>5.2.5</version>
+        </dependency>
+
+        <!-- Apache POI OOXML (XSSF, XWPF) -->
+        <dependency>
+            <groupId>org.apache.poi</groupId>
+            <artifactId>poi-ooxml</artifactId>
+            <version>5.2.5</version>
+        </dependency>
+
+        <!-- 必须：OOXML Schema 支持（包含 CTOMath 等类） -->
+        <dependency>
+            <groupId>org.apache.poi</groupId>
+            <artifactId>poi-ooxml-full</artifactId>
+            <version>5.2.5</version>
+        </dependency>
+
+
+
+        <dependency>
             <groupId>com.ruoyi</groupId>
             <artifactId>ruoyi-common</artifactId>
         </dependency>
diff --git a/ruoyi-api/src/main/java/com/ruoyi/api/controller/MathMLController.java b/ruoyi-api/src/main/java/com/ruoyi/api/controller/MathMLController.java
new file mode 100644
index 0000000..a78d89f
--- /dev/null
+++ b/ruoyi-api/src/main/java/com/ruoyi/api/controller/MathMLController.java
@@ -0,0 +1,175 @@
+package com.ruoyi.api.controller;
+
+import org.apache.xmlbeans.XmlCursor;
+import org.apache.poi.openxml4j.opc.OPCPackage;
+import org.apache.poi.xwpf.usermodel.*;
+import org.jsoup.Jsoup;
+import org.jsoup.nodes.Document;
+import org.jsoup.nodes.Element;
+import org.jsoup.parser.Parser;
+import org.openxmlformats.schemas.wordprocessingml.x2006.main.CTP;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+import org.apache.poi.ooxml.POIXMLDocumentPart;
+import org.apache.poi.xwpf.usermodel.XWPFPictureData;
+
+import java.util.Base64;
+import java.util.List;
+import java.util.logging.Logger;
+
+@RestController
+@RequestMapping("/api")
+public class MathMLController {
+
+    private static final Logger log = Logger.getLogger(MathMLController.class.getName());
+
+    @GetMapping("/getWordToHtml")
+    public String t1() {
+        String filePath = "C:\\D\\test.docx"; // ✅ 你的文件路径
+        StringBuilder html = new StringBuilder();
+
+        // 添加 MathJax 支持 MathML 渲染
+
+        try (OPCPackage opc = OPCPackage.open(filePath);
+             XWPFDocument doc = new XWPFDocument(opc)) {
+
+            List<XWPFParagraph> paragraphs = doc.getParagraphs();
+            List<XWPFTable> tables = doc.getTables();
+
+            // 处理段落
+            for (XWPFParagraph para : paragraphs) {
+                handleParagraph(para, html);
+            }
+
+            // 处理表格（含公式）
+            for (XWPFTable table : tables) {
+                html.append("<table border='1' style='border-collapse: collapse; margin: 10px 0;'>");
+                for (XWPFTableRow row : table.getRows()) {
+                    html.append("<tr>");
+                    for (XWPFTableCell cell : row.getTableCells()) {
+                        html.append("<td style='padding: 8px;'>");
+                        for (XWPFParagraph cellPara : cell.getParagraphs()) {
+                            handleParagraph(cellPara, html);
+                        }
+                        html.append("</td>");
+                    }
+                    html.append("</tr>");
+                }
+                html.append("</table>");
+            }
+
+        } catch (Exception e) {
+            html.append("<p style='color:red;'>").append(e.getMessage()).append("</p>");
+        }
+        System.out.println(html.toString());
+        return html.toString();
+    }
+    private void handleParagraph(XWPFParagraph para, StringBuilder html) {
+        System.out.println("处理段落: " + para.getText());
+
+        CTP ctp = para.getCTP();
+        XmlCursor cursor = ctp.newCursor();
+        cursor.selectPath("./*");
+
+        StringBuilder paraHtml = new StringBuilder("<p>");
+
+        while (cursor.toNextSelection()) {
+            String nodeXml = cursor.xmlText();
+
+            if (nodeXml.contains("<m:oMath") || nodeXml.contains("<m:oMathPara")) {
+                System.out.println("✅ 发现公式！");
+                String mathml = MathMLConverter.convertOmmlToMathML(nodeXml);
+                paraHtml.append(mathml);
+            } else if (nodeXml.startsWith("<w:r ")) {
+                // 处理文本 run（可能包含文字、图片）
+                processRunXml(nodeXml, para, paraHtml);
+            }
+        }
+        cursor.dispose();
+
+        if (paraHtml.length() > 3) {
+            paraHtml.append("</p>");
+            html.append(paraHtml);
+        }
+    }
+
+    private void processRunXml(String xml, XWPFParagraph para, StringBuilder html) {
+        try {
+            // 使用 Jsoup 解析 XML
+            Document doc = Jsoup.parse(xml, "", Parser.xmlParser());
+            Element wR = doc.child(0);
+
+            // 查找 blip 标签中的 r:embed
+            Element blip = wR.selectFirst("a|blip");
+            String relId = null;
+            if (blip != null) {
+                relId = blip.attr("r:embed");
+            }
+
+            // 如果没找到，尝试从其他标签找 r:embed
+            if ((relId == null || relId.isEmpty())) {
+                for (Element e : wR.select("[r|embed]")) {
+                    relId = e.attr("r:embed");
+                    if (relId != null && !relId.isEmpty()) break;
+                }
+            }
+
+            // 情况1：找到了 relId → 提取图片
+            if (relId != null && !relId.isEmpty()) {
+                POIXMLDocumentPart imagePart = para.getDocument().getRelationById(relId);
+                if (imagePart instanceof XWPFPictureData) {
+                    XWPFPictureData pictureData = (XWPFPictureData) imagePart;
+                    byte[] imageData = pictureData.getData();
+
+                    String ext;
+                    int pictureType = pictureData.getPictureType();
+                    if (pictureType == XWPFDocument.PICTURE_TYPE_JPEG) {
+                        ext = "jpeg";
+                    } else if (pictureType == XWPFDocument.PICTURE_TYPE_PNG) {
+                        ext = "png";
+                    } else if (pictureType == XWPFDocument.PICTURE_TYPE_GIF) {
+                        ext = "gif";
+                    } else if (pictureType == XWPFDocument.PICTURE_TYPE_BMP) {
+                        ext = "bmp";
+                    } else {
+                        ext = "png"; // 默认值
+                    }
+
+                    String base64 = Base64.getEncoder().encodeToString(imageData);
+                    String imgUrl = "data:image/" + ext + ";base64," + base64;
+                    html.append("<img src=\"").append(imgUrl)
+                            .append("\" style=\"max-width:100%;height:auto;vertical-align:middle;\" />");
+                    return;
+                }
+            }
+
+            // 情况2：没有图片，提取文本
+            String text = extractTextFromRunXml(xml);
+            if (text != null && !text.trim().isEmpty()) {
+                html.append(text);
+            }
+
+        } catch (Exception e) {
+            e.printStackTrace();
+            html.append("<span style='color:red;'>[图片解析错误]</span>");
+        }
+    }
+
+    // 辅助方法：从 <w:r> XML 中提取文本
+    private String extractTextFromRunXml(String xml) {
+        try {
+            javax.xml.parsers.DocumentBuilder db = javax.xml.parsers.DocumentBuilderFactory.newInstance().newDocumentBuilder();
+            org.w3c.dom.Document doc = db.parse(new java.io.ByteArrayInputStream(xml.getBytes()));
+            org.w3c.dom.NodeList texts = doc.getElementsByTagName("w:t");
+            StringBuilder sb = new StringBuilder();
+            for (int i = 0; i < texts.getLength(); i++) {
+                sb.append(texts.item(i).getTextContent());
+            }
+            return sb.toString();
+        } catch (Exception e) {
+            e.printStackTrace();
+            return "";
+        }
+    }
+}
\ No newline at end of file
diff --git a/ruoyi-api/src/main/java/com/ruoyi/api/controller/MathMLConverter.java b/ruoyi-api/src/main/java/com/ruoyi/api/controller/MathMLConverter.java
new file mode 100644
index 0000000..621f7ad
--- /dev/null
+++ b/ruoyi-api/src/main/java/com/ruoyi/api/controller/MathMLConverter.java
@@ -0,0 +1,100 @@
+package com.ruoyi.api.controller;
+
+import lombok.var;
+import net.sf.saxon.s9api.*;
+
+import javax.xml.transform.*;
+import javax.xml.transform.stream.StreamResult;
+import javax.xml.transform.stream.StreamSource;
+import java.io.InputStream;
+import java.io.StringReader;
+import java.io.StringWriter;
+
+public class MathMLConverter {
+
+    private static final Processor processor = new Processor(false);
+    private static final XsltCompiler xsltCompiler = processor.newXsltCompiler();  // ✅ 正确类型
+
+    // 加载你已有的 OMML2MML.XSL
+    private static final XsltExecutable executable;
+
+    static {
+        try (var xslStream = MathMLConverter.class.getResourceAsStream("/OMML2MML.XSL")) {
+            if (xslStream == null) {
+                throw new RuntimeException("❌ XSLT file '/OMML2MML.XSL' not found in resources!");
+            }
+            executable = xsltCompiler.compile(new StreamSource(xslStream));  // ✅ 使用 xsltCompiler
+        } catch (Exception e) {
+            throw new ExceptionInInitializerError("❌ Failed to load XSLT: " + e.getMessage());
+        }
+    }
+
+    /**
+     * 将 OMML XML 字符串转换为 MathML
+     */
+    public static String convertOmmlToMathML(String omml) {
+        try {
+            // 加载 XSL 文件
+            InputStream xslStream = MathMLConverter.class.getClassLoader()
+                    .getResourceAsStream("OMML2MML.XSL");
+            if (xslStream == null) {
+                throw new RuntimeException("XSL 文件未找到，请检查路径：OMML2MML.XSL");
+            }
+
+            Source xslSource = new StreamSource(xslStream);
+            Transformer transformer = TransformerFactory.newInstance().newTransformer(xslSource);
+
+            // 设置输出属性
+            transformer.setOutputProperty(OutputKeys.OMIT_XML_DECLARATION, "yes"); // ❌ 不要 XML 声明
+            transformer.setOutputProperty(OutputKeys.INDENT, "no");
+            transformer.setOutputProperty("{http://xml.apache.org/xslt}indent-amount", "0");
+
+            // 输入 OMML
+            Source source = new StreamSource(new StringReader(omml));
+
+            // 输出
+            StringWriter stringWriter = new StringWriter();
+            Result result = new StreamResult(stringWriter);
+            transformer.transform(source, result);
+
+            String mathml = stringWriter.toString().trim();
+
+            // 🔧 清理和修复 MathML
+            mathml = cleanupMathML(mathml);
+
+            return mathml;
+
+        } catch (Exception e) {
+            e.printStackTrace();
+            return "<math xmlns=\"http://www.w3.org/1998/Math/MathML\"><mtext>公式解析错误</mtext></math>";
+        }
+    }
+
+    // 新增：清理 MathML 输出
+    private static String cleanupMathML(String mathml) {
+        if (mathml == null || mathml.isEmpty()) {
+            return "";
+        }
+
+        // 1. 移除 XML 声明（如果还在）
+        mathml = mathml.replaceFirst("(?s)<!\\?xml.*?\\?>\\s*", "");
+
+        // 2. 替换 mml:math -> math，并修复命名空间
+        mathml = mathml.replaceAll("mml:math", "math");
+        mathml = mathml.replaceAll("xmlns:mml=\"http://www.w3.org/1998/Math/MathML\"", "xmlns=\"http://www.w3.org/1998/Math/MathML\"");
+        mathml = mathml.replaceAll("xmlns:m=\"[^\"]*\"", ""); // 移除 m: 命名空间
+
+        // 3. 移除多余的 mml: 前缀
+        mathml = mathml.replaceAll("mml:([a-z])", "$1"); // mml:mi -> mi, mml:mo -> mo 等
+
+        // 4. 确保根元素是 <math xmlns="...">
+        if (mathml.startsWith("<math ") && !mathml.contains("xmlns=\"http://www.w3.org/1998/Math/MathML\"")) {
+            mathml = mathml.replaceFirst("<math ", "<math xmlns=\"http://www.w3.org/1998/Math/MathML\" ");
+        } else if (!mathml.startsWith("<math")) {
+            // 如果根标签不是 math，手动包装
+            mathml = "<math xmlns=\"http://www.w3.org/1998/Math/MathML\">" + mathml + "</math>";
+        }
+
+        return mathml.trim();
+    }
+}
\ No newline at end of file
diff --git a/ruoyi-api/src/main/resources/MML2OMML.XSL b/ruoyi-api/src/main/resources/MML2OMML.XSL
new file mode 100644
index 0000000..e2789e4
--- /dev/null
+++ b/ruoyi-api/src/main/resources/MML2OMML.XSL
@@ -0,0 +1,3822 @@
+<?xml version="1.0" encoding="UTF-8" ?>
+<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform" xmlns:mml="http://www.w3.org/1998/Math/MathML"
+	xmlns:m="http://schemas.openxmlformats.org/officeDocument/2006/math">
+  <xsl:output method="xml" encoding="UTF-8" />
+
+
+  <xsl:variable name="StrUCAlphabet">ABCDEFGHIJKLMNOPQRSTUVWXYZ</xsl:variable>
+  <xsl:variable name="StrLCAlphabet">abcdefghijklmnopqrstuvwxyz</xsl:variable>
+
+  <!-- %%Template: match *
+
+		The catch all template, just passes through 
+	-->
+  <xsl:template match="*">
+    <xsl:apply-templates select="*" />
+  </xsl:template>
+
+  <!-- %%Template: match *
+
+		Another catch all template, just passes through 
+	-->
+  <xsl:template match="/">
+    <m:oMath>
+      <xsl:apply-templates select="*" />
+    </m:oMath>
+  </xsl:template>
+
+  <!-- %%Template: SReplace
+
+		Replace all occurences of sOrig in sInput with sReplacement
+		and return the resulting string. -->
+  <xsl:template name="SReplace">
+    <xsl:param name="sInput" />
+    <xsl:param name="sOrig" />
+    <xsl:param name="sReplacement" />
+
+    <xsl:choose>
+      <xsl:when test="not(contains($sInput, $sOrig))">
+        <xsl:value-of select="$sInput" />
+      </xsl:when>
+      <xsl:otherwise>
+        <xsl:variable name="sBefore" select="substring-before($sInput, $sOrig)" />
+        <xsl:variable name="sAfter" select="substring-after($sInput, $sOrig)" />
+        <xsl:variable name="sAfterProcessed">
+          <xsl:call-template name="SReplace">
+            <xsl:with-param name="sInput" select="$sAfter" />
+            <xsl:with-param name="sOrig" select="$sOrig" />
+            <xsl:with-param name="sReplacement" select="$sReplacement" />
+          </xsl:call-template>
+        </xsl:variable>
+
+        <xsl:value-of select="concat($sBefore, concat($sReplacement, $sAfterProcessed))" />
+      </xsl:otherwise>
+    </xsl:choose>
+  </xsl:template>
+
+  <!-- %%Template: OutputText
+
+		Post processing on the string given and otherwise do
+		a xsl:value-of on it -->
+  <xsl:template name="OutputText">
+    <xsl:param name="sInput" />
+
+    <!-- Add local variable as you add new post processing tasks -->
+
+    <!-- 1. Remove any unwanted characters -->
+    <xsl:variable name="sCharStrip">
+      <xsl:value-of select="translate($sInput, '&#x2062;&#x200B;', '')" />
+    </xsl:variable>
+
+    <!-- 2. Replace any characters as needed -->
+    <!--	Replace &#x2A75; <-> ==			 -->
+    <xsl:variable name="sCharReplace">
+      <xsl:call-template name="SReplace">
+        <xsl:with-param name="sInput" select="$sCharStrip" />
+        <xsl:with-param name="sOrig" select="'&#x2A75;'" />
+        <xsl:with-param name="sReplacement" select="'=='" />
+      </xsl:call-template>
+    </xsl:variable>
+
+    <!-- Replace &#xa0; (non-breaking space) with ' ' -->
+    <xsl:variable name="sCharReplaceFinal" select="translate($sCharReplace, '&#xa0;', ' ')" />
+
+    <!-- Finally, return the last value -->
+    <xsl:value-of select="$sCharReplaceFinal" />
+  </xsl:template>
+
+
+  <!-- Template that determines whether or the given node 
+	     ndCur is a token element that doesn't have an mglyph as 
+			 a child.
+	-->
+  <xsl:template name="FNonGlyphToken">
+    <xsl:param name="ndCur" select="." />
+    <xsl:choose>
+      <xsl:when test="$ndCur/self::mml:mi[not(child::mml:mglyph)] | 
+	                     $ndCur/self::mml:mn[not(child::mml:mglyph)] | 
+	                     $ndCur/self::mml:mo[not(child::mml:mglyph)] | 
+	                     $ndCur/self::mml:ms[not(child::mml:mglyph)] |
+                       $ndCur/self::mml:mtext[not(child::mml:mglyph)]">1</xsl:when>
+      <xsl:otherwise>0</xsl:otherwise>
+    </xsl:choose>
+  </xsl:template>
+
+
+  <!-- Template used to determine if the current token element (ndCur) is the beginning of a run. 
+			 A token element is the beginning of if:
+			 
+			 the count of preceding elements is 0 
+			 or 
+			 the directory preceding element is not a non-glyph token.
+	-->
+  <xsl:template name="FStartOfRun">
+    <xsl:param name="ndCur" select="." />
+    <xsl:variable name="fPrecSibNonGlyphToken">
+      <xsl:call-template name="FNonGlyphToken">
+        <xsl:with-param name="ndCur" select="$ndCur/preceding-sibling::*[1]" />
+      </xsl:call-template>
+    </xsl:variable>
+    <xsl:choose>
+      <xsl:when test="count($ndCur/preceding-sibling::*)=0 
+											or $fPrecSibNonGlyphToken=0">1</xsl:when>
+      <xsl:otherwise>0</xsl:otherwise>
+    </xsl:choose>
+  </xsl:template>
+
+  <!-- Template that determines if ndCur is the argument of an nary expression. 
+			 
+			 ndCur is the argument of an nary expression if:
+			 
+			 1.  The preceding sibling is one of the following:  munder, mover, msub, msup, munder, msubsup, munderover
+			 and
+			 2.  The preceding sibling's child is an nary char as specified by the template "isNary"
+	-->
+  <xsl:template name="FIsNaryArgument">
+    <xsl:param name="ndCur" select="." />
+
+    <xsl:variable name="fNary">
+      <xsl:call-template name="isNary">
+        <xsl:with-param name="ndCur" select="$ndCur/preceding-sibling::*[1]/child::*[1]" />
+      </xsl:call-template>
+    </xsl:variable>
+    <xsl:choose>
+      <xsl:when test="preceding-sibling::*[1][self::mml:munder or self::mml:mover or self::mml:munderover or
+                                                    self::mml:msub or self::mml:msup or self::mml:msubsup]
+							      and $fNary='true'">1</xsl:when>
+      <xsl:otherwise>0</xsl:otherwise>
+    </xsl:choose>
+  </xsl:template>
+
+  <!-- %%Template: mml:mrow | mml:mstyle
+
+		 if this row is the next sibling of an n-ary (i.e. any of 
+         mover, munder, munderover, msupsub, msup, or msub with 
+         the base being an n-ary operator) then ignore this. Otherwise
+         pass through -->
+  <xsl:template match="mml:mrow|mml:mstyle">
+    <xsl:variable name="fNaryArgument">
+      <xsl:call-template name="FIsNaryArgument">
+        <xsl:with-param name="ndCur" select="."/>
+      </xsl:call-template>
+    </xsl:variable>
+    <xsl:if test="$fNaryArgument=0">
+      <xsl:variable name="fLinearFrac">
+        <xsl:call-template name="FLinearFrac">
+          <xsl:with-param name="ndCur" select="." />
+        </xsl:call-template>
+      </xsl:variable>
+      <xsl:choose>
+        <xsl:when test="$fLinearFrac=1">
+          <xsl:call-template name="MakeLinearFraction">
+            <xsl:with-param name="ndCur" select="." />
+          </xsl:call-template>
+        </xsl:when>
+        <xsl:otherwise>
+          <xsl:variable name="fFunc">
+            <xsl:call-template name="FIsFunc">
+              <xsl:with-param name="ndCur" select="." />
+            </xsl:call-template>
+          </xsl:variable>
+          <xsl:choose>
+            <xsl:when test="$fFunc=1">
+              <xsl:call-template name="WriteFunc">
+                <xsl:with-param name="ndCur" select="." />
+              </xsl:call-template>
+            </xsl:when>
+            <xsl:otherwise>
+              <xsl:apply-templates select="*" />
+            </xsl:otherwise>
+          </xsl:choose>
+        </xsl:otherwise>
+      </xsl:choose>
+    </xsl:if>
+  </xsl:template>
+  <xsl:template match="mml:mi[not(child::mml:mglyph)] | 
+	                     mml:mn[not(child::mml:mglyph)] | 
+	                     mml:mo[not(child::mml:mglyph)] | 
+	                     mml:ms[not(child::mml:mglyph)] |
+                       mml:mtext[not(child::mml:mglyph)]">
+
+    <!-- tokens with mglyphs as children are tranformed
+			 in a different manner than "normal" token elements.  
+			 Where normal token elements are token elements that
+			 contain only text -->
+    <xsl:variable name="fStartOfRun">
+      <xsl:call-template name="FStartOfRun">
+        <xsl:with-param name="ndCur" select="." />
+      </xsl:call-template>
+    </xsl:variable>
+
+    <!--In MathML, successive characters that are all part of one string are sometimes listed as separate 
+			tags based on their type (identifier (mi), name (mn), operator (mo), quoted (ms), literal text (mtext)), 
+			where said tags act to link one another into one logical run.  In order to wrap the text of successive mi's, 
+			mn's, and mo's into one m:t, we need to denote where a run begins.  The beginning of a run is the first mi, mn, 
+			or mo whose immediately preceding sibling either doesn't exist or is something other than a "normal" mi, mn, mo, 
+			ms, or mtext tag-->
+
+    <!-- If this mi/mo/mn/ms . . . is part the numerator or denominator of a linear fraction, then don't collect. -->
+    <xsl:variable name="fLinearFracParent">
+      <xsl:call-template name="FLinearFrac">
+        <xsl:with-param name="ndCur" select="parent::*" />
+      </xsl:call-template>
+    </xsl:variable>
+    <!-- If this mi/mo/mn/ms . . . is part of the name of a function, then don't collect. -->
+    <xsl:variable name="fFunctionName">
+      <xsl:call-template name="FIsFunc">
+        <xsl:with-param name="ndCur" select="parent::*" />
+      </xsl:call-template>
+    </xsl:variable>
+    <xsl:variable name="fShouldCollect"
+					select="($fLinearFracParent=0 and $fFunctionName=0) and (parent::mml:mrow or parent::mml:mstyle or 
+					parent::mml:msqrt or parent::mml:menclose or
+					parent::mml:math or parent::mml:mphantom or 
+					parent::mml:mtd or parent::mml:maction)" />
+
+    <!--In MathML, the meaning of the different parts that make up mathematical structures, such as a fraction 
+			having a numerator and a denominator, is determined by the relative order of those different parts.  
+			For instance, In a fraction, the numerator is the first child and the denominator is the second child.  
+			To allow for more complex structures, MathML allows one to link a group of mi, mn, and mo's together 
+			using the mrow, or mstyle tags.  The mi, mn, and mo's found within any of the above tags are considered 
+			one run.  Therefore, if the parent of any mi, mn, or mo is found to be an mrow or mstyle, then the contiguous 
+			mi, mn, and mo's will be considered one run.-->
+    <xsl:choose>
+      <xsl:when test="$fShouldCollect">
+        <xsl:choose>
+          <xsl:when test="$fStartOfRun=1">
+            <!--If this is the beginning of the run, pass all run attributes to CreateRunWithSameProp.-->
+            <xsl:call-template name="CreateRunWithSameProp">
+              <xsl:with-param name="mathbackground">
+                <!-- Look for the unqualified mathml attribute mathbackground.
+										 Fall back to the qualified mathml attribute if necessary.
+										 This priority of unqualified over qualified will be 
+										 followed throughout this xslt. -->
+                <xsl:choose>
+                  <xsl:when test="@mathbackground">
+                    <xsl:value-of select="@mathbackground"/>
+                  </xsl:when>
+                  <xsl:otherwise>
+                    <xsl:value-of select="@mml:mathbackground"/>
+                  </xsl:otherwise>
+                </xsl:choose>
+              </xsl:with-param>
+              <xsl:with-param name="mathcolor">
+                <xsl:choose>
+                  <xsl:when test="@mathcolor">
+                    <xsl:value-of select="@mathcolor"/>
+                  </xsl:when>
+                  <xsl:otherwise>
+                    <xsl:value-of select="@mml:mathcolor"/>
+                  </xsl:otherwise>
+                </xsl:choose>
+              </xsl:with-param>
+              <xsl:with-param name="mathvariant">
+                <xsl:choose>
+                  <xsl:when test="@mathvariant">
+                    <xsl:value-of select="@mathvariant"/>
+                  </xsl:when>
+                  <xsl:otherwise>
+                    <xsl:value-of select="@mml:mathvariant"/>
+                  </xsl:otherwise>
+                </xsl:choose>
+              </xsl:with-param>
+              <xsl:with-param name="color">
+                <xsl:choose>
+                  <xsl:when test="@color">
+                    <xsl:value-of select="@color"/>
+                  </xsl:when>
+                  <xsl:otherwise>
+                    <xsl:value-of select="@mml:color"/>
+                  </xsl:otherwise>
+                </xsl:choose>
+              </xsl:with-param>
+              <xsl:with-param name="font-family">
+                <xsl:choose>
+                  <xsl:when test="@font-family">
+                    <xsl:value-of select="@font-family"/>
+                  </xsl:when>
+                  <xsl:otherwise>
+                    <xsl:value-of select="@mml:font-family"/>
+                  </xsl:otherwise>
+                </xsl:choose>
+              </xsl:with-param>
+              <xsl:with-param name="fontsize">
+                <xsl:choose>
+                  <xsl:when test="@fontsize">
+                    <xsl:value-of select="@fontsize"/>
+                  </xsl:when>
+                  <xsl:otherwise>
+                    <xsl:value-of select="@mml:fontsize"/>
+                  </xsl:otherwise>
+                </xsl:choose>
+              </xsl:with-param>
+              <xsl:with-param name="fontstyle">
+                <xsl:choose>
+                  <xsl:when test="@fontstyle">
+                    <xsl:value-of select="@fontstyle"/>
+                  </xsl:when>
+                  <xsl:otherwise>
+                    <xsl:value-of select="@mml:fontstyle"/>
+                  </xsl:otherwise>
+                </xsl:choose>
+              </xsl:with-param>
+              <xsl:with-param name="fontweight">
+                <xsl:choose>
+                  <xsl:when test="@fontweight">
+                    <xsl:value-of select="@fontweight"/>
+                  </xsl:when>
+                  <xsl:otherwise>
+                    <xsl:value-of select="@mml:fontweight"/>
+                  </xsl:otherwise>
+                </xsl:choose>
+              </xsl:with-param>
+              <xsl:with-param name="mathsize">
+                <xsl:choose>
+                  <xsl:when test="@mathsize">
+                    <xsl:value-of select="@mathsize"/>
+                  </xsl:when>
+                  <xsl:otherwise>
+                    <xsl:value-of select="@mml:mathsize"/>
+                  </xsl:otherwise>
+                </xsl:choose>
+              </xsl:with-param>
+              <xsl:with-param name="ndTokenFirst" select="." />
+            </xsl:call-template>
+          </xsl:when>
+        </xsl:choose>
+      </xsl:when>
+      <xsl:otherwise>
+        <!--Only one element will be part of run-->
+        <xsl:element name="m:r">
+          <!--Create Run Properties based on current node's attributes-->
+          <xsl:call-template name="CreateRunProp">
+            <xsl:with-param name="mathvariant">
+              <xsl:choose>
+                <xsl:when test="@mathvariant">
+                  <xsl:value-of select="@mathvariant"/>
+                </xsl:when>
+                <xsl:otherwise>
+                  <xsl:value-of select="@mml:mathvariant"/>
+                </xsl:otherwise>
+              </xsl:choose>
+            </xsl:with-param>
+            <xsl:with-param name="fontstyle">
+              <xsl:choose>
+                <xsl:when test="@fontstyle">
+                  <xsl:value-of select="@fontstyle"/>
+                </xsl:when>
+                <xsl:otherwise>
+                  <xsl:value-of select="@mml:fontstyle"/>
+                </xsl:otherwise>
+              </xsl:choose>
+            </xsl:with-param>
+            <xsl:with-param name="fontweight">
+              <xsl:choose>
+                <xsl:when test="@fontweight">
+                  <xsl:value-of select="@fontweight"/>
+                </xsl:when>
+                <xsl:otherwise>
+                  <xsl:value-of select="@mml:fontweight"/>
+                </xsl:otherwise>
+              </xsl:choose>
+            </xsl:with-param>
+            <xsl:with-param name="mathcolor">
+              <xsl:choose>
+                <xsl:when test="@mathcolor">
+                  <xsl:value-of select="@mathcolor"/>
+                </xsl:when>
+                <xsl:otherwise>
+                  <xsl:value-of select="@mml:mathcolor"/>
+                </xsl:otherwise>
+              </xsl:choose>
+            </xsl:with-param>
+            <xsl:with-param name="mathsize">
+              <xsl:choose>
+                <xsl:when test="@mathsize">
+                  <xsl:value-of select="@mathsize"/>
+                </xsl:when>
+                <xsl:otherwise>
+                  <xsl:value-of select="@mml:mathsize"/>
+                </xsl:otherwise>
+              </xsl:choose>
+            </xsl:with-param>
+            <xsl:with-param name="color">
+              <xsl:choose>
+                <xsl:when test="@color">
+                  <xsl:value-of select="@color"/>
+                </xsl:when>
+                <xsl:otherwise>
+                  <xsl:value-of select="@mml:color"/>
+                </xsl:otherwise>
+              </xsl:choose>
+            </xsl:with-param>
+            <xsl:with-param name="fontsize">
+              <xsl:choose>
+                <xsl:when test="@fontsize">
+                  <xsl:value-of select="@fontsize"/>
+                </xsl:when>
+                <xsl:otherwise>
+                  <xsl:value-of select="@mml:fontsize"/>
+                </xsl:otherwise>
+              </xsl:choose>
+            </xsl:with-param>
+            <xsl:with-param name="ndCur" select="." />
+            <xsl:with-param name="fNor">
+              <xsl:call-template name="FNor">
+                <xsl:with-param name="ndCur" select="." />
+              </xsl:call-template>
+            </xsl:with-param>
+          </xsl:call-template>
+          <xsl:element name="m:t">
+            <xsl:call-template name="OutputText">
+              <xsl:with-param name="sInput" select="normalize-space(.)" />
+            </xsl:call-template>
+          </xsl:element>
+        </xsl:element>
+      </xsl:otherwise>
+    </xsl:choose>
+  </xsl:template>
+
+  <!-- %%Template: CreateRunWithSameProp
+	-->
+  <xsl:template name="CreateRunWithSameProp">
+    <xsl:param name="mathbackground" />
+    <xsl:param name="mathcolor" />
+    <xsl:param name="mathvariant" />
+    <xsl:param name="color" />
+    <xsl:param name="font-family" />
+    <xsl:param name="fontsize" />
+    <xsl:param name="fontstyle" />
+    <xsl:param name="fontweight" />
+    <xsl:param name="mathsize" />
+    <xsl:param name="ndTokenFirst" />
+
+    <!--Given mathcolor, color, mstyle's (ancestor) color, and precedence of 
+			said attributes, determine the actual color of the current run-->
+    <xsl:variable name="sColorPropCur">
+      <xsl:choose>
+        <xsl:when test="$mathcolor!=''">
+          <xsl:value-of select="$mathcolor" />
+        </xsl:when>
+        <xsl:when test="$color!=''">
+          <xsl:value-of select="$color" />
+        </xsl:when>
+        <xsl:when test="$ndTokenFirst/ancestor::mml:mstyle[@color][1]/@color!=''">
+          <xsl:value-of select="$ndTokenFirst/ancestor::mml:mstyle[@color][1]/@color" />
+        </xsl:when>
+        <xsl:when test="$ndTokenFirst/ancestor::mml:mstyle[@mml:color][1]/@mml:color!=''">
+          <xsl:value-of select="$ndTokenFirst/ancestor::mml:mstyle[@color][1]/@mml:color" />
+        </xsl:when>
+        <xsl:otherwise>
+          <xsl:value-of select="''" />
+        </xsl:otherwise>
+      </xsl:choose>
+    </xsl:variable>
+
+    <!--Given mathsize, and fontsize and precedence of said attributes, 
+			determine the actual font size of the current run-->
+    <xsl:variable name="sSzCur">
+      <xsl:choose>
+        <xsl:when test="$mathsize!=''">
+          <xsl:value-of select="$mathsize" />
+        </xsl:when>
+        <xsl:when test="$fontsize!=''">
+          <xsl:value-of select="$fontsize" />
+        </xsl:when>
+        <xsl:otherwise>
+          <xsl:value-of select="''" />
+        </xsl:otherwise>
+      </xsl:choose>
+    </xsl:variable>
+
+    <!--Given mathvariant, fontstyle, and fontweight, and precedence of 
+			the attributes, determine the actual font of the current run-->
+    <xsl:variable name="sFontCur">
+      <xsl:call-template name="GetFontCur">
+        <xsl:with-param name="mathvariant" select="$mathvariant" />
+        <xsl:with-param name="fontstyle" select="$fontstyle" />
+        <xsl:with-param name="fontweight" select="$fontweight" />
+        <xsl:with-param name="ndCur" select="$ndTokenFirst" />
+      </xsl:call-template>
+    </xsl:variable>
+
+    <!-- The omml equivalent structure for mml:mtext is an omml run with the run property m:nor (normal) set.
+         Therefore, we can only collect mtexts with  other mtext elements.  Suppose the $ndTokenFirst is an 
+         mml:mtext, then if any of its following siblings are to be grouped, they must also be mml:text elements.  
+         The inverse is also true, suppose the $ndTokenFirst isn't an mml:mtext, then if any of its following siblings 
+         are to be grouped with $ndTokenFirst, they can't be mml:mtext elements-->
+    <xsl:variable name="fNdTokenFirstIsMText">
+      <xsl:choose>
+        <xsl:when test="$ndTokenFirst/self::mml:mtext">1</xsl:when>
+        <xsl:otherwise>0</xsl:otherwise>
+      </xsl:choose>
+    </xsl:variable>
+
+    <!--In order to determine the length of the run, we will find the number of nodes before the inital node in the run and
+			the number of nodes before the first node that DOES NOT belong to the current run.  The number of nodes that will
+			be printed is One Less than the difference between the latter and the former-->
+
+    <!--Find index of current node-->
+    <xsl:variable name="nndBeforeFirst" select="count($ndTokenFirst/preceding-sibling::*)" />
+
+    <!--Find index of next change in run properties.
+		
+		    The basic idea is that we want to find the position of the last node in the longest 
+				sequence of nodes, starting from ndTokenFirst, that can be grouped into a run.  For
+				example, nodes A and B can be grouped together into the same run iff they have the same 
+				props.
+				
+				To accomplish this grouping, we want to find the next sibling to ndTokenFirst that shouldn't be 
+				included in the run of text.  We do this by counting the number of elements that precede the first
+				such element that doesn't belong.  The xpath that accomplishes this is below.
+				    
+						Count the number of siblings the precede the first element after ndTokenFirst that shouldn't belong.
+						count($ndTokenFirst/following-sibling::*[ . . . ][1]/preceding-sibling::*)
+						
+				Now, the hard part to this is what is represented by the '. . .' above.  This conditional expression is 
+				defining what elements *don't* belong to the current run.  The conditions are as follows:
+				
+				The element is not a token element (mi, mn, mo, ms, or mtext)
+				
+				or
+				
+				The token element contains a glyph child (this is handled separately).
+				
+				or
+				
+				The token is an mtext and the run didn't start with an mtext, or the token isn't an mtext and the run started 
+				with an mtext.  We do this check because mtext transforms into an omml m:nor property, and thus, these mtext
+				token elements need to be grouped separately from other token elements.
+				
+				// We do an or not( . . . ), because it was easier to define what token elements match than how they don't match.
+				// Thus, this inner '. . .' defines how token attributes equate to one another.  We add the 'not' outside of to accomplish
+				// the goal of the outer '. . .', which is the find the next element that *doesn't* match.
+				or not(
+				   The background colors match.
+					 
+					 and
+					 
+							The current font (sFontCur) matches the mathvariant
+					 
+							or
+							
+							sFontCur is normal and matches the current font characteristics
+							
+							or 
+							
+							sFontCur is italic and matches the current font characteristics
+							
+							or 
+							
+							. . .
+				
+					 and
+					 
+					 The font family matches the current font family.
+					 ) // end of not().-->
+    <xsl:variable name="nndBeforeLim" select="count($ndTokenFirst/following-sibling::*
+					[(not(self::mml:mi) and not(self::mml:mn) and not(self::mml:mo) and not(self::mml:ms) and not(self::mml:mtext))
+					or
+					(self::mml:mi[child::mml:mglyph] or self::mml:mn[child::mml:mglyph] or self::mml:mo[child::mml:mglyph] or self::mml:ms[child::mml:mglyph] or self::mml:mtext[child::mml:mglyph])
+					or
+					(($fNdTokenFirstIsMText=1 and not(self::mml:mtext)) or ($fNdTokenFirstIsMText=0 and self::mml:mtext))
+					or  
+					not(
+						((($sFontCur=@mathvariant or $sFontCur=@mml:mathvariant)
+							or
+							($sFontCur='normal'
+							 and ((@mathvariant='normal' or @mml:mathvariant='normal')
+									  or (((not(@mathvariant) or @mathvariant='') and (not(@mml:mathvariant) or @mml:mathvariant=''))
+											  and (
+									           ((@fontstyle='normal' or @mml:fontstyle='normal') and (not(@fontweight='bold') and not(@mml:fontweight='bold')))
+									           or (self::mml:mi and string-length(normalize-space(.)) &gt; 1)
+									           or (self::mml:mn and string(number(self::mml:mn/text()))='NaN')
+									          )
+									     )
+									 )
+							)
+							or
+							($sFontCur='italic' 
+							 and ((@mathvariant='italic' or @mml:mathvariant='italic')
+									  or (((not(@mathvariant) or @mathvariant='') and (not(@mml:mathvariant) or @mml:mathvariant=''))
+												and (
+									           ((@fontstyle='italic' or @mml:fontstyle='italic') and (not(@fontweight='bold') and not(@mml:fontweight='bold')))
+										         or  
+															((self::mml:mn and string(number(self::mml:mn/text()))!='NaN')
+															 or self::mml:mo
+															 or (self::mml:mi and string-length(normalize-space(.)) &lt;= 1)
+									            )
+									          )
+									     )
+									 )
+							) 
+							or
+							($sFontCur='bold'
+							 and ((@mathvariant='bold' or @mml:mathvariant='bold')
+									  or (((not(@mathvariant) or @mathvariant='') and (not(@mml:mathvariant) or @mml:mathvariant=''))
+									      and (
+									           ((@fontweight='bold' or @mml:fontweight='bold')
+									           and ((@fontstyle='normal' or @mml:fontstyle='normal') or (self::mml:mi and string-length(normalize-space(.)) &lt;= 1))
+									          )
+									     )
+									   )  
+									 )
+							)
+						  or
+							(($sFontCur='bi' or $sFontCur='bold-italic')
+							 and (
+									  (@mathvariant='bold-italic' or @mml:mathvariant='bold-italic')
+									  or (((not(@mathvariant) or @mathvariant='') and (not(@mml:mathvariant) or @mml:mathvariant=''))
+												and (
+														 ((@fontweight='bold' or @mml:fontweight='bold') and (@fontstyle='italic' or @mml:fontstyle='italic'))
+														 or ((@fontweight='bold' or @mml:fontweight='bold')
+														  	 and (self::mml:mn 
+																 		  or self::mml:mo 
+																			or (self::mml:mi and string-length(normalize-space(.)) &lt;= 1)))
+									          )
+									     )
+									 )
+							)		     
+							or
+              (($sFontCur='' 
+                 and (
+                     ((not(@mathvariant) or @mathvariant='')
+                        and (not(@mml:mathvariant) or @mml:mathvariant='')
+                        and (not(@fontstyle) or @fontstyle='')
+                        and (not(@mml:fontstyle) or @mml:fontstyle='')
+                        and (not(@fontweight)or @fontweight='')
+                        and (not(@mml:fontweight) or @mml:fontweight='')
+		              ) 
+                      or 
+                        (@mathvariant='italic' or @mml:mathvariant='italic')  
+                      or (
+                           ((not(@mathvariant) or @mathvariant='') and (not(@mml:mathvariant) or @mml:mathvariant=''))
+                               and (
+	                                 (((@fontweight='normal' or @mml:fontweight='normal') 
+		                                and (@fontstyle='italic' or @mml:fontstyle='italic'))
+	                                 )
+	                                 or
+		                                ((not(@fontweight) or @fontweight='') and (not(@mml:fontweight) or @mml:fontweight=''))
+			                                and (@fontstyle='italic' or @mml:fontstyle='italic')
+	                                 or
+		                                ((not(@fontweight) or @fontweight='') and (not(@mml:fontweight) or @mml:fontweight=''))
+			                                and (not(@fontstyle) or @fontstyle='')
+			                                and (not(@mml:fontstyle) or @mml:fontstyle=''))
+                            )
+		              )
+
+              ))
+							or
+              ($sFontCur='normal' 
+               and ((self::mml:mi 
+                     and (not(@mathvariant) or @mathvariant='')
+	                 and (not(@mml:mathvariant) or @mml:mathvariant)
+	                 and (not(@fontstyle) or @fontstyle='') 
+	                 and (not(@mml:fontstyle) or @mml:fontstyle='')
+	                 and (not(@fontweight) or @fontweight='') 
+	                 and (not(@mml:fontweight) or @mml:fontweight='')
+	                 and (string-length(normalize-space(.)) &gt; 1)
+	                 )
+	                or ((self::mml:ms or self::mml:mtext) 
+		                and (not(@mathvariant) or @mathvariant='')
+		                and (not(@mml:mathvariant) or @mml:mathvariant)
+		                and (not(@fontstyle) or @fontstyle)
+		                and (not(@fontstyle) or @fontstyle='')
+		                and (not(@fontweight) or @fontweight)
+		                and (not(@mml:fontweight) or @mml:fontweight='')
+		                )
+	                )
+              )			 
+						)
+						and
+            (($font-family = @font-family or $font-family = @mml:font-family)
+              or (($font-family='' or not($font-family))
+	              and (not(@font-family) or @font-family='')
+	              and (not(@mml:font-family) or @mml:font-family='')
+	             ) 
+            )
+					))
+					][1]/preceding-sibling::*)" />
+
+    <xsl:variable name="cndRun" select="$nndBeforeLim - $nndBeforeFirst" />
+
+    <!--Contiguous groups of like-property mi, mn, and mo's are separated by non- mi, mn, mo tags, or mi,mn, or mo
+			tags with different properties.  nndBeforeLim is the number of nodes before the next tag which separates contiguous 
+			groups of like-property mi, mn, and mo's.  Knowing this delimiting tag allows for the aggregation of the correct 
+			number of mi, mn, and mo tags.-->
+    <xsl:element name="m:r">
+
+      <!--The beginning and ending of the current run has been established. Now we should open a run element-->
+      <xsl:choose>
+
+        <!--If cndRun > 0, then there is a following diffrent prop, or non- Token, 
+						although there may or may not have been a preceding different prop, or non-
+						Token-->
+        <xsl:when test="$cndRun &gt; 0">
+          <xsl:call-template name="CreateRunProp">
+            <xsl:with-param name="mathvariant" select="$mathvariant" />
+            <xsl:with-param name="fontstyle" select="$fontstyle" />
+            <xsl:with-param name="fontweight" select="$fontweight" />
+            <xsl:with-param name="mathcolor" select="$mathcolor" />
+            <xsl:with-param name="mathsize" select="$mathsize" />
+            <xsl:with-param name="color" select="$color" />
+            <xsl:with-param name="fontsize" select="$fontsize" />
+            <xsl:with-param name="ndCur" select="$ndTokenFirst" />
+            <xsl:with-param name="fNor">
+              <xsl:call-template name="FNor">
+                <xsl:with-param name="ndCur" select="$ndTokenFirst" />
+              </xsl:call-template>
+            </xsl:with-param>
+          </xsl:call-template>
+          <xsl:element name="m:t">
+            <xsl:call-template name="OutputText">
+              <xsl:with-param name="sInput">
+                <xsl:choose>
+                  <xsl:when test="namespace-uri($ndTokenFirst) = 'http://www.w3.org/1998/Math/MathML' and local-name($ndTokenFirst) = 'ms'">
+                    <xsl:call-template name="OutputMs">
+                      <xsl:with-param name="msCur" select="$ndTokenFirst" />
+                    </xsl:call-template>
+                  </xsl:when>
+                  <xsl:otherwise>
+                    <xsl:value-of select="normalize-space($ndTokenFirst)" />
+                  </xsl:otherwise>
+                </xsl:choose>
+                <xsl:for-each select="$ndTokenFirst/following-sibling::*[position() &lt; $cndRun]">
+                  <xsl:choose>
+                    <xsl:when test="namespace-uri(.) = 'http://www.w3.org/1998/Math/MathML' and 
+													local-name(.) = 'ms'">
+                      <xsl:call-template name="OutputMs">
+                        <xsl:with-param name="msCur" select="." />
+                      </xsl:call-template>
+                    </xsl:when>
+                    <xsl:otherwise>
+                      <xsl:value-of select="normalize-space(.)" />
+                    </xsl:otherwise>
+                  </xsl:choose>
+                </xsl:for-each>
+              </xsl:with-param>
+            </xsl:call-template>
+          </xsl:element>
+        </xsl:when>
+        <xsl:otherwise>
+
+          <!--if cndRun lt;= 0, then iNextNonToken = 0, 
+						and iPrecNonToken gt;= 0.  In either case, b/c there 
+						is no next different property or non-Token 
+						(which is implied by the nndBeforeLast being equal to 0) 
+						you can put all the remaining mi, mn, and mo's into one 
+						group.-->
+          <xsl:call-template name="CreateRunProp">
+            <xsl:with-param name="mathvariant" select="$mathvariant" />
+            <xsl:with-param name="fontstyle" select="$fontstyle" />
+            <xsl:with-param name="fontweight" select="$fontweight" />
+            <xsl:with-param name="mathcolor" select="$mathcolor" />
+            <xsl:with-param name="mathsize" select="$mathsize" />
+            <xsl:with-param name="color" select="$color" />
+            <xsl:with-param name="fontsize" select="$fontsize" />
+            <xsl:with-param name="ndCur" select="$ndTokenFirst" />
+            <xsl:with-param name="fNor">
+              <xsl:call-template name="FNor">
+                <xsl:with-param name="ndCur" select="$ndTokenFirst" />
+              </xsl:call-template>
+            </xsl:with-param>
+          </xsl:call-template>
+          <xsl:element name="m:t">
+
+            <!--Create the Run, first output current, then in a 
+							for-each, because all the following siblings are
+							mn, mi, and mo's that conform to the run's properties,
+							group them together-->
+            <xsl:call-template name="OutputText">
+              <xsl:with-param name="sInput">
+                <xsl:choose>
+                  <xsl:when test="namespace-uri($ndTokenFirst) = 'http://www.w3.org/1998/Math/MathML' and 
+													local-name($ndTokenFirst) = 'ms'">
+                    <xsl:call-template name="OutputMs">
+                      <xsl:with-param name="msCur" select="$ndTokenFirst" />
+                    </xsl:call-template>
+                  </xsl:when>
+                  <xsl:otherwise>
+                    <xsl:value-of select="normalize-space($ndTokenFirst)" />
+                  </xsl:otherwise>
+                </xsl:choose>
+                <xsl:for-each select="$ndTokenFirst/following-sibling::*[self::mml:mi or self::mml:mn or self::mml:mo or self::mml:ms or self::mml:mtext]">
+                  <xsl:choose>
+                    <xsl:when test="namespace-uri(.) = 'http://www.w3.org/1998/Math/MathML' and 
+													local-name(.) = 'ms'">
+                      <xsl:call-template name="OutputMs">
+                        <xsl:with-param name="msCur" select="." />
+                      </xsl:call-template>
+                    </xsl:when>
+                    <xsl:otherwise>
+                      <xsl:value-of select="normalize-space(.)" />
+                    </xsl:otherwise>
+                  </xsl:choose>
+                </xsl:for-each>
+              </xsl:with-param>
+            </xsl:call-template>
+          </xsl:element>
+        </xsl:otherwise>
+      </xsl:choose>
+    </xsl:element>
+
+    <!--The run was terminated by an mi, mn, mo, ms, or mtext with different properties, 
+				therefore, call-template CreateRunWithSameProp, using cndRun+1 node as new start node-->
+    <xsl:if test="$nndBeforeLim!=0 
+           and ($ndTokenFirst/following-sibling::*[$cndRun]/self::mml:mi or 
+					      $ndTokenFirst/following-sibling::*[$cndRun]/self::mml:mn or
+					      $ndTokenFirst/following-sibling::*[$cndRun]/self::mml:mo or
+					      $ndTokenFirst/following-sibling::*[$cndRun]/self::mml:ms or
+                $ndTokenFirst/following-sibling::*[$cndRun]/self::mml:mtext) 
+            and (count($ndTokenFirst/following-sibling::*[$cndRun]/mml:mglyph) = 0)">
+      <xsl:call-template name="CreateRunWithSameProp">
+        <xsl:with-param name="mathbackground">
+          <xsl:choose>
+            <xsl:when test="$ndTokenFirst/following-sibling::*[$cndRun]/@mathbackground">
+              <xsl:value-of select="$ndTokenFirst/following-sibling::*[$cndRun]/@mathbackground"/>
+            </xsl:when>
+            <xsl:otherwise>
+              <xsl:value-of select="$ndTokenFirst/following-sibling::*[$cndRun]/@mml:mathbackground"/>
+            </xsl:otherwise>
+          </xsl:choose>
+        </xsl:with-param>
+        <xsl:with-param name="mathcolor">
+          <xsl:choose>
+            <xsl:when test="$ndTokenFirst/following-sibling::*[$cndRun]/@mathcolor">
+              <xsl:value-of select="$ndTokenFirst/following-sibling::*[$cndRun]/@mathcolor"/>
+            </xsl:when>
+            <xsl:otherwise>
+              <xsl:value-of select="$ndTokenFirst/following-sibling::*[$cndRun]/@mml:mathcolor"/>
+            </xsl:otherwise>
+          </xsl:choose>
+        </xsl:with-param>
+        <xsl:with-param name="mathvariant">
+          <xsl:choose>
+            <xsl:when test="$ndTokenFirst/following-sibling::*[$cndRun]/@mathvariant">
+              <xsl:value-of select="$ndTokenFirst/following-sibling::*[$cndRun]/@mathvariant"/>
+            </xsl:when>
+            <xsl:otherwise>
+              <xsl:value-of select="$ndTokenFirst/following-sibling::*[$cndRun]/@mml:mathvariant"/>
+            </xsl:otherwise>
+          </xsl:choose>
+        </xsl:with-param>
+        <xsl:with-param name="color">
+          <xsl:choose>
+            <xsl:when test="$ndTokenFirst/following-sibling::*[$cndRun]/@color">
+              <xsl:value-of select="$ndTokenFirst/following-sibling::*[$cndRun]/@color"/>
+            </xsl:when>
+            <xsl:otherwise>
+              <xsl:value-of select="$ndTokenFirst/following-sibling::*[$cndRun]/@mml:color"/>
+            </xsl:otherwise>
+          </xsl:choose>
+        </xsl:with-param>
+        <xsl:with-param name="font-family">
+          <xsl:choose>
+            <xsl:when test="$ndTokenFirst/following-sibling::*[$cndRun]/@font-family">
+              <xsl:value-of select="$ndTokenFirst/following-sibling::*[$cndRun]/@font-family"/>
+            </xsl:when>
+            <xsl:otherwise>
+              <xsl:value-of select="$ndTokenFirst/following-sibling::*[$cndRun]/@mml:font-family"/>
+            </xsl:otherwise>
+          </xsl:choose>
+        </xsl:with-param>
+        <xsl:with-param name="fontsize">
+          <xsl:choose>
+            <xsl:when test="$ndTokenFirst/following-sibling::*[$cndRun]/@fontsize">
+              <xsl:value-of select="$ndTokenFirst/following-sibling::*[$cndRun]/@fontsize"/>
+            </xsl:when>
+            <xsl:otherwise>
+              <xsl:value-of select="$ndTokenFirst/following-sibling::*[$cndRun]/@mml:fontsize"/>
+            </xsl:otherwise>
+          </xsl:choose>
+        </xsl:with-param>
+        <xsl:with-param name="fontstyle">
+          <xsl:choose>
+            <xsl:when test="$ndTokenFirst/following-sibling::*[$cndRun]/@fontstyle">
+              <xsl:value-of select="$ndTokenFirst/following-sibling::*[$cndRun]/@fontstyle"/>
+            </xsl:when>
+            <xsl:otherwise>
+              <xsl:value-of select="$ndTokenFirst/following-sibling::*[$cndRun]/@mml:fontstyle"/>
+            </xsl:otherwise>
+          </xsl:choose>
+        </xsl:with-param>
+        <xsl:with-param name="fontweight">
+          <xsl:choose>
+            <xsl:when test="$ndTokenFirst/following-sibling::*[$cndRun]/@fontweight">
+              <xsl:value-of select="$ndTokenFirst/following-sibling::*[$cndRun]/@fontweight"/>
+            </xsl:when>
+            <xsl:otherwise>
+              <xsl:value-of select="$ndTokenFirst/following-sibling::*[$cndRun]/@mml:fontweight"/>
+            </xsl:otherwise>
+          </xsl:choose>
+        </xsl:with-param>
+        <xsl:with-param name="mathsize">
+          <xsl:choose>
+            <xsl:when test="$ndTokenFirst/following-sibling::*[$cndRun]/@mathsize">
+              <xsl:value-of select="$ndTokenFirst/following-sibling::*[$cndRun]/@mathsize"/>
+            </xsl:when>
+            <xsl:otherwise>
+              <xsl:value-of select="$ndTokenFirst/following-sibling::*[$cndRun]/@mml:mathsize"/>
+            </xsl:otherwise>
+          </xsl:choose>
+        </xsl:with-param>
+        <xsl:with-param name="ndTokenFirst" select="$ndTokenFirst/following-sibling::*[$cndRun]" />
+      </xsl:call-template>
+    </xsl:if>
+  </xsl:template>
+
+  <!-- %%Template: FNor
+				 Given the context of ndCur, determine if ndCur should be omml's normal style.
+	-->
+  <xsl:template name="FNor">
+    <xsl:param name="ndCur" select="." />
+    <xsl:choose>
+      <!-- Is the current node an mml:mtext, or if this is an mglyph whose parent is 
+             an mml:mtext. -->
+      <xsl:when test="$ndCur/self::mml:mtext or ($ndCur/self::mml:mglyph and parent::mml:mtext)">1</xsl:when>
+      <xsl:otherwise>0</xsl:otherwise>
+    </xsl:choose>
+  </xsl:template>
+
+
+  <!-- %%Template: CreateRunProp
+	-->
+  <xsl:template name="CreateRunProp">
+    <xsl:param name="mathbackground" />
+    <xsl:param name="mathcolor" />
+    <xsl:param name="mathvariant" />
+    <xsl:param name="color" />
+    <xsl:param name="font-family" />
+    <xsl:param name="fontsize" />
+    <xsl:param name="fontstyle" />
+    <xsl:param name="fontweight" />
+    <xsl:param name="mathsize" />
+    <xsl:param name="ndCur" />
+    <xsl:param name="fontfamily" />
+    <xsl:param name="fNor" />
+    <xsl:variable name="mstyleColor">
+      <xsl:if test="not(not($ndCur))">
+        <xsl:choose>
+          <xsl:when test="$ndCur/ancestor::mml:mstyle[@color][1]/@color">
+            <xsl:value-of select="$ndCur/ancestor::mml:mstyle[@color][1]/@color"/>
+          </xsl:when>
+          <xsl:otherwise>
+            <xsl:value-of select="$ndCur/ancestor::mml:mstyle[@color][1]/@mml:color"/>
+          </xsl:otherwise>
+        </xsl:choose>
+      </xsl:if>
+    </xsl:variable>
+    <xsl:call-template name="CreateMathRPR">
+      <xsl:with-param name="mathvariant" select="$mathvariant" />
+      <xsl:with-param name="fontstyle" select="$fontstyle" />
+      <xsl:with-param name="fontweight" select="$fontweight" />
+      <xsl:with-param name="ndCur" select="$ndCur" />
+      <xsl:with-param name="fNor" select="$fNor" />
+    </xsl:call-template>
+  </xsl:template>
+
+  <!-- %%Template: CreateMathRPR
+	-->
+  <xsl:template name="CreateMathRPR">
+    <xsl:param name="mathvariant" />
+    <xsl:param name="fontstyle" />
+    <xsl:param name="fontweight" />
+    <xsl:param name="ndCur" />
+    <xsl:param name="fNor" />
+    <xsl:variable name="sFontCur">
+      <xsl:call-template name="GetFontCur">
+        <xsl:with-param name="mathvariant" select="$mathvariant" />
+        <xsl:with-param name="fontstyle" select="$fontstyle" />
+        <xsl:with-param name="fontweight" select="$fontweight" />
+        <xsl:with-param name="ndCur" select="$ndCur" />
+      </xsl:call-template>
+    </xsl:variable>
+    <xsl:if test="$fNor=1 or ($sFontCur!='italic' and $sFontCur!='')">
+      <xsl:element name="m:rPr">
+        <xsl:if test="$fNor=1">
+          <m:nor />
+        </xsl:if>
+        <xsl:call-template name="CreateMathScrStyProp">
+          <xsl:with-param name="font" select="$sFontCur" />
+          <xsl:with-param name="fNor" select="$fNor" />
+        </xsl:call-template>
+      </xsl:element>
+    </xsl:if>
+  </xsl:template>
+
+  <!-- %%Template: GetFontCur
+	-->
+  <xsl:template name="GetFontCur">
+    <xsl:param name="ndCur" />
+    <xsl:param name="mathvariant" />
+    <xsl:param name="fontstyle" />
+    <xsl:param name="fontweight" />
+    <xsl:choose>
+      <xsl:when test="$mathvariant!=''">
+        <xsl:value-of select="$mathvariant" />
+      </xsl:when>
+      <xsl:when test="not($ndCur)">
+        <xsl:value-of select="'italic'" />
+      </xsl:when>
+      <xsl:when test="$ndCur/self::mml:mi and (string-length(normalize-space($ndCur)) &lt;= 1)
+								      or $ndCur/self::mml:mn and string(number($ndCur/text()))!='NaN'
+								      or $ndCur/self::mml:mo">
+
+        <!-- The default for the above three cases is fontstyle=italic fontweight=normal.-->
+        <xsl:choose>
+          <xsl:when test="$fontstyle='normal' and $fontweight='bold'">
+            <!-- In omml, a sty of 'b' (which is what bold is translated into)
+						     implies a normal fontstyle -->
+            <xsl:value-of select="'bold'" />
+          </xsl:when>
+          <xsl:when test="$fontstyle='normal'">
+            <xsl:value-of select="'normal'" />
+          </xsl:when>
+          <xsl:when test="$fontweight='bold'">
+            <xsl:value-of select="'bi'" />
+          </xsl:when>
+          <xsl:otherwise>
+            <xsl:value-of select="'italic'" />
+          </xsl:otherwise>
+        </xsl:choose>
+      </xsl:when>
+      <xsl:otherwise>
+        <!--Default is fontweight = 'normal' and fontstyle='normal'-->
+        <xsl:choose>
+          <xsl:when test="$fontstyle='italic' and $fontweight='bold'">
+            <xsl:value-of select="'bi'" />
+          </xsl:when>
+          <xsl:when test="$fontstyle='italic'">
+            <xsl:value-of select="'italic'" />
+          </xsl:when>
+          <xsl:when test="$fontweight='bold'">
+            <xsl:value-of select="'bold'" />
+          </xsl:when>
+          <xsl:otherwise>
+            <xsl:value-of select="'normal'" />
+          </xsl:otherwise>
+        </xsl:choose>
+      </xsl:otherwise>
+    </xsl:choose>
+  </xsl:template>
+
+
+  <!-- %%Template: CreateMathScrStyProp
+	-->
+  <xsl:template name="CreateMathScrStyProp">
+    <xsl:param name="font" />
+    <xsl:param name="fNor" select="0"/>
+    <xsl:choose>
+      <xsl:when test="$font='normal' and $fNor=0">
+        <xsl:element name="m:sty">
+          <xsl:attribute name="m:val">p</xsl:attribute>
+        </xsl:element>
+      </xsl:when>
+      <xsl:when test="$font='bold'">
+        <xsl:element name="m:sty">
+          <xsl:attribute name="m:val">b</xsl:attribute>
+        </xsl:element>
+      </xsl:when>
+      <xsl:when test="$font='italic'">
+      </xsl:when>
+      <xsl:when test="$font='script'">
+        <xsl:element name="m:scr">
+          <xsl:attribute name="m:val">script</xsl:attribute>
+        </xsl:element>
+      </xsl:when>
+      <xsl:when test="$font='bold-script'">
+        <xsl:element name="m:scr">
+          <xsl:attribute name="m:val">script</xsl:attribute>
+        </xsl:element>
+        <xsl:element name="m:sty">
+          <xsl:attribute name="m:val">b</xsl:attribute>
+        </xsl:element>
+      </xsl:when>
+      <xsl:when test="$font='double-struck'">
+        <xsl:element name="m:scr">
+          <xsl:attribute name="m:val">double-struck</xsl:attribute>
+        </xsl:element>
+        <xsl:element name="m:sty">
+          <xsl:attribute name="m:val">p</xsl:attribute>
+        </xsl:element>
+      </xsl:when>
+      <xsl:when test="$font='fraktur'">
+        <xsl:element name="m:scr">
+          <xsl:attribute name="m:val">fraktur</xsl:attribute>
+        </xsl:element>
+        <xsl:element name="m:sty">
+          <xsl:attribute name="m:val">p</xsl:attribute>
+        </xsl:element>
+      </xsl:when>
+      <xsl:when test="$font='bold-fraktur'">
+        <xsl:element name="m:scr">
+          <xsl:attribute name="m:val">fraktur</xsl:attribute>
+        </xsl:element>
+        <xsl:element name="m:sty">
+          <xsl:attribute name="m:val">b</xsl:attribute>
+        </xsl:element>
+      </xsl:when>
+      <xsl:when test="$font='sans-serif'">
+        <xsl:element name="m:scr">
+          <xsl:attribute name="m:val">sans-serif</xsl:attribute>
+        </xsl:element>
+        <xsl:element name="m:sty">
+          <xsl:attribute name="m:val">p</xsl:attribute>
+        </xsl:element>
+      </xsl:when>
+      <xsl:when test="$font='bold-sans-serif'">
+        <xsl:element name="m:scr">
+          <xsl:attribute name="m:val">sans-serif</xsl:attribute>
+        </xsl:element>
+        <xsl:element name="m:sty">
+          <xsl:attribute name="m:val">b</xsl:attribute>
+        </xsl:element>
+      </xsl:when>
+      <xsl:when test="$font='sans-serif-italic'">
+        <xsl:element name="m:scr">
+          <xsl:attribute name="m:val">sans-serif</xsl:attribute>
+        </xsl:element>
+      </xsl:when>
+      <xsl:when test="$font='sans-serif-bold-italic'">
+        <xsl:element name="m:scr">
+          <xsl:attribute name="m:val">sans-serif</xsl:attribute>
+        </xsl:element>
+        <xsl:element name="m:sty">
+          <xsl:attribute name="m:val">bi</xsl:attribute>
+        </xsl:element>
+      </xsl:when>
+      <xsl:when test="$font='monospace'" />
+      <!-- We can't do monospace, so leave empty -->
+      <xsl:when test="$font='bold'">
+        <xsl:element name="m:sty">
+          <xsl:attribute name="m:val">b</xsl:attribute>
+        </xsl:element>
+      </xsl:when>
+      <xsl:when test="$font='bi' or $font='bold-italic'">
+        <xsl:element name="m:sty">
+          <xsl:attribute name="m:val">bi</xsl:attribute>
+        </xsl:element>
+      </xsl:when>
+    </xsl:choose>
+  </xsl:template>
+
+  <xsl:template name="FBar">
+    <xsl:param name="sLineThickness" />
+    <xsl:variable name="sLowerLineThickness" select="translate($sLineThickness, $StrUCAlphabet, $StrLCAlphabet)" />
+    <xsl:choose>
+      <xsl:when test="string-length($sLowerLineThickness)=0
+                      or $sLowerLineThickness='thin' 
+                      or $sLowerLineThickness='medium' 
+                      or $sLowerLineThickness='thick'">1</xsl:when>
+      <xsl:otherwise>
+        <xsl:variable name="fStrContainsNonZeroDigit">
+          <xsl:call-template name="FStrContainsNonZeroDigit">
+            <xsl:with-param name="s" select="$sLowerLineThickness" />
+          </xsl:call-template>
+        </xsl:variable>
+        <xsl:choose>
+          <xsl:when test="$fStrContainsNonZeroDigit=1">1</xsl:when>
+          <xsl:otherwise>0</xsl:otherwise>
+        </xsl:choose>
+      </xsl:otherwise>
+    </xsl:choose>
+  </xsl:template>
+
+
+  <!-- %%Template: match mfrac 
+		-->
+  <xsl:template match="mml:mfrac">
+    <xsl:variable name="fBar">
+      <xsl:call-template name="FBar">
+        <xsl:with-param name="sLineThickness">
+          <xsl:choose>
+            <xsl:when test="@linethickness">
+              <xsl:value-of select="@linethickness"/>
+            </xsl:when>
+            <xsl:otherwise>
+              <xsl:value-of select="@mml:linethickness"/>
+            </xsl:otherwise>
+          </xsl:choose>
+        </xsl:with-param>
+      </xsl:call-template>
+    </xsl:variable>
+
+    <xsl:element name="m:f">
+      <xsl:element name="m:fPr">
+        <xsl:element name="m:type">
+          <xsl:attribute name="m:val">
+            <xsl:choose>
+              <xsl:when test="$fBar=0">noBar</xsl:when>
+              <xsl:when test="@bevelled='true' or @mml:bevelled='true'">skw</xsl:when>
+              <xsl:otherwise>bar</xsl:otherwise>
+            </xsl:choose>
+          </xsl:attribute>
+        </xsl:element>
+      </xsl:element>
+      <xsl:element name="m:num">
+        <xsl:call-template name="CreateArgProp" />
+        <xsl:apply-templates select="child::*[1]" />
+      </xsl:element>
+      <xsl:element name="m:den">
+        <xsl:call-template name="CreateArgProp" />
+        <xsl:apply-templates select="child::*[2]" />
+      </xsl:element>
+    </xsl:element>
+  </xsl:template>
+
+  <!-- %%Template: match menclose msqrt
+	-->
+  <xsl:template match="mml:menclose | mml:msqrt">
+    <xsl:variable name="sLowerCaseNotation">
+      <xsl:choose>
+        <xsl:when test="@notation">
+          <xsl:value-of select="translate(@notation, $StrUCAlphabet, $StrLCAlphabet)"/>
+        </xsl:when>
+        <xsl:otherwise>
+          <xsl:value-of select="translate(@mml:notation, $StrUCAlphabet, $StrLCAlphabet)"/>
+        </xsl:otherwise>
+      </xsl:choose>
+    </xsl:variable>
+    <xsl:choose>
+      <!-- Take care of default -->
+      <xsl:when test="$sLowerCaseNotation='radical' 
+                      or not($sLowerCaseNotation) 
+                      or $sLowerCaseNotation='' 
+                      or self::mml:msqrt">
+        <xsl:element name="m:rad">
+          <xsl:element name="m:radPr">
+            <xsl:element name="m:degHide">
+              <xsl:attribute name="m:val">on</xsl:attribute>
+            </xsl:element>
+          </xsl:element>
+          <xsl:element name="m:deg">
+            <xsl:call-template name="CreateArgProp" />
+          </xsl:element>
+          <xsl:element name="m:e">
+            <xsl:call-template name="CreateArgProp" />
+            <xsl:apply-templates select="*" />
+          </xsl:element>
+        </xsl:element>
+      </xsl:when>
+      <xsl:otherwise>
+        <xsl:choose>
+          <xsl:when test="$sLowerCaseNotation='actuarial' or $sLowerCaseNotation='longdiv'" />
+          <xsl:otherwise>
+            <xsl:element name="m:borderBox">
+              <!-- Dealing with more complex notation attribute -->
+              <xsl:variable name="fBox">
+                <xsl:choose>
+                  <!-- Word doesn't have circle and roundedbox concepts, therefore, map both to a 
+                       box. -->
+                  <xsl:when test="contains($sLowerCaseNotation, 'box')
+                                  or contains($sLowerCaseNotation, 'circle')
+                                  or contains($sLowerCaseNotation, 'roundedbox')">1</xsl:when>
+                  <xsl:otherwise>0</xsl:otherwise>
+                </xsl:choose>
+              </xsl:variable>
+              <xsl:variable name="fTop">
+                <xsl:choose>
+                  <xsl:when test="contains($sLowerCaseNotation, 'top')">1</xsl:when>
+                  <xsl:otherwise>0</xsl:otherwise>
+                </xsl:choose>
+              </xsl:variable>
+              <xsl:variable name="fBot">
+                <xsl:choose>
+                  <xsl:when test="contains($sLowerCaseNotation, 'bottom')">1</xsl:when>
+                  <xsl:otherwise>0</xsl:otherwise>
+                </xsl:choose>
+              </xsl:variable>
+              <xsl:variable name="fLeft">
+                <xsl:choose>
+                  <xsl:when test="contains($sLowerCaseNotation, 'left')">1</xsl:when>
+                  <xsl:otherwise>0</xsl:otherwise>
+                </xsl:choose>
+              </xsl:variable>
+              <xsl:variable name="fRight">
+                <xsl:choose>
+                  <xsl:when test="contains($sLowerCaseNotation, 'right')">1</xsl:when>
+                  <xsl:otherwise>0</xsl:otherwise>
+                </xsl:choose>
+              </xsl:variable>
+              <xsl:variable name="fStrikeH">
+                <xsl:choose>
+                  <xsl:when test="contains($sLowerCaseNotation, 'horizontalstrike')">1</xsl:when>
+                  <xsl:otherwise>0</xsl:otherwise>
+                </xsl:choose>
+              </xsl:variable>
+              <xsl:variable name="fStrikeV">
+                <xsl:choose>
+                  <xsl:when test="contains($sLowerCaseNotation, 'verticalstrike')">1</xsl:when>
+                  <xsl:otherwise>0</xsl:otherwise>
+                </xsl:choose>
+              </xsl:variable>
+              <xsl:variable name="fStrikeBLTR">
+                <xsl:choose>
+                  <xsl:when test="contains($sLowerCaseNotation, 'updiagonalstrike')">1</xsl:when>
+                  <xsl:otherwise>0</xsl:otherwise>
+                </xsl:choose>
+              </xsl:variable>
+              <xsl:variable name="fStrikeTLBR">
+                <xsl:choose>
+                  <xsl:when test="contains($sLowerCaseNotation, 'downdiagonalstrike')">1</xsl:when>
+                  <xsl:otherwise>0</xsl:otherwise>
+                </xsl:choose>
+              </xsl:variable>
+
+              <!-- Should we create borderBoxPr? 
+                   We should if the enclosure isn't Word's default, which is
+                   a plain box -->
+              <xsl:if test="$fStrikeH=1 
+                          or $fStrikeV=1
+                          or $fStrikeBLTR=1 
+                          or $fStrikeTLBR=1
+                          or ($fBox=0
+                              and not($fTop=1 
+                                      and $fBot=1
+                                      and $fLeft=1
+                                      and $fRight=1)
+                              )">
+                <xsl:element name="m:borderBoxPr">
+                  <xsl:if test="$fBox=0">
+                    <xsl:if test="$fTop=0">
+                      <xsl:element name="m:hideTop">
+                        <xsl:attribute name="m:val">on</xsl:attribute>
+                      </xsl:element>
+                    </xsl:if>
+                    <xsl:if test="$fBot=0">
+                      <xsl:element name="m:hideBot">
+                        <xsl:attribute name="m:val">on</xsl:attribute>
+                      </xsl:element>
+                    </xsl:if>
+                    <xsl:if test="$fLeft=0">
+                      <xsl:element name="m:hideLeft">
+                        <xsl:attribute name="m:val">on</xsl:attribute>
+                      </xsl:element>
+                    </xsl:if>
+                    <xsl:if test="$fRight=0">
+                      <xsl:element name="m:hideRight">
+                        <xsl:attribute name="m:val">on</xsl:attribute>
+                      </xsl:element>
+                    </xsl:if>
+                  </xsl:if>
+                  <xsl:if test="$fStrikeH=1">
+                    <xsl:element name="m:strikeH">
+                      <xsl:attribute name="m:val">on</xsl:attribute>
+                    </xsl:element>
+                  </xsl:if>
+                  <xsl:if test="$fStrikeV=1">
+                    <xsl:element name="m:strikeV">
+                      <xsl:attribute name="m:val">on</xsl:attribute>
+                    </xsl:element>
+                  </xsl:if>
+                  <xsl:if test="$fStrikeBLTR=1">
+                    <xsl:element name="m:strikeBLTR">
+                      <xsl:attribute name="m:val">on</xsl:attribute>
+                    </xsl:element>
+                  </xsl:if>
+                  <xsl:if test="$fStrikeTLBR=1">
+                    <xsl:element name="m:strikeTLBR">
+                      <xsl:attribute name="m:val">on</xsl:attribute>
+                    </xsl:element>
+                  </xsl:if>
+                </xsl:element>
+              </xsl:if>
+              <xsl:element name="m:e">
+                <xsl:call-template name="CreateArgProp" />
+                <xsl:apply-templates select="*" />
+              </xsl:element>
+            </xsl:element>
+          </xsl:otherwise>
+        </xsl:choose>
+      </xsl:otherwise>
+    </xsl:choose>
+  </xsl:template>
+
+  <!-- %%Template: CreateArgProp
+	-->
+  <xsl:template name="CreateArgProp">
+    <xsl:if test="not(count(ancestor-or-self::mml:mstyle[@scriptlevel='0' or @scriptlevel='1' or @scriptlevel='2'])=0)
+                  or not(count(ancestor-or-self::mml:mstyle[@mml:scriptlevel='0' or @mml:scriptlevel='1' or @mml:scriptlevel='2'])=0)">
+      <xsl:element name="m:argPr">
+        <xsl:element name="m:scrLvl">
+          <xsl:attribute name="m:val">
+            <xsl:choose>
+              <xsl:when test="ancestor-or-self::mml:mstyle[@scriptlevel][1]/@scriptlevel">
+                <xsl:value-of select="ancestor-or-self::mml:mstyle[@scriptlevel][1]/@scriptlevel"/>
+              </xsl:when>
+              <xsl:otherwise>
+                <xsl:value-of select="ancestor-or-self::mml:mstyle[@scriptlevel][1]/@mml:scriptlevel"/>
+              </xsl:otherwise>
+            </xsl:choose>
+          </xsl:attribute>
+        </xsl:element>
+      </xsl:element>
+    </xsl:if>
+  </xsl:template>
+
+  <!-- %%Template: match mroot
+	-->
+  <xsl:template match="mml:mroot">
+    <xsl:element name="m:rad">
+      <xsl:element name="m:radPr">
+        <xsl:element name="m:degHide">
+          <xsl:attribute name="m:val">off</xsl:attribute>
+        </xsl:element>
+      </xsl:element>
+      <xsl:element name="m:deg">
+        <xsl:call-template name="CreateArgProp" />
+        <xsl:apply-templates select="child::*[2]" />
+      </xsl:element>
+      <xsl:element name="m:e">
+        <xsl:call-template name="CreateArgProp" />
+        <xsl:apply-templates select="child::*[1]" />
+      </xsl:element>
+    </xsl:element>
+  </xsl:template>
+
+  <!-- MathML has no concept of a linear fraction.  When transforming a linear fraction
+       from Omml to MathML, we create the following MathML:
+       
+       <mml:mrow>
+         <mml:mrow>
+            // numerator
+         </mml:mrow>
+         <mml:mo>/</mml:mo>
+         <mml:mrow>
+            // denominator
+         </mml:mrow>
+       </mml:mrow>
+       
+       This template looks for four things:
+          1.  ndCur is an mml:mrow
+          2.  ndCur has three children
+          3.  The second child is an <mml:mo>
+          4.  The second child's text is '/'
+       
+       -->
+  <xsl:template name="FLinearFrac">
+    <xsl:param name="ndCur" select="." />
+    <xsl:variable name="sNdText">
+      <xsl:value-of select="normalize-space($ndCur/*[2])"/>
+    </xsl:variable>
+
+    <xsl:choose>
+      <!-- I spy a linear fraction -->
+      <xsl:when test="$ndCur/self::mml:mrow
+                      and count($ndCur/*)=3
+                      and $ndCur/*[2][self::mml:mo]
+                      and $sNdText='/'">1</xsl:when>
+      <xsl:otherwise>0</xsl:otherwise>
+    </xsl:choose>
+  </xsl:template>
+
+
+  <!-- Though presentation mathml can certainly typeset any generic function with the
+	     appropriate function operator spacing, presentation MathML has no concept of 
+			 a function structure like omml does.  In order to preserve the omml <func> 
+			 element, we must establish how an omml <func> element looks in mml.  This 
+			 is shown below:
+       
+       <mml:mrow>
+         <mml:mrow>
+            // function name
+         </mml:mrow>
+         <mml:mo>&#x02061;</mml:mo>
+         <mml:mrow>
+            // function argument
+         </mml:mrow>
+       </mml:mrow>
+       
+       This template looks for six things to be true:
+					1.  ndCur is an mml:mrow
+					2.  ndCur has three children
+					3.  The first child is an <mml:mrow>
+					4.  The second child is an <mml:mo>
+					5.  The third child is an <mml:mrow>
+					6.  The second child's text is '&#x02061;'
+       -->
+  <xsl:template name="FIsFunc">
+    <xsl:param name="ndCur" select="." />
+    <xsl:variable name="sNdText">
+      <xsl:value-of select="normalize-space($ndCur/*[2])"/>
+    </xsl:variable>
+
+    <xsl:choose>
+      <!-- Is this an omml function -->
+      <xsl:when test="count($ndCur/*)=3
+								      and $ndCur/self::*[self::mml:mrow]
+                      and $ndCur/*[2][self::mml:mo]
+                      and $sNdText='&#x02061;'">1</xsl:when>
+      <xsl:otherwise>0</xsl:otherwise>
+    </xsl:choose>
+  </xsl:template>
+
+
+  <!-- Given the node of the linear fraction's parent mrow, 
+       make a linear fraction -->
+  <xsl:template name="MakeLinearFraction">
+    <xsl:param name="ndCur" select="." />
+    <xsl:element name="m:f">
+      <xsl:element name="m:fPr">
+        <xsl:element name="m:type">
+          <xsl:attribute name="m:val">lin</xsl:attribute>
+        </xsl:element>
+      </xsl:element>
+      <xsl:element name="m:num">
+        <xsl:call-template name="CreateArgProp" />
+        <xsl:apply-templates select="$ndCur/*[1]" />
+      </xsl:element>
+      <xsl:element name="m:den">
+        <xsl:call-template name="CreateArgProp" />
+        <xsl:apply-templates select="$ndCur/*[3]" />
+      </xsl:element>
+    </xsl:element>
+  </xsl:template>
+
+
+  <!-- Given the node of the function's parent mrow, 
+       make an omml function -->
+  <xsl:template name="WriteFunc">
+    <xsl:param name="ndCur" select="." />
+
+    <xsl:element name="m:func">
+      <xsl:element name="m:fName">
+        <xsl:apply-templates select="$ndCur/child::*[1]" />
+      </xsl:element>
+      <xsl:element name="m:e">
+        <xsl:apply-templates select="$ndCur/child::*[3]" />
+      </xsl:element>
+    </xsl:element>
+  </xsl:template>
+
+
+  <!-- MathML doesn't have the concept of nAry structures.  The best approximation
+       to these is to have some under/over or sub/sup followed by an mrow or mstyle.
+       
+       In the case that we've come across some under/over or sub/sup that contains an 
+       nAry operator, this function handles the following sibling to the nAry structure.
+       
+       If the following sibling is:
+       
+          mml:mstyle, then apply templates to the children of this mml:mstyle
+          
+          mml:mrow, determine if this mrow is a linear fraction 
+          (see comments for FlinearFrac template).
+              If so, make an Omml linear fraction.
+              If not, apply templates as was done for mml:mstyle.
+       
+       -->
+  <xsl:template name="NaryHandleMrowMstyle">
+    <xsl:param name="ndCur" select="." />
+    <!-- if the next sibling is an mrow, pull it in by 
+							doing whatever we would have done to its children. 
+							The mrow itself will be skipped, see template above. -->
+    <xsl:choose>
+      <xsl:when test="$ndCur[self::mml:mrow]">
+        <!-- Check for linear fraction -->
+        <xsl:variable name="fLinearFrac">
+          <xsl:call-template name="FLinearFrac">
+            <xsl:with-param name="ndCur" select="$ndCur" />
+          </xsl:call-template>
+        </xsl:variable>
+        <xsl:choose>
+          <xsl:when test="$fLinearFrac=1">
+            <xsl:call-template name="MakeLinearFraction">
+              <xsl:with-param name="ndCur" select="$ndCur" />
+            </xsl:call-template>
+          </xsl:when>
+          <xsl:otherwise>
+            <xsl:variable name="fFunc">
+              <xsl:call-template name="FIsFunc">
+                <xsl:with-param name="ndCur" select="." />
+              </xsl:call-template>
+            </xsl:variable>
+            <xsl:choose>
+              <xsl:when test="$fFunc=1">
+                <xsl:call-template name="WriteFunc">
+                  <xsl:with-param name="ndCur" select="." />
+                </xsl:call-template>
+              </xsl:when>
+              <xsl:otherwise>
+                <xsl:apply-templates select="$ndCur/*" />
+              </xsl:otherwise>
+            </xsl:choose>
+          </xsl:otherwise>
+        </xsl:choose>
+      </xsl:when>
+      <xsl:when test="$ndCur[self::mml:mstyle]">
+        <xsl:apply-templates select="$ndCur/*" />
+      </xsl:when>
+    </xsl:choose>
+  </xsl:template>
+
+
+  <!-- MathML munder/mover can represent several Omml constructs 
+       (m:bar, m:limLow, m:limUpp, m:acc, m:groupChr, etc.).  The following 
+       templates (FIsBar, FIsAcc, and FIsGroupChr) are used to determine 
+			 which of these Omml constructs an munder/mover should be translated into. -->
+
+  <!-- Note:  ndCur should only be an munder/mover MathML element.
+  
+       ndCur should be interpretted as an m:bar if
+          1)  its respective accent attribute is not true
+          2)  its second child is an mml:mo
+          3)  the character of the mml:mo is the correct under/over bar. -->
+  <xsl:template name="FIsBar">
+    <xsl:param name="ndCur" />
+    <xsl:variable name="fUnder">
+      <xsl:choose>
+        <xsl:when test="$ndCur[self::mml:munder]">1</xsl:when>
+        <xsl:otherwise>0</xsl:otherwise>
+      </xsl:choose>
+    </xsl:variable>
+    <xsl:variable name="sLowerCaseAccent">
+      <xsl:choose>
+        <xsl:when test="$fUnder=1">
+          <xsl:choose>
+            <xsl:when test="$ndCur/@accentunder">
+              <xsl:value-of select="translate($ndCur/@accentunder, $StrUCAlphabet, $StrLCAlphabet)"/>
+            </xsl:when>
+            <xsl:otherwise>
+              <xsl:value-of select="translate($ndCur/@mml:accentunder, $StrUCAlphabet, $StrLCAlphabet)"/>
+            </xsl:otherwise>
+          </xsl:choose>
+        </xsl:when>
+        <xsl:otherwise>
+          <xsl:choose>
+            <xsl:when test="$ndCur/@accent">
+              <xsl:value-of select="translate($ndCur/@accent, $StrUCAlphabet, $StrLCAlphabet)"/>
+            </xsl:when>
+            <xsl:otherwise>
+              <xsl:value-of select="translate($ndCur/@mml:accent, $StrUCAlphabet, $StrLCAlphabet)"/>
+            </xsl:otherwise>
+          </xsl:choose>
+        </xsl:otherwise>
+      </xsl:choose>
+    </xsl:variable>
+    <xsl:variable name="fAccent">
+      <xsl:choose>
+        <xsl:when test="$sLowerCaseAccent='true'">1</xsl:when>
+        <xsl:otherwise>0</xsl:otherwise>
+      </xsl:choose>
+    </xsl:variable>
+
+    <xsl:choose>
+      <!-- The script is unaccented and the second child is an mo -->
+      <xsl:when test="$fAccent = 0 
+                      and $ndCur/child::*[2]/self::mml:mo">
+        <xsl:variable name="sOperator">
+          <xsl:value-of select="$ndCur/child::*[2]" />
+        </xsl:variable>
+        <xsl:choose>
+          <!-- Should we write an underbar? -->
+          <xsl:when test="$fUnder = 1">
+            <xsl:choose>
+              <xsl:when test="$sOperator = '&#x0332;' or $sOperator = '&#x005F;'">1</xsl:when>
+              <xsl:otherwise>0</xsl:otherwise>
+            </xsl:choose>
+          </xsl:when>
+          <!-- Should we write an overbar? -->
+          <xsl:otherwise>
+            <xsl:choose>
+              <xsl:when test="$sOperator = '&#x0305;' or $sOperator = '&#x00AF;'">1</xsl:when>
+              <xsl:otherwise>0</xsl:otherwise>
+            </xsl:choose>
+          </xsl:otherwise>
+        </xsl:choose>
+      </xsl:when>
+      <xsl:otherwise>0</xsl:otherwise>
+    </xsl:choose>
+  </xsl:template>
+
+  <!-- Note:  ndCur should only be an mover MathML element.
+  
+       ndCur should be interpretted as an m:acc if
+          1)  its accent attribute is true
+          2)  its second child is an mml:mo
+          3)  there is only zero or one character in the mml:mo -->
+  <xsl:template name="FIsAcc">
+    <xsl:param name="ndCur" select="." />
+
+    <xsl:variable name="sLowerCaseAccent">
+      <xsl:choose>
+        <xsl:when test="$ndCur/@accent">
+          <xsl:value-of select="translate($ndCur/@accent, $StrUCAlphabet, $StrLCAlphabet)"/>
+        </xsl:when>
+        <xsl:otherwise>
+          <xsl:value-of select="translate($ndCur/@mml:accent, $StrUCAlphabet, $StrLCAlphabet)"/>
+        </xsl:otherwise>
+      </xsl:choose>
+    </xsl:variable>
+    <xsl:variable name="sLowerCaseMoAccent">
+      <xsl:choose>
+        <xsl:when test="$ndCur/child::*[2] = mml:mo and $ndCur/child::*[2]/@accent">
+          <xsl:value-of select="translate($ndCur/child::*[2]/@accent, $StrUCAlphabet, $StrLCAlphabet)"/>
+        </xsl:when>
+        <xsl:when test="$ndCur/child::*[2] = mml:mo and $ndCur/child::*[2]/@mml:accent">
+          <xsl:value-of select="translate($ndCur/child::*[2]/@mml:accent, $StrUCAlphabet, $StrLCAlphabet)"/>
+        </xsl:when>
+      </xsl:choose>
+    </xsl:variable>
+    <xsl:variable name="fAccent">
+      <xsl:choose>
+        <xsl:when test="$sLowerCaseMoAccent='true' or ($sLowerCaseMoAccent='' and $sLowerCaseAccent='true')">1</xsl:when>
+        <xsl:otherwise>0</xsl:otherwise>
+      </xsl:choose>
+    </xsl:variable>
+
+    <xsl:choose>
+      <!-- The script is accented and the second child is an mo -->
+      <xsl:when test="$fAccent = 1 
+                      and $ndCur/child::*[2] = mml:mo">
+        <xsl:variable name="sOperator">
+          <xsl:value-of select="$ndCur/child::*[2]" />
+        </xsl:variable>
+        <xsl:choose>
+          <!-- There is only one operator, this is a valid Omml accent! -->
+          <xsl:when test="string-length($sOperator) &lt;= 1">1</xsl:when>
+          <!-- More than one accented operator.  This isn't a valid
+               omml accent -->
+          <xsl:otherwise>0</xsl:otherwise>
+        </xsl:choose>
+      </xsl:when>
+      <!-- Not accented, not an operator, or both, but in any case, this is
+           not an Omml accent. -->
+      <xsl:otherwise>0</xsl:otherwise>
+    </xsl:choose>
+  </xsl:template>
+
+
+  <!-- Is ndCur a groupChr? 
+			 ndCur is a groupChr if:
+			 
+				 1.  The accent is false (note:  accent attribute 
+						 for munder is accentunder). 
+				 2.  ndCur is an munder or mover.
+				 3.  ndCur has two children
+				 4.  Of these two children, one is an mml:mo and the other is an mml:mrow
+				 5.  The number of characters in the mml:mo is 1.
+			 
+			 If all of the above are true, then return 1, else return 0.
+	-->
+  <xsl:template name="FIsGroupChr">
+    <xsl:param name="ndCur" select="." />
+    <xsl:variable name="fUnder">
+      <xsl:choose>
+        <xsl:when test="$ndCur[self::mml:munder]">1</xsl:when>
+        <xsl:otherwise>0</xsl:otherwise>
+      </xsl:choose>
+    </xsl:variable>
+    <xsl:variable name="sLowerCaseAccent">
+      <xsl:choose>
+        <xsl:when test="$fUnder=1">
+          <xsl:choose>
+            <xsl:when test="$ndCur/@accentunder">
+              <xsl:value-of select="translate($ndCur/@accentunder, $StrUCAlphabet, $StrLCAlphabet)"/>
+            </xsl:when>
+            <xsl:otherwise>
+              <xsl:value-of select="translate($ndCur/@mml:accentunder, $StrUCAlphabet, $StrLCAlphabet)"/>
+            </xsl:otherwise>
+          </xsl:choose>
+        </xsl:when>
+        <xsl:otherwise>
+          <xsl:choose>
+            <xsl:when test="$ndCur/@accent">
+              <xsl:value-of select="translate($ndCur/@accent, $StrUCAlphabet, $StrLCAlphabet)"/>
+            </xsl:when>
+            <xsl:otherwise>
+              <xsl:value-of select="translate($ndCur/@mml:accent, $StrUCAlphabet, $StrLCAlphabet)"/>
+            </xsl:otherwise>
+          </xsl:choose>
+        </xsl:otherwise>
+      </xsl:choose>
+    </xsl:variable>
+
+    <xsl:variable name="fAccentFalse">
+      <xsl:choose>
+        <xsl:when test="$sLowerCaseAccent='false'">1</xsl:when>
+        <xsl:otherwise>0</xsl:otherwise>
+      </xsl:choose>
+    </xsl:variable>
+
+    <xsl:choose>
+      <xsl:when test="$fAccentFalse=1
+                      and $ndCur[self::mml:munder or self::mml:mover] 
+                      and count($ndCur/child::*)=2 
+                      and (($ndCur/child::*[1][self::mml:mrow] and $ndCur/child::*[2][self::mml:mo]) 
+                            or ($ndCur/child::*[1][self::mml:mo] and $ndCur/child::*[2][self::mml:mrow]))">
+        <xsl:variable name="sOperator">
+          <xsl:value-of select="$ndCur/child::mml:mo" />
+        </xsl:variable>
+        <xsl:choose>
+          <xsl:when test="string-length($sOperator) &lt;= 1">1</xsl:when>
+          <xsl:otherwise>0</xsl:otherwise>
+        </xsl:choose>
+      </xsl:when>
+
+      <xsl:otherwise>0</xsl:otherwise>
+    </xsl:choose>
+  </xsl:template>
+
+
+  <!-- %%Template: match munder
+	-->
+  <xsl:template match="mml:munder">
+    <xsl:variable name="fNary">
+      <xsl:call-template name="isNary">
+        <xsl:with-param name="ndCur" select="child::*[1]" />
+      </xsl:call-template>
+    </xsl:variable>
+    <xsl:choose>
+      <xsl:when test="$fNary='true'">
+        <m:nary>
+          <xsl:call-template name="CreateNaryProp">
+            <xsl:with-param name="chr">
+              <xsl:value-of select="normalize-space(child::*[1])" />
+            </xsl:with-param>
+            <xsl:with-param name="sMathmlType" select="'munder'" />
+          </xsl:call-template>
+          <m:sub>
+            <xsl:call-template name="CreateArgProp" />
+            <xsl:apply-templates select="child::*[2]" />
+          </m:sub>
+          <m:sup>
+            <xsl:call-template name="CreateArgProp" />
+          </m:sup>
+          <m:e>
+            <xsl:call-template name="CreateArgProp" />
+            <xsl:call-template name="NaryHandleMrowMstyle">
+              <xsl:with-param name="ndCur" select="following-sibling::*[1]" />
+            </xsl:call-template>
+          </m:e>
+        </m:nary>
+      </xsl:when>
+      <xsl:otherwise>
+        <!-- Should this munder be interpreted as an OMML m:bar? -->
+        <xsl:variable name="fIsBar">
+          <xsl:call-template name="FIsBar">
+            <xsl:with-param name="ndCur" select="." />
+          </xsl:call-template>
+        </xsl:variable>
+        <xsl:choose>
+          <xsl:when test="$fIsBar=1">
+            <m:bar>
+              <m:barPr>
+                <m:pos m:val="bot" />
+              </m:barPr>
+              <m:e>
+                <xsl:call-template name="CreateArgProp" />
+                <xsl:apply-templates select="child::*[1]" />
+              </m:e>
+            </m:bar>
+          </xsl:when>
+          <xsl:otherwise>
+            <!-- It isn't an integral or underbar, is this a groupChr? -->
+            <xsl:variable name="fGroupChr">
+              <xsl:call-template name="FIsGroupChr">
+                <xsl:with-param name="ndCur" select="." />
+              </xsl:call-template>
+            </xsl:variable>
+            <xsl:choose>
+              <xsl:when test="$fGroupChr=1">
+                <xsl:element name="m:groupChr">
+                  <xsl:call-template name="CreateGroupChrPr">
+                    <xsl:with-param name="chr">
+                      <xsl:value-of select="mml:mo" />
+                    </xsl:with-param>
+                    <xsl:with-param name="pos">
+                      <xsl:choose>
+                        <xsl:when test="child::*[1][self::mml:mrow]">bot</xsl:when>
+                        <xsl:otherwise>top</xsl:otherwise>
+                      </xsl:choose>
+                    </xsl:with-param>
+                    <xsl:with-param name="vertJc">top</xsl:with-param>
+                  </xsl:call-template>
+                  <xsl:element name="m:e">
+                    <xsl:apply-templates select="mml:mrow" />
+                  </xsl:element>
+                </xsl:element>
+              </xsl:when>
+              <xsl:otherwise>
+                <!-- Generic munder -->
+                <xsl:element name="m:limLow">
+                  <xsl:element name="m:e">
+                    <xsl:call-template name="CreateArgProp" />
+                    <xsl:apply-templates select="child::*[1]" />
+                  </xsl:element>
+                  <xsl:element name="m:lim">
+                    <xsl:call-template name="CreateArgProp" />
+                    <xsl:apply-templates select="child::*[2]" />
+                  </xsl:element>
+                </xsl:element>
+              </xsl:otherwise>
+            </xsl:choose>
+          </xsl:otherwise>
+        </xsl:choose>
+      </xsl:otherwise>
+    </xsl:choose>
+  </xsl:template>
+
+
+  <!-- Given the values for chr, pos, and vertJc, create an omml
+	     groupChr's groupChrPr -->
+  <xsl:template name="CreateGroupChrPr">
+    <xsl:param name="chr">&#x23df;</xsl:param>
+    <xsl:param name="pos" select="bot" />
+    <xsl:param name="vertJc" select="top" />
+    <xsl:element name="m:groupChrPr">
+      <xsl:element name="m:chr">
+        <xsl:attribute name="m:val">
+          <xsl:value-of select="$chr"/>
+        </xsl:attribute>
+      </xsl:element>
+      <xsl:element name="m:pos">
+        <xsl:attribute name="m:val">
+          <xsl:value-of select="$pos"/>
+        </xsl:attribute>
+      </xsl:element>
+      <xsl:element name="m:vertJc">
+        <xsl:attribute name="m:val">
+          <xsl:value-of select="$vertJc"/>
+        </xsl:attribute>
+      </xsl:element>
+    </xsl:element>
+  </xsl:template>
+
+
+  <!--
+      Convert a non-combining character into its upper combining
+      couterpart.
+      
+      { Non-combining, Upper-combining }
+      {U+02D8, U+0306}, // BREVE
+      {U+00B8, U+0312}, // CEDILLA
+      {U+0060, U+0300}, // GRAVE ACCENT
+      {U+002D, U+0305}, // HYPHEN-MINUS/OVERLINE
+      {U+2212, U+0305}, // MINUS SIGN/OVERLINE
+      {U+002E, U+0305}, // FULL STOP/DOT ABOVE
+      {U+02D9, U+0307}, // DOT ABOVE
+      {U+02DD, U+030B}, // DOUBLE ACUTE ACCENT
+      {U+00B4, U+0301}, // ACUTE ACCENT
+      {U+007E, U+0303}, // TILDE
+      {U+02DC, U+0303}, // SMALL TILDE
+      {U+00A8, U+0308}, // DIAERESIS
+      {U+02C7, U+030C}, // CARON
+      {U+005E, U+0302}, // CIRCUMFLEX ACCENT
+      {U+00AF, U+0305}, // MACRON
+      {U+005F, ::::::}, // LOW LINE
+      {U+2192, U+20D7}, // RIGHTWARDS ARROW
+      {U+27F6, U+20D7}, // LONG RIGHTWARDS ARROW
+      {U+2190, U+20D6}, // LEFT ARROW
+  -->
+  <xsl:template name="ToUpperCombining">
+    <xsl:param name="ch" />
+    <xsl:choose>
+      <!-- BREVE -->
+      <xsl:when test="$ch='&#x02D8;'">&#x0306;</xsl:when>
+      <!-- CEDILLA -->
+      <xsl:when test="$ch='&#x00B8;'">&#x0312;</xsl:when>
+      <!-- GRAVE ACCENT -->
+      <xsl:when test="$ch='&#x0060;'">&#x0300;</xsl:when>
+      <!-- HYPHEN-MINUS/OVERLINE -->
+      <xsl:when test="$ch='&#x002D;'">&#x0305;</xsl:when>
+      <!-- MINUS SIGN/OVERLINE -->
+      <xsl:when test="$ch='&#x2212;'">&#x0305;</xsl:when>
+      <!-- FULL STOP/DOT ABOVE -->
+      <xsl:when test="$ch='&#x002E;'">&#x0307;</xsl:when>
+      <!-- DOT ABOVE -->
+      <xsl:when test="$ch='&#x02D9;'">&#x0307;</xsl:when>
+      <!-- DOUBLE ACUTE ACCENT -->
+      <xsl:when test="$ch='&#x02DD;'">&#x030B;</xsl:when>
+      <!-- ACUTE ACCENT -->
+      <xsl:when test="$ch='&#x00B4;'">&#x0301;</xsl:when>
+      <!-- TILDE -->
+      <xsl:when test="$ch='&#x007E;'">&#x0303;</xsl:when>
+      <!-- SMALL TILDE -->
+      <xsl:when test="$ch='&#x02DC;'">&#x0303;</xsl:when>
+      <!-- DIAERESIS -->
+      <xsl:when test="$ch='&#x00A8;'">&#x0308;</xsl:when>
+      <!-- CARON -->
+      <xsl:when test="$ch='&#x02C7;'">&#x030C;</xsl:when>
+      <!-- CIRCUMFLEX ACCENT -->
+      <xsl:when test="$ch='&#x005E;'">&#x0302;</xsl:when>
+      <!-- MACRON -->
+      <xsl:when test="$ch='&#x00AF;'">&#x0305;</xsl:when>
+      
+      <!-- LOW LINE -->
+      
+      <!-- RIGHTWARDS ARROW -->
+      <xsl:when test="$ch='&#x2192;'">&#x20D7;</xsl:when>
+      <!-- LONG RIGHTWARDS ARROW -->
+      <xsl:when test="$ch='&#x27F6;'">&#x20D7;</xsl:when>
+      <!-- LEFT ARROW -->
+      <xsl:when test="$ch='&#x2190;'">&#x20D6;</xsl:when>
+      <xsl:otherwise>
+        <xsl:value-of select="$ch"/>
+      </xsl:otherwise>
+    </xsl:choose>
+  </xsl:template>
+
+
+  <!-- %%Template: match mover
+	-->
+  <xsl:template match="mml:mover">
+    <xsl:variable name="fNary">
+      <xsl:call-template name="isNary">
+        <xsl:with-param name="ndCur" select="child::*[1]" />
+      </xsl:call-template>
+    </xsl:variable>
+    <xsl:choose>
+      <xsl:when test="$fNary='true'">
+        <m:nary>
+          <xsl:call-template name="CreateNaryProp">
+            <xsl:with-param name="chr">
+              <xsl:value-of select="normalize-space(child::*[1])" />
+            </xsl:with-param>
+            <xsl:with-param name="sMathmlType" select="'mover'" />
+          </xsl:call-template>
+          <m:sub>
+            <xsl:call-template name="CreateArgProp" />
+          </m:sub>
+          <m:sup>
+            <xsl:call-template name="CreateArgProp" />
+            <xsl:apply-templates select="child::*[2]" />
+          </m:sup>
+          <m:e>
+            <xsl:call-template name="CreateArgProp" />
+            <xsl:call-template name="NaryHandleMrowMstyle">
+              <xsl:with-param name="ndCur" select="following-sibling::*[1]" />
+            </xsl:call-template>
+          </m:e>
+        </m:nary>
+      </xsl:when>
+      <xsl:otherwise>
+        <!-- Should this munder be interpreted as an OMML m:bar or m:acc? -->
+
+        <!-- Check to see if this is an m:bar -->
+        <xsl:variable name="fIsBar">
+          <xsl:call-template name="FIsBar">
+            <xsl:with-param name="ndCur" select="." />
+          </xsl:call-template>
+        </xsl:variable>
+        <xsl:choose>
+          <xsl:when test="$fIsBar = 1">
+            <m:bar>
+              <m:barPr>
+                <m:pos m:val="top" />
+              </m:barPr>
+              <m:e>
+                <xsl:call-template name="CreateArgProp" />
+                <xsl:apply-templates select="child::*[1]" />
+              </m:e>
+            </m:bar>
+          </xsl:when>
+          <xsl:otherwise>
+            <!-- Not an m:bar, should it be an m:acc? -->
+            <xsl:variable name="fIsAcc">
+              <xsl:call-template name="FIsAcc">
+                <xsl:with-param name="ndCur" select="." />
+              </xsl:call-template>
+            </xsl:variable>
+            <xsl:choose>
+              <xsl:when test="$fIsAcc=1">
+                <m:acc>
+                  <m:accPr>
+                    <m:chr>
+                      <xsl:variable name="ch">
+                        <xsl:value-of select="child::*[2]" />
+                      </xsl:variable>
+                      <xsl:variable name="chComb">
+                        <xsl:call-template name="ToUpperCombining">
+                          <xsl:with-param name="ch" select="$ch" />
+                        </xsl:call-template>
+                      </xsl:variable>
+                      <xsl:attribute name="m:val">
+                        <xsl:value-of select="$chComb" />
+                      </xsl:attribute>
+                    </m:chr>
+                  </m:accPr>
+                  <m:e>
+                    <xsl:call-template name="CreateArgProp" />
+                    <xsl:apply-templates select="child::*[1]" />
+                  </m:e>
+                </m:acc>
+              </xsl:when>
+              <xsl:otherwise>
+                <!-- This isn't an integral, overbar or accent, 
+								     could it be a groupChr? -->
+                <xsl:variable name="fGroupChr">
+                  <xsl:call-template name="FIsGroupChr">
+                    <xsl:with-param name="ndCur" select="." />
+                  </xsl:call-template>
+                </xsl:variable>
+                <xsl:choose>
+                  <xsl:when test="$fGroupChr=1">
+                    <xsl:element name="m:groupChr">
+                      <xsl:call-template name="CreateGroupChrPr">
+                        <xsl:with-param name="chr">
+                          <xsl:value-of select="mml:mo" />
+                        </xsl:with-param>
+                        <xsl:with-param name="pos">
+                          <xsl:choose>
+                            <xsl:when test="child::*[1][self::mml:mrow]">top</xsl:when>
+                            <xsl:otherwise>bot</xsl:otherwise>
+                          </xsl:choose>
+                        </xsl:with-param>
+                        <xsl:with-param name="vertJc">bot</xsl:with-param>
+                      </xsl:call-template>
+                      <xsl:element name="m:e">
+                        <xsl:apply-templates select="mml:mrow" />
+                      </xsl:element>
+                    </xsl:element>
+                  </xsl:when>
+                  <xsl:otherwise>
+                    <!-- Generic mover -->
+                    <xsl:element name="m:limUpp">
+                      <xsl:element name="m:e">
+                        <xsl:call-template name="CreateArgProp" />
+                        <xsl:apply-templates select="child::*[1]" />
+                      </xsl:element>
+                      <xsl:element name="m:lim">
+                        <xsl:call-template name="CreateArgProp" />
+                        <xsl:apply-templates select="child::*[2]" />
+                      </xsl:element>
+                    </xsl:element>
+                  </xsl:otherwise>
+                </xsl:choose>
+              </xsl:otherwise>
+            </xsl:choose>
+          </xsl:otherwise>
+        </xsl:choose>
+      </xsl:otherwise>
+    </xsl:choose>
+  </xsl:template>
+
+
+  <!-- %%Template: match munderover
+	-->
+  <xsl:template match="mml:munderover">
+    <xsl:variable name="fNary">
+      <xsl:call-template name="isNary">
+        <xsl:with-param name="ndCur" select="child::*[1]" />
+      </xsl:call-template>
+    </xsl:variable>
+    <xsl:choose>
+      <xsl:when test="$fNary='true'">
+        <m:nary>
+          <xsl:call-template name="CreateNaryProp">
+            <xsl:with-param name="chr">
+              <xsl:value-of select="normalize-space(child::*[1])" />
+            </xsl:with-param>
+            <xsl:with-param name="sMathmlType" select="'munderover'" />
+          </xsl:call-template>
+          <m:sub>
+            <xsl:call-template name="CreateArgProp" />
+            <xsl:apply-templates select="child::*[2]" />
+          </m:sub>
+          <m:sup>
+            <xsl:call-template name="CreateArgProp" />
+            <xsl:apply-templates select="child::*[3]" />
+          </m:sup>
+          <m:e>
+            <xsl:call-template name="CreateArgProp" />
+            <xsl:call-template name="NaryHandleMrowMstyle">
+              <xsl:with-param name="ndCur" select="following-sibling::*[1]" />
+            </xsl:call-template>
+          </m:e>
+        </m:nary>
+      </xsl:when>
+      <xsl:otherwise>
+        <xsl:element name="m:limUpp">
+          <xsl:element name="m:e">
+            <xsl:call-template name="CreateArgProp" />
+            <xsl:element name="m:limLow">
+              <xsl:element name="m:e">
+                <xsl:call-template name="CreateArgProp" />
+                <xsl:apply-templates select="child::*[1]" />
+              </xsl:element>
+              <xsl:element name="m:lim">
+                <xsl:call-template name="CreateArgProp" />
+                <xsl:apply-templates select="child::*[2]" />
+              </xsl:element>
+            </xsl:element>
+          </xsl:element>
+          <xsl:element name="m:lim">
+            <xsl:call-template name="CreateArgProp" />
+            <xsl:apply-templates select="child::*[3]" />
+          </xsl:element>
+        </xsl:element>
+      </xsl:otherwise>
+    </xsl:choose>
+  </xsl:template>
+
+  <!-- %%Template: match mfenced -->
+  <xsl:template match="mml:mfenced">
+    <m:d>
+      <xsl:call-template name="CreateDelimProp">
+        <xsl:with-param name="fChOpenValid">
+          <xsl:choose>
+            <xsl:when test="@open">
+              <xsl:value-of select="1"/>
+            </xsl:when>
+            <xsl:when test="@mml:open">
+              <xsl:value-of select="1"/>
+            </xsl:when>
+            <xsl:otherwise>
+              <xsl:value-of select="0"/>
+            </xsl:otherwise>
+          </xsl:choose>
+        </xsl:with-param>
+        <xsl:with-param name="chOpen">
+          <xsl:choose>
+            <xsl:when test="@open">
+              <xsl:value-of select="@open"/>
+            </xsl:when>
+            <xsl:otherwise>
+              <xsl:value-of select="@mml:open"/>
+            </xsl:otherwise>
+          </xsl:choose>
+        </xsl:with-param>
+        <xsl:with-param name="fChSeparatorsValid">
+          <xsl:choose>
+            <xsl:when test="@separators">
+              <xsl:value-of select="1"/>
+            </xsl:when>
+            <xsl:when test="@mml:separators">
+              <xsl:value-of select="1"/>
+            </xsl:when>
+            <xsl:otherwise>
+              <xsl:value-of select="0"/>
+            </xsl:otherwise>
+          </xsl:choose>
+        </xsl:with-param>
+        <xsl:with-param name="chSeparators">
+          <xsl:choose>
+            <xsl:when test="@separators">
+              <xsl:value-of select="@separators"/>
+            </xsl:when>
+            <xsl:otherwise>
+              <xsl:value-of select="@mml:separators"/>
+            </xsl:otherwise>
+          </xsl:choose>
+        </xsl:with-param>
+        <xsl:with-param name="fChCloseValid">
+          <xsl:choose>
+            <xsl:when test="@close">
+              <xsl:value-of select="1"/>
+            </xsl:when>
+            <xsl:when test="@mml:close">
+              <xsl:value-of select="1"/>
+            </xsl:when>
+            <xsl:otherwise>
+              <xsl:value-of select="0"/>
+            </xsl:otherwise>
+          </xsl:choose>
+        </xsl:with-param>
+        <xsl:with-param name="chClose">
+          <xsl:choose>
+            <xsl:when test="@close">
+              <xsl:value-of select="@close"/>
+            </xsl:when>
+            <xsl:otherwise>
+              <xsl:value-of select="@mml:close"/>
+            </xsl:otherwise>
+          </xsl:choose>
+        </xsl:with-param>
+      </xsl:call-template>
+      <xsl:for-each select="*">
+        <m:e>
+          <xsl:call-template name="CreateArgProp" />
+          <xsl:apply-templates select="."/>
+        </m:e>
+      </xsl:for-each>
+    </m:d>
+  </xsl:template>
+
+  <!-- %%Template: CreateDelimProp
+	
+		Given the characters to use as open, close and separators for 
+		the delim object, create the m:dPr (delim properties). 		
+		
+		MathML can have any number of separators in an mfenced object, but 
+		OMML can only represent one separator for each d (delim) object.
+		So, we pick the first separator specified. 		
+	-->
+  <xsl:template name="CreateDelimProp">
+    <xsl:param name="fChOpenValid" />
+    <xsl:param name="chOpen" />
+    <xsl:param name="fChSeparatorsValid" />
+    <xsl:param name="chSeparators" />
+    <xsl:param name="fChCloseValid" />
+    <xsl:param name="chClose" />
+    <xsl:variable name="chSep" select="substring($chSeparators, 1, 1)" />
+
+    <!-- do we need a dPr at all? If everything's at its default value, then 
+			don't bother at all -->
+    <xsl:if test="($fChOpenValid=1 and not($chOpen = '(')) or
+						  ($fChCloseValid=1 and not($chClose = ')')) or 
+						  not($chSep = '|')">
+      <m:dPr>
+        <!-- the default for MathML and OMML is '('. -->
+        <xsl:if test="$fChOpenValid=1 and not($chOpen = '(')">
+          <m:begChr>
+            <xsl:attribute name="m:val">
+              <xsl:value-of select="$chOpen" />
+            </xsl:attribute>
+          </m:begChr>
+        </xsl:if>
+
+        <!-- the default for MathML is ',' and for OMML is '|' -->
+
+        <xsl:choose>
+          <!-- matches OMML's default, don't bother to write anything out -->
+          <xsl:when test="$chSep = '|'" />
+
+          <!-- Not specified, use MathML's default. We test against 
+					the existence of the actual attribute, not the substring -->
+          <xsl:when test="$fChSeparatorsValid=0">
+            <m:sepChr m:val=',' />
+          </xsl:when>
+
+          <xsl:otherwise>
+            <m:sepChr>
+              <xsl:attribute name="m:val">
+                <xsl:value-of select="$chSep" />
+              </xsl:attribute>
+            </m:sepChr>
+          </xsl:otherwise>
+        </xsl:choose>
+
+        <!-- the default for MathML and OMML is ')'. -->
+        <xsl:if test="$fChCloseValid=1 and not($chClose = ')')">
+          <m:endChr>
+            <xsl:attribute name="m:val">
+              <xsl:value-of select="$chClose" />
+            </xsl:attribute>
+          </m:endChr>
+        </xsl:if>
+      </m:dPr>
+    </xsl:if>
+  </xsl:template>
+
+  <xsl:template name="LQuoteFromMs">
+    <xsl:param name="msCur" select="." />
+    <xsl:choose>
+      <xsl:when test="(not($msCur/@lquote) or $msCur/@lquote='')
+                      and (not($msCur/@mml:lquote) or $msCur/@mml:lquote='')">
+        <xsl:text>"</xsl:text>
+      </xsl:when>
+      <xsl:otherwise>
+        <xsl:choose>
+          <xsl:when test="$msCur/@lquote">
+            <xsl:value-of select="$msCur/@lquote"/>
+          </xsl:when>
+          <xsl:otherwise>
+            <xsl:value-of select="$msCur/@mml:lquote"/>
+          </xsl:otherwise>
+        </xsl:choose>
+      </xsl:otherwise>
+    </xsl:choose>
+  </xsl:template>
+
+  <xsl:template name="RQuoteFromMs">
+    <xsl:param name="msCur" select="." />
+    <xsl:choose>
+      <xsl:when test="(not($msCur/@rquote) or $msCur/@rquote='')
+                       and (not($msCur/@mml:rquote) or $msCur/@mml:rquote='')">
+        <xsl:text>"</xsl:text>
+      </xsl:when>
+      <xsl:otherwise>
+        <xsl:choose>
+          <xsl:when test="$msCur/@rquote">
+            <xsl:value-of select="$msCur/@rquote"/>
+          </xsl:when>
+          <xsl:otherwise>
+            <xsl:value-of select="$msCur/@mml:rquote"/>
+          </xsl:otherwise>
+        </xsl:choose>
+      </xsl:otherwise>
+    </xsl:choose>
+  </xsl:template>
+
+  <!-- %%Template: OutputMs
+	-->
+  <xsl:template name="OutputMs">
+    <xsl:param name="msCur" />
+
+    <xsl:variable name="chLquote">
+      <xsl:call-template name="LQuoteFromMs">
+        <xsl:with-param name="msCur" select="$msCur" />
+      </xsl:call-template>
+    </xsl:variable>
+
+    <xsl:variable name="chRquote">
+      <xsl:call-template name="RQuoteFromMs">
+        <xsl:with-param name="msCur" select="$msCur" />
+      </xsl:call-template>
+    </xsl:variable>
+
+    <xsl:value-of select="$chLquote"/>
+    <xsl:value-of select="normalize-space($msCur)" />
+    <xsl:value-of select="$chRquote"/>
+  </xsl:template>
+
+  <!-- %%Template: match msub
+	-->
+  <xsl:template match="mml:msub">
+    <xsl:variable name="fNary">
+      <xsl:call-template name="isNary">
+        <xsl:with-param name="ndCur" select="child::*[1]" />
+      </xsl:call-template>
+    </xsl:variable>
+    <xsl:choose>
+      <xsl:when test="$fNary='true'">
+        <m:nary>
+          <xsl:call-template name="CreateNaryProp">
+            <xsl:with-param name="chr">
+              <xsl:value-of select="normalize-space(child::*[1])" />
+            </xsl:with-param>
+            <xsl:with-param name="sMathmlType" select="'msub'" />
+          </xsl:call-template>
+          <m:sub>
+            <xsl:call-template name="CreateArgProp" />
+            <xsl:apply-templates select="child::*[2]" />
+          </m:sub>
+          <m:sup>
+            <xsl:call-template name="CreateArgProp" />
+          </m:sup>
+          <m:e>
+            <xsl:call-template name="CreateArgProp" />
+            <xsl:call-template name="NaryHandleMrowMstyle">
+              <xsl:with-param name="ndCur" select="following-sibling::*[1]" />
+            </xsl:call-template>
+          </m:e>
+        </m:nary>
+      </xsl:when>
+      <xsl:otherwise>
+        <m:sSub>
+          <m:e>
+            <xsl:call-template name="CreateArgProp" />
+            <xsl:apply-templates select="child::*[1]" />
+          </m:e>
+          <m:sub>
+            <xsl:call-template name="CreateArgProp" />
+            <xsl:apply-templates select="child::*[2]" />
+          </m:sub>
+        </m:sSub>
+      </xsl:otherwise>
+    </xsl:choose>
+  </xsl:template>
+
+  <!-- %%Template: match msup
+	-->
+  <xsl:template match="mml:msup">
+    <xsl:variable name="fNary">
+      <xsl:call-template name="isNary">
+        <xsl:with-param name="ndCur" select="child::*[1]" />
+      </xsl:call-template>
+    </xsl:variable>
+    <xsl:choose>
+      <xsl:when test="$fNary='true'">
+        <m:nary>
+          <xsl:call-template name="CreateNaryProp">
+            <xsl:with-param name="chr">
+              <xsl:value-of select="normalize-space(child::*[1])" />
+            </xsl:with-param>
+            <xsl:with-param name="sMathmlType" select="'msup'" />
+          </xsl:call-template>
+          <m:sub>
+            <xsl:call-template name="CreateArgProp" />
+          </m:sub>
+          <m:sup>
+            <xsl:call-template name="CreateArgProp" />
+            <xsl:apply-templates select="child::*[2]" />
+          </m:sup>
+          <m:e>
+            <xsl:call-template name="CreateArgProp" />
+            <xsl:call-template name="NaryHandleMrowMstyle">
+              <xsl:with-param name="ndCur" select="following-sibling::*[1]" />
+            </xsl:call-template>
+          </m:e>
+        </m:nary>
+      </xsl:when>
+      <xsl:otherwise>
+        <m:sSup>
+          <m:e>
+            <xsl:call-template name="CreateArgProp" />
+            <xsl:apply-templates select="child::*[1]" />
+          </m:e>
+          <m:sup>
+            <xsl:call-template name="CreateArgProp" />
+            <xsl:apply-templates select="child::*[2]" />
+          </m:sup>
+        </m:sSup>
+      </xsl:otherwise>
+    </xsl:choose>
+  </xsl:template>
+
+  <!-- %%Template: match msubsup
+	-->
+  <xsl:template match="mml:msubsup">
+    <xsl:variable name="fNary">
+      <xsl:call-template name="isNary">
+        <xsl:with-param name="ndCur" select="child::*[1]" />
+      </xsl:call-template>
+    </xsl:variable>
+    <xsl:choose>
+      <xsl:when test="$fNary='true'">
+        <m:nary>
+          <xsl:call-template name="CreateNaryProp">
+            <xsl:with-param name="chr">
+              <xsl:value-of select="normalize-space(child::*[1])" />
+            </xsl:with-param>
+            <xsl:with-param name="sMathmlType" select="'msubsup'" />
+          </xsl:call-template>
+          <m:sub>
+            <xsl:call-template name="CreateArgProp" />
+            <xsl:apply-templates select="child::*[2]" />
+          </m:sub>
+          <m:sup>
+            <xsl:call-template name="CreateArgProp" />
+            <xsl:apply-templates select="child::*[3]" />
+          </m:sup>
+          <m:e>
+            <xsl:call-template name="CreateArgProp" />
+            <xsl:call-template name="NaryHandleMrowMstyle">
+              <xsl:with-param name="ndCur" select="following-sibling::*[1]" />
+            </xsl:call-template>
+          </m:e>
+        </m:nary>
+      </xsl:when>
+      <xsl:otherwise>
+        <m:sSubSup>
+          <m:e>
+            <xsl:call-template name="CreateArgProp" />
+            <xsl:apply-templates select="child::*[1]" />
+          </m:e>
+          <m:sub>
+            <xsl:call-template name="CreateArgProp" />
+            <xsl:apply-templates select="child::*[2]" />
+          </m:sub>
+          <m:sup>
+            <xsl:call-template name="CreateArgProp" />
+            <xsl:apply-templates select="child::*[3]" />
+          </m:sup>
+        </m:sSubSup>
+      </xsl:otherwise>
+    </xsl:choose>
+  </xsl:template>
+
+  <!-- %%Template: SplitScripts 
+	
+		Takes an collection of nodes, and splits them
+		odd and even into sup and sub scripts. Used for dealing with
+		mmultiscript.
+		
+		This template assumes you want to output both a sub and sup element.
+		-->
+  <xsl:template name="SplitScripts">
+    <xsl:param name="ndScripts" />
+    <m:sub>
+      <xsl:call-template name="CreateArgProp" />
+      <xsl:apply-templates select="$ndScripts[(position() mod 2) = 1]" />
+    </m:sub>
+    <m:sup>
+      <xsl:call-template name="CreateArgProp" />
+      <xsl:apply-templates select="$ndScripts[(position() mod 2) = 0]" />
+    </m:sup>
+  </xsl:template>
+
+  <!-- %%Template: match mmultiscripts
+	
+		There is some subtlety with the mml:mprescripts element. Everything that comes before 
+		that is considered a script (as opposed to a pre-script), but it need not be present.
+	-->
+  <xsl:template match="mml:mmultiscripts">
+
+    <!-- count the nodes. Everything that comes after a mml:mprescripts is considered a pre-script;
+			Everything that does not have an mml:mprescript as a preceding-sibling (and is not itself 
+			mml:mprescript) is a script, except for the first child which is always the base.
+			The mml:none element is a place holder for a sub/sup element slot.
+			
+			mmultisript pattern:
+			<mmultiscript>
+				(base)
+				(sub sup)* // Where <none/> can replace a sub/sup entry to preserve pattern.
+				<mprescripts />
+				(presub presup)*
+			</mmultiscript>
+			-->
+    <!-- Count of presecript nodes that we'd print (this is essentially anything but the none placeholder. -->
+    <xsl:variable name="cndPrescriptStrict" select="count(mml:mprescripts[1]/following-sibling::*[not(self::mml:none)])" />
+    <!-- Count of all super script excluding mml:none -->
+    <xsl:variable name="cndSuperScript" select="count(*[not(preceding-sibling::mml:mprescripts)
+																														and not(self::mml:mprescripts)
+																														and ((position() mod 2) = 1) 
+																														and not(self::mml:none)]) - 1"/>
+    <!-- Count of all sup script excluding mml:none -->
+    <xsl:variable name="cndSubScript" select="count(*[not(preceding-sibling::mml:mprescripts)
+																														and not(self::mml:mprescripts)
+																														and ((position() mod 2) = 0) 
+																														and not(self::mml:none)])"/>
+    <!-- Count of all scripts excluding mml:none -->
+    <xsl:variable name="cndScriptStrict" select="$cndSuperScript + $cndSubScript" />
+    <!-- Count of all scripts including mml:none.  This is essentially all nodes before the 
+		first mml:mprescripts except the base. -->
+    <xsl:variable name="cndScript" select="count(*[not(preceding-sibling::mml:mprescripts) and not(self::mml:mprescripts)]) - 1" />
+
+    <xsl:choose>
+      <!-- The easy case first. No prescripts, and no script ... just a base -->
+      <xsl:when test="$cndPrescriptStrict &lt;= 0 and $cndScriptStrict &lt;= 0">
+        <xsl:apply-templates select="*[1]" />
+      </xsl:when>
+
+      <!-- Next, if there are no prescripts -->
+      <xsl:when test="$cndPrescriptStrict &lt;= 0">
+        <!-- we know we have some scripts or else we would have taken the earlier
+					  branch. -->
+        <xsl:choose>
+          <!-- We have both sub and super scripts-->
+          <xsl:when test="$cndSuperScript &gt; 0 and $cndSubScript &gt; 0">
+            <m:sSubSup>
+              <m:e>
+                <xsl:call-template name="CreateArgProp" />
+                <xsl:apply-templates select="child::*[1]" />
+              </m:e>
+
+              <!-- Every child except the first is a script.  Do the split -->
+              <xsl:call-template name="SplitScripts">
+                <xsl:with-param name="ndScripts" select="*[position() &gt; 1]" />
+              </xsl:call-template>
+            </m:sSubSup>
+          </xsl:when>
+          <!-- Just a sub script -->
+          <xsl:when test="$cndSubScript &gt; 0">
+            <m:sSub>
+              <m:e>
+                <xsl:call-template name="CreateArgProp" />
+                <xsl:apply-templates select="child::*[1]" />
+              </m:e>
+
+              <!-- No prescripts and no super scripts, therefore, it's a sub. -->
+              <m:sub>
+                <xsl:apply-templates select="*[position() &gt; 1]" />
+              </m:sub>
+            </m:sSub>
+          </xsl:when>
+          <!-- Just super script -->
+          <xsl:otherwise>
+            <m:sSup>
+              <m:e>
+                <xsl:call-template name="CreateArgProp" />
+                <xsl:apply-templates select="child::*[1]" />
+              </m:e>
+
+              <!-- No prescripts and no sub scripts, therefore, it's a sup. -->
+              <m:sup>
+                <xsl:apply-templates select="*[position() &gt; 1]" />
+              </m:sup>
+            </m:sSup>
+          </xsl:otherwise>
+        </xsl:choose>
+      </xsl:when>
+
+      <!-- Next, if there are no scripts -->
+      <xsl:when test="$cndScriptStrict &lt;= 0">
+        <!-- we know we have some prescripts or else we would have taken the earlier
+					  branch. So, create an sPre and split the elements -->
+        <m:sPre>
+          <m:e>
+            <xsl:call-template name="CreateArgProp" />
+            <xsl:apply-templates select="child::*[1]" />
+          </m:e>
+
+          <!-- The prescripts come after the mml:mprescript and if we get here
+							we know there exists some elements after the mml:mprescript element. 
+							
+							The prescript element has no sub/subsup variation, therefore, even if
+							we're only writing sub, we need to write out both the sub and sup element.
+							-->
+          <xsl:call-template name="SplitScripts">
+            <xsl:with-param name="ndScripts" select="mml:mprescripts[1]/following-sibling::*" />
+          </xsl:call-template>
+        </m:sPre>
+      </xsl:when>
+
+      <!-- Finally, the case with both prescripts and scripts. Create an sPre 
+				element to house the prescripts, with a sub/sup/subsup element at its base. -->
+      <xsl:otherwise>
+        <m:sPre>
+          <m:e>
+            <xsl:choose>
+              <!-- We have both sub and super scripts-->
+              <xsl:when test="$cndSuperScript &gt; 0 and $cndSubScript &gt; 0">
+                <m:sSubSup>
+                  <m:e>
+                    <xsl:call-template name="CreateArgProp" />
+                    <xsl:apply-templates select="child::*[1]" />
+                  </m:e>
+
+                  <!-- scripts come before the mml:mprescript but after the first child, so their
+								 positions will be 2, 3, ... ($nndScript + 1) -->
+                  <xsl:call-template name="SplitScripts">
+                    <xsl:with-param name="ndScripts" select="*[(position() &gt; 1) and (position() &lt;= ($cndScript + 1))]" />
+                  </xsl:call-template>
+                </m:sSubSup>
+              </xsl:when>
+              <!-- Just a sub script -->
+              <xsl:when test="$cndSubScript &gt; 0">
+                <m:sSub>
+                  <m:e>
+                    <xsl:call-template name="CreateArgProp" />
+                    <xsl:apply-templates select="child::*[1]" />
+                  </m:e>
+
+                  <!-- We have prescripts but no super scripts, therefore, do a sub 
+									and apply templates to all tokens counted by cndScript. -->
+                  <m:sub>
+                    <xsl:apply-templates select="*[position() &gt; 1 and (position() &lt;= ($cndScript + 1))]" />
+                  </m:sub>
+                </m:sSub>
+              </xsl:when>
+              <!-- Just super script -->
+              <xsl:otherwise>
+                <m:sSup>
+                  <m:e>
+                    <xsl:call-template name="CreateArgProp" />
+                    <xsl:apply-templates select="child::*[1]" />
+                  </m:e>
+
+                  <!-- We have prescripts but no sub scripts, therefore, do a sub 
+									and apply templates to all tokens counted by cndScript. -->
+                  <m:sup>
+                    <xsl:apply-templates select="*[position() &gt; 1 and (position() &lt;= ($cndScript + 1))]" />
+                  </m:sup>
+                </m:sSup>
+              </xsl:otherwise>
+            </xsl:choose>
+          </m:e>
+
+          <!-- The prescripts come after the mml:mprescript and if we get here
+							we know there exists one such element -->
+          <xsl:call-template name="SplitScripts">
+            <xsl:with-param name="ndScripts" select="mml:mprescripts[1]/following-sibling::*" />
+          </xsl:call-template>
+        </m:sPre>
+      </xsl:otherwise>
+    </xsl:choose>
+  </xsl:template>
+
+  <!-- Template that determines if ndCur is an equation array.
+				
+			 ndCur is an equation array if:
+			 
+			 1.  There are are no frame lines
+			 2.  There are no column lines
+			 3.  There are no row lines
+			 4.  There is no row with more than 1 column  
+			 5.  There is no row with fewer than 1 column
+			 6.  There are no labeled rows.
+			 
+	-->
+  <xsl:template name="FIsEqArray">
+    <xsl:param name="ndCur" select="." />
+
+    <!-- There should be no frame, columnlines, or rowlines -->
+    <xsl:choose>
+      <xsl:when test="(not($ndCur/@frame) or $ndCur/@frame='' or $ndCur/@frame='none')
+                      and (not($ndCur/@mml:frame) or $ndCur/@mml:frame='' or $ndCur/@mml:frame='none')
+								      and (not($ndCur/@columnlines) or $ndCur/@columnlines='' or $ndCur/@columnlines='none')
+                      and (not($ndCur/@mml:columnlines) or $ndCur/@mml:columnlines='' or $ndCur/@mml:columnlines='none')
+								      and (not($ndCur/@rowlines) or $ndCur/@rowlines='' or $ndCur/@rowlines='none')
+                      and (not($ndCur/@mml:rowlines) or $ndCur/@mml:rowlines='' or $ndCur/@mml:rowlines='none')
+								      and not($ndCur/mml:mtr[count(mml:mtd) &gt; 1])
+											and not($ndCur/mml:mtr[count(mml:mtd) &lt; 1])
+								      and not($ndCur/mml:mlabeledtr)">1</xsl:when>
+      <xsl:otherwise>0</xsl:otherwise>
+    </xsl:choose>
+  </xsl:template>
+
+  <!-- Template used to determine if we should ignore a collection when iterating through 
+	     a mathml equation array row.
+	
+			 So far, the only thing that needs to be ignored is the argument of an nary.  We
+			 can ignore this since it is output when we apply-templates to the munder[over]/msub[sup].
+	-->
+  <xsl:template name="FIgnoreCollection">
+    <xsl:param name="ndCur" select="." />
+
+    <xsl:variable name="fNaryArgument">
+      <xsl:call-template name="FIsNaryArgument">
+        <xsl:with-param name="ndCur" select="$ndCur" />
+      </xsl:call-template>
+    </xsl:variable>
+
+    <xsl:choose>
+      <xsl:when test="$fNaryArgument=1">1</xsl:when>
+      <xsl:otherwise>0</xsl:otherwise>
+    </xsl:choose>
+  </xsl:template>
+
+  <!-- Template used to determine if we've already encountered an maligngroup or malignmark.
+	
+			 This is needed because omml has an implicit spacing alignment (omml spacing alignment = 
+			 mathml's maligngroup element) at the beginning of each equation array row.  Therefore, 
+			 the first maligngroup (implied or explicit) we encounter does not need to be output.  
+			 This template recursively searches up the xml tree and looks at previous siblings to see 
+			 if they have a descendant that is an maligngroup or malignmark.  We look for the malignmark 
+			 to find the implicit maligngroup.
+	-->
+  <xsl:template name="FFirstAlignAlreadyFound">
+    <xsl:param name="ndCur" select="." />
+
+    <xsl:choose>
+      <xsl:when test="count($ndCur/preceding-sibling::*[descendant-or-self::mml:maligngroup
+								                                        or descendant-or-self::mml:malignmark]) &gt; 0">1</xsl:when>
+      <xsl:when test="not($ndCur/parent::mml:mtd)">
+        <xsl:call-template name="FFirstAlignAlreadyFound">
+          <xsl:with-param name="ndCur" select="$ndCur/parent::*" />
+        </xsl:call-template>
+      </xsl:when>
+      <xsl:otherwise>0</xsl:otherwise>
+    </xsl:choose>
+  </xsl:template>
+
+  <!-- This template builds a string that is result of concatenating a given string several times. 
+	
+			 Given strToRepeat, create a string that has strToRepeat repeated iRepitions times. 
+	-->
+  <xsl:template name="ConcatStringRepeat">
+    <xsl:param name="strToRepeat" select="''" />
+    <xsl:param name="iRepetitions" select="0" />
+    <xsl:param name="strBuilding" select="''" />
+
+    <xsl:choose>
+      <xsl:when test="$iRepetitions &lt;= 0">
+        <xsl:value-of select="$strBuilding" />
+      </xsl:when>
+      <xsl:otherwise>
+        <xsl:call-template name="ConcatStringRepeat">
+          <xsl:with-param name="strToRepeat" select="$strToRepeat" />
+          <xsl:with-param name="iRepetitions" select="$iRepetitions - 1" />
+          <xsl:with-param name="strBuilding" select="concat($strBuilding, $strToRepeat)" />
+        </xsl:call-template>
+      </xsl:otherwise>
+    </xsl:choose>
+  </xsl:template>
+
+  <!-- This template determines if ndCur is a special collection.
+			 By special collection, I mean is ndCur the outer element of some special grouping 
+			 of mathml elements that actually represents some over all omml structure.
+			 
+			 For instance, is ndCur a linear fraction, or an omml function.
+	-->
+  <xsl:template name="FSpecialCollection">
+    <xsl:param name="ndCur" select="." />
+    <xsl:choose>
+      <xsl:when test="$ndCur/self::mml:mrow">
+        <xsl:variable name="fLinearFraction">
+          <xsl:call-template name="FLinearFrac">
+            <xsl:with-param name="ndCur" select="$ndCur"/>
+          </xsl:call-template>
+        </xsl:variable>
+        <xsl:variable name="fFunc">
+          <xsl:call-template name="FIsFunc">
+            <xsl:with-param name="ndCur" select="$ndCur" />
+          </xsl:call-template>
+        </xsl:variable>
+        <xsl:choose>
+          <xsl:when test="$fLinearFraction=1 or $fFunc=1">1</xsl:when>
+          <xsl:otherwise>0</xsl:otherwise>
+        </xsl:choose>
+      </xsl:when>
+      <xsl:otherwise>0</xsl:otherwise>
+    </xsl:choose>
+  </xsl:template>
+
+  <!-- This template iterates through the children of an equation array row (mtr) and outputs
+	     the equation.
+			 
+			 This template does all the work to output ampersands and skip the right elements when needed.
+	-->
+  <xsl:template name="ProcessEqArrayRow">
+    <xsl:param name="ndCur" select="." />
+
+    <xsl:for-each select="$ndCur/*">
+      <xsl:variable name="fSpecialCollection">
+        <xsl:call-template name="FSpecialCollection">
+          <xsl:with-param name="ndCur" select="." />
+        </xsl:call-template>
+      </xsl:variable>
+      <xsl:variable name="fIgnoreCollection">
+        <xsl:call-template name="FIgnoreCollection">
+          <xsl:with-param name="ndCur" select="." />
+        </xsl:call-template>
+      </xsl:variable>
+      <xsl:choose>
+        <!-- If we have an alignment element output the ampersand. -->
+        <xsl:when test="self::mml:maligngroup or self::mml:malignmark">
+          <!-- Omml has an implied spacing alignment at the beginning of each equation.
+					     Therefore, if this is the first ampersand to be output, don't actually output. -->
+          <xsl:variable name="fFirstAlignAlreadyFound">
+            <xsl:call-template name="FFirstAlignAlreadyFound">
+              <xsl:with-param name="ndCur" select="." />
+            </xsl:call-template>
+          </xsl:variable>
+          <!-- Don't output unless it is an malignmark or we have already previously found an alignment point. -->
+          <xsl:if test="self::mml:malignmark or $fFirstAlignAlreadyFound=1">
+            <m:r>
+              <m:t>&amp;</m:t>
+            </m:r>
+          </xsl:if>
+        </xsl:when>
+        <!-- If this node is an non-special mrow or mstyle and we aren't supposed to ignore this collection, then
+				     go ahead an apply templates to this node. -->
+        <xsl:when test="$fIgnoreCollection=0 and ((self::mml:mrow and $fSpecialCollection=0) or self::mml:mstyle)">
+          <xsl:call-template name="ProcessEqArrayRow">
+            <xsl:with-param name="ndCur" select="." />
+          </xsl:call-template>
+        </xsl:when>
+        <!-- At this point we have some mathml structure (fraction, nary, non-grouping element, etc.) -->
+        <!-- If this mathml structure has alignment groups or marks as children, then extract those since
+				     omml can't handle that. -->
+        <xsl:when test="descendant::mml:maligngroup or descendant::mml:malignmark">
+          <xsl:variable name="cMalignGroups">
+            <xsl:value-of select="count(descendant::mml:maligngroup)" />
+          </xsl:variable>
+          <xsl:variable name="cMalignMarks">
+            <xsl:value-of select="count(descendant::mml:malignmark)" />
+          </xsl:variable>
+          <!-- Output all maligngroups and malignmarks as '&' -->
+          <xsl:if test="$cMalignGroups + $cMalignMarks &gt; 0">
+            <xsl:variable name="str">
+              <xsl:call-template name="ConcatStringRepeat">
+                <xsl:with-param name="strToRepeat" select="'&amp;'" />
+                <xsl:with-param name="iRepetitions" select="$cMalignGroups + $cMalignMarks" />
+                <xsl:with-param name="strBuilding" select="''" />
+              </xsl:call-template>
+            </xsl:variable>
+            <xsl:element name="m:r">
+              <xsl:element name="m:t">
+                <xsl:call-template name="OutputText">
+                  <xsl:with-param name="sInput" select="$str" />
+                </xsl:call-template>
+              </xsl:element>
+            </xsl:element>
+          </xsl:if>
+          <!-- Now that the '&' have been extracted, just apply-templates to this node.-->
+          <xsl:apply-templates select="." />
+        </xsl:when>
+        <!-- If there are no alignment points as descendants, then go ahead and output this node. -->
+        <xsl:otherwise>
+          <xsl:apply-templates select="." />
+        </xsl:otherwise>
+      </xsl:choose>
+    </xsl:for-each>
+  </xsl:template>
+
+  <!-- This template transforms mtable into its appropriate omml type.
+	
+			 There are two possible omml constructs that an mtable can become:  a matrix or 
+			 an equation array.
+			 
+			 Because omml has no generic table construct, the omml matrix is the best approximate
+			 for a mathml table.
+			 
+			 Our equation array transformation is very simple.  The main goal of this transform is to
+			 allow roundtripping omml eq arrays through mathml.  The template ProcessEqArrayRow was never
+			 intended to account for many of the alignment flexibilities that are present in mathml like 
+			 using the alig attribute, using alignmark attribute in token elements, etc.
+			 
+			 The restrictions on this transform require <malignmark> and <maligngroup> elements to be outside of
+			 any non-grouping mathml elements (that is, mrow and mstyle).  Moreover, these elements cannot be the children of
+			 mrows that represent linear fractions or functions.  Also, <malignmark> cannot be a child
+			 of token attributes.
+			 
+			 In the case that the above 
+	
+	-->
+  <xsl:template match="mml:mtable">
+    <xsl:variable name="fEqArray">
+      <xsl:call-template name="FIsEqArray">
+        <xsl:with-param name="ndCur" select="." />
+      </xsl:call-template>
+    </xsl:variable>
+    <xsl:choose>
+      <xsl:when test="$fEqArray=1">
+        <xsl:element name="m:eqArr">
+          <xsl:for-each select="mml:mtr">
+            <xsl:element name="m:e">
+              <xsl:call-template name="ProcessEqArrayRow">
+                <xsl:with-param name="ndCur" select="mml:mtd" />
+              </xsl:call-template>
+            </xsl:element>
+          </xsl:for-each>
+        </xsl:element>
+      </xsl:when>
+      <xsl:otherwise>
+        <xsl:variable name="cMaxElmtsInRow">
+          <xsl:call-template name="CountMaxElmtsInRow">
+            <xsl:with-param name="ndCur" select="*[1]" />
+            <xsl:with-param name="cMaxElmtsInRow" select="0" />
+          </xsl:call-template>
+        </xsl:variable>
+        <m:m>
+          <m:mPr>
+            <m:baseJc m:val="center" />
+            <m:plcHide m:val="on" />
+            <m:mcs>
+              <m:mc>
+                <m:mcPr>
+                  <m:count>
+                    <xsl:attribute name="m:val">
+                      <xsl:value-of select="$cMaxElmtsInRow" />
+                    </xsl:attribute>
+                  </m:count>
+                  <m:mcJc m:val="center" />
+                </m:mcPr>
+              </m:mc>
+            </m:mcs>
+          </m:mPr>
+          <xsl:for-each select="*">
+            <xsl:choose>
+              <xsl:when test="self::mml:mtr or self::mml:mlabeledtr">
+                <m:mr>
+                  <xsl:choose>
+                    <xsl:when test="self::mml:mtr">
+                      <xsl:for-each select="*">
+                        <m:e>
+                          <xsl:apply-templates select="." />
+                        </m:e>
+                      </xsl:for-each>
+                      <xsl:call-template name="CreateEmptyElmt">
+                        <xsl:with-param name="cEmptyMtd" select="$cMaxElmtsInRow - count(*)" />
+                      </xsl:call-template>
+                    </xsl:when>
+                    <xsl:otherwise>
+                      <xsl:for-each select="*[position() &gt; 1]">
+                        <m:e>
+                          <xsl:apply-templates select="." />
+                        </m:e>
+                      </xsl:for-each>
+                      <xsl:call-template name="CreateEmptyElmt">
+                        <xsl:with-param name="cEmptyMtd" select="$cMaxElmtsInRow - (count(*) - 1)" />
+                      </xsl:call-template>
+                    </xsl:otherwise>
+                  </xsl:choose>
+                </m:mr>
+              </xsl:when>
+              <xsl:otherwise>
+                <m:mr>
+                  <m:e>
+                    <xsl:apply-templates select="." />
+                  </m:e>
+                  <xsl:call-template name="CreateEmptyElmt">
+                    <xsl:with-param name="cEmptyMtd" select="$cMaxElmtsInRow - 1" />
+                  </xsl:call-template>
+                </m:mr>
+              </xsl:otherwise>
+            </xsl:choose>
+          </xsl:for-each>
+        </m:m>
+      </xsl:otherwise>
+    </xsl:choose>
+  </xsl:template>
+  <xsl:template match="m:mtd">
+    <xsl:apply-templates select="*" />
+  </xsl:template>
+  <xsl:template name="CreateEmptyElmt">
+    <xsl:param name="cEmptyMtd" />
+    <xsl:if test="$cEmptyMtd &gt; 0">
+      <m:e></m:e>
+      <xsl:call-template name="CreateEmptyElmt">
+        <xsl:with-param name="cEmptyMtd" select="$cEmptyMtd - 1" />
+      </xsl:call-template>
+    </xsl:if>
+  </xsl:template>
+  <xsl:template name="CountMaxElmtsInRow">
+    <xsl:param name="ndCur" />
+    <xsl:param name="cMaxElmtsInRow" select="0" />
+    <xsl:choose>
+      <xsl:when test="not($ndCur)">
+        <xsl:value-of select="$cMaxElmtsInRow" />
+      </xsl:when>
+      <xsl:otherwise>
+        <xsl:call-template name="CountMaxElmtsInRow">
+          <xsl:with-param name="ndCur" select="$ndCur/following-sibling::*[1]" />
+          <xsl:with-param name="cMaxElmtsInRow">
+            <xsl:choose>
+              <xsl:when test="local-name($ndCur) = 'mlabeledtr' and 
+								            namespace-uri($ndCur) = 'http://www.w3.org/1998/Math/MathML'">
+                <xsl:choose>
+                  <xsl:when test="(count($ndCur/*) - 1) &gt; $cMaxElmtsInRow">
+                    <xsl:value-of select="count($ndCur/*) - 1" />
+                  </xsl:when>
+                  <xsl:otherwise>
+                    <xsl:value-of select="$cMaxElmtsInRow" />
+                  </xsl:otherwise>
+                </xsl:choose>
+              </xsl:when>
+              <xsl:when test="local-name($ndCur) = 'mtr' and 
+								            namespace-uri($ndCur) = 'http://www.w3.org/1998/Math/MathML'">
+                <xsl:choose>
+                  <xsl:when test="count($ndCur/*) &gt; $cMaxElmtsInRow">
+                    <xsl:value-of select="count($ndCur/*)" />
+                  </xsl:when>
+                  <xsl:otherwise>
+                    <xsl:value-of select="$cMaxElmtsInRow" />
+                  </xsl:otherwise>
+                </xsl:choose>
+              </xsl:when>
+              <xsl:otherwise>
+                <xsl:choose>
+                  <xsl:when test="1 &gt; $cMaxElmtsInRow">
+                    <xsl:value-of select="1" />
+                  </xsl:when>
+                  <xsl:otherwise>
+                    <xsl:value-of select="$cMaxElmtsInRow" />
+                  </xsl:otherwise>
+                </xsl:choose>
+              </xsl:otherwise>
+            </xsl:choose>
+          </xsl:with-param>
+        </xsl:call-template>
+      </xsl:otherwise>
+    </xsl:choose>
+  </xsl:template>
+
+  <xsl:template name="GetMglyphAltText">
+    <xsl:param name="ndCur" select="." />
+    <xsl:choose>
+      <xsl:when test="$ndCur/@alt">
+        <xsl:value-of select="normalize-space($ndCur/@alt)"/>
+      </xsl:when>
+      <xsl:otherwise>
+        <xsl:value-of select="normalize-space($ndCur/@mml:alt)"/>
+      </xsl:otherwise>
+    </xsl:choose>
+  </xsl:template>
+
+  <xsl:template match="mml:mglyph">
+    <xsl:element name="m:r">
+      <xsl:element name="m:rPr">
+        <xsl:element name="m:nor" />
+      </xsl:element>
+      <xsl:element name="m:t">
+        <xsl:call-template name="OutputText">
+          <xsl:with-param name="sInput">
+            <xsl:call-template name="GetMglyphAltText">
+              <xsl:with-param name="ndCur" select="." />
+            </xsl:call-template>
+          </xsl:with-param>
+        </xsl:call-template>
+      </xsl:element>
+    </xsl:element>
+  </xsl:template>
+
+  <!-- Omml doesn't really support mglyph, so just output the alt text -->
+  <xsl:template match="mml:mi[child::mml:mglyph] | 
+	                     mml:mn[child::mml:mglyph] | 
+	                     mml:mo[child::mml:mglyph] | 
+	                     mml:ms[child::mml:mglyph] | 
+	                     mml:mtext[child::mml:mglyph]">
+    <xsl:variable name="mathvariant">
+      <xsl:choose>
+        <xsl:when test="@mathvariant">
+          <xsl:value-of select="@mathvariant"/>
+        </xsl:when>
+        <xsl:otherwise>
+          <xsl:value-of select="@mml:mathvariant"/>
+        </xsl:otherwise>
+      </xsl:choose>
+    </xsl:variable>
+    <xsl:variable name="fontstyle">
+      <xsl:choose>
+        <xsl:when test="@fontstyle">
+          <xsl:value-of select="@fontstyle"/>
+        </xsl:when>
+        <xsl:otherwise>
+          <xsl:value-of select="@mml:fontstyle"/>
+        </xsl:otherwise>
+      </xsl:choose>
+    </xsl:variable>
+    <xsl:variable name="fontweight">
+      <xsl:choose>
+        <xsl:when test="@fontweight">
+          <xsl:value-of select="@fontweight"/>
+        </xsl:when>
+        <xsl:otherwise>
+          <xsl:value-of select="@mml:fontweight"/>
+        </xsl:otherwise>
+      </xsl:choose>
+    </xsl:variable>
+    <xsl:variable name="mathcolor">
+      <xsl:choose>
+        <xsl:when test="@mathcolor">
+          <xsl:value-of select="@mathcolor"/>
+        </xsl:when>
+        <xsl:otherwise>
+          <xsl:value-of select="@mml:mathcolor"/>
+        </xsl:otherwise>
+      </xsl:choose>
+    </xsl:variable>
+    <xsl:variable name="mathsize">
+      <xsl:choose>
+        <xsl:when test="@mathsize">
+          <xsl:value-of select="@mathsize"/>
+        </xsl:when>
+        <xsl:otherwise>
+          <xsl:value-of select="@mml:mathsize"/>
+        </xsl:otherwise>
+      </xsl:choose>
+    </xsl:variable>
+    <xsl:variable name="color">
+      <xsl:choose>
+        <xsl:when test="@color">
+          <xsl:value-of select="@color"/>
+        </xsl:when>
+        <xsl:otherwise>
+          <xsl:value-of select="@mml:color"/>
+        </xsl:otherwise>
+      </xsl:choose>
+    </xsl:variable>
+    <xsl:variable name="fontsize">
+      <xsl:choose>
+        <xsl:when test="@fontsize">
+          <xsl:value-of select="@fontsize"/>
+        </xsl:when>
+        <xsl:otherwise>
+          <xsl:value-of select="@mml:fontsize"/>
+        </xsl:otherwise>
+      </xsl:choose>
+    </xsl:variable>
+    <xsl:variable name="fNor">
+      <xsl:call-template name="FNor">
+        <xsl:with-param name="ndCur" select="." />
+      </xsl:call-template>
+    </xsl:variable>
+
+    <!-- Output MS Left Quote (if need be) -->
+    <xsl:if test="self::mml:ms">
+      <xsl:variable name="chLquote">
+        <xsl:call-template name="LQuoteFromMs">
+          <xsl:with-param name="curMs" select="." />
+        </xsl:call-template>
+      </xsl:variable>
+      <xsl:element name="m:r">
+        <xsl:call-template name="CreateRunProp">
+          <xsl:with-param name="mathvariant" select="$mathvariant" />
+          <xsl:with-param name="fontstyle" select="$fontstyle" />
+          <xsl:with-param name="fontweight" select="$fontweight" />
+          <xsl:with-param name="mathcolor" select="$mathcolor" />
+          <xsl:with-param name="mathsize" select="$mathsize" />
+          <xsl:with-param name="color" select="$color" />
+          <xsl:with-param name="fontsize" select="$fontsize" />
+          <xsl:with-param name="fNor" select="$fNor" />
+          <xsl:with-param name="ndCur" select="." />
+        </xsl:call-template>
+        <xsl:element name="m:t">
+          <xsl:call-template name="OutputText">
+            <xsl:with-param name="sInput" select="$chLquote"/>
+          </xsl:call-template>
+        </xsl:element>
+      </xsl:element>
+    </xsl:if>
+    <xsl:for-each select="mml:mglyph | text()">
+      <xsl:variable name="fForceNor">
+        <xsl:choose>
+          <xsl:when test="self::mml:mglyph">1</xsl:when>
+          <xsl:otherwise>0</xsl:otherwise>
+        </xsl:choose>
+      </xsl:variable>
+
+      <xsl:variable name="str">
+        <xsl:choose>
+          <xsl:when test="self::mml:mglyph">
+            <xsl:call-template name="GetMglyphAltText">
+              <xsl:with-param name="ndCur" select="." />
+            </xsl:call-template>
+          </xsl:when>
+          <xsl:otherwise>
+            <xsl:value-of select="normalize-space(.)"/>
+          </xsl:otherwise>
+        </xsl:choose>
+      </xsl:variable>
+      <xsl:if test="string-length($str) &gt; 0">
+        <xsl:element name="m:r">
+          <xsl:call-template name="CreateRunProp">
+            <xsl:with-param name="mathvariant" select="$mathvariant" />
+            <xsl:with-param name="fontstyle" select="$fontstyle" />
+            <xsl:with-param name="fontweight" select="$fontweight" />
+            <xsl:with-param name="mathcolor" select="$mathcolor" />
+            <xsl:with-param name="mathsize" select="$mathsize" />
+            <xsl:with-param name="color" select="$color" />
+            <xsl:with-param name="fontsize" select="$fontsize" />
+            <xsl:with-param name="fNor">
+              <xsl:choose>
+                <xsl:when test="$fForceNor=1">1</xsl:when>
+                <xsl:otherwise>
+                  <xsl:value-of select="$fNor"/>
+                </xsl:otherwise>
+              </xsl:choose>
+            </xsl:with-param>
+            <xsl:with-param name="ndCur" select="." />
+          </xsl:call-template>
+          <xsl:element name="m:t">
+            <xsl:call-template name="OutputText">
+              <xsl:with-param name="sInput" select="$str"/>
+            </xsl:call-template>
+          </xsl:element>
+        </xsl:element>
+      </xsl:if>
+    </xsl:for-each>
+
+    <!-- Output MS Right Quote (if need be) -->
+    <xsl:if test="self::mml:ms">
+      <xsl:variable name="chRquote">
+        <xsl:call-template name="RQuoteFromMs">
+          <xsl:with-param name="curMs" select="." />
+        </xsl:call-template>
+      </xsl:variable>
+      <xsl:element name="m:r">
+        <xsl:call-template name="CreateRunProp">
+          <xsl:with-param name="mathvariant" select="$mathvariant" />
+          <xsl:with-param name="fontstyle" select="$fontstyle" />
+          <xsl:with-param name="fontweight" select="$fontweight" />
+          <xsl:with-param name="mathcolor" select="$mathcolor" />
+          <xsl:with-param name="mathsize" select="$mathsize" />
+          <xsl:with-param name="color" select="$color" />
+          <xsl:with-param name="fontsize" select="$fontsize" />
+          <xsl:with-param name="fNor" select="$fNor" />
+          <xsl:with-param name="ndCur" select="." />
+        </xsl:call-template>
+        <xsl:element name="m:t">
+          <xsl:call-template name="OutputText">
+            <xsl:with-param name="sInput" select="$chRquote"/>
+          </xsl:call-template>
+        </xsl:element>
+      </xsl:element>
+    </xsl:if>
+  </xsl:template>
+
+  <xsl:template name="FStrContainsNonZeroDigit">
+    <xsl:param name="s" />
+
+    <!-- Translate any nonzero digit into a 9 -->
+    <xsl:variable name="sNonZeroDigitsToNineDigit" select="translate($s, '12345678', '99999999')" />
+    <xsl:choose>
+      <!-- Search for 9s -->
+      <xsl:when test="contains($sNonZeroDigitsToNineDigit, '9')">1</xsl:when>
+      <xsl:otherwise>0</xsl:otherwise>
+    </xsl:choose>
+  </xsl:template>
+
+  <xsl:template name="FStrContainsDigits">
+    <xsl:param name="s" />
+
+    <!-- Translate any digit into a 0 -->
+    <xsl:variable name="sDigitsToZeroDigit" select="translate($s, '123456789', '000000000')" />
+    <xsl:choose>
+      <!-- Search for 0s -->
+      <xsl:when test="contains($sDigitsToZeroDigit, '0')">1</xsl:when>
+      <xsl:otherwise>0</xsl:otherwise>
+    </xsl:choose>
+  </xsl:template>
+
+
+  <!-- Used to determine if mpadded attribute {width, height, depth } 
+       indicates to show everything. 
+       
+       Unlike mathml, whose mpadded structure has great flexibility in modifying the 
+       bounding box's width, height, and depth, Word can only have zero or full width, height, and depth.
+       Thus, if the width, height, or depth attributes indicate any kind of nonzero width, height, 
+       or depth, we'll translate that into a show full width, height, or depth for OMML.  Only if the attribute
+       indicates a zero width, height, or depth, will we report back FFull as false.
+       
+       Example:  s=0%    ->  FFull returns 0.
+                 s=2%    ->  FFull returns 1.
+                 s=0.1em ->  FFull returns 1.     
+       
+       -->
+  <xsl:template name="FFull">
+    <xsl:param name="s" />
+
+    <xsl:variable name="fStrContainsNonZeroDigit">
+      <xsl:call-template name="FStrContainsNonZeroDigit">
+        <xsl:with-param name="s" select="$s" />
+      </xsl:call-template>
+    </xsl:variable>
+
+    <xsl:variable name="fStrContainsDigits">
+      <xsl:call-template name="FStrContainsDigits">
+        <xsl:with-param name="s" select="$s" />
+      </xsl:call-template>
+    </xsl:variable>
+
+    <xsl:choose>
+      <!-- String contained non-zero digit -->
+      <xsl:when test="$fStrContainsNonZeroDigit=1">1</xsl:when>
+      <!-- String didn't contain a non-zero digit, but it did contain digits.
+           This must mean that all digits in the string were 0s. -->
+      <xsl:when test="$fStrContainsDigits=1">0</xsl:when>
+      <!-- Else, no digits, therefore, return true.
+           We return true in the otherwise condition to take account for the possibility
+           in MathML to say something like width="height". -->
+      <xsl:otherwise>1</xsl:otherwise>
+    </xsl:choose>
+  </xsl:template>
+
+
+  <!-- Just outputs phant properties, doesn't do any fancy 
+       thinking of its own, just obeys the defaults of 
+       phants. -->
+  <xsl:template name="CreatePhantPropertiesCore">
+    <xsl:param name="fShow" select="1" />
+    <xsl:param name="fFullWidth" select="1" />
+    <xsl:param name="fFullHeight" select="1" />
+    <xsl:param name="fFullDepth" select="1" />
+
+    <xsl:if test="$fShow=0 
+                    or $fFullWidth=0 
+                    or $fFullHeight=0
+                    or $fFullDepth=0">
+      <xsl:element name="m:phantPr">
+        <xsl:if test="$fShow=0">
+          <xsl:element name="m:show">
+            <xsl:attribute name="m:val">off</xsl:attribute>
+          </xsl:element>
+        </xsl:if>
+        <xsl:if test="$fFullWidth=0">
+          <xsl:element name="m:zeroWid">
+            <xsl:attribute name="m:val">on</xsl:attribute>
+          </xsl:element>
+        </xsl:if>
+        <xsl:if test="$fFullHeight=0">
+          <xsl:element name="m:zeroAsc">
+            <xsl:attribute name="m:val">on</xsl:attribute>
+          </xsl:element>
+        </xsl:if>
+        <xsl:if test="$fFullDepth=0">
+          <xsl:element name="m:zeroDesc">
+            <xsl:attribute name="m:val">on</xsl:attribute>
+          </xsl:element>
+        </xsl:if>
+      </xsl:element>
+    </xsl:if>
+  </xsl:template>
+
+  <!-- Figures out if we should factor in width, height, and depth attributes.  
+  
+       If so, then it 
+       gets these attributes, does some processing to figure out what the attributes indicate, 
+       then passes these indications to CreatePhantPropertiesCore.  
+       
+       If we aren't supposed to factor in width, height, or depth, then we'll just output the show
+       attribute. -->
+  <xsl:template name="CreatePhantProperties">
+    <xsl:param name="ndCur" select="." />
+    <xsl:param name="fShow" select="1"/>
+
+    <xsl:choose>
+      <!-- In the special case that we have an mphantom with one child which is an mpadded, then we should 
+           subsume the mpadded attributes into the mphantom attributes.  The test statement below imples the 
+           'one child which is an mpadded'.  The first part, that the parent of mpadded is an mphantom, is implied
+           by being in this template, which is only called when we've encountered an mphantom.
+           
+           Word outputs its invisible phantoms with smashing as 
+
+              <mml:mphantom>
+                <mml:mpadded . . . >
+                  
+                </mml:mpadded>
+              </mml:mphantom>
+
+            This test is used to allow roundtripping smashed invisible phantoms. -->
+      <xsl:when test="count($ndCur/child::*)=1 and count($ndCur/mml:mpadded)=1">
+        <xsl:variable name="sLowerCaseWidth">
+          <xsl:choose>
+            <xsl:when test="$ndCur/mml:mpadded/@width">
+              <xsl:value-of select="translate($ndCur/mml:mpadded/@width, $StrUCAlphabet, $StrLCAlphabet)"/>
+            </xsl:when>
+            <xsl:otherwise>
+              <xsl:value-of select="translate($ndCur/mml:mpadded/@mml:width, $StrUCAlphabet, $StrLCAlphabet)"/>
+            </xsl:otherwise>
+          </xsl:choose>
+        </xsl:variable>
+        <xsl:variable name="sLowerCaseHeight">
+          <xsl:choose>
+            <xsl:when test="$ndCur/mml:mpadded/@height">
+              <xsl:value-of select="translate($ndCur/mml:mpadded/@height, $StrUCAlphabet, $StrLCAlphabet)"/>
+            </xsl:when>
+            <xsl:otherwise>
+              <xsl:value-of select="translate($ndCur/mml:mpadded/@mml:height, $StrUCAlphabet, $StrLCAlphabet)"/>
+            </xsl:otherwise>
+          </xsl:choose>
+        </xsl:variable>
+        <xsl:variable name="sLowerCaseDepth">
+          <xsl:choose>
+            <xsl:when test="$ndCur/mml:mpadded/@depth">
+              <xsl:value-of select="translate($ndCur/mml:mpadded/@depth, $StrUCAlphabet, $StrLCAlphabet)"/>
+            </xsl:when>
+            <xsl:otherwise>
+              <xsl:value-of select="translate($ndCur/mml:mpadded/@mml:depth, $StrUCAlphabet, $StrLCAlphabet)"/>
+            </xsl:otherwise>
+          </xsl:choose>
+        </xsl:variable>
+
+        <xsl:variable name="fFullWidth">
+          <xsl:call-template name="FFull">
+            <xsl:with-param name="s" select="$sLowerCaseWidth" />
+          </xsl:call-template>
+        </xsl:variable>
+        <xsl:variable name="fFullHeight">
+          <xsl:call-template name="FFull">
+            <xsl:with-param name="s" select="$sLowerCaseHeight" />
+          </xsl:call-template>
+        </xsl:variable>
+        <xsl:variable name="fFullDepth">
+          <xsl:call-template name="FFull">
+            <xsl:with-param name="s" select="$sLowerCaseDepth" />
+          </xsl:call-template>
+        </xsl:variable>
+
+        <xsl:call-template name="CreatePhantPropertiesCore">
+          <xsl:with-param name="fShow" select="$fShow"/>
+          <xsl:with-param name="fFullWidth" select="$fFullWidth" />
+          <xsl:with-param name="fFullHeight" select="$fFullHeight" />
+          <xsl:with-param name="fFullDepth" select="$fFullDepth" />
+        </xsl:call-template>
+      </xsl:when>
+      <xsl:otherwise>
+        <xsl:call-template name="CreatePhantPropertiesCore">
+          <xsl:with-param name="fShow" select="$fShow"/>
+        </xsl:call-template>
+      </xsl:otherwise>
+    </xsl:choose>
+  </xsl:template>
+
+  <xsl:template match="mml:mpadded">
+    <xsl:choose>
+      <xsl:when test="count(parent::mml:mphantom)=1 and count(preceding-sibling::*)=0 and count(following-sibling::*)=0">
+        <!-- This mpadded is inside an mphantom that has already setup phantom attributes, therefore, just apply templates -->
+        <xsl:apply-templates select="*" />
+      </xsl:when>
+      <xsl:otherwise>
+        <xsl:variable name="sLowerCaseWidth">
+          <xsl:choose>
+            <xsl:when test="@width">
+              <xsl:value-of select="@width"/>
+            </xsl:when>
+            <xsl:otherwise>
+              <xsl:value-of select="@mml:width"/>
+            </xsl:otherwise>
+          </xsl:choose>
+        </xsl:variable>
+        <xsl:variable name="sLowerCaseHeight">
+          <xsl:choose>
+            <xsl:when test="@height">
+              <xsl:value-of select="@height"/>
+            </xsl:when>
+            <xsl:otherwise>
+              <xsl:value-of select="@mml:height"/>
+            </xsl:otherwise>
+          </xsl:choose>
+        </xsl:variable>
+        <xsl:variable name="sLowerCaseDepth">
+          <xsl:choose>
+            <xsl:when test="@depth">
+              <xsl:value-of select="@depth"/>
+            </xsl:when>
+            <xsl:otherwise>
+              <xsl:value-of select="@mml:depth"/>
+            </xsl:otherwise>
+          </xsl:choose>
+        </xsl:variable>
+
+        <xsl:variable name="fFullWidth">
+          <xsl:call-template name="FFull">
+            <xsl:with-param name="s" select="$sLowerCaseWidth" />
+          </xsl:call-template>
+        </xsl:variable>
+        <xsl:variable name="fFullHeight">
+          <xsl:call-template name="FFull">
+            <xsl:with-param name="s" select="$sLowerCaseHeight" />
+          </xsl:call-template>
+        </xsl:variable>
+        <xsl:variable name="fFullDepth">
+          <xsl:call-template name="FFull">
+            <xsl:with-param name="s" select="$sLowerCaseDepth" />
+          </xsl:call-template>
+        </xsl:variable>
+
+        <xsl:element name="m:phant">
+          <xsl:call-template name="CreatePhantPropertiesCore">
+            <xsl:with-param name="fShow" select="1"/>
+            <xsl:with-param name="fFullWidth" select="$fFullWidth" />
+            <xsl:with-param name="fFullHeight" select="$fFullHeight" />
+            <xsl:with-param name="fFullDepth" select="$fFullDepth" />
+          </xsl:call-template>
+          <m:e>
+            <xsl:apply-templates select="*" />
+          </m:e>
+        </xsl:element>
+      </xsl:otherwise>
+    </xsl:choose>
+  </xsl:template>
+
+  <xsl:template match="mml:mphantom">
+    <xsl:element name="m:phant">
+      <xsl:call-template name="CreatePhantProperties">
+        <xsl:with-param name="ndCur" select="." />
+        <xsl:with-param name="fShow" select="0" />
+      </xsl:call-template>
+      <m:e>
+        <xsl:apply-templates select="*" />
+      </m:e>
+    </xsl:element>
+  </xsl:template>
+
+  <xsl:template name="isNaryOper">
+    <xsl:param name="sNdCur" />
+    <xsl:value-of select="($sNdCur = '&#x222B;' 
+                            or $sNdCur = '&#x222C;' 
+                            or $sNdCur = '&#x222D;' 
+                            or $sNdCur = '&#x222E;' 
+                            or $sNdCur = '&#x222F;' 
+                            or $sNdCur = '&#x2230;' 
+                            or $sNdCur = '&#x2232;' 
+                            or $sNdCur = '&#x2233;' 
+                            or $sNdCur = '&#x2231;' 
+                            or $sNdCur = '&#x2229;' 
+                            or $sNdCur = '&#x222A;' 
+                            or $sNdCur = '&#x220F;' 
+                            or $sNdCur = '&#x2210;' 
+                            or $sNdCur = '&#x2211;' 
+                            or $sNdCur = '&#x22C0;' 
+                            or $sNdCur = '&#x22C1;' 
+                            or $sNdCur = '&#x22C2;' 
+                            or $sNdCur = '&#x22C3;')" />
+  </xsl:template>
+
+
+  <xsl:template name="isNary">
+    <!-- ndCur is the element around the nAry operator -->
+    <xsl:param name="ndCur" />
+    <xsl:variable name="sNdCur">
+      <xsl:value-of select="normalize-space($ndCur)" />
+    </xsl:variable>
+
+    <xsl:variable name="fNaryOper">
+      <xsl:call-template name="isNaryOper">
+        <xsl:with-param name="sNdCur" select="$sNdCur" />
+      </xsl:call-template>
+    </xsl:variable>
+
+    <!-- Narys shouldn't be MathML accents.  -->
+    <xsl:variable name="fUnder">
+      <xsl:choose>
+        <xsl:when test="$ndCur/parent::*[self::mml:munder]">1</xsl:when>
+        <xsl:otherwise>0</xsl:otherwise>
+      </xsl:choose>
+    </xsl:variable>
+
+    <xsl:variable name="sLowerCaseAccent">
+      <xsl:choose>
+        <xsl:when test="$fUnder=1">
+          <xsl:choose>
+            <xsl:when test="$ndCur/parent::*[self::mml:munder]/@accentunder">
+              <xsl:value-of select="translate($ndCur/parent::*[self::mml:munder]/@accentunder, $StrUCAlphabet, $StrLCAlphabet)"/>
+            </xsl:when>
+            <xsl:otherwise>
+              <xsl:value-of select="translate($ndCur/parent::*[self::mml:munder]/@mml:accentunder, $StrUCAlphabet, $StrLCAlphabet)"/>
+            </xsl:otherwise>
+          </xsl:choose>
+        </xsl:when>
+        <xsl:otherwise>
+          <xsl:choose>
+            <xsl:when test="$ndCur/parent::*/@accent">
+              <xsl:value-of select="translate($ndCur/parent::*/@accent, $StrUCAlphabet, $StrLCAlphabet)"/>
+            </xsl:when>
+            <xsl:otherwise>
+              <xsl:value-of select="translate($ndCur/parent::*/@mml:accent, $StrUCAlphabet, $StrLCAlphabet)"/>
+            </xsl:otherwise>
+          </xsl:choose>
+        </xsl:otherwise>
+      </xsl:choose>
+    </xsl:variable>
+
+    <xsl:variable name="fAccent">
+      <xsl:choose>
+        <xsl:when test="$sLowerCaseAccent='true'">1</xsl:when>
+        <xsl:otherwise>0</xsl:otherwise>
+      </xsl:choose>
+    </xsl:variable>
+
+    <xsl:choose>
+      <!-- This ndCur is in fact part of an nAry if
+      
+           1)  The last descendant of ndCur (which could be ndCur itself) is an operator.
+           2)  Along that chain of descendants we only encounter mml:mo, mml:mstyle, and mml:mrow elements.
+           3)  the operator in mml:mo is a valid nAry operator
+           4)  The nAry is not accented.
+           -->
+      <xsl:when test="$fNaryOper = 'true'
+                      and $fAccent=0
+                      and $ndCur/descendant-or-self::*[last()]/self::mml:mo
+                      and not($ndCur/descendant-or-self::*[not(self::mml:mo or 
+			                                                     self::mml:mstyle or 
+			                                                     self::mml:mrow)])">
+        <xsl:value-of select="true()" />
+      </xsl:when>
+      <xsl:otherwise>
+        <xsl:value-of select="false()" />
+      </xsl:otherwise>
+    </xsl:choose>
+  </xsl:template>
+
+  <xsl:template name="CreateNaryProp">
+    <xsl:param name="chr" />
+    <xsl:param name="sMathmlType" />
+    <xsl:param name="sGrow">
+      <xsl:choose>
+        <xsl:when test="child::*[1]/@stretchy">
+          <xsl:value-of select="translate(child::*[1]/@stretchy, $StrUCAlphabet, $StrLCAlphabet)"/>
+        </xsl:when>
+        <xsl:otherwise>
+          <xsl:value-of select="translate(child::*[1]/@mml:stretchy, $StrUCAlphabet, $StrLCAlphabet)"/>
+        </xsl:otherwise>
+      </xsl:choose>
+    </xsl:param>
+    <m:naryPr>
+      <m:chr>
+        <xsl:attribute name="m:val">
+          <xsl:value-of select="$chr" />
+        </xsl:attribute>
+      </m:chr>
+      <m:limLoc>
+        <xsl:attribute name="m:val">
+          <xsl:choose>
+            <xsl:when test="$sMathmlType='munder' or 
+									$sMathmlType='mover' or 
+									$sMathmlType='munderover'">
+              <xsl:text>undOvr</xsl:text>
+            </xsl:when>
+            <xsl:when test="$sMathmlType='msub' or
+					                $sMathmlType='msup' or
+					                $sMathmlType='msubsup'">
+              <xsl:text>subSup</xsl:text>
+            </xsl:when>
+          </xsl:choose>
+        </xsl:attribute>
+      </m:limLoc>
+      <m:grow>
+        <xsl:attribute name="m:val">
+          <xsl:choose>
+            <xsl:when test="$sGrow='true'">1</xsl:when>
+            <xsl:when test="$sGrow='false'">0</xsl:when>
+            <xsl:when test="$chr='&#x222B;' 
+                            or $chr='&#x222E;' 
+                            or $chr='&#x222F;' 
+                            or $chr='&#x2232;' 
+                            or $chr='&#x2233;'
+                            or $chr='&#x2229;'
+                            or $chr='&#x222A;' 
+                            or $chr='&#x220F;' 
+                            or $chr='&#x2211;' 
+                            or $chr='&#x22C0;'
+                            or $chr='&#x22C1;' 
+                            or $chr='&#x22C2;'
+                            or $chr='&#x22C3;'">1</xsl:when>
+            <xsl:otherwise>0</xsl:otherwise>
+          </xsl:choose>
+        </xsl:attribute>
+      </m:grow>
+      <m:subHide>
+        <xsl:attribute name="m:val">
+          <xsl:choose>
+            <xsl:when test="$sMathmlType='mover' or
+						                $sMathmlType='msup'">
+              <xsl:text>on</xsl:text>
+            </xsl:when>
+            <xsl:otherwise>
+              <xsl:text>off</xsl:text>
+            </xsl:otherwise>
+          </xsl:choose>
+        </xsl:attribute>
+      </m:subHide>
+      <m:supHide>
+        <xsl:attribute name="m:val">
+          <xsl:choose>
+            <xsl:when test="$sMathmlType='munder' or
+						                $sMathmlType='msub'">
+              <xsl:text>on</xsl:text>
+            </xsl:when>
+            <xsl:otherwise>
+              <xsl:text>off</xsl:text>
+            </xsl:otherwise>
+          </xsl:choose>
+        </xsl:attribute>
+      </m:supHide>
+    </m:naryPr>
+  </xsl:template>
+</xsl:stylesheet>
\ No newline at end of file
diff --git a/ruoyi-api/src/main/resources/OMML2MML.XSL b/ruoyi-api/src/main/resources/OMML2MML.XSL
new file mode 100644
index 0000000..509a76f
--- /dev/null
+++ b/ruoyi-api/src/main/resources/OMML2MML.XSL
@@ -0,0 +1,2076 @@
+<?xml version="1.0" encoding="UTF-8" ?>
+<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform" xmlns:mml="http://www.w3.org/1998/Math/MathML"
+	xmlns:m="http://schemas.openxmlformats.org/officeDocument/2006/math">
+  <xsl:output method="xml" encoding="UTF-16" />
+
+  <!-- %% Global Definitions -->
+
+  <!-- Every single unicode character that is recognized by OMML as an operator -->
+  <xsl:variable name="sOperators"
+		select="concat(
+          '&#x00A8;&#x0021;&#x0022;&#x0023;&#x0026;&#x0028;&#x0029;&#x002B;&#x002C;&#x002D;&#x002E;&#x002F;&#x003A;',
+          '&#x003B;&#x003C;&#x003D;&#x003E;&#x003F;&#x0040;&#x005B;&#x005C;&#x005D;&#x005E;&#x005F;&#x0060;&#x007B;',
+          '&#x007C;&#x007D;&#x007E;&#x00A1;&#x00A6;&#x00AC;&#x00AF;&#x00B0;&#x00B1;&#x00B2;&#x00B3;&#x00B4;&#x00B7;&#x00B9;&#x00BF;',
+          '&#x00D7;&#x007E;&#x00F7;&#x02C7;&#x02D8;&#x02D9;&#x02DC;&#x02DD;&#x0300;&#x0301;&#x0302;&#x0303;&#x0304;&#x0305;&#x0306;&#x0307;&#x0308;&#x0309;',
+          '&#x030A;&#x030B;&#x030C;&#x030D;&#x030E;&#x030F;&#x0310;&#x0311;&#x0312;&#x0313;&#x0314;&#x0315;',
+          '&#x0316;&#x0317;&#x0318;&#x0319;&#x031A;&#x031B;&#x031C;&#x031D;&#x031E;&#x031F;&#x0320;&#x0321;',
+          '&#x0322;&#x0323;&#x0324;&#x0325;&#x0326;&#x0327;&#x0328;&#x0329;&#x032A;&#x032B;&#x032C;&#x032D;',
+          '&#x032E;&#x032F;&#x0330;&#x0331;&#x0332;&#x0333;&#x0334;&#x0335;&#x0336;&#x0337;&#x0338;&#x033F;',
+          '&#x2000;&#x2001;&#x2002;&#x2003;&#x2004;&#x2005;&#x2006;&#x2009;&#x200A;&#x2010;&#x2012;&#x2013;',
+          '&#x2014;&#x2016;&#x2020;&#x2021;&#x2022;&#x2024;&#x2025;&#x2026;&#x2032;&#x2033;&#x2034;&#x203C;',
+          '&#x2040;&#x2044;&#x204E;&#x204F;&#x2050;&#x2057;&#x2061;&#x2062;&#x2063;&#x2070;&#x2074;&#x2075;',
+          '&#x2076;&#x2077;&#x2078;&#x2079;&#x207A;&#x207B;&#x207C;&#x207D;&#x207E;&#x2080;&#x2081;&#x2082;',
+          '&#x2083;&#x2084;&#x2085;&#x2086;&#x2087;&#x2088;&#x2089;&#x208A;&#x208B;&#x208C;&#x208D;&#x208E;',
+          '&#x20D0;&#x20D1;&#x20D2;&#x20D3;&#x20D4;&#x20D5;&#x20D6;&#x20D7;&#x20D8;&#x20D9;&#x20DA;&#x20DB;',
+          '&#x20DC;&#x20DD;&#x20DE;&#x20DF;&#x20E0;&#x20E1;&#x20E4;&#x20E5;&#x20E6;&#x20E7;&#x20E8;&#x20E9;',
+          '&#x20EA;&#x2140;&#x2146;&#x2190;&#x2191;&#x2192;&#x2193;&#x2194;&#x2195;&#x2196;&#x2197;&#x2198;&#x2199;',
+          '&#x219A;&#x219B;&#x219C;&#x219D;&#x219E;&#x219F;&#x21A0;&#x21A1;&#x21A2;&#x21A3;&#x21A4;&#x21A5;',
+          '&#x21A6;&#x21A7;&#x21A8;&#x21A9;&#x21AA;&#x21AB;&#x21AC;&#x21AD;&#x21AE;&#x21AF;&#x21B0;&#x21B1;',
+          '&#x21B2;&#x21B3;&#x21B6;&#x21B7;&#x21BA;&#x21BB;&#x21BC;&#x21BD;&#x21BE;&#x21BF;&#x21C0;&#x21C1;',
+          '&#x21C2;&#x21C3;&#x21C4;&#x21C5;&#x21C6;&#x21C7;&#x21C8;&#x21C9;&#x21CA;&#x21CB;&#x21CC;&#x21CD;',
+          '&#x21CE;&#x21CF;&#x21D0;&#x21D1;&#x21D2;&#x21D3;&#x21D4;&#x21D5;&#x21D6;&#x21D7;&#x21D8;&#x21D9;',
+          '&#x21DA;&#x21DB;&#x21DC;&#x21DD;&#x21DE;&#x21DF;&#x21E0;&#x21E1;&#x21E2;&#x21E3;&#x21E4;&#x21E5;',
+          '&#x21E6;&#x21E7;&#x21E8;&#x21E9;&#x21F3;&#x21F4;&#x21F5;&#x21F6;&#x21F7;&#x21F8;&#x21F9;&#x21FA;',
+          '&#x21FB;&#x21FC;&#x21FD;&#x21FE;&#x21FF;&#x2200;&#x2201;&#x2202;&#x2203;&#x2204;&#x2206;&#x2207;',
+          '&#x2208;&#x2209;&#x220A;&#x220B;&#x220C;&#x220D;&#x220F;&#x2210;&#x2211;&#x2212;&#x2213;&#x2214;',
+          '&#x2215;&#x2216;&#x2217;&#x2218;&#x2219;&#x221A;&#x221B;&#x221C;&#x221D;&#x2223;&#x2224;&#x2225;',
+          '&#x2226;&#x2227;&#x2228;&#x2229;&#x222A;&#x222B;&#x222C;&#x222D;&#x222E;&#x222F;&#x2230;&#x2231;',
+          '&#x2232;&#x2233;&#x2234;&#x2235;&#x2236;&#x2237;&#x2238;&#x2239;&#x223A;&#x223B;&#x223C;&#x223D;',
+          '&#x223E;&#x2240;&#x2241;&#x2242;&#x2243;&#x2244;&#x2245;&#x2246;&#x2247;&#x2248;&#x2249;&#x224A;',
+          '&#x224B;&#x224C;&#x224D;&#x224E;&#x224F;&#x2250;&#x2251;&#x2252;&#x2253;&#x2254;&#x2255;&#x2256;',
+          '&#x2257;&#x2258;&#x2259;&#x225A;&#x225B;&#x225C;&#x225D;&#x225E;&#x225F;&#x2260;&#x2261;&#x2262;',
+          '&#x2263;&#x2264;&#x2265;&#x2266;&#x2267;&#x2268;&#x2269;&#x226A;&#x226B;&#x226C;&#x226D;&#x226E;',
+          '&#x226F;&#x2270;&#x2271;&#x2272;&#x2273;&#x2274;&#x2275;&#x2276;&#x2277;&#x2278;&#x2279;&#x227A;',
+          '&#x227B;&#x227C;&#x227D;&#x227E;&#x227F;&#x2280;&#x2281;&#x2282;&#x2283;&#x2284;&#x2285;&#x2286;',
+          '&#x2287;&#x2288;&#x2289;&#x228A;&#x228B;&#x228C;&#x228D;&#x228E;&#x228F;&#x2290;&#x2291;&#x2292;',
+          '&#x2293;&#x2294;&#x2295;&#x2296;&#x2297;&#x2298;&#x2299;&#x229A;&#x229B;&#x229C;&#x229D;&#x229E;',
+          '&#x229F;&#x22A0;&#x22A1;&#x22A2;&#x22A3;&#x22A5;&#x22A6;&#x22A7;&#x22A8;&#x22A9;&#x22AA;&#x22AB;',
+          '&#x22AC;&#x22AD;&#x22AE;&#x22AF;&#x22B0;&#x22B1;&#x22B2;&#x22B3;&#x22B4;&#x22B5;&#x22B6;&#x22B7;',
+          '&#x22B8;&#x22B9;&#x22BA;&#x22BB;&#x22BC;&#x22BD;&#x22C0;&#x22C1;&#x22C2;&#x22C3;&#x22C4;&#x22C5;',
+          '&#x22C6;&#x22C7;&#x22C8;&#x22C9;&#x22CA;&#x22CB;&#x22CC;&#x22CD;&#x22CE;&#x22CF;&#x22D0;&#x22D1;',
+          '&#x22D2;&#x22D3;&#x22D4;&#x22D5;&#x22D6;&#x22D7;&#x22D8;&#x22D9;&#x22DA;&#x22DB;&#x22DC;&#x22DD;',
+          '&#x22DE;&#x22DF;&#x22E0;&#x22E1;&#x22E2;&#x22E3;&#x22E4;&#x22E5;&#x22E6;&#x22E7;&#x22E8;&#x22E9;',
+          '&#x22EA;&#x22EB;&#x22EC;&#x22ED;&#x22EE;&#x22EF;&#x22F0;&#x22F1;&#x22F2;&#x22F3;&#x22F4;&#x22F5;',
+          '&#x22F6;&#x22F7;&#x22F8;&#x22F9;&#x22FA;&#x22FB;&#x22FC;&#x22FD;&#x22FE;&#x22FF;&#x2305;&#x2306;',
+          '&#x2308;&#x2309;&#x230A;&#x230B;&#x231C;&#x231D;&#x231E;&#x231F;&#x2322;&#x2323;&#x2329;&#x232A;',
+          '&#x233D;&#x233F;&#x23B0;&#x23B1;&#x23DC;&#x23DD;&#x23DE;&#x23DF;&#x23E0;&#x2502;&#x251C;&#x2524;',
+          '&#x252C;&#x2534;&#x2581;&#x2588;&#x2592;&#x25A0;&#x25A1;&#x25AD;&#x25B2;&#x25B3;&#x25B4;&#x25B5;',
+          '&#x25B6;&#x25B7;&#x25B8;&#x25B9;&#x25BC;&#x25BD;&#x25BE;&#x25BF;&#x25C0;&#x25C1;&#x25C2;&#x25C3;',
+          '&#x25C4;&#x25C5;&#x25CA;&#x25CB;&#x25E6;&#x25EB;&#x25EC;&#x25F8;&#x25F9;&#x25FA;&#x25FB;&#x25FC;',
+          '&#x25FD;&#x25FE;&#x25FF;&#x2605;&#x2606;&#x2772;&#x2773;&#x27D1;&#x27D2;&#x27D3;&#x27D4;&#x27D5;',
+          '&#x27D6;&#x27D7;&#x27D8;&#x27D9;&#x27DA;&#x27DB;&#x27DC;&#x27DD;&#x27DE;&#x27DF;&#x27E0;&#x27E1;',
+          '&#x27E2;&#x27E3;&#x27E4;&#x27E5;&#x27E6;&#x27E7;&#x27E8;&#x27E9;&#x27EA;&#x27EB;&#x27F0;&#x27F1;',
+          '&#x27F2;&#x27F3;&#x27F4;&#x27F5;&#x27F6;&#x27F7;&#x27F8;&#x27F9;&#x27FA;&#x27FB;&#x27FC;&#x27FD;',
+          '&#x27FE;&#x27FF;&#x2900;&#x2901;&#x2902;&#x2903;&#x2904;&#x2905;&#x2906;&#x2907;&#x2908;&#x2909;',
+          '&#x290A;&#x290B;&#x290C;&#x290D;&#x290E;&#x290F;&#x2910;&#x2911;&#x2912;&#x2913;&#x2914;&#x2915;',
+          '&#x2916;&#x2917;&#x2918;&#x2919;&#x291A;&#x291B;&#x291C;&#x291D;&#x291E;&#x291F;&#x2920;&#x2921;',
+          '&#x2922;&#x2923;&#x2924;&#x2925;&#x2926;&#x2927;&#x2928;&#x2929;&#x292A;&#x292B;&#x292C;&#x292D;',
+          '&#x292E;&#x292F;&#x2930;&#x2931;&#x2932;&#x2933;&#x2934;&#x2935;&#x2936;&#x2937;&#x2938;&#x2939;',
+          '&#x293A;&#x293B;&#x293C;&#x293D;&#x293E;&#x293F;&#x2940;&#x2941;&#x2942;&#x2943;&#x2944;&#x2945;',
+          '&#x2946;&#x2947;&#x2948;&#x2949;&#x294A;&#x294B;&#x294C;&#x294D;&#x294E;&#x294F;&#x2950;&#x2951;',
+          '&#x2952;&#x2953;&#x2954;&#x2955;&#x2956;&#x2957;&#x2958;&#x2959;&#x295A;&#x295B;&#x295C;&#x295D;',
+          '&#x295E;&#x295F;&#x2960;&#x2961;&#x2962;&#x2963;&#x2964;&#x2965;&#x2966;&#x2967;&#x2968;&#x2969;',
+          '&#x296A;&#x296B;&#x296C;&#x296D;&#x296E;&#x296F;&#x2970;&#x2971;&#x2972;&#x2973;&#x2974;&#x2975;',
+          '&#x2976;&#x2977;&#x2978;&#x2979;&#x297A;&#x297B;&#x297C;&#x297D;&#x297E;&#x297F;&#x2980;&#x2982;',
+          '&#x2983;&#x2984;&#x2985;&#x2986;&#x2987;&#x2988;&#x2989;&#x298A;&#x298B;&#x298C;&#x298D;&#x298E;',
+          '&#x298F;&#x2990;&#x2991;&#x2992;&#x2993;&#x2994;&#x2995;&#x2996;&#x2997;&#x2998;&#x2999;&#x299A;',
+          '&#x29B6;&#x29B7;&#x29B8;&#x29B9;&#x29C0;&#x29C1;&#x29C4;&#x29C5;&#x29C6;&#x29C7;&#x29C8;&#x29CE;',
+          '&#x29CF;&#x29D0;&#x29D1;&#x29D2;&#x29D3;&#x29D4;&#x29D5;&#x29D6;&#x29D7;&#x29D8;&#x29D9;&#x29DA;',
+          '&#x29DB;&#x29DF;&#x29E1;&#x29E2;&#x29E3;&#x29E4;&#x29E5;&#x29E6;&#x29EB;&#x29F4;&#x29F5;&#x29F6;',
+          '&#x29F7;&#x29F8;&#x29F9;&#x29FA;&#x29FB;&#x29FC;&#x29FD;&#x29FE;&#x29FF;&#x2A00;&#x2A01;&#x2A02;',
+          '&#x2A03;&#x2A04;&#x2A05;&#x2A06;&#x2A07;&#x2A08;&#x2A09;&#x2A0A;&#x2A0B;&#x2A0C;&#x2A0D;&#x2A0E;',
+          '&#x2A0F;&#x2A10;&#x2A11;&#x2A12;&#x2A13;&#x2A14;&#x2A15;&#x2A16;&#x2A17;&#x2A18;&#x2A19;&#x2A1A;',
+          '&#x2A1B;&#x2A1C;&#x2A1D;&#x2A1E;&#x2A1F;&#x2A20;&#x2A21;&#x2A22;&#x2A23;&#x2A24;&#x2A25;&#x2A26;',
+          '&#x2A27;&#x2A28;&#x2A29;&#x2A2A;&#x2A2B;&#x2A2C;&#x2A2D;&#x2A2E;&#x2A2F;&#x2A30;&#x2A31;&#x2A32;',
+          '&#x2A33;&#x2A34;&#x2A35;&#x2A36;&#x2A37;&#x2A38;&#x2A39;&#x2A3A;&#x2A3B;&#x2A3C;&#x2A3D;&#x2A3E;',
+          '&#x2A3F;&#x2A40;&#x2A41;&#x2A42;&#x2A43;&#x2A44;&#x2A45;&#x2A46;&#x2A47;&#x2A48;&#x2A49;&#x2A4A;',
+          '&#x2A4B;&#x2A4C;&#x2A4D;&#x2A4E;&#x2A4F;&#x2A50;&#x2A51;&#x2A52;&#x2A53;&#x2A54;&#x2A55;&#x2A56;',
+          '&#x2A57;&#x2A58;&#x2A59;&#x2A5A;&#x2A5B;&#x2A5C;&#x2A5D;&#x2A5E;&#x2A5F;&#x2A60;&#x2A61;&#x2A62;',
+          '&#x2A63;&#x2A64;&#x2A65;&#x2A66;&#x2A67;&#x2A68;&#x2A69;&#x2A6A;&#x2A6B;&#x2A6C;&#x2A6D;&#x2A6E;',
+          '&#x2A6F;&#x2A70;&#x2A71;&#x2A72;&#x2A73;&#x2A74;&#x2A75;&#x2A76;&#x2A77;&#x2A78;&#x2A79;&#x2A7A;',
+          '&#x2A7B;&#x2A7C;&#x2A7D;&#x2A7E;&#x2A7F;&#x2A80;&#x2A81;&#x2A82;&#x2A83;&#x2A84;&#x2A85;&#x2A86;',
+          '&#x2A87;&#x2A88;&#x2A89;&#x2A8A;&#x2A8B;&#x2A8C;&#x2A8D;&#x2A8E;&#x2A8F;&#x2A90;&#x2A91;&#x2A92;',
+          '&#x2A93;&#x2A94;&#x2A95;&#x2A96;&#x2A97;&#x2A98;&#x2A99;&#x2A9A;&#x2A9B;&#x2A9C;&#x2A9D;&#x2A9E;',
+          '&#x2A9F;&#x2AA0;&#x2AA1;&#x2AA2;&#x2AA3;&#x2AA4;&#x2AA5;&#x2AA6;&#x2AA7;&#x2AA8;&#x2AA9;&#x2AAA;',
+          '&#x2AAB;&#x2AAC;&#x2AAD;&#x2AAE;&#x2AAF;&#x2AB0;&#x2AB1;&#x2AB2;&#x2AB3;&#x2AB4;&#x2AB5;&#x2AB6;',
+          '&#x2AB7;&#x2AB8;&#x2AB9;&#x2ABA;&#x2ABB;&#x2ABC;&#x2ABD;&#x2ABE;&#x2ABF;&#x2AC0;&#x2AC1;&#x2AC2;',
+          '&#x2AC3;&#x2AC4;&#x2AC5;&#x2AC6;&#x2AC7;&#x2AC8;&#x2AC9;&#x2ACA;&#x2ACB;&#x2ACC;&#x2ACD;&#x2ACE;',
+          '&#x2ACF;&#x2AD0;&#x2AD1;&#x2AD2;&#x2AD3;&#x2AD4;&#x2AD5;&#x2AD6;&#x2AD7;&#x2AD8;&#x2AD9;&#x2ADA;',
+          '&#x2ADB;&#x2ADC;&#x2ADD;&#x2ADE;&#x2ADF;&#x2AE0;&#x2AE2;&#x2AE3;&#x2AE4;&#x2AE5;&#x2AE6;&#x2AE7;',
+          '&#x2AE8;&#x2AE9;&#x2AEA;&#x2AEB;&#x2AEC;&#x2AED;&#x2AEE;&#x2AEF;&#x2AF0;&#x2AF2;&#x2AF3;&#x2AF4;',
+          '&#x2AF5;&#x2AF6;&#x2AF7;&#x2AF8;&#x2AF9;&#x2AFA;&#x2AFB;&#x2AFC;&#x2AFD;&#x2AFE;&#x2AFF;&#x2B04;',
+          '&#x2B06;&#x2B07;&#x2B0C;&#x2B0D;&#x3014;&#x3015;&#x3016;&#x3017;&#x3018;&#x3019;&#xFF01;&#xFF06;',
+          '&#xFF08;&#xFF09;&#xFF0B;&#xFF0C;&#xFF0D;&#xFF0E;&#xFF0F;&#xFF1A;&#xFF1B;&#xFF1C;&#xFF1D;&#xFF1E;',
+          '&#xFF1F;&#xFF20;&#xFF3B;&#xFF3C;&#xFF3D;&#xFF3E;&#xFF3F;&#xFF5B;&#xFF5C;&#xFF5D;')" />
+
+  <!-- A string of '-'s repeated exactly as many times as the operators above -->
+  <xsl:variable name="sMinuses">
+    <xsl:call-template name="SRepeatChar">
+      <xsl:with-param name="cchRequired" select="string-length($sOperators)" />
+      <xsl:with-param name="ch" select="'-'" />
+    </xsl:call-template>
+  </xsl:variable>
+
+  <!-- Every single unicode character that is recognized by OMML as a number -->
+  <xsl:variable name="sNumbers" select="'0123456789'" />
+
+  <!-- A string of '0's repeated exactly as many times as the list of numbers above -->
+  <xsl:variable name="sZeros">
+    <xsl:call-template name="SRepeatChar">
+      <xsl:with-param name="cchRequired" select="string-length($sNumbers)" />
+      <xsl:with-param name="ch" select="'0'" />
+    </xsl:call-template>
+  </xsl:variable>
+
+  <!-- %%Template: SReplace
+
+		Replace all occurences of sOrig in sInput with sReplacement
+		and return the resulting string. -->
+  <xsl:template name="SReplace">
+    <xsl:param name="sInput" />
+    <xsl:param name="sOrig" />
+    <xsl:param name="sReplacement" />
+
+    <xsl:choose>
+      <xsl:when test="not(contains($sInput, $sOrig))">
+        <xsl:value-of select="$sInput" />
+      </xsl:when>
+      <xsl:otherwise>
+        <xsl:variable name="sBefore" select="substring-before($sInput, $sOrig)" />
+        <xsl:variable name="sAfter" select="substring-after($sInput, $sOrig)" />
+        <xsl:variable name="sAfterProcessed">
+          <xsl:call-template name="SReplace">
+            <xsl:with-param name="sInput" select="$sAfter" />
+            <xsl:with-param name="sOrig" select="$sOrig" />
+            <xsl:with-param name="sReplacement" select="$sReplacement" />
+          </xsl:call-template>
+        </xsl:variable>
+
+        <xsl:value-of select="concat($sBefore, concat($sReplacement, $sAfterProcessed))" />
+      </xsl:otherwise>
+    </xsl:choose>
+  </xsl:template>
+
+  <!-- Templates -->
+  <xsl:template match="/">
+    <mml:math>
+      <xsl:apply-templates select="*" />
+    </mml:math>
+  </xsl:template>
+
+  <xsl:template match="m:borderBox">
+
+    <!-- Get Lowercase versions of properties -->
+    <xsl:variable name="sLowerCaseHideTop" select="translate(m:borderBoxPr[last()]/m:hideTop[last()]/@m:val, 'ABCDEFGHIJKLMNOPQRSTUVWXYZ', 
+		                                                             'abcdefghijklmnopqrstuvwxyz')" />
+    <xsl:variable name="sLowerCaseHideBot" select="translate(m:borderBoxPr[last()]/m:hideBot[last()]/@m:val, 'ABCDEFGHIJKLMNOPQRSTUVWXYZ', 
+		                                                             'abcdefghijklmnopqrstuvwxyz')" />
+    <xsl:variable name="sLowerCaseHideLeft" select="translate(m:borderBoxPr[last()]/m:hideLeft[last()]/@m:val, 'ABCDEFGHIJKLMNOPQRSTUVWXYZ', 
+		                                                             'abcdefghijklmnopqrstuvwxyz')" />
+    <xsl:variable name="sLowerCaseHideRight" select="translate(m:borderBoxPr[last()]/m:hideRight[last()]/@m:val, 'ABCDEFGHIJKLMNOPQRSTUVWXYZ', 
+		                                                             'abcdefghijklmnopqrstuvwxyz')" />
+    <xsl:variable name="sLowerCaseStrikeH" select="translate(m:borderBoxPr[last()]/m:strikeH[last()]/@m:val, 'ABCDEFGHIJKLMNOPQRSTUVWXYZ', 
+		                                                             'abcdefghijklmnopqrstuvwxyz')" />
+    <xsl:variable name="sLowerCaseStrikeV" select="translate(m:borderBoxPr[last()]/m:strikeV[last()]/@m:val, 'ABCDEFGHIJKLMNOPQRSTUVWXYZ', 
+		                                                             'abcdefghijklmnopqrstuvwxyz')" />
+    <xsl:variable name="sLowerCaseStrikeBLTR" select="translate(m:borderBoxPr[last()]/m:strikeBLTR[last()]/@m:val, 'ABCDEFGHIJKLMNOPQRSTUVWXYZ', 
+		                                                             'abcdefghijklmnopqrstuvwxyz')" />
+    <xsl:variable name="sLowerCaseStrikeTLBR" select="translate(m:borderBoxPr[last()]/m:strikeTLBR[last()]/@m:val, 'ABCDEFGHIJKLMNOPQRSTUVWXYZ', 
+		                                                             'abcdefghijklmnopqrstuvwxyz')" />
+    <xsl:variable name="fHideTop">
+      <xsl:call-template name="ForceTrueStrVal">
+        <xsl:with-param name="str" select="$sLowerCaseHideTop" />
+      </xsl:call-template>
+    </xsl:variable>
+    <xsl:variable name="fHideBot">
+      <xsl:call-template name="ForceTrueStrVal">
+        <xsl:with-param name="str" select="$sLowerCaseHideBot" />
+      </xsl:call-template>
+    </xsl:variable>
+    <xsl:variable name="fHideLeft">
+      <xsl:call-template name="ForceTrueStrVal">
+        <xsl:with-param name="str" select="$sLowerCaseHideLeft" />
+      </xsl:call-template>
+    </xsl:variable>
+    <xsl:variable name="fHideRight">
+      <xsl:call-template name="ForceTrueStrVal">
+        <xsl:with-param name="str" select="$sLowerCaseHideRight" />
+      </xsl:call-template>
+    </xsl:variable>
+    <xsl:variable name="fStrikeH">
+      <xsl:call-template name="ForceTrueStrVal">
+        <xsl:with-param name="str" select="$sLowerCaseStrikeH" />
+      </xsl:call-template>
+    </xsl:variable>
+    <xsl:variable name="fStrikeV">
+      <xsl:call-template name="ForceTrueStrVal">
+        <xsl:with-param name="str" select="$sLowerCaseStrikeV" />
+      </xsl:call-template>
+    </xsl:variable>
+    <xsl:variable name="fStrikeBLTR">
+      <xsl:call-template name="ForceTrueStrVal">
+        <xsl:with-param name="str" select="$sLowerCaseStrikeBLTR" />
+      </xsl:call-template>
+    </xsl:variable>
+    <xsl:variable name="fStrikeTLBR">
+      <xsl:call-template name="ForceTrueStrVal">
+        <xsl:with-param name="str" select="$sLowerCaseStrikeTLBR" />
+      </xsl:call-template>
+    </xsl:variable>
+
+    <xsl:choose>
+      <xsl:when test="$fHideTop=1 
+                      and $fHideBot=1 
+                      and $fHideLeft=1 
+                      and $fHideRight=1 
+                      and $fStrikeH=0 
+                      and $fStrikeV=0 
+                      and $fStrikeBLTR=0 
+                      and $fStrikeTLBR=0">
+        <mml:mrow>
+          <xsl:apply-templates select="m:e[1]" />
+        </mml:mrow>
+      </xsl:when>
+      <xsl:otherwise>
+        <mml:menclose>
+          <xsl:call-template name="CreateMencloseNotationAttrFromBorderBoxAttr">
+            <xsl:with-param name="fHideTop" select="$fHideTop" />
+            <xsl:with-param name="fHideBot" select="$fHideBot" />
+            <xsl:with-param name="fHideLeft" select="$fHideLeft" />
+            <xsl:with-param name="fHideRight" select="$fHideRight" />
+            <xsl:with-param name="fStrikeH" select="$fStrikeH" />
+            <xsl:with-param name="fStrikeV" select="$fStrikeV" />
+            <xsl:with-param name="fStrikeBLTR" select="$fStrikeBLTR" />
+            <xsl:with-param name="fStrikeTLBR" select="$fStrikeTLBR" />
+          </xsl:call-template>
+          <xsl:apply-templates select="m:e[1]" />
+        </mml:menclose>
+      </xsl:otherwise>
+    </xsl:choose>
+  </xsl:template>
+
+  <xsl:template match="*">
+    <xsl:apply-templates select="*" />
+  </xsl:template>
+
+  <!--
+      { Non-combining, Upper-combining, Lower-combining }
+      {U+02D8, U+0306, U+032E}, // BREVE
+      {U+00B8, U+0312, U+0327}, // CEDILLA
+      {U+0060, U+0300, U+0316}, // GRAVE ACCENT
+      {U+002D, U+0305, U+0332}, // HYPHEN-MINUS/OVERLINE
+      {U+2212, U+0305, U+0332}, // MINUS SIGN/OVERLINE
+      {U+002E, U+0305, U+0323}, // FULL STOP/DOT ABOVE
+      {U+02D9, U+0307, U+0323}, // DOT ABOVE
+      {U+02DD, U+030B, U+02DD}, // DOUBLE ACUTE ACCENT
+      {U+00B4, U+0301, U+0317}, // ACUTE ACCENT
+      {U+007E, U+0303, U+0330}, // TILDE
+      {U+02DC, U+0303, U+0330}, // SMALL TILDE
+      {U+00A8, U+0308, U+0324}, // DIAERESIS
+      {U+02C7, U+030C, U+032C}, // CARON
+      {U+005E, U+0302, U+032D}, // CIRCUMFLEX ACCENT
+      {U+00AF, U+0305, ::::::}, // MACRON
+      {U+005F, ::::::, U+0332}, // LOW LINE
+      {U+2192, U+20D7, U+20EF}, // RIGHTWARDS ARROW
+      {U+27F6, U+20D7, U+20EF}, // LONG RIGHTWARDS ARROW
+      {U+2190, U+20D6, U+20EE}, // LEFT ARROW
+  -->
+  <xsl:template name="ToNonCombining">
+    <xsl:param name="ch" />
+    <xsl:choose>
+      <!-- BREVE -->
+      <xsl:when test="$ch='&#x0306;' or $ch='&#x032e;'">&#x02D8;</xsl:when>
+      <!-- CEDILLA -->
+      <xsl:when test="$ch='&#x0312;' or $ch='&#x0327;'">&#x00B8;</xsl:when>
+      <!-- GRAVE ACCENT -->
+      <xsl:when test="$ch='&#x0300;' or $ch='&#x0316;'">&#x0060;</xsl:when>
+      <!-- HYPHEN-MINUS/OVERLINE -->
+      <xsl:when test="$ch='&#x0305;' or $ch='&#x0332;'">&#x002D;</xsl:when>
+      <!-- MINUS SIGN/OVERLINE -->
+      <xsl:when test="$ch='&#x0305;' or $ch='&#x0332;'">&#x2212;</xsl:when>
+      <!-- FULL STOP/DOT ABOVE -->
+      <xsl:when test="$ch='&#x0305;' or $ch='&#x0323;'">&#x002E;</xsl:when>
+      <!-- DOT ABOVE -->
+      <xsl:when test="$ch='&#x0307;' or $ch='&#x0323;'">&#x02D9;</xsl:when>
+      <!-- DOUBLE ACUTE ACCENT -->
+      <xsl:when test="$ch='&#x030B;' or $ch='&#x02DD;'">&#x02DD;</xsl:when>
+      <!-- ACUTE ACCENT -->
+      <xsl:when test="$ch='&#x0301;' or $ch='&#x0317;'">&#x00B4;</xsl:when>
+      <!-- TILDE -->
+      <xsl:when test="$ch='&#x0303;' or $ch='&#x0330;'">&#x007E;</xsl:when>
+      <!-- SMALL TILDE -->
+      <xsl:when test="$ch='&#x0303;' or $ch='&#x0330;'">&#x02DC;</xsl:when>
+      <!-- DIAERESIS -->
+      <xsl:when test="$ch='&#x0308;' or $ch='&#x0324;'">&#x00A8;</xsl:when>
+      <!-- CARON -->
+      <xsl:when test="$ch='&#x030C;' or $ch='&#x032C;'">&#x02C7;</xsl:when>
+      <!-- CIRCUMFLEX ACCENT -->
+      <xsl:when test="$ch='&#x0302;' or $ch='&#x032D;'">&#x005E;</xsl:when>
+      <!-- MACRON -->
+      <xsl:when test="$ch='&#x0305;'                   ">&#x00AF;</xsl:when>
+      <!-- LOW LINE -->
+      <xsl:when test="                   $ch='&#x0332;'">&#x005F;</xsl:when>
+      <!-- RIGHTWARDS ARROW -->
+      <xsl:when test="$ch='&#x20D7;' or $ch='&#x20EF;'">&#x2192;</xsl:when>
+      <!-- LONG RIGHTWARDS ARROW -->
+      <xsl:when test="$ch='&#x20D7;' or $ch='&#x20EF;'">&#x27F6;</xsl:when>
+      <!-- LEFT ARROW -->
+      <xsl:when test="$ch='&#x20D6;' or $ch='&#x20EE;'">&#x2190;</xsl:when>
+      <xsl:otherwise>
+        <xsl:value-of select="$ch"/>
+      </xsl:otherwise>
+    </xsl:choose>
+  </xsl:template>
+
+  <xsl:template match="m:acc">
+    <mml:mover>
+      <xsl:attribute name="accent">true</xsl:attribute>
+      <mml:mrow>
+        <xsl:apply-templates select="m:e[1]" />
+      </mml:mrow>
+      <xsl:variable name="chAcc">
+        <xsl:choose>
+          <xsl:when test="not(m:accPr[last()]/m:chr)">
+            <xsl:value-of select="'&#x0302;'" />
+          </xsl:when>
+          <xsl:otherwise>
+            <xsl:value-of select="substring(m:accPr/m:chr/@m:val,1,1)" />
+          </xsl:otherwise>
+        </xsl:choose>
+      </xsl:variable>
+      <xsl:variable name="chNonComb">
+        <xsl:call-template name="ToNonCombining">
+          <xsl:with-param name="ch" select="$chAcc" />
+        </xsl:call-template>
+      </xsl:variable>
+      <xsl:choose>
+        <xsl:when test="string-length($chAcc)=0">
+          <mml:mo/>
+        </xsl:when>
+        <xsl:otherwise>
+          <xsl:call-template name="ParseMt">
+            <xsl:with-param name="sToParse" select="$chNonComb" />
+            <xsl:with-param name="scr" select="m:e[1]/*/m:rPr[last()]/m:scr/@m:val" />
+            <xsl:with-param name="sty" select="m:e[1]/*/m:rPr[last()]/m:sty/@m:val" />
+            <xsl:with-param name="nor">
+              <xsl:choose>
+                <xsl:when test="count(m:e[1]/*/m:rPr[last()]/m:nor) = 0">0</xsl:when>
+                <xsl:otherwise>
+                  <xsl:call-template name="ForceFalseStrVal">
+                    <xsl:with-param name="str" select="translate(m:e[1]/*/m:rPr[last()]/m:nor/@m:val, 
+                                                                     'ABCDEFGHIJKLMNOPQRSTUVWXYZ', 
+		                                                                 'abcdefghijklmnopqrstuvwxyz')" />
+                  </xsl:call-template>
+                </xsl:otherwise>
+              </xsl:choose>
+            </xsl:with-param>
+          </xsl:call-template>
+        </xsl:otherwise>
+      </xsl:choose>
+    </mml:mover>
+  </xsl:template>
+
+  <xsl:template name="OutputScript">
+    <xsl:param name="ndCur" select="." />
+    <xsl:choose>
+      <!-- Only output contents of $ndCur if $ndCur exists
+           and $ndCur has children -->
+      <xsl:when test="count($ndCur/*) &gt; 0">
+        <mml:mrow>
+          <xsl:apply-templates select="$ndCur" />
+        </mml:mrow>
+      </xsl:when>
+      <xsl:otherwise>
+        <mml:none />
+      </xsl:otherwise>
+    </xsl:choose>
+  </xsl:template>
+
+  <xsl:template match="m:sPre">
+    <mml:mmultiscripts>
+      <mml:mrow>
+        <xsl:apply-templates select="m:e[1]" />
+      </mml:mrow>
+      <mml:mprescripts />
+      <xsl:call-template name="OutputScript">
+        <xsl:with-param name="ndCur" select="m:sub[1]"/>
+      </xsl:call-template>
+      <xsl:call-template name="OutputScript">
+        <xsl:with-param name="ndCur" select="m:sup[1]" />
+      </xsl:call-template>
+    </mml:mmultiscripts>
+  </xsl:template>
+
+  <xsl:template match="m:m">
+    <mml:mtable>
+      <xsl:call-template name="CreateMathMLMatrixAttr">
+        <xsl:with-param name="mcJc" select="m:mPr[last()]/m:mcs/m:mc/m:mcPr[last()]/m:mcJc/@m:val" />
+      </xsl:call-template>
+      <xsl:for-each select="m:mr">
+        <mml:mtr>
+          <xsl:for-each select="m:e">
+            <mml:mtd>
+              <xsl:apply-templates select="." />
+            </mml:mtd>
+          </xsl:for-each>
+        </mml:mtr>
+      </xsl:for-each>
+    </mml:mtable>
+  </xsl:template>
+
+  <xsl:template name="CreateMathMLMatrixAttr">
+    <xsl:param name="mcJc" />
+    <xsl:variable name="sLowerCaseMcjc" select="translate($mcJc, 'ABCDEFGHIJKLMNOPQRSTUVWXYZ', 
+		                                                             'abcdefghijklmnopqrstuvwxyz')" />
+    <xsl:choose>
+      <xsl:when test="$sLowerCaseMcjc='left'">
+        <xsl:attribute name="columnalign">left</xsl:attribute>
+      </xsl:when>
+      <xsl:when test="$sLowerCaseMcjc='right'">
+        <xsl:attribute name="columnalign">right</xsl:attribute>
+      </xsl:when>
+    </xsl:choose>
+  </xsl:template>
+
+  <xsl:template match="m:phant">
+    <xsl:variable name="sLowerCaseZeroWidVal" select="translate(m:phantPr[last()]/m:zeroWid[last()]/@m:val, 
+		                                                       'ABCDEFGHIJKLMNOPQRSTUVWXYZ', 
+		                                                       'abcdefghijklmnopqrstuvwxyz')" />
+    <xsl:variable name="sLowerCaseZeroAscVal" select="translate(m:phantPr[last()]/m:zeroAsc[last()]/@m:val, 
+		                                                     'ABCDEFGHIJKLMNOPQRSTUVWXYZ', 
+		                                                     'abcdefghijklmnopqrstuvwxyz')" />
+    <xsl:variable name="sLowerCaseZeroDescVal" select="translate(m:phantPr[last()]/m:zeroDesc[last()]/@m:val, 
+		                                                     'ABCDEFGHIJKLMNOPQRSTUVWXYZ', 
+		                                                     'abcdefghijklmnopqrstuvwxyz')" />
+    <xsl:variable name="sLowerCaseShowVal" select="translate(m:phantPr[last()]/m:show[last()]/@m:val, 
+		                                                     'ABCDEFGHIJKLMNOPQRSTUVWXYZ', 
+		                                                     'abcdefghijklmnopqrstuvwxyz')" />
+
+
+    <!-- The following properties default to 'yes' unless the last value equals 'no' or there isn't any node for 
+         the property -->
+
+    <xsl:variable name="fZeroWid">
+      <xsl:choose>
+        <xsl:when test="count(m:phantPr[last()]/m:zeroWid[last()]) = 0">0</xsl:when>
+        <xsl:otherwise>
+          <xsl:call-template name="ForceFalseStrVal">
+            <xsl:with-param name="str" select="$sLowerCaseZeroWidVal" />
+          </xsl:call-template>
+        </xsl:otherwise>
+      </xsl:choose>
+    </xsl:variable>
+    <xsl:variable name="fZeroAsc">
+      <xsl:choose>
+        <xsl:when test="count(m:phantPr[last()]/m:zeroAsc[last()]) = 0">0</xsl:when>
+        <xsl:otherwise>
+          <xsl:call-template name="ForceFalseStrVal">
+            <xsl:with-param name="str" select="$sLowerCaseZeroAscVal" />
+          </xsl:call-template>
+        </xsl:otherwise>
+      </xsl:choose>
+    </xsl:variable>
+    <xsl:variable name="fZeroDesc">
+      <xsl:choose>
+        <xsl:when test="count(m:phantPr[last()]/m:zeroDesc[last()]) = 0">0</xsl:when>
+        <xsl:otherwise>
+          <xsl:call-template name="ForceFalseStrVal">
+            <xsl:with-param name="str" select="$sLowerCaseZeroDescVal" />
+          </xsl:call-template>
+        </xsl:otherwise>
+      </xsl:choose>
+    </xsl:variable>
+
+    <!-- The show property defaults to 'on' unless there exists a show property and its value is 'off' -->
+
+    <xsl:variable name="fShow">
+      <xsl:call-template name="ForceFalseStrVal">
+        <xsl:with-param name="str" select="$sLowerCaseShowVal" />
+      </xsl:call-template>
+    </xsl:variable>
+
+    <xsl:choose>
+      <!-- Show the phantom contents, therefore, just use mpadded. -->
+      <xsl:when test="$fShow = 1">
+        <xsl:element name="mml:mpadded">
+          <xsl:call-template name="CreateMpaddedAttributes">
+            <xsl:with-param name="fZeroWid" select="$fZeroWid" />
+            <xsl:with-param name="fZeroAsc" select="$fZeroAsc" />
+            <xsl:with-param name="fZeroDesc" select="$fZeroDesc" />
+          </xsl:call-template>
+          <mml:mrow>
+            <xsl:apply-templates select="m:e" />
+          </mml:mrow>
+        </xsl:element>
+      </xsl:when>
+      <!-- Don't show phantom contents, but don't smash anything, therefore, just 
+           use mphantom -->
+      <xsl:when test="$fZeroWid=0 and $fZeroAsc=0 and $fZeroDesc=0">
+        <xsl:element name="mml:mphantom">
+          <mml:mrow>
+            <xsl:apply-templates select="m:e" />
+          </mml:mrow>
+        </xsl:element>
+      </xsl:when>
+      <!-- Combination -->
+      <xsl:otherwise>
+        <xsl:element name="mml:mphantom">
+          <xsl:element name="mml:mpadded">
+            <xsl:call-template name="CreateMpaddedAttributes">
+              <xsl:with-param name="fZeroWid" select="$fZeroWid" />
+              <xsl:with-param name="fZeroAsc" select="$fZeroAsc" />
+              <xsl:with-param name="fZeroDesc" select="$fZeroDesc" />
+            </xsl:call-template>
+            <mml:mrow>
+              <xsl:apply-templates select="m:e" />
+            </mml:mrow>
+          </xsl:element>
+        </xsl:element>
+      </xsl:otherwise>
+    </xsl:choose>
+  </xsl:template>
+
+  <xsl:template name="CreateMpaddedAttributes">
+    <xsl:param name="fZeroWid" />
+    <xsl:param name="fZeroAsc" />
+    <xsl:param name="fZeroDesc" />
+
+    <xsl:if test="$fZeroWid=1">
+      <xsl:attribute name="width">0in</xsl:attribute>
+    </xsl:if>
+    <xsl:if test="$fZeroAsc=1">
+      <xsl:attribute name="height">0in</xsl:attribute>
+    </xsl:if>
+    <xsl:if test="$fZeroDesc=1">
+      <xsl:attribute name="depth">0in</xsl:attribute>
+    </xsl:if>
+  </xsl:template>
+
+
+
+  <xsl:template match="m:rad">
+    <xsl:variable name="fDegHide">
+      <xsl:choose>
+        <xsl:when test="count(m:radPr[last()]/m:degHide)=0">0</xsl:when>
+        <xsl:otherwise>
+          <xsl:call-template name="ForceFalseStrVal">
+            <xsl:with-param name="str" select="translate(m:radPr[last()]/m:degHide/@m:val, 
+		                                                          'ABCDEFGHIJKLMNOPQRSTUVWXYZ', 
+		                                                          'abcdefghijklmnopqrstuvwxyz')" />
+          </xsl:call-template>
+        </xsl:otherwise>
+      </xsl:choose>
+    </xsl:variable>
+    <xsl:choose>
+      <xsl:when test="$fDegHide=1">
+        <mml:msqrt>
+          <xsl:apply-templates select="m:e[1]" />
+        </mml:msqrt>
+      </xsl:when>
+      <xsl:otherwise>
+        <mml:mroot>
+          <mml:mrow>
+            <xsl:apply-templates select="m:e[1]" />
+          </mml:mrow>
+          <mml:mrow>
+            <xsl:apply-templates select="m:deg[1]" />
+          </mml:mrow>
+        </mml:mroot>
+      </xsl:otherwise>
+    </xsl:choose>
+  </xsl:template>
+
+  <xsl:template name="OutputNaryMo">
+    <xsl:param name="ndCur" select="." />
+    <xsl:param name="fGrow" select="0" />
+    <mml:mo>
+      <xsl:choose>
+        <xsl:when test="$fGrow=1">
+          <xsl:attribute name="stretchy">true</xsl:attribute>
+        </xsl:when>
+        <xsl:otherwise>
+          <xsl:attribute name="stretchy">false</xsl:attribute>
+        </xsl:otherwise>
+      </xsl:choose>
+      <xsl:choose>
+        <xsl:when test="not($ndCur/m:naryPr[last()]/m:chr/@m:val) or
+			                            $ndCur/m:naryPr[last()]/m:chr/@m:val=''">
+          <xsl:text>&#x222b;</xsl:text>
+        </xsl:when>
+        <xsl:otherwise>
+          <xsl:value-of select="$ndCur/m:naryPr[last()]/m:chr/@m:val" />
+        </xsl:otherwise>
+      </xsl:choose>
+    </mml:mo>
+  </xsl:template>
+
+  <!-- %%Template match m:nary 
+		Process an n-ary. 
+		
+		Decides, based on which arguments are supplied, between
+		using an mo, msup, msub, or msubsup for the n-ary operator		
+	-->
+  <xsl:template match="m:nary">
+    <xsl:variable name="sLowerCaseSubHide">
+      <xsl:choose>
+        <xsl:when test="count(m:naryPr[last()]/m:subHide) = 0">
+          <xsl:text>off</xsl:text>
+        </xsl:when>
+        <xsl:otherwise>
+          <xsl:value-of select="translate(m:naryPr[last()]/m:subHide/@m:val, 
+	                                  'ABCDEFGHIJKLMNOPQRSTUVWXYZ', 
+	                                  'abcdefghijklmnopqrstuvwxyz')" />
+        </xsl:otherwise>
+      </xsl:choose>
+    </xsl:variable>
+
+    <xsl:variable name="sLowerCaseSupHide">
+      <xsl:choose>
+        <xsl:when test="count(m:naryPr[last()]/m:supHide) = 0">
+          <xsl:text>off</xsl:text>
+        </xsl:when>
+        <xsl:otherwise>
+          <xsl:value-of select="translate(m:naryPr[last()]/m:supHide/@m:val, 
+	                                  'ABCDEFGHIJKLMNOPQRSTUVWXYZ', 
+	                                  'abcdefghijklmnopqrstuvwxyz')" />
+        </xsl:otherwise>
+      </xsl:choose>
+    </xsl:variable>
+
+    <xsl:variable name="sLowerCaseLimLoc">
+      <xsl:value-of select="translate(m:naryPr[last()]/m:limLoc/@m:val, 
+	                                  'ABCDEFGHIJKLMNOPQRSTUVWXYZ', 
+	                                  'abcdefghijklmnopqrstuvwxyz')" />
+    </xsl:variable>
+
+    <xsl:variable name="sLowerGrow">
+      <xsl:choose>
+        <xsl:when test="count(m:naryPr[last()]/m:grow)=0">off</xsl:when>
+        <xsl:otherwise>
+          <xsl:value-of select="translate(m:naryPr[last()]/m:grow/@m:val, 
+	                                  'ABCDEFGHIJKLMNOPQRSTUVWXYZ', 
+	                                  'abcdefghijklmnopqrstuvwxyz')" />
+        </xsl:otherwise>
+      </xsl:choose>
+    </xsl:variable>
+
+    <xsl:variable name="fLimLocSubSup">
+      <xsl:choose>
+        <xsl:when test="count(m:naryPr[last()]/m:limLoc)=0 or $sLowerCaseLimLoc='subsup'">1</xsl:when>
+        <xsl:otherwise>0</xsl:otherwise>
+      </xsl:choose>
+    </xsl:variable>
+
+    <xsl:variable name="fGrow">
+      <xsl:call-template name="ForceFalseStrVal">
+        <xsl:with-param name="str" select="$sLowerGrow" />
+      </xsl:call-template>
+    </xsl:variable>
+
+    <xsl:variable name="fSupHide">
+      <xsl:call-template name="ForceFalseStrVal">
+        <xsl:with-param name="str" select="$sLowerCaseSupHide" />
+      </xsl:call-template>
+    </xsl:variable>
+
+    <xsl:variable name="fSubHide">
+      <xsl:call-template name="ForceFalseStrVal">
+        <xsl:with-param name="str" select="$sLowerCaseSubHide" />
+      </xsl:call-template>
+    </xsl:variable>
+
+    <mml:mrow>
+      <xsl:choose>
+        <xsl:when test="$fSupHide=1 and $fSubHide=1">
+          <xsl:call-template name="OutputNaryMo">
+            <xsl:with-param name="ndCur" select="." />
+            <xsl:with-param name="fGrow" select="$fGrow" />
+          </xsl:call-template>
+        </xsl:when>
+        <xsl:when test="$fSubHide=1">
+          <xsl:choose>
+            <xsl:when test="$fLimLocSubSup=1">
+              <mml:msup>
+                <xsl:call-template name="OutputNaryMo">
+                  <xsl:with-param name="ndCur" select="." />
+                  <xsl:with-param name="fGrow" select="$fGrow" />
+                </xsl:call-template>
+                <mml:mrow>
+                  <xsl:apply-templates select="m:sup[1]" />
+                </mml:mrow>
+              </mml:msup>
+            </xsl:when>
+            <xsl:otherwise>
+              <mml:mover>
+                <xsl:call-template name="OutputNaryMo">
+                  <xsl:with-param name="ndCur" select="." />
+                  <xsl:with-param name="fGrow" select="$fGrow" />
+                </xsl:call-template>
+                <mml:mrow>
+                  <xsl:apply-templates select="m:sup[1]" />
+                </mml:mrow>
+              </mml:mover>
+            </xsl:otherwise>
+          </xsl:choose>
+        </xsl:when>
+        <xsl:when test="$fSupHide=1">
+          <xsl:choose>
+            <xsl:when test="$fLimLocSubSup=1">
+              <mml:msub>
+                <xsl:call-template name="OutputNaryMo">
+                  <xsl:with-param name="ndCur" select="." />
+                  <xsl:with-param name="fGrow" select="$fGrow" />
+                </xsl:call-template>
+                <mml:mrow>
+                  <xsl:apply-templates select="m:sub[1]" />
+                </mml:mrow>
+              </mml:msub>
+            </xsl:when>
+            <xsl:otherwise>
+              <mml:munder>
+                <xsl:call-template name="OutputNaryMo">
+                  <xsl:with-param name="ndCur" select="." />
+                  <xsl:with-param name="fGrow" select="$fGrow" />
+                </xsl:call-template>
+                <mml:mrow>
+                  <xsl:apply-templates select="m:sub[1]" />
+                </mml:mrow>
+              </mml:munder>
+            </xsl:otherwise>
+          </xsl:choose>
+        </xsl:when>
+        <xsl:otherwise>
+          <xsl:choose>
+            <xsl:when test="$fLimLocSubSup=1">
+              <mml:msubsup>
+                <xsl:call-template name="OutputNaryMo">
+                  <xsl:with-param name="ndCur" select="." />
+                  <xsl:with-param name="fGrow" select="$fGrow" />
+                </xsl:call-template>
+                <mml:mrow>
+                  <xsl:apply-templates select="m:sub[1]" />
+                </mml:mrow>
+                <mml:mrow>
+                  <xsl:apply-templates select="m:sup[1]" />
+                </mml:mrow>
+              </mml:msubsup>
+            </xsl:when>
+            <xsl:otherwise>
+              <mml:munderover>
+                <xsl:call-template name="OutputNaryMo">
+                  <xsl:with-param name="ndCur" select="." />
+                  <xsl:with-param name="fGrow" select="$fGrow" />
+                </xsl:call-template>
+                <mml:mrow>
+                  <xsl:apply-templates select="m:sub[1]" />
+                </mml:mrow>
+                <mml:mrow>
+                  <xsl:apply-templates select="m:sup[1]" />
+                </mml:mrow>
+              </mml:munderover>
+            </xsl:otherwise>
+          </xsl:choose>
+        </xsl:otherwise>
+      </xsl:choose>
+      <mml:mrow>
+        <xsl:apply-templates select="m:e[1]" />
+      </mml:mrow>
+    </mml:mrow>
+  </xsl:template>
+
+  <xsl:template match="m:limLow">
+    <mml:munder>
+      <mml:mrow>
+        <xsl:apply-templates select="m:e[1]" />
+      </mml:mrow>
+      <mml:mrow>
+        <xsl:apply-templates select="m:lim[1]" />
+      </mml:mrow>
+    </mml:munder>
+  </xsl:template>
+
+  <xsl:template match="m:limUpp">
+    <mml:mover>
+      <mml:mrow>
+        <xsl:apply-templates select="m:e[1]" />
+      </mml:mrow>
+      <mml:mrow>
+        <xsl:apply-templates select="m:lim[1]" />
+      </mml:mrow>
+    </mml:mover>
+  </xsl:template>
+
+  <xsl:template match="m:sSub">
+    <mml:msub>
+      <mml:mrow>
+        <xsl:apply-templates select="m:e[1]" />
+      </mml:mrow>
+      <mml:mrow>
+        <xsl:apply-templates select="m:sub[1]" />
+      </mml:mrow>
+    </mml:msub>
+  </xsl:template>
+
+  <xsl:template match="m:sSup">
+    <mml:msup>
+      <mml:mrow>
+        <xsl:apply-templates select="m:e[1]" />
+      </mml:mrow>
+      <mml:mrow>
+        <xsl:apply-templates select="m:sup[1]" />
+      </mml:mrow>
+    </mml:msup>
+  </xsl:template>
+
+  <xsl:template match="m:sSubSup">
+    <mml:msubsup>
+      <mml:mrow>
+        <xsl:apply-templates select="m:e[1]" />
+      </mml:mrow>
+      <mml:mrow>
+        <xsl:apply-templates select="m:sub[1]" />
+      </mml:mrow>
+      <mml:mrow>
+        <xsl:apply-templates select="m:sup[1]" />
+      </mml:mrow>
+    </mml:msubsup>
+  </xsl:template>
+
+  <xsl:template match="m:groupChr">
+    <xsl:variable name="ndLastGroupChrPr" select="m:groupChrPr[last()]" />
+    <xsl:variable name="sLowerCasePos" select="translate($ndLastGroupChrPr/m:pos/@m:val, 
+		                                                     'ABCDEFGHIJKLMNOPQRSTUVWXYZ', 
+		                                                     'abcdefghijklmnopqrstuvwxyz')" />
+
+    <xsl:variable name="sLowerCaseVertJc" select="translate($ndLastGroupChrPr/m:vertJc/@m:val, 
+		                                                     'ABCDEFGHIJKLMNOPQRSTUVWXYZ', 
+		                                                     'abcdefghijklmnopqrstuvwxyz')" />
+    <xsl:variable name="ndLastChr" select="$ndLastGroupChrPr/m:chr" />
+
+    <xsl:variable name="chr">
+      <xsl:choose>
+        <xsl:when test="$ndLastChr and (not($ndLastChr/@m:val) or string-length($ndLastChr/@m:val) = 0)"></xsl:when>
+        <xsl:when test="string-length($ndLastChr/@m:val) &gt;= 1">
+          <xsl:value-of select="substring($ndLastChr/@m:val,1,1)" />
+        </xsl:when>
+        <xsl:otherwise>
+          <xsl:text>&#x023DF;</xsl:text>
+        </xsl:otherwise>
+      </xsl:choose>
+    </xsl:variable>
+    <xsl:choose>
+      <xsl:when test="$sLowerCasePos = 'top'">
+        <xsl:choose>
+          <xsl:when test="$sLowerCaseVertJc = 'bot'">
+            <mml:mover accent="false">
+              <mml:mrow>
+                <xsl:apply-templates select="m:e[1]" />
+              </mml:mrow>
+              <mml:mo>
+                <xsl:value-of select="$chr" />
+              </mml:mo>
+            </mml:mover>
+          </xsl:when>
+          <xsl:otherwise>
+            <mml:munder accentunder="false">
+              <mml:mo>
+                <xsl:value-of select="$chr" />
+              </mml:mo>
+              <mml:mrow>
+                <xsl:apply-templates select="m:e[1]" />
+              </mml:mrow>
+            </mml:munder>
+          </xsl:otherwise>
+        </xsl:choose>
+      </xsl:when>
+      <xsl:otherwise>
+        <xsl:choose>
+          <xsl:when test="$sLowerCaseVertJc = 'bot'">
+            <mml:mover accent="false">
+              <mml:mo>
+                <xsl:value-of select="$chr" />
+              </mml:mo>
+              <mml:mrow>
+                <xsl:apply-templates select="m:e[1]" />
+              </mml:mrow>
+            </mml:mover>
+          </xsl:when>
+          <xsl:otherwise>
+            <mml:munder accentunder="false">
+              <mml:mrow>
+                <xsl:apply-templates select="m:e[1]" />
+              </mml:mrow>
+              <mml:mo>
+                <xsl:value-of select="$chr" />
+              </mml:mo>
+            </mml:munder>
+          </xsl:otherwise>
+        </xsl:choose>
+      </xsl:otherwise>
+    </xsl:choose>
+  </xsl:template>
+
+  <xsl:template name="fName">
+    <xsl:for-each select="m:fName/*">
+      <xsl:apply-templates select="." />
+    </xsl:for-each>
+  </xsl:template>
+
+  <xsl:template match="m:func">
+    <mml:mrow>
+      <mml:mrow>
+        <xsl:call-template name="fName" />
+      </mml:mrow>
+      <mml:mo>&#x02061;</mml:mo>
+      <mml:mrow>
+        <xsl:apply-templates select="m:e" />
+      </mml:mrow>
+    </mml:mrow>
+  </xsl:template>
+
+  <!-- %%Template: match m:f 
+		
+		m:f maps directly to mfrac. 
+	-->
+  <xsl:template match="m:f">
+    <xsl:variable name="sLowerCaseType" select="translate(m:fPr[last()]/m:type/@m:val, 'ABCDEFGHIJKLMNOPQRSTUVWXYZ', 'abcdefghijklmnopqrstuvwxyz')" />
+    <xsl:choose>
+      <xsl:when test="$sLowerCaseType='lin'">
+        <mml:mrow>
+          <mml:mrow>
+            <xsl:apply-templates select="m:num[1]" />
+          </mml:mrow>
+          <mml:mo>/</mml:mo>
+          <mml:mrow>
+            <xsl:apply-templates select="m:den[1]" />
+          </mml:mrow>
+        </mml:mrow>
+      </xsl:when>
+      <xsl:otherwise>
+        <mml:mfrac>
+          <xsl:call-template name="CreateMathMLFracProp">
+            <xsl:with-param name="type" select="$sLowerCaseType" />
+          </xsl:call-template>
+          <mml:mrow>
+            <xsl:apply-templates select="m:num[1]" />
+          </mml:mrow>
+          <mml:mrow>
+            <xsl:apply-templates select="m:den[1]" />
+          </mml:mrow>
+        </mml:mfrac>
+      </xsl:otherwise>
+    </xsl:choose>
+
+  </xsl:template>
+
+
+  <!-- %%Template: CreateMathMLFracProp 
+		
+			Make fraction properties based on supplied parameters.
+			OMML differentiates between a linear fraction and a skewed
+			one. For MathML, we write both as bevelled.
+	-->
+  <xsl:template name="CreateMathMLFracProp">
+    <xsl:param name="type" />
+    <xsl:variable name="sLowerCaseType" select="translate($type, 'ABCDEFGHIJKLMNOPQRSTUVWXYZ', 'abcdefghijklmnopqrstuvwxyz')" />
+
+    <xsl:if test="$sLowerCaseType='skw' or $sLowerCaseType='lin'">
+      <xsl:attribute name="bevelled">true</xsl:attribute>
+    </xsl:if>
+    <xsl:if test="$sLowerCaseType='nobar'">
+      <xsl:attribute name="linethickness">0pt</xsl:attribute>
+    </xsl:if>
+    <xsl:choose>
+      <xsl:when test="sLowerCaseNumJc='right'">
+        <xsl:attribute name="numalign">right</xsl:attribute>
+      </xsl:when>
+      <xsl:when test="sLowerCaseNumJc='left'">
+        <xsl:attribute name="numalign">left</xsl:attribute>
+      </xsl:when>
+    </xsl:choose>
+    <xsl:choose>
+      <xsl:when test="sLowerCaseDenJc='right'">
+        <xsl:attribute name="numalign">right</xsl:attribute>
+      </xsl:when>
+      <xsl:when test="sLowerCaseDenJc='left'">
+        <xsl:attribute name="numalign">left</xsl:attribute>
+      </xsl:when>
+    </xsl:choose>
+  </xsl:template>
+
+  <!-- %%Template: match m:e | m:den | m:num | m:lim | m:sup | m:sub 
+		
+		These element delinate parts of an expression (like the numerator).  -->
+  <xsl:template match="m:e | m:den | m:num | m:lim | m:sup | m:sub">
+    <xsl:choose>
+
+      <!-- If there is no scriptLevel specified, just call through -->
+      <xsl:when test="not(m:argPr[last()]/m:scrLvl/@m:val)">
+        <xsl:apply-templates select="*" />
+      </xsl:when>
+
+      <!-- Otherwise, create an mstyle and set the script level -->
+      <xsl:otherwise>
+        <mml:mstyle>
+          <xsl:attribute name="scriptlevel">
+            <xsl:value-of select="m:argPr[last()]/m:scrLvl/@m:val" />
+          </xsl:attribute>
+          <xsl:apply-templates select="*" />
+        </mml:mstyle>
+      </xsl:otherwise>
+    </xsl:choose>
+  </xsl:template>
+
+  <xsl:template match="m:bar">
+    <xsl:variable name="sLowerCasePos" select="translate(m:barPr/m:pos/@m:val, 'ABCDEFGHIJKLMNOPQRSTUVWXYZ', 
+		                                                                       'abcdefghijklmnopqrstuvwxyz')" />
+
+    <xsl:variable name="fTop">
+
+      <xsl:choose>
+        <xsl:when test="$sLowerCasePos='top'">1</xsl:when>
+        <xsl:otherwise>0</xsl:otherwise>
+      </xsl:choose>
+    </xsl:variable>
+    <xsl:choose>
+      <xsl:when test="$fTop=1">
+        <mml:mover accent="false">
+          <mml:mrow>
+            <xsl:apply-templates select="m:e[1]" />
+          </mml:mrow>
+          <mml:mo>
+            <xsl:text>&#x00AF;</xsl:text>
+          </mml:mo>
+        </mml:mover>
+      </xsl:when>
+      <xsl:otherwise>
+        <mml:munder underaccent="false">
+          <mml:mrow>
+            <xsl:apply-templates select="m:e[1]" />
+          </mml:mrow>
+          <mml:mo>
+            <xsl:text>&#x005F;</xsl:text>
+          </mml:mo>
+        </mml:munder>
+      </xsl:otherwise>
+    </xsl:choose>
+  </xsl:template>
+
+  <!-- %%Template match m:d
+
+		Process a delimiter. 
+	-->
+  <xsl:template match="m:d">
+    <mml:mfenced>
+      <!-- open: default is '(' for both OMML and MathML -->
+      <xsl:if test="m:dPr[1]/m:begChr/@m:val and not(m:dPr[1]/m:begChr/@m:val ='(')">
+        <xsl:attribute name="open">
+          <xsl:value-of select="m:dPr[1]/m:begChr/@m:val" />
+        </xsl:attribute>
+      </xsl:if>
+
+      <!-- close: default is ')' for both OMML and MathML -->
+      <xsl:if test="m:dPr[1]/m:endChr/@m:val and not(m:dPr[1]/m:endChr/@m:val =')')">
+        <xsl:attribute name="close">
+          <xsl:value-of select="m:dPr[1]/m:endChr/@m:val" />
+        </xsl:attribute>
+      </xsl:if>
+
+      <!-- separator: the default is ',' for MathML, and '|' for OMML -->
+      <xsl:choose>
+        <!-- Matches MathML default. Write nothing -->
+        <xsl:when test="m:dPr[1]/m:sepChr/@m:val = ','" />
+
+        <!-- OMML default: | -->
+        <xsl:when test="not(m:dPr[1]/m:sepChr/@m:val)">
+          <xsl:attribute name="separators">
+            <xsl:value-of select="'|'" />
+          </xsl:attribute>
+        </xsl:when>
+
+        <xsl:otherwise>
+          <xsl:attribute name="separators">
+            <xsl:value-of select="m:dPr[1]/m:sepChr/@m:val" />
+          </xsl:attribute>
+        </xsl:otherwise>
+      </xsl:choose>
+
+      <!-- now write all the children. Put each one into an mrow
+			just in case it produces multiple runs, etc -->
+      <xsl:for-each select="m:e">
+        <mml:mrow>
+          <xsl:apply-templates select="." />
+        </mml:mrow>
+      </xsl:for-each>
+    </mml:mfenced>
+  </xsl:template>
+
+  <xsl:template match="m:r">
+    <xsl:variable name="fNor">
+      <xsl:choose>
+        <xsl:when test="count(child::m:rPr[last()]/m:nor) = 0">0</xsl:when>
+        <xsl:otherwise>
+          <xsl:call-template name="ForceFalseStrVal">
+            <xsl:with-param name="str" select="translate(child::m:rPr[last()]/m:nor/@m:val, 'ABCDEFGHIJKLMNOPQRSTUVWXYZ', 
+		                                                                       'abcdefghijklmnopqrstuvwxyz')" />
+          </xsl:call-template>
+        </xsl:otherwise>
+      </xsl:choose>
+    </xsl:variable>
+
+    <xsl:choose>
+      <xsl:when test="$fNor=1">
+        <mml:mtext>
+          <xsl:variable name="sOutput" select="translate(.//m:t, ' ', '&#xa0;')" />
+          <xsl:value-of select="$sOutput" />
+        </mml:mtext>
+      </xsl:when>
+      <xsl:otherwise>
+        <xsl:for-each select=".//m:t">
+          <xsl:call-template name="ParseMt">
+            <xsl:with-param name="sToParse" select="text()" />
+            <xsl:with-param name="scr" select="../m:rPr[last()]/m:scr/@m:val" />
+            <xsl:with-param name="sty" select="../m:rPr[last()]/m:sty/@m:val" />
+            <xsl:with-param name="nor">0</xsl:with-param>
+          </xsl:call-template>
+        </xsl:for-each>
+      </xsl:otherwise>
+    </xsl:choose>
+  </xsl:template>
+
+
+  <xsl:template name="CreateTokenAttributes">
+    <xsl:param name="scr" />
+    <xsl:param name="sty" />
+    <xsl:param name="nor" />
+    <xsl:param name="nCharToPrint" />
+    <xsl:param name="sTokenType" />
+
+    <xsl:choose>
+      <xsl:when test="$nor=1">
+        <xsl:attribute name="mathvariant">normal</xsl:attribute>
+      </xsl:when>
+      <xsl:otherwise>
+        <xsl:variable name="mathvariant">
+          <xsl:choose>
+            <!-- numbers don't care -->
+            <xsl:when test="$sTokenType='mn'" />
+
+            <xsl:when test="$scr='monospace'">monospace</xsl:when>
+            <xsl:when test="$scr='sans-serif' and $sty='i'">sans-serif-italic</xsl:when>
+            <xsl:when test="$scr='sans-serif' and $sty='b'">bold-sans-serif</xsl:when>
+            <xsl:when test="$scr='sans-serif' and $sty='bi'">sans-serif-bold-italic</xsl:when>
+            <xsl:when test="$scr='sans-serif'">sans-serif</xsl:when>
+            <xsl:when test="$scr='fraktur' and ($sty='b' or $sty='bi')">bold-fraktur</xsl:when>
+            <xsl:when test="$scr='fraktur'">fraktur</xsl:when>
+            <xsl:when test="$scr='double-struck'">double-struck</xsl:when>
+            <xsl:when test="$scr='script' and ($sty='b' or $sty='bi')">bold-script</xsl:when>
+            <xsl:when test="$scr='script'">script</xsl:when>
+            <xsl:when test="($scr='roman' or not($scr) or $scr='') and $sty='b'">bold</xsl:when>
+            <xsl:when test="($scr='roman' or not($scr) or $scr='') and $sty='i'">italic</xsl:when>
+            <xsl:when test="($scr='roman' or not($scr) or $scr='') and $sty='p'">normal</xsl:when>
+            <xsl:when test="($scr='roman' or not($scr) or $scr='') and $sty='bi'">bold-italic</xsl:when>
+            <xsl:otherwise />
+          </xsl:choose>
+        </xsl:variable>
+        <xsl:variable name="fontweight">
+          <xsl:choose>
+            <xsl:when test="$sty='b' or $sty='bi'">bold</xsl:when>
+            <xsl:otherwise>normal</xsl:otherwise>
+          </xsl:choose>
+        </xsl:variable>
+        <xsl:variable name="fontstyle">
+          <xsl:choose>
+            <xsl:when test="$sty='p' or $sty='b'">normal</xsl:when>
+            <xsl:otherwise>italic</xsl:otherwise>
+          </xsl:choose>
+        </xsl:variable>
+
+        <!-- Writing of attributes begins here -->
+        <xsl:choose>
+          <!-- Don't write mathvariant for operators unless they want to be normal -->
+          <xsl:when test="$sTokenType='mo' and $mathvariant!='normal'" />
+
+          <!-- A single character within an mi is already italics, don't write -->
+          <xsl:when test="$sTokenType='mi' and $nCharToPrint=1 and ($mathvariant='' or $mathvariant='italic')" />
+
+          <xsl:when test="$sTokenType='mi' and $nCharToPrint &gt; 1 and ($mathvariant='' or $mathvariant='italic')">
+            <xsl:attribute name="mathvariant">
+              <xsl:value-of select="'italic'" />
+            </xsl:attribute>
+          </xsl:when>
+          <xsl:when test="$mathvariant!='italic' and $mathvariant!=''">
+            <xsl:attribute name="mathvariant">
+              <xsl:value-of select="$mathvariant" />
+            </xsl:attribute>
+          </xsl:when>
+          <xsl:otherwise>
+            <xsl:if test="not($sTokenType='mi' and $nCharToPrint=1) and $fontstyle='italic'">
+              <xsl:attribute name="fontstyle">italic</xsl:attribute>
+            </xsl:if>
+            <xsl:if test="$fontweight='bold'">
+              <xsl:attribute name="fontweight">bold</xsl:attribute>
+            </xsl:if>
+          </xsl:otherwise>
+        </xsl:choose>
+      </xsl:otherwise>
+    </xsl:choose>
+  </xsl:template>
+
+  <xsl:template match="m:eqArr">
+    <mml:mtable>
+      <xsl:for-each select="m:e">
+        <mml:mtr>
+          <mml:mtd>
+            <xsl:choose>
+              <xsl:when test="m:argPr[last()]/m:scrLvl/@m:val!='0' or 
+					            not(m:argPr[last()]/m:scrLvl/@m:val)  or 
+					            m:argPr[last()]/m:scrLvl/@m:val=''">
+                <mml:mrow>
+                  <mml:maligngroup />
+                  <xsl:call-template name="CreateEqArrRow">
+                    <xsl:with-param name="align" select="1" />
+                    <xsl:with-param name="ndCur" select="*[1]" />
+                  </xsl:call-template>
+                </mml:mrow>
+              </xsl:when>
+              <xsl:otherwise>
+                <mml:mstyle>
+                  <xsl:attribute name="scriptlevel">
+                    <xsl:value-of select="m:argPr[last()]/m:scrLvl/@m:val" />
+                  </xsl:attribute>
+                  <mml:maligngroup />
+                  <xsl:call-template name="CreateEqArrRow">
+                    <xsl:with-param name="align" select="1" />
+                    <xsl:with-param name="ndCur" select="*[1]" />
+                  </xsl:call-template>
+                </mml:mstyle>
+              </xsl:otherwise>
+            </xsl:choose>
+          </mml:mtd>
+        </mml:mtr>
+      </xsl:for-each>
+    </mml:mtable>
+  </xsl:template>
+
+  <xsl:template name="CreateEqArrRow">
+    <xsl:param name="align" />
+    <xsl:param name="ndCur" />
+    <xsl:variable name="sAllMt">
+      <xsl:for-each select="$ndCur/m:t">
+        <xsl:value-of select="." />
+      </xsl:for-each>
+    </xsl:variable>
+    <xsl:choose>
+      <xsl:when test="$ndCur/self::m:r">
+        <xsl:call-template name="ParseEqArrMr">
+          <xsl:with-param name="sToParse" select="$sAllMt" />
+          <xsl:with-param name="scr" select="../m:rPr[last()]/m:scr/@m:val" />
+          <xsl:with-param name="sty" select="../m:rPr[last()]/m:sty/@m:val" />
+          <xsl:with-param name="nor">
+            <xsl:choose>
+              <xsl:when test="count($ndCur/m:rPr[last()]/m:nor) = 0">0</xsl:when>
+              <xsl:otherwise>
+                <xsl:call-template name="ForceFalseStrVal">
+                  <xsl:with-param name="str" select="translate($ndCur/m:rPr[last()]/m:nor/@m:val, 
+                                                                     'ABCDEFGHIJKLMNOPQRSTUVWXYZ', 
+		                                                                 'abcdefghijklmnopqrstuvwxyz')" />
+                </xsl:call-template>
+              </xsl:otherwise>
+            </xsl:choose>
+          </xsl:with-param>
+          <xsl:with-param name="align" select="$align" />
+        </xsl:call-template>
+      </xsl:when>
+      <xsl:otherwise>
+        <xsl:apply-templates select="$ndCur" />
+      </xsl:otherwise>
+    </xsl:choose>
+    <xsl:if test="count($ndCur/following-sibling::*) &gt; 0">
+      <xsl:variable name="cAmp">
+        <xsl:call-template name="CountAmp">
+          <xsl:with-param name="sAllMt" select="$sAllMt" />
+          <xsl:with-param name="cAmp" select="0" />
+        </xsl:call-template>
+      </xsl:variable>
+      <xsl:call-template name="CreateEqArrRow">
+        <xsl:with-param name="align" select="($align+($cAmp mod 2)) mod 2" />
+        <xsl:with-param name="ndCur" select="$ndCur/following-sibling::*[1]" />
+      </xsl:call-template>
+    </xsl:if>
+  </xsl:template>
+
+  <xsl:template name="CountAmp">
+    <xsl:param name="sAllMt" />
+    <xsl:param name="cAmp" />
+    <xsl:choose>
+      <xsl:when test="string-length(substring-after($sAllMt, '&amp;')) &gt; 0 or 
+			                substring($sAllMt, string-length($sAllMt))='&#x0026;'">
+        <xsl:call-template name="CountAmp">
+          <xsl:with-param name="sAllMt" select="substring-after($sAllMt, '&#x0026;')" />
+          <xsl:with-param name="cAmp" select="$cAmp+1" />
+        </xsl:call-template>
+      </xsl:when>
+      <xsl:otherwise>
+        <xsl:value-of select="$cAmp" />
+      </xsl:otherwise>
+    </xsl:choose>
+  </xsl:template>
+
+  <!-- %%Template: ParseEqArrMr
+			
+			Similar to ParseMt, but this one has to do more for an equation array. 
+      In equation arrays &amp; is a special character which denotes alignment.
+      
+      The &amp; in an equation works by alternating between meaning insert alignment spacing
+      and insert alignment mark.  For each equation in the equation array
+      there is an implied align space at the beginning of the equation.  Within each equation,
+      the first &amp; means alignmark, the second, align space, the third, alignmark, etc.
+      
+      For this reason when parsing m:r's in equation arrays it is important to keep track of what
+      the next ampersand will mean.
+      
+      $align=0 => Omml's align space, which is similar to MathML's maligngroup.
+      $align=1 => Omml's alignment mark, which is similar to MathML's malignmark.
+	-->
+  <xsl:template name="ParseEqArrMr">
+    <xsl:param name="sToParse" />
+    <xsl:param name="sty" />
+    <xsl:param name="scr" />
+    <xsl:param name="nor" />
+    <xsl:param name="align" />
+
+    <xsl:if test="string-length($sToParse) &gt; 0">
+      <xsl:choose>
+        <xsl:when test="substring($sToParse,1,1) = '&amp;'">
+          <xsl:choose>
+            <xsl:when test="$align='0'">
+              <mml:maligngroup />
+            </xsl:when>
+            <xsl:when test="$align='1'">
+              <mml:malignmark />
+            </xsl:when>
+          </xsl:choose>
+          <xsl:call-template name="ParseEqArrMr">
+            <xsl:with-param name="sToParse" select="substring($sToParse,2)" />
+            <xsl:with-param name="scr" select="$scr" />
+            <xsl:with-param name="sty" select="$sty" />
+            <xsl:with-param name="nor" select="$nor" />
+            <xsl:with-param name="align">
+              <xsl:choose>
+                <xsl:when test="$align='1'">0</xsl:when>
+                <xsl:otherwise>1</xsl:otherwise>
+              </xsl:choose>
+            </xsl:with-param>
+          </xsl:call-template>
+        </xsl:when>
+        <xsl:otherwise>
+          <xsl:variable name="sRepNumWith0">
+            <xsl:call-template name="SReplaceNumWithZero">
+              <xsl:with-param name="sToParse" select="$sToParse" />
+            </xsl:call-template>
+          </xsl:variable>
+          <xsl:variable name="sRepOperWith-">
+            <xsl:call-template name="SReplaceOperWithMinus">
+              <xsl:with-param name="sToParse" select="$sRepNumWith0" />
+            </xsl:call-template>
+          </xsl:variable>
+
+          <xsl:variable name="iFirstOper" select="string-length($sRepOperWith-) - string-length(substring-after($sRepOperWith-, '-'))" />
+          <xsl:variable name="iFirstNum" select="string-length($sRepOperWith-) - string-length(substring-after($sRepOperWith-, '0'))" />
+          <xsl:variable name="iFirstAmp" select="string-length($sRepOperWith-) - string-length(substring-after($sRepOperWith-, '&#x0026;'))" />
+          <xsl:variable name="fNumAtPos1">
+            <xsl:choose>
+              <xsl:when test="substring($sRepOperWith-,1,1)='0'">1</xsl:when>
+              <xsl:otherwise>0</xsl:otherwise>
+            </xsl:choose>
+          </xsl:variable>
+          <xsl:variable name="fOperAtPos1">
+            <xsl:choose>
+              <xsl:when test="substring($sRepOperWith-,1,1)='-'">1</xsl:when>
+              <xsl:otherwise>0</xsl:otherwise>
+            </xsl:choose>
+          </xsl:variable>
+          <xsl:choose>
+
+            <!-- Case I: The string begins with neither a number, nor an operator -->
+            <xsl:when test="$fNumAtPos1='0' and $fOperAtPos1='0'">
+              <xsl:choose>
+                <xsl:when test="$nor = 0">
+                  <mml:mi>
+                    <xsl:call-template name="CreateTokenAttributes">
+                      <xsl:with-param name="scr" select="$scr" />
+                      <xsl:with-param name="sty" select="$sty" />
+                      <xsl:with-param name="nor" select="$nor" />
+                      <xsl:with-param name="nCharToPrint" select="1" />
+                      <xsl:with-param name="sTokenType" select="'mi'" />
+                    </xsl:call-template>
+                    <xsl:variable name="sOutput" select="translate(substring($sToParse, 1, 1), ' ', '&#xa0;')" />
+                    <xsl:value-of select="$sOutput" />
+                  </mml:mi>
+                </xsl:when>
+                <xsl:otherwise>
+                  <mml:mtext>
+                    <xsl:variable name="sOutput" select="translate(substring($sToParse, 1, 1), ' ', '&#xa0;')" />
+                    <xsl:value-of select="$sOutput" />
+                  </mml:mtext>
+                </xsl:otherwise>
+              </xsl:choose>
+              <xsl:call-template name="ParseEqArrMr">
+                <xsl:with-param name="sToParse" select="substring($sToParse, 2)" />
+                <xsl:with-param name="scr" select="$scr" />
+                <xsl:with-param name="sty" select="$sty" />
+                <xsl:with-param name="nor" select="$nor" />
+                <xsl:with-param name="align" select="$align" />
+              </xsl:call-template>
+            </xsl:when>
+
+            <!-- Case II: There is an operator at position 1 -->
+            <xsl:when test="$fOperAtPos1='1'">
+              <xsl:choose>
+                <xsl:when test="$nor = 0">
+                  <mml:mo>
+                    <xsl:call-template name="CreateTokenAttributes">
+                      <xsl:with-param name="scr" />
+                      <xsl:with-param name="sty" />
+                      <xsl:with-param name="nor" select="$nor" />
+                      <xsl:with-param name="sTokenType" select="'mo'" />
+                    </xsl:call-template>
+                    <xsl:value-of select="substring($sToParse,1,1)" />
+                  </mml:mo>
+                </xsl:when>
+                <xsl:otherwise>
+                  <mml:mtext>
+                    <xsl:value-of select="substring($sToParse,1,1)" />
+                  </mml:mtext>                  
+                </xsl:otherwise>
+              </xsl:choose>
+              <xsl:call-template name="ParseEqArrMr">
+                <xsl:with-param name="sToParse" select="substring($sToParse, 2)" />
+                <xsl:with-param name="scr" select="$scr" />
+                <xsl:with-param name="sty" select="$sty" />
+                <xsl:with-param name="nor" select="$nor" />
+                <xsl:with-param name="align" select="$align" />
+              </xsl:call-template>
+            </xsl:when>
+
+            <!-- Case III: There is a number at position 1 -->
+            <xsl:otherwise>
+              <xsl:variable name="sConsecNum">
+                <xsl:call-template name="SNumStart">
+                  <xsl:with-param name="sToParse" select="$sToParse" />
+                  <xsl:with-param name="sPattern" select="$sRepNumWith0" />
+                </xsl:call-template>
+              </xsl:variable>
+              <xsl:choose>
+                <xsl:when test="$nor = 0">
+                  <mml:mn>
+                    <xsl:call-template name="CreateTokenAttributes">
+                      <xsl:with-param name="scr" />
+                      <xsl:with-param name="sty" select="'p'"/>
+                      <xsl:with-param name="nor" select="$nor" />
+                      <xsl:with-param name="sTokenType" select="'mn'" />
+                    </xsl:call-template>
+                    <xsl:value-of select="$sConsecNum" />
+                  </mml:mn>
+                </xsl:when>
+                <xsl:otherwise>
+                  <mml:mtext>
+                    <xsl:value-of select="$sConsecNum" />
+                  </mml:mtext>
+                </xsl:otherwise>
+              </xsl:choose>
+              <xsl:call-template name="ParseEqArrMr">
+                <xsl:with-param name="sToParse" select="substring-after($sToParse, $sConsecNum)" />
+                <xsl:with-param name="scr" select="$scr" />
+                <xsl:with-param name="sty" select="$sty" />
+                <xsl:with-param name="nor" select="$nor" />
+                <xsl:with-param name="align" select="$align" />
+              </xsl:call-template>
+            </xsl:otherwise>
+          </xsl:choose>
+        </xsl:otherwise>
+      </xsl:choose>
+    </xsl:if>
+  </xsl:template>
+
+  <!-- %%Template: ParseMt
+
+			Produce a run of text. Technically, OMML makes no distinction 
+			between numbers, operators, and other characters in a run. For 
+			MathML we need to break these into mi, mn, or mo elements. 
+			
+			See also ParseEqArrMr
+	-->
+  <xsl:template name="ParseMt">
+    <xsl:param name="sToParse" />
+    <xsl:param name="sty" />
+    <xsl:param name="scr" />
+    <xsl:param name="nor" />
+    <xsl:if test="string-length($sToParse) &gt; 0">
+      <xsl:variable name="sRepNumWith0">
+        <xsl:call-template name="SReplaceNumWithZero">
+          <xsl:with-param name="sToParse" select="$sToParse" />
+        </xsl:call-template>
+      </xsl:variable>
+      <xsl:variable name="sRepOperWith-">
+        <xsl:call-template name="SReplaceOperWithMinus">
+          <xsl:with-param name="sToParse" select="$sRepNumWith0" />
+        </xsl:call-template>
+      </xsl:variable>
+
+      <xsl:variable name="iFirstOper" select="string-length($sRepOperWith-) - string-length(substring-after($sRepOperWith-, '-'))" />
+      <xsl:variable name="iFirstNum" select="string-length($sRepOperWith-) - string-length(substring-after($sRepOperWith-, '0'))" />
+      <xsl:variable name="fNumAtPos1">
+        <xsl:choose>
+          <xsl:when test="substring($sRepOperWith-,1,1)='0'">1</xsl:when>
+          <xsl:otherwise>0</xsl:otherwise>
+        </xsl:choose>
+      </xsl:variable>
+      <xsl:variable name="fOperAtPos1">
+        <xsl:choose>
+          <xsl:when test="substring($sRepOperWith-,1,1)='-'">1</xsl:when>
+          <xsl:otherwise>0</xsl:otherwise>
+        </xsl:choose>
+      </xsl:variable>
+
+      <xsl:choose>
+
+        <!-- Case I: The string begins with neither a number, nor an operator -->
+        <xsl:when test="$fOperAtPos1='0' and $fNumAtPos1='0'">
+          <xsl:variable name="nCharToPrint">
+            <xsl:choose>
+              <xsl:when test="ancestor::m:fName">
+                <xsl:choose>
+                  <xsl:when test="($iFirstOper=$iFirstNum) and 
+											($iFirstOper=string-length($sToParse)) and
+							                (substring($sRepOperWith-, string-length($sRepOperWith-))!='0') and 
+							                (substring($sRepOperWith-, string-length($sRepOperWith-))!='-')">
+                    <xsl:value-of select="string-length($sToParse)" />
+                  </xsl:when>
+                  <xsl:when test="$iFirstOper &lt; $iFirstNum">
+                    <xsl:value-of select="$iFirstOper - 1" />
+                  </xsl:when>
+                  <xsl:otherwise>
+                    <xsl:value-of select="$iFirstNum - 1" />
+                  </xsl:otherwise>
+                </xsl:choose>
+              </xsl:when>
+              <xsl:otherwise>1</xsl:otherwise>
+            </xsl:choose>
+          </xsl:variable>
+
+          <mml:mi>
+            <xsl:call-template name="CreateTokenAttributes">
+              <xsl:with-param name="scr" select="$scr" />
+              <xsl:with-param name="sty" select="$sty" />
+              <xsl:with-param name="nor" select="$nor" />
+              <xsl:with-param name="nCharToPrint" select="$nCharToPrint" />
+              <xsl:with-param name="sTokenType" select="'mi'" />
+            </xsl:call-template>
+            <xsl:variable name="sWrite" select="translate(substring($sToParse, 1, $nCharToPrint), ' ', '&#xa0;')" />
+            <xsl:value-of select="$sWrite" />
+          </mml:mi>
+          <xsl:call-template name="ParseMt">
+            <xsl:with-param name="sToParse" select="substring($sToParse, $nCharToPrint+1)" />
+            <xsl:with-param name="scr" select="$scr" />
+            <xsl:with-param name="sty" select="$sty" />
+            <xsl:with-param name="nor" select="$nor" />
+          </xsl:call-template>
+        </xsl:when>
+
+        <!-- Case II: There is an operator at position 1 -->
+        <xsl:when test="$fOperAtPos1='1'">
+          <mml:mo>
+            <xsl:call-template name="CreateTokenAttributes">
+              <xsl:with-param name="scr" />
+              <xsl:with-param name="sty" />
+              <xsl:with-param name="nor" select="$nor" />
+              <xsl:with-param name="sTokenType" select="'mo'" />
+            </xsl:call-template>
+            <xsl:value-of select="substring($sToParse,1,1)" />
+          </mml:mo>
+          <xsl:call-template name="ParseMt">
+            <xsl:with-param name="sToParse" select="substring($sToParse, 2)" />
+            <xsl:with-param name="scr" select="$scr" />
+            <xsl:with-param name="sty" select="$sty" />
+            <xsl:with-param name="nor" select="$nor" />
+          </xsl:call-template>
+        </xsl:when>
+
+        <!-- Case III: There is a number at position 1 -->
+        <xsl:otherwise>
+          <xsl:variable name="sConsecNum">
+            <xsl:call-template name="SNumStart">
+              <xsl:with-param name="sToParse" select="$sToParse" />
+              <xsl:with-param name="sPattern" select="$sRepNumWith0" />
+            </xsl:call-template>
+          </xsl:variable>
+          <mml:mn>
+            <xsl:call-template name="CreateTokenAttributes">
+              <xsl:with-param name="scr" select="$scr" />
+              <xsl:with-param name="sty" select="'p'" />
+              <xsl:with-param name="nor" select="$nor" />
+              <xsl:with-param name="sTokenType" select="'mn'" />
+            </xsl:call-template>
+            <xsl:value-of select="$sConsecNum" />
+          </mml:mn>
+          <xsl:call-template name="ParseMt">
+            <xsl:with-param name="sToParse" select="substring-after($sToParse, $sConsecNum)" />
+            <xsl:with-param name="scr" select="$scr" />
+            <xsl:with-param name="sty" select="$sty" />
+            <xsl:with-param name="nor" select="$nor" />
+          </xsl:call-template>
+        </xsl:otherwise>
+      </xsl:choose>
+    </xsl:if>
+  </xsl:template>
+
+  <!-- %%Template: SNumStart 
+	
+		Return the longest substring of sToParse starting from the 
+		start of sToParse that is a number. In addition, it takes the
+		pattern string, which is sToParse with all of its numbers 
+		replaced with a 0. sPattern should be the same length 
+		as sToParse		
+	-->
+  <xsl:template name="SNumStart">
+    <xsl:param name="sToParse" select="''" />
+    <!-- if we don't get anything, take the string itself -->
+    <xsl:param name="sPattern" select="'$sToParse'" />
+
+
+    <xsl:choose>
+      <!-- the pattern says this is a number, recurse with the rest -->
+      <xsl:when test="substring($sPattern, 1, 1) = '0'">
+        <xsl:call-template name="SNumStart">
+          <xsl:with-param name="sToParse" select="$sToParse" />
+          <xsl:with-param name="sPattern" select="substring($sPattern, 2)" />
+        </xsl:call-template>
+      </xsl:when>
+
+      <!-- the pattern says we've run out of numbers. Take as many
+				characters from sToParse as we shaved off sPattern -->
+      <xsl:otherwise>
+        <xsl:value-of select="substring($sToParse, 1, string-length($sToParse) - string-length($sPattern))" />
+      </xsl:otherwise>
+    </xsl:choose>
+  </xsl:template>
+
+  <!-- %%Template SRepeatCharAcc
+	
+			The core of SRepeatChar with an accumulator. The current
+			string is in param $acc, and we will double and recurse,
+			if we're less than half of the required length or else just 
+			add the right amount of characters to the accumulator and
+			return
+	-->
+  <xsl:template name="SRepeatCharAcc">
+    <xsl:param name="cchRequired" select="1" />
+    <xsl:param name="ch" select="'-'" />
+    <xsl:param name="acc" select="$ch" />
+
+    <xsl:variable name="cchAcc" select="string-length($acc)" />
+    <xsl:choose>
+      <xsl:when test="(2 * $cchAcc) &lt; $cchRequired">
+        <xsl:call-template name="SRepeatCharAcc">
+          <xsl:with-param name="cchRequired" select="$cchRequired" />
+          <xsl:with-param name="ch" select="$ch" />
+          <xsl:with-param name="acc" select="concat($acc, $acc)" />
+        </xsl:call-template>
+      </xsl:when>
+
+      <xsl:otherwise>
+        <xsl:value-of select="concat($acc, substring($acc, 1, $cchRequired - $cchAcc))" />
+      </xsl:otherwise>
+    </xsl:choose>
+  </xsl:template>
+
+
+  <!-- %%Template SRepeatChar
+	
+			Generates a string nchRequired long by repeating the given character ch
+	-->
+  <xsl:template name="SRepeatChar">
+    <xsl:param name="cchRequired" select="1" />
+    <xsl:param name="ch" select="'-'" />
+
+    <xsl:call-template name="SRepeatCharAcc">
+      <xsl:with-param name="cchRequired" select="$cchRequired" />
+      <xsl:with-param name="ch" select="$ch" />
+      <xsl:with-param name="acc" select="$ch" />
+    </xsl:call-template>
+  </xsl:template>
+
+  <!-- %%Template SReplaceOperWithMinus
+	
+		Go through the given string and replace every instance
+		of an operator with a minus '-'. This helps quickly identify
+		the first instance of an operator.  
+	-->
+  <xsl:template name="SReplaceOperWithMinus">
+    <xsl:param name="sToParse" select="''" />
+
+    <xsl:value-of select="translate($sToParse, $sOperators, $sMinuses)" />
+  </xsl:template>
+
+  <!-- %%Template SReplaceNumWithZero
+	
+		Go through the given string and replace every instance
+		of an number with a zero '0'. This helps quickly identify
+		the first occurence of a number. 
+		
+		Considers the '.' and ',' part of a number iff they are sandwiched 
+		between two other numbers. 0.3 will be recognized as a number,
+		x.3 will not be. Since these characters can also be an operator, this 
+		should be called before SReplaceOperWithMinus.
+	-->
+  <xsl:template name="SReplaceNumWithZero">
+    <xsl:param name="sToParse" select="''" />
+
+    <!-- First do a simple replace. Numbers will all be come 0's.
+			After this point, the pattern involving the . or , that 
+			we are looking for will become 0.0 or 0,0 -->
+    <xsl:variable name="sSimpleReplace" select="translate($sToParse, $sNumbers, $sZeros)" />
+
+    <!-- And then, replace 0.0 with just 000. This means that the . will 
+			become part of the number -->
+    <xsl:variable name="sReplacePeriod">
+      <xsl:call-template name="SReplace">
+        <xsl:with-param name="sInput" select="$sSimpleReplace" />
+        <xsl:with-param name="sOrig" select="'0.0'" />
+        <xsl:with-param name="sReplacement" select="'000'" />
+      </xsl:call-template>
+    </xsl:variable>
+
+    <!-- And then, replace 0,0 with just 000. This means that the , will 
+			become part of the number -->
+    <xsl:call-template name="SReplace">
+      <xsl:with-param name="sInput" select="$sReplacePeriod" />
+      <xsl:with-param name="sOrig" select="'0,0'" />
+      <xsl:with-param name="sReplacement" select="'000'" />
+    </xsl:call-template>
+  </xsl:template>
+
+  <!-- Template to translate Word's borderBox properties into the menclose notation attribute
+       The initial call to this SHOULD NOT pass an sAttribute.  Subsequent calls to 
+       CreateMencloseNotationAttrFromBorderBoxAttr by CreateMencloseNotationAttrFromBorderBoxAttr will
+       update the sAttribute as appropriate.
+       
+       CreateMencloseNotationAttrFromBorderBoxAttr looks at each attribute (fHideTop, fHideBot, etc.) one at a time
+       in the order they are listed and passes a modified sAttribute to CreateMencloseNotationAttrFromBorderBoxAttr.
+       Each successive call to CreateMencloseNotationAttrFromBorderBoxAttr knows which attribute to look at because 
+       the previous call should have omitted passing the attribute it just analyzed.  This is why as you read lower 
+       and lower in the template that each call to CreateMencloseNotationAttrFromBorderBoxAttr has fewer and fewer attributes.
+       -->
+  <xsl:template name="CreateMencloseNotationAttrFromBorderBoxAttr">
+    <xsl:param name="fHideTop" />
+    <xsl:param name="fHideBot" />
+    <xsl:param name="fHideLeft" />
+    <xsl:param name="fHideRight" />
+    <xsl:param name="fStrikeH" />
+    <xsl:param name="fStrikeV" />
+    <xsl:param name="fStrikeBLTR" />
+    <xsl:param name="fStrikeTLBR" />
+    <xsl:param name="sAttribute" />
+
+    <xsl:choose>
+      <xsl:when test="string-length($sAttribute) = 0">
+        <xsl:choose>
+          <xsl:when test="string-length($fHideTop) &gt; 0
+                      and string-length($fHideBot) &gt; 0 
+                      and string-length($fHideLeft) &gt; 0
+                      and string-length($fHideRight) &gt; 0">
+
+            <xsl:choose>
+              <xsl:when test="$fHideTop = 0 
+                              and $fHideBot = 0
+                              and $fHideLeft = 0 
+                              and $fHideRight = 0">
+                <!-- We can use 'box' instead of top, bot, left, and right.  Therefore,
+                  replace sAttribute with 'box' and begin analyzing params fStrikeH
+                  and below. -->
+                <xsl:call-template name="CreateMencloseNotationAttrFromBorderBoxAttr">
+                  <xsl:with-param name="fStrikeH" select="$fStrikeH" />
+                  <xsl:with-param name="fStrikeV" select="$fStrikeV" />
+                  <xsl:with-param name="fStrikeBLTR" select="$fStrikeBLTR" />
+                  <xsl:with-param name="fStrikeTLBR" select="$fStrikeTLBR" />
+                  <xsl:with-param name="sAttribute">
+                    <xsl:text>box</xsl:text>
+                  </xsl:with-param>
+                </xsl:call-template>
+              </xsl:when>
+              <xsl:otherwise>
+                <!-- Can't use 'box', theremore, must analyze all attributes -->
+                <xsl:call-template name="CreateMencloseNotationAttrFromBorderBoxAttr">
+                  <xsl:with-param name="fHideTop" select="$fHideTop" />
+                  <xsl:with-param name="fHideBot" select="$fHideBot" />
+                  <xsl:with-param name="fHideLeft" select="$fHideLeft" />
+                  <xsl:with-param name="fHideRight" select="$fHideRight" />
+                  <xsl:with-param name="fStrikeH" select="$fStrikeH" />
+                  <xsl:with-param name="fStrikeV" select="$fStrikeV" />
+                  <xsl:with-param name="fStrikeBLTR" select="$fStrikeBLTR" />
+                  <xsl:with-param name="fStrikeTLBR" select="$fStrikeTLBR" />
+                  <xsl:with-param name="sAttribute">
+                    <!-- Assume using all four (left right top bottom).  Subsequent calls
+                         will remove the sides which aren't to be includes. -->
+                    <xsl:text>left right top bottom</xsl:text>
+                  </xsl:with-param>
+                </xsl:call-template>
+              </xsl:otherwise>
+            </xsl:choose>
+          </xsl:when>
+        </xsl:choose>
+      </xsl:when>
+      <xsl:otherwise>
+        <xsl:choose>
+          <xsl:when test="string-length($fHideTop) &gt; 0">
+            <xsl:choose>
+              <xsl:when test="$fHideTop=1">
+                <xsl:call-template name="CreateMencloseNotationAttrFromBorderBoxAttr">
+                  <xsl:with-param name="fHideBot" select="$fHideBot" />
+                  <xsl:with-param name="fHideLeft" select="$fHideLeft" />
+                  <xsl:with-param name="fHideRight" select="$fHideRight" />
+                  <xsl:with-param name="fStrikeH" select="$fStrikeH" />
+                  <xsl:with-param name="fStrikeV" select="$fStrikeV" />
+                  <xsl:with-param name="fStrikeBLTR" select="$fStrikeBLTR" />
+                  <xsl:with-param name="fStrikeTLBR" select="$fStrikeTLBR" />
+                  <xsl:with-param name="sAttribute">
+                    <xsl:call-template name="SReplace">
+                      <xsl:with-param name="sInput" select="$sAttribute" />
+                      <xsl:with-param name="sOrig" select="'top'" />
+                      <xsl:with-param name="sReplacement" select="''" />
+                    </xsl:call-template>
+                  </xsl:with-param>
+                </xsl:call-template>
+              </xsl:when>
+              <xsl:otherwise>
+                <xsl:call-template name="CreateMencloseNotationAttrFromBorderBoxAttr">
+                  <xsl:with-param name="fHideBot" select="$fHideBot" />
+                  <xsl:with-param name="fHideLeft" select="$fHideLeft" />
+                  <xsl:with-param name="fHideRight" select="$fHideRight" />
+                  <xsl:with-param name="fStrikeH" select="$fStrikeH" />
+                  <xsl:with-param name="fStrikeV" select="$fStrikeV" />
+                  <xsl:with-param name="fStrikeBLTR" select="$fStrikeBLTR" />
+                  <xsl:with-param name="fStrikeTLBR" select="$fStrikeTLBR" />
+                  <xsl:with-param name="sAttribute" select="$sAttribute" />
+                </xsl:call-template>
+              </xsl:otherwise>
+            </xsl:choose>
+          </xsl:when>
+          <xsl:when test="string-length($fHideBot) &gt; 0">
+            <xsl:choose>
+              <xsl:when test="$fHideBot=1">
+                <xsl:call-template name="CreateMencloseNotationAttrFromBorderBoxAttr">
+                  <xsl:with-param name="fHideLeft" select="$fHideLeft" />
+                  <xsl:with-param name="fHideRight" select="$fHideRight" />
+                  <xsl:with-param name="fStrikeH" select="$fStrikeH" />
+                  <xsl:with-param name="fStrikeV" select="$fStrikeV" />
+                  <xsl:with-param name="fStrikeBLTR" select="$fStrikeBLTR" />
+                  <xsl:with-param name="fStrikeTLBR" select="$fStrikeTLBR" />
+                  <xsl:with-param name="sAttribute">
+                    <xsl:call-template name="SReplace">
+                      <xsl:with-param name="sInput" select="$sAttribute" />
+                      <xsl:with-param name="sOrig" select="'bottom'" />
+                      <xsl:with-param name="sReplacement" select="''" />
+                    </xsl:call-template>
+                  </xsl:with-param>
+                </xsl:call-template>
+              </xsl:when>
+              <xsl:otherwise>
+                <xsl:call-template name="CreateMencloseNotationAttrFromBorderBoxAttr">
+                  <xsl:with-param name="fHideLeft" select="$fHideLeft" />
+                  <xsl:with-param name="fHideRight" select="$fHideRight" />
+                  <xsl:with-param name="fStrikeH" select="$fStrikeH" />
+                  <xsl:with-param name="fStrikeV" select="$fStrikeV" />
+                  <xsl:with-param name="fStrikeBLTR" select="$fStrikeBLTR" />
+                  <xsl:with-param name="fStrikeTLBR" select="$fStrikeTLBR" />
+                  <xsl:with-param name="sAttribute" select="$sAttribute" />
+                </xsl:call-template>
+              </xsl:otherwise>
+            </xsl:choose>
+          </xsl:when>
+          <xsl:when test="string-length($fHideLeft) &gt; 0">
+            <xsl:choose>
+              <xsl:when test="$fHideLeft=1">
+                <xsl:call-template name="CreateMencloseNotationAttrFromBorderBoxAttr">
+                  <xsl:with-param name="fHideRight" select="$fHideRight" />
+                  <xsl:with-param name="fStrikeH" select="$fStrikeH" />
+                  <xsl:with-param name="fStrikeV" select="$fStrikeV" />
+                  <xsl:with-param name="fStrikeBLTR" select="$fStrikeBLTR" />
+                  <xsl:with-param name="fStrikeTLBR" select="$fStrikeTLBR" />
+                  <xsl:with-param name="sAttribute">
+                    <xsl:call-template name="SReplace">
+                      <xsl:with-param name="sInput" select="$sAttribute" />
+                      <xsl:with-param name="sOrig" select="'left'" />
+                      <xsl:with-param name="sReplacement" select="''" />
+                    </xsl:call-template>
+                  </xsl:with-param>
+                </xsl:call-template>
+              </xsl:when>
+              <xsl:otherwise>
+                <xsl:call-template name="CreateMencloseNotationAttrFromBorderBoxAttr">
+                  <xsl:with-param name="fHideRight" select="$fHideRight" />
+                  <xsl:with-param name="fStrikeH" select="$fStrikeH" />
+                  <xsl:with-param name="fStrikeV" select="$fStrikeV" />
+                  <xsl:with-param name="fStrikeBLTR" select="$fStrikeBLTR" />
+                  <xsl:with-param name="fStrikeTLBR" select="$fStrikeTLBR" />
+                  <xsl:with-param name="sAttribute" select="$sAttribute" />
+                </xsl:call-template>
+              </xsl:otherwise>
+            </xsl:choose>
+          </xsl:when>
+          <xsl:when test="string-length($fHideRight) &gt; 0">
+            <xsl:choose>
+              <xsl:when test="$fHideRight=1">
+                <xsl:call-template name="CreateMencloseNotationAttrFromBorderBoxAttr">
+                  <xsl:with-param name="fStrikeH" select="$fStrikeH" />
+                  <xsl:with-param name="fStrikeV" select="$fStrikeV" />
+                  <xsl:with-param name="fStrikeBLTR" select="$fStrikeBLTR" />
+                  <xsl:with-param name="fStrikeTLBR" select="$fStrikeTLBR" />
+                  <xsl:with-param name="sAttribute">
+                    <xsl:call-template name="SReplace">
+                      <xsl:with-param name="sInput" select="$sAttribute" />
+                      <xsl:with-param name="sOrig" select="'right'" />
+                      <xsl:with-param name="sReplacement" select="''" />
+                    </xsl:call-template>
+                  </xsl:with-param>
+                </xsl:call-template>
+              </xsl:when>
+              <xsl:otherwise>
+                <xsl:call-template name="CreateMencloseNotationAttrFromBorderBoxAttr">
+                  <xsl:with-param name="fStrikeH" select="$fStrikeH" />
+                  <xsl:with-param name="fStrikeV" select="$fStrikeV" />
+                  <xsl:with-param name="fStrikeBLTR" select="$fStrikeBLTR" />
+                  <xsl:with-param name="fStrikeTLBR" select="$fStrikeTLBR" />
+                  <xsl:with-param name="sAttribute" select="$sAttribute" />
+                </xsl:call-template>
+              </xsl:otherwise>
+            </xsl:choose>
+          </xsl:when>
+          <xsl:when test="string-length($fStrikeH) &gt; 0">
+            <xsl:choose>
+              <xsl:when test="$fStrikeH=1">
+                <xsl:call-template name="CreateMencloseNotationAttrFromBorderBoxAttr">
+                  <xsl:with-param name="fStrikeV" select="$fStrikeV" />
+                  <xsl:with-param name="fStrikeBLTR" select="$fStrikeBLTR" />
+                  <xsl:with-param name="fStrikeTLBR" select="$fStrikeTLBR" />
+                  <xsl:with-param name="sAttribute" select="concat($sAttribute, ' horizontalstrike')" />
+                </xsl:call-template>
+              </xsl:when>
+              <xsl:otherwise>
+                <xsl:call-template name="CreateMencloseNotationAttrFromBorderBoxAttr">
+                  <xsl:with-param name="fStrikeV" select="$fStrikeV" />
+                  <xsl:with-param name="fStrikeBLTR" select="$fStrikeBLTR" />
+                  <xsl:with-param name="fStrikeTLBR" select="$fStrikeTLBR" />
+                  <xsl:with-param name="sAttribute" select="$sAttribute" />
+                </xsl:call-template>
+              </xsl:otherwise>
+            </xsl:choose>
+          </xsl:when>
+          <xsl:when test="string-length($fStrikeV) &gt; 0">
+            <xsl:choose>
+              <xsl:when test="$fStrikeV=1">
+                <xsl:call-template name="CreateMencloseNotationAttrFromBorderBoxAttr">
+                  <xsl:with-param name="fStrikeBLTR" select="$fStrikeBLTR" />
+                  <xsl:with-param name="fStrikeTLBR" select="$fStrikeTLBR" />
+                  <xsl:with-param name="sAttribute" select="concat($sAttribute, ' verticalstrike')" />
+                </xsl:call-template>
+              </xsl:when>
+              <xsl:otherwise>
+                <xsl:call-template name="CreateMencloseNotationAttrFromBorderBoxAttr">
+                  <xsl:with-param name="fStrikeBLTR" select="$fStrikeBLTR" />
+                  <xsl:with-param name="fStrikeTLBR" select="$fStrikeTLBR" />
+                  <xsl:with-param name="sAttribute" select="$sAttribute" />
+                </xsl:call-template>
+              </xsl:otherwise>
+            </xsl:choose>
+          </xsl:when>
+          <xsl:when test="string-length($fStrikeBLTR) &gt; 0">
+            <xsl:choose>
+              <xsl:when test="$fStrikeBLTR=1">
+                <xsl:call-template name="CreateMencloseNotationAttrFromBorderBoxAttr">
+                  <xsl:with-param name="fStrikeTLBR" select="$fStrikeTLBR" />
+                  <xsl:with-param name="sAttribute" select="concat($sAttribute, ' updiagonalstrike')" />
+                </xsl:call-template>
+              </xsl:when>
+              <xsl:otherwise>
+                <xsl:call-template name="CreateMencloseNotationAttrFromBorderBoxAttr">
+                  <xsl:with-param name="fStrikeTLBR" select="$fStrikeTLBR" />
+                  <xsl:with-param name="sAttribute" select="$sAttribute" />
+                </xsl:call-template>
+              </xsl:otherwise>
+            </xsl:choose>
+          </xsl:when>
+          <xsl:when test="string-length($fStrikeTLBR) &gt; 0">
+            <xsl:choose>
+              <xsl:when test="$fStrikeTLBR=1">
+                <xsl:call-template name="CreateMencloseNotationAttrFromBorderBoxAttr">
+                  <xsl:with-param name="sAttribute" select="concat($sAttribute, ' downdiagonalstrike')" />
+                </xsl:call-template>
+              </xsl:when>
+              <xsl:otherwise>
+                <xsl:call-template name="CreateMencloseNotationAttrFromBorderBoxAttr">
+                  <xsl:with-param name="sAttribute" select="$sAttribute" />
+                </xsl:call-template>
+              </xsl:otherwise>
+            </xsl:choose>
+          </xsl:when>
+          <xsl:otherwise>
+            <xsl:attribute name="notation">
+              <xsl:value-of select="normalize-space($sAttribute)" />
+            </xsl:attribute>
+          </xsl:otherwise>
+        </xsl:choose>
+      </xsl:otherwise>
+    </xsl:choose>
+  </xsl:template>
+
+  <!-- Tristate (true, false, neither) from string value -->
+  <xsl:template name="TFromStrVal">
+    <xsl:param name="str" />
+    <xsl:choose>
+      <xsl:when test="$str = 'on' or $str = '1' or $str = 'true'">1</xsl:when>
+      <xsl:when test="$str = 'off' or $str = '0' or $str = 'false'">0</xsl:when>
+      <xsl:otherwise>-1</xsl:otherwise>
+    </xsl:choose>
+  </xsl:template>
+
+  <!-- Return 0 iff $str is explicitly set to a false value.  
+       Return true otherwise -->
+  <xsl:template name="ForceFalseStrVal">
+    <xsl:param name="str" />
+    <xsl:variable name="tValue">
+      <xsl:call-template name="TFromStrVal">
+        <xsl:with-param name="str" select="$str"/>
+      </xsl:call-template>
+    </xsl:variable>
+    <xsl:choose>
+      <xsl:when test="$tValue = '0'">0</xsl:when>
+      <xsl:otherwise>1</xsl:otherwise>
+    </xsl:choose>
+  </xsl:template>
+
+  <!-- Return 1 iff $str is explicitly set to a true value.  
+       Return false otherwise -->
+  <xsl:template name="ForceTrueStrVal">
+    <xsl:param name="str" />
+    <xsl:variable name="tValue">
+      <xsl:call-template name="TFromStrVal">
+        <xsl:with-param name="str" select="$str"/>
+      </xsl:call-template>
+    </xsl:variable>
+    <xsl:choose>
+      <xsl:when test="$tValue = '1'">1</xsl:when>
+      <xsl:otherwise>0</xsl:otherwise>
+    </xsl:choose>
+  </xsl:template>
+
+  <xsl:template match="m:d">
+    <mrow>
+      <mo>(</mo>
+      <xsl:apply-templates select="m:e"/>
+      <mo>)</mo>
+    </mrow>
+  </xsl:template>
+</xsl:stylesheet>
diff --git a/ruoyi-api/src/main/resources/OMML2MML1.XSL b/ruoyi-api/src/main/resources/OMML2MML1.XSL
new file mode 100644
index 0000000..b46ae33
--- /dev/null
+++ b/ruoyi-api/src/main/resources/OMML2MML1.XSL
@@ -0,0 +1,2068 @@
+<?xml version="1.0" encoding="UTF-8" ?>
+<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform" xmlns:mml="http://www.w3.org/1998/Math/MathML"
+	xmlns:m="http://schemas.openxmlformats.org/officeDocument/2006/math">
+  <xsl:output method="xml" encoding="UTF-16" />
+
+  <!-- %% Global Definitions -->
+
+  <!-- Every single unicode character that is recognized by OMML as an operator -->
+  <xsl:variable name="sOperators"
+		select="concat(
+          '&#x00A8;&#x0021;&#x0022;&#x0023;&#x0026;&#x0028;&#x0029;&#x002B;&#x002C;&#x002D;&#x002E;&#x002F;&#x003A;',
+          '&#x003B;&#x003C;&#x003D;&#x003E;&#x003F;&#x0040;&#x005B;&#x005C;&#x005D;&#x005E;&#x005F;&#x0060;&#x007B;',
+          '&#x007C;&#x007D;&#x007E;&#x00A1;&#x00A6;&#x00AC;&#x00AF;&#x00B0;&#x00B1;&#x00B2;&#x00B3;&#x00B4;&#x00B7;&#x00B9;&#x00BF;',
+          '&#x00D7;&#x007E;&#x00F7;&#x02C7;&#x02D8;&#x02D9;&#x02DC;&#x02DD;&#x0300;&#x0301;&#x0302;&#x0303;&#x0304;&#x0305;&#x0306;&#x0307;&#x0308;&#x0309;',
+          '&#x030A;&#x030B;&#x030C;&#x030D;&#x030E;&#x030F;&#x0310;&#x0311;&#x0312;&#x0313;&#x0314;&#x0315;',
+          '&#x0316;&#x0317;&#x0318;&#x0319;&#x031A;&#x031B;&#x031C;&#x031D;&#x031E;&#x031F;&#x0320;&#x0321;',
+          '&#x0322;&#x0323;&#x0324;&#x0325;&#x0326;&#x0327;&#x0328;&#x0329;&#x032A;&#x032B;&#x032C;&#x032D;',
+          '&#x032E;&#x032F;&#x0330;&#x0331;&#x0332;&#x0333;&#x0334;&#x0335;&#x0336;&#x0337;&#x0338;&#x033F;',
+          '&#x2000;&#x2001;&#x2002;&#x2003;&#x2004;&#x2005;&#x2006;&#x2009;&#x200A;&#x2010;&#x2012;&#x2013;',
+          '&#x2014;&#x2016;&#x2020;&#x2021;&#x2022;&#x2024;&#x2025;&#x2026;&#x2032;&#x2033;&#x2034;&#x203C;',
+          '&#x2040;&#x2044;&#x204E;&#x204F;&#x2050;&#x2057;&#x2061;&#x2062;&#x2063;&#x2070;&#x2074;&#x2075;',
+          '&#x2076;&#x2077;&#x2078;&#x2079;&#x207A;&#x207B;&#x207C;&#x207D;&#x207E;&#x2080;&#x2081;&#x2082;',
+          '&#x2083;&#x2084;&#x2085;&#x2086;&#x2087;&#x2088;&#x2089;&#x208A;&#x208B;&#x208C;&#x208D;&#x208E;',
+          '&#x20D0;&#x20D1;&#x20D2;&#x20D3;&#x20D4;&#x20D5;&#x20D6;&#x20D7;&#x20D8;&#x20D9;&#x20DA;&#x20DB;',
+          '&#x20DC;&#x20DD;&#x20DE;&#x20DF;&#x20E0;&#x20E1;&#x20E4;&#x20E5;&#x20E6;&#x20E7;&#x20E8;&#x20E9;',
+          '&#x20EA;&#x2140;&#x2146;&#x2190;&#x2191;&#x2192;&#x2193;&#x2194;&#x2195;&#x2196;&#x2197;&#x2198;&#x2199;',
+          '&#x219A;&#x219B;&#x219C;&#x219D;&#x219E;&#x219F;&#x21A0;&#x21A1;&#x21A2;&#x21A3;&#x21A4;&#x21A5;',
+          '&#x21A6;&#x21A7;&#x21A8;&#x21A9;&#x21AA;&#x21AB;&#x21AC;&#x21AD;&#x21AE;&#x21AF;&#x21B0;&#x21B1;',
+          '&#x21B2;&#x21B3;&#x21B6;&#x21B7;&#x21BA;&#x21BB;&#x21BC;&#x21BD;&#x21BE;&#x21BF;&#x21C0;&#x21C1;',
+          '&#x21C2;&#x21C3;&#x21C4;&#x21C5;&#x21C6;&#x21C7;&#x21C8;&#x21C9;&#x21CA;&#x21CB;&#x21CC;&#x21CD;',
+          '&#x21CE;&#x21CF;&#x21D0;&#x21D1;&#x21D2;&#x21D3;&#x21D4;&#x21D5;&#x21D6;&#x21D7;&#x21D8;&#x21D9;',
+          '&#x21DA;&#x21DB;&#x21DC;&#x21DD;&#x21DE;&#x21DF;&#x21E0;&#x21E1;&#x21E2;&#x21E3;&#x21E4;&#x21E5;',
+          '&#x21E6;&#x21E7;&#x21E8;&#x21E9;&#x21F3;&#x21F4;&#x21F5;&#x21F6;&#x21F7;&#x21F8;&#x21F9;&#x21FA;',
+          '&#x21FB;&#x21FC;&#x21FD;&#x21FE;&#x21FF;&#x2200;&#x2201;&#x2202;&#x2203;&#x2204;&#x2206;&#x2207;',
+          '&#x2208;&#x2209;&#x220A;&#x220B;&#x220C;&#x220D;&#x220F;&#x2210;&#x2211;&#x2212;&#x2213;&#x2214;',
+          '&#x2215;&#x2216;&#x2217;&#x2218;&#x2219;&#x221A;&#x221B;&#x221C;&#x221D;&#x2223;&#x2224;&#x2225;',
+          '&#x2226;&#x2227;&#x2228;&#x2229;&#x222A;&#x222B;&#x222C;&#x222D;&#x222E;&#x222F;&#x2230;&#x2231;',
+          '&#x2232;&#x2233;&#x2234;&#x2235;&#x2236;&#x2237;&#x2238;&#x2239;&#x223A;&#x223B;&#x223C;&#x223D;',
+          '&#x223E;&#x2240;&#x2241;&#x2242;&#x2243;&#x2244;&#x2245;&#x2246;&#x2247;&#x2248;&#x2249;&#x224A;',
+          '&#x224B;&#x224C;&#x224D;&#x224E;&#x224F;&#x2250;&#x2251;&#x2252;&#x2253;&#x2254;&#x2255;&#x2256;',
+          '&#x2257;&#x2258;&#x2259;&#x225A;&#x225B;&#x225C;&#x225D;&#x225E;&#x225F;&#x2260;&#x2261;&#x2262;',
+          '&#x2263;&#x2264;&#x2265;&#x2266;&#x2267;&#x2268;&#x2269;&#x226A;&#x226B;&#x226C;&#x226D;&#x226E;',
+          '&#x226F;&#x2270;&#x2271;&#x2272;&#x2273;&#x2274;&#x2275;&#x2276;&#x2277;&#x2278;&#x2279;&#x227A;',
+          '&#x227B;&#x227C;&#x227D;&#x227E;&#x227F;&#x2280;&#x2281;&#x2282;&#x2283;&#x2284;&#x2285;&#x2286;',
+          '&#x2287;&#x2288;&#x2289;&#x228A;&#x228B;&#x228C;&#x228D;&#x228E;&#x228F;&#x2290;&#x2291;&#x2292;',
+          '&#x2293;&#x2294;&#x2295;&#x2296;&#x2297;&#x2298;&#x2299;&#x229A;&#x229B;&#x229C;&#x229D;&#x229E;',
+          '&#x229F;&#x22A0;&#x22A1;&#x22A2;&#x22A3;&#x22A5;&#x22A6;&#x22A7;&#x22A8;&#x22A9;&#x22AA;&#x22AB;',
+          '&#x22AC;&#x22AD;&#x22AE;&#x22AF;&#x22B0;&#x22B1;&#x22B2;&#x22B3;&#x22B4;&#x22B5;&#x22B6;&#x22B7;',
+          '&#x22B8;&#x22B9;&#x22BA;&#x22BB;&#x22BC;&#x22BD;&#x22C0;&#x22C1;&#x22C2;&#x22C3;&#x22C4;&#x22C5;',
+          '&#x22C6;&#x22C7;&#x22C8;&#x22C9;&#x22CA;&#x22CB;&#x22CC;&#x22CD;&#x22CE;&#x22CF;&#x22D0;&#x22D1;',
+          '&#x22D2;&#x22D3;&#x22D4;&#x22D5;&#x22D6;&#x22D7;&#x22D8;&#x22D9;&#x22DA;&#x22DB;&#x22DC;&#x22DD;',
+          '&#x22DE;&#x22DF;&#x22E0;&#x22E1;&#x22E2;&#x22E3;&#x22E4;&#x22E5;&#x22E6;&#x22E7;&#x22E8;&#x22E9;',
+          '&#x22EA;&#x22EB;&#x22EC;&#x22ED;&#x22EE;&#x22EF;&#x22F0;&#x22F1;&#x22F2;&#x22F3;&#x22F4;&#x22F5;',
+          '&#x22F6;&#x22F7;&#x22F8;&#x22F9;&#x22FA;&#x22FB;&#x22FC;&#x22FD;&#x22FE;&#x22FF;&#x2305;&#x2306;',
+          '&#x2308;&#x2309;&#x230A;&#x230B;&#x231C;&#x231D;&#x231E;&#x231F;&#x2322;&#x2323;&#x2329;&#x232A;',
+          '&#x233D;&#x233F;&#x23B0;&#x23B1;&#x23DC;&#x23DD;&#x23DE;&#x23DF;&#x23E0;&#x2502;&#x251C;&#x2524;',
+          '&#x252C;&#x2534;&#x2581;&#x2588;&#x2592;&#x25A0;&#x25A1;&#x25AD;&#x25B2;&#x25B3;&#x25B4;&#x25B5;',
+          '&#x25B6;&#x25B7;&#x25B8;&#x25B9;&#x25BC;&#x25BD;&#x25BE;&#x25BF;&#x25C0;&#x25C1;&#x25C2;&#x25C3;',
+          '&#x25C4;&#x25C5;&#x25CA;&#x25CB;&#x25E6;&#x25EB;&#x25EC;&#x25F8;&#x25F9;&#x25FA;&#x25FB;&#x25FC;',
+          '&#x25FD;&#x25FE;&#x25FF;&#x2605;&#x2606;&#x2772;&#x2773;&#x27D1;&#x27D2;&#x27D3;&#x27D4;&#x27D5;',
+          '&#x27D6;&#x27D7;&#x27D8;&#x27D9;&#x27DA;&#x27DB;&#x27DC;&#x27DD;&#x27DE;&#x27DF;&#x27E0;&#x27E1;',
+          '&#x27E2;&#x27E3;&#x27E4;&#x27E5;&#x27E6;&#x27E7;&#x27E8;&#x27E9;&#x27EA;&#x27EB;&#x27F0;&#x27F1;',
+          '&#x27F2;&#x27F3;&#x27F4;&#x27F5;&#x27F6;&#x27F7;&#x27F8;&#x27F9;&#x27FA;&#x27FB;&#x27FC;&#x27FD;',
+          '&#x27FE;&#x27FF;&#x2900;&#x2901;&#x2902;&#x2903;&#x2904;&#x2905;&#x2906;&#x2907;&#x2908;&#x2909;',
+          '&#x290A;&#x290B;&#x290C;&#x290D;&#x290E;&#x290F;&#x2910;&#x2911;&#x2912;&#x2913;&#x2914;&#x2915;',
+          '&#x2916;&#x2917;&#x2918;&#x2919;&#x291A;&#x291B;&#x291C;&#x291D;&#x291E;&#x291F;&#x2920;&#x2921;',
+          '&#x2922;&#x2923;&#x2924;&#x2925;&#x2926;&#x2927;&#x2928;&#x2929;&#x292A;&#x292B;&#x292C;&#x292D;',
+          '&#x292E;&#x292F;&#x2930;&#x2931;&#x2932;&#x2933;&#x2934;&#x2935;&#x2936;&#x2937;&#x2938;&#x2939;',
+          '&#x293A;&#x293B;&#x293C;&#x293D;&#x293E;&#x293F;&#x2940;&#x2941;&#x2942;&#x2943;&#x2944;&#x2945;',
+          '&#x2946;&#x2947;&#x2948;&#x2949;&#x294A;&#x294B;&#x294C;&#x294D;&#x294E;&#x294F;&#x2950;&#x2951;',
+          '&#x2952;&#x2953;&#x2954;&#x2955;&#x2956;&#x2957;&#x2958;&#x2959;&#x295A;&#x295B;&#x295C;&#x295D;',
+          '&#x295E;&#x295F;&#x2960;&#x2961;&#x2962;&#x2963;&#x2964;&#x2965;&#x2966;&#x2967;&#x2968;&#x2969;',
+          '&#x296A;&#x296B;&#x296C;&#x296D;&#x296E;&#x296F;&#x2970;&#x2971;&#x2972;&#x2973;&#x2974;&#x2975;',
+          '&#x2976;&#x2977;&#x2978;&#x2979;&#x297A;&#x297B;&#x297C;&#x297D;&#x297E;&#x297F;&#x2980;&#x2982;',
+          '&#x2983;&#x2984;&#x2985;&#x2986;&#x2987;&#x2988;&#x2989;&#x298A;&#x298B;&#x298C;&#x298D;&#x298E;',
+          '&#x298F;&#x2990;&#x2991;&#x2992;&#x2993;&#x2994;&#x2995;&#x2996;&#x2997;&#x2998;&#x2999;&#x299A;',
+          '&#x29B6;&#x29B7;&#x29B8;&#x29B9;&#x29C0;&#x29C1;&#x29C4;&#x29C5;&#x29C6;&#x29C7;&#x29C8;&#x29CE;',
+          '&#x29CF;&#x29D0;&#x29D1;&#x29D2;&#x29D3;&#x29D4;&#x29D5;&#x29D6;&#x29D7;&#x29D8;&#x29D9;&#x29DA;',
+          '&#x29DB;&#x29DF;&#x29E1;&#x29E2;&#x29E3;&#x29E4;&#x29E5;&#x29E6;&#x29EB;&#x29F4;&#x29F5;&#x29F6;',
+          '&#x29F7;&#x29F8;&#x29F9;&#x29FA;&#x29FB;&#x29FC;&#x29FD;&#x29FE;&#x29FF;&#x2A00;&#x2A01;&#x2A02;',
+          '&#x2A03;&#x2A04;&#x2A05;&#x2A06;&#x2A07;&#x2A08;&#x2A09;&#x2A0A;&#x2A0B;&#x2A0C;&#x2A0D;&#x2A0E;',
+          '&#x2A0F;&#x2A10;&#x2A11;&#x2A12;&#x2A13;&#x2A14;&#x2A15;&#x2A16;&#x2A17;&#x2A18;&#x2A19;&#x2A1A;',
+          '&#x2A1B;&#x2A1C;&#x2A1D;&#x2A1E;&#x2A1F;&#x2A20;&#x2A21;&#x2A22;&#x2A23;&#x2A24;&#x2A25;&#x2A26;',
+          '&#x2A27;&#x2A28;&#x2A29;&#x2A2A;&#x2A2B;&#x2A2C;&#x2A2D;&#x2A2E;&#x2A2F;&#x2A30;&#x2A31;&#x2A32;',
+          '&#x2A33;&#x2A34;&#x2A35;&#x2A36;&#x2A37;&#x2A38;&#x2A39;&#x2A3A;&#x2A3B;&#x2A3C;&#x2A3D;&#x2A3E;',
+          '&#x2A3F;&#x2A40;&#x2A41;&#x2A42;&#x2A43;&#x2A44;&#x2A45;&#x2A46;&#x2A47;&#x2A48;&#x2A49;&#x2A4A;',
+          '&#x2A4B;&#x2A4C;&#x2A4D;&#x2A4E;&#x2A4F;&#x2A50;&#x2A51;&#x2A52;&#x2A53;&#x2A54;&#x2A55;&#x2A56;',
+          '&#x2A57;&#x2A58;&#x2A59;&#x2A5A;&#x2A5B;&#x2A5C;&#x2A5D;&#x2A5E;&#x2A5F;&#x2A60;&#x2A61;&#x2A62;',
+          '&#x2A63;&#x2A64;&#x2A65;&#x2A66;&#x2A67;&#x2A68;&#x2A69;&#x2A6A;&#x2A6B;&#x2A6C;&#x2A6D;&#x2A6E;',
+          '&#x2A6F;&#x2A70;&#x2A71;&#x2A72;&#x2A73;&#x2A74;&#x2A75;&#x2A76;&#x2A77;&#x2A78;&#x2A79;&#x2A7A;',
+          '&#x2A7B;&#x2A7C;&#x2A7D;&#x2A7E;&#x2A7F;&#x2A80;&#x2A81;&#x2A82;&#x2A83;&#x2A84;&#x2A85;&#x2A86;',
+          '&#x2A87;&#x2A88;&#x2A89;&#x2A8A;&#x2A8B;&#x2A8C;&#x2A8D;&#x2A8E;&#x2A8F;&#x2A90;&#x2A91;&#x2A92;',
+          '&#x2A93;&#x2A94;&#x2A95;&#x2A96;&#x2A97;&#x2A98;&#x2A99;&#x2A9A;&#x2A9B;&#x2A9C;&#x2A9D;&#x2A9E;',
+          '&#x2A9F;&#x2AA0;&#x2AA1;&#x2AA2;&#x2AA3;&#x2AA4;&#x2AA5;&#x2AA6;&#x2AA7;&#x2AA8;&#x2AA9;&#x2AAA;',
+          '&#x2AAB;&#x2AAC;&#x2AAD;&#x2AAE;&#x2AAF;&#x2AB0;&#x2AB1;&#x2AB2;&#x2AB3;&#x2AB4;&#x2AB5;&#x2AB6;',
+          '&#x2AB7;&#x2AB8;&#x2AB9;&#x2ABA;&#x2ABB;&#x2ABC;&#x2ABD;&#x2ABE;&#x2ABF;&#x2AC0;&#x2AC1;&#x2AC2;',
+          '&#x2AC3;&#x2AC4;&#x2AC5;&#x2AC6;&#x2AC7;&#x2AC8;&#x2AC9;&#x2ACA;&#x2ACB;&#x2ACC;&#x2ACD;&#x2ACE;',
+          '&#x2ACF;&#x2AD0;&#x2AD1;&#x2AD2;&#x2AD3;&#x2AD4;&#x2AD5;&#x2AD6;&#x2AD7;&#x2AD8;&#x2AD9;&#x2ADA;',
+          '&#x2ADB;&#x2ADC;&#x2ADD;&#x2ADE;&#x2ADF;&#x2AE0;&#x2AE2;&#x2AE3;&#x2AE4;&#x2AE5;&#x2AE6;&#x2AE7;',
+          '&#x2AE8;&#x2AE9;&#x2AEA;&#x2AEB;&#x2AEC;&#x2AED;&#x2AEE;&#x2AEF;&#x2AF0;&#x2AF2;&#x2AF3;&#x2AF4;',
+          '&#x2AF5;&#x2AF6;&#x2AF7;&#x2AF8;&#x2AF9;&#x2AFA;&#x2AFB;&#x2AFC;&#x2AFD;&#x2AFE;&#x2AFF;&#x2B04;',
+          '&#x2B06;&#x2B07;&#x2B0C;&#x2B0D;&#x3014;&#x3015;&#x3016;&#x3017;&#x3018;&#x3019;&#xFF01;&#xFF06;',
+          '&#xFF08;&#xFF09;&#xFF0B;&#xFF0C;&#xFF0D;&#xFF0E;&#xFF0F;&#xFF1A;&#xFF1B;&#xFF1C;&#xFF1D;&#xFF1E;',
+          '&#xFF1F;&#xFF20;&#xFF3B;&#xFF3C;&#xFF3D;&#xFF3E;&#xFF3F;&#xFF5B;&#xFF5C;&#xFF5D;')" />
+
+  <!-- A string of '-'s repeated exactly as many times as the operators above -->
+  <xsl:variable name="sMinuses">
+    <xsl:call-template name="SRepeatChar">
+      <xsl:with-param name="cchRequired" select="string-length($sOperators)" />
+      <xsl:with-param name="ch" select="'-'" />
+    </xsl:call-template>
+  </xsl:variable>
+
+  <!-- Every single unicode character that is recognized by OMML as a number -->
+  <xsl:variable name="sNumbers" select="'0123456789'" />
+
+  <!-- A string of '0's repeated exactly as many times as the list of numbers above -->
+  <xsl:variable name="sZeros">
+    <xsl:call-template name="SRepeatChar">
+      <xsl:with-param name="cchRequired" select="string-length($sNumbers)" />
+      <xsl:with-param name="ch" select="'0'" />
+    </xsl:call-template>
+  </xsl:variable>
+
+  <!-- %%Template: SReplace
+
+		Replace all occurences of sOrig in sInput with sReplacement
+		and return the resulting string. -->
+  <xsl:template name="SReplace">
+    <xsl:param name="sInput" />
+    <xsl:param name="sOrig" />
+    <xsl:param name="sReplacement" />
+
+    <xsl:choose>
+      <xsl:when test="not(contains($sInput, $sOrig))">
+        <xsl:value-of select="$sInput" />
+      </xsl:when>
+      <xsl:otherwise>
+        <xsl:variable name="sBefore" select="substring-before($sInput, $sOrig)" />
+        <xsl:variable name="sAfter" select="substring-after($sInput, $sOrig)" />
+        <xsl:variable name="sAfterProcessed">
+          <xsl:call-template name="SReplace">
+            <xsl:with-param name="sInput" select="$sAfter" />
+            <xsl:with-param name="sOrig" select="$sOrig" />
+            <xsl:with-param name="sReplacement" select="$sReplacement" />
+          </xsl:call-template>
+        </xsl:variable>
+
+        <xsl:value-of select="concat($sBefore, concat($sReplacement, $sAfterProcessed))" />
+      </xsl:otherwise>
+    </xsl:choose>
+  </xsl:template>
+
+  <!-- Templates -->
+  <xsl:template match="/">
+    <mml:math>
+      <xsl:apply-templates select="*" />
+    </mml:math>
+  </xsl:template>
+
+  <xsl:template match="m:borderBox">
+
+    <!-- Get Lowercase versions of properties -->
+    <xsl:variable name="sLowerCaseHideTop" select="translate(m:borderBoxPr[last()]/m:hideTop[last()]/@m:val, 'ABCDEFGHIJKLMNOPQRSTUVWXYZ', 
+		                                                             'abcdefghijklmnopqrstuvwxyz')" />
+    <xsl:variable name="sLowerCaseHideBot" select="translate(m:borderBoxPr[last()]/m:hideBot[last()]/@m:val, 'ABCDEFGHIJKLMNOPQRSTUVWXYZ', 
+		                                                             'abcdefghijklmnopqrstuvwxyz')" />
+    <xsl:variable name="sLowerCaseHideLeft" select="translate(m:borderBoxPr[last()]/m:hideLeft[last()]/@m:val, 'ABCDEFGHIJKLMNOPQRSTUVWXYZ', 
+		                                                             'abcdefghijklmnopqrstuvwxyz')" />
+    <xsl:variable name="sLowerCaseHideRight" select="translate(m:borderBoxPr[last()]/m:hideRight[last()]/@m:val, 'ABCDEFGHIJKLMNOPQRSTUVWXYZ', 
+		                                                             'abcdefghijklmnopqrstuvwxyz')" />
+    <xsl:variable name="sLowerCaseStrikeH" select="translate(m:borderBoxPr[last()]/m:strikeH[last()]/@m:val, 'ABCDEFGHIJKLMNOPQRSTUVWXYZ', 
+		                                                             'abcdefghijklmnopqrstuvwxyz')" />
+    <xsl:variable name="sLowerCaseStrikeV" select="translate(m:borderBoxPr[last()]/m:strikeV[last()]/@m:val, 'ABCDEFGHIJKLMNOPQRSTUVWXYZ', 
+		                                                             'abcdefghijklmnopqrstuvwxyz')" />
+    <xsl:variable name="sLowerCaseStrikeBLTR" select="translate(m:borderBoxPr[last()]/m:strikeBLTR[last()]/@m:val, 'ABCDEFGHIJKLMNOPQRSTUVWXYZ', 
+		                                                             'abcdefghijklmnopqrstuvwxyz')" />
+    <xsl:variable name="sLowerCaseStrikeTLBR" select="translate(m:borderBoxPr[last()]/m:strikeTLBR[last()]/@m:val, 'ABCDEFGHIJKLMNOPQRSTUVWXYZ', 
+		                                                             'abcdefghijklmnopqrstuvwxyz')" />
+    <xsl:variable name="fHideTop">
+      <xsl:call-template name="ForceTrueStrVal">
+        <xsl:with-param name="str" select="$sLowerCaseHideTop" />
+      </xsl:call-template>
+    </xsl:variable>
+    <xsl:variable name="fHideBot">
+      <xsl:call-template name="ForceTrueStrVal">
+        <xsl:with-param name="str" select="$sLowerCaseHideBot" />
+      </xsl:call-template>
+    </xsl:variable>
+    <xsl:variable name="fHideLeft">
+      <xsl:call-template name="ForceTrueStrVal">
+        <xsl:with-param name="str" select="$sLowerCaseHideLeft" />
+      </xsl:call-template>
+    </xsl:variable>
+    <xsl:variable name="fHideRight">
+      <xsl:call-template name="ForceTrueStrVal">
+        <xsl:with-param name="str" select="$sLowerCaseHideRight" />
+      </xsl:call-template>
+    </xsl:variable>
+    <xsl:variable name="fStrikeH">
+      <xsl:call-template name="ForceTrueStrVal">
+        <xsl:with-param name="str" select="$sLowerCaseStrikeH" />
+      </xsl:call-template>
+    </xsl:variable>
+    <xsl:variable name="fStrikeV">
+      <xsl:call-template name="ForceTrueStrVal">
+        <xsl:with-param name="str" select="$sLowerCaseStrikeV" />
+      </xsl:call-template>
+    </xsl:variable>
+    <xsl:variable name="fStrikeBLTR">
+      <xsl:call-template name="ForceTrueStrVal">
+        <xsl:with-param name="str" select="$sLowerCaseStrikeBLTR" />
+      </xsl:call-template>
+    </xsl:variable>
+    <xsl:variable name="fStrikeTLBR">
+      <xsl:call-template name="ForceTrueStrVal">
+        <xsl:with-param name="str" select="$sLowerCaseStrikeTLBR" />
+      </xsl:call-template>
+    </xsl:variable>
+
+    <xsl:choose>
+      <xsl:when test="$fHideTop=1 
+                      and $fHideBot=1 
+                      and $fHideLeft=1 
+                      and $fHideRight=1 
+                      and $fStrikeH=0 
+                      and $fStrikeV=0 
+                      and $fStrikeBLTR=0 
+                      and $fStrikeTLBR=0">
+        <mml:mrow>
+          <xsl:apply-templates select="m:e[1]" />
+        </mml:mrow>
+      </xsl:when>
+      <xsl:otherwise>
+        <mml:menclose>
+          <xsl:call-template name="CreateMencloseNotationAttrFromBorderBoxAttr">
+            <xsl:with-param name="fHideTop" select="$fHideTop" />
+            <xsl:with-param name="fHideBot" select="$fHideBot" />
+            <xsl:with-param name="fHideLeft" select="$fHideLeft" />
+            <xsl:with-param name="fHideRight" select="$fHideRight" />
+            <xsl:with-param name="fStrikeH" select="$fStrikeH" />
+            <xsl:with-param name="fStrikeV" select="$fStrikeV" />
+            <xsl:with-param name="fStrikeBLTR" select="$fStrikeBLTR" />
+            <xsl:with-param name="fStrikeTLBR" select="$fStrikeTLBR" />
+          </xsl:call-template>
+          <xsl:apply-templates select="m:e[1]" />
+        </mml:menclose>
+      </xsl:otherwise>
+    </xsl:choose>
+  </xsl:template>
+
+  <xsl:template match="*">
+    <xsl:apply-templates select="*" />
+  </xsl:template>
+
+  <!--
+      { Non-combining, Upper-combining, Lower-combining }
+      {U+02D8, U+0306, U+032E}, // BREVE
+      {U+00B8, U+0312, U+0327}, // CEDILLA
+      {U+0060, U+0300, U+0316}, // GRAVE ACCENT
+      {U+002D, U+0305, U+0332}, // HYPHEN-MINUS/OVERLINE
+      {U+2212, U+0305, U+0332}, // MINUS SIGN/OVERLINE
+      {U+002E, U+0305, U+0323}, // FULL STOP/DOT ABOVE
+      {U+02D9, U+0307, U+0323}, // DOT ABOVE
+      {U+02DD, U+030B, U+02DD}, // DOUBLE ACUTE ACCENT
+      {U+00B4, U+0301, U+0317}, // ACUTE ACCENT
+      {U+007E, U+0303, U+0330}, // TILDE
+      {U+02DC, U+0303, U+0330}, // SMALL TILDE
+      {U+00A8, U+0308, U+0324}, // DIAERESIS
+      {U+02C7, U+030C, U+032C}, // CARON
+      {U+005E, U+0302, U+032D}, // CIRCUMFLEX ACCENT
+      {U+00AF, U+0305, ::::::}, // MACRON
+      {U+005F, ::::::, U+0332}, // LOW LINE
+      {U+2192, U+20D7, U+20EF}, // RIGHTWARDS ARROW
+      {U+27F6, U+20D7, U+20EF}, // LONG RIGHTWARDS ARROW
+      {U+2190, U+20D6, U+20EE}, // LEFT ARROW
+  -->
+  <xsl:template name="ToNonCombining">
+    <xsl:param name="ch" />
+    <xsl:choose>
+      <!-- BREVE -->
+      <xsl:when test="$ch='&#x0306;' or $ch='&#x032e;'">&#x02D8;</xsl:when>
+      <!-- CEDILLA -->
+      <xsl:when test="$ch='&#x0312;' or $ch='&#x0327;'">&#x00B8;</xsl:when>
+      <!-- GRAVE ACCENT -->
+      <xsl:when test="$ch='&#x0300;' or $ch='&#x0316;'">&#x0060;</xsl:when>
+      <!-- HYPHEN-MINUS/OVERLINE -->
+      <xsl:when test="$ch='&#x0305;' or $ch='&#x0332;'">&#x002D;</xsl:when>
+      <!-- MINUS SIGN/OVERLINE -->
+      <xsl:when test="$ch='&#x0305;' or $ch='&#x0332;'">&#x2212;</xsl:when>
+      <!-- FULL STOP/DOT ABOVE -->
+      <xsl:when test="$ch='&#x0305;' or $ch='&#x0323;'">&#x002E;</xsl:when>
+      <!-- DOT ABOVE -->
+      <xsl:when test="$ch='&#x0307;' or $ch='&#x0323;'">&#x02D9;</xsl:when>
+      <!-- DOUBLE ACUTE ACCENT -->
+      <xsl:when test="$ch='&#x030B;' or $ch='&#x02DD;'">&#x02DD;</xsl:when>
+      <!-- ACUTE ACCENT -->
+      <xsl:when test="$ch='&#x0301;' or $ch='&#x0317;'">&#x00B4;</xsl:when>
+      <!-- TILDE -->
+      <xsl:when test="$ch='&#x0303;' or $ch='&#x0330;'">&#x007E;</xsl:when>
+      <!-- SMALL TILDE -->
+      <xsl:when test="$ch='&#x0303;' or $ch='&#x0330;'">&#x02DC;</xsl:when>
+      <!-- DIAERESIS -->
+      <xsl:when test="$ch='&#x0308;' or $ch='&#x0324;'">&#x00A8;</xsl:when>
+      <!-- CARON -->
+      <xsl:when test="$ch='&#x030C;' or $ch='&#x032C;'">&#x02C7;</xsl:when>
+      <!-- CIRCUMFLEX ACCENT -->
+      <xsl:when test="$ch='&#x0302;' or $ch='&#x032D;'">&#x005E;</xsl:when>
+      <!-- MACRON -->
+      <xsl:when test="$ch='&#x0305;'                   ">&#x00AF;</xsl:when>
+      <!-- LOW LINE -->
+      <xsl:when test="                   $ch='&#x0332;'">&#x005F;</xsl:when>
+      <!-- RIGHTWARDS ARROW -->
+      <xsl:when test="$ch='&#x20D7;' or $ch='&#x20EF;'">&#x2192;</xsl:when>
+      <!-- LONG RIGHTWARDS ARROW -->
+      <xsl:when test="$ch='&#x20D7;' or $ch='&#x20EF;'">&#x27F6;</xsl:when>
+      <!-- LEFT ARROW -->
+      <xsl:when test="$ch='&#x20D6;' or $ch='&#x20EE;'">&#x2190;</xsl:when>
+      <xsl:otherwise>
+        <xsl:value-of select="$ch"/>
+      </xsl:otherwise>
+    </xsl:choose>
+  </xsl:template>
+
+  <xsl:template match="m:acc">
+    <mml:mover>
+      <xsl:attribute name="accent">true</xsl:attribute>
+      <mml:mrow>
+        <xsl:apply-templates select="m:e[1]" />
+      </mml:mrow>
+      <xsl:variable name="chAcc">
+        <xsl:choose>
+          <xsl:when test="not(m:accPr[last()]/m:chr)">
+            <xsl:value-of select="'&#x0302;'" />
+          </xsl:when>
+          <xsl:otherwise>
+            <xsl:value-of select="substring(m:accPr/m:chr/@m:val,1,1)" />
+          </xsl:otherwise>
+        </xsl:choose>
+      </xsl:variable>
+      <xsl:variable name="chNonComb">
+        <xsl:call-template name="ToNonCombining">
+          <xsl:with-param name="ch" select="$chAcc" />
+        </xsl:call-template>
+      </xsl:variable>
+      <xsl:choose>
+        <xsl:when test="string-length($chAcc)=0">
+          <mml:mo/>
+        </xsl:when>
+        <xsl:otherwise>
+          <xsl:call-template name="ParseMt">
+            <xsl:with-param name="sToParse" select="$chNonComb" />
+            <xsl:with-param name="scr" select="m:e[1]/*/m:rPr[last()]/m:scr/@m:val" />
+            <xsl:with-param name="sty" select="m:e[1]/*/m:rPr[last()]/m:sty/@m:val" />
+            <xsl:with-param name="nor">
+              <xsl:choose>
+                <xsl:when test="count(m:e[1]/*/m:rPr[last()]/m:nor) = 0">0</xsl:when>
+                <xsl:otherwise>
+                  <xsl:call-template name="ForceFalseStrVal">
+                    <xsl:with-param name="str" select="translate(m:e[1]/*/m:rPr[last()]/m:nor/@m:val, 
+                                                                     'ABCDEFGHIJKLMNOPQRSTUVWXYZ', 
+		                                                                 'abcdefghijklmnopqrstuvwxyz')" />
+                  </xsl:call-template>
+                </xsl:otherwise>
+              </xsl:choose>
+            </xsl:with-param>
+          </xsl:call-template>
+        </xsl:otherwise>
+      </xsl:choose>
+    </mml:mover>
+  </xsl:template>
+
+  <xsl:template name="OutputScript">
+    <xsl:param name="ndCur" select="." />
+    <xsl:choose>
+      <!-- Only output contents of $ndCur if $ndCur exists
+           and $ndCur has children -->
+      <xsl:when test="count($ndCur/*) &gt; 0">
+        <mml:mrow>
+          <xsl:apply-templates select="$ndCur" />
+        </mml:mrow>
+      </xsl:when>
+      <xsl:otherwise>
+        <mml:none />
+      </xsl:otherwise>
+    </xsl:choose>
+  </xsl:template>
+
+  <xsl:template match="m:sPre">
+    <mml:mmultiscripts>
+      <mml:mrow>
+        <xsl:apply-templates select="m:e[1]" />
+      </mml:mrow>
+      <mml:mprescripts />
+      <xsl:call-template name="OutputScript">
+        <xsl:with-param name="ndCur" select="m:sub[1]"/>
+      </xsl:call-template>
+      <xsl:call-template name="OutputScript">
+        <xsl:with-param name="ndCur" select="m:sup[1]" />
+      </xsl:call-template>
+    </mml:mmultiscripts>
+  </xsl:template>
+
+  <xsl:template match="m:m">
+    <mml:mtable>
+      <xsl:call-template name="CreateMathMLMatrixAttr">
+        <xsl:with-param name="mcJc" select="m:mPr[last()]/m:mcs/m:mc/m:mcPr[last()]/m:mcJc/@m:val" />
+      </xsl:call-template>
+      <xsl:for-each select="m:mr">
+        <mml:mtr>
+          <xsl:for-each select="m:e">
+            <mml:mtd>
+              <xsl:apply-templates select="." />
+            </mml:mtd>
+          </xsl:for-each>
+        </mml:mtr>
+      </xsl:for-each>
+    </mml:mtable>
+  </xsl:template>
+
+  <xsl:template name="CreateMathMLMatrixAttr">
+    <xsl:param name="mcJc" />
+    <xsl:variable name="sLowerCaseMcjc" select="translate($mcJc, 'ABCDEFGHIJKLMNOPQRSTUVWXYZ', 
+		                                                             'abcdefghijklmnopqrstuvwxyz')" />
+    <xsl:choose>
+      <xsl:when test="$sLowerCaseMcjc='left'">
+        <xsl:attribute name="columnalign">left</xsl:attribute>
+      </xsl:when>
+      <xsl:when test="$sLowerCaseMcjc='right'">
+        <xsl:attribute name="columnalign">right</xsl:attribute>
+      </xsl:when>
+    </xsl:choose>
+  </xsl:template>
+
+  <xsl:template match="m:phant">
+    <xsl:variable name="sLowerCaseZeroWidVal" select="translate(m:phantPr[last()]/m:zeroWid[last()]/@m:val, 
+		                                                       'ABCDEFGHIJKLMNOPQRSTUVWXYZ', 
+		                                                       'abcdefghijklmnopqrstuvwxyz')" />
+    <xsl:variable name="sLowerCaseZeroAscVal" select="translate(m:phantPr[last()]/m:zeroAsc[last()]/@m:val, 
+		                                                     'ABCDEFGHIJKLMNOPQRSTUVWXYZ', 
+		                                                     'abcdefghijklmnopqrstuvwxyz')" />
+    <xsl:variable name="sLowerCaseZeroDescVal" select="translate(m:phantPr[last()]/m:zeroDesc[last()]/@m:val, 
+		                                                     'ABCDEFGHIJKLMNOPQRSTUVWXYZ', 
+		                                                     'abcdefghijklmnopqrstuvwxyz')" />
+    <xsl:variable name="sLowerCaseShowVal" select="translate(m:phantPr[last()]/m:show[last()]/@m:val, 
+		                                                     'ABCDEFGHIJKLMNOPQRSTUVWXYZ', 
+		                                                     'abcdefghijklmnopqrstuvwxyz')" />
+
+
+    <!-- The following properties default to 'yes' unless the last value equals 'no' or there isn't any node for 
+         the property -->
+
+    <xsl:variable name="fZeroWid">
+      <xsl:choose>
+        <xsl:when test="count(m:phantPr[last()]/m:zeroWid[last()]) = 0">0</xsl:when>
+        <xsl:otherwise>
+          <xsl:call-template name="ForceFalseStrVal">
+            <xsl:with-param name="str" select="$sLowerCaseZeroWidVal" />
+          </xsl:call-template>
+        </xsl:otherwise>
+      </xsl:choose>
+    </xsl:variable>
+    <xsl:variable name="fZeroAsc">
+      <xsl:choose>
+        <xsl:when test="count(m:phantPr[last()]/m:zeroAsc[last()]) = 0">0</xsl:when>
+        <xsl:otherwise>
+          <xsl:call-template name="ForceFalseStrVal">
+            <xsl:with-param name="str" select="$sLowerCaseZeroAscVal" />
+          </xsl:call-template>
+        </xsl:otherwise>
+      </xsl:choose>
+    </xsl:variable>
+    <xsl:variable name="fZeroDesc">
+      <xsl:choose>
+        <xsl:when test="count(m:phantPr[last()]/m:zeroDesc[last()]) = 0">0</xsl:when>
+        <xsl:otherwise>
+          <xsl:call-template name="ForceFalseStrVal">
+            <xsl:with-param name="str" select="$sLowerCaseZeroDescVal" />
+          </xsl:call-template>
+        </xsl:otherwise>
+      </xsl:choose>
+    </xsl:variable>
+
+    <!-- The show property defaults to 'on' unless there exists a show property and its value is 'off' -->
+
+    <xsl:variable name="fShow">
+      <xsl:call-template name="ForceFalseStrVal">
+        <xsl:with-param name="str" select="$sLowerCaseShowVal" />
+      </xsl:call-template>
+    </xsl:variable>
+
+    <xsl:choose>
+      <!-- Show the phantom contents, therefore, just use mpadded. -->
+      <xsl:when test="$fShow = 1">
+        <xsl:element name="mml:mpadded">
+          <xsl:call-template name="CreateMpaddedAttributes">
+            <xsl:with-param name="fZeroWid" select="$fZeroWid" />
+            <xsl:with-param name="fZeroAsc" select="$fZeroAsc" />
+            <xsl:with-param name="fZeroDesc" select="$fZeroDesc" />
+          </xsl:call-template>
+          <mml:mrow>
+            <xsl:apply-templates select="m:e" />
+          </mml:mrow>
+        </xsl:element>
+      </xsl:when>
+      <!-- Don't show phantom contents, but don't smash anything, therefore, just 
+           use mphantom -->
+      <xsl:when test="$fZeroWid=0 and $fZeroAsc=0 and $fZeroDesc=0">
+        <xsl:element name="mml:mphantom">
+          <mml:mrow>
+            <xsl:apply-templates select="m:e" />
+          </mml:mrow>
+        </xsl:element>
+      </xsl:when>
+      <!-- Combination -->
+      <xsl:otherwise>
+        <xsl:element name="mml:mphantom">
+          <xsl:element name="mml:mpadded">
+            <xsl:call-template name="CreateMpaddedAttributes">
+              <xsl:with-param name="fZeroWid" select="$fZeroWid" />
+              <xsl:with-param name="fZeroAsc" select="$fZeroAsc" />
+              <xsl:with-param name="fZeroDesc" select="$fZeroDesc" />
+            </xsl:call-template>
+            <mml:mrow>
+              <xsl:apply-templates select="m:e" />
+            </mml:mrow>
+          </xsl:element>
+        </xsl:element>
+      </xsl:otherwise>
+    </xsl:choose>
+  </xsl:template>
+
+  <xsl:template name="CreateMpaddedAttributes">
+    <xsl:param name="fZeroWid" />
+    <xsl:param name="fZeroAsc" />
+    <xsl:param name="fZeroDesc" />
+
+    <xsl:if test="$fZeroWid=1">
+      <xsl:attribute name="width">0in</xsl:attribute>
+    </xsl:if>
+    <xsl:if test="$fZeroAsc=1">
+      <xsl:attribute name="height">0in</xsl:attribute>
+    </xsl:if>
+    <xsl:if test="$fZeroDesc=1">
+      <xsl:attribute name="depth">0in</xsl:attribute>
+    </xsl:if>
+  </xsl:template>
+
+
+
+  <xsl:template match="m:rad">
+    <xsl:variable name="fDegHide">
+      <xsl:choose>
+        <xsl:when test="count(m:radPr[last()]/m:degHide)=0">0</xsl:when>
+        <xsl:otherwise>
+          <xsl:call-template name="ForceFalseStrVal">
+            <xsl:with-param name="str" select="translate(m:radPr[last()]/m:degHide/@m:val, 
+		                                                          'ABCDEFGHIJKLMNOPQRSTUVWXYZ', 
+		                                                          'abcdefghijklmnopqrstuvwxyz')" />
+          </xsl:call-template>
+        </xsl:otherwise>
+      </xsl:choose>
+    </xsl:variable>
+    <xsl:choose>
+      <xsl:when test="$fDegHide=1">
+        <mml:msqrt>
+          <xsl:apply-templates select="m:e[1]" />
+        </mml:msqrt>
+      </xsl:when>
+      <xsl:otherwise>
+        <mml:mroot>
+          <mml:mrow>
+            <xsl:apply-templates select="m:e[1]" />
+          </mml:mrow>
+          <mml:mrow>
+            <xsl:apply-templates select="m:deg[1]" />
+          </mml:mrow>
+        </mml:mroot>
+      </xsl:otherwise>
+    </xsl:choose>
+  </xsl:template>
+
+  <xsl:template name="OutputNaryMo">
+    <xsl:param name="ndCur" select="." />
+    <xsl:param name="fGrow" select="0" />
+    <mml:mo>
+      <xsl:choose>
+        <xsl:when test="$fGrow=1">
+          <xsl:attribute name="stretchy">true</xsl:attribute>
+        </xsl:when>
+        <xsl:otherwise>
+          <xsl:attribute name="stretchy">false</xsl:attribute>
+        </xsl:otherwise>
+      </xsl:choose>
+      <xsl:choose>
+        <xsl:when test="not($ndCur/m:naryPr[last()]/m:chr/@m:val) or
+			                            $ndCur/m:naryPr[last()]/m:chr/@m:val=''">
+          <xsl:text>&#x222b;</xsl:text>
+        </xsl:when>
+        <xsl:otherwise>
+          <xsl:value-of select="$ndCur/m:naryPr[last()]/m:chr/@m:val" />
+        </xsl:otherwise>
+      </xsl:choose>
+    </mml:mo>
+  </xsl:template>
+
+  <!-- %%Template match m:nary 
+		Process an n-ary. 
+		
+		Decides, based on which arguments are supplied, between
+		using an mo, msup, msub, or msubsup for the n-ary operator		
+	-->
+  <xsl:template match="m:nary">
+    <xsl:variable name="sLowerCaseSubHide">
+      <xsl:choose>
+        <xsl:when test="count(m:naryPr[last()]/m:subHide) = 0">
+          <xsl:text>off</xsl:text>
+        </xsl:when>
+        <xsl:otherwise>
+          <xsl:value-of select="translate(m:naryPr[last()]/m:subHide/@m:val, 
+	                                  'ABCDEFGHIJKLMNOPQRSTUVWXYZ', 
+	                                  'abcdefghijklmnopqrstuvwxyz')" />
+        </xsl:otherwise>
+      </xsl:choose>
+    </xsl:variable>
+
+    <xsl:variable name="sLowerCaseSupHide">
+      <xsl:choose>
+        <xsl:when test="count(m:naryPr[last()]/m:supHide) = 0">
+          <xsl:text>off</xsl:text>
+        </xsl:when>
+        <xsl:otherwise>
+          <xsl:value-of select="translate(m:naryPr[last()]/m:supHide/@m:val, 
+	                                  'ABCDEFGHIJKLMNOPQRSTUVWXYZ', 
+	                                  'abcdefghijklmnopqrstuvwxyz')" />
+        </xsl:otherwise>
+      </xsl:choose>
+    </xsl:variable>
+
+    <xsl:variable name="sLowerCaseLimLoc">
+      <xsl:value-of select="translate(m:naryPr[last()]/m:limLoc/@m:val, 
+	                                  'ABCDEFGHIJKLMNOPQRSTUVWXYZ', 
+	                                  'abcdefghijklmnopqrstuvwxyz')" />
+    </xsl:variable>
+
+    <xsl:variable name="sLowerGrow">
+      <xsl:choose>
+        <xsl:when test="count(m:naryPr[last()]/m:grow)=0">off</xsl:when>
+        <xsl:otherwise>
+          <xsl:value-of select="translate(m:naryPr[last()]/m:grow/@m:val, 
+	                                  'ABCDEFGHIJKLMNOPQRSTUVWXYZ', 
+	                                  'abcdefghijklmnopqrstuvwxyz')" />
+        </xsl:otherwise>
+      </xsl:choose>
+    </xsl:variable>
+
+    <xsl:variable name="fLimLocSubSup">
+      <xsl:choose>
+        <xsl:when test="count(m:naryPr[last()]/m:limLoc)=0 or $sLowerCaseLimLoc='subsup'">1</xsl:when>
+        <xsl:otherwise>0</xsl:otherwise>
+      </xsl:choose>
+    </xsl:variable>
+
+    <xsl:variable name="fGrow">
+      <xsl:call-template name="ForceFalseStrVal">
+        <xsl:with-param name="str" select="$sLowerGrow" />
+      </xsl:call-template>
+    </xsl:variable>
+
+    <xsl:variable name="fSupHide">
+      <xsl:call-template name="ForceFalseStrVal">
+        <xsl:with-param name="str" select="$sLowerCaseSupHide" />
+      </xsl:call-template>
+    </xsl:variable>
+
+    <xsl:variable name="fSubHide">
+      <xsl:call-template name="ForceFalseStrVal">
+        <xsl:with-param name="str" select="$sLowerCaseSubHide" />
+      </xsl:call-template>
+    </xsl:variable>
+
+    <mml:mrow>
+      <xsl:choose>
+        <xsl:when test="$fSupHide=1 and $fSubHide=1">
+          <xsl:call-template name="OutputNaryMo">
+            <xsl:with-param name="ndCur" select="." />
+            <xsl:with-param name="fGrow" select="$fGrow" />
+          </xsl:call-template>
+        </xsl:when>
+        <xsl:when test="$fSubHide=1">
+          <xsl:choose>
+            <xsl:when test="$fLimLocSubSup=1">
+              <mml:msup>
+                <xsl:call-template name="OutputNaryMo">
+                  <xsl:with-param name="ndCur" select="." />
+                  <xsl:with-param name="fGrow" select="$fGrow" />
+                </xsl:call-template>
+                <mml:mrow>
+                  <xsl:apply-templates select="m:sup[1]" />
+                </mml:mrow>
+              </mml:msup>
+            </xsl:when>
+            <xsl:otherwise>
+              <mml:mover>
+                <xsl:call-template name="OutputNaryMo">
+                  <xsl:with-param name="ndCur" select="." />
+                  <xsl:with-param name="fGrow" select="$fGrow" />
+                </xsl:call-template>
+                <mml:mrow>
+                  <xsl:apply-templates select="m:sup[1]" />
+                </mml:mrow>
+              </mml:mover>
+            </xsl:otherwise>
+          </xsl:choose>
+        </xsl:when>
+        <xsl:when test="$fSupHide=1">
+          <xsl:choose>
+            <xsl:when test="$fLimLocSubSup=1">
+              <mml:msub>
+                <xsl:call-template name="OutputNaryMo">
+                  <xsl:with-param name="ndCur" select="." />
+                  <xsl:with-param name="fGrow" select="$fGrow" />
+                </xsl:call-template>
+                <mml:mrow>
+                  <xsl:apply-templates select="m:sub[1]" />
+                </mml:mrow>
+              </mml:msub>
+            </xsl:when>
+            <xsl:otherwise>
+              <mml:munder>
+                <xsl:call-template name="OutputNaryMo">
+                  <xsl:with-param name="ndCur" select="." />
+                  <xsl:with-param name="fGrow" select="$fGrow" />
+                </xsl:call-template>
+                <mml:mrow>
+                  <xsl:apply-templates select="m:sub[1]" />
+                </mml:mrow>
+              </mml:munder>
+            </xsl:otherwise>
+          </xsl:choose>
+        </xsl:when>
+        <xsl:otherwise>
+          <xsl:choose>
+            <xsl:when test="$fLimLocSubSup=1">
+              <mml:msubsup>
+                <xsl:call-template name="OutputNaryMo">
+                  <xsl:with-param name="ndCur" select="." />
+                  <xsl:with-param name="fGrow" select="$fGrow" />
+                </xsl:call-template>
+                <mml:mrow>
+                  <xsl:apply-templates select="m:sub[1]" />
+                </mml:mrow>
+                <mml:mrow>
+                  <xsl:apply-templates select="m:sup[1]" />
+                </mml:mrow>
+              </mml:msubsup>
+            </xsl:when>
+            <xsl:otherwise>
+              <mml:munderover>
+                <xsl:call-template name="OutputNaryMo">
+                  <xsl:with-param name="ndCur" select="." />
+                  <xsl:with-param name="fGrow" select="$fGrow" />
+                </xsl:call-template>
+                <mml:mrow>
+                  <xsl:apply-templates select="m:sub[1]" />
+                </mml:mrow>
+                <mml:mrow>
+                  <xsl:apply-templates select="m:sup[1]" />
+                </mml:mrow>
+              </mml:munderover>
+            </xsl:otherwise>
+          </xsl:choose>
+        </xsl:otherwise>
+      </xsl:choose>
+      <mml:mrow>
+        <xsl:apply-templates select="m:e[1]" />
+      </mml:mrow>
+    </mml:mrow>
+  </xsl:template>
+
+  <xsl:template match="m:limLow">
+    <mml:munder>
+      <mml:mrow>
+        <xsl:apply-templates select="m:e[1]" />
+      </mml:mrow>
+      <mml:mrow>
+        <xsl:apply-templates select="m:lim[1]" />
+      </mml:mrow>
+    </mml:munder>
+  </xsl:template>
+
+  <xsl:template match="m:limUpp">
+    <mml:mover>
+      <mml:mrow>
+        <xsl:apply-templates select="m:e[1]" />
+      </mml:mrow>
+      <mml:mrow>
+        <xsl:apply-templates select="m:lim[1]" />
+      </mml:mrow>
+    </mml:mover>
+  </xsl:template>
+
+  <xsl:template match="m:sSub">
+    <mml:msub>
+      <mml:mrow>
+        <xsl:apply-templates select="m:e[1]" />
+      </mml:mrow>
+      <mml:mrow>
+        <xsl:apply-templates select="m:sub[1]" />
+      </mml:mrow>
+    </mml:msub>
+  </xsl:template>
+
+  <xsl:template match="m:sSup">
+    <mml:msup>
+      <mml:mrow>
+        <xsl:apply-templates select="m:e[1]" />
+      </mml:mrow>
+      <mml:mrow>
+        <xsl:apply-templates select="m:sup[1]" />
+      </mml:mrow>
+    </mml:msup>
+  </xsl:template>
+
+  <xsl:template match="m:sSubSup">
+    <mml:msubsup>
+      <mml:mrow>
+        <xsl:apply-templates select="m:e[1]" />
+      </mml:mrow>
+      <mml:mrow>
+        <xsl:apply-templates select="m:sub[1]" />
+      </mml:mrow>
+      <mml:mrow>
+        <xsl:apply-templates select="m:sup[1]" />
+      </mml:mrow>
+    </mml:msubsup>
+  </xsl:template>
+
+  <xsl:template match="m:groupChr">
+    <xsl:variable name="ndLastGroupChrPr" select="m:groupChrPr[last()]" />
+    <xsl:variable name="sLowerCasePos" select="translate($ndLastGroupChrPr/m:pos/@m:val, 
+		                                                     'ABCDEFGHIJKLMNOPQRSTUVWXYZ', 
+		                                                     'abcdefghijklmnopqrstuvwxyz')" />
+
+    <xsl:variable name="sLowerCaseVertJc" select="translate($ndLastGroupChrPr/m:vertJc/@m:val, 
+		                                                     'ABCDEFGHIJKLMNOPQRSTUVWXYZ', 
+		                                                     'abcdefghijklmnopqrstuvwxyz')" />
+    <xsl:variable name="ndLastChr" select="$ndLastGroupChrPr/m:chr" />
+
+    <xsl:variable name="chr">
+      <xsl:choose>
+        <xsl:when test="$ndLastChr and (not($ndLastChr/@m:val) or string-length($ndLastChr/@m:val) = 0)"></xsl:when>
+        <xsl:when test="string-length($ndLastChr/@m:val) &gt;= 1">
+          <xsl:value-of select="substring($ndLastChr/@m:val,1,1)" />
+        </xsl:when>
+        <xsl:otherwise>
+          <xsl:text>&#x023DF;</xsl:text>
+        </xsl:otherwise>
+      </xsl:choose>
+    </xsl:variable>
+    <xsl:choose>
+      <xsl:when test="$sLowerCasePos = 'top'">
+        <xsl:choose>
+          <xsl:when test="$sLowerCaseVertJc = 'bot'">
+            <mml:mover accent="false">
+              <mml:mrow>
+                <xsl:apply-templates select="m:e[1]" />
+              </mml:mrow>
+              <mml:mo>
+                <xsl:value-of select="$chr" />
+              </mml:mo>
+            </mml:mover>
+          </xsl:when>
+          <xsl:otherwise>
+            <mml:munder accentunder="false">
+              <mml:mo>
+                <xsl:value-of select="$chr" />
+              </mml:mo>
+              <mml:mrow>
+                <xsl:apply-templates select="m:e[1]" />
+              </mml:mrow>
+            </mml:munder>
+          </xsl:otherwise>
+        </xsl:choose>
+      </xsl:when>
+      <xsl:otherwise>
+        <xsl:choose>
+          <xsl:when test="$sLowerCaseVertJc = 'bot'">
+            <mml:mover accent="false">
+              <mml:mo>
+                <xsl:value-of select="$chr" />
+              </mml:mo>
+              <mml:mrow>
+                <xsl:apply-templates select="m:e[1]" />
+              </mml:mrow>
+            </mml:mover>
+          </xsl:when>
+          <xsl:otherwise>
+            <mml:munder accentunder="false">
+              <mml:mrow>
+                <xsl:apply-templates select="m:e[1]" />
+              </mml:mrow>
+              <mml:mo>
+                <xsl:value-of select="$chr" />
+              </mml:mo>
+            </mml:munder>
+          </xsl:otherwise>
+        </xsl:choose>
+      </xsl:otherwise>
+    </xsl:choose>
+  </xsl:template>
+
+  <xsl:template name="fName">
+    <xsl:for-each select="m:fName/*">
+      <xsl:apply-templates select="." />
+    </xsl:for-each>
+  </xsl:template>
+
+  <xsl:template match="m:func">
+    <mml:mrow>
+      <mml:mrow>
+        <xsl:call-template name="fName" />
+      </mml:mrow>
+      <mml:mo>&#x02061;</mml:mo>
+      <mml:mrow>
+        <xsl:apply-templates select="m:e" />
+      </mml:mrow>
+    </mml:mrow>
+  </xsl:template>
+
+  <!-- %%Template: match m:f 
+		
+		m:f maps directly to mfrac. 
+	-->
+  <xsl:template match="m:f">
+    <xsl:variable name="sLowerCaseType" select="translate(m:fPr[last()]/m:type/@m:val, 'ABCDEFGHIJKLMNOPQRSTUVWXYZ', 'abcdefghijklmnopqrstuvwxyz')" />
+    <xsl:choose>
+      <xsl:when test="$sLowerCaseType='lin'">
+        <mml:mrow>
+          <mml:mrow>
+            <xsl:apply-templates select="m:num[1]" />
+          </mml:mrow>
+          <mml:mo>/</mml:mo>
+          <mml:mrow>
+            <xsl:apply-templates select="m:den[1]" />
+          </mml:mrow>
+        </mml:mrow>
+      </xsl:when>
+      <xsl:otherwise>
+        <mml:mfrac>
+          <xsl:call-template name="CreateMathMLFracProp">
+            <xsl:with-param name="type" select="$sLowerCaseType" />
+          </xsl:call-template>
+          <mml:mrow>
+            <xsl:apply-templates select="m:num[1]" />
+          </mml:mrow>
+          <mml:mrow>
+            <xsl:apply-templates select="m:den[1]" />
+          </mml:mrow>
+        </mml:mfrac>
+      </xsl:otherwise>
+    </xsl:choose>
+
+  </xsl:template>
+
+
+  <!-- %%Template: CreateMathMLFracProp 
+		
+			Make fraction properties based on supplied parameters.
+			OMML differentiates between a linear fraction and a skewed
+			one. For MathML, we write both as bevelled.
+	-->
+  <xsl:template name="CreateMathMLFracProp">
+    <xsl:param name="type" />
+    <xsl:variable name="sLowerCaseType" select="translate($type, 'ABCDEFGHIJKLMNOPQRSTUVWXYZ', 'abcdefghijklmnopqrstuvwxyz')" />
+
+    <xsl:if test="$sLowerCaseType='skw' or $sLowerCaseType='lin'">
+      <xsl:attribute name="bevelled">true</xsl:attribute>
+    </xsl:if>
+    <xsl:if test="$sLowerCaseType='nobar'">
+      <xsl:attribute name="linethickness">0pt</xsl:attribute>
+    </xsl:if>
+    <xsl:choose>
+      <xsl:when test="sLowerCaseNumJc='right'">
+        <xsl:attribute name="numalign">right</xsl:attribute>
+      </xsl:when>
+      <xsl:when test="sLowerCaseNumJc='left'">
+        <xsl:attribute name="numalign">left</xsl:attribute>
+      </xsl:when>
+    </xsl:choose>
+    <xsl:choose>
+      <xsl:when test="sLowerCaseDenJc='right'">
+        <xsl:attribute name="numalign">right</xsl:attribute>
+      </xsl:when>
+      <xsl:when test="sLowerCaseDenJc='left'">
+        <xsl:attribute name="numalign">left</xsl:attribute>
+      </xsl:when>
+    </xsl:choose>
+  </xsl:template>
+
+  <!-- %%Template: match m:e | m:den | m:num | m:lim | m:sup | m:sub 
+		
+		These element delinate parts of an expression (like the numerator).  -->
+  <xsl:template match="m:e | m:den | m:num | m:lim | m:sup | m:sub">
+    <xsl:choose>
+
+      <!-- If there is no scriptLevel specified, just call through -->
+      <xsl:when test="not(m:argPr[last()]/m:scrLvl/@m:val)">
+        <xsl:apply-templates select="*" />
+      </xsl:when>
+
+      <!-- Otherwise, create an mstyle and set the script level -->
+      <xsl:otherwise>
+        <mml:mstyle>
+          <xsl:attribute name="scriptlevel">
+            <xsl:value-of select="m:argPr[last()]/m:scrLvl/@m:val" />
+          </xsl:attribute>
+          <xsl:apply-templates select="*" />
+        </mml:mstyle>
+      </xsl:otherwise>
+    </xsl:choose>
+  </xsl:template>
+
+  <xsl:template match="m:bar">
+    <xsl:variable name="sLowerCasePos" select="translate(m:barPr/m:pos/@m:val, 'ABCDEFGHIJKLMNOPQRSTUVWXYZ', 
+		                                                                       'abcdefghijklmnopqrstuvwxyz')" />
+
+    <xsl:variable name="fTop">
+
+      <xsl:choose>
+        <xsl:when test="$sLowerCasePos='top'">1</xsl:when>
+        <xsl:otherwise>0</xsl:otherwise>
+      </xsl:choose>
+    </xsl:variable>
+    <xsl:choose>
+      <xsl:when test="$fTop=1">
+        <mml:mover accent="false">
+          <mml:mrow>
+            <xsl:apply-templates select="m:e[1]" />
+          </mml:mrow>
+          <mml:mo>
+            <xsl:text>&#x00AF;</xsl:text>
+          </mml:mo>
+        </mml:mover>
+      </xsl:when>
+      <xsl:otherwise>
+        <mml:munder underaccent="false">
+          <mml:mrow>
+            <xsl:apply-templates select="m:e[1]" />
+          </mml:mrow>
+          <mml:mo>
+            <xsl:text>&#x005F;</xsl:text>
+          </mml:mo>
+        </mml:munder>
+      </xsl:otherwise>
+    </xsl:choose>
+  </xsl:template>
+
+  <!-- %%Template match m:d
+
+		Process a delimiter. 
+	-->
+  <xsl:template match="m:d">
+    <mml:mfenced>
+      <!-- open: default is '(' for both OMML and MathML -->
+      <xsl:if test="m:dPr[1]/m:begChr/@m:val and not(m:dPr[1]/m:begChr/@m:val ='(')">
+        <xsl:attribute name="open">
+          <xsl:value-of select="m:dPr[1]/m:begChr/@m:val" />
+        </xsl:attribute>
+      </xsl:if>
+
+      <!-- close: default is ')' for both OMML and MathML -->
+      <xsl:if test="m:dPr[1]/m:endChr/@m:val and not(m:dPr[1]/m:endChr/@m:val =')')">
+        <xsl:attribute name="close">
+          <xsl:value-of select="m:dPr[1]/m:endChr/@m:val" />
+        </xsl:attribute>
+      </xsl:if>
+
+      <!-- separator: the default is ',' for MathML, and '|' for OMML -->
+      <xsl:choose>
+        <!-- Matches MathML default. Write nothing -->
+        <xsl:when test="m:dPr[1]/m:sepChr/@m:val = ','" />
+
+        <!-- OMML default: | -->
+        <xsl:when test="not(m:dPr[1]/m:sepChr/@m:val)">
+          <xsl:attribute name="separators">
+            <xsl:value-of select="'|'" />
+          </xsl:attribute>
+        </xsl:when>
+
+        <xsl:otherwise>
+          <xsl:attribute name="separators">
+            <xsl:value-of select="m:dPr[1]/m:sepChr/@m:val" />
+          </xsl:attribute>
+        </xsl:otherwise>
+      </xsl:choose>
+
+      <!-- now write all the children. Put each one into an mrow
+			just in case it produces multiple runs, etc -->
+      <xsl:for-each select="m:e">
+        <mml:mrow>
+          <xsl:apply-templates select="." />
+        </mml:mrow>
+      </xsl:for-each>
+    </mml:mfenced>
+  </xsl:template>
+
+  <xsl:template match="m:r">
+    <xsl:variable name="fNor">
+      <xsl:choose>
+        <xsl:when test="count(child::m:rPr[last()]/m:nor) = 0">0</xsl:when>
+        <xsl:otherwise>
+          <xsl:call-template name="ForceFalseStrVal">
+            <xsl:with-param name="str" select="translate(child::m:rPr[last()]/m:nor/@m:val, 'ABCDEFGHIJKLMNOPQRSTUVWXYZ', 
+		                                                                       'abcdefghijklmnopqrstuvwxyz')" />
+          </xsl:call-template>
+        </xsl:otherwise>
+      </xsl:choose>
+    </xsl:variable>
+
+    <xsl:choose>
+      <xsl:when test="$fNor=1">
+        <mml:mtext>
+          <xsl:variable name="sOutput" select="translate(.//m:t, ' ', '&#xa0;')" />
+          <xsl:value-of select="$sOutput" />
+        </mml:mtext>
+      </xsl:when>
+      <xsl:otherwise>
+        <xsl:for-each select=".//m:t">
+          <xsl:call-template name="ParseMt">
+            <xsl:with-param name="sToParse" select="text()" />
+            <xsl:with-param name="scr" select="../m:rPr[last()]/m:scr/@m:val" />
+            <xsl:with-param name="sty" select="../m:rPr[last()]/m:sty/@m:val" />
+            <xsl:with-param name="nor">0</xsl:with-param>
+          </xsl:call-template>
+        </xsl:for-each>
+      </xsl:otherwise>
+    </xsl:choose>
+  </xsl:template>
+
+
+  <xsl:template name="CreateTokenAttributes">
+    <xsl:param name="scr" />
+    <xsl:param name="sty" />
+    <xsl:param name="nor" />
+    <xsl:param name="nCharToPrint" />
+    <xsl:param name="sTokenType" />
+
+    <xsl:choose>
+      <xsl:when test="$nor=1">
+        <xsl:attribute name="mathvariant">normal</xsl:attribute>
+      </xsl:when>
+      <xsl:otherwise>
+        <xsl:variable name="mathvariant">
+          <xsl:choose>
+            <!-- numbers don't care -->
+            <xsl:when test="$sTokenType='mn'" />
+
+            <xsl:when test="$scr='monospace'">monospace</xsl:when>
+            <xsl:when test="$scr='sans-serif' and $sty='i'">sans-serif-italic</xsl:when>
+            <xsl:when test="$scr='sans-serif' and $sty='b'">bold-sans-serif</xsl:when>
+            <xsl:when test="$scr='sans-serif' and $sty='bi'">sans-serif-bold-italic</xsl:when>
+            <xsl:when test="$scr='sans-serif'">sans-serif</xsl:when>
+            <xsl:when test="$scr='fraktur' and ($sty='b' or $sty='bi')">bold-fraktur</xsl:when>
+            <xsl:when test="$scr='fraktur'">fraktur</xsl:when>
+            <xsl:when test="$scr='double-struck'">double-struck</xsl:when>
+            <xsl:when test="$scr='script' and ($sty='b' or $sty='bi')">bold-script</xsl:when>
+            <xsl:when test="$scr='script'">script</xsl:when>
+            <xsl:when test="($scr='roman' or not($scr) or $scr='') and $sty='b'">bold</xsl:when>
+            <xsl:when test="($scr='roman' or not($scr) or $scr='') and $sty='i'">italic</xsl:when>
+            <xsl:when test="($scr='roman' or not($scr) or $scr='') and $sty='p'">normal</xsl:when>
+            <xsl:when test="($scr='roman' or not($scr) or $scr='') and $sty='bi'">bold-italic</xsl:when>
+            <xsl:otherwise />
+          </xsl:choose>
+        </xsl:variable>
+        <xsl:variable name="fontweight">
+          <xsl:choose>
+            <xsl:when test="$sty='b' or $sty='bi'">bold</xsl:when>
+            <xsl:otherwise>normal</xsl:otherwise>
+          </xsl:choose>
+        </xsl:variable>
+        <xsl:variable name="fontstyle">
+          <xsl:choose>
+            <xsl:when test="$sty='p' or $sty='b'">normal</xsl:when>
+            <xsl:otherwise>italic</xsl:otherwise>
+          </xsl:choose>
+        </xsl:variable>
+
+        <!-- Writing of attributes begins here -->
+        <xsl:choose>
+          <!-- Don't write mathvariant for operators unless they want to be normal -->
+          <xsl:when test="$sTokenType='mo' and $mathvariant!='normal'" />
+
+          <!-- A single character within an mi is already italics, don't write -->
+          <xsl:when test="$sTokenType='mi' and $nCharToPrint=1 and ($mathvariant='' or $mathvariant='italic')" />
+
+          <xsl:when test="$sTokenType='mi' and $nCharToPrint &gt; 1 and ($mathvariant='' or $mathvariant='italic')">
+            <xsl:attribute name="mathvariant">
+              <xsl:value-of select="'italic'" />
+            </xsl:attribute>
+          </xsl:when>
+          <xsl:when test="$mathvariant!='italic' and $mathvariant!=''">
+            <xsl:attribute name="mathvariant">
+              <xsl:value-of select="$mathvariant" />
+            </xsl:attribute>
+          </xsl:when>
+          <xsl:otherwise>
+            <xsl:if test="not($sTokenType='mi' and $nCharToPrint=1) and $fontstyle='italic'">
+              <xsl:attribute name="fontstyle">italic</xsl:attribute>
+            </xsl:if>
+            <xsl:if test="$fontweight='bold'">
+              <xsl:attribute name="fontweight">bold</xsl:attribute>
+            </xsl:if>
+          </xsl:otherwise>
+        </xsl:choose>
+      </xsl:otherwise>
+    </xsl:choose>
+  </xsl:template>
+
+  <xsl:template match="m:eqArr">
+    <mml:mtable>
+      <xsl:for-each select="m:e">
+        <mml:mtr>
+          <mml:mtd>
+            <xsl:choose>
+              <xsl:when test="m:argPr[last()]/m:scrLvl/@m:val!='0' or 
+					            not(m:argPr[last()]/m:scrLvl/@m:val)  or 
+					            m:argPr[last()]/m:scrLvl/@m:val=''">
+                <mml:mrow>
+                  <mml:maligngroup />
+                  <xsl:call-template name="CreateEqArrRow">
+                    <xsl:with-param name="align" select="1" />
+                    <xsl:with-param name="ndCur" select="*[1]" />
+                  </xsl:call-template>
+                </mml:mrow>
+              </xsl:when>
+              <xsl:otherwise>
+                <mml:mstyle>
+                  <xsl:attribute name="scriptlevel">
+                    <xsl:value-of select="m:argPr[last()]/m:scrLvl/@m:val" />
+                  </xsl:attribute>
+                  <mml:maligngroup />
+                  <xsl:call-template name="CreateEqArrRow">
+                    <xsl:with-param name="align" select="1" />
+                    <xsl:with-param name="ndCur" select="*[1]" />
+                  </xsl:call-template>
+                </mml:mstyle>
+              </xsl:otherwise>
+            </xsl:choose>
+          </mml:mtd>
+        </mml:mtr>
+      </xsl:for-each>
+    </mml:mtable>
+  </xsl:template>
+
+  <xsl:template name="CreateEqArrRow">
+    <xsl:param name="align" />
+    <xsl:param name="ndCur" />
+    <xsl:variable name="sAllMt">
+      <xsl:for-each select="$ndCur/m:t">
+        <xsl:value-of select="." />
+      </xsl:for-each>
+    </xsl:variable>
+    <xsl:choose>
+      <xsl:when test="$ndCur/self::m:r">
+        <xsl:call-template name="ParseEqArrMr">
+          <xsl:with-param name="sToParse" select="$sAllMt" />
+          <xsl:with-param name="scr" select="../m:rPr[last()]/m:scr/@m:val" />
+          <xsl:with-param name="sty" select="../m:rPr[last()]/m:sty/@m:val" />
+          <xsl:with-param name="nor">
+            <xsl:choose>
+              <xsl:when test="count($ndCur/m:rPr[last()]/m:nor) = 0">0</xsl:when>
+              <xsl:otherwise>
+                <xsl:call-template name="ForceFalseStrVal">
+                  <xsl:with-param name="str" select="translate($ndCur/m:rPr[last()]/m:nor/@m:val, 
+                                                                     'ABCDEFGHIJKLMNOPQRSTUVWXYZ', 
+		                                                                 'abcdefghijklmnopqrstuvwxyz')" />
+                </xsl:call-template>
+              </xsl:otherwise>
+            </xsl:choose>
+          </xsl:with-param>
+          <xsl:with-param name="align" select="$align" />
+        </xsl:call-template>
+      </xsl:when>
+      <xsl:otherwise>
+        <xsl:apply-templates select="$ndCur" />
+      </xsl:otherwise>
+    </xsl:choose>
+    <xsl:if test="count($ndCur/following-sibling::*) &gt; 0">
+      <xsl:variable name="cAmp">
+        <xsl:call-template name="CountAmp">
+          <xsl:with-param name="sAllMt" select="$sAllMt" />
+          <xsl:with-param name="cAmp" select="0" />
+        </xsl:call-template>
+      </xsl:variable>
+      <xsl:call-template name="CreateEqArrRow">
+        <xsl:with-param name="align" select="($align+($cAmp mod 2)) mod 2" />
+        <xsl:with-param name="ndCur" select="$ndCur/following-sibling::*[1]" />
+      </xsl:call-template>
+    </xsl:if>
+  </xsl:template>
+
+  <xsl:template name="CountAmp">
+    <xsl:param name="sAllMt" />
+    <xsl:param name="cAmp" />
+    <xsl:choose>
+      <xsl:when test="string-length(substring-after($sAllMt, '&amp;')) &gt; 0 or 
+			                substring($sAllMt, string-length($sAllMt))='&#x0026;'">
+        <xsl:call-template name="CountAmp">
+          <xsl:with-param name="sAllMt" select="substring-after($sAllMt, '&#x0026;')" />
+          <xsl:with-param name="cAmp" select="$cAmp+1" />
+        </xsl:call-template>
+      </xsl:when>
+      <xsl:otherwise>
+        <xsl:value-of select="$cAmp" />
+      </xsl:otherwise>
+    </xsl:choose>
+  </xsl:template>
+
+  <!-- %%Template: ParseEqArrMr
+			
+			Similar to ParseMt, but this one has to do more for an equation array. 
+      In equation arrays &amp; is a special character which denotes alignment.
+      
+      The &amp; in an equation works by alternating between meaning insert alignment spacing
+      and insert alignment mark.  For each equation in the equation array
+      there is an implied align space at the beginning of the equation.  Within each equation,
+      the first &amp; means alignmark, the second, align space, the third, alignmark, etc.
+      
+      For this reason when parsing m:r's in equation arrays it is important to keep track of what
+      the next ampersand will mean.
+      
+      $align=0 => Omml's align space, which is similar to MathML's maligngroup.
+      $align=1 => Omml's alignment mark, which is similar to MathML's malignmark.
+	-->
+  <xsl:template name="ParseEqArrMr">
+    <xsl:param name="sToParse" />
+    <xsl:param name="sty" />
+    <xsl:param name="scr" />
+    <xsl:param name="nor" />
+    <xsl:param name="align" />
+
+    <xsl:if test="string-length($sToParse) &gt; 0">
+      <xsl:choose>
+        <xsl:when test="substring($sToParse,1,1) = '&amp;'">
+          <xsl:choose>
+            <xsl:when test="$align='0'">
+              <mml:maligngroup />
+            </xsl:when>
+            <xsl:when test="$align='1'">
+              <mml:malignmark />
+            </xsl:when>
+          </xsl:choose>
+          <xsl:call-template name="ParseEqArrMr">
+            <xsl:with-param name="sToParse" select="substring($sToParse,2)" />
+            <xsl:with-param name="scr" select="$scr" />
+            <xsl:with-param name="sty" select="$sty" />
+            <xsl:with-param name="nor" select="$nor" />
+            <xsl:with-param name="align">
+              <xsl:choose>
+                <xsl:when test="$align='1'">0</xsl:when>
+                <xsl:otherwise>1</xsl:otherwise>
+              </xsl:choose>
+            </xsl:with-param>
+          </xsl:call-template>
+        </xsl:when>
+        <xsl:otherwise>
+          <xsl:variable name="sRepNumWith0">
+            <xsl:call-template name="SReplaceNumWithZero">
+              <xsl:with-param name="sToParse" select="$sToParse" />
+            </xsl:call-template>
+          </xsl:variable>
+          <xsl:variable name="sRepOperWith-">
+            <xsl:call-template name="SReplaceOperWithMinus">
+              <xsl:with-param name="sToParse" select="$sRepNumWith0" />
+            </xsl:call-template>
+          </xsl:variable>
+
+          <xsl:variable name="iFirstOper" select="string-length($sRepOperWith-) - string-length(substring-after($sRepOperWith-, '-'))" />
+          <xsl:variable name="iFirstNum" select="string-length($sRepOperWith-) - string-length(substring-after($sRepOperWith-, '0'))" />
+          <xsl:variable name="iFirstAmp" select="string-length($sRepOperWith-) - string-length(substring-after($sRepOperWith-, '&#x0026;'))" />
+          <xsl:variable name="fNumAtPos1">
+            <xsl:choose>
+              <xsl:when test="substring($sRepOperWith-,1,1)='0'">1</xsl:when>
+              <xsl:otherwise>0</xsl:otherwise>
+            </xsl:choose>
+          </xsl:variable>
+          <xsl:variable name="fOperAtPos1">
+            <xsl:choose>
+              <xsl:when test="substring($sRepOperWith-,1,1)='-'">1</xsl:when>
+              <xsl:otherwise>0</xsl:otherwise>
+            </xsl:choose>
+          </xsl:variable>
+          <xsl:choose>
+
+            <!-- Case I: The string begins with neither a number, nor an operator -->
+            <xsl:when test="$fNumAtPos1='0' and $fOperAtPos1='0'">
+              <xsl:choose>
+                <xsl:when test="$nor = 0">
+                  <mml:mi>
+                    <xsl:call-template name="CreateTokenAttributes">
+                      <xsl:with-param name="scr" select="$scr" />
+                      <xsl:with-param name="sty" select="$sty" />
+                      <xsl:with-param name="nor" select="$nor" />
+                      <xsl:with-param name="nCharToPrint" select="1" />
+                      <xsl:with-param name="sTokenType" select="'mi'" />
+                    </xsl:call-template>
+                    <xsl:variable name="sOutput" select="translate(substring($sToParse, 1, 1), ' ', '&#xa0;')" />
+                    <xsl:value-of select="$sOutput" />
+                  </mml:mi>
+                </xsl:when>
+                <xsl:otherwise>
+                  <mml:mtext>
+                    <xsl:variable name="sOutput" select="translate(substring($sToParse, 1, 1), ' ', '&#xa0;')" />
+                    <xsl:value-of select="$sOutput" />
+                  </mml:mtext>
+                </xsl:otherwise>
+              </xsl:choose>
+              <xsl:call-template name="ParseEqArrMr">
+                <xsl:with-param name="sToParse" select="substring($sToParse, 2)" />
+                <xsl:with-param name="scr" select="$scr" />
+                <xsl:with-param name="sty" select="$sty" />
+                <xsl:with-param name="nor" select="$nor" />
+                <xsl:with-param name="align" select="$align" />
+              </xsl:call-template>
+            </xsl:when>
+
+            <!-- Case II: There is an operator at position 1 -->
+            <xsl:when test="$fOperAtPos1='1'">
+              <xsl:choose>
+                <xsl:when test="$nor = 0">
+                  <mml:mo>
+                    <xsl:call-template name="CreateTokenAttributes">
+                      <xsl:with-param name="scr" />
+                      <xsl:with-param name="sty" />
+                      <xsl:with-param name="nor" select="$nor" />
+                      <xsl:with-param name="sTokenType" select="'mo'" />
+                    </xsl:call-template>
+                    <xsl:value-of select="substring($sToParse,1,1)" />
+                  </mml:mo>
+                </xsl:when>
+                <xsl:otherwise>
+                  <mml:mtext>
+                    <xsl:value-of select="substring($sToParse,1,1)" />
+                  </mml:mtext>                  
+                </xsl:otherwise>
+              </xsl:choose>
+              <xsl:call-template name="ParseEqArrMr">
+                <xsl:with-param name="sToParse" select="substring($sToParse, 2)" />
+                <xsl:with-param name="scr" select="$scr" />
+                <xsl:with-param name="sty" select="$sty" />
+                <xsl:with-param name="nor" select="$nor" />
+                <xsl:with-param name="align" select="$align" />
+              </xsl:call-template>
+            </xsl:when>
+
+            <!-- Case III: There is a number at position 1 -->
+            <xsl:otherwise>
+              <xsl:variable name="sConsecNum">
+                <xsl:call-template name="SNumStart">
+                  <xsl:with-param name="sToParse" select="$sToParse" />
+                  <xsl:with-param name="sPattern" select="$sRepNumWith0" />
+                </xsl:call-template>
+              </xsl:variable>
+              <xsl:choose>
+                <xsl:when test="$nor = 0">
+                  <mml:mn>
+                    <xsl:call-template name="CreateTokenAttributes">
+                      <xsl:with-param name="scr" />
+                      <xsl:with-param name="sty" select="'p'"/>
+                      <xsl:with-param name="nor" select="$nor" />
+                      <xsl:with-param name="sTokenType" select="'mn'" />
+                    </xsl:call-template>
+                    <xsl:value-of select="$sConsecNum" />
+                  </mml:mn>
+                </xsl:when>
+                <xsl:otherwise>
+                  <mml:mtext>
+                    <xsl:value-of select="$sConsecNum" />
+                  </mml:mtext>
+                </xsl:otherwise>
+              </xsl:choose>
+              <xsl:call-template name="ParseEqArrMr">
+                <xsl:with-param name="sToParse" select="substring-after($sToParse, $sConsecNum)" />
+                <xsl:with-param name="scr" select="$scr" />
+                <xsl:with-param name="sty" select="$sty" />
+                <xsl:with-param name="nor" select="$nor" />
+                <xsl:with-param name="align" select="$align" />
+              </xsl:call-template>
+            </xsl:otherwise>
+          </xsl:choose>
+        </xsl:otherwise>
+      </xsl:choose>
+    </xsl:if>
+  </xsl:template>
+
+  <!-- %%Template: ParseMt
+
+			Produce a run of text. Technically, OMML makes no distinction 
+			between numbers, operators, and other characters in a run. For 
+			MathML we need to break these into mi, mn, or mo elements. 
+			
+			See also ParseEqArrMr
+	-->
+  <xsl:template name="ParseMt">
+    <xsl:param name="sToParse" />
+    <xsl:param name="sty" />
+    <xsl:param name="scr" />
+    <xsl:param name="nor" />
+    <xsl:if test="string-length($sToParse) &gt; 0">
+      <xsl:variable name="sRepNumWith0">
+        <xsl:call-template name="SReplaceNumWithZero">
+          <xsl:with-param name="sToParse" select="$sToParse" />
+        </xsl:call-template>
+      </xsl:variable>
+      <xsl:variable name="sRepOperWith-">
+        <xsl:call-template name="SReplaceOperWithMinus">
+          <xsl:with-param name="sToParse" select="$sRepNumWith0" />
+        </xsl:call-template>
+      </xsl:variable>
+
+      <xsl:variable name="iFirstOper" select="string-length($sRepOperWith-) - string-length(substring-after($sRepOperWith-, '-'))" />
+      <xsl:variable name="iFirstNum" select="string-length($sRepOperWith-) - string-length(substring-after($sRepOperWith-, '0'))" />
+      <xsl:variable name="fNumAtPos1">
+        <xsl:choose>
+          <xsl:when test="substring($sRepOperWith-,1,1)='0'">1</xsl:when>
+          <xsl:otherwise>0</xsl:otherwise>
+        </xsl:choose>
+      </xsl:variable>
+      <xsl:variable name="fOperAtPos1">
+        <xsl:choose>
+          <xsl:when test="substring($sRepOperWith-,1,1)='-'">1</xsl:when>
+          <xsl:otherwise>0</xsl:otherwise>
+        </xsl:choose>
+      </xsl:variable>
+
+      <xsl:choose>
+
+        <!-- Case I: The string begins with neither a number, nor an operator -->
+        <xsl:when test="$fOperAtPos1='0' and $fNumAtPos1='0'">
+          <xsl:variable name="nCharToPrint">
+            <xsl:choose>
+              <xsl:when test="ancestor::m:fName">
+                <xsl:choose>
+                  <xsl:when test="($iFirstOper=$iFirstNum) and 
+											($iFirstOper=string-length($sToParse)) and
+							                (substring($sRepOperWith-, string-length($sRepOperWith-))!='0') and 
+							                (substring($sRepOperWith-, string-length($sRepOperWith-))!='-')">
+                    <xsl:value-of select="string-length($sToParse)" />
+                  </xsl:when>
+                  <xsl:when test="$iFirstOper &lt; $iFirstNum">
+                    <xsl:value-of select="$iFirstOper - 1" />
+                  </xsl:when>
+                  <xsl:otherwise>
+                    <xsl:value-of select="$iFirstNum - 1" />
+                  </xsl:otherwise>
+                </xsl:choose>
+              </xsl:when>
+              <xsl:otherwise>1</xsl:otherwise>
+            </xsl:choose>
+          </xsl:variable>
+
+          <mml:mi>
+            <xsl:call-template name="CreateTokenAttributes">
+              <xsl:with-param name="scr" select="$scr" />
+              <xsl:with-param name="sty" select="$sty" />
+              <xsl:with-param name="nor" select="$nor" />
+              <xsl:with-param name="nCharToPrint" select="$nCharToPrint" />
+              <xsl:with-param name="sTokenType" select="'mi'" />
+            </xsl:call-template>
+            <xsl:variable name="sWrite" select="translate(substring($sToParse, 1, $nCharToPrint), ' ', '&#xa0;')" />
+            <xsl:value-of select="$sWrite" />
+          </mml:mi>
+          <xsl:call-template name="ParseMt">
+            <xsl:with-param name="sToParse" select="substring($sToParse, $nCharToPrint+1)" />
+            <xsl:with-param name="scr" select="$scr" />
+            <xsl:with-param name="sty" select="$sty" />
+            <xsl:with-param name="nor" select="$nor" />
+          </xsl:call-template>
+        </xsl:when>
+
+        <!-- Case II: There is an operator at position 1 -->
+        <xsl:when test="$fOperAtPos1='1'">
+          <mml:mo>
+            <xsl:call-template name="CreateTokenAttributes">
+              <xsl:with-param name="scr" />
+              <xsl:with-param name="sty" />
+              <xsl:with-param name="nor" select="$nor" />
+              <xsl:with-param name="sTokenType" select="'mo'" />
+            </xsl:call-template>
+            <xsl:value-of select="substring($sToParse,1,1)" />
+          </mml:mo>
+          <xsl:call-template name="ParseMt">
+            <xsl:with-param name="sToParse" select="substring($sToParse, 2)" />
+            <xsl:with-param name="scr" select="$scr" />
+            <xsl:with-param name="sty" select="$sty" />
+            <xsl:with-param name="nor" select="$nor" />
+          </xsl:call-template>
+        </xsl:when>
+
+        <!-- Case III: There is a number at position 1 -->
+        <xsl:otherwise>
+          <xsl:variable name="sConsecNum">
+            <xsl:call-template name="SNumStart">
+              <xsl:with-param name="sToParse" select="$sToParse" />
+              <xsl:with-param name="sPattern" select="$sRepNumWith0" />
+            </xsl:call-template>
+          </xsl:variable>
+          <mml:mn>
+            <xsl:call-template name="CreateTokenAttributes">
+              <xsl:with-param name="scr" select="$scr" />
+              <xsl:with-param name="sty" select="'p'" />
+              <xsl:with-param name="nor" select="$nor" />
+              <xsl:with-param name="sTokenType" select="'mn'" />
+            </xsl:call-template>
+            <xsl:value-of select="$sConsecNum" />
+          </mml:mn>
+          <xsl:call-template name="ParseMt">
+            <xsl:with-param name="sToParse" select="substring-after($sToParse, $sConsecNum)" />
+            <xsl:with-param name="scr" select="$scr" />
+            <xsl:with-param name="sty" select="$sty" />
+            <xsl:with-param name="nor" select="$nor" />
+          </xsl:call-template>
+        </xsl:otherwise>
+      </xsl:choose>
+    </xsl:if>
+  </xsl:template>
+
+  <!-- %%Template: SNumStart 
+	
+		Return the longest substring of sToParse starting from the 
+		start of sToParse that is a number. In addition, it takes the
+		pattern string, which is sToParse with all of its numbers 
+		replaced with a 0. sPattern should be the same length 
+		as sToParse		
+	-->
+  <xsl:template name="SNumStart">
+    <xsl:param name="sToParse" select="''" />
+    <!-- if we don't get anything, take the string itself -->
+    <xsl:param name="sPattern" select="'$sToParse'" />
+
+
+    <xsl:choose>
+      <!-- the pattern says this is a number, recurse with the rest -->
+      <xsl:when test="substring($sPattern, 1, 1) = '0'">
+        <xsl:call-template name="SNumStart">
+          <xsl:with-param name="sToParse" select="$sToParse" />
+          <xsl:with-param name="sPattern" select="substring($sPattern, 2)" />
+        </xsl:call-template>
+      </xsl:when>
+
+      <!-- the pattern says we've run out of numbers. Take as many
+				characters from sToParse as we shaved off sPattern -->
+      <xsl:otherwise>
+        <xsl:value-of select="substring($sToParse, 1, string-length($sToParse) - string-length($sPattern))" />
+      </xsl:otherwise>
+    </xsl:choose>
+  </xsl:template>
+
+  <!-- %%Template SRepeatCharAcc
+	
+			The core of SRepeatChar with an accumulator. The current
+			string is in param $acc, and we will double and recurse,
+			if we're less than half of the required length or else just 
+			add the right amount of characters to the accumulator and
+			return
+	-->
+  <xsl:template name="SRepeatCharAcc">
+    <xsl:param name="cchRequired" select="1" />
+    <xsl:param name="ch" select="'-'" />
+    <xsl:param name="acc" select="$ch" />
+
+    <xsl:variable name="cchAcc" select="string-length($acc)" />
+    <xsl:choose>
+      <xsl:when test="(2 * $cchAcc) &lt; $cchRequired">
+        <xsl:call-template name="SRepeatCharAcc">
+          <xsl:with-param name="cchRequired" select="$cchRequired" />
+          <xsl:with-param name="ch" select="$ch" />
+          <xsl:with-param name="acc" select="concat($acc, $acc)" />
+        </xsl:call-template>
+      </xsl:when>
+
+      <xsl:otherwise>
+        <xsl:value-of select="concat($acc, substring($acc, 1, $cchRequired - $cchAcc))" />
+      </xsl:otherwise>
+    </xsl:choose>
+  </xsl:template>
+
+
+  <!-- %%Template SRepeatChar
+	
+			Generates a string nchRequired long by repeating the given character ch
+	-->
+  <xsl:template name="SRepeatChar">
+    <xsl:param name="cchRequired" select="1" />
+    <xsl:param name="ch" select="'-'" />
+
+    <xsl:call-template name="SRepeatCharAcc">
+      <xsl:with-param name="cchRequired" select="$cchRequired" />
+      <xsl:with-param name="ch" select="$ch" />
+      <xsl:with-param name="acc" select="$ch" />
+    </xsl:call-template>
+  </xsl:template>
+
+  <!-- %%Template SReplaceOperWithMinus
+	
+		Go through the given string and replace every instance
+		of an operator with a minus '-'. This helps quickly identify
+		the first instance of an operator.  
+	-->
+  <xsl:template name="SReplaceOperWithMinus">
+    <xsl:param name="sToParse" select="''" />
+
+    <xsl:value-of select="translate($sToParse, $sOperators, $sMinuses)" />
+  </xsl:template>
+
+  <!-- %%Template SReplaceNumWithZero
+	
+		Go through the given string and replace every instance
+		of an number with a zero '0'. This helps quickly identify
+		the first occurence of a number. 
+		
+		Considers the '.' and ',' part of a number iff they are sandwiched 
+		between two other numbers. 0.3 will be recognized as a number,
+		x.3 will not be. Since these characters can also be an operator, this 
+		should be called before SReplaceOperWithMinus.
+	-->
+  <xsl:template name="SReplaceNumWithZero">
+    <xsl:param name="sToParse" select="''" />
+
+    <!-- First do a simple replace. Numbers will all be come 0's.
+			After this point, the pattern involving the . or , that 
+			we are looking for will become 0.0 or 0,0 -->
+    <xsl:variable name="sSimpleReplace" select="translate($sToParse, $sNumbers, $sZeros)" />
+
+    <!-- And then, replace 0.0 with just 000. This means that the . will 
+			become part of the number -->
+    <xsl:variable name="sReplacePeriod">
+      <xsl:call-template name="SReplace">
+        <xsl:with-param name="sInput" select="$sSimpleReplace" />
+        <xsl:with-param name="sOrig" select="'0.0'" />
+        <xsl:with-param name="sReplacement" select="'000'" />
+      </xsl:call-template>
+    </xsl:variable>
+
+    <!-- And then, replace 0,0 with just 000. This means that the , will 
+			become part of the number -->
+    <xsl:call-template name="SReplace">
+      <xsl:with-param name="sInput" select="$sReplacePeriod" />
+      <xsl:with-param name="sOrig" select="'0,0'" />
+      <xsl:with-param name="sReplacement" select="'000'" />
+    </xsl:call-template>
+  </xsl:template>
+
+  <!-- Template to translate Word's borderBox properties into the menclose notation attribute
+       The initial call to this SHOULD NOT pass an sAttribute.  Subsequent calls to 
+       CreateMencloseNotationAttrFromBorderBoxAttr by CreateMencloseNotationAttrFromBorderBoxAttr will
+       update the sAttribute as appropriate.
+       
+       CreateMencloseNotationAttrFromBorderBoxAttr looks at each attribute (fHideTop, fHideBot, etc.) one at a time
+       in the order they are listed and passes a modified sAttribute to CreateMencloseNotationAttrFromBorderBoxAttr.
+       Each successive call to CreateMencloseNotationAttrFromBorderBoxAttr knows which attribute to look at because 
+       the previous call should have omitted passing the attribute it just analyzed.  This is why as you read lower 
+       and lower in the template that each call to CreateMencloseNotationAttrFromBorderBoxAttr has fewer and fewer attributes.
+       -->
+  <xsl:template name="CreateMencloseNotationAttrFromBorderBoxAttr">
+    <xsl:param name="fHideTop" />
+    <xsl:param name="fHideBot" />
+    <xsl:param name="fHideLeft" />
+    <xsl:param name="fHideRight" />
+    <xsl:param name="fStrikeH" />
+    <xsl:param name="fStrikeV" />
+    <xsl:param name="fStrikeBLTR" />
+    <xsl:param name="fStrikeTLBR" />
+    <xsl:param name="sAttribute" />
+
+    <xsl:choose>
+      <xsl:when test="string-length($sAttribute) = 0">
+        <xsl:choose>
+          <xsl:when test="string-length($fHideTop) &gt; 0
+                      and string-length($fHideBot) &gt; 0 
+                      and string-length($fHideLeft) &gt; 0
+                      and string-length($fHideRight) &gt; 0">
+
+            <xsl:choose>
+              <xsl:when test="$fHideTop = 0 
+                              and $fHideBot = 0
+                              and $fHideLeft = 0 
+                              and $fHideRight = 0">
+                <!-- We can use 'box' instead of top, bot, left, and right.  Therefore,
+                  replace sAttribute with 'box' and begin analyzing params fStrikeH
+                  and below. -->
+                <xsl:call-template name="CreateMencloseNotationAttrFromBorderBoxAttr">
+                  <xsl:with-param name="fStrikeH" select="$fStrikeH" />
+                  <xsl:with-param name="fStrikeV" select="$fStrikeV" />
+                  <xsl:with-param name="fStrikeBLTR" select="$fStrikeBLTR" />
+                  <xsl:with-param name="fStrikeTLBR" select="$fStrikeTLBR" />
+                  <xsl:with-param name="sAttribute">
+                    <xsl:text>box</xsl:text>
+                  </xsl:with-param>
+                </xsl:call-template>
+              </xsl:when>
+              <xsl:otherwise>
+                <!-- Can't use 'box', theremore, must analyze all attributes -->
+                <xsl:call-template name="CreateMencloseNotationAttrFromBorderBoxAttr">
+                  <xsl:with-param name="fHideTop" select="$fHideTop" />
+                  <xsl:with-param name="fHideBot" select="$fHideBot" />
+                  <xsl:with-param name="fHideLeft" select="$fHideLeft" />
+                  <xsl:with-param name="fHideRight" select="$fHideRight" />
+                  <xsl:with-param name="fStrikeH" select="$fStrikeH" />
+                  <xsl:with-param name="fStrikeV" select="$fStrikeV" />
+                  <xsl:with-param name="fStrikeBLTR" select="$fStrikeBLTR" />
+                  <xsl:with-param name="fStrikeTLBR" select="$fStrikeTLBR" />
+                  <xsl:with-param name="sAttribute">
+                    <!-- Assume using all four (left right top bottom).  Subsequent calls
+                         will remove the sides which aren't to be includes. -->
+                    <xsl:text>left right top bottom</xsl:text>
+                  </xsl:with-param>
+                </xsl:call-template>
+              </xsl:otherwise>
+            </xsl:choose>
+          </xsl:when>
+        </xsl:choose>
+      </xsl:when>
+      <xsl:otherwise>
+        <xsl:choose>
+          <xsl:when test="string-length($fHideTop) &gt; 0">
+            <xsl:choose>
+              <xsl:when test="$fHideTop=1">
+                <xsl:call-template name="CreateMencloseNotationAttrFromBorderBoxAttr">
+                  <xsl:with-param name="fHideBot" select="$fHideBot" />
+                  <xsl:with-param name="fHideLeft" select="$fHideLeft" />
+                  <xsl:with-param name="fHideRight" select="$fHideRight" />
+                  <xsl:with-param name="fStrikeH" select="$fStrikeH" />
+                  <xsl:with-param name="fStrikeV" select="$fStrikeV" />
+                  <xsl:with-param name="fStrikeBLTR" select="$fStrikeBLTR" />
+                  <xsl:with-param name="fStrikeTLBR" select="$fStrikeTLBR" />
+                  <xsl:with-param name="sAttribute">
+                    <xsl:call-template name="SReplace">
+                      <xsl:with-param name="sInput" select="$sAttribute" />
+                      <xsl:with-param name="sOrig" select="'top'" />
+                      <xsl:with-param name="sReplacement" select="''" />
+                    </xsl:call-template>
+                  </xsl:with-param>
+                </xsl:call-template>
+              </xsl:when>
+              <xsl:otherwise>
+                <xsl:call-template name="CreateMencloseNotationAttrFromBorderBoxAttr">
+                  <xsl:with-param name="fHideBot" select="$fHideBot" />
+                  <xsl:with-param name="fHideLeft" select="$fHideLeft" />
+                  <xsl:with-param name="fHideRight" select="$fHideRight" />
+                  <xsl:with-param name="fStrikeH" select="$fStrikeH" />
+                  <xsl:with-param name="fStrikeV" select="$fStrikeV" />
+                  <xsl:with-param name="fStrikeBLTR" select="$fStrikeBLTR" />
+                  <xsl:with-param name="fStrikeTLBR" select="$fStrikeTLBR" />
+                  <xsl:with-param name="sAttribute" select="$sAttribute" />
+                </xsl:call-template>
+              </xsl:otherwise>
+            </xsl:choose>
+          </xsl:when>
+          <xsl:when test="string-length($fHideBot) &gt; 0">
+            <xsl:choose>
+              <xsl:when test="$fHideBot=1">
+                <xsl:call-template name="CreateMencloseNotationAttrFromBorderBoxAttr">
+                  <xsl:with-param name="fHideLeft" select="$fHideLeft" />
+                  <xsl:with-param name="fHideRight" select="$fHideRight" />
+                  <xsl:with-param name="fStrikeH" select="$fStrikeH" />
+                  <xsl:with-param name="fStrikeV" select="$fStrikeV" />
+                  <xsl:with-param name="fStrikeBLTR" select="$fStrikeBLTR" />
+                  <xsl:with-param name="fStrikeTLBR" select="$fStrikeTLBR" />
+                  <xsl:with-param name="sAttribute">
+                    <xsl:call-template name="SReplace">
+                      <xsl:with-param name="sInput" select="$sAttribute" />
+                      <xsl:with-param name="sOrig" select="'bottom'" />
+                      <xsl:with-param name="sReplacement" select="''" />
+                    </xsl:call-template>
+                  </xsl:with-param>
+                </xsl:call-template>
+              </xsl:when>
+              <xsl:otherwise>
+                <xsl:call-template name="CreateMencloseNotationAttrFromBorderBoxAttr">
+                  <xsl:with-param name="fHideLeft" select="$fHideLeft" />
+                  <xsl:with-param name="fHideRight" select="$fHideRight" />
+                  <xsl:with-param name="fStrikeH" select="$fStrikeH" />
+                  <xsl:with-param name="fStrikeV" select="$fStrikeV" />
+                  <xsl:with-param name="fStrikeBLTR" select="$fStrikeBLTR" />
+                  <xsl:with-param name="fStrikeTLBR" select="$fStrikeTLBR" />
+                  <xsl:with-param name="sAttribute" select="$sAttribute" />
+                </xsl:call-template>
+              </xsl:otherwise>
+            </xsl:choose>
+          </xsl:when>
+          <xsl:when test="string-length($fHideLeft) &gt; 0">
+            <xsl:choose>
+              <xsl:when test="$fHideLeft=1">
+                <xsl:call-template name="CreateMencloseNotationAttrFromBorderBoxAttr">
+                  <xsl:with-param name="fHideRight" select="$fHideRight" />
+                  <xsl:with-param name="fStrikeH" select="$fStrikeH" />
+                  <xsl:with-param name="fStrikeV" select="$fStrikeV" />
+                  <xsl:with-param name="fStrikeBLTR" select="$fStrikeBLTR" />
+                  <xsl:with-param name="fStrikeTLBR" select="$fStrikeTLBR" />
+                  <xsl:with-param name="sAttribute">
+                    <xsl:call-template name="SReplace">
+                      <xsl:with-param name="sInput" select="$sAttribute" />
+                      <xsl:with-param name="sOrig" select="'left'" />
+                      <xsl:with-param name="sReplacement" select="''" />
+                    </xsl:call-template>
+                  </xsl:with-param>
+                </xsl:call-template>
+              </xsl:when>
+              <xsl:otherwise>
+                <xsl:call-template name="CreateMencloseNotationAttrFromBorderBoxAttr">
+                  <xsl:with-param name="fHideRight" select="$fHideRight" />
+                  <xsl:with-param name="fStrikeH" select="$fStrikeH" />
+                  <xsl:with-param name="fStrikeV" select="$fStrikeV" />
+                  <xsl:with-param name="fStrikeBLTR" select="$fStrikeBLTR" />
+                  <xsl:with-param name="fStrikeTLBR" select="$fStrikeTLBR" />
+                  <xsl:with-param name="sAttribute" select="$sAttribute" />
+                </xsl:call-template>
+              </xsl:otherwise>
+            </xsl:choose>
+          </xsl:when>
+          <xsl:when test="string-length($fHideRight) &gt; 0">
+            <xsl:choose>
+              <xsl:when test="$fHideRight=1">
+                <xsl:call-template name="CreateMencloseNotationAttrFromBorderBoxAttr">
+                  <xsl:with-param name="fStrikeH" select="$fStrikeH" />
+                  <xsl:with-param name="fStrikeV" select="$fStrikeV" />
+                  <xsl:with-param name="fStrikeBLTR" select="$fStrikeBLTR" />
+                  <xsl:with-param name="fStrikeTLBR" select="$fStrikeTLBR" />
+                  <xsl:with-param name="sAttribute">
+                    <xsl:call-template name="SReplace">
+                      <xsl:with-param name="sInput" select="$sAttribute" />
+                      <xsl:with-param name="sOrig" select="'right'" />
+                      <xsl:with-param name="sReplacement" select="''" />
+                    </xsl:call-template>
+                  </xsl:with-param>
+                </xsl:call-template>
+              </xsl:when>
+              <xsl:otherwise>
+                <xsl:call-template name="CreateMencloseNotationAttrFromBorderBoxAttr">
+                  <xsl:with-param name="fStrikeH" select="$fStrikeH" />
+                  <xsl:with-param name="fStrikeV" select="$fStrikeV" />
+                  <xsl:with-param name="fStrikeBLTR" select="$fStrikeBLTR" />
+                  <xsl:with-param name="fStrikeTLBR" select="$fStrikeTLBR" />
+                  <xsl:with-param name="sAttribute" select="$sAttribute" />
+                </xsl:call-template>
+              </xsl:otherwise>
+            </xsl:choose>
+          </xsl:when>
+          <xsl:when test="string-length($fStrikeH) &gt; 0">
+            <xsl:choose>
+              <xsl:when test="$fStrikeH=1">
+                <xsl:call-template name="CreateMencloseNotationAttrFromBorderBoxAttr">
+                  <xsl:with-param name="fStrikeV" select="$fStrikeV" />
+                  <xsl:with-param name="fStrikeBLTR" select="$fStrikeBLTR" />
+                  <xsl:with-param name="fStrikeTLBR" select="$fStrikeTLBR" />
+                  <xsl:with-param name="sAttribute" select="concat($sAttribute, ' horizontalstrike')" />
+                </xsl:call-template>
+              </xsl:when>
+              <xsl:otherwise>
+                <xsl:call-template name="CreateMencloseNotationAttrFromBorderBoxAttr">
+                  <xsl:with-param name="fStrikeV" select="$fStrikeV" />
+                  <xsl:with-param name="fStrikeBLTR" select="$fStrikeBLTR" />
+                  <xsl:with-param name="fStrikeTLBR" select="$fStrikeTLBR" />
+                  <xsl:with-param name="sAttribute" select="$sAttribute" />
+                </xsl:call-template>
+              </xsl:otherwise>
+            </xsl:choose>
+          </xsl:when>
+          <xsl:when test="string-length($fStrikeV) &gt; 0">
+            <xsl:choose>
+              <xsl:when test="$fStrikeV=1">
+                <xsl:call-template name="CreateMencloseNotationAttrFromBorderBoxAttr">
+                  <xsl:with-param name="fStrikeBLTR" select="$fStrikeBLTR" />
+                  <xsl:with-param name="fStrikeTLBR" select="$fStrikeTLBR" />
+                  <xsl:with-param name="sAttribute" select="concat($sAttribute, ' verticalstrike')" />
+                </xsl:call-template>
+              </xsl:when>
+              <xsl:otherwise>
+                <xsl:call-template name="CreateMencloseNotationAttrFromBorderBoxAttr">
+                  <xsl:with-param name="fStrikeBLTR" select="$fStrikeBLTR" />
+                  <xsl:with-param name="fStrikeTLBR" select="$fStrikeTLBR" />
+                  <xsl:with-param name="sAttribute" select="$sAttribute" />
+                </xsl:call-template>
+              </xsl:otherwise>
+            </xsl:choose>
+          </xsl:when>
+          <xsl:when test="string-length($fStrikeBLTR) &gt; 0">
+            <xsl:choose>
+              <xsl:when test="$fStrikeBLTR=1">
+                <xsl:call-template name="CreateMencloseNotationAttrFromBorderBoxAttr">
+                  <xsl:with-param name="fStrikeTLBR" select="$fStrikeTLBR" />
+                  <xsl:with-param name="sAttribute" select="concat($sAttribute, ' updiagonalstrike')" />
+                </xsl:call-template>
+              </xsl:when>
+              <xsl:otherwise>
+                <xsl:call-template name="CreateMencloseNotationAttrFromBorderBoxAttr">
+                  <xsl:with-param name="fStrikeTLBR" select="$fStrikeTLBR" />
+                  <xsl:with-param name="sAttribute" select="$sAttribute" />
+                </xsl:call-template>
+              </xsl:otherwise>
+            </xsl:choose>
+          </xsl:when>
+          <xsl:when test="string-length($fStrikeTLBR) &gt; 0">
+            <xsl:choose>
+              <xsl:when test="$fStrikeTLBR=1">
+                <xsl:call-template name="CreateMencloseNotationAttrFromBorderBoxAttr">
+                  <xsl:with-param name="sAttribute" select="concat($sAttribute, ' downdiagonalstrike')" />
+                </xsl:call-template>
+              </xsl:when>
+              <xsl:otherwise>
+                <xsl:call-template name="CreateMencloseNotationAttrFromBorderBoxAttr">
+                  <xsl:with-param name="sAttribute" select="$sAttribute" />
+                </xsl:call-template>
+              </xsl:otherwise>
+            </xsl:choose>
+          </xsl:when>
+          <xsl:otherwise>
+            <xsl:attribute name="notation">
+              <xsl:value-of select="normalize-space($sAttribute)" />
+            </xsl:attribute>
+          </xsl:otherwise>
+        </xsl:choose>
+      </xsl:otherwise>
+    </xsl:choose>
+  </xsl:template>
+
+  <!-- Tristate (true, false, neither) from string value -->
+  <xsl:template name="TFromStrVal">
+    <xsl:param name="str" />
+    <xsl:choose>
+      <xsl:when test="$str = 'on' or $str = '1' or $str = 'true'">1</xsl:when>
+      <xsl:when test="$str = 'off' or $str = '0' or $str = 'false'">0</xsl:when>
+      <xsl:otherwise>-1</xsl:otherwise>
+    </xsl:choose>
+  </xsl:template>
+
+  <!-- Return 0 iff $str is explicitly set to a false value.  
+       Return true otherwise -->
+  <xsl:template name="ForceFalseStrVal">
+    <xsl:param name="str" />
+    <xsl:variable name="tValue">
+      <xsl:call-template name="TFromStrVal">
+        <xsl:with-param name="str" select="$str"/>
+      </xsl:call-template>
+    </xsl:variable>
+    <xsl:choose>
+      <xsl:when test="$tValue = '0'">0</xsl:when>
+      <xsl:otherwise>1</xsl:otherwise>
+    </xsl:choose>
+  </xsl:template>
+
+  <!-- Return 1 iff $str is explicitly set to a true value.  
+       Return false otherwise -->
+  <xsl:template name="ForceTrueStrVal">
+    <xsl:param name="str" />
+    <xsl:variable name="tValue">
+      <xsl:call-template name="TFromStrVal">
+        <xsl:with-param name="str" select="$str"/>
+      </xsl:call-template>
+    </xsl:variable>
+    <xsl:choose>
+      <xsl:when test="$tValue = '1'">1</xsl:when>
+      <xsl:otherwise>0</xsl:otherwise>
+    </xsl:choose>
+  </xsl:template>
+</xsl:stylesheet>