docx2html.xsl

<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE xsl:stylesheet [<!ENTITY nbsp "&#160;">]>
<xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
                xmlns:w="http://schemas.openxmlformats.org/wordprocessingml/2006/main"
                xmlns:a="http://schemas.openxmlformats.org/drawingml/2006/main"
                xmlns:o="urn:schemas-microsoft-com:office:office"
                xmlns:v="urn:schemas-microsoft-com:vml"
                xmlns:WX="http://schemas.microsoft.com/office/word/2003/auxHint"
                xmlns:aml="http://schemas.microsoft.com/aml/2001/core"
                xmlns:w10="urn:schemas-microsoft-com:office:word"
                xmlns:mml="http://www.w3.org/1998/Math/MathML"
                xmlns:m="http://schemas.openxmlformats.org/officeDocument/2006/math"
                xmlns:wp="http://schemas.openxmlformats.org/drawingml/2006/wordprocessingDrawing"
                xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships"
                xmlns="http://www.w3.org/1999/xhtml"
                version="1.0">

    <xsl:param name="pmathml" select="''"/>
    <xsl:param name="dtd" select="false()"/>


    <xsl:output method="html" encoding="utf-8" omit-xml-declaration="yes" indent="yes"/>

    <xsl:variable name="paraStyleID_Default">Normal</xsl:variable>
    <xsl:variable name="tblStyleID_Default">TableNormal</xsl:variable>

    <xsl:variable name="tblStyleSuffix">-T</xsl:variable>
    <xsl:variable name="rowStyleSuffix">-R</xsl:variable>
    <xsl:variable name="cellStyleSuffix">-C</xsl:variable>
    <xsl:variable name="paraStyleSuffix">-P</xsl:variable>
    <xsl:variable name="charStyleSuffix">-H</xsl:variable>

    <xsl:variable name="paraMarginDefaultTop">0pt</xsl:variable>
    <xsl:variable name="paraMarginDefaultRight">0pt</xsl:variable>
    <xsl:variable name="paraMarginDefaultBottom">.0001pt</xsl:variable>
    <xsl:variable name="paraMarginDefaultLeft">0pt</xsl:variable>

    <xsl:variable name="cxtSpacing_all"></xsl:variable>
    <xsl:variable name="cxtSpacing_top">t</xsl:variable>
    <xsl:variable name="cxtSpacing_bottom">b</xsl:variable>
    <xsl:variable name="cxtSpacing_none">
        <xsl:value-of select="$cxtSpacing_top"/>
        <xsl:value-of select="$cxtSpacing_bottom"/>
    </xsl:variable>

    <xsl:variable name="bdrSide_top">-top</xsl:variable>
    <xsl:variable name="bdrSide_right">-right</xsl:variable>
    <xsl:variable name="bdrSide_bottom">-bottom</xsl:variable>
    <xsl:variable name="bdrSide_left">-left</xsl:variable>
    <xsl:variable name="bdrSide_char"></xsl:variable>

    <xsl:variable name="prrFrame">1</xsl:variable>
    <xsl:variable name="prrDefaultCellpadding">2</xsl:variable>
    <xsl:variable name="prrCellspacing">3</xsl:variable>
    <xsl:variable name="prrBdrPr_top">4</xsl:variable>
    <xsl:variable name="prrBdrPr_right">5</xsl:variable>
    <xsl:variable name="prrBdrPr_bottom">6</xsl:variable>
    <xsl:variable name="prrBdrPr_left">7</xsl:variable>
    <xsl:variable name="prrBdrPr_between">8</xsl:variable>
    <xsl:variable name="prrBdrPr_bar">9</xsl:variable>
    <xsl:variable name="prrBdrPr_insideH">A</xsl:variable>
    <xsl:variable name="prrBdrPr_insideV">B</xsl:variable>
    <xsl:variable name="prrListSuff">C</xsl:variable>
    <xsl:variable name="prrListInd">D</xsl:variable>
    <xsl:variable name="prrApplyRPr">E</xsl:variable>
    <xsl:variable name="prrUpdateRPr">F</xsl:variable>
    <xsl:variable name="prrApplyTcPr">G</xsl:variable>
    <xsl:variable name="prrCustomCellpadding">H</xsl:variable>
    <xsl:variable name="prrCantSplit">I</xsl:variable>
    <xsl:variable name="prrTblInd">J</xsl:variable>
    <xsl:variable name="prrList">K</xsl:variable>
    <xsl:variable name="prrNonList">L</xsl:variable>

    <xsl:variable name="cnfFirstRow">firstRow</xsl:variable>
    <xsl:variable name="cnfLastRow">lastRow</xsl:variable>
    <xsl:variable name="cnfFirstCol">firstCol</xsl:variable>
    <xsl:variable name="cnfLastCol">lastCol</xsl:variable>
    <xsl:variable name="cnfBand1Vert">band1Vert</xsl:variable>
    <xsl:variable name="cnfBand2Vert">band2Vert</xsl:variable>
    <xsl:variable name="cnfBand1Horz">band1Horz</xsl:variable>
    <xsl:variable name="cnfBand2Horz">band2Horz</xsl:variable>
    <xsl:variable name="cnfNECell">neCell</xsl:variable>
    <xsl:variable name="cnfNWCell">nwCell</xsl:variable>
    <xsl:variable name="cnfSECell">seCell</xsl:variable>
    <xsl:variable name="cnfSWCell">swCell</xsl:variable>

    <xsl:variable name="icnfFirstRow">1</xsl:variable>
    <xsl:variable name="icnfLastRow">2</xsl:variable>
    <xsl:variable name="icnfFirstCol">3</xsl:variable>
    <xsl:variable name="icnfLastCol">4</xsl:variable>
    <xsl:variable name="icnfBand1Vert">5</xsl:variable>
    <xsl:variable name="icnfBand2Vert">6</xsl:variable>
    <xsl:variable name="icnfBand1Horz">7</xsl:variable>
    <xsl:variable name="icnfBand2Horz">8</xsl:variable>
    <xsl:variable name="icnfNECell">9</xsl:variable>
    <xsl:variable name="icnfNWCell">10</xsl:variable>
    <xsl:variable name="icnfSECell">11</xsl:variable>
    <xsl:variable name="icnfSWCell">12</xsl:variable>

    <xsl:variable name="off">0</xsl:variable>
    <xsl:variable name="on">1</xsl:variable>
    <xsl:variable name="na">2</xsl:variable>

    <xsl:variable name="defaultFontSz">20</xsl:variable>

    <xsl:variable name="sep">/</xsl:variable>
    <xsl:variable name="sep1">|</xsl:variable>
    <xsl:variable name="sep2">,</xsl:variable>

    <xsl:variable name="autoColor_hex">auto</xsl:variable>
    <xsl:variable name="autoColor_text">windowtext</xsl:variable>
    <xsl:variable name="autoColor_bg">transparent</xsl:variable>

    <xsl:variable name="transparentColor_hex">transparent</xsl:variable>
    <xsl:variable name="transparentColor_text">transparent</xsl:variable>
    <xsl:variable name="transparentColor_bg">transparent</xsl:variable>

    <xsl:variable name="prListSuff_space">Space</xsl:variable>
    <xsl:variable name="prListSuff_nothing">Nothing</xsl:variable>

    <xsl:variable name="nsStyles" select="/w:document[1]/w:styles[1]/w:style"/>
    <xsl:variable name="ndLists" select="/w:document[1]/w:numbering[1]|//w:cfChunk/w:numbering"/>
    <xsl:variable name="ndDocPr" select="/w:document[1]/w:settings[1]"/>
    <xsl:variable name="ndDocInfo" select="/w:document[1]/w:docInfo[1]"/>
    <xsl:variable name="ndOfficeDocPr" select="/w:document[1]/o:DocumentProperties[1]"/>

    <xsl:variable name="lowercase" select="'abcdefghijklmnopqrstuvwxyz'"/>
    <xsl:variable name="uppercase" select="'ABCDEFGHIJKLMNOPQRSTUVWXYZ'"/>

    <xsl:variable name="pixelsPerInch">
        <xsl:choose>
            <xsl:when test="$ndDocPr/w:pixelsPerInch/@w:val">
                <xsl:value-of select="$ndDocPr/w:pixelsPerInch/@w:val"/>
            </xsl:when>
            <xsl:otherwise>96</xsl:otherwise>
        </xsl:choose>
    </xsl:variable>

    <xsl:variable name="nfcBullet">bullet</xsl:variable>

    <xsl:variable name="iEmbossImprint">1</xsl:variable>
    <xsl:variable name="iU_Em">2</xsl:variable>
    <xsl:variable name="iStrikeDStrike">3</xsl:variable>
    <xsl:variable name="iSup">4</xsl:variable>
    <xsl:variable name="iSub">5</xsl:variable>
    <xsl:variable name="iVanishWebHidden">6</xsl:variable>
    <xsl:variable name="iBCs">7</xsl:variable>
    <xsl:variable name="iICs">8</xsl:variable>
    <xsl:variable name="iAsciiTheme">9</xsl:variable>
    <xsl:variable name="iAnsiTheme">10</xsl:variable>
    <xsl:variable name="iEATheme">11</xsl:variable>
    <xsl:variable name="iCSTheme">12</xsl:variable>
    <xsl:variable name="ISzCs">13</xsl:variable>

    <xsl:variable name="iTextAutospaceO">1</xsl:variable>
    <xsl:variable name="iTextAutospaceN">2</xsl:variable>
    <xsl:variable name="iInd">3</xsl:variable>

    <xsl:variable name="prsRDefault">
        <xsl:variable name="innerDefault">
            <xsl:value-of select="$na"/>
            <xsl:value-of select="$na"/>
            <xsl:value-of select="$na"/>
            <xsl:value-of select="$na"/>
            <xsl:value-of select="$na"/>
            <xsl:value-of select="$na"/>
            <xsl:value-of select="$na"/>
            <xsl:value-of select="$na"/>
            <xsl:value-of select="$na"/>
            <xsl:value-of select="$na"/>
            <xsl:value-of select="$na"/>
            <xsl:value-of select="$na"/>
            <xsl:value-of select="$defaultFontSz"/>
        </xsl:variable>

        <xsl:for-each select="/w:document[1]/w:styles[1]/w:docDefaults/w:rPrDefault">
            <xsl:call-template name="PrsUpdateRPrCore">
                <xsl:with-param name="prsR" select="$innerDefault"/>
            </xsl:call-template>
        </xsl:for-each>
    </xsl:variable>

    <xsl:variable name="minorAscii">0</xsl:variable>
    <xsl:variable name="minorAnsi">1</xsl:variable>
    <xsl:variable name="minorEA">3</xsl:variable>
    <xsl:variable name="minorCS">4</xsl:variable>
    <xsl:variable name="majorAscii">5</xsl:variable>
    <xsl:variable name="majorAnsi">6</xsl:variable>
    <xsl:variable name="majorEA">7</xsl:variable>
    <xsl:variable name="majorCS">8</xsl:variable>

    <xsl:variable name="textClassAscii">asciiText</xsl:variable>
    <xsl:variable name="textClassAnsi">hAnsiText</xsl:variable>
    <xsl:variable name="textClassEA">eaText</xsl:variable>
    <xsl:variable name="textClassCS">csText</xsl:variable>

    <xsl:variable name="minorAsciiTheme">minorAsciiTheme</xsl:variable>
    <xsl:variable name="majorAsciiTheme">majorAsciiTheme</xsl:variable>
    <xsl:variable name="minorAnsiTheme">minorAnsiTheme</xsl:variable>
    <xsl:variable name="majorAnsiTheme">majorAnsiTheme</xsl:variable>
    <xsl:variable name="minorEATheme">minorEATheme</xsl:variable>
    <xsl:variable name="majorEATheme">majorEATheme</xsl:variable>
    <xsl:variable name="minorCSTheme">minorCSTheme</xsl:variable>
    <xsl:variable name="majorCSTheme">majorCSTheme</xsl:variable>

    <xsl:variable name="prsPDefault">
        <xsl:value-of select="$na"/>
        <xsl:value-of select="$na"/>
    </xsl:variable>

    <xsl:variable name="footnoteRefLink">_ftnref</xsl:variable>
    <xsl:variable name="footnoteLink">_ftn</xsl:variable>
    <xsl:variable name="endnoteRefLink">_ednref</xsl:variable>
    <xsl:variable name="endnoteLink">_edn</xsl:variable>

    <xsl:template name="ConvertHexToDec">
        <xsl:param name="value"/>
        <xsl:param name="i" select="1"/>
        <xsl:param name="s" select="1"/>
        <xsl:variable name="hexDigit" select="substring($value,$i,1)"/>
        <xsl:if test="not($hexDigit = '')">
            <xsl:text> </xsl:text>
            <xsl:choose>
                <xsl:when test="$hexDigit = 'A'">10</xsl:when>
                <xsl:when test="$hexDigit = 'B'">11</xsl:when>
                <xsl:when test="$hexDigit = 'C'">12</xsl:when>
                <xsl:when test="$hexDigit = 'D'">13</xsl:when>
                <xsl:when test="$hexDigit = 'E'">14</xsl:when>
                <xsl:when test="$hexDigit = 'F'">15</xsl:when>
                <xsl:otherwise>
                    <xsl:value-of select="$hexDigit"/>
                </xsl:otherwise>
            </xsl:choose>
            <xsl:call-template name="ConvertHexToDec">
                <xsl:with-param name="value" select="$value"/>
                <xsl:with-param name="i" select="$i+$s"/>
                <xsl:with-param name="s" select="$s"/>
            </xsl:call-template>
        </xsl:if>
    </xsl:template>

    <xsl:template name="ConvBorderStyle">
        <xsl:param name="value"/>
        <xsl:choose>
            <xsl:when test="$value='none' or $value='nil'">none</xsl:when>
            <xsl:when test="$value='single'">solid</xsl:when>
            <xsl:when test="contains($value,'stroke')">solid</xsl:when>
            <xsl:when test="$value='dashed'">dashed</xsl:when>
            <xsl:when test="contains($value,'dash')">dashed</xsl:when>
            <xsl:when test="$value='double'">double</xsl:when>
            <xsl:when test="$value='triple'">double</xsl:when>
            <xsl:when test="contains($value,'double')">double</xsl:when>
            <xsl:when test="contains($value,'gap')">double</xsl:when>
            <xsl:when test="$value='dotted'">dotted</xsl:when>
            <xsl:when test="$value='three-d-emboss'">ridge</xsl:when>
            <xsl:when test="$value='three-d-engrave'">groove</xsl:when>
            <xsl:when test="$value='outset'">outset</xsl:when>
            <xsl:when test="$value='inset'">inset</xsl:when>
            <xsl:otherwise>solid</xsl:otherwise>
        </xsl:choose>
    </xsl:template>

    <xsl:template name="EvalTableWidth">
        <xsl:choose>
            <xsl:when test="@w:type = 'pct'">
                <xsl:value-of select="@w:w div 50"/>%
            </xsl:when>
            <xsl:otherwise>
                <xsl:value-of select="@w:w div 20"/>pt
            </xsl:otherwise>
        </xsl:choose>
    </xsl:template>

    <xsl:template name="ConvColor">
        <xsl:param name="value"/>
        <xsl:choose>
            <xsl:when test="$value='black'">black</xsl:when>
            <xsl:when test="$value='blue'">blue</xsl:when>
            <xsl:when test="$value='cyan'">aqua</xsl:when>
            <xsl:when test="$value='green'">lime</xsl:when>
            <xsl:when test="$value='magenta'">fuchsia</xsl:when>
            <xsl:when test="$value='red'">red</xsl:when>
            <xsl:when test="$value='yellow'">yellow</xsl:when>
            <xsl:when test="$value='white'">white</xsl:when>
            <xsl:when test="$value='darkBlue'">navy</xsl:when>
            <xsl:when test="$value='darkCyan'">teal</xsl:when>
            <xsl:when test="$value='darkGreen'">green</xsl:when>
            <xsl:when test="$value='darkMagenta'">purple</xsl:when>
            <xsl:when test="$value='darkRed'">maroon</xsl:when>
            <xsl:when test="$value='darkYellow'">olive</xsl:when>
            <xsl:when test="$value='darkGray'">gray</xsl:when>
            <xsl:when test="$value='lightGray'">silver</xsl:when>
            <xsl:when test="$value='none'">transparent</xsl:when>
        </xsl:choose>
    </xsl:template>

    <xsl:template name="ConvHexColor">
        <xsl:param name="value"/>
        <xsl:param name="autoColor" select="$autoColor_text"/>
        <xsl:param name="transparentColor">transparent</xsl:param>
        <xsl:choose>
            <xsl:when test="$value = $autoColor_hex or $value = ''">
                <xsl:value-of select="$autoColor"/>
            </xsl:when>
            <xsl:when test="$value = $transparentColor_hex">
                <xsl:value-of select="$transparentColor"/>
            </xsl:when>
            <xsl:otherwise>
                <xsl:value-of select="concat('#',$value)"/>
            </xsl:otherwise>
        </xsl:choose>
    </xsl:template>


    <!--template of underline,strikethrough-->

    <xsl:template name="EvalBooleanType">
        <xsl:choose>
            <xsl:when test="string-length(@w:val) = 0 or @w:val = 'off' or @w:val = 'none' or @w:val = '0' ">
                <xsl:value-of select="$off"/>
            </xsl:when>
            <xsl:otherwise>
                <xsl:value-of select="$on"/>
            </xsl:otherwise>
        </xsl:choose>
    </xsl:template>


    <xsl:template name="GetBorderPr">
        <xsl:value-of select="@w:val"/>
        <xsl:value-of select="$sep2"/>
        <xsl:value-of select="@w:color"/>
        <xsl:value-of select="$sep2"/>
        <xsl:choose>
            <xsl:when test="@w:sz">

                <xsl:value-of select="@w:sz * 2.5"/>
                <xsl:value-of select="$sep2"/>
            </xsl:when>
            <xsl:otherwise>
                0<xsl:value-of select="$sep2"/>
            </xsl:otherwise>
        </xsl:choose>
        <xsl:value-of select="@w:space"/>
        <xsl:value-of select="$sep2"/>
        <xsl:value-of select="@w:shadow"/>
    </xsl:template>

    <xsl:template name="ApplyBorderPr">
        <xsl:param name="pr.bdr"/>
        <xsl:param name="bdrSide" select="$bdrSide_char"/>
        <xsl:if test="not($pr.bdr='')">
            <xsl:text>border</xsl:text>
            <xsl:value-of select="$bdrSide"/>
            <xsl:text>:</xsl:text>
            <xsl:call-template name="ConvBorderStyle">
                <xsl:with-param name="value" select="substring-before($pr.bdr,$sep2)"/>
            </xsl:call-template>
            <xsl:variable name="temp" select="substring-after($pr.bdr,$sep2)"/>
            <xsl:text> </xsl:text>
            <xsl:call-template name="ConvHexColor">
                <xsl:with-param name="value" select="substring-before($temp,$sep2)"/>
            </xsl:call-template>
            <xsl:text> </xsl:text>
            <xsl:value-of select="substring-before(substring-after($temp,$sep2),$sep2) div 20"/>
            <xsl:text>pt;</xsl:text>
            <xsl:if test="$bdrSide = $bdrSide_char">padding:0;</xsl:if>
        </xsl:if>
    </xsl:template>

    <xsl:variable name="valid_hex_digits" select="'0123456789ABCDEF'"/>

    <xsl:template name="TwoHexToDec">
        <xsl:param name="value"/>

        <xsl:choose>
            <xsl:when test="string-length($value) = 0">
                <xsl:value-of select="0"/>
            </xsl:when>
            <xsl:when test="string-length($value) = 1">
                <xsl:value-of select="string-length(substring-before($valid_hex_digits,substring($value,1,1)))"/>
            </xsl:when>
            <xsl:otherwise>
                <xsl:variable name="digit1_16" select="substring($value,1,1)"/>
                <xsl:variable name="digit2_16" select="substring($value,2,1)"/>
                <xsl:variable name="digit1_10" select="string-length(substring-before($valid_hex_digits,$digit1_16))"/>
                <xsl:variable name="digit2_10" select="string-length(substring-before($valid_hex_digits,$digit2_16))"/>

                <xsl:value-of select="$digit1_10 * 16 + $digit2_10"/>
            </xsl:otherwise>
        </xsl:choose>
    </xsl:template>

    <xsl:template name="DecToTwoHex">
        <xsl:param name="value"/>

        <xsl:variable name="digit1_10" select="floor($value div 16)"/>
        <xsl:variable name="digit2_10" select="$value mod 16"/>

        <xsl:variable name="digit1_16" select="substring($valid_hex_digits,$digit1_10 + 1,1)"/>
        <xsl:variable name="digit2_16" select="substring($valid_hex_digits,$digit2_10 + 1,1)"/>

        <xsl:value-of select="concat($digit1_16,$digit2_16)"/>
    </xsl:template>

    <xsl:template name="ApplyShdPct">
        <xsl:param name="value"/>
        <xsl:param name="pct"/>
        <xsl:param name="transparentColor">transparent</xsl:param>

        <xsl:choose>
            <xsl:when test="$value = $autoColor_hex or $value = ''">
                <xsl:call-template name="ApplyShdPct">
                    <xsl:with-param name="value" select="'FFFFFF'"/>
                    <xsl:with-param name="pct" select="$pct"/>
                </xsl:call-template>
            </xsl:when>
            <xsl:when test="$value = $transparentColor_hex">
                <xsl:value-of select="$transparentColor"/>
            </xsl:when>
            <xsl:otherwise>
                <xsl:variable name="r">
                    <xsl:call-template name="TwoHexToDec">
                        <xsl:with-param name="value" select="substring($value,1,2)"/>
                    </xsl:call-template>
                </xsl:variable>
                <xsl:variable name="g">
                    <xsl:call-template name="TwoHexToDec">
                        <xsl:with-param name="value" select="substring($value,3,2)"/>
                    </xsl:call-template>
                </xsl:variable>
                <xsl:variable name="b">
                    <xsl:call-template name="TwoHexToDec">
                        <xsl:with-param name="value" select="substring($value,5,2)"/>
                    </xsl:call-template>
                </xsl:variable>

                <xsl:value-of select="'#'"/>
                <xsl:call-template name="DecToTwoHex">
                    <xsl:with-param name="value" select="round(number($r) * $pct)"/>
                </xsl:call-template>
                <xsl:call-template name="DecToTwoHex">
                    <xsl:with-param name="value" select="round(number($g) * $pct)"/>
                </xsl:call-template>
                <xsl:call-template name="DecToTwoHex">
                    <xsl:with-param name="value" select="round(number($b) * $pct)"/>
                </xsl:call-template>
            </xsl:otherwise>
        </xsl:choose>

    </xsl:template>

    <xsl:template name="ApplyShd">

        <xsl:variable name="backgroundColor">
            <xsl:choose>
                <xsl:when test="@w:val = 'clear' or not(@w:val)">
                    <xsl:call-template name="ConvHexColor">
                        <xsl:with-param name="value" select="@w:fill"/>
                        <xsl:with-param name="autoColor" select="$autoColor_bg"/>
                    </xsl:call-template>
                </xsl:when>
                <xsl:when test="@w:val = 'solid'">#000000</xsl:when>
                <xsl:when test="substring(@w:val,1,3) = 'pct'">
                    <xsl:call-template name="ApplyShdPct">
                        <xsl:with-param name="value" select="@w:fill"/>
                        <xsl:with-param name="autoColor" select="$autoColor_bg"/>
                        <xsl:with-param name="pct" select="(100 - number(substring(@w:val,4))) div 100"/>
                    </xsl:call-template>
                </xsl:when>
                <xsl:otherwise>
                    <xsl:call-template name="ConvHexColor">
                        <xsl:with-param name="value" select="@WX:bgcolor"/>
                        <xsl:with-param name="autoColor" select="$autoColor_bg"/>
                    </xsl:call-template>
                </xsl:otherwise>
            </xsl:choose>
        </xsl:variable>

        <xsl:text>background-color:</xsl:text>

        <xsl:value-of select="$backgroundColor"/>
        <!--<xsl:variable select="backgroundColor"/>-->
        <xsl:text>;</xsl:text>

        <xsl:call-template name="ApplyAutoForeColor">
            <xsl:with-param name="backgroundColor" select="$backgroundColor"/>
        </xsl:call-template>
    </xsl:template>

    <xsl:template name="ApplyAutoForeColor">
        <xsl:param name="backgroundColor"/>

        <xsl:if test="contains($backgroundColor,'#')">
            <xsl:variable name="backgroundHex" select="substring-after($backgroundColor,'#')"/>
            <xsl:variable name="r">
                <xsl:call-template name="TwoHexToDec">
                    <xsl:with-param name="value" select="substring($backgroundHex,1,2)"/>
                </xsl:call-template>
            </xsl:variable>
            <xsl:variable name="g">
                <xsl:call-template name="TwoHexToDec">
                    <xsl:with-param name="value" select="substring($backgroundHex,3,2)"/>
                </xsl:call-template>
            </xsl:variable>
            <xsl:variable name="b">
                <xsl:call-template name="TwoHexToDec">
                    <xsl:with-param name="value" select="substring($backgroundHex,5,2)"/>
                </xsl:call-template>
            </xsl:variable>

            <xsl:if test="0.299 * number($r) + 0.587 * number($g) + 0.114 * number($b) &lt;= 60">
                <xsl:text>color:#FFFFFF;</xsl:text>
            </xsl:if>
        </xsl:if>
    </xsl:template>

    <xsl:template name="ApplyShdHint">
        <xsl:text>background-color:</xsl:text>
        <xsl:call-template name="ConvHexColor">
            <xsl:with-param name="value" select="@WX:bgcolor"/>
            <xsl:with-param name="autoColor" select="$autoColor_bg"/>
            <xsl:with-param name="transparentColor">transparent</xsl:with-param>
        </xsl:call-template>
        <xsl:text>;</xsl:text>
    </xsl:template>

    <xsl:template name="ApplyTextDirection">
        <xsl:text>layout-flow:</xsl:text>
        <xsl:choose>
            <xsl:when test="@w:val = 'tb-rl-v'">vertical-ideographic</xsl:when>
            <xsl:when test="@w:val = 'lr-tb-v'">horizontal-ideographic</xsl:when>
            <xsl:otherwise>normal</xsl:otherwise>
        </xsl:choose>
        <xsl:text>;</xsl:text>
    </xsl:template>

    <xsl:template name="ApplyCellMar">
        <xsl:choose>
            <xsl:when test="@w:val='none'">none</xsl:when>
            <xsl:otherwise>
                <xsl:text>padding:</xsl:text>
                <xsl:choose>
                    <xsl:when test="w:top">
                        <xsl:for-each select="w:top[1]">
                            <xsl:call-template name="EvalTableWidth"/>
                        </xsl:for-each>
                    </xsl:when>
                    <xsl:otherwise>0</xsl:otherwise>
                </xsl:choose>
                <xsl:text> </xsl:text>
                <xsl:choose>
                    <xsl:when test="w:right">
                        <xsl:for-each select="w:right[1]">
                            <xsl:call-template name="EvalTableWidth"/>
                        </xsl:for-each>
                    </xsl:when>
                    <xsl:otherwise>0</xsl:otherwise>
                </xsl:choose>
                <xsl:text> </xsl:text>
                <xsl:choose>
                    <xsl:when test="w:bottom">
                        <xsl:for-each select="w:bottom[1]">
                            <xsl:call-template name="EvalTableWidth"/>
                        </xsl:for-each>
                    </xsl:when>
                    <xsl:otherwise>0</xsl:otherwise>
                </xsl:choose>
                <xsl:text> </xsl:text>
                <xsl:choose>
                    <xsl:when test="w:left">
                        <xsl:for-each select="w:left[1]">
                            <xsl:call-template name="EvalTableWidth"/>
                        </xsl:for-each>
                    </xsl:when>
                    <xsl:otherwise>0</xsl:otherwise>
                </xsl:choose>
                <xsl:text>;</xsl:text>
            </xsl:otherwise>
        </xsl:choose>
    </xsl:template>

    <xsl:template name="PrsUpdatePPr">
        <xsl:param name="prsP" select="$prsPDefault"/>
        <xsl:param name="ndPrContainer" select="."/>

        <xsl:variable name="prsPTemp">
            <xsl:for-each select="$ndPrContainer">
                <xsl:call-template name="PrsUpdatePPrCore">
                    <xsl:with-param name="prsP" select="$prsP"/>
                </xsl:call-template>
            </xsl:for-each>
        </xsl:variable>
        <xsl:choose>
            <xsl:when test="$prsPTemp=''">
                <xsl:value-of select="$prsP"/>
            </xsl:when>
            <xsl:otherwise>
                <xsl:value-of select="$prsPTemp"/>
            </xsl:otherwise>
        </xsl:choose>
    </xsl:template>

    <xsl:template name="FetchBasedOnPropertyBoolean">
        <xsl:param name="match" select="''"/>

        <xsl:choose>
            <xsl:when test="$match">
                <xsl:for-each select="$match">
                    <xsl:call-template name="EvalBooleanType"/>
                </xsl:for-each>
            </xsl:when>
            <xsl:when test="../w:basedOn">
                <xsl:variable name="sBasedOn">
                    <xsl:value-of select="../w:basedOn/@w:val"/>
                </xsl:variable>
                <xsl:for-each select="$nsStyles[@w:styleId=$sBasedOn]">
                    <xsl:call-template name="FetchBasedOnPropertyBoolean">
                        <xsl:with-param name="match" select="$match"/>
                    </xsl:call-template>
                </xsl:for-each>
            </xsl:when>
            <xsl:otherwise>
                <xsl:value-of select="$na"/>
            </xsl:otherwise>
        </xsl:choose>
    </xsl:template>

    <xsl:variable name="fbopModeIndentLeft" select="'1'"/>
    <xsl:variable name="fbopModeIndentLeftChars" select="'2'"/>
    <xsl:variable name="fbopModeIndentRight" select="'3'"/>
    <xsl:variable name="fbopModeIndentRightChars" select="'4'"/>
    <xsl:variable name="fbopModeIndentHanging" select="'5'"/>
    <xsl:variable name="fbopModeIndentHangingChars" select="'6'"/>
    <xsl:variable name="fbopModeIndentFirstLine" select="'7'"/>
    <xsl:variable name="fbopModeIndentFirstLineChars" select="'8'"/>

    <xsl:template name="FetchBasedOnProperty">
        <xsl:param name="mode" select="''"/>
        <xsl:param name="sDefault" select="''"/>

        <xsl:variable name="sValue">
            <xsl:choose>
                <xsl:when test="$mode=$fbopModeIndentLeft">
                    <xsl:value-of select="w:ind[1]/@w:left"/>
                </xsl:when>
                <xsl:when test="$mode=$fbopModeIndentLeftChars">
                    <xsl:value-of select="w:ind[1]/@w:leftChars"/>
                </xsl:when>
                <xsl:when test="$mode=$fbopModeIndentRight">
                    <xsl:value-of select="w:ind[1]/@w:right"/>
                </xsl:when>
                <xsl:when test="$mode=$fbopModeIndentRightChars">
                    <xsl:value-of select="w:ind[1]/@w:rightChars"/>
                </xsl:when>
                <xsl:when test="$mode=$fbopModeIndentHanging">
                    <xsl:value-of select="w:ind[1]/@w:hanging"/>
                </xsl:when>
                <xsl:when test="$mode=$fbopModeIndentHangingChars">
                    <xsl:value-of select="w:ind[1]/@w:hangingChars"/>
                </xsl:when>
                <xsl:when test="$mode=$fbopModeIndentFirstLine">
                    <xsl:value-of select="w:ind[1]/@w:firstLine"/>
                </xsl:when>
                <xsl:when test="$mode=$fbopModeIndentFirstLineChars">
                    <xsl:value-of select="w:ind[1]/@w:firstLineChars"/>
                </xsl:when>
                <xsl:otherwise>
                    <xsl:text></xsl:text>
                </xsl:otherwise>
            </xsl:choose>
        </xsl:variable>

        <xsl:choose>
            <xsl:when test="not($sValue='')">
                <xsl:value-of select="$sValue"/>
            </xsl:when>
            <xsl:when test="../w:basedOn">
                <xsl:variable name="sBasedOn">
                    <xsl:value-of select="../w:basedOn/@w:val"/>
                </xsl:variable>
                <xsl:for-each select="$nsStyles[@w:styleId=$sBasedOn]/w:pPr[1]">
                    <xsl:call-template name="FetchBasedOnProperty">
                        <xsl:with-param name="mode" select="$mode"/>
                    </xsl:call-template>
                </xsl:for-each>
            </xsl:when>
            <xsl:otherwise>
                <xsl:value-of select="$sDefault"/>
            </xsl:otherwise>
        </xsl:choose>
    </xsl:template>

    <xsl:template name="PrsUpdatePPrCore">
        <xsl:param name="prsP" select="$prsPDefault"/>
        <xsl:for-each select="w:pPr[1]">

            <xsl:variable name="fTextAutospaceO">

                <xsl:for-each select="w:autoSpaceDE[1]">
                    <xsl:call-template name="EvalBooleanType"/>
                </xsl:for-each>
            </xsl:variable>
            <xsl:choose>
                <xsl:when test="$fTextAutospaceO=''">
                    <xsl:value-of select="substring($prsP, $iTextAutospaceO, 1)"/>
                </xsl:when>
                <xsl:otherwise>
                    <xsl:value-of select="$fTextAutospaceO"/>
                </xsl:otherwise>
            </xsl:choose>

            <xsl:variable name="fTextAutospaceN">
                <xsl:for-each select="w:autoSpaceDN[1]">
                    <xsl:call-template name="EvalBooleanType"/>
                </xsl:for-each>
            </xsl:variable>
            <xsl:choose>
                <xsl:when test="$fTextAutospaceN=''">
                    <xsl:value-of select="substring($prsP, $iTextAutospaceN, 1)"/>
                </xsl:when>
                <xsl:otherwise>
                    <xsl:value-of select="$fTextAutospaceN"/>
                </xsl:otherwise>
            </xsl:choose>

            <xsl:variable name="prsDefaultInd" select="substring($prsP, $iInd)"/>
            <xsl:variable name="sDefLeft" select="substring-before($prsDefaultInd,$sep2)"/>
            <xsl:variable name="temp1" select="substring-after($prsDefaultInd,$sep2)"/>
            <xsl:variable name="sDefLeftChars" select="substring-before($temp1,$sep2)"/>
            <xsl:variable name="temp2" select="substring-after($temp1,$sep2)"/>
            <xsl:variable name="sDefRight" select="substring-before($temp2,$sep2)"/>
            <xsl:variable name="temp3" select="substring-after($temp2,$sep2)"/>
            <xsl:variable name="sDefRightChars" select="substring-before($temp3,$sep2)"/>
            <xsl:variable name="temp4" select="substring-after($temp3,$sep2)"/>
            <xsl:variable name="sDefHanging" select="substring-before($temp4,$sep2)"/>
            <xsl:variable name="temp5" select="substring-after($temp4,$sep2)"/>
            <xsl:variable name="sDefHangingChars" select="substring-before($temp5,$sep2)"/>
            <xsl:variable name="temp6" select="substring-after($temp5,$sep2)"/>
            <xsl:variable name="sDefFirstLine" select="substring-before($temp6,$sep2)"/>
            <xsl:variable name="sDefFirstLineChars" select="substring-after($temp6,$sep2)"/>

            <xsl:variable name="nInd">

                <xsl:call-template name="FetchBasedOnProperty">
                    <xsl:with-param name="mode" select="$fbopModeIndentLeft"/>
                    <xsl:with-param name="sDefault" select="$sDefLeft"/>
                </xsl:call-template>

                <xsl:value-of select="$sep2"/>

                <xsl:call-template name="FetchBasedOnProperty">
                    <xsl:with-param name="mode" select="$fbopModeIndentLeftChars"/>
                    <xsl:with-param name="sDefault" select="$sDefLeftChars"/>
                </xsl:call-template>

                <xsl:value-of select="$sep2"/>

                <xsl:call-template name="FetchBasedOnProperty">
                    <xsl:with-param name="mode" select="$fbopModeIndentRight"/>
                    <xsl:with-param name="sDefault" select="$sDefRight"/>
                </xsl:call-template>

                <xsl:value-of select="$sep2"/>

                <xsl:call-template name="FetchBasedOnProperty">
                    <xsl:with-param name="mode" select="$fbopModeIndentRightChars"/>
                    <xsl:with-param name="sDefault" select="$sDefRightChars"/>
                </xsl:call-template>

                <xsl:value-of select="$sep2"/>

                <xsl:call-template name="FetchBasedOnProperty">
                    <xsl:with-param name="mode" select="$fbopModeIndentHanging"/>
                    <xsl:with-param name="sDefault" select="$sDefHanging"/>
                </xsl:call-template>

                <xsl:value-of select="$sep2"/>

                <xsl:call-template name="FetchBasedOnProperty">
                    <xsl:with-param name="mode" select="$fbopModeIndentHangingChars"/>
                    <xsl:with-param name="sDefault" select="$sDefHangingChars"/>
                </xsl:call-template>

                <xsl:value-of select="$sep2"/>

                <xsl:call-template name="FetchBasedOnProperty">
                    <xsl:with-param name="mode" select="$fbopModeIndentFirstLine"/>
                    <xsl:with-param name="sDefault" select="$sDefFirstLine"/>
                </xsl:call-template>

                <xsl:value-of select="$sep2"/>

                <xsl:call-template name="FetchBasedOnProperty">
                    <xsl:with-param name="mode" select="$fbopModeIndentFirstLineChars"/>
                    <xsl:with-param name="sDefault" select="$sDefFirstLineChars"/>
                </xsl:call-template>

            </xsl:variable>
            <xsl:choose>
                <xsl:when test="$nInd=''">
                    <xsl:value-of select="substring($prsP, $iInd)"/>
                </xsl:when>
                <xsl:otherwise>
                    <xsl:value-of select="$nInd"/>
                </xsl:otherwise>
            </xsl:choose>
        </xsl:for-each>
    </xsl:template>

    <xsl:template name="PrsUpdateRPr">
        <xsl:param name="prsR" select="$prsRDefault"/>
        <xsl:param name="ndPrContainer" select="."/>
        <xsl:variable name="prsRTemp">
            <xsl:for-each select="$ndPrContainer">
                <xsl:call-template name="PrsUpdateRPrCore">
                    <xsl:with-param name="prsR" select="$prsR"/>
                </xsl:call-template>
            </xsl:for-each>
        </xsl:variable>
        <xsl:choose>
            <xsl:when test="$prsRTemp=''">
                <xsl:value-of select="$prsR"/>
            </xsl:when>
            <xsl:otherwise>
                <xsl:value-of select="$prsRTemp"/>
            </xsl:otherwise>
        </xsl:choose>
    </xsl:template>

    <xsl:template name="PrsUpdateRPrCore">
        <xsl:param name="prsR"/>
        <xsl:param name="type" select="$prrNonList"/>

        <xsl:for-each select="w:rPr[1]">

            <xsl:variable name="fEmbossImprint">
                <xsl:variable name="condition1">
                    <xsl:for-each select="w:emboss[1]">
                        <xsl:call-template name="EvalBooleanType"/>
                    </xsl:for-each>
                </xsl:variable>
                <xsl:variable name="condition2">
                    <xsl:for-each select="w:imprint[1]">
                        <xsl:call-template name="EvalBooleanType"/>
                    </xsl:for-each>
                </xsl:variable>
                <xsl:choose>
                    <xsl:when test="$condition1 = $on or $condition2 = $on">
                        <xsl:value-of select="$on"/>
                    </xsl:when>
                    <xsl:when test="$condition1 = $off or $condition2 = $off">
                        <xsl:value-of select="$off"/>
                    </xsl:when>
                </xsl:choose>
            </xsl:variable>
            <xsl:choose>
                <xsl:when test="$fEmbossImprint = ''">
                    <xsl:value-of select="substring($prsR,$iEmbossImprint,1)"/>
                </xsl:when>
                <xsl:otherwise>
                    <xsl:value-of select="$fEmbossImprint"/>
                </xsl:otherwise>
            </xsl:choose>

            <xsl:variable name="fU_Em">
                <xsl:variable name="condition1">

                    <!--here is the underline tag-->

                    <xsl:for-each select="w:u[1]">
                        <xsl:call-template name="EvalBooleanType"/>
                    </xsl:for-each>
                </xsl:variable>
                <xsl:variable name="condition2">
                    <xsl:for-each select="w:em[1]">
                        <xsl:call-template name="EvalBooleanType"/>
                    </xsl:for-each>
                </xsl:variable>
                <xsl:choose>
                    <xsl:when test="$condition1 = $on or $condition2 = $on">
                        <xsl:value-of select="$on"/>
                    </xsl:when>
                    <xsl:when test="$condition1 = $off or $condition2 = $off">
                        <xsl:value-of select="$off"/>
                    </xsl:when>
                </xsl:choose>
            </xsl:variable>
            <xsl:choose>
                <xsl:when test="$fU_Em = ''">
                    <xsl:choose>
                        <xsl:when test="$type=$prrList">
                            <xsl:value-of select="$off"/>
                        </xsl:when>
                        <xsl:otherwise>
                            <xsl:value-of select="substring($prsR,$iU_Em,1)"/>
                        </xsl:otherwise>
                    </xsl:choose>
                </xsl:when>
                <xsl:otherwise>
                    <xsl:value-of select="$fU_Em"/>
                </xsl:otherwise>
            </xsl:choose>

            <xsl:variable name="fStrikeDStrike">
                <xsl:variable name="condition1">
                    <xsl:for-each select="w:strike[1]">
                        <xsl:value-of select="$on"/>
                    </xsl:for-each>
                </xsl:variable>
                <xsl:variable name="condition2">
                    <xsl:for-each select="w:dstrike[1]">
                        <xsl:call-template name="EvalBooleanType"/>
                    </xsl:for-each>
                </xsl:variable>
                <xsl:choose>
                    <xsl:when test="$condition1 = $on or $condition2 = $on">
                        <xsl:value-of select="$on"/>
                    </xsl:when>
                    <xsl:when test="$condition1 = $off or $condition2 = $off">
                        <xsl:value-of select="$off"/>
                    </xsl:when>
                </xsl:choose>
            </xsl:variable>
            <xsl:choose>
                <xsl:when test="$fStrikeDStrike = ''">
                    <xsl:value-of select="substring($prsR,$iStrikeDStrike,1)"/>
                </xsl:when>
                <xsl:otherwise>
                    <xsl:value-of select="$fStrikeDStrike"/>
                </xsl:otherwise>
            </xsl:choose>

            <xsl:variable name="fSup">
                <xsl:choose>
                    <xsl:when test="w:vertAlign/@w:val='superscript'">
                        <xsl:value-of select="$on"/>
                    </xsl:when>
                    <xsl:otherwise>
                        <xsl:value-of select="$off"/>
                    </xsl:otherwise>
                </xsl:choose>
            </xsl:variable>
            <xsl:choose>
                <xsl:when test="not(w:vertAlign)">
                    <xsl:value-of select="substring($prsR,$iSup,1)"/>
                </xsl:when>
                <xsl:otherwise>
                    <xsl:value-of select="$fSup"/>
                </xsl:otherwise>
            </xsl:choose>

            <xsl:variable name="fSub">
                <xsl:choose>
                    <xsl:when test="w:vertAlign/@w:val='subscript'">
                        <xsl:value-of select="$on"/>
                    </xsl:when>
                    <xsl:otherwise>
                        <xsl:value-of select="$off"/>
                    </xsl:otherwise>
                </xsl:choose>
            </xsl:variable>
            <xsl:choose>
                <xsl:when test="not(w:vertAlign)">
                    <xsl:value-of select="substring($prsR,$iSub,1)"/>
                </xsl:when>
                <xsl:otherwise>
                    <xsl:value-of select="$fSub"/>
                </xsl:otherwise>
            </xsl:choose>

            <xsl:variable name="fVanishWebHidden">
                <xsl:variable name="condition1">
                    <xsl:for-each select="w:vanish[1]">
                        <xsl:call-template name="EvalBooleanType"/>
                    </xsl:for-each>
                </xsl:variable>
                <xsl:variable name="condition2">
                    <xsl:for-each select="w:webHidden[1]">
                        <xsl:call-template name="EvalBooleanType"/>
                    </xsl:for-each>
                </xsl:variable>
                <xsl:choose>
                    <xsl:when test="$condition1 = $on or $condition2 = $on">
                        <xsl:value-of select="$on"/>
                    </xsl:when>
                    <xsl:when test="$condition1 = $off or $condition2 = $off">
                        <xsl:value-of select="$off"/>
                    </xsl:when>
                </xsl:choose>
            </xsl:variable>
            <xsl:choose>
                <xsl:when test="$fVanishWebHidden = ''">
                    <xsl:value-of select="substring($prsR,$iVanishWebHidden,1)"/>
                </xsl:when>
                <xsl:otherwise>
                    <xsl:value-of select="$fVanishWebHidden"/>
                </xsl:otherwise>
            </xsl:choose>

            <xsl:variable name="fBCs">
                <xsl:for-each select="w:bCs[1]">
                    <xsl:call-template name="EvalBooleanType"/>
                </xsl:for-each>
            </xsl:variable>
            <xsl:choose>
                <xsl:when test="$fBCs = ''">
                    <xsl:value-of select="substring($prsR,$iBCs,1)"/>
                </xsl:when>
                <xsl:otherwise>
                    <xsl:value-of select="$fBCs"/>
                </xsl:otherwise>
            </xsl:choose>

            <xsl:variable name="fICs">
                <xsl:for-each select="w:iCs[1]">
                    <xsl:call-template name="EvalBooleanType"/>
                </xsl:for-each>
            </xsl:variable>
            <xsl:choose>
                <xsl:when test="$fICs = ''">
                    <xsl:value-of select="substring($prsR,$iICs,1)"/>
                </xsl:when>
                <xsl:otherwise>
                    <xsl:value-of select="$fICs"/>
                </xsl:otherwise>
            </xsl:choose>

            <xsl:variable name="szAsciiTheme" select="string(w:rFonts[1]/@w:asciiTheme)"/>
            <xsl:choose>
                <xsl:when test="$szAsciiTheme = ''">
                    <xsl:value-of select="substring($prsR,$iAsciiTheme,1)"/>
                </xsl:when>
                <xsl:otherwise>
                    <xsl:call-template name="EvalThemeType">
                        <xsl:with-param name="themeStyle" select="$szAsciiTheme"/>
                    </xsl:call-template>
                </xsl:otherwise>
            </xsl:choose>

            <xsl:variable name="szAnsiTheme" select="string(w:rFonts[1]/@w:hAnsiTheme)"/>
            <xsl:choose>
                <xsl:when test="$szAnsiTheme = ''">
                    <xsl:value-of select="substring($prsR,$iAnsiTheme,1)"/>
                </xsl:when>
                <xsl:otherwise>
                    <xsl:call-template name="EvalThemeType">
                        <xsl:with-param name="themeStyle" select="$szAnsiTheme"/>
                    </xsl:call-template>
                </xsl:otherwise>
            </xsl:choose>

            <xsl:variable name="szEATheme" select="string(w:rFonts[1]/@w:eastAsiaTheme)"/>
            <xsl:choose>
                <xsl:when test="$szEATheme = ''">
                    <xsl:value-of select="substring($prsR,$iEATheme,1)"/>
                </xsl:when>
                <xsl:otherwise>
                    <xsl:call-template name="EvalThemeType">
                        <xsl:with-param name="themeStyle" select="$szEATheme"/>
                    </xsl:call-template>
                </xsl:otherwise>
            </xsl:choose>

            <xsl:variable name="szCSTheme" select="string(w:rFonts[1]/@w:cstheme)"/>
            <xsl:choose>
                <xsl:when test="$szCSTheme = ''">
                    <xsl:value-of select="substring($prsR,$iCSTheme,1)"/>
                </xsl:when>
                <xsl:otherwise>
                    <xsl:call-template name="EvalThemeType">
                        <xsl:with-param name="themeStyle" select="$szCSTheme"/>
                    </xsl:call-template>
                </xsl:otherwise>
            </xsl:choose>

            <xsl:variable name="nSzCs" select="string(w:szCs[1]/@w:val)"/>
            <xsl:choose>
                <xsl:when test="$nSzCs = ''">
                    <xsl:value-of select="substring($prsR,$ISzCs)"/>
                </xsl:when>
                <xsl:otherwise>
                    <xsl:value-of select="$nSzCs"/>
                </xsl:otherwise>
            </xsl:choose>

        </xsl:for-each>
    </xsl:template>

    <xsl:template name="EvalThemeType">
        <xsl:param name="themeStyle"/>

        <xsl:choose>
            <xsl:when test="$themeStyle = 'minorAscii'">
                <xsl:value-of select="$minorAscii"/>
            </xsl:when>
            <xsl:when test="$themeStyle = 'majorAscii'">
                <xsl:value-of select="$majorAscii"/>
            </xsl:when>
            <xsl:when test="$themeStyle = 'minorHAnsi'">
                <xsl:value-of select="$minorAnsi"/>
            </xsl:when>
            <xsl:when test="$themeStyle = 'majorHAnsi'">
                <xsl:value-of select="$majorAnsi"/>
            </xsl:when>
            <xsl:when test="$themeStyle = 'minorEastAsia'">
                <xsl:value-of select="$minorEA"/>
            </xsl:when>
            <xsl:when test="$themeStyle = 'majorEastAsia'">
                <xsl:value-of select="$majorEA"/>
            </xsl:when>
            <xsl:when test="$themeStyle = 'minorBidi'">
                <xsl:value-of select="$minorCS"/>
            </xsl:when>
            <xsl:when test="$themeStyle = 'majorBidi'">
                <xsl:value-of select="$majorCS"/>
            </xsl:when>
        </xsl:choose>

    </xsl:template>

    <xsl:template name="PrsGetListPr">
        <xsl:param name="type"/>
        <xsl:param name="prsR"/>
        <xsl:for-each select="w:numPr">
            <xsl:choose>

                <xsl:when test="w:numId and w:ilvl">
                    <xsl:call-template name="PrsGetListPrCore">
                        <xsl:with-param name="type" select="$type"/>
                        <xsl:with-param name="prsR" select="$prsR"/>
                    </xsl:call-template>
                </xsl:when>

                <xsl:otherwise>
                    <xsl:variable name="pstyleId">
                        <xsl:for-each select="ancestor::w:p[1]">
                            <xsl:call-template name="GetPStyleId"/>
                        </xsl:for-each>
                    </xsl:variable>
                    <xsl:for-each select="($nsStyles[@w:styleId=$pstyleId])[1]/w:pPr[1]/w:numPr[1]">
                        <xsl:call-template name="PrsGetListPrCore">
                            <xsl:with-param name="type" select="$type"/>
                            <xsl:with-param name="prsR" select="$prsR"/>
                        </xsl:call-template>
                    </xsl:for-each>
                </xsl:otherwise>
            </xsl:choose>
        </xsl:for-each>
    </xsl:template>

    <xsl:template name="PrsGetListPrCore">
        <xsl:param name="type"/>
        <xsl:param name="prsR"/>

        <xsl:variable name="numId" select="w:numId/@w:val"/>
        <xsl:variable name="ilvl" select="w:ilvl/@w:val"/>
        <xsl:for-each select="$ndLists">

            <xsl:variable name="list" select="w:num[@w:numId=$numId][1]"/>

            <xsl:choose>
                <xsl:when
                        test="w:abstractNum[@w:abstractNumId=$list/w:abstractNumId/@w:val][1]/w:lvl[@w:ilvl=$ilvl][1]">
                    <xsl:for-each
                            select="w:abstractNum[@w:abstractNumId=$list/w:abstractNumId/@w:val][1]/w:lvl[@w:ilvl=$ilvl][1]">
                        <xsl:call-template name="PrsGetListPrFromListDef">
                            <xsl:with-param name="type" select="$type"/>
                            <xsl:with-param name="prsR" select="$prsR"/>
                        </xsl:call-template>
                    </xsl:for-each>

                    <xsl:if test="$list/w:lvlOverride[@w:ilvl=$ilvl]">
                        <xsl:for-each select="$list/w:lvlOverride[@w:ilvl=$ilvl]">
                            <xsl:call-template name="PrsGetListPrFromListDef">
                                <xsl:with-param name="type" select="$type"/>
                                <xsl:with-param name="prsR" select="$prsR"/>
                            </xsl:call-template>
                        </xsl:for-each>
                    </xsl:if>
                </xsl:when>

                <xsl:when test="$list/w:lvlOverride[@w:ilvl=$ilvl]">
                    <xsl:for-each select="$list/w:lvlOverride[@w:ilvl=$ilvl]">
                        <xsl:call-template name="PrsGetListPrFromListDef">
                            <xsl:with-param name="type" select="$type"/>
                            <xsl:with-param name="prsR" select="$prsR"/>
                        </xsl:call-template>
                    </xsl:for-each>
                </xsl:when>

                <xsl:when test="w:abstractNum[@w:abstractNumId=$list/w:abstractNumId/@w:val][1]/w:listStyleLink">
                    <xsl:variable name="linkedStyleId"
                                  select="w:abstractNum[@w:abstractNumId=$list/w:abstractNumId/@w:val][1]/w:listStyleLink/@w:val"/>
                    <xsl:variable name="linkedStyle" select="$nsStyles[@w:styleId=$linkedStyleId]"/>
                    <xsl:variable name="linkedList" select="w:num[@w:numId=$linkedStyle/w:pPr/w:numPr/w:numId/@w:val]"/>
                    <xsl:for-each
                            select="w:abstractNum[@w:abstractNumId=$linkedList/w:abstractNumId/@w:val][1]/w:lvl[@w:ilvl=$ilvl][1]">
                        <xsl:call-template name="PrsGetListPrFromListDef">
                            <xsl:with-param name="type" select="$type"/>
                            <xsl:with-param name="prsR" select="$prsR"/>
                        </xsl:call-template>
                    </xsl:for-each>
                </xsl:when>
            </xsl:choose>
        </xsl:for-each>
    </xsl:template>

    <xsl:template name="PrsGetListPrFromListDef">
        <xsl:param name="type"/>
        <xsl:param name="prsR"/>
        <xsl:choose>

            <xsl:when test="$type = $prrListSuff">
                <xsl:variable name="suff" select="w:suff[1]/@w:val"/>
                <xsl:choose>
                    <xsl:when test="$suff = $prListSuff_space or $suff = $prListSuff_nothing">
                        <xsl:value-of select="$suff"/>
                    </xsl:when>

                    <xsl:otherwise>
                        <xsl:value-of select="$prListSuff_space"/>
                    </xsl:otherwise>
                </xsl:choose>
            </xsl:when>

            <xsl:when test="$type = $prrListInd">
                <xsl:for-each select="w:pPr[1]/w:ind[1]">
                    <xsl:value-of select="@w:left"/>
                    <xsl:value-of select="$sep2"/>
                    <xsl:value-of select="@w:left-chars"/>
                    <xsl:value-of select="$sep2"/>
                    <xsl:value-of select="@w:hanging"/>
                    <xsl:value-of select="$sep2"/>
                    <xsl:value-of select="@w:hanging-chars"/>
                </xsl:for-each>
            </xsl:when>

            <xsl:when test="$type = $prrApplyRPr">
                <xsl:call-template name="ApplyRPr.class"/>
            </xsl:when>

            <xsl:when test="$type = $prrUpdateRPr">
                <xsl:call-template name="PrsUpdateRPrCore">
                    <xsl:with-param name="type" select="$prrList"/>
                    <xsl:with-param name="prsR" select="$prsR"/>
                </xsl:call-template>
            </xsl:when>
        </xsl:choose>
    </xsl:template>

    <xsl:template name="GetSinglePPr">
        <xsl:param name="type"/>
        <xsl:param name="sParaStyleName"/>

        <xsl:variable name="result">
            <xsl:call-template name="GetSinglePPrCore">
                <xsl:with-param name="type" select="$type"/>
            </xsl:call-template>
        </xsl:variable>

        <xsl:if test="$result=''">
            <xsl:for-each select="$sParaStyleName">
                <xsl:call-template name="GetSinglePPrCore">
                    <xsl:with-param name="type" select="$type"/>
                </xsl:call-template>
            </xsl:for-each>
        </xsl:if>
        <xsl:value-of select="$result"/>
    </xsl:template>

    <xsl:template name="GetSinglePPrCore">
        <xsl:param name="type"/>
        <xsl:for-each select="w:pPr[1]">
            <xsl:choose>
                <xsl:when test="$type = $prrBdrPr_top">
                    <xsl:for-each select="w:bdr[1]/w:top[1]">
                        <xsl:call-template name="GetBorderPr"/>
                    </xsl:for-each>
                </xsl:when>
                <xsl:when test="$type = $prrBdrPr_right">
                    <xsl:for-each select="w:bdr[1]/w:right[1]">
                        <xsl:call-template name="GetBorderPr"/>
                    </xsl:for-each>
                </xsl:when>
                <xsl:when test="$type = $prrBdrPr_bottom">
                    <xsl:for-each select="w:bdr[1]/w:bottom[1]">
                        <xsl:call-template name="GetBorderPr"/>
                    </xsl:for-each>
                </xsl:when>
                <xsl:when test="$type = $prrBdrPr_left">
                    <xsl:for-each select="w:bdr[1]/w:left[1]">
                        <xsl:call-template name="GetBorderPr"/>
                    </xsl:for-each>
                </xsl:when>
                <xsl:when test="$type = $prrBdrPr_between">
                    <xsl:for-each select="w:bdr[1]/w:between[1]">
                        <xsl:call-template name="GetBorderPr"/>
                    </xsl:for-each>
                </xsl:when>
                <xsl:when test="$type = $prrBdrPr_bar">
                    <xsl:for-each select="w:bdr[1]/w:bar[1]">
                        <xsl:call-template name="GetBorderPr"/>
                    </xsl:for-each>
                </xsl:when>
                <xsl:when test="$type = $prrFrame">
                    <xsl:for-each select="w:framePr[1]">
                        <xsl:value-of select="@w:w"/>
                        <xsl:value-of select="$sep2"/>
                        <xsl:value-of select="@w:h"/>
                        <xsl:value-of select="$sep2"/>
                        <xsl:value-of select="@w:h-rule"/>
                        <xsl:value-of select="$sep2"/>
                        <xsl:value-of select="@w:x-align"/>
                        <xsl:value-of select="$sep2"/>
                        <xsl:value-of select="@w:vSpace"/>
                        <xsl:value-of select="$sep2"/>
                        <xsl:value-of select="@w:hSpace"/>
                        <xsl:value-of select="$sep2"/>
                        <xsl:value-of select="@w:wrap"/>
                        <xsl:value-of select="$sep2"/>
                        <xsl:value-of select="@w:drop-cap"/>
                        <xsl:value-of select="$sep2"/>
                        <xsl:value-of select="@w:lines"/>
                        <xsl:value-of select="$sep2"/>
                        <xsl:value-of select="@w:x"/>
                        <xsl:value-of select="$sep2"/>
                        <xsl:value-of select="@w:y-align"/>
                        <xsl:value-of select="$sep2"/>
                        <xsl:value-of select="@w:y"/>
                        <xsl:value-of select="$sep2"/>
                        <xsl:value-of select="@w:hAnchor"/>
                        <xsl:value-of select="$sep2"/>
                        <xsl:value-of select="@w:vAnchor"/>
                        <xsl:value-of select="$sep2"/>
                        <xsl:value-of select="@w:anchor-lock"/>
                    </xsl:for-each>
                </xsl:when>
            </xsl:choose>
        </xsl:for-each>
    </xsl:template>

    <xsl:template name="GetSingleTblPr">
        <xsl:param name="type"/>
        <xsl:param name="sTblStyleName"/>
        <xsl:variable name="result">
            <xsl:call-template name="GetSingleTblPrCore">
                <xsl:with-param name="type" select="$type"/>
            </xsl:call-template>
        </xsl:variable>

        <xsl:if test="$result='' and $sTblStyleName">
            <xsl:for-each select="$sTblStyleName">
                <xsl:call-template name="GetSingleTblPrCore">
                    <xsl:with-param name="type" select="$type"/>
                </xsl:call-template>
            </xsl:for-each>
        </xsl:if>
        <xsl:value-of select="$result"/>
    </xsl:template>

    <xsl:template name="GetSingleTblPrCore">
        <xsl:param name="type"/>
        <xsl:for-each select="w:tblPr[1]">
            <xsl:choose>
                <xsl:when test="$type = $prrBdrPr_top">
                    <xsl:for-each select="w:tblBorders[1]/w:top[1]">
                        <xsl:call-template name="GetBorderPr"/>
                    </xsl:for-each>
                </xsl:when>
                <xsl:when test="$type = $prrBdrPr_left">
                    <xsl:for-each select="w:tblBorders[1]/w:left[1]">
                        <xsl:call-template name="GetBorderPr"/>
                    </xsl:for-each>
                </xsl:when>
                <xsl:when test="$type = $prrBdrPr_bottom">
                    <xsl:for-each select="w:tblBorders[1]/w:bottom[1]">
                        <xsl:call-template name="GetBorderPr"/>
                    </xsl:for-each>
                </xsl:when>
                <xsl:when test="$type = $prrBdrPr_right">
                    <xsl:for-each select="w:tblBorders[1]/w:right[1]">
                        <xsl:call-template name="GetBorderPr"/>
                    </xsl:for-each>
                </xsl:when>
                <xsl:when test="$type = $prrBdrPr_insideH">
                    <xsl:for-each select="w:tblBorders[1]/w:insideH[1]">
                        <xsl:call-template name="GetBorderPr"/>
                    </xsl:for-each>
                </xsl:when>
                <xsl:when test="$type = $prrBdrPr_insideV">
                    <xsl:for-each select="w:tblBorders[1]/w:insideV[1]">
                        <xsl:call-template name="GetBorderPr"/>
                    </xsl:for-each>
                </xsl:when>
                <xsl:when test="$type = $prrDefaultCellpadding">
                    <xsl:for-each select="w:tblCellMar[1]">
                        <xsl:call-template name="ApplyCellMar"/>
                    </xsl:for-each>
                </xsl:when>
                <xsl:when test="$type = $prrCellspacing">
                    <xsl:value-of select="w:tblCellSpacing[1]/@w:w"/>
                </xsl:when>
                <xsl:when test="$type = $prrTblInd">
                    <xsl:for-each select="w:tblInd[1]">
                        <xsl:call-template name="EvalTableWidth"/>
                    </xsl:for-each>
                </xsl:when>
            </xsl:choose>
        </xsl:for-each>
    </xsl:template>

    <xsl:template name="WrapCnf">
        <xsl:param name="sTblStyleName"/>
        <xsl:param name="cnfCol"/>
        <xsl:param name="cnfRow"/>
        <xsl:param name="prsPAccum"/>
        <xsl:param name="prsP"/>
        <xsl:param name="prsR"/>

        <xsl:choose>

            <xsl:when test="substring($cnfRow,$icnfBand1Horz,1)=$on">
                <xsl:variable name="p.cnfType" select="$sTblStyleName/w:tblStylePr[@w:type=$cnfBand1Horz][1]"/>

                <xsl:variable name="prsP.updated">
                    <xsl:call-template name="PrsUpdatePPr">
                        <xsl:with-param name="ndPrContainer" select="$p.cnfType"/>
                        <xsl:with-param name="prsP" select="$prsP"/>
                    </xsl:call-template>
                </xsl:variable>
                <xsl:variable name="prsR.updated">
                    <xsl:call-template name="PrsUpdateRPr">
                        <xsl:with-param name="ndPrContainer" select="$p.cnfType"/>
                        <xsl:with-param name="prsR" select="$prsR"/>
                    </xsl:call-template>
                </xsl:variable>
                <xsl:variable name="prsPAccum.updated">
                    <xsl:value-of select="$prsPAccum"/>
                    <xsl:for-each select="$p.cnfType">
                        <xsl:call-template name="ApplyPPr.many"/>
                    </xsl:for-each>
                </xsl:variable>

                <div class="{concat($sTblStyleName/@w:styleId,'-',$cnfBand1Horz)}">
                    <xsl:call-template name="WrapCnf.a">
                        <xsl:with-param name="sTblStyleName" select="$sTblStyleName"/>
                        <xsl:with-param name="cnfCol" select="$cnfCol"/>
                        <xsl:with-param name="cnfRow" select="$cnfRow"/>
                        <xsl:with-param name="prsPAccum" select="$prsPAccum.updated"/>
                        <xsl:with-param name="prsP" select="$prsP.updated"/>
                        <xsl:with-param name="prsR" select="$prsR.updated"/>
                    </xsl:call-template>
                </div>
            </xsl:when>

            <xsl:when test="substring($cnfRow,$icnfBand2Horz,1)=$on">
                <xsl:variable name="p.cnfType" select="$sTblStyleName/w:tblStylePr[@w:type=$cnfBand2Horz][1]"/>

                <xsl:variable name="prsP.updated">
                    <xsl:call-template name="PrsUpdatePPr">
                        <xsl:with-param name="ndPrContainer" select="$p.cnfType"/>
                        <xsl:with-param name="prsP" select="$prsP"/>
                    </xsl:call-template>
                </xsl:variable>
                <xsl:variable name="prsR.updated">
                    <xsl:call-template name="PrsUpdateRPr">
                        <xsl:with-param name="ndPrContainer" select="$p.cnfType"/>
                        <xsl:with-param name="prsR" select="$prsR"/>
                    </xsl:call-template>
                </xsl:variable>
                <xsl:variable name="prsPAccum.updated">
                    <xsl:value-of select="$prsPAccum"/>
                    <xsl:for-each select="$p.cnfType">
                        <xsl:call-template name="ApplyPPr.many"/>
                    </xsl:for-each>
                </xsl:variable>

                <div class="{concat($sTblStyleName/@w:styleId,'-',$cnfBand2Horz)}">
                    <xsl:call-template name="WrapCnf.a">
                        <xsl:with-param name="sTblStyleName" select="$sTblStyleName"/>
                        <xsl:with-param name="cnfCol" select="$cnfCol"/>
                        <xsl:with-param name="cnfRow" select="$cnfRow"/>
                        <xsl:with-param name="prsPAccum" select="$prsPAccum.updated"/>
                        <xsl:with-param name="prsP" select="$prsP.updated"/>
                        <xsl:with-param name="prsR" select="$prsR.updated"/>
                    </xsl:call-template>
                </div>
            </xsl:when>

            <xsl:otherwise>

                <xsl:call-template name="WrapCnf.a">
                    <xsl:with-param name="sTblStyleName" select="$sTblStyleName"/>
                    <xsl:with-param name="cnfCol" select="$cnfCol"/>
                    <xsl:with-param name="cnfRow" select="$cnfRow"/>
                    <xsl:with-param name="prsPAccum" select="$prsPAccum"/>
                    <xsl:with-param name="prsP" select="$prsP"/>
                    <xsl:with-param name="prsR" select="$prsR"/>
                </xsl:call-template>
            </xsl:otherwise>
        </xsl:choose>
    </xsl:template>
    <xsl:template name="WrapCnf.a">
        <xsl:param name="sTblStyleName"/>
        <xsl:param name="cnfCol"/>
        <xsl:param name="cnfRow"/>
        <xsl:param name="prsPAccum"/>
        <xsl:param name="prsP"/>
        <xsl:param name="prsR"/>
        <xsl:choose>

            <xsl:when test="substring($cnfCol,$icnfBand1Vert,1)=$on">
                <xsl:variable name="p.cnfType" select="$sTblStyleName/w:tblStylePr[@w:type=$cnfBand1Vert][1]"/>

                <xsl:variable name="prsP.updated">
                    <xsl:call-template name="PrsUpdatePPr">
                        <xsl:with-param name="ndPrContainer" select="$p.cnfType"/>
                        <xsl:with-param name="prsP" select="$prsP"/>
                    </xsl:call-template>
                </xsl:variable>
                <xsl:variable name="prsR.updated">
                    <xsl:call-template name="PrsUpdateRPr">
                        <xsl:with-param name="ndPrContainer" select="$p.cnfType"/>
                        <xsl:with-param name="prsR" select="$prsR"/>
                    </xsl:call-template>
                </xsl:variable>
                <xsl:variable name="prsPAccum.updated">
                    <xsl:value-of select="$prsPAccum"/>
                    <xsl:for-each select="$p.cnfType">
                        <xsl:call-template name="ApplyPPr.many"/>
                    </xsl:for-each>
                </xsl:variable>

                <div class="{concat($sTblStyleName/@w:styleId,'-',$cnfBand1Vert)}">
                    <xsl:call-template name="WrapCnf.b">
                        <xsl:with-param name="sTblStyleName" select="$sTblStyleName"/>
                        <xsl:with-param name="cnfCol" select="$cnfCol"/>
                        <xsl:with-param name="cnfRow" select="$cnfRow"/>
                        <xsl:with-param name="prsPAccum" select="$prsPAccum.updated"/>
                        <xsl:with-param name="prsP" select="$prsP.updated"/>
                        <xsl:with-param name="prsR" select="$prsR.updated"/>
                    </xsl:call-template>
                </div>
            </xsl:when>

            <xsl:when test="substring($cnfCol,$icnfBand2Vert,1)=$on">
                <xsl:variable name="p.cnfType" select="$sTblStyleName/w:tblStylePr[@w:type=$cnfBand2Vert][1]"/>

                <xsl:variable name="prsP.updated">
                    <xsl:call-template name="PrsUpdatePPr">
                        <xsl:with-param name="ndPrContainer" select="$p.cnfType"/>
                        <xsl:with-param name="prsP" select="$prsP"/>
                    </xsl:call-template>
                </xsl:variable>
                <xsl:variable name="prsR.updated">
                    <xsl:call-template name="PrsUpdateRPr">
                        <xsl:with-param name="ndPrContainer" select="$p.cnfType"/>
                        <xsl:with-param name="prsR" select="$prsR"/>
                    </xsl:call-template>
                </xsl:variable>
                <xsl:variable name="prsPAccum.updated">
                    <xsl:value-of select="$prsPAccum"/>
                    <xsl:for-each select="$p.cnfType">
                        <xsl:call-template name="ApplyPPr.many"/>
                    </xsl:for-each>
                </xsl:variable>

                <div class="{concat($sTblStyleName/@w:styleId,'-',$cnfBand2Vert)}">
                    <xsl:call-template name="WrapCnf.b">
                        <xsl:with-param name="sTblStyleName" select="$sTblStyleName"/>
                        <xsl:with-param name="cnfCol" select="$cnfCol"/>
                        <xsl:with-param name="cnfRow" select="$cnfRow"/>
                        <xsl:with-param name="prsPAccum" select="$prsPAccum.updated"/>
                        <xsl:with-param name="prsP" select="$prsP.updated"/>
                        <xsl:with-param name="prsR" select="$prsR.updated"/>
                    </xsl:call-template>
                </div>
            </xsl:when>

            <xsl:otherwise>

                <xsl:call-template name="WrapCnf.b">
                    <xsl:with-param name="sTblStyleName" select="$sTblStyleName"/>
                    <xsl:with-param name="cnfCol" select="$cnfCol"/>
                    <xsl:with-param name="cnfRow" select="$cnfRow"/>
                    <xsl:with-param name="prsPAccum" select="$prsPAccum"/>
                    <xsl:with-param name="prsP" select="$prsP"/>
                    <xsl:with-param name="prsR" select="$prsR"/>
                </xsl:call-template>
            </xsl:otherwise>
        </xsl:choose>
    </xsl:template>
    <xsl:template name="WrapCnf.b">
        <xsl:param name="sTblStyleName"/>
        <xsl:param name="cnfCol"/>
        <xsl:param name="cnfRow"/>
        <xsl:param name="prsPAccum"/>
        <xsl:param name="prsP"/>
        <xsl:param name="prsR"/>
        <xsl:choose>

            <xsl:when test="substring($cnfCol,$icnfFirstCol,1)=$on">
                <xsl:variable name="p.cnfType" select="$sTblStyleName/w:tblStylePr[@w:type=$cnfFirstCol][1]"/>

                <xsl:variable name="prsP.updated">
                    <xsl:call-template name="PrsUpdatePPr">
                        <xsl:with-param name="ndPrContainer" select="$p.cnfType"/>
                        <xsl:with-param name="prsP" select="$prsP"/>
                    </xsl:call-template>
                </xsl:variable>
                <xsl:variable name="prsR.updated">
                    <xsl:call-template name="PrsUpdateRPr">
                        <xsl:with-param name="ndPrContainer" select="$p.cnfType"/>
                        <xsl:with-param name="prsR" select="$prsR"/>
                    </xsl:call-template>
                </xsl:variable>
                <xsl:variable name="prsPAccum.updated">
                    <xsl:value-of select="$prsPAccum"/>
                    <xsl:for-each select="$p.cnfType">
                        <xsl:call-template name="ApplyPPr.many"/>
                    </xsl:for-each>
                </xsl:variable>

                <div class="{concat($sTblStyleName/@w:styleId,'-',$cnfFirstCol)}">
                    <xsl:call-template name="WrapCnf.c">
                        <xsl:with-param name="sTblStyleName" select="$sTblStyleName"/>
                        <xsl:with-param name="cnfCol" select="$cnfCol"/>
                        <xsl:with-param name="cnfRow" select="$cnfRow"/>
                        <xsl:with-param name="prsPAccum" select="$prsPAccum.updated"/>
                        <xsl:with-param name="prsP" select="$prsP.updated"/>
                        <xsl:with-param name="prsR" select="$prsR.updated"/>
                    </xsl:call-template>
                </div>
            </xsl:when>

            <xsl:when test="substring($cnfCol,$icnfLastCol,1)=$on">
                <xsl:variable name="p.cnfType" select="$sTblStyleName/w:tblStylePr[@w:type=$cnfLastCol][1]"/>

                <xsl:variable name="prsP.updated">
                    <xsl:call-template name="PrsUpdatePPr">
                        <xsl:with-param name="ndPrContainer" select="$p.cnfType"/>
                        <xsl:with-param name="prsP" select="$prsP"/>
                    </xsl:call-template>
                </xsl:variable>
                <xsl:variable name="prsR.updated">
                    <xsl:call-template name="PrsUpdateRPr">
                        <xsl:with-param name="ndPrContainer" select="$p.cnfType"/>
                        <xsl:with-param name="prsR" select="$prsR"/>
                    </xsl:call-template>
                </xsl:variable>
                <xsl:variable name="prsPAccum.updated">
                    <xsl:value-of select="$prsPAccum"/>
                    <xsl:for-each select="$p.cnfType">
                        <xsl:call-template name="ApplyPPr.many"/>
                    </xsl:for-each>
                </xsl:variable>

                <div class="{concat($sTblStyleName/@w:styleId,'-',$cnfLastCol)}">
                    <xsl:call-template name="WrapCnf.c">
                        <xsl:with-param name="sTblStyleName" select="$sTblStyleName"/>
                        <xsl:with-param name="cnfCol" select="$cnfCol"/>
                        <xsl:with-param name="cnfRow" select="$cnfRow"/>
                        <xsl:with-param name="prsPAccum" select="$prsPAccum.updated"/>
                        <xsl:with-param name="prsP" select="$prsP.updated"/>
                        <xsl:with-param name="prsR" select="$prsR.updated"/>
                    </xsl:call-template>
                </div>
            </xsl:when>

            <xsl:otherwise>

                <xsl:call-template name="WrapCnf.c">
                    <xsl:with-param name="sTblStyleName" select="$sTblStyleName"/>
                    <xsl:with-param name="cnfCol" select="$cnfCol"/>
                    <xsl:with-param name="cnfRow" select="$cnfRow"/>
                    <xsl:with-param name="prsPAccum" select="$prsPAccum"/>
                    <xsl:with-param name="prsP" select="$prsP"/>
                    <xsl:with-param name="prsR" select="$prsR"/>
                </xsl:call-template>
            </xsl:otherwise>
        </xsl:choose>
    </xsl:template>
    <xsl:template name="WrapCnf.c">
        <xsl:param name="sTblStyleName"/>
        <xsl:param name="cnfCol"/>
        <xsl:param name="cnfRow"/>
        <xsl:param name="prsPAccum"/>
        <xsl:param name="prsP"/>
        <xsl:param name="prsR"/>
        <xsl:choose>

            <xsl:when test="substring($cnfRow,$icnfFirstRow,1)=$on">
                <xsl:variable name="p.cnfType" select="$sTblStyleName/w:tblStylePr[@w:type=$cnfFirstRow][1]"/>

                <xsl:variable name="prsP.updated">
                    <xsl:call-template name="PrsUpdatePPr">
                        <xsl:with-param name="ndPrContainer" select="$p.cnfType"/>
                        <xsl:with-param name="prsP" select="$prsP"/>
                    </xsl:call-template>
                </xsl:variable>
                <xsl:variable name="prsR.updated">
                    <xsl:call-template name="PrsUpdateRPr">
                        <xsl:with-param name="ndPrContainer" select="$p.cnfType"/>
                        <xsl:with-param name="prsR" select="$prsR"/>
                    </xsl:call-template>
                </xsl:variable>
                <xsl:variable name="prsPAccum.updated">
                    <xsl:value-of select="$prsPAccum"/>
                    <xsl:for-each select="$p.cnfType">
                        <xsl:call-template name="ApplyPPr.many"/>
                    </xsl:for-each>
                </xsl:variable>

                <div class="{concat($sTblStyleName/@w:styleId,'-',$cnfFirstRow)}">
                    <xsl:call-template name="WrapCnf.d">
                        <xsl:with-param name="sTblStyleName" select="$sTblStyleName"/>
                        <xsl:with-param name="cnfCol" select="$cnfCol"/>
                        <xsl:with-param name="cnfRow" select="$cnfRow"/>
                        <xsl:with-param name="prsPAccum" select="$prsPAccum.updated"/>
                        <xsl:with-param name="prsP" select="$prsP.updated"/>
                        <xsl:with-param name="prsR" select="$prsR.updated"/>
                    </xsl:call-template>
                </div>
            </xsl:when>

            <xsl:when test="substring($cnfRow,$icnfLastRow,1)=$on">
                <xsl:variable name="p.cnfType" select="$sTblStyleName/w:tblStylePr[@w:type=$cnfLastRow][1]"/>

                <xsl:variable name="prsP.updated">
                    <xsl:call-template name="PrsUpdatePPr">
                        <xsl:with-param name="ndPrContainer" select="$p.cnfType"/>
                        <xsl:with-param name="prsP" select="$prsP"/>
                    </xsl:call-template>
                </xsl:variable>
                <xsl:variable name="prsR.updated">
                    <xsl:call-template name="PrsUpdateRPr">
                        <xsl:with-param name="ndPrContainer" select="$p.cnfType"/>
                        <xsl:with-param name="prsR" select="$prsR"/>
                    </xsl:call-template>
                </xsl:variable>
                <xsl:variable name="prsPAccum.updated">
                    <xsl:value-of select="$prsPAccum"/>
                    <xsl:for-each select="$p.cnfType">
                        <xsl:call-template name="ApplyPPr.many"/>
                    </xsl:for-each>
                </xsl:variable>

                <div class="{concat($sTblStyleName/@w:styleId,'-',$cnfLastRow)}">
                    <xsl:call-template name="WrapCnf.d">
                        <xsl:with-param name="sTblStyleName" select="$sTblStyleName"/>
                        <xsl:with-param name="cnfCol" select="$cnfCol"/>
                        <xsl:with-param name="cnfRow" select="$cnfRow"/>
                        <xsl:with-param name="prsPAccum" select="$prsPAccum.updated"/>
                        <xsl:with-param name="prsP" select="$prsP.updated"/>
                        <xsl:with-param name="prsR" select="$prsR.updated"/>
                    </xsl:call-template>
                </div>
            </xsl:when>

            <xsl:otherwise>

                <xsl:call-template name="WrapCnf.d">
                    <xsl:with-param name="sTblStyleName" select="$sTblStyleName"/>
                    <xsl:with-param name="cnfCol" select="$cnfCol"/>
                    <xsl:with-param name="cnfRow" select="$cnfRow"/>
                    <xsl:with-param name="prsPAccum" select="$prsPAccum"/>
                    <xsl:with-param name="prsP" select="$prsP"/>
                    <xsl:with-param name="prsR" select="$prsR"/>
                </xsl:call-template>
            </xsl:otherwise>
        </xsl:choose>
    </xsl:template>
    <xsl:template name="WrapCnf.d">
        <xsl:param name="sTblStyleName"/>
        <xsl:param name="cnfCol"/>
        <xsl:param name="cnfRow"/>
        <xsl:param name="prsPAccum"/>
        <xsl:param name="prsP"/>
        <xsl:param name="prsR"/>
        <xsl:choose>

            <xsl:when test="substring($cnfCol,$icnfNECell,1)=$on">
                <xsl:variable name="p.cnfType" select="$sTblStyleName/w:tblStylePr[@w:type=$cnfNECell][1]"/>

                <xsl:variable name="prsP.updated">
                    <xsl:call-template name="PrsUpdatePPr">
                        <xsl:with-param name="ndPrContainer" select="$p.cnfType"/>
                        <xsl:with-param name="prsP" select="$prsP"/>
                    </xsl:call-template>
                </xsl:variable>
                <xsl:variable name="prsR.updated">
                    <xsl:call-template name="PrsUpdateRPr">
                        <xsl:with-param name="ndPrContainer" select="$p.cnfType"/>
                        <xsl:with-param name="prsR" select="$prsR"/>
                    </xsl:call-template>
                </xsl:variable>
                <xsl:variable name="prsPAccum.updated">
                    <xsl:value-of select="$prsPAccum"/>
                    <xsl:for-each select="$p.cnfType">
                        <xsl:call-template name="ApplyPPr.many"/>
                    </xsl:for-each>
                </xsl:variable>

                <div class="{concat($sTblStyleName/@w:styleId,'-',$cnfNECell)}">
                    <xsl:call-template name="DisplayBodyContent">
                        <xsl:with-param name="ns.content" select="*"/>
                        <xsl:with-param name="prsPAccum" select="$prsPAccum.updated"/>
                        <xsl:with-param name="prsP" select="$prsP.updated"/>
                        <xsl:with-param name="prsR" select="$prsR.updated"/>
                    </xsl:call-template>
                </div>
            </xsl:when>

            <xsl:when test="substring($cnfCol,$icnfNWCell,1)=$on">
                <xsl:variable name="p.cnfType" select="$sTblStyleName/w:tblStylePr[@w:type=$cnfNWCell][1]"/>

                <xsl:variable name="prsP.updated">
                    <xsl:call-template name="PrsUpdatePPr">
                        <xsl:with-param name="ndPrContainer" select="$p.cnfType"/>
                        <xsl:with-param name="prsP" select="$prsP"/>
                    </xsl:call-template>
                </xsl:variable>
                <xsl:variable name="prsR.updated">
                    <xsl:call-template name="PrsUpdateRPr">
                        <xsl:with-param name="ndPrContainer" select="$p.cnfType"/>
                        <xsl:with-param name="prsR" select="$prsR"/>
                    </xsl:call-template>
                </xsl:variable>
                <xsl:variable name="prsPAccum.updated">
                    <xsl:value-of select="$prsPAccum"/>
                    <xsl:for-each select="$p.cnfType">
                        <xsl:call-template name="ApplyPPr.many"/>
                    </xsl:for-each>
                </xsl:variable>

                <div class="{concat($sTblStyleName/@w:styleId,'-',$cnfNWCell)}">
                    <xsl:call-template name="DisplayBodyContent">
                        <xsl:with-param name="ns.content" select="*"/>
                        <xsl:with-param name="prsPAccum" select="$prsPAccum.updated"/>
                        <xsl:with-param name="prsP" select="$prsP.updated"/>
                        <xsl:with-param name="prsR" select="$prsR.updated"/>
                    </xsl:call-template>
                </div>
            </xsl:when>

            <xsl:when test="substring($cnfCol,$icnfSECell,1)=$on">
                <xsl:variable name="p.cnfType" select="$sTblStyleName/w:tblStylePr[@w:type=$cnfSECell][1]"/>

                <xsl:variable name="prsP.updated">
                    <xsl:call-template name="PrsUpdatePPr">
                        <xsl:with-param name="ndPrContainer" select="$p.cnfType"/>
                        <xsl:with-param name="prsP" select="$prsP"/>
                    </xsl:call-template>
                </xsl:variable>
                <xsl:variable name="prsR.updated">
                    <xsl:call-template name="PrsUpdateRPr">
                        <xsl:with-param name="ndPrContainer" select="$p.cnfType"/>
                        <xsl:with-param name="prsR" select="$prsR"/>
                    </xsl:call-template>
                </xsl:variable>
                <xsl:variable name="prsPAccum.updated">
                    <xsl:value-of select="$prsPAccum"/>
                    <xsl:for-each select="$p.cnfType">
                        <xsl:call-template name="ApplyPPr.many"/>
                    </xsl:for-each>
                </xsl:variable>

                <div class="{concat($sTblStyleName/@w:styleId,'-',$cnfSECell)}">
                    <xsl:call-template name="DisplayBodyContent">
                        <xsl:with-param name="ns.content" select="*"/>
                        <xsl:with-param name="prsPAccum" select="$prsPAccum.updated"/>
                        <xsl:with-param name="prsP" select="$prsP.updated"/>
                        <xsl:with-param name="prsR" select="$prsR.updated"/>
                    </xsl:call-template>
                </div>
            </xsl:when>

            <xsl:when test="substring($cnfCol,$icnfSWCell,1)=$on">
                <xsl:variable name="p.cnfType" select="$sTblStyleName/w:tblStylePr[@w:type=$cnfSWCell][1]"/>

                <xsl:variable name="prsP.updated">
                    <xsl:call-template name="PrsUpdatePPr">
                        <xsl:with-param name="ndPrContainer" select="$p.cnfType"/>
                        <xsl:with-param name="prsP" select="$prsP"/>
                    </xsl:call-template>
                </xsl:variable>
                <xsl:variable name="prsR.updated">
                    <xsl:call-template name="PrsUpdateRPr">
                        <xsl:with-param name="ndPrContainer" select="$p.cnfType"/>
                        <xsl:with-param name="prsR" select="$prsR"/>
                    </xsl:call-template>
                </xsl:variable>
                <xsl:variable name="prsPAccum.updated">
                    <xsl:value-of select="$prsPAccum"/>
                    <xsl:for-each select="$p.cnfType">
                        <xsl:call-template name="ApplyPPr.many"/>
                    </xsl:for-each>
                </xsl:variable>

                <div class="{concat($sTblStyleName/@w:styleId,'-',$cnfSWCell)}">
                    <xsl:call-template name="DisplayBodyContent">
                        <xsl:with-param name="ns.content" select="*"/>
                        <xsl:with-param name="prsPAccum" select="$prsPAccum.updated"/>
                        <xsl:with-param name="prsP" select="$prsP.updated"/>
                        <xsl:with-param name="prsR" select="$prsR.updated"/>
                    </xsl:call-template>
                </div>
            </xsl:when>

            <xsl:otherwise>

                <xsl:call-template name="DisplayBodyContent">
                    <xsl:with-param name="ns.content" select="*"/>
                    <xsl:with-param name="prsPAccum" select="$prsPAccum"/>
                    <xsl:with-param name="prsP" select="$prsP"/>
                    <xsl:with-param name="prsR" select="$prsR"/>
                </xsl:call-template>
            </xsl:otherwise>
        </xsl:choose>
    </xsl:template>

    <xsl:template name="GetCnfPr.all">
        <xsl:param name="type"/>
        <xsl:param name="cnfCol"/>
        <xsl:param name="cnfRow"/>
        <xsl:choose>
            <xsl:when test="substring($cnfRow,$icnfBand1Horz,1)=$on">
                <xsl:for-each select="w:tblStylePr[@w:type=$cnfBand1Horz][1]">
                    <xsl:call-template name="GetCnfPr.a">
                        <xsl:with-param name="type" select="$type"/>
                    </xsl:call-template>
                </xsl:for-each>
            </xsl:when>
            <xsl:when test="substring($cnfRow,$icnfBand2Horz,1)=$on">
                <xsl:for-each select="w:tblStylePr[@w:type=$cnfBand2Horz][1]">
                    <xsl:call-template name="GetCnfPr.a">
                        <xsl:with-param name="type" select="$type"/>
                    </xsl:call-template>
                </xsl:for-each>
            </xsl:when>
        </xsl:choose>
        <xsl:choose>
            <xsl:when test="substring($cnfCol,$icnfBand1Vert,1)=$on">
                <xsl:for-each select="w:tblStylePr[@w:type=$cnfBand1Vert][1]">
                    <xsl:call-template name="GetCnfPr.a">
                        <xsl:with-param name="type" select="$type"/>
                    </xsl:call-template>
                </xsl:for-each>
            </xsl:when>
            <xsl:when test="substring($cnfCol,$icnfBand2Vert,1)=$on">
                <xsl:for-each select="w:tblStylePr[@w:type=$cnfBand2Vert][1]">
                    <xsl:call-template name="GetCnfPr.a">
                        <xsl:with-param name="type" select="$type"/>
                    </xsl:call-template>
                </xsl:for-each>
            </xsl:when>
        </xsl:choose>
        <xsl:choose>
            <xsl:when test="substring($cnfCol,$icnfFirstCol,1)=$on">
                <xsl:for-each select="w:tblStylePr[@w:type=$cnfFirstCol][1]">
                    <xsl:call-template name="GetCnfPr.a">
                        <xsl:with-param name="type" select="$type"/>
                    </xsl:call-template>
                </xsl:for-each>
            </xsl:when>
            <xsl:when test="substring($cnfCol,$icnfLastCol,1)=$on">
                <xsl:for-each select="w:tblStylePr[@w:type=$cnfLastCol][1]">
                    <xsl:call-template name="GetCnfPr.a">
                        <xsl:with-param name="type" select="$type"/>
                    </xsl:call-template>
                </xsl:for-each>
            </xsl:when>
        </xsl:choose>
        <xsl:choose>
            <xsl:when test="substring($cnfRow,$icnfFirstRow,1)=$on">
                <xsl:for-each select="w:tblStylePr[@w:type=$cnfFirstRow][1]">
                    <xsl:call-template name="GetCnfPr.a">
                        <xsl:with-param name="type" select="$type"/>
                    </xsl:call-template>
                </xsl:for-each>
            </xsl:when>
            <xsl:when test="substring($cnfRow,$icnfLastRow,1)=$on">
                <xsl:for-each select="w:tblStylePr[@w:type=$cnfLastRow][1]">
                    <xsl:call-template name="GetCnfPr.a">
                        <xsl:with-param name="type" select="$type"/>
                    </xsl:call-template>
                </xsl:for-each>
            </xsl:when>
        </xsl:choose>
        <xsl:choose>
            <xsl:when test="substring($cnfCol,$icnfNECell,1)=$on">
                <xsl:for-each select="w:tblStylePr[@w:type=$cnfNECell][1]">
                    <xsl:call-template name="GetCnfPr.a">
                        <xsl:with-param name="type" select="$type"/>
                    </xsl:call-template>
                </xsl:for-each>
            </xsl:when>
            <xsl:when test="substring($cnfCol,$icnfNWCell,1)=$on">
                <xsl:for-each select="w:tblStylePr[@w:type=$cnfNWCell][1]">
                    <xsl:call-template name="GetCnfPr.a">
                        <xsl:with-param name="type" select="$type"/>
                    </xsl:call-template>
                </xsl:for-each>
            </xsl:when>
            <xsl:when test="substring($cnfCol,$icnfSECell,1)=$on">
                <xsl:for-each select="w:tblStylePr[@w:type=$cnfSECell][1]">
                    <xsl:call-template name="GetCnfPr.a">
                        <xsl:with-param name="type" select="$type"/>
                    </xsl:call-template>
                </xsl:for-each>
            </xsl:when>
            <xsl:when test="substring($cnfCol,$icnfSWCell,1)=$on">
                <xsl:for-each select="w:tblStylePr[@w:type=$cnfSWCell][1]">
                    <xsl:call-template name="GetCnfPr.a">
                        <xsl:with-param name="type" select="$type"/>
                    </xsl:call-template>
                </xsl:for-each>
            </xsl:when>
        </xsl:choose>
    </xsl:template>

    <xsl:template name="GetCnfPr.cell">
        <xsl:param name="type"/>
        <xsl:param name="cnfCol"/>
        <xsl:param name="cnfRow"/>
        <xsl:variable name="result1">
            <xsl:choose>
                <xsl:when test="substring($cnfCol,$icnfNECell,1)=$on">
                    <xsl:for-each select="w:tblStylePr[@w:type=$cnfNECell][1]">
                        <xsl:call-template name="GetCnfPr.a">
                            <xsl:with-param name="type" select="$type"/>
                        </xsl:call-template>
                    </xsl:for-each>
                </xsl:when>
                <xsl:when test="substring($cnfCol,$icnfNWCell,1)=$on">
                    <xsl:for-each select="w:tblStylePr[@w:type=$cnfNWCell][1]">
                        <xsl:call-template name="GetCnfPr.a">
                            <xsl:with-param name="type" select="$type"/>
                        </xsl:call-template>
                    </xsl:for-each>
                </xsl:when>
                <xsl:when test="substring($cnfCol,$icnfSECell,1)=$on">
                    <xsl:for-each select="w:tblStylePr[@w:type=$cnfSECell][1]">
                        <xsl:call-template name="GetCnfPr.a">
                            <xsl:with-param name="type" select="$type"/>
                        </xsl:call-template>
                    </xsl:for-each>
                </xsl:when>
                <xsl:when test="substring($cnfCol,$icnfSWCell,1)=$on">
                    <xsl:for-each select="w:tblStylePr[@w:type=$cnfSWCell][1]">
                        <xsl:call-template name="GetCnfPr.a">
                            <xsl:with-param name="type" select="$type"/>
                        </xsl:call-template>
                    </xsl:for-each>
                </xsl:when>
            </xsl:choose>
        </xsl:variable>
        <xsl:value-of select="$result1"/>
        <xsl:if test="$result1=''">
            <xsl:variable name="result2">
                <xsl:choose>
                    <xsl:when test="substring($cnfRow,$icnfFirstRow,1)=$on">
                        <xsl:for-each select="w:tblStylePr[@w:type=$cnfFirstRow][1]">
                            <xsl:call-template name="GetCnfPr.a">
                                <xsl:with-param name="type" select="$type"/>
                            </xsl:call-template>
                        </xsl:for-each>
                    </xsl:when>
                    <xsl:when test="substring($cnfRow,$icnfLastRow,1)=$on">
                        <xsl:for-each select="w:tblStylePr[@w:type=$cnfLastRow][1]">
                            <xsl:call-template name="GetCnfPr.a">
                                <xsl:with-param name="type" select="$type"/>
                            </xsl:call-template>
                        </xsl:for-each>
                    </xsl:when>
                </xsl:choose>
            </xsl:variable>
            <xsl:value-of select="$result2"/>
            <xsl:if test="$result2=''">
                <xsl:variable name="result3">
                    <xsl:choose>
                        <xsl:when test="substring($cnfCol,$icnfFirstCol,1)=$on">
                            <xsl:for-each select="w:tblStylePr[@w:type=$cnfFirstCol][1]">
                                <xsl:call-template name="GetCnfPr.a">
                                    <xsl:with-param name="type" select="$type"/>
                                </xsl:call-template>
                            </xsl:for-each>
                        </xsl:when>
                        <xsl:when test="substring($cnfCol,$icnfLastCol,1)=$on">
                            <xsl:for-each select="w:tblStylePr[@w:type=$cnfLastCol][1]">
                                <xsl:call-template name="GetCnfPr.a">
                                    <xsl:with-param name="type" select="$type"/>
                                </xsl:call-template>
                            </xsl:for-each>
                        </xsl:when>
                    </xsl:choose>
                </xsl:variable>
                <xsl:value-of select="$result3"/>
                <xsl:if test="$result3=''">
                    <xsl:variable name="result4">
                        <xsl:choose>
                            <xsl:when test="substring($cnfCol,$icnfBand1Vert,1)=$on">
                                <xsl:for-each select="w:tblStylePr[@w:type=$cnfBand1Vert][1]">
                                    <xsl:call-template name="GetCnfPr.a">
                                        <xsl:with-param name="type" select="$type"/>
                                    </xsl:call-template>
                                </xsl:for-each>
                            </xsl:when>
                            <xsl:when test="substring($cnfCol,$icnfBand2Vert,1)=$on">
                                <xsl:for-each select="w:tblStylePr[@w:type=$cnfBand2Vert][1]">
                                    <xsl:call-template name="GetCnfPr.a">
                                        <xsl:with-param name="type" select="$type"/>
                                    </xsl:call-template>
                                </xsl:for-each>
                            </xsl:when>
                        </xsl:choose>
                    </xsl:variable>
                    <xsl:value-of select="$result4"/>
                    <xsl:if test="$result4=''">
                        <xsl:choose>
                            <xsl:when test="substring($cnfRow,$icnfBand1Horz,1)=$on">
                                <xsl:for-each select="w:tblStylePr[@w:type=$cnfBand1Horz][1]">
                                    <xsl:call-template name="GetCnfPr.a">
                                        <xsl:with-param name="type" select="$type"/>
                                    </xsl:call-template>
                                </xsl:for-each>
                            </xsl:when>
                            <xsl:when test="substring($cnfRow,$icnfBand2Horz,1)=$on">
                                <xsl:for-each select="w:tblStylePr[@w:type=$cnfBand2Horz][1]">
                                    <xsl:call-template name="GetCnfPr.a">
                                        <xsl:with-param name="type" select="$type"/>
                                    </xsl:call-template>
                                </xsl:for-each>
                            </xsl:when>
                        </xsl:choose>
                    </xsl:if>
                </xsl:if>
            </xsl:if>
        </xsl:if>
    </xsl:template>

    <xsl:template name="GetCnfPr.row">
        <xsl:param name="type"/>
        <xsl:param name="cnfRow"/>
        <xsl:variable name="result1">
            <xsl:choose>
                <xsl:when test="substring($cnfRow,$icnfFirstRow,1)=$on">
                    <xsl:for-each select="w:tblStylePr[@w:type=$cnfFirstRow][1]">
                        <xsl:call-template name="GetCnfPr.a">
                            <xsl:with-param name="type" select="$type"/>
                        </xsl:call-template>
                    </xsl:for-each>
                </xsl:when>
                <xsl:when test="substring($cnfRow,$icnfLastRow,1)=$on">
                    <xsl:for-each select="w:tblStylePr[@w:type=$cnfLastRow][1]">
                        <xsl:call-template name="GetCnfPr.a">
                            <xsl:with-param name="type" select="$type"/>
                        </xsl:call-template>
                    </xsl:for-each>
                </xsl:when>
            </xsl:choose>
        </xsl:variable>
        <xsl:value-of select="$result1"/>
        <xsl:if test="$result1=''">
            <xsl:choose>
                <xsl:when test="substring($cnfRow,$icnfBand1Horz,1)=$on">
                    <xsl:for-each select="w:tblStylePr[@w:type=$cnfBand1Horz][1]">
                        <xsl:call-template name="GetCnfPr.a">
                            <xsl:with-param name="type" select="$type"/>
                        </xsl:call-template>
                    </xsl:for-each>
                </xsl:when>
                <xsl:when test="substring($cnfRow,$icnfBand2Horz,1)=$on">
                    <xsl:for-each select="w:tblStylePr[@w:type=$cnfBand2Horz][1]">
                        <xsl:call-template name="GetCnfPr.a">
                            <xsl:with-param name="type" select="$type"/>
                        </xsl:call-template>
                    </xsl:for-each>
                </xsl:when>
            </xsl:choose>
        </xsl:if>
    </xsl:template>

    <xsl:template name="GetCnfPr.a">
        <xsl:param name="type"/>
        <xsl:choose>
            <xsl:when test="$type = $prrApplyTcPr">
                <xsl:call-template name="ApplyTcPr.class"/>
            </xsl:when>
            <xsl:when test="$type = $prrCustomCellpadding">
                <xsl:for-each select="w:tcPr[1]/w:tcMar[1]">
                    <xsl:call-template name="ApplyCellMar"/>
                </xsl:for-each>
            </xsl:when>
            <xsl:when test="$type = $prrDefaultCellpadding">
                <xsl:for-each select="w:tblPr[1]/w:tblCellMar[1]">
                    <xsl:call-template name="ApplyCellMar"/>
                </xsl:for-each>
            </xsl:when>
            <xsl:when test="$type = $prrCantSplit">
                <xsl:for-each select="w:trPr[1]/w:cantSplit[1]">
                    <xsl:choose>
                        <xsl:when test="@w:val = 'off'">page-break-inside:auto;</xsl:when>
                        <xsl:otherwise>page-break-inside:avoid;</xsl:otherwise>
                    </xsl:choose>
                </xsl:for-each>
            </xsl:when>
        </xsl:choose>
    </xsl:template>

    <xsl:template name="GetCnfType">
        <xsl:param name="cnfCol"/>
        <xsl:param name="cnfRow"/>
        <xsl:choose>
            <xsl:when test="substring($cnfCol,$icnfNECell,1)=$on">
                <xsl:value-of select="$cnfNECell"/>
            </xsl:when>
            <xsl:when test="substring($cnfCol,$icnfNWCell,1)=$on">
                <xsl:value-of select="$cnfNWCell"/>
            </xsl:when>
            <xsl:when test="substring($cnfCol,$icnfSECell,1)=$on">
                <xsl:value-of select="$cnfSECell"/>
            </xsl:when>
            <xsl:when test="substring($cnfCol,$icnfSWCell,1)=$on">
                <xsl:value-of select="$cnfSWCell"/>
            </xsl:when>
            <xsl:when test="substring($cnfRow,$icnfFirstRow,1)=$on">
                <xsl:value-of select="$cnfFirstRow"/>
            </xsl:when>
            <xsl:when test="substring($cnfRow,$icnfLastRow,1)=$on">
                <xsl:value-of select="$cnfLastRow"/>
            </xsl:when>
            <xsl:when test="substring($cnfCol,$icnfFirstCol,1)=$on">
                <xsl:value-of select="$cnfFirstCol"/>
            </xsl:when>
            <xsl:when test="substring($cnfCol,$icnfLastCol,1)=$on">
                <xsl:value-of select="$cnfLastCol"/>
            </xsl:when>
            <xsl:when test="substring($cnfCol,$icnfBand1Vert,1)=$on">
                <xsl:value-of select="$cnfBand1Vert"/>
            </xsl:when>
            <xsl:when test="substring($cnfCol,$icnfBand2Vert,1)=$on">
                <xsl:value-of select="$cnfBand2Vert"/>
            </xsl:when>
            <xsl:when test="substring($cnfRow,$icnfBand1Horz,1)=$on">
                <xsl:value-of select="$cnfBand1Horz"/>
            </xsl:when>
            <xsl:when test="substring($cnfRow,$icnfBand2Horz,1)=$on">
                <xsl:value-of select="$cnfBand2Horz"/>
            </xsl:when>
        </xsl:choose>
    </xsl:template>

    <xsl:template name="GetCnfTypeRow">
        <xsl:param name="cnfRow"/>
        <xsl:choose>
            <xsl:when test="substring($cnfRow,$icnfFirstRow,1)=$on">
                <xsl:value-of select="$cnfFirstRow"/>
            </xsl:when>
            <xsl:when test="substring($cnfRow,$icnfLastRow,1)=$on">
                <xsl:value-of select="$cnfLastRow"/>
            </xsl:when>
            <xsl:when test="substring($cnfRow,$icnfBand1Horz,1)=$on">
                <xsl:value-of select="$cnfBand1Horz"/>
            </xsl:when>
            <xsl:when test="substring($cnfRow,$icnfBand2Horz,1)=$on">
                <xsl:value-of select="$cnfBand2Horz"/>
            </xsl:when>
        </xsl:choose>
    </xsl:template>

    <xsl:template name="GetCnfTypeCol">
        <xsl:param name="cnfCol"/>
        <xsl:choose>
            <xsl:when test="substring($cnfCol,$icnfNECell,1)=$on">
                <xsl:value-of select="$cnfNECell"/>
            </xsl:when>
            <xsl:when test="substring($cnfCol,$icnfNWCell,1)=$on">
                <xsl:value-of select="$cnfNWCell"/>
            </xsl:when>
            <xsl:when test="substring($cnfCol,$icnfSECell,1)=$on">
                <xsl:value-of select="$cnfSECell"/>
            </xsl:when>
            <xsl:when test="substring($cnfCol,$icnfSWCell,1)=$on">
                <xsl:value-of select="$cnfSWCell"/>
            </xsl:when>
            <xsl:when test="substring($cnfCol,$icnfFirstCol,1)=$on">
                <xsl:value-of select="$cnfFirstCol"/>
            </xsl:when>
            <xsl:when test="substring($cnfCol,$icnfLastCol,1)=$on">
                <xsl:value-of select="$cnfLastCol"/>
            </xsl:when>
            <xsl:when test="substring($cnfCol,$icnfBand1Vert,1)=$on">
                <xsl:value-of select="$cnfBand1Vert"/>
            </xsl:when>
            <xsl:when test="substring($cnfCol,$icnfBand2Vert,1)=$on">
                <xsl:value-of select="$cnfBand2Vert"/>
            </xsl:when>
        </xsl:choose>
    </xsl:template>

    <xsl:template name="RecursiveRStyledGetBorderPr">
        <xsl:param name="rStyleId"/>

        <xsl:variable name="myStyle" select="($nsStyles[@w:styleId=$rStyleId])[1]"/>

        <xsl:if test="not($rStyleId='')">
            <xsl:choose>
                <xsl:when test="$myStyle/w:rPr[1]/w:bdr[1]">
                    <xsl:for-each select="$myStyle/w:rPr[1]/w:bdr[1]">
                        <xsl:call-template name="GetBorderPr"/>
                    </xsl:for-each>
                </xsl:when>
                <xsl:otherwise>
                    <xsl:if test="$myStyle/w:basedOn">
                        <xsl:call-template name="RecursiveRStyledGetBorderPr">
                            <xsl:with-param name="rStyleId" select="$myStyle/w:basedOn/@w:val"/>
                        </xsl:call-template>
                    </xsl:if>
                </xsl:otherwise>
            </xsl:choose>

        </xsl:if>
    </xsl:template>

    <xsl:template name="DisplayRBorder">
        <xsl:param name="ns.content" select="*"/>
        <xsl:param name="i.range.start" select="1"/>
        <xsl:param name="i.this" select="number($i.range.start)"/>
        <xsl:param name="pr.bdr.prev" select="''"/>
        <xsl:param name="b.bidi"/>
        <xsl:param name="prsR"/>
        <xsl:param name="runStyleName"/>
        <xsl:choose>

            <xsl:when test="($ns.content)[$i.this]">
                <xsl:for-each select="($ns.content)[$i.this]">
                    <xsl:choose>

                        <xsl:when
                                test="name() = 'w:proofErr' or (name() = 'aml:annotation' and not(@w:type = 'Word.Insertion'))">
                            <xsl:call-template name="DisplayRBorder">
                                <xsl:with-param name="ns.content" select="$ns.content"/>
                                <xsl:with-param name="i.range.start" select="$i.range.start"/>
                                <xsl:with-param name="i.this" select="$i.this+1"/>
                                <xsl:with-param name="pr.bdr.prev" select="$pr.bdr.prev"/>
                                <xsl:with-param name="b.bidi" select="$b.bidi"/>
                                <xsl:with-param name="prsR" select="$prsR"/>
                                <xsl:with-param name="runStyleName" select="$runStyleName"/>
                            </xsl:call-template>
                        </xsl:when>
                        <xsl:otherwise>

                            <xsl:variable name="pr.bdr.this">
                                <xsl:choose>

                                    <xsl:when test="name()='aml:annotation'"/>

                                    <xsl:otherwise>

                                        <xsl:for-each select="descendant-or-self::*[name()='w:pPr' or name()='w:r'][1]">
                                            <xsl:choose>
                                                <xsl:when test="w:rPr[1]/w:bdr[1]">
                                                    <xsl:for-each select="w:rPr[1]/w:bdr[1]">
                                                        <xsl:call-template name="GetBorderPr"/>
                                                    </xsl:for-each>
                                                </xsl:when>

                                                <xsl:otherwise>
                                                    <xsl:call-template name="RecursiveRStyledGetBorderPr">
                                                        <xsl:with-param name="rStyleId"
                                                                        select="w:rPr[1]/w:rStyle[1]/@w:val"/>
                                                    </xsl:call-template>
                                                </xsl:otherwise>
                                            </xsl:choose>
                                        </xsl:for-each>
                                    </xsl:otherwise>
                                </xsl:choose>
                            </xsl:variable>
                            <xsl:choose>

                                <xsl:when test="$pr.bdr.prev = $pr.bdr.this">

                                    <xsl:call-template name="DisplayRBorder">
                                        <xsl:with-param name="ns.content" select="$ns.content"/>
                                        <xsl:with-param name="i.range.start" select="$i.range.start"/>
                                        <xsl:with-param name="i.this" select="$i.this+1"/>
                                        <xsl:with-param name="pr.bdr.prev" select="$pr.bdr.prev"/>
                                        <xsl:with-param name="b.bidi" select="$b.bidi"/>
                                        <xsl:with-param name="prsR" select="$prsR"/>
                                        <xsl:with-param name="runStyleName" select="$runStyleName"/>
                                    </xsl:call-template>
                                </xsl:when>

                                <xsl:otherwise>

                                    <xsl:call-template name="WrapRBorder">
                                        <xsl:with-param name="ns.content" select="$ns.content"/>
                                        <xsl:with-param name="i.bdrRange.start" select="$i.range.start"/>
                                        <xsl:with-param name="i.bdrRange.end" select="$i.this"/>
                                        <xsl:with-param name="pr.bdr" select="$pr.bdr.prev"/>
                                        <xsl:with-param name="b.bidi" select="$b.bidi"/>
                                        <xsl:with-param name="prsR" select="$prsR"/>
                                        <xsl:with-param name="runStyleName" select="$runStyleName"/>
                                    </xsl:call-template>

                                    <xsl:call-template name="DisplayRBorder">
                                        <xsl:with-param name="ns.content" select="$ns.content"/>
                                        <xsl:with-param name="i.range.start" select="$i.this"/>
                                        <xsl:with-param name="i.this" select="$i.this+1"/>
                                        <xsl:with-param name="pr.bdr.prev" select="$pr.bdr.this"/>
                                        <xsl:with-param name="b.bidi" select="$b.bidi"/>
                                        <xsl:with-param name="prsR" select="$prsR"/>
                                        <xsl:with-param name="runStyleName" select="$runStyleName"/>
                                    </xsl:call-template>
                                </xsl:otherwise>
                            </xsl:choose>
                        </xsl:otherwise>
                    </xsl:choose>
                </xsl:for-each>
            </xsl:when>

            <xsl:otherwise>

                <xsl:call-template name="WrapRBorder">
                    <xsl:with-param name="ns.content" select="$ns.content"/>
                    <xsl:with-param name="i.bdrRange.start" select="$i.range.start"/>
                    <xsl:with-param name="i.bdrRange.end" select="$i.this"/>
                    <xsl:with-param name="pr.bdr" select="$pr.bdr.prev"/>
                    <xsl:with-param name="b.bidi" select="$b.bidi"/>
                    <xsl:with-param name="prsR" select="$prsR"/>
                    <xsl:with-param name="runStyleName" select="$runStyleName"/>
                </xsl:call-template>
            </xsl:otherwise>
        </xsl:choose>
    </xsl:template>

    <xsl:template name="WrapRBorder">
        <xsl:param name="ns.content"/>
        <xsl:param name="i.bdrRange.start"/>
        <xsl:param name="i.bdrRange.end"/>
        <xsl:param name="pr.bdr"/>
        <xsl:param name="b.bidi"/>
        <xsl:param name="prsR"/>
        <xsl:param name="runStyleName"/>
        <xsl:choose>

            <xsl:when test="$pr.bdr = ''">
                <xsl:apply-templates
                        select="($ns.content)[position() &gt;= $i.bdrRange.start and position() &lt; $i.bdrRange.end]">
                    <xsl:with-param name="b.bidi" select="$b.bidi"/>
                    <xsl:with-param name="prsR" select="$prsR"/>
                    <xsl:with-param name="runStyleName" select="$runStyleName"/>
                </xsl:apply-templates>
            </xsl:when>

            <xsl:otherwise>
                <span>
                    <xsl:attribute name="style">
                        <xsl:call-template name="ApplyBorderPr">
                            <xsl:with-param name="pr.bdr" select="$pr.bdr"/>
                        </xsl:call-template>
                    </xsl:attribute>
                    <xsl:apply-templates
                            select="($ns.content)[position() &gt;= $i.bdrRange.start and position() &lt; $i.bdrRange.end]">
                        <xsl:with-param name="b.bidi" select="$b.bidi"/>
                        <xsl:with-param name="prsR" select="$prsR"/>
                        <xsl:with-param name="runStyleName" select="$runStyleName"/>
                    </xsl:apply-templates>
                </span>
            </xsl:otherwise>
        </xsl:choose>
    </xsl:template>

    <xsl:template name="DisplayPBorderOld">
        <xsl:param name="pr.frame.prev"/>
        <xsl:param name="pr.bdrTop.prev"/>
        <xsl:param name="pr.bdrLeft.prev"/>
        <xsl:param name="pr.bdrBottom.prev"/>
        <xsl:param name="pr.bdrRight.prev"/>
        <xsl:param name="pr.bdrBetween.prev"/>
        <xsl:param name="pr.bdrBar.prev"/>
        <xsl:param name="ns.content"/>
        <xsl:param name="i.range.start" select="1"/>
        <xsl:param name="i.this" select="number($i.range.start)"/>
        <xsl:param name="prsPAccum"/>
        <xsl:param name="prsP"/>
        <xsl:param name="prsR"/>
        <xsl:choose>

            <xsl:when test="($ns.content)[$i.this]">
                <xsl:for-each select="($ns.content)[$i.this]">
                    <xsl:variable name="pstyle">
                        <xsl:call-template name="GetPStyleId"/>
                    </xsl:variable>
                    <xsl:variable name="sParaStyleName" select="($nsStyles[@w:styleId=$pstyle])[1]"/>

                    <xsl:variable name="pr.frame.this">
                        <xsl:call-template name="GetSinglePPr">
                            <xsl:with-param name="type" select="$prrFrame"/>
                            <xsl:with-param name="sParaStyleName" select="$sParaStyleName"/>
                        </xsl:call-template>
                    </xsl:variable>
                    <xsl:variable name="pr.bdrTop.this">
                        <xsl:call-template name="GetSinglePPr">
                            <xsl:with-param name="type" select="$prrBdrPr_top"/>
                            <xsl:with-param name="sParaStyleName" select="$sParaStyleName"/>
                        </xsl:call-template>
                    </xsl:variable>
                    <xsl:variable name="pr.bdrLeft.this">
                        <xsl:call-template name="GetSinglePPr">
                            <xsl:with-param name="type" select="$prrBdrPr_left"/>
                            <xsl:with-param name="sParaStyleName" select="$sParaStyleName"/>
                        </xsl:call-template>
                    </xsl:variable>
                    <xsl:variable name="pr.bdrBottom.this">
                        <xsl:call-template name="GetSinglePPr">
                            <xsl:with-param name="type" select="$prrBdrPr_bottom"/>
                            <xsl:with-param name="sParaStyleName" select="$sParaStyleName"/>
                        </xsl:call-template>
                    </xsl:variable>
                    <xsl:variable name="pr.bdrRight.this">
                        <xsl:call-template name="GetSinglePPr">
                            <xsl:with-param name="type" select="$prrBdrPr_right"/>
                            <xsl:with-param name="sParaStyleName" select="$sParaStyleName"/>
                        </xsl:call-template>
                    </xsl:variable>
                    <xsl:variable name="pr.bdrBetween.this">
                        <xsl:call-template name="GetSinglePPr">
                            <xsl:with-param name="type" select="$prrBdrPr_between"/>
                            <xsl:with-param name="sParaStyleName" select="$sParaStyleName"/>
                        </xsl:call-template>
                    </xsl:variable>
                    <xsl:variable name="pr.bdrBar.this">
                        <xsl:call-template name="GetSinglePPr">
                            <xsl:with-param name="type" select="$prrBdrPr_bar"/>
                            <xsl:with-param name="sParaStyleName" select="$sParaStyleName"/>
                        </xsl:call-template>
                    </xsl:variable>
                    <xsl:choose>

                        <xsl:when
                                test="0 = 1 and $pr.frame.prev = $pr.frame.this and $pr.bdrTop.prev = $pr.bdrTop.this and $pr.bdrLeft.prev = $pr.bdrLeft.this and $pr.bdrBottom.prev = $pr.bdrBottom.this and $pr.bdrRight.prev = $pr.bdrRight.this and $pr.bdrBetween.prev = $pr.bdrBetween.this and $pr.bdrBar.prev = $pr.bdrBar.this">
                            <xsl:call-template name="DisplayPBorder">
                                <xsl:with-param name="ns.content" select="$ns.content"/>
                                <xsl:with-param name="i.range.start" select="$i.range.start"/>
                                <xsl:with-param name="i.this" select="$i.this+1"/>
                                <xsl:with-param name="prsPAccum" select="$prsPAccum"/>
                                <xsl:with-param name="prsP" select="$prsP"/>
                                <xsl:with-param name="prsR" select="$prsR"/>
                                <xsl:with-param name="pr.frame.prev" select="$pr.frame.prev"/>
                                <xsl:with-param name="pr.bdrTop.prev" select="$pr.bdrTop.prev"/>
                                <xsl:with-param name="pr.bdrLeft.prev" select="$pr.bdrLeft.prev"/>
                                <xsl:with-param name="pr.bdrBottom.prev" select="$pr.bdrBottom.prev"/>
                                <xsl:with-param name="pr.bdrRight.prev" select="$pr.bdrRight.prev"/>
                                <xsl:with-param name="pr.bdrBetween.prev" select="$pr.bdrBetween.prev"/>
                                <xsl:with-param name="pr.bdrBar.prev" select="$pr.bdrBar.prev"/>
                            </xsl:call-template>
                        </xsl:when>

                        <xsl:otherwise>

                            <xsl:call-template name="wrapFrame">
                                <xsl:with-param name="ns.content" select="$ns.content"/>
                                <xsl:with-param name="i.bdrRange.start" select="$i.range.start"/>
                                <xsl:with-param name="i.bdrRange.end" select="$i.this"/>
                                <xsl:with-param name="prsPAccum" select="$prsPAccum"/>
                                <xsl:with-param name="prsP" select="$prsP"/>
                                <xsl:with-param name="prsR" select="$prsR"/>
                                <xsl:with-param name="framePr" select="$pr.frame.prev"/>
                                <xsl:with-param name="pr.bdrTop" select="$pr.bdrTop.prev"/>
                                <xsl:with-param name="pr.bdrLeft" select="$pr.bdrLeft.prev"/>
                                <xsl:with-param name="pr.bdrBottom" select="$pr.bdrBottom.prev"/>
                                <xsl:with-param name="pr.bdrRight" select="$pr.bdrRight.prev"/>
                                <xsl:with-param name="pr.bdrBetween" select="$pr.bdrBetween.prev"/>
                                <xsl:with-param name="pr.bdrBar" select="$pr.bdrBar.prev"/>
                            </xsl:call-template>

                            <xsl:call-template name="DisplayPBorder">
                                <xsl:with-param name="ns.content" select="$ns.content"/>
                                <xsl:with-param name="i.range.start" select="$i.this"/>
                                <xsl:with-param name="i.this" select="$i.this+1"/>
                                <xsl:with-param name="prsPAccum" select="$prsPAccum"/>
                                <xsl:with-param name="prsP" select="$prsP"/>
                                <xsl:with-param name="prsR" select="$prsR"/>
                                <xsl:with-param name="pr.frame.prev" select="$pr.frame.this"/>
                                <xsl:with-param name="pr.bdrTop.prev" select="$pr.bdrTop.this"/>
                                <xsl:with-param name="pr.bdrLeft.prev" select="$pr.bdrLeft.this"/>
                                <xsl:with-param name="pr.bdrBottom.prev" select="$pr.bdrBottom.this"/>
                                <xsl:with-param name="pr.bdrRight.prev" select="$pr.bdrRight.this"/>
                                <xsl:with-param name="pr.bdrBetween.prev" select="$pr.bdrBetween.this"/>
                                <xsl:with-param name="pr.bdrBar.prev" select="$pr.bdrBar.this"/>
                            </xsl:call-template>
                        </xsl:otherwise>
                    </xsl:choose>
                </xsl:for-each>
            </xsl:when>

            <xsl:otherwise>
                <xsl:call-template name="wrapFrame">
                    <xsl:with-param name="ns.content" select="$ns.content"/>
                    <xsl:with-param name="i.bdrRange.start" select="$i.range.start"/>
                    <xsl:with-param name="i.bdrRange.end" select="$i.this"/>
                    <xsl:with-param name="prsPAccum" select="$prsPAccum"/>
                    <xsl:with-param name="prsP" select="$prsP"/>
                    <xsl:with-param name="prsR" select="$prsR"/>
                    <xsl:with-param name="framePr" select="$pr.frame.prev"/>
                    <xsl:with-param name="pr.bdrTop" select="$pr.bdrTop.prev"/>
                    <xsl:with-param name="pr.bdrLeft" select="$pr.bdrLeft.prev"/>
                    <xsl:with-param name="pr.bdrBottom" select="$pr.bdrBottom.prev"/>
                    <xsl:with-param name="pr.bdrRight" select="$pr.bdrRight.prev"/>
                    <xsl:with-param name="pr.bdrBetween" select="$pr.bdrBetween.prev"/>
                    <xsl:with-param name="pr.bdrBar" select="$pr.bdrBar.prev"/>
                </xsl:call-template>
            </xsl:otherwise>
        </xsl:choose>
    </xsl:template>

    <xsl:template name="DisplayPBorder">
        <xsl:param name="pr.frame.prev"/>
        <xsl:param name="pr.bdrTop.prev"/>
        <xsl:param name="pr.bdrLeft.prev"/>
        <xsl:param name="pr.bdrBottom.prev"/>
        <xsl:param name="pr.bdrRight.prev"/>
        <xsl:param name="pr.bdrBetween.prev"/>
        <xsl:param name="pr.bdrBar.prev"/>
        <xsl:param name="ns.content"/>
        <xsl:param name="i.range.start" select="1"/>
        <xsl:param name="i.this" select="number($i.range.start)"/>
        <xsl:param name="prsPAccum"/>
        <xsl:param name="prsP"/>
        <xsl:param name="prsR"/>
        <xsl:choose>

            <xsl:when test="($ns.content)[$i.this]">
                <xsl:for-each select="($ns.content)">

                    <xsl:variable name="pstyle">
                        <xsl:call-template name="GetPStyleId"/>
                    </xsl:variable>
                    <xsl:variable name="sParaStyleName" select="($nsStyles[@w:styleId=$pstyle])[1]"/>

                    <xsl:variable name="pr.frame.this">
                        <xsl:call-template name="GetSinglePPr">
                            <xsl:with-param name="type" select="$prrFrame"/>
                            <xsl:with-param name="sParaStyleName" select="$sParaStyleName"/>
                        </xsl:call-template>
                    </xsl:variable>
                    <xsl:variable name="pr.bdrTop.this">
                        <xsl:call-template name="GetSinglePPr">
                            <xsl:with-param name="type" select="$prrBdrPr_top"/>
                            <xsl:with-param name="sParaStyleName" select="$sParaStyleName"/>
                        </xsl:call-template>
                    </xsl:variable>
                    <xsl:variable name="pr.bdrLeft.this">
                        <xsl:call-template name="GetSinglePPr">
                            <xsl:with-param name="type" select="$prrBdrPr_left"/>
                            <xsl:with-param name="sParaStyleName" select="$sParaStyleName"/>
                        </xsl:call-template>
                    </xsl:variable>
                    <xsl:variable name="pr.bdrBottom.this">
                        <xsl:call-template name="GetSinglePPr">
                            <xsl:with-param name="type" select="$prrBdrPr_bottom"/>
                            <xsl:with-param name="sParaStyleName" select="$sParaStyleName"/>
                        </xsl:call-template>
                    </xsl:variable>
                    <xsl:variable name="pr.bdrRight.this">
                        <xsl:call-template name="GetSinglePPr">
                            <xsl:with-param name="type" select="$prrBdrPr_right"/>
                            <xsl:with-param name="sParaStyleName" select="$sParaStyleName"/>
                        </xsl:call-template>
                    </xsl:variable>
                    <xsl:variable name="pr.bdrBetween.this">
                        <xsl:call-template name="GetSinglePPr">
                            <xsl:with-param name="type" select="$prrBdrPr_between"/>
                            <xsl:with-param name="sParaStyleName" select="$sParaStyleName"/>
                        </xsl:call-template>
                    </xsl:variable>
                    <xsl:variable name="pr.bdrBar.this">
                        <xsl:call-template name="GetSinglePPr">
                            <xsl:with-param name="type" select="$prrBdrPr_bar"/>
                            <xsl:with-param name="sParaStyleName" select="$sParaStyleName"/>
                        </xsl:call-template>
                    </xsl:variable>

                    <xsl:call-template name="wrapFrame">
                        <xsl:with-param name="ns.content" select="."/>
                        <xsl:with-param name="i.bdrRange.start" select="1"/>
                        <xsl:with-param name="i.bdrRange.end" select="2"/>
                        <xsl:with-param name="prsPAccum" select="$prsPAccum"/>
                        <xsl:with-param name="prsP" select="$prsP"/>
                        <xsl:with-param name="prsR" select="$prsR"/>
                        <xsl:with-param name="framePr" select="$pr.frame.prev"/>
                        <xsl:with-param name="pr.bdrTop" select="$pr.bdrTop.prev"/>
                        <xsl:with-param name="pr.bdrLeft" select="$pr.bdrLeft.prev"/>
                        <xsl:with-param name="pr.bdrBottom" select="$pr.bdrBottom.prev"/>
                        <xsl:with-param name="pr.bdrRight" select="$pr.bdrRight.prev"/>
                        <xsl:with-param name="pr.bdrBetween" select="$pr.bdrBetween.prev"/>
                        <xsl:with-param name="pr.bdrBar" select="$pr.bdrBar.prev"/>
                    </xsl:call-template>
                </xsl:for-each>

            </xsl:when>

            <xsl:otherwise>
                <xsl:call-template name="wrapFrame">
                    <xsl:with-param name="ns.content" select="$ns.content"/>
                    <xsl:with-param name="i.bdrRange.start" select="$i.range.start"/>
                    <xsl:with-param name="i.bdrRange.end" select="$i.this"/>
                    <xsl:with-param name="prsPAccum" select="$prsPAccum"/>
                    <xsl:with-param name="prsP" select="$prsP"/>
                    <xsl:with-param name="prsR" select="$prsR"/>
                    <xsl:with-param name="framePr" select="$pr.frame.prev"/>
                    <xsl:with-param name="pr.bdrTop" select="$pr.bdrTop.prev"/>
                    <xsl:with-param name="pr.bdrLeft" select="$pr.bdrLeft.prev"/>
                    <xsl:with-param name="pr.bdrBottom" select="$pr.bdrBottom.prev"/>
                    <xsl:with-param name="pr.bdrRight" select="$pr.bdrRight.prev"/>
                    <xsl:with-param name="pr.bdrBetween" select="$pr.bdrBetween.prev"/>
                    <xsl:with-param name="pr.bdrBar" select="$pr.bdrBar.prev"/>
                </xsl:call-template>
            </xsl:otherwise>
        </xsl:choose>
    </xsl:template>

    <xsl:template name="wrapFrame">
        <xsl:param name="framePr"/>
        <xsl:param name="pr.bdrTop"/>
        <xsl:param name="pr.bdrLeft"/>
        <xsl:param name="pr.bdrBottom"/>
        <xsl:param name="pr.bdrRight"/>
        <xsl:param name="pr.bdrBetween"/>
        <xsl:param name="pr.bdrBar"/>
        <xsl:param name="ns.content"/>
        <xsl:param name="i.bdrRange.start"/>
        <xsl:param name="i.bdrRange.end"/>
        <xsl:param name="prsPAccum"/>
        <xsl:param name="prsP"/>
        <xsl:param name="prsR"/>
        <xsl:choose>

            <xsl:when test="$framePr = ''">
                <xsl:call-template name="wrapPBdr">
                    <xsl:with-param name="ns.content" select="$ns.content"/>
                    <xsl:with-param name="i.bdrRange.start" select="$i.bdrRange.start"/>
                    <xsl:with-param name="i.bdrRange.end" select="$i.bdrRange.end"/>
                    <xsl:with-param name="pr.bdrTop" select="$pr.bdrTop"/>
                    <xsl:with-param name="pr.bdrLeft" select="$pr.bdrLeft"/>
                    <xsl:with-param name="pr.bdrBottom" select="$pr.bdrBottom"/>
                    <xsl:with-param name="pr.bdrRight" select="$pr.bdrRight"/>
                    <xsl:with-param name="pr.bdrBetween" select="$pr.bdrBetween"/>
                    <xsl:with-param name="pr.bdrBar" select="$pr.bdrBar"/>
                    <xsl:with-param name="prsPAccum" select="$prsPAccum"/>
                    <xsl:with-param name="prsP" select="$prsP"/>
                    <xsl:with-param name="prsR" select="$prsR"/>
                </xsl:call-template>
            </xsl:when>

            <xsl:otherwise>
                <xsl:variable name="width" select="substring-before($framePr,$sep2)"/>
                <xsl:variable name="framePr1" select="substring-after($framePr,$sep2)"/>
                <xsl:variable name="height" select="substring-before($framePr1,$sep2)"/>
                <xsl:variable name="framePr2" select="substring-after($framePr1,$sep2)"/>
                <xsl:variable name="hrule" select="substring-before($framePr2,$sep2)"/>
                <xsl:variable name="framePr3" select="substring-after($framePr2,$sep2)"/>
                <xsl:variable name="xalign" select="substring-before($framePr3,$sep2)"/>
                <xsl:variable name="framePr4" select="substring-after($framePr3,$sep2)"/>
                <xsl:variable name="vspace" select="substring-before($framePr4,$sep2)"/>
                <xsl:variable name="framePr5" select="substring-after($framePr4,$sep2)"/>
                <xsl:variable name="hspace" select="substring-before($framePr5,$sep2)"/>
                <xsl:variable name="framePr6" select="substring-after($framePr5,$sep2)"/>
                <xsl:variable name="wrap" select="substring-before($framePr6,$sep2)"/>

                <table cellspacing="0" cellpadding="0" hspace="0" vspace="0">
                    <xsl:if test="not($width = '' and $height='')">
                        <xsl:attribute name="style">
                            <xsl:if test="not($width = '')">
                                width:<xsl:value-of select="$width div 20"/>pt;
                            </xsl:if>
                            <xsl:if test="not($height = '')">
                                height:<xsl:value-of select="$height div 20"/>pt;
                            </xsl:if>
                        </xsl:attribute>
                    </xsl:if>
                    <xsl:attribute name="align">
                        <xsl:choose>
                            <xsl:when test="$xalign = 'right' or $xalign = 'outside'">right</xsl:when>
                            <xsl:otherwise>left</xsl:otherwise>
                        </xsl:choose>
                    </xsl:attribute>
                    <tr>
                        <td valign="top" align="left">
                            <xsl:attribute name="style">
                                <xsl:text>padding:</xsl:text>
                                <xsl:choose>
                                    <xsl:when test="$vspace = ''">0</xsl:when>
                                    <xsl:otherwise>
                                        <xsl:value-of select="$vspace div 20"/>pt
                                    </xsl:otherwise>
                                </xsl:choose>
                                <xsl:text> </xsl:text>
                                <xsl:choose>
                                    <xsl:when test="$hspace = ''">0</xsl:when>
                                    <xsl:otherwise>
                                        <xsl:value-of select="$hspace div 20"/>pt
                                    </xsl:otherwise>
                                </xsl:choose>
                                <xsl:text>;</xsl:text>
                            </xsl:attribute>

                            <xsl:call-template name="wrapPBdr">
                                <xsl:with-param name="ns.content" select="$ns.content"/>
                                <xsl:with-param name="i.bdrRange.start" select="$i.bdrRange.start"/>
                                <xsl:with-param name="i.bdrRange.end" select="$i.bdrRange.end"/>
                                <xsl:with-param name="pr.bdrTop" select="$pr.bdrTop"/>
                                <xsl:with-param name="pr.bdrLeft" select="$pr.bdrLeft"/>
                                <xsl:with-param name="pr.bdrBottom" select="$pr.bdrBottom"/>
                                <xsl:with-param name="pr.bdrRight" select="$pr.bdrRight"/>
                                <xsl:with-param name="pr.bdrBetween" select="$pr.bdrBetween"/>
                                <xsl:with-param name="pr.bdrBar" select="$pr.bdrBar"/>
                                <xsl:with-param name="prsPAccum" select="$prsPAccum"/>
                                <xsl:with-param name="prsP" select="$prsP"/>
                                <xsl:with-param name="prsR" select="$prsR"/>
                            </xsl:call-template>
                        </td>
                    </tr>
                </table>
                <xsl:if test="$wrap = '' or $wrap = 'none' or $wrap = 'not-beside'">
                    <br clear="all"/>
                </xsl:if>
            </xsl:otherwise>
        </xsl:choose>
    </xsl:template>

    <xsl:template name="wrapPBdr">
        <xsl:param name="pr.bdrTop"/>
        <xsl:param name="pr.bdrLeft"/>
        <xsl:param name="pr.bdrBottom"/>
        <xsl:param name="pr.bdrRight"/>
        <xsl:param name="pr.bdrBetween"/>
        <xsl:param name="pr.bdrBar"/>
        <xsl:param name="ns.content"/>
        <xsl:param name="i.bdrRange.start"/>
        <xsl:param name="i.bdrRange.end"/>
        <xsl:param name="prsPAccum"/>
        <xsl:param name="prsP"/>
        <xsl:param name="prsR"/>
        <xsl:choose>

            <xsl:when
                    test="$pr.bdrTop = '' and $pr.bdrLeft = '' and $pr.bdrBottom = '' and $pr.bdrRight = '' and $pr.bdrBar = ''">
                <xsl:apply-templates
                        select="($ns.content)[position() &gt;= $i.bdrRange.start and position() &lt; $i.bdrRange.end]">
                    <xsl:with-param name="prsPAccum" select="$prsPAccum"/>
                    <xsl:with-param name="prsP" select="$prsP"/>
                    <xsl:with-param name="prsR" select="$prsR"/>
                    <xsl:with-param name="pr.bdrBetween" select="$pr.bdrBetween"/>
                </xsl:apply-templates>
            </xsl:when>

            <xsl:otherwise>
                <div>

                    <xsl:attribute name="style">
                        <xsl:call-template name="ApplyBorderPr">
                            <xsl:with-param name="pr.bdr" select="$pr.bdrBar"/>
                            <xsl:with-param name="bdrSide" select="$bdrSide_left"/>
                        </xsl:call-template>
                        <xsl:call-template name="ApplyBorderPr">
                            <xsl:with-param name="pr.bdr" select="$pr.bdrTop"/>
                            <xsl:with-param name="bdrSide" select="$bdrSide_top"/>
                        </xsl:call-template>
                        <xsl:call-template name="ApplyBorderPr">
                            <xsl:with-param name="pr.bdr" select="$pr.bdrLeft"/>
                            <xsl:with-param name="bdrSide" select="$bdrSide_left"/>
                        </xsl:call-template>
                        <xsl:call-template name="ApplyBorderPr">
                            <xsl:with-param name="pr.bdr" select="$pr.bdrBottom"/>
                            <xsl:with-param name="bdrSide" select="$bdrSide_bottom"/>
                        </xsl:call-template>
                        <xsl:call-template name="ApplyBorderPr">
                            <xsl:with-param name="pr.bdr" select="$pr.bdrRight"/>
                            <xsl:with-param name="bdrSide" select="$bdrSide_right"/>
                        </xsl:call-template>
                        <xsl:text>padding:</xsl:text>
                        <xsl:variable name="topPad"
                                      select="substring-before(substring-after(substring-after(substring-after($pr.bdrTop,$sep2),$sep2),$sep2),$sep2)"/>
                        <xsl:variable name="rightPad"
                                      select="substring-before(substring-after(substring-after(substring-after($pr.bdrRight,$sep2),$sep2),$sep2),$sep2)"/>
                        <xsl:variable name="bottomPad"
                                      select="substring-before(substring-after(substring-after(substring-after($pr.bdrBottom,$sep2),$sep2),$sep2),$sep2)"/>
                        <xsl:variable name="leftPad"
                                      select="substring-before(substring-after(substring-after(substring-after($pr.bdrLeft,$sep2),$sep2),$sep2),$sep2)"/>
                        <xsl:choose>
                            <xsl:when test="$topPad = ''">0</xsl:when>
                            <xsl:otherwise>
                                <xsl:value-of select="$topPad"/>pt
                            </xsl:otherwise>
                        </xsl:choose>
                        <xsl:text> </xsl:text>
                        <xsl:choose>
                            <xsl:when test="$rightPad = ''">0</xsl:when>
                            <xsl:otherwise>
                                <xsl:value-of select="$rightPad"/>pt
                            </xsl:otherwise>
                        </xsl:choose>
                        <xsl:text> </xsl:text>
                        <xsl:choose>
                            <xsl:when test="$bottomPad = ''">0</xsl:when>
                            <xsl:otherwise>
                                <xsl:value-of select="$bottomPad"/>pt
                            </xsl:otherwise>
                        </xsl:choose>
                        <xsl:text> </xsl:text>
                        <xsl:choose>
                            <xsl:when test="$leftPad = ''">0</xsl:when>
                            <xsl:otherwise>
                                <xsl:value-of select="$leftPad"/>pt
                            </xsl:otherwise>
                        </xsl:choose>
                        <xsl:text>;</xsl:text>
                    </xsl:attribute>

                    <xsl:apply-templates
                            select="($ns.content)[position() &gt;= $i.bdrRange.start and position() &lt; $i.bdrRange.end]">
                        <xsl:with-param name="prsPAccum" select="$prsPAccum"/>
                        <xsl:with-param name="prsP" select="$prsP"/>
                        <xsl:with-param name="prsR" select="$prsR"/>
                        <xsl:with-param name="pr.bdrBetween" select="$pr.bdrBetween"/>
                    </xsl:apply-templates>
                </div>
            </xsl:otherwise>
        </xsl:choose>
    </xsl:template>

    <xsl:template name="ApplyArgs">
        <xsl:param name="value"/>
        <xsl:variable name="attributeName" select="normalize-space(substring-before($value,'='))"/>
        <xsl:variable name="afterName" select="concat(substring-after($value,'='),' ')"/>
        <xsl:if test="not($attributeName = '')">
            <xsl:attribute name="{$attributeName}">
                <xsl:value-of select="normalize-space(translate(substring-before($afterName,' '),'&quot;',' '))"/>
            </xsl:attribute>
            <xsl:call-template name="ApplyArgs">
                <xsl:with-param name="value" select="normalize-space(substring-after($afterName,' '))"/>
            </xsl:call-template>
        </xsl:if>
    </xsl:template>

    <xsl:template match="w:scriptAnchor">
        <script>
            <xsl:apply-templates select="*" mode="scriptAnchor"/>
        </script>
    </xsl:template>
    <xsl:template match="w:args" mode="scriptAnchor">
        <xsl:call-template name="ApplyArgs">
            <xsl:with-param name="value" select="."/>
        </xsl:call-template>
    </xsl:template>
    <xsl:template match="w:language" mode="scriptAnchor">
        <xsl:attribute name="language">
            <xsl:value-of select="."/>
        </xsl:attribute>
    </xsl:template>
    <xsl:template match="w:scriptId" mode="scriptAnchor">
        <xsl:attribute name="id">
            <xsl:value-of select="."/>
        </xsl:attribute>
    </xsl:template>
    <xsl:template match="w:scriptText" mode="scriptAnchor">
        <xsl:value-of disable-output-escaping="yes" select="."/>
    </xsl:template>
    <xsl:template match="*" mode="scriptAnchor"/>

    <xsl:template match="w:applet">
        <applet>
            <xsl:apply-templates select="*" mode="applet"/>
        </applet>
    </xsl:template>
    <xsl:template match="w:appletText" mode="applet">
        <xsl:value-of disable-output-escaping="yes" select="."/>
    </xsl:template>
    <xsl:template match="w:args" mode="applet">
        <xsl:call-template name="ApplyArgs">
            <xsl:with-param name="value" select="."/>
        </xsl:call-template>
    </xsl:template>
    <xsl:template match="*" mode="applet"/>

    <xsl:template match="w:txbxContent">
        <xsl:call-template name="DisplayBodyContent">
            <xsl:with-param name="ns.content" select="*"/>
        </xsl:call-template>
    </xsl:template>

    <xsl:template match="WX:pBdrGroup">
        <xsl:variable name="dxaLeft" select="WX:margin-left/@WX:val"/>
        <xsl:variable name="dxaRight" select="WX:margin-right/@WX:val"/>
        <xsl:variable name="ns.borders" select="WX:borders"/>

        <xsl:variable name="bdrStyles">
            <xsl:if test="$ns.borders/WX:top">
                <xsl:text>border-top:</xsl:text>
                <xsl:value-of select="$ns.borders/WX:top/@WX:val"/>
                <xsl:text> </xsl:text>
                <xsl:value-of select="$ns.borders/WX:top/@WX:bdrwidth div 20"/>
                <xsl:text>pt </xsl:text>
                <xsl:call-template name="ConvHexColor">
                    <xsl:with-param name="value" select="$ns.borders/WX:top/@WX:color"/>
                </xsl:call-template>
                <xsl:text>;padding-top:</xsl:text>
                <xsl:value-of select="$ns.borders/WX:top/@WX:space"/>
                <xsl:text>pt</xsl:text>
            </xsl:if>
            <xsl:if test="$ns.borders/WX:bottom">
                <xsl:text>;border-bottom:</xsl:text>
                <xsl:value-of select="$ns.borders/WX:bottom/@WX:val"/>
                <xsl:text> </xsl:text>
                <xsl:value-of select="$ns.borders/WX:bottom/@WX:bdrwidth div 20"/>
                <xsl:text>pt </xsl:text>
                <xsl:call-template name="ConvHexColor">
                    <xsl:with-param name="value" select="$ns.borders/WX:bottom/@WX:color"/>
                </xsl:call-template>
                <xsl:text>;padding-bottom:</xsl:text>
                <xsl:value-of select="$ns.borders/WX:bottom/@WX:space"/>
                <xsl:text>pt</xsl:text>
            </xsl:if>
            <xsl:if test="$ns.borders/WX:right">
                <xsl:text>;border-right:</xsl:text>
                <xsl:value-of select="$ns.borders/WX:right/@WX:val"/>
                <xsl:text> </xsl:text>
                <xsl:value-of select="$ns.borders/WX:right/@WX:bdrwidth div 20"/>
                <xsl:text>pt </xsl:text>
                <xsl:call-template name="ConvHexColor">
                    <xsl:with-param name="value" select="$ns.borders/WX:right/@WX:color"/>
                </xsl:call-template>
                <xsl:text>;padding-right:</xsl:text>
                <xsl:value-of select="$ns.borders/WX:right/@WX:space"/>
                <xsl:text>pt</xsl:text>
            </xsl:if>
            <xsl:if test="$ns.borders/WX:left">
                <xsl:text>;border-left:</xsl:text>
                <xsl:value-of select="$ns.borders/WX:left/@WX:val"/>
                <xsl:text> </xsl:text>
                <xsl:value-of select="$ns.borders/WX:left/@WX:bdrwidth div 20"/>
                <xsl:text>pt </xsl:text>
                <xsl:call-template name="ConvHexColor">
                    <xsl:with-param name="value" select="$ns.borders/WX:left/@WX:color"/>
                </xsl:call-template>
                <xsl:text>;padding-left:</xsl:text>
                <xsl:value-of select="$ns.borders/WX:left/@WX:space"/>
                <xsl:text>pt</xsl:text>
            </xsl:if>
            <xsl:if test="$dxaLeft">
                <xsl:text>;margin-left:</xsl:text>
                <xsl:value-of select="$dxaLeft div 20"/>
                <xsl:text>pt</xsl:text>
            </xsl:if>
            <xsl:if test="$dxaRight">
                <xsl:text>;margin-right:</xsl:text>
                <xsl:value-of select="$dxaRight div 20"/>
                <xsl:text>pt</xsl:text>
            </xsl:if>
            <xsl:if test="WX:shd">
                <xsl:text>;background-color:</xsl:text>
                <xsl:call-template name="ConvHexColor">
                    <xsl:with-param name="value" select="WX:shd/@WX:bgcolor"/>
                    <xsl:with-param name="autoColor" select="$autoColor_bg"/>
                    <xsl:with-param name="transparentColor">transparent</xsl:with-param>
                </xsl:call-template>
            </xsl:if>
        </xsl:variable>

        <xsl:choose>
            <xsl:when test="WX:apo">
                <table cellspacing="0" cellpadding="0" hspace="0" vspace="0">
                    <xsl:choose>
                        <xsl:when test="WX:apo/WX:jc/@WX:val">
                            <xsl:attribute name="align">
                                <xsl:value-of select="WX:apo/WX:jc/@WX:val"/>
                            </xsl:attribute>
                        </xsl:when>
                        <xsl:otherwise>
                            <xsl:attribute name="align">
                                <xsl:text>left</xsl:text>
                            </xsl:attribute>
                        </xsl:otherwise>
                    </xsl:choose>
                    <xsl:attribute name="style">
                        <xsl:if test="WX:apo/WX:width/@WX:val">
                            <xsl:text>;width:</xsl:text>
                            <xsl:value-of select="WX:apo/WX:width/@WX:val div 20"/>
                            <xsl:text>pt</xsl:text>
                        </xsl:if>
                        <xsl:if test="WX:apo/WX:height/@WX:val">
                            <xsl:text>;height:</xsl:text>
                            <xsl:value-of select="WX:apo/WX:height/@WX:val div 20"/>
                            <xsl:text>pt</xsl:text>
                        </xsl:if>
                    </xsl:attribute>
                    <tr>
                        <td valign="top" align="left">
                            <xsl:attribute name="style">
                                <xsl:if test="WX:apo/WX:vertFromText/@WX:val">
                                    <xsl:text>;padding-top:</xsl:text>
                                    <xsl:value-of select="WX:apo/WX:vertFromText/@WX:val div 20"/>
                                    <xsl:text>pt</xsl:text>
                                    <xsl:text>;padding-bottom:</xsl:text>
                                    <xsl:value-of select="WX:apo/WX:vertFromText/@WX:val div 20"/>
                                    <xsl:text>pt</xsl:text>
                                </xsl:if>
                                <xsl:if test="WX:apo/WX:horizFromText/@WX:val">
                                    <xsl:text>;padding-right:</xsl:text>
                                    <xsl:value-of select="WX:apo/WX:horizFromText/@WX:val div 20"/>
                                    <xsl:text>pt</xsl:text>
                                    <xsl:text>;padding-left:</xsl:text>
                                    <xsl:value-of select="WX:apo/WX:horizFromText/@WX:val div 20"/>
                                    <xsl:text>pt</xsl:text>
                                </xsl:if>
                            </xsl:attribute>
                            <div>
                                <xsl:attribute name="style">
                                    <xsl:value-of select="$bdrStyles"/>
                                </xsl:attribute>

                                <div>
                                    <xsl:attribute name="style">
                                        <xsl:if test="$dxaLeft">
                                            <xsl:text>;margin-left:-</xsl:text>
                                            <xsl:value-of select="$dxaLeft div 20"/>
                                            <xsl:text>pt</xsl:text>
                                        </xsl:if>
                                        <xsl:if test="$dxaRight">
                                            <xsl:text>;margin-right:-</xsl:text>
                                            <xsl:value-of select="$dxaRight div 20"/>
                                            <xsl:text>pt</xsl:text>
                                        </xsl:if>
                                    </xsl:attribute>
                                    <xsl:call-template name="DisplayBodyContent">
                                        <xsl:with-param name="ns.content" select="*"/>
                                    </xsl:call-template>
                                </div>
                            </div>
                        </td>
                    </tr>
                </table>
            </xsl:when>
            <xsl:otherwise>
                <div>
                    <xsl:attribute name="style">
                        <xsl:value-of select="$bdrStyles"/>
                    </xsl:attribute>

                    <div>
                        <xsl:attribute name="style">
                            <xsl:if test="$dxaLeft">
                                <xsl:text>;margin-left:-</xsl:text>
                                <xsl:value-of select="$dxaLeft div 20"/>
                                <xsl:text>pt</xsl:text>
                            </xsl:if>
                            <xsl:if test="$dxaRight">
                                <xsl:text>;margin-right:-</xsl:text>
                                <xsl:value-of select="$dxaRight div 20"/>
                                <xsl:text>pt</xsl:text>
                            </xsl:if>
                        </xsl:attribute>

                        <xsl:call-template name="DisplayBodyContent">
                            <xsl:with-param name="ns.content" select="*"/>
                        </xsl:call-template>
                    </div>
                </div>
            </xsl:otherwise>
        </xsl:choose>
    </xsl:template>

    <!-- by sunil for positioning-->
    <xsl:template match="svg">
        <xsl:apply-templates select="*"/>
        <div>
            <xsl:attribute name="style">
                <xsl:text> padding-bottom:5px;</xsl:text>
            </xsl:attribute>
        </div>
    </xsl:template>
    <!--<xsl:template match="br">
    <br></br>
  </xsl:template>-->
    <xsl:template match="w:br">
        <br>
            <xsl:attribute name="clear">
                <xsl:choose>
                    <xsl:when test="@w:clear">
                        <xsl:value-of select="@w:clear"/>
                    </xsl:when>
                    <xsl:otherwise>all</xsl:otherwise>
                </xsl:choose>
            </xsl:attribute>
            <xsl:if test="@w:type = 'page'">
                <xsl:attribute name="style">page-break-before:always</xsl:attribute>
            </xsl:if>
        </br>
    </xsl:template>

    <xsl:template match="w:instrText">
    </xsl:template>

    <xsl:template match="w:delText">
        <xsl:if test="/w:document/w:settings/w:trackRevisions">
            <del>
                <xsl:value-of select="."/>
            </del>
        </xsl:if>
    </xsl:template>

    <xsl:template match="w:r//w:t[../w:rPr/WX:sym]">
        <xsl:variable name="p.SymHint" select="../w:rPr/WX:sym"/>

        <span>
            <xsl:attribute name="style">
                font-family:<xsl:value-of select="$p.SymHint/@WX:font"/>
            </xsl:attribute>
            <xsl:choose>
                <xsl:when test="starts-with($p.SymHint/@WX:char, 'F0')">
                    <xsl:text disable-output-escaping="yes">&amp;</xsl:text>#x<xsl:value-of
                        select="substring-after($p.SymHint/@WX:char, 'F0')"/><xsl:text>;</xsl:text>
                </xsl:when>
                <xsl:when test="starts-with($p.SymHint/@WX:char, 'f0')">
                    <xsl:text disable-output-escaping="yes">&amp;</xsl:text>#x<xsl:value-of
                        select="substring-after($p.SymHint/@WX:char, 'f0')"/><xsl:text>;</xsl:text>
                </xsl:when>
                <xsl:otherwise>
                    <xsl:text disable-output-escaping="yes">&amp;</xsl:text>#x<xsl:value-of
                        select="$p.SymHint/@WX:char"/><xsl:text>;</xsl:text>
                </xsl:otherwise>
            </xsl:choose>
        </span>

    </xsl:template>

    <xsl:template match="w:pict">
        <span>
            <xsl:value-of select="."/>
        </span>

        <br/>

    </xsl:template>

    <xsl:template match="w:t">
        <xsl:value-of select="."/>
    </xsl:template>

    <xsl:template match="w:sym">
        <span>
            <xsl:attribute name="style">
                font-family:<xsl:value-of select="@w:font"/>
            </xsl:attribute>
            <xsl:choose>
                <xsl:when test="starts-with(@w:char, 'F0')">
                    <xsl:text disable-output-escaping="yes">&amp;</xsl:text>#x<xsl:value-of
                        select="substring-after(@w:char, 'F0')"/><xsl:text>;</xsl:text>
                </xsl:when>
                <xsl:when test="starts-with(@w:char, 'f0')">
                    <xsl:text disable-output-escaping="yes">&amp;</xsl:text>#x<xsl:value-of
                        select="substring-after(@w:char, 'f0')"/><xsl:text>;</xsl:text>
                </xsl:when>
                <xsl:otherwise>
                    <xsl:text disable-output-escaping="yes">&amp;</xsl:text>#x<xsl:value-of select="@w:char"/><xsl:text>;</xsl:text>
                </xsl:otherwise>
            </xsl:choose>
        </span>
    </xsl:template>

    <xsl:template name="OutputTlcChar">
        <xsl:param name="count" select="0"/>
        <xsl:param name="tlc" select="' '"/>
        <xsl:value-of select="$tlc"/>
        <xsl:if test="$count > 1">
            <xsl:call-template name="OutputTlcChar">
                <xsl:with-param name="count" select="$count - 1"/>
                <xsl:with-param name="tlc" select="$tlc"/>
            </xsl:call-template>
        </xsl:if>
    </xsl:template>

    <xsl:template match="w:tab">
        <!-- Parwati:Commented to fix tab indentation.
    <xsl:call-template name="OutputTlcChar">
      <xsl:with-param name="tlc">
        <xsl:text disable-output-escaping="yes">&#160;</xsl:text>
      </xsl:with-param>
      <xsl:with-param name="count" select="12"/>
      </xsl:call-template>-->
        <!--by default tab value will be 5 inch-->
        <span>
            <xsl:attribute name="style">
                <xsl:choose>
                    <xsl:when test="./@w:pos">
                        <xsl:choose>
                            <xsl:when test="./@w:pos and ./@w:val = 'left'">
                                margin-left:
                                <xsl:choose>
                                    <xsl:when test="@w:pos &lt; 0">
                                        <xsl:value-of select="@w:pos div -20"/>pt;
                                    </xsl:when>
                                    <xsl:otherwise>
                                        <xsl:value-of select="@w:pos div 20"/>pt;
                                    </xsl:otherwise>
                                </xsl:choose>
                            </xsl:when>
                            <xsl:when test="./@w:pos and ./@w:val = 'right'">
                                <xsl:choose>
                                    <xsl:when test="@w:pos &lt; 0">
                                        <xsl:value-of select="@w:pos div -20"/>pt;
                                    </xsl:when>
                                    <xsl:otherwise>
                                        <xsl:value-of select="@w:pos div 20"/>pt;
                                    </xsl:otherwise>
                                </xsl:choose>
                            </xsl:when>
                        </xsl:choose>
                    </xsl:when>
                    <xsl:otherwise>
                        margin-left:26pt
                    </xsl:otherwise>
                </xsl:choose>
            </xsl:attribute>
        </span>
    </xsl:template>
    <!-- Parwati modified to correct tab indentation-->
    <xsl:template match="w:softHyphen">
        <xsl:text>&#xAD;</xsl:text>
    </xsl:template>

    <xsl:template match="w:noBreakHyphen">
        <xsl:text disable-output-escaping="yes">&amp;#8209;</xsl:text>
    </xsl:template>

    <xsl:template name="DisplayRContent">
        <xsl:choose>

            <xsl:when test="w:numPr">

                <xsl:choose>
                    <xsl:when test="w:numPr[1]/w:ilvl/@isBullet">
                        <xsl:text disable-output-escaping="yes">&amp;#8226;&amp;#160;</xsl:text>
                    </xsl:when>
                    <xsl:when test="w:numPr[1]/w:ilvl/@numFont">
                        <span>
                            <xsl:attribute name="style">
                                font-family:<xsl:value-of select="w:numPr[1]/w:ilvl/@numFont"/>
                            </xsl:attribute>
                            <xsl:value-of select="w:numPr[1]/w:ilvl/@numString"/>
                        </span>
                    </xsl:when>
                    <xsl:otherwise>
                        <xsl:value-of select="w:numPr[1]/w:ilvl/@numString"/>
                    </xsl:otherwise>
                </xsl:choose>

                <xsl:if test="w:numPr[1]/WX:t/@WX:wTabAfter">
                    <span>
                        <xsl:attribute name="style">
                            <xsl:text>padding-left:</xsl:text>
                            <xsl:value-of select="(w:numPr[1]/WX:t/@WX:wTabAfter div 20)"/>
                            <xsl:text>pt;</xsl:text>
                        </xsl:attribute>
                    </span>
                </xsl:if>
            </xsl:when>

            <xsl:otherwise>
                <xsl:apply-templates select="*"/>
            </xsl:otherwise>
        </xsl:choose>
    </xsl:template>

    <xsl:template name="ApplyRPr.once">
        <xsl:param name="rStyleId"/>
        <xsl:param name="b.bidi"/>
        <xsl:param name="prsR"/>

        <xsl:variable name="b.complexScript">
            <xsl:choose>
                <xsl:when test="w:rPr[1]/w:cs[1] or w:rPr[1]/w:rtl[1]">
                    <xsl:value-of select="$on"/>
                </xsl:when>
                <xsl:otherwise>
                    <xsl:value-of select="$off"/>
                </xsl:otherwise>
            </xsl:choose>
        </xsl:variable>
        <xsl:if test="$b.complexScript = $on">
            <xsl:variable name="suffix.complexScript">-CS</xsl:variable>
            <xsl:variable name="b.font-weight" select="substring($prsR,$iBCs,1)"/>
            <xsl:variable name="b.font-style" select="substring($prsR,$iICs,1)"/>
            <xsl:variable name="pr.sz" select="substring($prsR,$ISzCs)"/>

            <xsl:choose>
                <xsl:when test="$b.font-style = $on">font-style:italic;</xsl:when>
                <xsl:otherwise>font-style:normal;</xsl:otherwise>
            </xsl:choose>

            <xsl:choose>
                <xsl:when test="$b.font-weight = $on">font-weight:bold;</xsl:when>
                <xsl:otherwise>font-weight:normal;</xsl:otherwise>
            </xsl:choose>

            <xsl:choose>
                <xsl:when test="$pr.sz = ''">font-size:12pt;</xsl:when>
                <xsl:otherwise>
                    font-size:<xsl:value-of select="$pr.sz div 2"/>pt;
                </xsl:otherwise>
            </xsl:choose>
        </xsl:if>

        <xsl:if test="not($b.bidi = '')">
            <xsl:choose>
                <xsl:when test="$b.bidi = $on and not($b.complexScript = $on)">direction:ltr;</xsl:when>
                <xsl:when test="not($b.bidi = $on) and $b.complexScript = $on">direction:rtl;</xsl:when>
            </xsl:choose>
        </xsl:if>

        <xsl:if test="substring($prsR,$iEmbossImprint,1) = $on">color:gray;</xsl:if>

        <xsl:variable name="b.line-through" select="substring($prsR,$iStrikeDStrike,1)"/>
        <xsl:variable name="b.underline" select="substring($prsR,$iU_Em,1)"/>
        <xsl:choose>
            <xsl:when test="$b.line-through = $off and $b.underline = $off">text-decoration:none;</xsl:when>
            <xsl:when test="$b.line-through = $on and $b.underline = $on">text-decoration:line-through underline;
            </xsl:when>
            <xsl:when test="$b.line-through = $on">text-decoration: line-through;</xsl:when>
            <xsl:when test="$b.underline = $on">text-decoration: underline;</xsl:when>
        </xsl:choose>

        <xsl:variable name="fSup" select="substring($prsR,$iSup,1)"/>
        <xsl:variable name="fSub" select="substring($prsR,$iSub,1)"/>
        <xsl:choose>
            <xsl:when test="$fSup = $on and $fSub = $on">vertical-align:baseline;</xsl:when>
            <xsl:when test="$fSub = $on">vertical-align:sub;</xsl:when>
            <xsl:when test="$fSup = $on">vertical-align:super;</xsl:when>
        </xsl:choose>

        <xsl:if test="not($rStyleId='CommentReference')">
            <xsl:if test="substring($prsR,$iVanishWebHidden,1) = $on">display:none;</xsl:if>
        </xsl:if>
    </xsl:template>

    <xsl:template name="RecursiveApplyRPr.class">
        <xsl:if test="w:basedOn">
            <xsl:variable name="baseStyleName" select="w:basedOn[1]/@w:val"/>
            <xsl:variable name="sParaStyleBase" select="($nsStyles[@w:styleId=$baseStyleName])[1]"/>
            <xsl:for-each select="$sParaStyleBase">
                <xsl:call-template name="RecursiveApplyRPr.class"/>
            </xsl:for-each>
        </xsl:if>

        <xsl:call-template name="ApplyRPr.class"/>
    </xsl:template>

    <xsl:template name="ApplyRPr.class">
        <xsl:for-each select="w:rPr[1]">

            <xsl:choose>
                <xsl:when test="w:highlight">
                    background-color:
                    <xsl:call-template name="ConvColor">
                        <xsl:with-param name="value" select="w:hightlight[1]/@w:val"/>
                    </xsl:call-template>
                    <xsl:value-of select="value"/>;
                </xsl:when>
                <xsl:otherwise>
                    <xsl:for-each select="w:shd[1]">
                        <xsl:call-template name="ApplyShd"/>
                    </xsl:for-each>
                </xsl:otherwise>
            </xsl:choose>

            <xsl:apply-templates select="*" mode="rpr"/>
        </xsl:for-each>
    </xsl:template>

    <xsl:template match="w:highlight" mode="rpr">
        background:
        <xsl:call-template name="ConvColor">
            <xsl:with-param name="value" select="@w:val"/>
        </xsl:call-template>
        <xsl:value-of select="value"/>;
    </xsl:template>

    <xsl:template match="w:color" mode="rpr">
        color:
        <xsl:call-template name="ConvHexColor">
            <xsl:with-param name="value" select="@w:val"/>
        </xsl:call-template>
        ;
    </xsl:template>

    <xsl:template match="w:rFonts" mode="rpr">
        font-family:<xsl:value-of select="@w:ascii"/>;
    </xsl:template>

    <xsl:template match="w:smallCaps" mode="rpr">
        <xsl:choose>
            <xsl:when test="@w:val = 'off'">font-variant:normal;</xsl:when>
            <xsl:otherwise>font-variant:small-caps;</xsl:otherwise>
        </xsl:choose>
    </xsl:template>

    <xsl:template match="w:eastAsianLayout" mode="rpr">
        <xsl:choose>
            <xsl:when test="@w:vert = 'on'">layout-flow:horizontal;</xsl:when>
            <xsl:when test="@w:vert-compress = 'on'">layout-flow:horizontal;</xsl:when>
            <xsl:when test="@w:vert = 'off' or @w:vert-compress = 'off'">layout-flow:normal;</xsl:when>
        </xsl:choose>
        <xsl:if test="@w:combine = 'lines'">text-combine:lines;</xsl:if>
    </xsl:template>

    <xsl:template match="w:spacing" mode="rpr">
        letter-spacing:<xsl:value-of select="@w:val div 20"/>pt;
    </xsl:template>

    <xsl:template match="w:position" mode="rpr">
        <xsl:variable name="fDropCap">
            <xsl:value-of select="ancestor::w:p[1]/w:pPr/w:framePr/@w:drop-cap"/>
        </xsl:variable>
        <xsl:if test="$fDropCap=''">
            <xsl:text>position:relative;top:</xsl:text>
            <xsl:value-of select="@w:val div -2"/>
            <xsl:text>pt;</xsl:text>
        </xsl:if>
    </xsl:template>
    <xsl:template match="w:fitText" mode="rpr">
        text-fit:<xsl:value-of select="@w:val div 20"/>pt;
    </xsl:template>
    <xsl:template match="w:shadow" mode="rpr">
        <xsl:choose>
            <xsl:when test="@w:val = 'off'">text-shadow:none;</xsl:when>
            <xsl:otherwise>text-shadow:0.2em 0.2em;</xsl:otherwise>
        </xsl:choose>
    </xsl:template>

    <xsl:template match="w:caps" mode="rpr">
        <xsl:choose>
            <xsl:when test="@w:val = 'off'">text-transform:none;</xsl:when>
            <xsl:otherwise>text-transform:uppercase;</xsl:otherwise>
        </xsl:choose>
    </xsl:template>

    <xsl:template match="w:sz" mode="rpr">
        font-size:<xsl:value-of select="@w:val div 2"/>pt;
    </xsl:template>

    <xsl:template match="w:b" mode="rpr">
        <xsl:choose>
            <xsl:when test="@w:val = 'off'">font-weight:normal;</xsl:when>
            <xsl:otherwise>font-weight:bold;</xsl:otherwise>
        </xsl:choose>
    </xsl:template>

    <xsl:template match="w:i" mode="rpr">
        <xsl:choose>
            <xsl:when test="@w:val = 'off'">font-style:normal;</xsl:when>
            <xsl:otherwise>font-style:italic;</xsl:otherwise>
        </xsl:choose>
    </xsl:template>

    <xsl:template match="*" mode="rpr"/>

    <xsl:template name="RecursivePrsUpdateRPr">
        <xsl:param name="prsR"/>
        <xsl:param name="rStyleId"/>

        <xsl:variable name="myStyle" select="($nsStyles[@w:styleId=$rStyleId])[1]"/>

        <xsl:variable name="prsR.updated">
            <xsl:choose>
                <xsl:when test="$myStyle/w:basedOn">
                    <xsl:call-template name="RecursivePrsUpdateRPr">
                        <xsl:with-param name="prsR" select="$prsR"/>
                        <xsl:with-param name="rStyleId" select="$myStyle/w:basedOn/@w:val"/>
                    </xsl:call-template>
                </xsl:when>
                <xsl:otherwise>
                    <xsl:value-of select="$prsR"/>
                </xsl:otherwise>
            </xsl:choose>
        </xsl:variable>

        <xsl:call-template name="PrsUpdateRPr">
            <xsl:with-param name="ndPrContainer" select="$myStyle"/>
            <xsl:with-param name="prsR" select="$prsR.updated"/>
        </xsl:call-template>
    </xsl:template>

    <xsl:template name="PrsGetThemeStyle">
        <xsl:param name="prsR"/>
        <xsl:param name="runTextClass" select="$textClassAscii"/>

        <xsl:if test="not($runTextClass='')">
            <xsl:variable name="themeStyle">
                <xsl:choose>
                    <xsl:when test="$runTextClass=$textClassAscii">
                        <xsl:value-of select="substring($prsR,$iAsciiTheme,1)"/>
                    </xsl:when>
                    <xsl:when test="$runTextClass=$textClassAnsi">
                        <xsl:value-of select="substring($prsR,$iAnsiTheme,1)"/>
                    </xsl:when>
                    <xsl:when test="$runTextClass=$textClassEA">
                        <xsl:value-of select="substring($prsR,$iEATheme,1)"/>
                    </xsl:when>
                    <xsl:when test="$runTextClass=$textClassCS">
                        <xsl:value-of select="substring($prsR,$iCSTheme,1)"/>
                    </xsl:when>
                </xsl:choose>
            </xsl:variable>

            <xsl:choose>
                <xsl:when test="$themeStyle=$minorAscii">
                    <xsl:value-of select="$minorAsciiTheme"/>
                </xsl:when>
                <xsl:when test="$themeStyle=$majorAscii">
                    <xsl:value-of select="$majorAsciiTheme"/>
                </xsl:when>
                <xsl:when test="$themeStyle=$minorAnsi">
                    <xsl:value-of select="$minorAnsiTheme"/>
                </xsl:when>
                <xsl:when test="$themeStyle=$majorAnsi">
                    <xsl:value-of select="$majorAnsiTheme"/>
                </xsl:when>
                <xsl:when test="$themeStyle=$minorEA">
                    <xsl:value-of select="$minorEATheme"/>
                </xsl:when>
                <xsl:when test="$themeStyle=$majorEA">
                    <xsl:value-of select="$majorEATheme"/>
                </xsl:when>
                <xsl:when test="$themeStyle=$minorCS">
                    <xsl:value-of select="$minorCSTheme"/>
                </xsl:when>
                <xsl:when test="$themeStyle=$majorCS">
                    <xsl:value-of select="$majorCSTheme"/>
                </xsl:when>
            </xsl:choose>
        </xsl:if>
    </xsl:template>

    <xsl:template name="DisplayR">
        <xsl:param name="b.bidi"/>
        <xsl:param name="prsR"/>
        <xsl:param name="runStyleName"/>

        <xsl:variable name="rStyleId" select="string(w:rPr/w:rStyle/@w:val)"/>

        <xsl:variable name="prsR.updated">

            <xsl:variable name="prsR.updated1">
                <xsl:call-template name="RecursivePrsUpdateRPr">
                    <xsl:with-param name="rStyleId" select="$rStyleId"/>
                    <xsl:with-param name="prsR" select="$prsR"/>
                </xsl:call-template>
            </xsl:variable>

            <xsl:variable name="prsR.updated2">
                <xsl:call-template name="PrsUpdateRPr">
                    <xsl:with-param name="prsR" select="$prsR.updated1"/>
                </xsl:call-template>
            </xsl:variable>

            <xsl:variable name="prsRTemp3">
                <xsl:call-template name="PrsGetListPr">
                    <xsl:with-param name="type" select="$prrUpdateRPr"/>
                    <xsl:with-param name="prsR" select="$prsR.updated2"/>
                </xsl:call-template>
            </xsl:variable>
            <xsl:choose>
                <xsl:when test="$prsRTemp3=''">
                    <xsl:value-of select="$prsR.updated2"/>
                </xsl:when>
                <xsl:otherwise>
                    <xsl:value-of select="$prsRTemp3"/>
                </xsl:otherwise>
            </xsl:choose>
        </xsl:variable>

        <xsl:variable name="themeStyle">
            <xsl:call-template name="PrsGetThemeStyle">
                <xsl:with-param name="prsR" select="$prsR.updated"/>
                <xsl:with-param name="runTextClass" select="string(./@textClass)"/>
            </xsl:call-template>
        </xsl:variable>

        <xsl:variable name="pr.listSuff">
            <xsl:call-template name="PrsGetListPr">
                <xsl:with-param name="type" select="$prrListSuff"/>
            </xsl:call-template>
        </xsl:variable>
        <xsl:variable name="styleMod">
            <xsl:call-template name="ApplyRPr.class"/>

            <xsl:variable name="numId" select="w:numPr/w:numId/@w:val"/>
            <xsl:variable name="ilvl" select="w:numPr/w:ilvl/@w:val"/>
            <xsl:variable name="ilstDef" select="$ndLists/w:num[@w:numId=$numId]/w:abstractNumId/@w:val"/>
            <xsl:variable name="abstractNum" select="$ndLists/w:abstractNum[@w:abstractNumId=$ilstDef]"/>

            <xsl:variable name="isBullets">
                <xsl:for-each select="w:numPr[1]">
                    <xsl:call-template name="IsListBullet"/>
                </xsl:for-each>
            </xsl:variable>

            <xsl:if test="not($isBullets=$on)">
                <xsl:if test="$abstractNum/w:lvl[@w:ilvl=$ilvl]/w:rPr/w:rFonts/@w:ascii">
                    <xsl:apply-templates select="w:numPr[1]/WX:font[1]" mode="rpr"/>
                </xsl:if>

                <xsl:call-template name="PrsGetListPr">
                    <xsl:with-param name="type" select="$prrApplyRPr"/>
                </xsl:call-template>
                <xsl:call-template name="ApplyRPr.once">
                    <xsl:with-param name="rStyleId" select="$rStyleId"/>
                    <xsl:with-param name="b.bidi" select="$b.bidi"/>
                    <xsl:with-param name="prsR" select="$prsR.updated"/>
                </xsl:call-template>
            </xsl:if>

            <xsl:if test="$isBullets=$on or ancestor::w:rt">
                <xsl:text>font-style:normal;text-decoration:none;font-weight:normal;</xsl:text>
            </xsl:if>
        </xsl:variable>
        <xsl:choose>
            <xsl:when test="$rStyleId='' and $styleMod=''">
                <xsl:choose>
                    <xsl:when test="not($themeStyle='')">
                        <span>

                            <xsl:attribute name="class">
                                <xsl:value-of select="$themeStyle"/>
                                <xsl:if test="not($runStyleName='')">
                                    <xsl:value-of select="' '"/>
                                    <xsl:value-of select="$runStyleName"/>
                                </xsl:if>
                            </xsl:attribute>
                            <xsl:call-template name="DisplayRContent"/>
                        </span>

                    </xsl:when>
                    <xsl:otherwise>
                        <xsl:call-template name="DisplayRContent"/>
                    </xsl:otherwise>
                </xsl:choose>

                <xsl:if test="$pr.listSuff = $prListSuff_space">
                    <xsl:text> </xsl:text>
                </xsl:if>
            </xsl:when>
            <xsl:otherwise>
                <span>

                    <!-- <xsl:if test="not($rStyleId='')">-->
                    <xsl:attribute name="class">
                        <xsl:if test="not($themeStyle='')">
                            <xsl:value-of select="$themeStyle"/>
                            <xsl:value-of select="' '"/>
                        </xsl:if>
                        <xsl:value-of select="$rStyleId"/>
                        <xsl:value-of select="$charStyleSuffix"/>
                    </xsl:attribute>

                    <xsl:if test="not($styleMod='')">
                        <xsl:attribute name="style">
                            <xsl:value-of select="$styleMod"/>
                        </xsl:attribute>
                    </xsl:if>

                    <xsl:choose>
                        <xsl:when
                                test="contains($styleMod, 'vertical-align:super') or contains($styleMod, 'vertical-align:sub')">
                            <span>
                                <xsl:attribute name="style">font-size:smaller;</xsl:attribute>
                                <xsl:call-template name="DisplayRContent"/>
                            </span>
                        </xsl:when>
                        <xsl:otherwise>
                            <xsl:call-template name="DisplayRContent"/>
                        </xsl:otherwise>
                    </xsl:choose>

                </span>
            </xsl:otherwise>
        </xsl:choose>
    </xsl:template>
    <xsl:template match="w:sdt">

    </xsl:template>

    <xsl:template match="w:r">
        <xsl:param name="b.bidi" select="''"/>
        <xsl:param name="prsR" select="$prsRDefault"/>
        <xsl:param name="runStyleName"/>
        <!--<xsl:if test="not(w:fldChar or w:instrText)">-->
        <xsl:if test="not(w:fldChar or w:instrText)">

            <xsl:variable name="instrText" select="preceding-sibling::w:r[w:instrText][1]"/>

            <xsl:variable name="nInstrText" select="normalize-space(concat($instrText, ' -'))"/>
            <xsl:variable name="instruction" select="substring-before($nInstrText, ' ')"/>

            <xsl:choose>
                <xsl:when test="translate($instruction, $lowercase, $uppercase)='HYPERLINK'">
                    <a>
                        <!--<xsl:template match="a">
              <xsl:variable name="anchor-texts">
                <xsl:value-of select="."/>
              </xsl:variable>
              <xsl:apply-templates/>
              <xsl:if test="@href!=$anchor-texts">
                <fo:inline>
                  <xsl:text>(</xsl:text>
                  <xsl:value-of select="@href"/>
                  <xsl:text>)</xsl:text>
                </fo:inline>
              </xsl:if>
            </xsl:template>-->


                        <xsl:variable name="href">

                            <xsl:choose>
                                <xsl:when test="contains($nInstrText,'\l')">
                                    #<xsl:value-of
                                        select="translate(substring-before(substring-after($nInstrText, '\l '),' '),'&quot;', '')"/>
                                </xsl:when>
                                <xsl:otherwise>
                                    <xsl:value-of
                                            select="translate(substring-before(substring-after($nInstrText, concat($instruction, ' ')),' '),'&quot;', '')"/>
                                </xsl:otherwise>
                            </xsl:choose>
                        </xsl:variable>

                        <xsl:if test="not(href='')">
                            <xsl:attribute name="href">
                                <xsl:value-of select="$href"/>
                            </xsl:attribute>
                        </xsl:if>

                        <xsl:if test="contains($nInstrText,'\t') or contains($nInstrText, '\n')">
                            <xsl:attribute name="target">
                                <xsl:choose>
                                    <xsl:when test="contains($nInstrText, '\n')">
                                        <xsl:text>_new</xsl:text>
                                    </xsl:when>
                                    <xsl:otherwise>
                                        <xsl:value-of
                                                select="translate(substring-before(substring-after($nInstrText, '\t '),' '),'&quot;', '')"/>
                                    </xsl:otherwise>
                                </xsl:choose>
                            </xsl:attribute>
                        </xsl:if>

                        <xsl:if test="contains($nInstrText,'\o')">
                            <xsl:attribute name="title">
                                <xsl:value-of
                                        select="substring-before(substring-after($nInstrText, '\o &quot;'),'&quot;')"/>
                            </xsl:attribute>
                        </xsl:if>

                        <xsl:call-template name="DisplayR">
                            <xsl:with-param name="b.bidi" select="$b.bidi"/>
                            <xsl:with-param name="prsR" select="$prsR"/>
                            <xsl:with-param name="runStyleName" select="$runStyleName"/>
                        </xsl:call-template>

                    </a>
                </xsl:when>

                <xsl:otherwise>

                    <xsl:call-template name="DisplayR">
                        <xsl:with-param name="b.bidi" select="$b.bidi"/>
                        <xsl:with-param name="prsR" select="$prsR"/>
                        <xsl:with-param name="runStyleName" select="$runStyleName"/>
                    </xsl:call-template>
                </xsl:otherwise>
            </xsl:choose>
        </xsl:if>
    </xsl:template>
    <!-- Template added to render columns by Parwati -->
    <xsl:template name="ColumnRender">
        <xsl:param name="page"/>
        <xsl:param name="colNum"/>
        <xsl:param name="style"/>
        <xsl:param name="CoverPage"/>
        <xsl:param name="Align"/>
        <xsl:text disable-output-escaping="yes">&lt;/span&gt;</xsl:text>
        <xsl:text disable-output-escaping="yes">&lt;/p&gt;</xsl:text>
        <xsl:text disable-output-escaping="yes">&lt;/td&gt;</xsl:text>
        <xsl:if test="$page = $on">
            <xsl:text disable-output-escaping="yes">&lt;/tr&gt;</xsl:text>
            <xsl:text disable-output-escaping="yes">&lt;/table&gt;</xsl:text>
            <xsl:if test="$CoverPage = $on">
                <xsl:text disable-output-escaping="yes">&lt;div style="top:1010px;left:0px;position:absolute;visibility:show;"&gt;</xsl:text>
            </xsl:if>
            <xsl:text disable-output-escaping="yes">&lt;table cellpadding="5px"&gt;</xsl:text>
            <xsl:text disable-output-escaping="yes">&lt;tr&gt;</xsl:text>
        </xsl:if>
        <xsl:text disable-output-escaping="yes">&lt;td valign="top" width="</xsl:text>
        <xsl:value-of select="100 div $colNum"/>
        <xsl:text disable-output-escaping="yes">%"&gt;</xsl:text>
        <xsl:text disable-output-escaping="yes">&lt;p class="</xsl:text>
        <xsl:variable name="pStyleId">
            <xsl:call-template name="GetPStyleId"/>
        </xsl:variable>
        <xsl:value-of select="$pStyleId"/>
        <xsl:value-of select="$paraStyleSuffix"/>
        <xsl:text>" style="text-align:</xsl:text>
        <xsl:choose>
            <xsl:when test="$Align = 'both'">
                <xsl:text>justify</xsl:text>
            </xsl:when>
            <xsl:otherwise>
                <xsl:value-of select="$Align"/>
            </xsl:otherwise>
        </xsl:choose>
        <xsl:text>;</xsl:text>
        <xsl:value-of select="$style"/>
        <xsl:text disable-output-escaping="yes">"&gt;</xsl:text>
        <xsl:text disable-output-escaping="yes">&lt;span&gt;</xsl:text>
    </xsl:template>
    <!-- End to template for column rendering -->

    <xsl:template
            match="w:r[count(preceding-sibling::w:r[w:fldChar/@w:fldCharType='begin']) = count(preceding-sibling::w:r[w:fldChar/@w:fldCharType='end'])]">
        <xsl:param name="b.bidi" select="''"/>
        <xsl:param name="prsR" select="$prsRDefault"/>
        <xsl:param name="runStyleName"/>

        <!-- Changed For rendering column by Parwati-->
        <!-- <xsl:if test="//w:body//w:sectPr//w:cols[@w:num] | //w:body/w:p/w:pPr/w:sectPr/w:cols[@w:num]">
      <xsl:variable name="pageEnd">
        <xsl:choose>
          <xsl:when test="w:lastRenderedPageBreak[@pageNum]">
            <xsl:value-of select="$on"/>
          </xsl:when>
          <xsl:otherwise>
            <xsl:value-of select="$off"/>
          </xsl:otherwise>
        </xsl:choose>
      </xsl:variable> End of Change by Parwati -->
        <xsl:variable name="coverpage">
            <xsl:choose>
                <xsl:when test="./w:lastRenderedPageBreak/@Coverpage">
                    <xsl:value-of select="$on"/>
                </xsl:when>
                <xsl:otherwise>
                    <xsl:value-of select="$off"/>
                </xsl:otherwise>
            </xsl:choose>
        </xsl:variable>
        <xsl:variable name="columnNo">
            <xsl:value-of select="./w:lastRenderedPageBreak/@colNum"/>
        </xsl:variable>
        <xsl:variable name="columnCount">
            <xsl:value-of select="./w:lastRenderedPageBreak/@colCount"/>
        </xsl:variable>
        <xsl:variable name="pStyleId">
            <xsl:call-template name="GetPStyleId"/>
        </xsl:variable>
        <xsl:variable name="sParaStyleName" select="($nsStyles[@w:styleId=$pStyleId])[1]"/>
        <xsl:variable name="b.bidi1">
            <xsl:choose>
                <xsl:when test="parent::w:pPr[1]/w:rPr[1]/w:rtl[1]">
                    <xsl:value-of select="$on"/>
                </xsl:when>
                <xsl:otherwise>
                    <xsl:value-of select="$off"/>
                </xsl:otherwise>
            </xsl:choose>
        </xsl:variable>

        <xsl:variable name="prsR.updated">
            <xsl:call-template name="PrsUpdateRPr">
                <xsl:with-param name="ndPrContainer" select="$sParaStyleName"/>
                <xsl:with-param name="prsR" select="$prsR"/>
            </xsl:call-template>
        </xsl:variable>

        <xsl:variable name="prsP.updated1">
            <xsl:call-template name="PrsUpdatePPr">
                <xsl:with-param name="ndPrContainer" select="$sParaStyleName"/>
                <xsl:with-param name="prsP" select="$prsPDefault"/>
            </xsl:call-template>
        </xsl:variable>

        <xsl:variable name="prsP.updated">
            <xsl:call-template name="PrsUpdatePPr">
                <xsl:with-param name="prsP" select="$prsP.updated1"/>
            </xsl:call-template>
        </xsl:variable>
        <xsl:variable name="prsPAccum" select="''"/>
        <xsl:variable name="styleMod">

            <xsl:value-of select="$prsPAccum"/>

            <xsl:for-each select="$sParaStyleName">
                <xsl:call-template name="RecursiveApplyPPr.many"/>
            </xsl:for-each>

            <xsl:call-template name="ApplyPPr.many">
                <xsl:with-param name="cxtSpacing">
                    <xsl:variable name="cspacing" select="$sParaStyleName/w:pPr[1]/w:contextualSpacing[1]"/>
                    <xsl:if test="$cspacing and not($cspacing/@w:val = 'off')">
                        <xsl:if test="following-sibling::*[1]/w:pPr[1]/w:pStyle[1]/@w:val = $pStyleId">
                            <xsl:value-of select="$cxtSpacing_top"/>
                        </xsl:if>
                        <xsl:if test="preceding-sibling::*[1]/w:pPr[1]/w:pStyle[1]/@w:val = $pStyleId">
                            <xsl:value-of select="$cxtSpacing_bottom"/>
                        </xsl:if>
                    </xsl:if>
                </xsl:with-param>
            </xsl:call-template>

            <xsl:call-template name="ApplyPPr.class"/>
            <xsl:variable name="bdrBetween" select="''"/>
            <xsl:call-template name="ApplyPPr.once">
                <xsl:with-param name="b.bidi" select="$b.bidi1"/>
                <xsl:with-param name="prsP" select="$prsP.updated"/>
                <xsl:with-param name="i.bdrRange.this" select="position()"/>
                <xsl:with-param name="i.bdrRange.last" select="last()"/>
                <xsl:with-param name="pr.bdrBetween" select="$bdrBetween"/>
            </xsl:call-template>
        </xsl:variable>
        <xsl:variable name="alignment">
            <xsl:if test="parent::*[1]/w:pPr/w:jc">
                <xsl:value-of select="parent::*[1]/w:pPr/w:jc/@w:val"/>
            </xsl:if>
        </xsl:variable>
        <!-- Added for column rendering by Parwati -->
        <!-- <xsl:if test="//w:body//w:sectPr//w:cols[@w:num] | //w:body/w:p/w:pPr/w:sectPr/w:cols[@w:num] | //w:body//w:sdt//w:sdtContent">
      <xsl:if test="descendant::*[name()='w:lastRenderedPageBreak'][1]/@colNum">

        <xsl:call-template name="ColumnRender">
          <xsl:with-param name="page" select="$pageEnd"></xsl:with-param>
          <xsl:with-param name="colNum" select="$columnNo"></xsl:with-param>
          <xsl:with-param name="style" select="$styleMod"></xsl:with-param>
          <xsl:with-param name="CoverPage" select="$coverpage"></xsl:with-param>
          <xsl:with-param name="Align" select="$alignment"></xsl:with-param>
        </xsl:call-template>
      </xsl:if>
      </xsl:if>
    </xsl:if> -->
        <!-- End of change by Parwati -->
        <xsl:call-template name="DisplayR">
            <xsl:with-param name="b.bidi" select="$b.bidi"/>
            <xsl:with-param name="prsR" select="$prsR"/>
            <xsl:with-param name="runStyleName" select="$runStyleName"/>
        </xsl:call-template>
    </xsl:template>

    <xsl:template name="ColumnAddition"> <!-- This is template is added by Parwati to handle columns -->
        <xsl:param name="totalColumns"></xsl:param>
        <xsl:text disable-output-escaping="yes">&lt;/td&gt;</xsl:text>
        <xsl:text disable-output-escaping="yes">&lt;td colspan="</xsl:text>
        <xsl:value-of select="$totalColumns"/>
        <xsl:text disable-output-escaping="yes">"&gt;</xsl:text>
    </xsl:template>

    <xsl:template match="w:pPr">
        <xsl:param name="b.bidi" select="''"/>
        <xsl:param name="prsR" select="$prsRDefault"/>
        <xsl:call-template name="DisplayR">
            <xsl:with-param name="b.bidi" select="$b.bidi"/>
            <xsl:with-param name="prsR" select="$prsR"/>
        </xsl:call-template>
    </xsl:template>

    <xsl:template name="DisplayHlink">
        <xsl:param name="b.bidi"/>
        <xsl:param name="prsR"/>
        <a style="text-decoration:none;">
            <xsl:variable name="href">
                <xsl:for-each select="@w:dest">
                    <xsl:value-of select="."/>
                </xsl:for-each>
                <xsl:choose>
                    <xsl:when test="@w:anchor">#<xsl:value-of select="@w:anchor"/>
                    </xsl:when>
                    <xsl:when test="@w:bookmark">#<xsl:value-of select="@w:bookmark"/>
                    </xsl:when>
                    <xsl:when test="@w:arbLocation">#
                        <xsl:value-of select="@w:arbLocation"/>
                    </xsl:when>
                </xsl:choose>
            </xsl:variable>
            <xsl:if test="not(href='')">
                <xsl:attribute name="href">
                    <xsl:value-of select="$href"/>
                </xsl:attribute>
            </xsl:if>
            <xsl:for-each select="@w:tgtFrame">
                <xsl:attribute name="target">
                    <xsl:value-of select="."/>
                </xsl:attribute>
            </xsl:for-each>
            <xsl:for-each select="@w:tooltip">
                <xsl:attribute name="title">
                    <xsl:value-of select="."/>
                </xsl:attribute>
            </xsl:for-each>
            <xsl:call-template name="DisplayPContent">
                <xsl:with-param name="b.bidi" select="$b.bidi"/>
                <xsl:with-param name="prsR" select="$prsR"/>
            </xsl:call-template>
        </a>
    </xsl:template>

    <xsl:template match="w:hlink | w:hyperlink">
        <xsl:param name="b.bidi" select="''"/>
        <xsl:param name="prsR" select="$prsRDefault"/>
        <xsl:call-template name="DisplayHlink">
            <xsl:with-param name="b.bidi" select="$b.bidi"/>
            <xsl:with-param name="prsR" select="$prsR"/>
        </xsl:call-template>
    </xsl:template>

    <xsl:template name="ApplyPPr.once">
        <xsl:param name="i.bdrRange.this"/>
        <xsl:param name="i.bdrRange.last"/>
        <xsl:param name="pr.bdrBetween"/>
        <xsl:param name="prsP"/>
        <xsl:param name="b.bidi"/>

        <xsl:if test="not($i.bdrRange.this = $i.bdrRange.last)">
            <xsl:call-template name="ApplyBorderPr">
                <xsl:with-param name="pr.bdr" select="$pr.bdrBetween"/>
                <xsl:with-param name="bdrSide" select="$bdrSide_bottom"/>
            </xsl:call-template>
        </xsl:if>

        <xsl:if test="not($pr.bdrBetween = '')">
            <xsl:choose>
                <xsl:when test="$i.bdrRange.this = 1">padding:0 0 1pt;</xsl:when>
                <xsl:when test="$i.bdrRange.this = i.bdrRange.last">padding:1pt 0 0;</xsl:when>
                <xsl:otherwise>padding:1pt 0 1pt;</xsl:otherwise>
            </xsl:choose>
        </xsl:if>

        <xsl:choose>
            <xsl:when test="$b.bidi = $off">direction:ltr;unicode-bidi:normal;</xsl:when>
            <xsl:when test="$b.bidi = $on">direction:rtl;unicode-bidi:embed;text-align:right;</xsl:when>
        </xsl:choose>

        <xsl:variable name="nInd" select="substring($prsP,$iInd)"/>
        <xsl:variable name="pr.listInd">
            <xsl:for-each select="w:pPr">
                <xsl:call-template name="PrsGetListPr">
                    <xsl:with-param name="type" select="$prrListInd"/>
                </xsl:call-template>
            </xsl:for-each>
        </xsl:variable>
        <xsl:if test="not($nInd='' and $pr.listInd='')">

            <xsl:variable name="nInd.left" select="substring-before($nInd,$sep2)"/>
            <xsl:variable name="temp1" select="substring-after($nInd,$sep2)"/>
            <xsl:variable name="nInd.leftChars" select="substring-before($temp1,$sep2)"/>
            <xsl:variable name="temp2" select="substring-after($temp1,$sep2)"/>
            <xsl:variable name="nInd.right" select="substring-before($temp2,$sep2)"/>
            <xsl:variable name="temp3" select="substring-after($temp2,$sep2)"/>
            <xsl:variable name="nInd.rightChars" select="substring-before($temp3,$sep2)"/>
            <xsl:variable name="temp4" select="substring-after($temp3,$sep2)"/>
            <xsl:variable name="nInd.hanging" select="substring-before($temp4,$sep2)"/>
            <xsl:variable name="temp5" select="substring-after($temp4,$sep2)"/>
            <xsl:variable name="nInd.hangingChars" select="substring-before($temp5,$sep2)"/>
            <xsl:variable name="temp6" select="substring-after($temp5,$sep2)"/>
            <xsl:variable name="nInd.firstLine" select="substring-before($temp6,$sep2)"/>
            <xsl:variable name="nInd.firstLineChars" select="substring-after($temp6,$sep2)"/>
            <xsl:variable name="pr.listInd.left" select="substring-before($pr.listInd,$sep2)"/>
            <xsl:variable name="temp1a" select="substring-after($pr.listInd,$sep2)"/>
            <xsl:variable name="pr.listInd.leftChars" select="substring-before($temp1a,$sep2)"/>
            <xsl:variable name="temp2a" select="substring-after($temp1a,$sep2)"/>
            <xsl:variable name="pr.listInd.hanging" select="substring-before($temp2a,$sep2)"/>
            <xsl:variable name="pr.listInd.hangingChars" select="substring-after($temp2a,$sep2)"/>

            <xsl:variable name="marginSide.before">
                margin-
                <xsl:choose>
                    <xsl:when test="$b.bidi=$on">right</xsl:when>
                    <xsl:otherwise>left</xsl:otherwise>
                </xsl:choose>
                :
            </xsl:variable>
            <xsl:variable name="marginSide.after">
                margin-
                <xsl:choose>
                    <xsl:when test="$b.bidi=$on">left</xsl:when>
                    <xsl:otherwise>right</xsl:otherwise>
                </xsl:choose>
                :
            </xsl:variable>

            <xsl:choose>

                <xsl:when test="not($pr.listInd.left = '')">
                    <xsl:value-of select="$marginSide.before"/><xsl:value-of select="$pr.listInd.left div 20"/>pt;
                </xsl:when>
                <xsl:when test="not($pr.listInd.leftChars = '' and $pr.listInd.hangingChars='')">
                    <xsl:value-of select="$marginSide.before"/>
                    <xsl:variable name="leftchars">
                        <xsl:choose>
                            <xsl:when test="$pr.listInd.leftChars=''">0</xsl:when>
                            <xsl:otherwise>
                                <xsl:value-of select="$pr.listInd.leftChars div 100 * 12"/>
                            </xsl:otherwise>
                        </xsl:choose>
                    </xsl:variable>
                    <xsl:variable name="hangingchars">
                        <xsl:choose>
                            <xsl:when test="$pr.listInd.hangingChars=''">0</xsl:when>
                            <xsl:otherwise>
                                <xsl:value-of select="$pr.listInd.hangingChars div 100 * 12"/>
                            </xsl:otherwise>
                        </xsl:choose>
                    </xsl:variable>
                    <xsl:value-of select="$leftchars + $hangingchars"/>
                    <xsl:text>pt;</xsl:text>
                </xsl:when>

                <xsl:when test="not($nInd.left = '')"> <!-- Modified by Parwati to handle negative indentation -->
                    <xsl:value-of select="$marginSide.before"/>
                    <xsl:choose>
                        <xsl:when test="$nInd.left &lt; 0">
                            0pt;
                        </xsl:when>
                        <xsl:otherwise>
                            <xsl:value-of select="$nInd.left div 20"/>pt;
                        </xsl:otherwise>
                    </xsl:choose>
                </xsl:when>
                <xsl:when test="not($nInd.leftChars = '' and $nInd.hangingChars='')">
                    <xsl:value-of select="$marginSide.before"/>
                    <xsl:variable name="leftchars">
                        <xsl:choose>
                            <xsl:when test="$nInd.leftChars=''">0</xsl:when>
                            <xsl:otherwise>
                                <xsl:value-of select="$nInd.leftChars div 100"/>
                            </xsl:otherwise>
                        </xsl:choose>
                    </xsl:variable>
                    <xsl:variable name="hangingchars">
                        <xsl:choose>
                            <xsl:when test="$nInd.hangingChars=''">0</xsl:when>
                            <xsl:otherwise>
                                <xsl:value-of select="$nInd.hangingChars div 100"/>
                            </xsl:otherwise>
                        </xsl:choose>
                    </xsl:variable>
                    <xsl:value-of select="$leftchars + $hangingchars"/>
                    <xsl:text>em;</xsl:text>
                </xsl:when>

            </xsl:choose>

            <xsl:choose>
                <xsl:when test="not($nInd.right = '')">
                    <xsl:value-of select="$marginSide.after"/><xsl:value-of select="$nInd.right div 20"/>pt;
                </xsl:when>
                <xsl:when test="not($nInd.rightChars = '')">
                    <xsl:value-of select="$marginSide.after"/><xsl:value-of select="$nInd.rightChars div 100"/>em;
                </xsl:when>
            </xsl:choose>
            <!-- TEXT INDENTATION FOR TABLE MODIFIED BY PRASAHANTH-->
            <xsl:choose>
                <xsl:when test="not($nInd.hanging='')">
                    <xsl:if test="not(../../w:tc)">
                        text-indent:<xsl:value-of
                            select="$nInd.hanging div 20"/>pt; <!-- - sign before 20 removed by Parwati -->
                    </xsl:if>
                </xsl:when>
                <!-- TEXT INDENTATION FOR TABLE MODIFIED BY PRASAHANTH-->

                <xsl:when test="not($nInd.hangingChars='')">
                    text-indent:<xsl:value-of select="$nInd.hangingChars div -100"/>em;
                </xsl:when>
                <xsl:when test="not($nInd.firstLine='')">
                    text-indent:<xsl:value-of select="$nInd.firstLine div 20"/>pt;
                </xsl:when>
                <xsl:when test="not($nInd.firstLineChars='')">
                    text-indent:<xsl:value-of select="$nInd.firstLineChars div 100"/>em;
                </xsl:when>
                <xsl:when test="not($pr.listInd.hanging='')">
                    text-indent:<xsl:value-of select="$pr.listInd.hanging div -20"/>pt;
                </xsl:when>
                <xsl:when test="not($pr.listInd.hangingChars='')">
                    text-indent:<xsl:value-of select="$pr.listInd.hangingChars div -100 * 12"/>pt;
                </xsl:when>
            </xsl:choose>
        </xsl:if>

        <xsl:variable name="fTextAutospaceO" select="substring($prsP,$iTextAutospaceO,1)"/>
        <xsl:variable name="fTextAutospaceN" select="substring($prsP,$iTextAutospaceN,1)"/>
        <xsl:choose>
            <xsl:when test="not($fTextAutospaceN = $off) and $fTextAutospaceO = $off">
                text-autospace:ideograph-numeric;
            </xsl:when>
            <xsl:when test="not($fTextAutospaceO = $off) and $fTextAutospaceN = $off">text-autospace:ideograph-other;
            </xsl:when>
            <xsl:when test="$fTextAutospaceO = $off and $fTextAutospaceN = $off">text-autospace:none;</xsl:when>
        </xsl:choose>
    </xsl:template>

    <xsl:template name="ApplyPPr.many">
        <xsl:param name="cxtSpacing" select="$cxtSpacing_all"/>

        <xsl:variable name="spacing" select="w:pPr[1]/w:spacing[1]"/>
        <xsl:choose>
            <xsl:when
                    test="($spacing/@w:before-autospacing and not($spacing/@w:before-autospacing = 'off')) or $cxtSpacing = $cxtSpacing_none or $cxtSpacing = $cxtSpacing_bottom">

            </xsl:when>
            <xsl:when test="$spacing/@w:before">
                margin-top:<xsl:value-of select="$spacing/@w:before div 20"/>pt;
            </xsl:when>
            <xsl:when test="$spacing/@w:before-lines">
                margin-top:<xsl:value-of select="$spacing/@w:before-lines *.12"/>pt;
            </xsl:when>
        </xsl:choose>
        <xsl:choose>
            <xsl:when
                    test="($spacing/@w:after-autospacing and not($spacing/@w:after-autospacing = 'off')) or $cxtSpacing = $cxtSpacing_none or $cxtSpacing = $cxtSpacing_top">

            </xsl:when>

            <xsl:when test="$spacing/@w:after">
                margin-bottom:<xsl:value-of select="$spacing/@w:after div 20"/>pt;
            </xsl:when>
            <xsl:when test="$spacing/@w:after-lines">
                margin-bottom:<xsl:value-of select="$spacing/@w:after-lines *.12"/>pt;
            </xsl:when>
        </xsl:choose>
        <xsl:for-each select="w:pPr[1]">

            <xsl:for-each select="w:snapToGrid[1]">
                <xsl:choose>
                    <xsl:when test="@w:val = 'off'">layout-grid-mode:char;</xsl:when>
                    <xsl:otherwise>layout-grid-mode:both;</xsl:otherwise>
                </xsl:choose>
            </xsl:for-each>

            <xsl:for-each select="w:keepNext[1]">
                <xsl:choose>
                    <xsl:when test="@w:val = 'off'">page-break-after:auto;</xsl:when>
                    <xsl:otherwise>page-break-after:avoid;</xsl:otherwise>
                </xsl:choose>
            </xsl:for-each>

            <xsl:for-each select="w:pageBreakBefore[1]">
                <xsl:choose>
                    <xsl:when test="@w:val = 'off'">page-break-before:auto;</xsl:when>
                    <xsl:otherwise>page-break-before:always;</xsl:otherwise>
                </xsl:choose>
            </xsl:for-each>
        </xsl:for-each>
    </xsl:template>

    <xsl:template name="RecursiveApplyPPr.class">
        <xsl:if test="w:basedOn">
            <xsl:variable name="baseStyleName" select="w:basedOn[1]/@w:val"/>
            <xsl:variable name="sParaStyleBase" select="($nsStyles[@w:styleId=$baseStyleName])[1]"/>
            <xsl:for-each select="$sParaStyleBase">
                <xsl:call-template name="RecursiveApplyPPr.class"/>
            </xsl:for-each>
        </xsl:if>

        <xsl:call-template name="ApplyPPr.class"/>
    </xsl:template>

    <xsl:template name="ApplyPPr.class">
        <xsl:apply-templates select="w:pPr[1]/*" mode="ppr"/>
    </xsl:template>

    <xsl:template match="w:shd" mode="ppr">
        <xsl:call-template name="ApplyShd"/>
    </xsl:template>

    <xsl:template match="WX:shd" mode="ppr">
        <xsl:call-template name="ApplyShdHint"/>
    </xsl:template>

    <xsl:template match="w:textDirection" mode="ppr">
        <xsl:call-template name="ApplyTextDirection"/>
    </xsl:template>

    <!-- ID 1 Fix linespacing issue - div from 20 to 10-->

    <xsl:template match="w:spacing[@w:lineRule or @w:line]" mode="ppr">
        <xsl:choose>
            <xsl:when test="not(@w:lineRule) or @w:lineRule = 'exact'or @w:lineRule = 'auto'">
                line-height:<xsl:value-of select="@w:line div 10"/>pt;
            </xsl:when>
        </xsl:choose>
    </xsl:template>

    <xsl:template match="w:topLinePunct" mode="ppr">
        <xsl:choose>
            <xsl:when test="@w:val = 'off'">punctuation-trim:none;</xsl:when>
            <xsl:otherwise>punctuation-trim:leading;</xsl:otherwise>
        </xsl:choose>
    </xsl:template>

    <xsl:template match="w:overflowPunct" mode="ppr">
        <xsl:choose>
            <xsl:when test="@w:val = 'off'">punctuation-wrap:simple;</xsl:when>
            <xsl:otherwise>punctuation-wrap:hanging;</xsl:otherwise>
        </xsl:choose>
    </xsl:template>

    <xsl:template match="w:jc" mode="ppr">
        <xsl:choose>
            <xsl:when test="@w:val = 'left'">text-align:left;</xsl:when>
            <xsl:when test="@w:val = 'center'">text-align:center;</xsl:when>
            <xsl:when test="@w:val = 'right'">text-align:right;</xsl:when>
            <xsl:when test="@w:val = 'both'">text-align:justify;text-justify:inter-ideograph;</xsl:when>
            <xsl:when test="@w:val = 'distribute'">text-align:justify;text-justify:distribute-all-lines;</xsl:when>
            <xsl:when test="@w:val = 'low-kashida'">text-align:justify;text-justify:kashida;text-kashida:0%;</xsl:when>
            <xsl:when test="@w:val = 'medium-kashida'">text-align:justify;text-justify:kashida;text-kashida:10%;
            </xsl:when>
            <xsl:when test="@w:val = 'high-kashida'">text-align:justify;text-justify:kashida;text-kashida:20%;
            </xsl:when>
            <xsl:when test="@w:val = 'thai-distribute'">text-align:justify;text-justify:inter-cluster;</xsl:when>
        </xsl:choose>
    </xsl:template>

    <xsl:template match="w:textAlignment" mode="ppr">
        <xsl:choose>
            <xsl:when test="@w:val = 'top'">vertical-align:top;</xsl:when>
            <xsl:when test="@w:val = 'center'">vertical-align:middle;</xsl:when>
            <xsl:when test="@w:val = 'baseline'">vertical-align:baseline;</xsl:when>
            <xsl:when test="@w:val = 'bottom'">vertical-align:bottom;</xsl:when>
            <xsl:when test="@w:val = 'auto'">vertical-align:baseline;</xsl:when>
        </xsl:choose>
    </xsl:template>

    <xsl:template match="w:wordWrap" mode="ppr">
        <xsl:choose>
            <xsl:when test="@w:val = 'off'">word-break:break-all;</xsl:when>
            <xsl:otherwise>word-break:normal;</xsl:otherwise>
        </xsl:choose>
    </xsl:template>

    <xsl:template match="*" mode="ppr"/>

    <xsl:template name="DisplayPContent">
        <xsl:param name="b.bidi"/>
        <xsl:param name="prsR"/>
        <xsl:param name="runStyleName"/>
        <xsl:call-template name="DisplayRBorder">
            <xsl:with-param name="b.bidi" select="$b.bidi"/>
            <xsl:with-param name="prsR" select="$prsR"/>
            <xsl:with-param name="runStyleName" select="$runStyleName"/>
        </xsl:call-template>

        <xsl:if test="count(*[not(name()='w:pPr')])=0">
            <xsl:text disable-output-escaping="yes">&#160;</xsl:text>
        </xsl:if>
    </xsl:template>

    <xsl:template name="GetPStyleId">
        <xsl:choose>
            <xsl:when test="w:pPr/w:pStyle/@w:val">
                <xsl:value-of select="w:pPr/w:pStyle/@w:val"/>
            </xsl:when>
            <xsl:otherwise>
                <xsl:value-of select="$paraStyleID_Default"/>
            </xsl:otherwise>
        </xsl:choose>
    </xsl:template>

    <xsl:template name="RecursiveApplyPPr.many">
        <xsl:if test="w:basedOn">
            <xsl:variable name="baseStyleName" select="w:basedOn[1]/@w:val"/>
            <xsl:variable name="sParaStyleBase" select="($nsStyles[@w:styleId=$baseStyleName])[1]"/>
            <xsl:for-each select="$sParaStyleBase">
                <xsl:call-template name="RecursiveApplyPPr.many"/>
            </xsl:for-each>
        </xsl:if>

        <xsl:call-template name="ApplyPPr.many"/>

    </xsl:template>

    <xsl:template match="w:p">
        <xsl:param name="bdrBetween" select="''"/>
        <xsl:param name="prsPAccum" select="''"/>
        <xsl:param name="prsP" select="$prsPDefault"/>
        <xsl:param name="prsR" select="$prsRDefault"/>

        <xsl:if test="not(w:pPr/w:pStyle/@w:val='z-TopofForm') and not(w:pPr/w:pStyle/@w:val='z-BottomofForm')">
            <p>

                <xsl:variable name="pStyleId">
                    <xsl:call-template name="GetPStyleId"/>
                </xsl:variable>
                <xsl:attribute name="class">
                    <xsl:value-of select="$pStyleId"/>
                    <xsl:value-of select="$paraStyleSuffix"/>
                </xsl:attribute>
                <xsl:variable name="sParaStyleName" select="($nsStyles[@w:styleId=$pStyleId])[1]"/>
                <xsl:variable name="b.bidi">
                    <xsl:choose>
                        <xsl:when test="w:pPr[1]/w:rPr[1]/w:rtl[1]">
                            <xsl:value-of select="$on"/>
                        </xsl:when>
                        <xsl:otherwise>
                            <xsl:value-of select="$off"/>
                        </xsl:otherwise>
                    </xsl:choose>
                </xsl:variable>

                <xsl:variable name="prsR.updated">
                    <xsl:call-template name="PrsUpdateRPr">
                        <xsl:with-param name="ndPrContainer" select="$sParaStyleName"/>
                        <xsl:with-param name="prsR" select="$prsR"/>
                    </xsl:call-template>
                </xsl:variable>

                <xsl:variable name="prsP.updated1">
                    <xsl:call-template name="PrsUpdatePPr">
                        <xsl:with-param name="ndPrContainer" select="$sParaStyleName"/>
                        <xsl:with-param name="prsP" select="$prsP"/>
                    </xsl:call-template>
                </xsl:variable>

                <xsl:variable name="prsP.updated">
                    <xsl:call-template name="PrsUpdatePPr">
                        <xsl:with-param name="prsP" select="$prsP.updated1"/>
                    </xsl:call-template>
                </xsl:variable>

                <xsl:variable name="styleMod">

                    <xsl:value-of select="$prsPAccum"/>

                    <xsl:for-each select="$sParaStyleName">
                        <xsl:call-template name="RecursiveApplyPPr.many"/>
                    </xsl:for-each>

                    <xsl:call-template name="ApplyPPr.many">
                        <xsl:with-param name="cxtSpacing">
                            <xsl:variable name="cspacing" select="$sParaStyleName/w:pPr[1]/w:contextualSpacing[1]"/>
                            <xsl:if test="$cspacing and not($cspacing/@w:val = 'off')">
                                <xsl:if test="following-sibling::*[1]/w:pPr[1]/w:pStyle[1]/@w:val = $pStyleId">
                                    <xsl:value-of select="$cxtSpacing_top"/>
                                </xsl:if>
                                <xsl:if test="preceding-sibling::*[1]/w:pPr[1]/w:pStyle[1]/@w:val = $pStyleId">
                                    <xsl:value-of select="$cxtSpacing_bottom"/>
                                </xsl:if>
                            </xsl:if>
                        </xsl:with-param>
                    </xsl:call-template>

                    <xsl:call-template name="ApplyPPr.class"/>

                    <xsl:call-template name="ApplyPPr.once">
                        <xsl:with-param name="b.bidi" select="$b.bidi"/>
                        <xsl:with-param name="prsP" select="$prsP.updated"/>
                        <xsl:with-param name="i.bdrRange.this" select="position()"/>
                        <xsl:with-param name="i.bdrRange.last" select="last()"/>
                        <xsl:with-param name="pr.bdrBetween" select="$bdrBetween"/>
                    </xsl:call-template>
                </xsl:variable>
                <xsl:if test="not($styleMod='')">
                    <xsl:attribute name="style">
                        <xsl:value-of select="$styleMod"/>
                    </xsl:attribute>
                </xsl:if>

                <span>
                    <xsl:attribute name="class">
                        <xsl:value-of select="$pStyleId"/>
                        <xsl:value-of select="$charStyleSuffix"/>
                    </xsl:attribute>
                    <xsl:call-template name="DisplayPContent">
                        <xsl:with-param name="b.bidi" select="$b.bidi"/>
                        <xsl:with-param name="prsR" select="$prsR.updated"/>
                        <xsl:with-param name="runStyleName">
                            <xsl:value-of select="$pStyleId"/>
                            <xsl:value-of select="$charStyleSuffix"/>
                        </xsl:with-param>
                    </xsl:call-template>
                </span>
            </p>
            <!--     <xsl:if test="./w:r/w:lastRenderedPageBreak/@ColumnEnd">  Added by Parwati to handle columns
        <xsl:variable name="columnNo">
          <xsl:value-of select="./w:r/w:lastRenderedPageBreak/@colNum"/>
        </xsl:variable>
        <xsl:call-template name="ColumnAddition">
          <xsl:with-param name="totalColumns" select="$columnNo"></xsl:with-param>
        </xsl:call-template>
      </xsl:if> End -->
            <!--By Sunil svg shapes positioning-->
            <xsl:if test="./w:r/div/svg">
                <!--<br/>
        <br/>-->
            </xsl:if>
        </xsl:if>
    </xsl:template>
    <xsl:template match="w:sdt/w:sdtContent">

        <span class="c-input">
            <xsl:attribute name="data-alias">
                <xsl:value-of select="../w:sdtPr/w:alias/@w:val"/>
            </xsl:attribute>
            <xsl:attribute name="data-tag">
                <xsl:value-of select="../w:sdtPr/w:tag/@w:val"/>
            </xsl:attribute>
            <xsl:attribute name="data-type">
                <xsl:choose>
                    <xsl:when test="../sdtPr/w:date">
                        <xsl:value-of select="'date'"/>
                    </xsl:when>
                    <xsl:otherwise>
                        <xsl:value-of select="'input'"/>
                    </xsl:otherwise>
                </xsl:choose>
            </xsl:attribute>
            <xsl:apply-templates/>
        </span>
    </xsl:template>


    <xsl:template match="w:sdt/w:sdtContent/w:tc/w:p | w:sdt/w:sdtContent/w:p">
        <p>
            <xsl:attribute name="class">
                <xsl:value-of select="./w:pPr/w:pStyle/@w:val"/>
                <xsl:value-of select="$charStyleSuffix"/>
            </xsl:attribute>
            <xsl:attribute name="style">
                text-align:<xsl:value-of select="./w:pPr/w:jc/@w:val"/>
            </xsl:attribute>
            <span>
                <xsl:apply-templates/>
            </span>
        </p>
    </xsl:template>

    <xsl:template name="DisplayBodyContent">

        <xsl:param name="ns.content"
                   select="descendant::*[(parent::WX:sect or parent::WX:sub-section) and not(name()='WX:sub-section')]"/>
        <xsl:param name="prsPAccum" select="''"/>
        <xsl:param name="prsP" select="$prsPDefault"/>
        <xsl:param name="prsR" select="$prsRDefault"/>
        <xsl:apply-templates>
            <xsl:with-param name="ns.content" select="$ns.content"/>
            <xsl:with-param name="prsPAccum" select="$prsPAccum"/>
            <xsl:with-param name="prsP" select="$prsP"/>
            <xsl:with-param name="prsR" select="$prsR"/>
        </xsl:apply-templates>

        <xsl:if test="count($ns.content)=0">
            <xsl:text disable-output-escaping="yes">&#160;</xsl:text>
        </xsl:if>
    </xsl:template>

    <xsl:template name="RecursiveApplyTcPr.class">
        <xsl:if test="w:basedOn">
            <xsl:variable name="baseStyleName" select="w:basedOn[1]/@w:val"/>
            <xsl:variable name="sTblStyleBase" select="($nsStyles[@w:styleId=$baseStyleName])[1]"/>
            <xsl:for-each select="$sTblStyleBase">
                <xsl:call-template name="RecursiveApplyTcPr.class"/>
            </xsl:for-each>
        </xsl:if>

        <xsl:call-template name="ApplyTcPr.class"/>
    </xsl:template>

    <xsl:template name="ApplyTcPr.class">
        <xsl:apply-templates select="w:tcPr[1]/*" mode="tcpr"/>
    </xsl:template>

    <xsl:template match="w:shd" mode="tcpr">
        <xsl:call-template name="ApplyShd"/>
    </xsl:template>

    <xsl:template match="w:textDirection" mode="tcpr">
        <xsl:call-template name="ApplyTextDirection"/>
    </xsl:template>

    <xsl:template match="w:tcFitText" mode="tcpr">
        <xsl:if test="not(@w:val = 'off')">text-fit:100%;</xsl:if>
    </xsl:template>

    <xsl:template match="w:vAlign" mode="tcpr">
        <xsl:choose>
            <xsl:when test="@w:val = 'center'">vertical-align:middle;</xsl:when>
            <xsl:when test="@w:val = 'bottom'">vertical-align:bottom;</xsl:when>
        </xsl:choose>
    </xsl:template>

    <xsl:template match="w:noWrap" mode="tcpr">
        <xsl:choose>
            <xsl:when test="@w:val = 'off'">white-space:normal;</xsl:when>
            <xsl:otherwise>white-space:nowrap;</xsl:otherwise>
        </xsl:choose>
    </xsl:template>

    <xsl:template match="w:tcW" mode="tcpr">
        width:<xsl:call-template name="EvalTableWidth"/>;
    </xsl:template>
    <xsl:template match="*" mode="tcpr"/>

    <xsl:template name="ApplyExtraCornerBorders">
        <xsl:param name="cnfType"/>
        <xsl:param name="sTblStyleName"/>
        <xsl:choose>
            <xsl:when test="$cnfType=$cnfNWCell">
                <xsl:call-template name="ApplyExtraCornerBordersNW">
                    <xsl:with-param name="sTblStyle" select="$sTblStyleName"/>
                </xsl:call-template>
            </xsl:when>
            <xsl:when test="$cnfType=$cnfNECell">
                <xsl:call-template name="ApplyExtraCornerBordersNE">
                    <xsl:with-param name="sTblStyle" select="$sTblStyleName"/>
                </xsl:call-template>
            </xsl:when>
            <xsl:when test="$cnfType=$cnfSECell">
                <xsl:call-template name="ApplyExtraCornerBordersSE">
                    <xsl:with-param name="sTblStyle" select="$sTblStyleName"/>
                </xsl:call-template>
            </xsl:when>
            <xsl:when test="$cnfType=$cnfSWCell">
                <xsl:call-template name="ApplyExtraCornerBordersSW">
                    <xsl:with-param name="sTblStyle" select="$sTblStyleName"/>
                </xsl:call-template>
            </xsl:when>
        </xsl:choose>
    </xsl:template>

    <xsl:template name="ApplyExtraCornerBordersNW">
        <xsl:param name="sTblStyle"/>

        <xsl:variable name="firstColBorders"
                      select="$sTblStyle/w:tblStylePr[@w:type=$cnfFirstCol][1]/w:tcPr[1]/w:tcBorders[1]"/>
        <xsl:variable name="firstRowBorders"
                      select="$sTblStyle/w:tblStylePr[@w:type=$cnfFirstRow][1]/w:tcPr[1]/w:tcBorders[1]"/>

        <xsl:call-template name="ApplyBorderPr">
            <xsl:with-param name="pr.bdr">
                <xsl:for-each select="$firstRowBorders/w:top[1]">
                    <xsl:call-template name="GetBorderPr"/>
                </xsl:for-each>
            </xsl:with-param>
            <xsl:with-param name="bdrSide" select="$bdrSide_top"/>
        </xsl:call-template>

        <xsl:call-template name="ApplyBorderPr">
            <xsl:with-param name="pr.bdr">
                <xsl:for-each select="$firstColBorders/w:top[1]">
                    <xsl:call-template name="GetBorderPr"/>
                </xsl:for-each>
            </xsl:with-param>
            <xsl:with-param name="bdrSide" select="$bdrSide_top"/>
        </xsl:call-template>

        <xsl:call-template name="ApplyBorderPr">
            <xsl:with-param name="pr.bdr">
                <xsl:for-each select="$firstRowBorders/w:left[1]">
                    <xsl:call-template name="GetBorderPr"/>
                </xsl:for-each>
            </xsl:with-param>
            <xsl:with-param name="bdrSide" select="$bdrSide_left"/>
        </xsl:call-template>

        <xsl:call-template name="ApplyBorderPr">
            <xsl:with-param name="pr.bdr">
                <xsl:for-each select="$firstColBorders/w:left[1]">
                    <xsl:call-template name="GetBorderPr"/>
                </xsl:for-each>
            </xsl:with-param>
            <xsl:with-param name="bdrSide" select="$bdrSide_left"/>
        </xsl:call-template>

        <xsl:call-template name="ApplyBorderPr">
            <xsl:with-param name="pr.bdr">
                <xsl:for-each select="$firstRowBorders/w:right[1]">
                    <xsl:call-template name="GetBorderPr"/>
                </xsl:for-each>
            </xsl:with-param>
            <xsl:with-param name="bdrSide" select="$bdrSide_right"/>
        </xsl:call-template>

        <xsl:call-template name="ApplyBorderPr">
            <xsl:with-param name="pr.bdr">
                <xsl:for-each select="$firstColBorders/w:right[1]">
                    <xsl:call-template name="GetBorderPr"/>
                </xsl:for-each>
            </xsl:with-param>
            <xsl:with-param name="bdrSide" select="$bdrSide_right"/>
        </xsl:call-template>

        <xsl:call-template name="ApplyBorderPr">
            <xsl:with-param name="pr.bdr">
                <xsl:for-each select="$firstRowBorders/w:bottom[1]">
                    <xsl:call-template name="GetBorderPr"/>
                </xsl:for-each>
            </xsl:with-param>
            <xsl:with-param name="bdrSide" select="$bdrSide_bottom"/>
        </xsl:call-template>

        <xsl:call-template name="ApplyBorderPr">
            <xsl:with-param name="pr.bdr">
                <xsl:for-each select="$firstColBorders/w:bottom[1]">
                    <xsl:call-template name="GetBorderPr"/>
                </xsl:for-each>
            </xsl:with-param>
            <xsl:with-param name="bdrSide" select="$bdrSide_bottom"/>
        </xsl:call-template>
    </xsl:template>

    <xsl:template name="ApplyExtraCornerBordersNE">
        <xsl:param name="sTblStyle"/>

        <xsl:variable name="lastColBorders"
                      select="$sTblStyle/w:tblStylePr[@w:type=$cnfLastCol][1]/w:tcPr[1]/w:tcBorders[1]"/>
        <xsl:variable name="firstRowBorders"
                      select="$sTblStyle/w:tblStylePr[@w:type=$cnfFirstRow][1]/w:tcPr[1]/w:tcBorders[1]"/>

        <xsl:call-template name="ApplyBorderPr">
            <xsl:with-param name="pr.bdr">
                <xsl:for-each select="$firstRowBorders/w:top[1]">
                    <xsl:call-template name="GetBorderPr"/>
                </xsl:for-each>
            </xsl:with-param>
            <xsl:with-param name="bdrSide" select="$bdrSide_top"/>
        </xsl:call-template>

        <xsl:call-template name="ApplyBorderPr">
            <xsl:with-param name="pr.bdr">
                <xsl:for-each select="$lastColBorders/w:top[1]">
                    <xsl:call-template name="GetBorderPr"/>
                </xsl:for-each>
            </xsl:with-param>
            <xsl:with-param name="bdrSide" select="$bdrSide_top"/>
        </xsl:call-template>

        <xsl:call-template name="ApplyBorderPr">
            <xsl:with-param name="pr.bdr">
                <xsl:for-each select="$firstRowBorders/w:left[1]">
                    <xsl:call-template name="GetBorderPr"/>
                </xsl:for-each>
            </xsl:with-param>
            <xsl:with-param name="bdrSide" select="$bdrSide_left"/>
        </xsl:call-template>

        <xsl:call-template name="ApplyBorderPr">
            <xsl:with-param name="pr.bdr">
                <xsl:for-each select="$lastColBorders/w:left[1]">
                    <xsl:call-template name="GetBorderPr"/>
                </xsl:for-each>
            </xsl:with-param>
            <xsl:with-param name="bdrSide" select="$bdrSide_left"/>
        </xsl:call-template>

        <xsl:call-template name="ApplyBorderPr">
            <xsl:with-param name="pr.bdr">
                <xsl:for-each select="$firstRowBorders/w:right[1]">
                    <xsl:call-template name="GetBorderPr"/>
                </xsl:for-each>
            </xsl:with-param>
            <xsl:with-param name="bdrSide" select="$bdrSide_right"/>
        </xsl:call-template>

        <xsl:call-template name="ApplyBorderPr">
            <xsl:with-param name="pr.bdr">
                <xsl:for-each select="$lastColBorders/w:right[1]">
                    <xsl:call-template name="GetBorderPr"/>
                </xsl:for-each>
            </xsl:with-param>
            <xsl:with-param name="bdrSide" select="$bdrSide_right"/>
        </xsl:call-template>

        <xsl:call-template name="ApplyBorderPr">
            <xsl:with-param name="pr.bdr">
                <xsl:for-each select="$firstRowBorders/w:bottom[1]">
                    <xsl:call-template name="GetBorderPr"/>
                </xsl:for-each>
            </xsl:with-param>
            <xsl:with-param name="bdrSide" select="$bdrSide_bottom"/>
        </xsl:call-template>

        <xsl:call-template name="ApplyBorderPr">
            <xsl:with-param name="pr.bdr">
                <xsl:for-each select="$lastColBorders/w:bottom[1]">
                    <xsl:call-template name="GetBorderPr"/>
                </xsl:for-each>
            </xsl:with-param>
            <xsl:with-param name="bdrSide" select="$bdrSide_bottom"/>
        </xsl:call-template>
    </xsl:template>

    <xsl:template name="ApplyExtraCornerBordersSE">
        <xsl:param name="sTblStyle"/>

        <xsl:variable name="lastColBorders"
                      select="$sTblStyle/w:tblStylePr[@w:type=$cnfLastCol][1]/w:tcPr[1]/w:tcBorders[1]"/>
        <xsl:variable name="lastRowBorders"
                      select="$sTblStyle/w:tblStylePr[@w:type=$cnfLastRow][1]/w:tcPr[1]/w:tcBorders[1]"/>

        <xsl:call-template name="ApplyBorderPr">
            <xsl:with-param name="pr.bdr">
                <xsl:for-each select="$lastRowBorders/w:top[1]">
                    <xsl:call-template name="GetBorderPr"/>
                </xsl:for-each>
            </xsl:with-param>
            <xsl:with-param name="bdrSide" select="$bdrSide_top"/>
        </xsl:call-template>

        <xsl:call-template name="ApplyBorderPr">
            <xsl:with-param name="pr.bdr">
                <xsl:for-each select="$lastColBorders/w:top[1]">
                    <xsl:call-template name="GetBorderPr"/>
                </xsl:for-each>
            </xsl:with-param>
            <xsl:with-param name="bdrSide" select="$bdrSide_top"/>
        </xsl:call-template>

        <xsl:call-template name="ApplyBorderPr">
            <xsl:with-param name="pr.bdr">
                <xsl:for-each select="$lastRowBorders/w:left[1]">
                    <xsl:call-template name="GetBorderPr"/>
                </xsl:for-each>
            </xsl:with-param>
            <xsl:with-param name="bdrSide" select="$bdrSide_left"/>
        </xsl:call-template>

        <xsl:call-template name="ApplyBorderPr">
            <xsl:with-param name="pr.bdr">
                <xsl:for-each select="$lastColBorders/w:left[1]">
                    <xsl:call-template name="GetBorderPr"/>
                </xsl:for-each>
            </xsl:with-param>
            <xsl:with-param name="bdrSide" select="$bdrSide_left"/>
        </xsl:call-template>

        <xsl:call-template name="ApplyBorderPr">
            <xsl:with-param name="pr.bdr">
                <xsl:for-each select="$lastRowBorders/w:right[1]">
                    <xsl:call-template name="GetBorderPr"/>
                </xsl:for-each>
            </xsl:with-param>
            <xsl:with-param name="bdrSide" select="$bdrSide_right"/>
        </xsl:call-template>

        <xsl:call-template name="ApplyBorderPr">
            <xsl:with-param name="pr.bdr">
                <xsl:for-each select="$lastColBorders/w:right[1]">
                    <xsl:call-template name="GetBorderPr"/>
                </xsl:for-each>
            </xsl:with-param>
            <xsl:with-param name="bdrSide" select="$bdrSide_right"/>
        </xsl:call-template>

        <xsl:call-template name="ApplyBorderPr">
            <xsl:with-param name="pr.bdr">
                <xsl:for-each select="$lastColBorders/w:bottom[1]">
                    <xsl:call-template name="GetBorderPr"/>
                </xsl:for-each>
            </xsl:with-param>
            <xsl:with-param name="bdrSide" select="$bdrSide_bottom"/>
        </xsl:call-template>

        <xsl:call-template name="ApplyBorderPr">
            <xsl:with-param name="pr.bdr">
                <xsl:for-each select="$lastRowBorders/w:bottom[1]">
                    <xsl:call-template name="GetBorderPr"/>
                </xsl:for-each>
            </xsl:with-param>
            <xsl:with-param name="bdrSide" select="$bdrSide_bottom"/>
        </xsl:call-template>

    </xsl:template>

    <xsl:template name="ApplyExtraCornerBordersSW">
        <xsl:param name="sTblStyle"/>

        <xsl:variable name="firstColBorders"
                      select="$sTblStyle/w:tblStylePr[@w:type=$cnfFirstCol][1]/w:tcPr[1]/w:tcBorders[1]"/>
        <xsl:variable name="lastRowBorders"
                      select="$sTblStyle/w:tblStylePr[@w:type=$cnfLastRow][1]/w:tcPr[1]/w:tcBorders[1]"/>

        <xsl:call-template name="ApplyBorderPr">
            <xsl:with-param name="pr.bdr">
                <xsl:for-each select="$lastRowBorders/w:top[1]">
                    <xsl:call-template name="GetBorderPr"/>
                </xsl:for-each>
            </xsl:with-param>
            <xsl:with-param name="bdrSide" select="$bdrSide_top"/>
        </xsl:call-template>

        <xsl:call-template name="ApplyBorderPr">
            <xsl:with-param name="pr.bdr">
                <xsl:for-each select="$firstColBorders/w:top[1]">
                    <xsl:call-template name="GetBorderPr"/>
                </xsl:for-each>
            </xsl:with-param>
            <xsl:with-param name="bdrSide" select="$bdrSide_top"/>
        </xsl:call-template>

        <xsl:call-template name="ApplyBorderPr">
            <xsl:with-param name="pr.bdr">
                <xsl:for-each select="$lastRowBorders/w:left[1]">
                    <xsl:call-template name="GetBorderPr"/>
                </xsl:for-each>
            </xsl:with-param>
            <xsl:with-param name="bdrSide" select="$bdrSide_left"/>
        </xsl:call-template>

        <xsl:call-template name="ApplyBorderPr">
            <xsl:with-param name="pr.bdr">
                <xsl:for-each select="$firstColBorders/w:left[1]">
                    <xsl:call-template name="GetBorderPr"/>
                </xsl:for-each>
            </xsl:with-param>
            <xsl:with-param name="bdrSide" select="$bdrSide_left"/>
        </xsl:call-template>

        <xsl:call-template name="ApplyBorderPr">
            <xsl:with-param name="pr.bdr">
                <xsl:for-each select="$lastRowBorders/w:right[1]">
                    <xsl:call-template name="GetBorderPr"/>
                </xsl:for-each>
            </xsl:with-param>
            <xsl:with-param name="bdrSide" select="$bdrSide_right"/>
        </xsl:call-template>

        <xsl:call-template name="ApplyBorderPr">
            <xsl:with-param name="pr.bdr">
                <xsl:for-each select="$firstColBorders/w:right[1]">
                    <xsl:call-template name="GetBorderPr"/>
                </xsl:for-each>
            </xsl:with-param>
            <xsl:with-param name="bdrSide" select="$bdrSide_right"/>
        </xsl:call-template>

        <xsl:call-template name="ApplyBorderPr">
            <xsl:with-param name="pr.bdr">
                <xsl:for-each select="$lastRowBorders/w:bottom[1]">
                    <xsl:call-template name="GetBorderPr"/>
                </xsl:for-each>
            </xsl:with-param>
            <xsl:with-param name="bdrSide" select="$bdrSide_bottom"/>
        </xsl:call-template>

        <xsl:call-template name="ApplyBorderPr">
            <xsl:with-param name="pr.bdr">
                <xsl:for-each select="$firstColBorders/w:bottom[1]">
                    <xsl:call-template name="GetBorderPr"/>
                </xsl:for-each>
            </xsl:with-param>
            <xsl:with-param name="bdrSide" select="$bdrSide_bottom"/>
        </xsl:call-template>
    </xsl:template>

    <xsl:template name="ApplyTcBordersFromCnf">
        <xsl:param name="tcBorders"/>
        <xsl:param name="sTblStyleName"/>
        <xsl:param name="cnfType"/>
        <xsl:param name="thisRow"/>
        <xsl:param name="lastRow"/>
        <xsl:param name="bdr.top"/>
        <xsl:param name="bdr.left"/>
        <xsl:param name="bdr.bottom"/>
        <xsl:param name="bdr.right"/>
        <xsl:param name="bdrSide_right.bidi"/>
        <xsl:param name="bdrSide_left.bidi"/>

        <xsl:variable name="thisBdr.top">
            <xsl:choose>
                <xsl:when test="$tcBorders/w:top">
                    <xsl:for-each select="$tcBorders/w:top[1]">
                        <xsl:call-template name="GetBorderPr"/>
                    </xsl:for-each>
                </xsl:when>
                <xsl:when test="not($cnfType='')">
                    <xsl:choose>
                        <xsl:when
                                test="$cnfType=$cnfBand1Vert or $cnfType=$cnfBand2Vert or $cnfType=$cnfFirstCol or $cnfType=$cnfLastCol">
                            <xsl:variable name="p.cnfFirstRow"
                                          select="$sTblStyleName/w:tblStylePr[@w:type=$cnfFirstRow][1]"/>
                            <xsl:choose>
                                <xsl:when test="$p.cnfFirstRow and $thisRow=2">
                                    <xsl:for-each
                                            select="$sTblStyleName/w:tblStylePr[@w:type=$cnfType][1]/w:tcPr[1]/w:tcBorders[1]/w:top[1]">
                                        <xsl:call-template name="GetBorderPr"/>
                                    </xsl:for-each>
                                </xsl:when>
                                <xsl:when test="not($p.cnfFirstRow) and $thisRow=1">
                                    <xsl:for-each
                                            select="$sTblStyleName/w:tblStylePr[@w:type=$cnfType][1]/w:tcPr[1]/w:tcBorders[1]/w:top[1]">
                                        <xsl:call-template name="GetBorderPr"/>
                                    </xsl:for-each>
                                </xsl:when>
                                <xsl:otherwise>
                                    <xsl:for-each
                                            select="$sTblStyleName/w:tblStylePr[@w:type=$cnfType][1]/w:tcPr[1]/w:tcBorders[1]/w:insideH[1]">
                                        <xsl:call-template name="GetBorderPr"/>
                                    </xsl:for-each>
                                </xsl:otherwise>
                            </xsl:choose>
                        </xsl:when>
                        <xsl:otherwise>
                            <xsl:for-each
                                    select="$sTblStyleName/w:tblStylePr[@w:type=$cnfType][1]/w:tcPr[1]/w:tcBorders[1]/w:top[1]">
                                <xsl:call-template name="GetBorderPr"/>
                            </xsl:for-each>
                        </xsl:otherwise>
                    </xsl:choose>
                </xsl:when>
                <xsl:otherwise>
                    <xsl:value-of select="$bdr.top"/>
                </xsl:otherwise>
            </xsl:choose>
        </xsl:variable>
        <xsl:variable name="thisBdr.bottom">
            <xsl:choose>
                <xsl:when test="$tcBorders/w:bottom">
                    <xsl:for-each select="$tcBorders/w:bottom[1]">
                        <xsl:call-template name="GetBorderPr"/>
                    </xsl:for-each>
                </xsl:when>
                <xsl:when test="not($cnfType='')">
                    <xsl:choose>
                        <xsl:when
                                test="$cnfType=$cnfBand1Vert or $cnfType=$cnfBand2Vert or $cnfType=$cnfFirstCol or $cnfType=$cnfLastCol">
                            <xsl:variable name="p.cnfLastRow"
                                          select="$sTblStyleName/w:tblStylePr[@w:type=$cnfLastRow][1]"/>
                            <xsl:choose>
                                <xsl:when test="$p.cnfLastRow and $thisRow=$lastRow - 1">
                                    <xsl:for-each
                                            select="$sTblStyleName/w:tblStylePr[@w:type=$cnfType][1]/w:tcPr[1]/w:tcBorders[1]/w:bottom[1]">
                                        <xsl:call-template name="GetBorderPr"/>
                                    </xsl:for-each>
                                </xsl:when>
                                <xsl:when test="not($p.cnfLastRow) and $thisRow=$lastRow">
                                    <xsl:for-each
                                            select="$sTblStyleName/w:tblStylePr[@w:type=$cnfType][1]/w:tcPr[1]/w:tcBorders[1]/w:bottom[1]">
                                        <xsl:call-template name="GetBorderPr"/>
                                    </xsl:for-each>
                                </xsl:when>
                                <xsl:otherwise>
                                    <xsl:for-each
                                            select="$sTblStyleName/w:tblStylePr[@w:type=$cnfType][1]/w:tcPr[1]/w:tcBorders[1]/w:insideH[1]">
                                        <xsl:call-template name="GetBorderPr"/>
                                    </xsl:for-each>
                                </xsl:otherwise>
                            </xsl:choose>
                        </xsl:when>
                        <xsl:otherwise>
                            <xsl:for-each
                                    select="$sTblStyleName/w:tblStylePr[@w:type=$cnfType][1]/w:tcPr[1]/w:tcBorders[1]/w:bottom[1]">
                                <xsl:call-template name="GetBorderPr"/>
                            </xsl:for-each>
                        </xsl:otherwise>
                    </xsl:choose>
                </xsl:when>
                <xsl:otherwise>
                    <xsl:value-of select="$bdr.bottom"/>
                </xsl:otherwise>
            </xsl:choose>
        </xsl:variable>
        <xsl:variable name="thisBdr.left">
            <xsl:choose>
                <xsl:when test="$tcBorders/w:left">
                    <xsl:for-each select="$tcBorders/w:left[1]">
                        <xsl:call-template name="GetBorderPr"/>
                    </xsl:for-each>
                </xsl:when>
                <xsl:when test="not($cnfType='')">
                    <xsl:choose>
                        <xsl:when test="$cnfType=$cnfBand1Horz or $cnfType=$cnfBand2Horz">
                            <xsl:variable name="p.cnfFirstCol"
                                          select="$sTblStyleName/w:tblStylePr[@w:type=$cnfFirstCol][1]"/>
                            <xsl:choose>
                                <xsl:when test="$p.cnfFirstCol and position()=2">
                                    <xsl:for-each
                                            select="$sTblStyleName/w:tblStylePr[@w:type=$cnfType][1]/w:tcPr[1]/w:tcBorders[1]/w:left[1]">
                                        <xsl:call-template name="GetBorderPr"/>
                                    </xsl:for-each>
                                </xsl:when>
                                <xsl:when test="not($p.cnfFirstCol) and position()=1">
                                    <xsl:for-each
                                            select="$sTblStyleName/w:tblStylePr[@w:type=$cnfType][1]/w:tcPr[1]/w:tcBorders[1]/w:left[1]">
                                        <xsl:call-template name="GetBorderPr"/>
                                    </xsl:for-each>
                                </xsl:when>
                                <xsl:otherwise>
                                    <xsl:for-each
                                            select="$sTblStyleName/w:tblStylePr[@w:type=$cnfType][1]/w:tcPr[1]/w:tcBorders[1]/w:insideV[1]">
                                        <xsl:call-template name="GetBorderPr"/>
                                    </xsl:for-each>
                                </xsl:otherwise>
                            </xsl:choose>
                        </xsl:when>
                        <xsl:when test="$cnfType=$cnfFirstRow or $cnfType=$cnfLastRow">
                            <xsl:choose>
                                <xsl:when test="position()=1">
                                    <xsl:for-each
                                            select="$sTblStyleName/w:tblStylePr[@w:type=$cnfType][1]/w:tcPr[1]/w:tcBorders[1]/w:left[1]">
                                        <xsl:call-template name="GetBorderPr"/>
                                    </xsl:for-each>
                                </xsl:when>
                                <xsl:otherwise>
                                    <xsl:for-each
                                            select="$sTblStyleName/w:tblStylePr[@w:type=$cnfType][1]/w:tcPr[1]/w:tcBorders[1]/w:insideV[1]">
                                        <xsl:call-template name="GetBorderPr"/>
                                    </xsl:for-each>
                                </xsl:otherwise>
                            </xsl:choose>
                        </xsl:when>
                        <xsl:otherwise>
                            <xsl:for-each
                                    select="$sTblStyleName/w:tblStylePr[@w:type=$cnfType][1]/w:tcPr[1]/w:tcBorders[1]/w:left[1]">
                                <xsl:call-template name="GetBorderPr"/>
                            </xsl:for-each>
                        </xsl:otherwise>
                    </xsl:choose>
                </xsl:when>
                <xsl:otherwise>
                    <xsl:value-of select="$bdr.left"/>
                </xsl:otherwise>
            </xsl:choose>
        </xsl:variable>
        <xsl:variable name="thisBdr.right">
            <xsl:choose>
                <xsl:when test="$tcBorders/w:right">
                    <xsl:for-each select="$tcBorders/w:right[1]">
                        <xsl:call-template name="GetBorderPr"/>
                    </xsl:for-each>
                </xsl:when>
                <xsl:when test="not($cnfType='')">
                    <xsl:choose>
                        <xsl:when test="$cnfType=$cnfBand1Horz or $cnfType=$cnfBand2Horz">
                            <xsl:variable name="p.cnfLastCol"
                                          select="$sTblStyleName/w:tblStylePr[@w:type=$cnfLastCol][1]"/>
                            <xsl:choose>
                                <xsl:when test="$p.cnfLastCol and position()=last() - 1">
                                    <xsl:for-each
                                            select="$sTblStyleName/w:tblStylePr[@w:type=$cnfType][1]/w:tcPr[1]/w:tcBorders[1]/w:right[1]">
                                        <xsl:call-template name="GetBorderPr"/>
                                    </xsl:for-each>
                                </xsl:when>
                                <xsl:when test="not($p.cnfLastCol) and position()=last()">
                                    <xsl:for-each
                                            select="$sTblStyleName/w:tblStylePr[@w:type=$cnfType][1]/w:tcPr[1]/w:tcBorders[1]/w:right[1]">
                                        <xsl:call-template name="GetBorderPr"/>
                                    </xsl:for-each>
                                </xsl:when>
                                <xsl:otherwise>
                                    <xsl:for-each
                                            select="$sTblStyleName/w:tblStylePr[@w:type=$cnfType][1]/w:tcPr[1]/w:tcBorders[1]/w:insideV[1]">
                                        <xsl:call-template name="GetBorderPr"/>
                                    </xsl:for-each>
                                </xsl:otherwise>
                            </xsl:choose>
                        </xsl:when>
                        <xsl:when test="$cnfType=$cnfFirstRow or $cnfType=$cnfLastRow">
                            <xsl:choose>
                                <xsl:when test="position()=last()">
                                    <xsl:for-each
                                            select="$sTblStyleName/w:tblStylePr[@w:type=$cnfType][1]/w:tcPr[1]/w:tcBorders[1]/w:right[1]">
                                        <xsl:call-template name="GetBorderPr"/>
                                    </xsl:for-each>
                                </xsl:when>
                                <xsl:otherwise>
                                    <xsl:for-each
                                            select="$sTblStyleName/w:tblStylePr[@w:type=$cnfType][1]/w:tcPr[1]/w:tcBorders[1]/w:insideV[1]">
                                        <xsl:call-template name="GetBorderPr"/>
                                    </xsl:for-each>
                                </xsl:otherwise>
                            </xsl:choose>
                        </xsl:when>
                        <xsl:otherwise>
                            <xsl:for-each
                                    select="$sTblStyleName/w:tblStylePr[@w:type=$cnfType][1]/w:tcPr[1]/w:tcBorders[1]/w:right[1]">
                                <xsl:call-template name="GetBorderPr"/>
                            </xsl:for-each>
                        </xsl:otherwise>
                    </xsl:choose>
                </xsl:when>
                <xsl:otherwise>
                    <xsl:value-of select="$bdr.right"/>
                </xsl:otherwise>
            </xsl:choose>
        </xsl:variable>

        <xsl:call-template name="ApplyBorderPr">
            <xsl:with-param name="pr.bdr" select="$thisBdr.top"/>
            <xsl:with-param name="bdrSide" select="$bdrSide_top"/>
        </xsl:call-template>
        <xsl:call-template name="ApplyBorderPr">
            <xsl:with-param name="pr.bdr" select="$thisBdr.right"/>
            <xsl:with-param name="bdrSide" select="$bdrSide_right.bidi"/>
        </xsl:call-template>
        <xsl:call-template name="ApplyBorderPr">
            <xsl:with-param name="pr.bdr" select="$thisBdr.bottom"/>
            <xsl:with-param name="bdrSide" select="$bdrSide_bottom"/>
        </xsl:call-template>
        <xsl:call-template name="ApplyBorderPr">
            <xsl:with-param name="pr.bdr" select="$thisBdr.left"/>
            <xsl:with-param name="bdrSide" select="$bdrSide_left.bidi"/>
        </xsl:call-template>

    </xsl:template>

    <xsl:template name="ApplyTcPr.once">
        <xsl:param name="cellspacing"/>
        <xsl:param name="cellpadding.default"/>
        <xsl:param name="cellpadding.custom"/>
        <xsl:param name="bdr.top"/>
        <xsl:param name="bdr.left"/>
        <xsl:param name="bdr.bottom"/>
        <xsl:param name="bdr.right"/>
        <xsl:param name="bdr.insideV"/>
        <xsl:param name="thisRow"/>
        <xsl:param name="lastRow"/>
        <xsl:param name="sTblStyleName"/>
        <xsl:param name="cnfRow"/>
        <xsl:param name="cnfCol"/>
        <xsl:param name="b.bidivisual"/>

        <xsl:variable name="cnfType">
            <xsl:if test="not($cnfRow='' and $cnfCol='')">
                <xsl:call-template name="GetCnfType">
                    <xsl:with-param name="cnfRow" select="$cnfRow"/>
                    <xsl:with-param name="cnfCol" select="$cnfCol"/>
                </xsl:call-template>
            </xsl:if>
        </xsl:variable>

        <xsl:variable name="cnfTypeRow">
            <xsl:if test="not($cnfRow='')">
                <xsl:call-template name="GetCnfTypeRow">
                    <xsl:with-param name="cnfRow" select="$cnfRow"/>
                </xsl:call-template>
            </xsl:if>
        </xsl:variable>

        <xsl:variable name="cnfTypeCol">
            <xsl:if test="not($cnfCol='')">
                <xsl:call-template name="GetCnfTypeCol">
                    <xsl:with-param name="cnfCol" select="$cnfCol"/>
                </xsl:call-template>
            </xsl:if>
        </xsl:variable>

        <xsl:variable name="tcborders" select="w:tcPr[1]/w:tcBorders[1]"/>

        <xsl:variable name="bdrSide_left.bidi">
            <xsl:choose>
                <xsl:when test="$b.bidivisual = $on">
                    <xsl:value-of select="$bdrSide_right"/>
                </xsl:when>
                <xsl:otherwise>
                    <xsl:value-of select="$bdrSide_left"/>
                </xsl:otherwise>
            </xsl:choose>
        </xsl:variable>
        <xsl:variable name="bdrSide_right.bidi">
            <xsl:choose>
                <xsl:when test="$b.bidivisual = $on">
                    <xsl:value-of select="$bdrSide_left"/>
                </xsl:when>
                <xsl:otherwise>
                    <xsl:value-of select="$bdrSide_right"/>
                </xsl:otherwise>
            </xsl:choose>
        </xsl:variable>

        <xsl:for-each select="$sTblStyleName/w:tblPr[1]/w:tblBorders[1]">
            <xsl:call-template name="ApplyBorderPr">
                <xsl:with-param name="pr.bdr" select="$bdr.top"/>
                <xsl:with-param name="bdrSide" select="$bdrSide_top"/>
            </xsl:call-template>
            <xsl:call-template name="ApplyBorderPr">
                <xsl:with-param name="pr.bdr" select="$bdr.bottom"/>
                <xsl:with-param name="bdrSide" select="$bdrSide_bottom"/>
            </xsl:call-template>
            <xsl:call-template name="ApplyBorderPr">
                <xsl:with-param name="pr.bdr" select="$bdr.right"/>
                <xsl:with-param name="bdrSide" select="$bdrSide_right.bidi"/>
            </xsl:call-template>
            <xsl:call-template name="ApplyBorderPr">
                <xsl:with-param name="pr.bdr" select="$bdr.left"/>
                <xsl:with-param name="bdrSide" select="$bdrSide_left.bidi"/>
            </xsl:call-template>
        </xsl:for-each>

        <xsl:call-template name="ApplyExtraCornerBorders">
            <xsl:with-param name="cnfType" select="$cnfType"/>
            <xsl:with-param name="sTblStyleName" select="$sTblStyleName"/>
        </xsl:call-template>

        <xsl:call-template name="ApplyTcBordersFromCnf">
            <xsl:with-param name="cnfType" select="$cnfTypeRow"/>
            <xsl:with-param name="sTblStyleName" select="$sTblStyleName"/>
            <xsl:with-param name="tcBorders" select="$tcborders"/>
            <xsl:with-param name="bdrSide_right.bidi" select="$bdrSide_right.bidi"/>
            <xsl:with-param name="bdrSide_left.bidi" select="$bdrSide_left.bidi"/>
            <xsl:with-param name="thisRow" select="$thisRow"/>
            <xsl:with-param name="lastRow" select="$lastRow"/>

            <xsl:with-param name="bdr.top" select="$bdr.top"/>
            <xsl:with-param name="bdr.left" select="$bdr.left"/>
            <xsl:with-param name="bdr.right" select="$bdr.right"/>
            <xsl:with-param name="bdr.bottom" select="$bdr.bottom"/>
        </xsl:call-template>

        <xsl:call-template name="ApplyTcBordersFromCnf">
            <xsl:with-param name="cnfType" select="$cnfTypeCol"/>
            <xsl:with-param name="sTblStyleName" select="$sTblStyleName"/>
            <xsl:with-param name="tcBorders" select="$tcborders"/>
            <xsl:with-param name="bdrSide_right.bidi" select="$bdrSide_right.bidi"/>
            <xsl:with-param name="bdrSide_left.bidi" select="$bdrSide_left.bidi"/>
            <xsl:with-param name="thisRow" select="$thisRow"/>
            <xsl:with-param name="lastRow" select="$lastRow"/>

            <xsl:with-param name="bdr.top" select="$bdr.top"/>
            <xsl:with-param name="bdr.left" select="$bdr.left"/>
            <xsl:with-param name="bdr.right" select="$bdr.right"/>
            <xsl:with-param name="bdr.bottom" select="$bdr.bottom"/>
        </xsl:call-template>

        <xsl:variable name="cellpadding.custom.merged">

            <xsl:variable name="temp.direct">
                <xsl:for-each select="w:tcPr[1]/w:tcMar[1]">
                    <xsl:call-template name="ApplyCellMar"/>
                </xsl:for-each>
            </xsl:variable>
            <xsl:value-of select="$temp.direct"/>
            <xsl:if test="$temp.direct=''">

                <xsl:variable name="temp.cnf">
                    <xsl:for-each select="$sTblStyleName">
                        <xsl:call-template name="GetCnfPr.cell">
                            <xsl:with-param name="type" select="$prrCustomCellpadding"/>
                            <xsl:with-param name="cnfCol" select="$cnfCol"/>
                            <xsl:with-param name="cnfRow" select="$cnfRow"/>
                        </xsl:call-template>
                    </xsl:for-each>
                </xsl:variable>
                <xsl:value-of select="$temp.cnf"/>
                <xsl:if test="$temp.cnf=''">

                    <xsl:value-of select="$cellpadding.custom"/>
                </xsl:if>
            </xsl:if>
        </xsl:variable>
        <xsl:variable name="cellpadding.default.merged">

            <xsl:variable name="temp.cnf">
                <xsl:for-each select="$sTblStyleName">
                    <xsl:call-template name="GetCnfPr.cell">
                        <xsl:with-param name="type" select="$prrDefaultCellpadding"/>
                        <xsl:with-param name="cnfCol" select="$cnfCol"/>
                        <xsl:with-param name="cnfRow" select="$cnfRow"/>
                    </xsl:call-template>
                </xsl:for-each>
            </xsl:variable>
            <xsl:value-of select="$temp.cnf"/>
            <xsl:if test="$temp.cnf=''">

                <xsl:value-of select="$cellpadding.default"/>
            </xsl:if>
        </xsl:variable>
        <xsl:choose>
            <xsl:when test="$cellpadding.custom.merged = 'none' and not($cellpadding.default.merged='')">
                <xsl:value-of select="$cellpadding.default.merged"/>
            </xsl:when>
            <xsl:when test="not($cellpadding.custom.merged='')">
                <xsl:value-of select="$cellpadding.custom.merged"/>
            </xsl:when>
            <xsl:when test="not($cellpadding.default.merged='')">
                <xsl:value-of select="$cellpadding.default.merged"/>
            </xsl:when>
        </xsl:choose>
    </xsl:template>

    <xsl:template match="w:tc">
        <xsl:param name="sTblStyleName" select="($nsStyles[@w:styleId=$tblStyleID_Default])[1]"/>
        <xsl:param name="prsPAccum"/>
        <xsl:param name="prsP"/>
        <xsl:param name="prsR"/>
        <xsl:param name="cellspacing"/>
        <xsl:param name="cellpadding.default"/>
        <xsl:param name="cellpadding.custom"/>
        <xsl:param name="bdr.top"/>
        <xsl:param name="bdr.left"/>
        <xsl:param name="bdr.bottom"/>
        <xsl:param name="bdr.right"/>
        <xsl:param name="bdr.insideV"/>
        <xsl:param name="bdr.insideH"/>
        <xsl:param name="thisRow"/>
        <xsl:param name="lastRow"/>
        <xsl:param name="cnfRow"/>
        <xsl:param name="b.bidivisual"/>
        <xsl:variable name="cnfCol" select="string(w:tcPr[1]/w:cnfStyle[1]/@w:val)"/>
        <xsl:variable name="vmerge" select="w:tcPr[1]/w:vMerge[1]"/>
        <xsl:variable name="me" select="."/>
        <xsl:variable name="tblCount" select="count(ancestor::w:tbl)"/>
        <xsl:variable name="meInContext"
                      select="ancestor::w:tr[1]/*[count($me|descendant-or-self::*)=count(descendant-or-self::*)]"/>
        <xsl:variable name="before"
                      select="count($meInContext/preceding-sibling::*[descendant-or-self::*[name()='w:tc' and (count(ancestor::w:tbl)=$tblCount)]])"/>
        <xsl:variable name="after"
                      select="count($meInContext/following-sibling::*[descendant-or-self::*[name()='w:tc' and (count(ancestor::w:tbl)=$tblCount)]])"/>
        <!-- TO FIX THE COVERPAGE issue added by Shbuh
    <xsl:variable name="tStyleId" />
    <xsl:attribute name="class">
      <xsl:value-of select="$tStyleId"/>
      <xsl:value-of select="$tblStyleSuffix"/>
    </xsl:attribute>
    <xsl:variable name="sTblStyleName" select="($nsStyles[@w:styleId=$tStyleId])[1]"/>
    TO FIX THE COVERPAGE issue added by Shbuha-->
        <xsl:if test="not($vmerge and not($vmerge/@w:val))">
            <td>

                <xsl:attribute name="class">
                    <xsl:value-of select="$sTblStyleName/@w:styleId"/>
                    <xsl:value-of select="$cellStyleSuffix"/>
                </xsl:attribute>

                <xsl:for-each select="w:tcPr[1]/w:gridSpan[1]/@w:val">
                    <xsl:attribute name="colspan">
                        <xsl:value-of select="."/>
                    </xsl:attribute>
                </xsl:for-each>

                <xsl:variable name="rowspan">
                    <xsl:choose>
                        <xsl:when test="not($vmerge)">1</xsl:when>

                        <xsl:otherwise>
                            <xsl:variable name="myRow" select="ancestor::w:tr[1]"/>
                            <xsl:variable name="myRowInContext"
                                          select="$myRow/ancestor::w:tbl[1]/*[count($myRow|descendant-or-self::*)=count(descendant-or-self::*)]"/>
                            <xsl:variable name="belowMe"
                                          select="$myRowInContext/following-sibling::*//w:tc[count(ancestor::w:tbl)=$tblCount][$before + 1]"/>
                            <xsl:variable name="NextRestart" select="($belowMe//w:tcPr/w:vMerge[@w:val='restart'])[1]"/>
                            <xsl:variable name="NextRestartInContext"
                                          select="$NextRestart/ancestor::w:tbl[1]/*[count($NextRestart|descendant-or-self::*)=count(descendant-or-self::*)]"/>
                            <xsl:variable name="mergesAboveMe"
                                          select="count($myRowInContext/preceding-sibling::*[(descendant-or-self::*[name()='w:tc'])[$before + 1][descendant-or-self::*[name()='w:vMerge']]])"/>
                            <xsl:variable name="mergesAboveNextRestart"
                                          select="count($NextRestartInContext/preceding-sibling::*[(descendant-or-self::*[name()='w:tc'])[$before + 1][descendant-or-self::*[name()='w:vMerge']]])"/>

                            <xsl:choose>
                                <xsl:when test="$NextRestart">
                                    <xsl:value-of select="$mergesAboveNextRestart - $mergesAboveMe"/>
                                </xsl:when>
                                <xsl:when test="$vmerge/@w:val">
                                    <xsl:value-of
                                            select="count($belowMe[descendant-or-self::*[name()='w:vMerge']]) + 1"/>
                                </xsl:when>
                                <xsl:otherwise>1</xsl:otherwise>
                            </xsl:choose>
                        </xsl:otherwise>
                    </xsl:choose>
                </xsl:variable>

                <xsl:if test="$vmerge">
                    <xsl:attribute name="rowspan">
                        <xsl:value-of select="$rowspan"/>
                    </xsl:attribute>
                </xsl:if>
                <xsl:variable name="lastRow.updated" select="$lastRow - $rowspan + 1"/>

                <xsl:variable name="bdr.bottom.updated">
                    <xsl:choose>
                        <xsl:when test="$cellspacing='' and $thisRow=$lastRow.updated">
                            <xsl:value-of select="$bdr.bottom"/>
                        </xsl:when>
                        <xsl:otherwise>
                            <xsl:value-of select="$bdr.insideH"/>
                        </xsl:otherwise>
                    </xsl:choose>
                </xsl:variable>
                <xsl:variable name="bdr.left.updated">
                    <xsl:choose>
                        <xsl:when test="$cellspacing='' and $before=0">
                            <xsl:value-of select="$bdr.left"/>
                        </xsl:when>
                        <xsl:otherwise>
                            <xsl:value-of select="$bdr.insideV"/>
                        </xsl:otherwise>
                    </xsl:choose>
                </xsl:variable>
                <xsl:variable name="bdr.right.updated">
                    <xsl:choose>
                        <xsl:when test="$cellspacing='' and $after=0">
                            <xsl:value-of select="$bdr.right"/>
                        </xsl:when>
                        <xsl:otherwise>
                            <xsl:value-of select="$bdr.insideV"/>
                        </xsl:otherwise>
                    </xsl:choose>
                </xsl:variable>

                <xsl:attribute name="style">

                    <xsl:if test="not($cnfRow='' and $cnfCol='')">
                        <xsl:for-each select="$sTblStyleName">
                            <xsl:call-template name="GetCnfPr.all">
                                <xsl:with-param name="type" select="$prrApplyTcPr"/>
                                <xsl:with-param name="cnfRow" select="$cnfRow"/>
                                <xsl:with-param name="cnfCol" select="$cnfCol"/>
                            </xsl:call-template>
                        </xsl:for-each>
                    </xsl:if>

                    <xsl:call-template name="ApplyTcPr.class"/>
                    <xsl:call-template name="ApplyTcPr.once">
                        <xsl:with-param name="thisRow" select="$thisRow"/>
                        <xsl:with-param name="lastRow" select="$lastRow.updated"/>
                        <xsl:with-param name="cellspacing" select="$cellspacing"/>
                        <xsl:with-param name="cellpadding.default" select="$cellpadding.default"/>
                        <xsl:with-param name="cellpadding.custom" select="$cellpadding.custom"/>
                        <xsl:with-param name="bdr.top" select="$bdr.top"/>
                        <xsl:with-param name="bdr.left" select="$bdr.left.updated"/>
                        <xsl:with-param name="bdr.right" select="$bdr.right.updated"/>
                        <xsl:with-param name="bdr.bottom" select="$bdr.bottom.updated"/>
                        <xsl:with-param name="bdr.insideV" select="$bdr.insideV"/>
                        <xsl:with-param name="sTblStyleName" select="$sTblStyleName"/>
                        <xsl:with-param name="cnfRow" select="$cnfRow"/>
                        <xsl:with-param name="cnfCol" select="$cnfCol"/>
                        <xsl:with-param name="b.bidivisual" select="$b.bidivisual"/>
                    </xsl:call-template>
                </xsl:attribute>
                <xsl:choose>
                    <xsl:when test="$cnfRow='' and $cnfCol=''">

                        <xsl:call-template name="DisplayBodyContent">
                            <xsl:with-param name="ns.content" select="*"/>
                            <xsl:with-param name="prsPAccum" select="$prsPAccum"/>
                            <xsl:with-param name="prsP" select="$prsP"/>
                            <xsl:with-param name="prsR" select="$prsR"/>
                        </xsl:call-template>
                    </xsl:when>
                    <xsl:otherwise>

                        <xsl:call-template name="WrapCnf">
                            <xsl:with-param name="sTblStyleName" select="$sTblStyleName"/>
                            <xsl:with-param name="cnfRow" select="$cnfRow"/>
                            <xsl:with-param name="cnfCol" select="$cnfCol"/>
                            <xsl:with-param name="prsPAccum" select="$prsPAccum"/>
                            <xsl:with-param name="prsP" select="$prsP"/>
                            <xsl:with-param name="prsR" select="$prsR"/>
                        </xsl:call-template>
                    </xsl:otherwise>
                </xsl:choose>
            </td>
        </xsl:if>
    </xsl:template>

    <xsl:template name="RecursiveApplyTrPr.class">
        <xsl:if test="w:basedOn">
            <xsl:variable name="baseStyleName" select="w:basedOn[1]/@w:val"/>
            <xsl:variable name="sTblStyleBase" select="($nsStyles[@w:styleId=$baseStyleName])[1]"/>
            <xsl:for-each select="$sTblStyleBase">
                <xsl:call-template name="RecursiveApplyTrPr.class"/>
            </xsl:for-each>
        </xsl:if>

        <xsl:call-template name="ApplyTrPr.class"/>
    </xsl:template>

    <xsl:template name="ApplyTrPr.class">
        <xsl:for-each select="w:trPr">

            <xsl:text>height:</xsl:text>
            <xsl:choose>
                <xsl:when test="w:trHeight/@w:val">
                    <xsl:value-of select="w:trHeight[1]/@w:val div 20"/>pt
                </xsl:when>
                <xsl:otherwise>0</xsl:otherwise>
            </xsl:choose>
            <xsl:text>;</xsl:text>

            <xsl:for-each select="w:cantSplit[1]">
                <xsl:choose>
                    <xsl:when test="@w:val = 'off'">page-break-inside:auto;</xsl:when>
                    <xsl:otherwise>page-break-inside:avoid;</xsl:otherwise>
                </xsl:choose>
            </xsl:for-each>
        </xsl:for-each>
    </xsl:template>

    <xsl:template name="DisplayEmptyCell">
        <xsl:param name="i" select="1"/>
        <td colspan="$i"></td>
    </xsl:template>

    <xsl:template match="w:tr">
        <xsl:param name="sTblStyleName"/>
        <xsl:param name="prsPAccum"/>
        <xsl:param name="prsP"/>
        <xsl:param name="prsR"/>
        <xsl:param name="cellspacing"/>
        <xsl:param name="cellpadding.default"/>
        <xsl:param name="cellpadding.custom"/>
        <xsl:param name="bdr.top"/>
        <xsl:param name="bdr.left"/>
        <xsl:param name="bdr.bottom"/>
        <xsl:param name="bdr.right"/>
        <xsl:param name="bdr.insideH"/>
        <xsl:param name="bdr.insideV"/>
        <xsl:param name="b.bidivisual"/>
        <tr>

            <xsl:attribute name="class">
                <xsl:value-of select="$sTblStyleName/@w:styleId"/>
                <xsl:value-of select="$rowStyleSuffix"/>
            </xsl:attribute>

            <xsl:variable name="cnfRow" select="string(w:trPr[1]/w:cnfStyle[1]/@w:val)"/>

            <xsl:variable name="styleMod">

                <xsl:if test="not($cnfRow='')">
                    <xsl:for-each select="$sTblStyleName">
                        <xsl:call-template name="GetCnfPr.row">
                            <xsl:with-param name="type" select="$prrCantSplit"/>
                            <xsl:with-param name="cnfRow" select="$cnfRow"/>
                        </xsl:call-template>
                    </xsl:for-each>
                </xsl:if>

                <xsl:call-template name="ApplyTrPr.class"/>
            </xsl:variable>
            <xsl:if test="not($styleMod='')">
                <xsl:attribute name="style">
                    <xsl:value-of select="$styleMod"/>
                </xsl:attribute>
            </xsl:if>

            <xsl:variable name="me" select="."/>
            <xsl:variable name="tblCount" select="count(ancestor::w:tbl)"/>
            <xsl:variable name="meInContext"
                          select="ancestor::w:tbl[1]/*[count($me|descendant-or-self::*)=count(descendant-or-self::*)]"/>
            <xsl:variable name="before"
                          select="count($meInContext/preceding-sibling::*[descendant-or-self::*[name()='w:tr' and (count(ancestor::w:tbl)=$tblCount)]])"/>
            <xsl:variable name="after"
                          select="count($meInContext/following-sibling::*[descendant-or-self::*[name()='w:tr' and (count(ancestor::w:tbl)=$tblCount)]])"/>
            <xsl:variable name="thisRow" select="$before + 1"/>
            <xsl:variable name="lastRow" select="$before + $after + 1"/>

            <xsl:variable name="bdr.top.updated">
                <xsl:choose>
                    <xsl:when test="$cellspacing='' and $thisRow=1">
                        <xsl:value-of select="$bdr.top"/>
                    </xsl:when>
                    <xsl:otherwise>
                        <xsl:value-of select="$bdr.insideH"/>
                    </xsl:otherwise>
                </xsl:choose>
            </xsl:variable>

            <xsl:for-each select="w:trPr[1]/w:gridBefore[1]/@w:val">
                <xsl:call-template name="DisplayEmptyCell">
                    <xsl:with-param name="i">
                        <xsl:value-of select="."/>
                    </xsl:with-param>
                </xsl:call-template>
            </xsl:for-each>

            <xsl:apply-templates select="*[not(name()='w:trPr')]">
                <xsl:with-param name="sTblStyleName" select="$sTblStyleName"/>
                <xsl:with-param name="prsPAccum" select="$prsPAccum"/>
                <xsl:with-param name="prsP" select="$prsP"/>
                <xsl:with-param name="prsR" select="$prsR"/>
                <xsl:with-param name="thisRow" select="$thisRow"/>
                <xsl:with-param name="lastRow" select="$lastRow"/>
                <xsl:with-param name="cellspacing" select="$cellspacing"/>
                <xsl:with-param name="cellpadding.default" select="$cellpadding.default"/>
                <xsl:with-param name="cellpadding.custom" select="$cellpadding.custom"/>
                <xsl:with-param name="bdr.top" select="$bdr.top.updated"/>
                <xsl:with-param name="bdr.left" select="$bdr.left"/>
                <xsl:with-param name="bdr.right" select="$bdr.right"/>
                <xsl:with-param name="bdr.bottom" select="$bdr.bottom"/>
                <xsl:with-param name="bdr.insideV" select="$bdr.insideV"/>
                <xsl:with-param name="bdr.insideH" select="$bdr.insideH"/>
                <xsl:with-param name="cnfRow" select="$cnfRow"/>
                <xsl:with-param name="b.bidivisual" select="$b.bidivisual"/>
            </xsl:apply-templates>

            <xsl:for-each select="w:trPr[1]/w:gridAfter[1]/@w:val">
                <xsl:call-template name="DisplayEmptyCell">
                    <xsl:with-param name="i">
                        <xsl:value-of select="."/>
                    </xsl:with-param>
                </xsl:call-template>
            </xsl:for-each>
        </tr>
    </xsl:template>

    <xsl:template name="RecursiveApplyTblPr.class">
        <xsl:if test="w:basedOn">
            <xsl:variable name="baseStyleName" select="w:basedOn[1]/@w:val"/>
            <xsl:variable name="sTblStyleBase" select="($nsStyles[@w:styleId=$baseStyleName])[1]"/>
            <xsl:for-each select="$sTblStyleBase">
                <xsl:call-template name="RecursiveApplyTblPr.class"/>
            </xsl:for-each>
        </xsl:if>

        <xsl:call-template name="ApplyTblPr.class"/>
    </xsl:template>

    <xsl:template name="ApplyTblPr.class">
        <xsl:for-each select="w:tblPr[1]">

            <xsl:if test="w:tblpPr/@w:topFromText">
                margin-top:<xsl:value-of select="w:tblpPr/@w:topFromText[1] div 20"/>pt;
            </xsl:if>
            <xsl:if test="w:tblpPr/@w:rightFromText">
                margin-right:<xsl:value-of select="w:tblpPr/@w:rightFromText[1] div 20"/>pt;
            </xsl:if>
            <xsl:if test="w:tblpPr/@w:bottomFromText">
                margin-bottom:<xsl:value-of select="w:tblpPr/@w:bottomFromText[1] div 20"/>pt;
            </xsl:if>
            <xsl:if test="w:tblpPr/@w:leftFromText">
                margin-left:<xsl:value-of select="w:tblpPr/@w:leftFromText[1] div 20"/>pt;
            </xsl:if>

            <xsl:for-each select="w:tblW[1]">
                <xsl:if test="@w:type != 'auto'">
                    width:<xsl:call-template name="EvalTableWidth"/>;
                </xsl:if>
            </xsl:for-each>
        </xsl:for-each>
    </xsl:template>

    <xsl:template name="tblCore">
        <table>

            <xsl:variable name="tStyleId">
                <xsl:choose>
                    <xsl:when test="w:tblPr[1]/w:tblStyle[1]/@w:val">
                        <xsl:value-of select="w:tblPr[1]/w:tblStyle[1]/@w:val"/>
                    </xsl:when>
                    <xsl:otherwise>
                        <xsl:value-of select="$tblStyleID_Default"/>
                    </xsl:otherwise>
                </xsl:choose>
            </xsl:variable>
            <xsl:attribute name="class">
                <xsl:value-of select="$tStyleId"/>
                <xsl:value-of select="$tblStyleSuffix"/>
            </xsl:attribute>
            <xsl:variable name="sTblStyleName" select="($nsStyles[@w:styleId=$tStyleId])[1]"/>

            <xsl:variable name="cellspacingTEMP">
                <xsl:call-template name="GetSingleTblPr">
                    <xsl:with-param name="type" select="$prrCellspacing"/>
                    <xsl:with-param name="sTblStyleName" select="$sTblStyleName"/>
                </xsl:call-template>
            </xsl:variable>
            <xsl:variable name="cellspacing">
                <xsl:choose>

                    <xsl:when test="$cellspacingTEMP='0'"></xsl:when>
                    <xsl:otherwise>
                        <xsl:value-of select="$cellspacingTEMP"/>
                    </xsl:otherwise>
                </xsl:choose>
            </xsl:variable>
            <xsl:variable name="cellpadding.default">
                <xsl:call-template name="GetSingleTblPr">
                    <xsl:with-param name="type" select="$prrDefaultCellpadding"/>
                    <xsl:with-param name="sTblStyleName" select="$sTblStyleName"/>
                </xsl:call-template>
            </xsl:variable>
            <xsl:variable name="cellpadding.custom">
                <xsl:for-each select="$sTblStyleName/w:tcPr[1]/w:tcMar[1]">
                    <xsl:call-template name="ApplyCellMar"/>
                </xsl:for-each>
            </xsl:variable>

            <xsl:variable name="tblInd">
                <xsl:call-template name="GetSingleTblPr">
                    <xsl:with-param name="type" select="$prrTblInd"/>
                    <xsl:with-param name="sTblStyleName" select="$sTblStyleName"/>
                </xsl:call-template>
            </xsl:variable>

            <xsl:variable name="bdr.top">
                <xsl:call-template name="GetSingleTblPr">
                    <xsl:with-param name="type" select="$prrBdrPr_top"/>
                    <xsl:with-param name="sTblStyleName" select="$sTblStyleName"/>
                </xsl:call-template>
            </xsl:variable>
            <xsl:variable name="bdr.left">
                <xsl:call-template name="GetSingleTblPr">
                    <xsl:with-param name="type" select="$prrBdrPr_left"/>
                    <xsl:with-param name="sTblStyleName" select="$sTblStyleName"/>
                </xsl:call-template>
            </xsl:variable>
            <xsl:variable name="bdr.bottom">
                <xsl:call-template name="GetSingleTblPr">
                    <xsl:with-param name="type" select="$prrBdrPr_bottom"/>
                    <xsl:with-param name="sTblStyleName" select="$sTblStyleName"/>
                </xsl:call-template>
            </xsl:variable>
            <xsl:variable name="bdr.right">
                <xsl:call-template name="GetSingleTblPr">
                    <xsl:with-param name="type" select="$prrBdrPr_right"/>
                    <xsl:with-param name="sTblStyleName" select="$sTblStyleName"/>
                </xsl:call-template>
            </xsl:variable>

            <xsl:variable name="bdr.insideH">
                <xsl:call-template name="GetSingleTblPr">
                    <xsl:with-param name="type" select="$prrBdrPr_insideH"/>
                    <xsl:with-param name="sTblStyleName" select="$sTblStyleName"/>
                </xsl:call-template>
            </xsl:variable>
            <xsl:variable name="bdr.insideV">
                <xsl:call-template name="GetSingleTblPr">
                    <xsl:with-param name="type" select="$prrBdrPr_insideV"/>
                    <xsl:with-param name="sTblStyleName" select="$sTblStyleName"/>
                </xsl:call-template>
            </xsl:variable>

            <xsl:variable name="b.bidivisual">
                <xsl:for-each select="w:tblPr[1]/w:bidiVisual[1]">
                    <xsl:value-of select="$on"/>
                </xsl:for-each>
            </xsl:variable>

            <xsl:variable name="align">
                <xsl:for-each select="w:tblPr[1]/w:tblpPr[1]/@w:tblpXSpec">
                    <xsl:value-of select="."/>
                </xsl:for-each>
            </xsl:variable>
            <xsl:if test="not($align='')">
                <xsl:attribute name="align">
                    <xsl:choose>
                        <xsl:when test="$align = 'right' or $align = 'outside'">right</xsl:when>
                        <xsl:otherwise>left</xsl:otherwise>
                    </xsl:choose>
                </xsl:attribute>
            </xsl:if>

            <xsl:attribute name="cellspacing">
                <xsl:choose>
                    <xsl:when test="$cellspacing=''">0</xsl:when>
                    <xsl:otherwise>
                        <xsl:value-of select="($cellspacing div 1440) * $pixelsPerInch"/>
                    </xsl:otherwise>
                </xsl:choose>
            </xsl:attribute>
            <xsl:if test="$cellspacing=''">
                <xsl:attribute name="cellspacing">0</xsl:attribute>
            </xsl:if>

            <xsl:variable name="styleMod">
                <xsl:call-template name="ApplyTblPr.class"/>

                <xsl:choose>
                    <xsl:when test="$cellspacing=''">border-collapse:collapse;</xsl:when>
                    <xsl:otherwise>
                        <xsl:text>border-collapse:separate;</xsl:text>
                        <xsl:call-template name="ApplyBorderPr">
                            <xsl:with-param name="pr.bdr" select="$bdr.top"/>
                            <xsl:with-param name="bdrSide" select="$bdrSide_top"/>
                        </xsl:call-template>
                        <xsl:call-template name="ApplyBorderPr">
                            <xsl:with-param name="pr.bdr" select="$bdr.left"/>
                            <xsl:with-param name="bdrSide" select="$bdrSide_left"/>
                        </xsl:call-template>
                        <xsl:call-template name="ApplyBorderPr">
                            <xsl:with-param name="pr.bdr" select="$bdr.bottom"/>
                            <xsl:with-param name="bdrSide" select="$bdrSide_bottom"/>
                        </xsl:call-template>
                        <xsl:call-template name="ApplyBorderPr">
                            <xsl:with-param name="pr.bdr" select="$bdr.right"/>
                            <xsl:with-param name="bdrSide" select="$bdrSide_right"/>
                        </xsl:call-template>
                    </xsl:otherwise>
                </xsl:choose>

                <xsl:if test="$b.bidivisual=$on">direction:rtl;</xsl:if>

                <xsl:if test="not(w:tblPr/w:tblpPr)">
                    <xsl:text>margin-</xsl:text>
                    <xsl:choose>
                        <xsl:when test="$b.bidivisual=$on">right</xsl:when>
                        <xsl:otherwise>left</xsl:otherwise>
                    </xsl:choose>
                    <xsl:text>:</xsl:text>
                    <xsl:value-of select="$tblInd"/>
                    <xsl:text>;</xsl:text>
                </xsl:if>
            </xsl:variable>
            <xsl:if test="not($styleMod='')">
                <xsl:attribute name="style">
                    <xsl:value-of select="$styleMod"/>
                </xsl:attribute>
            </xsl:if>

            <xsl:variable name="prsPAccum">

                <xsl:for-each select="$sTblStyleName">
                    <xsl:call-template name="ApplyPPr.many"/>
                </xsl:for-each>
            </xsl:variable>

            <xsl:variable name="prsR">
                <xsl:call-template name="PrsUpdateRPr">
                    <xsl:with-param name="ndPrContainer" select="$sTblStyleName"/>
                </xsl:call-template>
            </xsl:variable>

            <xsl:variable name="prsP">
                <xsl:call-template name="PrsUpdatePPr">
                    <xsl:with-param name="ndPrContainer" select="$sTblStyleName"/>
                </xsl:call-template>
            </xsl:variable>

            <xsl:apply-templates select="*[not(name()='w:tblPr' or name()='w:tblGrid')]">
                <xsl:with-param name="sTblStyleName" select="$sTblStyleName"/>
                <xsl:with-param name="prsPAccum" select="$prsPAccum"/>
                <xsl:with-param name="prsP" select="$prsP"/>
                <xsl:with-param name="prsR" select="$prsR"/>
                <xsl:with-param name="cellspacing" select="$cellspacing"/>
                <xsl:with-param name="cellpadding.default" select="$cellpadding.default"/>
                <xsl:with-param name="cellpadding.custom" select="$cellpadding.custom"/>
                <xsl:with-param name="bdr.top" select="$bdr.top"/>
                <xsl:with-param name="bdr.left" select="$bdr.left"/>
                <xsl:with-param name="bdr.right" select="$bdr.right"/>
                <xsl:with-param name="bdr.bottom" select="$bdr.bottom"/>
                <xsl:with-param name="bdr.insideH" select="$bdr.insideH"/>
                <xsl:with-param name="bdr.insideV" select="$bdr.insideV"/>
                <xsl:with-param name="b.bidivisual" select="$b.bidivisual"/>
            </xsl:apply-templates>


            <xsl:for-each select="w:tblGrid[1]">
                <!--<xsl:text disable-output-escaping="yes">&lt;![if !supportMisalignedColumns]&gt;</xsl:text>-->
                <tr height="0">
                    <xsl:for-each select="w:gridCol">
                        <xsl:variable name="gridStyle">
                            margin:0;padding:0;border:none;width:<xsl:call-template name="EvalTableWidth"/>;
                        </xsl:variable>
                        <td style="{$gridStyle}"/>
                    </xsl:for-each>
                </tr>
                <!--<xsl:text disable-output-escaping="yes">&lt;![endif]&gt;</xsl:text>-->
            </xsl:for-each>
        </table>
    </xsl:template>

    <xsl:template match="w:tbl[w:tblPr/w:jc/@w:val]">
        <xsl:variable name="p.Jc" select="w:tblPr/w:jc/@w:val"/>
        <div>
            <xsl:attribute name="align">
                <xsl:value-of select="$p.Jc"/>
            </xsl:attribute>

            <xsl:call-template name="tblCore"/>
        </div>
    </xsl:template>

    <xsl:template match="w:tbl">
        <xsl:call-template name="tblCore"/>
    </xsl:template>

    <xsl:template name="hrCore">
        <xsl:param name="p.Hr"/>
        <hr>
            <xsl:attribute name="style">
                <xsl:value-of select="substring-after($p.Hr/@style, ';')"/>
            </xsl:attribute>
            <xsl:attribute name="align">
                <xsl:value-of select="$p.Hr/@o:hralign"/>
            </xsl:attribute>
            <xsl:if test="$p.Hr/@o:hrnoshade='t'">
                <xsl:attribute name="noshade">
                    <xsl:text>1</xsl:text>
                </xsl:attribute>
                <xsl:attribute name="color">
                    <xsl:value-of select="$p.Hr/@fillcolor"/>
                </xsl:attribute>
            </xsl:if>
            <xsl:if test="$p.Hr/@o:hrpct">
                <xsl:attribute name="width">
                    <xsl:value-of select="$p.Hr/@o:hrpct div 10"/>
                    <xsl:text>%</xsl:text>
                </xsl:attribute>
            </xsl:if>
        </hr>
    </xsl:template>

    <xsl:template match="w:p[w:r[1]//v:rect/@o:hrstd and not(w:r[2])]">
        <xsl:call-template name="hrCore">
            <xsl:with-param name="p.Hr" select="w:r//v:rect"/>
        </xsl:call-template>
    </xsl:template>

    <xsl:template match="v:rect[@o:hrstd]">
        <xsl:call-template name="hrCore">
            <xsl:with-param name="p.Hr" select="."/>
        </xsl:call-template>
    </xsl:template>

    <xsl:template match="w:body">

        <xsl:attribute name="style">
            <xsl:variable name="divBody" select="/w:document/w:divs/w:div[w:bodyDiv/@w:val='on']"/>
            <xsl:variable name="dxaBodyLeft">
                <xsl:value-of select="$divBody/w:marLeft/@w:val"/>
            </xsl:variable>
            <xsl:variable name="dxaBodyRight">
                <xsl:value-of select="$divBody/w:marRight/@w:val"/>
            </xsl:variable>
            <xsl:if test="not($dxaBodyLeft='' or $dxaBodyLeft=0)">
                <xsl:text>margin-left:</xsl:text>
                <xsl:value-of select="$dxaBodyLeft div 20"/>
                <xsl:text>pt;</xsl:text>
            </xsl:if>
            <xsl:if test="not($dxaBodyRight='' or $dxaBodyRight=0)">
                <xsl:text>margin-right:</xsl:text>
                <xsl:value-of select="$dxaBodyRight div 20"/>
                <xsl:text>pt;</xsl:text>
            </xsl:if>
        </xsl:attribute>
        <xsl:apply-templates select="*"/>
    </xsl:template>

    <xsl:template match="w:font">
        <xsl:text>@font-face{font-family:"</xsl:text>
        <xsl:value-of select="@w:name"/>
        <xsl:text>";panose-1:</xsl:text>
        <xsl:variable name="panose1">
            <xsl:call-template name="ConvertHexToDec">
                <xsl:with-param name="value" select="w:panose-1[1]/@w:val"/>
                <xsl:with-param name="i" select="2"/>
                <xsl:with-param name="s" select="2"/>
            </xsl:call-template>
        </xsl:variable>
        <xsl:value-of select="substring($panose1,2)"/>
        <xsl:text>;}</xsl:text>
    </xsl:template>

    <xsl:template name="MakeRStyle">
        <xsl:text>.</xsl:text>
        <xsl:value-of select="@w:styleId"/>
        <xsl:value-of select="$charStyleSuffix"/>
        <xsl:text>{</xsl:text>
        <xsl:call-template name="MakeRStyleCore"/>
        <xsl:text>}
   </xsl:text>
    </xsl:template>

    <xsl:template name="MakeRStyleCore">

        <xsl:if test="w:basedOn/@w:val">
            <xsl:variable name="sBasedOn">
                <xsl:value-of select="w:basedOn/@w:val"/>
            </xsl:variable>
            <xsl:for-each select="$nsStyles[@w:styleId=$sBasedOn]">
                <xsl:call-template name="MakeRStyleCore"/>
            </xsl:for-each>
        </xsl:if>

        <xsl:call-template name="ApplyRPr.class"/>
    </xsl:template>

    <xsl:template name="MakePStyle">

        <xsl:text>.</xsl:text>
        <xsl:value-of select="@w:styleId"/>
        <xsl:value-of select="$paraStyleSuffix"/>
        <xsl:text>{
   </xsl:text>
        <xsl:call-template name="MakePStyleCore"/>
        <xsl:text>}
   </xsl:text>

        <xsl:call-template name="MakeRStyle"/>
    </xsl:template>

    <xsl:template name="MakePStyleCore">
        <xsl:param name="beforeAutospace" select="$off"/>
        <xsl:param name="afterAutospace" select="$off"/>

        <xsl:variable name="spacing" select="w:pPr[1]/w:spacing[1]"/>
        <xsl:variable name="beforeAutospaceHere">
            <xsl:choose>
                <xsl:when test="$spacing/@w:before-autospacing = 'on'">
                    <xsl:value-of select="$on"/>
                </xsl:when>
                <xsl:otherwise>
                    <xsl:value-of select="$beforeAutospace"/>
                </xsl:otherwise>
            </xsl:choose>
        </xsl:variable>

        <xsl:variable name="afterAutospaceHere">
            <xsl:choose>
                <xsl:when test="$spacing/@w:after-autospacing = 'on'">
                    <xsl:value-of select="$on"/>
                </xsl:when>
                <xsl:otherwise>
                    <xsl:value-of select="$afterAutospace"/>
                </xsl:otherwise>
            </xsl:choose>
        </xsl:variable>

        <xsl:choose>
            <xsl:when test="w:basedOn/@w:val">
                <xsl:variable name="sBasedOn">
                    <xsl:value-of select="w:basedOn/@w:val"/>
                </xsl:variable>
                <xsl:for-each select="$nsStyles[@w:styleId=$sBasedOn]">
                    <xsl:call-template name="MakePStyleCore">
                        <xsl:with-param name="beforeAutospace" select="$beforeAutospaceHere"/>
                        <xsl:with-param name="afterAutospace" select="$afterAutospaceHere"/>
                    </xsl:call-template>
                </xsl:for-each>
            </xsl:when>
            <xsl:otherwise>
                <xsl:text>margin-left:</xsl:text>
                <xsl:value-of select="$paraMarginDefaultLeft"/>
                <xsl:text>;margin-right:</xsl:text>
                <xsl:value-of select="$paraMarginDefaultRight"/>

                <xsl:if test="not($beforeAutospace = $on)">
                    <xsl:if test="(not($spacing/@w:before-autospacing) or $spacing/@w:before-autospacing = 'off')">
                        <xsl:text>;margin-top:</xsl:text>
                        <xsl:value-of select="$paraMarginDefaultTop"/>
                    </xsl:if>
                </xsl:if>

                <xsl:if test="not($afterAutospace = $on)">
                    <xsl:if test="(not($spacing/@w:after-autospacing) or $spacing/@w:after-autospacing = 'off')">
                        <xsl:text>;margin-bottom:</xsl:text>
                        <xsl:value-of select="$paraMarginDefaultBottom"/>
                    </xsl:if>
                </xsl:if>

                <xsl:text>;font-size:10.0pt;font-family:"Times New Roman";</xsl:text>

                <xsl:for-each select="/w:document[1]/w:styles[1]/w:docDefaults/w:pPrDefault">
                    <xsl:call-template name="ApplyPPr.many"/>
                </xsl:for-each>

            </xsl:otherwise>
        </xsl:choose>

        <xsl:call-template name="ApplyPPr.class"/>
    </xsl:template>

    <xsl:template name="MakeTblStyle">
        <xsl:variable name="styleId" select="@w:styleId"/>

        <xsl:text>.</xsl:text>
        <xsl:value-of select="$styleId"/>
        <xsl:value-of select="$tblStyleSuffix"/>
        <xsl:text>{</xsl:text>
        <xsl:call-template name="RecursiveApplyTblPr.class"/>
        <xsl:text>} </xsl:text>

        <xsl:text>.</xsl:text>
        <xsl:value-of select="$styleId"/>
        <xsl:value-of select="$rowStyleSuffix"/>
        <xsl:text>{</xsl:text>
        <xsl:call-template name="RecursiveApplyTrPr.class"/>
        <xsl:text>} </xsl:text>

        <xsl:text>.</xsl:text>
        <xsl:value-of select="$styleId"/>
        <xsl:value-of select="$cellStyleSuffix"/>
        <xsl:text>{vertical-align:top;</xsl:text>

        <xsl:call-template name="RecursiveApplyTcPr.class"/>

        <xsl:call-template name="RecursiveApplyPPr.class"/>

        <xsl:call-template name="RecursiveApplyRPr.class"/>
        <xsl:text>} </xsl:text>

        <xsl:for-each select="w:tblStylePr">
            <xsl:text>.</xsl:text><xsl:value-of select="$styleId"/>-<xsl:value-of select="@w:type"/>
            <xsl:text>{vertical-align:top;</xsl:text>
            <xsl:call-template name="ApplyPPr.class"/>
            <xsl:call-template name="ApplyRPr.class"/>
            <xsl:text>} </xsl:text>
        </xsl:for-each>
    </xsl:template>

    <xsl:template match="w:style">
        <xsl:choose>

            <xsl:when test="@w:type = 'character'">
                <xsl:call-template name="MakeRStyle"/>
            </xsl:when>

            <xsl:when test="@w:type = 'paragraph'">
                <xsl:call-template name="MakePStyle"/>
            </xsl:when>

            <xsl:when test="@w:type = 'table'">
                <xsl:call-template name="MakeTblStyle"/>
            </xsl:when>
        </xsl:choose>
    </xsl:template>

    <xsl:template match="a:fontScheme">
        .<xsl:value-of select="$minorAsciiTheme"/>{font-family:<xsl:value-of select="./a:minorFont/a:latin/@typeface"/>;}
        .<xsl:value-of select="$majorAsciiTheme"/>{font-family:<xsl:value-of select="./a:majorFont/a:latin/@typeface"/>;}
        .<xsl:value-of select="$minorAnsiTheme"/>{font-family:<xsl:value-of select="./a:minorFont/a:latin/@typeface"/>;}
        .<xsl:value-of select="$majorAnsiTheme"/>{font-family:<xsl:value-of select="./a:majorFont/a:latin/@typeface"/>;}
        .<xsl:value-of select="$minorEATheme"/>{font-family:<xsl:value-of select="./a:minorFont/a:ea/@typeface"/>;}
        .<xsl:value-of select="$majorEATheme"/>{font-family:<xsl:value-of select="./a:majorFont/a:ea/@typeface"/>;}
        .<xsl:value-of select="$minorCSTheme"/>{font-family:<xsl:value-of select="./a:minorFont/a:cs/@typeface"/>;}
        .<xsl:value-of select="$majorCSTheme"/>{font-family:<xsl:value-of select="./a:majorFont/a:cs/@typeface"/>;}
    </xsl:template>

    <xsl:template match="w:bookmarkStart">
        <a name="{@w:name}"/>
    </xsl:template>

    <xsl:template match="w:ins">
        <xsl:param name="b.bidi"/>
        <xsl:param name="prsR"/>
        <ins>
            <xsl:call-template name="DisplayPContent">
                <xsl:with-param name="b.bidi" select="$b.bidi"/>
                <xsl:with-param name="prsR" select="$prsR"/>
            </xsl:call-template>
        </ins>
    </xsl:template>

    <xsl:template match="w:del">
        <xsl:param name="b.bidi"/>
        <xsl:param name="prsR"/>
        <xsl:if test="/w:document/w:settings/w:trackRevisions">
            <del>
                <xsl:call-template name="DisplayPContent">
                    <xsl:with-param name="b.bidi" select="$b.bidi"/>
                    <xsl:with-param name="prsR" select="$prsR"/>
                </xsl:call-template>
            </del>
        </xsl:if>
    </xsl:template>

    <xsl:template match="aml:annotation[@w:type='Word.Comment']">
        <xsl:variable name="id" select="@aml:id + 1"/>
        <a class="msocomanchor" id="_anchor_{$id}" onmouseover="msoCommentShow('_anchor_{$id}','_com_{$id}')"
           onmouseout="msoCommentHide('_com_{$id}')" href="#_msocom_{$id}" language="JavaScript"
           name="_msoanchor_{$id}">
            <xsl:value-of select="concat('[',@w:initials,$id,']')"/>
        </a>
    </xsl:template>

    <xsl:template name="DisplayAnnotationText">
        <xsl:variable name="id" select="@aml:id + 1"/>
        <div id="_com_{$id}" class="msocomtxt" language="JavaScript"
             onmouseover="msoCommentShow('_anchor_{$id}','_com_{$id}')" onmouseout="msoCommentHide('_com_{$id}')">
            <a name="_msocom_{$id}"></a>
            <a href="#_msoanchor_{$id}" class="msocomoff">
                <xsl:value-of select="concat('[',@w:initials,$id,']')"/>
            </a>
            <xsl:for-each select="aml:content">
                <xsl:call-template name="DisplayBodyContent">
                    <xsl:with-param name="ns.content" select="*"/>
                </xsl:call-template>
            </xsl:for-each>
        </div>
    </xsl:template>

    <xsl:template name="DisplayAnnotationScript">
        <!-- <xsl:text disable-output-escaping="yes">&lt;![if !supportAnnotations]&gt;</xsl:text> -->
        <style id="dynCom" type="text/css"></style>
        <script type="text/javascript" language="JavaScript">
            <xsl:comment>
        <xsl:text disable-output-escaping="yes">
function msoCommentShow(anchor_id, com_id)
{
    if(msoBrowserCheck())
        {
        c = document.all(com_id);
        a = document.all(anchor_id);
        if (null != c &amp;&amp; null == c.length &amp;&amp; null != a &amp;&amp; null == a.length)
            {
            var cw = c.offsetWidth;
            var ch = c.offsetHeight;
            var aw = a.offsetWidth;
            var ah = a.offsetHeight;
            var x  = a.offsetLeft;
            var y  = a.offsetTop;
            var el = a;
            while (el.tagName != "BODY")
                {
                el = el.offsetParent;
                x = x + el.offsetLeft;
                y = y + el.offsetTop;
                }
            var bw = document.body.clientWidth;
            var bh = document.body.clientHeight;
            var bsl = document.body.scrollLeft;
            var bst = document.body.scrollTop;
            if (x + cw + ah / 2 > bw + bsl &amp;&amp; x + aw - ah / 2 - cw >= bsl )
                { c.style.left = x + aw - ah / 2 - cw; }
            else
                { c.style.left = x + ah / 2; }
            if (y + ch + ah / 2 > bh + bst &amp;&amp; y + ah / 2 - ch >= bst )
                { c.style.top = y + ah / 2 - ch; }
            else
                { c.style.top = y + ah / 2; }
            c.style.visibility = "visible";
}    }    }
function msoCommentHide(com_id)
{
    if(msoBrowserCheck())
        {
        c = document.all(com_id);
        if (null != c &amp;&amp; null == c.length)
        {
        c.style.visibility = "hidden";
        c.style.left = -1000;
        c.style.top = -1000;
        } }
}
function msoBrowserCheck()
{
    ms = navigator.appVersion.indexOf("MSIE");
    vers = navigator.appVersion.substring(ms + 5, ms + 6);
    ie4 = (ms > 0) &amp;&amp; (parseInt(vers) >= 4);
    return ie4;
}
if (msoBrowserCheck())
{
    document.styleSheets.dynCom.addRule(".msocomanchor","background: infobackground");
    document.styleSheets.dynCom.addRule(".msocomoff","display: none");
    document.styleSheets.dynCom.addRule(".msocomtxt","visibility: hidden");
    document.styleSheets.dynCom.addRule(".msocomtxt","position: absolute");
    document.styleSheets.dynCom.addRule(".msocomtxt","top: -1000");
    document.styleSheets.dynCom.addRule(".msocomtxt","left: -1000");
    document.styleSheets.dynCom.addRule(".msocomtxt","width: 33%");
    document.styleSheets.dynCom.addRule(".msocomtxt","background: infobackground");
    document.styleSheets.dynCom.addRule(".msocomtxt","color: infotext");
    document.styleSheets.dynCom.addRule(".msocomtxt","border-top: 1pt solid threedlightshadow");
    document.styleSheets.dynCom.addRule(".msocomtxt","border-right: 2pt solid threedshadow");
    document.styleSheets.dynCom.addRule(".msocomtxt","border-bottom: 2pt solid threedshadow");
    document.styleSheets.dynCom.addRule(".msocomtxt","border-left: 1pt solid threedlightshadow");
    document.styleSheets.dynCom.addRule(".msocomtxt","padding: 3pt 3pt 3pt 3pt");
    document.styleSheets.dynCom.addRule(".msocomtxt","z-index: 100");
}
</xsl:text>
            </xsl:comment>
        </script>
        <!--<xsl:text disable-output-escaping="yes">&lt;![endif]&gt;</xsl:text>-->
    </xsl:template>

    <xsl:template name="copyElements">
        <xsl:param name="sTblStyleName"/>
        <xsl:param name="prsPAccum"/>
        <xsl:param name="prsP"/>
        <xsl:param name="prsR"/>
        <xsl:param name="cellspacing"/>
        <xsl:param name="cellpadding.default"/>
        <xsl:param name="cellpadding.custom"/>
        <xsl:param name="bdr.top"/>
        <xsl:param name="bdr.left"/>
        <xsl:param name="bdr.bottom"/>
        <xsl:param name="bdr.right"/>
        <xsl:param name="bdr.insideV"/>
        <xsl:param name="bdr.insideH"/>
        <xsl:param name="thisRow"/>
        <xsl:param name="lastRow"/>
        <xsl:param name="cnfRow"/>
        <xsl:param name="b.bidivisual"/>
        <xsl:element name="{name()}" namespace="{namespace-uri()}">
            <xsl:for-each select="@*">
                <xsl:attribute name="{name()}" namespace="{namespace-uri()}">
                    <xsl:value-of select="."/>
                </xsl:attribute>
            </xsl:for-each>
            <xsl:apply-templates>
                <xsl:with-param name="sTblStyleName" select="$sTblStyleName"/>
                <xsl:with-param name="prsPAccum" select="$prsPAccum"/>
                <xsl:with-param name="prsP" select="$prsP"/>
                <xsl:with-param name="prsR" select="$prsR"/>
                <xsl:with-param name="cellspacing" select="$cellspacing"/>
                <xsl:with-param name="cellpadding.default" select="$cellpadding.default"/>
                <xsl:with-param name="cellpadding.custom" select="$cellpadding.custom"/>
                <xsl:with-param name="bdr.top" select="$bdr.top"/>
                <xsl:with-param name="bdr.left" select="$bdr.left"/>
                <xsl:with-param name="bdr.bottom" select="$bdr.bottom"/>
                <xsl:with-param name="bdr.right" select="$bdr.right"/>
                <xsl:with-param name="bdr.insideV" select="$bdr.insideV"/>
                <xsl:with-param name="bdr.insideH" select="$bdr.insideH"/>
                <xsl:with-param name="thisRow" select="$thisRow"/>
                <xsl:with-param name="lastRow" select="$lastRow"/>
                <xsl:with-param name="cnfRow" select="$cnfRow"/>
                <xsl:with-param name="b.bidivisual" select="$b.bidivisual"/>
            </xsl:apply-templates>
        </xsl:element>
    </xsl:template>

    <xsl:template match="*">
        <xsl:param name="sTblStyleName"/>
        <xsl:param name="prsPAccum"/>
        <xsl:param name="prsP"/>
        <xsl:param name="prsR"/>
        <xsl:param name="cellspacing"/>
        <xsl:param name="cellpadding.default"/>
        <xsl:param name="cellpadding.custom"/>
        <xsl:param name="bdr.top"/>
        <xsl:param name="bdr.left"/>
        <xsl:param name="bdr.bottom"/>
        <xsl:param name="bdr.right"/>
        <xsl:param name="bdr.insideV"/>
        <xsl:param name="bdr.insideH"/>
        <xsl:param name="thisRow"/>
        <xsl:param name="lastRow"/>
        <xsl:param name="cnfRow"/>
        <xsl:param name="b.bidivisual"/>
        <xsl:call-template name="copyElements">
            <xsl:with-param name="sTblStyleName" select="$sTblStyleName"/>
            <xsl:with-param name="prsPAccum" select="$prsPAccum"/>
            <xsl:with-param name="prsP" select="$prsP"/>
            <xsl:with-param name="prsR" select="$prsR"/>
            <xsl:with-param name="cellspacing" select="$cellspacing"/>
            <xsl:with-param name="cellpadding.default" select="$cellpadding.default"/>
            <xsl:with-param name="cellpadding.custom" select="$cellpadding.custom"/>
            <xsl:with-param name="bdr.top" select="$bdr.top"/>
            <xsl:with-param name="bdr.left" select="$bdr.left"/>
            <xsl:with-param name="bdr.bottom" select="$bdr.bottom"/>
            <xsl:with-param name="bdr.right" select="$bdr.right"/>
            <xsl:with-param name="bdr.insideV" select="$bdr.insideV"/>
            <xsl:with-param name="bdr.insideH" select="$bdr.insideH"/>
            <xsl:with-param name="thisRow" select="$thisRow"/>
            <xsl:with-param name="lastRow" select="$lastRow"/>
            <xsl:with-param name="cnfRow" select="$cnfRow"/>
            <xsl:with-param name="b.bidivisual" select="$b.bidivisual"/>
        </xsl:call-template>
    </xsl:template>

    <xsl:template match="v:*">
        <xsl:choose>
            <xsl:when test=".//w10:wrap[@type='topAndBottom']">
                <o:wrapblock>
                    <xsl:call-template name="copyElements"/>
                </o:wrapblock>
                <br style="mso-ignore:vglayout" clear='ALL'/>
            </xsl:when>
            <xsl:otherwise>
                <xsl:call-template name="copyElements"/>
            </xsl:otherwise>
        </xsl:choose>
    </xsl:template>

    <xsl:template match="w:ruby">
        <ruby>

            <xsl:attribute name="lang">
                <xsl:value-of select="w:rubyPr/w:lid/@w:val"/>
            </xsl:attribute>

            <xsl:attribute name="style">

                <xsl:variable name="align" select="w:rubyPr/w:rubyAlign/@w:val"/>
                <xsl:text>ruby-align:</xsl:text>
                <xsl:choose>
                    <xsl:when test="$align='rightVertical'">
                        <xsl:text>auto</xsl:text>
                    </xsl:when>
                    <xsl:when test="$align='distributeLetter'">
                        <xsl:text>distribute-letter</xsl:text>
                    </xsl:when>
                    <xsl:when test="$align='distributeSpace'">
                        <xsl:text>distribute-space</xsl:text>
                    </xsl:when>
                    <xsl:otherwise>
                        <xsl:value-of select="$align"/>
                    </xsl:otherwise>
                </xsl:choose>

            </xsl:attribute>

            <span>
                <xsl:if test="w:rubyPr/w:hpsBaseText">
                    <xsl:attribute name="style">
                        <xsl:text>font-size:</xsl:text>
                        <xsl:value-of select="w:rubyPr/w:hpsBaseText/@w:val"/>
                        <xsl:text>pt;</xsl:text>
                    </xsl:attribute>
                </xsl:if>

                <xsl:apply-templates select="w:rubyBase/w:r"/>
            </span>

            <rt>
                <span>
                    <xsl:if test="w:rubyPr/w:hps">
                        <xsl:attribute name="style">
                            <xsl:text>font-size:</xsl:text>
                            <xsl:value-of select="w:rubyPr/w:hps/@w:val div 2"/>
                            <xsl:text>pt;</xsl:text>
                        </xsl:attribute>

                        <xsl:apply-templates select="w:rt/w:r/w:t"/>
                        <!--<xsl:apply-templates select="w:r/w:t"/>-->
                    </xsl:if>
                </span>
            </rt>
        </ruby>
    </xsl:template>

    <xsl:template match="w:footnote">

        <xsl:variable name="me" select="."/>
        <xsl:variable name="meInContext"
                      select="ancestor::w:r[1]/*[count($me|descendant-or-self::*)=count(descendant-or-self::*)]"/>
        <xsl:variable name="start">
            <xsl:choose>
                <xsl:when test="$ndDocPr/w:footnotePr/w:numStart">
                    <xsl:value-of select="$ndDocPr/w:footnotePr/w:numStart/@w:val"/>
                </xsl:when>
                <xsl:otherwise>
                    <xsl:value-of select="1"/>
                </xsl:otherwise>
            </xsl:choose>
        </xsl:variable>
        <xsl:variable name="position"
                      select="count($meInContext/preceding::*[name()='w:footnote' and ancestor::w:body]) + $start"/>

        <sup>
            <a>
                <xsl:attribute name="name">
                    <xsl:value-of select="$footnoteRefLink"/>
                    <xsl:value-of select="$position"/>
                </xsl:attribute>
                <xsl:attribute name="href">
                    <xsl:text>#</xsl:text>
                    <xsl:value-of select="$footnoteLink"/>
                    <xsl:value-of select="$position"/>
                </xsl:attribute>
                <xsl:text>[</xsl:text>
                <xsl:value-of select="$position"/>
                <xsl:text>]</xsl:text>
            </a>
        </sup>
    </xsl:template>

    <xsl:template match="w:endnote">

        <xsl:variable name="me" select="."/>
        <xsl:variable name="meInContext"
                      select="ancestor::w:r[1]/*[count($me|descendant-or-self::*)=count(descendant-or-self::*)]"/>
        <xsl:variable name="start">
            <xsl:choose>
                <xsl:when test="$ndDocPr/w:endnotePr/w:numStart">
                    <xsl:value-of select="$ndDocPr/w:endnotePr/w:numStart/@w:val"/>
                </xsl:when>
                <xsl:otherwise>
                    <xsl:value-of select="1"/>
                </xsl:otherwise>
            </xsl:choose>
        </xsl:variable>
        <xsl:variable name="position"
                      select="count($meInContext/preceding::*[name()='w:endnote' and ancestor::w:body]) + $start"/>

        <sup>
            <a>
                <xsl:attribute name="name">
                    <xsl:value-of select="$endnoteRefLink"/>
                    <xsl:value-of select="$position"/>
                </xsl:attribute>
                <xsl:attribute name="href">
                    <xsl:text>#</xsl:text>
                    <xsl:value-of select="$endnoteLink"/>
                    <xsl:value-of select="$position"/>
                </xsl:attribute>
                <xsl:text>[</xsl:text>
                <xsl:value-of select="$position"/>
                <xsl:text>]</xsl:text>
            </a>
        </sup>
    </xsl:template>

    <xsl:template name="IsListBullet">

        <xsl:variable name="numId" select="w:numId/@w:val"/>
        <xsl:variable name="ilvl" select="w:ilvl/@w:val"/>
        <xsl:variable name="list" select="$ndLists/w:num[@w:numId=$numId][1]"/>

        <xsl:variable name="nfc">

            <xsl:choose>
                <xsl:when
                        test="$ndLists/w:abstractNum[@w:abstractNumId=$list/w:abstractNumId/@w:val][1]/w:lvl[@w:ilvl=$ilvl][1]">
                    <xsl:for-each
                            select="$ndLists/w:abstractNum[@w:abstractNumId=$list/w:abstractNumId/@w:val][1]/w:lvl[@w:ilvl=$ilvl][1]">
                        <xsl:choose>
                            <xsl:when test="$list/w:lvlOverride[@w:ilvl=$ilvl]/w:numFmt">
                                <xsl:value-of select="$list/w:lvlOverride[@w:ilvl=$ilvl]/w:numFmt/@w:val"/>
                            </xsl:when>
                            <xsl:otherwise>
                                <xsl:value-of
                                        select="$ndLists/w:abstractNum[@w:abstractNumId=$list/w:abstractNumId/@w:val][1]/w:lvl[@w:ilvl=$ilvl][1]/w:numFmt/@w:val"/>
                            </xsl:otherwise>
                        </xsl:choose>
                    </xsl:for-each>
                </xsl:when>

                <xsl:when test="$list/w:lvlOverride[@w:ilvl=$ilvl]">
                    <xsl:for-each select="$list/w:lvlOverride[@w:ilvl=$ilvl]">
                        <xsl:value-of select="w:numFmt/@w:val"/>
                    </xsl:for-each>
                </xsl:when>

                <xsl:when
                        test="$ndLists/w:abstractNum[@w:abstractNumId=$list/w:abstractNumId/@w:val][1]/w:listStyleLink">
                    <xsl:variable name="linkedStyleId"
                                  select="$ndLists/w:abstractNum[@w:abstractNumId=$list/w:abstractNumId/@w:val][1]/w:listStyleLink/@w:val"/>
                    <xsl:variable name="linkedStyle" select="$nsStyles[@w:styleId=$linkedStyleId]"/>
                    <xsl:variable name="linkedList" select="w:num[@w:numId=$linkedStyle/w:pPr/w:numPr/w:numId/@w:val]"/>
                    <xsl:for-each
                            select="$ndLists/w:abstractNum[@w:abstractNumId=$linkedList/w:abstractNumId/@w:val][1]/w:lvl[@w:ilvl=$ilvl][1]">
                        <xsl:value-of select="w:numFmt/@w:val"/>
                    </xsl:for-each>
                </xsl:when>
            </xsl:choose>
        </xsl:variable>

        <xsl:if test="$nfc=$nfcBullet">
            <xsl:value-of select="$on"/>
        </xsl:if>
    </xsl:template>

    <xsl:template match="w:fldSimple">
        <xsl:apply-templates/>
    </xsl:template>

    <xsl:template match="w:*"/>

    <xsl:template match="o:WordFieldCodes"/>

    <xsl:template match="w:cfChunk">
        <xsl:apply-templates/>
    </xsl:template>

    <xsl:template match="w:sdt">
        <xsl:apply-templates/>
    </xsl:template>

    <xsl:template match="w:sdtContent">
        <xsl:apply-templates/>
    </xsl:template>

    <xsl:template match="w:smartTag">
        <xsl:apply-templates/>
    </xsl:template>

    <!--this template is added now
  <xsl:template match="w:background" mode="rpr">
    bgcolor=<xsl:call-template name="ConvHexColor">
      <xsl:with-param name="value" select="@w:color"/>
    </xsl:call-template>;
  </xsl:template>
-->
    <xsl:template match="/w:document">

        <html>
            <head>
                <xsl:for-each select="$ndOfficeDocPr/o:HyperlinkBase[1]">
                    <base href="{(.)}"/>
                </xsl:for-each>
                <xsl:call-template name="DisplayAnnotationScript"/>

                <!--<xsl:comment>-->
                <!--<xsl:text disable-output-escaping="yes">[if !mso]&gt;</xsl:text>-->
                <xsl:text disable-output-escaping="yes">&lt;style&gt;</xsl:text>
                <xsl:text>

                            v\:* {behavior:url(#default#VML);}
                            o\:* {behavior:url(#default#VML);}
                            w10\:* {behavior:url(#default#VML);}
                            .shape {behavior:url(#default#VML);}
                        </xsl:text>

                <xsl:text disable-output-escaping="yes">&lt;/style&gt;</xsl:text>
                <!--<xsl:text disable-output-escaping="yes">&lt;![endif]</xsl:text>-->
                <!-- </xsl:comment> -->

                <style>
                    <!--   <xsl:comment> -->

                    <xsl:apply-templates select="w:fonts[1]/w:font"/>

                    del {text-decoration:line-through;color:red;}
                    <xsl:choose>
                        <xsl:when test="/w:document/w:settings/w:trackRevisions">
                            ins {text-decoration:underline;color:teal;}
                        </xsl:when>
                        <xsl:otherwise>
                            ins {text-decoration:none;}
                        </xsl:otherwise>
                    </xsl:choose>

                    <xsl:apply-templates select="a:theme/a:themeElements/a:fontScheme"/>

                    <xsl:apply-templates select="$nsStyles"/>

                    <!-- </xsl:comment> -->
                </style>
            </head>

            <body>
                <xsl:if test="w:background/@w:color">
                    <xsl:variable name="color"> <!-- Added by Parwati to handle Background Page Color-->
                        <xsl:text>#</xsl:text>
                    </xsl:variable>
                    <xsl:attribute name="bgcolor">
                        <xsl:value-of select="$color"/>
                        <xsl:value-of select="w:background/@w:color"/>
                    </xsl:attribute>
                </xsl:if>
                <!-- Added for column rendering by Parwati
        <xsl:if test="//w:body//w:sectPr//w:cols[@w:num] | //w:body/w:p/w:pPr/w:sectPr/w:cols[@w:num] | //w:body/w:sdt/w:sdtContent">
          <xsl:text disable-output-escaping="yes">&lt;table cellpadding="5px"&gt;</xsl:text>
          <xsl:text disable-output-escaping="yes">&lt;tr&gt;</xsl:text>
          <xsl:text disable-output-escaping="yes">&lt;td valign="top"&gt;</xsl:text>
        </xsl:if>
            End of change by Parwati -->
                <xsl:apply-templates select="w:body|w:cfChunk"/>

                <xsl:if test="//v:background">
                    <xsl:for-each select="//v:background[1]">
                        <xsl:call-template name="copyElements"/>
                    </xsl:for-each>
                </xsl:if>

                <xsl:for-each select="//aml:annotation[@w:type='Word.Comment']">
                    <xsl:call-template name="DisplayAnnotationText"/>
                </xsl:for-each>

                <xsl:if test="//w:body//w:footnote">
                    <xsl:variable name="start">
                        <xsl:choose>
                            <xsl:when test="$ndDocPr/w:footnotePr/w:numStart">
                                <xsl:value-of select="$ndDocPr/w:footnotePr/w:numStart/@w:val"/>
                            </xsl:when>
                            <xsl:otherwise>
                                <xsl:value-of select="0"/>
                            </xsl:otherwise>
                        </xsl:choose>
                    </xsl:variable>
                    <hr align="left" size="1" width="33%"/>
                    <xsl:for-each select="//w:body//w:footnote">
                        <a>
                            <xsl:attribute name="href">
                                <xsl:text>#</xsl:text>
                                <xsl:value-of select="$footnoteRefLink"/>
                                <xsl:value-of select="position() + $start"/>
                            </xsl:attribute>
                            <xsl:attribute name="target">
                                <xsl:text>_self</xsl:text>
                            </xsl:attribute>
                            <xsl:attribute name="name">
                                <xsl:value-of select="$footnoteLink"/>
                                <xsl:value-of select="position() + $start"/>
                            </xsl:attribute>
                            <xsl:text>[</xsl:text>
                            <xsl:value-of select="position() + $start"/>
                            <xsl:text>]</xsl:text>
                        </a>
                        <xsl:apply-templates select="*"/>
                    </xsl:for-each>
                </xsl:if>

                <xsl:if test="//w:body//w:endnote">
                    <xsl:variable name="start">
                        <xsl:choose>
                            <xsl:when test="$ndDocPr/w:endnotePr/w:numStart">
                                <xsl:value-of select="$ndDocPr/w:endnotePr/w:numStart/@w:val"/>
                            </xsl:when>
                            <xsl:otherwise>
                                <xsl:value-of select="0"/>
                            </xsl:otherwise>
                        </xsl:choose>
                    </xsl:variable>
                    <hr align="left" size="1" width="33%"/>
                    <xsl:for-each select="//w:body//w:endnote">
                        <a>
                            <xsl:attribute name="href">
                                <xsl:text>#</xsl:text>
                                <xsl:value-of select="$endnoteRefLink"/>
                                <xsl:value-of select="position() + $start"/>
                            </xsl:attribute>
                            <xsl:attribute name="target">
                                <xsl:text>_self</xsl:text>
                            </xsl:attribute>
                            <xsl:attribute name="name">
                                <xsl:value-of select="$endnoteLink"/>
                                <xsl:value-of select="position() + $start"/>
                            </xsl:attribute>
                            <xsl:text>[</xsl:text>
                            <xsl:value-of select="position() + $start"/>
                            <xsl:text>]</xsl:text>
                        </a>
                        <xsl:apply-templates select="*"/>
                    </xsl:for-each>
                </xsl:if>
                <!-- Added for column rendering by Parwati
        <xsl:if test="//w:body/w:sectPr/w:cols/@w:num | //w:body/w:p/w:pPr/w:sectPr/w:cols[@w:num] | //w:body/w:sdt/w:sdtContent">
          <xsl:text disable-output-escaping="yes">&lt;/td&gt;</xsl:text>
          <xsl:text disable-output-escaping="yes">&lt;/tr&gt;</xsl:text>
          <xsl:text disable-output-escaping="yes">&lt;/table&gt;</xsl:text>
        </xsl:if>
         End of change by Parwati -->
                <!--<xsl:if test="//w:body//w:sdt//w:sdtContent and //w:body/w:p/w:r/w:lastRenderedPageBreak"> --><!-- For coverpage Added by Parwati--><!--
          <xsl:text disable-output-escaping="yes">&lt;/div&gt;</xsl:text>
        </xsl:if>-->
            </body>
        </html>
    </xsl:template>

    <xsl:template match="w:drawing">
        <xsl:variable name="w">
            <xsl:value-of select=".//wp:extent/@cx"/>
        </xsl:variable>

        <xsl:variable name="h">
            <xsl:value-of select=".//wp:extent/@cy"/>
        </xsl:variable>

        <img src="?image={.//a:blip/@r:embed[1]}">

            <xsl:attribute name="width">
                <xsl:value-of select="number($w) div 9525"/>px
            </xsl:attribute>

            <xsl:attribute name="height">
                <xsl:value-of select="number($h) div 9525"/>px
            </xsl:attribute>
        </img>
    </xsl:template>

    <xsl:template match="w:customXml">
        <xsl:apply-templates select="*"/>
    </xsl:template>


    <xsl:template match="/">
        <!--ADDED for Equations -->
        <xsl:if test="$pmathml">
            <xsl:processing-instruction name="xml-stylesheet"
            >type="text/xsl" href="<xsl:value-of select="$pmathml"/>"
            </xsl:processing-instruction>
        </xsl:if>
        <xsl:if test="$dtd">
      <xsl:text disable-output-escaping="yes"><![CDATA[
<!DOCTYPE html SYSTEM "]]></xsl:text>
            <xsl:value-of select="$dtd"/>
            <xsl:text disable-output-escaping="yes"><![CDATA[" [
<!ENTITY % MATHML.prefixed      "INCLUDE" >
<!ENTITY % MATHML.prefix        "mml" >
]>
]]>
      </xsl:text>
        </xsl:if>
        <!--ADDED for Equations -->
        <xsl:apply-templates select="*"/>
    </xsl:template>


    <!--ADDED FOR MATHML SUPPORT BY SHUBHA -->


    <!-- Every single unicode character that is recognized by OMML as an operator -->
    <xsl:variable name="sOperators"
                  select="concat(
    '&#x0021;&#x0022;&#x0028;&#x0029;&#x002B;&#x002C;&#x002D;&#x002F;&#x2AFE;&#x003A;&#x003B;&#x003C;',
    '&#x003D;&#x003E;&#x003F;&#x005B;&#x005C;&#x005D;&#x007B;&#x007C;&#x007D;&#x00A1;&#x00AC;&#x00B1;',
    '&#x00B7;&#x00BF;&#x00D7;&#x00F7;&#x2000;&#x2001;&#x2002;&#x2003;&#x2004;&#x2005;&#x2006;&#x2009;',
    '&#x200A;&#x2010;&#x2012;&#x2013;&#x2014;&#x2016;&#x2020;&#x2021;&#x2022;&#x2024;&#x2025;&#x2026;',
    '&#x203C;&#x2040;&#x204E;&#x204F;&#x2050;&#x205f;&#x2061;&#x2062;&#x2063;&#x2140;&#x2190;&#x2191;',
    '&#x2192;&#x2193;&#x2194;&#x2195;&#x2196;&#x2197;&#x2198;&#x2199;&#x219A;&#x219B;&#x219C;&#x219D;',
    '&#x219E;&#x219F;&#x21A0;&#x21A1;&#x21A2;&#x21A3;&#x21A4;&#x21A5;&#x21A6;&#x21A7;&#x21A8;&#x21A9;',
    '&#x21AA;&#x21AB;&#x21AC;&#x21AD;&#x21AE;&#x21AF;&#x21B0;&#x21B1;&#x21B2;&#x21B3;&#x21B6;&#x21B7;',
    '&#x21BA;&#x21BB;&#x21BC;&#x21BD;&#x21BE;&#x21BF;&#x21C0;&#x21C1;&#x21C2;&#x21C3;&#x21C4;&#x21C5;',
    '&#x21C6;&#x21C7;&#x21C8;&#x21C9;&#x21CA;&#x21CB;&#x21CC;&#x21CD;&#x21CE;&#x21CF;&#x21D0;&#x21D1;',
    '&#x21D2;&#x21D3;&#x21D4;&#x21D5;&#x21D6;&#x21D7;&#x21D8;&#x21D9;&#x21DA;&#x21DB;&#x21DC;&#x21DD;',
    '&#x21DE;&#x21DF;&#x21E0;&#x21E1;&#x21E2;&#x21E3;&#x21E4;&#x21E5;&#x21E6;&#x21E7;&#x21E8;&#x21E9;',
    '&#x21F4;&#x21F5;&#x21F6;&#x21F7;&#x21F8;&#x21F9;&#x21FA;&#x21FB;&#x21FC;&#x21FD;&#x21FE;&#x21FF;',
    '&#x2200;&#x2201;&#x2202;&#x2203;&#x2204;&#x2206;&#x2207;&#x2208;&#x2209;&#x220A;&#x220B;&#x220C;',
    '&#x220D;&#x220F;&#x2210;&#x2211;&#x2212;&#x2213;&#x2214;&#x2215;&#x2216;&#x2217;&#x2218;&#x2219;',
    '&#x221A;&#x221B;&#x221C;&#x221D;&#x2223;&#x2224;&#x2225;&#x2226;&#x2227;&#x2228;&#x2229;&#x222A;',
    '&#x222B;&#x222C;&#x222D;&#x222E;&#x222F;&#x2230;&#x2231;&#x2232;&#x2233;&#x2234;&#x2235;&#x2236;',
    '&#x2237;&#x2238;&#x2239;&#x223A;&#x223B;&#x223C;&#x223D;&#x223E;&#x2240;&#x2241;&#x2242;&#x2243;',
    '&#x2244;&#x2245;&#x2246;&#x2247;&#x2248;&#x2249;&#x224A;&#x224B;&#x224C;&#x224D;&#x224E;&#x224F;',
    '&#x2250;&#x2251;&#x2252;&#x2253;&#x2254;&#x2255;&#x2256;&#x2257;&#x2258;&#x2259;&#x225A;&#x225B;',
    '&#x225C;&#x225D;&#x225E;&#x225F;&#x2260;&#x2261;&#x2262;&#x2263;&#x2264;&#x2265;&#x2266;&#x2267;',
    '&#x2268;&#x2269;&#x226A;&#x226B;&#x226C;&#x226D;&#x226E;&#x226F;&#x2270;&#x2271;&#x2272;&#x2273;',
    '&#x2274;&#x2275;&#x2276;&#x2277;&#x2278;&#x2279;&#x227A;&#x227B;&#x227C;&#x227D;&#x227E;&#x227F;',
    '&#x2280;&#x2281;&#x2282;&#x2283;&#x2284;&#x2285;&#x2286;&#x2287;&#x2288;&#x2289;&#x228A;&#x228B;',
    '&#x228C;&#x228D;&#x228E;&#x228F;&#x2290;&#x2291;&#x2292;&#x2293;&#x2294;&#x2295;&#x2296;&#x2297;',
    '&#x2298;&#x2299;&#x229A;&#x229B;&#x229C;&#x229D;&#x229E;&#x229F;&#x22A0;&#x22A1;&#x22A2;&#x22A3;',
    '&#x22A5;&#x22A6;&#x22A7;&#x22A8;&#x22A9;&#x22AA;&#x22AB;&#x22AC;&#x22AD;&#x22AE;&#x22AF;&#x22B0;',
    '&#x22B1;&#x22B2;&#x22B3;&#x22B4;&#x22B5;&#x22B6;&#x22B7;&#x22B8;&#x22B9;&#x22BA;&#x22BB;&#x22BC;',
    '&#x22BD;&#x22C0;&#x22C1;&#x22C2;&#x22C3;&#x22C4;&#x22C5;&#x22C6;&#x22C7;&#x22C8;&#x22C9;&#x22CA;',
    '&#x22CB;&#x22CC;&#x22CD;&#x22CE;&#x22CF;&#x22D0;&#x22D1;&#x22D2;&#x22D3;&#x22D4;&#x22D5;&#x22D6;',
    '&#x22D7;&#x22D8;&#x22D9;&#x22DA;&#x22DB;&#x22DC;&#x22DD;&#x22DE;&#x22DF;&#x22E0;&#x22E1;&#x22E2;',
    '&#x22E3;&#x22E4;&#x22E5;&#x22E6;&#x22E7;&#x22E8;&#x22E9;&#x22EA;&#x22EB;&#x22EC;&#x22ED;&#x22EE;',
    '&#x22EF;&#x22F0;&#x22F1;&#x22F2;&#x22F3;&#x22F4;&#x22F5;&#x22F6;&#x22F7;&#x22F8;&#x22F9;&#x22FA;',
    '&#x22FB;&#x22FC;&#x22FD;&#x22FE;&#x22FF;&#x2305;&#x2306;&#x2308;&#x2309;&#x230A;&#x230B;&#x231C;',
    '&#x231D;&#x231E;&#x231F;&#x2322;&#x2323;&#x2329;&#x232A;&#x233D;&#x233F;&#x23B0;&#x23B1;&#x25B2;',
    '&#x25B3;&#x25B4;&#x25B5;&#x25B6;&#x25B7;&#x25B8;&#x25B9;&#x25BC;&#x25BD;&#x25BE;&#x25BF;&#x25C0;',
    '&#x25C1;&#x25C2;&#x25C3;&#x25C4;&#x25C5;&#x25CA;&#x25CB;&#x25E6;&#x25EB;&#x25EC;&#x25F8;&#x25F9;',
    '&#x25FA;&#x25FB;&#x25FC;&#x25FD;&#x25FE;&#x25FF;&#x2605;&#x2606;&#x2772;&#x2773;&#x27D1;&#x27D2;',
    '&#x27D3;&#x27D4;&#x27D5;&#x27D6;&#x27D7;&#x27D8;&#x27D9;&#x27DA;&#x27DB;&#x27DC;&#x27DD;&#x27DE;',
    '&#x27DF;&#x27E0;&#x27E1;&#x27E2;&#x27E3;&#x27E4;&#x27E5;&#x27E6;&#x27E7;&#x27E8;&#x27E9;&#x27EA;',
    '&#x27EB;&#x27F0;&#x27F1;&#x27F2;&#x27F3;&#x27F4;&#x27F5;&#x27F6;&#x27F7;&#x27F8;&#x27F9;&#x27FA;',
    '&#x27FB;&#x27FC;&#x27FD;&#x27FE;&#x27FF;&#x2900;&#x2901;&#x2902;&#x2903;&#x2904;&#x2905;&#x2906;',
    '&#x2907;&#x2908;&#x2909;&#x290A;&#x290B;&#x290C;&#x290D;&#x290E;&#x290F;&#x2910;&#x2911;&#x2912;',
    '&#x2913;&#x2914;&#x2915;&#x2916;&#x2917;&#x2918;&#x2919;&#x291A;&#x291B;&#x291C;&#x291D;&#x291E;',
    '&#x291F;&#x2920;&#x2921;&#x2922;&#x2923;&#x2924;&#x2925;&#x2926;&#x2927;&#x2928;&#x2929;&#x292A;',
    '&#x292B;&#x292C;&#x292D;&#x292E;&#x292F;&#x2930;&#x2931;&#x2932;&#x2933;&#x2934;&#x2935;&#x2936;',
    '&#x2937;&#x2938;&#x2939;&#x293A;&#x293B;&#x293C;&#x293D;&#x293E;&#x293F;&#x2940;&#x2941;&#x2942;',
    '&#x2943;&#x2944;&#x2945;&#x2946;&#x2947;&#x2948;&#x2949;&#x294A;&#x294B;&#x294C;&#x294D;&#x294E;',
    '&#x294F;&#x2950;&#x2951;&#x2952;&#x2953;&#x2954;&#x2955;&#x2956;&#x2957;&#x2958;&#x2959;&#x295A;',
    '&#x295B;&#x295C;&#x295D;&#x295E;&#x295F;&#x2960;&#x2961;&#x2962;&#x2963;&#x2964;&#x2965;&#x2966;',
    '&#x2967;&#x2968;&#x2969;&#x296A;&#x296B;&#x296C;&#x296D;&#x296E;&#x296F;&#x2970;&#x2971;&#x2972;',
    '&#x2973;&#x2974;&#x2975;&#x2976;&#x2977;&#x2978;&#x2979;&#x297A;&#x297B;&#x297C;&#x297D;&#x297E;',
    '&#x297F;&#x2980;&#x2982;&#x2983;&#x2984;&#x2985;&#x2986;&#x2987;&#x2988;&#x2989;&#x298A;&#x298B;',
    '&#x298C;&#x298D;&#x298E;&#x298F;&#x2990;&#x2991;&#x2992;&#x2993;&#x2994;&#x2995;&#x2996;&#x2997;',
    '&#x2998;&#x2999;&#x299A;&#x29B6;&#x29B7;&#x29B8;&#x29B9;&#x29C0;&#x29C1;&#x29C4;&#x29C5;&#x29C6;',
    '&#x29C7;&#x29C8;&#x29CE;&#x29CF;&#x29D0;&#x29D1;&#x29D2;&#x29D3;&#x29D4;&#x29D5;&#x29D6;&#x29D7;',
    '&#x29D8;&#x29D9;&#x29DA;&#x29DB;&#x29DF;&#x29E1;&#x29E2;&#x29E3;&#x29E4;&#x29E5;&#x29E6;&#x29EB;',
    '&#x29F4;&#x29F5;&#x29F6;&#x29F7;&#x29F8;&#x29F9;&#x29FA;&#x29FB;&#x29FC;&#x29FD;&#x29FE;&#x29FF;',
    '&#x2A00;&#x2A01;&#x2A02;&#x2A03;&#x2A04;&#x2A05;&#x2A06;&#x2A07;&#x2A08;&#x2A09;&#x2A0A;&#x2A0B;',
    '&#x2A0C;&#x2A0D;&#x2A0E;&#x2A0F;&#x2A10;&#x2A11;&#x2A12;&#x2A13;&#x2A14;&#x2A15;&#x2A16;&#x2A17;',
    '&#x2A18;&#x2A19;&#x2A1A;&#x2A1B;&#x2A1C;&#x2A1D;&#x2A1E;&#x2A1F;&#x2A20;&#x2A21;&#x2A22;&#x2A23;',
    '&#x2A24;&#x2A25;&#x2A26;&#x2A27;&#x2A28;&#x2A29;&#x2A2A;&#x2A2B;&#x2A2C;&#x2A2D;&#x2A2E;&#x2A2F;',
    '&#x2A30;&#x2A31;&#x2A32;&#x2A33;&#x2A34;&#x2A35;&#x2A36;&#x2A37;&#x2A38;&#x2A39;&#x2A3A;&#x2A3B;',
    '&#x2A3C;&#x2A3D;&#x2A3E;&#x2A3F;&#x2A40;&#x2A41;&#x2A42;&#x2A43;&#x2A44;&#x2A45;&#x2A46;&#x2A47;',
    '&#x2A48;&#x2A49;&#x2A4A;&#x2A4B;&#x2A4C;&#x2A4D;&#x2A4E;&#x2A4F;&#x2A50;&#x2A51;&#x2A52;&#x2A53;',
    '&#x2A54;&#x2A55;&#x2A56;&#x2A57;&#x2A58;&#x2A59;&#x2A5A;&#x2A5B;&#x2A5C;&#x2A5D;&#x2A5E;&#x2A5F;',
    '&#x2A60;&#x2A61;&#x2A62;&#x2A63;&#x2A64;&#x2A65;&#x2A66;&#x2A67;&#x2A68;&#x2A69;&#x2A6A;&#x2A6B;',
    '&#x2A6C;&#x2A6D;&#x2A6E;&#x2A6F;&#x2A70;&#x2A71;&#x2A72;&#x2A73;&#x2A74;&#x2A75;&#x2A76;&#x2A77;',
    '&#x2A78;&#x2A79;&#x2A7A;&#x2A7B;&#x2A7C;&#x2A7D;&#x2A7E;&#x2A7F;&#x2A80;&#x2A81;&#x2A82;&#x2A83;',
    '&#x2A84;&#x2A85;&#x2A86;&#x2A87;&#x2A88;&#x2A89;&#x2A8A;&#x2A8B;&#x2A8C;&#x2A8D;&#x2A8E;&#x2A8F;',
    '&#x2A90;&#x2A91;&#x2A92;&#x2A93;&#x2A94;&#x2A95;&#x2A96;&#x2A97;&#x2A98;&#x2A99;&#x2A9A;&#x2A9B;',
    '&#x2A9C;&#x2A9D;&#x2A9E;&#x2A9F;&#x2AA0;&#x2AA1;&#x2AA2;&#x2AA3;&#x2AA4;&#x2AA5;&#x2AA6;&#x2AA7;',
    '&#x2AA8;&#x2AA9;&#x2AAA;&#x2AAB;&#x2AAC;&#x2AAD;&#x2AAE;&#x2AAF;&#x2AB0;&#x2AB1;&#x2AB2;&#x2AB3;',
    '&#x2AB4;&#x2AB5;&#x2AB6;&#x2AB7;&#x2AB8;&#x2AB9;&#x2ABA;&#x2ABB;&#x2ABC;&#x2ABD;&#x2ABE;&#x2ABF;',
    '&#x2AC0;&#x2AC1;&#x2AC2;&#x2AC3;&#x2AC4;&#x2AC5;&#x2AC6;&#x2AC7;&#x2AC8;&#x2AC9;&#x2ACA;&#x2ACB;',
    '&#x2ACC;&#x2ACD;&#x2ACE;&#x2ACF;&#x2AD0;&#x2AD1;&#x2AD2;&#x2AD3;&#x2AD4;&#x2AD5;&#x2AD6;&#x2AD7;',
    '&#x2AD8;&#x2AD9;&#x2ADA;&#x2ADB;&#x2ADC;&#x2ADD;&#x2ADE;&#x2ADF;&#x2AE0;&#x2AE2;&#x2AE3;&#x2AE4;',
    '&#x2AE5;&#x2AE6;&#x2AE7;&#x2AE8;&#x2AE9;&#x2AEA;&#x2AEB;&#x2AEC;&#x2AED;&#x2AEE;&#x2AEF;&#x2AF0;',
    '&#x2AF2;&#x2AF3;&#x2AF4;&#x2AF5;&#x2AF6;&#x2AF7;&#x2AF8;&#x2AF9;&#x2AFA;&#x2AFB;&#x2AFC;&#x2AFD;')"/>

    <!-- A string of '-'s repeated exactly as many times as the operators above -->
    <xsl:variable name="sMinuses">
        <xsl:call-template name="SRepeatChar">
            <xsl:with-param name="cchRequired" select="string-length($sOperators)"/>
            <xsl:with-param name="ch" select="'-'"/>
        </xsl:call-template>
    </xsl:variable>

    <!-- Every single unicode character that is recognized by OMML as a number -->
    <xsl:variable name="sNumbers" select="'0123456789'"/>

    <!-- A string of '0's repeated exactly as many times as the list of numbers above -->
    <xsl:variable name="sOnes">
        <xsl:call-template name="SRepeatChar">
            <xsl:with-param name="cchRequired" select="string-length($sNumbers)"/>
            <xsl:with-param name="ch" select="'1'"/>
        </xsl:call-template>
    </xsl:variable>

    <!-- %%Template: SReplace

    Replace all occurences of sOrig in sInput with sReplacement
    and return the resulting string. -->
    <xsl:template name="SReplace">
        <xsl:param name="sInput"/>
        <xsl:param name="sOrig"/>
        <xsl:param name="sReplacement"/>

        <xsl:choose>
            <xsl:when test="not(contains($sInput, $sOrig))">
                <xsl:value-of select="$sInput"/>
            </xsl:when>
            <xsl:otherwise>
                <xsl:variable name="sBefore" select="substring-before($sInput, $sOrig)"/>
                <xsl:variable name="sAfter" select="substring-after($sInput, $sOrig)"/>
                <xsl:variable name="sAfterProcessed">
                    <xsl:call-template name="SReplace">
                        <xsl:with-param name="sInput" select="$sAfter"/>
                        <xsl:with-param name="sOrig" select="$sOrig"/>
                        <xsl:with-param name="sReplacement" select="$sReplacement"/>
                    </xsl:call-template>
                </xsl:variable>

                <xsl:value-of select="concat($sBefore, concat($sReplacement, $sAfterProcessed))"/>
            </xsl:otherwise>
        </xsl:choose>
    </xsl:template>

    <!--  -->
    <xsl:template match="m:e | m:den | m:num | m:lim | m:sup | m:sub">
        <xsl:choose>

            <!-- If there is no scriptLevel speified, just call through -->
            <xsl:when test="not(m:argPr[last()]/m:scrLvl/@m:val)">
                <!-- DPC make sure only one element returned -->
                <mml:mrow>
                    <xsl:apply-templates select="*"/>
                </mml:mrow>
            </xsl:when>

            <!-- Otherwise, create an mstyle and set the script level -->
            <xsl:otherwise>
                <mml:mstyle>
                    <xsl:attribute name="scriptlevel">
                        <xsl:value-of select="m:argPr[last()]/m:scrLvl/@m:val"/>
                    </xsl:attribute>
                    <xsl:apply-templates select="*"/>
                </mml:mstyle>
            </xsl:otherwise>
        </xsl:choose>
    </xsl:template>

    <!--
    MS stylesheet uses DOE which is (a) unevil, (b) non necessary, and (c) breaks the pass through a temporay tree to get rid of namespace nodes.
    repeat the templates here without doe (and without double quoting amp)
  -->
    <xsl:template match="m:nary">
        <xsl:variable name="sLowerCaseSubHide">
            <xsl:choose>
                <xsl:when test="count(m:naryPr[last()]/m:subHide) = 0">
                    <xsl:text>off</xsl:text>
                </xsl:when>
                <xsl:otherwise>
                    <xsl:value-of select="translate(m:naryPr[last()]/m:subHide/@m:val,
            'ABCDEFGHIJKLMNOPQRSTUVWXYZ',
            'abcdefghijklmnopqrstuvwxyz')"/>
                </xsl:otherwise>
            </xsl:choose>
        </xsl:variable>
        <xsl:variable name="sLowerCaseSupHide">
            <xsl:choose>
                <xsl:when test="count(m:naryPr[last()]/m:supHide) = 0">
                    <xsl:text>off</xsl:text>
                </xsl:when>
                <xsl:otherwise>
                    <xsl:value-of select="translate(m:naryPr[last()]/m:supHide/@m:val,
            'ABCDEFGHIJKLMNOPQRSTUVWXYZ',
            'abcdefghijklmnopqrstuvwxyz')"/>
                </xsl:otherwise>
            </xsl:choose>
        </xsl:variable>
        <xsl:choose>
            <xsl:when test="not($sLowerCaseSupHide='off') and
        not($sLowerCaseSubHide='off')">
                <mml:mo>
                    <xsl:choose>
                        <xsl:when test="not(m:naryPr[last()]/m:chr/@m:val) or
              m:naryPr[last()]/m:chr/@m:val=''">
                            <xsl:text disable-output-escaping="no">&#x222b;</xsl:text>
                        </xsl:when>
                        <xsl:otherwise>
                            <xsl:value-of select="m:naryPr[last()]/m:chr/@m:val"/>
                        </xsl:otherwise>
                    </xsl:choose>
                </mml:mo>
            </xsl:when>
            <xsl:when test="not($sLowerCaseSubHide='off')">
                <xsl:choose>
                    <xsl:when test="m:naryPr[last()]/m:limLoc/@m:val='subSup'">
                        <mml:msup>
                            <mml:mo>
                                <xsl:choose>
                                    <xsl:when test="not(m:naryPr[last()]/m:chr/@m:val) or
                    m:naryPr[last()]/m:chr/@m:val=''">
                                        <xsl:text disable-output-escaping="no">&#x222b;</xsl:text>
                                    </xsl:when>
                                    <xsl:otherwise>
                                        <xsl:value-of select="m:naryPr[last()]/m:chr/@m:val"/>
                                    </xsl:otherwise>
                                </xsl:choose>
                            </mml:mo>
                            <xsl:apply-templates select="m:sup[1]"/>
                        </mml:msup>
                    </xsl:when>
                    <xsl:otherwise>
                        <mml:mover>
                            <mml:mo>
                                <xsl:choose>
                                    <xsl:when test="not(m:naryPr[last()]/m:chr/@m:val) or
                    m:naryPr[last()]/m:chr/@m:val=''">
                                        <xsl:text disable-output-escaping="no">&#x222b;</xsl:text>
                                    </xsl:when>
                                    <xsl:otherwise>
                                        <xsl:value-of select="m:naryPr[last()]/m:chr/@m:val"/>
                                    </xsl:otherwise>
                                </xsl:choose>
                            </mml:mo>
                            <xsl:apply-templates select="m:sup[1]"/>
                        </mml:mover>
                    </xsl:otherwise>
                </xsl:choose>
            </xsl:when>
            <xsl:when test="not($sLowerCaseSupHide='off')">
                <xsl:choose>
                    <xsl:when test="m:naryPr[last()]/m:limLoc/@m:val='subSup'">
                        <mml:msub>
                            <mml:mo>
                                <xsl:choose>
                                    <xsl:when test="not(m:naryPr[last()]/m:chr/@m:val) or
                    m:naryPr[last()]/m:chr/@m:val=''">
                                        <xsl:text disable-output-escaping="no">&#x222b;</xsl:text>
                                    </xsl:when>
                                    <xsl:otherwise>
                                        <xsl:value-of select="m:naryPr[last()]/m:chr/@m:val"/>
                                    </xsl:otherwise>
                                </xsl:choose>
                            </mml:mo>
                            <xsl:apply-templates select="m:sub[1]"/>
                        </mml:msub>
                    </xsl:when>
                    <xsl:otherwise>
                        <mml:munder>
                            <mml:mo>
                                <xsl:choose>
                                    <xsl:when test="not(m:naryPr[last()]/m:chr/@m:val) or
                    m:naryPr[last()]/m:chr/@m:val=''">
                                        <xsl:text disable-output-escaping="no">&#x222b;</xsl:text>
                                    </xsl:when>
                                    <xsl:otherwise>
                                        <xsl:value-of select="m:naryPr[last()]/m:chr/@m:val"/>
                                    </xsl:otherwise>
                                </xsl:choose>
                            </mml:mo>
                            <xsl:apply-templates select="m:sub[1]"/>
                        </mml:munder>
                    </xsl:otherwise>
                </xsl:choose>
            </xsl:when>
            <xsl:otherwise>
                <xsl:choose>
                    <xsl:when test="m:naryPr[last()]/m:limLoc/@m:val='subSup'">
                        <mml:msubsup>
                            <mml:mo>
                                <xsl:choose>
                                    <xsl:when test="not(m:naryPr[last()]/m:chr/@m:val) or
                    m:naryPr[last()]/m:chr/@m:val=''">
                                        <xsl:text disable-output-escaping="no">&#x222b;</xsl:text>
                                    </xsl:when>
                                    <xsl:otherwise>
                                        <xsl:value-of select="m:naryPr[last()]/m:chr/@m:val"/>
                                    </xsl:otherwise>
                                </xsl:choose>
                            </mml:mo>
                            <xsl:apply-templates select="m:sub[1]"/>
                            <xsl:apply-templates select="m:sup[1]"/>
                        </mml:msubsup>
                    </xsl:when>
                    <xsl:otherwise>
                        <mml:munderover>
                            <mml:mo>
                                <xsl:choose>
                                    <xsl:when test="not(m:naryPr[last()]/m:chr/@m:val) or
                    m:naryPr[last()]/m:chr/@m:val=''">
                                        <xsl:text disable-output-escaping="no">&#x222b;</xsl:text>
                                    </xsl:when>
                                    <xsl:otherwise>
                                        <xsl:value-of select="m:naryPr[last()]/m:chr/@m:val"/>
                                    </xsl:otherwise>
                                </xsl:choose>
                            </mml:mo>
                            <xsl:apply-templates select="m:sub[1]"/>
                            <xsl:apply-templates select="m:sup[1]"/>
                        </mml:munderover>
                    </xsl:otherwise>
                </xsl:choose>
            </xsl:otherwise>
        </xsl:choose>
        <mml:mrow>
            <xsl:apply-templates select="m:e[1]"/>
        </mml:mrow>
    </xsl:template>


    <!--<xsl:template name="CreateGroupChr">
    <xsl:variable name="sLowerCasePos" select="translate(m:groupChrPr[last()]/m:pos/@m:val,
      'ABCDEFGHIJKLMNOPQRSTUVWXYZ',
      'abcdefghijklmnopqrstuvwxyz')" />
    <xsl:choose>
      <xsl:when test="$sLowerCasePos!='top' or
        not(m:groupChrPr[last()]/m:pos/@m:val)   or
        m:groupChrPr[last()]/m:pos/@m:val=''">
        <mml:munder>
          <xsl:apply-templates select="m:e[1]" />
          <mml:mo>
            <xsl:choose>
              <xsl:when test="string-length(m:groupChrPr[last()]/m:chr/@m:val) &gt;= 1">
                <xsl:value-of select="substring(m:groupChrPr[last()]/m:chr/@m:val,1,1)" />
              </xsl:when>
              <xsl:otherwise>
                <xsl:text disable-output-escaping="no">&#x023DF;</xsl:text>
              </xsl:otherwise>
            </xsl:choose>
          </mml:mo>
        </mml:munder>
      </xsl:when>
      <xsl:otherwise>
        <mml:mover>
          <xsl:apply-templates select="m:e[1]" />
          <mml:mo>
            <xsl:choose>
              <xsl:when test="string-length(m:groupChrPr[last()]/m:chr/@m:val) &gt;= 1">
                <xsl:value-of select="substring(m:groupChrPr[last()]/m:chr/@m:val,1,1)" />
              </xsl:when>
              <xsl:otherwise>
                <xsl:text disable-output-escaping="no">&#x023DF;</xsl:text>
              </xsl:otherwise>
            </xsl:choose>
          </mml:mo>
        </mml:mover>
      </xsl:otherwise>
    </xsl:choose>
  </xsl:template>-->
    <xsl:template match="m:sSub">
        <mml:msub>
            <mml:mrow>
                <xsl:apply-templates select="m:e[1]"/>
            </mml:mrow>
            <mml:mrow>
                <xsl:apply-templates select="m:sub[1]"/>
            </mml:mrow>
        </mml:msub>
    </xsl:template>

    <xsl:template match="m:sSup">
        <mml:msup>
            <mml:mrow>
                <xsl:apply-templates select="m:e[1]"/>
            </mml:mrow>
            <mml:mrow>
                <xsl:apply-templates select="m:sup[1]"/>
            </mml:mrow>
        </mml:msup>
    </xsl:template>

    <xsl:template match="m:sSubSup">
        <mml:msubsup>
            <mml:mrow>
                <xsl:apply-templates select="m:e[1]"/>
            </mml:mrow>
            <mml:mrow>
                <xsl:apply-templates select="m:sub[1]"/>
            </mml:mrow>
            <mml:mrow>
                <xsl:apply-templates select="m:sup[1]"/>
            </mml:mrow>
        </mml:msubsup>
    </xsl:template>

    <xsl:template match="m:groupChr">
        <xsl:variable name="sLowerCaseOpEmu" select="translate(m:groupChrPr[last()]/m:opEmu/@m:val,
      'ABCDEFGHIJKLMNOPQRSTUVWXYZ',
      'abcdefghijklmnopqrstuvwxyz')"/>
        <xsl:choose>
            <xsl:when test="$sLowerCaseOpEmu='on'">
                <mml:mrow>
                    <xsl:call-template name="CreateGroupChr"/>
                </mml:mrow>
            </xsl:when>
            <xsl:otherwise>
                <xsl:call-template name="CreateGroupChr"/>
            </xsl:otherwise>
        </xsl:choose>
    </xsl:template>


    <!--Display cos,sin -->
    <xsl:template name="fName">
        <xsl:for-each select="m:fName/*">
            <xsl:apply-templates select="."/>
        </xsl:for-each>
    </xsl:template>

    <xsl:template match="m:func">
        <mml:mrow>
            <mml:mrow>
                <xsl:call-template name="fName"/>
            </mml:mrow>
            <mml:mo>&#x02061;</mml:mo>
            <xsl:apply-templates select="*[position() &gt; 1]"/>
        </mml:mrow>
    </xsl:template>

    <!-- %%Template: match m:f

    m:f maps directly to mfrac.
  -->
    <xsl:template match="m:f">
        <mml:mfrac>
            <xsl:call-template name="CreateMathMLFracProp">
                <xsl:with-param name="type" select="m:fPr[last()]/m:type/@m:val"/>
                <xsl:with-param name="baseJc" select="m:fPr[last()]/m:baseJc/@m:val"/>
                <xsl:with-param name="numJc" select="m:fPr[last()]/m:numJc/@m:val"/>
                <xsl:with-param name="denJc" select="m:fPr[last()]/m:type/@m:val"/>
            </xsl:call-template>

            <mml:mrow>
                <xsl:apply-templates select="m:num[1]"/>
            </mml:mrow>
            <mml:mrow>
                <xsl:apply-templates select="m:den[1]"/>
            </mml:mrow>
        </mml:mfrac>
    </xsl:template>

    <!-- %%Template: CreateMathMLFracProp

    Make fraction properties based on supplied parameters.
    OMML differentiates between a linear fraction and a skewed
    one. For MathML, we write both as bevelled.
  -->
    <xsl:template name="CreateMathMLFracProp">
        <xsl:param name="type"/>
        <xsl:param name="baseJc"/>
        <xsl:param name="numJc"/>
        <xsl:param name="denJc"/>
        <xsl:variable name="sLowerCaseType"
                      select="translate($type, 'ABCDEFGHIJKLMNOPQRSTUVWXYZ', 'abcdefghijklmnopqrstuvwxyz')"/>
        <xsl:variable name="sLowerCaseNumJc"
                      select="translate($numJc, 'ABCDEFGHIJKLMNOPQRSTUVWXYZ', 'abcdefghijklmnopqrstuvwxyz')"/>
        <xsl:variable name="sLowerCaseDenJc"
                      select="translate($denJc, 'ABCDEFGHIJKLMNOPQRSTUVWXYZ', 'abcdefghijklmnopqrstuvwxyz')"/>

        <xsl:if test="$sLowerCaseType='skw' or $sLowerCaseType='lin'">
            <xsl:attribute name="bevelled">true</xsl:attribute>
        </xsl:if>
        <xsl:if test="$sLowerCaseType='nobar'">
            <xsl:attribute name="linethickness">0pt</xsl:attribute>
        </xsl:if>
        <xsl:choose>
            <xsl:when test="sLowerCaseNumJc='right'">
                <xsl:attribute name="numalign">right</xsl:attribute>
            </xsl:when>
            <xsl:when test="sLowerCaseNumJc='left'">
                <xsl:attribute name="numalign">left</xsl:attribute>
            </xsl:when>
        </xsl:choose>
        <xsl:choose>
            <xsl:when test="sLowerCaseDenJc='right'">
                <xsl:attribute name="numalign">right</xsl:attribute>
            </xsl:when>
            <xsl:when test="sLowerCaseDenJc='left'">
                <xsl:attribute name="numalign">left</xsl:attribute>
            </xsl:when>
        </xsl:choose>
    </xsl:template>

    <xsl:template match="m:bar">
        <xsl:variable name="sLowerCasePos" select="translate(m:barPr/m:pos/@m:val, 'ABCDEFGHIJKLMNOPQRSTUVWXYZ',
      'abcdefghijklmnopqrstuvwxyz')"/>
        <xsl:choose>
            <xsl:when test="$sLowerCasePos!='bot' or
        not($sLowerCasePos)   or
        $sLowerCasePos=''   ">
                <mml:mover>
                    <xsl:attribute name="accent">true</xsl:attribute>
                    <xsl:apply-templates select="m:e[1]"/>
                    <mml:mo>
                        <xsl:text disable-output-escaping="yes">&amp;#x000AF;</xsl:text>
                    </mml:mo>
                </mml:mover>
            </xsl:when>
            <xsl:otherwise>
                <mml:munder>
                    <xsl:apply-templates select="m:e[1]"/>
                    <mml:mo>
                        <xsl:text disable-output-escaping="yes">&amp;#x00332;</xsl:text>
                    </mml:mo>
                </mml:munder>
            </xsl:otherwise>
        </xsl:choose>
    </xsl:template>

    <!-- %%Template match m:d

    Process a delimiter.
  -->
    <xsl:template match="m:d">
        <mml:mfenced>
            <!-- open: default is ( for both OMML and MathML -->
            <xsl:if test="m:dPr[1]/m:begChr/@m:val and not(m:dPr[1]/m:begChr/@m:val ='(')">
                <xsl:attribute name="open">
                    <xsl:value-of select="m:dPr[1]/m:begChr/@m:val"/>
                </xsl:attribute>
            </xsl:if>

            <!-- close: default is ) for both OMML and MathML -->
            <xsl:if test="m:dPr[1]/m:endChr/@m:val and not(m:dPr[1]/m:endChr/@m:val =')')">
                <xsl:attribute name="close">
                    <xsl:value-of select="m:dPr[1]/m:endChr/@m:val"/>
                </xsl:attribute>
            </xsl:if>

            <!-- separator: the default is ',' for MathML, and '|' for OMML -->
            <xsl:choose>
                <!-- Matches MathML default. Write nothing -->
                <xsl:when test="m:dPr[1]/m:sepChr/@m:val = ','"/>

                <!-- OMML default: | -->
                <xsl:when test="not(m:dPr[1]/m:sepChr/@m:val)">
                    <xsl:attribute name="separators">
                        <xsl:value-of select="'|'"/>
                    </xsl:attribute>
                </xsl:when>

                <xsl:otherwise>
                    <xsl:attribute name="separators">
                        <xsl:value-of select="m:dPr[1]/m:sepChr/@m:val"/>
                    </xsl:attribute>
                </xsl:otherwise>
            </xsl:choose>

            <!-- now write all the children. Put each one into an mrow
        just in case it produces multiple runs, etc -->
            <xsl:for-each select="m:e">
                <mml:mrow>
                    <xsl:apply-templates select="."/>
                </mml:mrow>
            </xsl:for-each>
        </mml:mfenced>
    </xsl:template>

    <xsl:template match="m:r">
        <xsl:variable name="sLowerCaseNor" select="translate(child::m:rPr[last()]/m:nor/@m:val, 'ABCDEFGHIJKLMNOPQRSTUVWXYZ',
      'abcdefghijklmnopqrstuvwxyz')"/>
        <xsl:choose>
            <xsl:when test="$sLowerCaseNor='on'">
                <mml:mtext>
                    <xsl:value-of select=".//m:t"/>
                </mml:mtext>
            </xsl:when>
            <xsl:otherwise>
                <xsl:for-each select=".//m:t">
                    <xsl:call-template name="ParseMt">
                        <xsl:with-param name="sToParse" select="text()"/>
                        <xsl:with-param name="mscr" select="../m:rPr[last()]/m:scr/@m:val"/>
                        <xsl:with-param name="msty" select="../m:rPr[last()]/m:sty/@m:val"/>
                        <xsl:with-param name="mnor" select="../m:rPr[last()]/m:nor/@m:val"/>
                    </xsl:call-template>
                </xsl:for-each>
            </xsl:otherwise>
        </xsl:choose>
    </xsl:template>

    <xsl:template name="CreateAttributesforToken">
        <xsl:param name="mscr"/>
        <xsl:param name="msty"/>
        <xsl:param name="mnor"/>
        <xsl:param name="nCharToPrint"/>
        <xsl:param name="sTokenType"/>
        <xsl:variable name="sLowerCaseNor" select="translate($mnor, 'ABCDEFGHIJKLMNOPQRSTUVWXYZ',
      'abcdefghijklmnopqrstuvwxyz')"/>
        <xsl:choose>
            <xsl:when test="$sLowerCaseNor = 'on'">
                <xsl:attribute name="mathvariant">normal</xsl:attribute>
            </xsl:when>
            <xsl:otherwise>
                <xsl:variable name="mathvariant">
                    <xsl:choose>
                        <!-- numbers don't care -->
                        <xsl:when test="$sTokenType='mn'"/>

                        <xsl:when test="$mscr='monospace'">monospace</xsl:when>
                        <xsl:when test="$mscr='sans-serif' and $msty='i'">sans-serif-italic</xsl:when>
                        <xsl:when test="$mscr='sans-serif' and $msty='b'">bold-sans-serif</xsl:when>
                        <xsl:when test="$mscr='sans-serif'">sans-serif</xsl:when>
                        <xsl:when test="$mscr='fraktur' and $msty='b'">bold-fraktur</xsl:when>
                        <xsl:when test="$mscr='fraktur'">fraktur</xsl:when>
                        <xsl:when test="$mscr='double-struck'">double-struck</xsl:when>
                        <xsl:when test="$mscr='script' and $msty='b'">bold-script</xsl:when>
                        <xsl:when test="$mscr='script'">script</xsl:when>
                        <xsl:when test="($mscr='roman' or not($mscr) or $mscr='') and $msty='b'">bold</xsl:when>
                        <xsl:when test="($mscr='roman' or not($mscr) or $mscr='') and $msty='i'">italic</xsl:when>
                        <xsl:when test="($mscr='roman' or not($mscr) or $mscr='') and $msty='p'">normal</xsl:when>

                        <xsl:otherwise/>
                    </xsl:choose>
                </xsl:variable>
                <xsl:variable name="fontweight">
                    <xsl:choose>
                        <xsl:when test="$msty='b' or $msty='bi'">bold</xsl:when>
                        <xsl:otherwise>normal</xsl:otherwise>
                    </xsl:choose>
                </xsl:variable>
                <xsl:variable name="fontstyle">
                    <xsl:choose>
                        <xsl:when test="$msty='p' or $msty='b'">normal</xsl:when>
                        <xsl:otherwise>italic</xsl:otherwise>
                    </xsl:choose>
                </xsl:variable>

                <!-- Writing of attributes begins here -->
                <xsl:choose>
                    <!-- Don't write mathvariant for operators unless they want to be normal -->
                    <xsl:when test="$sTokenType='mo' and $mathvariant!='normal'"/>

                    <!-- A single character within an mi is already italics, don't write -->
                    <xsl:when
                            test="$sTokenType='mi' and $nCharToPrint=1 and ($mathvariant='' or $mathvariant='italic')"/>

                    <xsl:when
                            test="$sTokenType='mi' and $nCharToPrint &gt; 1 and ($mathvariant='' or $mathvariant='italic')">
                        <xsl:attribute name="mathvariant">
                            <xsl:value-of select="'italic'"/>
                        </xsl:attribute>
                    </xsl:when>
                    <xsl:when test="$mathvariant!='italic' and $mathvariant!=''">
                        <xsl:attribute name="mathvariant">
                            <xsl:value-of select="$mathvariant"/>
                        </xsl:attribute>
                    </xsl:when>
                    <xsl:otherwise>
                        <xsl:if test="not($sTokenType='mi' and $nCharToPrint=1) and $fontstyle='italic'">
                            <xsl:attribute name="fontstyle">italic</xsl:attribute>
                        </xsl:if>
                        <xsl:if test="$fontweight='bold'">
                            <xsl:attribute name="fontweight">bold</xsl:attribute>
                        </xsl:if>
                    </xsl:otherwise>
                </xsl:choose>
            </xsl:otherwise>
        </xsl:choose>
    </xsl:template>

    <xsl:template match="m:eqArr">
        <mml:mtable>
            <xsl:attribute name="frame">none</xsl:attribute>
            <xsl:attribute name="columnlines">none</xsl:attribute>
            <xsl:attribute name="rowlines">none</xsl:attribute>
            <xsl:for-each select="m:e">
                <mml:mtr>
                    <mml:mtd>
                        <mml:maligngroup/>
                        <xsl:choose>
                            <xsl:when test="m:argPr[last()]/m:scrLvl/@m:val!='0' or
                not(m:argPr[last()]/m:scrLvl/@m:val)  or
                m:argPr[last()]/m:scrLvl/@m:val=''">
                                <mml:mrow>
                                    <xsl:call-template name="CreateEqArrRow">
                                        <xsl:with-param name="align" select="1"/>
                                        <xsl:with-param name="ndCur" select="*[1]"/>
                                    </xsl:call-template>
                                </mml:mrow>
                            </xsl:when>
                            <xsl:otherwise>
                                <mml:mstyle>
                                    <xsl:attribute name="scriptlevel">
                                        <xsl:value-of select="m:argPr[last()]/m:scrLvl/@m:val"/>
                                    </xsl:attribute>
                                    <xsl:call-template name="CreateEqArrRow">
                                        <xsl:with-param name="align" select="1"/>
                                        <xsl:with-param name="ndCur" select="*[1]"/>
                                    </xsl:call-template>
                                </mml:mstyle>
                            </xsl:otherwise>
                        </xsl:choose>
                    </mml:mtd>
                </mml:mtr>
            </xsl:for-each>
        </mml:mtable>
    </xsl:template>

    <xsl:template name="CreateEqArrRow">
        <xsl:param name="align"/>
        <xsl:param name="ndCur"/>
        <xsl:variable name="sAllMt">
            <xsl:for-each select="$ndCur/m:t">
                <xsl:value-of select="."/>
            </xsl:for-each>
        </xsl:variable>
        <xsl:choose>
            <xsl:when test="local-name($ndCur)='r' and
        namespace-uri($ndCur)='http://schemas.microsoft.com/office/omml/2004/12/core'">

                <xsl:call-template name="ParseEqArrMr">
                    <xsl:with-param name="sToParse" select="$sAllMt"/>
                    <xsl:with-param name="mscr" select="../m:rPr[last()]/m:scr/@m:val"/>
                    <xsl:with-param name="msty" select="../m:rPr[last()]/m:sty/@m:val"/>
                    <xsl:with-param name="mnor" select="../m:rPr[last()]/m:nor/@m:val"/>
                    <xsl:with-param name="align" select="$align"/>
                </xsl:call-template>
            </xsl:when>
            <xsl:otherwise>
                <xsl:apply-templates select="$ndCur"/>
            </xsl:otherwise>
        </xsl:choose>
        <xsl:if test="count($ndCur/following-sibling::*) &gt; 0">
            <xsl:variable name="cAmp">
                <xsl:call-template name="CountAmp">
                    <xsl:with-param name="sAllMt" select="$sAllMt"/>
                    <xsl:with-param name="cAmp" select="0"/>
                </xsl:call-template>
            </xsl:variable>
            <xsl:call-template name="CreateEqArrRow">
                <xsl:with-param name="align" select="($align+($cAmp mod 2)) mod 2"/>
                <xsl:with-param name="ndCur" select="$ndCur/following-sibling::*[1]"/>
            </xsl:call-template>
        </xsl:if>
    </xsl:template>

    <xsl:template name="CountAmp">
        <xsl:param name="sAllMt"/>
        <xsl:param name="cAmp"/>
        <xsl:choose>
            <xsl:when test="string-length(substring-after($sAllMt, '&amp;')) &gt; 0 or
        substring($sAllMt, string-length($sAllMt))='&#x0026;'">
                <xsl:call-template name="CountAmp">
                    <xsl:with-param name="sAllMt" select="substring-after($sAllMt, '&#x0026;')"/>
                    <xsl:with-param name="cAmp" select="$cAmp+1"/>
                </xsl:call-template>
            </xsl:when>
            <xsl:otherwise>
                <xsl:value-of select="$cAmp"/>
            </xsl:otherwise>
        </xsl:choose>
    </xsl:template>

    <!-- %%Template: ParseEqArrMr

    Similar to ParseMt, but this one has to do more for an equation
    array. The presence of &amp; in a run that is in an equation array
    indicates alignment
  -->
    <xsl:template name="ParseEqArrMr">
        <xsl:param name="sToParse"/>
        <xsl:param name="msty"/>
        <xsl:param name="mscr"/>
        <xsl:param name="mnor"/>
        <xsl:param name="align"/>
        <xsl:if test="string-length($sToParse) &gt; 0">
            <xsl:choose>
                <xsl:when test="substring($sToParse,1,1) = '&amp;'">
                    <xsl:choose>
                        <xsl:when test="$align='0'">
                            <mml:maligngroup/>
                        </xsl:when>
                        <xsl:when test="$align='1'">
                            <mml:malignmark>
                                <xsl:attribute name="edge">left</xsl:attribute>
                            </mml:malignmark>
                        </xsl:when>
                    </xsl:choose>
                    <xsl:call-template name="ParseEqArrMr">
                        <xsl:with-param name="sToParse" select="substring($sToParse,2)"/>
                        <xsl:with-param name="mscr" select="$mscr"/>
                        <xsl:with-param name="msty" select="$msty"/>
                        <xsl:with-param name="mnor" select="$mnor"/>
                        <xsl:with-param name="align">
                            <xsl:choose>
                                <xsl:when test="$align='1'">0</xsl:when>
                                <xsl:otherwise>1</xsl:otherwise>
                            </xsl:choose>
                        </xsl:with-param>
                    </xsl:call-template>
                </xsl:when>
                <xsl:otherwise>
                    <xsl:variable name="sRepNumWith1">
                        <xsl:call-template name="SReplaceNumWithOne">
                            <xsl:with-param name="sToParse" select="$sToParse"/>
                        </xsl:call-template>
                    </xsl:variable>
                    <xsl:variable name="sRepOperWith-">
                        <xsl:call-template name="SReplaceOperWithMinus">
                            <xsl:with-param name="sToParse" select="$sRepNumWith1"/>
                        </xsl:call-template>
                    </xsl:variable>

                    <xsl:variable name="iFirstOper"
                                  select="string-length($sRepOperWith-) - string-length(substring-after($sRepOperWith-, '-'))"/>
                    <xsl:variable name="iFirstNum"
                                  select="string-length($sRepOperWith-) - string-length(substring-after($sRepOperWith-, '0'))"/>
                    <xsl:variable name="iFirstAmp"
                                  select="string-length($sRepOperWith-) - string-length(substring-after($sRepOperWith-, '&#x0026;'))"/>
                    <xsl:variable name="fNumAtPos1">
                        <xsl:choose>
                            <xsl:when test="substring($sRepOperWith-,1,1)='0'">1</xsl:when>
                            <xsl:otherwise>0</xsl:otherwise>
                        </xsl:choose>
                    </xsl:variable>
                    <xsl:variable name="fOperAtPos1">
                        <xsl:choose>
                            <xsl:when test="substring($sRepOperWith-,1,1)='-'">1</xsl:when>
                            <xsl:otherwise>0</xsl:otherwise>
                        </xsl:choose>
                    </xsl:variable>
                    <xsl:choose>

                        <!-- Case I: The string begins with neither a number, nor an operator -->
                        <xsl:when test="$fNumAtPos1='0' and $fOperAtPos1='0'">
                            <xsl:variable name="nCharToPrint">
                                <xsl:choose>
                                    <xsl:when test="($iFirstOper=$iFirstNum) and
                    ($iFirstAmp=$iFirstOper) and
                    ($iFirstOper=string-length($sToParse)) and
                    $fNumAtPos1='0' and
                    $fOperAtPos1='0'">
                                        <xsl:value-of select="string-length($sToParse)"/>
                                    </xsl:when>
                                    <xsl:when test="($iFirstOper &lt; $iFirstNum) and
                    ($iFirstOper &lt; $iFirstAmp)">
                                        <xsl:value-of select="$iFirstOper - 1"/>
                                    </xsl:when>
                                    <xsl:when test="($iFirstNum &lt; $iFirstOper) and
                    ($iFirstNum &lt; $iFirstAmp)">
                                        <xsl:value-of select="$iFirstNum - 1"/>
                                    </xsl:when>
                                    <xsl:otherwise>
                                        <xsl:value-of select="$iFirstAmp - 1"/>
                                    </xsl:otherwise>
                                </xsl:choose>
                            </xsl:variable>
                            <mml:mi>
                                <xsl:call-template name="CreateAttributesforToken">
                                    <xsl:with-param name="mscr" select="$mscr"/>
                                    <xsl:with-param name="msty" select="$msty"/>
                                    <xsl:with-param name="mnor" select="$mnor"/>
                                    <xsl:with-param name="nCharToPrint" select="$nCharToPrint"/>
                                    <xsl:with-param name="sTokenType" select="'mi'"/>
                                </xsl:call-template>
                                <xsl:value-of select="substring($sToParse,1,$nCharToPrint)"/>
                            </mml:mi>
                            <xsl:call-template name="ParseEqArrMr">
                                <xsl:with-param name="sToParse" select="substring($sToParse, $nCharToPrint+1)"/>
                                <xsl:with-param name="mscr" select="$mscr"/>
                                <xsl:with-param name="msty" select="$msty"/>
                                <xsl:with-param name="mnor" select="$mnor"/>
                                <xsl:with-param name="align" select="$align"/>
                            </xsl:call-template>
                        </xsl:when>

                        <!-- Case II: There is an operator at position 1 -->
                        <xsl:when test="$fOperAtPos1='1'">
                            <mml:mo>
                                <xsl:call-template name="CreateAttributesforToken">
                                    <xsl:with-param name="mscr"/>
                                    <xsl:with-param name="msty"/>
                                    <xsl:with-param name="mnor" select="$mnor"/>
                                    <xsl:with-param name="sTokenType" select="'mo'"/>
                                </xsl:call-template>
                                <xsl:value-of select="substring($sToParse,1,1)"/>
                            </mml:mo>
                            <xsl:call-template name="ParseEqArrMr">
                                <xsl:with-param name="sToParse" select="substring($sToParse, 2)"/>
                                <xsl:with-param name="mscr" select="$mscr"/>
                                <xsl:with-param name="msty" select="$msty"/>
                                <xsl:with-param name="mnor" select="$mnor"/>
                                <xsl:with-param name="align" select="$align"/>
                            </xsl:call-template>
                        </xsl:when>

                        <!-- Case III: There is a number at position 1 -->
                        <xsl:otherwise>
                            <xsl:variable name="sConsecNum">
                                <xsl:call-template name="SNumStart">
                                    <xsl:with-param name="sToParse" select="$sToParse"/>
                                    <xsl:with-param name="sPattern" select="$sRepNumWith1"/>
                                </xsl:call-template>
                            </xsl:variable>
                            <mml:mn>
                                <xsl:call-template name="CreateAttributesforToken">
                                    <xsl:with-param name="mscr"/>
                                    <xsl:with-param name="msty"/>
                                    <xsl:with-param name="mnor" select="$mnor"/>
                                    <xsl:with-param name="sTokenType" select="'mn'"/>
                                </xsl:call-template>
                                <xsl:value-of select="$sConsecNum"/>
                            </mml:mn>
                            <xsl:call-template name="ParseEqArrMr">
                                <xsl:with-param name="sToParse" select="substring-after($sToParse, $sConsecNum)"/>
                                <xsl:with-param name="mscr" select="$mscr"/>
                                <xsl:with-param name="msty" select="$msty"/>
                                <xsl:with-param name="mnor" select="$mnor"/>
                                <xsl:with-param name="align" select="$align"/>
                            </xsl:call-template>
                        </xsl:otherwise>
                    </xsl:choose>
                </xsl:otherwise>
            </xsl:choose>
        </xsl:if>
    </xsl:template>

    <!-- %%Template: SNumStart

    Return the longest substring of sToParse starting from the
    start of sToParse that is a number. In addition, it takes the
    pattern string, which is sToParse with all of its numbers
    replaced with a 0. sPattern should be the same length
    as sToParse
  -->
    <xsl:template name="SNumStart">
        <xsl:param name="sToParse" select="''"/>
        <xsl:param name="sPattern" select="'$sToParse'"/>    <!-- if we don't get anything, take the string itself -->

        <xsl:choose>
            <!-- the pattern says this is a number, recurse with the rest -->
            <xsl:when test="substring($sPattern, 1, 1) = '1'">
                <xsl:call-template name="SNumStart">
                    <xsl:with-param name="sToParse" select="$sToParse"/>
                    <xsl:with-param name="sPattern" select="substring($sPattern, 2)"/>
                </xsl:call-template>
            </xsl:when>

            <!-- the pattern says we've run out of numbers. Take as many
        characters from sToParse as we shaved off sPattern -->
            <xsl:otherwise>
                <xsl:value-of select="substring($sToParse, 1, string-length($sToParse) - string-length($sPattern))"/>
            </xsl:otherwise>
        </xsl:choose>
    </xsl:template>
    <!-- %%Template: ParseMt

    Produce a run of text. Technically, OMML makes no distinction
    between numbers, operators, and other characters in a run. For
    MathML we need to break these into mi, mn, or mo elements.

    See also ParseEqArrMr
  -->
    <xsl:template name="ParseMt">
        <xsl:param name="sToParse"/>
        <xsl:param name="msty"/>
        <xsl:param name="mscr"/>
        <xsl:param name="mnor"/>
        <xsl:if test="string-length($sToParse) &gt; 0">
            <xsl:variable name="sRepNumWith1">
                <xsl:call-template name="SReplaceNumWithOne">
                    <xsl:with-param name="sToParse" select="$sToParse"/>
                </xsl:call-template>
            </xsl:variable>
            <xsl:variable name="sRepOperWith-">
                <xsl:call-template name="SReplaceOperWithMinus">
                    <xsl:with-param name="sToParse" select="$sRepNumWith1"/>
                </xsl:call-template>
            </xsl:variable>

            <xsl:variable name="iFirstOper"
                          select="string-length($sRepOperWith-) - string-length(substring-after($sRepOperWith-, '-'))"/>
            <xsl:variable name="iFirstNum"
                          select="string-length($sRepOperWith-) - string-length(substring-after($sRepOperWith-, '0'))"/>
            <xsl:variable name="fNumAtPos1">
                <xsl:choose>
                    <xsl:when test="substring($sRepOperWith-,1,1)='1'">1</xsl:when>
                    <xsl:otherwise>0</xsl:otherwise>
                </xsl:choose>
            </xsl:variable>
            <xsl:variable name="fOperAtPos1">
                <xsl:choose>
                    <xsl:when test="substring($sRepOperWith-,1,1)='-'">1</xsl:when>
                    <xsl:otherwise>0</xsl:otherwise>
                </xsl:choose>
            </xsl:variable>

            <xsl:choose>

                <!-- Case I: The string begins with neither a number, nor an operator -->
                <xsl:when test="$fOperAtPos1='0' and $fNumAtPos1='0'">
                    <xsl:variable name="nCharToPrint">
                        <xsl:choose>
                            <xsl:when test="($iFirstOper=$iFirstNum) and
                ($iFirstOper=string-length($sToParse)) and
                (substring($sRepOperWith-, string-length($sRepOperWith-))!='0') and
                (substring($sRepOperWith-, string-length($sRepOperWith-))!='-')">
                                <xsl:value-of select="string-length($sToParse)"/>
                            </xsl:when>
                            <xsl:when test="$iFirstOper &lt; $iFirstNum">
                                <xsl:value-of select="$iFirstOper - 1"/>
                            </xsl:when>
                            <xsl:otherwise>
                                <xsl:value-of select="$iFirstNum - 1"/>
                            </xsl:otherwise>
                        </xsl:choose>
                    </xsl:variable>
                    <mml:mi>
                        <xsl:call-template name="CreateAttributesforToken">
                            <xsl:with-param name="mscr" select="$mscr"/>
                            <xsl:with-param name="msty" select="$msty"/>
                            <xsl:with-param name="mnor" select="$mnor"/>
                            <xsl:with-param name="nCharToPrint" select="$nCharToPrint"/>
                            <xsl:with-param name="sTokenType" select="'mi'"/>
                        </xsl:call-template>
                        <xsl:value-of select="translate(substring($sToParse,1,$nCharToPrint),' ','&nbsp;')"/>
                    </mml:mi>
                    <xsl:call-template name="ParseMt">
                        <xsl:with-param name="sToParse" select="substring($sToParse, $nCharToPrint+1)"/>
                        <xsl:with-param name="mscr" select="$mscr"/>
                        <xsl:with-param name="msty" select="$msty"/>
                        <xsl:with-param name="mnor" select="$mnor"/>
                    </xsl:call-template>
                </xsl:when>

                <!-- Case II: There is an operator at position 1 -->
                <xsl:when test="$fOperAtPos1='1'">
                    <mml:mo>
                        <xsl:call-template name="CreateAttributesforToken">
                            <xsl:with-param name="mscr"/>
                            <xsl:with-param name="msty"/>
                            <xsl:with-param name="mnor" select="$mnor"/>
                            <xsl:with-param name="sTokenType" select="'mo'"/>
                        </xsl:call-template>
                        <xsl:value-of select="substring($sToParse,1,1)"/>
                    </mml:mo>
                    <xsl:call-template name="ParseMt">
                        <xsl:with-param name="sToParse" select="substring($sToParse, 2)"/>
                        <xsl:with-param name="mscr" select="$mscr"/>
                        <xsl:with-param name="msty" select="$msty"/>
                        <xsl:with-param name="mnor" select="$mnor"/>
                    </xsl:call-template>
                </xsl:when>

                <!-- Case III: There is a number at position 1 -->
                <xsl:otherwise>
                    <xsl:variable name="sConsecNum">
                        <xsl:call-template name="SNumStart">
                            <xsl:with-param name="sToParse" select="$sToParse"/>
                            <xsl:with-param name="sPattern" select="$sRepNumWith1"/>
                        </xsl:call-template>
                    </xsl:variable>
                    <mml:mn>
                        <xsl:call-template name="CreateAttributesforToken">
                            <xsl:with-param name="mscr" select="$mscr"/>
                            <xsl:with-param name="msty" select="'p'"/>
                            <xsl:with-param name="mnor" select="$mnor"/>
                            <xsl:with-param name="sTokenType" select="'mn'"/>
                        </xsl:call-template>
                        <xsl:value-of select="$sConsecNum"/>
                    </mml:mn>
                    <xsl:call-template name="ParseMt">
                        <xsl:with-param name="sToParse" select="substring-after($sToParse, $sConsecNum)"/>
                        <xsl:with-param name="mscr" select="$mscr"/>
                        <xsl:with-param name="msty" select="$msty"/>
                        <xsl:with-param name="mnor" select="$mnor"/>
                    </xsl:call-template>
                </xsl:otherwise>
            </xsl:choose>
        </xsl:if>
    </xsl:template>
    <!-- %%Template SReplaceOperWithMinus

    Go through the given string and replace every instance
    of an operator with a minus '-'. This helps quickly identify
    the first instance of an operator.
  -->
    <xsl:template name="SReplaceOperWithMinus">
        <xsl:param name="sToParse" select="''"/>

        <xsl:value-of select="translate($sToParse, $sOperators, $sMinuses)"/>
    </xsl:template>
    <!-- %%Template SRepeatCharAcc

    The core of SRepeatChar with an accumulator. The current
    string is in param $acc, and we will double and recurse,
    if we're less than half of the required length or else just
    add the right amount of characters to the accumulator and
    return
  -->
    <xsl:template name="SRepeatCharAcc">
        <xsl:param name="cchRequired" select="1"/>
        <xsl:param name="ch" select="'-'"/>
        <xsl:param name="acc" select="$ch"/>

        <xsl:variable name="cchAcc" select="string-length($acc)"/>
        <xsl:choose>
            <xsl:when test="(2 * $cchAcc) &lt; $cchRequired">
                <xsl:call-template name="SRepeatCharAcc">
                    <xsl:with-param name="cchRequired" select="$cchRequired"/>
                    <xsl:with-param name="ch" select="$ch"/>
                    <xsl:with-param name="acc" select="concat($acc, $acc)"/>
                </xsl:call-template>
            </xsl:when>

            <xsl:otherwise>
                <xsl:value-of select="concat($acc, substring($acc, 1, $cchRequired - $cchAcc))"/>
            </xsl:otherwise>
        </xsl:choose>
    </xsl:template>


    <!-- %%Template SRepeatChar

    Generates a string nchRequired long by repeating the given character ch
  -->
    <xsl:template name="SRepeatChar">
        <xsl:param name="cchRequired" select="1"/>
        <xsl:param name="ch" select="'-'"/>

        <xsl:call-template name="SRepeatCharAcc">
            <xsl:with-param name="cchRequired" select="$cchRequired"/>
            <xsl:with-param name="ch" select="$ch"/>
            <xsl:with-param name="acc" select="$ch"/>
        </xsl:call-template>
    </xsl:template>

    <!-- %%Template SReplaceNumWithOne

    Go through the given string and replace every instance
    of an number with a One '1'. This helps quickly identify
    the first occurence of a number.

    Considers the '.' and ',' part of a number iff they are sandwiched
    between two other numbers. 1.3 will be recognized as a number,
    x.3 will not be. Since these characters can also be an operator, this
    should be called before SReplaceOperWithMinus.
  -->
    <xsl:template name="SReplaceNumWithOne">
        <xsl:param name="sToParse" select="''"/>

        <!-- First do a simple replace. Numbers will all be come 0's.
      After this point, the pattern involving the . or , that
      we are looking for will become 1.1 or 1,1 -->
        <xsl:variable name="sSimpleReplace" select="translate($sToParse, $sNumbers, $sOnes)"/>

        <!-- And then, replace 1.1 with just 111. This means that the . will
      become part of the number -->
        <xsl:variable name="sReplacePeriod">
            <xsl:call-template name="SReplace">
                <xsl:with-param name="sInput" select="$sSimpleReplace"/>
                <xsl:with-param name="sOrig" select="'1.1'"/>
                <xsl:with-param name="sReplacement" select="'111'"/>
            </xsl:call-template>
        </xsl:variable>

        <!-- And then, replace 1,1 with just 111. This means that the , will
      become part of the number -->
        <xsl:call-template name="SReplace">
            <xsl:with-param name="sInput" select="$sReplacePeriod"/>
            <xsl:with-param name="sOrig" select="'1,1'"/>
            <xsl:with-param name="sReplacement" select="'111'"/>
        </xsl:call-template>
    </xsl:template>
    <xsl:template match="m:m">
        <mml:mtable>
            <xsl:call-template name="CreateMathMLMatrixAttr">
                <xsl:with-param name="mcJc" select="m:mPr[last()]/m:mcs/m:mc/m:mcPr[last()]/m:mcJc/@m:val"/>
            </xsl:call-template>
            <xsl:for-each select="m:mr">
                <mml:mtr>
                    <xsl:for-each select="m:e">
                        <mml:mtd>
                            <xsl:apply-templates select="."/>
                        </mml:mtd>
                    </xsl:for-each>
                </mml:mtr>
            </xsl:for-each>
        </mml:mtable>
    </xsl:template>

    <xsl:template name="CreateMathMLMatrixAttr">
        <xsl:param name="mcJc"/>
        <xsl:variable name="sLowerCaseMcjc" select="translate($mcJc, 'ABCDEFGHIJKLMNOPQRSTUVWXYZ',
      'abcdefghijklmnopqrstuvwxyz')"/>
        <xsl:choose>
            <xsl:when test="$sLowerCaseMcjc='left'">
                <xsl:attribute name="columnalign">left</xsl:attribute>
            </xsl:when>
            <xsl:when test="$sLowerCaseMcjc='right'">
                <xsl:attribute name="columnalign">right</xsl:attribute>
            </xsl:when>
        </xsl:choose>
    </xsl:template>

    <xsl:template match="m:limLow">
        <mml:munder>
            <mml:mrow>
                <xsl:apply-templates select="m:e[1]"/>
            </mml:mrow>
            <mml:mrow>
                <xsl:apply-templates select="m:lim[1]"/>
            </mml:mrow>
        </mml:munder>
    </xsl:template>

    <xsl:template match="m:limUpp">
        <mml:mover>
            <mml:mrow>
                <xsl:apply-templates select="m:e[1]"/>
            </mml:mrow>
            <mml:mrow>
                <xsl:apply-templates select="m:lim[1]"/>
            </mml:mrow>
        </mml:mover>
    </xsl:template>

    <xsl:template match="m:rad">
        <xsl:variable name="sLowerCaseDegHide" select="translate(m:radPr[last()]/m:degHide/@m:val,
      'ABCDEFGHIJKLMNOPQRSTUVWXYZ',
      'abcdefghijklmnopqrstuvwxyz')"/>
        <xsl:choose>
            <xsl:when test="$sLowerCaseDegHide='on'">
                <mml:msqrt>
                    <xsl:apply-templates select="m:e[1]"/>
                </mml:msqrt>
            </xsl:when>
            <xsl:otherwise>
                <mml:mroot>
                    <mml:mrow>
                        <xsl:apply-templates select="m:e[1]"/>
                    </mml:mrow>
                    <mml:mrow>
                        <xsl:apply-templates select="m:deg[1]"/>
                    </mml:mrow>
                </mml:mroot>
            </xsl:otherwise>
        </xsl:choose>
    </xsl:template>
    <xsl:template match="m:acc">
        <mml:mover>
            <xsl:attribute name="accent">true</xsl:attribute>
            <xsl:apply-templates select="m:e[1]"/>
            <mml:mtext>
                <xsl:call-template name="CreateAttributesforToken">
                    <xsl:with-param name="mscr" select="m:e[1]/*/m:rPr[last()]/m:scr/@m:val"/>
                    <xsl:with-param name="msty" select="m:e[1]/*/m:rPr[last()]/m:sty/@m:val"/>
                    <xsl:with-param name="mnor" select="m:e[1]/*/m:rPr[last()]/m:nor/@m:val"/>
                </xsl:call-template>
                <xsl:choose>
                    <xsl:when test="not(m:accPr[last()]/m:chr)">
                        <xsl:value-of select="'&#x0302;'"/>
                    </xsl:when>
                    <xsl:otherwise>
                        <xsl:value-of select="substring(m:accPr/m:chr/@m:val,1,1)"/>
                    </xsl:otherwise>
                </xsl:choose>
            </mml:mtext>
        </mml:mover>
    </xsl:template>

    <xsl:template match="m:sPre">
        <mml:mmultiscripts>
            <mml:mrow>
                <xsl:apply-templates select="m:e[1]"/>
            </mml:mrow>
            <mml:mprescripts/>
            <mml:mrow>
                <xsl:apply-templates select="m:sub[1]"/>
            </mml:mrow>
            <mml:mrow>
                <xsl:apply-templates select="m:sup[1]"/>
            </mml:mrow>
        </mml:mmultiscripts>
    </xsl:template>

    <!-- Fixex -->
    <!-- avoid printing fnames twice -->
    <xsl:template match="m:func">
        <mml:mrow>
            <mml:mrow>
                <xsl:apply-templates select="m:fName[1]/*"/>
            </mml:mrow>
            <mml:mo></mml:mo>
            <xsl:apply-templates select="m:fName[1]/following-sibling::*"/>
        </mml:mrow>
    </xsl:template>

    <!-- m:r reconstituted from Word comments don't have character data in m:t it is directly i m:r (and style information is in interleaved span and i elements, weird but true -->

    <xsl:template match="m:r[not(.//m:t)]">
        <xsl:for-each select=".//text()[translate(.,' &#10;&amp;','')]">
            <xsl:call-template name="ParseMt">
                <xsl:with-param name="sToParse" select="translate(.,' &#10;&amp;','')"/>
                <xsl:with-param name="mscr" select="../m:rPr[last()]/m:scr/@m:val"/>
                <xsl:with-param name="msty" select="../m:rPr[last()]/m:sty/@m:val"/>
                <xsl:with-param name="mnor" select="../m:rPr[last()]/m:nor/@m:val"/>
            </xsl:call-template>
        </xsl:for-each>
    </xsl:template>

    <!--
    MS stylesheet uses DOE which is (a) unevil, (b) non necessary, and (c) breaks the pass through a temporay tree to get rid of namespace nodes.
    repeat the templates here without doe (and without double quoting amp)
  -->
    <xsl:template match="m:nary">
        <xsl:variable name="sLowerCaseSubHide">
            <xsl:choose>
                <xsl:when test="count(m:naryPr[last()]/m:subHide) = 0">
                    <xsl:text>off</xsl:text>
                </xsl:when>
                <xsl:otherwise>
                    <xsl:value-of select="translate(m:naryPr[last()]/m:subHide/@m:val,
            'ABCDEFGHIJKLMNOPQRSTUVWXYZ',
            'abcdefghijklmnopqrstuvwxyz')"/>
                </xsl:otherwise>
            </xsl:choose>
        </xsl:variable>
        <xsl:variable name="sLowerCaseSupHide">
            <xsl:choose>
                <xsl:when test="count(m:naryPr[last()]/m:supHide) = 0">
                    <xsl:text>off</xsl:text>
                </xsl:when>
                <xsl:otherwise>
                    <xsl:value-of select="translate(m:naryPr[last()]/m:supHide/@m:val,
            'ABCDEFGHIJKLMNOPQRSTUVWXYZ',
            'abcdefghijklmnopqrstuvwxyz')"/>
                </xsl:otherwise>
            </xsl:choose>
        </xsl:variable>
        <xsl:choose>
            <xsl:when test="not($sLowerCaseSupHide='off') and
        not($sLowerCaseSubHide='off')">
                <mml:mo>
                    <xsl:choose>
                        <xsl:when test="not(m:naryPr[last()]/m:chr/@m:val) or
              m:naryPr[last()]/m:chr/@m:val=''">
                            <xsl:text disable-output-escaping="no">&#x222b;</xsl:text>
                        </xsl:when>
                        <xsl:otherwise>
                            <xsl:value-of select="m:naryPr[last()]/m:chr/@m:val"/>
                        </xsl:otherwise>
                    </xsl:choose>
                </mml:mo>
            </xsl:when>
            <xsl:when test="not($sLowerCaseSubHide='off')">
                <xsl:choose>
                    <xsl:when test="m:naryPr[last()]/m:limLoc/@m:val='subSup'">
                        <mml:msup>
                            <mml:mo>
                                <xsl:choose>
                                    <xsl:when test="not(m:naryPr[last()]/m:chr/@m:val) or
                    m:naryPr[last()]/m:chr/@m:val=''">
                                        <xsl:text disable-output-escaping="no">&#x222b;</xsl:text>
                                    </xsl:when>
                                    <xsl:otherwise>
                                        <xsl:value-of select="m:naryPr[last()]/m:chr/@m:val"/>
                                    </xsl:otherwise>
                                </xsl:choose>
                            </mml:mo>
                            <xsl:apply-templates select="m:sup[1]"/>
                        </mml:msup>
                    </xsl:when>
                    <xsl:otherwise>
                        <mml:mover>
                            <mml:mo>
                                <xsl:choose>
                                    <xsl:when test="not(m:naryPr[last()]/m:chr/@m:val) or
                    m:naryPr[last()]/m:chr/@m:val=''">
                                        <xsl:text disable-output-escaping="no">&#x222b;</xsl:text>
                                    </xsl:when>
                                    <xsl:otherwise>
                                        <xsl:value-of select="m:naryPr[last()]/m:chr/@m:val"/>
                                    </xsl:otherwise>
                                </xsl:choose>
                            </mml:mo>
                            <xsl:apply-templates select="m:sup[1]"/>
                        </mml:mover>
                    </xsl:otherwise>
                </xsl:choose>
            </xsl:when>
            <xsl:when test="not($sLowerCaseSupHide='off')">
                <xsl:choose>
                    <xsl:when test="m:naryPr[last()]/m:limLoc/@m:val='subSup'">
                        <mml:msub>
                            <mml:mo>
                                <xsl:choose>
                                    <xsl:when test="not(m:naryPr[last()]/m:chr/@m:val) or
                    m:naryPr[last()]/m:chr/@m:val=''">
                                        <xsl:text disable-output-escaping="no">&#x222b;</xsl:text>
                                    </xsl:when>
                                    <xsl:otherwise>
                                        <xsl:value-of select="m:naryPr[last()]/m:chr/@m:val"/>
                                    </xsl:otherwise>
                                </xsl:choose>
                            </mml:mo>
                            <xsl:apply-templates select="m:sub[1]"/>
                        </mml:msub>
                    </xsl:when>
                    <xsl:otherwise>
                        <mml:munder>
                            <mml:mo>
                                <xsl:choose>
                                    <xsl:when test="not(m:naryPr[last()]/m:chr/@m:val) or
                    m:naryPr[last()]/m:chr/@m:val=''">
                                        <xsl:text disable-output-escaping="no">&#x222b;</xsl:text>
                                    </xsl:when>
                                    <xsl:otherwise>
                                        <xsl:value-of select="m:naryPr[last()]/m:chr/@m:val"/>
                                    </xsl:otherwise>
                                </xsl:choose>
                            </mml:mo>
                            <xsl:apply-templates select="m:sub[1]"/>
                        </mml:munder>
                    </xsl:otherwise>
                </xsl:choose>
            </xsl:when>
            <xsl:otherwise>
                <xsl:choose>
                    <xsl:when test="m:naryPr[last()]/m:limLoc/@m:val='subSup'">
                        <mml:msubsup>
                            <mml:mo>
                                <xsl:choose>
                                    <xsl:when test="not(m:naryPr[last()]/m:chr/@m:val) or
                    m:naryPr[last()]/m:chr/@m:val=''">
                                        <xsl:text disable-output-escaping="no">&#x222b;</xsl:text>
                                    </xsl:when>
                                    <xsl:otherwise>
                                        <xsl:value-of select="m:naryPr[last()]/m:chr/@m:val"/>
                                    </xsl:otherwise>
                                </xsl:choose>
                            </mml:mo>
                            <xsl:apply-templates select="m:sub[1]"/>
                            <xsl:apply-templates select="m:sup[1]"/>
                        </mml:msubsup>
                    </xsl:when>
                    <xsl:otherwise>
                        <mml:munderover>
                            <mml:mo>
                                <xsl:choose>
                                    <xsl:when test="not(m:naryPr[last()]/m:chr/@m:val) or
                    m:naryPr[last()]/m:chr/@m:val=''">
                                        <xsl:text disable-output-escaping="no">&#x222b;</xsl:text>
                                    </xsl:when>
                                    <xsl:otherwise>
                                        <xsl:value-of select="m:naryPr[last()]/m:chr/@m:val"/>
                                    </xsl:otherwise>
                                </xsl:choose>
                            </mml:mo>
                            <xsl:apply-templates select="m:sub[1]"/>
                            <xsl:apply-templates select="m:sup[1]"/>
                        </mml:munderover>
                    </xsl:otherwise>
                </xsl:choose>
            </xsl:otherwise>
        </xsl:choose>
        <mml:mrow>
            <xsl:apply-templates select="m:e[1]"/>
        </mml:mrow>
    </xsl:template>
    <xsl:template name="CreateGroupChr">
        <xsl:variable name="sLowerCasePos" select="translate(m:groupChrPr[last()]/m:pos/@m:val,
      'ABCDEFGHIJKLMNOPQRSTUVWXYZ',
      'abcdefghijklmnopqrstuvwxyz')"/>
        <xsl:choose>
            <xsl:when test="$sLowerCasePos!='top' or
        not(m:groupChrPr[last()]/m:pos/@m:val)   or
        m:groupChrPr[last()]/m:pos/@m:val=''">
                <mml:munder>
                    <xsl:apply-templates select="m:e[1]"/>
                    <mml:mo>
                        <xsl:choose>
                            <xsl:when test="string-length(m:groupChrPr[last()]/m:chr/@m:val) &gt;= 1">
                                <xsl:value-of select="substring(m:groupChrPr[last()]/m:chr/@m:val,1,1)"/>
                            </xsl:when>
                            <xsl:otherwise>
                                <xsl:text disable-output-escaping="no">&#x023DF;</xsl:text>
                            </xsl:otherwise>
                        </xsl:choose>
                    </mml:mo>
                </mml:munder>
            </xsl:when>
            <xsl:otherwise>
                <mml:mover>
                    <xsl:apply-templates select="m:e[1]"/>
                    <mml:mo>
                        <xsl:choose>
                            <xsl:when test="string-length(m:groupChrPr[last()]/m:chr/@m:val) &gt;= 1">
                                <xsl:value-of select="substring(m:groupChrPr[last()]/m:chr/@m:val,1,1)"/>
                            </xsl:when>
                            <xsl:otherwise>
                                <xsl:text disable-output-escaping="no">&#x023DF;</xsl:text>
                            </xsl:otherwise>
                        </xsl:choose>
                    </mml:mo>
                </mml:mover>
            </xsl:otherwise>
        </xsl:choose>
    </xsl:template>
    <xsl:template match="m:bar">
        <xsl:variable name="sLowerCasePos" select="translate(m:barPr/m:pos/@m:val, 'ABCDEFGHIJKLMNOPQRSTUVWXYZ',
      'abcdefghijklmnopqrstuvwxyz')"/>
        <xsl:choose>
            <xsl:when test="$sLowerCasePos!='bot' or
        not($sLowerCasePos)   or
        $sLowerCasePos=''   ">
                <mml:mover>
                    <xsl:attribute name="accent">true</xsl:attribute>
                    <xsl:apply-templates select="m:e[1]"/>
                    <mml:mo>
                        <xsl:text disable-output-escaping="no">&#x000AF;</xsl:text>
                    </mml:mo>
                </mml:mover>
            </xsl:when>
            <xsl:otherwise>
                <mml:munder>
                    <xsl:apply-templates select="m:e[1]"/>
                    <mml:mo>
                        <xsl:text disable-output-escaping="no">&#x00332;</xsl:text>
                    </mml:mo>
                </mml:munder>
            </xsl:otherwise>
        </xsl:choose>
    </xsl:template>

    <!-- wrong name for (m)phantom -->

    <xsl:template match="m:phant">
        <xsl:variable name="sLowerCaseWidth" select="translate(m:phantPr[last()]/m:width/@m:val,
      'ABCDEFGHIJKLMNOPQRSTUVWXYZ',
      'abcdefghijklmnopqrstuvwxyz')"/>
        <xsl:variable name="sLowerCaseAsc" select="translate(m:phantPr[last()]/m:asc/@m:val,
      'ABCDEFGHIJKLMNOPQRSTUVWXYZ',
      'abcdefghijklmnopqrstuvwxyz')"/>
        <xsl:variable name="sLowerCaseDec" select="translate(m:phantPr[last()]/m:dec/@m:val,
      'ABCDEFGHIJKLMNOPQRSTUVWXYZ',
      'abcdefghijklmnopqrstuvwxyz')"/>
        <xsl:if test="not($sLowerCaseWidth='off' and
      $sLowerCaseAsc='off'   and
      $sLowerCaseDec='off')">
            <mml:mphantom>
                <xsl:apply-templates select="m:e[1]"/>
            </mml:mphantom>
        </xsl:if>
    </xsl:template>

    <!--TEMPLATES NEWLY ADDED-->

    <xsl:template match="m:oMath">
        <xsl:variable name="varAlign">
            <xsl:value-of select="preceding-sibling::m:oMathParaPr/m:jc/@m:val"/>
        </xsl:variable>
        <xsl:variable name="spStyle">
            <xsl:choose>
                <xsl:when test="((parent::m:oMathPara) and not(preceding-sibling::m:oMathParaPr))">
                    display:block;
                </xsl:when>
                <xsl:otherwise>
                </xsl:otherwise>
            </xsl:choose>
            font-family:<xsl:value-of select=".//w:rPr[last()]/w:rFonts/@w:ascii"/>;
            font-size:<xsl:value-of select=".//w:rPr[last()]/w:sz/@w:val div 2"/>pt;
            <xsl:choose>
                <xsl:when test="string-length(.//w:rPr[last()]/w:color/@w:val) = 0">
                    color:
                    <xsl:call-template name="ConvHexColor">
                        <xsl:with-param name="value" select="ancestor::w:p/w:pPr/w:rPr[last()]/w:color/@w:val"/>
                    </xsl:call-template>
                    ;
                </xsl:when>
                <xsl:otherwise>
                    color:
                    <xsl:call-template name="ConvHexColor">
                        <xsl:with-param name="value" select=".//w:rPr[last()]/w:color/@w:val"/>
                    </xsl:call-template>
                    ;
                </xsl:otherwise>
            </xsl:choose>
            <xsl:choose>
                <xsl:when test="string-length(.//w:rPr[last()]/w:highlight/@w:val) = 0">
                    background-color:
                    <xsl:call-template name="ConvColor">
                        <xsl:with-param name="value" select="ancestor::w:p/w:pPr/w:rPr[last()]/w:hightlight/@w:val"/>
                    </xsl:call-template>
                    ;
                </xsl:when>
                <xsl:otherwise>
                    background-color:
                    <xsl:call-template name="ConvColor">
                        <xsl:with-param name="value" select=".//w:rPr[last()]/w:highlight/@w:val"/>
                    </xsl:call-template>
                    ;
                </xsl:otherwise>
            </xsl:choose>
            <xsl:choose>
                <xsl:when
                        test="string-length(.//w:rPr[last()]/w:u[1]/@w:val) = 0 or .//w:rPr[last()]/w:u[1]/@w:val = 'off' or .//w:rPr[last()]/w:u[1]/@w:val = 'none' or .//w:rPr[last()]/w:u[1]/@w:val = '0' ">
                    text-decoration:none;
                </xsl:when>
                <xsl:otherwise>
                    text-decoration:underline;
                </xsl:otherwise>
            </xsl:choose>
            text-align:<xsl:value-of select="$varAlign"></xsl:value-of>;
        </xsl:variable>

        <xsl:choose>
            <xsl:when test="(parent::m:oMathPara) and not(preceding-sibling::m:oMathParaPr)">
                <span style="{$spStyle}">
                    <mml:math display="block">
                        <xsl:apply-templates select="*"/>
                    </mml:math>
                </span>
            </xsl:when>
            <xsl:otherwise>
                <div align="{$varAlign}">
                    <span style="{$spStyle}">
                        <mml:math>
                            <xsl:apply-templates select="*"/>
                        </mml:math>
                    </span>
                </div>
            </xsl:otherwise>
        </xsl:choose>

    </xsl:template>
    <!--ADDED FOR MATHML SUPPORT BY SHUBHA align="{$varAlign}" -->


    <xsl:template match="m:t">

        <xsl:choose>
            <xsl:when test="/@xml:space">
                &#160;
            </xsl:when>
        </xsl:choose>
        <xsl:apply-templates select="*"/>
    </xsl:template>
</xsl:stylesheet>