<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>

<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, '⁢​', '')"/>
  </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="'⩵'"/>
      <xsl:with-param name="sReplacement" select="'=='"/>
    </xsl:call-template>
  </xsl:variable>
  <!-- Finally, return the last value -->
  <xsl:value-of select="$sCharReplace"/>
</xsl:template>

<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>

<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>

<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>

<xsl:template mode="mml" 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 mode="mml"/>
          </xsl:otherwise>
        </xsl:choose>
      </xsl:otherwise>
    </xsl:choose>
  </xsl:if>
</xsl:template>

<xsl:template mode="mml" 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 transformed
			 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-->
      <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:with-param name="fLit">
            <xsl:call-template name="FLit">
              <xsl:with-param name="ndCur" select="."/>
            </xsl:call-template>
          </xsl:with-param>
        </xsl:call-template>
        <t>
          <xsl:call-template name="OutputText">
            <xsl:with-param name="sInput" select="normalize-space(.)"/>
          </xsl:call-template>
        </t>
      </r>
    </xsl:otherwise>
  </xsl:choose>
</xsl:template>

<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 initial 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(.)) > 1)                    )               )           )        )        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                  or self::mml:mo                 or (self::mml:mi and string-length(normalize-space(.)) <= 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(.)) <= 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(.)) <= 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(.)) > 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.-->
  <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 different prop, or non- Token,
						although there may or may not have been a preceding different prop, or non-
						Token-->
      <xsl:when test="$cndRun > 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:with-param name="fLit">
            <xsl:call-template name="FLit">
              <xsl:with-param name="ndCur" select="$ndTokenFirst"/>
            </xsl:call-template>
          </xsl:with-param>
        </xsl:call-template>
        <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() < $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>
        </t>
      </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:with-param name="fLit">
            <xsl:call-template name="FLit">
              <xsl:with-param name="ndCur" select="$ndTokenFirst"/>
            </xsl:call-template>
          </xsl:with-param>
        </xsl:call-template>
        <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>
        </t>
      </xsl:otherwise>
    </xsl:choose>
  </r>
  <!--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>

<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>

<xsl:template name="FLit">
  <xsl:param name="ndCur" select="."/>
  <xsl:variable name="sLowerActiontype">
    <xsl:choose>
      <xsl:when test="$ndCur/ancestor::mml:maction[@actiontype='lit']/@actiontype">
        <xsl:value-of select="translate($ndCur/ancestor::mml:maction[@actiontype='lit']/@actiontype, $StrUCAlphabet,                                                                                                       $StrLCAlphabet)"/>
      </xsl:when>
      <xsl:otherwise>
        <xsl:value-of select="translate($ndCur/ancestor::mml:maction[@actiontype='lit']/@mml:actiontype, $StrUCAlphabet,                                                                                                       $StrLCAlphabet)"/>
      </xsl:otherwise>
    </xsl:choose>
  </xsl:variable>
  <xsl:choose>
    <xsl:when test="$sLowerActiontype='lit'">1</xsl:when>
    <xsl:otherwise>0</xsl:otherwise>
  </xsl:choose>
</xsl:template>

<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">Cambria Math</xsl:param>
  <xsl:param name="fontsize"/>
  <xsl:param name="fontstyle"/>
  <xsl:param name="fontweight"/>
  <xsl:param name="mathsize"/>
  <xsl:param name="ndCur"/>
  <xsl:param name="fNor"/>
  <xsl:param name="fLit"/>
  <w:rPr>
    <xsl:call-template name="mathrRpHook"/>
    <w:rFonts w:ascii="{$font-family}" w:eastAsia="{$font-family}" w:hAnsi="{$font-family}" w:cs="{$font-family}"/>
    <xsl:choose>
      <xsl:when test="$fontweight=''"/>
      <xsl:when test="$fontweight='bold'">
        <w:b/>
      </xsl:when>
      <xsl:when test="$fontweight='normal'">
        <w:b w:val="0"/>
      </xsl:when>
    </xsl:choose>
    <xsl:choose>
      <xsl:when test="$fontstyle=''"/>
      <xsl:when test="$fontstyle='italic'">
        <w:i/>
      </xsl:when>
      <xsl:when test="$fontstyle='normal'">
        <w:i w:val="0"/>
      </xsl:when>
    </xsl:choose>
  </w:rPr>
  <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:with-param name="fLit" select="$fLit"/>
  </xsl:call-template>
</xsl:template>

<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:param name="fLit"/>
  <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="$fLit=1 or $fNor=1 or ($sFontCur!='italic' and $sFontCur!='')">
    <rPr>
      <xsl:if test="$fNor=1">
        <nor/>
      </xsl:if>
      <xsl:if test="$fLit=1">
        <lit/>
      </xsl:if>
      <xsl:call-template name="CreateMathScrStyProp">
        <xsl:with-param name="font" select="$sFontCur"/>
        <xsl:with-param name="fNor" select="$fNor"/>
      </xsl:call-template>
    </rPr>
  </xsl:if>
</xsl:template>

<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)) <= 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:when test="$fontweight='normal'">
          <xsl:value-of select="'i'"/>
        </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='normal'">
          <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>

<xsl:template name="CreateMathScrStyProp">
  <xsl:param name="font"/>
  <xsl:param name="fNor" select="0"/>
  <xsl:choose>
    <xsl:when test="$font='normal' and $fNor=0">
      <sty>
        <xsl:attribute name="m:val">p</xsl:attribute>
      </sty>
    </xsl:when>
    <xsl:when test="$font='bold'">
      <sty>
        <xsl:attribute name="m:val">b</xsl:attribute>
      </sty>
    </xsl:when>
    <xsl:when test="$font='italic'">
    </xsl:when>
    <xsl:when test="$font='script'">
      <scr>
        <xsl:attribute name="m:val">script</xsl:attribute>
      </scr>
    </xsl:when>
    <xsl:when test="$font='bold-script'">
      <scr>
        <xsl:attribute name="m:val">script</xsl:attribute>
      </scr>
      <sty>
        <xsl:attribute name="m:val">b</xsl:attribute>
      </sty>
    </xsl:when>
    <xsl:when test="$font='double-struck'">
      <scr>
        <xsl:attribute name="m:val">double-struck</xsl:attribute>
      </scr>
      <sty>
        <xsl:attribute name="m:val">p</xsl:attribute>
      </sty>
    </xsl:when>
    <xsl:when test="$font='fraktur'">
      <scr>
        <xsl:attribute name="m:val">fraktur</xsl:attribute>
      </scr>
      <sty>
        <xsl:attribute name="m:val">p</xsl:attribute>
      </sty>
    </xsl:when>
    <xsl:when test="$font='bold-fraktur'">
      <scr>
        <xsl:attribute name="m:val">fraktur</xsl:attribute>
      </scr>
      <sty>
        <xsl:attribute name="m:val">b</xsl:attribute>
      </sty>
    </xsl:when>
    <xsl:when test="$font='sans-serif'">
      <scr>
        <xsl:attribute name="m:val">sans-serif</xsl:attribute>
      </scr>
      <sty>
        <xsl:attribute name="m:val">p</xsl:attribute>
      </sty>
    </xsl:when>
    <xsl:when test="$font='bold-sans-serif'">
      <scr>
        <xsl:attribute name="m:val">sans-serif</xsl:attribute>
      </scr>
      <sty>
        <xsl:attribute name="m:val">b</xsl:attribute>
      </sty>
    </xsl:when>
    <xsl:when test="$font='sans-serif-italic'">
      <scr>
        <xsl:attribute name="m:val">sans-serif</xsl:attribute>
      </scr>
    </xsl:when>
    <xsl:when test="$font='sans-serif-bold-italic'">
      <scr>
        <xsl:attribute name="m:val">sans-serif</xsl:attribute>
      </scr>
      <sty>
        <xsl:attribute name="m:val">bi</xsl:attribute>
      </sty>
    </xsl:when>
    <xsl:when test="$font='monospace'"/>
    <!-- We can't do monospace, so leave empty -->
    <xsl:when test="$font='bold'">
      <sty>
        <xsl:attribute name="m:val">b</xsl:attribute>
      </sty>
    </xsl:when>
    <xsl:when test="$font='bi' or $font='bold-italic'">
      <sty>
        <xsl:attribute name="m:val">bi</xsl:attribute>
      </sty>
    </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>

<xsl:template mode="mml" 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>
  <f>
    <fPr>
      <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>
      </type>
    </fPr>
    <num>
      <xsl:call-template name="CreateArgProp"/>
      <xsl:apply-templates mode="mml" select="child::*[1]"/>
    </num>
    <den>
      <xsl:call-template name="CreateArgProp"/>
      <xsl:apply-templates mode="mml" select="child::*[2]"/>
    </den>
  </f>
</xsl:template>

<xsl:template mode="mml" 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">
      <rad>
        <radPr>
          <degHide>
            <xsl:attribute name="m:val">on</xsl:attribute>
          </degHide>
        </radPr>
        <deg>
          <xsl:call-template name="CreateArgProp"/>
        </deg>
        <e>
          <xsl:call-template name="CreateArgProp"/>
          <xsl:apply-templates mode="mml"/>
        </e>
      </rad>
    </xsl:when>
    <xsl:otherwise>
      <xsl:choose>
        <xsl:when test="$sLowerCaseNotation='actuarial' or $sLowerCaseNotation='longdiv'"/>
        <xsl:otherwise>
          <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)                               )">
              <borderBoxPr>
                <xsl:if test="$fBox=0">
                  <xsl:if test="$fTop=0">
                    <hideTop>
                      <xsl:attribute name="m:val">on</xsl:attribute>
                    </hideTop>
                  </xsl:if>
                  <xsl:if test="$fBot=0">
                    <hideBot>
                      <xsl:attribute name="m:val">on</xsl:attribute>
                    </hideBot>
                  </xsl:if>
                  <xsl:if test="$fLeft=0">
                    <hideLeft>
                      <xsl:attribute name="m:val">on</xsl:attribute>
                    </hideLeft>
                  </xsl:if>
                  <xsl:if test="$fRight=0">
                    <hideRight>
                      <xsl:attribute name="m:val">on</xsl:attribute>
                    </hideRight>
                  </xsl:if>
                </xsl:if>
                <xsl:if test="$fStrikeH=1">
                  <strikeH>
                    <xsl:attribute name="m:val">on</xsl:attribute>
                  </strikeH>
                </xsl:if>
                <xsl:if test="$fStrikeV=1">
                  <strikeV>
                    <xsl:attribute name="m:val">on</xsl:attribute>
                  </strikeV>
                </xsl:if>
                <xsl:if test="$fStrikeBLTR=1">
                  <strikeBLTR>
                    <xsl:attribute name="m:val">on</xsl:attribute>
                  </strikeBLTR>
                </xsl:if>
                <xsl:if test="$fStrikeTLBR=1">
                  <strikeTLBR>
                    <xsl:attribute name="m:val">on</xsl:attribute>
                  </strikeTLBR>
                </xsl:if>
              </borderBoxPr>
            </xsl:if>
            <e>
              <xsl:call-template name="CreateArgProp"/>
              <xsl:apply-templates mode="mml"/>
            </e>
          </borderBox>
        </xsl:otherwise>
      </xsl:choose>
    </xsl:otherwise>
  </xsl:choose>
</xsl:template>

<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)">
    <argPr>
      <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>
      </scrLvl>
    </argPr>
  </xsl:if>
</xsl:template>

<xsl:template mode="mml" match="mml:mroot">
  <rad>
    <radPr>
      <degHide>
        <xsl:attribute name="m:val">off</xsl:attribute>
      </degHide>
    </radPr>
    <deg>
      <xsl:call-template name="CreateArgProp"/>
      <xsl:apply-templates mode="mml" select="child::*[2]"/>
    </deg>
    <e>
      <xsl:call-template name="CreateArgProp"/>
      <xsl:apply-templates mode="mml" select="child::*[1]"/>
    </e>
  </rad>
</xsl:template>

<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>

<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='⁡'">1</xsl:when>
    <xsl:otherwise>0</xsl:otherwise>
  </xsl:choose>
</xsl:template>

<xsl:template name="MakeLinearFraction">
  <xsl:param name="ndCur" select="."/>
  <f>
    <fPr>
      <type>
        <xsl:attribute name="m:val">lin</xsl:attribute>
      </type>
    </fPr>
    <num>
      <xsl:call-template name="CreateArgProp"/>
      <xsl:apply-templates mode="mml" select="$ndCur/*[1]"/>
    </num>
    <den>
      <xsl:call-template name="CreateArgProp"/>
      <xsl:apply-templates mode="mml" select="$ndCur/*[3]"/>
    </den>
  </f>
</xsl:template>

<xsl:template name="WriteFunc">
  <xsl:param name="ndCur" select="."/>
  <func>
    <fName>
      <xsl:apply-templates mode="mml" select="$ndCur/child::*[1]"/>
    </fName>
    <e>
      <xsl:apply-templates mode="mml" select="$ndCur/child::*[3]"/>
    </e>
  </func>
</xsl:template>

<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 mode="mml" select="$ndCur/*"/>
            </xsl:otherwise>
          </xsl:choose>
        </xsl:otherwise>
      </xsl:choose>
    </xsl:when>
    <xsl:when test="$ndCur[self::mml:mstyle]">
      <xsl:apply-templates mode="mml" select="$ndCur/*"/>
    </xsl:when>
  </xsl:choose>
</xsl:template>

<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 = '̲'">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 = '¯'">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>

<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="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 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) = 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>

<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) <= 1">1</xsl:when>
        <xsl:otherwise>0</xsl:otherwise>
      </xsl:choose>
    </xsl:when>
    <xsl:otherwise>0</xsl:otherwise>
  </xsl:choose>
</xsl:template>