html2doc 0.0.1

data/.rubocop.yml

@@ -0,0 +1,15 @@
+# This project follows the Ribose OSS style guide.
+# https://github.com/riboseinc/oss-guides
+# All project-specific additions and overrides should be specified in this file.
+
+inherit_from:
+  # Thoughtbot's style guide from: https://github.com/thoughtbot/guides
+  - ".rubocop.tb.yml"
+  # Overrides from Ribose
+  - ".rubocop.ribose.yml"
+AllCops:
+  DisplayCopNames: false
+  StyleGuideCopsOnly: false
+  TargetRubyVersion: 2.4
+Rails:
+  Enabled: true

data/.travis.yml

@@ -0,0 +1,5 @@
+sudo: false
+language: ruby
+rvm:
+  - 2.4.3
+before_install: gem install bundler -v 1.16.1

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,74 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+In the interest of fostering an open and welcoming environment, we as
+contributors and maintainers pledge to making participation in our project and
+our community a harassment-free experience for everyone, regardless of age, body
+size, disability, ethnicity, gender identity and expression, level of experience,
+nationality, personal appearance, race, religion, or sexual identity and
+orientation.
+
+## Our Standards
+
+Examples of behavior that contributes to creating a positive environment
+include:
+
+* Using welcoming and inclusive language
+* Being respectful of differing viewpoints and experiences
+* Gracefully accepting constructive criticism
+* Focusing on what is best for the community
+* Showing empathy towards other community members
+
+Examples of unacceptable behavior by participants include:
+
+* The use of sexualized language or imagery and unwelcome sexual attention or
+advances
+* Trolling, insulting/derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or electronic
+  address, without explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+  professional setting
+
+## Our Responsibilities
+
+Project maintainers are responsible for clarifying the standards of acceptable
+behavior and are expected to take appropriate and fair corrective action in
+response to any instances of unacceptable behavior.
+
+Project maintainers have the right and responsibility to remove, edit, or
+reject comments, commits, code, wiki edits, issues, and other contributions
+that are not aligned to this Code of Conduct, or to ban temporarily or
+permanently any contributor for other behaviors that they deem inappropriate,
+threatening, offensive, or harmful.
+
+## Scope
+
+This Code of Conduct applies both within project spaces and in public spaces
+when an individual is representing the project or its community. Examples of
+representing a project or community include using an official project e-mail
+address, posting via an official social media account, or acting as an appointed
+representative at an online or offline event. Representation of a project may be
+further defined and clarified by project maintainers.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported by contacting the project team at ronald.tse@ribose.com. All
+complaints will be reviewed and investigated and will result in a response that
+is deemed necessary and appropriate to the circumstances. The project team is
+obligated to maintain confidentiality with regard to the reporter of an incident.
+Further details of specific enforcement policies may be posted separately.
+
+Project maintainers who do not follow or enforce the Code of Conduct in good
+faith may face temporary or permanent repercussions as determined by other
+members of the project's leadership.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4,
+available at [http://contributor-covenant.org/version/1/4][version]
+
+[homepage]: http://contributor-covenant.org
+[version]: http://contributor-covenant.org/version/1/4/

data/Gemfile

@@ -0,0 +1,6 @@
+source "https://rubygems.org"
+
+git_source(:github) {|repo_name| "https://github.com/#{repo_name}" }
+
+# Specify your gem's dependencies in html2doc.gemspec
+gemspec

data/README.adoc

@@ -0,0 +1,44 @@
+= Html2Doc
+
+Gem to convert an HTML document into a Word document (.doc) format. This is intended for automated generation of Microsoft Word documents, given HTML documents, which are mmuch more readily crafted.
+
+This gem originated out of https://github.com/riboseinc/asciidoctor-iso, which creates a Word document from a Microsoft HTML document (created in turn by processing Asciidoc). The Microsoft HTML document is already quite close to Microsoft Word requirements, but future iterations of this gem will become more generic.
+
+This work is driven by the Word document generation procedure documented in http://sebsauvage.net/wiki/doku.php?id=word_document_generation
+
+The gem currently does the following:
+
+* Resize any images in the HTML file to fit within the maximum page size. (Word will otherwise crash on reading the document.)
+* Generate a filelist.xml listing of all files to be bundled into the Word document.
+* Inject Microsoft Word-specific CSS into the HTML document. The CSS file used is at `lib/html2doc/wordstyle.css`, and can be customised. (This generic CSS can be overridden by CSS already in the HTML document, since the generic CSS is injected at the top of the document.)
+* Bundle up the images, the HTML file of the document proper, and the `header.html` file representing header/footer information, into a MIME file, and save that file to disk (so that Microsoft Word can deal with it as a Word file.)
+
+Future iterations will convert generic HTML to Microsoft-specific HTML. For a representative generator of Microsoft HTML, see https://github.com/riboseinc/asciidoctor-iso
+
+Work being tracked at https://github.com/riboseinc/asciidoctor-iso/issues/47:
+
+* Render footnotes
+* Render (editorial) comments
+* Render MathML, AsciiMath
+
+== Constraints
+
+This generates .doc documents. 
+
+TO DO: compare with https://github.com/MuhammetDilmac/Html2Docx (much simpler, but generates Docx) and https://github.com/jetruby/puredocx (generates Word doc as Ruby object, necessarily simpler).
+
+== Usage
+
+[source,ruby]
+--
+require "html2doc"
+
+Html2Doc.process(result, filename, header_filename, dir)
+--
+
+result:: is the Html document to be converted into Word, as a string.
+filename:: is the name the document is to be saved as, without a file suffix
+header_filename:: is the location of the HTML document containing header and footer for the document, as well as footnote/endnote separators; if there is none, use nil. To generate your own such document, save a Word document with headers/footers and/or footnote/endnote separators as an HTML document; the `header.html` will be in the `{filename}.fld` folder generated along with the HTML. A sample file is available at https://github.com/riboseinc/asciidoctor-iso/blob/master/lib/asciidoctor/iso/word/header.html
+dir:: is the directory the document is to be saved to
+
+Note that the local CSS file contains a variable `FILENAME` for the location of footnote/endnote separators and headers/footers, which are provided in the header HTML file. The gem replaces `FILENAME` with the file nane that the document will be saved as.

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "html2doc"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/html2doc.gemspec

@@ -0,0 +1,46 @@
+
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "html2doc/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "html2doc"
+  spec.version       = Html2Doc::VERSION
+  spec.authors       = ["Ribose Inc."]
+  spec.email         = ["open.source@ribose.com"]
+
+  spec.summary       = "Convert HTML document to Microsoft Word document"
+    "in AsciiDoc."
+  spec.description   = <<~DESCRIPTION
+    Convert HTML document to Microsoft Word document.
+
+    This gem is in active development.
+  DESCRIPTION
+
+  spec.homepage      = "https://github.com/riboseinc/html2doc"
+  spec.license       = "MIT"
+
+  spec.bindir        = "bin"
+  spec.require_paths = ["lib"]
+  spec.files         = `git ls-files`.split("\n")
+  spec.test_files    = `git ls-files -- {spec}/*`.split("\n")
+  spec.required_ruby_version = Gem::Requirement.new(">= 2.4.0")
+
+  spec.add_dependency "htmlentities", "~> 4.3.4"
+  spec.add_dependency "image_size"
+  spec.add_dependency "mime-types"
+  spec.add_dependency "nokogiri", "~> 1.8.1"
+  spec.add_dependency "thread_safe"
+  spec.add_dependency "uuidtools"
+
+  spec.add_development_dependency "bundler", "~> 1.15"
+  spec.add_development_dependency "byebug", "~> 9.1"
+  spec.add_development_dependency "equivalent-xml", "~> 0.6"
+  spec.add_development_dependency "guard", "~> 2.14"
+  spec.add_development_dependency "guard-rspec", "~> 4.7"
+  spec.add_development_dependency "rake", "~> 12.0"
+  spec.add_development_dependency "rspec", "~> 3.6"
+  spec.add_development_dependency "rubocop", "~> 0.50"
+  spec.add_development_dependency "simplecov", "~> 0.15"
+  spec.add_development_dependency "timecop", "~> 0.9"
+end

data/lib/html2doc.rb

@@ -0,0 +1,2 @@
+require_relative "html2doc/version"
+require_relative "html2doc/base"

data/lib/html2doc/base.rb

@@ -0,0 +1,171 @@
+require "uuidtools"
+require "nokogiri"
+
+module Html2Doc
+  def self.process(result, filename, header_file, dir)
+    # preserve HTML escapes
+    unless /<!DOCTYPE html/.match? result
+      result.gsub!(/<\?xml version="1.0"\?>/, "")
+      result = "<!DOCTYPE html SYSTEM " +
+        "'http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd'>" + result
+    end
+    docxml = Nokogiri::XML(result)
+    image_cleanup(docxml, dir)
+    define_head(docxml, dir, filename, header_file)
+    result = self.msword_fix(docxml.to_xml)
+    system "cp #{header_file} #{dir}/header.html" unless header_file.nil?
+    generate_filelist(filename, dir)
+    File.open("#{filename}.htm", "w") { |f| f.write(result) }
+    mime_package result, filename, dir
+  end
+
+  def self.msword_fix(r)
+    # brain damage in MSWord parser
+    r.gsub(%r{<span style="mso-special-character:footnote"/>},
+           '<span style="mso-special-character:footnote"></span>').
+           gsub(%r{(<a style="mso-comment-reference:[^>/]+)/>}, "\\1></a>").
+           gsub(%r{<link rel="File-List"}, "<link rel=File-List").
+           gsub(%r{<meta http-equiv="Content-Type"},
+                "<meta http-equiv=Content-Type").
+                gsub(%r{&tab;|&amp;tab;},
+                     '<span style="mso-tab-count:1">&#xA0; </span>')
+  end
+
+  def self.image_resize(orig_filename)
+    image_size = ImageSize.path(orig_filename).size
+    # max width for Word document is 400, max height is 680
+    if image_size[0] > 400
+      image_size[1] = (image_size[1] * 400 / image_size[0]).ceil
+      image_size[0] = 400
+    end
+    if image_size[1] > 680
+      image_size[0] = (image_size[0] * 680 / image_size[1]).ceil
+      image_size[1] = 680
+    end
+    image_size
+  end
+
+  def self.image_cleanup(docxml, dir)
+    docxml.xpath("//*[local-name() = 'img']").each do |i|
+      matched = /\.(?<suffix>\S+)$/.match i["src"]
+      uuid = UUIDTools::UUID.random_create.to_s
+      new_full_filename = File.join(dir, "#{uuid}.#{matched[:suffix]}")
+      # presupposes that the image source is local
+      system "cp #{i['src']} #{new_full_filename}"
+      # image_size = image_resize(i["src"])
+      i["width"], i["height"] = image_resize(i["src"])
+      i["src"] = new_full_filename
+      #i["height"] = image_size[1]
+      #i["width"] = image_size[0]
+    end
+    docxml
+  end
+
+  def self.define_head1(docxml, dir)
+    docxml.xpath("//*[local-name() = 'head']").each do |h|
+      h.children.first.add_previous_sibling <<~XML
+            <!--[if gte mso 9]>
+            <xml>
+            <w:WordDocument>
+            <w:View>Print</w:View>
+            <w:Zoom>100</w:Zoom>
+            <w:DoNotOptimizeForBrowser/>
+            </w:WordDocument>
+            </xml>
+            <![endif]-->
+            <meta http-equiv=Content-Type content="text/html; charset=utf-8"/>
+            <link rel="File-List" href="#{dir}/filelist.xml"/>
+      XML
+    end
+  end
+
+  def self.stylesheet(filename, header_filename)
+    fn = File.join(File.dirname(__FILE__), "wordstyle.css")
+    stylesheet = File.read(fn, encoding: "UTF-8")
+    if header_filename.nil?
+      stylesheet.gsub!(/\n[^\n]*FILENAME[^\n]*i\n/, "\n")
+    else
+      stylesheet.gsub!(/FILENAME/, filename)
+    end
+    xml = Nokogiri::XML("<style/>")
+    xml.children.first << Nokogiri::XML::Comment.new(xml, "\n#{stylesheet}\n")
+    xml.root.to_s
+  end
+
+  def self.define_head(docxml, dir, filename, header_file)
+    title = docxml.at("//*[local-name() = 'head']/*[local-name() = 'title']")
+    head = docxml.at("//*[local-name() = 'head']")
+    if title.nil?
+      head.children.first.add_previous_sibling stylesheet(filename, header_file)
+    else
+      title.add_next_sibling stylesheet(filename, header_file)
+    end
+    self.define_head1(docxml, dir)
+  end
+
+  def self.mime_preamble(boundary, filename, result)
+    <<~"PREAMBLE"
+    MIME-Version: 1.0
+    Content-Type: multipart/related; boundary="#{boundary}"
+
+    --#{boundary}
+    Content-Location: file:///C:/Doc/#{filename}.htm
+    Content-Type: text/html; charset="utf-8"
+
+    #{result}
+
+    PREAMBLE
+  end
+
+  def self.mime_attachment(boundary, filename, item, dir)
+    encoded_file = Base64.strict_encode64(
+      File.read("#{dir}/#{item}"),
+    ).gsub(/(.{76})/, "\\1\n")
+    <<~"FILE"
+    --#{boundary}
+    Content-Location: file:///C:/Doc/#{filename}_files/#{item}
+    Content-Transfer-Encoding: base64
+    Content-Type: #{mime_type(item)}
+
+    #{encoded_file}
+
+    FILE
+  end
+
+  def self.mime_type(item)
+    types = MIME::Types.type_for(item)
+    type = types ? types.first.to_s : 'text/plain; charset="utf-8"'
+    type = type + ' charset="utf-8"' if /^text/.match?(type) && types
+    type
+  end
+
+  def self.mime_boundary
+    salt = UUIDTools::UUID.random_create.to_s.gsub(/-/, ".")[0..17]
+    "----=_NextPart_#{salt}"
+  end
+
+  def self.mime_package(result, filename, dir)
+    boundary = mime_boundary
+    mhtml = mime_preamble(boundary, filename, result)
+    Dir.foreach(dir) do |item|
+      next if item == "." || item == ".." || /^\./.match(item)
+      mhtml += mime_attachment(boundary, filename, item, dir)
+    end
+    mhtml += "--#{boundary}--"
+    File.open("#{filename}.doc", "w") { |f| f.write mhtml }
+  end
+
+  def self.generate_filelist(filename, dir)
+    File.open(File.join(dir, "filelist.xml"), "w") do |f|
+      f.write(<<~"XML")
+                <xml xmlns:o="urn:schemas-microsoft-com:office:office">
+                 <o:MainFile HRef="../#{filename}.htm"/>
+      XML
+      Dir.foreach(dir) do |item|
+        next if item == "." || item == ".." || /^\./.match(item)
+        f.write %{  <o:File HRef="#{item}"/>\n}
+      end
+      f.write("</xml>\n")
+    end
+  end
+end

data/lib/html2doc/mathml2omml.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>