Commits

Ronan Amicel  committed 7c48c22

Import of regex 0.1.20110106

  • Participants

Comments (0)

Files changed (29)

+Metadata-Version: 1.0
+Name: regex
+Version: 0.1.20110106
+Summary: Alternate regular expression module, to replace re.
+Home-page: http://bugs.python.org/issue2636
+Author: Matthew Barnett
+Author-email: regex@mrabarnett.plus.com
+License: Python Software Foundation License
+Description: Notes
+        -----
+        
+        For testing and comparison with the current 're' module the new implementation is in the form of a module called 'regex'.
+        
+        Please note that certain aspects of this module have changed from those of previous versions to make it conform better to the 're' module.
+        
+        Please also note that ``matchobject.captures`` and the related methods now return a **list** (or a tuple of lists for the multi-group versions) instead of a tuple as previously.
+        
+        
+        Flags
+        -----
+        
+        There are 2 kinds of flag: scoped and global. Scoped flags can apply to only part of a pattern and can be turned on or off; global flags apply to the entire pattern and can only be turned on.
+        
+        The scoped flags are: ``IGNORECASE``, ``MULTILINE``, ``DOTALL``, ``VERBOSE``, ``WORD``.
+        
+        The global flags are: ``ASCII``, ``LOCALE``, ``NEW``, ``REVERSE``, ``UNICODE``.
+        
+        
+        The ``NEW`` flag turns on the new behaviour of this module, which can differ from that of the 're' module, such as splitting on zero-width matches, inline flags affecting only what follows, and being able to turn inline flags off.
+        
+        Note: The ``ZEROWIDTH`` flag which was in previous versions of this module has been removed. The ``NEW`` flag should be used instead.
+        
+        
+        Notes on named capture groups
+        -----------------------------
+        
+        All capture groups have a group number, starting from 1.
+        
+        Groups with the same group name will have the same group number, and groups with a different group name will have a different group number.
+        
+        The same group name can be used on different branches of an alternation because they are mutually exclusive, eg. ``(?P<foo>first)|(?P<foo>second)``. They will, of course, have the same group number.
+        
+        Group numbers will be reused, where possible, across different branches of a branch reset, eg. ``(?|(first)|(second))`` has only group 1. If capture groups have different group names then they will, of course, have different group numbers, eg. ``(?|(?P<foo>first)|(?P<bar>second))`` has group 1 ("foo") and group 2 ("bar").
+        
+        
+        Multithreading
+        --------------
+        
+        The regex module releases the GIL during matching on instances of the built-in (immutable) string classes, enabling other Python threads to run concurrently. It is also possible to force the regex module to release the GIL during matching by calling the matching methods with the keyword argument ``concurrent=True``. The behaviour is undefined if the string changes during matching, so use it *only* when it is guaranteed that that won't happen.
+        
+        
+        Building for 64-bits
+        --------------------
+        
+        If the source files are built for a 64-bit target then the string positions will also be 64-bit. (The 're' module appears to limit string positions to 32 bits, even on a 64-bit build.)
+        
+        
+        Unicode
+        -------
+        
+        This module supports Unicode 6.0.0.
+        
+        
+        
+        Additional features
+        -------------------
+        
+        * regex.escape (issue #2650)
+        
+            regex.escape has an additional keyword parameter ``special_only``. When True, only 'special' regex characters, such as '?', are escaped.
+        
+            Examples:
+        
+                >>> regex.escape("foo!?")
+                'foo\\!\\?'
+                >>> regex.escape("foo!?", special_only=True)
+                'foo!\\?'
+        
+        * Repeated captures (issue #7132)
+        
+            A match object has additional methods which return information on all the successful matches of a repeated capture group. These methods are:
+        
+            ``matchobject.captures([group1, ...])``
+        
+                Returns a list of the strings matched in a group or groups. Compare with ``matchobject.group([group1, ...])``.
+        
+            ``matchobject.starts([group])``
+        
+                Returns a list of the start positions. Compare with ``matchobject.start([group])``.
+        
+            ``matchobject.ends([group])``
+        
+                Returns a list of the end positions. Compare with ``matchobject.end([group])``.
+        
+            ``matchobject.spans([group])``
+        
+                Returns a list of the spans. Compare with ``matchobject.span([group])``.
+        
+            Examples:
+        
+                >>> m = regex.search(r"(\w{3})+", "123456789")
+                >>> m.group(1)
+                '789'
+                >>> m.captures(1)
+                ['123', '456', '789']
+                >>> m.start(1)
+                6
+                >>> m.starts(1)
+                [0, 3, 6]
+                >>> m.end(1)
+                9
+                >>> m.ends(1)
+                [3, 6, 9]
+                >>> m.span(1)
+                (6, 9)
+                >>> m.spans(1)
+                [(0, 3), (3, 6), (6, 9)]
+        
+        * Atomic grouping (issue #433030)
+        
+            ``(?>...)``
+        
+            If the following pattern subsequently fails, then the subpattern as a whole will fail.
+        
+        * Possessive quantifiers.
+        
+            ``(?:...)?+`` ; ``(?:...)*+`` ; ``(?:...)++`` ; ``(?:...){min,max}+``
+        
+            The subpattern is matched up to 'max' times. If the following pattern subsequently fails, then all of the repeated subpatterns will fail as a whole. For example, ``(?:...)++`` is equivalent to ``(?>(?:...)+)``.
+        
+        * Scoped flags (issue #433028)
+        
+            ``(?flags-flags:...)``
+        
+            The flags will apply only to the subpattern. Flags can be turned on or off.
+        
+        * Inline flags (issue #433024, issue #433027)
+        
+            ``(?flags-flags)``
+        
+            If the ``NEW`` flag is turned on then the flags will apply to the end of the group or pattern and can be turned on or off. If the ``NEW`` flag isn't turned on then the flags will be global and can't be turned off.
+        
+        * Repeated repeats (issue #2537)
+        
+            A regex like ``((x|y+)*)*`` will be accepted and will work correctly, but should complete more quickly.
+        
+        * Definition of 'word' character (issue #1693050)
+        
+            The definition of a 'word' character has been expanded for Unicode. This applies to ``\w``, ``\W``, ``\b`` and ``\B``.
+        
+        * Groups in lookahead and lookbehind (issue #814253)
+        
+            Groups and group references are permitted in both lookahead and lookbehind.
+        
+        * Variable-length lookbehind
+        
+            A lookbehind can match a variable-length string.
+        
+        * Correct handling of charset with ignore case flag (issue #3511)
+        
+            Ranges within charsets are handled correctly when the ignore-case flag is turned on.
+        
+        * Unmatched group in replacement (issue #1519638)
+        
+            An unmatched group is treated as an empty string in a replacement template.
+        
+        * 'Pathological' patterns (issue #1566086, issue #1662581, issue #1448325, issue #1721518, issue #1297193)
+        
+            'Pathological' patterns should complete more quickly.
+        
+        * Flags argument for regex.split, regex.sub and regex.subn (issue #3482)
+        
+            ``regex.split``, ``regex.sub`` and ``regex.subn`` support a 'flags' argument.
+        
+        * Pos and endpos arguments for regex.sub and regex.subn
+        
+            ``regex.sub`` and ``regex.subn`` support 'pos' and 'endpos' arguments.
+        
+        * 'Overlapped' argument for regex.findall and regex.finditer
+        
+            ``regex.findall`` and ``regex.finditer`` support an 'overlapped' flag which permits overlapped matches.
+        
+        * Unicode escapes (issue #3665)
+        
+            The Unicode escapes ``\uxxxx`` and ``\Uxxxxxxxx`` are supported.
+        
+        * Large patterns (issue #1160)
+        
+            Patterns can be much larger.
+        
+        * Zero-width match with regex.finditer (issue #1647489)
+        
+            ``regex.finditer`` behaves correctly when it splits at a zero-width match.
+        
+        * Zero-width split with regex.split (issue #3262)
+        
+            ``regex.split`` can split at a zero-width match if the ``NEW`` flag is turned on. When the flag is turned off the current behaviour is unchanged because the BDFL thinks that some existing software might depend on it.
+        
+        * Splititer
+        
+            ``regex.splititer`` has been added. It's a generator equivalent of ``regex.split``.
+        
+        * Subscripting for groups
+        
+            A match object accepts access to the captured groups via subscripting and slicing:
+        
+            >>> m = regex.search(r"(?P<before>.*?)(?P<num>\d+)(?P<after>.*)", "pqr123stu")
+            >>> print m["before"]
+            pqr
+            >>> print m["num"]
+            123
+            >>> print m["after"]
+            stu
+            >>> print len(m)
+            4
+            >>> print m[:]
+            ('pqr123stu', 'pqr', '123', 'stu')
+        
+        * Named groups
+        
+            Groups can be named with ``(?<name>...)`` as well as the current ``(?P<name>...)``.
+        
+        * Group references
+        
+            Groups can be referenced within a pattern with ``\g<name>``. This also allows there to be more than 99 groups.
+        
+        * Named characters
+        
+            ``\N{name}``
+        
+            Named characters are supported.
+        
+        * Unicode codepoint properties, blocks and scripts
+        
+            ``\p{name}`` ; ``\P{name}``
+        
+            Unicode properties, blocks and scripts are supported. ``\p{name}`` matches a character which has property 'name' and ``\P{name}`` matches a character which doesn't have property 'name'.
+        
+            In order to avoid ambiguity, block names should start with ``In`` and script names should start with ``Is``. If a name lacks such a prefix and it could be a block or a script, script will take priority, for example:
+        
+            1. ``InBasicLatin`` or ``BasicLatin``, the 'BasicLatin' **block**.
+        
+            2. ``IsLatin`` or ``Latin``, the 'Latin' **script**.
+        
+            3. ``InCyrillic``, the 'Cyrillic' **block**.
+        
+            4. ``IsCyrillic`` or ``Cyrillic``, the 'Cyrillic' **script**.
+        
+        * POSIX character classes
+        
+            ``[[:alpha:]]``
+        
+            POSIX character classes are supported.
+        
+        * Search anchor
+        
+            ``\G``
+        
+            A search anchor has been added. It matches at the position where each search started/continued and can be used for contiguous matches or in negative variable-length lookbehinds to limit how far back the lookbehind goes:
+        
+            >>> regex.findall(r"\w{2}", "abcd ef")
+            ['ab', 'cd', 'ef']
+            >>> regex.findall(r"\G\w{2}", "abcd ef")
+            ['ab', 'cd']
+        
+            1. The search starts at position 0 and matches 2 letters 'ab'.
+        
+            2. The search continues at position 2 and matches 2 letters 'cd'.
+        
+            3. The search continues at position 4 and fails to match any letters.
+        
+            4. The anchor stops the search start position from being advanced, so there are no more results.
+        
+        * Reverse searching
+        
+            Searches can now work backwards:
+        
+            >>> regex.findall(r".", "abc")
+            ['a', 'b', 'c']
+            >>> regex.findall(r"(?r).", "abc")
+            ['c', 'b', 'a']
+        
+            Note: the result of a reverse search is not necessarily the reverse of a forward search:
+        
+            >>> regex.findall(r"..", "abcde")
+            ['ab', 'cd']
+            >>> regex.findall(r"(?r)..", "abcde")
+            ['de', 'bc']
+        
+        * Matching a single grapheme
+        
+            ``\X``
+        
+            The grapheme matcher is supported. It's equivalent to ``\P{M}\p{M}*``.
+        
+        * Branch reset
+        
+            (?|...|...)
+        
+            Capture group numbers will be reused across the alternatives.
+        
+        * Default Unicode word boundary
+        
+            The ``WORD`` flag changes the definition of a 'word boundary' to that of a default Unicode word boundary. This applies to ``\b`` and ``\B``.
+        
+            Please note: I'm unsure whether I've understood the specification correctly, so if you're using this feature I'd be interested in any feedback.
+        
+Platform: UNKNOWN
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Python Software Foundation License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 2.5
+Classifier: Programming Language :: Python :: 2.6
+Classifier: Programming Language :: Python :: 2.7
+Classifier: Programming Language :: Python :: 3.1
+Classifier: Programming Language :: Python :: 3.2
+Classifier: Topic :: Scientific/Engineering :: Information Analysis
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Text Processing
+Classifier: Topic :: Text Processing :: General

File Python2/Features.html

+<?xml version="1.0" encoding="utf-8" ?>
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
+<meta name="generator" content="Docutils 0.7: http://docutils.sourceforge.net/" />
+<title></title>
+<style type="text/css">
+
+/*
+:Author: David Goodger (goodger@python.org)
+:Id: $Id: html4css1.css 6194 2009-11-11 12:05:10Z milde $
+:Copyright: This stylesheet has been placed in the public domain.
+
+Default cascading style sheet for the HTML output of Docutils.
+
+See http://docutils.sf.net/docs/howto/html-stylesheets.html for how to
+customize this style sheet.
+*/
+
+/* used to remove borders from tables and images */
+.borderless, table.borderless td, table.borderless th {
+  border: 0 }
+
+table.borderless td, table.borderless th {
+  /* Override padding for "table.docutils td" with "! important".
+     The right padding separates the table cells. */
+  padding: 0 0.5em 0 0 ! important }
+
+.first {
+  /* Override more specific margin styles with "! important". */
+  margin-top: 0 ! important }
+
+.last, .with-subtitle {
+  margin-bottom: 0 ! important }
+
+.hidden {
+  display: none }
+
+a.toc-backref {
+  text-decoration: none ;
+  color: black }
+
+blockquote.epigraph {
+  margin: 2em 5em ; }
+
+dl.docutils dd {
+  margin-bottom: 0.5em }
+
+/* Uncomment (and remove this text!) to get bold-faced definition list terms
+dl.docutils dt {
+  font-weight: bold }
+*/
+
+div.abstract {
+  margin: 2em 5em }
+
+div.abstract p.topic-title {
+  font-weight: bold ;
+  text-align: center }
+
+div.admonition, div.attention, div.caution, div.danger, div.error,
+div.hint, div.important, div.note, div.tip, div.warning {
+  margin: 2em ;
+  border: medium outset ;
+  padding: 1em }
+
+div.admonition p.admonition-title, div.hint p.admonition-title,
+div.important p.admonition-title, div.note p.admonition-title,
+div.tip p.admonition-title {
+  font-weight: bold ;
+  font-family: sans-serif }
+
+div.attention p.admonition-title, div.caution p.admonition-title,
+div.danger p.admonition-title, div.error p.admonition-title,
+div.warning p.admonition-title {
+  color: red ;
+  font-weight: bold ;
+  font-family: sans-serif }
+
+/* Uncomment (and remove this text!) to get reduced vertical space in
+   compound paragraphs.
+div.compound .compound-first, div.compound .compound-middle {
+  margin-bottom: 0.5em }
+
+div.compound .compound-last, div.compound .compound-middle {
+  margin-top: 0.5em }
+*/
+
+div.dedication {
+  margin: 2em 5em ;
+  text-align: center ;
+  font-style: italic }
+
+div.dedication p.topic-title {
+  font-weight: bold ;
+  font-style: normal }
+
+div.figure {
+  margin-left: 2em ;
+  margin-right: 2em }
+
+div.footer, div.header {
+  clear: both;
+  font-size: smaller }
+
+div.line-block {
+  display: block ;
+  margin-top: 1em ;
+  margin-bottom: 1em }
+
+div.line-block div.line-block {
+  margin-top: 0 ;
+  margin-bottom: 0 ;
+  margin-left: 1.5em }
+
+div.sidebar {
+  margin: 0 0 0.5em 1em ;
+  border: medium outset ;
+  padding: 1em ;
+  background-color: #ffffee ;
+  width: 40% ;
+  float: right ;
+  clear: right }
+
+div.sidebar p.rubric {
+  font-family: sans-serif ;
+  font-size: medium }
+
+div.system-messages {
+  margin: 5em }
+
+div.system-messages h1 {
+  color: red }
+
+div.system-message {
+  border: medium outset ;
+  padding: 1em }
+
+div.system-message p.system-message-title {
+  color: red ;
+  font-weight: bold }
+
+div.topic {
+  margin: 2em }
+
+h1.section-subtitle, h2.section-subtitle, h3.section-subtitle,
+h4.section-subtitle, h5.section-subtitle, h6.section-subtitle {
+  margin-top: 0.4em }
+
+h1.title {
+  text-align: center }
+
+h2.subtitle {
+  text-align: center }
+
+hr.docutils {
+  width: 75% }
+
+img.align-left, .figure.align-left{
+  clear: left ;
+  float: left ;
+  margin-right: 1em }
+
+img.align-right, .figure.align-right {
+  clear: right ;
+  float: right ;
+  margin-left: 1em }
+
+img.align-center, .figure.align-center {
+  display: block;
+  margin-left: auto;
+  margin-right: auto;
+}
+
+.align-left {
+  text-align: left }
+
+.align-center {
+  clear: both ;
+  text-align: center }
+
+.align-right {
+  text-align: right }
+
+/* reset inner alignment in figures */
+div.align-right {
+  text-align: left }
+
+/* div.align-center * { */
+/*   text-align: left } */
+
+ol.simple, ul.simple {
+  margin-bottom: 1em }
+
+ol.arabic {
+  list-style: decimal }
+
+ol.loweralpha {
+  list-style: lower-alpha }
+
+ol.upperalpha {
+  list-style: upper-alpha }
+
+ol.lowerroman {
+  list-style: lower-roman }
+
+ol.upperroman {
+  list-style: upper-roman }
+
+p.attribution {
+  text-align: right ;
+  margin-left: 50% }
+
+p.caption {
+  font-style: italic }
+
+p.credits {
+  font-style: italic ;
+  font-size: smaller }
+
+p.label {
+  white-space: nowrap }
+
+p.rubric {
+  font-weight: bold ;
+  font-size: larger ;
+  color: maroon ;
+  text-align: center }
+
+p.sidebar-title {
+  font-family: sans-serif ;
+  font-weight: bold ;
+  font-size: larger }
+
+p.sidebar-subtitle {
+  font-family: sans-serif ;
+  font-weight: bold }
+
+p.topic-title {
+  font-weight: bold }
+
+pre.address {
+  margin-bottom: 0 ;
+  margin-top: 0 ;
+  font: inherit }
+
+pre.literal-block, pre.doctest-block {
+  margin-left: 2em ;
+  margin-right: 2em }
+
+span.classifier {
+  font-family: sans-serif ;
+  font-style: oblique }
+
+span.classifier-delimiter {
+  font-family: sans-serif ;
+  font-weight: bold }
+
+span.interpreted {
+  font-family: sans-serif }
+
+span.option {
+  white-space: nowrap }
+
+span.pre {
+  white-space: pre }
+
+span.problematic {
+  color: red }
+
+span.section-subtitle {
+  /* font-size relative to parent (h1..h6 element) */
+  font-size: 80% }
+
+table.citation {
+  border-left: solid 1px gray;
+  margin-left: 1px }
+
+table.docinfo {
+  margin: 2em 4em }
+
+table.docutils {
+  margin-top: 0.5em ;
+  margin-bottom: 0.5em }
+
+table.footnote {
+  border-left: solid 1px black;
+  margin-left: 1px }
+
+table.docutils td, table.docutils th,
+table.docinfo td, table.docinfo th {
+  padding-left: 0.5em ;
+  padding-right: 0.5em ;
+  vertical-align: top }
+
+table.docutils th.field-name, table.docinfo th.docinfo-name {
+  font-weight: bold ;
+  text-align: left ;
+  white-space: nowrap ;
+  padding-left: 0 }
+
+h1 tt.docutils, h2 tt.docutils, h3 tt.docutils,
+h4 tt.docutils, h5 tt.docutils, h6 tt.docutils {
+  font-size: 100% }
+
+ul.auto-toc {
+  list-style-type: none }
+
+</style>
+</head>
+<body>
+<div class="document">
+
+
+<div class="section" id="notes">
+<h1>Notes</h1>
+<p>For testing and comparison with the current 're' module the new implementation is in the form of a module called 'regex'.</p>
+<p>Please note that certain aspects of this module have changed from those of previous versions to make it conform better to the 're' module.</p>
+<p>Please also note that <tt class="docutils literal">matchobject.captures</tt> and the related methods now return a <strong>list</strong> (or a tuple of lists for the multi-group versions) instead of a tuple as previously.</p>
+</div>
+<div class="section" id="flags">
+<h1>Flags</h1>
+<p>There are 2 kinds of flag: scoped and global. Scoped flags can apply to only part of a pattern and can be turned on or off; global flags apply to the entire pattern and can only be turned on.</p>
+<p>The scoped flags are: <tt class="docutils literal">IGNORECASE</tt>, <tt class="docutils literal">MULTILINE</tt>, <tt class="docutils literal">DOTALL</tt>, <tt class="docutils literal">VERBOSE</tt>, <tt class="docutils literal">WORD</tt>.</p>
+<p>The global flags are: <tt class="docutils literal">ASCII</tt>, <tt class="docutils literal">LOCALE</tt>, <tt class="docutils literal">NEW</tt>, <tt class="docutils literal">REVERSE</tt>, <tt class="docutils literal">UNICODE</tt>.</p>
+<p>The <tt class="docutils literal">NEW</tt> flag turns on the new behaviour of this module, which can differ from that of the 're' module, such as splitting on zero-width matches, inline flags affecting only what follows, and being able to turn inline flags off.</p>
+<p>Note: The <tt class="docutils literal">ZEROWIDTH</tt> flag which was in previous versions of this module has been removed. The <tt class="docutils literal">NEW</tt> flag should be used instead.</p>
+</div>
+<div class="section" id="notes-on-named-capture-groups">
+<h1>Notes on named capture groups</h1>
+<p>All capture groups have a group number, starting from 1.</p>
+<p>Groups with the same group name will have the same group number, and groups with a different group name will have a different group number.</p>
+<p>The same group name can be used on different branches of an alternation because they are mutually exclusive, eg. <tt class="docutils literal"><span class="pre">(?P&lt;foo&gt;first)|(?P&lt;foo&gt;second)</span></tt>. They will, of course, have the same group number.</p>
+<p>Group numbers will be reused, where possible, across different branches of a branch reset, eg. <tt class="docutils literal"><span class="pre">(?|(first)|(second))</span></tt> has only group 1. If capture groups have different group names then they will, of course, have different group numbers, eg. <tt class="docutils literal"><span class="pre">(?|(?P&lt;foo&gt;first)|(?P&lt;bar&gt;second))</span></tt> has group 1 (&quot;foo&quot;) and group 2 (&quot;bar&quot;).</p>
+</div>
+<div class="section" id="multithreading">
+<h1>Multithreading</h1>
+<p>The regex module releases the GIL during matching on instances of the built-in (immutable) string classes, enabling other Python threads to run concurrently. It is also possible to force the regex module to release the GIL during matching by calling the matching methods with the keyword argument <tt class="docutils literal">concurrent=True</tt>. The behaviour is undefined if the string changes during matching, so use it <em>only</em> when it is guaranteed that that won't happen.</p>
+</div>
+<div class="section" id="building-for-64-bits">
+<h1>Building for 64-bits</h1>
+<p>If the source files are built for a 64-bit target then the string positions will also be 64-bit. (The 're' module appears to limit string positions to 32 bits, even on a 64-bit build.)</p>
+</div>
+<div class="section" id="unicode">
+<h1>Unicode</h1>
+<p>This module supports Unicode 6.0.0.</p>
+</div>
+<div class="section" id="additional-features">
+<h1>Additional features</h1>
+<ul>
+<li><p class="first">regex.escape (issue #2650)</p>
+<blockquote>
+<p>regex.escape has an additional keyword parameter <tt class="docutils literal">special_only</tt>. When True, only 'special' regex characters, such as '?', are escaped.</p>
+<p>Examples:</p>
+<blockquote>
+<pre class="doctest-block">
+&gt;&gt;&gt; regex.escape(&quot;foo!?&quot;)
+'foo\\!\\?'
+&gt;&gt;&gt; regex.escape(&quot;foo!?&quot;, special_only=True)
+'foo!\\?'
+</pre>
+</blockquote>
+</blockquote>
+</li>
+<li><p class="first">Repeated captures (issue #7132)</p>
+<blockquote>
+<p>A match object has additional methods which return information on all the successful matches of a repeated capture group. These methods are:</p>
+<p><tt class="docutils literal"><span class="pre">matchobject.captures([group1,</span> <span class="pre">...])</span></tt></p>
+<blockquote>
+<p>Returns a list of the strings matched in a group or groups. Compare with <tt class="docutils literal"><span class="pre">matchobject.group([group1,</span> <span class="pre">...])</span></tt>.</p>
+</blockquote>
+<p><tt class="docutils literal"><span class="pre">matchobject.starts([group])</span></tt></p>
+<blockquote>
+<p>Returns a list of the start positions. Compare with <tt class="docutils literal"><span class="pre">matchobject.start([group])</span></tt>.</p>
+</blockquote>
+<p><tt class="docutils literal"><span class="pre">matchobject.ends([group])</span></tt></p>
+<blockquote>
+<p>Returns a list of the end positions. Compare with <tt class="docutils literal"><span class="pre">matchobject.end([group])</span></tt>.</p>
+</blockquote>
+<p><tt class="docutils literal"><span class="pre">matchobject.spans([group])</span></tt></p>
+<blockquote>
+<p>Returns a list of the spans. Compare with <tt class="docutils literal"><span class="pre">matchobject.span([group])</span></tt>.</p>
+</blockquote>
+<p>Examples:</p>
+<blockquote>
+<pre class="doctest-block">
+&gt;&gt;&gt; m = regex.search(r&quot;(\w{3})+&quot;, &quot;123456789&quot;)
+&gt;&gt;&gt; m.group(1)
+'789'
+&gt;&gt;&gt; m.captures(1)
+['123', '456', '789']
+&gt;&gt;&gt; m.start(1)
+6
+&gt;&gt;&gt; m.starts(1)
+[0, 3, 6]
+&gt;&gt;&gt; m.end(1)
+9
+&gt;&gt;&gt; m.ends(1)
+[3, 6, 9]
+&gt;&gt;&gt; m.span(1)
+(6, 9)
+&gt;&gt;&gt; m.spans(1)
+[(0, 3), (3, 6), (6, 9)]
+</pre>
+</blockquote>
+</blockquote>
+</li>
+<li><p class="first">Atomic grouping (issue #433030)</p>
+<blockquote>
+<p><tt class="docutils literal"><span class="pre">(?&gt;...)</span></tt></p>
+<p>If the following pattern subsequently fails, then the subpattern as a whole will fail.</p>
+</blockquote>
+</li>
+<li><p class="first">Possessive quantifiers.</p>
+<blockquote>
+<p><tt class="docutils literal"><span class="pre">(?:...)?+</span></tt> ; <tt class="docutils literal"><span class="pre">(?:...)*+</span></tt> ; <tt class="docutils literal"><span class="pre">(?:...)++</span></tt> ; <tt class="docutils literal"><span class="pre">(?:...){min,max}+</span></tt></p>
+<p>The subpattern is matched up to 'max' times. If the following pattern subsequently fails, then all of the repeated subpatterns will fail as a whole. For example, <tt class="docutils literal"><span class="pre">(?:...)++</span></tt> is equivalent to <tt class="docutils literal"><span class="pre">(?&gt;(?:...)+)</span></tt>.</p>
+</blockquote>
+</li>
+<li><p class="first">Scoped flags (issue #433028)</p>
+<blockquote>
+<p><tt class="docutils literal"><span class="pre">(?flags-flags:...)</span></tt></p>
+<p>The flags will apply only to the subpattern. Flags can be turned on or off.</p>
+</blockquote>
+</li>
+<li><p class="first">Inline flags (issue #433024, issue #433027)</p>
+<blockquote>
+<p><tt class="docutils literal"><span class="pre">(?flags-flags)</span></tt></p>
+<p>If the <tt class="docutils literal">NEW</tt> flag is turned on then the flags will apply to the end of the group or pattern and can be turned on or off. If the <tt class="docutils literal">NEW</tt> flag isn't turned on then the flags will be global and can't be turned off.</p>
+</blockquote>
+</li>
+<li><p class="first">Repeated repeats (issue #2537)</p>
+<blockquote>
+<p>A regex like <tt class="docutils literal"><span class="pre">((x|y+)*)*</span></tt> will be accepted and will work correctly, but should complete more quickly.</p>
+</blockquote>
+</li>
+<li><p class="first">Definition of 'word' character (issue #1693050)</p>
+<blockquote>
+<p>The definition of a 'word' character has been expanded for Unicode. This applies to <tt class="docutils literal">\w</tt>, <tt class="docutils literal">\W</tt>, <tt class="docutils literal">\b</tt> and <tt class="docutils literal">\B</tt>.</p>
+</blockquote>
+</li>
+<li><p class="first">Groups in lookahead and lookbehind (issue #814253)</p>
+<blockquote>
+<p>Groups and group references are permitted in both lookahead and lookbehind.</p>
+</blockquote>
+</li>
+<li><p class="first">Variable-length lookbehind</p>
+<blockquote>
+<p>A lookbehind can match a variable-length string.</p>
+</blockquote>
+</li>
+<li><p class="first">Correct handling of charset with ignore case flag (issue #3511)</p>
+<blockquote>
+<p>Ranges within charsets are handled correctly when the ignore-case flag is turned on.</p>
+</blockquote>
+</li>
+<li><p class="first">Unmatched group in replacement (issue #1519638)</p>
+<blockquote>
+<p>An unmatched group is treated as an empty string in a replacement template.</p>
+</blockquote>
+</li>
+<li><p class="first">'Pathological' patterns (issue #1566086, issue #1662581, issue #1448325, issue #1721518, issue #1297193)</p>
+<blockquote>
+<p>'Pathological' patterns should complete more quickly.</p>
+</blockquote>
+</li>
+<li><p class="first">Flags argument for regex.split, regex.sub and regex.subn (issue #3482)</p>
+<blockquote>
+<p><tt class="docutils literal">regex.split</tt>, <tt class="docutils literal">regex.sub</tt> and <tt class="docutils literal">regex.subn</tt> support a 'flags' argument.</p>
+</blockquote>
+</li>
+<li><p class="first">Pos and endpos arguments for regex.sub and regex.subn</p>
+<blockquote>
+<p><tt class="docutils literal">regex.sub</tt> and <tt class="docutils literal">regex.subn</tt> support 'pos' and 'endpos' arguments.</p>
+</blockquote>
+</li>
+<li><p class="first">'Overlapped' argument for regex.findall and regex.finditer</p>
+<blockquote>
+<p><tt class="docutils literal">regex.findall</tt> and <tt class="docutils literal">regex.finditer</tt> support an 'overlapped' flag which permits overlapped matches.</p>
+</blockquote>
+</li>
+<li><p class="first">Unicode escapes (issue #3665)</p>
+<blockquote>
+<p>The Unicode escapes <tt class="docutils literal">\uxxxx</tt> and <tt class="docutils literal">\Uxxxxxxxx</tt> are supported.</p>
+</blockquote>
+</li>
+<li><p class="first">Large patterns (issue #1160)</p>
+<blockquote>
+<p>Patterns can be much larger.</p>
+</blockquote>
+</li>
+<li><p class="first">Zero-width match with regex.finditer (issue #1647489)</p>
+<blockquote>
+<p><tt class="docutils literal">regex.finditer</tt> behaves correctly when it splits at a zero-width match.</p>
+</blockquote>
+</li>
+<li><p class="first">Zero-width split with regex.split (issue #3262)</p>
+<blockquote>
+<p><tt class="docutils literal">regex.split</tt> can split at a zero-width match if the <tt class="docutils literal">NEW</tt> flag is turned on. When the flag is turned off the current behaviour is unchanged because the BDFL thinks that some existing software might depend on it.</p>
+</blockquote>
+</li>
+<li><p class="first">Splititer</p>
+<blockquote>
+<p><tt class="docutils literal">regex.splititer</tt> has been added. It's a generator equivalent of <tt class="docutils literal">regex.split</tt>.</p>
+</blockquote>
+</li>
+<li><p class="first">Subscripting for groups</p>
+<blockquote>
+<p>A match object accepts access to the captured groups via subscripting and slicing:</p>
+<pre class="doctest-block">
+&gt;&gt;&gt; m = regex.search(r&quot;(?P&lt;before&gt;.*?)(?P&lt;num&gt;\d+)(?P&lt;after&gt;.*)&quot;, &quot;pqr123stu&quot;)
+&gt;&gt;&gt; print m[&quot;before&quot;]
+pqr
+&gt;&gt;&gt; print m[&quot;num&quot;]
+123
+&gt;&gt;&gt; print m[&quot;after&quot;]
+stu
+&gt;&gt;&gt; print len(m)
+4
+&gt;&gt;&gt; print m[:]
+('pqr123stu', 'pqr', '123', 'stu')
+</pre>
+</blockquote>
+</li>
+<li><p class="first">Named groups</p>
+<blockquote>
+<p>Groups can be named with <tt class="docutils literal"><span class="pre">(?&lt;name&gt;...)</span></tt> as well as the current <tt class="docutils literal"><span class="pre">(?P&lt;name&gt;...)</span></tt>.</p>
+</blockquote>
+</li>
+<li><p class="first">Group references</p>
+<blockquote>
+<p>Groups can be referenced within a pattern with <tt class="docutils literal">\g&lt;name&gt;</tt>. This also allows there to be more than 99 groups.</p>
+</blockquote>
+</li>
+<li><p class="first">Named characters</p>
+<blockquote>
+<p><tt class="docutils literal">\N{name}</tt></p>
+<p>Named characters are supported.</p>
+</blockquote>
+</li>
+<li><p class="first">Unicode codepoint properties, blocks and scripts</p>
+<blockquote>
+<p><tt class="docutils literal">\p{name}</tt> ; <tt class="docutils literal">\P{name}</tt></p>
+<p>Unicode properties, blocks and scripts are supported. <tt class="docutils literal">\p{name}</tt> matches a character which has property 'name' and <tt class="docutils literal">\P{name}</tt> matches a character which doesn't have property 'name'.</p>
+<p>In order to avoid ambiguity, block names should start with <tt class="docutils literal">In</tt> and script names should start with <tt class="docutils literal">Is</tt>. If a name lacks such a prefix and it could be a block or a script, script will take priority, for example:</p>
+<ol class="arabic simple">
+<li><tt class="docutils literal">InBasicLatin</tt> or <tt class="docutils literal">BasicLatin</tt>, the 'BasicLatin' <strong>block</strong>.</li>
+<li><tt class="docutils literal">IsLatin</tt> or <tt class="docutils literal">Latin</tt>, the 'Latin' <strong>script</strong>.</li>
+<li><tt class="docutils literal">InCyrillic</tt>, the 'Cyrillic' <strong>block</strong>.</li>
+<li><tt class="docutils literal">IsCyrillic</tt> or <tt class="docutils literal">Cyrillic</tt>, the 'Cyrillic' <strong>script</strong>.</li>
+</ol>
+</blockquote>
+</li>
+<li><p class="first">POSIX character classes</p>
+<blockquote>
+<p><tt class="docutils literal"><span class="pre">[[:alpha:]]</span></tt></p>
+<p>POSIX character classes are supported.</p>
+</blockquote>
+</li>
+<li><p class="first">Search anchor</p>
+<blockquote>
+<p><tt class="docutils literal">\G</tt></p>
+<p>A search anchor has been added. It matches at the position where each search started/continued and can be used for contiguous matches or in negative variable-length lookbehinds to limit how far back the lookbehind goes:</p>
+<pre class="doctest-block">
+&gt;&gt;&gt; regex.findall(r&quot;\w{2}&quot;, &quot;abcd ef&quot;)
+['ab', 'cd', 'ef']
+&gt;&gt;&gt; regex.findall(r&quot;\G\w{2}&quot;, &quot;abcd ef&quot;)
+['ab', 'cd']
+</pre>
+<ol class="arabic simple">
+<li>The search starts at position 0 and matches 2 letters 'ab'.</li>
+<li>The search continues at position 2 and matches 2 letters 'cd'.</li>
+<li>The search continues at position 4 and fails to match any letters.</li>
+<li>The anchor stops the search start position from being advanced, so there are no more results.</li>
+</ol>
+</blockquote>
+</li>
+<li><p class="first">Reverse searching</p>
+<blockquote>
+<p>Searches can now work backwards:</p>
+<pre class="doctest-block">
+&gt;&gt;&gt; regex.findall(r&quot;.&quot;, &quot;abc&quot;)
+['a', 'b', 'c']
+&gt;&gt;&gt; regex.findall(r&quot;(?r).&quot;, &quot;abc&quot;)
+['c', 'b', 'a']
+</pre>
+<p>Note: the result of a reverse search is not necessarily the reverse of a forward search:</p>
+<pre class="doctest-block">
+&gt;&gt;&gt; regex.findall(r&quot;..&quot;, &quot;abcde&quot;)
+['ab', 'cd']
+&gt;&gt;&gt; regex.findall(r&quot;(?r)..&quot;, &quot;abcde&quot;)
+['de', 'bc']
+</pre>
+</blockquote>
+</li>
+<li><p class="first">Matching a single grapheme</p>
+<blockquote>
+<p><tt class="docutils literal">\X</tt></p>
+<p>The grapheme matcher is supported. It's equivalent to <tt class="docutils literal"><span class="pre">\P{M}\p{M}*</span></tt>.</p>
+</blockquote>
+</li>
+<li><p class="first">Branch reset</p>
+<blockquote>
+<p>(?|...|...)</p>
+<p>Capture group numbers will be reused across the alternatives.</p>
+</blockquote>
+</li>
+<li><p class="first">Default Unicode word boundary</p>
+<blockquote>
+<p>The <tt class="docutils literal">WORD</tt> flag changes the definition of a 'word boundary' to that of a default Unicode word boundary. This applies to <tt class="docutils literal">\b</tt> and <tt class="docutils literal">\B</tt>.</p>
+<p>Please note: I'm unsure whether I've understood the specification correctly, so if you're using this feature I'd be interested in any feedback.</p>
+</blockquote>
+</li>
+</ul>
+</div>
+</div>
+</body>
+</html>

File Python2/Features.rst

+Notes
+-----
+
+For testing and comparison with the current 're' module the new implementation is in the form of a module called 'regex'.
+
+Please note that certain aspects of this module have changed from those of previous versions to make it conform better to the 're' module.
+
+Please also note that ``matchobject.captures`` and the related methods now return a **list** (or a tuple of lists for the multi-group versions) instead of a tuple as previously.
+
+
+Flags
+-----
+
+There are 2 kinds of flag: scoped and global. Scoped flags can apply to only part of a pattern and can be turned on or off; global flags apply to the entire pattern and can only be turned on.
+
+The scoped flags are: ``IGNORECASE``, ``MULTILINE``, ``DOTALL``, ``VERBOSE``, ``WORD``.
+
+The global flags are: ``ASCII``, ``LOCALE``, ``NEW``, ``REVERSE``, ``UNICODE``.
+
+
+The ``NEW`` flag turns on the new behaviour of this module, which can differ from that of the 're' module, such as splitting on zero-width matches, inline flags affecting only what follows, and being able to turn inline flags off.
+
+Note: The ``ZEROWIDTH`` flag which was in previous versions of this module has been removed. The ``NEW`` flag should be used instead.
+
+
+Notes on named capture groups
+-----------------------------
+
+All capture groups have a group number, starting from 1.
+
+Groups with the same group name will have the same group number, and groups with a different group name will have a different group number.
+
+The same group name can be used on different branches of an alternation because they are mutually exclusive, eg. ``(?P<foo>first)|(?P<foo>second)``. They will, of course, have the same group number.
+
+Group numbers will be reused, where possible, across different branches of a branch reset, eg. ``(?|(first)|(second))`` has only group 1. If capture groups have different group names then they will, of course, have different group numbers, eg. ``(?|(?P<foo>first)|(?P<bar>second))`` has group 1 ("foo") and group 2 ("bar").
+
+
+Multithreading
+--------------
+
+The regex module releases the GIL during matching on instances of the built-in (immutable) string classes, enabling other Python threads to run concurrently. It is also possible to force the regex module to release the GIL during matching by calling the matching methods with the keyword argument ``concurrent=True``. The behaviour is undefined if the string changes during matching, so use it *only* when it is guaranteed that that won't happen.
+
+
+Building for 64-bits
+--------------------
+
+If the source files are built for a 64-bit target then the string positions will also be 64-bit. (The 're' module appears to limit string positions to 32 bits, even on a 64-bit build.)
+
+
+Unicode
+-------
+
+This module supports Unicode 6.0.0.
+
+
+
+Additional features
+-------------------
+
+* regex.escape (issue #2650)
+
+    regex.escape has an additional keyword parameter ``special_only``. When True, only 'special' regex characters, such as '?', are escaped.
+
+    Examples:
+
+        >>> regex.escape("foo!?")
+        'foo\\!\\?'
+        >>> regex.escape("foo!?", special_only=True)
+        'foo!\\?'
+
+* Repeated captures (issue #7132)
+
+    A match object has additional methods which return information on all the successful matches of a repeated capture group. These methods are:
+
+    ``matchobject.captures([group1, ...])``
+
+        Returns a list of the strings matched in a group or groups. Compare with ``matchobject.group([group1, ...])``.
+
+    ``matchobject.starts([group])``
+
+        Returns a list of the start positions. Compare with ``matchobject.start([group])``.
+
+    ``matchobject.ends([group])``
+
+        Returns a list of the end positions. Compare with ``matchobject.end([group])``.
+
+    ``matchobject.spans([group])``
+
+        Returns a list of the spans. Compare with ``matchobject.span([group])``.
+
+    Examples:
+
+        >>> m = regex.search(r"(\w{3})+", "123456789")
+        >>> m.group(1)
+        '789'
+        >>> m.captures(1)
+        ['123', '456', '789']
+        >>> m.start(1)
+        6
+        >>> m.starts(1)
+        [0, 3, 6]
+        >>> m.end(1)
+        9
+        >>> m.ends(1)
+        [3, 6, 9]
+        >>> m.span(1)
+        (6, 9)
+        >>> m.spans(1)
+        [(0, 3), (3, 6), (6, 9)]
+
+* Atomic grouping (issue #433030)
+
+    ``(?>...)``
+
+    If the following pattern subsequently fails, then the subpattern as a whole will fail.
+
+* Possessive quantifiers.
+
+    ``(?:...)?+`` ; ``(?:...)*+`` ; ``(?:...)++`` ; ``(?:...){min,max}+``
+
+    The subpattern is matched up to 'max' times. If the following pattern subsequently fails, then all of the repeated subpatterns will fail as a whole. For example, ``(?:...)++`` is equivalent to ``(?>(?:...)+)``.
+
+* Scoped flags (issue #433028)
+
+    ``(?flags-flags:...)``
+
+    The flags will apply only to the subpattern. Flags can be turned on or off.
+
+* Inline flags (issue #433024, issue #433027)
+
+    ``(?flags-flags)``
+
+    If the ``NEW`` flag is turned on then the flags will apply to the end of the group or pattern and can be turned on or off. If the ``NEW`` flag isn't turned on then the flags will be global and can't be turned off.
+
+* Repeated repeats (issue #2537)
+
+    A regex like ``((x|y+)*)*`` will be accepted and will work correctly, but should complete more quickly.
+
+* Definition of 'word' character (issue #1693050)
+
+    The definition of a 'word' character has been expanded for Unicode. This applies to ``\w``, ``\W``, ``\b`` and ``\B``.
+
+* Groups in lookahead and lookbehind (issue #814253)
+
+    Groups and group references are permitted in both lookahead and lookbehind.
+
+* Variable-length lookbehind
+
+    A lookbehind can match a variable-length string.
+
+* Correct handling of charset with ignore case flag (issue #3511)
+
+    Ranges within charsets are handled correctly when the ignore-case flag is turned on.
+
+* Unmatched group in replacement (issue #1519638)
+
+    An unmatched group is treated as an empty string in a replacement template.
+
+* 'Pathological' patterns (issue #1566086, issue #1662581, issue #1448325, issue #1721518, issue #1297193)
+
+    'Pathological' patterns should complete more quickly.
+
+* Flags argument for regex.split, regex.sub and regex.subn (issue #3482)
+
+    ``regex.split``, ``regex.sub`` and ``regex.subn`` support a 'flags' argument.
+
+* Pos and endpos arguments for regex.sub and regex.subn
+
+    ``regex.sub`` and ``regex.subn`` support 'pos' and 'endpos' arguments.
+
+* 'Overlapped' argument for regex.findall and regex.finditer
+
+    ``regex.findall`` and ``regex.finditer`` support an 'overlapped' flag which permits overlapped matches.
+
+* Unicode escapes (issue #3665)
+
+    The Unicode escapes ``\uxxxx`` and ``\Uxxxxxxxx`` are supported.
+
+* Large patterns (issue #1160)
+
+    Patterns can be much larger.
+
+* Zero-width match with regex.finditer (issue #1647489)
+
+    ``regex.finditer`` behaves correctly when it splits at a zero-width match.
+
+* Zero-width split with regex.split (issue #3262)
+
+    ``regex.split`` can split at a zero-width match if the ``NEW`` flag is turned on. When the flag is turned off the current behaviour is unchanged because the BDFL thinks that some existing software might depend on it.
+
+* Splititer
+
+    ``regex.splititer`` has been added. It's a generator equivalent of ``regex.split``.
+
+* Subscripting for groups
+
+    A match object accepts access to the captured groups via subscripting and slicing:
+
+    >>> m = regex.search(r"(?P<before>.*?)(?P<num>\d+)(?P<after>.*)", "pqr123stu")
+    >>> print m["before"]
+    pqr
+    >>> print m["num"]
+    123
+    >>> print m["after"]
+    stu
+    >>> print len(m)
+    4
+    >>> print m[:]
+    ('pqr123stu', 'pqr', '123', 'stu')
+
+* Named groups
+
+    Groups can be named with ``(?<name>...)`` as well as the current ``(?P<name>...)``.
+
+* Group references
+
+    Groups can be referenced within a pattern with ``\g<name>``. This also allows there to be more than 99 groups.
+
+* Named characters
+
+    ``\N{name}``
+
+    Named characters are supported.
+
+* Unicode codepoint properties, blocks and scripts
+
+    ``\p{name}`` ; ``\P{name}``
+
+    Unicode properties, blocks and scripts are supported. ``\p{name}`` matches a character which has property 'name' and ``\P{name}`` matches a character which doesn't have property 'name'.
+
+    In order to avoid ambiguity, block names should start with ``In`` and script names should start with ``Is``. If a name lacks such a prefix and it could be a block or a script, script will take priority, for example:
+
+    1. ``InBasicLatin`` or ``BasicLatin``, the 'BasicLatin' **block**.
+
+    2. ``IsLatin`` or ``Latin``, the 'Latin' **script**.
+
+    3. ``InCyrillic``, the 'Cyrillic' **block**.
+
+    4. ``IsCyrillic`` or ``Cyrillic``, the 'Cyrillic' **script**.
+
+* POSIX character classes
+
+    ``[[:alpha:]]``
+
+    POSIX character classes are supported.
+
+* Search anchor
+
+    ``\G``
+
+    A search anchor has been added. It matches at the position where each search started/continued and can be used for contiguous matches or in negative variable-length lookbehinds to limit how far back the lookbehind goes:
+
+    >>> regex.findall(r"\w{2}", "abcd ef")
+    ['ab', 'cd', 'ef']
+    >>> regex.findall(r"\G\w{2}", "abcd ef")
+    ['ab', 'cd']
+
+    1. The search starts at position 0 and matches 2 letters 'ab'.
+
+    2. The search continues at position 2 and matches 2 letters 'cd'.
+
+    3. The search continues at position 4 and fails to match any letters.
+
+    4. The anchor stops the search start position from being advanced, so there are no more results.
+
+* Reverse searching
+
+    Searches can now work backwards:
+
+    >>> regex.findall(r".", "abc")
+    ['a', 'b', 'c']
+    >>> regex.findall(r"(?r).", "abc")
+    ['c', 'b', 'a']
+
+    Note: the result of a reverse search is not necessarily the reverse of a forward search:
+
+    >>> regex.findall(r"..", "abcde")
+    ['ab', 'cd']
+    >>> regex.findall(r"(?r)..", "abcde")
+    ['de', 'bc']
+
+* Matching a single grapheme
+
+    ``\X``
+
+    The grapheme matcher is supported. It's equivalent to ``\P{M}\p{M}*``.
+
+* Branch reset
+
+    (?|...|...)
+
+    Capture group numbers will be reused across the alternatives.
+
+* Default Unicode word boundary
+
+    The ``WORD`` flag changes the definition of a 'word boundary' to that of a default Unicode word boundary. This applies to ``\b`` and ``\B``.
+
+    Please note: I'm unsure whether I've understood the specification correctly, so if you're using this feature I'd be interested in any feedback.

File Python2/Python25/_regex.pyd

Binary file added.

File Python2/Python25/unicodedata_db.h

+/* this file was generated by Tools/unicode/makeunicodedata.py 2.5 */
+
+#define UNIDATA_VERSION "4.1.0"
+/* a list of unique database records */
+const _PyUnicode_DatabaseRecord _PyUnicode_Database_Records[] = {
+    {0, 0, 0, 0, 0},
+    {13, 0, 15, 0, 5},
+    {13, 0, 17, 0, 5},
+    {13, 0, 16, 0, 5},
+    {13, 0, 18, 0, 5},
+    {10, 0, 18, 0, 3},
+    {26, 0, 19, 0, 3},
+    {26, 0, 11, 0, 3},
+    {28, 0, 11, 0, 3},
+    {22, 0, 19, 1, 3},
+    {23, 0, 19, 1, 3},
+    {27, 0, 10, 0, 3},
+    {26, 0, 13, 0, 3},
+    {21, 0, 10, 0, 3},
+    {7, 0, 9, 0, 3},
+    {27, 0, 19, 1, 3},
+    {27, 0, 19, 0, 3},
+    {1, 0, 1, 0, 3},
+    {29, 0, 19, 0, 3},
+    {20, 0, 19, 0, 3},
+    {2, 0, 1, 0, 3},
+    {10, 0, 13, 0, 5},
+    {26, 0, 19, 0, 4},
+    {28, 0, 11, 0, 4},
+    {30, 0, 19, 0, 3},
+    {30, 0, 19, 0, 4},
+    {29, 0, 19, 0, 4},
+    {30, 0, 19, 0, 5},
+    {2, 0, 1, 0, 4},
+    {24, 0, 19, 1, 5},
+    {14, 0, 15, 0, 4},
+    {30, 0, 11, 0, 4},
+    {27, 0, 11, 0, 4},
+    {9, 0, 9, 0, 4},
+    {2, 0, 1, 0, 5},
+    {25, 0, 19, 1, 5},
+    {9, 0, 19, 0, 4},
+    {1, 0, 1, 0, 5},
+    {1, 0, 1, 0, 4},
+    {27, 0, 19, 0, 4},
+    {19, 0, 1, 0, 5},
+    {3, 0, 1, 0, 5},
+    {18, 0, 1, 0, 5},
+    {18, 0, 19, 0, 5},
+    {29, 0, 19, 0, 5},
+    {18, 0, 19, 0, 4},
+    {18, 0, 1, 0, 4},
+    {4, 230, 14, 0, 4},
+    {4, 232, 14, 0, 4},
+    {4, 220, 14, 0, 4},
+    {4, 216, 14, 0, 4},
+    {4, 202, 14, 0, 4},
+    {4, 1, 14, 0, 4},
+    {4, 240, 14, 0, 4},
+    {4, 0, 14, 0, 4},
+    {4, 233, 14, 0, 4},
+    {4, 234, 14, 0, 4},
+    {26, 0, 19, 0, 5},
+    {27, 0, 19, 0, 5},
+    {30, 0, 1, 0, 5},
+    {4, 230, 14, 0, 5},
+    {6, 0, 14, 0, 5},
+    {26, 0, 1, 0, 5},
+    {21, 0, 19, 0, 5},
+    {4, 220, 14, 0, 5},
+    {4, 222, 14, 0, 5},
+    {4, 228, 14, 0, 5},
+    {4, 10, 14, 0, 5},
+    {4, 11, 14, 0, 5},
+    {4, 12, 14, 0, 5},
+    {4, 13, 14, 0, 5},
+    {4, 14, 14, 0, 5},
+    {4, 15, 14, 0, 5},
+    {4, 16, 14, 0, 5},
+    {4, 17, 14, 0, 5},
+    {4, 18, 14, 0, 5},
+    {4, 19, 14, 0, 5},
+    {4, 20, 14, 0, 5},
+    {4, 21, 14, 0, 5},
+    {4, 22, 14, 0, 5},
+    {26, 0, 4, 0, 5},
+    {4, 23, 14, 0, 5},
+    {4, 24, 14, 0, 5},
+    {4, 25, 14, 0, 5},
+    {19, 0, 4, 0, 5},
+    {14, 0, 5, 0, 5},
+    {28, 0, 5, 0, 5},
+    {26, 0, 13, 0, 5},
+    {26, 0, 5, 0, 5},
+    {19, 0, 5, 0, 5},
+    {18, 0, 5, 0, 5},
+    {4, 27, 14, 0, 5},
+    {4, 28, 14, 0, 5},
+    {4, 29, 14, 0, 5},
+    {4, 30, 14, 0, 5},
+    {4, 31, 14, 0, 5},
+    {4, 32, 14, 0, 5},
+    {4, 33, 14, 0, 5},
+    {4, 34, 14, 0, 5},
+    {7, 0, 12, 0, 5},
+    {26, 0, 11, 0, 5},
+    {26, 0, 12, 0, 5},
+    {4, 35, 14, 0, 5},
+    {7, 0, 9, 0, 5},
+    {30, 0, 5, 0, 5},
+    {14, 0, 15, 0, 5},
+    {4, 36, 14, 0, 5},
+    {4, 0, 14, 0, 5},
+    {5, 0, 1, 0, 5},
+    {4, 7, 14, 0, 5},
+    {4, 9, 14, 0, 5},
+    {7, 0, 1, 0, 5},
+    {28, 0, 11, 0, 5},
+    {9, 0, 1, 0, 5},
+    {4, 84, 14, 0, 5},
+    {4, 91, 14, 0, 5},
+    {4, 0, 1, 0, 5},
+    {4, 103, 14, 0, 5},
+    {4, 107, 14, 0, 5},
+    {4, 118, 14, 0, 5},
+    {4, 122, 14, 0, 5},
+    {4, 216, 14, 0, 5},
+    {22, 0, 19, 0, 5},
+    {23, 0, 19, 0, 5},
+    {4, 129, 14, 0, 5},
+    {4, 130, 14, 0, 5},
+    {4, 132, 14, 0, 5},
+    {19, 0, 1, 0, 2},
+    {10, 0, 18, 0, 5},
+    {8, 0, 1, 0, 5},
+    {14, 0, 1, 0, 5},
+    {9, 0, 19, 0, 5},
+    {5, 0, 14, 0, 5},
+    {14, 0, 4, 0, 5},
+    {21, 0, 19, 0, 4},
+    {24, 0, 19, 0, 4},
+    {25, 0, 19, 0, 4},
+    {24, 0, 19, 0, 5},
+    {11, 0, 18, 0, 5},
+    {12, 0, 16, 0, 5},
+    {14, 0, 2, 0, 5},
+    {14, 0, 6, 0, 5},
+    {14, 0, 8, 0, 5},
+    {14, 0, 3, 0, 5},
+    {14, 0, 7, 0, 5},
+    {26, 0, 11, 0, 4},
+    {20, 0, 19, 0, 5},
+    {27, 0, 13, 0, 5},
+    {22, 0, 19, 1, 5},
+    {23, 0, 19, 1, 5},
+    {9, 0, 9, 0, 5},
+    {27, 0, 10, 0, 5},
+    {28, 0, 11, 0, 1},
+    {4, 1, 14, 0, 5},
+    {30, 0, 11, 0, 5},
+    {27, 0, 19, 1, 5},
+    {8, 0, 1, 0, 4},
+    {27, 0, 19, 1, 4},
+    {27, 0, 11, 0, 5},
+    {22, 0, 19, 1, 2},
+    {23, 0, 19, 1, 2},
+    {30, 0, 1, 0, 4},
+    {30, 0, 19, 0, 2},
+    {10, 0, 18, 0, 0},
+    {26, 0, 19, 0, 2},
+    {18, 0, 1, 0, 2},
+    {8, 0, 1, 0, 2},
+    {21, 0, 19, 0, 2},
+    {22, 0, 19, 0, 2},
+    {23, 0, 19, 0, 2},
+    {4, 218, 14, 0, 2},
+    {4, 228, 14, 0, 2},
+    {4, 232, 14, 0, 2},
+    {4, 222, 14, 0, 2},
+    {4, 224, 14, 0, 2},
+    {4, 8, 14, 0, 2},
+    {29, 0, 19, 0, 2},
+    {30, 0, 1, 0, 2},
+    {9, 0, 1, 0, 2},
+    {9, 0, 19, 0, 2},
+    {15, 0, 1, 0, 5},
+    {16, 0, 1, 0, 4},
+    {4, 26, 14, 0, 5},
+    {20, 0, 19, 0, 2},
+    {26, 0, 13, 0, 2},
+    {26, 0, 11, 0, 2},
+    {27, 0, 10, 0, 2},
+    {21, 0, 10, 0, 2},
+    {27, 0, 19, 0, 2},
+    {28, 0, 11, 0, 2},
+    {26, 0, 19, 0, 0},
+    {26, 0, 11, 0, 0},
+    {28, 0, 11, 0, 0},
+    {22, 0, 19, 1, 0},
+    {23, 0, 19, 1, 0},
+    {27, 0, 10, 0, 0},
+    {26, 0, 13, 0, 0},
+    {21, 0, 10, 0, 0},
+    {7, 0, 9, 0, 0},
+    {27, 0, 19, 1, 0},
+    {27, 0, 19, 0, 0},
+    {1, 0, 1, 0, 0},
+    {29, 0, 19, 0, 0},
+    {20, 0, 19, 0, 0},
+    {2, 0, 1, 0, 0},
+    {26, 0, 19, 0, 1},
+    {22, 0, 19, 1, 1},
+    {23, 0, 19, 1, 1},
+    {19, 0, 1, 0, 1},
+    {18, 0, 1, 0, 1},
+    {30, 0, 19, 0, 0},
+    {30, 0, 19, 0, 1},
+    {27, 0, 19, 0, 1},
+    {14, 0, 19, 0, 5},
+    {8, 0, 19, 0, 5},
+    {9, 0, 4, 0, 5},
+    {5, 216, 1, 0, 5},
+    {5, 226, 1, 0, 5},
+    {27, 0, 1, 0, 5},
+};
+
+/* Reindexing of NFC first characters. */
+#define TOTAL_FIRST 356
+#define TOTAL_LAST 53
+struct reindex{int start;short count,index;};
+struct reindex nfc_first[] = {
+  { 60, 2, 0},
+  { 65, 15, 3},
+  { 82, 8, 19},
+  { 97, 15, 28},
+  { 114, 8, 44},
+  { 168, 0, 53},
+  { 194, 0, 54},
+  { 196, 3, 55},
+  { 202, 0, 59},
+  { 207, 0, 60},
+  { 212, 2, 61},
+  { 216, 0, 64},
+  { 220, 0, 65},
+  { 226, 0, 66},
+  { 228, 3, 67},
+  { 234, 0, 71},
+  { 239, 0, 72},
+  { 244, 2, 73},
+  { 248, 0, 76},
+  { 252, 0, 77},
+  { 258, 1, 78},
+  { 274, 1, 80},
+  { 332, 1, 82},
+  { 346, 1, 84},
+  { 352, 1, 86},
+  { 360, 3, 88},
+  { 383, 0, 92},
+  { 416, 1, 93},
+  { 431, 1, 95},
+  { 439, 0, 97},
+  { 490, 1, 98},
+  { 550, 3, 100},
+  { 558, 1, 104},
+  { 658, 0, 106},
+  { 913, 0, 107},
+  { 917, 0, 108},
+  { 919, 0, 109},
+  { 921, 0, 110},
+  { 927, 0, 111},
+  { 929, 0, 112},
+  { 933, 0, 113},
+  { 937, 0, 114},
+  { 940, 0, 115},
+  { 942, 0, 116},
+  { 945, 0, 117},
+  { 949, 0, 118},
+  { 951, 0, 119},
+  { 953, 0, 120},
+  { 959, 0, 121},
+  { 961, 0, 122},
+  { 965, 0, 123},
+  { 969, 2, 124},
+  { 974, 0, 127},
+  { 978, 0, 128},
+  { 1030, 0, 129},
+  { 1040, 0, 130},
+  { 1043, 0, 131},
+  { 1045, 3, 132},
+  { 1050, 0, 136},
+  { 1054, 0, 137},
+  { 1059, 0, 138},
+  { 1063, 0, 139},
+  { 1067, 0, 140},
+  { 1069, 0, 141},
+  { 1072, 0, 142},
+  { 1075, 0, 143},
+  { 1077, 3, 144},
+  { 1082, 0, 148},
+  { 1086, 0, 149},
+  { 1091, 0, 150},
+  { 1095, 0, 151},
+  { 1099, 0, 152},
+  { 1101, 0, 153},
+  { 1110, 0, 154},
+  { 1140, 1, 155},
+  { 1240, 1, 157},
+  { 1256, 1, 159},
+  { 1575, 0, 161},
+  { 1608, 0, 162},
+  { 1610, 0, 163},
+  { 1729, 0, 164},
+  { 1746, 0, 165},
+  { 1749, 0, 166},
+  { 2344, 0, 167},
+  { 2352, 0, 168},
+  { 2355, 0, 169},
+  { 2503, 0, 170},
+  { 2887, 0, 171},
+  { 2962, 0, 172},
+  { 3014, 1, 173},
+  { 3142, 0, 175},
+  { 3263, 0, 176},
+  { 3270, 0, 177},
+  { 3274, 0, 178},
+  { 3398, 1, 179},
+  { 3545, 0, 181},
+  { 3548, 0, 182},
+  { 4133, 0, 183},
+  { 7734, 1, 184},
+  { 7770, 1, 186},
+  { 7778, 1, 188},
+  { 7840, 1, 190},
+  { 7864, 1, 192},
+  { 7884, 1, 194},
+  { 7936, 17, 196},
+  { 7960, 1, 214},
+  { 7968, 17, 216},
+  { 7992, 1, 234},
+  { 8000, 1, 236},
+  { 8008, 1, 238},
+  { 8016, 1, 240},
+  { 8025, 0, 242},
+  { 8032, 16, 243},
+  { 8052, 0, 260},
+  { 8060, 0, 261},
+  { 8118, 0, 262},
+  { 8127, 0, 263},
+  { 8134, 0, 264},
+  { 8182, 0, 265},
+  { 8190, 0, 266},
+  { 8592, 0, 267},
+  { 8594, 0, 268},
+  { 8596, 0, 269},
+  { 8656, 0, 270},
+  { 8658, 0, 271},
+  { 8660, 0, 272},
+  { 8707, 0, 273},
+  { 8712, 0, 274},
+  { 8715, 0, 275},
+  { 8739, 0, 276},
+  { 8741, 0, 277},
+  { 8764, 0, 278},
+  { 8771, 0, 279},
+  { 8773, 0, 280},
+  { 8776, 0, 281},
+  { 8781, 0, 282},
+  { 8801, 0, 283},
+  { 8804, 1, 284},
+  { 8818, 1, 286},
+  { 8822, 1, 288},
+  { 8826, 3, 290},
+  { 8834, 1, 294},
+  { 8838, 1, 296},
+  { 8849, 1, 298},
+  { 8866, 0, 300},
+  { 8872, 1, 301},
+  { 8875, 0, 303},
+  { 8882, 3, 304},
+  { 12358, 0, 308},
+  { 12363, 0, 309},
+  { 12365, 0, 310},
+  { 12367, 0, 311},
+  { 12369, 0, 312},
+  { 12371, 0, 313},
+  { 12373, 0, 314},
+  { 12375, 0, 315},
+  { 12377, 0, 316},
+  { 12379, 0, 317},
+  { 12381, 0, 318},
+  { 12383, 0, 319},
+  { 12385, 0, 320},
+  { 12388, 0, 321},
+  { 12390, 0, 322},
+  { 12392, 0, 323},
+  { 12399, 0, 324},
+  { 12402, 0, 325},
+  { 12405, 0, 326},
+  { 12408, 0, 327},
+  { 12411, 0, 328},
+  { 12445, 0, 329},
+  { 12454, 0, 330},
+  { 12459, 0, 331},
+  { 12461, 0, 332},
+  { 12463, 0, 333},
+  { 12465, 0, 334},
+  { 12467, 0, 335},
+  { 12469, 0, 336},
+  { 12471, 0, 337},
+  { 12473, 0, 338},
+  { 12475, 0, 339},
+  { 12477, 0, 340},
+  { 12479, 0, 341},
+  { 12481, 0, 342},
+  { 12484, 0, 343},
+  { 12486, 0, 344},
+  { 12488, 0, 345},
+  { 12495, 0, 346},
+  { 12498, 0, 347},
+  { 12501, 0, 348},
+  { 12504, 0, 349},
+  { 12507, 0, 350},
+  { 12527, 3, 351},
+  { 12541, 0, 355},
+  {0,0,0}
+};
+
+struct reindex nfc_last[] = {
+  { 768, 4, 0},
+  { 774, 6, 5},
+  { 783, 0, 12},
+  { 785, 0, 13},
+  { 787, 1, 14},
+  { 795, 0, 16},
+  { 803, 5, 17},
+  { 813, 1, 23},
+  { 816, 1, 25},
+  { 824, 0, 27},
+  { 834, 0, 28},
+  { 837, 0, 29},
+  { 1619, 2, 30},
+  { 2364, 0, 33},
+  { 2494, 0, 34},
+  { 2519, 0, 35},
+  { 2878, 0, 36},
+  { 2902, 1, 37},
+  { 3006, 0, 39},
+  { 3031, 0, 40},
+  { 3158, 0, 41},
+  { 3266, 0, 42},
+  { 3285, 1, 43},
+  { 3390, 0, 45},
+  { 3415, 0, 46},
+  { 3530, 0, 47},
+  { 3535, 0, 48},
+  { 3551, 0, 49},
+  { 4142, 0, 50},
+  { 12441, 1, 51},
+  {0,0,0}
+};
+
+/* string literals */
+const char *_PyUnicode_CategoryNames[] = {
+    "Cn",
+    "Lu",
+    "Ll",
+    "Lt",
+    "Mn",
+    "Mc",
+    "Me",
+    "Nd",
+    "Nl",
+    "No",
+    "Zs",
+    "Zl",
+    "Zp",
+    "Cc",
+    "Cf",
+    "Cs",
+    "Co",
+    "Cn",
+    "Lm",
+    "Lo",
+    "Pc",
+    "Pd",
+    "Ps",
+    "Pe",
+    "Pi",
+    "Pf",
+    "Po",
+    "Sm",
+    "Sc",
+    "Sk",
+    "So",
+    NULL
+};
+const char *_PyUnicode_BidirectionalNames[] = {
+    "",
+    "L",
+    "LRE",
+    "LRO",
+    "R",
+    "AL",
+    "RLE",
+    "RLO",
+    "PDF",
+    "EN",
+    "ES",
+    "ET",
+    "AN",
+    "CS",
+    "NSM",
+    "BN",
+    "B",
+    "S",
+    "WS",
+    "ON",
+    NULL
+};
+const char *_PyUnicode_EastAsianWidthNames[] = {
+    "F",
+    "H",
+    "W",
+    "Na",
+    "A",
+    "N",
+    NULL
+};
+static const char *decomp_prefix[] = {
+    "",
+    "<noBreak>",
+    "<compat>",
+    "<super>",
+    "<fraction>",
+    "<sub>",
+    "<font>",
+    "<circle>",
+    "<wide>",
+    "<vertical>",
+    "<square>",
+    "<isolated>",
+    "<final>",
+    "<initial>",
+    "<medial>",
+    "<small>",
+    "<narrow>",
+    NULL
+};
+/* index tables for the database records */
+#define SHIFT 8
+static unsigned char index1[] = {
+    0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 
+    21, 22, 23, 24, 25, 26, 8, 8, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 
+    38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 50, 50, 50, 50, 50, 
+    50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 
+    50, 51, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 
+    50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 
+    50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 
+    50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 
+    50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 52, 53, 50, 50, 50, 54, 8, 8, 
+    55, 56, 8, 8, 8, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 
+    50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 
+    50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 57, 58, 58, 58, 58, 58, 58, 
+    58, 58, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 
+    59, 59, 59, 59, 59, 59, 59, 59, 59, 50, 60, 61, 62, 63, 64, 65, 66, 67, 
+    8, 68, 69, 8, 8, 8, 70, 8, 71, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 
+    8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 
+    8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 
+    8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 
+    8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 
+    8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 
+    8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 
+    8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 
+    8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 72, 73, 74, 75, 76, 77, 78, 
+    79, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 
+    8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 50, 50, 50, 50, 50, 
+    50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 
+    50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 
+    50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 
+    50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 
+    50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 
+    50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 
+    50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 
+    50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 
+    50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 80, 
+    8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 
+    8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 
+    8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 
+    8, 8, 8, 8, 8, 8, 8, 8, 8, 50, 50, 81, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 
+    8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 
+    8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 
+    8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 
+    8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 
+    8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 
+    8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 
+    8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 
+    8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 
+    8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 
+    8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 
+    8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 
+    8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 
+    8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 
+    8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 
+    8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 
+    8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 
+    8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 
+    8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 
+    8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 
+    8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 
+    8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 
+    8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 
+    8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 
+    8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 
+    8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 
+    8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 
+    8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 
+    8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 
+    8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 
+    8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 
+    8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 
+    8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 
+    8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 
+    8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 
+    8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 
+    8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 
+    8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 
+    8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 
+    8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 
+    8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 
+    8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 
+    8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 
+    8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 
+    8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 
+    8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 
+    8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 
+    8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 
+    8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 
+    8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 
+    8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 
+    8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 
+    8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 
+    8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 
+    8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 
+    8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 
+    8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 
+    8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 
+    8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 
+    8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 
+    8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 
+    8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 
+    8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 
+    8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 
+    8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 
+    8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 
+    8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 
+    8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 
+    8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 
+    8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 
+    8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 
+    8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 
+    8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 
+    8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 
+    8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 
+    8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 
+    8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 
+    8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 
+    8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 
+    8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 
+    8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 
+    8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 
+    8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 
+    8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 
+    8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 
+    8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 
+    8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 
+    8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 
+    8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 
+    8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 
+    8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 
+    8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 
+    8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 
+    8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 
+    8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 
+    8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 
+    8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 
+    8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 
+    8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 
+    8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 
+    8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 
+    8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 
+    8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 
+    8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 
+    8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 
+    8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 
+    8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 
+    8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 
+    8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 
+    8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 
+    8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 
+    8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 
+    8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 
+    8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 
+    8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 
+    8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 
+    8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 
+    8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 
+    8, 8, 82, 83, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 
+    8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 
+    8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 
+    8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 
+    8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 
+    8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 
+    8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 
+    8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 
+    8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 
+    8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 
+    8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 59, 59, 59, 59, 59, 
+    59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 
+    59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 
+    59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 
+    59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 
+    59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 
+    59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 
+    59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 
+    59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 
+    59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 
+    59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 
+    59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 
+    59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 
+    59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 
+    59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 84, 59, 
+    59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 
+    59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 
+    59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 
+    59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 
+    59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 
+    59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 
+    59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 
+    59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 
+    59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 
+    59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 
+    59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 
+    59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 
+    59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 
+    59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 
+    59, 59, 84, 
+};
+
+static unsigned char index2[] = {
+    1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 3, 2, 4, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 
+    1, 1, 1, 1, 3, 3, 3, 2, 5, 6, 6, 7, 8, 7, 6, 6, 9, 10, 6, 11, 12, 13, 12, 
+    12, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 12, 6, 15, 16, 15, 6, 6, 17, 
+    17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 
+    17, 17, 17, 17, 17, 17, 17, 9, 6, 10, 18, 19, 18, 20, 20, 20, 20, 20, 20, 
+    20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 
+    20, 20, 9, 16, 10, 16, 1, 1, 1, 1, 1, 1, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 
+    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 21, 22, 8, 8, 23, 8, 24, 
+    25, 26, 27, 28, 29, 16, 30, 25, 18, 31, 32, 33, 33, 26, 34, 25, 22, 26, 
+    33, 28, 35, 36, 36, 36, 22, 37, 37, 37, 37, 37, 37, 38, 37, 37, 37, 37, 
+    37, 37, 37, 37, 37, 38, 37, 37, 37, 37, 37, 37, 39, 38, 37, 37, 37, 37, 
+    37, 38, 28, 28, 28, 34, 34, 34, 34, 28, 34, 28, 28, 28, 34, 28, 28, 34, 
+    34, 28, 34, 28, 28, 34, 34, 34, 39, 28, 28, 28, 34, 28, 34, 28, 34, 37, 
+    28, 37, 34, 37, 34, 37, 34, 37, 34, 37, 34, 37, 34, 37, 34, 37, 28, 37, 
+    28, 37, 34, 37, 34, 37, 34, 37, 28, 37, 34, 37, 34, 37, 34, 37, 34, 37, 
+    34, 38, 28, 37, 34, 37, 28, 37, 34, 37, 34, 37, 28, 38, 28, 37, 34, 37, 
+    34, 28, 37, 34, 37, 34, 37, 34, 38, 28, 38, 28, 37, 28, 37, 34, 37, 28, 
+    28, 38, 28, 37, 28, 37, 34, 37, 34, 38, 28, 37, 34, 37, 34, 37, 34, 37, 
+    34, 37, 34, 37, 34, 37, 34, 37, 34, 37, 34, 38, 28, 37, 34, 37, 28, 37, 
+    34, 37, 34, 37, 34, 37, 34, 37, 34, 37, 34, 37, 37, 34, 37, 34, 37, 34, 
+    34, 34, 37, 37, 34, 37, 34, 37, 37, 34, 37, 37, 37, 34, 34, 37, 37, 37, 
+    37, 34, 37, 37, 34, 37, 37, 37, 34, 34, 34, 37, 37, 34, 37, 37, 34, 37, 
+    34, 37, 34, 37, 37, 34, 37, 34, 34, 37, 34, 37, 37, 34, 37, 37, 37, 34, 
+    37, 34, 37, 37, 34, 34, 40, 37, 34, 34, 34, 40, 40, 40, 40, 37, 41, 34, 
+    37, 41, 34, 37, 41, 34, 37, 28, 37, 28, 37, 28, 37, 28, 37, 28, 37, 28, 
+    37, 28, 37, 28, 34, 37, 34, 37, 34, 37, 34, 37, 34, 37, 34, 37, 34, 37, 
+    34, 37, 34, 37, 34, 34, 37, 41, 34, 37, 34, 37, 37, 37, 34, 37, 34, 37, 
+    34, 37, 34, 37, 34, 37, 34, 37, 34, 37, 34, 37, 34, 37, 34, 37, 34, 37, 
+    34, 37, 34, 37, 34, 37, 34, 37, 34, 37, 34, 37, 34, 37, 34, 37, 34, 37, 
+    34, 37, 34, 37, 34, 37, 34, 37, 34, 37, 34, 37, 34, 37, 34, 37, 34, 37, 
+    34, 34, 34, 34, 34, 34, 34, 37, 37, 34, 37, 37, 34, 34, 37, 0, 0, 0, 0, 
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 34, 28, 34, 34, 34, 34, 34, 34, 34, 34, 34, 
+    34, 34, 34, 34, 34, 34, 28, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 
+    34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 
+    34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 
+    34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 
+    34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 42, 42, 42, 42, 42, 
+    42, 42, 42, 42, 43, 43, 42, 42, 42, 42, 42, 42, 42, 44, 44, 26, 44, 43, 
+    45, 43, 45, 45, 45, 43, 45, 43, 43, 46, 42, 44, 44, 44, 44, 44, 44, 26, 
+    26, 26, 26, 44, 26, 44, 26, 42, 42, 42, 42, 42, 44, 44, 44, 44, 44, 44, 
+    44, 44, 44, 42, 44, 44, 44, 44, 44, 44, 44, 44, 44, 44, 44, 44, 44, 44, 
+    44, 44, 44, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 
+    47, 47, 47, 47, 47, 47, 48, 49, 49, 49, 49, 48, 50, 49, 49, 49, 49, 49, 
+    51, 51, 49, 49, 49, 49, 51, 51, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 
+    49, 52, 52, 52, 52, 52, 49, 49, 49, 49, 47, 47, 47, 47, 47, 47, 47, 47, 
+    53, 47, 49, 49, 49, 47, 47, 47, 49, 49, 54, 47, 47, 47, 49, 49, 49, 49, 
+    47, 48, 49, 49, 47, 55, 56, 56, 55, 56, 56, 55, 47, 47, 47, 47, 47, 47, 
+    47, 47, 47, 47, 47, 47, 47, 0, 0, 0, 0, 44, 44, 0, 0, 0, 0, 42, 0, 0, 0, 
+    57, 0, 0, 0, 0, 0, 44, 44, 37, 57, 37, 37, 37, 0, 37, 0, 37, 37, 34, 38, 
+    38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 0, 38, 
+    38, 38, 38, 38, 38, 38, 37, 37, 34, 34, 34, 34, 34, 28, 28, 28, 28, 28, 
+    28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 34, 28, 28, 28, 28, 28, 
+    28, 28, 34, 34, 34, 34, 34, 0, 34, 34, 37, 37, 37, 34, 34, 34, 37, 34, 
+    37, 34, 37, 34, 37, 34, 37, 34, 37, 34, 37, 34, 37, 34, 37, 34, 37, 34, 
+    37, 34, 37, 34, 34, 34, 34, 34, 37, 34, 58, 37, 34, 37, 37, 34, 34, 37, 
+    37, 37, 37, 38, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 
+    38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 
+    38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 28, 28, 28, 28, 
+    28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 
+    28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 34, 28, 34, 34, 34, 34, 34, 34, 
+    34, 34, 34, 34, 34, 34, 34, 34, 37, 34, 37, 34, 37, 34, 37, 34, 37, 34, 
+    37, 34, 37, 34, 37, 34, 37, 34, 37, 34, 37, 34, 37, 34, 37, 34, 37, 34, 
+    37, 34, 37, 34, 37, 34, 59, 60, 60, 60, 60, 0, 61, 61, 37, 34, 37, 34, 
+    37, 34, 37, 34, 37, 34, 37, 34, 37, 34, 37, 34, 37, 34, 37, 34, 37, 34, 
+    37, 34, 37, 34, 37, 34, 37, 34, 37, 34, 37, 34, 37, 34, 37, 34, 37, 34, 
+    37, 34, 37, 34, 37, 34, 37, 34, 37, 34, 37, 34, 37, 34, 37, 37, 34, 37, 
+    34, 37, 34, 37, 34, 37, 34, 37, 34, 37, 34, 0, 37, 34, 37, 34, 37, 34,