<xsl:template match="*" mode="depth">99</xsl:template>

<xsl:template match="tei:argument">
  <xsl:call-template name="makeBlock">
    <xsl:with-param name="style">argument</xsl:with-param>
  </xsl:call-template>
</xsl:template>

<xsl:template match="tei:sic">
  <xsl:choose>
    <xsl:when test="parent::tei:choice">
    </xsl:when>
    <xsl:otherwise>
      <xsl:call-template name="makeInline">
        <xsl:with-param name="after">(sic)</xsl:with-param>
      </xsl:call-template>
    </xsl:otherwise>
  </xsl:choose>
</xsl:template>

<xsl:template match="tei:reg">
  <xsl:call-template name="makeInline"/>
</xsl:template>

<xsl:template match="tei:orig">
  <xsl:choose>
    <xsl:when test="parent::tei:choice">
    </xsl:when>
    <xsl:otherwise>
      <xsl:call-template name="makeInline"/>
    </xsl:otherwise>
  </xsl:choose>
</xsl:template>

<xsl:template match="tei:expan">
  <xsl:call-template name="makeInline"/>
</xsl:template>

<xsl:template match="tei:corr">
  <xsl:call-template name="makeInline">
    <xsl:with-param name="before">[</xsl:with-param>
    <xsl:with-param name="after">]</xsl:with-param>
  </xsl:call-template>
</xsl:template>

<xsl:template match="tei:abbr">
  <xsl:choose>
    <xsl:when test="parent::tei:choice/tei:expan">
      <xsl:call-template name="makeInline">
        <xsl:with-param name="before">(</xsl:with-param>
        <xsl:with-param name="after">)</xsl:with-param>
      </xsl:call-template>
    </xsl:when>
    <xsl:otherwise>
      <xsl:call-template name="makeInline"/>
    </xsl:otherwise>
  </xsl:choose>
</xsl:template>

<xsl:template match="tei:signed">
  <xsl:call-template name="makeBlock">
    <xsl:with-param name="style">signed</xsl:with-param>
  </xsl:call-template>
</xsl:template>

<xsl:template match="tei:item" mode="runin">
  <xsl:text> • </xsl:text>
  <xsl:apply-templates/>
  <xsl:text> </xsl:text>
</xsl:template>

<xsl:template match="tei:edition">
  <xsl:apply-templates/>
  <xsl:if test="ancestor::tei:biblStruct or ancestor::tei:biblFull">
    <xsl:call-template name="makeText">
      <xsl:with-param name="letters">.</xsl:with-param>
    </xsl:call-template>
  </xsl:if>
</xsl:template>

<xsl:template match="tei:imprint">
  <xsl:choose>
    <xsl:when test="ancestor::tei:biblStruct or ancestor::tei:biblFull">
      <xsl:apply-templates select="tei:date"/>
      <xsl:apply-templates select="tei:pubPlace"/>
      <xsl:apply-templates select="tei:publisher"/>
      <xsl:apply-templates select="tei:biblScope"/>
    </xsl:when>
    <xsl:otherwise>
      <xsl:apply-templates/>
    </xsl:otherwise>
  </xsl:choose>
</xsl:template>

<xsl:template match="tei:biblStruct" mode="xref">
  <xsl:choose>
    <xsl:when test="count(key('ANAMES',@xml:id))=1">
      <xsl:value-of select="key('ANAMES',@xml:id)/tei:surname"/>
    </xsl:when>
    <xsl:when test="count(key('ANAMES',@xml:id))=2">
      <xsl:value-of select="key('ANAMES',@xml:id)[1]/tei:surname"/>
      <xsl:call-template name="makeText">
        <xsl:with-param name="letters">and</xsl:with-param>
      </xsl:call-template>
      <xsl:value-of select="key('ANAMES',@xml:id)[2]/tei:surname"/>
    </xsl:when>
    <xsl:when test="count(key('ANAMES',@xml:id))>2">
      <xsl:value-of select="key('ANAMES',@xml:id)[1]/tei:surname"/>
      <xsl:call-template name="makeText">
        <xsl:with-param name="letters">et al.</xsl:with-param>
      </xsl:call-template>
    </xsl:when>
    <xsl:when test="count(key('MNAMES',@xml:id))=1">
      <xsl:value-of select="key('MNAMES',@xml:id)/tei:surname"/>
    </xsl:when>
    <xsl:when test="count(key('MNAMES',@xml:id))=2">
      <xsl:value-of select="key('MNAMES',@xml:id)[1]/tei:surname"/>
      <xsl:call-template name="makeText">
        <xsl:with-param name="letters">and</xsl:with-param>
      </xsl:call-template>
      <xsl:value-of select="key('MNAMES',@xml:id)[2]/tei:surname"/>
    </xsl:when>
    <xsl:when test="count(key('MNAMES',@xml:id))>2">
      <xsl:value-of select="key('MNAMES',@xml:id)[1]/tei:surname"/>
      <xsl:call-template name="makeText">
        <xsl:with-param name="letters">et al.</xsl:with-param>
      </xsl:call-template>
    </xsl:when>
    <xsl:when test=".//tei:author[tei:surname]">
      <xsl:value-of select=".//tei:author/tei:surname[1]"/>
    </xsl:when>
    <xsl:when test=".//tei:author[tei:orgName]">
      <xsl:value-of select=".//tei:author/tei:orgName[1]"/>
    </xsl:when>
    <xsl:when test=".//tei:author">
      <xsl:value-of select=".//tei:author[1]"/>
    </xsl:when>
    <xsl:when test=".//tei:editor[tei:surname]">
      <xsl:value-of select=".//tei:editor/tei:surname[1]"/>
    </xsl:when>
    <xsl:when test=".//tei:editor">
      <xsl:value-of select=".//tei:editor[1]"/>
    </xsl:when>
    <xsl:otherwise>
      <xsl:value-of select=".//tei:title[1]"/>
    </xsl:otherwise>
  </xsl:choose>
  <xsl:choose>
    <xsl:when test="count(tei:*[1]/tei:editor)=1">
      <xsl:call-template name="makeText">
        <xsl:with-param name="letters">(ed.)</xsl:with-param>
      </xsl:call-template>
    </xsl:when>
    <xsl:when test="count(tei:*[1]/tei:editor)>1">
      <xsl:call-template name="makeText">
        <xsl:with-param name="letters">(eds.)</xsl:with-param>
      </xsl:call-template>
    </xsl:when>
  </xsl:choose>
  <xsl:choose>
    <xsl:when test="tei:monogr/tei:imprint/tei:date/@when">
      <xsl:call-template name="makeText">
        <xsl:with-param name="letters">(</xsl:with-param>
      </xsl:call-template>
      <xsl:value-of select="substring-before(tei:monogr/tei:imprint/tei:date/@when,'-')"/>
      <xsl:call-template name="makeText">
        <xsl:with-param name="letters">)</xsl:with-param>
      </xsl:call-template>
    </xsl:when>
    <xsl:when test="tei:monogr/tei:imprint/tei:date">
      <xsl:call-template name="makeText">
        <xsl:with-param name="letters">(</xsl:with-param>
      </xsl:call-template>
      <xsl:value-of select="tei:monogr/tei:imprint/tei:date"/>
      <xsl:call-template name="makeText">
        <xsl:with-param name="letters">)</xsl:with-param>
      </xsl:call-template>
    </xsl:when>
  </xsl:choose>
</xsl:template>

<xsl:template match="tei:editor|tei:author">
  <xsl:choose>
    <xsl:when test="ancestor::tei:bibl">
      <xsl:apply-templates/>
    </xsl:when>
    <xsl:when test="self::tei:author and not(following-sibling::tei:author)">
      <xsl:apply-templates/>
      <xsl:call-template name="makeText">
        <xsl:with-param name="letters">.</xsl:with-param>
      </xsl:call-template>
    </xsl:when>
    <xsl:when test="self::tei:editor and not(following-sibling::tei:editor)">
      <xsl:apply-templates/>
      <xsl:call-template name="makeText">
        <xsl:with-param name="letters">(ed</xsl:with-param>
      </xsl:call-template>
      <xsl:if test="preceding-sibling::tei:editor">s</xsl:if>
      <xsl:call-template name="makeText">
        <xsl:with-param name="letters">.)</xsl:with-param>
      </xsl:call-template>
    </xsl:when>
    <xsl:otherwise>
      <xsl:apply-templates/>
      <xsl:call-template name="makeText">
        <xsl:with-param name="letters">,</xsl:with-param>
      </xsl:call-template>
    </xsl:otherwise>
  </xsl:choose>
</xsl:template>

<xsl:template match="tei:author|tei:editor" mode="mla">
  <!-- <xsl:variable name="totalNbr">
	  <xsl:number select="ancestor::tei:listBibl"/>
        </xsl:variable>
        <xsl:value-of select="$totalNbr"/>. 
        <xsl:choose>
        <xsl:when test="self::tei:author[1] = parent::tei:analytic/parent::tei:biblStruct/preceding-sibling::tei:biblStruct/*/tei:author[1] or self::tei:author[1] =
        parent::tei:analytic/parent::tei:biblStruct/preceding-sibling::tei:biblStruct/tei:monogr/tei:editor[1]">
        <xsl:text>[three hyphens]</xsl:text>
        <xsl:choose>
        <xsl:when test="self::tei:author and following-sibling::tei:author"><xsl:text>, </xsl:text></xsl:when>
        <xsl:otherwise><xsl:text>. </xsl:text></xsl:otherwise>
        </xsl:choose>
        </xsl:when>
        <xsl:when test="self::tei:author[1] = parent::tei:monogr/parent::tei:biblStruct/preceding-sibling::tei:biblStruct/*/tei:author[1] and not(preceding-sibling::tei:analytic) or self::tei:author[1] =
        parent::tei:monogr/parent::tei:biblStruct/preceding-sibling::tei:biblStruct/tei:monogr/tei:editor[1] and not(preceding-sibling::tei:analytic)">
        <xsl:text>[three hyphens]</xsl:text>
        <xsl:choose>
        <xsl:when test="self::tei:author and following-sibling::tei:author"><xsl:text>, </xsl:text></xsl:when>
        <xsl:otherwise><xsl:text>. </xsl:text></xsl:otherwise>
        </xsl:choose>
        </xsl:when>
        <xsl:when test="self::tei:editor[1] = parent::tei:*/parent::tei:biblStruct/preceding-sibling::tei:biblStruct/*/tei:author[1] and
        not(preceding-sibling::tei:analytic) or self::tei:editor[1]
        = parent::tei:*/parent::tei:biblStruct/preceding-sibling::tei:biblStruct/tei:monogr/tei:editor[1] and not(preceding-sibling::tei:analytic)">
        <xsl:text>[three hyphens]</xsl:text>
        <xsl:text>, </xsl:text>
        </xsl:when> 
        TAKE OUT THE EXTRA OPEN CHOOSE BEFORE YOU ADD THIS BACK IN-->
  <xsl:choose>
    <xsl:when test="self::tei:author and not(following-sibling::tei:author)">
      <xsl:choose>
        <xsl:when test="ancestor::tei:biblStruct and not(preceding-sibling::tei:author)">
          <xsl:apply-templates/>
          <xsl:if test="not(ends-with(.,'.'))">
            <xsl:text>. </xsl:text>
          </xsl:if>
        </xsl:when>
        <xsl:otherwise>
          <xsl:if test="not(self::tei:author[3])">
            <xsl:text> and </xsl:text>
          </xsl:if>
          <xsl:choose>
            <xsl:when test="contains(self::tei:author, ',')">
              <xsl:value-of select="substring-after(., ',')"/>
              <xsl:text> </xsl:text>
              <xsl:value-of select="substring-before(., ',')"/>
            </xsl:when>
            <xsl:otherwise>
              <xsl:apply-templates/>
            </xsl:otherwise>
          </xsl:choose>
          <xsl:if test="not(ends-with(.,'.'))">
            <xsl:text>. </xsl:text>
          </xsl:if>
        </xsl:otherwise>
      </xsl:choose>
      <xsl:text> </xsl:text>
    </xsl:when>
    <xsl:when test="self::tei:author and following-sibling::tei:author">
      <xsl:choose>
        <xsl:when test="ancestor::tei:biblStruct and not(preceding-sibling::tei:author)">
          <xsl:apply-templates/>
          <xsl:text>, </xsl:text>
        </xsl:when>
        <xsl:otherwise>
          <xsl:choose>
            <xsl:when test="contains(self::tei:author, ',')">
              <xsl:value-of select="substring-after(., ',')"/>
              <xsl:text> </xsl:text>
              <xsl:value-of select="substring-before(., ',')"/>
              <xsl:text>, and </xsl:text>
            </xsl:when>
            <xsl:otherwise>
              <xsl:apply-templates/>
              <xsl:text>, and </xsl:text>
            </xsl:otherwise>
          </xsl:choose>
        </xsl:otherwise>
      </xsl:choose>
    </xsl:when>
    <xsl:when test="self::tei:editor[@role='translator'] and ancestor::tei:biblStruct">
      <xsl:choose>
        <xsl:when test="preceding-sibling::tei:editor[@role='editor']/text() = self::tei:editor[@role='translator']/text()">
          <xsl:text>Ed. and Trans. </xsl:text>
        </xsl:when>
        <xsl:when test="not(preceding-sibling::tei:editor[@role='translator'])">
          <xsl:text>Trans. </xsl:text>
        </xsl:when>
        <xsl:when test="preceding-sibling::tei:editor[@role='translator'] and following-sibling::tei:editor[@role='translator']">
          <xsl:text>, </xsl:text>
        </xsl:when>
        <xsl:otherwise>
          <xsl:text> and </xsl:text>
        </xsl:otherwise>
      </xsl:choose>
      <xsl:choose>
        <xsl:when test="contains(self::tei:editor[@role='translator'], ',')">
          <xsl:value-of select="substring-after(., ',')"/>
          <xsl:text> </xsl:text>
          <xsl:value-of select="substring-before(., ',')"/>
        </xsl:when>
        <xsl:otherwise>
          <xsl:apply-templates/>
        </xsl:otherwise>
      </xsl:choose>
      <xsl:if test="not(following-sibling::tei:editor[@role='translator'])">
        <xsl:text>. </xsl:text>
      </xsl:if>
    </xsl:when>
    <xsl:when test="self::tei:editor[@role='editor'] and not(parent::tei:monogr/parent::tei:biblStruct/tei:analytic) and not(preceding-sibling::tei:author)">
      <xsl:choose>
        <xsl:when test="ancestor::tei:biblStruct and not(following-sibling::tei:editor[@role='editor']) and not(preceding-sibling::tei:editor[@role='editor'])">
          <xsl:apply-templates/>
          <xsl:text>, ed. </xsl:text>
        </xsl:when>
        <xsl:when test="ancestor::tei:biblStruct and following-sibling::tei:editor[@role='editor'] and not(preceding-sibling::tei:editor[@role='editor'])">
          <xsl:apply-templates/>
          <xsl:choose>
            <xsl:when test="position() + 1 = last()">
              <xsl:text> </xsl:text>
            </xsl:when>
            <xsl:otherwise>
              <xsl:text>, </xsl:text>
            </xsl:otherwise>
          </xsl:choose>
        </xsl:when>
        <xsl:when test="ancestor::tei:biblStruct and following-sibling::tei:editor[@role='editor']">
          <xsl:choose>
            <xsl:when test="contains(self::tei:editor[@role='editor'], ',')">
              <xsl:value-of select="substring-after(., ',')"/>
              <xsl:text> </xsl:text>
              <xsl:value-of select="substring-before(., ',')"/>
            </xsl:when>
            <xsl:otherwise>
              <xsl:apply-templates/>
            </xsl:otherwise>
          </xsl:choose>
          <xsl:choose>
            <xsl:when test="position() + 1 = last()">
              <xsl:text> </xsl:text>
            </xsl:when>
            <xsl:otherwise>
              <xsl:text>, </xsl:text>
            </xsl:otherwise>
          </xsl:choose>
        </xsl:when>
        <xsl:when test="ancestor::tei:biblStruct and not(following-sibling::tei:editor[@role='editor'])">
          <xsl:choose>
            <xsl:when test="preceding-sibling::tei:editor[@role='editor']">
              <xsl:text>and </xsl:text>
              <xsl:choose>
                <xsl:when test="contains(self::tei:editor[@role='editor'], ',')">
                  <xsl:value-of select="substring-after(., ',')"/>
                  <xsl:text> </xsl:text>
                  <xsl:value-of select="substring-before(., ',')"/>
                </xsl:when>
                <xsl:otherwise>
                  <xsl:apply-templates/>
                </xsl:otherwise>
              </xsl:choose>
            </xsl:when>
            <xsl:otherwise>
              <xsl:apply-templates/>
            </xsl:otherwise>
          </xsl:choose>
          <xsl:choose>
            <xsl:when test="../tei:editor[@role='editor'][2]">
              <xsl:text>, eds. </xsl:text>
            </xsl:when>
            <xsl:otherwise>
              <xsl:text>, ed. </xsl:text>
            </xsl:otherwise>
          </xsl:choose>
        </xsl:when>
      </xsl:choose>
    </xsl:when>
    <xsl:when test="self::tei:editor[@role='editor'] and not(following-sibling::tei:editor[@role='editor'])">
      <xsl:choose>
        <xsl:when test="ancestor::tei:biblStruct and not(preceding-sibling::tei:editor[@role='editor'])">
          <xsl:text>Ed. </xsl:text>
          <xsl:choose>
            <xsl:when test="contains(self::tei:editor[@role='editor'], ',')">
              <xsl:value-of select="substring-after(., ',')"/>
              <xsl:text> </xsl:text>
              <xsl:value-of select="substring-before(., ',')"/>
            </xsl:when>
            <xsl:otherwise>
              <xsl:apply-templates/>
            </xsl:otherwise>
          </xsl:choose>
          <xsl:text>. </xsl:text>
        </xsl:when>
        <xsl:when test="ancestor::tei:biblStruct and preceding-sibling::tei:editor[@role='editor']">
          <xsl:text>and </xsl:text>
          <xsl:choose>
            <xsl:when test="contains(self::tei:editor[@role='editor'], ',')">
              <xsl:value-of select="substring-after(., ',')"/>
              <xsl:text> </xsl:text>
              <xsl:value-of select="substring-before(., ',')"/>
            </xsl:when>
            <xsl:otherwise>
              <xsl:apply-templates/>
            </xsl:otherwise>
          </xsl:choose>
          <xsl:text>. </xsl:text>
        </xsl:when>
        <xsl:otherwise>
          <xsl:apply-templates/>
          <xsl:text> (</xsl:text>
          <xsl:text>ed</xsl:text>
          <xsl:if test="preceding-sibling::tei:editor[@role='editor']">s</xsl:if>
          <xsl:text>.</xsl:text>
          <xsl:text>) </xsl:text>
        </xsl:otherwise>
      </xsl:choose>
    </xsl:when>
    <xsl:when test="self::tei:editor[@role='editor'] and following-sibling::tei:editor[@role='editor']">
      <xsl:choose>
        <xsl:when test="ancestor::tei:biblStruct and not(preceding-sibling::tei:editor[@role='editor'])">
          <xsl:text>Ed. </xsl:text>
          <xsl:choose>
            <xsl:when test="contains(self::tei:editor[@role='editor'], ',')">
              <xsl:value-of select="substring-after(., ',')"/>
              <xsl:text> </xsl:text>
              <xsl:value-of select="substring-before(., ',')"/>
            </xsl:when>
            <xsl:otherwise>
              <xsl:apply-templates/>
            </xsl:otherwise>
          </xsl:choose>
          <xsl:choose>
            <xsl:when test="position() + 1 = last()">
              <xsl:text> </xsl:text>
            </xsl:when>
            <xsl:otherwise>
              <xsl:text>, </xsl:text>
            </xsl:otherwise>
          </xsl:choose>
        </xsl:when>
        <xsl:when test="ancestor::tei:biblStruct and preceding-sibling::tei:editor[@role='editor']">
          <xsl:choose>
            <xsl:when test="contains(self::tei:editor[@role='editor'], ',')">
              <xsl:value-of select="substring-after(., ',')"/>
              <xsl:text> </xsl:text>
              <xsl:value-of select="substring-before(., ',')"/>
            </xsl:when>
            <xsl:otherwise>
              <xsl:apply-templates/>
            </xsl:otherwise>
          </xsl:choose>
          <xsl:text>, </xsl:text>
        </xsl:when>
        <xsl:otherwise>
          <xsl:choose>
            <xsl:when test="contains(self::tei:editor[@role='editor'], ',')">
              <xsl:value-of select="substring-after(., ',')"/>
              <xsl:text> </xsl:text>
              <xsl:value-of select="substring-before(., ',')"/>
            </xsl:when>
            <xsl:otherwise>
              <xsl:apply-templates/>
            </xsl:otherwise>
          </xsl:choose>
          <xsl:choose>
            <xsl:when test="position() + 1 = last()">
              <xsl:text> </xsl:text>
            </xsl:when>
            <xsl:otherwise>
              <xsl:text>, </xsl:text>
            </xsl:otherwise>
          </xsl:choose>
        </xsl:otherwise>
      </xsl:choose>
    </xsl:when>
  </xsl:choose>
</xsl:template>

<xsl:template match="tei:nameLink">
</xsl:template>

<xsl:template match="tei:title" mode="simple">
  <xsl:value-of select="."/>
</xsl:template>

<xsl:template match="tei:title">
  <xsl:choose>
    <xsl:when test="parent::tei:titleStmt/parent::tei:fileDesc">
      <xsl:if test="preceding-sibling::tei:title">
        <xsl:call-template name="makeText">
          <xsl:with-param name="letters">—</xsl:with-param>
        </xsl:call-template>
      </xsl:if>
      <xsl:apply-templates/>
    </xsl:when>
    <xsl:when test="not(@level) and parent::tei:bibl">
      <xsl:call-template name="makeInline">
        <xsl:with-param name="style">titlem</xsl:with-param>
      </xsl:call-template>
    </xsl:when>
    <xsl:when test="@level='m' or not(@level)">
      <xsl:call-template name="emphasize">
        <xsl:with-param name="class">
          <xsl:text>titlem</xsl:text>
        </xsl:with-param>
        <xsl:with-param name="content">
          <xsl:apply-templates/>
        </xsl:with-param>
      </xsl:call-template>
      <xsl:if test="ancestor::tei:biblStruct or ancestor::tei:biblFull">
        <xsl:call-template name="makeText">
          <xsl:with-param name="letters">,</xsl:with-param>
        </xsl:call-template>
      </xsl:if>
    </xsl:when>
    <xsl:when test="@level='s'">
      <xsl:call-template name="emphasize">
        <xsl:with-param name="class">
          <xsl:text>titles</xsl:text>
        </xsl:with-param>
        <xsl:with-param name="content">
          <xsl:apply-templates/>
        </xsl:with-param>
      </xsl:call-template>
      <xsl:if test="following-sibling::* and     (ancestor::tei:biblStruct  or ancestor::tei:biblFull)">
        <xsl:call-template name="makeText">
          <xsl:with-param name="letters">
          </xsl:with-param>
        </xsl:call-template>
      </xsl:if>
    </xsl:when>
    <xsl:when test="@level='j'">
      <xsl:call-template name="emphasize">
        <xsl:with-param name="class">
          <xsl:text>titlej</xsl:text>
        </xsl:with-param>
        <xsl:with-param name="content">
          <xsl:apply-templates/>
        </xsl:with-param>
      </xsl:call-template>
      <xsl:call-template name="makeText">
        <xsl:with-param name="letters">
          <xsl:text> </xsl:text>
        </xsl:with-param>
      </xsl:call-template>
    </xsl:when>
    <xsl:when test="@level='a'">
      <xsl:call-template name="emphasize">
        <xsl:with-param name="class">
          <xsl:text>titlea</xsl:text>
        </xsl:with-param>
        <xsl:with-param name="content">
          <xsl:apply-templates/>
        </xsl:with-param>
      </xsl:call-template>
      <xsl:if test="ancestor::tei:biblStruct or ancestor::tei:biblFull">
        <xsl:call-template name="makeText">
          <xsl:with-param name="letters">.</xsl:with-param>
        </xsl:call-template>
      </xsl:if>
    </xsl:when>
    <xsl:when test="@level='u'">
      <xsl:call-template name="emphasize">
        <xsl:with-param name="class">
          <xsl:text>titleu</xsl:text>
        </xsl:with-param>
        <xsl:with-param name="content">
          <xsl:apply-templates/>
        </xsl:with-param>
      </xsl:call-template>
      <xsl:if test="ancestor::tei:biblStruct  or ancestor::tei:biblFull">
        <xsl:call-template name="makeText">
          <xsl:with-param name="letters">.</xsl:with-param>
        </xsl:call-template>
      </xsl:if>
    </xsl:when>
    <!--
         <xsl:when test="ancestor::tei:bibl">
	   <xsl:apply-templates/>
         </xsl:when>
-->
    <xsl:otherwise>
      <xsl:call-template name="emphasize">
        <xsl:with-param name="class">
          <xsl:text>titlem</xsl:text>
        </xsl:with-param>
        <xsl:with-param name="content">
          <xsl:apply-templates/>
        </xsl:with-param>
      </xsl:call-template>
    </xsl:otherwise>
  </xsl:choose>
</xsl:template>

<xsl:template match="tei:meeting">
  <xsl:call-template name="makeText">
    <xsl:with-param name="letters">(</xsl:with-param>
  </xsl:call-template>
  <xsl:apply-templates/>
  <xsl:call-template name="makeText">
    <xsl:with-param name="letters">)</xsl:with-param>
  </xsl:call-template>
  <xsl:if test="following-sibling::* and (ancestor::tei:biblStruct  or ancestor::tei:biblFull)">
    <xsl:call-template name="makeText">
      <xsl:with-param name="letters">
        <xsl:text> </xsl:text>
      </xsl:with-param>
    </xsl:call-template>
  </xsl:if>
</xsl:template>

<xsl:template match="tei:series">
  <xsl:apply-templates/>
</xsl:template>

<xsl:template match="tei:biblStruct//tei:date|tei:biblFull//tei:date">
  <!--
	 <xsl:choose>
	 <xsl:when test="starts-with(.,'$Date:')">
	 <xsl:value-of select="substring-before(substring-after(.,'$Date:'),'$')"/>
	 </xsl:when>
	 <xsl:otherwise>
	 <xsl:apply-templates/>
	 </xsl:otherwise>
	 </xsl:choose>
     -->
  <xsl:apply-templates/>
  <xsl:call-template name="makeText">
    <xsl:with-param name="letters">.</xsl:with-param>
  </xsl:call-template>
</xsl:template>

<xsl:template match="tei:byline">
  <xsl:call-template name="makeSpan"/>
</xsl:template>

<xsl:template match="tei:pubPlace">
  <xsl:call-template name="makeSpan"/>
  <xsl:choose>
    <xsl:when test="ancestor::tei:bibl"/>
    <xsl:when test="following-sibling::tei:pubPlace">
      <xsl:call-template name="makeText">
        <xsl:with-param name="letters">,</xsl:with-param>
      </xsl:call-template>
    </xsl:when>
    <xsl:when test="../tei:publisher">
      <xsl:call-template name="makeText">
        <xsl:with-param name="letters">:</xsl:with-param>
      </xsl:call-template>
    </xsl:when>
    <xsl:otherwise>
      <xsl:call-template name="makeText">
        <xsl:with-param name="letters">.</xsl:with-param>
      </xsl:call-template>
    </xsl:otherwise>
  </xsl:choose>
</xsl:template>

<xsl:template match="tei:publisher">
  <xsl:call-template name="makeSpan"/>
  <xsl:if test="ancestor::tei:biblStruct or ancestor::tei:biblFull">
    <xsl:call-template name="makeText">
      <xsl:with-param name="letters">.</xsl:with-param>
    </xsl:call-template>
  </xsl:if>
</xsl:template>

<xsl:template match="tei:biblScope">
  <xsl:variable name="Unit" select="(@unit|@type)[1]"/>
  <xsl:choose>
    <xsl:when test="ancestor::tei:bibl">
      <xsl:apply-templates/>
    </xsl:when>
    <xsl:when test="$Unit='vol' or $Unit='volume'">
      <xsl:call-template name="emphasize">
        <xsl:with-param name="class">
          <xsl:text>vol</xsl:text>
        </xsl:with-param>
        <xsl:with-param name="content">
          <xsl:apply-templates/>
        </xsl:with-param>
      </xsl:call-template>
    </xsl:when>
    <xsl:when test="$Unit='chap' or $Unit='chapter'">
      <xsl:call-template name="makeText">
        <xsl:with-param name="letters">chapter</xsl:with-param>
      </xsl:call-template>
      <xsl:apply-templates/>
    </xsl:when>
    <xsl:when test="$Unit='issue' or $Unit='nr'">
      <xsl:call-template name="makeText">
        <xsl:with-param name="letters">(</xsl:with-param>
      </xsl:call-template>
      <xsl:apply-templates/>
      <xsl:call-template name="makeText">
        <xsl:with-param name="letters">)</xsl:with-param>
      </xsl:call-template>
    </xsl:when>
    <xsl:when test="$Unit='page_from'">
      <xsl:text>pp. </xsl:text>
      <xsl:apply-templates/>
    </xsl:when>
    <xsl:when test="$Unit='page_to'">
      <xsl:text>-</xsl:text>
      <xsl:apply-templates/>
    </xsl:when>
    <xsl:when test="$Unit='pp' or $Unit='pages' or $Unit='page'">
      <xsl:choose>
        <xsl:when test="contains(.,'-')">
          <xsl:call-template name="makeText">
            <xsl:with-param name="letters">pp.</xsl:with-param>
          </xsl:call-template>
        </xsl:when>
        <xsl:when test="contains(.,'ff')">
          <xsl:call-template name="makeText">
            <xsl:with-param name="letters">pp.</xsl:with-param>
          </xsl:call-template>
        </xsl:when>
        <xsl:when test="contains(.,' ')">
          <xsl:call-template name="makeText">
            <xsl:with-param name="letters">pp.</xsl:with-param>
          </xsl:call-template>
        </xsl:when>
        <xsl:otherwise>
          <xsl:call-template name="makeText">
            <xsl:with-param name="letters">p.</xsl:with-param>
          </xsl:call-template>
        </xsl:otherwise>
      </xsl:choose>
      <xsl:apply-templates/>
    </xsl:when>
    <xsl:otherwise>
      <xsl:apply-templates/>
    </xsl:otherwise>
  </xsl:choose>
  <xsl:choose>
    <xsl:when test="$Unit='vol' and      following-sibling::tei:biblScope[$Unit='issue']">
      <xsl:call-template name="makeText">
        <xsl:with-param name="letters">
          <xsl:text> </xsl:text>
        </xsl:with-param>
      </xsl:call-template>
    </xsl:when>
    <xsl:when test="$Unit='vol' and following-sibling::tei:biblScope">
      <xsl:call-template name="makeText">
        <xsl:with-param name="letters">
          <xsl:text> </xsl:text>
        </xsl:with-param>
      </xsl:call-template>
    </xsl:when>
    <xsl:when test="following-sibling::tei:biblScope">
      <xsl:call-template name="makeText">
        <xsl:with-param name="letters">
          <xsl:text> </xsl:text>
        </xsl:with-param>
      </xsl:call-template>
    </xsl:when>
    <xsl:when test="ancestor::tei:biblStruct or ancestor::tei:biblFull">
      <xsl:call-template name="makeText">
        <xsl:with-param name="letters">.</xsl:with-param>
      </xsl:call-template>
    </xsl:when>
  </xsl:choose>
</xsl:template>

<xsl:template match="tei:name|tei:persName|tei:placeName">
  <xsl:choose>
    <xsl:when test="not(ancestor::tei:person|ancestor::tei:biblStruct)">
      <xsl:call-template name="makeSpan"/>
    </xsl:when>
    <xsl:when test="following-sibling::tei:name|following-sibling::tei:persName">
      <xsl:call-template name="makeText">
        <xsl:with-param name="letters">,</xsl:with-param>
      </xsl:call-template>
    </xsl:when>
    <xsl:otherwise>
      <xsl:call-template name="makeSpan"/>
    </xsl:otherwise>
  </xsl:choose>
</xsl:template>

<xsl:template name="noteID">
  <xsl:choose>
    <xsl:when test="@xml:id">
      <xsl:value-of select="@xml:id"/>
    </xsl:when>
    <xsl:otherwise>
      <xsl:text>Note</xsl:text>
      <xsl:number count="tei:note" level="any"/>
    </xsl:otherwise>
  </xsl:choose>
</xsl:template>

<xsl:template name="noteN">
  <xsl:choose>
    <xsl:when test="@n">
      <xsl:value-of select="@n"/>
    </xsl:when>
    <xsl:when test="not(@place) and $consecutiveFNs='true'">
      <xsl:number count="tei:note[not(@place)]" level="any"/>
    </xsl:when>
    <xsl:when test="not(@place)">
      <xsl:choose>
        <xsl:when test="ancestor::tei:front">
          <xsl:number count="tei:note[not(@place)]" from="tei:front" level="any"/>
        </xsl:when>
        <xsl:when test="ancestor::tei:back">
          <xsl:number count="tei:note[not(@place)]" from="tei:back" level="any"/>
        </xsl:when>
        <xsl:otherwise>
          <xsl:number count="tei:note[not(@place)]" from="tei:body" level="any"/>
        </xsl:otherwise>
      </xsl:choose>
    </xsl:when>
    <xsl:when test="tei:isEndNote(.)">
      <xsl:choose>
        <xsl:when test="$consecutiveFNs = 'true'">
          <xsl:number count="tei:note[tei:isEndNote(.)]" level="any"/>
        </xsl:when>
        <xsl:otherwise>
          <xsl:choose>
            <xsl:when test="ancestor::tei:front">
              <xsl:number count="tei:note[tei:isEndNote(.)]" from="tei:front" level="any"/>
            </xsl:when>
            <xsl:when test="ancestor::tei:back">
              <xsl:number count="tei:note[tei:isEndNote(.)]" from="tei:back" level="any"/>
            </xsl:when>
            <xsl:otherwise>
              <xsl:number count="tei:note[tei:isEndNote(.)]" from="tei:body" level="any"/>
            </xsl:otherwise>
          </xsl:choose>
        </xsl:otherwise>
      </xsl:choose>
    </xsl:when>
    <xsl:otherwise>
      <xsl:choose>
        <xsl:when test="$consecutiveFNs = 'true'">
          <xsl:number count="tei:note[tei:isFootNote(.)]" level="any"/>
        </xsl:when>
        <xsl:otherwise>
          <xsl:choose>
            <xsl:when test="ancestor::tei:front">
              <xsl:number count="tei:note[tei:isFootNote(.)]" from="tei:front" level="any"/>
            </xsl:when>
            <xsl:when test="ancestor::tei:back">
              <xsl:number count="tei:note[tei:isFootNote(.)]" from="tei:back" level="any"/>
            </xsl:when>
            <xsl:otherwise>
              <xsl:number count="tei:note[tei:isFootNote(.)]" from="tei:body" level="any"/>
            </xsl:otherwise>
          </xsl:choose>
        </xsl:otherwise>
      </xsl:choose>
    </xsl:otherwise>
  </xsl:choose>
</xsl:template>

<xsl:template match="tei:note">
  <xsl:choose>
    <xsl:when test="@place='none'"/>
    <xsl:when test="not(@place) and ancestor::tei:bibl">
      <xsl:call-template name="makeText">
        <xsl:with-param name="letters">(</xsl:with-param>
      </xsl:call-template>
      <xsl:apply-templates/>
      <xsl:call-template name="makeText">
        <xsl:with-param name="letters">)</xsl:with-param>
      </xsl:call-template>
    </xsl:when>
    <xsl:when test="ancestor::tei:listBibl or         ancestor::tei:biblFull or         ancestor::tei:biblStruct">
      <xsl:text>[</xsl:text>
      <xsl:apply-templates/>
      <xsl:text>] </xsl:text>
    </xsl:when>
    <xsl:when test="@place='comment'">
      <xsl:call-template name="commentNote"/>
    </xsl:when>
    <xsl:when test="@place='inline' and not(tei:is-inline(.))">
      <xsl:call-template name="displayNote"/>
    </xsl:when>
    <xsl:when test="@place='inline'">
      <xsl:call-template name="plainNote"/>
    </xsl:when>
    <xsl:when test="tei:isEndNote(.) or $autoEndNotes='true'">
      <xsl:call-template name="endNote"/>
    </xsl:when>
    <xsl:when test="tei:isFootNote(.)">
      <xsl:call-template name="footNote"/>
    </xsl:when>
    <xsl:when test="@place='margin' or          @place='margin/inline' or         @place='marg1' or         @place='marg2' or         @place='marg3' or         @place='marge' or         @place='h' or         @place='inter' or         @place='divend' or         @place='marginOuter' or         @place='marginLeft' or         @place='marginRight'">
      <xsl:call-template name="marginalNote"/>
    </xsl:when>
    <xsl:when test="(@place='display' or not(tei:is-inline(.)) or tei:q)">
      <xsl:call-template name="displayNote"/>
    </xsl:when>
    <xsl:when test="@place">
      <xsl:message terminate="yes">unknown @place for note,
        <xsl:value-of select="@place"/>
      </xsl:message>
    </xsl:when>
    <xsl:otherwise>
      <xsl:call-template name="plainNote"/>
    </xsl:otherwise>
  </xsl:choose>
</xsl:template>

<xsl:template name="marginalNote">
  <xsl:call-template name="plainNote"/>
</xsl:template>

<xsl:template name="endNote">
  <xsl:call-template name="plainNote"/>
</xsl:template>

<xsl:template name="footNote">
  <xsl:call-template name="plainNote"/>
</xsl:template>

<xsl:template name="commentNote">
  <xsl:call-template name="plainNote"/>
</xsl:template>

<xsl:template name="displayNote">
  <xsl:call-template name="plainNote"/>
</xsl:template>

<xsl:template name="plainNote">
  <xsl:text> [</xsl:text>
  <xsl:choose>
    <xsl:when test="@n">
      <xsl:value-of select="@n"/>
    </xsl:when>
    <xsl:otherwise>
      <xsl:sequence select="tei:i18n('Note')"/>
      <xsl:text>: </xsl:text>
    </xsl:otherwise>
  </xsl:choose>
  <xsl:apply-templates/>
  <xsl:text>] </xsl:text>
</xsl:template>

<xsl:template match="tei:bibl">
  <xsl:choose>
    <xsl:when test="parent::tei:cit[@rend='display'] or         (parent::tei:cit and tei:p) or  parent::tei:q[tei:is-inline(.)]">
      <xsl:call-template name="makeInline">
        <xsl:with-param name="style">citbibl</xsl:with-param>
      </xsl:call-template>
    </xsl:when>
    <xsl:when test="parent::tei:q/parent::tei:head or parent::tei:q[@rend='inline']">
      <xsl:call-template name="makeBlock">
        <xsl:with-param name="style">citbibl</xsl:with-param>
      </xsl:call-template>
    </xsl:when>
    <xsl:when test="not(tei:is-inline(.))">
      <xsl:call-template name="makeBlock">
        <xsl:with-param name="style">biblfree</xsl:with-param>
      </xsl:call-template>
    </xsl:when>
    <xsl:otherwise>
      <xsl:call-template name="makeInline">
        <xsl:with-param name="style">
          <xsl:text>bibl</xsl:text>
        </xsl:with-param>
        <xsl:with-param name="before">
          <xsl:if test="parent::tei:cit">
            <xsl:text> (</xsl:text>
          </xsl:if>
        </xsl:with-param>
        <xsl:with-param name="after">
          <xsl:if test="parent::tei:cit">
            <xsl:text>)</xsl:text>
          </xsl:if>
        </xsl:with-param>
      </xsl:call-template>
    </xsl:otherwise>
  </xsl:choose>
</xsl:template>

<xsl:template match="tite:b" mode="tite">
  <hi xmlns="http://www.tei-c.org/ns/1.0" rend="bold">
    <xsl:apply-templates select="@*|*|text()|comment()|processing-instruction" mode="tite"/>
  </hi>
</xsl:template>

<xsl:template match="tite:i" mode="tite">
  <hi xmlns="http://www.tei-c.org/ns/1.0" rend="italic">
    <xsl:apply-templates select="@*|*|text()|comment()|processing-instruction" mode="tite"/>
  </hi>
</xsl:template>

<xsl:template match="tite:ul" mode="tite">
  <hi xmlns="http://www.tei-c.org/ns/1.0" rend="underline">
    <xsl:apply-templates select="@*|*|text()|comment()|processing-instruction" mode="tite"/>
  </hi>
</xsl:template>

<xsl:template match="tite:sup" mode="tite">
  <hi xmlns="http://www.tei-c.org/ns/1.0" rend="sup">
    <xsl:apply-templates select="@*|*|text()|comment()|processing-instruction" mode="tite"/>
  </hi>
</xsl:template>

<xsl:template match="tite:sub" mode="tite">
  <hi xmlns="http://www.tei-c.org/ns/1.0" rend="sub">
    <xsl:apply-templates select="@*|*|text()|comment()|processing-instruction" mode="tite"/>
  </hi>
</xsl:template>

<xsl:template match="tite:smcap" mode="tite">
  <hi xmlns="http://www.tei-c.org/ns/1.0" rend="smcap">
    <xsl:apply-templates select="@*|*|text()|comment()|processing-instruction" mode="tite"/>
  </hi>
</xsl:template>

<xsl:template match="*" mode="tite">
  <xsl:copy>
    <xsl:apply-templates select="@*|*|processing-instruction()|comment()|text()" mode="tite"/>
  </xsl:copy>
</xsl:template>

<xsl:template match="comment()|@*|processing-instruction()|text()" mode="tite">
  <xsl:copy-of select="."/>
</xsl:template>

<xsl:template match="tei:head" mode="plain">
  <xsl:if test="preceding-sibling::tei:head">
    <xsl:text> </xsl:text>
  </xsl:if>
  <xsl:apply-templates mode="plain"/>
</xsl:template>

<xsl:template match="tei:*" mode="plain">
  <xsl:apply-templates mode="plain"/>
</xsl:template>

<xsl:template match="tei:note" mode="plain"/>

<xsl:template match="tei:app" mode="plain"/>

<xsl:template match="tei:pb" mode="plain"/>

<xsl:template match="tei:lb" mode="plain"/>

<xsl:template match="tei:figure" mode="plain">
  <xsl:text>[</xsl:text>
  <xsl:sequence select="tei:i18n('figureWord')"/>
  <xsl:text>]</xsl:text>
</xsl:template>

<xsl:template match="tei:figDesc" mode="plain"/>

<xsl:template match="tei:ptr" mode="plain"/>

<xsl:output indent="no"/>

<xsl:key name="MNAMES" match="tei:monogr/tei:author[tei:surname]|tei:monogr/tei:editor[tei:surname]" use="ancestor::tei:biblStruct/@xml:id"/>

<xsl:key name="ANAMES" match="tei:analytic/tei:author[tei:surname]|tei:analytic/tei:editor[tei:surname]" use="ancestor::tei:biblStruct/@xml:id"/>