Markdown-2.4/0000777000000000000000000000000012300213225011261 5ustar 00000000000000Markdown-2.4/bin/0000777000000000000000000000000012300213220012024 5ustar 00000000000000Markdown-2.4/bin/markdown_py0000666000000000000000000000203311756571171014331 0ustar 00000000000000#!/usr/bin/env python """ Python Markdown, the Command Line Script ======================================== This is the command line script for Python Markdown. Basic use from the command line: markdown source.txt > destination.html Run "markdown --help" to see more options. See markdown/__init__.py for information on using Python Markdown as a module. ## Authors and License Started by [Manfred Stienstra](http://www.dwerg.net/). Continued and maintained by [Yuri Takhteyev](http://www.freewisdom.org), [Waylan Limberg](http://achinghead.com/) and [Artem Yunusov](http://blog.splyer.com). Contact: markdown@freewisdom.org Copyright 2007, 2008 The Python Markdown Project (v. 1.7 and later) Copyright 200? Django Software Foundation (OrderedDict implementation) Copyright 2004, 2005, 2006 Yuri Takhteyev (v. 0.2-1.6b) Copyright 2004 Manfred Stienstra (the original version) License: BSD (see docs/LICENSE for details). """ if __name__ == '__main__': from markdown.__main__ import run run() Markdown-2.4/docs/0000777000000000000000000000000012300213220012204 5ustar 00000000000000Markdown-2.4/docs/authors.txt0000666000000000000000000000335712111563026014456 0ustar 00000000000000title: Authors prev_title: Release Notes for v2.0 prev_url: release-2.0.html next_title: Table of Contents next_url: siteindex.html Primary Authors =============== [Yuri Takteyev](http://freewisdom.org/) : Yuri has written much of the current code while procrastingating his Ph.D. [Waylan Limberg](http://achinghead.com/) : Waylan is the current maintainer of the code and has written much the current code base, included a complete refactor of the core. He started out by authoring mmany of the available extensions and later was asked to join Yuri, where he began fixing nummrious bugs, adding documentation and making general improvements to the existing codebase. Artem Yunusov : Artem, who as part of a 2008 GSoC project, refactored inline patterns, replaced the NanoDOM with ElementTree support and made various other improvements. [Manfed Stienstra](http://www.dwerg.net/) : Manfed wrote the original version of the script and is responsible for various parts of the existing codebase. David Wolever : David refactored the extension API and made other improvements as he helped to integrate Markdown into Dr.Project. Other Contributors ================== The incomplete list of individuals below have provided patches or otherwise contributed to the project in various ways. We would like to thank everyone who has contributed to the progect in any way. * Eric Abrahamsen * Jeff Balogh * Sergej Chodarev * Chris Clark * Tiago Cogumbreiro * Kjell Magne Fauske * G. Clark Haynes * Daniel Krech * Steward Midwinter * Jack Miller * Neale Pickett * Paul Stansifer * John Szakmeister * Malcolm Tredinnick * Ben Wilson * and many others who helped by reporting bugs Markdown-2.4/docs/basic.css0000666000000000000000000001626212111563026014022 0ustar 00000000000000/** * Sphinx stylesheet -- basic theme * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ */ /* -- main layout ----------------------------------------------------------- */ div.clearer { clear: both; } /* -- relbar ---------------------------------------------------------------- */ div.related { width: 100%; font-size: 90%; } div.related h3 { display: none; } div.related ul { margin: 0; padding: 0 0 0 10px; list-style: none; } div.related li { display: inline; } div.related li.right { float: right; margin-right: 5px; } /* -- sidebar --------------------------------------------------------------- */ div.sphinxsidebarwrapper { padding: 10px 5px 0 10px; } div.sphinxsidebar { float: left; width: 230px; margin-left: -100%; font-size: 90%; } div.sphinxsidebar ul { list-style: none; } div.sphinxsidebar ul ul, div.sphinxsidebar ul.want-points { margin-left: 20px; list-style: square; } div.sphinxsidebar ul ul { margin-top: 0; margin-bottom: 0; } div.sphinxsidebar form { margin-top: 10px; } div.sphinxsidebar input { border: 1px solid #98dbcc; font-family: sans-serif; font-size: 1em; } img { border: 0; } /* -- search page ----------------------------------------------------------- */ ul.search { margin: 10px 0 0 20px; padding: 0; } ul.search li { padding: 5px 0 5px 20px; background-image: url(file.png); background-repeat: no-repeat; background-position: 0 7px; } ul.search li a { font-weight: bold; } ul.search li div.context { color: #888; margin: 2px 0 0 30px; text-align: left; } ul.keywordmatches li.goodmatch a { font-weight: bold; } /* -- index page ------------------------------------------------------------ */ table.contentstable { width: 90%; } table.contentstable p.biglink { line-height: 150%; } a.biglink { font-size: 1.3em; } span.linkdescr { font-style: italic; padding-top: 5px; font-size: 90%; } /* -- general index --------------------------------------------------------- */ table.indextable td { text-align: left; vertical-align: top; } table.indextable dl, table.indextable dd { margin-top: 0; margin-bottom: 0; } table.indextable tr.pcap { height: 10px; } table.indextable tr.cap { margin-top: 10px; background-color: #f2f2f2; } img.toggler { margin-right: 3px; margin-top: 3px; cursor: pointer; } /* -- general body styles --------------------------------------------------- */ a.headerlink { visibility: hidden; } h1:hover > a.headerlink, h2:hover > a.headerlink, h3:hover > a.headerlink, h4:hover > a.headerlink, h5:hover > a.headerlink, h6:hover > a.headerlink, dt:hover > a.headerlink { visibility: visible; } div.body p.caption { text-align: inherit; } div.body td { text-align: left; } .field-list ul { padding-left: 1em; } .first { margin-top: 0 !important; } p.rubric { margin-top: 30px; font-weight: bold; } /* -- sidebars -------------------------------------------------------------- */ div.sidebar { margin: 0 0 0.5em 1em; border: 1px solid #ddb; padding: 7px 7px 0 7px; background-color: #ffe; width: 40%; float: right; } p.sidebar-title { font-weight: bold; } /* -- topics ---------------------------------------------------------------- */ div.topic { border: 1px solid #ccc; padding: 7px 7px 0 7px; margin: 10px 0 10px 0; } p.topic-title { font-size: 1.1em; font-weight: bold; margin-top: 10px; } /* -- admonitions ----------------------------------------------------------- */ div.admonition { margin-top: 10px; margin-bottom: 10px; padding: 7px; } div.admonition dt { font-weight: bold; } div.admonition dl { margin-bottom: 0; } p.admonition-title { margin: 0px 10px 5px 0px; font-weight: bold; } div.body p.centered { text-align: center; margin-top: 25px; } /* -- tables ---------------------------------------------------------------- */ table { border: 0 solid #dce; border-collapse: collapse; } table td, table th { padding: 2px 5px 2px 5px; } table td { border: 1px solid #ddd; background-color: #eef; } table td p.last, table th p.last { margin-bottom: 0; } table.field-list td, table.field-list th { border: 0 !important; } table.footnote td, table.footnote th { border: 0 !important; } table th { border: 1px solid #cac; background-color: #ede; } th { text-align: left; padding-right: 5px; } th.head { text-align: center; } /* -- other body styles ----------------------------------------------------- */ dl { margin-bottom: 15px; } dd p { margin-top: 0px; } dd ul, dd table { margin-bottom: 10px; } dd { margin-top: 3px; margin-bottom: 10px; margin-left: 30px; } dt:target, .highlight { background-color: #fbe54e; } dl.glossary dt { font-weight: bold; font-size: 1.1em; } .field-list ul { margin: 0; padding-left: 1em; } .field-list p { margin: 0; } .refcount { color: #060; } .optional { font-size: 1.3em; } .versionmodified { font-style: italic; } p.deprecated { background-color: #ffe4e4; border: 1px solid #f66; padding: 7px } .system-message { background-color: #fda; padding: 5px; border: 3px solid red; } .footnote:target { background-color: #ffa; } .impl-detail { margin-top: 10px; margin-bottom: 10px; padding: 7px; border: 1px solid #ccc; } .impl-detail .compound-first { margin-top: 0; } .impl-detail .compound-last { margin-bottom: 0; } /* -- code displays --------------------------------------------------------- */ pre { overflow: auto; overflow-y: hidden; } code { font-size: 1.1em; } td.linenos pre { padding: 5px 0px; border: 0; background-color: transparent; color: #aaa; } table.highlighttable { margin-left: 0.5em; } table.highlighttable td { padding: 0 0.5em 0 0.5em; } tt.descname { background-color: transparent; font-weight: bold; font-size: 1.2em; } tt.descclassname { background-color: transparent; } tt.xref, a tt { background-color: transparent; font-weight: bold; } h1 tt, h2 tt, h3 tt, h4 tt, h5 tt, h6 tt { background-color: transparent; } /* -- math display ---------------------------------------------------------- */ img.math { vertical-align: middle; } div.body div.math p { text-align: center; } span.eqno { float: right; } /* -- printout stylesheet --------------------------------------------------- */ @media print { div.document, div.documentwrapper, div.bodywrapper { margin: 0 !important; width: 100%; } div.sphinxsidebar, div.related, div.footer, #top-link { display: none; } } Markdown-2.4/docs/change_log.txt0000666000000000000000000001667312261107556015074 0ustar 00000000000000title: Change Log prev_title: Test Suite prev_url: test_suite.html next_title: Release Notes for v2.4 next_url: release-2.4.html Python-Markdown Changelog ========================= __: Released version 2.4.0 ([Notes](release-2.4.html)) Mar 22, 2013: Released version 2.3.1 (a bugfix release). Mar 14, 2013: Released version 2.3.0 ([Notes](release-2.3.html)) Nov 4, 2012: Released version 2.2.1 ([Notes](release-2.2.1.html)). Jul 5, 2012: Released version 2.2.0 ([Notes](release-2.2.0.html)). Jan 22, 2012: Released version 2.1.1 ([Notes](release-2.1.1.html)). Nov 24, 2011: Released version 2.1.0 ([Notes](release-2.1.0.html)). Oct 7, 2009: Released version 2.0.3. Sept 28, 2009: Released version 2.0.2 ([Notes](release-2.0.2.html)). May 20, 2009: Released version 2.0.1 ([Notes](release-2.0.1.html)). Mar 30, 2009: Released version 2.0 ([Notes](release-2.0.html)). Mar 8, 2009: Release Candidate 2.0-rc-1. Feb 2009: Added support for multi-level lists to new Blockprocessors. Jan 2009: Added HTML 4 output as an option (thanks Eric Abrahamsen) Nov 2008: Added Definistion List ext. Replaced old core with BlockProcessors. Broken up into multiple files. Oct 2008: Changed logging behavior to work better with other systems. Refactored tree tarversing. Added treap implementation, then replaced with OrderedDEict. Renamed various processors to better reflect what they actually do. Refactored footnote ext to match php Extra's output. Sept 2008: Moved prettifyTree to a Postprocessor, replaced wikilink ext with wikilinks (note the s) ext (uses bracketed links instead of CamelCase) and various bug fixes. August 18 2008: Reorganized directory structure. Added a 'docs' dir and moved all extensions into a 'markdown-extensions' package. Added additional documentation and a few bug fixes. (v2.0-beta) August 4 2008: Updated included extensions to ElementTree. Added a seperate commanline script. (v2.0-alpha) July 2008: Switched from home-grown NanoDOM to ElementTree and various related bugs (thanks Artem Yunusov). June 2008: Fixed issues with nested inline patterns and cleaned up testing framework (thanks Artem Yunusov). May 2008: Added a number of additional extensions to the distribution and other minor changes. Moved repo to git from svn. Mar 2008: Refactored extension api to accept either an extension name (as a string) or an instance of an extension (Thanks David Wolever). Fixed various bugs and added doc strings. Feb 2008: Various bugfixes mostly regarding extensions. Feb 18, 2008: Version 1.7. Feb 13, 2008: A little code cleanup and better documentation and inheritance for pre/post proccessors. Feb 9, 2008: Doublequotes no longer html escaped and rawhtml honors ``, `<@foo>`, and `<%foo>` for those who run markdown on template syntax. Dec 12, 2007: Updated docs. Removed encoding arg from Markdown and markdown as per list discussion. Clean up in prep for 1.7. Nov 29, 2007: Added support for images inside links. Also fixed a few bugs in the footnote extension. Nov 19, 2007: `message` now uses python's logging module. Also removed limit imposed by recursion in `_process_section()`. You can now parse as long of a document as your memory can handle. Nov 5, 2007: Moved safe_mode code to a textPostprocessor and added escaping option. Nov 3, 2007: Fixed convert method to accept empty strings. Oct 30, 2007: Fixed BOM removal (thanks Malcolm Tredinnick). Fixed infinite loop in bracket regex for inline links. Oct 11, 2007: LineBreaks is now an inlinePattern. Fixed HR in blockquotes. Refactored _processSection method (see tracker #1793419). Oct 9, 2007: Added textPreprocessor (from 1.6b). Oct 8, 2008: Fixed Lazy Blockquote. Fixed code block on first line. Fixed empty inline image link. Oct 7, 2007: Limit recursion on inlinePatterns. Added a 'safe' tag to htmlStash. March 18, 2007: Fixed or merged a bunch of minor bugs, including multi-line comments and markup inside links. (Tracker #s: 1683066, 1671153, 1661751, 1627935, 1544371, 1458139.) -> v. 1.6b Oct 10, 2006: Fixed a bug that caused some text to be lost after comments. Added "safe mode" (user's html tags are removed). Sept 6, 2006: Added exception for PHP tags when handling html blocks. August 7, 2006: Incorporated Sergej Chodarev's patch to fix a problem with ampersand normalization and html blocks. July 10, 2006: Switched to using optparse. Added proper support for unicode. July 9, 2006: Fixed the `
%(body)s

Table Of Contents

%(toc)s

Previous topic

%(prev_title)s

Next topic

%(next_title)s

This Page

Markdown-2.4/INSTALL.md0000666000000000000000000000042112111563026012715 0ustar 00000000000000Installing Python-Markdown ========================== As an Admin/Root user on your system do: pip install markdown Or for more specific instructions, view the documentation in `docs/install.txt` or on the website at . Markdown-2.4/LICENSE.md0000666000000000000000000000323511756571171012715 0ustar 00000000000000Copyright 2007, 2008 The Python Markdown Project (v. 1.7 and later) Copyright 2004, 2005, 2006 Yuri Takhteyev (v. 0.2-1.6b) Copyright 2004 Manfred Stienstra (the original version) All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. * Neither the name of the nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. THIS SOFTWARE IS PROVIDED BY THE PYTHON MARKDOWN PROJECT ''AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL ANY CONTRIBUTORS TO THE PYTHON MARKDOWN PROJECT BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. Markdown-2.4/makefile0000666000000000000000000000154512153773345013012 0ustar 00000000000000# Python-Markdown makefile .PHONY : install install: python setup.py install .PHONY : deploy deploy: python setup.py register python setup.py sdist --formats zip,gztar upload .PHONY : build build: python setup.py sdist --formats zip,gztar .PHONY : build-win build-win: python setup.py bdist_wininst .PHONY : docs docs: python setup.py build_docs --force cd build/docs && zip -r ../docs.zip . .PHONY : test test: tox .PHONY : update-tests update-tests: python run-tests.py update .PHONY : clean clean: rm -f MANIFEST rm -f test-output.html rm -f *.pyc rm -f markdown/*.pyc rm -f markdown/extensions/*.pyc rm -f *.bak rm -f markdown/*.bak rm -f markdown/extensions/*.bak rm -f *.swp rm -f markdown/*.swp rm -f markdown/extensions/*.swp rm -rf build rm -rf dist rm -rf tmp # git clean -dfx' Markdown-2.4/markdown/0000777000000000000000000000000012300213220013076 5ustar 00000000000000Markdown-2.4/markdown/blockparser.py0000666000000000000000000000712112153773345016011 0ustar 00000000000000from __future__ import unicode_literals from __future__ import absolute_import from . import util from . import odict class State(list): """ Track the current and nested state of the parser. This utility class is used to track the state of the BlockParser and support multiple levels if nesting. It's just a simple API wrapped around a list. Each time a state is set, that state is appended to the end of the list. Each time a state is reset, that state is removed from the end of the list. Therefore, each time a state is set for a nested block, that state must be reset when we back out of that level of nesting or the state could be corrupted. While all the methods of a list object are available, only the three defined below need be used. """ def set(self, state): """ Set a new state. """ self.append(state) def reset(self): """ Step back one step in nested state. """ self.pop() def isstate(self, state): """ Test that top (current) level is of given state. """ if len(self): return self[-1] == state else: return False class BlockParser: """ Parse Markdown blocks into an ElementTree object. A wrapper class that stitches the various BlockProcessors together, looping through them and creating an ElementTree object. """ def __init__(self, markdown): self.blockprocessors = odict.OrderedDict() self.state = State() self.markdown = markdown def parseDocument(self, lines): """ Parse a markdown document into an ElementTree. Given a list of lines, an ElementTree object (not just a parent Element) is created and the root element is passed to the parser as the parent. The ElementTree object is returned. This should only be called on an entire document, not pieces. """ # Create a ElementTree from the lines self.root = util.etree.Element(self.markdown.doc_tag) self.parseChunk(self.root, '\n'.join(lines)) return util.etree.ElementTree(self.root) def parseChunk(self, parent, text): """ Parse a chunk of markdown text and attach to given etree node. While the ``text`` argument is generally assumed to contain multiple blocks which will be split on blank lines, it could contain only one block. Generally, this method would be called by extensions when block parsing is required. The ``parent`` etree Element passed in is altered in place. Nothing is returned. """ self.parseBlocks(parent, text.split('\n\n')) def parseBlocks(self, parent, blocks): """ Process blocks of markdown text and attach to given etree node. Given a list of ``blocks``, each blockprocessor is stepped through until there are no blocks left. While an extension could potentially call this method directly, it's generally expected to be used internally. This is a public method as an extension may need to add/alter additional BlockProcessors which call this method to recursively parse a nested block. """ while blocks: for processor in self.blockprocessors.values(): if processor.test(parent, blocks[0]): if processor.run(parent, blocks) is not False: # run returns True or None break Markdown-2.4/markdown/blockprocessors.py0000666000000000000000000005471512300201166016707 0ustar 00000000000000""" CORE MARKDOWN BLOCKPARSER =========================================================================== This parser handles basic parsing of Markdown blocks. It doesn't concern itself with inline elements such as **bold** or *italics*, but rather just catches blocks, lists, quotes, etc. The BlockParser is made up of a bunch of BlockProssors, each handling a different type of block. Extensions may add/replace/remove BlockProcessors as they need to alter how markdown blocks are parsed. """ from __future__ import absolute_import from __future__ import division from __future__ import unicode_literals import logging import re from . import util from .blockparser import BlockParser logger = logging.getLogger('MARKDOWN') def build_block_parser(md_instance, **kwargs): """ Build the default block parser used by Markdown. """ parser = BlockParser(md_instance) parser.blockprocessors['empty'] = EmptyBlockProcessor(parser) parser.blockprocessors['indent'] = ListIndentProcessor(parser) parser.blockprocessors['code'] = CodeBlockProcessor(parser) parser.blockprocessors['hashheader'] = HashHeaderProcessor(parser) parser.blockprocessors['setextheader'] = SetextHeaderProcessor(parser) parser.blockprocessors['hr'] = HRProcessor(parser) parser.blockprocessors['olist'] = OListProcessor(parser) parser.blockprocessors['ulist'] = UListProcessor(parser) parser.blockprocessors['quote'] = BlockQuoteProcessor(parser) parser.blockprocessors['paragraph'] = ParagraphProcessor(parser) return parser class BlockProcessor: """ Base class for block processors. Each subclass will provide the methods below to work with the source and tree. Each processor will need to define it's own ``test`` and ``run`` methods. The ``test`` method should return True or False, to indicate whether the current block should be processed by this processor. If the test passes, the parser will call the processors ``run`` method. """ def __init__(self, parser): self.parser = parser self.tab_length = parser.markdown.tab_length def lastChild(self, parent): """ Return the last child of an etree element. """ if len(parent): return parent[-1] else: return None def detab(self, text): """ Remove a tab from the front of each line of the given text. """ newtext = [] lines = text.split('\n') for line in lines: if line.startswith(' '*self.tab_length): newtext.append(line[self.tab_length:]) elif not line.strip(): newtext.append('') else: break return '\n'.join(newtext), '\n'.join(lines[len(newtext):]) def looseDetab(self, text, level=1): """ Remove a tab from front of lines but allowing dedented lines. """ lines = text.split('\n') for i in range(len(lines)): if lines[i].startswith(' '*self.tab_length*level): lines[i] = lines[i][self.tab_length*level:] return '\n'.join(lines) def test(self, parent, block): """ Test for block type. Must be overridden by subclasses. As the parser loops through processors, it will call the ``test`` method on each to determine if the given block of text is of that type. This method must return a boolean ``True`` or ``False``. The actual method of testing is left to the needs of that particular block type. It could be as simple as ``block.startswith(some_string)`` or a complex regular expression. As the block type may be different depending on the parent of the block (i.e. inside a list), the parent etree element is also provided and may be used as part of the test. Keywords: * ``parent``: A etree element which will be the parent of the block. * ``block``: A block of text from the source which has been split at blank lines. """ pass def run(self, parent, blocks): """ Run processor. Must be overridden by subclasses. When the parser determines the appropriate type of a block, the parser will call the corresponding processor's ``run`` method. This method should parse the individual lines of the block and append them to the etree. Note that both the ``parent`` and ``etree`` keywords are pointers to instances of the objects which should be edited in place. Each processor must make changes to the existing objects as there is no mechanism to return new/different objects to replace them. This means that this method should be adding SubElements or adding text to the parent, and should remove (``pop``) or add (``insert``) items to the list of blocks. Keywords: * ``parent``: A etree element which is the parent of the current block. * ``blocks``: A list of all remaining blocks of the document. """ pass class ListIndentProcessor(BlockProcessor): """ Process children of list items. Example: * a list item process this part or this part """ ITEM_TYPES = ['li'] LIST_TYPES = ['ul', 'ol'] def __init__(self, *args): BlockProcessor.__init__(self, *args) self.INDENT_RE = re.compile(r'^(([ ]{%s})+)'% self.tab_length) def test(self, parent, block): return block.startswith(' '*self.tab_length) and \ not self.parser.state.isstate('detabbed') and \ (parent.tag in self.ITEM_TYPES or \ (len(parent) and parent[-1] and \ (parent[-1].tag in self.LIST_TYPES) ) ) def run(self, parent, blocks): block = blocks.pop(0) level, sibling = self.get_level(parent, block) block = self.looseDetab(block, level) self.parser.state.set('detabbed') if parent.tag in self.ITEM_TYPES: # It's possible that this parent has a 'ul' or 'ol' child list # with a member. If that is the case, then that should be the # parent. This is intended to catch the edge case of an indented # list whose first member was parsed previous to this point # see OListProcessor if len(parent) and parent[-1].tag in self.LIST_TYPES: self.parser.parseBlocks(parent[-1], [block]) else: # The parent is already a li. Just parse the child block. self.parser.parseBlocks(parent, [block]) elif sibling.tag in self.ITEM_TYPES: # The sibling is a li. Use it as parent. self.parser.parseBlocks(sibling, [block]) elif len(sibling) and sibling[-1].tag in self.ITEM_TYPES: # The parent is a list (``ol`` or ``ul``) which has children. # Assume the last child li is the parent of this block. if sibling[-1].text: # If the parent li has text, that text needs to be moved to a p # The p must be 'inserted' at beginning of list in the event # that other children already exist i.e.; a nested sublist. p = util.etree.Element('p') p.text = sibling[-1].text sibling[-1].text = '' sibling[-1].insert(0, p) self.parser.parseChunk(sibling[-1], block) else: self.create_item(sibling, block) self.parser.state.reset() def create_item(self, parent, block): """ Create a new li and parse the block with it as the parent. """ li = util.etree.SubElement(parent, 'li') self.parser.parseBlocks(li, [block]) def get_level(self, parent, block): """ Get level of indent based on list level. """ # Get indent level m = self.INDENT_RE.match(block) if m: indent_level = len(m.group(1))/self.tab_length else: indent_level = 0 if self.parser.state.isstate('list'): # We're in a tightlist - so we already are at correct parent. level = 1 else: # We're in a looselist - so we need to find parent. level = 0 # Step through children of tree to find matching indent level. while indent_level > level: child = self.lastChild(parent) if child is not None and (child.tag in self.LIST_TYPES or child.tag in self.ITEM_TYPES): if child.tag in self.LIST_TYPES: level += 1 parent = child else: # No more child levels. If we're short of indent_level, # we have a code block. So we stop here. break return level, parent class CodeBlockProcessor(BlockProcessor): """ Process code blocks. """ def test(self, parent, block): return block.startswith(' '*self.tab_length) def run(self, parent, blocks): sibling = self.lastChild(parent) block = blocks.pop(0) theRest = '' if sibling is not None and sibling.tag == "pre" and len(sibling) \ and sibling[0].tag == "code": # The previous block was a code block. As blank lines do not start # new code blocks, append this block to the previous, adding back # linebreaks removed from the split into a list. code = sibling[0] block, theRest = self.detab(block) code.text = util.AtomicString('%s\n%s\n' % (code.text, block.rstrip())) else: # This is a new codeblock. Create the elements and insert text. pre = util.etree.SubElement(parent, 'pre') code = util.etree.SubElement(pre, 'code') block, theRest = self.detab(block) code.text = util.AtomicString('%s\n' % block.rstrip()) if theRest: # This block contained unindented line(s) after the first indented # line. Insert these lines as the first block of the master blocks # list for future processing. blocks.insert(0, theRest) class BlockQuoteProcessor(BlockProcessor): RE = re.compile(r'(^|\n)[ ]{0,3}>[ ]?(.*)') def test(self, parent, block): return bool(self.RE.search(block)) def run(self, parent, blocks): block = blocks.pop(0) m = self.RE.search(block) if m: before = block[:m.start()] # Lines before blockquote # Pass lines before blockquote in recursively for parsing forst. self.parser.parseBlocks(parent, [before]) # Remove ``> `` from begining of each line. block = '\n'.join([self.clean(line) for line in block[m.start():].split('\n')]) sibling = self.lastChild(parent) if sibling is not None and sibling.tag == "blockquote": # Previous block was a blockquote so set that as this blocks parent quote = sibling else: # This is a new blockquote. Create a new parent element. quote = util.etree.SubElement(parent, 'blockquote') # Recursively parse block with blockquote as parent. # change parser state so blockquotes embedded in lists use p tags self.parser.state.set('blockquote') self.parser.parseChunk(quote, block) self.parser.state.reset() def clean(self, line): """ Remove ``>`` from beginning of a line. """ m = self.RE.match(line) if line.strip() == ">": return "" elif m: return m.group(2) else: return line class OListProcessor(BlockProcessor): """ Process ordered list blocks. """ TAG = 'ol' # Detect an item (``1. item``). ``group(1)`` contains contents of item. RE = re.compile(r'^[ ]{0,3}\d+\.[ ]+(.*)') # Detect items on secondary lines. they can be of either list type. CHILD_RE = re.compile(r'^[ ]{0,3}((\d+\.)|[*+-])[ ]+(.*)') # Detect indented (nested) items of either type INDENT_RE = re.compile(r'^[ ]{4,7}((\d+\.)|[*+-])[ ]+.*') # The integer (python string) with which the lists starts (default=1) # Eg: If list is intialized as) # 3. Item # The ol tag will get starts="3" attribute STARTSWITH = '1' # List of allowed sibling tags. SIBLING_TAGS = ['ol', 'ul'] def test(self, parent, block): return bool(self.RE.match(block)) def run(self, parent, blocks): # Check fr multiple items in one block. items = self.get_items(blocks.pop(0)) sibling = self.lastChild(parent) if sibling is not None and sibling.tag in self.SIBLING_TAGS: # Previous block was a list item, so set that as parent lst = sibling # make sure previous item is in a p- if the item has text, then it # it isn't in a p if lst[-1].text: # since it's possible there are other children for this sibling, # we can't just SubElement the p, we need to insert it as the # first item p = util.etree.Element('p') p.text = lst[-1].text lst[-1].text = '' lst[-1].insert(0, p) # if the last item has a tail, then the tail needs to be put in a p # likely only when a header is not followed by a blank line lch = self.lastChild(lst[-1]) if lch is not None and lch.tail: p = util.etree.SubElement(lst[-1], 'p') p.text = lch.tail.lstrip() lch.tail = '' # parse first block differently as it gets wrapped in a p. li = util.etree.SubElement(lst, 'li') self.parser.state.set('looselist') firstitem = items.pop(0) self.parser.parseBlocks(li, [firstitem]) self.parser.state.reset() elif parent.tag in ['ol', 'ul']: # this catches the edge case of a multi-item indented list whose # first item is in a blank parent-list item: # * * subitem1 # * subitem2 # see also ListIndentProcessor lst = parent else: # This is a new list so create parent with appropriate tag. lst = util.etree.SubElement(parent, self.TAG) # Check if a custom start integer is set if not self.parser.markdown.lazy_ol and self.STARTSWITH !='1': lst.attrib['start'] = self.STARTSWITH self.parser.state.set('list') # Loop through items in block, recursively parsing each with the # appropriate parent. for item in items: if item.startswith(' '*self.tab_length): # Item is indented. Parse with last item as parent self.parser.parseBlocks(lst[-1], [item]) else: # New item. Create li and parse with it as parent li = util.etree.SubElement(lst, 'li') self.parser.parseBlocks(li, [item]) self.parser.state.reset() def get_items(self, block): """ Break a block into list items. """ items = [] for line in block.split('\n'): m = self.CHILD_RE.match(line) if m: # This is a new list item # Check first item for the start index if not items and self.TAG=='ol': # Detect the integer value of first list item INTEGER_RE = re.compile('(\d+)') self.STARTSWITH = INTEGER_RE.match(m.group(1)).group() # Append to the list items.append(m.group(3)) elif self.INDENT_RE.match(line): # This is an indented (possibly nested) item. if items[-1].startswith(' '*self.tab_length): # Previous item was indented. Append to that item. items[-1] = '%s\n%s' % (items[-1], line) else: items.append(line) else: # This is another line of previous item. Append to that item. items[-1] = '%s\n%s' % (items[-1], line) return items class UListProcessor(OListProcessor): """ Process unordered list blocks. """ TAG = 'ul' RE = re.compile(r'^[ ]{0,3}[*+-][ ]+(.*)') class HashHeaderProcessor(BlockProcessor): """ Process Hash Headers. """ # Detect a header at start of any line in block RE = re.compile(r'(^|\n)(?P#{1,6})(?P
.*?)#*(\n|$)') def test(self, parent, block): return bool(self.RE.search(block)) def run(self, parent, blocks): block = blocks.pop(0) m = self.RE.search(block) if m: before = block[:m.start()] # All lines before header after = block[m.end():] # All lines after header if before: # As the header was not the first line of the block and the # lines before the header must be parsed first, # recursively parse this lines as a block. self.parser.parseBlocks(parent, [before]) # Create header using named groups from RE h = util.etree.SubElement(parent, 'h%d' % len(m.group('level'))) h.text = m.group('header').strip() if after: # Insert remaining lines as first block for future parsing. blocks.insert(0, after) else: # This should never happen, but just in case... logger.warn("We've got a problem header: %r" % block) class SetextHeaderProcessor(BlockProcessor): """ Process Setext-style Headers. """ # Detect Setext-style header. Must be first 2 lines of block. RE = re.compile(r'^.*?\n[=-]+[ ]*(\n|$)', re.MULTILINE) def test(self, parent, block): return bool(self.RE.match(block)) def run(self, parent, blocks): lines = blocks.pop(0).split('\n') # Determine level. ``=`` is 1 and ``-`` is 2. if lines[1].startswith('='): level = 1 else: level = 2 h = util.etree.SubElement(parent, 'h%d' % level) h.text = lines[0].strip() if len(lines) > 2: # Block contains additional lines. Add to master blocks for later. blocks.insert(0, '\n'.join(lines[2:])) class HRProcessor(BlockProcessor): """ Process Horizontal Rules. """ RE = r'^[ ]{0,3}((-+[ ]{0,2}){3,}|(_+[ ]{0,2}){3,}|(\*+[ ]{0,2}){3,})[ ]*' # Detect hr on any line of a block. SEARCH_RE = re.compile(RE, re.MULTILINE) def test(self, parent, block): m = self.SEARCH_RE.search(block) # No atomic grouping in python so we simulate it here for performance. # The regex only matches what would be in the atomic group - the HR. # Then check if we are at end of block or if next char is a newline. if m and (m.end() == len(block) or block[m.end()] == '\n'): # Save match object on class instance so we can use it later. self.match = m return True return False def run(self, parent, blocks): block = blocks.pop(0) # Check for lines in block before hr. prelines = block[:self.match.start()].rstrip('\n') if prelines: # Recursively parse lines before hr so they get parsed first. self.parser.parseBlocks(parent, [prelines]) # create hr util.etree.SubElement(parent, 'hr') # check for lines in block after hr. postlines = block[self.match.end():].lstrip('\n') if postlines: # Add lines after hr to master blocks for later parsing. blocks.insert(0, postlines) class EmptyBlockProcessor(BlockProcessor): """ Process blocks that are empty or start with an empty line. """ def test(self, parent, block): return not block or block.startswith('\n') def run(self, parent, blocks): block = blocks.pop(0) filler = '\n\n' if block: # Starts with empty line # Only replace a single line. filler = '\n' # Save the rest for later. theRest = block[1:] if theRest: # Add remaining lines to master blocks for later. blocks.insert(0, theRest) sibling = self.lastChild(parent) if sibling is not None and sibling.tag == 'pre' and len(sibling) and sibling[0].tag == 'code': # Last block is a codeblock. Append to preserve whitespace. sibling[0].text = util.AtomicString('%s%s' % (sibling[0].text, filler)) class ParagraphProcessor(BlockProcessor): """ Process Paragraph blocks. """ def test(self, parent, block): return True def run(self, parent, blocks): block = blocks.pop(0) if block.strip(): # Not a blank block. Add to parent, otherwise throw it away. if self.parser.state.isstate('list'): # The parent is a tight-list. # # Check for any children. This will likely only happen in a # tight-list when a header isn't followed by a blank line. # For example: # # * # Header # Line 2 of list item - not part of header. sibling = self.lastChild(parent) if sibling is not None: # Insetrt after sibling. if sibling.tail: sibling.tail = '%s\n%s' % (sibling.tail, block) else: sibling.tail = '\n%s' % block else: # Append to parent.text if parent.text: parent.text = '%s\n%s' % (parent.text, block) else: parent.text = block.lstrip() else: # Create a regular paragraph p = util.etree.SubElement(parent, 'p') p.text = block.lstrip() Markdown-2.4/markdown/extensions/0000777000000000000000000000000012300213220015275 5ustar 00000000000000Markdown-2.4/markdown/extensions/abbr.py0000666000000000000000000000576112261107556016612 0ustar 00000000000000''' Abbreviation Extension for Python-Markdown ========================================== This extension adds abbreviation handling to Python-Markdown. Simple Usage: >>> import markdown >>> text = """ ... Some text with an ABBR and a REF. Ignore REFERENCE and ref. ... ... *[ABBR]: Abbreviation ... *[REF]: Abbreviation Reference ... """ >>> print markdown.markdown(text, ['abbr'])

Some text with an ABBR and a REF. Ignore REFERENCE and ref.

Copyright 2007-2008 * [Waylan Limberg](http://achinghead.com/) * [Seemant Kulleen](http://www.kulleen.org/) ''' from __future__ import absolute_import from __future__ import unicode_literals from . import Extension from ..preprocessors import Preprocessor from ..inlinepatterns import Pattern from ..util import etree, AtomicString import re # Global Vars ABBR_REF_RE = re.compile(r'[*]\[(?P[^\]]*)\][ ]?:\s*(?P.*)') class AbbrExtension(Extension): """ Abbreviation Extension for Python-Markdown. """ def extendMarkdown(self, md, md_globals): """ Insert AbbrPreprocessor before ReferencePreprocessor. """ md.preprocessors.add('abbr', AbbrPreprocessor(md), '<reference') class AbbrPreprocessor(Preprocessor): """ Abbreviation Preprocessor - parse text for abbr references. """ def run(self, lines): ''' Find and remove all Abbreviation references from the text. Each reference is set as a new AbbrPattern in the markdown instance. ''' new_text = [] for line in lines: m = ABBR_REF_RE.match(line) if m: abbr = m.group('abbr').strip() title = m.group('title').strip() self.markdown.inlinePatterns['abbr-%s'%abbr] = \ AbbrPattern(self._generate_pattern(abbr), title) else: new_text.append(line) return new_text def _generate_pattern(self, text): ''' Given a string, returns an regex pattern to match that string. 'HTML' -> r'(?P<abbr>[H][T][M][L])' Note: we force each char as a literal match (in brackets) as we don't know what they will be beforehand. ''' chars = list(text) for i in range(len(chars)): chars[i] = r'[%s]' % chars[i] return r'(?P<abbr>\b%s\b)' % (r''.join(chars)) class AbbrPattern(Pattern): """ Abbreviation inline pattern. """ def __init__(self, pattern, title): super(AbbrPattern, self).__init__(pattern) self.title = title def handleMatch(self, m): abbr = etree.Element('abbr') abbr.text = AtomicString(m.group('abbr')) abbr.set('title', self.title) return abbr def makeExtension(configs=None): return AbbrExtension(configs=configs) ���������������Markdown-2.4/markdown/extensions/admonition.py������������������������������������������������������0000666�0000000�0000000�00000007470�12153773345�020051� 0����������������������������������������������������������������������������������������������������ustar �����������������������������������������������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������""" Admonition extension for Python-Markdown ======================================== Adds rST-style admonitions. Inspired by [rST][] feature with the same name. The syntax is (followed by an indented block with the contents): !!! [type] [optional explicit title] Where `type` is used as a CSS class name of the div. If not present, `title` defaults to the capitalized `type`, so "note" -> "Note". rST suggests the following `types`, but you're free to use whatever you want: attention, caution, danger, error, hint, important, note, tip, warning A simple example: !!! note This is the first line inside the box. Outputs: <div class="admonition note"> <p class="admonition-title">Note</p> <p>This is the first line inside the box</p> </div> You can also specify the title and CSS class of the admonition: !!! custom "Did you know?" Another line here. Outputs: <div class="admonition custom"> <p class="admonition-title">Did you know?</p> <p>Another line here.</p> </div> [rST]: http://docutils.sourceforge.net/docs/ref/rst/directives.html#specific-admonitions By [Tiago Serafim](http://www.tiagoserafim.com/). """ from __future__ import absolute_import from __future__ import unicode_literals from . import Extension from ..blockprocessors import BlockProcessor from ..util import etree import re class AdmonitionExtension(Extension): """ Admonition extension for Python-Markdown. """ def extendMarkdown(self, md, md_globals): """ Add Admonition to Markdown instance. """ md.registerExtension(self) md.parser.blockprocessors.add('admonition', AdmonitionProcessor(md.parser), '_begin') class AdmonitionProcessor(BlockProcessor): CLASSNAME = 'admonition' CLASSNAME_TITLE = 'admonition-title' RE = re.compile(r'(?:^|\n)!!!\ ?([\w\-]+)(?:\ "(.*?)")?') def test(self, parent, block): sibling = self.lastChild(parent) return self.RE.search(block) or \ (block.startswith(' ' * self.tab_length) and sibling and \ sibling.get('class', '').find(self.CLASSNAME) != -1) def run(self, parent, blocks): sibling = self.lastChild(parent) block = blocks.pop(0) m = self.RE.search(block) if m: block = block[m.end() + 1:] # removes the first line block, theRest = self.detab(block) if m: klass, title = self.get_class_and_title(m) div = etree.SubElement(parent, 'div') div.set('class', '%s %s' % (self.CLASSNAME, klass)) if title: p = etree.SubElement(div, 'p') p.text = title p.set('class', self.CLASSNAME_TITLE) else: div = sibling self.parser.parseChunk(div, block) if theRest: # This block contained unindented line(s) after the first indented # line. Insert these lines as the first block of the master blocks # list for future processing. blocks.insert(0, theRest) def get_class_and_title(self, match): klass, title = match.group(1).lower(), match.group(2) if title is None: # no title was provided, use the capitalized classname as title # e.g.: `!!! note` will render `<p class="admonition-title">Note</p>` title = klass.capitalize() elif title == '': # an explicit blank title should not be rendered # e.g.: `!!! warning ""` will *not* render `p` with a title title = None return klass, title def makeExtension(configs={}): return AdmonitionExtension(configs=configs) ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������Markdown-2.4/markdown/extensions/attr_list.py�������������������������������������������������������0000666�0000000�0000000�00000014242�12300201166�017665� 0����������������������������������������������������������������������������������������������������ustar �����������������������������������������������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������""" Attribute List Extension for Python-Markdown ============================================ Adds attribute list syntax. Inspired by [maruku](http://maruku.rubyforge.org/proposal.html#attribute_lists)'s feature of the same name. Copyright 2011 [Waylan Limberg](http://achinghead.com/). Contact: markdown@freewisdom.org License: BSD (see ../LICENSE.md for details) Dependencies: * [Python 2.4+](http://python.org) * [Markdown 2.1+](http://packages.python.org/Markdown/) """ from __future__ import absolute_import from __future__ import unicode_literals from . import Extension from ..treeprocessors import Treeprocessor from ..util import isBlockLevel import re try: Scanner = re.Scanner except AttributeError: # must be on Python 2.4 from sre import Scanner def _handle_double_quote(s, t): k, v = t.split('=') return k, v.strip('"') def _handle_single_quote(s, t): k, v = t.split('=') return k, v.strip("'") def _handle_key_value(s, t): return t.split('=') def _handle_word(s, t): if t.startswith('.'): return '.', t[1:] if t.startswith('#'): return 'id', t[1:] return t, t _scanner = Scanner([ (r'[^ ]+=".*?"', _handle_double_quote), (r"[^ ]+='.*?'", _handle_single_quote), (r'[^ ]+=[^ ]*', _handle_key_value), (r'[^ ]+', _handle_word), (r' ', None) ]) def get_attrs(str): """ Parse attribute list and return a list of attribute tuples. """ return _scanner.scan(str)[0] def isheader(elem): return elem.tag in ['h1', 'h2', 'h3', 'h4', 'h5', 'h6'] class AttrListTreeprocessor(Treeprocessor): BASE_RE = r'\{\:?([^\}]*)\}' HEADER_RE = re.compile(r'[ ]+%s[ ]*$' % BASE_RE) BLOCK_RE = re.compile(r'\n[ ]*%s[ ]*$' % BASE_RE) INLINE_RE = re.compile(r'^%s' % BASE_RE) NAME_RE = re.compile(r'[^A-Z_a-z\u00c0-\u00d6\u00d8-\u00f6\u00f8-\u02ff\u0370-\u037d' r'\u037f-\u1fff\u200c-\u200d\u2070-\u218f\u2c00-\u2fef' r'\u3001-\ud7ff\uf900-\ufdcf\ufdf0-\ufffd' r'\:\-\.0-9\u00b7\u0300-\u036f\u203f-\u2040]+') def run(self, doc): for elem in doc.getiterator(): if isBlockLevel(elem.tag): # Block level: check for attrs on last line of text RE = self.BLOCK_RE if isheader(elem) or elem.tag == 'dt': # header or def-term: check for attrs at end of line RE = self.HEADER_RE if len(elem) and elem.tag == 'li': # special case list items. children may include a ul or ol. pos = None # find the ul or ol position for i, child in enumerate(elem): if child.tag in ['ul', 'ol']: pos = i break if pos is None and elem[-1].tail: # use tail of last child. no ul or ol. m = RE.search(elem[-1].tail) if m: self.assign_attrs(elem, m.group(1)) elem[-1].tail = elem[-1].tail[:m.start()] elif pos is not None and pos > 0 and elem[pos-1].tail: # use tail of last child before ul or ol m = RE.search(elem[pos-1].tail) if m: self.assign_attrs(elem, m.group(1)) elem[pos-1].tail = elem[pos-1].tail[:m.start()] elif elem.text: # use text. ul is first child. m = RE.search(elem.text) if m: self.assign_attrs(elem, m.group(1)) elem.text = elem.text[:m.start()] elif len(elem) and elem[-1].tail: # has children. Get from tail of last child m = RE.search(elem[-1].tail) if m: self.assign_attrs(elem, m.group(1)) elem[-1].tail = elem[-1].tail[:m.start()] if isheader(elem): # clean up trailing #s elem[-1].tail = elem[-1].tail.rstrip('#').rstrip() elif elem.text: # no children. Get from text. m = RE.search(elem.text) if not m and elem.tag == 'td': m = re.search(self.BASE_RE, elem.text) if m: self.assign_attrs(elem, m.group(1)) elem.text = elem.text[:m.start()] if isheader(elem): # clean up trailing #s elem.text = elem.text.rstrip('#').rstrip() else: # inline: check for attrs at start of tail if elem.tail: m = self.INLINE_RE.match(elem.tail) if m: self.assign_attrs(elem, m.group(1)) elem.tail = elem.tail[m.end():] def assign_attrs(self, elem, attrs): """ Assign attrs to element. """ for k, v in get_attrs(attrs): if k == '.': # add to class cls = elem.get('class') if cls: elem.set('class', '%s %s' % (cls, v)) else: elem.set('class', v) else: # assign attr k with v elem.set(self.sanitize_name(k), v) def sanitize_name(self, name): """ Sanitize name as 'an XML Name, minus the ":"'. See http://www.w3.org/TR/REC-xml-names/#NT-NCName """ return self.NAME_RE.sub('_', name) class AttrListExtension(Extension): def extendMarkdown(self, md, md_globals): md.treeprocessors.add('attr_list', AttrListTreeprocessor(md), '>prettify') def makeExtension(configs={}): return AttrListExtension(configs=configs) ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������Markdown-2.4/markdown/extensions/codehilite.py������������������������������������������������������0000666�0000000�0000000�00000024010�12300201166�017763� 0����������������������������������������������������������������������������������������������������ustar �����������������������������������������������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������""" CodeHilite Extension for Python-Markdown ======================================== Adds code/syntax highlighting to standard Python-Markdown code blocks. Copyright 2006-2008 [Waylan Limberg](http://achinghead.com/). Project website: <http://packages.python.org/Markdown/extensions/code_hilite.html> Contact: markdown@freewisdom.org License: BSD (see ../LICENSE.md for details) Dependencies: * [Python 2.3+](http://python.org/) * [Markdown 2.0+](http://packages.python.org/Markdown/) * [Pygments](http://pygments.org/) """ from __future__ import absolute_import from __future__ import unicode_literals from . import Extension from ..treeprocessors import Treeprocessor import warnings try: from pygments import highlight from pygments.lexers import get_lexer_by_name, guess_lexer, TextLexer from pygments.formatters import HtmlFormatter pygments = True except ImportError: pygments = False def parse_hl_lines(expr): """Support our syntax for emphasizing certain lines of code. expr should be like '1 2' to emphasize lines 1 and 2 of a code block. Returns a list of ints, the line numbers to emphasize. """ if not expr: return [] try: return list(map(int, expr.split())) except ValueError: return [] # ------------------ The Main CodeHilite Class ---------------------- class CodeHilite(object): """ Determine language of source code, and pass it into the pygments hilighter. Basic Usage: >>> code = CodeHilite(src = 'some text') >>> html = code.hilite() * src: Source string or any object with a .readline attribute. * linenums: (Boolean) Set line numbering to 'on' (True), 'off' (False) or 'auto'(None). Set to 'auto' by default. * guess_lang: (Boolean) Turn language auto-detection 'on' or 'off' (on by default). * css_class: Set class name of wrapper div ('codehilite' by default). * hl_lines: (List of integers) Lines to emphasize, 1-indexed. Low Level Usage: >>> code = CodeHilite() >>> code.src = 'some text' # String or anything with a .readline attr. >>> code.linenos = True # True or False; Turns line numbering on or of. >>> html = code.hilite() """ def __init__(self, src=None, linenums=None, guess_lang=True, css_class="codehilite", lang=None, style='default', noclasses=False, tab_length=4, hl_lines=None): self.src = src self.lang = lang self.linenums = linenums self.guess_lang = guess_lang self.css_class = css_class self.style = style self.noclasses = noclasses self.tab_length = tab_length self.hl_lines = hl_lines or [] def hilite(self): """ Pass code to the [Pygments](http://pygments.pocoo.org/) highliter with optional line numbers. The output should then be styled with css to your liking. No styles are applied by default - only styling hooks (i.e.: <span class="k">). returns : A string of html. """ self.src = self.src.strip('\n') if self.lang is None: self._parseHeader() if pygments: try: lexer = get_lexer_by_name(self.lang) except ValueError: try: if self.guess_lang: lexer = guess_lexer(self.src) else: lexer = TextLexer() except ValueError: lexer = TextLexer() formatter = HtmlFormatter(linenos=self.linenums, cssclass=self.css_class, style=self.style, noclasses=self.noclasses, hl_lines=self.hl_lines) return highlight(self.src, lexer, formatter) else: # just escape and build markup usable by JS highlighting libs txt = self.src.replace('&', '&') txt = txt.replace('<', '<') txt = txt.replace('>', '>') txt = txt.replace('"', '"') classes = [] if self.lang: classes.append('language-%s' % self.lang) if self.linenums: classes.append('linenums') class_str = '' if classes: class_str = ' class="%s"' % ' '.join(classes) return '<pre class="%s"><code%s>%s</code></pre>\n'% \ (self.css_class, class_str, txt) def _parseHeader(self): """ Determines language of a code block from shebang line and whether said line should be removed or left in place. If the sheband line contains a path (even a single /) then it is assumed to be a real shebang line and left alone. However, if no path is given (e.i.: #!python or :::python) then it is assumed to be a mock shebang for language identifitation of a code fragment and removed from the code block prior to processing for code highlighting. When a mock shebang (e.i: #!python) is found, line numbering is turned on. When colons are found in place of a shebang (e.i.: :::python), line numbering is left in the current state - off by default. Also parses optional list of highlight lines, like: :::python hl_lines="1 3" """ import re #split text into lines lines = self.src.split("\n") #pull first line to examine fl = lines.pop(0) c = re.compile(r''' (?:(?:^::+)|(?P<shebang>^[#]!)) # Shebang or 2 or more colons (?P<path>(?:/\w+)*[/ ])? # Zero or 1 path (?P<lang>[\w+-]*) # The language \s* # Arbitrary whitespace # Optional highlight lines, single- or double-quote-delimited (hl_lines=(?P<quot>"|')(?P<hl_lines>.*?)(?P=quot))? ''', re.VERBOSE) # search first line for shebang m = c.search(fl) if m: # we have a match try: self.lang = m.group('lang').lower() except IndexError: self.lang = None if m.group('path'): # path exists - restore first line lines.insert(0, fl) if self.linenums is None and m.group('shebang'): # Overridable and Shebang exists - use line numbers self.linenums = True self.hl_lines = parse_hl_lines(m.group('hl_lines')) else: # No match lines.insert(0, fl) self.src = "\n".join(lines).strip("\n") # ------------------ The Markdown Extension ------------------------------- class HiliteTreeprocessor(Treeprocessor): """ Hilight source code in code blocks. """ def run(self, root): """ Find code blocks and store in htmlStash. """ blocks = root.getiterator('pre') for block in blocks: children = block.getchildren() if len(children) == 1 and children[0].tag == 'code': code = CodeHilite(children[0].text, linenums=self.config['linenums'], guess_lang=self.config['guess_lang'], css_class=self.config['css_class'], style=self.config['pygments_style'], noclasses=self.config['noclasses'], tab_length=self.markdown.tab_length) placeholder = self.markdown.htmlStash.store(code.hilite(), safe=True) # Clear codeblock in etree instance block.clear() # Change to p element which will later # be removed when inserting raw html block.tag = 'p' block.text = placeholder class CodeHiliteExtension(Extension): """ Add source code hilighting to markdown codeblocks. """ def __init__(self, configs): # define default configs self.config = { 'linenums': [None, "Use lines numbers. True=yes, False=no, None=auto"], 'force_linenos' : [False, "Depreciated! Use 'linenums' instead. Force line numbers - Default: False"], 'guess_lang' : [True, "Automatic language detection - Default: True"], 'css_class' : ["codehilite", "Set class name for wrapper <div> - Default: codehilite"], 'pygments_style' : ['default', 'Pygments HTML Formatter Style (Colorscheme) - Default: default'], 'noclasses': [False, 'Use inline styles instead of CSS classes - Default false'] } # Override defaults with user settings for key, value in configs: # convert strings to booleans if value == 'True': value = True if value == 'False': value = False if value == 'None': value = None if key == 'force_linenos': warnings.warn('The "force_linenos" config setting' ' to the CodeHilite extension is deprecrecated.' ' Use "linenums" instead.', DeprecationWarning) if value: # Carry 'force_linenos' over to new 'linenos'. self.setConfig('linenums', True) self.setConfig(key, value) def extendMarkdown(self, md, md_globals): """ Add HilitePostprocessor to Markdown instance. """ hiliter = HiliteTreeprocessor(md) hiliter.config = self.getConfigs() md.treeprocessors.add("hilite", hiliter, "<inline") md.registerExtension(self) def makeExtension(configs={}): return CodeHiliteExtension(configs=configs) ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������Markdown-2.4/markdown/extensions/def_list.py��������������������������������������������������������0000666�0000000�0000000�00000007367�12261107556�017501� 0����������������������������������������������������������������������������������������������������ustar �����������������������������������������������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������""" Definition List Extension for Python-Markdown ============================================= Added parsing of Definition Lists to Python-Markdown. A simple example: Apple : Pomaceous fruit of plants of the genus Malus in the family Rosaceae. : An american computer company. Orange : The fruit of an evergreen tree of the genus Citrus. Copyright 2008 - [Waylan Limberg](http://achinghead.com) """ from __future__ import absolute_import from __future__ import unicode_literals from . import Extension from ..blockprocessors import BlockProcessor, ListIndentProcessor from ..util import etree import re class DefListProcessor(BlockProcessor): """ Process Definition Lists. """ RE = re.compile(r'(^|\n)[ ]{0,3}:[ ]{1,3}(.*?)(\n|$)') NO_INDENT_RE = re.compile(r'^[ ]{0,3}[^ :]') def test(self, parent, block): return bool(self.RE.search(block)) def run(self, parent, blocks): raw_block = blocks.pop(0) m = self.RE.search(raw_block) terms = [l.strip() for l in raw_block[:m.start()].split('\n') if l.strip()] block = raw_block[m.end():] no_indent = self.NO_INDENT_RE.match(block) if no_indent: d, theRest = (block, None) else: d, theRest = self.detab(block) if d: d = '%s\n%s' % (m.group(2), d) else: d = m.group(2) sibling = self.lastChild(parent) if not terms and sibling is None: # This is not a definition item. Most likely a paragraph that # starts with a colon at the begining of a document or list. blocks.insert(0, raw_block) return False if not terms and sibling.tag == 'p': # The previous paragraph contains the terms state = 'looselist' terms = sibling.text.split('\n') parent.remove(sibling) # Aquire new sibling sibling = self.lastChild(parent) else: state = 'list' if sibling and sibling.tag == 'dl': # This is another item on an existing list dl = sibling if not terms and len(dl) and dl[-1].tag == 'dd' and len(dl[-1]): state = 'looselist' else: # This is a new list dl = etree.SubElement(parent, 'dl') # Add terms for term in terms: dt = etree.SubElement(dl, 'dt') dt.text = term # Add definition self.parser.state.set(state) dd = etree.SubElement(dl, 'dd') self.parser.parseBlocks(dd, [d]) self.parser.state.reset() if theRest: blocks.insert(0, theRest) class DefListIndentProcessor(ListIndentProcessor): """ Process indented children of definition list items. """ ITEM_TYPES = ['dd'] LIST_TYPES = ['dl'] def create_item(self, parent, block): """ Create a new dd and parse the block with it as the parent. """ dd = etree.SubElement(parent, 'dd') self.parser.parseBlocks(dd, [block]) class DefListExtension(Extension): """ Add definition lists to Markdown. """ def extendMarkdown(self, md, md_globals): """ Add an instance of DefListProcessor to BlockParser. """ md.parser.blockprocessors.add('defindent', DefListIndentProcessor(md.parser), '>indent') md.parser.blockprocessors.add('deflist', DefListProcessor(md.parser), '>ulist') def makeExtension(configs={}): return DefListExtension(configs=configs) �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������Markdown-2.4/markdown/extensions/extra.py�����������������������������������������������������������0000666�0000000�0000000�00000013151�12261107556�017017� 0����������������������������������������������������������������������������������������������������ustar �����������������������������������������������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������""" Python-Markdown Extra Extension =============================== A compilation of various Python-Markdown extensions that imitates [PHP Markdown Extra](http://michelf.com/projects/php-markdown/extra/). Note that each of the individual extensions still need to be available on your PYTHONPATH. This extension simply wraps them all up as a convenience so that only one extension needs to be listed when initiating Markdown. See the documentation for each individual extension for specifics about that extension. In the event that one or more of the supported extensions are not available for import, Markdown will issue a warning and simply continue without that extension. There may be additional extensions that are distributed with Python-Markdown that are not included here in Extra. Those extensions are not part of PHP Markdown Extra, and therefore, not part of Python-Markdown Extra. If you really would like Extra to include additional extensions, we suggest creating your own clone of Extra under a differant name. You could also edit the `extensions` global variable defined below, but be aware that such changes may be lost when you upgrade to any future version of Python-Markdown. """ from __future__ import absolute_import from __future__ import unicode_literals from . import Extension from ..blockprocessors import BlockProcessor from .. import util import re extensions = ['smart_strong', 'fenced_code', 'footnotes', 'attr_list', 'def_list', 'tables', 'abbr', ] class ExtraExtension(Extension): """ Add various extensions to Markdown class.""" def extendMarkdown(self, md, md_globals): """ Register extension instances. """ md.registerExtensions(extensions, self.config) if not md.safeMode: # Turn on processing of markdown text within raw html md.preprocessors['html_block'].markdown_in_raw = True md.parser.blockprocessors.add('markdown_block', MarkdownInHtmlProcessor(md.parser), '_begin') md.parser.blockprocessors.tag_counter = -1 md.parser.blockprocessors.contain_span_tags = re.compile( r'^(p|h[1-6]|li|dd|dt|td|th|legend|address)$', re.IGNORECASE) def makeExtension(configs={}): return ExtraExtension(configs=dict(configs)) class MarkdownInHtmlProcessor(BlockProcessor): """Process Markdown Inside HTML Blocks.""" def test(self, parent, block): return block == util.TAG_PLACEHOLDER % \ str(self.parser.blockprocessors.tag_counter + 1) def _process_nests(self, element, block): """Process the element's child elements in self.run.""" # Build list of indexes of each nest within the parent element. nest_index = [] # a list of tuples: (left index, right index) i = self.parser.blockprocessors.tag_counter + 1 is_nest = self.parser.markdown.htmlStash.tag_data[i]['left_index'] while len(self.parser.markdown.htmlStash.tag_data) > i and is_nest: left_child_index = \ self.parser.markdown.htmlStash.tag_data[i]['left_index'] right_child_index = \ self.parser.markdown.htmlStash.tag_data[i]['right_index'] nest_index.append((left_child_index - 1, right_child_index)) i += 1 # Create each nest subelement. for i, (left_index, right_index) in enumerate(nest_index[:-1]): self.run(element, block[left_index:right_index], block[right_index:nest_index[i + 1][0]], True) self.run(element, block[nest_index[-1][0]:nest_index[-1][1]], # last block[nest_index[-1][1]:], True) # nest def run(self, parent, blocks, tail=None, nest=False): self.parser.blockprocessors.tag_counter += 1 tag_data = self.parser.markdown.htmlStash.tag_data[ self.parser.blockprocessors.tag_counter] # Create Element markdown_value = tag_data['attrs'].pop('markdown') element = util.etree.SubElement(parent, tag_data['tag'], tag_data['attrs']) # Slice Off Block if nest: self.parser.parseBlocks(parent, tail) # Process Tail block = blocks[1:] else: # includes nests since a third level of nesting isn't supported block = blocks[tag_data['left_index'] + 1: tag_data['right_index']] del blocks[:tag_data['right_index']] # Process Text if (self.parser.blockprocessors.contain_span_tags.match( # Span Mode tag_data['tag']) and markdown_value != 'block') or \ markdown_value == 'span': element.text = '\n'.join(block) else: # Block Mode i = self.parser.blockprocessors.tag_counter + 1 if len(self.parser.markdown.htmlStash.tag_data) > i and self.\ parser.markdown.htmlStash.tag_data[i]['left_index']: first_subelement_index = self.parser.markdown.htmlStash.\ tag_data[i]['left_index'] - 1 self.parser.parseBlocks( element, block[:first_subelement_index]) if not nest: block = self._process_nests(element, block) else: self.parser.parseBlocks(element, block) �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������Markdown-2.4/markdown/extensions/fenced_code.py�����������������������������������������������������0000666�0000000�0000000�00000013623�12300201166�020100� 0����������������������������������������������������������������������������������������������������ustar �����������������������������������������������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������""" Fenced Code Extension for Python Markdown ========================================= This extension adds Fenced Code Blocks to Python-Markdown. >>> import markdown >>> text = ''' ... A paragraph before a fenced code block: ... ... ~~~ ... Fenced code block ... ~~~ ... ''' >>> html = markdown.markdown(text, extensions=['fenced_code']) >>> print html <p>A paragraph before a fenced code block:</p> <pre><code>Fenced code block </code></pre> Works with safe_mode also (we check this because we are using the HtmlStash): >>> print markdown.markdown(text, extensions=['fenced_code'], safe_mode='replace') <p>A paragraph before a fenced code block:</p> <pre><code>Fenced code block </code></pre> Include tilde's in a code block and wrap with blank lines: >>> text = ''' ... ~~~~~~~~ ... ... ~~~~ ... ~~~~~~~~''' >>> print markdown.markdown(text, extensions=['fenced_code']) <pre><code> ~~~~ </code></pre> Language tags: >>> text = ''' ... ~~~~{.python} ... # Some python code ... ~~~~''' >>> print markdown.markdown(text, extensions=['fenced_code']) <pre><code class="python"># Some python code </code></pre> Optionally backticks instead of tildes as per how github's code block markdown is identified: >>> text = ''' ... ````` ... # Arbitrary code ... ~~~~~ # these tildes will not close the block ... `````''' >>> print markdown.markdown(text, extensions=['fenced_code']) <pre><code># Arbitrary code ~~~~~ # these tildes will not close the block </code></pre> If the codehighlite extension and Pygments are installed, lines can be highlighted: >>> text = ''' ... ```hl_lines="1 3" ... line 1 ... line 2 ... line 3 ... ```''' >>> print markdown.markdown(text, extensions=['codehilite', 'fenced_code']) <pre><code><span class="hilight">line 1</span> line 2 <span class="hilight">line 3</span> </code></pre> Copyright 2007-2008 [Waylan Limberg](http://achinghead.com/). Project website: <http://packages.python.org/Markdown/extensions/fenced_code_blocks.html> Contact: markdown@freewisdom.org License: BSD (see ../docs/LICENSE for details) Dependencies: * [Python 2.4+](http://python.org) * [Markdown 2.0+](http://packages.python.org/Markdown/) * [Pygments (optional)](http://pygments.org) """ from __future__ import absolute_import from __future__ import unicode_literals from . import Extension from ..preprocessors import Preprocessor from .codehilite import CodeHilite, CodeHiliteExtension, parse_hl_lines import re class FencedCodeExtension(Extension): def extendMarkdown(self, md, md_globals): """ Add FencedBlockPreprocessor to the Markdown instance. """ md.registerExtension(self) md.preprocessors.add('fenced_code_block', FencedBlockPreprocessor(md), ">normalize_whitespace") class FencedBlockPreprocessor(Preprocessor): FENCED_BLOCK_RE = re.compile(r''' (?P<fence>^(?:~{3,}|`{3,}))[ ]* # Opening ``` or ~~~ (\{?\.?(?P<lang>[a-zA-Z0-9_+-]*))?[ ]* # Optional {, and lang # Optional highlight lines, single- or double-quote-delimited (hl_lines=(?P<quot>"|')(?P<hl_lines>.*?)(?P=quot))?[ ]* }?[ ]*\n # Optional closing } (?P<code>.*?)(?<=\n) (?P=fence)[ ]*$''', re.MULTILINE | re.DOTALL | re.VERBOSE) CODE_WRAP = '<pre><code%s>%s</code></pre>' LANG_TAG = ' class="%s"' def __init__(self, md): super(FencedBlockPreprocessor, self).__init__(md) self.checked_for_codehilite = False self.codehilite_conf = {} def run(self, lines): """ Match and store Fenced Code Blocks in the HtmlStash. """ # Check for code hilite extension if not self.checked_for_codehilite: for ext in self.markdown.registeredExtensions: if isinstance(ext, CodeHiliteExtension): self.codehilite_conf = ext.config break self.checked_for_codehilite = True text = "\n".join(lines) while 1: m = self.FENCED_BLOCK_RE.search(text) if m: lang = '' if m.group('lang'): lang = self.LANG_TAG % m.group('lang') # If config is not empty, then the codehighlite extension # is enabled, so we call it to highlight the code if self.codehilite_conf: highliter = CodeHilite(m.group('code'), linenums=self.codehilite_conf['linenums'][0], guess_lang=self.codehilite_conf['guess_lang'][0], css_class=self.codehilite_conf['css_class'][0], style=self.codehilite_conf['pygments_style'][0], lang=(m.group('lang') or None), noclasses=self.codehilite_conf['noclasses'][0], hl_lines=parse_hl_lines(m.group('hl_lines'))) code = highliter.hilite() else: code = self.CODE_WRAP % (lang, self._escape(m.group('code'))) placeholder = self.markdown.htmlStash.store(code, safe=True) text = '%s\n%s\n%s'% (text[:m.start()], placeholder, text[m.end():]) else: break return text.split("\n") def _escape(self, txt): """ basic html escaping """ txt = txt.replace('&', '&') txt = txt.replace('<', '<') txt = txt.replace('>', '>') txt = txt.replace('"', '"') return txt def makeExtension(configs=None): return FencedCodeExtension(configs=configs) �������������������������������������������������������������������������������������������������������������Markdown-2.4/markdown/extensions/footnotes.py�������������������������������������������������������0000666�0000000�0000000�00000026410�12261107556�017716� 0����������������������������������������������������������������������������������������������������ustar �����������������������������������������������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������""" ========================= FOOTNOTES ================================= This section adds footnote handling to markdown. It can be used as an example for extending python-markdown with relatively complex functionality. While in this case the extension is included inside the module itself, it could just as easily be added from outside the module. Not that all markdown classes above are ignorant about footnotes. All footnote functionality is provided separately and then added to the markdown instance at the run time. Footnote functionality is attached by calling extendMarkdown() method of FootnoteExtension. The method also registers the extension to allow it's state to be reset by a call to reset() method. Example: Footnotes[^1] have a label[^label] and a definition[^!DEF]. [^1]: This is a footnote [^label]: A footnote on "label" [^!DEF]: The footnote for definition """ from __future__ import absolute_import from __future__ import unicode_literals from . import Extension from ..preprocessors import Preprocessor from ..inlinepatterns import Pattern from ..treeprocessors import Treeprocessor from ..postprocessors import Postprocessor from ..util import etree, text_type from ..odict import OrderedDict import re FN_BACKLINK_TEXT = "zz1337820767766393qq" NBSP_PLACEHOLDER = "qq3936677670287331zz" DEF_RE = re.compile(r'[ ]{0,3}\[\^([^\]]*)\]:\s*(.*)') TABBED_RE = re.compile(r'((\t)|( ))(.*)') class FootnoteExtension(Extension): """ Footnote Extension. """ def __init__ (self, configs): """ Setup configs. """ self.config = {'PLACE_MARKER': ["///Footnotes Go Here///", "The text string that marks where the footnotes go"], 'UNIQUE_IDS': [False, "Avoid name collisions across " "multiple calls to reset()."], "BACKLINK_TEXT": ["↩", "The text string that links from the footnote to the reader's place."] } for key, value in configs: self.config[key][0] = value # In multiple invocations, emit links that don't get tangled. self.unique_prefix = 0 self.reset() def extendMarkdown(self, md, md_globals): """ Add pieces to Markdown. """ md.registerExtension(self) self.parser = md.parser self.md = md # Insert a preprocessor before ReferencePreprocessor md.preprocessors.add("footnote", FootnotePreprocessor(self), "<reference") # Insert an inline pattern before ImageReferencePattern FOOTNOTE_RE = r'\[\^([^\]]*)\]' # blah blah [^1] blah md.inlinePatterns.add("footnote", FootnotePattern(FOOTNOTE_RE, self), "<reference") # Insert a tree-processor that would actually add the footnote div # This must be before all other treeprocessors (i.e., inline and # codehilite) so they can run on the the contents of the div. md.treeprocessors.add("footnote", FootnoteTreeprocessor(self), "_begin") # Insert a postprocessor after amp_substitute oricessor md.postprocessors.add("footnote", FootnotePostprocessor(self), ">amp_substitute") def reset(self): """ Clear the footnotes on reset, and prepare for a distinct document. """ self.footnotes = OrderedDict() self.unique_prefix += 1 def findFootnotesPlaceholder(self, root): """ Return ElementTree Element that contains Footnote placeholder. """ def finder(element): for child in element: if child.text: if child.text.find(self.getConfig("PLACE_MARKER")) > -1: return child, element, True if child.tail: if child.tail.find(self.getConfig("PLACE_MARKER")) > -1: return child, element, False finder(child) return None res = finder(root) return res def setFootnote(self, id, text): """ Store a footnote for later retrieval. """ self.footnotes[id] = text def get_separator(self): if self.md.output_format in ['html5', 'xhtml5']: return '-' return ':' def makeFootnoteId(self, id): """ Return footnote link id. """ if self.getConfig("UNIQUE_IDS"): return 'fn%s%d-%s' % (self.get_separator(), self.unique_prefix, id) else: return 'fn%s%s' % (self.get_separator(), id) def makeFootnoteRefId(self, id): """ Return footnote back-link id. """ if self.getConfig("UNIQUE_IDS"): return 'fnref%s%d-%s' % (self.get_separator(), self.unique_prefix, id) else: return 'fnref%s%s' % (self.get_separator(), id) def makeFootnotesDiv(self, root): """ Return div of footnotes as et Element. """ if not list(self.footnotes.keys()): return None div = etree.Element("div") div.set('class', 'footnote') etree.SubElement(div, "hr") ol = etree.SubElement(div, "ol") for id in self.footnotes.keys(): li = etree.SubElement(ol, "li") li.set("id", self.makeFootnoteId(id)) self.parser.parseChunk(li, self.footnotes[id]) backlink = etree.Element("a") backlink.set("href", "#" + self.makeFootnoteRefId(id)) if self.md.output_format not in ['html5', 'xhtml5']: backlink.set("rev", "footnote") # Invalid in HTML5 backlink.set("class", "footnote-backref") backlink.set("title", "Jump back to footnote %d in the text" % \ (self.footnotes.index(id)+1)) backlink.text = FN_BACKLINK_TEXT if li.getchildren(): node = li[-1] if node.tag == "p": node.text = node.text + NBSP_PLACEHOLDER node.append(backlink) else: p = etree.SubElement(li, "p") p.append(backlink) return div class FootnotePreprocessor(Preprocessor): """ Find all footnote references and store for later use. """ def __init__ (self, footnotes): self.footnotes = footnotes def run(self, lines): """ Loop through lines and find, set, and remove footnote definitions. Keywords: * lines: A list of lines of text Return: A list of lines of text with footnote definitions removed. """ newlines = [] i = 0 while True: m = DEF_RE.match(lines[i]) if m: fn, _i = self.detectTabbed(lines[i+1:]) fn.insert(0, m.group(2)) i += _i-1 # skip past footnote self.footnotes.setFootnote(m.group(1), "\n".join(fn)) else: newlines.append(lines[i]) if len(lines) > i+1: i += 1 else: break return newlines def detectTabbed(self, lines): """ Find indented text and remove indent before further proccesing. Keyword arguments: * lines: an array of strings Returns: a list of post processed items and the index of last line. """ items = [] blank_line = False # have we encountered a blank line yet? i = 0 # to keep track of where we are def detab(line): match = TABBED_RE.match(line) if match: return match.group(4) for line in lines: if line.strip(): # Non-blank line detabbed_line = detab(line) if detabbed_line: items.append(detabbed_line) i += 1 continue elif not blank_line and not DEF_RE.match(line): # not tabbed but still part of first par. items.append(line) i += 1 continue else: return items, i+1 else: # Blank line: _maybe_ we are done. blank_line = True i += 1 # advance # Find the next non-blank line for j in range(i, len(lines)): if lines[j].strip(): next_line = lines[j]; break else: break # There is no more text; we are done. # Check if the next non-blank line is tabbed if detab(next_line): # Yes, more work to do. items.append("") continue else: break # No, we are done. else: i += 1 return items, i class FootnotePattern(Pattern): """ InlinePattern for footnote markers in a document's body text. """ def __init__(self, pattern, footnotes): super(FootnotePattern, self).__init__(pattern) self.footnotes = footnotes def handleMatch(self, m): id = m.group(2) if id in self.footnotes.footnotes.keys(): sup = etree.Element("sup") a = etree.SubElement(sup, "a") sup.set('id', self.footnotes.makeFootnoteRefId(id)) a.set('href', '#' + self.footnotes.makeFootnoteId(id)) if self.footnotes.md.output_format not in ['html5', 'xhtml5']: a.set('rel', 'footnote') # invalid in HTML5 a.set('class', 'footnote-ref') a.text = text_type(self.footnotes.footnotes.index(id) + 1) return sup else: return None class FootnoteTreeprocessor(Treeprocessor): """ Build and append footnote div to end of document. """ def __init__ (self, footnotes): self.footnotes = footnotes def run(self, root): footnotesDiv = self.footnotes.makeFootnotesDiv(root) if footnotesDiv: result = self.footnotes.findFootnotesPlaceholder(root) if result: child, parent, isText = result ind = parent.getchildren().index(child) if isText: parent.remove(child) parent.insert(ind, footnotesDiv) else: parent.insert(ind + 1, footnotesDiv) child.tail = None else: root.append(footnotesDiv) class FootnotePostprocessor(Postprocessor): """ Replace placeholders with html entities. """ def __init__(self, footnotes): self.footnotes = footnotes def run(self, text): text = text.replace(FN_BACKLINK_TEXT, self.footnotes.getConfig("BACKLINK_TEXT")) return text.replace(NBSP_PLACEHOLDER, " ") def makeExtension(configs=[]): """ Return an instance of the FootnoteExtension """ return FootnoteExtension(configs=configs) ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������Markdown-2.4/markdown/extensions/headerid.py��������������������������������������������������������0000666�0000000�0000000�00000014542�12261107556�017446� 0����������������������������������������������������������������������������������������������������ustar �����������������������������������������������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������""" HeaderID Extension for Python-Markdown ====================================== Auto-generate id attributes for HTML headers. Basic usage: >>> import markdown >>> text = "# Some Header #" >>> md = markdown.markdown(text, ['headerid']) >>> print md <h1 id="some-header">Some Header</h1> All header IDs are unique: >>> text = ''' ... #Header ... #Header ... #Header''' >>> md = markdown.markdown(text, ['headerid']) >>> print md <h1 id="header">Header</h1> <h1 id="header_1">Header</h1> <h1 id="header_2">Header</h1> To fit within a html template's hierarchy, set the header base level: >>> text = ''' ... #Some Header ... ## Next Level''' >>> md = markdown.markdown(text, ['headerid(level=3)']) >>> print md <h3 id="some-header">Some Header</h3> <h4 id="next-level">Next Level</h4> Works with inline markup. >>> text = '#Some *Header* with [markup](http://example.com).' >>> md = markdown.markdown(text, ['headerid']) >>> print md <h1 id="some-header-with-markup">Some <em>Header</em> with <a href="http://example.com">markup</a>.</h1> Turn off auto generated IDs: >>> text = ''' ... # Some Header ... # Another Header''' >>> md = markdown.markdown(text, ['headerid(forceid=False)']) >>> print md <h1>Some Header</h1> <h1>Another Header</h1> Use with MetaData extension: >>> text = '''header_level: 2 ... header_forceid: Off ... ... # A Header''' >>> md = markdown.markdown(text, ['headerid', 'meta']) >>> print md <h2>A Header</h2> Copyright 2007-2011 [Waylan Limberg](http://achinghead.com/). Project website: <http://packages.python.org/Markdown/extensions/header_id.html> Contact: markdown@freewisdom.org License: BSD (see ../docs/LICENSE for details) Dependencies: * [Python 2.3+](http://python.org) * [Markdown 2.0+](http://packages.python.org/Markdown/) """ from __future__ import absolute_import from __future__ import unicode_literals from . import Extension from ..treeprocessors import Treeprocessor from ..util import HTML_PLACEHOLDER_RE, parseBoolValue import re import logging import unicodedata logger = logging.getLogger('MARKDOWN') IDCOUNT_RE = re.compile(r'^(.*)_([0-9]+)$') def slugify(value, separator): """ Slugify a string, to make it URL friendly. """ value = unicodedata.normalize('NFKD', value).encode('ascii', 'ignore') value = re.sub('[^\w\s-]', '', value.decode('ascii')).strip().lower() return re.sub('[%s\s]+' % separator, separator, value) def unique(id, ids): """ Ensure id is unique in set of ids. Append '_1', '_2'... if not """ while id in ids or not id: m = IDCOUNT_RE.match(id) if m: id = '%s_%d'% (m.group(1), int(m.group(2))+1) else: id = '%s_%d'% (id, 1) ids.add(id) return id def itertext(elem): """ Loop through all children and return text only. Reimplements method of same name added to ElementTree in Python 2.7 """ if elem.text: yield elem.text for e in elem: for s in itertext(e): yield s if e.tail: yield e.tail def stashedHTML2text(text, md): """ Extract raw HTML, reduce to plain text and swap with placeholder. """ def _html_sub(m): """ Substitute raw html with plain text. """ try: raw, safe = md.htmlStash.rawHtmlBlocks[int(m.group(1))] except (IndexError, TypeError): return m.group(0) if md.safeMode and not safe: return '' # Strip out tags and entities - leaveing text return re.sub(r'(<[^>]+>)|(&[\#a-zA-Z0-9]+;)', '', raw) return HTML_PLACEHOLDER_RE.sub(_html_sub, text) class HeaderIdTreeprocessor(Treeprocessor): """ Assign IDs to headers. """ IDs = set() def run(self, doc): start_level, force_id = self._get_meta() slugify = self.config['slugify'] sep = self.config['separator'] for elem in doc.getiterator(): if elem.tag in ['h1', 'h2', 'h3', 'h4', 'h5', 'h6']: if force_id: if "id" in elem.attrib: id = elem.get('id') else: id = stashedHTML2text(''.join(itertext(elem)), self.md) id = slugify(id, sep) elem.set('id', unique(id, self.IDs)) if start_level: level = int(elem.tag[-1]) + start_level if level > 6: level = 6 elem.tag = 'h%d' % level def _get_meta(self): """ Return meta data suported by this ext as a tuple """ level = int(self.config['level']) - 1 force = parseBoolValue(self.config['forceid']) if hasattr(self.md, 'Meta'): if 'header_level' in self.md.Meta: level = int(self.md.Meta['header_level'][0]) - 1 if 'header_forceid' in self.md.Meta: force = parseBoolValue(self.md.Meta['header_forceid'][0]) return level, force class HeaderIdExtension(Extension): def __init__(self, configs): # set defaults self.config = { 'level' : ['1', 'Base level for headers.'], 'forceid' : ['True', 'Force all headers to have an id.'], 'separator' : ['-', 'Word separator.'], 'slugify' : [slugify, 'Callable to generate anchors'], } for key, value in configs: self.setConfig(key, value) def extendMarkdown(self, md, md_globals): md.registerExtension(self) self.processor = HeaderIdTreeprocessor() self.processor.md = md self.processor.config = self.getConfigs() if 'attr_list' in md.treeprocessors.keys(): # insert after attr_list treeprocessor md.treeprocessors.add('headerid', self.processor, '>attr_list') else: # insert after 'prettify' treeprocessor. md.treeprocessors.add('headerid', self.processor, '>prettify') def reset(self): self.processor.IDs = set() def makeExtension(configs=None): return HeaderIdExtension(configs=configs) ��������������������������������������������������������������������������������������������������������������������������������������������������������������Markdown-2.4/markdown/extensions/meta.py������������������������������������������������������������0000666�0000000�0000000�00000005446�12261107557�016633� 0����������������������������������������������������������������������������������������������������ustar �����������������������������������������������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������""" Meta Data Extension for Python-Markdown ======================================= This extension adds Meta Data handling to markdown. Basic Usage: >>> import markdown >>> text = '''Title: A Test Doc. ... Author: Waylan Limberg ... John Doe ... Blank_Data: ... ... The body. This is paragraph one. ... ''' >>> md = markdown.Markdown(['meta']) >>> print md.convert(text) <p>The body. This is paragraph one.</p> >>> print md.Meta {u'blank_data': [u''], u'author': [u'Waylan Limberg', u'John Doe'], u'title': [u'A Test Doc.']} Make sure text without Meta Data still works (markdown < 1.6b returns a <p>). >>> text = ' Some Code - not extra lines of meta data.' >>> md = markdown.Markdown(['meta']) >>> print md.convert(text) <pre><code>Some Code - not extra lines of meta data. </code></pre> >>> md.Meta {} Copyright 2007-2008 [Waylan Limberg](http://achinghead.com). Project website: <http://packages.python.org/Markdown/meta_data.html> Contact: markdown@freewisdom.org License: BSD (see ../LICENSE.md for details) """ from __future__ import absolute_import from __future__ import unicode_literals from . import Extension from ..preprocessors import Preprocessor import re # Global Vars META_RE = re.compile(r'^[ ]{0,3}(?P<key>[A-Za-z0-9_-]+):\s*(?P<value>.*)') META_MORE_RE = re.compile(r'^[ ]{4,}(?P<value>.*)') class MetaExtension (Extension): """ Meta-Data extension for Python-Markdown. """ def extendMarkdown(self, md, md_globals): """ Add MetaPreprocessor to Markdown instance. """ md.preprocessors.add("meta", MetaPreprocessor(md), "_begin") class MetaPreprocessor(Preprocessor): """ Get Meta-Data. """ def run(self, lines): """ Parse Meta-Data and store in Markdown.Meta. """ meta = {} key = None while lines: line = lines.pop(0) if line.strip() == '': break # blank line - done m1 = META_RE.match(line) if m1: key = m1.group('key').lower().strip() value = m1.group('value').strip() try: meta[key].append(value) except KeyError: meta[key] = [value] else: m2 = META_MORE_RE.match(line) if m2 and key: # Add another line to existing key meta[key].append(m2.group('value').strip()) else: lines.insert(0, line) break # no meta data - done self.markdown.Meta = meta return lines def makeExtension(configs={}): return MetaExtension(configs=configs) ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������Markdown-2.4/markdown/extensions/nl2br.py�����������������������������������������������������������0000666�0000000�0000000�00000001612�12153773346�016720� 0����������������������������������������������������������������������������������������������������ustar �����������������������������������������������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������""" NL2BR Extension =============== A Python-Markdown extension to treat newlines as hard breaks; like GitHub-flavored Markdown does. Usage: >>> import markdown >>> print markdown.markdown('line 1\\nline 2', extensions=['nl2br']) <p>line 1<br /> line 2</p> Copyright 2011 [Brian Neal](http://deathofagremmie.com/) Dependencies: * [Python 2.4+](http://python.org) * [Markdown 2.1+](http://packages.python.org/Markdown/) """ from __future__ import absolute_import from __future__ import unicode_literals from . import Extension from ..inlinepatterns import SubstituteTagPattern BR_RE = r'\n' class Nl2BrExtension(Extension): def extendMarkdown(self, md, md_globals): br_tag = SubstituteTagPattern(BR_RE, 'br') md.inlinePatterns.add('nl', br_tag, '_end') def makeExtension(configs=None): return Nl2BrExtension(configs) ����������������������������������������������������������������������������������������������������������������������Markdown-2.4/markdown/extensions/sane_lists.py������������������������������������������������������0000666�0000000�0000000�00000002543�12153773346�020051� 0����������������������������������������������������������������������������������������������������ustar �����������������������������������������������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������""" Sane List Extension for Python-Markdown ======================================= Modify the behavior of Lists in Python-Markdown t act in a sane manor. In standard Markdown syntax, the following would constitute a single ordered list. However, with this extension, the output would include two lists, the first an ordered list and the second and unordered list. 1. ordered 2. list * unordered * list Copyright 2011 - [Waylan Limberg](http://achinghead.com) """ from __future__ import absolute_import from __future__ import unicode_literals from . import Extension from ..blockprocessors import OListProcessor, UListProcessor import re class SaneOListProcessor(OListProcessor): CHILD_RE = re.compile(r'^[ ]{0,3}((\d+\.))[ ]+(.*)') SIBLING_TAGS = ['ol'] class SaneUListProcessor(UListProcessor): CHILD_RE = re.compile(r'^[ ]{0,3}(([*+-]))[ ]+(.*)') SIBLING_TAGS = ['ul'] class SaneListExtension(Extension): """ Add sane lists to Markdown. """ def extendMarkdown(self, md, md_globals): """ Override existing Processors. """ md.parser.blockprocessors['olist'] = SaneOListProcessor(md.parser) md.parser.blockprocessors['ulist'] = SaneUListProcessor(md.parser) def makeExtension(configs={}): return SaneListExtension(configs=configs) �������������������������������������������������������������������������������������������������������������������������������������������������������������Markdown-2.4/markdown/extensions/smarty.py����������������������������������������������������������0000666�0000000�0000000�00000017616�12300201166�017207� 0����������������������������������������������������������������������������������������������������ustar �����������������������������������������������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������# -*- coding: utf-8 -*- # Smarty extension for Python-Markdown # Author: 2013, Dmitry Shachnev <mitya57@gmail.com> # SmartyPants license: # # Copyright (c) 2003 John Gruber <http://daringfireball.net/> # All rights reserved. # # Redistribution and use in source and binary forms, with or without # modification, are permitted provided that the following conditions are # met: # # * Redistributions of source code must retain the above copyright # notice, this list of conditions and the following disclaimer. # # * Redistributions in binary form must reproduce the above copyright # notice, this list of conditions and the following disclaimer in # the documentation and/or other materials provided with the # distribution. # # * Neither the name "SmartyPants" nor the names of its contributors # may be used to endorse or promote products derived from this # software without specific prior written permission. # # This software is provided by the copyright holders and contributors "as # is" and any express or implied warranties, including, but not limited # to, the implied warranties of merchantability and fitness for a # particular purpose are disclaimed. In no event shall the copyright # owner or contributors be liable for any direct, indirect, incidental, # special, exemplary, or consequential damages (including, but not # limited to, procurement of substitute goods or services; loss of use, # data, or profits; or business interruption) however caused and on any # theory of liability, whether in contract, strict liability, or tort # (including negligence or otherwise) arising in any way out of the use # of this software, even if advised of the possibility of such damage. # # # smartypants.py license: # # smartypants.py is a derivative work of SmartyPants. # Copyright (c) 2004, 2007 Chad Miller <http://web.chad.org/> # # Redistribution and use in source and binary forms, with or without # modification, are permitted provided that the following conditions are # met: # # * Redistributions of source code must retain the above copyright # notice, this list of conditions and the following disclaimer. # # * Redistributions in binary form must reproduce the above copyright # notice, this list of conditions and the following disclaimer in # the documentation and/or other materials provided with the # distribution. # # This software is provided by the copyright holders and contributors "as # is" and any express or implied warranties, including, but not limited # to, the implied warranties of merchantability and fitness for a # particular purpose are disclaimed. In no event shall the copyright # owner or contributors be liable for any direct, indirect, incidental, # special, exemplary, or consequential damages (including, but not # limited to, procurement of substitute goods or services; loss of use, # data, or profits; or business interruption) however caused and on any # theory of liability, whether in contract, strict liability, or tort # (including negligence or otherwise) arising in any way out of the use # of this software, even if advised of the possibility of such damage. from __future__ import unicode_literals from . import Extension from ..inlinepatterns import HtmlPattern from ..util import parseBoolValue # Constants for quote education. punctClass = r"""[!"#\$\%'()*+,-.\/:;<=>?\@\[\\\]\^_`{|}~]""" endOfWordClass = r"[\s.,;:!?)]" closeClass = r"[^\ \t\r\n\[\{\(\-\u0002\u0003]" openingQuotesBase = ( '(\s' # a whitespace char '| ' # or a non-breaking space entity '|--' # or dashes '|–|—' # or unicode '|&[mn]dash;' # or named dash entities '|–|—' # or decimal entities ')' ) # Special case if the very first character is a quote # followed by punctuation at a non-word-break. Close the quotes by brute force: singleQuoteStartRe = r"^'(?=%s\\B)" % punctClass doubleQuoteStartRe = r'^"(?=%s\\B)' % punctClass # Special case for double sets of quotes, e.g.: # <p>He said, "'Quoted' words in a larger quote."</p> doubleQuoteSetsRe = r""""'(?=\w)""" singleQuoteSetsRe = r"""'"(?=\w)""" # Get most opening double quotes: openingDoubleQuotesRegex = r'%s"(?=\w)' % openingQuotesBase # Double closing quotes: closingDoubleQuotesRegex = r'"(?=\s)' closingDoubleQuotesRegex2 = '(?<=%s)"' % closeClass # Get most opening single quotes: openingSingleQuotesRegex = r"%s'(?=\w)" % openingQuotesBase # Single closing quotes: closingSingleQuotesRegex = r"(?<=%s)'(?!\s|s\b|\d)" % closeClass closingSingleQuotesRegex2 = r"(?<=%s)'(\s|s\b)" % closeClass # All remaining quotes should be opening ones remainingSingleQuotesRegex = "'" remainingDoubleQuotesRegex = '"' lsquo, rsquo, ldquo, rdquo = '‘', '’', '“', '”' class SubstituteTextPattern(HtmlPattern): def __init__(self, pattern, replace, markdown_instance): """ Replaces matches with some text. """ HtmlPattern.__init__(self, pattern) self.replace = replace self.markdown = markdown_instance def handleMatch(self, m): result = '' for part in self.replace: if isinstance(part, int): result += m.group(part) else: result += self.markdown.htmlStash.store(part, safe=True) return result class SmartyExtension(Extension): def __init__(self, configs): self.config = { 'smart_quotes': [True, 'Educate quotes'], 'smart_dashes': [True, 'Educate dashes'], 'smart_ellipses': [True, 'Educate ellipses'] } for key, value in configs: self.setConfig(key, parseBoolValue(value)) def _addPatterns(self, md, patterns, serie): for ind, pattern in enumerate(patterns): pattern += (md,) pattern = SubstituteTextPattern(*pattern) after = ('>smarty-%s-%d' % (serie, ind - 1) if ind else '>entity') name = 'smarty-%s-%d' % (serie, ind) md.inlinePatterns.add(name, pattern, after) def educateDashes(self, md): emDashesPattern = SubstituteTextPattern(r'(?<!-)---(?!-)', '—', md) enDashesPattern = SubstituteTextPattern(r'(?<!-)--(?!-)', '–', md) md.inlinePatterns.add('smarty-em-dashes', emDashesPattern, '>entity') md.inlinePatterns.add('smarty-en-dashes', enDashesPattern, '>smarty-em-dashes') def educateEllipses(self, md): ellipsesPattern = SubstituteTextPattern(r'(?<!\.)\.{3}(?!\.)', '…', md) md.inlinePatterns.add('smarty-ellipses', ellipsesPattern, '>entity') def educateQuotes(self, md): patterns = ( (singleQuoteStartRe, (rsquo,)), (doubleQuoteStartRe, (rdquo,)), (doubleQuoteSetsRe, (ldquo + lsquo,)), (singleQuoteSetsRe, (lsquo + ldquo,)), (openingSingleQuotesRegex, (2, lsquo)), (closingSingleQuotesRegex, (rsquo,)), (closingSingleQuotesRegex2, (rsquo, 2)), (remainingSingleQuotesRegex, (lsquo,)), (openingDoubleQuotesRegex, (2, ldquo)), (closingDoubleQuotesRegex, (rdquo,)), (closingDoubleQuotesRegex2, (rdquo,)), (remainingDoubleQuotesRegex, (ldquo,)) ) self._addPatterns(md, patterns, 'quotes') def extendMarkdown(self, md, md_globals): configs = self.getConfigs() if configs['smart_quotes']: self.educateQuotes(md) if configs['smart_dashes']: self.educateDashes(md) if configs['smart_ellipses']: self.educateEllipses(md) md.ESCAPED_CHARS.extend(['"', "'"]) def makeExtension(configs=None): return SmartyExtension(configs) ������������������������������������������������������������������������������������������������������������������Markdown-2.4/markdown/extensions/smart_strong.py����������������������������������������������������0000666�0000000�0000000�00000002727�12153773346�020433� 0����������������������������������������������������������������������������������������������������ustar �����������������������������������������������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������''' Smart_Strong Extension for Python-Markdown ========================================== This extention adds smarter handling of double underscores within words. Simple Usage: >>> import markdown >>> print markdown.markdown('Text with double__underscore__words.', ... extensions=['smart_strong']) <p>Text with double__underscore__words.</p> >>> print markdown.markdown('__Strong__ still works.', ... extensions=['smart_strong']) <p><strong>Strong</strong> still works.</p> >>> print markdown.markdown('__this__works__too__.', ... extensions=['smart_strong']) <p><strong>this__works__too</strong>.</p> Copyright 2011 [Waylan Limberg](http://achinghead.com) ''' from __future__ import absolute_import from __future__ import unicode_literals from . import Extension from ..inlinepatterns import SimpleTagPattern SMART_STRONG_RE = r'(?<!\w)(_{2})(?!_)(.+?)(?<!_)\2(?!\w)' STRONG_RE = r'(\*{2})(.+?)\2' class SmartEmphasisExtension(Extension): """ Add smart_emphasis extension to Markdown class.""" def extendMarkdown(self, md, md_globals): """ Modify inline patterns. """ md.inlinePatterns['strong'] = SimpleTagPattern(STRONG_RE, 'strong') md.inlinePatterns.add('strong2', SimpleTagPattern(SMART_STRONG_RE, 'strong'), '>emphasis2') def makeExtension(configs={}): return SmartEmphasisExtension(configs=dict(configs)) �����������������������������������������Markdown-2.4/markdown/extensions/tables.py����������������������������������������������������������0000666�0000000�0000000�00000006401�12153773346�017154� 0����������������������������������������������������������������������������������������������������ustar �����������������������������������������������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������""" Tables Extension for Python-Markdown ==================================== Added parsing of tables to Python-Markdown. A simple example: First Header | Second Header ------------- | ------------- Content Cell | Content Cell Content Cell | Content Cell Copyright 2009 - [Waylan Limberg](http://achinghead.com) """ from __future__ import absolute_import from __future__ import unicode_literals from . import Extension from ..blockprocessors import BlockProcessor from ..util import etree class TableProcessor(BlockProcessor): """ Process Tables. """ def test(self, parent, block): rows = block.split('\n') return (len(rows) > 2 and '|' in rows[0] and '|' in rows[1] and '-' in rows[1] and rows[1].strip()[0] in ['|', ':', '-']) def run(self, parent, blocks): """ Parse a table block and build table. """ block = blocks.pop(0).split('\n') header = block[0].strip() seperator = block[1].strip() rows = block[2:] # Get format type (bordered by pipes or not) border = False if header.startswith('|'): border = True # Get alignment of columns align = [] for c in self._split_row(seperator, border): if c.startswith(':') and c.endswith(':'): align.append('center') elif c.startswith(':'): align.append('left') elif c.endswith(':'): align.append('right') else: align.append(None) # Build table table = etree.SubElement(parent, 'table') thead = etree.SubElement(table, 'thead') self._build_row(header, thead, align, border) tbody = etree.SubElement(table, 'tbody') for row in rows: self._build_row(row.strip(), tbody, align, border) def _build_row(self, row, parent, align, border): """ Given a row of text, build table cells. """ tr = etree.SubElement(parent, 'tr') tag = 'td' if parent.tag == 'thead': tag = 'th' cells = self._split_row(row, border) # We use align here rather than cells to ensure every row # contains the same number of columns. for i, a in enumerate(align): c = etree.SubElement(tr, tag) try: c.text = cells[i].strip() except IndexError: c.text = "" if a: c.set('align', a) def _split_row(self, row, border): """ split a row of text into list of cells. """ if border: if row.startswith('|'): row = row[1:] if row.endswith('|'): row = row[:-1] return row.split('|') class TableExtension(Extension): """ Add tables to Markdown. """ def extendMarkdown(self, md, md_globals): """ Add an instance of TableProcessor to BlockParser. """ md.parser.blockprocessors.add('table', TableProcessor(md.parser), '<hashheader') def makeExtension(configs={}): return TableExtension(configs=configs) ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������Markdown-2.4/markdown/extensions/toc.py�������������������������������������������������������������0000666�0000000�0000000�00000022423�12261107557�016464� 0����������������������������������������������������������������������������������������������������ustar �����������������������������������������������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������""" Table of Contents Extension for Python-Markdown * * * (c) 2008 [Jack Miller](http://codezen.org) Dependencies: * [Markdown 2.1+](http://packages.python.org/Markdown/) """ from __future__ import absolute_import from __future__ import unicode_literals from . import Extension from ..treeprocessors import Treeprocessor from ..util import etree, parseBoolValue, AMP_SUBSTITUTE from .headerid import slugify, unique, itertext, stashedHTML2text import re def order_toc_list(toc_list): """Given an unsorted list with errors and skips, return a nested one. [{'level': 1}, {'level': 2}] => [{'level': 1, 'children': [{'level': 2, 'children': []}]}] A wrong list is also converted: [{'level': 2}, {'level': 1}] => [{'level': 2, 'children': []}, {'level': 1, 'children': []}] """ def build_correct(remaining_list, prev_elements=[{'level': 1000}]): if not remaining_list: return [], [] current = remaining_list.pop(0) if not 'children' in current.keys(): current['children'] = [] if not prev_elements: # This happens for instance with [8, 1, 1], ie. when some # header level is outside a scope. We treat it as a # top-level next_elements, children = build_correct(remaining_list, [current]) current['children'].append(children) return [current] + next_elements, [] prev_element = prev_elements.pop() children = [] next_elements = [] # Is current part of the child list or next list? if current['level'] > prev_element['level']: #print "%d is a child of %d" % (current['level'], prev_element['level']) prev_elements.append(prev_element) prev_elements.append(current) prev_element['children'].append(current) next_elements2, children2 = build_correct(remaining_list, prev_elements) children += children2 next_elements += next_elements2 else: #print "%d is ancestor of %d" % (current['level'], prev_element['level']) if not prev_elements: #print "No previous elements, so appending to the next set" next_elements.append(current) prev_elements = [current] next_elements2, children2 = build_correct(remaining_list, prev_elements) current['children'].extend(children2) else: #print "Previous elements, comparing to those first" remaining_list.insert(0, current) next_elements2, children2 = build_correct(remaining_list, prev_elements) children.extend(children2) next_elements += next_elements2 return next_elements, children ordered_list, __ = build_correct(toc_list) return ordered_list class TocTreeprocessor(Treeprocessor): # Iterator wrapper to get parent and child all at once def iterparent(self, root): for parent in root.getiterator(): for child in parent: yield parent, child def add_anchor(self, c, elem_id): #@ReservedAssignment anchor = etree.Element("a") anchor.text = c.text anchor.attrib["href"] = "#" + elem_id anchor.attrib["class"] = "toclink" c.text = "" for elem in c.getchildren(): anchor.append(elem) c.remove(elem) c.append(anchor) def add_permalink(self, c, elem_id): permalink = etree.Element("a") permalink.text = ("%spara;" % AMP_SUBSTITUTE if self.use_permalinks is True else self.use_permalinks) permalink.attrib["href"] = "#" + elem_id permalink.attrib["class"] = "headerlink" permalink.attrib["title"] = "Permanent link" c.append(permalink) def build_toc_etree(self, div, toc_list): # Add title to the div if self.config["title"]: header = etree.SubElement(div, "span") header.attrib["class"] = "toctitle" header.text = self.config["title"] def build_etree_ul(toc_list, parent): ul = etree.SubElement(parent, "ul") for item in toc_list: # List item link, to be inserted into the toc div li = etree.SubElement(ul, "li") link = etree.SubElement(li, "a") link.text = item.get('name', '') link.attrib["href"] = '#' + item.get('id', '') if item['children']: build_etree_ul(item['children'], li) return ul return build_etree_ul(toc_list, div) def run(self, doc): div = etree.Element("div") div.attrib["class"] = "toc" header_rgx = re.compile("[Hh][123456]") self.use_anchors = parseBoolValue(self.config["anchorlink"]) self.use_permalinks = parseBoolValue(self.config["permalink"], False) if self.use_permalinks is None: self.use_permalinks = self.config["permalink"] # Get a list of id attributes used_ids = set() for c in doc.getiterator(): if "id" in c.attrib: used_ids.add(c.attrib["id"]) toc_list = [] marker_found = False for (p, c) in self.iterparent(doc): text = ''.join(itertext(c)).strip() if not text: continue # To keep the output from screwing up the # validation by putting a <div> inside of a <p> # we actually replace the <p> in its entirety. # We do not allow the marker inside a header as that # would causes an enless loop of placing a new TOC # inside previously generated TOC. if c.text and c.text.strip() == self.config["marker"] and \ not header_rgx.match(c.tag) and c.tag not in ['pre', 'code']: for i in range(len(p)): if p[i] == c: p[i] = div break marker_found = True if header_rgx.match(c.tag): # Do not override pre-existing ids if not "id" in c.attrib: elem_id = stashedHTML2text(text, self.markdown) elem_id = unique(self.config["slugify"](elem_id, '-'), used_ids) c.attrib["id"] = elem_id else: elem_id = c.attrib["id"] tag_level = int(c.tag[-1]) toc_list.append({'level': tag_level, 'id': elem_id, 'name': text}) if self.use_anchors: self.add_anchor(c, elem_id) if self.use_permalinks: self.add_permalink(c, elem_id) toc_list_nested = order_toc_list(toc_list) self.build_toc_etree(div, toc_list_nested) prettify = self.markdown.treeprocessors.get('prettify') if prettify: prettify.run(div) if not marker_found: # serialize and attach to markdown instance. toc = self.markdown.serializer(div) for pp in self.markdown.postprocessors.values(): toc = pp.run(toc) self.markdown.toc = toc class TocExtension(Extension): TreeProcessorClass = TocTreeprocessor def __init__(self, configs=[]): self.config = { "marker" : ["[TOC]", "Text to find and replace with Table of Contents -" "Defaults to \"[TOC]\""], "slugify" : [slugify, "Function to generate anchors based on header text-" "Defaults to the headerid ext's slugify function."], "title" : [None, "Title to insert into TOC <div> - " "Defaults to None"], "anchorlink" : [0, "1 if header should be a self link" "Defaults to 0"], "permalink" : [0, "1 or link text if a Sphinx-style permalink should be added", "Defaults to 0"] } for key, value in configs: self.setConfig(key, value) def extendMarkdown(self, md, md_globals): tocext = self.TreeProcessorClass(md) tocext.config = self.getConfigs() # Headerid ext is set to '>prettify'. With this set to '_end', # it should always come after headerid ext (and honor ids assinged # by the header id extension) if both are used. Same goes for # attr_list extension. This must come last because we don't want # to redefine ids after toc is created. But we do want toc prettified. md.treeprocessors.add("toc", tocext, "_end") def makeExtension(configs={}): return TocExtension(configs=configs) ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������Markdown-2.4/markdown/extensions/wikilinks.py�������������������������������������������������������0000666�0000000�0000000�00000012550�12261107557�017703� 0����������������������������������������������������������������������������������������������������ustar �����������������������������������������������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������''' WikiLinks Extension for Python-Markdown ====================================== Converts [[WikiLinks]] to relative links. Requires Python-Markdown 2.0+ Basic usage: >>> import markdown >>> text = "Some text with a [[WikiLink]]." >>> html = markdown.markdown(text, ['wikilinks']) >>> print html <p>Some text with a <a class="wikilink" href="/WikiLink/">WikiLink</a>.</p> Whitespace behavior: >>> print markdown.markdown('[[ foo bar_baz ]]', ['wikilinks']) <p><a class="wikilink" href="/foo_bar_baz/">foo bar_baz</a></p> >>> print markdown.markdown('foo [[ ]] bar', ['wikilinks']) <p>foo bar</p> To define custom settings the simple way: >>> print markdown.markdown(text, ... ['wikilinks(base_url=/wiki/,end_url=.html,html_class=foo)'] ... ) <p>Some text with a <a class="foo" href="/wiki/WikiLink.html">WikiLink</a>.</p> Custom settings the complex way: >>> md = markdown.Markdown( ... extensions = ['wikilinks'], ... extension_configs = {'wikilinks': [ ... ('base_url', 'http://example.com/'), ... ('end_url', '.html'), ... ('html_class', '') ]}, ... safe_mode = True) >>> print md.convert(text) <p>Some text with a <a href="http://example.com/WikiLink.html">WikiLink</a>.</p> Use MetaData with mdx_meta.py (Note the blank html_class in MetaData): >>> text = """wiki_base_url: http://example.com/ ... wiki_end_url: .html ... wiki_html_class: ... ... Some text with a [[WikiLink]].""" >>> md = markdown.Markdown(extensions=['meta', 'wikilinks']) >>> print md.convert(text) <p>Some text with a <a href="http://example.com/WikiLink.html">WikiLink</a>.</p> MetaData should not carry over to next document: >>> print md.convert("No [[MetaData]] here.") <p>No <a class="wikilink" href="/MetaData/">MetaData</a> here.</p> Define a custom URL builder: >>> def my_url_builder(label, base, end): ... return '/bar/' >>> md = markdown.Markdown(extensions=['wikilinks'], ... extension_configs={'wikilinks' : [('build_url', my_url_builder)]}) >>> print md.convert('[[foo]]') <p><a class="wikilink" href="/bar/">foo</a></p> From the command line: python markdown.py -x wikilinks(base_url=http://example.com/,end_url=.html,html_class=foo) src.txt By [Waylan Limberg](http://achinghead.com/). License: [BSD](http://www.opensource.org/licenses/bsd-license.php) Dependencies: * [Python 2.3+](http://python.org) * [Markdown 2.0+](http://packages.python.org/Markdown/) ''' from __future__ import absolute_import from __future__ import unicode_literals from . import Extension from ..inlinepatterns import Pattern from ..util import etree import re def build_url(label, base, end): """ Build a url from the label, a base, and an end. """ clean_label = re.sub(r'([ ]+_)|(_[ ]+)|([ ]+)', '_', label) return '%s%s%s'% (base, clean_label, end) class WikiLinkExtension(Extension): def __init__(self, configs): # set extension defaults self.config = { 'base_url' : ['/', 'String to append to beginning or URL.'], 'end_url' : ['/', 'String to append to end of URL.'], 'html_class' : ['wikilink', 'CSS hook. Leave blank for none.'], 'build_url' : [build_url, 'Callable formats URL from label.'], } configs = dict(configs) or {} # Override defaults with user settings for key, value in configs.items(): self.setConfig(key, value) def extendMarkdown(self, md, md_globals): self.md = md # append to end of inline patterns WIKILINK_RE = r'\[\[([\w0-9_ -]+)\]\]' wikilinkPattern = WikiLinks(WIKILINK_RE, self.getConfigs()) wikilinkPattern.md = md md.inlinePatterns.add('wikilink', wikilinkPattern, "<not_strong") class WikiLinks(Pattern): def __init__(self, pattern, config): super(WikiLinks, self).__init__(pattern) self.config = config def handleMatch(self, m): if m.group(2).strip(): base_url, end_url, html_class = self._getMeta() label = m.group(2).strip() url = self.config['build_url'](label, base_url, end_url) a = etree.Element('a') a.text = label a.set('href', url) if html_class: a.set('class', html_class) else: a = '' return a def _getMeta(self): """ Return meta data or config data. """ base_url = self.config['base_url'] end_url = self.config['end_url'] html_class = self.config['html_class'] if hasattr(self.md, 'Meta'): if 'wiki_base_url' in self.md.Meta: base_url = self.md.Meta['wiki_base_url'][0] if 'wiki_end_url' in self.md.Meta: end_url = self.md.Meta['wiki_end_url'][0] if 'wiki_html_class' in self.md.Meta: html_class = self.md.Meta['wiki_html_class'][0] return base_url, end_url, html_class def makeExtension(configs=None) : return WikiLinkExtension(configs=configs) ��������������������������������������������������������������������������������������������������������������������������������������������������������Markdown-2.4/markdown/extensions/__init__.py��������������������������������������������������������0000666�0000000�0000000�00000003261�12153773345�017441� 0����������������������������������������������������������������������������������������������������ustar �����������������������������������������������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������""" Extensions ----------------------------------------------------------------------------- """ from __future__ import unicode_literals class Extension(object): """ Base class for extensions to subclass. """ def __init__(self, configs = {}): """Create an instance of an Extention. Keyword arguments: * configs: A dict of configuration setting used by an Extension. """ self.config = configs def getConfig(self, key, default=''): """ Return a setting for the given key or an empty string. """ if key in self.config: return self.config[key][0] else: return default def getConfigs(self): """ Return all configs settings as a dict. """ return dict([(key, self.getConfig(key)) for key in self.config.keys()]) def getConfigInfo(self): """ Return all config descriptions as a list of tuples. """ return [(key, self.config[key][1]) for key in self.config.keys()] def setConfig(self, key, value): """ Set a config setting for `key` with the given `value`. """ self.config[key][0] = value def extendMarkdown(self, md, md_globals): """ Add the various proccesors and patterns to the Markdown Instance. This method must be overriden by every extension. Keyword arguments: * md: The Markdown instance. * md_globals: Global variables in the markdown module namespace. """ raise NotImplementedError('Extension "%s.%s" must define an "extendMarkdown"' \ 'method.' % (self.__class__.__module__, self.__class__.__name__)) �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������Markdown-2.4/markdown/inlinepatterns.py�������������������������������������������������������������0000666�0000000�0000000�00000041544�12300201166�016525� 0����������������������������������������������������������������������������������������������������ustar �����������������������������������������������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������""" INLINE PATTERNS ============================================================================= Inline patterns such as *emphasis* are handled by means of auxiliary objects, one per pattern. Pattern objects must be instances of classes that extend markdown.Pattern. Each pattern object uses a single regular expression and needs support the following methods: pattern.getCompiledRegExp() # returns a regular expression pattern.handleMatch(m) # takes a match object and returns # an ElementTree element or just plain text All of python markdown's built-in patterns subclass from Pattern, but you can add additional patterns that don't. Also note that all the regular expressions used by inline must capture the whole block. For this reason, they all start with '^(.*)' and end with '(.*)!'. In case with built-in expression Pattern takes care of adding the "^(.*)" and "(.*)!". Finally, the order in which regular expressions are applied is very important - e.g. if we first replace http://.../ links with <a> tags and _then_ try to replace inline html, we would end up with a mess. So, we apply the expressions in the following order: * escape and backticks have to go before everything else, so that we can preempt any markdown patterns by escaping them. * then we handle auto-links (must be done before inline html) * then we handle inline HTML. At this point we will simply replace all inline HTML strings with a placeholder and add the actual HTML to a hash. * then inline images (must be done before links) * then bracketed links, first regular then reference-style * finally we apply strong and emphasis """ from __future__ import absolute_import from __future__ import unicode_literals from . import util from . import odict import re try: from urllib.parse import urlparse, urlunparse except ImportError: from urlparse import urlparse, urlunparse try: from html import entities except ImportError: import htmlentitydefs as entities def build_inlinepatterns(md_instance, **kwargs): """ Build the default set of inline patterns for Markdown. """ inlinePatterns = odict.OrderedDict() inlinePatterns["backtick"] = BacktickPattern(BACKTICK_RE) inlinePatterns["escape"] = EscapePattern(ESCAPE_RE, md_instance) inlinePatterns["reference"] = ReferencePattern(REFERENCE_RE, md_instance) inlinePatterns["link"] = LinkPattern(LINK_RE, md_instance) inlinePatterns["image_link"] = ImagePattern(IMAGE_LINK_RE, md_instance) inlinePatterns["image_reference"] = \ ImageReferencePattern(IMAGE_REFERENCE_RE, md_instance) inlinePatterns["short_reference"] = \ ReferencePattern(SHORT_REF_RE, md_instance) inlinePatterns["autolink"] = AutolinkPattern(AUTOLINK_RE, md_instance) inlinePatterns["automail"] = AutomailPattern(AUTOMAIL_RE, md_instance) inlinePatterns["linebreak"] = SubstituteTagPattern(LINE_BREAK_RE, 'br') if md_instance.safeMode != 'escape': inlinePatterns["html"] = HtmlPattern(HTML_RE, md_instance) inlinePatterns["entity"] = HtmlPattern(ENTITY_RE, md_instance) inlinePatterns["not_strong"] = SimpleTextPattern(NOT_STRONG_RE) inlinePatterns["strong_em"] = DoubleTagPattern(STRONG_EM_RE, 'strong,em') inlinePatterns["strong"] = SimpleTagPattern(STRONG_RE, 'strong') inlinePatterns["emphasis"] = SimpleTagPattern(EMPHASIS_RE, 'em') if md_instance.smart_emphasis: inlinePatterns["emphasis2"] = SimpleTagPattern(SMART_EMPHASIS_RE, 'em') else: inlinePatterns["emphasis2"] = SimpleTagPattern(EMPHASIS_2_RE, 'em') return inlinePatterns """ The actual regular expressions for patterns ----------------------------------------------------------------------------- """ NOBRACKET = r'[^\]\[]*' BRK = ( r'\[(' + (NOBRACKET + r'(\[')*6 + (NOBRACKET+ r'\])*')*6 + NOBRACKET + r')\]' ) NOIMG = r'(?<!\!)' BACKTICK_RE = r'(?<!\\)(`+)(.+?)(?<!`)\2(?!`)' # `e=f()` or ``e=f("`")`` ESCAPE_RE = r'\\(.)' # \< EMPHASIS_RE = r'(\*)([^\*]+)\2' # *emphasis* STRONG_RE = r'(\*{2}|_{2})(.+?)\2' # **strong** STRONG_EM_RE = r'(\*{3}|_{3})(.+?)\2' # ***strong*** SMART_EMPHASIS_RE = r'(?<!\w)(_)(?!_)(.+?)(?<!_)\2(?!\w)' # _smart_emphasis_ EMPHASIS_2_RE = r'(_)(.+?)\2' # _emphasis_ LINK_RE = NOIMG + BRK + \ r'''\(\s*(<.*?>|((?:(?:\(.*?\))|[^\(\)]))*?)\s*((['"])(.*?)\12\s*)?\)''' # [text](url) or [text](<url>) or [text](url "title") IMAGE_LINK_RE = r'\!' + BRK + r'\s*\((<.*?>|([^")]+"[^"]*"|[^\)]*))\)' # ![alttxt](http://x.com/) or ![alttxt](<http://x.com/>) REFERENCE_RE = NOIMG + BRK+ r'\s?\[([^\]]*)\]' # [Google][3] SHORT_REF_RE = NOIMG + r'\[([^\]]+)\]' # [Google] IMAGE_REFERENCE_RE = r'\!' + BRK + '\s?\[([^\]]*)\]' # ![alt text][2] NOT_STRONG_RE = r'((^| )(\*|_)( |$))' # stand-alone * or _ AUTOLINK_RE = r'<((?:[Ff]|[Hh][Tt])[Tt][Pp][Ss]?://[^>]*)>' # <http://www.123.com> AUTOMAIL_RE = r'<([^> \!]*@[^> ]*)>' # <me@example.com> HTML_RE = r'(\<([a-zA-Z/][^\>]*?|\!--.*?--)\>)' # <...> ENTITY_RE = r'(&[\#a-zA-Z0-9]*;)' # & LINE_BREAK_RE = r' \n' # two spaces at end of line def dequote(string): """Remove quotes from around a string.""" if ( ( string.startswith('"') and string.endswith('"')) or (string.startswith("'") and string.endswith("'")) ): return string[1:-1] else: return string ATTR_RE = re.compile("\{@([^\}]*)=([^\}]*)}") # {@id=123} def handleAttributes(text, parent): """Set values of an element based on attribute definitions ({@id=123}).""" def attributeCallback(match): parent.set(match.group(1), match.group(2).replace('\n', ' ')) return ATTR_RE.sub(attributeCallback, text) """ The pattern classes ----------------------------------------------------------------------------- """ class Pattern(object): """Base class that inline patterns subclass. """ def __init__(self, pattern, markdown_instance=None): """ Create an instant of an inline pattern. Keyword arguments: * pattern: A regular expression that matches a pattern """ self.pattern = pattern self.compiled_re = re.compile("^(.*?)%s(.*?)$" % pattern, re.DOTALL | re.UNICODE) # Api for Markdown to pass safe_mode into instance self.safe_mode = False if markdown_instance: self.markdown = markdown_instance def getCompiledRegExp(self): """ Return a compiled regular expression. """ return self.compiled_re def handleMatch(self, m): """Return a ElementTree element from the given match. Subclasses should override this method. Keyword arguments: * m: A re match object containing a match of the pattern. """ pass def type(self): """ Return class name, to define pattern type """ return self.__class__.__name__ def unescape(self, text): """ Return unescaped text given text with an inline placeholder. """ try: stash = self.markdown.treeprocessors['inline'].stashed_nodes except KeyError: return text def itertext(el): ' Reimplement Element.itertext for older python versions ' tag = el.tag if not isinstance(tag, util.string_type) and tag is not None: return if el.text: yield el.text for e in el: for s in itertext(e): yield s if e.tail: yield e.tail def get_stash(m): id = m.group(1) if id in stash: value = stash.get(id) if isinstance(value, util.string_type): return value else: # An etree Element - return text content only return ''.join(itertext(value)) return util.INLINE_PLACEHOLDER_RE.sub(get_stash, text) class SimpleTextPattern(Pattern): """ Return a simple text of group(2) of a Pattern. """ def handleMatch(self, m): text = m.group(2) if text == util.INLINE_PLACEHOLDER_PREFIX: return None return text class EscapePattern(Pattern): """ Return an escaped character. """ def handleMatch(self, m): char = m.group(2) if char in self.markdown.ESCAPED_CHARS: return '%s%s%s' % (util.STX, ord(char), util.ETX) else: return None class SimpleTagPattern(Pattern): """ Return element of type `tag` with a text attribute of group(3) of a Pattern. """ def __init__ (self, pattern, tag): Pattern.__init__(self, pattern) self.tag = tag def handleMatch(self, m): el = util.etree.Element(self.tag) el.text = m.group(3) return el class SubstituteTagPattern(SimpleTagPattern): """ Return an element of type `tag` with no children. """ def handleMatch (self, m): return util.etree.Element(self.tag) class BacktickPattern(Pattern): """ Return a `<code>` element containing the matching text. """ def __init__ (self, pattern): Pattern.__init__(self, pattern) self.tag = "code" def handleMatch(self, m): el = util.etree.Element(self.tag) el.text = util.AtomicString(m.group(3).strip()) return el class DoubleTagPattern(SimpleTagPattern): """Return a ElementTree element nested in tag2 nested in tag1. Useful for strong emphasis etc. """ def handleMatch(self, m): tag1, tag2 = self.tag.split(",") el1 = util.etree.Element(tag1) el2 = util.etree.SubElement(el1, tag2) el2.text = m.group(3) return el1 class HtmlPattern(Pattern): """ Store raw inline html and return a placeholder. """ def handleMatch (self, m): rawhtml = self.unescape(m.group(2)) place_holder = self.markdown.htmlStash.store(rawhtml) return place_holder def unescape(self, text): """ Return unescaped text given text with an inline placeholder. """ try: stash = self.markdown.treeprocessors['inline'].stashed_nodes except KeyError: return text def get_stash(m): id = m.group(1) value = stash.get(id) if value is not None: try: return self.markdown.serializer(value) except: return '\%s' % value return util.INLINE_PLACEHOLDER_RE.sub(get_stash, text) class LinkPattern(Pattern): """ Return a link element from the given match. """ def handleMatch(self, m): el = util.etree.Element("a") el.text = m.group(2) title = m.group(13) href = m.group(9) if href: if href[0] == "<": href = href[1:-1] el.set("href", self.sanitize_url(self.unescape(href.strip()))) else: el.set("href", "") if title: title = dequote(self.unescape(title)) el.set("title", title) return el def sanitize_url(self, url): """ Sanitize a url against xss attacks in "safe_mode". Rather than specifically blacklisting `javascript:alert("XSS")` and all its aliases (see <http://ha.ckers.org/xss.html>), we whitelist known safe url formats. Most urls contain a network location, however some are known not to (i.e.: mailto links). Script urls do not contain a location. Additionally, for `javascript:...`, the scheme would be "javascript" but some aliases will appear to `urlparse()` to have no scheme. On top of that relative links (i.e.: "foo/bar.html") have no scheme. Therefore we must check "path", "parameters", "query" and "fragment" for any literal colons. We don't check "scheme" for colons because it *should* never have any and "netloc" must allow the form: `username:password@host:port`. """ if not self.markdown.safeMode: # Return immediately bipassing parsing. return url try: scheme, netloc, path, params, query, fragment = url = urlparse(url) except ValueError: # Bad url - so bad it couldn't be parsed. return '' locless_schemes = ['', 'mailto', 'news'] allowed_schemes = locless_schemes + ['http', 'https', 'ftp', 'ftps'] if scheme not in allowed_schemes: # Not a known (allowed) scheme. Not safe. return '' if netloc == '' and scheme not in locless_schemes: # This should not happen. Treat as suspect. return '' for part in url[2:]: if ":" in part: # A colon in "path", "parameters", "query" or "fragment" is suspect. return '' # Url passes all tests. Return url as-is. return urlunparse(url) class ImagePattern(LinkPattern): """ Return a img element from the given match. """ def handleMatch(self, m): el = util.etree.Element("img") src_parts = m.group(9).split() if src_parts: src = src_parts[0] if src[0] == "<" and src[-1] == ">": src = src[1:-1] el.set('src', self.sanitize_url(self.unescape(src))) else: el.set('src', "") if len(src_parts) > 1: el.set('title', dequote(self.unescape(" ".join(src_parts[1:])))) if self.markdown.enable_attributes: truealt = handleAttributes(m.group(2), el) else: truealt = m.group(2) el.set('alt', self.unescape(truealt)) return el class ReferencePattern(LinkPattern): """ Match to a stored reference and return link element. """ NEWLINE_CLEANUP_RE = re.compile(r'[ ]?\n', re.MULTILINE) def handleMatch(self, m): try: id = m.group(9).lower() except IndexError: id = None if not id: # if we got something like "[Google][]" or "[Goggle]" # we'll use "google" as the id id = m.group(2).lower() # Clean up linebreaks in id id = self.NEWLINE_CLEANUP_RE.sub(' ', id) if not id in self.markdown.references: # ignore undefined refs return None href, title = self.markdown.references[id] text = m.group(2) return self.makeTag(href, title, text) def makeTag(self, href, title, text): el = util.etree.Element('a') el.set('href', self.sanitize_url(href)) if title: el.set('title', title) el.text = text return el class ImageReferencePattern(ReferencePattern): """ Match to a stored reference and return img element. """ def makeTag(self, href, title, text): el = util.etree.Element("img") el.set("src", self.sanitize_url(href)) if title: el.set("title", title) if self.markdown.enable_attributes: text = handleAttributes(text, el) el.set("alt", self.unescape(text)) return el class AutolinkPattern(Pattern): """ Return a link Element given an autolink (`<http://example/com>`). """ def handleMatch(self, m): el = util.etree.Element("a") el.set('href', self.unescape(m.group(2))) el.text = util.AtomicString(m.group(2)) return el class AutomailPattern(Pattern): """ Return a mailto link Element given an automail link (`<foo@example.com>`). """ def handleMatch(self, m): el = util.etree.Element('a') email = self.unescape(m.group(2)) if email.startswith("mailto:"): email = email[len("mailto:"):] def codepoint2name(code): """Return entity definition by code, or the code if not defined.""" entity = entities.codepoint2name.get(code) if entity: return "%s%s;" % (util.AMP_SUBSTITUTE, entity) else: return "%s#%d;" % (util.AMP_SUBSTITUTE, code) letters = [codepoint2name(ord(letter)) for letter in email] el.text = util.AtomicString(''.join(letters)) mailto = "mailto:" + email mailto = "".join([util.AMP_SUBSTITUTE + '#%d;' % ord(letter) for letter in mailto]) el.set('href', mailto) return el ������������������������������������������������������������������������������������������������������������������������������������������������������������Markdown-2.4/markdown/odict.py����������������������������������������������������������������������0000666�0000000�0000000�00000014037�12153773346�014611� 0����������������������������������������������������������������������������������������������������ustar �����������������������������������������������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������from __future__ import unicode_literals from __future__ import absolute_import from . import util from copy import deepcopy class OrderedDict(dict): """ A dictionary that keeps its keys in the order in which they're inserted. Copied from Django's SortedDict with some modifications. """ def __new__(cls, *args, **kwargs): instance = super(OrderedDict, cls).__new__(cls, *args, **kwargs) instance.keyOrder = [] return instance def __init__(self, data=None): if data is None or isinstance(data, dict): data = data or [] super(OrderedDict, self).__init__(data) self.keyOrder = list(data) if data else [] else: super(OrderedDict, self).__init__() super_set = super(OrderedDict, self).__setitem__ for key, value in data: # Take the ordering from first key if key not in self: self.keyOrder.append(key) # But override with last value in data (dict() does this) super_set(key, value) def __deepcopy__(self, memo): return self.__class__([(key, deepcopy(value, memo)) for key, value in self.items()]) def __copy__(self): # The Python's default copy implementation will alter the state # of self. The reason for this seems complex but is likely related to # subclassing dict. return self.copy() def __setitem__(self, key, value): if key not in self: self.keyOrder.append(key) super(OrderedDict, self).__setitem__(key, value) def __delitem__(self, key): super(OrderedDict, self).__delitem__(key) self.keyOrder.remove(key) def __iter__(self): return iter(self.keyOrder) def __reversed__(self): return reversed(self.keyOrder) def pop(self, k, *args): result = super(OrderedDict, self).pop(k, *args) try: self.keyOrder.remove(k) except ValueError: # Key wasn't in the dictionary in the first place. No problem. pass return result def popitem(self): result = super(OrderedDict, self).popitem() self.keyOrder.remove(result[0]) return result def _iteritems(self): for key in self.keyOrder: yield key, self[key] def _iterkeys(self): for key in self.keyOrder: yield key def _itervalues(self): for key in self.keyOrder: yield self[key] if util.PY3: items = _iteritems keys = _iterkeys values = _itervalues else: iteritems = _iteritems iterkeys = _iterkeys itervalues = _itervalues def items(self): return [(k, self[k]) for k in self.keyOrder] def keys(self): return self.keyOrder[:] def values(self): return [self[k] for k in self.keyOrder] def update(self, dict_): for k in dict_: self[k] = dict_[k] def setdefault(self, key, default): if key not in self: self.keyOrder.append(key) return super(OrderedDict, self).setdefault(key, default) def value_for_index(self, index): """Returns the value of the item at the given zero-based index.""" return self[self.keyOrder[index]] def insert(self, index, key, value): """Inserts the key, value pair before the item with the given index.""" if key in self.keyOrder: n = self.keyOrder.index(key) del self.keyOrder[n] if n < index: index -= 1 self.keyOrder.insert(index, key) super(OrderedDict, self).__setitem__(key, value) def copy(self): """Returns a copy of this object.""" # This way of initializing the copy means it works for subclasses, too. return self.__class__(self) def __repr__(self): """ Replaces the normal dict.__repr__ with a version that returns the keys in their Ordered order. """ return '{%s}' % ', '.join(['%r: %r' % (k, v) for k, v in self._iteritems()]) def clear(self): super(OrderedDict, self).clear() self.keyOrder = [] def index(self, key): """ Return the index of a given key. """ try: return self.keyOrder.index(key) except ValueError: raise ValueError("Element '%s' was not found in OrderedDict" % key) def index_for_location(self, location): """ Return index or None for a given location. """ if location == '_begin': i = 0 elif location == '_end': i = None elif location.startswith('<') or location.startswith('>'): i = self.index(location[1:]) if location.startswith('>'): if i >= len(self): # last item i = None else: i += 1 else: raise ValueError('Not a valid location: "%s". Location key ' 'must start with a ">" or "<".' % location) return i def add(self, key, value, location): """ Insert by key location. """ i = self.index_for_location(location) if i is not None: self.insert(i, key, value) else: self.__setitem__(key, value) def link(self, key, location): """ Change location of an existing item. """ n = self.keyOrder.index(key) del self.keyOrder[n] try: i = self.index_for_location(location) if i is not None: self.keyOrder.insert(i, key) else: self.keyOrder.append(key) except Exception as e: # restore to prevent data loss and reraise self.keyOrder.insert(n, key) raise e �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������Markdown-2.4/markdown/postprocessors.py�������������������������������������������������������������0000666�0000000�0000000�00000006634�12153773346�016623� 0����������������������������������������������������������������������������������������������������ustar �����������������������������������������������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������""" POST-PROCESSORS ============================================================================= Markdown also allows post-processors, which are similar to preprocessors in that they need to implement a "run" method. However, they are run after core processing. """ from __future__ import absolute_import from __future__ import unicode_literals from . import util from . import odict import re def build_postprocessors(md_instance, **kwargs): """ Build the default postprocessors for Markdown. """ postprocessors = odict.OrderedDict() postprocessors["raw_html"] = RawHtmlPostprocessor(md_instance) postprocessors["amp_substitute"] = AndSubstitutePostprocessor() postprocessors["unescape"] = UnescapePostprocessor() return postprocessors class Postprocessor(util.Processor): """ Postprocessors are run after the ElementTree it converted back into text. Each Postprocessor implements a "run" method that takes a pointer to a text string, modifies it as necessary and returns a text string. Postprocessors must extend markdown.Postprocessor. """ def run(self, text): """ Subclasses of Postprocessor should implement a `run` method, which takes the html document as a single text string and returns a (possibly modified) string. """ pass class RawHtmlPostprocessor(Postprocessor): """ Restore raw html to the document. """ def run(self, text): """ Iterate over html stash and restore "safe" html. """ for i in range(self.markdown.htmlStash.html_counter): html, safe = self.markdown.htmlStash.rawHtmlBlocks[i] if self.markdown.safeMode and not safe: if str(self.markdown.safeMode).lower() == 'escape': html = self.escape(html) elif str(self.markdown.safeMode).lower() == 'remove': html = '' else: html = self.markdown.html_replacement_text if self.isblocklevel(html) and (safe or not self.markdown.safeMode): text = text.replace("<p>%s</p>" % (self.markdown.htmlStash.get_placeholder(i)), html + "\n") text = text.replace(self.markdown.htmlStash.get_placeholder(i), html) return text def escape(self, html): """ Basic html escaping """ html = html.replace('&', '&') html = html.replace('<', '<') html = html.replace('>', '>') return html.replace('"', '"') def isblocklevel(self, html): m = re.match(r'^\<\/?([^ >]+)', html) if m: if m.group(1)[0] in ('!', '?', '@', '%'): # Comment, php etc... return True return util.isBlockLevel(m.group(1)) return False class AndSubstitutePostprocessor(Postprocessor): """ Restore valid entities """ def run(self, text): text = text.replace(util.AMP_SUBSTITUTE, "&") return text class UnescapePostprocessor(Postprocessor): """ Restore escaped chars """ RE = re.compile('%s(\d+)%s' % (util.STX, util.ETX)) def unescape(self, m): return util.int2str(int(m.group(1))) def run(self, text): return self.RE.sub(self.unescape, text) ����������������������������������������������������������������������������������������������������Markdown-2.4/markdown/preprocessors.py��������������������������������������������������������������0000666�0000000�0000000�00000034137�12300201166�016377� 0����������������������������������������������������������������������������������������������������ustar �����������������������������������������������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������""" PRE-PROCESSORS ============================================================================= Preprocessors work on source text before we start doing anything too complicated. """ from __future__ import absolute_import from __future__ import unicode_literals from . import util from . import odict import re def build_preprocessors(md_instance, **kwargs): """ Build the default set of preprocessors used by Markdown. """ preprocessors = odict.OrderedDict() preprocessors['normalize_whitespace'] = NormalizeWhitespace(md_instance) if md_instance.safeMode != 'escape': preprocessors["html_block"] = HtmlBlockPreprocessor(md_instance) preprocessors["reference"] = ReferencePreprocessor(md_instance) return preprocessors class Preprocessor(util.Processor): """ Preprocessors are run after the text is broken into lines. Each preprocessor implements a "run" method that takes a pointer to a list of lines of the document, modifies it as necessary and returns either the same pointer or a pointer to a new list. Preprocessors must extend markdown.Preprocessor. """ def run(self, lines): """ Each subclass of Preprocessor should override the `run` method, which takes the document as a list of strings split by newlines and returns the (possibly modified) list of lines. """ pass class NormalizeWhitespace(Preprocessor): """ Normalize whitespace for consistant parsing. """ def run(self, lines): source = '\n'.join(lines) source = source.replace(util.STX, "").replace(util.ETX, "") source = source.replace("\r\n", "\n").replace("\r", "\n") + "\n\n" source = source.expandtabs(self.markdown.tab_length) source = re.sub(r'(?<=\n) +\n', '\n', source) return source.split('\n') class HtmlBlockPreprocessor(Preprocessor): """Remove html blocks from the text and store them for later retrieval.""" right_tag_patterns = ["</%s>", "%s>"] attrs_pattern = r""" \s+(?P<attr>[^>"'/= ]+)=(?P<q>['"])(?P<value>.*?)(?P=q) # attr="value" | # OR \s+(?P<attr1>[^>"'/= ]+)=(?P<value1>[^> ]+) # attr=value | # OR \s+(?P<attr2>[^>"'/= ]+) # attr """ left_tag_pattern = r'^\<(?P<tag>[^> ]+)(?P<attrs>(%s)*)\s*\/?\>?' % attrs_pattern attrs_re = re.compile(attrs_pattern, re.VERBOSE) left_tag_re = re.compile(left_tag_pattern, re.VERBOSE) markdown_in_raw = False def _get_left_tag(self, block): m = self.left_tag_re.match(block) if m: tag = m.group('tag') raw_attrs = m.group('attrs') attrs = {} if raw_attrs: for ma in self.attrs_re.finditer(raw_attrs): if ma.group('attr'): if ma.group('value'): attrs[ma.group('attr').strip()] = ma.group('value') else: attrs[ma.group('attr').strip()] = "" elif ma.group('attr1'): if ma.group('value1'): attrs[ma.group('attr1').strip()] = ma.group('value1') else: attrs[ma.group('attr1').strip()] = "" elif ma.group('attr2'): attrs[ma.group('attr2').strip()] = "" return tag, len(m.group(0)), attrs else: tag = block[1:].split(">", 1)[0].lower() return tag, len(tag)+2, {} def _recursive_tagfind(self, ltag, rtag, start_index, block): while 1: i = block.find(rtag, start_index) if i == -1: return -1 j = block.find(ltag, start_index) # if no ltag, or rtag found before another ltag, return index if (j > i or j == -1): return i + len(rtag) # another ltag found before rtag, use end of ltag as starting # point and search again j = block.find('>', j) start_index = self._recursive_tagfind(ltag, rtag, j + 1, block) if start_index == -1: # HTML potentially malformed- ltag has no corresponding # rtag return -1 def _get_right_tag(self, left_tag, left_index, block): for p in self.right_tag_patterns: tag = p % left_tag i = self._recursive_tagfind("<%s" % left_tag, tag, left_index, block) if i > 2: return tag.lstrip("<").rstrip(">"), i return block.rstrip()[-left_index:-1].lower(), len(block) def _equal_tags(self, left_tag, right_tag): if left_tag[0] in ['?', '@', '%']: # handle PHP, etc. return True if ("/" + left_tag) == right_tag: return True if (right_tag == "--" and left_tag == "--"): return True elif left_tag == right_tag[1:] \ and right_tag[0] == "/": return True else: return False def _is_oneliner(self, tag): return (tag in ['hr', 'hr/']) def _stringindex_to_listindex(self, stringindex, items): """ Same effect as concatenating the strings in items, finding the character to which stringindex refers in that string, and returning the item in which that character resides. """ items.append('dummy') i, count = 0, 0 while count <= stringindex: count += len(items[i]) i += 1 return i - 1 def _nested_markdown_in_html(self, items): """Find and process html child elements of the given element block.""" for i, item in enumerate(items): if self.left_tag_re.match(item): left_tag, left_index, attrs = \ self._get_left_tag(''.join(items[i:])) right_tag, data_index = self._get_right_tag( left_tag, left_index, ''.join(items[i:])) right_listindex = \ self._stringindex_to_listindex(data_index, items[i:]) + i if 'markdown' in attrs.keys(): items[i] = items[i][left_index:] # remove opening tag placeholder = self.markdown.htmlStash.store_tag( left_tag, attrs, i + 1, right_listindex + 1) items.insert(i, placeholder) if len(items) - right_listindex <= 1: # last nest, no tail right_listindex -= 1 items[right_listindex] = items[right_listindex][ :-len(right_tag) - 2] # remove closing tag else: # raw html if len(items) - right_listindex <= 1: # last element right_listindex -= 1 placeholder = self.markdown.htmlStash.store('\n\n'.join( items[i:right_listindex])) del items[i:right_listindex] items.insert(i, placeholder) return items def run(self, lines): text = "\n".join(lines) new_blocks = [] text = text.rsplit("\n\n") items = [] left_tag = '' right_tag = '' in_tag = False # flag while text: block = text[0] if block.startswith("\n"): block = block[1:] text = text[1:] if block.startswith("\n"): block = block[1:] if not in_tag: if block.startswith("<") and len(block.strip()) > 1: if block[1:4] == "!--": # is a comment block left_tag, left_index, attrs = "--", 2, {} else: left_tag, left_index, attrs = self._get_left_tag(block) right_tag, data_index = self._get_right_tag(left_tag, left_index, block) # keep checking conditions below and maybe just append if data_index < len(block) \ and (util.isBlockLevel(left_tag) or left_tag == '--'): text.insert(0, block[data_index:]) block = block[:data_index] if not (util.isBlockLevel(left_tag) \ or block[1] in ["!", "?", "@", "%"]): new_blocks.append(block) continue if self._is_oneliner(left_tag): new_blocks.append(block.strip()) continue if block.rstrip().endswith(">") \ and self._equal_tags(left_tag, right_tag): if self.markdown_in_raw and 'markdown' in attrs.keys(): block = block[left_index:-len(right_tag) - 2] new_blocks.append(self.markdown.htmlStash. store_tag(left_tag, attrs, 0, 2)) new_blocks.extend([block]) else: new_blocks.append( self.markdown.htmlStash.store(block.strip())) continue else: # if is block level tag and is not complete if (not self._equal_tags(left_tag, right_tag)) and \ (util.isBlockLevel(left_tag) or left_tag == "--"): items.append(block.strip()) in_tag = True else: new_blocks.append( self.markdown.htmlStash.store(block.strip())) continue else: new_blocks.append(block) else: items.append(block) right_tag, data_index = self._get_right_tag(left_tag, 0, block) if self._equal_tags(left_tag, right_tag): # if find closing tag if data_index < len(block): # we have more text after right_tag items[-1] = block[:data_index] text.insert(0, block[data_index:]) in_tag = False if self.markdown_in_raw and 'markdown' in attrs.keys(): items[0] = items[0][left_index:] items[-1] = items[-1][:-len(right_tag) - 2] if items[len(items) - 1]: # not a newline/empty string right_index = len(items) + 3 else: right_index = len(items) + 2 new_blocks.append(self.markdown.htmlStash.store_tag( left_tag, attrs, 0, right_index)) placeholderslen = len(self.markdown.htmlStash.tag_data) new_blocks.extend( self._nested_markdown_in_html(items)) nests = len(self.markdown.htmlStash.tag_data) - \ placeholderslen self.markdown.htmlStash.tag_data[-1 - nests][ 'right_index'] += nests - 2 else: new_blocks.append( self.markdown.htmlStash.store('\n\n'.join(items))) items = [] if items: if self.markdown_in_raw and 'markdown' in attrs.keys(): items[0] = items[0][left_index:] items[-1] = items[-1][:-len(right_tag) - 2] if items[len(items) - 1]: # not a newline/empty string right_index = len(items) + 3 else: right_index = len(items) + 2 new_blocks.append( self.markdown.htmlStash.store_tag( left_tag, attrs, 0, right_index)) placeholderslen = len(self.markdown.htmlStash.tag_data) new_blocks.extend(self._nested_markdown_in_html(items)) nests = len(self.markdown.htmlStash.tag_data) - placeholderslen self.markdown.htmlStash.tag_data[-1 - nests][ 'right_index'] += nests - 2 else: new_blocks.append( self.markdown.htmlStash.store('\n\n'.join(items))) new_blocks.append('\n') new_text = "\n\n".join(new_blocks) return new_text.split("\n") class ReferencePreprocessor(Preprocessor): """ Remove reference definitions from text and store for later use. """ TITLE = r'[ ]*(\"(.*)\"|\'(.*)\'|\((.*)\))[ ]*' RE = re.compile(r'^[ ]{0,3}\[([^\]]*)\]:\s*([^ ]*)[ ]*(%s)?$' % TITLE, re.DOTALL) TITLE_RE = re.compile(r'^%s$' % TITLE) def run (self, lines): new_text = []; while lines: line = lines.pop(0) m = self.RE.match(line) if m: id = m.group(1).strip().lower() link = m.group(2).lstrip('<').rstrip('>') t = m.group(5) or m.group(6) or m.group(7) if not t: # Check next line for title tm = self.TITLE_RE.match(lines[0]) if tm: lines.pop(0) t = tm.group(2) or tm.group(3) or tm.group(4) self.markdown.references[id] = (link, t) else: new_text.append(line) return new_text #+ "\n" ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������Markdown-2.4/markdown/serializers.py����������������������������������������������������������������0000666�0000000�0000000�00000023262�12261107557�016036� 0����������������������������������������������������������������������������������������������������ustar �����������������������������������������������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������# markdown/searializers.py # # Add x/html serialization to Elementree # Taken from ElementTree 1.3 preview with slight modifications # # Copyright (c) 1999-2007 by Fredrik Lundh. All rights reserved. # # fredrik@pythonware.com # http://www.pythonware.com # # -------------------------------------------------------------------- # The ElementTree toolkit is # # Copyright (c) 1999-2007 by Fredrik Lundh # # By obtaining, using, and/or copying this software and/or its # associated documentation, you agree that you have read, understood, # and will comply with the following terms and conditions: # # Permission to use, copy, modify, and distribute this software and # its associated documentation for any purpose and without fee is # hereby granted, provided that the above copyright notice appears in # all copies, and that both that copyright notice and this permission # notice appear in supporting documentation, and that the name of # Secret Labs AB or the author not be used in advertising or publicity # pertaining to distribution of the software without specific, written # prior permission. # # SECRET LABS AB AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD # TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANT- # ABILITY AND FITNESS. IN NO EVENT SHALL SECRET LABS AB OR THE AUTHOR # BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY # DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, # WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS # ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE # OF THIS SOFTWARE. # -------------------------------------------------------------------- from __future__ import absolute_import from __future__ import unicode_literals from . import util ElementTree = util.etree.ElementTree QName = util.etree.QName if hasattr(util.etree, 'test_comment'): Comment = util.etree.test_comment else: Comment = util.etree.Comment PI = util.etree.PI ProcessingInstruction = util.etree.ProcessingInstruction __all__ = ['to_html_string', 'to_xhtml_string'] HTML_EMPTY = ("area", "base", "basefont", "br", "col", "frame", "hr", "img", "input", "isindex", "link", "meta" "param") try: HTML_EMPTY = set(HTML_EMPTY) except NameError: pass _namespace_map = { # "well-known" namespace prefixes "http://www.w3.org/XML/1998/namespace": "xml", "http://www.w3.org/1999/xhtml": "html", "http://www.w3.org/1999/02/22-rdf-syntax-ns#": "rdf", "http://schemas.xmlsoap.org/wsdl/": "wsdl", # xml schema "http://www.w3.org/2001/XMLSchema": "xs", "http://www.w3.org/2001/XMLSchema-instance": "xsi", # dublic core "http://purl.org/dc/elements/1.1/": "dc", } def _raise_serialization_error(text): raise TypeError( "cannot serialize %r (type %s)" % (text, type(text).__name__) ) def _encode(text, encoding): try: return text.encode(encoding, "xmlcharrefreplace") except (TypeError, AttributeError): _raise_serialization_error(text) def _escape_cdata(text): # escape character data try: # it's worth avoiding do-nothing calls for strings that are # shorter than 500 character, or so. assume that's, by far, # the most common case in most applications. if "&" in text: text = text.replace("&", "&") if "<" in text: text = text.replace("<", "<") if ">" in text: text = text.replace(">", ">") return text except (TypeError, AttributeError): _raise_serialization_error(text) def _escape_attrib(text): # escape attribute value try: if "&" in text: text = text.replace("&", "&") if "<" in text: text = text.replace("<", "<") if ">" in text: text = text.replace(">", ">") if "\"" in text: text = text.replace("\"", """) if "\n" in text: text = text.replace("\n", " ") return text except (TypeError, AttributeError): _raise_serialization_error(text) def _escape_attrib_html(text): # escape attribute value try: if "&" in text: text = text.replace("&", "&") if "<" in text: text = text.replace("<", "<") if ">" in text: text = text.replace(">", ">") if "\"" in text: text = text.replace("\"", """) return text except (TypeError, AttributeError): _raise_serialization_error(text) def _serialize_html(write, elem, qnames, namespaces, format): tag = elem.tag text = elem.text if tag is Comment: write("<!--%s-->" % _escape_cdata(text)) elif tag is ProcessingInstruction: write("<?%s?>" % _escape_cdata(text)) else: tag = qnames[tag] if tag is None: if text: write(_escape_cdata(text)) for e in elem: _serialize_html(write, e, qnames, None, format) else: write("<" + tag) items = elem.items() if items or namespaces: items = sorted(items) # lexical order for k, v in items: if isinstance(k, QName): k = k.text if isinstance(v, QName): v = qnames[v.text] else: v = _escape_attrib_html(v) if qnames[k] == v and format == 'html': # handle boolean attributes write(" %s" % v) else: write(" %s=\"%s\"" % (qnames[k], v)) if namespaces: items = namespaces.items() items.sort(key=lambda x: x[1]) # sort on prefix for v, k in items: if k: k = ":" + k write(" xmlns%s=\"%s\"" % (k, _escape_attrib(v))) if format == "xhtml" and tag.lower() in HTML_EMPTY: write(" />") else: write(">") if text: if tag.lower() in ["script", "style"]: write(text) else: write(_escape_cdata(text)) for e in elem: _serialize_html(write, e, qnames, None, format) if tag.lower() not in HTML_EMPTY: write("</" + tag + ">") if elem.tail: write(_escape_cdata(elem.tail)) def _write_html(root, encoding=None, default_namespace=None, format="html"): assert root is not None data = [] write = data.append qnames, namespaces = _namespaces(root, default_namespace) _serialize_html(write, root, qnames, namespaces, format) if encoding is None: return "".join(data) else: return _encode("".join(data)) # -------------------------------------------------------------------- # serialization support def _namespaces(elem, default_namespace=None): # identify namespaces used in this tree # maps qnames to *encoded* prefix:local names qnames = {None: None} # maps uri:s to prefixes namespaces = {} if default_namespace: namespaces[default_namespace] = "" def add_qname(qname): # calculate serialized qname representation try: if qname[:1] == "{": uri, tag = qname[1:].split("}", 1) prefix = namespaces.get(uri) if prefix is None: prefix = _namespace_map.get(uri) if prefix is None: prefix = "ns%d" % len(namespaces) if prefix != "xml": namespaces[uri] = prefix if prefix: qnames[qname] = "%s:%s" % (prefix, tag) else: qnames[qname] = tag # default element else: if default_namespace: raise ValueError( "cannot use non-qualified names with " "default_namespace option" ) qnames[qname] = qname except TypeError: _raise_serialization_error(qname) # populate qname and namespaces table try: iterate = elem.iter except AttributeError: iterate = elem.getiterator # cET compatibility for elem in iterate(): tag = elem.tag if isinstance(tag, QName) and tag.text not in qnames: add_qname(tag.text) elif isinstance(tag, util.string_type): if tag not in qnames: add_qname(tag) elif tag is not None and tag is not Comment and tag is not PI: _raise_serialization_error(tag) for key, value in elem.items(): if isinstance(key, QName): key = key.text if key not in qnames: add_qname(key) if isinstance(value, QName) and value.text not in qnames: add_qname(value.text) text = elem.text if isinstance(text, QName) and text.text not in qnames: add_qname(text.text) return qnames, namespaces def to_html_string(element): return _write_html(ElementTree(element).getroot(), format="html") def to_xhtml_string(element): return _write_html(ElementTree(element).getroot(), format="xhtml") ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������Markdown-2.4/markdown/treeprocessors.py�������������������������������������������������������������0000666�0000000�0000000�00000031635�12300201166�016550� 0����������������������������������������������������������������������������������������������������ustar �����������������������������������������������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������from __future__ import unicode_literals from __future__ import absolute_import from . import util from . import odict from . import inlinepatterns def build_treeprocessors(md_instance, **kwargs): """ Build the default treeprocessors for Markdown. """ treeprocessors = odict.OrderedDict() treeprocessors["inline"] = InlineProcessor(md_instance) treeprocessors["prettify"] = PrettifyTreeprocessor(md_instance) return treeprocessors def isString(s): """ Check if it's string """ if not isinstance(s, util.AtomicString): return isinstance(s, util.string_type) return False class Treeprocessor(util.Processor): """ Treeprocessors are run on the ElementTree object before serialization. Each Treeprocessor implements a "run" method that takes a pointer to an ElementTree, modifies it as necessary and returns an ElementTree object. Treeprocessors must extend markdown.Treeprocessor. """ def run(self, root): """ Subclasses of Treeprocessor should implement a `run` method, which takes a root ElementTree. This method can return another ElementTree object, and the existing root ElementTree will be replaced, or it can modify the current tree and return None. """ pass class InlineProcessor(Treeprocessor): """ A Treeprocessor that traverses a tree, applying inline patterns. """ def __init__(self, md): self.__placeholder_prefix = util.INLINE_PLACEHOLDER_PREFIX self.__placeholder_suffix = util.ETX self.__placeholder_length = 4 + len(self.__placeholder_prefix) \ + len(self.__placeholder_suffix) self.__placeholder_re = util.INLINE_PLACEHOLDER_RE self.markdown = md def __makePlaceholder(self, type): """ Generate a placeholder """ id = "%04d" % len(self.stashed_nodes) hash = util.INLINE_PLACEHOLDER % id return hash, id def __findPlaceholder(self, data, index): """ Extract id from data string, start from index Keyword arguments: * data: string * index: index, from which we start search Returns: placeholder id and string index, after the found placeholder. """ m = self.__placeholder_re.search(data, index) if m: return m.group(1), m.end() else: return None, index + 1 def __stashNode(self, node, type): """ Add node to stash """ placeholder, id = self.__makePlaceholder(type) self.stashed_nodes[id] = node return placeholder def __handleInline(self, data, patternIndex=0): """ Process string with inline patterns and replace it with placeholders Keyword arguments: * data: A line of Markdown text * patternIndex: The index of the inlinePattern to start with Returns: String with placeholders. """ if not isinstance(data, util.AtomicString): startIndex = 0 while patternIndex < len(self.markdown.inlinePatterns): data, matched, startIndex = self.__applyPattern( self.markdown.inlinePatterns.value_for_index(patternIndex), data, patternIndex, startIndex) if not matched: patternIndex += 1 return data def __processElementText(self, node, subnode, isText=True): """ Process placeholders in Element.text or Element.tail of Elements popped from self.stashed_nodes. Keywords arguments: * node: parent node * subnode: processing node * isText: bool variable, True - it's text, False - it's tail Returns: None """ if isText: text = subnode.text subnode.text = None else: text = subnode.tail subnode.tail = None childResult = self.__processPlaceholders(text, subnode) if not isText and node is not subnode: pos = list(node).index(subnode) node.remove(subnode) else: pos = 0 childResult.reverse() for newChild in childResult: node.insert(pos, newChild) def __processPlaceholders(self, data, parent): """ Process string with placeholders and generate ElementTree tree. Keyword arguments: * data: string with placeholders instead of ElementTree elements. * parent: Element, which contains processing inline data Returns: list with ElementTree elements with applied inline patterns. """ def linkText(text): if text: if result: if result[-1].tail: result[-1].tail += text else: result[-1].tail = text else: if parent.text: parent.text += text else: parent.text = text result = [] strartIndex = 0 while data: index = data.find(self.__placeholder_prefix, strartIndex) if index != -1: id, phEndIndex = self.__findPlaceholder(data, index) if id in self.stashed_nodes: node = self.stashed_nodes.get(id) if index > 0: text = data[strartIndex:index] linkText(text) if not isString(node): # it's Element for child in [node] + list(node): if child.tail: if child.tail.strip(): self.__processElementText(node, child,False) if child.text: if child.text.strip(): self.__processElementText(child, child) else: # it's just a string linkText(node) strartIndex = phEndIndex continue strartIndex = phEndIndex result.append(node) else: # wrong placeholder end = index + len(self.__placeholder_prefix) linkText(data[strartIndex:end]) strartIndex = end else: text = data[strartIndex:] if isinstance(data, util.AtomicString): # We don't want to loose the AtomicString text = util.AtomicString(text) linkText(text) data = "" return result def __applyPattern(self, pattern, data, patternIndex, startIndex=0): """ Check if the line fits the pattern, create the necessary elements, add it to stashed_nodes. Keyword arguments: * data: the text to be processed * pattern: the pattern to be checked * patternIndex: index of current pattern * startIndex: string index, from which we start searching Returns: String with placeholders instead of ElementTree elements. """ match = pattern.getCompiledRegExp().match(data[startIndex:]) leftData = data[:startIndex] if not match: return data, False, 0 node = pattern.handleMatch(match) if node is None: return data, True, len(leftData)+match.span(len(match.groups()))[0] if not isString(node): if not isinstance(node.text, util.AtomicString): # We need to process current node too for child in [node] + list(node): if not isString(node): if child.text: child.text = self.__handleInline(child.text, patternIndex + 1) if child.tail: child.tail = self.__handleInline(child.tail, patternIndex) placeholder = self.__stashNode(node, pattern.type()) return "%s%s%s%s" % (leftData, match.group(1), placeholder, match.groups()[-1]), True, 0 def run(self, tree): """Apply inline patterns to a parsed Markdown tree. Iterate over ElementTree, find elements with inline tag, apply inline patterns and append newly created Elements to tree. If you don't want to process your data with inline paterns, instead of normal string, use subclass AtomicString: node.text = markdown.AtomicString("This will not be processed.") Arguments: * tree: ElementTree object, representing Markdown tree. Returns: ElementTree object with applied inline patterns. """ self.stashed_nodes = {} stack = [tree] while stack: currElement = stack.pop() insertQueue = [] for child in currElement: if child.text and not isinstance(child.text, util.AtomicString): text = child.text child.text = None lst = self.__processPlaceholders(self.__handleInline( text), child) stack += lst insertQueue.append((child, lst)) if child.tail: tail = self.__handleInline(child.tail) dumby = util.etree.Element('d') tailResult = self.__processPlaceholders(tail, dumby) if dumby.text: child.tail = dumby.text else: child.tail = None pos = list(currElement).index(child) + 1 tailResult.reverse() for newChild in tailResult: currElement.insert(pos, newChild) if len(child): stack.append(child) for element, lst in insertQueue: if self.markdown.enable_attributes: if element.text and isString(element.text): element.text = \ inlinepatterns.handleAttributes(element.text, element) i = 0 for newChild in lst: if self.markdown.enable_attributes: # Processing attributes if newChild.tail and isString(newChild.tail): newChild.tail = \ inlinepatterns.handleAttributes(newChild.tail, element) if newChild.text and isString(newChild.text): newChild.text = \ inlinepatterns.handleAttributes(newChild.text, newChild) element.insert(i, newChild) i += 1 return tree class PrettifyTreeprocessor(Treeprocessor): """ Add linebreaks to the html document. """ def _prettifyETree(self, elem): """ Recursively add linebreaks to ElementTree children. """ i = "\n" if util.isBlockLevel(elem.tag) and elem.tag not in ['code', 'pre']: if (not elem.text or not elem.text.strip()) \ and len(elem) and util.isBlockLevel(elem[0].tag): elem.text = i for e in elem: if util.isBlockLevel(e.tag): self._prettifyETree(e) if not elem.tail or not elem.tail.strip(): elem.tail = i if not elem.tail or not elem.tail.strip(): elem.tail = i def run(self, root): """ Add linebreaks to ElementTree root object. """ self._prettifyETree(root) # Do <br />'s seperately as they are often in the middle of # inline content and missed by _prettifyETree. brs = root.getiterator('br') for br in brs: if not br.tail or not br.tail.strip(): br.tail = '\n' else: br.tail = '\n%s' % br.tail # Clean up extra empty lines at end of code blocks. pres = root.getiterator('pre') for pre in pres: if len(pre) and pre[0].tag == 'code': pre[0].text = pre[0].text.rstrip() + '\n' ���������������������������������������������������������������������������������������������������Markdown-2.4/markdown/util.py�����������������������������������������������������������������������0000666�0000000�0000000�00000013040�12300201166�014431� 0����������������������������������������������������������������������������������������������������ustar �����������������������������������������������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������# -*- coding: utf-8 -*- from __future__ import unicode_literals import re import sys """ Python 3 Stuff ============================================================================= """ PY3 = sys.version_info[0] == 3 if PY3: string_type = str text_type = str int2str = chr else: string_type = basestring text_type = unicode int2str = unichr """ Constants you might want to modify ----------------------------------------------------------------------------- """ BLOCK_LEVEL_ELEMENTS = re.compile("^(p|div|h[1-6]|blockquote|pre|table|dl|ol|ul" "|script|noscript|form|fieldset|iframe|math" "|hr|hr/|style|li|dt|dd|thead|tbody" "|tr|th|td|section|footer|header|group|figure" "|figcaption|aside|article|canvas|output" "|progress|video)$", re.IGNORECASE) # Placeholders STX = '\u0002' # Use STX ("Start of text") for start-of-placeholder ETX = '\u0003' # Use ETX ("End of text") for end-of-placeholder INLINE_PLACEHOLDER_PREFIX = STX+"klzzwxh:" INLINE_PLACEHOLDER = INLINE_PLACEHOLDER_PREFIX + "%s" + ETX INLINE_PLACEHOLDER_RE = re.compile(INLINE_PLACEHOLDER % r'([0-9]+)') AMP_SUBSTITUTE = STX+"amp"+ETX HTML_PLACEHOLDER = STX + "wzxhzdk:%s" + ETX HTML_PLACEHOLDER_RE = re.compile(HTML_PLACEHOLDER % r'([0-9]+)') TAG_PLACEHOLDER = STX + "hzzhzkh:%s" + ETX """ Constants you probably do not need to change ----------------------------------------------------------------------------- """ RTL_BIDI_RANGES = ( ('\u0590', '\u07FF'), # Hebrew (0590-05FF), Arabic (0600-06FF), # Syriac (0700-074F), Arabic supplement (0750-077F), # Thaana (0780-07BF), Nko (07C0-07FF). ('\u2D30', '\u2D7F'), # Tifinagh ) # Extensions should use "markdown.util.etree" instead of "etree" (or do `from # markdown.util import etree`). Do not import it by yourself. try: # Is the C implementation of ElementTree available? import xml.etree.cElementTree as etree from xml.etree.ElementTree import Comment # Serializers (including ours) test with non-c Comment etree.test_comment = Comment if etree.VERSION < "1.0.5": raise RuntimeError("cElementTree version 1.0.5 or higher is required.") except (ImportError, RuntimeError): # Use the Python implementation of ElementTree? import xml.etree.ElementTree as etree if etree.VERSION < "1.1": raise RuntimeError("ElementTree version 1.1 or higher is required") """ AUXILIARY GLOBAL FUNCTIONS ============================================================================= """ def isBlockLevel(tag): """Check if the tag is a block level HTML tag.""" if isinstance(tag, string_type): return BLOCK_LEVEL_ELEMENTS.match(tag) # Some ElementTree tags are not strings, so return False. return False def parseBoolValue(value, fail_on_errors=True): """Parses a string representing bool value. If parsing was successful, returns True or False. If parsing was not successful, raises ValueError, or, if fail_on_errors=False, returns None.""" if not isinstance(value, string_type): return bool(value) elif value.lower() in ('true', 'yes', 'y', 'on', '1'): return True elif value.lower() in ('false', 'no', 'n', 'off', '0'): return False elif fail_on_errors: raise ValueError('Cannot parse bool value: %r' % value) """ MISC AUXILIARY CLASSES ============================================================================= """ class AtomicString(text_type): """A string which should not be further processed.""" pass class Processor(object): def __init__(self, markdown_instance=None): if markdown_instance: self.markdown = markdown_instance class HtmlStash(object): """ This class is used for stashing HTML objects that we extract in the beginning and replace with place-holders. """ def __init__(self): """ Create a HtmlStash. """ self.html_counter = 0 # for counting inline html segments self.rawHtmlBlocks = [] self.tag_counter = 0 self.tag_data = [] # list of dictionaries in the order tags appear def store(self, html, safe=False): """ Saves an HTML segment for later reinsertion. Returns a placeholder string that needs to be inserted into the document. Keyword arguments: * html: an html segment * safe: label an html segment as safe for safemode Returns : a placeholder string """ self.rawHtmlBlocks.append((html, safe)) placeholder = self.get_placeholder(self.html_counter) self.html_counter += 1 return placeholder def reset(self): self.html_counter = 0 self.rawHtmlBlocks = [] def get_placeholder(self, key): return HTML_PLACEHOLDER % key def store_tag(self, tag, attrs, left_index, right_index): """Store tag data and return a placeholder.""" self.tag_data.append({'tag': tag, 'attrs': attrs, 'left_index': left_index, 'right_index': right_index}) placeholder = TAG_PLACEHOLDER % str(self.tag_counter) self.tag_counter += 1 # equal to the tag's index in self.tag_data return placeholder ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������Markdown-2.4/markdown/__init__.py�������������������������������������������������������������������0000666�0000000�0000000�00000040354�12300201166�015223� 0����������������������������������������������������������������������������������������������������ustar �����������������������������������������������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������""" Python Markdown =============== Python Markdown converts Markdown to HTML and can be used as a library or called from the command line. ## Basic usage as a module: import markdown html = markdown.markdown(your_text_string) See <http://packages.python.org/Markdown/> for more information and instructions on how to extend the functionality of Python Markdown. Read that before you try modifying this file. ## Authors and License Started by [Manfred Stienstra](http://www.dwerg.net/). Continued and maintained by [Yuri Takhteyev](http://www.freewisdom.org), [Waylan Limberg](http://achinghead.com/) and [Artem Yunusov](http://blog.splyer.com). Contact: markdown@freewisdom.org Copyright 2007-2013 The Python Markdown Project (v. 1.7 and later) Copyright 200? Django Software Foundation (OrderedDict implementation) Copyright 2004, 2005, 2006 Yuri Takhteyev (v. 0.2-1.6b) Copyright 2004 Manfred Stienstra (the original version) License: BSD (see LICENSE for details). """ from __future__ import absolute_import from __future__ import unicode_literals from .__version__ import version, version_info import codecs import sys import logging from . import util from .preprocessors import build_preprocessors from .blockprocessors import build_block_parser from .treeprocessors import build_treeprocessors from .inlinepatterns import build_inlinepatterns from .postprocessors import build_postprocessors from .extensions import Extension from .serializers import to_html_string, to_xhtml_string __all__ = ['Markdown', 'markdown', 'markdownFromFile'] logger = logging.getLogger('MARKDOWN') class Markdown(object): """Convert Markdown to HTML.""" doc_tag = "div" # Element used to wrap document - later removed option_defaults = { 'html_replacement_text' : '[HTML_REMOVED]', 'tab_length' : 4, 'enable_attributes' : True, 'smart_emphasis' : True, 'lazy_ol' : True, } output_formats = { 'html' : to_html_string, 'html4' : to_html_string, 'html5' : to_html_string, 'xhtml' : to_xhtml_string, 'xhtml1': to_xhtml_string, 'xhtml5': to_xhtml_string, } ESCAPED_CHARS = ['\\', '`', '*', '_', '{', '}', '[', ']', '(', ')', '>', '#', '+', '-', '.', '!'] def __init__(self, *args, **kwargs): """ Creates a new Markdown instance. Keyword arguments: * extensions: A list of extensions. If they are of type string, the module mdx_name.py will be loaded. If they are a subclass of markdown.Extension, they will be used as-is. * extension_configs: Configuration settingis for extensions. * output_format: Format of output. Supported formats are: * "xhtml1": Outputs XHTML 1.x. Default. * "xhtml5": Outputs XHTML style tags of HTML 5 * "xhtml": Outputs latest supported version of XHTML (currently XHTML 1.1). * "html4": Outputs HTML 4 * "html5": Outputs HTML style tags of HTML 5 * "html": Outputs latest supported version of HTML (currently HTML 4). Note that it is suggested that the more specific formats ("xhtml1" and "html4") be used as "xhtml" or "html" may change in the future if it makes sense at that time. * safe_mode: Disallow raw html. One of "remove", "replace" or "escape". * html_replacement_text: Text used when safe_mode is set to "replace". * tab_length: Length of tabs in the source. Default: 4 * enable_attributes: Enable the conversion of attributes. Default: True * smart_emphasis: Treat `_connected_words_` intelligently Default: True * lazy_ol: Ignore number of first item of ordered lists. Default: True """ # For backward compatibility, loop through old positional args pos = ['extensions', 'extension_configs', 'safe_mode', 'output_format'] c = 0 for arg in args: if pos[c] not in kwargs: kwargs[pos[c]] = arg c += 1 if c == len(pos): # ignore any additional args break # Loop through kwargs and assign defaults for option, default in self.option_defaults.items(): setattr(self, option, kwargs.get(option, default)) self.safeMode = kwargs.get('safe_mode', False) if self.safeMode and 'enable_attributes' not in kwargs: # Disable attributes in safeMode when not explicitly set self.enable_attributes = False self.registeredExtensions = [] self.docType = "" self.stripTopLevelTags = True self.build_parser() self.references = {} self.htmlStash = util.HtmlStash() self.registerExtensions(extensions=kwargs.get('extensions', []), configs=kwargs.get('extension_configs', {})) self.set_output_format(kwargs.get('output_format', 'xhtml1')) self.reset() def build_parser(self): """ Build the parser from the various parts. """ self.preprocessors = build_preprocessors(self) self.parser = build_block_parser(self) self.inlinePatterns = build_inlinepatterns(self) self.treeprocessors = build_treeprocessors(self) self.postprocessors = build_postprocessors(self) return self def registerExtensions(self, extensions, configs): """ Register extensions with this instance of Markdown. Keyword arguments: * extensions: A list of extensions, which can either be strings or objects. See the docstring on Markdown. * configs: A dictionary mapping module names to config options. """ for ext in extensions: if isinstance(ext, util.string_type): ext = self.build_extension(ext, configs.get(ext, [])) if isinstance(ext, Extension): ext.extendMarkdown(self, globals()) elif ext is not None: raise TypeError( 'Extension "%s.%s" must be of type: "markdown.Extension"' % (ext.__class__.__module__, ext.__class__.__name__)) return self def build_extension(self, ext_name, configs = []): """Build extension by name, then return the module. The extension name may contain arguments as part of the string in the following format: "extname(key1=value1,key2=value2)" """ # Parse extensions config params (ignore the order) configs = dict(configs) pos = ext_name.find("(") # find the first "(" if pos > 0: ext_args = ext_name[pos+1:-1] ext_name = ext_name[:pos] pairs = [x.split("=") for x in ext_args.split(",")] configs.update([(x.strip(), y.strip()) for (x, y) in pairs]) # Setup the module name module_name = ext_name if '.' not in ext_name: module_name = '.'.join(['markdown.extensions', ext_name]) # Try loading the extension first from one place, then another try: # New style (markdown.extensions.<extension>) module = __import__(module_name, {}, {}, [module_name.rpartition('.')[0]]) except ImportError: module_name_old_style = '_'.join(['mdx', ext_name]) try: # Old style (mdx_<extension>) module = __import__(module_name_old_style) except ImportError as e: message = "Failed loading extension '%s' from '%s' or '%s'" \ % (ext_name, module_name, module_name_old_style) e.args = (message,) + e.args[1:] raise # If the module is loaded successfully, we expect it to define a # function called makeExtension() try: return module.makeExtension(configs.items()) except AttributeError as e: message = e.args[0] message = "Failed to initiate extension " \ "'%s': %s" % (ext_name, message) e.args = (message,) + e.args[1:] raise def registerExtension(self, extension): """ This gets called by the extension """ self.registeredExtensions.append(extension) return self def reset(self): """ Resets all state variables so that we can start with a new text. """ self.htmlStash.reset() self.references.clear() for extension in self.registeredExtensions: if hasattr(extension, 'reset'): extension.reset() return self def set_output_format(self, format): """ Set the output format for the class instance. """ self.output_format = format.lower() try: self.serializer = self.output_formats[self.output_format] except KeyError as e: valid_formats = list(self.output_formats.keys()) valid_formats.sort() message = 'Invalid Output Format: "%s". Use one of %s.' \ % (self.output_format, '"' + '", "'.join(valid_formats) + '"') e.args = (message,) + e.args[1:] raise return self def convert(self, source): """ Convert markdown to serialized XHTML or HTML. Keyword arguments: * source: Source text as a Unicode string. Markdown processing takes place in five steps: 1. A bunch of "preprocessors" munge the input text. 2. BlockParser() parses the high-level structural elements of the pre-processed text into an ElementTree. 3. A bunch of "treeprocessors" are run against the ElementTree. One such treeprocessor runs InlinePatterns against the ElementTree, detecting inline markup. 4. Some post-processors are run against the text after the ElementTree has been serialized into text. 5. The output is written to a string. """ # Fixup the source text if not source.strip(): return '' # a blank unicode string try: source = util.text_type(source) except UnicodeDecodeError as e: # Customise error message while maintaining original trackback e.reason += '. -- Note: Markdown only accepts unicode input!' raise # Split into lines and run the line preprocessors. self.lines = source.split("\n") for prep in self.preprocessors.values(): self.lines = prep.run(self.lines) # Parse the high-level elements. root = self.parser.parseDocument(self.lines).getroot() # Run the tree-processors for treeprocessor in self.treeprocessors.values(): newRoot = treeprocessor.run(root) if newRoot is not None: root = newRoot # Serialize _properly_. Strip top-level tags. output = self.serializer(root) if self.stripTopLevelTags: try: start = output.index('<%s>'%self.doc_tag)+len(self.doc_tag)+2 end = output.rindex('</%s>'%self.doc_tag) output = output[start:end].strip() except ValueError: if output.strip().endswith('<%s />'%self.doc_tag): # We have an empty document output = '' else: # We have a serious problem raise ValueError('Markdown failed to strip top-level tags. Document=%r' % output.strip()) # Run the text post-processors for pp in self.postprocessors.values(): output = pp.run(output) return output.strip() def convertFile(self, input=None, output=None, encoding=None): """Converts a markdown file and returns the HTML as a unicode string. Decodes the file using the provided encoding (defaults to utf-8), passes the file content to markdown, and outputs the html to either the provided stream or the file with provided name, using the same encoding as the source file. The 'xmlcharrefreplace' error handler is used when encoding the output. **Note:** This is the only place that decoding and encoding of unicode takes place in Python-Markdown. (All other code is unicode-in / unicode-out.) Keyword arguments: * input: File object or path. Reads from stdin if `None`. * output: File object or path. Writes to stdout if `None`. * encoding: Encoding of input and output files. Defaults to utf-8. """ encoding = encoding or "utf-8" # Read the source if input: if isinstance(input, util.string_type): input_file = codecs.open(input, mode="r", encoding=encoding) else: input_file = codecs.getreader(encoding)(input) text = input_file.read() input_file.close() else: text = sys.stdin.read() if not isinstance(text, util.text_type): text = text.decode(encoding) text = text.lstrip('\ufeff') # remove the byte-order mark # Convert html = self.convert(text) # Write to file or stdout if output: if isinstance(output, util.string_type): output_file = codecs.open(output, "w", encoding=encoding, errors="xmlcharrefreplace") output_file.write(html) output_file.close() else: writer = codecs.getwriter(encoding) output_file = writer(output, errors="xmlcharrefreplace") output_file.write(html) # Don't close here. User may want to write more. else: # Encode manually and write bytes to stdout. html = html.encode(encoding, "xmlcharrefreplace") try: # Write bytes directly to buffer (Python 3). sys.stdout.buffer.write(html) except AttributeError: # Probably Python 2, which works with bytes by default. sys.stdout.write(html) return self """ EXPORTED FUNCTIONS ============================================================================= Those are the two functions we really mean to export: markdown() and markdownFromFile(). """ def markdown(text, *args, **kwargs): """Convert a markdown string to HTML and return HTML as a unicode string. This is a shortcut function for `Markdown` class to cover the most basic use case. It initializes an instance of Markdown, loads the necessary extensions and runs the parser on the given text. Keyword arguments: * text: Markdown formatted text as Unicode or ASCII string. * Any arguments accepted by the Markdown class. Returns: An HTML document as a string. """ md = Markdown(*args, **kwargs) return md.convert(text) def markdownFromFile(*args, **kwargs): """Read markdown code from a file and write it to a file or a stream. This is a shortcut function which initializes an instance of Markdown, and calls the convertFile method rather than convert. Keyword arguments: * input: a file name or readable object. * output: a file name or writable object. * encoding: Encoding of input and output. * Any arguments accepted by the Markdown class. """ # For backward compatibility loop through positional args pos = ['input', 'output', 'extensions', 'encoding'] c = 0 for arg in args: if pos[c] not in kwargs: kwargs[pos[c]] = arg c += 1 if c == len(pos): break md = Markdown(**kwargs) md.convertFile(kwargs.get('input', None), kwargs.get('output', None), kwargs.get('encoding', None)) ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������Markdown-2.4/markdown/__main__.py�������������������������������������������������������������������0000666�0000000�0000000�00000006554�12111563027�015217� 0����������������������������������������������������������������������������������������������������ustar �����������������������������������������������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������""" COMMAND-LINE SPECIFIC STUFF ============================================================================= """ import markdown import sys import optparse import logging from logging import DEBUG, INFO, CRITICAL logger = logging.getLogger('MARKDOWN') def parse_options(): """ Define and parse `optparse` options for command-line usage. """ usage = """%prog [options] [INPUTFILE] (STDIN is assumed if no INPUTFILE is given)""" desc = "A Python implementation of John Gruber's Markdown. " \ "http://packages.python.org/Markdown/" ver = "%%prog %s" % markdown.version parser = optparse.OptionParser(usage=usage, description=desc, version=ver) parser.add_option("-f", "--file", dest="filename", default=None, help="Write output to OUTPUT_FILE. Defaults to STDOUT.", metavar="OUTPUT_FILE") parser.add_option("-e", "--encoding", dest="encoding", help="Encoding for input and output files.",) parser.add_option("-q", "--quiet", default = CRITICAL, action="store_const", const=CRITICAL+10, dest="verbose", help="Suppress all warnings.") parser.add_option("-v", "--verbose", action="store_const", const=INFO, dest="verbose", help="Print all warnings.") parser.add_option("-s", "--safe", dest="safe", default=False, metavar="SAFE_MODE", help="'replace', 'remove' or 'escape' HTML tags in input") parser.add_option("-o", "--output_format", dest="output_format", default='xhtml1', metavar="OUTPUT_FORMAT", help="'xhtml1' (default), 'html4' or 'html5'.") parser.add_option("--noisy", action="store_const", const=DEBUG, dest="verbose", help="Print debug messages.") parser.add_option("-x", "--extension", action="append", dest="extensions", help = "Load extension EXTENSION.", metavar="EXTENSION") parser.add_option("-n", "--no_lazy_ol", dest="lazy_ol", action='store_false', default=True, help="Observe number of first item of ordered lists.") (options, args) = parser.parse_args() if len(args) == 0: input_file = None else: input_file = args[0] if not options.extensions: options.extensions = [] return {'input': input_file, 'output': options.filename, 'safe_mode': options.safe, 'extensions': options.extensions, 'encoding': options.encoding, 'output_format': options.output_format, 'lazy_ol': options.lazy_ol}, options.verbose def run(): """Run Markdown from the command line.""" # Parse options and adjust logging level if necessary options, logging_level = parse_options() if not options: sys.exit(2) logger.setLevel(logging_level) logger.addHandler(logging.StreamHandler()) # Run markdown.markdownFromFile(**options) if __name__ == '__main__': # Support running module as a commandline command. # Python 2.5 & 2.6 do: `python -m markdown.__main__ [options] [args]`. # Python 2.7 & 3.x do: `python -m markdown [options] [args]`. run() ����������������������������������������������������������������������������������������������������������������������������������������������������Markdown-2.4/markdown/__version__.py����������������������������������������������������������������0000666�0000000�0000000�00000001613�12300212541�015737� 0����������������������������������������������������������������������������������������������������ustar �����������������������������������������������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������# # markdown/__version__.py # # version_info should conform to PEP 386 # (major, minor, micro, alpha/beta/rc/final, #) # (1, 1, 2, 'alpha', 0) => "1.1.2.dev" # (1, 2, 0, 'beta', 2) => "1.2b2" version_info = (2, 4, 0, 'final', 0) def _get_version(): " Returns a PEP 386-compliant version number from version_info. " assert len(version_info) == 5 assert version_info[3] in ('alpha', 'beta', 'rc', 'final') parts = 2 if version_info[2] == 0 else 3 main = '.'.join(map(str, version_info[:parts])) sub = '' if version_info[3] == 'alpha' and version_info[4] == 0: # TODO: maybe append some sort of git info here?? sub = '.dev' elif version_info[3] != 'final': mapping = {'alpha': 'a', 'beta': 'b', 'rc': 'c'} sub = mapping[version_info[3]] + str(version_info[4]) return str(main + sub) version = _get_version() ���������������������������������������������������������������������������������������������������������������������Markdown-2.4/PKG-INFO�������������������������������������������������������������������������������0000666�0000000�0000000�00000004425�12300213225�012363� 0����������������������������������������������������������������������������������������������������ustar �����������������������������������������������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������Metadata-Version: 1.0 Name: Markdown Version: 2.4 Summary: Python implementation of Markdown. Home-page: http://packages.python.org/Markdown/ Author: Waylan Limberg Author-email: waylan [at] gmail.com License: BSD License Download-URL: http://pypi.python.org/packages/source/M/Markdown/Markdown-2.4.tar.gz Description: This is a Python implementation of John Gruber's Markdown_. It is almost completely compliant with the reference implementation, though there are a few known issues. See Features_ for information on what exactly is supported and what is not. Additional features are supported by the `Available Extensions`_. .. _Markdown: http://daringfireball.net/projects/markdown/ .. _Features: http://packages.python.org/Markdown/index.html#Features .. _`Available Extensions`: http://packages.python.org/Markdown/extensions/index.html Support ======= You may ask for help and discuss various other issues on the `mailing list`_ and report bugs on the `bug tracker`_. .. _`mailing list`: http://lists.sourceforge.net/lists/listinfo/python-markdown-discuss .. _`bug tracker`: http://github.com/waylan/Python-Markdown/issues Platform: UNKNOWN Classifier: Development Status :: 5 - Production/Stable Classifier: License :: OSI Approved :: BSD License Classifier: Operating System :: OS Independent Classifier: Programming Language :: Python Classifier: Programming Language :: Python :: 2 Classifier: Programming Language :: Python :: 2.6 Classifier: Programming Language :: Python :: 2.7 Classifier: Programming Language :: Python :: 3 Classifier: Programming Language :: Python :: 3.1 Classifier: Programming Language :: Python :: 3.2 Classifier: Programming Language :: Python :: 3.3 Classifier: Topic :: Communications :: Email :: Filters Classifier: Topic :: Internet :: WWW/HTTP :: Dynamic Content :: CGI Tools/Libraries Classifier: Topic :: Internet :: WWW/HTTP :: Site Management Classifier: Topic :: Software Development :: Documentation Classifier: Topic :: Software Development :: Libraries :: Python Modules Classifier: Topic :: Text Processing :: Filters Classifier: Topic :: Text Processing :: Markup :: HTML �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������Markdown-2.4/README.md������������������������������������������������������������������������������0000666�0000000�0000000�00000002160�12111563026�012546� 0����������������������������������������������������������������������������������������������������ustar �����������������������������������������������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������[Python-Markdown][] =================== This is a Python implementation of John Gruber's [Markdown][]. It is almost completely compliant with the reference implementation, though there are a few known issues. See [Features][] for information on what exactly is supported and what is not. Additional features are supported by the [Available Extensions][]. [Python-Markdown]: http://packages.python.org/Markdown/ [Markdown]: http://daringfireball.net/projects/markdown/ [Features]: http://packages.python.org/Markdown/index.html#Features [Available Extensions]: http://packages.python.org/Markdown/extensions/index.html Documentation ------------- Installation and usage documentation is available in the `docs/` directory of the distribution and on the project website at <http://packages.python.org/Markdown/>. Support ------- You may ask for help and discuss various other issues on the [mailing list][] and report bugs on the [bug tracker][]. [mailing list]: http://lists.sourceforge.net/lists/listinfo/python-markdown-discuss [bug tracker]: http://github.com/waylan/Python-Markdown/issues ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������Markdown-2.4/run-tests.py���������������������������������������������������������������������������0000666�0000000�0000000�00000001053�12261107557�013616� 0����������������������������������������������������������������������������������������������������ustar �����������������������������������������������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������#!/usr/bin/env python import tests import os, sys if len(sys.argv) > 1 and sys.argv[1] == "update": if len(sys.argv) > 2: config = tests.get_config(os.path.dirname(sys.argv[2])) root, ext = os.path.splitext(sys.argv[2]) if ext == config.get(tests.get_section(os.path.basename(root), config), 'input_ext'): tests.generate(root, config) else: print(sys.argv[2], 'does not have a valid file extension. Check config.') else: tests.generate_all() else: tests.run() �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������Markdown-2.4/setup.cfg������������������������������������������������������������������������������0000666�0000000�0000000�00000000015�12111563027�013106� 0����������������������������������������������������������������������������������������������������ustar �����������������������������������������������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������[nosetests] �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������Markdown-2.4/setup.py�������������������������������������������������������������������������������0000666�0000000�0000000�00000024206�12261107557�013017� 0����������������������������������������������������������������������������������������������������ustar �����������������������������������������������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������#!/usr/bin/env python from __future__ import with_statement import sys, os from distutils.core import setup from distutils.command.install_scripts import install_scripts from distutils.command.build import build from distutils.core import Command from distutils.util import change_root, newer import codecs import imp def get_version(): " Get version & version_info without importing markdown.__init__ " path = os.path.join(os.path.dirname(__file__), 'markdown') fp, pathname, desc = imp.find_module('__version__', [path]) try: v = imp.load_module('__version__', fp, pathname, desc) return v.version, v.version_info finally: fp.close() version, version_info = get_version() # Get development Status for classifiers dev_status_map = { 'alpha': '3 - Alpha', 'beta' : '4 - Beta', 'rc' : '4 - Beta', 'final': '5 - Production/Stable' } if version_info[3] == 'alpha' and version_info[4] == 0: DEVSTATUS = '2 - Pre-Alpha' else: DEVSTATUS = dev_status_map[version_info[3]] # The command line script name. Currently set to "markdown_py" so as not to # conflict with the perl implimentation (which uses "markdown"). We can't use # "markdown.py" as the default config on some systems will cause the script to # try to import itself rather than the library which will raise an error. SCRIPT_NAME = 'markdown_py' class md_install_scripts(install_scripts): """ Customized install_scripts. Create markdown_py.bat for win32. """ def run(self): install_scripts.run(self) if sys.platform == 'win32': try: script_dir = os.path.join(sys.prefix, 'Scripts') script_path = os.path.join(script_dir, SCRIPT_NAME) bat_str = '@"%s" "%s" %%*' % (sys.executable, script_path) bat_path = os.path.join(self.install_dir, '%s.bat' %SCRIPT_NAME) f = open(bat_path, 'w') f.write(bat_str) f.close() print ('Created: %s' % bat_path) except Exception: _, err, _ = sys.exc_info() # for both 2.x & 3.x compatability print ('ERROR: Unable to create %s: %s' % (bat_path, err)) class build_docs(Command): """ Build markdown documentation into html.""" description = '"build" documentation (convert markdown text to html)' user_options = [ ('build-base=', 'd', 'directory to "build" to'), ('force', 'f', 'forcibly build everything (ignore file timestamps)'), ] boolean_options = ['force'] def initialize_options(self): self.build_base = None self.force = None self.docs = None self.sitemap = '' def finalize_options(self): self.set_undefined_options('build', ('build_base', 'build_base'), ('force', 'force')) self.docs = self._get_docs() def _get_docs(self): for root, dirs, files in os.walk('docs'): for file in files: if not file.startswith('_'): path = os.path.join(root, file) yield path def _get_context(self, src, path): """ Build and return context to pass to template. """ # set defaults c = { 'title' : '', 'prev_url' : '', 'prev_title' : '', 'next_url' : '', 'next_title' : '', 'crumb' : '', 'version' : version, } c['body'] = self.md.convert(src) c['toc'] = self.md.toc for k, v in self.md.Meta.items(): c[k] = ' '.join(v) self.md.reset() # Manipulate path path = path[len(os.path.join(self.build_base, 'docs/')):] dir, file = os.path.split(path) name, ext = os.path.splitext(file) parts = [x for x in dir.split(os.sep) if x] c['source'] = '%s.txt' % name c['base'] = '../'*len(parts) # Build page title if name.lower() != 'index' or parts: c['page_title'] = '%s — Python Markdown' % c['title'] else: c['page_title'] = 'Python Markdown' # Build crumb trail crumbs = [] ctemp = '<li><a href="%s">%s</a> »</li>' for n, part in enumerate(parts): href = ('../'*n) + 'index.html' label = part.replace('_', ' ').capitalize() crumbs.append(ctemp % (href, label)) if c['title'] and name.lower() != 'index': crumbs.append(ctemp % (file, c['title'])) c['crumb'] = '\n'.join(crumbs) return c def run(self): # Before importing markdown, tweak sys.path to import from the # build directory (2to3 might have run on the library). bld_cmd = self.get_finalized_command("build") sys.path.insert(0, bld_cmd.build_lib) try: import markdown except ImportError: print ('skipping build_docs: Markdown "import" failed!') else: with codecs.open('docs/_template.html', encoding='utf-8') as f: template = f.read() self.md = markdown.Markdown( extensions=['extra', 'toc(permalink=true)', 'meta', 'admonition', 'smarty']) for infile in self.docs: outfile, ext = os.path.splitext(infile) if ext == '.txt': # Copy src to .txt file srcfile = outfile + '.txt' srcfile = change_root(self.build_base, srcfile) self.mkpath(os.path.split(srcfile)[0]) self.copy_file(infile, srcfile) # Render html file outfile += '.html' outfile = change_root(self.build_base, outfile) self.mkpath(os.path.split(outfile)[0]) if self.force or newer(infile, outfile): if self.verbose: print ('Converting %s -> %s' % (infile, outfile)) if not self.dry_run: with codecs.open(infile, encoding='utf-8') as f: src = f.read() out = template % self._get_context(src, outfile) doc = open(outfile, 'wb') doc.write(out.encode('utf-8')) doc.close() else: outfile = change_root(self.build_base, infile) self.mkpath(os.path.split(outfile)[0]) self.copy_file(infile, outfile) class md_build(build): """ Run "build_docs" command from "build" command. """ user_options = build.user_options + [ ('no-build-docs', None, 'do not build documentation'), ] boolean_options = build.boolean_options + ['build-docs'] def initialize_options(self): build.initialize_options(self) self.no_build_docs = False def has_docs(self): return not self.no_build_docs sub_commands = build.sub_commands + [('build_docs', has_docs)] long_description = \ '''This is a Python implementation of John Gruber's Markdown_. It is almost completely compliant with the reference implementation, though there are a few known issues. See Features_ for information on what exactly is supported and what is not. Additional features are supported by the `Available Extensions`_. .. _Markdown: http://daringfireball.net/projects/markdown/ .. _Features: http://packages.python.org/Markdown/index.html#Features .. _`Available Extensions`: http://packages.python.org/Markdown/extensions/index.html Support ======= You may ask for help and discuss various other issues on the `mailing list`_ and report bugs on the `bug tracker`_. .. _`mailing list`: http://lists.sourceforge.net/lists/listinfo/python-markdown-discuss .. _`bug tracker`: http://github.com/waylan/Python-Markdown/issues ''' setup( name = 'Markdown', version = version, url = 'http://packages.python.org/Markdown/', download_url = 'http://pypi.python.org/packages/source/M/Markdown/Markdown-%s.tar.gz' % version, description = 'Python implementation of Markdown.', long_description = long_description, author = 'Manfred Stienstra, Yuri takhteyev and Waylan limberg', author_email = 'markdown [at] freewisdom.org', maintainer = 'Waylan Limberg', maintainer_email = 'waylan [at] gmail.com', license = 'BSD License', packages = ['markdown', 'markdown.extensions'], scripts = ['bin/%s' % SCRIPT_NAME], cmdclass = {'install_scripts': md_install_scripts, 'build_docs': build_docs, 'build': md_build}, classifiers = ['Development Status :: %s' % DEVSTATUS, 'License :: OSI Approved :: BSD License', 'Operating System :: OS Independent', 'Programming Language :: Python', 'Programming Language :: Python :: 2', 'Programming Language :: Python :: 2.6', 'Programming Language :: Python :: 2.7', 'Programming Language :: Python :: 3', 'Programming Language :: Python :: 3.1', 'Programming Language :: Python :: 3.2', 'Programming Language :: Python :: 3.3', 'Topic :: Communications :: Email :: Filters', 'Topic :: Internet :: WWW/HTTP :: Dynamic Content :: CGI Tools/Libraries', 'Topic :: Internet :: WWW/HTTP :: Site Management', 'Topic :: Software Development :: Documentation', 'Topic :: Software Development :: Libraries :: Python Modules', 'Topic :: Text Processing :: Filters', 'Topic :: Text Processing :: Markup :: HTML', ], ) ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������Markdown-2.4/tests/���������������������������������������������������������������������������������0000777�0000000�0000000�00000000000�12300213220�012416� 5����������������������������������������������������������������������������������������������������ustar �����������������������������������������������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������Markdown-2.4/tests/basic/���������������������������������������������������������������������������0000777�0000000�0000000�00000000000�12300213221�013500� 5����������������������������������������������������������������������������������������������������ustar �����������������������������������������������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������Markdown-2.4/tests/basic/amps-and-angle-encoding.html�����������������������������������������������0000666�0000000�0000000�00000000773�11756571171�020776� 0����������������������������������������������������������������������������������������������������ustar �����������������������������������������������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������<p>AT&T has an ampersand in their name.</p> <p>AT&T is another way to write it.</p> <p>This & that.</p> <p>4 < 5.</p> <p>6 > 5.</p> <p>Here's a <a href="http://example.com/?foo=1&bar=2">link</a> with an ampersand in the URL.</p> <p>Here's a link with an amersand in the link text: <a href="http://att.com/" title="AT&T">AT&T</a>.</p> <p>Here's an inline <a href="/script?foo=1&bar=2">link</a>.</p> <p>Here's an inline <a href="/script?foo=1&bar=2">link</a>.</p>�����Markdown-2.4/tests/basic/amps-and-angle-encoding.txt������������������������������������������������0000666�0000000�0000000�00000000621�11756571171�020641� 0����������������������������������������������������������������������������������������������������ustar �����������������������������������������������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������AT&T has an ampersand in their name. AT&T is another way to write it. This & that. 4 < 5. 6 > 5. Here's a [link] [1] with an ampersand in the URL. Here's a link with an amersand in the link text: [AT&T] [2]. Here's an inline [link](/script?foo=1&bar=2). Here's an inline [link](</script?foo=1&bar=2>). [1]: http://example.com/?foo=1&bar=2 [2]: http://att.com/ "AT&T"���������������������������������������������������������������������������������������������������������������Markdown-2.4/tests/basic/angle-links-and-img.html���������������������������������������������������0000666�0000000�0000000�00000000306�12300201166�020110� 0����������������������������������������������������������������������������������������������������ustar �����������������������������������������������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������<p><a href="simple link" title="title">link</a> <img alt="image" src="http://example.com/image.jpg" /> <a href="http://example.com/(()((())923)(">link</a> <img alt="image" src="link(()))(" /></p>��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������Markdown-2.4/tests/basic/angle-links-and-img.txt����������������������������������������������������0000666�0000000�0000000�00000000215�11756571171�020006� 0����������������������������������������������������������������������������������������������������ustar �����������������������������������������������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������[link](<simple link> "title") ![image](<http://example.com/image.jpg>) [link](<http://example.com/(()((())923)(>) ![image](<link(()))(>) �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������Markdown-2.4/tests/basic/auto-links.html������������������������������������������������������������0000666�0000000�0000000�00000001264�11756571171�016510� 0����������������������������������������������������������������������������������������������������ustar �����������������������������������������������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������<p>Link: <a href="http://example.com/">http://example.com/</a>.</p> <p>Https link: <a href="https://example.com">https://example.com</a></p> <p>Ftp link: <a href="ftp://example.com">ftp://example.com</a></p> <p>With an ampersand: <a href="http://example.com/?foo=1&bar=2">http://example.com/?foo=1&bar=2</a></p> <ul> <li>In a list?</li> <li><a href="http://example.com/">http://example.com/</a></li> <li>It should.</li> </ul> <blockquote> <p>Blockquoted: <a href="http://example.com/">http://example.com/</a></p> </blockquote> <p>Auto-links should not occur here: <code><http://example.com/></code></p> <pre><code>or here: <http://example.com/> </code></pre>��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������Markdown-2.4/tests/basic/auto-links.txt�������������������������������������������������������������0000666�0000000�0000000�00000000533�11756571171�016361� 0����������������������������������������������������������������������������������������������������ustar �����������������������������������������������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������Link: <http://example.com/>. Https link: <https://example.com> Ftp link: <ftp://example.com> With an ampersand: <http://example.com/?foo=1&bar=2> * In a list? * <http://example.com/> * It should. > Blockquoted: <http://example.com/> Auto-links should not occur here: `<http://example.com/>` or here: <http://example.com/> ���������������������������������������������������������������������������������������������������������������������������������������������������������������������Markdown-2.4/tests/basic/backlash-escapes.html������������������������������������������������������0000666�0000000�0000000�00000002464�11756571171�017616� 0����������������������������������������������������������������������������������������������������ustar �����������������������������������������������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������<p>These should all get escaped:</p> <p>Backslash: \</p> <p>Backtick: `</p> <p>Asterisk: *</p> <p>Underscore: _</p> <p>Left brace: {</p> <p>Right brace: }</p> <p>Left bracket: [</p> <p>Right bracket: ]</p> <p>Left paren: (</p> <p>Right paren: )</p> <p>Greater-than: ></p> <p>Hash: #</p> <p>Period: .</p> <p>Bang: !</p> <p>Plus: +</p> <p>Minus: -</p> <p>These should not, because they occur within a code block:</p> <pre><code>Backslash: \\ Backtick: \` Asterisk: \* Underscore: \_ Left brace: \{ Right brace: \} Left bracket: \[ Right bracket: \] Left paren: \( Right paren: \) Greater-than: \> Hash: \# Period: \. Bang: \! Plus: \+ Minus: \- </code></pre> <p>Nor should these, which occur in code spans:</p> <p>Backslash: <code>\\</code></p> <p>Backtick: <code>\`</code></p> <p>Asterisk: <code>\*</code></p> <p>Underscore: <code>\_</code></p> <p>Left brace: <code>\{</code></p> <p>Right brace: <code>\}</code></p> <p>Left bracket: <code>\[</code></p> <p>Right bracket: <code>\]</code></p> <p>Left paren: <code>\(</code></p> <p>Right paren: <code>\)</code></p> <p>Greater-than: <code>\></code></p> <p>Hash: <code>\#</code></p> <p>Period: <code>\.</code></p> <p>Bang: <code>\!</code></p> <p>Plus: <code>\+</code></p> <p>Minus: <code>\-</code></p>������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������Markdown-2.4/tests/basic/backlash-escapes.txt�������������������������������������������������������0000666�0000000�0000000�00000001741�11756571171�017466� 0����������������������������������������������������������������������������������������������������ustar �����������������������������������������������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������These should all get escaped: Backslash: \\ Backtick: \` Asterisk: \* Underscore: \_ Left brace: \{ Right brace: \} Left bracket: \[ Right bracket: \] Left paren: \( Right paren: \) Greater-than: \> Hash: \# Period: \. Bang: \! Plus: \+ Minus: \- These should not, because they occur within a code block: Backslash: \\ Backtick: \` Asterisk: \* Underscore: \_ Left brace: \{ Right brace: \} Left bracket: \[ Right bracket: \] Left paren: \( Right paren: \) Greater-than: \> Hash: \# Period: \. Bang: \! Plus: \+ Minus: \- Nor should these, which occur in code spans: Backslash: `\\` Backtick: `` \` `` Asterisk: `\*` Underscore: `\_` Left brace: `\{` Right brace: `\}` Left bracket: `\[` Right bracket: `\]` Left paren: `\(` Right paren: `\)` Greater-than: `\>` Hash: `\#` Period: `\.` Bang: `\!` Plus: `\+` Minus: `\-` �������������������������������Markdown-2.4/tests/basic/blockquotes-with-code-blocks.html������������������������������������������0000666�0000000�0000000�00000000273�11756571171�022110� 0����������������������������������������������������������������������������������������������������ustar �����������������������������������������������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������<blockquote> <p>Example:</p> <pre><code>sub status { print "working"; } </code></pre> <p>Or:</p> <pre><code>sub status { return "working"; } </code></pre> </blockquote>�������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������Markdown-2.4/tests/basic/blockquotes-with-code-blocks.txt�������������������������������������������0000666�0000000�0000000�00000000222�11756571171�021755� 0����������������������������������������������������������������������������������������������������ustar �����������������������������������������������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������> Example: > > sub status { > print "working"; > } > > Or: > > sub status { > return "working"; > } ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������Markdown-2.4/tests/basic/codeblock-in-list.html�����������������������������������������������������0000666�0000000�0000000�00000000302�11756571171�017714� 0����������������������������������������������������������������������������������������������������ustar �����������������������������������������������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������<ul> <li> <p>A list item with a code block</p> <pre><code>Some *code* </code></pre> </li> <li> <p>Another list item</p> <pre><code>More code And more code </code></pre> </li> </ul>������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������Markdown-2.4/tests/basic/codeblock-in-list.txt������������������������������������������������������0000666�0000000�0000000�00000000177�11756571171�017601� 0����������������������������������������������������������������������������������������������������ustar �����������������������������������������������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������* A list item with a code block Some *code* * Another list item More code And more code �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������Markdown-2.4/tests/basic/hard-wrapped.html����������������������������������������������������������0000666�0000000�0000000�00000000327�11756571171�016777� 0����������������������������������������������������������������������������������������������������ustar �����������������������������������������������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������<p>In Markdown 1.0.0 and earlier. Version 8. This line turns into a list item. Because a hard-wrapped line in the middle of a paragraph looked like a list item.</p> <p>Here's one with a bullet. * criminey.</p>���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������Markdown-2.4/tests/basic/hard-wrapped.txt�����������������������������������������������������������0000666�0000000�0000000�00000000315�11756571171�016647� 0����������������������������������������������������������������������������������������������������ustar �����������������������������������������������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������In Markdown 1.0.0 and earlier. Version 8. This line turns into a list item. Because a hard-wrapped line in the middle of a paragraph looked like a list item. Here's one with a bullet. * criminey. �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������Markdown-2.4/tests/basic/horizontal-rules.html������������������������������������������������������0000666�0000000�0000000�00000000666�11756571171�017750� 0����������������������������������������������������������������������������������������������������ustar �����������������������������������������������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������<p>Dashes:</p> <hr /> <hr /> <hr /> <hr /> <pre><code>--- </code></pre> <hr /> <hr /> <hr /> <hr /> <pre><code>- - - </code></pre> <p>Asterisks:</p> <hr /> <hr /> <hr /> <hr /> <pre><code>*** </code></pre> <hr /> <hr /> <hr /> <hr /> <pre><code>* * * </code></pre> <p>Underscores:</p> <hr /> <hr /> <hr /> <hr /> <pre><code>___ </code></pre> <hr /> <hr /> <hr /> <hr /> <pre><code>_ _ _ </code></pre>��������������������������������������������������������������������������Markdown-2.4/tests/basic/horizontal-rules.txt�������������������������������������������������������0000666�0000000�0000000�00000000521�11756571171�017611� 0����������������������������������������������������������������������������������������������������ustar �����������������������������������������������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������Dashes: --- --- --- --- --- - - - - - - - - - - - - - - - Asterisks: *** *** *** *** *** * * * * * * * * * * * * * * * Underscores: ___ ___ ___ ___ ___ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������Markdown-2.4/tests/basic/inline-html-advanced.html��������������������������������������������������0000666�0000000�0000000�00000000234�11756571171�020401� 0����������������������������������������������������������������������������������������������������ustar �����������������������������������������������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������<p>Simple block on one line:</p> <div>foo</div> <p>And nested without indentation:</p> <div> <div> <div> foo </div> </div> <div>bar</div> </div>��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������Markdown-2.4/tests/basic/inline-html-advanced.txt���������������������������������������������������0000666�0000000�0000000�00000000224�11756571171�020253� 0����������������������������������������������������������������������������������������������������ustar �����������������������������������������������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������Simple block on one line: <div>foo</div> And nested without indentation: <div> <div> <div> foo </div> </div> <div>bar</div> </div> ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������Markdown-2.4/tests/basic/inline-html-comments.html��������������������������������������������������0000666�0000000�0000000�00000000303�11756571171�020456� 0����������������������������������������������������������������������������������������������������ustar �����������������������������������������������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������<p>Paragraph one.</p> <!-- This is a simple comment --> <!-- This is another comment. --> <p>Paragraph two.</p> <!-- one comment block -- -- with two comments --> <p>The end.</p>�����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������Markdown-2.4/tests/basic/inline-html-comments.txt���������������������������������������������������0000666�0000000�0000000�00000000261�11756571171�020334� 0����������������������������������������������������������������������������������������������������ustar �����������������������������������������������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������Paragraph one. <!-- This is a simple comment --> <!-- This is another comment. --> Paragraph two. <!-- one comment block -- -- with two comments --> The end. �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������Markdown-2.4/tests/basic/inline-html-simple.html����������������������������������������������������0000666�0000000�0000000�00000001557�12111563027�020121� 0����������������������������������������������������������������������������������������������������ustar �����������������������������������������������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������<p>Here's a simple block:</p> <div> foo </div> <p>This should be a code block, though:</p> <pre><code><div> foo </div> </code></pre> <p>As should this:</p> <pre><code><div>foo</div> </code></pre> <p>Now, nested:</p> <div> <div> <div> foo </div> </div> </div> <p>This should just be an HTML comment:</p> <!-- Comment --> <p>Multiline:</p> <!-- Blah Blah --> <p>Code block:</p> <pre><code><!-- Comment --> </code></pre> <p>Just plain comment, with trailing spaces on the line:</p> <!-- foo --> <p>Code:</p> <pre><code><hr /> </code></pre> <p>Hr's:</p> <hr> <hr/> <hr /> <hr> <hr/> <hr /> <hr class="foo" id="bar" /> <hr class="foo" id="bar"/> <hr class="foo" id="bar" > <p><some <a href="http://example.com">weird</a> stuff></p>�������������������������������������������������������������������������������������������������������������������������������������������������Markdown-2.4/tests/basic/inline-html-simple.txt�����������������������������������������������������0000666�0000000�0000000�00000001230�12111563027�017760� 0����������������������������������������������������������������������������������������������������ustar �����������������������������������������������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������Here's a simple block: <div> foo </div> This should be a code block, though: <div> foo </div> As should this: <div>foo</div> Now, nested: <div> <div> <div> foo </div> </div> </div> This should just be an HTML comment: <!-- Comment --> Multiline: <!-- Blah Blah --> Code block: <!-- Comment --> Just plain comment, with trailing spaces on the line: <!-- foo --> Code: <hr /> Hr's: <hr> <hr/> <hr /> <hr> <hr/> <hr /> <hr class="foo" id="bar" /> <hr class="foo" id="bar"/> <hr class="foo" id="bar" > <some [weird](http://example.com) stuff> ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������Markdown-2.4/tests/basic/links-inline.html����������������������������������������������������������0000666�0000000�0000000�00000000430�11756571171�017010� 0����������������������������������������������������������������������������������������������������ustar �����������������������������������������������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������<p>Just a <a href="/url/">URL</a>.</p> <p><a href="/url/" title="title">URL and title</a>.</p> <p><a href="/url/" title="title preceded by two spaces">URL and title</a>.</p> <p><a href="/url/" title="title preceded by a tab">URL and title</a>.</p> <p><a href="">Empty</a>.</p>����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������Markdown-2.4/tests/basic/links-inline.txt�����������������������������������������������������������0000666�0000000�0000000�00000000267�11756571171�016673� 0����������������������������������������������������������������������������������������������������ustar �����������������������������������������������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������Just a [URL](/url/). [URL and title](/url/ "title"). [URL and title](/url/ "title preceded by two spaces"). [URL and title](/url/ "title preceded by a tab"). [Empty](). �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������Markdown-2.4/tests/basic/links-reference.html�������������������������������������������������������0000666�0000000�0000000�00000002054�12111563027�017457� 0����������������������������������������������������������������������������������������������������ustar �����������������������������������������������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������<p>Foo <a href="/url/" title="Title">bar</a>.</p> <p>Foo <a href="/url/" title="Title">bar</a>.</p> <p>Foo <a href="/url/" title="Title">bar</a>.</p> <p>With <a href="/url/">embedded [brackets]</a>.</p> <p>Indented <a href="/url">once</a>.</p> <p>Indented <a href="/url">twice</a>.</p> <p>Indented <a href="/url">thrice</a>.</p> <p>Indented [four][] times.</p> <pre><code>[four]: /url </code></pre> <p>With <a href="http://example.com/" title="Angle Brackets">angle brackets</a>.</p> <p>And <a href="http://example.com/" title="Without angle brackets.">without</a>.</p> <p>With <a href="http://example.com" title="Yes this works">line breaks</a></p> <p>and <a href="http://example.com" title="Yes this works">line breaks</a> with one space.</p> <p>and [line<br /> breaks[] with two spaces.</p> <p><a href="http://example.com" title="No more hanging empty bracket!">short ref</a></p> <p><a href="http://example.com" title="No more hanging empty bracket!">short ref</a></p> <p><a href="http://example.com" title="Title on next line.">a ref</a></p>������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������Markdown-2.4/tests/basic/links-reference.txt��������������������������������������������������������0000666�0000000�0000000�00000001441�12111563027�017331� 0����������������������������������������������������������������������������������������������������ustar �����������������������������������������������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������Foo [bar] [1]. Foo [bar][1]. Foo [bar] [1]. [1]: /url/ "Title" With [embedded [brackets]] [b]. Indented [once][]. Indented [twice][]. Indented [thrice][]. Indented [four][] times. [once]: /url [twice]: /url [thrice]: /url [four]: /url [b]: /url/ With [angle brackets][]. And [without][]. [angle brackets]: <http://example.com/> "Angle Brackets" [without]: http://example.com/ "Without angle brackets." With [line breaks][] and [line breaks][] with one space. and [line breaks[] with two spaces. [line breaks]: http://example.com "Yes this works" [short ref] [short ref] [short ref]: http://example.com "No more hanging empty bracket!" [a ref] [a ref]: http://example.com "Title on next line." �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������Markdown-2.4/tests/basic/literal-quotes.html��������������������������������������������������������0000666�0000000�0000000�00000000242�11756571171�017367� 0����������������������������������������������������������������������������������������������������ustar �����������������������������������������������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������<p>Foo <a href="/url/" title="Title with "quotes" inside">bar</a>.</p> <p>Foo <a href="/url/" title="Title with "quotes" inside">bar</a>.</p>��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������Markdown-2.4/tests/basic/literal-quotes.txt���������������������������������������������������������0000666�0000000�0000000�00000000163�11756571171�017244� 0����������������������������������������������������������������������������������������������������ustar �����������������������������������������������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������Foo [bar][]. Foo [bar](/url/ "Title with "quotes" inside"). [bar]: /url/ "Title with "quotes" inside" �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������Markdown-2.4/tests/basic/markdown-documentation-basics.html�����������������������������������������0000666�0000000�0000000�00000022522�11756571171�022355� 0����������������������������������������������������������������������������������������������������ustar �����������������������������������������������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������<h1>Markdown: Basics</h1> <ul id="ProjectSubmenu"> <li><a href="/projects/markdown/" title="Markdown Project Page">Main</a></li> <li><a class="selected" title="Markdown Basics">Basics</a></li> <li><a href="/projects/markdown/syntax" title="Markdown Syntax Documentation">Syntax</a></li> <li><a href="/projects/markdown/license" title="Pricing and License Information">License</a></li> <li><a href="/projects/markdown/dingus" title="Online Markdown Web Form">Dingus</a></li> </ul> <h2>Getting the Gist of Markdown's Formatting Syntax</h2> <p>This page offers a brief overview of what it's like to use Markdown. The <a href="/projects/markdown/syntax" title="Markdown Syntax">syntax page</a> provides complete, detailed documentation for every feature, but Markdown should be very easy to pick up simply by looking at a few examples of it in action. The examples on this page are written in a before/after style, showing example syntax and the HTML output produced by Markdown.</p> <p>It's also helpful to simply try Markdown out; the <a href="/projects/markdown/dingus" title="Markdown Dingus">Dingus</a> is a web application that allows you type your own Markdown-formatted text and translate it to XHTML.</p> <p><strong>Note:</strong> This document is itself written using Markdown; you can <a href="/projects/markdown/basics.text">see the source for it by adding '.text' to the URL</a>.</p> <h2>Paragraphs, Headers, Blockquotes</h2> <p>A paragraph is simply one or more consecutive lines of text, separated by one or more blank lines. (A blank line is any line that looks like a blank line -- a line containing nothing spaces or tabs is considered blank.) Normal paragraphs should not be intended with spaces or tabs.</p> <p>Markdown offers two styles of headers: <em>Setext</em> and <em>atx</em>. Setext-style headers for <code><h1></code> and <code><h2></code> are created by "underlining" with equal signs (<code>=</code>) and hyphens (<code>-</code>), respectively. To create an atx-style header, you put 1-6 hash marks (<code>#</code>) at the beginning of the line -- the number of hashes equals the resulting HTML header level.</p> <p>Blockquotes are indicated using email-style '<code>></code>' angle brackets.</p> <p>Markdown:</p> <pre><code>A First Level Header ==================== A Second Level Header --------------------- Now is the time for all good men to come to the aid of their country. This is just a regular paragraph. The quick brown fox jumped over the lazy dog's back. ### Header 3 > This is a blockquote. > > This is the second paragraph in the blockquote. > > ## This is an H2 in a blockquote </code></pre> <p>Output:</p> <pre><code><h1>A First Level Header</h1> <h2>A Second Level Header</h2> <p>Now is the time for all good men to come to the aid of their country. This is just a regular paragraph.</p> <p>The quick brown fox jumped over the lazy dog's back.</p> <h3>Header 3</h3> <blockquote> <p>This is a blockquote.</p> <p>This is the second paragraph in the blockquote.</p> <h2>This is an H2 in a blockquote</h2> </blockquote> </code></pre> <h3>Phrase Emphasis</h3> <p>Markdown uses asterisks and underscores to indicate spans of emphasis.</p> <p>Markdown:</p> <pre><code>Some of these words *are emphasized*. Some of these words _are emphasized also_. Use two asterisks for **strong emphasis**. Or, if you prefer, __use two underscores instead__. </code></pre> <p>Output:</p> <pre><code><p>Some of these words <em>are emphasized</em>. Some of these words <em>are emphasized also</em>.</p> <p>Use two asterisks for <strong>strong emphasis</strong>. Or, if you prefer, <strong>use two underscores instead</strong>.</p> </code></pre> <h2>Lists</h2> <p>Unordered (bulleted) lists use asterisks, pluses, and hyphens (<code>*</code>, <code>+</code>, and <code>-</code>) as list markers. These three markers are interchangable; this:</p> <pre><code>* Candy. * Gum. * Booze. </code></pre> <p>this:</p> <pre><code>+ Candy. + Gum. + Booze. </code></pre> <p>and this:</p> <pre><code>- Candy. - Gum. - Booze. </code></pre> <p>all produce the same output:</p> <pre><code><ul> <li>Candy.</li> <li>Gum.</li> <li>Booze.</li> </ul> </code></pre> <p>Ordered (numbered) lists use regular numbers, followed by periods, as list markers:</p> <pre><code>1. Red 2. Green 3. Blue </code></pre> <p>Output:</p> <pre><code><ol> <li>Red</li> <li>Green</li> <li>Blue</li> </ol> </code></pre> <p>If you put blank lines between items, you'll get <code><p></code> tags for the list item text. You can create multi-paragraph list items by indenting the paragraphs by 4 spaces or 1 tab:</p> <pre><code>* A list item. With multiple paragraphs. * Another item in the list. </code></pre> <p>Output:</p> <pre><code><ul> <li><p>A list item.</p> <p>With multiple paragraphs.</p></li> <li><p>Another item in the list.</p></li> </ul> </code></pre> <h3>Links</h3> <p>Markdown supports two styles for creating links: <em>inline</em> and <em>reference</em>. With both styles, you use square brackets to delimit the text you want to turn into a link.</p> <p>Inline-style links use parentheses immediately after the link text. For example:</p> <pre><code>This is an [example link](http://example.com/). </code></pre> <p>Output:</p> <pre><code><p>This is an <a href="http://example.com/"> example link</a>.</p> </code></pre> <p>Optionally, you may include a title attribute in the parentheses:</p> <pre><code>This is an [example link](http://example.com/ "With a Title"). </code></pre> <p>Output:</p> <pre><code><p>This is an <a href="http://example.com/" title="With a Title"> example link</a>.</p> </code></pre> <p>Reference-style links allow you to refer to your links by names, which you define elsewhere in your document:</p> <pre><code>I get 10 times more traffic from [Google][1] than from [Yahoo][2] or [MSN][3]. [1]: http://google.com/ "Google" [2]: http://search.yahoo.com/ "Yahoo Search" [3]: http://search.msn.com/ "MSN Search" </code></pre> <p>Output:</p> <pre><code><p>I get 10 times more traffic from <a href="http://google.com/" title="Google">Google</a> than from <a href="http://search.yahoo.com/" title="Yahoo Search">Yahoo</a> or <a href="http://search.msn.com/" title="MSN Search">MSN</a>.</p> </code></pre> <p>The title attribute is optional. Link names may contain letters, numbers and spaces, but are <em>not</em> case sensitive:</p> <pre><code>I start my morning with a cup of coffee and [The New York Times][NY Times]. [ny times]: http://www.nytimes.com/ </code></pre> <p>Output:</p> <pre><code><p>I start my morning with a cup of coffee and <a href="http://www.nytimes.com/">The New York Times</a>.</p> </code></pre> <h3>Images</h3> <p>Image syntax is very much like link syntax.</p> <p>Inline (titles are optional):</p> <pre><code>![alt text](/path/to/img.jpg "Title") </code></pre> <p>Reference-style:</p> <pre><code>![alt text][id] [id]: /path/to/img.jpg "Title" </code></pre> <p>Both of the above examples produce the same output:</p> <pre><code><img src="/path/to/img.jpg" alt="alt text" title="Title" /> </code></pre> <h3>Code</h3> <p>In a regular paragraph, you can create code span by wrapping text in backtick quotes. Any ampersands (<code>&</code>) and angle brackets (<code><</code> or <code>></code>) will automatically be translated into HTML entities. This makes it easy to use Markdown to write about HTML example code:</p> <pre><code>I strongly recommend against using any `<blink>` tags. I wish SmartyPants used named entities like `&mdash;` instead of decimal-encoded entites like `&#8212;`. </code></pre> <p>Output:</p> <pre><code><p>I strongly recommend against using any <code>&lt;blink&gt;</code> tags.</p> <p>I wish SmartyPants used named entities like <code>&amp;mdash;</code> instead of decimal-encoded entites like <code>&amp;#8212;</code>.</p> </code></pre> <p>To specify an entire block of pre-formatted code, indent every line of the block by 4 spaces or 1 tab. Just like with code spans, <code>&</code>, <code><</code>, and <code>></code> characters will be escaped automatically.</p> <p>Markdown:</p> <pre><code>If you want your page to validate under XHTML 1.0 Strict, you've got to put paragraph tags in your blockquotes: <blockquote> <p>For example.</p> </blockquote> </code></pre> <p>Output:</p> <pre><code><p>If you want your page to validate under XHTML 1.0 Strict, you've got to put paragraph tags in your blockquotes:</p> <pre><code>&lt;blockquote&gt; &lt;p&gt;For example.&lt;/p&gt; &lt;/blockquote&gt; </code></pre> </code></pre>������������������������������������������������������������������������������������������������������������������������������������������������������������������������������Markdown-2.4/tests/basic/markdown-documentation-basics.txt������������������������������������������0000666�0000000�0000000�00000020262�11756571171�022227� 0����������������������������������������������������������������������������������������������������ustar �����������������������������������������������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������Markdown: Basics ================ <ul id="ProjectSubmenu"> <li><a href="/projects/markdown/" title="Markdown Project Page">Main</a></li> <li><a class="selected" title="Markdown Basics">Basics</a></li> <li><a href="/projects/markdown/syntax" title="Markdown Syntax Documentation">Syntax</a></li> <li><a href="/projects/markdown/license" title="Pricing and License Information">License</a></li> <li><a href="/projects/markdown/dingus" title="Online Markdown Web Form">Dingus</a></li> </ul> Getting the Gist of Markdown's Formatting Syntax ------------------------------------------------ This page offers a brief overview of what it's like to use Markdown. The [syntax page] [s] provides complete, detailed documentation for every feature, but Markdown should be very easy to pick up simply by looking at a few examples of it in action. The examples on this page are written in a before/after style, showing example syntax and the HTML output produced by Markdown. It's also helpful to simply try Markdown out; the [Dingus] [d] is a web application that allows you type your own Markdown-formatted text and translate it to XHTML. **Note:** This document is itself written using Markdown; you can [see the source for it by adding '.text' to the URL] [src]. [s]: /projects/markdown/syntax "Markdown Syntax" [d]: /projects/markdown/dingus "Markdown Dingus" [src]: /projects/markdown/basics.text ## Paragraphs, Headers, Blockquotes ## A paragraph is simply one or more consecutive lines of text, separated by one or more blank lines. (A blank line is any line that looks like a blank line -- a line containing nothing spaces or tabs is considered blank.) Normal paragraphs should not be intended with spaces or tabs. Markdown offers two styles of headers: *Setext* and *atx*. Setext-style headers for `<h1>` and `<h2>` are created by "underlining" with equal signs (`=`) and hyphens (`-`), respectively. To create an atx-style header, you put 1-6 hash marks (`#`) at the beginning of the line -- the number of hashes equals the resulting HTML header level. Blockquotes are indicated using email-style '`>`' angle brackets. Markdown: A First Level Header ==================== A Second Level Header --------------------- Now is the time for all good men to come to the aid of their country. This is just a regular paragraph. The quick brown fox jumped over the lazy dog's back. ### Header 3 > This is a blockquote. > > This is the second paragraph in the blockquote. > > ## This is an H2 in a blockquote Output: <h1>A First Level Header</h1> <h2>A Second Level Header</h2> <p>Now is the time for all good men to come to the aid of their country. This is just a regular paragraph.</p> <p>The quick brown fox jumped over the lazy dog's back.</p> <h3>Header 3</h3> <blockquote> <p>This is a blockquote.</p> <p>This is the second paragraph in the blockquote.</p> <h2>This is an H2 in a blockquote</h2> </blockquote> ### Phrase Emphasis ### Markdown uses asterisks and underscores to indicate spans of emphasis. Markdown: Some of these words *are emphasized*. Some of these words _are emphasized also_. Use two asterisks for **strong emphasis**. Or, if you prefer, __use two underscores instead__. Output: <p>Some of these words <em>are emphasized</em>. Some of these words <em>are emphasized also</em>.</p> <p>Use two asterisks for <strong>strong emphasis</strong>. Or, if you prefer, <strong>use two underscores instead</strong>.</p> ## Lists ## Unordered (bulleted) lists use asterisks, pluses, and hyphens (`*`, `+`, and `-`) as list markers. These three markers are interchangable; this: * Candy. * Gum. * Booze. this: + Candy. + Gum. + Booze. and this: - Candy. - Gum. - Booze. all produce the same output: <ul> <li>Candy.</li> <li>Gum.</li> <li>Booze.</li> </ul> Ordered (numbered) lists use regular numbers, followed by periods, as list markers: 1. Red 2. Green 3. Blue Output: <ol> <li>Red</li> <li>Green</li> <li>Blue</li> </ol> If you put blank lines between items, you'll get `<p>` tags for the list item text. You can create multi-paragraph list items by indenting the paragraphs by 4 spaces or 1 tab: * A list item. With multiple paragraphs. * Another item in the list. Output: <ul> <li><p>A list item.</p> <p>With multiple paragraphs.</p></li> <li><p>Another item in the list.</p></li> </ul> ### Links ### Markdown supports two styles for creating links: *inline* and *reference*. With both styles, you use square brackets to delimit the text you want to turn into a link. Inline-style links use parentheses immediately after the link text. For example: This is an [example link](http://example.com/). Output: <p>This is an <a href="http://example.com/"> example link</a>.</p> Optionally, you may include a title attribute in the parentheses: This is an [example link](http://example.com/ "With a Title"). Output: <p>This is an <a href="http://example.com/" title="With a Title"> example link</a>.</p> Reference-style links allow you to refer to your links by names, which you define elsewhere in your document: I get 10 times more traffic from [Google][1] than from [Yahoo][2] or [MSN][3]. [1]: http://google.com/ "Google" [2]: http://search.yahoo.com/ "Yahoo Search" [3]: http://search.msn.com/ "MSN Search" Output: <p>I get 10 times more traffic from <a href="http://google.com/" title="Google">Google</a> than from <a href="http://search.yahoo.com/" title="Yahoo Search">Yahoo</a> or <a href="http://search.msn.com/" title="MSN Search">MSN</a>.</p> The title attribute is optional. Link names may contain letters, numbers and spaces, but are *not* case sensitive: I start my morning with a cup of coffee and [The New York Times][NY Times]. [ny times]: http://www.nytimes.com/ Output: <p>I start my morning with a cup of coffee and <a href="http://www.nytimes.com/">The New York Times</a>.</p> ### Images ### Image syntax is very much like link syntax. Inline (titles are optional): ![alt text](/path/to/img.jpg "Title") Reference-style: ![alt text][id] [id]: /path/to/img.jpg "Title" Both of the above examples produce the same output: <img src="/path/to/img.jpg" alt="alt text" title="Title" /> ### Code ### In a regular paragraph, you can create code span by wrapping text in backtick quotes. Any ampersands (`&`) and angle brackets (`<` or `>`) will automatically be translated into HTML entities. This makes it easy to use Markdown to write about HTML example code: I strongly recommend against using any `<blink>` tags. I wish SmartyPants used named entities like `—` instead of decimal-encoded entites like `—`. Output: <p>I strongly recommend against using any <code><blink></code> tags.</p> <p>I wish SmartyPants used named entities like <code>&mdash;</code> instead of decimal-encoded entites like <code>&#8212;</code>.</p> To specify an entire block of pre-formatted code, indent every line of the block by 4 spaces or 1 tab. Just like with code spans, `&`, `<`, and `>` characters will be escaped automatically. Markdown: If you want your page to validate under XHTML 1.0 Strict, you've got to put paragraph tags in your blockquotes: <blockquote> <p>For example.</p> </blockquote> Output: <p>If you want your page to validate under XHTML 1.0 Strict, you've got to put paragraph tags in your blockquotes:</p> <pre><code><blockquote> <p>For example.</p> </blockquote> </code></pre> ����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������Markdown-2.4/tests/basic/markdown-syntax.html�������������������������������������������������������0000666�0000000�0000000�00000077075�11756571171�017605� 0����������������������������������������������������������������������������������������������������ustar �����������������������������������������������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������<h1>Markdown: Syntax</h1> <ul id="ProjectSubmenu"> <li><a href="/projects/markdown/" title="Markdown Project Page">Main</a></li> <li><a href="/projects/markdown/basics" title="Markdown Basics">Basics</a></li> <li><a class="selected" title="Markdown Syntax Documentation">Syntax</a></li> <li><a href="/projects/markdown/license" title="Pricing and License Information">License</a></li> <li><a href="/projects/markdown/dingus" title="Online Markdown Web Form">Dingus</a></li> </ul> <ul> <li><a href="#overview">Overview</a><ul> <li><a href="#philosophy">Philosophy</a></li> <li><a href="#html">Inline HTML</a></li> <li><a href="#autoescape">Automatic Escaping for Special Characters</a></li> </ul> </li> <li><a href="#block">Block Elements</a><ul> <li><a href="#p">Paragraphs and Line Breaks</a></li> <li><a href="#header">Headers</a></li> <li><a href="#blockquote">Blockquotes</a></li> <li><a href="#list">Lists</a></li> <li><a href="#precode">Code Blocks</a></li> <li><a href="#hr">Horizontal Rules</a></li> </ul> </li> <li><a href="#span">Span Elements</a><ul> <li><a href="#link">Links</a></li> <li><a href="#em">Emphasis</a></li> <li><a href="#code">Code</a></li> <li><a href="#img">Images</a></li> </ul> </li> <li><a href="#misc">Miscellaneous</a><ul> <li><a href="#backslash">Backslash Escapes</a></li> <li><a href="#autolink">Automatic Links</a></li> </ul> </li> </ul> <p><strong>Note:</strong> This document is itself written using Markdown; you can <a href="/projects/markdown/syntax.text">see the source for it by adding '.text' to the URL</a>.</p> <hr /> <h2 id="overview">Overview</h2> <h3 id="philosophy">Philosophy</h3> <p>Markdown is intended to be as easy-to-read and easy-to-write as is feasible.</p> <p>Readability, however, is emphasized above all else. A Markdown-formatted document should be publishable as-is, as plain text, without looking like it's been marked up with tags or formatting instructions. While Markdown's syntax has been influenced by several existing text-to-HTML filters -- including <a href="http://docutils.sourceforge.net/mirror/setext.html">Setext</a>, <a href="http://www.aaronsw.com/2002/atx/">atx</a>, <a href="http://textism.com/tools/textile/">Textile</a>, <a href="http://docutils.sourceforge.net/rst.html">reStructuredText</a>, <a href="http://www.triptico.com/software/grutatxt.html">Grutatext</a>, and <a href="http://ettext.taint.org/doc/">EtText</a> -- the single biggest source of inspiration for Markdown's syntax is the format of plain text email.</p> <p>To this end, Markdown's syntax is comprised entirely of punctuation characters, which punctuation characters have been carefully chosen so as to look like what they mean. E.g., asterisks around a word actually look like *emphasis*. Markdown lists look like, well, lists. Even blockquotes look like quoted passages of text, assuming you've ever used email.</p> <h3 id="html">Inline HTML</h3> <p>Markdown's syntax is intended for one purpose: to be used as a format for <em>writing</em> for the web.</p> <p>Markdown is not a replacement for HTML, or even close to it. Its syntax is very small, corresponding only to a very small subset of HTML tags. The idea is <em>not</em> to create a syntax that makes it easier to insert HTML tags. In my opinion, HTML tags are already easy to insert. The idea for Markdown is to make it easy to read, write, and edit prose. HTML is a <em>publishing</em> format; Markdown is a <em>writing</em> format. Thus, Markdown's formatting syntax only addresses issues that can be conveyed in plain text.</p> <p>For any markup that is not covered by Markdown's syntax, you simply use HTML itself. There's no need to preface it or delimit it to indicate that you're switching from Markdown to HTML; you just use the tags.</p> <p>The only restrictions are that block-level HTML elements -- e.g. <code><div></code>, <code><table></code>, <code><pre></code>, <code><p></code>, etc. -- must be separated from surrounding content by blank lines, and the start and end tags of the block should not be indented with tabs or spaces. Markdown is smart enough not to add extra (unwanted) <code><p></code> tags around HTML block-level tags.</p> <p>For example, to add an HTML table to a Markdown article:</p> <pre><code>This is a regular paragraph. <table> <tr> <td>Foo</td> </tr> </table> This is another regular paragraph. </code></pre> <p>Note that Markdown formatting syntax is not processed within block-level HTML tags. E.g., you can't use Markdown-style <code>*emphasis*</code> inside an HTML block.</p> <p>Span-level HTML tags -- e.g. <code><span></code>, <code><cite></code>, or <code><del></code> -- can be used anywhere in a Markdown paragraph, list item, or header. If you want, you can even use HTML tags instead of Markdown formatting; e.g. if you'd prefer to use HTML <code><a></code> or <code><img></code> tags instead of Markdown's link or image syntax, go right ahead.</p> <p>Unlike block-level HTML tags, Markdown syntax <em>is</em> processed within span-level tags.</p> <h3 id="autoescape">Automatic Escaping for Special Characters</h3> <p>In HTML, there are two characters that demand special treatment: <code><</code> and <code>&</code>. Left angle brackets are used to start tags; ampersands are used to denote HTML entities. If you want to use them as literal characters, you must escape them as entities, e.g. <code>&lt;</code>, and <code>&amp;</code>.</p> <p>Ampersands in particular are bedeviling for web writers. If you want to write about 'AT&T', you need to write '<code>AT&amp;T</code>'. You even need to escape ampersands within URLs. Thus, if you want to link to:</p> <pre><code>http://images.google.com/images?num=30&q=larry+bird </code></pre> <p>you need to encode the URL as:</p> <pre><code>http://images.google.com/images?num=30&amp;q=larry+bird </code></pre> <p>in your anchor tag <code>href</code> attribute. Needless to say, this is easy to forget, and is probably the single most common source of HTML validation errors in otherwise well-marked-up web sites.</p> <p>Markdown allows you to use these characters naturally, taking care of all the necessary escaping for you. If you use an ampersand as part of an HTML entity, it remains unchanged; otherwise it will be translated into <code>&amp;</code>.</p> <p>So, if you want to include a copyright symbol in your article, you can write:</p> <pre><code>&copy; </code></pre> <p>and Markdown will leave it alone. But if you write:</p> <pre><code>AT&T </code></pre> <p>Markdown will translate it to:</p> <pre><code>AT&amp;T </code></pre> <p>Similarly, because Markdown supports <a href="#html">inline HTML</a>, if you use angle brackets as delimiters for HTML tags, Markdown will treat them as such. But if you write:</p> <pre><code>4 < 5 </code></pre> <p>Markdown will translate it to:</p> <pre><code>4 &lt; 5 </code></pre> <p>However, inside Markdown code spans and blocks, angle brackets and ampersands are <em>always</em> encoded automatically. This makes it easy to use Markdown to write about HTML code. (As opposed to raw HTML, which is a terrible format for writing about HTML syntax, because every single <code><</code> and <code>&</code> in your example code needs to be escaped.)</p> <hr /> <h2 id="block">Block Elements</h2> <h3 id="p">Paragraphs and Line Breaks</h3> <p>A paragraph is simply one or more consecutive lines of text, separated by one or more blank lines. (A blank line is any line that looks like a blank line -- a line containing nothing but spaces or tabs is considered blank.) Normal paragraphs should not be intended with spaces or tabs.</p> <p>The implication of the "one or more consecutive lines of text" rule is that Markdown supports "hard-wrapped" text paragraphs. This differs significantly from most other text-to-HTML formatters (including Movable Type's "Convert Line Breaks" option) which translate every line break character in a paragraph into a <code><br /></code> tag.</p> <p>When you <em>do</em> want to insert a <code><br /></code> break tag using Markdown, you end a line with two or more spaces, then type return.</p> <p>Yes, this takes a tad more effort to create a <code><br /></code>, but a simplistic "every line break is a <code><br /></code>" rule wouldn't work for Markdown. Markdown's email-style <a href="#blockquote">blockquoting</a> and multi-paragraph <a href="#list">list items</a> work best -- and look better -- when you format them with hard breaks.</p> <h3 id="header">Headers</h3> <p>Markdown supports two styles of headers, <a href="http://docutils.sourceforge.net/mirror/setext.html">Setext</a> and <a href="http://www.aaronsw.com/2002/atx/">atx</a>.</p> <p>Setext-style headers are "underlined" using equal signs (for first-level headers) and dashes (for second-level headers). For example:</p> <pre><code>This is an H1 ============= This is an H2 ------------- </code></pre> <p>Any number of underlining <code>=</code>'s or <code>-</code>'s will work.</p> <p>Atx-style headers use 1-6 hash characters at the start of the line, corresponding to header levels 1-6. For example:</p> <pre><code># This is an H1 ## This is an H2 ###### This is an H6 </code></pre> <p>Optionally, you may "close" atx-style headers. This is purely cosmetic -- you can use this if you think it looks better. The closing hashes don't even need to match the number of hashes used to open the header. (The number of opening hashes determines the header level.) :</p> <pre><code># This is an H1 # ## This is an H2 ## ### This is an H3 ###### </code></pre> <h3 id="blockquote">Blockquotes</h3> <p>Markdown uses email-style <code>></code> characters for blockquoting. If you're familiar with quoting passages of text in an email message, then you know how to create a blockquote in Markdown. It looks best if you hard wrap the text and put a <code>></code> before every line:</p> <pre><code>> This is a blockquote with two paragraphs. Lorem ipsum dolor sit amet, > consectetuer adipiscing elit. Aliquam hendrerit mi posuere lectus. > Vestibulum enim wisi, viverra nec, fringilla in, laoreet vitae, risus. > > Donec sit amet nisl. Aliquam semper ipsum sit amet velit. Suspendisse > id sem consectetuer libero luctus adipiscing. </code></pre> <p>Markdown allows you to be lazy and only put the <code>></code> before the first line of a hard-wrapped paragraph:</p> <pre><code>> This is a blockquote with two paragraphs. Lorem ipsum dolor sit amet, consectetuer adipiscing elit. Aliquam hendrerit mi posuere lectus. Vestibulum enim wisi, viverra nec, fringilla in, laoreet vitae, risus. > Donec sit amet nisl. Aliquam semper ipsum sit amet velit. Suspendisse id sem consectetuer libero luctus adipiscing. </code></pre> <p>Blockquotes can be nested (i.e. a blockquote-in-a-blockquote) by adding additional levels of <code>></code>:</p> <pre><code>> This is the first level of quoting. > > > This is nested blockquote. > > Back to the first level. </code></pre> <p>Blockquotes can contain other Markdown elements, including headers, lists, and code blocks:</p> <pre><code>> ## This is a header. > > 1. This is the first list item. > 2. This is the second list item. > > Here's some example code: > > return shell_exec("echo $input | $markdown_script"); </code></pre> <p>Any decent text editor should make email-style quoting easy. For example, with BBEdit, you can make a selection and choose Increase Quote Level from the Text menu.</p> <h3 id="list">Lists</h3> <p>Markdown supports ordered (numbered) and unordered (bulleted) lists.</p> <p>Unordered lists use asterisks, pluses, and hyphens -- interchangably -- as list markers:</p> <pre><code>* Red * Green * Blue </code></pre> <p>is equivalent to:</p> <pre><code>+ Red + Green + Blue </code></pre> <p>and:</p> <pre><code>- Red - Green - Blue </code></pre> <p>Ordered lists use numbers followed by periods:</p> <pre><code>1. Bird 2. McHale 3. Parish </code></pre> <p>It's important to note that the actual numbers you use to mark the list have no effect on the HTML output Markdown produces. The HTML Markdown produces from the above list is:</p> <pre><code><ol> <li>Bird</li> <li>McHale</li> <li>Parish</li> </ol> </code></pre> <p>If you instead wrote the list in Markdown like this:</p> <pre><code>1. Bird 1. McHale 1. Parish </code></pre> <p>or even:</p> <pre><code>3. Bird 1. McHale 8. Parish </code></pre> <p>you'd get the exact same HTML output. The point is, if you want to, you can use ordinal numbers in your ordered Markdown lists, so that the numbers in your source match the numbers in your published HTML. But if you want to be lazy, you don't have to.</p> <p>If you do use lazy list numbering, however, you should still start the list with the number 1. At some point in the future, Markdown may support starting ordered lists at an arbitrary number.</p> <p>List markers typically start at the left margin, but may be indented by up to three spaces. List markers must be followed by one or more spaces or a tab.</p> <p>To make lists look nice, you can wrap items with hanging indents:</p> <pre><code>* Lorem ipsum dolor sit amet, consectetuer adipiscing elit. Aliquam hendrerit mi posuere lectus. Vestibulum enim wisi, viverra nec, fringilla in, laoreet vitae, risus. * Donec sit amet nisl. Aliquam semper ipsum sit amet velit. Suspendisse id sem consectetuer libero luctus adipiscing. </code></pre> <p>But if you want to be lazy, you don't have to:</p> <pre><code>* Lorem ipsum dolor sit amet, consectetuer adipiscing elit. Aliquam hendrerit mi posuere lectus. Vestibulum enim wisi, viverra nec, fringilla in, laoreet vitae, risus. * Donec sit amet nisl. Aliquam semper ipsum sit amet velit. Suspendisse id sem consectetuer libero luctus adipiscing. </code></pre> <p>If list items are separated by blank lines, Markdown will wrap the items in <code><p></code> tags in the HTML output. For example, this input:</p> <pre><code>* Bird * Magic </code></pre> <p>will turn into:</p> <pre><code><ul> <li>Bird</li> <li>Magic</li> </ul> </code></pre> <p>But this:</p> <pre><code>* Bird * Magic </code></pre> <p>will turn into:</p> <pre><code><ul> <li><p>Bird</p></li> <li><p>Magic</p></li> </ul> </code></pre> <p>List items may consist of multiple paragraphs. Each subsequent paragraph in a list item must be intended by either 4 spaces or one tab:</p> <pre><code>1. This is a list item with two paragraphs. Lorem ipsum dolor sit amet, consectetuer adipiscing elit. Aliquam hendrerit mi posuere lectus. Vestibulum enim wisi, viverra nec, fringilla in, laoreet vitae, risus. Donec sit amet nisl. Aliquam semper ipsum sit amet velit. 2. Suspendisse id sem consectetuer libero luctus adipiscing. </code></pre> <p>It looks nice if you indent every line of the subsequent paragraphs, but here again, Markdown will allow you to be lazy:</p> <pre><code>* This is a list item with two paragraphs. This is the second paragraph in the list item. You're only required to indent the first line. Lorem ipsum dolor sit amet, consectetuer adipiscing elit. * Another item in the same list. </code></pre> <p>To put a blockquote within a list item, the blockquote's <code>></code> delimiters need to be indented:</p> <pre><code>* A list item with a blockquote: > This is a blockquote > inside a list item. </code></pre> <p>To put a code block within a list item, the code block needs to be indented <em>twice</em> -- 8 spaces or two tabs:</p> <pre><code>* A list item with a code block: <code goes here> </code></pre> <p>It's worth noting that it's possible to trigger an ordered list by accident, by writing something like this:</p> <pre><code>1986. What a great season. </code></pre> <p>In other words, a <em>number-period-space</em> sequence at the beginning of a line. To avoid this, you can backslash-escape the period:</p> <pre><code>1986\. What a great season. </code></pre> <h3 id="precode">Code Blocks</h3> <p>Pre-formatted code blocks are used for writing about programming or markup source code. Rather than forming normal paragraphs, the lines of a code block are interpreted literally. Markdown wraps a code block in both <code><pre></code> and <code><code></code> tags.</p> <p>To produce a code block in Markdown, simply indent every line of the block by at least 4 spaces or 1 tab. For example, given this input:</p> <pre><code>This is a normal paragraph: This is a code block. </code></pre> <p>Markdown will generate:</p> <pre><code><p>This is a normal paragraph:</p> <pre><code>This is a code block. </code></pre> </code></pre> <p>One level of indentation -- 4 spaces or 1 tab -- is removed from each line of the code block. For example, this:</p> <pre><code>Here is an example of AppleScript: tell application "Foo" beep end tell </code></pre> <p>will turn into:</p> <pre><code><p>Here is an example of AppleScript:</p> <pre><code>tell application "Foo" beep end tell </code></pre> </code></pre> <p>A code block continues until it reaches a line that is not indented (or the end of the article).</p> <p>Within a code block, ampersands (<code>&</code>) and angle brackets (<code><</code> and <code>></code>) are automatically converted into HTML entities. This makes it very easy to include example HTML source code using Markdown -- just paste it and indent it, and Markdown will handle the hassle of encoding the ampersands and angle brackets. For example, this:</p> <pre><code> <div class="footer"> &copy; 2004 Foo Corporation </div> </code></pre> <p>will turn into:</p> <pre><code><pre><code>&lt;div class="footer"&gt; &amp;copy; 2004 Foo Corporation &lt;/div&gt; </code></pre> </code></pre> <p>Regular Markdown syntax is not processed within code blocks. E.g., asterisks are just literal asterisks within a code block. This means it's also easy to use Markdown to write about Markdown's own syntax.</p> <h3 id="hr">Horizontal Rules</h3> <p>You can produce a horizontal rule tag (<code><hr /></code>) by placing three or more hyphens, asterisks, or underscores on a line by themselves. If you wish, you may use spaces between the hyphens or asterisks. Each of the following lines will produce a horizontal rule:</p> <pre><code>* * * *** ***** - - - --------------------------------------- _ _ _ </code></pre> <hr /> <h2 id="span">Span Elements</h2> <h3 id="link">Links</h3> <p>Markdown supports two style of links: <em>inline</em> and <em>reference</em>.</p> <p>In both styles, the link text is delimited by [square brackets].</p> <p>To create an inline link, use a set of regular parentheses immediately after the link text's closing square bracket. Inside the parentheses, put the URL where you want the link to point, along with an <em>optional</em> title for the link, surrounded in quotes. For example:</p> <pre><code>This is [an example](http://example.com/ "Title") inline link. [This link](http://example.net/) has no title attribute. </code></pre> <p>Will produce:</p> <pre><code><p>This is <a href="http://example.com/" title="Title"> an example</a> inline link.</p> <p><a href="http://example.net/">This link</a> has no title attribute.</p> </code></pre> <p>If you're referring to a local resource on the same server, you can use relative paths:</p> <pre><code>See my [About](/about/) page for details. </code></pre> <p>Reference-style links use a second set of square brackets, inside which you place a label of your choosing to identify the link:</p> <pre><code>This is [an example][id] reference-style link. </code></pre> <p>You can optionally use a space to separate the sets of brackets:</p> <pre><code>This is [an example] [id] reference-style link. </code></pre> <p>Then, anywhere in the document, you define your link label like this, on a line by itself:</p> <pre><code>[id]: http://example.com/ "Optional Title Here" </code></pre> <p>That is:</p> <ul> <li>Square brackets containing the link identifier (optionally indented from the left margin using up to three spaces);</li> <li>followed by a colon;</li> <li>followed by one or more spaces (or tabs);</li> <li>followed by the URL for the link;</li> <li>optionally followed by a title attribute for the link, enclosed in double or single quotes.</li> </ul> <p>The link URL may, optionally, be surrounded by angle brackets:</p> <pre><code>[id]: <http://example.com/> "Optional Title Here" </code></pre> <p>You can put the title attribute on the next line and use extra spaces or tabs for padding, which tends to look better with longer URLs:</p> <pre><code>[id]: http://example.com/longish/path/to/resource/here "Optional Title Here" </code></pre> <p>Link definitions are only used for creating links during Markdown processing, and are stripped from your document in the HTML output.</p> <p>Link definition names may constist of letters, numbers, spaces, and punctuation -- but they are <em>not</em> case sensitive. E.g. these two links:</p> <pre><code>[link text][a] [link text][A] </code></pre> <p>are equivalent.</p> <p>The <em>implicit link name</em> shortcut allows you to omit the name of the link, in which case the link text itself is used as the name. Just use an empty set of square brackets -- e.g., to link the word "Google" to the google.com web site, you could simply write:</p> <pre><code>[Google][] </code></pre> <p>And then define the link:</p> <pre><code>[Google]: http://google.com/ </code></pre> <p>Because link names may contain spaces, this shortcut even works for multiple words in the link text:</p> <pre><code>Visit [Daring Fireball][] for more information. </code></pre> <p>And then define the link:</p> <pre><code>[Daring Fireball]: http://daringfireball.net/ </code></pre> <p>Link definitions can be placed anywhere in your Markdown document. I tend to put them immediately after each paragraph in which they're used, but if you want, you can put them all at the end of your document, sort of like footnotes.</p> <p>Here's an example of reference links in action:</p> <pre><code>I get 10 times more traffic from [Google] [1] than from [Yahoo] [2] or [MSN] [3]. [1]: http://google.com/ "Google" [2]: http://search.yahoo.com/ "Yahoo Search" [3]: http://search.msn.com/ "MSN Search" </code></pre> <p>Using the implicit link name shortcut, you could instead write:</p> <pre><code>I get 10 times more traffic from [Google][] than from [Yahoo][] or [MSN][]. [google]: http://google.com/ "Google" [yahoo]: http://search.yahoo.com/ "Yahoo Search" [msn]: http://search.msn.com/ "MSN Search" </code></pre> <p>Both of the above examples will produce the following HTML output:</p> <pre><code><p>I get 10 times more traffic from <a href="http://google.com/" title="Google">Google</a> than from <a href="http://search.yahoo.com/" title="Yahoo Search">Yahoo</a> or <a href="http://search.msn.com/" title="MSN Search">MSN</a>.</p> </code></pre> <p>For comparison, here is the same paragraph written using Markdown's inline link style:</p> <pre><code>I get 10 times more traffic from [Google](http://google.com/ "Google") than from [Yahoo](http://search.yahoo.com/ "Yahoo Search") or [MSN](http://search.msn.com/ "MSN Search"). </code></pre> <p>The point of reference-style links is not that they're easier to write. The point is that with reference-style links, your document source is vastly more readable. Compare the above examples: using reference-style links, the paragraph itself is only 81 characters long; with inline-style links, it's 176 characters; and as raw HTML, it's 234 characters. In the raw HTML, there's more markup than there is text.</p> <p>With Markdown's reference-style links, a source document much more closely resembles the final output, as rendered in a browser. By allowing you to move the markup-related metadata out of the paragraph, you can add links without interrupting the narrative flow of your prose.</p> <h3 id="em">Emphasis</h3> <p>Markdown treats asterisks (<code>*</code>) and underscores (<code>_</code>) as indicators of emphasis. Text wrapped with one <code>*</code> or <code>_</code> will be wrapped with an HTML <code><em></code> tag; double <code>*</code>'s or <code>_</code>'s will be wrapped with an HTML <code><strong></code> tag. E.g., this input:</p> <pre><code>*single asterisks* _single underscores_ **double asterisks** __double underscores__ </code></pre> <p>will produce:</p> <pre><code><em>single asterisks</em> <em>single underscores</em> <strong>double asterisks</strong> <strong>double underscores</strong> </code></pre> <p>You can use whichever style you prefer; the lone restriction is that the same character must be used to open and close an emphasis span.</p> <p>Emphasis can be used in the middle of a word:</p> <pre><code>un*fucking*believable </code></pre> <p>But if you surround an <code>*</code> or <code>_</code> with spaces, it'll be treated as a literal asterisk or underscore.</p> <p>To produce a literal asterisk or underscore at a position where it would otherwise be used as an emphasis delimiter, you can backslash escape it:</p> <pre><code>\*this text is surrounded by literal asterisks\* </code></pre> <h3 id="code">Code</h3> <p>To indicate a span of code, wrap it with backtick quotes (<code>`</code>). Unlike a pre-formatted code block, a code span indicates code within a normal paragraph. For example:</p> <pre><code>Use the `printf()` function. </code></pre> <p>will produce:</p> <pre><code><p>Use the <code>printf()</code> function.</p> </code></pre> <p>To include a literal backtick character within a code span, you can use multiple backticks as the opening and closing delimiters:</p> <pre><code>``There is a literal backtick (`) here.`` </code></pre> <p>which will produce this:</p> <pre><code><p><code>There is a literal backtick (`) here.</code></p> </code></pre> <p>The backtick delimiters surrounding a code span may include spaces -- one after the opening, one before the closing. This allows you to place literal backtick characters at the beginning or end of a code span:</p> <pre><code>A single backtick in a code span: `` ` `` A backtick-delimited string in a code span: `` `foo` `` </code></pre> <p>will produce:</p> <pre><code><p>A single backtick in a code span: <code>`</code></p> <p>A backtick-delimited string in a code span: <code>`foo`</code></p> </code></pre> <p>With a code span, ampersands and angle brackets are encoded as HTML entities automatically, which makes it easy to include example HTML tags. Markdown will turn this:</p> <pre><code>Please don't use any `<blink>` tags. </code></pre> <p>into:</p> <pre><code><p>Please don't use any <code>&lt;blink&gt;</code> tags.</p> </code></pre> <p>You can write this:</p> <pre><code>`&#8212;` is the decimal-encoded equivalent of `&mdash;`. </code></pre> <p>to produce:</p> <pre><code><p><code>&amp;#8212;</code> is the decimal-encoded equivalent of <code>&amp;mdash;</code>.</p> </code></pre> <h3 id="img">Images</h3> <p>Admittedly, it's fairly difficult to devise a "natural" syntax for placing images into a plain text document format.</p> <p>Markdown uses an image syntax that is intended to resemble the syntax for links, allowing for two styles: <em>inline</em> and <em>reference</em>.</p> <p>Inline image syntax looks like this:</p> <pre><code>![Alt text](/path/to/img.jpg) ![Alt text](/path/to/img.jpg "Optional title") </code></pre> <p>That is:</p> <ul> <li>An exclamation mark: <code>!</code>;</li> <li>followed by a set of square brackets, containing the <code>alt</code> attribute text for the image;</li> <li>followed by a set of parentheses, containing the URL or path to the image, and an optional <code>title</code> attribute enclosed in double or single quotes.</li> </ul> <p>Reference-style image syntax looks like this:</p> <pre><code>![Alt text][id] </code></pre> <p>Where "id" is the name of a defined image reference. Image references are defined using syntax identical to link references:</p> <pre><code>[id]: url/to/image "Optional title attribute" </code></pre> <p>As of this writing, Markdown has no syntax for specifying the dimensions of an image; if this is important to you, you can simply use regular HTML <code><img></code> tags.</p> <hr /> <h2 id="misc">Miscellaneous</h2> <h3 id="autolink">Automatic Links</h3> <p>Markdown supports a shortcut style for creating "automatic" links for URLs and email addresses: simply surround the URL or email address with angle brackets. What this means is that if you want to show the actual text of a URL or email address, and also have it be a clickable link, you can do this:</p> <pre><code><http://example.com/> </code></pre> <p>Markdown will turn this into:</p> <pre><code><a href="http://example.com/">http://example.com/</a> </code></pre> <p>Automatic links for email addresses work similarly, except that Markdown will also perform a bit of randomized decimal and hex entity-encoding to help obscure your address from address-harvesting spambots. For example, Markdown will turn this:</p> <pre><code><address@example.com> </code></pre> <p>into something like this:</p> <pre><code><a href="&#x6D;&#x61;i&#x6C;&#x74;&#x6F;:&#x61;&#x64;&#x64;&#x72;&#x65; &#115;&#115;&#64;&#101;&#120;&#x61;&#109;&#x70;&#x6C;e&#x2E;&#99;&#111; &#109;">&#x61;&#x64;&#x64;&#x72;&#x65;&#115;&#115;&#64;&#101;&#120;&#x61; &#109;&#x70;&#x6C;e&#x2E;&#99;&#111;&#109;</a> </code></pre> <p>which will render in a browser as a clickable link to "address@example.com".</p> <p>(This sort of entity-encoding trick will indeed fool many, if not most, address-harvesting bots, but it definitely won't fool all of them. It's better than nothing, but an address published in this way will probably eventually start receiving spam.)</p> <h3 id="backslash">Backslash Escapes</h3> <p>Markdown allows you to use backslash escapes to generate literal characters which would otherwise have special meaning in Markdown's formatting syntax. For example, if you wanted to surround a word with literal asterisks (instead of an HTML <code><em></code> tag), you can backslashes before the asterisks, like this:</p> <pre><code>\*literal asterisks\* </code></pre> <p>Markdown provides backslash escapes for the following characters:</p> <pre><code>\ backslash ` backtick * asterisk _ underscore {} curly braces [] square brackets () parentheses # hash mark + plus sign - minus sign (hyphen) . dot ! exclamation mark </code></pre>�������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������Markdown-2.4/tests/basic/markdown-syntax.txt��������������������������������������������������������0000666�0000000�0000000�00000067237�11756571171�017457� 0����������������������������������������������������������������������������������������������������ustar �����������������������������������������������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������Markdown: Syntax ================ <ul id="ProjectSubmenu"> <li><a href="/projects/markdown/" title="Markdown Project Page">Main</a></li> <li><a href="/projects/markdown/basics" title="Markdown Basics">Basics</a></li> <li><a class="selected" title="Markdown Syntax Documentation">Syntax</a></li> <li><a href="/projects/markdown/license" title="Pricing and License Information">License</a></li> <li><a href="/projects/markdown/dingus" title="Online Markdown Web Form">Dingus</a></li> </ul> * [Overview](#overview) * [Philosophy](#philosophy) * [Inline HTML](#html) * [Automatic Escaping for Special Characters](#autoescape) * [Block Elements](#block) * [Paragraphs and Line Breaks](#p) * [Headers](#header) * [Blockquotes](#blockquote) * [Lists](#list) * [Code Blocks](#precode) * [Horizontal Rules](#hr) * [Span Elements](#span) * [Links](#link) * [Emphasis](#em) * [Code](#code) * [Images](#img) * [Miscellaneous](#misc) * [Backslash Escapes](#backslash) * [Automatic Links](#autolink) **Note:** This document is itself written using Markdown; you can [see the source for it by adding '.text' to the URL][src]. [src]: /projects/markdown/syntax.text * * * <h2 id="overview">Overview</h2> <h3 id="philosophy">Philosophy</h3> Markdown is intended to be as easy-to-read and easy-to-write as is feasible. Readability, however, is emphasized above all else. A Markdown-formatted document should be publishable as-is, as plain text, without looking like it's been marked up with tags or formatting instructions. While Markdown's syntax has been influenced by several existing text-to-HTML filters -- including [Setext] [1], [atx] [2], [Textile] [3], [reStructuredText] [4], [Grutatext] [5], and [EtText] [6] -- the single biggest source of inspiration for Markdown's syntax is the format of plain text email. [1]: http://docutils.sourceforge.net/mirror/setext.html [2]: http://www.aaronsw.com/2002/atx/ [3]: http://textism.com/tools/textile/ [4]: http://docutils.sourceforge.net/rst.html [5]: http://www.triptico.com/software/grutatxt.html [6]: http://ettext.taint.org/doc/ To this end, Markdown's syntax is comprised entirely of punctuation characters, which punctuation characters have been carefully chosen so as to look like what they mean. E.g., asterisks around a word actually look like \*emphasis\*. Markdown lists look like, well, lists. Even blockquotes look like quoted passages of text, assuming you've ever used email. <h3 id="html">Inline HTML</h3> Markdown's syntax is intended for one purpose: to be used as a format for *writing* for the web. Markdown is not a replacement for HTML, or even close to it. Its syntax is very small, corresponding only to a very small subset of HTML tags. The idea is *not* to create a syntax that makes it easier to insert HTML tags. In my opinion, HTML tags are already easy to insert. The idea for Markdown is to make it easy to read, write, and edit prose. HTML is a *publishing* format; Markdown is a *writing* format. Thus, Markdown's formatting syntax only addresses issues that can be conveyed in plain text. For any markup that is not covered by Markdown's syntax, you simply use HTML itself. There's no need to preface it or delimit it to indicate that you're switching from Markdown to HTML; you just use the tags. The only restrictions are that block-level HTML elements -- e.g. `<div>`, `<table>`, `<pre>`, `<p>`, etc. -- must be separated from surrounding content by blank lines, and the start and end tags of the block should not be indented with tabs or spaces. Markdown is smart enough not to add extra (unwanted) `<p>` tags around HTML block-level tags. For example, to add an HTML table to a Markdown article: This is a regular paragraph. <table> <tr> <td>Foo</td> </tr> </table> This is another regular paragraph. Note that Markdown formatting syntax is not processed within block-level HTML tags. E.g., you can't use Markdown-style `*emphasis*` inside an HTML block. Span-level HTML tags -- e.g. `<span>`, `<cite>`, or `<del>` -- can be used anywhere in a Markdown paragraph, list item, or header. If you want, you can even use HTML tags instead of Markdown formatting; e.g. if you'd prefer to use HTML `<a>` or `<img>` tags instead of Markdown's link or image syntax, go right ahead. Unlike block-level HTML tags, Markdown syntax *is* processed within span-level tags. <h3 id="autoescape">Automatic Escaping for Special Characters</h3> In HTML, there are two characters that demand special treatment: `<` and `&`. Left angle brackets are used to start tags; ampersands are used to denote HTML entities. If you want to use them as literal characters, you must escape them as entities, e.g. `<`, and `&`. Ampersands in particular are bedeviling for web writers. If you want to write about 'AT&T', you need to write '`AT&T`'. You even need to escape ampersands within URLs. Thus, if you want to link to: http://images.google.com/images?num=30&q=larry+bird you need to encode the URL as: http://images.google.com/images?num=30&q=larry+bird in your anchor tag `href` attribute. Needless to say, this is easy to forget, and is probably the single most common source of HTML validation errors in otherwise well-marked-up web sites. Markdown allows you to use these characters naturally, taking care of all the necessary escaping for you. If you use an ampersand as part of an HTML entity, it remains unchanged; otherwise it will be translated into `&`. So, if you want to include a copyright symbol in your article, you can write: © and Markdown will leave it alone. But if you write: AT&T Markdown will translate it to: AT&T Similarly, because Markdown supports [inline HTML](#html), if you use angle brackets as delimiters for HTML tags, Markdown will treat them as such. But if you write: 4 < 5 Markdown will translate it to: 4 < 5 However, inside Markdown code spans and blocks, angle brackets and ampersands are *always* encoded automatically. This makes it easy to use Markdown to write about HTML code. (As opposed to raw HTML, which is a terrible format for writing about HTML syntax, because every single `<` and `&` in your example code needs to be escaped.) * * * <h2 id="block">Block Elements</h2> <h3 id="p">Paragraphs and Line Breaks</h3> A paragraph is simply one or more consecutive lines of text, separated by one or more blank lines. (A blank line is any line that looks like a blank line -- a line containing nothing but spaces or tabs is considered blank.) Normal paragraphs should not be intended with spaces or tabs. The implication of the "one or more consecutive lines of text" rule is that Markdown supports "hard-wrapped" text paragraphs. This differs significantly from most other text-to-HTML formatters (including Movable Type's "Convert Line Breaks" option) which translate every line break character in a paragraph into a `<br />` tag. When you *do* want to insert a `<br />` break tag using Markdown, you end a line with two or more spaces, then type return. Yes, this takes a tad more effort to create a `<br />`, but a simplistic "every line break is a `<br />`" rule wouldn't work for Markdown. Markdown's email-style [blockquoting][bq] and multi-paragraph [list items][l] work best -- and look better -- when you format them with hard breaks. [bq]: #blockquote [l]: #list <h3 id="header">Headers</h3> Markdown supports two styles of headers, [Setext] [1] and [atx] [2]. Setext-style headers are "underlined" using equal signs (for first-level headers) and dashes (for second-level headers). For example: This is an H1 ============= This is an H2 ------------- Any number of underlining `=`'s or `-`'s will work. Atx-style headers use 1-6 hash characters at the start of the line, corresponding to header levels 1-6. For example: # This is an H1 ## This is an H2 ###### This is an H6 Optionally, you may "close" atx-style headers. This is purely cosmetic -- you can use this if you think it looks better. The closing hashes don't even need to match the number of hashes used to open the header. (The number of opening hashes determines the header level.) : # This is an H1 # ## This is an H2 ## ### This is an H3 ###### <h3 id="blockquote">Blockquotes</h3> Markdown uses email-style `>` characters for blockquoting. If you're familiar with quoting passages of text in an email message, then you know how to create a blockquote in Markdown. It looks best if you hard wrap the text and put a `>` before every line: > This is a blockquote with two paragraphs. Lorem ipsum dolor sit amet, > consectetuer adipiscing elit. Aliquam hendrerit mi posuere lectus. > Vestibulum enim wisi, viverra nec, fringilla in, laoreet vitae, risus. > > Donec sit amet nisl. Aliquam semper ipsum sit amet velit. Suspendisse > id sem consectetuer libero luctus adipiscing. Markdown allows you to be lazy and only put the `>` before the first line of a hard-wrapped paragraph: > This is a blockquote with two paragraphs. Lorem ipsum dolor sit amet, consectetuer adipiscing elit. Aliquam hendrerit mi posuere lectus. Vestibulum enim wisi, viverra nec, fringilla in, laoreet vitae, risus. > Donec sit amet nisl. Aliquam semper ipsum sit amet velit. Suspendisse id sem consectetuer libero luctus adipiscing. Blockquotes can be nested (i.e. a blockquote-in-a-blockquote) by adding additional levels of `>`: > This is the first level of quoting. > > > This is nested blockquote. > > Back to the first level. Blockquotes can contain other Markdown elements, including headers, lists, and code blocks: > ## This is a header. > > 1. This is the first list item. > 2. This is the second list item. > > Here's some example code: > > return shell_exec("echo $input | $markdown_script"); Any decent text editor should make email-style quoting easy. For example, with BBEdit, you can make a selection and choose Increase Quote Level from the Text menu. <h3 id="list">Lists</h3> Markdown supports ordered (numbered) and unordered (bulleted) lists. Unordered lists use asterisks, pluses, and hyphens -- interchangably -- as list markers: * Red * Green * Blue is equivalent to: + Red + Green + Blue and: - Red - Green - Blue Ordered lists use numbers followed by periods: 1. Bird 2. McHale 3. Parish It's important to note that the actual numbers you use to mark the list have no effect on the HTML output Markdown produces. The HTML Markdown produces from the above list is: <ol> <li>Bird</li> <li>McHale</li> <li>Parish</li> </ol> If you instead wrote the list in Markdown like this: 1. Bird 1. McHale 1. Parish or even: 3. Bird 1. McHale 8. Parish you'd get the exact same HTML output. The point is, if you want to, you can use ordinal numbers in your ordered Markdown lists, so that the numbers in your source match the numbers in your published HTML. But if you want to be lazy, you don't have to. If you do use lazy list numbering, however, you should still start the list with the number 1. At some point in the future, Markdown may support starting ordered lists at an arbitrary number. List markers typically start at the left margin, but may be indented by up to three spaces. List markers must be followed by one or more spaces or a tab. To make lists look nice, you can wrap items with hanging indents: * Lorem ipsum dolor sit amet, consectetuer adipiscing elit. Aliquam hendrerit mi posuere lectus. Vestibulum enim wisi, viverra nec, fringilla in, laoreet vitae, risus. * Donec sit amet nisl. Aliquam semper ipsum sit amet velit. Suspendisse id sem consectetuer libero luctus adipiscing. But if you want to be lazy, you don't have to: * Lorem ipsum dolor sit amet, consectetuer adipiscing elit. Aliquam hendrerit mi posuere lectus. Vestibulum enim wisi, viverra nec, fringilla in, laoreet vitae, risus. * Donec sit amet nisl. Aliquam semper ipsum sit amet velit. Suspendisse id sem consectetuer libero luctus adipiscing. If list items are separated by blank lines, Markdown will wrap the items in `<p>` tags in the HTML output. For example, this input: * Bird * Magic will turn into: <ul> <li>Bird</li> <li>Magic</li> </ul> But this: * Bird * Magic will turn into: <ul> <li><p>Bird</p></li> <li><p>Magic</p></li> </ul> List items may consist of multiple paragraphs. Each subsequent paragraph in a list item must be intended by either 4 spaces or one tab: 1. This is a list item with two paragraphs. Lorem ipsum dolor sit amet, consectetuer adipiscing elit. Aliquam hendrerit mi posuere lectus. Vestibulum enim wisi, viverra nec, fringilla in, laoreet vitae, risus. Donec sit amet nisl. Aliquam semper ipsum sit amet velit. 2. Suspendisse id sem consectetuer libero luctus adipiscing. It looks nice if you indent every line of the subsequent paragraphs, but here again, Markdown will allow you to be lazy: * This is a list item with two paragraphs. This is the second paragraph in the list item. You're only required to indent the first line. Lorem ipsum dolor sit amet, consectetuer adipiscing elit. * Another item in the same list. To put a blockquote within a list item, the blockquote's `>` delimiters need to be indented: * A list item with a blockquote: > This is a blockquote > inside a list item. To put a code block within a list item, the code block needs to be indented *twice* -- 8 spaces or two tabs: * A list item with a code block: <code goes here> It's worth noting that it's possible to trigger an ordered list by accident, by writing something like this: 1986. What a great season. In other words, a *number-period-space* sequence at the beginning of a line. To avoid this, you can backslash-escape the period: 1986\. What a great season. <h3 id="precode">Code Blocks</h3> Pre-formatted code blocks are used for writing about programming or markup source code. Rather than forming normal paragraphs, the lines of a code block are interpreted literally. Markdown wraps a code block in both `<pre>` and `<code>` tags. To produce a code block in Markdown, simply indent every line of the block by at least 4 spaces or 1 tab. For example, given this input: This is a normal paragraph: This is a code block. Markdown will generate: <p>This is a normal paragraph:</p> <pre><code>This is a code block. </code></pre> One level of indentation -- 4 spaces or 1 tab -- is removed from each line of the code block. For example, this: Here is an example of AppleScript: tell application "Foo" beep end tell will turn into: <p>Here is an example of AppleScript:</p> <pre><code>tell application "Foo" beep end tell </code></pre> A code block continues until it reaches a line that is not indented (or the end of the article). Within a code block, ampersands (`&`) and angle brackets (`<` and `>`) are automatically converted into HTML entities. This makes it very easy to include example HTML source code using Markdown -- just paste it and indent it, and Markdown will handle the hassle of encoding the ampersands and angle brackets. For example, this: <div class="footer"> © 2004 Foo Corporation </div> will turn into: <pre><code><div class="footer"> &copy; 2004 Foo Corporation </div> </code></pre> Regular Markdown syntax is not processed within code blocks. E.g., asterisks are just literal asterisks within a code block. This means it's also easy to use Markdown to write about Markdown's own syntax. <h3 id="hr">Horizontal Rules</h3> You can produce a horizontal rule tag (`<hr />`) by placing three or more hyphens, asterisks, or underscores on a line by themselves. If you wish, you may use spaces between the hyphens or asterisks. Each of the following lines will produce a horizontal rule: * * * *** ***** - - - --------------------------------------- _ _ _ * * * <h2 id="span">Span Elements</h2> <h3 id="link">Links</h3> Markdown supports two style of links: *inline* and *reference*. In both styles, the link text is delimited by [square brackets]. To create an inline link, use a set of regular parentheses immediately after the link text's closing square bracket. Inside the parentheses, put the URL where you want the link to point, along with an *optional* title for the link, surrounded in quotes. For example: This is [an example](http://example.com/ "Title") inline link. [This link](http://example.net/) has no title attribute. Will produce: <p>This is <a href="http://example.com/" title="Title"> an example</a> inline link.</p> <p><a href="http://example.net/">This link</a> has no title attribute.</p> If you're referring to a local resource on the same server, you can use relative paths: See my [About](/about/) page for details. Reference-style links use a second set of square brackets, inside which you place a label of your choosing to identify the link: This is [an example][id] reference-style link. You can optionally use a space to separate the sets of brackets: This is [an example] [id] reference-style link. Then, anywhere in the document, you define your link label like this, on a line by itself: [id]: http://example.com/ "Optional Title Here" That is: * Square brackets containing the link identifier (optionally indented from the left margin using up to three spaces); * followed by a colon; * followed by one or more spaces (or tabs); * followed by the URL for the link; * optionally followed by a title attribute for the link, enclosed in double or single quotes. The link URL may, optionally, be surrounded by angle brackets: [id]: <http://example.com/> "Optional Title Here" You can put the title attribute on the next line and use extra spaces or tabs for padding, which tends to look better with longer URLs: [id]: http://example.com/longish/path/to/resource/here "Optional Title Here" Link definitions are only used for creating links during Markdown processing, and are stripped from your document in the HTML output. Link definition names may constist of letters, numbers, spaces, and punctuation -- but they are *not* case sensitive. E.g. these two links: [link text][a] [link text][A] are equivalent. The *implicit link name* shortcut allows you to omit the name of the link, in which case the link text itself is used as the name. Just use an empty set of square brackets -- e.g., to link the word "Google" to the google.com web site, you could simply write: [Google][] And then define the link: [Google]: http://google.com/ Because link names may contain spaces, this shortcut even works for multiple words in the link text: Visit [Daring Fireball][] for more information. And then define the link: [Daring Fireball]: http://daringfireball.net/ Link definitions can be placed anywhere in your Markdown document. I tend to put them immediately after each paragraph in which they're used, but if you want, you can put them all at the end of your document, sort of like footnotes. Here's an example of reference links in action: I get 10 times more traffic from [Google] [1] than from [Yahoo] [2] or [MSN] [3]. [1]: http://google.com/ "Google" [2]: http://search.yahoo.com/ "Yahoo Search" [3]: http://search.msn.com/ "MSN Search" Using the implicit link name shortcut, you could instead write: I get 10 times more traffic from [Google][] than from [Yahoo][] or [MSN][]. [google]: http://google.com/ "Google" [yahoo]: http://search.yahoo.com/ "Yahoo Search" [msn]: http://search.msn.com/ "MSN Search" Both of the above examples will produce the following HTML output: <p>I get 10 times more traffic from <a href="http://google.com/" title="Google">Google</a> than from <a href="http://search.yahoo.com/" title="Yahoo Search">Yahoo</a> or <a href="http://search.msn.com/" title="MSN Search">MSN</a>.</p> For comparison, here is the same paragraph written using Markdown's inline link style: I get 10 times more traffic from [Google](http://google.com/ "Google") than from [Yahoo](http://search.yahoo.com/ "Yahoo Search") or [MSN](http://search.msn.com/ "MSN Search"). The point of reference-style links is not that they're easier to write. The point is that with reference-style links, your document source is vastly more readable. Compare the above examples: using reference-style links, the paragraph itself is only 81 characters long; with inline-style links, it's 176 characters; and as raw HTML, it's 234 characters. In the raw HTML, there's more markup than there is text. With Markdown's reference-style links, a source document much more closely resembles the final output, as rendered in a browser. By allowing you to move the markup-related metadata out of the paragraph, you can add links without interrupting the narrative flow of your prose. <h3 id="em">Emphasis</h3> Markdown treats asterisks (`*`) and underscores (`_`) as indicators of emphasis. Text wrapped with one `*` or `_` will be wrapped with an HTML `<em>` tag; double `*`'s or `_`'s will be wrapped with an HTML `<strong>` tag. E.g., this input: *single asterisks* _single underscores_ **double asterisks** __double underscores__ will produce: <em>single asterisks</em> <em>single underscores</em> <strong>double asterisks</strong> <strong>double underscores</strong> You can use whichever style you prefer; the lone restriction is that the same character must be used to open and close an emphasis span. Emphasis can be used in the middle of a word: un*fucking*believable But if you surround an `*` or `_` with spaces, it'll be treated as a literal asterisk or underscore. To produce a literal asterisk or underscore at a position where it would otherwise be used as an emphasis delimiter, you can backslash escape it: \*this text is surrounded by literal asterisks\* <h3 id="code">Code</h3> To indicate a span of code, wrap it with backtick quotes (`` ` ``). Unlike a pre-formatted code block, a code span indicates code within a normal paragraph. For example: Use the `printf()` function. will produce: <p>Use the <code>printf()</code> function.</p> To include a literal backtick character within a code span, you can use multiple backticks as the opening and closing delimiters: ``There is a literal backtick (`) here.`` which will produce this: <p><code>There is a literal backtick (`) here.</code></p> The backtick delimiters surrounding a code span may include spaces -- one after the opening, one before the closing. This allows you to place literal backtick characters at the beginning or end of a code span: A single backtick in a code span: `` ` `` A backtick-delimited string in a code span: `` `foo` `` will produce: <p>A single backtick in a code span: <code>`</code></p> <p>A backtick-delimited string in a code span: <code>`foo`</code></p> With a code span, ampersands and angle brackets are encoded as HTML entities automatically, which makes it easy to include example HTML tags. Markdown will turn this: Please don't use any `<blink>` tags. into: <p>Please don't use any <code><blink></code> tags.</p> You can write this: `—` is the decimal-encoded equivalent of `—`. to produce: <p><code>&#8212;</code> is the decimal-encoded equivalent of <code>&mdash;</code>.</p> <h3 id="img">Images</h3> Admittedly, it's fairly difficult to devise a "natural" syntax for placing images into a plain text document format. Markdown uses an image syntax that is intended to resemble the syntax for links, allowing for two styles: *inline* and *reference*. Inline image syntax looks like this: ![Alt text](/path/to/img.jpg) ![Alt text](/path/to/img.jpg "Optional title") That is: * An exclamation mark: `!`; * followed by a set of square brackets, containing the `alt` attribute text for the image; * followed by a set of parentheses, containing the URL or path to the image, and an optional `title` attribute enclosed in double or single quotes. Reference-style image syntax looks like this: ![Alt text][id] Where "id" is the name of a defined image reference. Image references are defined using syntax identical to link references: [id]: url/to/image "Optional title attribute" As of this writing, Markdown has no syntax for specifying the dimensions of an image; if this is important to you, you can simply use regular HTML `<img>` tags. * * * <h2 id="misc">Miscellaneous</h2> <h3 id="autolink">Automatic Links</h3> Markdown supports a shortcut style for creating "automatic" links for URLs and email addresses: simply surround the URL or email address with angle brackets. What this means is that if you want to show the actual text of a URL or email address, and also have it be a clickable link, you can do this: <http://example.com/> Markdown will turn this into: <a href="http://example.com/">http://example.com/</a> Automatic links for email addresses work similarly, except that Markdown will also perform a bit of randomized decimal and hex entity-encoding to help obscure your address from address-harvesting spambots. For example, Markdown will turn this: <address@example.com> into something like this: <a href="mailto:addre ss@example.co m">address@exa mple.com</a> which will render in a browser as a clickable link to "address@example.com". (This sort of entity-encoding trick will indeed fool many, if not most, address-harvesting bots, but it definitely won't fool all of them. It's better than nothing, but an address published in this way will probably eventually start receiving spam.) <h3 id="backslash">Backslash Escapes</h3> Markdown allows you to use backslash escapes to generate literal characters which would otherwise have special meaning in Markdown's formatting syntax. For example, if you wanted to surround a word with literal asterisks (instead of an HTML `<em>` tag), you can backslashes before the asterisks, like this: \*literal asterisks\* Markdown provides backslash escapes for the following characters: \ backslash ` backtick * asterisk _ underscore {} curly braces [] square brackets () parentheses # hash mark + plus sign - minus sign (hyphen) . dot ! exclamation mark �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������Markdown-2.4/tests/basic/nested-blockquotes.html����������������������������������������������������0000666�0000000�0000000�00000000134�11756571171�020230� 0����������������������������������������������������������������������������������������������������ustar �����������������������������������������������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������<blockquote> <p>foo</p> <blockquote> <p>bar</p> </blockquote> <p>foo</p> </blockquote>������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������Markdown-2.4/tests/basic/nested-blockquotes.txt�����������������������������������������������������0000666�0000000�0000000�00000000035�11756571171�020103� 0����������������������������������������������������������������������������������������������������ustar �����������������������������������������������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������> foo > > > bar > > foo ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������Markdown-2.4/tests/basic/ordered-and-unordered-list.html��������������������������������������������0000666�0000000�0000000�00000003313�11756571171�021541� 0����������������������������������������������������������������������������������������������������ustar �����������������������������������������������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������<h2>Unordered</h2> <p>Asterisks tight:</p> <ul> <li>asterisk 1</li> <li>asterisk 2</li> <li>asterisk 3</li> </ul> <p>Asterisks loose:</p> <ul> <li> <p>asterisk 1</p> </li> <li> <p>asterisk 2</p> </li> <li> <p>asterisk 3</p> </li> </ul> <hr /> <p>Pluses tight:</p> <ul> <li>Plus 1</li> <li>Plus 2</li> <li>Plus 3</li> </ul> <p>Pluses loose:</p> <ul> <li> <p>Plus 1</p> </li> <li> <p>Plus 2</p> </li> <li> <p>Plus 3</p> </li> </ul> <hr /> <p>Minuses tight:</p> <ul> <li>Minus 1</li> <li>Minus 2</li> <li>Minus 3</li> </ul> <p>Minuses loose:</p> <ul> <li> <p>Minus 1</p> </li> <li> <p>Minus 2</p> </li> <li> <p>Minus 3</p> </li> </ul> <h2>Ordered</h2> <p>Tight:</p> <ol> <li>First</li> <li>Second</li> <li>Third</li> </ol> <p>and:</p> <ol> <li>One</li> <li>Two</li> <li>Three</li> </ol> <p>Loose using tabs:</p> <ol> <li> <p>First</p> </li> <li> <p>Second</p> </li> <li> <p>Third</p> </li> </ol> <p>and using spaces:</p> <ol> <li> <p>One</p> </li> <li> <p>Two</p> </li> <li> <p>Three</p> </li> </ol> <p>Multiple paragraphs:</p> <ol> <li> <p>Item 1, graf one.</p> <p>Item 2. graf two. The quick brown fox jumped over the lazy dog's back.</p> </li> <li> <p>Item 2.</p> </li> <li> <p>Item 3.</p> </li> </ol> <h2>Nested</h2> <ul> <li>Tab<ul> <li>Tab<ul> <li>Tab</li> </ul> </li> </ul> </li> </ul> <p>Here's another:</p> <ol> <li>First</li> <li>Second:<ul> <li>Fee</li> <li>Fie</li> <li>Foe</li> </ul> </li> <li>Third</li> </ol> <p>Same thing but with paragraphs:</p> <ol> <li> <p>First</p> </li> <li> <p>Second:</p> <ul> <li>Fee</li> <li>Fie</li> <li>Foe</li> </ul> </li> <li> <p>Third</p> </li> </ol>���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������Markdown-2.4/tests/basic/ordered-and-unordered-list.txt���������������������������������������������0000666�0000000�0000000�00000001703�11756571171�021415� 0����������������������������������������������������������������������������������������������������ustar �����������������������������������������������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������## Unordered Asterisks tight: * asterisk 1 * asterisk 2 * asterisk 3 Asterisks loose: * asterisk 1 * asterisk 2 * asterisk 3 * * * Pluses tight: + Plus 1 + Plus 2 + Plus 3 Pluses loose: + Plus 1 + Plus 2 + Plus 3 * * * Minuses tight: - Minus 1 - Minus 2 - Minus 3 Minuses loose: - Minus 1 - Minus 2 - Minus 3 ## Ordered Tight: 1. First 2. Second 3. Third and: 1. One 2. Two 3. Three Loose using tabs: 1. First 2. Second 3. Third and using spaces: 1. One 2. Two 3. Three Multiple paragraphs: 1. Item 1, graf one. Item 2. graf two. The quick brown fox jumped over the lazy dog's back. 2. Item 2. 3. Item 3. ## Nested * Tab * Tab * Tab Here's another: 1. First 2. Second: * Fee * Fie * Foe 3. Third Same thing but with paragraphs: 1. First 2. Second: * Fee * Fie * Foe 3. Third �������������������������������������������������������������Markdown-2.4/tests/basic/strong-and-em-together.html������������������������������������������������0000666�0000000�0000000�00000000326�11756571171�020712� 0����������������������������������������������������������������������������������������������������ustar �����������������������������������������������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������<p><strong><em>This is strong and em.</em></strong></p> <p>So is <strong><em>this</em></strong> word.</p> <p><strong><em>This is strong and em.</em></strong></p> <p>So is <strong><em>this</em></strong> word.</p>����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������Markdown-2.4/tests/basic/strong-and-em-together.txt�������������������������������������������������0000666�0000000�0000000�00000000162�11756571171�020563� 0����������������������������������������������������������������������������������������������������ustar �����������������������������������������������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������***This is strong and em.*** So is ***this*** word. ___This is strong and em.___ So is ___this___ word. ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������Markdown-2.4/tests/basic/tabs.html������������������������������������������������������������������0000666�0000000�0000000�00000000722�11756571171�015351� 0����������������������������������������������������������������������������������������������������ustar �����������������������������������������������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������<ul> <li> <p>this is a list item indented with tabs</p> </li> <li> <p>this is a list item indented with spaces</p> </li> </ul> <p>Code:</p> <pre><code>this code block is indented by one tab </code></pre> <p>And:</p> <pre><code> this code block is indented by two tabs </code></pre> <p>And:</p> <pre><code>+ this is an example list item indented with tabs + this is an example list item indented with spaces </code></pre>����������������������������������������������Markdown-2.4/tests/basic/tabs.txt�������������������������������������������������������������������0000666�0000000�0000000�00000000514�11756571171�015223� 0����������������������������������������������������������������������������������������������������ustar �����������������������������������������������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������+ this is a list item indented with tabs + this is a list item indented with spaces Code: this code block is indented by one tab And: this code block is indented by two tabs And: + this is an example list item indented with tabs + this is an example list item indented with spaces ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������Markdown-2.4/tests/basic/tidyness.html��������������������������������������������������������������0000666�0000000�0000000�00000000213�11756571172�016256� 0����������������������������������������������������������������������������������������������������ustar �����������������������������������������������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������<blockquote> <p>A list within a blockquote:</p> <ul> <li>asterisk 1</li> <li>asterisk 2</li> <li>asterisk 3</li> </ul> </blockquote>�������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������Markdown-2.4/tests/basic/tidyness.txt���������������������������������������������������������������0000666�0000000�0000000�00000000123�11756571172�016131� 0����������������������������������������������������������������������������������������������������ustar �����������������������������������������������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������> A list within a blockquote: > > * asterisk 1 > * asterisk 2 > * asterisk 3 ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������Markdown-2.4/tests/extensions/����������������������������������������������������������������������0000777�0000000�0000000�00000000000�12300213221�014616� 5����������������������������������������������������������������������������������������������������ustar �����������������������������������������������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������Markdown-2.4/tests/extensions/admonition.html�������������������������������������������������������0000666�0000000�0000000�00000001447�12111563047�017671� 0����������������������������������������������������������������������������������������������������ustar �����������������������������������������������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������<p>Some text</p> <div class="admonition note"> <p class="admonition-title">Note</p> <p>A normal paragraph here</p> <ol> <li>first</li> <li>second</li> </ol> <blockquote> <p>Some important quote</p> <p>another paragraph in the quote</p> </blockquote> <pre><code>int main() { // insert some code } </code></pre> </div> <p>More text and stuff.</p> <div class="admonition note"> <p class="admonition-title">Did you know?</p> <p>You can customize the title of the admonition</p> </div> <div class="admonition mycustomcssclass"> <p class="admonition-title">And now...</p> <p>For something completely different.</p> <p>You can also use a custom CSS class name.</p> </div> <div class="admonition tip"> <p>An explicitly empty string prevents the title from being rendered.</p> </div>�������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������Markdown-2.4/tests/extensions/admonition.txt��������������������������������������������������������0000666�0000000�0000000�00000001031�12111563047�017531� 0����������������������������������������������������������������������������������������������������ustar �����������������������������������������������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������Some text !!! note A normal paragraph here 1. first 2. second > Some important quote > another paragraph in the quote int main() { // insert some code } More text and stuff. !!! Note "Did you know?" You can customize the title of the admonition !!! mycustomcssclass "And now..." For something completely different. You can also use a custom CSS class name. !!! tip "" An explicitly empty string prevents the title from being rendered. �������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������Markdown-2.4/tests/extensions/attr_list.html��������������������������������������������������������0000666�0000000�0000000�00000003561�12261107557�017542� 0����������������������������������������������������������������������������������������������������ustar �����������������������������������������������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������<h1 id="setext">This is a sextext header</h1> <p class="myclass" id="par1">A paragraph with some text. Line two of the paragraph.</p> <h2 class="someclass" id="sextext2">This is another</h2> <p>Test some <em class="inline">inline</em> text. A <a class="linkkyclass" href="http://example.com" title="A title.">link</a> And a <strong class="nest">nested <a class="linky2" href="http://example.com" title="Some title">link</a></strong></p> <h3 id="hash">This is a hash Header</h3> <p bar="b az" baz="blah blah" foo="foo" title="I wasn't kidding!">And now some random attributes.</p> <h3 id="hash2">No closing hash header</h3> <p class="foo bar addme" id="overridden">Now test overrides</p> <pre><code># A code block which contains attr_list syntax # This should be ignored. {: #someid .someclass } </code></pre> <h3 id="hash3">No colon for compatability with Headerid ext</h3> <p id="the_end">Also a codespan: <code class="foo">{: .someclass}</code>.</p> <h3 _:="{:" id="hash5">Bad Syntax</h3> <ul> <li class="item">Item1</li> <li class="item">Item2<ul> <li class="subitem">Item2-1</li> </ul> </li> <li class="item"><em class="emph">Item3</em><ul> <li class="subitem"><em class="emph">Item3-1</em></li> </ul> </li> <li>Item4<ul> <li>Item4-1</li> </ul> </li> <li>Item5</li> </ul> <h1>And ordered lists <em class="inline">too</em></h1> <ol> <li class="item">Item1</li> <li class="item">Item2<ol> <li class="subitem">Item2-1</li> </ol> </li> <li class="item"><em class="emph">Item3</em><ol> <li class="subitem"><em class="emph">Item3-1</em></li> </ol> </li> <li>Item4<ol> <li>Item4-1</li> </ol> </li> <li>Item5</li> </ol> <h1 class="block">Definition <em>lists</em></h1> <dl> <dt class="term">DT1</dt> <dt class="term">DT2</dt> <dd class="def">Some dd</dd> <dd><em class="inline">dd</em></dd> <dt><em class="inline">DT3</em></dt> <dd>Some dd</dd> </dl>�����������������������������������������������������������������������������������������������������������������������������������������������Markdown-2.4/tests/extensions/attr_list.txt���������������������������������������������������������0000666�0000000�0000000�00000003025�12261107557�017410� 0����������������������������������������������������������������������������������������������������ustar �����������������������������������������������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������This is a sextext header {: #setext} ==================================== A paragraph with some text. Line two of the paragraph. {: #par1 .myclass } This is another {: #sextext2 .someclass} ---------------------------------------- Test some _inline_{: .inline} text. A [link](http://example.com){: .linkkyclass title="A title."} And a __nested [link][]{: .linky2}__{: .nest} [link]: http://example.com "Some title" ### This is a hash Header ### {: #hash} And now some random attributes. {:foo bar='b az' baz="blah blah" title="I wasn't kidding!" } ### No closing hash header {: #hash2} Now test overrides {: #overrideme .andme id=overridden class='foo bar' .addme } # A code block which contains attr_list syntax # This should be ignored. {: #someid .someclass } ### No colon for compatability with Headerid ext { #hash3 } Also a codespan: `{: .someclass}`{: .foo}. {: #the_end} ### Bad Syntax { {: #hash5 } * Item1 {: .item } * Item2 {: .item } * Item2-1 {: .subitem } * _Item3_{: .emph } {: .item } * _Item3-1_{: .emph } {: .subitem } * Item4 * Item4-1 * Item5 # And ordered lists *too*{.inline} 1. Item1 {: .item } 2. Item2 {: .item } 1. Item2-1 {: .subitem } 3. _Item3_{: .emph } {: .item } 1. _Item3-1_{: .emph } {: .subitem } 4. Item4 1. Item4-1 5. Item5 # Definition *lists* {.block} DT1 {.term} DT2 {.term} : Some dd {.def} : *dd*{.inline} *DT3*{.inline} : Some dd �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������Markdown-2.4/tests/extensions/codehilite.html�������������������������������������������������������0000666�0000000�0000000�00000002517�11756571172�017654� 0����������������������������������������������������������������������������������������������������ustar �����������������������������������������������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������<p>Some text</p> <table class="codehilitetable"><tr><td class="linenos"><pre>1 2 3 4 5 6</pre></td><td class="code"><div class="codehilite"><pre><span class="k">def</span> <span class="nf">__init__</span> <span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">pattern</span><span class="p">)</span> <span class="p">:</span> <span class="bp">self</span><span class="o">.</span><span class="n">pattern</span> <span class="o">=</span> <span class="n">pattern</span> <span class="bp">self</span><span class="o">.</span><span class="n">compiled_re</span> <span class="o">=</span> <span class="n">re</span><span class="o">.</span><span class="n">compile</span><span class="p">(</span><span class="s">"^(.*)</span><span class="si">%s</span><span class="s">(.*)$"</span> <span class="o">%</span> <span class="n">pattern</span><span class="p">,</span> <span class="n">re</span><span class="o">.</span><span class="n">DOTALL</span><span class="p">)</span> <span class="k">def</span> <span class="nf">getCompiledRegExp</span> <span class="p">(</span><span class="bp">self</span><span class="p">)</span> <span class="p">:</span> <span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">compiled_re</span> </pre></div> </td></tr></table> <p>More text</p>���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������Markdown-2.4/tests/extensions/codehilite.txt��������������������������������������������������������0000666�0000000�0000000�00000000377�11756571172�017531� 0����������������������������������������������������������������������������������������������������ustar �����������������������������������������������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������ Some text #!python def __init__ (self, pattern) : self.pattern = pattern self.compiled_re = re.compile("^(.*)%s(.*)$" % pattern, re.DOTALL) def getCompiledRegExp (self) : return self.compiled_re More text�����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������Markdown-2.4/tests/extensions/extra/����������������������������������������������������������������0000777�0000000�0000000�00000000000�12300213222�015742� 5����������������������������������������������������������������������������������������������������ustar �����������������������������������������������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������Markdown-2.4/tests/extensions/extra/abbr.html�������������������������������������������������������0000666�0000000�0000000�00000000426�11756571172�017571� 0����������������������������������������������������������������������������������������������������ustar �����������������������������������������������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������<p>An <abbr title="Abbreviation">ABBR</abbr>: "<abbr title="Reference">REF</abbr>". ref and REFERENCE should be ignored.</p> <p>The <abbr title="Hyper Text Markup Language">HTML</abbr> specification is maintained by the <abbr title="World Wide Web Consortium">W3C</abbr>.</p>������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������Markdown-2.4/tests/extensions/extra/abbr.txt��������������������������������������������������������0000666�0000000�0000000�00000000424�11756571172�017442� 0����������������������������������������������������������������������������������������������������ustar �����������������������������������������������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������An ABBR: "REF". ref and REFERENCE should be ignored. *[REF]: Reference *[ABBR]: This gets overriden by the next one. *[ABBR]: Abbreviation The HTML specification is maintained by the W3C. *[HTML]: Hyper Text Markup Language *[W3C]: World Wide Web Consortium ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������Markdown-2.4/tests/extensions/extra/def-in-list.html������������������������������������������������0000666�0000000�0000000�00000000530�12111563047�020756� 0����������������������������������������������������������������������������������������������������ustar �����������������������������������������������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������<p>: a paragraph that starts with a colon</p> <ul> <li>A List item</li> <li> <dl> <dt>A def term</dt> <dd>A def item</dd> <dd>a second</dd> </dl> </li> <li> <dl> <dt>Another def term</dt> <dd> <p>a loose item</p> </dd> <dd> <p>a second</p> </dd> </dl> </li> <li> <p>: a list item that starts with a colon</p> </li> </ul>������������������������������������������������������������������������������������������������������������������������������������������������������������������������Markdown-2.4/tests/extensions/extra/def-in-list.txt�������������������������������������������������0000666�0000000�0000000�00000000335�12111563047�020634� 0����������������������������������������������������������������������������������������������������ustar �����������������������������������������������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������: a paragraph that starts with a colon * A List item * A def term : A def item : a second * Another def term : a loose item : a second * : a list item that starts with a colon ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������Markdown-2.4/tests/extensions/extra/footnote.html���������������������������������������������������0000666�0000000�0000000�00000003151�12111563027�020500� 0����������������������������������������������������������������������������������������������������ustar �����������������������������������������������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������<p>This is the body with a footnote<sup id="fnref:1"><a class="footnote-ref" href="#fn:1" rel="footnote">1</a></sup> or two<sup id="fnref:2"><a class="footnote-ref" href="#fn:2" rel="footnote">2</a></sup> or more<sup id="fnref:3"><a class="footnote-ref" href="#fn:3" rel="footnote">3</a></sup> <sup id="fnref:4"><a class="footnote-ref" href="#fn:4" rel="footnote">4</a></sup> <sup id="fnref:5"><a class="footnote-ref" href="#fn:5" rel="footnote">5</a></sup>.</p> <p>Also a reference that does not exist[^6].</p> <div class="footnote"> <hr /> <ol> <li id="fn:1"> <p>Footnote that ends with a list:</p> <ul> <li>item 1</li> <li>item 2</li> </ul> <p><a class="footnote-backref" href="#fnref:1" rev="footnote" title="Jump back to footnote 1 in the text">↩</a></p> </li> <li id="fn:2"> <blockquote> <p>This footnote is a blockquote.</p> </blockquote> <p><a class="footnote-backref" href="#fnref:2" rev="footnote" title="Jump back to footnote 2 in the text">↩</a></p> </li> <li id="fn:3"> <p>A simple oneliner. <a class="footnote-backref" href="#fnref:3" rev="footnote" title="Jump back to footnote 3 in the text">↩</a></p> </li> <li id="fn:4"> <p>A footnote with multiple paragraphs.</p> <p>Paragraph two. <a class="footnote-backref" href="#fnref:4" rev="footnote" title="Jump back to footnote 4 in the text">↩</a></p> </li> <li id="fn:5"> <p>First line of first paragraph. Second line of first paragraph is not intended. Nor is third... <a class="footnote-backref" href="#fnref:5" rev="footnote" title="Jump back to footnote 5 in the text">↩</a></p> </li> </ol> </div>�����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������Markdown-2.4/tests/extensions/extra/footnote.txt����������������������������������������������������0000666�0000000�0000000�00000000660�11756571172�020373� 0����������������������������������������������������������������������������������������������������ustar �����������������������������������������������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������This is the body with a footnote[^1] or two[^2] or more[^3] [^4] [^5]. Also a reference that does not exist[^6]. [^1]: Footnote that ends with a list: * item 1 * item 2 [^2]: > This footnote is a blockquote. [^3]: A simple oneliner. [^4]: A footnote with multiple paragraphs. Paragraph two. [^5]: First line of first paragraph. Second line of first paragraph is not intended. Nor is third... ��������������������������������������������������������������������������������Markdown-2.4/tests/extensions/extra/footnote_many_footnotes.html������������������������������������0000666�0000000�0000000�00001207407�12111563027�023637� 0����������������������������������������������������������������������������������������������������ustar �����������������������������������������������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������<p>Something<sup id="fnref:1"><a class="footnote-ref" href="#fn:1" rel="footnote">1</a></sup></p> <p>Something<sup id="fnref:2"><a class="footnote-ref" href="#fn:2" rel="footnote">2</a></sup></p> <p>Something<sup id="fnref:3"><a class="footnote-ref" href="#fn:3" rel="footnote">3</a></sup></p> <p>Something<sup id="fnref:4"><a class="footnote-ref" href="#fn:4" rel="footnote">4</a></sup></p> <p>Something<sup id="fnref:5"><a class="footnote-ref" href="#fn:5" rel="footnote">5</a></sup></p> <p>Something<sup id="fnref:6"><a class="footnote-ref" href="#fn:6" rel="footnote">6</a></sup></p> <p>Something<sup id="fnref:7"><a class="footnote-ref" href="#fn:7" rel="footnote">7</a></sup></p> <p>Something<sup id="fnref:8"><a class="footnote-ref" href="#fn:8" rel="footnote">8</a></sup></p> <p>Something<sup id="fnref:9"><a class="footnote-ref" href="#fn:9" rel="footnote">9</a></sup></p> <p>Something<sup id="fnref:10"><a class="footnote-ref" href="#fn:10" rel="footnote">10</a></sup></p> <p>Something<sup id="fnref:11"><a class="footnote-ref" href="#fn:11" rel="footnote">11</a></sup></p> <p>Something<sup id="fnref:12"><a class="footnote-ref" href="#fn:12" rel="footnote">12</a></sup></p> <p>Something<sup id="fnref:13"><a class="footnote-ref" href="#fn:13" rel="footnote">13</a></sup></p> <p>Something<sup id="fnref:14"><a class="footnote-ref" href="#fn:14" rel="footnote">14</a></sup></p> <p>Something<sup id="fnref:15"><a class="footnote-ref" href="#fn:15" rel="footnote">15</a></sup></p> <p>Something<sup id="fnref:16"><a class="footnote-ref" href="#fn:16" rel="footnote">16</a></sup></p> <p>Something<sup id="fnref:17"><a class="footnote-ref" href="#fn:17" rel="footnote">17</a></sup></p> <p>Something<sup id="fnref:18"><a class="footnote-ref" href="#fn:18" rel="footnote">18</a></sup></p> <p>Something<sup id="fnref:19"><a class="footnote-ref" href="#fn:19" rel="footnote">19</a></sup></p> <p>Something<sup id="fnref:20"><a class="footnote-ref" href="#fn:20" rel="footnote">20</a></sup></p> <p>Something<sup id="fnref:21"><a class="footnote-ref" href="#fn:21" rel="footnote">21</a></sup></p> <p>Something<sup id="fnref:22"><a class="footnote-ref" href="#fn:22" rel="footnote">22</a></sup></p> <p>Something<sup id="fnref:23"><a class="footnote-ref" href="#fn:23" rel="footnote">23</a></sup></p> <p>Something<sup id="fnref:24"><a class="footnote-ref" href="#fn:24" rel="footnote">24</a></sup></p> <p>Something<sup id="fnref:25"><a class="footnote-ref" href="#fn:25" rel="footnote">25</a></sup></p> <p>Something<sup id="fnref:26"><a class="footnote-ref" href="#fn:26" rel="footnote">26</a></sup></p> <p>Something<sup id="fnref:27"><a class="footnote-ref" href="#fn:27" rel="footnote">27</a></sup></p> <p>Something<sup id="fnref:28"><a class="footnote-ref" href="#fn:28" rel="footnote">28</a></sup></p> <p>Something<sup id="fnref:29"><a class="footnote-ref" href="#fn:29" rel="footnote">29</a></sup></p> <p>Something<sup id="fnref:30"><a class="footnote-ref" href="#fn:30" rel="footnote">30</a></sup></p> <p>Something<sup id="fnref:31"><a class="footnote-ref" href="#fn:31" rel="footnote">31</a></sup></p> <p>Something<sup id="fnref:32"><a class="footnote-ref" href="#fn:32" rel="footnote">32</a></sup></p> <p>Something<sup id="fnref:33"><a class="footnote-ref" href="#fn:33" rel="footnote">33</a></sup></p> <p>Something<sup id="fnref:34"><a class="footnote-ref" href="#fn:34" rel="footnote">34</a></sup></p> <p>Something<sup id="fnref:35"><a class="footnote-ref" href="#fn:35" rel="footnote">35</a></sup></p> <p>Something<sup id="fnref:36"><a class="footnote-ref" href="#fn:36" rel="footnote">36</a></sup></p> <p>Something<sup id="fnref:37"><a class="footnote-ref" href="#fn:37" rel="footnote">37</a></sup></p> <p>Something<sup id="fnref:38"><a class="footnote-ref" href="#fn:38" rel="footnote">38</a></sup></p> <p>Something<sup id="fnref:39"><a class="footnote-ref" href="#fn:39" rel="footnote">39</a></sup></p> <p>Something<sup id="fnref:40"><a class="footnote-ref" href="#fn:40" rel="footnote">40</a></sup></p> <p>Something<sup id="fnref:41"><a class="footnote-ref" href="#fn:41" rel="footnote">41</a></sup></p> <p>Something<sup id="fnref:42"><a class="footnote-ref" href="#fn:42" rel="footnote">42</a></sup></p> <p>Something<sup id="fnref:43"><a class="footnote-ref" href="#fn:43" rel="footnote">43</a></sup></p> <p>Something<sup id="fnref:44"><a class="footnote-ref" href="#fn:44" rel="footnote">44</a></sup></p> <p>Something<sup id="fnref:45"><a class="footnote-ref" href="#fn:45" rel="footnote">45</a></sup></p> <p>Something<sup id="fnref:46"><a class="footnote-ref" href="#fn:46" rel="footnote">46</a></sup></p> <p>Something<sup id="fnref:47"><a class="footnote-ref" href="#fn:47" rel="footnote">47</a></sup></p> <p>Something<sup id="fnref:48"><a class="footnote-ref" href="#fn:48" rel="footnote">48</a></sup></p> <p>Something<sup id="fnref:49"><a class="footnote-ref" href="#fn:49" rel="footnote">49</a></sup></p> <p>Something<sup id="fnref:50"><a class="footnote-ref" href="#fn:50" rel="footnote">50</a></sup></p> <p>Something<sup id="fnref:51"><a class="footnote-ref" href="#fn:51" rel="footnote">51</a></sup></p> <p>Something<sup id="fnref:52"><a class="footnote-ref" href="#fn:52" rel="footnote">52</a></sup></p> <p>Something<sup id="fnref:53"><a class="footnote-ref" href="#fn:53" rel="footnote">53</a></sup></p> <p>Something<sup id="fnref:54"><a class="footnote-ref" href="#fn:54" rel="footnote">54</a></sup></p> <p>Something<sup id="fnref:55"><a class="footnote-ref" href="#fn:55" rel="footnote">55</a></sup></p> <p>Something<sup id="fnref:56"><a class="footnote-ref" href="#fn:56" rel="footnote">56</a></sup></p> <p>Something<sup id="fnref:57"><a class="footnote-ref" href="#fn:57" rel="footnote">57</a></sup></p> <p>Something<sup id="fnref:58"><a class="footnote-ref" href="#fn:58" rel="footnote">58</a></sup></p> <p>Something<sup id="fnref:59"><a class="footnote-ref" href="#fn:59" rel="footnote">59</a></sup></p> <p>Something<sup id="fnref:60"><a class="footnote-ref" href="#fn:60" rel="footnote">60</a></sup></p> <p>Something<sup id="fnref:61"><a class="footnote-ref" href="#fn:61" rel="footnote">61</a></sup></p> <p>Something<sup id="fnref:62"><a class="footnote-ref" href="#fn:62" rel="footnote">62</a></sup></p> <p>Something<sup id="fnref:63"><a class="footnote-ref" href="#fn:63" rel="footnote">63</a></sup></p> <p>Something<sup id="fnref:64"><a class="footnote-ref" href="#fn:64" rel="footnote">64</a></sup></p> <p>Something<sup id="fnref:65"><a class="footnote-ref" href="#fn:65" rel="footnote">65</a></sup></p> <p>Something<sup id="fnref:66"><a class="footnote-ref" href="#fn:66" rel="footnote">66</a></sup></p> <p>Something<sup id="fnref:67"><a class="footnote-ref" href="#fn:67" rel="footnote">67</a></sup></p> <p>Something<sup id="fnref:68"><a class="footnote-ref" href="#fn:68" rel="footnote">68</a></sup></p> <p>Something<sup id="fnref:69"><a class="footnote-ref" href="#fn:69" rel="footnote">69</a></sup></p> <p>Something<sup id="fnref:70"><a class="footnote-ref" href="#fn:70" rel="footnote">70</a></sup></p> <p>Something<sup id="fnref:71"><a class="footnote-ref" href="#fn:71" rel="footnote">71</a></sup></p> <p>Something<sup id="fnref:72"><a class="footnote-ref" href="#fn:72" rel="footnote">72</a></sup></p> <p>Something<sup id="fnref:73"><a class="footnote-ref" href="#fn:73" rel="footnote">73</a></sup></p> <p>Something<sup id="fnref:74"><a class="footnote-ref" href="#fn:74" rel="footnote">74</a></sup></p> <p>Something<sup id="fnref:75"><a class="footnote-ref" href="#fn:75" rel="footnote">75</a></sup></p> <p>Something<sup id="fnref:76"><a class="footnote-ref" href="#fn:76" rel="footnote">76</a></sup></p> <p>Something<sup id="fnref:77"><a class="footnote-ref" href="#fn:77" rel="footnote">77</a></sup></p> <p>Something<sup id="fnref:78"><a class="footnote-ref" href="#fn:78" rel="footnote">78</a></sup></p> <p>Something<sup id="fnref:79"><a class="footnote-ref" href="#fn:79" rel="footnote">79</a></sup></p> <p>Something<sup id="fnref:80"><a class="footnote-ref" href="#fn:80" rel="footnote">80</a></sup></p> <p>Something<sup id="fnref:81"><a class="footnote-ref" href="#fn:81" rel="footnote">81</a></sup></p> <p>Something<sup id="fnref:82"><a class="footnote-ref" href="#fn:82" rel="footnote">82</a></sup></p> <p>Something<sup id="fnref:83"><a class="footnote-ref" href="#fn:83" rel="footnote">83</a></sup></p> <p>Something<sup id="fnref:84"><a class="footnote-ref" href="#fn:84" rel="footnote">84</a></sup></p> <p>Something<sup id="fnref:85"><a class="footnote-ref" href="#fn:85" rel="footnote">85</a></sup></p> <p>Something<sup id="fnref:86"><a class="footnote-ref" href="#fn:86" rel="footnote">86</a></sup></p> <p>Something<sup id="fnref:87"><a class="footnote-ref" href="#fn:87" rel="footnote">87</a></sup></p> <p>Something<sup id="fnref:88"><a class="footnote-ref" href="#fn:88" rel="footnote">88</a></sup></p> <p>Something<sup id="fnref:89"><a class="footnote-ref" href="#fn:89" rel="footnote">89</a></sup></p> <p>Something<sup id="fnref:90"><a class="footnote-ref" href="#fn:90" rel="footnote">90</a></sup></p> <p>Something<sup id="fnref:91"><a class="footnote-ref" href="#fn:91" rel="footnote">91</a></sup></p> <p>Something<sup id="fnref:92"><a class="footnote-ref" href="#fn:92" rel="footnote">92</a></sup></p> <p>Something<sup id="fnref:93"><a class="footnote-ref" href="#fn:93" rel="footnote">93</a></sup></p> <p>Something<sup id="fnref:94"><a class="footnote-ref" href="#fn:94" rel="footnote">94</a></sup></p> <p>Something<sup id="fnref:95"><a class="footnote-ref" href="#fn:95" rel="footnote">95</a></sup></p> <p>Something<sup id="fnref:96"><a class="footnote-ref" href="#fn:96" rel="footnote">96</a></sup></p> <p>Something<sup id="fnref:97"><a class="footnote-ref" href="#fn:97" rel="footnote">97</a></sup></p> <p>Something<sup id="fnref:98"><a class="footnote-ref" href="#fn:98" rel="footnote">98</a></sup></p> <p>Something<sup id="fnref:99"><a class="footnote-ref" href="#fn:99" rel="footnote">99</a></sup></p> <p>Something<sup id="fnref:100"><a class="footnote-ref" href="#fn:100" rel="footnote">100</a></sup></p> <p>Something<sup id="fnref:101"><a class="footnote-ref" href="#fn:101" rel="footnote">101</a></sup></p> <p>Something<sup id="fnref:102"><a class="footnote-ref" href="#fn:102" rel="footnote">102</a></sup></p> <p>Something<sup id="fnref:103"><a class="footnote-ref" href="#fn:103" rel="footnote">103</a></sup></p> <p>Something<sup id="fnref:104"><a class="footnote-ref" href="#fn:104" rel="footnote">104</a></sup></p> <p>Something<sup id="fnref:105"><a class="footnote-ref" href="#fn:105" rel="footnote">105</a></sup></p> <p>Something<sup id="fnref:106"><a class="footnote-ref" href="#fn:106" rel="footnote">106</a></sup></p> <p>Something<sup id="fnref:107"><a class="footnote-ref" href="#fn:107" rel="footnote">107</a></sup></p> <p>Something<sup id="fnref:108"><a class="footnote-ref" href="#fn:108" rel="footnote">108</a></sup></p> <p>Something<sup id="fnref:109"><a class="footnote-ref" href="#fn:109" rel="footnote">109</a></sup></p> <p>Something<sup id="fnref:110"><a class="footnote-ref" href="#fn:110" rel="footnote">110</a></sup></p> <p>Something<sup id="fnref:111"><a class="footnote-ref" href="#fn:111" rel="footnote">111</a></sup></p> <p>Something<sup id="fnref:112"><a class="footnote-ref" href="#fn:112" rel="footnote">112</a></sup></p> <p>Something<sup id="fnref:113"><a class="footnote-ref" href="#fn:113" rel="footnote">113</a></sup></p> <p>Something<sup id="fnref:114"><a class="footnote-ref" href="#fn:114" rel="footnote">114</a></sup></p> <p>Something<sup id="fnref:115"><a class="footnote-ref" href="#fn:115" rel="footnote">115</a></sup></p> <p>Something<sup id="fnref:116"><a class="footnote-ref" href="#fn:116" rel="footnote">116</a></sup></p> <p>Something<sup id="fnref:117"><a class="footnote-ref" href="#fn:117" rel="footnote">117</a></sup></p> <p>Something<sup id="fnref:118"><a class="footnote-ref" href="#fn:118" rel="footnote">118</a></sup></p> <p>Something<sup id="fnref:119"><a class="footnote-ref" href="#fn:119" rel="footnote">119</a></sup></p> <p>Something<sup id="fnref:120"><a class="footnote-ref" href="#fn:120" rel="footnote">120</a></sup></p> <p>Something<sup id="fnref:121"><a class="footnote-ref" href="#fn:121" rel="footnote">121</a></sup></p> <p>Something<sup id="fnref:122"><a class="footnote-ref" href="#fn:122" rel="footnote">122</a></sup></p> <p>Something<sup id="fnref:123"><a class="footnote-ref" href="#fn:123" rel="footnote">123</a></sup></p> <p>Something<sup id="fnref:124"><a class="footnote-ref" href="#fn:124" rel="footnote">124</a></sup></p> <p>Something<sup id="fnref:125"><a class="footnote-ref" href="#fn:125" rel="footnote">125</a></sup></p> <p>Something<sup id="fnref:126"><a class="footnote-ref" href="#fn:126" rel="footnote">126</a></sup></p> <p>Something<sup id="fnref:127"><a class="footnote-ref" href="#fn:127" rel="footnote">127</a></sup></p> <p>Something<sup id="fnref:128"><a class="footnote-ref" href="#fn:128" rel="footnote">128</a></sup></p> <p>Something<sup id="fnref:129"><a class="footnote-ref" href="#fn:129" rel="footnote">129</a></sup></p> <p>Something<sup id="fnref:130"><a class="footnote-ref" href="#fn:130" rel="footnote">130</a></sup></p> <p>Something<sup id="fnref:131"><a class="footnote-ref" href="#fn:131" rel="footnote">131</a></sup></p> <p>Something<sup id="fnref:132"><a class="footnote-ref" href="#fn:132" rel="footnote">132</a></sup></p> <p>Something<sup id="fnref:133"><a class="footnote-ref" href="#fn:133" rel="footnote">133</a></sup></p> <p>Something<sup id="fnref:134"><a class="footnote-ref" href="#fn:134" rel="footnote">134</a></sup></p> <p>Something<sup id="fnref:135"><a class="footnote-ref" href="#fn:135" rel="footnote">135</a></sup></p> <p>Something<sup id="fnref:136"><a class="footnote-ref" href="#fn:136" rel="footnote">136</a></sup></p> <p>Something<sup id="fnref:137"><a class="footnote-ref" href="#fn:137" rel="footnote">137</a></sup></p> <p>Something<sup id="fnref:138"><a class="footnote-ref" href="#fn:138" rel="footnote">138</a></sup></p> <p>Something<sup id="fnref:139"><a class="footnote-ref" href="#fn:139" rel="footnote">139</a></sup></p> <p>Something<sup id="fnref:140"><a class="footnote-ref" href="#fn:140" rel="footnote">140</a></sup></p> <p>Something<sup id="fnref:141"><a class="footnote-ref" href="#fn:141" rel="footnote">141</a></sup></p> <p>Something<sup id="fnref:142"><a class="footnote-ref" href="#fn:142" rel="footnote">142</a></sup></p> <p>Something<sup id="fnref:143"><a class="footnote-ref" href="#fn:143" rel="footnote">143</a></sup></p> <p>Something<sup id="fnref:144"><a class="footnote-ref" href="#fn:144" rel="footnote">144</a></sup></p> <p>Something<sup id="fnref:145"><a class="footnote-ref" href="#fn:145" rel="footnote">145</a></sup></p> <p>Something<sup id="fnref:146"><a class="footnote-ref" href="#fn:146" rel="footnote">146</a></sup></p> <p>Something<sup id="fnref:147"><a class="footnote-ref" href="#fn:147" rel="footnote">147</a></sup></p> <p>Something<sup id="fnref:148"><a class="footnote-ref" href="#fn:148" rel="footnote">148</a></sup></p> <p>Something<sup id="fnref:149"><a class="footnote-ref" href="#fn:149" rel="footnote">149</a></sup></p> <p>Something<sup id="fnref:150"><a class="footnote-ref" href="#fn:150" rel="footnote">150</a></sup></p> <p>Something<sup id="fnref:151"><a class="footnote-ref" href="#fn:151" rel="footnote">151</a></sup></p> <p>Something<sup id="fnref:152"><a class="footnote-ref" href="#fn:152" rel="footnote">152</a></sup></p> <p>Something<sup id="fnref:153"><a class="footnote-ref" href="#fn:153" rel="footnote">153</a></sup></p> <p>Something<sup id="fnref:154"><a class="footnote-ref" href="#fn:154" rel="footnote">154</a></sup></p> <p>Something<sup id="fnref:155"><a class="footnote-ref" href="#fn:155" rel="footnote">155</a></sup></p> <p>Something<sup id="fnref:156"><a class="footnote-ref" href="#fn:156" rel="footnote">156</a></sup></p> <p>Something<sup id="fnref:157"><a class="footnote-ref" href="#fn:157" rel="footnote">157</a></sup></p> <p>Something<sup id="fnref:158"><a class="footnote-ref" href="#fn:158" rel="footnote">158</a></sup></p> <p>Something<sup id="fnref:159"><a class="footnote-ref" href="#fn:159" rel="footnote">159</a></sup></p> <p>Something<sup id="fnref:160"><a class="footnote-ref" href="#fn:160" rel="footnote">160</a></sup></p> <p>Something<sup id="fnref:161"><a class="footnote-ref" href="#fn:161" rel="footnote">161</a></sup></p> <p>Something<sup id="fnref:162"><a class="footnote-ref" href="#fn:162" rel="footnote">162</a></sup></p> <p>Something<sup id="fnref:163"><a class="footnote-ref" href="#fn:163" rel="footnote">163</a></sup></p> <p>Something<sup id="fnref:164"><a class="footnote-ref" href="#fn:164" rel="footnote">164</a></sup></p> <p>Something<sup id="fnref:165"><a class="footnote-ref" href="#fn:165" rel="footnote">165</a></sup></p> <p>Something<sup id="fnref:166"><a class="footnote-ref" href="#fn:166" rel="footnote">166</a></sup></p> <p>Something<sup id="fnref:167"><a class="footnote-ref" href="#fn:167" rel="footnote">167</a></sup></p> <p>Something<sup id="fnref:168"><a class="footnote-ref" href="#fn:168" rel="footnote">168</a></sup></p> <p>Something<sup id="fnref:169"><a class="footnote-ref" href="#fn:169" rel="footnote">169</a></sup></p> <p>Something<sup id="fnref:170"><a class="footnote-ref" href="#fn:170" rel="footnote">170</a></sup></p> <p>Something<sup id="fnref:171"><a class="footnote-ref" href="#fn:171" rel="footnote">171</a></sup></p> <p>Something<sup id="fnref:172"><a class="footnote-ref" href="#fn:172" rel="footnote">172</a></sup></p> <p>Something<sup id="fnref:173"><a class="footnote-ref" href="#fn:173" rel="footnote">173</a></sup></p> <p>Something<sup id="fnref:174"><a class="footnote-ref" href="#fn:174" rel="footnote">174</a></sup></p> <p>Something<sup id="fnref:175"><a class="footnote-ref" href="#fn:175" rel="footnote">175</a></sup></p> <p>Something<sup id="fnref:176"><a class="footnote-ref" href="#fn:176" rel="footnote">176</a></sup></p> <p>Something<sup id="fnref:177"><a class="footnote-ref" href="#fn:177" rel="footnote">177</a></sup></p> <p>Something<sup id="fnref:178"><a class="footnote-ref" href="#fn:178" rel="footnote">178</a></sup></p> <p>Something<sup id="fnref:179"><a class="footnote-ref" href="#fn:179" rel="footnote">179</a></sup></p> <p>Something<sup id="fnref:180"><a class="footnote-ref" href="#fn:180" rel="footnote">180</a></sup></p> <p>Something<sup id="fnref:181"><a class="footnote-ref" href="#fn:181" rel="footnote">181</a></sup></p> <p>Something<sup id="fnref:182"><a class="footnote-ref" href="#fn:182" rel="footnote">182</a></sup></p> <p>Something<sup id="fnref:183"><a class="footnote-ref" href="#fn:183" rel="footnote">183</a></sup></p> <p>Something<sup id="fnref:184"><a class="footnote-ref" href="#fn:184" rel="footnote">184</a></sup></p> <p>Something<sup id="fnref:185"><a class="footnote-ref" href="#fn:185" rel="footnote">185</a></sup></p> <p>Something<sup id="fnref:186"><a class="footnote-ref" href="#fn:186" rel="footnote">186</a></sup></p> <p>Something<sup id="fnref:187"><a class="footnote-ref" href="#fn:187" rel="footnote">187</a></sup></p> <p>Something<sup id="fnref:188"><a class="footnote-ref" href="#fn:188" rel="footnote">188</a></sup></p> <p>Something<sup id="fnref:189"><a class="footnote-ref" href="#fn:189" rel="footnote">189</a></sup></p> <p>Something<sup id="fnref:190"><a class="footnote-ref" href="#fn:190" rel="footnote">190</a></sup></p> <p>Something<sup id="fnref:191"><a class="footnote-ref" href="#fn:191" rel="footnote">191</a></sup></p> <p>Something<sup id="fnref:192"><a class="footnote-ref" href="#fn:192" rel="footnote">192</a></sup></p> <p>Something<sup id="fnref:193"><a class="footnote-ref" href="#fn:193" rel="footnote">193</a></sup></p> <p>Something<sup id="fnref:194"><a class="footnote-ref" href="#fn:194" rel="footnote">194</a></sup></p> <p>Something<sup id="fnref:195"><a class="footnote-ref" href="#fn:195" rel="footnote">195</a></sup></p> <p>Something<sup id="fnref:196"><a class="footnote-ref" href="#fn:196" rel="footnote">196</a></sup></p> <p>Something<sup id="fnref:197"><a class="footnote-ref" href="#fn:197" rel="footnote">197</a></sup></p> <p>Something<sup id="fnref:198"><a class="footnote-ref" href="#fn:198" rel="footnote">198</a></sup></p> <p>Something<sup id="fnref:199"><a class="footnote-ref" href="#fn:199" rel="footnote">199</a></sup></p> <p>Something<sup id="fnref:200"><a class="footnote-ref" href="#fn:200" rel="footnote">200</a></sup></p> <p>Something<sup id="fnref:201"><a class="footnote-ref" href="#fn:201" rel="footnote">201</a></sup></p> <p>Something<sup id="fnref:202"><a class="footnote-ref" href="#fn:202" rel="footnote">202</a></sup></p> <p>Something<sup id="fnref:203"><a class="footnote-ref" href="#fn:203" rel="footnote">203</a></sup></p> <p>Something<sup id="fnref:204"><a class="footnote-ref" href="#fn:204" rel="footnote">204</a></sup></p> <p>Something<sup id="fnref:205"><a class="footnote-ref" href="#fn:205" rel="footnote">205</a></sup></p> <p>Something<sup id="fnref:206"><a class="footnote-ref" href="#fn:206" rel="footnote">206</a></sup></p> <p>Something<sup id="fnref:207"><a class="footnote-ref" href="#fn:207" rel="footnote">207</a></sup></p> <p>Something<sup id="fnref:208"><a class="footnote-ref" href="#fn:208" rel="footnote">208</a></sup></p> <p>Something<sup id="fnref:209"><a class="footnote-ref" href="#fn:209" rel="footnote">209</a></sup></p> <p>Something<sup id="fnref:210"><a class="footnote-ref" href="#fn:210" rel="footnote">210</a></sup></p> <p>Something<sup id="fnref:211"><a class="footnote-ref" href="#fn:211" rel="footnote">211</a></sup></p> <p>Something<sup id="fnref:212"><a class="footnote-ref" href="#fn:212" rel="footnote">212</a></sup></p> <p>Something<sup id="fnref:213"><a class="footnote-ref" href="#fn:213" rel="footnote">213</a></sup></p> <p>Something<sup id="fnref:214"><a class="footnote-ref" href="#fn:214" rel="footnote">214</a></sup></p> <p>Something<sup id="fnref:215"><a class="footnote-ref" href="#fn:215" rel="footnote">215</a></sup></p> <p>Something<sup id="fnref:216"><a class="footnote-ref" href="#fn:216" rel="footnote">216</a></sup></p> <p>Something<sup id="fnref:217"><a class="footnote-ref" href="#fn:217" rel="footnote">217</a></sup></p> <p>Something<sup id="fnref:218"><a class="footnote-ref" href="#fn:218" rel="footnote">218</a></sup></p> <p>Something<sup id="fnref:219"><a class="footnote-ref" href="#fn:219" rel="footnote">219</a></sup></p> <p>Something<sup id="fnref:220"><a class="footnote-ref" href="#fn:220" rel="footnote">220</a></sup></p> <p>Something<sup id="fnref:221"><a class="footnote-ref" href="#fn:221" rel="footnote">221</a></sup></p> <p>Something<sup id="fnref:222"><a class="footnote-ref" href="#fn:222" rel="footnote">222</a></sup></p> <p>Something<sup id="fnref:223"><a class="footnote-ref" href="#fn:223" rel="footnote">223</a></sup></p> <p>Something<sup id="fnref:224"><a class="footnote-ref" href="#fn:224" rel="footnote">224</a></sup></p> <p>Something<sup id="fnref:225"><a class="footnote-ref" href="#fn:225" rel="footnote">225</a></sup></p> <p>Something<sup id="fnref:226"><a class="footnote-ref" href="#fn:226" rel="footnote">226</a></sup></p> <p>Something<sup id="fnref:227"><a class="footnote-ref" href="#fn:227" rel="footnote">227</a></sup></p> <p>Something<sup id="fnref:228"><a class="footnote-ref" href="#fn:228" rel="footnote">228</a></sup></p> <p>Something<sup id="fnref:229"><a class="footnote-ref" href="#fn:229" rel="footnote">229</a></sup></p> <p>Something<sup id="fnref:230"><a class="footnote-ref" href="#fn:230" rel="footnote">230</a></sup></p> <p>Something<sup id="fnref:231"><a class="footnote-ref" href="#fn:231" rel="footnote">231</a></sup></p> <p>Something<sup id="fnref:232"><a class="footnote-ref" href="#fn:232" rel="footnote">232</a></sup></p> <p>Something<sup id="fnref:233"><a class="footnote-ref" href="#fn:233" rel="footnote">233</a></sup></p> <p>Something<sup id="fnref:234"><a class="footnote-ref" href="#fn:234" rel="footnote">234</a></sup></p> <p>Something<sup id="fnref:235"><a class="footnote-ref" href="#fn:235" rel="footnote">235</a></sup></p> <p>Something<sup id="fnref:236"><a class="footnote-ref" href="#fn:236" rel="footnote">236</a></sup></p> <p>Something<sup id="fnref:237"><a class="footnote-ref" href="#fn:237" rel="footnote">237</a></sup></p> <p>Something<sup id="fnref:238"><a class="footnote-ref" href="#fn:238" rel="footnote">238</a></sup></p> <p>Something<sup id="fnref:239"><a class="footnote-ref" href="#fn:239" rel="footnote">239</a></sup></p> <p>Something<sup id="fnref:240"><a class="footnote-ref" href="#fn:240" rel="footnote">240</a></sup></p> <p>Something<sup id="fnref:241"><a class="footnote-ref" href="#fn:241" rel="footnote">241</a></sup></p> <p>Something<sup id="fnref:242"><a class="footnote-ref" href="#fn:242" rel="footnote">242</a></sup></p> <p>Something<sup id="fnref:243"><a class="footnote-ref" href="#fn:243" rel="footnote">243</a></sup></p> <p>Something<sup id="fnref:244"><a class="footnote-ref" href="#fn:244" rel="footnote">244</a></sup></p> <p>Something<sup id="fnref:245"><a class="footnote-ref" href="#fn:245" rel="footnote">245</a></sup></p> <p>Something<sup id="fnref:246"><a class="footnote-ref" href="#fn:246" rel="footnote">246</a></sup></p> <p>Something<sup id="fnref:247"><a class="footnote-ref" href="#fn:247" rel="footnote">247</a></sup></p> <p>Something<sup id="fnref:248"><a class="footnote-ref" href="#fn:248" rel="footnote">248</a></sup></p> <p>Something<sup id="fnref:249"><a class="footnote-ref" href="#fn:249" rel="footnote">249</a></sup></p> <p>Something<sup id="fnref:250"><a class="footnote-ref" href="#fn:250" rel="footnote">250</a></sup></p> <p>Something<sup id="fnref:251"><a class="footnote-ref" href="#fn:251" rel="footnote">251</a></sup></p> <p>Something<sup id="fnref:252"><a class="footnote-ref" href="#fn:252" rel="footnote">252</a></sup></p> <p>Something<sup id="fnref:253"><a class="footnote-ref" href="#fn:253" rel="footnote">253</a></sup></p> <p>Something<sup id="fnref:254"><a class="footnote-ref" href="#fn:254" rel="footnote">254</a></sup></p> <p>Something<sup id="fnref:255"><a class="footnote-ref" href="#fn:255" rel="footnote">255</a></sup></p> <p>Something<sup id="fnref:256"><a class="footnote-ref" href="#fn:256" rel="footnote">256</a></sup></p> <p>Something<sup id="fnref:257"><a class="footnote-ref" href="#fn:257" rel="footnote">257</a></sup></p> <p>Something<sup id="fnref:258"><a class="footnote-ref" href="#fn:258" rel="footnote">258</a></sup></p> <p>Something<sup id="fnref:259"><a class="footnote-ref" href="#fn:259" rel="footnote">259</a></sup></p> <p>Something<sup id="fnref:260"><a class="footnote-ref" href="#fn:260" rel="footnote">260</a></sup></p> <p>Something<sup id="fnref:261"><a class="footnote-ref" href="#fn:261" rel="footnote">261</a></sup></p> <p>Something<sup id="fnref:262"><a class="footnote-ref" href="#fn:262" rel="footnote">262</a></sup></p> <p>Something<sup id="fnref:263"><a class="footnote-ref" href="#fn:263" rel="footnote">263</a></sup></p> <p>Something<sup id="fnref:264"><a class="footnote-ref" href="#fn:264" rel="footnote">264</a></sup></p> <p>Something<sup id="fnref:265"><a class="footnote-ref" href="#fn:265" rel="footnote">265</a></sup></p> <p>Something<sup id="fnref:266"><a class="footnote-ref" href="#fn:266" rel="footnote">266</a></sup></p> <p>Something<sup id="fnref:267"><a class="footnote-ref" href="#fn:267" rel="footnote">267</a></sup></p> <p>Something<sup id="fnref:268"><a class="footnote-ref" href="#fn:268" rel="footnote">268</a></sup></p> <p>Something<sup id="fnref:269"><a class="footnote-ref" href="#fn:269" rel="footnote">269</a></sup></p> <p>Something<sup id="fnref:270"><a class="footnote-ref" href="#fn:270" rel="footnote">270</a></sup></p> <p>Something<sup id="fnref:271"><a class="footnote-ref" href="#fn:271" rel="footnote">271</a></sup></p> <p>Something<sup id="fnref:272"><a class="footnote-ref" href="#fn:272" rel="footnote">272</a></sup></p> <p>Something<sup id="fnref:273"><a class="footnote-ref" href="#fn:273" rel="footnote">273</a></sup></p> <p>Something<sup id="fnref:274"><a class="footnote-ref" href="#fn:274" rel="footnote">274</a></sup></p> <p>Something<sup id="fnref:275"><a class="footnote-ref" href="#fn:275" rel="footnote">275</a></sup></p> <p>Something<sup id="fnref:276"><a class="footnote-ref" href="#fn:276" rel="footnote">276</a></sup></p> <p>Something<sup id="fnref:277"><a class="footnote-ref" href="#fn:277" rel="footnote">277</a></sup></p> <p>Something<sup id="fnref:278"><a class="footnote-ref" href="#fn:278" rel="footnote">278</a></sup></p> <p>Something<sup id="fnref:279"><a class="footnote-ref" href="#fn:279" rel="footnote">279</a></sup></p> <p>Something<sup id="fnref:280"><a class="footnote-ref" href="#fn:280" rel="footnote">280</a></sup></p> <p>Something<sup id="fnref:281"><a class="footnote-ref" href="#fn:281" rel="footnote">281</a></sup></p> <p>Something<sup id="fnref:282"><a class="footnote-ref" href="#fn:282" rel="footnote">282</a></sup></p> <p>Something<sup id="fnref:283"><a class="footnote-ref" href="#fn:283" rel="footnote">283</a></sup></p> <p>Something<sup id="fnref:284"><a class="footnote-ref" href="#fn:284" rel="footnote">284</a></sup></p> <p>Something<sup id="fnref:285"><a class="footnote-ref" href="#fn:285" rel="footnote">285</a></sup></p> <p>Something<sup id="fnref:286"><a class="footnote-ref" href="#fn:286" rel="footnote">286</a></sup></p> <p>Something<sup id="fnref:287"><a class="footnote-ref" href="#fn:287" rel="footnote">287</a></sup></p> <p>Something<sup id="fnref:288"><a class="footnote-ref" href="#fn:288" rel="footnote">288</a></sup></p> <p>Something<sup id="fnref:289"><a class="footnote-ref" href="#fn:289" rel="footnote">289</a></sup></p> <p>Something<sup id="fnref:290"><a class="footnote-ref" href="#fn:290" rel="footnote">290</a></sup></p> <p>Something<sup id="fnref:291"><a class="footnote-ref" href="#fn:291" rel="footnote">291</a></sup></p> <p>Something<sup id="fnref:292"><a class="footnote-ref" href="#fn:292" rel="footnote">292</a></sup></p> <p>Something<sup id="fnref:293"><a class="footnote-ref" href="#fn:293" rel="footnote">293</a></sup></p> <p>Something<sup id="fnref:294"><a class="footnote-ref" href="#fn:294" rel="footnote">294</a></sup></p> <p>Something<sup id="fnref:295"><a class="footnote-ref" href="#fn:295" rel="footnote">295</a></sup></p> <p>Something<sup id="fnref:296"><a class="footnote-ref" href="#fn:296" rel="footnote">296</a></sup></p> <p>Something<sup id="fnref:297"><a class="footnote-ref" href="#fn:297" rel="footnote">297</a></sup></p> <p>Something<sup id="fnref:298"><a class="footnote-ref" href="#fn:298" rel="footnote">298</a></sup></p> <p>Something<sup id="fnref:299"><a class="footnote-ref" href="#fn:299" rel="footnote">299</a></sup></p> <p>Something<sup id="fnref:300"><a class="footnote-ref" href="#fn:300" rel="footnote">300</a></sup></p> <p>Something<sup id="fnref:301"><a class="footnote-ref" href="#fn:301" rel="footnote">301</a></sup></p> <p>Something<sup id="fnref:302"><a class="footnote-ref" href="#fn:302" rel="footnote">302</a></sup></p> <p>Something<sup id="fnref:303"><a class="footnote-ref" href="#fn:303" rel="footnote">303</a></sup></p> <p>Something<sup id="fnref:304"><a class="footnote-ref" href="#fn:304" rel="footnote">304</a></sup></p> <p>Something<sup id="fnref:305"><a class="footnote-ref" href="#fn:305" rel="footnote">305</a></sup></p> <p>Something<sup id="fnref:306"><a class="footnote-ref" href="#fn:306" rel="footnote">306</a></sup></p> <p>Something<sup id="fnref:307"><a class="footnote-ref" href="#fn:307" rel="footnote">307</a></sup></p> <p>Something<sup id="fnref:308"><a class="footnote-ref" href="#fn:308" rel="footnote">308</a></sup></p> <p>Something<sup id="fnref:309"><a class="footnote-ref" href="#fn:309" rel="footnote">309</a></sup></p> <p>Something<sup id="fnref:310"><a class="footnote-ref" href="#fn:310" rel="footnote">310</a></sup></p> <p>Something<sup id="fnref:311"><a class="footnote-ref" href="#fn:311" rel="footnote">311</a></sup></p> <p>Something<sup id="fnref:312"><a class="footnote-ref" href="#fn:312" rel="footnote">312</a></sup></p> <p>Something<sup id="fnref:313"><a class="footnote-ref" href="#fn:313" rel="footnote">313</a></sup></p> <p>Something<sup id="fnref:314"><a class="footnote-ref" href="#fn:314" rel="footnote">314</a></sup></p> <p>Something<sup id="fnref:315"><a class="footnote-ref" href="#fn:315" rel="footnote">315</a></sup></p> <p>Something<sup id="fnref:316"><a class="footnote-ref" href="#fn:316" rel="footnote">316</a></sup></p> <p>Something<sup id="fnref:317"><a class="footnote-ref" href="#fn:317" rel="footnote">317</a></sup></p> <p>Something<sup id="fnref:318"><a class="footnote-ref" href="#fn:318" rel="footnote">318</a></sup></p> <p>Something<sup id="fnref:319"><a class="footnote-ref" href="#fn:319" rel="footnote">319</a></sup></p> <p>Something<sup id="fnref:320"><a class="footnote-ref" href="#fn:320" rel="footnote">320</a></sup></p> <p>Something<sup id="fnref:321"><a class="footnote-ref" href="#fn:321" rel="footnote">321</a></sup></p> <p>Something<sup id="fnref:322"><a class="footnote-ref" href="#fn:322" rel="footnote">322</a></sup></p> <p>Something<sup id="fnref:323"><a class="footnote-ref" href="#fn:323" rel="footnote">323</a></sup></p> <p>Something<sup id="fnref:324"><a class="footnote-ref" href="#fn:324" rel="footnote">324</a></sup></p> <p>Something<sup id="fnref:325"><a class="footnote-ref" href="#fn:325" rel="footnote">325</a></sup></p> <p>Something<sup id="fnref:326"><a class="footnote-ref" href="#fn:326" rel="footnote">326</a></sup></p> <p>Something<sup id="fnref:327"><a class="footnote-ref" href="#fn:327" rel="footnote">327</a></sup></p> <p>Something<sup id="fnref:328"><a class="footnote-ref" href="#fn:328" rel="footnote">328</a></sup></p> <p>Something<sup id="fnref:329"><a class="footnote-ref" href="#fn:329" rel="footnote">329</a></sup></p> <p>Something<sup id="fnref:330"><a class="footnote-ref" href="#fn:330" rel="footnote">330</a></sup></p> <p>Something<sup id="fnref:331"><a class="footnote-ref" href="#fn:331" rel="footnote">331</a></sup></p> <p>Something<sup id="fnref:332"><a class="footnote-ref" href="#fn:332" rel="footnote">332</a></sup></p> <p>Something<sup id="fnref:333"><a class="footnote-ref" href="#fn:333" rel="footnote">333</a></sup></p> <p>Something<sup id="fnref:334"><a class="footnote-ref" href="#fn:334" rel="footnote">334</a></sup></p> <p>Something<sup id="fnref:335"><a class="footnote-ref" href="#fn:335" rel="footnote">335</a></sup></p> <p>Something<sup id="fnref:336"><a class="footnote-ref" href="#fn:336" rel="footnote">336</a></sup></p> <p>Something<sup id="fnref:337"><a class="footnote-ref" href="#fn:337" rel="footnote">337</a></sup></p> <p>Something<sup id="fnref:338"><a class="footnote-ref" href="#fn:338" rel="footnote">338</a></sup></p> <p>Something<sup id="fnref:339"><a class="footnote-ref" href="#fn:339" rel="footnote">339</a></sup></p> <p>Something<sup id="fnref:340"><a class="footnote-ref" href="#fn:340" rel="footnote">340</a></sup></p> <p>Something<sup id="fnref:341"><a class="footnote-ref" href="#fn:341" rel="footnote">341</a></sup></p> <p>Something<sup id="fnref:342"><a class="footnote-ref" href="#fn:342" rel="footnote">342</a></sup></p> <p>Something<sup id="fnref:343"><a class="footnote-ref" href="#fn:343" rel="footnote">343</a></sup></p> <p>Something<sup id="fnref:344"><a class="footnote-ref" href="#fn:344" rel="footnote">344</a></sup></p> <p>Something<sup id="fnref:345"><a class="footnote-ref" href="#fn:345" rel="footnote">345</a></sup></p> <p>Something<sup id="fnref:346"><a class="footnote-ref" href="#fn:346" rel="footnote">346</a></sup></p> <p>Something<sup id="fnref:347"><a class="footnote-ref" href="#fn:347" rel="footnote">347</a></sup></p> <p>Something<sup id="fnref:348"><a class="footnote-ref" href="#fn:348" rel="footnote">348</a></sup></p> <p>Something<sup id="fnref:349"><a class="footnote-ref" href="#fn:349" rel="footnote">349</a></sup></p> <p>Something<sup id="fnref:350"><a class="footnote-ref" href="#fn:350" rel="footnote">350</a></sup></p> <p>Something<sup id="fnref:351"><a class="footnote-ref" href="#fn:351" rel="footnote">351</a></sup></p> <p>Something<sup id="fnref:352"><a class="footnote-ref" href="#fn:352" rel="footnote">352</a></sup></p> <p>Something<sup id="fnref:353"><a class="footnote-ref" href="#fn:353" rel="footnote">353</a></sup></p> <p>Something<sup id="fnref:354"><a class="footnote-ref" href="#fn:354" rel="footnote">354</a></sup></p> <p>Something<sup id="fnref:355"><a class="footnote-ref" href="#fn:355" rel="footnote">355</a></sup></p> <p>Something<sup id="fnref:356"><a class="footnote-ref" href="#fn:356" rel="footnote">356</a></sup></p> <p>Something<sup id="fnref:357"><a class="footnote-ref" href="#fn:357" rel="footnote">357</a></sup></p> <p>Something<sup id="fnref:358"><a class="footnote-ref" href="#fn:358" rel="footnote">358</a></sup></p> <p>Something<sup id="fnref:359"><a class="footnote-ref" href="#fn:359" rel="footnote">359</a></sup></p> <p>Something<sup id="fnref:360"><a class="footnote-ref" href="#fn:360" rel="footnote">360</a></sup></p> <p>Something<sup id="fnref:361"><a class="footnote-ref" href="#fn:361" rel="footnote">361</a></sup></p> <p>Something<sup id="fnref:362"><a class="footnote-ref" href="#fn:362" rel="footnote">362</a></sup></p> <p>Something<sup id="fnref:363"><a class="footnote-ref" href="#fn:363" rel="footnote">363</a></sup></p> <p>Something<sup id="fnref:364"><a class="footnote-ref" href="#fn:364" rel="footnote">364</a></sup></p> <p>Something<sup id="fnref:365"><a class="footnote-ref" href="#fn:365" rel="footnote">365</a></sup></p> <p>Something<sup id="fnref:366"><a class="footnote-ref" href="#fn:366" rel="footnote">366</a></sup></p> <p>Something<sup id="fnref:367"><a class="footnote-ref" href="#fn:367" rel="footnote">367</a></sup></p> <p>Something<sup id="fnref:368"><a class="footnote-ref" href="#fn:368" rel="footnote">368</a></sup></p> <p>Something<sup id="fnref:369"><a class="footnote-ref" href="#fn:369" rel="footnote">369</a></sup></p> <p>Something<sup id="fnref:370"><a class="footnote-ref" href="#fn:370" rel="footnote">370</a></sup></p> <p>Something<sup id="fnref:371"><a class="footnote-ref" href="#fn:371" rel="footnote">371</a></sup></p> <p>Something<sup id="fnref:372"><a class="footnote-ref" href="#fn:372" rel="footnote">372</a></sup></p> <p>Something<sup id="fnref:373"><a class="footnote-ref" href="#fn:373" rel="footnote">373</a></sup></p> <p>Something<sup id="fnref:374"><a class="footnote-ref" href="#fn:374" rel="footnote">374</a></sup></p> <p>Something<sup id="fnref:375"><a class="footnote-ref" href="#fn:375" rel="footnote">375</a></sup></p> <p>Something<sup id="fnref:376"><a class="footnote-ref" href="#fn:376" rel="footnote">376</a></sup></p> <p>Something<sup id="fnref:377"><a class="footnote-ref" href="#fn:377" rel="footnote">377</a></sup></p> <p>Something<sup id="fnref:378"><a class="footnote-ref" href="#fn:378" rel="footnote">378</a></sup></p> <p>Something<sup id="fnref:379"><a class="footnote-ref" href="#fn:379" rel="footnote">379</a></sup></p> <p>Something<sup id="fnref:380"><a class="footnote-ref" href="#fn:380" rel="footnote">380</a></sup></p> <p>Something<sup id="fnref:381"><a class="footnote-ref" href="#fn:381" rel="footnote">381</a></sup></p> <p>Something<sup id="fnref:382"><a class="footnote-ref" href="#fn:382" rel="footnote">382</a></sup></p> <p>Something<sup id="fnref:383"><a class="footnote-ref" href="#fn:383" rel="footnote">383</a></sup></p> <p>Something<sup id="fnref:384"><a class="footnote-ref" href="#fn:384" rel="footnote">384</a></sup></p> <p>Something<sup id="fnref:385"><a class="footnote-ref" href="#fn:385" rel="footnote">385</a></sup></p> <p>Something<sup id="fnref:386"><a class="footnote-ref" href="#fn:386" rel="footnote">386</a></sup></p> <p>Something<sup id="fnref:387"><a class="footnote-ref" href="#fn:387" rel="footnote">387</a></sup></p> <p>Something<sup id="fnref:388"><a class="footnote-ref" href="#fn:388" rel="footnote">388</a></sup></p> <p>Something<sup id="fnref:389"><a class="footnote-ref" href="#fn:389" rel="footnote">389</a></sup></p> <p>Something<sup id="fnref:390"><a class="footnote-ref" href="#fn:390" rel="footnote">390</a></sup></p> <p>Something<sup id="fnref:391"><a class="footnote-ref" href="#fn:391" rel="footnote">391</a></sup></p> <p>Something<sup id="fnref:392"><a class="footnote-ref" href="#fn:392" rel="footnote">392</a></sup></p> <p>Something<sup id="fnref:393"><a class="footnote-ref" href="#fn:393" rel="footnote">393</a></sup></p> <p>Something<sup id="fnref:394"><a class="footnote-ref" href="#fn:394" rel="footnote">394</a></sup></p> <p>Something<sup id="fnref:395"><a class="footnote-ref" href="#fn:395" rel="footnote">395</a></sup></p> <p>Something<sup id="fnref:396"><a class="footnote-ref" href="#fn:396" rel="footnote">396</a></sup></p> <p>Something<sup id="fnref:397"><a class="footnote-ref" href="#fn:397" rel="footnote">397</a></sup></p> <p>Something<sup id="fnref:398"><a class="footnote-ref" href="#fn:398" rel="footnote">398</a></sup></p> <p>Something<sup id="fnref:399"><a class="footnote-ref" href="#fn:399" rel="footnote">399</a></sup></p> <p>Something<sup id="fnref:400"><a class="footnote-ref" href="#fn:400" rel="footnote">400</a></sup></p> <p>Something<sup id="fnref:401"><a class="footnote-ref" href="#fn:401" rel="footnote">401</a></sup></p> <p>Something<sup id="fnref:402"><a class="footnote-ref" href="#fn:402" rel="footnote">402</a></sup></p> <p>Something<sup id="fnref:403"><a class="footnote-ref" href="#fn:403" rel="footnote">403</a></sup></p> <p>Something<sup id="fnref:404"><a class="footnote-ref" href="#fn:404" rel="footnote">404</a></sup></p> <p>Something<sup id="fnref:405"><a class="footnote-ref" href="#fn:405" rel="footnote">405</a></sup></p> <p>Something<sup id="fnref:406"><a class="footnote-ref" href="#fn:406" rel="footnote">406</a></sup></p> <p>Something<sup id="fnref:407"><a class="footnote-ref" href="#fn:407" rel="footnote">407</a></sup></p> <p>Something<sup id="fnref:408"><a class="footnote-ref" href="#fn:408" rel="footnote">408</a></sup></p> <p>Something<sup id="fnref:409"><a class="footnote-ref" href="#fn:409" rel="footnote">409</a></sup></p> <p>Something<sup id="fnref:410"><a class="footnote-ref" href="#fn:410" rel="footnote">410</a></sup></p> <p>Something<sup id="fnref:411"><a class="footnote-ref" href="#fn:411" rel="footnote">411</a></sup></p> <p>Something<sup id="fnref:412"><a class="footnote-ref" href="#fn:412" rel="footnote">412</a></sup></p> <p>Something<sup id="fnref:413"><a class="footnote-ref" href="#fn:413" rel="footnote">413</a></sup></p> <p>Something<sup id="fnref:414"><a class="footnote-ref" href="#fn:414" rel="footnote">414</a></sup></p> <p>Something<sup id="fnref:415"><a class="footnote-ref" href="#fn:415" rel="footnote">415</a></sup></p> <p>Something<sup id="fnref:416"><a class="footnote-ref" href="#fn:416" rel="footnote">416</a></sup></p> <p>Something<sup id="fnref:417"><a class="footnote-ref" href="#fn:417" rel="footnote">417</a></sup></p> <p>Something<sup id="fnref:418"><a class="footnote-ref" href="#fn:418" rel="footnote">418</a></sup></p> <p>Something<sup id="fnref:419"><a class="footnote-ref" href="#fn:419" rel="footnote">419</a></sup></p> <p>Something<sup id="fnref:420"><a class="footnote-ref" href="#fn:420" rel="footnote">420</a></sup></p> <p>Something<sup id="fnref:421"><a class="footnote-ref" href="#fn:421" rel="footnote">421</a></sup></p> <p>Something<sup id="fnref:422"><a class="footnote-ref" href="#fn:422" rel="footnote">422</a></sup></p> <p>Something<sup id="fnref:423"><a class="footnote-ref" href="#fn:423" rel="footnote">423</a></sup></p> <p>Something<sup id="fnref:424"><a class="footnote-ref" href="#fn:424" rel="footnote">424</a></sup></p> <p>Something<sup id="fnref:425"><a class="footnote-ref" href="#fn:425" rel="footnote">425</a></sup></p> <p>Something<sup id="fnref:426"><a class="footnote-ref" href="#fn:426" rel="footnote">426</a></sup></p> <p>Something<sup id="fnref:427"><a class="footnote-ref" href="#fn:427" rel="footnote">427</a></sup></p> <p>Something<sup id="fnref:428"><a class="footnote-ref" href="#fn:428" rel="footnote">428</a></sup></p> <p>Something<sup id="fnref:429"><a class="footnote-ref" href="#fn:429" rel="footnote">429</a></sup></p> <p>Something<sup id="fnref:430"><a class="footnote-ref" href="#fn:430" rel="footnote">430</a></sup></p> <p>Something<sup id="fnref:431"><a class="footnote-ref" href="#fn:431" rel="footnote">431</a></sup></p> <p>Something<sup id="fnref:432"><a class="footnote-ref" href="#fn:432" rel="footnote">432</a></sup></p> <p>Something<sup id="fnref:433"><a class="footnote-ref" href="#fn:433" rel="footnote">433</a></sup></p> <p>Something<sup id="fnref:434"><a class="footnote-ref" href="#fn:434" rel="footnote">434</a></sup></p> <p>Something<sup id="fnref:435"><a class="footnote-ref" href="#fn:435" rel="footnote">435</a></sup></p> <p>Something<sup id="fnref:436"><a class="footnote-ref" href="#fn:436" rel="footnote">436</a></sup></p> <p>Something<sup id="fnref:437"><a class="footnote-ref" href="#fn:437" rel="footnote">437</a></sup></p> <p>Something<sup id="fnref:438"><a class="footnote-ref" href="#fn:438" rel="footnote">438</a></sup></p> <p>Something<sup id="fnref:439"><a class="footnote-ref" href="#fn:439" rel="footnote">439</a></sup></p> <p>Something<sup id="fnref:440"><a class="footnote-ref" href="#fn:440" rel="footnote">440</a></sup></p> <p>Something<sup id="fnref:441"><a class="footnote-ref" href="#fn:441" rel="footnote">441</a></sup></p> <p>Something<sup id="fnref:442"><a class="footnote-ref" href="#fn:442" rel="footnote">442</a></sup></p> <p>Something<sup id="fnref:443"><a class="footnote-ref" href="#fn:443" rel="footnote">443</a></sup></p> <p>Something<sup id="fnref:444"><a class="footnote-ref" href="#fn:444" rel="footnote">444</a></sup></p> <p>Something<sup id="fnref:445"><a class="footnote-ref" href="#fn:445" rel="footnote">445</a></sup></p> <p>Something<sup id="fnref:446"><a class="footnote-ref" href="#fn:446" rel="footnote">446</a></sup></p> <p>Something<sup id="fnref:447"><a class="footnote-ref" href="#fn:447" rel="footnote">447</a></sup></p> <p>Something<sup id="fnref:448"><a class="footnote-ref" href="#fn:448" rel="footnote">448</a></sup></p> <p>Something<sup id="fnref:449"><a class="footnote-ref" href="#fn:449" rel="footnote">449</a></sup></p> <p>Something<sup id="fnref:450"><a class="footnote-ref" href="#fn:450" rel="footnote">450</a></sup></p> <p>Something<sup id="fnref:451"><a class="footnote-ref" href="#fn:451" rel="footnote">451</a></sup></p> <p>Something<sup id="fnref:452"><a class="footnote-ref" href="#fn:452" rel="footnote">452</a></sup></p> <p>Something<sup id="fnref:453"><a class="footnote-ref" href="#fn:453" rel="footnote">453</a></sup></p> <p>Something<sup id="fnref:454"><a class="footnote-ref" href="#fn:454" rel="footnote">454</a></sup></p> <p>Something<sup id="fnref:455"><a class="footnote-ref" href="#fn:455" rel="footnote">455</a></sup></p> <p>Something<sup id="fnref:456"><a class="footnote-ref" href="#fn:456" rel="footnote">456</a></sup></p> <p>Something<sup id="fnref:457"><a class="footnote-ref" href="#fn:457" rel="footnote">457</a></sup></p> <p>Something<sup id="fnref:458"><a class="footnote-ref" href="#fn:458" rel="footnote">458</a></sup></p> <p>Something<sup id="fnref:459"><a class="footnote-ref" href="#fn:459" rel="footnote">459</a></sup></p> <p>Something<sup id="fnref:460"><a class="footnote-ref" href="#fn:460" rel="footnote">460</a></sup></p> <p>Something<sup id="fnref:461"><a class="footnote-ref" href="#fn:461" rel="footnote">461</a></sup></p> <p>Something<sup id="fnref:462"><a class="footnote-ref" href="#fn:462" rel="footnote">462</a></sup></p> <p>Something<sup id="fnref:463"><a class="footnote-ref" href="#fn:463" rel="footnote">463</a></sup></p> <p>Something<sup id="fnref:464"><a class="footnote-ref" href="#fn:464" rel="footnote">464</a></sup></p> <p>Something<sup id="fnref:465"><a class="footnote-ref" href="#fn:465" rel="footnote">465</a></sup></p> <p>Something<sup id="fnref:466"><a class="footnote-ref" href="#fn:466" rel="footnote">466</a></sup></p> <p>Something<sup id="fnref:467"><a class="footnote-ref" href="#fn:467" rel="footnote">467</a></sup></p> <p>Something<sup id="fnref:468"><a class="footnote-ref" href="#fn:468" rel="footnote">468</a></sup></p> <p>Something<sup id="fnref:469"><a class="footnote-ref" href="#fn:469" rel="footnote">469</a></sup></p> <p>Something<sup id="fnref:470"><a class="footnote-ref" href="#fn:470" rel="footnote">470</a></sup></p> <p>Something<sup id="fnref:471"><a class="footnote-ref" href="#fn:471" rel="footnote">471</a></sup></p> <p>Something<sup id="fnref:472"><a class="footnote-ref" href="#fn:472" rel="footnote">472</a></sup></p> <p>Something<sup id="fnref:473"><a class="footnote-ref" href="#fn:473" rel="footnote">473</a></sup></p> <p>Something<sup id="fnref:474"><a class="footnote-ref" href="#fn:474" rel="footnote">474</a></sup></p> <p>Something<sup id="fnref:475"><a class="footnote-ref" href="#fn:475" rel="footnote">475</a></sup></p> <p>Something<sup id="fnref:476"><a class="footnote-ref" href="#fn:476" rel="footnote">476</a></sup></p> <p>Something<sup id="fnref:477"><a class="footnote-ref" href="#fn:477" rel="footnote">477</a></sup></p> <p>Something<sup id="fnref:478"><a class="footnote-ref" href="#fn:478" rel="footnote">478</a></sup></p> <p>Something<sup id="fnref:479"><a class="footnote-ref" href="#fn:479" rel="footnote">479</a></sup></p> <p>Something<sup id="fnref:480"><a class="footnote-ref" href="#fn:480" rel="footnote">480</a></sup></p> <p>Something<sup id="fnref:481"><a class="footnote-ref" href="#fn:481" rel="footnote">481</a></sup></p> <p>Something<sup id="fnref:482"><a class="footnote-ref" href="#fn:482" rel="footnote">482</a></sup></p> <p>Something<sup id="fnref:483"><a class="footnote-ref" href="#fn:483" rel="footnote">483</a></sup></p> <p>Something<sup id="fnref:484"><a class="footnote-ref" href="#fn:484" rel="footnote">484</a></sup></p> <p>Something<sup id="fnref:485"><a class="footnote-ref" href="#fn:485" rel="footnote">485</a></sup></p> <p>Something<sup id="fnref:486"><a class="footnote-ref" href="#fn:486" rel="footnote">486</a></sup></p> <p>Something<sup id="fnref:487"><a class="footnote-ref" href="#fn:487" rel="footnote">487</a></sup></p> <p>Something<sup id="fnref:488"><a class="footnote-ref" href="#fn:488" rel="footnote">488</a></sup></p> <p>Something<sup id="fnref:489"><a class="footnote-ref" href="#fn:489" rel="footnote">489</a></sup></p> <p>Something<sup id="fnref:490"><a class="footnote-ref" href="#fn:490" rel="footnote">490</a></sup></p> <p>Something<sup id="fnref:491"><a class="footnote-ref" href="#fn:491" rel="footnote">491</a></sup></p> <p>Something<sup id="fnref:492"><a class="footnote-ref" href="#fn:492" rel="footnote">492</a></sup></p> <p>Something<sup id="fnref:493"><a class="footnote-ref" href="#fn:493" rel="footnote">493</a></sup></p> <p>Something<sup id="fnref:494"><a class="footnote-ref" href="#fn:494" rel="footnote">494</a></sup></p> <p>Something<sup id="fnref:495"><a class="footnote-ref" href="#fn:495" rel="footnote">495</a></sup></p> <p>Something<sup id="fnref:496"><a class="footnote-ref" href="#fn:496" rel="footnote">496</a></sup></p> <p>Something<sup id="fnref:497"><a class="footnote-ref" href="#fn:497" rel="footnote">497</a></sup></p> <p>Something<sup id="fnref:498"><a class="footnote-ref" href="#fn:498" rel="footnote">498</a></sup></p> <p>Something<sup id="fnref:499"><a class="footnote-ref" href="#fn:499" rel="footnote">499</a></sup></p> <p>Something<sup id="fnref:500"><a class="footnote-ref" href="#fn:500" rel="footnote">500</a></sup></p> <p>Something<sup id="fnref:501"><a class="footnote-ref" href="#fn:501" rel="footnote">501</a></sup></p> <p>Something<sup id="fnref:502"><a class="footnote-ref" href="#fn:502" rel="footnote">502</a></sup></p> <p>Something<sup id="fnref:503"><a class="footnote-ref" href="#fn:503" rel="footnote">503</a></sup></p> <p>Something<sup id="fnref:504"><a class="footnote-ref" href="#fn:504" rel="footnote">504</a></sup></p> <p>Something<sup id="fnref:505"><a class="footnote-ref" href="#fn:505" rel="footnote">505</a></sup></p> <p>Something<sup id="fnref:506"><a class="footnote-ref" href="#fn:506" rel="footnote">506</a></sup></p> <p>Something<sup id="fnref:507"><a class="footnote-ref" href="#fn:507" rel="footnote">507</a></sup></p> <p>Something<sup id="fnref:508"><a class="footnote-ref" href="#fn:508" rel="footnote">508</a></sup></p> <p>Something<sup id="fnref:509"><a class="footnote-ref" href="#fn:509" rel="footnote">509</a></sup></p> <p>Something<sup id="fnref:510"><a class="footnote-ref" href="#fn:510" rel="footnote">510</a></sup></p> <p>Something<sup id="fnref:511"><a class="footnote-ref" href="#fn:511" rel="footnote">511</a></sup></p> <p>Something<sup id="fnref:512"><a class="footnote-ref" href="#fn:512" rel="footnote">512</a></sup></p> <p>Something<sup id="fnref:513"><a class="footnote-ref" href="#fn:513" rel="footnote">513</a></sup></p> <p>Something<sup id="fnref:514"><a class="footnote-ref" href="#fn:514" rel="footnote">514</a></sup></p> <p>Something<sup id="fnref:515"><a class="footnote-ref" href="#fn:515" rel="footnote">515</a></sup></p> <p>Something<sup id="fnref:516"><a class="footnote-ref" href="#fn:516" rel="footnote">516</a></sup></p> <p>Something<sup id="fnref:517"><a class="footnote-ref" href="#fn:517" rel="footnote">517</a></sup></p> <p>Something<sup id="fnref:518"><a class="footnote-ref" href="#fn:518" rel="footnote">518</a></sup></p> <p>Something<sup id="fnref:519"><a class="footnote-ref" href="#fn:519" rel="footnote">519</a></sup></p> <p>Something<sup id="fnref:520"><a class="footnote-ref" href="#fn:520" rel="footnote">520</a></sup></p> <p>Something<sup id="fnref:521"><a class="footnote-ref" href="#fn:521" rel="footnote">521</a></sup></p> <p>Something<sup id="fnref:522"><a class="footnote-ref" href="#fn:522" rel="footnote">522</a></sup></p> <p>Something<sup id="fnref:523"><a class="footnote-ref" href="#fn:523" rel="footnote">523</a></sup></p> <p>Something<sup id="fnref:524"><a class="footnote-ref" href="#fn:524" rel="footnote">524</a></sup></p> <p>Something<sup id="fnref:525"><a class="footnote-ref" href="#fn:525" rel="footnote">525</a></sup></p> <p>Something<sup id="fnref:526"><a class="footnote-ref" href="#fn:526" rel="footnote">526</a></sup></p> <p>Something<sup id="fnref:527"><a class="footnote-ref" href="#fn:527" rel="footnote">527</a></sup></p> <p>Something<sup id="fnref:528"><a class="footnote-ref" href="#fn:528" rel="footnote">528</a></sup></p> <p>Something<sup id="fnref:529"><a class="footnote-ref" href="#fn:529" rel="footnote">529</a></sup></p> <p>Something<sup id="fnref:530"><a class="footnote-ref" href="#fn:530" rel="footnote">530</a></sup></p> <p>Something<sup id="fnref:531"><a class="footnote-ref" href="#fn:531" rel="footnote">531</a></sup></p> <p>Something<sup id="fnref:532"><a class="footnote-ref" href="#fn:532" rel="footnote">532</a></sup></p> <p>Something<sup id="fnref:533"><a class="footnote-ref" href="#fn:533" rel="footnote">533</a></sup></p> <p>Something<sup id="fnref:534"><a class="footnote-ref" href="#fn:534" rel="footnote">534</a></sup></p> <p>Something<sup id="fnref:535"><a class="footnote-ref" href="#fn:535" rel="footnote">535</a></sup></p> <p>Something<sup id="fnref:536"><a class="footnote-ref" href="#fn:536" rel="footnote">536</a></sup></p> <p>Something<sup id="fnref:537"><a class="footnote-ref" href="#fn:537" rel="footnote">537</a></sup></p> <p>Something<sup id="fnref:538"><a class="footnote-ref" href="#fn:538" rel="footnote">538</a></sup></p> <p>Something<sup id="fnref:539"><a class="footnote-ref" href="#fn:539" rel="footnote">539</a></sup></p> <p>Something<sup id="fnref:540"><a class="footnote-ref" href="#fn:540" rel="footnote">540</a></sup></p> <p>Something<sup id="fnref:541"><a class="footnote-ref" href="#fn:541" rel="footnote">541</a></sup></p> <p>Something<sup id="fnref:542"><a class="footnote-ref" href="#fn:542" rel="footnote">542</a></sup></p> <p>Something<sup id="fnref:543"><a class="footnote-ref" href="#fn:543" rel="footnote">543</a></sup></p> <p>Something<sup id="fnref:544"><a class="footnote-ref" href="#fn:544" rel="footnote">544</a></sup></p> <p>Something<sup id="fnref:545"><a class="footnote-ref" href="#fn:545" rel="footnote">545</a></sup></p> <p>Something<sup id="fnref:546"><a class="footnote-ref" href="#fn:546" rel="footnote">546</a></sup></p> <p>Something<sup id="fnref:547"><a class="footnote-ref" href="#fn:547" rel="footnote">547</a></sup></p> <p>Something<sup id="fnref:548"><a class="footnote-ref" href="#fn:548" rel="footnote">548</a></sup></p> <p>Something<sup id="fnref:549"><a class="footnote-ref" href="#fn:549" rel="footnote">549</a></sup></p> <p>Something<sup id="fnref:550"><a class="footnote-ref" href="#fn:550" rel="footnote">550</a></sup></p> <p>Something<sup id="fnref:551"><a class="footnote-ref" href="#fn:551" rel="footnote">551</a></sup></p> <p>Something<sup id="fnref:552"><a class="footnote-ref" href="#fn:552" rel="footnote">552</a></sup></p> <p>Something<sup id="fnref:553"><a class="footnote-ref" href="#fn:553" rel="footnote">553</a></sup></p> <p>Something<sup id="fnref:554"><a class="footnote-ref" href="#fn:554" rel="footnote">554</a></sup></p> <p>Something<sup id="fnref:555"><a class="footnote-ref" href="#fn:555" rel="footnote">555</a></sup></p> <p>Something<sup id="fnref:556"><a class="footnote-ref" href="#fn:556" rel="footnote">556</a></sup></p> <p>Something<sup id="fnref:557"><a class="footnote-ref" href="#fn:557" rel="footnote">557</a></sup></p> <p>Something<sup id="fnref:558"><a class="footnote-ref" href="#fn:558" rel="footnote">558</a></sup></p> <p>Something<sup id="fnref:559"><a class="footnote-ref" href="#fn:559" rel="footnote">559</a></sup></p> <p>Something<sup id="fnref:560"><a class="footnote-ref" href="#fn:560" rel="footnote">560</a></sup></p> <p>Something<sup id="fnref:561"><a class="footnote-ref" href="#fn:561" rel="footnote">561</a></sup></p> <p>Something<sup id="fnref:562"><a class="footnote-ref" href="#fn:562" rel="footnote">562</a></sup></p> <p>Something<sup id="fnref:563"><a class="footnote-ref" href="#fn:563" rel="footnote">563</a></sup></p> <p>Something<sup id="fnref:564"><a class="footnote-ref" href="#fn:564" rel="footnote">564</a></sup></p> <p>Something<sup id="fnref:565"><a class="footnote-ref" href="#fn:565" rel="footnote">565</a></sup></p> <p>Something<sup id="fnref:566"><a class="footnote-ref" href="#fn:566" rel="footnote">566</a></sup></p> <p>Something<sup id="fnref:567"><a class="footnote-ref" href="#fn:567" rel="footnote">567</a></sup></p> <p>Something<sup id="fnref:568"><a class="footnote-ref" href="#fn:568" rel="footnote">568</a></sup></p> <p>Something<sup id="fnref:569"><a class="footnote-ref" href="#fn:569" rel="footnote">569</a></sup></p> <p>Something<sup id="fnref:570"><a class="footnote-ref" href="#fn:570" rel="footnote">570</a></sup></p> <p>Something<sup id="fnref:571"><a class="footnote-ref" href="#fn:571" rel="footnote">571</a></sup></p> <p>Something<sup id="fnref:572"><a class="footnote-ref" href="#fn:572" rel="footnote">572</a></sup></p> <p>Something<sup id="fnref:573"><a class="footnote-ref" href="#fn:573" rel="footnote">573</a></sup></p> <p>Something<sup id="fnref:574"><a class="footnote-ref" href="#fn:574" rel="footnote">574</a></sup></p> <p>Something<sup id="fnref:575"><a class="footnote-ref" href="#fn:575" rel="footnote">575</a></sup></p> <p>Something<sup id="fnref:576"><a class="footnote-ref" href="#fn:576" rel="footnote">576</a></sup></p> <p>Something<sup id="fnref:577"><a class="footnote-ref" href="#fn:577" rel="footnote">577</a></sup></p> <p>Something<sup id="fnref:578"><a class="footnote-ref" href="#fn:578" rel="footnote">578</a></sup></p> <p>Something<sup id="fnref:579"><a class="footnote-ref" href="#fn:579" rel="footnote">579</a></sup></p> <p>Something<sup id="fnref:580"><a class="footnote-ref" href="#fn:580" rel="footnote">580</a></sup></p> <p>Something<sup id="fnref:581"><a class="footnote-ref" href="#fn:581" rel="footnote">581</a></sup></p> <p>Something<sup id="fnref:582"><a class="footnote-ref" href="#fn:582" rel="footnote">582</a></sup></p> <p>Something<sup id="fnref:583"><a class="footnote-ref" href="#fn:583" rel="footnote">583</a></sup></p> <p>Something<sup id="fnref:584"><a class="footnote-ref" href="#fn:584" rel="footnote">584</a></sup></p> <p>Something<sup id="fnref:585"><a class="footnote-ref" href="#fn:585" rel="footnote">585</a></sup></p> <p>Something<sup id="fnref:586"><a class="footnote-ref" href="#fn:586" rel="footnote">586</a></sup></p> <p>Something<sup id="fnref:587"><a class="footnote-ref" href="#fn:587" rel="footnote">587</a></sup></p> <p>Something<sup id="fnref:588"><a class="footnote-ref" href="#fn:588" rel="footnote">588</a></sup></p> <p>Something<sup id="fnref:589"><a class="footnote-ref" href="#fn:589" rel="footnote">589</a></sup></p> <p>Something<sup id="fnref:590"><a class="footnote-ref" href="#fn:590" rel="footnote">590</a></sup></p> <p>Something<sup id="fnref:591"><a class="footnote-ref" href="#fn:591" rel="footnote">591</a></sup></p> <p>Something<sup id="fnref:592"><a class="footnote-ref" href="#fn:592" rel="footnote">592</a></sup></p> <p>Something<sup id="fnref:593"><a class="footnote-ref" href="#fn:593" rel="footnote">593</a></sup></p> <p>Something<sup id="fnref:594"><a class="footnote-ref" href="#fn:594" rel="footnote">594</a></sup></p> <p>Something<sup id="fnref:595"><a class="footnote-ref" href="#fn:595" rel="footnote">595</a></sup></p> <p>Something<sup id="fnref:596"><a class="footnote-ref" href="#fn:596" rel="footnote">596</a></sup></p> <p>Something<sup id="fnref:597"><a class="footnote-ref" href="#fn:597" rel="footnote">597</a></sup></p> <p>Something<sup id="fnref:598"><a class="footnote-ref" href="#fn:598" rel="footnote">598</a></sup></p> <p>Something<sup id="fnref:599"><a class="footnote-ref" href="#fn:599" rel="footnote">599</a></sup></p> <p>Something<sup id="fnref:600"><a class="footnote-ref" href="#fn:600" rel="footnote">600</a></sup></p> <p>Something<sup id="fnref:601"><a class="footnote-ref" href="#fn:601" rel="footnote">601</a></sup></p> <p>Something<sup id="fnref:602"><a class="footnote-ref" href="#fn:602" rel="footnote">602</a></sup></p> <p>Something<sup id="fnref:603"><a class="footnote-ref" href="#fn:603" rel="footnote">603</a></sup></p> <p>Something<sup id="fnref:604"><a class="footnote-ref" href="#fn:604" rel="footnote">604</a></sup></p> <p>Something<sup id="fnref:605"><a class="footnote-ref" href="#fn:605" rel="footnote">605</a></sup></p> <p>Something<sup id="fnref:606"><a class="footnote-ref" href="#fn:606" rel="footnote">606</a></sup></p> <p>Something<sup id="fnref:607"><a class="footnote-ref" href="#fn:607" rel="footnote">607</a></sup></p> <p>Something<sup id="fnref:608"><a class="footnote-ref" href="#fn:608" rel="footnote">608</a></sup></p> <p>Something<sup id="fnref:609"><a class="footnote-ref" href="#fn:609" rel="footnote">609</a></sup></p> <p>Something<sup id="fnref:610"><a class="footnote-ref" href="#fn:610" rel="footnote">610</a></sup></p> <p>Something<sup id="fnref:611"><a class="footnote-ref" href="#fn:611" rel="footnote">611</a></sup></p> <p>Something<sup id="fnref:612"><a class="footnote-ref" href="#fn:612" rel="footnote">612</a></sup></p> <p>Something<sup id="fnref:613"><a class="footnote-ref" href="#fn:613" rel="footnote">613</a></sup></p> <p>Something<sup id="fnref:614"><a class="footnote-ref" href="#fn:614" rel="footnote">614</a></sup></p> <p>Something<sup id="fnref:615"><a class="footnote-ref" href="#fn:615" rel="footnote">615</a></sup></p> <p>Something<sup id="fnref:616"><a class="footnote-ref" href="#fn:616" rel="footnote">616</a></sup></p> <p>Something<sup id="fnref:617"><a class="footnote-ref" href="#fn:617" rel="footnote">617</a></sup></p> <p>Something<sup id="fnref:618"><a class="footnote-ref" href="#fn:618" rel="footnote">618</a></sup></p> <p>Something<sup id="fnref:619"><a class="footnote-ref" href="#fn:619" rel="footnote">619</a></sup></p> <p>Something<sup id="fnref:620"><a class="footnote-ref" href="#fn:620" rel="footnote">620</a></sup></p> <p>Something<sup id="fnref:621"><a class="footnote-ref" href="#fn:621" rel="footnote">621</a></sup></p> <p>Something<sup id="fnref:622"><a class="footnote-ref" href="#fn:622" rel="footnote">622</a></sup></p> <p>Something<sup id="fnref:623"><a class="footnote-ref" href="#fn:623" rel="footnote">623</a></sup></p> <p>Something<sup id="fnref:624"><a class="footnote-ref" href="#fn:624" rel="footnote">624</a></sup></p> <p>Something<sup id="fnref:625"><a class="footnote-ref" href="#fn:625" rel="footnote">625</a></sup></p> <p>Something<sup id="fnref:626"><a class="footnote-ref" href="#fn:626" rel="footnote">626</a></sup></p> <p>Something<sup id="fnref:627"><a class="footnote-ref" href="#fn:627" rel="footnote">627</a></sup></p> <p>Something<sup id="fnref:628"><a class="footnote-ref" href="#fn:628" rel="footnote">628</a></sup></p> <p>Something<sup id="fnref:629"><a class="footnote-ref" href="#fn:629" rel="footnote">629</a></sup></p> <p>Something<sup id="fnref:630"><a class="footnote-ref" href="#fn:630" rel="footnote">630</a></sup></p> <p>Something<sup id="fnref:631"><a class="footnote-ref" href="#fn:631" rel="footnote">631</a></sup></p> <p>Something<sup id="fnref:632"><a class="footnote-ref" href="#fn:632" rel="footnote">632</a></sup></p> <p>Something<sup id="fnref:633"><a class="footnote-ref" href="#fn:633" rel="footnote">633</a></sup></p> <p>Something<sup id="fnref:634"><a class="footnote-ref" href="#fn:634" rel="footnote">634</a></sup></p> <p>Something<sup id="fnref:635"><a class="footnote-ref" href="#fn:635" rel="footnote">635</a></sup></p> <p>Something<sup id="fnref:636"><a class="footnote-ref" href="#fn:636" rel="footnote">636</a></sup></p> <p>Something<sup id="fnref:637"><a class="footnote-ref" href="#fn:637" rel="footnote">637</a></sup></p> <p>Something<sup id="fnref:638"><a class="footnote-ref" href="#fn:638" rel="footnote">638</a></sup></p> <p>Something<sup id="fnref:639"><a class="footnote-ref" href="#fn:639" rel="footnote">639</a></sup></p> <p>Something<sup id="fnref:640"><a class="footnote-ref" href="#fn:640" rel="footnote">640</a></sup></p> <p>Something<sup id="fnref:641"><a class="footnote-ref" href="#fn:641" rel="footnote">641</a></sup></p> <p>Something<sup id="fnref:642"><a class="footnote-ref" href="#fn:642" rel="footnote">642</a></sup></p> <p>Something<sup id="fnref:643"><a class="footnote-ref" href="#fn:643" rel="footnote">643</a></sup></p> <p>Something<sup id="fnref:644"><a class="footnote-ref" href="#fn:644" rel="footnote">644</a></sup></p> <p>Something<sup id="fnref:645"><a class="footnote-ref" href="#fn:645" rel="footnote">645</a></sup></p> <p>Something<sup id="fnref:646"><a class="footnote-ref" href="#fn:646" rel="footnote">646</a></sup></p> <p>Something<sup id="fnref:647"><a class="footnote-ref" href="#fn:647" rel="footnote">647</a></sup></p> <p>Something<sup id="fnref:648"><a class="footnote-ref" href="#fn:648" rel="footnote">648</a></sup></p> <p>Something<sup id="fnref:649"><a class="footnote-ref" href="#fn:649" rel="footnote">649</a></sup></p> <p>Something<sup id="fnref:650"><a class="footnote-ref" href="#fn:650" rel="footnote">650</a></sup></p> <p>Something<sup id="fnref:651"><a class="footnote-ref" href="#fn:651" rel="footnote">651</a></sup></p> <p>Something<sup id="fnref:652"><a class="footnote-ref" href="#fn:652" rel="footnote">652</a></sup></p> <p>Something<sup id="fnref:653"><a class="footnote-ref" href="#fn:653" rel="footnote">653</a></sup></p> <p>Something<sup id="fnref:654"><a class="footnote-ref" href="#fn:654" rel="footnote">654</a></sup></p> <p>Something<sup id="fnref:655"><a class="footnote-ref" href="#fn:655" rel="footnote">655</a></sup></p> <p>Something<sup id="fnref:656"><a class="footnote-ref" href="#fn:656" rel="footnote">656</a></sup></p> <p>Something<sup id="fnref:657"><a class="footnote-ref" href="#fn:657" rel="footnote">657</a></sup></p> <p>Something<sup id="fnref:658"><a class="footnote-ref" href="#fn:658" rel="footnote">658</a></sup></p> <p>Something<sup id="fnref:659"><a class="footnote-ref" href="#fn:659" rel="footnote">659</a></sup></p> <p>Something<sup id="fnref:660"><a class="footnote-ref" href="#fn:660" rel="footnote">660</a></sup></p> <p>Something<sup id="fnref:661"><a class="footnote-ref" href="#fn:661" rel="footnote">661</a></sup></p> <p>Something<sup id="fnref:662"><a class="footnote-ref" href="#fn:662" rel="footnote">662</a></sup></p> <p>Something<sup id="fnref:663"><a class="footnote-ref" href="#fn:663" rel="footnote">663</a></sup></p> <p>Something<sup id="fnref:664"><a class="footnote-ref" href="#fn:664" rel="footnote">664</a></sup></p> <p>Something<sup id="fnref:665"><a class="footnote-ref" href="#fn:665" rel="footnote">665</a></sup></p> <p>Something<sup id="fnref:666"><a class="footnote-ref" href="#fn:666" rel="footnote">666</a></sup></p> <p>Something<sup id="fnref:667"><a class="footnote-ref" href="#fn:667" rel="footnote">667</a></sup></p> <p>Something<sup id="fnref:668"><a class="footnote-ref" href="#fn:668" rel="footnote">668</a></sup></p> <p>Something<sup id="fnref:669"><a class="footnote-ref" href="#fn:669" rel="footnote">669</a></sup></p> <p>Something<sup id="fnref:670"><a class="footnote-ref" href="#fn:670" rel="footnote">670</a></sup></p> <p>Something<sup id="fnref:671"><a class="footnote-ref" href="#fn:671" rel="footnote">671</a></sup></p> <p>Something<sup id="fnref:672"><a class="footnote-ref" href="#fn:672" rel="footnote">672</a></sup></p> <p>Something<sup id="fnref:673"><a class="footnote-ref" href="#fn:673" rel="footnote">673</a></sup></p> <p>Something<sup id="fnref:674"><a class="footnote-ref" href="#fn:674" rel="footnote">674</a></sup></p> <p>Something<sup id="fnref:675"><a class="footnote-ref" href="#fn:675" rel="footnote">675</a></sup></p> <p>Something<sup id="fnref:676"><a class="footnote-ref" href="#fn:676" rel="footnote">676</a></sup></p> <p>Something<sup id="fnref:677"><a class="footnote-ref" href="#fn:677" rel="footnote">677</a></sup></p> <p>Something<sup id="fnref:678"><a class="footnote-ref" href="#fn:678" rel="footnote">678</a></sup></p> <p>Something<sup id="fnref:679"><a class="footnote-ref" href="#fn:679" rel="footnote">679</a></sup></p> <p>Something<sup id="fnref:680"><a class="footnote-ref" href="#fn:680" rel="footnote">680</a></sup></p> <p>Something<sup id="fnref:681"><a class="footnote-ref" href="#fn:681" rel="footnote">681</a></sup></p> <p>Something<sup id="fnref:682"><a class="footnote-ref" href="#fn:682" rel="footnote">682</a></sup></p> <p>Something<sup id="fnref:683"><a class="footnote-ref" href="#fn:683" rel="footnote">683</a></sup></p> <p>Something<sup id="fnref:684"><a class="footnote-ref" href="#fn:684" rel="footnote">684</a></sup></p> <p>Something<sup id="fnref:685"><a class="footnote-ref" href="#fn:685" rel="footnote">685</a></sup></p> <p>Something<sup id="fnref:686"><a class="footnote-ref" href="#fn:686" rel="footnote">686</a></sup></p> <p>Something<sup id="fnref:687"><a class="footnote-ref" href="#fn:687" rel="footnote">687</a></sup></p> <p>Something<sup id="fnref:688"><a class="footnote-ref" href="#fn:688" rel="footnote">688</a></sup></p> <p>Something<sup id="fnref:689"><a class="footnote-ref" href="#fn:689" rel="footnote">689</a></sup></p> <p>Something<sup id="fnref:690"><a class="footnote-ref" href="#fn:690" rel="footnote">690</a></sup></p> <p>Something<sup id="fnref:691"><a class="footnote-ref" href="#fn:691" rel="footnote">691</a></sup></p> <p>Something<sup id="fnref:692"><a class="footnote-ref" href="#fn:692" rel="footnote">692</a></sup></p> <p>Something<sup id="fnref:693"><a class="footnote-ref" href="#fn:693" rel="footnote">693</a></sup></p> <p>Something<sup id="fnref:694"><a class="footnote-ref" href="#fn:694" rel="footnote">694</a></sup></p> <p>Something<sup id="fnref:695"><a class="footnote-ref" href="#fn:695" rel="footnote">695</a></sup></p> <p>Something<sup id="fnref:696"><a class="footnote-ref" href="#fn:696" rel="footnote">696</a></sup></p> <p>Something<sup id="fnref:697"><a class="footnote-ref" href="#fn:697" rel="footnote">697</a></sup></p> <p>Something<sup id="fnref:698"><a class="footnote-ref" href="#fn:698" rel="footnote">698</a></sup></p> <p>Something<sup id="fnref:699"><a class="footnote-ref" href="#fn:699" rel="footnote">699</a></sup></p> <p>Something<sup id="fnref:700"><a class="footnote-ref" href="#fn:700" rel="footnote">700</a></sup></p> <p>Something<sup id="fnref:701"><a class="footnote-ref" href="#fn:701" rel="footnote">701</a></sup></p> <p>Something<sup id="fnref:702"><a class="footnote-ref" href="#fn:702" rel="footnote">702</a></sup></p> <p>Something<sup id="fnref:703"><a class="footnote-ref" href="#fn:703" rel="footnote">703</a></sup></p> <p>Something<sup id="fnref:704"><a class="footnote-ref" href="#fn:704" rel="footnote">704</a></sup></p> <p>Something<sup id="fnref:705"><a class="footnote-ref" href="#fn:705" rel="footnote">705</a></sup></p> <p>Something<sup id="fnref:706"><a class="footnote-ref" href="#fn:706" rel="footnote">706</a></sup></p> <p>Something<sup id="fnref:707"><a class="footnote-ref" href="#fn:707" rel="footnote">707</a></sup></p> <p>Something<sup id="fnref:708"><a class="footnote-ref" href="#fn:708" rel="footnote">708</a></sup></p> <p>Something<sup id="fnref:709"><a class="footnote-ref" href="#fn:709" rel="footnote">709</a></sup></p> <p>Something<sup id="fnref:710"><a class="footnote-ref" href="#fn:710" rel="footnote">710</a></sup></p> <p>Something<sup id="fnref:711"><a class="footnote-ref" href="#fn:711" rel="footnote">711</a></sup></p> <p>Something<sup id="fnref:712"><a class="footnote-ref" href="#fn:712" rel="footnote">712</a></sup></p> <p>Something<sup id="fnref:713"><a class="footnote-ref" href="#fn:713" rel="footnote">713</a></sup></p> <p>Something<sup id="fnref:714"><a class="footnote-ref" href="#fn:714" rel="footnote">714</a></sup></p> <p>Something<sup id="fnref:715"><a class="footnote-ref" href="#fn:715" rel="footnote">715</a></sup></p> <p>Something<sup id="fnref:716"><a class="footnote-ref" href="#fn:716" rel="footnote">716</a></sup></p> <p>Something<sup id="fnref:717"><a class="footnote-ref" href="#fn:717" rel="footnote">717</a></sup></p> <p>Something<sup id="fnref:718"><a class="footnote-ref" href="#fn:718" rel="footnote">718</a></sup></p> <p>Something<sup id="fnref:719"><a class="footnote-ref" href="#fn:719" rel="footnote">719</a></sup></p> <p>Something<sup id="fnref:720"><a class="footnote-ref" href="#fn:720" rel="footnote">720</a></sup></p> <p>Something<sup id="fnref:721"><a class="footnote-ref" href="#fn:721" rel="footnote">721</a></sup></p> <p>Something<sup id="fnref:722"><a class="footnote-ref" href="#fn:722" rel="footnote">722</a></sup></p> <p>Something<sup id="fnref:723"><a class="footnote-ref" href="#fn:723" rel="footnote">723</a></sup></p> <p>Something<sup id="fnref:724"><a class="footnote-ref" href="#fn:724" rel="footnote">724</a></sup></p> <p>Something<sup id="fnref:725"><a class="footnote-ref" href="#fn:725" rel="footnote">725</a></sup></p> <p>Something<sup id="fnref:726"><a class="footnote-ref" href="#fn:726" rel="footnote">726</a></sup></p> <p>Something<sup id="fnref:727"><a class="footnote-ref" href="#fn:727" rel="footnote">727</a></sup></p> <p>Something<sup id="fnref:728"><a class="footnote-ref" href="#fn:728" rel="footnote">728</a></sup></p> <p>Something<sup id="fnref:729"><a class="footnote-ref" href="#fn:729" rel="footnote">729</a></sup></p> <p>Something<sup id="fnref:730"><a class="footnote-ref" href="#fn:730" rel="footnote">730</a></sup></p> <p>Something<sup id="fnref:731"><a class="footnote-ref" href="#fn:731" rel="footnote">731</a></sup></p> <p>Something<sup id="fnref:732"><a class="footnote-ref" href="#fn:732" rel="footnote">732</a></sup></p> <p>Something<sup id="fnref:733"><a class="footnote-ref" href="#fn:733" rel="footnote">733</a></sup></p> <p>Something<sup id="fnref:734"><a class="footnote-ref" href="#fn:734" rel="footnote">734</a></sup></p> <p>Something<sup id="fnref:735"><a class="footnote-ref" href="#fn:735" rel="footnote">735</a></sup></p> <p>Something<sup id="fnref:736"><a class="footnote-ref" href="#fn:736" rel="footnote">736</a></sup></p> <p>Something<sup id="fnref:737"><a class="footnote-ref" href="#fn:737" rel="footnote">737</a></sup></p> <p>Something<sup id="fnref:738"><a class="footnote-ref" href="#fn:738" rel="footnote">738</a></sup></p> <p>Something<sup id="fnref:739"><a class="footnote-ref" href="#fn:739" rel="footnote">739</a></sup></p> <p>Something<sup id="fnref:740"><a class="footnote-ref" href="#fn:740" rel="footnote">740</a></sup></p> <p>Something<sup id="fnref:741"><a class="footnote-ref" href="#fn:741" rel="footnote">741</a></sup></p> <p>Something<sup id="fnref:742"><a class="footnote-ref" href="#fn:742" rel="footnote">742</a></sup></p> <p>Something<sup id="fnref:743"><a class="footnote-ref" href="#fn:743" rel="footnote">743</a></sup></p> <p>Something<sup id="fnref:744"><a class="footnote-ref" href="#fn:744" rel="footnote">744</a></sup></p> <p>Something<sup id="fnref:745"><a class="footnote-ref" href="#fn:745" rel="footnote">745</a></sup></p> <p>Something<sup id="fnref:746"><a class="footnote-ref" href="#fn:746" rel="footnote">746</a></sup></p> <p>Something<sup id="fnref:747"><a class="footnote-ref" href="#fn:747" rel="footnote">747</a></sup></p> <p>Something<sup id="fnref:748"><a class="footnote-ref" href="#fn:748" rel="footnote">748</a></sup></p> <p>Something<sup id="fnref:749"><a class="footnote-ref" href="#fn:749" rel="footnote">749</a></sup></p> <p>Something<sup id="fnref:750"><a class="footnote-ref" href="#fn:750" rel="footnote">750</a></sup></p> <p>Something<sup id="fnref:751"><a class="footnote-ref" href="#fn:751" rel="footnote">751</a></sup></p> <p>Something<sup id="fnref:752"><a class="footnote-ref" href="#fn:752" rel="footnote">752</a></sup></p> <p>Something<sup id="fnref:753"><a class="footnote-ref" href="#fn:753" rel="footnote">753</a></sup></p> <p>Something<sup id="fnref:754"><a class="footnote-ref" href="#fn:754" rel="footnote">754</a></sup></p> <p>Something<sup id="fnref:755"><a class="footnote-ref" href="#fn:755" rel="footnote">755</a></sup></p> <p>Something<sup id="fnref:756"><a class="footnote-ref" href="#fn:756" rel="footnote">756</a></sup></p> <p>Something<sup id="fnref:757"><a class="footnote-ref" href="#fn:757" rel="footnote">757</a></sup></p> <p>Something<sup id="fnref:758"><a class="footnote-ref" href="#fn:758" rel="footnote">758</a></sup></p> <p>Something<sup id="fnref:759"><a class="footnote-ref" href="#fn:759" rel="footnote">759</a></sup></p> <p>Something<sup id="fnref:760"><a class="footnote-ref" href="#fn:760" rel="footnote">760</a></sup></p> <p>Something<sup id="fnref:761"><a class="footnote-ref" href="#fn:761" rel="footnote">761</a></sup></p> <p>Something<sup id="fnref:762"><a class="footnote-ref" href="#fn:762" rel="footnote">762</a></sup></p> <p>Something<sup id="fnref:763"><a class="footnote-ref" href="#fn:763" rel="footnote">763</a></sup></p> <p>Something<sup id="fnref:764"><a class="footnote-ref" href="#fn:764" rel="footnote">764</a></sup></p> <p>Something<sup id="fnref:765"><a class="footnote-ref" href="#fn:765" rel="footnote">765</a></sup></p> <p>Something<sup id="fnref:766"><a class="footnote-ref" href="#fn:766" rel="footnote">766</a></sup></p> <p>Something<sup id="fnref:767"><a class="footnote-ref" href="#fn:767" rel="footnote">767</a></sup></p> <p>Something<sup id="fnref:768"><a class="footnote-ref" href="#fn:768" rel="footnote">768</a></sup></p> <p>Something<sup id="fnref:769"><a class="footnote-ref" href="#fn:769" rel="footnote">769</a></sup></p> <p>Something<sup id="fnref:770"><a class="footnote-ref" href="#fn:770" rel="footnote">770</a></sup></p> <p>Something<sup id="fnref:771"><a class="footnote-ref" href="#fn:771" rel="footnote">771</a></sup></p> <p>Something<sup id="fnref:772"><a class="footnote-ref" href="#fn:772" rel="footnote">772</a></sup></p> <p>Something<sup id="fnref:773"><a class="footnote-ref" href="#fn:773" rel="footnote">773</a></sup></p> <p>Something<sup id="fnref:774"><a class="footnote-ref" href="#fn:774" rel="footnote">774</a></sup></p> <p>Something<sup id="fnref:775"><a class="footnote-ref" href="#fn:775" rel="footnote">775</a></sup></p> <p>Something<sup id="fnref:776"><a class="footnote-ref" href="#fn:776" rel="footnote">776</a></sup></p> <p>Something<sup id="fnref:777"><a class="footnote-ref" href="#fn:777" rel="footnote">777</a></sup></p> <p>Something<sup id="fnref:778"><a class="footnote-ref" href="#fn:778" rel="footnote">778</a></sup></p> <p>Something<sup id="fnref:779"><a class="footnote-ref" href="#fn:779" rel="footnote">779</a></sup></p> <p>Something<sup id="fnref:780"><a class="footnote-ref" href="#fn:780" rel="footnote">780</a></sup></p> <p>Something<sup id="fnref:781"><a class="footnote-ref" href="#fn:781" rel="footnote">781</a></sup></p> <p>Something<sup id="fnref:782"><a class="footnote-ref" href="#fn:782" rel="footnote">782</a></sup></p> <p>Something<sup id="fnref:783"><a class="footnote-ref" href="#fn:783" rel="footnote">783</a></sup></p> <p>Something<sup id="fnref:784"><a class="footnote-ref" href="#fn:784" rel="footnote">784</a></sup></p> <p>Something<sup id="fnref:785"><a class="footnote-ref" href="#fn:785" rel="footnote">785</a></sup></p> <p>Something<sup id="fnref:786"><a class="footnote-ref" href="#fn:786" rel="footnote">786</a></sup></p> <p>Something<sup id="fnref:787"><a class="footnote-ref" href="#fn:787" rel="footnote">787</a></sup></p> <p>Something<sup id="fnref:788"><a class="footnote-ref" href="#fn:788" rel="footnote">788</a></sup></p> <p>Something<sup id="fnref:789"><a class="footnote-ref" href="#fn:789" rel="footnote">789</a></sup></p> <p>Something<sup id="fnref:790"><a class="footnote-ref" href="#fn:790" rel="footnote">790</a></sup></p> <p>Something<sup id="fnref:791"><a class="footnote-ref" href="#fn:791" rel="footnote">791</a></sup></p> <p>Something<sup id="fnref:792"><a class="footnote-ref" href="#fn:792" rel="footnote">792</a></sup></p> <p>Something<sup id="fnref:793"><a class="footnote-ref" href="#fn:793" rel="footnote">793</a></sup></p> <p>Something<sup id="fnref:794"><a class="footnote-ref" href="#fn:794" rel="footnote">794</a></sup></p> <p>Something<sup id="fnref:795"><a class="footnote-ref" href="#fn:795" rel="footnote">795</a></sup></p> <p>Something<sup id="fnref:796"><a class="footnote-ref" href="#fn:796" rel="footnote">796</a></sup></p> <p>Something<sup id="fnref:797"><a class="footnote-ref" href="#fn:797" rel="footnote">797</a></sup></p> <p>Something<sup id="fnref:798"><a class="footnote-ref" href="#fn:798" rel="footnote">798</a></sup></p> <p>Something<sup id="fnref:799"><a class="footnote-ref" href="#fn:799" rel="footnote">799</a></sup></p> <p>Something<sup id="fnref:800"><a class="footnote-ref" href="#fn:800" rel="footnote">800</a></sup></p> <p>Something<sup id="fnref:801"><a class="footnote-ref" href="#fn:801" rel="footnote">801</a></sup></p> <p>Something<sup id="fnref:802"><a class="footnote-ref" href="#fn:802" rel="footnote">802</a></sup></p> <p>Something<sup id="fnref:803"><a class="footnote-ref" href="#fn:803" rel="footnote">803</a></sup></p> <p>Something<sup id="fnref:804"><a class="footnote-ref" href="#fn:804" rel="footnote">804</a></sup></p> <p>Something<sup id="fnref:805"><a class="footnote-ref" href="#fn:805" rel="footnote">805</a></sup></p> <p>Something<sup id="fnref:806"><a class="footnote-ref" href="#fn:806" rel="footnote">806</a></sup></p> <p>Something<sup id="fnref:807"><a class="footnote-ref" href="#fn:807" rel="footnote">807</a></sup></p> <p>Something<sup id="fnref:808"><a class="footnote-ref" href="#fn:808" rel="footnote">808</a></sup></p> <p>Something<sup id="fnref:809"><a class="footnote-ref" href="#fn:809" rel="footnote">809</a></sup></p> <p>Something<sup id="fnref:810"><a class="footnote-ref" href="#fn:810" rel="footnote">810</a></sup></p> <p>Something<sup id="fnref:811"><a class="footnote-ref" href="#fn:811" rel="footnote">811</a></sup></p> <p>Something<sup id="fnref:812"><a class="footnote-ref" href="#fn:812" rel="footnote">812</a></sup></p> <p>Something<sup id="fnref:813"><a class="footnote-ref" href="#fn:813" rel="footnote">813</a></sup></p> <p>Something<sup id="fnref:814"><a class="footnote-ref" href="#fn:814" rel="footnote">814</a></sup></p> <p>Something<sup id="fnref:815"><a class="footnote-ref" href="#fn:815" rel="footnote">815</a></sup></p> <p>Something<sup id="fnref:816"><a class="footnote-ref" href="#fn:816" rel="footnote">816</a></sup></p> <p>Something<sup id="fnref:817"><a class="footnote-ref" href="#fn:817" rel="footnote">817</a></sup></p> <p>Something<sup id="fnref:818"><a class="footnote-ref" href="#fn:818" rel="footnote">818</a></sup></p> <p>Something<sup id="fnref:819"><a class="footnote-ref" href="#fn:819" rel="footnote">819</a></sup></p> <p>Something<sup id="fnref:820"><a class="footnote-ref" href="#fn:820" rel="footnote">820</a></sup></p> <p>Something<sup id="fnref:821"><a class="footnote-ref" href="#fn:821" rel="footnote">821</a></sup></p> <p>Something<sup id="fnref:822"><a class="footnote-ref" href="#fn:822" rel="footnote">822</a></sup></p> <p>Something<sup id="fnref:823"><a class="footnote-ref" href="#fn:823" rel="footnote">823</a></sup></p> <p>Something<sup id="fnref:824"><a class="footnote-ref" href="#fn:824" rel="footnote">824</a></sup></p> <p>Something<sup id="fnref:825"><a class="footnote-ref" href="#fn:825" rel="footnote">825</a></sup></p> <p>Something<sup id="fnref:826"><a class="footnote-ref" href="#fn:826" rel="footnote">826</a></sup></p> <p>Something<sup id="fnref:827"><a class="footnote-ref" href="#fn:827" rel="footnote">827</a></sup></p> <p>Something<sup id="fnref:828"><a class="footnote-ref" href="#fn:828" rel="footnote">828</a></sup></p> <p>Something<sup id="fnref:829"><a class="footnote-ref" href="#fn:829" rel="footnote">829</a></sup></p> <p>Something<sup id="fnref:830"><a class="footnote-ref" href="#fn:830" rel="footnote">830</a></sup></p> <p>Something<sup id="fnref:831"><a class="footnote-ref" href="#fn:831" rel="footnote">831</a></sup></p> <p>Something<sup id="fnref:832"><a class="footnote-ref" href="#fn:832" rel="footnote">832</a></sup></p> <p>Something<sup id="fnref:833"><a class="footnote-ref" href="#fn:833" rel="footnote">833</a></sup></p> <p>Something<sup id="fnref:834"><a class="footnote-ref" href="#fn:834" rel="footnote">834</a></sup></p> <p>Something<sup id="fnref:835"><a class="footnote-ref" href="#fn:835" rel="footnote">835</a></sup></p> <p>Something<sup id="fnref:836"><a class="footnote-ref" href="#fn:836" rel="footnote">836</a></sup></p> <p>Something<sup id="fnref:837"><a class="footnote-ref" href="#fn:837" rel="footnote">837</a></sup></p> <p>Something<sup id="fnref:838"><a class="footnote-ref" href="#fn:838" rel="footnote">838</a></sup></p> <p>Something<sup id="fnref:839"><a class="footnote-ref" href="#fn:839" rel="footnote">839</a></sup></p> <p>Something<sup id="fnref:840"><a class="footnote-ref" href="#fn:840" rel="footnote">840</a></sup></p> <p>Something<sup id="fnref:841"><a class="footnote-ref" href="#fn:841" rel="footnote">841</a></sup></p> <p>Something<sup id="fnref:842"><a class="footnote-ref" href="#fn:842" rel="footnote">842</a></sup></p> <p>Something<sup id="fnref:843"><a class="footnote-ref" href="#fn:843" rel="footnote">843</a></sup></p> <p>Something<sup id="fnref:844"><a class="footnote-ref" href="#fn:844" rel="footnote">844</a></sup></p> <p>Something<sup id="fnref:845"><a class="footnote-ref" href="#fn:845" rel="footnote">845</a></sup></p> <p>Something<sup id="fnref:846"><a class="footnote-ref" href="#fn:846" rel="footnote">846</a></sup></p> <p>Something<sup id="fnref:847"><a class="footnote-ref" href="#fn:847" rel="footnote">847</a></sup></p> <p>Something<sup id="fnref:848"><a class="footnote-ref" href="#fn:848" rel="footnote">848</a></sup></p> <p>Something<sup id="fnref:849"><a class="footnote-ref" href="#fn:849" rel="footnote">849</a></sup></p> <p>Something<sup id="fnref:850"><a class="footnote-ref" href="#fn:850" rel="footnote">850</a></sup></p> <p>Something<sup id="fnref:851"><a class="footnote-ref" href="#fn:851" rel="footnote">851</a></sup></p> <p>Something<sup id="fnref:852"><a class="footnote-ref" href="#fn:852" rel="footnote">852</a></sup></p> <p>Something<sup id="fnref:853"><a class="footnote-ref" href="#fn:853" rel="footnote">853</a></sup></p> <p>Something<sup id="fnref:854"><a class="footnote-ref" href="#fn:854" rel="footnote">854</a></sup></p> <p>Something<sup id="fnref:855"><a class="footnote-ref" href="#fn:855" rel="footnote">855</a></sup></p> <p>Something<sup id="fnref:856"><a class="footnote-ref" href="#fn:856" rel="footnote">856</a></sup></p> <p>Something<sup id="fnref:857"><a class="footnote-ref" href="#fn:857" rel="footnote">857</a></sup></p> <p>Something<sup id="fnref:858"><a class="footnote-ref" href="#fn:858" rel="footnote">858</a></sup></p> <p>Something<sup id="fnref:859"><a class="footnote-ref" href="#fn:859" rel="footnote">859</a></sup></p> <p>Something<sup id="fnref:860"><a class="footnote-ref" href="#fn:860" rel="footnote">860</a></sup></p> <p>Something<sup id="fnref:861"><a class="footnote-ref" href="#fn:861" rel="footnote">861</a></sup></p> <p>Something<sup id="fnref:862"><a class="footnote-ref" href="#fn:862" rel="footnote">862</a></sup></p> <p>Something<sup id="fnref:863"><a class="footnote-ref" href="#fn:863" rel="footnote">863</a></sup></p> <p>Something<sup id="fnref:864"><a class="footnote-ref" href="#fn:864" rel="footnote">864</a></sup></p> <p>Something<sup id="fnref:865"><a class="footnote-ref" href="#fn:865" rel="footnote">865</a></sup></p> <p>Something<sup id="fnref:866"><a class="footnote-ref" href="#fn:866" rel="footnote">866</a></sup></p> <p>Something<sup id="fnref:867"><a class="footnote-ref" href="#fn:867" rel="footnote">867</a></sup></p> <p>Something<sup id="fnref:868"><a class="footnote-ref" href="#fn:868" rel="footnote">868</a></sup></p> <p>Something<sup id="fnref:869"><a class="footnote-ref" href="#fn:869" rel="footnote">869</a></sup></p> <p>Something<sup id="fnref:870"><a class="footnote-ref" href="#fn:870" rel="footnote">870</a></sup></p> <p>Something<sup id="fnref:871"><a class="footnote-ref" href="#fn:871" rel="footnote">871</a></sup></p> <p>Something<sup id="fnref:872"><a class="footnote-ref" href="#fn:872" rel="footnote">872</a></sup></p> <p>Something<sup id="fnref:873"><a class="footnote-ref" href="#fn:873" rel="footnote">873</a></sup></p> <p>Something<sup id="fnref:874"><a class="footnote-ref" href="#fn:874" rel="footnote">874</a></sup></p> <p>Something<sup id="fnref:875"><a class="footnote-ref" href="#fn:875" rel="footnote">875</a></sup></p> <p>Something<sup id="fnref:876"><a class="footnote-ref" href="#fn:876" rel="footnote">876</a></sup></p> <p>Something<sup id="fnref:877"><a class="footnote-ref" href="#fn:877" rel="footnote">877</a></sup></p> <p>Something<sup id="fnref:878"><a class="footnote-ref" href="#fn:878" rel="footnote">878</a></sup></p> <p>Something<sup id="fnref:879"><a class="footnote-ref" href="#fn:879" rel="footnote">879</a></sup></p> <p>Something<sup id="fnref:880"><a class="footnote-ref" href="#fn:880" rel="footnote">880</a></sup></p> <p>Something<sup id="fnref:881"><a class="footnote-ref" href="#fn:881" rel="footnote">881</a></sup></p> <p>Something<sup id="fnref:882"><a class="footnote-ref" href="#fn:882" rel="footnote">882</a></sup></p> <p>Something<sup id="fnref:883"><a class="footnote-ref" href="#fn:883" rel="footnote">883</a></sup></p> <p>Something<sup id="fnref:884"><a class="footnote-ref" href="#fn:884" rel="footnote">884</a></sup></p> <p>Something<sup id="fnref:885"><a class="footnote-ref" href="#fn:885" rel="footnote">885</a></sup></p> <p>Something<sup id="fnref:886"><a class="footnote-ref" href="#fn:886" rel="footnote">886</a></sup></p> <p>Something<sup id="fnref:887"><a class="footnote-ref" href="#fn:887" rel="footnote">887</a></sup></p> <p>Something<sup id="fnref:888"><a class="footnote-ref" href="#fn:888" rel="footnote">888</a></sup></p> <p>Something<sup id="fnref:889"><a class="footnote-ref" href="#fn:889" rel="footnote">889</a></sup></p> <p>Something<sup id="fnref:890"><a class="footnote-ref" href="#fn:890" rel="footnote">890</a></sup></p> <p>Something<sup id="fnref:891"><a class="footnote-ref" href="#fn:891" rel="footnote">891</a></sup></p> <p>Something<sup id="fnref:892"><a class="footnote-ref" href="#fn:892" rel="footnote">892</a></sup></p> <p>Something<sup id="fnref:893"><a class="footnote-ref" href="#fn:893" rel="footnote">893</a></sup></p> <p>Something<sup id="fnref:894"><a class="footnote-ref" href="#fn:894" rel="footnote">894</a></sup></p> <p>Something<sup id="fnref:895"><a class="footnote-ref" href="#fn:895" rel="footnote">895</a></sup></p> <p>Something<sup id="fnref:896"><a class="footnote-ref" href="#fn:896" rel="footnote">896</a></sup></p> <p>Something<sup id="fnref:897"><a class="footnote-ref" href="#fn:897" rel="footnote">897</a></sup></p> <p>Something<sup id="fnref:898"><a class="footnote-ref" href="#fn:898" rel="footnote">898</a></sup></p> <p>Something<sup id="fnref:899"><a class="footnote-ref" href="#fn:899" rel="footnote">899</a></sup></p> <p>Something<sup id="fnref:900"><a class="footnote-ref" href="#fn:900" rel="footnote">900</a></sup></p> <p>Something<sup id="fnref:901"><a class="footnote-ref" href="#fn:901" rel="footnote">901</a></sup></p> <p>Something<sup id="fnref:902"><a class="footnote-ref" href="#fn:902" rel="footnote">902</a></sup></p> <p>Something<sup id="fnref:903"><a class="footnote-ref" href="#fn:903" rel="footnote">903</a></sup></p> <p>Something<sup id="fnref:904"><a class="footnote-ref" href="#fn:904" rel="footnote">904</a></sup></p> <p>Something<sup id="fnref:905"><a class="footnote-ref" href="#fn:905" rel="footnote">905</a></sup></p> <p>Something<sup id="fnref:906"><a class="footnote-ref" href="#fn:906" rel="footnote">906</a></sup></p> <p>Something<sup id="fnref:907"><a class="footnote-ref" href="#fn:907" rel="footnote">907</a></sup></p> <p>Something<sup id="fnref:908"><a class="footnote-ref" href="#fn:908" rel="footnote">908</a></sup></p> <p>Something<sup id="fnref:909"><a class="footnote-ref" href="#fn:909" rel="footnote">909</a></sup></p> <p>Something<sup id="fnref:910"><a class="footnote-ref" href="#fn:910" rel="footnote">910</a></sup></p> <p>Something<sup id="fnref:911"><a class="footnote-ref" href="#fn:911" rel="footnote">911</a></sup></p> <p>Something<sup id="fnref:912"><a class="footnote-ref" href="#fn:912" rel="footnote">912</a></sup></p> <p>Something<sup id="fnref:913"><a class="footnote-ref" href="#fn:913" rel="footnote">913</a></sup></p> <p>Something<sup id="fnref:914"><a class="footnote-ref" href="#fn:914" rel="footnote">914</a></sup></p> <p>Something<sup id="fnref:915"><a class="footnote-ref" href="#fn:915" rel="footnote">915</a></sup></p> <p>Something<sup id="fnref:916"><a class="footnote-ref" href="#fn:916" rel="footnote">916</a></sup></p> <p>Something<sup id="fnref:917"><a class="footnote-ref" href="#fn:917" rel="footnote">917</a></sup></p> <p>Something<sup id="fnref:918"><a class="footnote-ref" href="#fn:918" rel="footnote">918</a></sup></p> <p>Something<sup id="fnref:919"><a class="footnote-ref" href="#fn:919" rel="footnote">919</a></sup></p> <p>Something<sup id="fnref:920"><a class="footnote-ref" href="#fn:920" rel="footnote">920</a></sup></p> <p>Something<sup id="fnref:921"><a class="footnote-ref" href="#fn:921" rel="footnote">921</a></sup></p> <p>Something<sup id="fnref:922"><a class="footnote-ref" href="#fn:922" rel="footnote">922</a></sup></p> <p>Something<sup id="fnref:923"><a class="footnote-ref" href="#fn:923" rel="footnote">923</a></sup></p> <p>Something<sup id="fnref:924"><a class="footnote-ref" href="#fn:924" rel="footnote">924</a></sup></p> <p>Something<sup id="fnref:925"><a class="footnote-ref" href="#fn:925" rel="footnote">925</a></sup></p> <p>Something<sup id="fnref:926"><a class="footnote-ref" href="#fn:926" rel="footnote">926</a></sup></p> <p>Something<sup id="fnref:927"><a class="footnote-ref" href="#fn:927" rel="footnote">927</a></sup></p> <p>Something<sup id="fnref:928"><a class="footnote-ref" href="#fn:928" rel="footnote">928</a></sup></p> <p>Something<sup id="fnref:929"><a class="footnote-ref" href="#fn:929" rel="footnote">929</a></sup></p> <p>Something<sup id="fnref:930"><a class="footnote-ref" href="#fn:930" rel="footnote">930</a></sup></p> <p>Something<sup id="fnref:931"><a class="footnote-ref" href="#fn:931" rel="footnote">931</a></sup></p> <p>Something<sup id="fnref:932"><a class="footnote-ref" href="#fn:932" rel="footnote">932</a></sup></p> <p>Something<sup id="fnref:933"><a class="footnote-ref" href="#fn:933" rel="footnote">933</a></sup></p> <p>Something<sup id="fnref:934"><a class="footnote-ref" href="#fn:934" rel="footnote">934</a></sup></p> <p>Something<sup id="fnref:935"><a class="footnote-ref" href="#fn:935" rel="footnote">935</a></sup></p> <p>Something<sup id="fnref:936"><a class="footnote-ref" href="#fn:936" rel="footnote">936</a></sup></p> <p>Something<sup id="fnref:937"><a class="footnote-ref" href="#fn:937" rel="footnote">937</a></sup></p> <p>Something<sup id="fnref:938"><a class="footnote-ref" href="#fn:938" rel="footnote">938</a></sup></p> <p>Something<sup id="fnref:939"><a class="footnote-ref" href="#fn:939" rel="footnote">939</a></sup></p> <p>Something<sup id="fnref:940"><a class="footnote-ref" href="#fn:940" rel="footnote">940</a></sup></p> <p>Something<sup id="fnref:941"><a class="footnote-ref" href="#fn:941" rel="footnote">941</a></sup></p> <p>Something<sup id="fnref:942"><a class="footnote-ref" href="#fn:942" rel="footnote">942</a></sup></p> <p>Something<sup id="fnref:943"><a class="footnote-ref" href="#fn:943" rel="footnote">943</a></sup></p> <p>Something<sup id="fnref:944"><a class="footnote-ref" href="#fn:944" rel="footnote">944</a></sup></p> <p>Something<sup id="fnref:945"><a class="footnote-ref" href="#fn:945" rel="footnote">945</a></sup></p> <p>Something<sup id="fnref:946"><a class="footnote-ref" href="#fn:946" rel="footnote">946</a></sup></p> <p>Something<sup id="fnref:947"><a class="footnote-ref" href="#fn:947" rel="footnote">947</a></sup></p> <p>Something<sup id="fnref:948"><a class="footnote-ref" href="#fn:948" rel="footnote">948</a></sup></p> <p>Something<sup id="fnref:949"><a class="footnote-ref" href="#fn:949" rel="footnote">949</a></sup></p> <p>Something<sup id="fnref:950"><a class="footnote-ref" href="#fn:950" rel="footnote">950</a></sup></p> <p>Something<sup id="fnref:951"><a class="footnote-ref" href="#fn:951" rel="footnote">951</a></sup></p> <p>Something<sup id="fnref:952"><a class="footnote-ref" href="#fn:952" rel="footnote">952</a></sup></p> <p>Something<sup id="fnref:953"><a class="footnote-ref" href="#fn:953" rel="footnote">953</a></sup></p> <p>Something<sup id="fnref:954"><a class="footnote-ref" href="#fn:954" rel="footnote">954</a></sup></p> <p>Something<sup id="fnref:955"><a class="footnote-ref" href="#fn:955" rel="footnote">955</a></sup></p> <p>Something<sup id="fnref:956"><a class="footnote-ref" href="#fn:956" rel="footnote">956</a></sup></p> <p>Something<sup id="fnref:957"><a class="footnote-ref" href="#fn:957" rel="footnote">957</a></sup></p> <p>Something<sup id="fnref:958"><a class="footnote-ref" href="#fn:958" rel="footnote">958</a></sup></p> <p>Something<sup id="fnref:959"><a class="footnote-ref" href="#fn:959" rel="footnote">959</a></sup></p> <p>Something<sup id="fnref:960"><a class="footnote-ref" href="#fn:960" rel="footnote">960</a></sup></p> <p>Something<sup id="fnref:961"><a class="footnote-ref" href="#fn:961" rel="footnote">961</a></sup></p> <p>Something<sup id="fnref:962"><a class="footnote-ref" href="#fn:962" rel="footnote">962</a></sup></p> <p>Something<sup id="fnref:963"><a class="footnote-ref" href="#fn:963" rel="footnote">963</a></sup></p> <p>Something<sup id="fnref:964"><a class="footnote-ref" href="#fn:964" rel="footnote">964</a></sup></p> <p>Something<sup id="fnref:965"><a class="footnote-ref" href="#fn:965" rel="footnote">965</a></sup></p> <p>Something<sup id="fnref:966"><a class="footnote-ref" href="#fn:966" rel="footnote">966</a></sup></p> <p>Something<sup id="fnref:967"><a class="footnote-ref" href="#fn:967" rel="footnote">967</a></sup></p> <p>Something<sup id="fnref:968"><a class="footnote-ref" href="#fn:968" rel="footnote">968</a></sup></p> <p>Something<sup id="fnref:969"><a class="footnote-ref" href="#fn:969" rel="footnote">969</a></sup></p> <p>Something<sup id="fnref:970"><a class="footnote-ref" href="#fn:970" rel="footnote">970</a></sup></p> <p>Something<sup id="fnref:971"><a class="footnote-ref" href="#fn:971" rel="footnote">971</a></sup></p> <p>Something<sup id="fnref:972"><a class="footnote-ref" href="#fn:972" rel="footnote">972</a></sup></p> <p>Something<sup id="fnref:973"><a class="footnote-ref" href="#fn:973" rel="footnote">973</a></sup></p> <p>Something<sup id="fnref:974"><a class="footnote-ref" href="#fn:974" rel="footnote">974</a></sup></p> <p>Something<sup id="fnref:975"><a class="footnote-ref" href="#fn:975" rel="footnote">975</a></sup></p> <p>Something<sup id="fnref:976"><a class="footnote-ref" href="#fn:976" rel="footnote">976</a></sup></p> <p>Something<sup id="fnref:977"><a class="footnote-ref" href="#fn:977" rel="footnote">977</a></sup></p> <p>Something<sup id="fnref:978"><a class="footnote-ref" href="#fn:978" rel="footnote">978</a></sup></p> <p>Something<sup id="fnref:979"><a class="footnote-ref" href="#fn:979" rel="footnote">979</a></sup></p> <p>Something<sup id="fnref:980"><a class="footnote-ref" href="#fn:980" rel="footnote">980</a></sup></p> <p>Something<sup id="fnref:981"><a class="footnote-ref" href="#fn:981" rel="footnote">981</a></sup></p> <p>Something<sup id="fnref:982"><a class="footnote-ref" href="#fn:982" rel="footnote">982</a></sup></p> <p>Something<sup id="fnref:983"><a class="footnote-ref" href="#fn:983" rel="footnote">983</a></sup></p> <p>Something<sup id="fnref:984"><a class="footnote-ref" href="#fn:984" rel="footnote">984</a></sup></p> <p>Something<sup id="fnref:985"><a class="footnote-ref" href="#fn:985" rel="footnote">985</a></sup></p> <p>Something<sup id="fnref:986"><a class="footnote-ref" href="#fn:986" rel="footnote">986</a></sup></p> <p>Something<sup id="fnref:987"><a class="footnote-ref" href="#fn:987" rel="footnote">987</a></sup></p> <p>Something<sup id="fnref:988"><a class="footnote-ref" href="#fn:988" rel="footnote">988</a></sup></p> <p>Something<sup id="fnref:989"><a class="footnote-ref" href="#fn:989" rel="footnote">989</a></sup></p> <p>Something<sup id="fnref:990"><a class="footnote-ref" href="#fn:990" rel="footnote">990</a></sup></p> <p>Something<sup id="fnref:991"><a class="footnote-ref" href="#fn:991" rel="footnote">991</a></sup></p> <p>Something<sup id="fnref:992"><a class="footnote-ref" href="#fn:992" rel="footnote">992</a></sup></p> <p>Something<sup id="fnref:993"><a class="footnote-ref" href="#fn:993" rel="footnote">993</a></sup></p> <p>Something<sup id="fnref:994"><a class="footnote-ref" href="#fn:994" rel="footnote">994</a></sup></p> <p>Something<sup id="fnref:995"><a class="footnote-ref" href="#fn:995" rel="footnote">995</a></sup></p> <p>Something<sup id="fnref:996"><a class="footnote-ref" href="#fn:996" rel="footnote">996</a></sup></p> <p>Something<sup id="fnref:997"><a class="footnote-ref" href="#fn:997" rel="footnote">997</a></sup></p> <p>Something<sup id="fnref:998"><a class="footnote-ref" href="#fn:998" rel="footnote">998</a></sup></p> <p>Something<sup id="fnref:999"><a class="footnote-ref" href="#fn:999" rel="footnote">999</a></sup></p> <p>Something<sup id="fnref:1000"><a class="footnote-ref" href="#fn:1000" rel="footnote">1000</a></sup></p> <p>Something<sup id="fnref:1001"><a class="footnote-ref" href="#fn:1001" rel="footnote">1001</a></sup></p> <p>Something<sup id="fnref:1002"><a class="footnote-ref" href="#fn:1002" rel="footnote">1002</a></sup></p> <p>Something<sup id="fnref:1003"><a class="footnote-ref" href="#fn:1003" rel="footnote">1003</a></sup></p> <p>Something<sup id="fnref:1004"><a class="footnote-ref" href="#fn:1004" rel="footnote">1004</a></sup></p> <p>Something<sup id="fnref:1005"><a class="footnote-ref" href="#fn:1005" rel="footnote">1005</a></sup></p> <p>Something<sup id="fnref:1006"><a class="footnote-ref" href="#fn:1006" rel="footnote">1006</a></sup></p> <p>Something<sup id="fnref:1007"><a class="footnote-ref" href="#fn:1007" rel="footnote">1007</a></sup></p> <p>Something<sup id="fnref:1008"><a class="footnote-ref" href="#fn:1008" rel="footnote">1008</a></sup></p> <p>Something<sup id="fnref:1009"><a class="footnote-ref" href="#fn:1009" rel="footnote">1009</a></sup></p> <p>Something<sup id="fnref:1010"><a class="footnote-ref" href="#fn:1010" rel="footnote">1010</a></sup></p> <p>Something<sup id="fnref:1011"><a class="footnote-ref" href="#fn:1011" rel="footnote">1011</a></sup></p> <p>Something<sup id="fnref:1012"><a class="footnote-ref" href="#fn:1012" rel="footnote">1012</a></sup></p> <p>Something<sup id="fnref:1013"><a class="footnote-ref" href="#fn:1013" rel="footnote">1013</a></sup></p> <p>Something<sup id="fnref:1014"><a class="footnote-ref" href="#fn:1014" rel="footnote">1014</a></sup></p> <p>Something<sup id="fnref:1015"><a class="footnote-ref" href="#fn:1015" rel="footnote">1015</a></sup></p> <p>Something<sup id="fnref:1016"><a class="footnote-ref" href="#fn:1016" rel="footnote">1016</a></sup></p> <p>Something<sup id="fnref:1017"><a class="footnote-ref" href="#fn:1017" rel="footnote">1017</a></sup></p> <p>Something<sup id="fnref:1018"><a class="footnote-ref" href="#fn:1018" rel="footnote">1018</a></sup></p> <p>Something<sup id="fnref:1019"><a class="footnote-ref" href="#fn:1019" rel="footnote">1019</a></sup></p> <p>Something<sup id="fnref:1020"><a class="footnote-ref" href="#fn:1020" rel="footnote">1020</a></sup></p> <p>Something<sup id="fnref:1021"><a class="footnote-ref" href="#fn:1021" rel="footnote">1021</a></sup></p> <p>Something<sup id="fnref:1022"><a class="footnote-ref" href="#fn:1022" rel="footnote">1022</a></sup></p> <p>Something<sup id="fnref:1023"><a class="footnote-ref" href="#fn:1023" rel="footnote">1023</a></sup></p> <p>Something<sup id="fnref:1024"><a class="footnote-ref" href="#fn:1024" rel="footnote">1024</a></sup></p> <p>Something<sup id="fnref:1025"><a class="footnote-ref" href="#fn:1025" rel="footnote">1025</a></sup></p> <p>Something<sup id="fnref:1026"><a class="footnote-ref" href="#fn:1026" rel="footnote">1026</a></sup></p> <p>Something<sup id="fnref:1027"><a class="footnote-ref" href="#fn:1027" rel="footnote">1027</a></sup></p> <p>Something<sup id="fnref:1028"><a class="footnote-ref" href="#fn:1028" rel="footnote">1028</a></sup></p> <p>Something<sup id="fnref:1029"><a class="footnote-ref" href="#fn:1029" rel="footnote">1029</a></sup></p> <p>Something<sup id="fnref:1030"><a class="footnote-ref" href="#fn:1030" rel="footnote">1030</a></sup></p> <p>Something<sup id="fnref:1031"><a class="footnote-ref" href="#fn:1031" rel="footnote">1031</a></sup></p> <p>Something<sup id="fnref:1032"><a class="footnote-ref" href="#fn:1032" rel="footnote">1032</a></sup></p> <p>Something<sup id="fnref:1033"><a class="footnote-ref" href="#fn:1033" rel="footnote">1033</a></sup></p> <p>Something<sup id="fnref:1034"><a class="footnote-ref" href="#fn:1034" rel="footnote">1034</a></sup></p> <p>Something<sup id="fnref:1035"><a class="footnote-ref" href="#fn:1035" rel="footnote">1035</a></sup></p> <p>Something<sup id="fnref:1036"><a class="footnote-ref" href="#fn:1036" rel="footnote">1036</a></sup></p> <p>Something<sup id="fnref:1037"><a class="footnote-ref" href="#fn:1037" rel="footnote">1037</a></sup></p> <p>Something<sup id="fnref:1038"><a class="footnote-ref" href="#fn:1038" rel="footnote">1038</a></sup></p> <p>Something<sup id="fnref:1039"><a class="footnote-ref" href="#fn:1039" rel="footnote">1039</a></sup></p> <p>Something<sup id="fnref:1040"><a class="footnote-ref" href="#fn:1040" rel="footnote">1040</a></sup></p> <p>Something<sup id="fnref:1041"><a class="footnote-ref" href="#fn:1041" rel="footnote">1041</a></sup></p> <p>Something<sup id="fnref:1042"><a class="footnote-ref" href="#fn:1042" rel="footnote">1042</a></sup></p> <p>Something<sup id="fnref:1043"><a class="footnote-ref" href="#fn:1043" rel="footnote">1043</a></sup></p> <p>Something<sup id="fnref:1044"><a class="footnote-ref" href="#fn:1044" rel="footnote">1044</a></sup></p> <p>Something<sup id="fnref:1045"><a class="footnote-ref" href="#fn:1045" rel="footnote">1045</a></sup></p> <p>Something<sup id="fnref:1046"><a class="footnote-ref" href="#fn:1046" rel="footnote">1046</a></sup></p> <p>Something<sup id="fnref:1047"><a class="footnote-ref" href="#fn:1047" rel="footnote">1047</a></sup></p> <p>Something<sup id="fnref:1048"><a class="footnote-ref" href="#fn:1048" rel="footnote">1048</a></sup></p> <p>Something<sup id="fnref:1049"><a class="footnote-ref" href="#fn:1049" rel="footnote">1049</a></sup></p> <p>Something<sup id="fnref:1050"><a class="footnote-ref" href="#fn:1050" rel="footnote">1050</a></sup></p> <p>Something<sup id="fnref:1051"><a class="footnote-ref" href="#fn:1051" rel="footnote">1051</a></sup></p> <p>Something<sup id="fnref:1052"><a class="footnote-ref" href="#fn:1052" rel="footnote">1052</a></sup></p> <p>Something<sup id="fnref:1053"><a class="footnote-ref" href="#fn:1053" rel="footnote">1053</a></sup></p> <p>Something<sup id="fnref:1054"><a class="footnote-ref" href="#fn:1054" rel="footnote">1054</a></sup></p> <p>Something<sup id="fnref:1055"><a class="footnote-ref" href="#fn:1055" rel="footnote">1055</a></sup></p> <p>Something<sup id="fnref:1056"><a class="footnote-ref" href="#fn:1056" rel="footnote">1056</a></sup></p> <p>Something<sup id="fnref:1057"><a class="footnote-ref" href="#fn:1057" rel="footnote">1057</a></sup></p> <p>Something<sup id="fnref:1058"><a class="footnote-ref" href="#fn:1058" rel="footnote">1058</a></sup></p> <p>Something<sup id="fnref:1059"><a class="footnote-ref" href="#fn:1059" rel="footnote">1059</a></sup></p> <p>Something<sup id="fnref:1060"><a class="footnote-ref" href="#fn:1060" rel="footnote">1060</a></sup></p> <p>Something<sup id="fnref:1061"><a class="footnote-ref" href="#fn:1061" rel="footnote">1061</a></sup></p> <p>Something<sup id="fnref:1062"><a class="footnote-ref" href="#fn:1062" rel="footnote">1062</a></sup></p> <p>Something<sup id="fnref:1063"><a class="footnote-ref" href="#fn:1063" rel="footnote">1063</a></sup></p> <p>Something<sup id="fnref:1064"><a class="footnote-ref" href="#fn:1064" rel="footnote">1064</a></sup></p> <p>Something<sup id="fnref:1065"><a class="footnote-ref" href="#fn:1065" rel="footnote">1065</a></sup></p> <p>Something<sup id="fnref:1066"><a class="footnote-ref" href="#fn:1066" rel="footnote">1066</a></sup></p> <p>Something<sup id="fnref:1067"><a class="footnote-ref" href="#fn:1067" rel="footnote">1067</a></sup></p> <p>Something<sup id="fnref:1068"><a class="footnote-ref" href="#fn:1068" rel="footnote">1068</a></sup></p> <p>Something<sup id="fnref:1069"><a class="footnote-ref" href="#fn:1069" rel="footnote">1069</a></sup></p> <p>Something<sup id="fnref:1070"><a class="footnote-ref" href="#fn:1070" rel="footnote">1070</a></sup></p> <p>Something<sup id="fnref:1071"><a class="footnote-ref" href="#fn:1071" rel="footnote">1071</a></sup></p> <p>Something<sup id="fnref:1072"><a class="footnote-ref" href="#fn:1072" rel="footnote">1072</a></sup></p> <p>Something<sup id="fnref:1073"><a class="footnote-ref" href="#fn:1073" rel="footnote">1073</a></sup></p> <p>Something<sup id="fnref:1074"><a class="footnote-ref" href="#fn:1074" rel="footnote">1074</a></sup></p> <p>Something<sup id="fnref:1075"><a class="footnote-ref" href="#fn:1075" rel="footnote">1075</a></sup></p> <p>Something<sup id="fnref:1076"><a class="footnote-ref" href="#fn:1076" rel="footnote">1076</a></sup></p> <p>Something<sup id="fnref:1077"><a class="footnote-ref" href="#fn:1077" rel="footnote">1077</a></sup></p> <p>Something<sup id="fnref:1078"><a class="footnote-ref" href="#fn:1078" rel="footnote">1078</a></sup></p> <p>Something<sup id="fnref:1079"><a class="footnote-ref" href="#fn:1079" rel="footnote">1079</a></sup></p> <p>Something<sup id="fnref:1080"><a class="footnote-ref" href="#fn:1080" rel="footnote">1080</a></sup></p> <p>Something<sup id="fnref:1081"><a class="footnote-ref" href="#fn:1081" rel="footnote">1081</a></sup></p> <p>Something<sup id="fnref:1082"><a class="footnote-ref" href="#fn:1082" rel="footnote">1082</a></sup></p> <p>Something<sup id="fnref:1083"><a class="footnote-ref" href="#fn:1083" rel="footnote">1083</a></sup></p> <p>Something<sup id="fnref:1084"><a class="footnote-ref" href="#fn:1084" rel="footnote">1084</a></sup></p> <p>Something<sup id="fnref:1085"><a class="footnote-ref" href="#fn:1085" rel="footnote">1085</a></sup></p> <p>Something<sup id="fnref:1086"><a class="footnote-ref" href="#fn:1086" rel="footnote">1086</a></sup></p> <p>Something<sup id="fnref:1087"><a class="footnote-ref" href="#fn:1087" rel="footnote">1087</a></sup></p> <p>Something<sup id="fnref:1088"><a class="footnote-ref" href="#fn:1088" rel="footnote">1088</a></sup></p> <p>Something<sup id="fnref:1089"><a class="footnote-ref" href="#fn:1089" rel="footnote">1089</a></sup></p> <p>Something<sup id="fnref:1090"><a class="footnote-ref" href="#fn:1090" rel="footnote">1090</a></sup></p> <p>Something<sup id="fnref:1091"><a class="footnote-ref" href="#fn:1091" rel="footnote">1091</a></sup></p> <p>Something<sup id="fnref:1092"><a class="footnote-ref" href="#fn:1092" rel="footnote">1092</a></sup></p> <p>Something<sup id="fnref:1093"><a class="footnote-ref" href="#fn:1093" rel="footnote">1093</a></sup></p> <p>Something<sup id="fnref:1094"><a class="footnote-ref" href="#fn:1094" rel="footnote">1094</a></sup></p> <p>Something<sup id="fnref:1095"><a class="footnote-ref" href="#fn:1095" rel="footnote">1095</a></sup></p> <p>Something<sup id="fnref:1096"><a class="footnote-ref" href="#fn:1096" rel="footnote">1096</a></sup></p> <p>Something<sup id="fnref:1097"><a class="footnote-ref" href="#fn:1097" rel="footnote">1097</a></sup></p> <p>Something<sup id="fnref:1098"><a class="footnote-ref" href="#fn:1098" rel="footnote">1098</a></sup></p> <p>Something<sup id="fnref:1099"><a class="footnote-ref" href="#fn:1099" rel="footnote">1099</a></sup></p> <p>Something<sup id="fnref:1100"><a class="footnote-ref" href="#fn:1100" rel="footnote">1100</a></sup></p> <p>Something<sup id="fnref:1101"><a class="footnote-ref" href="#fn:1101" rel="footnote">1101</a></sup></p> <p>Something<sup id="fnref:1102"><a class="footnote-ref" href="#fn:1102" rel="footnote">1102</a></sup></p> <p>Something<sup id="fnref:1103"><a class="footnote-ref" href="#fn:1103" rel="footnote">1103</a></sup></p> <p>Something<sup id="fnref:1104"><a class="footnote-ref" href="#fn:1104" rel="footnote">1104</a></sup></p> <p>Something<sup id="fnref:1105"><a class="footnote-ref" href="#fn:1105" rel="footnote">1105</a></sup></p> <p>Something<sup id="fnref:1106"><a class="footnote-ref" href="#fn:1106" rel="footnote">1106</a></sup></p> <p>Something<sup id="fnref:1107"><a class="footnote-ref" href="#fn:1107" rel="footnote">1107</a></sup></p> <p>Something<sup id="fnref:1108"><a class="footnote-ref" href="#fn:1108" rel="footnote">1108</a></sup></p> <p>Something<sup id="fnref:1109"><a class="footnote-ref" href="#fn:1109" rel="footnote">1109</a></sup></p> <p>Something<sup id="fnref:1110"><a class="footnote-ref" href="#fn:1110" rel="footnote">1110</a></sup></p> <p>Something<sup id="fnref:1111"><a class="footnote-ref" href="#fn:1111" rel="footnote">1111</a></sup></p> <p>Something<sup id="fnref:1112"><a class="footnote-ref" href="#fn:1112" rel="footnote">1112</a></sup></p> <p>Something<sup id="fnref:1113"><a class="footnote-ref" href="#fn:1113" rel="footnote">1113</a></sup></p> <p>Something<sup id="fnref:1114"><a class="footnote-ref" href="#fn:1114" rel="footnote">1114</a></sup></p> <p>Something<sup id="fnref:1115"><a class="footnote-ref" href="#fn:1115" rel="footnote">1115</a></sup></p> <p>Something<sup id="fnref:1116"><a class="footnote-ref" href="#fn:1116" rel="footnote">1116</a></sup></p> <p>Something<sup id="fnref:1117"><a class="footnote-ref" href="#fn:1117" rel="footnote">1117</a></sup></p> <p>Something<sup id="fnref:1118"><a class="footnote-ref" href="#fn:1118" rel="footnote">1118</a></sup></p> <p>Something<sup id="fnref:1119"><a class="footnote-ref" href="#fn:1119" rel="footnote">1119</a></sup></p> <p>Something<sup id="fnref:1120"><a class="footnote-ref" href="#fn:1120" rel="footnote">1120</a></sup></p> <p>Something<sup id="fnref:1121"><a class="footnote-ref" href="#fn:1121" rel="footnote">1121</a></sup></p> <p>Something<sup id="fnref:1122"><a class="footnote-ref" href="#fn:1122" rel="footnote">1122</a></sup></p> <p>Something<sup id="fnref:1123"><a class="footnote-ref" href="#fn:1123" rel="footnote">1123</a></sup></p> <p>Something<sup id="fnref:1124"><a class="footnote-ref" href="#fn:1124" rel="footnote">1124</a></sup></p> <p>Something<sup id="fnref:1125"><a class="footnote-ref" href="#fn:1125" rel="footnote">1125</a></sup></p> <p>Something<sup id="fnref:1126"><a class="footnote-ref" href="#fn:1126" rel="footnote">1126</a></sup></p> <p>Something<sup id="fnref:1127"><a class="footnote-ref" href="#fn:1127" rel="footnote">1127</a></sup></p> <p>Something<sup id="fnref:1128"><a class="footnote-ref" href="#fn:1128" rel="footnote">1128</a></sup></p> <p>Something<sup id="fnref:1129"><a class="footnote-ref" href="#fn:1129" rel="footnote">1129</a></sup></p> <p>Something<sup id="fnref:1130"><a class="footnote-ref" href="#fn:1130" rel="footnote">1130</a></sup></p> <p>Something<sup id="fnref:1131"><a class="footnote-ref" href="#fn:1131" rel="footnote">1131</a></sup></p> <p>Something<sup id="fnref:1132"><a class="footnote-ref" href="#fn:1132" rel="footnote">1132</a></sup></p> <p>Something<sup id="fnref:1133"><a class="footnote-ref" href="#fn:1133" rel="footnote">1133</a></sup></p> <p>Something<sup id="fnref:1134"><a class="footnote-ref" href="#fn:1134" rel="footnote">1134</a></sup></p> <p>Something<sup id="fnref:1135"><a class="footnote-ref" href="#fn:1135" rel="footnote">1135</a></sup></p> <p>Something<sup id="fnref:1136"><a class="footnote-ref" href="#fn:1136" rel="footnote">1136</a></sup></p> <p>Something<sup id="fnref:1137"><a class="footnote-ref" href="#fn:1137" rel="footnote">1137</a></sup></p> <p>Something<sup id="fnref:1138"><a class="footnote-ref" href="#fn:1138" rel="footnote">1138</a></sup></p> <p>Something<sup id="fnref:1139"><a class="footnote-ref" href="#fn:1139" rel="footnote">1139</a></sup></p> <p>Something<sup id="fnref:1140"><a class="footnote-ref" href="#fn:1140" rel="footnote">1140</a></sup></p> <p>Something<sup id="fnref:1141"><a class="footnote-ref" href="#fn:1141" rel="footnote">1141</a></sup></p> <p>Something<sup id="fnref:1142"><a class="footnote-ref" href="#fn:1142" rel="footnote">1142</a></sup></p> <p>Something<sup id="fnref:1143"><a class="footnote-ref" href="#fn:1143" rel="footnote">1143</a></sup></p> <p>Something<sup id="fnref:1144"><a class="footnote-ref" href="#fn:1144" rel="footnote">1144</a></sup></p> <p>Something<sup id="fnref:1145"><a class="footnote-ref" href="#fn:1145" rel="footnote">1145</a></sup></p> <p>Something<sup id="fnref:1146"><a class="footnote-ref" href="#fn:1146" rel="footnote">1146</a></sup></p> <p>Something<sup id="fnref:1147"><a class="footnote-ref" href="#fn:1147" rel="footnote">1147</a></sup></p> <p>Something<sup id="fnref:1148"><a class="footnote-ref" href="#fn:1148" rel="footnote">1148</a></sup></p> <p>Something<sup id="fnref:1149"><a class="footnote-ref" href="#fn:1149" rel="footnote">1149</a></sup></p> <p>Something<sup id="fnref:1150"><a class="footnote-ref" href="#fn:1150" rel="footnote">1150</a></sup></p> <p>Something<sup id="fnref:1151"><a class="footnote-ref" href="#fn:1151" rel="footnote">1151</a></sup></p> <p>Something<sup id="fnref:1152"><a class="footnote-ref" href="#fn:1152" rel="footnote">1152</a></sup></p> <p>Something<sup id="fnref:1153"><a class="footnote-ref" href="#fn:1153" rel="footnote">1153</a></sup></p> <p>Something<sup id="fnref:1154"><a class="footnote-ref" href="#fn:1154" rel="footnote">1154</a></sup></p> <p>Something<sup id="fnref:1155"><a class="footnote-ref" href="#fn:1155" rel="footnote">1155</a></sup></p> <p>Something<sup id="fnref:1156"><a class="footnote-ref" href="#fn:1156" rel="footnote">1156</a></sup></p> <p>Something<sup id="fnref:1157"><a class="footnote-ref" href="#fn:1157" rel="footnote">1157</a></sup></p> <p>Something<sup id="fnref:1158"><a class="footnote-ref" href="#fn:1158" rel="footnote">1158</a></sup></p> <p>Something<sup id="fnref:1159"><a class="footnote-ref" href="#fn:1159" rel="footnote">1159</a></sup></p> <p>Something<sup id="fnref:1160"><a class="footnote-ref" href="#fn:1160" rel="footnote">1160</a></sup></p> <p>Something<sup id="fnref:1161"><a class="footnote-ref" href="#fn:1161" rel="footnote">1161</a></sup></p> <p>Something<sup id="fnref:1162"><a class="footnote-ref" href="#fn:1162" rel="footnote">1162</a></sup></p> <p>Something<sup id="fnref:1163"><a class="footnote-ref" href="#fn:1163" rel="footnote">1163</a></sup></p> <p>Something<sup id="fnref:1164"><a class="footnote-ref" href="#fn:1164" rel="footnote">1164</a></sup></p> <p>Something<sup id="fnref:1165"><a class="footnote-ref" href="#fn:1165" rel="footnote">1165</a></sup></p> <p>Something<sup id="fnref:1166"><a class="footnote-ref" href="#fn:1166" rel="footnote">1166</a></sup></p> <p>Something<sup id="fnref:1167"><a class="footnote-ref" href="#fn:1167" rel="footnote">1167</a></sup></p> <p>Something<sup id="fnref:1168"><a class="footnote-ref" href="#fn:1168" rel="footnote">1168</a></sup></p> <p>Something<sup id="fnref:1169"><a class="footnote-ref" href="#fn:1169" rel="footnote">1169</a></sup></p> <p>Something<sup id="fnref:1170"><a class="footnote-ref" href="#fn:1170" rel="footnote">1170</a></sup></p> <p>Something<sup id="fnref:1171"><a class="footnote-ref" href="#fn:1171" rel="footnote">1171</a></sup></p> <p>Something<sup id="fnref:1172"><a class="footnote-ref" href="#fn:1172" rel="footnote">1172</a></sup></p> <p>Something<sup id="fnref:1173"><a class="footnote-ref" href="#fn:1173" rel="footnote">1173</a></sup></p> <p>Something<sup id="fnref:1174"><a class="footnote-ref" href="#fn:1174" rel="footnote">1174</a></sup></p> <p>Something<sup id="fnref:1175"><a class="footnote-ref" href="#fn:1175" rel="footnote">1175</a></sup></p> <p>Something<sup id="fnref:1176"><a class="footnote-ref" href="#fn:1176" rel="footnote">1176</a></sup></p> <p>Something<sup id="fnref:1177"><a class="footnote-ref" href="#fn:1177" rel="footnote">1177</a></sup></p> <p>Something<sup id="fnref:1178"><a class="footnote-ref" href="#fn:1178" rel="footnote">1178</a></sup></p> <p>Something<sup id="fnref:1179"><a class="footnote-ref" href="#fn:1179" rel="footnote">1179</a></sup></p> <p>Something<sup id="fnref:1180"><a class="footnote-ref" href="#fn:1180" rel="footnote">1180</a></sup></p> <p>Something<sup id="fnref:1181"><a class="footnote-ref" href="#fn:1181" rel="footnote">1181</a></sup></p> <p>Something<sup id="fnref:1182"><a class="footnote-ref" href="#fn:1182" rel="footnote">1182</a></sup></p> <p>Something<sup id="fnref:1183"><a class="footnote-ref" href="#fn:1183" rel="footnote">1183</a></sup></p> <p>Something<sup id="fnref:1184"><a class="footnote-ref" href="#fn:1184" rel="footnote">1184</a></sup></p> <p>Something<sup id="fnref:1185"><a class="footnote-ref" href="#fn:1185" rel="footnote">1185</a></sup></p> <p>Something<sup id="fnref:1186"><a class="footnote-ref" href="#fn:1186" rel="footnote">1186</a></sup></p> <p>Something<sup id="fnref:1187"><a class="footnote-ref" href="#fn:1187" rel="footnote">1187</a></sup></p> <p>Something<sup id="fnref:1188"><a class="footnote-ref" href="#fn:1188" rel="footnote">1188</a></sup></p> <p>Something<sup id="fnref:1189"><a class="footnote-ref" href="#fn:1189" rel="footnote">1189</a></sup></p> <p>Something<sup id="fnref:1190"><a class="footnote-ref" href="#fn:1190" rel="footnote">1190</a></sup></p> <p>Something<sup id="fnref:1191"><a class="footnote-ref" href="#fn:1191" rel="footnote">1191</a></sup></p> <p>Something<sup id="fnref:1192"><a class="footnote-ref" href="#fn:1192" rel="footnote">1192</a></sup></p> <p>Something<sup id="fnref:1193"><a class="footnote-ref" href="#fn:1193" rel="footnote">1193</a></sup></p> <p>Something<sup id="fnref:1194"><a class="footnote-ref" href="#fn:1194" rel="footnote">1194</a></sup></p> <p>Something<sup id="fnref:1195"><a class="footnote-ref" href="#fn:1195" rel="footnote">1195</a></sup></p> <p>Something<sup id="fnref:1196"><a class="footnote-ref" href="#fn:1196" rel="footnote">1196</a></sup></p> <p>Something<sup id="fnref:1197"><a class="footnote-ref" href="#fn:1197" rel="footnote">1197</a></sup></p> <p>Something<sup id="fnref:1198"><a class="footnote-ref" href="#fn:1198" rel="footnote">1198</a></sup></p> <p>Something<sup id="fnref:1199"><a class="footnote-ref" href="#fn:1199" rel="footnote">1199</a></sup></p> <div class="footnote"> <hr /> <ol> <li id="fn:1"> <p>Another thing <a class="footnote-backref" href="#fnref:1" rev="footnote" title="Jump back to footnote 1 in the text">↩</a></p> </li> <li id="fn:2"> <p>Another thing <a class="footnote-backref" href="#fnref:2" rev="footnote" title="Jump back to footnote 2 in the text">↩</a></p> </li> <li id="fn:3"> <p>Another thing <a class="footnote-backref" href="#fnref:3" rev="footnote" title="Jump back to footnote 3 in the text">↩</a></p> </li> <li id="fn:4"> <p>Another thing <a class="footnote-backref" href="#fnref:4" rev="footnote" title="Jump back to footnote 4 in the text">↩</a></p> </li> <li id="fn:5"> <p>Another thing <a class="footnote-backref" href="#fnref:5" rev="footnote" title="Jump back to footnote 5 in the text">↩</a></p> </li> <li id="fn:6"> <p>Another thing <a class="footnote-backref" href="#fnref:6" rev="footnote" title="Jump back to footnote 6 in the text">↩</a></p> </li> <li id="fn:7"> <p>Another thing <a class="footnote-backref" href="#fnref:7" rev="footnote" title="Jump back to footnote 7 in the text">↩</a></p> </li> <li id="fn:8"> <p>Another thing <a class="footnote-backref" href="#fnref:8" rev="footnote" title="Jump back to footnote 8 in the text">↩</a></p> </li> <li id="fn:9"> <p>Another thing <a class="footnote-backref" href="#fnref:9" rev="footnote" title="Jump back to footnote 9 in the text">↩</a></p> </li> <li id="fn:10"> <p>Another thing <a class="footnote-backref" href="#fnref:10" rev="footnote" title="Jump back to footnote 10 in the text">↩</a></p> </li> <li id="fn:11"> <p>Another thing <a class="footnote-backref" href="#fnref:11" rev="footnote" title="Jump back to footnote 11 in the text">↩</a></p> </li> <li id="fn:12"> <p>Another thing <a class="footnote-backref" href="#fnref:12" rev="footnote" title="Jump back to footnote 12 in the text">↩</a></p> </li> <li id="fn:13"> <p>Another thing <a class="footnote-backref" href="#fnref:13" rev="footnote" title="Jump back to footnote 13 in the text">↩</a></p> </li> <li id="fn:14"> <p>Another thing <a class="footnote-backref" href="#fnref:14" rev="footnote" title="Jump back to footnote 14 in the text">↩</a></p> </li> <li id="fn:15"> <p>Another thing <a class="footnote-backref" href="#fnref:15" rev="footnote" title="Jump back to footnote 15 in the text">↩</a></p> </li> <li id="fn:16"> <p>Another thing <a class="footnote-backref" href="#fnref:16" rev="footnote" title="Jump back to footnote 16 in the text">↩</a></p> </li> <li id="fn:17"> <p>Another thing <a class="footnote-backref" href="#fnref:17" rev="footnote" title="Jump back to footnote 17 in the text">↩</a></p> </li> <li id="fn:18"> <p>Another thing <a class="footnote-backref" href="#fnref:18" rev="footnote" title="Jump back to footnote 18 in the text">↩</a></p> </li> <li id="fn:19"> <p>Another thing <a class="footnote-backref" href="#fnref:19" rev="footnote" title="Jump back to footnote 19 in the text">↩</a></p> </li> <li id="fn:20"> <p>Another thing <a class="footnote-backref" href="#fnref:20" rev="footnote" title="Jump back to footnote 20 in the text">↩</a></p> </li> <li id="fn:21"> <p>Another thing <a class="footnote-backref" href="#fnref:21" rev="footnote" title="Jump back to footnote 21 in the text">↩</a></p> </li> <li id="fn:22"> <p>Another thing <a class="footnote-backref" href="#fnref:22" rev="footnote" title="Jump back to footnote 22 in the text">↩</a></p> </li> <li id="fn:23"> <p>Another thing <a class="footnote-backref" href="#fnref:23" rev="footnote" title="Jump back to footnote 23 in the text">↩</a></p> </li> <li id="fn:24"> <p>Another thing <a class="footnote-backref" href="#fnref:24" rev="footnote" title="Jump back to footnote 24 in the text">↩</a></p> </li> <li id="fn:25"> <p>Another thing <a class="footnote-backref" href="#fnref:25" rev="footnote" title="Jump back to footnote 25 in the text">↩</a></p> </li> <li id="fn:26"> <p>Another thing <a class="footnote-backref" href="#fnref:26" rev="footnote" title="Jump back to footnote 26 in the text">↩</a></p> </li> <li id="fn:27"> <p>Another thing <a class="footnote-backref" href="#fnref:27" rev="footnote" title="Jump back to footnote 27 in the text">↩</a></p> </li> <li id="fn:28"> <p>Another thing <a class="footnote-backref" href="#fnref:28" rev="footnote" title="Jump back to footnote 28 in the text">↩</a></p> </li> <li id="fn:29"> <p>Another thing <a class="footnote-backref" href="#fnref:29" rev="footnote" title="Jump back to footnote 29 in the text">↩</a></p> </li> <li id="fn:30"> <p>Another thing <a class="footnote-backref" href="#fnref:30" rev="footnote" title="Jump back to footnote 30 in the text">↩</a></p> </li> <li id="fn:31"> <p>Another thing <a class="footnote-backref" href="#fnref:31" rev="footnote" title="Jump back to footnote 31 in the text">↩</a></p> </li> <li id="fn:32"> <p>Another thing <a class="footnote-backref" href="#fnref:32" rev="footnote" title="Jump back to footnote 32 in the text">↩</a></p> </li> <li id="fn:33"> <p>Another thing <a class="footnote-backref" href="#fnref:33" rev="footnote" title="Jump back to footnote 33 in the text">↩</a></p> </li> <li id="fn:34"> <p>Another thing <a class="footnote-backref" href="#fnref:34" rev="footnote" title="Jump back to footnote 34 in the text">↩</a></p> </li> <li id="fn:35"> <p>Another thing <a class="footnote-backref" href="#fnref:35" rev="footnote" title="Jump back to footnote 35 in the text">↩</a></p> </li> <li id="fn:36"> <p>Another thing <a class="footnote-backref" href="#fnref:36" rev="footnote" title="Jump back to footnote 36 in the text">↩</a></p> </li> <li id="fn:37"> <p>Another thing <a class="footnote-backref" href="#fnref:37" rev="footnote" title="Jump back to footnote 37 in the text">↩</a></p> </li> <li id="fn:38"> <p>Another thing <a class="footnote-backref" href="#fnref:38" rev="footnote" title="Jump back to footnote 38 in the text">↩</a></p> </li> <li id="fn:39"> <p>Another thing <a class="footnote-backref" href="#fnref:39" rev="footnote" title="Jump back to footnote 39 in the text">↩</a></p> </li> <li id="fn:40"> <p>Another thing <a class="footnote-backref" href="#fnref:40" rev="footnote" title="Jump back to footnote 40 in the text">↩</a></p> </li> <li id="fn:41"> <p>Another thing <a class="footnote-backref" href="#fnref:41" rev="footnote" title="Jump back to footnote 41 in the text">↩</a></p> </li> <li id="fn:42"> <p>Another thing <a class="footnote-backref" href="#fnref:42" rev="footnote" title="Jump back to footnote 42 in the text">↩</a></p> </li> <li id="fn:43"> <p>Another thing <a class="footnote-backref" href="#fnref:43" rev="footnote" title="Jump back to footnote 43 in the text">↩</a></p> </li> <li id="fn:44"> <p>Another thing <a class="footnote-backref" href="#fnref:44" rev="footnote" title="Jump back to footnote 44 in the text">↩</a></p> </li> <li id="fn:45"> <p>Another thing <a class="footnote-backref" href="#fnref:45" rev="footnote" title="Jump back to footnote 45 in the text">↩</a></p> </li> <li id="fn:46"> <p>Another thing <a class="footnote-backref" href="#fnref:46" rev="footnote" title="Jump back to footnote 46 in the text">↩</a></p> </li> <li id="fn:47"> <p>Another thing <a class="footnote-backref" href="#fnref:47" rev="footnote" title="Jump back to footnote 47 in the text">↩</a></p> </li> <li id="fn:48"> <p>Another thing <a class="footnote-backref" href="#fnref:48" rev="footnote" title="Jump back to footnote 48 in the text">↩</a></p> </li> <li id="fn:49"> <p>Another thing <a class="footnote-backref" href="#fnref:49" rev="footnote" title="Jump back to footnote 49 in the text">↩</a></p> </li> <li id="fn:50"> <p>Another thing <a class="footnote-backref" href="#fnref:50" rev="footnote" title="Jump back to footnote 50 in the text">↩</a></p> </li> <li id="fn:51"> <p>Another thing <a class="footnote-backref" href="#fnref:51" rev="footnote" title="Jump back to footnote 51 in the text">↩</a></p> </li> <li id="fn:52"> <p>Another thing <a class="footnote-backref" href="#fnref:52" rev="footnote" title="Jump back to footnote 52 in the text">↩</a></p> </li> <li id="fn:53"> <p>Another thing <a class="footnote-backref" href="#fnref:53" rev="footnote" title="Jump back to footnote 53 in the text">↩</a></p> </li> <li id="fn:54"> <p>Another thing <a class="footnote-backref" href="#fnref:54" rev="footnote" title="Jump back to footnote 54 in the text">↩</a></p> </li> <li id="fn:55"> <p>Another thing <a class="footnote-backref" href="#fnref:55" rev="footnote" title="Jump back to footnote 55 in the text">↩</a></p> </li> <li id="fn:56"> <p>Another thing <a class="footnote-backref" href="#fnref:56" rev="footnote" title="Jump back to footnote 56 in the text">↩</a></p> </li> <li id="fn:57"> <p>Another thing <a class="footnote-backref" href="#fnref:57" rev="footnote" title="Jump back to footnote 57 in the text">↩</a></p> </li> <li id="fn:58"> <p>Another thing <a class="footnote-backref" href="#fnref:58" rev="footnote" title="Jump back to footnote 58 in the text">↩</a></p> </li> <li id="fn:59"> <p>Another thing <a class="footnote-backref" href="#fnref:59" rev="footnote" title="Jump back to footnote 59 in the text">↩</a></p> </li> <li id="fn:60"> <p>Another thing <a class="footnote-backref" href="#fnref:60" rev="footnote" title="Jump back to footnote 60 in the text">↩</a></p> </li> <li id="fn:61"> <p>Another thing <a class="footnote-backref" href="#fnref:61" rev="footnote" title="Jump back to footnote 61 in the text">↩</a></p> </li> <li id="fn:62"> <p>Another thing <a class="footnote-backref" href="#fnref:62" rev="footnote" title="Jump back to footnote 62 in the text">↩</a></p> </li> <li id="fn:63"> <p>Another thing <a class="footnote-backref" href="#fnref:63" rev="footnote" title="Jump back to footnote 63 in the text">↩</a></p> </li> <li id="fn:64"> <p>Another thing <a class="footnote-backref" href="#fnref:64" rev="footnote" title="Jump back to footnote 64 in the text">↩</a></p> </li> <li id="fn:65"> <p>Another thing <a class="footnote-backref" href="#fnref:65" rev="footnote" title="Jump back to footnote 65 in the text">↩</a></p> </li> <li id="fn:66"> <p>Another thing <a class="footnote-backref" href="#fnref:66" rev="footnote" title="Jump back to footnote 66 in the text">↩</a></p> </li> <li id="fn:67"> <p>Another thing <a class="footnote-backref" href="#fnref:67" rev="footnote" title="Jump back to footnote 67 in the text">↩</a></p> </li> <li id="fn:68"> <p>Another thing <a class="footnote-backref" href="#fnref:68" rev="footnote" title="Jump back to footnote 68 in the text">↩</a></p> </li> <li id="fn:69"> <p>Another thing <a class="footnote-backref" href="#fnref:69" rev="footnote" title="Jump back to footnote 69 in the text">↩</a></p> </li> <li id="fn:70"> <p>Another thing <a class="footnote-backref" href="#fnref:70" rev="footnote" title="Jump back to footnote 70 in the text">↩</a></p> </li> <li id="fn:71"> <p>Another thing <a class="footnote-backref" href="#fnref:71" rev="footnote" title="Jump back to footnote 71 in the text">↩</a></p> </li> <li id="fn:72"> <p>Another thing <a class="footnote-backref" href="#fnref:72" rev="footnote" title="Jump back to footnote 72 in the text">↩</a></p> </li> <li id="fn:73"> <p>Another thing <a class="footnote-backref" href="#fnref:73" rev="footnote" title="Jump back to footnote 73 in the text">↩</a></p> </li> <li id="fn:74"> <p>Another thing <a class="footnote-backref" href="#fnref:74" rev="footnote" title="Jump back to footnote 74 in the text">↩</a></p> </li> <li id="fn:75"> <p>Another thing <a class="footnote-backref" href="#fnref:75" rev="footnote" title="Jump back to footnote 75 in the text">↩</a></p> </li> <li id="fn:76"> <p>Another thing <a class="footnote-backref" href="#fnref:76" rev="footnote" title="Jump back to footnote 76 in the text">↩</a></p> </li> <li id="fn:77"> <p>Another thing <a class="footnote-backref" href="#fnref:77" rev="footnote" title="Jump back to footnote 77 in the text">↩</a></p> </li> <li id="fn:78"> <p>Another thing <a class="footnote-backref" href="#fnref:78" rev="footnote" title="Jump back to footnote 78 in the text">↩</a></p> </li> <li id="fn:79"> <p>Another thing <a class="footnote-backref" href="#fnref:79" rev="footnote" title="Jump back to footnote 79 in the text">↩</a></p> </li> <li id="fn:80"> <p>Another thing <a class="footnote-backref" href="#fnref:80" rev="footnote" title="Jump back to footnote 80 in the text">↩</a></p> </li> <li id="fn:81"> <p>Another thing <a class="footnote-backref" href="#fnref:81" rev="footnote" title="Jump back to footnote 81 in the text">↩</a></p> </li> <li id="fn:82"> <p>Another thing <a class="footnote-backref" href="#fnref:82" rev="footnote" title="Jump back to footnote 82 in the text">↩</a></p> </li> <li id="fn:83"> <p>Another thing <a class="footnote-backref" href="#fnref:83" rev="footnote" title="Jump back to footnote 83 in the text">↩</a></p> </li> <li id="fn:84"> <p>Another thing <a class="footnote-backref" href="#fnref:84" rev="footnote" title="Jump back to footnote 84 in the text">↩</a></p> </li> <li id="fn:85"> <p>Another thing <a class="footnote-backref" href="#fnref:85" rev="footnote" title="Jump back to footnote 85 in the text">↩</a></p> </li> <li id="fn:86"> <p>Another thing <a class="footnote-backref" href="#fnref:86" rev="footnote" title="Jump back to footnote 86 in the text">↩</a></p> </li> <li id="fn:87"> <p>Another thing <a class="footnote-backref" href="#fnref:87" rev="footnote" title="Jump back to footnote 87 in the text">↩</a></p> </li> <li id="fn:88"> <p>Another thing <a class="footnote-backref" href="#fnref:88" rev="footnote" title="Jump back to footnote 88 in the text">↩</a></p> </li> <li id="fn:89"> <p>Another thing <a class="footnote-backref" href="#fnref:89" rev="footnote" title="Jump back to footnote 89 in the text">↩</a></p> </li> <li id="fn:90"> <p>Another thing <a class="footnote-backref" href="#fnref:90" rev="footnote" title="Jump back to footnote 90 in the text">↩</a></p> </li> <li id="fn:91"> <p>Another thing <a class="footnote-backref" href="#fnref:91" rev="footnote" title="Jump back to footnote 91 in the text">↩</a></p> </li> <li id="fn:92"> <p>Another thing <a class="footnote-backref" href="#fnref:92" rev="footnote" title="Jump back to footnote 92 in the text">↩</a></p> </li> <li id="fn:93"> <p>Another thing <a class="footnote-backref" href="#fnref:93" rev="footnote" title="Jump back to footnote 93 in the text">↩</a></p> </li> <li id="fn:94"> <p>Another thing <a class="footnote-backref" href="#fnref:94" rev="footnote" title="Jump back to footnote 94 in the text">↩</a></p> </li> <li id="fn:95"> <p>Another thing <a class="footnote-backref" href="#fnref:95" rev="footnote" title="Jump back to footnote 95 in the text">↩</a></p> </li> <li id="fn:96"> <p>Another thing <a class="footnote-backref" href="#fnref:96" rev="footnote" title="Jump back to footnote 96 in the text">↩</a></p> </li> <li id="fn:97"> <p>Another thing <a class="footnote-backref" href="#fnref:97" rev="footnote" title="Jump back to footnote 97 in the text">↩</a></p> </li> <li id="fn:98"> <p>Another thing <a class="footnote-backref" href="#fnref:98" rev="footnote" title="Jump back to footnote 98 in the text">↩</a></p> </li> <li id="fn:99"> <p>Another thing <a class="footnote-backref" href="#fnref:99" rev="footnote" title="Jump back to footnote 99 in the text">↩</a></p> </li> <li id="fn:100"> <p>Another thing <a class="footnote-backref" href="#fnref:100" rev="footnote" title="Jump back to footnote 100 in the text">↩</a></p> </li> <li id="fn:101"> <p>Another thing <a class="footnote-backref" href="#fnref:101" rev="footnote" title="Jump back to footnote 101 in the text">↩</a></p> </li> <li id="fn:102"> <p>Another thing <a class="footnote-backref" href="#fnref:102" rev="footnote" title="Jump back to footnote 102 in the text">↩</a></p> </li> <li id="fn:103"> <p>Another thing <a class="footnote-backref" href="#fnref:103" rev="footnote" title="Jump back to footnote 103 in the text">↩</a></p> </li> <li id="fn:104"> <p>Another thing <a class="footnote-backref" href="#fnref:104" rev="footnote" title="Jump back to footnote 104 in the text">↩</a></p> </li> <li id="fn:105"> <p>Another thing <a class="footnote-backref" href="#fnref:105" rev="footnote" title="Jump back to footnote 105 in the text">↩</a></p> </li> <li id="fn:106"> <p>Another thing <a class="footnote-backref" href="#fnref:106" rev="footnote" title="Jump back to footnote 106 in the text">↩</a></p> </li> <li id="fn:107"> <p>Another thing <a class="footnote-backref" href="#fnref:107" rev="footnote" title="Jump back to footnote 107 in the text">↩</a></p> </li> <li id="fn:108"> <p>Another thing <a class="footnote-backref" href="#fnref:108" rev="footnote" title="Jump back to footnote 108 in the text">↩</a></p> </li> <li id="fn:109"> <p>Another thing <a class="footnote-backref" href="#fnref:109" rev="footnote" title="Jump back to footnote 109 in the text">↩</a></p> </li> <li id="fn:110"> <p>Another thing <a class="footnote-backref" href="#fnref:110" rev="footnote" title="Jump back to footnote 110 in the text">↩</a></p> </li> <li id="fn:111"> <p>Another thing <a class="footnote-backref" href="#fnref:111" rev="footnote" title="Jump back to footnote 111 in the text">↩</a></p> </li> <li id="fn:112"> <p>Another thing <a class="footnote-backref" href="#fnref:112" rev="footnote" title="Jump back to footnote 112 in the text">↩</a></p> </li> <li id="fn:113"> <p>Another thing <a class="footnote-backref" href="#fnref:113" rev="footnote" title="Jump back to footnote 113 in the text">↩</a></p> </li> <li id="fn:114"> <p>Another thing <a class="footnote-backref" href="#fnref:114" rev="footnote" title="Jump back to footnote 114 in the text">↩</a></p> </li> <li id="fn:115"> <p>Another thing <a class="footnote-backref" href="#fnref:115" rev="footnote" title="Jump back to footnote 115 in the text">↩</a></p> </li> <li id="fn:116"> <p>Another thing <a class="footnote-backref" href="#fnref:116" rev="footnote" title="Jump back to footnote 116 in the text">↩</a></p> </li> <li id="fn:117"> <p>Another thing <a class="footnote-backref" href="#fnref:117" rev="footnote" title="Jump back to footnote 117 in the text">↩</a></p> </li> <li id="fn:118"> <p>Another thing <a class="footnote-backref" href="#fnref:118" rev="footnote" title="Jump back to footnote 118 in the text">↩</a></p> </li> <li id="fn:119"> <p>Another thing <a class="footnote-backref" href="#fnref:119" rev="footnote" title="Jump back to footnote 119 in the text">↩</a></p> </li> <li id="fn:120"> <p>Another thing <a class="footnote-backref" href="#fnref:120" rev="footnote" title="Jump back to footnote 120 in the text">↩</a></p> </li> <li id="fn:121"> <p>Another thing <a class="footnote-backref" href="#fnref:121" rev="footnote" title="Jump back to footnote 121 in the text">↩</a></p> </li> <li id="fn:122"> <p>Another thing <a class="footnote-backref" href="#fnref:122" rev="footnote" title="Jump back to footnote 122 in the text">↩</a></p> </li> <li id="fn:123"> <p>Another thing <a class="footnote-backref" href="#fnref:123" rev="footnote" title="Jump back to footnote 123 in the text">↩</a></p> </li> <li id="fn:124"> <p>Another thing <a class="footnote-backref" href="#fnref:124" rev="footnote" title="Jump back to footnote 124 in the text">↩</a></p> </li> <li id="fn:125"> <p>Another thing <a class="footnote-backref" href="#fnref:125" rev="footnote" title="Jump back to footnote 125 in the text">↩</a></p> </li> <li id="fn:126"> <p>Another thing <a class="footnote-backref" href="#fnref:126" rev="footnote" title="Jump back to footnote 126 in the text">↩</a></p> </li> <li id="fn:127"> <p>Another thing <a class="footnote-backref" href="#fnref:127" rev="footnote" title="Jump back to footnote 127 in the text">↩</a></p> </li> <li id="fn:128"> <p>Another thing <a class="footnote-backref" href="#fnref:128" rev="footnote" title="Jump back to footnote 128 in the text">↩</a></p> </li> <li id="fn:129"> <p>Another thing <a class="footnote-backref" href="#fnref:129" rev="footnote" title="Jump back to footnote 129 in the text">↩</a></p> </li> <li id="fn:130"> <p>Another thing <a class="footnote-backref" href="#fnref:130" rev="footnote" title="Jump back to footnote 130 in the text">↩</a></p> </li> <li id="fn:131"> <p>Another thing <a class="footnote-backref" href="#fnref:131" rev="footnote" title="Jump back to footnote 131 in the text">↩</a></p> </li> <li id="fn:132"> <p>Another thing <a class="footnote-backref" href="#fnref:132" rev="footnote" title="Jump back to footnote 132 in the text">↩</a></p> </li> <li id="fn:133"> <p>Another thing <a class="footnote-backref" href="#fnref:133" rev="footnote" title="Jump back to footnote 133 in the text">↩</a></p> </li> <li id="fn:134"> <p>Another thing <a class="footnote-backref" href="#fnref:134" rev="footnote" title="Jump back to footnote 134 in the text">↩</a></p> </li> <li id="fn:135"> <p>Another thing <a class="footnote-backref" href="#fnref:135" rev="footnote" title="Jump back to footnote 135 in the text">↩</a></p> </li> <li id="fn:136"> <p>Another thing <a class="footnote-backref" href="#fnref:136" rev="footnote" title="Jump back to footnote 136 in the text">↩</a></p> </li> <li id="fn:137"> <p>Another thing <a class="footnote-backref" href="#fnref:137" rev="footnote" title="Jump back to footnote 137 in the text">↩</a></p> </li> <li id="fn:138"> <p>Another thing <a class="footnote-backref" href="#fnref:138" rev="footnote" title="Jump back to footnote 138 in the text">↩</a></p> </li> <li id="fn:139"> <p>Another thing <a class="footnote-backref" href="#fnref:139" rev="footnote" title="Jump back to footnote 139 in the text">↩</a></p> </li> <li id="fn:140"> <p>Another thing <a class="footnote-backref" href="#fnref:140" rev="footnote" title="Jump back to footnote 140 in the text">↩</a></p> </li> <li id="fn:141"> <p>Another thing <a class="footnote-backref" href="#fnref:141" rev="footnote" title="Jump back to footnote 141 in the text">↩</a></p> </li> <li id="fn:142"> <p>Another thing <a class="footnote-backref" href="#fnref:142" rev="footnote" title="Jump back to footnote 142 in the text">↩</a></p> </li> <li id="fn:143"> <p>Another thing <a class="footnote-backref" href="#fnref:143" rev="footnote" title="Jump back to footnote 143 in the text">↩</a></p> </li> <li id="fn:144"> <p>Another thing <a class="footnote-backref" href="#fnref:144" rev="footnote" title="Jump back to footnote 144 in the text">↩</a></p> </li> <li id="fn:145"> <p>Another thing <a class="footnote-backref" href="#fnref:145" rev="footnote" title="Jump back to footnote 145 in the text">↩</a></p> </li> <li id="fn:146"> <p>Another thing <a class="footnote-backref" href="#fnref:146" rev="footnote" title="Jump back to footnote 146 in the text">↩</a></p> </li> <li id="fn:147"> <p>Another thing <a class="footnote-backref" href="#fnref:147" rev="footnote" title="Jump back to footnote 147 in the text">↩</a></p> </li> <li id="fn:148"> <p>Another thing <a class="footnote-backref" href="#fnref:148" rev="footnote" title="Jump back to footnote 148 in the text">↩</a></p> </li> <li id="fn:149"> <p>Another thing <a class="footnote-backref" href="#fnref:149" rev="footnote" title="Jump back to footnote 149 in the text">↩</a></p> </li> <li id="fn:150"> <p>Another thing <a class="footnote-backref" href="#fnref:150" rev="footnote" title="Jump back to footnote 150 in the text">↩</a></p> </li> <li id="fn:151"> <p>Another thing <a class="footnote-backref" href="#fnref:151" rev="footnote" title="Jump back to footnote 151 in the text">↩</a></p> </li> <li id="fn:152"> <p>Another thing <a class="footnote-backref" href="#fnref:152" rev="footnote" title="Jump back to footnote 152 in the text">↩</a></p> </li> <li id="fn:153"> <p>Another thing <a class="footnote-backref" href="#fnref:153" rev="footnote" title="Jump back to footnote 153 in the text">↩</a></p> </li> <li id="fn:154"> <p>Another thing <a class="footnote-backref" href="#fnref:154" rev="footnote" title="Jump back to footnote 154 in the text">↩</a></p> </li> <li id="fn:155"> <p>Another thing <a class="footnote-backref" href="#fnref:155" rev="footnote" title="Jump back to footnote 155 in the text">↩</a></p> </li> <li id="fn:156"> <p>Another thing <a class="footnote-backref" href="#fnref:156" rev="footnote" title="Jump back to footnote 156 in the text">↩</a></p> </li> <li id="fn:157"> <p>Another thing <a class="footnote-backref" href="#fnref:157" rev="footnote" title="Jump back to footnote 157 in the text">↩</a></p> </li> <li id="fn:158"> <p>Another thing <a class="footnote-backref" href="#fnref:158" rev="footnote" title="Jump back to footnote 158 in the text">↩</a></p> </li> <li id="fn:159"> <p>Another thing <a class="footnote-backref" href="#fnref:159" rev="footnote" title="Jump back to footnote 159 in the text">↩</a></p> </li> <li id="fn:160"> <p>Another thing <a class="footnote-backref" href="#fnref:160" rev="footnote" title="Jump back to footnote 160 in the text">↩</a></p> </li> <li id="fn:161"> <p>Another thing <a class="footnote-backref" href="#fnref:161" rev="footnote" title="Jump back to footnote 161 in the text">↩</a></p> </li> <li id="fn:162"> <p>Another thing <a class="footnote-backref" href="#fnref:162" rev="footnote" title="Jump back to footnote 162 in the text">↩</a></p> </li> <li id="fn:163"> <p>Another thing <a class="footnote-backref" href="#fnref:163" rev="footnote" title="Jump back to footnote 163 in the text">↩</a></p> </li> <li id="fn:164"> <p>Another thing <a class="footnote-backref" href="#fnref:164" rev="footnote" title="Jump back to footnote 164 in the text">↩</a></p> </li> <li id="fn:165"> <p>Another thing <a class="footnote-backref" href="#fnref:165" rev="footnote" title="Jump back to footnote 165 in the text">↩</a></p> </li> <li id="fn:166"> <p>Another thing <a class="footnote-backref" href="#fnref:166" rev="footnote" title="Jump back to footnote 166 in the text">↩</a></p> </li> <li id="fn:167"> <p>Another thing <a class="footnote-backref" href="#fnref:167" rev="footnote" title="Jump back to footnote 167 in the text">↩</a></p> </li> <li id="fn:168"> <p>Another thing <a class="footnote-backref" href="#fnref:168" rev="footnote" title="Jump back to footnote 168 in the text">↩</a></p> </li> <li id="fn:169"> <p>Another thing <a class="footnote-backref" href="#fnref:169" rev="footnote" title="Jump back to footnote 169 in the text">↩</a></p> </li> <li id="fn:170"> <p>Another thing <a class="footnote-backref" href="#fnref:170" rev="footnote" title="Jump back to footnote 170 in the text">↩</a></p> </li> <li id="fn:171"> <p>Another thing <a class="footnote-backref" href="#fnref:171" rev="footnote" title="Jump back to footnote 171 in the text">↩</a></p> </li> <li id="fn:172"> <p>Another thing <a class="footnote-backref" href="#fnref:172" rev="footnote" title="Jump back to footnote 172 in the text">↩</a></p> </li> <li id="fn:173"> <p>Another thing <a class="footnote-backref" href="#fnref:173" rev="footnote" title="Jump back to footnote 173 in the text">↩</a></p> </li> <li id="fn:174"> <p>Another thing <a class="footnote-backref" href="#fnref:174" rev="footnote" title="Jump back to footnote 174 in the text">↩</a></p> </li> <li id="fn:175"> <p>Another thing <a class="footnote-backref" href="#fnref:175" rev="footnote" title="Jump back to footnote 175 in the text">↩</a></p> </li> <li id="fn:176"> <p>Another thing <a class="footnote-backref" href="#fnref:176" rev="footnote" title="Jump back to footnote 176 in the text">↩</a></p> </li> <li id="fn:177"> <p>Another thing <a class="footnote-backref" href="#fnref:177" rev="footnote" title="Jump back to footnote 177 in the text">↩</a></p> </li> <li id="fn:178"> <p>Another thing <a class="footnote-backref" href="#fnref:178" rev="footnote" title="Jump back to footnote 178 in the text">↩</a></p> </li> <li id="fn:179"> <p>Another thing <a class="footnote-backref" href="#fnref:179" rev="footnote" title="Jump back to footnote 179 in the text">↩</a></p> </li> <li id="fn:180"> <p>Another thing <a class="footnote-backref" href="#fnref:180" rev="footnote" title="Jump back to footnote 180 in the text">↩</a></p> </li> <li id="fn:181"> <p>Another thing <a class="footnote-backref" href="#fnref:181" rev="footnote" title="Jump back to footnote 181 in the text">↩</a></p> </li> <li id="fn:182"> <p>Another thing <a class="footnote-backref" href="#fnref:182" rev="footnote" title="Jump back to footnote 182 in the text">↩</a></p> </li> <li id="fn:183"> <p>Another thing <a class="footnote-backref" href="#fnref:183" rev="footnote" title="Jump back to footnote 183 in the text">↩</a></p> </li> <li id="fn:184"> <p>Another thing <a class="footnote-backref" href="#fnref:184" rev="footnote" title="Jump back to footnote 184 in the text">↩</a></p> </li> <li id="fn:185"> <p>Another thing <a class="footnote-backref" href="#fnref:185" rev="footnote" title="Jump back to footnote 185 in the text">↩</a></p> </li> <li id="fn:186"> <p>Another thing <a class="footnote-backref" href="#fnref:186" rev="footnote" title="Jump back to footnote 186 in the text">↩</a></p> </li> <li id="fn:187"> <p>Another thing <a class="footnote-backref" href="#fnref:187" rev="footnote" title="Jump back to footnote 187 in the text">↩</a></p> </li> <li id="fn:188"> <p>Another thing <a class="footnote-backref" href="#fnref:188" rev="footnote" title="Jump back to footnote 188 in the text">↩</a></p> </li> <li id="fn:189"> <p>Another thing <a class="footnote-backref" href="#fnref:189" rev="footnote" title="Jump back to footnote 189 in the text">↩</a></p> </li> <li id="fn:190"> <p>Another thing <a class="footnote-backref" href="#fnref:190" rev="footnote" title="Jump back to footnote 190 in the text">↩</a></p> </li> <li id="fn:191"> <p>Another thing <a class="footnote-backref" href="#fnref:191" rev="footnote" title="Jump back to footnote 191 in the text">↩</a></p> </li> <li id="fn:192"> <p>Another thing <a class="footnote-backref" href="#fnref:192" rev="footnote" title="Jump back to footnote 192 in the text">↩</a></p> </li> <li id="fn:193"> <p>Another thing <a class="footnote-backref" href="#fnref:193" rev="footnote" title="Jump back to footnote 193 in the text">↩</a></p> </li> <li id="fn:194"> <p>Another thing <a class="footnote-backref" href="#fnref:194" rev="footnote" title="Jump back to footnote 194 in the text">↩</a></p> </li> <li id="fn:195"> <p>Another thing <a class="footnote-backref" href="#fnref:195" rev="footnote" title="Jump back to footnote 195 in the text">↩</a></p> </li> <li id="fn:196"> <p>Another thing <a class="footnote-backref" href="#fnref:196" rev="footnote" title="Jump back to footnote 196 in the text">↩</a></p> </li> <li id="fn:197"> <p>Another thing <a class="footnote-backref" href="#fnref:197" rev="footnote" title="Jump back to footnote 197 in the text">↩</a></p> </li> <li id="fn:198"> <p>Another thing <a class="footnote-backref" href="#fnref:198" rev="footnote" title="Jump back to footnote 198 in the text">↩</a></p> </li> <li id="fn:199"> <p>Another thing <a class="footnote-backref" href="#fnref:199" rev="footnote" title="Jump back to footnote 199 in the text">↩</a></p> </li> <li id="fn:200"> <p>Another thing <a class="footnote-backref" href="#fnref:200" rev="footnote" title="Jump back to footnote 200 in the text">↩</a></p> </li> <li id="fn:201"> <p>Another thing <a class="footnote-backref" href="#fnref:201" rev="footnote" title="Jump back to footnote 201 in the text">↩</a></p> </li> <li id="fn:202"> <p>Another thing <a class="footnote-backref" href="#fnref:202" rev="footnote" title="Jump back to footnote 202 in the text">↩</a></p> </li> <li id="fn:203"> <p>Another thing <a class="footnote-backref" href="#fnref:203" rev="footnote" title="Jump back to footnote 203 in the text">↩</a></p> </li> <li id="fn:204"> <p>Another thing <a class="footnote-backref" href="#fnref:204" rev="footnote" title="Jump back to footnote 204 in the text">↩</a></p> </li> <li id="fn:205"> <p>Another thing <a class="footnote-backref" href="#fnref:205" rev="footnote" title="Jump back to footnote 205 in the text">↩</a></p> </li> <li id="fn:206"> <p>Another thing <a class="footnote-backref" href="#fnref:206" rev="footnote" title="Jump back to footnote 206 in the text">↩</a></p> </li> <li id="fn:207"> <p>Another thing <a class="footnote-backref" href="#fnref:207" rev="footnote" title="Jump back to footnote 207 in the text">↩</a></p> </li> <li id="fn:208"> <p>Another thing <a class="footnote-backref" href="#fnref:208" rev="footnote" title="Jump back to footnote 208 in the text">↩</a></p> </li> <li id="fn:209"> <p>Another thing <a class="footnote-backref" href="#fnref:209" rev="footnote" title="Jump back to footnote 209 in the text">↩</a></p> </li> <li id="fn:210"> <p>Another thing <a class="footnote-backref" href="#fnref:210" rev="footnote" title="Jump back to footnote 210 in the text">↩</a></p> </li> <li id="fn:211"> <p>Another thing <a class="footnote-backref" href="#fnref:211" rev="footnote" title="Jump back to footnote 211 in the text">↩</a></p> </li> <li id="fn:212"> <p>Another thing <a class="footnote-backref" href="#fnref:212" rev="footnote" title="Jump back to footnote 212 in the text">↩</a></p> </li> <li id="fn:213"> <p>Another thing <a class="footnote-backref" href="#fnref:213" rev="footnote" title="Jump back to footnote 213 in the text">↩</a></p> </li> <li id="fn:214"> <p>Another thing <a class="footnote-backref" href="#fnref:214" rev="footnote" title="Jump back to footnote 214 in the text">↩</a></p> </li> <li id="fn:215"> <p>Another thing <a class="footnote-backref" href="#fnref:215" rev="footnote" title="Jump back to footnote 215 in the text">↩</a></p> </li> <li id="fn:216"> <p>Another thing <a class="footnote-backref" href="#fnref:216" rev="footnote" title="Jump back to footnote 216 in the text">↩</a></p> </li> <li id="fn:217"> <p>Another thing <a class="footnote-backref" href="#fnref:217" rev="footnote" title="Jump back to footnote 217 in the text">↩</a></p> </li> <li id="fn:218"> <p>Another thing <a class="footnote-backref" href="#fnref:218" rev="footnote" title="Jump back to footnote 218 in the text">↩</a></p> </li> <li id="fn:219"> <p>Another thing <a class="footnote-backref" href="#fnref:219" rev="footnote" title="Jump back to footnote 219 in the text">↩</a></p> </li> <li id="fn:220"> <p>Another thing <a class="footnote-backref" href="#fnref:220" rev="footnote" title="Jump back to footnote 220 in the text">↩</a></p> </li> <li id="fn:221"> <p>Another thing <a class="footnote-backref" href="#fnref:221" rev="footnote" title="Jump back to footnote 221 in the text">↩</a></p> </li> <li id="fn:222"> <p>Another thing <a class="footnote-backref" href="#fnref:222" rev="footnote" title="Jump back to footnote 222 in the text">↩</a></p> </li> <li id="fn:223"> <p>Another thing <a class="footnote-backref" href="#fnref:223" rev="footnote" title="Jump back to footnote 223 in the text">↩</a></p> </li> <li id="fn:224"> <p>Another thing <a class="footnote-backref" href="#fnref:224" rev="footnote" title="Jump back to footnote 224 in the text">↩</a></p> </li> <li id="fn:225"> <p>Another thing <a class="footnote-backref" href="#fnref:225" rev="footnote" title="Jump back to footnote 225 in the text">↩</a></p> </li> <li id="fn:226"> <p>Another thing <a class="footnote-backref" href="#fnref:226" rev="footnote" title="Jump back to footnote 226 in the text">↩</a></p> </li> <li id="fn:227"> <p>Another thing <a class="footnote-backref" href="#fnref:227" rev="footnote" title="Jump back to footnote 227 in the text">↩</a></p> </li> <li id="fn:228"> <p>Another thing <a class="footnote-backref" href="#fnref:228" rev="footnote" title="Jump back to footnote 228 in the text">↩</a></p> </li> <li id="fn:229"> <p>Another thing <a class="footnote-backref" href="#fnref:229" rev="footnote" title="Jump back to footnote 229 in the text">↩</a></p> </li> <li id="fn:230"> <p>Another thing <a class="footnote-backref" href="#fnref:230" rev="footnote" title="Jump back to footnote 230 in the text">↩</a></p> </li> <li id="fn:231"> <p>Another thing <a class="footnote-backref" href="#fnref:231" rev="footnote" title="Jump back to footnote 231 in the text">↩</a></p> </li> <li id="fn:232"> <p>Another thing <a class="footnote-backref" href="#fnref:232" rev="footnote" title="Jump back to footnote 232 in the text">↩</a></p> </li> <li id="fn:233"> <p>Another thing <a class="footnote-backref" href="#fnref:233" rev="footnote" title="Jump back to footnote 233 in the text">↩</a></p> </li> <li id="fn:234"> <p>Another thing <a class="footnote-backref" href="#fnref:234" rev="footnote" title="Jump back to footnote 234 in the text">↩</a></p> </li> <li id="fn:235"> <p>Another thing <a class="footnote-backref" href="#fnref:235" rev="footnote" title="Jump back to footnote 235 in the text">↩</a></p> </li> <li id="fn:236"> <p>Another thing <a class="footnote-backref" href="#fnref:236" rev="footnote" title="Jump back to footnote 236 in the text">↩</a></p> </li> <li id="fn:237"> <p>Another thing <a class="footnote-backref" href="#fnref:237" rev="footnote" title="Jump back to footnote 237 in the text">↩</a></p> </li> <li id="fn:238"> <p>Another thing <a class="footnote-backref" href="#fnref:238" rev="footnote" title="Jump back to footnote 238 in the text">↩</a></p> </li> <li id="fn:239"> <p>Another thing <a class="footnote-backref" href="#fnref:239" rev="footnote" title="Jump back to footnote 239 in the text">↩</a></p> </li> <li id="fn:240"> <p>Another thing <a class="footnote-backref" href="#fnref:240" rev="footnote" title="Jump back to footnote 240 in the text">↩</a></p> </li> <li id="fn:241"> <p>Another thing <a class="footnote-backref" href="#fnref:241" rev="footnote" title="Jump back to footnote 241 in the text">↩</a></p> </li> <li id="fn:242"> <p>Another thing <a class="footnote-backref" href="#fnref:242" rev="footnote" title="Jump back to footnote 242 in the text">↩</a></p> </li> <li id="fn:243"> <p>Another thing <a class="footnote-backref" href="#fnref:243" rev="footnote" title="Jump back to footnote 243 in the text">↩</a></p> </li> <li id="fn:244"> <p>Another thing <a class="footnote-backref" href="#fnref:244" rev="footnote" title="Jump back to footnote 244 in the text">↩</a></p> </li> <li id="fn:245"> <p>Another thing <a class="footnote-backref" href="#fnref:245" rev="footnote" title="Jump back to footnote 245 in the text">↩</a></p> </li> <li id="fn:246"> <p>Another thing <a class="footnote-backref" href="#fnref:246" rev="footnote" title="Jump back to footnote 246 in the text">↩</a></p> </li> <li id="fn:247"> <p>Another thing <a class="footnote-backref" href="#fnref:247" rev="footnote" title="Jump back to footnote 247 in the text">↩</a></p> </li> <li id="fn:248"> <p>Another thing <a class="footnote-backref" href="#fnref:248" rev="footnote" title="Jump back to footnote 248 in the text">↩</a></p> </li> <li id="fn:249"> <p>Another thing <a class="footnote-backref" href="#fnref:249" rev="footnote" title="Jump back to footnote 249 in the text">↩</a></p> </li> <li id="fn:250"> <p>Another thing <a class="footnote-backref" href="#fnref:250" rev="footnote" title="Jump back to footnote 250 in the text">↩</a></p> </li> <li id="fn:251"> <p>Another thing <a class="footnote-backref" href="#fnref:251" rev="footnote" title="Jump back to footnote 251 in the text">↩</a></p> </li> <li id="fn:252"> <p>Another thing <a class="footnote-backref" href="#fnref:252" rev="footnote" title="Jump back to footnote 252 in the text">↩</a></p> </li> <li id="fn:253"> <p>Another thing <a class="footnote-backref" href="#fnref:253" rev="footnote" title="Jump back to footnote 253 in the text">↩</a></p> </li> <li id="fn:254"> <p>Another thing <a class="footnote-backref" href="#fnref:254" rev="footnote" title="Jump back to footnote 254 in the text">↩</a></p> </li> <li id="fn:255"> <p>Another thing <a class="footnote-backref" href="#fnref:255" rev="footnote" title="Jump back to footnote 255 in the text">↩</a></p> </li> <li id="fn:256"> <p>Another thing <a class="footnote-backref" href="#fnref:256" rev="footnote" title="Jump back to footnote 256 in the text">↩</a></p> </li> <li id="fn:257"> <p>Another thing <a class="footnote-backref" href="#fnref:257" rev="footnote" title="Jump back to footnote 257 in the text">↩</a></p> </li> <li id="fn:258"> <p>Another thing <a class="footnote-backref" href="#fnref:258" rev="footnote" title="Jump back to footnote 258 in the text">↩</a></p> </li> <li id="fn:259"> <p>Another thing <a class="footnote-backref" href="#fnref:259" rev="footnote" title="Jump back to footnote 259 in the text">↩</a></p> </li> <li id="fn:260"> <p>Another thing <a class="footnote-backref" href="#fnref:260" rev="footnote" title="Jump back to footnote 260 in the text">↩</a></p> </li> <li id="fn:261"> <p>Another thing <a class="footnote-backref" href="#fnref:261" rev="footnote" title="Jump back to footnote 261 in the text">↩</a></p> </li> <li id="fn:262"> <p>Another thing <a class="footnote-backref" href="#fnref:262" rev="footnote" title="Jump back to footnote 262 in the text">↩</a></p> </li> <li id="fn:263"> <p>Another thing <a class="footnote-backref" href="#fnref:263" rev="footnote" title="Jump back to footnote 263 in the text">↩</a></p> </li> <li id="fn:264"> <p>Another thing <a class="footnote-backref" href="#fnref:264" rev="footnote" title="Jump back to footnote 264 in the text">↩</a></p> </li> <li id="fn:265"> <p>Another thing <a class="footnote-backref" href="#fnref:265" rev="footnote" title="Jump back to footnote 265 in the text">↩</a></p> </li> <li id="fn:266"> <p>Another thing <a class="footnote-backref" href="#fnref:266" rev="footnote" title="Jump back to footnote 266 in the text">↩</a></p> </li> <li id="fn:267"> <p>Another thing <a class="footnote-backref" href="#fnref:267" rev="footnote" title="Jump back to footnote 267 in the text">↩</a></p> </li> <li id="fn:268"> <p>Another thing <a class="footnote-backref" href="#fnref:268" rev="footnote" title="Jump back to footnote 268 in the text">↩</a></p> </li> <li id="fn:269"> <p>Another thing <a class="footnote-backref" href="#fnref:269" rev="footnote" title="Jump back to footnote 269 in the text">↩</a></p> </li> <li id="fn:270"> <p>Another thing <a class="footnote-backref" href="#fnref:270" rev="footnote" title="Jump back to footnote 270 in the text">↩</a></p> </li> <li id="fn:271"> <p>Another thing <a class="footnote-backref" href="#fnref:271" rev="footnote" title="Jump back to footnote 271 in the text">↩</a></p> </li> <li id="fn:272"> <p>Another thing <a class="footnote-backref" href="#fnref:272" rev="footnote" title="Jump back to footnote 272 in the text">↩</a></p> </li> <li id="fn:273"> <p>Another thing <a class="footnote-backref" href="#fnref:273" rev="footnote" title="Jump back to footnote 273 in the text">↩</a></p> </li> <li id="fn:274"> <p>Another thing <a class="footnote-backref" href="#fnref:274" rev="footnote" title="Jump back to footnote 274 in the text">↩</a></p> </li> <li id="fn:275"> <p>Another thing <a class="footnote-backref" href="#fnref:275" rev="footnote" title="Jump back to footnote 275 in the text">↩</a></p> </li> <li id="fn:276"> <p>Another thing <a class="footnote-backref" href="#fnref:276" rev="footnote" title="Jump back to footnote 276 in the text">↩</a></p> </li> <li id="fn:277"> <p>Another thing <a class="footnote-backref" href="#fnref:277" rev="footnote" title="Jump back to footnote 277 in the text">↩</a></p> </li> <li id="fn:278"> <p>Another thing <a class="footnote-backref" href="#fnref:278" rev="footnote" title="Jump back to footnote 278 in the text">↩</a></p> </li> <li id="fn:279"> <p>Another thing <a class="footnote-backref" href="#fnref:279" rev="footnote" title="Jump back to footnote 279 in the text">↩</a></p> </li> <li id="fn:280"> <p>Another thing <a class="footnote-backref" href="#fnref:280" rev="footnote" title="Jump back to footnote 280 in the text">↩</a></p> </li> <li id="fn:281"> <p>Another thing <a class="footnote-backref" href="#fnref:281" rev="footnote" title="Jump back to footnote 281 in the text">↩</a></p> </li> <li id="fn:282"> <p>Another thing <a class="footnote-backref" href="#fnref:282" rev="footnote" title="Jump back to footnote 282 in the text">↩</a></p> </li> <li id="fn:283"> <p>Another thing <a class="footnote-backref" href="#fnref:283" rev="footnote" title="Jump back to footnote 283 in the text">↩</a></p> </li> <li id="fn:284"> <p>Another thing <a class="footnote-backref" href="#fnref:284" rev="footnote" title="Jump back to footnote 284 in the text">↩</a></p> </li> <li id="fn:285"> <p>Another thing <a class="footnote-backref" href="#fnref:285" rev="footnote" title="Jump back to footnote 285 in the text">↩</a></p> </li> <li id="fn:286"> <p>Another thing <a class="footnote-backref" href="#fnref:286" rev="footnote" title="Jump back to footnote 286 in the text">↩</a></p> </li> <li id="fn:287"> <p>Another thing <a class="footnote-backref" href="#fnref:287" rev="footnote" title="Jump back to footnote 287 in the text">↩</a></p> </li> <li id="fn:288"> <p>Another thing <a class="footnote-backref" href="#fnref:288" rev="footnote" title="Jump back to footnote 288 in the text">↩</a></p> </li> <li id="fn:289"> <p>Another thing <a class="footnote-backref" href="#fnref:289" rev="footnote" title="Jump back to footnote 289 in the text">↩</a></p> </li> <li id="fn:290"> <p>Another thing <a class="footnote-backref" href="#fnref:290" rev="footnote" title="Jump back to footnote 290 in the text">↩</a></p> </li> <li id="fn:291"> <p>Another thing <a class="footnote-backref" href="#fnref:291" rev="footnote" title="Jump back to footnote 291 in the text">↩</a></p> </li> <li id="fn:292"> <p>Another thing <a class="footnote-backref" href="#fnref:292" rev="footnote" title="Jump back to footnote 292 in the text">↩</a></p> </li> <li id="fn:293"> <p>Another thing <a class="footnote-backref" href="#fnref:293" rev="footnote" title="Jump back to footnote 293 in the text">↩</a></p> </li> <li id="fn:294"> <p>Another thing <a class="footnote-backref" href="#fnref:294" rev="footnote" title="Jump back to footnote 294 in the text">↩</a></p> </li> <li id="fn:295"> <p>Another thing <a class="footnote-backref" href="#fnref:295" rev="footnote" title="Jump back to footnote 295 in the text">↩</a></p> </li> <li id="fn:296"> <p>Another thing <a class="footnote-backref" href="#fnref:296" rev="footnote" title="Jump back to footnote 296 in the text">↩</a></p> </li> <li id="fn:297"> <p>Another thing <a class="footnote-backref" href="#fnref:297" rev="footnote" title="Jump back to footnote 297 in the text">↩</a></p> </li> <li id="fn:298"> <p>Another thing <a class="footnote-backref" href="#fnref:298" rev="footnote" title="Jump back to footnote 298 in the text">↩</a></p> </li> <li id="fn:299"> <p>Another thing <a class="footnote-backref" href="#fnref:299" rev="footnote" title="Jump back to footnote 299 in the text">↩</a></p> </li> <li id="fn:300"> <p>Another thing <a class="footnote-backref" href="#fnref:300" rev="footnote" title="Jump back to footnote 300 in the text">↩</a></p> </li> <li id="fn:301"> <p>Another thing <a class="footnote-backref" href="#fnref:301" rev="footnote" title="Jump back to footnote 301 in the text">↩</a></p> </li> <li id="fn:302"> <p>Another thing <a class="footnote-backref" href="#fnref:302" rev="footnote" title="Jump back to footnote 302 in the text">↩</a></p> </li> <li id="fn:303"> <p>Another thing <a class="footnote-backref" href="#fnref:303" rev="footnote" title="Jump back to footnote 303 in the text">↩</a></p> </li> <li id="fn:304"> <p>Another thing <a class="footnote-backref" href="#fnref:304" rev="footnote" title="Jump back to footnote 304 in the text">↩</a></p> </li> <li id="fn:305"> <p>Another thing <a class="footnote-backref" href="#fnref:305" rev="footnote" title="Jump back to footnote 305 in the text">↩</a></p> </li> <li id="fn:306"> <p>Another thing <a class="footnote-backref" href="#fnref:306" rev="footnote" title="Jump back to footnote 306 in the text">↩</a></p> </li> <li id="fn:307"> <p>Another thing <a class="footnote-backref" href="#fnref:307" rev="footnote" title="Jump back to footnote 307 in the text">↩</a></p> </li> <li id="fn:308"> <p>Another thing <a class="footnote-backref" href="#fnref:308" rev="footnote" title="Jump back to footnote 308 in the text">↩</a></p> </li> <li id="fn:309"> <p>Another thing <a class="footnote-backref" href="#fnref:309" rev="footnote" title="Jump back to footnote 309 in the text">↩</a></p> </li> <li id="fn:310"> <p>Another thing <a class="footnote-backref" href="#fnref:310" rev="footnote" title="Jump back to footnote 310 in the text">↩</a></p> </li> <li id="fn:311"> <p>Another thing <a class="footnote-backref" href="#fnref:311" rev="footnote" title="Jump back to footnote 311 in the text">↩</a></p> </li> <li id="fn:312"> <p>Another thing <a class="footnote-backref" href="#fnref:312" rev="footnote" title="Jump back to footnote 312 in the text">↩</a></p> </li> <li id="fn:313"> <p>Another thing <a class="footnote-backref" href="#fnref:313" rev="footnote" title="Jump back to footnote 313 in the text">↩</a></p> </li> <li id="fn:314"> <p>Another thing <a class="footnote-backref" href="#fnref:314" rev="footnote" title="Jump back to footnote 314 in the text">↩</a></p> </li> <li id="fn:315"> <p>Another thing <a class="footnote-backref" href="#fnref:315" rev="footnote" title="Jump back to footnote 315 in the text">↩</a></p> </li> <li id="fn:316"> <p>Another thing <a class="footnote-backref" href="#fnref:316" rev="footnote" title="Jump back to footnote 316 in the text">↩</a></p> </li> <li id="fn:317"> <p>Another thing <a class="footnote-backref" href="#fnref:317" rev="footnote" title="Jump back to footnote 317 in the text">↩</a></p> </li> <li id="fn:318"> <p>Another thing <a class="footnote-backref" href="#fnref:318" rev="footnote" title="Jump back to footnote 318 in the text">↩</a></p> </li> <li id="fn:319"> <p>Another thing <a class="footnote-backref" href="#fnref:319" rev="footnote" title="Jump back to footnote 319 in the text">↩</a></p> </li> <li id="fn:320"> <p>Another thing <a class="footnote-backref" href="#fnref:320" rev="footnote" title="Jump back to footnote 320 in the text">↩</a></p> </li> <li id="fn:321"> <p>Another thing <a class="footnote-backref" href="#fnref:321" rev="footnote" title="Jump back to footnote 321 in the text">↩</a></p> </li> <li id="fn:322"> <p>Another thing <a class="footnote-backref" href="#fnref:322" rev="footnote" title="Jump back to footnote 322 in the text">↩</a></p> </li> <li id="fn:323"> <p>Another thing <a class="footnote-backref" href="#fnref:323" rev="footnote" title="Jump back to footnote 323 in the text">↩</a></p> </li> <li id="fn:324"> <p>Another thing <a class="footnote-backref" href="#fnref:324" rev="footnote" title="Jump back to footnote 324 in the text">↩</a></p> </li> <li id="fn:325"> <p>Another thing <a class="footnote-backref" href="#fnref:325" rev="footnote" title="Jump back to footnote 325 in the text">↩</a></p> </li> <li id="fn:326"> <p>Another thing <a class="footnote-backref" href="#fnref:326" rev="footnote" title="Jump back to footnote 326 in the text">↩</a></p> </li> <li id="fn:327"> <p>Another thing <a class="footnote-backref" href="#fnref:327" rev="footnote" title="Jump back to footnote 327 in the text">↩</a></p> </li> <li id="fn:328"> <p>Another thing <a class="footnote-backref" href="#fnref:328" rev="footnote" title="Jump back to footnote 328 in the text">↩</a></p> </li> <li id="fn:329"> <p>Another thing <a class="footnote-backref" href="#fnref:329" rev="footnote" title="Jump back to footnote 329 in the text">↩</a></p> </li> <li id="fn:330"> <p>Another thing <a class="footnote-backref" href="#fnref:330" rev="footnote" title="Jump back to footnote 330 in the text">↩</a></p> </li> <li id="fn:331"> <p>Another thing <a class="footnote-backref" href="#fnref:331" rev="footnote" title="Jump back to footnote 331 in the text">↩</a></p> </li> <li id="fn:332"> <p>Another thing <a class="footnote-backref" href="#fnref:332" rev="footnote" title="Jump back to footnote 332 in the text">↩</a></p> </li> <li id="fn:333"> <p>Another thing <a class="footnote-backref" href="#fnref:333" rev="footnote" title="Jump back to footnote 333 in the text">↩</a></p> </li> <li id="fn:334"> <p>Another thing <a class="footnote-backref" href="#fnref:334" rev="footnote" title="Jump back to footnote 334 in the text">↩</a></p> </li> <li id="fn:335"> <p>Another thing <a class="footnote-backref" href="#fnref:335" rev="footnote" title="Jump back to footnote 335 in the text">↩</a></p> </li> <li id="fn:336"> <p>Another thing <a class="footnote-backref" href="#fnref:336" rev="footnote" title="Jump back to footnote 336 in the text">↩</a></p> </li> <li id="fn:337"> <p>Another thing <a class="footnote-backref" href="#fnref:337" rev="footnote" title="Jump back to footnote 337 in the text">↩</a></p> </li> <li id="fn:338"> <p>Another thing <a class="footnote-backref" href="#fnref:338" rev="footnote" title="Jump back to footnote 338 in the text">↩</a></p> </li> <li id="fn:339"> <p>Another thing <a class="footnote-backref" href="#fnref:339" rev="footnote" title="Jump back to footnote 339 in the text">↩</a></p> </li> <li id="fn:340"> <p>Another thing <a class="footnote-backref" href="#fnref:340" rev="footnote" title="Jump back to footnote 340 in the text">↩</a></p> </li> <li id="fn:341"> <p>Another thing <a class="footnote-backref" href="#fnref:341" rev="footnote" title="Jump back to footnote 341 in the text">↩</a></p> </li> <li id="fn:342"> <p>Another thing <a class="footnote-backref" href="#fnref:342" rev="footnote" title="Jump back to footnote 342 in the text">↩</a></p> </li> <li id="fn:343"> <p>Another thing <a class="footnote-backref" href="#fnref:343" rev="footnote" title="Jump back to footnote 343 in the text">↩</a></p> </li> <li id="fn:344"> <p>Another thing <a class="footnote-backref" href="#fnref:344" rev="footnote" title="Jump back to footnote 344 in the text">↩</a></p> </li> <li id="fn:345"> <p>Another thing <a class="footnote-backref" href="#fnref:345" rev="footnote" title="Jump back to footnote 345 in the text">↩</a></p> </li> <li id="fn:346"> <p>Another thing <a class="footnote-backref" href="#fnref:346" rev="footnote" title="Jump back to footnote 346 in the text">↩</a></p> </li> <li id="fn:347"> <p>Another thing <a class="footnote-backref" href="#fnref:347" rev="footnote" title="Jump back to footnote 347 in the text">↩</a></p> </li> <li id="fn:348"> <p>Another thing <a class="footnote-backref" href="#fnref:348" rev="footnote" title="Jump back to footnote 348 in the text">↩</a></p> </li> <li id="fn:349"> <p>Another thing <a class="footnote-backref" href="#fnref:349" rev="footnote" title="Jump back to footnote 349 in the text">↩</a></p> </li> <li id="fn:350"> <p>Another thing <a class="footnote-backref" href="#fnref:350" rev="footnote" title="Jump back to footnote 350 in the text">↩</a></p> </li> <li id="fn:351"> <p>Another thing <a class="footnote-backref" href="#fnref:351" rev="footnote" title="Jump back to footnote 351 in the text">↩</a></p> </li> <li id="fn:352"> <p>Another thing <a class="footnote-backref" href="#fnref:352" rev="footnote" title="Jump back to footnote 352 in the text">↩</a></p> </li> <li id="fn:353"> <p>Another thing <a class="footnote-backref" href="#fnref:353" rev="footnote" title="Jump back to footnote 353 in the text">↩</a></p> </li> <li id="fn:354"> <p>Another thing <a class="footnote-backref" href="#fnref:354" rev="footnote" title="Jump back to footnote 354 in the text">↩</a></p> </li> <li id="fn:355"> <p>Another thing <a class="footnote-backref" href="#fnref:355" rev="footnote" title="Jump back to footnote 355 in the text">↩</a></p> </li> <li id="fn:356"> <p>Another thing <a class="footnote-backref" href="#fnref:356" rev="footnote" title="Jump back to footnote 356 in the text">↩</a></p> </li> <li id="fn:357"> <p>Another thing <a class="footnote-backref" href="#fnref:357" rev="footnote" title="Jump back to footnote 357 in the text">↩</a></p> </li> <li id="fn:358"> <p>Another thing <a class="footnote-backref" href="#fnref:358" rev="footnote" title="Jump back to footnote 358 in the text">↩</a></p> </li> <li id="fn:359"> <p>Another thing <a class="footnote-backref" href="#fnref:359" rev="footnote" title="Jump back to footnote 359 in the text">↩</a></p> </li> <li id="fn:360"> <p>Another thing <a class="footnote-backref" href="#fnref:360" rev="footnote" title="Jump back to footnote 360 in the text">↩</a></p> </li> <li id="fn:361"> <p>Another thing <a class="footnote-backref" href="#fnref:361" rev="footnote" title="Jump back to footnote 361 in the text">↩</a></p> </li> <li id="fn:362"> <p>Another thing <a class="footnote-backref" href="#fnref:362" rev="footnote" title="Jump back to footnote 362 in the text">↩</a></p> </li> <li id="fn:363"> <p>Another thing <a class="footnote-backref" href="#fnref:363" rev="footnote" title="Jump back to footnote 363 in the text">↩</a></p> </li> <li id="fn:364"> <p>Another thing <a class="footnote-backref" href="#fnref:364" rev="footnote" title="Jump back to footnote 364 in the text">↩</a></p> </li> <li id="fn:365"> <p>Another thing <a class="footnote-backref" href="#fnref:365" rev="footnote" title="Jump back to footnote 365 in the text">↩</a></p> </li> <li id="fn:366"> <p>Another thing <a class="footnote-backref" href="#fnref:366" rev="footnote" title="Jump back to footnote 366 in the text">↩</a></p> </li> <li id="fn:367"> <p>Another thing <a class="footnote-backref" href="#fnref:367" rev="footnote" title="Jump back to footnote 367 in the text">↩</a></p> </li> <li id="fn:368"> <p>Another thing <a class="footnote-backref" href="#fnref:368" rev="footnote" title="Jump back to footnote 368 in the text">↩</a></p> </li> <li id="fn:369"> <p>Another thing <a class="footnote-backref" href="#fnref:369" rev="footnote" title="Jump back to footnote 369 in the text">↩</a></p> </li> <li id="fn:370"> <p>Another thing <a class="footnote-backref" href="#fnref:370" rev="footnote" title="Jump back to footnote 370 in the text">↩</a></p> </li> <li id="fn:371"> <p>Another thing <a class="footnote-backref" href="#fnref:371" rev="footnote" title="Jump back to footnote 371 in the text">↩</a></p> </li> <li id="fn:372"> <p>Another thing <a class="footnote-backref" href="#fnref:372" rev="footnote" title="Jump back to footnote 372 in the text">↩</a></p> </li> <li id="fn:373"> <p>Another thing <a class="footnote-backref" href="#fnref:373" rev="footnote" title="Jump back to footnote 373 in the text">↩</a></p> </li> <li id="fn:374"> <p>Another thing <a class="footnote-backref" href="#fnref:374" rev="footnote" title="Jump back to footnote 374 in the text">↩</a></p> </li> <li id="fn:375"> <p>Another thing <a class="footnote-backref" href="#fnref:375" rev="footnote" title="Jump back to footnote 375 in the text">↩</a></p> </li> <li id="fn:376"> <p>Another thing <a class="footnote-backref" href="#fnref:376" rev="footnote" title="Jump back to footnote 376 in the text">↩</a></p> </li> <li id="fn:377"> <p>Another thing <a class="footnote-backref" href="#fnref:377" rev="footnote" title="Jump back to footnote 377 in the text">↩</a></p> </li> <li id="fn:378"> <p>Another thing <a class="footnote-backref" href="#fnref:378" rev="footnote" title="Jump back to footnote 378 in the text">↩</a></p> </li> <li id="fn:379"> <p>Another thing <a class="footnote-backref" href="#fnref:379" rev="footnote" title="Jump back to footnote 379 in the text">↩</a></p> </li> <li id="fn:380"> <p>Another thing <a class="footnote-backref" href="#fnref:380" rev="footnote" title="Jump back to footnote 380 in the text">↩</a></p> </li> <li id="fn:381"> <p>Another thing <a class="footnote-backref" href="#fnref:381" rev="footnote" title="Jump back to footnote 381 in the text">↩</a></p> </li> <li id="fn:382"> <p>Another thing <a class="footnote-backref" href="#fnref:382" rev="footnote" title="Jump back to footnote 382 in the text">↩</a></p> </li> <li id="fn:383"> <p>Another thing <a class="footnote-backref" href="#fnref:383" rev="footnote" title="Jump back to footnote 383 in the text">↩</a></p> </li> <li id="fn:384"> <p>Another thing <a class="footnote-backref" href="#fnref:384" rev="footnote" title="Jump back to footnote 384 in the text">↩</a></p> </li> <li id="fn:385"> <p>Another thing <a class="footnote-backref" href="#fnref:385" rev="footnote" title="Jump back to footnote 385 in the text">↩</a></p> </li> <li id="fn:386"> <p>Another thing <a class="footnote-backref" href="#fnref:386" rev="footnote" title="Jump back to footnote 386 in the text">↩</a></p> </li> <li id="fn:387"> <p>Another thing <a class="footnote-backref" href="#fnref:387" rev="footnote" title="Jump back to footnote 387 in the text">↩</a></p> </li> <li id="fn:388"> <p>Another thing <a class="footnote-backref" href="#fnref:388" rev="footnote" title="Jump back to footnote 388 in the text">↩</a></p> </li> <li id="fn:389"> <p>Another thing <a class="footnote-backref" href="#fnref:389" rev="footnote" title="Jump back to footnote 389 in the text">↩</a></p> </li> <li id="fn:390"> <p>Another thing <a class="footnote-backref" href="#fnref:390" rev="footnote" title="Jump back to footnote 390 in the text">↩</a></p> </li> <li id="fn:391"> <p>Another thing <a class="footnote-backref" href="#fnref:391" rev="footnote" title="Jump back to footnote 391 in the text">↩</a></p> </li> <li id="fn:392"> <p>Another thing <a class="footnote-backref" href="#fnref:392" rev="footnote" title="Jump back to footnote 392 in the text">↩</a></p> </li> <li id="fn:393"> <p>Another thing <a class="footnote-backref" href="#fnref:393" rev="footnote" title="Jump back to footnote 393 in the text">↩</a></p> </li> <li id="fn:394"> <p>Another thing <a class="footnote-backref" href="#fnref:394" rev="footnote" title="Jump back to footnote 394 in the text">↩</a></p> </li> <li id="fn:395"> <p>Another thing <a class="footnote-backref" href="#fnref:395" rev="footnote" title="Jump back to footnote 395 in the text">↩</a></p> </li> <li id="fn:396"> <p>Another thing <a class="footnote-backref" href="#fnref:396" rev="footnote" title="Jump back to footnote 396 in the text">↩</a></p> </li> <li id="fn:397"> <p>Another thing <a class="footnote-backref" href="#fnref:397" rev="footnote" title="Jump back to footnote 397 in the text">↩</a></p> </li> <li id="fn:398"> <p>Another thing <a class="footnote-backref" href="#fnref:398" rev="footnote" title="Jump back to footnote 398 in the text">↩</a></p> </li> <li id="fn:399"> <p>Another thing <a class="footnote-backref" href="#fnref:399" rev="footnote" title="Jump back to footnote 399 in the text">↩</a></p> </li> <li id="fn:400"> <p>Another thing <a class="footnote-backref" href="#fnref:400" rev="footnote" title="Jump back to footnote 400 in the text">↩</a></p> </li> <li id="fn:401"> <p>Another thing <a class="footnote-backref" href="#fnref:401" rev="footnote" title="Jump back to footnote 401 in the text">↩</a></p> </li> <li id="fn:402"> <p>Another thing <a class="footnote-backref" href="#fnref:402" rev="footnote" title="Jump back to footnote 402 in the text">↩</a></p> </li> <li id="fn:403"> <p>Another thing <a class="footnote-backref" href="#fnref:403" rev="footnote" title="Jump back to footnote 403 in the text">↩</a></p> </li> <li id="fn:404"> <p>Another thing <a class="footnote-backref" href="#fnref:404" rev="footnote" title="Jump back to footnote 404 in the text">↩</a></p> </li> <li id="fn:405"> <p>Another thing <a class="footnote-backref" href="#fnref:405" rev="footnote" title="Jump back to footnote 405 in the text">↩</a></p> </li> <li id="fn:406"> <p>Another thing <a class="footnote-backref" href="#fnref:406" rev="footnote" title="Jump back to footnote 406 in the text">↩</a></p> </li> <li id="fn:407"> <p>Another thing <a class="footnote-backref" href="#fnref:407" rev="footnote" title="Jump back to footnote 407 in the text">↩</a></p> </li> <li id="fn:408"> <p>Another thing <a class="footnote-backref" href="#fnref:408" rev="footnote" title="Jump back to footnote 408 in the text">↩</a></p> </li> <li id="fn:409"> <p>Another thing <a class="footnote-backref" href="#fnref:409" rev="footnote" title="Jump back to footnote 409 in the text">↩</a></p> </li> <li id="fn:410"> <p>Another thing <a class="footnote-backref" href="#fnref:410" rev="footnote" title="Jump back to footnote 410 in the text">↩</a></p> </li> <li id="fn:411"> <p>Another thing <a class="footnote-backref" href="#fnref:411" rev="footnote" title="Jump back to footnote 411 in the text">↩</a></p> </li> <li id="fn:412"> <p>Another thing <a class="footnote-backref" href="#fnref:412" rev="footnote" title="Jump back to footnote 412 in the text">↩</a></p> </li> <li id="fn:413"> <p>Another thing <a class="footnote-backref" href="#fnref:413" rev="footnote" title="Jump back to footnote 413 in the text">↩</a></p> </li> <li id="fn:414"> <p>Another thing <a class="footnote-backref" href="#fnref:414" rev="footnote" title="Jump back to footnote 414 in the text">↩</a></p> </li> <li id="fn:415"> <p>Another thing <a class="footnote-backref" href="#fnref:415" rev="footnote" title="Jump back to footnote 415 in the text">↩</a></p> </li> <li id="fn:416"> <p>Another thing <a class="footnote-backref" href="#fnref:416" rev="footnote" title="Jump back to footnote 416 in the text">↩</a></p> </li> <li id="fn:417"> <p>Another thing <a class="footnote-backref" href="#fnref:417" rev="footnote" title="Jump back to footnote 417 in the text">↩</a></p> </li> <li id="fn:418"> <p>Another thing <a class="footnote-backref" href="#fnref:418" rev="footnote" title="Jump back to footnote 418 in the text">↩</a></p> </li> <li id="fn:419"> <p>Another thing <a class="footnote-backref" href="#fnref:419" rev="footnote" title="Jump back to footnote 419 in the text">↩</a></p> </li> <li id="fn:420"> <p>Another thing <a class="footnote-backref" href="#fnref:420" rev="footnote" title="Jump back to footnote 420 in the text">↩</a></p> </li> <li id="fn:421"> <p>Another thing <a class="footnote-backref" href="#fnref:421" rev="footnote" title="Jump back to footnote 421 in the text">↩</a></p> </li> <li id="fn:422"> <p>Another thing <a class="footnote-backref" href="#fnref:422" rev="footnote" title="Jump back to footnote 422 in the text">↩</a></p> </li> <li id="fn:423"> <p>Another thing <a class="footnote-backref" href="#fnref:423" rev="footnote" title="Jump back to footnote 423 in the text">↩</a></p> </li> <li id="fn:424"> <p>Another thing <a class="footnote-backref" href="#fnref:424" rev="footnote" title="Jump back to footnote 424 in the text">↩</a></p> </li> <li id="fn:425"> <p>Another thing <a class="footnote-backref" href="#fnref:425" rev="footnote" title="Jump back to footnote 425 in the text">↩</a></p> </li> <li id="fn:426"> <p>Another thing <a class="footnote-backref" href="#fnref:426" rev="footnote" title="Jump back to footnote 426 in the text">↩</a></p> </li> <li id="fn:427"> <p>Another thing <a class="footnote-backref" href="#fnref:427" rev="footnote" title="Jump back to footnote 427 in the text">↩</a></p> </li> <li id="fn:428"> <p>Another thing <a class="footnote-backref" href="#fnref:428" rev="footnote" title="Jump back to footnote 428 in the text">↩</a></p> </li> <li id="fn:429"> <p>Another thing <a class="footnote-backref" href="#fnref:429" rev="footnote" title="Jump back to footnote 429 in the text">↩</a></p> </li> <li id="fn:430"> <p>Another thing <a class="footnote-backref" href="#fnref:430" rev="footnote" title="Jump back to footnote 430 in the text">↩</a></p> </li> <li id="fn:431"> <p>Another thing <a class="footnote-backref" href="#fnref:431" rev="footnote" title="Jump back to footnote 431 in the text">↩</a></p> </li> <li id="fn:432"> <p>Another thing <a class="footnote-backref" href="#fnref:432" rev="footnote" title="Jump back to footnote 432 in the text">↩</a></p> </li> <li id="fn:433"> <p>Another thing <a class="footnote-backref" href="#fnref:433" rev="footnote" title="Jump back to footnote 433 in the text">↩</a></p> </li> <li id="fn:434"> <p>Another thing <a class="footnote-backref" href="#fnref:434" rev="footnote" title="Jump back to footnote 434 in the text">↩</a></p> </li> <li id="fn:435"> <p>Another thing <a class="footnote-backref" href="#fnref:435" rev="footnote" title="Jump back to footnote 435 in the text">↩</a></p> </li> <li id="fn:436"> <p>Another thing <a class="footnote-backref" href="#fnref:436" rev="footnote" title="Jump back to footnote 436 in the text">↩</a></p> </li> <li id="fn:437"> <p>Another thing <a class="footnote-backref" href="#fnref:437" rev="footnote" title="Jump back to footnote 437 in the text">↩</a></p> </li> <li id="fn:438"> <p>Another thing <a class="footnote-backref" href="#fnref:438" rev="footnote" title="Jump back to footnote 438 in the text">↩</a></p> </li> <li id="fn:439"> <p>Another thing <a class="footnote-backref" href="#fnref:439" rev="footnote" title="Jump back to footnote 439 in the text">↩</a></p> </li> <li id="fn:440"> <p>Another thing <a class="footnote-backref" href="#fnref:440" rev="footnote" title="Jump back to footnote 440 in the text">↩</a></p> </li> <li id="fn:441"> <p>Another thing <a class="footnote-backref" href="#fnref:441" rev="footnote" title="Jump back to footnote 441 in the text">↩</a></p> </li> <li id="fn:442"> <p>Another thing <a class="footnote-backref" href="#fnref:442" rev="footnote" title="Jump back to footnote 442 in the text">↩</a></p> </li> <li id="fn:443"> <p>Another thing <a class="footnote-backref" href="#fnref:443" rev="footnote" title="Jump back to footnote 443 in the text">↩</a></p> </li> <li id="fn:444"> <p>Another thing <a class="footnote-backref" href="#fnref:444" rev="footnote" title="Jump back to footnote 444 in the text">↩</a></p> </li> <li id="fn:445"> <p>Another thing <a class="footnote-backref" href="#fnref:445" rev="footnote" title="Jump back to footnote 445 in the text">↩</a></p> </li> <li id="fn:446"> <p>Another thing <a class="footnote-backref" href="#fnref:446" rev="footnote" title="Jump back to footnote 446 in the text">↩</a></p> </li> <li id="fn:447"> <p>Another thing <a class="footnote-backref" href="#fnref:447" rev="footnote" title="Jump back to footnote 447 in the text">↩</a></p> </li> <li id="fn:448"> <p>Another thing <a class="footnote-backref" href="#fnref:448" rev="footnote" title="Jump back to footnote 448 in the text">↩</a></p> </li> <li id="fn:449"> <p>Another thing <a class="footnote-backref" href="#fnref:449" rev="footnote" title="Jump back to footnote 449 in the text">↩</a></p> </li> <li id="fn:450"> <p>Another thing <a class="footnote-backref" href="#fnref:450" rev="footnote" title="Jump back to footnote 450 in the text">↩</a></p> </li> <li id="fn:451"> <p>Another thing <a class="footnote-backref" href="#fnref:451" rev="footnote" title="Jump back to footnote 451 in the text">↩</a></p> </li> <li id="fn:452"> <p>Another thing <a class="footnote-backref" href="#fnref:452" rev="footnote" title="Jump back to footnote 452 in the text">↩</a></p> </li> <li id="fn:453"> <p>Another thing <a class="footnote-backref" href="#fnref:453" rev="footnote" title="Jump back to footnote 453 in the text">↩</a></p> </li> <li id="fn:454"> <p>Another thing <a class="footnote-backref" href="#fnref:454" rev="footnote" title="Jump back to footnote 454 in the text">↩</a></p> </li> <li id="fn:455"> <p>Another thing <a class="footnote-backref" href="#fnref:455" rev="footnote" title="Jump back to footnote 455 in the text">↩</a></p> </li> <li id="fn:456"> <p>Another thing <a class="footnote-backref" href="#fnref:456" rev="footnote" title="Jump back to footnote 456 in the text">↩</a></p> </li> <li id="fn:457"> <p>Another thing <a class="footnote-backref" href="#fnref:457" rev="footnote" title="Jump back to footnote 457 in the text">↩</a></p> </li> <li id="fn:458"> <p>Another thing <a class="footnote-backref" href="#fnref:458" rev="footnote" title="Jump back to footnote 458 in the text">↩</a></p> </li> <li id="fn:459"> <p>Another thing <a class="footnote-backref" href="#fnref:459" rev="footnote" title="Jump back to footnote 459 in the text">↩</a></p> </li> <li id="fn:460"> <p>Another thing <a class="footnote-backref" href="#fnref:460" rev="footnote" title="Jump back to footnote 460 in the text">↩</a></p> </li> <li id="fn:461"> <p>Another thing <a class="footnote-backref" href="#fnref:461" rev="footnote" title="Jump back to footnote 461 in the text">↩</a></p> </li> <li id="fn:462"> <p>Another thing <a class="footnote-backref" href="#fnref:462" rev="footnote" title="Jump back to footnote 462 in the text">↩</a></p> </li> <li id="fn:463"> <p>Another thing <a class="footnote-backref" href="#fnref:463" rev="footnote" title="Jump back to footnote 463 in the text">↩</a></p> </li> <li id="fn:464"> <p>Another thing <a class="footnote-backref" href="#fnref:464" rev="footnote" title="Jump back to footnote 464 in the text">↩</a></p> </li> <li id="fn:465"> <p>Another thing <a class="footnote-backref" href="#fnref:465" rev="footnote" title="Jump back to footnote 465 in the text">↩</a></p> </li> <li id="fn:466"> <p>Another thing <a class="footnote-backref" href="#fnref:466" rev="footnote" title="Jump back to footnote 466 in the text">↩</a></p> </li> <li id="fn:467"> <p>Another thing <a class="footnote-backref" href="#fnref:467" rev="footnote" title="Jump back to footnote 467 in the text">↩</a></p> </li> <li id="fn:468"> <p>Another thing <a class="footnote-backref" href="#fnref:468" rev="footnote" title="Jump back to footnote 468 in the text">↩</a></p> </li> <li id="fn:469"> <p>Another thing <a class="footnote-backref" href="#fnref:469" rev="footnote" title="Jump back to footnote 469 in the text">↩</a></p> </li> <li id="fn:470"> <p>Another thing <a class="footnote-backref" href="#fnref:470" rev="footnote" title="Jump back to footnote 470 in the text">↩</a></p> </li> <li id="fn:471"> <p>Another thing <a class="footnote-backref" href="#fnref:471" rev="footnote" title="Jump back to footnote 471 in the text">↩</a></p> </li> <li id="fn:472"> <p>Another thing <a class="footnote-backref" href="#fnref:472" rev="footnote" title="Jump back to footnote 472 in the text">↩</a></p> </li> <li id="fn:473"> <p>Another thing <a class="footnote-backref" href="#fnref:473" rev="footnote" title="Jump back to footnote 473 in the text">↩</a></p> </li> <li id="fn:474"> <p>Another thing <a class="footnote-backref" href="#fnref:474" rev="footnote" title="Jump back to footnote 474 in the text">↩</a></p> </li> <li id="fn:475"> <p>Another thing <a class="footnote-backref" href="#fnref:475" rev="footnote" title="Jump back to footnote 475 in the text">↩</a></p> </li> <li id="fn:476"> <p>Another thing <a class="footnote-backref" href="#fnref:476" rev="footnote" title="Jump back to footnote 476 in the text">↩</a></p> </li> <li id="fn:477"> <p>Another thing <a class="footnote-backref" href="#fnref:477" rev="footnote" title="Jump back to footnote 477 in the text">↩</a></p> </li> <li id="fn:478"> <p>Another thing <a class="footnote-backref" href="#fnref:478" rev="footnote" title="Jump back to footnote 478 in the text">↩</a></p> </li> <li id="fn:479"> <p>Another thing <a class="footnote-backref" href="#fnref:479" rev="footnote" title="Jump back to footnote 479 in the text">↩</a></p> </li> <li id="fn:480"> <p>Another thing <a class="footnote-backref" href="#fnref:480" rev="footnote" title="Jump back to footnote 480 in the text">↩</a></p> </li> <li id="fn:481"> <p>Another thing <a class="footnote-backref" href="#fnref:481" rev="footnote" title="Jump back to footnote 481 in the text">↩</a></p> </li> <li id="fn:482"> <p>Another thing <a class="footnote-backref" href="#fnref:482" rev="footnote" title="Jump back to footnote 482 in the text">↩</a></p> </li> <li id="fn:483"> <p>Another thing <a class="footnote-backref" href="#fnref:483" rev="footnote" title="Jump back to footnote 483 in the text">↩</a></p> </li> <li id="fn:484"> <p>Another thing <a class="footnote-backref" href="#fnref:484" rev="footnote" title="Jump back to footnote 484 in the text">↩</a></p> </li> <li id="fn:485"> <p>Another thing <a class="footnote-backref" href="#fnref:485" rev="footnote" title="Jump back to footnote 485 in the text">↩</a></p> </li> <li id="fn:486"> <p>Another thing <a class="footnote-backref" href="#fnref:486" rev="footnote" title="Jump back to footnote 486 in the text">↩</a></p> </li> <li id="fn:487"> <p>Another thing <a class="footnote-backref" href="#fnref:487" rev="footnote" title="Jump back to footnote 487 in the text">↩</a></p> </li> <li id="fn:488"> <p>Another thing <a class="footnote-backref" href="#fnref:488" rev="footnote" title="Jump back to footnote 488 in the text">↩</a></p> </li> <li id="fn:489"> <p>Another thing <a class="footnote-backref" href="#fnref:489" rev="footnote" title="Jump back to footnote 489 in the text">↩</a></p> </li> <li id="fn:490"> <p>Another thing <a class="footnote-backref" href="#fnref:490" rev="footnote" title="Jump back to footnote 490 in the text">↩</a></p> </li> <li id="fn:491"> <p>Another thing <a class="footnote-backref" href="#fnref:491" rev="footnote" title="Jump back to footnote 491 in the text">↩</a></p> </li> <li id="fn:492"> <p>Another thing <a class="footnote-backref" href="#fnref:492" rev="footnote" title="Jump back to footnote 492 in the text">↩</a></p> </li> <li id="fn:493"> <p>Another thing <a class="footnote-backref" href="#fnref:493" rev="footnote" title="Jump back to footnote 493 in the text">↩</a></p> </li> <li id="fn:494"> <p>Another thing <a class="footnote-backref" href="#fnref:494" rev="footnote" title="Jump back to footnote 494 in the text">↩</a></p> </li> <li id="fn:495"> <p>Another thing <a class="footnote-backref" href="#fnref:495" rev="footnote" title="Jump back to footnote 495 in the text">↩</a></p> </li> <li id="fn:496"> <p>Another thing <a class="footnote-backref" href="#fnref:496" rev="footnote" title="Jump back to footnote 496 in the text">↩</a></p> </li> <li id="fn:497"> <p>Another thing <a class="footnote-backref" href="#fnref:497" rev="footnote" title="Jump back to footnote 497 in the text">↩</a></p> </li> <li id="fn:498"> <p>Another thing <a class="footnote-backref" href="#fnref:498" rev="footnote" title="Jump back to footnote 498 in the text">↩</a></p> </li> <li id="fn:499"> <p>Another thing <a class="footnote-backref" href="#fnref:499" rev="footnote" title="Jump back to footnote 499 in the text">↩</a></p> </li> <li id="fn:500"> <p>Another thing <a class="footnote-backref" href="#fnref:500" rev="footnote" title="Jump back to footnote 500 in the text">↩</a></p> </li> <li id="fn:501"> <p>Another thing <a class="footnote-backref" href="#fnref:501" rev="footnote" title="Jump back to footnote 501 in the text">↩</a></p> </li> <li id="fn:502"> <p>Another thing <a class="footnote-backref" href="#fnref:502" rev="footnote" title="Jump back to footnote 502 in the text">↩</a></p> </li> <li id="fn:503"> <p>Another thing <a class="footnote-backref" href="#fnref:503" rev="footnote" title="Jump back to footnote 503 in the text">↩</a></p> </li> <li id="fn:504"> <p>Another thing <a class="footnote-backref" href="#fnref:504" rev="footnote" title="Jump back to footnote 504 in the text">↩</a></p> </li> <li id="fn:505"> <p>Another thing <a class="footnote-backref" href="#fnref:505" rev="footnote" title="Jump back to footnote 505 in the text">↩</a></p> </li> <li id="fn:506"> <p>Another thing <a class="footnote-backref" href="#fnref:506" rev="footnote" title="Jump back to footnote 506 in the text">↩</a></p> </li> <li id="fn:507"> <p>Another thing <a class="footnote-backref" href="#fnref:507" rev="footnote" title="Jump back to footnote 507 in the text">↩</a></p> </li> <li id="fn:508"> <p>Another thing <a class="footnote-backref" href="#fnref:508" rev="footnote" title="Jump back to footnote 508 in the text">↩</a></p> </li> <li id="fn:509"> <p>Another thing <a class="footnote-backref" href="#fnref:509" rev="footnote" title="Jump back to footnote 509 in the text">↩</a></p> </li> <li id="fn:510"> <p>Another thing <a class="footnote-backref" href="#fnref:510" rev="footnote" title="Jump back to footnote 510 in the text">↩</a></p> </li> <li id="fn:511"> <p>Another thing <a class="footnote-backref" href="#fnref:511" rev="footnote" title="Jump back to footnote 511 in the text">↩</a></p> </li> <li id="fn:512"> <p>Another thing <a class="footnote-backref" href="#fnref:512" rev="footnote" title="Jump back to footnote 512 in the text">↩</a></p> </li> <li id="fn:513"> <p>Another thing <a class="footnote-backref" href="#fnref:513" rev="footnote" title="Jump back to footnote 513 in the text">↩</a></p> </li> <li id="fn:514"> <p>Another thing <a class="footnote-backref" href="#fnref:514" rev="footnote" title="Jump back to footnote 514 in the text">↩</a></p> </li> <li id="fn:515"> <p>Another thing <a class="footnote-backref" href="#fnref:515" rev="footnote" title="Jump back to footnote 515 in the text">↩</a></p> </li> <li id="fn:516"> <p>Another thing <a class="footnote-backref" href="#fnref:516" rev="footnote" title="Jump back to footnote 516 in the text">↩</a></p> </li> <li id="fn:517"> <p>Another thing <a class="footnote-backref" href="#fnref:517" rev="footnote" title="Jump back to footnote 517 in the text">↩</a></p> </li> <li id="fn:518"> <p>Another thing <a class="footnote-backref" href="#fnref:518" rev="footnote" title="Jump back to footnote 518 in the text">↩</a></p> </li> <li id="fn:519"> <p>Another thing <a class="footnote-backref" href="#fnref:519" rev="footnote" title="Jump back to footnote 519 in the text">↩</a></p> </li> <li id="fn:520"> <p>Another thing <a class="footnote-backref" href="#fnref:520" rev="footnote" title="Jump back to footnote 520 in the text">↩</a></p> </li> <li id="fn:521"> <p>Another thing <a class="footnote-backref" href="#fnref:521" rev="footnote" title="Jump back to footnote 521 in the text">↩</a></p> </li> <li id="fn:522"> <p>Another thing <a class="footnote-backref" href="#fnref:522" rev="footnote" title="Jump back to footnote 522 in the text">↩</a></p> </li> <li id="fn:523"> <p>Another thing <a class="footnote-backref" href="#fnref:523" rev="footnote" title="Jump back to footnote 523 in the text">↩</a></p> </li> <li id="fn:524"> <p>Another thing <a class="footnote-backref" href="#fnref:524" rev="footnote" title="Jump back to footnote 524 in the text">↩</a></p> </li> <li id="fn:525"> <p>Another thing <a class="footnote-backref" href="#fnref:525" rev="footnote" title="Jump back to footnote 525 in the text">↩</a></p> </li> <li id="fn:526"> <p>Another thing <a class="footnote-backref" href="#fnref:526" rev="footnote" title="Jump back to footnote 526 in the text">↩</a></p> </li> <li id="fn:527"> <p>Another thing <a class="footnote-backref" href="#fnref:527" rev="footnote" title="Jump back to footnote 527 in the text">↩</a></p> </li> <li id="fn:528"> <p>Another thing <a class="footnote-backref" href="#fnref:528" rev="footnote" title="Jump back to footnote 528 in the text">↩</a></p> </li> <li id="fn:529"> <p>Another thing <a class="footnote-backref" href="#fnref:529" rev="footnote" title="Jump back to footnote 529 in the text">↩</a></p> </li> <li id="fn:530"> <p>Another thing <a class="footnote-backref" href="#fnref:530" rev="footnote" title="Jump back to footnote 530 in the text">↩</a></p> </li> <li id="fn:531"> <p>Another thing <a class="footnote-backref" href="#fnref:531" rev="footnote" title="Jump back to footnote 531 in the text">↩</a></p> </li> <li id="fn:532"> <p>Another thing <a class="footnote-backref" href="#fnref:532" rev="footnote" title="Jump back to footnote 532 in the text">↩</a></p> </li> <li id="fn:533"> <p>Another thing <a class="footnote-backref" href="#fnref:533" rev="footnote" title="Jump back to footnote 533 in the text">↩</a></p> </li> <li id="fn:534"> <p>Another thing <a class="footnote-backref" href="#fnref:534" rev="footnote" title="Jump back to footnote 534 in the text">↩</a></p> </li> <li id="fn:535"> <p>Another thing <a class="footnote-backref" href="#fnref:535" rev="footnote" title="Jump back to footnote 535 in the text">↩</a></p> </li> <li id="fn:536"> <p>Another thing <a class="footnote-backref" href="#fnref:536" rev="footnote" title="Jump back to footnote 536 in the text">↩</a></p> </li> <li id="fn:537"> <p>Another thing <a class="footnote-backref" href="#fnref:537" rev="footnote" title="Jump back to footnote 537 in the text">↩</a></p> </li> <li id="fn:538"> <p>Another thing <a class="footnote-backref" href="#fnref:538" rev="footnote" title="Jump back to footnote 538 in the text">↩</a></p> </li> <li id="fn:539"> <p>Another thing <a class="footnote-backref" href="#fnref:539" rev="footnote" title="Jump back to footnote 539 in the text">↩</a></p> </li> <li id="fn:540"> <p>Another thing <a class="footnote-backref" href="#fnref:540" rev="footnote" title="Jump back to footnote 540 in the text">↩</a></p> </li> <li id="fn:541"> <p>Another thing <a class="footnote-backref" href="#fnref:541" rev="footnote" title="Jump back to footnote 541 in the text">↩</a></p> </li> <li id="fn:542"> <p>Another thing <a class="footnote-backref" href="#fnref:542" rev="footnote" title="Jump back to footnote 542 in the text">↩</a></p> </li> <li id="fn:543"> <p>Another thing <a class="footnote-backref" href="#fnref:543" rev="footnote" title="Jump back to footnote 543 in the text">↩</a></p> </li> <li id="fn:544"> <p>Another thing <a class="footnote-backref" href="#fnref:544" rev="footnote" title="Jump back to footnote 544 in the text">↩</a></p> </li> <li id="fn:545"> <p>Another thing <a class="footnote-backref" href="#fnref:545" rev="footnote" title="Jump back to footnote 545 in the text">↩</a></p> </li> <li id="fn:546"> <p>Another thing <a class="footnote-backref" href="#fnref:546" rev="footnote" title="Jump back to footnote 546 in the text">↩</a></p> </li> <li id="fn:547"> <p>Another thing <a class="footnote-backref" href="#fnref:547" rev="footnote" title="Jump back to footnote 547 in the text">↩</a></p> </li> <li id="fn:548"> <p>Another thing <a class="footnote-backref" href="#fnref:548" rev="footnote" title="Jump back to footnote 548 in the text">↩</a></p> </li> <li id="fn:549"> <p>Another thing <a class="footnote-backref" href="#fnref:549" rev="footnote" title="Jump back to footnote 549 in the text">↩</a></p> </li> <li id="fn:550"> <p>Another thing <a class="footnote-backref" href="#fnref:550" rev="footnote" title="Jump back to footnote 550 in the text">↩</a></p> </li> <li id="fn:551"> <p>Another thing <a class="footnote-backref" href="#fnref:551" rev="footnote" title="Jump back to footnote 551 in the text">↩</a></p> </li> <li id="fn:552"> <p>Another thing <a class="footnote-backref" href="#fnref:552" rev="footnote" title="Jump back to footnote 552 in the text">↩</a></p> </li> <li id="fn:553"> <p>Another thing <a class="footnote-backref" href="#fnref:553" rev="footnote" title="Jump back to footnote 553 in the text">↩</a></p> </li> <li id="fn:554"> <p>Another thing <a class="footnote-backref" href="#fnref:554" rev="footnote" title="Jump back to footnote 554 in the text">↩</a></p> </li> <li id="fn:555"> <p>Another thing <a class="footnote-backref" href="#fnref:555" rev="footnote" title="Jump back to footnote 555 in the text">↩</a></p> </li> <li id="fn:556"> <p>Another thing <a class="footnote-backref" href="#fnref:556" rev="footnote" title="Jump back to footnote 556 in the text">↩</a></p> </li> <li id="fn:557"> <p>Another thing <a class="footnote-backref" href="#fnref:557" rev="footnote" title="Jump back to footnote 557 in the text">↩</a></p> </li> <li id="fn:558"> <p>Another thing <a class="footnote-backref" href="#fnref:558" rev="footnote" title="Jump back to footnote 558 in the text">↩</a></p> </li> <li id="fn:559"> <p>Another thing <a class="footnote-backref" href="#fnref:559" rev="footnote" title="Jump back to footnote 559 in the text">↩</a></p> </li> <li id="fn:560"> <p>Another thing <a class="footnote-backref" href="#fnref:560" rev="footnote" title="Jump back to footnote 560 in the text">↩</a></p> </li> <li id="fn:561"> <p>Another thing <a class="footnote-backref" href="#fnref:561" rev="footnote" title="Jump back to footnote 561 in the text">↩</a></p> </li> <li id="fn:562"> <p>Another thing <a class="footnote-backref" href="#fnref:562" rev="footnote" title="Jump back to footnote 562 in the text">↩</a></p> </li> <li id="fn:563"> <p>Another thing <a class="footnote-backref" href="#fnref:563" rev="footnote" title="Jump back to footnote 563 in the text">↩</a></p> </li> <li id="fn:564"> <p>Another thing <a class="footnote-backref" href="#fnref:564" rev="footnote" title="Jump back to footnote 564 in the text">↩</a></p> </li> <li id="fn:565"> <p>Another thing <a class="footnote-backref" href="#fnref:565" rev="footnote" title="Jump back to footnote 565 in the text">↩</a></p> </li> <li id="fn:566"> <p>Another thing <a class="footnote-backref" href="#fnref:566" rev="footnote" title="Jump back to footnote 566 in the text">↩</a></p> </li> <li id="fn:567"> <p>Another thing <a class="footnote-backref" href="#fnref:567" rev="footnote" title="Jump back to footnote 567 in the text">↩</a></p> </li> <li id="fn:568"> <p>Another thing <a class="footnote-backref" href="#fnref:568" rev="footnote" title="Jump back to footnote 568 in the text">↩</a></p> </li> <li id="fn:569"> <p>Another thing <a class="footnote-backref" href="#fnref:569" rev="footnote" title="Jump back to footnote 569 in the text">↩</a></p> </li> <li id="fn:570"> <p>Another thing <a class="footnote-backref" href="#fnref:570" rev="footnote" title="Jump back to footnote 570 in the text">↩</a></p> </li> <li id="fn:571"> <p>Another thing <a class="footnote-backref" href="#fnref:571" rev="footnote" title="Jump back to footnote 571 in the text">↩</a></p> </li> <li id="fn:572"> <p>Another thing <a class="footnote-backref" href="#fnref:572" rev="footnote" title="Jump back to footnote 572 in the text">↩</a></p> </li> <li id="fn:573"> <p>Another thing <a class="footnote-backref" href="#fnref:573" rev="footnote" title="Jump back to footnote 573 in the text">↩</a></p> </li> <li id="fn:574"> <p>Another thing <a class="footnote-backref" href="#fnref:574" rev="footnote" title="Jump back to footnote 574 in the text">↩</a></p> </li> <li id="fn:575"> <p>Another thing <a class="footnote-backref" href="#fnref:575" rev="footnote" title="Jump back to footnote 575 in the text">↩</a></p> </li> <li id="fn:576"> <p>Another thing <a class="footnote-backref" href="#fnref:576" rev="footnote" title="Jump back to footnote 576 in the text">↩</a></p> </li> <li id="fn:577"> <p>Another thing <a class="footnote-backref" href="#fnref:577" rev="footnote" title="Jump back to footnote 577 in the text">↩</a></p> </li> <li id="fn:578"> <p>Another thing <a class="footnote-backref" href="#fnref:578" rev="footnote" title="Jump back to footnote 578 in the text">↩</a></p> </li> <li id="fn:579"> <p>Another thing <a class="footnote-backref" href="#fnref:579" rev="footnote" title="Jump back to footnote 579 in the text">↩</a></p> </li> <li id="fn:580"> <p>Another thing <a class="footnote-backref" href="#fnref:580" rev="footnote" title="Jump back to footnote 580 in the text">↩</a></p> </li> <li id="fn:581"> <p>Another thing <a class="footnote-backref" href="#fnref:581" rev="footnote" title="Jump back to footnote 581 in the text">↩</a></p> </li> <li id="fn:582"> <p>Another thing <a class="footnote-backref" href="#fnref:582" rev="footnote" title="Jump back to footnote 582 in the text">↩</a></p> </li> <li id="fn:583"> <p>Another thing <a class="footnote-backref" href="#fnref:583" rev="footnote" title="Jump back to footnote 583 in the text">↩</a></p> </li> <li id="fn:584"> <p>Another thing <a class="footnote-backref" href="#fnref:584" rev="footnote" title="Jump back to footnote 584 in the text">↩</a></p> </li> <li id="fn:585"> <p>Another thing <a class="footnote-backref" href="#fnref:585" rev="footnote" title="Jump back to footnote 585 in the text">↩</a></p> </li> <li id="fn:586"> <p>Another thing <a class="footnote-backref" href="#fnref:586" rev="footnote" title="Jump back to footnote 586 in the text">↩</a></p> </li> <li id="fn:587"> <p>Another thing <a class="footnote-backref" href="#fnref:587" rev="footnote" title="Jump back to footnote 587 in the text">↩</a></p> </li> <li id="fn:588"> <p>Another thing <a class="footnote-backref" href="#fnref:588" rev="footnote" title="Jump back to footnote 588 in the text">↩</a></p> </li> <li id="fn:589"> <p>Another thing <a class="footnote-backref" href="#fnref:589" rev="footnote" title="Jump back to footnote 589 in the text">↩</a></p> </li> <li id="fn:590"> <p>Another thing <a class="footnote-backref" href="#fnref:590" rev="footnote" title="Jump back to footnote 590 in the text">↩</a></p> </li> <li id="fn:591"> <p>Another thing <a class="footnote-backref" href="#fnref:591" rev="footnote" title="Jump back to footnote 591 in the text">↩</a></p> </li> <li id="fn:592"> <p>Another thing <a class="footnote-backref" href="#fnref:592" rev="footnote" title="Jump back to footnote 592 in the text">↩</a></p> </li> <li id="fn:593"> <p>Another thing <a class="footnote-backref" href="#fnref:593" rev="footnote" title="Jump back to footnote 593 in the text">↩</a></p> </li> <li id="fn:594"> <p>Another thing <a class="footnote-backref" href="#fnref:594" rev="footnote" title="Jump back to footnote 594 in the text">↩</a></p> </li> <li id="fn:595"> <p>Another thing <a class="footnote-backref" href="#fnref:595" rev="footnote" title="Jump back to footnote 595 in the text">↩</a></p> </li> <li id="fn:596"> <p>Another thing <a class="footnote-backref" href="#fnref:596" rev="footnote" title="Jump back to footnote 596 in the text">↩</a></p> </li> <li id="fn:597"> <p>Another thing <a class="footnote-backref" href="#fnref:597" rev="footnote" title="Jump back to footnote 597 in the text">↩</a></p> </li> <li id="fn:598"> <p>Another thing <a class="footnote-backref" href="#fnref:598" rev="footnote" title="Jump back to footnote 598 in the text">↩</a></p> </li> <li id="fn:599"> <p>Another thing <a class="footnote-backref" href="#fnref:599" rev="footnote" title="Jump back to footnote 599 in the text">↩</a></p> </li> <li id="fn:600"> <p>Another thing <a class="footnote-backref" href="#fnref:600" rev="footnote" title="Jump back to footnote 600 in the text">↩</a></p> </li> <li id="fn:601"> <p>Another thing <a class="footnote-backref" href="#fnref:601" rev="footnote" title="Jump back to footnote 601 in the text">↩</a></p> </li> <li id="fn:602"> <p>Another thing <a class="footnote-backref" href="#fnref:602" rev="footnote" title="Jump back to footnote 602 in the text">↩</a></p> </li> <li id="fn:603"> <p>Another thing <a class="footnote-backref" href="#fnref:603" rev="footnote" title="Jump back to footnote 603 in the text">↩</a></p> </li> <li id="fn:604"> <p>Another thing <a class="footnote-backref" href="#fnref:604" rev="footnote" title="Jump back to footnote 604 in the text">↩</a></p> </li> <li id="fn:605"> <p>Another thing <a class="footnote-backref" href="#fnref:605" rev="footnote" title="Jump back to footnote 605 in the text">↩</a></p> </li> <li id="fn:606"> <p>Another thing <a class="footnote-backref" href="#fnref:606" rev="footnote" title="Jump back to footnote 606 in the text">↩</a></p> </li> <li id="fn:607"> <p>Another thing <a class="footnote-backref" href="#fnref:607" rev="footnote" title="Jump back to footnote 607 in the text">↩</a></p> </li> <li id="fn:608"> <p>Another thing <a class="footnote-backref" href="#fnref:608" rev="footnote" title="Jump back to footnote 608 in the text">↩</a></p> </li> <li id="fn:609"> <p>Another thing <a class="footnote-backref" href="#fnref:609" rev="footnote" title="Jump back to footnote 609 in the text">↩</a></p> </li> <li id="fn:610"> <p>Another thing <a class="footnote-backref" href="#fnref:610" rev="footnote" title="Jump back to footnote 610 in the text">↩</a></p> </li> <li id="fn:611"> <p>Another thing <a class="footnote-backref" href="#fnref:611" rev="footnote" title="Jump back to footnote 611 in the text">↩</a></p> </li> <li id="fn:612"> <p>Another thing <a class="footnote-backref" href="#fnref:612" rev="footnote" title="Jump back to footnote 612 in the text">↩</a></p> </li> <li id="fn:613"> <p>Another thing <a class="footnote-backref" href="#fnref:613" rev="footnote" title="Jump back to footnote 613 in the text">↩</a></p> </li> <li id="fn:614"> <p>Another thing <a class="footnote-backref" href="#fnref:614" rev="footnote" title="Jump back to footnote 614 in the text">↩</a></p> </li> <li id="fn:615"> <p>Another thing <a class="footnote-backref" href="#fnref:615" rev="footnote" title="Jump back to footnote 615 in the text">↩</a></p> </li> <li id="fn:616"> <p>Another thing <a class="footnote-backref" href="#fnref:616" rev="footnote" title="Jump back to footnote 616 in the text">↩</a></p> </li> <li id="fn:617"> <p>Another thing <a class="footnote-backref" href="#fnref:617" rev="footnote" title="Jump back to footnote 617 in the text">↩</a></p> </li> <li id="fn:618"> <p>Another thing <a class="footnote-backref" href="#fnref:618" rev="footnote" title="Jump back to footnote 618 in the text">↩</a></p> </li> <li id="fn:619"> <p>Another thing <a class="footnote-backref" href="#fnref:619" rev="footnote" title="Jump back to footnote 619 in the text">↩</a></p> </li> <li id="fn:620"> <p>Another thing <a class="footnote-backref" href="#fnref:620" rev="footnote" title="Jump back to footnote 620 in the text">↩</a></p> </li> <li id="fn:621"> <p>Another thing <a class="footnote-backref" href="#fnref:621" rev="footnote" title="Jump back to footnote 621 in the text">↩</a></p> </li> <li id="fn:622"> <p>Another thing <a class="footnote-backref" href="#fnref:622" rev="footnote" title="Jump back to footnote 622 in the text">↩</a></p> </li> <li id="fn:623"> <p>Another thing <a class="footnote-backref" href="#fnref:623" rev="footnote" title="Jump back to footnote 623 in the text">↩</a></p> </li> <li id="fn:624"> <p>Another thing <a class="footnote-backref" href="#fnref:624" rev="footnote" title="Jump back to footnote 624 in the text">↩</a></p> </li> <li id="fn:625"> <p>Another thing <a class="footnote-backref" href="#fnref:625" rev="footnote" title="Jump back to footnote 625 in the text">↩</a></p> </li> <li id="fn:626"> <p>Another thing <a class="footnote-backref" href="#fnref:626" rev="footnote" title="Jump back to footnote 626 in the text">↩</a></p> </li> <li id="fn:627"> <p>Another thing <a class="footnote-backref" href="#fnref:627" rev="footnote" title="Jump back to footnote 627 in the text">↩</a></p> </li> <li id="fn:628"> <p>Another thing <a class="footnote-backref" href="#fnref:628" rev="footnote" title="Jump back to footnote 628 in the text">↩</a></p> </li> <li id="fn:629"> <p>Another thing <a class="footnote-backref" href="#fnref:629" rev="footnote" title="Jump back to footnote 629 in the text">↩</a></p> </li> <li id="fn:630"> <p>Another thing <a class="footnote-backref" href="#fnref:630" rev="footnote" title="Jump back to footnote 630 in the text">↩</a></p> </li> <li id="fn:631"> <p>Another thing <a class="footnote-backref" href="#fnref:631" rev="footnote" title="Jump back to footnote 631 in the text">↩</a></p> </li> <li id="fn:632"> <p>Another thing <a class="footnote-backref" href="#fnref:632" rev="footnote" title="Jump back to footnote 632 in the text">↩</a></p> </li> <li id="fn:633"> <p>Another thing <a class="footnote-backref" href="#fnref:633" rev="footnote" title="Jump back to footnote 633 in the text">↩</a></p> </li> <li id="fn:634"> <p>Another thing <a class="footnote-backref" href="#fnref:634" rev="footnote" title="Jump back to footnote 634 in the text">↩</a></p> </li> <li id="fn:635"> <p>Another thing <a class="footnote-backref" href="#fnref:635" rev="footnote" title="Jump back to footnote 635 in the text">↩</a></p> </li> <li id="fn:636"> <p>Another thing <a class="footnote-backref" href="#fnref:636" rev="footnote" title="Jump back to footnote 636 in the text">↩</a></p> </li> <li id="fn:637"> <p>Another thing <a class="footnote-backref" href="#fnref:637" rev="footnote" title="Jump back to footnote 637 in the text">↩</a></p> </li> <li id="fn:638"> <p>Another thing <a class="footnote-backref" href="#fnref:638" rev="footnote" title="Jump back to footnote 638 in the text">↩</a></p> </li> <li id="fn:639"> <p>Another thing <a class="footnote-backref" href="#fnref:639" rev="footnote" title="Jump back to footnote 639 in the text">↩</a></p> </li> <li id="fn:640"> <p>Another thing <a class="footnote-backref" href="#fnref:640" rev="footnote" title="Jump back to footnote 640 in the text">↩</a></p> </li> <li id="fn:641"> <p>Another thing <a class="footnote-backref" href="#fnref:641" rev="footnote" title="Jump back to footnote 641 in the text">↩</a></p> </li> <li id="fn:642"> <p>Another thing <a class="footnote-backref" href="#fnref:642" rev="footnote" title="Jump back to footnote 642 in the text">↩</a></p> </li> <li id="fn:643"> <p>Another thing <a class="footnote-backref" href="#fnref:643" rev="footnote" title="Jump back to footnote 643 in the text">↩</a></p> </li> <li id="fn:644"> <p>Another thing <a class="footnote-backref" href="#fnref:644" rev="footnote" title="Jump back to footnote 644 in the text">↩</a></p> </li> <li id="fn:645"> <p>Another thing <a class="footnote-backref" href="#fnref:645" rev="footnote" title="Jump back to footnote 645 in the text">↩</a></p> </li> <li id="fn:646"> <p>Another thing <a class="footnote-backref" href="#fnref:646" rev="footnote" title="Jump back to footnote 646 in the text">↩</a></p> </li> <li id="fn:647"> <p>Another thing <a class="footnote-backref" href="#fnref:647" rev="footnote" title="Jump back to footnote 647 in the text">↩</a></p> </li> <li id="fn:648"> <p>Another thing <a class="footnote-backref" href="#fnref:648" rev="footnote" title="Jump back to footnote 648 in the text">↩</a></p> </li> <li id="fn:649"> <p>Another thing <a class="footnote-backref" href="#fnref:649" rev="footnote" title="Jump back to footnote 649 in the text">↩</a></p> </li> <li id="fn:650"> <p>Another thing <a class="footnote-backref" href="#fnref:650" rev="footnote" title="Jump back to footnote 650 in the text">↩</a></p> </li> <li id="fn:651"> <p>Another thing <a class="footnote-backref" href="#fnref:651" rev="footnote" title="Jump back to footnote 651 in the text">↩</a></p> </li> <li id="fn:652"> <p>Another thing <a class="footnote-backref" href="#fnref:652" rev="footnote" title="Jump back to footnote 652 in the text">↩</a></p> </li> <li id="fn:653"> <p>Another thing <a class="footnote-backref" href="#fnref:653" rev="footnote" title="Jump back to footnote 653 in the text">↩</a></p> </li> <li id="fn:654"> <p>Another thing <a class="footnote-backref" href="#fnref:654" rev="footnote" title="Jump back to footnote 654 in the text">↩</a></p> </li> <li id="fn:655"> <p>Another thing <a class="footnote-backref" href="#fnref:655" rev="footnote" title="Jump back to footnote 655 in the text">↩</a></p> </li> <li id="fn:656"> <p>Another thing <a class="footnote-backref" href="#fnref:656" rev="footnote" title="Jump back to footnote 656 in the text">↩</a></p> </li> <li id="fn:657"> <p>Another thing <a class="footnote-backref" href="#fnref:657" rev="footnote" title="Jump back to footnote 657 in the text">↩</a></p> </li> <li id="fn:658"> <p>Another thing <a class="footnote-backref" href="#fnref:658" rev="footnote" title="Jump back to footnote 658 in the text">↩</a></p> </li> <li id="fn:659"> <p>Another thing <a class="footnote-backref" href="#fnref:659" rev="footnote" title="Jump back to footnote 659 in the text">↩</a></p> </li> <li id="fn:660"> <p>Another thing <a class="footnote-backref" href="#fnref:660" rev="footnote" title="Jump back to footnote 660 in the text">↩</a></p> </li> <li id="fn:661"> <p>Another thing <a class="footnote-backref" href="#fnref:661" rev="footnote" title="Jump back to footnote 661 in the text">↩</a></p> </li> <li id="fn:662"> <p>Another thing <a class="footnote-backref" href="#fnref:662" rev="footnote" title="Jump back to footnote 662 in the text">↩</a></p> </li> <li id="fn:663"> <p>Another thing <a class="footnote-backref" href="#fnref:663" rev="footnote" title="Jump back to footnote 663 in the text">↩</a></p> </li> <li id="fn:664"> <p>Another thing <a class="footnote-backref" href="#fnref:664" rev="footnote" title="Jump back to footnote 664 in the text">↩</a></p> </li> <li id="fn:665"> <p>Another thing <a class="footnote-backref" href="#fnref:665" rev="footnote" title="Jump back to footnote 665 in the text">↩</a></p> </li> <li id="fn:666"> <p>Another thing <a class="footnote-backref" href="#fnref:666" rev="footnote" title="Jump back to footnote 666 in the text">↩</a></p> </li> <li id="fn:667"> <p>Another thing <a class="footnote-backref" href="#fnref:667" rev="footnote" title="Jump back to footnote 667 in the text">↩</a></p> </li> <li id="fn:668"> <p>Another thing <a class="footnote-backref" href="#fnref:668" rev="footnote" title="Jump back to footnote 668 in the text">↩</a></p> </li> <li id="fn:669"> <p>Another thing <a class="footnote-backref" href="#fnref:669" rev="footnote" title="Jump back to footnote 669 in the text">↩</a></p> </li> <li id="fn:670"> <p>Another thing <a class="footnote-backref" href="#fnref:670" rev="footnote" title="Jump back to footnote 670 in the text">↩</a></p> </li> <li id="fn:671"> <p>Another thing <a class="footnote-backref" href="#fnref:671" rev="footnote" title="Jump back to footnote 671 in the text">↩</a></p> </li> <li id="fn:672"> <p>Another thing <a class="footnote-backref" href="#fnref:672" rev="footnote" title="Jump back to footnote 672 in the text">↩</a></p> </li> <li id="fn:673"> <p>Another thing <a class="footnote-backref" href="#fnref:673" rev="footnote" title="Jump back to footnote 673 in the text">↩</a></p> </li> <li id="fn:674"> <p>Another thing <a class="footnote-backref" href="#fnref:674" rev="footnote" title="Jump back to footnote 674 in the text">↩</a></p> </li> <li id="fn:675"> <p>Another thing <a class="footnote-backref" href="#fnref:675" rev="footnote" title="Jump back to footnote 675 in the text">↩</a></p> </li> <li id="fn:676"> <p>Another thing <a class="footnote-backref" href="#fnref:676" rev="footnote" title="Jump back to footnote 676 in the text">↩</a></p> </li> <li id="fn:677"> <p>Another thing <a class="footnote-backref" href="#fnref:677" rev="footnote" title="Jump back to footnote 677 in the text">↩</a></p> </li> <li id="fn:678"> <p>Another thing <a class="footnote-backref" href="#fnref:678" rev="footnote" title="Jump back to footnote 678 in the text">↩</a></p> </li> <li id="fn:679"> <p>Another thing <a class="footnote-backref" href="#fnref:679" rev="footnote" title="Jump back to footnote 679 in the text">↩</a></p> </li> <li id="fn:680"> <p>Another thing <a class="footnote-backref" href="#fnref:680" rev="footnote" title="Jump back to footnote 680 in the text">↩</a></p> </li> <li id="fn:681"> <p>Another thing <a class="footnote-backref" href="#fnref:681" rev="footnote" title="Jump back to footnote 681 in the text">↩</a></p> </li> <li id="fn:682"> <p>Another thing <a class="footnote-backref" href="#fnref:682" rev="footnote" title="Jump back to footnote 682 in the text">↩</a></p> </li> <li id="fn:683"> <p>Another thing <a class="footnote-backref" href="#fnref:683" rev="footnote" title="Jump back to footnote 683 in the text">↩</a></p> </li> <li id="fn:684"> <p>Another thing <a class="footnote-backref" href="#fnref:684" rev="footnote" title="Jump back to footnote 684 in the text">↩</a></p> </li> <li id="fn:685"> <p>Another thing <a class="footnote-backref" href="#fnref:685" rev="footnote" title="Jump back to footnote 685 in the text">↩</a></p> </li> <li id="fn:686"> <p>Another thing <a class="footnote-backref" href="#fnref:686" rev="footnote" title="Jump back to footnote 686 in the text">↩</a></p> </li> <li id="fn:687"> <p>Another thing <a class="footnote-backref" href="#fnref:687" rev="footnote" title="Jump back to footnote 687 in the text">↩</a></p> </li> <li id="fn:688"> <p>Another thing <a class="footnote-backref" href="#fnref:688" rev="footnote" title="Jump back to footnote 688 in the text">↩</a></p> </li> <li id="fn:689"> <p>Another thing <a class="footnote-backref" href="#fnref:689" rev="footnote" title="Jump back to footnote 689 in the text">↩</a></p> </li> <li id="fn:690"> <p>Another thing <a class="footnote-backref" href="#fnref:690" rev="footnote" title="Jump back to footnote 690 in the text">↩</a></p> </li> <li id="fn:691"> <p>Another thing <a class="footnote-backref" href="#fnref:691" rev="footnote" title="Jump back to footnote 691 in the text">↩</a></p> </li> <li id="fn:692"> <p>Another thing <a class="footnote-backref" href="#fnref:692" rev="footnote" title="Jump back to footnote 692 in the text">↩</a></p> </li> <li id="fn:693"> <p>Another thing <a class="footnote-backref" href="#fnref:693" rev="footnote" title="Jump back to footnote 693 in the text">↩</a></p> </li> <li id="fn:694"> <p>Another thing <a class="footnote-backref" href="#fnref:694" rev="footnote" title="Jump back to footnote 694 in the text">↩</a></p> </li> <li id="fn:695"> <p>Another thing <a class="footnote-backref" href="#fnref:695" rev="footnote" title="Jump back to footnote 695 in the text">↩</a></p> </li> <li id="fn:696"> <p>Another thing <a class="footnote-backref" href="#fnref:696" rev="footnote" title="Jump back to footnote 696 in the text">↩</a></p> </li> <li id="fn:697"> <p>Another thing <a class="footnote-backref" href="#fnref:697" rev="footnote" title="Jump back to footnote 697 in the text">↩</a></p> </li> <li id="fn:698"> <p>Another thing <a class="footnote-backref" href="#fnref:698" rev="footnote" title="Jump back to footnote 698 in the text">↩</a></p> </li> <li id="fn:699"> <p>Another thing <a class="footnote-backref" href="#fnref:699" rev="footnote" title="Jump back to footnote 699 in the text">↩</a></p> </li> <li id="fn:700"> <p>Another thing <a class="footnote-backref" href="#fnref:700" rev="footnote" title="Jump back to footnote 700 in the text">↩</a></p> </li> <li id="fn:701"> <p>Another thing <a class="footnote-backref" href="#fnref:701" rev="footnote" title="Jump back to footnote 701 in the text">↩</a></p> </li> <li id="fn:702"> <p>Another thing <a class="footnote-backref" href="#fnref:702" rev="footnote" title="Jump back to footnote 702 in the text">↩</a></p> </li> <li id="fn:703"> <p>Another thing <a class="footnote-backref" href="#fnref:703" rev="footnote" title="Jump back to footnote 703 in the text">↩</a></p> </li> <li id="fn:704"> <p>Another thing <a class="footnote-backref" href="#fnref:704" rev="footnote" title="Jump back to footnote 704 in the text">↩</a></p> </li> <li id="fn:705"> <p>Another thing <a class="footnote-backref" href="#fnref:705" rev="footnote" title="Jump back to footnote 705 in the text">↩</a></p> </li> <li id="fn:706"> <p>Another thing <a class="footnote-backref" href="#fnref:706" rev="footnote" title="Jump back to footnote 706 in the text">↩</a></p> </li> <li id="fn:707"> <p>Another thing <a class="footnote-backref" href="#fnref:707" rev="footnote" title="Jump back to footnote 707 in the text">↩</a></p> </li> <li id="fn:708"> <p>Another thing <a class="footnote-backref" href="#fnref:708" rev="footnote" title="Jump back to footnote 708 in the text">↩</a></p> </li> <li id="fn:709"> <p>Another thing <a class="footnote-backref" href="#fnref:709" rev="footnote" title="Jump back to footnote 709 in the text">↩</a></p> </li> <li id="fn:710"> <p>Another thing <a class="footnote-backref" href="#fnref:710" rev="footnote" title="Jump back to footnote 710 in the text">↩</a></p> </li> <li id="fn:711"> <p>Another thing <a class="footnote-backref" href="#fnref:711" rev="footnote" title="Jump back to footnote 711 in the text">↩</a></p> </li> <li id="fn:712"> <p>Another thing <a class="footnote-backref" href="#fnref:712" rev="footnote" title="Jump back to footnote 712 in the text">↩</a></p> </li> <li id="fn:713"> <p>Another thing <a class="footnote-backref" href="#fnref:713" rev="footnote" title="Jump back to footnote 713 in the text">↩</a></p> </li> <li id="fn:714"> <p>Another thing <a class="footnote-backref" href="#fnref:714" rev="footnote" title="Jump back to footnote 714 in the text">↩</a></p> </li> <li id="fn:715"> <p>Another thing <a class="footnote-backref" href="#fnref:715" rev="footnote" title="Jump back to footnote 715 in the text">↩</a></p> </li> <li id="fn:716"> <p>Another thing <a class="footnote-backref" href="#fnref:716" rev="footnote" title="Jump back to footnote 716 in the text">↩</a></p> </li> <li id="fn:717"> <p>Another thing <a class="footnote-backref" href="#fnref:717" rev="footnote" title="Jump back to footnote 717 in the text">↩</a></p> </li> <li id="fn:718"> <p>Another thing <a class="footnote-backref" href="#fnref:718" rev="footnote" title="Jump back to footnote 718 in the text">↩</a></p> </li> <li id="fn:719"> <p>Another thing <a class="footnote-backref" href="#fnref:719" rev="footnote" title="Jump back to footnote 719 in the text">↩</a></p> </li> <li id="fn:720"> <p>Another thing <a class="footnote-backref" href="#fnref:720" rev="footnote" title="Jump back to footnote 720 in the text">↩</a></p> </li> <li id="fn:721"> <p>Another thing <a class="footnote-backref" href="#fnref:721" rev="footnote" title="Jump back to footnote 721 in the text">↩</a></p> </li> <li id="fn:722"> <p>Another thing <a class="footnote-backref" href="#fnref:722" rev="footnote" title="Jump back to footnote 722 in the text">↩</a></p> </li> <li id="fn:723"> <p>Another thing <a class="footnote-backref" href="#fnref:723" rev="footnote" title="Jump back to footnote 723 in the text">↩</a></p> </li> <li id="fn:724"> <p>Another thing <a class="footnote-backref" href="#fnref:724" rev="footnote" title="Jump back to footnote 724 in the text">↩</a></p> </li> <li id="fn:725"> <p>Another thing <a class="footnote-backref" href="#fnref:725" rev="footnote" title="Jump back to footnote 725 in the text">↩</a></p> </li> <li id="fn:726"> <p>Another thing <a class="footnote-backref" href="#fnref:726" rev="footnote" title="Jump back to footnote 726 in the text">↩</a></p> </li> <li id="fn:727"> <p>Another thing <a class="footnote-backref" href="#fnref:727" rev="footnote" title="Jump back to footnote 727 in the text">↩</a></p> </li> <li id="fn:728"> <p>Another thing <a class="footnote-backref" href="#fnref:728" rev="footnote" title="Jump back to footnote 728 in the text">↩</a></p> </li> <li id="fn:729"> <p>Another thing <a class="footnote-backref" href="#fnref:729" rev="footnote" title="Jump back to footnote 729 in the text">↩</a></p> </li> <li id="fn:730"> <p>Another thing <a class="footnote-backref" href="#fnref:730" rev="footnote" title="Jump back to footnote 730 in the text">↩</a></p> </li> <li id="fn:731"> <p>Another thing <a class="footnote-backref" href="#fnref:731" rev="footnote" title="Jump back to footnote 731 in the text">↩</a></p> </li> <li id="fn:732"> <p>Another thing <a class="footnote-backref" href="#fnref:732" rev="footnote" title="Jump back to footnote 732 in the text">↩</a></p> </li> <li id="fn:733"> <p>Another thing <a class="footnote-backref" href="#fnref:733" rev="footnote" title="Jump back to footnote 733 in the text">↩</a></p> </li> <li id="fn:734"> <p>Another thing <a class="footnote-backref" href="#fnref:734" rev="footnote" title="Jump back to footnote 734 in the text">↩</a></p> </li> <li id="fn:735"> <p>Another thing <a class="footnote-backref" href="#fnref:735" rev="footnote" title="Jump back to footnote 735 in the text">↩</a></p> </li> <li id="fn:736"> <p>Another thing <a class="footnote-backref" href="#fnref:736" rev="footnote" title="Jump back to footnote 736 in the text">↩</a></p> </li> <li id="fn:737"> <p>Another thing <a class="footnote-backref" href="#fnref:737" rev="footnote" title="Jump back to footnote 737 in the text">↩</a></p> </li> <li id="fn:738"> <p>Another thing <a class="footnote-backref" href="#fnref:738" rev="footnote" title="Jump back to footnote 738 in the text">↩</a></p> </li> <li id="fn:739"> <p>Another thing <a class="footnote-backref" href="#fnref:739" rev="footnote" title="Jump back to footnote 739 in the text">↩</a></p> </li> <li id="fn:740"> <p>Another thing <a class="footnote-backref" href="#fnref:740" rev="footnote" title="Jump back to footnote 740 in the text">↩</a></p> </li> <li id="fn:741"> <p>Another thing <a class="footnote-backref" href="#fnref:741" rev="footnote" title="Jump back to footnote 741 in the text">↩</a></p> </li> <li id="fn:742"> <p>Another thing <a class="footnote-backref" href="#fnref:742" rev="footnote" title="Jump back to footnote 742 in the text">↩</a></p> </li> <li id="fn:743"> <p>Another thing <a class="footnote-backref" href="#fnref:743" rev="footnote" title="Jump back to footnote 743 in the text">↩</a></p> </li> <li id="fn:744"> <p>Another thing <a class="footnote-backref" href="#fnref:744" rev="footnote" title="Jump back to footnote 744 in the text">↩</a></p> </li> <li id="fn:745"> <p>Another thing <a class="footnote-backref" href="#fnref:745" rev="footnote" title="Jump back to footnote 745 in the text">↩</a></p> </li> <li id="fn:746"> <p>Another thing <a class="footnote-backref" href="#fnref:746" rev="footnote" title="Jump back to footnote 746 in the text">↩</a></p> </li> <li id="fn:747"> <p>Another thing <a class="footnote-backref" href="#fnref:747" rev="footnote" title="Jump back to footnote 747 in the text">↩</a></p> </li> <li id="fn:748"> <p>Another thing <a class="footnote-backref" href="#fnref:748" rev="footnote" title="Jump back to footnote 748 in the text">↩</a></p> </li> <li id="fn:749"> <p>Another thing <a class="footnote-backref" href="#fnref:749" rev="footnote" title="Jump back to footnote 749 in the text">↩</a></p> </li> <li id="fn:750"> <p>Another thing <a class="footnote-backref" href="#fnref:750" rev="footnote" title="Jump back to footnote 750 in the text">↩</a></p> </li> <li id="fn:751"> <p>Another thing <a class="footnote-backref" href="#fnref:751" rev="footnote" title="Jump back to footnote 751 in the text">↩</a></p> </li> <li id="fn:752"> <p>Another thing <a class="footnote-backref" href="#fnref:752" rev="footnote" title="Jump back to footnote 752 in the text">↩</a></p> </li> <li id="fn:753"> <p>Another thing <a class="footnote-backref" href="#fnref:753" rev="footnote" title="Jump back to footnote 753 in the text">↩</a></p> </li> <li id="fn:754"> <p>Another thing <a class="footnote-backref" href="#fnref:754" rev="footnote" title="Jump back to footnote 754 in the text">↩</a></p> </li> <li id="fn:755"> <p>Another thing <a class="footnote-backref" href="#fnref:755" rev="footnote" title="Jump back to footnote 755 in the text">↩</a></p> </li> <li id="fn:756"> <p>Another thing <a class="footnote-backref" href="#fnref:756" rev="footnote" title="Jump back to footnote 756 in the text">↩</a></p> </li> <li id="fn:757"> <p>Another thing <a class="footnote-backref" href="#fnref:757" rev="footnote" title="Jump back to footnote 757 in the text">↩</a></p> </li> <li id="fn:758"> <p>Another thing <a class="footnote-backref" href="#fnref:758" rev="footnote" title="Jump back to footnote 758 in the text">↩</a></p> </li> <li id="fn:759"> <p>Another thing <a class="footnote-backref" href="#fnref:759" rev="footnote" title="Jump back to footnote 759 in the text">↩</a></p> </li> <li id="fn:760"> <p>Another thing <a class="footnote-backref" href="#fnref:760" rev="footnote" title="Jump back to footnote 760 in the text">↩</a></p> </li> <li id="fn:761"> <p>Another thing <a class="footnote-backref" href="#fnref:761" rev="footnote" title="Jump back to footnote 761 in the text">↩</a></p> </li> <li id="fn:762"> <p>Another thing <a class="footnote-backref" href="#fnref:762" rev="footnote" title="Jump back to footnote 762 in the text">↩</a></p> </li> <li id="fn:763"> <p>Another thing <a class="footnote-backref" href="#fnref:763" rev="footnote" title="Jump back to footnote 763 in the text">↩</a></p> </li> <li id="fn:764"> <p>Another thing <a class="footnote-backref" href="#fnref:764" rev="footnote" title="Jump back to footnote 764 in the text">↩</a></p> </li> <li id="fn:765"> <p>Another thing <a class="footnote-backref" href="#fnref:765" rev="footnote" title="Jump back to footnote 765 in the text">↩</a></p> </li> <li id="fn:766"> <p>Another thing <a class="footnote-backref" href="#fnref:766" rev="footnote" title="Jump back to footnote 766 in the text">↩</a></p> </li> <li id="fn:767"> <p>Another thing <a class="footnote-backref" href="#fnref:767" rev="footnote" title="Jump back to footnote 767 in the text">↩</a></p> </li> <li id="fn:768"> <p>Another thing <a class="footnote-backref" href="#fnref:768" rev="footnote" title="Jump back to footnote 768 in the text">↩</a></p> </li> <li id="fn:769"> <p>Another thing <a class="footnote-backref" href="#fnref:769" rev="footnote" title="Jump back to footnote 769 in the text">↩</a></p> </li> <li id="fn:770"> <p>Another thing <a class="footnote-backref" href="#fnref:770" rev="footnote" title="Jump back to footnote 770 in the text">↩</a></p> </li> <li id="fn:771"> <p>Another thing <a class="footnote-backref" href="#fnref:771" rev="footnote" title="Jump back to footnote 771 in the text">↩</a></p> </li> <li id="fn:772"> <p>Another thing <a class="footnote-backref" href="#fnref:772" rev="footnote" title="Jump back to footnote 772 in the text">↩</a></p> </li> <li id="fn:773"> <p>Another thing <a class="footnote-backref" href="#fnref:773" rev="footnote" title="Jump back to footnote 773 in the text">↩</a></p> </li> <li id="fn:774"> <p>Another thing <a class="footnote-backref" href="#fnref:774" rev="footnote" title="Jump back to footnote 774 in the text">↩</a></p> </li> <li id="fn:775"> <p>Another thing <a class="footnote-backref" href="#fnref:775" rev="footnote" title="Jump back to footnote 775 in the text">↩</a></p> </li> <li id="fn:776"> <p>Another thing <a class="footnote-backref" href="#fnref:776" rev="footnote" title="Jump back to footnote 776 in the text">↩</a></p> </li> <li id="fn:777"> <p>Another thing <a class="footnote-backref" href="#fnref:777" rev="footnote" title="Jump back to footnote 777 in the text">↩</a></p> </li> <li id="fn:778"> <p>Another thing <a class="footnote-backref" href="#fnref:778" rev="footnote" title="Jump back to footnote 778 in the text">↩</a></p> </li> <li id="fn:779"> <p>Another thing <a class="footnote-backref" href="#fnref:779" rev="footnote" title="Jump back to footnote 779 in the text">↩</a></p> </li> <li id="fn:780"> <p>Another thing <a class="footnote-backref" href="#fnref:780" rev="footnote" title="Jump back to footnote 780 in the text">↩</a></p> </li> <li id="fn:781"> <p>Another thing <a class="footnote-backref" href="#fnref:781" rev="footnote" title="Jump back to footnote 781 in the text">↩</a></p> </li> <li id="fn:782"> <p>Another thing <a class="footnote-backref" href="#fnref:782" rev="footnote" title="Jump back to footnote 782 in the text">↩</a></p> </li> <li id="fn:783"> <p>Another thing <a class="footnote-backref" href="#fnref:783" rev="footnote" title="Jump back to footnote 783 in the text">↩</a></p> </li> <li id="fn:784"> <p>Another thing <a class="footnote-backref" href="#fnref:784" rev="footnote" title="Jump back to footnote 784 in the text">↩</a></p> </li> <li id="fn:785"> <p>Another thing <a class="footnote-backref" href="#fnref:785" rev="footnote" title="Jump back to footnote 785 in the text">↩</a></p> </li> <li id="fn:786"> <p>Another thing <a class="footnote-backref" href="#fnref:786" rev="footnote" title="Jump back to footnote 786 in the text">↩</a></p> </li> <li id="fn:787"> <p>Another thing <a class="footnote-backref" href="#fnref:787" rev="footnote" title="Jump back to footnote 787 in the text">↩</a></p> </li> <li id="fn:788"> <p>Another thing <a class="footnote-backref" href="#fnref:788" rev="footnote" title="Jump back to footnote 788 in the text">↩</a></p> </li> <li id="fn:789"> <p>Another thing <a class="footnote-backref" href="#fnref:789" rev="footnote" title="Jump back to footnote 789 in the text">↩</a></p> </li> <li id="fn:790"> <p>Another thing <a class="footnote-backref" href="#fnref:790" rev="footnote" title="Jump back to footnote 790 in the text">↩</a></p> </li> <li id="fn:791"> <p>Another thing <a class="footnote-backref" href="#fnref:791" rev="footnote" title="Jump back to footnote 791 in the text">↩</a></p> </li> <li id="fn:792"> <p>Another thing <a class="footnote-backref" href="#fnref:792" rev="footnote" title="Jump back to footnote 792 in the text">↩</a></p> </li> <li id="fn:793"> <p>Another thing <a class="footnote-backref" href="#fnref:793" rev="footnote" title="Jump back to footnote 793 in the text">↩</a></p> </li> <li id="fn:794"> <p>Another thing <a class="footnote-backref" href="#fnref:794" rev="footnote" title="Jump back to footnote 794 in the text">↩</a></p> </li> <li id="fn:795"> <p>Another thing <a class="footnote-backref" href="#fnref:795" rev="footnote" title="Jump back to footnote 795 in the text">↩</a></p> </li> <li id="fn:796"> <p>Another thing <a class="footnote-backref" href="#fnref:796" rev="footnote" title="Jump back to footnote 796 in the text">↩</a></p> </li> <li id="fn:797"> <p>Another thing <a class="footnote-backref" href="#fnref:797" rev="footnote" title="Jump back to footnote 797 in the text">↩</a></p> </li> <li id="fn:798"> <p>Another thing <a class="footnote-backref" href="#fnref:798" rev="footnote" title="Jump back to footnote 798 in the text">↩</a></p> </li> <li id="fn:799"> <p>Another thing <a class="footnote-backref" href="#fnref:799" rev="footnote" title="Jump back to footnote 799 in the text">↩</a></p> </li> <li id="fn:800"> <p>Another thing <a class="footnote-backref" href="#fnref:800" rev="footnote" title="Jump back to footnote 800 in the text">↩</a></p> </li> <li id="fn:801"> <p>Another thing <a class="footnote-backref" href="#fnref:801" rev="footnote" title="Jump back to footnote 801 in the text">↩</a></p> </li> <li id="fn:802"> <p>Another thing <a class="footnote-backref" href="#fnref:802" rev="footnote" title="Jump back to footnote 802 in the text">↩</a></p> </li> <li id="fn:803"> <p>Another thing <a class="footnote-backref" href="#fnref:803" rev="footnote" title="Jump back to footnote 803 in the text">↩</a></p> </li> <li id="fn:804"> <p>Another thing <a class="footnote-backref" href="#fnref:804" rev="footnote" title="Jump back to footnote 804 in the text">↩</a></p> </li> <li id="fn:805"> <p>Another thing <a class="footnote-backref" href="#fnref:805" rev="footnote" title="Jump back to footnote 805 in the text">↩</a></p> </li> <li id="fn:806"> <p>Another thing <a class="footnote-backref" href="#fnref:806" rev="footnote" title="Jump back to footnote 806 in the text">↩</a></p> </li> <li id="fn:807"> <p>Another thing <a class="footnote-backref" href="#fnref:807" rev="footnote" title="Jump back to footnote 807 in the text">↩</a></p> </li> <li id="fn:808"> <p>Another thing <a class="footnote-backref" href="#fnref:808" rev="footnote" title="Jump back to footnote 808 in the text">↩</a></p> </li> <li id="fn:809"> <p>Another thing <a class="footnote-backref" href="#fnref:809" rev="footnote" title="Jump back to footnote 809 in the text">↩</a></p> </li> <li id="fn:810"> <p>Another thing <a class="footnote-backref" href="#fnref:810" rev="footnote" title="Jump back to footnote 810 in the text">↩</a></p> </li> <li id="fn:811"> <p>Another thing <a class="footnote-backref" href="#fnref:811" rev="footnote" title="Jump back to footnote 811 in the text">↩</a></p> </li> <li id="fn:812"> <p>Another thing <a class="footnote-backref" href="#fnref:812" rev="footnote" title="Jump back to footnote 812 in the text">↩</a></p> </li> <li id="fn:813"> <p>Another thing <a class="footnote-backref" href="#fnref:813" rev="footnote" title="Jump back to footnote 813 in the text">↩</a></p> </li> <li id="fn:814"> <p>Another thing <a class="footnote-backref" href="#fnref:814" rev="footnote" title="Jump back to footnote 814 in the text">↩</a></p> </li> <li id="fn:815"> <p>Another thing <a class="footnote-backref" href="#fnref:815" rev="footnote" title="Jump back to footnote 815 in the text">↩</a></p> </li> <li id="fn:816"> <p>Another thing <a class="footnote-backref" href="#fnref:816" rev="footnote" title="Jump back to footnote 816 in the text">↩</a></p> </li> <li id="fn:817"> <p>Another thing <a class="footnote-backref" href="#fnref:817" rev="footnote" title="Jump back to footnote 817 in the text">↩</a></p> </li> <li id="fn:818"> <p>Another thing <a class="footnote-backref" href="#fnref:818" rev="footnote" title="Jump back to footnote 818 in the text">↩</a></p> </li> <li id="fn:819"> <p>Another thing <a class="footnote-backref" href="#fnref:819" rev="footnote" title="Jump back to footnote 819 in the text">↩</a></p> </li> <li id="fn:820"> <p>Another thing <a class="footnote-backref" href="#fnref:820" rev="footnote" title="Jump back to footnote 820 in the text">↩</a></p> </li> <li id="fn:821"> <p>Another thing <a class="footnote-backref" href="#fnref:821" rev="footnote" title="Jump back to footnote 821 in the text">↩</a></p> </li> <li id="fn:822"> <p>Another thing <a class="footnote-backref" href="#fnref:822" rev="footnote" title="Jump back to footnote 822 in the text">↩</a></p> </li> <li id="fn:823"> <p>Another thing <a class="footnote-backref" href="#fnref:823" rev="footnote" title="Jump back to footnote 823 in the text">↩</a></p> </li> <li id="fn:824"> <p>Another thing <a class="footnote-backref" href="#fnref:824" rev="footnote" title="Jump back to footnote 824 in the text">↩</a></p> </li> <li id="fn:825"> <p>Another thing <a class="footnote-backref" href="#fnref:825" rev="footnote" title="Jump back to footnote 825 in the text">↩</a></p> </li> <li id="fn:826"> <p>Another thing <a class="footnote-backref" href="#fnref:826" rev="footnote" title="Jump back to footnote 826 in the text">↩</a></p> </li> <li id="fn:827"> <p>Another thing <a class="footnote-backref" href="#fnref:827" rev="footnote" title="Jump back to footnote 827 in the text">↩</a></p> </li> <li id="fn:828"> <p>Another thing <a class="footnote-backref" href="#fnref:828" rev="footnote" title="Jump back to footnote 828 in the text">↩</a></p> </li> <li id="fn:829"> <p>Another thing <a class="footnote-backref" href="#fnref:829" rev="footnote" title="Jump back to footnote 829 in the text">↩</a></p> </li> <li id="fn:830"> <p>Another thing <a class="footnote-backref" href="#fnref:830" rev="footnote" title="Jump back to footnote 830 in the text">↩</a></p> </li> <li id="fn:831"> <p>Another thing <a class="footnote-backref" href="#fnref:831" rev="footnote" title="Jump back to footnote 831 in the text">↩</a></p> </li> <li id="fn:832"> <p>Another thing <a class="footnote-backref" href="#fnref:832" rev="footnote" title="Jump back to footnote 832 in the text">↩</a></p> </li> <li id="fn:833"> <p>Another thing <a class="footnote-backref" href="#fnref:833" rev="footnote" title="Jump back to footnote 833 in the text">↩</a></p> </li> <li id="fn:834"> <p>Another thing <a class="footnote-backref" href="#fnref:834" rev="footnote" title="Jump back to footnote 834 in the text">↩</a></p> </li> <li id="fn:835"> <p>Another thing <a class="footnote-backref" href="#fnref:835" rev="footnote" title="Jump back to footnote 835 in the text">↩</a></p> </li> <li id="fn:836"> <p>Another thing <a class="footnote-backref" href="#fnref:836" rev="footnote" title="Jump back to footnote 836 in the text">↩</a></p> </li> <li id="fn:837"> <p>Another thing <a class="footnote-backref" href="#fnref:837" rev="footnote" title="Jump back to footnote 837 in the text">↩</a></p> </li> <li id="fn:838"> <p>Another thing <a class="footnote-backref" href="#fnref:838" rev="footnote" title="Jump back to footnote 838 in the text">↩</a></p> </li> <li id="fn:839"> <p>Another thing <a class="footnote-backref" href="#fnref:839" rev="footnote" title="Jump back to footnote 839 in the text">↩</a></p> </li> <li id="fn:840"> <p>Another thing <a class="footnote-backref" href="#fnref:840" rev="footnote" title="Jump back to footnote 840 in the text">↩</a></p> </li> <li id="fn:841"> <p>Another thing <a class="footnote-backref" href="#fnref:841" rev="footnote" title="Jump back to footnote 841 in the text">↩</a></p> </li> <li id="fn:842"> <p>Another thing <a class="footnote-backref" href="#fnref:842" rev="footnote" title="Jump back to footnote 842 in the text">↩</a></p> </li> <li id="fn:843"> <p>Another thing <a class="footnote-backref" href="#fnref:843" rev="footnote" title="Jump back to footnote 843 in the text">↩</a></p> </li> <li id="fn:844"> <p>Another thing <a class="footnote-backref" href="#fnref:844" rev="footnote" title="Jump back to footnote 844 in the text">↩</a></p> </li> <li id="fn:845"> <p>Another thing <a class="footnote-backref" href="#fnref:845" rev="footnote" title="Jump back to footnote 845 in the text">↩</a></p> </li> <li id="fn:846"> <p>Another thing <a class="footnote-backref" href="#fnref:846" rev="footnote" title="Jump back to footnote 846 in the text">↩</a></p> </li> <li id="fn:847"> <p>Another thing <a class="footnote-backref" href="#fnref:847" rev="footnote" title="Jump back to footnote 847 in the text">↩</a></p> </li> <li id="fn:848"> <p>Another thing <a class="footnote-backref" href="#fnref:848" rev="footnote" title="Jump back to footnote 848 in the text">↩</a></p> </li> <li id="fn:849"> <p>Another thing <a class="footnote-backref" href="#fnref:849" rev="footnote" title="Jump back to footnote 849 in the text">↩</a></p> </li> <li id="fn:850"> <p>Another thing <a class="footnote-backref" href="#fnref:850" rev="footnote" title="Jump back to footnote 850 in the text">↩</a></p> </li> <li id="fn:851"> <p>Another thing <a class="footnote-backref" href="#fnref:851" rev="footnote" title="Jump back to footnote 851 in the text">↩</a></p> </li> <li id="fn:852"> <p>Another thing <a class="footnote-backref" href="#fnref:852" rev="footnote" title="Jump back to footnote 852 in the text">↩</a></p> </li> <li id="fn:853"> <p>Another thing <a class="footnote-backref" href="#fnref:853" rev="footnote" title="Jump back to footnote 853 in the text">↩</a></p> </li> <li id="fn:854"> <p>Another thing <a class="footnote-backref" href="#fnref:854" rev="footnote" title="Jump back to footnote 854 in the text">↩</a></p> </li> <li id="fn:855"> <p>Another thing <a class="footnote-backref" href="#fnref:855" rev="footnote" title="Jump back to footnote 855 in the text">↩</a></p> </li> <li id="fn:856"> <p>Another thing <a class="footnote-backref" href="#fnref:856" rev="footnote" title="Jump back to footnote 856 in the text">↩</a></p> </li> <li id="fn:857"> <p>Another thing <a class="footnote-backref" href="#fnref:857" rev="footnote" title="Jump back to footnote 857 in the text">↩</a></p> </li> <li id="fn:858"> <p>Another thing <a class="footnote-backref" href="#fnref:858" rev="footnote" title="Jump back to footnote 858 in the text">↩</a></p> </li> <li id="fn:859"> <p>Another thing <a class="footnote-backref" href="#fnref:859" rev="footnote" title="Jump back to footnote 859 in the text">↩</a></p> </li> <li id="fn:860"> <p>Another thing <a class="footnote-backref" href="#fnref:860" rev="footnote" title="Jump back to footnote 860 in the text">↩</a></p> </li> <li id="fn:861"> <p>Another thing <a class="footnote-backref" href="#fnref:861" rev="footnote" title="Jump back to footnote 861 in the text">↩</a></p> </li> <li id="fn:862"> <p>Another thing <a class="footnote-backref" href="#fnref:862" rev="footnote" title="Jump back to footnote 862 in the text">↩</a></p> </li> <li id="fn:863"> <p>Another thing <a class="footnote-backref" href="#fnref:863" rev="footnote" title="Jump back to footnote 863 in the text">↩</a></p> </li> <li id="fn:864"> <p>Another thing <a class="footnote-backref" href="#fnref:864" rev="footnote" title="Jump back to footnote 864 in the text">↩</a></p> </li> <li id="fn:865"> <p>Another thing <a class="footnote-backref" href="#fnref:865" rev="footnote" title="Jump back to footnote 865 in the text">↩</a></p> </li> <li id="fn:866"> <p>Another thing <a class="footnote-backref" href="#fnref:866" rev="footnote" title="Jump back to footnote 866 in the text">↩</a></p> </li> <li id="fn:867"> <p>Another thing <a class="footnote-backref" href="#fnref:867" rev="footnote" title="Jump back to footnote 867 in the text">↩</a></p> </li> <li id="fn:868"> <p>Another thing <a class="footnote-backref" href="#fnref:868" rev="footnote" title="Jump back to footnote 868 in the text">↩</a></p> </li> <li id="fn:869"> <p>Another thing <a class="footnote-backref" href="#fnref:869" rev="footnote" title="Jump back to footnote 869 in the text">↩</a></p> </li> <li id="fn:870"> <p>Another thing <a class="footnote-backref" href="#fnref:870" rev="footnote" title="Jump back to footnote 870 in the text">↩</a></p> </li> <li id="fn:871"> <p>Another thing <a class="footnote-backref" href="#fnref:871" rev="footnote" title="Jump back to footnote 871 in the text">↩</a></p> </li> <li id="fn:872"> <p>Another thing <a class="footnote-backref" href="#fnref:872" rev="footnote" title="Jump back to footnote 872 in the text">↩</a></p> </li> <li id="fn:873"> <p>Another thing <a class="footnote-backref" href="#fnref:873" rev="footnote" title="Jump back to footnote 873 in the text">↩</a></p> </li> <li id="fn:874"> <p>Another thing <a class="footnote-backref" href="#fnref:874" rev="footnote" title="Jump back to footnote 874 in the text">↩</a></p> </li> <li id="fn:875"> <p>Another thing <a class="footnote-backref" href="#fnref:875" rev="footnote" title="Jump back to footnote 875 in the text">↩</a></p> </li> <li id="fn:876"> <p>Another thing <a class="footnote-backref" href="#fnref:876" rev="footnote" title="Jump back to footnote 876 in the text">↩</a></p> </li> <li id="fn:877"> <p>Another thing <a class="footnote-backref" href="#fnref:877" rev="footnote" title="Jump back to footnote 877 in the text">↩</a></p> </li> <li id="fn:878"> <p>Another thing <a class="footnote-backref" href="#fnref:878" rev="footnote" title="Jump back to footnote 878 in the text">↩</a></p> </li> <li id="fn:879"> <p>Another thing <a class="footnote-backref" href="#fnref:879" rev="footnote" title="Jump back to footnote 879 in the text">↩</a></p> </li> <li id="fn:880"> <p>Another thing <a class="footnote-backref" href="#fnref:880" rev="footnote" title="Jump back to footnote 880 in the text">↩</a></p> </li> <li id="fn:881"> <p>Another thing <a class="footnote-backref" href="#fnref:881" rev="footnote" title="Jump back to footnote 881 in the text">↩</a></p> </li> <li id="fn:882"> <p>Another thing <a class="footnote-backref" href="#fnref:882" rev="footnote" title="Jump back to footnote 882 in the text">↩</a></p> </li> <li id="fn:883"> <p>Another thing <a class="footnote-backref" href="#fnref:883" rev="footnote" title="Jump back to footnote 883 in the text">↩</a></p> </li> <li id="fn:884"> <p>Another thing <a class="footnote-backref" href="#fnref:884" rev="footnote" title="Jump back to footnote 884 in the text">↩</a></p> </li> <li id="fn:885"> <p>Another thing <a class="footnote-backref" href="#fnref:885" rev="footnote" title="Jump back to footnote 885 in the text">↩</a></p> </li> <li id="fn:886"> <p>Another thing <a class="footnote-backref" href="#fnref:886" rev="footnote" title="Jump back to footnote 886 in the text">↩</a></p> </li> <li id="fn:887"> <p>Another thing <a class="footnote-backref" href="#fnref:887" rev="footnote" title="Jump back to footnote 887 in the text">↩</a></p> </li> <li id="fn:888"> <p>Another thing <a class="footnote-backref" href="#fnref:888" rev="footnote" title="Jump back to footnote 888 in the text">↩</a></p> </li> <li id="fn:889"> <p>Another thing <a class="footnote-backref" href="#fnref:889" rev="footnote" title="Jump back to footnote 889 in the text">↩</a></p> </li> <li id="fn:890"> <p>Another thing <a class="footnote-backref" href="#fnref:890" rev="footnote" title="Jump back to footnote 890 in the text">↩</a></p> </li> <li id="fn:891"> <p>Another thing <a class="footnote-backref" href="#fnref:891" rev="footnote" title="Jump back to footnote 891 in the text">↩</a></p> </li> <li id="fn:892"> <p>Another thing <a class="footnote-backref" href="#fnref:892" rev="footnote" title="Jump back to footnote 892 in the text">↩</a></p> </li> <li id="fn:893"> <p>Another thing <a class="footnote-backref" href="#fnref:893" rev="footnote" title="Jump back to footnote 893 in the text">↩</a></p> </li> <li id="fn:894"> <p>Another thing <a class="footnote-backref" href="#fnref:894" rev="footnote" title="Jump back to footnote 894 in the text">↩</a></p> </li> <li id="fn:895"> <p>Another thing <a class="footnote-backref" href="#fnref:895" rev="footnote" title="Jump back to footnote 895 in the text">↩</a></p> </li> <li id="fn:896"> <p>Another thing <a class="footnote-backref" href="#fnref:896" rev="footnote" title="Jump back to footnote 896 in the text">↩</a></p> </li> <li id="fn:897"> <p>Another thing <a class="footnote-backref" href="#fnref:897" rev="footnote" title="Jump back to footnote 897 in the text">↩</a></p> </li> <li id="fn:898"> <p>Another thing <a class="footnote-backref" href="#fnref:898" rev="footnote" title="Jump back to footnote 898 in the text">↩</a></p> </li> <li id="fn:899"> <p>Another thing <a class="footnote-backref" href="#fnref:899" rev="footnote" title="Jump back to footnote 899 in the text">↩</a></p> </li> <li id="fn:900"> <p>Another thing <a class="footnote-backref" href="#fnref:900" rev="footnote" title="Jump back to footnote 900 in the text">↩</a></p> </li> <li id="fn:901"> <p>Another thing <a class="footnote-backref" href="#fnref:901" rev="footnote" title="Jump back to footnote 901 in the text">↩</a></p> </li> <li id="fn:902"> <p>Another thing <a class="footnote-backref" href="#fnref:902" rev="footnote" title="Jump back to footnote 902 in the text">↩</a></p> </li> <li id="fn:903"> <p>Another thing <a class="footnote-backref" href="#fnref:903" rev="footnote" title="Jump back to footnote 903 in the text">↩</a></p> </li> <li id="fn:904"> <p>Another thing <a class="footnote-backref" href="#fnref:904" rev="footnote" title="Jump back to footnote 904 in the text">↩</a></p> </li> <li id="fn:905"> <p>Another thing <a class="footnote-backref" href="#fnref:905" rev="footnote" title="Jump back to footnote 905 in the text">↩</a></p> </li> <li id="fn:906"> <p>Another thing <a class="footnote-backref" href="#fnref:906" rev="footnote" title="Jump back to footnote 906 in the text">↩</a></p> </li> <li id="fn:907"> <p>Another thing <a class="footnote-backref" href="#fnref:907" rev="footnote" title="Jump back to footnote 907 in the text">↩</a></p> </li> <li id="fn:908"> <p>Another thing <a class="footnote-backref" href="#fnref:908" rev="footnote" title="Jump back to footnote 908 in the text">↩</a></p> </li> <li id="fn:909"> <p>Another thing <a class="footnote-backref" href="#fnref:909" rev="footnote" title="Jump back to footnote 909 in the text">↩</a></p> </li> <li id="fn:910"> <p>Another thing <a class="footnote-backref" href="#fnref:910" rev="footnote" title="Jump back to footnote 910 in the text">↩</a></p> </li> <li id="fn:911"> <p>Another thing <a class="footnote-backref" href="#fnref:911" rev="footnote" title="Jump back to footnote 911 in the text">↩</a></p> </li> <li id="fn:912"> <p>Another thing <a class="footnote-backref" href="#fnref:912" rev="footnote" title="Jump back to footnote 912 in the text">↩</a></p> </li> <li id="fn:913"> <p>Another thing <a class="footnote-backref" href="#fnref:913" rev="footnote" title="Jump back to footnote 913 in the text">↩</a></p> </li> <li id="fn:914"> <p>Another thing <a class="footnote-backref" href="#fnref:914" rev="footnote" title="Jump back to footnote 914 in the text">↩</a></p> </li> <li id="fn:915"> <p>Another thing <a class="footnote-backref" href="#fnref:915" rev="footnote" title="Jump back to footnote 915 in the text">↩</a></p> </li> <li id="fn:916"> <p>Another thing <a class="footnote-backref" href="#fnref:916" rev="footnote" title="Jump back to footnote 916 in the text">↩</a></p> </li> <li id="fn:917"> <p>Another thing <a class="footnote-backref" href="#fnref:917" rev="footnote" title="Jump back to footnote 917 in the text">↩</a></p> </li> <li id="fn:918"> <p>Another thing <a class="footnote-backref" href="#fnref:918" rev="footnote" title="Jump back to footnote 918 in the text">↩</a></p> </li> <li id="fn:919"> <p>Another thing <a class="footnote-backref" href="#fnref:919" rev="footnote" title="Jump back to footnote 919 in the text">↩</a></p> </li> <li id="fn:920"> <p>Another thing <a class="footnote-backref" href="#fnref:920" rev="footnote" title="Jump back to footnote 920 in the text">↩</a></p> </li> <li id="fn:921"> <p>Another thing <a class="footnote-backref" href="#fnref:921" rev="footnote" title="Jump back to footnote 921 in the text">↩</a></p> </li> <li id="fn:922"> <p>Another thing <a class="footnote-backref" href="#fnref:922" rev="footnote" title="Jump back to footnote 922 in the text">↩</a></p> </li> <li id="fn:923"> <p>Another thing <a class="footnote-backref" href="#fnref:923" rev="footnote" title="Jump back to footnote 923 in the text">↩</a></p> </li> <li id="fn:924"> <p>Another thing <a class="footnote-backref" href="#fnref:924" rev="footnote" title="Jump back to footnote 924 in the text">↩</a></p> </li> <li id="fn:925"> <p>Another thing <a class="footnote-backref" href="#fnref:925" rev="footnote" title="Jump back to footnote 925 in the text">↩</a></p> </li> <li id="fn:926"> <p>Another thing <a class="footnote-backref" href="#fnref:926" rev="footnote" title="Jump back to footnote 926 in the text">↩</a></p> </li> <li id="fn:927"> <p>Another thing <a class="footnote-backref" href="#fnref:927" rev="footnote" title="Jump back to footnote 927 in the text">↩</a></p> </li> <li id="fn:928"> <p>Another thing <a class="footnote-backref" href="#fnref:928" rev="footnote" title="Jump back to footnote 928 in the text">↩</a></p> </li> <li id="fn:929"> <p>Another thing <a class="footnote-backref" href="#fnref:929" rev="footnote" title="Jump back to footnote 929 in the text">↩</a></p> </li> <li id="fn:930"> <p>Another thing <a class="footnote-backref" href="#fnref:930" rev="footnote" title="Jump back to footnote 930 in the text">↩</a></p> </li> <li id="fn:931"> <p>Another thing <a class="footnote-backref" href="#fnref:931" rev="footnote" title="Jump back to footnote 931 in the text">↩</a></p> </li> <li id="fn:932"> <p>Another thing <a class="footnote-backref" href="#fnref:932" rev="footnote" title="Jump back to footnote 932 in the text">↩</a></p> </li> <li id="fn:933"> <p>Another thing <a class="footnote-backref" href="#fnref:933" rev="footnote" title="Jump back to footnote 933 in the text">↩</a></p> </li> <li id="fn:934"> <p>Another thing <a class="footnote-backref" href="#fnref:934" rev="footnote" title="Jump back to footnote 934 in the text">↩</a></p> </li> <li id="fn:935"> <p>Another thing <a class="footnote-backref" href="#fnref:935" rev="footnote" title="Jump back to footnote 935 in the text">↩</a></p> </li> <li id="fn:936"> <p>Another thing <a class="footnote-backref" href="#fnref:936" rev="footnote" title="Jump back to footnote 936 in the text">↩</a></p> </li> <li id="fn:937"> <p>Another thing <a class="footnote-backref" href="#fnref:937" rev="footnote" title="Jump back to footnote 937 in the text">↩</a></p> </li> <li id="fn:938"> <p>Another thing <a class="footnote-backref" href="#fnref:938" rev="footnote" title="Jump back to footnote 938 in the text">↩</a></p> </li> <li id="fn:939"> <p>Another thing <a class="footnote-backref" href="#fnref:939" rev="footnote" title="Jump back to footnote 939 in the text">↩</a></p> </li> <li id="fn:940"> <p>Another thing <a class="footnote-backref" href="#fnref:940" rev="footnote" title="Jump back to footnote 940 in the text">↩</a></p> </li> <li id="fn:941"> <p>Another thing <a class="footnote-backref" href="#fnref:941" rev="footnote" title="Jump back to footnote 941 in the text">↩</a></p> </li> <li id="fn:942"> <p>Another thing <a class="footnote-backref" href="#fnref:942" rev="footnote" title="Jump back to footnote 942 in the text">↩</a></p> </li> <li id="fn:943"> <p>Another thing <a class="footnote-backref" href="#fnref:943" rev="footnote" title="Jump back to footnote 943 in the text">↩</a></p> </li> <li id="fn:944"> <p>Another thing <a class="footnote-backref" href="#fnref:944" rev="footnote" title="Jump back to footnote 944 in the text">↩</a></p> </li> <li id="fn:945"> <p>Another thing <a class="footnote-backref" href="#fnref:945" rev="footnote" title="Jump back to footnote 945 in the text">↩</a></p> </li> <li id="fn:946"> <p>Another thing <a class="footnote-backref" href="#fnref:946" rev="footnote" title="Jump back to footnote 946 in the text">↩</a></p> </li> <li id="fn:947"> <p>Another thing <a class="footnote-backref" href="#fnref:947" rev="footnote" title="Jump back to footnote 947 in the text">↩</a></p> </li> <li id="fn:948"> <p>Another thing <a class="footnote-backref" href="#fnref:948" rev="footnote" title="Jump back to footnote 948 in the text">↩</a></p> </li> <li id="fn:949"> <p>Another thing <a class="footnote-backref" href="#fnref:949" rev="footnote" title="Jump back to footnote 949 in the text">↩</a></p> </li> <li id="fn:950"> <p>Another thing <a class="footnote-backref" href="#fnref:950" rev="footnote" title="Jump back to footnote 950 in the text">↩</a></p> </li> <li id="fn:951"> <p>Another thing <a class="footnote-backref" href="#fnref:951" rev="footnote" title="Jump back to footnote 951 in the text">↩</a></p> </li> <li id="fn:952"> <p>Another thing <a class="footnote-backref" href="#fnref:952" rev="footnote" title="Jump back to footnote 952 in the text">↩</a></p> </li> <li id="fn:953"> <p>Another thing <a class="footnote-backref" href="#fnref:953" rev="footnote" title="Jump back to footnote 953 in the text">↩</a></p> </li> <li id="fn:954"> <p>Another thing <a class="footnote-backref" href="#fnref:954" rev="footnote" title="Jump back to footnote 954 in the text">↩</a></p> </li> <li id="fn:955"> <p>Another thing <a class="footnote-backref" href="#fnref:955" rev="footnote" title="Jump back to footnote 955 in the text">↩</a></p> </li> <li id="fn:956"> <p>Another thing <a class="footnote-backref" href="#fnref:956" rev="footnote" title="Jump back to footnote 956 in the text">↩</a></p> </li> <li id="fn:957"> <p>Another thing <a class="footnote-backref" href="#fnref:957" rev="footnote" title="Jump back to footnote 957 in the text">↩</a></p> </li> <li id="fn:958"> <p>Another thing <a class="footnote-backref" href="#fnref:958" rev="footnote" title="Jump back to footnote 958 in the text">↩</a></p> </li> <li id="fn:959"> <p>Another thing <a class="footnote-backref" href="#fnref:959" rev="footnote" title="Jump back to footnote 959 in the text">↩</a></p> </li> <li id="fn:960"> <p>Another thing <a class="footnote-backref" href="#fnref:960" rev="footnote" title="Jump back to footnote 960 in the text">↩</a></p> </li> <li id="fn:961"> <p>Another thing <a class="footnote-backref" href="#fnref:961" rev="footnote" title="Jump back to footnote 961 in the text">↩</a></p> </li> <li id="fn:962"> <p>Another thing <a class="footnote-backref" href="#fnref:962" rev="footnote" title="Jump back to footnote 962 in the text">↩</a></p> </li> <li id="fn:963"> <p>Another thing <a class="footnote-backref" href="#fnref:963" rev="footnote" title="Jump back to footnote 963 in the text">↩</a></p> </li> <li id="fn:964"> <p>Another thing <a class="footnote-backref" href="#fnref:964" rev="footnote" title="Jump back to footnote 964 in the text">↩</a></p> </li> <li id="fn:965"> <p>Another thing <a class="footnote-backref" href="#fnref:965" rev="footnote" title="Jump back to footnote 965 in the text">↩</a></p> </li> <li id="fn:966"> <p>Another thing <a class="footnote-backref" href="#fnref:966" rev="footnote" title="Jump back to footnote 966 in the text">↩</a></p> </li> <li id="fn:967"> <p>Another thing <a class="footnote-backref" href="#fnref:967" rev="footnote" title="Jump back to footnote 967 in the text">↩</a></p> </li> <li id="fn:968"> <p>Another thing <a class="footnote-backref" href="#fnref:968" rev="footnote" title="Jump back to footnote 968 in the text">↩</a></p> </li> <li id="fn:969"> <p>Another thing <a class="footnote-backref" href="#fnref:969" rev="footnote" title="Jump back to footnote 969 in the text">↩</a></p> </li> <li id="fn:970"> <p>Another thing <a class="footnote-backref" href="#fnref:970" rev="footnote" title="Jump back to footnote 970 in the text">↩</a></p> </li> <li id="fn:971"> <p>Another thing <a class="footnote-backref" href="#fnref:971" rev="footnote" title="Jump back to footnote 971 in the text">↩</a></p> </li> <li id="fn:972"> <p>Another thing <a class="footnote-backref" href="#fnref:972" rev="footnote" title="Jump back to footnote 972 in the text">↩</a></p> </li> <li id="fn:973"> <p>Another thing <a class="footnote-backref" href="#fnref:973" rev="footnote" title="Jump back to footnote 973 in the text">↩</a></p> </li> <li id="fn:974"> <p>Another thing <a class="footnote-backref" href="#fnref:974" rev="footnote" title="Jump back to footnote 974 in the text">↩</a></p> </li> <li id="fn:975"> <p>Another thing <a class="footnote-backref" href="#fnref:975" rev="footnote" title="Jump back to footnote 975 in the text">↩</a></p> </li> <li id="fn:976"> <p>Another thing <a class="footnote-backref" href="#fnref:976" rev="footnote" title="Jump back to footnote 976 in the text">↩</a></p> </li> <li id="fn:977"> <p>Another thing <a class="footnote-backref" href="#fnref:977" rev="footnote" title="Jump back to footnote 977 in the text">↩</a></p> </li> <li id="fn:978"> <p>Another thing <a class="footnote-backref" href="#fnref:978" rev="footnote" title="Jump back to footnote 978 in the text">↩</a></p> </li> <li id="fn:979"> <p>Another thing <a class="footnote-backref" href="#fnref:979" rev="footnote" title="Jump back to footnote 979 in the text">↩</a></p> </li> <li id="fn:980"> <p>Another thing <a class="footnote-backref" href="#fnref:980" rev="footnote" title="Jump back to footnote 980 in the text">↩</a></p> </li> <li id="fn:981"> <p>Another thing <a class="footnote-backref" href="#fnref:981" rev="footnote" title="Jump back to footnote 981 in the text">↩</a></p> </li> <li id="fn:982"> <p>Another thing <a class="footnote-backref" href="#fnref:982" rev="footnote" title="Jump back to footnote 982 in the text">↩</a></p> </li> <li id="fn:983"> <p>Another thing <a class="footnote-backref" href="#fnref:983" rev="footnote" title="Jump back to footnote 983 in the text">↩</a></p> </li> <li id="fn:984"> <p>Another thing <a class="footnote-backref" href="#fnref:984" rev="footnote" title="Jump back to footnote 984 in the text">↩</a></p> </li> <li id="fn:985"> <p>Another thing <a class="footnote-backref" href="#fnref:985" rev="footnote" title="Jump back to footnote 985 in the text">↩</a></p> </li> <li id="fn:986"> <p>Another thing <a class="footnote-backref" href="#fnref:986" rev="footnote" title="Jump back to footnote 986 in the text">↩</a></p> </li> <li id="fn:987"> <p>Another thing <a class="footnote-backref" href="#fnref:987" rev="footnote" title="Jump back to footnote 987 in the text">↩</a></p> </li> <li id="fn:988"> <p>Another thing <a class="footnote-backref" href="#fnref:988" rev="footnote" title="Jump back to footnote 988 in the text">↩</a></p> </li> <li id="fn:989"> <p>Another thing <a class="footnote-backref" href="#fnref:989" rev="footnote" title="Jump back to footnote 989 in the text">↩</a></p> </li> <li id="fn:990"> <p>Another thing <a class="footnote-backref" href="#fnref:990" rev="footnote" title="Jump back to footnote 990 in the text">↩</a></p> </li> <li id="fn:991"> <p>Another thing <a class="footnote-backref" href="#fnref:991" rev="footnote" title="Jump back to footnote 991 in the text">↩</a></p> </li> <li id="fn:992"> <p>Another thing <a class="footnote-backref" href="#fnref:992" rev="footnote" title="Jump back to footnote 992 in the text">↩</a></p> </li> <li id="fn:993"> <p>Another thing <a class="footnote-backref" href="#fnref:993" rev="footnote" title="Jump back to footnote 993 in the text">↩</a></p> </li> <li id="fn:994"> <p>Another thing <a class="footnote-backref" href="#fnref:994" rev="footnote" title="Jump back to footnote 994 in the text">↩</a></p> </li> <li id="fn:995"> <p>Another thing <a class="footnote-backref" href="#fnref:995" rev="footnote" title="Jump back to footnote 995 in the text">↩</a></p> </li> <li id="fn:996"> <p>Another thing <a class="footnote-backref" href="#fnref:996" rev="footnote" title="Jump back to footnote 996 in the text">↩</a></p> </li> <li id="fn:997"> <p>Another thing <a class="footnote-backref" href="#fnref:997" rev="footnote" title="Jump back to footnote 997 in the text">↩</a></p> </li> <li id="fn:998"> <p>Another thing <a class="footnote-backref" href="#fnref:998" rev="footnote" title="Jump back to footnote 998 in the text">↩</a></p> </li> <li id="fn:999"> <p>Another thing <a class="footnote-backref" href="#fnref:999" rev="footnote" title="Jump back to footnote 999 in the text">↩</a></p> </li> <li id="fn:1000"> <p>Another thing <a class="footnote-backref" href="#fnref:1000" rev="footnote" title="Jump back to footnote 1000 in the text">↩</a></p> </li> <li id="fn:1001"> <p>Another thing <a class="footnote-backref" href="#fnref:1001" rev="footnote" title="Jump back to footnote 1001 in the text">↩</a></p> </li> <li id="fn:1002"> <p>Another thing <a class="footnote-backref" href="#fnref:1002" rev="footnote" title="Jump back to footnote 1002 in the text">↩</a></p> </li> <li id="fn:1003"> <p>Another thing <a class="footnote-backref" href="#fnref:1003" rev="footnote" title="Jump back to footnote 1003 in the text">↩</a></p> </li> <li id="fn:1004"> <p>Another thing <a class="footnote-backref" href="#fnref:1004" rev="footnote" title="Jump back to footnote 1004 in the text">↩</a></p> </li> <li id="fn:1005"> <p>Another thing <a class="footnote-backref" href="#fnref:1005" rev="footnote" title="Jump back to footnote 1005 in the text">↩</a></p> </li> <li id="fn:1006"> <p>Another thing <a class="footnote-backref" href="#fnref:1006" rev="footnote" title="Jump back to footnote 1006 in the text">↩</a></p> </li> <li id="fn:1007"> <p>Another thing <a class="footnote-backref" href="#fnref:1007" rev="footnote" title="Jump back to footnote 1007 in the text">↩</a></p> </li> <li id="fn:1008"> <p>Another thing <a class="footnote-backref" href="#fnref:1008" rev="footnote" title="Jump back to footnote 1008 in the text">↩</a></p> </li> <li id="fn:1009"> <p>Another thing <a class="footnote-backref" href="#fnref:1009" rev="footnote" title="Jump back to footnote 1009 in the text">↩</a></p> </li> <li id="fn:1010"> <p>Another thing <a class="footnote-backref" href="#fnref:1010" rev="footnote" title="Jump back to footnote 1010 in the text">↩</a></p> </li> <li id="fn:1011"> <p>Another thing <a class="footnote-backref" href="#fnref:1011" rev="footnote" title="Jump back to footnote 1011 in the text">↩</a></p> </li> <li id="fn:1012"> <p>Another thing <a class="footnote-backref" href="#fnref:1012" rev="footnote" title="Jump back to footnote 1012 in the text">↩</a></p> </li> <li id="fn:1013"> <p>Another thing <a class="footnote-backref" href="#fnref:1013" rev="footnote" title="Jump back to footnote 1013 in the text">↩</a></p> </li> <li id="fn:1014"> <p>Another thing <a class="footnote-backref" href="#fnref:1014" rev="footnote" title="Jump back to footnote 1014 in the text">↩</a></p> </li> <li id="fn:1015"> <p>Another thing <a class="footnote-backref" href="#fnref:1015" rev="footnote" title="Jump back to footnote 1015 in the text">↩</a></p> </li> <li id="fn:1016"> <p>Another thing <a class="footnote-backref" href="#fnref:1016" rev="footnote" title="Jump back to footnote 1016 in the text">↩</a></p> </li> <li id="fn:1017"> <p>Another thing <a class="footnote-backref" href="#fnref:1017" rev="footnote" title="Jump back to footnote 1017 in the text">↩</a></p> </li> <li id="fn:1018"> <p>Another thing <a class="footnote-backref" href="#fnref:1018" rev="footnote" title="Jump back to footnote 1018 in the text">↩</a></p> </li> <li id="fn:1019"> <p>Another thing <a class="footnote-backref" href="#fnref:1019" rev="footnote" title="Jump back to footnote 1019 in the text">↩</a></p> </li> <li id="fn:1020"> <p>Another thing <a class="footnote-backref" href="#fnref:1020" rev="footnote" title="Jump back to footnote 1020 in the text">↩</a></p> </li> <li id="fn:1021"> <p>Another thing <a class="footnote-backref" href="#fnref:1021" rev="footnote" title="Jump back to footnote 1021 in the text">↩</a></p> </li> <li id="fn:1022"> <p>Another thing <a class="footnote-backref" href="#fnref:1022" rev="footnote" title="Jump back to footnote 1022 in the text">↩</a></p> </li> <li id="fn:1023"> <p>Another thing <a class="footnote-backref" href="#fnref:1023" rev="footnote" title="Jump back to footnote 1023 in the text">↩</a></p> </li> <li id="fn:1024"> <p>Another thing <a class="footnote-backref" href="#fnref:1024" rev="footnote" title="Jump back to footnote 1024 in the text">↩</a></p> </li> <li id="fn:1025"> <p>Another thing <a class="footnote-backref" href="#fnref:1025" rev="footnote" title="Jump back to footnote 1025 in the text">↩</a></p> </li> <li id="fn:1026"> <p>Another thing <a class="footnote-backref" href="#fnref:1026" rev="footnote" title="Jump back to footnote 1026 in the text">↩</a></p> </li> <li id="fn:1027"> <p>Another thing <a class="footnote-backref" href="#fnref:1027" rev="footnote" title="Jump back to footnote 1027 in the text">↩</a></p> </li> <li id="fn:1028"> <p>Another thing <a class="footnote-backref" href="#fnref:1028" rev="footnote" title="Jump back to footnote 1028 in the text">↩</a></p> </li> <li id="fn:1029"> <p>Another thing <a class="footnote-backref" href="#fnref:1029" rev="footnote" title="Jump back to footnote 1029 in the text">↩</a></p> </li> <li id="fn:1030"> <p>Another thing <a class="footnote-backref" href="#fnref:1030" rev="footnote" title="Jump back to footnote 1030 in the text">↩</a></p> </li> <li id="fn:1031"> <p>Another thing <a class="footnote-backref" href="#fnref:1031" rev="footnote" title="Jump back to footnote 1031 in the text">↩</a></p> </li> <li id="fn:1032"> <p>Another thing <a class="footnote-backref" href="#fnref:1032" rev="footnote" title="Jump back to footnote 1032 in the text">↩</a></p> </li> <li id="fn:1033"> <p>Another thing <a class="footnote-backref" href="#fnref:1033" rev="footnote" title="Jump back to footnote 1033 in the text">↩</a></p> </li> <li id="fn:1034"> <p>Another thing <a class="footnote-backref" href="#fnref:1034" rev="footnote" title="Jump back to footnote 1034 in the text">↩</a></p> </li> <li id="fn:1035"> <p>Another thing <a class="footnote-backref" href="#fnref:1035" rev="footnote" title="Jump back to footnote 1035 in the text">↩</a></p> </li> <li id="fn:1036"> <p>Another thing <a class="footnote-backref" href="#fnref:1036" rev="footnote" title="Jump back to footnote 1036 in the text">↩</a></p> </li> <li id="fn:1037"> <p>Another thing <a class="footnote-backref" href="#fnref:1037" rev="footnote" title="Jump back to footnote 1037 in the text">↩</a></p> </li> <li id="fn:1038"> <p>Another thing <a class="footnote-backref" href="#fnref:1038" rev="footnote" title="Jump back to footnote 1038 in the text">↩</a></p> </li> <li id="fn:1039"> <p>Another thing <a class="footnote-backref" href="#fnref:1039" rev="footnote" title="Jump back to footnote 1039 in the text">↩</a></p> </li> <li id="fn:1040"> <p>Another thing <a class="footnote-backref" href="#fnref:1040" rev="footnote" title="Jump back to footnote 1040 in the text">↩</a></p> </li> <li id="fn:1041"> <p>Another thing <a class="footnote-backref" href="#fnref:1041" rev="footnote" title="Jump back to footnote 1041 in the text">↩</a></p> </li> <li id="fn:1042"> <p>Another thing <a class="footnote-backref" href="#fnref:1042" rev="footnote" title="Jump back to footnote 1042 in the text">↩</a></p> </li> <li id="fn:1043"> <p>Another thing <a class="footnote-backref" href="#fnref:1043" rev="footnote" title="Jump back to footnote 1043 in the text">↩</a></p> </li> <li id="fn:1044"> <p>Another thing <a class="footnote-backref" href="#fnref:1044" rev="footnote" title="Jump back to footnote 1044 in the text">↩</a></p> </li> <li id="fn:1045"> <p>Another thing <a class="footnote-backref" href="#fnref:1045" rev="footnote" title="Jump back to footnote 1045 in the text">↩</a></p> </li> <li id="fn:1046"> <p>Another thing <a class="footnote-backref" href="#fnref:1046" rev="footnote" title="Jump back to footnote 1046 in the text">↩</a></p> </li> <li id="fn:1047"> <p>Another thing <a class="footnote-backref" href="#fnref:1047" rev="footnote" title="Jump back to footnote 1047 in the text">↩</a></p> </li> <li id="fn:1048"> <p>Another thing <a class="footnote-backref" href="#fnref:1048" rev="footnote" title="Jump back to footnote 1048 in the text">↩</a></p> </li> <li id="fn:1049"> <p>Another thing <a class="footnote-backref" href="#fnref:1049" rev="footnote" title="Jump back to footnote 1049 in the text">↩</a></p> </li> <li id="fn:1050"> <p>Another thing <a class="footnote-backref" href="#fnref:1050" rev="footnote" title="Jump back to footnote 1050 in the text">↩</a></p> </li> <li id="fn:1051"> <p>Another thing <a class="footnote-backref" href="#fnref:1051" rev="footnote" title="Jump back to footnote 1051 in the text">↩</a></p> </li> <li id="fn:1052"> <p>Another thing <a class="footnote-backref" href="#fnref:1052" rev="footnote" title="Jump back to footnote 1052 in the text">↩</a></p> </li> <li id="fn:1053"> <p>Another thing <a class="footnote-backref" href="#fnref:1053" rev="footnote" title="Jump back to footnote 1053 in the text">↩</a></p> </li> <li id="fn:1054"> <p>Another thing <a class="footnote-backref" href="#fnref:1054" rev="footnote" title="Jump back to footnote 1054 in the text">↩</a></p> </li> <li id="fn:1055"> <p>Another thing <a class="footnote-backref" href="#fnref:1055" rev="footnote" title="Jump back to footnote 1055 in the text">↩</a></p> </li> <li id="fn:1056"> <p>Another thing <a class="footnote-backref" href="#fnref:1056" rev="footnote" title="Jump back to footnote 1056 in the text">↩</a></p> </li> <li id="fn:1057"> <p>Another thing <a class="footnote-backref" href="#fnref:1057" rev="footnote" title="Jump back to footnote 1057 in the text">↩</a></p> </li> <li id="fn:1058"> <p>Another thing <a class="footnote-backref" href="#fnref:1058" rev="footnote" title="Jump back to footnote 1058 in the text">↩</a></p> </li> <li id="fn:1059"> <p>Another thing <a class="footnote-backref" href="#fnref:1059" rev="footnote" title="Jump back to footnote 1059 in the text">↩</a></p> </li> <li id="fn:1060"> <p>Another thing <a class="footnote-backref" href="#fnref:1060" rev="footnote" title="Jump back to footnote 1060 in the text">↩</a></p> </li> <li id="fn:1061"> <p>Another thing <a class="footnote-backref" href="#fnref:1061" rev="footnote" title="Jump back to footnote 1061 in the text">↩</a></p> </li> <li id="fn:1062"> <p>Another thing <a class="footnote-backref" href="#fnref:1062" rev="footnote" title="Jump back to footnote 1062 in the text">↩</a></p> </li> <li id="fn:1063"> <p>Another thing <a class="footnote-backref" href="#fnref:1063" rev="footnote" title="Jump back to footnote 1063 in the text">↩</a></p> </li> <li id="fn:1064"> <p>Another thing <a class="footnote-backref" href="#fnref:1064" rev="footnote" title="Jump back to footnote 1064 in the text">↩</a></p> </li> <li id="fn:1065"> <p>Another thing <a class="footnote-backref" href="#fnref:1065" rev="footnote" title="Jump back to footnote 1065 in the text">↩</a></p> </li> <li id="fn:1066"> <p>Another thing <a class="footnote-backref" href="#fnref:1066" rev="footnote" title="Jump back to footnote 1066 in the text">↩</a></p> </li> <li id="fn:1067"> <p>Another thing <a class="footnote-backref" href="#fnref:1067" rev="footnote" title="Jump back to footnote 1067 in the text">↩</a></p> </li> <li id="fn:1068"> <p>Another thing <a class="footnote-backref" href="#fnref:1068" rev="footnote" title="Jump back to footnote 1068 in the text">↩</a></p> </li> <li id="fn:1069"> <p>Another thing <a class="footnote-backref" href="#fnref:1069" rev="footnote" title="Jump back to footnote 1069 in the text">↩</a></p> </li> <li id="fn:1070"> <p>Another thing <a class="footnote-backref" href="#fnref:1070" rev="footnote" title="Jump back to footnote 1070 in the text">↩</a></p> </li> <li id="fn:1071"> <p>Another thing <a class="footnote-backref" href="#fnref:1071" rev="footnote" title="Jump back to footnote 1071 in the text">↩</a></p> </li> <li id="fn:1072"> <p>Another thing <a class="footnote-backref" href="#fnref:1072" rev="footnote" title="Jump back to footnote 1072 in the text">↩</a></p> </li> <li id="fn:1073"> <p>Another thing <a class="footnote-backref" href="#fnref:1073" rev="footnote" title="Jump back to footnote 1073 in the text">↩</a></p> </li> <li id="fn:1074"> <p>Another thing <a class="footnote-backref" href="#fnref:1074" rev="footnote" title="Jump back to footnote 1074 in the text">↩</a></p> </li> <li id="fn:1075"> <p>Another thing <a class="footnote-backref" href="#fnref:1075" rev="footnote" title="Jump back to footnote 1075 in the text">↩</a></p> </li> <li id="fn:1076"> <p>Another thing <a class="footnote-backref" href="#fnref:1076" rev="footnote" title="Jump back to footnote 1076 in the text">↩</a></p> </li> <li id="fn:1077"> <p>Another thing <a class="footnote-backref" href="#fnref:1077" rev="footnote" title="Jump back to footnote 1077 in the text">↩</a></p> </li> <li id="fn:1078"> <p>Another thing <a class="footnote-backref" href="#fnref:1078" rev="footnote" title="Jump back to footnote 1078 in the text">↩</a></p> </li> <li id="fn:1079"> <p>Another thing <a class="footnote-backref" href="#fnref:1079" rev="footnote" title="Jump back to footnote 1079 in the text">↩</a></p> </li> <li id="fn:1080"> <p>Another thing <a class="footnote-backref" href="#fnref:1080" rev="footnote" title="Jump back to footnote 1080 in the text">↩</a></p> </li> <li id="fn:1081"> <p>Another thing <a class="footnote-backref" href="#fnref:1081" rev="footnote" title="Jump back to footnote 1081 in the text">↩</a></p> </li> <li id="fn:1082"> <p>Another thing <a class="footnote-backref" href="#fnref:1082" rev="footnote" title="Jump back to footnote 1082 in the text">↩</a></p> </li> <li id="fn:1083"> <p>Another thing <a class="footnote-backref" href="#fnref:1083" rev="footnote" title="Jump back to footnote 1083 in the text">↩</a></p> </li> <li id="fn:1084"> <p>Another thing <a class="footnote-backref" href="#fnref:1084" rev="footnote" title="Jump back to footnote 1084 in the text">↩</a></p> </li> <li id="fn:1085"> <p>Another thing <a class="footnote-backref" href="#fnref:1085" rev="footnote" title="Jump back to footnote 1085 in the text">↩</a></p> </li> <li id="fn:1086"> <p>Another thing <a class="footnote-backref" href="#fnref:1086" rev="footnote" title="Jump back to footnote 1086 in the text">↩</a></p> </li> <li id="fn:1087"> <p>Another thing <a class="footnote-backref" href="#fnref:1087" rev="footnote" title="Jump back to footnote 1087 in the text">↩</a></p> </li> <li id="fn:1088"> <p>Another thing <a class="footnote-backref" href="#fnref:1088" rev="footnote" title="Jump back to footnote 1088 in the text">↩</a></p> </li> <li id="fn:1089"> <p>Another thing <a class="footnote-backref" href="#fnref:1089" rev="footnote" title="Jump back to footnote 1089 in the text">↩</a></p> </li> <li id="fn:1090"> <p>Another thing <a class="footnote-backref" href="#fnref:1090" rev="footnote" title="Jump back to footnote 1090 in the text">↩</a></p> </li> <li id="fn:1091"> <p>Another thing <a class="footnote-backref" href="#fnref:1091" rev="footnote" title="Jump back to footnote 1091 in the text">↩</a></p> </li> <li id="fn:1092"> <p>Another thing <a class="footnote-backref" href="#fnref:1092" rev="footnote" title="Jump back to footnote 1092 in the text">↩</a></p> </li> <li id="fn:1093"> <p>Another thing <a class="footnote-backref" href="#fnref:1093" rev="footnote" title="Jump back to footnote 1093 in the text">↩</a></p> </li> <li id="fn:1094"> <p>Another thing <a class="footnote-backref" href="#fnref:1094" rev="footnote" title="Jump back to footnote 1094 in the text">↩</a></p> </li> <li id="fn:1095"> <p>Another thing <a class="footnote-backref" href="#fnref:1095" rev="footnote" title="Jump back to footnote 1095 in the text">↩</a></p> </li> <li id="fn:1096"> <p>Another thing <a class="footnote-backref" href="#fnref:1096" rev="footnote" title="Jump back to footnote 1096 in the text">↩</a></p> </li> <li id="fn:1097"> <p>Another thing <a class="footnote-backref" href="#fnref:1097" rev="footnote" title="Jump back to footnote 1097 in the text">↩</a></p> </li> <li id="fn:1098"> <p>Another thing <a class="footnote-backref" href="#fnref:1098" rev="footnote" title="Jump back to footnote 1098 in the text">↩</a></p> </li> <li id="fn:1099"> <p>Another thing <a class="footnote-backref" href="#fnref:1099" rev="footnote" title="Jump back to footnote 1099 in the text">↩</a></p> </li> <li id="fn:1100"> <p>Another thing <a class="footnote-backref" href="#fnref:1100" rev="footnote" title="Jump back to footnote 1100 in the text">↩</a></p> </li> <li id="fn:1101"> <p>Another thing <a class="footnote-backref" href="#fnref:1101" rev="footnote" title="Jump back to footnote 1101 in the text">↩</a></p> </li> <li id="fn:1102"> <p>Another thing <a class="footnote-backref" href="#fnref:1102" rev="footnote" title="Jump back to footnote 1102 in the text">↩</a></p> </li> <li id="fn:1103"> <p>Another thing <a class="footnote-backref" href="#fnref:1103" rev="footnote" title="Jump back to footnote 1103 in the text">↩</a></p> </li> <li id="fn:1104"> <p>Another thing <a class="footnote-backref" href="#fnref:1104" rev="footnote" title="Jump back to footnote 1104 in the text">↩</a></p> </li> <li id="fn:1105"> <p>Another thing <a class="footnote-backref" href="#fnref:1105" rev="footnote" title="Jump back to footnote 1105 in the text">↩</a></p> </li> <li id="fn:1106"> <p>Another thing <a class="footnote-backref" href="#fnref:1106" rev="footnote" title="Jump back to footnote 1106 in the text">↩</a></p> </li> <li id="fn:1107"> <p>Another thing <a class="footnote-backref" href="#fnref:1107" rev="footnote" title="Jump back to footnote 1107 in the text">↩</a></p> </li> <li id="fn:1108"> <p>Another thing <a class="footnote-backref" href="#fnref:1108" rev="footnote" title="Jump back to footnote 1108 in the text">↩</a></p> </li> <li id="fn:1109"> <p>Another thing <a class="footnote-backref" href="#fnref:1109" rev="footnote" title="Jump back to footnote 1109 in the text">↩</a></p> </li> <li id="fn:1110"> <p>Another thing <a class="footnote-backref" href="#fnref:1110" rev="footnote" title="Jump back to footnote 1110 in the text">↩</a></p> </li> <li id="fn:1111"> <p>Another thing <a class="footnote-backref" href="#fnref:1111" rev="footnote" title="Jump back to footnote 1111 in the text">↩</a></p> </li> <li id="fn:1112"> <p>Another thing <a class="footnote-backref" href="#fnref:1112" rev="footnote" title="Jump back to footnote 1112 in the text">↩</a></p> </li> <li id="fn:1113"> <p>Another thing <a class="footnote-backref" href="#fnref:1113" rev="footnote" title="Jump back to footnote 1113 in the text">↩</a></p> </li> <li id="fn:1114"> <p>Another thing <a class="footnote-backref" href="#fnref:1114" rev="footnote" title="Jump back to footnote 1114 in the text">↩</a></p> </li> <li id="fn:1115"> <p>Another thing <a class="footnote-backref" href="#fnref:1115" rev="footnote" title="Jump back to footnote 1115 in the text">↩</a></p> </li> <li id="fn:1116"> <p>Another thing <a class="footnote-backref" href="#fnref:1116" rev="footnote" title="Jump back to footnote 1116 in the text">↩</a></p> </li> <li id="fn:1117"> <p>Another thing <a class="footnote-backref" href="#fnref:1117" rev="footnote" title="Jump back to footnote 1117 in the text">↩</a></p> </li> <li id="fn:1118"> <p>Another thing <a class="footnote-backref" href="#fnref:1118" rev="footnote" title="Jump back to footnote 1118 in the text">↩</a></p> </li> <li id="fn:1119"> <p>Another thing <a class="footnote-backref" href="#fnref:1119" rev="footnote" title="Jump back to footnote 1119 in the text">↩</a></p> </li> <li id="fn:1120"> <p>Another thing <a class="footnote-backref" href="#fnref:1120" rev="footnote" title="Jump back to footnote 1120 in the text">↩</a></p> </li> <li id="fn:1121"> <p>Another thing <a class="footnote-backref" href="#fnref:1121" rev="footnote" title="Jump back to footnote 1121 in the text">↩</a></p> </li> <li id="fn:1122"> <p>Another thing <a class="footnote-backref" href="#fnref:1122" rev="footnote" title="Jump back to footnote 1122 in the text">↩</a></p> </li> <li id="fn:1123"> <p>Another thing <a class="footnote-backref" href="#fnref:1123" rev="footnote" title="Jump back to footnote 1123 in the text">↩</a></p> </li> <li id="fn:1124"> <p>Another thing <a class="footnote-backref" href="#fnref:1124" rev="footnote" title="Jump back to footnote 1124 in the text">↩</a></p> </li> <li id="fn:1125"> <p>Another thing <a class="footnote-backref" href="#fnref:1125" rev="footnote" title="Jump back to footnote 1125 in the text">↩</a></p> </li> <li id="fn:1126"> <p>Another thing <a class="footnote-backref" href="#fnref:1126" rev="footnote" title="Jump back to footnote 1126 in the text">↩</a></p> </li> <li id="fn:1127"> <p>Another thing <a class="footnote-backref" href="#fnref:1127" rev="footnote" title="Jump back to footnote 1127 in the text">↩</a></p> </li> <li id="fn:1128"> <p>Another thing <a class="footnote-backref" href="#fnref:1128" rev="footnote" title="Jump back to footnote 1128 in the text">↩</a></p> </li> <li id="fn:1129"> <p>Another thing <a class="footnote-backref" href="#fnref:1129" rev="footnote" title="Jump back to footnote 1129 in the text">↩</a></p> </li> <li id="fn:1130"> <p>Another thing <a class="footnote-backref" href="#fnref:1130" rev="footnote" title="Jump back to footnote 1130 in the text">↩</a></p> </li> <li id="fn:1131"> <p>Another thing <a class="footnote-backref" href="#fnref:1131" rev="footnote" title="Jump back to footnote 1131 in the text">↩</a></p> </li> <li id="fn:1132"> <p>Another thing <a class="footnote-backref" href="#fnref:1132" rev="footnote" title="Jump back to footnote 1132 in the text">↩</a></p> </li> <li id="fn:1133"> <p>Another thing <a class="footnote-backref" href="#fnref:1133" rev="footnote" title="Jump back to footnote 1133 in the text">↩</a></p> </li> <li id="fn:1134"> <p>Another thing <a class="footnote-backref" href="#fnref:1134" rev="footnote" title="Jump back to footnote 1134 in the text">↩</a></p> </li> <li id="fn:1135"> <p>Another thing <a class="footnote-backref" href="#fnref:1135" rev="footnote" title="Jump back to footnote 1135 in the text">↩</a></p> </li> <li id="fn:1136"> <p>Another thing <a class="footnote-backref" href="#fnref:1136" rev="footnote" title="Jump back to footnote 1136 in the text">↩</a></p> </li> <li id="fn:1137"> <p>Another thing <a class="footnote-backref" href="#fnref:1137" rev="footnote" title="Jump back to footnote 1137 in the text">↩</a></p> </li> <li id="fn:1138"> <p>Another thing <a class="footnote-backref" href="#fnref:1138" rev="footnote" title="Jump back to footnote 1138 in the text">↩</a></p> </li> <li id="fn:1139"> <p>Another thing <a class="footnote-backref" href="#fnref:1139" rev="footnote" title="Jump back to footnote 1139 in the text">↩</a></p> </li> <li id="fn:1140"> <p>Another thing <a class="footnote-backref" href="#fnref:1140" rev="footnote" title="Jump back to footnote 1140 in the text">↩</a></p> </li> <li id="fn:1141"> <p>Another thing <a class="footnote-backref" href="#fnref:1141" rev="footnote" title="Jump back to footnote 1141 in the text">↩</a></p> </li> <li id="fn:1142"> <p>Another thing <a class="footnote-backref" href="#fnref:1142" rev="footnote" title="Jump back to footnote 1142 in the text">↩</a></p> </li> <li id="fn:1143"> <p>Another thing <a class="footnote-backref" href="#fnref:1143" rev="footnote" title="Jump back to footnote 1143 in the text">↩</a></p> </li> <li id="fn:1144"> <p>Another thing <a class="footnote-backref" href="#fnref:1144" rev="footnote" title="Jump back to footnote 1144 in the text">↩</a></p> </li> <li id="fn:1145"> <p>Another thing <a class="footnote-backref" href="#fnref:1145" rev="footnote" title="Jump back to footnote 1145 in the text">↩</a></p> </li> <li id="fn:1146"> <p>Another thing <a class="footnote-backref" href="#fnref:1146" rev="footnote" title="Jump back to footnote 1146 in the text">↩</a></p> </li> <li id="fn:1147"> <p>Another thing <a class="footnote-backref" href="#fnref:1147" rev="footnote" title="Jump back to footnote 1147 in the text">↩</a></p> </li> <li id="fn:1148"> <p>Another thing <a class="footnote-backref" href="#fnref:1148" rev="footnote" title="Jump back to footnote 1148 in the text">↩</a></p> </li> <li id="fn:1149"> <p>Another thing <a class="footnote-backref" href="#fnref:1149" rev="footnote" title="Jump back to footnote 1149 in the text">↩</a></p> </li> <li id="fn:1150"> <p>Another thing <a class="footnote-backref" href="#fnref:1150" rev="footnote" title="Jump back to footnote 1150 in the text">↩</a></p> </li> <li id="fn:1151"> <p>Another thing <a class="footnote-backref" href="#fnref:1151" rev="footnote" title="Jump back to footnote 1151 in the text">↩</a></p> </li> <li id="fn:1152"> <p>Another thing <a class="footnote-backref" href="#fnref:1152" rev="footnote" title="Jump back to footnote 1152 in the text">↩</a></p> </li> <li id="fn:1153"> <p>Another thing <a class="footnote-backref" href="#fnref:1153" rev="footnote" title="Jump back to footnote 1153 in the text">↩</a></p> </li> <li id="fn:1154"> <p>Another thing <a class="footnote-backref" href="#fnref:1154" rev="footnote" title="Jump back to footnote 1154 in the text">↩</a></p> </li> <li id="fn:1155"> <p>Another thing <a class="footnote-backref" href="#fnref:1155" rev="footnote" title="Jump back to footnote 1155 in the text">↩</a></p> </li> <li id="fn:1156"> <p>Another thing <a class="footnote-backref" href="#fnref:1156" rev="footnote" title="Jump back to footnote 1156 in the text">↩</a></p> </li> <li id="fn:1157"> <p>Another thing <a class="footnote-backref" href="#fnref:1157" rev="footnote" title="Jump back to footnote 1157 in the text">↩</a></p> </li> <li id="fn:1158"> <p>Another thing <a class="footnote-backref" href="#fnref:1158" rev="footnote" title="Jump back to footnote 1158 in the text">↩</a></p> </li> <li id="fn:1159"> <p>Another thing <a class="footnote-backref" href="#fnref:1159" rev="footnote" title="Jump back to footnote 1159 in the text">↩</a></p> </li> <li id="fn:1160"> <p>Another thing <a class="footnote-backref" href="#fnref:1160" rev="footnote" title="Jump back to footnote 1160 in the text">↩</a></p> </li> <li id="fn:1161"> <p>Another thing <a class="footnote-backref" href="#fnref:1161" rev="footnote" title="Jump back to footnote 1161 in the text">↩</a></p> </li> <li id="fn:1162"> <p>Another thing <a class="footnote-backref" href="#fnref:1162" rev="footnote" title="Jump back to footnote 1162 in the text">↩</a></p> </li> <li id="fn:1163"> <p>Another thing <a class="footnote-backref" href="#fnref:1163" rev="footnote" title="Jump back to footnote 1163 in the text">↩</a></p> </li> <li id="fn:1164"> <p>Another thing <a class="footnote-backref" href="#fnref:1164" rev="footnote" title="Jump back to footnote 1164 in the text">↩</a></p> </li> <li id="fn:1165"> <p>Another thing <a class="footnote-backref" href="#fnref:1165" rev="footnote" title="Jump back to footnote 1165 in the text">↩</a></p> </li> <li id="fn:1166"> <p>Another thing <a class="footnote-backref" href="#fnref:1166" rev="footnote" title="Jump back to footnote 1166 in the text">↩</a></p> </li> <li id="fn:1167"> <p>Another thing <a class="footnote-backref" href="#fnref:1167" rev="footnote" title="Jump back to footnote 1167 in the text">↩</a></p> </li> <li id="fn:1168"> <p>Another thing <a class="footnote-backref" href="#fnref:1168" rev="footnote" title="Jump back to footnote 1168 in the text">↩</a></p> </li> <li id="fn:1169"> <p>Another thing <a class="footnote-backref" href="#fnref:1169" rev="footnote" title="Jump back to footnote 1169 in the text">↩</a></p> </li> <li id="fn:1170"> <p>Another thing <a class="footnote-backref" href="#fnref:1170" rev="footnote" title="Jump back to footnote 1170 in the text">↩</a></p> </li> <li id="fn:1171"> <p>Another thing <a class="footnote-backref" href="#fnref:1171" rev="footnote" title="Jump back to footnote 1171 in the text">↩</a></p> </li> <li id="fn:1172"> <p>Another thing <a class="footnote-backref" href="#fnref:1172" rev="footnote" title="Jump back to footnote 1172 in the text">↩</a></p> </li> <li id="fn:1173"> <p>Another thing <a class="footnote-backref" href="#fnref:1173" rev="footnote" title="Jump back to footnote 1173 in the text">↩</a></p> </li> <li id="fn:1174"> <p>Another thing <a class="footnote-backref" href="#fnref:1174" rev="footnote" title="Jump back to footnote 1174 in the text">↩</a></p> </li> <li id="fn:1175"> <p>Another thing <a class="footnote-backref" href="#fnref:1175" rev="footnote" title="Jump back to footnote 1175 in the text">↩</a></p> </li> <li id="fn:1176"> <p>Another thing <a class="footnote-backref" href="#fnref:1176" rev="footnote" title="Jump back to footnote 1176 in the text">↩</a></p> </li> <li id="fn:1177"> <p>Another thing <a class="footnote-backref" href="#fnref:1177" rev="footnote" title="Jump back to footnote 1177 in the text">↩</a></p> </li> <li id="fn:1178"> <p>Another thing <a class="footnote-backref" href="#fnref:1178" rev="footnote" title="Jump back to footnote 1178 in the text">↩</a></p> </li> <li id="fn:1179"> <p>Another thing <a class="footnote-backref" href="#fnref:1179" rev="footnote" title="Jump back to footnote 1179 in the text">↩</a></p> </li> <li id="fn:1180"> <p>Another thing <a class="footnote-backref" href="#fnref:1180" rev="footnote" title="Jump back to footnote 1180 in the text">↩</a></p> </li> <li id="fn:1181"> <p>Another thing <a class="footnote-backref" href="#fnref:1181" rev="footnote" title="Jump back to footnote 1181 in the text">↩</a></p> </li> <li id="fn:1182"> <p>Another thing <a class="footnote-backref" href="#fnref:1182" rev="footnote" title="Jump back to footnote 1182 in the text">↩</a></p> </li> <li id="fn:1183"> <p>Another thing <a class="footnote-backref" href="#fnref:1183" rev="footnote" title="Jump back to footnote 1183 in the text">↩</a></p> </li> <li id="fn:1184"> <p>Another thing <a class="footnote-backref" href="#fnref:1184" rev="footnote" title="Jump back to footnote 1184 in the text">↩</a></p> </li> <li id="fn:1185"> <p>Another thing <a class="footnote-backref" href="#fnref:1185" rev="footnote" title="Jump back to footnote 1185 in the text">↩</a></p> </li> <li id="fn:1186"> <p>Another thing <a class="footnote-backref" href="#fnref:1186" rev="footnote" title="Jump back to footnote 1186 in the text">↩</a></p> </li> <li id="fn:1187"> <p>Another thing <a class="footnote-backref" href="#fnref:1187" rev="footnote" title="Jump back to footnote 1187 in the text">↩</a></p> </li> <li id="fn:1188"> <p>Another thing <a class="footnote-backref" href="#fnref:1188" rev="footnote" title="Jump back to footnote 1188 in the text">↩</a></p> </li> <li id="fn:1189"> <p>Another thing <a class="footnote-backref" href="#fnref:1189" rev="footnote" title="Jump back to footnote 1189 in the text">↩</a></p> </li> <li id="fn:1190"> <p>Another thing <a class="footnote-backref" href="#fnref:1190" rev="footnote" title="Jump back to footnote 1190 in the text">↩</a></p> </li> <li id="fn:1191"> <p>Another thing <a class="footnote-backref" href="#fnref:1191" rev="footnote" title="Jump back to footnote 1191 in the text">↩</a></p> </li> <li id="fn:1192"> <p>Another thing <a class="footnote-backref" href="#fnref:1192" rev="footnote" title="Jump back to footnote 1192 in the text">↩</a></p> </li> <li id="fn:1193"> <p>Another thing <a class="footnote-backref" href="#fnref:1193" rev="footnote" title="Jump back to footnote 1193 in the text">↩</a></p> </li> <li id="fn:1194"> <p>Another thing <a class="footnote-backref" href="#fnref:1194" rev="footnote" title="Jump back to footnote 1194 in the text">↩</a></p> </li> <li id="fn:1195"> <p>Another thing <a class="footnote-backref" href="#fnref:1195" rev="footnote" title="Jump back to footnote 1195 in the text">↩</a></p> </li> <li id="fn:1196"> <p>Another thing <a class="footnote-backref" href="#fnref:1196" rev="footnote" title="Jump back to footnote 1196 in the text">↩</a></p> </li> <li id="fn:1197"> <p>Another thing <a class="footnote-backref" href="#fnref:1197" rev="footnote" title="Jump back to footnote 1197 in the text">↩</a></p> </li> <li id="fn:1198"> <p>Another thing <a class="footnote-backref" href="#fnref:1198" rev="footnote" title="Jump back to footnote 1198 in the text">↩</a></p> </li> <li id="fn:1199"> <p>Another thing <a class="footnote-backref" href="#fnref:1199" rev="footnote" title="Jump back to footnote 1199 in the text">↩</a></p> </li> </ol> </div>���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������Markdown-2.4/tests/extensions/extra/footnote_many_footnotes.txt�������������������������������������0000666�0000000�0000000�00000147314�11756571172�023527� 0����������������������������������������������������������������������������������������������������ustar �����������������������������������������������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������Something[^1] Something[^2] Something[^3] Something[^4] Something[^5] Something[^6] Something[^7] Something[^8] Something[^9] Something[^10] Something[^11] Something[^12] Something[^13] Something[^14] Something[^15] Something[^16] Something[^17] Something[^18] Something[^19] Something[^20] Something[^21] Something[^22] Something[^23] Something[^24] Something[^25] Something[^26] Something[^27] Something[^28] Something[^29] Something[^30] Something[^31] Something[^32] Something[^33] Something[^34] Something[^35] Something[^36] Something[^37] Something[^38] Something[^39] Something[^40] Something[^41] Something[^42] Something[^43] Something[^44] Something[^45] Something[^46] Something[^47] Something[^48] Something[^49] Something[^50] Something[^51] Something[^52] Something[^53] Something[^54] Something[^55] Something[^56] Something[^57] Something[^58] Something[^59] Something[^60] Something[^61] Something[^62] Something[^63] Something[^64] Something[^65] Something[^66] Something[^67] Something[^68] Something[^69] Something[^70] Something[^71] Something[^72] Something[^73] Something[^74] Something[^75] Something[^76] Something[^77] Something[^78] Something[^79] Something[^80] Something[^81] Something[^82] Something[^83] Something[^84] Something[^85] Something[^86] Something[^87] Something[^88] Something[^89] Something[^90] Something[^91] Something[^92] Something[^93] Something[^94] Something[^95] Something[^96] Something[^97] Something[^98] Something[^99] Something[^100] Something[^101] Something[^102] Something[^103] Something[^104] Something[^105] Something[^106] Something[^107] Something[^108] Something[^109] Something[^110] Something[^111] Something[^112] Something[^113] Something[^114] Something[^115] Something[^116] Something[^117] Something[^118] Something[^119] Something[^120] Something[^121] Something[^122] Something[^123] Something[^124] Something[^125] Something[^126] Something[^127] Something[^128] Something[^129] Something[^130] Something[^131] Something[^132] Something[^133] Something[^134] Something[^135] Something[^136] Something[^137] Something[^138] Something[^139] Something[^140] Something[^141] Something[^142] Something[^143] Something[^144] Something[^145] Something[^146] Something[^147] Something[^148] Something[^149] Something[^150] Something[^151] Something[^152] Something[^153] Something[^154] Something[^155] Something[^156] Something[^157] Something[^158] Something[^159] Something[^160] Something[^161] Something[^162] Something[^163] Something[^164] Something[^165] Something[^166] Something[^167] Something[^168] Something[^169] Something[^170] Something[^171] Something[^172] Something[^173] Something[^174] Something[^175] Something[^176] Something[^177] Something[^178] Something[^179] Something[^180] Something[^181] Something[^182] Something[^183] Something[^184] Something[^185] Something[^186] Something[^187] Something[^188] Something[^189] Something[^190] Something[^191] Something[^192] Something[^193] Something[^194] Something[^195] Something[^196] Something[^197] Something[^198] Something[^199] Something[^200] Something[^201] Something[^202] Something[^203] Something[^204] Something[^205] Something[^206] Something[^207] Something[^208] Something[^209] Something[^210] Something[^211] Something[^212] Something[^213] Something[^214] Something[^215] Something[^216] Something[^217] Something[^218] Something[^219] Something[^220] Something[^221] Something[^222] Something[^223] Something[^224] Something[^225] Something[^226] Something[^227] Something[^228] Something[^229] Something[^230] Something[^231] Something[^232] Something[^233] Something[^234] Something[^235] Something[^236] Something[^237] Something[^238] Something[^239] Something[^240] Something[^241] Something[^242] Something[^243] Something[^244] Something[^245] Something[^246] Something[^247] Something[^248] Something[^249] Something[^250] Something[^251] Something[^252] Something[^253] Something[^254] Something[^255] Something[^256] Something[^257] Something[^258] Something[^259] Something[^260] Something[^261] Something[^262] Something[^263] Something[^264] Something[^265] Something[^266] Something[^267] Something[^268] Something[^269] Something[^270] Something[^271] Something[^272] Something[^273] Something[^274] Something[^275] Something[^276] Something[^277] Something[^278] Something[^279] Something[^280] Something[^281] Something[^282] Something[^283] Something[^284] Something[^285] Something[^286] Something[^287] Something[^288] Something[^289] Something[^290] Something[^291] Something[^292] Something[^293] Something[^294] Something[^295] Something[^296] Something[^297] Something[^298] Something[^299] Something[^300] Something[^301] Something[^302] Something[^303] Something[^304] Something[^305] Something[^306] Something[^307] Something[^308] Something[^309] Something[^310] Something[^311] Something[^312] Something[^313] Something[^314] Something[^315] Something[^316] Something[^317] Something[^318] Something[^319] Something[^320] Something[^321] Something[^322] Something[^323] Something[^324] Something[^325] Something[^326] Something[^327] Something[^328] Something[^329] Something[^330] Something[^331] Something[^332] Something[^333] Something[^334] Something[^335] Something[^336] Something[^337] Something[^338] Something[^339] Something[^340] Something[^341] Something[^342] Something[^343] Something[^344] Something[^345] Something[^346] Something[^347] Something[^348] Something[^349] Something[^350] Something[^351] Something[^352] Something[^353] Something[^354] Something[^355] Something[^356] Something[^357] Something[^358] Something[^359] Something[^360] Something[^361] Something[^362] Something[^363] Something[^364] Something[^365] Something[^366] Something[^367] Something[^368] Something[^369] Something[^370] Something[^371] Something[^372] Something[^373] Something[^374] Something[^375] Something[^376] Something[^377] Something[^378] Something[^379] Something[^380] Something[^381] Something[^382] Something[^383] Something[^384] Something[^385] Something[^386] Something[^387] Something[^388] Something[^389] Something[^390] Something[^391] Something[^392] Something[^393] Something[^394] Something[^395] Something[^396] Something[^397] Something[^398] Something[^399] Something[^400] Something[^401] Something[^402] Something[^403] Something[^404] Something[^405] Something[^406] Something[^407] Something[^408] Something[^409] Something[^410] Something[^411] Something[^412] Something[^413] Something[^414] Something[^415] Something[^416] Something[^417] Something[^418] Something[^419] Something[^420] Something[^421] Something[^422] Something[^423] Something[^424] Something[^425] Something[^426] Something[^427] Something[^428] Something[^429] Something[^430] Something[^431] Something[^432] Something[^433] Something[^434] Something[^435] Something[^436] Something[^437] Something[^438] Something[^439] Something[^440] Something[^441] Something[^442] Something[^443] Something[^444] Something[^445] Something[^446] Something[^447] Something[^448] Something[^449] Something[^450] Something[^451] Something[^452] Something[^453] Something[^454] Something[^455] Something[^456] Something[^457] Something[^458] Something[^459] Something[^460] Something[^461] Something[^462] Something[^463] Something[^464] Something[^465] Something[^466] Something[^467] Something[^468] Something[^469] Something[^470] Something[^471] Something[^472] Something[^473] Something[^474] Something[^475] Something[^476] Something[^477] Something[^478] Something[^479] Something[^480] Something[^481] Something[^482] Something[^483] Something[^484] Something[^485] Something[^486] Something[^487] Something[^488] Something[^489] Something[^490] Something[^491] Something[^492] Something[^493] Something[^494] Something[^495] Something[^496] Something[^497] Something[^498] Something[^499] Something[^500] Something[^501] Something[^502] Something[^503] Something[^504] Something[^505] Something[^506] Something[^507] Something[^508] Something[^509] Something[^510] Something[^511] Something[^512] Something[^513] Something[^514] Something[^515] Something[^516] Something[^517] Something[^518] Something[^519] Something[^520] Something[^521] Something[^522] Something[^523] Something[^524] Something[^525] Something[^526] Something[^527] Something[^528] Something[^529] Something[^530] Something[^531] Something[^532] Something[^533] Something[^534] Something[^535] Something[^536] Something[^537] Something[^538] Something[^539] Something[^540] Something[^541] Something[^542] Something[^543] Something[^544] Something[^545] Something[^546] Something[^547] Something[^548] Something[^549] Something[^550] Something[^551] Something[^552] Something[^553] Something[^554] Something[^555] Something[^556] Something[^557] Something[^558] Something[^559] Something[^560] Something[^561] Something[^562] Something[^563] Something[^564] Something[^565] Something[^566] Something[^567] Something[^568] Something[^569] Something[^570] Something[^571] Something[^572] Something[^573] Something[^574] Something[^575] Something[^576] Something[^577] Something[^578] Something[^579] Something[^580] Something[^581] Something[^582] Something[^583] Something[^584] Something[^585] Something[^586] Something[^587] Something[^588] Something[^589] Something[^590] Something[^591] Something[^592] Something[^593] Something[^594] Something[^595] Something[^596] Something[^597] Something[^598] Something[^599] Something[^600] Something[^601] Something[^602] Something[^603] Something[^604] Something[^605] Something[^606] Something[^607] Something[^608] Something[^609] Something[^610] Something[^611] Something[^612] Something[^613] Something[^614] Something[^615] Something[^616] Something[^617] Something[^618] Something[^619] Something[^620] Something[^621] Something[^622] Something[^623] Something[^624] Something[^625] Something[^626] Something[^627] Something[^628] Something[^629] Something[^630] Something[^631] Something[^632] Something[^633] Something[^634] Something[^635] Something[^636] Something[^637] Something[^638] Something[^639] Something[^640] Something[^641] Something[^642] Something[^643] Something[^644] Something[^645] Something[^646] Something[^647] Something[^648] Something[^649] Something[^650] Something[^651] Something[^652] Something[^653] Something[^654] Something[^655] Something[^656] Something[^657] Something[^658] Something[^659] Something[^660] Something[^661] Something[^662] Something[^663] Something[^664] Something[^665] Something[^666] Something[^667] Something[^668] Something[^669] Something[^670] Something[^671] Something[^672] Something[^673] Something[^674] Something[^675] Something[^676] Something[^677] Something[^678] Something[^679] Something[^680] Something[^681] Something[^682] Something[^683] Something[^684] Something[^685] Something[^686] Something[^687] Something[^688] Something[^689] Something[^690] Something[^691] Something[^692] Something[^693] Something[^694] Something[^695] Something[^696] Something[^697] Something[^698] Something[^699] Something[^700] Something[^701] Something[^702] Something[^703] Something[^704] Something[^705] Something[^706] Something[^707] Something[^708] Something[^709] Something[^710] Something[^711] Something[^712] Something[^713] Something[^714] Something[^715] Something[^716] Something[^717] Something[^718] Something[^719] Something[^720] Something[^721] Something[^722] Something[^723] Something[^724] Something[^725] Something[^726] Something[^727] Something[^728] Something[^729] Something[^730] Something[^731] Something[^732] Something[^733] Something[^734] Something[^735] Something[^736] Something[^737] Something[^738] Something[^739] Something[^740] Something[^741] Something[^742] Something[^743] Something[^744] Something[^745] Something[^746] Something[^747] Something[^748] Something[^749] Something[^750] Something[^751] Something[^752] Something[^753] Something[^754] Something[^755] Something[^756] Something[^757] Something[^758] Something[^759] Something[^760] Something[^761] Something[^762] Something[^763] Something[^764] Something[^765] Something[^766] Something[^767] Something[^768] Something[^769] Something[^770] Something[^771] Something[^772] Something[^773] Something[^774] Something[^775] Something[^776] Something[^777] Something[^778] Something[^779] Something[^780] Something[^781] Something[^782] Something[^783] Something[^784] Something[^785] Something[^786] Something[^787] Something[^788] Something[^789] Something[^790] Something[^791] Something[^792] Something[^793] Something[^794] Something[^795] Something[^796] Something[^797] Something[^798] Something[^799] Something[^800] Something[^801] Something[^802] Something[^803] Something[^804] Something[^805] Something[^806] Something[^807] Something[^808] Something[^809] Something[^810] Something[^811] Something[^812] Something[^813] Something[^814] Something[^815] Something[^816] Something[^817] Something[^818] Something[^819] Something[^820] Something[^821] Something[^822] Something[^823] Something[^824] Something[^825] Something[^826] Something[^827] Something[^828] Something[^829] Something[^830] Something[^831] Something[^832] Something[^833] Something[^834] Something[^835] Something[^836] Something[^837] Something[^838] Something[^839] Something[^840] Something[^841] Something[^842] Something[^843] Something[^844] Something[^845] Something[^846] Something[^847] Something[^848] Something[^849] Something[^850] Something[^851] Something[^852] Something[^853] Something[^854] Something[^855] Something[^856] Something[^857] Something[^858] Something[^859] Something[^860] Something[^861] Something[^862] Something[^863] Something[^864] Something[^865] Something[^866] Something[^867] Something[^868] Something[^869] Something[^870] Something[^871] Something[^872] Something[^873] Something[^874] Something[^875] Something[^876] Something[^877] Something[^878] Something[^879] Something[^880] Something[^881] Something[^882] Something[^883] Something[^884] Something[^885] Something[^886] Something[^887] Something[^888] Something[^889] Something[^890] Something[^891] Something[^892] Something[^893] Something[^894] Something[^895] Something[^896] Something[^897] Something[^898] Something[^899] Something[^900] Something[^901] Something[^902] Something[^903] Something[^904] Something[^905] Something[^906] Something[^907] Something[^908] Something[^909] Something[^910] Something[^911] Something[^912] Something[^913] Something[^914] Something[^915] Something[^916] Something[^917] Something[^918] Something[^919] Something[^920] Something[^921] Something[^922] Something[^923] Something[^924] Something[^925] Something[^926] Something[^927] Something[^928] Something[^929] Something[^930] Something[^931] Something[^932] Something[^933] Something[^934] Something[^935] Something[^936] Something[^937] Something[^938] Something[^939] Something[^940] Something[^941] Something[^942] Something[^943] Something[^944] Something[^945] Something[^946] Something[^947] Something[^948] Something[^949] Something[^950] Something[^951] Something[^952] Something[^953] Something[^954] Something[^955] Something[^956] Something[^957] Something[^958] Something[^959] Something[^960] Something[^961] Something[^962] Something[^963] Something[^964] Something[^965] Something[^966] Something[^967] Something[^968] Something[^969] Something[^970] Something[^971] Something[^972] Something[^973] Something[^974] Something[^975] Something[^976] Something[^977] Something[^978] Something[^979] Something[^980] Something[^981] Something[^982] Something[^983] Something[^984] Something[^985] Something[^986] Something[^987] Something[^988] Something[^989] Something[^990] Something[^991] Something[^992] Something[^993] Something[^994] Something[^995] Something[^996] Something[^997] Something[^998] Something[^999] Something[^1000] Something[^1001] Something[^1002] Something[^1003] Something[^1004] Something[^1005] Something[^1006] Something[^1007] Something[^1008] Something[^1009] Something[^1010] Something[^1011] Something[^1012] Something[^1013] Something[^1014] Something[^1015] Something[^1016] Something[^1017] Something[^1018] Something[^1019] Something[^1020] Something[^1021] Something[^1022] Something[^1023] Something[^1024] Something[^1025] Something[^1026] Something[^1027] Something[^1028] Something[^1029] Something[^1030] Something[^1031] Something[^1032] Something[^1033] Something[^1034] Something[^1035] Something[^1036] Something[^1037] Something[^1038] Something[^1039] Something[^1040] Something[^1041] Something[^1042] Something[^1043] Something[^1044] Something[^1045] Something[^1046] Something[^1047] Something[^1048] Something[^1049] Something[^1050] Something[^1051] Something[^1052] Something[^1053] Something[^1054] Something[^1055] Something[^1056] Something[^1057] Something[^1058] Something[^1059] Something[^1060] Something[^1061] Something[^1062] Something[^1063] Something[^1064] Something[^1065] Something[^1066] Something[^1067] Something[^1068] Something[^1069] Something[^1070] Something[^1071] Something[^1072] Something[^1073] Something[^1074] Something[^1075] Something[^1076] Something[^1077] Something[^1078] Something[^1079] Something[^1080] Something[^1081] Something[^1082] Something[^1083] Something[^1084] Something[^1085] Something[^1086] Something[^1087] Something[^1088] Something[^1089] Something[^1090] Something[^1091] Something[^1092] Something[^1093] Something[^1094] Something[^1095] Something[^1096] Something[^1097] Something[^1098] Something[^1099] Something[^1100] Something[^1101] Something[^1102] Something[^1103] Something[^1104] Something[^1105] Something[^1106] Something[^1107] Something[^1108] Something[^1109] Something[^1110] Something[^1111] Something[^1112] Something[^1113] Something[^1114] Something[^1115] Something[^1116] Something[^1117] Something[^1118] Something[^1119] Something[^1120] Something[^1121] Something[^1122] Something[^1123] Something[^1124] Something[^1125] Something[^1126] Something[^1127] Something[^1128] Something[^1129] Something[^1130] Something[^1131] Something[^1132] Something[^1133] Something[^1134] Something[^1135] Something[^1136] Something[^1137] Something[^1138] Something[^1139] Something[^1140] Something[^1141] Something[^1142] Something[^1143] Something[^1144] Something[^1145] Something[^1146] Something[^1147] Something[^1148] Something[^1149] Something[^1150] Something[^1151] Something[^1152] Something[^1153] Something[^1154] Something[^1155] Something[^1156] Something[^1157] Something[^1158] Something[^1159] Something[^1160] Something[^1161] Something[^1162] Something[^1163] Something[^1164] Something[^1165] Something[^1166] Something[^1167] Something[^1168] Something[^1169] Something[^1170] Something[^1171] Something[^1172] Something[^1173] Something[^1174] Something[^1175] Something[^1176] Something[^1177] Something[^1178] Something[^1179] Something[^1180] Something[^1181] Something[^1182] Something[^1183] Something[^1184] Something[^1185] Something[^1186] Something[^1187] Something[^1188] Something[^1189] Something[^1190] Something[^1191] Something[^1192] Something[^1193] Something[^1194] Something[^1195] Something[^1196] Something[^1197] Something[^1198] Something[^1199] [^1]: Another thing [^2]: Another thing [^3]: Another thing [^4]: Another thing [^5]: Another thing [^6]: Another thing [^7]: Another thing [^8]: Another thing [^9]: Another thing [^10]: Another thing [^11]: Another thing [^12]: Another thing [^13]: Another thing [^14]: Another thing [^15]: Another thing [^16]: Another thing [^17]: Another thing [^18]: Another thing [^19]: Another thing [^20]: Another thing [^21]: Another thing [^22]: Another thing [^23]: Another thing [^24]: Another thing [^25]: Another thing [^26]: Another thing [^27]: Another thing [^28]: Another thing [^29]: Another thing [^30]: Another thing [^31]: Another thing [^32]: Another thing [^33]: Another thing [^34]: Another thing [^35]: Another thing [^36]: Another thing [^37]: Another thing [^38]: Another thing [^39]: Another thing [^40]: Another thing [^41]: Another thing [^42]: Another thing [^43]: Another thing [^44]: Another thing [^45]: Another thing [^46]: Another thing [^47]: Another thing [^48]: Another thing [^49]: Another thing [^50]: Another thing [^51]: Another thing [^52]: Another thing [^53]: Another thing [^54]: Another thing [^55]: Another thing [^56]: Another thing [^57]: Another thing [^58]: Another thing [^59]: Another thing [^60]: Another thing [^61]: Another thing [^62]: Another thing [^63]: Another thing [^64]: Another thing [^65]: Another thing [^66]: Another thing [^67]: Another thing [^68]: Another thing [^69]: Another thing [^70]: Another thing [^71]: Another thing [^72]: Another thing [^73]: Another thing [^74]: Another thing [^75]: Another thing [^76]: Another thing [^77]: Another thing [^78]: Another thing [^79]: Another thing [^80]: Another thing [^81]: Another thing [^82]: Another thing [^83]: Another thing [^84]: Another thing [^85]: Another thing [^86]: Another thing [^87]: Another thing [^88]: Another thing [^89]: Another thing [^90]: Another thing [^91]: Another thing [^92]: Another thing [^93]: Another thing [^94]: Another thing [^95]: Another thing [^96]: Another thing [^97]: Another thing [^98]: Another thing [^99]: Another thing [^100]: Another thing [^101]: Another thing [^102]: Another thing [^103]: Another thing [^104]: Another thing [^105]: Another thing [^106]: Another thing [^107]: Another thing [^108]: Another thing [^109]: Another thing [^110]: Another thing [^111]: Another thing [^112]: Another thing [^113]: Another thing [^114]: Another thing [^115]: Another thing [^116]: Another thing [^117]: Another thing [^118]: Another thing [^119]: Another thing [^120]: Another thing [^121]: Another thing [^122]: Another thing [^123]: Another thing [^124]: Another thing [^125]: Another thing [^126]: Another thing [^127]: Another thing [^128]: Another thing [^129]: Another thing [^130]: Another thing [^131]: Another thing [^132]: Another thing [^133]: Another thing [^134]: Another thing [^135]: Another thing [^136]: Another thing [^137]: Another thing [^138]: Another thing [^139]: Another thing [^140]: Another thing [^141]: Another thing [^142]: Another thing [^143]: Another thing [^144]: Another thing [^145]: Another thing [^146]: Another thing [^147]: Another thing [^148]: Another thing [^149]: Another thing [^150]: Another thing [^151]: Another thing [^152]: Another thing [^153]: Another thing [^154]: Another thing [^155]: Another thing [^156]: Another thing [^157]: Another thing [^158]: Another thing [^159]: Another thing [^160]: Another thing [^161]: Another thing [^162]: Another thing [^163]: Another thing [^164]: Another thing [^165]: Another thing [^166]: Another thing [^167]: Another thing [^168]: Another thing [^169]: Another thing [^170]: Another thing [^171]: Another thing [^172]: Another thing [^173]: Another thing [^174]: Another thing [^175]: Another thing [^176]: Another thing [^177]: Another thing [^178]: Another thing [^179]: Another thing [^180]: Another thing [^181]: Another thing [^182]: Another thing [^183]: Another thing [^184]: Another thing [^185]: Another thing [^186]: Another thing [^187]: Another thing [^188]: Another thing [^189]: Another thing [^190]: Another thing [^191]: Another thing [^192]: Another thing [^193]: Another thing [^194]: Another thing [^195]: Another thing [^196]: Another thing [^197]: Another thing [^198]: Another thing [^199]: Another thing [^200]: Another thing [^201]: Another thing [^202]: Another thing [^203]: Another thing [^204]: Another thing [^205]: Another thing [^206]: Another thing [^207]: Another thing [^208]: Another thing [^209]: Another thing [^210]: Another thing [^211]: Another thing [^212]: Another thing [^213]: Another thing [^214]: Another thing [^215]: Another thing [^216]: Another thing [^217]: Another thing [^218]: Another thing [^219]: Another thing [^220]: Another thing [^221]: Another thing [^222]: Another thing [^223]: Another thing [^224]: Another thing [^225]: Another thing [^226]: Another thing [^227]: Another thing [^228]: Another thing [^229]: Another thing [^230]: Another thing [^231]: Another thing [^232]: Another thing [^233]: Another thing [^234]: Another thing [^235]: Another thing [^236]: Another thing [^237]: Another thing [^238]: Another thing [^239]: Another thing [^240]: Another thing [^241]: Another thing [^242]: Another thing [^243]: Another thing [^244]: Another thing [^245]: Another thing [^246]: Another thing [^247]: Another thing [^248]: Another thing [^249]: Another thing [^250]: Another thing [^251]: Another thing [^252]: Another thing [^253]: Another thing [^254]: Another thing [^255]: Another thing [^256]: Another thing [^257]: Another thing [^258]: Another thing [^259]: Another thing [^260]: Another thing [^261]: Another thing [^262]: Another thing [^263]: Another thing [^264]: Another thing [^265]: Another thing [^266]: Another thing [^267]: Another thing [^268]: Another thing [^269]: Another thing [^270]: Another thing [^271]: Another thing [^272]: Another thing [^273]: Another thing [^274]: Another thing [^275]: Another thing [^276]: Another thing [^277]: Another thing [^278]: Another thing [^279]: Another thing [^280]: Another thing [^281]: Another thing [^282]: Another thing [^283]: Another thing [^284]: Another thing [^285]: Another thing [^286]: Another thing [^287]: Another thing [^288]: Another thing [^289]: Another thing [^290]: Another thing [^291]: Another thing [^292]: Another thing [^293]: Another thing [^294]: Another thing [^295]: Another thing [^296]: Another thing [^297]: Another thing [^298]: Another thing [^299]: Another thing [^300]: Another thing [^301]: Another thing [^302]: Another thing [^303]: Another thing [^304]: Another thing [^305]: Another thing [^306]: Another thing [^307]: Another thing [^308]: Another thing [^309]: Another thing [^310]: Another thing [^311]: Another thing [^312]: Another thing [^313]: Another thing [^314]: Another thing [^315]: Another thing [^316]: Another thing [^317]: Another thing [^318]: Another thing [^319]: Another thing [^320]: Another thing [^321]: Another thing [^322]: Another thing [^323]: Another thing [^324]: Another thing [^325]: Another thing [^326]: Another thing [^327]: Another thing [^328]: Another thing [^329]: Another thing [^330]: Another thing [^331]: Another thing [^332]: Another thing [^333]: Another thing [^334]: Another thing [^335]: Another thing [^336]: Another thing [^337]: Another thing [^338]: Another thing [^339]: Another thing [^340]: Another thing [^341]: Another thing [^342]: Another thing [^343]: Another thing [^344]: Another thing [^345]: Another thing [^346]: Another thing [^347]: Another thing [^348]: Another thing [^349]: Another thing [^350]: Another thing [^351]: Another thing [^352]: Another thing [^353]: Another thing [^354]: Another thing [^355]: Another thing [^356]: Another thing [^357]: Another thing [^358]: Another thing [^359]: Another thing [^360]: Another thing [^361]: Another thing [^362]: Another thing [^363]: Another thing [^364]: Another thing [^365]: Another thing [^366]: Another thing [^367]: Another thing [^368]: Another thing [^369]: Another thing [^370]: Another thing [^371]: Another thing [^372]: Another thing [^373]: Another thing [^374]: Another thing [^375]: Another thing [^376]: Another thing [^377]: Another thing [^378]: Another thing [^379]: Another thing [^380]: Another thing [^381]: Another thing [^382]: Another thing [^383]: Another thing [^384]: Another thing [^385]: Another thing [^386]: Another thing [^387]: Another thing [^388]: Another thing [^389]: Another thing [^390]: Another thing [^391]: Another thing [^392]: Another thing [^393]: Another thing [^394]: Another thing [^395]: Another thing [^396]: Another thing [^397]: Another thing [^398]: Another thing [^399]: Another thing [^400]: Another thing [^401]: Another thing [^402]: Another thing [^403]: Another thing [^404]: Another thing [^405]: Another thing [^406]: Another thing [^407]: Another thing [^408]: Another thing [^409]: Another thing [^410]: Another thing [^411]: Another thing [^412]: Another thing [^413]: Another thing [^414]: Another thing [^415]: Another thing [^416]: Another thing [^417]: Another thing [^418]: Another thing [^419]: Another thing [^420]: Another thing [^421]: Another thing [^422]: Another thing [^423]: Another thing [^424]: Another thing [^425]: Another thing [^426]: Another thing [^427]: Another thing [^428]: Another thing [^429]: Another thing [^430]: Another thing [^431]: Another thing [^432]: Another thing [^433]: Another thing [^434]: Another thing [^435]: Another thing [^436]: Another thing [^437]: Another thing [^438]: Another thing [^439]: Another thing [^440]: Another thing [^441]: Another thing [^442]: Another thing [^443]: Another thing [^444]: Another thing [^445]: Another thing [^446]: Another thing [^447]: Another thing [^448]: Another thing [^449]: Another thing [^450]: Another thing [^451]: Another thing [^452]: Another thing [^453]: Another thing [^454]: Another thing [^455]: Another thing [^456]: Another thing [^457]: Another thing [^458]: Another thing [^459]: Another thing [^460]: Another thing [^461]: Another thing [^462]: Another thing [^463]: Another thing [^464]: Another thing [^465]: Another thing [^466]: Another thing [^467]: Another thing [^468]: Another thing [^469]: Another thing [^470]: Another thing [^471]: Another thing [^472]: Another thing [^473]: Another thing [^474]: Another thing [^475]: Another thing [^476]: Another thing [^477]: Another thing [^478]: Another thing [^479]: Another thing [^480]: Another thing [^481]: Another thing [^482]: Another thing [^483]: Another thing [^484]: Another thing [^485]: Another thing [^486]: Another thing [^487]: Another thing [^488]: Another thing [^489]: Another thing [^490]: Another thing [^491]: Another thing [^492]: Another thing [^493]: Another thing [^494]: Another thing [^495]: Another thing [^496]: Another thing [^497]: Another thing [^498]: Another thing [^499]: Another thing [^500]: Another thing [^501]: Another thing [^502]: Another thing [^503]: Another thing [^504]: Another thing [^505]: Another thing [^506]: Another thing [^507]: Another thing [^508]: Another thing [^509]: Another thing [^510]: Another thing [^511]: Another thing [^512]: Another thing [^513]: Another thing [^514]: Another thing [^515]: Another thing [^516]: Another thing [^517]: Another thing [^518]: Another thing [^519]: Another thing [^520]: Another thing [^521]: Another thing [^522]: Another thing [^523]: Another thing [^524]: Another thing [^525]: Another thing [^526]: Another thing [^527]: Another thing [^528]: Another thing [^529]: Another thing [^530]: Another thing [^531]: Another thing [^532]: Another thing [^533]: Another thing [^534]: Another thing [^535]: Another thing [^536]: Another thing [^537]: Another thing [^538]: Another thing [^539]: Another thing [^540]: Another thing [^541]: Another thing [^542]: Another thing [^543]: Another thing [^544]: Another thing [^545]: Another thing [^546]: Another thing [^547]: Another thing [^548]: Another thing [^549]: Another thing [^550]: Another thing [^551]: Another thing [^552]: Another thing [^553]: Another thing [^554]: Another thing [^555]: Another thing [^556]: Another thing [^557]: Another thing [^558]: Another thing [^559]: Another thing [^560]: Another thing [^561]: Another thing [^562]: Another thing [^563]: Another thing [^564]: Another thing [^565]: Another thing [^566]: Another thing [^567]: Another thing [^568]: Another thing [^569]: Another thing [^570]: Another thing [^571]: Another thing [^572]: Another thing [^573]: Another thing [^574]: Another thing [^575]: Another thing [^576]: Another thing [^577]: Another thing [^578]: Another thing [^579]: Another thing [^580]: Another thing [^581]: Another thing [^582]: Another thing [^583]: Another thing [^584]: Another thing [^585]: Another thing [^586]: Another thing [^587]: Another thing [^588]: Another thing [^589]: Another thing [^590]: Another thing [^591]: Another thing [^592]: Another thing [^593]: Another thing [^594]: Another thing [^595]: Another thing [^596]: Another thing [^597]: Another thing [^598]: Another thing [^599]: Another thing [^600]: Another thing [^601]: Another thing [^602]: Another thing [^603]: Another thing [^604]: Another thing [^605]: Another thing [^606]: Another thing [^607]: Another thing [^608]: Another thing [^609]: Another thing [^610]: Another thing [^611]: Another thing [^612]: Another thing [^613]: Another thing [^614]: Another thing [^615]: Another thing [^616]: Another thing [^617]: Another thing [^618]: Another thing [^619]: Another thing [^620]: Another thing [^621]: Another thing [^622]: Another thing [^623]: Another thing [^624]: Another thing [^625]: Another thing [^626]: Another thing [^627]: Another thing [^628]: Another thing [^629]: Another thing [^630]: Another thing [^631]: Another thing [^632]: Another thing [^633]: Another thing [^634]: Another thing [^635]: Another thing [^636]: Another thing [^637]: Another thing [^638]: Another thing [^639]: Another thing [^640]: Another thing [^641]: Another thing [^642]: Another thing [^643]: Another thing [^644]: Another thing [^645]: Another thing [^646]: Another thing [^647]: Another thing [^648]: Another thing [^649]: Another thing [^650]: Another thing [^651]: Another thing [^652]: Another thing [^653]: Another thing [^654]: Another thing [^655]: Another thing [^656]: Another thing [^657]: Another thing [^658]: Another thing [^659]: Another thing [^660]: Another thing [^661]: Another thing [^662]: Another thing [^663]: Another thing [^664]: Another thing [^665]: Another thing [^666]: Another thing [^667]: Another thing [^668]: Another thing [^669]: Another thing [^670]: Another thing [^671]: Another thing [^672]: Another thing [^673]: Another thing [^674]: Another thing [^675]: Another thing [^676]: Another thing [^677]: Another thing [^678]: Another thing [^679]: Another thing [^680]: Another thing [^681]: Another thing [^682]: Another thing [^683]: Another thing [^684]: Another thing [^685]: Another thing [^686]: Another thing [^687]: Another thing [^688]: Another thing [^689]: Another thing [^690]: Another thing [^691]: Another thing [^692]: Another thing [^693]: Another thing [^694]: Another thing [^695]: Another thing [^696]: Another thing [^697]: Another thing [^698]: Another thing [^699]: Another thing [^700]: Another thing [^701]: Another thing [^702]: Another thing [^703]: Another thing [^704]: Another thing [^705]: Another thing [^706]: Another thing [^707]: Another thing [^708]: Another thing [^709]: Another thing [^710]: Another thing [^711]: Another thing [^712]: Another thing [^713]: Another thing [^714]: Another thing [^715]: Another thing [^716]: Another thing [^717]: Another thing [^718]: Another thing [^719]: Another thing [^720]: Another thing [^721]: Another thing [^722]: Another thing [^723]: Another thing [^724]: Another thing [^725]: Another thing [^726]: Another thing [^727]: Another thing [^728]: Another thing [^729]: Another thing [^730]: Another thing [^731]: Another thing [^732]: Another thing [^733]: Another thing [^734]: Another thing [^735]: Another thing [^736]: Another thing [^737]: Another thing [^738]: Another thing [^739]: Another thing [^740]: Another thing [^741]: Another thing [^742]: Another thing [^743]: Another thing [^744]: Another thing [^745]: Another thing [^746]: Another thing [^747]: Another thing [^748]: Another thing [^749]: Another thing [^750]: Another thing [^751]: Another thing [^752]: Another thing [^753]: Another thing [^754]: Another thing [^755]: Another thing [^756]: Another thing [^757]: Another thing [^758]: Another thing [^759]: Another thing [^760]: Another thing [^761]: Another thing [^762]: Another thing [^763]: Another thing [^764]: Another thing [^765]: Another thing [^766]: Another thing [^767]: Another thing [^768]: Another thing [^769]: Another thing [^770]: Another thing [^771]: Another thing [^772]: Another thing [^773]: Another thing [^774]: Another thing [^775]: Another thing [^776]: Another thing [^777]: Another thing [^778]: Another thing [^779]: Another thing [^780]: Another thing [^781]: Another thing [^782]: Another thing [^783]: Another thing [^784]: Another thing [^785]: Another thing [^786]: Another thing [^787]: Another thing [^788]: Another thing [^789]: Another thing [^790]: Another thing [^791]: Another thing [^792]: Another thing [^793]: Another thing [^794]: Another thing [^795]: Another thing [^796]: Another thing [^797]: Another thing [^798]: Another thing [^799]: Another thing [^800]: Another thing [^801]: Another thing [^802]: Another thing [^803]: Another thing [^804]: Another thing [^805]: Another thing [^806]: Another thing [^807]: Another thing [^808]: Another thing [^809]: Another thing [^810]: Another thing [^811]: Another thing [^812]: Another thing [^813]: Another thing [^814]: Another thing [^815]: Another thing [^816]: Another thing [^817]: Another thing [^818]: Another thing [^819]: Another thing [^820]: Another thing [^821]: Another thing [^822]: Another thing [^823]: Another thing [^824]: Another thing [^825]: Another thing [^826]: Another thing [^827]: Another thing [^828]: Another thing [^829]: Another thing [^830]: Another thing [^831]: Another thing [^832]: Another thing [^833]: Another thing [^834]: Another thing [^835]: Another thing [^836]: Another thing [^837]: Another thing [^838]: Another thing [^839]: Another thing [^840]: Another thing [^841]: Another thing [^842]: Another thing [^843]: Another thing [^844]: Another thing [^845]: Another thing [^846]: Another thing [^847]: Another thing [^848]: Another thing [^849]: Another thing [^850]: Another thing [^851]: Another thing [^852]: Another thing [^853]: Another thing [^854]: Another thing [^855]: Another thing [^856]: Another thing [^857]: Another thing [^858]: Another thing [^859]: Another thing [^860]: Another thing [^861]: Another thing [^862]: Another thing [^863]: Another thing [^864]: Another thing [^865]: Another thing [^866]: Another thing [^867]: Another thing [^868]: Another thing [^869]: Another thing [^870]: Another thing [^871]: Another thing [^872]: Another thing [^873]: Another thing [^874]: Another thing [^875]: Another thing [^876]: Another thing [^877]: Another thing [^878]: Another thing [^879]: Another thing [^880]: Another thing [^881]: Another thing [^882]: Another thing [^883]: Another thing [^884]: Another thing [^885]: Another thing [^886]: Another thing [^887]: Another thing [^888]: Another thing [^889]: Another thing [^890]: Another thing [^891]: Another thing [^892]: Another thing [^893]: Another thing [^894]: Another thing [^895]: Another thing [^896]: Another thing [^897]: Another thing [^898]: Another thing [^899]: Another thing [^900]: Another thing [^901]: Another thing [^902]: Another thing [^903]: Another thing [^904]: Another thing [^905]: Another thing [^906]: Another thing [^907]: Another thing [^908]: Another thing [^909]: Another thing [^910]: Another thing [^911]: Another thing [^912]: Another thing [^913]: Another thing [^914]: Another thing [^915]: Another thing [^916]: Another thing [^917]: Another thing [^918]: Another thing [^919]: Another thing [^920]: Another thing [^921]: Another thing [^922]: Another thing [^923]: Another thing [^924]: Another thing [^925]: Another thing [^926]: Another thing [^927]: Another thing [^928]: Another thing [^929]: Another thing [^930]: Another thing [^931]: Another thing [^932]: Another thing [^933]: Another thing [^934]: Another thing [^935]: Another thing [^936]: Another thing [^937]: Another thing [^938]: Another thing [^939]: Another thing [^940]: Another thing [^941]: Another thing [^942]: Another thing [^943]: Another thing [^944]: Another thing [^945]: Another thing [^946]: Another thing [^947]: Another thing [^948]: Another thing [^949]: Another thing [^950]: Another thing [^951]: Another thing [^952]: Another thing [^953]: Another thing [^954]: Another thing [^955]: Another thing [^956]: Another thing [^957]: Another thing [^958]: Another thing [^959]: Another thing [^960]: Another thing [^961]: Another thing [^962]: Another thing [^963]: Another thing [^964]: Another thing [^965]: Another thing [^966]: Another thing [^967]: Another thing [^968]: Another thing [^969]: Another thing [^970]: Another thing [^971]: Another thing [^972]: Another thing [^973]: Another thing [^974]: Another thing [^975]: Another thing [^976]: Another thing [^977]: Another thing [^978]: Another thing [^979]: Another thing [^980]: Another thing [^981]: Another thing [^982]: Another thing [^983]: Another thing [^984]: Another thing [^985]: Another thing [^986]: Another thing [^987]: Another thing [^988]: Another thing [^989]: Another thing [^990]: Another thing [^991]: Another thing [^992]: Another thing [^993]: Another thing [^994]: Another thing [^995]: Another thing [^996]: Another thing [^997]: Another thing [^998]: Another thing [^999]: Another thing [^1000]: Another thing [^1001]: Another thing [^1002]: Another thing [^1003]: Another thing [^1004]: Another thing [^1005]: Another thing [^1006]: Another thing [^1007]: Another thing [^1008]: Another thing [^1009]: Another thing [^1010]: Another thing [^1011]: Another thing [^1012]: Another thing [^1013]: Another thing [^1014]: Another thing [^1015]: Another thing [^1016]: Another thing [^1017]: Another thing [^1018]: Another thing [^1019]: Another thing [^1020]: Another thing [^1021]: Another thing [^1022]: Another thing [^1023]: Another thing [^1024]: Another thing [^1025]: Another thing [^1026]: Another thing [^1027]: Another thing [^1028]: Another thing [^1029]: Another thing [^1030]: Another thing [^1031]: Another thing [^1032]: Another thing [^1033]: Another thing [^1034]: Another thing [^1035]: Another thing [^1036]: Another thing [^1037]: Another thing [^1038]: Another thing [^1039]: Another thing [^1040]: Another thing [^1041]: Another thing [^1042]: Another thing [^1043]: Another thing [^1044]: Another thing [^1045]: Another thing [^1046]: Another thing [^1047]: Another thing [^1048]: Another thing [^1049]: Another thing [^1050]: Another thing [^1051]: Another thing [^1052]: Another thing [^1053]: Another thing [^1054]: Another thing [^1055]: Another thing [^1056]: Another thing [^1057]: Another thing [^1058]: Another thing [^1059]: Another thing [^1060]: Another thing [^1061]: Another thing [^1062]: Another thing [^1063]: Another thing [^1064]: Another thing [^1065]: Another thing [^1066]: Another thing [^1067]: Another thing [^1068]: Another thing [^1069]: Another thing [^1070]: Another thing [^1071]: Another thing [^1072]: Another thing [^1073]: Another thing [^1074]: Another thing [^1075]: Another thing [^1076]: Another thing [^1077]: Another thing [^1078]: Another thing [^1079]: Another thing [^1080]: Another thing [^1081]: Another thing [^1082]: Another thing [^1083]: Another thing [^1084]: Another thing [^1085]: Another thing [^1086]: Another thing [^1087]: Another thing [^1088]: Another thing [^1089]: Another thing [^1090]: Another thing [^1091]: Another thing [^1092]: Another thing [^1093]: Another thing [^1094]: Another thing [^1095]: Another thing [^1096]: Another thing [^1097]: Another thing [^1098]: Another thing [^1099]: Another thing [^1100]: Another thing [^1101]: Another thing [^1102]: Another thing [^1103]: Another thing [^1104]: Another thing [^1105]: Another thing [^1106]: Another thing [^1107]: Another thing [^1108]: Another thing [^1109]: Another thing [^1110]: Another thing [^1111]: Another thing [^1112]: Another thing [^1113]: Another thing [^1114]: Another thing [^1115]: Another thing [^1116]: Another thing [^1117]: Another thing [^1118]: Another thing [^1119]: Another thing [^1120]: Another thing [^1121]: Another thing [^1122]: Another thing [^1123]: Another thing [^1124]: Another thing [^1125]: Another thing [^1126]: Another thing [^1127]: Another thing [^1128]: Another thing [^1129]: Another thing [^1130]: Another thing [^1131]: Another thing [^1132]: Another thing [^1133]: Another thing [^1134]: Another thing [^1135]: Another thing [^1136]: Another thing [^1137]: Another thing [^1138]: Another thing [^1139]: Another thing [^1140]: Another thing [^1141]: Another thing [^1142]: Another thing [^1143]: Another thing [^1144]: Another thing [^1145]: Another thing [^1146]: Another thing [^1147]: Another thing [^1148]: Another thing [^1149]: Another thing [^1150]: Another thing [^1151]: Another thing [^1152]: Another thing [^1153]: Another thing [^1154]: Another thing [^1155]: Another thing [^1156]: Another thing [^1157]: Another thing [^1158]: Another thing [^1159]: Another thing [^1160]: Another thing [^1161]: Another thing [^1162]: Another thing [^1163]: Another thing [^1164]: Another thing [^1165]: Another thing [^1166]: Another thing [^1167]: Another thing [^1168]: Another thing [^1169]: Another thing [^1170]: Another thing [^1171]: Another thing [^1172]: Another thing [^1173]: Another thing [^1174]: Another thing [^1175]: Another thing [^1176]: Another thing [^1177]: Another thing [^1178]: Another thing [^1179]: Another thing [^1180]: Another thing [^1181]: Another thing [^1182]: Another thing [^1183]: Another thing [^1184]: Another thing [^1185]: Another thing [^1186]: Another thing [^1187]: Another thing [^1188]: Another thing [^1189]: Another thing [^1190]: Another thing [^1191]: Another thing [^1192]: Another thing [^1193]: Another thing [^1194]: Another thing [^1195]: Another thing [^1196]: Another thing [^1197]: Another thing [^1198]: Another thing [^1199]: Another thing ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������Markdown-2.4/tests/extensions/extra/footnote_placeholder.html���������������������������������������0000666�0000000�0000000�00000000512�12111563027�023040� 0����������������������������������������������������������������������������������������������������ustar �����������������������������������������������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������<div class="footnote"> <hr /> <ol> <li id="fn:1"> <p>A Footnote. <a class="footnote-backref" href="#fnref:1" rev="footnote" title="Jump back to footnote 1 in the text">↩</a></p> </li> </ol> </div> <p>Some text with a footnote<sup id="fnref:1"><a class="footnote-ref" href="#fn:1" rel="footnote">1</a></sup>.</p>��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������Markdown-2.4/tests/extensions/extra/footnote_placeholder.txt����������������������������������������0000666�0000000�0000000�00000000120�11756571172�022724� 0����������������������������������������������������������������������������������������������������ustar �����������������������������������������������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������///Footnotes Go Here/// Some text with a footnote[^1]. [^1]: A Footnote. ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������Markdown-2.4/tests/extensions/extra/loose_def_list.html���������������������������������������������0000666�0000000�0000000�00000000611�12261107557�021643� 0����������������������������������������������������������������������������������������������������ustar �����������������������������������������������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������<p>some text</p> <dl> <dt>term 1</dt> <dd> <p>def 1-1</p> </dd> <dd> <p>def 2-2</p> </dd> <dt>term 2</dt> <dt>term 3</dt> <dd> <p>def 2-1 line 2 of def 2-1</p> </dd> <dd> <p>def 2-2</p> <p>par 2 of def2-2</p> </dd> </dl> <p>more text</p> <dl> <dt>term 4</dt> <dd>not loose</dd> <dt>term 5</dt> <dd> <p>loose</p> </dd> <dt>term 6</dt> <dd>also not loose</dd> </dl>�����������������������������������������������������������������������������������������������������������������������Markdown-2.4/tests/extensions/extra/loose_def_list.txt����������������������������������������������0000666�0000000�0000000�00000000360�12261107557�021517� 0����������������������������������������������������������������������������������������������������ustar �����������������������������������������������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������some text term 1 : def 1-1 : def 2-2 term 2 term 3 : def 2-1 line 2 of def 2-1 : def 2-2 par 2 of def2-2 more text term 4 : not loose term 5 : loose term 6 : also not loose ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������Markdown-2.4/tests/extensions/extra/markdown-syntax.html��������������������������������������������0000666�0000000�0000000�00000077075�11756571172�022047� 0����������������������������������������������������������������������������������������������������ustar �����������������������������������������������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������<h1>Markdown: Syntax</h1> <ul id="ProjectSubmenu"> <li><a href="/projects/markdown/" title="Markdown Project Page">Main</a></li> <li><a href="/projects/markdown/basics" title="Markdown Basics">Basics</a></li> <li><a class="selected" title="Markdown Syntax Documentation">Syntax</a></li> <li><a href="/projects/markdown/license" title="Pricing and License Information">License</a></li> <li><a href="/projects/markdown/dingus" title="Online Markdown Web Form">Dingus</a></li> </ul> <ul> <li><a href="#overview">Overview</a><ul> <li><a href="#philosophy">Philosophy</a></li> <li><a href="#html">Inline HTML</a></li> <li><a href="#autoescape">Automatic Escaping for Special Characters</a></li> </ul> </li> <li><a href="#block">Block Elements</a><ul> <li><a href="#p">Paragraphs and Line Breaks</a></li> <li><a href="#header">Headers</a></li> <li><a href="#blockquote">Blockquotes</a></li> <li><a href="#list">Lists</a></li> <li><a href="#precode">Code Blocks</a></li> <li><a href="#hr">Horizontal Rules</a></li> </ul> </li> <li><a href="#span">Span Elements</a><ul> <li><a href="#link">Links</a></li> <li><a href="#em">Emphasis</a></li> <li><a href="#code">Code</a></li> <li><a href="#img">Images</a></li> </ul> </li> <li><a href="#misc">Miscellaneous</a><ul> <li><a href="#backslash">Backslash Escapes</a></li> <li><a href="#autolink">Automatic Links</a></li> </ul> </li> </ul> <p><strong>Note:</strong> This document is itself written using Markdown; you can <a href="/projects/markdown/syntax.text">see the source for it by adding '.text' to the URL</a>.</p> <hr /> <h2 id="overview">Overview</h2> <h3 id="philosophy">Philosophy</h3> <p>Markdown is intended to be as easy-to-read and easy-to-write as is feasible.</p> <p>Readability, however, is emphasized above all else. A Markdown-formatted document should be publishable as-is, as plain text, without looking like it's been marked up with tags or formatting instructions. While Markdown's syntax has been influenced by several existing text-to-HTML filters -- including <a href="http://docutils.sourceforge.net/mirror/setext.html">Setext</a>, <a href="http://www.aaronsw.com/2002/atx/">atx</a>, <a href="http://textism.com/tools/textile/">Textile</a>, <a href="http://docutils.sourceforge.net/rst.html">reStructuredText</a>, <a href="http://www.triptico.com/software/grutatxt.html">Grutatext</a>, and <a href="http://ettext.taint.org/doc/">EtText</a> -- the single biggest source of inspiration for Markdown's syntax is the format of plain text email.</p> <p>To this end, Markdown's syntax is comprised entirely of punctuation characters, which punctuation characters have been carefully chosen so as to look like what they mean. E.g., asterisks around a word actually look like *emphasis*. Markdown lists look like, well, lists. Even blockquotes look like quoted passages of text, assuming you've ever used email.</p> <h3 id="html">Inline HTML</h3> <p>Markdown's syntax is intended for one purpose: to be used as a format for <em>writing</em> for the web.</p> <p>Markdown is not a replacement for HTML, or even close to it. Its syntax is very small, corresponding only to a very small subset of HTML tags. The idea is <em>not</em> to create a syntax that makes it easier to insert HTML tags. In my opinion, HTML tags are already easy to insert. The idea for Markdown is to make it easy to read, write, and edit prose. HTML is a <em>publishing</em> format; Markdown is a <em>writing</em> format. Thus, Markdown's formatting syntax only addresses issues that can be conveyed in plain text.</p> <p>For any markup that is not covered by Markdown's syntax, you simply use HTML itself. There's no need to preface it or delimit it to indicate that you're switching from Markdown to HTML; you just use the tags.</p> <p>The only restrictions are that block-level HTML elements -- e.g. <code><div></code>, <code><table></code>, <code><pre></code>, <code><p></code>, etc. -- must be separated from surrounding content by blank lines, and the start and end tags of the block should not be indented with tabs or spaces. Markdown is smart enough not to add extra (unwanted) <code><p></code> tags around HTML block-level tags.</p> <p>For example, to add an HTML table to a Markdown article:</p> <pre><code>This is a regular paragraph. <table> <tr> <td>Foo</td> </tr> </table> This is another regular paragraph. </code></pre> <p>Note that Markdown formatting syntax is not processed within block-level HTML tags. E.g., you can't use Markdown-style <code>*emphasis*</code> inside an HTML block.</p> <p>Span-level HTML tags -- e.g. <code><span></code>, <code><cite></code>, or <code><del></code> -- can be used anywhere in a Markdown paragraph, list item, or header. If you want, you can even use HTML tags instead of Markdown formatting; e.g. if you'd prefer to use HTML <code><a></code> or <code><img></code> tags instead of Markdown's link or image syntax, go right ahead.</p> <p>Unlike block-level HTML tags, Markdown syntax <em>is</em> processed within span-level tags.</p> <h3 id="autoescape">Automatic Escaping for Special Characters</h3> <p>In HTML, there are two characters that demand special treatment: <code><</code> and <code>&</code>. Left angle brackets are used to start tags; ampersands are used to denote HTML entities. If you want to use them as literal characters, you must escape them as entities, e.g. <code>&lt;</code>, and <code>&amp;</code>.</p> <p>Ampersands in particular are bedeviling for web writers. If you want to write about 'AT&T', you need to write '<code>AT&amp;T</code>'. You even need to escape ampersands within URLs. Thus, if you want to link to:</p> <pre><code>http://images.google.com/images?num=30&q=larry+bird </code></pre> <p>you need to encode the URL as:</p> <pre><code>http://images.google.com/images?num=30&amp;q=larry+bird </code></pre> <p>in your anchor tag <code>href</code> attribute. Needless to say, this is easy to forget, and is probably the single most common source of HTML validation errors in otherwise well-marked-up web sites.</p> <p>Markdown allows you to use these characters naturally, taking care of all the necessary escaping for you. If you use an ampersand as part of an HTML entity, it remains unchanged; otherwise it will be translated into <code>&amp;</code>.</p> <p>So, if you want to include a copyright symbol in your article, you can write:</p> <pre><code>&copy; </code></pre> <p>and Markdown will leave it alone. But if you write:</p> <pre><code>AT&T </code></pre> <p>Markdown will translate it to:</p> <pre><code>AT&amp;T </code></pre> <p>Similarly, because Markdown supports <a href="#html">inline HTML</a>, if you use angle brackets as delimiters for HTML tags, Markdown will treat them as such. But if you write:</p> <pre><code>4 < 5 </code></pre> <p>Markdown will translate it to:</p> <pre><code>4 &lt; 5 </code></pre> <p>However, inside Markdown code spans and blocks, angle brackets and ampersands are <em>always</em> encoded automatically. This makes it easy to use Markdown to write about HTML code. (As opposed to raw HTML, which is a terrible format for writing about HTML syntax, because every single <code><</code> and <code>&</code> in your example code needs to be escaped.)</p> <hr /> <h2 id="block">Block Elements</h2> <h3 id="p">Paragraphs and Line Breaks</h3> <p>A paragraph is simply one or more consecutive lines of text, separated by one or more blank lines. (A blank line is any line that looks like a blank line -- a line containing nothing but spaces or tabs is considered blank.) Normal paragraphs should not be intended with spaces or tabs.</p> <p>The implication of the "one or more consecutive lines of text" rule is that Markdown supports "hard-wrapped" text paragraphs. This differs significantly from most other text-to-HTML formatters (including Movable Type's "Convert Line Breaks" option) which translate every line break character in a paragraph into a <code><br /></code> tag.</p> <p>When you <em>do</em> want to insert a <code><br /></code> break tag using Markdown, you end a line with two or more spaces, then type return.</p> <p>Yes, this takes a tad more effort to create a <code><br /></code>, but a simplistic "every line break is a <code><br /></code>" rule wouldn't work for Markdown. Markdown's email-style <a href="#blockquote">blockquoting</a> and multi-paragraph <a href="#list">list items</a> work best -- and look better -- when you format them with hard breaks.</p> <h3 id="header">Headers</h3> <p>Markdown supports two styles of headers, <a href="http://docutils.sourceforge.net/mirror/setext.html">Setext</a> and <a href="http://www.aaronsw.com/2002/atx/">atx</a>.</p> <p>Setext-style headers are "underlined" using equal signs (for first-level headers) and dashes (for second-level headers). For example:</p> <pre><code>This is an H1 ============= This is an H2 ------------- </code></pre> <p>Any number of underlining <code>=</code>'s or <code>-</code>'s will work.</p> <p>Atx-style headers use 1-6 hash characters at the start of the line, corresponding to header levels 1-6. For example:</p> <pre><code># This is an H1 ## This is an H2 ###### This is an H6 </code></pre> <p>Optionally, you may "close" atx-style headers. This is purely cosmetic -- you can use this if you think it looks better. The closing hashes don't even need to match the number of hashes used to open the header. (The number of opening hashes determines the header level.) :</p> <pre><code># This is an H1 # ## This is an H2 ## ### This is an H3 ###### </code></pre> <h3 id="blockquote">Blockquotes</h3> <p>Markdown uses email-style <code>></code> characters for blockquoting. If you're familiar with quoting passages of text in an email message, then you know how to create a blockquote in Markdown. It looks best if you hard wrap the text and put a <code>></code> before every line:</p> <pre><code>> This is a blockquote with two paragraphs. Lorem ipsum dolor sit amet, > consectetuer adipiscing elit. Aliquam hendrerit mi posuere lectus. > Vestibulum enim wisi, viverra nec, fringilla in, laoreet vitae, risus. > > Donec sit amet nisl. Aliquam semper ipsum sit amet velit. Suspendisse > id sem consectetuer libero luctus adipiscing. </code></pre> <p>Markdown allows you to be lazy and only put the <code>></code> before the first line of a hard-wrapped paragraph:</p> <pre><code>> This is a blockquote with two paragraphs. Lorem ipsum dolor sit amet, consectetuer adipiscing elit. Aliquam hendrerit mi posuere lectus. Vestibulum enim wisi, viverra nec, fringilla in, laoreet vitae, risus. > Donec sit amet nisl. Aliquam semper ipsum sit amet velit. Suspendisse id sem consectetuer libero luctus adipiscing. </code></pre> <p>Blockquotes can be nested (i.e. a blockquote-in-a-blockquote) by adding additional levels of <code>></code>:</p> <pre><code>> This is the first level of quoting. > > > This is nested blockquote. > > Back to the first level. </code></pre> <p>Blockquotes can contain other Markdown elements, including headers, lists, and code blocks:</p> <pre><code>> ## This is a header. > > 1. This is the first list item. > 2. This is the second list item. > > Here's some example code: > > return shell_exec("echo $input | $markdown_script"); </code></pre> <p>Any decent text editor should make email-style quoting easy. For example, with BBEdit, you can make a selection and choose Increase Quote Level from the Text menu.</p> <h3 id="list">Lists</h3> <p>Markdown supports ordered (numbered) and unordered (bulleted) lists.</p> <p>Unordered lists use asterisks, pluses, and hyphens -- interchangably -- as list markers:</p> <pre><code>* Red * Green * Blue </code></pre> <p>is equivalent to:</p> <pre><code>+ Red + Green + Blue </code></pre> <p>and:</p> <pre><code>- Red - Green - Blue </code></pre> <p>Ordered lists use numbers followed by periods:</p> <pre><code>1. Bird 2. McHale 3. Parish </code></pre> <p>It's important to note that the actual numbers you use to mark the list have no effect on the HTML output Markdown produces. The HTML Markdown produces from the above list is:</p> <pre><code><ol> <li>Bird</li> <li>McHale</li> <li>Parish</li> </ol> </code></pre> <p>If you instead wrote the list in Markdown like this:</p> <pre><code>1. Bird 1. McHale 1. Parish </code></pre> <p>or even:</p> <pre><code>3. Bird 1. McHale 8. Parish </code></pre> <p>you'd get the exact same HTML output. The point is, if you want to, you can use ordinal numbers in your ordered Markdown lists, so that the numbers in your source match the numbers in your published HTML. But if you want to be lazy, you don't have to.</p> <p>If you do use lazy list numbering, however, you should still start the list with the number 1. At some point in the future, Markdown may support starting ordered lists at an arbitrary number.</p> <p>List markers typically start at the left margin, but may be indented by up to three spaces. List markers must be followed by one or more spaces or a tab.</p> <p>To make lists look nice, you can wrap items with hanging indents:</p> <pre><code>* Lorem ipsum dolor sit amet, consectetuer adipiscing elit. Aliquam hendrerit mi posuere lectus. Vestibulum enim wisi, viverra nec, fringilla in, laoreet vitae, risus. * Donec sit amet nisl. Aliquam semper ipsum sit amet velit. Suspendisse id sem consectetuer libero luctus adipiscing. </code></pre> <p>But if you want to be lazy, you don't have to:</p> <pre><code>* Lorem ipsum dolor sit amet, consectetuer adipiscing elit. Aliquam hendrerit mi posuere lectus. Vestibulum enim wisi, viverra nec, fringilla in, laoreet vitae, risus. * Donec sit amet nisl. Aliquam semper ipsum sit amet velit. Suspendisse id sem consectetuer libero luctus adipiscing. </code></pre> <p>If list items are separated by blank lines, Markdown will wrap the items in <code><p></code> tags in the HTML output. For example, this input:</p> <pre><code>* Bird * Magic </code></pre> <p>will turn into:</p> <pre><code><ul> <li>Bird</li> <li>Magic</li> </ul> </code></pre> <p>But this:</p> <pre><code>* Bird * Magic </code></pre> <p>will turn into:</p> <pre><code><ul> <li><p>Bird</p></li> <li><p>Magic</p></li> </ul> </code></pre> <p>List items may consist of multiple paragraphs. Each subsequent paragraph in a list item must be intended by either 4 spaces or one tab:</p> <pre><code>1. This is a list item with two paragraphs. Lorem ipsum dolor sit amet, consectetuer adipiscing elit. Aliquam hendrerit mi posuere lectus. Vestibulum enim wisi, viverra nec, fringilla in, laoreet vitae, risus. Donec sit amet nisl. Aliquam semper ipsum sit amet velit. 2. Suspendisse id sem consectetuer libero luctus adipiscing. </code></pre> <p>It looks nice if you indent every line of the subsequent paragraphs, but here again, Markdown will allow you to be lazy:</p> <pre><code>* This is a list item with two paragraphs. This is the second paragraph in the list item. You're only required to indent the first line. Lorem ipsum dolor sit amet, consectetuer adipiscing elit. * Another item in the same list. </code></pre> <p>To put a blockquote within a list item, the blockquote's <code>></code> delimiters need to be indented:</p> <pre><code>* A list item with a blockquote: > This is a blockquote > inside a list item. </code></pre> <p>To put a code block within a list item, the code block needs to be indented <em>twice</em> -- 8 spaces or two tabs:</p> <pre><code>* A list item with a code block: <code goes here> </code></pre> <p>It's worth noting that it's possible to trigger an ordered list by accident, by writing something like this:</p> <pre><code>1986. What a great season. </code></pre> <p>In other words, a <em>number-period-space</em> sequence at the beginning of a line. To avoid this, you can backslash-escape the period:</p> <pre><code>1986\. What a great season. </code></pre> <h3 id="precode">Code Blocks</h3> <p>Pre-formatted code blocks are used for writing about programming or markup source code. Rather than forming normal paragraphs, the lines of a code block are interpreted literally. Markdown wraps a code block in both <code><pre></code> and <code><code></code> tags.</p> <p>To produce a code block in Markdown, simply indent every line of the block by at least 4 spaces or 1 tab. For example, given this input:</p> <pre><code>This is a normal paragraph: This is a code block. </code></pre> <p>Markdown will generate:</p> <pre><code><p>This is a normal paragraph:</p> <pre><code>This is a code block. </code></pre> </code></pre> <p>One level of indentation -- 4 spaces or 1 tab -- is removed from each line of the code block. For example, this:</p> <pre><code>Here is an example of AppleScript: tell application "Foo" beep end tell </code></pre> <p>will turn into:</p> <pre><code><p>Here is an example of AppleScript:</p> <pre><code>tell application "Foo" beep end tell </code></pre> </code></pre> <p>A code block continues until it reaches a line that is not indented (or the end of the article).</p> <p>Within a code block, ampersands (<code>&</code>) and angle brackets (<code><</code> and <code>></code>) are automatically converted into HTML entities. This makes it very easy to include example HTML source code using Markdown -- just paste it and indent it, and Markdown will handle the hassle of encoding the ampersands and angle brackets. For example, this:</p> <pre><code> <div class="footer"> &copy; 2004 Foo Corporation </div> </code></pre> <p>will turn into:</p> <pre><code><pre><code>&lt;div class="footer"&gt; &amp;copy; 2004 Foo Corporation &lt;/div&gt; </code></pre> </code></pre> <p>Regular Markdown syntax is not processed within code blocks. E.g., asterisks are just literal asterisks within a code block. This means it's also easy to use Markdown to write about Markdown's own syntax.</p> <h3 id="hr">Horizontal Rules</h3> <p>You can produce a horizontal rule tag (<code><hr /></code>) by placing three or more hyphens, asterisks, or underscores on a line by themselves. If you wish, you may use spaces between the hyphens or asterisks. Each of the following lines will produce a horizontal rule:</p> <pre><code>* * * *** ***** - - - --------------------------------------- _ _ _ </code></pre> <hr /> <h2 id="span">Span Elements</h2> <h3 id="link">Links</h3> <p>Markdown supports two style of links: <em>inline</em> and <em>reference</em>.</p> <p>In both styles, the link text is delimited by [square brackets].</p> <p>To create an inline link, use a set of regular parentheses immediately after the link text's closing square bracket. Inside the parentheses, put the URL where you want the link to point, along with an <em>optional</em> title for the link, surrounded in quotes. For example:</p> <pre><code>This is [an example](http://example.com/ "Title") inline link. [This link](http://example.net/) has no title attribute. </code></pre> <p>Will produce:</p> <pre><code><p>This is <a href="http://example.com/" title="Title"> an example</a> inline link.</p> <p><a href="http://example.net/">This link</a> has no title attribute.</p> </code></pre> <p>If you're referring to a local resource on the same server, you can use relative paths:</p> <pre><code>See my [About](/about/) page for details. </code></pre> <p>Reference-style links use a second set of square brackets, inside which you place a label of your choosing to identify the link:</p> <pre><code>This is [an example][id] reference-style link. </code></pre> <p>You can optionally use a space to separate the sets of brackets:</p> <pre><code>This is [an example] [id] reference-style link. </code></pre> <p>Then, anywhere in the document, you define your link label like this, on a line by itself:</p> <pre><code>[id]: http://example.com/ "Optional Title Here" </code></pre> <p>That is:</p> <ul> <li>Square brackets containing the link identifier (optionally indented from the left margin using up to three spaces);</li> <li>followed by a colon;</li> <li>followed by one or more spaces (or tabs);</li> <li>followed by the URL for the link;</li> <li>optionally followed by a title attribute for the link, enclosed in double or single quotes.</li> </ul> <p>The link URL may, optionally, be surrounded by angle brackets:</p> <pre><code>[id]: <http://example.com/> "Optional Title Here" </code></pre> <p>You can put the title attribute on the next line and use extra spaces or tabs for padding, which tends to look better with longer URLs:</p> <pre><code>[id]: http://example.com/longish/path/to/resource/here "Optional Title Here" </code></pre> <p>Link definitions are only used for creating links during Markdown processing, and are stripped from your document in the HTML output.</p> <p>Link definition names may constist of letters, numbers, spaces, and punctuation -- but they are <em>not</em> case sensitive. E.g. these two links:</p> <pre><code>[link text][a] [link text][A] </code></pre> <p>are equivalent.</p> <p>The <em>implicit link name</em> shortcut allows you to omit the name of the link, in which case the link text itself is used as the name. Just use an empty set of square brackets -- e.g., to link the word "Google" to the google.com web site, you could simply write:</p> <pre><code>[Google][] </code></pre> <p>And then define the link:</p> <pre><code>[Google]: http://google.com/ </code></pre> <p>Because link names may contain spaces, this shortcut even works for multiple words in the link text:</p> <pre><code>Visit [Daring Fireball][] for more information. </code></pre> <p>And then define the link:</p> <pre><code>[Daring Fireball]: http://daringfireball.net/ </code></pre> <p>Link definitions can be placed anywhere in your Markdown document. I tend to put them immediately after each paragraph in which they're used, but if you want, you can put them all at the end of your document, sort of like footnotes.</p> <p>Here's an example of reference links in action:</p> <pre><code>I get 10 times more traffic from [Google] [1] than from [Yahoo] [2] or [MSN] [3]. [1]: http://google.com/ "Google" [2]: http://search.yahoo.com/ "Yahoo Search" [3]: http://search.msn.com/ "MSN Search" </code></pre> <p>Using the implicit link name shortcut, you could instead write:</p> <pre><code>I get 10 times more traffic from [Google][] than from [Yahoo][] or [MSN][]. [google]: http://google.com/ "Google" [yahoo]: http://search.yahoo.com/ "Yahoo Search" [msn]: http://search.msn.com/ "MSN Search" </code></pre> <p>Both of the above examples will produce the following HTML output:</p> <pre><code><p>I get 10 times more traffic from <a href="http://google.com/" title="Google">Google</a> than from <a href="http://search.yahoo.com/" title="Yahoo Search">Yahoo</a> or <a href="http://search.msn.com/" title="MSN Search">MSN</a>.</p> </code></pre> <p>For comparison, here is the same paragraph written using Markdown's inline link style:</p> <pre><code>I get 10 times more traffic from [Google](http://google.com/ "Google") than from [Yahoo](http://search.yahoo.com/ "Yahoo Search") or [MSN](http://search.msn.com/ "MSN Search"). </code></pre> <p>The point of reference-style links is not that they're easier to write. The point is that with reference-style links, your document source is vastly more readable. Compare the above examples: using reference-style links, the paragraph itself is only 81 characters long; with inline-style links, it's 176 characters; and as raw HTML, it's 234 characters. In the raw HTML, there's more markup than there is text.</p> <p>With Markdown's reference-style links, a source document much more closely resembles the final output, as rendered in a browser. By allowing you to move the markup-related metadata out of the paragraph, you can add links without interrupting the narrative flow of your prose.</p> <h3 id="em">Emphasis</h3> <p>Markdown treats asterisks (<code>*</code>) and underscores (<code>_</code>) as indicators of emphasis. Text wrapped with one <code>*</code> or <code>_</code> will be wrapped with an HTML <code><em></code> tag; double <code>*</code>'s or <code>_</code>'s will be wrapped with an HTML <code><strong></code> tag. E.g., this input:</p> <pre><code>*single asterisks* _single underscores_ **double asterisks** __double underscores__ </code></pre> <p>will produce:</p> <pre><code><em>single asterisks</em> <em>single underscores</em> <strong>double asterisks</strong> <strong>double underscores</strong> </code></pre> <p>You can use whichever style you prefer; the lone restriction is that the same character must be used to open and close an emphasis span.</p> <p>Emphasis can be used in the middle of a word:</p> <pre><code>un*fucking*believable </code></pre> <p>But if you surround an <code>*</code> or <code>_</code> with spaces, it'll be treated as a literal asterisk or underscore.</p> <p>To produce a literal asterisk or underscore at a position where it would otherwise be used as an emphasis delimiter, you can backslash escape it:</p> <pre><code>\*this text is surrounded by literal asterisks\* </code></pre> <h3 id="code">Code</h3> <p>To indicate a span of code, wrap it with backtick quotes (<code>`</code>). Unlike a pre-formatted code block, a code span indicates code within a normal paragraph. For example:</p> <pre><code>Use the `printf()` function. </code></pre> <p>will produce:</p> <pre><code><p>Use the <code>printf()</code> function.</p> </code></pre> <p>To include a literal backtick character within a code span, you can use multiple backticks as the opening and closing delimiters:</p> <pre><code>``There is a literal backtick (`) here.`` </code></pre> <p>which will produce this:</p> <pre><code><p><code>There is a literal backtick (`) here.</code></p> </code></pre> <p>The backtick delimiters surrounding a code span may include spaces -- one after the opening, one before the closing. This allows you to place literal backtick characters at the beginning or end of a code span:</p> <pre><code>A single backtick in a code span: `` ` `` A backtick-delimited string in a code span: `` `foo` `` </code></pre> <p>will produce:</p> <pre><code><p>A single backtick in a code span: <code>`</code></p> <p>A backtick-delimited string in a code span: <code>`foo`</code></p> </code></pre> <p>With a code span, ampersands and angle brackets are encoded as HTML entities automatically, which makes it easy to include example HTML tags. Markdown will turn this:</p> <pre><code>Please don't use any `<blink>` tags. </code></pre> <p>into:</p> <pre><code><p>Please don't use any <code>&lt;blink&gt;</code> tags.</p> </code></pre> <p>You can write this:</p> <pre><code>`&#8212;` is the decimal-encoded equivalent of `&mdash;`. </code></pre> <p>to produce:</p> <pre><code><p><code>&amp;#8212;</code> is the decimal-encoded equivalent of <code>&amp;mdash;</code>.</p> </code></pre> <h3 id="img">Images</h3> <p>Admittedly, it's fairly difficult to devise a "natural" syntax for placing images into a plain text document format.</p> <p>Markdown uses an image syntax that is intended to resemble the syntax for links, allowing for two styles: <em>inline</em> and <em>reference</em>.</p> <p>Inline image syntax looks like this:</p> <pre><code>![Alt text](/path/to/img.jpg) ![Alt text](/path/to/img.jpg "Optional title") </code></pre> <p>That is:</p> <ul> <li>An exclamation mark: <code>!</code>;</li> <li>followed by a set of square brackets, containing the <code>alt</code> attribute text for the image;</li> <li>followed by a set of parentheses, containing the URL or path to the image, and an optional <code>title</code> attribute enclosed in double or single quotes.</li> </ul> <p>Reference-style image syntax looks like this:</p> <pre><code>![Alt text][id] </code></pre> <p>Where "id" is the name of a defined image reference. Image references are defined using syntax identical to link references:</p> <pre><code>[id]: url/to/image "Optional title attribute" </code></pre> <p>As of this writing, Markdown has no syntax for specifying the dimensions of an image; if this is important to you, you can simply use regular HTML <code><img></code> tags.</p> <hr /> <h2 id="misc">Miscellaneous</h2> <h3 id="autolink">Automatic Links</h3> <p>Markdown supports a shortcut style for creating "automatic" links for URLs and email addresses: simply surround the URL or email address with angle brackets. What this means is that if you want to show the actual text of a URL or email address, and also have it be a clickable link, you can do this:</p> <pre><code><http://example.com/> </code></pre> <p>Markdown will turn this into:</p> <pre><code><a href="http://example.com/">http://example.com/</a> </code></pre> <p>Automatic links for email addresses work similarly, except that Markdown will also perform a bit of randomized decimal and hex entity-encoding to help obscure your address from address-harvesting spambots. For example, Markdown will turn this:</p> <pre><code><address@example.com> </code></pre> <p>into something like this:</p> <pre><code><a href="&#x6D;&#x61;i&#x6C;&#x74;&#x6F;:&#x61;&#x64;&#x64;&#x72;&#x65; &#115;&#115;&#64;&#101;&#120;&#x61;&#109;&#x70;&#x6C;e&#x2E;&#99;&#111; &#109;">&#x61;&#x64;&#x64;&#x72;&#x65;&#115;&#115;&#64;&#101;&#120;&#x61; &#109;&#x70;&#x6C;e&#x2E;&#99;&#111;&#109;</a> </code></pre> <p>which will render in a browser as a clickable link to "address@example.com".</p> <p>(This sort of entity-encoding trick will indeed fool many, if not most, address-harvesting bots, but it definitely won't fool all of them. It's better than nothing, but an address published in this way will probably eventually start receiving spam.)</p> <h3 id="backslash">Backslash Escapes</h3> <p>Markdown allows you to use backslash escapes to generate literal characters which would otherwise have special meaning in Markdown's formatting syntax. For example, if you wanted to surround a word with literal asterisks (instead of an HTML <code><em></code> tag), you can backslashes before the asterisks, like this:</p> <pre><code>\*literal asterisks\* </code></pre> <p>Markdown provides backslash escapes for the following characters:</p> <pre><code>\ backslash ` backtick * asterisk _ underscore {} curly braces [] square brackets () parentheses # hash mark + plus sign - minus sign (hyphen) . dot ! exclamation mark </code></pre>�������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������Markdown-2.4/tests/extensions/extra/markdown-syntax.txt���������������������������������������������0000666�0000000�0000000�00000067237�11756571172�021721� 0����������������������������������������������������������������������������������������������������ustar �����������������������������������������������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������Markdown: Syntax ================ <ul id="ProjectSubmenu"> <li><a href="/projects/markdown/" title="Markdown Project Page">Main</a></li> <li><a href="/projects/markdown/basics" title="Markdown Basics">Basics</a></li> <li><a class="selected" title="Markdown Syntax Documentation">Syntax</a></li> <li><a href="/projects/markdown/license" title="Pricing and License Information">License</a></li> <li><a href="/projects/markdown/dingus" title="Online Markdown Web Form">Dingus</a></li> </ul> * [Overview](#overview) * [Philosophy](#philosophy) * [Inline HTML](#html) * [Automatic Escaping for Special Characters](#autoescape) * [Block Elements](#block) * [Paragraphs and Line Breaks](#p) * [Headers](#header) * [Blockquotes](#blockquote) * [Lists](#list) * [Code Blocks](#precode) * [Horizontal Rules](#hr) * [Span Elements](#span) * [Links](#link) * [Emphasis](#em) * [Code](#code) * [Images](#img) * [Miscellaneous](#misc) * [Backslash Escapes](#backslash) * [Automatic Links](#autolink) **Note:** This document is itself written using Markdown; you can [see the source for it by adding '.text' to the URL][src]. [src]: /projects/markdown/syntax.text * * * <h2 id="overview">Overview</h2> <h3 id="philosophy">Philosophy</h3> Markdown is intended to be as easy-to-read and easy-to-write as is feasible. Readability, however, is emphasized above all else. A Markdown-formatted document should be publishable as-is, as plain text, without looking like it's been marked up with tags or formatting instructions. While Markdown's syntax has been influenced by several existing text-to-HTML filters -- including [Setext] [1], [atx] [2], [Textile] [3], [reStructuredText] [4], [Grutatext] [5], and [EtText] [6] -- the single biggest source of inspiration for Markdown's syntax is the format of plain text email. [1]: http://docutils.sourceforge.net/mirror/setext.html [2]: http://www.aaronsw.com/2002/atx/ [3]: http://textism.com/tools/textile/ [4]: http://docutils.sourceforge.net/rst.html [5]: http://www.triptico.com/software/grutatxt.html [6]: http://ettext.taint.org/doc/ To this end, Markdown's syntax is comprised entirely of punctuation characters, which punctuation characters have been carefully chosen so as to look like what they mean. E.g., asterisks around a word actually look like \*emphasis\*. Markdown lists look like, well, lists. Even blockquotes look like quoted passages of text, assuming you've ever used email. <h3 id="html">Inline HTML</h3> Markdown's syntax is intended for one purpose: to be used as a format for *writing* for the web. Markdown is not a replacement for HTML, or even close to it. Its syntax is very small, corresponding only to a very small subset of HTML tags. The idea is *not* to create a syntax that makes it easier to insert HTML tags. In my opinion, HTML tags are already easy to insert. The idea for Markdown is to make it easy to read, write, and edit prose. HTML is a *publishing* format; Markdown is a *writing* format. Thus, Markdown's formatting syntax only addresses issues that can be conveyed in plain text. For any markup that is not covered by Markdown's syntax, you simply use HTML itself. There's no need to preface it or delimit it to indicate that you're switching from Markdown to HTML; you just use the tags. The only restrictions are that block-level HTML elements -- e.g. `<div>`, `<table>`, `<pre>`, `<p>`, etc. -- must be separated from surrounding content by blank lines, and the start and end tags of the block should not be indented with tabs or spaces. Markdown is smart enough not to add extra (unwanted) `<p>` tags around HTML block-level tags. For example, to add an HTML table to a Markdown article: This is a regular paragraph. <table> <tr> <td>Foo</td> </tr> </table> This is another regular paragraph. Note that Markdown formatting syntax is not processed within block-level HTML tags. E.g., you can't use Markdown-style `*emphasis*` inside an HTML block. Span-level HTML tags -- e.g. `<span>`, `<cite>`, or `<del>` -- can be used anywhere in a Markdown paragraph, list item, or header. If you want, you can even use HTML tags instead of Markdown formatting; e.g. if you'd prefer to use HTML `<a>` or `<img>` tags instead of Markdown's link or image syntax, go right ahead. Unlike block-level HTML tags, Markdown syntax *is* processed within span-level tags. <h3 id="autoescape">Automatic Escaping for Special Characters</h3> In HTML, there are two characters that demand special treatment: `<` and `&`. Left angle brackets are used to start tags; ampersands are used to denote HTML entities. If you want to use them as literal characters, you must escape them as entities, e.g. `<`, and `&`. Ampersands in particular are bedeviling for web writers. If you want to write about 'AT&T', you need to write '`AT&T`'. You even need to escape ampersands within URLs. Thus, if you want to link to: http://images.google.com/images?num=30&q=larry+bird you need to encode the URL as: http://images.google.com/images?num=30&q=larry+bird in your anchor tag `href` attribute. Needless to say, this is easy to forget, and is probably the single most common source of HTML validation errors in otherwise well-marked-up web sites. Markdown allows you to use these characters naturally, taking care of all the necessary escaping for you. If you use an ampersand as part of an HTML entity, it remains unchanged; otherwise it will be translated into `&`. So, if you want to include a copyright symbol in your article, you can write: © and Markdown will leave it alone. But if you write: AT&T Markdown will translate it to: AT&T Similarly, because Markdown supports [inline HTML](#html), if you use angle brackets as delimiters for HTML tags, Markdown will treat them as such. But if you write: 4 < 5 Markdown will translate it to: 4 < 5 However, inside Markdown code spans and blocks, angle brackets and ampersands are *always* encoded automatically. This makes it easy to use Markdown to write about HTML code. (As opposed to raw HTML, which is a terrible format for writing about HTML syntax, because every single `<` and `&` in your example code needs to be escaped.) * * * <h2 id="block">Block Elements</h2> <h3 id="p">Paragraphs and Line Breaks</h3> A paragraph is simply one or more consecutive lines of text, separated by one or more blank lines. (A blank line is any line that looks like a blank line -- a line containing nothing but spaces or tabs is considered blank.) Normal paragraphs should not be intended with spaces or tabs. The implication of the "one or more consecutive lines of text" rule is that Markdown supports "hard-wrapped" text paragraphs. This differs significantly from most other text-to-HTML formatters (including Movable Type's "Convert Line Breaks" option) which translate every line break character in a paragraph into a `<br />` tag. When you *do* want to insert a `<br />` break tag using Markdown, you end a line with two or more spaces, then type return. Yes, this takes a tad more effort to create a `<br />`, but a simplistic "every line break is a `<br />`" rule wouldn't work for Markdown. Markdown's email-style [blockquoting][bq] and multi-paragraph [list items][l] work best -- and look better -- when you format them with hard breaks. [bq]: #blockquote [l]: #list <h3 id="header">Headers</h3> Markdown supports two styles of headers, [Setext] [1] and [atx] [2]. Setext-style headers are "underlined" using equal signs (for first-level headers) and dashes (for second-level headers). For example: This is an H1 ============= This is an H2 ------------- Any number of underlining `=`'s or `-`'s will work. Atx-style headers use 1-6 hash characters at the start of the line, corresponding to header levels 1-6. For example: # This is an H1 ## This is an H2 ###### This is an H6 Optionally, you may "close" atx-style headers. This is purely cosmetic -- you can use this if you think it looks better. The closing hashes don't even need to match the number of hashes used to open the header. (The number of opening hashes determines the header level.) : # This is an H1 # ## This is an H2 ## ### This is an H3 ###### <h3 id="blockquote">Blockquotes</h3> Markdown uses email-style `>` characters for blockquoting. If you're familiar with quoting passages of text in an email message, then you know how to create a blockquote in Markdown. It looks best if you hard wrap the text and put a `>` before every line: > This is a blockquote with two paragraphs. Lorem ipsum dolor sit amet, > consectetuer adipiscing elit. Aliquam hendrerit mi posuere lectus. > Vestibulum enim wisi, viverra nec, fringilla in, laoreet vitae, risus. > > Donec sit amet nisl. Aliquam semper ipsum sit amet velit. Suspendisse > id sem consectetuer libero luctus adipiscing. Markdown allows you to be lazy and only put the `>` before the first line of a hard-wrapped paragraph: > This is a blockquote with two paragraphs. Lorem ipsum dolor sit amet, consectetuer adipiscing elit. Aliquam hendrerit mi posuere lectus. Vestibulum enim wisi, viverra nec, fringilla in, laoreet vitae, risus. > Donec sit amet nisl. Aliquam semper ipsum sit amet velit. Suspendisse id sem consectetuer libero luctus adipiscing. Blockquotes can be nested (i.e. a blockquote-in-a-blockquote) by adding additional levels of `>`: > This is the first level of quoting. > > > This is nested blockquote. > > Back to the first level. Blockquotes can contain other Markdown elements, including headers, lists, and code blocks: > ## This is a header. > > 1. This is the first list item. > 2. This is the second list item. > > Here's some example code: > > return shell_exec("echo $input | $markdown_script"); Any decent text editor should make email-style quoting easy. For example, with BBEdit, you can make a selection and choose Increase Quote Level from the Text menu. <h3 id="list">Lists</h3> Markdown supports ordered (numbered) and unordered (bulleted) lists. Unordered lists use asterisks, pluses, and hyphens -- interchangably -- as list markers: * Red * Green * Blue is equivalent to: + Red + Green + Blue and: - Red - Green - Blue Ordered lists use numbers followed by periods: 1. Bird 2. McHale 3. Parish It's important to note that the actual numbers you use to mark the list have no effect on the HTML output Markdown produces. The HTML Markdown produces from the above list is: <ol> <li>Bird</li> <li>McHale</li> <li>Parish</li> </ol> If you instead wrote the list in Markdown like this: 1. Bird 1. McHale 1. Parish or even: 3. Bird 1. McHale 8. Parish you'd get the exact same HTML output. The point is, if you want to, you can use ordinal numbers in your ordered Markdown lists, so that the numbers in your source match the numbers in your published HTML. But if you want to be lazy, you don't have to. If you do use lazy list numbering, however, you should still start the list with the number 1. At some point in the future, Markdown may support starting ordered lists at an arbitrary number. List markers typically start at the left margin, but may be indented by up to three spaces. List markers must be followed by one or more spaces or a tab. To make lists look nice, you can wrap items with hanging indents: * Lorem ipsum dolor sit amet, consectetuer adipiscing elit. Aliquam hendrerit mi posuere lectus. Vestibulum enim wisi, viverra nec, fringilla in, laoreet vitae, risus. * Donec sit amet nisl. Aliquam semper ipsum sit amet velit. Suspendisse id sem consectetuer libero luctus adipiscing. But if you want to be lazy, you don't have to: * Lorem ipsum dolor sit amet, consectetuer adipiscing elit. Aliquam hendrerit mi posuere lectus. Vestibulum enim wisi, viverra nec, fringilla in, laoreet vitae, risus. * Donec sit amet nisl. Aliquam semper ipsum sit amet velit. Suspendisse id sem consectetuer libero luctus adipiscing. If list items are separated by blank lines, Markdown will wrap the items in `<p>` tags in the HTML output. For example, this input: * Bird * Magic will turn into: <ul> <li>Bird</li> <li>Magic</li> </ul> But this: * Bird * Magic will turn into: <ul> <li><p>Bird</p></li> <li><p>Magic</p></li> </ul> List items may consist of multiple paragraphs. Each subsequent paragraph in a list item must be intended by either 4 spaces or one tab: 1. This is a list item with two paragraphs. Lorem ipsum dolor sit amet, consectetuer adipiscing elit. Aliquam hendrerit mi posuere lectus. Vestibulum enim wisi, viverra nec, fringilla in, laoreet vitae, risus. Donec sit amet nisl. Aliquam semper ipsum sit amet velit. 2. Suspendisse id sem consectetuer libero luctus adipiscing. It looks nice if you indent every line of the subsequent paragraphs, but here again, Markdown will allow you to be lazy: * This is a list item with two paragraphs. This is the second paragraph in the list item. You're only required to indent the first line. Lorem ipsum dolor sit amet, consectetuer adipiscing elit. * Another item in the same list. To put a blockquote within a list item, the blockquote's `>` delimiters need to be indented: * A list item with a blockquote: > This is a blockquote > inside a list item. To put a code block within a list item, the code block needs to be indented *twice* -- 8 spaces or two tabs: * A list item with a code block: <code goes here> It's worth noting that it's possible to trigger an ordered list by accident, by writing something like this: 1986. What a great season. In other words, a *number-period-space* sequence at the beginning of a line. To avoid this, you can backslash-escape the period: 1986\. What a great season. <h3 id="precode">Code Blocks</h3> Pre-formatted code blocks are used for writing about programming or markup source code. Rather than forming normal paragraphs, the lines of a code block are interpreted literally. Markdown wraps a code block in both `<pre>` and `<code>` tags. To produce a code block in Markdown, simply indent every line of the block by at least 4 spaces or 1 tab. For example, given this input: This is a normal paragraph: This is a code block. Markdown will generate: <p>This is a normal paragraph:</p> <pre><code>This is a code block. </code></pre> One level of indentation -- 4 spaces or 1 tab -- is removed from each line of the code block. For example, this: Here is an example of AppleScript: tell application "Foo" beep end tell will turn into: <p>Here is an example of AppleScript:</p> <pre><code>tell application "Foo" beep end tell </code></pre> A code block continues until it reaches a line that is not indented (or the end of the article). Within a code block, ampersands (`&`) and angle brackets (`<` and `>`) are automatically converted into HTML entities. This makes it very easy to include example HTML source code using Markdown -- just paste it and indent it, and Markdown will handle the hassle of encoding the ampersands and angle brackets. For example, this: <div class="footer"> © 2004 Foo Corporation </div> will turn into: <pre><code><div class="footer"> &copy; 2004 Foo Corporation </div> </code></pre> Regular Markdown syntax is not processed within code blocks. E.g., asterisks are just literal asterisks within a code block. This means it's also easy to use Markdown to write about Markdown's own syntax. <h3 id="hr">Horizontal Rules</h3> You can produce a horizontal rule tag (`<hr />`) by placing three or more hyphens, asterisks, or underscores on a line by themselves. If you wish, you may use spaces between the hyphens or asterisks. Each of the following lines will produce a horizontal rule: * * * *** ***** - - - --------------------------------------- _ _ _ * * * <h2 id="span">Span Elements</h2> <h3 id="link">Links</h3> Markdown supports two style of links: *inline* and *reference*. In both styles, the link text is delimited by [square brackets]. To create an inline link, use a set of regular parentheses immediately after the link text's closing square bracket. Inside the parentheses, put the URL where you want the link to point, along with an *optional* title for the link, surrounded in quotes. For example: This is [an example](http://example.com/ "Title") inline link. [This link](http://example.net/) has no title attribute. Will produce: <p>This is <a href="http://example.com/" title="Title"> an example</a> inline link.</p> <p><a href="http://example.net/">This link</a> has no title attribute.</p> If you're referring to a local resource on the same server, you can use relative paths: See my [About](/about/) page for details. Reference-style links use a second set of square brackets, inside which you place a label of your choosing to identify the link: This is [an example][id] reference-style link. You can optionally use a space to separate the sets of brackets: This is [an example] [id] reference-style link. Then, anywhere in the document, you define your link label like this, on a line by itself: [id]: http://example.com/ "Optional Title Here" That is: * Square brackets containing the link identifier (optionally indented from the left margin using up to three spaces); * followed by a colon; * followed by one or more spaces (or tabs); * followed by the URL for the link; * optionally followed by a title attribute for the link, enclosed in double or single quotes. The link URL may, optionally, be surrounded by angle brackets: [id]: <http://example.com/> "Optional Title Here" You can put the title attribute on the next line and use extra spaces or tabs for padding, which tends to look better with longer URLs: [id]: http://example.com/longish/path/to/resource/here "Optional Title Here" Link definitions are only used for creating links during Markdown processing, and are stripped from your document in the HTML output. Link definition names may constist of letters, numbers, spaces, and punctuation -- but they are *not* case sensitive. E.g. these two links: [link text][a] [link text][A] are equivalent. The *implicit link name* shortcut allows you to omit the name of the link, in which case the link text itself is used as the name. Just use an empty set of square brackets -- e.g., to link the word "Google" to the google.com web site, you could simply write: [Google][] And then define the link: [Google]: http://google.com/ Because link names may contain spaces, this shortcut even works for multiple words in the link text: Visit [Daring Fireball][] for more information. And then define the link: [Daring Fireball]: http://daringfireball.net/ Link definitions can be placed anywhere in your Markdown document. I tend to put them immediately after each paragraph in which they're used, but if you want, you can put them all at the end of your document, sort of like footnotes. Here's an example of reference links in action: I get 10 times more traffic from [Google] [1] than from [Yahoo] [2] or [MSN] [3]. [1]: http://google.com/ "Google" [2]: http://search.yahoo.com/ "Yahoo Search" [3]: http://search.msn.com/ "MSN Search" Using the implicit link name shortcut, you could instead write: I get 10 times more traffic from [Google][] than from [Yahoo][] or [MSN][]. [google]: http://google.com/ "Google" [yahoo]: http://search.yahoo.com/ "Yahoo Search" [msn]: http://search.msn.com/ "MSN Search" Both of the above examples will produce the following HTML output: <p>I get 10 times more traffic from <a href="http://google.com/" title="Google">Google</a> than from <a href="http://search.yahoo.com/" title="Yahoo Search">Yahoo</a> or <a href="http://search.msn.com/" title="MSN Search">MSN</a>.</p> For comparison, here is the same paragraph written using Markdown's inline link style: I get 10 times more traffic from [Google](http://google.com/ "Google") than from [Yahoo](http://search.yahoo.com/ "Yahoo Search") or [MSN](http://search.msn.com/ "MSN Search"). The point of reference-style links is not that they're easier to write. The point is that with reference-style links, your document source is vastly more readable. Compare the above examples: using reference-style links, the paragraph itself is only 81 characters long; with inline-style links, it's 176 characters; and as raw HTML, it's 234 characters. In the raw HTML, there's more markup than there is text. With Markdown's reference-style links, a source document much more closely resembles the final output, as rendered in a browser. By allowing you to move the markup-related metadata out of the paragraph, you can add links without interrupting the narrative flow of your prose. <h3 id="em">Emphasis</h3> Markdown treats asterisks (`*`) and underscores (`_`) as indicators of emphasis. Text wrapped with one `*` or `_` will be wrapped with an HTML `<em>` tag; double `*`'s or `_`'s will be wrapped with an HTML `<strong>` tag. E.g., this input: *single asterisks* _single underscores_ **double asterisks** __double underscores__ will produce: <em>single asterisks</em> <em>single underscores</em> <strong>double asterisks</strong> <strong>double underscores</strong> You can use whichever style you prefer; the lone restriction is that the same character must be used to open and close an emphasis span. Emphasis can be used in the middle of a word: un*fucking*believable But if you surround an `*` or `_` with spaces, it'll be treated as a literal asterisk or underscore. To produce a literal asterisk or underscore at a position where it would otherwise be used as an emphasis delimiter, you can backslash escape it: \*this text is surrounded by literal asterisks\* <h3 id="code">Code</h3> To indicate a span of code, wrap it with backtick quotes (`` ` ``). Unlike a pre-formatted code block, a code span indicates code within a normal paragraph. For example: Use the `printf()` function. will produce: <p>Use the <code>printf()</code> function.</p> To include a literal backtick character within a code span, you can use multiple backticks as the opening and closing delimiters: ``There is a literal backtick (`) here.`` which will produce this: <p><code>There is a literal backtick (`) here.</code></p> The backtick delimiters surrounding a code span may include spaces -- one after the opening, one before the closing. This allows you to place literal backtick characters at the beginning or end of a code span: A single backtick in a code span: `` ` `` A backtick-delimited string in a code span: `` `foo` `` will produce: <p>A single backtick in a code span: <code>`</code></p> <p>A backtick-delimited string in a code span: <code>`foo`</code></p> With a code span, ampersands and angle brackets are encoded as HTML entities automatically, which makes it easy to include example HTML tags. Markdown will turn this: Please don't use any `<blink>` tags. into: <p>Please don't use any <code><blink></code> tags.</p> You can write this: `—` is the decimal-encoded equivalent of `—`. to produce: <p><code>&#8212;</code> is the decimal-encoded equivalent of <code>&mdash;</code>.</p> <h3 id="img">Images</h3> Admittedly, it's fairly difficult to devise a "natural" syntax for placing images into a plain text document format. Markdown uses an image syntax that is intended to resemble the syntax for links, allowing for two styles: *inline* and *reference*. Inline image syntax looks like this: ![Alt text](/path/to/img.jpg) ![Alt text](/path/to/img.jpg "Optional title") That is: * An exclamation mark: `!`; * followed by a set of square brackets, containing the `alt` attribute text for the image; * followed by a set of parentheses, containing the URL or path to the image, and an optional `title` attribute enclosed in double or single quotes. Reference-style image syntax looks like this: ![Alt text][id] Where "id" is the name of a defined image reference. Image references are defined using syntax identical to link references: [id]: url/to/image "Optional title attribute" As of this writing, Markdown has no syntax for specifying the dimensions of an image; if this is important to you, you can simply use regular HTML `<img>` tags. * * * <h2 id="misc">Miscellaneous</h2> <h3 id="autolink">Automatic Links</h3> Markdown supports a shortcut style for creating "automatic" links for URLs and email addresses: simply surround the URL or email address with angle brackets. What this means is that if you want to show the actual text of a URL or email address, and also have it be a clickable link, you can do this: <http://example.com/> Markdown will turn this into: <a href="http://example.com/">http://example.com/</a> Automatic links for email addresses work similarly, except that Markdown will also perform a bit of randomized decimal and hex entity-encoding to help obscure your address from address-harvesting spambots. For example, Markdown will turn this: <address@example.com> into something like this: <a href="mailto:addre ss@example.co m">address@exa mple.com</a> which will render in a browser as a clickable link to "address@example.com". (This sort of entity-encoding trick will indeed fool many, if not most, address-harvesting bots, but it definitely won't fool all of them. It's better than nothing, but an address published in this way will probably eventually start receiving spam.) <h3 id="backslash">Backslash Escapes</h3> Markdown allows you to use backslash escapes to generate literal characters which would otherwise have special meaning in Markdown's formatting syntax. For example, if you wanted to surround a word with literal asterisks (instead of an HTML `<em>` tag), you can backslashes before the asterisks, like this: \*literal asterisks\* Markdown provides backslash escapes for the following characters: \ backslash ` backtick * asterisk _ underscore {} curly braces [] square brackets () parentheses # hash mark + plus sign - minus sign (hyphen) . dot ! exclamation mark �����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������Markdown-2.4/tests/extensions/extra/named_markers.html����������������������������������������������0000666�0000000�0000000�00000002303�12111563027�021451� 0����������������������������������������������������������������������������������������������������ustar �����������������������������������������������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������<p>This is the body with footnotes<sup id="fnref:foo"><a class="footnote-ref" href="#fn:foo" rel="footnote">1</a></sup> that have named<sup id="fnref:bar"><a class="footnote-ref" href="#fn:bar" rel="footnote">2</a></sup> markers and oddly<sup id="fnref:56"><a class="footnote-ref" href="#fn:56" rel="footnote">3</a></sup> numbered<sup id="fnref:99"><a class="footnote-ref" href="#fn:99" rel="footnote">4</a></sup> markers.</p> <div class="footnote"> <hr /> <ol> <li id="fn:foo"> <p>Footnote marked <code>foo</code>. <a class="footnote-backref" href="#fnref:foo" rev="footnote" title="Jump back to footnote 1 in the text">↩</a></p> </li> <li id="fn:bar"> <p>This one is marked <em>bar</em>. <a class="footnote-backref" href="#fnref:bar" rev="footnote" title="Jump back to footnote 2 in the text">↩</a></p> </li> <li id="fn:56"> <p>A <strong>numbered</strong> footnote. <a class="footnote-backref" href="#fnref:56" rev="footnote" title="Jump back to footnote 3 in the text">↩</a></p> </li> <li id="fn:99"> <p>The last one. <a class="footnote-backref" href="#fnref:99" rev="footnote" title="Jump back to footnote 4 in the text">↩</a></p> </li> </ol> </div>�����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������Markdown-2.4/tests/extensions/extra/named_markers.txt�����������������������������������������������0000666�0000000�0000000�00000000360�11756571172�021343� 0����������������������������������������������������������������������������������������������������ustar �����������������������������������������������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������This is the body with footnotes[^foo] that have named[^bar] markers and oddly[^56] numbered[^99] markers. [^foo]: Footnote marked ``foo``. [^bar]: This one is marked *bar*. [^56]: A __numbered__ footnote. [^99]: The last one. ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������Markdown-2.4/tests/extensions/extra/raw-html.html���������������������������������������������������0000666�0000000�0000000�00000001745�12261107557�020415� 0����������������������������������������������������������������������������������������������������ustar �����������������������������������������������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������<div> <p><em>foo</em></p> </div> <div class="baz"> <p><em>bar</em></p> </div> <div> <p><em>blah</em></p> </div> <div name="Example"> <p>The text of the <code>Example</code> element.</p> <div name="DefaultBlockMode"> <p>This text gets wrapped in <code>p</code> tags.</p> </div> <p>The tail of the <code>DefaultBlockMode</code> subelement.</p> <p name="DefaultSpanMode"> This text <em>is not</em> wrapped in additional <code>p</code> tags.</p> <p>The tail of the <code>DefaultSpanMode</code> subelement.</p> <div name="SpanModeOverride"> This <code>div</code> block is not wrapped in paragraph tags. Note: Subelements are not required to have tail text.</div> <p name="BlockModeOverride"> <p>This <code>p</code> block <em>is</em> foolishly wrapped in further paragraph tags.</p> </p> <p>The tail of the <code>BlockModeOverride</code> subelement.</p> <div name="RawHtml"> Raw html blocks may also be nested. </div> </div> <p>This text is after the markdown in html.</p>���������������������������Markdown-2.4/tests/extensions/extra/raw-html.txt����������������������������������������������������0000666�0000000�0000000�00000001656�12261107557�020271� 0����������������������������������������������������������������������������������������������������ustar �����������������������������������������������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������<div markdown="1">_foo_</div> <div markdown=1 class="baz"> _bar_ </div> <div markdown> _blah_ </div> <div markdown="1" name="Example"> The text of the `Example` element. <div markdown="1" name="DefaultBlockMode"> This text gets wrapped in `p` tags. </div> The tail of the `DefaultBlockMode` subelement. <p markdown="1" name="DefaultSpanMode"> This text *is not* wrapped in additional `p` tags. </p> The tail of the `DefaultSpanMode` subelement. <div markdown="span" name="SpanModeOverride"> This `div` block is not wrapped in paragraph tags. Note: Subelements are not required to have tail text. </div> <p markdown="block" name="BlockModeOverride"> This `p` block *is* foolishly wrapped in further paragraph tags. </p> The tail of the `BlockModeOverride` subelement. <div name="RawHtml"> Raw html blocks may also be nested. </div> </div> This text is after the markdown in html. ����������������������������������������������������������������������������������Markdown-2.4/tests/extensions/extra/simple_def-lists.html�������������������������������������������0000666�0000000�0000000�00000001166�11756571172�022130� 0����������������������������������������������������������������������������������������������������ustar �����������������������������������������������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������<p>Some text</p> <dl> <dt>term1</dt> <dd>Def1</dd> <dt>term2-1</dt> <dt>term2-2</dt> <dd>Def2-1</dd> <dd>Def2-2</dd> </dl> <p>more text</p> <dl> <dt>term <em>3</em></dt> <dd> <p>def 3 line <strong>2</strong> of def 3</p> <p>paragraph 2 of def 3.</p> </dd> <dd> <p>def 3-2</p> <pre><code># A code block in a def </code></pre> <blockquote> <p>a blockquote</p> </blockquote> <ul> <li> <p>a list item</p> </li> <li> <blockquote> <p>blockquote in list</p> </blockquote> </li> </ul> </dd> </dl> <p>and more text.</p> <dl> <dt>term 4</dt> <dd>def4 line 2 of def 4</dd> </dl> <p>final text.</p>����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������Markdown-2.4/tests/extensions/extra/simple_def-lists.txt��������������������������������������������0000666�0000000�0000000�00000000545�11756571172�022003� 0����������������������������������������������������������������������������������������������������ustar �����������������������������������������������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������Some text term1 : Def1 term2-1 term2-2 : Def2-1 : Def2-2 more text term *3* : def 3 line __2__ of def 3 paragraph 2 of def 3. : def 3-2 # A code block in a def > a blockquote * a list item * > blockquote in list and more text. term 4 : def4 line 2 of def 4 final text. �����������������������������������������������������������������������������������������������������������������������������������������������������������Markdown-2.4/tests/extensions/extra/tables.html�����������������������������������������������������0000666�0000000�0000000�00000004376�11756571172�020145� 0����������������������������������������������������������������������������������������������������ustar �����������������������������������������������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������<h2>Table Tests</h2> <table> <thead> <tr> <th>First Header</th> <th>Second Header</th> </tr> </thead> <tbody> <tr> <td>Content Cell</td> <td>Content Cell</td> </tr> <tr> <td>Content Cell</td> <td>Content Cell</td> </tr> </tbody> </table> <table> <thead> <tr> <th>First Header</th> <th>Second Header</th> </tr> </thead> <tbody> <tr> <td>Content Cell</td> <td>Content Cell</td> </tr> <tr> <td>Content Cell</td> <td>Content Cell</td> </tr> </tbody> </table> <table> <thead> <tr> <th>Item</th> <th align="right">Value</th> </tr> </thead> <tbody> <tr> <td>Computer</td> <td align="right">$1600</td> </tr> <tr> <td>Phone</td> <td align="right">$12</td> </tr> <tr> <td>Pipe</td> <td align="right">$1</td> </tr> </tbody> </table> <table> <thead> <tr> <th>Function name</th> <th>Description</th> </tr> </thead> <tbody> <tr> <td><code>help()</code></td> <td>Display the help window.</td> </tr> <tr> <td><code>destroy()</code></td> <td><strong>Destroy your computer!</strong></td> </tr> </tbody> </table> <table> <thead> <tr> <th align="left">foo</th> <th align="center">bar</th> <th align="right">baz</th> </tr> </thead> <tbody> <tr> <td align="left"></td> <td align="center">Q</td> <td align="right"></td> </tr> <tr> <td align="left">W</td> <td align="center"></td> <td align="right">W</td> </tr> </tbody> </table> <table> <thead> <tr> <th>foo</th> <th>bar</th> <th>baz</th> </tr> </thead> <tbody> <tr> <td></td> <td>Q</td> <td></td> </tr> <tr> <td>W</td> <td></td> <td>W</td> </tr> </tbody> </table> <p>Three spaces in front of a table:</p> <table> <thead> <tr> <th>First Header</th> <th>Second Header</th> </tr> </thead> <tbody> <tr> <td>Content Cell</td> <td>Content Cell</td> </tr> <tr> <td>Content Cell</td> <td>Content Cell</td> </tr> </tbody> </table> <table> <thead> <tr> <th>First Header</th> <th>Second Header</th> </tr> </thead> <tbody> <tr> <td>Content Cell</td> <td>Content Cell</td> </tr> <tr> <td>Content Cell</td> <td>Content Cell</td> </tr> </tbody> </table> <p>Four spaces is a code block:</p> <pre><code>First Header | Second Header ------------ | ------------- Content Cell | Content Cell Content Cell | Content Cell </code></pre>������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������Markdown-2.4/tests/extensions/extra/tables.txt������������������������������������������������������0000666�0000000�0000000�00000002305�11756571172�020006� 0����������������������������������������������������������������������������������������������������ustar �����������������������������������������������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������Table Tests ----------- First Header | Second Header ------------- | ------------- Content Cell | Content Cell Content Cell | Content Cell | First Header | Second Header | | ------------- | ------------- | | Content Cell | Content Cell | | Content Cell | Content Cell | | Item | Value | | :-------- | -----:| | Computer | $1600 | | Phone | $12 | | Pipe | $1 | | Function name | Description | | ------------- | ------------------------------ | | `help()` | Display the help window. | | `destroy()` | **Destroy your computer!** | |foo|bar|baz| |:--|:-:|--:| | | Q | | |W | | W| foo|bar|baz ---|---|--- | Q | W | | W Three spaces in front of a table: First Header | Second Header ------------ | ------------- Content Cell | Content Cell Content Cell | Content Cell | First Header | Second Header | | ------------ | ------------- | | Content Cell | Content Cell | | Content Cell | Content Cell | Four spaces is a code block: First Header | Second Header ------------ | ------------- Content Cell | Content Cell Content Cell | Content Cell ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������Markdown-2.4/tests/extensions/extra/tables_and_attr_list.html���������������������������������������0000666�0000000�0000000�00000000461�12300201166�023016� 0����������������������������������������������������������������������������������������������������ustar �����������������������������������������������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������<table> <thead> <tr> <th>First Header</th> <th>Second Header</th> </tr> </thead> <tbody> <tr> <td class="foo bar" title="Some title!">Content Cell</td> <td>Content Cell</td> </tr> <tr> <td>Content Cell</td> <td class="foo bar" title="Some title!">Content Cell</td> </tr> </tbody> </table>���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������Markdown-2.4/tests/extensions/extra/tables_and_attr_list.txt����������������������������������������0000666�0000000�0000000�00000000506�12300201166�022671� 0����������������������������������������������������������������������������������������������������ustar �����������������������������������������������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������First Header | Second Header ------------------------------------------------------ | ------------- Content Cell{: class="foo bar" title="Some title!" } | Content Cell Content Cell | Content Cell{: class="foo bar" title="Some title!" } ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������Markdown-2.4/tests/extensions/extra/test.cfg��������������������������������������������������������0000666�0000000�0000000�00000000407�12300201166�017407� 0����������������������������������������������������������������������������������������������������ustar �����������������������������������������������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������[DEFAULT] extensions=extra [loose_def_list] extensions=def_list [simple_def-lists] extensions=def_list [abbr] extensions=abbr [footnotes] extensions=footnotes [tables] extensions=tables [tables_and_attr_list] extensions=tables,attr_list ���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������Markdown-2.4/tests/extensions/fenced_code.html������������������������������������������������������0000666�0000000�0000000�00000001625�12111563027�017742� 0����������������������������������������������������������������������������������������������������ustar �����������������������������������������������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������<p>index 0000000..6e956a9</p> <pre><code>--- /dev/null +++ b/test/data/stripped_text/mike-30-lili @@ -0,0 +1,27 @@ +Summary: + drift_mod.py | 1 + + 1 files changed, 1 insertions(+), 0 deletions(-) + +commit da4bfb04debdd994683740878d09988b2641513d +Author: Mike Dirolf <mike@dirolf.com> +Date: Tue Jan 17 13:42:28 2012 -0500 + +``` +minor: just wanted to push something. +``` + +diff --git a/drift_mod.py b/drift_mod.py +index 34dfba6..8a88a69 100644 + +``` +--- a/drift_mod.py ++++ b/drift_mod.py +@@ -281,6 +281,7 @@ CONTEXT_DIFF_LINE_PATTERN = re.compile(r'^(' + '|\+ .*' + '|- .*' + ')$') ++ + def wrap_context_diffs(message_text): + return _wrap_diff(CONTEXT_DIFF_HEADER_PATTERN, + CONTEXT_DIFF_LINE_PATTERN, +``` </code></pre>�����������������������������������������������������������������������������������������������������������Markdown-2.4/tests/extensions/fenced_code.txt�������������������������������������������������������0000666�0000000�0000000�00000001574�12111563027�017620� 0����������������������������������������������������������������������������������������������������ustar �����������������������������������������������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������index 0000000..6e956a9 ``` --- /dev/null +++ b/test/data/stripped_text/mike-30-lili @@ -0,0 +1,27 @@ +Summary: + drift_mod.py | 1 + + 1 files changed, 1 insertions(+), 0 deletions(-) + +commit da4bfb04debdd994683740878d09988b2641513d +Author: Mike Dirolf <mike@dirolf.com> +Date: Tue Jan 17 13:42:28 2012 -0500 + +``` +minor: just wanted to push something. +``` + +diff --git a/drift_mod.py b/drift_mod.py +index 34dfba6..8a88a69 100644 + +``` +--- a/drift_mod.py ++++ b/drift_mod.py +@@ -281,6 +281,7 @@ CONTEXT_DIFF_LINE_PATTERN = re.compile(r'^(' + '|\+ .*' + '|- .*' + ')$') ++ + def wrap_context_diffs(message_text): + return _wrap_diff(CONTEXT_DIFF_HEADER_PATTERN, + CONTEXT_DIFF_LINE_PATTERN, +``` ``` ������������������������������������������������������������������������������������������������������������������������������������Markdown-2.4/tests/extensions/github_flavored.html��������������������������������������������������0000666�0000000�0000000�00000002332�12111563027�020664� 0����������������������������������������������������������������������������������������������������ustar �����������������������������������������������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������<p>index 0000000..6e956a9</p> <pre><code class="diff">--- /dev/null +++ b/test/data/stripped_text/mike-30-lili @@ -0,0 +1,27 @@ +Summary: + drift_mod.py | 1 + + 1 files changed, 1 insertions(+), 0 deletions(-) + +commit da4bfb04debdd994683740878d09988b2641513d +Author: Mike Dirolf <mike@dirolf.com> +Date: Tue Jan 17 13:42:28 2012 -0500 + +``` +minor: just wanted to push something. +``` + +diff --git a/drift_mod.py b/drift_mod.py +index 34dfba6..8a88a69 100644 + +``` +--- a/drift_mod.py ++++ b/drift_mod.py +@@ -281,6 +281,7 @@ CONTEXT_DIFF_LINE_PATTERN = re.compile(r'^(' + '|\+ .*' + '|- .*' + ')$') ++ + def wrap_context_diffs(message_text): + return _wrap_diff(CONTEXT_DIFF_HEADER_PATTERN, + CONTEXT_DIFF_LINE_PATTERN, +``` </code></pre> <p>Test support for foo+bar lexer names.</p> <pre><code class="html+jinja"><title>{% block title %}{% endblock %}</title> <ul> {% for user in users %} <li><a href="{{ user.url }}">{{ user.username }}</a></li> {% endfor %} </ul> </code></pre>������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������Markdown-2.4/tests/extensions/github_flavored.txt���������������������������������������������������0000666�0000000�0000000�00000002140�12111563027�020534� 0����������������������������������������������������������������������������������������������������ustar �����������������������������������������������������������������0000000�0000000������������������������������������������������������������������������������������������������������������������������������������������������������������������������index 0000000..6e956a9 ```diff --- /dev/null +++ b/test/data/stripped_text/mike-30-lili @@ -0,0 +1,27 @@ +Summary: + drift_mod.py | 1 + + 1 files changed, 1 insertions(+), 0 deletions(-) + +commit da4bfb04debdd994683740878d09988b2641513d +Author: Mike Dirolf <mike@dirolf.com> +Date: Tue Jan 17 13:42:28 2012 -0500 + +``` +minor: just wanted to push something. +``` + +diff --git a/drift_mod.py b/drift_mod.py +index 34dfba6..8a88a69 100644 + +``` +--- a/drift_mod.py ++++ b/drift_mod.py +@@ -281,6 +281,7 @@ CONTEXT_DIFF_LINE_PATTERN = re.compile(r'^(' + '|\+ .*' + '|- .*' + ')$') ++ + def wrap_context_diffs(message_text): + return _wrap_diff(CONTEXT_DIFF_HEADER_PATTERN, + CONTEXT_DIFF_LINE_PATTERN, +``` ``` Test support for foo+bar lexer names. ```html+jinja <title>{% block title %}{% endblock %} ``` Markdown-2.4/tests/extensions/nl2br_w_attr_list.html0000666000000000000000000000003112111563047021146 0ustar 00000000000000

Foo

Markdown-2.4/tests/extensions/nl2br_w_attr_list.txt0000666000000000000000000000001512111563047021023 0ustar 00000000000000Foo {: #bar}Markdown-2.4/tests/extensions/sane_lists.html0000666000000000000000000000043012111563027017661 0ustar 00000000000000
  1. Ordered
  2. List
  • Unordered
  • List
  1. Ordered again

Paragraph * not a list item

  1. More ordered * not a list item
  • Unordered again 1. not a list item
Markdown-2.4/tests/extensions/sane_lists.txt0000666000000000000000000000025712111563027017543 0ustar 000000000000001. Ordered 2. List * Unordered * List 1. Ordered again Paragraph * not a list item 1. More ordered * not a list item * Unordered again 1. not a list item Markdown-2.4/tests/extensions/smarty.html0000666000000000000000000000157512300201166017040 0ustar 00000000000000

1440–80’s
1440–‘80s
1440—‘80s
1960s
1960’s
one two ‘60s
‘60s

It’s fun. What’s fun?
“Isn’t this fun”? — she said…
“‘Quoted’ words in a larger quote.”
‘Quoted “words” in a larger quote.’
“quoted” text and bold “quoted” text
‘quoted’ text and bold ‘quoted’ text
em-dashes (—) and ellipes (…)
Link” — she said.


Escaped -- ndash
'Escaped' "quotes"
Escaped ellipsis...

‘Escaped "quotes" in real ones’
'“Real” quotes in escaped ones'

Markdown-2.4/tests/extensions/smarty.txt0000666000000000000000000000105012300201167016700 0ustar 000000000000001440--80's 1440--'80s 1440---'80s 1960s 1960's one two '60s '60s It's fun. What's fun? "Isn't this fun"? --- she said... "'Quoted' words in a larger quote." 'Quoted "words" in a larger quote.' "quoted" text and **bold "quoted" text** 'quoted' text and **bold 'quoted' text** em-dashes (---) and ellipes (...) "[Link](http://example.com)" --- she said. --- -- --- Escaped \-- ndash \'Escaped\' \"quotes\" Escaped ellipsis\... 'Escaped \"quotes\" in real ones' \'"Real" quotes in escaped ones\'Markdown-2.4/tests/extensions/test.cfg0000666000000000000000000000115212261107557016301 0ustar 00000000000000[attr_list] extensions=attr_list,def_list [codehilite] extensions=codehilite # This passes or not based on version of pygments. skip=1 [toc] extensions=toc [toc_invalid] extensions=toc [toc_out_of_order] extensions=toc [toc_nested] extensions=toc(permalink=1) [toc_nested2] extensions=toc(permalink=[link]) [wikilinks] extensions=wikilinks [fenced_code] extensions=fenced_code [github_flavored] extensions=fenced_code [sane_lists] extensions=sane_lists [nl2br_w_attr_list] extensions=nl2br,attr_list [admonition] extensions=admonition [smarty] extensions=smarty Markdown-2.4/tests/extensions/toc.html0000666000000000000000000007620311756571172016333 0ustar 00000000000000

Overview

Philosophy

Markdown is intended to be as easy-to-read and easy-to-write as is feasible.

Readability, however, is emphasized above all else. A Markdown-formatted document should be publishable as-is, as plain text, without looking like it's been marked up with tags or formatting instructions. While Markdown's syntax has been influenced by several existing text-to-HTML filters -- including Setext, atx, Textile, reStructuredText, Grutatext, and EtText -- the single biggest source of inspiration for Markdown's syntax is the format of plain text email.

To this end, Markdown's syntax is comprised entirely of punctuation characters, which punctuation characters have been carefully chosen so as to look like what they mean. E.g., asterisks around a word actually look like *emphasis*. Markdown lists look like, well, lists. Even blockquotes look like quoted passages of text, assuming you've ever used email.

Inline HTML

Markdown's syntax is intended for one purpose: to be used as a format for writing for the web.

Markdown is not a replacement for HTML, or even close to it. Its syntax is very small, corresponding only to a very small subset of HTML tags. The idea is not to create a syntax that makes it easier to insert HTML tags. In my opinion, HTML tags are already easy to insert. The idea for Markdown is to make it easy to read, write, and edit prose. HTML is a publishing format; Markdown is a writing format. Thus, Markdown's formatting syntax only addresses issues that can be conveyed in plain text.

For any markup that is not covered by Markdown's syntax, you simply use HTML itself. There's no need to preface it or delimit it to indicate that you're switching from Markdown to HTML; you just use the tags.

The only restrictions are that block-level HTML elements -- e.g. <div>, <table>, <pre>, <p>, etc. -- must be separated from surrounding content by blank lines, and the start and end tags of the block should not be indented with tabs or spaces. Markdown is smart enough not to add extra (unwanted) <p> tags around HTML block-level tags.

For example, to add an HTML table to a Markdown article:

This is a regular paragraph.

<table>
    <tr>
        <td>Foo</td>
    </tr>
</table>

This is another regular paragraph.

Note that Markdown formatting syntax is not processed within block-level HTML tags. E.g., you can't use Markdown-style *emphasis* inside an HTML block.

Span-level HTML tags -- e.g. <span>, <cite>, or <del> -- can be used anywhere in a Markdown paragraph, list item, or header. If you want, you can even use HTML tags instead of Markdown formatting; e.g. if you'd prefer to use HTML <a> or <img> tags instead of Markdown's link or image syntax, go right ahead.

Unlike block-level HTML tags, Markdown syntax is processed within span-level tags.

Automatic Escaping for Special Characters

In HTML, there are two characters that demand special treatment: < and &. Left angle brackets are used to start tags; ampersands are used to denote HTML entities. If you want to use them as literal characters, you must escape them as entities, e.g. &lt;, and &amp;.

Ampersands in particular are bedeviling for web writers. If you want to write about 'AT&T', you need to write 'AT&amp;T'. You even need to escape ampersands within URLs. Thus, if you want to link to:

http://images.google.com/images?num=30&q=larry+bird

you need to encode the URL as:

http://images.google.com/images?num=30&amp;q=larry+bird

in your anchor tag href attribute. Needless to say, this is easy to forget, and is probably the single most common source of HTML validation errors in otherwise well-marked-up web sites.

Markdown allows you to use these characters naturally, taking care of all the necessary escaping for you. If you use an ampersand as part of an HTML entity, it remains unchanged; otherwise it will be translated into &amp;.

So, if you want to include a copyright symbol in your article, you can write:

&copy;

and Markdown will leave it alone. But if you write:

AT&T

Markdown will translate it to:

AT&amp;T

Similarly, because Markdown supports inline HTML, if you use angle brackets as delimiters for HTML tags, Markdown will treat them as such. But if you write:

4 < 5

Markdown will translate it to:

4 &lt; 5

However, inside Markdown code spans and blocks, angle brackets and ampersands are always encoded automatically. This makes it easy to use Markdown to write about HTML code. (As opposed to raw HTML, which is a terrible format for writing about HTML syntax, because every single < and & in your example code needs to be escaped.)


Block Elements

Paragraphs and Line Breaks

A paragraph is simply one or more consecutive lines of text, separated by one or more blank lines. (A blank line is any line that looks like a blank line -- a line containing nothing but spaces or tabs is considered blank.) Normal paragraphs should not be intended with spaces or tabs.

The implication of the "one or more consecutive lines of text" rule is that Markdown supports "hard-wrapped" text paragraphs. This differs significantly from most other text-to-HTML formatters (including Movable Type's "Convert Line Breaks" option) which translate every line break character in a paragraph into a <br /> tag.

When you do want to insert a <br /> break tag using Markdown, you end a line with two or more spaces, then type return.

Yes, this takes a tad more effort to create a <br />, but a simplistic "every line break is a <br />" rule wouldn't work for Markdown. Markdown's email-style blockquoting and multi-paragraph list items work best -- and look better -- when you format them with hard breaks.

Headers

Markdown supports two styles of headers, Setext and atx.

Setext-style headers are "underlined" using equal signs (for first-level headers) and dashes (for second-level headers). For example:

This is an H1
=============

This is an H2
-------------

Any number of underlining ='s or -'s will work.

Atx-style headers use 1-6 hash characters at the start of the line, corresponding to header levels 1-6. For example:

# This is an H1

## This is an H2

###### This is an H6

Optionally, you may "close" atx-style headers. This is purely cosmetic -- you can use this if you think it looks better. The closing hashes don't even need to match the number of hashes used to open the header. (The number of opening hashes determines the header level.) :

# This is an H1 #

## This is an H2 ##

### This is an H3 ######

Blockquotes

Markdown uses email-style > characters for blockquoting. If you're familiar with quoting passages of text in an email message, then you know how to create a blockquote in Markdown. It looks best if you hard wrap the text and put a > before every line:

> This is a blockquote with two paragraphs. Lorem ipsum dolor sit amet,
> consectetuer adipiscing elit. Aliquam hendrerit mi posuere lectus.
> Vestibulum enim wisi, viverra nec, fringilla in, laoreet vitae, risus.
> 
> Donec sit amet nisl. Aliquam semper ipsum sit amet velit. Suspendisse
> id sem consectetuer libero luctus adipiscing.

Markdown allows you to be lazy and only put the > before the first line of a hard-wrapped paragraph:

> This is a blockquote with two paragraphs. Lorem ipsum dolor sit amet,
consectetuer adipiscing elit. Aliquam hendrerit mi posuere lectus.
Vestibulum enim wisi, viverra nec, fringilla in, laoreet vitae, risus.

> Donec sit amet nisl. Aliquam semper ipsum sit amet velit. Suspendisse
id sem consectetuer libero luctus adipiscing.

Blockquotes can be nested (i.e. a blockquote-in-a-blockquote) by adding additional levels of >:

> This is the first level of quoting.
>
> > This is nested blockquote.
>
> Back to the first level.

Blockquotes can contain other Markdown elements, including headers, lists, and code blocks:

> ## This is a header.
> 
> 1.   This is the first list item.
> 2.   This is the second list item.
> 
> Here's some example code:
> 
>     return shell_exec("echo $input | $markdown_script");

Any decent text editor should make email-style quoting easy. For example, with BBEdit, you can make a selection and choose Increase Quote Level from the Text menu.

Lists

Markdown supports ordered (numbered) and unordered (bulleted) lists.

Unordered lists use asterisks, pluses, and hyphens -- interchangably -- as list markers:

*   Red
*   Green
*   Blue

is equivalent to:

+   Red
+   Green
+   Blue

and:

-   Red
-   Green
-   Blue

Ordered lists use numbers followed by periods:

1.  Bird
2.  McHale
3.  Parish

It's important to note that the actual numbers you use to mark the list have no effect on the HTML output Markdown produces. The HTML Markdown produces from the above list is:

<ol>
<li>Bird</li>
<li>McHale</li>
<li>Parish</li>
</ol>

If you instead wrote the list in Markdown like this:

1.  Bird
1.  McHale
1.  Parish

or even:

3. Bird
1. McHale
8. Parish

you'd get the exact same HTML output. The point is, if you want to, you can use ordinal numbers in your ordered Markdown lists, so that the numbers in your source match the numbers in your published HTML. But if you want to be lazy, you don't have to.

If you do use lazy list numbering, however, you should still start the list with the number 1. At some point in the future, Markdown may support starting ordered lists at an arbitrary number.

List markers typically start at the left margin, but may be indented by up to three spaces. List markers must be followed by one or more spaces or a tab.

To make lists look nice, you can wrap items with hanging indents:

*   Lorem ipsum dolor sit amet, consectetuer adipiscing elit.
    Aliquam hendrerit mi posuere lectus. Vestibulum enim wisi,
    viverra nec, fringilla in, laoreet vitae, risus.
*   Donec sit amet nisl. Aliquam semper ipsum sit amet velit.
    Suspendisse id sem consectetuer libero luctus adipiscing.

But if you want to be lazy, you don't have to:

*   Lorem ipsum dolor sit amet, consectetuer adipiscing elit.
Aliquam hendrerit mi posuere lectus. Vestibulum enim wisi,
viverra nec, fringilla in, laoreet vitae, risus.
*   Donec sit amet nisl. Aliquam semper ipsum sit amet velit.
Suspendisse id sem consectetuer libero luctus adipiscing.

If list items are separated by blank lines, Markdown will wrap the items in <p> tags in the HTML output. For example, this input:

*   Bird
*   Magic

will turn into:

<ul>
<li>Bird</li>
<li>Magic</li>
</ul>

But this:

*   Bird

*   Magic

will turn into:

<ul>
<li><p>Bird</p></li>
<li><p>Magic</p></li>
</ul>

List items may consist of multiple paragraphs. Each subsequent paragraph in a list item must be intended by either 4 spaces or one tab:

1.  This is a list item with two paragraphs. Lorem ipsum dolor
    sit amet, consectetuer adipiscing elit. Aliquam hendrerit
    mi posuere lectus.

    Vestibulum enim wisi, viverra nec, fringilla in, laoreet
    vitae, risus. Donec sit amet nisl. Aliquam semper ipsum
    sit amet velit.

2.  Suspendisse id sem consectetuer libero luctus adipiscing.

It looks nice if you indent every line of the subsequent paragraphs, but here again, Markdown will allow you to be lazy:

*   This is a list item with two paragraphs.

    This is the second paragraph in the list item. You're
only required to indent the first line. Lorem ipsum dolor
sit amet, consectetuer adipiscing elit.

*   Another item in the same list.

To put a blockquote within a list item, the blockquote's > delimiters need to be indented:

*   A list item with a blockquote:

    > This is a blockquote
    > inside a list item.

To put a code block within a list item, the code block needs to be indented twice -- 8 spaces or two tabs:

*   A list item with a code block:

        <code goes here>

It's worth noting that it's possible to trigger an ordered list by accident, by writing something like this:

1986. What a great season.

In other words, a number-period-space sequence at the beginning of a line. To avoid this, you can backslash-escape the period:

1986\. What a great season.

Code Blocks

Pre-formatted code blocks are used for writing about programming or markup source code. Rather than forming normal paragraphs, the lines of a code block are interpreted literally. Markdown wraps a code block in both <pre> and <code> tags.

To produce a code block in Markdown, simply indent every line of the block by at least 4 spaces or 1 tab. For example, given this input:

This is a normal paragraph:

    This is a code block.

Markdown will generate:

<p>This is a normal paragraph:</p>

<pre><code>This is a code block.
</code></pre>

One level of indentation -- 4 spaces or 1 tab -- is removed from each line of the code block. For example, this:

Here is an example of AppleScript:

    tell application "Foo"
        beep
    end tell

will turn into:

<p>Here is an example of AppleScript:</p>

<pre><code>tell application "Foo"
    beep
end tell
</code></pre>

A code block continues until it reaches a line that is not indented (or the end of the article).

Within a code block, ampersands (&) and angle brackets (< and >) are automatically converted into HTML entities. This makes it very easy to include example HTML source code using Markdown -- just paste it and indent it, and Markdown will handle the hassle of encoding the ampersands and angle brackets. For example, this:

    <div class="footer">
        &copy; 2004 Foo Corporation
    </div>

will turn into:

<pre><code>&lt;div class="footer"&gt;
    &amp;copy; 2004 Foo Corporation
&lt;/div&gt;
</code></pre>

Regular Markdown syntax is not processed within code blocks. E.g., asterisks are just literal asterisks within a code block. This means it's also easy to use Markdown to write about Markdown's own syntax.

Horizontal Rules

You can produce a horizontal rule tag (<hr />) by placing three or more hyphens, asterisks, or underscores on a line by themselves. If you wish, you may use spaces between the hyphens or asterisks. Each of the following lines will produce a horizontal rule:

* * *

***

*****

- - -

---------------------------------------

_ _ _

Span Elements

Markdown supports two style of links: inline and reference.

In both styles, the link text is delimited by [square brackets].

To create an inline link, use a set of regular parentheses immediately after the link text's closing square bracket. Inside the parentheses, put the URL where you want the link to point, along with an optional title for the link, surrounded in quotes. For example:

This is [an example](http://example.com/ "Title") inline link.

[This link](http://example.net/) has no title attribute.

Will produce:

<p>This is <a href="http://example.com/" title="Title">
an example</a> inline link.</p>

<p><a href="http://example.net/">This link</a> has no
title attribute.</p>

If you're referring to a local resource on the same server, you can use relative paths:

See my [About](/about/) page for details.

Reference-style links use a second set of square brackets, inside which you place a label of your choosing to identify the link:

This is [an example][id] reference-style link.

You can optionally use a space to separate the sets of brackets:

This is [an example] [id] reference-style link.

Then, anywhere in the document, you define your link label like this, on a line by itself:

[id]: http://example.com/  "Optional Title Here"

That is:

  • Square brackets containing the link identifier (optionally indented from the left margin using up to three spaces);
  • followed by a colon;
  • followed by one or more spaces (or tabs);
  • followed by the URL for the link;
  • optionally followed by a title attribute for the link, enclosed in double or single quotes.

The link URL may, optionally, be surrounded by angle brackets:

[id]: <http://example.com/>  "Optional Title Here"

You can put the title attribute on the next line and use extra spaces or tabs for padding, which tends to look better with longer URLs:

[id]: http://example.com/longish/path/to/resource/here
    "Optional Title Here"

Link definitions are only used for creating links during Markdown processing, and are stripped from your document in the HTML output.

Link definition names may constist of letters, numbers, spaces, and punctuation -- but they are not case sensitive. E.g. these two links:

[link text][a]
[link text][A]

are equivalent.

The implicit link name shortcut allows you to omit the name of the link, in which case the link text itself is used as the name. Just use an empty set of square brackets -- e.g., to link the word "Google" to the google.com web site, you could simply write:

[Google][]

And then define the link:

[Google]: http://google.com/

Because link names may contain spaces, this shortcut even works for multiple words in the link text:

Visit [Daring Fireball][] for more information.

And then define the link:

[Daring Fireball]: http://daringfireball.net/

Link definitions can be placed anywhere in your Markdown document. I tend to put them immediately after each paragraph in which they're used, but if you want, you can put them all at the end of your document, sort of like footnotes.

Here's an example of reference links in action:

I get 10 times more traffic from [Google] [1] than from
[Yahoo] [2] or [MSN] [3].

  [1]: http://google.com/        "Google"
  [2]: http://search.yahoo.com/  "Yahoo Search"
  [3]: http://search.msn.com/    "MSN Search"

Using the implicit link name shortcut, you could instead write:

I get 10 times more traffic from [Google][] than from
[Yahoo][] or [MSN][].

  [google]: http://google.com/        "Google"
  [yahoo]:  http://search.yahoo.com/  "Yahoo Search"
  [msn]:    http://search.msn.com/    "MSN Search"

Both of the above examples will produce the following HTML output:

<p>I get 10 times more traffic from <a href="http://google.com/"
title="Google">Google</a> than from
<a href="http://search.yahoo.com/" title="Yahoo Search">Yahoo</a>
or <a href="http://search.msn.com/" title="MSN Search">MSN</a>.</p>

For comparison, here is the same paragraph written using Markdown's inline link style:

I get 10 times more traffic from [Google](http://google.com/ "Google")
than from [Yahoo](http://search.yahoo.com/ "Yahoo Search") or
[MSN](http://search.msn.com/ "MSN Search").

The point of reference-style links is not that they're easier to write. The point is that with reference-style links, your document source is vastly more readable. Compare the above examples: using reference-style links, the paragraph itself is only 81 characters long; with inline-style links, it's 176 characters; and as raw HTML, it's 234 characters. In the raw HTML, there's more markup than there is text.

With Markdown's reference-style links, a source document much more closely resembles the final output, as rendered in a browser. By allowing you to move the markup-related metadata out of the paragraph, you can add links without interrupting the narrative flow of your prose.

Emphasis

Markdown treats asterisks (*) and underscores (_) as indicators of emphasis. Text wrapped with one * or _ will be wrapped with an HTML <em> tag; double *'s or _'s will be wrapped with an HTML <strong> tag. E.g., this input:

*single asterisks*

_single underscores_

**double asterisks**

__double underscores__

will produce:

<em>single asterisks</em>

<em>single underscores</em>

<strong>double asterisks</strong>

<strong>double underscores</strong>

You can use whichever style you prefer; the lone restriction is that the same character must be used to open and close an emphasis span.

Emphasis can be used in the middle of a word:

un*fucking*believable

But if you surround an * or _ with spaces, it'll be treated as a literal asterisk or underscore.

To produce a literal asterisk or underscore at a position where it would otherwise be used as an emphasis delimiter, you can backslash escape it:

\*this text is surrounded by literal asterisks\*

Code

To indicate a span of code, wrap it with backtick quotes (`). Unlike a pre-formatted code block, a code span indicates code within a normal paragraph. For example:

Use the `printf()` function.

will produce:

<p>Use the <code>printf()</code> function.</p>

To include a literal backtick character within a code span, you can use multiple backticks as the opening and closing delimiters:

``There is a literal backtick (`) here.``

which will produce this:

<p><code>There is a literal backtick (`) here.</code></p>

The backtick delimiters surrounding a code span may include spaces -- one after the opening, one before the closing. This allows you to place literal backtick characters at the beginning or end of a code span:

A single backtick in a code span: `` ` ``

A backtick-delimited string in a code span: `` `foo` ``

will produce:

<p>A single backtick in a code span: <code>`</code></p>

<p>A backtick-delimited string in a code span: <code>`foo`</code></p>

With a code span, ampersands and angle brackets are encoded as HTML entities automatically, which makes it easy to include example HTML tags. Markdown will turn this:

Please don't use any `<blink>` tags.

into:

<p>Please don't use any <code>&lt;blink&gt;</code> tags.</p>

You can write this:

`&#8212;` is the decimal-encoded equivalent of `&mdash;`.

to produce:

<p><code>&amp;#8212;</code> is the decimal-encoded
equivalent of <code>&amp;mdash;</code>.</p>

Images

Admittedly, it's fairly difficult to devise a "natural" syntax for placing images into a plain text document format.

Markdown uses an image syntax that is intended to resemble the syntax for links, allowing for two styles: inline and reference.

Inline image syntax looks like this:

![Alt text](/path/to/img.jpg)

![Alt text](/path/to/img.jpg "Optional title")

That is:

  • An exclamation mark: !;
  • followed by a set of square brackets, containing the alt attribute text for the image;
  • followed by a set of parentheses, containing the URL or path to the image, and an optional title attribute enclosed in double or single quotes.

Reference-style image syntax looks like this:

![Alt text][id]

Where "id" is the name of a defined image reference. Image references are defined using syntax identical to link references:

[id]: url/to/image  "Optional title attribute"

As of this writing, Markdown has no syntax for specifying the dimensions of an image; if this is important to you, you can simply use regular HTML <img> tags.


Miscellaneous

Markdown supports a shortcut style for creating "automatic" links for URLs and email addresses: simply surround the URL or email address with angle brackets. What this means is that if you want to show the actual text of a URL or email address, and also have it be a clickable link, you can do this:

<http://example.com/>

Markdown will turn this into:

<a href="http://example.com/">http://example.com/</a>

Automatic links for email addresses work similarly, except that Markdown will also perform a bit of randomized decimal and hex entity-encoding to help obscure your address from address-harvesting spambots. For example, Markdown will turn this:

<address@example.com>

into something like this:

<a href="&#x6D;&#x61;i&#x6C;&#x74;&#x6F;:&#x61;&#x64;&#x64;&#x72;&#x65;
&#115;&#115;&#64;&#101;&#120;&#x61;&#109;&#x70;&#x6C;e&#x2E;&#99;&#111;
&#109;">&#x61;&#x64;&#x64;&#x72;&#x65;&#115;&#115;&#64;&#101;&#120;&#x61;
&#109;&#x70;&#x6C;e&#x2E;&#99;&#111;&#109;</a>

which will render in a browser as a clickable link to "address@example.com".

(This sort of entity-encoding trick will indeed fool many, if not most, address-harvesting bots, but it definitely won't fool all of them. It's better than nothing, but an address published in this way will probably eventually start receiving spam.)

Backslash Escapes

Markdown allows you to use backslash escapes to generate literal characters which would otherwise have special meaning in Markdown's formatting syntax. For example, if you wanted to surround a word with literal asterisks (instead of an HTML <em> tag), you can backslashes before the asterisks, like this:

\*literal asterisks\*

Markdown provides backslash escapes for the following characters:

\   backslash
`   backtick
*   asterisk
_   underscore
{}  curly braces
[]  square brackets
()  parentheses
#   hash mark
+   plus sign
-   minus sign (hyphen)
.   dot
!   exclamation mark
Markdown-2.4/tests/extensions/toc.txt0000666000000000000000000006405611756571172016211 0ustar 00000000000000 [TOC] # Overview ## Philosophy Markdown is intended to be as easy-to-read and easy-to-write as is feasible. Readability, however, is emphasized above all else. A Markdown-formatted document should be publishable as-is, as plain text, without looking like it's been marked up with tags or formatting instructions. While Markdown's syntax has been influenced by several existing text-to-HTML filters -- including [Setext] [1], [atx] [2], [Textile] [3], [reStructuredText] [4], [Grutatext] [5], and [EtText] [6] -- the single biggest source of inspiration for Markdown's syntax is the format of plain text email. [1]: http://docutils.sourceforge.net/mirror/setext.html [2]: http://www.aaronsw.com/2002/atx/ [3]: http://textism.com/tools/textile/ [4]: http://docutils.sourceforge.net/rst.html [5]: http://www.triptico.com/software/grutatxt.html [6]: http://ettext.taint.org/doc/ To this end, Markdown's syntax is comprised entirely of punctuation characters, which punctuation characters have been carefully chosen so as to look like what they mean. E.g., asterisks around a word actually look like \*emphasis\*. Markdown lists look like, well, lists. Even blockquotes look like quoted passages of text, assuming you've ever used email. ## Inline HTML Markdown's syntax is intended for one purpose: to be used as a format for *writing* for the web. Markdown is not a replacement for HTML, or even close to it. Its syntax is very small, corresponding only to a very small subset of HTML tags. The idea is *not* to create a syntax that makes it easier to insert HTML tags. In my opinion, HTML tags are already easy to insert. The idea for Markdown is to make it easy to read, write, and edit prose. HTML is a *publishing* format; Markdown is a *writing* format. Thus, Markdown's formatting syntax only addresses issues that can be conveyed in plain text. For any markup that is not covered by Markdown's syntax, you simply use HTML itself. There's no need to preface it or delimit it to indicate that you're switching from Markdown to HTML; you just use the tags. The only restrictions are that block-level HTML elements -- e.g. `
`, ``, `
`, `

`, etc. -- must be separated from surrounding content by blank lines, and the start and end tags of the block should not be indented with tabs or spaces. Markdown is smart enough not to add extra (unwanted) `

` tags around HTML block-level tags. For example, to add an HTML table to a Markdown article: This is a regular paragraph.

Foo
This is another regular paragraph. Note that Markdown formatting syntax is not processed within block-level HTML tags. E.g., you can't use Markdown-style `*emphasis*` inside an HTML block. Span-level HTML tags -- e.g. ``, ``, or `` -- can be used anywhere in a Markdown paragraph, list item, or header. If you want, you can even use HTML tags instead of Markdown formatting; e.g. if you'd prefer to use HTML `` or `` tags instead of Markdown's link or image syntax, go right ahead. Unlike block-level HTML tags, Markdown syntax *is* processed within span-level tags. ## Automatic Escaping for Special Characters In HTML, there are two characters that demand special treatment: `<` and `&`. Left angle brackets are used to start tags; ampersands are used to denote HTML entities. If you want to use them as literal characters, you must escape them as entities, e.g. `<`, and `&`. Ampersands in particular are bedeviling for web writers. If you want to write about 'AT&T', you need to write '`AT&T`'. You even need to escape ampersands within URLs. Thus, if you want to link to: http://images.google.com/images?num=30&q=larry+bird you need to encode the URL as: http://images.google.com/images?num=30&q=larry+bird in your anchor tag `href` attribute. Needless to say, this is easy to forget, and is probably the single most common source of HTML validation errors in otherwise well-marked-up web sites. Markdown allows you to use these characters naturally, taking care of all the necessary escaping for you. If you use an ampersand as part of an HTML entity, it remains unchanged; otherwise it will be translated into `&`. So, if you want to include a copyright symbol in your article, you can write: © and Markdown will leave it alone. But if you write: AT&T Markdown will translate it to: AT&T Similarly, because Markdown supports [inline HTML](#html), if you use angle brackets as delimiters for HTML tags, Markdown will treat them as such. But if you write: 4 < 5 Markdown will translate it to: 4 < 5 However, inside Markdown code spans and blocks, angle brackets and ampersands are *always* encoded automatically. This makes it easy to use Markdown to write about HTML code. (As opposed to raw HTML, which is a terrible format for writing about HTML syntax, because every single `<` and `&` in your example code needs to be escaped.) * * * # Block Elements ## Paragraphs and Line Breaks A paragraph is simply one or more consecutive lines of text, separated by one or more blank lines. (A blank line is any line that looks like a blank line -- a line containing nothing but spaces or tabs is considered blank.) Normal paragraphs should not be intended with spaces or tabs. The implication of the "one or more consecutive lines of text" rule is that Markdown supports "hard-wrapped" text paragraphs. This differs significantly from most other text-to-HTML formatters (including Movable Type's "Convert Line Breaks" option) which translate every line break character in a paragraph into a `
` tag. When you *do* want to insert a `
` break tag using Markdown, you end a line with two or more spaces, then type return. Yes, this takes a tad more effort to create a `
`, but a simplistic "every line break is a `
`" rule wouldn't work for Markdown. Markdown's email-style [blockquoting][bq] and multi-paragraph [list items][l] work best -- and look better -- when you format them with hard breaks. [bq]: #blockquote [l]: #list ## Headers Markdown supports two styles of headers, [Setext] [1] and [atx] [2]. Setext-style headers are "underlined" using equal signs (for first-level headers) and dashes (for second-level headers). For example: This is an H1 ============= This is an H2 ------------- Any number of underlining `=`'s or `-`'s will work. Atx-style headers use 1-6 hash characters at the start of the line, corresponding to header levels 1-6. For example: # This is an H1 ## This is an H2 ###### This is an H6 Optionally, you may "close" atx-style headers. This is purely cosmetic -- you can use this if you think it looks better. The closing hashes don't even need to match the number of hashes used to open the header. (The number of opening hashes determines the header level.) : # This is an H1 # ## This is an H2 ## ### This is an H3 ###### ## Blockquotes Markdown uses email-style `>` characters for blockquoting. If you're familiar with quoting passages of text in an email message, then you know how to create a blockquote in Markdown. It looks best if you hard wrap the text and put a `>` before every line: > This is a blockquote with two paragraphs. Lorem ipsum dolor sit amet, > consectetuer adipiscing elit. Aliquam hendrerit mi posuere lectus. > Vestibulum enim wisi, viverra nec, fringilla in, laoreet vitae, risus. > > Donec sit amet nisl. Aliquam semper ipsum sit amet velit. Suspendisse > id sem consectetuer libero luctus adipiscing. Markdown allows you to be lazy and only put the `>` before the first line of a hard-wrapped paragraph: > This is a blockquote with two paragraphs. Lorem ipsum dolor sit amet, consectetuer adipiscing elit. Aliquam hendrerit mi posuere lectus. Vestibulum enim wisi, viverra nec, fringilla in, laoreet vitae, risus. > Donec sit amet nisl. Aliquam semper ipsum sit amet velit. Suspendisse id sem consectetuer libero luctus adipiscing. Blockquotes can be nested (i.e. a blockquote-in-a-blockquote) by adding additional levels of `>`: > This is the first level of quoting. > > > This is nested blockquote. > > Back to the first level. Blockquotes can contain other Markdown elements, including headers, lists, and code blocks: > ## This is a header. > > 1. This is the first list item. > 2. This is the second list item. > > Here's some example code: > > return shell_exec("echo $input | $markdown_script"); Any decent text editor should make email-style quoting easy. For example, with BBEdit, you can make a selection and choose Increase Quote Level from the Text menu. ## Lists Markdown supports ordered (numbered) and unordered (bulleted) lists. Unordered lists use asterisks, pluses, and hyphens -- interchangably -- as list markers: * Red * Green * Blue is equivalent to: + Red + Green + Blue and: - Red - Green - Blue Ordered lists use numbers followed by periods: 1. Bird 2. McHale 3. Parish It's important to note that the actual numbers you use to mark the list have no effect on the HTML output Markdown produces. The HTML Markdown produces from the above list is:
  1. Bird
  2. McHale
  3. Parish
If you instead wrote the list in Markdown like this: 1. Bird 1. McHale 1. Parish or even: 3. Bird 1. McHale 8. Parish you'd get the exact same HTML output. The point is, if you want to, you can use ordinal numbers in your ordered Markdown lists, so that the numbers in your source match the numbers in your published HTML. But if you want to be lazy, you don't have to. If you do use lazy list numbering, however, you should still start the list with the number 1. At some point in the future, Markdown may support starting ordered lists at an arbitrary number. List markers typically start at the left margin, but may be indented by up to three spaces. List markers must be followed by one or more spaces or a tab. To make lists look nice, you can wrap items with hanging indents: * Lorem ipsum dolor sit amet, consectetuer adipiscing elit. Aliquam hendrerit mi posuere lectus. Vestibulum enim wisi, viverra nec, fringilla in, laoreet vitae, risus. * Donec sit amet nisl. Aliquam semper ipsum sit amet velit. Suspendisse id sem consectetuer libero luctus adipiscing. But if you want to be lazy, you don't have to: * Lorem ipsum dolor sit amet, consectetuer adipiscing elit. Aliquam hendrerit mi posuere lectus. Vestibulum enim wisi, viverra nec, fringilla in, laoreet vitae, risus. * Donec sit amet nisl. Aliquam semper ipsum sit amet velit. Suspendisse id sem consectetuer libero luctus adipiscing. If list items are separated by blank lines, Markdown will wrap the items in `

` tags in the HTML output. For example, this input: * Bird * Magic will turn into:

  • Bird
  • Magic
But this: * Bird * Magic will turn into:
  • Bird

  • Magic

List items may consist of multiple paragraphs. Each subsequent paragraph in a list item must be intended by either 4 spaces or one tab: 1. This is a list item with two paragraphs. Lorem ipsum dolor sit amet, consectetuer adipiscing elit. Aliquam hendrerit mi posuere lectus. Vestibulum enim wisi, viverra nec, fringilla in, laoreet vitae, risus. Donec sit amet nisl. Aliquam semper ipsum sit amet velit. 2. Suspendisse id sem consectetuer libero luctus adipiscing. It looks nice if you indent every line of the subsequent paragraphs, but here again, Markdown will allow you to be lazy: * This is a list item with two paragraphs. This is the second paragraph in the list item. You're only required to indent the first line. Lorem ipsum dolor sit amet, consectetuer adipiscing elit. * Another item in the same list. To put a blockquote within a list item, the blockquote's `>` delimiters need to be indented: * A list item with a blockquote: > This is a blockquote > inside a list item. To put a code block within a list item, the code block needs to be indented *twice* -- 8 spaces or two tabs: * A list item with a code block: It's worth noting that it's possible to trigger an ordered list by accident, by writing something like this: 1986. What a great season. In other words, a *number-period-space* sequence at the beginning of a line. To avoid this, you can backslash-escape the period: 1986\. What a great season. ## Code Blocks Pre-formatted code blocks are used for writing about programming or markup source code. Rather than forming normal paragraphs, the lines of a code block are interpreted literally. Markdown wraps a code block in both `
` and `` tags.

To produce a code block in Markdown, simply indent every line of the
block by at least 4 spaces or 1 tab. For example, given this input:

    This is a normal paragraph:

        This is a code block.

Markdown will generate:

    

This is a normal paragraph:

This is a code block.
    
One level of indentation -- 4 spaces or 1 tab -- is removed from each line of the code block. For example, this: Here is an example of AppleScript: tell application "Foo" beep end tell will turn into:

Here is an example of AppleScript:

tell application "Foo"
        beep
    end tell
    
A code block continues until it reaches a line that is not indented (or the end of the article). Within a code block, ampersands (`&`) and angle brackets (`<` and `>`) are automatically converted into HTML entities. This makes it very easy to include example HTML source code using Markdown -- just paste it and indent it, and Markdown will handle the hassle of encoding the ampersands and angle brackets. For example, this: will turn into:
<div class="footer">
        &copy; 2004 Foo Corporation
    </div>
    
Regular Markdown syntax is not processed within code blocks. E.g., asterisks are just literal asterisks within a code block. This means it's also easy to use Markdown to write about Markdown's own syntax. ## Horizontal Rules You can produce a horizontal rule tag (`
`) by placing three or more hyphens, asterisks, or underscores on a line by themselves. If you wish, you may use spaces between the hyphens or asterisks. Each of the following lines will produce a horizontal rule: * * * *** ***** - - - --------------------------------------- _ _ _ * * * # Span Elements ## Links Markdown supports two style of links: *inline* and *reference*. In both styles, the link text is delimited by [square brackets]. To create an inline link, use a set of regular parentheses immediately after the link text's closing square bracket. Inside the parentheses, put the URL where you want the link to point, along with an *optional* title for the link, surrounded in quotes. For example: This is [an example](http://example.com/ "Title") inline link. [This link](http://example.net/) has no title attribute. Will produce:

This is an example inline link.

This link has no title attribute.

If you're referring to a local resource on the same server, you can use relative paths: See my [About](/about/) page for details. Reference-style links use a second set of square brackets, inside which you place a label of your choosing to identify the link: This is [an example][id] reference-style link. You can optionally use a space to separate the sets of brackets: This is [an example] [id] reference-style link. Then, anywhere in the document, you define your link label like this, on a line by itself: [id]: http://example.com/ "Optional Title Here" That is: * Square brackets containing the link identifier (optionally indented from the left margin using up to three spaces); * followed by a colon; * followed by one or more spaces (or tabs); * followed by the URL for the link; * optionally followed by a title attribute for the link, enclosed in double or single quotes. The link URL may, optionally, be surrounded by angle brackets: [id]: "Optional Title Here" You can put the title attribute on the next line and use extra spaces or tabs for padding, which tends to look better with longer URLs: [id]: http://example.com/longish/path/to/resource/here "Optional Title Here" Link definitions are only used for creating links during Markdown processing, and are stripped from your document in the HTML output. Link definition names may constist of letters, numbers, spaces, and punctuation -- but they are *not* case sensitive. E.g. these two links: [link text][a] [link text][A] are equivalent. The *implicit link name* shortcut allows you to omit the name of the link, in which case the link text itself is used as the name. Just use an empty set of square brackets -- e.g., to link the word "Google" to the google.com web site, you could simply write: [Google][] And then define the link: [Google]: http://google.com/ Because link names may contain spaces, this shortcut even works for multiple words in the link text: Visit [Daring Fireball][] for more information. And then define the link: [Daring Fireball]: http://daringfireball.net/ Link definitions can be placed anywhere in your Markdown document. I tend to put them immediately after each paragraph in which they're used, but if you want, you can put them all at the end of your document, sort of like footnotes. Here's an example of reference links in action: I get 10 times more traffic from [Google] [1] than from [Yahoo] [2] or [MSN] [3]. [1]: http://google.com/ "Google" [2]: http://search.yahoo.com/ "Yahoo Search" [3]: http://search.msn.com/ "MSN Search" Using the implicit link name shortcut, you could instead write: I get 10 times more traffic from [Google][] than from [Yahoo][] or [MSN][]. [google]: http://google.com/ "Google" [yahoo]: http://search.yahoo.com/ "Yahoo Search" [msn]: http://search.msn.com/ "MSN Search" Both of the above examples will produce the following HTML output:

I get 10 times more traffic from Google than from Yahoo or MSN.

For comparison, here is the same paragraph written using Markdown's inline link style: I get 10 times more traffic from [Google](http://google.com/ "Google") than from [Yahoo](http://search.yahoo.com/ "Yahoo Search") or [MSN](http://search.msn.com/ "MSN Search"). The point of reference-style links is not that they're easier to write. The point is that with reference-style links, your document source is vastly more readable. Compare the above examples: using reference-style links, the paragraph itself is only 81 characters long; with inline-style links, it's 176 characters; and as raw HTML, it's 234 characters. In the raw HTML, there's more markup than there is text. With Markdown's reference-style links, a source document much more closely resembles the final output, as rendered in a browser. By allowing you to move the markup-related metadata out of the paragraph, you can add links without interrupting the narrative flow of your prose. ## Emphasis Markdown treats asterisks (`*`) and underscores (`_`) as indicators of emphasis. Text wrapped with one `*` or `_` will be wrapped with an HTML `` tag; double `*`'s or `_`'s will be wrapped with an HTML `` tag. E.g., this input: *single asterisks* _single underscores_ **double asterisks** __double underscores__ will produce: single asterisks single underscores double asterisks double underscores You can use whichever style you prefer; the lone restriction is that the same character must be used to open and close an emphasis span. Emphasis can be used in the middle of a word: un*fucking*believable But if you surround an `*` or `_` with spaces, it'll be treated as a literal asterisk or underscore. To produce a literal asterisk or underscore at a position where it would otherwise be used as an emphasis delimiter, you can backslash escape it: \*this text is surrounded by literal asterisks\* ## Code To indicate a span of code, wrap it with backtick quotes (`` ` ``). Unlike a pre-formatted code block, a code span indicates code within a normal paragraph. For example: Use the `printf()` function. will produce:

Use the printf() function.

To include a literal backtick character within a code span, you can use multiple backticks as the opening and closing delimiters: ``There is a literal backtick (`) here.`` which will produce this:

There is a literal backtick (`) here.

The backtick delimiters surrounding a code span may include spaces -- one after the opening, one before the closing. This allows you to place literal backtick characters at the beginning or end of a code span: A single backtick in a code span: `` ` `` A backtick-delimited string in a code span: `` `foo` `` will produce:

A single backtick in a code span: `

A backtick-delimited string in a code span: `foo`

With a code span, ampersands and angle brackets are encoded as HTML entities automatically, which makes it easy to include example HTML tags. Markdown will turn this: Please don't use any `` tags. into:

Please don't use any <blink> tags.

You can write this: `—` is the decimal-encoded equivalent of `—`. to produce:

&#8212; is the decimal-encoded equivalent of &mdash;.

## Images Admittedly, it's fairly difficult to devise a "natural" syntax for placing images into a plain text document format. Markdown uses an image syntax that is intended to resemble the syntax for links, allowing for two styles: *inline* and *reference*. Inline image syntax looks like this: ![Alt text](/path/to/img.jpg) ![Alt text](/path/to/img.jpg "Optional title") That is: * An exclamation mark: `!`; * followed by a set of square brackets, containing the `alt` attribute text for the image; * followed by a set of parentheses, containing the URL or path to the image, and an optional `title` attribute enclosed in double or single quotes. Reference-style image syntax looks like this: ![Alt text][id] Where "id" is the name of a defined image reference. Image references are defined using syntax identical to link references: [id]: url/to/image "Optional title attribute" As of this writing, Markdown has no syntax for specifying the dimensions of an image; if this is important to you, you can simply use regular HTML `` tags. * * * # Miscellaneous ## Automatic Links Markdown supports a shortcut style for creating "automatic" links for URLs and email addresses: simply surround the URL or email address with angle brackets. What this means is that if you want to show the actual text of a URL or email address, and also have it be a clickable link, you can do this: Markdown will turn this into: http://example.com/ Automatic links for email addresses work similarly, except that Markdown will also perform a bit of randomized decimal and hex entity-encoding to help obscure your address from address-harvesting spambots. For example, Markdown will turn this: into something like this: address@exa mple.com which will render in a browser as a clickable link to "address@example.com". (This sort of entity-encoding trick will indeed fool many, if not most, address-harvesting bots, but it definitely won't fool all of them. It's better than nothing, but an address published in this way will probably eventually start receiving spam.) ## Backslash Escapes Markdown allows you to use backslash escapes to generate literal characters which would otherwise have special meaning in Markdown's formatting syntax. For example, if you wanted to surround a word with literal asterisks (instead of an HTML `` tag), you can backslashes before the asterisks, like this: \*literal asterisks\* Markdown provides backslash escapes for the following characters: \ backslash ` backtick * asterisk _ underscore {} curly braces [] square brackets () parentheses # hash mark + plus sign - minus sign (hyphen) . dot ! exclamation mark Markdown-2.4/tests/extensions/toc_invalid.html0000666000000000000000000000050711756571172020033 0ustar 00000000000000

[TOC]

Header 1

The TOC marker cannot be inside a header. This test makes sure markdown doesn't crash when it encounters this errant syntax. The unexpected output should clue the author in that s/he needs to add a blank line between the TOC and the <hr>.

Markdown-2.4/tests/extensions/toc_invalid.txt0000666000000000000000000000042511756571172017705 0ustar 00000000000000[TOC] ----- # Header 1 The TOC marker cannot be inside a header. This test makes sure markdown doesn't crash when it encounters this errant syntax. The unexpected output should clue the author in that s/he needs to add a blank line between the TOC and the `
`. Markdown-2.4/tests/extensions/toc_nested.html0000666000000000000000000000123112261107557017654 0ustar 00000000000000

Header A

Header 1

Header i

Header B

Markdown-2.4/tests/extensions/toc_nested.txt0000666000000000000000000000010412111563047017517 0ustar 00000000000000# Header A ## Header 1 ### Header i # Header *B* [TOC] Markdown-2.4/tests/extensions/toc_nested2.html0000666000000000000000000000140312261107557017737 0ustar 00000000000000

Start with header other than one.[link]

Header 3[link]

Header 4[link]

Header 3[link]

Markdown-2.4/tests/extensions/toc_nested2.txt0000666000000000000000000000014311756571172017620 0ustar 00000000000000[TOC] ### Start with header other than one. ### Header 3 #### Header 4 ### Header 3 Markdown-2.4/tests/extensions/toc_out_of_order.html0000666000000000000000000000027612111563047021062 0ustar 00000000000000

Header 2

Header 1

Markdown-2.4/tests/extensions/toc_out_of_order.txt0000666000000000000000000000004412111563047020726 0ustar 00000000000000[TOC] ## Header 2 # Header 1 Markdown-2.4/tests/extensions/wikilinks.html0000666000000000000000000000157111756571172017546 0ustar 00000000000000

Some text with a WikiLink.

A link with white space and_underscores and a empty one.

Another with double spaces and double__underscores and one that has emphasis inside and one with_multiple_underscores and one that is emphasised.

And a RealLink.

http://example.com/And_A_AutoLink

And a MarkdownLink for completeness.

Markdown-2.4/tests/extensions/wikilinks.txt0000666000000000000000000000071211756571172017415 0ustar 00000000000000Some text with a [[WikiLink]]. A link with [[ white space and_underscores ]] and a empty [[ ]] one. Another with [[double spaces]] and [[double__underscores]] and one that [[has _emphasis_ inside]] and one [[with_multiple_underscores]] and one that is _[[emphasised]]_. And a RealLink. And a [MarkdownLink](/MarkdownLink/ "A MarkdownLink") for completeness. Markdown-2.4/tests/html4/0000777000000000000000000000000012300213222013450 5ustar 00000000000000Markdown-2.4/tests/html4/html4.html0000666000000000000000000000007711756571172015423 0ustar 00000000000000

A test of the most
basic of html/xhtml differences.

Markdown-2.4/tests/html4/html4.txt0000666000000000000000000000006611756571172015274 0ustar 00000000000000A test of the most basic of html/xhtml differences.Markdown-2.4/tests/html4/test.cfg0000666000000000000000000000004011756571172015133 0ustar 00000000000000[DEFAULT] output_format=html4 Markdown-2.4/tests/misc/0000777000000000000000000000000012300213224013355 5ustar 00000000000000Markdown-2.4/tests/misc/adjacent-headers.html0000666000000000000000000000010111756571172017444 0ustar 00000000000000

this is a huge header

this is a smaller header

Markdown-2.4/tests/misc/adjacent-headers.txt0000666000000000000000000000007311756571172017327 0ustar 00000000000000# this is a huge header # ## this is a smaller header ## Markdown-2.4/tests/misc/amp-in-url.html0000666000000000000000000000010111756571172016243 0ustar 00000000000000

link

Markdown-2.4/tests/misc/amp-in-url.txt0000666000000000000000000000005511756571172016126 0ustar 00000000000000[link](http://www.freewisdom.org/this&that) Markdown-2.4/tests/misc/ampersand.html0000666000000000000000000000003511756571172016242 0ustar 00000000000000

&

AT&T

Markdown-2.4/tests/misc/ampersand.txt0000666000000000000000000000001711756571172016115 0ustar 00000000000000& AT&T Markdown-2.4/tests/misc/arabic.html0000666000000000000000000000425711756571172015523 0ustar 00000000000000

بايثون

بايثون لغة برمجة حديثة بسيطة، واضحة، سريعة ØŒ تستخدم أسلوب البرمجة الكائنية (OOP) وقابلة للتطوير Ø¨Ø§Ù„Ø¥Ø¶Ø§ÙØ© إلى أنها مجانية Ùˆ Ù…ÙØªÙˆØ­Ø© المصدر. صÙÙ†ÙØª بالأساس كلغة ØªÙØ³ÙŠØ±ÙŠØ© ØŒ بايثون مصممة أصلاً للأداء بعض المهام الخاصة أو المحدودة. إلا أنه يمكن استخدامها بايثون لإنجاز المشاريع الضخمه كأي لغة برمجية أخرى، غالباً ما ÙŠÙنصح المبتدئين ÙÙŠ ميدان البرمجة بتعلم هذه اللغة لأنها من بين أسهل اللغات البرمجية تعلماً.

نشأت بايثون ÙÙŠ مركز CWI (مركز العلوم والحاسب الآلي) بأمستردام على يد جويدو ÙØ§Ù† Ø±ÙØ²ÙˆÙ…. تم تطويرها بلغة C. أطلق ÙØ§Ù† Ø±ÙØ²ÙˆÙ… اسم "بايثون" على لغته تعبيرًا عن إعجابه بÙÙØ±Ù‚ÙŽØ© مسرحية هزلية شهيرة من بريطانيا، كانت تطلق على Ù†ÙØ³Ù‡Ø§ اسم مونتي بايثون Monty Python.

تتميز بايثون بمجتمعها النشط ØŒ كما أن لها الكثير من المكتبات البرمجية ذات الأغراض الخاصة والتي برمجها أشخاص من مجتمع هذه اللغة ØŒ مثلاً مكتبة PyGame التي ØªÙˆÙØ± مجموعه من الوظائ٠من اجل برمجة الالعاب. ويمكن لبايثون التعامل مع العديد من أنواع قواعد البيانات مثل MySQL وغيره.

أمثلة

مثال Hello World!

print "Hello World!"

مثال لاستخراج المضروب Factorial :

num = 1
x = raw_input('Insert the number please ')
x = int(x)

if x > 69:
 print 'Math Error !'
else:
 while x > 1:
  num *= x
  x = x-1

 print num

وصلات خارجية

بذرة حاس

Markdown-2.4/tests/misc/arabic.txt0000666000000000000000000000413411756571172015370 0ustar 00000000000000 بايثون ===== **بايثون** لغة برمجة حديثة بسيطة، واضحة، سريعة ØŒ تستخدم أسلوب البرمجة الكائنية (OOP) وقابلة للتطوير Ø¨Ø§Ù„Ø¥Ø¶Ø§ÙØ© إلى أنها مجانية Ùˆ Ù…ÙØªÙˆØ­Ø© المصدر. صÙÙ†ÙØª بالأساس كلغة ØªÙØ³ÙŠØ±ÙŠØ© ØŒ بايثون مصممة أصلاً للأداء بعض المهام الخاصة أو المحدودة. إلا أنه يمكن استخدامها بايثون لإنجاز المشاريع الضخمه كأي لغة برمجية أخرى، غالباً ما ÙŠÙنصح المبتدئين ÙÙŠ ميدان البرمجة بتعلم هذه اللغة لأنها من بين أسهل اللغات البرمجية تعلماً. نشأت بايثون ÙÙŠ مركز CWI (مركز العلوم والحاسب الآلي) بأمستردام على يد جويدو ÙØ§Ù† Ø±ÙØ²ÙˆÙ…. تم تطويرها بلغة C. أطلق ÙØ§Ù† Ø±ÙØ²ÙˆÙ… اسم "بايثون" على لغته تعبيرًا عن إعجابه بÙÙØ±Ù‚ÙŽØ© مسرحية هزلية شهيرة من بريطانيا، كانت تطلق على Ù†ÙØ³Ù‡Ø§ اسم مونتي بايثون Monty Python. تتميز بايثون بمجتمعها النشط ØŒ كما أن لها الكثير من المكتبات البرمجية ذات الأغراض الخاصة والتي برمجها أشخاص من مجتمع هذه اللغة ØŒ مثلاً مكتبة PyGame التي ØªÙˆÙØ± مجموعه من الوظائ٠من اجل برمجة الالعاب. ويمكن لبايثون التعامل مع العديد من أنواع قواعد البيانات مثل MySQL وغيره. ##أمثلة مثال Hello World! print "Hello World!" مثال لاستخراج المضروب Factorial : num = 1 x = raw_input('Insert the number please ') x = int(x) if x > 69: print 'Math Error !' else: while x > 1: num *= x x = x-1 print num ##وصلات خارجية * [الموقع الرسمي للغة بايثون](http://www.python.org) بذرة حاس Markdown-2.4/tests/misc/attributes-image-ref.html0000666000000000000000000000010012111563047020265 0ustar 00000000000000

img

Markdown-2.4/tests/misc/attributes-image-ref.txt0000666000000000000000000000007512111563047020153 0ustar 00000000000000![img{@id=foo}][img] [img]: http://example.com/i.jpg Markdown-2.4/tests/misc/attributes2.html0000666000000000000000000000024411756571172016542 0ustar 00000000000000

Or in the middle of the text

Markdown-2.4/tests/misc/attributes2.txt0000666000000000000000000000021111756571172016407 0ustar 00000000000000{@id=TABLE.OF.CONTENTS} * {@id=TABLEOFCONTENTS} Or in the middle of the text {@id=TABLEOFCONTENTS} {@id=tableofcontents} Markdown-2.4/tests/misc/autolinks_with_asterisks.html0000666000000000000000000000012611756571172021425 0ustar 00000000000000

http://some.site/weird*url*thing

Markdown-2.4/tests/misc/autolinks_with_asterisks.txt0000666000000000000000000000004611756571172021301 0ustar 00000000000000 Markdown-2.4/tests/misc/autolinks_with_asterisks_russian.html0000666000000000000000000000020411756571172023166 0ustar 00000000000000

http://some.site/нечто*очень*Ñтранное

Markdown-2.4/tests/misc/autolinks_with_asterisks_russian.txt0000666000000000000000000000007711756571172023051 0ustar 00000000000000 Markdown-2.4/tests/misc/backtick-escape.html0000666000000000000000000000016511756571172017305 0ustar 00000000000000

\`This should not be in code.\` `This also should not be in code.` `And finally this should not be in code.`

Markdown-2.4/tests/misc/backtick-escape.txt0000666000000000000000000000016511756571172017160 0ustar 00000000000000\\`This should not be in code.\\` \`This also should not be in code.\` \`And finally this should not be in code.` Markdown-2.4/tests/misc/bidi.html0000666000000000000000000001733611756571172015213 0ustar 00000000000000

Python(パイソン)ã¯ã€Guido van Rossum ã«ã‚ˆã£ã¦ä½œã‚‰ã‚ŒãŸã‚ªãƒ¼ãƒ—ンソースã®ã‚ªãƒ–ジェクト指å‘スクリプト言語。Perlã¨ã¨ã‚‚ã«æ¬§ç±³ã§åºƒãæ™®åŠã—ã¦ã„る。イギリスã®ãƒ†ãƒ¬ãƒ“å±€ BBC ãŒè£½ä½œã—ãŸã‚³ãƒ¡ãƒ‡ã‚£ç•ªçµ„『空飛ã¶ãƒ¢ãƒ³ãƒ†ã‚£ãƒ»ãƒ‘イソンã€ã«ã¡ãªã‚“ã§å付ã‘られãŸã€‚ (Pythonã«ã¯ã€çˆ¬è™«é¡žã®ãƒ‹ã‚·ã‚­ãƒ˜ãƒ“ã®æ„味ãŒã‚りã€Python言語ã®ãƒžã‚¹ã‚³ãƒƒãƒˆã‚„アイコンã¨ã—ã¦ä½¿ã‚れるã“ã¨ãŒã‚る。)

|||||||||||||||||||||||||||||THIS SHOULD BE LTR|||||||||||||||||||||||||

|||||||||||||||||||||||||||||THIS SHOULD BE RTL|||||||||||||||||||||||||

(بايثون لغة برمجة حديثة بسيطة، واضحة، سريعة ØŒ تستخدم أسلوب البرمجة الكائنية (THIS SHOULD BE LTR ) وقابلة للتطوير Ø¨Ø§Ù„Ø¥Ø¶Ø§ÙØ© إلى أنها مجانية Ùˆ Ù…ÙØªÙˆØ­

پایتون زبان برنامه‌نویسی ØªÙØ³ÛŒØ±ÛŒ Ùˆ سطح بالا ØŒ شی‌گرا Ùˆ یک زبان برنامه‌نویسی ØªÙØ³ÛŒØ±ÛŒ سمت سرور قدرتمند است Ú©Ù‡ توسط گیدو ون روسوم در سال Û±Û¹Û¹Û° ساخته شد. این زبان در ویژگی‌ها شبیه پرل، روبی، اسکیم، اسمال‌تاک Ùˆ تی‌سی‌ال است Ùˆ از مدیریت خودکار Ø­Ø§ÙØ¸Ù‡ Ø§Ø³ØªÙØ§Ø¯Ù‡ می‌کند

Python,是一ç§é¢å‘对象的ã€ç›´è­¯å¼çš„计算机程åºè®¾è®¡è¯­è¨€ï¼Œä¹Ÿæ˜¯ä¸€ç§åŠŸèƒ½å¼ºå¤§è€Œå®Œå–„çš„é€šç”¨åž‹è¯­è¨€ï¼Œå·²ç»å…·æœ‰å多年的å‘展历å²ï¼Œæˆç†Ÿä¸”稳定。

Þ„Þ°ÞÞ« ÞˆÞ­ÞÞ°ÞŽÞ¬ Þ‹Þ« މަތީގައި Þ‡Þ¬Þ‡Þ°ÞŠÞ¦Þ€Þ¦ÞƒÞ§ 50 Þ‰Þ©Þ€ÞªÞ‚Þ°Þ‚Þ¦ÞÞ° ތިބެވިދާނެވެ. Þ„Þ®Þ‘Þª Þ‰Þ¦Þ€ÞªÞŽÞ¬ Þ‹ÞªÞÞ¦Þ†Þ© Þ‡Þ¬Þ€Þ§Þ‰Þ¬ Þ„Þ®Þ‘Þª Þ‡Þ¬Þ‡Þ°Þ—Þ¬Þ†Þ¬ÞˆÞ¬.

உரà¯à®¤à¯ 13ஆம௠நூறà¯à®±à®¾à®£à¯à®Ÿà®¿à®²à¯ உரà¯à®µà®¾à®© ஒர௠இநà¯à®¤à¯‹-à®à®°à¯‹à®ªà¯à®ªà®¿à®¯ மொழியாகà¯à®®à¯. உரà¯à®¤à¯, ஹிநà¯à®¤à®¿à®¯à¯à®Ÿà®©à¯ சேரà¯à®¤à¯à®¤à¯ "ஹிநà¯à®¤à¯à®¸à¯à®¤à®¾à®©à®¿" என அழைகà¯à®•பà¯à®ªà®Ÿà¯à®•ினà¯à®±à®¤à¯. மணà¯à®Ÿà®°à®¿à®©à¯, ஆஙà¯à®•ிலம௠ஆகியவறà¯à®±à¯à®•à¯à®•௠அடà¯à®¤à¯à®¤à®ªà®Ÿà®¿à®¯à®¾à®• மூனà¯à®±à®¾à®µà®¤à¯ கூடிய அளவ௠மகà¯à®•ளால௠பà¯à®°à®¿à®¨à¯à®¤à¯ கொளà¯à®³à®ªà¯à®ªà®Ÿà®•à¯à®•ூடியத௠ஹிநà¯à®¤à¯à®¸à¯à®¤à®¾à®©à®¿à®¯à¯‡à®¯à®¾à®•à¯à®®à¯. தாய௠மொழியாகப௠பேசà¯à®ªà®µà®°à¯à®•ள௠எணà¯à®£à®¿à®•à¯à®•ையின௠அடிபà¯à®ªà®Ÿà¯ˆà®¯à®¿à®²à¯ உரà¯à®¤à¯ உலகின௠20 ஆவத௠பெரிய மொழியாகà¯à®®à¯. 6 கோடி மகà¯à®•ள௠இதனைத௠தாய௠மொழியாகக௠கொணà¯à®Ÿà¯à®³à¯à®³à®¾à®°à¯à®•ளà¯. இரணà¯à®Ÿà®¾à®µà®¤à¯ மொழியாகக௠கொணà¯à®Ÿà¯à®³à¯à®³à®µà®°à¯à®•ள௠உடà¯à®ªà®Ÿ 11 கோடிப௠பேர௠இதனைப௠பேசà¯à®•ிறாரà¯à®•ளà¯. உரà¯à®¤à¯ பாகிஸà¯à®¤à®¾à®©à®¿à®©à¯ அரசகரà¯à®® மொழியாகவà¯à®®à¯, இநà¯à®¤à®¿à®¯à®¾à®µà®¿à®©à¯ அரசகரà¯à®® மொழிகளà¯à®³à¯ ஒனà¯à®±à®¾à®•வà¯à®®à¯ விளஙà¯à®•à¯à®•ிறதà¯.

اردو Ûندوآریائی زبانوں Ú©ÛŒ Ûندويورپی شاخ Ú©ÛŒ ایک زبان ÛÛ’ جو تيرھويں صدی ميں بر صغير ميں پيدا Ûوئی Ù€ اردو پاکستان Ú©ÛŒ سرکاری زبان ÛÛ’ اور بھارت Ú©ÛŒ سرکاری زبانوں ميں سے ايک ÛÛ’Û” اردو بھارت ميں 5 کروڑ اور پاکستان ميں 1 کروڑ لوگوں Ú©ÛŒ مادری زبان ÛÛ’ مگر اسے بھارت اور پاکستان Ú©Û’ تقریباً 50 کروڑ لوگ بول اور سمجھ سکتے ھیں Û” جن میں سے تقریباً 10.5 کروڑ لوگ اسے Ø¨Ø§Ù‚Ø§Ø¹Ø¯Û Ø¨ÙˆÙ„ØªÛ’ ھیں۔

بايثون

بايثون لغة برمجة حديثة بسيطة، واضحة، سريعة ØŒ تستخدم أسلوب البرمجة الكائنية (OOP) وقابلة للتطوير Ø¨Ø§Ù„Ø¥Ø¶Ø§ÙØ© إلى أنها مجانية Ùˆ Ù…ÙØªÙˆØ­Ø© المصدر. صÙÙ†ÙØª بالأساس كلغة ØªÙØ³ÙŠØ±ÙŠØ© ØŒ بايثون مصممة أصلاً للأداء بعض المهام الخاصة أو المحدودة. إلا أنه يمكن استخدامها بايثون لإنجاز المشاريع الضخمه كأي لغة برمجية أخرى، غالباً ما ÙŠÙنصح المبتدئين ÙÙŠ ميدان البرمجة بتعلم هذه اللغة لأنها من بين أسهل اللغات البرمجية تعلماً.

|||||||||||||||||||||||||||||THIS SHOULD BE RTL|||||||||||||||||||||||||

(نشأت بايثون ÙÙŠ مركز CWI (مركز العلوم والحاسب الآلي) بأمستردام على يد جويدو ÙØ§Ù† Ø±ÙØ²ÙˆÙ…. تم تطويرها بلغة C. أطلق ÙØ§Ù† Ø±ÙØ²ÙˆÙ… اسم "بايثون" على لغته تعبيرًا عن إعجابه بÙÙØ±Ù‚ÙŽØ© مسرحية هزلية شهيرة من بريطانيا، كانت تطلق على Ù†ÙØ³Ù‡Ø§ اسم مونتي بايثون Monty Python.

تتميز بايثون بمجتمعها النشط ØŒ كما أن لها الكثير من المكتبات البرمجية ذات الأغراض الخاصة والتي برمجها أشخاص من مجتمع هذه اللغة ØŒ مثلاً مكتبة PyGame التي ØªÙˆÙØ± مجموعه من الوظائ٠من اجل برمجة الالعاب. ويمكن لبايثون التعامل مع العديد من أنواع قواعد البيانات مثل MySQL وغيره.

أمثلة

مثال Hello World!

print "Hello World!"

مثال لاستخراج المضروب Factorial :

num = 1
x = raw_input('Insert the number please ')
x = int(x)

if x > 69:
 print 'Math Error !'
else:
 while x > 1:
  num *= x
  x = x-1

 print num

وصلات خارجية

بذرة حاس

Ðедвард «Ðед» Ð¤Ð»Ð°Ð½Ð´ÐµÑ€Ñ (Nedward «Ned» Flanders) — вымышленный перÑонаж мультÑериала «[СимпÑоны][]», озвученный Гарри Ширером. Он и его ÑÐµÐ¼ÑŒÑ Ð¶Ð¸Ð²ÑƒÑ‚ по ÑоÑедÑтву от Ñемьи СимпÑонов. Ðабожный хриÑтианин, Ðед ÑвлÑетÑÑ Ð¾Ð´Ð½Ð¸Ð¼ из Ñтолпов морали Спрингфилда. Ð’ Ñпизоде «Alone Again, Natura-Diddily» он овдовел, его жена Мод погибла в результате неÑчаÑтного ÑлучаÑ.

Ðед был одним из первых перÑонажей в мультÑериале, который не был членом Ñемьи СимпÑонов. ÐÐ°Ñ‡Ð¸Ð½Ð°Ñ Ñ Ð¿ÐµÑ€Ð²Ñ‹Ñ… Ñерий, он регулÑрно поÑвлÑетÑÑ Ð² «СимпÑонах». СчитаетÑÑ, что Ðед Ð¤Ð»Ð°Ð½Ð´ÐµÑ€Ñ Ð±Ñ‹Ð» назван в чеÑть улицы Northeast Flanders St. в Портленде, Орегон, родном городе ÑÐ¾Ð·Ð´Ð°Ñ‚ÐµÐ»Ñ Ð¼ÑƒÐ»ÑŒÑ‚Ñериала МÑтта Грейнинга]]. ÐадпиÑÑŒ на указателе улицы NE Flanders St. хулиганы чаÑто иÑправлÑли на NED Flanders St.

Markdown-2.4/tests/misc/bidi.txt0000666000000000000000000001676311756571172015071 0ustar 00000000000000**Python**(パイソン)ã¯ã€[Guido van Rossum](http://en.wikipedia.org/wiki/Guido_van_Rossum) ã«ã‚ˆã£ã¦ä½œã‚‰ã‚ŒãŸã‚ªãƒ¼ãƒ—ンソースã®ã‚ªãƒ–ジェクト指å‘スクリプト言語。[Perl](http://ja.wikipedia.org/wiki/Perl)ã¨ã¨ã‚‚ã«æ¬§ç±³ã§åºƒãæ™®åŠã—ã¦ã„る。イギリスã®ãƒ†ãƒ¬ãƒ“å±€ BBC ãŒè£½ä½œã—ãŸã‚³ãƒ¡ãƒ‡ã‚£ç•ªçµ„『空飛ã¶ãƒ¢ãƒ³ãƒ†ã‚£ãƒ»ãƒ‘イソンã€ã«ã¡ãªã‚“ã§å付ã‘られãŸã€‚ (Pythonã«ã¯ã€çˆ¬è™«é¡žã®ãƒ‹ã‚·ã‚­ãƒ˜ãƒ“ã®æ„味ãŒã‚りã€Python言語ã®ãƒžã‚¹ã‚³ãƒƒãƒˆã‚„アイコンã¨ã—ã¦ä½¿ã‚れるã“ã¨ãŒã‚る。) |||||||||||||||||||||||||||||THIS SHOULD BE LTR||||||||||||||||||||||||| |||||||||||||||||||||||||||||THIS SHOULD BE RTL||||||||||||||||||||||||| {@dir=rtl} (**بايثون** لغة برمجة حديثة بسيطة، واضحة، سريعة ØŒ تستخدم أسلوب البرمجة الكائنية (THIS SHOULD BE LTR ) وقابلة للتطوير {@dir=ltr} Ø¨Ø§Ù„Ø¥Ø¶Ø§ÙØ© إلى أنها مجانية Ùˆ Ù…ÙØªÙˆØ­ پایتون زبان برنامه‌نویسی ØªÙØ³ÛŒØ±ÛŒ Ùˆ سطح بالا ØŒ شی‌گرا Ùˆ یک زبان برنامه‌نویسی ØªÙØ³ÛŒØ±ÛŒ سمت سرور قدرتمند است Ú©Ù‡ توسط گیدو ون روسوم در سال Û±Û¹Û¹Û° ساخته شد. این زبان در ویژگی‌ها شبیه پرل، روبی، اسکیم، اسمال‌تاک Ùˆ تی‌سی‌ال است Ùˆ از مدیریت خودکار Ø­Ø§ÙØ¸Ù‡ Ø§Ø³ØªÙØ§Ø¯Ù‡ می‌کند Python,是一ç§é¢å‘对象的ã€ç›´è­¯å¼çš„计算机程åºè®¾è®¡è¯­è¨€ï¼Œä¹Ÿæ˜¯ä¸€ç§åŠŸèƒ½å¼ºå¤§è€Œå®Œå–„çš„é€šç”¨åž‹è¯­è¨€ï¼Œå·²ç»å…·æœ‰å多年的å‘展历å²ï¼Œæˆç†Ÿä¸”稳定。 Þ„Þ°ÞÞ« ÞˆÞ­ÞÞ°ÞŽÞ¬ Þ‹Þ« މަތީގައި Þ‡Þ¬Þ‡Þ°ÞŠÞ¦Þ€Þ¦ÞƒÞ§ 50 Þ‰Þ©Þ€ÞªÞ‚Þ°Þ‚Þ¦ÞÞ° ތިބެވިދާނެވެ. Þ„Þ®Þ‘Þª Þ‰Þ¦Þ€ÞªÞŽÞ¬ Þ‹ÞªÞÞ¦Þ†Þ© Þ‡Þ¬Þ€Þ§Þ‰Þ¬ Þ„Þ®Þ‘Þª Þ‡Þ¬Þ‡Þ°Þ—Þ¬Þ†Þ¬ÞˆÞ¬. **உரà¯à®¤à¯** 13ஆம௠நூறà¯à®±à®¾à®£à¯à®Ÿà®¿à®²à¯ உரà¯à®µà®¾à®© ஒர௠இநà¯à®¤à¯‹-à®à®°à¯‹à®ªà¯à®ªà®¿à®¯ மொழியாகà¯à®®à¯. உரà¯à®¤à¯, ஹிநà¯à®¤à®¿à®¯à¯à®Ÿà®©à¯ சேரà¯à®¤à¯à®¤à¯ "ஹிநà¯à®¤à¯à®¸à¯à®¤à®¾à®©à®¿" என அழைகà¯à®•பà¯à®ªà®Ÿà¯à®•ினà¯à®±à®¤à¯. மணà¯à®Ÿà®°à®¿à®©à¯, ஆஙà¯à®•ிலம௠ஆகியவறà¯à®±à¯à®•à¯à®•௠அடà¯à®¤à¯à®¤à®ªà®Ÿà®¿à®¯à®¾à®• மூனà¯à®±à®¾à®µà®¤à¯ கூடிய அளவ௠மகà¯à®•ளால௠பà¯à®°à®¿à®¨à¯à®¤à¯ கொளà¯à®³à®ªà¯à®ªà®Ÿà®•à¯à®•ூடியத௠ஹிநà¯à®¤à¯à®¸à¯à®¤à®¾à®©à®¿à®¯à¯‡à®¯à®¾à®•à¯à®®à¯. தாய௠மொழியாகப௠பேசà¯à®ªà®µà®°à¯à®•ள௠எணà¯à®£à®¿à®•à¯à®•ையின௠அடிபà¯à®ªà®Ÿà¯ˆà®¯à®¿à®²à¯ உரà¯à®¤à¯ உலகின௠20 ஆவத௠பெரிய மொழியாகà¯à®®à¯. 6 கோடி மகà¯à®•ள௠இதனைத௠தாய௠மொழியாகக௠கொணà¯à®Ÿà¯à®³à¯à®³à®¾à®°à¯à®•ளà¯. இரணà¯à®Ÿà®¾à®µà®¤à¯ மொழியாகக௠கொணà¯à®Ÿà¯à®³à¯à®³à®µà®°à¯à®•ள௠உடà¯à®ªà®Ÿ 11 கோடிப௠பேர௠இதனைப௠பேசà¯à®•ிறாரà¯à®•ளà¯. உரà¯à®¤à¯ பாகிஸà¯à®¤à®¾à®©à®¿à®©à¯ அரசகரà¯à®® மொழியாகவà¯à®®à¯, இநà¯à®¤à®¿à®¯à®¾à®µà®¿à®©à¯ அரசகரà¯à®® மொழிகளà¯à®³à¯ ஒனà¯à®±à®¾à®•வà¯à®®à¯ விளஙà¯à®•à¯à®•ிறதà¯. اردو Ûندوآریائی زبانوں Ú©ÛŒ Ûندويورپی شاخ Ú©ÛŒ ایک زبان ÛÛ’ جو تيرھويں صدی ميں بر صغير ميں پيدا Ûوئی Ù€ اردو پاکستان Ú©ÛŒ سرکاری زبان ÛÛ’ اور بھارت Ú©ÛŒ سرکاری زبانوں ميں سے ايک ÛÛ’Û” اردو بھارت ميں 5 کروڑ اور پاکستان ميں 1 کروڑ لوگوں Ú©ÛŒ مادری زبان ÛÛ’ مگر اسے بھارت اور پاکستان Ú©Û’ تقریباً 50 کروڑ لوگ بول اور سمجھ سکتے ھیں Û” جن میں سے تقریباً 10.5 کروڑ لوگ اسے Ø¨Ø§Ù‚Ø§Ø¹Ø¯Û Ø¨ÙˆÙ„ØªÛ’ ھیں۔ بايثون ===== **بايثون** لغة برمجة حديثة بسيطة، واضحة، سريعة ØŒ تستخدم أسلوب البرمجة الكائنية (OOP) وقابلة للتطوير Ø¨Ø§Ù„Ø¥Ø¶Ø§ÙØ© إلى أنها مجانية Ùˆ Ù…ÙØªÙˆØ­Ø© المصدر. صÙÙ†ÙØª بالأساس كلغة ØªÙØ³ÙŠØ±ÙŠØ© ØŒ بايثون مصممة أصلاً للأداء بعض المهام الخاصة أو المحدودة. إلا أنه يمكن استخدامها بايثون لإنجاز المشاريع الضخمه كأي لغة برمجية أخرى، غالباً ما ÙŠÙنصح المبتدئين ÙÙŠ ميدان البرمجة بتعلم هذه اللغة لأنها من بين أسهل اللغات البرمجية تعلماً. |||||||||||||||||||||||||||||THIS SHOULD BE RTL||||||||||||||||||||||||| (نشأت بايثون ÙÙŠ مركز CWI (مركز العلوم والحاسب الآلي) بأمستردام على يد جويدو ÙØ§Ù† Ø±ÙØ²ÙˆÙ…. تم تطويرها بلغة C. أطلق ÙØ§Ù† Ø±ÙØ²ÙˆÙ… اسم "بايثون" على لغته تعبيرًا عن إعجابه بÙÙØ±Ù‚ÙŽØ© مسرحية هزلية شهيرة من بريطانيا، كانت تطلق على Ù†ÙØ³Ù‡Ø§ اسم مونتي بايثون Monty Python. تتميز بايثون بمجتمعها النشط ØŒ كما أن لها الكثير من المكتبات البرمجية ذات الأغراض الخاصة والتي برمجها أشخاص من مجتمع هذه اللغة ØŒ مثلاً مكتبة PyGame التي ØªÙˆÙØ± مجموعه من الوظائ٠من اجل برمجة الالعاب. ويمكن لبايثون التعامل مع العديد من أنواع قواعد البيانات مثل MySQL وغيره. ##أمثلة مثال Hello World! print "Hello World!" مثال لاستخراج المضروب Factorial : num = 1 x = raw_input('Insert the number please ') x = int(x) if x > 69: print 'Math Error !' else: while x > 1: num *= x x = x-1 print num ##وصلات خارجية * [الموقع الرسمي للغة بايثون](http://www.python.org) بذرة حاس **Ðедвард «Ðед» ФландерÑ** (Nedward «Ned» Flanders) — вымышленный перÑонаж мультÑериала «[СимпÑоны][]», озвученный Гарри Ширером. Он и его ÑÐµÐ¼ÑŒÑ Ð¶Ð¸Ð²ÑƒÑ‚ по ÑоÑедÑтву от Ñемьи СимпÑонов. Ðабожный хриÑтианин, Ðед ÑвлÑетÑÑ Ð¾Ð´Ð½Ð¸Ð¼ из Ñтолпов морали Спрингфилда. Ð’ Ñпизоде «Alone Again, Natura-Diddily» он овдовел, его жена Мод погибла в результате неÑчаÑтного ÑлучаÑ. Ðед был одним из первых перÑонажей в мультÑериале, который не был членом Ñемьи СимпÑонов. ÐÐ°Ñ‡Ð¸Ð½Ð°Ñ Ñ Ð¿ÐµÑ€Ð²Ñ‹Ñ… Ñерий, он регулÑрно поÑвлÑетÑÑ Ð² «СимпÑонах». СчитаетÑÑ, что Ðед Ð¤Ð»Ð°Ð½Ð´ÐµÑ€Ñ Ð±Ñ‹Ð» назван в чеÑть улицы *Northeast Flanders St.* в [Портленде](http://www.portland.gov), Орегон, родном городе ÑÐ¾Ð·Ð´Ð°Ñ‚ÐµÐ»Ñ Ð¼ÑƒÐ»ÑŒÑ‚Ñериала МÑтта Грейнинга]]. ÐадпиÑÑŒ на указателе улицы *NE Flanders St.* хулиганы чаÑто иÑправлÑли на _NED Flanders St._ Markdown-2.4/tests/misc/blank-block-quote.html0000666000000000000000000000010111756571172017574 0ustar 00000000000000

aaaaaaaaaaa

bbbbbbbbbbb

Markdown-2.4/tests/misc/blank-block-quote.txt0000666000000000000000000000004411756571172017455 0ustar 00000000000000 aaaaaaaaaaa > bbbbbbbbbbb Markdown-2.4/tests/misc/blank_lines_in_codeblocks.html0000666000000000000000000000074512111563047021423 0ustar 00000000000000

Preserve blank lines in code blocks with tabs:

a code block

two tabbed lines


three tabbed lines



four tabbed lines




five tabbed lines





six tabbed lines






End of tabbed block

And without tabs:

a code block

two blank lines


three blank lines



four blank lines




five blank lines





six blank lines






End of block

End of document

Markdown-2.4/tests/misc/blank_lines_in_codeblocks.txt0000666000000000000000000000113412111563047021267 0ustar 00000000000000Preserve blank lines in code blocks with tabs: a code block two tabbed lines three tabbed lines four tabbed lines five tabbed lines six tabbed lines End of tabbed block And without tabs: a code block two blank lines three blank lines four blank lines five blank lines six blank lines End of block End of documentMarkdown-2.4/tests/misc/blockquote-below-paragraph.html0000666000000000000000000000034411756571172021514 0ustar 00000000000000

Paragraph

Block quote Yep

Paragraph

no space Nope

Paragraph one

blockquote More blockquote.

Markdown-2.4/tests/misc/blockquote-below-paragraph.txt0000666000000000000000000000016111756571172021364 0ustar 00000000000000Paragraph > Block quote > Yep Paragraph >no space >Nope Paragraph one > blockquote More blockquote. Markdown-2.4/tests/misc/blockquote-hr.html0000666000000000000000000000047411756571172017056 0ustar 00000000000000

This is a paragraph.


Block quote with horizontal lines.


Double block quote.


End of the double block quote.

A new paragraph. With multiple lines. Even a lazy line.


The last line.

Markdown-2.4/tests/misc/blockquote-hr.txt0000666000000000000000000000037011756571172016724 0ustar 00000000000000This is a paragraph. --- > Block quote with horizontal lines. > --- > > Double block quote. > > --- > > End of the double block quote. > A new paragraph. > With multiple lines. Even a lazy line. > --- > The last line. Markdown-2.4/tests/misc/blockquote.html0000666000000000000000000000124611756571172016445 0ustar 00000000000000

blockquote with no whitespace before >.

foo

blockquote with one space before the >.

bar

blockquote with 2 spaces.

baz

this has three spaces so its a paragraph.

blah

> this one had four so it's a code block.

this nested blockquote has 0 on level one and 3 (one after the first > + 2 more) on level 2.

and this has 4 on level 2 - another code block.

Markdown-2.4/tests/misc/blockquote.txt0000666000000000000000000000064011756571172016315 0ustar 00000000000000> blockquote with no whitespace before `>`. foo > blockquote with one space before the `>`. bar > blockquote with 2 spaces. baz > this has three spaces so its a paragraph. blah > this one had four so it's a code block. > > this nested blockquote has 0 on level one and 3 (one after the first `>` + 2 more) on level 2. > > and this has 4 on level 2 - another code block. Markdown-2.4/tests/misc/block_html5.html0000666000000000000000000000046411756571172016501 0ustar 00000000000000

Hello :-)

Caption

Some footer

Markdown-2.4/tests/misc/block_html5.txt0000666000000000000000000000046211756571172016352 0ustar 00000000000000

Hello :-)

Caption

Some footer

Markdown-2.4/tests/misc/block_html_attr.html0000666000000000000000000000152311756571172017443 0ustar 00000000000000
Raw HTML processing should not confuse this with the blockquote below

Header2

Header3

Paragraph

Header3

Paragraph

Paragraph

Paragraph

linktext

Markdown-2.4/tests/misc/block_html_attr.txt0000666000000000000000000000151711756571172017321 0ustar 00000000000000
Raw HTML processing should not confuse this with the blockquote below

Header2

Header3

Paragraph

Header3

Paragraph

Paragraph

Paragraph

linktext

Markdown-2.4/tests/misc/block_html_simple.html0000666000000000000000000000011311756571172017754 0ustar 00000000000000

foo

  • bar

  • baz

Markdown-2.4/tests/misc/block_html_simple.txt0000666000000000000000000000011311756571172017627 0ustar 00000000000000

foo

  • bar

  • baz

Markdown-2.4/tests/misc/bold_links.html0000666000000000000000000000010211756571172016403 0ustar 00000000000000

bold link

Markdown-2.4/tests/misc/bold_links.txt0000666000000000000000000000004511756571172016264 0ustar 00000000000000**bold [link](http://example.com)** Markdown-2.4/tests/misc/br.html0000666000000000000000000000105011756571172014671 0ustar 00000000000000

Output:

<p>Some of these words <em>are emphasized</em>.
Some of these words <em>are emphasized also</em>.</p>

<p>Use two asterisks for <strong>strong emphasis</strong>.
Or, if you prefer, <strong>use two underscores instead</strong>.</p>

Lists

Unordered (bulleted) lists use asterisks, pluses, and hyphens (*, +, and -) as list markers. These three markers are interchangable; this:

Markdown-2.4/tests/misc/br.txt0000666000000000000000000000066211756571172014554 0ustar 00000000000000Output:

Some of these words are emphasized. Some of these words are emphasized also.

Use two asterisks for strong emphasis. Or, if you prefer, use two underscores instead.

## Lists ## Unordered (bulleted) lists use asterisks, pluses, and hyphens (`*`, `+`, and `-`) as list markers. These three markers are interchangable; this: Markdown-2.4/tests/misc/brackets-in-img-title.html0000666000000000000000000000102212300201167020334 0ustar 00000000000000

alt alt alt

alt alt

alt alt alt alt

Markdown-2.4/tests/misc/brackets-in-img-title.txt0000666000000000000000000000050512300201167020214 0ustar 00000000000000![alt](local-img.jpg) ![alt](local-img.jpg "") ![alt](local-img.jpg "normal title") ![alt](local-img.jpg "(just title in brackets)") ![alt](local-img.jpg "title with brackets (I think)") ![alt](local-img.jpg "(") ![alt](local-img.jpg "(open only") ![alt](local-img.jpg ")") ![alt](local-img.jpg "close only)") Markdown-2.4/tests/misc/bracket_re.html0000666000000000000000000000364411756571172016402 0ustar 00000000000000

[x xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx

Markdown-2.4/tests/misc/bracket_re.txt0000666000000000000000000000364111756571172016252 0ustar 00000000000000 [x xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx Markdown-2.4/tests/misc/code-first-line.html0000666000000000000000000000006711756571172017261 0ustar 00000000000000
print "This is a code block."
Markdown-2.4/tests/misc/code-first-line.txt0000666000000000000000000000004311756571172017126 0ustar 00000000000000 print "This is a code block." Markdown-2.4/tests/misc/comments.html0000666000000000000000000000020112111563027016072 0ustar 00000000000000

X<0

X>0

as if

no blank line

Markdown-2.4/tests/misc/comments.txt0000666000000000000000000000013512111563027015753 0ustar 00000000000000X<0 X>0
as if
__no blank line__ Markdown-2.4/tests/misc/CRLF_line_ends.html0000666000000000000000000000003611756571172017037 0ustar 00000000000000

foo

bar
Markdown-2.4/tests/misc/CRLF_line_ends.txt0000666000000000000000000000003311756571172016707 0ustar 00000000000000foo
bar
Markdown-2.4/tests/misc/div.html0000666000000000000000000000013412111563027015034 0ustar 00000000000000

And now in uppercase:

foo
Markdown-2.4/tests/misc/div.txt0000666000000000000000000000013112111563027014704 0ustar 00000000000000 And now in uppercase:
foo
Markdown-2.4/tests/misc/em-around-links.html0000666000000000000000000000143312111563027017262 0ustar 00000000000000

Title

Python in Markdown by some great folks - This does work as expected.

Markdown-2.4/tests/misc/em-around-links.txt0000666000000000000000000000116012111563027017132 0ustar 00000000000000# Title - *[Python in Markdown](http://packages.python.org/Markdown/) by some great folks* - This *does* work as expected. - _[Python in Markdown](http://packages.python.org/Markdown/) by some great folks_ - This *does* work as expected. - [_Python in Markdown_](http://packages.python.org/Markdown/) by some great folks - This *does* work as expected. - [_Python in Markdown_](http://packages.python.org/Markdown/) _by some great folks_ - This *does* work as expected. _[Python in Markdown](http://packages.python.org/Markdown/) by some great folks_ - This *does* work as expected. Markdown-2.4/tests/misc/email.html0000666000000000000000000000113711756571172015363 0ustar 00000000000000

asdfasdfadsfasd yuri@freewisdom.org or you can say instead yuri@freewisdom.org

Markdown-2.4/tests/misc/email.txt0000666000000000000000000000013711756571172015235 0ustar 00000000000000 asdfasdfadsfasd or you can say instead Markdown-2.4/tests/misc/em_strong.html0000666000000000000000000000044611756571172016273 0ustar 00000000000000

One asterisk: *

One underscore: _

Two asterisks: **

With spaces: * *

Two underscores __

with spaces: _ _

three asterisks: ***

with spaces: * * *

three underscores: ___

with spaces: _ _ _

One char: a

Markdown-2.4/tests/misc/em_strong.txt0000666000000000000000000000035011756571172016140 0ustar 00000000000000One asterisk: * One underscore: _ Two asterisks: ** With spaces: * * Two underscores __ with spaces: _ _ three asterisks: *** with spaces: * * * three underscores: ___ with spaces: _ _ _ One char: _a_ Markdown-2.4/tests/misc/escaped_chars_in_js.html0000666000000000000000000000073612300201167020222 0ustar 00000000000000

[javascript protected email address]

Markdown-2.4/tests/misc/escaped_chars_in_js.txt0000666000000000000000000000073112300201167020070 0ustar 00000000000000[javascript protected email address] Markdown-2.4/tests/misc/escaped_links.html0000666000000000000000000000027211756571172017077 0ustar 00000000000000

Backslashed in links:

q=go:GO\:0000307

q=go:GO\:0000308

Markdown-2.4/tests/misc/escaped_links.txt0000666000000000000000000000024011756571172016745 0ustar 00000000000000Backslashed in links: [q=go:GO\\:0000307](/query?q=go:GO\\:0000307) [q=go:GO\\:0000308][foo] [foo]: /query?q=go:GO\:0000308 "/query?q=go:GO\:0000308" Markdown-2.4/tests/misc/funky-list.html0000666000000000000000000000043411756571172016400 0ustar 00000000000000
  1. this starts a list with numbers
  2. this will show as number "2"
  3. this will show as number "3."
  4. any number, +, -, or * will keep the list going.

aaaaaaaaaaaaaaa

  • now a normal list
  • and more
Markdown-2.4/tests/misc/funky-list.txt0000666000000000000000000000032411756571172016251 0ustar 000000000000001. this starts a list *with* numbers + this will show as number "2" * this will show as number "3." 9. any number, +, -, or * will keep the list going. aaaaaaaaaaaaaaa - now a normal list - and more Markdown-2.4/tests/misc/h1.html0000666000000000000000000000011111756571172014573 0ustar 00000000000000

Header

Header 2

H3

H1

H2

Markdown-2.4/tests/misc/h1.txt0000666000000000000000000000010411756571172014450 0ustar 00000000000000Header ------ Header 2 ======== ### H3 H1 = H2 -- Markdown-2.4/tests/misc/hash.html0000666000000000000000000000015511756571172015216 0ustar 00000000000000

a

#!/usr/bin/python
hello

a

!/usr/bin/python
hello

a

Markdown-2.4/tests/misc/hash.txt0000666000000000000000000000013611756571172015070 0ustar 00000000000000a
#!/usr/bin/python
hello
a
!/usr/bin/python
hello
a Markdown-2.4/tests/misc/header-in-lists.html0000666000000000000000000000054711756571172017270 0ustar 00000000000000

Tight List:

  • Header1

    Line 1-2 - not a header or paragraph!
  • Header2

    Line 2-2 - not a header or paragraph!

Loose List:

  • Header1

    Line 1-2 - a paragraph

  • Header2

    Line 2-2 - a paragraph

Markdown-2.4/tests/misc/header-in-lists.txt0000666000000000000000000000033011756571172017131 0ustar 00000000000000Tight List: * #Header1 Line 1-2 - **not** a header *or* paragraph! * #Header2 Line 2-2 - not a header or paragraph! Loose List: * #Header1 Line 1-2 - *a* paragraph * #Header2 Line 2-2 - a paragraph Markdown-2.4/tests/misc/headers.html0000666000000000000000000000035411756571172015707 0ustar 00000000000000

Hello world

Line 2 Line 3

[Markdown][5]

Markdown

[5]: http://foo.com/

Issue #1: Markdown

Text

Header

Some other text

Markdown-2.4/tests/misc/headers.txt0000666000000000000000000000026211756571172015560 0ustar 00000000000000### Hello world Line 2 Line 3 # [Markdown][5] # [Markdown](http://some.link.com/) # [5]: http://foo.com/ # Issue #1: Markdown Text # Header Some other text Markdown-2.4/tests/misc/hline.html0000666000000000000000000000004111756571172015364 0ustar 00000000000000

Header

Next line

Markdown-2.4/tests/misc/hline.txt0000666000000000000000000000003211756571172015237 0ustar 00000000000000 #Header Next line Markdown-2.4/tests/misc/html-comments.html0000666000000000000000000000011511756571172017056 0ustar 00000000000000

Here is HTML and once more

Markdown-2.4/tests/misc/html-comments.txt0000666000000000000000000000011011756571172016724 0ustar 00000000000000Here is HTML and once more

Markdown-2.4/tests/misc/html.html0000666000000000000000000000124712111563027015224 0ustar 00000000000000

Block level html

Some inline stuff.

Now some arbitrary tags.

More block level html.
Html with various attributes.

And of course .

this . [this ) Some funky inline stuff with markdown escaping syntax. And now a line with only an opening bracket: < And one with other stuff but no closing bracket: < foo Markdown-2.4/tests/misc/image-2.html0000666000000000000000000000016111756571172015511 0ustar 00000000000000

link!

link

Markdown-2.4/tests/misc/image-2.txt0000666000000000000000000000010311756571172015360 0ustar 00000000000000[*link!*](http://src.com/) *[link](http://www.freewisdom.org)* Markdown-2.4/tests/misc/image.html0000666000000000000000000000012411756571172015351 0ustar 00000000000000

Poster

Markdown-2.4/tests/misc/image.txt0000666000000000000000000000007311756571172015227 0ustar 00000000000000 ![Poster](http://humane_man.jpg "The most humane man.") Markdown-2.4/tests/misc/image_in_links.html0000666000000000000000000000013011756571172017234 0ustar 00000000000000

altname

Markdown-2.4/tests/misc/image_in_links.txt0000666000000000000000000000007411756571172017116 0ustar 00000000000000 [![altname](path/to/img_thumb.png)](path/to/image.png) Markdown-2.4/tests/misc/ins-at-start-of-paragraph.html0000666000000000000000000000011412111563027021143 0ustar 00000000000000

Hello, fellow developer this ins should be wrapped in a p.

Markdown-2.4/tests/misc/ins-at-start-of-paragraph.txt0000666000000000000000000000010712111563027021020 0ustar 00000000000000Hello, fellow developer this ins should be wrapped in a p. Markdown-2.4/tests/misc/inside_html.html0000666000000000000000000000006111756571172016566 0ustar 00000000000000

ok?

Markdown-2.4/tests/misc/inside_html.txt0000666000000000000000000000003711756571172016444 0ustar 00000000000000 __ok__? Markdown-2.4/tests/misc/japanese.html0000666000000000000000000000567111756571172016071 0ustar 00000000000000

パイソン (Python)

Python(パイソン)ã¯ã€Guido van Rossum ã«ã‚ˆã£ã¦ä½œã‚‰ã‚ŒãŸã‚ªãƒ¼ãƒ—ンソースã®ã‚ªãƒ–ジェクト指å‘スクリプト言語。Perlã¨ã¨ã‚‚ã«æ¬§ç±³ã§åºƒãæ™®åŠã—ã¦ã„る。イギリスã®ãƒ†ãƒ¬ãƒ“å±€ BBC ãŒè£½ä½œã—ãŸã‚³ãƒ¡ãƒ‡ã‚£ç•ªçµ„『空飛ã¶ãƒ¢ãƒ³ãƒ†ã‚£ãƒ»ãƒ‘イソンã€ã«ã¡ãªã‚“ã§å付ã‘られãŸã€‚ (Pythonã«ã¯ã€çˆ¬è™«é¡žã®ãƒ‹ã‚·ã‚­ãƒ˜ãƒ“ã®æ„味ãŒã‚りã€Python言語ã®ãƒžã‚¹ã‚³ãƒƒãƒˆã‚„アイコンã¨ã—ã¦ä½¿ã‚れるã“ã¨ãŒã‚る。)

概è¦

プログラミング言語 Python ã¯åˆå¿ƒè€…ã‹ã‚‰å°‚門家ã¾ã§å¹…広ã„ユーザ層をç²å¾—ã—ã¦ã„ã‚‹ã€‚åˆ©ç”¨ç›®çš„ã¯æ±Žç”¨ã§ã€æ–¹å‘性ã¨ã—ã¦ã¯Javaã«è¿‘ã„。ãŸã ã—ã€æœ€åˆã‹ã‚‰ãƒãƒƒãƒˆãƒ¯ãƒ¼ã‚¯åˆ©ç”¨ã‚’メインã¨ã—ã¦è€ƒãˆã‚‰ã‚Œã¦ã„ã‚‹Javaよりセキュリティã«ã¤ã„ã¦ã¯ã‚„や寛大ã§ã‚る。多ãã®ãƒ—ラットフォームをサãƒãƒ¼ãƒˆã—ã¦ãŠã‚Šï¼ˆâ‡’動作ã™ã‚‹ãƒ—ラットフォーム)ã€è±Šå¯Œãªãƒ©ã‚¤ãƒ–ラリãŒã‚ã‚‹ã“ã¨ã‹ã‚‰ã€ç”£æ¥­ç•Œã§ã‚‚利用ãŒå¢—ãˆã¤ã¤ã‚る。ã¾ãŸã€Pythonã¯ç´”粋ãªãƒ—ログラミング言語ã®ã»ã‹ã«ã‚‚ã€å¤šãã®ç•°ãªã‚‹è¨€èªžã§æ›¸ã‹ã‚ŒãŸãƒ¢ã‚¸ãƒ¥ãƒ¼ãƒ«ã‚’ã¾ã¨ã‚る糊言語ã®ã²ã¨ã¤ã¨ã—ã¦ä½ç½®ã¥ã‘ã‚‹ã“ã¨ãŒã§ãる。実際Pythonã¯å¤šãã®å•†ç”¨ã‚¢ãƒ—リケーションã§ã‚¹ã‚¯ãƒªãƒ—ト言語ã¨ã—ã¦æŽ¡ç”¨ã•れã¦ã„る(⇒Pythonを使ã£ã¦ã„る製å“ã‚ã‚‹ã„ã¯ã‚½ãƒ•トウェアã®ä¸€è¦§ï¼‰ã€‚豊富ãªãƒ‰ã‚­ãƒ¥ãƒ¡ãƒ³ãƒˆã‚’ã‚‚ã¡ã€Unicodeã«ã‚ˆã‚‹æ–‡å­—列æ“作をサãƒãƒ¼ãƒˆã—ã¦ãŠã‚Šã€æ—¥æœ¬èªžå‡¦ç†ã‚‚標準ã§å¯èƒ½ã§ã‚る。

Python ã¯åŸºæœ¬çš„ã«ã‚¤ãƒ³ã‚¿ãƒ—リタ上ã§å®Ÿè¡Œã•れるã“ã¨ã‚’念頭ã«ãŠã„ã¦è¨­è¨ˆã•れã¦ãŠã‚Šã€ä»¥ä¸‹ã®ã‚ˆã†ãªç‰¹å¾´ã‚’ã‚‚ã£ã¦ã„ã‚‹:

  • å‹•çš„ãªåž‹ä»˜ã‘。
  • オブジェクトã®ãƒ¡ãƒ³ãƒã«å¯¾ã™ã‚‹ã‚¢ã‚¯ã‚»ã‚¹ãŒåˆ¶é™ã•れã¦ã„ãªã„。(属性や専用ã®ãƒ¡ã‚½ãƒƒãƒ‰ãƒ•ックを実装ã™ã‚‹ã“ã¨ã«ã‚ˆã£ã¦åˆ¶é™ã¯å¯èƒ½ã€‚)
  • モジュールã€ã‚¯ãƒ©ã‚¹ã€ã‚ªãƒ–ジェクト等ã®è¨€èªžã®è¦ç´ ãŒå†…部ã‹ã‚‰ã‚¢ã‚¯ã‚»ã‚¹å¯èƒ½ã§ã‚りã€ãƒªãƒ•レクションを利用ã—ãŸè¨˜è¿°ãŒå¯èƒ½ã€‚

ã¾ãŸã€Pythonã§ã¯ã‚¤ãƒ³ãƒ‡ãƒ³ãƒˆã«ã‚ˆã‚Šãƒ–ロックを指定ã™ã‚‹æ§‹æ–‡ã‚’採用ã—ã¦ã„る(⇒オフサイドルール)。ã“ã®æ§‹æ–‡ã¯Pythonã«æ…£ã‚ŒãŸãƒ¦ãƒ¼ã‚¶ã‹ã‚‰ã¯ç§°è³›ã‚’ã‚‚ã£ã¦å—ã‘入れられã¦ã„ã‚‹ãŒã€ä»–ã®è¨€èªžã®ãƒ¦ãƒ¼ã‚¶ã‹ã‚‰ã¯æ‰¹åˆ¤ã‚‚多ã„。ã“ã®ã»ã‹ã«ã‚‚ã€å¤§ãã™ãŽã‚‹å®Ÿè¡Œãƒ•ァイルやã€Javaã«æ¯”ã¹ã¦é…ã„処ç†é€Ÿåº¦ãªã©ãŒæ¬ ç‚¹ã¨ã—ã¦æŒ‡æ‘˜ã•れã¦ã„る。ã—ã‹ã— プロトタイピング ã®éš›ã«ã¯ã“れらã®ç‚¹ã¯ã•ã—ã¦å•題ã¨ã¯ãªã‚‰ãªã„ã“ã¨ã‹ã‚‰ã€ç ”究開発部門ã§ã¯é »ç¹ã«åˆ©ç”¨ã•れã¦ã„る。

Markdown-2.4/tests/misc/japanese.txt0000666000000000000000000000547311756571172015744 0ustar 00000000000000パイソン (Python) ======= **Python**(パイソン)ã¯ã€[Guido van Rossum](http://en.wikipedia.org/wiki/Guido_van_Rossum) ã«ã‚ˆã£ã¦ä½œã‚‰ã‚ŒãŸã‚ªãƒ¼ãƒ—ンソースã®ã‚ªãƒ–ジェクト指å‘スクリプト言語。[Perl](http://ja.wikipedia.org/wiki/Perl)ã¨ã¨ã‚‚ã«æ¬§ç±³ã§åºƒãæ™®åŠã—ã¦ã„る。イギリスã®ãƒ†ãƒ¬ãƒ“å±€ BBC ãŒè£½ä½œã—ãŸã‚³ãƒ¡ãƒ‡ã‚£ç•ªçµ„『空飛ã¶ãƒ¢ãƒ³ãƒ†ã‚£ãƒ»ãƒ‘イソンã€ã«ã¡ãªã‚“ã§å付ã‘られãŸã€‚ (Pythonã«ã¯ã€çˆ¬è™«é¡žã®ãƒ‹ã‚·ã‚­ãƒ˜ãƒ“ã®æ„味ãŒã‚りã€Python言語ã®ãƒžã‚¹ã‚³ãƒƒãƒˆã‚„アイコンã¨ã—ã¦ä½¿ã‚れるã“ã¨ãŒã‚る。) ## æ¦‚è¦ ãƒ—ãƒ­ã‚°ãƒ©ãƒŸãƒ³ã‚°è¨€èªž Python ã¯åˆå¿ƒè€…ã‹ã‚‰å°‚門家ã¾ã§å¹…広ã„ユーザ層をç²å¾—ã—ã¦ã„ã‚‹ã€‚åˆ©ç”¨ç›®çš„ã¯æ±Žç”¨ã§ã€æ–¹å‘性ã¨ã—ã¦ã¯Javaã«è¿‘ã„。ãŸã ã—ã€æœ€åˆã‹ã‚‰ãƒãƒƒãƒˆãƒ¯ãƒ¼ã‚¯åˆ©ç”¨ã‚’メインã¨ã—ã¦è€ƒãˆã‚‰ã‚Œã¦ã„ã‚‹Javaよりセキュリティã«ã¤ã„ã¦ã¯ã‚„や寛大ã§ã‚る。多ãã®ãƒ—ラットフォームをサãƒãƒ¼ãƒˆã—ã¦ãŠã‚Šï¼ˆâ‡’[動作ã™ã‚‹ãƒ—ラットフォーム](#somelink))ã€è±Šå¯Œãªãƒ©ã‚¤ãƒ–ラリãŒã‚ã‚‹ã“ã¨ã‹ã‚‰ã€ç”£æ¥­ç•Œã§ã‚‚利用ãŒå¢—ãˆã¤ã¤ã‚る。ã¾ãŸã€Pythonã¯ç´”粋ãªãƒ—ログラミング言語ã®ã»ã‹ã«ã‚‚ã€å¤šãã®ç•°ãªã‚‹è¨€èªžã§æ›¸ã‹ã‚ŒãŸãƒ¢ã‚¸ãƒ¥ãƒ¼ãƒ«ã‚’ã¾ã¨ã‚る糊言語ã®ã²ã¨ã¤ã¨ã—ã¦ä½ç½®ã¥ã‘ã‚‹ã“ã¨ãŒã§ãる。実際Pythonã¯å¤šãã®å•†ç”¨ã‚¢ãƒ—リケーションã§ã‚¹ã‚¯ãƒªãƒ—ト言語ã¨ã—ã¦æŽ¡ç”¨ã•れã¦ã„る(⇒Pythonを使ã£ã¦ã„る製å“ã‚ã‚‹ã„ã¯ã‚½ãƒ•トウェアã®ä¸€è¦§ï¼‰ã€‚豊富ãªãƒ‰ã‚­ãƒ¥ãƒ¡ãƒ³ãƒˆã‚’ã‚‚ã¡ã€Unicodeã«ã‚ˆã‚‹æ–‡å­—列æ“作をサãƒãƒ¼ãƒˆã—ã¦ãŠã‚Šã€æ—¥æœ¬èªžå‡¦ç†ã‚‚標準ã§å¯èƒ½ã§ã‚る。 Python ã¯åŸºæœ¬çš„ã«ã‚¤ãƒ³ã‚¿ãƒ—リタ上ã§å®Ÿè¡Œã•れるã“ã¨ã‚’念頭ã«ãŠã„ã¦è¨­è¨ˆã•れã¦ãŠã‚Šã€ä»¥ä¸‹ã®ã‚ˆã†ãªç‰¹å¾´ã‚’ã‚‚ã£ã¦ã„ã‚‹: * å‹•çš„ãªåž‹ä»˜ã‘。 * オブジェクトã®ãƒ¡ãƒ³ãƒã«å¯¾ã™ã‚‹ã‚¢ã‚¯ã‚»ã‚¹ãŒåˆ¶é™ã•れã¦ã„ãªã„。(属性や専用ã®ãƒ¡ã‚½ãƒƒãƒ‰ãƒ•ックを実装ã™ã‚‹ã“ã¨ã«ã‚ˆã£ã¦åˆ¶é™ã¯å¯èƒ½ã€‚) * モジュールã€ã‚¯ãƒ©ã‚¹ã€ã‚ªãƒ–ジェクト等ã®è¨€èªžã®è¦ç´ ãŒå†…部ã‹ã‚‰ã‚¢ã‚¯ã‚»ã‚¹å¯èƒ½ã§ã‚りã€ãƒªãƒ•レクションを利用ã—ãŸè¨˜è¿°ãŒå¯èƒ½ã€‚ ã¾ãŸã€Pythonã§ã¯ã‚¤ãƒ³ãƒ‡ãƒ³ãƒˆã«ã‚ˆã‚Šãƒ–ロックを指定ã™ã‚‹æ§‹æ–‡ã‚’採用ã—ã¦ã„る(⇒[オフサイドルール](#jklj))。ã“ã®æ§‹æ–‡ã¯Pythonã«æ…£ã‚ŒãŸãƒ¦ãƒ¼ã‚¶ã‹ã‚‰ã¯ç§°è³›ã‚’ã‚‚ã£ã¦å—ã‘入れられã¦ã„ã‚‹ãŒã€ä»–ã®è¨€èªžã®ãƒ¦ãƒ¼ã‚¶ã‹ã‚‰ã¯æ‰¹åˆ¤ã‚‚多ã„。ã“ã®ã»ã‹ã«ã‚‚ã€å¤§ãã™ãŽã‚‹å®Ÿè¡Œãƒ•ァイルやã€Javaã«æ¯”ã¹ã¦é…ã„処ç†é€Ÿåº¦ãªã©ãŒæ¬ ç‚¹ã¨ã—ã¦æŒ‡æ‘˜ã•れã¦ã„る。ã—ã‹ã— **プロトタイピング** ã®éš›ã«ã¯ã“れらã®ç‚¹ã¯ã•ã—ã¦å•題ã¨ã¯ãªã‚‰ãªã„ã“ã¨ã‹ã‚‰ã€ç ”究開発部門ã§ã¯é »ç¹ã«åˆ©ç”¨ã•れã¦ã„る。 Markdown-2.4/tests/misc/lazy-block-quote.html0000666000000000000000000000023711756571172017476 0ustar 00000000000000

Line one of lazy block quote. Line two of lazy block quote.

Line one of paragraph two. Line two of paragraph two.

Markdown-2.4/tests/misc/lazy-block-quote.txt0000666000000000000000000000017411756571172017351 0ustar 00000000000000> Line one of lazy block quote. Line two of lazy block quote. > Line one of paragraph two. Line two of paragraph two. Markdown-2.4/tests/misc/link-with-parenthesis.html0000666000000000000000000000021511756571172020521 0ustar 00000000000000

ZIP archives

Markdown-2.4/tests/misc/link-with-parenthesis.txt0000666000000000000000000000016711756571172020402 0ustar 00000000000000[ZIP archives](http://en.wikipedia.org/wiki/ZIP_(file_format) "ZIP (file format) - Wikipedia, the free encyclopedia") Markdown-2.4/tests/misc/lists.html0000666000000000000000000000071111756571172015427 0ustar 00000000000000
  • A multi-paragraph list, unindented.

Simple tight list

  • Uno
  • Due
  • Tri

A singleton tight list:

  • Uno

A lose list:

  • One

  • Two

  • Three

A lose list with paragraphs

  • One one one one

    one one one one

  • Two two two two

Markdown-2.4/tests/misc/lists.txt0000666000000000000000000000041411756571172015302 0ustar 00000000000000 * A multi-paragraph list, unindented. Simple tight list * Uno * Due * Tri A singleton tight list: * Uno A lose list: * One * Two * Three A lose list with paragraphs * One one one one one one one one * Two two two two Markdown-2.4/tests/misc/lists2.html0000666000000000000000000000012011756571172015503 0ustar 00000000000000
  • blah blah blah sdf asdf asdf asdf asdf asda asdf asdfasd
Markdown-2.4/tests/misc/lists2.txt0000666000000000000000000000007611756571172015370 0ustar 00000000000000* blah blah blah sdf asdf asdf asdf asdf asda asdf asdfasd Markdown-2.4/tests/misc/lists3.html0000666000000000000000000000013011756571172015505 0ustar 00000000000000
  • blah blah blah sdf asdf asdf asdf asdf asda asdf asdfasd
Markdown-2.4/tests/misc/lists3.txt0000666000000000000000000000010611756571172015363 0ustar 00000000000000* blah blah blah sdf asdf asdf asdf asdf asda asdf asdfasd Markdown-2.4/tests/misc/lists4.html0000666000000000000000000000013611756571172015514 0ustar 00000000000000
  • item1
  • item2
    1. Number 1
    2. Number 2
Markdown-2.4/tests/misc/lists4.txt0000666000000000000000000000006611756571172015371 0ustar 00000000000000 * item1 * item2 1. Number 1 2. Number 2 Markdown-2.4/tests/misc/lists5.html0000666000000000000000000000040411756571172015513 0ustar 00000000000000

This is a test of a block quote With just two lines

A paragraph

This is a more difficult case With a list item inside the quote

  • Alpha
  • Beta Etc.
Markdown-2.4/tests/misc/lists5.txt0000666000000000000000000000026311756571172015371 0ustar 00000000000000> This is a test of a block quote > With just two lines A paragraph > This is a more difficult case > With a list item inside the quote > > * Alpha > * Beta > Etc. Markdown-2.4/tests/misc/lists6.html0000666000000000000000000000040411756571172015514 0ustar 00000000000000

Test five or more spaces as start of list:

  • five spaces

not first item:

  • one space
  • five spaces

loose list:

  • one space

  • five spaces

Markdown-2.4/tests/misc/lists6.txt0000666000000000000000000000025111756571172015367 0ustar 00000000000000Test five or more spaces as start of list: * five spaces not first item: * one space * five spaces loose list: * one space * five spaces Markdown-2.4/tests/misc/lists7.html0000666000000000000000000000210711756571172015517 0ustar 00000000000000
  • item 1
    • item 2-1
    • item 2-2
    • item 2-3
    • item 2-4
  • item 3
    • item 4-1

    • item 4-2

    • item 4-3

    • item 4-4

same as above, different spacing

  • item 1
    • item 2-1
    • item 2-2
  • item 3
    • item 4-1

    • item 4-2

only 1 item in nested list ##

  • item 1
    • item 2-1
  • item 3
    • item 4-1

Something ludicrous ##

  • item 1
    • item 2-1
    • item 2-2
      • item 2-2-1
      • item 2-2-2
    • item 2-3
  • item 3
    • item 4-1

      • item 4-1-1
      • item 4-1-2
    • item 4-2

Markdown-2.4/tests/misc/lists7.txt0000666000000000000000000000110111756571172015363 0ustar 00000000000000* item 1 * * item 2-1 * item 2-2 * item 2-3 * item 2-4 * item 3 * * item 4-1 * item 4-2 * item 4-3 * item 4-4 ## same as above, different spacing * item 1 * * item 2-1 * item 2-2 * item 3 * * item 4-1 * item 4-2 ## only 1 item in nested list ## * item 1 * * item 2-1 * item 3 * * item 4-1 ## Something ludicrous ## * item 1 * * item 2-1 * item 2-2 * * item 2-2-1 * item 2-2-2 * item 2-3 * item 3 * * item 4-1 * * item 4-1-1 * item 4-1-2 * item 4-2 Markdown-2.4/tests/misc/lists8.html0000666000000000000000000000113011756571172015513 0ustar 00000000000000

Lists with blockquotes

  1. Four-score and seven years ago...

  2. We have nothing to fear...

  3. This is it...

Multi-line blockquotes

  • Four-score and sever years ago our fathers brought forth

  • We have nothing to fear but fear itself

  • This is it as far as I'm concerned

Markdown-2.4/tests/misc/lists8.txt0000666000000000000000000000047511756571172015401 0ustar 00000000000000# Lists with blockquotes 1. > Four-score and seven years ago... 2. > We have nothing to fear... 3. > This is it... # Multi-line blockquotes * > Four-score and sever years ago > our fathers brought forth * > We have nothing to fear > but fear itself * > This is it > as far as I'm concerned Markdown-2.4/tests/misc/markup-inside-p.html0000666000000000000000000000014411756571172017276 0ustar 00000000000000

_foo_

_foo_

_foo_

_foo_

_foo_

Markdown-2.4/tests/misc/markup-inside-p.txt0000666000000000000000000000014611756571172017153 0ustar 00000000000000

_foo_

_foo_

_foo_

_foo_

_foo_

Markdown-2.4/tests/misc/mismatched-tags.html0000666000000000000000000000041412111563027017325 0ustar 00000000000000

Some text

some more text

and a bit more

And this output

Compatible with PHP Markdown Extra 1.2.2 and Markdown.pl1.0.2b8:

text


Should be in p

Markdown-2.4/tests/misc/mismatched-tags.txt0000666000000000000000000000034211756571172017216 0ustar 00000000000000

Some text

some more text
and a bit more

And this output

*Compatible with PHP Markdown Extra 1.2.2 and Markdown.pl1.0.2b8:*

text


Should be in p Markdown-2.4/tests/misc/missing-link-def.html0000666000000000000000000000015111756571172017427 0ustar 00000000000000

This is a [missing link][empty] and a valid and [missing][again].

Markdown-2.4/tests/misc/missing-link-def.txt0000666000000000000000000000015311756571172017304 0ustar 00000000000000This is a [missing link][empty] and a [valid][link] and [missing][again]. [link]: http://example.com Markdown-2.4/tests/misc/more_comments.html0000666000000000000000000000016412300201167017116 0ustar 00000000000000

Foo

Bar

foo

foo

foo

foo
This shouldn't

<?php echo "not_block_level";?>

Markdown-2.4/tests/misc/php.txt0000666000000000000000000000041311756571172014732 0ustar 00000000000000 This should have a p tag
This shouldn't
Markdown-2.4/tests/misc/pre.html0000666000000000000000000000023511756571172015060 0ustar 00000000000000

aaa

bbb
* and this is pre-formatted content
* and it should be printed just like this
* and not formatted as a list

Markdown-2.4/tests/misc/pre.txt0000666000000000000000000000024111756571172014730 0ustar 00000000000000

aaa

bbb
* and this is pre-formatted content
* and it should be printed just like this
* and not formatted as a list

Markdown-2.4/tests/misc/raw_whitespace.html0000666000000000000000000000020211756571172017271 0ustar 00000000000000

Preserve whitespace in raw html

class Foo():
    bar = 'bar'

    def baz(self):
        print self.bar
Markdown-2.4/tests/misc/raw_whitespace.txt0000666000000000000000000000020111756571172017143 0ustar 00000000000000Preserve whitespace in raw html
class Foo():
    bar = 'bar'

    def baz(self):
        print self.bar
Markdown-2.4/tests/misc/russian.html0000666000000000000000000000644011756571172015762 0ustar 00000000000000

Ðедвард «Ðед» ФландерÑ

Ðедвард «Ðед» Ð¤Ð»Ð°Ð½Ð´ÐµÑ€Ñ (Nedward «Ned» Flanders) — вымышленный перÑонаж мультÑериала «[СимпÑоны][]», озвученный Гарри Ширером. Он и его ÑÐµÐ¼ÑŒÑ Ð¶Ð¸Ð²ÑƒÑ‚ по ÑоÑедÑтву от Ñемьи СимпÑонов. Ðабожный хриÑтианин, Ðед ÑвлÑетÑÑ Ð¾Ð´Ð½Ð¸Ð¼ из Ñтолпов морали Спрингфилда. Ð’ Ñпизоде «Alone Again, Natura-Diddily» он овдовел, его жена Мод погибла в результате неÑчаÑтного ÑлучаÑ.

Ðед был одним из первых перÑонажей в мультÑериале, который не был членом Ñемьи СимпÑонов. ÐÐ°Ñ‡Ð¸Ð½Ð°Ñ Ñ Ð¿ÐµÑ€Ð²Ñ‹Ñ… Ñерий, он регулÑрно поÑвлÑетÑÑ Ð² «СимпÑонах». СчитаетÑÑ, что Ðед Ð¤Ð»Ð°Ð½Ð´ÐµÑ€Ñ Ð±Ñ‹Ð» назван в чеÑть улицы Northeast Flanders St. в Портленде, Орегон, родном городе ÑÐ¾Ð·Ð´Ð°Ñ‚ÐµÐ»Ñ Ð¼ÑƒÐ»ÑŒÑ‚Ñериала МÑтта Грейнинга]]. ÐадпиÑÑŒ на указателе улицы NE Flanders St. хулиганы чаÑто иÑправлÑли на NED Flanders St.

БиографиÑ

Ðед Ð¤Ð»Ð°Ð½Ð´ÐµÑ€Ñ Ñ€Ð¾Ð´Ð¸Ð»ÑÑ Ð² Ðью-Йорке, его родители были битниками. Его отец в точноÑти похож на взроÑлого Ðеда, только он ноÑил козлиную бородку. Их отказ от воÑÐ¿Ð¸Ñ‚Ð°Ð½Ð¸Ñ Ðеда и то, что они, в общем-то, были плохими родителÑми («мы ничего в Ñтом не понимаем и не знаем как начать») привело к тому, что Ðед превратилÑÑ Ð² ужаÑного Ñорванца. Ð’ конце концов они ÑоглаÑилиÑÑŒ на ÑкÑпериментальную воÑьмимеÑÑчную шлепологичеÑкую терапию МиннеÑотÑкого УниверÑитета (воÑÐ¿Ð¾Ð¼Ð¸Ð½Ð°Ð½Ð¸Ñ Ðеда в Ñпизоде «Hurricane Neddy»), ÐºÐ¾Ñ‚Ð¾Ñ€Ð°Ñ Ð½Ð°ÑƒÑ‡Ð¸Ð»Ð° его подавлÑть чувÑтво злоÑти. Побочным Ñфектом терапии Ñтало то, что Ðед Ñтал ненавидеть Ñвоих родителей (Ñто одна из двух вещей которые ненавидит ФландерÑ, Ð²Ñ‚Ð¾Ñ€Ð°Ñ â€” Ð¾Ñ‚Ð´ÐµÐ»ÐµÐ½Ð¸Ñ Ð¿Ð¾Ñ‡Ñ‚Ñ‹, чьи длинные очереди, Ñуета и угрюмый перÑонал раздражают его).

У Ðеда еÑть ÑÑ‚Ñ€Ð°Ð½Ð½Ð°Ñ Ð¿Ñ€Ð¸Ð²Ñ‹Ñ‡ÐºÐ° добавлÑть «дидли», «дадли» и другие беÑÑмыÑленные Ñлова в Ñвои фразы при разговоре, например: «Hi-diddly-ho, neighbor-ino» («Приветик, ÑоÑедушка»). Это результат Ñублимации его злоÑти, вызванной Ñдерживанием гнева, который не имеет никакого другого выхода.

Markdown-2.4/tests/misc/russian.txt0000666000000000000000000000636211756571172015640 0ustar 00000000000000Ðедвард «Ðед» Ð¤Ð»Ð°Ð½Ð´ÐµÑ€Ñ ====================== **Ðедвард «Ðед» ФландерÑ** (Nedward «Ned» Flanders) — вымышленный перÑонаж мультÑериала «[СимпÑоны][]», озвученный Гарри Ширером. Он и его ÑÐµÐ¼ÑŒÑ Ð¶Ð¸Ð²ÑƒÑ‚ по ÑоÑедÑтву от Ñемьи СимпÑонов. Ðабожный хриÑтианин, Ðед ÑвлÑетÑÑ Ð¾Ð´Ð½Ð¸Ð¼ из Ñтолпов морали Спрингфилда. Ð’ Ñпизоде «Alone Again, Natura-Diddily» он овдовел, его жена Мод погибла в результате неÑчаÑтного ÑлучаÑ. Ðед был одним из первых перÑонажей в мультÑериале, который не был членом Ñемьи СимпÑонов. ÐÐ°Ñ‡Ð¸Ð½Ð°Ñ Ñ Ð¿ÐµÑ€Ð²Ñ‹Ñ… Ñерий, он регулÑрно поÑвлÑетÑÑ Ð² «СимпÑонах». СчитаетÑÑ, что Ðед Ð¤Ð»Ð°Ð½Ð´ÐµÑ€Ñ Ð±Ñ‹Ð» назван в чеÑть улицы *Northeast Flanders St.* в [Портленде](http://www.portland.gov), Орегон, родном городе ÑÐ¾Ð·Ð´Ð°Ñ‚ÐµÐ»Ñ Ð¼ÑƒÐ»ÑŒÑ‚Ñериала МÑтта Грейнинга]]. ÐадпиÑÑŒ на указателе улицы *NE Flanders St.* хулиганы чаÑто иÑправлÑли на _NED Flanders St._ ## Ð‘Ð¸Ð¾Ð³Ñ€Ð°Ñ„Ð¸Ñ Ðед Ð¤Ð»Ð°Ð½Ð´ÐµÑ€Ñ Ñ€Ð¾Ð´Ð¸Ð»ÑÑ Ð² Ðью-Йорке, его родители были битниками. Его отец в точноÑти похож на взроÑлого Ðеда, только он ноÑил козлиную бородку. Их отказ от воÑÐ¿Ð¸Ñ‚Ð°Ð½Ð¸Ñ Ðеда и то, что они, в общем-то, были плохими родителÑми («мы ничего в Ñтом не понимаем и не знаем как начать») привело к тому, что Ðед превратилÑÑ Ð² ужаÑного Ñорванца. Ð’ конце концов они ÑоглаÑилиÑÑŒ на ÑкÑпериментальную воÑьмимеÑÑчную шлепологичеÑкую терапию МиннеÑотÑкого УниверÑитета (воÑÐ¿Ð¾Ð¼Ð¸Ð½Ð°Ð½Ð¸Ñ Ðеда в Ñпизоде «Hurricane Neddy»), ÐºÐ¾Ñ‚Ð¾Ñ€Ð°Ñ Ð½Ð°ÑƒÑ‡Ð¸Ð»Ð° его подавлÑть чувÑтво злоÑти. Побочным Ñфектом терапии Ñтало то, что Ðед Ñтал ненавидеть Ñвоих родителей (Ñто одна из двух вещей которые ненавидит ФландерÑ, Ð²Ñ‚Ð¾Ñ€Ð°Ñ â€” Ð¾Ñ‚Ð´ÐµÐ»ÐµÐ½Ð¸Ñ Ð¿Ð¾Ñ‡Ñ‚Ñ‹, чьи длинные очереди, Ñуета и угрюмый перÑонал раздражают его). У Ðеда еÑть ÑÑ‚Ñ€Ð°Ð½Ð½Ð°Ñ Ð¿Ñ€Ð¸Ð²Ñ‹Ñ‡ÐºÐ° добавлÑть «дидли», «дадли» и другие беÑÑмыÑленные Ñлова в Ñвои фразы при разговоре, например: «Hi-diddly-ho, neighbor-ino» («Приветик, ÑоÑедушка»). Это результат Ñублимации его злоÑти, вызванной Ñдерживанием гнева, который не имеет никакого другого выхода. Markdown-2.4/tests/misc/smart_em.html0000666000000000000000000000026611756571172016105 0ustar 00000000000000

emphasis

this_is_not_emphasis

[punctuation with emphasis]

[punctuation_with_emphasis]

[punctuation_without_emphasis]

Markdown-2.4/tests/misc/smart_em.txt0000666000000000000000000000021011756571172015745 0ustar 00000000000000_emphasis_ this_is_not_emphasis [_punctuation with emphasis_] [_punctuation_with_emphasis_] [punctuation_without_emphasis] Markdown-2.4/tests/misc/some-test.html0000666000000000000000000000143111756571172016211 0ustar 00000000000000
  • as if

  • as if2


  • as if

  • as if2


  • as if non_code
  • as if2

Markdown

  • Python is ok

    • Therefore i am
  • Perl sucks big time

    • But that's ok
  • Python is ok Or not?

Here is a normal paragraph

  1. Another list with a bunch of items
  2. Mostly fruits

    1. Apple
    2. Pare

asdfasdfasd

# This is a code example
import stuff

Another code example
* Lists and similar stuff

> Should be ignored
Markdown-2.4/tests/misc/some-test.txt0000666000000000000000000000112211756571172016061 0ustar 00000000000000---------------------- * as if * as if2 ---------------------- * as if * as if2 ---------------------- * as if non_code * as if2 Markdown * Python is ok * Therefore i am * Perl sucks big time * But that's ok * Python is ok Or not? Here is a normal paragraph 1. Another list with a bunch of items 2. Mostly fruits 3. Apple 4. Pare asdfasdfasd # This is a code example import stuff Another code example * Lists and similar stuff > Should be ignored Markdown-2.4/tests/misc/span.html0000666000000000000000000000026311756571172015234 0ustar 00000000000000

Foo bar Baz

*foo*
Foo *bar* Baz

Foo bar Baz

Markdown-2.4/tests/misc/span.txt0000666000000000000000000000024111756571172015103 0ustar 00000000000000 Foo *bar* Baz
*foo*
Foo *bar* Baz
Foo *bar* Baz Markdown-2.4/tests/misc/strong-with-underscores.html0000666000000000000000000000004611756571172021111 0ustar 00000000000000

this_is_strong

Markdown-2.4/tests/misc/strong-with-underscores.txt0000666000000000000000000000002411756571172020760 0ustar 00000000000000__this_is_strong__ Markdown-2.4/tests/misc/stronintags.html0000666000000000000000000000035111756571172016644 0ustar 00000000000000

this is a test

this is a second test

reference [test][] reference [test][]

Markdown-2.4/tests/misc/stronintags.txt0000666000000000000000000000022411756571172016516 0ustar 00000000000000this is a [**test**](http://example.com/) this is a second **[test](http://example.com)** reference **[test][]** reference [**test**][] Markdown-2.4/tests/misc/tabs-in-lists.html0000666000000000000000000000073311756571172016766 0ustar 00000000000000

First a list with a tabbed line

  • A

  • B

Just a blank line:

  • A

  • B

Now a list with 4 spaces and some text:

  • A abcdef
  • B

Now with a tab and an extra space:

  • A

  • B

Now a list with 4 spaces:

  • A

  • B

Markdown-2.4/tests/misc/tabs-in-lists.txt0000666000000000000000000000040211756571172016632 0ustar 00000000000000First a list with a tabbed line * A * B Just a blank line: * A * B Now a list with 4 spaces and some text: * A abcdef * B Now with a tab and an extra space: * A * B Now a list with 4 spaces: * A * B Markdown-2.4/tests/misc/test.cfg0000666000000000000000000000005012111563027015021 0ustar 00000000000000[no-attributes] enable_attributes=FalseMarkdown-2.4/tests/misc/two-spaces.html0000666000000000000000000000066612111563027016351 0ustar 00000000000000

This line has two spaces at the end
but this one has none but this line has three
and this is the second from last line in this test message

  • This list item has two spaces.
  • This has none. This line has three.
    This line has none. And this line two.

    This line has none.

  • This line has none.

And this is the end.

Markdown-2.4/tests/misc/two-spaces.txt0000666000000000000000000000055311756571172016235 0ustar 00000000000000This line has two spaces at the end but this one has none but this line has three and this is the second from last line in this test message * This list item has two spaces. * This has none. This line has three. This line has none. And this line two. This line has none. * This line has none. And this is the end. Markdown-2.4/tests/misc/uche.html0000666000000000000000000000053111756571172015215 0ustar 00000000000000

asif

text

Markdown-2.4/tests/misc/uche.txt0000666000000000000000000000037211756571172015073 0ustar 00000000000000![asif](http://fourthought.com/images/ftlogo.png "Fourthought logo") [![{@style=float: left; margin: 10px; border: none;}](http://fourthought.com/images/ftlogo.png "Fourthought logo")](http://fourthought.com/) [![text](x)](http://link.com/) Markdown-2.4/tests/misc/underscores.html0000666000000000000000000000040711756571173016630 0ustar 00000000000000

THIS_SHOULD_STAY_AS_IS

Here is some emphasis, ok?

Ok, at least this should work.

THISSHOULDSTAY

Here is some strong stuff.

THISSHOULDSTAY?

Markdown-2.4/tests/misc/underscores.txt0000666000000000000000000000025511756571173016504 0ustar 00000000000000THIS_SHOULD_STAY_AS_IS Here is some _emphasis_, ok? Ok, at least _this_ should work. THIS__SHOULD__STAY Here is some __strong__ stuff. THIS___SHOULD___STAY? Markdown-2.4/tests/misc/url_spaces.html0000666000000000000000000000024212300201167016404 0ustar 00000000000000

Dawn of War

Dawn of War

Markdown-2.4/tests/misc/url_spaces.txt0000666000000000000000000000017611756571173016312 0ustar 00000000000000[Dawn of War](http://wikipedia.org/wiki/Dawn of War) [Dawn of War](http://wikipedia.org/wiki/Dawn of War "Dawn of War") Markdown-2.4/tests/options/0000777000000000000000000000000012300213224014115 5ustar 00000000000000Markdown-2.4/tests/options/lazy_ol_off.html0000666000000000000000000000044511756571173017341 0ustar 00000000000000

A numbered list from daringfireball:

  1. Bird
  2. McHale
  3. Parish

Again:

  1. Bird
  2. McHale
  3. Parish

Now starting with 1:

  1. Bird
  2. McHale
  3. Parish
Markdown-2.4/tests/options/lazy_ol_off.txt0000666000000000000000000000025311756571173017211 0ustar 00000000000000A numbered list from daringfireball: 3. Bird 1. McHale 8. Parish Again: 3. Bird 1. McHale 8. Parish Now starting with 1: 1. Bird 1. McHale 8. Parish Markdown-2.4/tests/options/test.cfg0000666000000000000000000000004011756571173015577 0ustar 00000000000000[lazy_ol_off] lazy_ol = False Markdown-2.4/tests/php/0000777000000000000000000000000012300213224013211 5ustar 00000000000000Markdown-2.4/tests/php/extra/0000777000000000000000000000000012300213224014334 5ustar 00000000000000Markdown-2.4/tests/php/extra/test.cfg0000666000000000000000000000012611756571173016023 0ustar 00000000000000[DEFAULT] extensions=extra normalize=1 input_ext=.text output_ext=.xhtml skip=1 Markdown-2.4/tests/php/test.cfg0000666000000000000000000000172311756571173014704 0ustar 00000000000000[DEFAULT] normalize=1 input_ext=.text output_ext=.xhtml #skip=1 [Quotes in attributes] # attributes get output in differant order skip=1 [Inline HTML (Span)] # Backtick in raw HTML attribute TODO: fixme skip=1 [Backslash escapes] # Weird whitespace issue in output skip=1 [Ins & del] # Our behavior follows markdown.pl I think PHP is wrong here skip=1 [Auto Links] # TODO: fix raw HTML so is doesn't match as a
. skip=1 [Empty List Item] # We match markdown.pl here. Maybe someday we'll support this skip=1 [Headers] # TODO: fix headers to not require blank line before skip=1 [Mixed OLs and ULs] # We match markdown.pl here. I think PHP is wrong here skip=1 [Emphasis] # We have various minor differances in combined & incorrect em markup. # Maybe fix a few of them - but most aren't too important skip=1 [Code block in a list item] # We match markdown.pl - not sure how php gets that output?? skip=1 Markdown-2.4/tests/pl/0000777000000000000000000000000012300213217013037 5ustar 00000000000000Markdown-2.4/tests/pl/Tests_2004/0000777000000000000000000000000012300213224014604 5ustar 00000000000000Markdown-2.4/tests/pl/Tests_2004/Amps and angle encoding.html0000666000000000000000000000101211756571173021755 0ustar 00000000000000

AT&T has an ampersand in their name.

AT&T is another way to write it.

This & that.

4 < 5.

6 > 5.

Here's a link with an ampersand in the URL.

Here's a link with an amersand in the link text: AT&T.

Here's an inline link.

Here's an inline link.

Markdown-2.4/tests/pl/Tests_2004/Auto links.html0000666000000000000000000000106411756571173017534 0ustar 00000000000000

Link: http://example.com/.

With an ampersand: http://example.com/?foo=1&bar=2

Blockquoted: http://example.com/

Auto-links should not occur here: <http://example.com/>

or here: <http://example.com/>
Markdown-2.4/tests/pl/Tests_2004/Backslash escapes.html0000666000000000000000000000257411756571173021031 0ustar 00000000000000

These should all get escaped:

Backslash: \

Backtick: `

Asterisk: *

Underscore: _

Left brace: {

Right brace: }

Left bracket: [

Right bracket: ]

Left paren: (

Right paren: )

Greater-than: >

Hash: #

Period: .

Bang: !

Plus: +

Minus: -

These should not, because they occur within a code block:

Backslash: \\

Backtick: \`

Asterisk: \*

Underscore: \_

Left brace: \{

Right brace: \}

Left bracket: \[

Right bracket: \]

Left paren: \(

Right paren: \)

Greater-than: \>

Hash: \#

Period: \.

Bang: \!

Plus: \+

Minus: \-

Nor should these, which occur in code spans:

Backslash: \\

Backtick: \`

Asterisk: \*

Underscore: \_

Left brace: \{

Right brace: \}

Left bracket: \[

Right bracket: \]

Left paren: \(

Right paren: \)

Greater-than: \>

Hash: \#

Period: \.

Bang: \!

Plus: \+

Minus: \-

Markdown-2.4/tests/pl/Tests_2004/Blockquotes with code blocks.html0000666000000000000000000000031111756571173023075 0ustar 00000000000000

Example:

sub status {
    print "working";
}

Or:

sub status {
    return "working";
}
Markdown-2.4/tests/pl/Tests_2004/Hard-wrapped paragraphs with list-like lines.html0000666000000000000000000000033311756571173026055 0ustar 00000000000000

In Markdown 1.0.0 and earlier. Version 8. This line turns into a list item. Because a hard-wrapped line in the middle of a paragraph looked like a list item.

Here's one with a bullet. * criminey.

Markdown-2.4/tests/pl/Tests_2004/Horizontal rules.html0000666000000000000000000000077011756571173020772 0ustar 00000000000000

Dashes:





---




- - -

Asterisks:





***




* * *

Underscores:





___




_ _ _
Markdown-2.4/tests/pl/Tests_2004/Inline HTML (Advanced).html0000666000000000000000000000024211756571173021272 0ustar 00000000000000

Simple block on one line:

foo

And nested without indentation:

foo
bar
Markdown-2.4/tests/pl/Tests_2004/Inline HTML (Simple).html0000666000000000000000000000153011756571173021017 0ustar 00000000000000

Here's a simple block:

foo

This should be a code block, though:

<div>
    foo
</div>

As should this:

<div>foo</div>

Now, nested:

foo

This should just be an HTML comment:

Multiline:

Code block:

<!-- Comment -->

Just plain comment, with trailing spaces on the line:

Code:

<hr />

Hr's:










Markdown-2.4/tests/pl/Tests_2004/Inline HTML comments.html0000666000000000000000000000031111756571173021266 0ustar 00000000000000

Paragraph one.

Paragraph two.

The end.

Markdown-2.4/tests/pl/Tests_2004/Links, inline style.html0000666000000000000000000000044211756571173021236 0ustar 00000000000000

Just a URL.

URL and title.

URL and title.

URL and title.

Empty.

Markdown-2.4/tests/pl/Tests_2004/Links, reference style.html0000666000000000000000000000065111756571173021720 0ustar 00000000000000

Foo bar.

Foo bar.

Foo bar.

With embedded [brackets].

Indented once.

Indented twice.

Indented thrice.

Indented [four][] times.

[four]: /url
Markdown-2.4/tests/pl/Tests_2004/Literal quotes in titles.html0000666000000000000000000000024611756571173022275 0ustar 00000000000000

Foo bar.

Foo bar.

Markdown-2.4/tests/pl/Tests_2004/Markdown Documentation - Basics.html0000666000000000000000000002274211756571173023407 0ustar 00000000000000

Markdown: Basics

Getting the Gist of Markdown's Formatting Syntax

This page offers a brief overview of what it's like to use Markdown. The syntax page provides complete, detailed documentation for every feature, but Markdown should be very easy to pick up simply by looking at a few examples of it in action. The examples on this page are written in a before/after style, showing example syntax and the HTML output produced by Markdown.

It's also helpful to simply try Markdown out; the Dingus is a web application that allows you type your own Markdown-formatted text and translate it to XHTML.

Note: This document is itself written using Markdown; you can see the source for it by adding '.text' to the URL.

Paragraphs, Headers, Blockquotes

A paragraph is simply one or more consecutive lines of text, separated by one or more blank lines. (A blank line is any line that looks like a blank line -- a line containing nothing spaces or tabs is considered blank.) Normal paragraphs should not be intended with spaces or tabs.

Markdown offers two styles of headers: Setext and atx. Setext-style headers for <h1> and <h2> are created by "underlining" with equal signs (=) and hyphens (-), respectively. To create an atx-style header, you put 1-6 hash marks (#) at the beginning of the line -- the number of hashes equals the resulting HTML header level.

Blockquotes are indicated using email-style '>' angle brackets.

Markdown:

A First Level Header
====================

A Second Level Header
---------------------

Now is the time for all good men to come to
the aid of their country. This is just a
regular paragraph.

The quick brown fox jumped over the lazy
dog's back.

### Header 3

> This is a blockquote.
> 
> This is the second paragraph in the blockquote.
>
> ## This is an H2 in a blockquote

Output:

<h1>A First Level Header</h1>

<h2>A Second Level Header</h2>

<p>Now is the time for all good men to come to
the aid of their country. This is just a
regular paragraph.</p>

<p>The quick brown fox jumped over the lazy
dog's back.</p>

<h3>Header 3</h3>

<blockquote>
    <p>This is a blockquote.</p>

    <p>This is the second paragraph in the blockquote.</p>

    <h2>This is an H2 in a blockquote</h2>
</blockquote>

Phrase Emphasis

Markdown uses asterisks and underscores to indicate spans of emphasis.

Markdown:

Some of these words *are emphasized*.
Some of these words _are emphasized also_.

Use two asterisks for **strong emphasis**.
Or, if you prefer, __use two underscores instead__.

Output:

<p>Some of these words <em>are emphasized</em>.
Some of these words <em>are emphasized also</em>.</p>

<p>Use two asterisks for <strong>strong emphasis</strong>.
Or, if you prefer, <strong>use two underscores instead</strong>.</p>

Lists

Unordered (bulleted) lists use asterisks, pluses, and hyphens (*, +, and -) as list markers. These three markers are interchangable; this:

*   Candy.
*   Gum.
*   Booze.

this:

+   Candy.
+   Gum.
+   Booze.

and this:

-   Candy.
-   Gum.
-   Booze.

all produce the same output:

<ul>
<li>Candy.</li>
<li>Gum.</li>
<li>Booze.</li>
</ul>

Ordered (numbered) lists use regular numbers, followed by periods, as list markers:

1.  Red
2.  Green
3.  Blue

Output:

<ol>
<li>Red</li>
<li>Green</li>
<li>Blue</li>
</ol>

If you put blank lines between items, you'll get <p> tags for the list item text. You can create multi-paragraph list items by indenting the paragraphs by 4 spaces or 1 tab:

*   A list item.

    With multiple paragraphs.

*   Another item in the list.

Output:

<ul>
<li><p>A list item.</p>
<p>With multiple paragraphs.</p></li>
<li><p>Another item in the list.</p></li>
</ul>

Links

Markdown supports two styles for creating links: inline and reference. With both styles, you use square brackets to delimit the text you want to turn into a link.

Inline-style links use parentheses immediately after the link text. For example:

This is an [example link](http://example.com/).

Output:

<p>This is an <a href="http://example.com/">
example link</a>.</p>

Optionally, you may include a title attribute in the parentheses:

This is an [example link](http://example.com/ "With a Title").

Output:

<p>This is an <a href="http://example.com/" title="With a Title">
example link</a>.</p>

Reference-style links allow you to refer to your links by names, which you define elsewhere in your document:

I get 10 times more traffic from [Google][1] than from
[Yahoo][2] or [MSN][3].

[1]: http://google.com/        "Google"
[2]: http://search.yahoo.com/  "Yahoo Search"
[3]: http://search.msn.com/    "MSN Search"

Output:

<p>I get 10 times more traffic from <a href="http://google.com/"
title="Google">Google</a> than from <a href="http://search.yahoo.com/"
title="Yahoo Search">Yahoo</a> or <a href="http://search.msn.com/"
title="MSN Search">MSN</a>.</p>

The title attribute is optional. Link names may contain letters, numbers and spaces, but are not case sensitive:

I start my morning with a cup of coffee and
[The New York Times][NY Times].

[ny times]: http://www.nytimes.com/

Output:

<p>I start my morning with a cup of coffee and
<a href="http://www.nytimes.com/">The New York Times</a>.</p>

Images

Image syntax is very much like link syntax.

Inline (titles are optional):

![alt text](/path/to/img.jpg "Title")

Reference-style:

![alt text][id]

[id]: /path/to/img.jpg "Title"

Both of the above examples produce the same output:

<img src="/path/to/img.jpg" alt="alt text" title="Title" />

Code

In a regular paragraph, you can create code span by wrapping text in backtick quotes. Any ampersands (&) and angle brackets (< or >) will automatically be translated into HTML entities. This makes it easy to use Markdown to write about HTML example code:

I strongly recommend against using any `<blink>` tags.

I wish SmartyPants used named entities like `&mdash;`
instead of decimal-encoded entites like `&#8212;`.

Output:

<p>I strongly recommend against using any
<code>&lt;blink&gt;</code> tags.</p>

<p>I wish SmartyPants used named entities like
<code>&amp;mdash;</code> instead of decimal-encoded
entites like <code>&amp;#8212;</code>.</p>

To specify an entire block of pre-formatted code, indent every line of the block by 4 spaces or 1 tab. Just like with code spans, &, <, and > characters will be escaped automatically.

Markdown:

If you want your page to validate under XHTML 1.0 Strict,
you've got to put paragraph tags in your blockquotes:

    <blockquote>
        <p>For example.</p>
    </blockquote>

Output:

<p>If you want your page to validate under XHTML 1.0 Strict,
you've got to put paragraph tags in your blockquotes:</p>

<pre><code>&lt;blockquote&gt;
    &lt;p&gt;For example.&lt;/p&gt;
&lt;/blockquote&gt;
</code></pre>
Markdown-2.4/tests/pl/Tests_2004/Markdown Documentation - Syntax.html0000666000000000000000000007772711756571173023506 0ustar 00000000000000

Markdown: Syntax

Note: This document is itself written using Markdown; you can see the source for it by adding '.text' to the URL.


Overview

Philosophy

Markdown is intended to be as easy-to-read and easy-to-write as is feasible.

Readability, however, is emphasized above all else. A Markdown-formatted document should be publishable as-is, as plain text, without looking like it's been marked up with tags or formatting instructions. While Markdown's syntax has been influenced by several existing text-to-HTML filters -- including Setext, atx, Textile, reStructuredText, Grutatext, and EtText -- the single biggest source of inspiration for Markdown's syntax is the format of plain text email.

To this end, Markdown's syntax is comprised entirely of punctuation characters, which punctuation characters have been carefully chosen so as to look like what they mean. E.g., asterisks around a word actually look like *emphasis*. Markdown lists look like, well, lists. Even blockquotes look like quoted passages of text, assuming you've ever used email.

Inline HTML

Markdown's syntax is intended for one purpose: to be used as a format for writing for the web.

Markdown is not a replacement for HTML, or even close to it. Its syntax is very small, corresponding only to a very small subset of HTML tags. The idea is not to create a syntax that makes it easier to insert HTML tags. In my opinion, HTML tags are already easy to insert. The idea for Markdown is to make it easy to read, write, and edit prose. HTML is a publishing format; Markdown is a writing format. Thus, Markdown's formatting syntax only addresses issues that can be conveyed in plain text.

For any markup that is not covered by Markdown's syntax, you simply use HTML itself. There's no need to preface it or delimit it to indicate that you're switching from Markdown to HTML; you just use the tags.

The only restrictions are that block-level HTML elements -- e.g. <div>, <table>, <pre>, <p>, etc. -- must be separated from surrounding content by blank lines, and the start and end tags of the block should not be indented with tabs or spaces. Markdown is smart enough not to add extra (unwanted) <p> tags around HTML block-level tags.

For example, to add an HTML table to a Markdown article:

This is a regular paragraph.

<table>
    <tr>
        <td>Foo</td>
    </tr>
</table>

This is another regular paragraph.

Note that Markdown formatting syntax is not processed within block-level HTML tags. E.g., you can't use Markdown-style *emphasis* inside an HTML block.

Span-level HTML tags -- e.g. <span>, <cite>, or <del> -- can be used anywhere in a Markdown paragraph, list item, or header. If you want, you can even use HTML tags instead of Markdown formatting; e.g. if you'd prefer to use HTML <a> or <img> tags instead of Markdown's link or image syntax, go right ahead.

Unlike block-level HTML tags, Markdown syntax is processed within span-level tags.

Automatic Escaping for Special Characters

In HTML, there are two characters that demand special treatment: < and &. Left angle brackets are used to start tags; ampersands are used to denote HTML entities. If you want to use them as literal characters, you must escape them as entities, e.g. &lt;, and &amp;.

Ampersands in particular are bedeviling for web writers. If you want to write about 'AT&T', you need to write 'AT&amp;T'. You even need to escape ampersands within URLs. Thus, if you want to link to:

http://images.google.com/images?num=30&q=larry+bird

you need to encode the URL as:

http://images.google.com/images?num=30&amp;q=larry+bird

in your anchor tag href attribute. Needless to say, this is easy to forget, and is probably the single most common source of HTML validation errors in otherwise well-marked-up web sites.

Markdown allows you to use these characters naturally, taking care of all the necessary escaping for you. If you use an ampersand as part of an HTML entity, it remains unchanged; otherwise it will be translated into &amp;.

So, if you want to include a copyright symbol in your article, you can write:

&copy;

and Markdown will leave it alone. But if you write:

AT&T

Markdown will translate it to:

AT&amp;T

Similarly, because Markdown supports inline HTML, if you use angle brackets as delimiters for HTML tags, Markdown will treat them as such. But if you write:

4 < 5

Markdown will translate it to:

4 &lt; 5

However, inside Markdown code spans and blocks, angle brackets and ampersands are always encoded automatically. This makes it easy to use Markdown to write about HTML code. (As opposed to raw HTML, which is a terrible format for writing about HTML syntax, because every single < and & in your example code needs to be escaped.)


Block Elements

Paragraphs and Line Breaks

A paragraph is simply one or more consecutive lines of text, separated by one or more blank lines. (A blank line is any line that looks like a blank line -- a line containing nothing but spaces or tabs is considered blank.) Normal paragraphs should not be intended with spaces or tabs.

The implication of the "one or more consecutive lines of text" rule is that Markdown supports "hard-wrapped" text paragraphs. This differs significantly from most other text-to-HTML formatters (including Movable Type's "Convert Line Breaks" option) which translate every line break character in a paragraph into a <br /> tag.

When you do want to insert a <br /> break tag using Markdown, you end a line with two or more spaces, then type return.

Yes, this takes a tad more effort to create a <br />, but a simplistic "every line break is a <br />" rule wouldn't work for Markdown. Markdown's email-style blockquoting and multi-paragraph list items work best -- and look better -- when you format them with hard breaks.

Markdown supports two styles of headers, Setext and atx.

Setext-style headers are "underlined" using equal signs (for first-level headers) and dashes (for second-level headers). For example:

This is an H1
=============

This is an H2
-------------

Any number of underlining ='s or -'s will work.

Atx-style headers use 1-6 hash characters at the start of the line, corresponding to header levels 1-6. For example:

# This is an H1

## This is an H2

###### This is an H6

Optionally, you may "close" atx-style headers. This is purely cosmetic -- you can use this if you think it looks better. The closing hashes don't even need to match the number of hashes used to open the header. (The number of opening hashes determines the header level.) :

# This is an H1 #

## This is an H2 ##

### This is an H3 ######

Blockquotes

Markdown uses email-style > characters for blockquoting. If you're familiar with quoting passages of text in an email message, then you know how to create a blockquote in Markdown. It looks best if you hard wrap the text and put a > before every line:

> This is a blockquote with two paragraphs. Lorem ipsum dolor sit amet,
> consectetuer adipiscing elit. Aliquam hendrerit mi posuere lectus.
> Vestibulum enim wisi, viverra nec, fringilla in, laoreet vitae, risus.
> 
> Donec sit amet nisl. Aliquam semper ipsum sit amet velit. Suspendisse
> id sem consectetuer libero luctus adipiscing.

Markdown allows you to be lazy and only put the > before the first line of a hard-wrapped paragraph:

> This is a blockquote with two paragraphs. Lorem ipsum dolor sit amet,
consectetuer adipiscing elit. Aliquam hendrerit mi posuere lectus.
Vestibulum enim wisi, viverra nec, fringilla in, laoreet vitae, risus.

> Donec sit amet nisl. Aliquam semper ipsum sit amet velit. Suspendisse
id sem consectetuer libero luctus adipiscing.

Blockquotes can be nested (i.e. a blockquote-in-a-blockquote) by adding additional levels of >:

> This is the first level of quoting.
>
> > This is nested blockquote.
>
> Back to the first level.

Blockquotes can contain other Markdown elements, including headers, lists, and code blocks:

> ## This is a header.
> 
> 1.   This is the first list item.
> 2.   This is the second list item.
> 
> Here's some example code:
> 
>     return shell_exec("echo $input | $markdown_script");

Any decent text editor should make email-style quoting easy. For example, with BBEdit, you can make a selection and choose Increase Quote Level from the Text menu.

Lists

Markdown supports ordered (numbered) and unordered (bulleted) lists.

Unordered lists use asterisks, pluses, and hyphens -- interchangably -- as list markers:

*   Red
*   Green
*   Blue

is equivalent to:

+   Red
+   Green
+   Blue

and:

-   Red
-   Green
-   Blue

Ordered lists use numbers followed by periods:

1.  Bird
2.  McHale
3.  Parish

It's important to note that the actual numbers you use to mark the list have no effect on the HTML output Markdown produces. The HTML Markdown produces from the above list is:

<ol>
<li>Bird</li>
<li>McHale</li>
<li>Parish</li>
</ol>

If you instead wrote the list in Markdown like this:

1.  Bird
1.  McHale
1.  Parish

or even:

3. Bird
1. McHale
8. Parish

you'd get the exact same HTML output. The point is, if you want to, you can use ordinal numbers in your ordered Markdown lists, so that the numbers in your source match the numbers in your published HTML. But if you want to be lazy, you don't have to.

If you do use lazy list numbering, however, you should still start the list with the number 1. At some point in the future, Markdown may support starting ordered lists at an arbitrary number.

List markers typically start at the left margin, but may be indented by up to three spaces. List markers must be followed by one or more spaces or a tab.

To make lists look nice, you can wrap items with hanging indents:

*   Lorem ipsum dolor sit amet, consectetuer adipiscing elit.
    Aliquam hendrerit mi posuere lectus. Vestibulum enim wisi,
    viverra nec, fringilla in, laoreet vitae, risus.
*   Donec sit amet nisl. Aliquam semper ipsum sit amet velit.
    Suspendisse id sem consectetuer libero luctus adipiscing.

But if you want to be lazy, you don't have to:

*   Lorem ipsum dolor sit amet, consectetuer adipiscing elit.
Aliquam hendrerit mi posuere lectus. Vestibulum enim wisi,
viverra nec, fringilla in, laoreet vitae, risus.
*   Donec sit amet nisl. Aliquam semper ipsum sit amet velit.
Suspendisse id sem consectetuer libero luctus adipiscing.

If list items are separated by blank lines, Markdown will wrap the items in <p> tags in the HTML output. For example, this input:

*   Bird
*   Magic

will turn into:

<ul>
<li>Bird</li>
<li>Magic</li>
</ul>

But this:

*   Bird

*   Magic

will turn into:

<ul>
<li><p>Bird</p></li>
<li><p>Magic</p></li>
</ul>

List items may consist of multiple paragraphs. Each subsequent paragraph in a list item must be intended by either 4 spaces or one tab:

1.  This is a list item with two paragraphs. Lorem ipsum dolor
    sit amet, consectetuer adipiscing elit. Aliquam hendrerit
    mi posuere lectus.

    Vestibulum enim wisi, viverra nec, fringilla in, laoreet
    vitae, risus. Donec sit amet nisl. Aliquam semper ipsum
    sit amet velit.

2.  Suspendisse id sem consectetuer libero luctus adipiscing.

It looks nice if you indent every line of the subsequent paragraphs, but here again, Markdown will allow you to be lazy:

*   This is a list item with two paragraphs.

    This is the second paragraph in the list item. You're
only required to indent the first line. Lorem ipsum dolor
sit amet, consectetuer adipiscing elit.

*   Another item in the same list.

To put a blockquote within a list item, the blockquote's > delimiters need to be indented:

*   A list item with a blockquote:

    > This is a blockquote
    > inside a list item.

To put a code block within a list item, the code block needs to be indented twice -- 8 spaces or two tabs:

*   A list item with a code block:

        <code goes here>

It's worth noting that it's possible to trigger an ordered list by accident, by writing something like this:

1986. What a great season.

In other words, a number-period-space sequence at the beginning of a line. To avoid this, you can backslash-escape the period:

1986\. What a great season.

Code Blocks

Pre-formatted code blocks are used for writing about programming or markup source code. Rather than forming normal paragraphs, the lines of a code block are interpreted literally. Markdown wraps a code block in both <pre> and <code> tags.

To produce a code block in Markdown, simply indent every line of the block by at least 4 spaces or 1 tab. For example, given this input:

This is a normal paragraph:

    This is a code block.

Markdown will generate:

<p>This is a normal paragraph:</p>

<pre><code>This is a code block.
</code></pre>

One level of indentation -- 4 spaces or 1 tab -- is removed from each line of the code block. For example, this:

Here is an example of AppleScript:

    tell application "Foo"
        beep
    end tell

will turn into:

<p>Here is an example of AppleScript:</p>

<pre><code>tell application "Foo"
    beep
end tell
</code></pre>

A code block continues until it reaches a line that is not indented (or the end of the article).

Within a code block, ampersands (&) and angle brackets (< and >) are automatically converted into HTML entities. This makes it very easy to include example HTML source code using Markdown -- just paste it and indent it, and Markdown will handle the hassle of encoding the ampersands and angle brackets. For example, this:

    <div class="footer">
        &copy; 2004 Foo Corporation
    </div>

will turn into:

<pre><code>&lt;div class="footer"&gt;
    &amp;copy; 2004 Foo Corporation
&lt;/div&gt;
</code></pre>

Regular Markdown syntax is not processed within code blocks. E.g., asterisks are just literal asterisks within a code block. This means it's also easy to use Markdown to write about Markdown's own syntax.

Horizontal Rules

You can produce a horizontal rule tag (<hr />) by placing three or more hyphens, asterisks, or underscores on a line by themselves. If you wish, you may use spaces between the hyphens or asterisks. Each of the following lines will produce a horizontal rule:

* * *

***

*****

- - -

---------------------------------------

_ _ _

Span Elements

Markdown supports two style of links: inline and reference.

In both styles, the link text is delimited by [square brackets].

To create an inline link, use a set of regular parentheses immediately after the link text's closing square bracket. Inside the parentheses, put the URL where you want the link to point, along with an optional title for the link, surrounded in quotes. For example:

This is [an example](http://example.com/ "Title") inline link.

[This link](http://example.net/) has no title attribute.

Will produce:

<p>This is <a href="http://example.com/" title="Title">
an example</a> inline link.</p>

<p><a href="http://example.net/">This link</a> has no
title attribute.</p>

If you're referring to a local resource on the same server, you can use relative paths:

See my [About](/about/) page for details.

Reference-style links use a second set of square brackets, inside which you place a label of your choosing to identify the link:

This is [an example][id] reference-style link.

You can optionally use a space to separate the sets of brackets:

This is [an example] [id] reference-style link.

Then, anywhere in the document, you define your link label like this, on a line by itself:

[id]: http://example.com/  "Optional Title Here"

That is:

  • Square brackets containing the link identifier (optionally indented from the left margin using up to three spaces);
  • followed by a colon;
  • followed by one or more spaces (or tabs);
  • followed by the URL for the link;
  • optionally followed by a title attribute for the link, enclosed in double or single quotes.

The link URL may, optionally, be surrounded by angle brackets:

[id]: <http://example.com/>  "Optional Title Here"

You can put the title attribute on the next line and use extra spaces or tabs for padding, which tends to look better with longer URLs:

[id]: http://example.com/longish/path/to/resource/here
    "Optional Title Here"

Link definitions are only used for creating links during Markdown processing, and are stripped from your document in the HTML output.

Link definition names may constist of letters, numbers, spaces, and punctuation -- but they are not case sensitive. E.g. these two links:

[link text][a]
[link text][A]

are equivalent.

The implicit link name shortcut allows you to omit the name of the link, in which case the link text itself is used as the name. Just use an empty set of square brackets -- e.g., to link the word "Google" to the google.com web site, you could simply write:

[Google][]

And then define the link:

[Google]: http://google.com/

Because link names may contain spaces, this shortcut even works for multiple words in the link text:

Visit [Daring Fireball][] for more information.

And then define the link:

[Daring Fireball]: http://daringfireball.net/

Link definitions can be placed anywhere in your Markdown document. I tend to put them immediately after each paragraph in which they're used, but if you want, you can put them all at the end of your document, sort of like footnotes.

Here's an example of reference links in action:

I get 10 times more traffic from [Google] [1] than from
[Yahoo] [2] or [MSN] [3].

  [1]: http://google.com/        "Google"
  [2]: http://search.yahoo.com/  "Yahoo Search"
  [3]: http://search.msn.com/    "MSN Search"

Using the implicit link name shortcut, you could instead write:

I get 10 times more traffic from [Google][] than from
[Yahoo][] or [MSN][].

  [google]: http://google.com/        "Google"
  [yahoo]:  http://search.yahoo.com/  "Yahoo Search"
  [msn]:    http://search.msn.com/    "MSN Search"

Both of the above examples will produce the following HTML output:

<p>I get 10 times more traffic from <a href="http://google.com/"
title="Google">Google</a> than from
<a href="http://search.yahoo.com/" title="Yahoo Search">Yahoo</a>
or <a href="http://search.msn.com/" title="MSN Search">MSN</a>.</p>

For comparison, here is the same paragraph written using Markdown's inline link style:

I get 10 times more traffic from [Google](http://google.com/ "Google")
than from [Yahoo](http://search.yahoo.com/ "Yahoo Search") or
[MSN](http://search.msn.com/ "MSN Search").

The point of reference-style links is not that they're easier to write. The point is that with reference-style links, your document source is vastly more readable. Compare the above examples: using reference-style links, the paragraph itself is only 81 characters long; with inline-style links, it's 176 characters; and as raw HTML, it's 234 characters. In the raw HTML, there's more markup than there is text.

With Markdown's reference-style links, a source document much more closely resembles the final output, as rendered in a browser. By allowing you to move the markup-related metadata out of the paragraph, you can add links without interrupting the narrative flow of your prose.

Emphasis

Markdown treats asterisks (*) and underscores (_) as indicators of emphasis. Text wrapped with one * or _ will be wrapped with an HTML <em> tag; double *'s or _'s will be wrapped with an HTML <strong> tag. E.g., this input:

*single asterisks*

_single underscores_

**double asterisks**

__double underscores__

will produce:

<em>single asterisks</em>

<em>single underscores</em>

<strong>double asterisks</strong>

<strong>double underscores</strong>

You can use whichever style you prefer; the lone restriction is that the same character must be used to open and close an emphasis span.

Emphasis can be used in the middle of a word:

un*fucking*believable

But if you surround an * or _ with spaces, it'll be treated as a literal asterisk or underscore.

To produce a literal asterisk or underscore at a position where it would otherwise be used as an emphasis delimiter, you can backslash escape it:

\*this text is surrounded by literal asterisks\*

Code

To indicate a span of code, wrap it with backtick quotes (`). Unlike a pre-formatted code block, a code span indicates code within a normal paragraph. For example:

Use the `printf()` function.

will produce:

<p>Use the <code>printf()</code> function.</p>

To include a literal backtick character within a code span, you can use multiple backticks as the opening and closing delimiters:

``There is a literal backtick (`) here.``

which will produce this:

<p><code>There is a literal backtick (`) here.</code></p>

The backtick delimiters surrounding a code span may include spaces -- one after the opening, one before the closing. This allows you to place literal backtick characters at the beginning or end of a code span:

A single backtick in a code span: `` ` ``

A backtick-delimited string in a code span: `` `foo` ``

will produce:

<p>A single backtick in a code span: <code>`</code></p>

<p>A backtick-delimited string in a code span: <code>`foo`</code></p>

With a code span, ampersands and angle brackets are encoded as HTML entities automatically, which makes it easy to include example HTML tags. Markdown will turn this:

Please don't use any `<blink>` tags.

into:

<p>Please don't use any <code>&lt;blink&gt;</code> tags.</p>

You can write this:

`&#8212;` is the decimal-encoded equivalent of `&mdash;`.

to produce:

<p><code>&amp;#8212;</code> is the decimal-encoded
equivalent of <code>&amp;mdash;</code>.</p>

Images

Admittedly, it's fairly difficult to devise a "natural" syntax for placing images into a plain text document format.

Markdown uses an image syntax that is intended to resemble the syntax for links, allowing for two styles: inline and reference.

Inline image syntax looks like this:

![Alt text](/path/to/img.jpg)

![Alt text](/path/to/img.jpg "Optional title")

That is:

  • An exclamation mark: !;
  • followed by a set of square brackets, containing the alt attribute text for the image;
  • followed by a set of parentheses, containing the URL or path to the image, and an optional title attribute enclosed in double or single quotes.

Reference-style image syntax looks like this:

![Alt text][id]

Where "id" is the name of a defined image reference. Image references are defined using syntax identical to link references:

[id]: url/to/image  "Optional title attribute"

As of this writing, Markdown has no syntax for specifying the dimensions of an image; if this is important to you, you can simply use regular HTML <img> tags.


Miscellaneous

Markdown supports a shortcut style for creating "automatic" links for URLs and email addresses: simply surround the URL or email address with angle brackets. What this means is that if you want to show the actual text of a URL or email address, and also have it be a clickable link, you can do this:

<http://example.com/>

Markdown will turn this into:

<a href="http://example.com/">http://example.com/</a>

Automatic links for email addresses work similarly, except that Markdown will also perform a bit of randomized decimal and hex entity-encoding to help obscure your address from address-harvesting spambots. For example, Markdown will turn this:

<address@example.com>

into something like this:

<a href="&#x6D;&#x61;i&#x6C;&#x74;&#x6F;:&#x61;&#x64;&#x64;&#x72;&#x65;
&#115;&#115;&#64;&#101;&#120;&#x61;&#109;&#x70;&#x6C;e&#x2E;&#99;&#111;
&#109;">&#x61;&#x64;&#x64;&#x72;&#x65;&#115;&#115;&#64;&#101;&#120;&#x61;
&#109;&#x70;&#x6C;e&#x2E;&#99;&#111;&#109;</a>

which will render in a browser as a clickable link to "address@example.com".

(This sort of entity-encoding trick will indeed fool many, if not most, address-harvesting bots, but it definitely won't fool all of them. It's better than nothing, but an address published in this way will probably eventually start receiving spam.)

Backslash Escapes

Markdown allows you to use backslash escapes to generate literal characters which would otherwise have special meaning in Markdown's formatting syntax. For example, if you wanted to surround a word with literal asterisks (instead of an HTML <em> tag), you can backslashes before the asterisks, like this:

\*literal asterisks\*

Markdown provides backslash escapes for the following characters:

\   backslash
`   backtick
*   asterisk
_   underscore
{}  curly braces
[]  square brackets
()  parentheses
#   hash mark
+   plus sign
-   minus sign (hyphen)
.   dot
!   exclamation mark
Markdown-2.4/tests/pl/Tests_2004/Nested blockquotes.html0000666000000000000000000000016211756571173021257 0ustar 00000000000000

foo

bar

foo

Markdown-2.4/tests/pl/Tests_2004/Ordered and unordered lists.html0000666000000000000000000000327311756571173022725 0ustar 00000000000000

Unordered

Asterisks tight:

  • asterisk 1
  • asterisk 2
  • asterisk 3

Asterisks loose:

  • asterisk 1

  • asterisk 2

  • asterisk 3


Pluses tight:

  • Plus 1
  • Plus 2
  • Plus 3

Pluses loose:

  • Plus 1

  • Plus 2

  • Plus 3


Minuses tight:

  • Minus 1
  • Minus 2
  • Minus 3

Minuses loose:

  • Minus 1

  • Minus 2

  • Minus 3

Ordered

Tight:

  1. First
  2. Second
  3. Third

and:

  1. One
  2. Two
  3. Three

Loose using tabs:

  1. First

  2. Second

  3. Third

and using spaces:

  1. One

  2. Two

  3. Three

Multiple paragraphs:

  1. Item 1, graf one.

    Item 2. graf two. The quick brown fox jumped over the lazy dog's back.

  2. Item 2.

  3. Item 3.

Nested

  • Tab
    • Tab
      • Tab

Here's another:

  1. First
  2. Second:
    • Fee
    • Fie
    • Foe
  3. Third

Same thing but with paragraphs:

  1. First

  2. Second:

    • Fee
    • Fie
    • Foe
  3. Third

Markdown-2.4/tests/pl/Tests_2004/Strong and em together.html0000666000000000000000000000033611756571173021707 0ustar 00000000000000

This is strong and em.

So is this word.

This is strong and em.

So is this word.

Markdown-2.4/tests/pl/Tests_2004/Tabs.html0000666000000000000000000000072011756571173016412 0ustar 00000000000000
  • this is a list item indented with tabs

  • this is a list item indented with spaces

Code:

this code block is indented by one tab

And:

    this code block is indented by two tabs

And:

+   this is an example list item
    indented with tabs

+   this is an example list item
    indented with spaces
Markdown-2.4/tests/pl/Tests_2004/test.cfg0000666000000000000000000000022211756571173016270 0ustar 00000000000000[DEFAULT] input_ext=.text normalize=1 # comment out next line to run these tests #skip=1 [Yuri-Footnotes] extensions=footnotes skip=1 Markdown-2.4/tests/pl/Tests_2004/Tidyness.html0000666000000000000000000000021511756571173017322 0ustar 00000000000000

A list within a blockquote:

  • asterisk 1
  • asterisk 2
  • asterisk 3
Markdown-2.4/tests/pl/Tests_2004/Yuri-Attributes.html0000666000000000000000000000154511756571173020603 0ustar 00000000000000

Lorem ipsum

Dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.

  • Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat.

  • Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur2. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.

Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.

Markdown-2.4/tests/pl/Tests_2004/Yuri-Email.html0000666000000000000000000000115111756571173017475 0ustar 00000000000000

Lorem ipsum yuri@domain.org, etc.

Markdown-2.4/tests/pl/Tests_2004/Yuri-Footnotes.html0000666000000000000000000000443411756571173020435 0ustar 00000000000000

Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua1. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur2. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.

  • Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore3 magna aliqua.

Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.


  1. Sed ut perspiciatis unde omnis iste natus error sit voluptatem accusantium doloremque laudantium, totam rem aperiam, eaque ipsa quae ab illo inventore veritatis et quasi architecto beatae vitae dicta sunt explicabo.
  2. Nemo enim ipsam voluptatem quia voluptas sit aspernatur aut odit aut fugit, sed quia consequuntur magni dolores eos qui ratione voluptatem sequi nesciunt.

    Neque porro quisquam est, qui dolorem ipsum quia dolor sit amet, consectetur, adipisci velit, sed quia non numquam eius modi tempora incidunt ut labore et dolore magnam aliquam quaerat voluptatem.

  3. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat.
Markdown-2.4/tests/pl/Tests_2004/Yuri-Links-in-Headers.html0000666000000000000000000000050411756571173021504 0ustar 00000000000000

A plain header

Let's first have a plain header

An underlined header

(That's also useful)

A header with a link

First with a hash

Another with a link

This time underlined

Markdown-2.4/tests/pl/Tests_2007/0000777000000000000000000000000012300213224014607 5ustar 00000000000000Markdown-2.4/tests/pl/Tests_2007/Amps and angle encoding.html0000666000000000000000000000101211756571173021760 0ustar 00000000000000

AT&T has an ampersand in their name.

AT&T is another way to write it.

This & that.

4 < 5.

6 > 5.

Here's a link with an ampersand in the URL.

Here's a link with an amersand in the link text: AT&T.

Here's an inline link.

Here's an inline link.

Markdown-2.4/tests/pl/Tests_2007/Auto links.html0000666000000000000000000000106411756571173017537 0ustar 00000000000000

Link: http://example.com/.

With an ampersand: http://example.com/?foo=1&bar=2

Blockquoted: http://example.com/

Auto-links should not occur here: <http://example.com/>

or here: <http://example.com/>
Markdown-2.4/tests/pl/Tests_2007/Backslash escapes.html0000666000000000000000000000344711756571173021034 0ustar 00000000000000

These should all get escaped:

Backslash: \

Backtick: `

Asterisk: *

Underscore: _

Left brace: {

Right brace: }

Left bracket: [

Right bracket: ]

Left paren: (

Right paren: )

Greater-than: >

Hash: #

Period: .

Bang: !

Plus: +

Minus: -

These should not, because they occur within a code block:

Backslash: \\

Backtick: \`

Asterisk: \*

Underscore: \_

Left brace: \{

Right brace: \}

Left bracket: \[

Right bracket: \]

Left paren: \(

Right paren: \)

Greater-than: \>

Hash: \#

Period: \.

Bang: \!

Plus: \+

Minus: \-

Nor should these, which occur in code spans:

Backslash: \\

Backtick: \`

Asterisk: \*

Underscore: \_

Left brace: \{

Right brace: \}

Left bracket: \[

Right bracket: \]

Left paren: \(

Right paren: \)

Greater-than: \>

Hash: \#

Period: \.

Bang: \!

Plus: \+

Minus: \-

These should get escaped, even though they're matching pairs for other Markdown constructs:

*asterisks*

_underscores_

`backticks`

This is a code span with a literal backslash-backtick sequence: \`

This is a tag with unescaped backticks bar.

This is a tag with backslashes bar.

Markdown-2.4/tests/pl/Tests_2007/Blockquotes with code blocks.html0000666000000000000000000000031111756571173023100 0ustar 00000000000000

Example:

sub status {
    print "working";
}

Or:

sub status {
    return "working";
}
Markdown-2.4/tests/pl/Tests_2007/Code Blocks.html0000666000000000000000000000051211756571173017573 0ustar 00000000000000
code block on the first line

Regular text.

code block indented by spaces

Regular text.

the lines in this block  
all contain trailing spaces  

Regular Text.

code block on the last line
Markdown-2.4/tests/pl/Tests_2007/Code Spans.html0000666000000000000000000000034311756571173017444 0ustar 00000000000000

<test a=" content of attribute ">

Fix for backticks within HTML tag: like this

Here's how you put `backticks` in a code span.

Markdown-2.4/tests/pl/Tests_2007/Hard-wrapped paragraphs with list-like lines.html0000666000000000000000000000033311756571173026060 0ustar 00000000000000

In Markdown 1.0.0 and earlier. Version 8. This line turns into a list item. Because a hard-wrapped line in the middle of a paragraph looked like a list item.

Here's one with a bullet. * criminey.

Markdown-2.4/tests/pl/Tests_2007/Horizontal rules.html0000666000000000000000000000077011756571173020775 0ustar 00000000000000

Dashes:





---




- - -

Asterisks:





***




* * *

Underscores:





___




_ _ _
Markdown-2.4/tests/pl/Tests_2007/Images.html0000666000000000000000000000134311756571173016733 0ustar 00000000000000

Alt text

Alt text

Inline within a paragraph: alt text.

alt text

alt text

alt text

alt text.

Empty

this is a stupid URL

alt text

alt text

Markdown-2.4/tests/pl/Tests_2007/Inline HTML (Advanced).html0000666000000000000000000000057011756571173021301 0ustar 00000000000000

Simple block on one line:

foo

And nested without indentation:

foo
bar

And with attributes:

This was broken in 1.0.2b7:

foo
Markdown-2.4/tests/pl/Tests_2007/Inline HTML (Simple).html0000666000000000000000000000153011756571173021022 0ustar 00000000000000

Here's a simple block:

foo

This should be a code block, though:

<div>
    foo
</div>

As should this:

<div>foo</div>

Now, nested:

foo

This should just be an HTML comment:

Multiline:

Code block:

<!-- Comment -->

Just plain comment, with trailing spaces on the line:

Code:

<hr />

Hr's:










Markdown-2.4/tests/pl/Tests_2007/Inline HTML comments.html0000666000000000000000000000031111756571173021271 0ustar 00000000000000

Paragraph one.

Paragraph two.

The end.

Markdown-2.4/tests/pl/Tests_2007/Links, inline style.html0000666000000000000000000000152311756571173021242 0ustar 00000000000000

Just a URL.

URL and title.

URL and title.

URL and title.

URL and title.

URL wrapped in angle brackets.

URL w/ angle brackets + title.

Empty.

With parens in the URL

(With outer parens and parens in url)

With parens in the URL

(With outer parens and parens in url)

Markdown-2.4/tests/pl/Tests_2007/Links, reference style.html0000666000000000000000000000223111756571173021717 0ustar 00000000000000

Foo bar.

Foo bar.

Foo bar.

With embedded [brackets].

Indented once.

Indented twice.

Indented thrice.

Indented [four][] times.

[four]: /url

this should work

So should this.

And this.

And this.

And this.

But not [that] [].

Nor [that][].

Nor [that].

[Something in brackets like this should work]

[Same with this.]

In this case, this points to something else.

Backslashing should suppress [this] and [this].


Here's one where the link breaks across lines.

Here's another where the link breaks across lines, but with a line-ending space.

Markdown-2.4/tests/pl/Tests_2007/Links, shortcut references.html0000666000000000000000000000041111756571173022613 0ustar 00000000000000

This is the simple case.

This one has a line break.

This one has a line break with a line-ending space.

this and the other

Markdown-2.4/tests/pl/Tests_2007/Literal quotes in titles.html0000666000000000000000000000024611756571173022300 0ustar 00000000000000

Foo bar.

Foo bar.

Markdown-2.4/tests/pl/Tests_2007/Markdown Documentation - Basics.html0000666000000000000000000002274211756571173023412 0ustar 00000000000000

Markdown: Basics

Getting the Gist of Markdown's Formatting Syntax

This page offers a brief overview of what it's like to use Markdown. The syntax page provides complete, detailed documentation for every feature, but Markdown should be very easy to pick up simply by looking at a few examples of it in action. The examples on this page are written in a before/after style, showing example syntax and the HTML output produced by Markdown.

It's also helpful to simply try Markdown out; the Dingus is a web application that allows you type your own Markdown-formatted text and translate it to XHTML.

Note: This document is itself written using Markdown; you can see the source for it by adding '.text' to the URL.

Paragraphs, Headers, Blockquotes

A paragraph is simply one or more consecutive lines of text, separated by one or more blank lines. (A blank line is any line that looks like a blank line -- a line containing nothing spaces or tabs is considered blank.) Normal paragraphs should not be intended with spaces or tabs.

Markdown offers two styles of headers: Setext and atx. Setext-style headers for <h1> and <h2> are created by "underlining" with equal signs (=) and hyphens (-), respectively. To create an atx-style header, you put 1-6 hash marks (#) at the beginning of the line -- the number of hashes equals the resulting HTML header level.

Blockquotes are indicated using email-style '>' angle brackets.

Markdown:

A First Level Header
====================

A Second Level Header
---------------------

Now is the time for all good men to come to
the aid of their country. This is just a
regular paragraph.

The quick brown fox jumped over the lazy
dog's back.

### Header 3

> This is a blockquote.
> 
> This is the second paragraph in the blockquote.
>
> ## This is an H2 in a blockquote

Output:

<h1>A First Level Header</h1>

<h2>A Second Level Header</h2>

<p>Now is the time for all good men to come to
the aid of their country. This is just a
regular paragraph.</p>

<p>The quick brown fox jumped over the lazy
dog's back.</p>

<h3>Header 3</h3>

<blockquote>
    <p>This is a blockquote.</p>

    <p>This is the second paragraph in the blockquote.</p>

    <h2>This is an H2 in a blockquote</h2>
</blockquote>

Phrase Emphasis

Markdown uses asterisks and underscores to indicate spans of emphasis.

Markdown:

Some of these words *are emphasized*.
Some of these words _are emphasized also_.

Use two asterisks for **strong emphasis**.
Or, if you prefer, __use two underscores instead__.

Output:

<p>Some of these words <em>are emphasized</em>.
Some of these words <em>are emphasized also</em>.</p>

<p>Use two asterisks for <strong>strong emphasis</strong>.
Or, if you prefer, <strong>use two underscores instead</strong>.</p>

Lists

Unordered (bulleted) lists use asterisks, pluses, and hyphens (*, +, and -) as list markers. These three markers are interchangable; this:

*   Candy.
*   Gum.
*   Booze.

this:

+   Candy.
+   Gum.
+   Booze.

and this:

-   Candy.
-   Gum.
-   Booze.

all produce the same output:

<ul>
<li>Candy.</li>
<li>Gum.</li>
<li>Booze.</li>
</ul>

Ordered (numbered) lists use regular numbers, followed by periods, as list markers:

1.  Red
2.  Green
3.  Blue

Output:

<ol>
<li>Red</li>
<li>Green</li>
<li>Blue</li>
</ol>

If you put blank lines between items, you'll get <p> tags for the list item text. You can create multi-paragraph list items by indenting the paragraphs by 4 spaces or 1 tab:

*   A list item.

    With multiple paragraphs.

*   Another item in the list.

Output:

<ul>
<li><p>A list item.</p>
<p>With multiple paragraphs.</p></li>
<li><p>Another item in the list.</p></li>
</ul>

Links

Markdown supports two styles for creating links: inline and reference. With both styles, you use square brackets to delimit the text you want to turn into a link.

Inline-style links use parentheses immediately after the link text. For example:

This is an [example link](http://example.com/).

Output:

<p>This is an <a href="http://example.com/">
example link</a>.</p>

Optionally, you may include a title attribute in the parentheses:

This is an [example link](http://example.com/ "With a Title").

Output:

<p>This is an <a href="http://example.com/" title="With a Title">
example link</a>.</p>

Reference-style links allow you to refer to your links by names, which you define elsewhere in your document:

I get 10 times more traffic from [Google][1] than from
[Yahoo][2] or [MSN][3].

[1]: http://google.com/        "Google"
[2]: http://search.yahoo.com/  "Yahoo Search"
[3]: http://search.msn.com/    "MSN Search"

Output:

<p>I get 10 times more traffic from <a href="http://google.com/"
title="Google">Google</a> than from <a href="http://search.yahoo.com/"
title="Yahoo Search">Yahoo</a> or <a href="http://search.msn.com/"
title="MSN Search">MSN</a>.</p>

The title attribute is optional. Link names may contain letters, numbers and spaces, but are not case sensitive:

I start my morning with a cup of coffee and
[The New York Times][NY Times].

[ny times]: http://www.nytimes.com/

Output:

<p>I start my morning with a cup of coffee and
<a href="http://www.nytimes.com/">The New York Times</a>.</p>

Images

Image syntax is very much like link syntax.

Inline (titles are optional):

![alt text](/path/to/img.jpg "Title")

Reference-style:

![alt text][id]

[id]: /path/to/img.jpg "Title"

Both of the above examples produce the same output:

<img src="/path/to/img.jpg" alt="alt text" title="Title" />

Code

In a regular paragraph, you can create code span by wrapping text in backtick quotes. Any ampersands (&) and angle brackets (< or >) will automatically be translated into HTML entities. This makes it easy to use Markdown to write about HTML example code:

I strongly recommend against using any `<blink>` tags.

I wish SmartyPants used named entities like `&mdash;`
instead of decimal-encoded entites like `&#8212;`.

Output:

<p>I strongly recommend against using any
<code>&lt;blink&gt;</code> tags.</p>

<p>I wish SmartyPants used named entities like
<code>&amp;mdash;</code> instead of decimal-encoded
entites like <code>&amp;#8212;</code>.</p>

To specify an entire block of pre-formatted code, indent every line of the block by 4 spaces or 1 tab. Just like with code spans, &, <, and > characters will be escaped automatically.

Markdown:

If you want your page to validate under XHTML 1.0 Strict,
you've got to put paragraph tags in your blockquotes:

    <blockquote>
        <p>For example.</p>
    </blockquote>

Output:

<p>If you want your page to validate under XHTML 1.0 Strict,
you've got to put paragraph tags in your blockquotes:</p>

<pre><code>&lt;blockquote&gt;
    &lt;p&gt;For example.&lt;/p&gt;
&lt;/blockquote&gt;
</code></pre>
Markdown-2.4/tests/pl/Tests_2007/Markdown Documentation - Syntax.html0000666000000000000000000007772711756571173023511 0ustar 00000000000000

Markdown: Syntax

Note: This document is itself written using Markdown; you can see the source for it by adding '.text' to the URL.


Overview

Philosophy

Markdown is intended to be as easy-to-read and easy-to-write as is feasible.

Readability, however, is emphasized above all else. A Markdown-formatted document should be publishable as-is, as plain text, without looking like it's been marked up with tags or formatting instructions. While Markdown's syntax has been influenced by several existing text-to-HTML filters -- including Setext, atx, Textile, reStructuredText, Grutatext, and EtText -- the single biggest source of inspiration for Markdown's syntax is the format of plain text email.

To this end, Markdown's syntax is comprised entirely of punctuation characters, which punctuation characters have been carefully chosen so as to look like what they mean. E.g., asterisks around a word actually look like *emphasis*. Markdown lists look like, well, lists. Even blockquotes look like quoted passages of text, assuming you've ever used email.

Inline HTML

Markdown's syntax is intended for one purpose: to be used as a format for writing for the web.

Markdown is not a replacement for HTML, or even close to it. Its syntax is very small, corresponding only to a very small subset of HTML tags. The idea is not to create a syntax that makes it easier to insert HTML tags. In my opinion, HTML tags are already easy to insert. The idea for Markdown is to make it easy to read, write, and edit prose. HTML is a publishing format; Markdown is a writing format. Thus, Markdown's formatting syntax only addresses issues that can be conveyed in plain text.

For any markup that is not covered by Markdown's syntax, you simply use HTML itself. There's no need to preface it or delimit it to indicate that you're switching from Markdown to HTML; you just use the tags.

The only restrictions are that block-level HTML elements -- e.g. <div>, <table>, <pre>, <p>, etc. -- must be separated from surrounding content by blank lines, and the start and end tags of the block should not be indented with tabs or spaces. Markdown is smart enough not to add extra (unwanted) <p> tags around HTML block-level tags.

For example, to add an HTML table to a Markdown article:

This is a regular paragraph.

<table>
    <tr>
        <td>Foo</td>
    </tr>
</table>

This is another regular paragraph.

Note that Markdown formatting syntax is not processed within block-level HTML tags. E.g., you can't use Markdown-style *emphasis* inside an HTML block.

Span-level HTML tags -- e.g. <span>, <cite>, or <del> -- can be used anywhere in a Markdown paragraph, list item, or header. If you want, you can even use HTML tags instead of Markdown formatting; e.g. if you'd prefer to use HTML <a> or <img> tags instead of Markdown's link or image syntax, go right ahead.

Unlike block-level HTML tags, Markdown syntax is processed within span-level tags.

Automatic Escaping for Special Characters

In HTML, there are two characters that demand special treatment: < and &. Left angle brackets are used to start tags; ampersands are used to denote HTML entities. If you want to use them as literal characters, you must escape them as entities, e.g. &lt;, and &amp;.

Ampersands in particular are bedeviling for web writers. If you want to write about 'AT&T', you need to write 'AT&amp;T'. You even need to escape ampersands within URLs. Thus, if you want to link to:

http://images.google.com/images?num=30&q=larry+bird

you need to encode the URL as:

http://images.google.com/images?num=30&amp;q=larry+bird

in your anchor tag href attribute. Needless to say, this is easy to forget, and is probably the single most common source of HTML validation errors in otherwise well-marked-up web sites.

Markdown allows you to use these characters naturally, taking care of all the necessary escaping for you. If you use an ampersand as part of an HTML entity, it remains unchanged; otherwise it will be translated into &amp;.

So, if you want to include a copyright symbol in your article, you can write:

&copy;

and Markdown will leave it alone. But if you write:

AT&T

Markdown will translate it to:

AT&amp;T

Similarly, because Markdown supports inline HTML, if you use angle brackets as delimiters for HTML tags, Markdown will treat them as such. But if you write:

4 < 5

Markdown will translate it to:

4 &lt; 5

However, inside Markdown code spans and blocks, angle brackets and ampersands are always encoded automatically. This makes it easy to use Markdown to write about HTML code. (As opposed to raw HTML, which is a terrible format for writing about HTML syntax, because every single < and & in your example code needs to be escaped.)


Block Elements

Paragraphs and Line Breaks

A paragraph is simply one or more consecutive lines of text, separated by one or more blank lines. (A blank line is any line that looks like a blank line -- a line containing nothing but spaces or tabs is considered blank.) Normal paragraphs should not be intended with spaces or tabs.

The implication of the "one or more consecutive lines of text" rule is that Markdown supports "hard-wrapped" text paragraphs. This differs significantly from most other text-to-HTML formatters (including Movable Type's "Convert Line Breaks" option) which translate every line break character in a paragraph into a <br /> tag.

When you do want to insert a <br /> break tag using Markdown, you end a line with two or more spaces, then type return.

Yes, this takes a tad more effort to create a <br />, but a simplistic "every line break is a <br />" rule wouldn't work for Markdown. Markdown's email-style blockquoting and multi-paragraph list items work best -- and look better -- when you format them with hard breaks.

Markdown supports two styles of headers, Setext and atx.

Setext-style headers are "underlined" using equal signs (for first-level headers) and dashes (for second-level headers). For example:

This is an H1
=============

This is an H2
-------------

Any number of underlining ='s or -'s will work.

Atx-style headers use 1-6 hash characters at the start of the line, corresponding to header levels 1-6. For example:

# This is an H1

## This is an H2

###### This is an H6

Optionally, you may "close" atx-style headers. This is purely cosmetic -- you can use this if you think it looks better. The closing hashes don't even need to match the number of hashes used to open the header. (The number of opening hashes determines the header level.) :

# This is an H1 #

## This is an H2 ##

### This is an H3 ######

Blockquotes

Markdown uses email-style > characters for blockquoting. If you're familiar with quoting passages of text in an email message, then you know how to create a blockquote in Markdown. It looks best if you hard wrap the text and put a > before every line:

> This is a blockquote with two paragraphs. Lorem ipsum dolor sit amet,
> consectetuer adipiscing elit. Aliquam hendrerit mi posuere lectus.
> Vestibulum enim wisi, viverra nec, fringilla in, laoreet vitae, risus.
> 
> Donec sit amet nisl. Aliquam semper ipsum sit amet velit. Suspendisse
> id sem consectetuer libero luctus adipiscing.

Markdown allows you to be lazy and only put the > before the first line of a hard-wrapped paragraph:

> This is a blockquote with two paragraphs. Lorem ipsum dolor sit amet,
consectetuer adipiscing elit. Aliquam hendrerit mi posuere lectus.
Vestibulum enim wisi, viverra nec, fringilla in, laoreet vitae, risus.

> Donec sit amet nisl. Aliquam semper ipsum sit amet velit. Suspendisse
id sem consectetuer libero luctus adipiscing.

Blockquotes can be nested (i.e. a blockquote-in-a-blockquote) by adding additional levels of >:

> This is the first level of quoting.
>
> > This is nested blockquote.
>
> Back to the first level.

Blockquotes can contain other Markdown elements, including headers, lists, and code blocks:

> ## This is a header.
> 
> 1.   This is the first list item.
> 2.   This is the second list item.
> 
> Here's some example code:
> 
>     return shell_exec("echo $input | $markdown_script");

Any decent text editor should make email-style quoting easy. For example, with BBEdit, you can make a selection and choose Increase Quote Level from the Text menu.

Lists

Markdown supports ordered (numbered) and unordered (bulleted) lists.

Unordered lists use asterisks, pluses, and hyphens -- interchangably -- as list markers:

*   Red
*   Green
*   Blue

is equivalent to:

+   Red
+   Green
+   Blue

and:

-   Red
-   Green
-   Blue

Ordered lists use numbers followed by periods:

1.  Bird
2.  McHale
3.  Parish

It's important to note that the actual numbers you use to mark the list have no effect on the HTML output Markdown produces. The HTML Markdown produces from the above list is:

<ol>
<li>Bird</li>
<li>McHale</li>
<li>Parish</li>
</ol>

If you instead wrote the list in Markdown like this:

1.  Bird
1.  McHale
1.  Parish

or even:

3. Bird
1. McHale
8. Parish

you'd get the exact same HTML output. The point is, if you want to, you can use ordinal numbers in your ordered Markdown lists, so that the numbers in your source match the numbers in your published HTML. But if you want to be lazy, you don't have to.

If you do use lazy list numbering, however, you should still start the list with the number 1. At some point in the future, Markdown may support starting ordered lists at an arbitrary number.

List markers typically start at the left margin, but may be indented by up to three spaces. List markers must be followed by one or more spaces or a tab.

To make lists look nice, you can wrap items with hanging indents:

*   Lorem ipsum dolor sit amet, consectetuer adipiscing elit.
    Aliquam hendrerit mi posuere lectus. Vestibulum enim wisi,
    viverra nec, fringilla in, laoreet vitae, risus.
*   Donec sit amet nisl. Aliquam semper ipsum sit amet velit.
    Suspendisse id sem consectetuer libero luctus adipiscing.

But if you want to be lazy, you don't have to:

*   Lorem ipsum dolor sit amet, consectetuer adipiscing elit.
Aliquam hendrerit mi posuere lectus. Vestibulum enim wisi,
viverra nec, fringilla in, laoreet vitae, risus.
*   Donec sit amet nisl. Aliquam semper ipsum sit amet velit.
Suspendisse id sem consectetuer libero luctus adipiscing.

If list items are separated by blank lines, Markdown will wrap the items in <p> tags in the HTML output. For example, this input:

*   Bird
*   Magic

will turn into:

<ul>
<li>Bird</li>
<li>Magic</li>
</ul>

But this:

*   Bird

*   Magic

will turn into:

<ul>
<li><p>Bird</p></li>
<li><p>Magic</p></li>
</ul>

List items may consist of multiple paragraphs. Each subsequent paragraph in a list item must be intended by either 4 spaces or one tab:

1.  This is a list item with two paragraphs. Lorem ipsum dolor
    sit amet, consectetuer adipiscing elit. Aliquam hendrerit
    mi posuere lectus.

    Vestibulum enim wisi, viverra nec, fringilla in, laoreet
    vitae, risus. Donec sit amet nisl. Aliquam semper ipsum
    sit amet velit.

2.  Suspendisse id sem consectetuer libero luctus adipiscing.

It looks nice if you indent every line of the subsequent paragraphs, but here again, Markdown will allow you to be lazy:

*   This is a list item with two paragraphs.

    This is the second paragraph in the list item. You're
only required to indent the first line. Lorem ipsum dolor
sit amet, consectetuer adipiscing elit.

*   Another item in the same list.

To put a blockquote within a list item, the blockquote's > delimiters need to be indented:

*   A list item with a blockquote:

    > This is a blockquote
    > inside a list item.

To put a code block within a list item, the code block needs to be indented twice -- 8 spaces or two tabs:

*   A list item with a code block:

        <code goes here>

It's worth noting that it's possible to trigger an ordered list by accident, by writing something like this:

1986. What a great season.

In other words, a number-period-space sequence at the beginning of a line. To avoid this, you can backslash-escape the period:

1986\. What a great season.

Code Blocks

Pre-formatted code blocks are used for writing about programming or markup source code. Rather than forming normal paragraphs, the lines of a code block are interpreted literally. Markdown wraps a code block in both <pre> and <code> tags.

To produce a code block in Markdown, simply indent every line of the block by at least 4 spaces or 1 tab. For example, given this input:

This is a normal paragraph:

    This is a code block.

Markdown will generate:

<p>This is a normal paragraph:</p>

<pre><code>This is a code block.
</code></pre>

One level of indentation -- 4 spaces or 1 tab -- is removed from each line of the code block. For example, this:

Here is an example of AppleScript:

    tell application "Foo"
        beep
    end tell

will turn into:

<p>Here is an example of AppleScript:</p>

<pre><code>tell application "Foo"
    beep
end tell
</code></pre>

A code block continues until it reaches a line that is not indented (or the end of the article).

Within a code block, ampersands (&) and angle brackets (< and >) are automatically converted into HTML entities. This makes it very easy to include example HTML source code using Markdown -- just paste it and indent it, and Markdown will handle the hassle of encoding the ampersands and angle brackets. For example, this:

    <div class="footer">
        &copy; 2004 Foo Corporation
    </div>

will turn into:

<pre><code>&lt;div class="footer"&gt;
    &amp;copy; 2004 Foo Corporation
&lt;/div&gt;
</code></pre>

Regular Markdown syntax is not processed within code blocks. E.g., asterisks are just literal asterisks within a code block. This means it's also easy to use Markdown to write about Markdown's own syntax.

Horizontal Rules

You can produce a horizontal rule tag (<hr />) by placing three or more hyphens, asterisks, or underscores on a line by themselves. If you wish, you may use spaces between the hyphens or asterisks. Each of the following lines will produce a horizontal rule:

* * *

***

*****

- - -

---------------------------------------

_ _ _

Span Elements

Markdown supports two style of links: inline and reference.

In both styles, the link text is delimited by [square brackets].

To create an inline link, use a set of regular parentheses immediately after the link text's closing square bracket. Inside the parentheses, put the URL where you want the link to point, along with an optional title for the link, surrounded in quotes. For example:

This is [an example](http://example.com/ "Title") inline link.

[This link](http://example.net/) has no title attribute.

Will produce:

<p>This is <a href="http://example.com/" title="Title">
an example</a> inline link.</p>

<p><a href="http://example.net/">This link</a> has no
title attribute.</p>

If you're referring to a local resource on the same server, you can use relative paths:

See my [About](/about/) page for details.

Reference-style links use a second set of square brackets, inside which you place a label of your choosing to identify the link:

This is [an example][id] reference-style link.

You can optionally use a space to separate the sets of brackets:

This is [an example] [id] reference-style link.

Then, anywhere in the document, you define your link label like this, on a line by itself:

[id]: http://example.com/  "Optional Title Here"

That is:

  • Square brackets containing the link identifier (optionally indented from the left margin using up to three spaces);
  • followed by a colon;
  • followed by one or more spaces (or tabs);
  • followed by the URL for the link;
  • optionally followed by a title attribute for the link, enclosed in double or single quotes.

The link URL may, optionally, be surrounded by angle brackets:

[id]: <http://example.com/>  "Optional Title Here"

You can put the title attribute on the next line and use extra spaces or tabs for padding, which tends to look better with longer URLs:

[id]: http://example.com/longish/path/to/resource/here
    "Optional Title Here"

Link definitions are only used for creating links during Markdown processing, and are stripped from your document in the HTML output.

Link definition names may constist of letters, numbers, spaces, and punctuation -- but they are not case sensitive. E.g. these two links:

[link text][a]
[link text][A]

are equivalent.

The implicit link name shortcut allows you to omit the name of the link, in which case the link text itself is used as the name. Just use an empty set of square brackets -- e.g., to link the word "Google" to the google.com web site, you could simply write:

[Google][]

And then define the link:

[Google]: http://google.com/

Because link names may contain spaces, this shortcut even works for multiple words in the link text:

Visit [Daring Fireball][] for more information.

And then define the link:

[Daring Fireball]: http://daringfireball.net/

Link definitions can be placed anywhere in your Markdown document. I tend to put them immediately after each paragraph in which they're used, but if you want, you can put them all at the end of your document, sort of like footnotes.

Here's an example of reference links in action:

I get 10 times more traffic from [Google] [1] than from
[Yahoo] [2] or [MSN] [3].

  [1]: http://google.com/        "Google"
  [2]: http://search.yahoo.com/  "Yahoo Search"
  [3]: http://search.msn.com/    "MSN Search"

Using the implicit link name shortcut, you could instead write:

I get 10 times more traffic from [Google][] than from
[Yahoo][] or [MSN][].

  [google]: http://google.com/        "Google"
  [yahoo]:  http://search.yahoo.com/  "Yahoo Search"
  [msn]:    http://search.msn.com/    "MSN Search"

Both of the above examples will produce the following HTML output:

<p>I get 10 times more traffic from <a href="http://google.com/"
title="Google">Google</a> than from
<a href="http://search.yahoo.com/" title="Yahoo Search">Yahoo</a>
or <a href="http://search.msn.com/" title="MSN Search">MSN</a>.</p>

For comparison, here is the same paragraph written using Markdown's inline link style:

I get 10 times more traffic from [Google](http://google.com/ "Google")
than from [Yahoo](http://search.yahoo.com/ "Yahoo Search") or
[MSN](http://search.msn.com/ "MSN Search").

The point of reference-style links is not that they're easier to write. The point is that with reference-style links, your document source is vastly more readable. Compare the above examples: using reference-style links, the paragraph itself is only 81 characters long; with inline-style links, it's 176 characters; and as raw HTML, it's 234 characters. In the raw HTML, there's more markup than there is text.

With Markdown's reference-style links, a source document much more closely resembles the final output, as rendered in a browser. By allowing you to move the markup-related metadata out of the paragraph, you can add links without interrupting the narrative flow of your prose.

Emphasis

Markdown treats asterisks (*) and underscores (_) as indicators of emphasis. Text wrapped with one * or _ will be wrapped with an HTML <em> tag; double *'s or _'s will be wrapped with an HTML <strong> tag. E.g., this input:

*single asterisks*

_single underscores_

**double asterisks**

__double underscores__

will produce:

<em>single asterisks</em>

<em>single underscores</em>

<strong>double asterisks</strong>

<strong>double underscores</strong>

You can use whichever style you prefer; the lone restriction is that the same character must be used to open and close an emphasis span.

Emphasis can be used in the middle of a word:

un*fucking*believable

But if you surround an * or _ with spaces, it'll be treated as a literal asterisk or underscore.

To produce a literal asterisk or underscore at a position where it would otherwise be used as an emphasis delimiter, you can backslash escape it:

\*this text is surrounded by literal asterisks\*

Code

To indicate a span of code, wrap it with backtick quotes (`). Unlike a pre-formatted code block, a code span indicates code within a normal paragraph. For example:

Use the `printf()` function.

will produce:

<p>Use the <code>printf()</code> function.</p>

To include a literal backtick character within a code span, you can use multiple backticks as the opening and closing delimiters:

``There is a literal backtick (`) here.``

which will produce this:

<p><code>There is a literal backtick (`) here.</code></p>

The backtick delimiters surrounding a code span may include spaces -- one after the opening, one before the closing. This allows you to place literal backtick characters at the beginning or end of a code span:

A single backtick in a code span: `` ` ``

A backtick-delimited string in a code span: `` `foo` ``

will produce:

<p>A single backtick in a code span: <code>`</code></p>

<p>A backtick-delimited string in a code span: <code>`foo`</code></p>

With a code span, ampersands and angle brackets are encoded as HTML entities automatically, which makes it easy to include example HTML tags. Markdown will turn this:

Please don't use any `<blink>` tags.

into:

<p>Please don't use any <code>&lt;blink&gt;</code> tags.</p>

You can write this:

`&#8212;` is the decimal-encoded equivalent of `&mdash;`.

to produce:

<p><code>&amp;#8212;</code> is the decimal-encoded
equivalent of <code>&amp;mdash;</code>.</p>

Images

Admittedly, it's fairly difficult to devise a "natural" syntax for placing images into a plain text document format.

Markdown uses an image syntax that is intended to resemble the syntax for links, allowing for two styles: inline and reference.

Inline image syntax looks like this:

![Alt text](/path/to/img.jpg)

![Alt text](/path/to/img.jpg "Optional title")

That is:

  • An exclamation mark: !;
  • followed by a set of square brackets, containing the alt attribute text for the image;
  • followed by a set of parentheses, containing the URL or path to the image, and an optional title attribute enclosed in double or single quotes.

Reference-style image syntax looks like this:

![Alt text][id]

Where "id" is the name of a defined image reference. Image references are defined using syntax identical to link references:

[id]: url/to/image  "Optional title attribute"

As of this writing, Markdown has no syntax for specifying the dimensions of an image; if this is important to you, you can simply use regular HTML <img> tags.


Miscellaneous

Markdown supports a shortcut style for creating "automatic" links for URLs and email addresses: simply surround the URL or email address with angle brackets. What this means is that if you want to show the actual text of a URL or email address, and also have it be a clickable link, you can do this:

<http://example.com/>

Markdown will turn this into:

<a href="http://example.com/">http://example.com/</a>

Automatic links for email addresses work similarly, except that Markdown will also perform a bit of randomized decimal and hex entity-encoding to help obscure your address from address-harvesting spambots. For example, Markdown will turn this:

<address@example.com>

into something like this:

<a href="&#x6D;&#x61;i&#x6C;&#x74;&#x6F;:&#x61;&#x64;&#x64;&#x72;&#x65;
&#115;&#115;&#64;&#101;&#120;&#x61;&#109;&#x70;&#x6C;e&#x2E;&#99;&#111;
&#109;">&#x61;&#x64;&#x64;&#x72;&#x65;&#115;&#115;&#64;&#101;&#120;&#x61;
&#109;&#x70;&#x6C;e&#x2E;&#99;&#111;&#109;</a>

which will render in a browser as a clickable link to "address@example.com".

(This sort of entity-encoding trick will indeed fool many, if not most, address-harvesting bots, but it definitely won't fool all of them. It's better than nothing, but an address published in this way will probably eventually start receiving spam.)

Backslash Escapes

Markdown allows you to use backslash escapes to generate literal characters which would otherwise have special meaning in Markdown's formatting syntax. For example, if you wanted to surround a word with literal asterisks (instead of an HTML <em> tag), you can backslashes before the asterisks, like this:

\*literal asterisks\*

Markdown provides backslash escapes for the following characters:

\   backslash
`   backtick
*   asterisk
_   underscore
{}  curly braces
[]  square brackets
()  parentheses
#   hash mark
+   plus sign
-   minus sign (hyphen)
.   dot
!   exclamation mark
Markdown-2.4/tests/pl/Tests_2007/Nested blockquotes.html0000666000000000000000000000016211756571173021262 0ustar 00000000000000

foo

bar

foo

Markdown-2.4/tests/pl/Tests_2007/Ordered and unordered lists.html0000666000000000000000000000347111756571173022730 0ustar 00000000000000

Unordered

Asterisks tight:

  • asterisk 1
  • asterisk 2
  • asterisk 3

Asterisks loose:

  • asterisk 1

  • asterisk 2

  • asterisk 3


Pluses tight:

  • Plus 1
  • Plus 2
  • Plus 3

Pluses loose:

  • Plus 1

  • Plus 2

  • Plus 3


Minuses tight:

  • Minus 1
  • Minus 2
  • Minus 3

Minuses loose:

  • Minus 1

  • Minus 2

  • Minus 3

Ordered

Tight:

  1. First
  2. Second
  3. Third

and:

  1. One
  2. Two
  3. Three

Loose using tabs:

  1. First

  2. Second

  3. Third

and using spaces:

  1. One

  2. Two

  3. Three

Multiple paragraphs:

  1. Item 1, graf one.

    Item 2. graf two. The quick brown fox jumped over the lazy dog's back.

  2. Item 2.

  3. Item 3.

Nested

  • Tab
    • Tab
      • Tab

Here's another:

  1. First
  2. Second:
    • Fee
    • Fie
    • Foe
  3. Third

Same thing but with paragraphs:

  1. First

  2. Second:

    • Fee
    • Fie
    • Foe
  3. Third

This was an error in Markdown 1.0.1:

  • this

    • sub

    that

Markdown-2.4/tests/pl/Tests_2007/Strong and em together.html0000666000000000000000000000033611756571173021712 0ustar 00000000000000

This is strong and em.

So is this word.

This is strong and em.

So is this word.

Markdown-2.4/tests/pl/Tests_2007/Tabs.html0000666000000000000000000000072011756571173016415 0ustar 00000000000000
  • this is a list item indented with tabs

  • this is a list item indented with spaces

Code:

this code block is indented by one tab

And:

    this code block is indented by two tabs

And:

+   this is an example list item
    indented with tabs

+   this is an example list item
    indented with spaces
Markdown-2.4/tests/pl/Tests_2007/test.cfg0000666000000000000000000000072711756571173016305 0ustar 00000000000000[DEFAULT] input_ext=.text normalize=1 # comment out next line to run these tests #skip=1 [Images] # the attributes don't get ordered the same so we skip this skip=1 [Code Blocks] # some weird whitespace issue skip=1 [Links, reference style] # weird issue with nested brackets TODO: fixme skip=1 [Backslash escapes] # backticks in raw html attributes TODO: fixme skip=1 [Code Spans] # more backticks in raw html attributes TODO: fixme skip=1 Markdown-2.4/tests/pl/Tests_2007/Tidyness.html0000666000000000000000000000021511756571173017325 0ustar 00000000000000

A list within a blockquote:

  • asterisk 1
  • asterisk 2
  • asterisk 3
Markdown-2.4/tests/plugins.py0000666000000000000000000000744512111563027014500 0ustar 00000000000000import traceback from .util import MarkdownSyntaxError from nose.plugins import Plugin from nose.plugins.errorclass import ErrorClass, ErrorClassPlugin class Markdown(ErrorClassPlugin): """ Add MarkdownSyntaxError and ensure proper formatting. """ mdsyntax = ErrorClass(MarkdownSyntaxError, label='MarkdownSyntaxError', isfailure=True) enabled = True def configure(self, options, conf): self.conf = conf def addError(self, test, err): """ Ensure other plugins see the error by returning nothing here. """ pass def formatError(self, test, err): """ Remove unnessecary and unhelpful traceback from error report. """ et, ev, tb = err if et.__name__ == 'MarkdownSyntaxError': return et, ev, '' return err def escape(html): """ Escape HTML for display as source within HTML. """ html = html.replace('&', '&') html = html.replace('<', '<') html = html.replace('>', '>') return html class HtmlOutput(Plugin): """Output test results as ugly, unstyled html. """ name = 'html-output' score = 2 # run late enabled = True def __init__(self): super(HtmlOutput, self).__init__() self.html = [ '', 'Test output', '' ] def configure(self, options, conf): self.conf = conf def addSuccess(self, test): self.html.append('ok') def addError(self, test, err): err = self.formatErr(err) self.html.append('ERROR') self.html.append('
%s
' % escape(err)) def addFailure(self, test, err): err = self.formatErr(err) self.html.append('FAIL') self.html.append('
%s
' % escape(err)) def finalize(self, result): self.html.append('
') self.html.append("Ran %d test%s" % (result.testsRun, result.testsRun != 1 and "s" or "")) self.html.append('
') self.html.append('
') if not result.wasSuccessful(): self.html.extend(['FAILED (', 'failures=%d ' % len(result.failures), 'errors=%d' % len(result.errors)]) for cls in list(result.errorClasses.keys()): storage, label, isfail = result.errorClasses[cls] if len(storage): self.html.append(' %ss=%d' % (label, len(storage))) self.html.append(')') else: self.html.append('OK') self.html.append('
') f = open('test-output.html', 'w') for l in self.html: f.write(l) f.close() def formatErr(self, err): exctype, value, tb = err return ''.join(traceback.format_exception(exctype, value, tb)) def startContext(self, ctx): try: n = ctx.__name__ except AttributeError: n = str(ctx).replace('<', '').replace('>', '') self.html.extend(['
', '', n, '']) try: path = ctx.__file__.replace('.pyc', '.py') self.html.extend(['
', path, '
']) except AttributeError: pass def stopContext(self, ctx): self.html.append('
') def startTest(self, test): self.html.extend([ '
', test.shortDescription() or str(test), '' ]) def stopTest(self, test): self.html.append('
') Markdown-2.4/tests/safe_mode/0000777000000000000000000000000012300213225014345 5ustar 00000000000000Markdown-2.4/tests/safe_mode/html_then_blockquote.html0000666000000000000000000000036712111563027021463 0ustar 00000000000000

to:

<td /><td style="text-align: center; white-space: nowrap;"><br />

3) You don't need to alter all localization files. Adding the new labels to the en_US files will do it.

Markdown-2.4/tests/safe_mode/html_then_blockquote.txt0000666000000000000000000000027512111563027021334 0ustar 00000000000000to:
> 3) You don't need to alter all localization files. > Adding the new labels to the en_US files will do it. Markdown-2.4/tests/safe_mode/inline-html-advanced.html0000666000000000000000000000034411756571173021246 0ustar 00000000000000

Simple block on one line:

<div>foo</div>

And nested without indentation:

<div> <div> <div> foo </div> </div> <div>bar</div> </div>

Markdown-2.4/tests/safe_mode/inline-html-advanced.txt0000666000000000000000000000022411756571174021117 0ustar 00000000000000Simple block on one line:
foo
And nested without indentation:
foo
bar
Markdown-2.4/tests/safe_mode/inline-html-comments.html0000666000000000000000000000034411756571174021327 0ustar 00000000000000

Paragraph one.

<!-- This is a simple comment -->

<!-- This is another comment. -->

Paragraph two.

<!-- one comment block -- -- with two comments -->

The end.

Markdown-2.4/tests/safe_mode/inline-html-comments.txt0000666000000000000000000000026111756571174021200 0ustar 00000000000000Paragraph one. Paragraph two. The end. Markdown-2.4/tests/safe_mode/inline-html-simple.html0000666000000000000000000000207412111563027020755 0ustar 00000000000000

Here's a simple block:

<div> foo </div>

This should be a code block, though:

<div>
    foo
</div>

As should this:

<div>foo</div>

Now, nested:

<div> <div> <div> foo </div> </div> </div>

This should just be an HTML comment:

<!-- Comment -->

Multiline:

<!-- Blah Blah -->

Code block:

<!-- Comment -->

Just plain comment, with trailing spaces on the line:

<!-- foo -->

Code:

<hr />

Hr's:

<hr>

<hr/>

<hr />

<hr>

<hr/>

<hr />

<hr class="foo" id="bar" />

<hr class="foo" id="bar"/>

<hr class="foo" id="bar" >

<some weird stuff>

Markdown-2.4/tests/safe_mode/inline-html-simple.txt0000666000000000000000000000123012111563027020621 0ustar 00000000000000Here's a simple block:
foo
This should be a code block, though:
foo
As should this:
foo
Now, nested:
foo
This should just be an HTML comment: Multiline: Code block: Just plain comment, with trailing spaces on the line: Code:
Hr's:








Markdown-2.4/tests/safe_mode/link-targets.html0000666000000000000000000000013212111563047017645 0ustar 00000000000000

XSS See http://security.stackexchange.com/q/30330/1261 for details.

Markdown-2.4/tests/safe_mode/link-targets.txt0000666000000000000000000000015512111563047017525 0ustar 00000000000000[XSS](javascript://%0Aalert%28'XSS'%29;) See http://security.stackexchange.com/q/30330/1261 for details. Markdown-2.4/tests/safe_mode/remove.html0000666000000000000000000000117212111563027016541 0ustar 00000000000000

Here's a simple block:

This should be a code block, though:

<div>
    foo
</div>

As should this:

<div>foo</div>

Now, nested:

This should just be an HTML comment:

Multiline:

Code block:

<!-- Comment -->

Just plain comment, with trailing spaces on the line:

Code:

<hr />

Hr's:

Markdown-2.4/tests/safe_mode/remove.txt0000666000000000000000000000123012111563027016407 0ustar 00000000000000Here's a simple block:
foo
This should be a code block, though:
foo
As should this:
foo
Now, nested:
foo
This should just be an HTML comment: Multiline: Code block: Just plain comment, with trailing spaces on the line: Code:
Hr's:








Markdown-2.4/tests/safe_mode/replace.html0000666000000000000000000000151412111563027016657 0ustar 00000000000000

Here's a simple block:

[HTML_REMOVED]

This should be a code block, though:

<div>
    foo
</div>

As should this:

<div>foo</div>

Now, nested:

[HTML_REMOVED]

This should just be an HTML comment:

[HTML_REMOVED]

Multiline:

[HTML_REMOVED]

Code block:

<!-- Comment -->

Just plain comment, with trailing spaces on the line:

[HTML_REMOVED]

Code:

<hr />

Hr's:

[HTML_REMOVED]

[HTML_REMOVED]

[HTML_REMOVED]

[HTML_REMOVED]

[HTML_REMOVED]

[HTML_REMOVED]

[HTML_REMOVED]

[HTML_REMOVED]

[HTML_REMOVED]

[HTML_REMOVED]

Markdown-2.4/tests/safe_mode/replace.txt0000666000000000000000000000123012111563027016525 0ustar 00000000000000Here's a simple block:
foo
This should be a code block, though:
foo
As should this:
foo
Now, nested:
foo
This should just be an HTML comment: Multiline: Code block: Just plain comment, with trailing spaces on the line: Code:
Hr's:








Markdown-2.4/tests/safe_mode/script_tags.html0000666000000000000000000000105412111563027017565 0ustar 00000000000000

This should be stripped/escaped in safe_mode.

<script> alert("Hello world!") </script>

With blank lines.

<script>

alert("Hello world!")

</script>

Now with some weirdness

<script <!-- alert("Hello world!") </script <> `

Try another way.

<script <!-- alert("Hello world!") </script <>

This time with blank lines.

<script <!--

alert("Hello world!")

</script <>

Markdown-2.4/tests/safe_mode/script_tags.txt0000666000000000000000000000063011756571174017457 0ustar 00000000000000This should be stripped/escaped in safe_mode. With blank lines. Now with some weirdness `` This time with blank lines.