Current version: {{ version }}
Get Setuptools from the Python Package Index
Visit the Setuptools project page
setuptools-20.7.0/docs/_theme/ 0000775 0001750 0001750 00000000000 12702524134 017056 5 ustar travis travis 0000000 0000000 setuptools-20.7.0/docs/_theme/nature/ 0000775 0001750 0001750 00000000000 12702524134 020354 5 ustar travis travis 0000000 0000000 setuptools-20.7.0/docs/_theme/nature/static/ 0000775 0001750 0001750 00000000000 12702524134 021643 5 ustar travis travis 0000000 0000000 setuptools-20.7.0/docs/_theme/nature/static/nature.css_t 0000664 0001750 0001750 00000007415 12702524020 024177 0 ustar travis travis 0000000 0000000 /** * Sphinx stylesheet -- default theme * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ */ @import url("basic.css"); /* -- page layout ----------------------------------------------------------- */ body { font-family: Arial, sans-serif; font-size: 100%; background-color: #111111; color: #555555; margin: 0; padding: 0; } div.documentwrapper { float: left; width: 100%; } div.bodywrapper { margin: 0 0 0 300px; } hr{ border: 1px solid #B1B4B6; } div.document { background-color: #fafafa; } div.body { background-color: #ffffff; color: #3E4349; padding: 1em 30px 30px 30px; font-size: 0.9em; } div.footer { color: #555; width: 100%; padding: 13px 0; text-align: center; font-size: 75%; } div.footer a { color: #444444; } div.related { background-color: #6BA81E; line-height: 36px; color: #ffffff; text-shadow: 0px 1px 0 #444444; font-size: 1.1em; } div.related a { color: #E2F3CC; } div.related .right { font-size: 0.9em; } div.sphinxsidebar { font-size: 0.9em; line-height: 1.5em; width: 300px; } div.sphinxsidebarwrapper{ padding: 20px 0; } div.sphinxsidebar h3, div.sphinxsidebar h4 { font-family: Arial, sans-serif; color: #222222; font-size: 1.2em; font-weight: bold; margin: 0; padding: 5px 10px; text-shadow: 1px 1px 0 white } div.sphinxsidebar h3 a { color: #444444; } div.sphinxsidebar p { color: #888888; padding: 5px 20px; margin: 0.5em 0px; } div.sphinxsidebar p.topless { } div.sphinxsidebar ul { margin: 10px 10px 10px 20px; padding: 0; color: #000000; } div.sphinxsidebar a { color: #444444; } div.sphinxsidebar a:hover { color: #E32E00; } div.sphinxsidebar input { border: 1px solid #cccccc; font-family: sans-serif; font-size: 1.1em; padding: 0.15em 0.3em; } div.sphinxsidebar input[type=text]{ margin-left: 20px; } /* -- body styles ----------------------------------------------------------- */ a { color: #005B81; text-decoration: none; } a:hover { color: #E32E00; } div.body h1, div.body h2, div.body h3, div.body h4, div.body h5, div.body h6 { font-family: Arial, sans-serif; font-weight: normal; color: #212224; margin: 30px 0px 10px 0px; padding: 5px 0 5px 0px; text-shadow: 0px 1px 0 white; border-bottom: 1px solid #C8D5E3; } div.body h1 { margin-top: 0; font-size: 200%; } div.body h2 { font-size: 150%; } div.body h3 { font-size: 120%; } div.body h4 { font-size: 110%; } div.body h5 { font-size: 100%; } div.body h6 { font-size: 100%; } a.headerlink { color: #c60f0f; font-size: 0.8em; padding: 0 4px 0 4px; text-decoration: none; } a.headerlink:hover { background-color: #c60f0f; color: white; } div.body p, div.body dd, div.body li { line-height: 1.8em; } div.admonition p.admonition-title + p { display: inline; } div.highlight{ background-color: white; } div.note { background-color: #eeeeee; border: 1px solid #cccccc; } div.seealso { background-color: #ffffcc; border: 1px solid #ffff66; } div.topic { background-color: #fafafa; border-width: 0; } div.warning { background-color: #ffe4e4; border: 1px solid #ff6666; } p.admonition-title { display: inline; } p.admonition-title:after { content: ":"; } pre { padding: 10px; background-color: #fafafa; color: #222222; line-height: 1.5em; font-size: 1.1em; margin: 1.5em 0 1.5em 0; -webkit-box-shadow: 0px 0px 4px #d8d8d8; -moz-box-shadow: 0px 0px 4px #d8d8d8; box-shadow: 0px 0px 4px #d8d8d8; } tt { color: #222222; padding: 1px 2px; font-size: 1.2em; font-family: monospace; } #table-of-contents ul { padding-left: 2em; } setuptools-20.7.0/docs/_theme/nature/static/pygments.css 0000664 0001750 0001750 00000005235 12702524020 024222 0 ustar travis travis 0000000 0000000 .c { color: #999988; font-style: italic } /* Comment */ .k { font-weight: bold } /* Keyword */ .o { font-weight: bold } /* Operator */ .cm { color: #999988; font-style: italic } /* Comment.Multiline */ .cp { color: #999999; font-weight: bold } /* Comment.preproc */ .c1 { color: #999988; font-style: italic } /* Comment.Single */ .gd { color: #000000; background-color: #ffdddd } /* Generic.Deleted */ .ge { font-style: italic } /* Generic.Emph */ .gr { color: #aa0000 } /* Generic.Error */ .gh { color: #999999 } /* Generic.Heading */ .gi { color: #000000; background-color: #ddffdd } /* Generic.Inserted */ .go { color: #111 } /* Generic.Output */ .gp { color: #555555 } /* Generic.Prompt */ .gs { font-weight: bold } /* Generic.Strong */ .gu { color: #aaaaaa } /* Generic.Subheading */ .gt { color: #aa0000 } /* Generic.Traceback */ .kc { font-weight: bold } /* Keyword.Constant */ .kd { font-weight: bold } /* Keyword.Declaration */ .kp { font-weight: bold } /* Keyword.Pseudo */ .kr { font-weight: bold } /* Keyword.Reserved */ .kt { color: #445588; font-weight: bold } /* Keyword.Type */ .m { color: #009999 } /* Literal.Number */ .s { color: #bb8844 } /* Literal.String */ .na { color: #008080 } /* Name.Attribute */ .nb { color: #999999 } /* Name.Builtin */ .nc { color: #445588; font-weight: bold } /* Name.Class */ .no { color: #ff99ff } /* Name.Constant */ .ni { color: #800080 } /* Name.Entity */ .ne { color: #990000; font-weight: bold } /* Name.Exception */ .nf { color: #990000; font-weight: bold } /* Name.Function */ .nn { color: #555555 } /* Name.Namespace */ .nt { color: #000080 } /* Name.Tag */ .nv { color: purple } /* Name.Variable */ .ow { font-weight: bold } /* Operator.Word */ .mf { color: #009999 } /* Literal.Number.Float */ .mh { color: #009999 } /* Literal.Number.Hex */ .mi { color: #009999 } /* Literal.Number.Integer */ .mo { color: #009999 } /* Literal.Number.Oct */ .sb { color: #bb8844 } /* Literal.String.Backtick */ .sc { color: #bb8844 } /* Literal.String.Char */ .sd { color: #bb8844 } /* Literal.String.Doc */ .s2 { color: #bb8844 } /* Literal.String.Double */ .se { color: #bb8844 } /* Literal.String.Escape */ .sh { color: #bb8844 } /* Literal.String.Heredoc */ .si { color: #bb8844 } /* Literal.String.Interpol */ .sx { color: #bb8844 } /* Literal.String.Other */ .sr { color: #808000 } /* Literal.String.Regex */ .s1 { color: #bb8844 } /* Literal.String.Single */ .ss { color: #bb8844 } /* Literal.String.Symbol */ .bp { color: #999999 } /* Name.Builtin.Pseudo */ .vc { color: #ff99ff } /* Name.Variable.Class */ .vg { color: #ff99ff } /* Name.Variable.Global */ .vi { color: #ff99ff } /* Name.Variable.Instance */ .il { color: #009999 } /* Literal.Number.Integer.Long */ setuptools-20.7.0/docs/_theme/nature/theme.conf 0000664 0001750 0001750 00000000107 12702524020 022315 0 ustar travis travis 0000000 0000000 [theme] inherit = basic stylesheet = nature.css pygments_style = tango setuptools-20.7.0/docs/Makefile 0000664 0001750 0001750 00000004443 12702524020 017254 0 ustar travis travis 0000000 0000000 # Makefile for Sphinx documentation # # You can set these variables from the command line. SPHINXOPTS = SPHINXBUILD = sphinx-build PAPER = # Internal variables. PAPEROPT_a4 = -D latex_paper_size=a4 PAPEROPT_letter = -D latex_paper_size=letter ALLSPHINXOPTS = -d build/doctrees $(PAPEROPT_$(PAPER)) $(SPHINXOPTS) . .PHONY: help clean html web pickle htmlhelp latex changes linkcheck help: @echo "Please use \`make # pre-release
[-_\.]?
(?P(a|b|c|rc|alpha|beta|pre|preview))
[-_\.]?
(?P[0-9]+)?
)?
(?P # post release
(?:-(?P[0-9]+))
|
(?:
[-_\.]?
(?Ppost|rev|r)
[-_\.]?
(?P[0-9]+)?
)
)?
(?P # dev release
[-_\.]?
(?Pdev)
[-_\.]?
(?P[0-9]+)?
)?
)
(?:\+(?P[a-z0-9]+(?:[-_\.][a-z0-9]+)*))? # local version
"""
class Version(_BaseVersion):
_regex = re.compile(
r"^\s*" + VERSION_PATTERN + r"\s*$",
re.VERBOSE | re.IGNORECASE,
)
def __init__(self, version):
# Validate the version and parse it into pieces
match = self._regex.search(version)
if not match:
raise InvalidVersion("Invalid version: '{0}'".format(version))
# Store the parsed out pieces of the version
self._version = _Version(
epoch=int(match.group("epoch")) if match.group("epoch") else 0,
release=tuple(int(i) for i in match.group("release").split(".")),
pre=_parse_letter_version(
match.group("pre_l"),
match.group("pre_n"),
),
post=_parse_letter_version(
match.group("post_l"),
match.group("post_n1") or match.group("post_n2"),
),
dev=_parse_letter_version(
match.group("dev_l"),
match.group("dev_n"),
),
local=_parse_local_version(match.group("local")),
)
# Generate a key which will be used for sorting
self._key = _cmpkey(
self._version.epoch,
self._version.release,
self._version.pre,
self._version.post,
self._version.dev,
self._version.local,
)
def __repr__(self):
return "".format(repr(str(self)))
def __str__(self):
parts = []
# Epoch
if self._version.epoch != 0:
parts.append("{0}!".format(self._version.epoch))
# Release segment
parts.append(".".join(str(x) for x in self._version.release))
# Pre-release
if self._version.pre is not None:
parts.append("".join(str(x) for x in self._version.pre))
# Post-release
if self._version.post is not None:
parts.append(".post{0}".format(self._version.post[1]))
# Development release
if self._version.dev is not None:
parts.append(".dev{0}".format(self._version.dev[1]))
# Local version segment
if self._version.local is not None:
parts.append(
"+{0}".format(".".join(str(x) for x in self._version.local))
)
return "".join(parts)
@property
def public(self):
return str(self).split("+", 1)[0]
@property
def base_version(self):
parts = []
# Epoch
if self._version.epoch != 0:
parts.append("{0}!".format(self._version.epoch))
# Release segment
parts.append(".".join(str(x) for x in self._version.release))
return "".join(parts)
@property
def local(self):
version_string = str(self)
if "+" in version_string:
return version_string.split("+", 1)[1]
@property
def is_prerelease(self):
return bool(self._version.dev or self._version.pre)
@property
def is_postrelease(self):
return bool(self._version.post)
def _parse_letter_version(letter, number):
if letter:
# We consider there to be an implicit 0 in a pre-release if there is
# not a numeral associated with it.
if number is None:
number = 0
# We normalize any letters to their lower case form
letter = letter.lower()
# We consider some words to be alternate spellings of other words and
# in those cases we want to normalize the spellings to our preferred
# spelling.
if letter == "alpha":
letter = "a"
elif letter == "beta":
letter = "b"
elif letter in ["c", "pre", "preview"]:
letter = "rc"
elif letter in ["rev", "r"]:
letter = "post"
return letter, int(number)
if not letter and number:
# We assume if we are given a number, but we are not given a letter
# then this is using the implicit post release syntax (e.g. 1.0-1)
letter = "post"
return letter, int(number)
_local_version_seperators = re.compile(r"[\._-]")
def _parse_local_version(local):
"""
Takes a string like abc.1.twelve and turns it into ("abc", 1, "twelve").
"""
if local is not None:
return tuple(
part.lower() if not part.isdigit() else int(part)
for part in _local_version_seperators.split(local)
)
def _cmpkey(epoch, release, pre, post, dev, local):
# When we compare a release version, we want to compare it with all of the
# trailing zeros removed. So we'll use a reverse the list, drop all the now
# leading zeros until we come to something non zero, then take the rest
# re-reverse it back into the correct order and make it a tuple and use
# that for our sorting key.
release = tuple(
reversed(list(
itertools.dropwhile(
lambda x: x == 0,
reversed(release),
)
))
)
# We need to "trick" the sorting algorithm to put 1.0.dev0 before 1.0a0.
# We'll do this by abusing the pre segment, but we _only_ want to do this
# if there is not a pre or a post segment. If we have one of those then
# the normal sorting rules will handle this case correctly.
if pre is None and post is None and dev is not None:
pre = -Infinity
# Versions without a pre-release (except as noted above) should sort after
# those with one.
elif pre is None:
pre = Infinity
# Versions without a post segment should sort before those with one.
if post is None:
post = -Infinity
# Versions without a development segment should sort after those with one.
if dev is None:
dev = Infinity
if local is None:
# Versions without a local segment should sort before those with one.
local = -Infinity
else:
# Versions with a local segment need that segment parsed to implement
# the sorting rules in PEP440.
# - Alpha numeric segments sort before numeric segments
# - Alpha numeric segments sort lexicographically
# - Numeric segments sort numerically
# - Shorter versions sort before longer versions when the prefixes
# match exactly
local = tuple(
(i, "") if isinstance(i, int) else (-Infinity, i)
for i in local
)
return epoch, release, pre, post, dev, local
setuptools-20.7.0/pkg_resources/_vendor/__init__.py 0000664 0001750 0001750 00000000000 12702524020 023265 0 ustar travis travis 0000000 0000000 setuptools-20.7.0/pkg_resources/_vendor/pyparsing.py 0000664 0001750 0001750 00000471251 12702524020 023566 0 ustar travis travis 0000000 0000000 # module pyparsing.py
#
# Copyright (c) 2003-2015 Paul T. McGuire
#
# Permission is hereby granted, free of charge, to any person obtaining
# a copy of this software and associated documentation files (the
# "Software"), to deal in the Software without restriction, including
# without limitation the rights to use, copy, modify, merge, publish,
# distribute, sublicense, and/or sell copies of the Software, and to
# permit persons to whom the Software is furnished to do so, subject to
# the following conditions:
#
# The above copyright notice and this permission notice shall be
# included in all copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
# IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
# CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
# TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
# SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
#
__doc__ = \
"""
pyparsing module - Classes and methods to define and execute parsing grammars
The pyparsing module is an alternative approach to creating and executing simple grammars,
vs. the traditional lex/yacc approach, or the use of regular expressions. With pyparsing, you
don't need to learn a new syntax for defining grammars or matching expressions - the parsing module
provides a library of classes that you use to construct the grammar directly in Python.
Here is a program to parse "Hello, World!" (or any greeting of the form C{", !"})::
from pyparsing import Word, alphas
# define grammar of a greeting
greet = Word( alphas ) + "," + Word( alphas ) + "!"
hello = "Hello, World!"
print (hello, "->", greet.parseString( hello ))
The program outputs the following::
Hello, World! -> ['Hello', ',', 'World', '!']
The Python representation of the grammar is quite readable, owing to the self-explanatory
class names, and the use of '+', '|' and '^' operators.
The parsed results returned from C{parseString()} can be accessed as a nested list, a dictionary, or an
object with named attributes.
The pyparsing module handles some of the problems that are typically vexing when writing text parsers:
- extra or missing whitespace (the above program will also handle "Hello,World!", "Hello , World !", etc.)
- quoted strings
- embedded comments
"""
__version__ = "2.0.6"
__versionTime__ = "9 Nov 2015 19:03"
__author__ = "Paul McGuire "
import string
from weakref import ref as wkref
import copy
import sys
import warnings
import re
import sre_constants
import collections
import pprint
import functools
import itertools
#~ sys.stderr.write( "testing pyparsing module, version %s, %s\n" % (__version__,__versionTime__ ) )
__all__ = [
'And', 'CaselessKeyword', 'CaselessLiteral', 'CharsNotIn', 'Combine', 'Dict', 'Each', 'Empty',
'FollowedBy', 'Forward', 'GoToColumn', 'Group', 'Keyword', 'LineEnd', 'LineStart', 'Literal',
'MatchFirst', 'NoMatch', 'NotAny', 'OneOrMore', 'OnlyOnce', 'Optional', 'Or',
'ParseBaseException', 'ParseElementEnhance', 'ParseException', 'ParseExpression', 'ParseFatalException',
'ParseResults', 'ParseSyntaxException', 'ParserElement', 'QuotedString', 'RecursiveGrammarException',
'Regex', 'SkipTo', 'StringEnd', 'StringStart', 'Suppress', 'Token', 'TokenConverter', 'Upcase',
'White', 'Word', 'WordEnd', 'WordStart', 'ZeroOrMore',
'alphanums', 'alphas', 'alphas8bit', 'anyCloseTag', 'anyOpenTag', 'cStyleComment', 'col',
'commaSeparatedList', 'commonHTMLEntity', 'countedArray', 'cppStyleComment', 'dblQuotedString',
'dblSlashComment', 'delimitedList', 'dictOf', 'downcaseTokens', 'empty', 'hexnums',
'htmlComment', 'javaStyleComment', 'keepOriginalText', 'line', 'lineEnd', 'lineStart', 'lineno',
'makeHTMLTags', 'makeXMLTags', 'matchOnlyAtCol', 'matchPreviousExpr', 'matchPreviousLiteral',
'nestedExpr', 'nullDebugAction', 'nums', 'oneOf', 'opAssoc', 'operatorPrecedence', 'printables',
'punc8bit', 'pythonStyleComment', 'quotedString', 'removeQuotes', 'replaceHTMLEntity',
'replaceWith', 'restOfLine', 'sglQuotedString', 'srange', 'stringEnd',
'stringStart', 'traceParseAction', 'unicodeString', 'upcaseTokens', 'withAttribute',
'indentedBlock', 'originalTextFor', 'ungroup', 'infixNotation','locatedExpr', 'withClass',
]
PY_3 = sys.version.startswith('3')
if PY_3:
_MAX_INT = sys.maxsize
basestring = str
unichr = chr
_ustr = str
# build list of single arg builtins, that can be used as parse actions
singleArgBuiltins = [sum, len, sorted, reversed, list, tuple, set, any, all, min, max]
else:
_MAX_INT = sys.maxint
range = xrange
def _ustr(obj):
"""Drop-in replacement for str(obj) that tries to be Unicode friendly. It first tries
str(obj). If that fails with a UnicodeEncodeError, then it tries unicode(obj). It
then < returns the unicode object | encodes it with the default encoding | ... >.
"""
if isinstance(obj,unicode):
return obj
try:
# If this works, then _ustr(obj) has the same behaviour as str(obj), so
# it won't break any existing code.
return str(obj)
except UnicodeEncodeError:
# The Python docs (http://docs.python.org/ref/customization.html#l2h-182)
# state that "The return value must be a string object". However, does a
# unicode object (being a subclass of basestring) count as a "string
# object"?
# If so, then return a unicode object:
return unicode(obj)
# Else encode it... but how? There are many choices... :)
# Replace unprintables with escape codes?
#return unicode(obj).encode(sys.getdefaultencoding(), 'backslashreplace_errors')
# Replace unprintables with question marks?
#return unicode(obj).encode(sys.getdefaultencoding(), 'replace')
# ...
# build list of single arg builtins, tolerant of Python version, that can be used as parse actions
singleArgBuiltins = []
import __builtin__
for fname in "sum len sorted reversed list tuple set any all min max".split():
try:
singleArgBuiltins.append(getattr(__builtin__,fname))
except AttributeError:
continue
_generatorType = type((y for y in range(1)))
def _xml_escape(data):
"""Escape &, <, >, ", ', etc. in a string of data."""
# ampersand must be replaced first
from_symbols = '&><"\''
to_symbols = ('&'+s+';' for s in "amp gt lt quot apos".split())
for from_,to_ in zip(from_symbols, to_symbols):
data = data.replace(from_, to_)
return data
class _Constants(object):
pass
alphas = string.ascii_lowercase + string.ascii_uppercase
nums = "0123456789"
hexnums = nums + "ABCDEFabcdef"
alphanums = alphas + nums
_bslash = chr(92)
printables = "".join(c for c in string.printable if c not in string.whitespace)
class ParseBaseException(Exception):
"""base exception class for all parsing runtime exceptions"""
# Performance tuning: we construct a *lot* of these, so keep this
# constructor as small and fast as possible
def __init__( self, pstr, loc=0, msg=None, elem=None ):
self.loc = loc
if msg is None:
self.msg = pstr
self.pstr = ""
else:
self.msg = msg
self.pstr = pstr
self.parserElement = elem
def __getattr__( self, aname ):
"""supported attributes by name are:
- lineno - returns the line number of the exception text
- col - returns the column number of the exception text
- line - returns the line containing the exception text
"""
if( aname == "lineno" ):
return lineno( self.loc, self.pstr )
elif( aname in ("col", "column") ):
return col( self.loc, self.pstr )
elif( aname == "line" ):
return line( self.loc, self.pstr )
else:
raise AttributeError(aname)
def __str__( self ):
return "%s (at char %d), (line:%d, col:%d)" % \
( self.msg, self.loc, self.lineno, self.column )
def __repr__( self ):
return _ustr(self)
def markInputline( self, markerString = ">!<" ):
"""Extracts the exception line from the input string, and marks
the location of the exception with a special symbol.
"""
line_str = self.line
line_column = self.column - 1
if markerString:
line_str = "".join((line_str[:line_column],
markerString, line_str[line_column:]))
return line_str.strip()
def __dir__(self):
return "loc msg pstr parserElement lineno col line " \
"markInputline __str__ __repr__".split()
class ParseException(ParseBaseException):
"""exception thrown when parse expressions don't match class;
supported attributes by name are:
- lineno - returns the line number of the exception text
- col - returns the column number of the exception text
- line - returns the line containing the exception text
"""
pass
class ParseFatalException(ParseBaseException):
"""user-throwable exception thrown when inconsistent parse content
is found; stops all parsing immediately"""
pass
class ParseSyntaxException(ParseFatalException):
"""just like C{L{ParseFatalException}}, but thrown internally when an
C{L{ErrorStop}} ('-' operator) indicates that parsing is to stop immediately because
an unbacktrackable syntax error has been found"""
def __init__(self, pe):
super(ParseSyntaxException, self).__init__(
pe.pstr, pe.loc, pe.msg, pe.parserElement)
#~ class ReparseException(ParseBaseException):
#~ """Experimental class - parse actions can raise this exception to cause
#~ pyparsing to reparse the input string:
#~ - with a modified input string, and/or
#~ - with a modified start location
#~ Set the values of the ReparseException in the constructor, and raise the
#~ exception in a parse action to cause pyparsing to use the new string/location.
#~ Setting the values as None causes no change to be made.
#~ """
#~ def __init_( self, newstring, restartLoc ):
#~ self.newParseText = newstring
#~ self.reparseLoc = restartLoc
class RecursiveGrammarException(Exception):
"""exception thrown by C{validate()} if the grammar could be improperly recursive"""
def __init__( self, parseElementList ):
self.parseElementTrace = parseElementList
def __str__( self ):
return "RecursiveGrammarException: %s" % self.parseElementTrace
class _ParseResultsWithOffset(object):
def __init__(self,p1,p2):
self.tup = (p1,p2)
def __getitem__(self,i):
return self.tup[i]
def __repr__(self):
return repr(self.tup)
def setOffset(self,i):
self.tup = (self.tup[0],i)
class ParseResults(object):
"""Structured parse results, to provide multiple means of access to the parsed data:
- as a list (C{len(results)})
- by list index (C{results[0], results[1]}, etc.)
- by attribute (C{results.})
"""
def __new__(cls, toklist, name=None, asList=True, modal=True ):
if isinstance(toklist, cls):
return toklist
retobj = object.__new__(cls)
retobj.__doinit = True
return retobj
# Performance tuning: we construct a *lot* of these, so keep this
# constructor as small and fast as possible
def __init__( self, toklist, name=None, asList=True, modal=True, isinstance=isinstance ):
if self.__doinit:
self.__doinit = False
self.__name = None
self.__parent = None
self.__accumNames = {}
if isinstance(toklist, list):
self.__toklist = toklist[:]
elif isinstance(toklist, _generatorType):
self.__toklist = list(toklist)
else:
self.__toklist = [toklist]
self.__tokdict = dict()
if name is not None and name:
if not modal:
self.__accumNames[name] = 0
if isinstance(name,int):
name = _ustr(name) # will always return a str, but use _ustr for consistency
self.__name = name
if not (isinstance(toklist, (type(None), basestring, list)) and toklist in (None,'',[])):
if isinstance(toklist,basestring):
toklist = [ toklist ]
if asList:
if isinstance(toklist,ParseResults):
self[name] = _ParseResultsWithOffset(toklist.copy(),0)
else:
self[name] = _ParseResultsWithOffset(ParseResults(toklist[0]),0)
self[name].__name = name
else:
try:
self[name] = toklist[0]
except (KeyError,TypeError,IndexError):
self[name] = toklist
def __getitem__( self, i ):
if isinstance( i, (int,slice) ):
return self.__toklist[i]
else:
if i not in self.__accumNames:
return self.__tokdict[i][-1][0]
else:
return ParseResults([ v[0] for v in self.__tokdict[i] ])
def __setitem__( self, k, v, isinstance=isinstance ):
if isinstance(v,_ParseResultsWithOffset):
self.__tokdict[k] = self.__tokdict.get(k,list()) + [v]
sub = v[0]
elif isinstance(k,int):
self.__toklist[k] = v
sub = v
else:
self.__tokdict[k] = self.__tokdict.get(k,list()) + [_ParseResultsWithOffset(v,0)]
sub = v
if isinstance(sub,ParseResults):
sub.__parent = wkref(self)
def __delitem__( self, i ):
if isinstance(i,(int,slice)):
mylen = len( self.__toklist )
del self.__toklist[i]
# convert int to slice
if isinstance(i, int):
if i < 0:
i += mylen
i = slice(i, i+1)
# get removed indices
removed = list(range(*i.indices(mylen)))
removed.reverse()
# fixup indices in token dictionary
#~ for name in self.__tokdict:
#~ occurrences = self.__tokdict[name]
#~ for j in removed:
#~ for k, (value, position) in enumerate(occurrences):
#~ occurrences[k] = _ParseResultsWithOffset(value, position - (position > j))
for name,occurrences in self.__tokdict.items():
for j in removed:
for k, (value, position) in enumerate(occurrences):
occurrences[k] = _ParseResultsWithOffset(value, position - (position > j))
else:
del self.__tokdict[i]
def __contains__( self, k ):
return k in self.__tokdict
def __len__( self ): return len( self.__toklist )
def __bool__(self): return len( self.__toklist ) > 0
__nonzero__ = __bool__
def __iter__( self ): return iter( self.__toklist )
def __reversed__( self ): return iter( self.__toklist[::-1] )
def iterkeys( self ):
"""Returns all named result keys."""
if hasattr(self.__tokdict, "iterkeys"):
return self.__tokdict.iterkeys()
else:
return iter(self.__tokdict)
def itervalues( self ):
"""Returns all named result values."""
return (self[k] for k in self.iterkeys())
def iteritems( self ):
return ((k, self[k]) for k in self.iterkeys())
if PY_3:
keys = iterkeys
values = itervalues
items = iteritems
else:
def keys( self ):
"""Returns all named result keys."""
return list(self.iterkeys())
def values( self ):
"""Returns all named result values."""
return list(self.itervalues())
def items( self ):
"""Returns all named result keys and values as a list of tuples."""
return list(self.iteritems())
def haskeys( self ):
"""Since keys() returns an iterator, this method is helpful in bypassing
code that looks for the existence of any defined results names."""
return bool(self.__tokdict)
def pop( self, *args, **kwargs):
"""Removes and returns item at specified index (default=last).
Supports both list and dict semantics for pop(). If passed no
argument or an integer argument, it will use list semantics
and pop tokens from the list of parsed tokens. If passed a
non-integer argument (most likely a string), it will use dict
semantics and pop the corresponding value from any defined
results names. A second default return value argument is
supported, just as in dict.pop()."""
if not args:
args = [-1]
for k,v in kwargs.items():
if k == 'default':
args = (args[0], v)
else:
raise TypeError("pop() got an unexpected keyword argument '%s'" % k)
if (isinstance(args[0], int) or
len(args) == 1 or
args[0] in self):
index = args[0]
ret = self[index]
del self[index]
return ret
else:
defaultvalue = args[1]
return defaultvalue
def get(self, key, defaultValue=None):
"""Returns named result matching the given key, or if there is no
such name, then returns the given C{defaultValue} or C{None} if no
C{defaultValue} is specified."""
if key in self:
return self[key]
else:
return defaultValue
def insert( self, index, insStr ):
"""Inserts new element at location index in the list of parsed tokens."""
self.__toklist.insert(index, insStr)
# fixup indices in token dictionary
#~ for name in self.__tokdict:
#~ occurrences = self.__tokdict[name]
#~ for k, (value, position) in enumerate(occurrences):
#~ occurrences[k] = _ParseResultsWithOffset(value, position + (position > index))
for name,occurrences in self.__tokdict.items():
for k, (value, position) in enumerate(occurrences):
occurrences[k] = _ParseResultsWithOffset(value, position + (position > index))
def append( self, item ):
"""Add single element to end of ParseResults list of elements."""
self.__toklist.append(item)
def extend( self, itemseq ):
"""Add sequence of elements to end of ParseResults list of elements."""
if isinstance(itemseq, ParseResults):
self += itemseq
else:
self.__toklist.extend(itemseq)
def clear( self ):
"""Clear all elements and results names."""
del self.__toklist[:]
self.__tokdict.clear()
def __getattr__( self, name ):
try:
return self[name]
except KeyError:
return ""
if name in self.__tokdict:
if name not in self.__accumNames:
return self.__tokdict[name][-1][0]
else:
return ParseResults([ v[0] for v in self.__tokdict[name] ])
else:
return ""
def __add__( self, other ):
ret = self.copy()
ret += other
return ret
def __iadd__( self, other ):
if other.__tokdict:
offset = len(self.__toklist)
addoffset = lambda a: offset if a<0 else a+offset
otheritems = other.__tokdict.items()
otherdictitems = [(k, _ParseResultsWithOffset(v[0],addoffset(v[1])) )
for (k,vlist) in otheritems for v in vlist]
for k,v in otherdictitems:
self[k] = v
if isinstance(v[0],ParseResults):
v[0].__parent = wkref(self)
self.__toklist += other.__toklist
self.__accumNames.update( other.__accumNames )
return self
def __radd__(self, other):
if isinstance(other,int) and other == 0:
return self.copy()
def __repr__( self ):
return "(%s, %s)" % ( repr( self.__toklist ), repr( self.__tokdict ) )
def __str__( self ):
return '[' + ', '.join(_ustr(i) if isinstance(i, ParseResults) else repr(i) for i in self.__toklist) + ']'
def _asStringList( self, sep='' ):
out = []
for item in self.__toklist:
if out and sep:
out.append(sep)
if isinstance( item, ParseResults ):
out += item._asStringList()
else:
out.append( _ustr(item) )
return out
def asList( self ):
"""Returns the parse results as a nested list of matching tokens, all converted to strings."""
return [res.asList() if isinstance(res,ParseResults) else res for res in self.__toklist]
def asDict( self ):
"""Returns the named parse results as dictionary."""
if PY_3:
return dict( self.items() )
else:
return dict( self.iteritems() )
def copy( self ):
"""Returns a new copy of a C{ParseResults} object."""
ret = ParseResults( self.__toklist )
ret.__tokdict = self.__tokdict.copy()
ret.__parent = self.__parent
ret.__accumNames.update( self.__accumNames )
ret.__name = self.__name
return ret
def asXML( self, doctag=None, namedItemsOnly=False, indent="", formatted=True ):
"""Returns the parse results as XML. Tags are created for tokens and lists that have defined results names."""
nl = "\n"
out = []
namedItems = dict((v[1],k) for (k,vlist) in self.__tokdict.items()
for v in vlist)
nextLevelIndent = indent + " "
# collapse out indents if formatting is not desired
if not formatted:
indent = ""
nextLevelIndent = ""
nl = ""
selfTag = None
if doctag is not None:
selfTag = doctag
else:
if self.__name:
selfTag = self.__name
if not selfTag:
if namedItemsOnly:
return ""
else:
selfTag = "ITEM"
out += [ nl, indent, "<", selfTag, ">" ]
for i,res in enumerate(self.__toklist):
if isinstance(res,ParseResults):
if i in namedItems:
out += [ res.asXML(namedItems[i],
namedItemsOnly and doctag is None,
nextLevelIndent,
formatted)]
else:
out += [ res.asXML(None,
namedItemsOnly and doctag is None,
nextLevelIndent,
formatted)]
else:
# individual token, see if there is a name for it
resTag = None
if i in namedItems:
resTag = namedItems[i]
if not resTag:
if namedItemsOnly:
continue
else:
resTag = "ITEM"
xmlBodyText = _xml_escape(_ustr(res))
out += [ nl, nextLevelIndent, "<", resTag, ">",
xmlBodyText,
"" ]
out += [ nl, indent, "" ]
return "".join(out)
def __lookup(self,sub):
for k,vlist in self.__tokdict.items():
for v,loc in vlist:
if sub is v:
return k
return None
def getName(self):
"""Returns the results name for this token expression."""
if self.__name:
return self.__name
elif self.__parent:
par = self.__parent()
if par:
return par.__lookup(self)
else:
return None
elif (len(self) == 1 and
len(self.__tokdict) == 1 and
self.__tokdict.values()[0][0][1] in (0,-1)):
return self.__tokdict.keys()[0]
else:
return None
def dump(self,indent='',depth=0):
"""Diagnostic method for listing out the contents of a C{ParseResults}.
Accepts an optional C{indent} argument so that this string can be embedded
in a nested display of other data."""
out = []
NL = '\n'
out.append( indent+_ustr(self.asList()) )
if self.haskeys():
items = sorted(self.items())
for k,v in items:
if out:
out.append(NL)
out.append( "%s%s- %s: " % (indent,(' '*depth), k) )
if isinstance(v,ParseResults):
if v:
out.append( v.dump(indent,depth+1) )
else:
out.append(_ustr(v))
else:
out.append(_ustr(v))
elif any(isinstance(vv,ParseResults) for vv in self):
v = self
for i,vv in enumerate(v):
if isinstance(vv,ParseResults):
out.append("\n%s%s[%d]:\n%s%s%s" % (indent,(' '*(depth)),i,indent,(' '*(depth+1)),vv.dump(indent,depth+1) ))
else:
out.append("\n%s%s[%d]:\n%s%s%s" % (indent,(' '*(depth)),i,indent,(' '*(depth+1)),_ustr(vv)))
return "".join(out)
def pprint(self, *args, **kwargs):
"""Pretty-printer for parsed results as a list, using the C{pprint} module.
Accepts additional positional or keyword args as defined for the
C{pprint.pprint} method. (U{http://docs.python.org/3/library/pprint.html#pprint.pprint})"""
pprint.pprint(self.asList(), *args, **kwargs)
# add support for pickle protocol
def __getstate__(self):
return ( self.__toklist,
( self.__tokdict.copy(),
self.__parent is not None and self.__parent() or None,
self.__accumNames,
self.__name ) )
def __setstate__(self,state):
self.__toklist = state[0]
(self.__tokdict,
par,
inAccumNames,
self.__name) = state[1]
self.__accumNames = {}
self.__accumNames.update(inAccumNames)
if par is not None:
self.__parent = wkref(par)
else:
self.__parent = None
def __dir__(self):
return dir(super(ParseResults,self)) + list(self.keys())
collections.MutableMapping.register(ParseResults)
def col (loc,strg):
"""Returns current column within a string, counting newlines as line separators.
The first column is number 1.
Note: the default parsing behavior is to expand tabs in the input string
before starting the parsing process. See L{I{ParserElement.parseString}} for more information
on parsing strings containing C{}s, and suggested methods to maintain a
consistent view of the parsed string, the parse location, and line and column
positions within the parsed string.
"""
s = strg
return 1 if loc} for more information
on parsing strings containing C{}s, and suggested methods to maintain a
consistent view of the parsed string, the parse location, and line and column
positions within the parsed string.
"""
return strg.count("\n",0,loc) + 1
def line( loc, strg ):
"""Returns the line of text containing loc within a string, counting newlines as line separators.
"""
lastCR = strg.rfind("\n", 0, loc)
nextCR = strg.find("\n", loc)
if nextCR >= 0:
return strg[lastCR+1:nextCR]
else:
return strg[lastCR+1:]
def _defaultStartDebugAction( instring, loc, expr ):
print (("Match " + _ustr(expr) + " at loc " + _ustr(loc) + "(%d,%d)" % ( lineno(loc,instring), col(loc,instring) )))
def _defaultSuccessDebugAction( instring, startloc, endloc, expr, toks ):
print ("Matched " + _ustr(expr) + " -> " + str(toks.asList()))
def _defaultExceptionDebugAction( instring, loc, expr, exc ):
print ("Exception raised:" + _ustr(exc))
def nullDebugAction(*args):
"""'Do-nothing' debug action, to suppress debugging output during parsing."""
pass
# Only works on Python 3.x - nonlocal is toxic to Python 2 installs
#~ 'decorator to trim function calls to match the arity of the target'
#~ def _trim_arity(func, maxargs=3):
#~ if func in singleArgBuiltins:
#~ return lambda s,l,t: func(t)
#~ limit = 0
#~ foundArity = False
#~ def wrapper(*args):
#~ nonlocal limit,foundArity
#~ while 1:
#~ try:
#~ ret = func(*args[limit:])
#~ foundArity = True
#~ return ret
#~ except TypeError:
#~ if limit == maxargs or foundArity:
#~ raise
#~ limit += 1
#~ continue
#~ return wrapper
# this version is Python 2.x-3.x cross-compatible
'decorator to trim function calls to match the arity of the target'
def _trim_arity(func, maxargs=2):
if func in singleArgBuiltins:
return lambda s,l,t: func(t)
limit = [0]
foundArity = [False]
def wrapper(*args):
while 1:
try:
ret = func(*args[limit[0]:])
foundArity[0] = True
return ret
except TypeError:
if limit[0] <= maxargs and not foundArity[0]:
limit[0] += 1
continue
raise
return wrapper
class ParserElement(object):
"""Abstract base level parser element class."""
DEFAULT_WHITE_CHARS = " \n\t\r"
verbose_stacktrace = False
@staticmethod
def setDefaultWhitespaceChars( chars ):
"""Overrides the default whitespace chars
"""
ParserElement.DEFAULT_WHITE_CHARS = chars
@staticmethod
def inlineLiteralsUsing(cls):
"""
Set class to be used for inclusion of string literals into a parser.
"""
ParserElement.literalStringClass = cls
def __init__( self, savelist=False ):
self.parseAction = list()
self.failAction = None
#~ self.name = "" # don't define self.name, let subclasses try/except upcall
self.strRepr = None
self.resultsName = None
self.saveAsList = savelist
self.skipWhitespace = True
self.whiteChars = ParserElement.DEFAULT_WHITE_CHARS
self.copyDefaultWhiteChars = True
self.mayReturnEmpty = False # used when checking for left-recursion
self.keepTabs = False
self.ignoreExprs = list()
self.debug = False
self.streamlined = False
self.mayIndexError = True # used to optimize exception handling for subclasses that don't advance parse index
self.errmsg = ""
self.modalResults = True # used to mark results names as modal (report only last) or cumulative (list all)
self.debugActions = ( None, None, None ) #custom debug actions
self.re = None
self.callPreparse = True # used to avoid redundant calls to preParse
self.callDuringTry = False
def copy( self ):
"""Make a copy of this C{ParserElement}. Useful for defining different parse actions
for the same parsing pattern, using copies of the original parse element."""
cpy = copy.copy( self )
cpy.parseAction = self.parseAction[:]
cpy.ignoreExprs = self.ignoreExprs[:]
if self.copyDefaultWhiteChars:
cpy.whiteChars = ParserElement.DEFAULT_WHITE_CHARS
return cpy
def setName( self, name ):
"""Define name for this expression, for use in debugging."""
self.name = name
self.errmsg = "Expected " + self.name
if hasattr(self,"exception"):
self.exception.msg = self.errmsg
return self
def setResultsName( self, name, listAllMatches=False ):
"""Define name for referencing matching tokens as a nested attribute
of the returned parse results.
NOTE: this returns a *copy* of the original C{ParserElement} object;
this is so that the client can define a basic element, such as an
integer, and reference it in multiple places with different names.
You can also set results names using the abbreviated syntax,
C{expr("name")} in place of C{expr.setResultsName("name")} -
see L{I{__call__}<__call__>}.
"""
newself = self.copy()
if name.endswith("*"):
name = name[:-1]
listAllMatches=True
newself.resultsName = name
newself.modalResults = not listAllMatches
return newself
def setBreak(self,breakFlag = True):
"""Method to invoke the Python pdb debugger when this element is
about to be parsed. Set C{breakFlag} to True to enable, False to
disable.
"""
if breakFlag:
_parseMethod = self._parse
def breaker(instring, loc, doActions=True, callPreParse=True):
import pdb
pdb.set_trace()
return _parseMethod( instring, loc, doActions, callPreParse )
breaker._originalParseMethod = _parseMethod
self._parse = breaker
else:
if hasattr(self._parse,"_originalParseMethod"):
self._parse = self._parse._originalParseMethod
return self
def setParseAction( self, *fns, **kwargs ):
"""Define action to perform when successfully matching parse element definition.
Parse action fn is a callable method with 0-3 arguments, called as C{fn(s,loc,toks)},
C{fn(loc,toks)}, C{fn(toks)}, or just C{fn()}, where:
- s = the original string being parsed (see note below)
- loc = the location of the matching substring
- toks = a list of the matched tokens, packaged as a C{L{ParseResults}} object
If the functions in fns modify the tokens, they can return them as the return
value from fn, and the modified list of tokens will replace the original.
Otherwise, fn does not need to return any value.
Note: the default parsing behavior is to expand tabs in the input string
before starting the parsing process. See L{I{parseString}} for more information
on parsing strings containing C{}s, and suggested methods to maintain a
consistent view of the parsed string, the parse location, and line and column
positions within the parsed string.
"""
self.parseAction = list(map(_trim_arity, list(fns)))
self.callDuringTry = kwargs.get("callDuringTry", False)
return self
def addParseAction( self, *fns, **kwargs ):
"""Add parse action to expression's list of parse actions. See L{I{setParseAction}}."""
self.parseAction += list(map(_trim_arity, list(fns)))
self.callDuringTry = self.callDuringTry or kwargs.get("callDuringTry", False)
return self
def addCondition(self, *fns, **kwargs):
"""Add a boolean predicate function to expression's list of parse actions. See
L{I{setParseAction}}. Optional keyword argument C{message} can
be used to define a custom message to be used in the raised exception."""
msg = kwargs.get("message") or "failed user-defined condition"
for fn in fns:
def pa(s,l,t):
if not bool(_trim_arity(fn)(s,l,t)):
raise ParseException(s,l,msg)
return t
self.parseAction.append(pa)
self.callDuringTry = self.callDuringTry or kwargs.get("callDuringTry", False)
return self
def setFailAction( self, fn ):
"""Define action to perform if parsing fails at this expression.
Fail acton fn is a callable function that takes the arguments
C{fn(s,loc,expr,err)} where:
- s = string being parsed
- loc = location where expression match was attempted and failed
- expr = the parse expression that failed
- err = the exception thrown
The function returns no value. It may throw C{L{ParseFatalException}}
if it is desired to stop parsing immediately."""
self.failAction = fn
return self
def _skipIgnorables( self, instring, loc ):
exprsFound = True
while exprsFound:
exprsFound = False
for e in self.ignoreExprs:
try:
while 1:
loc,dummy = e._parse( instring, loc )
exprsFound = True
except ParseException:
pass
return loc
def preParse( self, instring, loc ):
if self.ignoreExprs:
loc = self._skipIgnorables( instring, loc )
if self.skipWhitespace:
wt = self.whiteChars
instrlen = len(instring)
while loc < instrlen and instring[loc] in wt:
loc += 1
return loc
def parseImpl( self, instring, loc, doActions=True ):
return loc, []
def postParse( self, instring, loc, tokenlist ):
return tokenlist
#~ @profile
def _parseNoCache( self, instring, loc, doActions=True, callPreParse=True ):
debugging = ( self.debug ) #and doActions )
if debugging or self.failAction:
#~ print ("Match",self,"at loc",loc,"(%d,%d)" % ( lineno(loc,instring), col(loc,instring) ))
if (self.debugActions[0] ):
self.debugActions[0]( instring, loc, self )
if callPreParse and self.callPreparse:
preloc = self.preParse( instring, loc )
else:
preloc = loc
tokensStart = preloc
try:
try:
loc,tokens = self.parseImpl( instring, preloc, doActions )
except IndexError:
raise ParseException( instring, len(instring), self.errmsg, self )
except ParseBaseException as err:
#~ print ("Exception raised:", err)
if self.debugActions[2]:
self.debugActions[2]( instring, tokensStart, self, err )
if self.failAction:
self.failAction( instring, tokensStart, self, err )
raise
else:
if callPreParse and self.callPreparse:
preloc = self.preParse( instring, loc )
else:
preloc = loc
tokensStart = preloc
if self.mayIndexError or loc >= len(instring):
try:
loc,tokens = self.parseImpl( instring, preloc, doActions )
except IndexError:
raise ParseException( instring, len(instring), self.errmsg, self )
else:
loc,tokens = self.parseImpl( instring, preloc, doActions )
tokens = self.postParse( instring, loc, tokens )
retTokens = ParseResults( tokens, self.resultsName, asList=self.saveAsList, modal=self.modalResults )
if self.parseAction and (doActions or self.callDuringTry):
if debugging:
try:
for fn in self.parseAction:
tokens = fn( instring, tokensStart, retTokens )
if tokens is not None:
retTokens = ParseResults( tokens,
self.resultsName,
asList=self.saveAsList and isinstance(tokens,(ParseResults,list)),
modal=self.modalResults )
except ParseBaseException as err:
#~ print "Exception raised in user parse action:", err
if (self.debugActions[2] ):
self.debugActions[2]( instring, tokensStart, self, err )
raise
else:
for fn in self.parseAction:
tokens = fn( instring, tokensStart, retTokens )
if tokens is not None:
retTokens = ParseResults( tokens,
self.resultsName,
asList=self.saveAsList and isinstance(tokens,(ParseResults,list)),
modal=self.modalResults )
if debugging:
#~ print ("Matched",self,"->",retTokens.asList())
if (self.debugActions[1] ):
self.debugActions[1]( instring, tokensStart, loc, self, retTokens )
return loc, retTokens
def tryParse( self, instring, loc ):
try:
return self._parse( instring, loc, doActions=False )[0]
except ParseFatalException:
raise ParseException( instring, loc, self.errmsg, self)
# this method gets repeatedly called during backtracking with the same arguments -
# we can cache these arguments and save ourselves the trouble of re-parsing the contained expression
def _parseCache( self, instring, loc, doActions=True, callPreParse=True ):
lookup = (self,instring,loc,callPreParse,doActions)
if lookup in ParserElement._exprArgCache:
value = ParserElement._exprArgCache[ lookup ]
if isinstance(value, Exception):
raise value
return (value[0],value[1].copy())
else:
try:
value = self._parseNoCache( instring, loc, doActions, callPreParse )
ParserElement._exprArgCache[ lookup ] = (value[0],value[1].copy())
return value
except ParseBaseException as pe:
pe.__traceback__ = None
ParserElement._exprArgCache[ lookup ] = pe
raise
_parse = _parseNoCache
# argument cache for optimizing repeated calls when backtracking through recursive expressions
_exprArgCache = {}
@staticmethod
def resetCache():
ParserElement._exprArgCache.clear()
_packratEnabled = False
@staticmethod
def enablePackrat():
"""Enables "packrat" parsing, which adds memoizing to the parsing logic.
Repeated parse attempts at the same string location (which happens
often in many complex grammars) can immediately return a cached value,
instead of re-executing parsing/validating code. Memoizing is done of
both valid results and parsing exceptions.
This speedup may break existing programs that use parse actions that
have side-effects. For this reason, packrat parsing is disabled when
you first import pyparsing. To activate the packrat feature, your
program must call the class method C{ParserElement.enablePackrat()}. If
your program uses C{psyco} to "compile as you go", you must call
C{enablePackrat} before calling C{psyco.full()}. If you do not do this,
Python will crash. For best results, call C{enablePackrat()} immediately
after importing pyparsing.
"""
if not ParserElement._packratEnabled:
ParserElement._packratEnabled = True
ParserElement._parse = ParserElement._parseCache
def parseString( self, instring, parseAll=False ):
"""Execute the parse expression with the given string.
This is the main interface to the client code, once the complete
expression has been built.
If you want the grammar to require that the entire input string be
successfully parsed, then set C{parseAll} to True (equivalent to ending
the grammar with C{L{StringEnd()}}).
Note: C{parseString} implicitly calls C{expandtabs()} on the input string,
in order to report proper column numbers in parse actions.
If the input string contains tabs and
the grammar uses parse actions that use the C{loc} argument to index into the
string being parsed, you can ensure you have a consistent view of the input
string by:
- calling C{parseWithTabs} on your grammar before calling C{parseString}
(see L{I{parseWithTabs}})
- define your parse action using the full C{(s,loc,toks)} signature, and
reference the input string using the parse action's C{s} argument
- explictly expand the tabs in your input string before calling
C{parseString}
"""
ParserElement.resetCache()
if not self.streamlined:
self.streamline()
#~ self.saveAsList = True
for e in self.ignoreExprs:
e.streamline()
if not self.keepTabs:
instring = instring.expandtabs()
try:
loc, tokens = self._parse( instring, 0 )
if parseAll:
loc = self.preParse( instring, loc )
se = Empty() + StringEnd()
se._parse( instring, loc )
except ParseBaseException as exc:
if ParserElement.verbose_stacktrace:
raise
else:
# catch and re-raise exception from here, clears out pyparsing internal stack trace
raise exc
else:
return tokens
def scanString( self, instring, maxMatches=_MAX_INT, overlap=False ):
"""Scan the input string for expression matches. Each match will return the
matching tokens, start location, and end location. May be called with optional
C{maxMatches} argument, to clip scanning after 'n' matches are found. If
C{overlap} is specified, then overlapping matches will be reported.
Note that the start and end locations are reported relative to the string
being parsed. See L{I{parseString}} for more information on parsing
strings with embedded tabs."""
if not self.streamlined:
self.streamline()
for e in self.ignoreExprs:
e.streamline()
if not self.keepTabs:
instring = _ustr(instring).expandtabs()
instrlen = len(instring)
loc = 0
preparseFn = self.preParse
parseFn = self._parse
ParserElement.resetCache()
matches = 0
try:
while loc <= instrlen and matches < maxMatches:
try:
preloc = preparseFn( instring, loc )
nextLoc,tokens = parseFn( instring, preloc, callPreParse=False )
except ParseException:
loc = preloc+1
else:
if nextLoc > loc:
matches += 1
yield tokens, preloc, nextLoc
if overlap:
nextloc = preparseFn( instring, loc )
if nextloc > loc:
loc = nextLoc
else:
loc += 1
else:
loc = nextLoc
else:
loc = preloc+1
except ParseBaseException as exc:
if ParserElement.verbose_stacktrace:
raise
else:
# catch and re-raise exception from here, clears out pyparsing internal stack trace
raise exc
def transformString( self, instring ):
"""Extension to C{L{scanString}}, to modify matching text with modified tokens that may
be returned from a parse action. To use C{transformString}, define a grammar and
attach a parse action to it that modifies the returned token list.
Invoking C{transformString()} on a target string will then scan for matches,
and replace the matched text patterns according to the logic in the parse
action. C{transformString()} returns the resulting transformed string."""
out = []
lastE = 0
# force preservation of s, to minimize unwanted transformation of string, and to
# keep string locs straight between transformString and scanString
self.keepTabs = True
try:
for t,s,e in self.scanString( instring ):
out.append( instring[lastE:s] )
if t:
if isinstance(t,ParseResults):
out += t.asList()
elif isinstance(t,list):
out += t
else:
out.append(t)
lastE = e
out.append(instring[lastE:])
out = [o for o in out if o]
return "".join(map(_ustr,_flatten(out)))
except ParseBaseException as exc:
if ParserElement.verbose_stacktrace:
raise
else:
# catch and re-raise exception from here, clears out pyparsing internal stack trace
raise exc
def searchString( self, instring, maxMatches=_MAX_INT ):
"""Another extension to C{L{scanString}}, simplifying the access to the tokens found
to match the given parse expression. May be called with optional
C{maxMatches} argument, to clip searching after 'n' matches are found.
"""
try:
return ParseResults([ t for t,s,e in self.scanString( instring, maxMatches ) ])
except ParseBaseException as exc:
if ParserElement.verbose_stacktrace:
raise
else:
# catch and re-raise exception from here, clears out pyparsing internal stack trace
raise exc
def __add__(self, other ):
"""Implementation of + operator - returns C{L{And}}"""
if isinstance( other, basestring ):
other = ParserElement.literalStringClass( other )
if not isinstance( other, ParserElement ):
warnings.warn("Cannot combine element of type %s with ParserElement" % type(other),
SyntaxWarning, stacklevel=2)
return None
return And( [ self, other ] )
def __radd__(self, other ):
"""Implementation of + operator when left operand is not a C{L{ParserElement}}"""
if isinstance( other, basestring ):
other = ParserElement.literalStringClass( other )
if not isinstance( other, ParserElement ):
warnings.warn("Cannot combine element of type %s with ParserElement" % type(other),
SyntaxWarning, stacklevel=2)
return None
return other + self
def __sub__(self, other):
"""Implementation of - operator, returns C{L{And}} with error stop"""
if isinstance( other, basestring ):
other = ParserElement.literalStringClass( other )
if not isinstance( other, ParserElement ):
warnings.warn("Cannot combine element of type %s with ParserElement" % type(other),
SyntaxWarning, stacklevel=2)
return None
return And( [ self, And._ErrorStop(), other ] )
def __rsub__(self, other ):
"""Implementation of - operator when left operand is not a C{L{ParserElement}}"""
if isinstance( other, basestring ):
other = ParserElement.literalStringClass( other )
if not isinstance( other, ParserElement ):
warnings.warn("Cannot combine element of type %s with ParserElement" % type(other),
SyntaxWarning, stacklevel=2)
return None
return other - self
def __mul__(self,other):
"""Implementation of * operator, allows use of C{expr * 3} in place of
C{expr + expr + expr}. Expressions may also me multiplied by a 2-integer
tuple, similar to C{{min,max}} multipliers in regular expressions. Tuples
may also include C{None} as in:
- C{expr*(n,None)} or C{expr*(n,)} is equivalent
to C{expr*n + L{ZeroOrMore}(expr)}
(read as "at least n instances of C{expr}")
- C{expr*(None,n)} is equivalent to C{expr*(0,n)}
(read as "0 to n instances of C{expr}")
- C{expr*(None,None)} is equivalent to C{L{ZeroOrMore}(expr)}
- C{expr*(1,None)} is equivalent to C{L{OneOrMore}(expr)}
Note that C{expr*(None,n)} does not raise an exception if
more than n exprs exist in the input stream; that is,
C{expr*(None,n)} does not enforce a maximum number of expr
occurrences. If this behavior is desired, then write
C{expr*(None,n) + ~expr}
"""
if isinstance(other,int):
minElements, optElements = other,0
elif isinstance(other,tuple):
other = (other + (None, None))[:2]
if other[0] is None:
other = (0, other[1])
if isinstance(other[0],int) and other[1] is None:
if other[0] == 0:
return ZeroOrMore(self)
if other[0] == 1:
return OneOrMore(self)
else:
return self*other[0] + ZeroOrMore(self)
elif isinstance(other[0],int) and isinstance(other[1],int):
minElements, optElements = other
optElements -= minElements
else:
raise TypeError("cannot multiply 'ParserElement' and ('%s','%s') objects", type(other[0]),type(other[1]))
else:
raise TypeError("cannot multiply 'ParserElement' and '%s' objects", type(other))
if minElements < 0:
raise ValueError("cannot multiply ParserElement by negative value")
if optElements < 0:
raise ValueError("second tuple value must be greater or equal to first tuple value")
if minElements == optElements == 0:
raise ValueError("cannot multiply ParserElement by 0 or (0,0)")
if (optElements):
def makeOptionalList(n):
if n>1:
return Optional(self + makeOptionalList(n-1))
else:
return Optional(self)
if minElements:
if minElements == 1:
ret = self + makeOptionalList(optElements)
else:
ret = And([self]*minElements) + makeOptionalList(optElements)
else:
ret = makeOptionalList(optElements)
else:
if minElements == 1:
ret = self
else:
ret = And([self]*minElements)
return ret
def __rmul__(self, other):
return self.__mul__(other)
def __or__(self, other ):
"""Implementation of | operator - returns C{L{MatchFirst}}"""
if isinstance( other, basestring ):
other = ParserElement.literalStringClass( other )
if not isinstance( other, ParserElement ):
warnings.warn("Cannot combine element of type %s with ParserElement" % type(other),
SyntaxWarning, stacklevel=2)
return None
return MatchFirst( [ self, other ] )
def __ror__(self, other ):
"""Implementation of | operator when left operand is not a C{L{ParserElement}}"""
if isinstance( other, basestring ):
other = ParserElement.literalStringClass( other )
if not isinstance( other, ParserElement ):
warnings.warn("Cannot combine element of type %s with ParserElement" % type(other),
SyntaxWarning, stacklevel=2)
return None
return other | self
def __xor__(self, other ):
"""Implementation of ^ operator - returns C{L{Or}}"""
if isinstance( other, basestring ):
other = ParserElement.literalStringClass( other )
if not isinstance( other, ParserElement ):
warnings.warn("Cannot combine element of type %s with ParserElement" % type(other),
SyntaxWarning, stacklevel=2)
return None
return Or( [ self, other ] )
def __rxor__(self, other ):
"""Implementation of ^ operator when left operand is not a C{L{ParserElement}}"""
if isinstance( other, basestring ):
other = ParserElement.literalStringClass( other )
if not isinstance( other, ParserElement ):
warnings.warn("Cannot combine element of type %s with ParserElement" % type(other),
SyntaxWarning, stacklevel=2)
return None
return other ^ self
def __and__(self, other ):
"""Implementation of & operator - returns C{L{Each}}"""
if isinstance( other, basestring ):
other = ParserElement.literalStringClass( other )
if not isinstance( other, ParserElement ):
warnings.warn("Cannot combine element of type %s with ParserElement" % type(other),
SyntaxWarning, stacklevel=2)
return None
return Each( [ self, other ] )
def __rand__(self, other ):
"""Implementation of & operator when left operand is not a C{L{ParserElement}}"""
if isinstance( other, basestring ):
other = ParserElement.literalStringClass( other )
if not isinstance( other, ParserElement ):
warnings.warn("Cannot combine element of type %s with ParserElement" % type(other),
SyntaxWarning, stacklevel=2)
return None
return other & self
def __invert__( self ):
"""Implementation of ~ operator - returns C{L{NotAny}}"""
return NotAny( self )
def __call__(self, name=None):
"""Shortcut for C{L{setResultsName}}, with C{listAllMatches=default}::
userdata = Word(alphas).setResultsName("name") + Word(nums+"-").setResultsName("socsecno")
could be written as::
userdata = Word(alphas)("name") + Word(nums+"-")("socsecno")
If C{name} is given with a trailing C{'*'} character, then C{listAllMatches} will be
passed as C{True}.
If C{name} is omitted, same as calling C{L{copy}}.
"""
if name is not None:
return self.setResultsName(name)
else:
return self.copy()
def suppress( self ):
"""Suppresses the output of this C{ParserElement}; useful to keep punctuation from
cluttering up returned output.
"""
return Suppress( self )
def leaveWhitespace( self ):
"""Disables the skipping of whitespace before matching the characters in the
C{ParserElement}'s defined pattern. This is normally only used internally by
the pyparsing module, but may be needed in some whitespace-sensitive grammars.
"""
self.skipWhitespace = False
return self
def setWhitespaceChars( self, chars ):
"""Overrides the default whitespace chars
"""
self.skipWhitespace = True
self.whiteChars = chars
self.copyDefaultWhiteChars = False
return self
def parseWithTabs( self ):
"""Overrides default behavior to expand C{}s to spaces before parsing the input string.
Must be called before C{parseString} when the input grammar contains elements that
match C{} characters."""
self.keepTabs = True
return self
def ignore( self, other ):
"""Define expression to be ignored (e.g., comments) while doing pattern
matching; may be called repeatedly, to define multiple comment or other
ignorable patterns.
"""
if isinstance( other, Suppress ):
if other not in self.ignoreExprs:
self.ignoreExprs.append( other.copy() )
else:
self.ignoreExprs.append( Suppress( other.copy() ) )
return self
def setDebugActions( self, startAction, successAction, exceptionAction ):
"""Enable display of debugging messages while doing pattern matching."""
self.debugActions = (startAction or _defaultStartDebugAction,
successAction or _defaultSuccessDebugAction,
exceptionAction or _defaultExceptionDebugAction)
self.debug = True
return self
def setDebug( self, flag=True ):
"""Enable display of debugging messages while doing pattern matching.
Set C{flag} to True to enable, False to disable."""
if flag:
self.setDebugActions( _defaultStartDebugAction, _defaultSuccessDebugAction, _defaultExceptionDebugAction )
else:
self.debug = False
return self
def __str__( self ):
return self.name
def __repr__( self ):
return _ustr(self)
def streamline( self ):
self.streamlined = True
self.strRepr = None
return self
def checkRecursion( self, parseElementList ):
pass
def validate( self, validateTrace=[] ):
"""Check defined expressions for valid structure, check for infinite recursive definitions."""
self.checkRecursion( [] )
def parseFile( self, file_or_filename, parseAll=False ):
"""Execute the parse expression on the given file or filename.
If a filename is specified (instead of a file object),
the entire file is opened, read, and closed before parsing.
"""
try:
file_contents = file_or_filename.read()
except AttributeError:
f = open(file_or_filename, "r")
file_contents = f.read()
f.close()
try:
return self.parseString(file_contents, parseAll)
except ParseBaseException as exc:
if ParserElement.verbose_stacktrace:
raise
else:
# catch and re-raise exception from here, clears out pyparsing internal stack trace
raise exc
def __eq__(self,other):
if isinstance(other, ParserElement):
return self is other or self.__dict__ == other.__dict__
elif isinstance(other, basestring):
try:
self.parseString(_ustr(other), parseAll=True)
return True
except ParseBaseException:
return False
else:
return super(ParserElement,self)==other
def __ne__(self,other):
return not (self == other)
def __hash__(self):
return hash(id(self))
def __req__(self,other):
return self == other
def __rne__(self,other):
return not (self == other)
def runTests(self, tests, parseAll=False):
"""Execute the parse expression on a series of test strings, showing each
test, the parsed results or where the parse failed. Quick and easy way to
run a parse expression against a list of sample strings.
Parameters:
- tests - a list of separate test strings, or a multiline string of test strings
- parseAll - (default=False) - flag to pass to C{L{parseString}} when running tests
"""
if isinstance(tests, basestring):
tests = map(str.strip, tests.splitlines())
for t in tests:
out = [t]
try:
out.append(self.parseString(t, parseAll=parseAll).dump())
except ParseException as pe:
if '\n' in t:
out.append(line(pe.loc, t))
out.append(' '*(col(pe.loc,t)-1) + '^')
else:
out.append(' '*pe.loc + '^')
out.append(str(pe))
out.append('')
print('\n'.join(out))
class Token(ParserElement):
"""Abstract C{ParserElement} subclass, for defining atomic matching patterns."""
def __init__( self ):
super(Token,self).__init__( savelist=False )
class Empty(Token):
"""An empty token, will always match."""
def __init__( self ):
super(Empty,self).__init__()
self.name = "Empty"
self.mayReturnEmpty = True
self.mayIndexError = False
class NoMatch(Token):
"""A token that will never match."""
def __init__( self ):
super(NoMatch,self).__init__()
self.name = "NoMatch"
self.mayReturnEmpty = True
self.mayIndexError = False
self.errmsg = "Unmatchable token"
def parseImpl( self, instring, loc, doActions=True ):
raise ParseException(instring, loc, self.errmsg, self)
class Literal(Token):
"""Token to exactly match a specified string."""
def __init__( self, matchString ):
super(Literal,self).__init__()
self.match = matchString
self.matchLen = len(matchString)
try:
self.firstMatchChar = matchString[0]
except IndexError:
warnings.warn("null string passed to Literal; use Empty() instead",
SyntaxWarning, stacklevel=2)
self.__class__ = Empty
self.name = '"%s"' % _ustr(self.match)
self.errmsg = "Expected " + self.name
self.mayReturnEmpty = False
self.mayIndexError = False
# Performance tuning: this routine gets called a *lot*
# if this is a single character match string and the first character matches,
# short-circuit as quickly as possible, and avoid calling startswith
#~ @profile
def parseImpl( self, instring, loc, doActions=True ):
if (instring[loc] == self.firstMatchChar and
(self.matchLen==1 or instring.startswith(self.match,loc)) ):
return loc+self.matchLen, self.match
raise ParseException(instring, loc, self.errmsg, self)
_L = Literal
ParserElement.literalStringClass = Literal
class Keyword(Token):
"""Token to exactly match a specified string as a keyword, that is, it must be
immediately followed by a non-keyword character. Compare with C{L{Literal}}::
Literal("if") will match the leading C{'if'} in C{'ifAndOnlyIf'}.
Keyword("if") will not; it will only match the leading C{'if'} in C{'if x=1'}, or C{'if(y==2)'}
Accepts two optional constructor arguments in addition to the keyword string:
C{identChars} is a string of characters that would be valid identifier characters,
defaulting to all alphanumerics + "_" and "$"; C{caseless} allows case-insensitive
matching, default is C{False}.
"""
DEFAULT_KEYWORD_CHARS = alphanums+"_$"
def __init__( self, matchString, identChars=DEFAULT_KEYWORD_CHARS, caseless=False ):
super(Keyword,self).__init__()
self.match = matchString
self.matchLen = len(matchString)
try:
self.firstMatchChar = matchString[0]
except IndexError:
warnings.warn("null string passed to Keyword; use Empty() instead",
SyntaxWarning, stacklevel=2)
self.name = '"%s"' % self.match
self.errmsg = "Expected " + self.name
self.mayReturnEmpty = False
self.mayIndexError = False
self.caseless = caseless
if caseless:
self.caselessmatch = matchString.upper()
identChars = identChars.upper()
self.identChars = set(identChars)
def parseImpl( self, instring, loc, doActions=True ):
if self.caseless:
if ( (instring[ loc:loc+self.matchLen ].upper() == self.caselessmatch) and
(loc >= len(instring)-self.matchLen or instring[loc+self.matchLen].upper() not in self.identChars) and
(loc == 0 or instring[loc-1].upper() not in self.identChars) ):
return loc+self.matchLen, self.match
else:
if (instring[loc] == self.firstMatchChar and
(self.matchLen==1 or instring.startswith(self.match,loc)) and
(loc >= len(instring)-self.matchLen or instring[loc+self.matchLen] not in self.identChars) and
(loc == 0 or instring[loc-1] not in self.identChars) ):
return loc+self.matchLen, self.match
raise ParseException(instring, loc, self.errmsg, self)
def copy(self):
c = super(Keyword,self).copy()
c.identChars = Keyword.DEFAULT_KEYWORD_CHARS
return c
@staticmethod
def setDefaultKeywordChars( chars ):
"""Overrides the default Keyword chars
"""
Keyword.DEFAULT_KEYWORD_CHARS = chars
class CaselessLiteral(Literal):
"""Token to match a specified string, ignoring case of letters.
Note: the matched results will always be in the case of the given
match string, NOT the case of the input text.
"""
def __init__( self, matchString ):
super(CaselessLiteral,self).__init__( matchString.upper() )
# Preserve the defining literal.
self.returnString = matchString
self.name = "'%s'" % self.returnString
self.errmsg = "Expected " + self.name
def parseImpl( self, instring, loc, doActions=True ):
if instring[ loc:loc+self.matchLen ].upper() == self.match:
return loc+self.matchLen, self.returnString
raise ParseException(instring, loc, self.errmsg, self)
class CaselessKeyword(Keyword):
def __init__( self, matchString, identChars=Keyword.DEFAULT_KEYWORD_CHARS ):
super(CaselessKeyword,self).__init__( matchString, identChars, caseless=True )
def parseImpl( self, instring, loc, doActions=True ):
if ( (instring[ loc:loc+self.matchLen ].upper() == self.caselessmatch) and
(loc >= len(instring)-self.matchLen or instring[loc+self.matchLen].upper() not in self.identChars) ):
return loc+self.matchLen, self.match
raise ParseException(instring, loc, self.errmsg, self)
class Word(Token):
"""Token for matching words composed of allowed character sets.
Defined with string containing all allowed initial characters,
an optional string containing allowed body characters (if omitted,
defaults to the initial character set), and an optional minimum,
maximum, and/or exact length. The default value for C{min} is 1 (a
minimum value < 1 is not valid); the default values for C{max} and C{exact}
are 0, meaning no maximum or exact length restriction. An optional
C{exclude} parameter can list characters that might be found in
the input C{bodyChars} string; useful to define a word of all printables
except for one or two characters, for instance.
"""
def __init__( self, initChars, bodyChars=None, min=1, max=0, exact=0, asKeyword=False, excludeChars=None ):
super(Word,self).__init__()
if excludeChars:
initChars = ''.join(c for c in initChars if c not in excludeChars)
if bodyChars:
bodyChars = ''.join(c for c in bodyChars if c not in excludeChars)
self.initCharsOrig = initChars
self.initChars = set(initChars)
if bodyChars :
self.bodyCharsOrig = bodyChars
self.bodyChars = set(bodyChars)
else:
self.bodyCharsOrig = initChars
self.bodyChars = set(initChars)
self.maxSpecified = max > 0
if min < 1:
raise ValueError("cannot specify a minimum length < 1; use Optional(Word()) if zero-length word is permitted")
self.minLen = min
if max > 0:
self.maxLen = max
else:
self.maxLen = _MAX_INT
if exact > 0:
self.maxLen = exact
self.minLen = exact
self.name = _ustr(self)
self.errmsg = "Expected " + self.name
self.mayIndexError = False
self.asKeyword = asKeyword
if ' ' not in self.initCharsOrig+self.bodyCharsOrig and (min==1 and max==0 and exact==0):
if self.bodyCharsOrig == self.initCharsOrig:
self.reString = "[%s]+" % _escapeRegexRangeChars(self.initCharsOrig)
elif len(self.initCharsOrig) == 1:
self.reString = "%s[%s]*" % \
(re.escape(self.initCharsOrig),
_escapeRegexRangeChars(self.bodyCharsOrig),)
else:
self.reString = "[%s][%s]*" % \
(_escapeRegexRangeChars(self.initCharsOrig),
_escapeRegexRangeChars(self.bodyCharsOrig),)
if self.asKeyword:
self.reString = r"\b"+self.reString+r"\b"
try:
self.re = re.compile( self.reString )
except:
self.re = None
def parseImpl( self, instring, loc, doActions=True ):
if self.re:
result = self.re.match(instring,loc)
if not result:
raise ParseException(instring, loc, self.errmsg, self)
loc = result.end()
return loc, result.group()
if not(instring[ loc ] in self.initChars):
raise ParseException(instring, loc, self.errmsg, self)
start = loc
loc += 1
instrlen = len(instring)
bodychars = self.bodyChars
maxloc = start + self.maxLen
maxloc = min( maxloc, instrlen )
while loc < maxloc and instring[loc] in bodychars:
loc += 1
throwException = False
if loc - start < self.minLen:
throwException = True
if self.maxSpecified and loc < instrlen and instring[loc] in bodychars:
throwException = True
if self.asKeyword:
if (start>0 and instring[start-1] in bodychars) or (loc4:
return s[:4]+"..."
else:
return s
if ( self.initCharsOrig != self.bodyCharsOrig ):
self.strRepr = "W:(%s,%s)" % ( charsAsStr(self.initCharsOrig), charsAsStr(self.bodyCharsOrig) )
else:
self.strRepr = "W:(%s)" % charsAsStr(self.initCharsOrig)
return self.strRepr
class Regex(Token):
"""Token for matching strings that match a given regular expression.
Defined with string specifying the regular expression in a form recognized by the inbuilt Python re module.
"""
compiledREtype = type(re.compile("[A-Z]"))
def __init__( self, pattern, flags=0):
"""The parameters C{pattern} and C{flags} are passed to the C{re.compile()} function as-is. See the Python C{re} module for an explanation of the acceptable patterns and flags."""
super(Regex,self).__init__()
if isinstance(pattern, basestring):
if len(pattern) == 0:
warnings.warn("null string passed to Regex; use Empty() instead",
SyntaxWarning, stacklevel=2)
self.pattern = pattern
self.flags = flags
try:
self.re = re.compile(self.pattern, self.flags)
self.reString = self.pattern
except sre_constants.error:
warnings.warn("invalid pattern (%s) passed to Regex" % pattern,
SyntaxWarning, stacklevel=2)
raise
elif isinstance(pattern, Regex.compiledREtype):
self.re = pattern
self.pattern = \
self.reString = str(pattern)
self.flags = flags
else:
raise ValueError("Regex may only be constructed with a string or a compiled RE object")
self.name = _ustr(self)
self.errmsg = "Expected " + self.name
self.mayIndexError = False
self.mayReturnEmpty = True
def parseImpl( self, instring, loc, doActions=True ):
result = self.re.match(instring,loc)
if not result:
raise ParseException(instring, loc, self.errmsg, self)
loc = result.end()
d = result.groupdict()
ret = ParseResults(result.group())
if d:
for k in d:
ret[k] = d[k]
return loc,ret
def __str__( self ):
try:
return super(Regex,self).__str__()
except:
pass
if self.strRepr is None:
self.strRepr = "Re:(%s)" % repr(self.pattern)
return self.strRepr
class QuotedString(Token):
"""Token for matching strings that are delimited by quoting characters.
"""
def __init__( self, quoteChar, escChar=None, escQuote=None, multiline=False, unquoteResults=True, endQuoteChar=None):
"""
Defined with the following parameters:
- quoteChar - string of one or more characters defining the quote delimiting string
- escChar - character to escape quotes, typically backslash (default=None)
- escQuote - special quote sequence to escape an embedded quote string (such as SQL's "" to escape an embedded ") (default=None)
- multiline - boolean indicating whether quotes can span multiple lines (default=C{False})
- unquoteResults - boolean indicating whether the matched text should be unquoted (default=C{True})
- endQuoteChar - string of one or more characters defining the end of the quote delimited string (default=C{None} => same as quoteChar)
"""
super(QuotedString,self).__init__()
# remove white space from quote chars - wont work anyway
quoteChar = quoteChar.strip()
if len(quoteChar) == 0:
warnings.warn("quoteChar cannot be the empty string",SyntaxWarning,stacklevel=2)
raise SyntaxError()
if endQuoteChar is None:
endQuoteChar = quoteChar
else:
endQuoteChar = endQuoteChar.strip()
if len(endQuoteChar) == 0:
warnings.warn("endQuoteChar cannot be the empty string",SyntaxWarning,stacklevel=2)
raise SyntaxError()
self.quoteChar = quoteChar
self.quoteCharLen = len(quoteChar)
self.firstQuoteChar = quoteChar[0]
self.endQuoteChar = endQuoteChar
self.endQuoteCharLen = len(endQuoteChar)
self.escChar = escChar
self.escQuote = escQuote
self.unquoteResults = unquoteResults
if multiline:
self.flags = re.MULTILINE | re.DOTALL
self.pattern = r'%s(?:[^%s%s]' % \
( re.escape(self.quoteChar),
_escapeRegexRangeChars(self.endQuoteChar[0]),
(escChar is not None and _escapeRegexRangeChars(escChar) or '') )
else:
self.flags = 0
self.pattern = r'%s(?:[^%s\n\r%s]' % \
( re.escape(self.quoteChar),
_escapeRegexRangeChars(self.endQuoteChar[0]),
(escChar is not None and _escapeRegexRangeChars(escChar) or '') )
if len(self.endQuoteChar) > 1:
self.pattern += (
'|(?:' + ')|(?:'.join("%s[^%s]" % (re.escape(self.endQuoteChar[:i]),
_escapeRegexRangeChars(self.endQuoteChar[i]))
for i in range(len(self.endQuoteChar)-1,0,-1)) + ')'
)
if escQuote:
self.pattern += (r'|(?:%s)' % re.escape(escQuote))
if escChar:
self.pattern += (r'|(?:%s.)' % re.escape(escChar))
self.escCharReplacePattern = re.escape(self.escChar)+"(.)"
self.pattern += (r')*%s' % re.escape(self.endQuoteChar))
try:
self.re = re.compile(self.pattern, self.flags)
self.reString = self.pattern
except sre_constants.error:
warnings.warn("invalid pattern (%s) passed to Regex" % self.pattern,
SyntaxWarning, stacklevel=2)
raise
self.name = _ustr(self)
self.errmsg = "Expected " + self.name
self.mayIndexError = False
self.mayReturnEmpty = True
def parseImpl( self, instring, loc, doActions=True ):
result = instring[loc] == self.firstQuoteChar and self.re.match(instring,loc) or None
if not result:
raise ParseException(instring, loc, self.errmsg, self)
loc = result.end()
ret = result.group()
if self.unquoteResults:
# strip off quotes
ret = ret[self.quoteCharLen:-self.endQuoteCharLen]
if isinstance(ret,basestring):
# replace escaped characters
if self.escChar:
ret = re.sub(self.escCharReplacePattern,"\g<1>",ret)
# replace escaped quotes
if self.escQuote:
ret = ret.replace(self.escQuote, self.endQuoteChar)
return loc, ret
def __str__( self ):
try:
return super(QuotedString,self).__str__()
except:
pass
if self.strRepr is None:
self.strRepr = "quoted string, starting with %s ending with %s" % (self.quoteChar, self.endQuoteChar)
return self.strRepr
class CharsNotIn(Token):
"""Token for matching words composed of characters *not* in a given set.
Defined with string containing all disallowed characters, and an optional
minimum, maximum, and/or exact length. The default value for C{min} is 1 (a
minimum value < 1 is not valid); the default values for C{max} and C{exact}
are 0, meaning no maximum or exact length restriction.
"""
def __init__( self, notChars, min=1, max=0, exact=0 ):
super(CharsNotIn,self).__init__()
self.skipWhitespace = False
self.notChars = notChars
if min < 1:
raise ValueError("cannot specify a minimum length < 1; use Optional(CharsNotIn()) if zero-length char group is permitted")
self.minLen = min
if max > 0:
self.maxLen = max
else:
self.maxLen = _MAX_INT
if exact > 0:
self.maxLen = exact
self.minLen = exact
self.name = _ustr(self)
self.errmsg = "Expected " + self.name
self.mayReturnEmpty = ( self.minLen == 0 )
self.mayIndexError = False
def parseImpl( self, instring, loc, doActions=True ):
if instring[loc] in self.notChars:
raise ParseException(instring, loc, self.errmsg, self)
start = loc
loc += 1
notchars = self.notChars
maxlen = min( start+self.maxLen, len(instring) )
while loc < maxlen and \
(instring[loc] not in notchars):
loc += 1
if loc - start < self.minLen:
raise ParseException(instring, loc, self.errmsg, self)
return loc, instring[start:loc]
def __str__( self ):
try:
return super(CharsNotIn, self).__str__()
except:
pass
if self.strRepr is None:
if len(self.notChars) > 4:
self.strRepr = "!W:(%s...)" % self.notChars[:4]
else:
self.strRepr = "!W:(%s)" % self.notChars
return self.strRepr
class White(Token):
"""Special matching class for matching whitespace. Normally, whitespace is ignored
by pyparsing grammars. This class is included when some whitespace structures
are significant. Define with a string containing the whitespace characters to be
matched; default is C{" \\t\\r\\n"}. Also takes optional C{min}, C{max}, and C{exact} arguments,
as defined for the C{L{Word}} class."""
whiteStrs = {
" " : "",
"\t": "",
"\n": "",
"\r": "",
"\f": "",
}
def __init__(self, ws=" \t\r\n", min=1, max=0, exact=0):
super(White,self).__init__()
self.matchWhite = ws
self.setWhitespaceChars( "".join(c for c in self.whiteChars if c not in self.matchWhite) )
#~ self.leaveWhitespace()
self.name = ("".join(White.whiteStrs[c] for c in self.matchWhite))
self.mayReturnEmpty = True
self.errmsg = "Expected " + self.name
self.minLen = min
if max > 0:
self.maxLen = max
else:
self.maxLen = _MAX_INT
if exact > 0:
self.maxLen = exact
self.minLen = exact
def parseImpl( self, instring, loc, doActions=True ):
if not(instring[ loc ] in self.matchWhite):
raise ParseException(instring, loc, self.errmsg, self)
start = loc
loc += 1
maxloc = start + self.maxLen
maxloc = min( maxloc, len(instring) )
while loc < maxloc and instring[loc] in self.matchWhite:
loc += 1
if loc - start < self.minLen:
raise ParseException(instring, loc, self.errmsg, self)
return loc, instring[start:loc]
class _PositionToken(Token):
def __init__( self ):
super(_PositionToken,self).__init__()
self.name=self.__class__.__name__
self.mayReturnEmpty = True
self.mayIndexError = False
class GoToColumn(_PositionToken):
"""Token to advance to a specific column of input text; useful for tabular report scraping."""
def __init__( self, colno ):
super(GoToColumn,self).__init__()
self.col = colno
def preParse( self, instring, loc ):
if col(loc,instring) != self.col:
instrlen = len(instring)
if self.ignoreExprs:
loc = self._skipIgnorables( instring, loc )
while loc < instrlen and instring[loc].isspace() and col( loc, instring ) != self.col :
loc += 1
return loc
def parseImpl( self, instring, loc, doActions=True ):
thiscol = col( loc, instring )
if thiscol > self.col:
raise ParseException( instring, loc, "Text not in expected column", self )
newloc = loc + self.col - thiscol
ret = instring[ loc: newloc ]
return newloc, ret
class LineStart(_PositionToken):
"""Matches if current position is at the beginning of a line within the parse string"""
def __init__( self ):
super(LineStart,self).__init__()
self.setWhitespaceChars( ParserElement.DEFAULT_WHITE_CHARS.replace("\n","") )
self.errmsg = "Expected start of line"
def preParse( self, instring, loc ):
preloc = super(LineStart,self).preParse(instring,loc)
if instring[preloc] == "\n":
loc += 1
return loc
def parseImpl( self, instring, loc, doActions=True ):
if not( loc==0 or
(loc == self.preParse( instring, 0 )) or
(instring[loc-1] == "\n") ): #col(loc, instring) != 1:
raise ParseException(instring, loc, self.errmsg, self)
return loc, []
class LineEnd(_PositionToken):
"""Matches if current position is at the end of a line within the parse string"""
def __init__( self ):
super(LineEnd,self).__init__()
self.setWhitespaceChars( ParserElement.DEFAULT_WHITE_CHARS.replace("\n","") )
self.errmsg = "Expected end of line"
def parseImpl( self, instring, loc, doActions=True ):
if loc len(instring):
return loc, []
else:
raise ParseException(instring, loc, self.errmsg, self)
class WordStart(_PositionToken):
"""Matches if the current position is at the beginning of a Word, and
is not preceded by any character in a given set of C{wordChars}
(default=C{printables}). To emulate the C{\b} behavior of regular expressions,
use C{WordStart(alphanums)}. C{WordStart} will also match at the beginning of
the string being parsed, or at the beginning of a line.
"""
def __init__(self, wordChars = printables):
super(WordStart,self).__init__()
self.wordChars = set(wordChars)
self.errmsg = "Not at the start of a word"
def parseImpl(self, instring, loc, doActions=True ):
if loc != 0:
if (instring[loc-1] in self.wordChars or
instring[loc] not in self.wordChars):
raise ParseException(instring, loc, self.errmsg, self)
return loc, []
class WordEnd(_PositionToken):
"""Matches if the current position is at the end of a Word, and
is not followed by any character in a given set of C{wordChars}
(default=C{printables}). To emulate the C{\b} behavior of regular expressions,
use C{WordEnd(alphanums)}. C{WordEnd} will also match at the end of
the string being parsed, or at the end of a line.
"""
def __init__(self, wordChars = printables):
super(WordEnd,self).__init__()
self.wordChars = set(wordChars)
self.skipWhitespace = False
self.errmsg = "Not at the end of a word"
def parseImpl(self, instring, loc, doActions=True ):
instrlen = len(instring)
if instrlen>0 and loc maxExcLoc:
maxException = err
maxExcLoc = err.loc
except IndexError:
if len(instring) > maxExcLoc:
maxException = ParseException(instring,len(instring),e.errmsg,self)
maxExcLoc = len(instring)
else:
# save match among all matches, to retry longest to shortest
matches.append((loc2, e))
if matches:
matches.sort(key=lambda x: -x[0])
for _,e in matches:
try:
return e._parse( instring, loc, doActions )
except ParseException as err:
err.__traceback__ = None
if err.loc > maxExcLoc:
maxException = err
maxExcLoc = err.loc
if maxException is not None:
maxException.msg = self.errmsg
raise maxException
else:
raise ParseException(instring, loc, "no defined alternatives to match", self)
def __ixor__(self, other ):
if isinstance( other, basestring ):
other = ParserElement.literalStringClass( other )
return self.append( other ) #Or( [ self, other ] )
def __str__( self ):
if hasattr(self,"name"):
return self.name
if self.strRepr is None:
self.strRepr = "{" + " ^ ".join(_ustr(e) for e in self.exprs) + "}"
return self.strRepr
def checkRecursion( self, parseElementList ):
subRecCheckList = parseElementList[:] + [ self ]
for e in self.exprs:
e.checkRecursion( subRecCheckList )
class MatchFirst(ParseExpression):
"""Requires that at least one C{ParseExpression} is found.
If two expressions match, the first one listed is the one that will match.
May be constructed using the C{'|'} operator.
"""
def __init__( self, exprs, savelist = False ):
super(MatchFirst,self).__init__(exprs, savelist)
if self.exprs:
self.mayReturnEmpty = any(e.mayReturnEmpty for e in self.exprs)
else:
self.mayReturnEmpty = True
def parseImpl( self, instring, loc, doActions=True ):
maxExcLoc = -1
maxException = None
for e in self.exprs:
try:
ret = e._parse( instring, loc, doActions )
return ret
except ParseException as err:
if err.loc > maxExcLoc:
maxException = err
maxExcLoc = err.loc
except IndexError:
if len(instring) > maxExcLoc:
maxException = ParseException(instring,len(instring),e.errmsg,self)
maxExcLoc = len(instring)
# only got here if no expression matched, raise exception for match that made it the furthest
else:
if maxException is not None:
maxException.msg = self.errmsg
raise maxException
else:
raise ParseException(instring, loc, "no defined alternatives to match", self)
def __ior__(self, other ):
if isinstance( other, basestring ):
other = ParserElement.literalStringClass( other )
return self.append( other ) #MatchFirst( [ self, other ] )
def __str__( self ):
if hasattr(self,"name"):
return self.name
if self.strRepr is None:
self.strRepr = "{" + " | ".join(_ustr(e) for e in self.exprs) + "}"
return self.strRepr
def checkRecursion( self, parseElementList ):
subRecCheckList = parseElementList[:] + [ self ]
for e in self.exprs:
e.checkRecursion( subRecCheckList )
class Each(ParseExpression):
"""Requires all given C{ParseExpression}s to be found, but in any order.
Expressions may be separated by whitespace.
May be constructed using the C{'&'} operator.
"""
def __init__( self, exprs, savelist = True ):
super(Each,self).__init__(exprs, savelist)
self.mayReturnEmpty = all(e.mayReturnEmpty for e in self.exprs)
self.skipWhitespace = True
self.initExprGroups = True
def parseImpl( self, instring, loc, doActions=True ):
if self.initExprGroups:
self.opt1map = dict((id(e.expr),e) for e in self.exprs if isinstance(e,Optional))
opt1 = [ e.expr for e in self.exprs if isinstance(e,Optional) ]
opt2 = [ e for e in self.exprs if e.mayReturnEmpty and not isinstance(e,Optional)]
self.optionals = opt1 + opt2
self.multioptionals = [ e.expr for e in self.exprs if isinstance(e,ZeroOrMore) ]
self.multirequired = [ e.expr for e in self.exprs if isinstance(e,OneOrMore) ]
self.required = [ e for e in self.exprs if not isinstance(e,(Optional,ZeroOrMore,OneOrMore)) ]
self.required += self.multirequired
self.initExprGroups = False
tmpLoc = loc
tmpReqd = self.required[:]
tmpOpt = self.optionals[:]
matchOrder = []
keepMatching = True
while keepMatching:
tmpExprs = tmpReqd + tmpOpt + self.multioptionals + self.multirequired
failed = []
for e in tmpExprs:
try:
tmpLoc = e.tryParse( instring, tmpLoc )
except ParseException:
failed.append(e)
else:
matchOrder.append(self.opt1map.get(id(e),e))
if e in tmpReqd:
tmpReqd.remove(e)
elif e in tmpOpt:
tmpOpt.remove(e)
if len(failed) == len(tmpExprs):
keepMatching = False
if tmpReqd:
missing = ", ".join(_ustr(e) for e in tmpReqd)
raise ParseException(instring,loc,"Missing one or more required elements (%s)" % missing )
# add any unmatched Optionals, in case they have default values defined
matchOrder += [e for e in self.exprs if isinstance(e,Optional) and e.expr in tmpOpt]
resultlist = []
for e in matchOrder:
loc,results = e._parse(instring,loc,doActions)
resultlist.append(results)
finalResults = ParseResults([])
for r in resultlist:
dups = {}
for k in r.keys():
if k in finalResults:
tmp = ParseResults(finalResults[k])
tmp += ParseResults(r[k])
dups[k] = tmp
finalResults += ParseResults(r)
for k,v in dups.items():
finalResults[k] = v
return loc, finalResults
def __str__( self ):
if hasattr(self,"name"):
return self.name
if self.strRepr is None:
self.strRepr = "{" + " & ".join(_ustr(e) for e in self.exprs) + "}"
return self.strRepr
def checkRecursion( self, parseElementList ):
subRecCheckList = parseElementList[:] + [ self ]
for e in self.exprs:
e.checkRecursion( subRecCheckList )
class ParseElementEnhance(ParserElement):
"""Abstract subclass of C{ParserElement}, for combining and post-processing parsed tokens."""
def __init__( self, expr, savelist=False ):
super(ParseElementEnhance,self).__init__(savelist)
if isinstance( expr, basestring ):
expr = Literal(expr)
self.expr = expr
self.strRepr = None
if expr is not None:
self.mayIndexError = expr.mayIndexError
self.mayReturnEmpty = expr.mayReturnEmpty
self.setWhitespaceChars( expr.whiteChars )
self.skipWhitespace = expr.skipWhitespace
self.saveAsList = expr.saveAsList
self.callPreparse = expr.callPreparse
self.ignoreExprs.extend(expr.ignoreExprs)
def parseImpl( self, instring, loc, doActions=True ):
if self.expr is not None:
return self.expr._parse( instring, loc, doActions, callPreParse=False )
else:
raise ParseException("",loc,self.errmsg,self)
def leaveWhitespace( self ):
self.skipWhitespace = False
self.expr = self.expr.copy()
if self.expr is not None:
self.expr.leaveWhitespace()
return self
def ignore( self, other ):
if isinstance( other, Suppress ):
if other not in self.ignoreExprs:
super( ParseElementEnhance, self).ignore( other )
if self.expr is not None:
self.expr.ignore( self.ignoreExprs[-1] )
else:
super( ParseElementEnhance, self).ignore( other )
if self.expr is not None:
self.expr.ignore( self.ignoreExprs[-1] )
return self
def streamline( self ):
super(ParseElementEnhance,self).streamline()
if self.expr is not None:
self.expr.streamline()
return self
def checkRecursion( self, parseElementList ):
if self in parseElementList:
raise RecursiveGrammarException( parseElementList+[self] )
subRecCheckList = parseElementList[:] + [ self ]
if self.expr is not None:
self.expr.checkRecursion( subRecCheckList )
def validate( self, validateTrace=[] ):
tmp = validateTrace[:]+[self]
if self.expr is not None:
self.expr.validate(tmp)
self.checkRecursion( [] )
def __str__( self ):
try:
return super(ParseElementEnhance,self).__str__()
except:
pass
if self.strRepr is None and self.expr is not None:
self.strRepr = "%s:(%s)" % ( self.__class__.__name__, _ustr(self.expr) )
return self.strRepr
class FollowedBy(ParseElementEnhance):
"""Lookahead matching of the given parse expression. C{FollowedBy}
does *not* advance the parsing position within the input string, it only
verifies that the specified parse expression matches at the current
position. C{FollowedBy} always returns a null token list."""
def __init__( self, expr ):
super(FollowedBy,self).__init__(expr)
self.mayReturnEmpty = True
def parseImpl( self, instring, loc, doActions=True ):
self.expr.tryParse( instring, loc )
return loc, []
class NotAny(ParseElementEnhance):
"""Lookahead to disallow matching with the given parse expression. C{NotAny}
does *not* advance the parsing position within the input string, it only
verifies that the specified parse expression does *not* match at the current
position. Also, C{NotAny} does *not* skip over leading whitespace. C{NotAny}
always returns a null token list. May be constructed using the '~' operator."""
def __init__( self, expr ):
super(NotAny,self).__init__(expr)
#~ self.leaveWhitespace()
self.skipWhitespace = False # do NOT use self.leaveWhitespace(), don't want to propagate to exprs
self.mayReturnEmpty = True
self.errmsg = "Found unwanted token, "+_ustr(self.expr)
def parseImpl( self, instring, loc, doActions=True ):
try:
self.expr.tryParse( instring, loc )
except (ParseException,IndexError):
pass
else:
raise ParseException(instring, loc, self.errmsg, self)
return loc, []
def __str__( self ):
if hasattr(self,"name"):
return self.name
if self.strRepr is None:
self.strRepr = "~{" + _ustr(self.expr) + "}"
return self.strRepr
class ZeroOrMore(ParseElementEnhance):
"""Optional repetition of zero or more of the given expression."""
def __init__( self, expr ):
super(ZeroOrMore,self).__init__(expr)
self.mayReturnEmpty = True
def parseImpl( self, instring, loc, doActions=True ):
tokens = []
try:
loc, tokens = self.expr._parse( instring, loc, doActions, callPreParse=False )
hasIgnoreExprs = ( len(self.ignoreExprs) > 0 )
while 1:
if hasIgnoreExprs:
preloc = self._skipIgnorables( instring, loc )
else:
preloc = loc
loc, tmptokens = self.expr._parse( instring, preloc, doActions )
if tmptokens or tmptokens.haskeys():
tokens += tmptokens
except (ParseException,IndexError):
pass
return loc, tokens
def __str__( self ):
if hasattr(self,"name"):
return self.name
if self.strRepr is None:
self.strRepr = "[" + _ustr(self.expr) + "]..."
return self.strRepr
def setResultsName( self, name, listAllMatches=False ):
ret = super(ZeroOrMore,self).setResultsName(name,listAllMatches)
ret.saveAsList = True
return ret
class OneOrMore(ParseElementEnhance):
"""Repetition of one or more of the given expression."""
def parseImpl( self, instring, loc, doActions=True ):
# must be at least one
loc, tokens = self.expr._parse( instring, loc, doActions, callPreParse=False )
try:
hasIgnoreExprs = ( len(self.ignoreExprs) > 0 )
while 1:
if hasIgnoreExprs:
preloc = self._skipIgnorables( instring, loc )
else:
preloc = loc
loc, tmptokens = self.expr._parse( instring, preloc, doActions )
if tmptokens or tmptokens.haskeys():
tokens += tmptokens
except (ParseException,IndexError):
pass
return loc, tokens
def __str__( self ):
if hasattr(self,"name"):
return self.name
if self.strRepr is None:
self.strRepr = "{" + _ustr(self.expr) + "}..."
return self.strRepr
def setResultsName( self, name, listAllMatches=False ):
ret = super(OneOrMore,self).setResultsName(name,listAllMatches)
ret.saveAsList = True
return ret
class _NullToken(object):
def __bool__(self):
return False
__nonzero__ = __bool__
def __str__(self):
return ""
_optionalNotMatched = _NullToken()
class Optional(ParseElementEnhance):
"""Optional matching of the given expression.
A default return string can also be specified, if the optional expression
is not found.
"""
def __init__( self, expr, default=_optionalNotMatched ):
super(Optional,self).__init__( expr, savelist=False )
self.defaultValue = default
self.mayReturnEmpty = True
def parseImpl( self, instring, loc, doActions=True ):
try:
loc, tokens = self.expr._parse( instring, loc, doActions, callPreParse=False )
except (ParseException,IndexError):
if self.defaultValue is not _optionalNotMatched:
if self.expr.resultsName:
tokens = ParseResults([ self.defaultValue ])
tokens[self.expr.resultsName] = self.defaultValue
else:
tokens = [ self.defaultValue ]
else:
tokens = []
return loc, tokens
def __str__( self ):
if hasattr(self,"name"):
return self.name
if self.strRepr is None:
self.strRepr = "[" + _ustr(self.expr) + "]"
return self.strRepr
class SkipTo(ParseElementEnhance):
"""Token for skipping over all undefined text until the matched expression is found.
If C{include} is set to true, the matched expression is also parsed (the skipped text
and matched expression are returned as a 2-element list). The C{ignore}
argument is used to define grammars (typically quoted strings and comments) that
might contain false matches.
"""
def __init__( self, other, include=False, ignore=None, failOn=None ):
super( SkipTo, self ).__init__( other )
self.ignoreExpr = ignore
self.mayReturnEmpty = True
self.mayIndexError = False
self.includeMatch = include
self.asList = False
if failOn is not None and isinstance(failOn, basestring):
self.failOn = Literal(failOn)
else:
self.failOn = failOn
self.errmsg = "No match found for "+_ustr(self.expr)
def parseImpl( self, instring, loc, doActions=True ):
startLoc = loc
instrlen = len(instring)
expr = self.expr
failParse = False
while loc <= instrlen:
try:
if self.failOn:
try:
self.failOn.tryParse(instring, loc)
except ParseBaseException:
pass
else:
failParse = True
raise ParseException(instring, loc, "Found expression " + str(self.failOn))
failParse = False
if self.ignoreExpr is not None:
while 1:
try:
loc = self.ignoreExpr.tryParse(instring,loc)
# print("found ignoreExpr, advance to", loc)
except ParseBaseException:
break
expr._parse( instring, loc, doActions=False, callPreParse=False )
skipText = instring[startLoc:loc]
if self.includeMatch:
loc,mat = expr._parse(instring,loc,doActions,callPreParse=False)
if mat:
skipRes = ParseResults( skipText )
skipRes += mat
return loc, [ skipRes ]
else:
return loc, [ skipText ]
else:
return loc, [ skipText ]
except (ParseException,IndexError):
if failParse:
raise
else:
loc += 1
raise ParseException(instring, loc, self.errmsg, self)
class Forward(ParseElementEnhance):
"""Forward declaration of an expression to be defined later -
used for recursive grammars, such as algebraic infix notation.
When the expression is known, it is assigned to the C{Forward} variable using the '<<' operator.
Note: take care when assigning to C{Forward} not to overlook precedence of operators.
Specifically, '|' has a lower precedence than '<<', so that::
fwdExpr << a | b | c
will actually be evaluated as::
(fwdExpr << a) | b | c
thereby leaving b and c out as parseable alternatives. It is recommended that you
explicitly group the values inserted into the C{Forward}::
fwdExpr << (a | b | c)
Converting to use the '<<=' operator instead will avoid this problem.
"""
def __init__( self, other=None ):
super(Forward,self).__init__( other, savelist=False )
def __lshift__( self, other ):
if isinstance( other, basestring ):
other = ParserElement.literalStringClass(other)
self.expr = other
self.mayReturnEmpty = other.mayReturnEmpty
self.strRepr = None
self.mayIndexError = self.expr.mayIndexError
self.mayReturnEmpty = self.expr.mayReturnEmpty
self.setWhitespaceChars( self.expr.whiteChars )
self.skipWhitespace = self.expr.skipWhitespace
self.saveAsList = self.expr.saveAsList
self.ignoreExprs.extend(self.expr.ignoreExprs)
return self
def __ilshift__(self, other):
return self << other
def leaveWhitespace( self ):
self.skipWhitespace = False
return self
def streamline( self ):
if not self.streamlined:
self.streamlined = True
if self.expr is not None:
self.expr.streamline()
return self
def validate( self, validateTrace=[] ):
if self not in validateTrace:
tmp = validateTrace[:]+[self]
if self.expr is not None:
self.expr.validate(tmp)
self.checkRecursion([])
def __str__( self ):
if hasattr(self,"name"):
return self.name
self._revertClass = self.__class__
self.__class__ = _ForwardNoRecurse
try:
if self.expr is not None:
retString = _ustr(self.expr)
else:
retString = "None"
finally:
self.__class__ = self._revertClass
return self.__class__.__name__ + ": " + retString
def copy(self):
if self.expr is not None:
return super(Forward,self).copy()
else:
ret = Forward()
ret <<= self
return ret
class _ForwardNoRecurse(Forward):
def __str__( self ):
return "..."
class TokenConverter(ParseElementEnhance):
"""Abstract subclass of C{ParseExpression}, for converting parsed results."""
def __init__( self, expr, savelist=False ):
super(TokenConverter,self).__init__( expr )#, savelist )
self.saveAsList = False
class Upcase(TokenConverter):
"""Converter to upper case all matching tokens."""
def __init__(self, *args):
super(Upcase,self).__init__(*args)
warnings.warn("Upcase class is deprecated, use upcaseTokens parse action instead",
DeprecationWarning,stacklevel=2)
def postParse( self, instring, loc, tokenlist ):
return list(map( str.upper, tokenlist ))
class Combine(TokenConverter):
"""Converter to concatenate all matching tokens to a single string.
By default, the matching patterns must also be contiguous in the input string;
this can be disabled by specifying C{'adjacent=False'} in the constructor.
"""
def __init__( self, expr, joinString="", adjacent=True ):
super(Combine,self).__init__( expr )
# suppress whitespace-stripping in contained parse expressions, but re-enable it on the Combine itself
if adjacent:
self.leaveWhitespace()
self.adjacent = adjacent
self.skipWhitespace = True
self.joinString = joinString
self.callPreparse = True
def ignore( self, other ):
if self.adjacent:
ParserElement.ignore(self, other)
else:
super( Combine, self).ignore( other )
return self
def postParse( self, instring, loc, tokenlist ):
retToks = tokenlist.copy()
del retToks[:]
retToks += ParseResults([ "".join(tokenlist._asStringList(self.joinString)) ], modal=self.modalResults)
if self.resultsName and retToks.haskeys():
return [ retToks ]
else:
return retToks
class Group(TokenConverter):
"""Converter to return the matched tokens as a list - useful for returning tokens of C{L{ZeroOrMore}} and C{L{OneOrMore}} expressions."""
def __init__( self, expr ):
super(Group,self).__init__( expr )
self.saveAsList = True
def postParse( self, instring, loc, tokenlist ):
return [ tokenlist ]
class Dict(TokenConverter):
"""Converter to return a repetitive expression as a list, but also as a dictionary.
Each element can also be referenced using the first token in the expression as its key.
Useful for tabular report scraping when the first column can be used as a item key.
"""
def __init__( self, expr ):
super(Dict,self).__init__( expr )
self.saveAsList = True
def postParse( self, instring, loc, tokenlist ):
for i,tok in enumerate(tokenlist):
if len(tok) == 0:
continue
ikey = tok[0]
if isinstance(ikey,int):
ikey = _ustr(tok[0]).strip()
if len(tok)==1:
tokenlist[ikey] = _ParseResultsWithOffset("",i)
elif len(tok)==2 and not isinstance(tok[1],ParseResults):
tokenlist[ikey] = _ParseResultsWithOffset(tok[1],i)
else:
dictvalue = tok.copy() #ParseResults(i)
del dictvalue[0]
if len(dictvalue)!= 1 or (isinstance(dictvalue,ParseResults) and dictvalue.haskeys()):
tokenlist[ikey] = _ParseResultsWithOffset(dictvalue,i)
else:
tokenlist[ikey] = _ParseResultsWithOffset(dictvalue[0],i)
if self.resultsName:
return [ tokenlist ]
else:
return tokenlist
class Suppress(TokenConverter):
"""Converter for ignoring the results of a parsed expression."""
def postParse( self, instring, loc, tokenlist ):
return []
def suppress( self ):
return self
class OnlyOnce(object):
"""Wrapper for parse actions, to ensure they are only called once."""
def __init__(self, methodCall):
self.callable = _trim_arity(methodCall)
self.called = False
def __call__(self,s,l,t):
if not self.called:
results = self.callable(s,l,t)
self.called = True
return results
raise ParseException(s,l,"")
def reset(self):
self.called = False
def traceParseAction(f):
"""Decorator for debugging parse actions."""
f = _trim_arity(f)
def z(*paArgs):
thisFunc = f.func_name
s,l,t = paArgs[-3:]
if len(paArgs)>3:
thisFunc = paArgs[0].__class__.__name__ + '.' + thisFunc
sys.stderr.write( ">>entering %s(line: '%s', %d, %s)\n" % (thisFunc,line(l,s),l,t) )
try:
ret = f(*paArgs)
except Exception as exc:
sys.stderr.write( "<", "|".join( [ _escapeRegexChars(sym) for sym in symbols] ))
try:
if len(symbols)==len("".join(symbols)):
return Regex( "[%s]" % "".join(_escapeRegexRangeChars(sym) for sym in symbols) )
else:
return Regex( "|".join(re.escape(sym) for sym in symbols) )
except:
warnings.warn("Exception creating Regex for oneOf, building MatchFirst",
SyntaxWarning, stacklevel=2)
# last resort, just use MatchFirst
return MatchFirst( [ parseElementClass(sym) for sym in symbols ] )
def dictOf( key, value ):
"""Helper to easily and clearly define a dictionary by specifying the respective patterns
for the key and value. Takes care of defining the C{L{Dict}}, C{L{ZeroOrMore}}, and C{L{Group}} tokens
in the proper order. The key pattern can include delimiting markers or punctuation,
as long as they are suppressed, thereby leaving the significant key text. The value
pattern can include named results, so that the C{Dict} results can include named token
fields.
"""
return Dict( ZeroOrMore( Group ( key + value ) ) )
def originalTextFor(expr, asString=True):
"""Helper to return the original, untokenized text for a given expression. Useful to
restore the parsed fields of an HTML start tag into the raw tag text itself, or to
revert separate tokens with intervening whitespace back to the original matching
input text. Simpler to use than the parse action C{L{keepOriginalText}}, and does not
require the inspect module to chase up the call stack. By default, returns a
string containing the original parsed text.
If the optional C{asString} argument is passed as C{False}, then the return value is a
C{L{ParseResults}} containing any results names that were originally matched, and a
single token containing the original matched text from the input string. So if
the expression passed to C{L{originalTextFor}} contains expressions with defined
results names, you must set C{asString} to C{False} if you want to preserve those
results name values."""
locMarker = Empty().setParseAction(lambda s,loc,t: loc)
endlocMarker = locMarker.copy()
endlocMarker.callPreparse = False
matchExpr = locMarker("_original_start") + expr + endlocMarker("_original_end")
if asString:
extractText = lambda s,l,t: s[t._original_start:t._original_end]
else:
def extractText(s,l,t):
del t[:]
t.insert(0, s[t._original_start:t._original_end])
del t["_original_start"]
del t["_original_end"]
matchExpr.setParseAction(extractText)
return matchExpr
def ungroup(expr):
"""Helper to undo pyparsing's default grouping of And expressions, even
if all but one are non-empty."""
return TokenConverter(expr).setParseAction(lambda t:t[0])
def locatedExpr(expr):
"""Helper to decorate a returned token with its starting and ending locations in the input string.
This helper adds the following results names:
- locn_start = location where matched expression begins
- locn_end = location where matched expression ends
- value = the actual parsed results
Be careful if the input text contains C{} characters, you may want to call
C{L{ParserElement.parseWithTabs}}
"""
locator = Empty().setParseAction(lambda s,l,t: l)
return Group(locator("locn_start") + expr("value") + locator.copy().leaveWhitespace()("locn_end"))
# convenience constants for positional expressions
empty = Empty().setName("empty")
lineStart = LineStart().setName("lineStart")
lineEnd = LineEnd().setName("lineEnd")
stringStart = StringStart().setName("stringStart")
stringEnd = StringEnd().setName("stringEnd")
_escapedPunc = Word( _bslash, r"\[]-*.$+^?()~ ", exact=2 ).setParseAction(lambda s,l,t:t[0][1])
_escapedHexChar = Regex(r"\\0?[xX][0-9a-fA-F]+").setParseAction(lambda s,l,t:unichr(int(t[0].lstrip(r'\0x'),16)))
_escapedOctChar = Regex(r"\\0[0-7]+").setParseAction(lambda s,l,t:unichr(int(t[0][1:],8)))
_singleChar = _escapedPunc | _escapedHexChar | _escapedOctChar | Word(printables, excludeChars=r'\]', exact=1) | Regex(r"\w", re.UNICODE)
_charRange = Group(_singleChar + Suppress("-") + _singleChar)
_reBracketExpr = Literal("[") + Optional("^").setResultsName("negate") + Group( OneOrMore( _charRange | _singleChar ) ).setResultsName("body") + "]"
def srange(s):
r"""Helper to easily define string ranges for use in Word construction. Borrows
syntax from regexp '[]' string range definitions::
srange("[0-9]") -> "0123456789"
srange("[a-z]") -> "abcdefghijklmnopqrstuvwxyz"
srange("[a-z$_]") -> "abcdefghijklmnopqrstuvwxyz$_"
The input string must be enclosed in []'s, and the returned string is the expanded
character set joined into a single string.
The values enclosed in the []'s may be::
a single character
an escaped character with a leading backslash (such as \- or \])
an escaped hex character with a leading '\x' (\x21, which is a '!' character)
(\0x## is also supported for backwards compatibility)
an escaped octal character with a leading '\0' (\041, which is a '!' character)
a range of any of the above, separated by a dash ('a-z', etc.)
any combination of the above ('aeiouy', 'a-zA-Z0-9_$', etc.)
"""
_expanded = lambda p: p if not isinstance(p,ParseResults) else ''.join(unichr(c) for c in range(ord(p[0]),ord(p[1])+1))
try:
return "".join(_expanded(part) for part in _reBracketExpr.parseString(s).body)
except:
return ""
def matchOnlyAtCol(n):
"""Helper method for defining parse actions that require matching at a specific
column in the input text.
"""
def verifyCol(strg,locn,toks):
if col(locn,strg) != n:
raise ParseException(strg,locn,"matched token not at column %d" % n)
return verifyCol
def replaceWith(replStr):
"""Helper method for common parse actions that simply return a literal value. Especially
useful when used with C{L{transformString}()}.
"""
#def _replFunc(*args):
# return [replStr]
#return _replFunc
return functools.partial(next, itertools.repeat([replStr]))
def removeQuotes(s,l,t):
"""Helper parse action for removing quotation marks from parsed quoted strings.
To use, add this parse action to quoted string using::
quotedString.setParseAction( removeQuotes )
"""
return t[0][1:-1]
def upcaseTokens(s,l,t):
"""Helper parse action to convert tokens to upper case."""
return [ tt.upper() for tt in map(_ustr,t) ]
def downcaseTokens(s,l,t):
"""Helper parse action to convert tokens to lower case."""
return [ tt.lower() for tt in map(_ustr,t) ]
def keepOriginalText(s,startLoc,t):
"""DEPRECATED - use new helper method C{L{originalTextFor}}.
Helper parse action to preserve original parsed text,
overriding any nested parse actions."""
try:
endloc = getTokensEndLoc()
except ParseException:
raise ParseFatalException("incorrect usage of keepOriginalText - may only be called as a parse action")
del t[:]
t += ParseResults(s[startLoc:endloc])
return t
def getTokensEndLoc():
"""Method to be called from within a parse action to determine the end
location of the parsed tokens."""
import inspect
fstack = inspect.stack()
try:
# search up the stack (through intervening argument normalizers) for correct calling routine
for f in fstack[2:]:
if f[3] == "_parseNoCache":
endloc = f[0].f_locals["loc"]
return endloc
else:
raise ParseFatalException("incorrect usage of getTokensEndLoc - may only be called from within a parse action")
finally:
del fstack
def _makeTags(tagStr, xml):
"""Internal helper to construct opening and closing tag expressions, given a tag name"""
if isinstance(tagStr,basestring):
resname = tagStr
tagStr = Keyword(tagStr, caseless=not xml)
else:
resname = tagStr.name
tagAttrName = Word(alphas,alphanums+"_-:")
if (xml):
tagAttrValue = dblQuotedString.copy().setParseAction( removeQuotes )
openTag = Suppress("<") + tagStr("tag") + \
Dict(ZeroOrMore(Group( tagAttrName + Suppress("=") + tagAttrValue ))) + \
Optional("/",default=[False]).setResultsName("empty").setParseAction(lambda s,l,t:t[0]=='/') + Suppress(">")
else:
printablesLessRAbrack = "".join(c for c in printables if c not in ">")
tagAttrValue = quotedString.copy().setParseAction( removeQuotes ) | Word(printablesLessRAbrack)
openTag = Suppress("<") + tagStr("tag") + \
Dict(ZeroOrMore(Group( tagAttrName.setParseAction(downcaseTokens) + \
Optional( Suppress("=") + tagAttrValue ) ))) + \
Optional("/",default=[False]).setResultsName("empty").setParseAction(lambda s,l,t:t[0]=='/') + Suppress(">")
closeTag = Combine(_L("")
openTag = openTag.setResultsName("start"+"".join(resname.replace(":"," ").title().split())).setName("<%s>" % tagStr)
closeTag = closeTag.setResultsName("end"+"".join(resname.replace(":"," ").title().split())).setName("" % tagStr)
openTag.tag = resname
closeTag.tag = resname
return openTag, closeTag
def makeHTMLTags(tagStr):
"""Helper to construct opening and closing tag expressions for HTML, given a tag name"""
return _makeTags( tagStr, False )
def makeXMLTags(tagStr):
"""Helper to construct opening and closing tag expressions for XML, given a tag name"""
return _makeTags( tagStr, True )
def withAttribute(*args,**attrDict):
"""Helper to create a validating parse action to be used with start tags created
with C{L{makeXMLTags}} or C{L{makeHTMLTags}}. Use C{withAttribute} to qualify a starting tag
with a required attribute value, to avoid false matches on common tags such as
C{} or C{}.
Call C{withAttribute} with a series of attribute names and values. Specify the list
of filter attributes names and values as:
- keyword arguments, as in C{(align="right")}, or
- as an explicit dict with C{**} operator, when an attribute name is also a Python
reserved word, as in C{**{"class":"Customer", "align":"right"}}
- a list of name-value tuples, as in ( ("ns1:class", "Customer"), ("ns2:align","right") )
For attribute names with a namespace prefix, you must use the second form. Attribute
names are matched insensitive to upper/lower case.
If just testing for C{class} (with or without a namespace), use C{L{withClass}}.
To verify that the attribute exists, but without specifying a value, pass
C{withAttribute.ANY_VALUE} as the value.
"""
if args:
attrs = args[:]
else:
attrs = attrDict.items()
attrs = [(k,v) for k,v in attrs]
def pa(s,l,tokens):
for attrName,attrValue in attrs:
if attrName not in tokens:
raise ParseException(s,l,"no matching attribute " + attrName)
if attrValue != withAttribute.ANY_VALUE and tokens[attrName] != attrValue:
raise ParseException(s,l,"attribute '%s' has value '%s', must be '%s'" %
(attrName, tokens[attrName], attrValue))
return pa
withAttribute.ANY_VALUE = object()
def withClass(classname, namespace=''):
"""Simplified version of C{L{withAttribute}} when matching on a div class - made
difficult because C{class} is a reserved word in Python.
"""
classattr = "%s:class" % namespace if namespace else "class"
return withAttribute(**{classattr : classname})
opAssoc = _Constants()
opAssoc.LEFT = object()
opAssoc.RIGHT = object()
def infixNotation( baseExpr, opList, lpar=Suppress('('), rpar=Suppress(')') ):
"""Helper method for constructing grammars of expressions made up of
operators working in a precedence hierarchy. Operators may be unary or
binary, left- or right-associative. Parse actions can also be attached
to operator expressions.
Parameters:
- baseExpr - expression representing the most basic element for the nested
- opList - list of tuples, one for each operator precedence level in the
expression grammar; each tuple is of the form
(opExpr, numTerms, rightLeftAssoc, parseAction), where:
- opExpr is the pyparsing expression for the operator;
may also be a string, which will be converted to a Literal;
if numTerms is 3, opExpr is a tuple of two expressions, for the
two operators separating the 3 terms
- numTerms is the number of terms for this operator (must
be 1, 2, or 3)
- rightLeftAssoc is the indicator whether the operator is
right or left associative, using the pyparsing-defined
constants C{opAssoc.RIGHT} and C{opAssoc.LEFT}.
- parseAction is the parse action to be associated with
expressions matching this operator expression (the
parse action tuple member may be omitted)
- lpar - expression for matching left-parentheses (default=Suppress('('))
- rpar - expression for matching right-parentheses (default=Suppress(')'))
"""
ret = Forward()
lastExpr = baseExpr | ( lpar + ret + rpar )
for i,operDef in enumerate(opList):
opExpr,arity,rightLeftAssoc,pa = (operDef + (None,))[:4]
if arity == 3:
if opExpr is None or len(opExpr) != 2:
raise ValueError("if numterms=3, opExpr must be a tuple or list of two expressions")
opExpr1, opExpr2 = opExpr
thisExpr = Forward()#.setName("expr%d" % i)
if rightLeftAssoc == opAssoc.LEFT:
if arity == 1:
matchExpr = FollowedBy(lastExpr + opExpr) + Group( lastExpr + OneOrMore( opExpr ) )
elif arity == 2:
if opExpr is not None:
matchExpr = FollowedBy(lastExpr + opExpr + lastExpr) + Group( lastExpr + OneOrMore( opExpr + lastExpr ) )
else:
matchExpr = FollowedBy(lastExpr+lastExpr) + Group( lastExpr + OneOrMore(lastExpr) )
elif arity == 3:
matchExpr = FollowedBy(lastExpr + opExpr1 + lastExpr + opExpr2 + lastExpr) + \
Group( lastExpr + opExpr1 + lastExpr + opExpr2 + lastExpr )
else:
raise ValueError("operator must be unary (1), binary (2), or ternary (3)")
elif rightLeftAssoc == opAssoc.RIGHT:
if arity == 1:
# try to avoid LR with this extra test
if not isinstance(opExpr, Optional):
opExpr = Optional(opExpr)
matchExpr = FollowedBy(opExpr.expr + thisExpr) + Group( opExpr + thisExpr )
elif arity == 2:
if opExpr is not None:
matchExpr = FollowedBy(lastExpr + opExpr + thisExpr) + Group( lastExpr + OneOrMore( opExpr + thisExpr ) )
else:
matchExpr = FollowedBy(lastExpr + thisExpr) + Group( lastExpr + OneOrMore( thisExpr ) )
elif arity == 3:
matchExpr = FollowedBy(lastExpr + opExpr1 + thisExpr + opExpr2 + thisExpr) + \
Group( lastExpr + opExpr1 + thisExpr + opExpr2 + thisExpr )
else:
raise ValueError("operator must be unary (1), binary (2), or ternary (3)")
else:
raise ValueError("operator must indicate right or left associativity")
if pa:
matchExpr.setParseAction( pa )
thisExpr <<= ( matchExpr | lastExpr )
lastExpr = thisExpr
ret <<= lastExpr
return ret
operatorPrecedence = infixNotation
dblQuotedString = Regex(r'"(?:[^"\n\r\\]|(?:"")|(?:\\x[0-9a-fA-F]+)|(?:\\.))*"').setName("string enclosed in double quotes")
sglQuotedString = Regex(r"'(?:[^'\n\r\\]|(?:'')|(?:\\x[0-9a-fA-F]+)|(?:\\.))*'").setName("string enclosed in single quotes")
quotedString = Regex(r'''(?:"(?:[^"\n\r\\]|(?:"")|(?:\\x[0-9a-fA-F]+)|(?:\\.))*")|(?:'(?:[^'\n\r\\]|(?:'')|(?:\\x[0-9a-fA-F]+)|(?:\\.))*')''').setName("quotedString using single or double quotes")
unicodeString = Combine(_L('u') + quotedString.copy())
def nestedExpr(opener="(", closer=")", content=None, ignoreExpr=quotedString.copy()):
"""Helper method for defining nested lists enclosed in opening and closing
delimiters ("(" and ")" are the default).
Parameters:
- opener - opening character for a nested list (default="("); can also be a pyparsing expression
- closer - closing character for a nested list (default=")"); can also be a pyparsing expression
- content - expression for items within the nested lists (default=None)
- ignoreExpr - expression for ignoring opening and closing delimiters (default=quotedString)
If an expression is not provided for the content argument, the nested
expression will capture all whitespace-delimited content between delimiters
as a list of separate values.
Use the C{ignoreExpr} argument to define expressions that may contain
opening or closing characters that should not be treated as opening
or closing characters for nesting, such as quotedString or a comment
expression. Specify multiple expressions using an C{L{Or}} or C{L{MatchFirst}}.
The default is L{quotedString}, but if no expressions are to be ignored,
then pass C{None} for this argument.
"""
if opener == closer:
raise ValueError("opening and closing strings cannot be the same")
if content is None:
if isinstance(opener,basestring) and isinstance(closer,basestring):
if len(opener) == 1 and len(closer)==1:
if ignoreExpr is not None:
content = (Combine(OneOrMore(~ignoreExpr +
CharsNotIn(opener+closer+ParserElement.DEFAULT_WHITE_CHARS,exact=1))
).setParseAction(lambda t:t[0].strip()))
else:
content = (empty.copy()+CharsNotIn(opener+closer+ParserElement.DEFAULT_WHITE_CHARS
).setParseAction(lambda t:t[0].strip()))
else:
if ignoreExpr is not None:
content = (Combine(OneOrMore(~ignoreExpr +
~Literal(opener) + ~Literal(closer) +
CharsNotIn(ParserElement.DEFAULT_WHITE_CHARS,exact=1))
).setParseAction(lambda t:t[0].strip()))
else:
content = (Combine(OneOrMore(~Literal(opener) + ~Literal(closer) +
CharsNotIn(ParserElement.DEFAULT_WHITE_CHARS,exact=1))
).setParseAction(lambda t:t[0].strip()))
else:
raise ValueError("opening and closing arguments must be strings if no content expression is given")
ret = Forward()
if ignoreExpr is not None:
ret <<= Group( Suppress(opener) + ZeroOrMore( ignoreExpr | ret | content ) + Suppress(closer) )
else:
ret <<= Group( Suppress(opener) + ZeroOrMore( ret | content ) + Suppress(closer) )
return ret
def indentedBlock(blockStatementExpr, indentStack, indent=True):
"""Helper method for defining space-delimited indentation blocks, such as
those used to define block statements in Python source code.
Parameters:
- blockStatementExpr - expression defining syntax of statement that
is repeated within the indented block
- indentStack - list created by caller to manage indentation stack
(multiple statementWithIndentedBlock expressions within a single grammar
should share a common indentStack)
- indent - boolean indicating whether block must be indented beyond the
the current level; set to False for block of left-most statements
(default=True)
A valid block must contain at least one C{blockStatement}.
"""
def checkPeerIndent(s,l,t):
if l >= len(s): return
curCol = col(l,s)
if curCol != indentStack[-1]:
if curCol > indentStack[-1]:
raise ParseFatalException(s,l,"illegal nesting")
raise ParseException(s,l,"not a peer entry")
def checkSubIndent(s,l,t):
curCol = col(l,s)
if curCol > indentStack[-1]:
indentStack.append( curCol )
else:
raise ParseException(s,l,"not a subentry")
def checkUnindent(s,l,t):
if l >= len(s): return
curCol = col(l,s)
if not(indentStack and curCol < indentStack[-1] and curCol <= indentStack[-2]):
raise ParseException(s,l,"not an unindent")
indentStack.pop()
NL = OneOrMore(LineEnd().setWhitespaceChars("\t ").suppress())
INDENT = Empty() + Empty().setParseAction(checkSubIndent)
PEER = Empty().setParseAction(checkPeerIndent)
UNDENT = Empty().setParseAction(checkUnindent)
if indent:
smExpr = Group( Optional(NL) +
#~ FollowedBy(blockStatementExpr) +
INDENT + (OneOrMore( PEER + Group(blockStatementExpr) + Optional(NL) )) + UNDENT)
else:
smExpr = Group( Optional(NL) +
(OneOrMore( PEER + Group(blockStatementExpr) + Optional(NL) )) )
blockStatementExpr.ignore(_bslash + LineEnd())
return smExpr
alphas8bit = srange(r"[\0xc0-\0xd6\0xd8-\0xf6\0xf8-\0xff]")
punc8bit = srange(r"[\0xa1-\0xbf\0xd7\0xf7]")
anyOpenTag,anyCloseTag = makeHTMLTags(Word(alphas,alphanums+"_:"))
commonHTMLEntity = Combine(_L("&") + oneOf("gt lt amp nbsp quot").setResultsName("entity") +";").streamline()
_htmlEntityMap = dict(zip("gt lt amp nbsp quot".split(),'><& "'))
replaceHTMLEntity = lambda t : t.entity in _htmlEntityMap and _htmlEntityMap[t.entity] or None
# it's easy to get these comment structures wrong - they're very common, so may as well make them available
cStyleComment = Regex(r"/\*(?:[^*]*\*+)+?/").setName("C style comment")
htmlComment = Regex(r"")
restOfLine = Regex(r".*").leaveWhitespace()
dblSlashComment = Regex(r"\/\/(\\\n|.)*").setName("// comment")
cppStyleComment = Regex(r"/(?:\*(?:[^*]*\*+)+?/|/[^\n]*(?:\n[^\n]*)*?(?:(?"
__version__ = "1.10.0"
# Useful for very coarse version differentiation.
PY2 = sys.version_info[0] == 2
PY3 = sys.version_info[0] == 3
PY34 = sys.version_info[0:2] >= (3, 4)
if PY3:
string_types = str,
integer_types = int,
class_types = type,
text_type = str
binary_type = bytes
MAXSIZE = sys.maxsize
else:
string_types = basestring,
integer_types = (int, long)
class_types = (type, types.ClassType)
text_type = unicode
binary_type = str
if sys.platform.startswith("java"):
# Jython always uses 32 bits.
MAXSIZE = int((1 << 31) - 1)
else:
# It's possible to have sizeof(long) != sizeof(Py_ssize_t).
class X(object):
def __len__(self):
return 1 << 31
try:
len(X())
except OverflowError:
# 32-bit
MAXSIZE = int((1 << 31) - 1)
else:
# 64-bit
MAXSIZE = int((1 << 63) - 1)
del X
def _add_doc(func, doc):
"""Add documentation to a function."""
func.__doc__ = doc
def _import_module(name):
"""Import module, returning the module after the last dot."""
__import__(name)
return sys.modules[name]
class _LazyDescr(object):
def __init__(self, name):
self.name = name
def __get__(self, obj, tp):
result = self._resolve()
setattr(obj, self.name, result) # Invokes __set__.
try:
# This is a bit ugly, but it avoids running this again by
# removing this descriptor.
delattr(obj.__class__, self.name)
except AttributeError:
pass
return result
class MovedModule(_LazyDescr):
def __init__(self, name, old, new=None):
super(MovedModule, self).__init__(name)
if PY3:
if new is None:
new = name
self.mod = new
else:
self.mod = old
def _resolve(self):
return _import_module(self.mod)
def __getattr__(self, attr):
_module = self._resolve()
value = getattr(_module, attr)
setattr(self, attr, value)
return value
class _LazyModule(types.ModuleType):
def __init__(self, name):
super(_LazyModule, self).__init__(name)
self.__doc__ = self.__class__.__doc__
def __dir__(self):
attrs = ["__doc__", "__name__"]
attrs += [attr.name for attr in self._moved_attributes]
return attrs
# Subclasses should override this
_moved_attributes = []
class MovedAttribute(_LazyDescr):
def __init__(self, name, old_mod, new_mod, old_attr=None, new_attr=None):
super(MovedAttribute, self).__init__(name)
if PY3:
if new_mod is None:
new_mod = name
self.mod = new_mod
if new_attr is None:
if old_attr is None:
new_attr = name
else:
new_attr = old_attr
self.attr = new_attr
else:
self.mod = old_mod
if old_attr is None:
old_attr = name
self.attr = old_attr
def _resolve(self):
module = _import_module(self.mod)
return getattr(module, self.attr)
class _SixMetaPathImporter(object):
"""
A meta path importer to import six.moves and its submodules.
This class implements a PEP302 finder and loader. It should be compatible
with Python 2.5 and all existing versions of Python3
"""
def __init__(self, six_module_name):
self.name = six_module_name
self.known_modules = {}
def _add_module(self, mod, *fullnames):
for fullname in fullnames:
self.known_modules[self.name + "." + fullname] = mod
def _get_module(self, fullname):
return self.known_modules[self.name + "." + fullname]
def find_module(self, fullname, path=None):
if fullname in self.known_modules:
return self
return None
def __get_module(self, fullname):
try:
return self.known_modules[fullname]
except KeyError:
raise ImportError("This loader does not know module " + fullname)
def load_module(self, fullname):
try:
# in case of a reload
return sys.modules[fullname]
except KeyError:
pass
mod = self.__get_module(fullname)
if isinstance(mod, MovedModule):
mod = mod._resolve()
else:
mod.__loader__ = self
sys.modules[fullname] = mod
return mod
def is_package(self, fullname):
"""
Return true, if the named module is a package.
We need this method to get correct spec objects with
Python 3.4 (see PEP451)
"""
return hasattr(self.__get_module(fullname), "__path__")
def get_code(self, fullname):
"""Return None
Required, if is_package is implemented"""
self.__get_module(fullname) # eventually raises ImportError
return None
get_source = get_code # same as get_code
_importer = _SixMetaPathImporter(__name__)
class _MovedItems(_LazyModule):
"""Lazy loading of moved objects"""
__path__ = [] # mark as package
_moved_attributes = [
MovedAttribute("cStringIO", "cStringIO", "io", "StringIO"),
MovedAttribute("filter", "itertools", "builtins", "ifilter", "filter"),
MovedAttribute("filterfalse", "itertools", "itertools", "ifilterfalse", "filterfalse"),
MovedAttribute("input", "__builtin__", "builtins", "raw_input", "input"),
MovedAttribute("intern", "__builtin__", "sys"),
MovedAttribute("map", "itertools", "builtins", "imap", "map"),
MovedAttribute("getcwd", "os", "os", "getcwdu", "getcwd"),
MovedAttribute("getcwdb", "os", "os", "getcwd", "getcwdb"),
MovedAttribute("range", "__builtin__", "builtins", "xrange", "range"),
MovedAttribute("reload_module", "__builtin__", "importlib" if PY34 else "imp", "reload"),
MovedAttribute("reduce", "__builtin__", "functools"),
MovedAttribute("shlex_quote", "pipes", "shlex", "quote"),
MovedAttribute("StringIO", "StringIO", "io"),
MovedAttribute("UserDict", "UserDict", "collections"),
MovedAttribute("UserList", "UserList", "collections"),
MovedAttribute("UserString", "UserString", "collections"),
MovedAttribute("xrange", "__builtin__", "builtins", "xrange", "range"),
MovedAttribute("zip", "itertools", "builtins", "izip", "zip"),
MovedAttribute("zip_longest", "itertools", "itertools", "izip_longest", "zip_longest"),
MovedModule("builtins", "__builtin__"),
MovedModule("configparser", "ConfigParser"),
MovedModule("copyreg", "copy_reg"),
MovedModule("dbm_gnu", "gdbm", "dbm.gnu"),
MovedModule("_dummy_thread", "dummy_thread", "_dummy_thread"),
MovedModule("http_cookiejar", "cookielib", "http.cookiejar"),
MovedModule("http_cookies", "Cookie", "http.cookies"),
MovedModule("html_entities", "htmlentitydefs", "html.entities"),
MovedModule("html_parser", "HTMLParser", "html.parser"),
MovedModule("http_client", "httplib", "http.client"),
MovedModule("email_mime_multipart", "email.MIMEMultipart", "email.mime.multipart"),
MovedModule("email_mime_nonmultipart", "email.MIMENonMultipart", "email.mime.nonmultipart"),
MovedModule("email_mime_text", "email.MIMEText", "email.mime.text"),
MovedModule("email_mime_base", "email.MIMEBase", "email.mime.base"),
MovedModule("BaseHTTPServer", "BaseHTTPServer", "http.server"),
MovedModule("CGIHTTPServer", "CGIHTTPServer", "http.server"),
MovedModule("SimpleHTTPServer", "SimpleHTTPServer", "http.server"),
MovedModule("cPickle", "cPickle", "pickle"),
MovedModule("queue", "Queue"),
MovedModule("reprlib", "repr"),
MovedModule("socketserver", "SocketServer"),
MovedModule("_thread", "thread", "_thread"),
MovedModule("tkinter", "Tkinter"),
MovedModule("tkinter_dialog", "Dialog", "tkinter.dialog"),
MovedModule("tkinter_filedialog", "FileDialog", "tkinter.filedialog"),
MovedModule("tkinter_scrolledtext", "ScrolledText", "tkinter.scrolledtext"),
MovedModule("tkinter_simpledialog", "SimpleDialog", "tkinter.simpledialog"),
MovedModule("tkinter_tix", "Tix", "tkinter.tix"),
MovedModule("tkinter_ttk", "ttk", "tkinter.ttk"),
MovedModule("tkinter_constants", "Tkconstants", "tkinter.constants"),
MovedModule("tkinter_dnd", "Tkdnd", "tkinter.dnd"),
MovedModule("tkinter_colorchooser", "tkColorChooser",
"tkinter.colorchooser"),
MovedModule("tkinter_commondialog", "tkCommonDialog",
"tkinter.commondialog"),
MovedModule("tkinter_tkfiledialog", "tkFileDialog", "tkinter.filedialog"),
MovedModule("tkinter_font", "tkFont", "tkinter.font"),
MovedModule("tkinter_messagebox", "tkMessageBox", "tkinter.messagebox"),
MovedModule("tkinter_tksimpledialog", "tkSimpleDialog",
"tkinter.simpledialog"),
MovedModule("urllib_parse", __name__ + ".moves.urllib_parse", "urllib.parse"),
MovedModule("urllib_error", __name__ + ".moves.urllib_error", "urllib.error"),
MovedModule("urllib", __name__ + ".moves.urllib", __name__ + ".moves.urllib"),
MovedModule("urllib_robotparser", "robotparser", "urllib.robotparser"),
MovedModule("xmlrpc_client", "xmlrpclib", "xmlrpc.client"),
MovedModule("xmlrpc_server", "SimpleXMLRPCServer", "xmlrpc.server"),
]
# Add windows specific modules.
if sys.platform == "win32":
_moved_attributes += [
MovedModule("winreg", "_winreg"),
]
for attr in _moved_attributes:
setattr(_MovedItems, attr.name, attr)
if isinstance(attr, MovedModule):
_importer._add_module(attr, "moves." + attr.name)
del attr
_MovedItems._moved_attributes = _moved_attributes
moves = _MovedItems(__name__ + ".moves")
_importer._add_module(moves, "moves")
class Module_six_moves_urllib_parse(_LazyModule):
"""Lazy loading of moved objects in six.moves.urllib_parse"""
_urllib_parse_moved_attributes = [
MovedAttribute("ParseResult", "urlparse", "urllib.parse"),
MovedAttribute("SplitResult", "urlparse", "urllib.parse"),
MovedAttribute("parse_qs", "urlparse", "urllib.parse"),
MovedAttribute("parse_qsl", "urlparse", "urllib.parse"),
MovedAttribute("urldefrag", "urlparse", "urllib.parse"),
MovedAttribute("urljoin", "urlparse", "urllib.parse"),
MovedAttribute("urlparse", "urlparse", "urllib.parse"),
MovedAttribute("urlsplit", "urlparse", "urllib.parse"),
MovedAttribute("urlunparse", "urlparse", "urllib.parse"),
MovedAttribute("urlunsplit", "urlparse", "urllib.parse"),
MovedAttribute("quote", "urllib", "urllib.parse"),
MovedAttribute("quote_plus", "urllib", "urllib.parse"),
MovedAttribute("unquote", "urllib", "urllib.parse"),
MovedAttribute("unquote_plus", "urllib", "urllib.parse"),
MovedAttribute("urlencode", "urllib", "urllib.parse"),
MovedAttribute("splitquery", "urllib", "urllib.parse"),
MovedAttribute("splittag", "urllib", "urllib.parse"),
MovedAttribute("splituser", "urllib", "urllib.parse"),
MovedAttribute("uses_fragment", "urlparse", "urllib.parse"),
MovedAttribute("uses_netloc", "urlparse", "urllib.parse"),
MovedAttribute("uses_params", "urlparse", "urllib.parse"),
MovedAttribute("uses_query", "urlparse", "urllib.parse"),
MovedAttribute("uses_relative", "urlparse", "urllib.parse"),
]
for attr in _urllib_parse_moved_attributes:
setattr(Module_six_moves_urllib_parse, attr.name, attr)
del attr
Module_six_moves_urllib_parse._moved_attributes = _urllib_parse_moved_attributes
_importer._add_module(Module_six_moves_urllib_parse(__name__ + ".moves.urllib_parse"),
"moves.urllib_parse", "moves.urllib.parse")
class Module_six_moves_urllib_error(_LazyModule):
"""Lazy loading of moved objects in six.moves.urllib_error"""
_urllib_error_moved_attributes = [
MovedAttribute("URLError", "urllib2", "urllib.error"),
MovedAttribute("HTTPError", "urllib2", "urllib.error"),
MovedAttribute("ContentTooShortError", "urllib", "urllib.error"),
]
for attr in _urllib_error_moved_attributes:
setattr(Module_six_moves_urllib_error, attr.name, attr)
del attr
Module_six_moves_urllib_error._moved_attributes = _urllib_error_moved_attributes
_importer._add_module(Module_six_moves_urllib_error(__name__ + ".moves.urllib.error"),
"moves.urllib_error", "moves.urllib.error")
class Module_six_moves_urllib_request(_LazyModule):
"""Lazy loading of moved objects in six.moves.urllib_request"""
_urllib_request_moved_attributes = [
MovedAttribute("urlopen", "urllib2", "urllib.request"),
MovedAttribute("install_opener", "urllib2", "urllib.request"),
MovedAttribute("build_opener", "urllib2", "urllib.request"),
MovedAttribute("pathname2url", "urllib", "urllib.request"),
MovedAttribute("url2pathname", "urllib", "urllib.request"),
MovedAttribute("getproxies", "urllib", "urllib.request"),
MovedAttribute("Request", "urllib2", "urllib.request"),
MovedAttribute("OpenerDirector", "urllib2", "urllib.request"),
MovedAttribute("HTTPDefaultErrorHandler", "urllib2", "urllib.request"),
MovedAttribute("HTTPRedirectHandler", "urllib2", "urllib.request"),
MovedAttribute("HTTPCookieProcessor", "urllib2", "urllib.request"),
MovedAttribute("ProxyHandler", "urllib2", "urllib.request"),
MovedAttribute("BaseHandler", "urllib2", "urllib.request"),
MovedAttribute("HTTPPasswordMgr", "urllib2", "urllib.request"),
MovedAttribute("HTTPPasswordMgrWithDefaultRealm", "urllib2", "urllib.request"),
MovedAttribute("AbstractBasicAuthHandler", "urllib2", "urllib.request"),
MovedAttribute("HTTPBasicAuthHandler", "urllib2", "urllib.request"),
MovedAttribute("ProxyBasicAuthHandler", "urllib2", "urllib.request"),
MovedAttribute("AbstractDigestAuthHandler", "urllib2", "urllib.request"),
MovedAttribute("HTTPDigestAuthHandler", "urllib2", "urllib.request"),
MovedAttribute("ProxyDigestAuthHandler", "urllib2", "urllib.request"),
MovedAttribute("HTTPHandler", "urllib2", "urllib.request"),
MovedAttribute("HTTPSHandler", "urllib2", "urllib.request"),
MovedAttribute("FileHandler", "urllib2", "urllib.request"),
MovedAttribute("FTPHandler", "urllib2", "urllib.request"),
MovedAttribute("CacheFTPHandler", "urllib2", "urllib.request"),
MovedAttribute("UnknownHandler", "urllib2", "urllib.request"),
MovedAttribute("HTTPErrorProcessor", "urllib2", "urllib.request"),
MovedAttribute("urlretrieve", "urllib", "urllib.request"),
MovedAttribute("urlcleanup", "urllib", "urllib.request"),
MovedAttribute("URLopener", "urllib", "urllib.request"),
MovedAttribute("FancyURLopener", "urllib", "urllib.request"),
MovedAttribute("proxy_bypass", "urllib", "urllib.request"),
]
for attr in _urllib_request_moved_attributes:
setattr(Module_six_moves_urllib_request, attr.name, attr)
del attr
Module_six_moves_urllib_request._moved_attributes = _urllib_request_moved_attributes
_importer._add_module(Module_six_moves_urllib_request(__name__ + ".moves.urllib.request"),
"moves.urllib_request", "moves.urllib.request")
class Module_six_moves_urllib_response(_LazyModule):
"""Lazy loading of moved objects in six.moves.urllib_response"""
_urllib_response_moved_attributes = [
MovedAttribute("addbase", "urllib", "urllib.response"),
MovedAttribute("addclosehook", "urllib", "urllib.response"),
MovedAttribute("addinfo", "urllib", "urllib.response"),
MovedAttribute("addinfourl", "urllib", "urllib.response"),
]
for attr in _urllib_response_moved_attributes:
setattr(Module_six_moves_urllib_response, attr.name, attr)
del attr
Module_six_moves_urllib_response._moved_attributes = _urllib_response_moved_attributes
_importer._add_module(Module_six_moves_urllib_response(__name__ + ".moves.urllib.response"),
"moves.urllib_response", "moves.urllib.response")
class Module_six_moves_urllib_robotparser(_LazyModule):
"""Lazy loading of moved objects in six.moves.urllib_robotparser"""
_urllib_robotparser_moved_attributes = [
MovedAttribute("RobotFileParser", "robotparser", "urllib.robotparser"),
]
for attr in _urllib_robotparser_moved_attributes:
setattr(Module_six_moves_urllib_robotparser, attr.name, attr)
del attr
Module_six_moves_urllib_robotparser._moved_attributes = _urllib_robotparser_moved_attributes
_importer._add_module(Module_six_moves_urllib_robotparser(__name__ + ".moves.urllib.robotparser"),
"moves.urllib_robotparser", "moves.urllib.robotparser")
class Module_six_moves_urllib(types.ModuleType):
"""Create a six.moves.urllib namespace that resembles the Python 3 namespace"""
__path__ = [] # mark as package
parse = _importer._get_module("moves.urllib_parse")
error = _importer._get_module("moves.urllib_error")
request = _importer._get_module("moves.urllib_request")
response = _importer._get_module("moves.urllib_response")
robotparser = _importer._get_module("moves.urllib_robotparser")
def __dir__(self):
return ['parse', 'error', 'request', 'response', 'robotparser']
_importer._add_module(Module_six_moves_urllib(__name__ + ".moves.urllib"),
"moves.urllib")
def add_move(move):
"""Add an item to six.moves."""
setattr(_MovedItems, move.name, move)
def remove_move(name):
"""Remove item from six.moves."""
try:
delattr(_MovedItems, name)
except AttributeError:
try:
del moves.__dict__[name]
except KeyError:
raise AttributeError("no such move, %r" % (name,))
if PY3:
_meth_func = "__func__"
_meth_self = "__self__"
_func_closure = "__closure__"
_func_code = "__code__"
_func_defaults = "__defaults__"
_func_globals = "__globals__"
else:
_meth_func = "im_func"
_meth_self = "im_self"
_func_closure = "func_closure"
_func_code = "func_code"
_func_defaults = "func_defaults"
_func_globals = "func_globals"
try:
advance_iterator = next
except NameError:
def advance_iterator(it):
return it.next()
next = advance_iterator
try:
callable = callable
except NameError:
def callable(obj):
return any("__call__" in klass.__dict__ for klass in type(obj).__mro__)
if PY3:
def get_unbound_function(unbound):
return unbound
create_bound_method = types.MethodType
def create_unbound_method(func, cls):
return func
Iterator = object
else:
def get_unbound_function(unbound):
return unbound.im_func
def create_bound_method(func, obj):
return types.MethodType(func, obj, obj.__class__)
def create_unbound_method(func, cls):
return types.MethodType(func, None, cls)
class Iterator(object):
def next(self):
return type(self).__next__(self)
callable = callable
_add_doc(get_unbound_function,
"""Get the function out of a possibly unbound function""")
get_method_function = operator.attrgetter(_meth_func)
get_method_self = operator.attrgetter(_meth_self)
get_function_closure = operator.attrgetter(_func_closure)
get_function_code = operator.attrgetter(_func_code)
get_function_defaults = operator.attrgetter(_func_defaults)
get_function_globals = operator.attrgetter(_func_globals)
if PY3:
def iterkeys(d, **kw):
return iter(d.keys(**kw))
def itervalues(d, **kw):
return iter(d.values(**kw))
def iteritems(d, **kw):
return iter(d.items(**kw))
def iterlists(d, **kw):
return iter(d.lists(**kw))
viewkeys = operator.methodcaller("keys")
viewvalues = operator.methodcaller("values")
viewitems = operator.methodcaller("items")
else:
def iterkeys(d, **kw):
return d.iterkeys(**kw)
def itervalues(d, **kw):
return d.itervalues(**kw)
def iteritems(d, **kw):
return d.iteritems(**kw)
def iterlists(d, **kw):
return d.iterlists(**kw)
viewkeys = operator.methodcaller("viewkeys")
viewvalues = operator.methodcaller("viewvalues")
viewitems = operator.methodcaller("viewitems")
_add_doc(iterkeys, "Return an iterator over the keys of a dictionary.")
_add_doc(itervalues, "Return an iterator over the values of a dictionary.")
_add_doc(iteritems,
"Return an iterator over the (key, value) pairs of a dictionary.")
_add_doc(iterlists,
"Return an iterator over the (key, [values]) pairs of a dictionary.")
if PY3:
def b(s):
return s.encode("latin-1")
def u(s):
return s
unichr = chr
import struct
int2byte = struct.Struct(">B").pack
del struct
byte2int = operator.itemgetter(0)
indexbytes = operator.getitem
iterbytes = iter
import io
StringIO = io.StringIO
BytesIO = io.BytesIO
_assertCountEqual = "assertCountEqual"
if sys.version_info[1] <= 1:
_assertRaisesRegex = "assertRaisesRegexp"
_assertRegex = "assertRegexpMatches"
else:
_assertRaisesRegex = "assertRaisesRegex"
_assertRegex = "assertRegex"
else:
def b(s):
return s
# Workaround for standalone backslash
def u(s):
return unicode(s.replace(r'\\', r'\\\\'), "unicode_escape")
unichr = unichr
int2byte = chr
def byte2int(bs):
return ord(bs[0])
def indexbytes(buf, i):
return ord(buf[i])
iterbytes = functools.partial(itertools.imap, ord)
import StringIO
StringIO = BytesIO = StringIO.StringIO
_assertCountEqual = "assertItemsEqual"
_assertRaisesRegex = "assertRaisesRegexp"
_assertRegex = "assertRegexpMatches"
_add_doc(b, """Byte literal""")
_add_doc(u, """Text literal""")
def assertCountEqual(self, *args, **kwargs):
return getattr(self, _assertCountEqual)(*args, **kwargs)
def assertRaisesRegex(self, *args, **kwargs):
return getattr(self, _assertRaisesRegex)(*args, **kwargs)
def assertRegex(self, *args, **kwargs):
return getattr(self, _assertRegex)(*args, **kwargs)
if PY3:
exec_ = getattr(moves.builtins, "exec")
def reraise(tp, value, tb=None):
if value is None:
value = tp()
if value.__traceback__ is not tb:
raise value.with_traceback(tb)
raise value
else:
def exec_(_code_, _globs_=None, _locs_=None):
"""Execute code in a namespace."""
if _globs_ is None:
frame = sys._getframe(1)
_globs_ = frame.f_globals
if _locs_ is None:
_locs_ = frame.f_locals
del frame
elif _locs_ is None:
_locs_ = _globs_
exec("""exec _code_ in _globs_, _locs_""")
exec_("""def reraise(tp, value, tb=None):
raise tp, value, tb
""")
if sys.version_info[:2] == (3, 2):
exec_("""def raise_from(value, from_value):
if from_value is None:
raise value
raise value from from_value
""")
elif sys.version_info[:2] > (3, 2):
exec_("""def raise_from(value, from_value):
raise value from from_value
""")
else:
def raise_from(value, from_value):
raise value
print_ = getattr(moves.builtins, "print", None)
if print_ is None:
def print_(*args, **kwargs):
"""The new-style print function for Python 2.4 and 2.5."""
fp = kwargs.pop("file", sys.stdout)
if fp is None:
return
def write(data):
if not isinstance(data, basestring):
data = str(data)
# If the file has an encoding, encode unicode with it.
if (isinstance(fp, file) and
isinstance(data, unicode) and
fp.encoding is not None):
errors = getattr(fp, "errors", None)
if errors is None:
errors = "strict"
data = data.encode(fp.encoding, errors)
fp.write(data)
want_unicode = False
sep = kwargs.pop("sep", None)
if sep is not None:
if isinstance(sep, unicode):
want_unicode = True
elif not isinstance(sep, str):
raise TypeError("sep must be None or a string")
end = kwargs.pop("end", None)
if end is not None:
if isinstance(end, unicode):
want_unicode = True
elif not isinstance(end, str):
raise TypeError("end must be None or a string")
if kwargs:
raise TypeError("invalid keyword arguments to print()")
if not want_unicode:
for arg in args:
if isinstance(arg, unicode):
want_unicode = True
break
if want_unicode:
newline = unicode("\n")
space = unicode(" ")
else:
newline = "\n"
space = " "
if sep is None:
sep = space
if end is None:
end = newline
for i, arg in enumerate(args):
if i:
write(sep)
write(arg)
write(end)
if sys.version_info[:2] < (3, 3):
_print = print_
def print_(*args, **kwargs):
fp = kwargs.get("file", sys.stdout)
flush = kwargs.pop("flush", False)
_print(*args, **kwargs)
if flush and fp is not None:
fp.flush()
_add_doc(reraise, """Reraise an exception.""")
if sys.version_info[0:2] < (3, 4):
def wraps(wrapped, assigned=functools.WRAPPER_ASSIGNMENTS,
updated=functools.WRAPPER_UPDATES):
def wrapper(f):
f = functools.wraps(wrapped, assigned, updated)(f)
f.__wrapped__ = wrapped
return f
return wrapper
else:
wraps = functools.wraps
def with_metaclass(meta, *bases):
"""Create a base class with a metaclass."""
# This requires a bit of explanation: the basic idea is to make a dummy
# metaclass for one level of class instantiation that replaces itself with
# the actual metaclass.
class metaclass(meta):
def __new__(cls, name, this_bases, d):
return meta(name, bases, d)
return type.__new__(metaclass, 'temporary_class', (), {})
def add_metaclass(metaclass):
"""Class decorator for creating a class with a metaclass."""
def wrapper(cls):
orig_vars = cls.__dict__.copy()
slots = orig_vars.get('__slots__')
if slots is not None:
if isinstance(slots, str):
slots = [slots]
for slots_var in slots:
orig_vars.pop(slots_var)
orig_vars.pop('__dict__', None)
orig_vars.pop('__weakref__', None)
return metaclass(cls.__name__, cls.__bases__, orig_vars)
return wrapper
def python_2_unicode_compatible(klass):
"""
A decorator that defines __unicode__ and __str__ methods under Python 2.
Under Python 3 it does nothing.
To support Python 2 and 3 with a single code base, define a __str__ method
returning text and apply this decorator to the class.
"""
if PY2:
if '__str__' not in klass.__dict__:
raise ValueError("@python_2_unicode_compatible cannot be applied "
"to %s because it doesn't define __str__()." %
klass.__name__)
klass.__unicode__ = klass.__str__
klass.__str__ = lambda self: self.__unicode__().encode('utf-8')
return klass
# Complete the moves implementation.
# This code is at the end of this module to speed up module loading.
# Turn this module into a package.
__path__ = [] # required for PEP 302 and PEP 451
__package__ = __name__ # see PEP 366 @ReservedAssignment
if globals().get("__spec__") is not None:
__spec__.submodule_search_locations = [] # PEP 451 @UndefinedVariable
# Remove other six meta path importers, since they cause problems. This can
# happen if six is removed from sys.modules and then reloaded. (Setuptools does
# this for some reason.)
if sys.meta_path:
for i, importer in enumerate(sys.meta_path):
# Here's some real nastiness: Another "instance" of the six module might
# be floating around. Therefore, we can't use isinstance() to check for
# the six meta path importer, since the other six instance will have
# inserted an importer with different class.
if (type(importer).__name__ == "_SixMetaPathImporter" and
importer.name == __name__):
del sys.meta_path[i]
break
del i, importer
# Finally, add the importer to the meta path import hook.
sys.meta_path.append(_importer)
setuptools-20.7.0/pkg_resources/_vendor/vendored.txt 0000664 0001750 0001750 00000000055 12702524020 023535 0 ustar travis travis 0000000 0000000 packaging==16.6
pyparsing==2.0.6
six==1.10.0
setuptools-20.7.0/pkg_resources/extern/ 0000775 0001750 0001750 00000000000 12702524134 021045 5 ustar travis travis 0000000 0000000 setuptools-20.7.0/pkg_resources/extern/__init__.py 0000664 0001750 0001750 00000004652 12702524020 023157 0 ustar travis travis 0000000 0000000 import sys
class VendorImporter:
"""
A PEP 302 meta path importer for finding optionally-vendored
or otherwise naturally-installed packages from root_name.
"""
def __init__(self, root_name, vendored_names=(), vendor_pkg=None):
self.root_name = root_name
self.vendored_names = set(vendored_names)
self.vendor_pkg = vendor_pkg or root_name.replace('extern', '_vendor')
@property
def search_path(self):
"""
Search first the vendor package then as a natural package.
"""
yield self.vendor_pkg + '.'
yield ''
def find_module(self, fullname, path=None):
"""
Return self when fullname starts with root_name and the
target module is one vendored through this importer.
"""
root, base, target = fullname.partition(self.root_name + '.')
if root:
return
if not any(map(target.startswith, self.vendored_names)):
return
return self
def load_module(self, fullname):
"""
Iterate over the search path to locate and load fullname.
"""
root, base, target = fullname.partition(self.root_name + '.')
for prefix in self.search_path:
try:
extant = prefix + target
__import__(extant)
mod = sys.modules[extant]
sys.modules[fullname] = mod
# mysterious hack:
# Remove the reference to the extant package/module
# on later Python versions to cause relative imports
# in the vendor package to resolve the same modules
# as those going through this importer.
if sys.version_info > (3, 3):
del sys.modules[extant]
return mod
except ImportError:
pass
else:
raise ImportError(
"The '{target}' package is required; "
"normally this is bundled with this package so if you get "
"this warning, consult the packager of your "
"distribution.".format(**locals())
)
def install(self):
"""
Install this importer into sys.meta_path if not already present.
"""
if self not in sys.meta_path:
sys.meta_path.append(self)
names = 'packaging', 'pyparsing', 'six'
VendorImporter(__name__, names).install()
setuptools-20.7.0/pkg_resources/tests/ 0000775 0001750 0001750 00000000000 12702524134 020702 5 ustar travis travis 0000000 0000000 setuptools-20.7.0/pkg_resources/tests/__init__.py 0000664 0001750 0001750 00000000000 12702524020 022773 0 ustar travis travis 0000000 0000000 setuptools-20.7.0/pkg_resources/tests/test_markers.py 0000664 0001750 0001750 00000000440 12702524020 023747 0 ustar travis travis 0000000 0000000 try:
import unittest.mock as mock
except ImportError:
import mock
from pkg_resources import evaluate_marker
@mock.patch('platform.python_version', return_value='2.7.10')
def test_ordering(python_version_mock):
assert evaluate_marker("python_full_version > '2.7.3'") is True
setuptools-20.7.0/pkg_resources/tests/test_pkg_resources.py 0000664 0001750 0001750 00000012153 12702524020 025162 0 ustar travis travis 0000000 0000000 # coding: utf-8
from __future__ import unicode_literals
import sys
import tempfile
import os
import zipfile
import datetime
import time
import subprocess
import stat
import distutils.dist
import distutils.command.install_egg_info
from pkg_resources.extern.six.moves import map
import pytest
import pkg_resources
try:
unicode
except NameError:
unicode = str
def timestamp(dt):
"""
Return a timestamp for a local, naive datetime instance.
"""
try:
return dt.timestamp()
except AttributeError:
# Python 3.2 and earlier
return time.mktime(dt.timetuple())
class EggRemover(unicode):
def __call__(self):
if self in sys.path:
sys.path.remove(self)
if os.path.exists(self):
os.remove(self)
class TestZipProvider(object):
finalizers = []
ref_time = datetime.datetime(2013, 5, 12, 13, 25, 0)
"A reference time for a file modification"
@classmethod
def setup_class(cls):
"create a zip egg and add it to sys.path"
egg = tempfile.NamedTemporaryFile(suffix='.egg', delete=False)
zip_egg = zipfile.ZipFile(egg, 'w')
zip_info = zipfile.ZipInfo()
zip_info.filename = 'mod.py'
zip_info.date_time = cls.ref_time.timetuple()
zip_egg.writestr(zip_info, 'x = 3\n')
zip_info = zipfile.ZipInfo()
zip_info.filename = 'data.dat'
zip_info.date_time = cls.ref_time.timetuple()
zip_egg.writestr(zip_info, 'hello, world!')
zip_egg.close()
egg.close()
sys.path.append(egg.name)
cls.finalizers.append(EggRemover(egg.name))
@classmethod
def teardown_class(cls):
for finalizer in cls.finalizers:
finalizer()
def test_resource_filename_rewrites_on_change(self):
"""
If a previous call to get_resource_filename has saved the file, but
the file has been subsequently mutated with different file of the
same size and modification time, it should not be overwritten on a
subsequent call to get_resource_filename.
"""
import mod
manager = pkg_resources.ResourceManager()
zp = pkg_resources.ZipProvider(mod)
filename = zp.get_resource_filename(manager, 'data.dat')
actual = datetime.datetime.fromtimestamp(os.stat(filename).st_mtime)
assert actual == self.ref_time
f = open(filename, 'w')
f.write('hello, world?')
f.close()
ts = timestamp(self.ref_time)
os.utime(filename, (ts, ts))
filename = zp.get_resource_filename(manager, 'data.dat')
f = open(filename)
assert f.read() == 'hello, world!'
manager.cleanup_resources()
class TestResourceManager(object):
def test_get_cache_path(self):
mgr = pkg_resources.ResourceManager()
path = mgr.get_cache_path('foo')
type_ = str(type(path))
message = "Unexpected type from get_cache_path: " + type_
assert isinstance(path, (unicode, str)), message
class TestIndependence:
"""
Tests to ensure that pkg_resources runs independently from setuptools.
"""
def test_setuptools_not_imported(self):
"""
In a separate Python environment, import pkg_resources and assert
that action doesn't cause setuptools to be imported.
"""
lines = (
'import pkg_resources',
'import sys',
'assert "setuptools" not in sys.modules, '
'"setuptools was imported"',
)
cmd = [sys.executable, '-c', '; '.join(lines)]
subprocess.check_call(cmd)
class TestDeepVersionLookupDistutils(object):
@pytest.fixture
def env(self, tmpdir):
"""
Create a package environment, similar to a virtualenv,
in which packages are installed.
"""
class Environment(str):
pass
env = Environment(tmpdir)
tmpdir.chmod(stat.S_IRWXU)
subs = 'home', 'lib', 'scripts', 'data', 'egg-base'
env.paths = dict(
(dirname, str(tmpdir / dirname))
for dirname in subs
)
list(map(os.mkdir, env.paths.values()))
return env
def create_foo_pkg(self, env, version):
"""
Create a foo package installed (distutils-style) to env.paths['lib']
as version.
"""
ld = "This package has unicode metadata! â„"
attrs = dict(name='foo', version=version, long_description=ld)
dist = distutils.dist.Distribution(attrs)
iei_cmd = distutils.command.install_egg_info.install_egg_info(dist)
iei_cmd.initialize_options()
iei_cmd.install_dir = env.paths['lib']
iei_cmd.finalize_options()
iei_cmd.run()
def test_version_resolved_from_egg_info(self, env):
version = '1.11.0.dev0+2329eae'
self.create_foo_pkg(env, version)
# this requirement parsing will raise a VersionConflict unless the
# .egg-info file is parsed (see #419 on BitBucket)
req = pkg_resources.Requirement.parse('foo>=1.9')
dist = pkg_resources.WorkingSet([env.paths['lib']]).find(req)
assert dist.version == version
setuptools-20.7.0/pkg_resources/tests/test_resources.py 0000664 0001750 0001750 00000073173 12702524020 024332 0 ustar travis travis 0000000 0000000 from __future__ import unicode_literals
import os
import sys
import string
from pkg_resources.extern.six.moves import map
import pytest
from pkg_resources.extern import packaging
import pkg_resources
from pkg_resources import (parse_requirements, VersionConflict, parse_version,
Distribution, EntryPoint, Requirement, safe_version, safe_name,
WorkingSet)
class Metadata(pkg_resources.EmptyProvider):
"""Mock object to return metadata as if from an on-disk distribution"""
def __init__(self, *pairs):
self.metadata = dict(pairs)
def has_metadata(self, name):
return name in self.metadata
def get_metadata(self, name):
return self.metadata[name]
def get_metadata_lines(self, name):
return pkg_resources.yield_lines(self.get_metadata(name))
dist_from_fn = pkg_resources.Distribution.from_filename
class TestDistro:
def testCollection(self):
# empty path should produce no distributions
ad = pkg_resources.Environment([], platform=None, python=None)
assert list(ad) == []
assert ad['FooPkg'] == []
ad.add(dist_from_fn("FooPkg-1.3_1.egg"))
ad.add(dist_from_fn("FooPkg-1.4-py2.4-win32.egg"))
ad.add(dist_from_fn("FooPkg-1.2-py2.4.egg"))
# Name is in there now
assert ad['FooPkg']
# But only 1 package
assert list(ad) == ['foopkg']
# Distributions sort by version
assert [dist.version for dist in ad['FooPkg']] == ['1.4','1.3-1','1.2']
# Removing a distribution leaves sequence alone
ad.remove(ad['FooPkg'][1])
assert [dist.version for dist in ad['FooPkg']] == ['1.4','1.2']
# And inserting adds them in order
ad.add(dist_from_fn("FooPkg-1.9.egg"))
assert [dist.version for dist in ad['FooPkg']] == ['1.9','1.4','1.2']
ws = WorkingSet([])
foo12 = dist_from_fn("FooPkg-1.2-py2.4.egg")
foo14 = dist_from_fn("FooPkg-1.4-py2.4-win32.egg")
req, = parse_requirements("FooPkg>=1.3")
# Nominal case: no distros on path, should yield all applicable
assert ad.best_match(req, ws).version == '1.9'
# If a matching distro is already installed, should return only that
ws.add(foo14)
assert ad.best_match(req, ws).version == '1.4'
# If the first matching distro is unsuitable, it's a version conflict
ws = WorkingSet([])
ws.add(foo12)
ws.add(foo14)
with pytest.raises(VersionConflict):
ad.best_match(req, ws)
# If more than one match on the path, the first one takes precedence
ws = WorkingSet([])
ws.add(foo14)
ws.add(foo12)
ws.add(foo14)
assert ad.best_match(req, ws).version == '1.4'
def checkFooPkg(self,d):
assert d.project_name == "FooPkg"
assert d.key == "foopkg"
assert d.version == "1.3.post1"
assert d.py_version == "2.4"
assert d.platform == "win32"
assert d.parsed_version == parse_version("1.3-1")
def testDistroBasics(self):
d = Distribution(
"/some/path",
project_name="FooPkg",version="1.3-1",py_version="2.4",platform="win32"
)
self.checkFooPkg(d)
d = Distribution("/some/path")
assert d.py_version == sys.version[:3]
assert d.platform == None
def testDistroParse(self):
d = dist_from_fn("FooPkg-1.3.post1-py2.4-win32.egg")
self.checkFooPkg(d)
d = dist_from_fn("FooPkg-1.3.post1-py2.4-win32.egg-info")
self.checkFooPkg(d)
def testDistroMetadata(self):
d = Distribution(
"/some/path", project_name="FooPkg", py_version="2.4", platform="win32",
metadata = Metadata(
('PKG-INFO',"Metadata-Version: 1.0\nVersion: 1.3-1\n")
)
)
self.checkFooPkg(d)
def distRequires(self, txt):
return Distribution("/foo", metadata=Metadata(('depends.txt', txt)))
def checkRequires(self, dist, txt, extras=()):
assert list(dist.requires(extras)) == list(parse_requirements(txt))
def testDistroDependsSimple(self):
for v in "Twisted>=1.5", "Twisted>=1.5\nZConfig>=2.0":
self.checkRequires(self.distRequires(v), v)
def testResolve(self):
ad = pkg_resources.Environment([])
ws = WorkingSet([])
# Resolving no requirements -> nothing to install
assert list(ws.resolve([], ad)) == []
# Request something not in the collection -> DistributionNotFound
with pytest.raises(pkg_resources.DistributionNotFound):
ws.resolve(parse_requirements("Foo"), ad)
Foo = Distribution.from_filename(
"/foo_dir/Foo-1.2.egg",
metadata=Metadata(('depends.txt', "[bar]\nBaz>=2.0"))
)
ad.add(Foo)
ad.add(Distribution.from_filename("Foo-0.9.egg"))
# Request thing(s) that are available -> list to activate
for i in range(3):
targets = list(ws.resolve(parse_requirements("Foo"), ad))
assert targets == [Foo]
list(map(ws.add, targets))
with pytest.raises(VersionConflict):
ws.resolve(parse_requirements("Foo==0.9"), ad)
ws = WorkingSet([]) # reset
# Request an extra that causes an unresolved dependency for "Baz"
with pytest.raises(pkg_resources.DistributionNotFound):
ws.resolve(parse_requirements("Foo[bar]"), ad)
Baz = Distribution.from_filename(
"/foo_dir/Baz-2.1.egg", metadata=Metadata(('depends.txt', "Foo"))
)
ad.add(Baz)
# Activation list now includes resolved dependency
assert list(ws.resolve(parse_requirements("Foo[bar]"), ad)) ==[Foo,Baz]
# Requests for conflicting versions produce VersionConflict
with pytest.raises(VersionConflict) as vc:
ws.resolve(parse_requirements("Foo==1.2\nFoo!=1.2"), ad)
msg = 'Foo 0.9 is installed but Foo==1.2 is required'
assert vc.value.report() == msg
def test_environment_marker_evaluation_negative(self):
"""Environment markers are evaluated at resolution time."""
ad = pkg_resources.Environment([])
ws = WorkingSet([])
res = ws.resolve(parse_requirements("Foo;python_version<'2'"), ad)
assert list(res) == []
def test_environment_marker_evaluation_positive(self):
ad = pkg_resources.Environment([])
ws = WorkingSet([])
Foo = Distribution.from_filename("/foo_dir/Foo-1.2.dist-info")
ad.add(Foo)
res = ws.resolve(parse_requirements("Foo;python_version>='2'"), ad)
assert list(res) == [Foo]
def test_environment_marker_evaluation_called(self):
"""
If one package foo requires bar without any extras,
markers should pass for bar.
"""
parent_req, = parse_requirements("foo")
req, = parse_requirements("bar;python_version>='2'")
req_extras = pkg_resources._ReqExtras({req: parent_req.extras})
assert req_extras.markers_pass(req)
parent_req, = parse_requirements("foo[]")
req, = parse_requirements("bar;python_version>='2'")
req_extras = pkg_resources._ReqExtras({req: parent_req.extras})
assert req_extras.markers_pass(req)
# extra should not be present in the marker namespace if
# no markers were supplied
parent_req, = parse_requirements("foo")
req, = parse_requirements("bar;extra==''")
req_extras = pkg_resources._ReqExtras({req: parent_req.extras})
with pytest.raises(packaging.markers.UndefinedEnvironmentName):
req_extras.markers_pass(req)
def test_marker_evaluation_with_extras(self):
"""Extras are also evaluated as markers at resolution time."""
ad = pkg_resources.Environment([])
ws = WorkingSet([])
# Metadata needs to be native strings due to cStringIO behaviour in
# 2.6, so use str().
Foo = Distribution.from_filename(
"/foo_dir/Foo-1.2.dist-info",
metadata=Metadata(("METADATA", str("Provides-Extra: baz\n"
"Requires-Dist: quux; extra=='baz'")))
)
ad.add(Foo)
assert list(ws.resolve(parse_requirements("Foo"), ad)) == [Foo]
quux = Distribution.from_filename("/foo_dir/quux-1.0.dist-info")
ad.add(quux)
res = list(ws.resolve(parse_requirements("Foo[baz]"), ad))
assert res == [Foo,quux]
def test_marker_evaluation_with_multiple_extras(self):
ad = pkg_resources.Environment([])
ws = WorkingSet([])
# Metadata needs to be native strings due to cStringIO behaviour in
# 2.6, so use str().
Foo = Distribution.from_filename(
"/foo_dir/Foo-1.2.dist-info",
metadata=Metadata(("METADATA", str("Provides-Extra: baz\n"
"Requires-Dist: quux; extra=='baz'\n"
"Provides-Extra: bar\n"
"Requires-Dist: fred; extra=='bar'\n")))
)
ad.add(Foo)
quux = Distribution.from_filename("/foo_dir/quux-1.0.dist-info")
ad.add(quux)
fred = Distribution.from_filename("/foo_dir/fred-0.1.dist-info")
ad.add(fred)
res = list(ws.resolve(parse_requirements("Foo[baz,bar]"), ad))
assert sorted(res) == [fred,quux,Foo]
def test_marker_evaluation_with_extras_loop(self):
ad = pkg_resources.Environment([])
ws = WorkingSet([])
# Metadata needs to be native strings due to cStringIO behaviour in
# 2.6, so use str().
a = Distribution.from_filename(
"/foo_dir/a-0.2.dist-info",
metadata=Metadata(("METADATA", str("Requires-Dist: c[a]")))
)
b = Distribution.from_filename(
"/foo_dir/b-0.3.dist-info",
metadata=Metadata(("METADATA", str("Requires-Dist: c[b]")))
)
c = Distribution.from_filename(
"/foo_dir/c-1.0.dist-info",
metadata=Metadata(("METADATA", str("Provides-Extra: a\n"
"Requires-Dist: b;extra=='a'\n"
"Provides-Extra: b\n"
"Requires-Dist: foo;extra=='b'")))
)
foo = Distribution.from_filename("/foo_dir/foo-0.1.dist-info")
for dist in (a, b, c, foo):
ad.add(dist)
res = list(ws.resolve(parse_requirements("a"), ad))
assert res == [a, c, b, foo]
def testDistroDependsOptions(self):
d = self.distRequires("""
Twisted>=1.5
[docgen]
ZConfig>=2.0
docutils>=0.3
[fastcgi]
fcgiapp>=0.1""")
self.checkRequires(d,"Twisted>=1.5")
self.checkRequires(
d,"Twisted>=1.5 ZConfig>=2.0 docutils>=0.3".split(), ["docgen"]
)
self.checkRequires(
d,"Twisted>=1.5 fcgiapp>=0.1".split(), ["fastcgi"]
)
self.checkRequires(
d,"Twisted>=1.5 ZConfig>=2.0 docutils>=0.3 fcgiapp>=0.1".split(),
["docgen","fastcgi"]
)
self.checkRequires(
d,"Twisted>=1.5 fcgiapp>=0.1 ZConfig>=2.0 docutils>=0.3".split(),
["fastcgi", "docgen"]
)
with pytest.raises(pkg_resources.UnknownExtra):
d.requires(["foo"])
class TestWorkingSet:
def test_find_conflicting(self):
ws = WorkingSet([])
Foo = Distribution.from_filename("/foo_dir/Foo-1.2.egg")
ws.add(Foo)
# create a requirement that conflicts with Foo 1.2
req = next(parse_requirements("Foo<1.2"))
with pytest.raises(VersionConflict) as vc:
ws.find(req)
msg = 'Foo 1.2 is installed but Foo<1.2 is required'
assert vc.value.report() == msg
def test_resolve_conflicts_with_prior(self):
"""
A ContextualVersionConflict should be raised when a requirement
conflicts with a prior requirement for a different package.
"""
# Create installation where Foo depends on Baz 1.0 and Bar depends on
# Baz 2.0.
ws = WorkingSet([])
md = Metadata(('depends.txt', "Baz==1.0"))
Foo = Distribution.from_filename("/foo_dir/Foo-1.0.egg", metadata=md)
ws.add(Foo)
md = Metadata(('depends.txt', "Baz==2.0"))
Bar = Distribution.from_filename("/foo_dir/Bar-1.0.egg", metadata=md)
ws.add(Bar)
Baz = Distribution.from_filename("/foo_dir/Baz-1.0.egg")
ws.add(Baz)
Baz = Distribution.from_filename("/foo_dir/Baz-2.0.egg")
ws.add(Baz)
with pytest.raises(VersionConflict) as vc:
ws.resolve(parse_requirements("Foo\nBar\n"))
msg = "Baz 1.0 is installed but Baz==2.0 is required by "
msg += repr(set(['Bar']))
assert vc.value.report() == msg
class TestEntryPoints:
def assertfields(self, ep):
assert ep.name == "foo"
assert ep.module_name == "pkg_resources.tests.test_resources"
assert ep.attrs == ("TestEntryPoints",)
assert ep.extras == ("x",)
assert ep.load() is TestEntryPoints
expect = "foo = pkg_resources.tests.test_resources:TestEntryPoints [x]"
assert str(ep) == expect
def setup_method(self, method):
self.dist = Distribution.from_filename(
"FooPkg-1.2-py2.4.egg", metadata=Metadata(('requires.txt','[x]')))
def testBasics(self):
ep = EntryPoint(
"foo", "pkg_resources.tests.test_resources", ["TestEntryPoints"],
["x"], self.dist
)
self.assertfields(ep)
def testParse(self):
s = "foo = pkg_resources.tests.test_resources:TestEntryPoints [x]"
ep = EntryPoint.parse(s, self.dist)
self.assertfields(ep)
ep = EntryPoint.parse("bar baz= spammity[PING]")
assert ep.name == "bar baz"
assert ep.module_name == "spammity"
assert ep.attrs == ()
assert ep.extras == ("ping",)
ep = EntryPoint.parse(" fizzly = wocka:foo")
assert ep.name == "fizzly"
assert ep.module_name == "wocka"
assert ep.attrs == ("foo",)
assert ep.extras == ()
# plus in the name
spec = "html+mako = mako.ext.pygmentplugin:MakoHtmlLexer"
ep = EntryPoint.parse(spec)
assert ep.name == 'html+mako'
reject_specs = "foo", "x=a:b:c", "q=x/na", "fez=pish:tush-z", "x=f[a]>2"
@pytest.mark.parametrize("reject_spec", reject_specs)
def test_reject_spec(self, reject_spec):
with pytest.raises(ValueError):
EntryPoint.parse(reject_spec)
def test_printable_name(self):
"""
Allow any printable character in the name.
"""
# Create a name with all printable characters; strip the whitespace.
name = string.printable.strip()
spec = "{name} = module:attr".format(**locals())
ep = EntryPoint.parse(spec)
assert ep.name == name
def checkSubMap(self, m):
assert len(m) == len(self.submap_expect)
for key, ep in self.submap_expect.items():
assert m.get(key).name == ep.name
assert m.get(key).module_name == ep.module_name
assert sorted(m.get(key).attrs) == sorted(ep.attrs)
assert sorted(m.get(key).extras) == sorted(ep.extras)
submap_expect = dict(
feature1=EntryPoint('feature1', 'somemodule', ['somefunction']),
feature2=EntryPoint('feature2', 'another.module', ['SomeClass'], ['extra1','extra2']),
feature3=EntryPoint('feature3', 'this.module', extras=['something'])
)
submap_str = """
# define features for blah blah
feature1 = somemodule:somefunction
feature2 = another.module:SomeClass [extra1,extra2]
feature3 = this.module [something]
"""
def testParseList(self):
self.checkSubMap(EntryPoint.parse_group("xyz", self.submap_str))
with pytest.raises(ValueError):
EntryPoint.parse_group("x a", "foo=bar")
with pytest.raises(ValueError):
EntryPoint.parse_group("x", ["foo=baz", "foo=bar"])
def testParseMap(self):
m = EntryPoint.parse_map({'xyz':self.submap_str})
self.checkSubMap(m['xyz'])
assert list(m.keys()) == ['xyz']
m = EntryPoint.parse_map("[xyz]\n"+self.submap_str)
self.checkSubMap(m['xyz'])
assert list(m.keys()) == ['xyz']
with pytest.raises(ValueError):
EntryPoint.parse_map(["[xyz]", "[xyz]"])
with pytest.raises(ValueError):
EntryPoint.parse_map(self.submap_str)
class TestRequirements:
def testBasics(self):
r = Requirement.parse("Twisted>=1.2")
assert str(r) == "Twisted>=1.2"
assert repr(r) == "Requirement.parse('Twisted>=1.2')"
assert r == Requirement("Twisted>=1.2")
assert r == Requirement("twisTed>=1.2")
assert r != Requirement("Twisted>=2.0")
assert r != Requirement("Zope>=1.2")
assert r != Requirement("Zope>=3.0")
assert r != Requirement("Twisted[extras]>=1.2")
def testOrdering(self):
r1 = Requirement("Twisted==1.2c1,>=1.2")
r2 = Requirement("Twisted>=1.2,==1.2c1")
assert r1 == r2
assert str(r1) == str(r2)
assert str(r2) == "Twisted==1.2c1,>=1.2"
def testBasicContains(self):
r = Requirement("Twisted>=1.2")
foo_dist = Distribution.from_filename("FooPkg-1.3_1.egg")
twist11 = Distribution.from_filename("Twisted-1.1.egg")
twist12 = Distribution.from_filename("Twisted-1.2.egg")
assert parse_version('1.2') in r
assert parse_version('1.1') not in r
assert '1.2' in r
assert '1.1' not in r
assert foo_dist not in r
assert twist11 not in r
assert twist12 in r
def testOptionsAndHashing(self):
r1 = Requirement.parse("Twisted[foo,bar]>=1.2")
r2 = Requirement.parse("Twisted[bar,FOO]>=1.2")
assert r1 == r2
assert set(r1.extras) == set(("foo", "bar"))
assert set(r2.extras) == set(("foo", "bar"))
assert hash(r1) == hash(r2)
assert (
hash(r1)
==
hash((
"twisted",
packaging.specifiers.SpecifierSet(">=1.2"),
frozenset(["foo","bar"]),
None
))
)
def testVersionEquality(self):
r1 = Requirement.parse("foo==0.3a2")
r2 = Requirement.parse("foo!=0.3a4")
d = Distribution.from_filename
assert d("foo-0.3a4.egg") not in r1
assert d("foo-0.3a1.egg") not in r1
assert d("foo-0.3a4.egg") not in r2
assert d("foo-0.3a2.egg") in r1
assert d("foo-0.3a2.egg") in r2
assert d("foo-0.3a3.egg") in r2
assert d("foo-0.3a5.egg") in r2
def testSetuptoolsProjectName(self):
"""
The setuptools project should implement the setuptools package.
"""
assert (
Requirement.parse('setuptools').project_name == 'setuptools')
# setuptools 0.7 and higher means setuptools.
assert (
Requirement.parse('setuptools == 0.7').project_name == 'setuptools')
assert (
Requirement.parse('setuptools == 0.7a1').project_name == 'setuptools')
assert (
Requirement.parse('setuptools >= 0.7').project_name == 'setuptools')
class TestParsing:
def testEmptyParse(self):
assert list(parse_requirements('')) == []
def testYielding(self):
for inp,out in [
([], []), ('x',['x']), ([[]],[]), (' x\n y', ['x','y']),
(['x\n\n','y'], ['x','y']),
]:
assert list(pkg_resources.yield_lines(inp)) == out
def testSplitting(self):
sample = """
x
[Y]
z
a
[b ]
# foo
c
[ d]
[q]
v
"""
assert (
list(pkg_resources.split_sections(sample))
==
[
(None, ["x"]),
("Y", ["z", "a"]),
("b", ["c"]),
("d", []),
("q", ["v"]),
]
)
with pytest.raises(ValueError):
list(pkg_resources.split_sections("[foo"))
def testSafeName(self):
assert safe_name("adns-python") == "adns-python"
assert safe_name("WSGI Utils") == "WSGI-Utils"
assert safe_name("WSGI Utils") == "WSGI-Utils"
assert safe_name("Money$$$Maker") == "Money-Maker"
assert safe_name("peak.web") != "peak-web"
def testSafeVersion(self):
assert safe_version("1.2-1") == "1.2.post1"
assert safe_version("1.2 alpha") == "1.2.alpha"
assert safe_version("2.3.4 20050521") == "2.3.4.20050521"
assert safe_version("Money$$$Maker") == "Money-Maker"
assert safe_version("peak.web") == "peak.web"
def testSimpleRequirements(self):
assert (
list(parse_requirements('Twis-Ted>=1.2-1'))
==
[Requirement('Twis-Ted>=1.2-1')]
)
assert (
list(parse_requirements('Twisted >=1.2, \ # more\n<2.0'))
==
[Requirement('Twisted>=1.2,<2.0')]
)
assert (
Requirement.parse("FooBar==1.99a3")
==
Requirement("FooBar==1.99a3")
)
with pytest.raises(ValueError):
Requirement.parse(">=2.3")
with pytest.raises(ValueError):
Requirement.parse("x\\")
with pytest.raises(ValueError):
Requirement.parse("x==2 q")
with pytest.raises(ValueError):
Requirement.parse("X==1\nY==2")
with pytest.raises(ValueError):
Requirement.parse("#")
def test_requirements_with_markers(self):
assert (
Requirement.parse("foobar;os_name=='a'")
==
Requirement.parse("foobar;os_name=='a'")
)
assert (
Requirement.parse("name==1.1;python_version=='2.7'")
!=
Requirement.parse("name==1.1;python_version=='3.3'")
)
assert (
Requirement.parse("name==1.0;python_version=='2.7'")
!=
Requirement.parse("name==1.2;python_version=='2.7'")
)
assert (
Requirement.parse("name[foo]==1.0;python_version=='3.3'")
!=
Requirement.parse("name[foo,bar]==1.0;python_version=='3.3'")
)
def test_local_version(self):
req, = parse_requirements('foo==1.0.org1')
def test_spaces_between_multiple_versions(self):
req, = parse_requirements('foo>=1.0, <3')
req, = parse_requirements('foo >= 1.0, < 3')
def testVersionEquality(self):
def c(s1,s2):
p1, p2 = parse_version(s1),parse_version(s2)
assert p1 == p2, (s1,s2,p1,p2)
c('1.2-rc1', '1.2rc1')
c('0.4', '0.4.0')
c('0.4.0.0', '0.4.0')
c('0.4.0-0', '0.4-0')
c('0post1', '0.0post1')
c('0pre1', '0.0c1')
c('0.0.0preview1', '0c1')
c('0.0c1', '0-rc1')
c('1.2a1', '1.2.a.1')
c('1.2.a', '1.2a')
def testVersionOrdering(self):
def c(s1,s2):
p1, p2 = parse_version(s1),parse_version(s2)
assert p1 tuple(parse_version("2.0"))
assert parse_version("3.0") >= tuple(parse_version("2.0"))
assert parse_version("3.0") != tuple(parse_version("2.0"))
assert not (parse_version("3.0") != tuple(parse_version("3.0")))
def testVersionHashable(self):
"""
Ensure that our versions stay hashable even though we've subclassed
them and added some shim code to them.
"""
assert (
hash(parse_version("1.0"))
==
hash(parse_version("1.0"))
)
class TestNamespaces:
ns_str = "__import__('pkg_resources').declare_namespace(__name__)\n"
@pytest.yield_fixture
def symlinked_tmpdir(self, tmpdir):
"""
Where available, return the tempdir as a symlink,
which as revealed in #231 is more fragile than
a natural tempdir.
"""
if not hasattr(os, 'symlink'):
yield str(tmpdir)
return
link_name = str(tmpdir) + '-linked'
os.symlink(str(tmpdir), link_name)
try:
yield type(tmpdir)(link_name)
finally:
os.unlink(link_name)
@pytest.yield_fixture(autouse=True)
def patched_path(self, tmpdir):
"""
Patch sys.path to include the 'site-pkgs' dir. Also
restore pkg_resources._namespace_packages to its
former state.
"""
saved_ns_pkgs = pkg_resources._namespace_packages.copy()
saved_sys_path = sys.path[:]
site_pkgs = tmpdir.mkdir('site-pkgs')
sys.path.append(str(site_pkgs))
try:
yield
finally:
pkg_resources._namespace_packages = saved_ns_pkgs
sys.path = saved_sys_path
def test_two_levels_deep(self, symlinked_tmpdir):
"""
Test nested namespace packages
Create namespace packages in the following tree :
site-packages-1/pkg1/pkg2
site-packages-2/pkg1/pkg2
Check both are in the _namespace_packages dict and that their __path__
is correct
"""
real_tmpdir = symlinked_tmpdir.realpath()
tmpdir = symlinked_tmpdir
sys.path.append(str(tmpdir / 'site-pkgs2'))
site_dirs = tmpdir / 'site-pkgs', tmpdir / 'site-pkgs2'
for site in site_dirs:
pkg1 = site / 'pkg1'
pkg2 = pkg1 / 'pkg2'
pkg2.ensure_dir()
(pkg1 / '__init__.py').write_text(self.ns_str, encoding='utf-8')
(pkg2 / '__init__.py').write_text(self.ns_str, encoding='utf-8')
import pkg1
assert "pkg1" in pkg_resources._namespace_packages
# attempt to import pkg2 from site-pkgs2
import pkg1.pkg2
# check the _namespace_packages dict
assert "pkg1.pkg2" in pkg_resources._namespace_packages
assert pkg_resources._namespace_packages["pkg1"] == ["pkg1.pkg2"]
# check the __path__ attribute contains both paths
expected = [
str(real_tmpdir / "site-pkgs" / "pkg1" / "pkg2"),
str(real_tmpdir / "site-pkgs2" / "pkg1" / "pkg2"),
]
assert pkg1.pkg2.__path__ == expected
def test_path_order(self, symlinked_tmpdir):
"""
Test that if multiple versions of the same namespace package subpackage
are on different sys.path entries, that only the one earliest on
sys.path is imported, and that the namespace package's __path__ is in
the correct order.
Regression test for https://github.com/pypa/setuptools/issues/207
"""
tmpdir = symlinked_tmpdir
site_dirs = (
tmpdir / "site-pkgs",
tmpdir / "site-pkgs2",
tmpdir / "site-pkgs3",
)
vers_str = "__version__ = %r"
for number, site in enumerate(site_dirs, 1):
if number > 1:
sys.path.append(str(site))
nspkg = site / 'nspkg'
subpkg = nspkg / 'subpkg'
subpkg.ensure_dir()
(nspkg / '__init__.py').write_text(self.ns_str, encoding='utf-8')
(subpkg / '__init__.py').write_text(vers_str % number, encoding='utf-8')
import nspkg.subpkg
import nspkg
expected = [
str(site.realpath() / 'nspkg')
for site in site_dirs
]
assert nspkg.__path__ == expected
assert nspkg.subpkg.__version__ == 1
setuptools-20.7.0/pkg_resources/__init__.py 0000664 0001750 0001750 00000305775 12702524020 021664 0 ustar travis travis 0000000 0000000 """
Package resource API
--------------------
A resource is a logical file contained within a package, or a logical
subdirectory thereof. The package resource API expects resource names
to have their path parts separated with ``/``, *not* whatever the local
path separator is. Do not use os.path operations to manipulate resource
names being passed into the API.
The package resource API is designed to work with normal filesystem packages,
.egg files, and unpacked .egg files. It can also work in a limited way with
.zip files and with custom PEP 302 loaders that support the ``get_data()``
method.
"""
from __future__ import absolute_import
import sys
import os
import io
import time
import re
import types
import zipfile
import zipimport
import warnings
import stat
import functools
import pkgutil
import operator
import platform
import collections
import plistlib
import email.parser
import tempfile
import textwrap
from pkgutil import get_importer
try:
import _imp
except ImportError:
# Python 3.2 compatibility
import imp as _imp
from pkg_resources.extern import six
from pkg_resources.extern.six.moves import urllib, map, filter
# capture these to bypass sandboxing
from os import utime
try:
from os import mkdir, rename, unlink
WRITE_SUPPORT = True
except ImportError:
# no write support, probably under GAE
WRITE_SUPPORT = False
from os import open as os_open
from os.path import isdir, split
try:
import importlib.machinery as importlib_machinery
# access attribute to force import under delayed import mechanisms.
importlib_machinery.__name__
except ImportError:
importlib_machinery = None
from pkg_resources.extern import packaging
__import__('pkg_resources.extern.packaging.version')
__import__('pkg_resources.extern.packaging.specifiers')
__import__('pkg_resources.extern.packaging.requirements')
__import__('pkg_resources.extern.packaging.markers')
if (3, 0) < sys.version_info < (3, 3):
msg = (
"Support for Python 3.0-3.2 has been dropped. Future versions "
"will fail here."
)
warnings.warn(msg)
# declare some globals that will be defined later to
# satisfy the linters.
require = None
working_set = None
class PEP440Warning(RuntimeWarning):
"""
Used when there is an issue with a version or specifier not complying with
PEP 440.
"""
class _SetuptoolsVersionMixin(object):
def __hash__(self):
return super(_SetuptoolsVersionMixin, self).__hash__()
def __lt__(self, other):
if isinstance(other, tuple):
return tuple(self) < other
else:
return super(_SetuptoolsVersionMixin, self).__lt__(other)
def __le__(self, other):
if isinstance(other, tuple):
return tuple(self) <= other
else:
return super(_SetuptoolsVersionMixin, self).__le__(other)
def __eq__(self, other):
if isinstance(other, tuple):
return tuple(self) == other
else:
return super(_SetuptoolsVersionMixin, self).__eq__(other)
def __ge__(self, other):
if isinstance(other, tuple):
return tuple(self) >= other
else:
return super(_SetuptoolsVersionMixin, self).__ge__(other)
def __gt__(self, other):
if isinstance(other, tuple):
return tuple(self) > other
else:
return super(_SetuptoolsVersionMixin, self).__gt__(other)
def __ne__(self, other):
if isinstance(other, tuple):
return tuple(self) != other
else:
return super(_SetuptoolsVersionMixin, self).__ne__(other)
def __getitem__(self, key):
return tuple(self)[key]
def __iter__(self):
component_re = re.compile(r'(\d+ | [a-z]+ | \.| -)', re.VERBOSE)
replace = {
'pre': 'c',
'preview': 'c',
'-': 'final-',
'rc': 'c',
'dev': '@',
}.get
def _parse_version_parts(s):
for part in component_re.split(s):
part = replace(part, part)
if not part or part == '.':
continue
if part[:1] in '0123456789':
# pad for numeric comparison
yield part.zfill(8)
else:
yield '*'+part
# ensure that alpha/beta/candidate are before final
yield '*final'
def old_parse_version(s):
parts = []
for part in _parse_version_parts(s.lower()):
if part.startswith('*'):
# remove '-' before a prerelease tag
if part < '*final':
while parts and parts[-1] == '*final-':
parts.pop()
# remove trailing zeros from each series of numeric parts
while parts and parts[-1] == '00000000':
parts.pop()
parts.append(part)
return tuple(parts)
# Warn for use of this function
warnings.warn(
"You have iterated over the result of "
"pkg_resources.parse_version. This is a legacy behavior which is "
"inconsistent with the new version class introduced in setuptools "
"8.0. In most cases, conversion to a tuple is unnecessary. For "
"comparison of versions, sort the Version instances directly. If "
"you have another use case requiring the tuple, please file a "
"bug with the setuptools project describing that need.",
RuntimeWarning,
stacklevel=1,
)
for part in old_parse_version(str(self)):
yield part
class SetuptoolsVersion(_SetuptoolsVersionMixin, packaging.version.Version):
pass
class SetuptoolsLegacyVersion(_SetuptoolsVersionMixin,
packaging.version.LegacyVersion):
pass
def parse_version(v):
try:
return SetuptoolsVersion(v)
except packaging.version.InvalidVersion:
return SetuptoolsLegacyVersion(v)
_state_vars = {}
def _declare_state(vartype, **kw):
globals().update(kw)
_state_vars.update(dict.fromkeys(kw, vartype))
def __getstate__():
state = {}
g = globals()
for k, v in _state_vars.items():
state[k] = g['_sget_'+v](g[k])
return state
def __setstate__(state):
g = globals()
for k, v in state.items():
g['_sset_'+_state_vars[k]](k, g[k], v)
return state
def _sget_dict(val):
return val.copy()
def _sset_dict(key, ob, state):
ob.clear()
ob.update(state)
def _sget_object(val):
return val.__getstate__()
def _sset_object(key, ob, state):
ob.__setstate__(state)
_sget_none = _sset_none = lambda *args: None
def get_supported_platform():
"""Return this platform's maximum compatible version.
distutils.util.get_platform() normally reports the minimum version
of Mac OS X that would be required to *use* extensions produced by
distutils. But what we want when checking compatibility is to know the
version of Mac OS X that we are *running*. To allow usage of packages that
explicitly require a newer version of Mac OS X, we must also know the
current version of the OS.
If this condition occurs for any other platform with a version in its
platform strings, this function should be extended accordingly.
"""
plat = get_build_platform()
m = macosVersionString.match(plat)
if m is not None and sys.platform == "darwin":
try:
plat = 'macosx-%s-%s' % ('.'.join(_macosx_vers()[:2]), m.group(3))
except ValueError:
# not Mac OS X
pass
return plat
__all__ = [
# Basic resource access and distribution/entry point discovery
'require', 'run_script', 'get_provider', 'get_distribution',
'load_entry_point', 'get_entry_map', 'get_entry_info',
'iter_entry_points',
'resource_string', 'resource_stream', 'resource_filename',
'resource_listdir', 'resource_exists', 'resource_isdir',
# Environmental control
'declare_namespace', 'working_set', 'add_activation_listener',
'find_distributions', 'set_extraction_path', 'cleanup_resources',
'get_default_cache',
# Primary implementation classes
'Environment', 'WorkingSet', 'ResourceManager',
'Distribution', 'Requirement', 'EntryPoint',
# Exceptions
'ResolutionError', 'VersionConflict', 'DistributionNotFound',
'UnknownExtra', 'ExtractionError',
# Warnings
'PEP440Warning',
# Parsing functions and string utilities
'parse_requirements', 'parse_version', 'safe_name', 'safe_version',
'get_platform', 'compatible_platforms', 'yield_lines', 'split_sections',
'safe_extra', 'to_filename', 'invalid_marker', 'evaluate_marker',
# filesystem utilities
'ensure_directory', 'normalize_path',
# Distribution "precedence" constants
'EGG_DIST', 'BINARY_DIST', 'SOURCE_DIST', 'CHECKOUT_DIST', 'DEVELOP_DIST',
# "Provider" interfaces, implementations, and registration/lookup APIs
'IMetadataProvider', 'IResourceProvider', 'FileMetadata',
'PathMetadata', 'EggMetadata', 'EmptyProvider', 'empty_provider',
'NullProvider', 'EggProvider', 'DefaultProvider', 'ZipProvider',
'register_finder', 'register_namespace_handler', 'register_loader_type',
'fixup_namespace_packages', 'get_importer',
# Deprecated/backward compatibility only
'run_main', 'AvailableDistributions',
]
class ResolutionError(Exception):
"""Abstract base for dependency resolution errors"""
def __repr__(self):
return self.__class__.__name__+repr(self.args)
class VersionConflict(ResolutionError):
"""
An already-installed version conflicts with the requested version.
Should be initialized with the installed Distribution and the requested
Requirement.
"""
_template = "{self.dist} is installed but {self.req} is required"
@property
def dist(self):
return self.args[0]
@property
def req(self):
return self.args[1]
def report(self):
return self._template.format(**locals())
def with_context(self, required_by):
"""
If required_by is non-empty, return a version of self that is a
ContextualVersionConflict.
"""
if not required_by:
return self
args = self.args + (required_by,)
return ContextualVersionConflict(*args)
class ContextualVersionConflict(VersionConflict):
"""
A VersionConflict that accepts a third parameter, the set of the
requirements that required the installed Distribution.
"""
_template = VersionConflict._template + ' by {self.required_by}'
@property
def required_by(self):
return self.args[2]
class DistributionNotFound(ResolutionError):
"""A requested distribution was not found"""
_template = ("The '{self.req}' distribution was not found "
"and is required by {self.requirers_str}")
@property
def req(self):
return self.args[0]
@property
def requirers(self):
return self.args[1]
@property
def requirers_str(self):
if not self.requirers:
return 'the application'
return ', '.join(self.requirers)
def report(self):
return self._template.format(**locals())
def __str__(self):
return self.report()
class UnknownExtra(ResolutionError):
"""Distribution doesn't have an "extra feature" of the given name"""
_provider_factories = {}
PY_MAJOR = sys.version[:3]
EGG_DIST = 3
BINARY_DIST = 2
SOURCE_DIST = 1
CHECKOUT_DIST = 0
DEVELOP_DIST = -1
def register_loader_type(loader_type, provider_factory):
"""Register `provider_factory` to make providers for `loader_type`
`loader_type` is the type or class of a PEP 302 ``module.__loader__``,
and `provider_factory` is a function that, passed a *module* object,
returns an ``IResourceProvider`` for that module.
"""
_provider_factories[loader_type] = provider_factory
def get_provider(moduleOrReq):
"""Return an IResourceProvider for the named module or requirement"""
if isinstance(moduleOrReq, Requirement):
return working_set.find(moduleOrReq) or require(str(moduleOrReq))[0]
try:
module = sys.modules[moduleOrReq]
except KeyError:
__import__(moduleOrReq)
module = sys.modules[moduleOrReq]
loader = getattr(module, '__loader__', None)
return _find_adapter(_provider_factories, loader)(module)
def _macosx_vers(_cache=[]):
if not _cache:
version = platform.mac_ver()[0]
# fallback for MacPorts
if version == '':
plist = '/System/Library/CoreServices/SystemVersion.plist'
if os.path.exists(plist):
if hasattr(plistlib, 'readPlist'):
plist_content = plistlib.readPlist(plist)
if 'ProductVersion' in plist_content:
version = plist_content['ProductVersion']
_cache.append(version.split('.'))
return _cache[0]
def _macosx_arch(machine):
return {'PowerPC': 'ppc', 'Power_Macintosh': 'ppc'}.get(machine, machine)
def get_build_platform():
"""Return this platform's string for platform-specific distributions
XXX Currently this is the same as ``distutils.util.get_platform()``, but it
needs some hacks for Linux and Mac OS X.
"""
try:
# Python 2.7 or >=3.2
from sysconfig import get_platform
except ImportError:
from distutils.util import get_platform
plat = get_platform()
if sys.platform == "darwin" and not plat.startswith('macosx-'):
try:
version = _macosx_vers()
machine = os.uname()[4].replace(" ", "_")
return "macosx-%d.%d-%s" % (int(version[0]), int(version[1]),
_macosx_arch(machine))
except ValueError:
# if someone is running a non-Mac darwin system, this will fall
# through to the default implementation
pass
return plat
macosVersionString = re.compile(r"macosx-(\d+)\.(\d+)-(.*)")
darwinVersionString = re.compile(r"darwin-(\d+)\.(\d+)\.(\d+)-(.*)")
# XXX backward compat
get_platform = get_build_platform
def compatible_platforms(provided, required):
"""Can code for the `provided` platform run on the `required` platform?
Returns true if either platform is ``None``, or the platforms are equal.
XXX Needs compatibility checks for Linux and other unixy OSes.
"""
if provided is None or required is None or provided==required:
# easy case
return True
# Mac OS X special cases
reqMac = macosVersionString.match(required)
if reqMac:
provMac = macosVersionString.match(provided)
# is this a Mac package?
if not provMac:
# this is backwards compatibility for packages built before
# setuptools 0.6. All packages built after this point will
# use the new macosx designation.
provDarwin = darwinVersionString.match(provided)
if provDarwin:
dversion = int(provDarwin.group(1))
macosversion = "%s.%s" % (reqMac.group(1), reqMac.group(2))
if dversion == 7 and macosversion >= "10.3" or \
dversion == 8 and macosversion >= "10.4":
return True
# egg isn't macosx or legacy darwin
return False
# are they the same major version and machine type?
if provMac.group(1) != reqMac.group(1) or \
provMac.group(3) != reqMac.group(3):
return False
# is the required OS major update >= the provided one?
if int(provMac.group(2)) > int(reqMac.group(2)):
return False
return True
# XXX Linux and other platforms' special cases should go here
return False
def run_script(dist_spec, script_name):
"""Locate distribution `dist_spec` and run its `script_name` script"""
ns = sys._getframe(1).f_globals
name = ns['__name__']
ns.clear()
ns['__name__'] = name
require(dist_spec)[0].run_script(script_name, ns)
# backward compatibility
run_main = run_script
def get_distribution(dist):
"""Return a current distribution object for a Requirement or string"""
if isinstance(dist, six.string_types):
dist = Requirement.parse(dist)
if isinstance(dist, Requirement):
dist = get_provider(dist)
if not isinstance(dist, Distribution):
raise TypeError("Expected string, Requirement, or Distribution", dist)
return dist
def load_entry_point(dist, group, name):
"""Return `name` entry point of `group` for `dist` or raise ImportError"""
return get_distribution(dist).load_entry_point(group, name)
def get_entry_map(dist, group=None):
"""Return the entry point map for `group`, or the full entry map"""
return get_distribution(dist).get_entry_map(group)
def get_entry_info(dist, group, name):
"""Return the EntryPoint object for `group`+`name`, or ``None``"""
return get_distribution(dist).get_entry_info(group, name)
class IMetadataProvider:
def has_metadata(name):
"""Does the package's distribution contain the named metadata?"""
def get_metadata(name):
"""The named metadata resource as a string"""
def get_metadata_lines(name):
"""Yield named metadata resource as list of non-blank non-comment lines
Leading and trailing whitespace is stripped from each line, and lines
with ``#`` as the first non-blank character are omitted."""
def metadata_isdir(name):
"""Is the named metadata a directory? (like ``os.path.isdir()``)"""
def metadata_listdir(name):
"""List of metadata names in the directory (like ``os.listdir()``)"""
def run_script(script_name, namespace):
"""Execute the named script in the supplied namespace dictionary"""
class IResourceProvider(IMetadataProvider):
"""An object that provides access to package resources"""
def get_resource_filename(manager, resource_name):
"""Return a true filesystem path for `resource_name`
`manager` must be an ``IResourceManager``"""
def get_resource_stream(manager, resource_name):
"""Return a readable file-like object for `resource_name`
`manager` must be an ``IResourceManager``"""
def get_resource_string(manager, resource_name):
"""Return a string containing the contents of `resource_name`
`manager` must be an ``IResourceManager``"""
def has_resource(resource_name):
"""Does the package contain the named resource?"""
def resource_isdir(resource_name):
"""Is the named resource a directory? (like ``os.path.isdir()``)"""
def resource_listdir(resource_name):
"""List of resource names in the directory (like ``os.listdir()``)"""
class WorkingSet(object):
"""A collection of active distributions on sys.path (or a similar list)"""
def __init__(self, entries=None):
"""Create working set from list of path entries (default=sys.path)"""
self.entries = []
self.entry_keys = {}
self.by_key = {}
self.callbacks = []
if entries is None:
entries = sys.path
for entry in entries:
self.add_entry(entry)
@classmethod
def _build_master(cls):
"""
Prepare the master working set.
"""
ws = cls()
try:
from __main__ import __requires__
except ImportError:
# The main program does not list any requirements
return ws
# ensure the requirements are met
try:
ws.require(__requires__)
except VersionConflict:
return cls._build_from_requirements(__requires__)
return ws
@classmethod
def _build_from_requirements(cls, req_spec):
"""
Build a working set from a requirement spec. Rewrites sys.path.
"""
# try it without defaults already on sys.path
# by starting with an empty path
ws = cls([])
reqs = parse_requirements(req_spec)
dists = ws.resolve(reqs, Environment())
for dist in dists:
ws.add(dist)
# add any missing entries from sys.path
for entry in sys.path:
if entry not in ws.entries:
ws.add_entry(entry)
# then copy back to sys.path
sys.path[:] = ws.entries
return ws
def add_entry(self, entry):
"""Add a path item to ``.entries``, finding any distributions on it
``find_distributions(entry, True)`` is used to find distributions
corresponding to the path entry, and they are added. `entry` is
always appended to ``.entries``, even if it is already present.
(This is because ``sys.path`` can contain the same value more than
once, and the ``.entries`` of the ``sys.path`` WorkingSet should always
equal ``sys.path``.)
"""
self.entry_keys.setdefault(entry, [])
self.entries.append(entry)
for dist in find_distributions(entry, True):
self.add(dist, entry, False)
def __contains__(self, dist):
"""True if `dist` is the active distribution for its project"""
return self.by_key.get(dist.key) == dist
def find(self, req):
"""Find a distribution matching requirement `req`
If there is an active distribution for the requested project, this
returns it as long as it meets the version requirement specified by
`req`. But, if there is an active distribution for the project and it
does *not* meet the `req` requirement, ``VersionConflict`` is raised.
If there is no active distribution for the requested project, ``None``
is returned.
"""
dist = self.by_key.get(req.key)
if dist is not None and dist not in req:
# XXX add more info
raise VersionConflict(dist, req)
return dist
def iter_entry_points(self, group, name=None):
"""Yield entry point objects from `group` matching `name`
If `name` is None, yields all entry points in `group` from all
distributions in the working set, otherwise only ones matching
both `group` and `name` are yielded (in distribution order).
"""
for dist in self:
entries = dist.get_entry_map(group)
if name is None:
for ep in entries.values():
yield ep
elif name in entries:
yield entries[name]
def run_script(self, requires, script_name):
"""Locate distribution for `requires` and run `script_name` script"""
ns = sys._getframe(1).f_globals
name = ns['__name__']
ns.clear()
ns['__name__'] = name
self.require(requires)[0].run_script(script_name, ns)
def __iter__(self):
"""Yield distributions for non-duplicate projects in the working set
The yield order is the order in which the items' path entries were
added to the working set.
"""
seen = {}
for item in self.entries:
if item not in self.entry_keys:
# workaround a cache issue
continue
for key in self.entry_keys[item]:
if key not in seen:
seen[key]=1
yield self.by_key[key]
def add(self, dist, entry=None, insert=True, replace=False):
"""Add `dist` to working set, associated with `entry`
If `entry` is unspecified, it defaults to the ``.location`` of `dist`.
On exit from this routine, `entry` is added to the end of the working
set's ``.entries`` (if it wasn't already present).
`dist` is only added to the working set if it's for a project that
doesn't already have a distribution in the set, unless `replace=True`.
If it's added, any callbacks registered with the ``subscribe()`` method
will be called.
"""
if insert:
dist.insert_on(self.entries, entry, replace=replace)
if entry is None:
entry = dist.location
keys = self.entry_keys.setdefault(entry,[])
keys2 = self.entry_keys.setdefault(dist.location,[])
if not replace and dist.key in self.by_key:
# ignore hidden distros
return
self.by_key[dist.key] = dist
if dist.key not in keys:
keys.append(dist.key)
if dist.key not in keys2:
keys2.append(dist.key)
self._added_new(dist)
def resolve(self, requirements, env=None, installer=None,
replace_conflicting=False):
"""List all distributions needed to (recursively) meet `requirements`
`requirements` must be a sequence of ``Requirement`` objects. `env`,
if supplied, should be an ``Environment`` instance. If
not supplied, it defaults to all distributions available within any
entry or distribution in the working set. `installer`, if supplied,
will be invoked with each requirement that cannot be met by an
already-installed distribution; it should return a ``Distribution`` or
``None``.
Unless `replace_conflicting=True`, raises a VersionConflict exception if
any requirements are found on the path that have the correct name but
the wrong version. Otherwise, if an `installer` is supplied it will be
invoked to obtain the correct version of the requirement and activate
it.
"""
# set up the stack
requirements = list(requirements)[::-1]
# set of processed requirements
processed = {}
# key -> dist
best = {}
to_activate = []
req_extras = _ReqExtras()
# Mapping of requirement to set of distributions that required it;
# useful for reporting info about conflicts.
required_by = collections.defaultdict(set)
while requirements:
# process dependencies breadth-first
req = requirements.pop(0)
if req in processed:
# Ignore cyclic or redundant dependencies
continue
if not req_extras.markers_pass(req):
continue
dist = best.get(req.key)
if dist is None:
# Find the best distribution and add it to the map
dist = self.by_key.get(req.key)
if dist is None or (dist not in req and replace_conflicting):
ws = self
if env is None:
if dist is None:
env = Environment(self.entries)
else:
# Use an empty environment and workingset to avoid
# any further conflicts with the conflicting
# distribution
env = Environment([])
ws = WorkingSet([])
dist = best[req.key] = env.best_match(req, ws, installer)
if dist is None:
requirers = required_by.get(req, None)
raise DistributionNotFound(req, requirers)
to_activate.append(dist)
if dist not in req:
# Oops, the "best" so far conflicts with a dependency
dependent_req = required_by[req]
raise VersionConflict(dist, req).with_context(dependent_req)
# push the new requirements onto the stack
new_requirements = dist.requires(req.extras)[::-1]
requirements.extend(new_requirements)
# Register the new requirements needed by req
for new_requirement in new_requirements:
required_by[new_requirement].add(req.project_name)
req_extras[new_requirement] = req.extras
processed[req] = True
# return list of distros to activate
return to_activate
def find_plugins(self, plugin_env, full_env=None, installer=None,
fallback=True):
"""Find all activatable distributions in `plugin_env`
Example usage::
distributions, errors = working_set.find_plugins(
Environment(plugin_dirlist)
)
# add plugins+libs to sys.path
map(working_set.add, distributions)
# display errors
print('Could not load', errors)
The `plugin_env` should be an ``Environment`` instance that contains
only distributions that are in the project's "plugin directory" or
directories. The `full_env`, if supplied, should be an ``Environment``
contains all currently-available distributions. If `full_env` is not
supplied, one is created automatically from the ``WorkingSet`` this
method is called on, which will typically mean that every directory on
``sys.path`` will be scanned for distributions.
`installer` is a standard installer callback as used by the
``resolve()`` method. The `fallback` flag indicates whether we should
attempt to resolve older versions of a plugin if the newest version
cannot be resolved.
This method returns a 2-tuple: (`distributions`, `error_info`), where
`distributions` is a list of the distributions found in `plugin_env`
that were loadable, along with any other distributions that are needed
to resolve their dependencies. `error_info` is a dictionary mapping
unloadable plugin distributions to an exception instance describing the
error that occurred. Usually this will be a ``DistributionNotFound`` or
``VersionConflict`` instance.
"""
plugin_projects = list(plugin_env)
# scan project names in alphabetic order
plugin_projects.sort()
error_info = {}
distributions = {}
if full_env is None:
env = Environment(self.entries)
env += plugin_env
else:
env = full_env + plugin_env
shadow_set = self.__class__([])
# put all our entries in shadow_set
list(map(shadow_set.add, self))
for project_name in plugin_projects:
for dist in plugin_env[project_name]:
req = [dist.as_requirement()]
try:
resolvees = shadow_set.resolve(req, env, installer)
except ResolutionError as v:
# save error info
error_info[dist] = v
if fallback:
# try the next older version of project
continue
else:
# give up on this project, keep going
break
else:
list(map(shadow_set.add, resolvees))
distributions.update(dict.fromkeys(resolvees))
# success, no need to try any more versions of this project
break
distributions = list(distributions)
distributions.sort()
return distributions, error_info
def require(self, *requirements):
"""Ensure that distributions matching `requirements` are activated
`requirements` must be a string or a (possibly-nested) sequence
thereof, specifying the distributions and versions required. The
return value is a sequence of the distributions that needed to be
activated to fulfill the requirements; all relevant distributions are
included, even if they were already activated in this working set.
"""
needed = self.resolve(parse_requirements(requirements))
for dist in needed:
self.add(dist)
return needed
def subscribe(self, callback):
"""Invoke `callback` for all distributions (including existing ones)"""
if callback in self.callbacks:
return
self.callbacks.append(callback)
for dist in self:
callback(dist)
def _added_new(self, dist):
for callback in self.callbacks:
callback(dist)
def __getstate__(self):
return (
self.entries[:], self.entry_keys.copy(), self.by_key.copy(),
self.callbacks[:]
)
def __setstate__(self, e_k_b_c):
entries, keys, by_key, callbacks = e_k_b_c
self.entries = entries[:]
self.entry_keys = keys.copy()
self.by_key = by_key.copy()
self.callbacks = callbacks[:]
class _ReqExtras(dict):
"""
Map each requirement to the extras that demanded it.
"""
def markers_pass(self, req):
"""
Evaluate markers for req against each extra that
demanded it.
Return False if the req has a marker and fails
evaluation. Otherwise, return True.
"""
extra_evals = (
req.marker.evaluate({'extra': extra})
for extra in self.get(req, ())
)
return not req.marker or any(extra_evals) or req.marker.evaluate()
class Environment(object):
"""Searchable snapshot of distributions on a search path"""
def __init__(self, search_path=None, platform=get_supported_platform(),
python=PY_MAJOR):
"""Snapshot distributions available on a search path
Any distributions found on `search_path` are added to the environment.
`search_path` should be a sequence of ``sys.path`` items. If not
supplied, ``sys.path`` is used.
`platform` is an optional string specifying the name of the platform
that platform-specific distributions must be compatible with. If
unspecified, it defaults to the current platform. `python` is an
optional string naming the desired version of Python (e.g. ``'3.3'``);
it defaults to the current version.
You may explicitly set `platform` (and/or `python`) to ``None`` if you
wish to map *all* distributions, not just those compatible with the
running platform or Python version.
"""
self._distmap = {}
self.platform = platform
self.python = python
self.scan(search_path)
def can_add(self, dist):
"""Is distribution `dist` acceptable for this environment?
The distribution must match the platform and python version
requirements specified when this environment was created, or False
is returned.
"""
return (self.python is None or dist.py_version is None
or dist.py_version==self.python) \
and compatible_platforms(dist.platform, self.platform)
def remove(self, dist):
"""Remove `dist` from the environment"""
self._distmap[dist.key].remove(dist)
def scan(self, search_path=None):
"""Scan `search_path` for distributions usable in this environment
Any distributions found are added to the environment.
`search_path` should be a sequence of ``sys.path`` items. If not
supplied, ``sys.path`` is used. Only distributions conforming to
the platform/python version defined at initialization are added.
"""
if search_path is None:
search_path = sys.path
for item in search_path:
for dist in find_distributions(item):
self.add(dist)
def __getitem__(self, project_name):
"""Return a newest-to-oldest list of distributions for `project_name`
Uses case-insensitive `project_name` comparison, assuming all the
project's distributions use their project's name converted to all
lowercase as their key.
"""
distribution_key = project_name.lower()
return self._distmap.get(distribution_key, [])
def add(self, dist):
"""Add `dist` if we ``can_add()`` it and it has not already been added
"""
if self.can_add(dist) and dist.has_version():
dists = self._distmap.setdefault(dist.key, [])
if dist not in dists:
dists.append(dist)
dists.sort(key=operator.attrgetter('hashcmp'), reverse=True)
def best_match(self, req, working_set, installer=None):
"""Find distribution best matching `req` and usable on `working_set`
This calls the ``find(req)`` method of the `working_set` to see if a
suitable distribution is already active. (This may raise
``VersionConflict`` if an unsuitable version of the project is already
active in the specified `working_set`.) If a suitable distribution
isn't active, this method returns the newest distribution in the
environment that meets the ``Requirement`` in `req`. If no suitable
distribution is found, and `installer` is supplied, then the result of
calling the environment's ``obtain(req, installer)`` method will be
returned.
"""
dist = working_set.find(req)
if dist is not None:
return dist
for dist in self[req.key]:
if dist in req:
return dist
# try to download/install
return self.obtain(req, installer)
def obtain(self, requirement, installer=None):
"""Obtain a distribution matching `requirement` (e.g. via download)
Obtain a distro that matches requirement (e.g. via download). In the
base ``Environment`` class, this routine just returns
``installer(requirement)``, unless `installer` is None, in which case
None is returned instead. This method is a hook that allows subclasses
to attempt other ways of obtaining a distribution before falling back
to the `installer` argument."""
if installer is not None:
return installer(requirement)
def __iter__(self):
"""Yield the unique project names of the available distributions"""
for key in self._distmap.keys():
if self[key]:
yield key
def __iadd__(self, other):
"""In-place addition of a distribution or environment"""
if isinstance(other, Distribution):
self.add(other)
elif isinstance(other, Environment):
for project in other:
for dist in other[project]:
self.add(dist)
else:
raise TypeError("Can't add %r to environment" % (other,))
return self
def __add__(self, other):
"""Add an environment or distribution to an environment"""
new = self.__class__([], platform=None, python=None)
for env in self, other:
new += env
return new
# XXX backward compatibility
AvailableDistributions = Environment
class ExtractionError(RuntimeError):
"""An error occurred extracting a resource
The following attributes are available from instances of this exception:
manager
The resource manager that raised this exception
cache_path
The base directory for resource extraction
original_error
The exception instance that caused extraction to fail
"""
class ResourceManager:
"""Manage resource extraction and packages"""
extraction_path = None
def __init__(self):
self.cached_files = {}
def resource_exists(self, package_or_requirement, resource_name):
"""Does the named resource exist?"""
return get_provider(package_or_requirement).has_resource(resource_name)
def resource_isdir(self, package_or_requirement, resource_name):
"""Is the named resource an existing directory?"""
return get_provider(package_or_requirement).resource_isdir(
resource_name
)
def resource_filename(self, package_or_requirement, resource_name):
"""Return a true filesystem path for specified resource"""
return get_provider(package_or_requirement).get_resource_filename(
self, resource_name
)
def resource_stream(self, package_or_requirement, resource_name):
"""Return a readable file-like object for specified resource"""
return get_provider(package_or_requirement).get_resource_stream(
self, resource_name
)
def resource_string(self, package_or_requirement, resource_name):
"""Return specified resource as a string"""
return get_provider(package_or_requirement).get_resource_string(
self, resource_name
)
def resource_listdir(self, package_or_requirement, resource_name):
"""List the contents of the named resource directory"""
return get_provider(package_or_requirement).resource_listdir(
resource_name
)
def extraction_error(self):
"""Give an error message for problems extracting file(s)"""
old_exc = sys.exc_info()[1]
cache_path = self.extraction_path or get_default_cache()
tmpl = textwrap.dedent("""
Can't extract file(s) to egg cache
The following error occurred while trying to extract file(s) to the Python egg
cache:
{old_exc}
The Python egg cache directory is currently set to:
{cache_path}
Perhaps your account does not have write access to this directory? You can
change the cache directory by setting the PYTHON_EGG_CACHE environment
variable to point to an accessible directory.
""").lstrip()
err = ExtractionError(tmpl.format(**locals()))
err.manager = self
err.cache_path = cache_path
err.original_error = old_exc
raise err
def get_cache_path(self, archive_name, names=()):
"""Return absolute location in cache for `archive_name` and `names`
The parent directory of the resulting path will be created if it does
not already exist. `archive_name` should be the base filename of the
enclosing egg (which may not be the name of the enclosing zipfile!),
including its ".egg" extension. `names`, if provided, should be a
sequence of path name parts "under" the egg's extraction location.
This method should only be called by resource providers that need to
obtain an extraction location, and only for names they intend to
extract, as it tracks the generated names for possible cleanup later.
"""
extract_path = self.extraction_path or get_default_cache()
target_path = os.path.join(extract_path, archive_name+'-tmp', *names)
try:
_bypass_ensure_directory(target_path)
except:
self.extraction_error()
self._warn_unsafe_extraction_path(extract_path)
self.cached_files[target_path] = 1
return target_path
@staticmethod
def _warn_unsafe_extraction_path(path):
"""
If the default extraction path is overridden and set to an insecure
location, such as /tmp, it opens up an opportunity for an attacker to
replace an extracted file with an unauthorized payload. Warn the user
if a known insecure location is used.
See Distribute #375 for more details.
"""
if os.name == 'nt' and not path.startswith(os.environ['windir']):
# On Windows, permissions are generally restrictive by default
# and temp directories are not writable by other users, so
# bypass the warning.
return
mode = os.stat(path).st_mode
if mode & stat.S_IWOTH or mode & stat.S_IWGRP:
msg = ("%s is writable by group/others and vulnerable to attack "
"when "
"used with get_resource_filename. Consider a more secure "
"location (set with .set_extraction_path or the "
"PYTHON_EGG_CACHE environment variable)." % path)
warnings.warn(msg, UserWarning)
def postprocess(self, tempname, filename):
"""Perform any platform-specific postprocessing of `tempname`
This is where Mac header rewrites should be done; other platforms don't
have anything special they should do.
Resource providers should call this method ONLY after successfully
extracting a compressed resource. They must NOT call it on resources
that are already in the filesystem.
`tempname` is the current (temporary) name of the file, and `filename`
is the name it will be renamed to by the caller after this routine
returns.
"""
if os.name == 'posix':
# Make the resource executable
mode = ((os.stat(tempname).st_mode) | 0o555) & 0o7777
os.chmod(tempname, mode)
def set_extraction_path(self, path):
"""Set the base path where resources will be extracted to, if needed.
If you do not call this routine before any extractions take place, the
path defaults to the return value of ``get_default_cache()``. (Which
is based on the ``PYTHON_EGG_CACHE`` environment variable, with various
platform-specific fallbacks. See that routine's documentation for more
details.)
Resources are extracted to subdirectories of this path based upon
information given by the ``IResourceProvider``. You may set this to a
temporary directory, but then you must call ``cleanup_resources()`` to
delete the extracted files when done. There is no guarantee that
``cleanup_resources()`` will be able to remove all extracted files.
(Note: you may not change the extraction path for a given resource
manager once resources have been extracted, unless you first call
``cleanup_resources()``.)
"""
if self.cached_files:
raise ValueError(
"Can't change extraction path, files already extracted"
)
self.extraction_path = path
def cleanup_resources(self, force=False):
"""
Delete all extracted resource files and directories, returning a list
of the file and directory names that could not be successfully removed.
This function does not have any concurrency protection, so it should
generally only be called when the extraction path is a temporary
directory exclusive to a single process. This method is not
automatically called; you must call it explicitly or register it as an
``atexit`` function if you wish to ensure cleanup of a temporary
directory used for extractions.
"""
# XXX
def get_default_cache():
"""Determine the default cache location
This returns the ``PYTHON_EGG_CACHE`` environment variable, if set.
Otherwise, on Windows, it returns a "Python-Eggs" subdirectory of the
"Application Data" directory. On all other systems, it's "~/.python-eggs".
"""
try:
return os.environ['PYTHON_EGG_CACHE']
except KeyError:
pass
if os.name!='nt':
return os.path.expanduser('~/.python-eggs')
# XXX this may be locale-specific!
app_data = 'Application Data'
app_homes = [
# best option, should be locale-safe
(('APPDATA',), None),
(('USERPROFILE',), app_data),
(('HOMEDRIVE','HOMEPATH'), app_data),
(('HOMEPATH',), app_data),
(('HOME',), None),
# 95/98/ME
(('WINDIR',), app_data),
]
for keys, subdir in app_homes:
dirname = ''
for key in keys:
if key in os.environ:
dirname = os.path.join(dirname, os.environ[key])
else:
break
else:
if subdir:
dirname = os.path.join(dirname, subdir)
return os.path.join(dirname, 'Python-Eggs')
else:
raise RuntimeError(
"Please set the PYTHON_EGG_CACHE enviroment variable"
)
def safe_name(name):
"""Convert an arbitrary string to a standard distribution name
Any runs of non-alphanumeric/. characters are replaced with a single '-'.
"""
return re.sub('[^A-Za-z0-9.]+', '-', name)
def safe_version(version):
"""
Convert an arbitrary string to a standard version string
"""
try:
# normalize the version
return str(packaging.version.Version(version))
except packaging.version.InvalidVersion:
version = version.replace(' ','.')
return re.sub('[^A-Za-z0-9.]+', '-', version)
def safe_extra(extra):
"""Convert an arbitrary string to a standard 'extra' name
Any runs of non-alphanumeric characters are replaced with a single '_',
and the result is always lowercased.
"""
return re.sub('[^A-Za-z0-9.]+', '_', extra).lower()
def to_filename(name):
"""Convert a project or version name to its filename-escaped form
Any '-' characters are currently replaced with '_'.
"""
return name.replace('-','_')
def invalid_marker(text):
"""
Validate text as a PEP 508 environment marker; return an exception
if invalid or False otherwise.
"""
try:
evaluate_marker(text)
except SyntaxError as e:
e.filename = None
e.lineno = None
return e
return False
def evaluate_marker(text, extra=None):
"""
Evaluate a PEP 508 environment marker.
Return a boolean indicating the marker result in this environment.
Raise SyntaxError if marker is invalid.
This implementation uses the 'pyparsing' module.
"""
try:
marker = packaging.markers.Marker(text)
return marker.evaluate()
except packaging.markers.InvalidMarker as e:
raise SyntaxError(e)
class NullProvider:
"""Try to implement resources and metadata for arbitrary PEP 302 loaders"""
egg_name = None
egg_info = None
loader = None
def __init__(self, module):
self.loader = getattr(module, '__loader__', None)
self.module_path = os.path.dirname(getattr(module, '__file__', ''))
def get_resource_filename(self, manager, resource_name):
return self._fn(self.module_path, resource_name)
def get_resource_stream(self, manager, resource_name):
return io.BytesIO(self.get_resource_string(manager, resource_name))
def get_resource_string(self, manager, resource_name):
return self._get(self._fn(self.module_path, resource_name))
def has_resource(self, resource_name):
return self._has(self._fn(self.module_path, resource_name))
def has_metadata(self, name):
return self.egg_info and self._has(self._fn(self.egg_info, name))
if sys.version_info <= (3,):
def get_metadata(self, name):
if not self.egg_info:
return ""
return self._get(self._fn(self.egg_info, name))
else:
def get_metadata(self, name):
if not self.egg_info:
return ""
return self._get(self._fn(self.egg_info, name)).decode("utf-8")
def get_metadata_lines(self, name):
return yield_lines(self.get_metadata(name))
def resource_isdir(self, resource_name):
return self._isdir(self._fn(self.module_path, resource_name))
def metadata_isdir(self, name):
return self.egg_info and self._isdir(self._fn(self.egg_info, name))
def resource_listdir(self, resource_name):
return self._listdir(self._fn(self.module_path, resource_name))
def metadata_listdir(self, name):
if self.egg_info:
return self._listdir(self._fn(self.egg_info, name))
return []
def run_script(self, script_name, namespace):
script = 'scripts/'+script_name
if not self.has_metadata(script):
raise ResolutionError("No script named %r" % script_name)
script_text = self.get_metadata(script).replace('\r\n', '\n')
script_text = script_text.replace('\r', '\n')
script_filename = self._fn(self.egg_info, script)
namespace['__file__'] = script_filename
if os.path.exists(script_filename):
source = open(script_filename).read()
code = compile(source, script_filename, 'exec')
exec(code, namespace, namespace)
else:
from linecache import cache
cache[script_filename] = (
len(script_text), 0, script_text.split('\n'), script_filename
)
script_code = compile(script_text, script_filename,'exec')
exec(script_code, namespace, namespace)
def _has(self, path):
raise NotImplementedError(
"Can't perform this operation for unregistered loader type"
)
def _isdir(self, path):
raise NotImplementedError(
"Can't perform this operation for unregistered loader type"
)
def _listdir(self, path):
raise NotImplementedError(
"Can't perform this operation for unregistered loader type"
)
def _fn(self, base, resource_name):
if resource_name:
return os.path.join(base, *resource_name.split('/'))
return base
def _get(self, path):
if hasattr(self.loader, 'get_data'):
return self.loader.get_data(path)
raise NotImplementedError(
"Can't perform this operation for loaders without 'get_data()'"
)
register_loader_type(object, NullProvider)
class EggProvider(NullProvider):
"""Provider based on a virtual filesystem"""
def __init__(self, module):
NullProvider.__init__(self, module)
self._setup_prefix()
def _setup_prefix(self):
# we assume here that our metadata may be nested inside a "basket"
# of multiple eggs; that's why we use module_path instead of .archive
path = self.module_path
old = None
while path!=old:
if _is_unpacked_egg(path):
self.egg_name = os.path.basename(path)
self.egg_info = os.path.join(path, 'EGG-INFO')
self.egg_root = path
break
old = path
path, base = os.path.split(path)
class DefaultProvider(EggProvider):
"""Provides access to package resources in the filesystem"""
def _has(self, path):
return os.path.exists(path)
def _isdir(self, path):
return os.path.isdir(path)
def _listdir(self, path):
return os.listdir(path)
def get_resource_stream(self, manager, resource_name):
return open(self._fn(self.module_path, resource_name), 'rb')
def _get(self, path):
with open(path, 'rb') as stream:
return stream.read()
@classmethod
def _register(cls):
loader_cls = getattr(importlib_machinery, 'SourceFileLoader',
type(None))
register_loader_type(loader_cls, cls)
DefaultProvider._register()
class EmptyProvider(NullProvider):
"""Provider that returns nothing for all requests"""
_isdir = _has = lambda self, path: False
_get = lambda self, path: ''
_listdir = lambda self, path: []
module_path = None
def __init__(self):
pass
empty_provider = EmptyProvider()
class ZipManifests(dict):
"""
zip manifest builder
"""
@classmethod
def build(cls, path):
"""
Build a dictionary similar to the zipimport directory
caches, except instead of tuples, store ZipInfo objects.
Use a platform-specific path separator (os.sep) for the path keys
for compatibility with pypy on Windows.
"""
with ContextualZipFile(path) as zfile:
items = (
(
name.replace('/', os.sep),
zfile.getinfo(name),
)
for name in zfile.namelist()
)
return dict(items)
load = build
class MemoizedZipManifests(ZipManifests):
"""
Memoized zipfile manifests.
"""
manifest_mod = collections.namedtuple('manifest_mod', 'manifest mtime')
def load(self, path):
"""
Load a manifest at path or return a suitable manifest already loaded.
"""
path = os.path.normpath(path)
mtime = os.stat(path).st_mtime
if path not in self or self[path].mtime != mtime:
manifest = self.build(path)
self[path] = self.manifest_mod(manifest, mtime)
return self[path].manifest
class ContextualZipFile(zipfile.ZipFile):
"""
Supplement ZipFile class to support context manager for Python 2.6
"""
def __enter__(self):
return self
def __exit__(self, type, value, traceback):
self.close()
def __new__(cls, *args, **kwargs):
"""
Construct a ZipFile or ContextualZipFile as appropriate
"""
if hasattr(zipfile.ZipFile, '__exit__'):
return zipfile.ZipFile(*args, **kwargs)
return super(ContextualZipFile, cls).__new__(cls)
class ZipProvider(EggProvider):
"""Resource support for zips and eggs"""
eagers = None
_zip_manifests = MemoizedZipManifests()
def __init__(self, module):
EggProvider.__init__(self, module)
self.zip_pre = self.loader.archive+os.sep
def _zipinfo_name(self, fspath):
# Convert a virtual filename (full path to file) into a zipfile subpath
# usable with the zipimport directory cache for our target archive
if fspath.startswith(self.zip_pre):
return fspath[len(self.zip_pre):]
raise AssertionError(
"%s is not a subpath of %s" % (fspath, self.zip_pre)
)
def _parts(self, zip_path):
# Convert a zipfile subpath into an egg-relative path part list.
# pseudo-fs path
fspath = self.zip_pre+zip_path
if fspath.startswith(self.egg_root+os.sep):
return fspath[len(self.egg_root)+1:].split(os.sep)
raise AssertionError(
"%s is not a subpath of %s" % (fspath, self.egg_root)
)
@property
def zipinfo(self):
return self._zip_manifests.load(self.loader.archive)
def get_resource_filename(self, manager, resource_name):
if not self.egg_name:
raise NotImplementedError(
"resource_filename() only supported for .egg, not .zip"
)
# no need to lock for extraction, since we use temp names
zip_path = self._resource_to_zip(resource_name)
eagers = self._get_eager_resources()
if '/'.join(self._parts(zip_path)) in eagers:
for name in eagers:
self._extract_resource(manager, self._eager_to_zip(name))
return self._extract_resource(manager, zip_path)
@staticmethod
def _get_date_and_size(zip_stat):
size = zip_stat.file_size
# ymdhms+wday, yday, dst
date_time = zip_stat.date_time + (0, 0, -1)
# 1980 offset already done
timestamp = time.mktime(date_time)
return timestamp, size
def _extract_resource(self, manager, zip_path):
if zip_path in self._index():
for name in self._index()[zip_path]:
last = self._extract_resource(
manager, os.path.join(zip_path, name)
)
# return the extracted directory name
return os.path.dirname(last)
timestamp, size = self._get_date_and_size(self.zipinfo[zip_path])
if not WRITE_SUPPORT:
raise IOError('"os.rename" and "os.unlink" are not supported '
'on this platform')
try:
real_path = manager.get_cache_path(
self.egg_name, self._parts(zip_path)
)
if self._is_current(real_path, zip_path):
return real_path
outf, tmpnam = _mkstemp(".$extract", dir=os.path.dirname(real_path))
os.write(outf, self.loader.get_data(zip_path))
os.close(outf)
utime(tmpnam, (timestamp, timestamp))
manager.postprocess(tmpnam, real_path)
try:
rename(tmpnam, real_path)
except os.error:
if os.path.isfile(real_path):
if self._is_current(real_path, zip_path):
# the file became current since it was checked above,
# so proceed.
return real_path
# Windows, del old file and retry
elif os.name=='nt':
unlink(real_path)
rename(tmpnam, real_path)
return real_path
raise
except os.error:
# report a user-friendly error
manager.extraction_error()
return real_path
def _is_current(self, file_path, zip_path):
"""
Return True if the file_path is current for this zip_path
"""
timestamp, size = self._get_date_and_size(self.zipinfo[zip_path])
if not os.path.isfile(file_path):
return False
stat = os.stat(file_path)
if stat.st_size!=size or stat.st_mtime!=timestamp:
return False
# check that the contents match
zip_contents = self.loader.get_data(zip_path)
with open(file_path, 'rb') as f:
file_contents = f.read()
return zip_contents == file_contents
def _get_eager_resources(self):
if self.eagers is None:
eagers = []
for name in ('native_libs.txt', 'eager_resources.txt'):
if self.has_metadata(name):
eagers.extend(self.get_metadata_lines(name))
self.eagers = eagers
return self.eagers
def _index(self):
try:
return self._dirindex
except AttributeError:
ind = {}
for path in self.zipinfo:
parts = path.split(os.sep)
while parts:
parent = os.sep.join(parts[:-1])
if parent in ind:
ind[parent].append(parts[-1])
break
else:
ind[parent] = [parts.pop()]
self._dirindex = ind
return ind
def _has(self, fspath):
zip_path = self._zipinfo_name(fspath)
return zip_path in self.zipinfo or zip_path in self._index()
def _isdir(self, fspath):
return self._zipinfo_name(fspath) in self._index()
def _listdir(self, fspath):
return list(self._index().get(self._zipinfo_name(fspath), ()))
def _eager_to_zip(self, resource_name):
return self._zipinfo_name(self._fn(self.egg_root, resource_name))
def _resource_to_zip(self, resource_name):
return self._zipinfo_name(self._fn(self.module_path, resource_name))
register_loader_type(zipimport.zipimporter, ZipProvider)
class FileMetadata(EmptyProvider):
"""Metadata handler for standalone PKG-INFO files
Usage::
metadata = FileMetadata("/path/to/PKG-INFO")
This provider rejects all data and metadata requests except for PKG-INFO,
which is treated as existing, and will be the contents of the file at
the provided location.
"""
def __init__(self, path):
self.path = path
def has_metadata(self, name):
return name=='PKG-INFO' and os.path.isfile(self.path)
def get_metadata(self, name):
if name=='PKG-INFO':
with io.open(self.path, encoding='utf-8') as f:
try:
metadata = f.read()
except UnicodeDecodeError as exc:
# add path context to error message
tmpl = " in {self.path}"
exc.reason += tmpl.format(self=self)
raise
return metadata
raise KeyError("No metadata except PKG-INFO is available")
def get_metadata_lines(self, name):
return yield_lines(self.get_metadata(name))
class PathMetadata(DefaultProvider):
"""Metadata provider for egg directories
Usage::
# Development eggs:
egg_info = "/path/to/PackageName.egg-info"
base_dir = os.path.dirname(egg_info)
metadata = PathMetadata(base_dir, egg_info)
dist_name = os.path.splitext(os.path.basename(egg_info))[0]
dist = Distribution(basedir, project_name=dist_name, metadata=metadata)
# Unpacked egg directories:
egg_path = "/path/to/PackageName-ver-pyver-etc.egg"
metadata = PathMetadata(egg_path, os.path.join(egg_path,'EGG-INFO'))
dist = Distribution.from_filename(egg_path, metadata=metadata)
"""
def __init__(self, path, egg_info):
self.module_path = path
self.egg_info = egg_info
class EggMetadata(ZipProvider):
"""Metadata provider for .egg files"""
def __init__(self, importer):
"""Create a metadata provider from a zipimporter"""
self.zip_pre = importer.archive+os.sep
self.loader = importer
if importer.prefix:
self.module_path = os.path.join(importer.archive, importer.prefix)
else:
self.module_path = importer.archive
self._setup_prefix()
_declare_state('dict', _distribution_finders = {})
def register_finder(importer_type, distribution_finder):
"""Register `distribution_finder` to find distributions in sys.path items
`importer_type` is the type or class of a PEP 302 "Importer" (sys.path item
handler), and `distribution_finder` is a callable that, passed a path
item and the importer instance, yields ``Distribution`` instances found on
that path item. See ``pkg_resources.find_on_path`` for an example."""
_distribution_finders[importer_type] = distribution_finder
def find_distributions(path_item, only=False):
"""Yield distributions accessible via `path_item`"""
importer = get_importer(path_item)
finder = _find_adapter(_distribution_finders, importer)
return finder(importer, path_item, only)
def find_eggs_in_zip(importer, path_item, only=False):
"""
Find eggs in zip files; possibly multiple nested eggs.
"""
if importer.archive.endswith('.whl'):
# wheels are not supported with this finder
# they don't have PKG-INFO metadata, and won't ever contain eggs
return
metadata = EggMetadata(importer)
if metadata.has_metadata('PKG-INFO'):
yield Distribution.from_filename(path_item, metadata=metadata)
if only:
# don't yield nested distros
return
for subitem in metadata.resource_listdir('/'):
if _is_unpacked_egg(subitem):
subpath = os.path.join(path_item, subitem)
for dist in find_eggs_in_zip(zipimport.zipimporter(subpath), subpath):
yield dist
register_finder(zipimport.zipimporter, find_eggs_in_zip)
def find_nothing(importer, path_item, only=False):
return ()
register_finder(object, find_nothing)
def find_on_path(importer, path_item, only=False):
"""Yield distributions accessible on a sys.path directory"""
path_item = _normalize_cached(path_item)
if os.path.isdir(path_item) and os.access(path_item, os.R_OK):
if _is_unpacked_egg(path_item):
yield Distribution.from_filename(
path_item, metadata=PathMetadata(
path_item, os.path.join(path_item,'EGG-INFO')
)
)
else:
# scan for .egg and .egg-info in directory
for entry in os.listdir(path_item):
lower = entry.lower()
if lower.endswith('.egg-info') or lower.endswith('.dist-info'):
fullpath = os.path.join(path_item, entry)
if os.path.isdir(fullpath):
# egg-info directory, allow getting metadata
metadata = PathMetadata(path_item, fullpath)
else:
metadata = FileMetadata(fullpath)
yield Distribution.from_location(
path_item, entry, metadata, precedence=DEVELOP_DIST
)
elif not only and _is_unpacked_egg(entry):
dists = find_distributions(os.path.join(path_item, entry))
for dist in dists:
yield dist
elif not only and lower.endswith('.egg-link'):
with open(os.path.join(path_item, entry)) as entry_file:
entry_lines = entry_file.readlines()
for line in entry_lines:
if not line.strip():
continue
path = os.path.join(path_item, line.rstrip())
dists = find_distributions(path)
for item in dists:
yield item
break
register_finder(pkgutil.ImpImporter, find_on_path)
if hasattr(importlib_machinery, 'FileFinder'):
register_finder(importlib_machinery.FileFinder, find_on_path)
_declare_state('dict', _namespace_handlers={})
_declare_state('dict', _namespace_packages={})
def register_namespace_handler(importer_type, namespace_handler):
"""Register `namespace_handler` to declare namespace packages
`importer_type` is the type or class of a PEP 302 "Importer" (sys.path item
handler), and `namespace_handler` is a callable like this::
def namespace_handler(importer, path_entry, moduleName, module):
# return a path_entry to use for child packages
Namespace handlers are only called if the importer object has already
agreed that it can handle the relevant path item, and they should only
return a subpath if the module __path__ does not already contain an
equivalent subpath. For an example namespace handler, see
``pkg_resources.file_ns_handler``.
"""
_namespace_handlers[importer_type] = namespace_handler
def _handle_ns(packageName, path_item):
"""Ensure that named package includes a subpath of path_item (if needed)"""
importer = get_importer(path_item)
if importer is None:
return None
loader = importer.find_module(packageName)
if loader is None:
return None
module = sys.modules.get(packageName)
if module is None:
module = sys.modules[packageName] = types.ModuleType(packageName)
module.__path__ = []
_set_parent_ns(packageName)
elif not hasattr(module,'__path__'):
raise TypeError("Not a package:", packageName)
handler = _find_adapter(_namespace_handlers, importer)
subpath = handler(importer, path_item, packageName, module)
if subpath is not None:
path = module.__path__
path.append(subpath)
loader.load_module(packageName)
_rebuild_mod_path(path, packageName, module)
return subpath
def _rebuild_mod_path(orig_path, package_name, module):
"""
Rebuild module.__path__ ensuring that all entries are ordered
corresponding to their sys.path order
"""
sys_path = [_normalize_cached(p) for p in sys.path]
def position_in_sys_path(path):
"""
Return the ordinal of the path based on its position in sys.path
"""
path_parts = path.split(os.sep)
module_parts = package_name.count('.') + 1
parts = path_parts[:-module_parts]
return sys_path.index(_normalize_cached(os.sep.join(parts)))
orig_path.sort(key=position_in_sys_path)
module.__path__[:] = [_normalize_cached(p) for p in orig_path]
def declare_namespace(packageName):
"""Declare that package 'packageName' is a namespace package"""
_imp.acquire_lock()
try:
if packageName in _namespace_packages:
return
path, parent = sys.path, None
if '.' in packageName:
parent = '.'.join(packageName.split('.')[:-1])
declare_namespace(parent)
if parent not in _namespace_packages:
__import__(parent)
try:
path = sys.modules[parent].__path__
except AttributeError:
raise TypeError("Not a package:", parent)
# Track what packages are namespaces, so when new path items are added,
# they can be updated
_namespace_packages.setdefault(parent,[]).append(packageName)
_namespace_packages.setdefault(packageName,[])
for path_item in path:
# Ensure all the parent's path items are reflected in the child,
# if they apply
_handle_ns(packageName, path_item)
finally:
_imp.release_lock()
def fixup_namespace_packages(path_item, parent=None):
"""Ensure that previously-declared namespace packages include path_item"""
_imp.acquire_lock()
try:
for package in _namespace_packages.get(parent,()):
subpath = _handle_ns(package, path_item)
if subpath:
fixup_namespace_packages(subpath, package)
finally:
_imp.release_lock()
def file_ns_handler(importer, path_item, packageName, module):
"""Compute an ns-package subpath for a filesystem or zipfile importer"""
subpath = os.path.join(path_item, packageName.split('.')[-1])
normalized = _normalize_cached(subpath)
for item in module.__path__:
if _normalize_cached(item)==normalized:
break
else:
# Only return the path if it's not already there
return subpath
register_namespace_handler(pkgutil.ImpImporter, file_ns_handler)
register_namespace_handler(zipimport.zipimporter, file_ns_handler)
if hasattr(importlib_machinery, 'FileFinder'):
register_namespace_handler(importlib_machinery.FileFinder, file_ns_handler)
def null_ns_handler(importer, path_item, packageName, module):
return None
register_namespace_handler(object, null_ns_handler)
def normalize_path(filename):
"""Normalize a file/dir name for comparison purposes"""
return os.path.normcase(os.path.realpath(filename))
def _normalize_cached(filename, _cache={}):
try:
return _cache[filename]
except KeyError:
_cache[filename] = result = normalize_path(filename)
return result
def _is_unpacked_egg(path):
"""
Determine if given path appears to be an unpacked egg.
"""
return (
path.lower().endswith('.egg')
)
def _set_parent_ns(packageName):
parts = packageName.split('.')
name = parts.pop()
if parts:
parent = '.'.join(parts)
setattr(sys.modules[parent], name, sys.modules[packageName])
def yield_lines(strs):
"""Yield non-empty/non-comment lines of a string or sequence"""
if isinstance(strs, six.string_types):
for s in strs.splitlines():
s = s.strip()
# skip blank lines/comments
if s and not s.startswith('#'):
yield s
else:
for ss in strs:
for s in yield_lines(ss):
yield s
MODULE = re.compile(r"\w+(\.\w+)*$").match
EGG_NAME = re.compile(
r"""
(?P[^-]+) (
-(?P[^-]+) (
-py(?P[^-]+) (
-(?P.+)
)?
)?
)?
""",
re.VERBOSE | re.IGNORECASE,
).match
class EntryPoint(object):
"""Object representing an advertised importable object"""
def __init__(self, name, module_name, attrs=(), extras=(), dist=None):
if not MODULE(module_name):
raise ValueError("Invalid module name", module_name)
self.name = name
self.module_name = module_name
self.attrs = tuple(attrs)
self.extras = Requirement.parse(("x[%s]" % ','.join(extras))).extras
self.dist = dist
def __str__(self):
s = "%s = %s" % (self.name, self.module_name)
if self.attrs:
s += ':' + '.'.join(self.attrs)
if self.extras:
s += ' [%s]' % ','.join(self.extras)
return s
def __repr__(self):
return "EntryPoint.parse(%r)" % str(self)
def load(self, require=True, *args, **kwargs):
"""
Require packages for this EntryPoint, then resolve it.
"""
if not require or args or kwargs:
warnings.warn(
"Parameters to load are deprecated. Call .resolve and "
".require separately.",
DeprecationWarning,
stacklevel=2,
)
if require:
self.require(*args, **kwargs)
return self.resolve()
def resolve(self):
"""
Resolve the entry point from its module and attrs.
"""
module = __import__(self.module_name, fromlist=['__name__'], level=0)
try:
return functools.reduce(getattr, self.attrs, module)
except AttributeError as exc:
raise ImportError(str(exc))
def require(self, env=None, installer=None):
if self.extras and not self.dist:
raise UnknownExtra("Can't require() without a distribution", self)
reqs = self.dist.requires(self.extras)
items = working_set.resolve(reqs, env, installer)
list(map(working_set.add, items))
pattern = re.compile(
r'\s*'
r'(?P.+?)\s*'
r'=\s*'
r'(?P[\w.]+)\s*'
r'(:\s*(?P[\w.]+))?\s*'
r'(?P\[.*\])?\s*$'
)
@classmethod
def parse(cls, src, dist=None):
"""Parse a single entry point from string `src`
Entry point syntax follows the form::
name = some.module:some.attr [extra1, extra2]
The entry name and module name are required, but the ``:attrs`` and
``[extras]`` parts are optional
"""
m = cls.pattern.match(src)
if not m:
msg = "EntryPoint must be in 'name=module:attrs [extras]' format"
raise ValueError(msg, src)
res = m.groupdict()
extras = cls._parse_extras(res['extras'])
attrs = res['attr'].split('.') if res['attr'] else ()
return cls(res['name'], res['module'], attrs, extras, dist)
@classmethod
def _parse_extras(cls, extras_spec):
if not extras_spec:
return ()
req = Requirement.parse('x' + extras_spec)
if req.specs:
raise ValueError()
return req.extras
@classmethod
def parse_group(cls, group, lines, dist=None):
"""Parse an entry point group"""
if not MODULE(group):
raise ValueError("Invalid group name", group)
this = {}
for line in yield_lines(lines):
ep = cls.parse(line, dist)
if ep.name in this:
raise ValueError("Duplicate entry point", group, ep.name)
this[ep.name]=ep
return this
@classmethod
def parse_map(cls, data, dist=None):
"""Parse a map of entry point groups"""
if isinstance(data, dict):
data = data.items()
else:
data = split_sections(data)
maps = {}
for group, lines in data:
if group is None:
if not lines:
continue
raise ValueError("Entry points must be listed in groups")
group = group.strip()
if group in maps:
raise ValueError("Duplicate group name", group)
maps[group] = cls.parse_group(group, lines, dist)
return maps
def _remove_md5_fragment(location):
if not location:
return ''
parsed = urllib.parse.urlparse(location)
if parsed[-1].startswith('md5='):
return urllib.parse.urlunparse(parsed[:-1] + ('',))
return location
def _version_from_file(lines):
"""
Given an iterable of lines from a Metadata file, return
the value of the Version field, if present, or None otherwise.
"""
is_version_line = lambda line: line.lower().startswith('version:')
version_lines = filter(is_version_line, lines)
line = next(iter(version_lines), '')
_, _, value = line.partition(':')
return safe_version(value.strip()) or None
class Distribution(object):
"""Wrap an actual or potential sys.path entry w/metadata"""
PKG_INFO = 'PKG-INFO'
def __init__(self, location=None, metadata=None, project_name=None,
version=None, py_version=PY_MAJOR, platform=None,
precedence=EGG_DIST):
self.project_name = safe_name(project_name or 'Unknown')
if version is not None:
self._version = safe_version(version)
self.py_version = py_version
self.platform = platform
self.location = location
self.precedence = precedence
self._provider = metadata or empty_provider
@classmethod
def from_location(cls, location, basename, metadata=None, **kw):
project_name, version, py_version, platform = [None]*4
basename, ext = os.path.splitext(basename)
if ext.lower() in _distributionImpl:
cls = _distributionImpl[ext.lower()]
match = EGG_NAME(basename)
if match:
project_name, version, py_version, platform = match.group(
'name', 'ver', 'pyver', 'plat'
)
return cls(
location, metadata, project_name=project_name, version=version,
py_version=py_version, platform=platform, **kw
)._reload_version()
def _reload_version(self):
return self
@property
def hashcmp(self):
return (
self.parsed_version,
self.precedence,
self.key,
_remove_md5_fragment(self.location),
self.py_version or '',
self.platform or '',
)
def __hash__(self):
return hash(self.hashcmp)
def __lt__(self, other):
return self.hashcmp < other.hashcmp
def __le__(self, other):
return self.hashcmp <= other.hashcmp
def __gt__(self, other):
return self.hashcmp > other.hashcmp
def __ge__(self, other):
return self.hashcmp >= other.hashcmp
def __eq__(self, other):
if not isinstance(other, self.__class__):
# It's not a Distribution, so they are not equal
return False
return self.hashcmp == other.hashcmp
def __ne__(self, other):
return not self == other
# These properties have to be lazy so that we don't have to load any
# metadata until/unless it's actually needed. (i.e., some distributions
# may not know their name or version without loading PKG-INFO)
@property
def key(self):
try:
return self._key
except AttributeError:
self._key = key = self.project_name.lower()
return key
@property
def parsed_version(self):
if not hasattr(self, "_parsed_version"):
self._parsed_version = parse_version(self.version)
return self._parsed_version
def _warn_legacy_version(self):
LV = packaging.version.LegacyVersion
is_legacy = isinstance(self._parsed_version, LV)
if not is_legacy:
return
# While an empty version is technically a legacy version and
# is not a valid PEP 440 version, it's also unlikely to
# actually come from someone and instead it is more likely that
# it comes from setuptools attempting to parse a filename and
# including it in the list. So for that we'll gate this warning
# on if the version is anything at all or not.
if not self.version:
return
tmpl = textwrap.dedent("""
'{project_name} ({version})' is being parsed as a legacy,
non PEP 440,
version. You may find odd behavior and sort order.
In particular it will be sorted as less than 0.0. It
is recommended to migrate to PEP 440 compatible
versions.
""").strip().replace('\n', ' ')
warnings.warn(tmpl.format(**vars(self)), PEP440Warning)
@property
def version(self):
try:
return self._version
except AttributeError:
version = _version_from_file(self._get_metadata(self.PKG_INFO))
if version is None:
tmpl = "Missing 'Version:' header and/or %s file"
raise ValueError(tmpl % self.PKG_INFO, self)
return version
@property
def _dep_map(self):
try:
return self.__dep_map
except AttributeError:
dm = self.__dep_map = {None: []}
for name in 'requires.txt', 'depends.txt':
for extra, reqs in split_sections(self._get_metadata(name)):
if extra:
if ':' in extra:
extra, marker = extra.split(':', 1)
if invalid_marker(marker):
# XXX warn
reqs=[]
elif not evaluate_marker(marker):
reqs=[]
extra = safe_extra(extra) or None
dm.setdefault(extra,[]).extend(parse_requirements(reqs))
return dm
def requires(self, extras=()):
"""List of Requirements needed for this distro if `extras` are used"""
dm = self._dep_map
deps = []
deps.extend(dm.get(None, ()))
for ext in extras:
try:
deps.extend(dm[safe_extra(ext)])
except KeyError:
raise UnknownExtra(
"%s has no such extra feature %r" % (self, ext)
)
return deps
def _get_metadata(self, name):
if self.has_metadata(name):
for line in self.get_metadata_lines(name):
yield line
def activate(self, path=None):
"""Ensure distribution is importable on `path` (default=sys.path)"""
if path is None:
path = sys.path
self.insert_on(path, replace=True)
if path is sys.path:
fixup_namespace_packages(self.location)
for pkg in self._get_metadata('namespace_packages.txt'):
if pkg in sys.modules:
declare_namespace(pkg)
def egg_name(self):
"""Return what this distribution's standard .egg filename should be"""
filename = "%s-%s-py%s" % (
to_filename(self.project_name), to_filename(self.version),
self.py_version or PY_MAJOR
)
if self.platform:
filename += '-' + self.platform
return filename
def __repr__(self):
if self.location:
return "%s (%s)" % (self, self.location)
else:
return str(self)
def __str__(self):
try:
version = getattr(self, 'version', None)
except ValueError:
version = None
version = version or "[unknown version]"
return "%s %s" % (self.project_name, version)
def __getattr__(self, attr):
"""Delegate all unrecognized public attributes to .metadata provider"""
if attr.startswith('_'):
raise AttributeError(attr)
return getattr(self._provider, attr)
@classmethod
def from_filename(cls, filename, metadata=None, **kw):
return cls.from_location(
_normalize_cached(filename), os.path.basename(filename), metadata,
**kw
)
def as_requirement(self):
"""Return a ``Requirement`` that matches this distribution exactly"""
if isinstance(self.parsed_version, packaging.version.Version):
spec = "%s==%s" % (self.project_name, self.parsed_version)
else:
spec = "%s===%s" % (self.project_name, self.parsed_version)
return Requirement.parse(spec)
def load_entry_point(self, group, name):
"""Return the `name` entry point of `group` or raise ImportError"""
ep = self.get_entry_info(group, name)
if ep is None:
raise ImportError("Entry point %r not found" % ((group, name),))
return ep.load()
def get_entry_map(self, group=None):
"""Return the entry point map for `group`, or the full entry map"""
try:
ep_map = self._ep_map
except AttributeError:
ep_map = self._ep_map = EntryPoint.parse_map(
self._get_metadata('entry_points.txt'), self
)
if group is not None:
return ep_map.get(group,{})
return ep_map
def get_entry_info(self, group, name):
"""Return the EntryPoint object for `group`+`name`, or ``None``"""
return self.get_entry_map(group).get(name)
def insert_on(self, path, loc=None, replace=False):
"""Insert self.location in path before its nearest parent directory"""
loc = loc or self.location
if not loc:
return
nloc = _normalize_cached(loc)
bdir = os.path.dirname(nloc)
npath= [(p and _normalize_cached(p) or p) for p in path]
for p, item in enumerate(npath):
if item == nloc:
break
elif item == bdir and self.precedence == EGG_DIST:
# if it's an .egg, give it precedence over its directory
if path is sys.path:
self.check_version_conflict()
path.insert(p, loc)
npath.insert(p, nloc)
break
else:
if path is sys.path:
self.check_version_conflict()
if replace:
path.insert(0, loc)
else:
path.append(loc)
return
# p is the spot where we found or inserted loc; now remove duplicates
while True:
try:
np = npath.index(nloc, p+1)
except ValueError:
break
else:
del npath[np], path[np]
# ha!
p = np
return
def check_version_conflict(self):
if self.key == 'setuptools':
# ignore the inevitable setuptools self-conflicts :(
return
nsp = dict.fromkeys(self._get_metadata('namespace_packages.txt'))
loc = normalize_path(self.location)
for modname in self._get_metadata('top_level.txt'):
if (modname not in sys.modules or modname in nsp
or modname in _namespace_packages):
continue
if modname in ('pkg_resources', 'setuptools', 'site'):
continue
fn = getattr(sys.modules[modname], '__file__', None)
if fn and (normalize_path(fn).startswith(loc) or
fn.startswith(self.location)):
continue
issue_warning(
"Module %s was already imported from %s, but %s is being added"
" to sys.path" % (modname, fn, self.location),
)
def has_version(self):
try:
self.version
except ValueError:
issue_warning("Unbuilt egg for " + repr(self))
return False
return True
def clone(self,**kw):
"""Copy this distribution, substituting in any changed keyword args"""
names = 'project_name version py_version platform location precedence'
for attr in names.split():
kw.setdefault(attr, getattr(self, attr, None))
kw.setdefault('metadata', self._provider)
return self.__class__(**kw)
@property
def extras(self):
return [dep for dep in self._dep_map if dep]
class EggInfoDistribution(Distribution):
def _reload_version(self):
"""
Packages installed by distutils (e.g. numpy or scipy),
which uses an old safe_version, and so
their version numbers can get mangled when
converted to filenames (e.g., 1.11.0.dev0+2329eae to
1.11.0.dev0_2329eae). These distributions will not be
parsed properly
downstream by Distribution and safe_version, so
take an extra step and try to get the version number from
the metadata file itself instead of the filename.
"""
md_version = _version_from_file(self._get_metadata(self.PKG_INFO))
if md_version:
self._version = md_version
return self
class DistInfoDistribution(Distribution):
"""Wrap an actual or potential sys.path entry w/metadata, .dist-info style"""
PKG_INFO = 'METADATA'
EQEQ = re.compile(r"([\(,])\s*(\d.*?)\s*([,\)])")
@property
def _parsed_pkg_info(self):
"""Parse and cache metadata"""
try:
return self._pkg_info
except AttributeError:
metadata = self.get_metadata(self.PKG_INFO)
self._pkg_info = email.parser.Parser().parsestr(metadata)
return self._pkg_info
@property
def _dep_map(self):
try:
return self.__dep_map
except AttributeError:
self.__dep_map = self._compute_dependencies()
return self.__dep_map
def _compute_dependencies(self):
"""Recompute this distribution's dependencies."""
dm = self.__dep_map = {None: []}
reqs = []
# Including any condition expressions
for req in self._parsed_pkg_info.get_all('Requires-Dist') or []:
reqs.extend(parse_requirements(req))
def reqs_for_extra(extra):
for req in reqs:
if not req.marker or req.marker.evaluate({'extra': extra}):
yield req
common = frozenset(reqs_for_extra(None))
dm[None].extend(common)
for extra in self._parsed_pkg_info.get_all('Provides-Extra') or []:
extra = safe_extra(extra.strip())
dm[extra] = list(frozenset(reqs_for_extra(extra)) - common)
return dm
_distributionImpl = {
'.egg': Distribution,
'.egg-info': EggInfoDistribution,
'.dist-info': DistInfoDistribution,
}
def issue_warning(*args,**kw):
level = 1
g = globals()
try:
# find the first stack frame that is *not* code in
# the pkg_resources module, to use for the warning
while sys._getframe(level).f_globals is g:
level += 1
except ValueError:
pass
warnings.warn(stacklevel=level + 1, *args, **kw)
class RequirementParseError(ValueError):
def __str__(self):
return ' '.join(self.args)
def parse_requirements(strs):
"""Yield ``Requirement`` objects for each specification in `strs`
`strs` must be a string, or a (possibly-nested) iterable thereof.
"""
# create a steppable iterator, so we can handle \-continuations
lines = iter(yield_lines(strs))
for line in lines:
# Drop comments -- a hash without a space may be in a URL.
if ' #' in line:
line = line[:line.find(' #')]
# If there is a line continuation, drop it, and append the next line.
if line.endswith('\\'):
line = line[:-2].strip()
line += next(lines)
yield Requirement(line)
class Requirement(packaging.requirements.Requirement):
def __init__(self, requirement_string):
"""DO NOT CALL THIS UNDOCUMENTED METHOD; use Requirement.parse()!"""
try:
super(Requirement, self).__init__(requirement_string)
except packaging.requirements.InvalidRequirement as e:
raise RequirementParseError(str(e))
self.unsafe_name = self.name
project_name = safe_name(self.name)
self.project_name, self.key = project_name, project_name.lower()
self.specs = [
(spec.operator, spec.version) for spec in self.specifier]
self.extras = tuple(map(safe_extra, self.extras))
self.hashCmp = (
self.key,
self.specifier,
frozenset(self.extras),
str(self.marker) if self.marker else None,
)
self.__hash = hash(self.hashCmp)
def __eq__(self, other):
return (
isinstance(other, Requirement) and
self.hashCmp == other.hashCmp
)
def __ne__(self, other):
return not self == other
def __contains__(self, item):
if isinstance(item, Distribution):
if item.key != self.key:
return False
item = item.version
# Allow prereleases always in order to match the previous behavior of
# this method. In the future this should be smarter and follow PEP 440
# more accurately.
return self.specifier.contains(item, prereleases=True)
def __hash__(self):
return self.__hash
def __repr__(self): return "Requirement.parse(%r)" % str(self)
@staticmethod
def parse(s):
req, = parse_requirements(s)
return req
def _get_mro(cls):
"""Get an mro for a type or classic class"""
if not isinstance(cls, type):
class cls(cls, object): pass
return cls.__mro__[1:]
return cls.__mro__
def _find_adapter(registry, ob):
"""Return an adapter factory for `ob` from `registry`"""
for t in _get_mro(getattr(ob, '__class__', type(ob))):
if t in registry:
return registry[t]
def ensure_directory(path):
"""Ensure that the parent directory of `path` exists"""
dirname = os.path.dirname(path)
if not os.path.isdir(dirname):
os.makedirs(dirname)
def _bypass_ensure_directory(path):
"""Sandbox-bypassing version of ensure_directory()"""
if not WRITE_SUPPORT:
raise IOError('"os.mkdir" not supported on this platform.')
dirname, filename = split(path)
if dirname and filename and not isdir(dirname):
_bypass_ensure_directory(dirname)
mkdir(dirname, 0o755)
def split_sections(s):
"""Split a string or iterable thereof into (section, content) pairs
Each ``section`` is a stripped version of the section header ("[section]")
and each ``content`` is a list of stripped lines excluding blank lines and
comment-only lines. If there are any such lines before the first section
header, they're returned in a first ``section`` of ``None``.
"""
section = None
content = []
for line in yield_lines(s):
if line.startswith("["):
if line.endswith("]"):
if section or content:
yield section, content
section = line[1:-1].strip()
content = []
else:
raise ValueError("Invalid section heading", line)
else:
content.append(line)
# wrap up last segment
yield section, content
def _mkstemp(*args,**kw):
old_open = os.open
try:
# temporarily bypass sandboxing
os.open = os_open
return tempfile.mkstemp(*args,**kw)
finally:
# and then put it back
os.open = old_open
# Silence the PEP440Warning by default, so that end users don't get hit by it
# randomly just because they use pkg_resources. We want to append the rule
# because we want earlier uses of filterwarnings to take precedence over this
# one.
warnings.filterwarnings("ignore", category=PEP440Warning, append=True)
# from jaraco.functools 1.3
def _call_aside(f, *args, **kwargs):
f(*args, **kwargs)
return f
@_call_aside
def _initialize(g=globals()):
"Set up global resource manager (deliberately not state-saved)"
manager = ResourceManager()
g['_manager'] = manager
for name in dir(manager):
if not name.startswith('_'):
g[name] = getattr(manager, name)
@_call_aside
def _initialize_master_working_set():
"""
Prepare the master working set and make the ``require()``
API available.
This function has explicit effects on the global state
of pkg_resources. It is intended to be invoked once at
the initialization of this module.
Invocation by other packages is unsupported and done
at their own risk.
"""
working_set = WorkingSet._build_master()
_declare_state('object', working_set=working_set)
require = working_set.require
iter_entry_points = working_set.iter_entry_points
add_activation_listener = working_set.subscribe
run_script = working_set.run_script
# backward compatibility
run_main = run_script
# Activate all distributions already on sys.path, and ensure that
# all distributions added to the working set in the future (e.g. by
# calling ``require()``) will get activated as well.
add_activation_listener(lambda dist: dist.activate())
working_set.entries=[]
# match order
list(map(working_set.add_entry, sys.path))
globals().update(locals())
setuptools-20.7.0/pkg_resources/api_tests.txt 0000664 0001750 0001750 00000027663 12702524020 022304 0 ustar travis travis 0000000 0000000 Pluggable Distributions of Python Software
==========================================
Distributions
-------------
A "Distribution" is a collection of files that represent a "Release" of a
"Project" as of a particular point in time, denoted by a
"Version"::
>>> import sys, pkg_resources
>>> from pkg_resources import Distribution
>>> Distribution(project_name="Foo", version="1.2")
Foo 1.2
Distributions have a location, which can be a filename, URL, or really anything
else you care to use::
>>> dist = Distribution(
... location="http://example.com/something",
... project_name="Bar", version="0.9"
... )
>>> dist
Bar 0.9 (http://example.com/something)
Distributions have various introspectable attributes::
>>> dist.location
'http://example.com/something'
>>> dist.project_name
'Bar'
>>> dist.version
'0.9'
>>> dist.py_version == sys.version[:3]
True
>>> print(dist.platform)
None
Including various computed attributes::
>>> from pkg_resources import parse_version
>>> dist.parsed_version == parse_version(dist.version)
True
>>> dist.key # case-insensitive form of the project name
'bar'
Distributions are compared (and hashed) by version first::
>>> Distribution(version='1.0') == Distribution(version='1.0')
True
>>> Distribution(version='1.0') == Distribution(version='1.1')
False
>>> Distribution(version='1.0') < Distribution(version='1.1')
True
but also by project name (case-insensitive), platform, Python version,
location, etc.::
>>> Distribution(project_name="Foo",version="1.0") == \
... Distribution(project_name="Foo",version="1.0")
True
>>> Distribution(project_name="Foo",version="1.0") == \
... Distribution(project_name="foo",version="1.0")
True
>>> Distribution(project_name="Foo",version="1.0") == \
... Distribution(project_name="Foo",version="1.1")
False
>>> Distribution(project_name="Foo",py_version="2.3",version="1.0") == \
... Distribution(project_name="Foo",py_version="2.4",version="1.0")
False
>>> Distribution(location="spam",version="1.0") == \
... Distribution(location="spam",version="1.0")
True
>>> Distribution(location="spam",version="1.0") == \
... Distribution(location="baz",version="1.0")
False
Hash and compare distribution by prio/plat
Get version from metadata
provider capabilities
egg_name()
as_requirement()
from_location, from_filename (w/path normalization)
Releases may have zero or more "Requirements", which indicate
what releases of another project the release requires in order to
function. A Requirement names the other project, expresses some criteria
as to what releases of that project are acceptable, and lists any "Extras"
that the requiring release may need from that project. (An Extra is an
optional feature of a Release, that can only be used if its additional
Requirements are satisfied.)
The Working Set
---------------
A collection of active distributions is called a Working Set. Note that a
Working Set can contain any importable distribution, not just pluggable ones.
For example, the Python standard library is an importable distribution that
will usually be part of the Working Set, even though it is not pluggable.
Similarly, when you are doing development work on a project, the files you are
editing are also a Distribution. (And, with a little attention to the
directory names used, and including some additional metadata, such a
"development distribution" can be made pluggable as well.)
>>> from pkg_resources import WorkingSet
A working set's entries are the sys.path entries that correspond to the active
distributions. By default, the working set's entries are the items on
``sys.path``::
>>> ws = WorkingSet()
>>> ws.entries == sys.path
True
But you can also create an empty working set explicitly, and add distributions
to it::
>>> ws = WorkingSet([])
>>> ws.add(dist)
>>> ws.entries
['http://example.com/something']
>>> dist in ws
True
>>> Distribution('foo',version="") in ws
False
And you can iterate over its distributions::
>>> list(ws)
[Bar 0.9 (http://example.com/something)]
Adding the same distribution more than once is a no-op::
>>> ws.add(dist)
>>> list(ws)
[Bar 0.9 (http://example.com/something)]
For that matter, adding multiple distributions for the same project also does
nothing, because a working set can only hold one active distribution per
project -- the first one added to it::
>>> ws.add(
... Distribution(
... 'http://example.com/something', project_name="Bar",
... version="7.2"
... )
... )
>>> list(ws)
[Bar 0.9 (http://example.com/something)]
You can append a path entry to a working set using ``add_entry()``::
>>> ws.entries
['http://example.com/something']
>>> ws.add_entry(pkg_resources.__file__)
>>> ws.entries
['http://example.com/something', '...pkg_resources...']
Multiple additions result in multiple entries, even if the entry is already in
the working set (because ``sys.path`` can contain the same entry more than
once)::
>>> ws.add_entry(pkg_resources.__file__)
>>> ws.entries
['...example.com...', '...pkg_resources...', '...pkg_resources...']
And you can specify the path entry a distribution was found under, using the
optional second parameter to ``add()``::
>>> ws = WorkingSet([])
>>> ws.add(dist,"foo")
>>> ws.entries
['foo']
But even if a distribution is found under multiple path entries, it still only
shows up once when iterating the working set:
>>> ws.add_entry(ws.entries[0])
>>> list(ws)
[Bar 0.9 (http://example.com/something)]
You can ask a WorkingSet to ``find()`` a distribution matching a requirement::
>>> from pkg_resources import Requirement
>>> print(ws.find(Requirement.parse("Foo==1.0"))) # no match, return None
None
>>> ws.find(Requirement.parse("Bar==0.9")) # match, return distribution
Bar 0.9 (http://example.com/something)
Note that asking for a conflicting version of a distribution already in a
working set triggers a ``pkg_resources.VersionConflict`` error:
>>> try:
... ws.find(Requirement.parse("Bar==1.0"))
... except pkg_resources.VersionConflict as exc:
... print(str(exc))
... else:
... raise AssertionError("VersionConflict was not raised")
(Bar 0.9 (http://example.com/something), Requirement.parse('Bar==1.0'))
You can subscribe a callback function to receive notifications whenever a new
distribution is added to a working set. The callback is immediately invoked
once for each existing distribution in the working set, and then is called
again for new distributions added thereafter::
>>> def added(dist): print("Added %s" % dist)
>>> ws.subscribe(added)
Added Bar 0.9
>>> foo12 = Distribution(project_name="Foo", version="1.2", location="f12")
>>> ws.add(foo12)
Added Foo 1.2
Note, however, that only the first distribution added for a given project name
will trigger a callback, even during the initial ``subscribe()`` callback::
>>> foo14 = Distribution(project_name="Foo", version="1.4", location="f14")
>>> ws.add(foo14) # no callback, because Foo 1.2 is already active
>>> ws = WorkingSet([])
>>> ws.add(foo12)
>>> ws.add(foo14)
>>> ws.subscribe(added)
Added Foo 1.2
And adding a callback more than once has no effect, either::
>>> ws.subscribe(added) # no callbacks
# and no double-callbacks on subsequent additions, either
>>> just_a_test = Distribution(project_name="JustATest", version="0.99")
>>> ws.add(just_a_test)
Added JustATest 0.99
Finding Plugins
---------------
``WorkingSet`` objects can be used to figure out what plugins in an
``Environment`` can be loaded without any resolution errors::
>>> from pkg_resources import Environment
>>> plugins = Environment([]) # normally, a list of plugin directories
>>> plugins.add(foo12)
>>> plugins.add(foo14)
>>> plugins.add(just_a_test)
In the simplest case, we just get the newest version of each distribution in
the plugin environment::
>>> ws = WorkingSet([])
>>> ws.find_plugins(plugins)
([JustATest 0.99, Foo 1.4 (f14)], {})
But if there's a problem with a version conflict or missing requirements, the
method falls back to older versions, and the error info dict will contain an
exception instance for each unloadable plugin::
>>> ws.add(foo12) # this will conflict with Foo 1.4
>>> ws.find_plugins(plugins)
([JustATest 0.99, Foo 1.2 (f12)], {Foo 1.4 (f14): VersionConflict(...)})
But if you disallow fallbacks, the failed plugin will be skipped instead of
trying older versions::
>>> ws.find_plugins(plugins, fallback=False)
([JustATest 0.99], {Foo 1.4 (f14): VersionConflict(...)})
Platform Compatibility Rules
----------------------------
On the Mac, there are potential compatibility issues for modules compiled
on newer versions of Mac OS X than what the user is running. Additionally,
Mac OS X will soon have two platforms to contend with: Intel and PowerPC.
Basic equality works as on other platforms::
>>> from pkg_resources import compatible_platforms as cp
>>> reqd = 'macosx-10.4-ppc'
>>> cp(reqd, reqd)
True
>>> cp("win32", reqd)
False
Distributions made on other machine types are not compatible::
>>> cp("macosx-10.4-i386", reqd)
False
Distributions made on earlier versions of the OS are compatible, as
long as they are from the same top-level version. The patchlevel version
number does not matter::
>>> cp("macosx-10.4-ppc", reqd)
True
>>> cp("macosx-10.3-ppc", reqd)
True
>>> cp("macosx-10.5-ppc", reqd)
False
>>> cp("macosx-9.5-ppc", reqd)
False
Backwards compatibility for packages made via earlier versions of
setuptools is provided as well::
>>> cp("darwin-8.2.0-Power_Macintosh", reqd)
True
>>> cp("darwin-7.2.0-Power_Macintosh", reqd)
True
>>> cp("darwin-8.2.0-Power_Macintosh", "macosx-10.3-ppc")
False
Environment Markers
-------------------
>>> from pkg_resources import invalid_marker as im, evaluate_marker as em
>>> import os
>>> print(im("sys_platform"))
Invalid marker: 'sys_platform', parse error at ''
>>> print(im("sys_platform=="))
Invalid marker: 'sys_platform==', parse error at ''
>>> print(im("sys_platform=='win32'"))
False
>>> print(im("sys=='x'"))
Invalid marker: "sys=='x'", parse error at "sys=='x'"
>>> print(im("(extra)"))
Invalid marker: '(extra)', parse error at ')'
>>> print(im("(extra"))
Invalid marker: '(extra', parse error at ''
>>> print(im("os.open('foo')=='y'"))
Invalid marker: "os.open('foo')=='y'", parse error at 'os.open('
>>> print(im("'x'=='y' and os.open('foo')=='y'")) # no short-circuit!
Invalid marker: "'x'=='y' and os.open('foo')=='y'", parse error at 'and os.o'
>>> print(im("'x'=='x' or os.open('foo')=='y'")) # no short-circuit!
Invalid marker: "'x'=='x' or os.open('foo')=='y'", parse error at 'or os.op'
>>> print(im("'x' < 'y' < 'z'"))
Invalid marker: "'x' < 'y' < 'z'", parse error at "< 'z'"
>>> print(im("r'x'=='x'"))
Invalid marker: "r'x'=='x'", parse error at "r'x'=='x"
>>> print(im("'''x'''=='x'"))
Invalid marker: "'''x'''=='x'", parse error at "'x'''=='"
>>> print(im('"""x"""=="x"'))
Invalid marker: '"""x"""=="x"', parse error at '"x"""=="'
>>> print(im(r"x\n=='x'"))
Invalid marker: "x\\n=='x'", parse error at "x\\n=='x'"
>>> print(im("os.open=='y'"))
Invalid marker: "os.open=='y'", parse error at 'os.open='
>>> em("sys_platform=='win32'") == (sys.platform=='win32')
True
>>> em("python_version >= '2.6'")
True
>>> em("python_version > '2.5'")
True
>>> im("implementation_name=='cpython'")
False
>>> im("platform_python_implementation=='CPython'")
False
>>> im("implementation_version=='3.5.1'")
False
setuptools-20.7.0/setuptools/ 0000775 0001750 0001750 00000000000 12702524134 017106 5 ustar travis travis 0000000 0000000 setuptools-20.7.0/setuptools/command/ 0000775 0001750 0001750 00000000000 12702524134 020524 5 ustar travis travis 0000000 0000000 setuptools-20.7.0/setuptools/command/__init__.py 0000664 0001750 0001750 00000001064 12702524020 022630 0 ustar travis travis 0000000 0000000 __all__ = [
'alias', 'bdist_egg', 'bdist_rpm', 'build_ext', 'build_py', 'develop',
'easy_install', 'egg_info', 'install', 'install_lib', 'rotate', 'saveopts',
'sdist', 'setopt', 'test', 'install_egg_info', 'install_scripts',
'register', 'bdist_wininst', 'upload_docs', 'upload',
]
from distutils.command.bdist import bdist
import sys
from setuptools.command import install_scripts
if 'egg' not in bdist.format_commands:
bdist.format_command['egg'] = ('bdist_egg', "Python .egg file")
bdist.format_commands.append('egg')
del bdist, sys
setuptools-20.7.0/setuptools/command/alias.py 0000775 0001750 0001750 00000004572 12702524020 022174 0 ustar travis travis 0000000 0000000 from distutils.errors import DistutilsOptionError
from setuptools.extern.six.moves import map
from setuptools.command.setopt import edit_config, option_base, config_file
def shquote(arg):
"""Quote an argument for later parsing by shlex.split()"""
for c in '"', "'", "\\", "#":
if c in arg:
return repr(arg)
if arg.split() != [arg]:
return repr(arg)
return arg
class alias(option_base):
"""Define a shortcut that invokes one or more commands"""
description = "define a shortcut to invoke one or more commands"
command_consumes_arguments = True
user_options = [
('remove', 'r', 'remove (unset) the alias'),
] + option_base.user_options
boolean_options = option_base.boolean_options + ['remove']
def initialize_options(self):
option_base.initialize_options(self)
self.args = None
self.remove = None
def finalize_options(self):
option_base.finalize_options(self)
if self.remove and len(self.args) != 1:
raise DistutilsOptionError(
"Must specify exactly one argument (the alias name) when "
"using --remove"
)
def run(self):
aliases = self.distribution.get_option_dict('aliases')
if not self.args:
print("Command Aliases")
print("---------------")
for alias in aliases:
print("setup.py alias", format_alias(alias, aliases))
return
elif len(self.args) == 1:
alias, = self.args
if self.remove:
command = None
elif alias in aliases:
print("setup.py alias", format_alias(alias, aliases))
return
else:
print("No alias definition found for %r" % alias)
return
else:
alias = self.args[0]
command = ' '.join(map(shquote, self.args[1:]))
edit_config(self.filename, {'aliases': {alias: command}}, self.dry_run)
def format_alias(name, aliases):
source, command = aliases[name]
if source == config_file('global'):
source = '--global-config '
elif source == config_file('user'):
source = '--user-config '
elif source == config_file('local'):
source = ''
else:
source = '--filename=%r' % source
return source + name + ' ' + command
setuptools-20.7.0/setuptools/command/bdist_egg.py 0000664 0001750 0001750 00000041440 12702524020 023022 0 ustar travis travis 0000000 0000000 """setuptools.command.bdist_egg
Build .egg distributions"""
from distutils.errors import DistutilsSetupError
from distutils.dir_util import remove_tree, mkpath
from distutils import log
from types import CodeType
import sys
import os
import marshal
import textwrap
from setuptools.extern import six
from pkg_resources import get_build_platform, Distribution, ensure_directory
from pkg_resources import EntryPoint
from setuptools.extension import Library
from setuptools import Command
try:
# Python 2.7 or >=3.2
from sysconfig import get_path, get_python_version
def _get_purelib():
return get_path("purelib")
except ImportError:
from distutils.sysconfig import get_python_lib, get_python_version
def _get_purelib():
return get_python_lib(False)
def strip_module(filename):
if '.' in filename:
filename = os.path.splitext(filename)[0]
if filename.endswith('module'):
filename = filename[:-6]
return filename
def write_stub(resource, pyfile):
_stub_template = textwrap.dedent("""
def __bootstrap__():
global __bootstrap__, __loader__, __file__
import sys, pkg_resources, imp
__file__ = pkg_resources.resource_filename(__name__, %r)
__loader__ = None; del __bootstrap__, __loader__
imp.load_dynamic(__name__,__file__)
__bootstrap__()
""").lstrip()
with open(pyfile, 'w') as f:
f.write(_stub_template % resource)
class bdist_egg(Command):
description = "create an \"egg\" distribution"
user_options = [
('bdist-dir=', 'b',
"temporary directory for creating the distribution"),
('plat-name=', 'p', "platform name to embed in generated filenames "
"(default: %s)" % get_build_platform()),
('exclude-source-files', None,
"remove all .py files from the generated egg"),
('keep-temp', 'k',
"keep the pseudo-installation tree around after " +
"creating the distribution archive"),
('dist-dir=', 'd',
"directory to put final built distributions in"),
('skip-build', None,
"skip rebuilding everything (for testing/debugging)"),
]
boolean_options = [
'keep-temp', 'skip-build', 'exclude-source-files'
]
def initialize_options(self):
self.bdist_dir = None
self.plat_name = None
self.keep_temp = 0
self.dist_dir = None
self.skip_build = 0
self.egg_output = None
self.exclude_source_files = None
def finalize_options(self):
ei_cmd = self.ei_cmd = self.get_finalized_command("egg_info")
self.egg_info = ei_cmd.egg_info
if self.bdist_dir is None:
bdist_base = self.get_finalized_command('bdist').bdist_base
self.bdist_dir = os.path.join(bdist_base, 'egg')
if self.plat_name is None:
self.plat_name = get_build_platform()
self.set_undefined_options('bdist', ('dist_dir', 'dist_dir'))
if self.egg_output is None:
# Compute filename of the output egg
basename = Distribution(
None, None, ei_cmd.egg_name, ei_cmd.egg_version,
get_python_version(),
self.distribution.has_ext_modules() and self.plat_name
).egg_name()
self.egg_output = os.path.join(self.dist_dir, basename + '.egg')
def do_install_data(self):
# Hack for packages that install data to install's --install-lib
self.get_finalized_command('install').install_lib = self.bdist_dir
site_packages = os.path.normcase(os.path.realpath(_get_purelib()))
old, self.distribution.data_files = self.distribution.data_files, []
for item in old:
if isinstance(item, tuple) and len(item) == 2:
if os.path.isabs(item[0]):
realpath = os.path.realpath(item[0])
normalized = os.path.normcase(realpath)
if normalized == site_packages or normalized.startswith(
site_packages + os.sep
):
item = realpath[len(site_packages) + 1:], item[1]
# XXX else: raise ???
self.distribution.data_files.append(item)
try:
log.info("installing package data to %s" % self.bdist_dir)
self.call_command('install_data', force=0, root=None)
finally:
self.distribution.data_files = old
def get_outputs(self):
return [self.egg_output]
def call_command(self, cmdname, **kw):
"""Invoke reinitialized command `cmdname` with keyword args"""
for dirname in INSTALL_DIRECTORY_ATTRS:
kw.setdefault(dirname, self.bdist_dir)
kw.setdefault('skip_build', self.skip_build)
kw.setdefault('dry_run', self.dry_run)
cmd = self.reinitialize_command(cmdname, **kw)
self.run_command(cmdname)
return cmd
def run(self):
# Generate metadata first
self.run_command("egg_info")
# We run install_lib before install_data, because some data hacks
# pull their data path from the install_lib command.
log.info("installing library code to %s" % self.bdist_dir)
instcmd = self.get_finalized_command('install')
old_root = instcmd.root
instcmd.root = None
if self.distribution.has_c_libraries() and not self.skip_build:
self.run_command('build_clib')
cmd = self.call_command('install_lib', warn_dir=0)
instcmd.root = old_root
all_outputs, ext_outputs = self.get_ext_outputs()
self.stubs = []
to_compile = []
for (p, ext_name) in enumerate(ext_outputs):
filename, ext = os.path.splitext(ext_name)
pyfile = os.path.join(self.bdist_dir, strip_module(filename) +
'.py')
self.stubs.append(pyfile)
log.info("creating stub loader for %s" % ext_name)
if not self.dry_run:
write_stub(os.path.basename(ext_name), pyfile)
to_compile.append(pyfile)
ext_outputs[p] = ext_name.replace(os.sep, '/')
if to_compile:
cmd.byte_compile(to_compile)
if self.distribution.data_files:
self.do_install_data()
# Make the EGG-INFO directory
archive_root = self.bdist_dir
egg_info = os.path.join(archive_root, 'EGG-INFO')
self.mkpath(egg_info)
if self.distribution.scripts:
script_dir = os.path.join(egg_info, 'scripts')
log.info("installing scripts to %s" % script_dir)
self.call_command('install_scripts', install_dir=script_dir,
no_ep=1)
self.copy_metadata_to(egg_info)
native_libs = os.path.join(egg_info, "native_libs.txt")
if all_outputs:
log.info("writing %s" % native_libs)
if not self.dry_run:
ensure_directory(native_libs)
libs_file = open(native_libs, 'wt')
libs_file.write('\n'.join(all_outputs))
libs_file.write('\n')
libs_file.close()
elif os.path.isfile(native_libs):
log.info("removing %s" % native_libs)
if not self.dry_run:
os.unlink(native_libs)
write_safety_flag(
os.path.join(archive_root, 'EGG-INFO'), self.zip_safe()
)
if os.path.exists(os.path.join(self.egg_info, 'depends.txt')):
log.warn(
"WARNING: 'depends.txt' will not be used by setuptools 0.6!\n"
"Use the install_requires/extras_require setup() args instead."
)
if self.exclude_source_files:
self.zap_pyfiles()
# Make the archive
make_zipfile(self.egg_output, archive_root, verbose=self.verbose,
dry_run=self.dry_run, mode=self.gen_header())
if not self.keep_temp:
remove_tree(self.bdist_dir, dry_run=self.dry_run)
# Add to 'Distribution.dist_files' so that the "upload" command works
getattr(self.distribution, 'dist_files', []).append(
('bdist_egg', get_python_version(), self.egg_output))
def zap_pyfiles(self):
log.info("Removing .py files from temporary directory")
for base, dirs, files in walk_egg(self.bdist_dir):
for name in files:
if name.endswith('.py'):
path = os.path.join(base, name)
log.debug("Deleting %s", path)
os.unlink(path)
def zip_safe(self):
safe = getattr(self.distribution, 'zip_safe', None)
if safe is not None:
return safe
log.warn("zip_safe flag not set; analyzing archive contents...")
return analyze_egg(self.bdist_dir, self.stubs)
def gen_header(self):
epm = EntryPoint.parse_map(self.distribution.entry_points or '')
ep = epm.get('setuptools.installation', {}).get('eggsecutable')
if ep is None:
return 'w' # not an eggsecutable, do it the usual way.
if not ep.attrs or ep.extras:
raise DistutilsSetupError(
"eggsecutable entry point (%r) cannot have 'extras' "
"or refer to a module" % (ep,)
)
pyver = sys.version[:3]
pkg = ep.module_name
full = '.'.join(ep.attrs)
base = ep.attrs[0]
basename = os.path.basename(self.egg_output)
header = (
"#!/bin/sh\n"
'if [ `basename $0` = "%(basename)s" ]\n'
'then exec python%(pyver)s -c "'
"import sys, os; sys.path.insert(0, os.path.abspath('$0')); "
"from %(pkg)s import %(base)s; sys.exit(%(full)s())"
'" "$@"\n'
'else\n'
' echo $0 is not the correct name for this egg file.\n'
' echo Please rename it back to %(basename)s and try again.\n'
' exec false\n'
'fi\n'
) % locals()
if not self.dry_run:
mkpath(os.path.dirname(self.egg_output), dry_run=self.dry_run)
f = open(self.egg_output, 'w')
f.write(header)
f.close()
return 'a'
def copy_metadata_to(self, target_dir):
"Copy metadata (egg info) to the target_dir"
# normalize the path (so that a forward-slash in egg_info will
# match using startswith below)
norm_egg_info = os.path.normpath(self.egg_info)
prefix = os.path.join(norm_egg_info, '')
for path in self.ei_cmd.filelist.files:
if path.startswith(prefix):
target = os.path.join(target_dir, path[len(prefix):])
ensure_directory(target)
self.copy_file(path, target)
def get_ext_outputs(self):
"""Get a list of relative paths to C extensions in the output distro"""
all_outputs = []
ext_outputs = []
paths = {self.bdist_dir: ''}
for base, dirs, files in os.walk(self.bdist_dir):
for filename in files:
if os.path.splitext(filename)[1].lower() in NATIVE_EXTENSIONS:
all_outputs.append(paths[base] + filename)
for filename in dirs:
paths[os.path.join(base, filename)] = (paths[base] +
filename + '/')
if self.distribution.has_ext_modules():
build_cmd = self.get_finalized_command('build_ext')
for ext in build_cmd.extensions:
if isinstance(ext, Library):
continue
fullname = build_cmd.get_ext_fullname(ext.name)
filename = build_cmd.get_ext_filename(fullname)
if not os.path.basename(filename).startswith('dl-'):
if os.path.exists(os.path.join(self.bdist_dir, filename)):
ext_outputs.append(filename)
return all_outputs, ext_outputs
NATIVE_EXTENSIONS = dict.fromkeys('.dll .so .dylib .pyd'.split())
def walk_egg(egg_dir):
"""Walk an unpacked egg's contents, skipping the metadata directory"""
walker = os.walk(egg_dir)
base, dirs, files = next(walker)
if 'EGG-INFO' in dirs:
dirs.remove('EGG-INFO')
yield base, dirs, files
for bdf in walker:
yield bdf
def analyze_egg(egg_dir, stubs):
# check for existing flag in EGG-INFO
for flag, fn in safety_flags.items():
if os.path.exists(os.path.join(egg_dir, 'EGG-INFO', fn)):
return flag
if not can_scan():
return False
safe = True
for base, dirs, files in walk_egg(egg_dir):
for name in files:
if name.endswith('.py') or name.endswith('.pyw'):
continue
elif name.endswith('.pyc') or name.endswith('.pyo'):
# always scan, even if we already know we're not safe
safe = scan_module(egg_dir, base, name, stubs) and safe
return safe
def write_safety_flag(egg_dir, safe):
# Write or remove zip safety flag file(s)
for flag, fn in safety_flags.items():
fn = os.path.join(egg_dir, fn)
if os.path.exists(fn):
if safe is None or bool(safe) != flag:
os.unlink(fn)
elif safe is not None and bool(safe) == flag:
f = open(fn, 'wt')
f.write('\n')
f.close()
safety_flags = {
True: 'zip-safe',
False: 'not-zip-safe',
}
def scan_module(egg_dir, base, name, stubs):
"""Check whether module possibly uses unsafe-for-zipfile stuff"""
filename = os.path.join(base, name)
if filename[:-1] in stubs:
return True # Extension module
pkg = base[len(egg_dir) + 1:].replace(os.sep, '.')
module = pkg + (pkg and '.' or '') + os.path.splitext(name)[0]
if sys.version_info < (3, 3):
skip = 8 # skip magic & date
else:
skip = 12 # skip magic & date & file size
f = open(filename, 'rb')
f.read(skip)
code = marshal.load(f)
f.close()
safe = True
symbols = dict.fromkeys(iter_symbols(code))
for bad in ['__file__', '__path__']:
if bad in symbols:
log.warn("%s: module references %s", module, bad)
safe = False
if 'inspect' in symbols:
for bad in [
'getsource', 'getabsfile', 'getsourcefile', 'getfile'
'getsourcelines', 'findsource', 'getcomments', 'getframeinfo',
'getinnerframes', 'getouterframes', 'stack', 'trace'
]:
if bad in symbols:
log.warn("%s: module MAY be using inspect.%s", module, bad)
safe = False
return safe
def iter_symbols(code):
"""Yield names and strings used by `code` and its nested code objects"""
for name in code.co_names:
yield name
for const in code.co_consts:
if isinstance(const, six.string_types):
yield const
elif isinstance(const, CodeType):
for name in iter_symbols(const):
yield name
def can_scan():
if not sys.platform.startswith('java') and sys.platform != 'cli':
# CPython, PyPy, etc.
return True
log.warn("Unable to analyze compiled code on this platform.")
log.warn("Please ask the author to include a 'zip_safe'"
" setting (either True or False) in the package's setup.py")
# Attribute names of options for commands that might need to be convinced to
# install to the egg build directory
INSTALL_DIRECTORY_ATTRS = [
'install_lib', 'install_dir', 'install_data', 'install_base'
]
def make_zipfile(zip_filename, base_dir, verbose=0, dry_run=0, compress=True,
mode='w'):
"""Create a zip file from all the files under 'base_dir'. The output
zip file will be named 'base_dir' + ".zip". Uses either the "zipfile"
Python module (if available) or the InfoZIP "zip" utility (if installed
and found on the default search path). If neither tool is available,
raises DistutilsExecError. Returns the name of the output zip file.
"""
import zipfile
mkpath(os.path.dirname(zip_filename), dry_run=dry_run)
log.info("creating '%s' and adding '%s' to it", zip_filename, base_dir)
def visit(z, dirname, names):
for name in names:
path = os.path.normpath(os.path.join(dirname, name))
if os.path.isfile(path):
p = path[len(base_dir) + 1:]
if not dry_run:
z.write(path, p)
log.debug("adding '%s'" % p)
compression = zipfile.ZIP_DEFLATED if compress else zipfile.ZIP_STORED
if not dry_run:
z = zipfile.ZipFile(zip_filename, mode, compression=compression)
for dirname, dirs, files in os.walk(base_dir):
visit(z, dirname, files)
z.close()
else:
for dirname, dirs, files in os.walk(base_dir):
visit(None, dirname, files)
return zip_filename
setuptools-20.7.0/setuptools/command/bdist_rpm.py 0000775 0001750 0001750 00000002744 12702524020 023065 0 ustar travis travis 0000000 0000000 import distutils.command.bdist_rpm as orig
class bdist_rpm(orig.bdist_rpm):
"""
Override the default bdist_rpm behavior to do the following:
1. Run egg_info to ensure the name and version are properly calculated.
2. Always run 'install' using --single-version-externally-managed to
disable eggs in RPM distributions.
3. Replace dash with underscore in the version numbers for better RPM
compatibility.
"""
def run(self):
# ensure distro name is up-to-date
self.run_command('egg_info')
orig.bdist_rpm.run(self)
def _make_spec_file(self):
version = self.distribution.get_version()
rpmversion = version.replace('-', '_')
spec = orig.bdist_rpm._make_spec_file(self)
line23 = '%define version ' + version
line24 = '%define version ' + rpmversion
spec = [
line.replace(
"Source0: %{name}-%{version}.tar",
"Source0: %{name}-%{unmangled_version}.tar"
).replace(
"setup.py install ",
"setup.py install --single-version-externally-managed "
).replace(
"%setup",
"%setup -n %{name}-%{unmangled_version}"
).replace(line23, line24)
for line in spec
]
insert_loc = spec.index(line24) + 1
unmangled_version = "%define unmangled_version " + version
spec.insert(insert_loc, unmangled_version)
return spec
setuptools-20.7.0/setuptools/command/bdist_wininst.py 0000775 0001750 0001750 00000001175 12702524020 023757 0 ustar travis travis 0000000 0000000 import distutils.command.bdist_wininst as orig
class bdist_wininst(orig.bdist_wininst):
def reinitialize_command(self, command, reinit_subcommands=0):
"""
Supplement reinitialize_command to work around
http://bugs.python.org/issue20819
"""
cmd = self.distribution.reinitialize_command(
command, reinit_subcommands)
if command in ('install', 'install_lib'):
cmd.install_lib = None
return cmd
def run(self):
self._is_running = True
try:
orig.bdist_wininst.run(self)
finally:
self._is_running = False
setuptools-20.7.0/setuptools/command/build_ext.py 0000664 0001750 0001750 00000027274 12702524020 023063 0 ustar travis travis 0000000 0000000 from distutils.command.build_ext import build_ext as _du_build_ext
from distutils.file_util import copy_file
from distutils.ccompiler import new_compiler
from distutils.sysconfig import customize_compiler
from distutils.errors import DistutilsError
from distutils import log
import os
import sys
import itertools
from setuptools.extension import Library
try:
# Attempt to use Cython for building extensions, if available
from Cython.Distutils.build_ext import build_ext as _build_ext
except ImportError:
_build_ext = _du_build_ext
try:
# Python 2.7 or >=3.2
from sysconfig import _CONFIG_VARS
except ImportError:
from distutils.sysconfig import get_config_var
get_config_var("LDSHARED") # make sure _config_vars is initialized
del get_config_var
from distutils.sysconfig import _config_vars as _CONFIG_VARS
have_rtld = False
use_stubs = False
libtype = 'shared'
if sys.platform == "darwin":
use_stubs = True
elif os.name != 'nt':
try:
import dl
use_stubs = have_rtld = hasattr(dl, 'RTLD_NOW')
except ImportError:
pass
if_dl = lambda s: s if have_rtld else ''
class build_ext(_build_ext):
def run(self):
"""Build extensions in build directory, then copy if --inplace"""
old_inplace, self.inplace = self.inplace, 0
_build_ext.run(self)
self.inplace = old_inplace
if old_inplace:
self.copy_extensions_to_source()
def copy_extensions_to_source(self):
build_py = self.get_finalized_command('build_py')
for ext in self.extensions:
fullname = self.get_ext_fullname(ext.name)
filename = self.get_ext_filename(fullname)
modpath = fullname.split('.')
package = '.'.join(modpath[:-1])
package_dir = build_py.get_package_dir(package)
dest_filename = os.path.join(package_dir,
os.path.basename(filename))
src_filename = os.path.join(self.build_lib, filename)
# Always copy, even if source is older than destination, to ensure
# that the right extensions for the current Python/platform are
# used.
copy_file(
src_filename, dest_filename, verbose=self.verbose,
dry_run=self.dry_run
)
if ext._needs_stub:
self.write_stub(package_dir or os.curdir, ext, True)
def get_ext_filename(self, fullname):
filename = _build_ext.get_ext_filename(self, fullname)
if fullname in self.ext_map:
ext = self.ext_map[fullname]
if isinstance(ext, Library):
fn, ext = os.path.splitext(filename)
return self.shlib_compiler.library_filename(fn, libtype)
elif use_stubs and ext._links_to_dynamic:
d, fn = os.path.split(filename)
return os.path.join(d, 'dl-' + fn)
return filename
def initialize_options(self):
_build_ext.initialize_options(self)
self.shlib_compiler = None
self.shlibs = []
self.ext_map = {}
def finalize_options(self):
_build_ext.finalize_options(self)
self.extensions = self.extensions or []
self.check_extensions_list(self.extensions)
self.shlibs = [ext for ext in self.extensions
if isinstance(ext, Library)]
if self.shlibs:
self.setup_shlib_compiler()
for ext in self.extensions:
ext._full_name = self.get_ext_fullname(ext.name)
for ext in self.extensions:
fullname = ext._full_name
self.ext_map[fullname] = ext
# distutils 3.1 will also ask for module names
# XXX what to do with conflicts?
self.ext_map[fullname.split('.')[-1]] = ext
ltd = self.shlibs and self.links_to_dynamic(ext) or False
ns = ltd and use_stubs and not isinstance(ext, Library)
ext._links_to_dynamic = ltd
ext._needs_stub = ns
filename = ext._file_name = self.get_ext_filename(fullname)
libdir = os.path.dirname(os.path.join(self.build_lib, filename))
if ltd and libdir not in ext.library_dirs:
ext.library_dirs.append(libdir)
if ltd and use_stubs and os.curdir not in ext.runtime_library_dirs:
ext.runtime_library_dirs.append(os.curdir)
def setup_shlib_compiler(self):
compiler = self.shlib_compiler = new_compiler(
compiler=self.compiler, dry_run=self.dry_run, force=self.force
)
if sys.platform == "darwin":
tmp = _CONFIG_VARS.copy()
try:
# XXX Help! I don't have any idea whether these are right...
_CONFIG_VARS['LDSHARED'] = (
"gcc -Wl,-x -dynamiclib -undefined dynamic_lookup")
_CONFIG_VARS['CCSHARED'] = " -dynamiclib"
_CONFIG_VARS['SO'] = ".dylib"
customize_compiler(compiler)
finally:
_CONFIG_VARS.clear()
_CONFIG_VARS.update(tmp)
else:
customize_compiler(compiler)
if self.include_dirs is not None:
compiler.set_include_dirs(self.include_dirs)
if self.define is not None:
# 'define' option is a list of (name,value) tuples
for (name, value) in self.define:
compiler.define_macro(name, value)
if self.undef is not None:
for macro in self.undef:
compiler.undefine_macro(macro)
if self.libraries is not None:
compiler.set_libraries(self.libraries)
if self.library_dirs is not None:
compiler.set_library_dirs(self.library_dirs)
if self.rpath is not None:
compiler.set_runtime_library_dirs(self.rpath)
if self.link_objects is not None:
compiler.set_link_objects(self.link_objects)
# hack so distutils' build_extension() builds a library instead
compiler.link_shared_object = link_shared_object.__get__(compiler)
def get_export_symbols(self, ext):
if isinstance(ext, Library):
return ext.export_symbols
return _build_ext.get_export_symbols(self, ext)
def build_extension(self, ext):
ext._convert_pyx_sources_to_lang()
_compiler = self.compiler
try:
if isinstance(ext, Library):
self.compiler = self.shlib_compiler
_build_ext.build_extension(self, ext)
if ext._needs_stub:
cmd = self.get_finalized_command('build_py').build_lib
self.write_stub(cmd, ext)
finally:
self.compiler = _compiler
def links_to_dynamic(self, ext):
"""Return true if 'ext' links to a dynamic lib in the same package"""
# XXX this should check to ensure the lib is actually being built
# XXX as dynamic, and not just using a locally-found version or a
# XXX static-compiled version
libnames = dict.fromkeys([lib._full_name for lib in self.shlibs])
pkg = '.'.join(ext._full_name.split('.')[:-1] + [''])
return any(pkg + libname in libnames for libname in ext.libraries)
def get_outputs(self):
return _build_ext.get_outputs(self) + self.__get_stubs_outputs()
def __get_stubs_outputs(self):
# assemble the base name for each extension that needs a stub
ns_ext_bases = (
os.path.join(self.build_lib, *ext._full_name.split('.'))
for ext in self.extensions
if ext._needs_stub
)
# pair each base with the extension
pairs = itertools.product(ns_ext_bases, self.__get_output_extensions())
return list(base + fnext for base, fnext in pairs)
def __get_output_extensions(self):
yield '.py'
yield '.pyc'
if self.get_finalized_command('build_py').optimize:
yield '.pyo'
def write_stub(self, output_dir, ext, compile=False):
log.info("writing stub loader for %s to %s", ext._full_name,
output_dir)
stub_file = (os.path.join(output_dir, *ext._full_name.split('.')) +
'.py')
if compile and os.path.exists(stub_file):
raise DistutilsError(stub_file + " already exists! Please delete.")
if not self.dry_run:
f = open(stub_file, 'w')
f.write(
'\n'.join([
"def __bootstrap__():",
" global __bootstrap__, __file__, __loader__",
" import sys, os, pkg_resources, imp" + if_dl(", dl"),
" __file__ = pkg_resources.resource_filename"
"(__name__,%r)"
% os.path.basename(ext._file_name),
" del __bootstrap__",
" if '__loader__' in globals():",
" del __loader__",
if_dl(" old_flags = sys.getdlopenflags()"),
" old_dir = os.getcwd()",
" try:",
" os.chdir(os.path.dirname(__file__))",
if_dl(" sys.setdlopenflags(dl.RTLD_NOW)"),
" imp.load_dynamic(__name__,__file__)",
" finally:",
if_dl(" sys.setdlopenflags(old_flags)"),
" os.chdir(old_dir)",
"__bootstrap__()",
"" # terminal \n
])
)
f.close()
if compile:
from distutils.util import byte_compile
byte_compile([stub_file], optimize=0,
force=True, dry_run=self.dry_run)
optimize = self.get_finalized_command('install_lib').optimize
if optimize > 0:
byte_compile([stub_file], optimize=optimize,
force=True, dry_run=self.dry_run)
if os.path.exists(stub_file) and not self.dry_run:
os.unlink(stub_file)
if use_stubs or os.name == 'nt':
# Build shared libraries
#
def link_shared_object(
self, objects, output_libname, output_dir=None, libraries=None,
library_dirs=None, runtime_library_dirs=None, export_symbols=None,
debug=0, extra_preargs=None, extra_postargs=None, build_temp=None,
target_lang=None):
self.link(
self.SHARED_LIBRARY, objects, output_libname,
output_dir, libraries, library_dirs, runtime_library_dirs,
export_symbols, debug, extra_preargs, extra_postargs,
build_temp, target_lang
)
else:
# Build static libraries everywhere else
libtype = 'static'
def link_shared_object(
self, objects, output_libname, output_dir=None, libraries=None,
library_dirs=None, runtime_library_dirs=None, export_symbols=None,
debug=0, extra_preargs=None, extra_postargs=None, build_temp=None,
target_lang=None):
# XXX we need to either disallow these attrs on Library instances,
# or warn/abort here if set, or something...
# libraries=None, library_dirs=None, runtime_library_dirs=None,
# export_symbols=None, extra_preargs=None, extra_postargs=None,
# build_temp=None
assert output_dir is None # distutils build_ext doesn't pass this
output_dir, filename = os.path.split(output_libname)
basename, ext = os.path.splitext(filename)
if self.library_filename("x").startswith('lib'):
# strip 'lib' prefix; this is kludgy if some platform uses
# a different prefix
basename = basename[3:]
self.create_static_lib(
objects, basename, output_dir, debug, target_lang
)
setuptools-20.7.0/setuptools/command/build_py.py 0000664 0001750 0001750 00000017457 12702524020 022715 0 ustar travis travis 0000000 0000000 from glob import glob
from distutils.util import convert_path
import distutils.command.build_py as orig
import os
import fnmatch
import textwrap
import io
import distutils.errors
import collections
import itertools
from setuptools.extern.six.moves import map
try:
from setuptools.lib2to3_ex import Mixin2to3
except ImportError:
class Mixin2to3:
def run_2to3(self, files, doctests=True):
"do nothing"
class build_py(orig.build_py, Mixin2to3):
"""Enhanced 'build_py' command that includes data files with packages
The data files are specified via a 'package_data' argument to 'setup()'.
See 'setuptools.dist.Distribution' for more details.
Also, this version of the 'build_py' command allows you to specify both
'py_modules' and 'packages' in the same setup operation.
"""
def finalize_options(self):
orig.build_py.finalize_options(self)
self.package_data = self.distribution.package_data
self.exclude_package_data = (self.distribution.exclude_package_data or
{})
if 'data_files' in self.__dict__:
del self.__dict__['data_files']
self.__updated_files = []
self.__doctests_2to3 = []
def run(self):
"""Build modules, packages, and copy data files to build directory"""
if not self.py_modules and not self.packages:
return
if self.py_modules:
self.build_modules()
if self.packages:
self.build_packages()
self.build_package_data()
self.run_2to3(self.__updated_files, False)
self.run_2to3(self.__updated_files, True)
self.run_2to3(self.__doctests_2to3, True)
# Only compile actual .py files, using our base class' idea of what our
# output files are.
self.byte_compile(orig.build_py.get_outputs(self, include_bytecode=0))
def __getattr__(self, attr):
"lazily compute data files"
if attr == 'data_files':
self.data_files = self._get_data_files()
return self.data_files
return orig.build_py.__getattr__(self, attr)
def build_module(self, module, module_file, package):
outfile, copied = orig.build_py.build_module(self, module, module_file,
package)
if copied:
self.__updated_files.append(outfile)
return outfile, copied
def _get_data_files(self):
"""Generate list of '(package,src_dir,build_dir,filenames)' tuples"""
self.analyze_manifest()
return list(map(self._get_pkg_data_files, self.packages or ()))
def _get_pkg_data_files(self, package):
# Locate package source directory
src_dir = self.get_package_dir(package)
# Compute package build directory
build_dir = os.path.join(*([self.build_lib] + package.split('.')))
# Strip directory from globbed filenames
filenames = [
os.path.relpath(file, src_dir)
for file in self.find_data_files(package, src_dir)
]
return package, src_dir, build_dir, filenames
def find_data_files(self, package, src_dir):
"""Return filenames for package's data files in 'src_dir'"""
globs = (self.package_data.get('', [])
+ self.package_data.get(package, []))
files = self.manifest_files.get(package, [])[:]
for pattern in globs:
# Each pattern has to be converted to a platform-specific path
files.extend(glob(os.path.join(src_dir, convert_path(pattern))))
return self.exclude_data_files(package, src_dir, files)
def build_package_data(self):
"""Copy data files into build directory"""
for package, src_dir, build_dir, filenames in self.data_files:
for filename in filenames:
target = os.path.join(build_dir, filename)
self.mkpath(os.path.dirname(target))
srcfile = os.path.join(src_dir, filename)
outf, copied = self.copy_file(srcfile, target)
srcfile = os.path.abspath(srcfile)
if (copied and
srcfile in self.distribution.convert_2to3_doctests):
self.__doctests_2to3.append(outf)
def analyze_manifest(self):
self.manifest_files = mf = {}
if not self.distribution.include_package_data:
return
src_dirs = {}
for package in self.packages or ():
# Locate package source directory
src_dirs[assert_relative(self.get_package_dir(package))] = package
self.run_command('egg_info')
ei_cmd = self.get_finalized_command('egg_info')
for path in ei_cmd.filelist.files:
d, f = os.path.split(assert_relative(path))
prev = None
oldf = f
while d and d != prev and d not in src_dirs:
prev = d
d, df = os.path.split(d)
f = os.path.join(df, f)
if d in src_dirs:
if path.endswith('.py') and f == oldf:
continue # it's a module, not data
mf.setdefault(src_dirs[d], []).append(path)
def get_data_files(self):
pass # Lazily compute data files in _get_data_files() function.
def check_package(self, package, package_dir):
"""Check namespace packages' __init__ for declare_namespace"""
try:
return self.packages_checked[package]
except KeyError:
pass
init_py = orig.build_py.check_package(self, package, package_dir)
self.packages_checked[package] = init_py
if not init_py or not self.distribution.namespace_packages:
return init_py
for pkg in self.distribution.namespace_packages:
if pkg == package or pkg.startswith(package + '.'):
break
else:
return init_py
with io.open(init_py, 'rb') as f:
contents = f.read()
if b'declare_namespace' not in contents:
raise distutils.errors.DistutilsError(
"Namespace package problem: %s is a namespace package, but "
"its\n__init__.py does not call declare_namespace()! Please "
'fix it.\n(See the setuptools manual under '
'"Namespace Packages" for details.)\n"' % (package,)
)
return init_py
def initialize_options(self):
self.packages_checked = {}
orig.build_py.initialize_options(self)
def get_package_dir(self, package):
res = orig.build_py.get_package_dir(self, package)
if self.distribution.src_root is not None:
return os.path.join(self.distribution.src_root, res)
return res
def exclude_data_files(self, package, src_dir, files):
"""Filter filenames for package's data files in 'src_dir'"""
globs = (
self.exclude_package_data.get('', [])
+ self.exclude_package_data.get(package, [])
)
bad = set(
item
for pattern in globs
for item in fnmatch.filter(
files,
os.path.join(src_dir, convert_path(pattern)),
)
)
seen = collections.defaultdict(itertools.count)
return [
fn
for fn in files
if fn not in bad
# ditch dupes
and not next(seen[fn])
]
def assert_relative(path):
if not os.path.isabs(path):
return path
from distutils.errors import DistutilsSetupError
msg = textwrap.dedent("""
Error: setup script specifies an absolute path:
%s
setup() arguments must *always* be /-separated paths relative to the
setup.py directory, *never* absolute paths.
""").lstrip() % path
raise DistutilsSetupError(msg)
setuptools-20.7.0/setuptools/command/develop.py 0000775 0001750 0001750 00000016327 12702524020 022542 0 ustar travis travis 0000000 0000000 from distutils.util import convert_path
from distutils import log
from distutils.errors import DistutilsError, DistutilsOptionError
import os
import glob
import io
from setuptools.extern import six
from pkg_resources import Distribution, PathMetadata, normalize_path
from setuptools.command.easy_install import easy_install
import setuptools
class develop(easy_install):
"""Set up package for development"""
description = "install package in 'development mode'"
user_options = easy_install.user_options + [
("uninstall", "u", "Uninstall this source package"),
("egg-path=", None, "Set the path to be used in the .egg-link file"),
]
boolean_options = easy_install.boolean_options + ['uninstall']
command_consumes_arguments = False # override base
def run(self):
if self.uninstall:
self.multi_version = True
self.uninstall_link()
else:
self.install_for_development()
self.warn_deprecated_options()
def initialize_options(self):
self.uninstall = None
self.egg_path = None
easy_install.initialize_options(self)
self.setup_path = None
self.always_copy_from = '.' # always copy eggs installed in curdir
def finalize_options(self):
ei = self.get_finalized_command("egg_info")
if ei.broken_egg_info:
template = "Please rename %r to %r before using 'develop'"
args = ei.egg_info, ei.broken_egg_info
raise DistutilsError(template % args)
self.args = [ei.egg_name]
easy_install.finalize_options(self)
self.expand_basedirs()
self.expand_dirs()
# pick up setup-dir .egg files only: no .egg-info
self.package_index.scan(glob.glob('*.egg'))
egg_link_fn = ei.egg_name + '.egg-link'
self.egg_link = os.path.join(self.install_dir, egg_link_fn)
self.egg_base = ei.egg_base
if self.egg_path is None:
self.egg_path = os.path.abspath(ei.egg_base)
target = normalize_path(self.egg_base)
egg_path = normalize_path(os.path.join(self.install_dir,
self.egg_path))
if egg_path != target:
raise DistutilsOptionError(
"--egg-path must be a relative path from the install"
" directory to " + target
)
# Make a distribution for the package's source
self.dist = Distribution(
target,
PathMetadata(target, os.path.abspath(ei.egg_info)),
project_name=ei.egg_name
)
p = self.egg_base.replace(os.sep, '/')
if p != os.curdir:
p = '../' * (p.count('/') + 1)
self.setup_path = p
p = normalize_path(os.path.join(self.install_dir, self.egg_path, p))
if p != normalize_path(os.curdir):
raise DistutilsOptionError(
"Can't get a consistent path to setup script from"
" installation directory", p, normalize_path(os.curdir))
def install_for_development(self):
if six.PY3 and getattr(self.distribution, 'use_2to3', False):
# If we run 2to3 we can not do this inplace:
# Ensure metadata is up-to-date
self.reinitialize_command('build_py', inplace=0)
self.run_command('build_py')
bpy_cmd = self.get_finalized_command("build_py")
build_path = normalize_path(bpy_cmd.build_lib)
# Build extensions
self.reinitialize_command('egg_info', egg_base=build_path)
self.run_command('egg_info')
self.reinitialize_command('build_ext', inplace=0)
self.run_command('build_ext')
# Fixup egg-link and easy-install.pth
ei_cmd = self.get_finalized_command("egg_info")
self.egg_path = build_path
self.dist.location = build_path
# XXX
self.dist._provider = PathMetadata(build_path, ei_cmd.egg_info)
else:
# Without 2to3 inplace works fine:
self.run_command('egg_info')
# Build extensions in-place
self.reinitialize_command('build_ext', inplace=1)
self.run_command('build_ext')
self.install_site_py() # ensure that target dir is site-safe
if setuptools.bootstrap_install_from:
self.easy_install(setuptools.bootstrap_install_from)
setuptools.bootstrap_install_from = None
# create an .egg-link in the installation dir, pointing to our egg
log.info("Creating %s (link to %s)", self.egg_link, self.egg_base)
if not self.dry_run:
with open(self.egg_link, "w") as f:
f.write(self.egg_path + "\n" + self.setup_path)
# postprocess the installed distro, fixing up .pth, installing scripts,
# and handling requirements
self.process_distribution(None, self.dist, not self.no_deps)
def uninstall_link(self):
if os.path.exists(self.egg_link):
log.info("Removing %s (link to %s)", self.egg_link, self.egg_base)
egg_link_file = open(self.egg_link)
contents = [line.rstrip() for line in egg_link_file]
egg_link_file.close()
if contents not in ([self.egg_path],
[self.egg_path, self.setup_path]):
log.warn("Link points to %s: uninstall aborted", contents)
return
if not self.dry_run:
os.unlink(self.egg_link)
if not self.dry_run:
self.update_pth(self.dist) # remove any .pth link to us
if self.distribution.scripts:
# XXX should also check for entry point scripts!
log.warn("Note: you must uninstall or replace scripts manually!")
def install_egg_scripts(self, dist):
if dist is not self.dist:
# Installing a dependency, so fall back to normal behavior
return easy_install.install_egg_scripts(self, dist)
# create wrapper scripts in the script dir, pointing to dist.scripts
# new-style...
self.install_wrapper_scripts(dist)
# ...and old-style
for script_name in self.distribution.scripts or []:
script_path = os.path.abspath(convert_path(script_name))
script_name = os.path.basename(script_path)
with io.open(script_path) as strm:
script_text = strm.read()
self.install_script(dist, script_name, script_text, script_path)
def install_wrapper_scripts(self, dist):
dist = VersionlessRequirement(dist)
return easy_install.install_wrapper_scripts(self, dist)
class VersionlessRequirement(object):
"""
Adapt a pkg_resources.Distribution to simply return the project
name as the 'requirement' so that scripts will work across
multiple versions.
>>> dist = Distribution(project_name='foo', version='1.0')
>>> str(dist.as_requirement())
'foo==1.0'
>>> adapted_dist = VersionlessRequirement(dist)
>>> str(adapted_dist.as_requirement())
'foo'
"""
def __init__(self, dist):
self.__dist = dist
def __getattr__(self, name):
return getattr(self.__dist, name)
def as_requirement(self):
return self.project_name
setuptools-20.7.0/setuptools/command/easy_install.py 0000775 0001750 0001750 00000247560 12702524020 023600 0 ustar travis travis 0000000 0000000 #!/usr/bin/env python
"""
Easy Install
------------
A tool for doing automatic download/extract/build of distutils-based Python
packages. For detailed documentation, see the accompanying EasyInstall.txt
file, or visit the `EasyInstall home page`__.
__ https://pythonhosted.org/setuptools/easy_install.html
"""
from glob import glob
from distutils.util import get_platform
from distutils.util import convert_path, subst_vars
from distutils.errors import DistutilsArgError, DistutilsOptionError, \
DistutilsError, DistutilsPlatformError
from distutils.command.install import INSTALL_SCHEMES, SCHEME_KEYS
from distutils import log, dir_util
from distutils.command.build_scripts import first_line_re
from distutils.spawn import find_executable
import sys
import os
import zipimport
import shutil
import tempfile
import zipfile
import re
import stat
import random
import platform
import textwrap
import warnings
import site
import struct
import contextlib
import subprocess
import shlex
import io
from setuptools.extern import six
from setuptools.extern.six.moves import configparser, map
from setuptools import Command
from setuptools.sandbox import run_setup
from setuptools.py31compat import get_path, get_config_vars
from setuptools.command import setopt
from setuptools.archive_util import unpack_archive
from setuptools.package_index import PackageIndex
from setuptools.package_index import URL_SCHEME
from setuptools.command import bdist_egg, egg_info
from pkg_resources import (
yield_lines, normalize_path, resource_string, ensure_directory,
get_distribution, find_distributions, Environment, Requirement,
Distribution, PathMetadata, EggMetadata, WorkingSet, DistributionNotFound,
VersionConflict, DEVELOP_DIST,
)
import pkg_resources
# Turn on PEP440Warnings
warnings.filterwarnings("default", category=pkg_resources.PEP440Warning)
__all__ = [
'samefile', 'easy_install', 'PthDistributions', 'extract_wininst_cfg',
'main', 'get_exe_prefixes',
]
def is_64bit():
return struct.calcsize("P") == 8
def samefile(p1, p2):
both_exist = os.path.exists(p1) and os.path.exists(p2)
use_samefile = hasattr(os.path, 'samefile') and both_exist
if use_samefile:
return os.path.samefile(p1, p2)
norm_p1 = os.path.normpath(os.path.normcase(p1))
norm_p2 = os.path.normpath(os.path.normcase(p2))
return norm_p1 == norm_p2
if six.PY2:
def _to_ascii(s):
return s
def isascii(s):
try:
six.text_type(s, 'ascii')
return True
except UnicodeError:
return False
else:
def _to_ascii(s):
return s.encode('ascii')
def isascii(s):
try:
s.encode('ascii')
return True
except UnicodeError:
return False
class easy_install(Command):
"""Manage a download/build/install process"""
description = "Find/get/install Python packages"
command_consumes_arguments = True
user_options = [
('prefix=', None, "installation prefix"),
("zip-ok", "z", "install package as a zipfile"),
("multi-version", "m", "make apps have to require() a version"),
("upgrade", "U", "force upgrade (searches PyPI for latest versions)"),
("install-dir=", "d", "install package to DIR"),
("script-dir=", "s", "install scripts to DIR"),
("exclude-scripts", "x", "Don't install scripts"),
("always-copy", "a", "Copy all needed packages to install dir"),
("index-url=", "i", "base URL of Python Package Index"),
("find-links=", "f", "additional URL(s) to search for packages"),
("build-directory=", "b",
"download/extract/build in DIR; keep the results"),
('optimize=', 'O',
"also compile with optimization: -O1 for \"python -O\", "
"-O2 for \"python -OO\", and -O0 to disable [default: -O0]"),
('record=', None,
"filename in which to record list of installed files"),
('always-unzip', 'Z', "don't install as a zipfile, no matter what"),
('site-dirs=', 'S', "list of directories where .pth files work"),
('editable', 'e', "Install specified packages in editable form"),
('no-deps', 'N', "don't install dependencies"),
('allow-hosts=', 'H', "pattern(s) that hostnames must match"),
('local-snapshots-ok', 'l',
"allow building eggs from local checkouts"),
('version', None, "print version information and exit"),
('no-find-links', None,
"Don't load find-links defined in packages being installed")
]
boolean_options = [
'zip-ok', 'multi-version', 'exclude-scripts', 'upgrade', 'always-copy',
'editable',
'no-deps', 'local-snapshots-ok', 'version'
]
if site.ENABLE_USER_SITE:
help_msg = "install in user site-package '%s'" % site.USER_SITE
user_options.append(('user', None, help_msg))
boolean_options.append('user')
negative_opt = {'always-unzip': 'zip-ok'}
create_index = PackageIndex
def initialize_options(self):
# the --user option seems to be an opt-in one,
# so the default should be False.
self.user = 0
self.zip_ok = self.local_snapshots_ok = None
self.install_dir = self.script_dir = self.exclude_scripts = None
self.index_url = None
self.find_links = None
self.build_directory = None
self.args = None
self.optimize = self.record = None
self.upgrade = self.always_copy = self.multi_version = None
self.editable = self.no_deps = self.allow_hosts = None
self.root = self.prefix = self.no_report = None
self.version = None
self.install_purelib = None # for pure module distributions
self.install_platlib = None # non-pure (dists w/ extensions)
self.install_headers = None # for C/C++ headers
self.install_lib = None # set to either purelib or platlib
self.install_scripts = None
self.install_data = None
self.install_base = None
self.install_platbase = None
if site.ENABLE_USER_SITE:
self.install_userbase = site.USER_BASE
self.install_usersite = site.USER_SITE
else:
self.install_userbase = None
self.install_usersite = None
self.no_find_links = None
# Options not specifiable via command line
self.package_index = None
self.pth_file = self.always_copy_from = None
self.site_dirs = None
self.installed_projects = {}
self.sitepy_installed = False
# Always read easy_install options, even if we are subclassed, or have
# an independent instance created. This ensures that defaults will
# always come from the standard configuration file(s)' "easy_install"
# section, even if this is a "develop" or "install" command, or some
# other embedding.
self._dry_run = None
self.verbose = self.distribution.verbose
self.distribution._set_command_options(
self, self.distribution.get_option_dict('easy_install')
)
def delete_blockers(self, blockers):
extant_blockers = (
filename for filename in blockers
if os.path.exists(filename) or os.path.islink(filename)
)
list(map(self._delete_path, extant_blockers))
def _delete_path(self, path):
log.info("Deleting %s", path)
if self.dry_run:
return
is_tree = os.path.isdir(path) and not os.path.islink(path)
remover = rmtree if is_tree else os.unlink
remover(path)
@staticmethod
def _render_version():
"""
Render the Setuptools version and installation details, then exit.
"""
ver = sys.version[:3]
dist = get_distribution('setuptools')
tmpl = 'setuptools {dist.version} from {dist.location} (Python {ver})'
print(tmpl.format(**locals()))
raise SystemExit()
def finalize_options(self):
self.version and self._render_version()
py_version = sys.version.split()[0]
prefix, exec_prefix = get_config_vars('prefix', 'exec_prefix')
self.config_vars = {
'dist_name': self.distribution.get_name(),
'dist_version': self.distribution.get_version(),
'dist_fullname': self.distribution.get_fullname(),
'py_version': py_version,
'py_version_short': py_version[0:3],
'py_version_nodot': py_version[0] + py_version[2],
'sys_prefix': prefix,
'prefix': prefix,
'sys_exec_prefix': exec_prefix,
'exec_prefix': exec_prefix,
# Only python 3.2+ has abiflags
'abiflags': getattr(sys, 'abiflags', ''),
}
if site.ENABLE_USER_SITE:
self.config_vars['userbase'] = self.install_userbase
self.config_vars['usersite'] = self.install_usersite
self._fix_install_dir_for_user_site()
self.expand_basedirs()
self.expand_dirs()
self._expand('install_dir', 'script_dir', 'build_directory',
'site_dirs')
# If a non-default installation directory was specified, default the
# script directory to match it.
if self.script_dir is None:
self.script_dir = self.install_dir
if self.no_find_links is None:
self.no_find_links = False
# Let install_dir get set by install_lib command, which in turn
# gets its info from the install command, and takes into account
# --prefix and --home and all that other crud.
self.set_undefined_options(
'install_lib', ('install_dir', 'install_dir')
)
# Likewise, set default script_dir from 'install_scripts.install_dir'
self.set_undefined_options(
'install_scripts', ('install_dir', 'script_dir')
)
if self.user and self.install_purelib:
self.install_dir = self.install_purelib
self.script_dir = self.install_scripts
# default --record from the install command
self.set_undefined_options('install', ('record', 'record'))
# Should this be moved to the if statement below? It's not used
# elsewhere
normpath = map(normalize_path, sys.path)
self.all_site_dirs = get_site_dirs()
if self.site_dirs is not None:
site_dirs = [
os.path.expanduser(s.strip()) for s in
self.site_dirs.split(',')
]
for d in site_dirs:
if not os.path.isdir(d):
log.warn("%s (in --site-dirs) does not exist", d)
elif normalize_path(d) not in normpath:
raise DistutilsOptionError(
d + " (in --site-dirs) is not on sys.path"
)
else:
self.all_site_dirs.append(normalize_path(d))
if not self.editable:
self.check_site_dir()
self.index_url = self.index_url or "https://pypi.python.org/simple"
self.shadow_path = self.all_site_dirs[:]
for path_item in self.install_dir, normalize_path(self.script_dir):
if path_item not in self.shadow_path:
self.shadow_path.insert(0, path_item)
if self.allow_hosts is not None:
hosts = [s.strip() for s in self.allow_hosts.split(',')]
else:
hosts = ['*']
if self.package_index is None:
self.package_index = self.create_index(
self.index_url, search_path=self.shadow_path, hosts=hosts,
)
self.local_index = Environment(self.shadow_path + sys.path)
if self.find_links is not None:
if isinstance(self.find_links, six.string_types):
self.find_links = self.find_links.split()
else:
self.find_links = []
if self.local_snapshots_ok:
self.package_index.scan_egg_links(self.shadow_path + sys.path)
if not self.no_find_links:
self.package_index.add_find_links(self.find_links)
self.set_undefined_options('install_lib', ('optimize', 'optimize'))
if not isinstance(self.optimize, int):
try:
self.optimize = int(self.optimize)
if not (0 <= self.optimize <= 2):
raise ValueError
except ValueError:
raise DistutilsOptionError("--optimize must be 0, 1, or 2")
if self.editable and not self.build_directory:
raise DistutilsArgError(
"Must specify a build directory (-b) when using --editable"
)
if not self.args:
raise DistutilsArgError(
"No urls, filenames, or requirements specified (see --help)")
self.outputs = []
def _fix_install_dir_for_user_site(self):
"""
Fix the install_dir if "--user" was used.
"""
if not self.user or not site.ENABLE_USER_SITE:
return
self.create_home_path()
if self.install_userbase is None:
msg = "User base directory is not specified"
raise DistutilsPlatformError(msg)
self.install_base = self.install_platbase = self.install_userbase
scheme_name = os.name.replace('posix', 'unix') + '_user'
self.select_scheme(scheme_name)
def _expand_attrs(self, attrs):
for attr in attrs:
val = getattr(self, attr)
if val is not None:
if os.name == 'posix' or os.name == 'nt':
val = os.path.expanduser(val)
val = subst_vars(val, self.config_vars)
setattr(self, attr, val)
def expand_basedirs(self):
"""Calls `os.path.expanduser` on install_base, install_platbase and
root."""
self._expand_attrs(['install_base', 'install_platbase', 'root'])
def expand_dirs(self):
"""Calls `os.path.expanduser` on install dirs."""
self._expand_attrs(['install_purelib', 'install_platlib',
'install_lib', 'install_headers',
'install_scripts', 'install_data', ])
def run(self):
if self.verbose != self.distribution.verbose:
log.set_verbosity(self.verbose)
try:
for spec in self.args:
self.easy_install(spec, not self.no_deps)
if self.record:
outputs = self.outputs
if self.root: # strip any package prefix
root_len = len(self.root)
for counter in range(len(outputs)):
outputs[counter] = outputs[counter][root_len:]
from distutils import file_util
self.execute(
file_util.write_file, (self.record, outputs),
"writing list of installed files to '%s'" %
self.record
)
self.warn_deprecated_options()
finally:
log.set_verbosity(self.distribution.verbose)
def pseudo_tempname(self):
"""Return a pseudo-tempname base in the install directory.
This code is intentionally naive; if a malicious party can write to
the target directory you're already in deep doodoo.
"""
try:
pid = os.getpid()
except:
pid = random.randint(0, sys.maxsize)
return os.path.join(self.install_dir, "test-easy-install-%s" % pid)
def warn_deprecated_options(self):
pass
def check_site_dir(self):
"""Verify that self.install_dir is .pth-capable dir, if needed"""
instdir = normalize_path(self.install_dir)
pth_file = os.path.join(instdir, 'easy-install.pth')
# Is it a configured, PYTHONPATH, implicit, or explicit site dir?
is_site_dir = instdir in self.all_site_dirs
if not is_site_dir and not self.multi_version:
# No? Then directly test whether it does .pth file processing
is_site_dir = self.check_pth_processing()
else:
# make sure we can write to target dir
testfile = self.pseudo_tempname() + '.write-test'
test_exists = os.path.exists(testfile)
try:
if test_exists:
os.unlink(testfile)
open(testfile, 'w').close()
os.unlink(testfile)
except (OSError, IOError):
self.cant_write_to_target()
if not is_site_dir and not self.multi_version:
# Can't install non-multi to non-site dir
raise DistutilsError(self.no_default_version_msg())
if is_site_dir:
if self.pth_file is None:
self.pth_file = PthDistributions(pth_file, self.all_site_dirs)
else:
self.pth_file = None
PYTHONPATH = os.environ.get('PYTHONPATH', '').split(os.pathsep)
if instdir not in map(normalize_path, filter(None, PYTHONPATH)):
# only PYTHONPATH dirs need a site.py, so pretend it's there
self.sitepy_installed = True
elif self.multi_version and not os.path.exists(pth_file):
self.sitepy_installed = True # don't need site.py in this case
self.pth_file = None # and don't create a .pth file
self.install_dir = instdir
__cant_write_msg = textwrap.dedent("""
can't create or remove files in install directory
The following error occurred while trying to add or remove files in the
installation directory:
%s
The installation directory you specified (via --install-dir, --prefix, or
the distutils default setting) was:
%s
""").lstrip()
__not_exists_id = textwrap.dedent("""
This directory does not currently exist. Please create it and try again, or
choose a different installation directory (using the -d or --install-dir
option).
""").lstrip()
__access_msg = textwrap.dedent("""
Perhaps your account does not have write access to this directory? If the
installation directory is a system-owned directory, you may need to sign in
as the administrator or "root" account. If you do not have administrative
access to this machine, you may wish to choose a different installation
directory, preferably one that is listed in your PYTHONPATH environment
variable.
For information on other options, you may wish to consult the
documentation at:
https://pythonhosted.org/setuptools/easy_install.html
Please make the appropriate changes for your system and try again.
""").lstrip()
def cant_write_to_target(self):
msg = self.__cant_write_msg % (sys.exc_info()[1], self.install_dir,)
if not os.path.exists(self.install_dir):
msg += '\n' + self.__not_exists_id
else:
msg += '\n' + self.__access_msg
raise DistutilsError(msg)
def check_pth_processing(self):
"""Empirically verify whether .pth files are supported in inst. dir"""
instdir = self.install_dir
log.info("Checking .pth file support in %s", instdir)
pth_file = self.pseudo_tempname() + ".pth"
ok_file = pth_file + '.ok'
ok_exists = os.path.exists(ok_file)
try:
if ok_exists:
os.unlink(ok_file)
dirname = os.path.dirname(ok_file)
if not os.path.exists(dirname):
os.makedirs(dirname)
f = open(pth_file, 'w')
except (OSError, IOError):
self.cant_write_to_target()
else:
try:
f.write("import os; f = open(%r, 'w'); f.write('OK'); "
"f.close()\n" % (ok_file,))
f.close()
f = None
executable = sys.executable
if os.name == 'nt':
dirname, basename = os.path.split(executable)
alt = os.path.join(dirname, 'pythonw.exe')
if (basename.lower() == 'python.exe' and
os.path.exists(alt)):
# use pythonw.exe to avoid opening a console window
executable = alt
from distutils.spawn import spawn
spawn([executable, '-E', '-c', 'pass'], 0)
if os.path.exists(ok_file):
log.info(
"TEST PASSED: %s appears to support .pth files",
instdir
)
return True
finally:
if f:
f.close()
if os.path.exists(ok_file):
os.unlink(ok_file)
if os.path.exists(pth_file):
os.unlink(pth_file)
if not self.multi_version:
log.warn("TEST FAILED: %s does NOT support .pth files", instdir)
return False
def install_egg_scripts(self, dist):
"""Write all the scripts for `dist`, unless scripts are excluded"""
if not self.exclude_scripts and dist.metadata_isdir('scripts'):
for script_name in dist.metadata_listdir('scripts'):
if dist.metadata_isdir('scripts/' + script_name):
# The "script" is a directory, likely a Python 3
# __pycache__ directory, so skip it.
continue
self.install_script(
dist, script_name,
dist.get_metadata('scripts/' + script_name)
)
self.install_wrapper_scripts(dist)
def add_output(self, path):
if os.path.isdir(path):
for base, dirs, files in os.walk(path):
for filename in files:
self.outputs.append(os.path.join(base, filename))
else:
self.outputs.append(path)
def not_editable(self, spec):
if self.editable:
raise DistutilsArgError(
"Invalid argument %r: you can't use filenames or URLs "
"with --editable (except via the --find-links option)."
% (spec,)
)
def check_editable(self, spec):
if not self.editable:
return
if os.path.exists(os.path.join(self.build_directory, spec.key)):
raise DistutilsArgError(
"%r already exists in %s; can't do a checkout there" %
(spec.key, self.build_directory)
)
def easy_install(self, spec, deps=False):
tmpdir = tempfile.mkdtemp(prefix="easy_install-")
download = None
if not self.editable:
self.install_site_py()
try:
if not isinstance(spec, Requirement):
if URL_SCHEME(spec):
# It's a url, download it to tmpdir and process
self.not_editable(spec)
download = self.package_index.download(spec, tmpdir)
return self.install_item(None, download, tmpdir, deps,
True)
elif os.path.exists(spec):
# Existing file or directory, just process it directly
self.not_editable(spec)
return self.install_item(None, spec, tmpdir, deps, True)
else:
spec = parse_requirement_arg(spec)
self.check_editable(spec)
dist = self.package_index.fetch_distribution(
spec, tmpdir, self.upgrade, self.editable,
not self.always_copy, self.local_index
)
if dist is None:
msg = "Could not find suitable distribution for %r" % spec
if self.always_copy:
msg += " (--always-copy skips system and development eggs)"
raise DistutilsError(msg)
elif dist.precedence == DEVELOP_DIST:
# .egg-info dists don't need installing, just process deps
self.process_distribution(spec, dist, deps, "Using")
return dist
else:
return self.install_item(spec, dist.location, tmpdir, deps)
finally:
if os.path.exists(tmpdir):
rmtree(tmpdir)
def install_item(self, spec, download, tmpdir, deps, install_needed=False):
# Installation is also needed if file in tmpdir or is not an egg
install_needed = install_needed or self.always_copy
install_needed = install_needed or os.path.dirname(download) == tmpdir
install_needed = install_needed or not download.endswith('.egg')
install_needed = install_needed or (
self.always_copy_from is not None and
os.path.dirname(normalize_path(download)) ==
normalize_path(self.always_copy_from)
)
if spec and not install_needed:
# at this point, we know it's a local .egg, we just don't know if
# it's already installed.
for dist in self.local_index[spec.project_name]:
if dist.location == download:
break
else:
install_needed = True # it's not in the local index
log.info("Processing %s", os.path.basename(download))
if install_needed:
dists = self.install_eggs(spec, download, tmpdir)
for dist in dists:
self.process_distribution(spec, dist, deps)
else:
dists = [self.egg_distribution(download)]
self.process_distribution(spec, dists[0], deps, "Using")
if spec is not None:
for dist in dists:
if dist in spec:
return dist
def select_scheme(self, name):
"""Sets the install directories by applying the install schemes."""
# it's the caller's problem if they supply a bad name!
scheme = INSTALL_SCHEMES[name]
for key in SCHEME_KEYS:
attrname = 'install_' + key
if getattr(self, attrname) is None:
setattr(self, attrname, scheme[key])
def process_distribution(self, requirement, dist, deps=True, *info):
self.update_pth(dist)
self.package_index.add(dist)
if dist in self.local_index[dist.key]:
self.local_index.remove(dist)
self.local_index.add(dist)
self.install_egg_scripts(dist)
self.installed_projects[dist.key] = dist
log.info(self.installation_report(requirement, dist, *info))
if (dist.has_metadata('dependency_links.txt') and
not self.no_find_links):
self.package_index.add_find_links(
dist.get_metadata_lines('dependency_links.txt')
)
if not deps and not self.always_copy:
return
elif requirement is not None and dist.key != requirement.key:
log.warn("Skipping dependencies for %s", dist)
return # XXX this is not the distribution we were looking for
elif requirement is None or dist not in requirement:
# if we wound up with a different version, resolve what we've got
distreq = dist.as_requirement()
requirement = Requirement(str(distreq))
log.info("Processing dependencies for %s", requirement)
try:
distros = WorkingSet([]).resolve(
[requirement], self.local_index, self.easy_install
)
except DistributionNotFound as e:
raise DistutilsError(str(e))
except VersionConflict as e:
raise DistutilsError(e.report())
if self.always_copy or self.always_copy_from:
# Force all the relevant distros to be copied or activated
for dist in distros:
if dist.key not in self.installed_projects:
self.easy_install(dist.as_requirement())
log.info("Finished processing dependencies for %s", requirement)
def should_unzip(self, dist):
if self.zip_ok is not None:
return not self.zip_ok
if dist.has_metadata('not-zip-safe'):
return True
if not dist.has_metadata('zip-safe'):
return True
return False
def maybe_move(self, spec, dist_filename, setup_base):
dst = os.path.join(self.build_directory, spec.key)
if os.path.exists(dst):
msg = ("%r already exists in %s; build directory %s will not be "
"kept")
log.warn(msg, spec.key, self.build_directory, setup_base)
return setup_base
if os.path.isdir(dist_filename):
setup_base = dist_filename
else:
if os.path.dirname(dist_filename) == setup_base:
os.unlink(dist_filename) # get it out of the tmp dir
contents = os.listdir(setup_base)
if len(contents) == 1:
dist_filename = os.path.join(setup_base, contents[0])
if os.path.isdir(dist_filename):
# if the only thing there is a directory, move it instead
setup_base = dist_filename
ensure_directory(dst)
shutil.move(setup_base, dst)
return dst
def install_wrapper_scripts(self, dist):
if self.exclude_scripts:
return
for args in ScriptWriter.best().get_args(dist):
self.write_script(*args)
def install_script(self, dist, script_name, script_text, dev_path=None):
"""Generate a legacy script wrapper and install it"""
spec = str(dist.as_requirement())
is_script = is_python_script(script_text, script_name)
if is_script:
body = self._load_template(dev_path) % locals()
script_text = ScriptWriter.get_header(script_text) + body
self.write_script(script_name, _to_ascii(script_text), 'b')
@staticmethod
def _load_template(dev_path):
"""
There are a couple of template scripts in the package. This
function loads one of them and prepares it for use.
"""
# See https://github.com/pypa/setuptools/issues/134 for info
# on script file naming and downstream issues with SVR4
name = 'script.tmpl'
if dev_path:
name = name.replace('.tmpl', ' (dev).tmpl')
raw_bytes = resource_string('setuptools', name)
return raw_bytes.decode('utf-8')
def write_script(self, script_name, contents, mode="t", blockers=()):
"""Write an executable file to the scripts directory"""
self.delete_blockers( # clean up old .py/.pyw w/o a script
[os.path.join(self.script_dir, x) for x in blockers]
)
log.info("Installing %s script to %s", script_name, self.script_dir)
target = os.path.join(self.script_dir, script_name)
self.add_output(target)
mask = current_umask()
if not self.dry_run:
ensure_directory(target)
if os.path.exists(target):
os.unlink(target)
with open(target, "w" + mode) as f:
f.write(contents)
chmod(target, 0o777 - mask)
def install_eggs(self, spec, dist_filename, tmpdir):
# .egg dirs or files are already built, so just return them
if dist_filename.lower().endswith('.egg'):
return [self.install_egg(dist_filename, tmpdir)]
elif dist_filename.lower().endswith('.exe'):
return [self.install_exe(dist_filename, tmpdir)]
# Anything else, try to extract and build
setup_base = tmpdir
if os.path.isfile(dist_filename) and not dist_filename.endswith('.py'):
unpack_archive(dist_filename, tmpdir, self.unpack_progress)
elif os.path.isdir(dist_filename):
setup_base = os.path.abspath(dist_filename)
if (setup_base.startswith(tmpdir) # something we downloaded
and self.build_directory and spec is not None):
setup_base = self.maybe_move(spec, dist_filename, setup_base)
# Find the setup.py file
setup_script = os.path.join(setup_base, 'setup.py')
if not os.path.exists(setup_script):
setups = glob(os.path.join(setup_base, '*', 'setup.py'))
if not setups:
raise DistutilsError(
"Couldn't find a setup script in %s" %
os.path.abspath(dist_filename)
)
if len(setups) > 1:
raise DistutilsError(
"Multiple setup scripts in %s" %
os.path.abspath(dist_filename)
)
setup_script = setups[0]
# Now run it, and return the result
if self.editable:
log.info(self.report_editable(spec, setup_script))
return []
else:
return self.build_and_install(setup_script, setup_base)
def egg_distribution(self, egg_path):
if os.path.isdir(egg_path):
metadata = PathMetadata(egg_path, os.path.join(egg_path,
'EGG-INFO'))
else:
metadata = EggMetadata(zipimport.zipimporter(egg_path))
return Distribution.from_filename(egg_path, metadata=metadata)
def install_egg(self, egg_path, tmpdir):
destination = os.path.join(self.install_dir,
os.path.basename(egg_path))
destination = os.path.abspath(destination)
if not self.dry_run:
ensure_directory(destination)
dist = self.egg_distribution(egg_path)
if not samefile(egg_path, destination):
if os.path.isdir(destination) and not os.path.islink(destination):
dir_util.remove_tree(destination, dry_run=self.dry_run)
elif os.path.exists(destination):
self.execute(os.unlink, (destination,), "Removing " +
destination)
try:
new_dist_is_zipped = False
if os.path.isdir(egg_path):
if egg_path.startswith(tmpdir):
f, m = shutil.move, "Moving"
else:
f, m = shutil.copytree, "Copying"
elif self.should_unzip(dist):
self.mkpath(destination)
f, m = self.unpack_and_compile, "Extracting"
else:
new_dist_is_zipped = True
if egg_path.startswith(tmpdir):
f, m = shutil.move, "Moving"
else:
f, m = shutil.copy2, "Copying"
self.execute(f, (egg_path, destination),
(m + " %s to %s") %
(os.path.basename(egg_path),
os.path.dirname(destination)))
update_dist_caches(destination,
fix_zipimporter_caches=new_dist_is_zipped)
except:
update_dist_caches(destination, fix_zipimporter_caches=False)
raise
self.add_output(destination)
return self.egg_distribution(destination)
def install_exe(self, dist_filename, tmpdir):
# See if it's valid, get data
cfg = extract_wininst_cfg(dist_filename)
if cfg is None:
raise DistutilsError(
"%s is not a valid distutils Windows .exe" % dist_filename
)
# Create a dummy distribution object until we build the real distro
dist = Distribution(
None,
project_name=cfg.get('metadata', 'name'),
version=cfg.get('metadata', 'version'), platform=get_platform(),
)
# Convert the .exe to an unpacked egg
egg_path = dist.location = os.path.join(tmpdir, dist.egg_name() +
'.egg')
egg_tmp = egg_path + '.tmp'
_egg_info = os.path.join(egg_tmp, 'EGG-INFO')
pkg_inf = os.path.join(_egg_info, 'PKG-INFO')
ensure_directory(pkg_inf) # make sure EGG-INFO dir exists
dist._provider = PathMetadata(egg_tmp, _egg_info) # XXX
self.exe_to_egg(dist_filename, egg_tmp)
# Write EGG-INFO/PKG-INFO
if not os.path.exists(pkg_inf):
f = open(pkg_inf, 'w')
f.write('Metadata-Version: 1.0\n')
for k, v in cfg.items('metadata'):
if k != 'target_version':
f.write('%s: %s\n' % (k.replace('_', '-').title(), v))
f.close()
script_dir = os.path.join(_egg_info, 'scripts')
# delete entry-point scripts to avoid duping
self.delete_blockers(
[os.path.join(script_dir, args[0]) for args in
ScriptWriter.get_args(dist)]
)
# Build .egg file from tmpdir
bdist_egg.make_zipfile(
egg_path, egg_tmp, verbose=self.verbose, dry_run=self.dry_run
)
# install the .egg
return self.install_egg(egg_path, tmpdir)
def exe_to_egg(self, dist_filename, egg_tmp):
"""Extract a bdist_wininst to the directories an egg would use"""
# Check for .pth file and set up prefix translations
prefixes = get_exe_prefixes(dist_filename)
to_compile = []
native_libs = []
top_level = {}
def process(src, dst):
s = src.lower()
for old, new in prefixes:
if s.startswith(old):
src = new + src[len(old):]
parts = src.split('/')
dst = os.path.join(egg_tmp, *parts)
dl = dst.lower()
if dl.endswith('.pyd') or dl.endswith('.dll'):
parts[-1] = bdist_egg.strip_module(parts[-1])
top_level[os.path.splitext(parts[0])[0]] = 1
native_libs.append(src)
elif dl.endswith('.py') and old != 'SCRIPTS/':
top_level[os.path.splitext(parts[0])[0]] = 1
to_compile.append(dst)
return dst
if not src.endswith('.pth'):
log.warn("WARNING: can't process %s", src)
return None
# extract, tracking .pyd/.dll->native_libs and .py -> to_compile
unpack_archive(dist_filename, egg_tmp, process)
stubs = []
for res in native_libs:
if res.lower().endswith('.pyd'): # create stubs for .pyd's
parts = res.split('/')
resource = parts[-1]
parts[-1] = bdist_egg.strip_module(parts[-1]) + '.py'
pyfile = os.path.join(egg_tmp, *parts)
to_compile.append(pyfile)
stubs.append(pyfile)
bdist_egg.write_stub(resource, pyfile)
self.byte_compile(to_compile) # compile .py's
bdist_egg.write_safety_flag(
os.path.join(egg_tmp, 'EGG-INFO'),
bdist_egg.analyze_egg(egg_tmp, stubs)) # write zip-safety flag
for name in 'top_level', 'native_libs':
if locals()[name]:
txt = os.path.join(egg_tmp, 'EGG-INFO', name + '.txt')
if not os.path.exists(txt):
f = open(txt, 'w')
f.write('\n'.join(locals()[name]) + '\n')
f.close()
__mv_warning = textwrap.dedent("""
Because this distribution was installed --multi-version, before you can
import modules from this package in an application, you will need to
'import pkg_resources' and then use a 'require()' call similar to one of
these examples, in order to select the desired version:
pkg_resources.require("%(name)s") # latest installed version
pkg_resources.require("%(name)s==%(version)s") # this exact version
pkg_resources.require("%(name)s>=%(version)s") # this version or higher
""").lstrip()
__id_warning = textwrap.dedent("""
Note also that the installation directory must be on sys.path at runtime for
this to work. (e.g. by being the application's script directory, by being on
PYTHONPATH, or by being added to sys.path by your code.)
""")
def installation_report(self, req, dist, what="Installed"):
"""Helpful installation message for display to package users"""
msg = "\n%(what)s %(eggloc)s%(extras)s"
if self.multi_version and not self.no_report:
msg += '\n' + self.__mv_warning
if self.install_dir not in map(normalize_path, sys.path):
msg += '\n' + self.__id_warning
eggloc = dist.location
name = dist.project_name
version = dist.version
extras = '' # TODO: self.report_extras(req, dist)
return msg % locals()
__editable_msg = textwrap.dedent("""
Extracted editable version of %(spec)s to %(dirname)s
If it uses setuptools in its setup script, you can activate it in
"development" mode by going to that directory and running::
%(python)s setup.py develop
See the setuptools documentation for the "develop" command for more info.
""").lstrip()
def report_editable(self, spec, setup_script):
dirname = os.path.dirname(setup_script)
python = sys.executable
return '\n' + self.__editable_msg % locals()
def run_setup(self, setup_script, setup_base, args):
sys.modules.setdefault('distutils.command.bdist_egg', bdist_egg)
sys.modules.setdefault('distutils.command.egg_info', egg_info)
args = list(args)
if self.verbose > 2:
v = 'v' * (self.verbose - 1)
args.insert(0, '-' + v)
elif self.verbose < 2:
args.insert(0, '-q')
if self.dry_run:
args.insert(0, '-n')
log.info(
"Running %s %s", setup_script[len(setup_base) + 1:], ' '.join(args)
)
try:
run_setup(setup_script, args)
except SystemExit as v:
raise DistutilsError("Setup script exited with %s" % (v.args[0],))
def build_and_install(self, setup_script, setup_base):
args = ['bdist_egg', '--dist-dir']
dist_dir = tempfile.mkdtemp(
prefix='egg-dist-tmp-', dir=os.path.dirname(setup_script)
)
try:
self._set_fetcher_options(os.path.dirname(setup_script))
args.append(dist_dir)
self.run_setup(setup_script, setup_base, args)
all_eggs = Environment([dist_dir])
eggs = []
for key in all_eggs:
for dist in all_eggs[key]:
eggs.append(self.install_egg(dist.location, setup_base))
if not eggs and not self.dry_run:
log.warn("No eggs found in %s (setup script problem?)",
dist_dir)
return eggs
finally:
rmtree(dist_dir)
log.set_verbosity(self.verbose) # restore our log verbosity
def _set_fetcher_options(self, base):
"""
When easy_install is about to run bdist_egg on a source dist, that
source dist might have 'setup_requires' directives, requiring
additional fetching. Ensure the fetcher options given to easy_install
are available to that command as well.
"""
# find the fetch options from easy_install and write them out
# to the setup.cfg file.
ei_opts = self.distribution.get_option_dict('easy_install').copy()
fetch_directives = (
'find_links', 'site_dirs', 'index_url', 'optimize',
'site_dirs', 'allow_hosts',
)
fetch_options = {}
for key, val in ei_opts.items():
if key not in fetch_directives:
continue
fetch_options[key.replace('_', '-')] = val[1]
# create a settings dictionary suitable for `edit_config`
settings = dict(easy_install=fetch_options)
cfg_filename = os.path.join(base, 'setup.cfg')
setopt.edit_config(cfg_filename, settings)
def update_pth(self, dist):
if self.pth_file is None:
return
for d in self.pth_file[dist.key]: # drop old entries
if self.multi_version or d.location != dist.location:
log.info("Removing %s from easy-install.pth file", d)
self.pth_file.remove(d)
if d.location in self.shadow_path:
self.shadow_path.remove(d.location)
if not self.multi_version:
if dist.location in self.pth_file.paths:
log.info(
"%s is already the active version in easy-install.pth",
dist
)
else:
log.info("Adding %s to easy-install.pth file", dist)
self.pth_file.add(dist) # add new entry
if dist.location not in self.shadow_path:
self.shadow_path.append(dist.location)
if not self.dry_run:
self.pth_file.save()
if dist.key == 'setuptools':
# Ensure that setuptools itself never becomes unavailable!
# XXX should this check for latest version?
filename = os.path.join(self.install_dir, 'setuptools.pth')
if os.path.islink(filename):
os.unlink(filename)
f = open(filename, 'wt')
f.write(self.pth_file.make_relative(dist.location) + '\n')
f.close()
def unpack_progress(self, src, dst):
# Progress filter for unpacking
log.debug("Unpacking %s to %s", src, dst)
return dst # only unpack-and-compile skips files for dry run
def unpack_and_compile(self, egg_path, destination):
to_compile = []
to_chmod = []
def pf(src, dst):
if dst.endswith('.py') and not src.startswith('EGG-INFO/'):
to_compile.append(dst)
elif dst.endswith('.dll') or dst.endswith('.so'):
to_chmod.append(dst)
self.unpack_progress(src, dst)
return not self.dry_run and dst or None
unpack_archive(egg_path, destination, pf)
self.byte_compile(to_compile)
if not self.dry_run:
for f in to_chmod:
mode = ((os.stat(f)[stat.ST_MODE]) | 0o555) & 0o7755
chmod(f, mode)
def byte_compile(self, to_compile):
if sys.dont_write_bytecode:
self.warn('byte-compiling is disabled, skipping.')
return
from distutils.util import byte_compile
try:
# try to make the byte compile messages quieter
log.set_verbosity(self.verbose - 1)
byte_compile(to_compile, optimize=0, force=1, dry_run=self.dry_run)
if self.optimize:
byte_compile(
to_compile, optimize=self.optimize, force=1,
dry_run=self.dry_run
)
finally:
log.set_verbosity(self.verbose) # restore original verbosity
__no_default_msg = textwrap.dedent("""
bad install directory or PYTHONPATH
You are attempting to install a package to a directory that is not
on PYTHONPATH and which Python does not read ".pth" files from. The
installation directory you specified (via --install-dir, --prefix, or
the distutils default setting) was:
%s
and your PYTHONPATH environment variable currently contains:
%r
Here are some of your options for correcting the problem:
* You can choose a different installation directory, i.e., one that is
on PYTHONPATH or supports .pth files
* You can add the installation directory to the PYTHONPATH environment
variable. (It must then also be on PYTHONPATH whenever you run
Python and want to use the package(s) you are installing.)
* You can set up the installation directory to support ".pth" files by
using one of the approaches described here:
https://pythonhosted.org/setuptools/easy_install.html#custom-installation-locations
Please make the appropriate changes for your system and try again.""").lstrip()
def no_default_version_msg(self):
template = self.__no_default_msg
return template % (self.install_dir, os.environ.get('PYTHONPATH', ''))
def install_site_py(self):
"""Make sure there's a site.py in the target dir, if needed"""
if self.sitepy_installed:
return # already did it, or don't need to
sitepy = os.path.join(self.install_dir, "site.py")
source = resource_string("setuptools", "site-patch.py")
source = source.decode('utf-8')
current = ""
if os.path.exists(sitepy):
log.debug("Checking existing site.py in %s", self.install_dir)
with io.open(sitepy) as strm:
current = strm.read()
if not current.startswith('def __boot():'):
raise DistutilsError(
"%s is not a setuptools-generated site.py; please"
" remove it." % sitepy
)
if current != source:
log.info("Creating %s", sitepy)
if not self.dry_run:
ensure_directory(sitepy)
with io.open(sitepy, 'w', encoding='utf-8') as strm:
strm.write(source)
self.byte_compile([sitepy])
self.sitepy_installed = True
def create_home_path(self):
"""Create directories under ~."""
if not self.user:
return
home = convert_path(os.path.expanduser("~"))
for name, path in six.iteritems(self.config_vars):
if path.startswith(home) and not os.path.isdir(path):
self.debug_print("os.makedirs('%s', 0o700)" % path)
os.makedirs(path, 0o700)
INSTALL_SCHEMES = dict(
posix=dict(
install_dir='$base/lib/python$py_version_short/site-packages',
script_dir='$base/bin',
),
)
DEFAULT_SCHEME = dict(
install_dir='$base/Lib/site-packages',
script_dir='$base/Scripts',
)
def _expand(self, *attrs):
config_vars = self.get_finalized_command('install').config_vars
if self.prefix:
# Set default install_dir/scripts from --prefix
config_vars = config_vars.copy()
config_vars['base'] = self.prefix
scheme = self.INSTALL_SCHEMES.get(os.name, self.DEFAULT_SCHEME)
for attr, val in scheme.items():
if getattr(self, attr, None) is None:
setattr(self, attr, val)
from distutils.util import subst_vars
for attr in attrs:
val = getattr(self, attr)
if val is not None:
val = subst_vars(val, config_vars)
if os.name == 'posix':
val = os.path.expanduser(val)
setattr(self, attr, val)
def get_site_dirs():
# return a list of 'site' dirs
sitedirs = [_f for _f in os.environ.get('PYTHONPATH',
'').split(os.pathsep) if _f]
prefixes = [sys.prefix]
if sys.exec_prefix != sys.prefix:
prefixes.append(sys.exec_prefix)
for prefix in prefixes:
if prefix:
if sys.platform in ('os2emx', 'riscos'):
sitedirs.append(os.path.join(prefix, "Lib", "site-packages"))
elif os.sep == '/':
sitedirs.extend([os.path.join(prefix,
"lib",
"python" + sys.version[:3],
"site-packages"),
os.path.join(prefix, "lib", "site-python")])
else:
sitedirs.extend(
[prefix, os.path.join(prefix, "lib", "site-packages")]
)
if sys.platform == 'darwin':
# for framework builds *only* we add the standard Apple
# locations. Currently only per-user, but /Library and
# /Network/Library could be added too
if 'Python.framework' in prefix:
home = os.environ.get('HOME')
if home:
sitedirs.append(
os.path.join(home,
'Library',
'Python',
sys.version[:3],
'site-packages'))
lib_paths = get_path('purelib'), get_path('platlib')
for site_lib in lib_paths:
if site_lib not in sitedirs:
sitedirs.append(site_lib)
if site.ENABLE_USER_SITE:
sitedirs.append(site.USER_SITE)
sitedirs = list(map(normalize_path, sitedirs))
return sitedirs
def expand_paths(inputs):
"""Yield sys.path directories that might contain "old-style" packages"""
seen = {}
for dirname in inputs:
dirname = normalize_path(dirname)
if dirname in seen:
continue
seen[dirname] = 1
if not os.path.isdir(dirname):
continue
files = os.listdir(dirname)
yield dirname, files
for name in files:
if not name.endswith('.pth'):
# We only care about the .pth files
continue
if name in ('easy-install.pth', 'setuptools.pth'):
# Ignore .pth files that we control
continue
# Read the .pth file
f = open(os.path.join(dirname, name))
lines = list(yield_lines(f))
f.close()
# Yield existing non-dupe, non-import directory lines from it
for line in lines:
if not line.startswith("import"):
line = normalize_path(line.rstrip())
if line not in seen:
seen[line] = 1
if not os.path.isdir(line):
continue
yield line, os.listdir(line)
def extract_wininst_cfg(dist_filename):
"""Extract configuration data from a bdist_wininst .exe
Returns a configparser.RawConfigParser, or None
"""
f = open(dist_filename, 'rb')
try:
endrec = zipfile._EndRecData(f)
if endrec is None:
return None
prepended = (endrec[9] - endrec[5]) - endrec[6]
if prepended < 12: # no wininst data here
return None
f.seek(prepended - 12)
tag, cfglen, bmlen = struct.unpack("egg path translations for a given .exe file"""
prefixes = [
('PURELIB/', ''), ('PLATLIB/pywin32_system32', ''),
('PLATLIB/', ''),
('SCRIPTS/', 'EGG-INFO/scripts/'),
('DATA/lib/site-packages', ''),
]
z = zipfile.ZipFile(exe_filename)
try:
for info in z.infolist():
name = info.filename
parts = name.split('/')
if len(parts) == 3 and parts[2] == 'PKG-INFO':
if parts[1].endswith('.egg-info'):
prefixes.insert(0, ('/'.join(parts[:2]), 'EGG-INFO/'))
break
if len(parts) != 2 or not name.endswith('.pth'):
continue
if name.endswith('-nspkg.pth'):
continue
if parts[0].upper() in ('PURELIB', 'PLATLIB'):
contents = z.read(name)
if six.PY3:
contents = contents.decode()
for pth in yield_lines(contents):
pth = pth.strip().replace('\\', '/')
if not pth.startswith('import'):
prefixes.append((('%s/%s/' % (parts[0], pth)), ''))
finally:
z.close()
prefixes = [(x.lower(), y) for x, y in prefixes]
prefixes.sort()
prefixes.reverse()
return prefixes
def parse_requirement_arg(spec):
try:
return Requirement.parse(spec)
except ValueError:
raise DistutilsError(
"Not a URL, existing file, or requirement spec: %r" % (spec,)
)
class PthDistributions(Environment):
"""A .pth file with Distribution paths in it"""
dirty = False
def __init__(self, filename, sitedirs=()):
self.filename = filename
self.sitedirs = list(map(normalize_path, sitedirs))
self.basedir = normalize_path(os.path.dirname(self.filename))
self._load()
Environment.__init__(self, [], None, None)
for path in yield_lines(self.paths):
list(map(self.add, find_distributions(path, True)))
def _load(self):
self.paths = []
saw_import = False
seen = dict.fromkeys(self.sitedirs)
if os.path.isfile(self.filename):
f = open(self.filename, 'rt')
for line in f:
if line.startswith('import'):
saw_import = True
continue
path = line.rstrip()
self.paths.append(path)
if not path.strip() or path.strip().startswith('#'):
continue
# skip non-existent paths, in case somebody deleted a package
# manually, and duplicate paths as well
path = self.paths[-1] = normalize_path(
os.path.join(self.basedir, path)
)
if not os.path.exists(path) or path in seen:
self.paths.pop() # skip it
self.dirty = True # we cleaned up, so we're dirty now :)
continue
seen[path] = 1
f.close()
if self.paths and not saw_import:
self.dirty = True # ensure anything we touch has import wrappers
while self.paths and not self.paths[-1].strip():
self.paths.pop()
def save(self):
"""Write changed .pth file back to disk"""
if not self.dirty:
return
rel_paths = list(map(self.make_relative, self.paths))
if rel_paths:
log.debug("Saving %s", self.filename)
lines = self._wrap_lines(rel_paths)
data = '\n'.join(lines) + '\n'
if os.path.islink(self.filename):
os.unlink(self.filename)
with open(self.filename, 'wt') as f:
f.write(data)
elif os.path.exists(self.filename):
log.debug("Deleting empty %s", self.filename)
os.unlink(self.filename)
self.dirty = False
@staticmethod
def _wrap_lines(lines):
return lines
def add(self, dist):
"""Add `dist` to the distribution map"""
new_path = (
dist.location not in self.paths and (
dist.location not in self.sitedirs or
# account for '.' being in PYTHONPATH
dist.location == os.getcwd()
)
)
if new_path:
self.paths.append(dist.location)
self.dirty = True
Environment.add(self, dist)
def remove(self, dist):
"""Remove `dist` from the distribution map"""
while dist.location in self.paths:
self.paths.remove(dist.location)
self.dirty = True
Environment.remove(self, dist)
def make_relative(self, path):
npath, last = os.path.split(normalize_path(path))
baselen = len(self.basedir)
parts = [last]
sep = os.altsep == '/' and '/' or os.sep
while len(npath) >= baselen:
if npath == self.basedir:
parts.append(os.curdir)
parts.reverse()
return sep.join(parts)
npath, last = os.path.split(npath)
parts.append(last)
else:
return path
class RewritePthDistributions(PthDistributions):
@classmethod
def _wrap_lines(cls, lines):
yield cls.prelude
for line in lines:
yield line
yield cls.postlude
_inline = lambda text: textwrap.dedent(text).strip().replace('\n', '; ')
prelude = _inline("""
import sys
sys.__plen = len(sys.path)
""")
postlude = _inline("""
import sys
new = sys.path[sys.__plen:]
del sys.path[sys.__plen:]
p = getattr(sys, '__egginsert', 0)
sys.path[p:p] = new
sys.__egginsert = p + len(new)
""")
if os.environ.get('SETUPTOOLS_SYS_PATH_TECHNIQUE', 'rewrite') == 'rewrite':
PthDistributions = RewritePthDistributions
def _first_line_re():
"""
Return a regular expression based on first_line_re suitable for matching
strings.
"""
if isinstance(first_line_re.pattern, str):
return first_line_re
# first_line_re in Python >=3.1.4 and >=3.2.1 is a bytes pattern.
return re.compile(first_line_re.pattern.decode())
def auto_chmod(func, arg, exc):
if func is os.remove and os.name == 'nt':
chmod(arg, stat.S_IWRITE)
return func(arg)
et, ev, _ = sys.exc_info()
six.reraise(et, (ev[0], ev[1] + (" %s %s" % (func, arg))))
def update_dist_caches(dist_path, fix_zipimporter_caches):
"""
Fix any globally cached `dist_path` related data
`dist_path` should be a path of a newly installed egg distribution (zipped
or unzipped).
sys.path_importer_cache contains finder objects that have been cached when
importing data from the original distribution. Any such finders need to be
cleared since the replacement distribution might be packaged differently,
e.g. a zipped egg distribution might get replaced with an unzipped egg
folder or vice versa. Having the old finders cached may then cause Python
to attempt loading modules from the replacement distribution using an
incorrect loader.
zipimport.zipimporter objects are Python loaders charged with importing
data packaged inside zip archives. If stale loaders referencing the
original distribution, are left behind, they can fail to load modules from
the replacement distribution. E.g. if an old zipimport.zipimporter instance
is used to load data from a new zipped egg archive, it may cause the
operation to attempt to locate the requested data in the wrong location -
one indicated by the original distribution's zip archive directory
information. Such an operation may then fail outright, e.g. report having
read a 'bad local file header', or even worse, it may fail silently &
return invalid data.
zipimport._zip_directory_cache contains cached zip archive directory
information for all existing zipimport.zipimporter instances and all such
instances connected to the same archive share the same cached directory
information.
If asked, and the underlying Python implementation allows it, we can fix
all existing zipimport.zipimporter instances instead of having to track
them down and remove them one by one, by updating their shared cached zip
archive directory information. This, of course, assumes that the
replacement distribution is packaged as a zipped egg.
If not asked to fix existing zipimport.zipimporter instances, we still do
our best to clear any remaining zipimport.zipimporter related cached data
that might somehow later get used when attempting to load data from the new
distribution and thus cause such load operations to fail. Note that when
tracking down such remaining stale data, we can not catch every conceivable
usage from here, and we clear only those that we know of and have found to
cause problems if left alive. Any remaining caches should be updated by
whomever is in charge of maintaining them, i.e. they should be ready to
handle us replacing their zip archives with new distributions at runtime.
"""
# There are several other known sources of stale zipimport.zipimporter
# instances that we do not clear here, but might if ever given a reason to
# do so:
# * Global setuptools pkg_resources.working_set (a.k.a. 'master working
# set') may contain distributions which may in turn contain their
# zipimport.zipimporter loaders.
# * Several zipimport.zipimporter loaders held by local variables further
# up the function call stack when running the setuptools installation.
# * Already loaded modules may have their __loader__ attribute set to the
# exact loader instance used when importing them. Python 3.4 docs state
# that this information is intended mostly for introspection and so is
# not expected to cause us problems.
normalized_path = normalize_path(dist_path)
_uncache(normalized_path, sys.path_importer_cache)
if fix_zipimporter_caches:
_replace_zip_directory_cache_data(normalized_path)
else:
# Here, even though we do not want to fix existing and now stale
# zipimporter cache information, we still want to remove it. Related to
# Python's zip archive directory information cache, we clear each of
# its stale entries in two phases:
# 1. Clear the entry so attempting to access zip archive information
# via any existing stale zipimport.zipimporter instances fails.
# 2. Remove the entry from the cache so any newly constructed
# zipimport.zipimporter instances do not end up using old stale
# zip archive directory information.
# This whole stale data removal step does not seem strictly necessary,
# but has been left in because it was done before we started replacing
# the zip archive directory information cache content if possible, and
# there are no relevant unit tests that we can depend on to tell us if
# this is really needed.
_remove_and_clear_zip_directory_cache_data(normalized_path)
def _collect_zipimporter_cache_entries(normalized_path, cache):
"""
Return zipimporter cache entry keys related to a given normalized path.
Alternative path spellings (e.g. those using different character case or
those using alternative path separators) related to the same path are
included. Any sub-path entries are included as well, i.e. those
corresponding to zip archives embedded in other zip archives.
"""
result = []
prefix_len = len(normalized_path)
for p in cache:
np = normalize_path(p)
if (np.startswith(normalized_path) and
np[prefix_len:prefix_len + 1] in (os.sep, '')):
result.append(p)
return result
def _update_zipimporter_cache(normalized_path, cache, updater=None):
"""
Update zipimporter cache data for a given normalized path.
Any sub-path entries are processed as well, i.e. those corresponding to zip
archives embedded in other zip archives.
Given updater is a callable taking a cache entry key and the original entry
(after already removing the entry from the cache), and expected to update
the entry and possibly return a new one to be inserted in its place.
Returning None indicates that the entry should not be replaced with a new
one. If no updater is given, the cache entries are simply removed without
any additional processing, the same as if the updater simply returned None.
"""
for p in _collect_zipimporter_cache_entries(normalized_path, cache):
# N.B. pypy's custom zipimport._zip_directory_cache implementation does
# not support the complete dict interface:
# * Does not support item assignment, thus not allowing this function
# to be used only for removing existing cache entries.
# * Does not support the dict.pop() method, forcing us to use the
# get/del patterns instead. For more detailed information see the
# following links:
# https://github.com/pypa/setuptools/issues/202#issuecomment-202913420
# https://bitbucket.org/pypy/pypy/src/dd07756a34a41f674c0cacfbc8ae1d4cc9ea2ae4/pypy/module/zipimport/interp_zipimport.py#cl-99
old_entry = cache[p]
del cache[p]
new_entry = updater and updater(p, old_entry)
if new_entry is not None:
cache[p] = new_entry
def _uncache(normalized_path, cache):
_update_zipimporter_cache(normalized_path, cache)
def _remove_and_clear_zip_directory_cache_data(normalized_path):
def clear_and_remove_cached_zip_archive_directory_data(path, old_entry):
old_entry.clear()
_update_zipimporter_cache(
normalized_path, zipimport._zip_directory_cache,
updater=clear_and_remove_cached_zip_archive_directory_data)
# PyPy Python implementation does not allow directly writing to the
# zipimport._zip_directory_cache and so prevents us from attempting to correct
# its content. The best we can do there is clear the problematic cache content
# and have PyPy repopulate it as needed. The downside is that if there are any
# stale zipimport.zipimporter instances laying around, attempting to use them
# will fail due to not having its zip archive directory information available
# instead of being automatically corrected to use the new correct zip archive
# directory information.
if '__pypy__' in sys.builtin_module_names:
_replace_zip_directory_cache_data = \
_remove_and_clear_zip_directory_cache_data
else:
def _replace_zip_directory_cache_data(normalized_path):
def replace_cached_zip_archive_directory_data(path, old_entry):
# N.B. In theory, we could load the zip directory information just
# once for all updated path spellings, and then copy it locally and
# update its contained path strings to contain the correct
# spelling, but that seems like a way too invasive move (this cache
# structure is not officially documented anywhere and could in
# theory change with new Python releases) for no significant
# benefit.
old_entry.clear()
zipimport.zipimporter(path)
old_entry.update(zipimport._zip_directory_cache[path])
return old_entry
_update_zipimporter_cache(
normalized_path, zipimport._zip_directory_cache,
updater=replace_cached_zip_archive_directory_data)
def is_python(text, filename=''):
"Is this string a valid Python script?"
try:
compile(text, filename, 'exec')
except (SyntaxError, TypeError):
return False
else:
return True
def is_sh(executable):
"""Determine if the specified executable is a .sh (contains a #! line)"""
try:
with io.open(executable, encoding='latin-1') as fp:
magic = fp.read(2)
except (OSError, IOError):
return executable
return magic == '#!'
def nt_quote_arg(arg):
"""Quote a command line argument according to Windows parsing rules"""
return subprocess.list2cmdline([arg])
def is_python_script(script_text, filename):
"""Is this text, as a whole, a Python script? (as opposed to shell/bat/etc.
"""
if filename.endswith('.py') or filename.endswith('.pyw'):
return True # extension says it's Python
if is_python(script_text, filename):
return True # it's syntactically valid Python
if script_text.startswith('#!'):
# It begins with a '#!' line, so check if 'python' is in it somewhere
return 'python' in script_text.splitlines()[0].lower()
return False # Not any Python I can recognize
try:
from os import chmod as _chmod
except ImportError:
# Jython compatibility
def _chmod(*args):
pass
def chmod(path, mode):
log.debug("changing mode of %s to %o", path, mode)
try:
_chmod(path, mode)
except os.error as e:
log.debug("chmod failed: %s", e)
class CommandSpec(list):
"""
A command spec for a #! header, specified as a list of arguments akin to
those passed to Popen.
"""
options = []
split_args = dict()
@classmethod
def best(cls):
"""
Choose the best CommandSpec class based on environmental conditions.
"""
return cls
@classmethod
def _sys_executable(cls):
_default = os.path.normpath(sys.executable)
return os.environ.get('__PYVENV_LAUNCHER__', _default)
@classmethod
def from_param(cls, param):
"""
Construct a CommandSpec from a parameter to build_scripts, which may
be None.
"""
if isinstance(param, cls):
return param
if isinstance(param, list):
return cls(param)
if param is None:
return cls.from_environment()
# otherwise, assume it's a string.
return cls.from_string(param)
@classmethod
def from_environment(cls):
return cls([cls._sys_executable()])
@classmethod
def from_string(cls, string):
"""
Construct a command spec from a simple string representing a command
line parseable by shlex.split.
"""
items = shlex.split(string, **cls.split_args)
return cls(items)
def install_options(self, script_text):
self.options = shlex.split(self._extract_options(script_text))
cmdline = subprocess.list2cmdline(self)
if not isascii(cmdline):
self.options[:0] = ['-x']
@staticmethod
def _extract_options(orig_script):
"""
Extract any options from the first line of the script.
"""
first = (orig_script + '\n').splitlines()[0]
match = _first_line_re().match(first)
options = match.group(1) or '' if match else ''
return options.strip()
def as_header(self):
return self._render(self + list(self.options))
@staticmethod
def _render(items):
cmdline = subprocess.list2cmdline(items)
return '#!' + cmdline + '\n'
# For pbr compat; will be removed in a future version.
sys_executable = CommandSpec._sys_executable()
class WindowsCommandSpec(CommandSpec):
split_args = dict(posix=False)
class ScriptWriter(object):
"""
Encapsulates behavior around writing entry point scripts for console and
gui apps.
"""
template = textwrap.dedent("""
# EASY-INSTALL-ENTRY-SCRIPT: %(spec)r,%(group)r,%(name)r
__requires__ = %(spec)r
import sys
from pkg_resources import load_entry_point
if __name__ == '__main__':
sys.exit(
load_entry_point(%(spec)r, %(group)r, %(name)r)()
)
""").lstrip()
command_spec_class = CommandSpec
@classmethod
def get_script_args(cls, dist, executable=None, wininst=False):
# for backward compatibility
warnings.warn("Use get_args", DeprecationWarning)
writer = (WindowsScriptWriter if wininst else ScriptWriter).best()
header = cls.get_script_header("", executable, wininst)
return writer.get_args(dist, header)
@classmethod
def get_script_header(cls, script_text, executable=None, wininst=False):
# for backward compatibility
warnings.warn("Use get_header", DeprecationWarning)
if wininst:
executable = "python.exe"
cmd = cls.command_spec_class.best().from_param(executable)
cmd.install_options(script_text)
return cmd.as_header()
@classmethod
def get_args(cls, dist, header=None):
"""
Yield write_script() argument tuples for a distribution's
console_scripts and gui_scripts entry points.
"""
if header is None:
header = cls.get_header()
spec = str(dist.as_requirement())
for type_ in 'console', 'gui':
group = type_ + '_scripts'
for name, ep in dist.get_entry_map(group).items():
cls._ensure_safe_name(name)
script_text = cls.template % locals()
args = cls._get_script_args(type_, name, header, script_text)
for res in args:
yield res
@staticmethod
def _ensure_safe_name(name):
"""
Prevent paths in *_scripts entry point names.
"""
has_path_sep = re.search(r'[\\/]', name)
if has_path_sep:
raise ValueError("Path separators not allowed in script names")
@classmethod
def get_writer(cls, force_windows):
# for backward compatibility
warnings.warn("Use best", DeprecationWarning)
return WindowsScriptWriter.best() if force_windows else cls.best()
@classmethod
def best(cls):
"""
Select the best ScriptWriter for this environment.
"""
if sys.platform == 'win32' or (os.name == 'java' and os._name == 'nt'):
return WindowsScriptWriter.best()
else:
return cls
@classmethod
def _get_script_args(cls, type_, name, header, script_text):
# Simply write the stub with no extension.
yield (name, header + script_text)
@classmethod
def get_header(cls, script_text="", executable=None):
"""Create a #! line, getting options (if any) from script_text"""
cmd = cls.command_spec_class.best().from_param(executable)
cmd.install_options(script_text)
return cmd.as_header()
class WindowsScriptWriter(ScriptWriter):
command_spec_class = WindowsCommandSpec
@classmethod
def get_writer(cls):
# for backward compatibility
warnings.warn("Use best", DeprecationWarning)
return cls.best()
@classmethod
def best(cls):
"""
Select the best ScriptWriter suitable for Windows
"""
writer_lookup = dict(
executable=WindowsExecutableLauncherWriter,
natural=cls,
)
# for compatibility, use the executable launcher by default
launcher = os.environ.get('SETUPTOOLS_LAUNCHER', 'executable')
return writer_lookup[launcher]
@classmethod
def _get_script_args(cls, type_, name, header, script_text):
"For Windows, add a .py extension"
ext = dict(console='.pya', gui='.pyw')[type_]
if ext not in os.environ['PATHEXT'].lower().split(';'):
warnings.warn("%s not listed in PATHEXT; scripts will not be "
"recognized as executables." % ext, UserWarning)
old = ['.pya', '.py', '-script.py', '.pyc', '.pyo', '.pyw', '.exe']
old.remove(ext)
header = cls._adjust_header(type_, header)
blockers = [name + x for x in old]
yield name + ext, header + script_text, 't', blockers
@classmethod
def _adjust_header(cls, type_, orig_header):
"""
Make sure 'pythonw' is used for gui and and 'python' is used for
console (regardless of what sys.executable is).
"""
pattern = 'pythonw.exe'
repl = 'python.exe'
if type_ == 'gui':
pattern, repl = repl, pattern
pattern_ob = re.compile(re.escape(pattern), re.IGNORECASE)
new_header = pattern_ob.sub(string=orig_header, repl=repl)
return new_header if cls._use_header(new_header) else orig_header
@staticmethod
def _use_header(new_header):
"""
Should _adjust_header use the replaced header?
On non-windows systems, always use. On
Windows systems, only use the replaced header if it resolves
to an executable on the system.
"""
clean_header = new_header[2:-1].strip('"')
return sys.platform != 'win32' or find_executable(clean_header)
class WindowsExecutableLauncherWriter(WindowsScriptWriter):
@classmethod
def _get_script_args(cls, type_, name, header, script_text):
"""
For Windows, add a .py extension and an .exe launcher
"""
if type_ == 'gui':
launcher_type = 'gui'
ext = '-script.pyw'
old = ['.pyw']
else:
launcher_type = 'cli'
ext = '-script.py'
old = ['.py', '.pyc', '.pyo']
hdr = cls._adjust_header(type_, header)
blockers = [name + x for x in old]
yield (name + ext, hdr + script_text, 't', blockers)
yield (
name + '.exe', get_win_launcher(launcher_type),
'b' # write in binary mode
)
if not is_64bit():
# install a manifest for the launcher to prevent Windows
# from detecting it as an installer (which it will for
# launchers like easy_install.exe). Consider only
# adding a manifest for launchers detected as installers.
# See Distribute #143 for details.
m_name = name + '.exe.manifest'
yield (m_name, load_launcher_manifest(name), 't')
# for backward-compatibility
get_script_args = ScriptWriter.get_script_args
get_script_header = ScriptWriter.get_script_header
def get_win_launcher(type):
"""
Load the Windows launcher (executable) suitable for launching a script.
`type` should be either 'cli' or 'gui'
Returns the executable as a byte string.
"""
launcher_fn = '%s.exe' % type
if platform.machine().lower() == 'arm':
launcher_fn = launcher_fn.replace(".", "-arm.")
if is_64bit():
launcher_fn = launcher_fn.replace(".", "-64.")
else:
launcher_fn = launcher_fn.replace(".", "-32.")
return resource_string('setuptools', launcher_fn)
def load_launcher_manifest(name):
manifest = pkg_resources.resource_string(__name__, 'launcher manifest.xml')
if six.PY2:
return manifest % vars()
else:
return manifest.decode('utf-8') % vars()
def rmtree(path, ignore_errors=False, onerror=auto_chmod):
"""Recursively delete a directory tree.
This code is taken from the Python 2.4 version of 'shutil', because
the 2.3 version doesn't really work right.
"""
if ignore_errors:
def onerror(*args):
pass
elif onerror is None:
def onerror(*args):
raise
names = []
try:
names = os.listdir(path)
except os.error:
onerror(os.listdir, path, sys.exc_info())
for name in names:
fullname = os.path.join(path, name)
try:
mode = os.lstat(fullname).st_mode
except os.error:
mode = 0
if stat.S_ISDIR(mode):
rmtree(fullname, ignore_errors, onerror)
else:
try:
os.remove(fullname)
except os.error:
onerror(os.remove, fullname, sys.exc_info())
try:
os.rmdir(path)
except os.error:
onerror(os.rmdir, path, sys.exc_info())
def current_umask():
tmp = os.umask(0o022)
os.umask(tmp)
return tmp
def bootstrap():
# This function is called when setuptools*.egg is run using /bin/sh
import setuptools
argv0 = os.path.dirname(setuptools.__path__[0])
sys.argv[0] = argv0
sys.argv.append(argv0)
main()
def main(argv=None, **kw):
from setuptools import setup
from setuptools.dist import Distribution
class DistributionWithoutHelpCommands(Distribution):
common_usage = ""
def _show_help(self, *args, **kw):
with _patch_usage():
Distribution._show_help(self, *args, **kw)
if argv is None:
argv = sys.argv[1:]
with _patch_usage():
setup(
script_args=['-q', 'easy_install', '-v'] + argv,
script_name=sys.argv[0] or 'easy_install',
distclass=DistributionWithoutHelpCommands, **kw
)
@contextlib.contextmanager
def _patch_usage():
import distutils.core
USAGE = textwrap.dedent("""
usage: %(script)s [options] requirement_or_url ...
or: %(script)s --help
""").lstrip()
def gen_usage(script_name):
return USAGE % dict(
script=os.path.basename(script_name),
)
saved = distutils.core.gen_usage
distutils.core.gen_usage = gen_usage
try:
yield
finally:
distutils.core.gen_usage = saved
setuptools-20.7.0/setuptools/command/egg_info.py 0000775 0001750 0001750 00000040772 12702524020 022662 0 ustar travis travis 0000000 0000000 """setuptools.command.egg_info
Create a distribution's .egg-info directory and contents"""
from distutils.filelist import FileList as _FileList
from distutils.util import convert_path
from distutils import log
import distutils.errors
import distutils.filelist
import os
import re
import sys
import io
import warnings
import time
from setuptools.extern import six
from setuptools.extern.six.moves import map
from setuptools import Command
from setuptools.command.sdist import sdist
from setuptools.command.sdist import walk_revctrl
from setuptools.command.setopt import edit_config
from setuptools.command import bdist_egg
from pkg_resources import (
parse_requirements, safe_name, parse_version,
safe_version, yield_lines, EntryPoint, iter_entry_points, to_filename)
import setuptools.unicode_utils as unicode_utils
from pkg_resources.extern import packaging
try:
from setuptools_svn import svn_utils
except ImportError:
pass
class egg_info(Command):
description = "create a distribution's .egg-info directory"
user_options = [
('egg-base=', 'e', "directory containing .egg-info directories"
" (default: top of the source tree)"),
('tag-svn-revision', 'r',
"Add subversion revision ID to version number"),
('tag-date', 'd', "Add date stamp (e.g. 20050528) to version number"),
('tag-build=', 'b', "Specify explicit tag to add to version number"),
('no-svn-revision', 'R',
"Don't add subversion revision ID [default]"),
('no-date', 'D', "Don't include date stamp [default]"),
]
boolean_options = ['tag-date', 'tag-svn-revision']
negative_opt = {'no-svn-revision': 'tag-svn-revision',
'no-date': 'tag-date'}
def initialize_options(self):
self.egg_name = None
self.egg_version = None
self.egg_base = None
self.egg_info = None
self.tag_build = None
self.tag_svn_revision = 0
self.tag_date = 0
self.broken_egg_info = False
self.vtags = None
def save_version_info(self, filename):
values = dict(
egg_info=dict(
tag_svn_revision=0,
tag_date=0,
tag_build=self.tags(),
)
)
edit_config(filename, values)
def finalize_options(self):
self.egg_name = safe_name(self.distribution.get_name())
self.vtags = self.tags()
self.egg_version = self.tagged_version()
parsed_version = parse_version(self.egg_version)
try:
is_version = isinstance(parsed_version, packaging.version.Version)
spec = (
"%s==%s" if is_version else "%s===%s"
)
list(
parse_requirements(spec % (self.egg_name, self.egg_version))
)
except ValueError:
raise distutils.errors.DistutilsOptionError(
"Invalid distribution name or version syntax: %s-%s" %
(self.egg_name, self.egg_version)
)
if self.egg_base is None:
dirs = self.distribution.package_dir
self.egg_base = (dirs or {}).get('', os.curdir)
self.ensure_dirname('egg_base')
self.egg_info = to_filename(self.egg_name) + '.egg-info'
if self.egg_base != os.curdir:
self.egg_info = os.path.join(self.egg_base, self.egg_info)
if '-' in self.egg_name:
self.check_broken_egg_info()
# Set package version for the benefit of dumber commands
# (e.g. sdist, bdist_wininst, etc.)
#
self.distribution.metadata.version = self.egg_version
# If we bootstrapped around the lack of a PKG-INFO, as might be the
# case in a fresh checkout, make sure that any special tags get added
# to the version info
#
pd = self.distribution._patched_dist
if pd is not None and pd.key == self.egg_name.lower():
pd._version = self.egg_version
pd._parsed_version = parse_version(self.egg_version)
self.distribution._patched_dist = None
def write_or_delete_file(self, what, filename, data, force=False):
"""Write `data` to `filename` or delete if empty
If `data` is non-empty, this routine is the same as ``write_file()``.
If `data` is empty but not ``None``, this is the same as calling
``delete_file(filename)`. If `data` is ``None``, then this is a no-op
unless `filename` exists, in which case a warning is issued about the
orphaned file (if `force` is false), or deleted (if `force` is true).
"""
if data:
self.write_file(what, filename, data)
elif os.path.exists(filename):
if data is None and not force:
log.warn(
"%s not set in setup(), but %s exists", what, filename
)
return
else:
self.delete_file(filename)
def write_file(self, what, filename, data):
"""Write `data` to `filename` (if not a dry run) after announcing it
`what` is used in a log message to identify what is being written
to the file.
"""
log.info("writing %s to %s", what, filename)
if six.PY3:
data = data.encode("utf-8")
if not self.dry_run:
f = open(filename, 'wb')
f.write(data)
f.close()
def delete_file(self, filename):
"""Delete `filename` (if not a dry run) after announcing it"""
log.info("deleting %s", filename)
if not self.dry_run:
os.unlink(filename)
def tagged_version(self):
version = self.distribution.get_version()
# egg_info may be called more than once for a distribution,
# in which case the version string already contains all tags.
if self.vtags and version.endswith(self.vtags):
return safe_version(version)
return safe_version(version + self.vtags)
def run(self):
self.mkpath(self.egg_info)
installer = self.distribution.fetch_build_egg
for ep in iter_entry_points('egg_info.writers'):
ep.require(installer=installer)
writer = ep.resolve()
writer(self, ep.name, os.path.join(self.egg_info, ep.name))
# Get rid of native_libs.txt if it was put there by older bdist_egg
nl = os.path.join(self.egg_info, "native_libs.txt")
if os.path.exists(nl):
self.delete_file(nl)
self.find_sources()
def tags(self):
version = ''
if self.tag_build:
version += self.tag_build
if self.tag_svn_revision:
version += '-r%s' % self.get_svn_revision()
if self.tag_date:
version += time.strftime("-%Y%m%d")
return version
@staticmethod
def get_svn_revision():
if 'svn_utils' not in globals():
return "0"
return str(svn_utils.SvnInfo.load(os.curdir).get_revision())
def find_sources(self):
"""Generate SOURCES.txt manifest file"""
manifest_filename = os.path.join(self.egg_info, "SOURCES.txt")
mm = manifest_maker(self.distribution)
mm.manifest = manifest_filename
mm.run()
self.filelist = mm.filelist
def check_broken_egg_info(self):
bei = self.egg_name + '.egg-info'
if self.egg_base != os.curdir:
bei = os.path.join(self.egg_base, bei)
if os.path.exists(bei):
log.warn(
"-" * 78 + '\n'
"Note: Your current .egg-info directory has a '-' in its name;"
'\nthis will not work correctly with "setup.py develop".\n\n'
'Please rename %s to %s to correct this problem.\n' + '-' * 78,
bei, self.egg_info
)
self.broken_egg_info = self.egg_info
self.egg_info = bei # make it work for now
class FileList(_FileList):
"""File list that accepts only existing, platform-independent paths"""
def append(self, item):
if item.endswith('\r'): # Fix older sdists built on Windows
item = item[:-1]
path = convert_path(item)
if self._safe_path(path):
self.files.append(path)
def extend(self, paths):
self.files.extend(filter(self._safe_path, paths))
def _repair(self):
"""
Replace self.files with only safe paths
Because some owners of FileList manipulate the underlying
``files`` attribute directly, this method must be called to
repair those paths.
"""
self.files = list(filter(self._safe_path, self.files))
def _safe_path(self, path):
enc_warn = "'%s' not %s encodable -- skipping"
# To avoid accidental trans-codings errors, first to unicode
u_path = unicode_utils.filesys_decode(path)
if u_path is None:
log.warn("'%s' in unexpected encoding -- skipping" % path)
return False
# Must ensure utf-8 encodability
utf8_path = unicode_utils.try_encode(u_path, "utf-8")
if utf8_path is None:
log.warn(enc_warn, path, 'utf-8')
return False
try:
# accept is either way checks out
if os.path.exists(u_path) or os.path.exists(utf8_path):
return True
# this will catch any encode errors decoding u_path
except UnicodeEncodeError:
log.warn(enc_warn, path, sys.getfilesystemencoding())
class manifest_maker(sdist):
template = "MANIFEST.in"
def initialize_options(self):
self.use_defaults = 1
self.prune = 1
self.manifest_only = 1
self.force_manifest = 1
def finalize_options(self):
pass
def run(self):
self.filelist = FileList()
if not os.path.exists(self.manifest):
self.write_manifest() # it must exist so it'll get in the list
self.filelist.findall()
self.add_defaults()
if os.path.exists(self.template):
self.read_template()
self.prune_file_list()
self.filelist.sort()
self.filelist.remove_duplicates()
self.write_manifest()
def _manifest_normalize(self, path):
path = unicode_utils.filesys_decode(path)
return path.replace(os.sep, '/')
def write_manifest(self):
"""
Write the file list in 'self.filelist' to the manifest file
named by 'self.manifest'.
"""
self.filelist._repair()
# Now _repairs should encodability, but not unicode
files = [self._manifest_normalize(f) for f in self.filelist.files]
msg = "writing manifest file '%s'" % self.manifest
self.execute(write_file, (self.manifest, files), msg)
def warn(self, msg): # suppress missing-file warnings from sdist
if not msg.startswith("standard file not found:"):
sdist.warn(self, msg)
def add_defaults(self):
sdist.add_defaults(self)
self.filelist.append(self.template)
self.filelist.append(self.manifest)
rcfiles = list(walk_revctrl())
if rcfiles:
self.filelist.extend(rcfiles)
elif os.path.exists(self.manifest):
self.read_manifest()
ei_cmd = self.get_finalized_command('egg_info')
self._add_egg_info(cmd=ei_cmd)
self.filelist.include_pattern("*", prefix=ei_cmd.egg_info)
def _add_egg_info(self, cmd):
"""
Add paths for egg-info files for an external egg-base.
The egg-info files are written to egg-base. If egg-base is
outside the current working directory, this method
searchs the egg-base directory for files to include
in the manifest. Uses distutils.filelist.findall (which is
really the version monkeypatched in by setuptools/__init__.py)
to perform the search.
Since findall records relative paths, prefix the returned
paths with cmd.egg_base, so add_default's include_pattern call
(which is looking for the absolute cmd.egg_info) will match
them.
"""
if cmd.egg_base == os.curdir:
# egg-info files were already added by something else
return
discovered = distutils.filelist.findall(cmd.egg_base)
resolved = (os.path.join(cmd.egg_base, path) for path in discovered)
self.filelist.allfiles.extend(resolved)
def prune_file_list(self):
build = self.get_finalized_command('build')
base_dir = self.distribution.get_fullname()
self.filelist.exclude_pattern(None, prefix=build.build_base)
self.filelist.exclude_pattern(None, prefix=base_dir)
sep = re.escape(os.sep)
self.filelist.exclude_pattern(r'(^|' + sep + r')(RCS|CVS|\.svn)' + sep,
is_regex=1)
def write_file(filename, contents):
"""Create a file with the specified name and write 'contents' (a
sequence of strings without line terminators) to it.
"""
contents = "\n".join(contents)
# assuming the contents has been vetted for utf-8 encoding
contents = contents.encode("utf-8")
with open(filename, "wb") as f: # always write POSIX-style manifest
f.write(contents)
def write_pkg_info(cmd, basename, filename):
log.info("writing %s", filename)
if not cmd.dry_run:
metadata = cmd.distribution.metadata
metadata.version, oldver = cmd.egg_version, metadata.version
metadata.name, oldname = cmd.egg_name, metadata.name
try:
# write unescaped data to PKG-INFO, so older pkg_resources
# can still parse it
metadata.write_pkg_info(cmd.egg_info)
finally:
metadata.name, metadata.version = oldname, oldver
safe = getattr(cmd.distribution, 'zip_safe', None)
bdist_egg.write_safety_flag(cmd.egg_info, safe)
def warn_depends_obsolete(cmd, basename, filename):
if os.path.exists(filename):
log.warn(
"WARNING: 'depends.txt' is not used by setuptools 0.6!\n"
"Use the install_requires/extras_require setup() args instead."
)
def _write_requirements(stream, reqs):
lines = yield_lines(reqs or ())
append_cr = lambda line: line + '\n'
lines = map(append_cr, lines)
stream.writelines(lines)
def write_requirements(cmd, basename, filename):
dist = cmd.distribution
data = six.StringIO()
_write_requirements(data, dist.install_requires)
extras_require = dist.extras_require or {}
for extra in sorted(extras_require):
data.write('\n[{extra}]\n'.format(**vars()))
_write_requirements(data, extras_require[extra])
cmd.write_or_delete_file("requirements", filename, data.getvalue())
def write_setup_requirements(cmd, basename, filename):
data = StringIO()
_write_requirements(data, cmd.distribution.setup_requires)
cmd.write_or_delete_file("setup-requirements", filename, data.getvalue())
def write_toplevel_names(cmd, basename, filename):
pkgs = dict.fromkeys(
[
k.split('.', 1)[0]
for k in cmd.distribution.iter_distribution_names()
]
)
cmd.write_file("top-level names", filename, '\n'.join(sorted(pkgs)) + '\n')
def overwrite_arg(cmd, basename, filename):
write_arg(cmd, basename, filename, True)
def write_arg(cmd, basename, filename, force=False):
argname = os.path.splitext(basename)[0]
value = getattr(cmd.distribution, argname, None)
if value is not None:
value = '\n'.join(value) + '\n'
cmd.write_or_delete_file(argname, filename, value, force)
def write_entries(cmd, basename, filename):
ep = cmd.distribution.entry_points
if isinstance(ep, six.string_types) or ep is None:
data = ep
elif ep is not None:
data = []
for section, contents in sorted(ep.items()):
if not isinstance(contents, six.string_types):
contents = EntryPoint.parse_group(section, contents)
contents = '\n'.join(sorted(map(str, contents.values())))
data.append('[%s]\n%s\n\n' % (section, contents))
data = ''.join(data)
cmd.write_or_delete_file('entry points', filename, data, True)
def get_pkg_info_revision():
"""
Get a -r### off of PKG-INFO Version in case this is an sdist of
a subversion revision.
"""
warnings.warn("get_pkg_info_revision is deprecated.", DeprecationWarning)
if os.path.exists('PKG-INFO'):
with io.open('PKG-INFO') as f:
for line in f:
match = re.match(r"Version:.*-r(\d+)\s*$", line)
if match:
return int(match.group(1))
return 0
setuptools-20.7.0/setuptools/command/install.py 0000664 0001750 0001750 00000011113 12702524020 022533 0 ustar travis travis 0000000 0000000 from distutils.errors import DistutilsArgError
import inspect
import glob
import warnings
import platform
import distutils.command.install as orig
import setuptools
# Prior to numpy 1.9, NumPy relies on the '_install' name, so provide it for
# now. See https://github.com/pypa/setuptools/issues/199/
_install = orig.install
class install(orig.install):
"""Use easy_install to install the package, w/dependencies"""
user_options = orig.install.user_options + [
('old-and-unmanageable', None, "Try not to use this!"),
('single-version-externally-managed', None,
"used by system package builders to create 'flat' eggs"),
]
boolean_options = orig.install.boolean_options + [
'old-and-unmanageable', 'single-version-externally-managed',
]
new_commands = [
('install_egg_info', lambda self: True),
('install_scripts', lambda self: True),
]
_nc = dict(new_commands)
def initialize_options(self):
orig.install.initialize_options(self)
self.old_and_unmanageable = None
self.single_version_externally_managed = None
def finalize_options(self):
orig.install.finalize_options(self)
if self.root:
self.single_version_externally_managed = True
elif self.single_version_externally_managed:
if not self.root and not self.record:
raise DistutilsArgError(
"You must specify --record or --root when building system"
" packages"
)
def handle_extra_path(self):
if self.root or self.single_version_externally_managed:
# explicit backward-compatibility mode, allow extra_path to work
return orig.install.handle_extra_path(self)
# Ignore extra_path when installing an egg (or being run by another
# command without --root or --single-version-externally-managed
self.path_file = None
self.extra_dirs = ''
def run(self):
# Explicit request for old-style install? Just do it
if self.old_and_unmanageable or self.single_version_externally_managed:
return orig.install.run(self)
if not self._called_from_setup(inspect.currentframe()):
# Run in backward-compatibility mode to support bdist_* commands.
orig.install.run(self)
else:
self.do_egg_install()
@staticmethod
def _called_from_setup(run_frame):
"""
Attempt to detect whether run() was called from setup() or by another
command. If called by setup(), the parent caller will be the
'run_command' method in 'distutils.dist', and *its* caller will be
the 'run_commands' method. If called any other way, the
immediate caller *might* be 'run_command', but it won't have been
called by 'run_commands'. Return True in that case or if a call stack
is unavailable. Return False otherwise.
"""
if run_frame is None:
msg = "Call stack not available. bdist_* commands may fail."
warnings.warn(msg)
if platform.python_implementation() == 'IronPython':
msg = "For best results, pass -X:Frames to enable call stack."
warnings.warn(msg)
return True
res = inspect.getouterframes(run_frame)[2]
caller, = res[:1]
info = inspect.getframeinfo(caller)
caller_module = caller.f_globals.get('__name__', '')
return (
caller_module == 'distutils.dist'
and info.function == 'run_commands'
)
def do_egg_install(self):
easy_install = self.distribution.get_command_class('easy_install')
cmd = easy_install(
self.distribution, args="x", root=self.root, record=self.record,
)
cmd.ensure_finalized() # finalize before bdist_egg munges install cmd
cmd.always_copy_from = '.' # make sure local-dir eggs get installed
# pick up setup-dir .egg files only: no .egg-info
cmd.package_index.scan(glob.glob('*.egg'))
self.run_command('bdist_egg')
args = [self.distribution.get_command_obj('bdist_egg').egg_output]
if setuptools.bootstrap_install_from:
# Bootstrap self-installation of setuptools
args.insert(0, setuptools.bootstrap_install_from)
cmd.args = args
cmd.run()
setuptools.bootstrap_install_from = None
# XXX Python 3.1 doesn't see _nc if this is inside the class
install.sub_commands = (
[cmd for cmd in orig.install.sub_commands if cmd[0] not in install._nc] +
install.new_commands
)
setuptools-20.7.0/setuptools/command/install_egg_info.py 0000775 0001750 0001750 00000007703 12702524020 024405 0 ustar travis travis 0000000 0000000 from distutils import log, dir_util
import os
from setuptools.extern.six.moves import map
from setuptools import Command
from setuptools.archive_util import unpack_archive
import pkg_resources
class install_egg_info(Command):
"""Install an .egg-info directory for the package"""
description = "Install an .egg-info directory for the package"
user_options = [
('install-dir=', 'd', "directory to install to"),
]
def initialize_options(self):
self.install_dir = None
def finalize_options(self):
self.set_undefined_options('install_lib',
('install_dir', 'install_dir'))
ei_cmd = self.get_finalized_command("egg_info")
basename = pkg_resources.Distribution(
None, None, ei_cmd.egg_name, ei_cmd.egg_version
).egg_name() + '.egg-info'
self.source = ei_cmd.egg_info
self.target = os.path.join(self.install_dir, basename)
self.outputs = []
def run(self):
self.run_command('egg_info')
if os.path.isdir(self.target) and not os.path.islink(self.target):
dir_util.remove_tree(self.target, dry_run=self.dry_run)
elif os.path.exists(self.target):
self.execute(os.unlink, (self.target,), "Removing " + self.target)
if not self.dry_run:
pkg_resources.ensure_directory(self.target)
self.execute(
self.copytree, (), "Copying %s to %s" % (self.source, self.target)
)
self.install_namespaces()
def get_outputs(self):
return self.outputs
def copytree(self):
# Copy the .egg-info tree to site-packages
def skimmer(src, dst):
# filter out source-control directories; note that 'src' is always
# a '/'-separated path, regardless of platform. 'dst' is a
# platform-specific path.
for skip in '.svn/', 'CVS/':
if src.startswith(skip) or '/' + skip in src:
return None
self.outputs.append(dst)
log.debug("Copying %s to %s", src, dst)
return dst
unpack_archive(self.source, self.target, skimmer)
def install_namespaces(self):
nsp = self._get_all_ns_packages()
if not nsp:
return
filename, ext = os.path.splitext(self.target)
filename += '-nspkg.pth'
self.outputs.append(filename)
log.info("Installing %s", filename)
lines = map(self._gen_nspkg_line, nsp)
if self.dry_run:
# always generate the lines, even in dry run
list(lines)
return
with open(filename, 'wt') as f:
f.writelines(lines)
_nspkg_tmpl = (
"import sys, types, os",
"p = os.path.join(sys._getframe(1).f_locals['sitedir'], *%(pth)r)",
"ie = os.path.exists(os.path.join(p,'__init__.py'))",
"m = not ie and "
"sys.modules.setdefault(%(pkg)r, types.ModuleType(%(pkg)r))",
"mp = (m or []) and m.__dict__.setdefault('__path__',[])",
"(p not in mp) and mp.append(p)",
)
"lines for the namespace installer"
_nspkg_tmpl_multi = (
'm and setattr(sys.modules[%(parent)r], %(child)r, m)',
)
"additional line(s) when a parent package is indicated"
@classmethod
def _gen_nspkg_line(cls, pkg):
# ensure pkg is not a unicode string under Python 2.7
pkg = str(pkg)
pth = tuple(pkg.split('.'))
tmpl_lines = cls._nspkg_tmpl
parent, sep, child = pkg.rpartition('.')
if parent:
tmpl_lines += cls._nspkg_tmpl_multi
return ';'.join(tmpl_lines) % locals() + '\n'
def _get_all_ns_packages(self):
"""Return sorted list of all package namespaces"""
nsp = set()
for pkg in self.distribution.namespace_packages or []:
pkg = pkg.split('.')
while pkg:
nsp.add('.'.join(pkg))
pkg.pop()
return sorted(nsp)
setuptools-20.7.0/setuptools/command/install_lib.py 0000664 0001750 0001750 00000007377 12702524020 023402 0 ustar travis travis 0000000 0000000 import os
import imp
from itertools import product, starmap
import distutils.command.install_lib as orig
class install_lib(orig.install_lib):
"""Don't add compiled flags to filenames of non-Python files"""
def run(self):
self.build()
outfiles = self.install()
if outfiles is not None:
# always compile, in case we have any extension stubs to deal with
self.byte_compile(outfiles)
def get_exclusions(self):
"""
Return a collections.Sized collections.Container of paths to be
excluded for single_version_externally_managed installations.
"""
all_packages = (
pkg
for ns_pkg in self._get_SVEM_NSPs()
for pkg in self._all_packages(ns_pkg)
)
excl_specs = product(all_packages, self._gen_exclusion_paths())
return set(starmap(self._exclude_pkg_path, excl_specs))
def _exclude_pkg_path(self, pkg, exclusion_path):
"""
Given a package name and exclusion path within that package,
compute the full exclusion path.
"""
parts = pkg.split('.') + [exclusion_path]
return os.path.join(self.install_dir, *parts)
@staticmethod
def _all_packages(pkg_name):
"""
>>> list(install_lib._all_packages('foo.bar.baz'))
['foo.bar.baz', 'foo.bar', 'foo']
"""
while pkg_name:
yield pkg_name
pkg_name, sep, child = pkg_name.rpartition('.')
def _get_SVEM_NSPs(self):
"""
Get namespace packages (list) but only for
single_version_externally_managed installations and empty otherwise.
"""
# TODO: is it necessary to short-circuit here? i.e. what's the cost
# if get_finalized_command is called even when namespace_packages is
# False?
if not self.distribution.namespace_packages:
return []
install_cmd = self.get_finalized_command('install')
svem = install_cmd.single_version_externally_managed
return self.distribution.namespace_packages if svem else []
@staticmethod
def _gen_exclusion_paths():
"""
Generate file paths to be excluded for namespace packages (bytecode
cache files).
"""
# always exclude the package module itself
yield '__init__.py'
yield '__init__.pyc'
yield '__init__.pyo'
if not hasattr(imp, 'get_tag'):
return
base = os.path.join('__pycache__', '__init__.' + imp.get_tag())
yield base + '.pyc'
yield base + '.pyo'
yield base + '.opt-1.pyc'
yield base + '.opt-2.pyc'
def copy_tree(
self, infile, outfile,
preserve_mode=1, preserve_times=1, preserve_symlinks=0, level=1
):
assert preserve_mode and preserve_times and not preserve_symlinks
exclude = self.get_exclusions()
if not exclude:
return orig.install_lib.copy_tree(self, infile, outfile)
# Exclude namespace package __init__.py* files from the output
from setuptools.archive_util import unpack_directory
from distutils import log
outfiles = []
def pf(src, dst):
if dst in exclude:
log.warn("Skipping installation of %s (namespace package)",
dst)
return False
log.info("copying %s -> %s", src, os.path.dirname(dst))
outfiles.append(dst)
return dst
unpack_directory(infile, outfile, pf)
return outfiles
def get_outputs(self):
outputs = orig.install_lib.get_outputs(self)
exclude = self.get_exclusions()
if exclude:
return [f for f in outputs if f not in exclude]
return outputs
setuptools-20.7.0/setuptools/command/install_scripts.py 0000775 0001750 0001750 00000004267 12702524020 024321 0 ustar travis travis 0000000 0000000 from distutils import log
import distutils.command.install_scripts as orig
import os
from pkg_resources import Distribution, PathMetadata, ensure_directory
class install_scripts(orig.install_scripts):
"""Do normal script install, plus any egg_info wrapper scripts"""
def initialize_options(self):
orig.install_scripts.initialize_options(self)
self.no_ep = False
def run(self):
import setuptools.command.easy_install as ei
self.run_command("egg_info")
if self.distribution.scripts:
orig.install_scripts.run(self) # run first to set up self.outfiles
else:
self.outfiles = []
if self.no_ep:
# don't install entry point scripts into .egg file!
return
ei_cmd = self.get_finalized_command("egg_info")
dist = Distribution(
ei_cmd.egg_base, PathMetadata(ei_cmd.egg_base, ei_cmd.egg_info),
ei_cmd.egg_name, ei_cmd.egg_version,
)
bs_cmd = self.get_finalized_command('build_scripts')
exec_param = getattr(bs_cmd, 'executable', None)
bw_cmd = self.get_finalized_command("bdist_wininst")
is_wininst = getattr(bw_cmd, '_is_running', False)
writer = ei.ScriptWriter
if is_wininst:
exec_param = "python.exe"
writer = ei.WindowsScriptWriter
# resolve the writer to the environment
writer = writer.best()
cmd = writer.command_spec_class.best().from_param(exec_param)
for args in writer.get_args(dist, cmd.as_header()):
self.write_script(*args)
def write_script(self, script_name, contents, mode="t", *ignored):
"""Write an executable file to the scripts directory"""
from setuptools.command.easy_install import chmod, current_umask
log.info("Installing %s script to %s", script_name, self.install_dir)
target = os.path.join(self.install_dir, script_name)
self.outfiles.append(target)
mask = current_umask()
if not self.dry_run:
ensure_directory(target)
f = open(target, "w" + mode)
f.write(contents)
f.close()
chmod(target, 0o777 - mask)
setuptools-20.7.0/setuptools/command/launcher manifest.xml 0000664 0001750 0001750 00000001164 12702524020 024632 0 ustar travis travis 0000000 0000000
setuptools-20.7.0/setuptools/command/register.py 0000775 0001750 0001750 00000000416 12702524020 022720 0 ustar travis travis 0000000 0000000 import distutils.command.register as orig
class register(orig.register):
__doc__ = orig.register.__doc__
def run(self):
# Make sure that we are using valid current name/version info
self.run_command('egg_info')
orig.register.run(self)
setuptools-20.7.0/setuptools/command/rotate.py 0000775 0001750 0001750 00000003766 12702524020 022405 0 ustar travis travis 0000000 0000000 from distutils.util import convert_path
from distutils import log
from distutils.errors import DistutilsOptionError
import os
from setuptools.extern import six
from setuptools import Command
class rotate(Command):
"""Delete older distributions"""
description = "delete older distributions, keeping N newest files"
user_options = [
('match=', 'm', "patterns to match (required)"),
('dist-dir=', 'd', "directory where the distributions are"),
('keep=', 'k', "number of matching distributions to keep"),
]
boolean_options = []
def initialize_options(self):
self.match = None
self.dist_dir = None
self.keep = None
def finalize_options(self):
if self.match is None:
raise DistutilsOptionError(
"Must specify one or more (comma-separated) match patterns "
"(e.g. '.zip' or '.egg')"
)
if self.keep is None:
raise DistutilsOptionError("Must specify number of files to keep")
try:
self.keep = int(self.keep)
except ValueError:
raise DistutilsOptionError("--keep must be an integer")
if isinstance(self.match, six.string_types):
self.match = [
convert_path(p.strip()) for p in self.match.split(',')
]
self.set_undefined_options('bdist', ('dist_dir', 'dist_dir'))
def run(self):
self.run_command("egg_info")
from glob import glob
for pattern in self.match:
pattern = self.distribution.get_name() + '*' + pattern
files = glob(os.path.join(self.dist_dir, pattern))
files = [(os.path.getmtime(f), f) for f in files]
files.sort()
files.reverse()
log.info("%d file(s) matching %s", len(files), pattern)
files = files[self.keep:]
for (t, f) in files:
log.info("Deleting %s", f)
if not self.dry_run:
os.unlink(f)
setuptools-20.7.0/setuptools/command/saveopts.py 0000775 0001750 0001750 00000001222 12702524020 022734 0 ustar travis travis 0000000 0000000 from setuptools.command.setopt import edit_config, option_base
class saveopts(option_base):
"""Save command-line options to a file"""
description = "save supplied options to setup.cfg or other config file"
def run(self):
dist = self.distribution
settings = {}
for cmd in dist.command_options:
if cmd == 'saveopts':
continue # don't save our own options!
for opt, (src, val) in dist.get_option_dict(cmd).items():
if src == "command line":
settings.setdefault(cmd, {})[opt] = val
edit_config(self.filename, settings, self.dry_run)
setuptools-20.7.0/setuptools/command/sdist.py 0000775 0001750 0001750 00000015612 12702524020 022226 0 ustar travis travis 0000000 0000000 from glob import glob
from distutils import log
import distutils.command.sdist as orig
import os
import sys
import io
from setuptools.extern import six
from setuptools.utils import cs_path_exists
import pkg_resources
READMES = 'README', 'README.rst', 'README.txt'
_default_revctrl = list
def walk_revctrl(dirname=''):
"""Find all files under revision control"""
for ep in pkg_resources.iter_entry_points('setuptools.file_finders'):
for item in ep.load()(dirname):
yield item
class sdist(orig.sdist):
"""Smart sdist that finds anything supported by revision control"""
user_options = [
('formats=', None,
"formats for source distribution (comma-separated list)"),
('keep-temp', 'k',
"keep the distribution tree around after creating " +
"archive file(s)"),
('dist-dir=', 'd',
"directory to put the source distribution archive(s) in "
"[default: dist]"),
]
negative_opt = {}
def run(self):
self.run_command('egg_info')
ei_cmd = self.get_finalized_command('egg_info')
self.filelist = ei_cmd.filelist
self.filelist.append(os.path.join(ei_cmd.egg_info, 'SOURCES.txt'))
self.check_readme()
# Run sub commands
for cmd_name in self.get_sub_commands():
self.run_command(cmd_name)
# Call check_metadata only if no 'check' command
# (distutils <= 2.6)
import distutils.command
if 'check' not in distutils.command.__all__:
self.check_metadata()
self.make_distribution()
dist_files = getattr(self.distribution, 'dist_files', [])
for file in self.archive_files:
data = ('sdist', '', file)
if data not in dist_files:
dist_files.append(data)
def __read_template_hack(self):
# This grody hack closes the template file (MANIFEST.in) if an
# exception occurs during read_template.
# Doing so prevents an error when easy_install attempts to delete the
# file.
try:
orig.sdist.read_template(self)
except:
_, _, tb = sys.exc_info()
tb.tb_next.tb_frame.f_locals['template'].close()
raise
# Beginning with Python 2.7.2, 3.1.4, and 3.2.1, this leaky file handle
# has been fixed, so only override the method if we're using an earlier
# Python.
has_leaky_handle = (
sys.version_info < (2, 7, 2)
or (3, 0) <= sys.version_info < (3, 1, 4)
or (3, 2) <= sys.version_info < (3, 2, 1)
)
if has_leaky_handle:
read_template = __read_template_hack
def add_defaults(self):
standards = [READMES,
self.distribution.script_name]
for fn in standards:
if isinstance(fn, tuple):
alts = fn
got_it = 0
for fn in alts:
if cs_path_exists(fn):
got_it = 1
self.filelist.append(fn)
break
if not got_it:
self.warn("standard file not found: should have one of " +
', '.join(alts))
else:
if cs_path_exists(fn):
self.filelist.append(fn)
else:
self.warn("standard file '%s' not found" % fn)
optional = ['test/test*.py', 'setup.cfg']
for pattern in optional:
files = list(filter(cs_path_exists, glob(pattern)))
if files:
self.filelist.extend(files)
# getting python files
if self.distribution.has_pure_modules():
build_py = self.get_finalized_command('build_py')
self.filelist.extend(build_py.get_source_files())
# This functionality is incompatible with include_package_data, and
# will in fact create an infinite recursion if include_package_data
# is True. Use of include_package_data will imply that
# distutils-style automatic handling of package_data is disabled
if not self.distribution.include_package_data:
for _, src_dir, _, filenames in build_py.data_files:
self.filelist.extend([os.path.join(src_dir, filename)
for filename in filenames])
if self.distribution.has_ext_modules():
build_ext = self.get_finalized_command('build_ext')
self.filelist.extend(build_ext.get_source_files())
if self.distribution.has_c_libraries():
build_clib = self.get_finalized_command('build_clib')
self.filelist.extend(build_clib.get_source_files())
if self.distribution.has_scripts():
build_scripts = self.get_finalized_command('build_scripts')
self.filelist.extend(build_scripts.get_source_files())
def check_readme(self):
for f in READMES:
if os.path.exists(f):
return
else:
self.warn(
"standard file not found: should have one of " +
', '.join(READMES)
)
def make_release_tree(self, base_dir, files):
orig.sdist.make_release_tree(self, base_dir, files)
# Save any egg_info command line options used to create this sdist
dest = os.path.join(base_dir, 'setup.cfg')
if hasattr(os, 'link') and os.path.exists(dest):
# unlink and re-copy, since it might be hard-linked, and
# we don't want to change the source version
os.unlink(dest)
self.copy_file('setup.cfg', dest)
self.get_finalized_command('egg_info').save_version_info(dest)
def _manifest_is_not_generated(self):
# check for special comment used in 2.7.1 and higher
if not os.path.isfile(self.manifest):
return False
with io.open(self.manifest, 'rb') as fp:
first_line = fp.readline()
return (first_line !=
'# file GENERATED by distutils, do NOT edit\n'.encode())
def read_manifest(self):
"""Read the manifest file (named by 'self.manifest') and use it to
fill in 'self.filelist', the list of files to include in the source
distribution.
"""
log.info("reading manifest file '%s'", self.manifest)
manifest = open(self.manifest, 'rbU')
for line in manifest:
# The manifest must contain UTF-8. See #303.
if six.PY3:
try:
line = line.decode('UTF-8')
except UnicodeDecodeError:
log.warn("%r not UTF-8 decodable -- skipping" % line)
continue
# ignore comments and blank lines
line = line.strip()
if line.startswith('#') or not line:
continue
self.filelist.append(line)
manifest.close()
setuptools-20.7.0/setuptools/command/setopt.py 0000775 0001750 0001750 00000011736 12702524020 022421 0 ustar travis travis 0000000 0000000 from distutils.util import convert_path
from distutils import log
from distutils.errors import DistutilsOptionError
import distutils
import os
from setuptools.extern.six.moves import configparser
from setuptools import Command
__all__ = ['config_file', 'edit_config', 'option_base', 'setopt']
def config_file(kind="local"):
"""Get the filename of the distutils, local, global, or per-user config
`kind` must be one of "local", "global", or "user"
"""
if kind == 'local':
return 'setup.cfg'
if kind == 'global':
return os.path.join(
os.path.dirname(distutils.__file__), 'distutils.cfg'
)
if kind == 'user':
dot = os.name == 'posix' and '.' or ''
return os.path.expanduser(convert_path("~/%spydistutils.cfg" % dot))
raise ValueError(
"config_file() type must be 'local', 'global', or 'user'", kind
)
def edit_config(filename, settings, dry_run=False):
"""Edit a configuration file to include `settings`
`settings` is a dictionary of dictionaries or ``None`` values, keyed by
command/section name. A ``None`` value means to delete the entire section,
while a dictionary lists settings to be changed or deleted in that section.
A setting of ``None`` means to delete that setting.
"""
log.debug("Reading configuration from %s", filename)
opts = configparser.RawConfigParser()
opts.read([filename])
for section, options in settings.items():
if options is None:
log.info("Deleting section [%s] from %s", section, filename)
opts.remove_section(section)
else:
if not opts.has_section(section):
log.debug("Adding new section [%s] to %s", section, filename)
opts.add_section(section)
for option, value in options.items():
if value is None:
log.debug(
"Deleting %s.%s from %s",
section, option, filename
)
opts.remove_option(section, option)
if not opts.options(section):
log.info("Deleting empty [%s] section from %s",
section, filename)
opts.remove_section(section)
else:
log.debug(
"Setting %s.%s to %r in %s",
section, option, value, filename
)
opts.set(section, option, value)
log.info("Writing %s", filename)
if not dry_run:
with open(filename, 'w') as f:
opts.write(f)
class option_base(Command):
"""Abstract base class for commands that mess with config files"""
user_options = [
('global-config', 'g',
"save options to the site-wide distutils.cfg file"),
('user-config', 'u',
"save options to the current user's pydistutils.cfg file"),
('filename=', 'f',
"configuration file to use (default=setup.cfg)"),
]
boolean_options = [
'global-config', 'user-config',
]
def initialize_options(self):
self.global_config = None
self.user_config = None
self.filename = None
def finalize_options(self):
filenames = []
if self.global_config:
filenames.append(config_file('global'))
if self.user_config:
filenames.append(config_file('user'))
if self.filename is not None:
filenames.append(self.filename)
if not filenames:
filenames.append(config_file('local'))
if len(filenames) > 1:
raise DistutilsOptionError(
"Must specify only one configuration file option",
filenames
)
self.filename, = filenames
class setopt(option_base):
"""Save command-line options to a file"""
description = "set an option in setup.cfg or another config file"
user_options = [
('command=', 'c', 'command to set an option for'),
('option=', 'o', 'option to set'),
('set-value=', 's', 'value of the option'),
('remove', 'r', 'remove (unset) the value'),
] + option_base.user_options
boolean_options = option_base.boolean_options + ['remove']
def initialize_options(self):
option_base.initialize_options(self)
self.command = None
self.option = None
self.set_value = None
self.remove = None
def finalize_options(self):
option_base.finalize_options(self)
if self.command is None or self.option is None:
raise DistutilsOptionError("Must specify --command *and* --option")
if self.set_value is None and not self.remove:
raise DistutilsOptionError("Must specify --set-value or --remove")
def run(self):
edit_config(
self.filename, {
self.command: {self.option.replace('-', '_'): self.set_value}
},
self.dry_run
)
setuptools-20.7.0/setuptools/command/test.py 0000664 0001750 0001750 00000015350 12702524020 022053 0 ustar travis travis 0000000 0000000 from distutils.errors import DistutilsOptionError
from unittest import TestLoader
import sys
from setuptools.extern import six
from setuptools.extern.six.moves import map
from pkg_resources import (resource_listdir, resource_exists, normalize_path,
working_set, _namespace_packages,
add_activation_listener, require, EntryPoint)
from setuptools import Command
from setuptools.py31compat import unittest_main
class ScanningLoader(TestLoader):
def loadTestsFromModule(self, module, pattern=None):
"""Return a suite of all tests cases contained in the given module
If the module is a package, load tests from all the modules in it.
If the module has an ``additional_tests`` function, call it and add
the return value to the tests.
"""
tests = []
tests.append(TestLoader.loadTestsFromModule(self, module))
if hasattr(module, "additional_tests"):
tests.append(module.additional_tests())
if hasattr(module, '__path__'):
for file in resource_listdir(module.__name__, ''):
if file.endswith('.py') and file != '__init__.py':
submodule = module.__name__ + '.' + file[:-3]
else:
if resource_exists(module.__name__, file + '/__init__.py'):
submodule = module.__name__ + '.' + file
else:
continue
tests.append(self.loadTestsFromName(submodule))
if len(tests) != 1:
return self.suiteClass(tests)
else:
return tests[0] # don't create a nested suite for only one return
# adapted from jaraco.classes.properties:NonDataProperty
class NonDataProperty(object):
def __init__(self, fget):
self.fget = fget
def __get__(self, obj, objtype=None):
if obj is None:
return self
return self.fget(obj)
class test(Command):
"""Command to run unit tests after in-place build"""
description = "run unit tests after in-place build"
user_options = [
('test-module=', 'm', "Run 'test_suite' in specified module"),
('test-suite=', 's',
"Test suite to run (e.g. 'some_module.test_suite')"),
('test-runner=', 'r', "Test runner to use"),
]
def initialize_options(self):
self.test_suite = None
self.test_module = None
self.test_loader = None
self.test_runner = None
def finalize_options(self):
if self.test_suite and self.test_module:
msg = "You may specify a module or a suite, but not both"
raise DistutilsOptionError(msg)
if self.test_suite is None:
if self.test_module is None:
self.test_suite = self.distribution.test_suite
else:
self.test_suite = self.test_module + ".test_suite"
if self.test_loader is None:
self.test_loader = getattr(self.distribution, 'test_loader', None)
if self.test_loader is None:
self.test_loader = "setuptools.command.test:ScanningLoader"
if self.test_runner is None:
self.test_runner = getattr(self.distribution, 'test_runner', None)
@NonDataProperty
def test_args(self):
return list(self._test_args())
def _test_args(self):
if self.verbose:
yield '--verbose'
if self.test_suite:
yield self.test_suite
def with_project_on_sys_path(self, func):
with_2to3 = six.PY3 and getattr(self.distribution, 'use_2to3', False)
if with_2to3:
# If we run 2to3 we can not do this inplace:
# Ensure metadata is up-to-date
self.reinitialize_command('build_py', inplace=0)
self.run_command('build_py')
bpy_cmd = self.get_finalized_command("build_py")
build_path = normalize_path(bpy_cmd.build_lib)
# Build extensions
self.reinitialize_command('egg_info', egg_base=build_path)
self.run_command('egg_info')
self.reinitialize_command('build_ext', inplace=0)
self.run_command('build_ext')
else:
# Without 2to3 inplace works fine:
self.run_command('egg_info')
# Build extensions in-place
self.reinitialize_command('build_ext', inplace=1)
self.run_command('build_ext')
ei_cmd = self.get_finalized_command("egg_info")
old_path = sys.path[:]
old_modules = sys.modules.copy()
try:
sys.path.insert(0, normalize_path(ei_cmd.egg_base))
working_set.__init__()
add_activation_listener(lambda dist: dist.activate())
require('%s==%s' % (ei_cmd.egg_name, ei_cmd.egg_version))
func()
finally:
sys.path[:] = old_path
sys.modules.clear()
sys.modules.update(old_modules)
working_set.__init__()
def run(self):
if self.distribution.install_requires:
self.distribution.fetch_build_eggs(
self.distribution.install_requires)
if self.distribution.tests_require:
self.distribution.fetch_build_eggs(self.distribution.tests_require)
cmd = ' '.join(self._argv)
if self.dry_run:
self.announce('skipping "%s" (dry run)' % cmd)
else:
self.announce('running "%s"' % cmd)
self.with_project_on_sys_path(self.run_tests)
def run_tests(self):
# Purge modules under test from sys.modules. The test loader will
# re-import them from the build location. Required when 2to3 is used
# with namespace packages.
if six.PY3 and getattr(self.distribution, 'use_2to3', False):
module = self.test_suite.split('.')[0]
if module in _namespace_packages:
del_modules = []
if module in sys.modules:
del_modules.append(module)
module += '.'
for name in sys.modules:
if name.startswith(module):
del_modules.append(name)
list(map(sys.modules.__delitem__, del_modules))
unittest_main(
None, None, self._argv,
testLoader=self._resolve_as_ep(self.test_loader),
testRunner=self._resolve_as_ep(self.test_runner),
)
@property
def _argv(self):
return ['unittest'] + self.test_args
@staticmethod
def _resolve_as_ep(val):
"""
Load the indicated attribute value, called, as a as if it were
specified as an entry point.
"""
if val is None:
return
parsed = EntryPoint.parse("x=" + val)
return parsed.resolve()()
setuptools-20.7.0/setuptools/command/upload.py 0000664 0001750 0001750 00000001211 12702524020 022347 0 ustar travis travis 0000000 0000000 from distutils.command import upload as orig
class upload(orig.upload):
"""
Override default upload behavior to look up password
in the keyring if available.
"""
def finalize_options(self):
orig.upload.finalize_options(self)
self.password or self._load_password_from_keyring()
def _load_password_from_keyring(self):
"""
Attempt to load password from keyring. Suppress Exceptions.
"""
try:
keyring = __import__('keyring')
self.password = keyring.get_password(self.repository,
self.username)
except Exception:
pass
setuptools-20.7.0/setuptools/command/upload_docs.py 0000664 0001750 0001750 00000015237 12702524020 023374 0 ustar travis travis 0000000 0000000 # -*- coding: utf-8 -*-
"""upload_docs
Implements a Distutils 'upload_docs' subcommand (upload documentation to
PyPI's pythonhosted.org).
"""
from base64 import standard_b64encode
from distutils import log
from distutils.errors import DistutilsOptionError
import os
import socket
import zipfile
import tempfile
import shutil
from setuptools.extern import six
from setuptools.extern.six.moves import http_client, urllib
from pkg_resources import iter_entry_points
from .upload import upload
errors = 'surrogateescape' if six.PY3 else 'strict'
# This is not just a replacement for byte literals
# but works as a general purpose encoder
def b(s, encoding='utf-8'):
if isinstance(s, six.text_type):
return s.encode(encoding, errors)
return s
class upload_docs(upload):
description = 'Upload documentation to PyPI'
user_options = [
('repository=', 'r',
"url of repository [default: %s]" % upload.DEFAULT_REPOSITORY),
('show-response', None,
'display full response text from server'),
('upload-dir=', None, 'directory to upload'),
]
boolean_options = upload.boolean_options
def has_sphinx(self):
if self.upload_dir is None:
for ep in iter_entry_points('distutils.commands', 'build_sphinx'):
return True
sub_commands = [('build_sphinx', has_sphinx)]
def initialize_options(self):
upload.initialize_options(self)
self.upload_dir = None
self.target_dir = None
def finalize_options(self):
upload.finalize_options(self)
if self.upload_dir is None:
if self.has_sphinx():
build_sphinx = self.get_finalized_command('build_sphinx')
self.target_dir = build_sphinx.builder_target_dir
else:
build = self.get_finalized_command('build')
self.target_dir = os.path.join(build.build_base, 'docs')
else:
self.ensure_dirname('upload_dir')
self.target_dir = self.upload_dir
self.announce('Using upload directory %s' % self.target_dir)
def create_zipfile(self, filename):
zip_file = zipfile.ZipFile(filename, "w")
try:
self.mkpath(self.target_dir) # just in case
for root, dirs, files in os.walk(self.target_dir):
if root == self.target_dir and not files:
raise DistutilsOptionError(
"no files found in upload directory '%s'"
% self.target_dir)
for name in files:
full = os.path.join(root, name)
relative = root[len(self.target_dir):].lstrip(os.path.sep)
dest = os.path.join(relative, name)
zip_file.write(full, dest)
finally:
zip_file.close()
def run(self):
# Run sub commands
for cmd_name in self.get_sub_commands():
self.run_command(cmd_name)
tmp_dir = tempfile.mkdtemp()
name = self.distribution.metadata.get_name()
zip_file = os.path.join(tmp_dir, "%s.zip" % name)
try:
self.create_zipfile(zip_file)
self.upload_file(zip_file)
finally:
shutil.rmtree(tmp_dir)
def upload_file(self, filename):
f = open(filename, 'rb')
content = f.read()
f.close()
meta = self.distribution.metadata
data = {
':action': 'doc_upload',
'name': meta.get_name(),
'content': (os.path.basename(filename), content),
}
# set up the authentication
credentials = b(self.username + ':' + self.password)
credentials = standard_b64encode(credentials)
if six.PY3:
credentials = credentials.decode('ascii')
auth = "Basic " + credentials
# Build up the MIME payload for the POST data
boundary = '--------------GHSKFJDLGDS7543FJKLFHRE75642756743254'
sep_boundary = b('\n--') + b(boundary)
end_boundary = sep_boundary + b('--')
body = []
for key, values in six.iteritems(data):
title = '\nContent-Disposition: form-data; name="%s"' % key
# handle multiple entries for the same name
if not isinstance(values, list):
values = [values]
for value in values:
if type(value) is tuple:
title += '; filename="%s"' % value[0]
value = value[1]
else:
value = b(value)
body.append(sep_boundary)
body.append(b(title))
body.append(b("\n\n"))
body.append(value)
if value and value[-1:] == b('\r'):
body.append(b('\n')) # write an extra newline (lurve Macs)
body.append(end_boundary)
body.append(b("\n"))
body = b('').join(body)
self.announce("Submitting documentation to %s" % (self.repository),
log.INFO)
# build the Request
# We can't use urllib2 since we need to send the Basic
# auth right with the first request
schema, netloc, url, params, query, fragments = \
urllib.parse.urlparse(self.repository)
assert not params and not query and not fragments
if schema == 'http':
conn = http_client.HTTPConnection(netloc)
elif schema == 'https':
conn = http_client.HTTPSConnection(netloc)
else:
raise AssertionError("unsupported schema " + schema)
data = ''
try:
conn.connect()
conn.putrequest("POST", url)
content_type = 'multipart/form-data; boundary=%s' % boundary
conn.putheader('Content-type', content_type)
conn.putheader('Content-length', str(len(body)))
conn.putheader('Authorization', auth)
conn.endheaders()
conn.send(body)
except socket.error as e:
self.announce(str(e), log.ERROR)
return
r = conn.getresponse()
if r.status == 200:
self.announce('Server response (%s): %s' % (r.status, r.reason),
log.INFO)
elif r.status == 301:
location = r.getheader('Location')
if location is None:
location = 'https://pythonhosted.org/%s/' % meta.get_name()
self.announce('Upload successful. Visit %s' % location,
log.INFO)
else:
self.announce('Upload failed (%s): %s' % (r.status, r.reason),
log.ERROR)
if self.show_response:
print('-' * 75, r.read(), '-' * 75)
setuptools-20.7.0/setuptools/extern/ 0000775 0001750 0001750 00000000000 12702524134 020413 5 ustar travis travis 0000000 0000000 setuptools-20.7.0/setuptools/extern/__init__.py 0000664 0001750 0001750 00000000204 12702524020 022512 0 ustar travis travis 0000000 0000000 from pkg_resources.extern import VendorImporter
names = 'six',
VendorImporter(__name__, names, 'pkg_resources._vendor').install()
setuptools-20.7.0/setuptools/tests/ 0000775 0001750 0001750 00000000000 12702524134 020250 5 ustar travis travis 0000000 0000000 setuptools-20.7.0/setuptools/tests/indexes/ 0000775 0001750 0001750 00000000000 12702524134 021707 5 ustar travis travis 0000000 0000000 setuptools-20.7.0/setuptools/tests/indexes/test_links_priority/ 0000775 0001750 0001750 00000000000 12702524134 026027 5 ustar travis travis 0000000 0000000 setuptools-20.7.0/setuptools/tests/indexes/test_links_priority/simple/ 0000775 0001750 0001750 00000000000 12702524134 027320 5 ustar travis travis 0000000 0000000 setuptools-20.7.0/setuptools/tests/indexes/test_links_priority/simple/foobar/ 0000775 0001750 0001750 00000000000 12702524134 030570 5 ustar travis travis 0000000 0000000 setuptools-20.7.0/setuptools/tests/indexes/test_links_priority/simple/foobar/index.html 0000664 0001750 0001750 00000000256 12702524020 032562 0 ustar travis travis 0000000 0000000
foobar-0.1.tar.gz
external homepage
setuptools-20.7.0/setuptools/tests/indexes/test_links_priority/external.html 0000664 0001750 0001750 00000000134 12702524020 030527 0 ustar travis travis 0000000 0000000
bad old link
setuptools-20.7.0/setuptools/tests/__init__.py 0000664 0001750 0001750 00000026122 12702524020 022356 0 ustar travis travis 0000000 0000000 """Tests for the 'setuptools' package"""
import sys
import os
import distutils.core
import distutils.cmd
from distutils.errors import DistutilsOptionError, DistutilsPlatformError
from distutils.errors import DistutilsSetupError
from distutils.core import Extension
from distutils.version import LooseVersion
from setuptools.extern import six
import pytest
import setuptools.dist
import setuptools.depends as dep
from setuptools import Feature
from setuptools.depends import Require
c_type = os.environ.get("LC_CTYPE", os.environ.get("LC_ALL"))
is_ascii = c_type in ("C", "POSIX")
fail_on_ascii = pytest.mark.xfail(is_ascii, reason="Test fails in this locale")
def makeSetup(**args):
"""Return distribution from 'setup(**args)', without executing commands"""
distutils.core._setup_stop_after = "commandline"
# Don't let system command line leak into tests!
args.setdefault('script_args',['install'])
try:
return setuptools.setup(**args)
finally:
distutils.core._setup_stop_after = None
needs_bytecode = pytest.mark.skipif(
not hasattr(dep, 'get_module_constant'),
reason="bytecode support not available",
)
class TestDepends:
def testExtractConst(self):
if not hasattr(dep, 'extract_constant'):
# skip on non-bytecode platforms
return
def f1():
global x, y, z
x = "test"
y = z
fc = six.get_function_code(f1)
# unrecognized name
assert dep.extract_constant(fc,'q', -1) is None
# constant assigned
dep.extract_constant(fc,'x', -1) == "test"
# expression assigned
dep.extract_constant(fc,'y', -1) == -1
# recognized name, not assigned
dep.extract_constant(fc,'z', -1) is None
def testFindModule(self):
with pytest.raises(ImportError):
dep.find_module('no-such.-thing')
with pytest.raises(ImportError):
dep.find_module('setuptools.non-existent')
f,p,i = dep.find_module('setuptools.tests')
f.close()
@needs_bytecode
def testModuleExtract(self):
from email import __version__
assert dep.get_module_constant('email','__version__') == __version__
assert dep.get_module_constant('sys','version') == sys.version
assert dep.get_module_constant('setuptools.tests','__doc__') == __doc__
@needs_bytecode
def testRequire(self):
req = Require('Email','1.0.3','email')
assert req.name == 'Email'
assert req.module == 'email'
assert req.requested_version == '1.0.3'
assert req.attribute == '__version__'
assert req.full_name() == 'Email-1.0.3'
from email import __version__
assert req.get_version() == __version__
assert req.version_ok('1.0.9')
assert not req.version_ok('0.9.1')
assert not req.version_ok('unknown')
assert req.is_present()
assert req.is_current()
req = Require('Email 3000','03000','email',format=LooseVersion)
assert req.is_present()
assert not req.is_current()
assert not req.version_ok('unknown')
req = Require('Do-what-I-mean','1.0','d-w-i-m')
assert not req.is_present()
assert not req.is_current()
req = Require('Tests', None, 'tests', homepage="http://example.com")
assert req.format is None
assert req.attribute is None
assert req.requested_version is None
assert req.full_name() == 'Tests'
assert req.homepage == 'http://example.com'
paths = [os.path.dirname(p) for p in __path__]
assert req.is_present(paths)
assert req.is_current(paths)
class TestDistro:
def setup_method(self, method):
self.e1 = Extension('bar.ext',['bar.c'])
self.e2 = Extension('c.y', ['y.c'])
self.dist = makeSetup(
packages=['a', 'a.b', 'a.b.c', 'b', 'c'],
py_modules=['b.d','x'],
ext_modules = (self.e1, self.e2),
package_dir = {},
)
def testDistroType(self):
assert isinstance(self.dist,setuptools.dist.Distribution)
def testExcludePackage(self):
self.dist.exclude_package('a')
assert self.dist.packages == ['b','c']
self.dist.exclude_package('b')
assert self.dist.packages == ['c']
assert self.dist.py_modules == ['x']
assert self.dist.ext_modules == [self.e1, self.e2]
self.dist.exclude_package('c')
assert self.dist.packages == []
assert self.dist.py_modules == ['x']
assert self.dist.ext_modules == [self.e1]
# test removals from unspecified options
makeSetup().exclude_package('x')
def testIncludeExclude(self):
# remove an extension
self.dist.exclude(ext_modules=[self.e1])
assert self.dist.ext_modules == [self.e2]
# add it back in
self.dist.include(ext_modules=[self.e1])
assert self.dist.ext_modules == [self.e2, self.e1]
# should not add duplicate
self.dist.include(ext_modules=[self.e1])
assert self.dist.ext_modules == [self.e2, self.e1]
def testExcludePackages(self):
self.dist.exclude(packages=['c','b','a'])
assert self.dist.packages == []
assert self.dist.py_modules == ['x']
assert self.dist.ext_modules == [self.e1]
def testEmpty(self):
dist = makeSetup()
dist.include(packages=['a'], py_modules=['b'], ext_modules=[self.e2])
dist = makeSetup()
dist.exclude(packages=['a'], py_modules=['b'], ext_modules=[self.e2])
def testContents(self):
assert self.dist.has_contents_for('a')
self.dist.exclude_package('a')
assert not self.dist.has_contents_for('a')
assert self.dist.has_contents_for('b')
self.dist.exclude_package('b')
assert not self.dist.has_contents_for('b')
assert self.dist.has_contents_for('c')
self.dist.exclude_package('c')
assert not self.dist.has_contents_for('c')
def testInvalidIncludeExclude(self):
with pytest.raises(DistutilsSetupError):
self.dist.include(nonexistent_option='x')
with pytest.raises(DistutilsSetupError):
self.dist.exclude(nonexistent_option='x')
with pytest.raises(DistutilsSetupError):
self.dist.include(packages={'x':'y'})
with pytest.raises(DistutilsSetupError):
self.dist.exclude(packages={'x':'y'})
with pytest.raises(DistutilsSetupError):
self.dist.include(ext_modules={'x':'y'})
with pytest.raises(DistutilsSetupError):
self.dist.exclude(ext_modules={'x':'y'})
with pytest.raises(DistutilsSetupError):
self.dist.include(package_dir=['q'])
with pytest.raises(DistutilsSetupError):
self.dist.exclude(package_dir=['q'])
class TestFeatures:
def setup_method(self, method):
self.req = Require('Distutils','1.0.3','distutils')
self.dist = makeSetup(
features={
'foo': Feature("foo",standard=True,require_features=['baz',self.req]),
'bar': Feature("bar", standard=True, packages=['pkg.bar'],
py_modules=['bar_et'], remove=['bar.ext'],
),
'baz': Feature(
"baz", optional=False, packages=['pkg.baz'],
scripts = ['scripts/baz_it'],
libraries=[('libfoo','foo/foofoo.c')]
),
'dwim': Feature("DWIM", available=False, remove='bazish'),
},
script_args=['--without-bar', 'install'],
packages = ['pkg.bar', 'pkg.foo'],
py_modules = ['bar_et', 'bazish'],
ext_modules = [Extension('bar.ext',['bar.c'])]
)
def testDefaults(self):
assert not Feature(
"test",standard=True,remove='x',available=False
).include_by_default()
assert Feature("test",standard=True,remove='x').include_by_default()
# Feature must have either kwargs, removes, or require_features
with pytest.raises(DistutilsSetupError):
Feature("test")
def testAvailability(self):
with pytest.raises(DistutilsPlatformError):
self.dist.features['dwim'].include_in(self.dist)
def testFeatureOptions(self):
dist = self.dist
assert (
('with-dwim',None,'include DWIM') in dist.feature_options
)
assert (
('without-dwim',None,'exclude DWIM (default)') in dist.feature_options
)
assert (
('with-bar',None,'include bar (default)') in dist.feature_options
)
assert (
('without-bar',None,'exclude bar') in dist.feature_options
)
assert dist.feature_negopt['without-foo'] == 'with-foo'
assert dist.feature_negopt['without-bar'] == 'with-bar'
assert dist.feature_negopt['without-dwim'] == 'with-dwim'
assert (not 'without-baz' in dist.feature_negopt)
def testUseFeatures(self):
dist = self.dist
assert dist.with_foo == 1
assert dist.with_bar == 0
assert dist.with_baz == 1
assert (not 'bar_et' in dist.py_modules)
assert (not 'pkg.bar' in dist.packages)
assert ('pkg.baz' in dist.packages)
assert ('scripts/baz_it' in dist.scripts)
assert (('libfoo','foo/foofoo.c') in dist.libraries)
assert dist.ext_modules == []
assert dist.require_features == [self.req]
# If we ask for bar, it should fail because we explicitly disabled
# it on the command line
with pytest.raises(DistutilsOptionError):
dist.include_feature('bar')
def testFeatureWithInvalidRemove(self):
with pytest.raises(SystemExit):
makeSetup(features={'x':Feature('x', remove='y')})
class TestCommandTests:
def testTestIsCommand(self):
test_cmd = makeSetup().get_command_obj('test')
assert (isinstance(test_cmd, distutils.cmd.Command))
def testLongOptSuiteWNoDefault(self):
ts1 = makeSetup(script_args=['test','--test-suite=foo.tests.suite'])
ts1 = ts1.get_command_obj('test')
ts1.ensure_finalized()
assert ts1.test_suite == 'foo.tests.suite'
def testDefaultSuite(self):
ts2 = makeSetup(test_suite='bar.tests.suite').get_command_obj('test')
ts2.ensure_finalized()
assert ts2.test_suite == 'bar.tests.suite'
def testDefaultWModuleOnCmdLine(self):
ts3 = makeSetup(
test_suite='bar.tests',
script_args=['test','-m','foo.tests']
).get_command_obj('test')
ts3.ensure_finalized()
assert ts3.test_module == 'foo.tests'
assert ts3.test_suite == 'foo.tests.test_suite'
def testConflictingOptions(self):
ts4 = makeSetup(
script_args=['test','-m','bar.tests', '-s','foo.tests.suite']
).get_command_obj('test')
with pytest.raises(DistutilsOptionError):
ts4.ensure_finalized()
def testNoSuite(self):
ts5 = makeSetup().get_command_obj('test')
ts5.ensure_finalized()
assert ts5.test_suite == None
setuptools-20.7.0/setuptools/tests/contexts.py 0000664 0001750 0001750 00000004134 12702524020 022465 0 ustar travis travis 0000000 0000000 import tempfile
import os
import shutil
import sys
import contextlib
import site
from setuptools.extern import six
import pkg_resources
@contextlib.contextmanager
def tempdir(cd=lambda dir:None, **kwargs):
temp_dir = tempfile.mkdtemp(**kwargs)
orig_dir = os.getcwd()
try:
cd(temp_dir)
yield temp_dir
finally:
cd(orig_dir)
shutil.rmtree(temp_dir)
@contextlib.contextmanager
def environment(**replacements):
"""
In a context, patch the environment with replacements. Pass None values
to clear the values.
"""
saved = dict(
(key, os.environ[key])
for key in replacements
if key in os.environ
)
# remove values that are null
remove = (key for (key, value) in replacements.items() if value is None)
for key in list(remove):
os.environ.pop(key, None)
replacements.pop(key)
os.environ.update(replacements)
try:
yield saved
finally:
for key in replacements:
os.environ.pop(key, None)
os.environ.update(saved)
@contextlib.contextmanager
def quiet():
"""
Redirect stdout/stderr to StringIO objects to prevent console output from
distutils commands.
"""
old_stdout = sys.stdout
old_stderr = sys.stderr
new_stdout = sys.stdout = six.StringIO()
new_stderr = sys.stderr = six.StringIO()
try:
yield new_stdout, new_stderr
finally:
new_stdout.seek(0)
new_stderr.seek(0)
sys.stdout = old_stdout
sys.stderr = old_stderr
@contextlib.contextmanager
def save_user_site_setting():
saved = site.ENABLE_USER_SITE
try:
yield saved
finally:
site.ENABLE_USER_SITE = saved
@contextlib.contextmanager
def save_pkg_resources_state():
pr_state = pkg_resources.__getstate__()
# also save sys.path
sys_path = sys.path[:]
try:
yield pr_state, sys_path
finally:
sys.path[:] = sys_path
pkg_resources.__setstate__(pr_state)
@contextlib.contextmanager
def suppress_exceptions(*excs):
try:
yield
except excs:
pass
setuptools-20.7.0/setuptools/tests/environment.py 0000664 0001750 0001750 00000003113 12702524020 023156 0 ustar travis travis 0000000 0000000 import os
import sys
import unicodedata
from subprocess import Popen as _Popen, PIPE as _PIPE
def _which_dirs(cmd):
result = set()
for path in os.environ.get('PATH', '').split(os.pathsep):
filename = os.path.join(path, cmd)
if os.access(filename, os.X_OK):
result.add(path)
return result
def run_setup_py(cmd, pypath=None, path=None,
data_stream=0, env=None):
"""
Execution command for tests, separate from those used by the
code directly to prevent accidental behavior issues
"""
if env is None:
env = dict()
for envname in os.environ:
env[envname] = os.environ[envname]
#override the python path if needed
if pypath is not None:
env["PYTHONPATH"] = pypath
#overide the execution path if needed
if path is not None:
env["PATH"] = path
if not env.get("PATH", ""):
env["PATH"] = _which_dirs("tar").union(_which_dirs("gzip"))
env["PATH"] = os.pathsep.join(env["PATH"])
cmd = [sys.executable, "setup.py"] + list(cmd)
# http://bugs.python.org/issue8557
shell = sys.platform == 'win32'
try:
proc = _Popen(
cmd, stdout=_PIPE, stderr=_PIPE, shell=shell, env=env,
)
data = proc.communicate()[data_stream]
except OSError:
return 1, ''
#decode the console string if needed
if hasattr(data, "decode"):
# use the default encoding
data = data.decode()
data = unicodedata.normalize('NFC', data)
#communciate calls wait()
return proc.returncode, data
setuptools-20.7.0/setuptools/tests/files.py 0000664 0001750 0001750 00000001646 12702524020 021725 0 ustar travis travis 0000000 0000000 import os
def build_files(file_defs, prefix=""):
"""
Build a set of files/directories, as described by the file_defs dictionary.
Each key/value pair in the dictionary is interpreted as a filename/contents
pair. If the contents value is a dictionary, a directory is created, and the
dictionary interpreted as the files within it, recursively.
For example:
{"README.txt": "A README file",
"foo": {
"__init__.py": "",
"bar": {
"__init__.py": "",
},
"baz.py": "# Some code",
}
}
"""
for name, contents in file_defs.items():
full_name = os.path.join(prefix, name)
if isinstance(contents, dict):
if not os.path.exists(full_name):
os.makedirs(full_name)
build_files(contents, prefix=full_name)
else:
with open(full_name, 'w') as f:
f.write(contents)
setuptools-20.7.0/setuptools/tests/fixtures.py 0000664 0001750 0001750 00000001225 12702524020 022465 0 ustar travis travis 0000000 0000000 try:
from unittest import mock
except ImportError:
import mock
import pytest
from . import contexts
@pytest.yield_fixture
def user_override():
"""
Override site.USER_BASE and site.USER_SITE with temporary directories in
a context.
"""
with contexts.tempdir() as user_base:
with mock.patch('site.USER_BASE', user_base):
with contexts.tempdir() as user_site:
with mock.patch('site.USER_SITE', user_site):
with contexts.save_user_site_setting():
yield
@pytest.yield_fixture
def tmpdir_cwd(tmpdir):
with tmpdir.as_cwd() as orig:
yield orig
setuptools-20.7.0/setuptools/tests/py26compat.py 0000664 0001750 0001750 00000000525 12702524020 022622 0 ustar travis travis 0000000 0000000 import sys
import tarfile
import contextlib
def _tarfile_open_ex(*args, **kwargs):
"""
Extend result as a context manager.
"""
return contextlib.closing(tarfile.open(*args, **kwargs))
if sys.version_info[:2] < (2, 7) or (3, 0) <= sys.version_info[:2] < (3, 2):
tarfile_open = _tarfile_open_ex
else:
tarfile_open = tarfile.open
setuptools-20.7.0/setuptools/tests/script-with-bom.py 0000664 0001750 0001750 00000000056 12702524020 023645 0 ustar travis travis 0000000 0000000 # -*- coding: utf-8 -*-
result = 'passed'
setuptools-20.7.0/setuptools/tests/server.py 0000664 0001750 0001750 00000004052 12702524020 022123 0 ustar travis travis 0000000 0000000 """Basic http server for tests to simulate PyPI or custom indexes
"""
import time
import threading
from setuptools.extern.six.moves import BaseHTTPServer, SimpleHTTPServer
class IndexServer(BaseHTTPServer.HTTPServer):
"""Basic single-threaded http server simulating a package index
You can use this server in unittest like this::
s = IndexServer()
s.start()
index_url = s.base_url() + 'mytestindex'
# do some test requests to the index
# The index files should be located in setuptools/tests/indexes
s.stop()
"""
def __init__(self, server_address=('', 0),
RequestHandlerClass=SimpleHTTPServer.SimpleHTTPRequestHandler):
BaseHTTPServer.HTTPServer.__init__(self, server_address,
RequestHandlerClass)
self._run = True
def start(self):
self.thread = threading.Thread(target=self.serve_forever)
self.thread.start()
def stop(self):
"Stop the server"
# Let the server finish the last request and wait for a new one.
time.sleep(0.1)
self.shutdown()
self.thread.join()
self.socket.close()
def base_url(self):
port = self.server_port
return 'http://127.0.0.1:%s/setuptools/tests/indexes/' % port
class RequestRecorder(BaseHTTPServer.BaseHTTPRequestHandler):
def do_GET(self):
requests = vars(self.server).setdefault('requests', [])
requests.append(self)
self.send_response(200, 'OK')
class MockServer(BaseHTTPServer.HTTPServer, threading.Thread):
"""
A simple HTTP Server that records the requests made to it.
"""
def __init__(self, server_address=('', 0),
RequestHandlerClass=RequestRecorder):
BaseHTTPServer.HTTPServer.__init__(self, server_address,
RequestHandlerClass)
threading.Thread.__init__(self)
self.setDaemon(True)
self.requests = []
def run(self):
self.serve_forever()
@property
def url(self):
return 'http://localhost:%(server_port)s/' % vars(self)
setuptools-20.7.0/setuptools/tests/test_bdist_egg.py 0000664 0001750 0001750 00000001761 12702524020 023607 0 ustar travis travis 0000000 0000000 """develop tests
"""
import os
import re
import pytest
from setuptools.dist import Distribution
from . import contexts
SETUP_PY = """\
from setuptools import setup
setup(name='foo', py_modules=['hi'])
"""
@pytest.yield_fixture
def setup_context(tmpdir):
with (tmpdir/'setup.py').open('w') as f:
f.write(SETUP_PY)
with (tmpdir/'hi.py').open('w') as f:
f.write('1\n')
with tmpdir.as_cwd():
yield tmpdir
class Test:
def test_bdist_egg(self, setup_context, user_override):
dist = Distribution(dict(
script_name='setup.py',
script_args=['bdist_egg'],
name='foo',
py_modules=['hi']
))
os.makedirs(os.path.join('build', 'src'))
with contexts.quiet():
dist.parse_command_line()
dist.run_commands()
# let's see if we got our egg link at the right place
[content] = os.listdir('dist')
assert re.match('foo-0.0.0-py[23].\d.egg$', content)
setuptools-20.7.0/setuptools/tests/test_build_ext.py 0000664 0001750 0001750 00000001072 12702524020 023632 0 ustar travis travis 0000000 0000000 import distutils.command.build_ext as orig
from setuptools.command.build_ext import build_ext
from setuptools.dist import Distribution
class TestBuildExt:
def test_get_ext_filename(self):
"""
Setuptools needs to give back the same
result as distutils, even if the fullname
is not in ext_map.
"""
dist = Distribution()
cmd = build_ext(dist)
cmd.ext_map['foo/bar'] = ''
res = cmd.get_ext_filename('foo')
wanted = orig.build_ext.get_ext_filename(cmd, 'foo')
assert res == wanted
setuptools-20.7.0/setuptools/tests/test_develop.py 0000664 0001750 0001750 00000006204 12702524020 023313 0 ustar travis travis 0000000 0000000 """develop tests
"""
import os
import site
import sys
import io
from setuptools.extern import six
import pytest
from setuptools.command.develop import develop
from setuptools.dist import Distribution
from . import contexts
SETUP_PY = """\
from setuptools import setup
setup(name='foo',
packages=['foo'],
use_2to3=True,
)
"""
INIT_PY = """print "foo"
"""
@pytest.yield_fixture
def temp_user(monkeypatch):
with contexts.tempdir() as user_base:
with contexts.tempdir() as user_site:
monkeypatch.setattr('site.USER_BASE', user_base)
monkeypatch.setattr('site.USER_SITE', user_site)
yield
@pytest.yield_fixture
def test_env(tmpdir, temp_user):
target = tmpdir
foo = target.mkdir('foo')
setup = target / 'setup.py'
if setup.isfile():
raise ValueError(dir(target))
with setup.open('w') as f:
f.write(SETUP_PY)
init = foo / '__init__.py'
with init.open('w') as f:
f.write(INIT_PY)
with target.as_cwd():
yield target
class TestDevelop:
in_virtualenv = hasattr(sys, 'real_prefix')
in_venv = hasattr(sys, 'base_prefix') and sys.base_prefix != sys.prefix
@pytest.mark.skipif(in_virtualenv or in_venv,
reason="Cannot run when invoked in a virtualenv or venv")
def test_2to3_user_mode(self, test_env):
settings = dict(
name='foo',
packages=['foo'],
use_2to3=True,
version='0.0',
)
dist = Distribution(settings)
dist.script_name = 'setup.py'
cmd = develop(dist)
cmd.user = 1
cmd.ensure_finalized()
cmd.install_dir = site.USER_SITE
cmd.user = 1
with contexts.quiet():
cmd.run()
# let's see if we got our egg link at the right place
content = os.listdir(site.USER_SITE)
content.sort()
assert content == ['easy-install.pth', 'foo.egg-link']
# Check that we are using the right code.
fn = os.path.join(site.USER_SITE, 'foo.egg-link')
with io.open(fn) as egg_link_file:
path = egg_link_file.read().split()[0].strip()
fn = os.path.join(path, 'foo', '__init__.py')
with io.open(fn) as init_file:
init = init_file.read().strip()
expected = 'print("foo")' if six.PY3 else 'print "foo"'
assert init == expected
def test_console_scripts(self, tmpdir):
"""
Test that console scripts are installed and that they reference
only the project by name and not the current version.
"""
pytest.skip("TODO: needs a fixture to cause 'develop' "
"to be invoked without mutating environment.")
settings = dict(
name='foo',
packages=['foo'],
version='0.0',
entry_points={
'console_scripts': [
'foocmd = foo:foo',
],
},
)
dist = Distribution(settings)
dist.script_name = 'setup.py'
cmd = develop(dist)
cmd.ensure_finalized()
cmd.install_dir = tmpdir
cmd.run()
#assert '0.0' not in foocmd_text
setuptools-20.7.0/setuptools/tests/test_dist_info.py 0000664 0001750 0001750 00000004476 12702524020 023644 0 ustar travis travis 0000000 0000000 """Test .dist-info style distributions.
"""
import os
import shutil
import tempfile
from setuptools.extern.six.moves import map
import pytest
import pkg_resources
from .textwrap import DALS
class TestDistInfo:
def test_distinfo(self):
dists = dict(
(d.project_name, d)
for d in pkg_resources.find_distributions(self.tmpdir)
)
assert len(dists) == 2, dists
unversioned = dists['UnversionedDistribution']
versioned = dists['VersionedDistribution']
assert versioned.version == '2.718' # from filename
assert unversioned.version == '0.3' # from METADATA
def test_conditional_dependencies(self):
specs = 'splort==4', 'quux>=1.1'
requires = list(map(pkg_resources.Requirement.parse, specs))
for d in pkg_resources.find_distributions(self.tmpdir):
assert d.requires() == requires[:1]
assert d.requires(extras=('baz',)) == [
requires[0],
pkg_resources.Requirement.parse('quux>=1.1;extra=="baz"')]
assert d.extras == ['baz']
metadata_template = DALS("""
Metadata-Version: 1.2
Name: {name}
{version}
Requires-Dist: splort (==4)
Provides-Extra: baz
Requires-Dist: quux (>=1.1); extra == 'baz'
""")
def setup_method(self, method):
self.tmpdir = tempfile.mkdtemp()
dist_info_name = 'VersionedDistribution-2.718.dist-info'
versioned = os.path.join(self.tmpdir, dist_info_name)
os.mkdir(versioned)
with open(os.path.join(versioned, 'METADATA'), 'w+') as metadata_file:
metadata = self.metadata_template.format(
name='VersionedDistribution',
version='',
).replace('\n\n', '\n')
metadata_file.write(metadata)
dist_info_name = 'UnversionedDistribution.dist-info'
unversioned = os.path.join(self.tmpdir, dist_info_name)
os.mkdir(unversioned)
with open(os.path.join(unversioned, 'METADATA'), 'w+') as metadata_file:
metadata = self.metadata_template.format(
name='UnversionedDistribution',
version='Version: 0.3',
)
metadata_file.write(metadata)
def teardown_method(self, method):
shutil.rmtree(self.tmpdir)
setuptools-20.7.0/setuptools/tests/test_easy_install.py 0000664 0001750 0001750 00000051104 12702524020 024343 0 ustar travis travis 0000000 0000000 # -*- coding: utf-8 -*-
"""Easy install Tests
"""
from __future__ import absolute_import
import sys
import os
import shutil
import tempfile
import site
import contextlib
import tarfile
import logging
import itertools
import distutils.errors
import io
from setuptools.extern.six.moves import urllib
import time
import pytest
try:
from unittest import mock
except ImportError:
import mock
from setuptools import sandbox
from setuptools.sandbox import run_setup
import setuptools.command.easy_install as ei
from setuptools.command.easy_install import PthDistributions
from setuptools.command import easy_install as easy_install_pkg
from setuptools.dist import Distribution
from pkg_resources import working_set
from pkg_resources import Distribution as PRDistribution
import setuptools.tests.server
import pkg_resources
from .py26compat import tarfile_open
from . import contexts
from .textwrap import DALS
class FakeDist(object):
def get_entry_map(self, group):
if group != 'console_scripts':
return {}
return {'name': 'ep'}
def as_requirement(self):
return 'spec'
SETUP_PY = DALS("""
from setuptools import setup
setup(name='foo')
""")
class TestEasyInstallTest:
def test_install_site_py(self, tmpdir):
dist = Distribution()
cmd = ei.easy_install(dist)
cmd.sitepy_installed = False
cmd.install_dir = str(tmpdir)
cmd.install_site_py()
assert (tmpdir / 'site.py').exists()
def test_get_script_args(self):
header = ei.CommandSpec.best().from_environment().as_header()
expected = header + DALS("""
# EASY-INSTALL-ENTRY-SCRIPT: 'spec','console_scripts','name'
__requires__ = 'spec'
import sys
from pkg_resources import load_entry_point
if __name__ == '__main__':
sys.exit(
load_entry_point('spec', 'console_scripts', 'name')()
)
""")
dist = FakeDist()
args = next(ei.ScriptWriter.get_args(dist))
name, script = itertools.islice(args, 2)
assert script == expected
def test_no_find_links(self):
# new option '--no-find-links', that blocks find-links added at
# the project level
dist = Distribution()
cmd = ei.easy_install(dist)
cmd.check_pth_processing = lambda: True
cmd.no_find_links = True
cmd.find_links = ['link1', 'link2']
cmd.install_dir = os.path.join(tempfile.mkdtemp(), 'ok')
cmd.args = ['ok']
cmd.ensure_finalized()
assert cmd.package_index.scanned_urls == {}
# let's try without it (default behavior)
cmd = ei.easy_install(dist)
cmd.check_pth_processing = lambda: True
cmd.find_links = ['link1', 'link2']
cmd.install_dir = os.path.join(tempfile.mkdtemp(), 'ok')
cmd.args = ['ok']
cmd.ensure_finalized()
keys = sorted(cmd.package_index.scanned_urls.keys())
assert keys == ['link1', 'link2']
def test_write_exception(self):
"""
Test that `cant_write_to_target` is rendered as a DistutilsError.
"""
dist = Distribution()
cmd = ei.easy_install(dist)
cmd.install_dir = os.getcwd()
with pytest.raises(distutils.errors.DistutilsError):
cmd.cant_write_to_target()
class TestPTHFileWriter:
def test_add_from_cwd_site_sets_dirty(self):
'''a pth file manager should set dirty
if a distribution is in site but also the cwd
'''
pth = PthDistributions('does-not_exist', [os.getcwd()])
assert not pth.dirty
pth.add(PRDistribution(os.getcwd()))
assert pth.dirty
def test_add_from_site_is_ignored(self):
location = '/test/location/does-not-have-to-exist'
# PthDistributions expects all locations to be normalized
location = pkg_resources.normalize_path(location)
pth = PthDistributions('does-not_exist', [location, ])
assert not pth.dirty
pth.add(PRDistribution(location))
assert not pth.dirty
@pytest.yield_fixture
def setup_context(tmpdir):
with (tmpdir/'setup.py').open('w') as f:
f.write(SETUP_PY)
with tmpdir.as_cwd():
yield tmpdir
@pytest.mark.usefixtures("user_override")
@pytest.mark.usefixtures("setup_context")
class TestUserInstallTest:
# prevent check that site-packages is writable. easy_install
# shouldn't be writing to system site-packages during finalize
# options, but while it does, bypass the behavior.
prev_sp_write = mock.patch(
'setuptools.command.easy_install.easy_install.check_site_dir',
mock.Mock(),
)
# simulate setuptools installed in user site packages
@mock.patch('setuptools.command.easy_install.__file__', site.USER_SITE)
@mock.patch('site.ENABLE_USER_SITE', True)
@prev_sp_write
def test_user_install_not_implied_user_site_enabled(self):
self.assert_not_user_site()
@mock.patch('site.ENABLE_USER_SITE', False)
@prev_sp_write
def test_user_install_not_implied_user_site_disabled(self):
self.assert_not_user_site()
@staticmethod
def assert_not_user_site():
# create a finalized easy_install command
dist = Distribution()
dist.script_name = 'setup.py'
cmd = ei.easy_install(dist)
cmd.args = ['py']
cmd.ensure_finalized()
assert not cmd.user, 'user should not be implied'
def test_multiproc_atexit(self):
pytest.importorskip('multiprocessing')
log = logging.getLogger('test_easy_install')
logging.basicConfig(level=logging.INFO, stream=sys.stderr)
log.info('this should not break')
@pytest.fixture()
def foo_package(self, tmpdir):
egg_file = tmpdir / 'foo-1.0.egg-info'
with egg_file.open('w') as f:
f.write('Name: foo\n')
return str(tmpdir)
@pytest.yield_fixture()
def install_target(self, tmpdir):
target = str(tmpdir)
with mock.patch('sys.path', sys.path + [target]):
python_path = os.path.pathsep.join(sys.path)
with mock.patch.dict(os.environ, PYTHONPATH=python_path):
yield target
def test_local_index(self, foo_package, install_target):
"""
The local index must be used when easy_install locates installed
packages.
"""
dist = Distribution()
dist.script_name = 'setup.py'
cmd = ei.easy_install(dist)
cmd.install_dir = install_target
cmd.args = ['foo']
cmd.ensure_finalized()
cmd.local_index.scan([foo_package])
res = cmd.easy_install('foo')
actual = os.path.normcase(os.path.realpath(res.location))
expected = os.path.normcase(os.path.realpath(foo_package))
assert actual == expected
@contextlib.contextmanager
def user_install_setup_context(self, *args, **kwargs):
"""
Wrap sandbox.setup_context to patch easy_install in that context to
appear as user-installed.
"""
with self.orig_context(*args, **kwargs):
import setuptools.command.easy_install as ei
ei.__file__ = site.USER_SITE
yield
def patched_setup_context(self):
self.orig_context = sandbox.setup_context
return mock.patch(
'setuptools.sandbox.setup_context',
self.user_install_setup_context,
)
@pytest.yield_fixture
def distutils_package():
distutils_setup_py = SETUP_PY.replace(
'from setuptools import setup',
'from distutils.core import setup',
)
with contexts.tempdir(cd=os.chdir):
with open('setup.py', 'w') as f:
f.write(distutils_setup_py)
yield
class TestDistutilsPackage:
def test_bdist_egg_available_on_distutils_pkg(self, distutils_package):
run_setup('setup.py', ['bdist_egg'])
class TestSetupRequires:
def test_setup_requires_honors_fetch_params(self):
"""
When easy_install installs a source distribution which specifies
setup_requires, it should honor the fetch parameters (such as
allow-hosts, index-url, and find-links).
"""
# set up a server which will simulate an alternate package index.
p_index = setuptools.tests.server.MockServer()
p_index.start()
netloc = 1
p_index_loc = urllib.parse.urlparse(p_index.url)[netloc]
if p_index_loc.endswith(':0'):
# Some platforms (Jython) don't find a port to which to bind,
# so skip this test for them.
return
with contexts.quiet():
# create an sdist that has a build-time dependency.
with TestSetupRequires.create_sdist() as dist_file:
with contexts.tempdir() as temp_install_dir:
with contexts.environment(PYTHONPATH=temp_install_dir):
ei_params = [
'--index-url', p_index.url,
'--allow-hosts', p_index_loc,
'--exclude-scripts',
'--install-dir', temp_install_dir,
dist_file,
]
with sandbox.save_argv(['easy_install']):
# attempt to install the dist. It should fail because
# it doesn't exist.
with pytest.raises(SystemExit):
easy_install_pkg.main(ei_params)
# there should have been two or three requests to the server
# (three happens on Python 3.3a)
assert 2 <= len(p_index.requests) <= 3
assert p_index.requests[0].path == '/does-not-exist/'
@staticmethod
@contextlib.contextmanager
def create_sdist():
"""
Return an sdist with a setup_requires dependency (of something that
doesn't exist)
"""
with contexts.tempdir() as dir:
dist_path = os.path.join(dir, 'setuptools-test-fetcher-1.0.tar.gz')
make_sdist(dist_path, [
('setup.py', DALS("""
import setuptools
setuptools.setup(
name="setuptools-test-fetcher",
version="1.0",
setup_requires = ['does-not-exist'],
)
"""))])
yield dist_path
def test_setup_requires_overrides_version_conflict(self):
"""
Regression test for distribution issue 323:
https://bitbucket.org/tarek/distribute/issues/323
Ensures that a distribution's setup_requires requirements can still be
installed and used locally even if a conflicting version of that
requirement is already on the path.
"""
fake_dist = PRDistribution('does-not-matter', project_name='foobar',
version='0.0')
working_set.add(fake_dist)
with contexts.save_pkg_resources_state():
with contexts.tempdir() as temp_dir:
test_pkg = create_setup_requires_package(temp_dir)
test_setup_py = os.path.join(test_pkg, 'setup.py')
with contexts.quiet() as (stdout, stderr):
# Don't even need to install the package, just
# running the setup.py at all is sufficient
run_setup(test_setup_py, ['--name'])
lines = stdout.readlines()
assert len(lines) > 0
assert lines[-1].strip(), 'test_pkg'
def test_setup_requires_override_nspkg(self):
"""
Like ``test_setup_requires_overrides_version_conflict`` but where the
``setup_requires`` package is part of a namespace package that has
*already* been imported.
"""
with contexts.save_pkg_resources_state():
with contexts.tempdir() as temp_dir:
foobar_1_archive = os.path.join(temp_dir, 'foo.bar-0.1.tar.gz')
make_nspkg_sdist(foobar_1_archive, 'foo.bar', '0.1')
# Now actually go ahead an extract to the temp dir and add the
# extracted path to sys.path so foo.bar v0.1 is importable
foobar_1_dir = os.path.join(temp_dir, 'foo.bar-0.1')
os.mkdir(foobar_1_dir)
with tarfile_open(foobar_1_archive) as tf:
tf.extractall(foobar_1_dir)
sys.path.insert(1, foobar_1_dir)
dist = PRDistribution(foobar_1_dir, project_name='foo.bar',
version='0.1')
working_set.add(dist)
template = DALS("""\
import foo # Even with foo imported first the
# setup_requires package should override
import setuptools
setuptools.setup(**%r)
if not (hasattr(foo, '__path__') and
len(foo.__path__) == 2):
print('FAIL')
if 'foo.bar-0.2' not in foo.__path__[0]:
print('FAIL')
""")
test_pkg = create_setup_requires_package(
temp_dir, 'foo.bar', '0.2', make_nspkg_sdist, template)
test_setup_py = os.path.join(test_pkg, 'setup.py')
with contexts.quiet() as (stdout, stderr):
try:
# Don't even need to install the package, just
# running the setup.py at all is sufficient
run_setup(test_setup_py, ['--name'])
except pkg_resources.VersionConflict:
self.fail('Installing setup.py requirements '
'caused a VersionConflict')
assert 'FAIL' not in stdout.getvalue()
lines = stdout.readlines()
assert len(lines) > 0
assert lines[-1].strip() == 'test_pkg'
def make_trivial_sdist(dist_path, distname, version):
"""
Create a simple sdist tarball at dist_path, containing just a simple
setup.py.
"""
make_sdist(dist_path, [
('setup.py',
DALS("""\
import setuptools
setuptools.setup(
name=%r,
version=%r
)
""" % (distname, version)))])
def make_nspkg_sdist(dist_path, distname, version):
"""
Make an sdist tarball with distname and version which also contains one
package with the same name as distname. The top-level package is
designated a namespace package).
"""
parts = distname.split('.')
nspackage = parts[0]
packages = ['.'.join(parts[:idx]) for idx in range(1, len(parts) + 1)]
setup_py = DALS("""\
import setuptools
setuptools.setup(
name=%r,
version=%r,
packages=%r,
namespace_packages=[%r]
)
""" % (distname, version, packages, nspackage))
init = "__import__('pkg_resources').declare_namespace(__name__)"
files = [('setup.py', setup_py),
(os.path.join(nspackage, '__init__.py'), init)]
for package in packages[1:]:
filename = os.path.join(*(package.split('.') + ['__init__.py']))
files.append((filename, ''))
make_sdist(dist_path, files)
def make_sdist(dist_path, files):
"""
Create a simple sdist tarball at dist_path, containing the files
listed in ``files`` as ``(filename, content)`` tuples.
"""
with tarfile_open(dist_path, 'w:gz') as dist:
for filename, content in files:
file_bytes = io.BytesIO(content.encode('utf-8'))
file_info = tarfile.TarInfo(name=filename)
file_info.size = len(file_bytes.getvalue())
file_info.mtime = int(time.time())
dist.addfile(file_info, fileobj=file_bytes)
def create_setup_requires_package(path, distname='foobar', version='0.1',
make_package=make_trivial_sdist,
setup_py_template=None):
"""Creates a source tree under path for a trivial test package that has a
single requirement in setup_requires--a tarball for that requirement is
also created and added to the dependency_links argument.
``distname`` and ``version`` refer to the name/version of the package that
the test package requires via ``setup_requires``. The name of the test
package itself is just 'test_pkg'.
"""
test_setup_attrs = {
'name': 'test_pkg', 'version': '0.0',
'setup_requires': ['%s==%s' % (distname, version)],
'dependency_links': [os.path.abspath(path)]
}
test_pkg = os.path.join(path, 'test_pkg')
test_setup_py = os.path.join(test_pkg, 'setup.py')
os.mkdir(test_pkg)
if setup_py_template is None:
setup_py_template = DALS("""\
import setuptools
setuptools.setup(**%r)
""")
with open(test_setup_py, 'w') as f:
f.write(setup_py_template % test_setup_attrs)
foobar_path = os.path.join(path, '%s-%s.tar.gz' % (distname, version))
make_package(foobar_path, distname, version)
return test_pkg
def make_trivial_sdist(dist_path, setup_py):
"""Create a simple sdist tarball at dist_path, containing just a
setup.py, the contents of which are provided by the setup_py string.
"""
setup_py_file = tarfile.TarInfo(name='setup.py')
setup_py_bytes = io.BytesIO(setup_py.encode('utf-8'))
setup_py_file.size = len(setup_py_bytes.getvalue())
with tarfile_open(dist_path, 'w:gz') as dist:
dist.addfile(setup_py_file, fileobj=setup_py_bytes)
class TestScriptHeader:
non_ascii_exe = '/Users/José/bin/python'
exe_with_spaces = r'C:\Program Files\Python33\python.exe'
@pytest.mark.skipif(
sys.platform.startswith('java') and ei.is_sh(sys.executable),
reason="Test cannot run under java when executable is sh"
)
def test_get_script_header(self):
expected = '#!%s\n' % ei.nt_quote_arg(os.path.normpath(sys.executable))
actual = ei.ScriptWriter.get_script_header('#!/usr/local/bin/python')
assert actual == expected
expected = '#!%s -x\n' % ei.nt_quote_arg(os.path.normpath
(sys.executable))
actual = ei.ScriptWriter.get_script_header('#!/usr/bin/python -x')
assert actual == expected
actual = ei.ScriptWriter.get_script_header('#!/usr/bin/python',
executable=self.non_ascii_exe)
expected = '#!%s -x\n' % self.non_ascii_exe
assert actual == expected
actual = ei.ScriptWriter.get_script_header('#!/usr/bin/python',
executable='"'+self.exe_with_spaces+'"')
expected = '#!"%s"\n' % self.exe_with_spaces
assert actual == expected
class TestCommandSpec:
def test_custom_launch_command(self):
"""
Show how a custom CommandSpec could be used to specify a #! executable
which takes parameters.
"""
cmd = ei.CommandSpec(['/usr/bin/env', 'python3'])
assert cmd.as_header() == '#!/usr/bin/env python3\n'
def test_from_param_for_CommandSpec_is_passthrough(self):
"""
from_param should return an instance of a CommandSpec
"""
cmd = ei.CommandSpec(['python'])
cmd_new = ei.CommandSpec.from_param(cmd)
assert cmd is cmd_new
@mock.patch('sys.executable', TestScriptHeader.exe_with_spaces)
@mock.patch.dict(os.environ)
def test_from_environment_with_spaces_in_executable(self):
os.environ.pop('__PYVENV_LAUNCHER__', None)
cmd = ei.CommandSpec.from_environment()
assert len(cmd) == 1
assert cmd.as_header().startswith('#!"')
def test_from_simple_string_uses_shlex(self):
"""
In order to support `executable = /usr/bin/env my-python`, make sure
from_param invokes shlex on that input.
"""
cmd = ei.CommandSpec.from_param('/usr/bin/env my-python')
assert len(cmd) == 2
assert '"' not in cmd.as_header()
def test_sys_executable(self):
"""
CommandSpec.from_string(sys.executable) should contain just that param.
"""
writer = ei.ScriptWriter.best()
cmd = writer.command_spec_class.from_string(sys.executable)
assert len(cmd) == 1
assert cmd[0] == sys.executable
class TestWindowsScriptWriter:
def test_header(self):
hdr = ei.WindowsScriptWriter.get_script_header('')
assert hdr.startswith('#!')
assert hdr.endswith('\n')
hdr = hdr.lstrip('#!')
hdr = hdr.rstrip('\n')
# header should not start with an escaped quote
assert not hdr.startswith('\\"')
setuptools-20.7.0/setuptools/tests/test_egg_info.py 0000664 0001750 0001750 00000012770 12702524020 023437 0 ustar travis travis 0000000 0000000 import os
import glob
import stat
from setuptools.extern.six.moves import map
import pytest
from . import environment
from .files import build_files
from .textwrap import DALS
from . import contexts
class Environment(str):
pass
class TestEggInfo(object):
setup_script = DALS("""
from setuptools import setup
setup(
name='foo',
py_modules=['hello'],
entry_points={'console_scripts': ['hi = hello.run']},
zip_safe=False,
)
""")
def _create_project(self):
build_files({
'setup.py': self.setup_script,
'hello.py': DALS("""
def run():
print('hello')
""")
})
@pytest.yield_fixture
def env(self):
with contexts.tempdir(prefix='setuptools-test.') as env_dir:
env = Environment(env_dir)
os.chmod(env_dir, stat.S_IRWXU)
subs = 'home', 'lib', 'scripts', 'data', 'egg-base'
env.paths = dict(
(dirname, os.path.join(env_dir, dirname))
for dirname in subs
)
list(map(os.mkdir, env.paths.values()))
build_files({
env.paths['home']: {
'.pydistutils.cfg': DALS("""
[egg_info]
egg-base = %(egg-base)s
""" % env.paths)
}
})
yield env
def test_egg_base_installed_egg_info(self, tmpdir_cwd, env):
self._create_project()
self._run_install_command(tmpdir_cwd, env)
actual = self._find_egg_info_files(env.paths['lib'])
expected = [
'PKG-INFO',
'SOURCES.txt',
'dependency_links.txt',
'entry_points.txt',
'not-zip-safe',
'top_level.txt',
]
assert sorted(actual) == expected
def test_manifest_template_is_read(self, tmpdir_cwd, env):
self._create_project()
build_files({
'MANIFEST.in': DALS("""
recursive-include docs *.rst
"""),
'docs': {
'usage.rst': "Run 'hi'",
}
})
self._run_install_command(tmpdir_cwd, env)
egg_info_dir = self._find_egg_info_files(env.paths['lib']).base
sources_txt = os.path.join(egg_info_dir, 'SOURCES.txt')
assert 'docs/usage.rst' in open(sources_txt).read().split('\n')
def _setup_script_with_requires(self, requires_line):
setup_script = DALS("""
from setuptools import setup
setup(
name='foo',
%s
zip_safe=False,
)
""" % requires_line)
build_files({
'setup.py': setup_script,
})
def test_install_requires_with_markers(self, tmpdir_cwd, env):
self._setup_script_with_requires(
"""install_requires=["barbazquux;python_version<'2'"],""")
self._run_install_command(tmpdir_cwd, env)
egg_info_dir = self._find_egg_info_files(env.paths['lib']).base
requires_txt = os.path.join(egg_info_dir, 'requires.txt')
assert "barbazquux;python_version<'2'" in open(
requires_txt).read().split('\n')
assert glob.glob(os.path.join(env.paths['lib'], 'barbazquux*')) == []
def test_setup_requires_with_markers(self, tmpdir_cwd, env):
self._setup_script_with_requires(
"""setup_requires=["barbazquux;python_version<'2'"],""")
self._run_install_command(tmpdir_cwd, env)
assert glob.glob(os.path.join(env.paths['lib'], 'barbazquux*')) == []
def test_tests_require_with_markers(self, tmpdir_cwd, env):
self._setup_script_with_requires(
"""tests_require=["barbazquux;python_version<'2'"],""")
self._run_install_command(
tmpdir_cwd, env, cmd=['test'], output="Ran 0 tests in")
assert glob.glob(os.path.join(env.paths['lib'], 'barbazquux*')) == []
def test_extra_requires_with_markers(self, tmpdir_cwd, env):
self._setup_script_with_requires(
"""extra_requires={":python_version<'2'": ["barbazquux"]},""")
self._run_install_command(tmpdir_cwd, env)
assert glob.glob(os.path.join(env.paths['lib'], 'barbazquux*')) == []
def _run_install_command(self, tmpdir_cwd, env, cmd=None, output=None):
environ = os.environ.copy().update(
HOME=env.paths['home'],
)
if cmd is None:
cmd = [
'install',
'--home', env.paths['home'],
'--install-lib', env.paths['lib'],
'--install-scripts', env.paths['scripts'],
'--install-data', env.paths['data'],
]
code, data = environment.run_setup_py(
cmd=cmd,
pypath=os.pathsep.join([env.paths['lib'], str(tmpdir_cwd)]),
data_stream=1,
env=environ,
)
if code:
raise AssertionError(data)
if output:
assert output in data
def _find_egg_info_files(self, root):
class DirList(list):
def __init__(self, files, base):
super(DirList, self).__init__(files)
self.base = base
results = (
DirList(filenames, dirpath)
for dirpath, dirnames, filenames in os.walk(root)
if os.path.basename(dirpath) == 'EGG-INFO'
)
# expect exactly one result
result, = results
return result
setuptools-20.7.0/setuptools/tests/test_find_packages.py 0000664 0001750 0001750 00000013452 12702524020 024436 0 ustar travis travis 0000000 0000000 """Tests for setuptools.find_packages()."""
import os
import sys
import shutil
import tempfile
import platform
import pytest
import setuptools
from setuptools import find_packages
find_420_packages = setuptools.PEP420PackageFinder.find
# modeled after CPython's test.support.can_symlink
def can_symlink():
TESTFN = tempfile.mktemp()
symlink_path = TESTFN + "can_symlink"
try:
os.symlink(TESTFN, symlink_path)
can = True
except (OSError, NotImplementedError, AttributeError):
can = False
else:
os.remove(symlink_path)
globals().update(can_symlink=lambda: can)
return can
def has_symlink():
bad_symlink = (
# Windows symlink directory detection is broken on Python 3.2
platform.system() == 'Windows' and sys.version_info[:2] == (3,2)
)
return can_symlink() and not bad_symlink
class TestFindPackages:
def setup_method(self, method):
self.dist_dir = tempfile.mkdtemp()
self._make_pkg_structure()
def teardown_method(self, method):
shutil.rmtree(self.dist_dir)
def _make_pkg_structure(self):
"""Make basic package structure.
dist/
docs/
conf.py
pkg/
__pycache__/
nspkg/
mod.py
subpkg/
assets/
asset
__init__.py
setup.py
"""
self.docs_dir = self._mkdir('docs', self.dist_dir)
self._touch('conf.py', self.docs_dir)
self.pkg_dir = self._mkdir('pkg', self.dist_dir)
self._mkdir('__pycache__', self.pkg_dir)
self.ns_pkg_dir = self._mkdir('nspkg', self.pkg_dir)
self._touch('mod.py', self.ns_pkg_dir)
self.sub_pkg_dir = self._mkdir('subpkg', self.pkg_dir)
self.asset_dir = self._mkdir('assets', self.sub_pkg_dir)
self._touch('asset', self.asset_dir)
self._touch('__init__.py', self.sub_pkg_dir)
self._touch('setup.py', self.dist_dir)
def _mkdir(self, path, parent_dir=None):
if parent_dir:
path = os.path.join(parent_dir, path)
os.mkdir(path)
return path
def _touch(self, path, dir_=None):
if dir_:
path = os.path.join(dir_, path)
fp = open(path, 'w')
fp.close()
return path
def test_regular_package(self):
self._touch('__init__.py', self.pkg_dir)
packages = find_packages(self.dist_dir)
assert packages == ['pkg', 'pkg.subpkg']
def test_exclude(self):
self._touch('__init__.py', self.pkg_dir)
packages = find_packages(self.dist_dir, exclude=('pkg.*',))
assert packages == ['pkg']
def test_include_excludes_other(self):
"""
If include is specified, other packages should be excluded.
"""
self._touch('__init__.py', self.pkg_dir)
alt_dir = self._mkdir('other_pkg', self.dist_dir)
self._touch('__init__.py', alt_dir)
packages = find_packages(self.dist_dir, include=['other_pkg'])
assert packages == ['other_pkg']
def test_dir_with_dot_is_skipped(self):
shutil.rmtree(os.path.join(self.dist_dir, 'pkg/subpkg/assets'))
data_dir = self._mkdir('some.data', self.pkg_dir)
self._touch('__init__.py', data_dir)
self._touch('file.dat', data_dir)
packages = find_packages(self.dist_dir)
assert 'pkg.some.data' not in packages
def test_dir_with_packages_in_subdir_is_excluded(self):
"""
Ensure that a package in a non-package such as build/pkg/__init__.py
is excluded.
"""
build_dir = self._mkdir('build', self.dist_dir)
build_pkg_dir = self._mkdir('pkg', build_dir)
self._touch('__init__.py', build_pkg_dir)
packages = find_packages(self.dist_dir)
assert 'build.pkg' not in packages
@pytest.mark.skipif(not has_symlink(), reason='Symlink support required')
def test_symlinked_packages_are_included(self):
"""
A symbolically-linked directory should be treated like any other
directory when matched as a package.
Create a link from lpkg -> pkg.
"""
self._touch('__init__.py', self.pkg_dir)
linked_pkg = os.path.join(self.dist_dir, 'lpkg')
os.symlink('pkg', linked_pkg)
assert os.path.isdir(linked_pkg)
packages = find_packages(self.dist_dir)
assert 'lpkg' in packages
def _assert_packages(self, actual, expected):
assert set(actual) == set(expected)
def test_pep420_ns_package(self):
packages = find_420_packages(
self.dist_dir, include=['pkg*'], exclude=['pkg.subpkg.assets'])
self._assert_packages(packages, ['pkg', 'pkg.nspkg', 'pkg.subpkg'])
def test_pep420_ns_package_no_includes(self):
packages = find_420_packages(
self.dist_dir, exclude=['pkg.subpkg.assets'])
self._assert_packages(packages, ['docs', 'pkg', 'pkg.nspkg', 'pkg.subpkg'])
def test_pep420_ns_package_no_includes_or_excludes(self):
packages = find_420_packages(self.dist_dir)
expected = [
'docs', 'pkg', 'pkg.nspkg', 'pkg.subpkg', 'pkg.subpkg.assets']
self._assert_packages(packages, expected)
def test_regular_package_with_nested_pep420_ns_packages(self):
self._touch('__init__.py', self.pkg_dir)
packages = find_420_packages(
self.dist_dir, exclude=['docs', 'pkg.subpkg.assets'])
self._assert_packages(packages, ['pkg', 'pkg.nspkg', 'pkg.subpkg'])
def test_pep420_ns_package_no_non_package_dirs(self):
shutil.rmtree(self.docs_dir)
shutil.rmtree(os.path.join(self.dist_dir, 'pkg/subpkg/assets'))
packages = find_420_packages(self.dist_dir)
self._assert_packages(packages, ['pkg', 'pkg.nspkg', 'pkg.subpkg'])
setuptools-20.7.0/setuptools/tests/test_integration.py 0000664 0001750 0001750 00000005664 12702524020 024211 0 ustar travis travis 0000000 0000000 """Run some integration tests.
Try to install a few packages.
"""
import glob
import os
import sys
from setuptools.extern.six.moves import urllib
import pytest
from setuptools.command.easy_install import easy_install
from setuptools.command import easy_install as easy_install_pkg
from setuptools.dist import Distribution
def setup_module(module):
packages = 'stevedore', 'virtualenvwrapper', 'pbr', 'novaclient'
for pkg in packages:
try:
__import__(pkg)
tmpl = "Integration tests cannot run when {pkg} is installed"
pytest.skip(tmpl.format(**locals()))
except ImportError:
pass
try:
urllib.request.urlopen('https://pypi.python.org/pypi')
except Exception as exc:
pytest.skip(str(exc))
@pytest.fixture
def install_context(request, tmpdir, monkeypatch):
"""Fixture to set up temporary installation directory.
"""
# Save old values so we can restore them.
new_cwd = tmpdir.mkdir('cwd')
user_base = tmpdir.mkdir('user_base')
user_site = tmpdir.mkdir('user_site')
install_dir = tmpdir.mkdir('install_dir')
def fin():
# undo the monkeypatch, particularly needed under
# windows because of kept handle on cwd
monkeypatch.undo()
new_cwd.remove()
user_base.remove()
user_site.remove()
install_dir.remove()
request.addfinalizer(fin)
# Change the environment and site settings to control where the
# files are installed and ensure we do not overwrite anything.
monkeypatch.chdir(new_cwd)
monkeypatch.setattr(easy_install_pkg, '__file__', user_site.strpath)
monkeypatch.setattr('site.USER_BASE', user_base.strpath)
monkeypatch.setattr('site.USER_SITE', user_site.strpath)
monkeypatch.setattr('sys.path', sys.path + [install_dir.strpath])
monkeypatch.setenv('PYTHONPATH', os.path.pathsep.join(sys.path))
# Set up the command for performing the installation.
dist = Distribution()
cmd = easy_install(dist)
cmd.install_dir = install_dir.strpath
return cmd
def _install_one(requirement, cmd, pkgname, modulename):
cmd.args = [requirement]
cmd.ensure_finalized()
cmd.run()
target = cmd.install_dir
dest_path = glob.glob(os.path.join(target, pkgname + '*.egg'))
assert dest_path
assert os.path.exists(os.path.join(dest_path[0], pkgname, modulename))
def test_stevedore(install_context):
_install_one('stevedore', install_context,
'stevedore', 'extension.py')
@pytest.mark.xfail
def test_virtualenvwrapper(install_context):
_install_one('virtualenvwrapper', install_context,
'virtualenvwrapper', 'hook_loader.py')
def test_pbr(install_context):
_install_one('pbr', install_context,
'pbr', 'core.py')
@pytest.mark.xfail
def test_python_novaclient(install_context):
_install_one('python-novaclient', install_context,
'novaclient', 'base.py')
setuptools-20.7.0/setuptools/tests/test_msvc9compiler.py 0000664 0001750 0001750 00000013405 12702524020 024452 0 ustar travis travis 0000000 0000000 """
Tests for msvc9compiler.
"""
import os
import contextlib
import distutils.errors
import pytest
try:
from unittest import mock
except ImportError:
import mock
from . import contexts
# importing only setuptools should apply the patch
__import__('setuptools')
pytest.importorskip("distutils.msvc9compiler")
def mock_reg(hkcu=None, hklm=None):
"""
Return a mock for distutils.msvc9compiler.Reg, patched
to mock out the functions that access the registry.
"""
_winreg = getattr(distutils.msvc9compiler, '_winreg', None)
winreg = getattr(distutils.msvc9compiler, 'winreg', _winreg)
hives = {
winreg.HKEY_CURRENT_USER: hkcu or {},
winreg.HKEY_LOCAL_MACHINE: hklm or {},
}
@classmethod
def read_keys(cls, base, key):
"""Return list of registry keys."""
hive = hives.get(base, {})
return [
k.rpartition('\\')[2]
for k in hive if k.startswith(key.lower())
]
@classmethod
def read_values(cls, base, key):
"""Return dict of registry keys and values."""
hive = hives.get(base, {})
return dict(
(k.rpartition('\\')[2], hive[k])
for k in hive if k.startswith(key.lower())
)
return mock.patch.multiple(distutils.msvc9compiler.Reg,
read_keys=read_keys, read_values=read_values)
class TestModulePatch:
"""
Ensure that importing setuptools is sufficient to replace
the standard find_vcvarsall function with a version that
recognizes the "Visual C++ for Python" package.
"""
key_32 = r'software\microsoft\devdiv\vcforpython\9.0\installdir'
key_64 = r'software\wow6432node\microsoft\devdiv\vcforpython\9.0\installdir'
def test_patched(self):
"Test the module is actually patched"
mod_name = distutils.msvc9compiler.find_vcvarsall.__module__
assert mod_name == "setuptools.msvc9_support", "find_vcvarsall unpatched"
def test_no_registry_entryies_means_nothing_found(self):
"""
No registry entries or environment variable should lead to an error
directing the user to download vcpython27.
"""
find_vcvarsall = distutils.msvc9compiler.find_vcvarsall
query_vcvarsall = distutils.msvc9compiler.query_vcvarsall
with contexts.environment(VS90COMNTOOLS=None):
with mock_reg():
assert find_vcvarsall(9.0) is None
expected = distutils.errors.DistutilsPlatformError
with pytest.raises(expected) as exc:
query_vcvarsall(9.0)
assert 'aka.ms/vcpython27' in str(exc)
@pytest.yield_fixture
def user_preferred_setting(self):
"""
Set up environment with different install dirs for user vs. system
and yield the user_install_dir for the expected result.
"""
with self.mock_install_dir() as user_install_dir:
with self.mock_install_dir() as system_install_dir:
reg = mock_reg(
hkcu={
self.key_32: user_install_dir,
},
hklm={
self.key_32: system_install_dir,
self.key_64: system_install_dir,
},
)
with reg:
yield user_install_dir
def test_prefer_current_user(self, user_preferred_setting):
"""
Ensure user's settings are preferred.
"""
result = distutils.msvc9compiler.find_vcvarsall(9.0)
expected = os.path.join(user_preferred_setting, 'vcvarsall.bat')
assert expected == result
@pytest.yield_fixture
def local_machine_setting(self):
"""
Set up environment with only the system environment configured.
"""
with self.mock_install_dir() as system_install_dir:
reg = mock_reg(
hklm={
self.key_32: system_install_dir,
},
)
with reg:
yield system_install_dir
def test_local_machine_recognized(self, local_machine_setting):
"""
Ensure machine setting is honored if user settings are not present.
"""
result = distutils.msvc9compiler.find_vcvarsall(9.0)
expected = os.path.join(local_machine_setting, 'vcvarsall.bat')
assert expected == result
@pytest.yield_fixture
def x64_preferred_setting(self):
"""
Set up environment with 64-bit and 32-bit system settings configured
and yield the canonical location.
"""
with self.mock_install_dir() as x32_dir:
with self.mock_install_dir() as x64_dir:
reg = mock_reg(
hklm={
# This *should* only exist on 32-bit machines
self.key_32: x32_dir,
# This *should* only exist on 64-bit machines
self.key_64: x64_dir,
},
)
with reg:
yield x32_dir
def test_ensure_64_bit_preferred(self, x64_preferred_setting):
"""
Ensure 64-bit system key is preferred.
"""
result = distutils.msvc9compiler.find_vcvarsall(9.0)
expected = os.path.join(x64_preferred_setting, 'vcvarsall.bat')
assert expected == result
@staticmethod
@contextlib.contextmanager
def mock_install_dir():
"""
Make a mock install dir in a unique location so that tests can
distinguish which dir was detected in a given scenario.
"""
with contexts.tempdir() as result:
vcvarsall = os.path.join(result, 'vcvarsall.bat')
with open(vcvarsall, 'w'):
pass
yield result
setuptools-20.7.0/setuptools/tests/test_packageindex.py 0000664 0001750 0001750 00000017454 12702524020 024311 0 ustar travis travis 0000000 0000000 from __future__ import absolute_import
import sys
import os
import distutils.errors
from setuptools.extern import six
from setuptools.extern.six.moves import urllib, http_client
from .textwrap import DALS
import pkg_resources
import setuptools.package_index
from setuptools.tests.server import IndexServer
class TestPackageIndex:
def test_bad_url_bad_port(self):
index = setuptools.package_index.PackageIndex()
url = 'http://127.0.0.1:0/nonesuch/test_package_index'
try:
v = index.open_url(url)
except Exception as v:
assert url in str(v)
else:
assert isinstance(v, urllib.error.HTTPError)
def test_bad_url_typo(self):
# issue 16
# easy_install inquant.contentmirror.plone breaks because of a typo
# in its home URL
index = setuptools.package_index.PackageIndex(
hosts=('www.example.com',)
)
url = 'url:%20https://svn.plone.org/svn/collective/inquant.contentmirror.plone/trunk'
try:
v = index.open_url(url)
except Exception as v:
assert url in str(v)
else:
assert isinstance(v, urllib.error.HTTPError)
def test_bad_url_bad_status_line(self):
index = setuptools.package_index.PackageIndex(
hosts=('www.example.com',)
)
def _urlopen(*args):
raise http_client.BadStatusLine('line')
index.opener = _urlopen
url = 'http://example.com'
try:
v = index.open_url(url)
except Exception as v:
assert 'line' in str(v)
else:
raise AssertionError('Should have raise here!')
def test_bad_url_double_scheme(self):
"""
A bad URL with a double scheme should raise a DistutilsError.
"""
index = setuptools.package_index.PackageIndex(
hosts=('www.example.com',)
)
# issue 20
url = 'http://http://svn.pythonpaste.org/Paste/wphp/trunk'
try:
index.open_url(url)
except distutils.errors.DistutilsError as error:
msg = six.text_type(error)
assert 'nonnumeric port' in msg or 'getaddrinfo failed' in msg or 'Name or service not known' in msg
return
raise RuntimeError("Did not raise")
def test_bad_url_screwy_href(self):
index = setuptools.package_index.PackageIndex(
hosts=('www.example.com',)
)
# issue #160
if sys.version_info[0] == 2 and sys.version_info[1] == 7:
# this should not fail
url = 'http://example.com'
page = ('')
index.process_index(url, page)
def test_url_ok(self):
index = setuptools.package_index.PackageIndex(
hosts=('www.example.com',)
)
url = 'file:///tmp/test_package_index'
assert index.url_ok(url, True)
def test_links_priority(self):
"""
Download links from the pypi simple index should be used before
external download links.
https://bitbucket.org/tarek/distribute/issue/163
Usecase :
- someone uploads a package on pypi, a md5 is generated
- someone manually copies this link (with the md5 in the url) onto an
external page accessible from the package page.
- someone reuploads the package (with a different md5)
- while easy_installing, an MD5 error occurs because the external link
is used
-> Setuptools should use the link from pypi, not the external one.
"""
if sys.platform.startswith('java'):
# Skip this test on jython because binding to :0 fails
return
# start an index server
server = IndexServer()
server.start()
index_url = server.base_url() + 'test_links_priority/simple/'
# scan a test index
pi = setuptools.package_index.PackageIndex(index_url)
requirement = pkg_resources.Requirement.parse('foobar')
pi.find_packages(requirement)
server.stop()
# the distribution has been found
assert 'foobar' in pi
# we have only one link, because links are compared without md5
assert len(pi['foobar'])==1
# the link should be from the index
assert 'correct_md5' in pi['foobar'][0].location
def test_parse_bdist_wininst(self):
parse = setuptools.package_index.parse_bdist_wininst
actual = parse('reportlab-2.5.win32-py2.4.exe')
expected = 'reportlab-2.5', '2.4', 'win32'
assert actual == expected
actual = parse('reportlab-2.5.win32.exe')
expected = 'reportlab-2.5', None, 'win32'
assert actual == expected
actual = parse('reportlab-2.5.win-amd64-py2.7.exe')
expected = 'reportlab-2.5', '2.7', 'win-amd64'
assert actual == expected
actual = parse('reportlab-2.5.win-amd64.exe')
expected = 'reportlab-2.5', None, 'win-amd64'
assert actual == expected
def test__vcs_split_rev_from_url(self):
"""
Test the basic usage of _vcs_split_rev_from_url
"""
vsrfu = setuptools.package_index.PackageIndex._vcs_split_rev_from_url
url, rev = vsrfu('https://example.com/bar@2995')
assert url == 'https://example.com/bar'
assert rev == '2995'
def test_local_index(self, tmpdir):
"""
local_open should be able to read an index from the file system.
"""
index_file = tmpdir / 'index.html'
with index_file.open('w') as f:
f.write('content')
url = 'file:' + urllib.request.pathname2url(str(tmpdir)) + '/'
res = setuptools.package_index.local_open(url)
assert 'content' in res.read()
class TestContentCheckers:
def test_md5(self):
checker = setuptools.package_index.HashChecker.from_url(
'http://foo/bar#md5=f12895fdffbd45007040d2e44df98478')
checker.feed('You should probably not be using MD5'.encode('ascii'))
assert checker.hash.hexdigest() == 'f12895fdffbd45007040d2e44df98478'
assert checker.is_valid()
def test_other_fragment(self):
"Content checks should succeed silently if no hash is present"
checker = setuptools.package_index.HashChecker.from_url(
'http://foo/bar#something%20completely%20different')
checker.feed('anything'.encode('ascii'))
assert checker.is_valid()
def test_blank_md5(self):
"Content checks should succeed if a hash is empty"
checker = setuptools.package_index.HashChecker.from_url(
'http://foo/bar#md5=')
checker.feed('anything'.encode('ascii'))
assert checker.is_valid()
def test_get_hash_name_md5(self):
checker = setuptools.package_index.HashChecker.from_url(
'http://foo/bar#md5=f12895fdffbd45007040d2e44df98478')
assert checker.hash_name == 'md5'
def test_report(self):
checker = setuptools.package_index.HashChecker.from_url(
'http://foo/bar#md5=f12895fdffbd45007040d2e44df98478')
rep = checker.report(lambda x: x, 'My message about %s')
assert rep == 'My message about md5'
class TestPyPIConfig:
def test_percent_in_password(self, tmpdir, monkeypatch):
monkeypatch.setitem(os.environ, 'HOME', str(tmpdir))
pypirc = tmpdir / '.pypirc'
with pypirc.open('w') as strm:
strm.write(DALS("""
[pypi]
repository=https://pypi.python.org
username=jaraco
password=pity%
"""))
cfg = setuptools.package_index.PyPIConfig()
cred = cfg.creds_by_repository['https://pypi.python.org']
assert cred.username == 'jaraco'
assert cred.password == 'pity%'
setuptools-20.7.0/setuptools/tests/test_sandbox.py 0000664 0001750 0001750 00000010774 12702524020 023322 0 ustar travis travis 0000000 0000000 """develop tests
"""
import os
import types
import pytest
import pkg_resources
import setuptools.sandbox
from setuptools.sandbox import DirectorySandbox
class TestSandbox:
def test_devnull(self, tmpdir):
sandbox = DirectorySandbox(str(tmpdir))
sandbox.run(self._file_writer(os.devnull))
@staticmethod
def _file_writer(path):
def do_write():
with open(path, 'w') as f:
f.write('xxx')
return do_write
def test_win32com(self, tmpdir):
"""
win32com should not be prevented from caching COM interfaces
in gen_py.
"""
win32com = pytest.importorskip('win32com')
gen_py = win32com.__gen_path__
target = os.path.join(gen_py, 'test_write')
sandbox = DirectorySandbox(str(tmpdir))
try:
# attempt to create gen_py file
sandbox.run(self._file_writer(target))
finally:
if os.path.exists(target):
os.remove(target)
def test_setup_py_with_BOM(self):
"""
It should be possible to execute a setup.py with a Byte Order Mark
"""
target = pkg_resources.resource_filename(__name__,
'script-with-bom.py')
namespace = types.ModuleType('namespace')
setuptools.sandbox._execfile(target, vars(namespace))
assert namespace.result == 'passed'
def test_setup_py_with_CRLF(self, tmpdir):
setup_py = tmpdir / 'setup.py'
with setup_py.open('wb') as stream:
stream.write(b'"degenerate script"\r\n')
setuptools.sandbox._execfile(str(setup_py), globals())
class TestExceptionSaver:
def test_exception_trapped(self):
with setuptools.sandbox.ExceptionSaver():
raise ValueError("details")
def test_exception_resumed(self):
with setuptools.sandbox.ExceptionSaver() as saved_exc:
raise ValueError("details")
with pytest.raises(ValueError) as caught:
saved_exc.resume()
assert isinstance(caught.value, ValueError)
assert str(caught.value) == 'details'
def test_exception_reconstructed(self):
orig_exc = ValueError("details")
with setuptools.sandbox.ExceptionSaver() as saved_exc:
raise orig_exc
with pytest.raises(ValueError) as caught:
saved_exc.resume()
assert isinstance(caught.value, ValueError)
assert caught.value is not orig_exc
def test_no_exception_passes_quietly(self):
with setuptools.sandbox.ExceptionSaver() as saved_exc:
pass
saved_exc.resume()
def test_unpickleable_exception(self):
class CantPickleThis(Exception):
"This Exception is unpickleable because it's not in globals"
with setuptools.sandbox.ExceptionSaver() as saved_exc:
raise CantPickleThis('detail')
with pytest.raises(setuptools.sandbox.UnpickleableException) as caught:
saved_exc.resume()
assert str(caught.value) == "CantPickleThis('detail',)"
def test_unpickleable_exception_when_hiding_setuptools(self):
"""
As revealed in #440, an infinite recursion can occur if an unpickleable
exception while setuptools is hidden. Ensure this doesn't happen.
"""
class ExceptionUnderTest(Exception):
"""
An unpickleable exception (not in globals).
"""
with pytest.raises(setuptools.sandbox.UnpickleableException) as caught:
with setuptools.sandbox.save_modules():
setuptools.sandbox.hide_setuptools()
raise ExceptionUnderTest()
msg, = caught.value.args
assert msg == 'ExceptionUnderTest()'
def test_sandbox_violation_raised_hiding_setuptools(self, tmpdir):
"""
When in a sandbox with setuptools hidden, a SandboxViolation
should reflect a proper exception and not be wrapped in
an UnpickleableException.
"""
def write_file():
"Trigger a SandboxViolation by writing outside the sandbox"
with open('/etc/foo', 'w'):
pass
sandbox = DirectorySandbox(str(tmpdir))
with pytest.raises(setuptools.sandbox.SandboxViolation) as caught:
with setuptools.sandbox.save_modules():
setuptools.sandbox.hide_setuptools()
sandbox.run(write_file)
cmd, args, kwargs = caught.value.args
assert cmd == 'open'
assert args == ('/etc/foo', 'w')
assert kwargs == {}
setuptools-20.7.0/setuptools/tests/test_sdist.py 0000664 0001750 0001750 00000032227 12702524020 023007 0 ustar travis travis 0000000 0000000 # -*- coding: utf-8 -*-
"""sdist tests"""
import os
import shutil
import sys
import tempfile
import unicodedata
import contextlib
import io
from setuptools.extern import six
from setuptools.extern.six.moves import map
import pytest
import pkg_resources
from setuptools.command.sdist import sdist
from setuptools.command.egg_info import manifest_maker
from setuptools.dist import Distribution
from setuptools.tests import fail_on_ascii
py3_only = pytest.mark.xfail(six.PY2, reason="Test runs on Python 3 only")
SETUP_ATTRS = {
'name': 'sdist_test',
'version': '0.0',
'packages': ['sdist_test'],
'package_data': {'sdist_test': ['*.txt']}
}
SETUP_PY = """\
from setuptools import setup
setup(**%r)
""" % SETUP_ATTRS
if six.PY3:
LATIN1_FILENAME = 'smörbröd.py'.encode('latin-1')
else:
LATIN1_FILENAME = 'sm\xf6rbr\xf6d.py'
# Cannot use context manager because of Python 2.4
@contextlib.contextmanager
def quiet():
old_stdout, old_stderr = sys.stdout, sys.stderr
sys.stdout, sys.stderr = six.StringIO(), six.StringIO()
try:
yield
finally:
sys.stdout, sys.stderr = old_stdout, old_stderr
# Fake byte literals for Python <= 2.5
def b(s, encoding='utf-8'):
if six.PY3:
return s.encode(encoding)
return s
# Convert to POSIX path
def posix(path):
if six.PY3 and not isinstance(path, str):
return path.replace(os.sep.encode('ascii'), b('/'))
else:
return path.replace(os.sep, '/')
# HFS Plus uses decomposed UTF-8
def decompose(path):
if isinstance(path, six.text_type):
return unicodedata.normalize('NFD', path)
try:
path = path.decode('utf-8')
path = unicodedata.normalize('NFD', path)
path = path.encode('utf-8')
except UnicodeError:
pass # Not UTF-8
return path
def read_all_bytes(filename):
with io.open(filename, 'rb') as fp:
return fp.read()
class TestSdistTest:
def setup_method(self, method):
self.temp_dir = tempfile.mkdtemp()
f = open(os.path.join(self.temp_dir, 'setup.py'), 'w')
f.write(SETUP_PY)
f.close()
# Set up the rest of the test package
test_pkg = os.path.join(self.temp_dir, 'sdist_test')
os.mkdir(test_pkg)
# *.rst was not included in package_data, so c.rst should not be
# automatically added to the manifest when not under version control
for fname in ['__init__.py', 'a.txt', 'b.txt', 'c.rst']:
# Just touch the files; their contents are irrelevant
open(os.path.join(test_pkg, fname), 'w').close()
self.old_cwd = os.getcwd()
os.chdir(self.temp_dir)
def teardown_method(self, method):
os.chdir(self.old_cwd)
shutil.rmtree(self.temp_dir)
def test_package_data_in_sdist(self):
"""Regression test for pull request #4: ensures that files listed in
package_data are included in the manifest even if they're not added to
version control.
"""
dist = Distribution(SETUP_ATTRS)
dist.script_name = 'setup.py'
cmd = sdist(dist)
cmd.ensure_finalized()
with quiet():
cmd.run()
manifest = cmd.filelist.files
assert os.path.join('sdist_test', 'a.txt') in manifest
assert os.path.join('sdist_test', 'b.txt') in manifest
assert os.path.join('sdist_test', 'c.rst') not in manifest
def test_defaults_case_sensitivity(self):
"""
Make sure default files (README.*, etc.) are added in a case-sensitive
way to avoid problems with packages built on Windows.
"""
open(os.path.join(self.temp_dir, 'readme.rst'), 'w').close()
open(os.path.join(self.temp_dir, 'SETUP.cfg'), 'w').close()
dist = Distribution(SETUP_ATTRS)
# the extension deliberately capitalized for this test
# to make sure the actual filename (not capitalized) gets added
# to the manifest
dist.script_name = 'setup.PY'
cmd = sdist(dist)
cmd.ensure_finalized()
with quiet():
cmd.run()
# lowercase all names so we can test in a case-insensitive way to make sure the files are not included
manifest = map(lambda x: x.lower(), cmd.filelist.files)
assert 'readme.rst' not in manifest, manifest
assert 'setup.py' not in manifest, manifest
assert 'setup.cfg' not in manifest, manifest
@fail_on_ascii
def test_manifest_is_written_with_utf8_encoding(self):
# Test for #303.
dist = Distribution(SETUP_ATTRS)
dist.script_name = 'setup.py'
mm = manifest_maker(dist)
mm.manifest = os.path.join('sdist_test.egg-info', 'SOURCES.txt')
os.mkdir('sdist_test.egg-info')
# UTF-8 filename
filename = os.path.join('sdist_test', 'smörbröd.py')
# Must create the file or it will get stripped.
open(filename, 'w').close()
# Add UTF-8 filename and write manifest
with quiet():
mm.run()
mm.filelist.append(filename)
mm.write_manifest()
contents = read_all_bytes(mm.manifest)
# The manifest should be UTF-8 encoded
u_contents = contents.decode('UTF-8')
# The manifest should contain the UTF-8 filename
if six.PY2:
fs_enc = sys.getfilesystemencoding()
filename = filename.decode(fs_enc)
assert posix(filename) in u_contents
@py3_only
@fail_on_ascii
def test_write_manifest_allows_utf8_filenames(self):
# Test for #303.
dist = Distribution(SETUP_ATTRS)
dist.script_name = 'setup.py'
mm = manifest_maker(dist)
mm.manifest = os.path.join('sdist_test.egg-info', 'SOURCES.txt')
os.mkdir('sdist_test.egg-info')
# UTF-8 filename
filename = os.path.join(b('sdist_test'), b('smörbröd.py'))
# Must touch the file or risk removal
open(filename, "w").close()
# Add filename and write manifest
with quiet():
mm.run()
u_filename = filename.decode('utf-8')
mm.filelist.files.append(u_filename)
# Re-write manifest
mm.write_manifest()
contents = read_all_bytes(mm.manifest)
# The manifest should be UTF-8 encoded
contents.decode('UTF-8')
# The manifest should contain the UTF-8 filename
assert posix(filename) in contents
# The filelist should have been updated as well
assert u_filename in mm.filelist.files
@py3_only
def test_write_manifest_skips_non_utf8_filenames(self):
"""
Files that cannot be encoded to UTF-8 (specifically, those that
weren't originally successfully decoded and have surrogate
escapes) should be omitted from the manifest.
See https://bitbucket.org/tarek/distribute/issue/303 for history.
"""
dist = Distribution(SETUP_ATTRS)
dist.script_name = 'setup.py'
mm = manifest_maker(dist)
mm.manifest = os.path.join('sdist_test.egg-info', 'SOURCES.txt')
os.mkdir('sdist_test.egg-info')
# Latin-1 filename
filename = os.path.join(b('sdist_test'), LATIN1_FILENAME)
# Add filename with surrogates and write manifest
with quiet():
mm.run()
u_filename = filename.decode('utf-8', 'surrogateescape')
mm.filelist.append(u_filename)
# Re-write manifest
mm.write_manifest()
contents = read_all_bytes(mm.manifest)
# The manifest should be UTF-8 encoded
contents.decode('UTF-8')
# The Latin-1 filename should have been skipped
assert posix(filename) not in contents
# The filelist should have been updated as well
assert u_filename not in mm.filelist.files
@fail_on_ascii
def test_manifest_is_read_with_utf8_encoding(self):
# Test for #303.
dist = Distribution(SETUP_ATTRS)
dist.script_name = 'setup.py'
cmd = sdist(dist)
cmd.ensure_finalized()
# Create manifest
with quiet():
cmd.run()
# Add UTF-8 filename to manifest
filename = os.path.join(b('sdist_test'), b('smörbröd.py'))
cmd.manifest = os.path.join('sdist_test.egg-info', 'SOURCES.txt')
manifest = open(cmd.manifest, 'ab')
manifest.write(b('\n') + filename)
manifest.close()
# The file must exist to be included in the filelist
open(filename, 'w').close()
# Re-read manifest
cmd.filelist.files = []
with quiet():
cmd.read_manifest()
# The filelist should contain the UTF-8 filename
if six.PY3:
filename = filename.decode('utf-8')
assert filename in cmd.filelist.files
@py3_only
def test_read_manifest_skips_non_utf8_filenames(self):
# Test for #303.
dist = Distribution(SETUP_ATTRS)
dist.script_name = 'setup.py'
cmd = sdist(dist)
cmd.ensure_finalized()
# Create manifest
with quiet():
cmd.run()
# Add Latin-1 filename to manifest
filename = os.path.join(b('sdist_test'), LATIN1_FILENAME)
cmd.manifest = os.path.join('sdist_test.egg-info', 'SOURCES.txt')
manifest = open(cmd.manifest, 'ab')
manifest.write(b('\n') + filename)
manifest.close()
# The file must exist to be included in the filelist
open(filename, 'w').close()
# Re-read manifest
cmd.filelist.files = []
with quiet():
cmd.read_manifest()
# The Latin-1 filename should have been skipped
filename = filename.decode('latin-1')
assert filename not in cmd.filelist.files
@fail_on_ascii
def test_sdist_with_utf8_encoded_filename(self):
# Test for #303.
dist = Distribution(SETUP_ATTRS)
dist.script_name = 'setup.py'
cmd = sdist(dist)
cmd.ensure_finalized()
# UTF-8 filename
filename = os.path.join(b('sdist_test'), b('smörbröd.py'))
open(filename, 'w').close()
with quiet():
cmd.run()
if sys.platform == 'darwin':
filename = decompose(filename)
if six.PY3:
fs_enc = sys.getfilesystemencoding()
if sys.platform == 'win32':
if fs_enc == 'cp1252':
# Python 3 mangles the UTF-8 filename
filename = filename.decode('cp1252')
assert filename in cmd.filelist.files
else:
filename = filename.decode('mbcs')
assert filename in cmd.filelist.files
else:
filename = filename.decode('utf-8')
assert filename in cmd.filelist.files
else:
assert filename in cmd.filelist.files
def test_sdist_with_latin1_encoded_filename(self):
# Test for #303.
dist = Distribution(SETUP_ATTRS)
dist.script_name = 'setup.py'
cmd = sdist(dist)
cmd.ensure_finalized()
# Latin-1 filename
filename = os.path.join(b('sdist_test'), LATIN1_FILENAME)
open(filename, 'w').close()
assert os.path.isfile(filename)
with quiet():
cmd.run()
if six.PY3:
# not all windows systems have a default FS encoding of cp1252
if sys.platform == 'win32':
# Latin-1 is similar to Windows-1252 however
# on mbcs filesys it is not in latin-1 encoding
fs_enc = sys.getfilesystemencoding()
if fs_enc == 'mbcs':
filename = filename.decode('mbcs')
else:
filename = filename.decode('latin-1')
assert filename in cmd.filelist.files
else:
# The Latin-1 filename should have been skipped
filename = filename.decode('latin-1')
filename not in cmd.filelist.files
else:
# Under Python 2 there seems to be no decoded string in the
# filelist. However, due to decode and encoding of the
# file name to get utf-8 Manifest the latin1 maybe excluded
try:
# fs_enc should match how one is expect the decoding to
# be proformed for the manifest output.
fs_enc = sys.getfilesystemencoding()
filename.decode(fs_enc)
assert filename in cmd.filelist.files
except UnicodeDecodeError:
filename not in cmd.filelist.files
def test_default_revctrl():
"""
When _default_revctrl was removed from the `setuptools.command.sdist`
module in 10.0, it broke some systems which keep an old install of
setuptools (Distribute) around. Those old versions require that the
setuptools package continue to implement that interface, so this
function provides that interface, stubbed. See #320 for details.
This interface must be maintained until Ubuntu 12.04 is no longer
supported (by Setuptools).
"""
ep_def = 'svn_cvs = setuptools.command.sdist:_default_revctrl'
ep = pkg_resources.EntryPoint.parse(ep_def)
res = ep.resolve()
assert hasattr(res, '__iter__')
setuptools-20.7.0/setuptools/tests/test_setuptools.py 0000664 0001750 0001750 00000002210 12702524020 024067 0 ustar travis travis 0000000 0000000 import os
import pytest
import setuptools
@pytest.fixture
def example_source(tmpdir):
tmpdir.mkdir('foo')
(tmpdir / 'foo/bar.py').write('')
(tmpdir / 'readme.txt').write('')
return tmpdir
def test_findall(example_source):
found = list(setuptools.findall(str(example_source)))
expected = ['readme.txt', 'foo/bar.py']
expected = [example_source.join(fn) for fn in expected]
assert found == expected
def test_findall_curdir(example_source):
with example_source.as_cwd():
found = list(setuptools.findall())
expected = ['readme.txt', os.path.join('foo', 'bar.py')]
assert found == expected
@pytest.fixture
def can_symlink(tmpdir):
"""
Skip if cannot create a symbolic link
"""
link_fn = 'link'
target_fn = 'target'
try:
os.symlink(target_fn, link_fn)
except (OSError, NotImplementedError, AttributeError):
pytest.skip("Cannot create symbolic links")
os.remove(link_fn)
def test_findall_missing_symlink(tmpdir, can_symlink):
with tmpdir.as_cwd():
os.symlink('foo', 'bar')
found = list(setuptools.findall())
assert found == []
setuptools-20.7.0/setuptools/tests/test_test.py 0000664 0001750 0001750 00000004505 12702524020 022636 0 ustar travis travis 0000000 0000000 # -*- coding: UTF-8 -*-
from __future__ import unicode_literals
import os
import site
from distutils.errors import DistutilsError
import pytest
from setuptools.command.test import test
from setuptools.dist import Distribution
from .textwrap import DALS
from . import contexts
SETUP_PY = DALS("""
from setuptools import setup
setup(name='foo',
packages=['name', 'name.space', 'name.space.tests'],
namespace_packages=['name'],
test_suite='name.space.tests.test_suite',
)
""")
NS_INIT = DALS("""
# -*- coding: Latin-1 -*-
# Söme Arbiträry Ünicode to test Distribute Issüé 310
try:
__import__('pkg_resources').declare_namespace(__name__)
except ImportError:
from pkgutil import extend_path
__path__ = extend_path(__path__, __name__)
""")
TEST_PY = DALS("""
import unittest
class TestTest(unittest.TestCase):
def test_test(self):
print "Foo" # Should fail under Python 3 unless 2to3 is used
test_suite = unittest.makeSuite(TestTest)
""")
@pytest.fixture
def sample_test(tmpdir_cwd):
os.makedirs('name/space/tests')
# setup.py
with open('setup.py', 'wt') as f:
f.write(SETUP_PY)
# name/__init__.py
with open('name/__init__.py', 'wb') as f:
f.write(NS_INIT.encode('Latin-1'))
# name/space/__init__.py
with open('name/space/__init__.py', 'wt') as f:
f.write('#empty\n')
# name/space/tests/__init__.py
with open('name/space/tests/__init__.py', 'wt') as f:
f.write(TEST_PY)
@pytest.mark.skipif('hasattr(sys, "real_prefix")')
@pytest.mark.usefixtures('user_override')
@pytest.mark.usefixtures('sample_test')
class TestTestTest:
def test_test(self):
params = dict(
name='foo',
packages=['name', 'name.space', 'name.space.tests'],
namespace_packages=['name'],
test_suite='name.space.tests.test_suite',
use_2to3=True,
)
dist = Distribution(params)
dist.script_name = 'setup.py'
cmd = test(dist)
cmd.user = 1
cmd.ensure_finalized()
cmd.install_dir = site.USER_SITE
cmd.user = 1
with contexts.quiet():
# The test runner calls sys.exit
with contexts.suppress_exceptions(SystemExit):
cmd.run()
setuptools-20.7.0/setuptools/tests/test_unicode_utils.py 0000664 0001750 0001750 00000000474 12702524020 024526 0 ustar travis travis 0000000 0000000 from setuptools import unicode_utils
def test_filesys_decode_fs_encoding_is_None(monkeypatch):
"""
Test filesys_decode does not raise TypeError when
getfilesystemencoding returns None.
"""
monkeypatch.setattr('sys.getfilesystemencoding', lambda: None)
unicode_utils.filesys_decode(b'test')
setuptools-20.7.0/setuptools/tests/test_upload_docs.py 0000664 0001750 0001750 00000002472 12702524020 024154 0 ustar travis travis 0000000 0000000 import os
import zipfile
import contextlib
import pytest
from setuptools.command.upload_docs import upload_docs
from setuptools.dist import Distribution
from .textwrap import DALS
from . import contexts
SETUP_PY = DALS(
"""
from setuptools import setup
setup(name='foo')
""")
@pytest.fixture
def sample_project(tmpdir_cwd):
# setup.py
with open('setup.py', 'wt') as f:
f.write(SETUP_PY)
os.mkdir('build')
# A test document.
with open('build/index.html', 'w') as f:
f.write("Hello world.")
# An empty folder.
os.mkdir('build/empty')
@pytest.mark.usefixtures('sample_project')
@pytest.mark.usefixtures('user_override')
class TestUploadDocsTest:
def test_create_zipfile(self):
"""
Ensure zipfile creation handles common cases, including a folder
containing an empty folder.
"""
dist = Distribution()
cmd = upload_docs(dist)
cmd.target_dir = cmd.upload_dir = 'build'
with contexts.tempdir() as tmp_dir:
tmp_file = os.path.join(tmp_dir, 'foo.zip')
zip_file = cmd.create_zipfile(tmp_file)
assert zipfile.is_zipfile(tmp_file)
with contextlib.closing(zipfile.ZipFile(tmp_file)) as zip_file:
assert zip_file.namelist() == ['index.html']
setuptools-20.7.0/setuptools/tests/test_windows_wrappers.py 0000664 0001750 0001750 00000014012 12702524020 025266 0 ustar travis travis 0000000 0000000 """
Python Script Wrapper for Windows
=================================
setuptools includes wrappers for Python scripts that allows them to be
executed like regular windows programs. There are 2 wrappers, one
for command-line programs, cli.exe, and one for graphical programs,
gui.exe. These programs are almost identical, function pretty much
the same way, and are generated from the same source file. The
wrapper programs are used by copying them to the directory containing
the script they are to wrap and with the same name as the script they
are to wrap.
"""
from __future__ import absolute_import
import sys
import textwrap
import subprocess
import pytest
from setuptools.command.easy_install import nt_quote_arg
import pkg_resources
pytestmark = pytest.mark.skipif(sys.platform != 'win32', reason="Windows only")
class WrapperTester:
@classmethod
def prep_script(cls, template):
python_exe = nt_quote_arg(sys.executable)
return template % locals()
@classmethod
def create_script(cls, tmpdir):
"""
Create a simple script, foo-script.py
Note that the script starts with a Unix-style '#!' line saying which
Python executable to run. The wrapper will use this line to find the
correct Python executable.
"""
script = cls.prep_script(cls.script_tmpl)
with (tmpdir / cls.script_name).open('w') as f:
f.write(script)
# also copy cli.exe to the sample directory
with (tmpdir / cls.wrapper_name).open('wb') as f:
w = pkg_resources.resource_string('setuptools', cls.wrapper_source)
f.write(w)
class TestCLI(WrapperTester):
script_name = 'foo-script.py'
wrapper_source = 'cli-32.exe'
wrapper_name = 'foo.exe'
script_tmpl = textwrap.dedent("""
#!%(python_exe)s
import sys
input = repr(sys.stdin.read())
print(sys.argv[0][-14:])
print(sys.argv[1:])
print(input)
if __debug__:
print('non-optimized')
""").lstrip()
def test_basic(self, tmpdir):
"""
When the copy of cli.exe, foo.exe in this example, runs, it examines
the path name it was run with and computes a Python script path name
by removing the '.exe' suffix and adding the '-script.py' suffix. (For
GUI programs, the suffix '-script.pyw' is added.) This is why we
named out script the way we did. Now we can run out script by running
the wrapper:
This example was a little pathological in that it exercised windows
(MS C runtime) quoting rules:
- Strings containing spaces are surrounded by double quotes.
- Double quotes in strings need to be escaped by preceding them with
back slashes.
- One or more backslashes preceding double quotes need to be escaped
by preceding each of them with back slashes.
"""
self.create_script(tmpdir)
cmd = [
str(tmpdir / 'foo.exe'),
'arg1',
'arg 2',
'arg "2\\"',
'arg 4\\',
'arg5 a\\\\b',
]
proc = subprocess.Popen(cmd, stdout=subprocess.PIPE, stdin=subprocess.PIPE)
stdout, stderr = proc.communicate('hello\nworld\n'.encode('ascii'))
actual = stdout.decode('ascii').replace('\r\n', '\n')
expected = textwrap.dedent(r"""
\foo-script.py
['arg1', 'arg 2', 'arg "2\\"', 'arg 4\\', 'arg5 a\\\\b']
'hello\nworld\n'
non-optimized
""").lstrip()
assert actual == expected
def test_with_options(self, tmpdir):
"""
Specifying Python Command-line Options
--------------------------------------
You can specify a single argument on the '#!' line. This can be used
to specify Python options like -O, to run in optimized mode or -i
to start the interactive interpreter. You can combine multiple
options as usual. For example, to run in optimized mode and
enter the interpreter after running the script, you could use -Oi:
"""
self.create_script(tmpdir)
tmpl = textwrap.dedent("""
#!%(python_exe)s -Oi
import sys
input = repr(sys.stdin.read())
print(sys.argv[0][-14:])
print(sys.argv[1:])
print(input)
if __debug__:
print('non-optimized')
sys.ps1 = '---'
""").lstrip()
with (tmpdir / 'foo-script.py').open('w') as f:
f.write(self.prep_script(tmpl))
cmd = [str(tmpdir / 'foo.exe')]
proc = subprocess.Popen(cmd, stdout=subprocess.PIPE, stdin=subprocess.PIPE, stderr=subprocess.STDOUT)
stdout, stderr = proc.communicate()
actual = stdout.decode('ascii').replace('\r\n', '\n')
expected = textwrap.dedent(r"""
\foo-script.py
[]
''
---
""").lstrip()
assert actual == expected
class TestGUI(WrapperTester):
"""
Testing the GUI Version
-----------------------
"""
script_name = 'bar-script.pyw'
wrapper_source = 'gui-32.exe'
wrapper_name = 'bar.exe'
script_tmpl = textwrap.dedent("""
#!%(python_exe)s
import sys
f = open(sys.argv[1], 'wb')
bytes_written = f.write(repr(sys.argv[2]).encode('utf-8'))
f.close()
""").strip()
def test_basic(self, tmpdir):
"""Test the GUI version with the simple scipt, bar-script.py"""
self.create_script(tmpdir)
cmd = [
str(tmpdir / 'bar.exe'),
str(tmpdir / 'test_output.txt'),
'Test Argument',
]
proc = subprocess.Popen(cmd, stdout=subprocess.PIPE, stdin=subprocess.PIPE, stderr=subprocess.STDOUT)
stdout, stderr = proc.communicate()
assert not stdout
assert not stderr
with (tmpdir / 'test_output.txt').open('rb') as f_out:
actual = f_out.read().decode('ascii')
assert actual == repr('Test Argument')
setuptools-20.7.0/setuptools/tests/textwrap.py 0000664 0001750 0001750 00000000212 12702524020 022465 0 ustar travis travis 0000000 0000000 from __future__ import absolute_import
import textwrap
def DALS(s):
"dedent and left-strip"
return textwrap.dedent(s).lstrip()
setuptools-20.7.0/setuptools/__init__.py 0000664 0001750 0001750 00000012500 12702524020 021207 0 ustar travis travis 0000000 0000000 """Extensions to the 'distutils' for large or complex distributions"""
import os
import functools
import distutils.core
import distutils.filelist
from distutils.core import Command as _Command
from distutils.util import convert_path
from fnmatch import fnmatchcase
from setuptools.extern.six.moves import filterfalse, map
import setuptools.version
from setuptools.extension import Extension
from setuptools.dist import Distribution, Feature, _get_unpatched
from setuptools.depends import Require
__all__ = [
'setup', 'Distribution', 'Feature', 'Command', 'Extension', 'Require',
'find_packages'
]
__version__ = setuptools.version.__version__
bootstrap_install_from = None
# If we run 2to3 on .py files, should we also convert docstrings?
# Default: yes; assume that we can detect doctests reliably
run_2to3_on_doctests = True
# Standard package names for fixer packages
lib2to3_fixer_packages = ['lib2to3.fixes']
class PackageFinder(object):
@classmethod
def find(cls, where='.', exclude=(), include=('*',)):
"""Return a list all Python packages found within directory 'where'
'where' should be supplied as a "cross-platform" (i.e. URL-style)
path; it will be converted to the appropriate local path syntax.
'exclude' is a sequence of package names to exclude; '*' can be used
as a wildcard in the names, such that 'foo.*' will exclude all
subpackages of 'foo' (but not 'foo' itself).
'include' is a sequence of package names to include. If it's
specified, only the named packages will be included. If it's not
specified, all found packages will be included. 'include' can contain
shell style wildcard patterns just like 'exclude'.
The list of included packages is built up first and then any
explicitly excluded packages are removed from it.
"""
out = cls._find_packages_iter(convert_path(where))
out = cls.require_parents(out)
includes = cls._build_filter(*include)
excludes = cls._build_filter('ez_setup', '*__pycache__', *exclude)
out = filter(includes, out)
out = filterfalse(excludes, out)
return list(out)
@staticmethod
def require_parents(packages):
"""
Exclude any apparent package that apparently doesn't include its
parent.
For example, exclude 'foo.bar' if 'foo' is not present.
"""
found = []
for pkg in packages:
base, sep, child = pkg.rpartition('.')
if base and base not in found:
continue
found.append(pkg)
yield pkg
@staticmethod
def _candidate_dirs(base_path):
"""
Return all dirs in base_path that might be packages.
"""
has_dot = lambda name: '.' in name
for root, dirs, files in os.walk(base_path, followlinks=True):
# Exclude directories that contain a period, as they cannot be
# packages. Mutate the list to avoid traversal.
dirs[:] = filterfalse(has_dot, dirs)
for dir in dirs:
yield os.path.relpath(os.path.join(root, dir), base_path)
@classmethod
def _find_packages_iter(cls, base_path):
candidates = cls._candidate_dirs(base_path)
return (
path.replace(os.path.sep, '.')
for path in candidates
if cls._looks_like_package(os.path.join(base_path, path))
)
@staticmethod
def _looks_like_package(path):
return os.path.isfile(os.path.join(path, '__init__.py'))
@staticmethod
def _build_filter(*patterns):
"""
Given a list of patterns, return a callable that will be true only if
the input matches one of the patterns.
"""
return lambda name: any(fnmatchcase(name, pat=pat) for pat in patterns)
class PEP420PackageFinder(PackageFinder):
@staticmethod
def _looks_like_package(path):
return True
find_packages = PackageFinder.find
setup = distutils.core.setup
_Command = _get_unpatched(_Command)
class Command(_Command):
__doc__ = _Command.__doc__
command_consumes_arguments = False
def __init__(self, dist, **kw):
"""
Construct the command for dist, updating
vars(self) with any keyword parameters.
"""
_Command.__init__(self, dist)
vars(self).update(kw)
def reinitialize_command(self, command, reinit_subcommands=0, **kw):
cmd = _Command.reinitialize_command(self, command, reinit_subcommands)
vars(cmd).update(kw)
return cmd
# we can't patch distutils.cmd, alas
distutils.core.Command = Command
def _find_all_simple(path):
"""
Find all files under 'path'
"""
results = (
os.path.join(base, file)
for base, dirs, files in os.walk(path, followlinks=True)
for file in files
)
return filter(os.path.isfile, results)
def findall(dir=os.curdir):
"""
Find all files under 'dir' and return the list of full filenames.
Unless dir is '.', return full filenames with dir prepended.
"""
files = _find_all_simple(dir)
if dir == os.curdir:
make_rel = functools.partial(os.path.relpath, start=dir)
files = map(make_rel, files)
return list(files)
# fix findall bug in distutils (http://bugs.python.org/issue12885)
distutils.filelist.findall = findall
setuptools-20.7.0/setuptools/archive_util.py 0000775 0001750 0001750 00000014721 12702524020 022140 0 ustar travis travis 0000000 0000000 """Utilities for extracting common archive formats"""
__all__ = [
"unpack_archive", "unpack_zipfile", "unpack_tarfile", "default_filter",
"UnrecognizedFormat", "extraction_drivers", "unpack_directory",
]
import zipfile
import tarfile
import os
import shutil
import posixpath
import contextlib
from pkg_resources import ensure_directory, ContextualZipFile
from distutils.errors import DistutilsError
class UnrecognizedFormat(DistutilsError):
"""Couldn't recognize the archive type"""
def default_filter(src,dst):
"""The default progress/filter callback; returns True for all files"""
return dst
def unpack_archive(filename, extract_dir, progress_filter=default_filter,
drivers=None):
"""Unpack `filename` to `extract_dir`, or raise ``UnrecognizedFormat``
`progress_filter` is a function taking two arguments: a source path
internal to the archive ('/'-separated), and a filesystem path where it
will be extracted. The callback must return the desired extract path
(which may be the same as the one passed in), or else ``None`` to skip
that file or directory. The callback can thus be used to report on the
progress of the extraction, as well as to filter the items extracted or
alter their extraction paths.
`drivers`, if supplied, must be a non-empty sequence of functions with the
same signature as this function (minus the `drivers` argument), that raise
``UnrecognizedFormat`` if they do not support extracting the designated
archive type. The `drivers` are tried in sequence until one is found that
does not raise an error, or until all are exhausted (in which case
``UnrecognizedFormat`` is raised). If you do not supply a sequence of
drivers, the module's ``extraction_drivers`` constant will be used, which
means that ``unpack_zipfile`` and ``unpack_tarfile`` will be tried, in that
order.
"""
for driver in drivers or extraction_drivers:
try:
driver(filename, extract_dir, progress_filter)
except UnrecognizedFormat:
continue
else:
return
else:
raise UnrecognizedFormat(
"Not a recognized archive type: %s" % filename
)
def unpack_directory(filename, extract_dir, progress_filter=default_filter):
""""Unpack" a directory, using the same interface as for archives
Raises ``UnrecognizedFormat`` if `filename` is not a directory
"""
if not os.path.isdir(filename):
raise UnrecognizedFormat("%s is not a directory" % filename)
paths = {
filename: ('', extract_dir),
}
for base, dirs, files in os.walk(filename):
src, dst = paths[base]
for d in dirs:
paths[os.path.join(base, d)] = src + d + '/', os.path.join(dst, d)
for f in files:
target = os.path.join(dst, f)
target = progress_filter(src + f, target)
if not target:
# skip non-files
continue
ensure_directory(target)
f = os.path.join(base, f)
shutil.copyfile(f, target)
shutil.copystat(f, target)
def unpack_zipfile(filename, extract_dir, progress_filter=default_filter):
"""Unpack zip `filename` to `extract_dir`
Raises ``UnrecognizedFormat`` if `filename` is not a zipfile (as determined
by ``zipfile.is_zipfile()``). See ``unpack_archive()`` for an explanation
of the `progress_filter` argument.
"""
if not zipfile.is_zipfile(filename):
raise UnrecognizedFormat("%s is not a zip file" % (filename,))
with ContextualZipFile(filename) as z:
for info in z.infolist():
name = info.filename
# don't extract absolute paths or ones with .. in them
if name.startswith('/') or '..' in name.split('/'):
continue
target = os.path.join(extract_dir, *name.split('/'))
target = progress_filter(name, target)
if not target:
continue
if name.endswith('/'):
# directory
ensure_directory(target)
else:
# file
ensure_directory(target)
data = z.read(info.filename)
with open(target, 'wb') as f:
f.write(data)
unix_attributes = info.external_attr >> 16
if unix_attributes:
os.chmod(target, unix_attributes)
def unpack_tarfile(filename, extract_dir, progress_filter=default_filter):
"""Unpack tar/tar.gz/tar.bz2 `filename` to `extract_dir`
Raises ``UnrecognizedFormat`` if `filename` is not a tarfile (as determined
by ``tarfile.open()``). See ``unpack_archive()`` for an explanation
of the `progress_filter` argument.
"""
try:
tarobj = tarfile.open(filename)
except tarfile.TarError:
raise UnrecognizedFormat(
"%s is not a compressed or uncompressed tar file" % (filename,)
)
with contextlib.closing(tarobj):
# don't do any chowning!
tarobj.chown = lambda *args: None
for member in tarobj:
name = member.name
# don't extract absolute paths or ones with .. in them
if not name.startswith('/') and '..' not in name.split('/'):
prelim_dst = os.path.join(extract_dir, *name.split('/'))
# resolve any links and to extract the link targets as normal
# files
while member is not None and (member.islnk() or member.issym()):
linkpath = member.linkname
if member.issym():
base = posixpath.dirname(member.name)
linkpath = posixpath.join(base, linkpath)
linkpath = posixpath.normpath(linkpath)
member = tarobj._getmember(linkpath)
if member is not None and (member.isfile() or member.isdir()):
final_dst = progress_filter(name, prelim_dst)
if final_dst:
if final_dst.endswith(os.sep):
final_dst = final_dst[:-1]
try:
# XXX Ugh
tarobj._extract_member(member, final_dst)
except tarfile.ExtractError:
# chown/chmod/mkfifo/mknode/makedev failed
pass
return True
extraction_drivers = unpack_directory, unpack_zipfile, unpack_tarfile
setuptools-20.7.0/setuptools/cli-32.exe 0000664 0001750 0001750 00000200000 12702524020 020564 0 ustar travis travis 0000000 0000000 MZ ÿÿ ¸ @ à º ´ Í!¸LÍ!This program cannot be run in DOS mode.
$ YSþj 29 29 29:ôë9 29 2‘9F29 }929`9929`929`9m29`9 29Rich 29 PE L ø°‹Q à Ê N ç% à @ @ € ,ù ( ˆô @ à @ .text ]É Ê `.rdata ` à " Î @ @.data Ä+ ð @ À Q‹D$PŠ@„ÉuùSUV+ÂW‹èD-jPès
ƒÄ3ÿ3Û‰D$Æ "p…í~Wë› ‹L$Š <\uGë <"u…ÿ~Wj\Vè
ƒÄ ÷3ÿÆ\Fë3ÿ‹T$ŠˆCF;Ý|Ã…ÿ~Wj\VèV
ƒÄ ÷‹D$_Æ"ÆF ^][YÃì ¡€A 3ĉ„$ V‹´$ W‹¼$ Š‹Ï„Àtd$ A ƒÀ@Pè ƒÄ F^‹Œ$ 3Ìè! Ä ÃWh Œ$ QV虫 V¼, 訊 „$, ƒÄH@;ÇsŠ„Ét
€ù
t€ù
uëj”$ hâ@ RÆ èT
ƒÄ …Àt2¡â@ ‹
â@ ‹ â@ ‰„$ â@ ‰Œ$ ‰”$$ ˆ„$( L$Q”$" Rè…ûÿÿ‹0‰D$ D$$PVè$úÿÿ‹øƒÄ‰|$ …ÿu Vhàá@ éµ S‹\$ U‹¬$, +‰D$ @jPèå ‹ðW‰t$ èCùÿÿ‰¿ ƒÄ ƒÆ;ß~ ‹ÿ‹L$ ‹¹Rè#ùÿÿ‰GƒÄƒÆ;û|æD$$Pè ùÿÿ‰¿ ƒÄƒÆ;ï~‹L$‹¹Rèîøÿÿ‰GƒÄƒÆ;ý|惼$4 ]Ç [tE‹D$‹t$ PVè$¤ ƒÄVhÌá@ è“ ƒÀ@Pèn ƒÄ _¸ ^‹Œ$ 3Ìès Ä Ã‹L$‹T$‹D$ QRPè†üÿÿPèÀûÿÿ‹Œ$, ƒÄ_^3Ìè? Ä ÃÌÌÌÌÌÌ‹D$‹L$j PQè ýÿÿƒÄ Ãj hðô@ èŸ 3ö‰uä3À‹];Þ•À;Æu è; Ç VVVVVèà ƒÄƒÈÿéÍ 3À9u •À;ÆtÔ‰]SèŸ Y‰uüöC @uwSè* Yƒøÿtƒøþt‹ÐÁú‹Èƒá Áá • *A 빘A öA$u)ƒøÿtƒøþt‹ÈÁùƒà Áà *A 븘A ö@$€t è¡ Ç VVVVVè) ƒÄƒMäÿ9uäu#SèL
‹øEPVÿu Sè² ‰EäSWèÎ
ƒÄ ÇEüþÿÿÿè ‹Eäèß ÃÿuèL Yø A áÀ;A Vj^…Àu¸ ë;Æ}‹Æ£À;A jPè“ YY£¼+A …Àu jV‰5À;A èz YY£¼+A …ÀujX^Ã3Ò¹ A 롼+A ‰ ƒÁ ƒÂù€A |êjþ^3Ò¹A W‹ÂÁø‹… *A ‹úƒç Á狃øÿt;Æt…Àu‰1ƒÁ BùpA |Î_3À^Ãè§# €=0 A tèp! ÿ5¼+A è× YËÿU‹ìV‹u¸ A ;ðr"þ`A w‹Î+ÈÁùƒÁQèç$ N € Yë
ƒÆ Vÿà@ ^]ËÿU‹ì‹Eƒø}ƒÀPèº$ ‹E H € Y]ËE ƒÀ Pÿà@ ]ËÿU‹ì‹E¹ A ;Ár =`A w` ÿÿÿ+ÁÁøƒÀPè—# Y]ÃÀ Pÿ à@ ]ËÿU‹ì‹Mƒù‹E }` ÿÿÿƒÁQèh# Y]ÃÀ Pÿ à@ ]ËÿU‹ìQƒeü VEüPÿu ÿuèL$ ‹ðƒÄ …öu9Eütèa …Àt
èX ‹Mü‰‹Æ^ÉÃÌÌÌÌÌÌÌÌÌÌ‹T$ ‹L$…Òti3ÀŠD$„Àuú rƒ=ˆ*A tée% W‹ùƒúr1÷Ùƒát +шƒÇƒéuö‹ÈÁàÁ‹ÈÁàÁ‹ÊƒâÁétó«…Òt
ˆƒÇƒêuö‹D$_ËD$ÃÌÌÌÌÌÌ‹L$ W…É„’ VS‹Ù‹t$÷Æ ‹|$u Áé…… ë'ŠƒÆˆƒÇƒét+„Àt/÷Æ uå‹ÙÁéuaƒãtŠƒÆˆƒÇ„Àt7ƒëuí‹D$[^_Ã÷Ç tˆƒÇƒé„˜ ÷Ç uê‹ÙÁéutˆƒÇƒëuö[^‹D$_ɃǃétŸºÿþþ~‹Ðƒðÿ3‹ƒÆ© tÜ„Òt,„öt ÷ ÿ t ÷ ÿuĉëâÿÿ ‰ëâÿ ‰ë3Ò‰ƒÇ3Àƒét 3À‰ƒÇƒéuöƒã…wÿÿÿ‹D$[^_ËÿU‹ìÿuÿuÿuÿu jÿÿuè % ƒÄ]ËÿU‹ìQQS3ÛVW‰]ø9]t}‹M ;Ëu9]uqë9]tj9]u9]u`ë9]tY9] u9] uOë9] tH9]$u>9](u>‹u3À@8 tHF;Ãwö€>:u5;Ëtƒ}‚õ jÿujÿQè%& ƒÄF‰uë9](uÂÇEø éÎ ;Ëtˆ‹u3ÿ‰]ü8 tU¾PèØ% Y…ÀtFëŠ é¤þÿÿ‹ÿU‹ìV‹uVèS Pè? YY…Àt|èÐòÿÿƒÀ ;ðu3ÀëèÀòÿÿƒÀ@;ðu`3À@ÿ A ÷F uNSW<…H A ƒ? » u Sè Y‰…ÀuFj‰F‰X‰F‰Fë
‹?‰~‰>‰^‰^N 3À_@[ë3À^]ËÿU‹ìƒ} t'V‹u ÷F tVè f ÿîÿÿƒf ƒ& ƒf Y^]ÃöA @tƒy t$ÿIx ‹ˆÿ¶Àë ¾ÀQPèå- YYƒøÿu ÃÿËÿU‹ìV‹ðë‹MŠEÿM èµÿÿÿƒ>ÿtƒ} ç^]ËÿU‹ìöG @SV‹ð‹Ùt2ƒ u,‹Eë+ŠÿM‹Ïè}ÿÿÿCƒ>ÿuèÕ ƒ8*u‹Ï°?èdÿÿÿƒ} Õ^[]ËÿU‹ììx ¡€A 3ʼnEüS‹] V‹u3ÀW‹}ÿu¤ýÿÿ‰µ´ýÿÿ‰½Üýÿÿ‰…¸ýÿÿ‰…ðýÿÿ‰…Ìýÿÿ‰…èýÿÿ‰…Ðýÿÿ‰…Àýÿÿ‰…Èýÿÿè#÷ÿÿ…öu5èM Ç 3ÀPPPPPèÓ ƒÄ€½°ýÿÿ t
‹…¬ýÿÿƒ`pýƒÈÿéÈ
öF @u^Vè@
Yº˜A ƒøÿtƒøþt‹Èƒá ‹ðÁþÁá µ *A ë‹ÊöA$u‘ƒøÿtƒøþt‹Èƒà ÁùÁà *A ë‹Âö@$€…gÿÿÿ3É;Ù„]ÿÿÿŠ‰Øýÿÿ‰àýÿÿ‰¼ýÿÿˆ•ïýÿÿ„Ò„
Cƒ½Øýÿÿ ‰ÄýÿÿŒ
ŠÂ, If90t@@;Îuô+…äýÿÿÑøë(;þu ¡A ‰…äýÿÿ‹…äýÿÿëI€8 t@;Îuõ+…äýÿÿ‰…àýÿÿƒ½Àýÿÿ …\ ‹…ðýÿÿ¨@t2© t Æ…Ôýÿÿ-ë¨t Æ…Ôýÿÿ+ë ¨tÆ…Ôýÿÿ Ç…Ðýÿÿ ‹Ìýÿÿ+àýÿÿ+Ðýÿÿö…ðýÿÿ uÿµ´ýÿÿ…ØýÿÿSj èpõÿÿƒÄ ÿµÐýÿÿ‹½´ýÿÿ…ØýÿÿÔýÿÿèvõÿÿö…ðýÿÿYtö…ðýÿÿuWSj0…Øýÿÿè.õÿÿƒÄ ƒ½Èýÿÿ ‹…àýÿÿtf…À~b‹µäýÿÿ‰… ýÿÿ·ÿ ýÿÿPjEôP…˜ýÿÿFPFè5 ƒÄ…Àu(9…˜ýÿÿt ÿµ˜ýÿÿ…ØýÿÿMôèñôÿÿƒ½ ýÿÿ Yuµë ƒØýÿÿÿë‹äýÿÿP…ØýÿÿèÊôÿÿYƒ½Øýÿÿ |ö…ðýÿÿtWSj …Øýÿÿè‚ôÿÿƒÄ ƒ½¼ýÿÿ tÿµ¼ýÿÿè ƒ¥¼ýÿÿ Y‹ÄýÿÿŠˆ…ïýÿÿ„Àt‹”ýÿÿ‹½ÜýÿÿŠÐéáõÿÿ€½°ýÿÿ t
‹…¬ýÿÿƒ`pý‹…Øýÿÿ‹Mü_^3Í[èìÿÿÉÃê*@ ë(@ )@ y)@ Å)@ Ð)@ *@ D+@ jThPõ@ èe 3ÿ‰}üEœPÿ@à@ ÇEüþÿÿÿj@j ^Vèu YY;Ç„ £ *A ‰5*A ˆ ë0Æ@ ƒÿÆ@
‰xÆ@$ Æ@%
Æ@&
‰x8Æ@4 ƒÀ@‹
*A Á ;ÁrÌf9}΄
‹EÐ;Ç„ÿ ‹8X;‰Eä¾ ;þ|‹þÇEà ë[j@j èç YY…ÀtV‹Mà *A ‰ƒ*A ë*Æ@ ƒÿÆ@
ƒ` €`$€Æ@%
Æ@&
ƒ`8 Æ@4 ƒÀ@‹Ö;ÂrÒÿEà9=*A |ë‹=*A ƒeà …ÿ~m‹E䋃ùÿtVƒùþtQŠ¨tK¨u Qÿ<à@ …Àt<‹uà‹ÆÁøƒæ Áæ4… *A ‹Eä‹ ‰ŠˆFh F Pè€* YY…À„É ÿFÿEàCƒEä9}à|“3Û‹óÁæ5 *A ‹ƒøÿt ƒøþt€N€ërÆF…ÛujöXë
‹ÃH÷ØÀƒÀõPÿ8à@ ‹øƒÿÿtC…ÿt?Wÿ<à@ …Àt4‰>%ÿ ƒøu€N@ë ƒøu€Nh F Pèê) YY…Àt7ÿFë
€N@ÇþÿÿÿCƒûŒgÿÿÿÿ5*A ÿ4à@ 3Àë3À@ËeèÇEüþÿÿÿƒÈÿèc ËÿU‹ì‹EV3ö;Æu è½ VVVVVÇ èE ƒÄƒÈÿë‹@^]ËÿU‹ì‹E£P A ]ËÿU‹ìì( ¡€A 3ʼnEüƒ¥Øüÿÿ SjL…Üüÿÿj Pè åÿÿ…Øüÿÿ‰…(ýÿÿ…0ýÿÿƒÄ ‰…,ýÿÿ‰…àýÿÿ‰Üýÿÿ‰•Øýÿÿ‰Ôýÿÿ‰µÐýÿÿ‰½ÌýÿÿfŒ•øýÿÿfŒìýÿÿfŒÈýÿÿfŒ…ÄýÿÿfŒ¥ÀýÿÿfŒ¼ýÿÿœ…ðýÿÿ‹EMÇ…0ýÿÿ ‰…èýÿÿ‰ôýÿÿ‹Iü‰äýÿÿÇ…Øüÿÿ ÀÇ…Üüÿÿ ‰…äüÿÿÿXà@ j ‹ØÿTà@ …(ýÿÿPÿPà@ …Àu …Ûujèé1 Yh ÀÿLà@ PÿHà@ ‹Mü3Í[è(èÿÿÉËÿU‹ìÿ5P A è& Y…Àt]ÿàjèª1 Y]é²þÿÿ‹ÿU‹ì‹E3É;ÍØA tAƒù-rñHíƒùwj
X]ËÍÜA ]ÃDÿÿÿjY;ÈÀ#ÁƒÀ]Ãèœ …Àu¸@A ÃÀÃè‰ …Àu¸DA ÃÀ ËÿU‹ìVèâÿÿÿ‹MQ‰è‚ÿÿÿY‹ðè¼ÿÿÿ‰0^]ÃÌÌÌhÐ7@ dÿ5 ‹D$‰l$l$+àSVW¡€A 1Eü3ÅP‰eèÿuø‹EüÇEüþÿÿÿ‰EøEðd£ ËMðd‰
Y__^[‹å]QÃÌÌÌÌÌÌÌ‹ÿU‹ìƒìS‹] V‹s35€A W‹ÆEÿ ÇEô {ƒøþt
‹NÏ3 8èÙæÿÿ‹N ‹FÏ3 8èÉæÿÿ‹Eö@f… ‹MUè‰Sü‹[ ‰Eè‰Mìƒûþt_I [‹L†D†‰Eð‹ ‰Eø…Ét‹×è$1 ÆEÿ…À|@G‹Eø‹Øƒøþu΀}ÿ t$‹ƒøþt
‹NÏ3 8èVæÿÿ‹N ‹VÏ3 :èFæÿÿ‹Eô_^[‹å]ÃÇEô ëÉ‹M9csmàu)ƒ=Œ*A t hŒ*A èƒ! ƒÄ…Àt‹UjRÿŒ*A ƒÄ‹M èÇ0 ‹E 9X th€A W‹Ó‹ÈèÊ0 ‹E ‹Mø‰H ‹ƒøþt
‹NÏ3 8èÃåÿÿ‹N ‹VÏ3 :è³åÿÿ‹Eð‹H‹×è]0 ºþÿÿÿ9S „Rÿÿÿh€A W‹Ëèu0 é ÿÿÿ‹ÿU‹ìVW3öÿuèÅ0 ‹øY…ÿu'9T A v Vÿ$à@ †è ;T A vƒÈÿ‹ðƒøÿuÊ‹Ç_^]ËÿU‹ìVW3öj ÿu ÿuèE ‹øƒÄ …ÿu'9T A v Vÿ$à@ †è ;T A vƒÈÿ‹ðƒøÿuËÇ_^]ËÿU‹ìVW3öÿu ÿuèû0 ‹øYY…ÿu,9E t'9T A v Vÿ$à@ †è ;T A vƒÈÿ‹ðƒøÿuÁ‹Ç_^]ËÿU‹ìVW3öÿuÿu ÿuèÅ2 ‹øƒÄ …ÿu,9Et'9T A v Vÿ$à@ †è ;T A vƒÈÿ‹ðƒøÿu½‹Ç_^]Ãj hpõ@ è×üÿÿ‹u…ötuƒ=„*A uCjè Yƒeü Vè×2 Y‰Eä…Àt VPèø2 YYÇEüþÿÿÿè ƒ}ä u7ÿuë
jè YÃVj ÿ5t)A ÿ`à@ …Àuè üÿÿ‹ðÿ\à@ PèÐûÿÿ‰Yè›üÿÿÃjhõ@ èIüÿÿ3Û‰]äjè– Y‰]üj_‰}à;=À;A }W‹÷Á桼+A Æ9tD‹ ö@ ƒtPèj= YƒøÿtÿEäƒÿ|(¡¼+A ‹ƒÀ PÿDà@ ¡¼+A ÿ4èýþÿÿY¡¼+A ‰ GëžÇEüþÿÿÿè ‹EäèüÿÿÃjè7 YËÿU‹ìSV‹u‹F ‹È€á3Û€ùu@© t9‹FW‹>+ø…ÿ~,WPVèeùÿÿYPè‡D ƒÄ ;Çu‹F „Àyƒàý‰F ëƒN ƒËÿ_‹Fƒf ‰^‹Ã[]ËÿU‹ìV‹u…öu Vè5 Yë/Vè|ÿÿÿY…ÀtƒÈÿë ÷F @ tVèüøÿÿPèûD Y÷ØYÀë3À^]Ãjh°õ@ èúúÿÿ3ÿ‰}ä‰}ÜjèD Y‰}ü3ö‰uà;5À;A ƒ ¡¼+A °98t^‹ ö@ ƒtVPVèDÝÿÿYY3ÒB‰Uü¡¼+A ‹°‹H öÁƒt/9UuPèJÿÿÿYƒøÿt ÿEäë9}uöÁtPè/ÿÿÿYƒøÿu E܉}üè Fë„3ÿ‹uࡼ+A ÿ4°VèMÝÿÿYYÃÇEüþÿÿÿè ƒ}‹Eät‹EÜè{úÿÿÃjè YÃjè ÿÿÿYËÿVW3ö¿X A ƒ<õLA u õHA ‰8h ÿ0ƒÇè}! YY…Àt Fƒþ$|Ò3À@_^Ã$õHA 3Àëñ‹ÿS‹ Dà@ V¾HA W‹>…ÿtƒ~t
WÿÓWèÐüÿÿƒ& YƒÆþhA |ܾHA _‹…Àt ƒ~uPÿÓƒÆþhA |æ^[ËÿU‹ì‹Eÿ4ÅHA ÿ à@ ]Ãj hØõ@ è^ùÿÿ3ÿG‰}ä3Û9 t)A uè´ j è hÿ è€ãÿÿYY‹u4õHA 9 t‹Çënjè ûÿÿY‹ø;ûuèÅøÿÿÇ 3ÀëQj
èY Y‰]ü9 u,h Wèt YY…ÀuWèþûÿÿYèøÿÿÇ ‰]äë ‰>ëWèãûÿÿYÇEüþÿÿÿè ‹EäèöøÿÿÃj
è(ÿÿÿYËÿU‹ì‹EV4ÅHA ƒ> uPè"ÿÿÿY…ÀujètâÿÿYÿ6ÿà@ ^]Ãj høõ@ èhøÿÿ‹M3ÿ;Ïv.jàX3Ò÷ñ;E À@u èÿ÷ÿÿÇ WWWWWè‡÷ÿÿƒÄ3ÀéÕ ¯M ‹ñ‰u;÷u3öF3Û‰]äƒþàwiƒ=„*A uKƒÆƒæð‰u ‹E;p*A w7jèLÿÿÿY‰}üÿuèè5 Y‰EäÇEüþÿÿÿè_ ‹]ä;ßtÿuWSè6ÛÿÿƒÄ ;ßuaVjÿ5t)A ÿdà@ ‹Ø;ßuL9=€)A t3Vè’ Y…À…rÿÿÿ‹E;Ç„PÿÿÿÇ éEÿÿÿ3ÿ‹u jèðýÿÿYÃ;ßu
‹E;ÇtÇ ‹Ãèœ÷ÿÿÃU‹ìƒì‰}ü‹}‹M ÁéfïÀë¤$ ffGfG fG0fG@fGPfG`fGp¿€ IuЋ}ü‹å]ÃU‹ìƒì‰}ü‹E™‹ø3ú+úƒç3ú+ú…ÿu<‹M‹Ñƒâ‰Uô;Êt+ÊQPèsÿÿÿƒÄ‹E‹Uô…ÒtEE+‰Eø3À‹}ø‹Môóª‹Eë.÷߃lj}ð3À‹}‹Mðóª‹Eð‹M‹UÈ+ÐRj Qè~ÿÿÿƒÄ ‹E‹}ü‹å]Ãj hö@ èdöÿÿƒeü f(ÁÇEä ë#‹Eì‹ ‹ = Àt
= Àt3ÀÃ3À@Ëeèƒeä ÇEüþÿÿÿ‹EäèföÿÿËÿU‹ìƒì3ÀS‰Eü‰Eô‰EøSœX‹È5 PœZ+Ñt Q3À¢‰Eô‰]è‰Uì‰M𸠢‰Uü‰Eø[÷Eü tè\ÿÿÿ…Àt3À@ë3À[ÉÃè™ÿÿÿ£ˆ*A 3ÀËÿU‹ìQSV‹u3ÛW;ót9] w èIõÿÿjYSSSSS‹ñ‰èÐôÿÿƒÄ‹ÆéÍ ‹E3ÿ;ÃtŠ :Ãtj_9} † ˆFÆ:F‹M‹Á;Ët@8t<ë‹}ü‹U G‰}ü;úsyŠˆF@8uèPQèŒ@ Š YYŠˆF@8uð‹E ;Ãt'Š:Ët!€ù.tG;} s Æ.Fë G;} sŠˆF@8uðG;} v‹Eˆèlôÿÿj"é ÿÿÿˆ 3À_^[ÉËÿU‹ìƒìÿuMðèÜÿÿ¶E ‹MôŠU„T u ƒ} t‹Mð‹‰È ·A#Eë3À…Àt3À@€}ü t‹MøƒapýÉËÿU‹ìjj ÿuÿu è™ÿÿÿƒÄ]ËÿU‹ìjj ÿuj èÿÿÿƒÄ]ËÿU‹ìj ÿuÿuÿu ÿuè…? ƒÄ]ËÿU‹ìì( £°"A ‰
¬"A ‰¨"A ‰ ¤"A ‰5 "A ‰=œ"A fŒÈ"A fŒ
¼"A fŒ ˜"A fŒ”"A fŒ%"A fŒ-Œ"A œÀ"A ‹E £´"A ‹E£¸"A E£Ä"A ‹…àüÿÿÇ "A ¡¸"A £´!A Ǩ!A ÀǬ!A ¡€A ‰…Øüÿÿ¡„A ‰…ÜüÿÿÿXà@ £ø!A jèO$ Yj ÿTà@ hÔâ@ ÿPà@ ƒ=ø!A ujè+$ Yh ÀÿLà@ PÿHà@ ÉÃ-¤ t"ƒètƒè
t Ht3Àø ø ø ø ËÿVW‹ðh 3ÿF WPè+Öÿÿ3À·È‹Á‰~‰~‰~ Áá Á~«««¹hA ƒÄ F +ο Šˆ@Ou÷† ¾ Šˆ@Nu÷_^ËÿU‹ìì ¡€A 3ʼnEüSW…èúÿÿPÿvÿhà@ ¿ …À„û 3Àˆ„üþÿÿ@;ÇrôŠ…îúÿÿÆ…üþÿÿ „Àt.ïúÿÿ¶È¶;Èw+Á@P”
üþÿÿj RèhÕÿÿƒÄ CŠC„ÀuØj ÿv …üúÿÿÿvPW…üþÿÿPjj èE 3ÛSÿv…üýÿÿWPW…üþÿÿPWÿv SèúB ƒÄDSÿv…üüÿÿWPW…üþÿÿPh ÿv SèÕB ƒÄ$3À·ŒEüúÿÿöÁt€L ŠŒüýÿÿëöÁt€L ŠŒüüÿÿˆŒ ëÆ„ @;Çr¾ëV† Ç…äúÿÿŸÿÿÿ3É)…äúÿÿ‹•äúÿÿ„ ÐZ ƒûw €L ŠÑ€Â ëƒúw€L ŠÑ€ê ˆëÆ A;Ïr‹Mü_3Í[èOØÿÿÉÃj h8ö@ èÏðÿÿè˜
‹ø¡ŒA …Gpt ƒl t‹wh…öuj èžÚÿÿY‹ÆèçðÿÿÃj
èó÷ÿÿYƒeü ‹wh‰uä;5A t6…ötVÿpà@ …ÀuþhA tVè‡óÿÿY¡A ‰Gh‹5A ‰uäVÿlà@ ÇEüþÿÿÿè 뎋uäj
è¸öÿÿYËÿU‹ìƒìS3ÛSMðè¤×ÿÿ‰ Ì$A ƒþþu ÇÌ$A ÿxà@ 8]ütE‹Møƒapýë<ƒþýuÇÌ$A ÿtà@ ëÛƒþüu‹Eð‹@ÇÌ$A ëÄ8]üt‹Eøƒ`pý‹Æ[ÉËÿU‹ìƒì ¡€A 3ʼnEüS‹] V‹uWèdÿÿÿ‹ø3ö‰};þu‹Ãè·üÿÿ3Àé ‰uä3À9¸˜A „‘ ÿEäƒÀ0=ð rçÿèý „p ÿéý „d ·ÇPÿ|à@ …À„R EèPWÿhà@ …À„3 h C VPèˆÒÿÿ3ÒBƒÄ ‰{‰s 9Uè†ø €}î „Ï uɄ ¶Fÿ¶Éé¦ h C VPèAÒÿÿ‹MäƒÄ kÉ0‰u౨A ‰uäë*ŠF„Àt(¶>¶Àë‹EàŠ€”A D; ¶FG;øvê‹}FF€> uÑ‹uäÿEàƒÆƒ}à‰uäré‹Ç‰{ÇC ègûÿÿj‰C C‰œA Zf‹1Af‰0A@@Juó‹óè×ûÿÿé·þÿÿ€L @;ÁvöFF€~ÿ …4ÿÿÿC ¹þ €@Iuù‹Cèûÿÿ‰C ‰Së‰s3À·È‹ÁÁá Á{«««ë¨95Ì$A …XþÿÿƒÈÿ‹Mü_^3Í[èJÕÿÿÉÃjhXö@ èÊíÿÿƒMàÿè ‹ø‰}ÜèÜüÿÿ‹_h‹uèuýÿÿ‰E;C„W h è‚ïÿÿY‹Ø…Û„F ¹ˆ ‹wh‹ûó¥ƒ# Sÿuè¸ýÿÿYY‰Eà…À…ü ‹uÜÿvhÿpà@ …Àu‹Fh=hA tPècðÿÿY‰^hS‹=là@ ÿ×öFp…ê öŒA …Ý j
ètôÿÿYƒeü ‹C£Ü$A ‹C£à$A ‹C £ä$A 3À‰Eäƒø}f‹LCf‰ EÐ$A @ëè3À‰Eä= }
ŠL ˆˆˆA @ëé3À‰Eä= }ŠŒ ˆˆA @ëæÿ5A ÿpà@ …Àu¡A =hA tPèªïÿÿY‰ A Sÿ×ÇEüþÿÿÿè ë0j
èíòÿÿYÃë%ƒøÿu ûhA tSètïÿÿYèìÿÿÇ ëƒeà ‹Eàè‚ìÿÿÃ=°+A ujýèVþÿÿYÇ°+A 3ÀËÿU‹ìSV‹u‹†¼ 3ÛW;Ãto=H A th‹†° ;Ãt^9uZ‹†¸ ;Ãt9uPèûîÿÿÿ¶¼ è;A YY‹†´ ;Ãt9uPèÚîÿÿÿ¶¼ èÕ@ YYÿ¶° èÂîÿÿÿ¶¼ è·îÿÿYY‹†À ;ÃtD9u@‹†Ä -þ Pè–îÿÿ‹†Ì ¿€ +ÇPèƒîÿÿ‹†Ð +ÇPèuîÿÿÿ¶À èjîÿÿƒÄ¾Ô ‹=ˆ A t9˜´ uPè»> ÿ7èCîÿÿYY~PÇE øA t‹;Ãt 9uPè îÿÿY9_üt‹G;Ãt 9uPèîÿÿYƒÇÿMuÇVèøíÿÿY_^[]ËÿU‹ìSV‹5là@ W‹}WÿÖ‹‡° …ÀtPÿÖ‹‡¸ …ÀtPÿÖ‹‡´ …ÀtPÿÖ‹‡À …ÀtPÿÖ_PÇE {øA t ‹…ÀtPÿÖƒ{ü t
‹C…ÀtPÿÖƒÃÿMuÖ‹‡Ô ´ PÿÖ_^[]ËÿU‹ìW‹}…ÿ„ƒ SV‹5pà@ WÿÖ‹‡° …ÀtPÿÖ‹‡¸ …ÀtPÿÖ‹‡´ …ÀtPÿÖ‹‡À …ÀtPÿÖ_PÇE {øA t ‹…ÀtPÿÖƒ{ü t
‹C…ÀtPÿÖƒÃÿMuÖ‹‡Ô ´ PÿÖ^[‹Ç_]Ã…ÿt7…Àt3V‹0;÷t(W‰8èÁþÿÿY…ötVèEÿÿÿƒ> Yuþ˜A tVèYýÿÿY‹Ç^Ã3ÀÃj hxö@ ècéÿÿè, ‹ð¡ŒA …Fpt"ƒ~l t è ‹pl…öuj è-ÓÿÿY‹ÆèvéÿÿÃj è‚ðÿÿYƒeü Fl‹=pA èiÿÿÿ‰EäÇEüþÿÿÿè ëÁj è}ïÿÿY‹uäËÿU‹ìVÿ5„A ‹5€à@ ÿÖ…Àt!¡€A ƒøÿtPÿ5„A ÿÖÿÐ…Àt‹€ø ë'¾tã@ Vÿ à@ …Àu VènÒÿÿY…Àthdã@ Pÿ(à@ …ÀtÿuÿЉE‹E^]Ãj è‡ÿÿÿYËÿU‹ìVÿ5„A ‹5€à@ ÿÖ…Àt!¡€A ƒøÿtPÿ5„A ÿÖÿÐ…Àt‹€ü ë'¾tã@ Vÿ à@ …Àu VèóÑÿÿY…Àthã@ Pÿ(à@ …ÀtÿuÿЉE‹E^]Ãÿ„à@  ‹ÿVÿ5„A ÿ€à@ ‹ð…öuÿ5%A èeÿÿÿY‹ðVÿ5„A ÿˆà@ ‹Æ^á€A ƒøÿtPÿ5%A è;ÿÿÿYÿЃ
€A ÿ¡„A ƒøÿtPÿŒà@ ƒ
„A ÿéºíÿÿj h˜ö@ è†çÿÿ¾tã@ Vÿ à@ …ÀuVè4ÑÿÿY‰Eä‹uÇF\é@ 3ÿG‰~…Àt$hdã@ P‹ (à@ ÿÓ‰†ø hã@ ÿuäÿÓ‰†ü ‰~pÆ†È CƆK CÇFhhA j
ènîÿÿYƒeü ÿvhÿlà@ ÇEüþÿÿÿè> j èMîÿÿY‰}ü‹E ‰Fl…Àu¡pA ‰FlÿvlèüÿÿYÇEüþÿÿÿè è çÿÿÃ3ÿG‹uj
è5íÿÿYÃj è,íÿÿYËÿVWÿ\à@ ÿ5€A ‹øè‘þÿÿÿЋð…öuNh jè±èÿÿ‹ðYY…öt:Vÿ5€A ÿ5%A èèýÿÿYÿÐ…Àtj VèÅþÿÿYYÿ”à@ ƒNÿ‰ë Vè^éÿÿY3öWÿà@ _‹Æ^ËÿVèÿÿÿ‹ð…öujèÐÿÿY‹Æ^ÃjhÀö@ è æÿÿ‹u…ö„ø ‹F$…ÀtPèéÿÿY‹F,…ÀtPèéÿÿY‹F4…ÀtPèõèÿÿY‹F<…ÀtPèçèÿÿY‹F@…ÀtPèÙèÿÿY‹FD…ÀtPèËèÿÿY‹FH…ÀtPè½èÿÿY‹F\=é@ tPè¬èÿÿYj
èàìÿÿYƒeü ‹~h…ÿtWÿpà@ …ÀuÿhA tWèèÿÿYÇEüþÿÿÿèW j è§ìÿÿYÇEü ‹~l…ÿt#WèóúÿÿY;=pA tÿ˜A t ƒ? uWèÿøÿÿYÇEüþÿÿÿè Vè'èÿÿYèIåÿÿ ‹uj
èvëÿÿYËuj èjëÿÿYËÿVW¾tã@ Vÿ à@ …ÀuVè“ÎÿÿY‹ø…ÿ„^ ‹5(à@ hÀã@ WÿÖh´ã@ W£ %A ÿÖh¨ã@ W£%A ÿÖh ã@ W£%A ÿÖƒ= %A ‹5ˆà@ £%A tƒ=%A t
ƒ=%A t…Àu$¡€à@ £%A ¡Œà@ Ç %A dO@ ‰5%A £%A ÿ„à@ £„A ƒøÿ„Ì ÿ5%A PÿÖ…À„» èÅÐÿÿÿ5 %A èûÿÿÿ5%A £ %A èûÿÿÿ5%A £%A èóúÿÿÿ5%A £%A èãúÿÿƒÄ£%A è¬éÿÿ…ÀtehXQ@ ÿ5 %A è=ûÿÿYÿУ€A ƒøÿtHh jèÓåÿÿ‹ðYY…öt4Vÿ5€A ÿ5%A è
ûÿÿYÿÐ…Àtj VèçûÿÿYYÿ”à@ ƒNÿ‰3À@ëè’ûÿÿ3À_^ËÿU‹ìƒìSÿuMèèÉÊÿÿ‹]C= w‹Eè‹€È ·Xëu‰]Á}EèP‹E%ÿ PèG YY…ÀtŠEjˆEøˆ]ùÆEú Yë
3Ɉ]øÆEù A‹EèjÿpÿpEüPQEøPEèjPè 6 ƒÄ …Àu8Eôt‹Eðƒ`pý3Àë·Eü#E €}ô t‹Mðƒapý[ÉËÿU‹ìQV‹u Vèwàÿÿ‰E ‹F Y¨‚uè8âÿÿÇ ƒN ƒÈÿé/ ¨@t
è âÿÿÇ " ëãS3Û¨t‰^¨„‡ ‹Nƒàþ‰‰F ‹F ƒàïƒÈ‰F ‰^‰]ü© u,è—ÃÿÿƒÀ ;ðt è‹ÃÿÿƒÀ@;ðu
ÿu è© Y…ÀuVè¾? Y÷F W„€ ‹F‹>H‰‹N+øI;û‰N~ WPÿu èÜ* ƒÄ ‰EüëMƒÈ ‰F ƒÈÿëy‹M ƒùÿtƒùþt‹Áƒà ‹ÑÁúÁà• *A 븘A ö@ tjSSQè*> #ƒăøÿt%‹FŠMˆë3ÿGWEPÿu èm* ƒÄ ‰Eü9}üt ƒN ƒÈÿë‹E%ÿ _[^ÉËÿU‹ìQQS‹]VW3ö3ÿ‰}ü; ýˆA t G‰}üƒÿrîƒÿƒw jèz@ Yƒø„4 jèi@ Y…Àu
ƒ=ŒA „ ûü „A hpé@ » S¿ %A Wè08 ƒÄ …Àt
VVVVVèØÞÿÿƒÄh ¾9%A Vj Æ=&A ÿà@ …Àu&hXé@ hû Vèî7 ƒÄ …Àt3ÀPPPPPè”ÞÿÿƒÄVè‡ @Yƒø Yƒøtjèñ> Y…Àu ƒ=ŒA uhü è)þÿÿhÿ è þÿÿYYËÿU‹ìQSVWÿ5¬+A èÊöÿÿÿ5¨+A ‹ø‰}üèºöÿÿ‹ðYY;÷‚ƒ ‹Þ+ßCƒørwWèÕ> ‹øCY;øsH¸ ;øs‹ÇÇ;ÇrPÿuüèsáÿÿYY…ÀuG;Çr@Pÿuüè]áÿÿYY…Àt1ÁûP4˜èÕõÿÿY£¬+A ÿuèÇõÿÿ‰ƒÆVè¼õÿÿY£¨+A ‹EYë3À_^[ÉËÿVjj èÇàÿÿ‹ðVè•õÿÿƒÄ £¬+A £¨+A …öujX^Ã& 3À^Ãj hèö@ èeÞÿÿèÀÈÿÿƒeü ÿuèøþÿÿY‰EäÇEüþÿÿÿè ‹EäèÞÿÿÃèŸÈÿÿËÿU‹ìÿuè·ÿÿÿ÷ØÀ÷ØYH]ËÿV¸àô@ ¾àô@ W‹ø;Æs‹…ÀtÿЃÇ;þrñ_^ËÿV¸èô@ ¾èô@ W‹ø;Æs‹…ÀtÿЃÇ;þrñ_^ËÿVW3ÿ·@ A ÿ6èÆôÿÿƒÇY‰ƒÿ(rè_^ÃÌ‹ÿU‹ì‹M¸MZ f9t3À]ËA<Á8PE uï3Ò¹ f9H”‹Â]ÃÌÌÌÌÌÌÌÌÌÌÌ‹ÿU‹ì‹E‹H<È·ASV·q3ÒWD…öv‹} ‹H ;ùr ‹XÙ;ûr
BƒÀ(;Örè3À_^[]ÃÌÌÌÌÌÌÌÌÌÌÌÌ‹ÿU‹ìjþh÷@ hÐ7@ d¡ PƒìSVW¡€A 1Eø3ÅPEðd£ ‰eèÇEü h @ è*ÿÿÿƒÄ…ÀtU‹E- @ Ph @ èPÿÿÿƒÄ…Àt;‹@$Áè ÷ЃàÇEüþÿÿÿ‹Mðd‰
Y_^[‹å]ËEì‹‹3Ò= À”‹ÂËeèÇEüþÿÿÿ3À‹Mðd‰
Y_^[‹å]Ãjh(÷@ èWÜÿÿè öÿÿ‹@x…Àtƒeü ÿÐë3À@ËeèÇEüþÿÿÿè—< èpÜÿÿÃh
[@ è'óÿÿY£4(A ÃËÿU‹ìQQVè`õÿÿ‹ð…ö„F ‹V\¡t A W‹}‹ÊS99t‹ØkÛ ƒÁ Ú;ËrîkÀ Â;Ès99u‹Áë3À…Àt
‹X‰]ü…Ûu3Àéû ƒûu ƒ` 3À@éê ƒû„Þ ‹N`‰Mø‹M ‰N`‹Hƒù…¸ ‹
h A ‹=l A ‹Ñù;×}$kÉ ‹~\ƒd9 ‹=h A ‹ l A B߃Á ;Ó|â‹]ü‹ ‹~d=Ž Àu ÇFdƒ ë^= Àu ÇFd ëN=‘ Àu ÇFd„ ë>=“ Àu ÇFd… ë.= Àu ÇFd‚ ë = Àu ÇFd† ë=’ ÀuÇFdŠ ÿvdjÿÓY‰~dëƒ` QÿÓ‹EøY‰F`ƒÈÿ[_^ÉËÿU‹ì‹E£8(A £<(A £@(A £D(A ]ËÿU‹ì‹E‹
t A V9Pt‹ñkö uƒÀ ;ÆrìkÉ M^;Ás9Pt3À]Ãÿ5@(A èÚñÿÿYÃj hH÷@ èJÚÿÿ3ÿ‰}ä‰}Ø‹]ƒû Lt‹ÃjY+Át"+Át+Átd+ÁuDèsóÿÿ‹ø‰}Ø…ÿuƒÈÿéa ¾8(A ¡8(A ë`ÿw\‹Óè]ÿÿÿ‹ðƒÆ‹ëZ‹Ãƒèt<ƒèt+Ht èŽÙÿÿÇ 3ÀPPPPPèÙÿÿƒÄ뮾@(A ¡@(A ë¾<(A ¡<(A ë
¾D(A ¡D(A ÇEä Pèñÿÿ‰EàY3Àƒ}à„Ø 9EàujèòÅÿÿ9EätPèÆàÿÿY3À‰Eüƒût
ƒû tƒûu‹O`‰MÔ‰G`ƒûu@‹Od‰MÐÇGdŒ ƒûu.‹
h A ‰MÜ‹
l A ‹h A Ê9MÜ}‹MÜkÉ ‹W\‰DÿEÜëÛè~ðÿÿ‰ÇEüþÿÿÿè ƒûu ÿwdSÿUàYë‹]‹}؃}ä tj èTßÿÿYÃSÿUàYƒût
ƒû tƒûu‹EÔ‰G`ƒûu‹EЉGd3ÀèìØÿÿËÿU‹ì‹E£L(A ]ËÿU‹ì‹E£X(A ]ËÿU‹ì‹E£\(A ]Ãjhh÷@ èmØÿÿƒeü ÿu ÿuÿ à@ ‰Eäë/‹Eì‹ ‹ ‰Eà3É= À”Á‹ÁËeè}à Àujÿà@ ƒeä ÇEüþÿÿÿ‹Eäè_ØÿÿËÿU‹ì‹E£`(A ]ËÿU‹ìÿ5`(A è|ïÿÿY…ÀtÿuÿÐY…Àt3À@]Ã3À]ËÿU‹ì‹E‹ 8csmàu*ƒxu$‹@= “t=!“t="“t= @™uèCûÿÿ3À] hŽ_@ ÿTà@ 3ÀÃ=°+A uèHëÿÿV‹5< A W3ÿ…öuƒÈÿé <=tGVèƒ YtŠ„ÀuêjGWè€Ùÿÿ‹øYY‰= A …ÿtË‹5< A SëBVèR ‹ØC€>=Yt1jSèRÙÿÿYY‰…ÀtNVSPè|. ƒÄ …Àt3ÀPPPPPè"ÕÿÿƒÄƒÇó€> u¹ÿ5< A èÚÿÿƒ%< A ƒ' Ǥ+A 3ÀY[_^Ãÿ5 A èÝÙÿÿƒ% A ƒÈÿëä‹ÿU‹ìQ‹MS3ÀV‰‹ò‹U Ç 9Et ‹]ƒE‰‰Eü€>"u3À9Eü³"”ÀF‰Eüë<ÿ…ÒtŠˆB‰U Š ¶ÃPFè âÿÿY…Àtÿƒ} t
‹M ŠÿE ˆF‹U ‹M„Ût2ƒ}ü u©€û t€û uŸ…ÒtÆBÿ ƒeü €> „é Š< t< uFëóNëã€> „Ð ƒ} t ‹EƒE‰ÿ3ÛC3ÉëFA€>\tù€>"u&öÁu ƒ}ü t F€8"u‹ðë
3À3Û9Eü”À‰EüÑé…ÉtI…ÒtÆ\Bÿ…Éuñ‰U Š„ÀtUƒ}ü u< tK< tG…Ût=¾ÀP…Òt#è9áÿÿY…Àt
Š‹M ÿE ˆFÿ‹M ŠÿE ˆë
èáÿÿY…ÀtFÿÿ‹U FéVÿÿÿ…ÒtÆ B‰U ÿ‹Méÿÿÿ‹E^[…Àtƒ ÿÉËÿU‹ìƒì S3ÛVW9 °+A uèÄèÿÿh ¾h(A VSˆ l)A ÿà@ ¡ +A ‰5( A ;Ãt‰Eü8u‰uü‹UüEøPSS}ôè
þÿÿ‹EøƒÄ =ÿÿÿ?sJ‹MôƒùÿsB‹øÁç;Ár6PèƒÖÿÿ‹ðY;ót)‹UüEøPþWV}ôèÉýÿÿ‹EøƒÄ H£ A ‰5 A 3ÀëƒÈÿ_^[ÉËÿU‹ì¡p)A ƒì SV‹5´à@ W3Û3ÿ;Ãu.ÿÖ‹ø;ût Çp)A ë#ÿ\à@ ƒøxu
jX£p)A ë¡p)A ƒø… ;ûuÿÖ‹ø;ûu3ÀéÊ ‹Çf9 t@@f9uù@@f9uò‹5°à@ SSS+ÇSÑø@PWSS‰EôÿÖ‰Eø;Ãt/Pè©ÕÿÿY‰Eü;Ãt!SSÿuøPÿuôWSSÿÖ…Àu ÿuüè¸ÖÿÿY‰]ü‹]üWÿ¬à@ ‹Ãë\ƒøt;Ãu‚ÿ¨à@ ‹ð;ó„rÿÿÿ8 t
@8uû@8uö+Æ@P‰EøèBÕÿÿ‹øY;ûu Vÿ¤à@ éEÿÿÿÿuøVWè©+ ƒÄ Vÿ¤à@ ‹Ç_^[ÉËÿU‹ì3À9Ej ”Àh Pÿ¸à@ £t)A …Àu]Ã3À@£„*A ]ËÿU‹ìƒì¡€A ƒeø ƒeü SW¿Næ@»» ÿÿ;Çt
…Ãt ÷У„A ë`VEøPÿÌà@ ‹uü3uøÿÈà@ 3ðÿ”à@ 3ðÿÄà@ 3ðEðPÿÀà@ ‹Eô3Eð3ð;÷u¾Oæ@»ë …óu‹ÆÁà ð‰5€A ÷Ö‰5„A ^_[ÉËÿU‹ì‹EƒøþuèÒÿÿÇ 3À]ÃV3ö;Æ|;*A r èæÑÿÿVVVVVÇ ènÑÿÿƒÄ3Àë‹Èƒà Áù‹ *A Áà¾Dƒà@^]á€A ƒÈ3É9x)A ”Á‹ÁÃÌÌÌÌÌÌÌÌ‹L$÷Á t$ŠƒÁ„ÀtN÷Á uï ¤$ ¤$ ‹ºÿþþ~Ѓðÿ3ƒÁ© tè‹Aü„Àt2„ät$© ÿ t© ÿtëÍAÿ‹L$+ÁÃAþ‹L$+ÁÃAý‹L$+ÁÃAü‹L$+ÁËÿU‹ìƒìSV‹u 3ÛW‹};óu;ûv‹E;Ãt‰3Àéƒ ‹E;ÃtƒÿÿÿÿÿvèÇÐÿÿj^SSSSS‰0èPÐÿÿƒÄ‹ÆëVÿuMðès¸ÿÿ‹Eð9X…œ f‹E¹ÿ f;Áv6;ót;ûv WSVè8´ÿÿƒÄ ètÐÿÿÇ * èiÐÿÿ‹ 8]üt‹Møƒapý_^[ÉÃ;ót2;ûw,èIÐÿÿj"^SSSSS‰0èÒÏÿÿƒÄ8]ü„yÿÿÿ‹Eøƒ`pýémÿÿÿˆ‹E;ÃtÇ 8]ü„%ÿÿÿ‹Eøƒ`pýéÿÿÿM QSWVjMQS‰] ÿpÿ°à@ ;Ãt9] …^ÿÿÿ‹M;Ët½‰ë¹ÿ\à@ ƒøz…Dÿÿÿ;ó„gÿÿÿ;û†_ÿÿÿWSVèa³ÿÿƒÄ éOÿÿÿ‹ÿU‹ìj ÿuÿuÿu ÿuè|þÿÿƒÄ]ËÿU‹ìƒìÿu Mðè:·ÿÿ¶E‹Mð‹‰È ·A% € €}ü t‹MøƒapýÉËÿU‹ìj ÿuè¹ÿÿÿYY]ÃÌV‹D$ Àu(‹L$‹D$ 3Ò÷ñ‹Ø‹D$÷ñ‹ð‹Ã÷d$‹È‹Æ÷d$ÑëG‹È‹\$‹T$ ‹D$ÑéÑÛÑêÑØ Éuô÷ó‹ð÷d$‹È‹D$÷æÑr;T$ wr;D$v N+D$T$3Û+D$T$ ÷Ú÷ØƒÚ ‹Ê‹Ó‹Ù‹È‹Æ^ ƒ%€*A ÃÌÌÌSVW‹T$‹D$‹L$URPQQh i@ dÿ5 ¡€A 3ĉD$d‰% ‹D$0‹X‹L$,3‹p ƒþþt;‹T$4ƒúþt;òv.4v\³‹ ‰H ƒ{ uÌh ‹Cè1 ¹ ‹Cè1 ë°d ƒÄ_^[ËL$÷A ¸ t3‹D$‹H3È袵ÿÿU‹hÿp ÿpÿpè>ÿÿÿƒÄ ]‹D$‹T$‰¸ ÃU‹L$‹)ÿq ÿqÿq(èÿÿÿƒÄ ] UVWS‹ê3À3Û3Ò3ö3ÿÿÑ[_^]Ëê‹ñ‹Ájè_0 3À3Û3É3Ò3ÿÿæU‹ìSVWj j hÇi@ Qè—Q _^[]ÃU‹l$RQÿt$è´þÿÿƒÄ ] j hˆ÷@ èÍÿÿƒeä ‹u;5p*A w"jèÄÔÿÿYƒeü Vèa Y‰EäÇEüþÿÿÿè ‹EäèÍÿÿÃjè¿ÓÿÿYËÿU‹ìV‹uƒþà‡¡ SW‹=dà@ ƒ=t)A uèíÿÿj èÏëÿÿhÿ èM·ÿÿYY¡„*A ƒøu…öt‹Æë3À@Pë ƒøu VèSÿÿÿY…Àu…öuFƒÆƒæðVj ÿ5t)A ÿ׋؅Ûu.j ^9€)A tÿuè¢ôÿÿY…Àt‹ué{ÿÿÿèNÌÿÿ‰0èGÌÿÿ‰0_‹Ã[ëVè{ôÿÿYè3ÌÿÿÇ 3À^]Ãjh¨÷@ èhÌÿÿ‹]…Ûuÿu èÿÿÿYéÌ ‹u …öu SècÏÿÿYé· ƒ=„*A …“ 3ÿ‰}äƒþà‡Š jèwÓÿÿY‰}üSè6 Y‰Eà;Ç„ž ;5p*A wIVSPè ƒÄ …Àt‰]äë5Vèç Y‰Eä;Çt'‹CüH;Ær‹ÆPSÿuäè:$ Sèæ ‰EàSPè ƒÄ9}äuH;÷u3öF‰u ƒÆƒæð‰u VWÿ5t)A ÿdà@ ‰Eä;Çt ‹CüH;Ær‹ÆPSÿuäèæ# Sÿuàè¿ ƒÄÇEüþÿÿÿè. ƒ}à u1…öuFƒÆƒæð‰u VSj ÿ5t)A ÿÔà@ ‹øë‹u ‹]jè¨ÑÿÿYË}ä…ÿ…¿ 9=€)A t,VèóÿÿY…À…Òþÿÿè´Êÿÿ9}àul‹ðÿ\à@ Pè_ÊÿÿY‰ë_…ÿ…ƒ èÊÿÿ9}àthÇ ëq…öuFVSj ÿ5t)A ÿÔà@ ‹ø…ÿuV9€)A t4Vè›òÿÿY…Àt ƒþàvÍVè‹òÿÿYèCÊÿÿÇ 3ÀèÇÊÿÿÃè0Êÿÿé|ÿÿÿ…ÿuè"Êÿÿ‹ðÿ\à@ PèÒÉÿÿ‰Y‹ÇëÒ‹ÿU‹ì‹M S3Û;Ëv(jà3ÒX÷ñ;Es èíÉÿÿSSSSSÇ èuÉÿÿƒÄ3ÀëA¯MVW‹ñ9]t ÿuèÈ) Y‹ØVÿuèýÿÿ‹øYY…ÿt;Þs+óVj ßSèXÿÿƒÄ ‹Ç_^[]ËÿU‹ì‹
h*A ¡l*A kÉÈë‹U+P ú r ƒÀ;Árë3À]ËÿU‹ìƒì‹M‹AV‹u W‹þ+y ƒÆüÁï‹ÏiÉ ŒD ‰Mð‹I‰MüöÁ…Ó S 1‹‰Uô‹Vü‰Uø‹Uô‰] öÂutÁúJƒú?vj?Z‹K;KuB» €ƒú s‹ÊÓëL÷Ó!\¸Dþ u#‹M!ë JàÓëL÷Ó!œ¸Ä þ u‹M!Y‹] ‹S‹[‹MüMô‰Z‹U ‹Z‹R‰S‰Mü‹ÑÁúJƒú?vj?Z‹]øƒã‰]ô… +uø‹]øÁûj?‰u K^;Þv‹ÞMø‹ÑÁúJ‰Mü;Öv‹Ö;Út^‹M ‹q;qu;¾ €ƒû s‹ËÓî÷Ö!t¸DþLu!‹M!1ëKàÓî÷Ö!´¸Ä þLu‹M!q‹M ‹q‹I‰N‹M ‹q‹I‰N‹u ë‹]ƒ}ô u;Ú„€ ‹Mð Ñ‹Y‰N‰^‰q‹N‰q‹N;Nu`ŠLˆMþÁˆLƒú s%€} u‹Ê» €Óë‹M » €‹ÊÓëD¸D ë)€} uJà» €Óë‹M YJຠ€Óê„¸Ä ‹Eü‰‰D0ü‹Eðÿ…ó ¡|)A …À„Ø ‹
|*A ‹5¼à@ h @ ÁáH » € SQÿÖ‹
|*A ¡|)A º €Óê P¡|)A ‹@‹
|*A ƒ¤ˆÄ ¡|)A ‹@þHC¡|)A ‹H€yC u ƒ`þ¡|)A ƒxÿueSj ÿp ÿÖ¡|)A ÿpj ÿ5t)A ÿ`à@ ‹
h*A ¡|)A kÉ‹l*A +ÈLìQHQPèí+ ‹EƒÄ ÿ
h*A ;|)A vƒm¡l*A £t*A ‹E£|)A ‰=|*A [_^Éáx*A V‹5h*A W3ÿ;ðu4ƒÀkÀPÿ5l*A Wÿ5t)A ÿÔà@ ;Çu3Àëxƒx*A ‹5h*A £l*A kö5l*A hÄA jÿ5t)A ÿdà@ ‰F;ÇtÇjh h WÿØà@ ‰F ;ÇuÿvWÿ5t)A ÿ`à@ 뛃Nÿ‰>‰~ÿh*A ‹Fƒÿ‹Æ_^ËÿU‹ìQQ‹M‹ASV‹qW3ÛëÀC…À}ù‹ÃiÀ „0D j?‰EøZ‰@‰@ƒÀJuôj‹ûh Áçy h € WÿØà@ …ÀuƒÈÿé — p ‰Uü;úwC‹Ê+ÏÁé GAƒHøÿƒˆì ÿü ‰üïÿÿÇ@üð ‰PÇ€è ð IuË‹Uü‹Eøø O ‰H‰AJ ‰H‰AƒdžD 3ÿG‰¼žÄ ŠFCŠÈþÁ„À‹EˆNCu xº €‹ËÓê÷Ò!P‹Ã_^[ÉËÿU‹ìƒì ‹M‹ASV‹uW‹} ‹×+Q ƒÆÁê‹ÊiÉ ŒD ‰Mô‹OüƒæðI;ñ|9ü‹ ‰M‰]üŽU öÃ…E Ù;ó; ‹MüÁùI‰Møƒù?vj?Y‰Mø‹_;_uC» €ƒù sÓë‹MøL÷Ó!\Dþ u&‹M!ë ƒÁàÓë‹MøL÷Ó!œÄ þ u‹M!Y‹O‹_‰Y‹O‹‰y‹M+ÎMüƒ}ü Ž¥ ‹}ü‹M ÁÿOL1üƒÿ?vj?_‹]ô û‰]‹[‰Y‹]‰Y‰K‹Y‰K‹Y;YuWŠLˆMþÁˆLƒÿ s €} u‹Ï» €Óë‹M DD‹Ïë €} uOà» €Óë‹M Y„Ä Oຠ€Óê ‹U ‹MüD2ü‰‰Lüë‹U F‰Bü‰D2øé< 3Àé8 / ‹] )uN‰Kü\3ü‹uÁþN‰] ‰Küƒþ?vj?^öEü…€ ‹uüÁþNƒþ?vj?^‹O;OuB» €ƒþ s‹ÎÓët÷Ó!\Dþu#‹M!ë NàÓëL÷Ó!œÄ þ u‹M!Y‹] ‹O‹w‰q‹w‹O‰q‹uuü‰uÁþNƒþ?vj?^‹Mô ñ‹y‰K‰{‰Y‹K‰Y‹K;KuWŠLˆMþÁˆLƒþ s €} u‹Î¿ €Óï‹M 9DD‹Îë €} uNà¿ €Óï‹M y„Ä Nຠ€Óê ‹E‰‰Dü3À@_^[ÉËÿU‹ìƒì¡h*A ‹MkÀl*A ƒÁƒáð‰MðÁùSIƒù VW} ƒÎÿÓîƒMøÿë
ƒÁàƒÊÿ3öÓê‰Uø‹
t*A ‹Ùë‹S‹;#Uø#þ ×u
ƒÃ‰];Ørè;Øu‹ l*A ë‹S‹;#Uø#þ ×u
ƒÃ‰];Ùrè;Ùu[ë ƒ{ u
ƒÃ‰];Ørð;Øu1‹ l*A ë ƒ{ u
ƒÃ‰];Ùrð;Ùuè úÿÿ‹Ø‰]…Ûu3Àé Sè:ûÿÿY‹K‰‹Cƒ8ÿtå‰ t*A ‹C‹‰Uüƒúÿt‹ŒÄ ‹|D#Mø#þ Ïu)ƒeü ‹Ä HD‹9#Uø#þ ×uÿEü‹‘„ ƒÁëç‹Uü‹ÊiÉ ŒD ‰Mô‹LD3ÿ#Îu‹ŒÄ #Møj _ëÉG…É}ù‹Mô‹Tù‹
+Mð‹ñÁþNƒþ?‰Mø~j?^;÷„ ‹J;Ju\ƒÿ » €}&‹ÏÓë‹Mü|8÷Ó‰]ì#\ˆD‰\ˆDþu3‹Mì‹]! ë,OàÓë‹MüŒˆÄ |8÷Ó!þ‰]ìu ‹]‹Mì!Kë‹]ƒ}ø ‹J‹z‰y‹J‹z‰y„ ‹Mô ñ‹y‰J‰z‰Q‹J‰Q‹J;Ju^ŠLˆM þÁƒþ ˆL}#€} u ¿ €‹ÎÓï ;‹Î¿ €Óï‹Mü |ˆDë)€} u
Nà¿ €Óï {‹Mü¼ˆÄ Nྠ€Óî 7‹Mø…Ét ‰
‰Lüë‹Mø‹uðÑN‰
‰L2ü‹uô‹y‰>…Éu; |)A u‹Mü;
|*A uƒ%|)A ‹Mü‰B_^[ÉËÿU‹ìSV‹uW3ÿƒËÿ;÷u èµ¾ÿÿWWWWWÇ è=¾ÿÿƒÄ ÃëBöF ƒt7Vè(ÃÿÿV‹ØèÄ( Vè³¼ÿÿPèë' ƒÄ…À}ƒËÿë‹F ;Çt
PèÎÁÿÿY‰~ ‰~ ‹Ã_^[]Ãj hÈ÷@ è—¾ÿÿƒMäÿ3À‹u3ÿ;÷•À;Çu è2¾ÿÿÇ WWWWW躽ÿÿƒÄƒÈÿë öF @t ‰~ ‹Eäèš¾ÿÿÃVè– ÿÿY‰}üVè*ÿÿÿY‰EäÇEüþÿÿÿè ëÕ‹uVèä ÿÿYËÿU‹ì¸ä è8* ¡€A 3ʼnEü‹E V3ö‰…4åÿÿ‰µ8åÿÿ‰µ0åÿÿ9uu3Àéé ;Æu'訽ÿÿ‰0莽ÿÿVVVVVÇ è½ÿÿƒÄƒÈÿé¾ SW‹}‹ÇÁø4… *A ‹ƒç ÁçÇŠX$ÛÐû‰µ(åÿÿˆ'åÿÿ€ût€ûu0‹M÷ÑöÁu&è?½ÿÿ3ö‰0è#½ÿÿVVVVVÇ è«¼ÿÿƒÄéC ö@ tjj j ÿuèc ƒÄÿuèÖêÿÿY…À„ ‹öD€„ èëÖÿÿ‹@l3É9H… åÿÿ”ÁP‹ÿ4‰ åÿÿÿàà@ …À„` 3É9 åÿÿt„Û„P ÿÜà@ ‹4åÿÿ‰… åÿÿ3À‰…<åÿÿ9E†B ‰…DåÿÿŠ…'åÿÿ„À…g Š ‹µ(åÿÿ3À€ù
”À‰… åÿÿ‹Çƒx8 tŠP4ˆUôˆMõƒ`8 jEôPëK¾ÁPè×ìÿÿY…Àt:‹4åÿÿ+ËM3À@;Ȇ¥ j…@åÿÿSPè<( ƒÄ ƒøÿ„± Cÿ…DåÿÿëjS…@åÿÿPè( ƒÄ ƒøÿ„ 3ÀPPjMôQj@åÿÿQPÿµ åÿÿCÿ…Dåÿÿÿ°à@ ‹ð…ö„\ j …<åÿÿPVEôP‹…(åÿÿ‹ ÿ4ÿ˜à@ …À„) ‹…Dåÿÿ‹0åÿÿÁ9µ<åÿÿ‰…8åÿÿŒ ƒ½ åÿÿ „Í j …<åÿÿPjEôP‹…(åÿÿ‹ ÆEô
ÿ4ÿ˜à@ …À„Ð ƒ½<åÿÿŒÏ ÿ…0åÿÿÿ…8åÿÿéƒ <t<u!·33Éfƒþ
”ÁCCƒ…Dåÿÿ‰µ@åÿÿ‰ åÿÿ<t<uRÿµ@åÿÿè%% Yf;…@åÿÿ…h ƒ…8åÿÿƒ½ åÿÿ t)j
XP‰…@åÿÿèø$ Yf;…@åÿÿ…; ÿ…8åÿÿÿ…0åÿÿ‹E9…Dåÿÿ‚ùýÿÿé' ‹Šÿ…8åÿÿˆT4‹‰D8é 3É‹Çö@€„¿ ‹…4åÿÿ‰@åÿÿ„Û…Ê ‰…<åÿÿ9M† 답(åÿÿ‹<åÿÿƒ¥Dåÿÿ +4åÿÿ…Håÿÿ;Ms9‹•<åÿÿÿ…<åÿÿŠA€ú
uÿ…0åÿÿÆ
@ÿ…Dåÿÿˆ@ÿ…Dåÿÿ½Dåÿÿÿ r‹؅Håÿÿ+Øj …,åÿÿPS…HåÿÿP‹ÿ4ÿ˜à@ …À„B ‹…,åÿÿ…8åÿÿ;ÃŒ: ‹…<åÿÿ+…4åÿÿ;E‚Lÿÿÿé ‰…Dåÿÿ€û…Ñ 9M†M 답(åÿÿ‹Dåÿÿƒ¥<åÿÿ +4åÿÿ…Håÿÿ;MsF‹•Dåÿÿƒ…Dåÿÿ·AAfƒú
uƒ…0åÿÿj
[f‰@@ƒ…<åÿÿƒ…<åÿÿf‰@@½<åÿÿþ rµ‹Ø…Håÿÿ+Øj …,åÿÿPS…HåÿÿP‹ÿ4ÿ˜à@ …À„b ‹…,åÿÿ…8åÿÿ;ÃŒZ ‹…Dåÿÿ+…4åÿÿ;E‚?ÿÿÿé@ 9M†| ‹Dåÿÿƒ¥<åÿÿ +4åÿÿj…Hùÿÿ^;Ms<‹•Dåÿÿ·µDåÿÿÎfƒú
uj
[f‰Æµ<åÿÿµ<åÿÿf‰Æ½<åÿÿ¨ r¿3öVVhU
ðëÿÿQHùÿÿ+Á™+ÂÑøP‹ÁPVhéý ÿ°à@ ‹Ø;Þ„— j …,åÿÿP‹Ã+ÆP„5ðëÿÿP‹…(åÿÿ‹ ÿ4ÿ˜à@ …Àt µ,åÿÿ;ÞËë ÿ\à@ ‰…@åÿÿ;Þ\‹…Dåÿÿ+…4åÿÿ‰…8åÿÿ;E‚
ÿÿÿë?j ,åÿÿQÿuÿµ4åÿÿÿ0ÿ˜à@ …Àt‹…,åÿÿƒ¥@åÿÿ ‰…8åÿÿë ÿ\à@ ‰…@åÿÿƒ½8åÿÿ ulƒ½@åÿÿ t-j^9µ@åÿÿuè·ÿÿÇ è ·ÿÿ‰0ë?ÿµ@åÿÿè"·ÿÿYë1‹µ(åÿÿ‹öD@t‹…4åÿÿ€8u3Àë$èÖ¶ÿÿÇ èÞ¶ÿÿƒ ƒÈÿë ‹…8åÿÿ+…0åÿÿ_[‹Mü3Í^èhžÿÿÉÃjhè÷@ èè¶ÿÿ‹Eƒøþu袶ÿÿƒ 臶ÿÿÇ ƒÈÿé 3ÿ;Ç|;*A r!èy¶ÿÿ‰8è_¶ÿÿÇ WWWWWèçµÿÿƒÄëÉ‹ÈÁù *A ‹ðƒæ Áæ‹ ¾L1ƒát¿Pè9$ Y‰}ü‹öD0tÿuÿu ÿuè.øÿÿƒÄ ‰EäëèüµÿÿÇ è¶ÿÿ‰8ƒMäÿÇEüþÿÿÿè ‹Eäèh¶ÿÿÃÿuèƒ$ YÃjhø@ è ¶ÿÿ‹Eƒøþuè³µÿÿÇ ƒÈÿéª 3Û;Ã|;*A rè’µÿÿÇ SSSSSèµÿÿƒÄëЋÈÁù< *A ‹ðƒæ Á拾LƒátÆPèl# Y‰]ü‹öDt1ÿuèà" YPÿäà@ …Àu ÿ\à@ ‰Eäë‰]ä9]ätè1µÿÿ‹Mä‰èµÿÿÇ ƒMäÿÇEüþÿÿÿè ‹Eä臵ÿÿÃÿuè¢# YËÿU‹ìƒìS3Û9]u èÖ´ÿÿSSSSSÇ è^´ÿÿƒÄ3ÀëjV‹u ;óuè²´ÿÿSSSSSÇ è:´ÿÿƒÄë9ur3Àë>ÿuMðèVœÿÿ‹MôFÿ9Yt H9Ew
¶öD
uð‹Î+ȃá+ñN‹Æ8]üt‹Møƒapý^[ÉËÿU‹ìj ÿu ÿuèUÿÿÿƒÄ ]ËÿU‹ìƒìS3ÛV‹u9]u;óu9] u3Àéç ;ót9] w è ´ÿÿj^SSSSS‰0è’³ÿÿƒÄ‹ÆéÀ 9]uˆ ëÉW‹};ûu ˆ èسÿÿj^SSSSS‰0èa³ÿÿƒÄé( ÿuMì胛ÿÿ‹Eð9XuÿuWÿu Vè£
ƒÄéL ƒ}ÿ‹U ‹ÆuŠˆ@G:Ët Juó늈@G:ËtJtÿMuî9]uˆ@;Ó…È 8 tƒ}u5xÿ‰}ü;þr EìP‹Eü¶ Pè0¿ÿÿYY…ÀtÿMü9uüsâ‹Ç+Eü¨…à ƒ}ÿuZ‹E ƒøv:|þ‰};þr!EìP‹E¶ Pèì¾ÿÿYY…ÀtÿM9usâ‹E ‹Ï+MöÁtˆ ëˆ\ÿ8]øt‹Eôƒ`pýjPXé ˆ è·²ÿÿj"^SSSSS‰0è@²ÿÿƒÄ8]øt‹Eôƒ`pý‹Æëd‹È+΃ù|Mxþ‰};þr EìP‹E¶ Pèi¾ÿÿYY…ÀtÿM9usâ‹Ç+E¨t ˆ èT²ÿÿ‹Èj*X‰8]øt‹Môƒapýë8]øt‹Eôƒ`pý3À_^[ÉËÿU‹ì‹E…Àtƒè8ÝÝ uPèxµÿÿY]ËÿU‹ìƒì¡€A 3ʼnEüSV3ÛW‹ñ9 „)A u8SS3ÿGWhdê@ h Sÿðà@ …Àt‰=„)A ëÿ\à@ ƒøxu
Ç„)A 9]~"‹M‹EI8t@;ËuöƒÉÿ‹E+ÁH;E}@‰E¡„)A ƒø„¬ ;Ĥ ƒø…Ì ‰]ø9] u‹‹@‰E ‹5ìà@ 3À9]$SSÿu•ÀÿuÅ Pÿu ÿÖ‹ø;û„ ~Cjà3ÒX÷÷ƒør7D?= wèŽ# ‹Ä;Ãt Ç ÌÌ ëPè äÿÿY;Ãt Ç ÝÝ ƒÀ‰Eôë‰]ô9]ô„> Wÿuôÿuÿujÿu ÿÖ…À„ã ‹5ðà@ SSWÿuôÿu ÿuÿ֋ȉMø;Ë„Â ÷E t)9] „° ;M § ÿu ÿuWÿuôÿu ÿuÿÖé ;Ë~Ejà3ÒX÷ñƒør9D = wèÏ" ‹ô;ótjÇÌÌ ƒÆëPèJãÿÿY;Ãt Ç ÝÝ ƒÀ‹ðë3ö;ótAÿuøVWÿuôÿu ÿuÿðà@ …Àt"SS9] uSSëÿu ÿuÿuøVSÿu ÿ°à@ ‰EøVè¸ýÿÿYÿuôè¯ýÿÿ‹EøYéY ‰]ô‰]ð9]u‹‹@‰E9] u‹‹@‰E ÿuè Y‰Eìƒøÿu3Àé! ;E „Û SSMQÿuPÿu è> ƒÄ‰Eô;ÃtÔ‹5èà@ SSÿuPÿu ÿuÿÖ‰Eø;Ãu3öé· ~=ƒøàw8ƒÀ= wè¹! ‹ü;ûtÝÇÌÌ ƒÇëPè4âÿÿY;Ãt Ç ÝÝ ƒÀ‹øë3ÿ;ût´ÿuøSWèÀ’ÿÿƒÄ ÿuøWÿuÿuôÿu ÿuÿÖ‰Eø;Ãu3öë%ÿu EøÿuPWÿu ÿuìè ‹ð‰uðƒÄ÷Þö#uøWèüÿÿYëÿu ÿuÿuÿuÿu ÿuÿèà@ ‹ð9]ôt ÿuôèø±ÿÿY‹Eð;Ãt 9EtPèå±ÿÿY‹Æeà_^[‹Mü3Íè'–ÿÿÉËÿU‹ìƒìÿuMðè!–ÿÿÿu(Mðÿu$ÿu ÿu ÿuÿuÿuÿu è(üÿÿƒÄ €}ü t‹MøƒapýÉËÿU‹ìQQ¡€A 3ʼnEü¡ˆ)A SV3ÛW‹ù;Ãu:EøP3öFVhdê@ Vÿøà@ …Àt‰5ˆ)A ë4ÿ\à@ ƒøxu
jX£ˆ)A 롈)A ƒø„Ï ;Ã„Ç ƒø…è ‰]ø9]u‹‹@‰E‹5ìà@ 3À9] SSÿu•Àÿu Å PÿuÿÖ‹ø;û„« ~<ÿðÿÿw4D?= wèÒ ‹Ä;Ãt Ç ÌÌ ëPèPàÿÿY;Ãt Ç ÝÝ ƒÀ‹Ø…Ûti?Pj SèÞÿÿƒÄ WSÿuÿu jÿuÿÖ…ÀtÿuPSÿuÿøà@ ‰EøSèÉúÿÿ‹EøYëu3ö9] u‹‹@‰E 9]u‹‹@‰Eÿu èA Yƒøÿu3ÀëG;Et SSMQÿu Pÿuèi ‹ðƒÄ;ót܉u ÿuÿuÿu ÿuÿu ÿôà@ ‹ø;ótVèæ¯ÿÿY‹Çeì_^[‹Mü3Íè(”ÿÿÉËÿU‹ìƒìÿuMðè"”ÿÿÿu$Mðÿu ÿu ÿuÿuÿuÿu èþÿÿƒÄ €}ü t‹MøƒapýÉËÿU‹ìV‹u…ö„ ÿvèv¯ÿÿÿvèn¯ÿÿÿv èf¯ÿÿÿvè^¯ÿÿÿvèV¯ÿÿÿvèN¯ÿÿÿ6èG¯ÿÿÿv è?¯ÿÿÿv$è7¯ÿÿÿv(è/¯ÿÿÿv,è'¯ÿÿÿv0è ¯ÿÿÿv4è¯ÿÿÿv è¯ÿÿÿv8è¯ÿÿÿv<èÿ®ÿÿƒÄ@ÿv@èô®ÿÿÿvDèì®ÿÿÿvHèä®ÿÿÿvLèÜ®ÿÿÿvPèÔ®ÿÿÿvTèÌ®ÿÿÿvXèÄ®ÿÿÿv\è¼®ÿÿÿv`è´®ÿÿÿvd謮ÿÿÿvh褮ÿÿÿvl蜮ÿÿÿvpè”®ÿÿÿvt茮ÿÿÿvxè„®ÿÿÿv|è|®ÿÿƒÄ@ÿ¶€ èn®ÿÿÿ¶„ èc®ÿÿÿ¶ˆ èX®ÿÿÿ¶Œ èM®ÿÿÿ¶ èB®ÿÿÿ¶” è7®ÿÿÿ¶˜ è,®ÿÿÿ¶œ è!®ÿÿÿ¶ è®ÿÿÿ¶¤ è ®ÿÿÿ¶¨ è ®ÿÿƒÄ,^]ËÿU‹ìV‹u…öt5‹;H A tPèÝÿÿY‹F;L A tPèËÿÿY‹v;5P A tVè¹ÿÿY^]ËÿU‹ìV‹u…öt~‹F ;T A tPè—ÿÿY‹F;X A tPè…ÿÿY‹F;\ A tPèsÿÿY‹F;` A tPèaÿÿY‹F ;d A tPèOÿÿY‹F ;h A tPè=ÿÿY‹v$;5l A tVè+ÿÿY^]ËÿU‹ì‹ES3ÛVW;Ãt‹} ;ûwè¡©ÿÿj^‰0SSSSSè*©ÿÿƒÄ‹Æë<‹u;óuˆëÚ‹Ð8tBOuø;ût
BF:ËtOuó;ûuˆèZ©ÿÿj"Y‰‹ñëµ3À_^[]ÃÌÌÌÌÌÌU‹ìV3ÀPPPPPPPP‹U I Š
Àt ƒÂ«$ëñ‹uƒÉÿI ƒÁŠ
Àt ƒÆ£$sî‹ÁƒÄ ^ÉËÿU‹ìSV‹u3ÛW9]u;óu9] u3À_^[]Ã;ót‹} ;ûwę̀ÿÿj^‰0SSSSSèU¨ÿÿƒÄ‹ÆëÕ9]uˆ ëÊ‹U;Óuˆ ëу}ÿ‹ÆuŠ
ˆ@B:Ët OuóëŠ
ˆ@B:ËtOtÿMuî9]uˆ;ûu‹ƒ}ÿu‹E jPˆ\ÿXéxÿÿÿˆ èR¨ÿÿj"Y‰‹ñë‚‹ÿU‹ì‹MS3ÛVW;Ët‹} ;ûwè,¨ÿÿj^‰0SSSSS赧ÿÿƒÄ‹Æë0‹u;óuˆëÚ‹ÑŠˆBF:ÃtOuó;ûuˆèñ§ÿÿj"Y‰‹ñëÁ3À_^[]ÃÌÌÌÌÌÌÌÌÌÌÌÌÌ‹T$‹L$÷ u<‹:u.
Àt&:au%
ät Áè:Au
Àt:auƒÁƒÂ
äuÒ‹ÿ3ÀÃÀÑàƒÀÃ÷ tŠƒÂ:uçƒÁ
ÀtÜ÷ t¤f‹ƒÂ:uÎ
ÀtÆ:auÅ
ät½ƒÁëˆÌÌÌÌÌÌÌÌU‹ìWV‹u ‹M‹}‹Á‹ÑÆ;þv;ø‚¤ ù r ƒ=ˆ*A tWVƒçƒæ;þ^_u^_]é, ÷Ç uÁéƒâƒùr*ó¥ÿ$•T‘@ ‹Çº ƒér ƒàÈÿ$…h@ ÿ$d‘@ ÿ$è@ x@ ¤@ È@ #ÑŠˆŠFˆGŠFÁéˆGƒÆƒÇƒùrÌó¥ÿ$•T‘@ I #ÑŠˆŠFÁéˆGƒÆƒÇƒùr¦ó¥ÿ$•T‘@ #ÑŠˆƒÆÁéƒÇƒùrˆó¥ÿ$•T‘@ I K‘@ 8‘@ 0‘@ (‘@ ‘@ ‘@ ‘@ ‘@ ‹DŽä‰Dä‹DŽè‰Dè‹DŽì‰Dì‹DŽð‰Dð‹DŽô‰Dô‹DŽø‰Dø‹DŽü‰Dü ðøÿ$•T‘@ ‹ÿd‘@ l‘@ x‘@ Œ‘@ ‹E^_Éʈ‹E^_ÉʈŠFˆG‹E^_ÉÃI ŠˆŠFˆGŠFˆG‹E^_ÉÃt1ü|9ü÷Ç u$Áéƒâƒùr
ýó¥üÿ$•ð’@ ‹ÿ÷Ùÿ$ ’@ I ‹Çº ƒùr ƒà+Èÿ$…ô‘@ ÿ$ð’@ ’@ (’@ P’@ ŠF#шGƒîÁéƒïƒùr²ýó¥üÿ$•ð’@ I ŠF#шGŠFÁéˆGƒîƒïƒùrˆýó¥üÿ$•ð’@ ŠF#шGŠFˆGŠFÁéˆGƒîƒïƒù‚Vÿÿÿýó¥üÿ$•ð’@ I ¤’@ ¬’@ ´’@ ¼’@ Ä’@ Ì’@ Ô’@ ç’@ ‹DŽ ‰D ‹DŽ‰D‹DŽ‰D‹DŽ‰D‹DŽ ‰D ‹DŽ‰D‹DŽ‰D ðøÿ$•ð’@ ‹ÿ “@ “@ “@ ,“@ ‹E^_ÉÊFˆG‹E^_ÉÃI ŠFˆGŠFˆG‹E^_ÉÊFˆGŠFˆGŠFˆG‹E^_ÉÃÌÌÌÌÌÌÌÌÌÌÌU‹ìV3ÀPPPPPPPP‹U I Š
Àt ƒÂ«$ëñ‹u‹ÿŠ
Àt ƒÆ£$sñFÿƒÄ ^ÉËÿU‹ìQQ‹E V‹u‰Eø‹EWV‰Eüè ƒÏÿY;Çuèi£ÿÿÇ ‹Ç‹×ëJÿuMüQÿuøPÿ á@ ‰Eø;Çuÿ\à@ …Àt Pè[£ÿÿYëÏ‹ÆÁø‹… *A ƒæ ÁæD0€ ý‹Eø‹Uü_^ÉÃjh(ø@ èO£ÿÿƒÎÿ‰u܉uà‹Eƒøþu è £ÿÿƒ èå¢ÿÿÇ ‹Æ‹ÖéÐ 3ÿ;Ç|;*A r!èÖ¢ÿÿ‰8è¼¢ÿÿÇ WWWWWèD¢ÿÿƒÄëÈ‹ÈÁù *A ‹ðƒæ Áæ‹ ¾L1ƒáu&è•¢ÿÿ‰8è{¢ÿÿÇ WWWWWè¢ÿÿƒÄƒÊÿ‹Âë[Pèp Y‰}ü‹öD0t ÿuÿuÿu ÿuè©þÿÿƒÄ‰E܉Uàëè-¢ÿÿÇ è5¢ÿÿ‰8ƒMÜÿƒMàÿÇEüþÿÿÿè ‹EÜ‹Uàè’¢ÿÿÃÿuè YËÿU‹ìÿ A h è¤ÿÿY‹M‰A…Àt
ƒI ÇA ëƒI A‰AÇA ‹Aƒa ‰]ËÿU‹ìƒìSVWèb¹ÿÿƒeü ƒ=)A ‹Ø…Ž h ô@ ÿœà@ ‹ø…ÿ„* ‹5(à@ hôó@ WÿÖ…À„ P謸ÿÿÇ$äó@ W£)A ÿÖPè—¸ÿÿÇ$Ðó@ W£”)A ÿÖP肸ÿÿÇ$´ó@ W£˜)A ÿÖPèm¸ÿÿY£ )A …Àthœó@ WÿÖPèU¸ÿÿY£œ)A ¡œ)A ;ÃtO9 )A tGP賸ÿÿÿ5 )A ‹ð覸ÿÿYY‹ø…öt,…ÿt(ÿÖ…ÀtMøQj MìQjPÿ×…ÀtöEôu M ë9¡”)A ;Ãt0Pèc¸ÿÿY…Àt%ÿЉEü…Àt ¡˜)A ;ÃtPèF¸ÿÿY…ÀtÿuüÿЉEüÿ5)A è.¸ÿÿY…Àtÿuÿu ÿuÿuüÿÐë3À_^[ÉËÿU‹ì‹MV3ö;Î| ƒù~ ƒùu¡D A ë(¡D A ‰
D A ëè ÿÿVVVVVÇ èšŸÿÿƒÄƒÈÿ^]ÃjhHø@ è9 ÿÿ3À‹]3ÿ;ß•À;Çu èØŸÿÿÇ WWWWWè`ŸÿÿƒÄƒÈÿëSƒ=„*A u8jèU§ÿÿY‰}üSèÖÿÿY‰Eà;Çt ‹süƒî ‰uäë‹uäÇEüþÿÿÿè% 9}àuSWÿ5t)A ÿá@ ‹ð‹ÆèùŸÿÿÃ3ÿ‹]‹uäjè#¦ÿÿYÃjè‰ÿÿYËÿU‹ìì( ¡€A 3ʼnEüö A Vtj
è3¾ÿÿYè
Åÿÿ…Àtjè ÅÿÿYö A „Ê ‰…àýÿÿ‰Üýÿÿ‰•Øýÿÿ‰Ôýÿÿ‰µÐýÿÿ‰½ÌýÿÿfŒ•øýÿÿfŒìýÿÿfŒÈýÿÿfŒ…ÄýÿÿfŒ¥ÀýÿÿfŒ¼ýÿÿœ…ðýÿÿ‹uE‰…ôýÿÿÇ…0ýÿÿ ‰µèýÿÿ‹@üjP‰…äýÿÿ…Øüÿÿj Pè:‚ÿÿ…ØüÿÿƒÄ ‰…(ýÿÿ…0ýÿÿj Ç…Øüÿÿ @‰µäüÿÿ‰…,ýÿÿÿTà@ …(ýÿÿPÿPà@ jèýŠÿÿÌÌÌU‹ìSVWUj j h™@ ÿuèV" ]_^[‹å]ËL$÷A ¸ t2‹D$‹Hü3Èè²…ÿÿU‹h‹P(R‹P$Rè ƒÄ]‹D$‹T$‰¸ ÃSVW‹D$UPjþh™@ dÿ5 ¡€A 3ÄPD$d£ ‹D$(‹X‹p ƒþÿt:ƒ|$,ÿt;t$,v-4v‹ ³‰L$ ‰H ƒ|³ uh ‹D³èI ‹D³è_ ë·‹L$d‰
ƒÄ_^[Ã3Àd‹
y™@ u‹Q ‹R 9Qu¸ ÃSQ»” A ë SQ»” A ‹L$ ‰K‰C‰k UQPXY]Y[ ÿÐËÿU‹ìƒìVWÿuMì资ÿÿ‹E‹u 3ÿ;Çt‰0;÷u,èÑœÿÿWWWWWÇ èYœÿÿƒÄ€}ø t‹Eôƒ`pý3ÀéØ 9}t ƒ}|Ƀ}$ËMìSŠ ‰}ü~ƒ¹¬ ~EìP¶ÃjPèe¹ÿÿ‹MìƒÄ ë‹‘È ¶Ã·Bƒà…ÀtŠ GëÇ€û-uƒMë€û+uŠ G‹E…ÀŒK ƒø„B ƒø$9 …Àu*€û0t ÇE
ë4Š·É¶ÒÁá Ê9M u Hë ·Ñ9U t
@f¶·Éf;ËuÇ·É9M u8]üt‹Møƒapýë8]üt‹Eøƒ`pý3À^[ÉËÿU‹ìj ÿu ÿuè2ÿÿÿƒÄ ]ÃÌÌÌBÿ[ä$ d$ 3ÀŠD$S‹ØÁà‹T$÷ tŠ
ƒÂ:ËtÏ„ÉtQ÷ uë ØW‹ÃÁãV Ø‹
¿ÿþþ~‹Á‹÷3Ëðùƒñÿƒðÿ3Ï3ƃÂá u % tÓ% uæ €uÄ^_[3ÀËBü:Ãt6„Àtï:ãt'„ätçÁè:Ãt„ÀtÜ:ãt„ätÔë–^_Bÿ[ÃBþ^_[ÃBý^_[ÃBü^_[Ãÿ%Ðà@ ‹ÿU‹ì‹US3Û;Óu è¬{ÿÿSSSSSÇ è4{ÿÿƒÄƒÈÿë 8tß‹M ;ËtØ‹;ÃtÒ8tÎSQRè ƒÄ []ËÿU‹ìƒì ‹UV‹ujþX‰Eì‰Uä;ðuèc{ÿÿƒ èH{ÿÿÇ ƒÈÿéˆ S3Û;ó|;5*A r'è9{ÿÿ‰è {ÿÿSSSSSÇ è§zÿÿƒÄƒÈÿéQ ‹ÆÁøW<… *A ‹ƒæ ÁæÆŠHöÁuèózÿÿ‰èÙzÿÿÇ ëjúÿÿÿwP‰]ð;Ó„ öÁ…ÿ 9] t7Š@$ÀÐøˆEþ¾ÀHjYt Hu‹Â÷Шtƒâþ‰U‹E ‰Eôé ‹Â÷Шu!è‡zÿÿ‰èmzÿÿÇ SSSSSèõyÿÿƒÄë4‹ÂÑè‰M;Ár‰Eÿuèz|ÿÿY‰Eô;Ãu è5zÿÿÇ è=zÿÿÇ ƒÈÿéh jSSÿuè|Öÿÿ‹‰D(‹EôƒÄ‰T,‹ÎöAHttŠI€ù
tl9]tgˆ‹@ÿMÇEð ÆD
8]þtN‹ŠL%€ù
tC9]t>ˆ‹@ÿM€}þÇEð ÆD%
u$‹ŠL&€ù
t9]tˆ‹@ÿMÇEð ÆD&
SMèQÿuP‹ÿ4ÿ,á@ …À„{ ‹Mè;ËŒp ;M‡g ‹MðDö €„æ €}þ„ ;Ët
‹Mô€9
u€ë€ û‹]ô‹EðÉ]‰Eð;؃Р‹MŠ<„® <
t ˆCA‰Mé ‹EðH;ÈsA€8
u
AA‰MÆ
ëu‰EëmÿEj EèPjEÿP‹ÿ4ÿ,á@ …Àu
ÿ\à@ …ÀuEƒ}è t?‹öDHt€}ÿ
t¹Æ
‹ŠMÿˆLë%;]ôu€}ÿ
t jjÿjÿÿuèØÔÿÿƒÄ€}ÿ
tÆ
C‹Eð9E‚Gÿÿÿë‹Dö @u€ëŠˆC‹Ã+Eô€}þ‰Eð…Ð …À„È KŠ „ÉxCé† 3À@¶Éëƒø;]ôrK¶ @€¹à A t芶ʾ‰à A …Éu
èàwÿÿÇ * ëzA;ÈuØë@‹ÎöAHt$CƒøˆQ| Š‹ˆT%Cƒøu Š‹ˆT&C+Øë÷Ø™jRPÿuèþÓÿÿƒÄ‹Eä+]ôÑèPÿu Sÿuôj héý ÿìà@ ‰Eð…Àu4ÿ\à@ Pè…wÿÿYƒMìÿ‹Eô;E tPèµzÿÿY‹Eìƒøþ…‹ ‹Eðéƒ ‹Eð‹3É;ÕÁÀ‰Eð‰L0ëÆ;Ët‹Môfƒ9
u€ë€ û‹]ô‹EðÉ]‰Eð;؃ÿ ‹E·fƒù„× fƒù
tf‰ CC@@‰Eé´ ‹MðƒÁþ;Ás Hfƒ9
u
ƒÀ‰Ej
éŽ ‰Mé„ ƒEj EèPjEøP‹ÿ4ÿ,á@ …Àu
ÿ\à@ …Àu[ƒ}è tU‹öDHt(fƒ}ø
t²j
Xf‰‹ŠMøˆL‹ŠMùˆL%‹ÆD&
ë*;]ôufƒ}ø
t…jjÿjþÿuèšÒÿÿƒÄfƒ}ø
tj
Xf‰CC‹Eð9E‚ÿÿÿë‹tö@u€ëf‹ f‰CC+]ô‰]ðé‘þÿÿÿ\à@ j^;ÆuèÙuÿÿÇ èáuÿÿ‰0éiþÿÿƒøm…Yþÿÿ‰]ìé\þÿÿ3À_[^ÉÃjhðø@ èïuÿÿ‹Eƒøþuè©uÿÿƒ èŽuÿÿÇ ƒÈÿé¾ 3ö;Æ|;*A r!è€uÿÿ‰0èfuÿÿÇ VVVVVèîtÿÿƒÄëÉ‹ÈÁù *A ‹øƒç Áç‹ ¾L9ƒát¿¹ÿÿÿ;MÉAuè2uÿÿ‰0èuÿÿÇ ë°Pè ãÿÿY‰uü‹öD8tÿuÿu ÿuè~ùÿÿƒÄ ‰EäëèâtÿÿÇ èêtÿÿ‰0ƒMäÿÇEüþÿÿÿè ‹EäèNuÿÿÃÿuèiãÿÿYËÿU‹ìƒì0S3ÛöE€VW‹ð‰]àˆ]þÇEÐ ‰]Ôt ‰]ØÆEÿë
ÇEØ ˆ]ÿEàPè
Y…Àt
SSSSSèÒrÿÿƒÄ‹M¸ € …Èu÷Á @ u9Eàt€Mÿ€‹Áƒà+ú À¿ €tGHt.Ht&è7tÿÿ‰ƒÿètÿÿj^SSSSS‰0è£sÿÿƒÄé ‰UøëöÁt÷Á uîÇEø @ë‰}ø‹EjY+Át7+Át*+Át +Átƒè@u¡9}ø”À‰Eðë ÇEð ëÇEð ë ÇEð ë‰]ð‹Eº #¹ ;Á¿ ;t0;Ãt,;Çt = „” = …@ÿÿÿÇEì ë/ÇEì ë&ÇEì ë = t= t`;Â…ÿÿÿÇEì ‹EÇEô€ …Çt‹
A ÷Ñ#M„ÉxÇEô ¨@tMô Mø ƒMð© t }ô¨ tMô ëÇEì 릨tMô è£áÿÿ‰ƒøÿuèÎrÿÿ‰ƒÿè±rÿÿÇ éŽ ‹E‹= á@ SÿuôÇ ÿuìEÐPÿuðÿuøÿu ÿ׉Eäƒøÿum‹Mø¸ À#È;Èu+öEt%eøÿÿÿSÿuôEÐÿuìPÿuðÿuøÿu ÿ׉Eäƒøÿu4‹6‹ÆÁø‹… *A ƒæ ÁæD0€ þÿ\à@ Pè?rÿÿYèrÿÿ‹ ét ÿuäÿ<à@ ;ÃuD‹6‹ÆÁø‹… *A ƒæ ÁæD0€ þÿ\à@ ‹ðVèüqÿÿYÿuäÿá@ ;óu°èÃqÿÿÇ
룃øu€Mÿ@ë ƒøu€Mÿÿuäÿ6è4Þÿÿ‹‹Ðƒà Áú‹• *A YÁàYŠMÿ€ÉˆL‹‹Ðƒà Áú‹• *A ÁàD$€ €ˆMý€eýHˆMÿ…€ öÁ€„± öEtqjƒÏÿWÿ6è£ ƒÄ ‰Eè;Çuè:qÿÿ8ƒ tMÿ6èéÙÿÿéúþÿÿjEüPÿ6ˆ]üè’õÿÿƒÄ …Àu€}üu‹Eè™RPÿ6è ƒÄ ;ÇtÃSSÿ6èF ƒÄ ;Çt³öEÿ€„0 ¿ @ ¹ @ …}u‹Eà#Çu Më E‹E#Ç;ÁtD= t)= @ t"= t)= @ t"= t= @ u ÆEþë‹M¸ #È;Èu ÆEþëˆ]þ÷E „µ öEÿ@‰]è…¨ ‹Eø¹ À#Á= @„· = €tw;Á…„ ‹Eì;Æy ƒøvƒøv0ƒø…f ¾Eþ3ÿH„& H…R ÇEèÿþ ÇEì é jSSÿ6è8ÌÿÿƒÄ ÂtÇSSSÿ6è'Ìÿÿ#ƒăøÿ„ŽþÿÿjEèPÿ6è/ôÿÿƒÄ ƒøÿ„uþÿÿƒøtkƒø… }è uYÆEþéÜ ‹Eì;Ã†Ñ ƒø†bÿÿÿƒø‡PÿÿÿjSSÿ6è¸ËÿÿƒÄ „CÿÿÿSSSÿ6è£ËÿÿƒÄ#ƒøÿ…‘ éþÿÿ‹Eè%ÿÿ =þÿ uÿ6èß×ÿÿYèoÿÿj^‰0‹Æéd =ÿþ u Sjÿ6èX ƒÄ ƒøÿ„ÀýÿÿÆEþëASSÿ6è= ƒÄ ë™ÇEè ÇEì ‹Eì+ÇPD=èPÿ6è¸ÿÿƒÄ ƒøÿ„€ýÿÿø9}ìÛ‹‹ÈÁù‹ *A ƒà ÁàD$Š2Mþ€á0‹‹ÈÁù‹ *A ƒà ÁàD$‹MŠÁéÀá€â
ʈ8]ýu!öEt‹‹Èƒà Áù‹ *A ÁàD€ ‹}ø¸ À‹Ï#È;Èu|öEtvÿuäÿá@ SÿuôEÐjPÿuðçÿÿÿWÿu ÿ á@ ƒøÿu4ÿ\à@ Pèÿmÿÿ‹‹Èƒà Áù‹ *A ÁàD€ þÿ6èÏÚÿÿYé˜ûÿÿ‹6‹ÎÁù‹ *A ƒæ Á手Ã_^[ÉÃjhù@ èÓmÿÿƒMäÿ3ö‰uà3À9u•À;Æu èmmÿÿÇ VVVVVèõlÿÿƒÄƒÈÿër‰uüÿuj@ÿu ÿuEàPEäè‰øÿÿƒÄ‰EÜÇEüþÿÿÿè ‹}Ü;þt<è mÿÿ‰8ë¿3ö9uàt+9uÜt ‹EäÁø‹Mäƒá Áá‹… *A D€ þÿuäèÛÿÿYËEäèomÿÿËÿU‹ìQQV3ö9uu èÉlÿÿVVVVVÇ èQlÿÿƒÄƒÈÿëJ9u tÞÿuEøPEüPÿuÿu è| ƒÄƒøÿtØÿuøÿuüÿujèU ÿuü‹ðèÝoÿÿÿuøèÕoÿÿƒÄ‹Æ^ÉËÿU‹ìƒìSW‹}3Û‰}ü;ûu èIlÿÿSSSSSÇ èÑkÿÿƒÄƒÈÿéá 8 tÜ‹E ;ÃtÕ‹ ;ÃtÏ8tËVj\Wè j/W‹ðè
ƒÄ;Ã… ;ó…ƒ j:Wè=ïÿÿ‹ðYY;óusWèIšÿÿ‹ðƒÆjVèMnÿÿ‹øƒÄ ‰}ü;û„ htô@ VWèkÃÿÿƒÄ …Àt
SSSSSèjÿÿƒÄÿuVWèØÁÿÿƒÄ …Àt
SSSSSèõiÿÿƒÄw‹}ë
;ót;Æv‹ðƒMðÿj.Vèh YY…Àt,Sÿuüè
YY…À…ì ÿuÿu ÿuüè`þÿÿƒÄ ‰EðéÓ ÿuüè–™ÿÿ‹ðƒÆjVèšmÿÿƒÄ ‰Eø;ÃuƒÈÿé½ ÿuüVPè¸ÂÿÿƒÄ …Àt
SSSSSè`iÿÿƒÄÿuüèQ™ÿÿ‹ø}øYèÚjÿÿ‹ ‰Eì‹Eø+÷ðÇEôì A ‹Eôÿ0VWèrÂÿÿƒÄ …Àt
SSSSSèiÿÿƒÄSÿuøè] YY…Àtƒmô}ôà A }Äë è„jÿÿÿu‹Mìÿu ‰ÿuøè”ýÿÿƒÄ ‰EðÿuøèÌmÿÿ‹}Y9}üt ÿuüè»mÿÿY‹Eð^_[ÉËÿU‹ìƒìSVW3ÛjSSÿu‰]ð‰]ôè–Æÿÿ‰Eè#ƒĉUìƒøÿtYjSSÿuèzÆÿÿ‹È#ʃăùÿtA‹u ‹}+ðúˆÆ ;ó†¼ » Sjÿ4á@ Pÿdà@ ‰Eü…ÀuèÇiÿÿÇ è¼iÿÿ‹ _^[ÉÃh € ÿuèŠ YY‰Eø…ÿ|
;ór‹Ãë‹ÆPÿuüÿu謫ÿÿƒÄ ƒøÿt6™+ðúxÓ…öwÏ‹uðÿuøÿuèF YYÿuüj ÿ4á@ Pÿ`à@ 3Ûé† èWiÿÿƒ8u è:iÿÿÇ
ƒÎÿ‰uôë½;ûq|;óskSÿuÿu ÿuèÅÿÿ#ƒăøÿ„Dÿÿÿÿuè›ÖÿÿYPÿ0á@ ÷ØÀ÷ØH™‰Eð#‰Uôƒøÿu)èÛhÿÿÇ
èãhÿÿ‹ðÿ\à@ ‰‹uð#uôƒþÿ„öþÿÿSÿuìÿuèÿuèÅÿÿ#ƒăøÿ„Ùþÿÿ3ÀéÙþÿÿ‹ÿU‹ìV‹uVè"ÖÿÿYƒøÿuèyhÿÿÇ ƒÈÿëMWÿuj ÿu Pÿ á@ ‹øƒÿÿuÿ\à@ ë3À…Àt PèihÿÿYƒÈÿë‹ÆÁø‹… *A ƒæ ÁæD0€ ý‹Ç_^]ËÿU‹ìS‹] V‹u‹ÆÁø… *A ‹ƒæ Áæ 0ŠA$ÀW¶y¾Àç€ Ñøû @ tPû € tBû t&û t û u=€I€‹
L1$Š€â€Êˆë'€I€‹
L1$Š€â‚€Êëè€aë
€I€‹
L1$€!€…ÿ_^[u¸ € ]Ã÷ØÀ% À @ ]ËÿU‹ì‹EV3ö;Æu èNgÿÿVVVVVÇ èÖfÿÿƒÄjXë
‹
d*A ‰3À^]ËÿU‹ìƒìh‹ES3ÛW‰]ôˆ]ÿ;Ãtƒøt~ƒø~ ƒøu ÆEÿ‹E‰Eðë8ègÿÿ‰èçfÿÿSSSSSÇ èofÿÿƒÄƒÈÿé® @8uûH8tÆ ‹Á8uëVjD^VE˜SPèdJÿÿ‰u˜‹5*A ƒÄ ;ót+Fÿ‹È‹ÐÁù‹ *A ƒâ Áâ8\uNH;óuà;óŒ@ þ23 ƒ4 ‹ÆkÀƒÀf‰EÊ·ÀjPèÇhÿÿYY‰EÌ;Ä ;ó‰0‹EÌH|0‰]ø~9‹Eø‹Ðƒà ÁúÁà• *A ŠPöÂuˆ‹ ‰ëˆƒÿÿEøAƒÇ9uø|Ê‹EÌ8]ÿt,H3ÒD0ƒþ}‹þëj_;×} ˆƒÿBAƒÀëäÇEô èÎeÿÿ‰EÜPE˜PSÿuÿuôjSSÿuðÿu ÿ à@ ‹ðÿ\à@ ÿuÌ‹øèñhÿÿY;óu Wè£eÿÿYëXƒ}uSè4Rÿÿ‹5á@ 9]u jÿÿuÜÿà@ EìPÿuÜÿà@ ‹]ìëƒ}uÿuÜÿÖë‹]ÜÿuàÿÖ‹Ãëè(eÿÿÇ ƒÈÿ^_[ÉËÿU‹ìƒì@¡€A 3ʼnEü‹M ‹ESVW¾xô@ }ð¥¥f¥‰MÔ‹M3Û‰Mà‹M¤j‰EÈ‹ø‹ ‰Mè‰]܉]ì‰]Ä^ëPè2“ÿÿƒÇt‹Y;ÃuìjV‰uÌè*gÿÿ‹uàYY‰;Ãu#‹Eè‰è˜dÿÿÇ è dÿÿÇ ƒÈÿé/ EðPEìSPè¼ÚÿÿƒÄ ;ÃtƒøuqSSSSSèËbÿÿƒÄëbEðPè¹’ÿÿ‹øGGY‰}Ð9]ìtÿuì褒ÿÿøY‰}ЋEÔ;ÃtOj‹ð‹ _ëP舒ÿÿƒÆ|‹Y;Ãuì¡< A ;ÃuCèíÿÿ£< A ;Ãu5‹uàÿ6ƒMÜÿèRgÿÿ‹Eè‰ Y‰ée ‹E艋}È‹‹6;Ã…ñ FéU ‰]ä8t(Š‹ð€ù=t Vè’ÿÿY‹MäL¡< A 4‰MäŠ:ËuÜ‹Mä‰MØë+8Xt-€x:u'€x=u!ƒÀPèÝ‘ÿÿY‹MØD‹
< A ‰EØÁ€8=t΋EØ+Eä‹uÔø‰}Àë EðP謑ÿÿPEðPÿ6è ƒÄ…ÀtMƒÆ9 uÝ}ÐjWè˜eÿÿ‹uàYY‹Mè‰;Ã…2ÿÿÿÿ6èkfÿÿY‰ èúbÿÿÇ ècÿÿƒMÜÿÇ éi ÇEÄ ë´P‹Æ+ÆEÌPVèºÿÿƒÄ …Àt
SSSSSè'aÿÿƒÄÿ7è‘ÿÿtƒÇë6P‹Eà‹ +ÆEÌPVèIºÿÿƒÄ …Àt
SSSSSèñ`ÿÿƒÄÿ7èãÿÿðƒÇÆ FY‹;ÃuËEèˆ^ÿˆ ‹09]Ô„Í ‹}Ø‹Eä‹Ï+ÈQ‹
< A ÈQVèöºÿÿ+}äƒÄ ÷‹}Ôë6‹EÀ‹Mèÿ7+ÆPVèѹÿÿƒÄ …Àt
SSSSSèy`ÿÿƒÄÿ7èkÿÿYtƒÇ9 uÆ9]Äug‹}ÐEðPWVè—¹ÿÿƒÄ …Àt
SSSSSè?`ÿÿƒÄh`ã@ WVè¸ÿÿƒÄ …Àt
SSSSSè `ÿÿƒÄ9]ìt ÿuìWVèß·ÿÿƒÄ …Àt
SSSSSèü_ÿÿƒÄ÷;ót ‹Eè;0uˆ Fˆ ¡< A ;ÃtPèÑdÿÿY‰ < A 9]ìt ÿuìè½dÿÿY‹EÜ‹Mü_^3Í[èIÿÿÉËÿU‹ìV3ö9uu$èBaÿÿ‰0è(aÿÿVVVVVÇ è°`ÿÿƒÄjXëU÷E ùÿÿÿuÓÿuÿ8á@ ƒøÿuÿ\à@ PèaÿÿYèç`ÿÿ‹ ë(¨u"¨t öE tèã`ÿÿÇ èÅ`ÿÿÇ
ëÑ3À^]ËÿU‹ìƒìSÿu3ÛMì‰]üèlHÿÿ‹M;Ëu(è“`ÿÿSSSSSÇ è`ÿÿƒÄ8]øt‹Eôƒ`pý3ÀëqV‹uð9^uÿu Qèj YY8]øtW‹MôƒapýëNWŠ¶Â¶øöD7 t!AŠ:Ót¶úÁà Ç9E uAÿ‰Eüë
9]üë9E u‰MüA:ÓuÃ_8]øt‹Eôƒ`pý‹Eü^[ÉËÿU‹ìj ÿu ÿuè2ÿÿÿƒÄ ]ËÿU‹ìƒìS3Û9]u3Àéš ÿuMìèGÿÿ‹Eð9Xu&ÿuÿu ÿuèÇÔÿÿƒÄ 8]ø„m ‹Môƒapýéa W‹};ût9] u.èƒ_ÿÿSSSSSÇ è _ÿÿƒÄ8]øt‹Eôƒ`pý¸ÿÿÿé% Vf¶ÿM·É¶ÑGöD ‰MütCŠ:Óu‰]üëXÁáf¶Òf Ê·Éf‹ñG‰Müf;pr f;pwfpë6f;pr0f;pw*fpë$·Uü öA t
f¶‰ ·Éë·Ê‰Müf‹uü‹M f¶ ÿE ·É¶ÑöD ‰MütE‹U Š:Óu‰]üëWÁáf¶Òf ÊÿE ·É‰Müf;Hr f;HwfHë6f;Hr0f;Hw*fHë$·Uü öA t
f¶‰ ·Éë·Ê‰Müf‹Müf;Îu!f;ót 9]…ëþÿÿ8]øt‹Eôƒ`pý3À^_[ÉÃÀƒàH8]øtð‹Môƒapýëç‹ÿU‹ìj ÿuÿu ÿuè#þÿÿƒÄ]ÃÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌU‹ìW‹}3ÀƒÉÿò®ƒÁ÷ÙƒïŠE ýò®ƒÇ8t3Àë‹Çü_Éà ”ú °ú Æú Üú îú û û 4û Lû `û hû zû ˆû šû ¬û ¼û Êû Üû ôû ü ü 8ü Vü jü zü †ü ’ü žü ¶ü Îü Øü äü öü ý ý ý (ý 8ý Ný Zý jý ’ý ¬ý Äý Þý ôý þ þ *þ Dþ Tþ jþ „þ þ žþ ®þ ¾þ Ðþ äþ ôþ
ÿ ÿ ,ÿ >ÿ Pÿ bÿ nÿ |ÿ Œÿ ¢ÿ ²ÿ Âÿ Ðÿ âÿ ôÿ ( 8 J ç@ ²A@ 4K@ ÎX@ Ð_@ »¬@ ˜@ failed to get exit code from process.
failed to create process.
%s %s Could not exec %s Cannot find Python executable %s
#!python.exe #! Cannot open %s
-script.py CorExitProcess m s c o r e e . d l l ( n u l l ) (null) EEE50 P ( 8PX 700WP `h```` xpxxxx ¨!A "A
!"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ = EncodePointer K E R N E L 3 2 . D L L DecodePointer FlsFree FlsSetValue FlsGetValue FlsAlloc runtime error
TLOSS error
SING error
DOMAIN error
R6034
An application has made an attempt to load the C runtime library incorrectly.
Please contact the application's support team for more information.
R6033
- Attempt to use MSIL code from this assembly during native code initialization
This indicates a bug in your application. It is most likely the result of calling an MSIL-compiled (/clr) function from a native constructor or from DllMain.
R6032
- not enough space for locale information
R6031
- Attempt to initialize the CRT more than once.
This indicates a bug in your application.
R6030
- CRT not initialized
R6028
- unable to initialize heap
R6027
- not enough space for lowio initialization
R6026
- not enough space for stdio initialization
R6025
- pure virtual function call
R6024
- not enough space for _onexit/atexit table
R6019
- unable to open console device
R6018
- unexpected heap error
R6017
- unexpected multithread lock error
R6016
- not enough space for thread data
This application has requested the Runtime to terminate it in an unusual way.
Please contact the application's support team for more information.
R6009
- not enough space for environment
R6008
- not enough space for arguments
R6002
- floating point support not loaded
Microsoft Visual C++ Runtime Library
... Runtime Error!
Program: À À – À À Ž À À À ‘ À ’ À “ À €€†€€ †€†‚€EEE……… 00€P€ˆ ('8PW€ 700PPˆ (€ˆ€€ `h`hhhxppwpp ( ( ( ( ( H „ „ „ „ „ „ „ „ „ „ ‚ ‚ ‚ ‚ ‚ ‚ h ( ( ( ( H „ „ „ „ „ „ „ „ „ „ ‚‚‚‚‚‚ H €‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ ¡¢£¤¥¦§¨©ª«¬®¯°±²³´µ¶·¸¹º»¼½¾¿ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖ×ØÙÚÛÜÝÞßàáâãäåæçèéêëìíîïðñòóôõö÷øùúûüýþÿ
!"#$%&'()*+,-./0123456789:;<=>?@abcdefghijklmnopqrstuvwxyz[\]^_`abcdefghijklmnopqrstuvwxyz{|}~€‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ ¡¢£¤¥¦§¨©ª«¬®¯°±²³´µ¶·¸¹º»¼½¾¿ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖ×ØÙÚÛÜÝÞßàáâãäåæçèéêëìíîïðñòóôõö÷øùúûüýþÿ€‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ ¡¢£¤¥¦§¨©ª«¬®¯°±²³´µ¶·¸¹º»¼½¾¿ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖ×ØÙÚÛÜÝÞßàáâãäåæçèéêëìíîïðñòóôõö÷øùúûüýþÿ
!"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`ABCDEFGHIJKLMNOPQRSTUVWXYZ{|}~€‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ ¡¢£¤¥¦§¨©ª«¬®¯°±²³´µ¶·¸¹º»¼½¾¿ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖ×ØÙÚÛÜÝÞßàáâãäåæçèéêëìíîïðñòóôõö÷øùúûüýþÿHH:mm:ss dddd, MMMM dd, yyyy MM/dd/yy PM AM December November October September August July June April March February January Dec Nov Oct Sep Aug Jul Jun May Apr Mar Feb Jan Saturday Friday Thursday Wednesday Tuesday Monday Sunday Sat Fri Thu Wed Tue Mon Sun GetProcessWindowStation GetUserObjectInformationA GetLastActivePopup GetActiveWindow MessageBoxA USER32.DLL SunMonTueWedThuFriSat JanFebMarAprMayJunJulAugSepOctNovDec CONOUT$ .com .exe .bat .cmd .\ SystemRoot H €A Ðô@ Ð7 i ™ þÿÿÿ Ôÿÿÿ þÿÿÿ ×@ þÿÿÿ Èÿÿÿ þÿÿÿ ¼#@ þÿÿÿ Ìÿÿÿ þÿÿÿ©%@ ½%@ þÿÿÿ Œÿÿÿ þÿÿÿ<5@ @5@ þÿÿÿ Ôÿÿÿ þÿÿÿ ã:@ þÿÿÿ Ðÿÿÿ þÿÿÿ ±;@ þÿÿÿ Ìÿÿÿ þÿÿÿ ;=@ =@ þÿÿÿ Ôÿÿÿ þÿÿÿ À>@ þÿÿÿ Ôÿÿÿ þÿÿÿ ó?@ þÿÿÿ Ôÿÿÿ þÿÿÿ A@ 9A@ þÿÿÿ Ôÿÿÿ þÿÿÿ -G@ þÿÿÿ Ìÿÿÿ þÿÿÿ ûJ@ þÿÿÿ Ôÿÿÿ þÿÿÿ kN@ þÿÿÿ Ôÿÿÿ þÿÿÿ P@ þÿÿÿ ¼P@ þÿÿÿ Øÿÿÿ þÿÿÿ oR@ þÿÿÿ {R@ þÿÿÿ Ôÿÿÿ þÿÿÿ 5Y@ þÿÿÿ Øÿÿÿ þÿÿÿÛZ@ ïZ@ þÿÿÿ Øÿÿÿ þÿÿÿ-[@ 1[@ þÿÿÿ Àÿÿÿ þÿÿÿ ˆ^@ þÿÿÿ Ðÿÿÿ þÿÿÿ_@ /_@ þÿÿÿ Ôÿÿÿ þÿÿÿ )j@ þÿÿÿ Ðÿÿÿ þÿÿÿ :l@ þÿÿÿ Ôÿÿÿ þÿÿÿ >y@ þÿÿÿ Ðÿÿÿ þÿÿÿ N@ þÿÿÿ Ðÿÿÿ þÿÿÿ /‚@ þÿÿÿ Ìÿÿÿ þÿÿÿ $•@ þÿÿÿ Ðÿÿÿ þÿÿÿ ½—@ þÿÿÿ Ðÿÿÿ þÿÿÿ T¡@ þÿÿÿ Ôÿÿÿ þÿÿÿ Ë¥@ þÿÿÿ Èÿÿÿ þÿÿÿ ‘§@ ͦ@ þÿÿÿ Ðÿÿÿ þÿÿÿ L®@ þÿÿÿ Ðÿÿÿ þÿÿÿ hÂ@ þÿÿÿ Ìÿÿÿ þÿÿÿ Ê@ Tù à ”ú °ú Æú Üú îú û û 4û Lû `û hû zû ˆû šû ¬û ¼û Êû Üû ôû ü ü 8ü Vü jü zü †ü ’ü žü ¶ü Îü Øü äü öü ý ý ý (ý 8ý Ný Zý jý ’ý ¬ý Äý Þý ôý þ þ *þ Dþ Tþ jþ „þ þ žþ ®þ ¾þ Ðþ äþ ôþ
ÿ ÿ ,ÿ >ÿ Pÿ bÿ nÿ |ÿ Œÿ ¢ÿ ²ÿ Âÿ Ðÿ âÿ ôÿ ( 8 J RGenerateConsoleCtrlEvent ÆGetExitCodeProcess nWaitForSingleObject • CreateProcessA ¯SetConsoleCtrlHandler õGetModuleFileNameA Ú EnterCriticalSection ôLeaveCriticalSection úGetModuleHandleW +Sleep "GetProcAddress ExitProcess pGetCommandLineA ðSetHandleCount >GetStdHandle ØGetFileType <GetStartupInfoA ¿ DeleteCriticalSection 7TerminateProcess ªGetCurrentProcess HUnhandledExceptionFilter SetUnhandledExceptionFilter ÖIsDebuggerPresent çGetLastError ¦HeapFree ¢HeapAlloc \GetCPInfo ÅInterlockedIncrement ÁInterlockedDecrement SGetACP GetOEMCP àIsValidCodePage >TlsGetValue <TlsAlloc ?TlsSetValue =TlsFree ôSetLastError ®GetCurrentThreadId —WriteFile öLoadLibraryA ºInitializeCriticalSectionAndSpinCount KFreeEnvironmentStringsA ÀGetEnvironmentStrings LFreeEnvironmentStringsW „WideCharToMultiByte ÂGetEnvironmentStringsW ¤HeapCreate aVirtualFree YQueryPerformanceCounter jGetTickCount «GetCurrentProcessId SGetSystemTimeAsFileTime šRtlUnwind ©HeapReAlloc ^VirtualAlloc „GetConsoleCP –GetConsoleMode BFlushFileBuffers æLCMapStringA MultiByteToWideChar èLCMapStringW @GetStringTypeA CGetStringTypeW éGetLocaleInfoA çSetFilePointer «HeapSize D CloseHandle ŒWriteConsoleA šGetConsoleOutputCP –WriteConsoleW SetStdHandle y CreateFileA S CompareStringA V CompareStringW ØSetEnvironmentVariableA KERNEL32.dll nReadFile ÕSetEndOfFile &GetProcessHeap ÊGetFileAttributesA À+A À+A Næ@»±¿Dê#@ lâ@ \â@ ÿÿÿÿ€
!
5 A
C P R
S
W Y l
m p r €
‚ ƒ „
‘ ) ž
¡ ¤ §
· Î × abcdefghijklmnopqrstuvwxyz ABCDEFGHIJKLMNOPQRSTUVWXYZ abcdefghijklmnopqrstuvwxyz ABCDEFGHIJKLMNOPQRSTUVWXYZ hA ¤ `‚y‚! ¦ß ¡¥ Ÿàü @~€ü ¨ Á£Ú£ þ @þ µ Á£Ú£ þ Aþ ¶ Ï¢ä¢ å¢è¢[ þ @~¡þ Q QÚ^Ú _ÚjÚ2 ÓØÞàù 1~þ lí@ þÿÿÿC A A A A A H A hë@ ðï@ pñ@ ˆ A ˜A ˜A hA ÿÿÿÿÿÿÿÿ øè@ Ìè@ è@
è@ Üç@ ¬ç@ ˆç@ \ç@ $ç@ üæ@ Äæ@ Œæ@ dæ@ Dæ@ àå@ ¨å@ ! °ä@ " ä@ x ä@ y ðã@ z àã@ ü Üã@ ÿ Ìã@ Η@ Η@ Η@ Η@ Η@ Η@ Η@ Η@ Η@ Η@ x
hë@ jí@ ˜ó@ ”ó@ ó@ Œó@ ˆó@ „ó@ €ó@ xó@ pó@ hó@ \ó@ Pó@ Hó@ <ó@ 8ó@ 4ó@ 0ó@ ,ó@ (ó@ $ó@ ó@ ó@ ó@ ó@ ó@ ó@ ó@ øò@ ðò@ èò@ (ó@ àò@ Øò@ Ðò@ Äò@ ¼ò@ °ò@ ¤ò@ ò@ œò@ ò@ |ò@ pò@ ˆ A . D A Œ)A Œ)A Œ)A Œ)A Œ)A Œ)A Œ)A Œ)A Œ)A H A . “ €p ðñÿÿ PST PDT Ð A A ÿÿÿÿ ÿÿÿÿ þÿÿÿþÿÿÿÿÿÿÿ ; Z x — µ Ô ó 0 N m ÿÿÿÿ : Y w – ´ Ó ò / M l lô@ dô@ \ô@ Tô@ setuptools-20.7.0/setuptools/cli-64.exe 0000664 0001750 0001750 00000222000 12702524020 020575 0 ustar travis travis 0000000 0000000 MZ ÿÿ ¸ @ à º ´ Í!¸LÍ!This program cannot be run in DOS mode.
$ è
W†^W†^W†^p¹ý^T†^W‡^
†^ê0^S†^I-^s†^I-^]†^I-^:†^I-^V†^RichW†^ PE d† ±‹Q ð # Ö j x+ @ p € ì ( ` ü ð .text Ô Ö `.rdata ) ð * Ú @ @.data ä5 @ À.pdata ü `
@ @ H‰\$H‰l$H‰t$H‰|$ ATAUAVHƒì L‹áHƒÉÿ3ÀI‹üº ò®H÷ÑD HyÿHcÈè@ 3ö3íLcïÆ "HXL‹ð…ÿ~e € A¶ ,€ù\uÿÆë'€ù"u …ö~D‹Æ²\H‹Ë‹þèZ Hß+öÆ\HÿÃë3öA¶,HÿÅHÿÃI;íˆCÿ|¸…ö~D‹Æ²\H‹Ë‹þè% HßH‹l$HH‹t$PH‹|$XÆ"ÆC H‹\$@I‹ÆHƒÄ A^A]A\ÃÌÌÌÌÌÌÌÌÌH‰\$WHì` H‹¼ H3ÄH‰„$P H‹ÙH‹Á¶ H‹ú„ÉtHÿÀ€ù/uÆ@ÿ\Š„ÉuîH„$@ LŒ$@ LD$@HT$0H‹ËH‰D$ è? €|$0 …® €|$@\„£ H„$@ LŒ$@ LD$@HT$0H‹ÏH‰D$ è HƒÉÿ3ÀH|$@ò®HD$@H÷ÑHÿÈHÿÉHÈ€9\uHÿÉ€9\tHD$@H;Èr Æ HÿÉ€9\uëLD$@HT$0HŒ$@ L‹ËHÇD$ èÏ
º ¹ è|
H”$@ ëº ¹ èc
H‹ÓA¸ H‹ÈH‹øè« H‹ÇH‹Œ$P H3Ìèø H‹œ$€ HÄ` _ÃÌÌÌÌÌÌÌH‰\$H‰l$H‰t$H‰|$ ATAUAVHƒì H‹ÙHƒÉÿ3ÀL‹êH‹ûPò®H÷ÑHÿÉèç 3ÿH‹óA‰} ¾ L‹ðE3äH‰èU …Àt D ¾KHÿÃè@ …Àuð¶+HÿÃ@„ít[@¾Íè( …ÀtE…ätI@€ý\uÿÇëÙ@€ý"u@öÇu3ÀE…ä”À@2íD‹àÑÿ…ÿtL‹Ç²\H‹Îè¼ H÷3ÿ@„ít¢@ˆ.HÿÆëš…ÿtL‹Ç²\H‹Îè™ H÷3ÿÆ AÿE IcE HÿÆI‰4Æ@„ít&¾ è¡ …Àt¾KHÿÃè …Àuð€; …GÿÿÿH‹\$@H‹l$HH‹t$PH‹|$XI‹ÆHƒÄ A^A]A\ÃÌÌÌÌÌHƒì(…Éu‹
‚! …Ét3Òÿ6Ü ¸ HƒÄ(ÃÌÌÌÌÌÌÌÌÌÌÌÌH‰\$WHìà 3À3ÿH‹ÙHL$pDGh3Ò‰¼$ð H‰D$PH‰D$XH‰D$`èÆ WH
ŒÿÿÿÇD$ph ÿîÛ L\$PHD$pL‰\$HH‰D$@H‰|$8H‰|$0E3ÉE3ÀH‹Ó3ɉ|$(ÇD$ ÿ«Û …Àu(èê H«Þ HH`èb 3ÀH‹œ$ø HÄà _ËD$`H‹L$PƒÊÿ‰• ÿ_Û H‹L$PH”$ð ÿDÛ …Àu(è“ H,Þ HH`è 3ÀH‹œ$ø HÄà _Ë„$ð H‹œ$ø HÄà _ÃÌÌÌÌÌÌÌÌH‰\$H‰l$H‰t$WATAUHƒì L‹éHƒÉÿ3À» I‹ýIcèò®H;ÝH‹òH÷ÑL‹ËLQ}J‹<ÊHƒÉÿ3Àò®IÿÁH÷ÑDÑL;Í|æIcÊH‹Óè HÌÝ M‹ÅH‹ÈL‹àè HƒÉÿ3ÀI‹ýò®H;ÝH÷ÑLiÿ}0L‹ÞIcÍH•Ý IÌèÕ H‹<ÞHƒÉÿ3ÀHÿÃò®H÷ÑDéH;Ý|ÐH‹\$@H‹l$HH‹t$PI‹ÄHƒÄ A]A\_ÃÌÌÌ@SWAVAWHìX H‹»
H3ÄH‰„$0 L‹òD‰D$ LcùHT$0A¸ 3ÉÿúÙ HƒÉÿ3ÀH|$0ò®H÷ÑHD /HL$0H;Áv €8.tHT$0Æ HÿÈH;ÂwëÆ 3ÀHƒÉÿH|$03Òò®H‹:Ý HL$0H‰Gÿ·2Ý f‰G¶)Ý ˆG èë· ‹Øƒøÿu"è³ LD$0HïÜ HH`è& Céó H”$0 A¸ ‹ÈH‰¬$ è1® HcÈH¼ 0 ‹Ëè_‡ H”$0 HÿÊHÿÂH;×s¶„Àt<
t<
uéÆ HŒ$0 HsÜ A¸ è …Àt%H‹MÜ HŒ$0 H‰‹DÜ ‰A¶>Ü ˆA HT$$HŒ$2 èíúÿÿHT$0H‹8H‹ØH‹ÏèjùÿÿH‹èH…Àu èÍ HÎÛ L‹ÇHH`èB Eé H‰´$P ‹t$$L‰¤$H L‰¬$@ E,7º AEHcÈè¥ H‹ÍL‹àèøÿÿƒþI‰$I|$~"HƒÃÿÎfH‹ èø÷ÿÿHƒÇHƒÃHƒîH‰GøuæHL$0èÜ÷ÿÿ» HƒÇI;ßH‰Gø}I‹ ÞèÁ÷ÿÿHÿÃHƒÇI;ßH‰Gø|çƒ|$ H‹´$P HÇ t*I‹ÔH‹ÍèÔ¤ èë HÔÚ HH`L‹Åè` ¸ ëE‹ÅI‹ÔH‹ÍèsüÿÿH‹Èè;ûÿÿL‹¤$H L‹¬$@ H‹¬$ H‹Œ$0 H3Ìès
HÄX A_A^_[ÃÌÌÌÌÌE3ÀéýÿÿH‹ÄH‰PH‰HL‰@L‰H SVWATHƒì8H‹ù3Û‹ó‹ÃH;Ë•À;Ãu'èL& Ç H‰\$ E3ÉE3À3Ò3Éèb% ƒÈÿé ‹ÃH;Ó•À;Ãu'è& Ç H‰\$ E3ÉE3À3Ò3Éè/% ƒÈÿéâ Ld$pèù öG@…• H‹Ïè¢# ƒøÿt*ƒøþt%HcÐH‹ÊHÁùL×) ƒâ HkÒXIÈH
5
ëH
,
H‹ÑL²) öB8u%ƒøÿtƒøþtHcÈH‹ÁHÁøƒá HkÉXI ÀöA8€t"èj% Ç H‰\$ E3ÉE3À3Ò3Éè€$ ƒÎÿ;óu*H‹Ïè ‹ØM‹ÌE3ÀH‹T$hH‹Ïè ‹ðH‹×‹Ëè¼ H‹Ïè³ ‹ÆHƒÄ8A\_^[ÃÌÌÌH™ Ã@SHƒì ‹l; » …Àu¸ ë;ÃLÃHcȺ ‰I; èÀ% H‰ + H…Àu$PH‹Ë‰ ,; è£% H‰ + H…Àu¸ ëx3ÉH+ H‰HƒÂ0HƒÁHƒët H‹Ò* ëåE3ÀH" EHI‹ÈLx( I‹ÀHÁøƒá I‹ÂHkÉXL‹Iƒúÿt IƒúþtM…ÒuÇþÿÿÿIÿÀHƒÂ0Iƒéu¼3ÀHƒÄ [ÃÌÌHƒì(èC) €=4 tèÍ& H‹
V* HƒÄ(é}& Ì@SHƒì H‹ÙH
| H;Ùr:H H;Øw.H‹ÓH¸«ªªªªªª*H+ÑH÷êHÁúH‹ÊHÁé?Lèø* ºkë
HK0ÿcÔ HƒÄ [ÃÌ@SHƒì ƒùH‹Ú}ƒÁèÊ* ºkë
HJ0ÿ5Ô HƒÄ [ÃÌÌÌHƒì(Hñ H;Êr7Hu H;Èw+ºqH+ÊH¸«ªªªªªª*H÷éHÁúH‹ÊHÁé?Lèk) ë
HƒÁ0ÿãÓ HƒÄ(ÃÌÌHƒì(ƒù}ºrƒÁèB) ë
HJ0ÿºÓ HƒÄ(ÃÌ@SHƒì ƒd$@ LD$@è_* H‹ØH…Àu9D$@tè¼" H…Àt è²" ‹L$@‰H‹ÃHƒÄ [ÃÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌff „ H‹ÁIƒørS¶ÒI¹I¯ÑIƒø@r H÷ÙƒátL+ÁH‰HÈM‹ÈIƒà?IÁéu9M‹ÈIƒàIÁétfffH‰HƒÁIÿÉuôM…Àt
ˆHÿÁIÿÈuöà @ fffffIù s0H‰H‰QH‰QHƒÁ@H‰QØH‰QàIÿÉH‰QèH‰QðH‰QøuØë”f D HÃHÃQHÃQHƒÁ@HÃQØHÃQàIÿÉHÃQèHÃQðHÃQøuÐð€ $ éTÿÿÿÌÌÌÌÌÌÌÌÌÌÌÌff „ L‹ÙM Àt$H+ÊöÂt(Š„Àˆ„ã HÿÂIÿÈtöÂuæë I‹ÃÃH‰HƒÂH‹Iƒèr&I¹ÿþþþþþþ~LÈL‹ÐIƒòÿM3ÑI¹ M…ÑtÉIƒÀ„‹ „Àˆ„„ HÿÂIÿÈtx„äˆ$tuHÿÂIÿÈtiHÁè„ÀˆtbHÿÂIÿÈtV„äˆ$tSHÿÂIÿÈtGHÁè„Àˆt@HÿÂIÿÈt4„äˆ$t1HÿÂIÿÈt%Áè„Àˆt HÿÂIÿÈt„äˆ$tHÿÂIÿÈ…<ÿÿÿI‹ÃÃHÊH3ÒIƒørEöÁt
HÿÁˆIÿÈëñIƒè rH‰H‰QH‰QH‰QHƒÁ Iƒè sçIƒÀ Iƒèr H‰HƒÁëñIƒÀIƒèrˆHÿÁëóI‹ÃÃÌÌ@SHƒì E‹H‹ÚL‹ÉAƒãøAö L‹ÑtA‹@McP÷ØLÑHcÈL#ÑIcÃJ‹H‹C‹HHKöAt ¶AƒàðH˜LÈL3ÊI‹ÉHƒÄ [é™ ÌHƒì(M‹A8H‹ÊI‹Ñè‰ÿÿÿ¸ HƒÄ(ÃÌÌÌHƒì8H‹D$`H‰D$(L‰L$ M‹ÈL‹ÂHƒÊÿè¾' HƒÄ8ÃÌH‰\$L‰D$UVWATAUAVAWHƒì0L‹¤$¨ L‹¬$˜ H‹ùL‹ò3ÒM‹ù‹Ê‰T$pH;út
L;òuL;Ât¹ é¼ L;ÂtñL;Êu H9”$ uâë
H9”$ tÖL;êu H9”$ uÇë
H9”$ t»L;âu H9”$° u¬ë
H9”$° t ¸ H‹ß8t HÿÈHÿÃH;Âwñ€;:u,L;òt!Iƒø‚; A¹ L‹ÇHƒÊÿI‹ÎèÏ( 3ÒH{ëL;òtAˆH‹êH‹òH‹ß8te¾ è–( 3Ò;ÂtHÿÃëŠ
L‰?
H‹
‹
è¥íÿÿ‹ø‰D$ …Ûu‹Èèôýÿÿèþÿÿë‹øƒ|$@ u‹ÈèéýÿÿÌèÿýÿÿ‹ÇH‹\$HHƒÄ0_ÃÌHƒì(è7B HƒÄ(éVþÿÿÌÌH‹ÄH‰XH‰hH‰p H‰PWATAUAVAWHƒì@M‹yM‹!I‹q8M+çöAfM‹ñH‹êL‹é…Ü 3ÿH‰HÈL‰@Ð9>†+ H^ ‹CøL;à‚§ ‹CüL;àƒ› ƒ{ „‘ ƒ;t‹HL$0H‹ÕIÇÿÐ…Àˆ„ ~sA} csmàu(Hƒ=K t H
B è5 …Àtº I‹Íÿ+ ‹KA¸ H‹ÕIÏèGB I‹F@‹SMcM H‰D$(I‹F(I×M‹ÅH‹ÍH‰D$ ÿ×à èJB ÿÇHƒÃ;>sjé>ÿÿÿ3ÀëfI‹y 3íI+ÿ9.vTH^‹KôL;ár>‹CøL;às6H;ùr H;øsAöE u/ƒ; t ‹H;øt#ëH‹T$xIDZI‰D‹CüMÇAÿÐÿÅHƒÃ;.r°¸ L\$@I‹[0I‹k@I‹sHI‹ãA_A^A]A\_ÃÌÌÌH‰\$H‰|$ATHƒì H‹Ùèè ‹Èè•A …À„— èíÿÿHƒÀ0H;Øu3ÀëèòìÿÿHƒÀ`H;Øuw¸ ÿ ÷C ucL%& HcøIƒ<ü u+¹ èJ I‰üH…ÀuHC H‰CH‰¸ ‰C$‰CëI‹ üÇC$ ÇC H‰KH‰ K ¸ ë3ÀH‹\$0H‹|$8HƒÄ A\ÃÌÌÌ…Ét0SHƒì ºb H‹Ús H‹ÊèÁ cÿîÿÿƒc$ Hƒ# Hƒc HƒÄ [ÃÌÌÌ@SHƒì öB@I‹Øt Hƒz uAÿ ë&ƒBÿx
H‹ˆHÿ¶Áë¾Éèæ, ƒøÿu ëÿHƒÄ [ÃÌ…Ò~LH‰\$H‰l$H‰t$WHƒì I‹ùI‹ð‹Ú@ŠéL‹ÇH‹Ö@ŠÍÿËè…ÿÿÿƒ?ÿt…ÛçH‹\$0H‹l$8H‹t$@HƒÄ _ÃÌÌÌH‰\$H‰l$H‰t$WHƒì Aö@@I‹ùI‹ð‹ÚH‹ét Iƒx uAë7…Ò~3ŠM L‹ÇH‹ÖÿËè ÿÿÿHÿŃ?ÿuè= ƒ8*uL‹ÇH‹Ö±?èÿþÿÿ…ÛÍH‹\$0H‹l$8H‹t$@HƒÄ _ÃÌÌH‰\$UVWATAUAVAWHìÐ H‹Jô H3ÄH‰„$È 3ÀH‹ÙH‰L$hH‹úHL$xI‹ÐM‹é‰D$`D‹à‰D$TD‹ð‰D$H‰D$X‰D$Pè¨óÿÿE3ÒI;ÚuAè£ 3ÛE3ÉE3À3Ò3ÉÇ H‰\$ è· 8œ$ tH‹„$ˆ ƒ È ýƒÈÿéý AƒÏÿöC@L
ðÏÿÿ…º H‹Ëè
HËó A;Çt(ƒøþt#LcÀL
ÇÏÿÿI‹ÈAƒà HÁùMkÀXM„É€C ë
L‹ÂL
¤ÏÿÿAö@8u)A;Çt ƒøþtHcÐH‹Âƒâ HÁøHkÒXI”Á€C öB8€tAè× 3ÛE3ÉE3À3Ò3ÉÇ H‰\$ èë
8œ$ tH‹„$ˆ ƒ È ýA‹Çé1 E3ÒI;út·@Š/A‹òD‰T$@D‰T$DA‹ÒL‰”$˜ A:ê„ê H‹œ$¨ A» HÿÇA;òH‰¼$° ŒÈ EàÿtkHƒ>þteAöE t^AöE uH‹ÿ˜´ A;ÇtILcçI‹ÄHÁøAƒä MkäXM$ÆH‹I‰$AŠE AˆD$IL$º èÎ* A;ÇtAÿD$ ëƒÈÿéÕ ÿÇIÿÅHƒÆ;û|‚E‹çI‹ÿH‹ßHkÛXH ) Hƒ;ÿt Hƒ;þt€K€ëÆCAD$ÿ÷ØɃÁõ¸öÿÿÿE;çDÈÿî³ H‹ðHƒøÿtJI;ÇtEH‹Èÿß³ A;Çt7H‰3¶Àƒøu€K@ë ƒøu€KHKº è"* A;ÇtÿC ëƒÈÿë.€K@HÇþÿÿÿAÿÄHÿÇHƒÿŒQÿÿÿ‹
j ÿl³ 3ÀëƒÈÿLœ$ I‹[ I‹s(I‹{0M‹c8I‹ãA_A^A]ÃÌÌÌHƒì8H…Éu%è* Hƒd$ E3ÉE3À3Ò3ÉÇ è? ƒÈÿë‹A HƒÄ8ÃÌÌH‰
Yø Ã@SHìà ƒd$p HL$t3ÒA¸” èPßÿÿL\$pH„$ HŒ$ L‰\$HH‰D$Pÿ³ H‹œ$ HT$@H‹ËE3Àèq H…Àt;Hƒd$8 H‹T$@HL$`H‰L$0HL$XL‹ÈH‰L$(HŒ$ L‹ÃH‰L$ 3Éè- ë H‹„$è H‰„$ H„$è H‰„$¨ H‹„$è ÇD$p ÀÇD$t H‰„$€ ÿe² 3É‹ØÿS² HL$Hÿ@² …Àu …ÛuHèl4 ÿ"² º ÀH‹Èÿ ² HÄà [ÃÌÌÌH‰\$H‰l$H‰t$WHƒì0H‹éH‹
÷ A‹ÙI‹øH‹òè@ H…ÀtL‹T$`D‹ËL‹ÇH‹ÖH‹ÍL‰T$ ÿÐë%¹ è÷3 L‹\$`D‹ËL‹ÇH‹ÖH‹ÍL‰\$ èhþÿÿH‹\$@H‹l$HH‹t$PHƒÄ0_ÃÌÌÌL
)å 3ÀI‹ÑD@;
t+ÿÀIЃø-ròAíƒøw¸
ÃÁDÿÿÿ¸ ƒùAFÀÃH˜A‹DÁÃÌHƒì(èw H…Àu H;æ ëHƒÀHƒÄ(ÃHƒì(èW H…Àu H æ ëHƒÀHƒÄ(Ã@SHƒì ‹Ùè3 H…Àu Hûå ëHƒÀ‰è Lãå H…ÀtLP‹Ëè;ÿÿÿA‰HƒÄ [ÃÌÌH‰\$H‰l$H‰t$WHƒì 3ÿH‹ñƒÍÿH‹ÎèØ2 H‹ØH…Àu(9®õ v ‹Ïÿ ° DŸè D; –õ A‹ûGý;ýuÈH‹l$8H‹t$@H‹ÃH‹\$0HƒÄ _ÃH‹ÄH‰XH‰hH‰pH‰x ATHƒì 3ÿH‹òH‹éAƒÌÿE3ÀH‹ÖH‹Íèi H‹ØH…Àu*93õ v"‹Ïÿ¡¯ DŸè D; õ A‹ûAGüA;üuÀH‹l$8H‹t$@H‹|$HH‹ÃH‹\$0HƒÄ A\ÃÌH‹ÄH‰XH‰hH‰pH‰x ATHƒì 3öH‹úH‹éAƒÌÿH‹×H‹Íè”2 H‹ØH…Àu/H…ÿt*9ô v"‹Îÿ¯ Džè D; •ô A‹óAGôA;ôu¾H‹l$8H‹t$@H‹|$HH‹ÃH‹\$0HƒÄ A\ÃÌÌÌH‰\$H‰l$H‰t$WATAUHƒì 3öI‹øH‹êAƒÍÿL‹áL‹ÇH‹ÕI‹ÌèÛ2 H‹ØH…Àu/H…ÿt*9 ô v"‹ÎÿŽ® Džè D; ô A‹óAGõA;õu»H‹l$HH‹t$PH‹ÃH‹\$@HƒÄ A]A\_ÃH…Ét7SHƒì L‹ÁH‹
L 3ÒÿÔ® …ÀuèSýÿÿH‹Øÿº® ‹Èèûüÿÿ‰HƒÄ [ÃÌÌÌH‰\$H‰t$ATHƒì03öNèj ^‰\$ ; ˆ }iLcãH‹\ Jƒ<à tPJ‹ àöAƒtè&3 ƒøÿtÿƉt$$ƒû|1H‹/ J‹ àHƒÁ0ÿñ H‹
J‹ áèAÿÿÿL‹
Kƒ$ã ÿÉ\$ ë¹ èç ‹ÆH‹\$@H‹t$HHƒÄ0A\ÃH‰\$H‰t$WHƒì ‹A3öH‹Ù$<u?÷A t6‹9+y…ÿ~-è úÿÿH‹SD‹Ç‹ÈèV: ;Çu‹C„Àyƒàý‰CëƒK ƒÎÿH‹Kƒc ‹ÆH‹t$8H‰ H‹\$0HƒÄ _ÃÌÌÌ@SHƒì H‹ÙH…Éuè5 ë,èjÿÿÿ…ÀtƒÈÿë ºcsH‹Ëè¢ùÿÿ‹Èè; ÷ØÀë3ÀHƒÄ [ÃÌH‰t$H‰|$L‰d$AUAVAWHƒì0D‹ñE3ä3öNèç 3ÿ‰|$ AƒÏÿ;= † LcïH‹Ò Jƒ<è tjJ‹èöBƒt`‹ÏèÎ×ÿÿH‹² J‹ èöAƒt5Aƒþuè9ÿÿÿA;Çt%AÿÄD‰d$$ëE…öuöAtèÿÿÿA;ÇAD÷‰t$(H‹l J‹ê‹Ïèý×ÿÿÿlj|$ énÿÿÿ¹ è@ AƒþADô‹ÆH‹t$PH‹|$XL‹d$`HƒÄ0A_A^A]ù éÿÿÿÌÌH‰\$H‰t$H‰|$ATHƒì L% á 3ö3ÿI‹Üƒ{u%Hcƺ ÿÆH €Hþð H ÈH‰ è" …Àt-Hã HƒÃÿÇH;Ø|ø H‹\$0H‹t$8H‹|$@HƒÄ A\ÃHcÇHÀIƒ$Ä 3ÀëÛÌÌH‰\$H‰l$H‰t$WHƒì H uà H-®â H‹ûH‹7H…ötƒtH‹Îÿ$« H‹Îè|üÿÿHƒ' HƒÇH;ý|ÔH‹ H…Ét ƒ{uÿûª HƒÃH;Ý|ãH‹\$0H‹l$8H‹t$@HƒÄ _ÃÌHcÉHà HÉH‹ ÈHÿ%lª H‰\$H‰t$H‰|$AUHƒì HcÙ¾ Hƒ=_ü uè N èè ¹ÿ èZàÿÿH‹ûHÿL-©ß Iƒ|ý t‹Æë{¹( èÃùÿÿH‹ØH…Àuè.ùÿÿÇ 3ÀëZ¹
èf Iƒ|ý u/º H‹ËèŒ …ÀuH‹Ëè€ûÿÿèóøÿÿÇ 3öëI‰\ý ë H‹ËèbûÿÿH‹
Êß ÿœ© ‹ÆH‹\$0H‹t$8H‹|$@HƒÄ A]ÃH‰\$WHƒì HcÙH=øÞ HÛHƒ<ß uèõþÿÿ…ÀuHèßÿÿH‹ ßH‹\$0HƒÄ _Hÿ%8© H‰\$WHƒì0I‹ØH‹úH…Ét23ÒHBàH÷ñH;Çs$èHøÿÿHƒd$ E3ÉE3À3Ò3ÉÇ è]÷ÿÿ3Àë]H¯ù¸ H…ÿHDø3ÀHƒÿàwH‹
òú PL‹Çÿ~© H…Àu-ƒ=êú tH‹Ïè° …ÀuËH…Ût²Ç ëªH…ÛtÇ H‹\$@HƒÄ0_ÃÌH‰\$H‰l$H‰t$WHƒì0H‹òH‹éH…É„û H…Ò„ò 3ÿH‹ÙM…Àt!AŠ „Àt¿ H;׆¼ HYˆÆ:HÿÃI‹ÑM…ÉtAA€9 t;HÿÇH;þƒ– ŠHÿˆHÿÀ: uåI‹ÉèL8 €8/t€8\tHÿÇH;þsmÆ\HÿÃH‹L$`H…ÉtëHÿÇH;þsSŠˆHÿÃHÿÁ€9 uéH‹L$hH…Ét1Š„Àt+<.t"HÿÇH;þs(Æ.HÿÃëHÿÇH;þsŠˆHÿÃHÿÁ€9 uéHGH;ÆvÆE è°öÿÿ»" ëÆ 3Àë#èöÿÿ» Hƒd$ E3ÉE3À3Ò3ɉè±õÿÿ‹ÃH‹\$@H‹l$HH‹t$PHƒÄ0_ÃÌÌH‰\$H‰t$WHƒì@‹ÚH‹ÑHL$ A‹ùA‹ðè<ÚÿÿH‹D$(D¶ÛA„| u …ötH‹D$ H‹ˆ@ B·Y#Æë3À…Àt¸ €|$8 t H‹L$0ƒ¡È ýH‹\$PH‹t$XHƒÄ@_ÃÌH‹Â‹ÑA¹ H‹ÈE3ÀénÿÿÿÌÌ‹ÑA¹ E3À3ÉéZÿÿÿÌÌHƒì8Hƒd$ èÍ6 HƒÄ8ÃH‰L$Hìˆ H
áî ÿû¦ L‹ Ìï L‰\$XE3ÀHT$`H‹L$XèKs H‰D$PHƒ|$P tAHÇD$8 HD$HH‰D$0HD$@H‰D$(HŒî H‰D$ L‹L$PL‹D$XH‹T$`3Éèùr ë"H‹„$ˆ H‰Xï H„$ˆ HƒÀH‰åî H‹>ï H‰¯í H‹„$ H‰°î dží ÀÇ€í H‹%Ù H‰D$hH‹!Ù H‰D$pÿ¦ ‰ðí ¹ è"( 3Éÿæ¥ H
Ÿ© ÿÑ¥ ƒ=Êí u
¹ èú' ÿ°¥ º ÀH‹Èÿš¥ HĈ ÃÌÌH‰\$H‰l$H‰t$WHƒì HY H‹é¾ H‹ËL‹Æ3Òè«ÑÿÿE3ÛH}AKA·ÃD‰]D‰]D‰] fó«H=¦Ü H+ýŠ ˆHÿÃHƒîuòH º Š9ˆHÿÁHƒêuòH‹\$0H‹l$8H‹t$@HƒÄ _ÃÌÌH‰\$H‰t$WHì€ H‹ Ø H3ÄH‰„$p H‹ñ‹IHT$Pÿ ¥ » …À„= 3ÀHT$pˆÿÀHÿÂ;ÃrõŠD$VÆD$p H|$Vë)¶WD¶ÀD;ÂwA+ÐI‹ÀJLpDB² è½ÐÿÿHƒÇŠ„ÀuÓ‹F ƒd$8 LD$p‰D$0‹FD‹Ë‰D$(H„$p º 3ÉH‰D$ è? ƒd$@ ‹F‹V ‰D$8H„$p ‰\$0H‰D$(LL$pD‹Ã3ɉ\$ èØ; ƒd$@ ‹F‹V ‰D$8H„$p ‰\$0H‰D$(LL$pA¸ 3ɉ\$ è¢; Lœ$p HN 3ÒAöt € Š„p ëAöt€ Š„p ˆ ëÆ HÿÁHÿÂIƒÃHƒëu¿ë?3ÒHN DBŸA@ ƒøw€ B ë Aƒøw€ Bàˆ ëÆ ÿÂHÿÁ;ÓrÇH‹Œ$p H3ÌèÖÕÿÿLœ$€ I‹[I‹s I‹ã_ÃÌH‰\$WHƒì èÝ
H‹ø‹ˆÈ …
šß tHƒ¸À t H‹˜¸ ën¹
è÷øÿÿH‹Ÿ¸ H‰\$0H; _Þ tDH…Ût ðƒÿuHÚ H‹L$0H;ÈtèüóÿÿH‹5Þ H‰‡¸ H‹'Þ H‰D$0ðƒ H‹\$0¹
è“÷ÿÿH…ÛuK èÊ×ÿÿH‹ÃH‹\$8HƒÄ _Ã@SHƒì@‹ÙHL$ 3ÒèÕÿÿƒ%)ï ƒûþu%Çï ÿ”¢ €|$8 tSH‹L$0ƒ¡È ýëEƒûýuÇðî ÿb¢ ëÔƒûüuH‹D$ ÇÔî ‹@뻀|$8 t H‹D$0ƒ È ý‹ÃHƒÄ@[ÃH‰\$UVWATAUHƒì@H‹ÝÔ H3ÄH‰D$8H‹òèIÿÿÿ3Û‹ø;Ãu
H‹Îèüÿÿé L-1Ý ‹ËH‹ëI‹ÅA¼ 98„' AÌIìHƒÀ0ƒùréÿèý „ ÿéý „ø ·Ïÿ³¡ ;Äç HT$ ‹Ïÿ†¡ ;Ã„Æ HN 3ÒA¸ è]Íÿÿ‰~‰^ D9d$ † HD$&8\$&t-8Xt(¶8¶H;ùw+ÏHT7 AÌ€
IÔI+ÌuõHƒÀ8uÓHF ¹þ €IÄI+Ìuõ‹Né¤ t(ƒét ƒé
tA;Ìt‹Ãë¸ ë¸ ë ¸ ë¸ ‰F D‰fë‰^H~·Ã¹ fó«éà 9 Bí …·þÿÿƒÈÿéÖ HN 3ÒA¸ èƒÌÿÿHlm L ÏÛ HíAº MDíI‹ÈA8t18Yt,¶¶A;ÐwLL2 AŠAÔA¶AMÌ;ÐvìHƒÁ8uÏIƒÀMÜM+Ôu»‰~ï¤ D‰ft$ƒïtƒï
t A;üu» ë» ë » ë» ‰^ HVI|í¹ ·HƒÇf‰HƒÂI+ÌuíH‹Îè|úÿÿ3ÀH‹L$8H3ÌèÒÿÿH‹œ$€ HƒÄ@A]A\_^]ÃÌH‹ÄH‰XH‰pH‰xL‰` AUHƒì0‹ùAƒÍÿè H‹ðèüÿÿH‹ž¸ ‹Ïè¾üÿÿD‹à;C„ ¹ è\îÿÿH‹Ø3ÿH;Ç„| H‹–¸ H‹ÈA¸ èY: ‰;H‹ÓA‹ÌèýÿÿD‹è;Ç…$ H‹Ž¸ ðƒÿuH‹Ž¸ L%Ö I;ÌtèüïÿÿëL%Ö H‰ž¸ ðƒö†È … ö Û …ü ¹
èˆôÿÿ‹C‰^ë ‹C‰Yë ‹C ‰Të ‹×‰T$ L«ÿÿƒú}HcÊ·DKfA‰„Hˆ= ÿ‰T$ ëâ‹×‰T$ ú }HcÊŠD Bˆ„ * ÿ‰T$ ëá‰|$ ÿ }HcÏŠ„ Bˆ„0+ ÿlj|$ ëÞH‹kÙ ðƒ ÿuH‹
^Ù I;ÌtèïÿÿH‰ MÙ ðƒ¹
èÃòÿÿë+ƒøÿu&L%Õ I;ÜtH‹ËèäîÿÿèWìÿÿÇ ë3ÿD‹ïA‹ÅH‹\$@H‹t$HH‹|$PL‹d$XHƒÄ0A]ÃHƒì(ƒ=aò u¹ýÿÿÿèñýÿÿÇKò 3ÀHƒÄ(ÃH‰\$H‰t$WHƒì H‹( H‹ÙH…ÀtyH
ÇÞ H;ÁtmH‹ƒ H…Àtaƒ8 u\H‹‹ H…Étƒ9 uè;îÿÿH‹‹( è·= H‹‹ H…Étƒ9 uèîÿÿH‹‹( èM= H‹‹ èîÿÿH‹‹( èõíÿÿH‹ƒ0 H…ÀtGƒ8 uBH‹‹8 Héþ èÑíÿÿH‹‹H ¿€ H+Ïè½íÿÿH‹‹P H+Ïè®íÿÿH‹‹0 è¢íÿÿH‹‹X HtÜ H;Ètƒ¹` uèÕ: H‹‹X èuíÿÿH{X¾ HµØ H9GðtH‹H…Ét
ƒ9 uèMíÿÿHƒø tH‹OH…Ét
ƒ9 uè3íÿÿHƒÇ Hƒîu½H‹ËH‹\$0H‹t$8HƒÄ _éíÿÿÌÌðƒH‹ H…Àtðƒ H‹ H…Àtðƒ H‹ H…Àtðƒ H‹0 H…Àtðƒ HAXA¸ H Ø H9Pðt H‹H…ÒtðƒHƒxø t
H‹PH…ÒtðƒHƒÀ IƒèuÉH‹X ðƒ€` ÃÌÌÌH…É„˜ AƒÉÿðD H‹ H…ÀtðDH‹ H…ÀtðDH‹ H…ÀtðDH‹0 H…ÀtðDHAXA¸ Hf× H9Pðt H‹H…ÒtðD
Hƒxø t
H‹PH…ÒtðD
HƒÀ IƒèuÉH‹X ðDˆ` H‹ÁÃÌÌÌ@SHƒì H‹ÚH…ÒtAH…Ét÷ÿÿL‹àH‹
Èå è/÷ÿÿH‹ØI;Ä‚˜ H‹øI+üLoIƒý‚„ I‹Ìèó9 H‹ðI;ÅsTº H;ÂHBÐHÐH;ÐrI‹Ìè¿àÿÿ3ÛH;Ãuë3ÛHV H;ÖrFI‹Ìè£àÿÿH;Ãt9HÁÿH øH‹ÈèžöÿÿH‰Gå I‹ÎèöÿÿH‰HKèƒöÿÿH‰$å I‹Þë3ÛèÆÿÿH‹ÃH‹\$@H‹t$HH‹|$PHƒÄ A^A]A\ÃÌÌÌHƒì(èïþÿÿH÷ØÀ÷ØÿÈHƒÄ(ÃÌH‰\$WHƒì H —¥ H=¥ ëH‹H…ÀtÿÐHƒÃH;ßríH‹\$0HƒÄ _ÃH‰\$WHƒì H o¥ H=h¥ ëH‹H…ÀtÿÐHƒÃH;ßríH‹\$0HƒÄ _ÃH‰\$WHƒì H Ï ¿
H‹ èªõÿÿH‰HƒÃHƒïuëH‹\$0HƒÄ _ÃÌÌH‹Á¹MZ f9t3ÀÃHcHËÿÿÇ 3ÀH‹\$0H‹t$8HƒÄ _Ãè!ËÿÿH‹Øÿˆ| ‹ÈèÉÊÿÿ‰ëÕèËÿÿH‹Øÿo| ‹Èè°Êÿÿ‰H‹Æë»ÌH‰\$H‰t$WHƒì03ÿH‹ÚH‹ñH…Òt13ÒHGàH÷óI;Às#èÁÊÿÿH!|$ E3ÉE3À3Ò3ÉÇ è×Éÿÿ3Àë=I¯ØH…Étè % H‹øH‹ÓH‹ÎèÃþÿÿH‹ðH…ÀtH;ûsH+ßH 3ÒL‹Ãèá§ÿÿH‹ÆH‹\$@H‹t$HHƒÄ0_ÃÌÌH‰\$WHƒì0ƒÏÿH‹ÙH…Éu#è:ÊÿÿH!\$ E3ÉE3À3Ò3ÉÇ èPÉÿÿ ÇëFöAƒt:è‰ÍÿÿH‹Ë‹øè* H‹ËèÇÇÿÿ‹Èèè( …ÀyƒÏÿëH‹K(H…Ét
èiÌÿÿHƒc( ƒc ‹ÇH‹\$@HƒÄ0_ÃÌÌÌH‰\$H‰L$WHƒì0H‹ÙƒÏÿ3ÀH…É•À…Àu$è¢ÉÿÿÇ Hƒd$ E3ÉE3À3Ò3Éè·Èÿÿ‹Çë&öA@tƒa ëè~¥ÿÿH‹Ëèÿÿÿ‹øH‹Ëèû¥ÿÿ‹ÇH‹\$HHƒÄ0_ÃÌÌH‰\$ UVWATAUAVAW¸0 èÞj H+àH‹„ H3ÄH‰„$ 3í3ÿE‹èL‹âHcÙ‰l$@E…Àu3Àéç H…Òu.èÉÿÿ!8èóÈÿÿH!|$ E3ÉE3À3Ò3ÉÇ è ÈÿÿƒÈÿé´ L‹ûL‹óHÜÌ IÁþAƒç J‹ ðL‰t$PMkÿXAŠt8@ö@Ðþ@€þt@€þu A‹Å÷ШtAöD t
3Ò‹ËDBèš ‹Ëèï÷ÿÿ…À„ñ H|Ì J‹ðAöD€„Ú èSáÿÿ3ÛHT$XH‹ˆÀ HRÌ 9YJ‹ ðI‹ ”ÃÿŽz …À„¤ …Ût @„ö„— ÿkz !|$LI‹Ü‰D$XE…í„w D‹t$X½
@„ö…ƒ H‹T$PŠ E3ö€ù
H-èË H‹TÕ A”ÆAƒ|P t AŠDLˆL$]A¸ ˆD$\AƒdP HT$\ëI¾ÉèË÷ÿÿ…Àt4I‹ÅH+ÃIÄHƒøŽÏ HL$DA¸ H‹Óè5* ƒøÿ„v HÿÃë A¸ H‹ÓHL$Dè* ƒøÿ„U Hƒd$8 Hƒd$0 ‹L$XHD$\LD$DA¹ 3ÒÇD$( HÿÃH‰D$ ÿ#y ‹è…À„ H‹D$PHƒd$ H
Ë H‹ ÁLL$LHT$\I‹ D‹Åÿ¼x …À„B ‹ûA+ü|$@9l$LŒË ½
E…ö„¯ H‹D$PHƒd$ @ˆl$\H
¬Ê LL$LDEôH‹ ÁHT$\I‹ ÿ`x …À„æ ƒ|$L|{ÿD$@ÿÇëe@€þt@€þu·E3öfƒø
f‰D$DA”ÆHƒÃ@€þt@€þu6·L$Dèh& f;D$D…“ ƒÇE…öt‹Íf‰l$DèI& f;D$DuxÿÇÿD$@‹ÃA+ÄA;Å‚þÿÿ‹\$LL‹t$P‹l$@…ÿ…¸ …Û„z ƒû…e èÃÅÿÿÇ èØÅÿÿ‰éØüÿÿŠL‹t$PÿÇJ‹Lõ AˆDLJ‹Dõ AÇDP ‹\$Lë¥ÿôv ‹Øë–‹\$Lë¡H‹É J‹ ðAöD€„Ê 3ÛI‹ì@„ö…Ð E…í„ü S
D‹t$@H´$ 3É‹ÅA+ÄA;Ås&ŠE HÿÅ<
u ˆAÿÆHÿÆHÿÁHÿÁˆHÿÆHùÿ rÐH!\$ H„$ D‹ÆD+ÀHÉ D‰t$@L‹t$PLL$HH”$ J‹ ðI‹ ÿ³v …Àt5|$HH„$ H+ðHcD$HH;ÆŒÅþÿÿ‹Åº
A+ÄA;Å‚Nÿÿÿéþÿÿÿüu ‹Øé þÿÿ@€þ…Ô E…í„" º
D‹t$@H´$ 3É‹ÅA+ÄA;Ås1·E HƒÅfƒø
uf‰AƒÆHƒÆHƒÁHƒÁf‰HƒÆHùþ rÅH!\$ H„$ D‹ÆD+ÀH!È D‰t$@L‹t$PLL$HH”$ J‹ ðI‹ ÿÌu …À„Jÿÿÿ|$HH„$ H+ðHcD$HH;ÆŒÚýÿÿ‹Åº
A+ÄA;Å‚?ÿÿÿéÂýÿÿE…í„N A¸
HL$p3Ò‹ÅA+ÄA;Ås.·E HƒÅfƒø
u fD‰HƒÁHƒÂHƒÂf‰HƒÁHú¨ rÈHƒd$8 Hƒd$0 HD$p+ÈLD$pÇD$(U
‹Á¹éý ™+Â3ÒÑøD‹ÈH„$ H‰D$ ÿ-u D‹ð…À„€ýÿÿ3öH‹D$PHƒd$ HcÎH” E‹ÆH
Ç H‹ ÁLL$HD+ÆI‹ ÿºt …Àt t$HD;ö½ëÿ-t ‹ØD;öÈüÿÿ‹ýA¸
A+üA;ý‚ÿÿÿé¯üÿÿI‹ H!|$ LL$HE‹ÅI‹Ôÿgt …Àt ‹|$H3ÛéüÿÿÿÚs ‹Øé‚üÿÿ‹ËèœÂÿÿé~ùÿÿHhÆ J‹ðAöD@t A€<$„.ùÿÿè4ÂÿÿÇ èIÂÿÿƒ éHùÿÿ+ý‹ÇH‹Œ$ H3Ìèå¥ÿÿH‹œ$ˆ HÄ0 A_A^A]A\_^]ÃÌÌH‰\$H‰t$‰L$WATAUAVAWHƒì0E‹àL‹êHcÙƒûþu èâÁÿÿ3ÿ‰8è¹ÁÿÿÇ ƒÈÿéÔ 3ÿ;ߌ¡ ; ›Å ƒ• H‹óL‹óIÁþL=œÅ ƒæ HköXK‹÷¾L0ƒáu+èŠÁÿÿ‰8ècÁÿÿÇ H‰|$ E3ÉE3À3Ò3ÉèyÀÿÿƒÈÿëm‹Ëèõ% K‹÷öD0tE‹ÄI‹Õ‹ËèÔ÷ÿÿ‹øëèÁÿÿÇ è0Áÿÿ‰8ƒÏÿ‹Ëèd& ‹Çë)èÁÿÿ‰8èôÀÿÿÇ H‰|$ E3ÉE3À3Ò3Éè
ÀÿÿƒÈÿH‹\$hH‹t$pHƒÄ0A_A^A]A\_ÃÌÌÌH‰\$‰L$VWATHƒì0HcùƒÿþuèžÀÿÿÇ ƒÈÿéÙ …Ɉ® ;=‚Ä ƒ¢ H‹ßH‹÷HÁþL%ƒÄ ƒã HkÛXI‹ô¾Lƒáu%èQÀÿÿÇ Hƒd$ E3ÉE3À3Ò3Éèf¿ÿÿƒÈÿëz‹Ïèâ$ I‹ôöDt+‹ÏèK$ H‹Èÿ~r …Àu
ÿtq ‹Øë3Û…ÛtèÀÿÿ‰èî¿ÿÿÇ ƒËÿ‹Ïè>% ‹Ãë#èÕ¿ÿÿÇ Hƒd$ E3ÉE3À3Ò3Éèê¾ÿÿƒÈÿH‹\$`HƒÄ0A\_^ÃÌH‰\$WHƒìPH‹ÚH‹ùH…Éu$莿ÿÿHƒd$ E3ÉE3À3Ò3ÉÇ è£¾ÿÿ3ÀëvH…Òt×H;ÊsòHL$0I‹ÐèP£ÿÿL‹\$8Aƒ{ u€|$H HCÿtHH‹L$@ƒ¡È ýë:HSÿHÿÊH;úw ¶BöD uíH‹ËH+ʃáH+Ù€|$H t H‹L$@ƒ¡È ýHCÿH‹\$`HƒÄP_ÃÌÌE3Àé<ÿÿÿH‰\$H‰l$H‰t$WATAUHƒìPE3íI‹ùI‹ðH‹êH‹ÙM;ÍuI;ÍuI;Õu 3Àë>I;ÍtI;ÕvM;ÍuDˆ)ëèM;Åu?Dˆ)艾ÿÿ» E3ÉE3À3Ò3ɉL‰l$ èž½ÿÿ‹ÃL\$PI‹[ I‹k(I‹s0I‹ãA]A\_ÃH‹”$ HL$0è8¢ÿÿL‹\$8H‹ÕH‹ËE9ku L‹ÏL‹ÆèX D8l$Ht±H‹L$@ƒ¡È ýë£HƒÿÿuŠHÿƈHÿÁA:Åt.Hƒêuëë&ŠHÿƈHÿÁA:Åt HƒêtHƒïuåI;ýuDˆ)HÿÁI;Õ… D8.tHƒÿuYLaÿI‹ôL;ãr¶HT$0è³ÇÿÿA;ÅtHÿÎH;ósæA‹Ä+ƨt*Eˆ,$耽ÿÿº* ‰D8l$Ht H‹L$@ƒ¡È ý‹ÂéóþÿÿHƒÿÿu\HƒývOHt+þH‹þH;ór¶HT$0èMÇÿÿA;ÅtHÿÏH;ûsæ‹Æ+Ǩt Dˆ.D8l$Ht H‹D$@ƒ È ý¸P é˜þÿÿDˆl+ÿëÜDˆ+èõ¼ÿÿ»" E3ÉE3À3Ò3ɉL‰l$ è
¼ÿÿD8l$H„aþÿÿH‹L$@ƒ¡È ýéPþÿÿH‹ÁH+ÃHƒø|YHqþH‹þH;ór¶HT$0èÆÿÿA;ÅtHÿÏH;ûsæ‹Æ+Ǩt+Dˆ.è|¼ÿÿº* ‰D8l$H„ÿÿÿH‹D$@ƒ È ýéóþÿÿD8l$H„ ýÿÿH‹D$@ƒ È ýéýÿÿÌ@UATAUAVAWHƒì`Hl$@H‰]PH‰uXH‰}`H‹n H3ÅH‰ED‹¿ ¾ 3ÿM‹ÙL‰MD‰E D‹ò‰UH‹ÙDnÿD;×uOLax E‹Íº 3ɉ|$(H‰|$ ÿLn ;Çt E‹ÕD‰-²¾ ëÿ m D‹£¾ ƒøxDDÖD‰•¾ L‹]D‹MpD;Ï~5A‹ÉI‹ÃA+Í@88t
IÅ;ÏuñƒÉÿA‹Á+ÁA+ÅA;Á}
DHD‰MpëD‹È‰EpD;Ö„\ D;ׄS E;Õ…€ D‹¥ˆ ‹÷D;çuH‹D‹`÷ M‹ÃA‹ÌÒ‰|$(H‰|$ ƒâAÕÿ„m LcøD;ÿ„< H»ðÿÿÿÿÿÿA¾ÝÝ A½ ~[3ÒHBàI÷÷HƒørLKL?I;Íw.HAH;ÁwH‹ÃHƒàðèZ\ H+àH|$@H…ÿ„å ÇÌÌ ëèîÿÿH‹øH…ÀtD‰0HƒÇH…ÿ„À D‹MpL‹Eº A‹ÌD‰|$(H‰|$ ÿÜl 3É;Á„K ‹U ‰L$(H‰L$ ‹ME‹ÏL‹Çÿ¿l E3ÀHcðA;ð„! D‹U Aºâ
s;‹…€ A;À„ ;ðÿ ‹M‰D$(H‹ExE‹ÏL‹ÇA‹ÒH‰D$ ÿol éÛ A;ð~`3ÒHBàH÷öHƒørQHL6I;Íw*HAH;ÁwH‹ÃHƒàðèW[ H+àH\$@I;Øt ÇÌÌ ëèíÿÿE3ÀH‹ØI;ÀtD‰0HƒÃD‹U ëI‹ØI;Øtn‹ME‹ÏL‹ÇA‹Ò‰t$(H‰\$ ÿâk 3É;Át?‹…€ 3ÒH‰L$8D‹ÎL‹ÃH‰L$0;Áu ‰L$(H‰L$ ë
‰D$(H‹ExH‰D$ A‹Ìÿ/k ‹ðHKðD91uè»ÿÿHOðD91uè»ÿÿ‹ÆéÍ H‹÷L‹çD;÷u H‹D‹pD‰u‹½ˆ …ÿuH‹‹xA‹Îèh D‹èƒøÿu3Àé L‹}xL‹E;Ç„< 3ÛLMp‹Ð‹Ï‰\$(H‰\$ è… H‹ðH;ÃtÉD‹Mp‹U L‹ÀA‹Î‰\$(H‰\$ ÿáj LcÈD‰MD;Ëu‹ûé D;ËA¾ÝÝ ~bI‹ÉIƒùàwYHƒÁHù w4HYH;Ùw
H»ðÿÿÿÿÿÿHƒãðH‹Ãè¾Y H+ãH\$@H…Ût%ÇÌÌ ëè€ëÿÿH‹ØH…ÀtD‰0HƒÃD‹MH…Ûu3ÛëƒMcÁ3ÒH‹ËèK•ÿÿD‹]D‹Mp‹U ‹MD‰\$(L‹ÆH‰\$ ÿ*j ‰E…Àu3ÿë.‹…€ LML‹Ã‰D$(‹×A‹ÍL‰|$ è ‹}L‹à3ÀL;àDøHKðD91u(èó¹ÿÿë!‹…€ D‹Mp‹U ‰D$(A‹ÎL‰|$ ÿÂi ‹ø3ÛH;ótH‹ÎèÁ¹ÿÿL;ãt
M;ütI‹Ì诹ÿÿ‹ÇH‹MH3ÍèñšÿÿH‹]PH‹uXH‹}`He A_A^A]A\]ÃÌÌÌH‰\$H‰t$WHƒìp‹òH‹ÑHL$PI‹ÙA‹øèКÿÿ‹„$¸ D‹œ$À HL$PD‰\$@‰D$8‹„$° ‰D$0H‹„$¨ L‹ËH‰D$(‹„$ D‹Ç‹Ö‰D$ èOúÿÿ€|$h t H‹L$`ƒ¡È ýL\$pI‹[I‹sI‹ã_ÃÌÌD‰L$ UATAUAVAWHƒì@Hl$0H‰]@H‰uHH‰}PH‹’š H3ÅH‰ED‹
,¹ ¿ 3ÛM‹ðD‹úL‹éwD;Ëu=LM Hr D‹Ç‹Ïÿ–h ;Ãt‰=ô¸ ë6ÿ\g D‹
å¸ ƒøxDDÎD‰
׸ D;΄& D;Ë„ D;Ï…C ‹uh;óuI‹E ‹p÷]xD‹MXM‹ÆҋΉ\$(ƒâH‰\$ ×ÿ h LcàD;ã„ A½ÝÝ ~hH¸ðÿÿÿÿÿÿL;àwYKL$Hù w5HAH;Áw
H¸ðÿÿÿÿÿÿHƒàðèçV H+àH|$0H;û„µ ÇÌÌ ëè¥èÿÿH‹øH;Ãt D‰(HƒÇëH‹ûH;û„‹ M‹Ä3ÒH‹ÏMÀèl’ÿÿD‹MXM‹Æº ‹ÎD‰d$(H‰|$ ÿVg ;ÃtL‹M`D‹ÀH‹×A‹ÏÿWg ‹ØHOðD9)uè7·ÿÿ‹Ãéˆ D‹epH‹ûD;ãuI‹E D‹`‹uh;óuI‹E ‹pA‹Ìè" ƒøÿu3ÀëU;Æt$LMXM‹Æ‹Ð‹Î‰\$(H‰\$ èP H‹øH;Ãt×L‹ðH‹E`D‹MXM‹ÆA‹×A‹ÌH‰D$ ÿÁf ‹ðH;ûtH‹Ï誶ÿÿ‹ÆH‹MH3Íèì—ÿÿH‹]@H‹uHH‹}PHeA_A^A]A\]ÃÌÌH‰\$H‰t$WHƒì`‹òH‹ÑHL$@A‹ÙI‹øèÌ—ÿÿ‹„$ D‹œ$¨ HL$@D‰\$8‰D$0‹„$˜ ‰D$(H‹„$ D‹ËL‹Ç‹ÖH‰D$ è.ýÿÿ€|$X t H‹L$Pƒ¡È ýH‹\$pH‹t$xHƒÄ`_ÃÌÌÌÌÌÌÌÌÌÌÌÌÌff „ L‹ÙH+Ñ‚ž IƒøraöÁt6öÁt Š
IÿȈHÿÁöÁtf‹
Iƒèf‰HƒÁöÁt
‹
Iƒè‰HƒÁM‹ÈIÁéuQM‹ÈIÁétH‹
H‰HƒÁIÿÉuðIƒàM…ÀuI‹Ãà @ Š
ˆHÿÁIÿÈuóI‹ÃÃfffffff „ fffffIù sBH‹
L‹T
HƒÁ H‰AàL‰QèH‹D
ðL‹T
øIÿÉH‰AðL‰QøuÔIƒà éqÿÿÿfff „ fHú rµ¸
D
@HÁ€ ÿÈuìHé ¸@ L‹
L‹T
LÃ LÃQL‹L
L‹T
LÃILÃQL‹L
L‹T
(HƒÁ@LÃIàLÃQèL‹L
ðL‹T
øÿÈLÃIðLÃQøuªIè Iø ƒqÿÿÿð€ $ é¹þÿÿffff „ fffffffIÈIƒøraöÁt6öÁt HÿÉŠ
IÿȈöÁtHƒéf‹
Iƒèf‰öÁt
Hƒé‹
Iƒè‰M‹ÈIÁéuPM‹ÈIÁétHƒéH‹
IÿÉH‰uðIƒàM…ÀuI‹Ãà HÿÉŠ
IÿȈuóI‹ÃÃfffffff „ fffffIù sBH‹D
øL‹T
ðHƒé H‰AL‰QH‹D
L‹
IÿÉH‰AL‰uÕIƒà ésÿÿÿffff „ fHú ðÿÿwµ¸ Hé€
D
@ÿÈuìHÁ ¸@ L‹L
øL‹T
ðLÃIøLÃQðL‹L
èL‹T
àLÃIèLÃQàL‹L
ØL‹T
ÐHƒé@LÃILÃQL‹L
L‹
ÿÈLÃILÃuªIè Iø ƒqÿÿÿð€ $ éºþÿÿH…É„à SHƒì H‹ÙH‹Iè’²ÿÿH‹K色ÿÿH‹K耲ÿÿH‹K èw²ÿÿH‹K(èn²ÿÿH‹K0èe²ÿÿH‹ è]²ÿÿH‹K@èT²ÿÿH‹KHèK²ÿÿH‹KPèB²ÿÿH‹KXè9²ÿÿH‹K`è0²ÿÿH‹Khè'²ÿÿH‹K8è ²ÿÿH‹Kpè²ÿÿH‹Kxè ²ÿÿH‹‹€ è ²ÿÿH‹‹ˆ èô±ÿÿH‹‹ èè±ÿÿH‹‹˜ èܱÿÿH‹‹ èбÿÿH‹‹¨ èıÿÿH‹‹° 踱ÿÿH‹‹¸ 謱ÿÿH‹‹À è ±ÿÿH‹‹È è”±ÿÿH‹‹Ð 舱ÿÿH‹‹Ø è|±ÿÿH‹‹à èp±ÿÿH‹‹è èd±ÿÿH‹‹ð èX±ÿÿH‹‹ø èL±ÿÿH‹‹ è@±ÿÿH‹‹ è4±ÿÿH‹‹ è(±ÿÿH‹‹ è ±ÿÿH‹‹ è±ÿÿH‹‹( è±ÿÿH‹‹0 èø°ÿÿH‹‹8 èì°ÿÿH‹‹@ èà°ÿÿH‹‹H èÔ°ÿÿH‹‹P èÈ°ÿÿHƒÄ [ÃÌÌH…ÉtBSHƒì H‹ÙH‹ H;
¡ t袰ÿÿH‹KH;
ÿ tè°ÿÿH‹KH;
õ tè~°ÿÿHƒÄ [ÃH…É„‹ SHƒì H‹ÙH‹IH;
Ô tèU°ÿÿH‹K H;
Ê tèC°ÿÿH‹K(H;
À tè1°ÿÿH‹K0H;
¶ tè °ÿÿH‹K8H;
¬ tè
°ÿÿH‹K@H;
¢ tèû¯ÿÿH‹KHH;
˜ tèé¯ÿÿHƒÄ [ÃÌÌÌ@SHƒì0L‹ÉH…Ét
H…ÒtM…Àu,Dˆè8ÿÿ» Hƒd$ E3ÉE3À3Ò3ɉèL¬ÿÿ‹ÃHƒÄ0[À9 t HÿÁHƒêuòH…ÒuAˆë¿AŠ IÿÀˆHÿÁ„ÀtHƒêuëH…ÒuAˆèÚ¬ÿÿ»" ë 3ÀëµÌÌÌ@SHƒì0M‹ØM…ÉuH…ÉuH…Òu 3Àë?H…ÉtH…ÒtM…ÉuDˆ ëèM…Àu,Dˆè¬ÿÿ» Hƒd$ E3ÉE3À3Ò3ɉ裫ÿÿ‹ÃHƒÄ0[ÃL‹ÑL‹ÂIƒùÿuAŠIÿÃAˆIÿ„Àt,Iƒèuêë$AŠIÿÃAˆIÿ„Àt IƒètIƒéuäM…ÉuEˆ
M…À…fÿÿÿIƒùÿu DˆDÿA@Pë˜Æ è¬ÿÿ»" émÿÿÿÌÌÌ@SHƒì0H…Ét
H…ÒtM…Àu,Dˆè׫ÿÿ» Hƒd$ E3ÉE3À3Ò3ɉèëªÿÿ‹ÃHƒÄ0[ÃL‹ÉAŠ IÿÀAˆIÿÁ„ÀtHƒêuêH…ÒuˆèŽ«ÿÿ»" ëµ3ÀëÊÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌff „ H+ÑL‹ÊöÁtŠBŠ :ÂuVHÿÁ„ÀtWH÷Á uæI» J fâÿfúøwËH‹J‹ H;Âu¿Iºÿþþþþþþ~LÒHƒðÿHƒÁI3ÂI…ÃtÇëHÀHƒØÿÃ3ÀÃfff„Òt'„öt#HÁê„Òt„ötHÁê„Òt„öt Áê„Òt„öu‹3ÀÃHÀHƒØÿÃÌÌÌÌÌÌff „ H+ÑIƒør"öÁtfŠ:
u,HÿÁIÿÈöÁuîM‹ÈIÁéu M…ÀtŠ:
u HÿÁIÿÈuñH3ÀÃÀƒØÿÃIÁét7H‹H;
u[H‹AH;D
uLH‹AH;D
u=H‹AH;D
u.HƒÁ IÿÉuÍIƒà M‹ÈIÁét›H‹H;
uHƒÁIÿÉuîIƒàëƒHƒÁHƒÁHƒÁH‹ HÈHÉH;ÁÀƒØÿÃÌH‰\$WHƒì HcÙA‹øH‰T$8‹Ëèø
Hƒøÿu蹩ÿÿÇ HƒÈÿëW‹T$8LD$H‹
I© H;Ït2è˽ÿÿH…Àt(ÿÐH‹ØH…Àt H‹
1© H;Ït諽ÿÿH…ÀtH‹ËÿÐH‹ØH‹
© è’½ÿÿH…ÀtD‹ÍM‹ÅI‹ÖH‹ËÿÐë3ÀH‹\$pH‹l$xHƒÄ@A^A]A\_^ÃHƒì8…Éx ƒù~
ƒùu‹ø› ë1‹ð› ‰
ê› ë#蛥ÿÿHƒd$ E3ÉE3À3Ò3ÉÇ è°¤ÿÿƒÈÿHƒÄ8ÃHƒì8H…Éu&èj¥ÿÿHƒd$ E3ÉE3À3Ò3ÉÇ è¤ÿÿHƒÈÿëL‹ÁH‹
'¨ 3ÒÿçW HƒÄ8ÃÌ̹ 鶋ÿÿÌÌHì¨ ön˜ t
¹
èŠÂÿÿèõÉÿÿH…Àt
¹ èòÉÿÿöG˜ t_HŒ$Ð ÿGV HL$03ÒA¸˜ èE‚ÿÿH‹„$¨ 3ÉH‰D$@HD$0ÇD$0 @H‰D$ H„$Ð H‰D$(ÿáU HL$ ÿÎU ¹ èhŽÿÿÌÌÌÌH‹ÄH‰XH‰hH‰pH‰x ATAUAVHƒìPL‹òH‹ÑHHÈE‹áM‹èèFˆÿÿM…ítM‰u M…öu*è;¤ÿÿHƒd$ E3ÉE3À3Ò3ÉÇ èP£ÿÿ€|$H éé E…ät Aƒü|ËAƒü$ÅAŠ.L‹D$03ÿI^Aƒ¸ ~LD$0@¶Íº è¾¾ÿÿL‹D$0ëI‹€@ @¶Í·Hƒà…Àt@Š+HÿÃ뾋´$ @€ý-uƒÎë@€ý+u@Š+HÿÃE…äˆS Aƒü„I Aƒü$? E…äu(@€ý0tA¼
ë8€;xt
€;XtA¼ ë&A¼ ë Aƒüu@€ý0u€;xt€;Xu@ŠkHƒÃM‹@ 3ÒƒÈÿA÷ôD‹È@¶ÍE·JAöÀt @¾Íƒé0ëA÷À t,EŸ@¾Í<wƒé ƒÁÉA;ÌsƒÎA;ùr"u;Êv ƒÎM…íuHÿË@öÆuM…íIEÞ3ÿëYA¯üù@Š+HÿÃ둽ÿÿÿ@öÆu @öÆu:‹Æƒàtÿ €w…Àu';ýv#è¢ÿÿÇ " @öÆtƒÏÿë
@ŠÆ$öØÿ÷ßýM…ítI‰] @öÆt÷߀|$H t H‹L$@ƒ¡È ý‹Çë M…ítM‰u @8|$Ht H‹D$@ƒ È ý3ÀL\$PI‹[ I‹k(I‹s0I‹{8I‹ãA^A]A\ÃÌÌHƒì83ÀE‹ÈL‹Â‰D$ H‹Ñ9 u H
2‘ ë3ÉèQýÿÿHƒÄ8ÃH‰\$WHƒì Hcù‹Ïèì HƒøÿtYH‹Ã¥ ¹ ƒÿu @„¸¸ u
;ùu ö@`tè½ ¹ H‹Øè° H;Ãt ‹Ïè¤ H‹Èÿ T …Àu
ÿÍR ‹Øë3Û‹ÏèØ L‹ßH‹ÏHÁùAƒã HS¥ H‹ ÊMkÛXBÆD …Ût ‹Ëèb¡ÿÿƒÈÿë3ÀH‹\$0HƒÄ _ÃH‰\$H‰t$ ‰L$WATAUHƒì0HcÙƒûþu è ¡ÿÿ3ÿ‰8èã ÿÿÇ ƒÈÿéÉ 3ÿ;ߌ– ; Ť ƒŠ H‹óL‹ãIÁüL-Ƥ ƒæ HköXK‹Då ¾L0ƒáu+è³ ÿÿ‰8èŒ ÿÿÇ H‰|$ E3ÉE3À3Ò3É袟ÿÿƒÈÿëa‹Ëè K‹Då öD0t ‹Ëè†þÿÿ‹øëèI ÿÿÇ ƒÏÿ‹Ëè™ ‹Çë)èP ÿÿ‰8è) ÿÿÇ H‰|$ E3ÉE3À3Ò3Éè?ŸÿÿƒÈÿH‹\$`H‹t$hHƒÄ0A]A\_Ã@SHƒì öAƒH‹Ùt"öAt H‹Ièb¢ÿÿc÷ûÿÿ3ÀH‰H‰C‰CHƒÄ [ÃÌHƒìhH‹
„ H3ÄH‰D$Pƒ=“ f‰L$@tfH‹
È“ Hƒùþu èÑ H‹
¶“ Hƒùÿ„¹ Hƒd$ LL$DHT$@A¸ ÿ0R …À…‰ ƒ=’ …ˆ ÿµP ƒøxu}ƒ%•’ ÿûQ Hƒd$8 Hƒd$0 ‹ÈHD$HLD$@A¹ 3ÒÇD$( H‰D$ ÿQ H‹
)“ Hƒùÿt0Hƒd$ LL$DHT$HD‹ÀÿšQ …Àtf‹D$@ëÇ!’ ëí¸ÿÿ H‹L$PH3Ì艂ÿÿHƒÄhÃH‰\$H‰l$H‰t$WHƒìP3íI‹ðH‹úH‹ÙH;ÕtL;Åt
@8*u H;Ítf‰)3ÀH‹\$`H‹l$hH‹t$pHƒÄP_ÃHL$0I‹ÑèJ‚ÿÿL‹\$0A9ku%H;Ýt¶f‰@8l$Ht H‹D$@ƒ È ý¸ 뮶HT$0èÎÿÿ;Å„œ H‹L$0D‹‰ Aƒù~0A;ñ|+‹I‹ÅH;Ý•ÀL‹Çº ‰D$(H‰\$ ÿTP H‹L$0;ÅuHc H;ðr(@8ot"‹ @8l$H„4ÿÿÿH‹L$@ƒ¡È ýé#ÿÿÿè’ÿÿÇ * @8l$Ht H‹D$@ƒ È ýƒÈÿéýþÿÿ‹ÅA¹ H;Ý•ÀAQL‹Ç‰D$(H‹D$0H‰\$ ‹HÿÅO ;Å…ÿÿÿë¤ÌÌÌE3Éé„þÿÿÌÌÌÌÌÌÌÌH‰\$H‰l$H‰t$WHƒì H‹Ú…Éxi;
¡ saHcùH-¡ H‹÷ƒç HÁþHkÿXH‹Dõ Hƒ<ÿu=ƒ=J u'…Étƒét ƒùu¹ôÿÿÿë ¹õÿÿÿë¹öÿÿÿÿ‰O H‹Dõ H‰ 3Àë蟜ÿÿÇ è´œÿÿƒ ƒÈÿH‹\$0H‹l$8H‹t$@HƒÄ _ÃÌH‰\$H‰l$WHƒì …Éxs;
_ skHcÙH-k H‹ûƒã HÁÿHkÛXH‹Dý öDtGHƒ<ÿt@ƒ=›€ u)…Étƒét ƒùu¹ôÿÿÿë ¹õÿÿÿë¹öÿÿÿ3ÒÿØN H‹Dý Hƒ ÿ3Àëèí›ÿÿÇ èœÿÿƒ ƒÈÿH‹\$0H‹l$8HƒÄ _ÃHƒì8ƒùþuèÞ›ÿÿƒ 趛ÿÿÇ ë]…Éx1;
¤Ÿ s)HcÑH
°Ÿ H‹Âƒâ HÁøHkÒXH‹ÁöDtH‹ë,è”›ÿÿƒ èl›ÿÿHƒd$ E3ÉE3À3Ò3ÉÇ èšÿÿHƒÈÿHƒÄ8ÃH‹ÄH‰XH‰pH‰xL‰` AUHƒì HcÙL‹ãIÁüL-6Ÿ ƒã HkÛXK‹tå ¿ ƒ|3 u3O èJ¢ÿÿƒ|3 uHL3º èoÂÿÿ÷ØÒ#úÿD3 ¹
è ¡ÿÿ…ÿtK‹Lå HLÿ‡K ‹ÇH‹\$0H‹t$8H‹|$@L‹d$HHƒÄ A]ÃÌÌHcÑH
®ž H‹Âƒâ HÁøHkÒXH‹ÁHLHÿ%HK H‰\$H‰|$L‰d$AUAVAWHƒì@IƒÌÿE‹ìE3öAL$ è¯ ÿÿ…ÀuA‹ÄéÉ ¹ è¡ÿÿ3ÿ‰|$$H?ž ƒÿ@› LcÿJ‹ øH…Û„ H‰\$0J‹øH H;ØƒÍ öC…ª ƒ{ u;¹
è(¡ÿÿƒ{ u HKº èOÁÿÿ…Àu DpD‰t$(ëÿC ¹
è÷ŸÿÿE…öu HKÿdJ öCt HKÿ\J ëHIƒÌÿE…öu?ÆCL‰#L‹ K+ øH¸£‹.ºè¢‹.H÷ëL‹êIÁýI‹ÅHÁè?Lè‹ÇÁàDèD‰l$ ëHƒÃXH‰\$0IƒÌÿHF é ÿÿÿE;ì… ÿlj|$$H+ éçþÿÿºX JÈèõ™ÿÿH‰D$0H…ÀttHc×L I‰Ðƒâœ I‹ ÐHÁ H;ÁsÆ@ L‰ Æ@
ƒ` HƒÀXH‰D$0ëÖÁç‰|$ HcÏH‹ÁHÁøƒá HkÉXI‹ÀÆD‹ÏèHýÿÿ…ÀADüD‹ï‰|$ ¹ èÅžÿÿA‹ÅH‹\$`H‹|$hL‹d$pHƒÄ@A_A^A]ÃHƒì8H‹©| H3ÄH‰D$(LD$ A¹ º ÆD$& ÿÎJ …ÀuƒÈÿë
HL$ è› H‹L$(H3Ìèæ{ÿÿHƒÄ8ÃÌ@USVWATAUAVAWHìˆ Hl$@H‹@| H3ÅH‰E0L‹µ° E‹!3ÿI‹ØH‹÷‰} L‰MD‹êD‹ùH‰];Ê„ HUÿ4I ;Ç„Ÿ ƒ}…• HUA‹ÍÿI ;Ç„€ ƒ}uzÇE Aƒüÿt`A‹ü…ÿŽ© HcÏH¸ðÿÿÿÿÿÿH;ȇ“ HL Hù wlHAH;Áw
H¸ðÿÿÿÿÿÿHƒàðèÏ8 H+àH\$@H…Ût<ÇÌÌ ëNH‹Ëè¢Çÿÿxë–E‹ÌL‹Ãº A‹Ï‰|$(H‰|$ ÿhI ‹ø…À…oÿÿÿ3Àé7 èVÊÿÿH‹ØH…ÀtÇ ÝÝ HƒÃë3ÛH…ÛtÙLcÇ3ÒH‹ËMÀè tÿÿL‹EE‹Ìº A‹Ï‰|$(H‰\$ ÿ I E3ÿA;Ç„É M;÷t;‹…¸ L‰|$8L‰|$0‰D$(D‹ÏL‹Ã3ÒA‹ÍL‰t$ ÿfH A;Ç„‘ I‹öé‰ D9} u,L‰|$8L‰|$0D‹ÏL‹Ã3ÒA‹ÍD‰|$(L‰|$ ÿ*H ‹øA;ÇtWHc×¹ èò–ÿÿH‹ðI;ÇtBL‰|$8L‰|$0D‹ÏL‹Ã3ÒA‹Í‰|$(H‰D$ ÿêG A;Çu
H‹ÎèM˜ÿÿI‹÷ë AƒüÿtH‹M‰HKð9ÝÝ uè+˜ÿÿH‹ÆH‹M0H3ÍèlyÿÿHeHA_A^A]A\_^[]ÃÌÌÌ3ÒDB
éyóÿÿÌL‹ÑM…Àt ‹W‘ A» ƒøxADÓD‹U ‰@‘ D‹ D;Ë~YA‹ÉI‹ÇA+̃Îÿ8t IÄ;Ëuï‹Î‹Æ+ÁDÈD‰ D‹…° D;Ã~5A‹ÈH‹ÇA+Ì8t IÄ;Ëuò‹Î‹Æ+ÁDÀD‰…° ëƒÎÿD;Î}Æ3Àé¥ D;Æ|ôA;Ó„¯ ;Ó„§ A;ÔuÞD‹¸ D;ëuI‹D‹iD;Ët D;Ã…« E;ÈuA‹Ãé\ E;Ä~A‹ÄéO E;Ì~
¸ é@ HUA‹Íÿî= ;ÃtƒD‹ D;Ë~2ƒ}rÓ8]HEtÊ8XtÅAŠ:r:HvHƒÀ8ëå¸ éñ 9° ~+ƒ}rŒ8]HEtƒ8X„zÿÿÿŠ:r:HvËHƒÀ8ëâM‹Çº A‹Í‰\$(H‰\$ ÿW> LcðD;ó„ìþÿÿI¸ðÿÿÿÿÿÿ~d3ÒHBàI÷öHƒørUKL6Hù w.HAH;ÁwI‹ÀHƒàðè5- H+àHt$0H;ó„þÿÿÇÌÌ ëèó¾ÿÿH‹ðH;ÃtÇ ÝÝ HƒÆëH‹óH;ó„pþÿÿD‹ M‹ÇA‹ÔA‹ÍD‰t$(H‰t$ ÿ¯= ;Äô D‹° L‹Çº A‹Í‰\$(H‰\$ ÿ†= LcàD;ã„Ç ~g3ÒHBàI÷ôHƒørXKL$Hù w1HAH;Áw
H¸ðÿÿÿÿÿÿHƒàðèg, H+àH|$0H;ûtÇÌÌ ëè)¾ÿÿH‹øH;ÃtÇ ÝÝ HƒÇëH‹ûH;ûtVD‹° L‹Eº A‹ÍD‰d$(H‰|$ ÿæ< ;Ãt ‹U‹M E‹ÎL‹ÆD‰d$(H‰|$ ÿ6= ‹ØHOð9ÝÝ u軌ÿÿHNð9ÝÝ u誌ÿÿ‹Ãéè H‹ûL‹ëD;Óu I‹D‹PD‰U D‹¥¸ D;ãuI‹D‹`A‹ÊèŽñÿÿD‹ð;Æ„ ýÿÿA;ÄteL M‹Ç‹ÐA‹Ì‰\$(H‰\$ èµñÿÿH‹øH;ÄÒüÿÿL‹EL° A‹ÖA‹Ì‰\$(H‰\$ èŠñÿÿL‹èH;Ãu
H‹Ïè
ŒÿÿéžüÿÿL‹ÿL‹ÀëL‹E‹…° D‹ ‹U‹M ‰D$(L‰D$ M‹Çÿ4< ‹ðH;ûtH‹ÏèÅ‹ÿÿI‹Í轋ÿÿ‹ÆH‹M(H3ÍèÿlÿÿHe8A_A^A]A\_^[]ÃÌÌH‰\$H‰t$WHƒì`‹òH‹ÑHL$@I‹ÙA‹øèèlÿÿD‹œ$¨ ‹„$ HL$@D‰\$8‰D$0H‹„$˜ H‰D$(‹„$ L‹ËD‹Ç‹Ö‰D$ è¾úÿÿ€|$X t H‹L$Pƒ¡È ýH‹\$pH‹t$xHƒÄ`_ÃÌÌÌH‰\$H‰t$WHƒì`H‹ñH‹úHL$@I‹ÑI‹Øè[lÿÿH…Ûu8\$Xt H‹D$Pƒ È ý3Àé H…öu=è;ˆÿÿHƒd$ E3ÉE3À3Ò3ÉÇ èP‡ÿÿ€|$X t H‹D$Pƒ È ý¸ÿÿÿé€ H…ÿt¾HûÿÿÿwµH‹D$@‹P…ÒuLL$@L‹ÃH‹×H‹Îèªòÿÿë>‹@HL$@L‹Î‰D$8‰\$0A¸ H‰|$(‰\$ è™þÿÿ…Àu複ÿÿÇ éyÿÿÿƒÀþ€|$X t H‹L$Pƒ¡È ýH‹\$pH‹t$xHƒÄ`_ÃÌÌÌH‰\$‰T$UVWATAUAVAWHƒì0E3í‹êL‹ñA‹ÝI;Íu$èC‡ÿÿE3ÉE3À3Ò3ÉL‰l$ Ç èY†ÿÿéê L‹!M;å„Ó º= I‹Ìè³ H‹øH‰D$pI;Å„µ L;à„¬ D8hH‹5Þ| E‹ýA”ÇH;5Ø| upH‹îA‹ÅI;õu I‹õëUHƒÆÿÀL9.uõÿÀº HcÈè ‡ÿÿH‹øH‹ðI;Åu ¹ è'mÿÿëH‹ÈèÍ H‰HƒÇHƒÅH‹E I;ÅuäL‰/H‹|$p‹l$xH‰5^| I;õ…‰ A;ít9L9-Y| t0èf÷ÿÿA;Åtjè@†ÿÿÇ ƒÈÿH‹œ$€ HƒÄ0A_A^A]A\_^]ÃE;ýt3Àëß¹ 蔆ÿÿH‰ý{ I;ÅtÆL‰(L9-þ{ u¹ èr†ÿÿH‰ë{ I;Åt¤L‰(H‹5Ì{ H‹îI;õt’H‹‹ÇH‹þA+ÄLcèH…Ét?H‹ÑM‹ÅI‹Ìè¿öÿÿ…ÀuH‹A€| =„¢ A8\ „— HƒÇH‹H…ÉuÈH‹5r{ H+þHÁÿ÷ßE3íA;ýŒŒ L9m „‚ Hc÷H‹Lõ èÖ‡ÿÿE;ýtfL9lõ t HLõH‹ÿÇHƒÁH‰Dõ HÿÆL9lõ uèHc×H¸ÿÿÿÿÿÿÿ H;Ѓ“ H‹
{ A¸ èý†ÿÿI;Åt|ësH‹5çz H+þHÁÿérÿÿÿL‰dõ M‰.ë]E;ý… A;ý}÷ßG;ÇŒ„þÿÿLcÀH¸ÿÿÿÿÿÿÿ L;Àƒnþÿÿº H‹Î蛆ÿÿI;Å„XþÿÿHcÏL‰$ÈL‰lÈM‰.H‰tz D9l$x„Š I‹Ìèµÿÿº HHèO…ÿÿH‹øI;ÅtlI‹Ìèã´ÿÿM‹ÄH‹ÏHPèHØÿÿA;ÅtE3ÉE3À3Ò3ÉL‰l$ è+‚ÿÿH‹×H‹ÏI+ÔHT$pDˆ*HÿÂE;ýIEÕÿú6 A;ÅuƒËÿèõƒÿÿÇ * H‹Ïèo†ÿÿE;ýt I‹Ìèb†ÿÿM‰.‹Ãé™ýÿÿI‹ÌèP†ÿÿM‰.é¦ýÿÿH‰\$H‰t$WHƒì0H‹ÙH…ÉtFè<´ÿÿH‹ðHHè ·ÿÿH‹øH…Àt-HVL‹ÃH‹Èè×ÿÿ…ÀtHƒd$ E3ÉE3À3Ò3ÉèpÿÿH‹Çë3ÀH‹\$@H‹t$HHƒÄ0_ÃÌH‰\$H‰t$WHƒìPH‹Ù‹úHL$0I‹Ðè'gÿÿ3öH;ÞuDè#ƒÿÿE3ÉE3À3Ò3ÉH‰t$ Ç è9‚ÿÿ@8t$Ht H‹D$@ƒ È ý3ÀH‹\$`H‹t$hHƒÄP_ÃH‹T$89ru ‹×H‹Ëè€ @8t$HtÕH‹L$@ƒ¡È ýëǶ f;Ît3¶ÁöD t HÿÃ@83t˜¶·ÉÁá È;ùu
HCÿë¼·Á;øtHÿÃëÅ·Á;ø…lÿÿÿ@8t$Ht H‹D$@ƒ È ýH‹ÃéfÿÿÿÌÌE3Àé ÿÿÿë:Ât
HÿÁŠ„Àuó:ÂuH‹ÁÃ3ÀÃÿ%03 ÿ%‚3 ÿ%„3 Hƒì8H…Éu&è‚ÿÿHƒd$ E3ÉE3À3Ò3ÉÇ è+ÿÿHƒÈÿë €9 tÕH…ÒtÐH‹H…ÀtÈ€8 tÃE3Àè‚ HƒÄ8ÃÌH‰T$‰L$SUVWATAUAVAWHƒìXA¼þÿÿÿHcÁA‹ØD‰d$4‰\$8A;Äuè¸ÿÿ3ÿ‰8èÿÿÇ é 3ÿ;ÇŒï ;t… ƒã H‹ðL‹ðL
ùAÿÿIÁþƒæ K‹Œñ€C HköXŠD1¨„· ûÿÿÿvèUÿÿ‰8è.ÿÿÇ éª ‹ï;ß„Š ¨…‚ H;×tÒDŠ|18A¸ EÿAÐÿA¾Ïƒétƒéu ‹Ã÷Шt«ƒãþL‹êëd‹Ã÷Шt›ÑëA;ØABØ‹ËèMÿÿL‹èH;Çu踀ÿÿÇ èÍ€ÿÿÇ é= ‹Œ$ 3ÒDBè°ÖÿÿL
!AÿÿL‹ØK‹„ñ€C L‰\0@K‹„ñ€C I‹ÕA¸
öD0H„œ ŠL0 A:È„ ;ß„‡ AˆM K‹„ñ€C AƒÊÿAÚIUAh÷DˆD0 D:ÿtbK‹„ñ€C ŠL09A:ÈtQ;ßtMˆ
K‹„ñ€C AÚHÿÂAhøDˆD09A€ÿu.K‹„ñ€C ŠL0:A:Èt ;ßtˆ
K‹„ñ€C HÿÂAhùAÚDˆD0:K‹Œñ€C LL$0D‹ÃH‹ 1H‰|$ ÿ¢2 ;Ç„Ï HcT$0;׌ ‹ÃH;Ї· L@ÿÿêK‹„ð€C öD0€„y A€ÿ„¸ ;×tA€}
u€L0ë€d0ûHcÅI‹ÝM‹åIÅH‰D$@L;èƒ: ½
AŠ$<„
@:Åt
ˆHÿÃIÿÄéë H‹D$@HÿÈL;àsID$€8
u IƒÄé L‹àé½ K‹Œð€C LL$0H”$° H‹ 1A¸ IÿÄH‰|$ ÿ³1 ;Çu
ÿ0 ;Çu{9|$0tuL0?ÿÿK‹„ð€C öD0Ht"€¼$°
t'@ˆ+K‹Œð€C Š„$° ˆD1 ëGI;Ýu€¼$°
uÆ
ë3‹Œ$ A¸ HƒÊÿè]Ôÿÿ€¼$°
LÆ>ÿÿtëL»>ÿÿ@ˆ+HÿÃL;d$@‚ìþÿÿë K‹„ð€C öD0@u€L0ë AŠ$ˆHÿËëA+íA€ÿ…ð ;ï„è A¿ I+ßö€uIßé² A‹×ëƒúI;ÝrI+ßA׶B8¼ 4 t㶠B¾„4 ;Çuè}ÿÿÇ * AƒÌÿé‘ ÿÀ;ÂuHcÂHØë^K‹„ð€C öD0Ht;I߃úˆL0 |ŠK‹Œð€C I߈D19ƒúuŠK‹Œð€C I߈D1:HcÂH+Øë‹Œ$ ÷ÚE‹ÇHcÒè2Óÿÿ‹D$8L‹¼$¨ A+ÝÑèD‹ËM‹Å‰D$(3Ò¹éý L‰|$ ÿe/ ‹è;ÇuÿI. ‹Èè}ÿÿAƒÌÿéä D‹d$4;ÃHS=ÿÿJ‹„ð€C @•Çí‰|0Hé¿ ;׺
tfA9U u€L0ë€d0ûHcÅI‹ÝM‹åN<(M;ïƒ{ ½
A·$fƒø„E f;Åtf‰HƒÃIƒÄé% IGþL;àsID$f9u IƒÄé L‹àéú K‹Œð€C LL$0H”$¸ H‹ 1A¸ IƒÄH‰|$ ÿ÷. ;Çuÿ]- ;Ç…® 9|$0„¤ Ll<ÿÿK‹„ð€C öD0HtFº
f9”$¸ tKf‰+Š„$¸ K‹Œð€C ˆD1 Š„$¹ K‹Œð€C ˆD19K‹„ð€C ˆT0:ëWI;Ýuº
f9”$¸ uf‰ë>‹Œ$ HÇÂþÿÿÿDBèoÑÿÿº
LÛ;ÿÿf9”$¸ të º
LÃ;ÿÿf‰+HƒÃM;ç‚®þÿÿë"K‹„ð€C öD0@u€L0ë A·$f‰HƒÃ‹ëA+íD‹d$4L‹¼$¨ M;ïtI‹Íè`}ÿÿAƒüþDDåA‹Äëiÿ5, ƒøuè»zÿÿÇ èÐzÿÿÇ é ýÿÿƒømuD‹ç뮋ÈèÔzÿÿéýÿÿ3Àë)è¦zÿÿ‰8èzÿÿÇ E3ÉE3À3Ò3ÉH‰|$ è•yÿÿƒÈÿHƒÄXA_A^A]A\_^][ÃÌH‰\$H‰t$‰L$WATAUAVAWHƒì0A‹ðL‹êHcùƒÿþu èBzÿÿ3Û‰èzÿÿÇ ƒÈÿé 3Û;ûŒâ ;=û} ƒÖ L‹çL‹÷IÁþL=ü} Aƒä MkäXK‹÷B¾L ƒáu.èèyÿÿ‰èÁyÿÿÇ H‰\$ E3ÉE3À3Ò3Éè×xÿÿƒÈÿé© ‹ÃAøÿÿÿ–À;Ãu+èªyÿÿ‰èƒyÿÿÇ H‰\$ E3ÉE3À3Ò3Éè™xÿÿƒÈÿën‹ÏèÞÿÿK‹÷BöD tD‹ÆI‹Õ‹Ïès÷ÿÿ‹Øëè:yÿÿÇ èOyÿÿ‰ƒËÿ‹ÏèƒÞÿÿ‹Ãë)è:yÿÿ‰èyÿÿÇ H‰\$ E3ÉE3À3Ò3Éè)xÿÿƒÈÿH‹\$hH‹t$pHƒÄ0A_A^A]A\_ÃÌÌH‹ÄH‰XL‰@H‰HUVWATAUAVAWHì€ 3ÿA´€A‹ñH‹ÚÇ@¨ o‰xœ@ˆ¼$Ø H‰x°E„Ìt‰x¸A¶ë‰l$pDŠ÷HL$Tè© ;ÇtE3ÉE3À3Ò3ÉH‰|$ èivÿÿºær÷Æ @ u
|$T € tE
ô‹ÎA¸ ¸ ÀA#Ⱥ €;ÏtT+Ít:;Ít1è@xÿÿ‰8ƒ ÿèxÿÿ» E3ÉE3À3Ò3ÉH‰|$ ‰è+wÿÿ‹Ãéû D‹øë@öÆt÷Æ uíA¿ @ëD‹ú‹Œ$à A¼ ƒét,ƒét#ƒétƒétƒù@u‹D;ú‹Ï”ÁëA‹Èë A‹Ìë‹Íë‹Ï‹Æº ‰L$H#ÂtF= t8= t*= t = t*= t&= t;Âté/ÿÿÿA‹ìë½ ë
½ ëA‹èºæA½€ D‰l$Ps Šm öÐ"„$è ¨€AEDDèD‰l$P@öÆ@tAºíAºïƒÉD‰l$P‰L$Hºæ s
AºíD‰l$P@öÆ tAºíë @öÆt
Aºí D‰l$PèIÜÿÿ‰ƒøÿu!èÕvÿÿ‰8ƒ ÿè«vÿÿÇ è vÿÿ‹ é H‹„$À D‹D$HH‹Œ$Ð H‰|$0LL$`A‹×D‰l$(Ç ‰l$ ÿB) H‰D$XHƒøÿ…Œ ¹ ÀA‹Ç#Á;ÁuC¸ @„ðt9D‹D$HH‹Œ$Ð H‰|$0Aº÷ LL$`D‰l$(A‹×‰l$ ÿí( H‰D$XHƒøÿu;Hc L-z H‹Áƒá HÁøHkÉXI‹DÅ €dþÿJ' ‹ÈèvÿÿèÎuÿÿ‹8éÌ H‹ÈÿÖ& ;ÇuMHc L-Èy H‹Áƒá HÁøHkÉXI‹DÅ €dþÿ' ‹È‹ØèÉuÿÿH‹L$Xÿ6( ;ßu§èuuÿÿÇ
ëšA;ÄuA€Î@ë ƒøuA€ÎH‹T$X‹ è%ØÿÿHc L-[y H‹Áƒá º HÁøD
òI‹DÅ HkÉXDˆtHc H‹Áƒá HÁøHkÉXI‹DÅ €d8€AŠÆ$HˆD$L…† E„ö‰Â A„ôtx‹ E‹ÄƒÊÿè¦ ‰D$Dƒøÿuèðtÿÿ8ƒ tP‹ èõÒÿÿééþÿÿ‹ HT$@A¸ @ˆ|$@èÕòÿÿ;Çu€|$@uHcT$D‹ è¾ ƒøÿtÁ‹ E3À3ÒèE ƒøÿt°º E„ö‰< ¹ @ …ñu‹D$T#Áuºîë ð‹Æ#Á= @ tJ= t,= @ t%= t+= @ t$= t= @ u(ˆ”$Ø ë ¹ ‹Æ#Á;ÁuDˆ¤$Ø ë@ˆ¼$Ø ÷Æ „º ‰|$DAöÆ@…¬ A‹Ç% À= @„$ = €t|= À…‡ ;ï† A;ìvƒýv8ƒý…l ¾Œ$Ø A¸ ‹ïA+È„ A;È…P ÇD$Dÿþ é ‹ E‹Ä3ÒèÉÿÿH;ÇtÀ‹ E3À3ÒènÉÿÿHƒøÿ„|þÿÿ‹ HT$DA¸ èbñÿÿƒøÿ„aþÿÿA;Ät ƒøuk|$D uD@þDˆ„$Ø éÜ ·D$D=þÿ u‹ è%Ñÿÿèìrÿÿ» ‰‹ûéã =ÿþ u#‹ E3ÀA‹Ôè’ ƒøÿ„ùýÿÿDˆ¤$Ø é† ‹ E3À3Òèp ƒøÿë;;ïvqA;ì†üþÿÿƒý‡êþÿÿ‹ E‹Ä3Òè¡ÈÿÿH;Ç„Þþÿÿ‹ E3À3ÒèŒÈÿÿHƒøÿu8é™ýÿÿÇD$D A¼ ‹ HcÅE‹ÄHTDD+ÅèN°ÿÿƒøÿ„mýÿÿèD;åÛA¸ Hc @Š¬$Ø H‹Áƒá @€åHÁøHkÉXI‹DÅ €d8€@l8HcH‹Âƒâ HÁøHkÒXI‹LÅ ‹Æ€d8ÁèÀàD8@8|$Lu!@öÆtHc H‹Áƒá HÁøHkÉXI‹DÅ €L A‹Ç% À= À…Ÿ A„ð„– H‹L$Xÿ>$ ‹D$PD‹D$HH‹Œ$Ð H‰|$0‰D$(Aº÷ LL$`ÇD$ A‹×ÿ1$ Hƒøÿu6ÿµ" ‹Èè~qÿÿLcI‹ÃAƒã HÁøMkÛXI‹DÅ B€dþ‹ è¢ÔÿÿéBûÿÿHcH‹Êƒâ HÁùHkÒXI‹LÍ H‰
‹ÇH‹œ$È HÄ€ A_A^A]A\_^]ÃÌÌH‹Ä‰PL‰@L‰H VWHƒìXƒHØÿƒ`Ü E3ÀH…ÉA•ÀE…Àu(è¬pÿÿÇ Hƒd$ E3ÉE3À3Ò3ÉèÁoÿÿƒÈÿé“ H„$€ HƒÀD‹@øƒd$0 D‰D$(ÇD$ @ D‹ÊL‹ÁHT$@HL$Dèv÷ÿÿ‹ð‰D$Hƒ|$D t9…Àt(Hc|$@H‹ÏH‹ÇHÁøLCt ƒá HkÉXI‹À€dþë‹|$@‹ÏènÕÿÿë‹|$@…öt èÿoÿÿ‰0ƒÈÿë‹ÇHƒÄX_^ÃÌÌÌ@SHƒì0M‹ÐH‹ÂH‹ÙH…Éu&èÓoÿÿHƒd$ E3ÉE3À3Ò3ÉÇ èènÿÿHƒÈÿëUH…ÀtÕH‰L$ LL$XLD$@I‹ÒH‹ÈèÏ ƒøÿtÖL‹L$XL‹D$@H‹Ó¹ èç H‹L$@H‹ØèòqÿÿH‹L$XèèqÿÿH‹ÃHƒÄ0[ÃÌÌÌH‰\$L‰D$UVWATAUAVAWHƒì0E3öM‹àL‹êH‹éH‹ñI;Îu(è"oÿÿE3ÉE3À3Ò3ÉL‰t$ Ç è8nÿÿHƒÈÿé D81tÓI;ÖtÎH‹I;ÆtÆD80tÁº\ èv º/ H‹ÍH‹øèf A¿ I;Æ…œ I;þ… AW9H‹ÍèRìÿÿH‹øI;Æ…ˆ H‹Íè.ŸÿÿI‹×HXH‹Ëè{oÿÿH‹ðI;Æ„sÿÿÿLL5 H‹ÓH‹ÈèuÂÿÿA;ÆtE3ÉE3À3Ò3ÉL‰t$ èXlÿÿL‹ÅH‹ÓH‹ÎèêÀÿÿA;ÆtE3ÉE3À3Ò3ÉL‰t$ è1lÿÿH~ë
I;þtH;ÇvH‹øHƒËÿH‹ÏS/èŸ
H‹ÎI;Æt&3Òè A;Æ…÷ M‹ÄI‹ÕH‹ÎèõýÿÿH‹Øéá èlžÿÿI‹×L`I‹Ìè¹nÿÿH‹øI;Æ„Î L‹ÆI‹ÔH‹Èè·ÁÿÿA;ÆtE3ÉE3À3Ò3ÉL‰t$ èškÿÿH‹Îè"žÿÿL4èmÿÿM+æD‹8I Z x Œ º Î Þ ê ö * : J X f p € – ¢ ® ¾ æ 2 H b x † ° Æ à î þ $ 4 J Z l ~ ¢ ® ¼ Ì â ò " 4 \ h x Š h @ ?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ = runtime error
TLOSS error
SING error
DOMAIN error
R6034
An application has made an attempt to load the C runtime library incorrectly.
Please contact the application's support team for more information.
R6033
- Attempt to use MSIL code from this assembly during native code initialization
This indicates a bug in your application. It is most likely the result of calling an MSIL-compiled (/clr) function from a native constructor or from DllMain.
R6032
- not enough space for locale information
R6031
- Attempt to initialize the CRT more than once.
This indicates a bug in your application.
R6030
- CRT not initialized
R6028
- unable to initialize heap
R6027
- not enough space for lowio initialization
R6026
- not enough space for stdio initialization
R6025
- pure virtual function call
R6024
- not enough space for _onexit/atexit table
R6019
- unable to open console device
R6018
- unexpected heap error
R6017
- unexpected multithread lock error
R6016
- not enough space for thread data
This application has requested the Runtime to terminate it in an unusual way.
Please contact the application's support team for more information.
R6009
- not enough space for environment
R6008
- not enough space for arguments
R6002
- floating point support not loaded
Microsoft Visual C++ Runtime Library
... Runtime Error!
Program: À À – À À Ž À À À ‘ À ’ À “ À €€†€€ †€†‚€EEE……… 00€P€ˆ ('8PW€ 700PPˆ (€ˆ€€ `h`hhhxppwpp ( ( ( ( ( H „ „ „ „ „ „ „ „ „ „ ‚ ‚ ‚ ‚ ‚ ‚ h ( ( ( ( H „ „ „ „ „ „ „ „ „ „ ‚‚‚‚‚‚ H €‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ ¡¢£¤¥¦§¨©ª«¬®¯°±²³´µ¶·¸¹º»¼½¾¿ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖ×ØÙÚÛÜÝÞßàáâãäåæçèéêëìíîïðñòóôõö÷øùúûüýþÿ
!"#$%&'()*+,-./0123456789:;<=>?@abcdefghijklmnopqrstuvwxyz[\]^_`abcdefghijklmnopqrstuvwxyz{|}~€‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ ¡¢£¤¥¦§¨©ª«¬®¯°±²³´µ¶·¸¹º»¼½¾¿ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖ×ØÙÚÛÜÝÞßàáâãäåæçèéêëìíîïðñòóôõö÷øùúûüýþÿ€‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ ¡¢£¤¥¦§¨©ª«¬®¯°±²³´µ¶·¸¹º»¼½¾¿ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖ×ØÙÚÛÜÝÞßàáâãäåæçèéêëìíîïðñòóôõö÷øùúûüýþÿ
!"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`ABCDEFGHIJKLMNOPQRSTUVWXYZ{|}~€‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ ¡¢£¤¥¦§¨©ª«¬®¯°±²³´µ¶·¸¹º»¼½¾¿ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖ×ØÙÚÛÜÝÞßàáâãäåæçèéêëìíîïðñòóôõö÷øùúûüýþÿHH:mm:ss dddd, MMMM dd, yyyy MM/dd/yy PM AM December November October September August July June April March February January Dec Nov Oct Sep Aug Jul Jun May Apr Mar Feb Jan Saturday Friday Thursday Wednesday Tuesday Monday Sunday Sat Fri Thu Wed Tue Mon Sun GetProcessWindowStation GetUserObjectInformationA GetLastActivePopup GetActiveWindow MessageBoxA USER32.DLL SunMonTueWedThuFriSat JanFebMarAprMayJunJulAugSepOctNovDec CONOUT$ .com .exe .bat .cmd .\ SystemRoot t d
T 4 2àÐÀ
4
Œ p ¨ P
4
p
d
T 4 2ÐÀp! ð Ú < ! Ú ® ( ! ÔH ÄI Ú ® ( ! ÔH ÄI dJ Ú ® ( ! TR ð Ú < K ðàp0¨ 0 bÀp`0 Œ+ | I `á
4 RðàÐÀ
p ` P r0 ²0 20 4 2 p
d 4 rðàÐÀpŒ+ ã' ì( xá
4
RpŒ+ ·* S+ šá S+ B d T 4 r ðàÐÀp t 4 2 À 20 d T 4 2p) 4d Z ðà Ð
Àp`P ¨ È
Ä t d 4 ðàÐ Œ+ `: l: = ¼ 0
t d T 4 2À
20 d 4 R ÀŒ+ KB ÃB ¶á
Ä t d
RðàÐŒ+ D MD Ïá ÎC jD ÿá t d 4 2À d T 4 2p t d 4 2ÐŒ+ OF F â
4
Rp d
T 4 Rp d 4
r p $ d´ 4³ ° p ¨ p
4
2pŒ+ ¾M N 4â 4 r Ð
Àp`P¨ 8
Ä t
d 4 RÐŒ+ -R çR 4â 20Œ+ ·V ÍV Mâ
4
2pŒ+ ŠW •W fâ ªW ÑW †â 4 2pŒ+ .Y \Y fâ qY ¨Y †â d T ² p d T 4 2p Ô t
4 Rà
t
d 4 2àÐÀŒ+ º_ {` Ÿâ 2P B Œ+ ça b Àâ b B Œ+ 9b =b =b
d 4 rðàÐ
À pŒ+ àe sf áâ b Œ+ ôf g ýâ g t d
T 4 2àÐÀ d 4
R p
t
d T 4
rÀ B
4
2p › b 4 ²p
` P d 4 R p 4 R pŒ+ ÷u v ã / 4q fðà Ð
Àp`P ¨
d 4
RðàÐÀpŒ+ ,~ ]~ Nã 4 R
À p
`Œ+ ? ƒ 7ã
4
’p
d T 4 ’ÐÀp-
E t d 4 C²
ðàÐÀP ¨ X d 4 Ò p1
5#t d 4 3rð à
ÐÀP ¨ 8 d 4 ² p 2
0 R0
d 4
RðàÐÀpŒ+ Ö– — Nã
T 4 ràÐÀ p ` µ t d T 4 ’àÐÀ
4
2p d
4 RÐÀpŒ+ Ÿ (Ÿ 7ã  ¨ P T 4 2 p
Ä t d 4 2ÐŒ+ k¤ ‹¤ eã
Ä t
4 rðàÐŒ+ ¥ ³¥ ~ã 4¥ å¦ žã b ¨ ( ' EC
ð à ÐÀp`0P ¨ p ‚ RP t
d 4 RÀŒ+ ñ¬ Ù ·ã
T
Òp d T 4 ²p T 4 r p$
53Â
ð à ÐÀp`0P¨ X
4 RðàÐÀ p `
P ¢ðàÐÀ
p ` P
0
d 4
RðàÐÀpŒ+ Æ >Æ Nã !
!4 !òðàÐÀp`P rP ¢p` Œ+ ïÎ Ï Ðã t d
T 4 2ðÐÀ d 4 2 p 4 ðàÐÀ
p P 0 #
ð à ÐÀp`P0¨ x d
4 ’ p d T
4 ’p N ð ¨ Ä Ú ð 0 H ` t | Ž œ ® ¼ Î Þ ì þ * > Z x Œ º Î Þ ê ö * : J X f p € – ¢ ® ¾ æ 2 H b x † ° Æ à î þ $ 4 J Z l ~ ¢ ® ¼ Ì â ò " 4 \ h x Š SGenerateConsoleCtrlEvent ÇGetExitCodeProcess rWaitForSingleObject – CreateProcessA ´SetConsoleCtrlHandler õGetModuleFileNameA Û EnterCriticalSection îLeaveCriticalSection úGetModuleHandleW /Sleep "GetProcAddress ExitProcess qGetCommandLineA žRtlUnwindEx ôSetHandleCount >GetStdHandle ÙGetFileType <GetStartupInfoA À DeleteCriticalSection ;TerminateProcess «GetCurrentProcess LUnhandledExceptionFilter #SetUnhandledExceptionFilter ÐIsDebuggerPresent ŸRtlVirtualUnwind ˜RtlLookupFunctionEntry ‘RtlCaptureContext çGetLastError ¦HeapFree ¢HeapAlloc ]GetCPInfo TGetACP GetOEMCP ÚIsValidCodePage × EncodePointer ¹ DecodePointer @FlsGetValue AFlsSetValue ?FlsFree øSetLastError ¯GetCurrentThreadId >FlsAlloc ›WriteFile ðLoadLibraryA ºInitializeCriticalSectionAndSpinCount LFreeEnvironmentStringsA ÁGetEnvironmentStrings MFreeEnvironmentStringsW ˆWideCharToMultiByte ÃGetEnvironmentStringsW ªHeapSetInformation ¤HeapCreate SQueryPerformanceCounter jGetTickCount ¬GetCurrentProcessId SGetSystemTimeAsFileTime ©HeapReAlloc …GetConsoleCP —GetConsoleMode CFlushFileBuffers àLCMapStringA MultiByteToWideChar âLCMapStringW @GetStringTypeA CGetStringTypeW éGetLocaleInfoA ìSetFilePointer «HeapSize D CloseHandle WriteConsoleA ›GetConsoleOutputCP šWriteConsoleW
SetStdHandle z CreateFileA S CompareStringA V CompareStringW ÝSetEnvironmentVariableA KERNEL32.dll hReadFile ÚSetEndOfFile &GetProcessHeap ËGetFileAttributesA àE@ àE@ 2¢ß-™+ Í] ÒfÔÿÿL) @ ô @ ðó @ ÿÿÿÿÿÿÿÿ€
!
5 A
C P R
S
W Y l
m p r €
‚ ƒ „
‘ ) ž
¡ ¤ §
· Î × abcdefghijklmnopqrstuvwxyz ABCDEFGHIJKLMNOPQRSTUVWXYZ abcdefghijklmnopqrstuvwxyz ABCDEFGHIJKLMNOPQRSTUVWXYZ (@ ¤ `‚y‚! ¦ß ¡¥ Ÿàü @~€ü ¨ Á£Ú£ þ @þ µ Á£Ú£ þ Aþ ¶ Ï¢ä¢ å¢è¢[ þ @~¡þ Q QÚ^Ú _ÚjÚ2 ÓØÞàù 1~þ ôþ @ þÿÿÿ C @-@ @-@ @-@ @-@ @-@ P2@ ðü @ €@ @ Ð0@ P-@ P-@ (@ ÿÿÿÿ Xú @ (ú @ øù @
`ù @ (ù @ øø @ Ðø @ ø @ hø @ @ø @ ø @ Ð÷ @ ¨÷ @ ˆ÷ @ ÷ @ èö @ ! ðõ @ " Põ @ x @õ @ y 0õ @ z õ @ ü õ @ ÿ õ @ 8š @ 8š @ 8š @ 8š @ 8š @ 8š @ 8š @ 8š @ 8š @ 8š @
ðü @ òþ @ P@ L@ H@ D@ @@ <@ 8@ 0@ (@ @ @ @ ô@ è@ ä@ à@ Ü@ Ø@ Ô@ Ð@ Ì@ È@ Ä@ À@ ¼@ ¸@ °@ @ ”@ Œ@ Ô@ „@ |@ t@ h@ `@ P@ @@ 8@ 4@ (@ @ @ Ð0@ . @2@ lB@ lB@ lB@ lB@ lB@ lB@ lB@ lB@ lB@ P2@ . €p ðñÿÿ PST PDT à2@ 3@ ÿÿÿÿ ÿÿÿÿ þÿÿÿÿÿÿÿþÿÿÿÿÿÿÿÿÿÿÿ ; Z x — µ Ô ó 0 N m ÿÿÿÿ : Y w – ´ Ó ò / M l 8@ 0@ (@ @ ç x ð Y ” ` « x ° Ô à ¬ í ¼ ð Ú < Ú ® ( ® e e µ ô µ ½ ä ½ Û Ô è ] T h J ¤ L s t Ó ¤ Ô ¤ Z \ ƒ „ Å ¤ D § ¤ ¨ Å È ï P ð •" | ˜" &# È `# $ ¤ $ Š$ ” Œ$ %% œ ø% %& ¤ (& a& ¤ d& z& ¤ ”& Ç& ¬ È& ' ( ' ³' ( ´' >) ¸ x) ß) ¤ à) w+ è x+ Š+ Œ+ -- 0- . 0 . 9. @ <. ƒ. ¤ „. Õ. H Ø. V/ ` X/ =: \ @: -= € 0= f= P p= •> ¸ ˜> ? ¬ h? ˆ? ˆ? ¨? ¨? î? ¤ ð? \@ ` \@ ß@ Ä à@ eA Ä hA ðA ¼ ðA -B Ü 0B àB ä àB YC x \C £C ¤ ¤C ˜D ¤D .E L 0E ³E ` ÌE ´F t ´F øF ( øF §G ¨G þH ¬ I {I À ¨I ¼I P ¼I K Ð K šK ` œK M Ø €M íÑ(F½èð‹(F½èð‹-éðO
ò ðHüò-BòÀò@ ‘‚FhOô€r© ˜G¨ ð+ü«Â« &šBÙ¬’ù 0.+Ðp:¢B÷Ø«Bò|Àò@pZ ø? +ûÑø; +ø;ùѨ ! ðüF°ñÿ?ÑBò”Àò@h˜GBò4Àò@BòˆÀò@ªh@0˜G
ò- ðü½èðB©Oô€r(F ðÒûB«Ä(F ðÓûB«;3£BÒ“ù ±
*Ð
*õÑBò˜Àò@B¨" p ðü`±BòœÀò@hB“ShC““hD“{ø1©
õ…pÿ÷åýF(h©ÿ÷XýFǹBò”Àò@h˜GBò4Àò@*hBò¬Àò@h@0˜G
ò- ð±û½èðžBò˜Àò@!ë
h ñ ˜G€F8Fÿ÷áüÈø ñ. Ý5>Uø ÿ÷ÕüDø >÷Ѩÿ÷ÎüDø ºñ Ý ›ªñ Uø ÿ÷ÁüDø >÷Ñ #JFAF8F#`ÿ÷Æþÿ÷Jþ
ò- ðnû½èð ÿ÷¿ßø ÀÜø À`EÑpG 0@ µ‚°ßø ÀÜø ÀÍøÀßøÀÜø ÀÍø À ðRùþÞ 0@ 0@ -é
ü pÈpðp8qNqzqºqÌqìqr
rrjrrrˆrÖrärssRsZsrs’sžs¦s¼sÎsÚsìsøs tRtbtjtŒtœtØtuFuRuZu¦uºuìuøuv vÔ6ü6 7D7H7L7P7T7|8€8„8ˆ8Œ88”8˜8œ8 8¤8¨8L9P9T9X9\9`9d9h9l9p9t9x9|9€9„9 :(:,:T:X:”:˜:œ: :$;(;,;0;4;P{\{h{t{ô{L|Ì<Ô<Ø<Ü<à<è<ì|ø|}} }(}4}@}L}X}f}|}Ô}à} Ì0Ø0Ü0à0(1,1 MZ ÿÿ ¸ @ è º ´ Í!¸LÍ!This program cannot be run in DOS mode.
$ Ý€ô™ffffï§Éfî§-£%§šfî§Æ)§fî§]£!§¼fî§]£ §ìfî§]£#§“f §˜f "§˜fî§Rich™fî§ PE Ä N€\Q à " š h q" ° @ 0 @ àÒ ( X ø ° .text p˜ š `.rdata D) ° * ž @ @.data $+ à È @ À.pdata X Ø @ @.reloc „
à @ B -éøCF ð üFs Ø ! ð üFOð" z ! $ .€ø )ÝOð\Oð\cW\+Ñ1à"+ Ñ )ÝFPøëƒBûÑR !ø‹ à !c]4´Bø;äÛ )Ý\$F!±PøKƒBûÑR #‚ø Sp8F½èøƒ-éøOŠFF ðÂû! ðÇû #Êø 0FÀø @”ù &F %Oð ð-ü0±4”ù ð'ü (øÑOð\ \!ù{W³8F ð ü±¸ñ "Ð\/Ñ5ðç"/ ÑðѸñ ÑOðàOð 'm=±3Frø»“BûÑv % /Oð\ÕÐø{Ñç\!=±3Frø“BûÑv % #ø;Úø 03Êø 0Iø#`§±”ù ðÜû0±4”ù ðÖû (øÑ”ù 0Oð\ +«ÑHF½èøHF½èø-éøCF‰F€F ðEû† /
Ý ñ} Tø ð;ûƒ^ =÷Ñ!0F ð;ûKòXÀò@BFF ðÛû@F ð(û€F/Ý ñ~ Uø+Kò\Àò@ë ðÈûUø ðû ëñ>ëÑ F½èøƒ F½èøƒ0µ ðóûòMù FFFJ±\!3/*Ñø “ù *öÑD« “„«ª©(F ð ýù0Û»ù0\+7ÐD« “„«ª© F ðüü¨ ðÙú«Z ’ù 0\+ Ñ:’ù 0 \+ЩŠBÓpù=\+øÑ Ä¨ª©+F ðý!Oô‚p ðÀúÄ©Oô‚rF ðÒú F
òM ð§û0½!Oô‚p ð¯úOô‚r)FF ðÁú F
òM ð–û0½ µp¹Nö€cÀò@h0±Kò Àò@ !h˜G ½ ½ µž°F # ¨D" !““ “
“ “ ðÐüD# “KòÀò@Aòé Àò@ !h˜G«“ «“!FKòÀò@ #“““$h# “ # " GX¹ ð*ùKò`Àò@@0 ðÓù °½Nö€bÀò@
›˜oð `KòÀò@h˜GKò Àò@˜©h˜GX¹ ðùKò|Àò@@0 ð¯ù °½˜ °½ -éðO ð ûò-KòÀò@ ’‹Fh‚FOô€r© ˜G¨ ð ú«Ä« &œBÙ”ù 0.+Ð&p<¬B÷Ø«Kò¤Àò@Z &pø? +ûÑø; +ø;ùѨ !ðlþF°ñÿ?Ñ ð¸øKò°Àò@ª@0 ð`ù
ò- ðÏú½èðB©Oô€r(Fð³ùB«Ä(Fð”ýB«;3£BÒ“ù ±
*Ð
*õÑKòÀÀò@B¨" p ðAü`±KòÄÀò@hB“ShC““hD“{ø1©
õ…pÿ÷ØýF(h©ÿ÷“þF‡¹ ðmøKòÔÀò@*h@0 ðù
ò- ð„ú½èðž!ë
ñ ðˆù€F8Fÿ÷nýÈø ñ. Ý5>Uø ÿ÷býDø >÷Ѩÿ÷[ýDø ºñ Ý ñªñUø ÿ÷NýDø >÷Ñ ##` ›AF8F“±ð¨ù ð$øKòøÀò@@0:F ðÌø
ò- ð;ú½èðJFÿ÷ðýÿ÷´þ
ò- ð0ú½èð "ÿ÷ ¿ HpG à@ -é0H
ò L h¹Oô pà(Ú `! ðŸþ
M(`H¹#! #` ð–þ(`¹ àJ #P3 2P+Ú(høç ½è0ˆ à@ A û@ -éH
ò ð€ÿK“ù 0 ± ð~ÿL h ðÂÿ ##`½èˆ A ¨î@ -éH
ò
JF”BÓò`#œB
Ø£[ñ ðøãhSô Cã`àKñ h˜G½èˆ°@ à@ -éH
ò F(Ú0 ðøÿãhSô Cã`àKñ h˜G½èˆ°@ JB
Óò`#˜B ØÃh3ô CÃ`ƒ[ñ ðó¿K 0hGþÞ °@ à@ (ÚËh3ô CË`0 ðá¿Kñ hG °@ ´-é¾H
ò oFybF $<`E¹ð…ú#`ðÕúoð Wà )ôÐð|ù (öÛ}`(Fÿ÷~ÿëhð@5Ñ(FðÏú°ñÿ? Ðñ ÐC$Ið Qø#0ë‚"Jà!JF I“ø$0ðÑ°ñÿ? ÐñÐCð Qø#0ë‚’ø$0ð€ÐðAú#`ð‘úoð <`|¹(Fð¨úFñ( "yj(FðZû8`)F Fðãú ðø8h½è¾]øûµxhÿ÷bÿ½þÞàù@ ã@ Fù; +ûÑX pG-éH
ò #jF “ðgÿFD¹ ›3±ðú±ðþù ›` F½èˆ -éH
ò F‚± V ø; ±:ùÑB±:Ð !"±ƒ ø˜BûÑ F½èˆ-é0H
ò F ##sY»ð¶ø `ÃnM#`ƒn"hc`KhšBÐo+hBÑðaú `KbhhšBУho+hBÑð‚û``¢hoð ÑSðg##sà h#`Khc` F½è0ˆþÞ”ç@ ˆç@ \å@ -éH
ò …°KFh;¹KÓø03ø0ð àhF !ÿ÷©ÿ šSo+ÝjF! FðŒýàÒø03ø0ð ø 0#±šo3ðg°½èˆÐæ@ Dð@ ´-é0H
ò ˆ°
FF #¨ ! "
• “ ð˜ùE¹ðUù#`ð¥ùoð à ,ôÐoð C“B#“«hF ")F” ”ðkú›F;“ +Û › "pàiF ð±ý F°½è0]øû °Nö´LÀò@ Üø Àë Íø ÀpGNö´LÀò@ ›Üø ÀëcEÑ°pGFµlFìF,ð åFð&þ¥F½è@pG-é HëFÛih3ðPXðÐXðþ ½è ˆ-éþO
ò( F– “Ýø4 FÝø<€ šžF›‰F™ ' ±¹ñ Ñ ± ´à .ûоñ Ñ *öÑà *óкñ Ñ +îÑà +ëиñ Ñ )æÑà )ãÐ",F”ù 0±:4 *øÑ”ù 0:+ѹñ Ð.Àð€#oð *FHFðâýÝø àe à¹ñ Љø p•ù 0 ' & +,FJДù ðþ±4
à”ù 0/+Ð\+Ð.+Ñ&F àg 4”ù 0 +èÑÝø à‡³¾ñ Ð š{šBDÙ*Foð pFð«ýÝø à=F '.³®B#Óºñ КsšB6Ù*Foð PFð—ýÝø à¸ñ #Й£™B(Ù2Foð @Fðˆýà¾ñ ÛÐ 'Žø pØçºñ КcšBÙ*Foð PFðsý¸ñ Јø p 2à™ 'à šà™ š ž›¹ñ б‰ø p¾ñ Ð
±Žø pºñ Ð ±Šø p¸ñ Ð ±ˆø p=¹ðø#`ðXø à (õÑ ðþÿ"#`" ½èþ -éðH
ò †°Ýø0à FF¾ñ Oô€tÐ%F à %±#F à #¹ $ ±" à "“;F•Íø à– ”ÿ÷âþ°½èðˆ -é H
ò FF
F™ ”‘oð ðHý½è ˆ FÛðÿAê!ð ÑAêA :ŒFÛ£è:£èùÚ2Û£è: ÛCø Ú Ðp*ÛYpÈ¿™ppGðÐR øðØÐ’ #øÔç -éxH
ò F $ -FÐ-BÓ. @Ð0ù,1Z³ù<šB'Ñù,ú±ù<šBÑù,š±ù<šBÑù,:±ù<šBÑ4´BÞÓ àø,ø<
àø,ø<àø,ø<àø,ø<Ð àù Z±‘ù 0šBÑ041¬BóÓ ½èxˆx xëç -éH
ò K IFhjF ˜G@±KI ˜h˜GF ± F˜G½èˆþÞ$²@ ,°@ ²@ (°@ ð?¼ ðU¼ -éH
ò K h˜GFðÿü F ð,ÿ Fðý Fðý Fð ý Fðþ½èˆ$°@ -éþI
ò F &
F?¹ ðäþ#` ð4ÿ ?à -õÐð þ ¹ Kh˜G ¹& LOð ê$h:F !0FÅø €Íø€Íø € GF4¹Kh˜G ðÙþ à` ðTú(` (÷Д L oð $h:F !0F GP¹Kh˜G ðÁþ(h ðfûÅø €áç ½èþ‰8°@ 4°@ 0°@ -éH
ò Fÿ÷[ÿK Fh˜GþÞ<°@ -é0H
ò LF#h3± Fðþ±#h(F˜GðCþLM ¬BÒø¹Tø;±˜G¬BøÓÀ¹HðóþL MàTø;±˜G¬BùÓL#hC± Fðòý ±#h "! ˜G ½è0ˆþÞèú@ ±@ ±@ 9L@ 8±@ $±@ ìú@ ´-éøO
ò oFFþ "!ÿ ÿ÷IÿþÞ-é¾H
ò oF ðdÿEöM"FI ˆ“BÑËkÉ
hDòPSšB Ñ
‹@ò šBÑKo+ÙÑøè0 ±$ à $<`ðLÿ7MP¹+h+Ðð×þ ðþÿ ÿ÷¿þðÿûP¹+h+ÐðÉþ ðúýÿ ÿ÷±þð%ý ðÛú'Kh˜G$K`ð8ÿ!K`ð^ø (Ú ÿ÷›ÿð³ø (Ú ÿ÷”ÿ ÿ÷¡þ±ÿ÷ŽÿIKh
`KhKhÿ÷ÖùF}` ¹ÿ÷{ÿÿ÷oÿ àF}`;h ¹ÿ÷nÿÿ÷`ÿ à=h(F½è¾ˆµF hhðëø½ˆî@ Œî@ ”î@ ´î@ ¼î@ äú@ @°@ œö@ @ -é HëFð[ùÿ÷_ÿ½è ˆ -éøO
ò OßøD FˆFF $2FAFHFðŽùF¹†±;hs±Úø 0 F˜G;hòè2FšBÙoð ´ñÿ?æÑ(F½èøþÞD°@ Äî@ -éðK
ò Oßø@F€F $1F@Fð”ùF¹†±;hs±Ùø 0 F˜G;hòè2FšBÙoð ´ñÿ?çÑ(F½èð‹þÞD°@ Äî@ -éðK
ò Nßø@F€F $ "9F@FðßùF…¹3hs±Ùø 0 F˜G3hòè2FšBÙoð ´ñÿ?çÑ(F½èð‹þÞD°@ Äî@ -éðK
ò Oßø8€F>h $@Fð™ùF}¹v±Ùø 0 F˜G>hòè3 F³BÙoð ´ñÿ?êÑ(F½èð‹D°@ Äî@ -éxH
ò Fâh %ð+Ñô„Ð"h£hÖ .Ý ð‹ü¡h2Fðgüãh°BÑð€Ð3ðàSð oð ã`£h(F#` #c`½èxˆ-éH
ò F ¹ ðøà Fÿ÷Åÿ±oð àãhô€OÐ F ðZüðžü (ñÑ ½èˆ ´-éþI
ò oFF½b &~` #»` ðù $<`*KhœB3Úßøœ€Øø 0Sø$1³Ëhðƒ"Ð Fÿ÷ùøØø 0Sø$ ÃhðƒÐ-Ñÿ÷±ÿ°ñÿ?Ðs {` àU¹ðÐÿ÷¥ÿ°ñÿ?Ñoð »` ðø;h\ <`½j~hÇç ð
ø»j+Ñxh à¸h½èþ ]ø ûµ ðßø½µ8hKhSø ÿ÷ìø½þÞ A û@ ÿ÷•¿ -éþI
ò oF %=` ð¨ø$|` Nßøl€Øø 0œB$Ú3hSø$ è±ÃhðƒÐð©ü°ñÿ?Ð5=`,Û3hSø$0ñ Kh˜G3hSø$ ðø3h "Cø$ 4|`Öç ðø8h½èþ‰µ ð‹ø½H°@ û@ A -éH
ò €± KF !hKh˜G@¹Kh˜G ðûF ð'û`½èˆ8°@ L°@ ö@ -éðH
ò L
NO$%ch+Ñ;h0F&`Oôza6˜G4=òÑ ½èðˆP°@ Èî@ €â@ -éðK
ò LßøH€$&%FOð /h_±kh+ÐØø 08F˜G8Fÿ÷ÿÅø 5>îÑN$% h ±ch+Ñ3h˜G4=õѽèð‹H°@ €â@ -é0H
ò MFUø00+¹ ðø¹ ÿ÷+ýKUø4 h˜G½è0ˆ°@ €â@ KSø0 KhG °@ €â@ -éðH
ò oFF Kh;¹ð ü ðPûÿ ÿ÷üMUø60ë¹ ÿ÷2þF,¹ ð’ú #` à
ÿ÷¹ÿUø60 F;¹Oôza Kh˜GEø6@àÿ÷Aÿ ðø ½èðˆµKmKh˜G½þÞ °@ €â@ P°@ ö@ -é HëFHOô€r !ÿ÷ŸúK"`½è ˆàú@ àù@ -éðO
ò ™°oF ÿ÷{ÿžL#h;±#{a£Iñˆ ð³û%á@! ÿ÷°ý8`8¹ #»a›Iñˆ ð¥ûá `ßø\‚ #Èø 0 %éC
"#hö ˜BÒq`Bq…`ø$03ð€ø$0[²ð€ø$0€ø% €ø& …c€ø4P@08`áçñ ‚Kh˜G·øR0 + ð‡€{m + ðƒ€ hñ Çø ë
Çø ¶õ oÛOô f$¼`Øø 0³B.Ú@! ÿ÷Yý8`0³jJBø$ Øø 0 3Èø 0
!Rø$0ö ˜BÒqoð `Aq…`ø$03ð€ø$0€ø%€ø&…c€ø4P@08`ãç4ÍçØø `¨F}`°E:ÚÚø °ñÿ?(Ðñ%Йø 0ð ÐðÑMKh˜Gȱ_êhð GIQø#0ë‚<`Úø 0#`™ø 0#qOôzañ @Kh˜G£h3£`ñÇø€ ñ Çø
ñ
Çø Âç6L}`ßøä€oð -TÚ#hë…<`#h³ñÿ?ÐñÐ#yoðC#q?àoð~#q¹oð à-Ñoð
àoð %Kh˜GF°ñÿ? Ðæ± Kh˜GÀ±&`ò+Ñ#ySð@à+Ñ#ySð#qOôzañ Kh˜G£h3£` à#ySð@#qÄø Øø 0±Sø%0Ãø5}`L¨ç ð ø àxi à¸i ¿°½èðµ ÿ÷Yþ½àù@ P°@ X°@ \°@ A T°@ àú@ *@ *@ -éH
ò LIH$h # " G± àoð ½èˆð@ ¡'@ `°@ -éðO
ò ‡° Fõi4hŽF+h‘qh‚F´ë ð O‘Ð3ð De–ø(@ ±©ñ Úø@ðfQÑÖø$€Íø ’+h˜E€ð€ILë{h™E9Ó»h™E6Ò;i£³úh*ÐójRqF¨ð)ú (0Û%ÝÚø 0>J“B Ñ#h;± Fð6ø±#h!PF˜G;iœ™"ð$ú3j9i˜“si 0L “Úø 0$hRF Gðú+LÝøà™+hñ7˜E¼ÓGà Fà3iwj(h³ë‡B>Òëch™E1Ó£h™E.ÒÚø0ð ÐOð ±)FKh˜E
Ó‹h˜EÒ
i#išBÑÊhãhšBÐñ1†EìÓ™†EÑÝøà#i±˜EÐà{ sbâhójRqF ðÀù(h7™Ýøà4‡BÂÓ °½èðÈù@ d°@ csmà-éH
ò I " FTø;˜BÐ2-*øÓ°ñ+Ø
à°ñ¼+Ø à à Sø2 ½èˆþÞàã@ -é HëF ðmþ¹H à0½è ˆþÞHå@ -é HëF ð_þ¹H à 0½è ˆþÞLå@ -éH
ò Fÿ÷ëÿ` Fÿ÷µÿFÿ÷Öÿ`½èˆ K`pGþÞ ð@ ûÞ-éüK
ò LF F hLFˆF$h GFE±
œ3F:FAFHF ”¨G½èü‹ ûÞ °@ ð@ -é H
ò # " ! “ÿ÷×ÿ½è ˆ -é HëF@¹ÿ÷˜ÿ#`ÿ÷èÿoð à i½è ˆ-éðH
ò Fÿ÷éÿð ù¨³þ÷@üñ œBÑ %àþ÷8üñ@œB'Ñ%Jh3`ãhô† ÑOOô€VWø% h¹0Fÿ÷ ûGø% 8¹ñ£`#`#£ac`à ` `¦af`âhAòCã` à ½èðˆþÞ ð@ „î@ -éH
ò Fp±ãhô€_
ÐFÿ÷ûúãh3ôˆSã` #£a#`£`½èˆ -éH
ò ËhFð@Ћh›±Kh;K` +Û hp hÀ²3 `àð•û°ñÿ?Ñoð à#h3#`½èˆ-éøO
ò
Òø @ FÕø ð@FF‚FÐÒø@ ¹2hÒ2` à #+` /Ýù 2FAF?ÿ÷ºÿ3h³ñÿ?Ñ+h*+Ñ2FAF? ÿ÷®ÿ /êÜ+h ¹Åø ½èø-éðO
ò þ÷¤ýòx-™F #“ #
“ # FF¨F “““”– %Oð
þ÷Úüÿ÷¶þÿ÷µýê
(Àòòƒ–³óhð@-Ñ0Fÿ÷ÿßøHßøü°ñÿ?
ÐñÐCTø#0ð ë‚ à F“ø$0ðÑ°ñÿ? ÐñÐCTø#0ð ë‚‘ø$0ð€Ñœ4¹ÿ÷xþ#`ÿ÷Èþ¶ã”ù ` ' # !2F . ——“ 𩃛ßølçÝøH€“4” /Àòžƒ * Ûx*Üßø\7›ø <ð à #ëÃßøH[V
‘) òxƒßèð«.JMgÆ #“ # % “Oð !ê
#“Íø<à
‘^ã *Ð#*Ð+*
Ð-*Ð0*@ðWƒUðSãUðPãUðMãUð€JãUðGã**ÑÙñ ðKDñ Yø
‘ )€ò8ƒUðIB
‘2ã
ݑđC0;
“+ãOð
(ã**ÑÙñ ðKDñ Yø¬ºñ €òƒoð šFã
ëŠëC³ñ0
ãI*Ðh*Ðl*Ðw*@ðƒUô eã”ù 0l+Ñ4Uô€UúâUð÷âUð ôâ”ù 6*Ñ”ù04+Ñ4Uô Eèâ3*Ñ”ù02+Ñ45ô EÞâd* ðÜ‚i* ðÙ‚o* ðÖ‚u* ðÓ‚x* ðЂX* ðÍ‚ #
“ #𲩓ðŠùP±™ª0Fÿ÷\þ”ù `4 . ðÀ‚™ª0Fÿ÷QþŸ˜ —¬â²ñA7) ò‚ßèðÝ 8 Ý Ý Š Se â = Mâ â â MÆ dQ OUôoÑUô eôoÐÙñ ðKDñ 9ø¯Uô€uñ8çUð@
$àOð
# à'#$ð€“Ð0"ø Q3" ’ø0à$ð€ÐUô uô O ÐÙñ ðKDñ Yø Yø<6àô€_ðÑð Ðð@
ÐÙñ ðKDñ 9ù Ã"àÙñ ðKDñ 9ø óçð@ ÐÙñ ðKDñ Yø FÛ àÙñ ðKDñ Yø #Íø0ð@ Ð + ÜÛ (Ò@BOð rëUô€uô OÑô€_Ñ3ðÿ3ºñ ÚOð
à5ðºõ ÝOô zPêÑ " ’ÝøL
òo(ºñ ªñ
ÜPêÐF Fá¹¹ùÞðÉþ02“9* F ÝJDø)æç
òo#£ë Ýø0ñô б˜ù 00+Шñ0#ˆø 00› +@ðˆ€ð@Ðô€Ð-#àðÐ+#àðÐ #ø0# “
› šžŸð Ñ` %½` ,3Ü
Ð,Ð, Ð,9Ð,Ð/àßø`Øø ?àÿ÷øF½`¹oð àèmFQKhëA ëƒSh£BÐ 2rEùÓëA 냚BÒSh£B Ð "ñØø à,Ð,
Ð,Ðþ÷{ù#`þ÷ËùÒç`3Kh˜Gx`(Nй ý÷¼û± ý÷†þ,Ð ,Ð,Ð à+n;a (f,Ñkn{aŒ#kf,Ñ!L"hFú` N3h›™BÚëAëm나`1ù`"hñç Kh˜GÈø ð ø¼k,{hѽhin ˜Gà F˜G½h,Ð ,Ð,Ñ;i+f,Ñ{ikf °½èð ]ø ûµ;h± ý÷Mþ½$°@ ÌÁ@ ÈÁ@ °@ Tð@ ÀÁ@ -éˆH
ò oFþ÷Óÿƒo±˜GðxþþÞ -é HëFKHh˜GK`½è ˆþÞhð@ ]J@ $°@ KhGþÞŒ°@ KhGþÞ°@ KhGþÞ”°@ KhGþÞ˜°@ KhGþÞœ°@ -éH
ò L#h +
Ú # “K !hFh˜Gz(Ñ# à ##` +Ý à ½èˆˆ°@ ¼ì@ ˆEöM#šBÐ pGÃkXDòPSšBöÑ
‹@ò šBñÑ pG -é0H
ò Ãk $“ŠÕˆ›ñ U±Âh‘BÓƒh›™BÓ4(0¬BôÓ ½è0ˆ½è0ˆ -é¸H
ò oFF@ò Àò@(Fÿ÷¿ÿ¹ 8`àa(Fÿ÷Íÿ¹ 8` àCjð OÑ à 8`à à8h½è¸ˆhhKšBÑ à pG À-éxH
ò LN
% h3h˜GDø =øѽèxˆ$°@ Àì@ -é0H
ò KM 3«BÒTø;±˜G¬BùÓ½è0ˆ,Ë@ (Ë@ -é0H
ò KM 3«BÒTø;±˜G¬BùÓ½è0ˆ4Ë@ 0Ë@ -éH
ò ! ý÷^û KFh˜GK`K` ¹ à ##` ½èˆøú@ ôú@ $°@ -éøO
ò oFFý÷ºø*Kh*Kh˜G€F%Kh'Kh˜GFÁE8Ó ë
ñ.2Ó@Fð]ýF´B Ò°õ oÒFàOô c¡BÓ@Fý÷ïú8¹ñ¡BÓ@Fý÷çú°±_êª ëƒ Kh˜GK`(F Kh˜GÉø ñ Kh˜GK` à %=` ðø8h½èøµý÷mø½øú@ $°@ ôú@ °@ -é HëFÿ÷™ÿ¹oð à ½è ˆ-éH
ò I " FTø;˜BÐ2*øÓ à Sø2 ½èˆþÞ°¿@ -épH
ò ü÷ þò-Fÿ÷ÝÿF -~Ð ðù(VÐ ð ùYL¹Ôø(6+MÐü.nÐTJOôEq Fðèù (@ðˆ€ #¤ø:2MKOô‚rñ2h ˜G@òû&8¹GJñ2 1FðÑù (UÑñ2 ð÷ùC <+Ù°ñ;ñ2ëB ñ2:Jæëc#ð5ù (DÑ5JOôEq Fð{ù (JÑ*FOôEq Fðsùà»,J+I Fð§ü"à'Koð h˜GFܱ°ñÿ?Ð "©5ø;ST±2²õú÷Ó #¨ø2ü÷´üF FL # “$h«© G
ò-ü÷¡ý½èpˆ # " ! “ý÷êþ # " ! “ý÷ãþ # " ! “ý÷Üþ # " ! “ý÷Õþ # " ! “ý÷ÎþþÞþÞ¤°@ \°@ àÀ@ ÔÀ@ ÌÀ@ œÀ@ °@ hÀ@ pð@ -é HëF ðDø(Ð ð?øH¹Kh+Ñü ÿ÷!ÿÿ ÿ÷ ÿ½è ˆ˜ö@ hK
hšBÑ i+ ÑJi KšB
ÐKšBÐKšBÐKšBÐ pGÿ÷Y½þÞ @™"“!“ “csmà-é HëFHÿ÷hý ½è ˆþÞyO@ -é HëF (
Û(Ý(Ñ Kh àKh`àý÷(þ#`ý÷xþoð F½è ˆþÞœö@ K`pGþÞ˜ö@ -é HëFKh˜GK`¹ à ½è ˆ ö@ ¨°@ -éðI
ò …°&Kh˜GFî³3ˆFà2ø?¹2ˆ +øÑ L“_$hOð { 2F ! Íø €Íø€Íø€Íø € GFÔ±ý÷uùFµ±”L{ 2F$h ! Íø €Íø€ • G¹(Fý÷Šú %K0Fh˜GàK0Fh˜G %(F°½èð‰þÞ´°@ °°@ ¬°@ -éøO
ò Ýø(šF #Éø 0#Êø 0FˆFF±Áø ñ '”ù "*ѹ' à 'Ö²àÙø 03Éø 0±#x+p5øk0Fÿ÷ôúH±Ùø 03Éø 0±#x+p546± /ÙÑ .Ð .ÕÑ~¹¯ àYø$0™Z+x‚ø40Yø$0["šc’D á
ᜠ"Yø%0yð€ ðð€ % .FÑFF / ð
$
ñ@ Aòÿ>« "¦ë¹BÒ–ù 61
(Ñ p3522rEø îÓ‰H œ
ñ@ £ë Pø$ œ # “ Y…L
«JF$h©• G (Oð ðÀ
›šDKEÀò€¦ë»Bñ
Aòÿ>
ñ@ ÂÓ¶à.CÑFF / ðÄ€
$
ñ@ Aòþ>« "¦ë¹B
Ò0ˆ61
(Ñ €3522rE#ø ïÓeH œ
ñ@ £ë Pø$ œ # “ YaL
«JF$h©• G (Oð {Ð
›šDKE{Û¦ë»Bñ
Aòþ>
ñ@ ÅÓpàÁF / ð€€
$
ñ@@öUV
õ¢S "©ë¹BÒ¹ø 1 ñ
(Ñ €322²õÕo#ø íÓ "DL’’
õ¢R›$hëÓs[
õ¢R !OöéP–Íø à GF’ª³ &6H œ #©Pø$@˜ “
« X3L’‰$h G(±
›šö²BêÜà,Kh˜GšF²BÜ©ë
ºEOð
@öUV
ñ@©Óà$L h ’$h
«:FAF G±Ýø( %à Kh˜GFºñ &Ñu±-Ñü÷øÿ #`ý÷ø#`›å(Fý÷
ø—åK šSø"0š›yð@Иù 0+?ôzü÷Üÿ #`ü÷æÿ #â盪ë Aöð,åDû÷°þ½èðàù@ 8°@ ¤°@ °°@ Ì°@ È°@ \°@ ´-éøO
ò oF‘FŠFF¼bñÑü÷½ÿ #`ü÷«ÿ #`?àü÷¨þ (;Û ,/Û#KhœB+Òe Nð Vø%0ëˆyð Ð FðÃÿVø%0ëˆyðÐJFQF Fÿ÷
ý8` àü÷~ÿ #`ü÷ˆÿ #`ÛC;` ðø8h àü÷~ÿ #`ü÷lÿ #`ü÷¼ÿoð ½èø]øûµ¸jðÒÿ½þÞàù@ àú@ ´-éøI
ò oFFþ #`ü÷Žþ ½èˆþÞàù@ àú@ €±F°ú€ð±úóÀòM£ëÀ£ë@Oð Àò¡€GùÞ±ëÂs(¿F@A±ë‚s(¿F@A±ëBs(¿F@A±ës(¿F@A±ëÂc(¿F@A±ë‚c(¿F@A±ëBc(¿F@A±ëc(¿F@A±ëÂS(¿F@A±ë‚S(¿F@A±ëBS(¿F@A±ëS(¿F@A±ëÂC(¿F@A±ë‚C(¿F@A±ëBC(¿F@A±ëC(¿F@A±ëÂ3(¿F@A±ë‚3(¿F@A±ëB3(¿F@A±ë3(¿F@A±ëÂ#(¿F@A±ë‚#(¿F@A±ëB#(¿F@A±ë#(¿F@A±ëÂ(¿F@A±ë‚(¿F@A±ëB(¿F@A±ë(¿F@A±ëÂ(¿F@A±ë‚(¿F@A±ëB(¿F@A‹(¿F@ApG ð CH¿@B“ê! (¿IB€±F°ú€ð±úóÀòM£ëÀ£ë@Oð Àò¡€GùÞ±ëÂs(¿F@A±ë‚s(¿F@A±ëBs(¿F@A±ës(¿F@A±ëÂc(¿F@A±ë‚c(¿F@A±ëBc(¿F@A±ëc(¿F@A±ëÂS(¿F@A±ë‚S(¿F@A±ëBS(¿F@A±ëS(¿F@A±ëÂC(¿F@A±ë‚C(¿F@A±ëBC(¿F@A±ëC(¿F@A±ëÂ3(¿F@A±ë‚3(¿F@A±ëB3(¿F@A±ë3(¿F@A±ëÂ#(¿F@A±ë‚#(¿F@A±ëB#(¿F@A±ë#(¿F@A±ëÂ(¿F@A±ë‚(¿F@A±ëB(¿F@A±ë(¿F@A±ëÂ(¿F@A±ë‚(¿F@A±ëB(¿F@A‹(¿F@A_êL (¿@BH¿IBpG -éðH
ñ Pê&ÐQê9ÐFŒF³úƒñ¹²ú‚ñ 1¼ñ ¼úŒðѶú†ð 0@.Û (eF4FÓ5F $ð …@Ðñ 4úñ„@
C !àùÞd DêÅtIAmBØÓ”BØ«A@ Qñ ´BíÑeEëÑàFÿ÷Cþ
F ! #à ! ½èðˆ -éðH
ñ ð DÕ@BaëA”ê#ÓRBcëCPê&ÐQê9ÐFŒF³úƒñ¹²ú‚ñ 1¼ñ ¼úŒðѶú†ð 0@.Û (eF4FÓ5F $ð …@Ðñ 4úñ„@
C !àùÞd DêÅtIAmBØÓ”BØ«A@ Qñ ´BíÑeEëÑàFÿ÷çý
F ! #à ! Ó@BaëA?@ÕRBcëC½èðˆ -éH
ò …°FhFû÷ ú ›â²Óø03øø 0#±šo3ðgô @°½èˆ-éH
ò …°FhF !û÷ú ›â²Óø03øø 0#±šo3ðgô @°½èˆ ´-éðH
ò Š°FFF/¹&±
± #+` 1à±oð +`oð CžBÙü÷²û#`ü÷ü !à™¨û÷Êù˜Ðø¨0+»½øL0ÿ+Ù/±&±2F !8Fû÷Ùûü÷—û*#`ü÷“û hø$0#±šo3ðg
°½èð]øû±>³;p½±#+`à #L“«“@h$h #“#ª !– — G0±› +Ñѱ(` Ôç
Kh˜Gz(ÈÑ/±&±2F !8Fû÷›ûü÷Yû"#`ü÷©û" ÀçþÞ8°@ °°@ -é H
ò $ ”ÿ÷zÿ½è ˆKhSðKh“BÑ pG pG°÷@ ´ì@ -é0H
ò F ,NÐ(Màhëh˜BÐû÷êÿ i+i˜BÐû÷äÿ`iki˜BÐû÷Þÿ i«i˜BÐû÷Øÿàiëi˜BÐû÷Òÿ j+j˜BÐû÷Ìÿ`jkj˜BÐû÷Æÿ k«k˜BÐû÷Àÿàkëk˜BÐû÷ºÿ l+l˜BÐû÷´ÿ`lkl˜BÐû÷®ÿ l«l˜BÐû÷¨ÿàlël˜BÐû÷¢ÿ½è0ˆðì@ -é0H
ò Fô±M h+h˜BÐû÷‘ÿ`hkh˜BÐû÷‹ÿ h«h˜BÐû÷…ÿ k+k˜BÐû÷ÿ`kkk˜BÐû÷yÿ½è0ˆþÞðì@ -éH
ò F , ð<`hû÷iÿ hû÷fÿàhû÷cÿ iû÷`ÿ`iû÷]ÿ iû÷Zÿ hû÷Wÿ jû÷Tÿ`jû÷Qÿ jû÷Nÿàjû÷Kÿ kû÷Hÿ`kû÷Eÿàiû÷Bÿ kû÷?ÿàkû÷<ÿ lû÷9ÿ`lû÷6ÿ lû÷3ÿàlû÷0ÿ mû÷-ÿ`mû÷*ÿ mû÷'ÿàmû÷$ÿ nû÷!ÿ`nû÷ ÿ nû÷ÿànû÷ÿ oû÷ÿ`oû÷ÿ oû÷ÿàoû÷ ÿÔø€ û÷ÿÔø„ û÷ÿÔøˆ û÷ ÿÔøŒ û÷üþÔø û÷øþÔø” û÷ôþÔø˜ û÷ðþÔøœ û÷ìþÔø û÷èþÔø¤ û÷äþÔø¨ û÷àþÔø¸ û÷ÜþÔø¼ û÷ØþÔøÀ û÷ÔþÔøÄ û÷ÐþÔøÈ û÷ÌþÔøÌ û÷ÈþÔø´ û÷ÄþÔøÔ û÷ÀþÔøØ û÷¼þÔøÜ û÷¸þÔøà û÷´þÔøä û÷°þÔøè û÷¬þÔøÐ û÷¨þÔøì û÷¤þÔøð û÷ þÔøô û÷œþÔøø û÷˜þÔøü û÷”þÔø û÷þÔøû÷ŒþÔøû÷ˆþÔø û÷„þÔøû÷€þÔøû÷|þÔøû÷xþÔø û÷tþÔø û÷pþÔø$û÷lþÔø(û÷hþÔø,û÷dþÔø0û÷`þÔø4û÷\þÔø8û÷XþÔø<û÷TþÔø@û÷PþÔøDû÷LþÔøHû÷HþÔøLû÷DþÔøPû÷@þÔøTû÷<þÔøXû÷8þÔø\û÷4þÔø`û÷0þ½èˆ-éðO
ò û÷:ø„°oF‚°{` &×ø< :`¹`ºñ Ñ hÐø 8l± ! à!1L $h PF G€F¹ &OàMöÝY¸ñ &Ý#Û;˜E!ØñX °õ€oØà ƒBØoð3ðœ ðåÿë
ñ
ÐLöÌC+`àþ÷bþF -ÕÐÀø 5 à % -ÎÐ_êH !(Fû÷PùL{h:h$h!PFÍø€ • G8± L»kF$h¸h)F GFUøöѹ…ø 5 *Eјø 0 ±.ѵñ ÈF¡E Ó˜ø iFý÷Òø±¨ñ EõÒ©ëðÐø¬>à¶ñÿ? Ñ/Ùë¨ñ5F¦BÓ(xiFý÷µø±=¥B÷ÒsðÐø¬àãø¬P %à„ø û÷)û"#`û÷yû" à++Û¯ >F§BÓ0xiFý÷ø±>¦B÷Ò»ðÐø¬û÷ û*#`* à ø 0 +?ôj¯šo3ðgcç-é?H
ò F F=¹û÷óú#`û÷Cû #à ,õÐ¥BùÒhFFú÷ù™‹h ¹` àb :•BØx[[~ðöÑ£ðãX ø 0#±šo3ðg°½è0ˆ "ÿ÷Ç¿ -éðH
ò F ¹¹Ù» $@àÀ³¹³¹ #p÷ç*¹ #pû÷ú$(à '´ñÿ?F
F ц’ù 0³Tñk±=÷Ñ
à“Wø;±=Ð<÷ѹ7p -ÓÑ´ñÿ?ÑCø|P$àpû÷ƒú"$`û÷Óúàû÷|ú#`û÷Ìú$ F½èðˆ-é HëFý÷Ÿø± ý÷¥øKhðÐ ûÞ ú÷ÁüþÞLí@ ú÷ü -é HëF@¹û÷Tú#`û÷¤úoð àKF !hKh˜G½è ˆä°@ ö@ -éðO
ò ú÷ùˆ°YKF‘h F˜GF %ý÷tù\L‚F#hÓ»YKXHOô bh !˜GF / ð€NKQIh˜G ( ð†€HKh˜GIKKI `h8F˜GDKh˜GDKFI``h8F˜G?Kh˜G@K@I `h8F˜G;Kh˜G a@±:K9I8Fh˜G6Kh˜Gà`3Kh˜GX±¹ñ Ð.KHFh˜Gºñ
Ð Màºñ Ð'K hh˜G Dààh°B Ð#i³B Ð!Kh˜G K‚F ih˜GFºñ бÐGP±« “ #ª!¸G±›ðÑXô à`h°BÐKh˜Gh±€GFU± h°BÐ Kh˜GF±(F˜GFK hh˜GF,±šCFIF(F G à °ú÷pø½èð °@ ì°@ è°@ $°@ ¤Ê@ ,°@ dÊ@ €Ê@ ”Ê@ XÊ@ @Ê@ „°@ °ù@ -éH
ò à±Ù±*¹ #pû÷gù$à„’ù 0£Tñ ±9÷ÑA¹ #pû÷Wù"$`û÷§ùà $àû÷Nù#`û÷žù$ F½èˆ½ë„ îPO¤hÓ¤EÓë pG_ð ÷ç`´fFoó ¤õ€T%h´BúÑ`¼ë pG -éðH
ò †°FFF6±/±‘ù @4¹
± #+€ °½èðˆ¨Fù÷4ÿ›Óø¨0k¹
±3x+€ ø0 +ìКo3ðgæç0x©þ÷öüౘCo+ÝŸBÛ
±" à "L@h’$h2F ! • G (˜ÑCoŸBÓ–ù0‹±@oÓç
±# à #˜ L“@h$h#2F ! • G (ÂÑû÷Ìø*#`oð ¼çþÞ4°@ #ÿ÷—¿ ´-é H
ò L hñÑ ðÆú h°ñÿ?ÑOöÿp àL # “$h«"© G (òнø ½è ]ø ûþÞð°@ Pí@ -éðH
ò F ((Û Kh˜B$ÒNð EŸVø%0ûX³ñÿ?ÑKh+ÑH±(Ð( Ñoð àoð
àoð
K!Fh˜GVø%0 üPàû÷fø #`û÷pø #`ØC½èðˆþÞô°@ ˜ö@ àù@ àú@ -éxH
ò (1Û!Kh˜B-Ò Mð DžUø$0òyð!Ðh³ñÿ? ÐKh+ÑX±(Ð(
Ñ !oð à !oð
à !oð
Kh˜GUø$0oð òPàû÷ø #`û÷$ø #`ØC½èxˆþÞô°@ ˜ö@ àù@ àú@ -éH
ò FñÑû÷ ø #`ú÷úÿ #`!àú÷÷þ ( Û ,ÛKhœB
ÒKað Sø!0ë‚yðÐh àú÷ëÿ #`ú÷Ùÿ #`û÷)øoð ½èˆþÞàù@ àú@ ´-éH
ò oF8aAKð Sø!0ë‚£hƒ¹
ú÷æü£hK¹Oôzañ Kh˜G£h3£` ðø:iQ Kð Sø!0ë‚ñ Kh˜G ½è]ø ûµ
ú÷Ûü½°@ àù@ P°@ KAð Sø!0ë‚ñ KhGþÞ °@ àù@ -éðO
ò …°oFoð ©F=` #û` ú÷½ü ( ð˜€ú÷hþ (Àò“€ ú÷Žü &ßøFF–ù *]Ð
*Ð*p56TàŽB
Òù?
+Ñ6
#+p5Hà*pûçZø) $h #Xø “«"©6 G ¹ßøX3h˜Gx»›k³Zø)0CDyðHÐù0™ßø8C
+×Ð
#+pZø)05ëø0Sqà½BÑù0
+Ñ
#
à˜# “oð oð þ÷Tÿù0
+Ð
#+p5»L™›žBžÓàZø)0ëyð@ÑSðqà3x+p5›î+dÑ .bÐø=ð€Ñ5?à¬J!à)ܽBÓ=+x1›V +õÐ(xƒV¹ú÷ƒû*#$á3‹BÑm&àZø)0ëyðHÐ5)PqÛZø)0ë+x5‚ø%0)ÑZø)0ë+x5‚ø&0mà˜#JB “Óþ÷ëþ ›ŠLí[“›$h:F “+F !OöéP GF .?ôè®®BÐ" à "Zø)0v CDcoð›ŸBÐ8Fù÷õÿñ ðæ€&Fãà›S³ëÖs[ëC§B9F:F Ò¥ ˆ(Ð
( ѪB
ÒSˆ
+Ñ
# €21à€12¢BëÓàZø)0ëySðqË[^ Äç*±;ˆ
+ÑPðà0𺒗B q=F¸F€ðƒ€‘ UL
ž‘F¸ø *jÐ
*Ð*€5ñ`àˆE Ò8ø?
+Ññ
#+€5Sà*€ûçZø) $h #0X “«"
ñ
ñ G¹?Kh˜Gл›Ã³Zø)0›yðH нø
0™8L
+ØÐ
#+€Zø)05òø
0SqZø)0òø 0‚ø%0Zø)0›
"ƒø& à½Bѽø
0
+Ñ
#
à˜# “oð oðþ÷ þ½ø
0
+Ð
#+€5 L™›˜E‘ÓàZø)0òyð@ÑSðqà¸ø 0+€5î.çKh˜G(Ñú÷aú #`ú÷kú#`æm(ô ® $ ç & àú÷_ú #`ú÷Mú #`ú÷úoð 0F °½èðþÞ8°@ ±@ 4°@ Xí@ ±@ È°@ àù@ àú@ ´-éøO
ò oFFŠFF¼bñÑú÷1ú #`ú÷ ú #`Làú÷ ù (HÛ ,<Û)KhœB8Òfßø˜€ð Xø&0ë‰yð+Ðoð CBÙú÷
ú #`ú÷ûù#&à Fÿ÷*úXø&0ë‰yðÐ*FQF Fÿ÷ü8` àú÷åù #`ú÷ïù #`ÛC;` ðø8h àú÷åù #`ú÷Óù #`ú÷#úoð ½èø]øûµ¸jÿ÷9ú½àù@ àú@ -é HëF@¹ú÷ºù#`ú÷
úoð àù 0 +òÐ )ðÐ h +íГù 0 +éÐ " ðû½è ˆ -éðI
ò ° FFF€Fü÷Ûø`± L H$h GLI$h GF ¹oð #àœü÷Êø (@F9FÐ#“›2F
•“›“ # “ “« “› G à #š“›LC“›$h2F “+F G
°½èð‰ü°@ ÌÊ@ ,°@ ØÊ@ ±@ -éðO
ò ‘° F #
““ #“ #“ ’ F &ú÷Eø (ÚóC#`ùàð€Ð #Oðà#Oð
¨“ ð^ü (@ðã‚ô O Ñôè/Ñ
›³õ OÐoðSêOúƒøð Ð+Ð+ Ðú÷"ù #`ÛC#`ú÷ù#`ú÷^ùâOð@I
àðÐôà/öÑOð€IàOð I›+Ð +Ð0+
Ð@+Ѐ+Ùѹñ OÑ!à!à! à !ôàc³õ€o‘Ü
Ðc±³õ€Ð³õ %гõ@¾Ñ'
à' à' à³õ oгõÀoгõào¯Ñ'€#Oð
“ô€Ðßø5h›3êð€Ñ#“à'êç€#ð@ÐYô€9Qð‘Oð€jô€_ÐSô€s“ô _ÐZð zð ÐZð jàðÐZð€Zÿ÷ù `°ñÿ? Ñú÷•ø #`ÛC#`ú÷ø#ià ›" ˜`›šIF“«Íø —ÿ÷ÑþF “°ñÿ?1Ñð@C³ñ@OÑðЛš ˜9ð I“«IFÍø —ÿ÷·þF “°ñÿ?Ñ"hßø$4QSø!0ð ë‚y3ðqßø 4h˜Gú÷Zøú÷<øhëáFßøü3h˜G »"hßøè3QSø!0ð ë‚y3ðqßøÄ3h˜GFú÷;øßø¼3 ˜h˜G ,ÙÑú÷ø
#`Ôç(ÑXð@à(ÑXðOúƒø h ™þ÷lÿ#hßøˆãXð Yð ^ø!0ë‚q#hYð ^ø!0Oðë‚’ø$03ð‚ø$0ðH
“>Ñð€;Ð
B9Ð hoð oð ‘þ÷kûF “ @³ñÿ?ˆFÑù÷Úÿhƒ+#Ð hÿ÷(ù†ç h #©"ø0ÿ÷úX¹½ø0+Ñ h šCF ðõú°ñÿ?æÐ h # " “þ÷@ûê³ñÿ?ÛИ!ð€ ðÝ€ôè/Ñ
›ôè#ÑUô€E à Côè#³õ€O гõ€?гõ ?гõ ?гõ?гõ€/гõˆ/ÑOðà@ò2ê“BÑOðÍø€àOð ùçOð ôà/ 𤀠#“ð@@ðž€ð@C³ñ€Ojгñ O0гñ@O@ð’€ / ð€/Ù/Ù/@ðˆ€ '¸ñpиñ@ð€€OöÿcOðjà h # " ‘þ÷ÍúPêéÐ h ' # " —þ÷Ãúê³ñÿ?Ñ]ç ' h©"ÿ÷åù°ñÿ??ôT¯š(Ð(%ÑmKšBÑ#“Oà’²OöþsšBÑ hÿ÷løù÷ÿ#`&µàOöÿcšB
Ñ h #" —þ÷úê³ñÿ??ô+¯#Ýç —àg³/¢Ù/Ø h # " ‘þ÷{úPê—Ð # “ h # "þ÷qúê³ñÿ?Ñ çLKOð“« h¨ëùü÷ ÿ°ñÿ??ôý®?¸E«ñÜ#hAOYð Wø!0ë‚‘ø$0šS@ð‘ø$0S@ø$0ô€?Ñ à #hYð Wø!0ë‚’ø$0ðCêÀ‚ø$0
›s¹ð Ð#hXð Wø 0ë ySð qð@C³ñ@O3Ñð0Ð K ˜h˜G›š ˜“# “«9ð AÍø ÿ÷Îü°ñÿ?ÑKh˜Gù÷‚þ#hYð Wø!0ë‚y3ðq hþ÷þæ#hYð šWø!0˜P0F°½èð # " ! “ù÷wþþÞ8°@ ø°@ àù@  X°@ ¤î@ -épH
ò …°FF FE¹ù÷+þ#`ù÷{þoð à ,ôЫª1F F • ð#ú°ñÿ?ðЛš)F ðÜûF˜ù÷Òú˜ù÷Ïú F°½èpˆ -éðO
ò ‡°F‘F’ˆFFG¹ù÷ùý#`ù÷Iþoð ™à—ù 0 +òиñ ïÐØø 0 +ëГù 0 +çÐ\!8F ðñüF8F/! ðìü » »:!8F ð*ýFî¹8Fø÷·ûFà !ù÷<ùF -ÑÐIJá þ÷Qü (sÑ:Fá (F ðý (eÑ® à±°B ÙF.!0Foð ðÀü ((F Ð ! ð:ý (HÑJFAF(Fÿ÷kÿFAàø÷…ûñ
PF!ù÷ ùFæ³*FQFþ÷ ü (OÑ(Fø÷tûƒ“ù÷ˆýh˜Oð “&Kªë ‘ñ
Zø)‰þ÷ü€» !0F ðý8±©ñ ˜™¹ñ íÚ àù÷hý›šAF`0Fÿ÷+ÿF0Fù÷!ú½BÐ(Fù÷ ú F°½èð # " ! “ù÷ý # " ! “ù÷zý # " ! “ù÷sý # " ! “ù÷lýþÞþÞXî@ Ë@ -éðH
ò ,MDð Uø$0±õ€O높ø$0yCó-бõ O&бõ€?бõ ?бõ€//ÑoðCqUø$0높ø$03ð~Sð àoðCqUø$0높ø$03ð}Sðàðq
àoðCqUø$0높ø$03ð‚ø$0ð€ÑOô @à¹Oô€@àOô€0½èðˆàù@ -é HëF8¹ù÷Ìü#`ù÷ ý àKh` ½è ˆÄù@ -éðO
ò …°™F# “’F # "F %Oð þ÷Cøê´ñÿ?‘$Ð# “ # "8Fþ÷5øê³ñÿ?кë ië # .TÛÜ ,LÐIKh˜GIKOô€R!h˜G‚FH¹ù÷ƒü #`ù÷ü h°½èðOô A8Fÿ÷DÿF .ÛÜ´õ€_ÓOô€R à"FQF8Fü÷ïù°ñÿ?Ð$fëàv .ÛèÜd±æçù÷hüh+Ñù÷Uü
#`oð ¨FIF8Fÿ÷ÿ'Kh˜G%KRF !h˜G,à .0ÜÛ ,-Ò “KFRF8Fý÷Îÿê³ñÿ?±Ð8Fþ÷(üKh˜G± %àoð _êåxê³ñÿ?Ñù÷ ü
#`
Kh˜GFù÷%ü`ê³ñÿ?Ð #š “›8Fý÷ ÿê³ñÿ?ƒÐ „çþÞ8°@ ±@ L°@ ¨°@ h°@ -éðO
ò ø÷ÈúŽ°ßøpC FF hF ’
`h "% ‰“—ø0 zFø2 h’’ F•@±ø÷¼ùCTø] (÷Ñ•!(Fø÷;ÿÈø `¹ #;`ù÷Âû #`ù÷Ìû#`oð Cá
ª¨ ! ðžû(±( ðAßøè¢'à
¨ø÷’ùñ ˜±ø÷ŒùDßøТ % . ð‹€0h'4F—@±ø÷~ùÃTø_ (÷Ñ—Úø @¤¹û÷†ýFÊø t¹ŸØø oð ’ù÷Bø %šœÈø P=`ôà”ù 0 '[±[² F=+Ðø÷UùÃ_ ãWà +õÑãW¸F—=+ Ñâ’ù0³±’ù0:+Ñ’ù0=+Ñë ø÷9ù ëñù0ë=+åÐÍø€š¨ë°Fœ3h” à
¨ø÷"ùFØø
© ðúûè±Xø? +ñÑLD! Fø÷œþ›`ع œ hø÷çÿ ##`ù÷ û #`ù÷)û#`šoð ’à#“ãç›=`Ÿ“›“àÝø$€›Øø @h
¹4à™# FÉþ÷Šù (@ð´€›Sø “ø÷Ûø\ ›hàØø 0™ FÉþ÷tù (@ð‚€›hø÷Çø$ #ø;›Sø/“ *æÑÝø€ø\%pØø @þ³Ýø€Úø 0 F¨ëÙý÷5ûãë3hÝø€›±ŸØø 02h FÙþ÷Aù (VÑ0hø÷–ø\ Vø? +ìћù
ªIF Fþ÷/ù (RÑ1JIF F ðôù (DÑš2±IF F ðìù ±'àšLD àš<±Øø 0œBÑ%p4%pš $Úø ±ø÷Aÿš #Êø 0±Fø÷9ÿ F°ø÷Sù½èð # " ! “ù÷œú # " ! •ù÷•ú # " ! •ù÷Žú # " ! •ù÷‡ú # " ! •ù÷€ú # " ! •ù÷yú # " ! •ù÷rúþÞþÞ$Ë@ ¼î@ Ë@ -éðO
ò Ÿ°FOð
Oð “‘F±.Ð Ý.Ý.ÑOð ’ù 0’Ó± ! àù÷&ú #`ù÷ú#`ù÷dúÃà2’ù 0 +úÑ’ù0 ±p2’ù 0 +òѨD" !ø÷<úD#“ù÷úø (Àòª€`Kßøx hŒ±a KXø#0ð ë‚“ù0¹<9 ,ñÑ ,Àò€Cò23œB€ðŠ€ë„3˜²!øj ø÷Bý (}Ð`šOð ! ê ,ÝKXø#0ð ë‚yðÑph;`à€ø à=`107¡BèÛš¹ñ Ð ! ,Ú#F à#™BÚ øëBø[1òçOð
ù÷Ÿù
«“«“›)L "“™$h#`˜ “’ # "Íø G!KFh˜GF˜ø÷9þ ¹8Fù÷ù&à.(Ð~¹K
˜)Fh˜GK
˜ ©h˜GK
˜ h˜Gà.Ñ
K
˜h˜G % à
K ˜h˜Gàù÷Mù #`oð (F °½èð ø÷¢ûþÞþÞø°@ °@ °@ 8°@ °@ àù@ àú@ -épH
ò …°FFhFF %÷÷Hÿ4¹ù÷#ù#`ù÷sù"à˜ƒh+¹1F F ðáùFà"xPú‚ó[~Fð
Ð4"x*±Bê#žBÑe à - à–B Ñ%F *ñåÑø 0#±šo3ðg(F°½èpˆ "ÿ÷¹¿ -é?H
ò
FFhFF÷÷ÿ4¹ù÷Ýø#`ù÷-ù à˜ƒh»¹)F F ðµùFàPú‚ó[~ðÐ4#xs±Cê#BÑ< àBÐ4"x *FéÑ•B Ð $ø 0#±šo3ðg F°½è0ˆ "ÿ÷½¿ -éH
ò F±±\¹ #pù÷šø#`ù÷êø$ F½èˆF’ù 0±29ùÑ)¹ #pù÷†ø$à”ù 0Uñ ±9÷ÑA¹ #pù÷vø"$`ù÷ÆøÛç $Ùç -éH
ò F FK±iFFø÷sù¹ù÷^øhà ˜!F ðNùF ˜ø÷ý F½èˆ -éðH
ò KMFh,h ³<¹Khë± ðzùй,hı¿±8F÷÷!þ%hFà(F÷÷þ°BÙ«W=+Ñ2F9F(F ðú0±Tø_ -íÑ ½èðˆ#h›X ùçþÞ˜î@ ”î@ üú@ -éüK
ò oF‚°F FF ø÷8ý=¹ù÷ø#`ù÷Wø#.àOð Åø ±Äø .îÐ0Fÿ÷¥ÿ€Fø±÷÷ÙýF !0F÷÷Üý(`8¹ø÷èÿ #`ø÷äÿhàBF1Fý÷lþ8±Íø # " ! ù÷ ø±&` #;` ðø8h àxh°½èð‹ µ ø÷
ý ½-éÿH
ò FFF¹ |àhFF÷÷Øý™‹h+¹:F1F(F ðîùgà±F¹ø÷©ÿ#`ø÷ùÿoð @\àø+?Qú‚ó[~ðÐ+x ¹ "àCê"‹‰5šBÓˉšBØ ŠàKŠšB
Ó‹ŠšB
ØËŠ›š²àPC~ðÐø!ø Qú€ó[~ðÐ3x ¹ àCê ‹‰6˜BÓˉ˜BØ ŠàKŠ˜B
Ó‹Š˜B
ØËŠ˜²àDc~ðДø‚BÑ
± /©Ñ àÙ àoð ø 0#±šo3ðg°½èðˆ #ÿ÷s¿ -éH
ò Fù; +ûÑJ²8 BÐù 0“BøÑù 0J²“B Ð ½èˆ ù 0;±J²“BÐ0ù 0 +øÑù 0J²“B Ð pG-éH
ò ÷÷ÚýŠ° FX¹ø÷
ÿ #`ø÷ûþ#`ø÷Kÿ %à4ððÑKjF !h˜G@¹Kh˜Gø÷ÿø÷åþ hà ›ðÑð ÐðÐø÷åþ#`ø÷Óþ
#`èç
°÷÷®ý½èˆ8°@ ±@ -éðO
ò …° #“$K h2hʳ!OOð ê ¸FOð
Ø RØ ^Ø rØ ˆØ ˜Ø ¨Ø ¶Ø ÒØ âØ îØ Ù Ù *Ù Ñ@ ED@ eL@ ÁO@
E@ €@ 1@ %s %s failed to create process.
failed to get exit code from process.
-script.py Cannot open %s
#! #!python.exe Cannot find Python executable %s
Could not exec %s m s c o r e e . d l l CorExitProcess (null) ( n u l l ) EEE50 P ( 8PX 700WP `h```` xpxxxx Sun Mon Tue Wed Thu Fri Sat Sunday Monday Tuesday Wednesday Thursday Friday Saturday Jan Feb Mar Apr May Jun Jul Aug Sep Oct Nov Dec January February March April June July August September October November December AM PM MM/dd/yy dddd, MMMM dd, yyyy HH:mm:ss S u n M o n T u e W e d T h u F r i S a t S u n d a y M o n d a y T u e s d a y W e d n e s d a y T h u r s d a y F r i d a y S a t u r d a y J a n F e b M a r A p r M a y J u n J u l A u g S e p O c t N o v D e c J a n u a r y F e b r u a r y M a r c h A p r i l J u n e J u l y A u g u s t S e p t e m b e r O c t o b e r N o v e m b e r D e c e m b e r A M P M M M / d d / y y d d d d , M M M M d d , y y y y H H : m m : s s e n - U S j a - J P z h - C N k o - K R z h - T W ¶@ ¶@ ¶@ ,¶@
!"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ R 6 0 0 2
- f l o a t i n g p o i n t s u p p o r t n o t l o a d e d
R 6 0 0 8
- n o t e n o u g h s p a c e f o r a r g u m e n t s
R 6 0 0 9
- n o t e n o u g h s p a c e f o r e n v i r o n m e n t
R 6 0 1 0
- a b o r t ( ) h a s b e e n c a l l e d
R 6 0 1 6
- n o t e n o u g h s p a c e f o r t h r e a d d a t a
R 6 0 1 7
- u n e x p e c t e d m u l t i t h r e a d l o c k e r r o r
R 6 0 1 8
- u n e x p e c t e d h e a p e r r o r
R 6 0 1 9
- u n a b l e t o o p e n c o n s o l e d e v i c e
R 6 0 2 4
- n o t e n o u g h s p a c e f o r _ o n e x i t / a t e x i t t a b l e
R 6 0 2 5
- p u r e v i r t u a l f u n c t i o n c a l l
R 6 0 2 6
- n o t e n o u g h s p a c e f o r s t d i o i n i t i a l i z a t i o n
R 6 0 2 7
- n o t e n o u g h s p a c e f o r l o w i o i n i t i a l i z a t i o n
R 6 0 2 8
- u n a b l e t o i n i t i a l i z e h e a p
R 6 0 3 0
- C R T n o t i n i t i a l i z e d
R 6 0 3 1
- A t t e m p t t o i n i t i a l i z e t h e C R T m o r e t h a n o n c e .
T h i s i n d i c a t e s a b u g i n y o u r a p p l i c a t i o n .
R 6 0 3 2
- n o t e n o u g h s p a c e f o r l o c a l e i n f o r m a t i o n
R 6 0 3 3
- A t t e m p t t o u s e M S I L c o d e f r o m t h i s a s s e m b l y d u r i n g n a t i v e c o d e i n i t i a l i z a t i o n
T h i s i n d i c a t e s a b u g i n y o u r a p p l i c a t i o n . I t i s m o s t l i k e l y t h e r e s u l t o f c a l l i n g a n M S I L - c o m p i l e d ( / c l r ) f u n c t i o n f r o m a n a t i v e c o n s t r u c t o r o r f r o m D l l M a i n .
R 6 0 3 4
- i n c o n s i s t e n t o n e x i t b e g i n - e n d v a r i a b l e s
D O M A I N e r r o r
S I N G e r r o r
T L O S S e r r o r
r u n t i m e e r r o r ȶ@ (·@ €·@
Ø·@ ¸@ x¸@ ظ@ ¹@ x¹@ è¹@ 8º@ ¨º@ »@ d»@ ¨»@ p¼@ ! ؼ@ " Ⱦ@ x 0¿@ y P¿@ z l¿@ ü ˆ¿@ ÿ ¿@ R u n t i m e E r r o r !
P r o g r a m : < p r o g r a m n a m e u n k n o w n > . . .
M i c r o s o f t V i s u a l C + + R u n t i m e L i b r a r y À À – À À Ž À À À ‘ À ’ À “ À ´ À µ À €€†€€ †€†‚€EEE……… 00€P€ˆ ('8PW€ 700PPˆ (€ˆ€€ `h`hhhxppwpp ( ( ( ( ( H „ „ „ „ „ „ „ „ „ „ ‚ ‚ ‚ ‚ ‚ ‚ h ( ( ( ( H „ „ „ „ „ „ „ „ „ „ ‚‚‚‚‚‚ H €‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ ¡¢£¤¥¦§¨©ª«¬®¯°±²³´µ¶·¸¹º»¼½¾¿ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖ×ØÙÚÛÜÝÞßàáâãäåæçèéêëìíîïðñòóôõö÷øùúûüýþÿ
!"#$%&'()*+,-./0123456789:;<=>?@abcdefghijklmnopqrstuvwxyz[\]^_`abcdefghijklmnopqrstuvwxyz{|}~€‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ ¡¢£¤¥¦§¨©ª«¬®¯°±²³´µ¶·¸¹º»¼½¾¿ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖ×ØÙÚÛÜÝÞßàáâãäåæçèéêëìíîïðñòóôõö÷øùúûüýþÿ€‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ ¡¢£¤¥¦§¨©ª«¬®¯°±²³´µ¶·¸¹º»¼½¾¿ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖ×ØÙÚÛÜÝÞßàáâãäåæçèéêëìíîïðñòóôõö÷øùúûüýþÿ
!"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`ABCDEFGHIJKLMNOPQRSTUVWXYZ{|}~€‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ ¡¢£¤¥¦§¨©ª«¬®¯°±²³´µ¶·¸¹º»¼½¾¿ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖ×ØÙÚÛÜÝÞßàáâãäåæçèéêëìíîïðñòóôõö÷øùúûüýþÿÀ÷@ ø@ U S E R 3 2 . D L L MessageBoxW GetUserObjectInformationW GetLastActivePopup GetActiveWindow GetProcessWindowStation C O N O U T $ CreateFile2 k e r n e l 3 2 . d l l .cmd .bat .exe .com .\ SystemRoot = m !Y àj àéèÕÿ E ñÿÿÿ c €; à_ àb à Ôÿ î "K à– àß àê àè‚èßÿ E Ùÿÿÿ p 03Çü¨¾ÿïÿ * e û € àÿýÿ À à ýÿ € àÄÔÿÄ ýÿy 03Çü¯øÿïÿ * å • ¿ Çü¨¾ÿ * Ã! #" ?" %" U 03Çü©þÿïÿ * ³$ ï$ !% ‹$ ÿ$ % = Çü©þÿ * Y% µ% ¿% 6 Çü¨ðÿ * 7' S' ]' A°!Çüßÿ * ³'
* #* '°3èžèüßÿèßÿ E Ùÿÿÿ: 03Çü¨ÿïÿ * 8 8 )8 ç7 ÿ7 38 b 03Çü¨ÿïÿ * ×8 û8
9 §8 Í8 9 ( Çü¨œÿ * ·= Å= Ù= § 0DéLèü¨pÿè¨pÿ E éÿÿÿ G Çü¨¸ÿ * @ _@ s@ Ê °3èü«ðÿè«ðÿE ÝÿÿÿÇ Çü«üÿ * _C ùC 'D Çü¨¸ÿ * 'E 1E 9E š "ü¨üÿïÿ íÿ » °3Çü©ðÿ‰ðïÿ* I ÷I 7J
Çü¨ˆÿ * oJ qJ qJ ' Çü¨¸ÿ * K ÅK ÏK ÅK V Çü¯øÿ * ±L CM MM · @ àè‚èü¨pÿè¨pÿ E éÿÿÿ¬0Uù¼üüèüßÿ÷¼èßÿ E Ùÿÿÿ\ 03Çü¯øÿïÿ * /] a] ‰] \ 03Çü©øÿïÿ * ó] 5^ U^ ) 03Çü¨¸ÿïÿ * _ _ #_ lû¨ ÿ € àü¯øÿ¯øÿÿ € àü¯øÿ¯øÿÿ € àìÿýÿ O € M àü¨ðÿ¨ðÿÿe € c àü¨ðÿ¨ðÿÿ y €0C à
ü¨ðÿˆðïÿ | °3ÇèüßÿèßÿE Ùÿÿÿ 0§ àÇèüßÿèßÿE Ùÿÿÿb 17 à] àüÛüÿÛüýÿÛüýÿh A; àc à
üÛüûûÿÛüýÿÛüýÿ ÿ h 03ÇüßÿÛïÿ * et t Ét ¼ €! àüßÿ ´ 03èüßÿèßÿ E Ùÿÿÿ À
à ýÿ
€ àì`ÿì`üýÿ c € àü¨ðÿ # "ü¨ ÿïÿ 5 03Çü¨ÿïÿ * Ý| õ| } ® °!Çüßÿ * Ç} ß} ¿~ } §~ µ~ U 03Çü©øÿïÿ * € 7€ _€ > 03Çü¨ÿÿˆðïÿ * g ¡ i 03Çü¯øÿïÿ * aˆ “ˆ »ˆ €
àüßÿ Ï €° àüßÿ » €A àüßÿ »0…àèüßÿèßÿ E Ùÿÿÿ õ €ï à üßÿ M °"Çü«üÿ«ðÿ* 9œ «œ »œ @ °3
èü¨ÿè¨ÿE ñÿÿÿN €H àüßÿ K€k àüßÿ P°3Ç èüßÿ èßÿE ÙÿÿÿÓ ÄØ ° $Ô @Ô RÔ jÔ €Ô –Ô ¬Ô ÄÔ ÜÔ ìÔ üÔ Õ $Õ 6Õ LÕ \Õ jÕ |Õ „Õ œÕ ¨Õ ÐÕ âÕ ðÕ Ö Ö $Ö 0Ö FÖ VÖ bÖ nÖ xÖ ŠÖ œÖ ²Ö ÐÖ ÜÖ æÖ ôÖ × × $× 6× P× f× €× š× ´× Æ× Ô× æ× ö×
Ø Ø .Ø >Ø RØ ^Ø rØ ˆØ ˜Ø ¨Ø ¶Ø ÒØ âØ îØ Ù Ù *Ù ¼GenerateConsoleCtrlEvent ë CreateProcessA ÏSetConsoleCtrlHandler CGetExitCodeProcess ¹WaitForSingleObject yGetModuleFileNameA ?EnterCriticalSection ³LeaveCriticalSection DecodePointer ;EncodePointer }GetModuleHandleExW ²GetProcAddress , AreFileApisANSI áMultiByteToWideChar gGetLastError lExitProcess áGetCommandLineA ]Sleep DeleteCriticalSection MHeapFree bInitializeCriticalSectionAndSpinCount ÔGetStartupInfoW UGetFileType ÚGetStdHandle ]InitOnceExecuteOnce ¹RtlUnwindEx IHeapAlloc 'GetCurrentThreadId SetLastError ÌGetCPInfo GetOEMCP ½GetACP ƒIsValidCodePage ¸LoadLibraryExW GetCurrentPackageId OSetUnhandledExceptionFilter §FlsAlloc ¨FlsFree ©FlsGetValue ªFlsSetValue zGetModuleFileNameW ïWriteFile ·GetProcessHeap >GetEnvironmentStringsW ÛWideCharToMultiByte ¶FreeEnvironmentStringsW 1QueryPerformanceCounter ñGetSystemTimeAsFileTime GetTickCount64 PHeapReAlloc GetConsoleMode õGetConsoleCP ¬FlushFileBuffers ßGetStringTypeW ¥ CompareStringEx ¦LCMapStringEx SetFilePointerEx RHeapSize yIsDebuggerPresent
OutputDebugStringW îWriteConsoleW .SetStdHandle Ž CloseHandle Ö CreateFileW KERNEL32.dll KReadConsoleW MReadFile ~GetModuleHandleW öSetEndOfFile IGetFileAttributesExW ùSetEnvironmentVariableA û@ û@ ÿÿÿÿ€
!
5 A
C P R
S
W Y l
m p r €
‚ ƒ „
‘ ) ž
¡ ¤ §
· Î × 4²@ <²@ ÿÿÿÿþÿÿÿC ¬²@ °²@ ´²@ ¸²@ ¼²@ À²@ IJ@ Ȳ@ в@ ز@ à²@ ì²@ ø²@ ³@ ³@ ³@ ³@ ³@ ³@ ³@ $³@ (³@ ,³@ 0³@ 4³@ 8³@ <³@ D³@ P³@ X³@ ³@ `³@ h³@ p³@ x³@ „³@ Œ³@ ˜³@ ¤³@ ¨³@ ¬³@ ¸³@ ̳@ س@ à³@ è³@ ð³@ ø³@ ´@ ´@ ´@ ´@ 0´@ @´@ T´@ h´@ x´@ Œ´@ ”´@ œ´@ ¤´@ ¬´@ ´´@ ¼´@ Ä´@ Ì´@ Ô´@ Ü´@ ä´@ ì´@ ü´@ µ@ µ@ ¬´@ (µ@ 4µ@ @µ@ Pµ@ dµ@ tµ@ ˆµ@ œµ@ ¤µ@ ¬µ@ Àµ@ èµ@ üµ@ `å@ `å@ `å@ `å@ `å@ ðì@ 0Ã@ ¸Ç@ 8É@ hå@ Ðæ@ ˆè@ ¤ `‚y‚! ¦ß ¡¥ Ÿàü @~€ü ¨ Á£Ú£ þ @þ µ Á£Ú£ þ Aþ ¶ Ï¢ä¢ å¢è¢[ þ @~¡þ Q QÚ^Ú _ÚjÚ2 ÓØÞàù 1~þ abcdefghijklmnopqrstuvwxyz ABCDEFGHIJKLMNOPQRSTUVWXYZ abcdefghijklmnopqrstuvwxyz ABCDEFGHIJKLMNOPQRSTUVWXYZ 4Å@ Næ@»±¿Dÿÿÿÿ‘w@ ‘w@ ‘w@ ‘w@ ‘w@ ‘w@ ‘w@ ‘w@ ‘w@ ‘w@ . . èì@ ¸÷@ ¸÷@ ¸÷@ ¸÷@ ¸÷@ ¸÷@ ¸÷@ ¸÷@ ¸÷@ ìì@ ¼÷@ ¼÷@ ¼÷@ ¼÷@ ¼÷@ ¼÷@ ¼÷@ ðì@ 0Ã@ 2Å@ þÿÿÿ ôÊ@ üÊ@ Ë@ Ë@ aý ñaý… aý
8Ë é M` ý XË Ù pË Ñ ©`1 1 Q`0ýa y`0ý¥ Y`0ý) ˜Ë ` - ]`0ý] i`0ý‘ í`1 Á p} õ€1ù ÀË ÌË - ØË E I`? i åc¶ý] ³ A`°ý9 Ua2ýå ]`0ý5 q`0ýq Ia´ý! 1`0ý= å`1 Í èË ¿ ` ! A`0ý=! Ì ?" ` q" %`? …" `6ýÝ" •`5 1# •`5 …# ‰`5 Ñ# ¹`2ý-$ }`0ým$ 8Ì % ` !% %` E% pÌ ¿% ` Õ% a`0ý& a`3 M& ©`5 ©& Y`1 ñ& ˜Ì ]' ` }' 9`? ¡' ÀÌ #* ` Q* I`0ý* ñö, …`0ýM, -`? i, -`? …, E`0ý¹, i`uýõ, 5`ý- A`? 1-
a3 Á- ]`0ýñ- ‘`0ý9. Ù`6ý¥. èÌ
7 é`4ý7 I`0ýµ7 Í )8 ` 38 ` I8 8Í
9 ` 9 ` 19 Å`2ý¥9 ½`1 : 9`0ý-:
b2ý9; b2ýI< Ýa4ýE= }`1 ‰= pÍ Ù= ` )> Å`0ý‘> ˜Í å? ¸Í s@ ` …@ Å põ@ àÍ ™B øÍ 'D ` ED A`0ýiD Iò
E Î 9E ` ME HÎ F TÎ ÉF )`°ýÝF © r=G 5`0ýYG Ýa3 UH Q`0ýÁH `Î 7J ` ]J ˆÎ yJ -`? ÙJ q`0ýEK u`1 K °Î åK A`2ý
L I`1 9L I`1 eL a`0ý¡L ØÎ MM ` eM 1`? }M U`0ýM Ï EO a`? ÁO %`? ÙO m`? !P 9`? EP 5tíP Uc6ý™R 5rQS auý!T Ùa3 1U Ý 1ÁU ½`3 !V =a6ýÑV ý`5 ]W Ï Ñ\ @Ï ‰] ` ] hÏ U^ ` q^ ½`3 Ñ^ Ï #_ ` -_ ¸Ï M_ ÄÏ a_ ÔÏ u_ äÏ _ ½`0ýÕb ôÏ uc Ð Ad q pyd u pµd Ð ±e )`°ýåe aa1 ™f `1 íf e0ýyi 0Ð yj rÁj HÐ ál ò1n dÐ ío |Ð ½p 9a3 Yq Õ`0ýÅq `0ý1r M ð]r M ð%s ˜Ð -s ‘`1 ys å€rùs Ð Ét `PýÝt ÈÐ Uv Ù ñýÉv 9a3 ew Q`? ™w Y`? Íw ØÐ iy ±`0ýÁy ðÐ Ýy üÐ ùy Ñ Íz Ñ { í`3 ¥{
a2ý=| Ý`0ýµ| 0Ñ } ` Y} XÑ µ~ ` ¿~ ` Ý~ e`0ý 1a2ýµ Ñ _€ ` q€ ] pÙ€ ™ r% ¸Ñ ¡ a Õ å öé‡ àÑ »ˆ ` ͈ }`?
‰ t¡‰ Ò á ½ rA Ò é‘ ya3 ©’ I`? Ñ’ (Ò ]” 8Ò á— XÒ é™
ryš ñý› Ý`0ýq› u`0ý› Í`3 !œ hÒ »œ `PýÅœ )óýá e`0ý9ž Ò Áž ¨Ò iŸ 1t u`1 E
óýÍ ¡`0ý!¡ ¸Ò É£ =3i¤ ÈÒ § • r]§ ¥11¨ `²ý x ¶qÜqìrør0s8sPstsˆsšs¦s¼säs$tXt¤t¸tît€uÌ5$6(6,6X6\6œ6 6Ð6 77$7889 99t9x9úyz>> > >l>?? ?8?°?´?¸?¼?À?Ä?È? ˜ Ì0Ð0Ô0Ø0Ü0à0ä0è0ì0ð0L2P2T2X2\2`2d2h2l2Ô2Ø2(3,3|3€3È3Ì34585È5Ì5Ð566 6@6D6H6 6¤6Ô6Ø6è6ì6l7p7t7x7˜7œ7,:0:4:8:<:@:D:H:L:t:x:|:ø;ü;HŒ>à? @ ˜ |0€0è0ì0ð0ˆ2Œ22”2044484<4@4d4D5H5€6„6˜6À6Ä6P8|8€8Œ8˜8¨8¸8¼8D:H:L:P:T:X::”:˜:¤:°:¼:È:Ô:;;Œ{<<0<4<\<`<”<˜<œd>h>l>à?ä? ` ¨5¬5Ü5à5”6è6p:t:Ø<Ü< p l X2„2t3ì3ð3ô3Ô4Ø4Œ7Ä7È74989<9@9D9H9L9P9T9X9\9`9d9À:;;”;˜;œ; ;,<0<4<8<¬<°<(=,=0=P=T=È>Ì>Ð>Ô>Ø>¨?¬?°? € D h0l0 0¤0¨0Ä0È0ÌpÐ1È7Ì7Ð7Ô7Ø7Ü7à7ä7Ä8È8Œ99”9˜9œ9È?Ì?Ð?Ø?Ü? < à1ä1¤2Ì2H4L4P4T4X4Ô7Ø7Ü7Ì9Ð9Ô9Ø9Ü9à9ä9<< <¸>¼>\?`? 1¸3¼3À3Ä37 7 ° 4 (1,10141@1D1H186<6@6D6´?¼?Ä?Ì?Ô?Ü?ä?ì?ô?ü? À ( 0 00 0$0,040<0D0L0T0\0d08:<: à 00P5T5h5l5p5t5x5|5€5„5ˆ5Œ55”5˜5œ5 5¤5¨5¬5°5´5¸5¼5À5Ä5È5Ì5Ð5Ô5Ø5Ü5à5ä5è5ì5ð5ô5ø5ü5 666 66 6 6$6(6,6064686<6@6D6H6L6P6T6X6\6`6d6h6l6p6t6x6|6€6„6ˆ6Œ66”6˜6œ6 6¤6¨6¬6°6´6¸6¼6À6Ä6È6ô677$747T7`7d7h7l7ˆ7”7°<À<Ä<È<Ì<Ð<Ô<Ø<Ü<à<ä<ð<ô<ø<ü< === === =$=(=,=0=4=8=<=@=D=H=X>\>`>d> setuptools-20.7.0/setuptools/cli.exe 0000664 0001750 0001750 00000200000 12702524020 020342 0 ustar travis travis 0000000 0000000 MZ ÿÿ ¸ @ à º ´ Í!¸LÍ!This program cannot be run in DOS mode.
$ YSþj 29 29 29:ôë9 29 2‘9F29 }929`9929`929`9m29`9 29Rich 29 PE L ø°‹Q à Ê N ç% à @ @ € ,ù ( ˆô @ à @ .text ]É Ê `.rdata ` à " Î @ @.data Ä+ ð @ À Q‹D$PŠ@„ÉuùSUV+ÂW‹èD-jPès
ƒÄ3ÿ3Û‰D$Æ "p…í~Wë› ‹L$Š <\uGë <"u…ÿ~Wj\Vè
ƒÄ ÷3ÿÆ\Fë3ÿ‹T$ŠˆCF;Ý|Ã…ÿ~Wj\VèV
ƒÄ ÷‹D$_Æ"ÆF ^][YÃì ¡€A 3ĉ„$ V‹´$ W‹¼$ Š‹Ï„Àtd$ A ƒÀ@Pè ƒÄ F^‹Œ$ 3Ìè! Ä ÃWh Œ$ QV虫 V¼, 訊 „$, ƒÄH@;ÇsŠ„Ét
€ù
t€ù
uëj”$ hâ@ RÆ èT
ƒÄ …Àt2¡â@ ‹
â@ ‹ â@ ‰„$ â@ ‰Œ$ ‰”$$ ˆ„$( L$Q”$" Rè…ûÿÿ‹0‰D$ D$$PVè$úÿÿ‹øƒÄ‰|$ …ÿu Vhàá@ éµ S‹\$ U‹¬$, +‰D$ @jPèå ‹ðW‰t$ èCùÿÿ‰¿ ƒÄ ƒÆ;ß~ ‹ÿ‹L$ ‹¹Rè#ùÿÿ‰GƒÄƒÆ;û|æD$$Pè ùÿÿ‰¿ ƒÄƒÆ;ï~‹L$‹¹Rèîøÿÿ‰GƒÄƒÆ;ý|惼$4 ]Ç [tE‹D$‹t$ PVè$¤ ƒÄVhÌá@ è“ ƒÀ@Pèn ƒÄ _¸ ^‹Œ$ 3Ìès Ä Ã‹L$‹T$‹D$ QRPè†üÿÿPèÀûÿÿ‹Œ$, ƒÄ_^3Ìè? Ä ÃÌÌÌÌÌÌ‹D$‹L$j PQè ýÿÿƒÄ Ãj hðô@ èŸ 3ö‰uä3À‹];Þ•À;Æu è; Ç VVVVVèà ƒÄƒÈÿéÍ 3À9u •À;ÆtÔ‰]SèŸ Y‰uüöC @uwSè* Yƒøÿtƒøþt‹ÐÁú‹Èƒá Áá • *A 빘A öA$u)ƒøÿtƒøþt‹ÈÁùƒà Áà *A 븘A ö@$€t è¡ Ç VVVVVè) ƒÄƒMäÿ9uäu#SèL
‹øEPVÿu Sè² ‰EäSWèÎ
ƒÄ ÇEüþÿÿÿè ‹Eäèß ÃÿuèL Yø A áÀ;A Vj^…Àu¸ ë;Æ}‹Æ£À;A jPè“ YY£¼+A …Àu jV‰5À;A èz YY£¼+A …ÀujX^Ã3Ò¹ A 롼+A ‰ ƒÁ ƒÂù€A |êjþ^3Ò¹A W‹ÂÁø‹… *A ‹úƒç Á狃øÿt;Æt…Àu‰1ƒÁ BùpA |Î_3À^Ãè§# €=0 A tèp! ÿ5¼+A è× YËÿU‹ìV‹u¸ A ;ðr"þ`A w‹Î+ÈÁùƒÁQèç$ N € Yë
ƒÆ Vÿà@ ^]ËÿU‹ì‹Eƒø}ƒÀPèº$ ‹E H € Y]ËE ƒÀ Pÿà@ ]ËÿU‹ì‹E¹ A ;Ár =`A w` ÿÿÿ+ÁÁøƒÀPè—# Y]ÃÀ Pÿ à@ ]ËÿU‹ì‹Mƒù‹E }` ÿÿÿƒÁQèh# Y]ÃÀ Pÿ à@ ]ËÿU‹ìQƒeü VEüPÿu ÿuèL$ ‹ðƒÄ …öu9Eütèa …Àt
èX ‹Mü‰‹Æ^ÉÃÌÌÌÌÌÌÌÌÌÌ‹T$ ‹L$…Òti3ÀŠD$„Àuú rƒ=ˆ*A tée% W‹ùƒúr1÷Ùƒát +шƒÇƒéuö‹ÈÁàÁ‹ÈÁàÁ‹ÊƒâÁétó«…Òt
ˆƒÇƒêuö‹D$_ËD$ÃÌÌÌÌÌÌ‹L$ W…É„’ VS‹Ù‹t$÷Æ ‹|$u Áé…… ë'ŠƒÆˆƒÇƒét+„Àt/÷Æ uå‹ÙÁéuaƒãtŠƒÆˆƒÇ„Àt7ƒëuí‹D$[^_Ã÷Ç tˆƒÇƒé„˜ ÷Ç uê‹ÙÁéutˆƒÇƒëuö[^‹D$_ɃǃétŸºÿþþ~‹Ðƒðÿ3‹ƒÆ© tÜ„Òt,„öt ÷ ÿ t ÷ ÿuĉëâÿÿ ‰ëâÿ ‰ë3Ò‰ƒÇ3Àƒét 3À‰ƒÇƒéuöƒã…wÿÿÿ‹D$[^_ËÿU‹ìÿuÿuÿuÿu jÿÿuè % ƒÄ]ËÿU‹ìQQS3ÛVW‰]ø9]t}‹M ;Ëu9]uqë9]tj9]u9]u`ë9]tY9] u9] uOë9] tH9]$u>9](u>‹u3À@8 tHF;Ãwö€>:u5;Ëtƒ}‚õ jÿujÿQè%& ƒÄF‰uë9](uÂÇEø éÎ ;Ëtˆ‹u3ÿ‰]ü8 tU¾PèØ% Y…ÀtFëŠ é¤þÿÿ‹ÿU‹ìV‹uVèS Pè? YY…Àt|èÐòÿÿƒÀ ;ðu3ÀëèÀòÿÿƒÀ@;ðu`3À@ÿ A ÷F uNSW<…H A ƒ? » u Sè Y‰…ÀuFj‰F‰X‰F‰Fë
‹?‰~‰>‰^‰^N 3À_@[ë3À^]ËÿU‹ìƒ} t'V‹u ÷F tVè f ÿîÿÿƒf ƒ& ƒf Y^]ÃöA @tƒy t$ÿIx ‹ˆÿ¶Àë ¾ÀQPèå- YYƒøÿu ÃÿËÿU‹ìV‹ðë‹MŠEÿM èµÿÿÿƒ>ÿtƒ} ç^]ËÿU‹ìöG @SV‹ð‹Ùt2ƒ u,‹Eë+ŠÿM‹Ïè}ÿÿÿCƒ>ÿuèÕ ƒ8*u‹Ï°?èdÿÿÿƒ} Õ^[]ËÿU‹ììx ¡€A 3ʼnEüS‹] V‹u3ÀW‹}ÿu¤ýÿÿ‰µ´ýÿÿ‰½Üýÿÿ‰…¸ýÿÿ‰…ðýÿÿ‰…Ìýÿÿ‰…èýÿÿ‰…Ðýÿÿ‰…Àýÿÿ‰…Èýÿÿè#÷ÿÿ…öu5èM Ç 3ÀPPPPPèÓ ƒÄ€½°ýÿÿ t
‹…¬ýÿÿƒ`pýƒÈÿéÈ
öF @u^Vè@
Yº˜A ƒøÿtƒøþt‹Èƒá ‹ðÁþÁá µ *A ë‹ÊöA$u‘ƒøÿtƒøþt‹Èƒà ÁùÁà *A ë‹Âö@$€…gÿÿÿ3É;Ù„]ÿÿÿŠ‰Øýÿÿ‰àýÿÿ‰¼ýÿÿˆ•ïýÿÿ„Ò„
Cƒ½Øýÿÿ ‰ÄýÿÿŒ
ŠÂ, If90t@@;Îuô+…äýÿÿÑøë(;þu ¡A ‰…äýÿÿ‹…äýÿÿëI€8 t@;Îuõ+…äýÿÿ‰…àýÿÿƒ½Àýÿÿ …\ ‹…ðýÿÿ¨@t2© t Æ…Ôýÿÿ-ë¨t Æ…Ôýÿÿ+ë ¨tÆ…Ôýÿÿ Ç…Ðýÿÿ ‹Ìýÿÿ+àýÿÿ+Ðýÿÿö…ðýÿÿ uÿµ´ýÿÿ…ØýÿÿSj èpõÿÿƒÄ ÿµÐýÿÿ‹½´ýÿÿ…ØýÿÿÔýÿÿèvõÿÿö…ðýÿÿYtö…ðýÿÿuWSj0…Øýÿÿè.õÿÿƒÄ ƒ½Èýÿÿ ‹…àýÿÿtf…À~b‹µäýÿÿ‰… ýÿÿ·ÿ ýÿÿPjEôP…˜ýÿÿFPFè5 ƒÄ…Àu(9…˜ýÿÿt ÿµ˜ýÿÿ…ØýÿÿMôèñôÿÿƒ½ ýÿÿ Yuµë ƒØýÿÿÿë‹äýÿÿP…ØýÿÿèÊôÿÿYƒ½Øýÿÿ |ö…ðýÿÿtWSj …Øýÿÿè‚ôÿÿƒÄ ƒ½¼ýÿÿ tÿµ¼ýÿÿè ƒ¥¼ýÿÿ Y‹ÄýÿÿŠˆ…ïýÿÿ„Àt‹”ýÿÿ‹½ÜýÿÿŠÐéáõÿÿ€½°ýÿÿ t
‹…¬ýÿÿƒ`pý‹…Øýÿÿ‹Mü_^3Í[èìÿÿÉÃê*@ ë(@ )@ y)@ Å)@ Ð)@ *@ D+@ jThPõ@ èe 3ÿ‰}üEœPÿ@à@ ÇEüþÿÿÿj@j ^Vèu YY;Ç„ £ *A ‰5*A ˆ ë0Æ@ ƒÿÆ@
‰xÆ@$ Æ@%
Æ@&
‰x8Æ@4 ƒÀ@‹
*A Á ;ÁrÌf9}΄
‹EÐ;Ç„ÿ ‹8X;‰Eä¾ ;þ|‹þÇEà ë[j@j èç YY…ÀtV‹Mà *A ‰ƒ*A ë*Æ@ ƒÿÆ@
ƒ` €`$€Æ@%
Æ@&
ƒ`8 Æ@4 ƒÀ@‹Ö;ÂrÒÿEà9=*A |ë‹=*A ƒeà …ÿ~m‹E䋃ùÿtVƒùþtQŠ¨tK¨u Qÿ<à@ …Àt<‹uà‹ÆÁøƒæ Áæ4… *A ‹Eä‹ ‰ŠˆFh F Pè€* YY…À„É ÿFÿEàCƒEä9}à|“3Û‹óÁæ5 *A ‹ƒøÿt ƒøþt€N€ërÆF…ÛujöXë
‹ÃH÷ØÀƒÀõPÿ8à@ ‹øƒÿÿtC…ÿt?Wÿ<à@ …Àt4‰>%ÿ ƒøu€N@ë ƒøu€Nh F Pèê) YY…Àt7ÿFë
€N@ÇþÿÿÿCƒûŒgÿÿÿÿ5*A ÿ4à@ 3Àë3À@ËeèÇEüþÿÿÿƒÈÿèc ËÿU‹ì‹EV3ö;Æu è½ VVVVVÇ èE ƒÄƒÈÿë‹@^]ËÿU‹ì‹E£P A ]ËÿU‹ìì( ¡€A 3ʼnEüƒ¥Øüÿÿ SjL…Üüÿÿj Pè åÿÿ…Øüÿÿ‰…(ýÿÿ…0ýÿÿƒÄ ‰…,ýÿÿ‰…àýÿÿ‰Üýÿÿ‰•Øýÿÿ‰Ôýÿÿ‰µÐýÿÿ‰½ÌýÿÿfŒ•øýÿÿfŒìýÿÿfŒÈýÿÿfŒ…ÄýÿÿfŒ¥ÀýÿÿfŒ¼ýÿÿœ…ðýÿÿ‹EMÇ…0ýÿÿ ‰…èýÿÿ‰ôýÿÿ‹Iü‰äýÿÿÇ…Øüÿÿ ÀÇ…Üüÿÿ ‰…äüÿÿÿXà@ j ‹ØÿTà@ …(ýÿÿPÿPà@ …Àu …Ûujèé1 Yh ÀÿLà@ PÿHà@ ‹Mü3Í[è(èÿÿÉËÿU‹ìÿ5P A è& Y…Àt]ÿàjèª1 Y]é²þÿÿ‹ÿU‹ì‹E3É;ÍØA tAƒù-rñHíƒùwj
X]ËÍÜA ]ÃDÿÿÿjY;ÈÀ#ÁƒÀ]Ãèœ …Àu¸@A ÃÀÃè‰ …Àu¸DA ÃÀ ËÿU‹ìVèâÿÿÿ‹MQ‰è‚ÿÿÿY‹ðè¼ÿÿÿ‰0^]ÃÌÌÌhÐ7@ dÿ5 ‹D$‰l$l$+àSVW¡€A 1Eü3ÅP‰eèÿuø‹EüÇEüþÿÿÿ‰EøEðd£ ËMðd‰
Y__^[‹å]QÃÌÌÌÌÌÌÌ‹ÿU‹ìƒìS‹] V‹s35€A W‹ÆEÿ ÇEô {ƒøþt
‹NÏ3 8èÙæÿÿ‹N ‹FÏ3 8èÉæÿÿ‹Eö@f… ‹MUè‰Sü‹[ ‰Eè‰Mìƒûþt_I [‹L†D†‰Eð‹ ‰Eø…Ét‹×è$1 ÆEÿ…À|@G‹Eø‹Øƒøþu΀}ÿ t$‹ƒøþt
‹NÏ3 8èVæÿÿ‹N ‹VÏ3 :èFæÿÿ‹Eô_^[‹å]ÃÇEô ëÉ‹M9csmàu)ƒ=Œ*A t hŒ*A èƒ! ƒÄ…Àt‹UjRÿŒ*A ƒÄ‹M èÇ0 ‹E 9X th€A W‹Ó‹ÈèÊ0 ‹E ‹Mø‰H ‹ƒøþt
‹NÏ3 8èÃåÿÿ‹N ‹VÏ3 :è³åÿÿ‹Eð‹H‹×è]0 ºþÿÿÿ9S „Rÿÿÿh€A W‹Ëèu0 é ÿÿÿ‹ÿU‹ìVW3öÿuèÅ0 ‹øY…ÿu'9T A v Vÿ$à@ †è ;T A vƒÈÿ‹ðƒøÿuÊ‹Ç_^]ËÿU‹ìVW3öj ÿu ÿuèE ‹øƒÄ …ÿu'9T A v Vÿ$à@ †è ;T A vƒÈÿ‹ðƒøÿuËÇ_^]ËÿU‹ìVW3öÿu ÿuèû0 ‹øYY…ÿu,9E t'9T A v Vÿ$à@ †è ;T A vƒÈÿ‹ðƒøÿuÁ‹Ç_^]ËÿU‹ìVW3öÿuÿu ÿuèÅ2 ‹øƒÄ …ÿu,9Et'9T A v Vÿ$à@ †è ;T A vƒÈÿ‹ðƒøÿu½‹Ç_^]Ãj hpõ@ è×üÿÿ‹u…ötuƒ=„*A uCjè Yƒeü Vè×2 Y‰Eä…Àt VPèø2 YYÇEüþÿÿÿè ƒ}ä u7ÿuë
jè YÃVj ÿ5t)A ÿ`à@ …Àuè üÿÿ‹ðÿ\à@ PèÐûÿÿ‰Yè›üÿÿÃjhõ@ èIüÿÿ3Û‰]äjè– Y‰]üj_‰}à;=À;A }W‹÷Á桼+A Æ9tD‹ ö@ ƒtPèj= YƒøÿtÿEäƒÿ|(¡¼+A ‹ƒÀ PÿDà@ ¡¼+A ÿ4èýþÿÿY¡¼+A ‰ GëžÇEüþÿÿÿè ‹EäèüÿÿÃjè7 YËÿU‹ìSV‹u‹F ‹È€á3Û€ùu@© t9‹FW‹>+ø…ÿ~,WPVèeùÿÿYPè‡D ƒÄ ;Çu‹F „Àyƒàý‰F ëƒN ƒËÿ_‹Fƒf ‰^‹Ã[]ËÿU‹ìV‹u…öu Vè5 Yë/Vè|ÿÿÿY…ÀtƒÈÿë ÷F @ tVèüøÿÿPèûD Y÷ØYÀë3À^]Ãjh°õ@ èúúÿÿ3ÿ‰}ä‰}ÜjèD Y‰}ü3ö‰uà;5À;A ƒ ¡¼+A °98t^‹ ö@ ƒtVPVèDÝÿÿYY3ÒB‰Uü¡¼+A ‹°‹H öÁƒt/9UuPèJÿÿÿYƒøÿt ÿEäë9}uöÁtPè/ÿÿÿYƒøÿu E܉}üè Fë„3ÿ‹uࡼ+A ÿ4°VèMÝÿÿYYÃÇEüþÿÿÿè ƒ}‹Eät‹EÜè{úÿÿÃjè YÃjè ÿÿÿYËÿVW3ö¿X A ƒ<õLA u õHA ‰8h ÿ0ƒÇè}! YY…Àt Fƒþ$|Ò3À@_^Ã$õHA 3Àëñ‹ÿS‹ Dà@ V¾HA W‹>…ÿtƒ~t
WÿÓWèÐüÿÿƒ& YƒÆþhA |ܾHA _‹…Àt ƒ~uPÿÓƒÆþhA |æ^[ËÿU‹ì‹Eÿ4ÅHA ÿ à@ ]Ãj hØõ@ è^ùÿÿ3ÿG‰}ä3Û9 t)A uè´ j è hÿ è€ãÿÿYY‹u4õHA 9 t‹Çënjè ûÿÿY‹ø;ûuèÅøÿÿÇ 3ÀëQj
èY Y‰]ü9 u,h Wèt YY…ÀuWèþûÿÿYèøÿÿÇ ‰]äë ‰>ëWèãûÿÿYÇEüþÿÿÿè ‹EäèöøÿÿÃj
è(ÿÿÿYËÿU‹ì‹EV4ÅHA ƒ> uPè"ÿÿÿY…ÀujètâÿÿYÿ6ÿà@ ^]Ãj høõ@ èhøÿÿ‹M3ÿ;Ïv.jàX3Ò÷ñ;E À@u èÿ÷ÿÿÇ WWWWWè‡÷ÿÿƒÄ3ÀéÕ ¯M ‹ñ‰u;÷u3öF3Û‰]äƒþàwiƒ=„*A uKƒÆƒæð‰u ‹E;p*A w7jèLÿÿÿY‰}üÿuèè5 Y‰EäÇEüþÿÿÿè_ ‹]ä;ßtÿuWSè6ÛÿÿƒÄ ;ßuaVjÿ5t)A ÿdà@ ‹Ø;ßuL9=€)A t3Vè’ Y…À…rÿÿÿ‹E;Ç„PÿÿÿÇ éEÿÿÿ3ÿ‹u jèðýÿÿYÃ;ßu
‹E;ÇtÇ ‹Ãèœ÷ÿÿÃU‹ìƒì‰}ü‹}‹M ÁéfïÀë¤$ ffGfG fG0fG@fGPfG`fGp¿€ IuЋ}ü‹å]ÃU‹ìƒì‰}ü‹E™‹ø3ú+úƒç3ú+ú…ÿu<‹M‹Ñƒâ‰Uô;Êt+ÊQPèsÿÿÿƒÄ‹E‹Uô…ÒtEE+‰Eø3À‹}ø‹Môóª‹Eë.÷߃lj}ð3À‹}‹Mðóª‹Eð‹M‹UÈ+ÐRj Qè~ÿÿÿƒÄ ‹E‹}ü‹å]Ãj hö@ èdöÿÿƒeü f(ÁÇEä ë#‹Eì‹ ‹ = Àt
= Àt3ÀÃ3À@Ëeèƒeä ÇEüþÿÿÿ‹EäèföÿÿËÿU‹ìƒì3ÀS‰Eü‰Eô‰EøSœX‹È5 PœZ+Ñt Q3À¢‰Eô‰]è‰Uì‰M𸠢‰Uü‰Eø[÷Eü tè\ÿÿÿ…Àt3À@ë3À[ÉÃè™ÿÿÿ£ˆ*A 3ÀËÿU‹ìQSV‹u3ÛW;ót9] w èIõÿÿjYSSSSS‹ñ‰èÐôÿÿƒÄ‹ÆéÍ ‹E3ÿ;ÃtŠ :Ãtj_9} † ˆFÆ:F‹M‹Á;Ët@8t<ë‹}ü‹U G‰}ü;úsyŠˆF@8uèPQèŒ@ Š YYŠˆF@8uð‹E ;Ãt'Š:Ët!€ù.tG;} s Æ.Fë G;} sŠˆF@8uðG;} v‹Eˆèlôÿÿj"é ÿÿÿˆ 3À_^[ÉËÿU‹ìƒìÿuMðèÜÿÿ¶E ‹MôŠU„T u ƒ} t‹Mð‹‰È ·A#Eë3À…Àt3À@€}ü t‹MøƒapýÉËÿU‹ìjj ÿuÿu è™ÿÿÿƒÄ]ËÿU‹ìjj ÿuj èÿÿÿƒÄ]ËÿU‹ìj ÿuÿuÿu ÿuè…? ƒÄ]ËÿU‹ìì( £°"A ‰
¬"A ‰¨"A ‰ ¤"A ‰5 "A ‰=œ"A fŒÈ"A fŒ
¼"A fŒ ˜"A fŒ”"A fŒ%"A fŒ-Œ"A œÀ"A ‹E £´"A ‹E£¸"A E£Ä"A ‹…àüÿÿÇ "A ¡¸"A £´!A Ǩ!A ÀǬ!A ¡€A ‰…Øüÿÿ¡„A ‰…ÜüÿÿÿXà@ £ø!A jèO$ Yj ÿTà@ hÔâ@ ÿPà@ ƒ=ø!A ujè+$ Yh ÀÿLà@ PÿHà@ ÉÃ-¤ t"ƒètƒè
t Ht3Àø ø ø ø ËÿVW‹ðh 3ÿF WPè+Öÿÿ3À·È‹Á‰~‰~‰~ Áá Á~«««¹hA ƒÄ F +ο Šˆ@Ou÷† ¾ Šˆ@Nu÷_^ËÿU‹ìì ¡€A 3ʼnEüSW…èúÿÿPÿvÿhà@ ¿ …À„û 3Àˆ„üþÿÿ@;ÇrôŠ…îúÿÿÆ…üþÿÿ „Àt.ïúÿÿ¶È¶;Èw+Á@P”
üþÿÿj RèhÕÿÿƒÄ CŠC„ÀuØj ÿv …üúÿÿÿvPW…üþÿÿPjj èE 3ÛSÿv…üýÿÿWPW…üþÿÿPWÿv SèúB ƒÄDSÿv…üüÿÿWPW…üþÿÿPh ÿv SèÕB ƒÄ$3À·ŒEüúÿÿöÁt€L ŠŒüýÿÿëöÁt€L ŠŒüüÿÿˆŒ ëÆ„ @;Çr¾ëV† Ç…äúÿÿŸÿÿÿ3É)…äúÿÿ‹•äúÿÿ„ ÐZ ƒûw €L ŠÑ€Â ëƒúw€L ŠÑ€ê ˆëÆ A;Ïr‹Mü_3Í[èOØÿÿÉÃj h8ö@ èÏðÿÿè˜
‹ø¡ŒA …Gpt ƒl t‹wh…öuj èžÚÿÿY‹ÆèçðÿÿÃj
èó÷ÿÿYƒeü ‹wh‰uä;5A t6…ötVÿpà@ …ÀuþhA tVè‡óÿÿY¡A ‰Gh‹5A ‰uäVÿlà@ ÇEüþÿÿÿè 뎋uäj
è¸öÿÿYËÿU‹ìƒìS3ÛSMðè¤×ÿÿ‰ Ì$A ƒþþu ÇÌ$A ÿxà@ 8]ütE‹Møƒapýë<ƒþýuÇÌ$A ÿtà@ ëÛƒþüu‹Eð‹@ÇÌ$A ëÄ8]üt‹Eøƒ`pý‹Æ[ÉËÿU‹ìƒì ¡€A 3ʼnEüS‹] V‹uWèdÿÿÿ‹ø3ö‰};þu‹Ãè·üÿÿ3Àé ‰uä3À9¸˜A „‘ ÿEäƒÀ0=ð rçÿèý „p ÿéý „d ·ÇPÿ|à@ …À„R EèPWÿhà@ …À„3 h C VPèˆÒÿÿ3ÒBƒÄ ‰{‰s 9Uè†ø €}î „Ï uɄ ¶Fÿ¶Éé¦ h C VPèAÒÿÿ‹MäƒÄ kÉ0‰u౨A ‰uäë*ŠF„Àt(¶>¶Àë‹EàŠ€”A D; ¶FG;øvê‹}FF€> uÑ‹uäÿEàƒÆƒ}à‰uäré‹Ç‰{ÇC ègûÿÿj‰C C‰œA Zf‹1Af‰0A@@Juó‹óè×ûÿÿé·þÿÿ€L @;ÁvöFF€~ÿ …4ÿÿÿC ¹þ €@Iuù‹Cèûÿÿ‰C ‰Së‰s3À·È‹ÁÁá Á{«««ë¨95Ì$A …XþÿÿƒÈÿ‹Mü_^3Í[èJÕÿÿÉÃjhXö@ èÊíÿÿƒMàÿè ‹ø‰}ÜèÜüÿÿ‹_h‹uèuýÿÿ‰E;C„W h è‚ïÿÿY‹Ø…Û„F ¹ˆ ‹wh‹ûó¥ƒ# Sÿuè¸ýÿÿYY‰Eà…À…ü ‹uÜÿvhÿpà@ …Àu‹Fh=hA tPècðÿÿY‰^hS‹=là@ ÿ×öFp…ê öŒA …Ý j
ètôÿÿYƒeü ‹C£Ü$A ‹C£à$A ‹C £ä$A 3À‰Eäƒø}f‹LCf‰ EÐ$A @ëè3À‰Eä= }
ŠL ˆˆˆA @ëé3À‰Eä= }ŠŒ ˆˆA @ëæÿ5A ÿpà@ …Àu¡A =hA tPèªïÿÿY‰ A Sÿ×ÇEüþÿÿÿè ë0j
èíòÿÿYÃë%ƒøÿu ûhA tSètïÿÿYèìÿÿÇ ëƒeà ‹Eàè‚ìÿÿÃ=°+A ujýèVþÿÿYÇ°+A 3ÀËÿU‹ìSV‹u‹†¼ 3ÛW;Ãto=H A th‹†° ;Ãt^9uZ‹†¸ ;Ãt9uPèûîÿÿÿ¶¼ è;A YY‹†´ ;Ãt9uPèÚîÿÿÿ¶¼ èÕ@ YYÿ¶° èÂîÿÿÿ¶¼ è·îÿÿYY‹†À ;ÃtD9u@‹†Ä -þ Pè–îÿÿ‹†Ì ¿€ +ÇPèƒîÿÿ‹†Ð +ÇPèuîÿÿÿ¶À èjîÿÿƒÄ¾Ô ‹=ˆ A t9˜´ uPè»> ÿ7èCîÿÿYY~PÇE øA t‹;Ãt 9uPè îÿÿY9_üt‹G;Ãt 9uPèîÿÿYƒÇÿMuÇVèøíÿÿY_^[]ËÿU‹ìSV‹5là@ W‹}WÿÖ‹‡° …ÀtPÿÖ‹‡¸ …ÀtPÿÖ‹‡´ …ÀtPÿÖ‹‡À …ÀtPÿÖ_PÇE {øA t ‹…ÀtPÿÖƒ{ü t
‹C…ÀtPÿÖƒÃÿMuÖ‹‡Ô ´ PÿÖ_^[]ËÿU‹ìW‹}…ÿ„ƒ SV‹5pà@ WÿÖ‹‡° …ÀtPÿÖ‹‡¸ …ÀtPÿÖ‹‡´ …ÀtPÿÖ‹‡À …ÀtPÿÖ_PÇE {øA t ‹…ÀtPÿÖƒ{ü t
‹C…ÀtPÿÖƒÃÿMuÖ‹‡Ô ´ PÿÖ^[‹Ç_]Ã…ÿt7…Àt3V‹0;÷t(W‰8èÁþÿÿY…ötVèEÿÿÿƒ> Yuþ˜A tVèYýÿÿY‹Ç^Ã3ÀÃj hxö@ ècéÿÿè, ‹ð¡ŒA …Fpt"ƒ~l t è ‹pl…öuj è-ÓÿÿY‹ÆèvéÿÿÃj è‚ðÿÿYƒeü Fl‹=pA èiÿÿÿ‰EäÇEüþÿÿÿè ëÁj è}ïÿÿY‹uäËÿU‹ìVÿ5„A ‹5€à@ ÿÖ…Àt!¡€A ƒøÿtPÿ5„A ÿÖÿÐ…Àt‹€ø ë'¾tã@ Vÿ à@ …Àu VènÒÿÿY…Àthdã@ Pÿ(à@ …ÀtÿuÿЉE‹E^]Ãj è‡ÿÿÿYËÿU‹ìVÿ5„A ‹5€à@ ÿÖ…Àt!¡€A ƒøÿtPÿ5„A ÿÖÿÐ…Àt‹€ü ë'¾tã@ Vÿ à@ …Àu VèóÑÿÿY…Àthã@ Pÿ(à@ …ÀtÿuÿЉE‹E^]Ãÿ„à@  ‹ÿVÿ5„A ÿ€à@ ‹ð…öuÿ5%A èeÿÿÿY‹ðVÿ5„A ÿˆà@ ‹Æ^á€A ƒøÿtPÿ5%A è;ÿÿÿYÿЃ
€A ÿ¡„A ƒøÿtPÿŒà@ ƒ
„A ÿéºíÿÿj h˜ö@ è†çÿÿ¾tã@ Vÿ à@ …ÀuVè4ÑÿÿY‰Eä‹uÇF\é@ 3ÿG‰~…Àt$hdã@ P‹ (à@ ÿÓ‰†ø hã@ ÿuäÿÓ‰†ü ‰~pÆ†È CƆK CÇFhhA j
ènîÿÿYƒeü ÿvhÿlà@ ÇEüþÿÿÿè> j èMîÿÿY‰}ü‹E ‰Fl…Àu¡pA ‰FlÿvlèüÿÿYÇEüþÿÿÿè è çÿÿÃ3ÿG‹uj
è5íÿÿYÃj è,íÿÿYËÿVWÿ\à@ ÿ5€A ‹øè‘þÿÿÿЋð…öuNh jè±èÿÿ‹ðYY…öt:Vÿ5€A ÿ5%A èèýÿÿYÿÐ…Àtj VèÅþÿÿYYÿ”à@ ƒNÿ‰ë Vè^éÿÿY3öWÿà@ _‹Æ^ËÿVèÿÿÿ‹ð…öujèÐÿÿY‹Æ^ÃjhÀö@ è æÿÿ‹u…ö„ø ‹F$…ÀtPèéÿÿY‹F,…ÀtPèéÿÿY‹F4…ÀtPèõèÿÿY‹F<…ÀtPèçèÿÿY‹F@…ÀtPèÙèÿÿY‹FD…ÀtPèËèÿÿY‹FH…ÀtPè½èÿÿY‹F\=é@ tPè¬èÿÿYj
èàìÿÿYƒeü ‹~h…ÿtWÿpà@ …ÀuÿhA tWèèÿÿYÇEüþÿÿÿèW j è§ìÿÿYÇEü ‹~l…ÿt#WèóúÿÿY;=pA tÿ˜A t ƒ? uWèÿøÿÿYÇEüþÿÿÿè Vè'èÿÿYèIåÿÿ ‹uj
èvëÿÿYËuj èjëÿÿYËÿVW¾tã@ Vÿ à@ …ÀuVè“ÎÿÿY‹ø…ÿ„^ ‹5(à@ hÀã@ WÿÖh´ã@ W£ %A ÿÖh¨ã@ W£%A ÿÖh ã@ W£%A ÿÖƒ= %A ‹5ˆà@ £%A tƒ=%A t
ƒ=%A t…Àu$¡€à@ £%A ¡Œà@ Ç %A dO@ ‰5%A £%A ÿ„à@ £„A ƒøÿ„Ì ÿ5%A PÿÖ…À„» èÅÐÿÿÿ5 %A èûÿÿÿ5%A £ %A èûÿÿÿ5%A £%A èóúÿÿÿ5%A £%A èãúÿÿƒÄ£%A è¬éÿÿ…ÀtehXQ@ ÿ5 %A è=ûÿÿYÿУ€A ƒøÿtHh jèÓåÿÿ‹ðYY…öt4Vÿ5€A ÿ5%A è
ûÿÿYÿÐ…Àtj VèçûÿÿYYÿ”à@ ƒNÿ‰3À@ëè’ûÿÿ3À_^ËÿU‹ìƒìSÿuMèèÉÊÿÿ‹]C= w‹Eè‹€È ·Xëu‰]Á}EèP‹E%ÿ PèG YY…ÀtŠEjˆEøˆ]ùÆEú Yë
3Ɉ]øÆEù A‹EèjÿpÿpEüPQEøPEèjPè 6 ƒÄ …Àu8Eôt‹Eðƒ`pý3Àë·Eü#E €}ô t‹Mðƒapý[ÉËÿU‹ìQV‹u Vèwàÿÿ‰E ‹F Y¨‚uè8âÿÿÇ ƒN ƒÈÿé/ ¨@t
è âÿÿÇ " ëãS3Û¨t‰^¨„‡ ‹Nƒàþ‰‰F ‹F ƒàïƒÈ‰F ‰^‰]ü© u,è—ÃÿÿƒÀ ;ðt è‹ÃÿÿƒÀ@;ðu
ÿu è© Y…ÀuVè¾? Y÷F W„€ ‹F‹>H‰‹N+øI;û‰N~ WPÿu èÜ* ƒÄ ‰EüëMƒÈ ‰F ƒÈÿëy‹M ƒùÿtƒùþt‹Áƒà ‹ÑÁúÁà• *A 븘A ö@ tjSSQè*> #ƒăøÿt%‹FŠMˆë3ÿGWEPÿu èm* ƒÄ ‰Eü9}üt ƒN ƒÈÿë‹E%ÿ _[^ÉËÿU‹ìQQS‹]VW3ö3ÿ‰}ü; ýˆA t G‰}üƒÿrîƒÿƒw jèz@ Yƒø„4 jèi@ Y…Àu
ƒ=ŒA „ ûü „A hpé@ » S¿ %A Wè08 ƒÄ …Àt
VVVVVèØÞÿÿƒÄh ¾9%A Vj Æ=&A ÿà@ …Àu&hXé@ hû Vèî7 ƒÄ …Àt3ÀPPPPPè”ÞÿÿƒÄVè‡ @Yƒø Yƒøtjèñ> Y…Àu ƒ=ŒA uhü è)þÿÿhÿ è þÿÿYYËÿU‹ìQSVWÿ5¬+A èÊöÿÿÿ5¨+A ‹ø‰}üèºöÿÿ‹ðYY;÷‚ƒ ‹Þ+ßCƒørwWèÕ> ‹øCY;øsH¸ ;øs‹ÇÇ;ÇrPÿuüèsáÿÿYY…ÀuG;Çr@Pÿuüè]áÿÿYY…Àt1ÁûP4˜èÕõÿÿY£¬+A ÿuèÇõÿÿ‰ƒÆVè¼õÿÿY£¨+A ‹EYë3À_^[ÉËÿVjj èÇàÿÿ‹ðVè•õÿÿƒÄ £¬+A £¨+A …öujX^Ã& 3À^Ãj hèö@ èeÞÿÿèÀÈÿÿƒeü ÿuèøþÿÿY‰EäÇEüþÿÿÿè ‹EäèÞÿÿÃèŸÈÿÿËÿU‹ìÿuè·ÿÿÿ÷ØÀ÷ØYH]ËÿV¸àô@ ¾àô@ W‹ø;Æs‹…ÀtÿЃÇ;þrñ_^ËÿV¸èô@ ¾èô@ W‹ø;Æs‹…ÀtÿЃÇ;þrñ_^ËÿVW3ÿ·@ A ÿ6èÆôÿÿƒÇY‰ƒÿ(rè_^ÃÌ‹ÿU‹ì‹M¸MZ f9t3À]ËA<Á8PE uï3Ò¹ f9H”‹Â]ÃÌÌÌÌÌÌÌÌÌÌÌ‹ÿU‹ì‹E‹H<È·ASV·q3ÒWD…öv‹} ‹H ;ùr ‹XÙ;ûr
BƒÀ(;Örè3À_^[]ÃÌÌÌÌÌÌÌÌÌÌÌÌ‹ÿU‹ìjþh÷@ hÐ7@ d¡ PƒìSVW¡€A 1Eø3ÅPEðd£ ‰eèÇEü h @ è*ÿÿÿƒÄ…ÀtU‹E- @ Ph @ èPÿÿÿƒÄ…Àt;‹@$Áè ÷ЃàÇEüþÿÿÿ‹Mðd‰
Y_^[‹å]ËEì‹‹3Ò= À”‹ÂËeèÇEüþÿÿÿ3À‹Mðd‰
Y_^[‹å]Ãjh(÷@ èWÜÿÿè öÿÿ‹@x…Àtƒeü ÿÐë3À@ËeèÇEüþÿÿÿè—< èpÜÿÿÃh
[@ è'óÿÿY£4(A ÃËÿU‹ìQQVè`õÿÿ‹ð…ö„F ‹V\¡t A W‹}‹ÊS99t‹ØkÛ ƒÁ Ú;ËrîkÀ Â;Ès99u‹Áë3À…Àt
‹X‰]ü…Ûu3Àéû ƒûu ƒ` 3À@éê ƒû„Þ ‹N`‰Mø‹M ‰N`‹Hƒù…¸ ‹
h A ‹=l A ‹Ñù;×}$kÉ ‹~\ƒd9 ‹=h A ‹ l A B߃Á ;Ó|â‹]ü‹ ‹~d=Ž Àu ÇFdƒ ë^= Àu ÇFd ëN=‘ Àu ÇFd„ ë>=“ Àu ÇFd… ë.= Àu ÇFd‚ ë = Àu ÇFd† ë=’ ÀuÇFdŠ ÿvdjÿÓY‰~dëƒ` QÿÓ‹EøY‰F`ƒÈÿ[_^ÉËÿU‹ì‹E£8(A £<(A £@(A £D(A ]ËÿU‹ì‹E‹
t A V9Pt‹ñkö uƒÀ ;ÆrìkÉ M^;Ás9Pt3À]Ãÿ5@(A èÚñÿÿYÃj hH÷@ èJÚÿÿ3ÿ‰}ä‰}Ø‹]ƒû Lt‹ÃjY+Át"+Át+Átd+ÁuDèsóÿÿ‹ø‰}Ø…ÿuƒÈÿéa ¾8(A ¡8(A ë`ÿw\‹Óè]ÿÿÿ‹ðƒÆ‹ëZ‹Ãƒèt<ƒèt+Ht èŽÙÿÿÇ 3ÀPPPPPèÙÿÿƒÄ뮾@(A ¡@(A ë¾<(A ¡<(A ë
¾D(A ¡D(A ÇEä Pèñÿÿ‰EàY3Àƒ}à„Ø 9EàujèòÅÿÿ9EätPèÆàÿÿY3À‰Eüƒût
ƒû tƒûu‹O`‰MÔ‰G`ƒûu@‹Od‰MÐÇGdŒ ƒûu.‹
h A ‰MÜ‹
l A ‹h A Ê9MÜ}‹MÜkÉ ‹W\‰DÿEÜëÛè~ðÿÿ‰ÇEüþÿÿÿè ƒûu ÿwdSÿUàYë‹]‹}؃}ä tj èTßÿÿYÃSÿUàYƒût
ƒû tƒûu‹EÔ‰G`ƒûu‹EЉGd3ÀèìØÿÿËÿU‹ì‹E£L(A ]ËÿU‹ì‹E£X(A ]ËÿU‹ì‹E£\(A ]Ãjhh÷@ èmØÿÿƒeü ÿu ÿuÿ à@ ‰Eäë/‹Eì‹ ‹ ‰Eà3É= À”Á‹ÁËeè}à Àujÿà@ ƒeä ÇEüþÿÿÿ‹Eäè_ØÿÿËÿU‹ì‹E£`(A ]ËÿU‹ìÿ5`(A è|ïÿÿY…ÀtÿuÿÐY…Àt3À@]Ã3À]ËÿU‹ì‹E‹ 8csmàu*ƒxu$‹@= “t=!“t="“t= @™uèCûÿÿ3À] hŽ_@ ÿTà@ 3ÀÃ=°+A uèHëÿÿV‹5< A W3ÿ…öuƒÈÿé <=tGVèƒ YtŠ„ÀuêjGWè€Ùÿÿ‹øYY‰= A …ÿtË‹5< A SëBVèR ‹ØC€>=Yt1jSèRÙÿÿYY‰…ÀtNVSPè|. ƒÄ …Àt3ÀPPPPPè"ÕÿÿƒÄƒÇó€> u¹ÿ5< A èÚÿÿƒ%< A ƒ' Ǥ+A 3ÀY[_^Ãÿ5 A èÝÙÿÿƒ% A ƒÈÿëä‹ÿU‹ìQ‹MS3ÀV‰‹ò‹U Ç 9Et ‹]ƒE‰‰Eü€>"u3À9Eü³"”ÀF‰Eüë<ÿ…ÒtŠˆB‰U Š ¶ÃPFè âÿÿY…Àtÿƒ} t
‹M ŠÿE ˆF‹U ‹M„Ût2ƒ}ü u©€û t€û uŸ…ÒtÆBÿ ƒeü €> „é Š< t< uFëóNëã€> „Ð ƒ} t ‹EƒE‰ÿ3ÛC3ÉëFA€>\tù€>"u&öÁu ƒ}ü t F€8"u‹ðë
3À3Û9Eü”À‰EüÑé…ÉtI…ÒtÆ\Bÿ…Éuñ‰U Š„ÀtUƒ}ü u< tK< tG…Ût=¾ÀP…Òt#è9áÿÿY…Àt
Š‹M ÿE ˆFÿ‹M ŠÿE ˆë
èáÿÿY…ÀtFÿÿ‹U FéVÿÿÿ…ÒtÆ B‰U ÿ‹Méÿÿÿ‹E^[…Àtƒ ÿÉËÿU‹ìƒì S3ÛVW9 °+A uèÄèÿÿh ¾h(A VSˆ l)A ÿà@ ¡ +A ‰5( A ;Ãt‰Eü8u‰uü‹UüEøPSS}ôè
þÿÿ‹EøƒÄ =ÿÿÿ?sJ‹MôƒùÿsB‹øÁç;Ár6PèƒÖÿÿ‹ðY;ót)‹UüEøPþWV}ôèÉýÿÿ‹EøƒÄ H£ A ‰5 A 3ÀëƒÈÿ_^[ÉËÿU‹ì¡p)A ƒì SV‹5´à@ W3Û3ÿ;Ãu.ÿÖ‹ø;ût Çp)A ë#ÿ\à@ ƒøxu
jX£p)A ë¡p)A ƒø… ;ûuÿÖ‹ø;ûu3ÀéÊ ‹Çf9 t@@f9uù@@f9uò‹5°à@ SSS+ÇSÑø@PWSS‰EôÿÖ‰Eø;Ãt/Pè©ÕÿÿY‰Eü;Ãt!SSÿuøPÿuôWSSÿÖ…Àu ÿuüè¸ÖÿÿY‰]ü‹]üWÿ¬à@ ‹Ãë\ƒøt;Ãu‚ÿ¨à@ ‹ð;ó„rÿÿÿ8 t
@8uû@8uö+Æ@P‰EøèBÕÿÿ‹øY;ûu Vÿ¤à@ éEÿÿÿÿuøVWè©+ ƒÄ Vÿ¤à@ ‹Ç_^[ÉËÿU‹ì3À9Ej ”Àh Pÿ¸à@ £t)A …Àu]Ã3À@£„*A ]ËÿU‹ìƒì¡€A ƒeø ƒeü SW¿Næ@»» ÿÿ;Çt
…Ãt ÷У„A ë`VEøPÿÌà@ ‹uü3uøÿÈà@ 3ðÿ”à@ 3ðÿÄà@ 3ðEðPÿÀà@ ‹Eô3Eð3ð;÷u¾Oæ@»ë …óu‹ÆÁà ð‰5€A ÷Ö‰5„A ^_[ÉËÿU‹ì‹EƒøþuèÒÿÿÇ 3À]ÃV3ö;Æ|;*A r èæÑÿÿVVVVVÇ ènÑÿÿƒÄ3Àë‹Èƒà Áù‹ *A Áà¾Dƒà@^]á€A ƒÈ3É9x)A ”Á‹ÁÃÌÌÌÌÌÌÌÌ‹L$÷Á t$ŠƒÁ„ÀtN÷Á uï ¤$ ¤$ ‹ºÿþþ~Ѓðÿ3ƒÁ© tè‹Aü„Àt2„ät$© ÿ t© ÿtëÍAÿ‹L$+ÁÃAþ‹L$+ÁÃAý‹L$+ÁÃAü‹L$+ÁËÿU‹ìƒìSV‹u 3ÛW‹};óu;ûv‹E;Ãt‰3Àéƒ ‹E;ÃtƒÿÿÿÿÿvèÇÐÿÿj^SSSSS‰0èPÐÿÿƒÄ‹ÆëVÿuMðès¸ÿÿ‹Eð9X…œ f‹E¹ÿ f;Áv6;ót;ûv WSVè8´ÿÿƒÄ ètÐÿÿÇ * èiÐÿÿ‹ 8]üt‹Møƒapý_^[ÉÃ;ót2;ûw,èIÐÿÿj"^SSSSS‰0èÒÏÿÿƒÄ8]ü„yÿÿÿ‹Eøƒ`pýémÿÿÿˆ‹E;ÃtÇ 8]ü„%ÿÿÿ‹Eøƒ`pýéÿÿÿM QSWVjMQS‰] ÿpÿ°à@ ;Ãt9] …^ÿÿÿ‹M;Ët½‰ë¹ÿ\à@ ƒøz…Dÿÿÿ;ó„gÿÿÿ;û†_ÿÿÿWSVèa³ÿÿƒÄ éOÿÿÿ‹ÿU‹ìj ÿuÿuÿu ÿuè|þÿÿƒÄ]ËÿU‹ìƒìÿu Mðè:·ÿÿ¶E‹Mð‹‰È ·A% € €}ü t‹MøƒapýÉËÿU‹ìj ÿuè¹ÿÿÿYY]ÃÌV‹D$ Àu(‹L$‹D$ 3Ò÷ñ‹Ø‹D$÷ñ‹ð‹Ã÷d$‹È‹Æ÷d$ÑëG‹È‹\$‹T$ ‹D$ÑéÑÛÑêÑØ Éuô÷ó‹ð÷d$‹È‹D$÷æÑr;T$ wr;D$v N+D$T$3Û+D$T$ ÷Ú÷ØƒÚ ‹Ê‹Ó‹Ù‹È‹Æ^ ƒ%€*A ÃÌÌÌSVW‹T$‹D$‹L$URPQQh i@ dÿ5 ¡€A 3ĉD$d‰% ‹D$0‹X‹L$,3‹p ƒþþt;‹T$4ƒúþt;òv.4v\³‹ ‰H ƒ{ uÌh ‹Cè1 ¹ ‹Cè1 ë°d ƒÄ_^[ËL$÷A ¸ t3‹D$‹H3È袵ÿÿU‹hÿp ÿpÿpè>ÿÿÿƒÄ ]‹D$‹T$‰¸ ÃU‹L$‹)ÿq ÿqÿq(èÿÿÿƒÄ ] UVWS‹ê3À3Û3Ò3ö3ÿÿÑ[_^]Ëê‹ñ‹Ájè_0 3À3Û3É3Ò3ÿÿæU‹ìSVWj j hÇi@ Qè—Q _^[]ÃU‹l$RQÿt$è´þÿÿƒÄ ] j hˆ÷@ èÍÿÿƒeä ‹u;5p*A w"jèÄÔÿÿYƒeü Vèa Y‰EäÇEüþÿÿÿè ‹EäèÍÿÿÃjè¿ÓÿÿYËÿU‹ìV‹uƒþà‡¡ SW‹=dà@ ƒ=t)A uèíÿÿj èÏëÿÿhÿ èM·ÿÿYY¡„*A ƒøu…öt‹Æë3À@Pë ƒøu VèSÿÿÿY…Àu…öuFƒÆƒæðVj ÿ5t)A ÿ׋؅Ûu.j ^9€)A tÿuè¢ôÿÿY…Àt‹ué{ÿÿÿèNÌÿÿ‰0èGÌÿÿ‰0_‹Ã[ëVè{ôÿÿYè3ÌÿÿÇ 3À^]Ãjh¨÷@ èhÌÿÿ‹]…Ûuÿu èÿÿÿYéÌ ‹u …öu SècÏÿÿYé· ƒ=„*A …“ 3ÿ‰}äƒþà‡Š jèwÓÿÿY‰}üSè6 Y‰Eà;Ç„ž ;5p*A wIVSPè ƒÄ …Àt‰]äë5Vèç Y‰Eä;Çt'‹CüH;Ær‹ÆPSÿuäè:$ Sèæ ‰EàSPè ƒÄ9}äuH;÷u3öF‰u ƒÆƒæð‰u VWÿ5t)A ÿdà@ ‰Eä;Çt ‹CüH;Ær‹ÆPSÿuäèæ# Sÿuàè¿ ƒÄÇEüþÿÿÿè. ƒ}à u1…öuFƒÆƒæð‰u VSj ÿ5t)A ÿÔà@ ‹øë‹u ‹]jè¨ÑÿÿYË}ä…ÿ…¿ 9=€)A t,VèóÿÿY…À…Òþÿÿè´Êÿÿ9}àul‹ðÿ\à@ Pè_ÊÿÿY‰ë_…ÿ…ƒ èÊÿÿ9}àthÇ ëq…öuFVSj ÿ5t)A ÿÔà@ ‹ø…ÿuV9€)A t4Vè›òÿÿY…Àt ƒþàvÍVè‹òÿÿYèCÊÿÿÇ 3ÀèÇÊÿÿÃè0Êÿÿé|ÿÿÿ…ÿuè"Êÿÿ‹ðÿ\à@ PèÒÉÿÿ‰Y‹ÇëÒ‹ÿU‹ì‹M S3Û;Ëv(jà3ÒX÷ñ;Es èíÉÿÿSSSSSÇ èuÉÿÿƒÄ3ÀëA¯MVW‹ñ9]t ÿuèÈ) Y‹ØVÿuèýÿÿ‹øYY…ÿt;Þs+óVj ßSèXÿÿƒÄ ‹Ç_^[]ËÿU‹ì‹
h*A ¡l*A kÉÈë‹U+P ú r ƒÀ;Árë3À]ËÿU‹ìƒì‹M‹AV‹u W‹þ+y ƒÆüÁï‹ÏiÉ ŒD ‰Mð‹I‰MüöÁ…Ó S 1‹‰Uô‹Vü‰Uø‹Uô‰] öÂutÁúJƒú?vj?Z‹K;KuB» €ƒú s‹ÊÓëL÷Ó!\¸Dþ u#‹M!ë JàÓëL÷Ó!œ¸Ä þ u‹M!Y‹] ‹S‹[‹MüMô‰Z‹U ‹Z‹R‰S‰Mü‹ÑÁúJƒú?vj?Z‹]øƒã‰]ô… +uø‹]øÁûj?‰u K^;Þv‹ÞMø‹ÑÁúJ‰Mü;Öv‹Ö;Út^‹M ‹q;qu;¾ €ƒû s‹ËÓî÷Ö!t¸DþLu!‹M!1ëKàÓî÷Ö!´¸Ä þLu‹M!q‹M ‹q‹I‰N‹M ‹q‹I‰N‹u ë‹]ƒ}ô u;Ú„€ ‹Mð Ñ‹Y‰N‰^‰q‹N‰q‹N;Nu`ŠLˆMþÁˆLƒú s%€} u‹Ê» €Óë‹M » €‹ÊÓëD¸D ë)€} uJà» €Óë‹M YJຠ€Óê„¸Ä ‹Eü‰‰D0ü‹Eðÿ…ó ¡|)A …À„Ø ‹
|*A ‹5¼à@ h @ ÁáH » € SQÿÖ‹
|*A ¡|)A º €Óê P¡|)A ‹@‹
|*A ƒ¤ˆÄ ¡|)A ‹@þHC¡|)A ‹H€yC u ƒ`þ¡|)A ƒxÿueSj ÿp ÿÖ¡|)A ÿpj ÿ5t)A ÿ`à@ ‹
h*A ¡|)A kÉ‹l*A +ÈLìQHQPèí+ ‹EƒÄ ÿ
h*A ;|)A vƒm¡l*A £t*A ‹E£|)A ‰=|*A [_^Éáx*A V‹5h*A W3ÿ;ðu4ƒÀkÀPÿ5l*A Wÿ5t)A ÿÔà@ ;Çu3Àëxƒx*A ‹5h*A £l*A kö5l*A hÄA jÿ5t)A ÿdà@ ‰F;ÇtÇjh h WÿØà@ ‰F ;ÇuÿvWÿ5t)A ÿ`à@ 뛃Nÿ‰>‰~ÿh*A ‹Fƒÿ‹Æ_^ËÿU‹ìQQ‹M‹ASV‹qW3ÛëÀC…À}ù‹ÃiÀ „0D j?‰EøZ‰@‰@ƒÀJuôj‹ûh Áçy h € WÿØà@ …ÀuƒÈÿé — p ‰Uü;úwC‹Ê+ÏÁé GAƒHøÿƒˆì ÿü ‰üïÿÿÇ@üð ‰PÇ€è ð IuË‹Uü‹Eøø O ‰H‰AJ ‰H‰AƒdžD 3ÿG‰¼žÄ ŠFCŠÈþÁ„À‹EˆNCu xº €‹ËÓê÷Ò!P‹Ã_^[ÉËÿU‹ìƒì ‹M‹ASV‹uW‹} ‹×+Q ƒÆÁê‹ÊiÉ ŒD ‰Mô‹OüƒæðI;ñ|9ü‹ ‰M‰]üŽU öÃ…E Ù;ó; ‹MüÁùI‰Møƒù?vj?Y‰Mø‹_;_uC» €ƒù sÓë‹MøL÷Ó!\Dþ u&‹M!ë ƒÁàÓë‹MøL÷Ó!œÄ þ u‹M!Y‹O‹_‰Y‹O‹‰y‹M+ÎMüƒ}ü Ž¥ ‹}ü‹M ÁÿOL1üƒÿ?vj?_‹]ô û‰]‹[‰Y‹]‰Y‰K‹Y‰K‹Y;YuWŠLˆMþÁˆLƒÿ s €} u‹Ï» €Óë‹M DD‹Ïë €} uOà» €Óë‹M Y„Ä Oຠ€Óê ‹U ‹MüD2ü‰‰Lüë‹U F‰Bü‰D2øé< 3Àé8 / ‹] )uN‰Kü\3ü‹uÁþN‰] ‰Küƒþ?vj?^öEü…€ ‹uüÁþNƒþ?vj?^‹O;OuB» €ƒþ s‹ÎÓët÷Ó!\Dþu#‹M!ë NàÓëL÷Ó!œÄ þ u‹M!Y‹] ‹O‹w‰q‹w‹O‰q‹uuü‰uÁþNƒþ?vj?^‹Mô ñ‹y‰K‰{‰Y‹K‰Y‹K;KuWŠLˆMþÁˆLƒþ s €} u‹Î¿ €Óï‹M 9DD‹Îë €} uNà¿ €Óï‹M y„Ä Nຠ€Óê ‹E‰‰Dü3À@_^[ÉËÿU‹ìƒì¡h*A ‹MkÀl*A ƒÁƒáð‰MðÁùSIƒù VW} ƒÎÿÓîƒMøÿë
ƒÁàƒÊÿ3öÓê‰Uø‹
t*A ‹Ùë‹S‹;#Uø#þ ×u
ƒÃ‰];Ørè;Øu‹ l*A ë‹S‹;#Uø#þ ×u
ƒÃ‰];Ùrè;Ùu[ë ƒ{ u
ƒÃ‰];Ørð;Øu1‹ l*A ë ƒ{ u
ƒÃ‰];Ùrð;Ùuè úÿÿ‹Ø‰]…Ûu3Àé Sè:ûÿÿY‹K‰‹Cƒ8ÿtå‰ t*A ‹C‹‰Uüƒúÿt‹ŒÄ ‹|D#Mø#þ Ïu)ƒeü ‹Ä HD‹9#Uø#þ ×uÿEü‹‘„ ƒÁëç‹Uü‹ÊiÉ ŒD ‰Mô‹LD3ÿ#Îu‹ŒÄ #Møj _ëÉG…É}ù‹Mô‹Tù‹
+Mð‹ñÁþNƒþ?‰Mø~j?^;÷„ ‹J;Ju\ƒÿ » €}&‹ÏÓë‹Mü|8÷Ó‰]ì#\ˆD‰\ˆDþu3‹Mì‹]! ë,OàÓë‹MüŒˆÄ |8÷Ó!þ‰]ìu ‹]‹Mì!Kë‹]ƒ}ø ‹J‹z‰y‹J‹z‰y„ ‹Mô ñ‹y‰J‰z‰Q‹J‰Q‹J;Ju^ŠLˆM þÁƒþ ˆL}#€} u ¿ €‹ÎÓï ;‹Î¿ €Óï‹Mü |ˆDë)€} u
Nà¿ €Óï {‹Mü¼ˆÄ Nྠ€Óî 7‹Mø…Ét ‰
‰Lüë‹Mø‹uðÑN‰
‰L2ü‹uô‹y‰>…Éu; |)A u‹Mü;
|*A uƒ%|)A ‹Mü‰B_^[ÉËÿU‹ìSV‹uW3ÿƒËÿ;÷u èµ¾ÿÿWWWWWÇ è=¾ÿÿƒÄ ÃëBöF ƒt7Vè(ÃÿÿV‹ØèÄ( Vè³¼ÿÿPèë' ƒÄ…À}ƒËÿë‹F ;Çt
PèÎÁÿÿY‰~ ‰~ ‹Ã_^[]Ãj hÈ÷@ è—¾ÿÿƒMäÿ3À‹u3ÿ;÷•À;Çu è2¾ÿÿÇ WWWWW躽ÿÿƒÄƒÈÿë öF @t ‰~ ‹Eäèš¾ÿÿÃVè– ÿÿY‰}üVè*ÿÿÿY‰EäÇEüþÿÿÿè ëÕ‹uVèä ÿÿYËÿU‹ì¸ä è8* ¡€A 3ʼnEü‹E V3ö‰…4åÿÿ‰µ8åÿÿ‰µ0åÿÿ9uu3Àéé ;Æu'訽ÿÿ‰0莽ÿÿVVVVVÇ è½ÿÿƒÄƒÈÿé¾ SW‹}‹ÇÁø4… *A ‹ƒç ÁçÇŠX$ÛÐû‰µ(åÿÿˆ'åÿÿ€ût€ûu0‹M÷ÑöÁu&è?½ÿÿ3ö‰0è#½ÿÿVVVVVÇ è«¼ÿÿƒÄéC ö@ tjj j ÿuèc ƒÄÿuèÖêÿÿY…À„ ‹öD€„ èëÖÿÿ‹@l3É9H… åÿÿ”ÁP‹ÿ4‰ åÿÿÿàà@ …À„` 3É9 åÿÿt„Û„P ÿÜà@ ‹4åÿÿ‰… åÿÿ3À‰…<åÿÿ9E†B ‰…DåÿÿŠ…'åÿÿ„À…g Š ‹µ(åÿÿ3À€ù
”À‰… åÿÿ‹Çƒx8 tŠP4ˆUôˆMõƒ`8 jEôPëK¾ÁPè×ìÿÿY…Àt:‹4åÿÿ+ËM3À@;Ȇ¥ j…@åÿÿSPè<( ƒÄ ƒøÿ„± Cÿ…DåÿÿëjS…@åÿÿPè( ƒÄ ƒøÿ„ 3ÀPPjMôQj@åÿÿQPÿµ åÿÿCÿ…Dåÿÿÿ°à@ ‹ð…ö„\ j …<åÿÿPVEôP‹…(åÿÿ‹ ÿ4ÿ˜à@ …À„) ‹…Dåÿÿ‹0åÿÿÁ9µ<åÿÿ‰…8åÿÿŒ ƒ½ åÿÿ „Í j …<åÿÿPjEôP‹…(åÿÿ‹ ÆEô
ÿ4ÿ˜à@ …À„Ð ƒ½<åÿÿŒÏ ÿ…0åÿÿÿ…8åÿÿéƒ <t<u!·33Éfƒþ
”ÁCCƒ…Dåÿÿ‰µ@åÿÿ‰ åÿÿ<t<uRÿµ@åÿÿè%% Yf;…@åÿÿ…h ƒ…8åÿÿƒ½ åÿÿ t)j
XP‰…@åÿÿèø$ Yf;…@åÿÿ…; ÿ…8åÿÿÿ…0åÿÿ‹E9…Dåÿÿ‚ùýÿÿé' ‹Šÿ…8åÿÿˆT4‹‰D8é 3É‹Çö@€„¿ ‹…4åÿÿ‰@åÿÿ„Û…Ê ‰…<åÿÿ9M† 답(åÿÿ‹<åÿÿƒ¥Dåÿÿ +4åÿÿ…Håÿÿ;Ms9‹•<åÿÿÿ…<åÿÿŠA€ú
uÿ…0åÿÿÆ
@ÿ…Dåÿÿˆ@ÿ…Dåÿÿ½Dåÿÿÿ r‹؅Håÿÿ+Øj …,åÿÿPS…HåÿÿP‹ÿ4ÿ˜à@ …À„B ‹…,åÿÿ…8åÿÿ;ÃŒ: ‹…<åÿÿ+…4åÿÿ;E‚Lÿÿÿé ‰…Dåÿÿ€û…Ñ 9M†M 답(åÿÿ‹Dåÿÿƒ¥<åÿÿ +4åÿÿ…Håÿÿ;MsF‹•Dåÿÿƒ…Dåÿÿ·AAfƒú
uƒ…0åÿÿj
[f‰@@ƒ…<åÿÿƒ…<åÿÿf‰@@½<åÿÿþ rµ‹Ø…Håÿÿ+Øj …,åÿÿPS…HåÿÿP‹ÿ4ÿ˜à@ …À„b ‹…,åÿÿ…8åÿÿ;ÃŒZ ‹…Dåÿÿ+…4åÿÿ;E‚?ÿÿÿé@ 9M†| ‹Dåÿÿƒ¥<åÿÿ +4åÿÿj…Hùÿÿ^;Ms<‹•Dåÿÿ·µDåÿÿÎfƒú
uj
[f‰Æµ<åÿÿµ<åÿÿf‰Æ½<åÿÿ¨ r¿3öVVhU
ðëÿÿQHùÿÿ+Á™+ÂÑøP‹ÁPVhéý ÿ°à@ ‹Ø;Þ„— j …,åÿÿP‹Ã+ÆP„5ðëÿÿP‹…(åÿÿ‹ ÿ4ÿ˜à@ …Àt µ,åÿÿ;ÞËë ÿ\à@ ‰…@åÿÿ;Þ\‹…Dåÿÿ+…4åÿÿ‰…8åÿÿ;E‚
ÿÿÿë?j ,åÿÿQÿuÿµ4åÿÿÿ0ÿ˜à@ …Àt‹…,åÿÿƒ¥@åÿÿ ‰…8åÿÿë ÿ\à@ ‰…@åÿÿƒ½8åÿÿ ulƒ½@åÿÿ t-j^9µ@åÿÿuè·ÿÿÇ è ·ÿÿ‰0ë?ÿµ@åÿÿè"·ÿÿYë1‹µ(åÿÿ‹öD@t‹…4åÿÿ€8u3Àë$èÖ¶ÿÿÇ èÞ¶ÿÿƒ ƒÈÿë ‹…8åÿÿ+…0åÿÿ_[‹Mü3Í^èhžÿÿÉÃjhè÷@ èè¶ÿÿ‹Eƒøþu袶ÿÿƒ 臶ÿÿÇ ƒÈÿé 3ÿ;Ç|;*A r!èy¶ÿÿ‰8è_¶ÿÿÇ WWWWWèçµÿÿƒÄëÉ‹ÈÁù *A ‹ðƒæ Áæ‹ ¾L1ƒát¿Pè9$ Y‰}ü‹öD0tÿuÿu ÿuè.øÿÿƒÄ ‰EäëèüµÿÿÇ è¶ÿÿ‰8ƒMäÿÇEüþÿÿÿè ‹Eäèh¶ÿÿÃÿuèƒ$ YÃjhø@ è ¶ÿÿ‹Eƒøþuè³µÿÿÇ ƒÈÿéª 3Û;Ã|;*A rè’µÿÿÇ SSSSSèµÿÿƒÄëЋÈÁù< *A ‹ðƒæ Á拾LƒátÆPèl# Y‰]ü‹öDt1ÿuèà" YPÿäà@ …Àu ÿ\à@ ‰Eäë‰]ä9]ätè1µÿÿ‹Mä‰èµÿÿÇ ƒMäÿÇEüþÿÿÿè ‹Eä臵ÿÿÃÿuè¢# YËÿU‹ìƒìS3Û9]u èÖ´ÿÿSSSSSÇ è^´ÿÿƒÄ3ÀëjV‹u ;óuè²´ÿÿSSSSSÇ è:´ÿÿƒÄë9ur3Àë>ÿuMðèVœÿÿ‹MôFÿ9Yt H9Ew
¶öD
uð‹Î+ȃá+ñN‹Æ8]üt‹Møƒapý^[ÉËÿU‹ìj ÿu ÿuèUÿÿÿƒÄ ]ËÿU‹ìƒìS3ÛV‹u9]u;óu9] u3Àéç ;ót9] w è ´ÿÿj^SSSSS‰0è’³ÿÿƒÄ‹ÆéÀ 9]uˆ ëÉW‹};ûu ˆ èسÿÿj^SSSSS‰0èa³ÿÿƒÄé( ÿuMì胛ÿÿ‹Eð9XuÿuWÿu Vè£
ƒÄéL ƒ}ÿ‹U ‹ÆuŠˆ@G:Ët Juó늈@G:ËtJtÿMuî9]uˆ@;Ó…È 8 tƒ}u5xÿ‰}ü;þr EìP‹Eü¶ Pè0¿ÿÿYY…ÀtÿMü9uüsâ‹Ç+Eü¨…à ƒ}ÿuZ‹E ƒøv:|þ‰};þr!EìP‹E¶ Pèì¾ÿÿYY…ÀtÿM9usâ‹E ‹Ï+MöÁtˆ ëˆ\ÿ8]øt‹Eôƒ`pýjPXé ˆ è·²ÿÿj"^SSSSS‰0è@²ÿÿƒÄ8]øt‹Eôƒ`pý‹Æëd‹È+΃ù|Mxþ‰};þr EìP‹E¶ Pèi¾ÿÿYY…ÀtÿM9usâ‹Ç+E¨t ˆ èT²ÿÿ‹Èj*X‰8]øt‹Môƒapýë8]øt‹Eôƒ`pý3À_^[ÉËÿU‹ì‹E…Àtƒè8ÝÝ uPèxµÿÿY]ËÿU‹ìƒì¡€A 3ʼnEüSV3ÛW‹ñ9 „)A u8SS3ÿGWhdê@ h Sÿðà@ …Àt‰=„)A ëÿ\à@ ƒøxu
Ç„)A 9]~"‹M‹EI8t@;ËuöƒÉÿ‹E+ÁH;E}@‰E¡„)A ƒø„¬ ;Ĥ ƒø…Ì ‰]ø9] u‹‹@‰E ‹5ìà@ 3À9]$SSÿu•ÀÿuÅ Pÿu ÿÖ‹ø;û„ ~Cjà3ÒX÷÷ƒør7D?= wèŽ# ‹Ä;Ãt Ç ÌÌ ëPè äÿÿY;Ãt Ç ÝÝ ƒÀ‰Eôë‰]ô9]ô„> Wÿuôÿuÿujÿu ÿÖ…À„ã ‹5ðà@ SSWÿuôÿu ÿuÿ֋ȉMø;Ë„Â ÷E t)9] „° ;M § ÿu ÿuWÿuôÿu ÿuÿÖé ;Ë~Ejà3ÒX÷ñƒør9D = wèÏ" ‹ô;ótjÇÌÌ ƒÆëPèJãÿÿY;Ãt Ç ÝÝ ƒÀ‹ðë3ö;ótAÿuøVWÿuôÿu ÿuÿðà@ …Àt"SS9] uSSëÿu ÿuÿuøVSÿu ÿ°à@ ‰EøVè¸ýÿÿYÿuôè¯ýÿÿ‹EøYéY ‰]ô‰]ð9]u‹‹@‰E9] u‹‹@‰E ÿuè Y‰Eìƒøÿu3Àé! ;E „Û SSMQÿuPÿu è> ƒÄ‰Eô;ÃtÔ‹5èà@ SSÿuPÿu ÿuÿÖ‰Eø;Ãu3öé· ~=ƒøàw8ƒÀ= wè¹! ‹ü;ûtÝÇÌÌ ƒÇëPè4âÿÿY;Ãt Ç ÝÝ ƒÀ‹øë3ÿ;ût´ÿuøSWèÀ’ÿÿƒÄ ÿuøWÿuÿuôÿu ÿuÿÖ‰Eø;Ãu3öë%ÿu EøÿuPWÿu ÿuìè ‹ð‰uðƒÄ÷Þö#uøWèüÿÿYëÿu ÿuÿuÿuÿu ÿuÿèà@ ‹ð9]ôt ÿuôèø±ÿÿY‹Eð;Ãt 9EtPèå±ÿÿY‹Æeà_^[‹Mü3Íè'–ÿÿÉËÿU‹ìƒìÿuMðè!–ÿÿÿu(Mðÿu$ÿu ÿu ÿuÿuÿuÿu è(üÿÿƒÄ €}ü t‹MøƒapýÉËÿU‹ìQQ¡€A 3ʼnEü¡ˆ)A SV3ÛW‹ù;Ãu:EøP3öFVhdê@ Vÿøà@ …Àt‰5ˆ)A ë4ÿ\à@ ƒøxu
jX£ˆ)A 롈)A ƒø„Ï ;Ã„Ç ƒø…è ‰]ø9]u‹‹@‰E‹5ìà@ 3À9] SSÿu•Àÿu Å PÿuÿÖ‹ø;û„« ~<ÿðÿÿw4D?= wèÒ ‹Ä;Ãt Ç ÌÌ ëPèPàÿÿY;Ãt Ç ÝÝ ƒÀ‹Ø…Ûti?Pj SèÞÿÿƒÄ WSÿuÿu jÿuÿÖ…ÀtÿuPSÿuÿøà@ ‰EøSèÉúÿÿ‹EøYëu3ö9] u‹‹@‰E 9]u‹‹@‰Eÿu èA Yƒøÿu3ÀëG;Et SSMQÿu Pÿuèi ‹ðƒÄ;ót܉u ÿuÿuÿu ÿuÿu ÿôà@ ‹ø;ótVèæ¯ÿÿY‹Çeì_^[‹Mü3Íè(”ÿÿÉËÿU‹ìƒìÿuMðè"”ÿÿÿu$Mðÿu ÿu ÿuÿuÿuÿu èþÿÿƒÄ €}ü t‹MøƒapýÉËÿU‹ìV‹u…ö„ ÿvèv¯ÿÿÿvèn¯ÿÿÿv èf¯ÿÿÿvè^¯ÿÿÿvèV¯ÿÿÿvèN¯ÿÿÿ6èG¯ÿÿÿv è?¯ÿÿÿv$è7¯ÿÿÿv(è/¯ÿÿÿv,è'¯ÿÿÿv0è ¯ÿÿÿv4è¯ÿÿÿv è¯ÿÿÿv8è¯ÿÿÿv<èÿ®ÿÿƒÄ@ÿv@èô®ÿÿÿvDèì®ÿÿÿvHèä®ÿÿÿvLèÜ®ÿÿÿvPèÔ®ÿÿÿvTèÌ®ÿÿÿvXèÄ®ÿÿÿv\è¼®ÿÿÿv`è´®ÿÿÿvd謮ÿÿÿvh褮ÿÿÿvl蜮ÿÿÿvpè”®ÿÿÿvt茮ÿÿÿvxè„®ÿÿÿv|è|®ÿÿƒÄ@ÿ¶€ èn®ÿÿÿ¶„ èc®ÿÿÿ¶ˆ èX®ÿÿÿ¶Œ èM®ÿÿÿ¶ èB®ÿÿÿ¶” è7®ÿÿÿ¶˜ è,®ÿÿÿ¶œ è!®ÿÿÿ¶ è®ÿÿÿ¶¤ è ®ÿÿÿ¶¨ è ®ÿÿƒÄ,^]ËÿU‹ìV‹u…öt5‹;H A tPèÝÿÿY‹F;L A tPèËÿÿY‹v;5P A tVè¹ÿÿY^]ËÿU‹ìV‹u…öt~‹F ;T A tPè—ÿÿY‹F;X A tPè…ÿÿY‹F;\ A tPèsÿÿY‹F;` A tPèaÿÿY‹F ;d A tPèOÿÿY‹F ;h A tPè=ÿÿY‹v$;5l A tVè+ÿÿY^]ËÿU‹ì‹ES3ÛVW;Ãt‹} ;ûwè¡©ÿÿj^‰0SSSSSè*©ÿÿƒÄ‹Æë<‹u;óuˆëÚ‹Ð8tBOuø;ût
BF:ËtOuó;ûuˆèZ©ÿÿj"Y‰‹ñëµ3À_^[]ÃÌÌÌÌÌÌU‹ìV3ÀPPPPPPPP‹U I Š
Àt ƒÂ«$ëñ‹uƒÉÿI ƒÁŠ
Àt ƒÆ£$sî‹ÁƒÄ ^ÉËÿU‹ìSV‹u3ÛW9]u;óu9] u3À_^[]Ã;ót‹} ;ûwę̀ÿÿj^‰0SSSSSèU¨ÿÿƒÄ‹ÆëÕ9]uˆ ëÊ‹U;Óuˆ ëу}ÿ‹ÆuŠ
ˆ@B:Ët OuóëŠ
ˆ@B:ËtOtÿMuî9]uˆ;ûu‹ƒ}ÿu‹E jPˆ\ÿXéxÿÿÿˆ èR¨ÿÿj"Y‰‹ñë‚‹ÿU‹ì‹MS3ÛVW;Ët‹} ;ûwè,¨ÿÿj^‰0SSSSS赧ÿÿƒÄ‹Æë0‹u;óuˆëÚ‹ÑŠˆBF:ÃtOuó;ûuˆèñ§ÿÿj"Y‰‹ñëÁ3À_^[]ÃÌÌÌÌÌÌÌÌÌÌÌÌÌ‹T$‹L$÷ u<‹:u.
Àt&:au%
ät Áè:Au
Àt:auƒÁƒÂ
äuÒ‹ÿ3ÀÃÀÑàƒÀÃ÷ tŠƒÂ:uçƒÁ
ÀtÜ÷ t¤f‹ƒÂ:uÎ
ÀtÆ:auÅ
ät½ƒÁëˆÌÌÌÌÌÌÌÌU‹ìWV‹u ‹M‹}‹Á‹ÑÆ;þv;ø‚¤ ù r ƒ=ˆ*A tWVƒçƒæ;þ^_u^_]é, ÷Ç uÁéƒâƒùr*ó¥ÿ$•T‘@ ‹Çº ƒér ƒàÈÿ$…h@ ÿ$d‘@ ÿ$è@ x@ ¤@ È@ #ÑŠˆŠFˆGŠFÁéˆGƒÆƒÇƒùrÌó¥ÿ$•T‘@ I #ÑŠˆŠFÁéˆGƒÆƒÇƒùr¦ó¥ÿ$•T‘@ #ÑŠˆƒÆÁéƒÇƒùrˆó¥ÿ$•T‘@ I K‘@ 8‘@ 0‘@ (‘@ ‘@ ‘@ ‘@ ‘@ ‹DŽä‰Dä‹DŽè‰Dè‹DŽì‰Dì‹DŽð‰Dð‹DŽô‰Dô‹DŽø‰Dø‹DŽü‰Dü ðøÿ$•T‘@ ‹ÿd‘@ l‘@ x‘@ Œ‘@ ‹E^_Éʈ‹E^_ÉʈŠFˆG‹E^_ÉÃI ŠˆŠFˆGŠFˆG‹E^_ÉÃt1ü|9ü÷Ç u$Áéƒâƒùr
ýó¥üÿ$•ð’@ ‹ÿ÷Ùÿ$ ’@ I ‹Çº ƒùr ƒà+Èÿ$…ô‘@ ÿ$ð’@ ’@ (’@ P’@ ŠF#шGƒîÁéƒïƒùr²ýó¥üÿ$•ð’@ I ŠF#шGŠFÁéˆGƒîƒïƒùrˆýó¥üÿ$•ð’@ ŠF#шGŠFˆGŠFÁéˆGƒîƒïƒù‚Vÿÿÿýó¥üÿ$•ð’@ I ¤’@ ¬’@ ´’@ ¼’@ Ä’@ Ì’@ Ô’@ ç’@ ‹DŽ ‰D ‹DŽ‰D‹DŽ‰D‹DŽ‰D‹DŽ ‰D ‹DŽ‰D‹DŽ‰D ðøÿ$•ð’@ ‹ÿ “@ “@ “@ ,“@ ‹E^_ÉÊFˆG‹E^_ÉÃI ŠFˆGŠFˆG‹E^_ÉÊFˆGŠFˆGŠFˆG‹E^_ÉÃÌÌÌÌÌÌÌÌÌÌÌU‹ìV3ÀPPPPPPPP‹U I Š
Àt ƒÂ«$ëñ‹u‹ÿŠ
Àt ƒÆ£$sñFÿƒÄ ^ÉËÿU‹ìQQ‹E V‹u‰Eø‹EWV‰Eüè ƒÏÿY;Çuèi£ÿÿÇ ‹Ç‹×ëJÿuMüQÿuøPÿ á@ ‰Eø;Çuÿ\à@ …Àt Pè[£ÿÿYëÏ‹ÆÁø‹… *A ƒæ ÁæD0€ ý‹Eø‹Uü_^ÉÃjh(ø@ èO£ÿÿƒÎÿ‰u܉uà‹Eƒøþu è £ÿÿƒ èå¢ÿÿÇ ‹Æ‹ÖéÐ 3ÿ;Ç|;*A r!èÖ¢ÿÿ‰8è¼¢ÿÿÇ WWWWWèD¢ÿÿƒÄëÈ‹ÈÁù *A ‹ðƒæ Áæ‹ ¾L1ƒáu&è•¢ÿÿ‰8è{¢ÿÿÇ WWWWWè¢ÿÿƒÄƒÊÿ‹Âë[Pèp Y‰}ü‹öD0t ÿuÿuÿu ÿuè©þÿÿƒÄ‰E܉Uàëè-¢ÿÿÇ è5¢ÿÿ‰8ƒMÜÿƒMàÿÇEüþÿÿÿè ‹EÜ‹Uàè’¢ÿÿÃÿuè YËÿU‹ìÿ A h è¤ÿÿY‹M‰A…Àt
ƒI ÇA ëƒI A‰AÇA ‹Aƒa ‰]ËÿU‹ìƒìSVWèb¹ÿÿƒeü ƒ=)A ‹Ø…Ž h ô@ ÿœà@ ‹ø…ÿ„* ‹5(à@ hôó@ WÿÖ…À„ P謸ÿÿÇ$äó@ W£)A ÿÖPè—¸ÿÿÇ$Ðó@ W£”)A ÿÖP肸ÿÿÇ$´ó@ W£˜)A ÿÖPèm¸ÿÿY£ )A …Àthœó@ WÿÖPèU¸ÿÿY£œ)A ¡œ)A ;ÃtO9 )A tGP賸ÿÿÿ5 )A ‹ð覸ÿÿYY‹ø…öt,…ÿt(ÿÖ…ÀtMøQj MìQjPÿ×…ÀtöEôu M ë9¡”)A ;Ãt0Pèc¸ÿÿY…Àt%ÿЉEü…Àt ¡˜)A ;ÃtPèF¸ÿÿY…ÀtÿuüÿЉEüÿ5)A è.¸ÿÿY…Àtÿuÿu ÿuÿuüÿÐë3À_^[ÉËÿU‹ì‹MV3ö;Î| ƒù~ ƒùu¡D A ë(¡D A ‰
D A ëè ÿÿVVVVVÇ èšŸÿÿƒÄƒÈÿ^]ÃjhHø@ è9 ÿÿ3À‹]3ÿ;ß•À;Çu èØŸÿÿÇ WWWWWè`ŸÿÿƒÄƒÈÿëSƒ=„*A u8jèU§ÿÿY‰}üSèÖÿÿY‰Eà;Çt ‹süƒî ‰uäë‹uäÇEüþÿÿÿè% 9}àuSWÿ5t)A ÿá@ ‹ð‹ÆèùŸÿÿÃ3ÿ‹]‹uäjè#¦ÿÿYÃjè‰ÿÿYËÿU‹ìì( ¡€A 3ʼnEüö A Vtj
è3¾ÿÿYè
Åÿÿ…Àtjè ÅÿÿYö A „Ê ‰…àýÿÿ‰Üýÿÿ‰•Øýÿÿ‰Ôýÿÿ‰µÐýÿÿ‰½ÌýÿÿfŒ•øýÿÿfŒìýÿÿfŒÈýÿÿfŒ…ÄýÿÿfŒ¥ÀýÿÿfŒ¼ýÿÿœ…ðýÿÿ‹uE‰…ôýÿÿÇ…0ýÿÿ ‰µèýÿÿ‹@üjP‰…äýÿÿ…Øüÿÿj Pè:‚ÿÿ…ØüÿÿƒÄ ‰…(ýÿÿ…0ýÿÿj Ç…Øüÿÿ @‰µäüÿÿ‰…,ýÿÿÿTà@ …(ýÿÿPÿPà@ jèýŠÿÿÌÌÌU‹ìSVWUj j h™@ ÿuèV" ]_^[‹å]ËL$÷A ¸ t2‹D$‹Hü3Èè²…ÿÿU‹h‹P(R‹P$Rè ƒÄ]‹D$‹T$‰¸ ÃSVW‹D$UPjþh™@ dÿ5 ¡€A 3ÄPD$d£ ‹D$(‹X‹p ƒþÿt:ƒ|$,ÿt;t$,v-4v‹ ³‰L$ ‰H ƒ|³ uh ‹D³èI ‹D³è_ ë·‹L$d‰
ƒÄ_^[Ã3Àd‹
y™@ u‹Q ‹R 9Qu¸ ÃSQ»” A ë SQ»” A ‹L$ ‰K‰C‰k UQPXY]Y[ ÿÐËÿU‹ìƒìVWÿuMì资ÿÿ‹E‹u 3ÿ;Çt‰0;÷u,èÑœÿÿWWWWWÇ èYœÿÿƒÄ€}ø t‹Eôƒ`pý3ÀéØ 9}t ƒ}|Ƀ}$ËMìSŠ ‰}ü~ƒ¹¬ ~EìP¶ÃjPèe¹ÿÿ‹MìƒÄ ë‹‘È ¶Ã·Bƒà…ÀtŠ GëÇ€û-uƒMë€û+uŠ G‹E…ÀŒK ƒø„B ƒø$9 …Àu*€û0t ÇE
ë4Š·É¶ÒÁá Ê9M u Hë ·Ñ9U t
@f¶·Éf;ËuÇ·É9M u8]üt‹Møƒapýë8]üt‹Eøƒ`pý3À^[ÉËÿU‹ìj ÿu ÿuè2ÿÿÿƒÄ ]ÃÌÌÌBÿ[ä$ d$ 3ÀŠD$S‹ØÁà‹T$÷ tŠ
ƒÂ:ËtÏ„ÉtQ÷ uë ØW‹ÃÁãV Ø‹
¿ÿþþ~‹Á‹÷3Ëðùƒñÿƒðÿ3Ï3ƃÂá u % tÓ% uæ €uÄ^_[3ÀËBü:Ãt6„Àtï:ãt'„ätçÁè:Ãt„ÀtÜ:ãt„ätÔë–^_Bÿ[ÃBþ^_[ÃBý^_[ÃBü^_[Ãÿ%Ðà@ ‹ÿU‹ì‹US3Û;Óu è¬{ÿÿSSSSSÇ è4{ÿÿƒÄƒÈÿë 8tß‹M ;ËtØ‹;ÃtÒ8tÎSQRè ƒÄ []ËÿU‹ìƒì ‹UV‹ujþX‰Eì‰Uä;ðuèc{ÿÿƒ èH{ÿÿÇ ƒÈÿéˆ S3Û;ó|;5*A r'è9{ÿÿ‰è {ÿÿSSSSSÇ è§zÿÿƒÄƒÈÿéQ ‹ÆÁøW<… *A ‹ƒæ ÁæÆŠHöÁuèózÿÿ‰èÙzÿÿÇ ëjúÿÿÿwP‰]ð;Ó„ öÁ…ÿ 9] t7Š@$ÀÐøˆEþ¾ÀHjYt Hu‹Â÷Шtƒâþ‰U‹E ‰Eôé ‹Â÷Шu!è‡zÿÿ‰èmzÿÿÇ SSSSSèõyÿÿƒÄë4‹ÂÑè‰M;Ár‰Eÿuèz|ÿÿY‰Eô;Ãu è5zÿÿÇ è=zÿÿÇ ƒÈÿéh jSSÿuè|Öÿÿ‹‰D(‹EôƒÄ‰T,‹ÎöAHttŠI€ù
tl9]tgˆ‹@ÿMÇEð ÆD
8]þtN‹ŠL%€ù
tC9]t>ˆ‹@ÿM€}þÇEð ÆD%
u$‹ŠL&€ù
t9]tˆ‹@ÿMÇEð ÆD&
SMèQÿuP‹ÿ4ÿ,á@ …À„{ ‹Mè;ËŒp ;M‡g ‹MðDö €„æ €}þ„ ;Ët
‹Mô€9
u€ë€ û‹]ô‹EðÉ]‰Eð;؃Р‹MŠ<„® <
t ˆCA‰Mé ‹EðH;ÈsA€8
u
AA‰MÆ
ëu‰EëmÿEj EèPjEÿP‹ÿ4ÿ,á@ …Àu
ÿ\à@ …ÀuEƒ}è t?‹öDHt€}ÿ
t¹Æ
‹ŠMÿˆLë%;]ôu€}ÿ
t jjÿjÿÿuèØÔÿÿƒÄ€}ÿ
tÆ
C‹Eð9E‚Gÿÿÿë‹Dö @u€ëŠˆC‹Ã+Eô€}þ‰Eð…Ð …À„È KŠ „ÉxCé† 3À@¶Éëƒø;]ôrK¶ @€¹à A t芶ʾ‰à A …Éu
èàwÿÿÇ * ëzA;ÈuØë@‹ÎöAHt$CƒøˆQ| Š‹ˆT%Cƒøu Š‹ˆT&C+Øë÷Ø™jRPÿuèþÓÿÿƒÄ‹Eä+]ôÑèPÿu Sÿuôj héý ÿìà@ ‰Eð…Àu4ÿ\à@ Pè…wÿÿYƒMìÿ‹Eô;E tPèµzÿÿY‹Eìƒøþ…‹ ‹Eðéƒ ‹Eð‹3É;ÕÁÀ‰Eð‰L0ëÆ;Ët‹Môfƒ9
u€ë€ û‹]ô‹EðÉ]‰Eð;؃ÿ ‹E·fƒù„× fƒù
tf‰ CC@@‰Eé´ ‹MðƒÁþ;Ás Hfƒ9
u
ƒÀ‰Ej
éŽ ‰Mé„ ƒEj EèPjEøP‹ÿ4ÿ,á@ …Àu
ÿ\à@ …Àu[ƒ}è tU‹öDHt(fƒ}ø
t²j
Xf‰‹ŠMøˆL‹ŠMùˆL%‹ÆD&
ë*;]ôufƒ}ø
t…jjÿjþÿuèšÒÿÿƒÄfƒ}ø
tj
Xf‰CC‹Eð9E‚ÿÿÿë‹tö@u€ëf‹ f‰CC+]ô‰]ðé‘þÿÿÿ\à@ j^;ÆuèÙuÿÿÇ èáuÿÿ‰0éiþÿÿƒøm…Yþÿÿ‰]ìé\þÿÿ3À_[^ÉÃjhðø@ èïuÿÿ‹Eƒøþuè©uÿÿƒ èŽuÿÿÇ ƒÈÿé¾ 3ö;Æ|;*A r!è€uÿÿ‰0èfuÿÿÇ VVVVVèîtÿÿƒÄëÉ‹ÈÁù *A ‹øƒç Áç‹ ¾L9ƒát¿¹ÿÿÿ;MÉAuè2uÿÿ‰0èuÿÿÇ ë°Pè ãÿÿY‰uü‹öD8tÿuÿu ÿuè~ùÿÿƒÄ ‰EäëèâtÿÿÇ èêtÿÿ‰0ƒMäÿÇEüþÿÿÿè ‹EäèNuÿÿÃÿuèiãÿÿYËÿU‹ìƒì0S3ÛöE€VW‹ð‰]àˆ]þÇEÐ ‰]Ôt ‰]ØÆEÿë
ÇEØ ˆ]ÿEàPè
Y…Àt
SSSSSèÒrÿÿƒÄ‹M¸ € …Èu÷Á @ u9Eàt€Mÿ€‹Áƒà+ú À¿ €tGHt.Ht&è7tÿÿ‰ƒÿètÿÿj^SSSSS‰0è£sÿÿƒÄé ‰UøëöÁt÷Á uîÇEø @ë‰}ø‹EjY+Át7+Át*+Át +Átƒè@u¡9}ø”À‰Eðë ÇEð ëÇEð ë ÇEð ë‰]ð‹Eº #¹ ;Á¿ ;t0;Ãt,;Çt = „” = …@ÿÿÿÇEì ë/ÇEì ë&ÇEì ë = t= t`;Â…ÿÿÿÇEì ‹EÇEô€ …Çt‹
A ÷Ñ#M„ÉxÇEô ¨@tMô Mø ƒMð© t }ô¨ tMô ëÇEì 릨tMô è£áÿÿ‰ƒøÿuèÎrÿÿ‰ƒÿè±rÿÿÇ éŽ ‹E‹= á@ SÿuôÇ ÿuìEÐPÿuðÿuøÿu ÿ׉Eäƒøÿum‹Mø¸ À#È;Èu+öEt%eøÿÿÿSÿuôEÐÿuìPÿuðÿuøÿu ÿ׉Eäƒøÿu4‹6‹ÆÁø‹… *A ƒæ ÁæD0€ þÿ\à@ Pè?rÿÿYèrÿÿ‹ ét ÿuäÿ<à@ ;ÃuD‹6‹ÆÁø‹… *A ƒæ ÁæD0€ þÿ\à@ ‹ðVèüqÿÿYÿuäÿá@ ;óu°èÃqÿÿÇ
룃øu€Mÿ@ë ƒøu€Mÿÿuäÿ6è4Þÿÿ‹‹Ðƒà Áú‹• *A YÁàYŠMÿ€ÉˆL‹‹Ðƒà Áú‹• *A ÁàD$€ €ˆMý€eýHˆMÿ…€ öÁ€„± öEtqjƒÏÿWÿ6è£ ƒÄ ‰Eè;Çuè:qÿÿ8ƒ tMÿ6èéÙÿÿéúþÿÿjEüPÿ6ˆ]üè’õÿÿƒÄ …Àu€}üu‹Eè™RPÿ6è ƒÄ ;ÇtÃSSÿ6èF ƒÄ ;Çt³öEÿ€„0 ¿ @ ¹ @ …}u‹Eà#Çu Më E‹E#Ç;ÁtD= t)= @ t"= t)= @ t"= t= @ u ÆEþë‹M¸ #È;Èu ÆEþëˆ]þ÷E „µ öEÿ@‰]è…¨ ‹Eø¹ À#Á= @„· = €tw;Á…„ ‹Eì;Æy ƒøvƒøv0ƒø…f ¾Eþ3ÿH„& H…R ÇEèÿþ ÇEì é jSSÿ6è8ÌÿÿƒÄ ÂtÇSSSÿ6è'Ìÿÿ#ƒăøÿ„ŽþÿÿjEèPÿ6è/ôÿÿƒÄ ƒøÿ„uþÿÿƒøtkƒø… }è uYÆEþéÜ ‹Eì;Ã†Ñ ƒø†bÿÿÿƒø‡PÿÿÿjSSÿ6è¸ËÿÿƒÄ „CÿÿÿSSSÿ6è£ËÿÿƒÄ#ƒøÿ…‘ éþÿÿ‹Eè%ÿÿ =þÿ uÿ6èß×ÿÿYèoÿÿj^‰0‹Æéd =ÿþ u Sjÿ6èX ƒÄ ƒøÿ„ÀýÿÿÆEþëASSÿ6è= ƒÄ ë™ÇEè ÇEì ‹Eì+ÇPD=èPÿ6è¸ÿÿƒÄ ƒøÿ„€ýÿÿø9}ìÛ‹‹ÈÁù‹ *A ƒà ÁàD$Š2Mþ€á0‹‹ÈÁù‹ *A ƒà ÁàD$‹MŠÁéÀá€â
ʈ8]ýu!öEt‹‹Èƒà Áù‹ *A ÁàD€ ‹}ø¸ À‹Ï#È;Èu|öEtvÿuäÿá@ SÿuôEÐjPÿuðçÿÿÿWÿu ÿ á@ ƒøÿu4ÿ\à@ Pèÿmÿÿ‹‹Èƒà Áù‹ *A ÁàD€ þÿ6èÏÚÿÿYé˜ûÿÿ‹6‹ÎÁù‹ *A ƒæ Á手Ã_^[ÉÃjhù@ èÓmÿÿƒMäÿ3ö‰uà3À9u•À;Æu èmmÿÿÇ VVVVVèõlÿÿƒÄƒÈÿër‰uüÿuj@ÿu ÿuEàPEäè‰øÿÿƒÄ‰EÜÇEüþÿÿÿè ‹}Ü;þt<è mÿÿ‰8ë¿3ö9uàt+9uÜt ‹EäÁø‹Mäƒá Áá‹… *A D€ þÿuäèÛÿÿYËEäèomÿÿËÿU‹ìQQV3ö9uu èÉlÿÿVVVVVÇ èQlÿÿƒÄƒÈÿëJ9u tÞÿuEøPEüPÿuÿu è| ƒÄƒøÿtØÿuøÿuüÿujèU ÿuü‹ðèÝoÿÿÿuøèÕoÿÿƒÄ‹Æ^ÉËÿU‹ìƒìSW‹}3Û‰}ü;ûu èIlÿÿSSSSSÇ èÑkÿÿƒÄƒÈÿéá 8 tÜ‹E ;ÃtÕ‹ ;ÃtÏ8tËVj\Wè j/W‹ðè
ƒÄ;Ã… ;ó…ƒ j:Wè=ïÿÿ‹ðYY;óusWèIšÿÿ‹ðƒÆjVèMnÿÿ‹øƒÄ ‰}ü;û„ htô@ VWèkÃÿÿƒÄ …Àt
SSSSSèjÿÿƒÄÿuVWèØÁÿÿƒÄ …Àt
SSSSSèõiÿÿƒÄw‹}ë
;ót;Æv‹ðƒMðÿj.Vèh YY…Àt,Sÿuüè
YY…À…ì ÿuÿu ÿuüè`þÿÿƒÄ ‰EðéÓ ÿuüè–™ÿÿ‹ðƒÆjVèšmÿÿƒÄ ‰Eø;ÃuƒÈÿé½ ÿuüVPè¸ÂÿÿƒÄ …Àt
SSSSSè`iÿÿƒÄÿuüèQ™ÿÿ‹ø}øYèÚjÿÿ‹ ‰Eì‹Eø+÷ðÇEôì A ‹Eôÿ0VWèrÂÿÿƒÄ …Àt
SSSSSèiÿÿƒÄSÿuøè] YY…Àtƒmô}ôà A }Äë è„jÿÿÿu‹Mìÿu ‰ÿuøè”ýÿÿƒÄ ‰EðÿuøèÌmÿÿ‹}Y9}üt ÿuüè»mÿÿY‹Eð^_[ÉËÿU‹ìƒìSVW3ÛjSSÿu‰]ð‰]ôè–Æÿÿ‰Eè#ƒĉUìƒøÿtYjSSÿuèzÆÿÿ‹È#ʃăùÿtA‹u ‹}+ðúˆÆ ;ó†¼ » Sjÿ4á@ Pÿdà@ ‰Eü…ÀuèÇiÿÿÇ è¼iÿÿ‹ _^[ÉÃh € ÿuèŠ YY‰Eø…ÿ|
;ór‹Ãë‹ÆPÿuüÿu謫ÿÿƒÄ ƒøÿt6™+ðúxÓ…öwÏ‹uðÿuøÿuèF YYÿuüj ÿ4á@ Pÿ`à@ 3Ûé† èWiÿÿƒ8u è:iÿÿÇ
ƒÎÿ‰uôë½;ûq|;óskSÿuÿu ÿuèÅÿÿ#ƒăøÿ„Dÿÿÿÿuè›ÖÿÿYPÿ0á@ ÷ØÀ÷ØH™‰Eð#‰Uôƒøÿu)èÛhÿÿÇ
èãhÿÿ‹ðÿ\à@ ‰‹uð#uôƒþÿ„öþÿÿSÿuìÿuèÿuèÅÿÿ#ƒăøÿ„Ùþÿÿ3ÀéÙþÿÿ‹ÿU‹ìV‹uVè"ÖÿÿYƒøÿuèyhÿÿÇ ƒÈÿëMWÿuj ÿu Pÿ á@ ‹øƒÿÿuÿ\à@ ë3À…Àt PèihÿÿYƒÈÿë‹ÆÁø‹… *A ƒæ ÁæD0€ ý‹Ç_^]ËÿU‹ìS‹] V‹u‹ÆÁø… *A ‹ƒæ Áæ 0ŠA$ÀW¶y¾Àç€ Ñøû @ tPû € tBû t&û t û u=€I€‹
L1$Š€â€Êˆë'€I€‹
L1$Š€â‚€Êëè€aë
€I€‹
L1$€!€…ÿ_^[u¸ € ]Ã÷ØÀ% À @ ]ËÿU‹ì‹EV3ö;Æu èNgÿÿVVVVVÇ èÖfÿÿƒÄjXë
‹
d*A ‰3À^]ËÿU‹ìƒìh‹ES3ÛW‰]ôˆ]ÿ;Ãtƒøt~ƒø~ ƒøu ÆEÿ‹E‰Eðë8ègÿÿ‰èçfÿÿSSSSSÇ èofÿÿƒÄƒÈÿé® @8uûH8tÆ ‹Á8uëVjD^VE˜SPèdJÿÿ‰u˜‹5*A ƒÄ ;ót+Fÿ‹È‹ÐÁù‹ *A ƒâ Áâ8\uNH;óuà;óŒ@ þ23 ƒ4 ‹ÆkÀƒÀf‰EÊ·ÀjPèÇhÿÿYY‰EÌ;Ä ;ó‰0‹EÌH|0‰]ø~9‹Eø‹Ðƒà ÁúÁà• *A ŠPöÂuˆ‹ ‰ëˆƒÿÿEøAƒÇ9uø|Ê‹EÌ8]ÿt,H3ÒD0ƒþ}‹þëj_;×} ˆƒÿBAƒÀëäÇEô èÎeÿÿ‰EÜPE˜PSÿuÿuôjSSÿuðÿu ÿ à@ ‹ðÿ\à@ ÿuÌ‹øèñhÿÿY;óu Wè£eÿÿYëXƒ}uSè4Rÿÿ‹5á@ 9]u jÿÿuÜÿà@ EìPÿuÜÿà@ ‹]ìëƒ}uÿuÜÿÖë‹]ÜÿuàÿÖ‹Ãëè(eÿÿÇ ƒÈÿ^_[ÉËÿU‹ìƒì@¡€A 3ʼnEü‹M ‹ESVW¾xô@ }ð¥¥f¥‰MÔ‹M3Û‰Mà‹M¤j‰EÈ‹ø‹ ‰Mè‰]܉]ì‰]Ä^ëPè2“ÿÿƒÇt‹Y;ÃuìjV‰uÌè*gÿÿ‹uàYY‰;Ãu#‹Eè‰è˜dÿÿÇ è dÿÿÇ ƒÈÿé/ EðPEìSPè¼ÚÿÿƒÄ ;ÃtƒøuqSSSSSèËbÿÿƒÄëbEðPè¹’ÿÿ‹øGGY‰}Ð9]ìtÿuì褒ÿÿøY‰}ЋEÔ;ÃtOj‹ð‹ _ëP舒ÿÿƒÆ|‹Y;Ãuì¡< A ;ÃuCèíÿÿ£< A ;Ãu5‹uàÿ6ƒMÜÿèRgÿÿ‹Eè‰ Y‰ée ‹E艋}È‹‹6;Ã…ñ FéU ‰]ä8t(Š‹ð€ù=t Vè’ÿÿY‹MäL¡< A 4‰MäŠ:ËuÜ‹Mä‰MØë+8Xt-€x:u'€x=u!ƒÀPèÝ‘ÿÿY‹MØD‹
< A ‰EØÁ€8=t΋EØ+Eä‹uÔø‰}Àë EðP謑ÿÿPEðPÿ6è ƒÄ…ÀtMƒÆ9 uÝ}ÐjWè˜eÿÿ‹uàYY‹Mè‰;Ã…2ÿÿÿÿ6èkfÿÿY‰ èúbÿÿÇ ècÿÿƒMÜÿÇ éi ÇEÄ ë´P‹Æ+ÆEÌPVèºÿÿƒÄ …Àt
SSSSSè'aÿÿƒÄÿ7è‘ÿÿtƒÇë6P‹Eà‹ +ÆEÌPVèIºÿÿƒÄ …Àt
SSSSSèñ`ÿÿƒÄÿ7èãÿÿðƒÇÆ FY‹;ÃuËEèˆ^ÿˆ ‹09]Ô„Í ‹}Ø‹Eä‹Ï+ÈQ‹
< A ÈQVèöºÿÿ+}äƒÄ ÷‹}Ôë6‹EÀ‹Mèÿ7+ÆPVèѹÿÿƒÄ …Àt
SSSSSèy`ÿÿƒÄÿ7èkÿÿYtƒÇ9 uÆ9]Äug‹}ÐEðPWVè—¹ÿÿƒÄ …Àt
SSSSSè?`ÿÿƒÄh`ã@ WVè¸ÿÿƒÄ …Àt
SSSSSè `ÿÿƒÄ9]ìt ÿuìWVèß·ÿÿƒÄ …Àt
SSSSSèü_ÿÿƒÄ÷;ót ‹Eè;0uˆ Fˆ ¡< A ;ÃtPèÑdÿÿY‰ < A 9]ìt ÿuìè½dÿÿY‹EÜ‹Mü_^3Í[èIÿÿÉËÿU‹ìV3ö9uu$èBaÿÿ‰0è(aÿÿVVVVVÇ è°`ÿÿƒÄjXëU÷E ùÿÿÿuÓÿuÿ8á@ ƒøÿuÿ\à@ PèaÿÿYèç`ÿÿ‹ ë(¨u"¨t öE tèã`ÿÿÇ èÅ`ÿÿÇ
ëÑ3À^]ËÿU‹ìƒìSÿu3ÛMì‰]üèlHÿÿ‹M;Ëu(è“`ÿÿSSSSSÇ è`ÿÿƒÄ8]øt‹Eôƒ`pý3ÀëqV‹uð9^uÿu Qèj YY8]øtW‹MôƒapýëNWŠ¶Â¶øöD7 t!AŠ:Ót¶úÁà Ç9E uAÿ‰Eüë
9]üë9E u‰MüA:ÓuÃ_8]øt‹Eôƒ`pý‹Eü^[ÉËÿU‹ìj ÿu ÿuè2ÿÿÿƒÄ ]ËÿU‹ìƒìS3Û9]u3Àéš ÿuMìèGÿÿ‹Eð9Xu&ÿuÿu ÿuèÇÔÿÿƒÄ 8]ø„m ‹Môƒapýéa W‹};ût9] u.èƒ_ÿÿSSSSSÇ è _ÿÿƒÄ8]øt‹Eôƒ`pý¸ÿÿÿé% Vf¶ÿM·É¶ÑGöD ‰MütCŠ:Óu‰]üëXÁáf¶Òf Ê·Éf‹ñG‰Müf;pr f;pwfpë6f;pr0f;pw*fpë$·Uü öA t
f¶‰ ·Éë·Ê‰Müf‹uü‹M f¶ ÿE ·É¶ÑöD ‰MütE‹U Š:Óu‰]üëWÁáf¶Òf ÊÿE ·É‰Müf;Hr f;HwfHë6f;Hr0f;Hw*fHë$·Uü öA t
f¶‰ ·Éë·Ê‰Müf‹Müf;Îu!f;ót 9]…ëþÿÿ8]øt‹Eôƒ`pý3À^_[ÉÃÀƒàH8]øtð‹Môƒapýëç‹ÿU‹ìj ÿuÿu ÿuè#þÿÿƒÄ]ÃÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌU‹ìW‹}3ÀƒÉÿò®ƒÁ÷ÙƒïŠE ýò®ƒÇ8t3Àë‹Çü_Éà ”ú °ú Æú Üú îú û û 4û Lû `û hû zû ˆû šû ¬û ¼û Êû Üû ôû ü ü 8ü Vü jü zü †ü ’ü žü ¶ü Îü Øü äü öü ý ý ý (ý 8ý Ný Zý jý ’ý ¬ý Äý Þý ôý þ þ *þ Dþ Tþ jþ „þ þ žþ ®þ ¾þ Ðþ äþ ôþ
ÿ ÿ ,ÿ >ÿ Pÿ bÿ nÿ |ÿ Œÿ ¢ÿ ²ÿ Âÿ Ðÿ âÿ ôÿ ( 8 J ç@ ²A@ 4K@ ÎX@ Ð_@ »¬@ ˜@ failed to get exit code from process.
failed to create process.
%s %s Could not exec %s Cannot find Python executable %s
#!python.exe #! Cannot open %s
-script.py CorExitProcess m s c o r e e . d l l ( n u l l ) (null) EEE50 P ( 8PX 700WP `h```` xpxxxx ¨!A "A
!"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ = EncodePointer K E R N E L 3 2 . D L L DecodePointer FlsFree FlsSetValue FlsGetValue FlsAlloc runtime error
TLOSS error
SING error
DOMAIN error
R6034
An application has made an attempt to load the C runtime library incorrectly.
Please contact the application's support team for more information.
R6033
- Attempt to use MSIL code from this assembly during native code initialization
This indicates a bug in your application. It is most likely the result of calling an MSIL-compiled (/clr) function from a native constructor or from DllMain.
R6032
- not enough space for locale information
R6031
- Attempt to initialize the CRT more than once.
This indicates a bug in your application.
R6030
- CRT not initialized
R6028
- unable to initialize heap
R6027
- not enough space for lowio initialization
R6026
- not enough space for stdio initialization
R6025
- pure virtual function call
R6024
- not enough space for _onexit/atexit table
R6019
- unable to open console device
R6018
- unexpected heap error
R6017
- unexpected multithread lock error
R6016
- not enough space for thread data
This application has requested the Runtime to terminate it in an unusual way.
Please contact the application's support team for more information.
R6009
- not enough space for environment
R6008
- not enough space for arguments
R6002
- floating point support not loaded
Microsoft Visual C++ Runtime Library
... Runtime Error!
Program: À À – À À Ž À À À ‘ À ’ À “ À €€†€€ †€†‚€EEE……… 00€P€ˆ ('8PW€ 700PPˆ (€ˆ€€ `h`hhhxppwpp ( ( ( ( ( H „ „ „ „ „ „ „ „ „ „ ‚ ‚ ‚ ‚ ‚ ‚ h ( ( ( ( H „ „ „ „ „ „ „ „ „ „ ‚‚‚‚‚‚ H €‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ ¡¢£¤¥¦§¨©ª«¬®¯°±²³´µ¶·¸¹º»¼½¾¿ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖ×ØÙÚÛÜÝÞßàáâãäåæçèéêëìíîïðñòóôõö÷øùúûüýþÿ
!"#$%&'()*+,-./0123456789:;<=>?@abcdefghijklmnopqrstuvwxyz[\]^_`abcdefghijklmnopqrstuvwxyz{|}~€‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ ¡¢£¤¥¦§¨©ª«¬®¯°±²³´µ¶·¸¹º»¼½¾¿ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖ×ØÙÚÛÜÝÞßàáâãäåæçèéêëìíîïðñòóôõö÷øùúûüýþÿ€‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ ¡¢£¤¥¦§¨©ª«¬®¯°±²³´µ¶·¸¹º»¼½¾¿ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖ×ØÙÚÛÜÝÞßàáâãäåæçèéêëìíîïðñòóôõö÷øùúûüýþÿ
!"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`ABCDEFGHIJKLMNOPQRSTUVWXYZ{|}~€‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ ¡¢£¤¥¦§¨©ª«¬®¯°±²³´µ¶·¸¹º»¼½¾¿ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖ×ØÙÚÛÜÝÞßàáâãäåæçèéêëìíîïðñòóôõö÷øùúûüýþÿHH:mm:ss dddd, MMMM dd, yyyy MM/dd/yy PM AM December November October September August July June April March February January Dec Nov Oct Sep Aug Jul Jun May Apr Mar Feb Jan Saturday Friday Thursday Wednesday Tuesday Monday Sunday Sat Fri Thu Wed Tue Mon Sun GetProcessWindowStation GetUserObjectInformationA GetLastActivePopup GetActiveWindow MessageBoxA USER32.DLL SunMonTueWedThuFriSat JanFebMarAprMayJunJulAugSepOctNovDec CONOUT$ .com .exe .bat .cmd .\ SystemRoot H €A Ðô@ Ð7 i ™ þÿÿÿ Ôÿÿÿ þÿÿÿ ×@ þÿÿÿ Èÿÿÿ þÿÿÿ ¼#@ þÿÿÿ Ìÿÿÿ þÿÿÿ©%@ ½%@ þÿÿÿ Œÿÿÿ þÿÿÿ<5@ @5@ þÿÿÿ Ôÿÿÿ þÿÿÿ ã:@ þÿÿÿ Ðÿÿÿ þÿÿÿ ±;@ þÿÿÿ Ìÿÿÿ þÿÿÿ ;=@ =@ þÿÿÿ Ôÿÿÿ þÿÿÿ À>@ þÿÿÿ Ôÿÿÿ þÿÿÿ ó?@ þÿÿÿ Ôÿÿÿ þÿÿÿ A@ 9A@ þÿÿÿ Ôÿÿÿ þÿÿÿ -G@ þÿÿÿ Ìÿÿÿ þÿÿÿ ûJ@ þÿÿÿ Ôÿÿÿ þÿÿÿ kN@ þÿÿÿ Ôÿÿÿ þÿÿÿ P@ þÿÿÿ ¼P@ þÿÿÿ Øÿÿÿ þÿÿÿ oR@ þÿÿÿ {R@ þÿÿÿ Ôÿÿÿ þÿÿÿ 5Y@ þÿÿÿ Øÿÿÿ þÿÿÿÛZ@ ïZ@ þÿÿÿ Øÿÿÿ þÿÿÿ-[@ 1[@ þÿÿÿ Àÿÿÿ þÿÿÿ ˆ^@ þÿÿÿ Ðÿÿÿ þÿÿÿ_@ /_@ þÿÿÿ Ôÿÿÿ þÿÿÿ )j@ þÿÿÿ Ðÿÿÿ þÿÿÿ :l@ þÿÿÿ Ôÿÿÿ þÿÿÿ >y@ þÿÿÿ Ðÿÿÿ þÿÿÿ N@ þÿÿÿ Ðÿÿÿ þÿÿÿ /‚@ þÿÿÿ Ìÿÿÿ þÿÿÿ $•@ þÿÿÿ Ðÿÿÿ þÿÿÿ ½—@ þÿÿÿ Ðÿÿÿ þÿÿÿ T¡@ þÿÿÿ Ôÿÿÿ þÿÿÿ Ë¥@ þÿÿÿ Èÿÿÿ þÿÿÿ ‘§@ ͦ@ þÿÿÿ Ðÿÿÿ þÿÿÿ L®@ þÿÿÿ Ðÿÿÿ þÿÿÿ hÂ@ þÿÿÿ Ìÿÿÿ þÿÿÿ Ê@ Tù à ”ú °ú Æú Üú îú û û 4û Lû `û hû zû ˆû šû ¬û ¼û Êû Üû ôû ü ü 8ü Vü jü zü †ü ’ü žü ¶ü Îü Øü äü öü ý ý ý (ý 8ý Ný Zý jý ’ý ¬ý Äý Þý ôý þ þ *þ Dþ Tþ jþ „þ þ žþ ®þ ¾þ Ðþ äþ ôþ
ÿ ÿ ,ÿ >ÿ Pÿ bÿ nÿ |ÿ Œÿ ¢ÿ ²ÿ Âÿ Ðÿ âÿ ôÿ ( 8 J RGenerateConsoleCtrlEvent ÆGetExitCodeProcess nWaitForSingleObject • CreateProcessA ¯SetConsoleCtrlHandler õGetModuleFileNameA Ú EnterCriticalSection ôLeaveCriticalSection úGetModuleHandleW +Sleep "GetProcAddress ExitProcess pGetCommandLineA ðSetHandleCount >GetStdHandle ØGetFileType <GetStartupInfoA ¿ DeleteCriticalSection 7TerminateProcess ªGetCurrentProcess HUnhandledExceptionFilter SetUnhandledExceptionFilter ÖIsDebuggerPresent çGetLastError ¦HeapFree ¢HeapAlloc \GetCPInfo ÅInterlockedIncrement ÁInterlockedDecrement SGetACP GetOEMCP àIsValidCodePage >TlsGetValue <TlsAlloc ?TlsSetValue =TlsFree ôSetLastError ®GetCurrentThreadId —WriteFile öLoadLibraryA ºInitializeCriticalSectionAndSpinCount KFreeEnvironmentStringsA ÀGetEnvironmentStrings LFreeEnvironmentStringsW „WideCharToMultiByte ÂGetEnvironmentStringsW ¤HeapCreate aVirtualFree YQueryPerformanceCounter jGetTickCount «GetCurrentProcessId SGetSystemTimeAsFileTime šRtlUnwind ©HeapReAlloc ^VirtualAlloc „GetConsoleCP –GetConsoleMode BFlushFileBuffers æLCMapStringA MultiByteToWideChar èLCMapStringW @GetStringTypeA CGetStringTypeW éGetLocaleInfoA çSetFilePointer «HeapSize D CloseHandle ŒWriteConsoleA šGetConsoleOutputCP –WriteConsoleW SetStdHandle y CreateFileA S CompareStringA V CompareStringW ØSetEnvironmentVariableA KERNEL32.dll nReadFile ÕSetEndOfFile &GetProcessHeap ÊGetFileAttributesA À+A À+A Næ@»±¿Dê#@ lâ@ \â@ ÿÿÿÿ€
!
5 A
C P R
S
W Y l
m p r €
‚ ƒ „
‘ ) ž
¡ ¤ §
· Î × abcdefghijklmnopqrstuvwxyz ABCDEFGHIJKLMNOPQRSTUVWXYZ abcdefghijklmnopqrstuvwxyz ABCDEFGHIJKLMNOPQRSTUVWXYZ hA ¤ `‚y‚! ¦ß ¡¥ Ÿàü @~€ü ¨ Á£Ú£ þ @þ µ Á£Ú£ þ Aþ ¶ Ï¢ä¢ å¢è¢[ þ @~¡þ Q QÚ^Ú _ÚjÚ2 ÓØÞàù 1~þ lí@ þÿÿÿC A A A A A H A hë@ ðï@ pñ@ ˆ A ˜A ˜A hA ÿÿÿÿÿÿÿÿ øè@ Ìè@ è@
è@ Üç@ ¬ç@ ˆç@ \ç@ $ç@ üæ@ Äæ@ Œæ@ dæ@ Dæ@ àå@ ¨å@ ! °ä@ " ä@ x ä@ y ðã@ z àã@ ü Üã@ ÿ Ìã@ Η@ Η@ Η@ Η@ Η@ Η@ Η@ Η@ Η@ Η@ x
hë@ jí@ ˜ó@ ”ó@ ó@ Œó@ ˆó@ „ó@ €ó@ xó@ pó@ hó@ \ó@ Pó@ Hó@ <ó@ 8ó@ 4ó@ 0ó@ ,ó@ (ó@ $ó@ ó@ ó@ ó@ ó@ ó@ ó@ ó@ øò@ ðò@ èò@ (ó@ àò@ Øò@ Ðò@ Äò@ ¼ò@ °ò@ ¤ò@ ò@ œò@ ò@ |ò@ pò@ ˆ A . D A Œ)A Œ)A Œ)A Œ)A Œ)A Œ)A Œ)A Œ)A Œ)A H A . “ €p ðñÿÿ PST PDT Ð A A ÿÿÿÿ ÿÿÿÿ þÿÿÿþÿÿÿÿÿÿÿ ; Z x — µ Ô ó 0 N m ÿÿÿÿ : Y w – ´ Ó ò / M l lô@ dô@ \ô@ Tô@ setuptools-20.7.0/setuptools/depends.py 0000664 0001750 0001750 00000014422 12702524020 021077 0 ustar travis travis 0000000 0000000 import sys
import imp
import marshal
from imp import PKG_DIRECTORY, PY_COMPILED, PY_SOURCE, PY_FROZEN
from distutils.version import StrictVersion
from setuptools.extern import six
__all__ = [
'Require', 'find_module', 'get_module_constant', 'extract_constant'
]
class Require:
"""A prerequisite to building or installing a distribution"""
def __init__(self, name, requested_version, module, homepage='',
attribute=None, format=None):
if format is None and requested_version is not None:
format = StrictVersion
if format is not None:
requested_version = format(requested_version)
if attribute is None:
attribute = '__version__'
self.__dict__.update(locals())
del self.self
def full_name(self):
"""Return full package/distribution name, w/version"""
if self.requested_version is not None:
return '%s-%s' % (self.name,self.requested_version)
return self.name
def version_ok(self, version):
"""Is 'version' sufficiently up-to-date?"""
return self.attribute is None or self.format is None or \
str(version) != "unknown" and version >= self.requested_version
def get_version(self, paths=None, default="unknown"):
"""Get version number of installed module, 'None', or 'default'
Search 'paths' for module. If not found, return 'None'. If found,
return the extracted version attribute, or 'default' if no version
attribute was specified, or the value cannot be determined without
importing the module. The version is formatted according to the
requirement's version format (if any), unless it is 'None' or the
supplied 'default'.
"""
if self.attribute is None:
try:
f,p,i = find_module(self.module,paths)
if f: f.close()
return default
except ImportError:
return None
v = get_module_constant(self.module, self.attribute, default, paths)
if v is not None and v is not default and self.format is not None:
return self.format(v)
return v
def is_present(self, paths=None):
"""Return true if dependency is present on 'paths'"""
return self.get_version(paths) is not None
def is_current(self, paths=None):
"""Return true if dependency is present and up-to-date on 'paths'"""
version = self.get_version(paths)
if version is None:
return False
return self.version_ok(version)
def _iter_code(code):
"""Yield '(op,arg)' pair for each operation in code object 'code'"""
from array import array
from dis import HAVE_ARGUMENT, EXTENDED_ARG
bytes = array('b',code.co_code)
eof = len(code.co_code)
ptr = 0
extended_arg = 0
while ptr=HAVE_ARGUMENT:
arg = bytes[ptr+1] + bytes[ptr+2]*256 + extended_arg
ptr += 3
if op==EXTENDED_ARG:
long_type = six.integer_types[-1]
extended_arg = arg * long_type(65536)
continue
else:
arg = None
ptr += 1
yield op,arg
def find_module(module, paths=None):
"""Just like 'imp.find_module()', but with package support"""
parts = module.split('.')
while parts:
part = parts.pop(0)
f, path, (suffix,mode,kind) = info = imp.find_module(part, paths)
if kind==PKG_DIRECTORY:
parts = parts or ['__init__']
paths = [path]
elif parts:
raise ImportError("Can't find %r in %s" % (parts,module))
return info
def get_module_constant(module, symbol, default=-1, paths=None):
"""Find 'module' by searching 'paths', and extract 'symbol'
Return 'None' if 'module' does not exist on 'paths', or it does not define
'symbol'. If the module defines 'symbol' as a constant, return the
constant. Otherwise, return 'default'."""
try:
f, path, (suffix, mode, kind) = find_module(module, paths)
except ImportError:
# Module doesn't exist
return None
try:
if kind==PY_COMPILED:
f.read(8) # skip magic & date
code = marshal.load(f)
elif kind==PY_FROZEN:
code = imp.get_frozen_object(module)
elif kind==PY_SOURCE:
code = compile(f.read(), path, 'exec')
else:
# Not something we can parse; we'll have to import it. :(
if module not in sys.modules:
imp.load_module(module, f, path, (suffix, mode, kind))
return getattr(sys.modules[module], symbol, None)
finally:
if f:
f.close()
return extract_constant(code, symbol, default)
def extract_constant(code, symbol, default=-1):
"""Extract the constant value of 'symbol' from 'code'
If the name 'symbol' is bound to a constant value by the Python code
object 'code', return that value. If 'symbol' is bound to an expression,
return 'default'. Otherwise, return 'None'.
Return value is based on the first assignment to 'symbol'. 'symbol' must
be a global, or at least a non-"fast" local in the code block. That is,
only 'STORE_NAME' and 'STORE_GLOBAL' opcodes are checked, and 'symbol'
must be present in 'code.co_names'.
"""
if symbol not in code.co_names:
# name's not there, can't possibly be an assigment
return None
name_idx = list(code.co_names).index(symbol)
STORE_NAME = 90
STORE_GLOBAL = 97
LOAD_CONST = 100
const = default
for op, arg in _iter_code(code):
if op==LOAD_CONST:
const = code.co_consts[arg]
elif arg==name_idx and (op==STORE_NAME or op==STORE_GLOBAL):
return const
else:
const = default
def _update_globals():
"""
Patch the globals to remove the objects not available on some platforms.
XXX it'd be better to test assertions about bytecode instead.
"""
if not sys.platform.startswith('java') and sys.platform != 'cli':
return
incompatible = 'extract_constant', 'get_module_constant'
for name in incompatible:
del globals()[name]
__all__.remove(name)
_update_globals()
setuptools-20.7.0/setuptools/dist.py 0000664 0001750 0001750 00000105570 12702524020 020425 0 ustar travis travis 0000000 0000000 __all__ = ['Distribution']
import re
import os
import sys
import warnings
import numbers
import distutils.log
import distutils.core
import distutils.cmd
import distutils.dist
from distutils.core import Distribution as _Distribution
from distutils.errors import (DistutilsOptionError, DistutilsPlatformError,
DistutilsSetupError)
from setuptools.extern import six
from setuptools.extern.six.moves import map
from pkg_resources.extern import packaging
from setuptools.depends import Require
from setuptools import windows_support
import pkg_resources
def _get_unpatched(cls):
"""Protect against re-patching the distutils if reloaded
Also ensures that no other distutils extension monkeypatched the distutils
first.
"""
while cls.__module__.startswith('setuptools'):
cls, = cls.__bases__
if not cls.__module__.startswith('distutils'):
raise AssertionError(
"distutils has already been patched by %r" % cls
)
return cls
_Distribution = _get_unpatched(_Distribution)
def _patch_distribution_metadata_write_pkg_info():
"""
Workaround issue #197 - Python 3 prior to 3.2.2 uses an environment-local
encoding to save the pkg_info. Monkey-patch its write_pkg_info method to
correct this undesirable behavior.
"""
environment_local = (3,) <= sys.version_info[:3] < (3, 2, 2)
if not environment_local:
return
# from Python 3.4
def write_pkg_info(self, base_dir):
"""Write the PKG-INFO file into the release tree.
"""
with open(os.path.join(base_dir, 'PKG-INFO'), 'w',
encoding='UTF-8') as pkg_info:
self.write_pkg_file(pkg_info)
distutils.dist.DistributionMetadata.write_pkg_info = write_pkg_info
_patch_distribution_metadata_write_pkg_info()
sequence = tuple, list
def check_importable(dist, attr, value):
try:
ep = pkg_resources.EntryPoint.parse('x='+value)
assert not ep.extras
except (TypeError,ValueError,AttributeError,AssertionError):
raise DistutilsSetupError(
"%r must be importable 'module:attrs' string (got %r)"
% (attr,value)
)
def assert_string_list(dist, attr, value):
"""Verify that value is a string list or None"""
try:
assert ''.join(value)!=value
except (TypeError,ValueError,AttributeError,AssertionError):
raise DistutilsSetupError(
"%r must be a list of strings (got %r)" % (attr,value)
)
def check_nsp(dist, attr, value):
"""Verify that namespace packages are valid"""
assert_string_list(dist,attr,value)
for nsp in value:
if not dist.has_contents_for(nsp):
raise DistutilsSetupError(
"Distribution contains no modules or packages for " +
"namespace package %r" % nsp
)
if '.' in nsp:
parent = '.'.join(nsp.split('.')[:-1])
if parent not in value:
distutils.log.warn(
"WARNING: %r is declared as a package namespace, but %r"
" is not: please correct this in setup.py", nsp, parent
)
def check_extras(dist, attr, value):
"""Verify that extras_require mapping is valid"""
try:
for k,v in value.items():
if ':' in k:
k,m = k.split(':',1)
if pkg_resources.invalid_marker(m):
raise DistutilsSetupError("Invalid environment marker: "+m)
list(pkg_resources.parse_requirements(v))
except (TypeError,ValueError,AttributeError):
raise DistutilsSetupError(
"'extras_require' must be a dictionary whose values are "
"strings or lists of strings containing valid project/version "
"requirement specifiers."
)
def assert_bool(dist, attr, value):
"""Verify that value is True, False, 0, or 1"""
if bool(value) != value:
tmpl = "{attr!r} must be a boolean value (got {value!r})"
raise DistutilsSetupError(tmpl.format(attr=attr, value=value))
def check_requirements(dist, attr, value):
"""Verify that install_requires is a valid requirements list"""
try:
list(pkg_resources.parse_requirements(value))
except (TypeError, ValueError) as error:
tmpl = (
"{attr!r} must be a string or list of strings "
"containing valid project/version requirement specifiers; {error}"
)
raise DistutilsSetupError(tmpl.format(attr=attr, error=error))
def check_entry_points(dist, attr, value):
"""Verify that entry_points map is parseable"""
try:
pkg_resources.EntryPoint.parse_map(value)
except ValueError as e:
raise DistutilsSetupError(e)
def check_test_suite(dist, attr, value):
if not isinstance(value, six.string_types):
raise DistutilsSetupError("test_suite must be a string")
def check_package_data(dist, attr, value):
"""Verify that value is a dictionary of package names to glob lists"""
if isinstance(value,dict):
for k,v in value.items():
if not isinstance(k,str): break
try: iter(v)
except TypeError:
break
else:
return
raise DistutilsSetupError(
attr+" must be a dictionary mapping package names to lists of "
"wildcard patterns"
)
def check_packages(dist, attr, value):
for pkgname in value:
if not re.match(r'\w+(\.\w+)*', pkgname):
distutils.log.warn(
"WARNING: %r not a valid package name; please use only "
".-separated package names in setup.py", pkgname
)
class Distribution(_Distribution):
"""Distribution with support for features, tests, and package data
This is an enhanced version of 'distutils.dist.Distribution' that
effectively adds the following new optional keyword arguments to 'setup()':
'install_requires' -- a string or sequence of strings specifying project
versions that the distribution requires when installed, in the format
used by 'pkg_resources.require()'. They will be installed
automatically when the package is installed. If you wish to use
packages that are not available in PyPI, or want to give your users an
alternate download location, you can add a 'find_links' option to the
'[easy_install]' section of your project's 'setup.cfg' file, and then
setuptools will scan the listed web pages for links that satisfy the
requirements.
'extras_require' -- a dictionary mapping names of optional "extras" to the
additional requirement(s) that using those extras incurs. For example,
this::
extras_require = dict(reST = ["docutils>=0.3", "reSTedit"])
indicates that the distribution can optionally provide an extra
capability called "reST", but it can only be used if docutils and
reSTedit are installed. If the user installs your package using
EasyInstall and requests one of your extras, the corresponding
additional requirements will be installed if needed.
'features' **deprecated** -- a dictionary mapping option names to
'setuptools.Feature'
objects. Features are a portion of the distribution that can be
included or excluded based on user options, inter-feature dependencies,
and availability on the current system. Excluded features are omitted
from all setup commands, including source and binary distributions, so
you can create multiple distributions from the same source tree.
Feature names should be valid Python identifiers, except that they may
contain the '-' (minus) sign. Features can be included or excluded
via the command line options '--with-X' and '--without-X', where 'X' is
the name of the feature. Whether a feature is included by default, and
whether you are allowed to control this from the command line, is
determined by the Feature object. See the 'Feature' class for more
information.
'test_suite' -- the name of a test suite to run for the 'test' command.
If the user runs 'python setup.py test', the package will be installed,
and the named test suite will be run. The format is the same as
would be used on a 'unittest.py' command line. That is, it is the
dotted name of an object to import and call to generate a test suite.
'package_data' -- a dictionary mapping package names to lists of filenames
or globs to use to find data files contained in the named packages.
If the dictionary has filenames or globs listed under '""' (the empty
string), those names will be searched for in every package, in addition
to any names for the specific package. Data files found using these
names/globs will be installed along with the package, in the same
location as the package. Note that globs are allowed to reference
the contents of non-package subdirectories, as long as you use '/' as
a path separator. (Globs are automatically converted to
platform-specific paths at runtime.)
In addition to these new keywords, this class also has several new methods
for manipulating the distribution's contents. For example, the 'include()'
and 'exclude()' methods can be thought of as in-place add and subtract
commands that add or remove packages, modules, extensions, and so on from
the distribution. They are used by the feature subsystem to configure the
distribution for the included and excluded features.
"""
_patched_dist = None
def patch_missing_pkg_info(self, attrs):
# Fake up a replacement for the data that would normally come from
# PKG-INFO, but which might not yet be built if this is a fresh
# checkout.
#
if not attrs or 'name' not in attrs or 'version' not in attrs:
return
key = pkg_resources.safe_name(str(attrs['name'])).lower()
dist = pkg_resources.working_set.by_key.get(key)
if dist is not None and not dist.has_metadata('PKG-INFO'):
dist._version = pkg_resources.safe_version(str(attrs['version']))
self._patched_dist = dist
def __init__(self, attrs=None):
have_package_data = hasattr(self, "package_data")
if not have_package_data:
self.package_data = {}
_attrs_dict = attrs or {}
if 'features' in _attrs_dict or 'require_features' in _attrs_dict:
Feature.warn_deprecated()
self.require_features = []
self.features = {}
self.dist_files = []
self.src_root = attrs and attrs.pop("src_root", None)
self.patch_missing_pkg_info(attrs)
# Make sure we have any eggs needed to interpret 'attrs'
if attrs is not None:
self.dependency_links = attrs.pop('dependency_links', [])
assert_string_list(self,'dependency_links',self.dependency_links)
if attrs and 'setup_requires' in attrs:
self.fetch_build_eggs(attrs['setup_requires'])
for ep in pkg_resources.iter_entry_points('distutils.setup_keywords'):
vars(self).setdefault(ep.name, None)
_Distribution.__init__(self,attrs)
if isinstance(self.metadata.version, numbers.Number):
# Some people apparently take "version number" too literally :)
self.metadata.version = str(self.metadata.version)
if self.metadata.version is not None:
try:
ver = packaging.version.Version(self.metadata.version)
normalized_version = str(ver)
if self.metadata.version != normalized_version:
warnings.warn(
"Normalizing '%s' to '%s'" % (
self.metadata.version,
normalized_version,
)
)
self.metadata.version = normalized_version
except (packaging.version.InvalidVersion, TypeError):
warnings.warn(
"The version specified (%r) is an invalid version, this "
"may not work as expected with newer versions of "
"setuptools, pip, and PyPI. Please see PEP 440 for more "
"details." % self.metadata.version
)
def parse_command_line(self):
"""Process features after parsing command line options"""
result = _Distribution.parse_command_line(self)
if self.features:
self._finalize_features()
return result
def _feature_attrname(self,name):
"""Convert feature name to corresponding option attribute name"""
return 'with_'+name.replace('-','_')
def fetch_build_eggs(self, requires):
"""Resolve pre-setup requirements"""
resolved_dists = pkg_resources.working_set.resolve(
pkg_resources.parse_requirements(requires),
installer=self.fetch_build_egg,
replace_conflicting=True,
)
for dist in resolved_dists:
pkg_resources.working_set.add(dist, replace=True)
def finalize_options(self):
_Distribution.finalize_options(self)
if self.features:
self._set_global_opts_from_features()
for ep in pkg_resources.iter_entry_points('distutils.setup_keywords'):
value = getattr(self,ep.name,None)
if value is not None:
ep.require(installer=self.fetch_build_egg)
ep.load()(self, ep.name, value)
if getattr(self, 'convert_2to3_doctests', None):
# XXX may convert to set here when we can rely on set being builtin
self.convert_2to3_doctests = [os.path.abspath(p) for p in self.convert_2to3_doctests]
else:
self.convert_2to3_doctests = []
def get_egg_cache_dir(self):
egg_cache_dir = os.path.join(os.curdir, '.eggs')
if not os.path.exists(egg_cache_dir):
os.mkdir(egg_cache_dir)
windows_support.hide_file(egg_cache_dir)
readme_txt_filename = os.path.join(egg_cache_dir, 'README.txt')
with open(readme_txt_filename, 'w') as f:
f.write('This directory contains eggs that were downloaded '
'by setuptools to build, test, and run plug-ins.\n\n')
f.write('This directory caches those eggs to prevent '
'repeated downloads.\n\n')
f.write('However, it is safe to delete this directory.\n\n')
return egg_cache_dir
def fetch_build_egg(self, req):
"""Fetch an egg needed for building"""
try:
cmd = self._egg_fetcher
cmd.package_index.to_scan = []
except AttributeError:
from setuptools.command.easy_install import easy_install
dist = self.__class__({'script_args':['easy_install']})
dist.parse_config_files()
opts = dist.get_option_dict('easy_install')
keep = (
'find_links', 'site_dirs', 'index_url', 'optimize',
'site_dirs', 'allow_hosts'
)
for key in list(opts):
if key not in keep:
del opts[key] # don't use any other settings
if self.dependency_links:
links = self.dependency_links[:]
if 'find_links' in opts:
links = opts['find_links'][1].split() + links
opts['find_links'] = ('setup', links)
install_dir = self.get_egg_cache_dir()
cmd = easy_install(
dist, args=["x"], install_dir=install_dir, exclude_scripts=True,
always_copy=False, build_directory=None, editable=False,
upgrade=False, multi_version=True, no_report=True, user=False
)
cmd.ensure_finalized()
self._egg_fetcher = cmd
return cmd.easy_install(req)
def _set_global_opts_from_features(self):
"""Add --with-X/--without-X options based on optional features"""
go = []
no = self.negative_opt.copy()
for name,feature in self.features.items():
self._set_feature(name,None)
feature.validate(self)
if feature.optional:
descr = feature.description
incdef = ' (default)'
excdef=''
if not feature.include_by_default():
excdef, incdef = incdef, excdef
go.append(('with-'+name, None, 'include '+descr+incdef))
go.append(('without-'+name, None, 'exclude '+descr+excdef))
no['without-'+name] = 'with-'+name
self.global_options = self.feature_options = go + self.global_options
self.negative_opt = self.feature_negopt = no
def _finalize_features(self):
"""Add/remove features and resolve dependencies between them"""
# First, flag all the enabled items (and thus their dependencies)
for name,feature in self.features.items():
enabled = self.feature_is_included(name)
if enabled or (enabled is None and feature.include_by_default()):
feature.include_in(self)
self._set_feature(name,1)
# Then disable the rest, so that off-by-default features don't
# get flagged as errors when they're required by an enabled feature
for name,feature in self.features.items():
if not self.feature_is_included(name):
feature.exclude_from(self)
self._set_feature(name,0)
def get_command_class(self, command):
"""Pluggable version of get_command_class()"""
if command in self.cmdclass:
return self.cmdclass[command]
for ep in pkg_resources.iter_entry_points('distutils.commands',command):
ep.require(installer=self.fetch_build_egg)
self.cmdclass[command] = cmdclass = ep.load()
return cmdclass
else:
return _Distribution.get_command_class(self, command)
def print_commands(self):
for ep in pkg_resources.iter_entry_points('distutils.commands'):
if ep.name not in self.cmdclass:
# don't require extras as the commands won't be invoked
cmdclass = ep.resolve()
self.cmdclass[ep.name] = cmdclass
return _Distribution.print_commands(self)
def get_command_list(self):
for ep in pkg_resources.iter_entry_points('distutils.commands'):
if ep.name not in self.cmdclass:
# don't require extras as the commands won't be invoked
cmdclass = ep.resolve()
self.cmdclass[ep.name] = cmdclass
return _Distribution.get_command_list(self)
def _set_feature(self,name,status):
"""Set feature's inclusion status"""
setattr(self,self._feature_attrname(name),status)
def feature_is_included(self,name):
"""Return 1 if feature is included, 0 if excluded, 'None' if unknown"""
return getattr(self,self._feature_attrname(name))
def include_feature(self,name):
"""Request inclusion of feature named 'name'"""
if self.feature_is_included(name)==0:
descr = self.features[name].description
raise DistutilsOptionError(
descr + " is required, but was excluded or is not available"
)
self.features[name].include_in(self)
self._set_feature(name,1)
def include(self,**attrs):
"""Add items to distribution that are named in keyword arguments
For example, 'dist.exclude(py_modules=["x"])' would add 'x' to
the distribution's 'py_modules' attribute, if it was not already
there.
Currently, this method only supports inclusion for attributes that are
lists or tuples. If you need to add support for adding to other
attributes in this or a subclass, you can add an '_include_X' method,
where 'X' is the name of the attribute. The method will be called with
the value passed to 'include()'. So, 'dist.include(foo={"bar":"baz"})'
will try to call 'dist._include_foo({"bar":"baz"})', which can then
handle whatever special inclusion logic is needed.
"""
for k,v in attrs.items():
include = getattr(self, '_include_'+k, None)
if include:
include(v)
else:
self._include_misc(k,v)
def exclude_package(self,package):
"""Remove packages, modules, and extensions in named package"""
pfx = package+'.'
if self.packages:
self.packages = [
p for p in self.packages
if p != package and not p.startswith(pfx)
]
if self.py_modules:
self.py_modules = [
p for p in self.py_modules
if p != package and not p.startswith(pfx)
]
if self.ext_modules:
self.ext_modules = [
p for p in self.ext_modules
if p.name != package and not p.name.startswith(pfx)
]
def has_contents_for(self,package):
"""Return true if 'exclude_package(package)' would do something"""
pfx = package+'.'
for p in self.iter_distribution_names():
if p==package or p.startswith(pfx):
return True
def _exclude_misc(self,name,value):
"""Handle 'exclude()' for list/tuple attrs without a special handler"""
if not isinstance(value,sequence):
raise DistutilsSetupError(
"%s: setting must be a list or tuple (%r)" % (name, value)
)
try:
old = getattr(self,name)
except AttributeError:
raise DistutilsSetupError(
"%s: No such distribution setting" % name
)
if old is not None and not isinstance(old,sequence):
raise DistutilsSetupError(
name+": this setting cannot be changed via include/exclude"
)
elif old:
setattr(self,name,[item for item in old if item not in value])
def _include_misc(self,name,value):
"""Handle 'include()' for list/tuple attrs without a special handler"""
if not isinstance(value,sequence):
raise DistutilsSetupError(
"%s: setting must be a list (%r)" % (name, value)
)
try:
old = getattr(self,name)
except AttributeError:
raise DistutilsSetupError(
"%s: No such distribution setting" % name
)
if old is None:
setattr(self,name,value)
elif not isinstance(old,sequence):
raise DistutilsSetupError(
name+": this setting cannot be changed via include/exclude"
)
else:
setattr(self,name,old+[item for item in value if item not in old])
def exclude(self,**attrs):
"""Remove items from distribution that are named in keyword arguments
For example, 'dist.exclude(py_modules=["x"])' would remove 'x' from
the distribution's 'py_modules' attribute. Excluding packages uses
the 'exclude_package()' method, so all of the package's contained
packages, modules, and extensions are also excluded.
Currently, this method only supports exclusion from attributes that are
lists or tuples. If you need to add support for excluding from other
attributes in this or a subclass, you can add an '_exclude_X' method,
where 'X' is the name of the attribute. The method will be called with
the value passed to 'exclude()'. So, 'dist.exclude(foo={"bar":"baz"})'
will try to call 'dist._exclude_foo({"bar":"baz"})', which can then
handle whatever special exclusion logic is needed.
"""
for k,v in attrs.items():
exclude = getattr(self, '_exclude_'+k, None)
if exclude:
exclude(v)
else:
self._exclude_misc(k,v)
def _exclude_packages(self,packages):
if not isinstance(packages,sequence):
raise DistutilsSetupError(
"packages: setting must be a list or tuple (%r)" % (packages,)
)
list(map(self.exclude_package, packages))
def _parse_command_opts(self, parser, args):
# Remove --with-X/--without-X options when processing command args
self.global_options = self.__class__.global_options
self.negative_opt = self.__class__.negative_opt
# First, expand any aliases
command = args[0]
aliases = self.get_option_dict('aliases')
while command in aliases:
src,alias = aliases[command]
del aliases[command] # ensure each alias can expand only once!
import shlex
args[:1] = shlex.split(alias,True)
command = args[0]
nargs = _Distribution._parse_command_opts(self, parser, args)
# Handle commands that want to consume all remaining arguments
cmd_class = self.get_command_class(command)
if getattr(cmd_class,'command_consumes_arguments',None):
self.get_option_dict(command)['args'] = ("command line", nargs)
if nargs is not None:
return []
return nargs
def get_cmdline_options(self):
"""Return a '{cmd: {opt:val}}' map of all command-line options
Option names are all long, but do not include the leading '--', and
contain dashes rather than underscores. If the option doesn't take
an argument (e.g. '--quiet'), the 'val' is 'None'.
Note that options provided by config files are intentionally excluded.
"""
d = {}
for cmd,opts in self.command_options.items():
for opt,(src,val) in opts.items():
if src != "command line":
continue
opt = opt.replace('_','-')
if val==0:
cmdobj = self.get_command_obj(cmd)
neg_opt = self.negative_opt.copy()
neg_opt.update(getattr(cmdobj,'negative_opt',{}))
for neg,pos in neg_opt.items():
if pos==opt:
opt=neg
val=None
break
else:
raise AssertionError("Shouldn't be able to get here")
elif val==1:
val = None
d.setdefault(cmd,{})[opt] = val
return d
def iter_distribution_names(self):
"""Yield all packages, modules, and extension names in distribution"""
for pkg in self.packages or ():
yield pkg
for module in self.py_modules or ():
yield module
for ext in self.ext_modules or ():
if isinstance(ext,tuple):
name, buildinfo = ext
else:
name = ext.name
if name.endswith('module'):
name = name[:-6]
yield name
def handle_display_options(self, option_order):
"""If there were any non-global "display-only" options
(--help-commands or the metadata display options) on the command
line, display the requested info and return true; else return
false.
"""
import sys
if six.PY2 or self.help_commands:
return _Distribution.handle_display_options(self, option_order)
# Stdout may be StringIO (e.g. in tests)
import io
if not isinstance(sys.stdout, io.TextIOWrapper):
return _Distribution.handle_display_options(self, option_order)
# Don't wrap stdout if utf-8 is already the encoding. Provides
# workaround for #334.
if sys.stdout.encoding.lower() in ('utf-8', 'utf8'):
return _Distribution.handle_display_options(self, option_order)
# Print metadata in UTF-8 no matter the platform
encoding = sys.stdout.encoding
errors = sys.stdout.errors
newline = sys.platform != 'win32' and '\n' or None
line_buffering = sys.stdout.line_buffering
sys.stdout = io.TextIOWrapper(
sys.stdout.detach(), 'utf-8', errors, newline, line_buffering)
try:
return _Distribution.handle_display_options(self, option_order)
finally:
sys.stdout = io.TextIOWrapper(
sys.stdout.detach(), encoding, errors, newline, line_buffering)
# Install it throughout the distutils
for module in distutils.dist, distutils.core, distutils.cmd:
module.Distribution = Distribution
class Feature:
"""
**deprecated** -- The `Feature` facility was never completely implemented
or supported, `has reported issues
`_ and will be removed in
a future version.
A subset of the distribution that can be excluded if unneeded/wanted
Features are created using these keyword arguments:
'description' -- a short, human readable description of the feature, to
be used in error messages, and option help messages.
'standard' -- if true, the feature is included by default if it is
available on the current system. Otherwise, the feature is only
included if requested via a command line '--with-X' option, or if
another included feature requires it. The default setting is 'False'.
'available' -- if true, the feature is available for installation on the
current system. The default setting is 'True'.
'optional' -- if true, the feature's inclusion can be controlled from the
command line, using the '--with-X' or '--without-X' options. If
false, the feature's inclusion status is determined automatically,
based on 'availabile', 'standard', and whether any other feature
requires it. The default setting is 'True'.
'require_features' -- a string or sequence of strings naming features
that should also be included if this feature is included. Defaults to
empty list. May also contain 'Require' objects that should be
added/removed from the distribution.
'remove' -- a string or list of strings naming packages to be removed
from the distribution if this feature is *not* included. If the
feature *is* included, this argument is ignored. This argument exists
to support removing features that "crosscut" a distribution, such as
defining a 'tests' feature that removes all the 'tests' subpackages
provided by other features. The default for this argument is an empty
list. (Note: the named package(s) or modules must exist in the base
distribution when the 'setup()' function is initially called.)
other keywords -- any other keyword arguments are saved, and passed to
the distribution's 'include()' and 'exclude()' methods when the
feature is included or excluded, respectively. So, for example, you
could pass 'packages=["a","b"]' to cause packages 'a' and 'b' to be
added or removed from the distribution as appropriate.
A feature must include at least one 'requires', 'remove', or other
keyword argument. Otherwise, it can't affect the distribution in any way.
Note also that you can subclass 'Feature' to create your own specialized
feature types that modify the distribution in other ways when included or
excluded. See the docstrings for the various methods here for more detail.
Aside from the methods, the only feature attributes that distributions look
at are 'description' and 'optional'.
"""
@staticmethod
def warn_deprecated():
warnings.warn(
"Features are deprecated and will be removed in a future "
"version. See https://github.com/pypa/setuptools/issues/65.",
DeprecationWarning,
stacklevel=3,
)
def __init__(self, description, standard=False, available=True,
optional=True, require_features=(), remove=(), **extras):
self.warn_deprecated()
self.description = description
self.standard = standard
self.available = available
self.optional = optional
if isinstance(require_features,(str,Require)):
require_features = require_features,
self.require_features = [
r for r in require_features if isinstance(r,str)
]
er = [r for r in require_features if not isinstance(r,str)]
if er: extras['require_features'] = er
if isinstance(remove,str):
remove = remove,
self.remove = remove
self.extras = extras
if not remove and not require_features and not extras:
raise DistutilsSetupError(
"Feature %s: must define 'require_features', 'remove', or at least one"
" of 'packages', 'py_modules', etc."
)
def include_by_default(self):
"""Should this feature be included by default?"""
return self.available and self.standard
def include_in(self,dist):
"""Ensure feature and its requirements are included in distribution
You may override this in a subclass to perform additional operations on
the distribution. Note that this method may be called more than once
per feature, and so should be idempotent.
"""
if not self.available:
raise DistutilsPlatformError(
self.description+" is required, "
"but is not available on this platform"
)
dist.include(**self.extras)
for f in self.require_features:
dist.include_feature(f)
def exclude_from(self,dist):
"""Ensure feature is excluded from distribution
You may override this in a subclass to perform additional operations on
the distribution. This method will be called at most once per
feature, and only after all included features have been asked to
include themselves.
"""
dist.exclude(**self.extras)
if self.remove:
for item in self.remove:
dist.exclude_package(item)
def validate(self,dist):
"""Verify that feature makes sense in context of distribution
This method is called by the distribution just before it parses its
command line. It checks to ensure that the 'remove' attribute, if any,
contains only valid package/module names that are present in the base
distribution when 'setup()' is called. You may override it in a
subclass to perform any other required validation of the feature
against a target distribution.
"""
for item in self.remove:
if not dist.has_contents_for(item):
raise DistutilsSetupError(
"%s wants to be able to remove %s, but the distribution"
" doesn't contain any packages or modules under %s"
% (self.description, item, item)
)
setuptools-20.7.0/setuptools/extension.py 0000664 0001750 0001750 00000003236 12702524020 021472 0 ustar travis travis 0000000 0000000 import sys
import re
import functools
import distutils.core
import distutils.errors
import distutils.extension
from setuptools.extern.six.moves import map
from .dist import _get_unpatched
from . import msvc9_support
_Extension = _get_unpatched(distutils.core.Extension)
msvc9_support.patch_for_specialized_compiler()
def _have_cython():
"""
Return True if Cython can be imported.
"""
cython_impl = 'Cython.Distutils.build_ext',
try:
# from (cython_impl) import build_ext
__import__(cython_impl, fromlist=['build_ext']).build_ext
return True
except Exception:
pass
return False
# for compatibility
have_pyrex = _have_cython
class Extension(_Extension):
"""Extension that uses '.c' files in place of '.pyx' files"""
def _convert_pyx_sources_to_lang(self):
"""
Replace sources with .pyx extensions to sources with the target
language extension. This mechanism allows language authors to supply
pre-converted sources but to prefer the .pyx sources.
"""
if _have_cython():
# the build has Cython, so allow it to compile the .pyx files
return
lang = self.language or ''
target_ext = '.cpp' if lang.lower() == 'c++' else '.c'
sub = functools.partial(re.sub, '.pyx$', target_ext)
self.sources = list(map(sub, self.sources))
class Library(Extension):
"""Just like a regular Extension, but built as a library instead"""
distutils.core.Extension = Extension
distutils.extension.Extension = Extension
if 'distutils.command.build_ext' in sys.modules:
sys.modules['distutils.command.build_ext'].Extension = Extension
setuptools-20.7.0/setuptools/gui-32.exe 0000664 0001750 0001750 00000200000 12702524020 020601 0 ustar travis travis 0000000 0000000 MZ ÿÿ ¸ @ è º ´ Í!¸LÍ!This program cannot be run in DOS mode.
$ äSÀØ 2®‹ 2®‹ 2®‹‡ôÕ‹£2®‹ 2¯‹û2®‹ }8‹¤2®‹¾`*‹„2®‹¾`;‹²2®‹¾`-‹Ñ2®‹¾`?‹¡2®‹Rich 2®‹ PE L ±‹Q à Ê N & à @ @ € 4ù ( ˆô @ à @ .text íÉ Ê `.rdata h à " Î @ @.data Ä+ ð @ À Q‹D$PŠ@„ÉuùSUV+ÂW‹èD-jPèx
ƒÄ3ÿ3Û‰D$Æ "p…í~Wë› ‹L$Š <\uGë <"u…ÿ~Wj\Vè
ƒÄ ÷3ÿÆ\Fë3ÿ‹T$ŠˆCF;Ý|Ã…ÿ~Wj\VèV
ƒÄ ÷‹D$_Æ"ÆF ^][YÃì ¡€A 3ĉ„$ V‹´$ W‹¼$ Š‹Ï„Àtd$ A9](u>‹u3À@8 tHF;Ãwö€>:u5;Ëtƒ}‚õ jÿujÿQèU& ƒÄF‰uë9](uÂÇEø éÎ ;Ëtˆ‹u3ÿ‰]ü8 tU¾Pè& Y…ÀtFëŠ Yƒeü 3ÛC9 8 A „Å ‰ 4 A ŠE¢0 A ƒ} … ÿ5¬+A è0, Y‹ø‰}Ø…ÿtxÿ5¨+A è, Y‹ð‰u܉}ä‰uàƒî‰uÜ;÷rWè÷+ 9tí;÷rJÿ6èñ+ ‹øèá+ ‰ÿ×ÿ5¬+A èÛ+ ‹øÿ5¨+A èÎ+ ƒÄ 9}äu9Eàt‰}ä‰}؉Eà‹ð‰uÜ‹}ØëŸhpá@ ¸dá@ è_þÿÿYhxá@ ¸tá@ èOþÿÿYÇEüþÿÿÿè ƒ} u(‰ 8 A jèl Yÿuèüýÿÿ3ÛCƒ} tjèS YÃè ËÿU‹ìj j ÿuèÃþÿÿƒÄ ]ËÿU‹ìj jÿuèþÿÿƒÄ ]Ãjj j èþÿÿƒÄ Ãjjj èŽþÿÿƒÄ ËÿVèó* ‹ðVèY; Vèä: Vèw VèÉ: Vè´: Vèœ8 Vè57 Vè 7 hê#@ èE* ƒÄ$£ˆA ^ËÿU‹ìƒ=D A uèŒ3 ÿuèÙ1 hÿ è'ýÿÿYY]ÃjXh0õ@ èû 3ö‰uüE˜Pÿ4à@ jþ_‰}ü¸MZ f9 @ u8¡< @ ¸ @ PE u'¹ f9ˆ @ uƒ¸t @ v3É9°è @ •Á‰Mäë‰uä3ÛCSèÏ? Y…Àuj èXÿÿÿYè- …ÀujèGÿÿÿYèW4 ‰]üèø
…À}jè&üÿÿYÿ0à@ £ +A èQ> £< A èŒ= …À}jè üÿÿYè; …À}j èïûÿÿYSè§üÿÿY;ÆtPèÝûÿÿYè: „]Ät·MÈëj
YQPVh @ èòÿÿ‰Eà9uäuPè þÿÿèEþÿÿ‰}üë5‹Eì‹‹ ‰MÜPQè·5 YYËeè‹E܉Eàƒ}ä uPèþÿÿè!þÿÿÇEüþÿÿÿ‹Eàë3À@ËeèÇEüþÿÿÿ¸ÿ èÏ Ãèï> éxþÿÿ‹ÿU‹ìV‹uVèS Pèk? YY…Àt|è©òÿÿƒÀ ;ðu3Àëè™òÿÿƒÀ@;ðu`3À@ÿ A ÷F uNSW<…H A ƒ? » u Sè
Y‰…ÀuFj‰F‰X‰F‰Fë
‹?‰~‰>‰^‰^N 3À_@[ë3À^]ËÿU‹ìƒ} t'V‹u ÷F tVè f ÿîÿÿƒf ƒ& ƒf Y^]ÃöA @tƒy t$ÿIx ‹ˆÿ¶Àë ¾ÀQPèé- YYƒøÿu ÃÿËÿU‹ìV‹ðë‹MŠEÿM èµÿÿÿƒ>ÿtƒ} ç^]ËÿU‹ìöG @SV‹ð‹Ùt2ƒ u,‹Eë+ŠÿM‹Ïè}ÿÿÿCƒ>ÿuèÕ ƒ8*u‹Ï°?èdÿÿÿƒ} Õ^[]ËÿU‹ììx ¡€A 3ʼnEüS‹] V‹u3ÀW‹}ÿu¤ýÿÿ‰µ´ýÿÿ‰½Üýÿÿ‰…¸ýÿÿ‰…ðýÿÿ‰…Ìýÿÿ‰…èýÿÿ‰…Ðýÿÿ‰…Àýÿÿ‰…Èýÿÿè÷öÿÿ…öu5èM Ç 3ÀPPPPPèÓ ƒÄ€½°ýÿÿ t
‹…¬ýÿÿƒ`pýƒÈÿéÈ
öF @u^Vè@
Yº˜A ƒøÿtƒøþt‹Èƒá ‹ðÁþÁá µ *A ë‹ÊöA$u‘ƒøÿtƒøþt‹Èƒà ÁùÁà *A ë‹Âö@$€…gÿÿÿ3É;Ù„]ÿÿÿŠ‰Øýÿÿ‰àýÿÿ‰¼ýÿÿˆ•ïýÿÿ„Ò„
Cƒ½Øýÿÿ ‰ÄýÿÿŒ
ŠÂ, If90t@@;Îuô+…äýÿÿÑøë(;þu ¡A ‰…äýÿÿ‹…äýÿÿëI€8 t@;Îuõ+…äýÿÿ‰…àýÿÿƒ½Àýÿÿ …\ ‹…ðýÿÿ¨@t2© t Æ…Ôýÿÿ-ë¨t Æ…Ôýÿÿ+ë ¨tÆ…Ôýÿÿ Ç…Ðýÿÿ ‹Ìýÿÿ+àýÿÿ+Ðýÿÿö…ðýÿÿ uÿµ´ýÿÿ…ØýÿÿSj èpõÿÿƒÄ ÿµÐýÿÿ‹½´ýÿÿ…ØýÿÿÔýÿÿèvõÿÿö…ðýÿÿYtö…ðýÿÿuWSj0…Øýÿÿè.õÿÿƒÄ ƒ½Èýÿÿ ‹…àýÿÿtf…À~b‹µäýÿÿ‰… ýÿÿ·ÿ ýÿÿPjEôP…˜ýÿÿFPFèå5 ƒÄ…Àu(9…˜ýÿÿt ÿµ˜ýÿÿ…ØýÿÿMôèñôÿÿƒ½ ýÿÿ Yuµë ƒØýÿÿÿë‹äýÿÿP…ØýÿÿèÊôÿÿYƒ½Øýÿÿ |ö…ðýÿÿtWSj …Øýÿÿè‚ôÿÿƒÄ ƒ½¼ýÿÿ tÿµ¼ýÿÿè ƒ¥¼ýÿÿ Y‹ÄýÿÿŠˆ…ïýÿÿ„Àt‹”ýÿÿ‹½ÜýÿÿŠÐéáõÿÿ€½°ýÿÿ t
‹…¬ýÿÿƒ`pý‹…Øýÿÿ‹Mü_^3Í[èÚëÿÿÉÃ+@ )@ G)@ ¥)@ ñ)@ ü)@ B*@ p+@ jThXõ@ èe 3ÿ‰}üEœPÿ4à@ ÇEüþÿÿÿj@j ^Vèy YY;Ç„ £ *A ‰5*A ˆ ë0Æ@ ƒÿÆ@
‰xÆ@$ Æ@%
Æ@&
‰x8Æ@4 ƒÀ@‹
*A Á ;ÁrÌf9}΄
‹EÐ;Ç„ÿ ‹8X;‰Eä¾ ;þ|‹þÇEà ë[j@j èë YY…ÀtV‹Mà *A ‰ƒ*A ë*Æ@ ƒÿÆ@
ƒ` €`$€Æ@%
Æ@&
ƒ`8 Æ@4 ƒÀ@‹Ö;ÂrÒÿEà9=*A |ë‹=*A ƒeà …ÿ~m‹E䋃ùÿtVƒùþtQŠ¨tK¨u Qÿ@à@ …Àt<‹uà‹ÆÁøƒæ Áæ4… *A ‹Eä‹ ‰ŠˆFh F Pè„* YY…À„É ÿFÿEàCƒEä9}à|“3Û‹óÁæ5 *A ‹ƒøÿt ƒøþt€N€ërÆF…ÛujöXë
‹ÃH÷ØÀƒÀõPÿ<à@ ‹øƒÿÿtC…ÿt?Wÿ@à@ …Àt4‰>%ÿ ƒøu€N@ë ƒøu€Nh F Pèî) YY…Àt7ÿFë
€N@ÇþÿÿÿCƒûŒgÿÿÿÿ5*A ÿ8à@ 3Àë3À@ËeèÇEüþÿÿÿƒÈÿèc ËÿU‹ì‹EV3ö;Æu è½ VVVVVÇ èE ƒÄƒÈÿë‹@^]ËÿU‹ì‹E£P A ]ËÿU‹ìì( ¡€A 3ʼnEüƒ¥Øüÿÿ SjL…Üüÿÿj Pèóäÿÿ…Øüÿÿ‰…(ýÿÿ…0ýÿÿƒÄ ‰…,ýÿÿ‰…àýÿÿ‰Üýÿÿ‰•Øýÿÿ‰Ôýÿÿ‰µÐýÿÿ‰½ÌýÿÿfŒ•øýÿÿfŒìýÿÿfŒÈýÿÿfŒ…ÄýÿÿfŒ¥ÀýÿÿfŒ¼ýÿÿœ…ðýÿÿ‹EMÇ…0ýÿÿ ‰…èýÿÿ‰ôýÿÿ‹Iü‰äýÿÿÇ…Øüÿÿ ÀÇ…Üüÿÿ ‰…äüÿÿÿXà@ j ‹ØÿTà@ …(ýÿÿPÿPà@ …Àu …ÛujèM2 Yh ÀÿLà@ PÿHà@ ‹Mü3Í[èüçÿÿÉËÿU‹ìÿ5P A è* Y…Àt]ÿàjè2 Y]é²þÿÿ‹ÿU‹ì‹E3É;ÍØA tAƒù-rñHíƒùwj
X]ËÍÜA ]ÃDÿÿÿjY;ÈÀ#ÁƒÀ]Ãè …Àu¸@A ÃÀÃè …Àu¸DA ÃÀ ËÿU‹ìVèâÿÿÿ‹MQ‰è‚ÿÿÿY‹ðè¼ÿÿÿ‰0^]ÃÌÌÌh 8@ dÿ5 ‹D$‰l$l$+àSVW¡€A 1Eü3ÅP‰eèÿuø‹EüÇEüþÿÿÿ‰EøEðd£ ËMðd‰
Y__^[‹å]QÃÌÌÌÌÌÌÌÌÌÌÌ‹ÿU‹ìƒìS‹] V‹s35€A W‹ÆEÿ ÇEô {ƒøþt
‹NÏ3 8è©æÿÿ‹N ‹FÏ3 8è™æÿÿ‹Eö@f… ‹MUè‰Sü‹[ ‰Eè‰Mìƒûþt_I [‹L†D†‰Eð‹ ‰Eø…Ét‹×è„1 ÆEÿ…À|@G‹Eø‹Øƒøþu΀}ÿ t$‹ƒøþt
‹NÏ3 8è&æÿÿ‹N ‹VÏ3 :èæÿÿ‹Eô_^[‹å]ÃÇEô ëÉ‹M9csmàu)ƒ=Œ*A t hŒ*A èƒ! ƒÄ…Àt‹UjRÿŒ*A ƒÄ‹M è'1 ‹E 9X th€A W‹Ó‹Èè*1 ‹E ‹Mø‰H ‹ƒøþt
‹NÏ3 8è“åÿÿ‹N ‹VÏ3 :èƒåÿÿ‹Eð‹H‹×è½0 ºþÿÿÿ9S „Rÿÿÿh€A W‹ËèÕ0 é ÿÿÿ‹ÿU‹ìVW3öÿuè%1 ‹øY…ÿu'9T A v Vÿ$à@ †è ;T A vƒÈÿ‹ðƒøÿuÊ‹Ç_^]ËÿU‹ìVW3öj ÿu ÿuèE ‹øƒÄ …ÿu'9T A v Vÿ$à@ †è ;T A vƒÈÿ‹ðƒøÿuËÇ_^]ËÿU‹ìVW3öÿu ÿuè[1 ‹øYY…ÿu,9E t'9T A v Vÿ$à@ †è ;T A vƒÈÿ‹ðƒøÿuÁ‹Ç_^]ËÿU‹ìVW3öÿuÿu ÿuè%3 ‹øƒÄ …ÿu,9Et'9T A v Vÿ$à@ †è ;T A vƒÈÿ‹ðƒøÿu½‹Ç_^]Ãj hxõ@ èÓüÿÿ‹u…ötuƒ=„*A uCjè Yƒeü Vè73 Y‰Eä…Àt VPèX3 YYÇEüþÿÿÿè ƒ}ä u7ÿuë
jè YÃVj ÿ5t)A ÿ`à@ …Àuè üÿÿ‹ðÿ\à@ PèÌûÿÿ‰Yè—üÿÿÃjh˜õ@ èEüÿÿ3Û‰]äjè– Y‰]üj_‰}à;=À;A }W‹÷Á桼+A Æ9tD‹ ö@ ƒtPèÊ= YƒøÿtÿEäƒÿ|(¡¼+A ‹ƒÀ PÿDà@ ¡¼+A ÿ4èýþÿÿY¡¼+A ‰ GëžÇEüþÿÿÿè ‹EäèüÿÿÃjè7 YËÿU‹ìSV‹u‹F ‹È€á3Û€ùu@© t9‹FW‹>+ø…ÿ~,WPVèaùÿÿYPèçD ƒÄ ;Çu‹F „Àyƒàý‰F ëƒN ƒËÿ_‹Fƒf ‰^‹Ã[]ËÿU‹ìV‹u…öu Vè5 Yë/Vè|ÿÿÿY…ÀtƒÈÿë ÷F @ tVèøøÿÿPè[E Y÷ØYÀë3À^]Ãjh¸õ@ èöúÿÿ3ÿ‰}ä‰}ÜjèD Y‰}ü3ö‰uà;5À;A ƒ ¡¼+A °98t^‹ ö@ ƒtVPVèÝÿÿYY3ÒB‰Uü¡¼+A ‹°‹H öÁƒt/9UuPèJÿÿÿYƒøÿt ÿEäë9}uöÁtPè/ÿÿÿYƒøÿu E܉}üè Fë„3ÿ‹uࡼ+A ÿ4°Vè"ÝÿÿYYÃÇEüþÿÿÿè ƒ}‹Eät‹EÜèwúÿÿÃjè YÃjè ÿÿÿYËÿVW3ö¿X A ƒ<õLA u õHA ‰8h ÿ0ƒÇè}! YY…Àt Fƒþ$|Ò3À@_^Ã$õHA 3Àëñ‹ÿS‹ Dà@ V¾HA W‹>…ÿtƒ~t
WÿÓWèÐüÿÿƒ& YƒÆþhA |ܾHA _‹…Àt ƒ~uPÿÓƒÆþhA |æ^[ËÿU‹ì‹Eÿ4ÅHA ÿ à@ ]Ãj hàõ@ èZùÿÿ3ÿG‰}ä3Û9 t)A uè´ j è hÿ èPãÿÿYY‹u4õHA 9 t‹Çënjè ûÿÿY‹ø;ûuèÁøÿÿÇ 3ÀëQj
èY Y‰]ü9 u,h Wèt YY…ÀuWèþûÿÿYè‹øÿÿÇ ‰]äë ‰>ëWèãûÿÿYÇEüþÿÿÿè ‹EäèòøÿÿÃj
è(ÿÿÿYËÿU‹ì‹EV4ÅHA ƒ> uPè"ÿÿÿY…ÀujèDâÿÿYÿ6ÿà@ ^]Ãj h ö@ èdøÿÿ‹M3ÿ;Ïv.jàX3Ò÷ñ;E À@u èû÷ÿÿÇ WWWWWèƒ÷ÿÿƒÄ3ÀéÕ ¯M ‹ñ‰u;÷u3öF3Û‰]äƒþàwiƒ=„*A uKƒÆƒæð‰u ‹E;p*A w7jèLÿÿÿY‰}üÿuèH6 Y‰EäÇEüþÿÿÿè_ ‹]ä;ßtÿuWSèÛÿÿƒÄ ;ßuaVjÿ5t)A ÿdà@ ‹Ø;ßuL9=€)A t3Vè’ Y…À…rÿÿÿ‹E;Ç„PÿÿÿÇ éEÿÿÿ3ÿ‹u jèðýÿÿYÃ;ßu
‹E;ÇtÇ ‹Ãè˜÷ÿÿÃU‹ìƒì‰}ü‹}‹M ÁéfïÀë¤$ ffGfG fG0fG@fGPfG`fGp¿€ IuЋ}ü‹å]ÃU‹ìƒì‰}ü‹E™‹ø3ú+úƒç3ú+ú…ÿu<‹M‹Ñƒâ‰Uô;Êt+ÊQPèsÿÿÿƒÄ‹E‹Uô…ÒtEE+‰Eø3À‹}ø‹Môóª‹Eë.÷߃lj}ð3À‹}‹Mðóª‹Eð‹M‹UÈ+ÐRj Qè~ÿÿÿƒÄ ‹E‹}ü‹å]Ãj h ö@ è`öÿÿƒeü f(ÁÇEä ë#‹Eì‹ ‹ = Àt
= Àt3ÀÃ3À@Ëeèƒeä ÇEüþÿÿÿ‹EäèböÿÿËÿU‹ìƒì3ÀS‰Eü‰Eô‰EøSœX‹È5 PœZ+Ñt Q3À¢‰Eô‰]è‰Uì‰M𸠢‰Uü‰Eø[÷Eü tè\ÿÿÿ…Àt3À@ë3À[ÉÃè™ÿÿÿ£ˆ*A 3ÀËÿU‹ìQSV‹u3ÛW;ót9] w èEõÿÿjYSSSSS‹ñ‰èÌôÿÿƒÄ‹ÆéÍ ‹E3ÿ;ÃtŠ :Ãtj_9} † ˆFÆ:F‹M‹Á;Ët@8t<ë‹}ü‹U G‰}ü;úsyŠˆF@8uèPQèì@ Š YYŠˆF@8uð‹E ;Ãt'Š:Ët!€ù.tG;} s Æ.Fë G;} sŠˆF@8uðG;} v‹Eˆèhôÿÿj"é ÿÿÿˆ 3À_^[ÉËÿU‹ìƒìÿuMðèæÛÿÿ¶E ‹MôŠU„T u ƒ} t‹Mð‹‰È ·A#Eë3À…Àt3À@€}ü t‹MøƒapýÉËÿU‹ìjj ÿuÿu è™ÿÿÿƒÄ]ËÿU‹ìjj ÿuj èÿÿÿƒÄ]ËÿU‹ìj ÿuÿuÿu ÿuèå? ƒÄ]ËÿU‹ìì( £°"A ‰
¬"A ‰¨"A ‰ ¤"A ‰5 "A ‰=œ"A fŒÈ"A fŒ
¼"A fŒ ˜"A fŒ”"A fŒ%"A fŒ-Œ"A œÀ"A ‹E £´"A ‹E£¸"A E£Ä"A ‹…àüÿÿÇ "A ¡¸"A £´!A Ǩ!A ÀǬ!A ¡€A ‰…Øüÿÿ¡„A ‰…ÜüÿÿÿXà@ £ø!A jè¯$ Yj ÿTà@ hÔâ@ ÿPà@ ƒ=ø!A ujè‹$ Yh ÀÿLà@ PÿHà@ ÉÃ-¤ t"ƒètƒè
t Ht3Àø ø ø ø ËÿVW‹ðh 3ÿF WPèûÕÿÿ3À·È‹Á‰~‰~‰~ Áá Á~«««¹hA ƒÄ F +ο Šˆ@Ou÷† ¾ Šˆ@Nu÷_^ËÿU‹ìì ¡€A 3ʼnEüSW…èúÿÿPÿvÿhà@ ¿ …À„û 3Àˆ„üþÿÿ@;ÇrôŠ…îúÿÿÆ…üþÿÿ „Àt.ïúÿÿ¶È¶;Èw+Á@P”
üþÿÿj Rè8ÕÿÿƒÄ CŠC„ÀuØj ÿv …üúÿÿÿvPW…üþÿÿPjj èyE 3ÛSÿv…üýÿÿWPW…üþÿÿPWÿv SèZC ƒÄDSÿv…üüÿÿWPW…üþÿÿPh ÿv Sè5C ƒÄ$3À·ŒEüúÿÿöÁt€L ŠŒüýÿÿëöÁt€L ŠŒüüÿÿˆŒ ëÆ„ @;Çr¾ëV† Ç…äúÿÿŸÿÿÿ3É)…äúÿÿ‹•äúÿÿ„ ÐZ ƒûw €L ŠÑ€Â ëƒúw€L ŠÑ€ê ˆëÆ A;Ïr‹Mü_3Í[è ØÿÿÉÃj h@ö@ èËðÿÿè˜
‹ø¡ŒA …Gpt ƒl t‹wh…öuj ènÚÿÿY‹ÆèãðÿÿÃj
èó÷ÿÿYƒeü ‹wh‰uä;5A t6…ötVÿpà@ …ÀuþhA tVè‡óÿÿY¡A ‰Gh‹5A ‰uäVÿlà@ ÇEüþÿÿÿè 뎋uäj
è¸öÿÿYËÿU‹ìƒìS3ÛSMðèt×ÿÿ‰ Ì$A ƒþþu ÇÌ$A ÿxà@ 8]ütE‹Møƒapýë<ƒþýuÇÌ$A ÿtà@ ëÛƒþüu‹Eð‹@ÇÌ$A ëÄ8]üt‹Eøƒ`pý‹Æ[ÉËÿU‹ìƒì ¡€A 3ʼnEüS‹] V‹uWèdÿÿÿ‹ø3ö‰};þu‹Ãè·üÿÿ3Àé ‰uä3À9¸˜A „‘ ÿEäƒÀ0=ð rçÿèý „p ÿéý „d ·ÇPÿ|à@ …À„R EèPWÿhà@ …À„3 h C VPèXÒÿÿ3ÒBƒÄ ‰{‰s 9Uè†ø €}î „Ï uɄ ¶Fÿ¶Éé¦ h C VPèÒÿÿ‹MäƒÄ kÉ0‰u౨A ‰uäë*ŠF„Àt(¶>¶Àë‹EàŠ€”A D; ¶FG;øvê‹}FF€> uÑ‹uäÿEàƒÆƒ}à‰uäré‹Ç‰{ÇC ègûÿÿj‰C C‰œA Zf‹1Af‰0A@@Juó‹óè×ûÿÿé·þÿÿ€L @;ÁvöFF€~ÿ …4ÿÿÿC ¹þ €@Iuù‹Cèûÿÿ‰C ‰Së‰s3À·È‹ÁÁá Á{«««ë¨95Ì$A …XþÿÿƒÈÿ‹Mü_^3Í[èÕÿÿÉÃjh`ö@ èÆíÿÿƒMàÿè ‹ø‰}ÜèÜüÿÿ‹_h‹uèuýÿÿ‰E;C„W h è‚ïÿÿY‹Ø…Û„F ¹ˆ ‹wh‹ûó¥ƒ# Sÿuè¸ýÿÿYY‰Eà…À…ü ‹uÜÿvhÿpà@ …Àu‹Fh=hA tPècðÿÿY‰^hS‹=là@ ÿ×öFp…ê öŒA …Ý j
ètôÿÿYƒeü ‹C£Ü$A ‹C£à$A ‹C £ä$A 3À‰Eäƒø}f‹LCf‰ EÐ$A @ëè3À‰Eä= }
ŠL ˆˆˆA @ëé3À‰Eä= }ŠŒ ˆˆA @ëæÿ5A ÿpà@ …Àu¡A =hA tPèªïÿÿY‰ A Sÿ×ÇEüþÿÿÿè ë0j
èíòÿÿYÃë%ƒøÿu ûhA tSètïÿÿYèìÿÿÇ ëƒeà ‹Eàè~ìÿÿÃ=°+A ujýèVþÿÿYÇ°+A 3ÀËÿU‹ìSV‹u‹†¼ 3ÛW;Ãto=H A th‹†° ;Ãt^9uZ‹†¸ ;Ãt9uPèûîÿÿÿ¶¼ è›A YY‹†´ ;Ãt9uPèÚîÿÿÿ¶¼ è5A YYÿ¶° èÂîÿÿÿ¶¼ è·îÿÿYY‹†À ;ÃtD9u@‹†Ä -þ Pè–îÿÿ‹†Ì ¿€ +ÇPèƒîÿÿ‹†Ð +ÇPèuîÿÿÿ¶À èjîÿÿƒÄ¾Ô ‹=ˆ A t9˜´ uPè? ÿ7èCîÿÿYY~PÇE øA t‹;Ãt 9uPè îÿÿY9_üt‹G;Ãt 9uPèîÿÿYƒÇÿMuÇVèøíÿÿY_^[]ËÿU‹ìSV‹5là@ W‹}WÿÖ‹‡° …ÀtPÿÖ‹‡¸ …ÀtPÿÖ‹‡´ …ÀtPÿÖ‹‡À …ÀtPÿÖ_PÇE {øA t ‹…ÀtPÿÖƒ{ü t
‹C…ÀtPÿÖƒÃÿMuÖ‹‡Ô ´ PÿÖ_^[]ËÿU‹ìW‹}…ÿ„ƒ SV‹5pà@ WÿÖ‹‡° …ÀtPÿÖ‹‡¸ …ÀtPÿÖ‹‡´ …ÀtPÿÖ‹‡À …ÀtPÿÖ_PÇE {øA t ‹…ÀtPÿÖƒ{ü t
‹C…ÀtPÿÖƒÃÿMuÖ‹‡Ô ´ PÿÖ^[‹Ç_]Ã…ÿt7…Àt3V‹0;÷t(W‰8èÁþÿÿY…ötVèEÿÿÿƒ> Yuþ˜A tVèYýÿÿY‹Ç^Ã3ÀÃj h€ö@ è_éÿÿè, ‹ð¡ŒA …Fpt"ƒ~l t è ‹pl…öuj èýÒÿÿY‹ÆèréÿÿÃj è‚ðÿÿYƒeü Fl‹=pA èiÿÿÿ‰EäÇEüþÿÿÿè ëÁj è}ïÿÿY‹uäËÿU‹ìVÿ5„A ‹5€à@ ÿÖ…Àt!¡€A ƒøÿtPÿ5„A ÿÖÿÐ…Àt‹€ø ë'¾tã@ Vÿ à@ …Àu Vè>ÒÿÿY…Àthdã@ Pÿ(à@ …ÀtÿuÿЉE‹E^]Ãj è‡ÿÿÿYËÿU‹ìVÿ5„A ‹5€à@ ÿÖ…Àt!¡€A ƒøÿtPÿ5„A ÿÖÿÐ…Àt‹€ü ë'¾tã@ Vÿ à@ …Àu VèÃÑÿÿY…Àthã@ Pÿ(à@ …ÀtÿuÿЉE‹E^]Ãÿ„à@  ‹ÿVÿ5„A ÿ€à@ ‹ð…öuÿ5%A èeÿÿÿY‹ðVÿ5„A ÿˆà@ ‹Æ^á€A ƒøÿtPÿ5%A è;ÿÿÿYÿЃ
€A ÿ¡„A ƒøÿtPÿŒà@ ƒ
„A ÿéºíÿÿj h ö@ è‚çÿÿ¾tã@ Vÿ à@ …ÀuVèÑÿÿY‰Eä‹uÇF\é@ 3ÿG‰~…Àt$hdã@ P‹ (à@ ÿÓ‰†ø hã@ ÿuäÿÓ‰†ü ‰~pÆ†È CƆK CÇFhhA j
ènîÿÿYƒeü ÿvhÿlà@ ÇEüþÿÿÿè> j èMîÿÿY‰}ü‹E ‰Fl…Àu¡pA ‰FlÿvlèüÿÿYÇEüþÿÿÿè èçÿÿÃ3ÿG‹uj
è5íÿÿYÃj è,íÿÿYËÿVWÿ\à@ ÿ5€A ‹øè‘þÿÿÿЋð…öuNh jè±èÿÿ‹ðYY…öt:Vÿ5€A ÿ5%A èèýÿÿYÿÐ…Àtj VèÅþÿÿYYÿ”à@ ƒNÿ‰ë Vè^éÿÿY3öWÿà@ _‹Æ^ËÿVèÿÿÿ‹ð…öujèáÏÿÿY‹Æ^ÃjhÈö@ èæÿÿ‹u…ö„ø ‹F$…ÀtPèéÿÿY‹F,…ÀtPèéÿÿY‹F4…ÀtPèõèÿÿY‹F<…ÀtPèçèÿÿY‹F@…ÀtPèÙèÿÿY‹FD…ÀtPèËèÿÿY‹FH…ÀtPè½èÿÿY‹F\=é@ tPè¬èÿÿYj
èàìÿÿYƒeü ‹~h…ÿtWÿpà@ …ÀuÿhA tWèèÿÿYÇEüþÿÿÿèW j è§ìÿÿYÇEü ‹~l…ÿt#WèóúÿÿY;=pA tÿ˜A t ƒ? uWèÿøÿÿYÇEüþÿÿÿè Vè'èÿÿYèEåÿÿ ‹uj
èvëÿÿYËuj èjëÿÿYËÿVW¾tã@ Vÿ à@ …ÀuVècÎÿÿY‹ø…ÿ„^ ‹5(à@ hÀã@ WÿÖh´ã@ W£ %A ÿÖh¨ã@ W£%A ÿÖh ã@ W£%A ÿÖƒ= %A ‹5ˆà@ £%A tƒ=%A t
ƒ=%A t…Àu$¡€à@ £%A ¡Œà@ Ç %A ”O@ ‰5%A £%A ÿ„à@ £„A ƒøÿ„Ì ÿ5%A PÿÖ…À„» è•Ðÿÿÿ5 %A èûÿÿÿ5%A £ %A èûÿÿÿ5%A £%A èóúÿÿÿ5%A £%A èãúÿÿƒÄ£%A è¬éÿÿ…ÀtehˆQ@ ÿ5 %A è=ûÿÿYÿУ€A ƒøÿtHh jèÓåÿÿ‹ðYY…öt4Vÿ5€A ÿ5%A è
ûÿÿYÿÐ…Àtj VèçûÿÿYYÿ”à@ ƒNÿ‰3À@ëè’ûÿÿ3À_^ËÿU‹ìƒìSÿuMèè™Êÿÿ‹]C= w‹Eè‹€È ·Xëu‰]Á}EèP‹E%ÿ Pè§ YY…ÀtŠEjˆEøˆ]ùÆEú Yë
3Ɉ]øÆEù A‹EèjÿpÿpEüPQEøPEèjPè~6 ƒÄ …Àu8Eôt‹Eðƒ`pý3Àë·Eü#E €}ô t‹Mðƒapý[ÉËÿU‹ìQV‹u Vèsàÿÿ‰E ‹F Y¨‚uè4âÿÿÇ ƒN ƒÈÿé/ ¨@t
èâÿÿÇ " ëãS3Û¨t‰^¨„‡ ‹Nƒàþ‰‰F ‹F ƒàïƒÈ‰F ‰^‰]ü© u,èlÃÿÿƒÀ ;ðt è`ÃÿÿƒÀ@;ðu
ÿu è Y…ÀuVè @ Y÷F W„€ ‹F‹>H‰‹N+øI;û‰N~ WPÿu è<+ ƒÄ ‰EüëMƒÈ ‰F ƒÈÿëy‹M ƒùÿtƒùþt‹Áƒà ‹ÑÁúÁà• *A 븘A ö@ tjSSQèŠ> #ƒăøÿt%‹FŠMˆë3ÿGWEPÿu èÍ* ƒÄ ‰Eü9}üt ƒN ƒÈÿë‹E%ÿ _[^ÉËÿU‹ìQQS‹]VW3ö3ÿ‰}ü; ýˆA t G‰}üƒÿrîƒÿƒw jèÚ@ Yƒø„4 jèÉ@ Y…Àu
ƒ=ŒA „ ûü „A hpé@ » S¿ %A Wè8 ƒÄ …Àt
VVVVVèÔÞÿÿƒÄh ¾9%A Vj Æ=&A ÿà@ …Àu&hXé@ hû VèN8 ƒÄ …Àt3ÀPPPPPèÞÿÿƒÄVèç @Yƒø ƒÄ ë2jôÿ<à@ ‹Ø;Þt$ƒûÿt j EøP4ýŒA ÿ6è% YPÿ6Sÿ˜à@ _^[ÉÃjè^? YƒøtjèQ? Y…Àu ƒ=ŒA uhü è)þÿÿhÿ è þÿÿYYËÿU‹ìQSVWÿ5¬+A èÊöÿÿÿ5¨+A ‹ø‰}üèºöÿÿ‹ðYY;÷‚ƒ ‹Þ+ßCƒørwWè5? ‹øCY;øsH¸ ;øs‹ÇÇ;ÇrPÿuüèsáÿÿYY…ÀuG;Çr@Pÿuüè]áÿÿYY…Àt1ÁûP4˜èÕõÿÿY£¬+A ÿuèÇõÿÿ‰ƒÆVè¼õÿÿY£¨+A ‹EYë3À_^[ÉËÿVjj èÇàÿÿ‹ðVè•õÿÿƒÄ £¬+A £¨+A …öujX^Ã& 3À^Ãj hðö@ èaÞÿÿèÈÿÿƒeü ÿuèøþÿÿY‰EäÇEüþÿÿÿè ‹Eäè}ÞÿÿÃèoÈÿÿËÿU‹ìÿuè·ÿÿÿ÷ØÀ÷ØYH]ËÿV¸àô@ ¾àô@ W‹ø;Æs‹…ÀtÿЃÇ;þrñ_^ËÿV¸èô@ ¾èô@ W‹ø;Æs‹…ÀtÿЃÇ;þrñ_^ËÿVW3ÿ·@ A ÿ6èÆôÿÿƒÇY‰ƒÿ(rè_^ÃÌ‹ÿU‹ì‹M¸MZ f9t3À]ËA<Á8PE uï3Ò¹ f9H”‹Â]ÃÌÌÌÌÌÌÌÌÌÌÌ‹ÿU‹ì‹E‹H<È·ASV·q3ÒWD…öv‹} ‹H ;ùr ‹XÙ;ûr
BƒÀ(;Örè3À_^[]ÃÌÌÌÌÌÌÌÌÌÌÌÌ‹ÿU‹ìjþh÷@ h 8@ d¡ PƒìSVW¡€A 1Eø3ÅPEðd£ ‰eèÇEü h @ è*ÿÿÿƒÄ…ÀtU‹E- @ Ph @ èPÿÿÿƒÄ…Àt;‹@$Áè ÷ЃàÇEüþÿÿÿ‹Mðd‰
Y_^[‹å]ËEì‹‹3Ò= À”‹ÂËeèÇEüþÿÿÿ3À‹Mðd‰
Y_^[‹å]Ãjh0÷@ èSÜÿÿè öÿÿ‹@x…Àtƒeü ÿÐë3À@ËeèÇEüþÿÿÿè÷< èlÜÿÿÃh=[@ è'óÿÿY£4(A ÃËÿU‹ìQQVè`õÿÿ‹ð…ö„F ‹V\¡t A W‹}‹ÊS99t‹ØkÛ ƒÁ Ú;ËrîkÀ Â;Ès99u‹Áë3À…Àt
‹X‰]ü…Ûu3Àéû ƒûu ƒ` 3À@éê ƒû„Þ ‹N`‰Mø‹M ‰N`‹Hƒù…¸ ‹
h A ‹=l A ‹Ñù;×}$kÉ ‹~\ƒd9 ‹=h A ‹ l A B߃Á ;Ó|â‹]ü‹ ‹~d=Ž Àu ÇFdƒ ë^= Àu ÇFd ëN=‘ Àu ÇFd„ ë>=“ Àu ÇFd… ë.= Àu ÇFd‚ ë = Àu ÇFd† ë=’ ÀuÇFdŠ ÿvdjÿÓY‰~dëƒ` QÿÓ‹EøY‰F`ƒÈÿ[_^ÉËÿU‹ì‹E£8(A £<(A £@(A £D(A ]ËÿU‹ì‹E‹
t A V9Pt‹ñkö uƒÀ ;ÆrìkÉ M^;Ás9Pt3À]Ãÿ5@(A èÚñÿÿYÃj hP÷@ èFÚÿÿ3ÿ‰}ä‰}Ø‹]ƒû Lt‹ÃjY+Át"+Át+Átd+ÁuDèsóÿÿ‹ø‰}Ø…ÿuƒÈÿéa ¾8(A ¡8(A ë`ÿw\‹Óè]ÿÿÿ‹ðƒÆ‹ëZ‹Ãƒèt<ƒèt+Ht èŠÙÿÿÇ 3ÀPPPPPèÙÿÿƒÄ뮾@(A ¡@(A ë¾<(A ¡<(A ë
¾D(A ¡D(A ÇEä Pèñÿÿ‰EàY3Àƒ}à„Ø 9EàujèÂÅÿÿ9EätPèÆàÿÿY3À‰Eüƒût
ƒû tƒûu‹O`‰MÔ‰G`ƒûu@‹Od‰MÐÇGdŒ ƒûu.‹
h A ‰MÜ‹
l A ‹h A Ê9MÜ}‹MÜkÉ ‹W\‰DÿEÜëÛè~ðÿÿ‰ÇEüþÿÿÿè ƒûu ÿwdSÿUàYë‹]‹}؃}ä tj èTßÿÿYÃSÿUàYƒût
ƒû tƒûu‹EÔ‰G`ƒûu‹EЉGd3ÀèèØÿÿËÿU‹ì‹E£L(A ]ËÿU‹ì‹E£X(A ]ËÿU‹ì‹E£\(A ]Ãjhp÷@ èiØÿÿƒeü ÿu ÿuÿ à@ ‰Eäë/‹Eì‹ ‹ ‰Eà3É= À”Á‹ÁËeè}à Àujÿà@ ƒeä ÇEüþÿÿÿ‹Eäè[ØÿÿËÿU‹ì‹E£`(A ]ËÿU‹ìÿ5`(A è|ïÿÿY…ÀtÿuÿÐY…Àt3À@]Ã3À]ËÿU‹ì‹E‹ 8csmàu*ƒxu$‹@= “t=!“t="“t= @™uèCûÿÿ3À] h¾_@ ÿTà@ 3ÀËÿVW3ÿ9=°+A uèCëÿÿ‹5 +A …öu¾bã@ Š< w„Àt.…ÿt$<"u 3É…ÿ”Á‹ù¶ÀPèãÿÿY…ÀtFFëÓ< wFŠ„Àuõ_‹Æ^Ã=°+A uèéêÿÿV‹5< A W3ÿ…öuƒÈÿé <=tGVè„ YtŠ„ÀuêjGWè!Ùÿÿ‹øYY‰= A …ÿtË‹5< A SëBVèS ‹ØC€>=Yt1jSèóØÿÿYY‰…ÀtNVSPè}. ƒÄ …Àt3ÀPPPPPè¿ÔÿÿƒÄƒÇó€> u¹ÿ5< A è¤Ùÿÿƒ%< A ƒ' Ǥ+A 3ÀY[_^Ãÿ5 A è~Ùÿÿƒ% A ƒÈÿëä‹ÿU‹ìQ‹MS3ÀV‰‹ò‹U Ç 9Et ‹]ƒE‰‰Eü€>"u3À9Eü³"”ÀF‰Eüë<ÿ…ÒtŠˆB‰U Š ¶ÃPFè¿áÿÿY…Àtÿƒ} t
‹M ŠÿE ˆF‹U ‹M„Ût2ƒ}ü u©€û t€û uŸ…ÒtÆBÿ ƒeü €> „é Š< t< uFëóNëã€> „Ð ƒ} t ‹EƒE‰ÿ3ÛC3ÉëFA€>\tù€>"u&öÁu ƒ}ü t F€8"u‹ðë
3À3Û9Eü”À‰EüÑé…ÉtI…ÒtÆ\Bÿ…Éuñ‰U Š„ÀtUƒ}ü u< tK< tG…Ût=¾ÀP…Òt#èÚàÿÿY…Àt
Š‹M ÿE ˆFÿ‹M ŠÿE ˆë
è·àÿÿY…ÀtFÿÿ‹U FéVÿÿÿ…ÒtÆ B‰U ÿ‹Méÿÿÿ‹E^[…Àtƒ ÿÉËÿU‹ìƒì S3ÛVW9 °+A uèeèÿÿh ¾h(A VSˆ l)A ÿà@ ¡ +A ‰5( A ;Ãt‰Eü8u‰uü‹UüEøPSS}ôè
þÿÿ‹EøƒÄ =ÿÿÿ?sJ‹MôƒùÿsB‹øÁç;Ár6Pè$Öÿÿ‹ðY;ót)‹UüEøPþWV}ôèÉýÿÿ‹EøƒÄ H£ A ‰5 A 3ÀëƒÈÿ_^[ÉËÿU‹ì¡p)A ƒì SV‹5´à@ W3Û3ÿ;Ãu.ÿÖ‹ø;ût Çp)A ë#ÿ\à@ ƒøxu
jX£p)A ë¡p)A ƒø… ;ûuÿÖ‹ø;ûu3ÀéÊ ‹Çf9 t@@f9uù@@f9uò‹5°à@ SSS+ÇSÑø@PWSS‰EôÿÖ‰Eø;Ãt/PèJÕÿÿY‰Eü;Ãt!SSÿuøPÿuôWSSÿÖ…Àu ÿuüèYÖÿÿY‰]ü‹]üWÿ¬à@ ‹Ãë\ƒøt;Ãu‚ÿ¨à@ ‹ð;ó„rÿÿÿ8 t
@8uû@8uö+Æ@P‰EøèãÔÿÿ‹øY;ûu Vÿ¤à@ éEÿÿÿÿuøVWèª+ ƒÄ Vÿ¤à@ ‹Ç_^[ÉËÿU‹ì3À9Ej ”Àh Pÿ¸à@ £t)A …Àu]Ã3À@£„*A ]ËÿU‹ìƒì¡€A ƒeø ƒeü SW¿Næ@»» ÿÿ;Çt
…Ãt ÷У„A ë`VEøPÿÌà@ ‹uü3uøÿÈà@ 3ðÿ”à@ 3ðÿÄà@ 3ðEðPÿÀà@ ‹Eô3Eð3ð;÷u¾Oæ@»ë …óu‹ÆÁà ð‰5€A ÷Ö‰5„A ^_[ÉËÿU‹ì‹Eƒøþuè¡ÑÿÿÇ 3À]ÃV3ö;Æ|;*A r èƒÑÿÿVVVVVÇ è ÑÿÿƒÄ3Àë‹Èƒà Áù‹ *A Áà¾Dƒà@^]á€A ƒÈ3É9x)A ”Á‹ÁÃÌÌÌÌÌÌÌÌÌ‹L$÷Á t$ŠƒÁ„ÀtN÷Á uï ¤$ ¤$ ‹ºÿþþ~Ѓðÿ3ƒÁ© tè‹Aü„Àt2„ät$© ÿ t© ÿtëÍAÿ‹L$+ÁÃAþ‹L$+ÁÃAý‹L$+ÁÃAü‹L$+ÁËÿU‹ìƒìSV‹u 3ÛW‹};óu;ûv‹E;Ãt‰3Àéƒ ‹E;ÃtƒÿÿÿÿÿvècÐÿÿj^SSSSS‰0èìÏÿÿƒÄ‹ÆëVÿuMðèã·ÿÿ‹Eð9X…œ f‹E¹ÿ f;Áv6;ót;ûv WSV訳ÿÿƒÄ èÐÿÿÇ * èÐÿÿ‹ 8]üt‹Møƒapý_^[ÉÃ;ót2;ûw,èåÏÿÿj"^SSSSS‰0ènÏÿÿƒÄ8]ü„yÿÿÿ‹Eøƒ`pýémÿÿÿˆ‹E;ÃtÇ 8]ü„%ÿÿÿ‹Eøƒ`pýéÿÿÿM QSWVjMQS‰] ÿpÿ°à@ ;Ãt9] …^ÿÿÿ‹M;Ët½‰ë¹ÿ\à@ ƒøz…Dÿÿÿ;ó„gÿÿÿ;û†_ÿÿÿWSVèѲÿÿƒÄ éOÿÿÿ‹ÿU‹ìj ÿuÿuÿu ÿuè|þÿÿƒÄ]ËÿU‹ìƒìÿu Mð誶ÿÿ¶E‹Mð‹‰È ·A% € €}ü t‹MøƒapýÉËÿU‹ìj ÿuè¹ÿÿÿYY]ÃÌV‹D$ Àu(‹L$‹D$ 3Ò÷ñ‹Ø‹D$÷ñ‹ð‹Ã÷d$‹È‹Æ÷d$ÑëG‹È‹\$‹T$ ‹D$ÑéÑÛÑêÑØ Éuô÷ó‹ð÷d$‹È‹D$÷æÑr;T$ wr;D$v N+D$T$3Û+D$T$ ÷Ú÷ØƒÚ ‹Ê‹Ó‹Ù‹È‹Æ^ ƒ%€*A ÃÌÌÌSVW‹T$‹D$‹L$URPQQh°i@ dÿ5 ¡€A 3ĉD$d‰% ‹D$0‹X‹L$,3‹p ƒþþt;‹T$4ƒúþt;òv.4v\³‹ ‰H ƒ{ uÌh ‹Cè1 ¹ ‹Cè1 ë°d ƒÄ_^[ËL$÷A ¸ t3‹D$‹H3ÈèµÿÿU‹hÿp ÿpÿpè>ÿÿÿƒÄ ]‹D$‹T$‰¸ ÃU‹L$‹)ÿq ÿqÿq(èÿÿÿƒÄ ] UVWS‹ê3À3Û3Ò3ö3ÿÿÑ[_^]Ëê‹ñ‹Ájè_0 3À3Û3É3Ò3ÿÿæU‹ìSVWj j hWj@ Qè—Q _^[]ÃU‹l$RQÿt$è´þÿÿƒÄ ] j h÷@ è Íÿÿƒeä ‹u;5p*A w"jèdÔÿÿYƒeü Vèa Y‰EäÇEüþÿÿÿè ‹Eäè)ÍÿÿÃjè_ÓÿÿYËÿU‹ìV‹uƒþà‡¡ SW‹=dà@ ƒ=t)A uè!íÿÿj èoëÿÿhÿ 轶ÿÿYY¡„*A ƒøu…öt‹Æë3À@Pë ƒøu VèSÿÿÿY…Àu…öuFƒÆƒæðVj ÿ5t)A ÿ׋؅Ûu.j ^9€)A tÿuèBôÿÿY…Àt‹ué{ÿÿÿèêËÿÿ‰0èãËÿÿ‰0_‹Ã[ëVèôÿÿYèÏËÿÿÇ 3À^]Ãjh°÷@ èÌÿÿ‹]…Ûuÿu èÿÿÿYéÌ ‹u …öu SèÏÿÿYé· ƒ=„*A …“ 3ÿ‰}äƒþà‡Š jèÓÿÿY‰}üSè6 Y‰Eà;Ç„ž ;5p*A wIVSPè ƒÄ …Àt‰]äë5Vèç Y‰Eä;Çt'‹CüH;Ær‹ÆPSÿuäè:$ Sèæ ‰EàSPè ƒÄ9}äuH;÷u3öF‰u ƒÆƒæð‰u VWÿ5t)A ÿdà@ ‰Eä;Çt ‹CüH;Ær‹ÆPSÿuäèæ# Sÿuàè¿ ƒÄÇEüþÿÿÿè. ƒ}à u1…öuFƒÆƒæð‰u VSj ÿ5t)A ÿÔà@ ‹øë‹u ‹]jèHÑÿÿYË}ä…ÿ…¿ 9=€)A t,Vè¤òÿÿY…À…ÒþÿÿèPÊÿÿ9}àul‹ðÿ\à@ PèûÉÿÿY‰ë_…ÿ…ƒ è+Êÿÿ9}àthÇ ëq…öuFVSj ÿ5t)A ÿÔà@ ‹ø…ÿuV9€)A t4Vè;òÿÿY…Àt ƒþàvÍVè+òÿÿYèßÉÿÿÇ 3ÀècÊÿÿÃèÌÉÿÿé|ÿÿÿ…ÿuè¾Éÿÿ‹ðÿ\à@ PènÉÿÿ‰Y‹ÇëÒ‹ÿU‹ì‹M S3Û;Ëv(jà3ÒX÷ñ;Es è‰ÉÿÿSSSSSÇ èÉÿÿƒÄ3ÀëA¯MVW‹ñ9]t ÿuèÈ) Y‹ØVÿuèýÿÿ‹øYY…ÿt;Þs+óVj ßSèȬÿÿƒÄ ‹Ç_^[]ËÿU‹ì‹
h*A ¡l*A kÉÈë‹U+P ú r ƒÀ;Árë3À]ËÿU‹ìƒì‹M‹AV‹u W‹þ+y ƒÆüÁï‹ÏiÉ ŒD ‰Mð‹I‰MüöÁ…Ó S 1‹‰Uô‹Vü‰Uø‹Uô‰] öÂutÁúJƒú?vj?Z‹K;KuB» €ƒú s‹ÊÓëL÷Ó!\¸Dþ u#‹M!ë JàÓëL÷Ó!œ¸Ä þ u‹M!Y‹] ‹S‹[‹MüMô‰Z‹U ‹Z‹R‰S‰Mü‹ÑÁúJƒú?vj?Z‹]øƒã‰]ô… +uø‹]øÁûj?‰u K^;Þv‹ÞMø‹ÑÁúJ‰Mü;Öv‹Ö;Út^‹M ‹q;qu;¾ €ƒû s‹ËÓî÷Ö!t¸DþLu!‹M!1ëKàÓî÷Ö!´¸Ä þLu‹M!q‹M ‹q‹I‰N‹M ‹q‹I‰N‹u ë‹]ƒ}ô u;Ú„€ ‹Mð Ñ‹Y‰N‰^‰q‹N‰q‹N;Nu`ŠLˆMþÁˆLƒú s%€} u‹Ê» €Óë‹M » €‹ÊÓëD¸D ë)€} uJà» €Óë‹M YJຠ€Óê„¸Ä ‹Eü‰‰D0ü‹Eðÿ…ó ¡|)A …À„Ø ‹
|*A ‹5¼à@ h @ ÁáH » € SQÿÖ‹
|*A ¡|)A º €Óê P¡|)A ‹@‹
|*A ƒ¤ˆÄ ¡|)A ‹@þHC¡|)A ‹H€yC u ƒ`þ¡|)A ƒxÿueSj ÿp ÿÖ¡|)A ÿpj ÿ5t)A ÿ`à@ ‹
h*A ¡|)A kÉ‹l*A +ÈLìQHQPèí+ ‹EƒÄ ÿ
h*A ;|)A vƒm¡l*A £t*A ‹E£|)A ‰=|*A [_^Éáx*A V‹5h*A W3ÿ;ðu4ƒÀkÀPÿ5l*A Wÿ5t)A ÿÔà@ ;Çu3Àëxƒx*A ‹5h*A £l*A kö5l*A hÄA jÿ5t)A ÿdà@ ‰F;ÇtÇjh h WÿØà@ ‰F ;ÇuÿvWÿ5t)A ÿ`à@ 뛃Nÿ‰>‰~ÿh*A ‹Fƒÿ‹Æ_^ËÿU‹ìQQ‹M‹ASV‹qW3ÛëÀC…À}ù‹ÃiÀ „0D j?‰EøZ‰@‰@ƒÀJuôj‹ûh Áçy h € WÿØà@ …ÀuƒÈÿé — p ‰Uü;úwC‹Ê+ÏÁé GAƒHøÿƒˆì ÿü ‰üïÿÿÇ@üð ‰PÇ€è ð IuË‹Uü‹Eøø O ‰H‰AJ ‰H‰AƒdžD 3ÿG‰¼žÄ ŠFCŠÈþÁ„À‹EˆNCu xº €‹ËÓê÷Ò!P‹Ã_^[ÉËÿU‹ìƒì ‹M‹ASV‹uW‹} ‹×+Q ƒÆÁê‹ÊiÉ ŒD ‰Mô‹OüƒæðI;ñ|9ü‹ ‰M‰]üŽU öÃ…E Ù;ó; ‹MüÁùI‰Møƒù?vj?Y‰Mø‹_;_uC» €ƒù sÓë‹MøL÷Ó!\Dþ u&‹M!ë ƒÁàÓë‹MøL÷Ó!œÄ þ u‹M!Y‹O‹_‰Y‹O‹‰y‹M+ÎMüƒ}ü Ž¥ ‹}ü‹M ÁÿOL1üƒÿ?vj?_‹]ô û‰]‹[‰Y‹]‰Y‰K‹Y‰K‹Y;YuWŠLˆMþÁˆLƒÿ s €} u‹Ï» €Óë‹M DD‹Ïë €} uOà» €Óë‹M Y„Ä Oຠ€Óê ‹U ‹MüD2ü‰‰Lüë‹U F‰Bü‰D2øé< 3Àé8 / ‹] )uN‰Kü\3ü‹uÁþN‰] ‰Küƒþ?vj?^öEü…€ ‹uüÁþNƒþ?vj?^‹O;OuB» €ƒþ s‹ÎÓët÷Ó!\Dþu#‹M!ë NàÓëL÷Ó!œÄ þ u‹M!Y‹] ‹O‹w‰q‹w‹O‰q‹uuü‰uÁþNƒþ?vj?^‹Mô ñ‹y‰K‰{‰Y‹K‰Y‹K;KuWŠLˆMþÁˆLƒþ s €} u‹Î¿ €Óï‹M 9DD‹Îë €} uNà¿ €Óï‹M y„Ä Nຠ€Óê ‹E‰‰Dü3À@_^[ÉËÿU‹ìƒì¡h*A ‹MkÀl*A ƒÁƒáð‰MðÁùSIƒù VW} ƒÎÿÓîƒMøÿë
ƒÁàƒÊÿ3öÓê‰Uø‹
t*A ‹Ùë‹S‹;#Uø#þ ×u
ƒÃ‰];Ørè;Øu‹ l*A ë‹S‹;#Uø#þ ×u
ƒÃ‰];Ùrè;Ùu[ë ƒ{ u
ƒÃ‰];Ørð;Øu1‹ l*A ë ƒ{ u
ƒÃ‰];Ùrð;Ùuè úÿÿ‹Ø‰]…Ûu3Àé Sè:ûÿÿY‹K‰‹Cƒ8ÿtå‰ t*A ‹C‹‰Uüƒúÿt‹ŒÄ ‹|D#Mø#þ Ïu)ƒeü ‹Ä HD‹9#Uø#þ ×uÿEü‹‘„ ƒÁëç‹Uü‹ÊiÉ ŒD ‰Mô‹LD3ÿ#Îu‹ŒÄ #Møj _ëÉG…É}ù‹Mô‹Tù‹
+Mð‹ñÁþNƒþ?‰Mø~j?^;÷„ ‹J;Ju\ƒÿ » €}&‹ÏÓë‹Mü|8÷Ó‰]ì#\ˆD‰\ˆDþu3‹Mì‹]! ë,OàÓë‹MüŒˆÄ |8÷Ó!þ‰]ìu ‹]‹Mì!Kë‹]ƒ}ø ‹J‹z‰y‹J‹z‰y„ ‹Mô ñ‹y‰J‰z‰Q‹J‰Q‹J;Ju^ŠLˆM þÁƒþ ˆL}#€} u ¿ €‹ÎÓï ;‹Î¿ €Óï‹Mü |ˆDë)€} u
Nà¿ €Óï {‹Mü¼ˆÄ Nྠ€Óî 7‹Mø…Ét ‰
‰Lüë‹Mø‹uðÑN‰
‰L2ü‹uô‹y‰>…Éu; |)A u‹Mü;
|*A uƒ%|)A ‹Mü‰B_^[ÉËÿU‹ìSV‹uW3ÿƒËÿ;÷u èQ¾ÿÿWWWWWÇ èÙ½ÿÿƒÄ ÃëBöF ƒt7VèÈÂÿÿV‹ØèÄ( VèO¼ÿÿPèë' ƒÄ…À}ƒËÿë‹F ;Çt
PènÁÿÿY‰~ ‰~ ‹Ã_^[]Ãj hÐ÷@ è3¾ÿÿƒMäÿ3À‹u3ÿ;÷•À;Çu èνÿÿÇ WWWWWèV½ÿÿƒÄƒÈÿë öF @t ‰~ ‹Eäè6¾ÿÿÃVè ÿÿY‰}üVè*ÿÿÿY‰EäÇEüþÿÿÿè ëÕ‹uVèY ÿÿYËÿU‹ì¸ä è8* ¡€A 3ʼnEü‹E V3ö‰…4åÿÿ‰µ8åÿÿ‰µ0åÿÿ9uu3Àéé ;Æu'èD½ÿÿ‰0è*½ÿÿVVVVVÇ è²¼ÿÿƒÄƒÈÿé¾ SW‹}‹ÇÁø4… *A ‹ƒç ÁçÇŠX$ÛÐû‰µ(åÿÿˆ'åÿÿ€ût€ûu0‹M÷ÑöÁu&èÛ¼ÿÿ3ö‰0迼ÿÿVVVVVÇ èG¼ÿÿƒÄéC ö@ tjj j ÿuèc ƒÄÿuèÕêÿÿY…À„ ‹öD€„ è‹Öÿÿ‹@l3É9H… åÿÿ”ÁP‹ÿ4‰ åÿÿÿàà@ …À„` 3É9 åÿÿt„Û„P ÿÜà@ ‹4åÿÿ‰… åÿÿ3À‰…<åÿÿ9E†B ‰…DåÿÿŠ…'åÿÿ„À…g Š ‹µ(åÿÿ3À€ù
”À‰… åÿÿ‹Çƒx8 tŠP4ˆUôˆMõƒ`8 jEôPëK¾ÁPè×ìÿÿY…Àt:‹4åÿÿ+ËM3À@;Ȇ¥ j…@åÿÿSPè<( ƒÄ ƒøÿ„± Cÿ…DåÿÿëjS…@åÿÿPè( ƒÄ ƒøÿ„ 3ÀPPjMôQj@åÿÿQPÿµ åÿÿCÿ…Dåÿÿÿ°à@ ‹ð…ö„\ j …<åÿÿPVEôP‹…(åÿÿ‹ ÿ4ÿ˜à@ …À„) ‹…Dåÿÿ‹0åÿÿÁ9µ<åÿÿ‰…8åÿÿŒ ƒ½ åÿÿ „Í j …<åÿÿPjEôP‹…(åÿÿ‹ ÆEô
ÿ4ÿ˜à@ …À„Ð ƒ½<åÿÿŒÏ ÿ…0åÿÿÿ…8åÿÿéƒ <t<u!·33Éfƒþ
”ÁCCƒ…Dåÿÿ‰µ@åÿÿ‰ åÿÿ<t<uRÿµ@åÿÿè%% Yf;…@åÿÿ…h ƒ…8åÿÿƒ½ åÿÿ t)j
XP‰…@åÿÿèø$ Yf;…@åÿÿ…; ÿ…8åÿÿÿ…0åÿÿ‹E9…Dåÿÿ‚ùýÿÿé' ‹Šÿ…8åÿÿˆT4‹‰D8é 3É‹Çö@€„¿ ‹…4åÿÿ‰@åÿÿ„Û…Ê ‰…<åÿÿ9M† 답(åÿÿ‹<åÿÿƒ¥Dåÿÿ +4åÿÿ…Håÿÿ;Ms9‹•<åÿÿÿ…<åÿÿŠA€ú
uÿ…0åÿÿÆ
@ÿ…Dåÿÿˆ@ÿ…Dåÿÿ½Dåÿÿÿ r‹؅Håÿÿ+Øj …,åÿÿPS…HåÿÿP‹ÿ4ÿ˜à@ …À„B ‹…,åÿÿ…8åÿÿ;ÃŒ: ‹…<åÿÿ+…4åÿÿ;E‚Lÿÿÿé ‰…Dåÿÿ€û…Ñ 9M†M 답(åÿÿ‹Dåÿÿƒ¥<åÿÿ +4åÿÿ…Håÿÿ;MsF‹•Dåÿÿƒ…Dåÿÿ·AAfƒú
uƒ…0åÿÿj
[f‰@@ƒ…<åÿÿƒ…<åÿÿf‰@@½<åÿÿþ rµ‹Ø…Håÿÿ+Øj …,åÿÿPS…HåÿÿP‹ÿ4ÿ˜à@ …À„b ‹…,åÿÿ…8åÿÿ;ÃŒZ ‹…Dåÿÿ+…4åÿÿ;E‚?ÿÿÿé@ 9M†| ‹Dåÿÿƒ¥<åÿÿ +4åÿÿj…Hùÿÿ^;Ms<‹•Dåÿÿ·µDåÿÿÎfƒú
uj
[f‰Æµ<åÿÿµ<åÿÿf‰Æ½<åÿÿ¨ r¿3öVVhU
ðëÿÿQHùÿÿ+Á™+ÂÑøP‹ÁPVhéý ÿ°à@ ‹Ø;Þ„— j …,åÿÿP‹Ã+ÆP„5ðëÿÿP‹…(åÿÿ‹ ÿ4ÿ˜à@ …Àt µ,åÿÿ;ÞËë ÿ\à@ ‰…@åÿÿ;Þ\‹…Dåÿÿ+…4åÿÿ‰…8åÿÿ;E‚
ÿÿÿë?j ,åÿÿQÿuÿµ4åÿÿÿ0ÿ˜à@ …Àt‹…,åÿÿƒ¥@åÿÿ ‰…8åÿÿë ÿ\à@ ‰…@åÿÿƒ½8åÿÿ ulƒ½@åÿÿ t-j^9µ@åÿÿu貶ÿÿÇ èº¶ÿÿ‰0ë?ÿµ@åÿÿ辶ÿÿYë1‹µ(åÿÿ‹öD@t‹…4åÿÿ€8u3Àë$èr¶ÿÿÇ èz¶ÿÿƒ ƒÈÿë ‹…8åÿÿ+…0åÿÿ_[‹Mü3Í^èØÿÿÉÃjhð÷@ 脶ÿÿ‹Eƒøþuè>¶ÿÿƒ è#¶ÿÿÇ ƒÈÿé 3ÿ;Ç|;*A r!è¶ÿÿ‰8èûµÿÿÇ WWWWW胵ÿÿƒÄëÉ‹ÈÁù *A ‹ðƒæ Áæ‹ ¾L1ƒát¿Pè9$ Y‰}ü‹öD0tÿuÿu ÿuè.øÿÿƒÄ ‰Eäë蘵ÿÿÇ è µÿÿ‰8ƒMäÿÇEüþÿÿÿè ‹Eäè¶ÿÿÃÿuèƒ$ YÃjhø@ 訵ÿÿ‹EƒøþuèOµÿÿÇ ƒÈÿéª 3Û;Ã|;*A rè.µÿÿÇ SSSSS趴ÿÿƒÄëЋÈÁù< *A ‹ðƒæ Á拾LƒátÆPèl# Y‰]ü‹öDt1ÿuèà" YPÿäà@ …Àu ÿ\à@ ‰Eäë‰]ä9]ätèÍ´ÿÿ‹Mä‰è°´ÿÿÇ ƒMäÿÇEüþÿÿÿè ‹Eäè#µÿÿÃÿuè¢# YËÿU‹ìƒìS3Û9]u èr´ÿÿSSSSSÇ èú³ÿÿƒÄ3ÀëjV‹u ;óuèN´ÿÿSSSSSÇ èÖ³ÿÿƒÄë9ur3Àë>ÿuMðèÆ›ÿÿ‹MôFÿ9Yt H9Ew
¶öD
uð‹Î+ȃá+ñN‹Æ8]üt‹Møƒapý^[ÉËÿU‹ìj ÿu ÿuèUÿÿÿƒÄ ]ËÿU‹ìƒìS3ÛV‹u9]u;óu9] u3Àéç ;ót9] w 襳ÿÿj^SSSSS‰0è.³ÿÿƒÄ‹ÆéÀ 9]uˆ ëÉW‹};ûu ˆ èt³ÿÿj^SSSSS‰0èý²ÿÿƒÄé( ÿuMìèóšÿÿ‹Eð9XuÿuWÿu Vè£
ƒÄéL ƒ}ÿ‹U ‹ÆuŠˆ@G:Ët Juó늈@G:ËtJtÿMuî9]uˆ@;Ó…È 8 tƒ}u5xÿ‰}ü;þr EìP‹Eü¶ PèоÿÿYY…ÀtÿMü9uüsâ‹Ç+Eü¨…à ƒ}ÿuZ‹E ƒøv:|þ‰};þr!EìP‹E¶ P茾ÿÿYY…ÀtÿM9usâ‹E ‹Ï+MöÁtˆ ëˆ\ÿ8]øt‹Eôƒ`pýjPXé ˆ èS²ÿÿj"^SSSSS‰0èܱÿÿƒÄ8]øt‹Eôƒ`pý‹Æëd‹È+΃ù|Mxþ‰};þr EìP‹E¶ Pè ¾ÿÿYY…ÀtÿM9usâ‹Ç+E¨t ˆ èð±ÿÿ‹Èj*X‰8]øt‹Môƒapýë8]øt‹Eôƒ`pý3À_^[ÉËÿU‹ì‹E…Àtƒè8ÝÝ uPèµÿÿY]ËÿU‹ìƒì¡€A 3ʼnEüSV3ÛW‹ñ9 „)A u8SS3ÿGWhdê@ h Sÿðà@ …Àt‰=„)A ëÿ\à@ ƒøxu
Ç„)A 9]~"‹M‹EI8t@;ËuöƒÉÿ‹E+ÁH;E}@‰E¡„)A ƒø„¬ ;Ĥ ƒø…Ì ‰]ø9] u‹‹@‰E ‹5ìà@ 3À9]$SSÿu•ÀÿuÅ Pÿu ÿÖ‹ø;û„ ~Cjà3ÒX÷÷ƒør7D?= wèŽ# ‹Ä;Ãt Ç ÌÌ ëPè äÿÿY;Ãt Ç ÝÝ ƒÀ‰Eôë‰]ô9]ô„> Wÿuôÿuÿujÿu ÿÖ…À„ã ‹5ðà@ SSWÿuôÿu ÿuÿ֋ȉMø;Ë„Â ÷E t)9] „° ;M § ÿu ÿuWÿuôÿu ÿuÿÖé ;Ë~Ejà3ÒX÷ñƒør9D = wèÏ" ‹ô;ótjÇÌÌ ƒÆëPèJãÿÿY;Ãt Ç ÝÝ ƒÀ‹ðë3ö;ótAÿuøVWÿuôÿu ÿuÿðà@ …Àt"SS9] uSSëÿu ÿuÿuøVSÿu ÿ°à@ ‰EøVè¸ýÿÿYÿuôè¯ýÿÿ‹EøYéY ‰]ô‰]ð9]u‹‹@‰E9] u‹‹@‰E ÿuè Y‰Eìƒøÿu3Àé! ;E „Û SSMQÿuPÿu è> ƒÄ‰Eô;ÃtÔ‹5èà@ SSÿuPÿu ÿuÿÖ‰Eø;Ãu3öé· ~=ƒøàw8ƒÀ= wè¹! ‹ü;ûtÝÇÌÌ ƒÇëPè4âÿÿY;Ãt Ç ÝÝ ƒÀ‹øë3ÿ;ût´ÿuøSWè0’ÿÿƒÄ ÿuøWÿuÿuôÿu ÿuÿÖ‰Eø;Ãu3öë%ÿu EøÿuPWÿu ÿuìè ‹ð‰uðƒÄ÷Þö#uøWèüÿÿYëÿu ÿuÿuÿuÿu ÿuÿèà@ ‹ð9]ôt ÿuô蘱ÿÿY‹Eð;Ãt 9EtPè…±ÿÿY‹Æeà_^[‹Mü3Íè—•ÿÿÉËÿU‹ìƒìÿuMðè‘•ÿÿÿu(Mðÿu$ÿu ÿu ÿuÿuÿuÿu è(üÿÿƒÄ €}ü t‹MøƒapýÉËÿU‹ìQQ¡€A 3ʼnEü¡ˆ)A SV3ÛW‹ù;Ãu:EøP3öFVhdê@ Vÿøà@ …Àt‰5ˆ)A ë4ÿ\à@ ƒøxu
jX£ˆ)A 롈)A ƒø„Ï ;Ã„Ç ƒø…è ‰]ø9]u‹‹@‰E‹5ìà@ 3À9] SSÿu•Àÿu Å PÿuÿÖ‹ø;û„« ~<ÿðÿÿw4D?= wèÒ ‹Ä;Ãt Ç ÌÌ ëPèPàÿÿY;Ãt Ç ÝÝ ƒÀ‹Ø…Ûti?Pj SèNÿÿƒÄ WSÿuÿu jÿuÿÖ…ÀtÿuPSÿuÿøà@ ‰EøSèÉúÿÿ‹EøYëu3ö9] u‹‹@‰E 9]u‹‹@‰Eÿu èA Yƒøÿu3ÀëG;Et SSMQÿu Pÿuèi ‹ðƒÄ;ót܉u ÿuÿuÿu ÿuÿu ÿôà@ ‹ø;ótV膯ÿÿY‹Çeì_^[‹Mü3Í蘓ÿÿÉËÿU‹ìƒìÿuMðè’“ÿÿÿu$Mðÿu ÿu ÿuÿuÿuÿu èþÿÿƒÄ €}ü t‹MøƒapýÉËÿU‹ìV‹u…ö„ ÿvè¯ÿÿÿvè¯ÿÿÿv è¯ÿÿÿvèþ®ÿÿÿvèö®ÿÿÿvèî®ÿÿÿ6èç®ÿÿÿv èß®ÿÿÿv$è×®ÿÿÿv(èÏ®ÿÿÿv,èÇ®ÿÿÿv0è¿®ÿÿÿv4è·®ÿÿÿv 诮ÿÿÿv8觮ÿÿÿv<蟮ÿÿƒÄ@ÿv@è”®ÿÿÿvD茮ÿÿÿvHè„®ÿÿÿvLè|®ÿÿÿvPèt®ÿÿÿvTèl®ÿÿÿvXèd®ÿÿÿv\è\®ÿÿÿv`èT®ÿÿÿvdèL®ÿÿÿvhèD®ÿÿÿvlè<®ÿÿÿvpè4®ÿÿÿvtè,®ÿÿÿvxè$®ÿÿÿv|è ®ÿÿƒÄ@ÿ¶€ è®ÿÿÿ¶„ è®ÿÿÿ¶ˆ èøÿÿÿ¶Œ èíÿÿÿ¶ èâÿÿÿ¶” è×ÿÿÿ¶˜ èÌÿÿÿ¶œ èÁÿÿÿ¶ è¶ÿÿÿ¶¤ è«ÿÿÿ¶¨ è ÿÿƒÄ,^]ËÿU‹ìV‹u…öt5‹;H A tPè}ÿÿY‹F;L A tPèkÿÿY‹v;5P A tVèYÿÿY^]ËÿU‹ìV‹u…öt~‹F ;T A tPè7ÿÿY‹F;X A tPè%ÿÿY‹F;\ A tPèÿÿY‹F;` A tPèÿÿY‹F ;d A tPèï¬ÿÿY‹F ;h A tPèݬÿÿY‹v$;5l A tVèˬÿÿY^]ËÿU‹ì‹ES3ÛVW;Ãt‹} ;ûwè=©ÿÿj^‰0SSSSSèƨÿÿƒÄ‹Æë<‹u;óuˆëÚ‹Ð8tBOuø;ût
BF:ËtOuó;ûuˆèö¨ÿÿj"Y‰‹ñëµ3À_^[]ÃÌÌÌÌÌÌU‹ìV3ÀPPPPPPPP‹U I Š
Àt ƒÂ«$ëñ‹uƒÉÿI ƒÁŠ
Àt ƒÆ£$sî‹ÁƒÄ ^ÉËÿU‹ìSV‹u3ÛW9]u;óu9] u3À_^[]Ã;ót‹} ;ûwèh¨ÿÿj^‰0SSSSSèñ§ÿÿƒÄ‹ÆëÕ9]uˆ ëÊ‹U;Óuˆ ëу}ÿ‹ÆuŠ
ˆ@B:Ët OuóëŠ
ˆ@B:ËtOtÿMuî9]uˆ;ûu‹ƒ}ÿu‹E jPˆ\ÿXéxÿÿÿˆ èî§ÿÿj"Y‰‹ñë‚‹ÿU‹ì‹MS3ÛVW;Ët‹} ;ûwèȧÿÿj^‰0SSSSSèQ§ÿÿƒÄ‹Æë0‹u;óuˆëÚ‹ÑŠˆBF:ÃtOuó;ûuˆè§ÿÿj"Y‰‹ñëÁ3À_^[]ÃÌÌÌÌÌÌÌÌÌÌÌÌÌ‹T$‹L$÷ u<‹:u.
Àt&:au%
ät Áè:Au
Àt:auƒÁƒÂ
äuÒ‹ÿ3ÀÃÀÑàƒÀÃ÷ tŠƒÂ:uçƒÁ
ÀtÜ÷ t¤f‹ƒÂ:uÎ
ÀtÆ:auÅ
ät½ƒÁëˆÌÌÌÌÌÌÌÌU‹ìWV‹u ‹M‹}‹Á‹ÑÆ;þv;ø‚¤ ù r ƒ=ˆ*A tWVƒçƒæ;þ^_u^_]é, ÷Ç uÁéƒâƒùr*ó¥ÿ$•ä‘@ ‹Çº ƒér ƒàÈÿ$…ø@ ÿ$ô‘@ ÿ$x‘@ ‘@ 4‘@ X‘@ #ÑŠˆŠFˆGŠFÁéˆGƒÆƒÇƒùrÌó¥ÿ$•ä‘@ I #ÑŠˆŠFÁéˆGƒÆƒÇƒùr¦ó¥ÿ$•ä‘@ #ÑŠˆƒÆÁéƒÇƒùrˆó¥ÿ$•ä‘@ I Û‘@ È‘@ À‘@ ¸‘@ °‘@ ¨‘@ ‘@ ˜‘@ ‹DŽä‰Dä‹DŽè‰Dè‹DŽì‰Dì‹DŽð‰Dð‹DŽô‰Dô‹DŽø‰Dø‹DŽü‰Dü ðøÿ$•ä‘@ ‹ÿô‘@ ü‘@ ’@ ’@ ‹E^_Éʈ‹E^_ÉʈŠFˆG‹E^_ÉÃI ŠˆŠFˆGŠFˆG‹E^_ÉÃt1ü|9ü÷Ç u$Áéƒâƒùr
ýó¥üÿ$•€“@ ‹ÿ÷Ùÿ$0“@ I ‹Çº ƒùr ƒà+Èÿ$…„’@ ÿ$€“@ ”’@ ¸’@ à’@ ŠF#шGƒîÁéƒïƒùr²ýó¥üÿ$•€“@ I ŠF#шGŠFÁéˆGƒîƒïƒùrˆýó¥üÿ$•€“@ ŠF#шGŠFˆGŠFÁéˆGƒîƒïƒù‚Vÿÿÿýó¥üÿ$•€“@ I 4“@ <“@ D“@ L“@ T“@ \“@ d“@ w“@ ‹DŽ ‰D ‹DŽ‰D‹DŽ‰D‹DŽ‰D‹DŽ ‰D ‹DŽ‰D‹DŽ‰D ðøÿ$•€“@ ‹ÿ“@ ˜“@ ¨“@ ¼“@ ‹E^_ÉÊFˆG‹E^_ÉÃI ŠFˆGŠFˆG‹E^_ÉÊFˆGŠFˆGŠFˆG‹E^_ÉÃÌÌÌÌÌÌÌÌÌÌÌU‹ìV3ÀPPPPPPPP‹U I Š
Àt ƒÂ«$ëñ‹u‹ÿŠ
Àt ƒÆ£$sñFÿƒÄ ^ÉËÿU‹ìQQ‹E V‹u‰Eø‹EWV‰Eüè ƒÏÿY;Çuè£ÿÿÇ ‹Ç‹×ëJÿuMüQÿuøPÿ á@ ‰Eø;Çuÿ\à@ …Àt Pè÷¢ÿÿYëÏ‹ÆÁø‹… *A ƒæ ÁæD0€ ý‹Eø‹Uü_^ÉÃjh0ø@ èë¢ÿÿƒÎÿ‰u܉uà‹Eƒøþu 蜢ÿÿƒ è¢ÿÿÇ ‹Æ‹ÖéÐ 3ÿ;Ç|;*A r!èr¢ÿÿ‰8èX¢ÿÿÇ WWWWWèà¡ÿÿƒÄëÈ‹ÈÁù *A ‹ðƒæ Áæ‹ ¾L1ƒáu&è1¢ÿÿ‰8è¢ÿÿÇ WWWWW蟡ÿÿƒÄƒÊÿ‹Âë[Pèp Y‰}ü‹öD0t ÿuÿuÿu ÿuè©þÿÿƒÄ‰E܉UàëèÉ¡ÿÿÇ èÑ¡ÿÿ‰8ƒMÜÿƒMàÿÇEüþÿÿÿè ‹EÜ‹Uàè.¢ÿÿÃÿuè YËÿU‹ìÿ A h è¹£ÿÿY‹M‰A…Àt
ƒI ÇA ëƒI A‰AÇA ‹Aƒa ‰]ËÿU‹ìƒìSVWè¹ÿÿƒeü ƒ=)A ‹Ø…Ž h ô@ ÿœà@ ‹ø…ÿ„* ‹5(à@ hôó@ WÿÖ…À„ PèL¸ÿÿÇ$äó@ W£)A ÿÖPè7¸ÿÿÇ$Ðó@ W£”)A ÿÖPè"¸ÿÿÇ$´ó@ W£˜)A ÿÖPè
¸ÿÿY£ )A …Àthœó@ WÿÖPèõ·ÿÿY£œ)A ¡œ)A ;ÃtO9 )A tGPèS¸ÿÿÿ5 )A ‹ðèF¸ÿÿYY‹ø…öt,…ÿt(ÿÖ…ÀtMøQj MìQjPÿ×…ÀtöEôu M ë9¡”)A ;Ãt0Pè¸ÿÿY…Àt%ÿЉEü…Àt ¡˜)A ;ÃtPèæ·ÿÿY…ÀtÿuüÿЉEüÿ5)A èηÿÿY…Àtÿuÿu ÿuÿuüÿÐë3À_^[ÉËÿU‹ì‹MV3ö;Î| ƒù~ ƒùu¡D A ë(¡D A ‰
D A ë讟ÿÿVVVVVÇ è6ŸÿÿƒÄƒÈÿ^]ÃjhPø@ èÕŸÿÿ3À‹]3ÿ;ß•À;Çu ètŸÿÿÇ WWWWWèüžÿÿƒÄƒÈÿëSƒ=„*A u8jèõ¦ÿÿY‰}üSèÖÿÿY‰Eà;Çt ‹süƒî ‰uäë‹uäÇEüþÿÿÿè% 9}àuSWÿ5t)A ÿá@ ‹ð‹Æè•ŸÿÿÃ3ÿ‹]‹uäjèÃ¥ÿÿYÃjèÿˆÿÿYËÿU‹ìì( ¡€A 3ʼnEüö A Vtj
èÓ½ÿÿYèªÄÿÿ…Àtjè¬ÄÿÿYö A „Ê ‰…àýÿÿ‰Üýÿÿ‰•Øýÿÿ‰Ôýÿÿ‰µÐýÿÿ‰½ÌýÿÿfŒ•øýÿÿfŒìýÿÿfŒÈýÿÿfŒ…ÄýÿÿfŒ¥ÀýÿÿfŒ¼ýÿÿœ…ðýÿÿ‹uE‰…ôýÿÿÇ…0ýÿÿ ‰µèýÿÿ‹@üjP‰…äýÿÿ…Øüÿÿj Pèªÿÿ…ØüÿÿƒÄ ‰…(ýÿÿ…0ýÿÿj Ç…Øüÿÿ @‰µäüÿÿ‰…,ýÿÿÿTà@ …(ýÿÿPÿPà@ jèmŠÿÿÌÌÌU‹ìSVWUj j h˜™@ ÿuèV" ]_^[‹å]ËL$÷A ¸ t2‹D$‹Hü3Èè"…ÿÿU‹h‹P(R‹P$Rè ƒÄ]‹D$‹T$‰¸ ÃSVW‹D$UPjþh ™@ dÿ5 ¡€A 3ÄPD$d£ ‹D$(‹X‹p ƒþÿt:ƒ|$,ÿt;t$,v-4v‹ ³‰L$ ‰H ƒ|³ uh ‹D³èI ‹D³è_ ë·‹L$d‰
ƒÄ_^[Ã3Àd‹
y ™@ u‹Q ‹R 9Qu¸ ÃSQ»” A ë SQ»” A ‹L$ ‰K‰C‰k UQPXY]Y[ ÿÐËÿU‹ìƒìVWÿuMìè%„ÿÿ‹E‹u 3ÿ;Çt‰0;÷u,èmœÿÿWWWWWÇ èõ›ÿÿƒÄ€}ø t‹Eôƒ`pý3ÀéØ 9}t ƒ}|Ƀ}$ËMìSŠ ‰}ü~ƒ¹¬ ~EìP¶ÃjPè¹ÿÿ‹MìƒÄ ë‹‘È ¶Ã·Bƒà…ÀtŠ GëÇ€û-uƒMë€û+uŠ G‹E…ÀŒK ƒø„B ƒø$9 …Àu*€û0t ÇE
ë4Š·É¶ÒÁá Ê9M u Hë ·Ñ9U t
@f¶·Éf;ËuÇ·É9M u8]üt‹Møƒapýë8]üt‹Eøƒ`pý3À^[ÉËÿU‹ìj ÿu ÿuè2ÿÿÿƒÄ ]ÃÌÌÌBÿ[ä$ d$ 3ÀŠD$S‹ØÁà‹T$÷ tŠ
ƒÂ:ËtÏ„ÉtQ÷ uë ØW‹ÃÁãV Ø‹
¿ÿþþ~‹Á‹÷3Ëðùƒñÿƒðÿ3Ï3ƃÂá u % tÓ% uæ €uÄ^_[3ÀËBü:Ãt6„Àtï:ãt'„ätçÁè:Ãt„ÀtÜ:ãt„ätÔë–^_Bÿ[ÃBþ^_[ÃBý^_[ÃBü^_[Ãÿ%Ðà@ ‹ÿU‹ì‹US3Û;Óu èH{ÿÿSSSSSÇ èÐzÿÿƒÄƒÈÿë 8tß‹M ;ËtØ‹;ÃtÒ8tÎSQRè ƒÄ []ËÿU‹ìƒì ‹UV‹ujþX‰Eì‰Uä;ðuèÿzÿÿƒ èäzÿÿÇ ƒÈÿéˆ S3Û;ó|;5*A r'èÕzÿÿ‰è»zÿÿSSSSSÇ èCzÿÿƒÄƒÈÿéQ ‹ÆÁøW<… *A ‹ƒæ ÁæÆŠHöÁuèzÿÿ‰èuzÿÿÇ ëjúÿÿÿwP‰]ð;Ó„ öÁ…ÿ 9] t7Š@$ÀÐøˆEþ¾ÀHjYt Hu‹Â÷Шtƒâþ‰U‹E ‰Eôé ‹Â÷Шu!è#zÿÿ‰è zÿÿÇ SSSSSè‘yÿÿƒÄë4‹ÂÑè‰M;Ár‰Eÿuè|ÿÿY‰Eô;Ãu èÑyÿÿÇ èÙyÿÿÇ ƒÈÿéh jSSÿuè|Öÿÿ‹‰D(‹EôƒÄ‰T,‹ÎöAHttŠI€ù
tl9]tgˆ‹@ÿMÇEð ÆD
8]þtN‹ŠL%€ù
tC9]t>ˆ‹@ÿM€}þÇEð ÆD%
u$‹ŠL&€ù
t9]tˆ‹@ÿMÇEð ÆD&
SMèQÿuP‹ÿ4ÿ,á@ …À„{ ‹Mè;ËŒp ;M‡g ‹MðDö €„æ €}þ„ ;Ët
‹Mô€9
u€ë€ û‹]ô‹EðÉ]‰Eð;؃Р‹MŠ<„® <
t ˆCA‰Mé ‹EðH;ÈsA€8
u
AA‰MÆ
ëu‰EëmÿEj EèPjEÿP‹ÿ4ÿ,á@ …Àu
ÿ\à@ …ÀuEƒ}è t?‹öDHt€}ÿ
t¹Æ
‹ŠMÿˆLë%;]ôu€}ÿ
t jjÿjÿÿuèØÔÿÿƒÄ€}ÿ
tÆ
C‹Eð9E‚Gÿÿÿë‹Dö @u€ëŠˆC‹Ã+Eô€}þ‰Eð…Ð …À„È KŠ „ÉxCé† 3À@¶Éëƒø;]ôrK¶ @€¹à A t芶ʾ‰à A …Éu
è|wÿÿÇ * ëzA;ÈuØë@‹ÎöAHt$CƒøˆQ| Š‹ˆT%Cƒøu Š‹ˆT&C+Øë÷Ø™jRPÿuèþÓÿÿƒÄ‹Eä+]ôÑèPÿu Sÿuôj héý ÿìà@ ‰Eð…Àu4ÿ\à@ Pè!wÿÿYƒMìÿ‹Eô;E tPèUzÿÿY‹Eìƒøþ…‹ ‹Eðéƒ ‹Eð‹3É;ÕÁÀ‰Eð‰L0ëÆ;Ët‹Môfƒ9
u€ë€ û‹]ô‹EðÉ]‰Eð;؃ÿ ‹E·fƒù„× fƒù
tf‰ CC@@‰Eé´ ‹MðƒÁþ;Ás Hfƒ9
u
ƒÀ‰Ej
éŽ ‰Mé„ ƒEj EèPjEøP‹ÿ4ÿ,á@ …Àu
ÿ\à@ …Àu[ƒ}è tU‹öDHt(fƒ}ø
t²j
Xf‰‹ŠMøˆL‹ŠMùˆL%‹ÆD&
ë*;]ôufƒ}ø
t…jjÿjþÿuèšÒÿÿƒÄfƒ}ø
tj
Xf‰CC‹Eð9E‚ÿÿÿë‹tö@u€ëf‹ f‰CC+]ô‰]ðé‘þÿÿÿ\à@ j^;ÆuèuuÿÿÇ è}uÿÿ‰0éiþÿÿƒøm…Yþÿÿ‰]ìé\þÿÿ3À_[^ÉÃjhøø@ è‹uÿÿ‹EƒøþuèEuÿÿƒ è*uÿÿÇ ƒÈÿé¾ 3ö;Æ|;*A r!è uÿÿ‰0èuÿÿÇ VVVVVèŠtÿÿƒÄëÉ‹ÈÁù *A ‹øƒç Áç‹ ¾L9ƒát¿¹ÿÿÿ;MÉAuèÎtÿÿ‰0è´tÿÿÇ ë°Pè ãÿÿY‰uü‹öD8tÿuÿu ÿuè~ùÿÿƒÄ ‰Eäëè~tÿÿÇ è†tÿÿ‰0ƒMäÿÇEüþÿÿÿè ‹EäèêtÿÿÃÿuèiãÿÿYËÿU‹ìƒì0S3ÛöE€VW‹ð‰]àˆ]þÇEÐ ‰]Ôt ‰]ØÆEÿë
ÇEØ ˆ]ÿEàPè
Y…Àt
SSSSSènrÿÿƒÄ‹M¸ € …Èu÷Á @ u9Eàt€Mÿ€‹Áƒà+ú À¿ €tGHt.Ht&èÓsÿÿ‰ƒÿè¶sÿÿj^SSSSS‰0è?sÿÿƒÄé ‰UøëöÁt÷Á uîÇEø @ë‰}ø‹EjY+Át7+Át*+Át +Átƒè@u¡9}ø”À‰Eðë ÇEð ëÇEð ë ÇEð ë‰]ð‹Eº #¹ ;Á¿ ;t0;Ãt,;Çt = „” = …@ÿÿÿÇEì ë/ÇEì ë&ÇEì ë = t= t`;Â…ÿÿÿÇEì ‹EÇEô€ …Çt‹
A ÷Ñ#M„ÉxÇEô ¨@tMô Mø ƒMð© t }ô¨ tMô ëÇEì 릨tMô è£áÿÿ‰ƒøÿuèjrÿÿ‰ƒÿèMrÿÿÇ éŽ ‹E‹= á@ SÿuôÇ ÿuìEÐPÿuðÿuøÿu ÿ׉Eäƒøÿum‹Mø¸ À#È;Èu+öEt%eøÿÿÿSÿuôEÐÿuìPÿuðÿuøÿu ÿ׉Eäƒøÿu4‹6‹ÆÁø‹… *A ƒæ ÁæD0€ þÿ\à@ PèÛqÿÿYè¯qÿÿ‹ ét ÿuäÿ@à@ ;ÃuD‹6‹ÆÁø‹… *A ƒæ ÁæD0€ þÿ\à@ ‹ðVè˜qÿÿYÿuäÿá@ ;óu°è_qÿÿÇ
룃øu€Mÿ@ë ƒøu€Mÿÿuäÿ6è4Þÿÿ‹‹Ðƒà Áú‹• *A YÁàYŠMÿ€ÉˆL‹‹Ðƒà Áú‹• *A ÁàD$€ €ˆMý€eýHˆMÿ…€ öÁ€„± öEtqjƒÏÿWÿ6è£ ƒÄ ‰Eè;ÇuèÖpÿÿ8ƒ tMÿ6èéÙÿÿéúþÿÿjEüPÿ6ˆ]üè’õÿÿƒÄ …Àu€}üu‹Eè™RPÿ6è ƒÄ ;ÇtÃSSÿ6èF ƒÄ ;Çt³öEÿ€„0 ¿ @ ¹ @ …}u‹Eà#Çu Më E‹E#Ç;ÁtD= t)= @ t"= t)= @ t"= t= @ u ÆEþë‹M¸ #È;Èu ÆEþëˆ]þ÷E „µ öEÿ@‰]è…¨ ‹Eø¹ À#Á= @„· = €tw;Á…„ ‹Eì;Æy ƒøvƒøv0ƒø…f ¾Eþ3ÿH„& H…R ÇEèÿþ ÇEì é jSSÿ6è8ÌÿÿƒÄ ÂtÇSSSÿ6è'Ìÿÿ#ƒăøÿ„ŽþÿÿjEèPÿ6è/ôÿÿƒÄ ƒøÿ„uþÿÿƒøtkƒø… }è uYÆEþéÜ ‹Eì;Ã†Ñ ƒø†bÿÿÿƒø‡PÿÿÿjSSÿ6è¸ËÿÿƒÄ „CÿÿÿSSSÿ6è£ËÿÿƒÄ#ƒøÿ…‘ éþÿÿ‹Eè%ÿÿ =þÿ uÿ6èß×ÿÿYè¤nÿÿj^‰0‹Æéd =ÿþ u Sjÿ6èX ƒÄ ƒøÿ„ÀýÿÿÆEþëASSÿ6è= ƒÄ ë™ÇEè ÇEì ‹Eì+ÇPD=èPÿ6è¸ÿÿƒÄ ƒøÿ„€ýÿÿø9}ìÛ‹‹ÈÁù‹ *A ƒà ÁàD$Š2Mþ€á0‹‹ÈÁù‹ *A ƒà ÁàD$‹MŠÁéÀá€â
ʈ8]ýu!öEt‹‹Èƒà Áù‹ *A ÁàD€ ‹}ø¸ À‹Ï#È;Èu|öEtvÿuäÿá@ SÿuôEÐjPÿuðçÿÿÿWÿu ÿ á@ ƒøÿu4ÿ\à@ Pè›mÿÿ‹‹Èƒà Áù‹ *A ÁàD€ þÿ6èÏÚÿÿYé˜ûÿÿ‹6‹ÎÁù‹ *A ƒæ Á手Ã_^[ÉÃjhù@ èomÿÿƒMäÿ3ö‰uà3À9u•À;Æu è mÿÿÇ VVVVVè‘lÿÿƒÄƒÈÿër‰uüÿuj@ÿu ÿuEàPEäè‰øÿÿƒÄ‰EÜÇEüþÿÿÿè ‹}Ü;þt<è¹lÿÿ‰8ë¿3ö9uàt+9uÜt ‹EäÁø‹Mäƒá Áá‹… *A D€ þÿuäèÛÿÿYËEäè mÿÿËÿU‹ìQQV3ö9uu èelÿÿVVVVVÇ èíkÿÿƒÄƒÈÿëJ9u tÞÿuEøPEüPÿuÿu è| ƒÄƒøÿtØÿuøÿuüÿujèU ÿuü‹ðè}oÿÿÿuøèuoÿÿƒÄ‹Æ^ÉËÿU‹ìƒìSW‹}3Û‰}ü;ûu èåkÿÿSSSSSÇ èmkÿÿƒÄƒÈÿéá 8 tÜ‹E ;ÃtÕ‹ ;ÃtÏ8tËVj\Wè j/W‹ðè
ƒÄ;Ã… ;ó…ƒ j:Wè=ïÿÿ‹ðYY;óusWèIšÿÿ‹ðƒÆjVèímÿÿ‹øƒÄ ‰}ü;û„ htô@ VWèkÃÿÿƒÄ …Àt
SSSSSè¯iÿÿƒÄÿuVWèØÁÿÿƒÄ …Àt
SSSSSè‘iÿÿƒÄw‹}ë
;ót;Æv‹ðƒMðÿj.Vèh YY…Àt,Sÿuüè
YY…À…ì ÿuÿu ÿuüè`þÿÿƒÄ ‰EðéÓ ÿuüè–™ÿÿ‹ðƒÆjVè:mÿÿƒÄ ‰Eø;ÃuƒÈÿé½ ÿuüVPè¸ÂÿÿƒÄ …Àt
SSSSSèühÿÿƒÄÿuüèQ™ÿÿ‹ø}øYèvjÿÿ‹ ‰Eì‹Eø+÷ðÇEôì A ‹Eôÿ0VWèrÂÿÿƒÄ …Àt
SSSSSè¶hÿÿƒÄSÿuøè] YY…Àtƒmô}ôà A }Äë è jÿÿÿu‹Mìÿu ‰ÿuøè”ýÿÿƒÄ ‰Eðÿuøèlmÿÿ‹}Y9}üt ÿuüè[mÿÿY‹Eð^_[ÉËÿU‹ìƒìSVW3ÛjSSÿu‰]ð‰]ôè–Æÿÿ‰Eè#ƒĉUìƒøÿtYjSSÿuèzÆÿÿ‹È#ʃăùÿtA‹u ‹}+ðúˆÆ ;ó†¼ » Sjÿ4á@ Pÿdà@ ‰Eü…ÀuèciÿÿÇ èXiÿÿ‹ _^[ÉÃh € ÿuèŠ YY‰Eø…ÿ|
;ór‹Ãë‹ÆPÿuüÿu謫ÿÿƒÄ ƒøÿt6™+ðúxÓ…öwÏ‹uðÿuøÿuèF YYÿuüj ÿ4á@ Pÿ`à@ 3Ûé† èóhÿÿƒ8u èÖhÿÿÇ
ƒÎÿ‰uôë½;ûq|;óskSÿuÿu ÿuèÅÿÿ#ƒăøÿ„Dÿÿÿÿuè›ÖÿÿYPÿ0á@ ÷ØÀ÷ØH™‰Eð#‰Uôƒøÿu)èwhÿÿÇ
èhÿÿ‹ðÿ\à@ ‰‹uð#uôƒþÿ„öþÿÿSÿuìÿuèÿuèÅÿÿ#ƒăøÿ„Ùþÿÿ3ÀéÙþÿÿ‹ÿU‹ìV‹uVè"ÖÿÿYƒøÿuèhÿÿÇ ƒÈÿëMWÿuj ÿu Pÿ á@ ‹øƒÿÿuÿ\à@ ë3À…Àt PèhÿÿYƒÈÿë‹ÆÁø‹… *A ƒæ ÁæD0€ ý‹Ç_^]ËÿU‹ìS‹] V‹u‹ÆÁø… *A ‹ƒæ Áæ 0ŠA$ÀW¶y¾Àç€ Ñøû @ tPû € tBû t&û t û u=€I€‹
L1$Š€â€Êˆë'€I€‹
L1$Š€â‚€Êëè€aë
€I€‹
L1$€!€…ÿ_^[u¸ € ]Ã÷ØÀ% À @ ]ËÿU‹ì‹EV3ö;Æu èêfÿÿVVVVVÇ èrfÿÿƒÄjXë
‹
d*A ‰3À^]ËÿU‹ìƒìh‹ES3ÛW‰]ôˆ]ÿ;Ãtƒøt~ƒø~ ƒøu ÆEÿ‹E‰Eðë8èfÿÿ‰èƒfÿÿSSSSSÇ è fÿÿƒÄƒÈÿé® @8uûH8tÆ ‹Á8uëVjD^VE˜SPèÔIÿÿ‰u˜‹5*A ƒÄ ;ót+Fÿ‹È‹ÐÁù‹ *A ƒâ Áâ8\uNH;óuà;óŒ@ þ23 ƒ4 ‹ÆkÀƒÀf‰EÊ·ÀjPèghÿÿYY‰EÌ;Ä ;ó‰0‹EÌH|0‰]ø~9‹Eø‹Ðƒà ÁúÁà• *A ŠPöÂuˆ‹ ‰ëˆƒÿÿEøAƒÇ9uø|Ê‹EÌ8]ÿt,H3ÒD0ƒþ}‹þëj_;×} ˆƒÿBAƒÀëäÇEô èjeÿÿ‰EÜPE˜PSÿuÿuôjSSÿuðÿu ÿ à@ ‹ðÿ\à@ ÿuÌ‹øè‘hÿÿY;óu Wè?eÿÿYëXƒ}uSè¤Qÿÿ‹5á@ 9]u jÿÿuÜÿà@ EìPÿuÜÿà@ ‹]ìëƒ}uÿuÜÿÖë‹]ÜÿuàÿÖ‹ÃëèÄdÿÿÇ ƒÈÿ^_[ÉËÿU‹ìƒì@¡€A 3ʼnEü‹M ‹ESVW¾xô@ }ð¥¥f¥‰MÔ‹M3Û‰Mà‹M¤j‰EÈ‹ø‹ ‰Mè‰]܉]ì‰]Ä^ëPè2“ÿÿƒÇt‹Y;ÃuìjV‰uÌèÊfÿÿ‹uàYY‰;Ãu#‹Eè‰è4dÿÿÇ è?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ = EncodePointer K E R N E L 3 2 . D L L DecodePointer FlsFree FlsSetValue FlsGetValue FlsAlloc runtime error
TLOSS error
SING error
DOMAIN error
R6034
An application has made an attempt to load the C runtime library incorrectly.
Please contact the application's support team for more information.
R6033
- Attempt to use MSIL code from this assembly during native code initialization
This indicates a bug in your application. It is most likely the result of calling an MSIL-compiled (/clr) function from a native constructor or from DllMain.
R6032
- not enough space for locale information
R6031
- Attempt to initialize the CRT more than once.
This indicates a bug in your application.
R6030
- CRT not initialized
R6028
- unable to initialize heap
R6027
- not enough space for lowio initialization
R6026
- not enough space for stdio initialization
R6025
- pure virtual function call
R6024
- not enough space for _onexit/atexit table
R6019
- unable to open console device
R6018
- unexpected heap error
R6017
- unexpected multithread lock error
R6016
- not enough space for thread data
This application has requested the Runtime to terminate it in an unusual way.
Please contact the application's support team for more information.
R6009
- not enough space for environment
R6008
- not enough space for arguments
R6002
- floating point support not loaded
Microsoft Visual C++ Runtime Library
... Runtime Error!
Program: À À – À À Ž À À À ‘ À ’ À “ À €€†€€ †€†‚€EEE……… 00€P€ˆ ('8PW€ 700PPˆ (€ˆ€€ `h`hhhxppwpp ( ( ( ( ( H „ „ „ „ „ „ „ „ „ „ ‚ ‚ ‚ ‚ ‚ ‚ h ( ( ( ( H „ „ „ „ „ „ „ „ „ „ ‚‚‚‚‚‚ H €‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ ¡¢£¤¥¦§¨©ª«¬®¯°±²³´µ¶·¸¹º»¼½¾¿ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖ×ØÙÚÛÜÝÞßàáâãäåæçèéêëìíîïðñòóôõö÷øùúûüýþÿ
!"#$%&'()*+,-./0123456789:;<=>?@abcdefghijklmnopqrstuvwxyz[\]^_`abcdefghijklmnopqrstuvwxyz{|}~€‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ ¡¢£¤¥¦§¨©ª«¬®¯°±²³´µ¶·¸¹º»¼½¾¿ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖ×ØÙÚÛÜÝÞßàáâãäåæçèéêëìíîïðñòóôõö÷øùúûüýþÿ€‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ ¡¢£¤¥¦§¨©ª«¬®¯°±²³´µ¶·¸¹º»¼½¾¿ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖ×ØÙÚÛÜÝÞßàáâãäåæçèéêëìíîïðñòóôõö÷øùúûüýþÿ
!"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`ABCDEFGHIJKLMNOPQRSTUVWXYZ{|}~€‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ ¡¢£¤¥¦§¨©ª«¬®¯°±²³´µ¶·¸¹º»¼½¾¿ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖ×ØÙÚÛÜÝÞßàáâãäåæçèéêëìíîïðñòóôõö÷øùúûüýþÿHH:mm:ss dddd, MMMM dd, yyyy MM/dd/yy PM AM December November October September August July June April March February January Dec Nov Oct Sep Aug Jul Jun May Apr Mar Feb Jan Saturday Friday Thursday Wednesday Tuesday Monday Sunday Sat Fri Thu Wed Tue Mon Sun GetProcessWindowStation GetUserObjectInformationA GetLastActivePopup GetActiveWindow MessageBoxA USER32.DLL SunMonTueWedThuFriSat JanFebMarAprMayJunJulAugSepOctNovDec CONOUT$ .com .exe .bat .cmd .\ SystemRoot H €A Ðô@ 8 °i ™ þÿÿÿ Ôÿÿÿ þÿÿÿ Ü@ þÿÿÿ Èÿÿÿ þÿÿÿ ¼#@ þÿÿÿ ˆÿÿÿ þÿÿÿú%@ þ%@ þÿÿÿÀ%@ Ô%@ þÿÿÿ Œÿÿÿ þÿÿÿh5@ l5@ þÿÿÿ Ôÿÿÿ þÿÿÿ ;@ þÿÿÿ Ðÿÿÿ þÿÿÿ á;@ þÿÿÿ Ìÿÿÿ þÿÿÿ k=@ 7=@ þÿÿÿ Ôÿÿÿ þÿÿÿ ð>@ þÿÿÿ Ôÿÿÿ þÿÿÿ #@@ þÿÿÿ Ôÿÿÿ þÿÿÿMA@ iA@ þÿÿÿ Ôÿÿÿ þÿÿÿ ]G@ þÿÿÿ Ìÿÿÿ þÿÿÿ +K@ þÿÿÿ Ôÿÿÿ þÿÿÿ ›N@ þÿÿÿ Ôÿÿÿ þÿÿÿ ÝP@ þÿÿÿ ìP@ þÿÿÿ Øÿÿÿ þÿÿÿ ŸR@ þÿÿÿ «R@ þÿÿÿ Ôÿÿÿ þÿÿÿ eY@ þÿÿÿ Øÿÿÿ þÿÿÿ [@ [@ þÿÿÿ Øÿÿÿ þÿÿÿ][@ a[@ þÿÿÿ Àÿÿÿ þÿÿÿ ¸^@ þÿÿÿ Ðÿÿÿ þÿÿÿH_@ __@ þÿÿÿ Ôÿÿÿ þÿÿÿ ¹j@ þÿÿÿ Ðÿÿÿ þÿÿÿ Êl@ þÿÿÿ Ôÿÿÿ þÿÿÿ Îy@ þÿÿÿ Ðÿÿÿ þÿÿÿ Þ@ þÿÿÿ Ðÿÿÿ þÿÿÿ ¿‚@ þÿÿÿ Ìÿÿÿ þÿÿÿ ´•@ þÿÿÿ Ðÿÿÿ þÿÿÿ M˜@ þÿÿÿ Ðÿÿÿ þÿÿÿ ä¡@ þÿÿÿ Ôÿÿÿ þÿÿÿ [¦@ þÿÿÿ Èÿÿÿ þÿÿÿ !¨@ ]§@ þÿÿÿ Ðÿÿÿ þÿÿÿ Ü®@ þÿÿÿ Ðÿÿÿ þÿÿÿ øÂ@ þÿÿÿ Ìÿÿÿ þÿÿÿ ›Ê@ \ù à œú ¸ú Îú äú öú û $û <û Tû hû pû ‚û û ¢û ´û Æû Öû äû üû ü $ü @ü ^ü rü ‚ü Žü šü ¦ü ¾ü Öü àü ìü þü ý ý &ý 0ý @ý Vý bý rý šý ´ý Ìý æý üý þ $þ 2þ Lþ \þ rþ Œþ ˜þ ¦þ ¶þ Æþ Øþ ìþ üþ ÿ "ÿ 4ÿ Fÿ Xÿ jÿ vÿ „ÿ ”ÿ ªÿ ºÿ Êÿ Øÿ êÿ üÿ $ 0 @ R RGenerateConsoleCtrlEvent ÆGetExitCodeProcess nWaitForSingleObject • CreateProcessA ¯SetConsoleCtrlHandler õGetModuleFileNameA Ú EnterCriticalSection ôLeaveCriticalSection úGetModuleHandleW +Sleep "GetProcAddress ExitProcess pGetCommandLineA <GetStartupInfoA ðSetHandleCount >GetStdHandle ØGetFileType ¿ DeleteCriticalSection 7TerminateProcess ªGetCurrentProcess HUnhandledExceptionFilter SetUnhandledExceptionFilter ÖIsDebuggerPresent çGetLastError ¦HeapFree ¢HeapAlloc \GetCPInfo ÅInterlockedIncrement ÁInterlockedDecrement SGetACP GetOEMCP àIsValidCodePage >TlsGetValue <TlsAlloc ?TlsSetValue =TlsFree ôSetLastError ®GetCurrentThreadId —WriteFile öLoadLibraryA ºInitializeCriticalSectionAndSpinCount KFreeEnvironmentStringsA ÀGetEnvironmentStrings LFreeEnvironmentStringsW „WideCharToMultiByte ÂGetEnvironmentStringsW ¤HeapCreate aVirtualFree YQueryPerformanceCounter jGetTickCount «GetCurrentProcessId SGetSystemTimeAsFileTime šRtlUnwind ©HeapReAlloc ^VirtualAlloc „GetConsoleCP –GetConsoleMode BFlushFileBuffers æLCMapStringA MultiByteToWideChar èLCMapStringW @GetStringTypeA CGetStringTypeW éGetLocaleInfoA çSetFilePointer «HeapSize D CloseHandle ŒWriteConsoleA šGetConsoleOutputCP –WriteConsoleW SetStdHandle y CreateFileA S CompareStringA V CompareStringW ØSetEnvironmentVariableA KERNEL32.dll nReadFile ÕSetEndOfFile &GetProcessHeap ÊGetFileAttributesA À+A À+A Næ@»±¿Dê#@ lâ@ \â@ ÿÿÿÿ€
!
5 A
C P R
S
W Y l
m p r €
‚ ƒ „
‘ ) ž
¡ ¤ §
· Î × abcdefghijklmnopqrstuvwxyz ABCDEFGHIJKLMNOPQRSTUVWXYZ abcdefghijklmnopqrstuvwxyz ABCDEFGHIJKLMNOPQRSTUVWXYZ hA ¤ `‚y‚! ¦ß ¡¥ Ÿàü @~€ü ¨ Á£Ú£ þ @þ µ Á£Ú£ þ Aþ ¶ Ï¢ä¢ å¢è¢[ þ @~¡þ Q QÚ^Ú _ÚjÚ2 ÓØÞàù 1~þ lí@ þÿÿÿC A A A A A H A hë@ ðï@ pñ@ ˆ A ˜A ˜A hA ÿÿÿÿÿÿÿÿ øè@ Ìè@ è@
è@ Üç@ ¬ç@ ˆç@ \ç@ $ç@ üæ@ Äæ@ Œæ@ dæ@ Dæ@ àå@ ¨å@ ! °ä@ " ä@ x ä@ y ðã@ z àã@ ü Üã@ ÿ Ìã@ ^˜@ ^˜@ ^˜@ ^˜@ ^˜@ ^˜@ ^˜@ ^˜@ ^˜@ ^˜@ x
hë@ jí@ ˜ó@ ”ó@ ó@ Œó@ ˆó@ „ó@ €ó@ xó@ pó@ hó@ \ó@ Pó@ Hó@ <ó@ 8ó@ 4ó@ 0ó@ ,ó@ (ó@ $ó@ ó@ ó@ ó@ ó@ ó@ ó@ ó@ øò@ ðò@ èò@ (ó@ àò@ Øò@ Ðò@ Äò@ ¼ò@ °ò@ ¤ò@ ò@ œò@ ò@ |ò@ pò@ ˆ A . D A Œ)A Œ)A Œ)A Œ)A Œ)A Œ)A Œ)A Œ)A Œ)A H A . “ €p ðñÿÿ PST PDT Ð A A ÿÿÿÿ ÿÿÿÿ þÿÿÿþÿÿÿÿÿÿÿ ; Z x — µ Ô ó 0 N m ÿÿÿÿ : Y w – ´ Ó ò / M l lô@ dô@ \ô@ Tô@ setuptools-20.7.0/setuptools/gui-64.exe 0000664 0001750 0001750 00000223000 12702524020 020613 0 ustar travis travis 0000000 0000000 MZ ÿÿ ¸ @ Ø º ´ Í!¸LÍ!This program cannot be run in DOS mode.
$ #^¤›g?ÊÈg?ÊÈg?ÊÈ@ù±Èd?ÊÈg?ËÈ:?ÊÈÚp\Èc?ÊÈymNÈC?ÊÈym_Èm?ÊÈymIÈ ?ÊÈym[Èf?ÊÈRichg?ÊÈ PE d† ±‹Q ð # Ö l Ì+ @ p € ( `
ð .text üÔ Ö `.rdata ¸) ð * Ú @ @.data ä5 @ À.pdata
` @ @ H‰\$H‰l$H‰t$H‰|$ ATAUAVHƒì L‹áHƒÉÿ3ÀI‹üº ò®H÷ÑD HyÿHcÈèP 3ö3íLcïÆ "HXL‹ð…ÿ~e € A¶ ,€ù\uÿÆë'€ù"u …ö~D‹Æ²\H‹Ë‹þèj Hß+öÆ\HÿÃë3öA¶,HÿÅHÿÃI;íˆCÿ|¸…ö~D‹Æ²\H‹Ë‹þè5 HßH‹l$HH‹t$PH‹|$XÆ"ÆC H‹\$@I‹ÆHƒÄ A^A]A\ÃÌÌÌÌÌÌÌÌÌH‰\$WHì` H‹¼ H3ÄH‰„$P H‹ÙH‹Á¶ H‹ú„ÉtHÿÀ€ù/uÆ@ÿ\Š„ÉuîH„$@ LŒ$@ LD$@HT$0H‹ËH‰D$ èO €|$0 …® €|$@\„£ H„$@ LŒ$@ LD$@HT$0H‹ÏH‰D$ è HƒÉÿ3ÀH|$@ò®HD$@H÷ÑHÿÈHÿÉHÈ€9\uHÿÉ€9\tHD$@H;Èr Æ HÿÉ€9\uëLD$@HT$0HŒ$@ L‹ËHÇD$ èß
º ¹ èŒ
H”$@ ëº ¹ ès
H‹ÓA¸ H‹ÈH‹øè» H‹ÇH‹Œ$P H3Ìè H‹œ$€ HÄ` _ÃÌÌÌÌÌÌÌH‰\$H‰l$H‰t$H‰|$ ATAUAVHƒì H‹ÙHƒÉÿ3ÀL‹êH‹ûPò®H÷ÑHÿÉè÷ 3ÿH‹óA‰} ¾ L‹ðE3äH‰èe …Àt D ¾KHÿÃèP …Àuð¶+HÿÃ@„ít[@¾Íè8 …ÀtE…ätI@€ý\uÿÇëÙ@€ý"u@öÇu3ÀE…ä”À@2íD‹àÑÿ…ÿtL‹Ç²\H‹ÎèÌ H÷3ÿ@„ít¢@ˆ.HÿÆëš…ÿtL‹Ç²\H‹Îè© H÷3ÿÆ AÿE IcE HÿÆI‰4Æ@„ít&¾ è± …Àt¾KHÿÃè …Àuð€; …GÿÿÿH‹\$@H‹l$HH‹t$PH‹|$XI‹ÆHƒÄ A^A]A\ÃÌÌÌÌÌHƒì(…Éu‹
‚! …Ét3Òÿ6Ü ¸ HƒÄ(ÃÌÌÌÌÌÌÌÌÌÌÌÌH‰\$WHìà 3À3ÿH‹ÙHL$pDGh3Ò‰¼$ð H‰D$PH‰D$XH‰D$`èÖ WH
ŒÿÿÿÇD$ph ÿîÛ L\$PHD$pL‰\$HH‰D$@H‰|$8H‰|$0E3ÉE3ÀH‹Ó3ɉ|$(ÇD$ ÿ«Û …Àu(èú H«Þ HH`èr 3ÀH‹œ$ø HÄà _ËD$`H‹L$PƒÊÿ‰• ÿ_Û H‹L$PH”$ð ÿDÛ …Àu(è£ H,Þ HH`è 3ÀH‹œ$ø HÄà _Ë„$ð H‹œ$ø HÄà _ÃÌÌÌÌÌÌÌÌH‰\$H‰l$H‰t$WATAUHƒì L‹éHƒÉÿ3À» I‹ýIcèò®H;ÝH‹òH÷ÑL‹ËLQ}J‹<ÊHƒÉÿ3Àò®IÿÁH÷ÑDÑL;Í|æIcÊH‹Óè HÌÝ M‹ÅH‹ÈL‹àè HƒÉÿ3ÀI‹ýò®H;ÝH÷ÑLiÿ}0L‹ÞIcÍH•Ý IÌèå H‹<ÞHƒÉÿ3ÀHÿÃò®H÷ÑDéH;Ý|ÐH‹\$@H‹l$HH‹t$PI‹ÄHƒÄ A]A\_ÃÌÌÌ@SWAVAWHìX H‹»
H3ÄH‰„$0 L‹òD‰D$ LcùHT$0A¸ 3ÉÿúÙ HƒÉÿ3ÀH|$0ò®H÷ÑHD /HL$0H;Áv €8.tHT$0Æ HÿÈH;ÂwëÆ 3ÀHƒÉÿH|$03Òò®H‹:Ý HL$0H‰Gÿ‹3Ý ‰Gè׸ ‹Øƒøÿu"èÏ LD$0HûÜ HH`èB Céù H”$0 A¸ ‹ÈH‰¬$ è ¯ HcÈH¼ 0 ‹ËèKˆ H”$0 HÿÊHÿÂH;×s¶„Àt<
t<
uéÆ HŒ$0 HÜ A¸ è$ …Àt%H‹YÜ HŒ$0 H‰‹PÜ ‰A¶JÜ ˆA HT$$HŒ$2 èùúÿÿHT$0H‹8H‹ØH‹ÏèvùÿÿH‹èH…Àu èé HÚÛ L‹ÇHH`è^ Eé
H‰´$P ‹t$$L‰¤$H L‰¬$@ E,7º AEHcÈèÁ H‹ÍL‹àè"øÿÿƒþI‰$I|$~ HƒÃÿÎH‹ èøÿÿHƒÇHƒÃHƒîH‰GøuæHL$0èê÷ÿÿ» HƒÇI;ßH‰Gø}! „ I‹ ÞèÇ÷ÿÿHÿÃHƒÇI;ßH‰Gø|çƒ|$ H‹´$P HÇ t*I‹ÔH‹Í躥 è HÚÚ HH`L‹Åèv ¸ ëE‹ÅI‹ÔH‹ÍèyüÿÿH‹ÈèAûÿÿL‹¤$H L‹¬$@ H‹¬$ H‹Œ$0 H3Ìè‰
HÄX A_A^_[ÃÌÌÌÌÌÌÌÌÌÌÌH‹i ‹
_ A¸ éøüÿÿH‹ÄH‰PH‰HL‰@L‰H SVWATHƒì8H‹ù3Û‹ó‹ÃH;Ë•À;Ãu'è& Ç H‰\$ E3ÉE3À3Ò3Éè¦% ƒÈÿé ‹ÃH;Ó•À;Ãu'è]& Ç H‰\$ E3ÉE3À3Ò3Éès% ƒÈÿéâ Ld$pèù öG@…• H‹Ïèæ# ƒøÿt*ƒøþt%HcÐH‹ÊHÁùLÇ) ƒâ HkÒXIÈH
%
ëH
H‹ÑL¢) öB8u%ƒøÿtƒøþtHcÈH‹ÁHÁøƒá HkÉXI ÀöA8€t"è®% Ç H‰\$ E3ÉE3À3Ò3ÉèÄ$ ƒÎÿ;óu*H‹ÏèM ‹ØM‹ÌE3ÀH‹T$hH‹Ïè` ‹ðH‹×‹Ëè H‹Ïè³ ‹ÆHƒÄ8A\_^[ÃÌÌÌH‰ Ã@SHƒì ‹\; » …Àu¸ ë;ÃLÃHcȺ ‰9; è& H‰
+ H…Àu$PH‹Ë‰ ; èç% H‰ð* H…Àu¸ ëx3ÉH H‰HƒÂ0HƒÁHƒët H‹Â* ëåE3ÀH EHI‹ÈLh( I‹ÀHÁøƒá I‹ÂHkÉXL‹Iƒúÿt IƒúþtM…ÒuÇþÿÿÿIÿÀHƒÂ0Iƒéu¼3ÀHƒÄ [ÃÌÌHƒì(è‡) €=$ tè' H‹
F* HƒÄ(éÁ& Ì@SHƒì H‹ÙH
l H;Ùr:Hð H;Øw.H‹ÓH¸«ªªªªªª*H+ÑH÷êHÁúH‹ÊHÁé?Lè<+ ºkë
HK0ÿSÔ HƒÄ [ÃÌ@SHƒì ƒùH‹Ú}ƒÁè+ ºkë
HJ0ÿ%Ô HƒÄ [ÃÌÌÌHƒì(Há H;Êr7He H;Èw+ºqH+ÊH¸«ªªªªªª*H÷éHÁúH‹ÊHÁé?Lè¯) ë
HƒÁ0ÿÓÓ HƒÄ(ÃÌÌHƒì(ƒù}ºrƒÁè†) ë
HJ0ÿªÓ HƒÄ(ÃÌ@SHƒì ƒd$@ LD$@è£* H‹ØH…Àu9D$@tè # H…Àt èö" ‹L$@‰H‹ÃHƒÄ [ÃÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌff „ H‹ÁIƒørS¶ÒI¹I¯ÑIƒø@r H÷ÙƒátL+ÁH‰HÈM‹ÈIƒà?IÁéu9M‹ÈIƒàIÁétfffH‰HƒÁIÿÉuôM…Àt
ˆHÿÁIÿÈuöà @ fffffIù s0H‰H‰QH‰QHƒÁ@H‰QØH‰QàIÿÉH‰QèH‰QðH‰QøuØë”f D HÃHÃQHÃQHƒÁ@HÃQØHÃQàIÿÉHÃQèHÃQðHÃQøuÐð€ $ éTÿÿÿÌÌÌÌÌÌÌÌÌÌÌÌff „ L‹ÙM Àt$H+ÊöÂt(Š„Àˆ„ã HÿÂIÿÈtöÂuæë I‹ÃÃH‰HƒÂH‹Iƒèr&I¹ÿþþþþþþ~LÈL‹ÐIƒòÿM3ÑI¹ M…ÑtÉIƒÀ„‹ „Àˆ„„ HÿÂIÿÈtx„äˆ$tuHÿÂIÿÈtiHÁè„ÀˆtbHÿÂIÿÈtV„äˆ$tSHÿÂIÿÈtGHÁè„Àˆt@HÿÂIÿÈt4„äˆ$t1HÿÂIÿÈt%Áè„Àˆt HÿÂIÿÈt„äˆ$tHÿÂIÿÈ…<ÿÿÿI‹ÃÃHÊH3ÒIƒørEöÁt
HÿÁˆIÿÈëñIƒè rH‰H‰QH‰QH‰QHƒÁ Iƒè sçIƒÀ Iƒèr H‰HƒÁëñIƒÀIƒèrˆHÿÁëóI‹ÃÃÌÌ@SHƒì E‹H‹ÚL‹ÉAƒãøAö L‹ÑtA‹@McP÷ØLÑHcÈL#ÑIcÃJ‹H‹C‹HHKöAt ¶AƒàðH˜LÈL3ÊI‹ÉHƒÄ [é™ ÌHƒì(M‹A8H‹ÊI‹Ñè‰ÿÿÿ¸ HƒÄ(ÃÌÌÌHƒì8H‹D$`H‰D$(L‰L$ M‹ÈL‹ÂHƒÊÿè( HƒÄ8ÃÌH‰\$L‰D$UVWATAUAVAWHƒì0L‹¤$¨ L‹¬$˜ H‹ùL‹ò3ÒM‹ù‹Ê‰T$pH;út
L;òuL;Ât¹ é¼ L;ÂtñL;Êu H9”$ uâë
H9”$ tÖL;êu H9”$ uÇë
H9”$ t»L;âu H9”$° u¬ë
H9”$° t ¸ H‹ß8t HÿÈHÿÃH;Âwñ€;:u,L;òt!Iƒø‚; A¹ L‹ÇHƒÊÿI‹Îè) 3ÒH{ëL;òtAˆH‹êH‹òH‹ß8te¾ èÚ( 3Ò;ÂtHÿÃ늆+ H^ ‹CøL;à‚§ ‹CüL;àƒ› ƒ{ „‘ ƒ;t‹HL$0H‹ÕIÇÿÐ…Àˆ„ ~sA} csmàu(Hƒ=÷ t H
î è©5 …Àtº I‹Íÿ× ‹KA¸ H‹ÕIÏèÓB I‹F@‹SMcM H‰D$(I‹F(I×M‹ÅH‹ÍH‰D$ ÿ‹Ã èÖB ÿÇHƒÃ;>sjé>ÿÿÿ3ÀëfI‹y 3íI+ÿ9.vTH^‹KôL;ár>‹CøL;às6H;ùr H;øsAöE u/ƒ; t ‹H;øt#ëH‹T$xIDZI‰D‹CüMÇAÿÐÿÅHƒÃ;.r°¸ L\$@I‹[0I‹k@I‹sHI‹ãA_A^A]A\_ÃÌÌÌH‰\$H‰|$ATHƒì H‹Ùèè ‹Èè!B …À„— èÀìÿÿHƒÀ0H;Øu3Àëè®ìÿÿHƒÀ`H;Øuw¸ ÿn ÷C ucL%Ò HcøIƒ<ü u+¹ èJ I‰üH…ÀuHC H‰CH‰¸ ‰C$‰CëI‹ üÇC$ ÇC H‰KH‰ K ¸ ë3ÀH‹\$0H‹|$8HƒÄ A\ÃÌÌÌ…Ét0SHƒì ºb H‹Ús H‹ÊèÁ cÿîÿÿƒc$ Hƒ# Hƒc HƒÄ [ÃÌÌÌ@SHƒì öB@I‹Øt Hƒz uAÿ ë&ƒBÿx
H‹ˆHÿ¶Áë¾Éèæ, ƒøÿu ëÿHƒÄ [ÃÌ…Ò~LH‰\$H‰l$H‰t$WHƒì I‹ùI‹ð‹Ú@ŠéL‹ÇH‹Ö@ŠÍÿËè…ÿÿÿƒ?ÿt…ÛçH‹\$0H‹l$8H‹t$@HƒÄ _ÃÌÌÌH‰\$H‰l$H‰t$WHƒì Aö@@I‹ùI‹ð‹ÚH‹ét Iƒx uAë7…Ò~3ŠM L‹ÇH‹ÖÿËè ÿÿÿHÿŃ?ÿuè= ƒ8*uL‹ÇH‹Ö±?èÿþÿÿ…ÛÍH‹\$0H‹l$8H‹t$@HƒÄ _ÃÌÌH‰\$UVWATAUAVAWHìÐ H‹öó H3ÄH‰„$È 3ÀH‹ÙH‰L$hH‹úHL$xI‹ÐM‹é‰D$`D‹à‰D$TD‹ð‰D$H‰D$X‰D$PèdóÿÿE3ÒI;ÚuAè£ 3ÛE3ÉE3À3Ò3ÉÇ H‰\$ è· 8œ$ tH‹„$ˆ ƒ È ýƒÈÿéý AƒÏÿöC@L
œÏÿÿ…º H‹Ëè
Hwó A;Çt(ƒøþt#LcÀL
sÏÿÿI‹ÈAƒà HÁùMkÀXM„É€C ë
L‹ÂL
PÏÿÿAö@8u)A;Çt ƒøþtHcÐH‹Âƒâ HÁøHkÒXI”Á€C öB8€tAè× 3ÛE3ÉE3À3Ò3ÉÇ H‰\$ èë
8œ$ tH‹„$ˆ ƒ È ýA‹Çé1 E3ÒI;út·@Š/A‹òD‰T$@D‰T$DA‹ÒL‰”$˜ A:ê„ê H‹œ$¨ A» HÿÇA;òH‰¼$° ŒÈ EàÿtkHƒ>þteAöE t^AöE uH‹ÿL´ A;ÇtILcçI‹ÄHÁøAƒä MkäXM$ÆH‹I‰$AŠE AˆD$IL$º èÚ* A;ÇtAÿD$ ëƒÈÿéÕ ÿÇIÿÅHƒÆ;û|‚E‹çI‹ÿH‹ßHkÛXH Õ Hƒ;ÿt Hƒ;þt€K€ëÆCAD$ÿ÷ØɃÁõ¸öÿÿÿE;çDÈÿ¢³ H‹ðHƒøÿtJI;ÇtEH‹Èÿ“³ A;Çt7H‰3¶Àƒøu€K@ë ƒøu€KHKº è.* A;ÇtÿC ëƒÈÿë.€K@HÇþÿÿÿAÿÄHÿÇHƒÿŒQÿÿÿ‹
ÿ ³ 3ÀëƒÈÿLœ$ I‹[ I‹s(I‹{0M‹c8I‹ãA_A^A]ÃÌÌÌHƒì8H…Éu%è* Hƒd$ E3ÉE3À3Ò3ÉÇ è? ƒÈÿë‹A HƒÄ8ÃÌÌH‰
ø Ã@SHìà ƒd$p HL$t3ÒA¸” è ßÿÿL\$pH„$ HŒ$ L‰\$HH‰D$PÿDz H‹œ$ HT$@H‹ËE3Àèý H…Àt;Hƒd$8 H‹T$@HL$`H‰L$0HL$XL‹ÈH‰L$(HŒ$ L‹ÃH‰L$ 3Éè¹ ë H‹„$è H‰„$ H„$è H‰„$¨ H‹„$è ÇD$p ÀÇD$t H‰„$€ ÿ² 3É‹Øÿÿ± HL$Hÿì± …Àu …ÛuHèø4 ÿα º ÀH‹Èÿ¸± HÄà [ÃÌÌÌH‰\$H‰l$H‰t$WHƒì0H‹éH‹
¾ö A‹ÙI‹øH‹òè@ H…ÀtL‹T$`D‹ËL‹ÇH‹ÖH‹ÍL‰T$ ÿÐë%¹ èƒ4 L‹\$`D‹ËL‹ÇH‹ÖH‹ÍL‰\$ èhþÿÿH‹\$@H‹l$HH‹t$PHƒÄ0_ÃÌÌÌL
Õä 3ÀI‹ÑD@;
t+ÿÀIЃø-ròAíƒøw¸
ÃÁDÿÿÿ¸ ƒùAFÀÃH˜A‹DÁÃÌHƒì(èw H…Àu Hçå ëHƒÀHƒÄ(ÃHƒì(èW H…Àu HËå ëHƒÀHƒÄ(Ã@SHƒì ‹Ùè3 H…Àu H§å ëHƒÀ‰è Lå H…ÀtLP‹Ëè;ÿÿÿA‰HƒÄ [ÃÌÌH‰\$H‰l$H‰t$WHƒì 3ÿH‹ñƒÍÿH‹Îèd3 H‹ØH…Àu(9Zõ v ‹Ïÿȯ DŸè D; Bõ A‹ûGý;ýuÈH‹l$8H‹t$@H‹ÃH‹\$0HƒÄ _ÃH‹ÄH‰XH‰hH‰pH‰x ATHƒì 3ÿH‹òH‹éAƒÌÿE3ÀH‹ÖH‹Íèi H‹ØH…Àu*9ßô v"‹ÏÿM¯ DŸè D; Çô A‹ûAGüA;üuÀH‹l$8H‹t$@H‹|$HH‹ÃH‹\$0HƒÄ A\ÃÌH‹ÄH‰XH‰hH‰pH‰x ATHƒì 3öH‹úH‹éAƒÌÿH‹×H‹Íè 3 H‹ØH…Àu/H…ÿt*9Yô v"‹ÎÿÇ® Džè D; Aô A‹óAGôA;ôu¾H‹l$8H‹t$@H‹|$HH‹ÃH‹\$0HƒÄ A\ÃÌÌÌH‰\$H‰l$H‰t$WATAUHƒì 3öI‹øH‹êAƒÍÿL‹áL‹ÇH‹ÕI‹Ìèg3 H‹ØH…Àu/H…ÿt*9Ìó v"‹Îÿ:® Džè D; ´ó A‹óAGõA;õu»H‹l$HH‹t$PH‹ÃH‹\$@HƒÄ A]A\_ÃH…Ét7SHƒì L‹ÁH‹
øÿ 3Òÿ€® …ÀuèSýÿÿH‹Øÿf® ‹Èèûüÿÿ‰HƒÄ [ÃÌÌÌH‰\$H‰t$ATHƒì03öNèj ^‰\$ ; 4 }iLcãH‹ Jƒ<à tPJ‹ àöAƒtè²3 ƒøÿtÿƉt$$ƒû|1H‹Û J‹ àHƒÁ0ÿ H‹
Æ J‹ áèAÿÿÿL‹ ¶ Kƒ$ã ÿÉ\$ ë¹ èç ‹ÆH‹\$@H‹t$HHƒÄ0A\ÃH‰\$H‰t$WHƒì ‹A3öH‹Ù$<u?÷A t6‹9+y…ÿ~-è úÿÿH‹SD‹Ç‹Èèâ: ;Çu‹C„Àyƒàý‰CëƒK ƒÎÿH‹Kƒc ‹ÆH‹t$8H‰ H‹\$0HƒÄ _ÃÌÌÌ@SHƒì H‹ÙH…Éuè5 ë,èjÿÿÿ…ÀtƒÈÿë ºcsH‹Ëè¢ùÿÿ‹Èè£; ÷ØÀë3ÀHƒÄ [ÃÌH‰t$H‰|$L‰d$AUAVAWHƒì0D‹ñE3ä3öNèç 3ÿ‰|$ AƒÏÿ;=® † LcïH‹~ Jƒ<è tjJ‹èöBƒt`‹ÏèŠ×ÿÿH‹^ J‹ èöAƒt5Aƒþuè9ÿÿÿA;Çt%AÿÄD‰d$$ëE…öuöAtèÿÿÿA;ÇAD÷‰t$(H‹ J‹ê‹Ïè¹×ÿÿÿlj|$ énÿÿÿ¹ è@ AƒþADô‹ÆH‹t$PH‹|$XL‹d$`HƒÄ0A_A^A]ù éÿÿÿÌÌH‰\$H‰t$H‰|$ATHƒì L%¬à 3ö3ÿI‹Üƒ{u%Hcƺ ÿÆH €Hªð H ÈH‰ è" …Àt-H³â HƒÃÿÇH;Ø|ø H‹\$0H‹t$8H‹|$@HƒÄ A\ÃHcÇHÀIƒ$Ä 3ÀëÛÌÌH‰\$H‰l$H‰t$WHƒì H !à H-Zâ H‹ûH‹7H…ötƒtH‹ÎÿЪ H‹Îè|üÿÿHƒ' HƒÇH;ý|ÔH‹ H…Ét ƒ{uÿ§ª HƒÃH;Ý|ãH‹\$0H‹l$8H‹t$@HƒÄ _ÃÌHcÉH®ß HÉH‹ ÈHÿ%ª H‰\$H‰t$H‰|$AUHƒì HcÙ¾ Hƒ= ü uè N èè ¹ÿ èàÿÿH‹ûHÿL-Uß Iƒ|ý t‹Æë{¹( èÃùÿÿH‹ØH…Àuè.ùÿÿÇ 3ÀëZ¹
èf Iƒ|ý u/º H‹Ëè˜ …ÀuH‹Ëè€ûÿÿèóøÿÿÇ 3öëI‰\ý ë H‹ËèbûÿÿH‹
vß ÿH© ‹ÆH‹\$0H‹t$8H‹|$@HƒÄ A]ÃH‰\$WHƒì HcÙH=¤Þ HÛHƒ<ß uèõþÿÿ…ÀuHèÑÞÿÿH‹ ßH‹\$0HƒÄ _Hÿ%ä¨ H‰\$WHƒì0I‹ØH‹úH…Ét23ÒHBàH÷ñH;Çs$èHøÿÿHƒd$ E3ÉE3À3Ò3ÉÇ è]÷ÿÿ3Àë]H¯ù¸ H…ÿHDø3ÀHƒÿàwH‹
žú PL‹Çÿ*© H…Àu-ƒ=–ú tH‹Ïè¼ …ÀuËH…Ût²Ç ëªH…ÛtÇ H‹\$@HƒÄ0_ÃÌH‰\$H‰l$H‰t$WHƒì0H‹òH‹éH…É„û H…Ò„ò 3ÿH‹ÙM…Àt!AŠ „Àt¿ H;׆¼ HYˆÆ:HÿÃI‹ÑM…ÉtAA€9 t;HÿÇH;þƒ– ŠHÿˆHÿÀ: uåI‹ÉèØ8 €8/t€8\tHÿÇH;þsmÆ\HÿÃH‹L$`H…ÉtëHÿÇH;þsSŠˆHÿÃHÿÁ€9 uéH‹L$hH…Ét1Š„Àt+<.t"HÿÇH;þs(Æ.HÿÃëHÿÇH;þsŠˆHÿÃHÿÁ€9 uéHGH;ÆvÆE è°öÿÿ»" ëÆ 3Àë#èöÿÿ» Hƒd$ E3ÉE3À3Ò3ɉè±õÿÿ‹ÃH‹\$@H‹l$HH‹t$PHƒÄ0_ÃÌÌH‰\$H‰t$WHƒì@‹ÚH‹ÑHL$ A‹ùA‹ðèøÙÿÿH‹D$(D¶ÛA„| u …ötH‹D$ H‹ˆ@ B·Y#Æë3À…Àt¸ €|$8 t H‹L$0ƒ¡È ýH‹\$PH‹t$XHƒÄ@_ÃÌH‹Â‹ÑA¹ H‹ÈE3ÀénÿÿÿÌÌ‹ÑA¹ E3À3ÉéZÿÿÿÌÌHƒì8Hƒd$ èY7 HƒÄ8ÃH‰L$Hìˆ H
î ÿ§¦ L‹ xï L‰\$XE3ÀHT$`H‹L$Xè×s H‰D$PHƒ|$P tAHÇD$8 HD$HH‰D$0HD$@H‰D$(H8î H‰D$ L‹L$PL‹D$XH‹T$`3Éè…s ë"H‹„$ˆ H‰ï H„$ˆ HƒÀH‰‘î H‹êî H‰[í H‹„$ H‰\î Ç2í ÀÇ,í H‹ÑØ H‰D$hH‹ÍØ H‰D$pÿ²¥ ‰œí ¹ è®( 3Éÿ’¥ H
K© ÿ}¥ ƒ=ví u
¹ è†( ÿ\¥ º ÀH‹ÈÿF¥ HĈ ÃÌÌH‰\$H‰l$H‰t$WHƒì HY H‹é¾ H‹ËL‹Æ3ÒègÑÿÿE3ÛH}AKA·ÃD‰]D‰]D‰] fó«H=RÜ H+ýŠ ˆHÿÃHƒîuòH º Š9ˆHÿÁHƒêuòH‹\$0H‹l$8H‹t$@HƒÄ _ÃÌÌH‰\$H‰t$WHì€ H‹·× H3ÄH‰„$p H‹ñ‹IHT$Pÿˤ » …À„= 3ÀHT$pˆÿÀHÿÂ;ÃrõŠD$VÆD$p H|$Vë)¶WD¶ÀD;ÂwA+ÐI‹ÀJLpDB² èyÐÿÿHƒÇŠ„ÀuÓ‹F ƒd$8 LD$p‰D$0‹FD‹Ë‰D$(H„$p º 3ÉH‰D$ è›? ƒd$@ ‹F‹V ‰D$8H„$p ‰\$0H‰D$(LL$pD‹Ã3ɉ\$ èd< ƒd$@ ‹F‹V ‰D$8H„$p ‰\$0H‰D$(LL$pA¸ 3ɉ\$ è.< Lœ$p HN 3ÒAöt € Š„p ëAöt€ Š„p ˆ ëÆ HÿÁHÿÂIƒÃHƒëu¿ë?3ÒHN DBŸA@ ƒøw€ B ë Aƒøw€ Bàˆ ëÆ ÿÂHÿÁ;ÓrÇH‹Œ$p H3Ìè’ÕÿÿLœ$€ I‹[I‹s I‹ã_ÃÌH‰\$WHƒì èÝ
H‹ø‹ˆÈ …
Fß tHƒ¸À t H‹˜¸ ën¹
è÷øÿÿH‹Ÿ¸ H‰\$0H; Þ tDH…Ût ðƒÿuHÇÙ H‹L$0H;ÈtèüóÿÿH‹áÝ H‰‡¸ H‹ÓÝ H‰D$0ðƒ H‹\$0¹
è“÷ÿÿH…ÛuK è†×ÿÿH‹ÃH‹\$8HƒÄ _Ã@SHƒì@‹ÙHL$ 3ÒèÌÔÿÿƒ%Õî ƒûþu%ÇÆî ÿ@¢ €|$8 tSH‹L$0ƒ¡È ýëEƒûýuÇœî ÿ¢ ëÔƒûüuH‹D$ Ç€î ‹@뻀|$8 t H‹D$0ƒ È ý‹ÃHƒÄ@[ÃH‰\$UVWATAUHƒì@H‹‰Ô H3ÄH‰D$8H‹òèIÿÿÿ3Û‹ø;Ãu
H‹Îèüÿÿé L-ÝÜ ‹ËH‹ëI‹ÅA¼ 98„' AÌIìHƒÀ0ƒùréÿèý „ ÿéý „ø ·Ïÿ_¡ ;Äç HT$ ‹Ïÿ2¡ ;Ã„Æ HN 3ÒA¸ èÍÿÿ‰~‰^ D9d$ † HD$&8\$&t-8Xt(¶8¶H;ùw+ÏHT7 AÌ€
IÔI+ÌuõHƒÀ8uÓHF ¹þ €IÄI+Ìuõ‹Né¤ t(ƒét ƒé
tA;Ìt‹Ãë¸ ë¸ ë ¸ ë¸ ‰F D‰fë‰^H~·Ã¹ fó«éà 9 îì …·þÿÿƒÈÿéÖ HN 3ÒA¸ è?ÌÿÿHlm L {Û HíAº MDíI‹ÈA8t18Yt,¶¶A;ÐwLL2 AŠAÔA¶AMÌ;ÐvìHƒÁ8uÏIƒÀMÜM+Ôu»‰~ï¤ D‰ft$ƒïtƒï
t A;üu» ë» ë » ë» ‰^ HVI|í¹ ·HƒÇf‰HƒÂI+ÌuíH‹Îè|úÿÿ3ÀH‹L$8H3ÌèÍÑÿÿH‹œ$€ HƒÄ@A]A\_^]ÃÌH‹ÄH‰XH‰pH‰xL‰` AUHƒì0‹ùAƒÍÿè H‹ðèüÿÿH‹ž¸ ‹Ïè¾üÿÿD‹à;C„ ¹ è\îÿÿH‹Ø3ÿH;Ç„| H‹–¸ H‹ÈA¸ èå: ‰;H‹ÓA‹ÌèýÿÿD‹è;Ç…$ H‹Ž¸ ðƒÿuH‹Ž¸ L%ÂÕ I;ÌtèüïÿÿëL%¯Õ H‰ž¸ ðƒö†È … öÈÚ …ü ¹
èˆôÿÿ‹C‰
ë ‹C‰ë ‹C ‰ ë ‹×‰T$ LWÿÿƒú}HcÊ·DKfA‰„Hˆ= ÿ‰T$ ëâ‹×‰T$ ú }HcÊŠD Bˆ„ * ÿ‰T$ ëá‰|$ ÿ }HcÏŠ„ Bˆ„0+ ÿlj|$ ëÞH‹Ù ðƒ ÿuH‹
Ù I;ÌtèïÿÿH‰ ùØ ðƒ¹
èÃòÿÿë+ƒøÿu&L%Ô I;ÜtH‹ËèäîÿÿèWìÿÿÇ ë3ÿD‹ïA‹ÅH‹\$@H‹t$HH‹|$PL‹d$XHƒÄ0A]ÃHƒì(ƒ=
ò u¹ýÿÿÿèñýÿÿÇ÷ñ 3ÀHƒÄ(ÃH‰\$H‰t$WHƒì H‹( H‹ÙH…ÀtyH
sÞ H;ÁtmH‹ƒ H…Àtaƒ8 u\H‹‹ H…Étƒ9 uè;îÿÿH‹‹( èC> H‹‹ H…Étƒ9 uèîÿÿH‹‹( èÙ= H‹‹ èîÿÿH‹‹( èõíÿÿH‹ƒ0 H…ÀtGƒ8 uBH‹‹8 Héþ èÑíÿÿH‹‹H ¿€ H+Ïè½íÿÿH‹‹P H+Ïè®íÿÿH‹‹0 è¢íÿÿH‹‹X H Ü H;Ètƒ¹` uèa; H‹‹X èuíÿÿH{X¾ HaØ H9GðtH‹H…Ét
ƒ9 uèMíÿÿHƒø tH‹OH…Ét
ƒ9 uè3íÿÿHƒÇ Hƒîu½H‹ËH‹\$0H‹t$8HƒÄ _éíÿÿÌÌðƒH‹ H…Àtðƒ H‹ H…Àtðƒ H‹ H…Àtðƒ H‹0 H…Àtðƒ HAXA¸ H·× H9Pðt H‹H…ÒtðƒHƒxø t
H‹PH…ÒtðƒHƒÀ IƒèuÉH‹X ðƒ€` ÃÌÌÌH…É„˜ AƒÉÿðD H‹ H…ÀtðDH‹ H…ÀtðDH‹ H…ÀtðDH‹0 H…ÀtðDHAXA¸ H× H9Pðt H‹H…ÒtðD
Hƒxø t
H‹PH…ÒtðD
HƒÀ IƒèuÉH‹X ðDˆ` H‹ÁÃÌÌÌ@SHƒì H‹ÚH…ÒtAH…Ét º …Àt @ˆ´$ˆ @ˆ¼$‰ Æ„$Š DJë@ˆ¼$ˆ Æ„$‰ D‹ÊH‹L$@‰T$8L„$ˆ ‹A‰D$0‹AHL$@‰D$(HD$pH‰D$ èí0 …Àu8D$Xt H‹D$Pƒ È ý3Àë·D$p#Å€|$X t H‹L$Pƒ¡È ýL\$`I‹kI‹s I‹ã_ÃÌÌÌH‹ÄH‰XH‰hH‰p ‰HWHƒì H‹ÊH‹Úè¶áÿÿ‹KHcðöÁ‚uèÞãÿÿÇ ƒK ƒÈÿé4 öÁ@t
èÂãÿÿÇ " ëâ3ÿöÁt‰{öÁ„‰ H‹CƒáþH‰‰K‹C‰{ƒàïƒÈ‰C© u/è3¾ÿÿHƒÀ0H;Øtè%¾ÿÿHƒÀ`H;Øu ‹Îèi ;ÇuH‹ËèÑ; ÷C „ ‹+H‹S+kHBH‰‹C$ÿÈ;ï‰C~D‹Å‹Îè¾! ‹øëWƒÉ ‰Ké?ÿÿÿƒþÿt#ƒþþt H‹ÎH‹ÆHÀæ ƒá HÁøHkÉXH ÂëH
Ç öA t3Ò‹ÎDBè: Hƒøÿ„ïþÿÿH‹KŠD$0ˆë½ HT$0‹ÎD‹ÅèC! ‹ø;ý…Åþÿÿ¶D$0H‹\$8H‹l$@H‹t$HHƒÄ _ÃÌÌÌH‰\$H‰|$L‰l$ AVHƒì0L5ˆÑ ‹ù3ÛI‹Æ;t ÿÃHƒÀƒûrñƒûƒÔ ¹ èÿ< ƒø„| ¹ èì< …Àu
ƒ=9Æ „a ÿü „š H=à A½ L H‹ÏI‹Õè„6 …ÀtHƒd$ E3ÉE3À3Ò3ÉèÛßÿÿHùß A¸ 3ÉÆîà ÿ#’ …Àu1L¨œ H
Òß ºû è36 …ÀtHƒd$ E3ÉE3À3Ò3ÉèŠßÿÿH
¨ß èš HÿÀHƒø÷ÿÿL‹àH‹
tå è/÷ÿÿH‹ØI;Ä‚˜ H‹øI+üLoIƒý‚„ I‹Ìè: H‹ðI;ÅsTº H;ÂHBÐHÐH;ÐrI‹Ìè¿àÿÿ3ÛH;Ãuë3ÛHV H;ÖrFI‹Ìè£àÿÿH;Ãt9HÁÿH øH‹ÈèžöÿÿH‰óä I‹ÎèöÿÿH‰HKèƒöÿÿH‰Ðä I‹Þë3ÛèÄÅÿÿH‹ÃH‹\$@H‹t$HH‹|$PHƒÄ A^A]A\ÃÌÌÌHƒì(èïþÿÿH÷ØÀ÷ØÿÈHƒÄ(ÃÌH‰\$WHƒì H C¥ H=<¥ ëH‹H…ÀtÿÐHƒÃH;ßríH‹\$0HƒÄ _ÃH‰\$WHƒì H ¥ H=¥ ëH‹H…ÀtÿÐHƒÃH;ßríH‹\$0HƒÄ _ÃH‰\$WHƒì H ÃÎ ¿
H‹ èªõÿÿH‰HƒÃHƒïuëH‹\$0HƒÄ _ÃÌÌÌÌÌÌÌÌÌÌÌÌÌÌH‹Á¹MZ f9t3ÀÃHcH% ‹Ãë#èI¿ÿÿÇ Hƒd$ E3ÉE3À3Ò3Éè^¾ÿÿƒÈÿH‹\$`HƒÄ0A\_^ÃÌH‰\$WHƒìPH‹ÚH‹ùH…Éu$è¿ÿÿHƒd$ E3ÉE3À3Ò3ÉÇ è¾ÿÿ3ÀëvH…Òt×H;ÊsòHL$0I‹Ð耢ÿÿL‹\$8Aƒ{ u€|$H HCÿtHH‹L$@ƒ¡È ýë:HSÿHÿÊH;úw ¶BöD uíH‹ËH+ʃáH+Ù€|$H t H‹L$@ƒ¡È ýHCÿH‹\$`HƒÄP_ÃÌÌE3Àé<ÿÿÿH‰\$H‰l$H‰t$WATAUHƒìPE3íI‹ùI‹ðH‹êH‹ÙM;ÍuI;ÍuI;Õu 3Àë>I;ÍtI;ÕvM;ÍuDˆ)ëèM;Åu?Dˆ)èý½ÿÿ» E3ÉE3À3Ò3ɉL‰l$ è½ÿÿ‹ÃL\$PI‹[ I‹k(I‹s0I‹ãA]A\_ÃH‹”$ HL$0èh¡ÿÿL‹\$8H‹ÕH‹ËE9ku L‹ÏL‹ÆèX D8l$Ht±H‹L$@ƒ¡È ýë£HƒÿÿuŠHÿƈHÿÁA:Åt.Hƒêuëë&ŠHÿƈHÿÁA:Åt HƒêtHƒïuåI;ýuDˆ)HÿÁI;Õ… D8.tHƒÿuYLaÿI‹ôL;ãr¶HT$0è'ÇÿÿA;ÅtHÿÎH;ósæA‹Ä+ƨt*Eˆ,$èô¼ÿÿº* ‰D8l$Ht H‹L$@ƒ¡È ý‹ÂéóþÿÿHƒÿÿu\HƒývOHt+þH‹þH;ór¶HT$0èÁÆÿÿA;ÅtHÿÏH;ûsæ‹Æ+Ǩt Dˆ.D8l$Ht H‹D$@ƒ È ý¸P é˜þÿÿDˆl+ÿëÜDˆ+èi¼ÿÿ»" E3ÉE3À3Ò3ɉL‰l$ è~»ÿÿD8l$H„aþÿÿH‹L$@ƒ¡È ýéPþÿÿH‹ÁH+ÃHƒø|YHqþH‹þH;ór¶HT$0è!ÆÿÿA;ÅtHÿÏH;ûsæ‹Æ+Ǩt+Dˆ.èð»ÿÿº* ‰D8l$H„ÿÿÿH‹D$@ƒ È ýéóþÿÿD8l$H„ ýÿÿH‹D$@ƒ È ýéýÿÿÌ@UATAUAVAWHƒì`Hl$@H‰]PH‰uXH‰}`H‹ŽŸ H3ÅH‰ED‹$¾ ¾ 3ÿM‹ÙL‰MD‰E D‹ò‰UH‹ÙDnÿD;×uOLw E‹Íº 3ɉ|$(H‰|$ ÿlm ;Çt E‹ÕD‰-Ò½ ëÿ>l D‹Ã½ ƒøxDDÖD‰µ½ L‹]D‹MpD;Ï~5A‹ÉI‹ÃA+Í@88t
IÅ;ÏuñƒÉÿA‹Á+ÁA+ÅA;Á}
DHD‰MpëD‹È‰EpD;Ö„\ D;ׄS E;Õ…€ D‹¥ˆ ‹÷D;çuH‹D‹`÷ M‹ÃA‹ÌÒ‰|$(H‰|$ ƒâAÕÿ¤l LcøD;ÿ„< H»ðÿÿÿÿÿÿA¾ÝÝ A½ ~[3ÒHBàI÷÷HƒørLKL?I;Íw.HAH;ÁwH‹ÃHƒàðèZ\ H+àH|$@H…ÿ„å ÇÌÌ ëèîÿÿH‹øH…ÀtD‰0HƒÇH…ÿ„À D‹MpL‹Eº A‹ÌD‰|$(H‰|$ ÿük 3É;Á„K ‹U ‰L$(H‰L$ ‹ME‹ÏL‹Çÿßk E3ÀHcðA;ð„! D‹U Aºâ
s;‹…€ A;À„ ;ðÿ ‹M‰D$(H‹ExE‹ÏL‹ÇA‹ÒH‰D$ ÿk éÛ A;ð~`3ÒHBàH÷öHƒørQHL6I;Íw*HAH;ÁwH‹ÃHƒàðèW[ H+àH\$@I;Øt ÇÌÌ ëèíÿÿE3ÀH‹ØI;ÀtD‰0HƒÃD‹U ëI‹ØI;Øtn‹ME‹ÏL‹ÇA‹Ò‰t$(H‰\$ ÿk 3É;Át?‹…€ 3ÒH‰L$8D‹ÎL‹ÃH‰L$0;Áu ‰L$(H‰L$ ë
‰D$(H‹ExH‰D$ A‹ÌÿOj ‹ðHKðD91uè»ÿÿHOðD91uèõºÿÿ‹ÆéÍ H‹÷L‹çD;÷u H‹D‹pD‰u‹½ˆ …ÿuH‹‹xA‹Îèh D‹èƒøÿu3Àé L‹}xL‹E;Ç„< 3ÛLMp‹Ð‹Ï‰\$(H‰\$ è… H‹ðH;ÃtÉD‹Mp‹U L‹ÀA‹Î‰\$(H‰\$ ÿj LcÈD‰MD;Ëu‹ûé D;ËA¾ÝÝ ~bI‹ÉIƒùàwYHƒÁHù w4HYH;Ùw
H»ðÿÿÿÿÿÿHƒãðH‹Ãè¾Y H+ãH\$@H…Ût%ÇÌÌ ëè€ëÿÿH‹ØH…ÀtD‰0HƒÃD‹MH…Ûu3ÛëƒMcÁ3ÒH‹Ëè{”ÿÿD‹]D‹Mp‹U ‹MD‰\$(L‹ÆH‰\$ ÿJi ‰E…Àu3ÿë.‹…€ LML‹Ã‰D$(‹×A‹ÍL‰|$ è ‹}L‹à3ÀL;àDøHKðD91u(èg¹ÿÿë!‹…€ D‹Mp‹U ‰D$(A‹ÎL‰|$ ÿâh ‹ø3ÛH;ótH‹Îè5¹ÿÿL;ãt
M;ütI‹Ìè#¹ÿÿ‹ÇH‹MH3Íè!šÿÿH‹]PH‹uXH‹}`He A_A^A]A\]ÃÌÌÌH‰\$H‰t$WHƒìp‹òH‹ÑHL$PI‹ÙA‹øè šÿÿ‹„$¸ D‹œ$À HL$PD‰\$@‰D$8‹„$° ‰D$0H‹„$¨ L‹ËH‰D$(‹„$ D‹Ç‹Ö‰D$ èOúÿÿ€|$h t H‹L$`ƒ¡È ýL\$pI‹[I‹sI‹ã_ÃÌÌD‰L$ UATAUAVAWHƒì@Hl$0H‰]@H‰uHH‰}PH‹²™ H3ÅH‰ED‹
L¸ ¿ 3ÛM‹ðD‹úL‹éwD;Ëu=LM Hq D‹Ç‹Ïÿ¶g ;Ãt‰=¸ ë6ÿ|f D‹
¸ ƒøxDDÎD‰
÷· D;΄& D;Ë„ D;Ï…C ‹uh;óuI‹E ‹p÷]xD‹MXM‹ÆҋΉ\$(ƒâH‰\$ ×ÿ,g LcàD;ã„ A½ÝÝ ~hH¸ðÿÿÿÿÿÿL;àwYKL$Hù w5HAH;Áw
H¸ðÿÿÿÿÿÿHƒàðèçV H+àH|$0H;û„µ ÇÌÌ ëè¥èÿÿH‹øH;Ãt D‰(HƒÇëH‹ûH;û„‹ M‹Ä3ÒH‹ÏMÀ蜑ÿÿD‹MXM‹Æº ‹ÎD‰d$(H‰|$ ÿvf ;ÃtL‹M`D‹ÀH‹×A‹Ïÿwf ‹ØHOðD9)u諶ÿÿ‹Ãéˆ D‹epH‹ûD;ãuI‹E D‹`‹uh;óuI‹E ‹pA‹Ìè" ƒøÿu3ÀëU;Æt$LMXM‹Æ‹Ð‹Î‰\$(H‰\$ èP H‹øH;Ãt×L‹ðH‹E`D‹MXM‹ÆA‹×A‹ÌH‰D$ ÿáe ‹ðH;ûtH‹Ïè ¶ÿÿ‹ÆH‹MH3Íè —ÿÿH‹]@H‹uHH‹}PHeA_A^A]A\]ÃÌÌH‰\$H‰t$WHƒì`‹òH‹ÑHL$@A‹ÙI‹øèü–ÿÿ‹„$ D‹œ$¨ HL$@D‰\$8‰D$0‹„$˜ ‰D$(H‹„$ D‹ËL‹Ç‹ÖH‰D$ è.ýÿÿ€|$X t H‹L$Pƒ¡È ýH‹\$pH‹t$xHƒÄ`_ÃÌÌÌÌÌÌÌÌÌÌÌÌÌff „ L‹ÙH+Ñ‚ž IƒøraöÁt6öÁt Š
IÿȈHÿÁöÁtf‹
Iƒèf‰HƒÁöÁt
‹
Iƒè‰HƒÁM‹ÈIÁéuQM‹ÈIÁétH‹
H‰HƒÁIÿÉuðIƒàM…ÀuI‹Ãà @ Š
ˆHÿÁIÿÈuóI‹ÃÃfffffff „ fffffIù sBH‹
L‹T
HƒÁ H‰AàL‰QèH‹D
ðL‹T
øIÿÉH‰AðL‰QøuÔIƒà éqÿÿÿfff „ fHú rµ¸
D
@HÁ€ ÿÈuìHé ¸@ L‹
L‹T
LÃ LÃQL‹L
L‹T
LÃILÃQL‹L
L‹T
(HƒÁ@LÃIàLÃQèL‹L
ðL‹T
øÿÈLÃIðLÃQøuªIè Iø ƒqÿÿÿð€ $ é¹þÿÿffff „ fffffffIÈIƒøraöÁt6öÁt HÿÉŠ
IÿȈöÁtHƒéf‹
Iƒèf‰öÁt
Hƒé‹
Iƒè‰M‹ÈIÁéuPM‹ÈIÁétHƒéH‹
IÿÉH‰uðIƒàM…ÀuI‹Ãà HÿÉŠ
IÿȈuóI‹ÃÃfffffff „ fffffIù sBH‹D
øL‹T
ðHƒé H‰AL‰QH‹D
L‹
IÿÉH‰AL‰uÕIƒà ésÿÿÿffff „ fHú ðÿÿwµ¸ Hé€
D
@ÿÈuìHÁ ¸@ L‹L
øL‹T
ðLÃIøLÃQðL‹L
èL‹T
àLÃIèLÃQàL‹L
ØL‹T
ÐHƒé@LÃILÃQL‹L
L‹
ÿÈLÃILÃuªIè Iø ƒqÿÿÿð€ $ éºþÿÿH…É„à SHƒì H‹ÙH‹Iè²ÿÿH‹Kèý±ÿÿH‹Kèô±ÿÿH‹K èë±ÿÿH‹K(èâ±ÿÿH‹K0èÙ±ÿÿH‹ èѱÿÿH‹K@èȱÿÿH‹KH迱ÿÿH‹KP趱ÿÿH‹KXè±ÿÿH‹K`褱ÿÿH‹Khè›±ÿÿH‹K8è’±ÿÿH‹Kp艱ÿÿH‹Kx耱ÿÿH‹‹€ èt±ÿÿH‹‹ˆ èh±ÿÿH‹‹ è\±ÿÿH‹‹˜ èP±ÿÿH‹‹ èD±ÿÿH‹‹¨ è8±ÿÿH‹‹° è,±ÿÿH‹‹¸ è ±ÿÿH‹‹À è±ÿÿH‹‹È è±ÿÿH‹‹Ð èü°ÿÿH‹‹Ø èð°ÿÿH‹‹à èä°ÿÿH‹‹è èØ°ÿÿH‹‹ð èÌ°ÿÿH‹‹ø èÀ°ÿÿH‹‹ è´°ÿÿH‹‹ 訰ÿÿH‹‹ 蜰ÿÿH‹‹ è°ÿÿH‹‹ è„°ÿÿH‹‹( èx°ÿÿH‹‹0 èl°ÿÿH‹‹8 è`°ÿÿH‹‹@ èT°ÿÿH‹‹H èH°ÿÿH‹‹P è<°ÿÿHƒÄ [ÃÌÌH…ÉtBSHƒì H‹ÙH‹ H;
) tè°ÿÿH‹KH;
tè°ÿÿH‹KH;
tèò¯ÿÿHƒÄ [ÃH…É„‹ SHƒì H‹ÙH‹IH;
ôŸ tèɯÿÿH‹K H;
êŸ tè·¯ÿÿH‹K(H;
àŸ t襯ÿÿH‹K0H;
ÖŸ t蓯ÿÿH‹K8H;
ÌŸ tè¯ÿÿH‹K@H;
Ÿ tèo¯ÿÿH‹KHH;
¸Ÿ tè]¯ÿÿHƒÄ [ÃÌÌÌ@SHƒì0L‹ÉH…Ét
H…ÒtM…Àu,Dˆè¬¬ÿÿ» Hƒd$ E3ÉE3À3Ò3ɉèÀ«ÿÿ‹ÃHƒÄ0[À9 t HÿÁHƒêuòH…ÒuAˆë¿AŠ IÿÀˆHÿÁ„ÀtHƒêuëH…ÒuAˆèN¬ÿÿ»" ë 3ÀëµÌÌÌ@SHƒì0M‹ØM…ÉuH…ÉuH…Òu 3Àë?H…ÉtH…ÒtM…ÉuDˆ ëèM…Àu,Dˆè¬ÿÿ» Hƒd$ E3ÉE3À3Ò3ɉè«ÿÿ‹ÃHƒÄ0[ÃL‹ÑL‹ÂIƒùÿuAŠIÿÃAˆIÿ„Àt,Iƒèuêë$AŠIÿÃAˆIÿ„Àt IƒètIƒéuäM…ÉuEˆ
M…À…fÿÿÿIƒùÿu DˆDÿA@Pë˜Æ èu«ÿÿ»" émÿÿÿÌÌÌ@SHƒì0H…Ét
H…ÒtM…Àu,DˆèK«ÿÿ» Hƒd$ E3ÉE3À3Ò3ɉè_ªÿÿ‹ÃHƒÄ0[ÃL‹ÉAŠ IÿÀAˆIÿÁ„ÀtHƒêuêH…Òuˆè«ÿÿ»" ëµ3ÀëÊÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌff „ H+ÑL‹ÊöÁtŠBŠ :ÂuVHÿÁ„ÀtWH÷Á uæI» J fâÿfúøwËH‹J‹ H;Âu¿Iºÿþþþþþþ~LÒHƒðÿHƒÁI3ÂI…ÃtÇëHÀHƒØÿÃ3ÀÃfff„Òt'„öt#HÁê„Òt„ötHÁê„Òt„öt Áê„Òt„öu‹3ÀÃHÀHƒØÿÃÌÌÌÌÌÌff „ H+ÑIƒør"öÁtfŠ:
u,HÿÁIÿÈöÁuîM‹ÈIÁéu M…ÀtŠ:
u HÿÁIÿÈuñH3ÀÃÀƒØÿÃIÁét7H‹H;
u[H‹AH;D
uLH‹AH;D
u=H‹AH;D
u.HƒÁ IÿÉuÍIƒà M‹ÈIÁét›H‹H;
uHƒÁIÿÉuîIƒàëƒHƒÁHƒÁHƒÁH‹ HÈHÉH;ÁÀƒØÿÃÌH‰\$WHƒì HcÙA‹øH‰T$8‹Ëèø
Hƒøÿuè-©ÿÿÇ HƒÈÿëW‹T$8LD$H‹
i¨ H;Ït2è?½ÿÿH…Àt(ÿÐH‹ØH…Àt H‹
Q¨ H;Ïtè ½ÿÿH…ÀtH‹ËÿÐH‹ØH‹
#¨ è½ÿÿH…ÀtD‹ÍM‹ÅI‹ÖH‹ËÿÐë3ÀH‹\$pH‹l$xHƒÄ@A^A]A\_^ÃHƒì8…Éx ƒù~
ƒùu‹› ë1‹› ‰
› ë#è¥ÿÿHƒd$ E3ÉE3À3Ò3ÉÇ è$¤ÿÿƒÈÿHƒÄ8ÃHƒì8H…Éu&èÞ¤ÿÿHƒd$ E3ÉE3À3Ò3ÉÇ èó£ÿÿHƒÈÿëL‹ÁH‹
G§ 3ÒÿW HƒÄ8ÃÌ̹ éæŠÿÿÌÌHì¨ öŽ— t
¹
èþÁÿÿèuÉÿÿH…Àt
¹ èrÉÿÿög— t_HŒ$Ð ÿgU HL$03ÒA¸˜ èuÿÿH‹„$¨ 3ÉH‰D$@HD$0ÇD$0 @H‰D$ H„$Ð H‰D$(ÿU HL$ ÿîT ¹ è˜ÿÿÌÌÌÌH‹ÄH‰XH‰hH‰pH‰x ATAUAVHƒìPL‹òH‹ÑHHÈE‹áM‹èèv‡ÿÿM…ítM‰u M…öu*诣ÿÿHƒd$ E3ÉE3À3Ò3ÉÇ èÄ¢ÿÿ€|$H éé E…ät Aƒü|ËAƒü$ÅAŠ.L‹D$03ÿI^Aƒ¸ ~LD$0@¶Íº è2¾ÿÿL‹D$0ëI‹€@ @¶Í·Hƒà…Àt@Š+HÿÃ뾋´$ @€ý-uƒÎë@€ý+u@Š+HÿÃE…äˆS Aƒü„I Aƒü$? E…äu(@€ý0tA¼
ë8€;xt
€;XtA¼ ë&A¼ ë Aƒüu@€ý0u€;xt€;Xu@ŠkHƒÃM‹@ 3ÒƒÈÿA÷ôD‹È@¶ÍE·JAöÀt @¾Íƒé0ëA÷À t,EŸ@¾Í<wƒé ƒÁÉA;ÌsƒÎA;ùr"u;Êv ƒÎM…íuHÿË@öÆuM…íIEÞ3ÿëYA¯üù@Š+HÿÃ둽ÿÿÿ@öÆu @öÆu:‹Æƒàtÿ €w…Àu';ýv#èõ¡ÿÿÇ " @öÆtƒÏÿë
@ŠÆ$öØÿ÷ßýM…ítI‰] @öÆt÷߀|$H t H‹L$@ƒ¡È ý‹Çë M…ítM‰u @8|$Ht H‹D$@ƒ È ý3ÀL\$PI‹[ I‹k(I‹s0I‹{8I‹ãA^A]A\ÃÌÌHƒì83ÀE‹ÈL‹Â‰D$ H‹Ñ9;Ÿ u H
R ë3ÉèQýÿÿHƒÄ8ÃH‰\$WHƒì Hcù‹Ïèì HƒøÿtYH‹ã¤ ¹ ƒÿu @„¸¸ u
;ùu ö@`tè½ ¹ H‹Øè° H;Ãt ‹Ïè¤ H‹Èÿ?S …Àu
ÿíQ ‹Øë3Û‹ÏèØ L‹ßH‹ÏHÁùAƒã Hs¤ H‹ ÊMkÛXBÆD …Ût ‹ËèÖ ÿÿƒÈÿë3ÀH‹\$0HƒÄ _ÃH‰\$H‰t$ ‰L$WATAUHƒì0HcÙƒûþu è€ ÿÿ3ÿ‰8èW ÿÿÇ ƒÈÿéÉ 3ÿ;ߌ– ; å£ ƒŠ H‹óL‹ãIÁüL-æ£ ƒæ HköXK‹Då ¾L0ƒáu+è' ÿÿ‰8è ÿÿÇ H‰|$ E3ÉE3À3Ò3ÉèŸÿÿƒÈÿëa‹Ëè K‹Då öD0t ‹Ëè†þÿÿ‹øë轟ÿÿÇ ƒÏÿ‹Ëè™ ‹Çë)èÄŸÿÿ‰8èŸÿÿÇ H‰|$ E3ÉE3À3Ò3É賞ÿÿƒÈÿH‹\$`H‹t$hHƒÄ0A]A\_Ã@SHƒì öAƒH‹Ùt"öAt H‹IèÖ¡ÿÿc÷ûÿÿ3ÀH‰H‰C‰CHƒÄ [ÃÌHƒìhH‹-ƒ H3ÄH‰D$Pƒ="’ f‰L$@tfH‹
è’ Hƒùþu èÑ H‹
Ö’ Hƒùÿ„¹ Hƒd$ LL$DHT$@A¸ ÿPQ …À…‰ ƒ=Í‘ …ˆ ÿÕO ƒøxu}ƒ%µ‘ ÿQ Hƒd$8 Hƒd$0 ‹ÈHD$HLD$@A¹ 3ÒÇD$( H‰D$ ÿ8P H‹
I’ Hƒùÿt0Hƒd$ LL$DHT$HD‹ÀÿºP …Àtf‹D$@ëÇA‘ ëí¸ÿÿ H‹L$PH3Ìè¹ÿÿHƒÄhÃH‰\$H‰l$H‰t$WHƒìP3íI‹ðH‹úH‹ÙH;ÕtL;Åt
@8*u H;Ítf‰)3ÀH‹\$`H‹l$hH‹t$pHƒÄP_ÃHL$0I‹ÑèzÿÿL‹\$0A9ku%H;Ýt¶f‰@8l$Ht H‹D$@ƒ È ý¸ 뮶HT$0èÎÿÿ;Å„œ H‹L$0D‹‰ Aƒù~0A;ñ|+‹I‹ÅH;Ý•ÀL‹Çº ‰D$(H‰\$ ÿtO H‹L$0;ÅuHc H;ðr(@8ot"‹ @8l$H„4ÿÿÿH‹L$@ƒ¡È ýé#ÿÿÿèÿÿÇ * @8l$Ht H‹D$@ƒ È ýƒÈÿéýþÿÿ‹ÅA¹ H;Ý•ÀAQL‹Ç‰D$(H‹D$0H‰\$ ‹HÿåN ;Å…ÿÿÿë¤ÌÌÌE3Éé„þÿÿÌÌÌÌÌÌÌÌH‰\$H‰l$H‰t$WHƒì H‹Ú…Éxi;
' saHcùH-3 H‹÷ƒç HÁþHkÿXH‹Dõ Hƒ<ÿu=ƒ=j€ u'…Étƒét ƒùu¹ôÿÿÿë ¹õÿÿÿë¹öÿÿÿÿ©N H‹Dõ H‰ 3ÀëèœÿÿÇ è(œÿÿƒ ƒÈÿH‹\$0H‹l$8H‹t$@HƒÄ _ÃÌH‰\$H‰l$WHƒì …Éxs;
Ÿ skHcÙH-‹Ÿ H‹ûƒã HÁÿHkÛXH‹Dý öDtGHƒ<ÿt@ƒ=» u)…Étƒét ƒùu¹ôÿÿÿë ¹õÿÿÿë¹öÿÿÿ3ÒÿøM H‹Dý Hƒ ÿ3Àëèa›ÿÿÇ èv›ÿÿƒ ƒÈÿH‹\$0H‹l$8HƒÄ _ÃHƒì8ƒùþuèR›ÿÿƒ è*›ÿÿÇ ë]…Éx1;
Äž s)HcÑH
О H‹Âƒâ HÁøHkÒXH‹ÁöDtH‹ë,è›ÿÿƒ èàšÿÿHƒd$ E3ÉE3À3Ò3ÉÇ èõ™ÿÿHƒÈÿHƒÄ8ÃH‹ÄH‰XH‰pH‰xL‰` AUHƒì HcÙL‹ãIÁüL-Vž ƒã HkÛXK‹tå ¿ ƒ|3 u3O 辡ÿÿƒ|3 uHL3º èïÁÿÿ÷ØÒ#úÿD3 ¹
è“ ÿÿ…ÿtK‹Lå HLÿ§J ‹ÇH‹\$0H‹t$8H‹|$@L‹d$HHƒÄ A]ÃÌÌHcÑH
Î H‹Âƒâ HÁøHkÒXH‹ÁHLHÿ%hJ H‰\$H‰|$L‰d$AUAVAWHƒì@IƒÌÿE‹ìE3öAL$ è# ÿÿ…ÀuA‹ÄéÉ ¹ èõ ÿÿ3ÿ‰|$$H_ ƒÿ@› LcÿJ‹ øH…Û„ H‰\$0J‹øH H;ØƒÍ öC…ª ƒ{ u;¹
èœ ÿÿƒ{ u HKº èÏÀÿÿ…Àu DpD‰t$(ëÿC ¹
èkŸÿÿE…öu HKÿ„I öCt HKÿ|I ëHIƒÌÿE…öu?ÆCL‰#L«œ K+ øH¸£‹.ºè¢‹.H÷ëL‹êIÁýI‹ÅHÁè?Lè‹ÇÁàDèD‰l$ ëHƒÃXH‰\$0IƒÌÿHfœ é ÿÿÿE;ì… ÿlj|$$HKœ éçþÿÿºX JÈèi™ÿÿH‰D$0H…ÀttHc×L%œ I‰Ðƒœ I‹ ÐHÁ H;ÁsÆ@ L‰ Æ@
ƒ` HƒÀXH‰D$0ëÖÁç‰|$ HcÏH‹ÁHÁøƒá HkÉXI‹ÀÆD‹ÏèHýÿÿ…ÀADüD‹ï‰|$ ¹ è9žÿÿA‹ÅH‹\$`H‹|$hL‹d$pHƒÄ@A_A^A]ÃHƒì8H‹É{ H3ÄH‰D$(LD$ A¹ º ÆD$& ÿîI …ÀuƒÈÿë
HL$ è› H‹L$(H3Ìè{ÿÿHƒÄ8ÃÌ@USVWATAUAVAWHìˆ Hl$@H‹`{ H3ÅH‰E0L‹µ° E‹!3ÿI‹ØH‹÷‰} L‰MD‹êD‹ùH‰];Ê„ HUÿTH ;Ç„Ÿ ƒ}…• HUA‹Íÿ5H ;Ç„€ ƒ}uzÇE Aƒüÿt`A‹ü…ÿŽ© HcÏH¸ðÿÿÿÿÿÿH;ȇ“ HL Hù wlHAH;Áw
H¸ðÿÿÿÿÿÿHƒàðèÏ8 H+àH\$@H…Ût<ÇÌÌ ëNH‹Ëè¢Çÿÿxë–E‹ÌL‹Ãº A‹Ï‰|$(H‰|$ ÿˆH ‹ø…À…oÿÿÿ3Àé7 èVÊÿÿH‹ØH…ÀtÇ ÝÝ HƒÃë3ÛH…ÛtÙLcÇ3ÒH‹ËMÀèOsÿÿL‹EE‹Ìº A‹Ï‰|$(H‰\$ ÿ)H E3ÿA;Ç„É M;÷t;‹…¸ L‰|$8L‰|$0‰D$(D‹ÏL‹Ã3ÒA‹ÍL‰t$ ÿ†G A;Ç„‘ I‹öé‰ D9} u,L‰|$8L‰|$0D‹ÏL‹Ã3ÒA‹ÍD‰|$(L‰|$ ÿJG ‹øA;ÇtWHc×¹ èf–ÿÿH‹ðI;ÇtBL‰|$8L‰|$0D‹ÏL‹Ã3ÒA‹Í‰|$(H‰D$ ÿ
G A;Çu
H‹ÎèÁ—ÿÿI‹÷ë AƒüÿtH‹M‰HKð9ÝÝ u蟗ÿÿH‹ÆH‹M0H3ÍèœxÿÿHeHA_A^A]A\_^[]ÃÌÌÌ3ÒDB
éyóÿÿÌL‹ÑM…Àtˆ t_è+ …ÀuVH‹ ˆ H…ÛtJH…ötEH‹ÎèŠÃÿÿH‹øH‹ H…Ét2èzÃÿÿH;ÇvH‹ €<9=uL‹ÇH‹ÖèÝ …ÀtHƒÃëÐH‹HD8ë3ÀH‹\$0H‹t$8HƒÄ _ÃÌÌÌH‰\$H‰t$H‰|$ATHƒì0I‹ðH‹ÚH‹ù¹ è8™ÿÿ3ÀH…ÿ•À…Àu&èÚ‘ÿÿ» ‰Hƒd$ E3ÉE3À3Ò3Éèîÿÿé¶ Hƒ' H…ÛtHƒ# 3ÀH…ö•À…Àu#蛑ÿÿ» ‰Hƒd$ E3ÉE3À3Ò3Éè¯ÿÿëzH‹Îè½þÿÿH‹ðH…Àu3ÛëfH‹Èè…Âÿÿº L$I‹Ìè(nÿÿH‰H…ÀuèC‘ÿÿÇ è8‘ÿÿ‹ë1L‹ÆI‹ÔH‹Èè¾åÿÿ…ÀtHƒd$ E3ÉE3À3Ò3ÉèÿÿH…ÛtL‰#3Û¹ èE—ÿÿ‹ÃH‹\$@H‹t$HH‹|$PHƒÄ0A\ÃÌH‰l$WHƒìpHcùHL$Pè}tÿÿÿ sbH‹T$Pƒº ~LD$Pº ‹Ï膫ÿÿH‹T$PëH‹‚@ ·xƒà…ÀtH‹‚H ¶8éè €|$h t H‹D$`ƒ È ý‹Çéá H‹D$Pƒ¸ ~6‹ïHT$PÁý@¶Íè¶Àÿÿ…Àt @ˆ¬$€ @ˆ¼$ Æ„$‚ º ë èÿÿº Ç * @ˆ¼$€ Æ„$ H‹L$PÇD$@ LŒ$€ ‹AA¸ ‰D$8H„$ ÇD$0 H‰D$(‰T$ ‹QHL$PèCÙÿÿ…À„2ÿÿÿƒø¶„$ t
¶Œ$‘ Áà Á€|$h t H‹L$`ƒ¡È ýH‹¬$ˆ HƒÄp_ÃH‹ÄH‰XH‰hH‰pWHƒì`H‹ñH‹úHHØI‹ÑI‹éI‹ØèørÿÿH…Ûu8\$Xt H‹D$Pƒ È ý3Àé¯ H…öu:è ÿÿHƒd$ E3ÉE3À3Ò3ÉÇ è1Žÿÿ€|$X t H‹D$Pƒ È ý¸ÿÿÿëpH…ÿtÁHûÿÿÿw¸H‹L$Hƒy uL‹ÍL‹ÃH‹×H‹ÎèÁ ë1‹A‹Q HL$@‰D$8‰\$0L‹ÎA¸ H‰|$(‰\$ è …ÀtŒƒÀþ€|$X t H‹L$Pƒ¡È ýL\$`I‹[I‹kI‹s I‹ã_ÃÌE3ÉéèþÿÿH‰\$H‰l$WHƒì@Hƒd$P H‹ ðƒ H‹H…À„ª ƒÍÿHƒd$8 Hƒd$0 ƒd$( Hƒd$ D‹ÍL‹À3Ò3ÉÿÊ? Hcø…À„‘ H‹Ïº èâŽÿÿH‰D$PH…ÀtzHƒd$8 Hƒd$0 L‹D‹Í3Ò3ɉ|$(H‰D$ ÿƒ? …ÀtGHL$P3ÒèË …ÀyH‹L$PH…Ét è$ÿÿHƒd$P HƒÃH‹H…À…Yÿÿÿ3ÀH‹\$XH‹l$`HƒÄ@_ÃH‹L$Pèòÿÿ‹ÅëâÌÌ@USVWATAUAVAWHƒìhHl$0H‹Kq H3ÅH‰E(H‹½¨ D‹Ò‰U ‹Í A» 3ÛM‹ùD‰EL‹ñH‰}Ecÿ;ÓuOL8I E‹Ì3Ò3ÉD‰d$(L‰D$ ÿ? ;Ãt
A‹ÔE\$ëÿù= ‹w A» ƒøxADÓD‹U ‰` D‹ D;Ë~YA‹ÉI‹ÇA+̃Îÿ8t IÄ;Ëuï‹Î‹Æ+ÁDÈD‰ D‹…° D;Ã~5A‹ÈH‹ÇA+Ì8t IÄ;Ëuò‹Î‹Æ+ÁDÀD‰…° ëƒÎÿD;Î}Æ3Àé¥ D;Æ|ôA;Ó„¯ ;Ó„§ A;ÔuÞD‹¸ D;ëuI‹D‹iD;Ët D;Ã…« E;ÈuA‹Ãé\ E;Ä~A‹ÄéO E;Ì~
¸ é@ HUA‹Íÿ= ;ÃtƒD‹ D;Ë~2ƒ}rÓ8]HEtÊ8XtÅAŠ:r:HvHƒÀ8ëå¸ éñ 9° ~+ƒ}rŒ8]HEtƒ8X„zÿÿÿŠ:r:HvËHƒÀ8ëâM‹Çº A‹Í‰\$(H‰\$ ÿw= LcðD;ó„ìþÿÿI¸ðÿÿÿÿÿÿ~d3ÒHBàI÷öHƒørUKL6Hù w.HAH;ÁwI‹ÀHƒàðè5- H+àHt$0H;ó„þÿÿÇÌÌ ëèó¾ÿÿH‹ðH;ÃtÇ ÝÝ HƒÆëH‹óH;ó„pþÿÿD‹ M‹ÇA‹ÔA‹ÍD‰t$(H‰t$ ÿÏ< ;Äô D‹° L‹Çº A‹Í‰\$(H‰\$ ÿ¦< LcàD;ã„Ç ~g3ÒHBàI÷ôHƒørXKL$Hù w1HAH;Áw
H¸ðÿÿÿÿÿÿHƒàðèg, H+àH|$0H;ûtÇÌÌ ëè)¾ÿÿH‹øH;ÃtÇ ÝÝ HƒÇëH‹ûH;ûtVD‹° L‹Eº A‹ÍD‰d$(H‰|$ ÿ< ;Ãt ‹U‹M E‹ÎL‹ÆD‰d$(H‰|$ ÿV< ‹ØHOð9ÝÝ uè/ŒÿÿHNð9ÝÝ uè Œÿÿ‹Ãéè H‹ûL‹ëD;Óu I‹D‹PD‰U D‹¥¸ D;ãuI‹D‹`A‹ÊèŽñÿÿD‹ð;Æ„ ýÿÿA;ÄteL M‹Ç‹ÐA‹Ì‰\$(H‰\$ èµñÿÿH‹øH;ÄÒüÿÿL‹EL° A‹ÖA‹Ì‰\$(H‰\$ èŠñÿÿL‹èH;Ãu
H‹Ïè~‹ÿÿéžüÿÿL‹ÿL‹ÀëL‹E‹…° D‹ ‹U‹M ‰D$(L‰D$ M‹ÇÿT; ‹ðH;ûtH‹Ïè9‹ÿÿI‹Íè1‹ÿÿ‹ÆH‹M(H3Íè/lÿÿHe8A_A^A]A\_^[]ÃÌÌH‰\$H‰t$WHƒì`‹òH‹ÑHL$@I‹ÙA‹øèlÿÿD‹œ$¨ ‹„$ HL$@D‰\$8‰D$0H‹„$˜ H‰D$(‹„$ L‹ËD‹Ç‹Ö‰D$ è¾úÿÿ€|$X t H‹L$Pƒ¡È ýH‹\$pH‹t$xHƒÄ`_ÃÌÌÌH‰\$H‰t$WHƒì`H‹ñH‹úHL$@I‹ÑI‹Øè‹kÿÿH…Ûu8\$Xt H‹D$Pƒ È ý3Àé H…öu=诇ÿÿHƒd$ E3ÉE3À3Ò3ÉÇ èĆÿÿ€|$X t H‹D$Pƒ È ý¸ÿÿÿé€ H…ÿt¾HûÿÿÿwµH‹D$@‹P…ÒuLL$@L‹ÃH‹×H‹Îèªòÿÿë>‹@HL$@L‹Î‰D$8‰\$0A¸ H‰|$(‰\$ è™þÿÿ…Àuè‡ÿÿÇ éyÿÿÿƒÀþ€|$X t H‹L$Pƒ¡È ýH‹\$pH‹t$xHƒÄ`_ÃÌÌÌH‰\$‰T$UVWATAUAVAWHƒì0E3í‹êL‹ñA‹ÝI;Íu$è·†ÿÿE3ÉE3À3Ò3ÉL‰l$ Ç èÍ…ÿÿéê L‹!M;å„Ó º= I‹Ìè³ H‹øH‰D$pI;Å„µ L;à„¬ D8hH‹5þ{ E‹ýA”ÇH;5ø{ upH‹îA‹ÅI;õu I‹õëUHƒÆÿÀL9.uõÿÀº HcÈè‡ÿÿH‹øH‹ðI;Åu ¹ èWlÿÿëH‹ÈèÍ H‰HƒÇHƒÅH‹E I;ÅuäL‰/H‹|$p‹l$xH‰5~{ I;õ…‰ A;ít9L9-y{ t0èf÷ÿÿA;Åtjè´…ÿÿÇ ƒÈÿH‹œ$€ HƒÄ0A_A^A]A\_^]ÃE;ýt3Àëß¹ è†ÿÿH‰ { I;ÅtÆL‰(L9- { u¹ èæ…ÿÿH‰ { I;Åt¤L‰(H‹5ìz H‹îI;õt’H‹‹ÇH‹þA+ÄLcèH…Ét?H‹ÑM‹ÅI‹Ìè¿öÿÿ…ÀuH‹A€| =„¢ A8\ „— HƒÇH‹H…ÉuÈH‹5’z H+þHÁÿ÷ßE3íA;ýŒŒ L9m „‚ Hc÷H‹Lõ èJ‡ÿÿE;ýtfL9lõ t HLõH‹ÿÇHƒÁH‰Dõ HÿÆL9lõ uèHc×H¸ÿÿÿÿÿÿÿ H;Ѓ“ H‹
z A¸ èq†ÿÿI;Åt|ësH‹5z H+þHÁÿérÿÿÿL‰dõ M‰.ë]E;ý… A;ý}÷ßG;ÇŒ„þÿÿLcÀH¸ÿÿÿÿÿÿÿ L;Àƒnþÿÿº H‹Îè†ÿÿI;Å„XþÿÿHcÏL‰$ÈL‰lÈM‰.H‰”y D9l$x„Š I‹Ìèµÿÿº HHèÄÿÿH‹øI;ÅtlI‹Ìèã´ÿÿM‹ÄH‹ÏHPèHØÿÿA;ÅtE3ÉE3À3Ò3ÉL‰l$ èŸÿÿH‹×H‹ÏI+ÔHT$pDˆ*HÿÂE;ýIEÕÿ6 A;ÅuƒËÿèiƒÿÿÇ * H‹Ïèã…ÿÿE;ýt I‹ÌèÖ…ÿÿM‰.‹Ãé™ýÿÿI‹ÌèÄ…ÿÿM‰.é¦ýÿÿH‰\$H‰t$WHƒì0H‹ÙH…ÉtFè<´ÿÿH‹ðHHè ·ÿÿH‹øH…Àt-HVL‹ÃH‹Èè×ÿÿ…ÀtHƒd$ E3ÉE3À3Ò3Éèä€ÿÿH‹Çë3ÀH‹\$@H‹t$HHƒÄ0_ÃÌH‰\$H‰t$WHƒìPH‹Ù‹úHL$0I‹ÐèWfÿÿ3öH;ÞuDè—‚ÿÿE3ÉE3À3Ò3ÉH‰t$ Ç èÿÿ@8t$Ht H‹D$@ƒ È ý3ÀH‹\$`H‹t$hHƒÄP_ÃH‹T$89ru ‹×H‹Ëè€ @8t$HtÕH‹L$@ƒ¡È ýëǶ f;Ît3¶ÁöD t HÿÃ@83t˜¶·ÉÁá È;ùu
HCÿë¼·Á;øtHÿÃëÅ·Á;ø…lÿÿÿ@8t$Ht H‹D$@ƒ È ýH‹ÃéfÿÿÿÌÌE3Àé ÿÿÿë:Ât
HÿÁŠ„Àuó:ÂuH‹ÁÃ3ÀÃÿ%X2 ÿ%¢2 ÿ%¤2 Hƒì8H…Éu&èŠÿÿHƒd$ E3ÉE3À3Ò3ÉÇ èŸ€ÿÿHƒÈÿë €9 tÕH…ÒtÐH‹H…ÀtÈ€8 tÃE3Àè‚ HƒÄ8ÃÌH‰T$‰L$SUVWATAUAVAWHƒìXA¼þÿÿÿHcÁA‹ØD‰d$4‰\$8A;Äuè,ÿÿ3ÿ‰8èÿÿÇ é 3ÿ;ÇŒï ;”„ ƒã H‹ðL‹ðL
AÿÿIÁþƒæ K‹Œñ€C HköXŠD1¨„· ûÿÿÿvèÉ€ÿÿ‰8袀ÿÿÇ éª ‹ï;ß„Š ¨…‚ H;×tÒDŠ|18A¸ EÿAÐÿA¾Ïƒétƒéu ‹Ã÷Шt«ƒãþL‹êëd‹Ã÷Шt›ÑëA;ØABØ‹ËèÁ€ÿÿL‹èH;Çuè,€ÿÿÇ èA€ÿÿÇ é= ‹Œ$ 3ÒDBè°ÖÿÿL
A@ÿÿL‹ØK‹„ñ€C L‰\0@K‹„ñ€C I‹ÕA¸
öD0H„œ ŠL0 A:È„ ;ß„‡ AˆM K‹„ñ€C AƒÊÿAÚIUAh÷DˆD0 D:ÿtbK‹„ñ€C ŠL09A:ÈtQ;ßtMˆ
K‹„ñ€C AÚHÿÂAhøDˆD09A€ÿu.K‹„ñ€C ŠL0:A:Èt ;ßtˆ
K‹„ñ€C HÿÂAhùAÚDˆD0:K‹Œñ€C LL$0D‹ÃH‹ 1H‰|$ ÿÂ1 ;Ç„Ï HcT$0;׌ ‹ÃH;Ї· L3?ÿÿêK‹„ð€C öD0€„y A€ÿ„¸ ;×tA€}
u€L0ë€d0ûHcÅI‹ÝM‹åIÅH‰D$@L;èƒ: ½
AŠ$<„
@:Åt
ˆHÿÃIÿÄéë H‹D$@HÿÈL;àsID$€8
u IƒÄé L‹àé½ K‹Œð€C LL$0H”$° H‹ 1A¸ IÿÄH‰|$ ÿÓ0 ;Çu
ÿ9/ ;Çu{9|$0tuLP>ÿÿK‹„ð€C öD0Ht"€¼$°
t'@ˆ+K‹Œð€C Š„$° ˆD1 ëGI;Ýu€¼$°
uÆ
ë3‹Œ$ A¸ HƒÊÿè]Ôÿÿ€¼$°
Læ=ÿÿtëLÛ=ÿÿ@ˆ+HÿÃL;d$@‚ìþÿÿë K‹„ð€C öD0@u€L0ë AŠ$ˆHÿËëA+íA€ÿ…ð ;ï„è A¿ I+ßö€uIßé² A‹×ëƒúI;ÝrI+ßA׶B8¼ 4 t㶠B¾„4 ;Çuè}ÿÿÇ * AƒÌÿé‘ ÿÀ;ÂuHcÂHØë^K‹„ð€C öD0Ht;I߃úˆL0 |ŠK‹Œð€C I߈D19ƒúuŠK‹Œð€C I߈D1:HcÂH+Øë‹Œ$ ÷ÚE‹ÇHcÒè2Óÿÿ‹D$8L‹¼$¨ A+ÝÑèD‹ËM‹Å‰D$(3Ò¹éý L‰|$ ÿ…. ‹è;Çuÿi- ‹Èè†|ÿÿAƒÌÿéä D‹d$4;ÃHs<ÿÿJ‹„ð€C @•Çí‰|0Hé¿ ;׺
tfA9U u€L0ë€d0ûHcÅI‹ÝM‹åN<(M;ïƒ{ ½
A·$fƒø„E f;Åtf‰HƒÃIƒÄé% IGþL;àsID$f9u IƒÄé L‹àéú K‹Œð€C LL$0H”$¸ H‹ 1A¸ IƒÄH‰|$ ÿ. ;Çuÿ}, ;Ç…® 9|$0„¤ LŒ;ÿÿK‹„ð€C öD0HtFº
f9”$¸ tKf‰+Š„$¸ K‹Œð€C ˆD1 Š„$¹ K‹Œð€C ˆD19K‹„ð€C ˆT0:ëWI;Ýuº
f9”$¸ uf‰ë>‹Œ$ HÇÂþÿÿÿDBèoÑÿÿº
Lû:ÿÿf9”$¸ të º
Lã:ÿÿf‰+HƒÃM;ç‚®þÿÿë"K‹„ð€C öD0@u€L0ë A·$f‰HƒÃ‹ëA+íD‹d$4L‹¼$¨ M;ïtI‹ÍèÔ|ÿÿAƒüþDDåA‹ÄëiÿU+ ƒøuè/zÿÿÇ èDzÿÿÇ é ýÿÿƒømuD‹ç뮋ÈèHzÿÿéýÿÿ3Àë)èzÿÿ‰8èóyÿÿÇ E3ÉE3À3Ò3ÉH‰|$ è yÿÿƒÈÿHƒÄXA_A^A]A\_^][ÃÌH‰\$H‰t$‰L$WATAUAVAWHƒì0A‹ðL‹êHcùƒÿþu è¶yÿÿ3Û‰èyÿÿÇ ƒÈÿé 3Û;ûŒâ ;=} ƒÖ L‹çL‹÷IÁþL= } Aƒä MkäXK‹÷B¾L ƒáu.è\yÿÿ‰è5yÿÿÇ H‰\$ E3ÉE3À3Ò3ÉèKxÿÿƒÈÿé© ‹ÃAøÿÿÿ–À;Ãu+è yÿÿ‰è÷xÿÿÇ H‰\$ E3ÉE3À3Ò3Éè
xÿÿƒÈÿën‹ÏèÞÿÿK‹÷BöD tD‹ÆI‹Õ‹Ïès÷ÿÿ‹Øëè®xÿÿÇ èÃxÿÿ‰ƒËÿ‹ÏèƒÞÿÿ‹Ãë)è®xÿÿ‰è‡xÿÿÇ H‰\$ E3ÉE3À3Ò3ÉèwÿÿƒÈÿH‹\$hH‹t$pHƒÄ0A_A^A]A\_ÃÌÌH‹ÄH‰XL‰@H‰HUVWATAUAVAWHì€ 3ÿA´€A‹ñH‹ÚÇ@¨ o‰xœ@ˆ¼$Ø H‰x°E„Ìt‰x¸A¶ë‰l$pDŠ÷HL$Tè© ;ÇtE3ÉE3À3Ò3ÉH‰|$ èÝuÿÿºær÷Æ @ u
|$T € tE
ô‹ÎA¸ ¸ ÀA#Ⱥ €;ÏtT+Ít:;Ít1è´wÿÿ‰8ƒ ÿèŠwÿÿ» E3ÉE3À3Ò3ÉH‰|$ ‰èŸvÿÿ‹Ãéû D‹øë@öÆt÷Æ uíA¿ @ëD‹ú‹Œ$à A¼ ƒét,ƒét#ƒétƒétƒù@u‹D;ú‹Ï”ÁëA‹Èë A‹Ìë‹Íë‹Ï‹Æº ‰L$H#ÂtF= t8= t*= t = t*= t&= t;Âté/ÿÿÿA‹ìë½ ë
½ ëA‹èºæA½€ D‰l$Ps Š'l öÐ"„$è ¨€AEDDèD‰l$P@öÆ@tAºíAºïƒÉD‰l$P‰L$Hºæ s
AºíD‰l$P@öÆ tAºíë @öÆt
Aºí D‰l$PèIÜÿÿ‰ƒøÿu!èIvÿÿ‰8ƒ ÿè vÿÿÇ èvÿÿ‹ é H‹„$À D‹D$HH‹Œ$Ð H‰|$0LL$`A‹×D‰l$(Ç ‰l$ ÿb( H‰D$XHƒøÿ…Œ ¹ ÀA‹Ç#Á;ÁuC¸ @„ðt9D‹D$HH‹Œ$Ð H‰|$0Aº÷ LL$`D‰l$(A‹×‰l$ ÿ
( H‰D$XHƒøÿu;Hc L-0y H‹Áƒá HÁøHkÉXI‹DÅ €dþÿj& ‹Èè‡uÿÿèBuÿÿ‹8éÌ H‹Èÿþ% ;ÇuMHc L-èx H‹Áƒá HÁøHkÉXI‹DÅ €dþÿ"& ‹È‹Øè=uÿÿH‹L$XÿV' ;ßu§èétÿÿÇ
ëšA;ÄuA€Î@ë ƒøuA€ÎH‹T$X‹ è%ØÿÿHc L-{x H‹Áƒá º HÁøD
òI‹DÅ HkÉXDˆtHc H‹Áƒá HÁøHkÉXI‹DÅ €d8€AŠÆ$HˆD$L…† E„ö‰Â A„ôtx‹ E‹ÄƒÊÿè¦ ‰D$Dƒøÿuèdtÿÿ8ƒ tP‹ èõÒÿÿééþÿÿ‹ HT$@A¸ @ˆ|$@èÕòÿÿ;Çu€|$@uHcT$D‹ è¾ ƒøÿtÁ‹ E3À3ÒèE ƒøÿt°º E„ö‰< ¹ @ …ñu‹D$T#Áuºîë ð‹Æ#Á= @ tJ= t,= @ t%= t+= @ t$= t= @ u(ˆ”$Ø ë ¹ ‹Æ#Á;ÁuDˆ¤$Ø ë@ˆ¼$Ø ÷Æ „º ‰|$DAöÆ@…¬ A‹Ç% À= @„$ = €t|= À…‡ ;ï† A;ìvƒýv8ƒý…l ¾Œ$Ø A¸ ‹ïA+È„ A;È…P ÇD$Dÿþ é ‹ E‹Ä3ÒèÉÿÿH;ÇtÀ‹ E3À3ÒènÉÿÿHƒøÿ„|þÿÿ‹ HT$DA¸ èbñÿÿƒøÿ„aþÿÿA;Ät ƒøuk|$D uD@þDˆ„$Ø éÜ ·D$D=þÿ u‹ è%Ñÿÿè`rÿÿ» ‰‹ûéã =ÿþ u#‹ E3ÀA‹Ôè’ ƒøÿ„ùýÿÿDˆ¤$Ø é† ‹ E3À3Òèp ƒøÿë;;ïvqA;ì†üþÿÿƒý‡êþÿÿ‹ E‹Ä3Òè¡ÈÿÿH;Ç„Þþÿÿ‹ E3À3ÒèŒÈÿÿHƒøÿu8é™ýÿÿÇD$D A¼ ‹ HcÅE‹ÄHTDD+ÅèN°ÿÿƒøÿ„mýÿÿèD;åÛA¸ Hc @Š¬$Ø H‹Áƒá @€åHÁøHkÉXI‹DÅ €d8€@l8HcH‹Âƒâ HÁøHkÒXI‹LÅ ‹Æ€d8ÁèÀàD8@8|$Lu!@öÆtHc H‹Áƒá HÁøHkÉXI‹DÅ €L A‹Ç% À= À…Ÿ A„ð„– H‹L$Xÿ^# ‹D$PD‹D$HH‹Œ$Ð H‰|$0‰D$(Aº÷ LL$`ÇD$ A‹×ÿQ# Hƒøÿu6ÿÕ! ‹ÈèòpÿÿLcI‹ÃAƒã HÁøMkÛXI‹DÅ B€dþ‹ è¢ÔÿÿéBûÿÿHcH‹Êƒâ HÁùHkÒXI‹LÍ H‰
‹ÇH‹œ$È HÄ€ A_A^A]A\_^]ÃÌÌH‹Ä‰PL‰@L‰H VWHƒìXƒHØÿƒ`Ü E3ÀH…ÉA•ÀE…Àu(è pÿÿÇ Hƒd$ E3ÉE3À3Ò3Éè5oÿÿƒÈÿé“ H„$€ HƒÀD‹@øƒd$0 D‰D$(ÇD$ @ D‹ÊL‹ÁHT$@HL$Dèv÷ÿÿ‹ð‰D$Hƒ|$D t9…Àt(Hc|$@H‹ÏH‹ÇHÁøLcs ƒá HkÉXI‹À€dþë‹|$@‹ÏènÕÿÿë‹|$@…öt èsoÿÿ‰0ƒÈÿë‹ÇHƒÄX_^ÃÌÌÌ@SHƒì0M‹ÐH‹ÂH‹ÙH…Éu&èGoÿÿHƒd$ E3ÉE3À3Ò3ÉÇ è\nÿÿHƒÈÿëUH…ÀtÕH‰L$ LL$XLD$@I‹ÒH‹ÈèÏ ƒøÿtÖL‹L$XL‹D$@H‹Ó¹ èç H‹L$@H‹ØèfqÿÿH‹L$Xè\qÿÿH‹ÃHƒÄ0[ÃÌÌÌH‰\$L‰D$UVWATAUAVAWHƒì0E3öM‹àL‹êH‹éH‹ñI;Îu(è–nÿÿE3ÉE3À3Ò3ÉL‰t$ Ç è¬mÿÿHƒÈÿé D81tÓI;ÖtÎH‹I;ÆtÆD80tÁº\ èv º/ H‹ÍH‹øèf A¿ I;Æ…œ I;þ… AW9H‹ÍèRìÿÿH‹øI;Æ…ˆ H‹Íè.ŸÿÿI‹×HXH‹ËèïnÿÿH‹ðI;Æ„sÿÿÿLl4 H‹ÓH‹ÈèuÂÿÿA;ÆtE3ÉE3À3Ò3ÉL‰t$ èÌkÿÿL‹ÅH‹ÓH‹ÎèêÀÿÿA;ÆtE3ÉE3À3Ò3ÉL‰t$ è¥kÿÿH~ë
I;þtH;ÇvH‹øHƒËÿH‹ÏS/èŸ
H‹ÎI;Æt&3Òè A;Æ…÷ M‹ÄI‹ÕH‹ÎèõýÿÿH‹Øéá èlžÿÿI‹×L`I‹Ìè-nÿÿH‹øI;Æ„Î L‹ÆI‹ÔH‹Èè·ÁÿÿA;ÆtE3ÉE3À3Ò3ÉL‰t$ èkÿÿH‹Îè"žÿÿL4èõlÿÿM+æD‹8I?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ = runtime error
TLOSS error
SING error
DOMAIN error
R6034
An application has made an attempt to load the C runtime library incorrectly.
Please contact the application's support team for more information.
R6033
- Attempt to use MSIL code from this assembly during native code initialization
This indicates a bug in your application. It is most likely the result of calling an MSIL-compiled (/clr) function from a native constructor or from DllMain.
R6032
- not enough space for locale information
R6031
- Attempt to initialize the CRT more than once.
This indicates a bug in your application.
R6030
- CRT not initialized
R6028
- unable to initialize heap
R6027
- not enough space for lowio initialization
R6026
- not enough space for stdio initialization
R6025
- pure virtual function call
R6024
- not enough space for _onexit/atexit table
R6019
- unable to open console device
R6018
- unexpected heap error
R6017
- unexpected multithread lock error
R6016
- not enough space for thread data
This application has requested the Runtime to terminate it in an unusual way.
Please contact the application's support team for more information.
R6009
- not enough space for environment
R6008
- not enough space for arguments
R6002
- floating point support not loaded
Microsoft Visual C++ Runtime Library
... Runtime Error!
Program: À À – À À Ž À À À ‘ À ’ À “ À €€†€€ †€†‚€EEE……… 00€P€ˆ ('8PW€ 700PPˆ (€ˆ€€ `h`hhhxppwpp ( ( ( ( ( H „ „ „ „ „ „ „ „ „ „ ‚ ‚ ‚ ‚ ‚ ‚ h ( ( ( ( H „ „ „ „ „ „ „ „ „ „ ‚‚‚‚‚‚ H €‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ ¡¢£¤¥¦§¨©ª«¬®¯°±²³´µ¶·¸¹º»¼½¾¿ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖ×ØÙÚÛÜÝÞßàáâãäåæçèéêëìíîïðñòóôõö÷øùúûüýþÿ
!"#$%&'()*+,-./0123456789:;<=>?@abcdefghijklmnopqrstuvwxyz[\]^_`abcdefghijklmnopqrstuvwxyz{|}~€‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ ¡¢£¤¥¦§¨©ª«¬®¯°±²³´µ¶·¸¹º»¼½¾¿ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖ×ØÙÚÛÜÝÞßàáâãäåæçèéêëìíîïðñòóôõö÷øùúûüýþÿ€‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ ¡¢£¤¥¦§¨©ª«¬®¯°±²³´µ¶·¸¹º»¼½¾¿ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖ×ØÙÚÛÜÝÞßàáâãäåæçèéêëìíîïðñòóôõö÷øùúûüýþÿ
!"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`ABCDEFGHIJKLMNOPQRSTUVWXYZ{|}~€‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ ¡¢£¤¥¦§¨©ª«¬®¯°±²³´µ¶·¸¹º»¼½¾¿ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖ×ØÙÚÛÜÝÞßàáâãäåæçèéêëìíîïðñòóôõö÷øùúûüýþÿHH:mm:ss dddd, MMMM dd, yyyy MM/dd/yy PM AM December November October September August July June April March February January Dec Nov Oct Sep Aug Jul Jun May Apr Mar Feb Jan Saturday Friday Thursday Wednesday Tuesday Monday Sunday Sat Fri Thu Wed Tue Mon Sun GetProcessWindowStation GetUserObjectInformationA GetLastActivePopup GetActiveWindow MessageBoxA USER32.DLL SunMonTueWedThuFriSat JanFebMarAprMayJunJulAugSepOctNovDec CONOUT$ .com .exe .bat .cmd .\ SystemRoot t d
T 4 2àÐÀ
4
Œ p ¸ P
4
p ! ð Î $ ! Î ¢ ! ÔH ÄI Î ¢ ! ÔH ÄI dJ Î ¢ ! TR ð Î $ K ðàp0¸ 0 bÀp`0 à+ Œ Y @â
4 RðàÐÀ
p ` P r0 ²0 4 2 p
4
2p
d 4 rðàÐÀpà+ ó' ü( Xâ 2P d 4 p à+ * * ¯+ ï* ‘+ zâ ‘+ d T 4 r ðàÐÀp t 4 2 À 20 d T 4 2p d T 4 2p) 4d Z ðà Ð
Àp`P ¸ È
Ä t d 4 ðàÐ à+ ´: À: \= ¼ 0
t d T 4 2À
d
T 4 2ÐÀp
20 d 4 R Àà+ ŸB C –â
Ä t d
RðàÐà+ [D ¡D ¯â "D ¾D ßâ t d 4 2À t d 4 2Ðà+ £F ãF øâ d
T 4 Rp d 4
r p $ d´ 4³ ° p ¸ p
4
2pà+ N kN ã 4 r Ð
Àp`P¸ 8
Ä t
d 4 RÐà+ R ;S ã 20à+ W !W -ã
4
2pà+ ÞW éW Fã þW %X fã 4 2pà+ ‚Y °Y Fã ÅY üY fã d T ² p d T 4 2p Ô t
4 Rà
t
d 4 2àÐÀà+ ` Ï` ã B B à+ Gb zb ã zb B à+ ™b b b
d 4 rðàÐ
À pà+ @f Óf Áã b à+ Tg cg Ýã cg t d
T 4 2àÐÀ d 4
R p
t
d T 4
rÀ B
4
2p › 4 ²p
` P d 4 R p
4
Rp RP 4 R pà+ ×v áv ÿã / 4q fðà Ð
Àp`P ¸
d 4
RðàÐÀpà+ = .ä 4 R
À p
`à+ € c€ ä
4
’p
d T 4 ’ÐÀp-
E t d 4 C²
ðàÐÀP ¸ X d 4 Ò p1
5#t d 4 3rð à
ÐÀP ¸ 8 d 4 ² p 2
0
d 4
RðàÐÀpà+ ¶— é— .ä
T 4 ràÐÀ p ` µ t d T 4 ’àÐÀ d
4 RÐÀpà+ 㟠ä 20  ¸ P T 4 2 p
Ä t d 4 2Ðà+ K¥ k¥ Eä
Ä t
4 rðàÐà+ m¦ “¦ ^ä ¦ ŧ ~ä b ¸ ( ' EC
ð à ÐÀp`0P ¸ p b ‚ t
d 4 RÀà+ Ñ ¹® —ä
T
Òp d T 4 ²p T 4 r p$
53Â
ð à ÐÀp`0P¸ X
4 RðàÐÀ p `
P d
4 ’ p ¢ðàÐÀ
p ` P
0
d 4
RðàÐÀpà+ ìÆ Ç .ä !
!4 !òðàÐÀp`P rP ¢p` à+ ÏÏ üÏ °ä R0 t d
T 4 2ðÐÀ d 4 2 p 4 ðàÐÀ
p P 0 #
ð à ÐÀp`P0¸ x d T
4 ’p0 f ð À Ü ò 2 H ` x Œ ” ¦ ´ Æ Ø æ ø . B V r ¤ ¸ Ò æ ö $ 0 B R b p ~ ˆ ˜ ® º Æ Ö þ 0 J ` z ž ¸ È Þ ø ( < L b r „ – ¨ º Æ Ô ä ú
( : L t € ¢ SGenerateConsoleCtrlEvent ÇGetExitCodeProcess rWaitForSingleObject – CreateProcessA ´SetConsoleCtrlHandler õGetModuleFileNameA Û EnterCriticalSection îLeaveCriticalSection úGetModuleHandleW /Sleep "GetProcAddress ExitProcess qGetCommandLineA <GetStartupInfoA žRtlUnwindEx ôSetHandleCount >GetStdHandle ÙGetFileType À DeleteCriticalSection ;TerminateProcess «GetCurrentProcess LUnhandledExceptionFilter #SetUnhandledExceptionFilter ÐIsDebuggerPresent ŸRtlVirtualUnwind ˜RtlLookupFunctionEntry ‘RtlCaptureContext çGetLastError ¦HeapFree ¢HeapAlloc ]GetCPInfo TGetACP GetOEMCP ÚIsValidCodePage × EncodePointer ¹ DecodePointer @FlsGetValue AFlsSetValue ?FlsFree øSetLastError ¯GetCurrentThreadId >FlsAlloc ›WriteFile ðLoadLibraryA ºInitializeCriticalSectionAndSpinCount LFreeEnvironmentStringsA ÁGetEnvironmentStrings MFreeEnvironmentStringsW ˆWideCharToMultiByte ÃGetEnvironmentStringsW ªHeapSetInformation ¤HeapCreate SQueryPerformanceCounter jGetTickCount ¬GetCurrentProcessId SGetSystemTimeAsFileTime ©HeapReAlloc …GetConsoleCP —GetConsoleMode CFlushFileBuffers àLCMapStringA MultiByteToWideChar âLCMapStringW @GetStringTypeA CGetStringTypeW éGetLocaleInfoA ìSetFilePointer «HeapSize D CloseHandle WriteConsoleA ›GetConsoleOutputCP šWriteConsoleW
SetStdHandle z CreateFileA S CompareStringA V CompareStringW ÝSetEnvironmentVariableA KERNEL32.dll hReadFile ÚSetEndOfFile &GetProcessHeap ËGetFileAttributesA àE@ àE@ 2¢ß-™+ Í] ÒfÔÿÿ\) @ ô @ ðó @ ÿÿÿÿÿÿÿÿ€
!
5 A
C P R
S
W Y l
m p r €
‚ ƒ „
‘ ) ž
¡ ¤ §
· Î × abcdefghijklmnopqrstuvwxyz ABCDEFGHIJKLMNOPQRSTUVWXYZ abcdefghijklmnopqrstuvwxyz ABCDEFGHIJKLMNOPQRSTUVWXYZ (@ ¤ `‚y‚! ¦ß ¡¥ Ÿàü @~€ü ¨ Á£Ú£ þ @þ µ Á£Ú£ þ Aþ ¶ Ï¢ä¢ å¢è¢[ þ @~¡þ Q QÚ^Ú _ÚjÚ2 ÓØÞàù 1~þ ôþ @ þÿÿÿ C @-@ @-@ @-@ @-@ @-@ P2@ ðü @ €@ @ Ð0@ P-@ P-@ (@ ÿÿÿÿ Xú @ (ú @ øù @
`ù @ (ù @ øø @ Ðø @ ø @ hø @ @ø @ ø @ Ð÷ @ ¨÷ @ ˆ÷ @ ÷ @ èö @ ! ðõ @ " Põ @ x @õ @ y 0õ @ z õ @ ü õ @ ÿ õ @ › @ › @ › @ › @ › @ › @ › @ › @ › @ › @
ðü @ òþ @ P@ L@ H@ D@ @@ <@ 8@ 0@ (@ @ @ @ ô@ è@ ä@ à@ Ü@ Ø@ Ô@ Ð@ Ì@ È@ Ä@ À@ ¼@ ¸@ °@ @ ”@ Œ@ Ô@ „@ |@ t@ h@ `@ P@ @@ 8@ 4@ (@ @ @ Ð0@ . @2@ lB@ lB@ lB@ lB@ lB@ lB@ lB@ lB@ lB@ P2@ . €p ðñÿÿ PST PDT à2@ 3@ ÿÿÿÿ ÿÿÿÿ þÿÿÿÿÿÿÿþÿÿÿÿÿÿÿÿÿÿÿ ; Z x — µ Ô ó 0 N m ÿÿÿÿ : Y w – ´ Ó ò / M l 8@ 0@ (@ @ ç x ð Y ” ` « x ° Ô d à ¬ í ô ð Î $ Î ¢ ¢ _ ô _ ¯ Ü ¯ · Ì · Õ ¼ ø m < x Z h \ ƒ d „ ã h ä h j d l “ d ” Õ h T · h ¸ Õ d Ø ÿ < ¥" d ¨" 6# à p# $ h $ š$ | œ$ 5% „ & 5& h 8& q& h t& Š& h ¤& ×& Œ Ø& ' ˜ ' Ã' ˜ Ä' N) ¤ ˆ) ï) h ð) É+ Ü Ì+ Þ+ d à+ - „- U. 4 X. . D . ×. h Ø. )/ L ,/ ª/ ` ¬/ ‘: t ”: = ˜ „= º= < Ä= é> Ð ì> q? ¼ ¼? Ü? d Ü? ü? d ü? B@ h D@ °@ ` °@ 3A Ü 4A ¹A Ü ¼A DB ô DB B „B 4C 4C C °C ÷C h øC ìD < øD ‚E | „E F ` F G G LG ˜ LG ûG € üG RI ¼ TI ÏI Ð üI J < J ZK à \K îK ` ðK ÓM è ÔM N
N O | O —Q (
˜Q S D
S ¸S d ¸S 2U tV ËV h ÌV AW t
`W …W d ˆW :X ”
â € @â Xâ Œ Xâ zâ Ô zâ –â Ô –â ¯â Ô ¯â Õâ Ô ßâ øâ Ô øâ ã Ô ã -ã Ô -ã Fã Ô Fã _ã Ô fã ã Ô ã “ã Ô ã Áã Ô Áã Ýã Œ Ýã ÿã Ô ÿã ä Œ ä .ä Œ .ä Eä Œ Eä ^ä Ô ^ä wä Ô ~ä —ä Ô —ä °ä Œ °ä üä P setuptools-20.7.0/setuptools/gui-arm-32.exe 0000664 0001750 0001750 00000207000 12702524020 021365 0 ustar travis travis 0000000 0000000 MZ ÿÿ ¸ @ º ´ Í!¸LÍ!This program cannot be run in DOS mode.
$ Õ7
<‘Vco‘Vco‘Vcoö¤o•VcoU“¨o“VcoU“®o“VcoU“oVcoU“¬o“Vco‘Vbo¢Vco%“¨o’Vco¶±oVco¶ªoVco¶¯oVcoRich‘Vco PE Ä þFǹBò€Àò@h˜GBò Àò@*hBò@Àò@h@0˜G
ò- ð½û½èð ž!ë X Bò„Àò@h˜G€F8Fÿ÷ÈýÈø ñ. Ý5>Uø ÿ÷¼ýDø >÷Ѩÿ÷µýDø ¹ñ Ý
ñ©ñUø ÿ÷¨ýDø >÷Ñ #AF8F#` ðdûBò€Àò@h˜GBò Àò@BòdÀò@:Fh@0˜G
ò- ðkû½èð ÿ÷ü¾ßø ÀÜø À`EÑpG 0@ µ‚°ßø ÀÜø ÀÍøÀßøÀÜø ÀÍø À ðRùþÞ 0@ 0@ -é% R% v% „% Ž% –% ¤% ($ $ $ ¸$ *& 2& <& D& N& X& b& E@ í@ @ -@ % R% v% „% Ž% –% ¤% ($ $ $ ¸$ *& 2& <& D& N& X& b& yGetModuleFileNameA KERNEL32.dll ¶isspace ocalloc __iob_func 9_makepath Žfprintf -_splitpath MSVCR110.dll Ž__getmainargs Ú_amsg_exit zexit ñ_cexit 9_exit ]__C_specific_handler ½_initterm_e ¼_initterm __initenv Y_XcptFilter ¶__set_app_type ¸__setusermatherr _configthreadlocale T_fmode ÿ_commode 9?terminate@@YAXXZ ƒ__crtSetUnhandledExceptionFilter ð_calloc_crt Ð_onexit *_lock †__dllonexit _unlock ;EncodePointer DecodePointer 1QueryPerformanceCounter 'GetCurrentThreadId ñGetSystemTimeAsFileTime GetTickCount64 æ_read ý_close Ñ_open 5_execv strlen strncpy strncmp Næ@»±¿Dÿÿÿÿ þÿÿÿ 1a5 ™ " © ¥b6ýý ¸" " E }`qý™ " ` í =a? É %`? Ý 8" - %`? E I`1 q I`1 m`1 å @" [ ` y 1`? í u`1 ) h" Ý 1± Ü" É è" å ô" ý I`? € 0 € H `P }
Ü pÈpðp8qNqzqºqÌqìqr
rrjrrrˆrÖrär sJszs†sŽsÚsîs t,t6t\tÄtÐtØt5<5@5„5ˆ5Œ55”5¼6À6Ä6È6Ì6Ð6Ô6Ø6Ü6à6ä6è6Œ77”7˜7œ7 7¤7¨7¬7°7´7¸7¼7À7Ä7@8h8l8”8˜8Ô8Ø8Ü8à8d9h9l9p9t9yœy¨y´y4zŒz ;;; ; ;(;,{8{D{P{\{h{t{€{Œ{˜{¤{²{È{ | ´0À0Ä0È01 1 MZ ÿÿ ¸ @ ð º ´ Í!¸LÍ!This program cannot be run in DOS mode.
$ 6á 3r€n`r€n`r€n`r€o`"€n`ÆE¥`q€n`ì ©`v€n`¶E¡`W€n`¶E `€n`¶E£`x€n`UF `s€n`UF¢`s€n`Richr€n` PE Ä R€\Q à " š h m" ° @ 0 @ àÒ ( h ° .text ô˜ š `.rdata D) ° * ž @ @.data $+ à È @ À.pdata h Ø @ @.reloc ‚
à @ B -éøCF ð
üFs Ø ! ðüFOð" z ! $ .€ø )ÝOð\Oð\cW\+Ñ1à"+ Ñ )ÝFPøëƒBûÑR !ø‹ à !c]4´Bø;äÛ )Ý\$F!±PøKƒBûÑR #‚ø Sp8F½èøƒ-éøOŠFF ðÆû! ðËû #Êø 0FÀø @”ù &F %Oð ð1ü0±4”ù ð+ü (øÑOð\ \!ù{W³8F ð ü±¸ñ "Ð\/Ñ5ðç"/ ÑðѸñ ÑOðàOð 'm=±3Frø»“BûÑv % /Oð\ÕÐø{Ñç\!=±3Frø“BûÑv % #ø;Úø 03Êø 0Iø#`§±”ù ðàû0±4”ù ðÚû (øÑ”ù 0Oð\ +«ÑHF½èøHF½èø-éøCF‰F€F ðIû† /
Ý ñ} Tø ð?ûƒ^ =÷Ñ!0F ð?ûKòXÀò@BFF ðßû@F ð,û€F/Ý ñ~ Uø+Kò\Àò@ë ðÌûUø ðû ëñ>ëÑ F½èøƒ F½èøƒ0µ ð÷ûòMù FFFJ±\!3/*Ñø “ù *öÑD« “„«ª©(F ðýù0Û»ù0\+7ÐD« “„«ª© F ð ý¨ ðÝú«Z ’ù 0\+ Ñ:’ù 0 \+ЩŠBÓpù=\+øÑ Ä¨ª©+F ð ý!Oô‚p ðÄúÄ©Oô‚rF ðÖú F
òM ð«û0½!Oô‚p ð³úOô‚r)FF ðÅú F
òM ðšû0½ µp¹Nö€cÀò@h0±Kò Àò@ !h˜G ½ ½ µž°F # ¨D" !““ “
“ “ ðÔüD# “KòÀò@Aòé Àò@ !h˜G«“ «“!FKòÀò@ #“““$h# “ # " GX¹ ð.ùKò`Àò@@0 ð×ù °½Nö€bÀò@
›˜oð `KòÀò@h˜GKò Àò@˜©h˜GX¹ ð
ùKò|Àò@@0 ð³ù °½˜ °½ -éðO ðûò-KòÀò@ ’‹Fh‚FOô€r© ˜G¨ ðú«Ä« &œBÙ”ù 0.+Ð&p<¬B÷Ø«Kò¤Àò@Z &pø? +ûÑø; +ø;ùѨ !ð°þF°ñÿ?Ñ ð¼øKò°Àò@ª@0 ðdù
ò- ðÓú½èðB©Oô€r(Fð÷ùB«Ä(FðØýB«;3£BÒ“ù ±
*Ð
*õÑKòÀÀò@B¨" p ðEü`±KòÄÀò@hB“ShC““hD“{ø1©
õ…pÿ÷ØýF(h©ÿ÷“þF‡¹ ðqøKòÔÀò@*h@0 ðù
ò- ðˆú½èðž!ë
ñ ðŒù€F8Fÿ÷nýÈø ñ. Ý5>Uø ÿ÷býDø >÷Ѩÿ÷[ýDø ºñ Ý ñªñUø ÿ÷NýDø >÷Ñ ##` ›AF8F“±ðìù ð(øKòøÀò@@0:F ðÐø
ò- ð?ú½èðJFÿ÷ðýÿ÷´þ
ò- ð4ú½èðNöŒcÀò@"hNöˆcÀò@hÿ÷¿ HpG à@ -é0H
ò L h¹Oô pà(Ú `! ð™þ
M(`H¹#! #` ðþ(`¹ àJ #P3 2P+Ú(høç ½è0ˆ à@ A û@ -éH
ò ðzÿK“ù 0 ± ðxÿL h ð¼ÿ ##`½èˆ A ¨î@ -éH
ò
JF”BÓò`#œB
Ø£[ñ ð øãhSô Cã`àKñ h˜G½èˆ°@ à@ -éH
ò F(Ú0 ðòÿãhSô Cã`àKñ h˜G½èˆ°@ JB
Óò`#˜B ØÃh3ô CÃ`ƒ[ñ ðí¿K 0hGþÞ °@ à@ (ÚËh3ô CË`0 ðÛ¿Kñ hG °@ ´-é¾H
ò oFybF $<`E¹ðú#`ðÏúoð Wà )ôÐðvù (öÛ}`(Fÿ÷~ÿëhð@5Ñ(FðÉú°ñÿ? Ðñ ÐC$Ið Qø#0ë‚"Jà!JF I“ø$0ðÑ°ñÿ? ÐñÐCð Qø#0ë‚’ø$0ð€Ðð;ú#`ð‹úoð <`|¹(Fð¢úFñ( "yj(FðVû8`)F FðÝú ðø8h½è¾]øûµxhÿ÷bÿ½þÞàù@ ã@ Fù; +ûÑX pG-éH
ò #jF “ðcÿFD¹ ›3±ðûù±ðøù ›` F½èˆ -éH
ò F‚± V ø; ±:ùÑB±:Ð !"±ƒ ø˜BûÑ F½èˆ-é0H
ò F ##sY»ð²ø `ÃnM#`ƒn"hc`KhšBÐo+hBÑð]ú `KbhhšBУho+hBÑð~û``¢hoð ÑSðg##sà h#`Khc` F½è0ˆþÞ”ç@ ˆç@ \å@ -éH
ò …°KFh;¹KÓø03ø0ð àhF !ÿ÷©ÿ šSo+ÝjF! FðˆýàÒø03ø0ð ø 0#±šo3ðg°½èˆÐæ@ Dð@ ´-é0H
ò ˆ°
FF #¨ ! "
• “ ð˜ùE¹ðOù#`ðŸùoð à ,ôÐoð C“B#“«hF ")F” ”ðgú›F;“ +Û › "pàiF ðý F°½è0]øû °Nö´LÀò@ Üø Àë Íø ÀpGNö´LÀò@ ›Üø ÀëcEÑ°pGFµlFìF,ð åFð"þ¥F½è@pG-é HëFÛih3ðPXðÐXðþ ½è ˆ-éþO
ò( F– “Ýø4 FÝø<€ šžF›‰F™ ' ±¹ñ Ñ ± ´à .ûоñ Ñ *öÑà *óкñ Ñ +îÑà +ëиñ Ñ )æÑà )ãÐ",F”ù 0±:4 *øÑ”ù 0:+ѹñ Ð.Àð€#oð *FHFðÞýÝø àe à¹ñ Љø p•ù 0 ' & +,FJДù ðþý±4
à”ù 0/+Ð\+Ð.+Ñ&F àg 4”ù 0 +èÑÝø à‡³¾ñ Ð š{šBDÙ*Foð pFð§ýÝø à=F '.³®B#Óºñ КsšB6Ù*Foð PFð“ýÝø à¸ñ #Й£™B(Ù2Foð @Fð„ýà¾ñ ÛÐ 'Žø pØçºñ КcšBÙ*Foð PFðoý¸ñ Јø p 2à™ 'à šà™ š ž›¹ñ б‰ø p¾ñ Ð
±Žø pºñ Ð ±Šø p¸ñ Ð ±ˆø p=¹ðø#`ðRø à (õÑ ðøÿ"#`" ½èþ -éðH
ò †°Ýø0à FF¾ñ Oô€tÐ%F à %±#F à #¹ $ ±" à "“;F•Íø à– ”ÿ÷âþ°½èðˆ -é H
ò FF
F™ ”‘oð ðDý½è ˆ FÛðÿAê!ð ÑAêA :ŒFÛ£è:£èùÚ2Û£è: ÛCø Ú Ðp*ÛYpÈ¿™ppGðÐR øðØÐ’ #øÔç -éxH
ò F $ -FÐ-BÓ. @Ð0ù,1Z³ù<šB'Ñù,ú±ù<šBÑù,š±ù<šBÑù,:±ù<šBÑ4´BÞÓ àø,ø<
àø,ø<àø,ø<àø,ø<Ð àù Z±‘ù 0šBÑ041¬BóÓ ½èxˆx xëç -éH
ò K IFhjF ˜G@±KI ˜h˜GF ± F˜G½èˆþÞ$²@ ,°@ ²@ (°@ ð9¼ ðO¼ -éH
ò K h˜GFðûü F ð&ÿ Fðý Fðý Fðý Fðþ½èˆ$°@ -éþI
ò F &
F?¹ ðÞþ#` ð.ÿ ?à -õÐð2þ ¹ Kh˜G ¹& LOð ê$h:F !0FÅø €Íø€Íø € GF4¹Kh˜G ðÓþ à` ðNú(` (÷Д L oð $h:F !0F GP¹Kh˜G ð»þ(h ð`ûÅø €áç ½èþ‰8°@ 4°@ 0°@ -éH
ò Fÿ÷[ÿK Fh˜GþÞ<°@ -é0H
ò LF#h3± Fð)þ±#h(F˜GðUþLM ¬BÒø¹Tø;±˜G¬BøÓÀ¹HðÿL MàTø;±˜G¬BùÓL#hC± Fðþ ±#h "! ˜G ½è0ˆþÞèú@ ±@ ±@ eL@ 8±@ $±@ ìú@ ´-éøO
ò oFFh $@FðßùF}¹v±Ùø 0 F˜G>hòè3 F³BÙoð ´ñÿ?êÑ(F½èð‹D°@ Äî@ -éxH
ò Fâh %ð+Ñô„Ð"h£hÖ .Ý ð‹ü¡h2Fðüãh°BÑð€Ð3ðàSð oð ã`£h(F#` #c`½èxˆ-éH
ò F ¹ ðøà Fÿ÷Åÿ±oð àãhô€OÐ F ðZüðäü (ñÑ ½èˆ ´-éþI
ò oFF½b &~` #»` ðù $<`*KhœB3Úßøœ€Øø 0Sø$1³Ëhðƒ"Ð Fÿ÷ÿøØø 0Sø$ ÃhðƒÐ-Ñÿ÷±ÿ°ñÿ?Ðs {` àU¹ðÐÿ÷¥ÿ°ñÿ?Ñoð »` ðø;h\ <`½j~hÇç ð
ø»j+Ñxh à¸h½èþ ]ø ûµ ðßø½µ8hKhSø ÿ÷òø½þÞ A û@ ÿ÷•¿ -éþI
ò oF %=` ð¨ø$|` Nßøl€Øø 0œB$Ú3hSø$ è±ÃhðƒÐðïü°ñÿ?Ð5=`,Û3hSø$0ñ Kh˜G3hSø$ ðø3h "Cø$ 4|`Öç ðø8h½èþ‰µ ð‹ø½H°@ û@ A -éH
ò €± KF !hKh˜G@¹Kh˜G ðûF ð'û`½èˆ8°@ L°@ ö@ -éðH
ò L
NO$%ch+Ñ;h0F&`Oôza6˜G4=òÑ ½èðˆP°@ Èî@ €â@ -éðK
ò LßøH€$&%FOð /h_±kh+ÐØø 08F˜G8Fÿ÷ÿÅø 5>îÑN$% h ±ch+Ñ3h˜G4=õѽèð‹H°@ €â@ -é0H
ò MFUø00+¹ ðø¹ ÿ÷1ýKUø4 h˜G½è0ˆ°@ €â@ KSø0 KhG °@ €â@ -éðH
ò oFF Kh;¹ð7ü ðhûÿ ÿ÷
üMUø60ë¹ ÿ÷2þF,¹ ð’ú #` à
ÿ÷¹ÿUø60 F;¹Oôza Kh˜GEø6@àÿ÷Aÿ ðø ½èðˆµKmKh˜G½þÞ °@ €â@ P°@ ö@ -é HëFHOô€r !ÿ÷¥úK"`½è ˆàú@ àù@ -éðO
ò ™°oF ÿ÷{ÿžL#h;±#{a£Iñˆ ðùû%á@! ÿ÷°ý8`8¹ #»a›Iñˆ ðëûá `ßø\‚ #Èø 0 %éC
"#hö ˜BÒq`Bq…`ø$03ð€ø$0[²ð€ø$0€ø% €ø& …c€ø4P@08`áçñ ‚Kh˜G·øR0 + ð‡€{m + ðƒ€ hñ Çø ë
Çø ¶õ oÛOô f$¼`Øø 0³B.Ú@! ÿ÷Yý8`0³jJBø$ Øø 0 3Èø 0
!Rø$0ö ˜BÒqoð `Aq…`ø$03ð€ø$0€ø%€ø&…c€ø4P@08`ãç4ÍçØø `¨F}`°E:ÚÚø °ñÿ?(Ðñ%Йø 0ð ÐðÑMKh˜Gȱ_êhð GIQø#0ë‚<`Úø 0#`™ø 0#qOôzañ @Kh˜G£h3£`ñÇø€ ñ Çø
ñ
Çø Âç6L}`ßøä€oð -TÚ#hë…<`#h³ñÿ?ÐñÐ#yoðC#q?àoð~#q¹oð à-Ñoð
àoð %Kh˜GF°ñÿ? Ðæ± Kh˜GÀ±&`ò+Ñ#ySð@à+Ñ#ySð#qOôzañ Kh˜G£h3£` à#ySð@#qÄø Øø 0±Sø%0Ãø5}`L¨ç ð ø àxi à¸i ¿°½èðµ ÿ÷Yþ½àù@ P°@ X°@ \°@ A T°@ àú@ *@ *@ -éH
ò LIH$h # " G± àoð ½èˆð@ '@ `°@ -éðO
ò ‡° Fõi4hŽF+h‘qh‚F´ë ð O‘Ð3ð De–ø(@ ±©ñ Úø@ðfQÑÖø$€Íø ’+h˜E€ð€ILë{h™E9Ó»h™E6Ò;i£³úh*ÐójRqF¨ðoú (0Û%ÝÚø 0>J“B Ñ#h;± FðNø±#h!PF˜G;iœ™"ðjú3j9i˜“si 0L “Úø 0$hRF Gð_ú+LÝøà™+hñ7˜E¼ÓGà Fà3iwj(h³ë‡B>Òëch™E1Ó£h™E.ÒÚø0ð ÐOð ±)FKh˜E
Ó‹h˜EÒ
i#išBÑÊhãhšBÐñ1†EìÓ™†EÑÝøà#i±˜EÐà{ sbâhójRqF ðú(h7™Ýøà4‡BÂÓ °½èðÈù@ d°@ csmà-éH
ò I " FTø;˜BÐ2-*øÓ°ñ+Ø
à°ñ¼+Ø à à Sø2 ½èˆþÞàã@ -é HëF ðoþ¹H à0½è ˆþÞHå@ -é HëF ðaþ¹H à 0½è ˆþÞLå@ -éH
ò Fÿ÷ëÿ` Fÿ÷µÿFÿ÷Öÿ`½èˆ K`pGþÞ ð@ ûÞ-éüK
ò LF F hLFˆF$h GFE±
œ3F:FAFHF ”¨G½èü‹ ûÞ °@ ð@ -é H
ò # " ! “ÿ÷×ÿ½è ˆ -é HëF@¹ÿ÷˜ÿ#`ÿ÷èÿoð à i½è ˆ-éðH
ò Fÿ÷éÿðeù¨³þ÷Füñ œBÑ %àþ÷>üñ@œB'Ñ%Jh3`ãhô† ÑOOô€VWø% h¹0Fÿ÷ ûGø% 8¹ñ£`#`#£ac`à ` `¦af`âhAòCã` à ½èðˆþÞ ð@ „î@ -éH
ò Fp±ãhô€_
ÐFÿ÷ûúãh3ôˆSã` #£a#`£`½èˆ -éH
ò ËhFð@Ћh›±Kh;K` +Û hp hÀ²3 `àð—û°ñÿ?Ñoð à#h3#`½èˆ-éøO
ò
Òø @ FÕø ð@FF‚FÐÒø@ ¹2hÒ2` à #+` /Ýù 2FAF?ÿ÷ºÿ3h³ñÿ?Ñ+h*+Ñ2FAF? ÿ÷®ÿ /êÜ+h ¹Åø ½èø -éðO
ò þ÷¨ýòx-™F #“ #
“ # FF¨F “““”– %Oð
þ÷Þüÿ÷´þÿ÷³ýê
(Àòòƒ–³óhð@-Ñ0Fÿ÷ÿßøHßøü°ñÿ?
ÐñÐCTø#0ð ë‚ à F“ø$0ðÑ°ñÿ? ÐñÐCTø#0ð ë‚‘ø$0ð€Ñœ4¹ÿ÷vþ#`ÿ÷Æþ¶ã”ù ` ' # !2F . ——“ 𩃛ßølçÝøH€“4” /Àòžƒ * Ûx*Üßø\7›ø <ð à #ëÃßøH[V
‘) òxƒßèð«.JMgÆ #“ # % “Oð !ê
#“Íø<à
‘^ã *Ð#*Ð+*
Ð-*Ð0*@ðWƒUðSãUðPãUðMãUð€JãUðGã**ÑÙñ ðKDñ Yø
‘ )€ò8ƒUðIB
‘2ã
ݑđC0;
“+ãOð
(ã**ÑÙñ ðKDñ Yø¬ºñ €òƒoð šFã
ëŠëC³ñ0
ãI*Ðh*Ðl*Ðw*@ðƒUô eã”ù 0l+Ñ4Uô€UúâUð÷âUð ôâ”ù 6*Ñ”ù04+Ñ4Uô Eèâ3*Ñ”ù02+Ñ45ô EÞâd* ðÜ‚i* ðÙ‚o* ðÖ‚u* ðÓ‚x* ðЂX* ðÍ‚ #
“ #𲩓ðÎùP±™ª0Fÿ÷Zþ”ù `4 . ðÀ‚™ª0Fÿ÷OþŸ˜ —¬â²ñA7) ò‚ßèðÝ 8 Ý Ý Š Se â = Mâ â â MÆ dQ OUôoÑUô eôoÐÙñ ðKDñ 9ø¯Uô€uñ8çUð@
$àOð
# à'#$ð€“Ð0"ø Q3" ’ø0à$ð€ÐUô uô O ÐÙñ ðKDñ Yø Yø<6àô€_ðÑð Ðð@
ÐÙñ ðKDñ 9ù Ã"àÙñ ðKDñ 9ø óçð@ ÐÙñ ðKDñ Yø FÛ àÙñ ðKDñ Yø #Íø0ð@ Ð + ÜÛ (Ò@BOð rëUô€uô OÑô€_Ñ3ðÿ3ºñ ÚOð
à5ðºõ ÝOô zPêÑ " ’ÝøL
òo(ºñ ªñ
ÜPêÐF Fá¹¹ùÞð
ÿ02“9* F ÝJDø)æç
òo#£ë Ýø0ñô б˜ù 00+Шñ0#ˆø 00› +@ðˆ€ð@Ðô€Ð-#àðÐ+#àðÐ #ø0# “
› šžŸð Ñ` %½` ,3Ü
Ð,Ð, Ð,9Ð,Ð/àßø`Øø ?àÿ÷øF½`¹oð àèmFQKhëA ëƒSh£BÐ 2rEùÓëA 냚BÒSh£B Ð "ñØø à,Ð,
Ð,Ðþ÷yù#`þ÷ÉùÒç`3Kh˜Gx`(Nй ý÷Àû± ý÷„þ,Ð ,Ð,Ð à+n;a (f,Ñkn{aŒ#kf,Ñ!L"hFú` N3h›™BÚëAëm나`1ù`"hñç Kh˜GÈø ð ø¼k,{hѽhin ˜Gà F˜G½h,Ð ,Ð,Ñ;i+f,Ñ{ikf °½èð ]ø ûµ;h± ý÷Kþ½$°@ ÌÁ@ ÈÁ@ °@ Tð@ ÀÁ@ -éˆH
ò oFþ÷Óÿƒo±˜Gð¼þþÞ -é HëFKHh˜GK`½è ˆþÞhð@ ]J@ $°@ -é HëF’°KhFh˜G ›ðнø0 à
°½è ˆþÞT°@ KhGþÞŒ°@ KhGþÞ°@ KhGþÞ”°@ KhGþÞ˜°@ KhGþÞœ°@ -éH
ò L#h +
Ú # “K !hFh˜Gz(Ñ# à ##` +Ý à ½èˆˆ°@ ¼ì@ ˆEöM#šBÐ pGÃkXDòPSšBöÑ
‹@ò šBñÑ pG -é0H
ò Ãk $“ŠÕˆ›ñ U±Âh‘BÓƒh›™BÓ4(0¬BôÓ ½è0ˆ½è0ˆ -é¸H
ò oFF@ò Àò@(Fÿ÷¿ÿ¹ 8`àa(Fÿ÷Íÿ¹ 8` àCjð OÑ à 8`à à8h½è¸ˆhhKšBÑ à pG À-éxH
ò LN
% h3h˜GDø =øѽèxˆ$°@ Àì@ -é0H
ò KM 3«BÒTø;±˜G¬BùÓ½è0ˆ,Ë@ (Ë@ -é0H
ò KM 3«BÒTø;±˜G¬BùÓ½è0ˆ4Ë@ 0Ë@ -éH
ò ! ý÷Fû KFh˜GK`K` ¹ à ##` ½èˆøú@ ôú@ $°@ -éøO
ò oFFý÷¨ø*Kh*Kh˜G€F%Kh'Kh˜GFÁE8Ó ë
ñ.2Ó@Fð‹ýF´B Ò°õ oÒFàOô c¡BÓ@Fý÷×ú8¹ñ¡BÓ@Fý÷Ïú°±_êª ëƒ Kh˜GK`(F Kh˜GÉø ñ Kh˜GK` à %=` ðø8h½èøµý÷[ø½øú@ $°@ ôú@ °@ -é HëFÿ÷™ÿ¹oð à ½è ˆ-éH
ò I " FTø;˜BÐ2*øÓ à Sø2 ½èˆþÞ°¿@ -épH
ò ü÷þò-Fÿ÷ÝÿF -~Ð ðù(VÐ ð ùYL¹Ôø(6+MÐü.nÐTJOôEq Fðú (@ðˆ€ #¤ø:2MKOô‚rñ2h ˜G@òû&8¹GJñ2 1Fðÿù (UÑñ2 ð%úC <+Ù°ñ;ñ2ëB ñ2:Jæëc#ðcù (DÑ5JOôEq Fð©ù (JÑ*FOôEq Fð¡ùà»,J+I FðÕü"à'Koð h˜GFܱ°ñÿ?Ð "©5ø;ST±2²õú÷Ó #¨ø2ü÷¢üF FL # “$h«© G
ò-ü÷ý½èpˆ # " ! “ý÷Òþ # " ! “ý÷Ëþ # " ! “ý÷Äþ # " ! “ý÷½þ # " ! “ý÷¶þþÞþÞ¤°@ \°@ àÀ@ ÔÀ@ ÌÀ@ œÀ@ °@ hÀ@ pð@ -é HëF ðDø(Ð ð?øH¹Kh+Ñü ÿ÷!ÿÿ ÿ÷ ÿ½è ˆ˜ö@ hK
hšBÑ i+ ÑJi KšB
ÐKšBÐKšBÐKšBÐ pGÿ÷C½þÞ @™"“!“ “csmà-é HëFHÿ÷hý ½è ˆþÞ¥O@ -é HëF (
Û(Ý(Ñ Kh àKh`àý÷þ#`ý÷`þoð F½è ˆþÞœö@ K`pGþÞ˜ö@ -é HëFKh˜GK`¹ à ½è ˆ ö@ ¨°@ -éðI
ò …°&Kh˜GFî³3ˆFà2ø?¹2ˆ +øÑ L“_$hOð { 2F ! Íø €Íø€Íø€Íø € GFÔ±ý÷]ùFµ±”L{ 2F$h ! Íø €Íø€ • G¹(Fý÷rú %K0Fh˜GàK0Fh˜G %(F°½èð‰þÞ´°@ °°@ ¬°@ -éøO
ò Ýø(šF #Éø 0#Êø 0FˆFF±Áø ñ '”ù "*ѹ' à 'Ö²àÙø 03Éø 0±#x+p5øk0Fÿ÷ÞúH±Ùø 03Éø 0±#x+p546± /ÙÑ .Ð .ÕÑ~¹ú\ ”ù 0 +óÑh !ü÷¸ÿßø€€F -Èø åЯ àYø$0™Z+x‚ø40Yø$0["šc’D á
ᜠ"Yø%0yð€ ðð€ % .FÑFF / ð
$
ñ@ Aòÿ>« "¦ë¹BÒ–ù 61
(Ñ p3522rEø îÓ‰H œ
ñ@ £ë Pø$ œ # “ Y…L
«JF$h©• G (Oð ðÀ
›šDKEÀò€¦ë»Bñ
Aòÿ>
ñ@ ÂÓ¶à.CÑFF / ðÄ€
$
ñ@ Aòþ>« "¦ë¹B
Ò0ˆ61
(Ñ €3522rE#ø ïÓeH œ
ñ@ £ë Pø$ œ # “ YaL
«JF$h©• G (Oð {Ð
›šDKE{Û¦ë»Bñ
Aòþ>
ñ@ ÅÓpàÁF / ð€€
$
ñ@@öUV
õ¢S "©ë¹BÒ¹ø 1 ñ
(Ñ €322²õÕo#ø íÓ "DL’’
õ¢R›$hëÓs[
õ¢R !OöéP–Íø à GF’ª³ &6H œ #©Pø$@˜ “
« X3L’‰$h G(±
›šö²BêÜà,Kh˜GšF²BÜ©ë
ºEOð
@öUV
ñ@©Óà$L h ’$h
«:FAF G±Ýø( %à Kh˜GFºñ &Ñu±-Ñü÷²ÿ #`ü÷¼ÿ#`›å(Fü÷Äÿ—åK šSø"0š›yð@Иù 0+?ôzü÷–ÿ #`ü÷ ÿ #â盪ë Aöð,åDû÷pþ½èðàù@ 8°@ ¤°@ °°@ Ì°@ È°@ \°@ ´-éøO
ò oF‘FŠFF¼bñÑü÷wÿ #`ü÷eÿ #`?àü÷bþ (;Û ,/Û#KhœB+Òe Nð Vø%0ëˆyð Ð FðÃÿVø%0ëˆyðÐJFQF Fÿ÷
ý8` àü÷8ÿ #`ü÷Bÿ #`ÛC;` ðø8h àü÷8ÿ #`ü÷&ÿ #`ü÷vÿoð ½èø]øûµ¸jðÒÿ½þÞàù@ àú@ ´-éøI
ò oFF³;p½±#+`à #L“«“@h$h #“#ª !– — G0±› +Ñѱ(` Ôç
Kh˜Gz(ÈÑ/±&±2F !8Fû÷[ûü÷û"#`ü÷cû" ÀçþÞ8°@ °°@ -é H
ò $ ”ÿ÷zÿ½è ˆKhSðKh“BÑ pG pG°÷@ ´ì@ -é0H
ò F ,NÐ(Màhëh˜BÐû÷¤ÿ i+i˜BÐû÷žÿ`iki˜BÐû÷˜ÿ i«i˜BÐû÷’ÿàiëi˜BÐû÷Œÿ j+j˜BÐû÷†ÿ`jkj˜BÐû÷€ÿ k«k˜BÐû÷zÿàkëk˜BÐû÷tÿ l+l˜BÐû÷nÿ`lkl˜BÐû÷hÿ l«l˜BÐû÷bÿàlël˜BÐû÷\ÿ½è0ˆðì@ -é0H
ò Fô±M h+h˜BÐû÷Kÿ`hkh˜BÐû÷Eÿ h«h˜BÐû÷?ÿ k+k˜BÐû÷9ÿ`kkk˜BÐû÷3ÿ½è0ˆþÞðì@ -éH
ò F , ð<`hû÷#ÿ hû÷ ÿàhû÷ ÿ iû÷ÿ`iû÷ÿ iû÷ÿ hû÷ÿ jû÷ÿ`jû÷ ÿ jû÷ÿàjû÷ÿ kû÷ÿ`kû÷ÿþàiû÷üþ kû÷ùþàkû÷öþ lû÷óþ`lû÷ðþ lû÷íþàlû÷êþ mû÷çþ`mû÷äþ mû÷áþàmû÷Þþ nû÷Ûþ`nû÷Øþ nû÷Õþànû÷Òþ oû÷Ïþ`oû÷Ìþ oû÷Éþàoû÷ÆþÔø€ û÷ÂþÔø„ û÷¾þÔøˆ û÷ºþÔøŒ û÷¶þÔø û÷²þÔø” û÷®þÔø˜ û÷ªþÔøœ û÷¦þÔø û÷¢þÔø¤ û÷žþÔø¨ û÷šþÔø¸ û÷–þÔø¼ û÷’þÔøÀ û÷ŽþÔøÄ û÷ŠþÔøÈ û÷†þÔøÌ û÷‚þÔø´ û÷~þÔøÔ û÷zþÔøØ û÷vþÔøÜ û÷rþÔøà û÷nþÔøä û÷jþÔøè û÷fþÔøÐ û÷bþÔøì û÷^þÔøð û÷ZþÔøô û÷VþÔøø û÷RþÔøü û÷NþÔø û÷JþÔøû÷FþÔøû÷BþÔø û÷>þÔøû÷:þÔøû÷6þÔøû÷2þÔø û÷.þÔø û÷*þÔø$û÷&þÔø(û÷"þÔø,û÷ þÔø0û÷þÔø4û÷þÔø8û÷þÔø<û÷þÔø@û÷
þÔøDû÷þÔøHû÷þÔøLû÷þýÔøPû÷úýÔøTû÷öýÔøXû÷òýÔø\û÷îýÔø`û÷êý½èˆ-éðO
ò ú÷úÿ„°oF‚°{` &×ø< :`¹`ºñ Ñ hÐø 8l± ! à!1L $h PF G€F¹ &OàMöÝY¸ñ &Ý#Û;˜E!ØñX °õ€oØà ƒBØoð3ðœ ðåÿë
ñ
ÐLöÌC+`àþ÷bþF -ÕÐÀø 5 à % -ÎÐ_êH !(Fû÷ùL{h:h$h!PFÍø€ • G8± L»kF$h¸h)F GFUøöѹ…ø 5 *Eјø 0 ±.ѵñ ÈF¡E Ó˜ø iFý÷Žø±¨ñ EõÒ©ëðÐø¬>à¶ñÿ? Ñ/Ùë¨ñ5F¦BÓ(xiFý÷qø±=¥B÷ÒsðÐø¬àãø¬P %à„ø û÷ãú"#`û÷3û" à++Û¯ >F§BÓ0xiFý÷Lø±>¦B÷Ò»ðÐø¬û÷Æú*#`* à ø 0 +?ôj¯šo3ðgcç-é?H
ò F F=¹û÷ú#`û÷ýú #à ,õÐ¥BùÒhFFú÷Çø™‹h ¹` àb :•BØx[[~ðöÑ£ðãX ø 0#±šo3ðg°½è0ˆ "ÿ÷Ç¿ -éðH
ò F ¹¹Ù» $@àÀ³¹³¹ #p÷ç*¹ #pû÷gú$(à '´ñÿ?F
F ц’ù 0³Tñk±=÷Ñ
à“Wø;±=Ð<÷ѹ7p -ÓÑ´ñÿ?ÑCø|P$àpû÷=ú"$`û÷úàû÷6ú#`û÷†ú$ F½èðˆ-é HëFý÷[ø± ý÷aøKhðÐ ûÞ ú÷üþÞLí@ ú÷ƒ¼ -é HëF@¹û÷ú#`û÷^úoð àKF !hKh˜G½è ˆä°@ ö@ -éðO
ò ú÷Ðøˆ°YKF‘h F˜GF %ý÷Fù\L‚F#hÓ»YKXHOô bh !˜GF / ð€NKQIh˜G ( ð†€HKh˜GIKKI `h8F˜GDKh˜GDKFI``h8F˜G?Kh˜G@K@I `h8F˜G;Kh˜G a@±:K9I8Fh˜G6Kh˜Gà`3Kh˜GX±¹ñ Ð.KHFh˜Gºñ
Ð Màºñ Ð'K hh˜G Dààh°B Ð#i³B Ð!Kh˜G K‚F ih˜GFºñ бÐGP±« “ #ª!¸G±›ðÑXô à`h°BÐKh˜Gh±€GFU± h°BÐ Kh˜GF±(F˜GFK hh˜GF,±šCFIF(F G à °ú÷0ø½èð °@ ì°@ è°@ $°@ ¤Ê@ ,°@ dÊ@ €Ê@ ”Ê@ XÊ@ @Ê@ „°@ °ù@ -éH
ò à±Ù±*¹ #pû÷!ù$à„’ù 0£Tñ ±9÷ÑA¹ #pû÷ù"$`û÷aùà $àû÷ù#`û÷Xù$ F½èˆ½ë„ îPO¤hÓ¤EÓë pG_ð ÷ç`´fFoó ¤õ€T%h´BúÑ`¼ë pG -éðH
ò †°FFF6±/±‘ù @4¹
± #+€ °½èðˆ¨Fù÷ôþ›Óø¨0k¹
±3x+€ ø0 +ìКo3ðgæç0x©þ÷öüౘCo+ÝŸBÛ
±" à "L@h’$h2F ! • G (˜ÑCoŸBÓ–ù0‹±@oÓç
±# à #˜ L“@h$h#2F ! • G (ÂÑû÷†ø*#`oð ¼çþÞ4°@ #ÿ÷—¿ ´-é H
ò L hñÑ ðÆú h°ñÿ?ÑOöÿp àL # “$h«"© G (òнø ½è ]ø ûþÞð°@ Pí@ -éðH
ò F ((Û Kh˜B$ÒNð EŸVø%0ûX³ñÿ?ÑKh+ÑH±(Ð( Ñoð àoð
àoð
K!Fh˜GVø%0 üPàû÷ ø #`û÷*ø #`ØC½èðˆþÞô°@ ˜ö@ àù@ àú@ -éxH
ò (1Û!Kh˜B-Ò Mð DžUø$0òyð!Ðh³ñÿ? ÐKh+ÑX±(Ð(
Ñ !oð à !oð
à !oð
Kh˜GUø$0oð òPàú÷Ôÿ #`ú÷Þÿ #`ØC½èxˆþÞô°@ ˜ö@ àù@ àú@ -éH
ò FñÑú÷Æÿ #`ú÷´ÿ #`!àú÷±þ ( Û ,ÛKhœB
ÒKað Sø!0ë‚yðÐh àú÷¥ÿ #`ú÷“ÿ #`ú÷ãÿoð ½èˆþÞàù@ àú@ ´-éH
ò oF8aAKð Sø!0ë‚£hƒ¹
ú÷ ü£hK¹Oôzañ Kh˜G£h3£` ðø:iQ Kð Sø!0ë‚ñ Kh˜G ½è]ø ûµ
ú÷•ü½°@ àù@ P°@ KAð Sø!0ë‚ñ KhGþÞ °@ àù@ -éðO
ò …°oFoð ©F=` #û` ú÷wü ( ð˜€ú÷"þ (Àò“€ ú÷Hü &ßøFF–ù *]Ð
*Ð*p56TàŽB
Òù?
+Ñ6
#+p5Hà*pûçZø) $h #Xø “«"©6 G ¹ßøX3h˜Gx»›k³Zø)0CDyðHÐù0™ßø8C
+×Ð
#+pZø)05ëø0Sqà½BÑù0
+Ñ
#
à˜# “oð oð þ÷Tÿù0
+Ð
#+p5»L™›žBžÓàZø)0ëyð@ÑSðqà3x+p5›î+dÑ .bÐø=ð€Ñ5?à¬J!à)ܽBÓ=+x1›V +õÐ(xƒV¹ú÷=û*#$á3‹BÑm&àZø)0ëyðHÐ5)PqÛZø)0ë+x5‚ø%0)ÑZø)0ë+x5‚ø&0mà˜#JB “Óþ÷ëþ ›ŠLí[“›$h:F “+F !OöéP GF .?ôè®®BÐ" à "Zø)0v CDcoð›ŸBÐ8Fù÷¯ÿñ ðæ€&Fãà›S³ëÖs[ëC§B9F:F Ò¥ ˆ(Ð
( ѪB
ÒSˆ
+Ñ
# €21à€12¢BëÓàZø)0ëySðqË[^ Äç*±;ˆ
+ÑPðà0𺒗B q=F¸F€ðƒ€‘ UL
ž‘F¸ø *jÐ
*Ð*€5ñ`àˆE Ò8ø?
+Ññ
#+€5Sà*€ûçZø) $h #0X “«"
ñ
ñ G¹?Kh˜Gл›Ã³Zø)0›yðH нø
0™8L
+ØÐ
#+€Zø)05òø
0SqZø)0òø 0‚ø%0Zø)0›
"ƒø& à½Bѽø
0
+Ñ
#
à˜# “oð oðþ÷ þ½ø
0
+Ð
#+€5 L™›˜E‘ÓàZø)0òyð@ÑSðqà¸ø 0+€5î.çKh˜G(Ñú÷ú #`ú÷%ú#`æm(ô ® $ ç & àú÷ú #`ú÷ú #`ú÷Wúoð 0F °½èðþÞ8°@ ±@ 4°@ Xí@ ±@ È°@ àù@ àú@ ´-éøO
ò oFFŠFF¼bñÑú÷ëù #`ú÷Ùù #`Làú÷Öø (HÛ ,<Û)KhœB8Òfßø˜€ð Xø&0ë‰yð+Ðoð CBÙú÷Çù #`ú÷µù#&à Fÿ÷*úXø&0ë‰yðÐ*FQF Fÿ÷ü8` àú÷Ÿù #`ú÷©ù #`ÛC;` ðø8h àú÷Ÿù #`ú÷ù #`ú÷Ýùoð ½èø]øûµ¸jÿ÷9ú½àù@ àú@ -é HëF@¹ú÷tù#`ú÷Äùoð àù 0 +òÐ )ðÐ h +íГù 0 +éÐ " ðû½è ˆ -éðI
ò ° FFF€Fü÷ø`± L H$h GLI$h GF ¹oð #àœü÷œø (@F9FÐ#“›2F
•“›“ # “ “« “› G à #š“›LC“›$h2F “+F G
°½èð‰ü°@ ÌÊ@ ,°@ ØÊ@ ±@ -éðO
ò ‘° F #
““ #“ #“ ’ F &ù÷ÿÿ (ÚóC#`ùàð€Ð #Oðà#Oð
¨“ ð^ü (@ðã‚ô O Ñôè/Ñ
›³õ OÐoðSêOúƒøð Ð+Ð+ Ðú÷Üø #`ÛC#`ú÷Èø#`ú÷ùâOð@I
àðÐôà/öÑOð€IàOð I›+Ð +Ð0+
Ð@+Ѐ+Ùѹñ OÑ!à!à! à !ôàc³õ€o‘Ü
Ðc±³õ€Ð³õ %гõ@¾Ñ'
à' à' à³õ oгõÀoгõào¯Ñ'€#Oð
“ô€Ðßø5h›3êð€Ñ#“à'êç€#ð@ÐYô€9Qð‘Oð€jô€_ÐSô€s“ô _ÐZð zð ÐZð jàðÐZð€Zÿ÷ù `°ñÿ? Ñú÷Oø #`ÛC#`ú÷;ø#ià ›" ˜`›šIF“«Íø —ÿ÷ÑþF “°ñÿ?1Ñð@C³ñ@OÑðЛš ˜9ð I“«IFÍø —ÿ÷·þF “°ñÿ?Ñ"hßø$4QSø!0ð ë‚y3ðqßø 4h˜Gú÷øù÷öÿhëáFßøü3h˜G »"hßøè3QSø!0ð ë‚y3ðqßøÄ3h˜GFù÷õÿßø¼3 ˜h˜G ,ÙÑù÷Ðÿ
#`Ôç(ÑXð@à(ÑXðOúƒø h ™þ÷lÿ#hßøˆãXð Yð ^ø!0ë‚q#hYð ^ø!0Oðë‚’ø$03ð‚ø$0ðH
“>Ñð€;Ð
B9Ð hoð oð ‘þ÷kûF “ @³ñÿ?ˆFÑù÷”ÿhƒ+#Ð hÿ÷(ù†ç h #©"ø0ÿ÷úX¹½ø0+Ñ h šCF ðõú°ñÿ?æÐ h # " “þ÷@ûê³ñÿ?ÛИ!ð€ ðÝ€ôè/Ñ
›ôè#ÑUô€E à Côè#³õ€O гõ€?гõ ?гõ ?гõ?гõ€/гõˆ/ÑOðà@ò2ê“BÑOðÍø€àOð ùçOð ôà/ 𤀠#“ð@@ðž€ð@C³ñ€Ojгñ O0гñ@O@ð’€ / ð€/Ù/Ù/@ðˆ€ '¸ñpиñ@ð€€OöÿcOðjà h # " ‘þ÷ÍúPêéÐ h ' # " —þ÷Ãúê³ñÿ?Ñ]ç ' h©"ÿ÷åù°ñÿ??ôT¯š(Ð(%ÑmKšBÑ#“Oà’²OöþsšBÑ hÿ÷løù÷Âþ#`&µàOöÿcšB
Ñ h #" —þ÷úê³ñÿ??ô+¯#Ýç —àg³/¢Ù/Ø h # " ‘þ÷{úPê—Ð # “ h # "þ÷qúê³ñÿ?Ñ çLKOð“« h¨ëùü÷ ÿ°ñÿ??ôý®?¸E«ñÜ#hAOYð Wø!0ë‚‘ø$0šS@ð‘ø$0S@ø$0ô€?Ñ à #hYð Wø!0ë‚’ø$0ðCêÀ‚ø$0
›s¹ð Ð#hXð Wø 0ë ySð qð@C³ñ@O3Ñð0Ð K ˜h˜G›š ˜“# “«9ð AÍø ÿ÷Îü°ñÿ?ÑKh˜Gù÷<þ#hYð Wø!0ë‚y3ðq hþ÷þæ#hYð šWø!0˜P0F°½èð # " ! “ù÷1þþÞ8°@ ø°@ àù@  X°@ ¤î@ -épH
ò …°FF FE¹ù÷åý#`ù÷5þoð à ,ôЫª1F F • ð#ú°ñÿ?ðЛš)F ðÜûF˜ù÷Œú˜ù÷‰ú F°½èpˆ -éðO
ò ‡°F‘F’ˆFFG¹ù÷³ý#`ù÷þoð ™à—ù 0 +òиñ ïÐØø 0 +ëГù 0 +çÐ\!8F ðñüF8F/! ðìü » »:!8F ð*ýFî¹8Fø÷wûFà !ù÷öøF -ÑÐIJá þ÷Qü (sÑ:Fá (F ðý (eÑ® à±°B ÙF.!0Foð ðÀü ((F Ð ! ð:ý (HÑJFAF(Fÿ÷kÿFAàø÷Eûñ
PF!ù÷ÃøFæ³*FQFþ÷ ü (OÑ(Fø÷4ûƒ“ù÷Býh˜Oð “&Kªë ‘ñ
Zø)‰þ÷ü€» !0F ðý8±©ñ ˜™¹ñ íÚ àù÷"ý›šAF`0Fÿ÷+ÿF0Fù÷Ûù½BÐ(Fù÷Öù F°½èð # " ! “ù÷;ý # " ! “ù÷4ý # " ! “ù÷-ý # " ! “ù÷&ýþÞþÞXî@ Ë@ -éðH
ò ,MDð Uø$0±õ€O높ø$0yCó-бõ O&бõ€?бõ ?бõ€//ÑoðCqUø$0높ø$03ð~Sð àoðCqUø$0높ø$03ð}Sðàðq
àoðCqUø$0높ø$03ð‚ø$0ð€ÑOô @à¹Oô€@àOô€0½èðˆàù@ -é HëF8¹ù÷†ü#`ù÷Öü àKh` ½è ˆÄù@ -éðO
ò …°™F# “’F # "F %Oð þ÷Cøê´ñÿ?‘$Ð# “ # "8Fþ÷5øê³ñÿ?кë ië # .TÛÜ ,LÐIKh˜GIKOô€R!h˜G‚FH¹ù÷=ü #`ù÷9ü h°½èðOô A8Fÿ÷DÿF .ÛÜ´õ€_ÓOô€R à"FQF8Fü÷ïù°ñÿ?Ð$fëàv .ÛèÜd±æçù÷"üh+Ñù÷ü
#`oð ¨FIF8Fÿ÷ÿ'Kh˜G%KRF !h˜G,à .0ÜÛ ,-Ò “KFRF8Fý÷Îÿê³ñÿ?±Ð8Fþ÷(üKh˜G± %àoð _êåxê³ñÿ?Ñù÷Ùû
#`
Kh˜GFù÷ßû`ê³ñÿ?Ð #š “›8Fý÷ ÿê³ñÿ?ƒÐ „çþÞ8°@ ±@ L°@ ¨°@ h°@ -éðO
ò ø÷ˆúŽ°ßøpC FF hF ’
`h "% ‰“—ø0 zFø2 h’’ F•@±ø÷|ùCTø] (÷Ñ•!(Fø÷õþÈø `¹ #;`ù÷|û #`ù÷†û#`oð Cá
ª¨ ! ðžû(±( ðAßøè¢'à
¨ø÷Rùñ ˜±ø÷LùDßøТ % . ð‹€0h'4F—@±ø÷>ùÃTø_ (÷Ñ—Úø @¤¹û÷XýFÊø t¹ŸØø oð ’ø÷üÿ %šœÈø P=`ôà”ù 0 '[±[² F=+Ðø÷ùÃ_ ãWà +õÑãW¸F—=+ Ñâ’ù0³±’ù0:+Ñ’ù0=+Ñë ø÷ùø ëñù0ë=+åÐÍø€š¨ë°Fœ3h” à
¨ø÷âøFØø
© ðúûè±Xø? +ñÑLD! Fø÷Vþ›`ع œ hø÷¡ÿ ##`ù÷Ùú #`ù÷ãú#`šoð ’à#“ãç›=`Ÿ“›“àÝø$€›Øø @h
¹4à™# FÉþ÷Šù (@ð´€›Sø “ø÷›ø\ ›hàØø 0™ FÉþ÷tù (@ð‚€›hø÷‡ø$ #ø;›Sø/“ *æÑÝø€ø\%pØø @þ³Ýø€Úø 0 F¨ëÙý÷5ûãë3hÝø€›±ŸØø 02h FÙþ÷Aù (VÑ0hø÷Vø\ Vø? +ìћù
ªIF Fþ÷/ù (RÑ1JIF F ðôù (DÑš2±IF F ðìù ±'àšLD àš<±Øø 0œBÑ%p4%pš $Úø ±ø÷ûþš #Êø 0±Fø÷óþ F°ø÷ù½èð # " ! “ù÷Vú # " ! •ù÷Oú # " ! •ù÷Hú # " ! •ù÷Aú # " ! •ù÷:ú # " ! •ù÷3ú # " ! •ù÷,úþÞþÞ$Ë@ ¼î@ Ë@ -éðO
ò Ÿ°FOð
Oð “‘F±.Ð Ý.Ý.ÑOð ’ù 0’Ó± ! àù÷àù #`ù÷Îù#`ù÷ úÃà2’ù 0 +úÑ’ù0 ±p2’ù 0 +òѨD" !ø÷üùD#“ù÷´ø (Àòª€`Kßøx hŒ±a KXø#0ð ë‚“ù0¹<9 ,ñÑ ,Àò€Cò23œB€ðŠ€ë„3˜²!øj ø÷üü (}Ð`šOð ! ê ,ÝKXø#0ð ë‚yðÑph;`à€ø à=`107¡BèÛš¹ñ Ð ! ,Ú#F à#™BÚ øëBø[1òçOð
ù÷Yù
«“«“›)L "“™$h#`˜ “’ # "Íø G!KFh˜GF˜ø÷óý ¹8Fù÷Gù&à.(Ð~¹K
˜)Fh˜GK
˜ ©h˜GK
˜ h˜Gà.Ñ
K
˜h˜G % à
K ˜h˜Gàù÷ù #`oð (F °½èð ø÷bûþÞþÞø°@ °@ °@ 8°@ °@ àù@ àú@ -épH
ò …°FFhFF %÷÷ÿ4¹ù÷Ýø#`ù÷-ù"à˜ƒh+¹1F F ðáùFà"xPú‚ó[~Fð
Ð4"x*±Bê#žBÑe à - à–B Ñ%F *ñåÑø 0#±šo3ðg(F°½èpˆ "ÿ÷¹¿ -é?H
ò
FFhFF÷÷Âþ4¹ù÷—ø#`ù÷çø à˜ƒh»¹)F F ðµùFàPú‚ó[~ðÐ4#xs±Cê#BÑ< àBÐ4"x *FéÑ•B Ð $ø 0#±šo3ðg F°½è0ˆ "ÿ÷½¿ -éH
ò F±±\¹ #pù÷Tø#`ù÷¤ø$ F½èˆF’ù 0±29ùÑ)¹ #pù÷@ø$à”ù 0Uñ ±9÷ÑA¹ #pù÷0ø"$`ù÷€øÛç $Ùç -éH
ò F FK±iFFø÷3ù¹ù÷øhà ˜!F ðNùF ˜ø÷Òü F½èˆ -éðH
ò KMFh,h ³<¹Khë± ðzùй,hı¿±8F÷÷áý%hFà(F÷÷Ûý°BÙ«W=+Ñ2F9F(F ðú0±Tø_ -íÑ ½èðˆ#h›X ùçþÞ˜î@ ”î@ üú@ -éüK
ò oF‚°F FF ø÷òü=¹ø÷Áÿ#`ù÷ø#.àOð Åø ±Äø .îÐ0Fÿ÷¥ÿ€Fø±÷÷™ýF !0F÷÷œý(`8¹ø÷¢ÿ #`ø÷žÿhàBF1Fý÷lþ8±Íø # " ! ø÷Ãÿ±&` #;` ðø8h àxh°½èð‹ µ ø÷Çü ½-éÿH
ò FFF¹ |àhFF÷÷˜ý™‹h+¹:F1F(F ðìùgà±F¹ø÷cÿ#`ø÷³ÿoð @\àø+?Qú‚ó[~ðÐ+x ¹ "àCê"‹‰5šBÓˉšBØ ŠàKŠšB
Ó‹ŠšB
ØËŠ›š²àPC~ðÐø!ø Qú€ó[~ðÐ3x ¹ àCê ‹‰6˜BÓˉ˜BØ ŠàKŠ˜B
Ó‹Š˜B
ØËŠ˜²àDc~ðДø‚BÑ
± /©Ñ àÙ àoð ø 0#±šo3ðg°½èðˆ #ÿ÷s¿ -éH
ò Fù; +ûÑJ²8 BÐù 0“BøÑù 0J²“B Ð ½èˆ ù 0;±J²“BÐ0ù 0 +øÑù 0J²“B Ð pG-éH
ò ÷÷šýŠ° FX¹ø÷Çþ #`ø÷µþ#`ø÷ÿ %à4ððÑKjF !h˜G@¹Kh˜Gø÷½þø÷Ÿþ hà ›ðÑð ÐðÐø÷Ÿþ#`ø÷þ
#`èç
°÷÷ný½èˆ8°@ ±@ -éðO
ò …° #“$K h2hʳ!OOð ê ¸FOð
Ø RØ ^Ø rØ ˆØ ˜Ø ¨Ø ¶Ø ÒØ âØ îØ Ù Ù *Ù Ù@ ED@ ‘L@ íO@
E@ 5@ 9@ %s %s failed to create process.
failed to get exit code from process.
-script.pyw Cannot open %s
#! #!python.exe Cannot find Python executable %s
Could not exec %s m s c o r e e . d l l CorExitProcess (null) ( n u l l ) EEE50 P ( 8PX 700WP `h```` xpxxxx Sun Mon Tue Wed Thu Fri Sat Sunday Monday Tuesday Wednesday Thursday Friday Saturday Jan Feb Mar Apr May Jun Jul Aug Sep Oct Nov Dec January February March April June July August September October November December AM PM MM/dd/yy dddd, MMMM dd, yyyy HH:mm:ss S u n M o n T u e W e d T h u F r i S a t S u n d a y M o n d a y T u e s d a y W e d n e s d a y T h u r s d a y F r i d a y S a t u r d a y J a n F e b M a r A p r M a y J u n J u l A u g S e p O c t N o v D e c J a n u a r y F e b r u a r y M a r c h A p r i l J u n e J u l y A u g u s t S e p t e m b e r O c t o b e r N o v e m b e r D e c e m b e r A M P M M M / d d / y y d d d d , M M M M d d , y y y y H H : m m : s s e n - U S j a - J P z h - C N k o - K R z h - T W ¶@ ¶@ ¶@ ,¶@
!"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ R 6 0 0 2
- f l o a t i n g p o i n t s u p p o r t n o t l o a d e d
R 6 0 0 8
- n o t e n o u g h s p a c e f o r a r g u m e n t s
R 6 0 0 9
- n o t e n o u g h s p a c e f o r e n v i r o n m e n t
R 6 0 1 0
- a b o r t ( ) h a s b e e n c a l l e d
R 6 0 1 6
- n o t e n o u g h s p a c e f o r t h r e a d d a t a
R 6 0 1 7
- u n e x p e c t e d m u l t i t h r e a d l o c k e r r o r
R 6 0 1 8
- u n e x p e c t e d h e a p e r r o r
R 6 0 1 9
- u n a b l e t o o p e n c o n s o l e d e v i c e
R 6 0 2 4
- n o t e n o u g h s p a c e f o r _ o n e x i t / a t e x i t t a b l e
R 6 0 2 5
- p u r e v i r t u a l f u n c t i o n c a l l
R 6 0 2 6
- n o t e n o u g h s p a c e f o r s t d i o i n i t i a l i z a t i o n
R 6 0 2 7
- n o t e n o u g h s p a c e f o r l o w i o i n i t i a l i z a t i o n
R 6 0 2 8
- u n a b l e t o i n i t i a l i z e h e a p
R 6 0 3 0
- C R T n o t i n i t i a l i z e d
R 6 0 3 1
- A t t e m p t t o i n i t i a l i z e t h e C R T m o r e t h a n o n c e .
T h i s i n d i c a t e s a b u g i n y o u r a p p l i c a t i o n .
R 6 0 3 2
- n o t e n o u g h s p a c e f o r l o c a l e i n f o r m a t i o n
R 6 0 3 3
- A t t e m p t t o u s e M S I L c o d e f r o m t h i s a s s e m b l y d u r i n g n a t i v e c o d e i n i t i a l i z a t i o n
T h i s i n d i c a t e s a b u g i n y o u r a p p l i c a t i o n . I t i s m o s t l i k e l y t h e r e s u l t o f c a l l i n g a n M S I L - c o m p i l e d ( / c l r ) f u n c t i o n f r o m a n a t i v e c o n s t r u c t o r o r f r o m D l l M a i n .
R 6 0 3 4
- i n c o n s i s t e n t o n e x i t b e g i n - e n d v a r i a b l e s
D O M A I N e r r o r
S I N G e r r o r
T L O S S e r r o r
r u n t i m e e r r o r ȶ@ (·@ €·@
Ø·@ ¸@ x¸@ ظ@ ¹@ x¹@ è¹@ 8º@ ¨º@ »@ d»@ ¨»@ p¼@ ! ؼ@ " Ⱦ@ x 0¿@ y P¿@ z l¿@ ü ˆ¿@ ÿ ¿@ R u n t i m e E r r o r !
P r o g r a m : < p r o g r a m n a m e u n k n o w n > . . .
M i c r o s o f t V i s u a l C + + R u n t i m e L i b r a r y À À – À À Ž À À À ‘ À ’ À “ À ´ À µ À €€†€€ †€†‚€EEE……… 00€P€ˆ ('8PW€ 700PPˆ (€ˆ€€ `h`hhhxppwpp ( ( ( ( ( H „ „ „ „ „ „ „ „ „ „ ‚ ‚ ‚ ‚ ‚ ‚ h ( ( ( ( H „ „ „ „ „ „ „ „ „ „ ‚‚‚‚‚‚ H €‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ ¡¢£¤¥¦§¨©ª«¬®¯°±²³´µ¶·¸¹º»¼½¾¿ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖ×ØÙÚÛÜÝÞßàáâãäåæçèéêëìíîïðñòóôõö÷øùúûüýþÿ
!"#$%&'()*+,-./0123456789:;<=>?@abcdefghijklmnopqrstuvwxyz[\]^_`abcdefghijklmnopqrstuvwxyz{|}~€‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ ¡¢£¤¥¦§¨©ª«¬®¯°±²³´µ¶·¸¹º»¼½¾¿ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖ×ØÙÚÛÜÝÞßàáâãäåæçèéêëìíîïðñòóôõö÷øùúûüýþÿ€‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ ¡¢£¤¥¦§¨©ª«¬®¯°±²³´µ¶·¸¹º»¼½¾¿ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖ×ØÙÚÛÜÝÞßàáâãäåæçèéêëìíîïðñòóôõö÷øùúûüýþÿ
!"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`ABCDEFGHIJKLMNOPQRSTUVWXYZ{|}~€‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ ¡¢£¤¥¦§¨©ª«¬®¯°±²³´µ¶·¸¹º»¼½¾¿ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖ×ØÙÚÛÜÝÞßàáâãäåæçèéêëìíîïðñòóôõö÷øùúûüýþÿÀ÷@ ø@ U S E R 3 2 . D L L MessageBoxW GetUserObjectInformationW GetLastActivePopup GetActiveWindow GetProcessWindowStation C O N O U T $ CreateFile2 k e r n e l 3 2 . d l l .cmd .bat .exe .com .\ SystemRoot = m !Y àj àéèÕÿ M ñÿÿÿ c €; à_ àb à Ôÿ î "K à– àß àê àè‚èßÿ M Ùÿÿÿ p 03Çü¨¾ÿïÿ }* m € àÿýÿ À à ýÿ € àÄÔÿÄ ýÿy 03Çü¯øÿïÿ }* í Ç ‚ Çü©þÿ }* Ñ! -" I" /" U 03Çü©þÿïÿ }* ¯$ ë$ % ‡$ û$ % = Çü©þÿ }* U% ±% »% 6 Çü¨ðÿ }* 3' O' Y' A°!Çüßÿ }* ¯' * * '°3èžèüßÿèßÿ M Ùÿÿÿ: 03Çü¨ÿïÿ }* 8 8 )8 ç7 ÿ7 38 b 03Çü¨ÿïÿ }* ×8 û8
9 §8 Í8 9 ( Çü¨œÿ }* ·= Å= Ù= § 0DéLèü¨pÿè¨pÿ M éÿÿÿ G Çü¨¸ÿ }* @ _@ s@ Ê °3èü«ðÿè«ðÿM ÝÿÿÿÇ Çü«üÿ }* _C ùC 'D Çü¨¸ÿ }* 'E 1E 9E š "ü¨üÿïÿ íÿ » °3Çü©ðÿ‰ðïÿ}* I ÷I 7J
Çü¨ˆÿ }* oJ qJ qJ ' Çü¨¸ÿ }* ¹K ñK ûK ñK V Çü¯øÿ }* ÝL oM yM · @ àè‚èü¨pÿè¨pÿ M éÿÿÿ¬0Uù¼üüèüßÿ÷¼èßÿ M Ùÿÿÿ\ 03Çü¯øÿïÿ }* ·] é] ^ \ 03Çü©øÿïÿ }* {^ ½^ Ý^ ) 03Çü¨¸ÿïÿ }* “_ ›_ «_ lû¨ ÿ € àü¯øÿ¯øÿÿ € àü¯øÿ¯øÿÿ € àìÿýÿ O € M àü¨ðÿ¨ðÿÿe € c àü¨ðÿ¨ðÿÿ y €0C à
ü¨ðÿˆðïÿ | °3ÇèüßÿèßÿM Ùÿÿÿ 0§ àÇèüßÿèßÿM Ùÿÿÿb 17 à] àüÛüÿÛüýÿÛüýÿh A; àc à
üÛüûûÿÛüýÿÛüýÿ ÿ h 03ÇüßÿÛïÿ }* ít %u Qu ¼ €! àüßÿ ´ 03èüßÿèßÿ M Ùÿÿÿ À
à ýÿ
€ àì`ÿì`üýÿ c € àü¨ðÿ # "ü¨ ÿïÿ 5 03Çü¨ÿïÿ }* e} }} §} ® °!Çüßÿ }* O~ g~ G ~ / = U 03Çü©øÿïÿ }* —€ ¿€ ç€ > 03Çü¨ÿÿˆðïÿ }* ï ‚ )‚ i 03Çü¯øÿïÿ }* éˆ ‰ C‰ €
àüßÿ Ï €° àüßÿ » €A àüßÿ »0…àèüßÿèßÿ M Ùÿÿÿ õ €ï à üßÿ M °"Çü«üÿ«ðÿ}* Áœ 3 C @ °3
èü¨ÿè¨ÿM ñÿÿÿN €H àüßÿ K€k àüßÿ P°3Ç èüßÿ èßÿM ÙÿÿÿÓ ÄØ ° $Ô @Ô RÔ jÔ €Ô –Ô ¬Ô ÄÔ ÜÔ ìÔ üÔ Õ $Õ 6Õ LÕ \Õ jÕ |Õ „Õ œÕ ¨Õ ÐÕ âÕ ðÕ Ö Ö $Ö 0Ö FÖ VÖ bÖ nÖ xÖ ŠÖ œÖ ²Ö ÐÖ ÜÖ æÖ ôÖ × × $× 6× P× f× €× š× ´× Æ× Ô× æ× ö×
Ø Ø .Ø >Ø RØ ^Ø rØ ˆØ ˜Ø ¨Ø ¶Ø ÒØ âØ îØ Ù Ù *Ù ¼GenerateConsoleCtrlEvent ë CreateProcessA ÏSetConsoleCtrlHandler CGetExitCodeProcess ¹WaitForSingleObject yGetModuleFileNameA ?EnterCriticalSection ³LeaveCriticalSection DecodePointer ;EncodePointer }GetModuleHandleExW ²GetProcAddress , AreFileApisANSI áMultiByteToWideChar gGetLastError lExitProcess áGetCommandLineA ]Sleep DeleteCriticalSection MHeapFree bInitializeCriticalSectionAndSpinCount ÔGetStartupInfoW UGetFileType ÚGetStdHandle ]InitOnceExecuteOnce ¹RtlUnwindEx IHeapAlloc 'GetCurrentThreadId SetLastError ÌGetCPInfo GetOEMCP ½GetACP ƒIsValidCodePage ¸LoadLibraryExW GetCurrentPackageId OSetUnhandledExceptionFilter §FlsAlloc ¨FlsFree ©FlsGetValue ªFlsSetValue zGetModuleFileNameW ïWriteFile ·GetProcessHeap >GetEnvironmentStringsW ÛWideCharToMultiByte ¶FreeEnvironmentStringsW 1QueryPerformanceCounter ñGetSystemTimeAsFileTime GetTickCount64 PHeapReAlloc GetConsoleMode õGetConsoleCP ¬FlushFileBuffers ßGetStringTypeW ¥ CompareStringEx ¦LCMapStringEx SetFilePointerEx RHeapSize yIsDebuggerPresent
OutputDebugStringW îWriteConsoleW .SetStdHandle Ž CloseHandle Ö CreateFileW KERNEL32.dll KReadConsoleW MReadFile ~GetModuleHandleW öSetEndOfFile IGetFileAttributesExW ùSetEnvironmentVariableA û@ û@ ÿÿÿÿ€
!
5 A
C P R
S
W Y l
m p r €
‚ ƒ „
‘ ) ž
¡ ¤ §
· Î × 4²@ <²@ ÿÿÿÿþÿÿÿC ¬²@ °²@ ´²@ ¸²@ ¼²@ À²@ IJ@ Ȳ@ в@ ز@ à²@ ì²@ ø²@ ³@ ³@ ³@ ³@ ³@ ³@ ³@ $³@ (³@ ,³@ 0³@ 4³@ 8³@ <³@ D³@ P³@ X³@ ³@ `³@ h³@ p³@ x³@ „³@ Œ³@ ˜³@ ¤³@ ¨³@ ¬³@ ¸³@ ̳@ س@ à³@ è³@ ð³@ ø³@ ´@ ´@ ´@ ´@ 0´@ @´@ T´@ h´@ x´@ Œ´@ ”´@ œ´@ ¤´@ ¬´@ ´´@ ¼´@ Ä´@ Ì´@ Ô´@ Ü´@ ä´@ ì´@ ü´@ µ@ µ@ ¬´@ (µ@ 4µ@ @µ@ Pµ@ dµ@ tµ@ ˆµ@ œµ@ ¤µ@ ¬µ@ Àµ@ èµ@ üµ@ `å@ `å@ `å@ `å@ `å@ ðì@ 0Ã@ ¸Ç@ 8É@ hå@ Ðæ@ ˆè@ ¤ `‚y‚! ¦ß ¡¥ Ÿàü @~€ü ¨ Á£Ú£ þ @þ µ Á£Ú£ þ Aþ ¶ Ï¢ä¢ å¢è¢[ þ @~¡þ Q QÚ^Ú _ÚjÚ2 ÓØÞàù 1~þ abcdefghijklmnopqrstuvwxyz ABCDEFGHIJKLMNOPQRSTUVWXYZ abcdefghijklmnopqrstuvwxyz ABCDEFGHIJKLMNOPQRSTUVWXYZ 4Å@ Næ@»±¿Dÿÿÿÿx@ x@ x@ x@ x@ x@ x@ x@ x@ x@ . . èì@ ¸÷@ ¸÷@ ¸÷@ ¸÷@ ¸÷@ ¸÷@ ¸÷@ ¸÷@ ¸÷@ ìì@ ¼÷@ ¼÷@ ¼÷@ ¼÷@ ¼÷@ ¼÷@ ¼÷@ ðì@ 0Ã@ 2Å@ þÿÿÿ ôÊ@ üÊ@ Ë@ Ë@ aý ñaý… aý
8Ë é M` ý XË Ù pË Ù ©`1 9 Q`0ýi y`0ý Y`0ý1 ˜Ë ` 5 ]`0ýe i`0ý™ í`1 Á p… õ€1 ÀË ÌË 5 ØË M I`? q åc¶ýe ³µ A`°ýA Ua2ýí ]`0ý= q`0ýy Ia´ý) 1`0ýE å`1 Õ èË Ç ` %! A`0ýE! Ì I" ` m" %`? " `6ýÙ" •`5 -# •`5 # ‰`5 Í# ¹`2ý)$ }`0ýi$ 8Ì % ` % %` A% pÌ »% ` Ñ% a`0ý
& a`3 I& ©`5 ¥& Y`1 í& ˜Ì Y' ` y' 9`? ' ÀÌ * ` M* I`0ý}* ñö, …`0ýI, -`? e, -`? , E`0ýµ, i`uýñ, 5`ý
- A`? --
a3 ½- ]`0ýí- ‘`0ý5. Ù`6ý¥. èÌ
7 é`4ý7 I`0ýµ7 Í )8 ` 38 ` I8 8Í
9 ` 9 ` 19 Å`2ý¥9 ½`1 : 9`0ý-:
b2ý9; b2ýI< Ýa4ýE= }`1 ‰= pÍ Ù= ` )> Å`0ý‘> ˜Í å? ¸Í s@ ` …@ Å põ@ àÍ ™B øÍ 'D ` ED A`0ýiD Iò
E Î 9E ` ME HÎ F TÎ ÉF )`°ýÝF © r=G 5`0ýYG Ýa3 UH Q`0ýÁH `Î 7J ` ]J ˆÎ yJ -`? J M ¿K q`0ýqK u`1 K °Î L A`2ý9L I`1 eL I`1 ‘L a`0ýÍL ØÎ yM ` ‘M 1`? ©M U`0ýÙM Ï qO a`? íO %`? P m`? MP 9`? qP 5tQ Uc6ýÅR 5r}S auýMT ¡`1 ©T Ùa3 ¹U Ý 1IV ½`3 ©V =a6ýYW ý`5 åW Ï Y] @Ï ^ ` %^ hÏ Ý^ ` ù^ ½`3 Y_ Ï «_ ` µ_ ¸Ï Õ_ ÄÏ é_ ÔÏ ý_ äÏ ` ½`0ý]c ôÏ ýc Ð Éd q pe u p=e Ð 9f )`°ýmf aa1 !g `1 ug e0ýj 0Ð k rIk HÐ im ò¹n dÐ up |Ð Eq 9a3 áq Õ`0ýMr `0ý¹r M ðår M ðs ˜Ð µs ‘`1 t å€rt Ð Qu `Pýeu ÈÐ Ýv Ù ñýQw 9a3 íw Q`? !x Y`? Ux ØÐ ñy ±`0ýIz ðÐ ez üÐ z Ñ U{ Ñ ¥{ í`3 -|
a2ýÅ| Ý`0ý=} 0Ñ §} ` á} XÑ = ` G ` e e`0ý™ 1a2ý=€ Ñ ç€ ` ù€ ] pa ™ r ¸Ñ )‚ a ]‚ å öqˆ àÑ C‰ ` U‰ }`? •‰ t)Š Ò i ½ rÉ Ò q’ ya3 1“ I`? Y“ (Ò å” 8Ò i˜ XÒ qš
r› ñý‰› Ý`0ýù› u`0ý5œ Í`3 ©œ hÒ C `PýM )óýiž e`0ýÁž Ò IŸ ¨Ò íŸ 1t u`1 É
óýQ¡ ¡`0ý¥¡ ¸Ò M¤ =3í¤ ÈÒ •§ • r᧠¥1µ¨ `²ý | ¶qÜqìrør0s8sPstsˆsšs¦s¼säs$tXt¤t¸tît€u´uÀuÔ5,60646`6d6¤6¨6Ø67 7,7 8 8999|9€9zz > >$>(>t> ? ?$?@?¸?¼?À?Ä?È?Ì?Ð? Ô0Ø0Ü0à0ä0è0ì0ð0ô0ø0X2\2`2d2h2Ð2Ô2$3(3x3|3Ä3È30545Ä5È5Ì5 666<6@6D6œ6 6Ð6Ô6ä6è6h7l7p7t7”7˜7(:,:0:4:8:<:@:D:H:p:t:x:ô;ø;D<`<|<¬<è<ì<´=¸= 0 P ô6ø6ü6 777€7„7ˆ7°7<8@8D8 9$9(9,9”9˜9œ9 9:: :4;D<8=<=@=„=ä=è=$>Œ>à? @ ˜ |0€0è0ì0ð0ˆ2Œ22”2044484<4@4d4D5H5€6„6˜6À6Ä6P8|8€8Œ8˜8¨8¸8¼8D:H:L:P:T:X::”:˜:Ä:Ð:Ü:è:ô: ;<;@;¸{0<4<\<`<ˆ<Œ<À<Ä<È<€=„=ˆ=Œ=Ô=H?L?P?X?\?`?d?h?l? ? P h 0<0H0h0l0 111`3d3h3l3p3t3x3<4@4D4H4œ4 4¤4(6064686<6D6H7L7P7T7Ø7Ü7à7<=@=D=H=L=P=T= > >è>ì>ð>ô> ` h0l00646d6h6 7p7ø:ü:`=d= p h à2 3ü3t4x4|4\5`58L8P8¼9À9Ä9È9Ì9Ð9Ô9Ø9Ü9à9ä9è9ì9H;œ; ; < <$<(<´<¸<¼<À<4=8=°=´=¸=Ø=Ü=P?T?X?\?`? € @ 004080ð0ô0(1,101L1P1TqX2P8T8X8\8`8d8h8l8L9P9:: : :$: H P0T0X0`0d0h2l2,3T3Ð4Ô4Ø4Ü4à4\8`8d8T:X:\:`:d:h:l:œ< <¤<@?D?ä?è? 1<4@4D4H4Œ77 ° 4 (1,10141@1D1H186<6@6D6´?¼?Ä?Ì?Ô?Ü?ä?ì?ô?ü? À ( 0 00 0$0,040<0D0L0T0\0d08:<: à 00P5T5h5l5p5t5x5|5€5„5ˆ5Œ55”5˜5œ5 5¤5¨5¬5°5´5¸5¼5À5Ä5È5Ì5Ð5Ô5Ø5Ü5à5ä5è5ì5ð5ô5ø5ü5 666 66 6 6$6(6,6064686<6@6D6H6L6P6T6X6\6`6d6h6l6p6t6x6|6€6„6ˆ6Œ66”6˜6œ6 6¤6¨6¬6°6´6¸6¼6À6Ä6È6ô677$747T7`7d7h7l7ˆ7”7°<À<Ä<È<Ì<Ð<Ô<Ø<Ü<à<ä<ð<ô<ø<ü< === === =$=(=,=0=4=8=<=@=D=H=X>\>`>d> setuptools-20.7.0/setuptools/gui.exe 0000664 0001750 0001750 00000200000 12702524020 020357 0 ustar travis travis 0000000 0000000 MZ ÿÿ ¸ @ è º ´ Í!¸LÍ!This program cannot be run in DOS mode.
$ äSÀØ 2®‹ 2®‹ 2®‹‡ôÕ‹£2®‹ 2¯‹û2®‹ }8‹¤2®‹¾`*‹„2®‹¾`;‹²2®‹¾`-‹Ñ2®‹¾`?‹¡2®‹Rich 2®‹ PE L ±‹Q à Ê N & à @ @ € 4ù ( ˆô @ à @ .text íÉ Ê `.rdata h à " Î @ @.data Ä+ ð @ À Q‹D$PŠ@„ÉuùSUV+ÂW‹èD-jPèx
ƒÄ3ÿ3Û‰D$Æ "p…í~Wë› ‹L$Š <\uGë <"u…ÿ~Wj\Vè
ƒÄ ÷3ÿÆ\Fë3ÿ‹T$ŠˆCF;Ý|Ã…ÿ~Wj\VèV
ƒÄ ÷‹D$_Æ"ÆF ^][YÃì ¡€A 3ĉ„$ V‹´$ W‹¼$ Š‹Ï„Àtd$ A9](u>‹u3À@8 tHF;Ãwö€>:u5;Ëtƒ}‚õ jÿujÿQèU& ƒÄF‰uë9](uÂÇEø éÎ ;Ëtˆ‹u3ÿ‰]ü8 tU¾Pè& Y…ÀtFëŠ Yƒeü 3ÛC9 8 A „Å ‰ 4 A ŠE¢0 A ƒ} … ÿ5¬+A è0, Y‹ø‰}Ø…ÿtxÿ5¨+A è, Y‹ð‰u܉}ä‰uàƒî‰uÜ;÷rWè÷+ 9tí;÷rJÿ6èñ+ ‹øèá+ ‰ÿ×ÿ5¬+A èÛ+ ‹øÿ5¨+A èÎ+ ƒÄ 9}äu9Eàt‰}ä‰}؉Eà‹ð‰uÜ‹}ØëŸhpá@ ¸dá@ è_þÿÿYhxá@ ¸tá@ èOþÿÿYÇEüþÿÿÿè ƒ} u(‰ 8 A jèl Yÿuèüýÿÿ3ÛCƒ} tjèS YÃè ËÿU‹ìj j ÿuèÃþÿÿƒÄ ]ËÿU‹ìj jÿuèþÿÿƒÄ ]Ãjj j èþÿÿƒÄ Ãjjj èŽþÿÿƒÄ ËÿVèó* ‹ðVèY; Vèä: Vèw VèÉ: Vè´: Vèœ8 Vè57 Vè 7 hê#@ èE* ƒÄ$£ˆA ^ËÿU‹ìƒ=D A uèŒ3 ÿuèÙ1 hÿ è'ýÿÿYY]ÃjXh0õ@ èû 3ö‰uüE˜Pÿ4à@ jþ_‰}ü¸MZ f9 @ u8¡< @ ¸ @ PE u'¹ f9ˆ @ uƒ¸t @ v3É9°è @ •Á‰Mäë‰uä3ÛCSèÏ? Y…Àuj èXÿÿÿYè- …ÀujèGÿÿÿYèW4 ‰]üèø
…À}jè&üÿÿYÿ0à@ £ +A èQ> £< A èŒ= …À}jè üÿÿYè; …À}j èïûÿÿYSè§üÿÿY;ÆtPèÝûÿÿYè: „]Ät·MÈëj
YQPVh @ èòÿÿ‰Eà9uäuPè þÿÿèEþÿÿ‰}üë5‹Eì‹‹ ‰MÜPQè·5 YYËeè‹E܉Eàƒ}ä uPèþÿÿè!þÿÿÇEüþÿÿÿ‹Eàë3À@ËeèÇEüþÿÿÿ¸ÿ èÏ Ãèï> éxþÿÿ‹ÿU‹ìV‹uVèS Pèk? YY…Àt|è©òÿÿƒÀ ;ðu3Àëè™òÿÿƒÀ@;ðu`3À@ÿ A ÷F uNSW<…H A ƒ? » u Sè
Y‰…ÀuFj‰F‰X‰F‰Fë
‹?‰~‰>‰^‰^N 3À_@[ë3À^]ËÿU‹ìƒ} t'V‹u ÷F tVè f ÿîÿÿƒf ƒ& ƒf Y^]ÃöA @tƒy t$ÿIx ‹ˆÿ¶Àë ¾ÀQPèé- YYƒøÿu ÃÿËÿU‹ìV‹ðë‹MŠEÿM èµÿÿÿƒ>ÿtƒ} ç^]ËÿU‹ìöG @SV‹ð‹Ùt2ƒ u,‹Eë+ŠÿM‹Ïè}ÿÿÿCƒ>ÿuèÕ ƒ8*u‹Ï°?èdÿÿÿƒ} Õ^[]ËÿU‹ììx ¡€A 3ʼnEüS‹] V‹u3ÀW‹}ÿu¤ýÿÿ‰µ´ýÿÿ‰½Üýÿÿ‰…¸ýÿÿ‰…ðýÿÿ‰…Ìýÿÿ‰…èýÿÿ‰…Ðýÿÿ‰…Àýÿÿ‰…Èýÿÿè÷öÿÿ…öu5èM Ç 3ÀPPPPPèÓ ƒÄ€½°ýÿÿ t
‹…¬ýÿÿƒ`pýƒÈÿéÈ
öF @u^Vè@
Yº˜A ƒøÿtƒøþt‹Èƒá ‹ðÁþÁá µ *A ë‹ÊöA$u‘ƒøÿtƒøþt‹Èƒà ÁùÁà *A ë‹Âö@$€…gÿÿÿ3É;Ù„]ÿÿÿŠ‰Øýÿÿ‰àýÿÿ‰¼ýÿÿˆ•ïýÿÿ„Ò„
Cƒ½Øýÿÿ ‰ÄýÿÿŒ
ŠÂ, If90t@@;Îuô+…äýÿÿÑøë(;þu ¡A ‰…äýÿÿ‹…äýÿÿëI€8 t@;Îuõ+…äýÿÿ‰…àýÿÿƒ½Àýÿÿ …\ ‹…ðýÿÿ¨@t2© t Æ…Ôýÿÿ-ë¨t Æ…Ôýÿÿ+ë ¨tÆ…Ôýÿÿ Ç…Ðýÿÿ ‹Ìýÿÿ+àýÿÿ+Ðýÿÿö…ðýÿÿ uÿµ´ýÿÿ…ØýÿÿSj èpõÿÿƒÄ ÿµÐýÿÿ‹½´ýÿÿ…ØýÿÿÔýÿÿèvõÿÿö…ðýÿÿYtö…ðýÿÿuWSj0…Øýÿÿè.õÿÿƒÄ ƒ½Èýÿÿ ‹…àýÿÿtf…À~b‹µäýÿÿ‰… ýÿÿ·ÿ ýÿÿPjEôP…˜ýÿÿFPFèå5 ƒÄ…Àu(9…˜ýÿÿt ÿµ˜ýÿÿ…ØýÿÿMôèñôÿÿƒ½ ýÿÿ Yuµë ƒØýÿÿÿë‹äýÿÿP…ØýÿÿèÊôÿÿYƒ½Øýÿÿ |ö…ðýÿÿtWSj …Øýÿÿè‚ôÿÿƒÄ ƒ½¼ýÿÿ tÿµ¼ýÿÿè ƒ¥¼ýÿÿ Y‹ÄýÿÿŠˆ…ïýÿÿ„Àt‹”ýÿÿ‹½ÜýÿÿŠÐéáõÿÿ€½°ýÿÿ t
‹…¬ýÿÿƒ`pý‹…Øýÿÿ‹Mü_^3Í[èÚëÿÿÉÃ+@ )@ G)@ ¥)@ ñ)@ ü)@ B*@ p+@ jThXõ@ èe 3ÿ‰}üEœPÿ4à@ ÇEüþÿÿÿj@j ^Vèy YY;Ç„ £ *A ‰5*A ˆ ë0Æ@ ƒÿÆ@
‰xÆ@$ Æ@%
Æ@&
‰x8Æ@4 ƒÀ@‹
*A Á ;ÁrÌf9}΄
‹EÐ;Ç„ÿ ‹8X;‰Eä¾ ;þ|‹þÇEà ë[j@j èë YY…ÀtV‹Mà *A ‰ƒ*A ë*Æ@ ƒÿÆ@
ƒ` €`$€Æ@%
Æ@&
ƒ`8 Æ@4 ƒÀ@‹Ö;ÂrÒÿEà9=*A |ë‹=*A ƒeà …ÿ~m‹E䋃ùÿtVƒùþtQŠ¨tK¨u Qÿ@à@ …Àt<‹uà‹ÆÁøƒæ Áæ4… *A ‹Eä‹ ‰ŠˆFh F Pè„* YY…À„É ÿFÿEàCƒEä9}à|“3Û‹óÁæ5 *A ‹ƒøÿt ƒøþt€N€ërÆF…ÛujöXë
‹ÃH÷ØÀƒÀõPÿ<à@ ‹øƒÿÿtC…ÿt?Wÿ@à@ …Àt4‰>%ÿ ƒøu€N@ë ƒøu€Nh F Pèî) YY…Àt7ÿFë
€N@ÇþÿÿÿCƒûŒgÿÿÿÿ5*A ÿ8à@ 3Àë3À@ËeèÇEüþÿÿÿƒÈÿèc ËÿU‹ì‹EV3ö;Æu è½ VVVVVÇ èE ƒÄƒÈÿë‹@^]ËÿU‹ì‹E£P A ]ËÿU‹ìì( ¡€A 3ʼnEüƒ¥Øüÿÿ SjL…Üüÿÿj Pèóäÿÿ…Øüÿÿ‰…(ýÿÿ…0ýÿÿƒÄ ‰…,ýÿÿ‰…àýÿÿ‰Üýÿÿ‰•Øýÿÿ‰Ôýÿÿ‰µÐýÿÿ‰½ÌýÿÿfŒ•øýÿÿfŒìýÿÿfŒÈýÿÿfŒ…ÄýÿÿfŒ¥ÀýÿÿfŒ¼ýÿÿœ…ðýÿÿ‹EMÇ…0ýÿÿ ‰…èýÿÿ‰ôýÿÿ‹Iü‰äýÿÿÇ…Øüÿÿ ÀÇ…Üüÿÿ ‰…äüÿÿÿXà@ j ‹ØÿTà@ …(ýÿÿPÿPà@ …Àu …ÛujèM2 Yh ÀÿLà@ PÿHà@ ‹Mü3Í[èüçÿÿÉËÿU‹ìÿ5P A è* Y…Àt]ÿàjè2 Y]é²þÿÿ‹ÿU‹ì‹E3É;ÍØA tAƒù-rñHíƒùwj
X]ËÍÜA ]ÃDÿÿÿjY;ÈÀ#ÁƒÀ]Ãè …Àu¸@A ÃÀÃè …Àu¸DA ÃÀ ËÿU‹ìVèâÿÿÿ‹MQ‰è‚ÿÿÿY‹ðè¼ÿÿÿ‰0^]ÃÌÌÌh 8@ dÿ5 ‹D$‰l$l$+àSVW¡€A 1Eü3ÅP‰eèÿuø‹EüÇEüþÿÿÿ‰EøEðd£ ËMðd‰
Y__^[‹å]QÃÌÌÌÌÌÌÌÌÌÌÌ‹ÿU‹ìƒìS‹] V‹s35€A W‹ÆEÿ ÇEô {ƒøþt
‹NÏ3 8è©æÿÿ‹N ‹FÏ3 8è™æÿÿ‹Eö@f… ‹MUè‰Sü‹[ ‰Eè‰Mìƒûþt_I [‹L†D†‰Eð‹ ‰Eø…Ét‹×è„1 ÆEÿ…À|@G‹Eø‹Øƒøþu΀}ÿ t$‹ƒøþt
‹NÏ3 8è&æÿÿ‹N ‹VÏ3 :èæÿÿ‹Eô_^[‹å]ÃÇEô ëÉ‹M9csmàu)ƒ=Œ*A t hŒ*A èƒ! ƒÄ…Àt‹UjRÿŒ*A ƒÄ‹M è'1 ‹E 9X th€A W‹Ó‹Èè*1 ‹E ‹Mø‰H ‹ƒøþt
‹NÏ3 8è“åÿÿ‹N ‹VÏ3 :èƒåÿÿ‹Eð‹H‹×è½0 ºþÿÿÿ9S „Rÿÿÿh€A W‹ËèÕ0 é ÿÿÿ‹ÿU‹ìVW3öÿuè%1 ‹øY…ÿu'9T A v Vÿ$à@ †è ;T A vƒÈÿ‹ðƒøÿuÊ‹Ç_^]ËÿU‹ìVW3öj ÿu ÿuèE ‹øƒÄ …ÿu'9T A v Vÿ$à@ †è ;T A vƒÈÿ‹ðƒøÿuËÇ_^]ËÿU‹ìVW3öÿu ÿuè[1 ‹øYY…ÿu,9E t'9T A v Vÿ$à@ †è ;T A vƒÈÿ‹ðƒøÿuÁ‹Ç_^]ËÿU‹ìVW3öÿuÿu ÿuè%3 ‹øƒÄ …ÿu,9Et'9T A v Vÿ$à@ †è ;T A vƒÈÿ‹ðƒøÿu½‹Ç_^]Ãj hxõ@ èÓüÿÿ‹u…ötuƒ=„*A uCjè Yƒeü Vè73 Y‰Eä…Àt VPèX3 YYÇEüþÿÿÿè ƒ}ä u7ÿuë
jè YÃVj ÿ5t)A ÿ`à@ …Àuè üÿÿ‹ðÿ\à@ PèÌûÿÿ‰Yè—üÿÿÃjh˜õ@ èEüÿÿ3Û‰]äjè– Y‰]üj_‰}à;=À;A }W‹÷Á桼+A Æ9tD‹ ö@ ƒtPèÊ= YƒøÿtÿEäƒÿ|(¡¼+A ‹ƒÀ PÿDà@ ¡¼+A ÿ4èýþÿÿY¡¼+A ‰ GëžÇEüþÿÿÿè ‹EäèüÿÿÃjè7 YËÿU‹ìSV‹u‹F ‹È€á3Û€ùu@© t9‹FW‹>+ø…ÿ~,WPVèaùÿÿYPèçD ƒÄ ;Çu‹F „Àyƒàý‰F ëƒN ƒËÿ_‹Fƒf ‰^‹Ã[]ËÿU‹ìV‹u…öu Vè5 Yë/Vè|ÿÿÿY…ÀtƒÈÿë ÷F @ tVèøøÿÿPè[E Y÷ØYÀë3À^]Ãjh¸õ@ èöúÿÿ3ÿ‰}ä‰}ÜjèD Y‰}ü3ö‰uà;5À;A ƒ ¡¼+A °98t^‹ ö@ ƒtVPVèÝÿÿYY3ÒB‰Uü¡¼+A ‹°‹H öÁƒt/9UuPèJÿÿÿYƒøÿt ÿEäë9}uöÁtPè/ÿÿÿYƒøÿu E܉}üè Fë„3ÿ‹uࡼ+A ÿ4°Vè"ÝÿÿYYÃÇEüþÿÿÿè ƒ}‹Eät‹EÜèwúÿÿÃjè YÃjè ÿÿÿYËÿVW3ö¿X A ƒ<õLA u õHA ‰8h ÿ0ƒÇè}! YY…Àt Fƒþ$|Ò3À@_^Ã$õHA 3Àëñ‹ÿS‹ Dà@ V¾HA W‹>…ÿtƒ~t
WÿÓWèÐüÿÿƒ& YƒÆþhA |ܾHA _‹…Àt ƒ~uPÿÓƒÆþhA |æ^[ËÿU‹ì‹Eÿ4ÅHA ÿ à@ ]Ãj hàõ@ èZùÿÿ3ÿG‰}ä3Û9 t)A uè´ j è hÿ èPãÿÿYY‹u4õHA 9 t‹Çënjè ûÿÿY‹ø;ûuèÁøÿÿÇ 3ÀëQj
èY Y‰]ü9 u,h Wèt YY…ÀuWèþûÿÿYè‹øÿÿÇ ‰]äë ‰>ëWèãûÿÿYÇEüþÿÿÿè ‹EäèòøÿÿÃj
è(ÿÿÿYËÿU‹ì‹EV4ÅHA ƒ> uPè"ÿÿÿY…ÀujèDâÿÿYÿ6ÿà@ ^]Ãj h ö@ èdøÿÿ‹M3ÿ;Ïv.jàX3Ò÷ñ;E À@u èû÷ÿÿÇ WWWWWèƒ÷ÿÿƒÄ3ÀéÕ ¯M ‹ñ‰u;÷u3öF3Û‰]äƒþàwiƒ=„*A uKƒÆƒæð‰u ‹E;p*A w7jèLÿÿÿY‰}üÿuèH6 Y‰EäÇEüþÿÿÿè_ ‹]ä;ßtÿuWSèÛÿÿƒÄ ;ßuaVjÿ5t)A ÿdà@ ‹Ø;ßuL9=€)A t3Vè’ Y…À…rÿÿÿ‹E;Ç„PÿÿÿÇ éEÿÿÿ3ÿ‹u jèðýÿÿYÃ;ßu
‹E;ÇtÇ ‹Ãè˜÷ÿÿÃU‹ìƒì‰}ü‹}‹M ÁéfïÀë¤$ ffGfG fG0fG@fGPfG`fGp¿€ IuЋ}ü‹å]ÃU‹ìƒì‰}ü‹E™‹ø3ú+úƒç3ú+ú…ÿu<‹M‹Ñƒâ‰Uô;Êt+ÊQPèsÿÿÿƒÄ‹E‹Uô…ÒtEE+‰Eø3À‹}ø‹Môóª‹Eë.÷߃lj}ð3À‹}‹Mðóª‹Eð‹M‹UÈ+ÐRj Qè~ÿÿÿƒÄ ‹E‹}ü‹å]Ãj h ö@ è`öÿÿƒeü f(ÁÇEä ë#‹Eì‹ ‹ = Àt
= Àt3ÀÃ3À@Ëeèƒeä ÇEüþÿÿÿ‹EäèböÿÿËÿU‹ìƒì3ÀS‰Eü‰Eô‰EøSœX‹È5 PœZ+Ñt Q3À¢‰Eô‰]è‰Uì‰M𸠢‰Uü‰Eø[÷Eü tè\ÿÿÿ…Àt3À@ë3À[ÉÃè™ÿÿÿ£ˆ*A 3ÀËÿU‹ìQSV‹u3ÛW;ót9] w èEõÿÿjYSSSSS‹ñ‰èÌôÿÿƒÄ‹ÆéÍ ‹E3ÿ;ÃtŠ :Ãtj_9} † ˆFÆ:F‹M‹Á;Ët@8t<ë‹}ü‹U G‰}ü;úsyŠˆF@8uèPQèì@ Š YYŠˆF@8uð‹E ;Ãt'Š:Ët!€ù.tG;} s Æ.Fë G;} sŠˆF@8uðG;} v‹Eˆèhôÿÿj"é ÿÿÿˆ 3À_^[ÉËÿU‹ìƒìÿuMðèæÛÿÿ¶E ‹MôŠU„T u ƒ} t‹Mð‹‰È ·A#Eë3À…Àt3À@€}ü t‹MøƒapýÉËÿU‹ìjj ÿuÿu è™ÿÿÿƒÄ]ËÿU‹ìjj ÿuj èÿÿÿƒÄ]ËÿU‹ìj ÿuÿuÿu ÿuèå? ƒÄ]ËÿU‹ìì( £°"A ‰
¬"A ‰¨"A ‰ ¤"A ‰5 "A ‰=œ"A fŒÈ"A fŒ
¼"A fŒ ˜"A fŒ”"A fŒ%"A fŒ-Œ"A œÀ"A ‹E £´"A ‹E£¸"A E£Ä"A ‹…àüÿÿÇ "A ¡¸"A £´!A Ǩ!A ÀǬ!A ¡€A ‰…Øüÿÿ¡„A ‰…ÜüÿÿÿXà@ £ø!A jè¯$ Yj ÿTà@ hÔâ@ ÿPà@ ƒ=ø!A ujè‹$ Yh ÀÿLà@ PÿHà@ ÉÃ-¤ t"ƒètƒè
t Ht3Àø ø ø ø ËÿVW‹ðh 3ÿF WPèûÕÿÿ3À·È‹Á‰~‰~‰~ Áá Á~«««¹hA ƒÄ F +ο Šˆ@Ou÷† ¾ Šˆ@Nu÷_^ËÿU‹ìì ¡€A 3ʼnEüSW…èúÿÿPÿvÿhà@ ¿ …À„û 3Àˆ„üþÿÿ@;ÇrôŠ…îúÿÿÆ…üþÿÿ „Àt.ïúÿÿ¶È¶;Èw+Á@P”
üþÿÿj Rè8ÕÿÿƒÄ CŠC„ÀuØj ÿv …üúÿÿÿvPW…üþÿÿPjj èyE 3ÛSÿv…üýÿÿWPW…üþÿÿPWÿv SèZC ƒÄDSÿv…üüÿÿWPW…üþÿÿPh ÿv Sè5C ƒÄ$3À·ŒEüúÿÿöÁt€L ŠŒüýÿÿëöÁt€L ŠŒüüÿÿˆŒ ëÆ„ @;Çr¾ëV† Ç…äúÿÿŸÿÿÿ3É)…äúÿÿ‹•äúÿÿ„ ÐZ ƒûw €L ŠÑ€Â ëƒúw€L ŠÑ€ê ˆëÆ A;Ïr‹Mü_3Í[è ØÿÿÉÃj h@ö@ èËðÿÿè˜
‹ø¡ŒA …Gpt ƒl t‹wh…öuj ènÚÿÿY‹ÆèãðÿÿÃj
èó÷ÿÿYƒeü ‹wh‰uä;5A t6…ötVÿpà@ …ÀuþhA tVè‡óÿÿY¡A ‰Gh‹5A ‰uäVÿlà@ ÇEüþÿÿÿè 뎋uäj
è¸öÿÿYËÿU‹ìƒìS3ÛSMðèt×ÿÿ‰ Ì$A ƒþþu ÇÌ$A ÿxà@ 8]ütE‹Møƒapýë<ƒþýuÇÌ$A ÿtà@ ëÛƒþüu‹Eð‹@ÇÌ$A ëÄ8]üt‹Eøƒ`pý‹Æ[ÉËÿU‹ìƒì ¡€A 3ʼnEüS‹] V‹uWèdÿÿÿ‹ø3ö‰};þu‹Ãè·üÿÿ3Àé ‰uä3À9¸˜A „‘ ÿEäƒÀ0=ð rçÿèý „p ÿéý „d ·ÇPÿ|à@ …À„R EèPWÿhà@ …À„3 h C VPèXÒÿÿ3ÒBƒÄ ‰{‰s 9Uè†ø €}î „Ï uɄ ¶Fÿ¶Éé¦ h C VPèÒÿÿ‹MäƒÄ kÉ0‰u౨A ‰uäë*ŠF„Àt(¶>¶Àë‹EàŠ€”A D; ¶FG;øvê‹}FF€> uÑ‹uäÿEàƒÆƒ}à‰uäré‹Ç‰{ÇC ègûÿÿj‰C C‰œA Zf‹1Af‰0A@@Juó‹óè×ûÿÿé·þÿÿ€L @;ÁvöFF€~ÿ …4ÿÿÿC ¹þ €@Iuù‹Cèûÿÿ‰C ‰Së‰s3À·È‹ÁÁá Á{«««ë¨95Ì$A …XþÿÿƒÈÿ‹Mü_^3Í[èÕÿÿÉÃjh`ö@ èÆíÿÿƒMàÿè ‹ø‰}ÜèÜüÿÿ‹_h‹uèuýÿÿ‰E;C„W h è‚ïÿÿY‹Ø…Û„F ¹ˆ ‹wh‹ûó¥ƒ# Sÿuè¸ýÿÿYY‰Eà…À…ü ‹uÜÿvhÿpà@ …Àu‹Fh=hA tPècðÿÿY‰^hS‹=là@ ÿ×öFp…ê öŒA …Ý j
ètôÿÿYƒeü ‹C£Ü$A ‹C£à$A ‹C £ä$A 3À‰Eäƒø}f‹LCf‰ EÐ$A @ëè3À‰Eä= }
ŠL ˆˆˆA @ëé3À‰Eä= }ŠŒ ˆˆA @ëæÿ5A ÿpà@ …Àu¡A =hA tPèªïÿÿY‰ A Sÿ×ÇEüþÿÿÿè ë0j
èíòÿÿYÃë%ƒøÿu ûhA tSètïÿÿYèìÿÿÇ ëƒeà ‹Eàè~ìÿÿÃ=°+A ujýèVþÿÿYÇ°+A 3ÀËÿU‹ìSV‹u‹†¼ 3ÛW;Ãto=H A th‹†° ;Ãt^9uZ‹†¸ ;Ãt9uPèûîÿÿÿ¶¼ è›A YY‹†´ ;Ãt9uPèÚîÿÿÿ¶¼ è5A YYÿ¶° èÂîÿÿÿ¶¼ è·îÿÿYY‹†À ;ÃtD9u@‹†Ä -þ Pè–îÿÿ‹†Ì ¿€ +ÇPèƒîÿÿ‹†Ð +ÇPèuîÿÿÿ¶À èjîÿÿƒÄ¾Ô ‹=ˆ A t9˜´ uPè? ÿ7èCîÿÿYY~PÇE øA t‹;Ãt 9uPè îÿÿY9_üt‹G;Ãt 9uPèîÿÿYƒÇÿMuÇVèøíÿÿY_^[]ËÿU‹ìSV‹5là@ W‹}WÿÖ‹‡° …ÀtPÿÖ‹‡¸ …ÀtPÿÖ‹‡´ …ÀtPÿÖ‹‡À …ÀtPÿÖ_PÇE {øA t ‹…ÀtPÿÖƒ{ü t
‹C…ÀtPÿÖƒÃÿMuÖ‹‡Ô ´ PÿÖ_^[]ËÿU‹ìW‹}…ÿ„ƒ SV‹5pà@ WÿÖ‹‡° …ÀtPÿÖ‹‡¸ …ÀtPÿÖ‹‡´ …ÀtPÿÖ‹‡À …ÀtPÿÖ_PÇE {øA t ‹…ÀtPÿÖƒ{ü t
‹C…ÀtPÿÖƒÃÿMuÖ‹‡Ô ´ PÿÖ^[‹Ç_]Ã…ÿt7…Àt3V‹0;÷t(W‰8èÁþÿÿY…ötVèEÿÿÿƒ> Yuþ˜A tVèYýÿÿY‹Ç^Ã3ÀÃj h€ö@ è_éÿÿè, ‹ð¡ŒA …Fpt"ƒ~l t è ‹pl…öuj èýÒÿÿY‹ÆèréÿÿÃj è‚ðÿÿYƒeü Fl‹=pA èiÿÿÿ‰EäÇEüþÿÿÿè ëÁj è}ïÿÿY‹uäËÿU‹ìVÿ5„A ‹5€à@ ÿÖ…Àt!¡€A ƒøÿtPÿ5„A ÿÖÿÐ…Àt‹€ø ë'¾tã@ Vÿ à@ …Àu Vè>ÒÿÿY…Àthdã@ Pÿ(à@ …ÀtÿuÿЉE‹E^]Ãj è‡ÿÿÿYËÿU‹ìVÿ5„A ‹5€à@ ÿÖ…Àt!¡€A ƒøÿtPÿ5„A ÿÖÿÐ…Àt‹€ü ë'¾tã@ Vÿ à@ …Àu VèÃÑÿÿY…Àthã@ Pÿ(à@ …ÀtÿuÿЉE‹E^]Ãÿ„à@  ‹ÿVÿ5„A ÿ€à@ ‹ð…öuÿ5%A èeÿÿÿY‹ðVÿ5„A ÿˆà@ ‹Æ^á€A ƒøÿtPÿ5%A è;ÿÿÿYÿЃ
€A ÿ¡„A ƒøÿtPÿŒà@ ƒ
„A ÿéºíÿÿj h ö@ è‚çÿÿ¾tã@ Vÿ à@ …ÀuVèÑÿÿY‰Eä‹uÇF\é@ 3ÿG‰~…Àt$hdã@ P‹ (à@ ÿÓ‰†ø hã@ ÿuäÿÓ‰†ü ‰~pÆ†È CƆK CÇFhhA j
ènîÿÿYƒeü ÿvhÿlà@ ÇEüþÿÿÿè> j èMîÿÿY‰}ü‹E ‰Fl…Àu¡pA ‰FlÿvlèüÿÿYÇEüþÿÿÿè èçÿÿÃ3ÿG‹uj
è5íÿÿYÃj è,íÿÿYËÿVWÿ\à@ ÿ5€A ‹øè‘þÿÿÿЋð…öuNh jè±èÿÿ‹ðYY…öt:Vÿ5€A ÿ5%A èèýÿÿYÿÐ…Àtj VèÅþÿÿYYÿ”à@ ƒNÿ‰ë Vè^éÿÿY3öWÿà@ _‹Æ^ËÿVèÿÿÿ‹ð…öujèáÏÿÿY‹Æ^ÃjhÈö@ èæÿÿ‹u…ö„ø ‹F$…ÀtPèéÿÿY‹F,…ÀtPèéÿÿY‹F4…ÀtPèõèÿÿY‹F<…ÀtPèçèÿÿY‹F@…ÀtPèÙèÿÿY‹FD…ÀtPèËèÿÿY‹FH…ÀtPè½èÿÿY‹F\=é@ tPè¬èÿÿYj
èàìÿÿYƒeü ‹~h…ÿtWÿpà@ …ÀuÿhA tWèèÿÿYÇEüþÿÿÿèW j è§ìÿÿYÇEü ‹~l…ÿt#WèóúÿÿY;=pA tÿ˜A t ƒ? uWèÿøÿÿYÇEüþÿÿÿè Vè'èÿÿYèEåÿÿ ‹uj
èvëÿÿYËuj èjëÿÿYËÿVW¾tã@ Vÿ à@ …ÀuVècÎÿÿY‹ø…ÿ„^ ‹5(à@ hÀã@ WÿÖh´ã@ W£ %A ÿÖh¨ã@ W£%A ÿÖh ã@ W£%A ÿÖƒ= %A ‹5ˆà@ £%A tƒ=%A t
ƒ=%A t…Àu$¡€à@ £%A ¡Œà@ Ç %A ”O@ ‰5%A £%A ÿ„à@ £„A ƒøÿ„Ì ÿ5%A PÿÖ…À„» è•Ðÿÿÿ5 %A èûÿÿÿ5%A £ %A èûÿÿÿ5%A £%A èóúÿÿÿ5%A £%A èãúÿÿƒÄ£%A è¬éÿÿ…ÀtehˆQ@ ÿ5 %A è=ûÿÿYÿУ€A ƒøÿtHh jèÓåÿÿ‹ðYY…öt4Vÿ5€A ÿ5%A è
ûÿÿYÿÐ…Àtj VèçûÿÿYYÿ”à@ ƒNÿ‰3À@ëè’ûÿÿ3À_^ËÿU‹ìƒìSÿuMèè™Êÿÿ‹]C= w‹Eè‹€È ·Xëu‰]Á}EèP‹E%ÿ Pè§ YY…ÀtŠEjˆEøˆ]ùÆEú Yë
3Ɉ]øÆEù A‹EèjÿpÿpEüPQEøPEèjPè~6 ƒÄ …Àu8Eôt‹Eðƒ`pý3Àë·Eü#E €}ô t‹Mðƒapý[ÉËÿU‹ìQV‹u Vèsàÿÿ‰E ‹F Y¨‚uè4âÿÿÇ ƒN ƒÈÿé/ ¨@t
èâÿÿÇ " ëãS3Û¨t‰^¨„‡ ‹Nƒàþ‰‰F ‹F ƒàïƒÈ‰F ‰^‰]ü© u,èlÃÿÿƒÀ ;ðt è`ÃÿÿƒÀ@;ðu
ÿu è Y…ÀuVè @ Y÷F W„€ ‹F‹>H‰‹N+øI;û‰N~ WPÿu è<+ ƒÄ ‰EüëMƒÈ ‰F ƒÈÿëy‹M ƒùÿtƒùþt‹Áƒà ‹ÑÁúÁà• *A 븘A ö@ tjSSQèŠ> #ƒăøÿt%‹FŠMˆë3ÿGWEPÿu èÍ* ƒÄ ‰Eü9}üt ƒN ƒÈÿë‹E%ÿ _[^ÉËÿU‹ìQQS‹]VW3ö3ÿ‰}ü; ýˆA t G‰}üƒÿrîƒÿƒw jèÚ@ Yƒø„4 jèÉ@ Y…Àu
ƒ=ŒA „ ûü „A hpé@ » S¿ %A Wè8 ƒÄ …Àt
VVVVVèÔÞÿÿƒÄh ¾9%A Vj Æ=&A ÿà@ …Àu&hXé@ hû VèN8 ƒÄ …Àt3ÀPPPPPèÞÿÿƒÄVèç @Yƒø ƒÄ ë2jôÿ<à@ ‹Ø;Þt$ƒûÿt j EøP4ýŒA ÿ6è% YPÿ6Sÿ˜à@ _^[ÉÃjè^? YƒøtjèQ? Y…Àu ƒ=ŒA uhü è)þÿÿhÿ è þÿÿYYËÿU‹ìQSVWÿ5¬+A èÊöÿÿÿ5¨+A ‹ø‰}üèºöÿÿ‹ðYY;÷‚ƒ ‹Þ+ßCƒørwWè5? ‹øCY;øsH¸ ;øs‹ÇÇ;ÇrPÿuüèsáÿÿYY…ÀuG;Çr@Pÿuüè]áÿÿYY…Àt1ÁûP4˜èÕõÿÿY£¬+A ÿuèÇõÿÿ‰ƒÆVè¼õÿÿY£¨+A ‹EYë3À_^[ÉËÿVjj èÇàÿÿ‹ðVè•õÿÿƒÄ £¬+A £¨+A …öujX^Ã& 3À^Ãj hðö@ èaÞÿÿèÈÿÿƒeü ÿuèøþÿÿY‰EäÇEüþÿÿÿè ‹Eäè}ÞÿÿÃèoÈÿÿËÿU‹ìÿuè·ÿÿÿ÷ØÀ÷ØYH]ËÿV¸àô@ ¾àô@ W‹ø;Æs‹…ÀtÿЃÇ;þrñ_^ËÿV¸èô@ ¾èô@ W‹ø;Æs‹…ÀtÿЃÇ;þrñ_^ËÿVW3ÿ·@ A ÿ6èÆôÿÿƒÇY‰ƒÿ(rè_^ÃÌ‹ÿU‹ì‹M¸MZ f9t3À]ËA<Á8PE uï3Ò¹ f9H”‹Â]ÃÌÌÌÌÌÌÌÌÌÌÌ‹ÿU‹ì‹E‹H<È·ASV·q3ÒWD…öv‹} ‹H ;ùr ‹XÙ;ûr
BƒÀ(;Örè3À_^[]ÃÌÌÌÌÌÌÌÌÌÌÌÌ‹ÿU‹ìjþh÷@ h 8@ d¡ PƒìSVW¡€A 1Eø3ÅPEðd£ ‰eèÇEü h @ è*ÿÿÿƒÄ…ÀtU‹E- @ Ph @ èPÿÿÿƒÄ…Àt;‹@$Áè ÷ЃàÇEüþÿÿÿ‹Mðd‰
Y_^[‹å]ËEì‹‹3Ò= À”‹ÂËeèÇEüþÿÿÿ3À‹Mðd‰
Y_^[‹å]Ãjh0÷@ èSÜÿÿè öÿÿ‹@x…Àtƒeü ÿÐë3À@ËeèÇEüþÿÿÿè÷< èlÜÿÿÃh=[@ è'óÿÿY£4(A ÃËÿU‹ìQQVè`õÿÿ‹ð…ö„F ‹V\¡t A W‹}‹ÊS99t‹ØkÛ ƒÁ Ú;ËrîkÀ Â;Ès99u‹Áë3À…Àt
‹X‰]ü…Ûu3Àéû ƒûu ƒ` 3À@éê ƒû„Þ ‹N`‰Mø‹M ‰N`‹Hƒù…¸ ‹
h A ‹=l A ‹Ñù;×}$kÉ ‹~\ƒd9 ‹=h A ‹ l A B߃Á ;Ó|â‹]ü‹ ‹~d=Ž Àu ÇFdƒ ë^= Àu ÇFd ëN=‘ Àu ÇFd„ ë>=“ Àu ÇFd… ë.= Àu ÇFd‚ ë = Àu ÇFd† ë=’ ÀuÇFdŠ ÿvdjÿÓY‰~dëƒ` QÿÓ‹EøY‰F`ƒÈÿ[_^ÉËÿU‹ì‹E£8(A £<(A £@(A £D(A ]ËÿU‹ì‹E‹
t A V9Pt‹ñkö uƒÀ ;ÆrìkÉ M^;Ás9Pt3À]Ãÿ5@(A èÚñÿÿYÃj hP÷@ èFÚÿÿ3ÿ‰}ä‰}Ø‹]ƒû Lt‹ÃjY+Át"+Át+Átd+ÁuDèsóÿÿ‹ø‰}Ø…ÿuƒÈÿéa ¾8(A ¡8(A ë`ÿw\‹Óè]ÿÿÿ‹ðƒÆ‹ëZ‹Ãƒèt<ƒèt+Ht èŠÙÿÿÇ 3ÀPPPPPèÙÿÿƒÄ뮾@(A ¡@(A ë¾<(A ¡<(A ë
¾D(A ¡D(A ÇEä Pèñÿÿ‰EàY3Àƒ}à„Ø 9EàujèÂÅÿÿ9EätPèÆàÿÿY3À‰Eüƒût
ƒû tƒûu‹O`‰MÔ‰G`ƒûu@‹Od‰MÐÇGdŒ ƒûu.‹
h A ‰MÜ‹
l A ‹h A Ê9MÜ}‹MÜkÉ ‹W\‰DÿEÜëÛè~ðÿÿ‰ÇEüþÿÿÿè ƒûu ÿwdSÿUàYë‹]‹}؃}ä tj èTßÿÿYÃSÿUàYƒût
ƒû tƒûu‹EÔ‰G`ƒûu‹EЉGd3ÀèèØÿÿËÿU‹ì‹E£L(A ]ËÿU‹ì‹E£X(A ]ËÿU‹ì‹E£\(A ]Ãjhp÷@ èiØÿÿƒeü ÿu ÿuÿ à@ ‰Eäë/‹Eì‹ ‹ ‰Eà3É= À”Á‹ÁËeè}à Àujÿà@ ƒeä ÇEüþÿÿÿ‹Eäè[ØÿÿËÿU‹ì‹E£`(A ]ËÿU‹ìÿ5`(A è|ïÿÿY…ÀtÿuÿÐY…Àt3À@]Ã3À]ËÿU‹ì‹E‹ 8csmàu*ƒxu$‹@= “t=!“t="“t= @™uèCûÿÿ3À] h¾_@ ÿTà@ 3ÀËÿVW3ÿ9=°+A uèCëÿÿ‹5 +A …öu¾bã@ Š< w„Àt.…ÿt$<"u 3É…ÿ”Á‹ù¶ÀPèãÿÿY…ÀtFFëÓ< wFŠ„Àuõ_‹Æ^Ã=°+A uèéêÿÿV‹5< A W3ÿ…öuƒÈÿé <=tGVè„ YtŠ„ÀuêjGWè!Ùÿÿ‹øYY‰= A …ÿtË‹5< A SëBVèS ‹ØC€>=Yt1jSèóØÿÿYY‰…ÀtNVSPè}. ƒÄ …Àt3ÀPPPPPè¿ÔÿÿƒÄƒÇó€> u¹ÿ5< A è¤Ùÿÿƒ%< A ƒ' Ǥ+A 3ÀY[_^Ãÿ5 A è~Ùÿÿƒ% A ƒÈÿëä‹ÿU‹ìQ‹MS3ÀV‰‹ò‹U Ç 9Et ‹]ƒE‰‰Eü€>"u3À9Eü³"”ÀF‰Eüë<ÿ…ÒtŠˆB‰U Š ¶ÃPFè¿áÿÿY…Àtÿƒ} t
‹M ŠÿE ˆF‹U ‹M„Ût2ƒ}ü u©€û t€û uŸ…ÒtÆBÿ ƒeü €> „é Š< t< uFëóNëã€> „Ð ƒ} t ‹EƒE‰ÿ3ÛC3ÉëFA€>\tù€>"u&öÁu ƒ}ü t F€8"u‹ðë
3À3Û9Eü”À‰EüÑé…ÉtI…ÒtÆ\Bÿ…Éuñ‰U Š„ÀtUƒ}ü u< tK< tG…Ût=¾ÀP…Òt#èÚàÿÿY…Àt
Š‹M ÿE ˆFÿ‹M ŠÿE ˆë
è·àÿÿY…ÀtFÿÿ‹U FéVÿÿÿ…ÒtÆ B‰U ÿ‹Méÿÿÿ‹E^[…Àtƒ ÿÉËÿU‹ìƒì S3ÛVW9 °+A uèeèÿÿh ¾h(A VSˆ l)A ÿà@ ¡ +A ‰5( A ;Ãt‰Eü8u‰uü‹UüEøPSS}ôè
þÿÿ‹EøƒÄ =ÿÿÿ?sJ‹MôƒùÿsB‹øÁç;Ár6Pè$Öÿÿ‹ðY;ót)‹UüEøPþWV}ôèÉýÿÿ‹EøƒÄ H£ A ‰5 A 3ÀëƒÈÿ_^[ÉËÿU‹ì¡p)A ƒì SV‹5´à@ W3Û3ÿ;Ãu.ÿÖ‹ø;ût Çp)A ë#ÿ\à@ ƒøxu
jX£p)A ë¡p)A ƒø… ;ûuÿÖ‹ø;ûu3ÀéÊ ‹Çf9 t@@f9uù@@f9uò‹5°à@ SSS+ÇSÑø@PWSS‰EôÿÖ‰Eø;Ãt/PèJÕÿÿY‰Eü;Ãt!SSÿuøPÿuôWSSÿÖ…Àu ÿuüèYÖÿÿY‰]ü‹]üWÿ¬à@ ‹Ãë\ƒøt;Ãu‚ÿ¨à@ ‹ð;ó„rÿÿÿ8 t
@8uû@8uö+Æ@P‰EøèãÔÿÿ‹øY;ûu Vÿ¤à@ éEÿÿÿÿuøVWèª+ ƒÄ Vÿ¤à@ ‹Ç_^[ÉËÿU‹ì3À9Ej ”Àh Pÿ¸à@ £t)A …Àu]Ã3À@£„*A ]ËÿU‹ìƒì¡€A ƒeø ƒeü SW¿Næ@»» ÿÿ;Çt
…Ãt ÷У„A ë`VEøPÿÌà@ ‹uü3uøÿÈà@ 3ðÿ”à@ 3ðÿÄà@ 3ðEðPÿÀà@ ‹Eô3Eð3ð;÷u¾Oæ@»ë …óu‹ÆÁà ð‰5€A ÷Ö‰5„A ^_[ÉËÿU‹ì‹Eƒøþuè¡ÑÿÿÇ 3À]ÃV3ö;Æ|;*A r èƒÑÿÿVVVVVÇ è ÑÿÿƒÄ3Àë‹Èƒà Áù‹ *A Áà¾Dƒà@^]á€A ƒÈ3É9x)A ”Á‹ÁÃÌÌÌÌÌÌÌÌÌ‹L$÷Á t$ŠƒÁ„ÀtN÷Á uï ¤$ ¤$ ‹ºÿþþ~Ѓðÿ3ƒÁ© tè‹Aü„Àt2„ät$© ÿ t© ÿtëÍAÿ‹L$+ÁÃAþ‹L$+ÁÃAý‹L$+ÁÃAü‹L$+ÁËÿU‹ìƒìSV‹u 3ÛW‹};óu;ûv‹E;Ãt‰3Àéƒ ‹E;ÃtƒÿÿÿÿÿvècÐÿÿj^SSSSS‰0èìÏÿÿƒÄ‹ÆëVÿuMðèã·ÿÿ‹Eð9X…œ f‹E¹ÿ f;Áv6;ót;ûv WSV訳ÿÿƒÄ èÐÿÿÇ * èÐÿÿ‹ 8]üt‹Møƒapý_^[ÉÃ;ót2;ûw,èåÏÿÿj"^SSSSS‰0ènÏÿÿƒÄ8]ü„yÿÿÿ‹Eøƒ`pýémÿÿÿˆ‹E;ÃtÇ 8]ü„%ÿÿÿ‹Eøƒ`pýéÿÿÿM QSWVjMQS‰] ÿpÿ°à@ ;Ãt9] …^ÿÿÿ‹M;Ët½‰ë¹ÿ\à@ ƒøz…Dÿÿÿ;ó„gÿÿÿ;û†_ÿÿÿWSVèѲÿÿƒÄ éOÿÿÿ‹ÿU‹ìj ÿuÿuÿu ÿuè|þÿÿƒÄ]ËÿU‹ìƒìÿu Mð誶ÿÿ¶E‹Mð‹‰È ·A% € €}ü t‹MøƒapýÉËÿU‹ìj ÿuè¹ÿÿÿYY]ÃÌV‹D$ Àu(‹L$‹D$ 3Ò÷ñ‹Ø‹D$÷ñ‹ð‹Ã÷d$‹È‹Æ÷d$ÑëG‹È‹\$‹T$ ‹D$ÑéÑÛÑêÑØ Éuô÷ó‹ð÷d$‹È‹D$÷æÑr;T$ wr;D$v N+D$T$3Û+D$T$ ÷Ú÷ØƒÚ ‹Ê‹Ó‹Ù‹È‹Æ^ ƒ%€*A ÃÌÌÌSVW‹T$‹D$‹L$URPQQh°i@ dÿ5 ¡€A 3ĉD$d‰% ‹D$0‹X‹L$,3‹p ƒþþt;‹T$4ƒúþt;òv.4v\³‹ ‰H ƒ{ uÌh ‹Cè1 ¹ ‹Cè1 ë°d ƒÄ_^[ËL$÷A ¸ t3‹D$‹H3ÈèµÿÿU‹hÿp ÿpÿpè>ÿÿÿƒÄ ]‹D$‹T$‰¸ ÃU‹L$‹)ÿq ÿqÿq(èÿÿÿƒÄ ] UVWS‹ê3À3Û3Ò3ö3ÿÿÑ[_^]Ëê‹ñ‹Ájè_0 3À3Û3É3Ò3ÿÿæU‹ìSVWj j hWj@ Qè—Q _^[]ÃU‹l$RQÿt$è´þÿÿƒÄ ] j h÷@ è Íÿÿƒeä ‹u;5p*A w"jèdÔÿÿYƒeü Vèa Y‰EäÇEüþÿÿÿè ‹Eäè)ÍÿÿÃjè_ÓÿÿYËÿU‹ìV‹uƒþà‡¡ SW‹=dà@ ƒ=t)A uè!íÿÿj èoëÿÿhÿ 轶ÿÿYY¡„*A ƒøu…öt‹Æë3À@Pë ƒøu VèSÿÿÿY…Àu…öuFƒÆƒæðVj ÿ5t)A ÿ׋؅Ûu.j ^9€)A tÿuèBôÿÿY…Àt‹ué{ÿÿÿèêËÿÿ‰0èãËÿÿ‰0_‹Ã[ëVèôÿÿYèÏËÿÿÇ 3À^]Ãjh°÷@ èÌÿÿ‹]…Ûuÿu èÿÿÿYéÌ ‹u …öu SèÏÿÿYé· ƒ=„*A …“ 3ÿ‰}äƒþà‡Š jèÓÿÿY‰}üSè6 Y‰Eà;Ç„ž ;5p*A wIVSPè ƒÄ …Àt‰]äë5Vèç Y‰Eä;Çt'‹CüH;Ær‹ÆPSÿuäè:$ Sèæ ‰EàSPè ƒÄ9}äuH;÷u3öF‰u ƒÆƒæð‰u VWÿ5t)A ÿdà@ ‰Eä;Çt ‹CüH;Ær‹ÆPSÿuäèæ# Sÿuàè¿ ƒÄÇEüþÿÿÿè. ƒ}à u1…öuFƒÆƒæð‰u VSj ÿ5t)A ÿÔà@ ‹øë‹u ‹]jèHÑÿÿYË}ä…ÿ…¿ 9=€)A t,Vè¤òÿÿY…À…ÒþÿÿèPÊÿÿ9}àul‹ðÿ\à@ PèûÉÿÿY‰ë_…ÿ…ƒ è+Êÿÿ9}àthÇ ëq…öuFVSj ÿ5t)A ÿÔà@ ‹ø…ÿuV9€)A t4Vè;òÿÿY…Àt ƒþàvÍVè+òÿÿYèßÉÿÿÇ 3ÀècÊÿÿÃèÌÉÿÿé|ÿÿÿ…ÿuè¾Éÿÿ‹ðÿ\à@ PènÉÿÿ‰Y‹ÇëÒ‹ÿU‹ì‹M S3Û;Ëv(jà3ÒX÷ñ;Es è‰ÉÿÿSSSSSÇ èÉÿÿƒÄ3ÀëA¯MVW‹ñ9]t ÿuèÈ) Y‹ØVÿuèýÿÿ‹øYY…ÿt;Þs+óVj ßSèȬÿÿƒÄ ‹Ç_^[]ËÿU‹ì‹
h*A ¡l*A kÉÈë‹U+P ú r ƒÀ;Árë3À]ËÿU‹ìƒì‹M‹AV‹u W‹þ+y ƒÆüÁï‹ÏiÉ ŒD ‰Mð‹I‰MüöÁ…Ó S 1‹‰Uô‹Vü‰Uø‹Uô‰] öÂutÁúJƒú?vj?Z‹K;KuB» €ƒú s‹ÊÓëL÷Ó!\¸Dþ u#‹M!ë JàÓëL÷Ó!œ¸Ä þ u‹M!Y‹] ‹S‹[‹MüMô‰Z‹U ‹Z‹R‰S‰Mü‹ÑÁúJƒú?vj?Z‹]øƒã‰]ô… +uø‹]øÁûj?‰u K^;Þv‹ÞMø‹ÑÁúJ‰Mü;Öv‹Ö;Út^‹M ‹q;qu;¾ €ƒû s‹ËÓî÷Ö!t¸DþLu!‹M!1ëKàÓî÷Ö!´¸Ä þLu‹M!q‹M ‹q‹I‰N‹M ‹q‹I‰N‹u ë‹]ƒ}ô u;Ú„€ ‹Mð Ñ‹Y‰N‰^‰q‹N‰q‹N;Nu`ŠLˆMþÁˆLƒú s%€} u‹Ê» €Óë‹M » €‹ÊÓëD¸D ë)€} uJà» €Óë‹M YJຠ€Óê„¸Ä ‹Eü‰‰D0ü‹Eðÿ…ó ¡|)A …À„Ø ‹
|*A ‹5¼à@ h @ ÁáH » € SQÿÖ‹
|*A ¡|)A º €Óê P¡|)A ‹@‹
|*A ƒ¤ˆÄ ¡|)A ‹@þHC¡|)A ‹H€yC u ƒ`þ¡|)A ƒxÿueSj ÿp ÿÖ¡|)A ÿpj ÿ5t)A ÿ`à@ ‹
h*A ¡|)A kÉ‹l*A +ÈLìQHQPèí+ ‹EƒÄ ÿ
h*A ;|)A vƒm¡l*A £t*A ‹E£|)A ‰=|*A [_^Éáx*A V‹5h*A W3ÿ;ðu4ƒÀkÀPÿ5l*A Wÿ5t)A ÿÔà@ ;Çu3Àëxƒx*A ‹5h*A £l*A kö5l*A hÄA jÿ5t)A ÿdà@ ‰F;ÇtÇjh h WÿØà@ ‰F ;ÇuÿvWÿ5t)A ÿ`à@ 뛃Nÿ‰>‰~ÿh*A ‹Fƒÿ‹Æ_^ËÿU‹ìQQ‹M‹ASV‹qW3ÛëÀC…À}ù‹ÃiÀ „0D j?‰EøZ‰@‰@ƒÀJuôj‹ûh Áçy h € WÿØà@ …ÀuƒÈÿé — p ‰Uü;úwC‹Ê+ÏÁé GAƒHøÿƒˆì ÿü ‰üïÿÿÇ@üð ‰PÇ€è ð IuË‹Uü‹Eøø O ‰H‰AJ ‰H‰AƒdžD 3ÿG‰¼žÄ ŠFCŠÈþÁ„À‹EˆNCu xº €‹ËÓê÷Ò!P‹Ã_^[ÉËÿU‹ìƒì ‹M‹ASV‹uW‹} ‹×+Q ƒÆÁê‹ÊiÉ ŒD ‰Mô‹OüƒæðI;ñ|9ü‹ ‰M‰]üŽU öÃ…E Ù;ó; ‹MüÁùI‰Møƒù?vj?Y‰Mø‹_;_uC» €ƒù sÓë‹MøL÷Ó!\Dþ u&‹M!ë ƒÁàÓë‹MøL÷Ó!œÄ þ u‹M!Y‹O‹_‰Y‹O‹‰y‹M+ÎMüƒ}ü Ž¥ ‹}ü‹M ÁÿOL1üƒÿ?vj?_‹]ô û‰]‹[‰Y‹]‰Y‰K‹Y‰K‹Y;YuWŠLˆMþÁˆLƒÿ s €} u‹Ï» €Óë‹M DD‹Ïë €} uOà» €Óë‹M Y„Ä Oຠ€Óê ‹U ‹MüD2ü‰‰Lüë‹U F‰Bü‰D2øé< 3Àé8 / ‹] )uN‰Kü\3ü‹uÁþN‰] ‰Küƒþ?vj?^öEü…€ ‹uüÁþNƒþ?vj?^‹O;OuB» €ƒþ s‹ÎÓët÷Ó!\Dþu#‹M!ë NàÓëL÷Ó!œÄ þ u‹M!Y‹] ‹O‹w‰q‹w‹O‰q‹uuü‰uÁþNƒþ?vj?^‹Mô ñ‹y‰K‰{‰Y‹K‰Y‹K;KuWŠLˆMþÁˆLƒþ s €} u‹Î¿ €Óï‹M 9DD‹Îë €} uNà¿ €Óï‹M y„Ä Nຠ€Óê ‹E‰‰Dü3À@_^[ÉËÿU‹ìƒì¡h*A ‹MkÀl*A ƒÁƒáð‰MðÁùSIƒù VW} ƒÎÿÓîƒMøÿë
ƒÁàƒÊÿ3öÓê‰Uø‹
t*A ‹Ùë‹S‹;#Uø#þ ×u
ƒÃ‰];Ørè;Øu‹ l*A ë‹S‹;#Uø#þ ×u
ƒÃ‰];Ùrè;Ùu[ë ƒ{ u
ƒÃ‰];Ørð;Øu1‹ l*A ë ƒ{ u
ƒÃ‰];Ùrð;Ùuè úÿÿ‹Ø‰]…Ûu3Àé Sè:ûÿÿY‹K‰‹Cƒ8ÿtå‰ t*A ‹C‹‰Uüƒúÿt‹ŒÄ ‹|D#Mø#þ Ïu)ƒeü ‹Ä HD‹9#Uø#þ ×uÿEü‹‘„ ƒÁëç‹Uü‹ÊiÉ ŒD ‰Mô‹LD3ÿ#Îu‹ŒÄ #Møj _ëÉG…É}ù‹Mô‹Tù‹
+Mð‹ñÁþNƒþ?‰Mø~j?^;÷„ ‹J;Ju\ƒÿ » €}&‹ÏÓë‹Mü|8÷Ó‰]ì#\ˆD‰\ˆDþu3‹Mì‹]! ë,OàÓë‹MüŒˆÄ |8÷Ó!þ‰]ìu ‹]‹Mì!Kë‹]ƒ}ø ‹J‹z‰y‹J‹z‰y„ ‹Mô ñ‹y‰J‰z‰Q‹J‰Q‹J;Ju^ŠLˆM þÁƒþ ˆL}#€} u ¿ €‹ÎÓï ;‹Î¿ €Óï‹Mü |ˆDë)€} u
Nà¿ €Óï {‹Mü¼ˆÄ Nྠ€Óî 7‹Mø…Ét ‰
‰Lüë‹Mø‹uðÑN‰
‰L2ü‹uô‹y‰>…Éu; |)A u‹Mü;
|*A uƒ%|)A ‹Mü‰B_^[ÉËÿU‹ìSV‹uW3ÿƒËÿ;÷u èQ¾ÿÿWWWWWÇ èÙ½ÿÿƒÄ ÃëBöF ƒt7VèÈÂÿÿV‹ØèÄ( VèO¼ÿÿPèë' ƒÄ…À}ƒËÿë‹F ;Çt
PènÁÿÿY‰~ ‰~ ‹Ã_^[]Ãj hÐ÷@ è3¾ÿÿƒMäÿ3À‹u3ÿ;÷•À;Çu èνÿÿÇ WWWWWèV½ÿÿƒÄƒÈÿë öF @t ‰~ ‹Eäè6¾ÿÿÃVè ÿÿY‰}üVè*ÿÿÿY‰EäÇEüþÿÿÿè ëÕ‹uVèY ÿÿYËÿU‹ì¸ä è8* ¡€A 3ʼnEü‹E V3ö‰…4åÿÿ‰µ8åÿÿ‰µ0åÿÿ9uu3Àéé ;Æu'èD½ÿÿ‰0è*½ÿÿVVVVVÇ è²¼ÿÿƒÄƒÈÿé¾ SW‹}‹ÇÁø4… *A ‹ƒç ÁçÇŠX$ÛÐû‰µ(åÿÿˆ'åÿÿ€ût€ûu0‹M÷ÑöÁu&èÛ¼ÿÿ3ö‰0迼ÿÿVVVVVÇ èG¼ÿÿƒÄéC ö@ tjj j ÿuèc ƒÄÿuèÕêÿÿY…À„ ‹öD€„ è‹Öÿÿ‹@l3É9H… åÿÿ”ÁP‹ÿ4‰ åÿÿÿàà@ …À„` 3É9 åÿÿt„Û„P ÿÜà@ ‹4åÿÿ‰… åÿÿ3À‰…<åÿÿ9E†B ‰…DåÿÿŠ…'åÿÿ„À…g Š ‹µ(åÿÿ3À€ù
”À‰… åÿÿ‹Çƒx8 tŠP4ˆUôˆMõƒ`8 jEôPëK¾ÁPè×ìÿÿY…Àt:‹4åÿÿ+ËM3À@;Ȇ¥ j…@åÿÿSPè<( ƒÄ ƒøÿ„± Cÿ…DåÿÿëjS…@åÿÿPè( ƒÄ ƒøÿ„ 3ÀPPjMôQj@åÿÿQPÿµ åÿÿCÿ…Dåÿÿÿ°à@ ‹ð…ö„\ j …<åÿÿPVEôP‹…(åÿÿ‹ ÿ4ÿ˜à@ …À„) ‹…Dåÿÿ‹0åÿÿÁ9µ<åÿÿ‰…8åÿÿŒ ƒ½ åÿÿ „Í j …<åÿÿPjEôP‹…(åÿÿ‹ ÆEô
ÿ4ÿ˜à@ …À„Ð ƒ½<åÿÿŒÏ ÿ…0åÿÿÿ…8åÿÿéƒ <t<u!·33Éfƒþ
”ÁCCƒ…Dåÿÿ‰µ@åÿÿ‰ åÿÿ<t<uRÿµ@åÿÿè%% Yf;…@åÿÿ…h ƒ…8åÿÿƒ½ åÿÿ t)j
XP‰…@åÿÿèø$ Yf;…@åÿÿ…; ÿ…8åÿÿÿ…0åÿÿ‹E9…Dåÿÿ‚ùýÿÿé' ‹Šÿ…8åÿÿˆT4‹‰D8é 3É‹Çö@€„¿ ‹…4åÿÿ‰@åÿÿ„Û…Ê ‰…<åÿÿ9M† 답(åÿÿ‹<åÿÿƒ¥Dåÿÿ +4åÿÿ…Håÿÿ;Ms9‹•<åÿÿÿ…<åÿÿŠA€ú
uÿ…0åÿÿÆ
@ÿ…Dåÿÿˆ@ÿ…Dåÿÿ½Dåÿÿÿ r‹؅Håÿÿ+Øj …,åÿÿPS…HåÿÿP‹ÿ4ÿ˜à@ …À„B ‹…,åÿÿ…8åÿÿ;ÃŒ: ‹…<åÿÿ+…4åÿÿ;E‚Lÿÿÿé ‰…Dåÿÿ€û…Ñ 9M†M 답(åÿÿ‹Dåÿÿƒ¥<åÿÿ +4åÿÿ…Håÿÿ;MsF‹•Dåÿÿƒ…Dåÿÿ·AAfƒú
uƒ…0åÿÿj
[f‰@@ƒ…<åÿÿƒ…<åÿÿf‰@@½<åÿÿþ rµ‹Ø…Håÿÿ+Øj …,åÿÿPS…HåÿÿP‹ÿ4ÿ˜à@ …À„b ‹…,åÿÿ…8åÿÿ;ÃŒZ ‹…Dåÿÿ+…4åÿÿ;E‚?ÿÿÿé@ 9M†| ‹Dåÿÿƒ¥<åÿÿ +4åÿÿj…Hùÿÿ^;Ms<‹•Dåÿÿ·µDåÿÿÎfƒú
uj
[f‰Æµ<åÿÿµ<åÿÿf‰Æ½<åÿÿ¨ r¿3öVVhU
ðëÿÿQHùÿÿ+Á™+ÂÑøP‹ÁPVhéý ÿ°à@ ‹Ø;Þ„— j …,åÿÿP‹Ã+ÆP„5ðëÿÿP‹…(åÿÿ‹ ÿ4ÿ˜à@ …Àt µ,åÿÿ;ÞËë ÿ\à@ ‰…@åÿÿ;Þ\‹…Dåÿÿ+…4åÿÿ‰…8åÿÿ;E‚
ÿÿÿë?j ,åÿÿQÿuÿµ4åÿÿÿ0ÿ˜à@ …Àt‹…,åÿÿƒ¥@åÿÿ ‰…8åÿÿë ÿ\à@ ‰…@åÿÿƒ½8åÿÿ ulƒ½@åÿÿ t-j^9µ@åÿÿu貶ÿÿÇ èº¶ÿÿ‰0ë?ÿµ@åÿÿ辶ÿÿYë1‹µ(åÿÿ‹öD@t‹…4åÿÿ€8u3Àë$èr¶ÿÿÇ èz¶ÿÿƒ ƒÈÿë ‹…8åÿÿ+…0åÿÿ_[‹Mü3Í^èØÿÿÉÃjhð÷@ 脶ÿÿ‹Eƒøþuè>¶ÿÿƒ è#¶ÿÿÇ ƒÈÿé 3ÿ;Ç|;*A r!è¶ÿÿ‰8èûµÿÿÇ WWWWW胵ÿÿƒÄëÉ‹ÈÁù *A ‹ðƒæ Áæ‹ ¾L1ƒát¿Pè9$ Y‰}ü‹öD0tÿuÿu ÿuè.øÿÿƒÄ ‰Eäë蘵ÿÿÇ è µÿÿ‰8ƒMäÿÇEüþÿÿÿè ‹Eäè¶ÿÿÃÿuèƒ$ YÃjhø@ 訵ÿÿ‹EƒøþuèOµÿÿÇ ƒÈÿéª 3Û;Ã|;*A rè.µÿÿÇ SSSSS趴ÿÿƒÄëЋÈÁù< *A ‹ðƒæ Á拾LƒátÆPèl# Y‰]ü‹öDt1ÿuèà" YPÿäà@ …Àu ÿ\à@ ‰Eäë‰]ä9]ätèÍ´ÿÿ‹Mä‰è°´ÿÿÇ ƒMäÿÇEüþÿÿÿè ‹Eäè#µÿÿÃÿuè¢# YËÿU‹ìƒìS3Û9]u èr´ÿÿSSSSSÇ èú³ÿÿƒÄ3ÀëjV‹u ;óuèN´ÿÿSSSSSÇ èÖ³ÿÿƒÄë9ur3Àë>ÿuMðèÆ›ÿÿ‹MôFÿ9Yt H9Ew
¶öD
uð‹Î+ȃá+ñN‹Æ8]üt‹Møƒapý^[ÉËÿU‹ìj ÿu ÿuèUÿÿÿƒÄ ]ËÿU‹ìƒìS3ÛV‹u9]u;óu9] u3Àéç ;ót9] w 襳ÿÿj^SSSSS‰0è.³ÿÿƒÄ‹ÆéÀ 9]uˆ ëÉW‹};ûu ˆ èt³ÿÿj^SSSSS‰0èý²ÿÿƒÄé( ÿuMìèóšÿÿ‹Eð9XuÿuWÿu Vè£
ƒÄéL ƒ}ÿ‹U ‹ÆuŠˆ@G:Ët Juó늈@G:ËtJtÿMuî9]uˆ@;Ó…È 8 tƒ}u5xÿ‰}ü;þr EìP‹Eü¶ PèоÿÿYY…ÀtÿMü9uüsâ‹Ç+Eü¨…à ƒ}ÿuZ‹E ƒøv:|þ‰};þr!EìP‹E¶ P茾ÿÿYY…ÀtÿM9usâ‹E ‹Ï+MöÁtˆ ëˆ\ÿ8]øt‹Eôƒ`pýjPXé ˆ èS²ÿÿj"^SSSSS‰0èܱÿÿƒÄ8]øt‹Eôƒ`pý‹Æëd‹È+΃ù|Mxþ‰};þr EìP‹E¶ Pè ¾ÿÿYY…ÀtÿM9usâ‹Ç+E¨t ˆ èð±ÿÿ‹Èj*X‰8]øt‹Môƒapýë8]øt‹Eôƒ`pý3À_^[ÉËÿU‹ì‹E…Àtƒè8ÝÝ uPèµÿÿY]ËÿU‹ìƒì¡€A 3ʼnEüSV3ÛW‹ñ9 „)A u8SS3ÿGWhdê@ h Sÿðà@ …Àt‰=„)A ëÿ\à@ ƒøxu
Ç„)A 9]~"‹M‹EI8t@;ËuöƒÉÿ‹E+ÁH;E}@‰E¡„)A ƒø„¬ ;Ĥ ƒø…Ì ‰]ø9] u‹‹@‰E ‹5ìà@ 3À9]$SSÿu•ÀÿuÅ Pÿu ÿÖ‹ø;û„ ~Cjà3ÒX÷÷ƒør7D?= wèŽ# ‹Ä;Ãt Ç ÌÌ ëPè äÿÿY;Ãt Ç ÝÝ ƒÀ‰Eôë‰]ô9]ô„> Wÿuôÿuÿujÿu ÿÖ…À„ã ‹5ðà@ SSWÿuôÿu ÿuÿ֋ȉMø;Ë„Â ÷E t)9] „° ;M § ÿu ÿuWÿuôÿu ÿuÿÖé ;Ë~Ejà3ÒX÷ñƒør9D = wèÏ" ‹ô;ótjÇÌÌ ƒÆëPèJãÿÿY;Ãt Ç ÝÝ ƒÀ‹ðë3ö;ótAÿuøVWÿuôÿu ÿuÿðà@ …Àt"SS9] uSSëÿu ÿuÿuøVSÿu ÿ°à@ ‰EøVè¸ýÿÿYÿuôè¯ýÿÿ‹EøYéY ‰]ô‰]ð9]u‹‹@‰E9] u‹‹@‰E ÿuè Y‰Eìƒøÿu3Àé! ;E „Û SSMQÿuPÿu è> ƒÄ‰Eô;ÃtÔ‹5èà@ SSÿuPÿu ÿuÿÖ‰Eø;Ãu3öé· ~=ƒøàw8ƒÀ= wè¹! ‹ü;ûtÝÇÌÌ ƒÇëPè4âÿÿY;Ãt Ç ÝÝ ƒÀ‹øë3ÿ;ût´ÿuøSWè0’ÿÿƒÄ ÿuøWÿuÿuôÿu ÿuÿÖ‰Eø;Ãu3öë%ÿu EøÿuPWÿu ÿuìè ‹ð‰uðƒÄ÷Þö#uøWèüÿÿYëÿu ÿuÿuÿuÿu ÿuÿèà@ ‹ð9]ôt ÿuô蘱ÿÿY‹Eð;Ãt 9EtPè…±ÿÿY‹Æeà_^[‹Mü3Íè—•ÿÿÉËÿU‹ìƒìÿuMðè‘•ÿÿÿu(Mðÿu$ÿu ÿu ÿuÿuÿuÿu è(üÿÿƒÄ €}ü t‹MøƒapýÉËÿU‹ìQQ¡€A 3ʼnEü¡ˆ)A SV3ÛW‹ù;Ãu:EøP3öFVhdê@ Vÿøà@ …Àt‰5ˆ)A ë4ÿ\à@ ƒøxu
jX£ˆ)A 롈)A ƒø„Ï ;Ã„Ç ƒø…è ‰]ø9]u‹‹@‰E‹5ìà@ 3À9] SSÿu•Àÿu Å PÿuÿÖ‹ø;û„« ~<ÿðÿÿw4D?= wèÒ ‹Ä;Ãt Ç ÌÌ ëPèPàÿÿY;Ãt Ç ÝÝ ƒÀ‹Ø…Ûti?Pj SèNÿÿƒÄ WSÿuÿu jÿuÿÖ…ÀtÿuPSÿuÿøà@ ‰EøSèÉúÿÿ‹EøYëu3ö9] u‹‹@‰E 9]u‹‹@‰Eÿu èA Yƒøÿu3ÀëG;Et SSMQÿu Pÿuèi ‹ðƒÄ;ót܉u ÿuÿuÿu ÿuÿu ÿôà@ ‹ø;ótV膯ÿÿY‹Çeì_^[‹Mü3Í蘓ÿÿÉËÿU‹ìƒìÿuMðè’“ÿÿÿu$Mðÿu ÿu ÿuÿuÿuÿu èþÿÿƒÄ €}ü t‹MøƒapýÉËÿU‹ìV‹u…ö„ ÿvè¯ÿÿÿvè¯ÿÿÿv è¯ÿÿÿvèþ®ÿÿÿvèö®ÿÿÿvèî®ÿÿÿ6èç®ÿÿÿv èß®ÿÿÿv$è×®ÿÿÿv(èÏ®ÿÿÿv,èÇ®ÿÿÿv0è¿®ÿÿÿv4è·®ÿÿÿv 诮ÿÿÿv8觮ÿÿÿv<蟮ÿÿƒÄ@ÿv@è”®ÿÿÿvD茮ÿÿÿvHè„®ÿÿÿvLè|®ÿÿÿvPèt®ÿÿÿvTèl®ÿÿÿvXèd®ÿÿÿv\è\®ÿÿÿv`èT®ÿÿÿvdèL®ÿÿÿvhèD®ÿÿÿvlè<®ÿÿÿvpè4®ÿÿÿvtè,®ÿÿÿvxè$®ÿÿÿv|è ®ÿÿƒÄ@ÿ¶€ è®ÿÿÿ¶„ è®ÿÿÿ¶ˆ èøÿÿÿ¶Œ èíÿÿÿ¶ èâÿÿÿ¶” è×ÿÿÿ¶˜ èÌÿÿÿ¶œ èÁÿÿÿ¶ è¶ÿÿÿ¶¤ è«ÿÿÿ¶¨ è ÿÿƒÄ,^]ËÿU‹ìV‹u…öt5‹;H A tPè}ÿÿY‹F;L A tPèkÿÿY‹v;5P A tVèYÿÿY^]ËÿU‹ìV‹u…öt~‹F ;T A tPè7ÿÿY‹F;X A tPè%ÿÿY‹F;\ A tPèÿÿY‹F;` A tPèÿÿY‹F ;d A tPèï¬ÿÿY‹F ;h A tPèݬÿÿY‹v$;5l A tVèˬÿÿY^]ËÿU‹ì‹ES3ÛVW;Ãt‹} ;ûwè=©ÿÿj^‰0SSSSSèƨÿÿƒÄ‹Æë<‹u;óuˆëÚ‹Ð8tBOuø;ût
BF:ËtOuó;ûuˆèö¨ÿÿj"Y‰‹ñëµ3À_^[]ÃÌÌÌÌÌÌU‹ìV3ÀPPPPPPPP‹U I Š
Àt ƒÂ«$ëñ‹uƒÉÿI ƒÁŠ
Àt ƒÆ£$sî‹ÁƒÄ ^ÉËÿU‹ìSV‹u3ÛW9]u;óu9] u3À_^[]Ã;ót‹} ;ûwèh¨ÿÿj^‰0SSSSSèñ§ÿÿƒÄ‹ÆëÕ9]uˆ ëÊ‹U;Óuˆ ëу}ÿ‹ÆuŠ
ˆ@B:Ët OuóëŠ
ˆ@B:ËtOtÿMuî9]uˆ;ûu‹ƒ}ÿu‹E jPˆ\ÿXéxÿÿÿˆ èî§ÿÿj"Y‰‹ñë‚‹ÿU‹ì‹MS3ÛVW;Ët‹} ;ûwèȧÿÿj^‰0SSSSSèQ§ÿÿƒÄ‹Æë0‹u;óuˆëÚ‹ÑŠˆBF:ÃtOuó;ûuˆè§ÿÿj"Y‰‹ñëÁ3À_^[]ÃÌÌÌÌÌÌÌÌÌÌÌÌÌ‹T$‹L$÷ u<‹:u.
Àt&:au%
ät Áè:Au
Àt:auƒÁƒÂ
äuÒ‹ÿ3ÀÃÀÑàƒÀÃ÷ tŠƒÂ:uçƒÁ
ÀtÜ÷ t¤f‹ƒÂ:uÎ
ÀtÆ:auÅ
ät½ƒÁëˆÌÌÌÌÌÌÌÌU‹ìWV‹u ‹M‹}‹Á‹ÑÆ;þv;ø‚¤ ù r ƒ=ˆ*A tWVƒçƒæ;þ^_u^_]é, ÷Ç uÁéƒâƒùr*ó¥ÿ$•ä‘@ ‹Çº ƒér ƒàÈÿ$…ø@ ÿ$ô‘@ ÿ$x‘@ ‘@ 4‘@ X‘@ #ÑŠˆŠFˆGŠFÁéˆGƒÆƒÇƒùrÌó¥ÿ$•ä‘@ I #ÑŠˆŠFÁéˆGƒÆƒÇƒùr¦ó¥ÿ$•ä‘@ #ÑŠˆƒÆÁéƒÇƒùrˆó¥ÿ$•ä‘@ I Û‘@ È‘@ À‘@ ¸‘@ °‘@ ¨‘@ ‘@ ˜‘@ ‹DŽä‰Dä‹DŽè‰Dè‹DŽì‰Dì‹DŽð‰Dð‹DŽô‰Dô‹DŽø‰Dø‹DŽü‰Dü ðøÿ$•ä‘@ ‹ÿô‘@ ü‘@ ’@ ’@ ‹E^_Éʈ‹E^_ÉʈŠFˆG‹E^_ÉÃI ŠˆŠFˆGŠFˆG‹E^_ÉÃt1ü|9ü÷Ç u$Áéƒâƒùr
ýó¥üÿ$•€“@ ‹ÿ÷Ùÿ$0“@ I ‹Çº ƒùr ƒà+Èÿ$…„’@ ÿ$€“@ ”’@ ¸’@ à’@ ŠF#шGƒîÁéƒïƒùr²ýó¥üÿ$•€“@ I ŠF#шGŠFÁéˆGƒîƒïƒùrˆýó¥üÿ$•€“@ ŠF#шGŠFˆGŠFÁéˆGƒîƒïƒù‚Vÿÿÿýó¥üÿ$•€“@ I 4“@ <“@ D“@ L“@ T“@ \“@ d“@ w“@ ‹DŽ ‰D ‹DŽ‰D‹DŽ‰D‹DŽ‰D‹DŽ ‰D ‹DŽ‰D‹DŽ‰D ðøÿ$•€“@ ‹ÿ“@ ˜“@ ¨“@ ¼“@ ‹E^_ÉÊFˆG‹E^_ÉÃI ŠFˆGŠFˆG‹E^_ÉÊFˆGŠFˆGŠFˆG‹E^_ÉÃÌÌÌÌÌÌÌÌÌÌÌU‹ìV3ÀPPPPPPPP‹U I Š
Àt ƒÂ«$ëñ‹u‹ÿŠ
Àt ƒÆ£$sñFÿƒÄ ^ÉËÿU‹ìQQ‹E V‹u‰Eø‹EWV‰Eüè ƒÏÿY;Çuè£ÿÿÇ ‹Ç‹×ëJÿuMüQÿuøPÿ á@ ‰Eø;Çuÿ\à@ …Àt Pè÷¢ÿÿYëÏ‹ÆÁø‹… *A ƒæ ÁæD0€ ý‹Eø‹Uü_^ÉÃjh0ø@ èë¢ÿÿƒÎÿ‰u܉uà‹Eƒøþu 蜢ÿÿƒ è¢ÿÿÇ ‹Æ‹ÖéÐ 3ÿ;Ç|;*A r!èr¢ÿÿ‰8èX¢ÿÿÇ WWWWWèà¡ÿÿƒÄëÈ‹ÈÁù *A ‹ðƒæ Áæ‹ ¾L1ƒáu&è1¢ÿÿ‰8è¢ÿÿÇ WWWWW蟡ÿÿƒÄƒÊÿ‹Âë[Pèp Y‰}ü‹öD0t ÿuÿuÿu ÿuè©þÿÿƒÄ‰E܉UàëèÉ¡ÿÿÇ èÑ¡ÿÿ‰8ƒMÜÿƒMàÿÇEüþÿÿÿè ‹EÜ‹Uàè.¢ÿÿÃÿuè YËÿU‹ìÿ A h è¹£ÿÿY‹M‰A…Àt
ƒI ÇA ëƒI A‰AÇA ‹Aƒa ‰]ËÿU‹ìƒìSVWè¹ÿÿƒeü ƒ=)A ‹Ø…Ž h ô@ ÿœà@ ‹ø…ÿ„* ‹5(à@ hôó@ WÿÖ…À„ PèL¸ÿÿÇ$äó@ W£)A ÿÖPè7¸ÿÿÇ$Ðó@ W£”)A ÿÖPè"¸ÿÿÇ$´ó@ W£˜)A ÿÖPè
¸ÿÿY£ )A …Àthœó@ WÿÖPèõ·ÿÿY£œ)A ¡œ)A ;ÃtO9 )A tGPèS¸ÿÿÿ5 )A ‹ðèF¸ÿÿYY‹ø…öt,…ÿt(ÿÖ…ÀtMøQj MìQjPÿ×…ÀtöEôu M ë9¡”)A ;Ãt0Pè¸ÿÿY…Àt%ÿЉEü…Àt ¡˜)A ;ÃtPèæ·ÿÿY…ÀtÿuüÿЉEüÿ5)A èηÿÿY…Àtÿuÿu ÿuÿuüÿÐë3À_^[ÉËÿU‹ì‹MV3ö;Î| ƒù~ ƒùu¡D A ë(¡D A ‰
D A ë讟ÿÿVVVVVÇ è6ŸÿÿƒÄƒÈÿ^]ÃjhPø@ èÕŸÿÿ3À‹]3ÿ;ß•À;Çu ètŸÿÿÇ WWWWWèüžÿÿƒÄƒÈÿëSƒ=„*A u8jèõ¦ÿÿY‰}üSèÖÿÿY‰Eà;Çt ‹süƒî ‰uäë‹uäÇEüþÿÿÿè% 9}àuSWÿ5t)A ÿá@ ‹ð‹Æè•ŸÿÿÃ3ÿ‹]‹uäjèÃ¥ÿÿYÃjèÿˆÿÿYËÿU‹ìì( ¡€A 3ʼnEüö A Vtj
èÓ½ÿÿYèªÄÿÿ…Àtjè¬ÄÿÿYö A „Ê ‰…àýÿÿ‰Üýÿÿ‰•Øýÿÿ‰Ôýÿÿ‰µÐýÿÿ‰½ÌýÿÿfŒ•øýÿÿfŒìýÿÿfŒÈýÿÿfŒ…ÄýÿÿfŒ¥ÀýÿÿfŒ¼ýÿÿœ…ðýÿÿ‹uE‰…ôýÿÿÇ…0ýÿÿ ‰µèýÿÿ‹@üjP‰…äýÿÿ…Øüÿÿj Pèªÿÿ…ØüÿÿƒÄ ‰…(ýÿÿ…0ýÿÿj Ç…Øüÿÿ @‰µäüÿÿ‰…,ýÿÿÿTà@ …(ýÿÿPÿPà@ jèmŠÿÿÌÌÌU‹ìSVWUj j h˜™@ ÿuèV" ]_^[‹å]ËL$÷A ¸ t2‹D$‹Hü3Èè"…ÿÿU‹h‹P(R‹P$Rè ƒÄ]‹D$‹T$‰¸ ÃSVW‹D$UPjþh ™@ dÿ5 ¡€A 3ÄPD$d£ ‹D$(‹X‹p ƒþÿt:ƒ|$,ÿt;t$,v-4v‹ ³‰L$ ‰H ƒ|³ uh ‹D³èI ‹D³è_ ë·‹L$d‰
ƒÄ_^[Ã3Àd‹
y ™@ u‹Q ‹R 9Qu¸ ÃSQ»” A ë SQ»” A ‹L$ ‰K‰C‰k UQPXY]Y[ ÿÐËÿU‹ìƒìVWÿuMìè%„ÿÿ‹E‹u 3ÿ;Çt‰0;÷u,èmœÿÿWWWWWÇ èõ›ÿÿƒÄ€}ø t‹Eôƒ`pý3ÀéØ 9}t ƒ}|Ƀ}$ËMìSŠ ‰}ü~ƒ¹¬ ~EìP¶ÃjPè¹ÿÿ‹MìƒÄ ë‹‘È ¶Ã·Bƒà…ÀtŠ GëÇ€û-uƒMë€û+uŠ G‹E…ÀŒK ƒø„B ƒø$9 …Àu*€û0t ÇE
ë4Š·É¶ÒÁá Ê9M u Hë ·Ñ9U t
@f¶·Éf;ËuÇ·É9M u8]üt‹Møƒapýë8]üt‹Eøƒ`pý3À^[ÉËÿU‹ìj ÿu ÿuè2ÿÿÿƒÄ ]ÃÌÌÌBÿ[ä$ d$ 3ÀŠD$S‹ØÁà‹T$÷ tŠ
ƒÂ:ËtÏ„ÉtQ÷ uë ØW‹ÃÁãV Ø‹
¿ÿþþ~‹Á‹÷3Ëðùƒñÿƒðÿ3Ï3ƃÂá u % tÓ% uæ €uÄ^_[3ÀËBü:Ãt6„Àtï:ãt'„ätçÁè:Ãt„ÀtÜ:ãt„ätÔë–^_Bÿ[ÃBþ^_[ÃBý^_[ÃBü^_[Ãÿ%Ðà@ ‹ÿU‹ì‹US3Û;Óu èH{ÿÿSSSSSÇ èÐzÿÿƒÄƒÈÿë 8tß‹M ;ËtØ‹;ÃtÒ8tÎSQRè ƒÄ []ËÿU‹ìƒì ‹UV‹ujþX‰Eì‰Uä;ðuèÿzÿÿƒ èäzÿÿÇ ƒÈÿéˆ S3Û;ó|;5*A r'èÕzÿÿ‰è»zÿÿSSSSSÇ èCzÿÿƒÄƒÈÿéQ ‹ÆÁøW<… *A ‹ƒæ ÁæÆŠHöÁuèzÿÿ‰èuzÿÿÇ ëjúÿÿÿwP‰]ð;Ó„ öÁ…ÿ 9] t7Š@$ÀÐøˆEþ¾ÀHjYt Hu‹Â÷Шtƒâþ‰U‹E ‰Eôé ‹Â÷Шu!è#zÿÿ‰è zÿÿÇ SSSSSè‘yÿÿƒÄë4‹ÂÑè‰M;Ár‰Eÿuè|ÿÿY‰Eô;Ãu èÑyÿÿÇ èÙyÿÿÇ ƒÈÿéh jSSÿuè|Öÿÿ‹‰D(‹EôƒÄ‰T,‹ÎöAHttŠI€ù
tl9]tgˆ‹@ÿMÇEð ÆD
8]þtN‹ŠL%€ù
tC9]t>ˆ‹@ÿM€}þÇEð ÆD%
u$‹ŠL&€ù
t9]tˆ‹@ÿMÇEð ÆD&
SMèQÿuP‹ÿ4ÿ,á@ …À„{ ‹Mè;ËŒp ;M‡g ‹MðDö €„æ €}þ„ ;Ët
‹Mô€9
u€ë€ û‹]ô‹EðÉ]‰Eð;؃Р‹MŠ<„® <
t ˆCA‰Mé ‹EðH;ÈsA€8
u
AA‰MÆ
ëu‰EëmÿEj EèPjEÿP‹ÿ4ÿ,á@ …Àu
ÿ\à@ …ÀuEƒ}è t?‹öDHt€}ÿ
t¹Æ
‹ŠMÿˆLë%;]ôu€}ÿ
t jjÿjÿÿuèØÔÿÿƒÄ€}ÿ
tÆ
C‹Eð9E‚Gÿÿÿë‹Dö @u€ëŠˆC‹Ã+Eô€}þ‰Eð…Ð …À„È KŠ „ÉxCé† 3À@¶Éëƒø;]ôrK¶ @€¹à A t芶ʾ‰à A …Éu
è|wÿÿÇ * ëzA;ÈuØë@‹ÎöAHt$CƒøˆQ| Š‹ˆT%Cƒøu Š‹ˆT&C+Øë÷Ø™jRPÿuèþÓÿÿƒÄ‹Eä+]ôÑèPÿu Sÿuôj héý ÿìà@ ‰Eð…Àu4ÿ\à@ Pè!wÿÿYƒMìÿ‹Eô;E tPèUzÿÿY‹Eìƒøþ…‹ ‹Eðéƒ ‹Eð‹3É;ÕÁÀ‰Eð‰L0ëÆ;Ët‹Môfƒ9
u€ë€ û‹]ô‹EðÉ]‰Eð;؃ÿ ‹E·fƒù„× fƒù
tf‰ CC@@‰Eé´ ‹MðƒÁþ;Ás Hfƒ9
u
ƒÀ‰Ej
éŽ ‰Mé„ ƒEj EèPjEøP‹ÿ4ÿ,á@ …Àu
ÿ\à@ …Àu[ƒ}è tU‹öDHt(fƒ}ø
t²j
Xf‰‹ŠMøˆL‹ŠMùˆL%‹ÆD&
ë*;]ôufƒ}ø
t…jjÿjþÿuèšÒÿÿƒÄfƒ}ø
tj
Xf‰CC‹Eð9E‚ÿÿÿë‹tö@u€ëf‹ f‰CC+]ô‰]ðé‘þÿÿÿ\à@ j^;ÆuèuuÿÿÇ è}uÿÿ‰0éiþÿÿƒøm…Yþÿÿ‰]ìé\þÿÿ3À_[^ÉÃjhøø@ è‹uÿÿ‹EƒøþuèEuÿÿƒ è*uÿÿÇ ƒÈÿé¾ 3ö;Æ|;*A r!è uÿÿ‰0èuÿÿÇ VVVVVèŠtÿÿƒÄëÉ‹ÈÁù *A ‹øƒç Áç‹ ¾L9ƒát¿¹ÿÿÿ;MÉAuèÎtÿÿ‰0è´tÿÿÇ ë°Pè ãÿÿY‰uü‹öD8tÿuÿu ÿuè~ùÿÿƒÄ ‰Eäëè~tÿÿÇ è†tÿÿ‰0ƒMäÿÇEüþÿÿÿè ‹EäèêtÿÿÃÿuèiãÿÿYËÿU‹ìƒì0S3ÛöE€VW‹ð‰]àˆ]þÇEÐ ‰]Ôt ‰]ØÆEÿë
ÇEØ ˆ]ÿEàPè
Y…Àt
SSSSSènrÿÿƒÄ‹M¸ € …Èu÷Á @ u9Eàt€Mÿ€‹Áƒà+ú À¿ €tGHt.Ht&èÓsÿÿ‰ƒÿè¶sÿÿj^SSSSS‰0è?sÿÿƒÄé ‰UøëöÁt÷Á uîÇEø @ë‰}ø‹EjY+Át7+Át*+Át +Átƒè@u¡9}ø”À‰Eðë ÇEð ëÇEð ë ÇEð ë‰]ð‹Eº #¹ ;Á¿ ;t0;Ãt,;Çt = „” = …@ÿÿÿÇEì ë/ÇEì ë&ÇEì ë = t= t`;Â…ÿÿÿÇEì ‹EÇEô€ …Çt‹
A ÷Ñ#M„ÉxÇEô ¨@tMô Mø ƒMð© t }ô¨ tMô ëÇEì 릨tMô è£áÿÿ‰ƒøÿuèjrÿÿ‰ƒÿèMrÿÿÇ éŽ ‹E‹= á@ SÿuôÇ ÿuìEÐPÿuðÿuøÿu ÿ׉Eäƒøÿum‹Mø¸ À#È;Èu+öEt%eøÿÿÿSÿuôEÐÿuìPÿuðÿuøÿu ÿ׉Eäƒøÿu4‹6‹ÆÁø‹… *A ƒæ ÁæD0€ þÿ\à@ PèÛqÿÿYè¯qÿÿ‹ ét ÿuäÿ@à@ ;ÃuD‹6‹ÆÁø‹… *A ƒæ ÁæD0€ þÿ\à@ ‹ðVè˜qÿÿYÿuäÿá@ ;óu°è_qÿÿÇ
룃øu€Mÿ@ë ƒøu€Mÿÿuäÿ6è4Þÿÿ‹‹Ðƒà Áú‹• *A YÁàYŠMÿ€ÉˆL‹‹Ðƒà Áú‹• *A ÁàD$€ €ˆMý€eýHˆMÿ…€ öÁ€„± öEtqjƒÏÿWÿ6è£ ƒÄ ‰Eè;ÇuèÖpÿÿ8ƒ tMÿ6èéÙÿÿéúþÿÿjEüPÿ6ˆ]üè’õÿÿƒÄ …Àu€}üu‹Eè™RPÿ6è ƒÄ ;ÇtÃSSÿ6èF ƒÄ ;Çt³öEÿ€„0 ¿ @ ¹ @ …}u‹Eà#Çu Më E‹E#Ç;ÁtD= t)= @ t"= t)= @ t"= t= @ u ÆEþë‹M¸ #È;Èu ÆEþëˆ]þ÷E „µ öEÿ@‰]è…¨ ‹Eø¹ À#Á= @„· = €tw;Á…„ ‹Eì;Æy ƒøvƒøv0ƒø…f ¾Eþ3ÿH„& H…R ÇEèÿþ ÇEì é jSSÿ6è8ÌÿÿƒÄ ÂtÇSSSÿ6è'Ìÿÿ#ƒăøÿ„ŽþÿÿjEèPÿ6è/ôÿÿƒÄ ƒøÿ„uþÿÿƒøtkƒø… }è uYÆEþéÜ ‹Eì;Ã†Ñ ƒø†bÿÿÿƒø‡PÿÿÿjSSÿ6è¸ËÿÿƒÄ „CÿÿÿSSSÿ6è£ËÿÿƒÄ#ƒøÿ…‘ éþÿÿ‹Eè%ÿÿ =þÿ uÿ6èß×ÿÿYè¤nÿÿj^‰0‹Æéd =ÿþ u Sjÿ6èX ƒÄ ƒøÿ„ÀýÿÿÆEþëASSÿ6è= ƒÄ ë™ÇEè ÇEì ‹Eì+ÇPD=èPÿ6è¸ÿÿƒÄ ƒøÿ„€ýÿÿø9}ìÛ‹‹ÈÁù‹ *A ƒà ÁàD$Š2Mþ€á0‹‹ÈÁù‹ *A ƒà ÁàD$‹MŠÁéÀá€â
ʈ8]ýu!öEt‹‹Èƒà Áù‹ *A ÁàD€ ‹}ø¸ À‹Ï#È;Èu|öEtvÿuäÿá@ SÿuôEÐjPÿuðçÿÿÿWÿu ÿ á@ ƒøÿu4ÿ\à@ Pè›mÿÿ‹‹Èƒà Áù‹ *A ÁàD€ þÿ6èÏÚÿÿYé˜ûÿÿ‹6‹ÎÁù‹ *A ƒæ Á手Ã_^[ÉÃjhù@ èomÿÿƒMäÿ3ö‰uà3À9u•À;Æu è mÿÿÇ VVVVVè‘lÿÿƒÄƒÈÿër‰uüÿuj@ÿu ÿuEàPEäè‰øÿÿƒÄ‰EÜÇEüþÿÿÿè ‹}Ü;þt<è¹lÿÿ‰8ë¿3ö9uàt+9uÜt ‹EäÁø‹Mäƒá Áá‹… *A D€ þÿuäèÛÿÿYËEäè mÿÿËÿU‹ìQQV3ö9uu èelÿÿVVVVVÇ èíkÿÿƒÄƒÈÿëJ9u tÞÿuEøPEüPÿuÿu è| ƒÄƒøÿtØÿuøÿuüÿujèU ÿuü‹ðè}oÿÿÿuøèuoÿÿƒÄ‹Æ^ÉËÿU‹ìƒìSW‹}3Û‰}ü;ûu èåkÿÿSSSSSÇ èmkÿÿƒÄƒÈÿéá 8 tÜ‹E ;ÃtÕ‹ ;ÃtÏ8tËVj\Wè j/W‹ðè
ƒÄ;Ã… ;ó…ƒ j:Wè=ïÿÿ‹ðYY;óusWèIšÿÿ‹ðƒÆjVèímÿÿ‹øƒÄ ‰}ü;û„ htô@ VWèkÃÿÿƒÄ …Àt
SSSSSè¯iÿÿƒÄÿuVWèØÁÿÿƒÄ …Àt
SSSSSè‘iÿÿƒÄw‹}ë
;ót;Æv‹ðƒMðÿj.Vèh YY…Àt,Sÿuüè
YY…À…ì ÿuÿu ÿuüè`þÿÿƒÄ ‰EðéÓ ÿuüè–™ÿÿ‹ðƒÆjVè:mÿÿƒÄ ‰Eø;ÃuƒÈÿé½ ÿuüVPè¸ÂÿÿƒÄ …Àt
SSSSSèühÿÿƒÄÿuüèQ™ÿÿ‹ø}øYèvjÿÿ‹ ‰Eì‹Eø+÷ðÇEôì A ‹Eôÿ0VWèrÂÿÿƒÄ …Àt
SSSSSè¶hÿÿƒÄSÿuøè] YY…Àtƒmô}ôà A }Äë è jÿÿÿu‹Mìÿu ‰ÿuøè”ýÿÿƒÄ ‰Eðÿuøèlmÿÿ‹}Y9}üt ÿuüè[mÿÿY‹Eð^_[ÉËÿU‹ìƒìSVW3ÛjSSÿu‰]ð‰]ôè–Æÿÿ‰Eè#ƒĉUìƒøÿtYjSSÿuèzÆÿÿ‹È#ʃăùÿtA‹u ‹}+ðúˆÆ ;ó†¼ » Sjÿ4á@ Pÿdà@ ‰Eü…ÀuèciÿÿÇ èXiÿÿ‹ _^[ÉÃh € ÿuèŠ YY‰Eø…ÿ|
;ór‹Ãë‹ÆPÿuüÿu謫ÿÿƒÄ ƒøÿt6™+ðúxÓ…öwÏ‹uðÿuøÿuèF YYÿuüj ÿ4á@ Pÿ`à@ 3Ûé† èóhÿÿƒ8u èÖhÿÿÇ
ƒÎÿ‰uôë½;ûq|;óskSÿuÿu ÿuèÅÿÿ#ƒăøÿ„Dÿÿÿÿuè›ÖÿÿYPÿ0á@ ÷ØÀ÷ØH™‰Eð#‰Uôƒøÿu)èwhÿÿÇ
èhÿÿ‹ðÿ\à@ ‰‹uð#uôƒþÿ„öþÿÿSÿuìÿuèÿuèÅÿÿ#ƒăøÿ„Ùþÿÿ3ÀéÙþÿÿ‹ÿU‹ìV‹uVè"ÖÿÿYƒøÿuèhÿÿÇ ƒÈÿëMWÿuj ÿu Pÿ á@ ‹øƒÿÿuÿ\à@ ë3À…Àt PèhÿÿYƒÈÿë‹ÆÁø‹… *A ƒæ ÁæD0€ ý‹Ç_^]ËÿU‹ìS‹] V‹u‹ÆÁø… *A ‹ƒæ Áæ 0ŠA$ÀW¶y¾Àç€ Ñøû @ tPû € tBû t&û t û u=€I€‹
L1$Š€â€Êˆë'€I€‹
L1$Š€â‚€Êëè€aë
€I€‹
L1$€!€…ÿ_^[u¸ € ]Ã÷ØÀ% À @ ]ËÿU‹ì‹EV3ö;Æu èêfÿÿVVVVVÇ èrfÿÿƒÄjXë
‹
d*A ‰3À^]ËÿU‹ìƒìh‹ES3ÛW‰]ôˆ]ÿ;Ãtƒøt~ƒø~ ƒøu ÆEÿ‹E‰Eðë8èfÿÿ‰èƒfÿÿSSSSSÇ è fÿÿƒÄƒÈÿé® @8uûH8tÆ ‹Á8uëVjD^VE˜SPèÔIÿÿ‰u˜‹5*A ƒÄ ;ót+Fÿ‹È‹ÐÁù‹ *A ƒâ Áâ8\uNH;óuà;óŒ@ þ23 ƒ4 ‹ÆkÀƒÀf‰EÊ·ÀjPèghÿÿYY‰EÌ;Ä ;ó‰0‹EÌH|0‰]ø~9‹Eø‹Ðƒà ÁúÁà• *A ŠPöÂuˆ‹ ‰ëˆƒÿÿEøAƒÇ9uø|Ê‹EÌ8]ÿt,H3ÒD0ƒþ}‹þëj_;×} ˆƒÿBAƒÀëäÇEô èjeÿÿ‰EÜPE˜PSÿuÿuôjSSÿuðÿu ÿ à@ ‹ðÿ\à@ ÿuÌ‹øè‘hÿÿY;óu Wè?eÿÿYëXƒ}uSè¤Qÿÿ‹5á@ 9]u jÿÿuÜÿà@ EìPÿuÜÿà@ ‹]ìëƒ}uÿuÜÿÖë‹]ÜÿuàÿÖ‹ÃëèÄdÿÿÇ ƒÈÿ^_[ÉËÿU‹ìƒì@¡€A 3ʼnEü‹M ‹ESVW¾xô@ }ð¥¥f¥‰MÔ‹M3Û‰Mà‹M¤j‰EÈ‹ø‹ ‰Mè‰]܉]ì‰]Ä^ëPè2“ÿÿƒÇt‹Y;ÃuìjV‰uÌèÊfÿÿ‹uàYY‰;Ãu#‹Eè‰è4dÿÿÇ è?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ = EncodePointer K E R N E L 3 2 . D L L DecodePointer FlsFree FlsSetValue FlsGetValue FlsAlloc runtime error
TLOSS error
SING error
DOMAIN error
R6034
An application has made an attempt to load the C runtime library incorrectly.
Please contact the application's support team for more information.
R6033
- Attempt to use MSIL code from this assembly during native code initialization
This indicates a bug in your application. It is most likely the result of calling an MSIL-compiled (/clr) function from a native constructor or from DllMain.
R6032
- not enough space for locale information
R6031
- Attempt to initialize the CRT more than once.
This indicates a bug in your application.
R6030
- CRT not initialized
R6028
- unable to initialize heap
R6027
- not enough space for lowio initialization
R6026
- not enough space for stdio initialization
R6025
- pure virtual function call
R6024
- not enough space for _onexit/atexit table
R6019
- unable to open console device
R6018
- unexpected heap error
R6017
- unexpected multithread lock error
R6016
- not enough space for thread data
This application has requested the Runtime to terminate it in an unusual way.
Please contact the application's support team for more information.
R6009
- not enough space for environment
R6008
- not enough space for arguments
R6002
- floating point support not loaded
Microsoft Visual C++ Runtime Library
... Runtime Error!
Program: À À – À À Ž À À À ‘ À ’ À “ À €€†€€ †€†‚€EEE……… 00€P€ˆ ('8PW€ 700PPˆ (€ˆ€€ `h`hhhxppwpp ( ( ( ( ( H „ „ „ „ „ „ „ „ „ „ ‚ ‚ ‚ ‚ ‚ ‚ h ( ( ( ( H „ „ „ „ „ „ „ „ „ „ ‚‚‚‚‚‚ H €‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ ¡¢£¤¥¦§¨©ª«¬®¯°±²³´µ¶·¸¹º»¼½¾¿ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖ×ØÙÚÛÜÝÞßàáâãäåæçèéêëìíîïðñòóôõö÷øùúûüýþÿ
!"#$%&'()*+,-./0123456789:;<=>?@abcdefghijklmnopqrstuvwxyz[\]^_`abcdefghijklmnopqrstuvwxyz{|}~€‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ ¡¢£¤¥¦§¨©ª«¬®¯°±²³´µ¶·¸¹º»¼½¾¿ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖ×ØÙÚÛÜÝÞßàáâãäåæçèéêëìíîïðñòóôõö÷øùúûüýþÿ€‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ ¡¢£¤¥¦§¨©ª«¬®¯°±²³´µ¶·¸¹º»¼½¾¿ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖ×ØÙÚÛÜÝÞßàáâãäåæçèéêëìíîïðñòóôõö÷øùúûüýþÿ
!"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`ABCDEFGHIJKLMNOPQRSTUVWXYZ{|}~€‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ ¡¢£¤¥¦§¨©ª«¬®¯°±²³´µ¶·¸¹º»¼½¾¿ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖ×ØÙÚÛÜÝÞßàáâãäåæçèéêëìíîïðñòóôõö÷øùúûüýþÿHH:mm:ss dddd, MMMM dd, yyyy MM/dd/yy PM AM December November October September August July June April March February January Dec Nov Oct Sep Aug Jul Jun May Apr Mar Feb Jan Saturday Friday Thursday Wednesday Tuesday Monday Sunday Sat Fri Thu Wed Tue Mon Sun GetProcessWindowStation GetUserObjectInformationA GetLastActivePopup GetActiveWindow MessageBoxA USER32.DLL SunMonTueWedThuFriSat JanFebMarAprMayJunJulAugSepOctNovDec CONOUT$ .com .exe .bat .cmd .\ SystemRoot H €A Ðô@ 8 °i ™ þÿÿÿ Ôÿÿÿ þÿÿÿ Ü@ þÿÿÿ Èÿÿÿ þÿÿÿ ¼#@ þÿÿÿ ˆÿÿÿ þÿÿÿú%@ þ%@ þÿÿÿÀ%@ Ô%@ þÿÿÿ Œÿÿÿ þÿÿÿh5@ l5@ þÿÿÿ Ôÿÿÿ þÿÿÿ ;@ þÿÿÿ Ðÿÿÿ þÿÿÿ á;@ þÿÿÿ Ìÿÿÿ þÿÿÿ k=@ 7=@ þÿÿÿ Ôÿÿÿ þÿÿÿ ð>@ þÿÿÿ Ôÿÿÿ þÿÿÿ #@@ þÿÿÿ Ôÿÿÿ þÿÿÿMA@ iA@ þÿÿÿ Ôÿÿÿ þÿÿÿ ]G@ þÿÿÿ Ìÿÿÿ þÿÿÿ +K@ þÿÿÿ Ôÿÿÿ þÿÿÿ ›N@ þÿÿÿ Ôÿÿÿ þÿÿÿ ÝP@ þÿÿÿ ìP@ þÿÿÿ Øÿÿÿ þÿÿÿ ŸR@ þÿÿÿ «R@ þÿÿÿ Ôÿÿÿ þÿÿÿ eY@ þÿÿÿ Øÿÿÿ þÿÿÿ [@ [@ þÿÿÿ Øÿÿÿ þÿÿÿ][@ a[@ þÿÿÿ Àÿÿÿ þÿÿÿ ¸^@ þÿÿÿ Ðÿÿÿ þÿÿÿH_@ __@ þÿÿÿ Ôÿÿÿ þÿÿÿ ¹j@ þÿÿÿ Ðÿÿÿ þÿÿÿ Êl@ þÿÿÿ Ôÿÿÿ þÿÿÿ Îy@ þÿÿÿ Ðÿÿÿ þÿÿÿ Þ@ þÿÿÿ Ðÿÿÿ þÿÿÿ ¿‚@ þÿÿÿ Ìÿÿÿ þÿÿÿ ´•@ þÿÿÿ Ðÿÿÿ þÿÿÿ M˜@ þÿÿÿ Ðÿÿÿ þÿÿÿ ä¡@ þÿÿÿ Ôÿÿÿ þÿÿÿ [¦@ þÿÿÿ Èÿÿÿ þÿÿÿ !¨@ ]§@ þÿÿÿ Ðÿÿÿ þÿÿÿ Ü®@ þÿÿÿ Ðÿÿÿ þÿÿÿ øÂ@ þÿÿÿ Ìÿÿÿ þÿÿÿ ›Ê@ \ù à œú ¸ú Îú äú öú û $û <û Tû hû pû ‚û û ¢û ´û Æû Öû äû üû ü $ü @ü ^ü rü ‚ü Žü šü ¦ü ¾ü Öü àü ìü þü ý ý &ý 0ý @ý Vý bý rý šý ´ý Ìý æý üý þ $þ 2þ Lþ \þ rþ Œþ ˜þ ¦þ ¶þ Æþ Øþ ìþ üþ ÿ "ÿ 4ÿ Fÿ Xÿ jÿ vÿ „ÿ ”ÿ ªÿ ºÿ Êÿ Øÿ êÿ üÿ $ 0 @ R RGenerateConsoleCtrlEvent ÆGetExitCodeProcess nWaitForSingleObject • CreateProcessA ¯SetConsoleCtrlHandler õGetModuleFileNameA Ú EnterCriticalSection ôLeaveCriticalSection úGetModuleHandleW +Sleep "GetProcAddress ExitProcess pGetCommandLineA <GetStartupInfoA ðSetHandleCount >GetStdHandle ØGetFileType ¿ DeleteCriticalSection 7TerminateProcess ªGetCurrentProcess HUnhandledExceptionFilter SetUnhandledExceptionFilter ÖIsDebuggerPresent çGetLastError ¦HeapFree ¢HeapAlloc \GetCPInfo ÅInterlockedIncrement ÁInterlockedDecrement SGetACP GetOEMCP àIsValidCodePage >TlsGetValue <TlsAlloc ?TlsSetValue =TlsFree ôSetLastError ®GetCurrentThreadId —WriteFile öLoadLibraryA ºInitializeCriticalSectionAndSpinCount KFreeEnvironmentStringsA ÀGetEnvironmentStrings LFreeEnvironmentStringsW „WideCharToMultiByte ÂGetEnvironmentStringsW ¤HeapCreate aVirtualFree YQueryPerformanceCounter jGetTickCount «GetCurrentProcessId SGetSystemTimeAsFileTime šRtlUnwind ©HeapReAlloc ^VirtualAlloc „GetConsoleCP –GetConsoleMode BFlushFileBuffers æLCMapStringA MultiByteToWideChar èLCMapStringW @GetStringTypeA CGetStringTypeW éGetLocaleInfoA çSetFilePointer «HeapSize D CloseHandle ŒWriteConsoleA šGetConsoleOutputCP –WriteConsoleW SetStdHandle y CreateFileA S CompareStringA V CompareStringW ØSetEnvironmentVariableA KERNEL32.dll nReadFile ÕSetEndOfFile &GetProcessHeap ÊGetFileAttributesA À+A À+A Næ@»±¿Dê#@ lâ@ \â@ ÿÿÿÿ€
!
5 A
C P R
S
W Y l
m p r €
‚ ƒ „
‘ ) ž
¡ ¤ §
· Î × abcdefghijklmnopqrstuvwxyz ABCDEFGHIJKLMNOPQRSTUVWXYZ abcdefghijklmnopqrstuvwxyz ABCDEFGHIJKLMNOPQRSTUVWXYZ hA ¤ `‚y‚! ¦ß ¡¥ Ÿàü @~€ü ¨ Á£Ú£ þ @þ µ Á£Ú£ þ Aþ ¶ Ï¢ä¢ å¢è¢[ þ @~¡þ Q QÚ^Ú _ÚjÚ2 ÓØÞàù 1~þ lí@ þÿÿÿC A A A A A H A hë@ ðï@ pñ@ ˆ A ˜A ˜A hA ÿÿÿÿÿÿÿÿ øè@ Ìè@ è@
è@ Üç@ ¬ç@ ˆç@ \ç@ $ç@ üæ@ Äæ@ Œæ@ dæ@ Dæ@ àå@ ¨å@ ! °ä@ " ä@ x ä@ y ðã@ z àã@ ü Üã@ ÿ Ìã@ ^˜@ ^˜@ ^˜@ ^˜@ ^˜@ ^˜@ ^˜@ ^˜@ ^˜@ ^˜@ x
hë@ jí@ ˜ó@ ”ó@ ó@ Œó@ ˆó@ „ó@ €ó@ xó@ pó@ hó@ \ó@ Pó@ Hó@ <ó@ 8ó@ 4ó@ 0ó@ ,ó@ (ó@ $ó@ ó@ ó@ ó@ ó@ ó@ ó@ ó@ øò@ ðò@ èò@ (ó@ àò@ Øò@ Ðò@ Äò@ ¼ò@ °ò@ ¤ò@ ò@ œò@ ò@ |ò@ pò@ ˆ A . D A Œ)A Œ)A Œ)A Œ)A Œ)A Œ)A Œ)A Œ)A Œ)A H A . “ €p ðñÿÿ PST PDT Ð A A ÿÿÿÿ ÿÿÿÿ þÿÿÿþÿÿÿÿÿÿÿ ; Z x — µ Ô ó 0 N m ÿÿÿÿ : Y w – ´ Ó ò / M l lô@ dô@ \ô@ Tô@ setuptools-20.7.0/setuptools/launch.py 0000664 0001750 0001750 00000001332 12702524020 020723 0 ustar travis travis 0000000 0000000 """
Launch the Python script on the command line after
setuptools is bootstrapped via import.
"""
# Note that setuptools gets imported implicitly by the
# invocation of this script using python -m setuptools.launch
import tokenize
import sys
def run():
"""
Run the script in sys.argv[1] as if it had
been invoked naturally.
"""
__builtins__
script_name = sys.argv[1]
namespace = dict(
__file__ = script_name,
__name__ = '__main__',
__doc__ = None,
)
sys.argv[:] = sys.argv[1:]
open_ = getattr(tokenize, 'open', open)
script = open_(script_name).read()
norm_script = script.replace('\\r\\n', '\\n')
code = compile(norm_script, script_name, 'exec')
exec(code, namespace)
if __name__ == '__main__':
run()
setuptools-20.7.0/setuptools/lib2to3_ex.py 0000664 0001750 0001750 00000003716 12702524020 021433 0 ustar travis travis 0000000 0000000 """
Customized Mixin2to3 support:
- adds support for converting doctests
This module raises an ImportError on Python 2.
"""
from distutils.util import Mixin2to3 as _Mixin2to3
from distutils import log
from lib2to3.refactor import RefactoringTool, get_fixers_from_package
import setuptools
class DistutilsRefactoringTool(RefactoringTool):
def log_error(self, msg, *args, **kw):
log.error(msg, *args)
def log_message(self, msg, *args):
log.info(msg, *args)
def log_debug(self, msg, *args):
log.debug(msg, *args)
class Mixin2to3(_Mixin2to3):
def run_2to3(self, files, doctests = False):
# See of the distribution option has been set, otherwise check the
# setuptools default.
if self.distribution.use_2to3 is not True:
return
if not files:
return
log.info("Fixing "+" ".join(files))
self.__build_fixer_names()
self.__exclude_fixers()
if doctests:
if setuptools.run_2to3_on_doctests:
r = DistutilsRefactoringTool(self.fixer_names)
r.refactor(files, write=True, doctests_only=True)
else:
_Mixin2to3.run_2to3(self, files)
def __build_fixer_names(self):
if self.fixer_names: return
self.fixer_names = []
for p in setuptools.lib2to3_fixer_packages:
self.fixer_names.extend(get_fixers_from_package(p))
if self.distribution.use_2to3_fixers is not None:
for p in self.distribution.use_2to3_fixers:
self.fixer_names.extend(get_fixers_from_package(p))
def __exclude_fixers(self):
excluded_fixers = getattr(self, 'exclude_fixers', [])
if self.distribution.use_2to3_exclude_fixers is not None:
excluded_fixers.extend(self.distribution.use_2to3_exclude_fixers)
for fixer_name in excluded_fixers:
if fixer_name in self.fixer_names:
self.fixer_names.remove(fixer_name)
setuptools-20.7.0/setuptools/msvc9_support.py 0000664 0001750 0001750 00000004211 12702524020 022305 0 ustar travis travis 0000000 0000000 try:
import distutils.msvc9compiler
except Exception:
pass
unpatched = dict()
def patch_for_specialized_compiler():
"""
Patch functions in distutils.msvc9compiler to use the standalone compiler
build for Python (Windows only). Fall back to original behavior when the
standalone compiler is not available.
"""
if 'distutils' not in globals():
# The module isn't available to be patched
return
if unpatched:
# Already patched
return
unpatched.update(vars(distutils.msvc9compiler))
distutils.msvc9compiler.find_vcvarsall = find_vcvarsall
distutils.msvc9compiler.query_vcvarsall = query_vcvarsall
def find_vcvarsall(version):
Reg = distutils.msvc9compiler.Reg
VC_BASE = r'Software\%sMicrosoft\DevDiv\VCForPython\%0.1f'
key = VC_BASE % ('', version)
try:
# Per-user installs register the compiler path here
productdir = Reg.get_value(key, "installdir")
except KeyError:
try:
# All-user installs on a 64-bit system register here
key = VC_BASE % ('Wow6432Node\\', version)
productdir = Reg.get_value(key, "installdir")
except KeyError:
productdir = None
if productdir:
import os
vcvarsall = os.path.join(productdir, "vcvarsall.bat")
if os.path.isfile(vcvarsall):
return vcvarsall
return unpatched['find_vcvarsall'](version)
def query_vcvarsall(version, *args, **kwargs):
try:
return unpatched['query_vcvarsall'](version, *args, **kwargs)
except distutils.errors.DistutilsPlatformError as exc:
if exc and "vcvarsall.bat" in exc.args[0]:
message = 'Microsoft Visual C++ %0.1f is required (%s).' % (version, exc.args[0])
if int(version) == 9:
# This redirection link is maintained by Microsoft.
# Contact vspython@microsoft.com if it needs updating.
raise distutils.errors.DistutilsPlatformError(
message + ' Get it from http://aka.ms/vcpython27'
)
raise distutils.errors.DistutilsPlatformError(message)
raise
setuptools-20.7.0/setuptools/package_index.py 0000775 0001750 0001750 00000115102 12702524020 022237 0 ustar travis travis 0000000 0000000 """PyPI and direct package downloading"""
import sys
import os
import re
import shutil
import socket
import base64
import hashlib
import itertools
from functools import wraps
try:
from urllib.parse import splituser
except ImportError:
from urllib2 import splituser
from setuptools.extern import six
from setuptools.extern.six.moves import urllib, http_client, configparser, map
from pkg_resources import (
CHECKOUT_DIST, Distribution, BINARY_DIST, normalize_path, SOURCE_DIST,
require, Environment, find_distributions, safe_name, safe_version,
to_filename, Requirement, DEVELOP_DIST,
)
from setuptools import ssl_support
from distutils import log
from distutils.errors import DistutilsError
from fnmatch import translate
from setuptools.py26compat import strip_fragment
from setuptools.py27compat import get_all_headers
EGG_FRAGMENT = re.compile(r'^egg=([-A-Za-z0-9_.]+)$')
HREF = re.compile("""href\\s*=\\s*['"]?([^'"> ]+)""", re.I)
# this is here to fix emacs' cruddy broken syntax highlighting
PYPI_MD5 = re.compile(
'([^<]+)\n\s+\\(md5\\)'
)
URL_SCHEME = re.compile('([-+.a-z0-9]{2,}):',re.I).match
EXTENSIONS = ".tar.gz .tar.bz2 .tar .zip .tgz".split()
__all__ = [
'PackageIndex', 'distros_for_url', 'parse_bdist_wininst',
'interpret_distro_name',
]
_SOCKET_TIMEOUT = 15
def parse_bdist_wininst(name):
"""Return (base,pyversion) or (None,None) for possible .exe name"""
lower = name.lower()
base, py_ver, plat = None, None, None
if lower.endswith('.exe'):
if lower.endswith('.win32.exe'):
base = name[:-10]
plat = 'win32'
elif lower.startswith('.win32-py',-16):
py_ver = name[-7:-4]
base = name[:-16]
plat = 'win32'
elif lower.endswith('.win-amd64.exe'):
base = name[:-14]
plat = 'win-amd64'
elif lower.startswith('.win-amd64-py',-20):
py_ver = name[-7:-4]
base = name[:-20]
plat = 'win-amd64'
return base,py_ver,plat
def egg_info_for_url(url):
parts = urllib.parse.urlparse(url)
scheme, server, path, parameters, query, fragment = parts
base = urllib.parse.unquote(path.split('/')[-1])
if server=='sourceforge.net' and base=='download': # XXX Yuck
base = urllib.parse.unquote(path.split('/')[-2])
if '#' in base: base, fragment = base.split('#',1)
return base,fragment
def distros_for_url(url, metadata=None):
"""Yield egg or source distribution objects that might be found at a URL"""
base, fragment = egg_info_for_url(url)
for dist in distros_for_location(url, base, metadata): yield dist
if fragment:
match = EGG_FRAGMENT.match(fragment)
if match:
for dist in interpret_distro_name(
url, match.group(1), metadata, precedence = CHECKOUT_DIST
):
yield dist
def distros_for_location(location, basename, metadata=None):
"""Yield egg or source distribution objects based on basename"""
if basename.endswith('.egg.zip'):
basename = basename[:-4] # strip the .zip
if basename.endswith('.egg') and '-' in basename:
# only one, unambiguous interpretation
return [Distribution.from_location(location, basename, metadata)]
if basename.endswith('.exe'):
win_base, py_ver, platform = parse_bdist_wininst(basename)
if win_base is not None:
return interpret_distro_name(
location, win_base, metadata, py_ver, BINARY_DIST, platform
)
# Try source distro extensions (.zip, .tgz, etc.)
#
for ext in EXTENSIONS:
if basename.endswith(ext):
basename = basename[:-len(ext)]
return interpret_distro_name(location, basename, metadata)
return [] # no extension matched
def distros_for_filename(filename, metadata=None):
"""Yield possible egg or source distribution objects based on a filename"""
return distros_for_location(
normalize_path(filename), os.path.basename(filename), metadata
)
def interpret_distro_name(
location, basename, metadata, py_version=None, precedence=SOURCE_DIST,
platform=None
):
"""Generate alternative interpretations of a source distro name
Note: if `location` is a filesystem filename, you should call
``pkg_resources.normalize_path()`` on it before passing it to this
routine!
"""
# Generate alternative interpretations of a source distro name
# Because some packages are ambiguous as to name/versions split
# e.g. "adns-python-1.1.0", "egenix-mx-commercial", etc.
# So, we generate each possible interepretation (e.g. "adns, python-1.1.0"
# "adns-python, 1.1.0", and "adns-python-1.1.0, no version"). In practice,
# the spurious interpretations should be ignored, because in the event
# there's also an "adns" package, the spurious "python-1.1.0" version will
# compare lower than any numeric version number, and is therefore unlikely
# to match a request for it. It's still a potential problem, though, and
# in the long run PyPI and the distutils should go for "safe" names and
# versions in distribution archive names (sdist and bdist).
parts = basename.split('-')
if not py_version and any(re.match('py\d\.\d$', p) for p in parts[2:]):
# it is a bdist_dumb, not an sdist -- bail out
return
for p in range(1,len(parts)+1):
yield Distribution(
location, metadata, '-'.join(parts[:p]), '-'.join(parts[p:]),
py_version=py_version, precedence = precedence,
platform = platform
)
# From Python 2.7 docs
def unique_everseen(iterable, key=None):
"List unique elements, preserving order. Remember all elements ever seen."
# unique_everseen('AAAABBBCCDAABBB') --> A B C D
# unique_everseen('ABBCcAD', str.lower) --> A B C D
seen = set()
seen_add = seen.add
if key is None:
for element in six.moves.filterfalse(seen.__contains__, iterable):
seen_add(element)
yield element
else:
for element in iterable:
k = key(element)
if k not in seen:
seen_add(k)
yield element
def unique_values(func):
"""
Wrap a function returning an iterable such that the resulting iterable
only ever yields unique items.
"""
@wraps(func)
def wrapper(*args, **kwargs):
return unique_everseen(func(*args, **kwargs))
return wrapper
REL = re.compile("""<([^>]*\srel\s*=\s*['"]?([^'">]+)[^>]*)>""", re.I)
# this line is here to fix emacs' cruddy broken syntax highlighting
@unique_values
def find_external_links(url, page):
"""Find rel="homepage" and rel="download" links in `page`, yielding URLs"""
for match in REL.finditer(page):
tag, rel = match.groups()
rels = set(map(str.strip, rel.lower().split(',')))
if 'homepage' in rels or 'download' in rels:
for match in HREF.finditer(tag):
yield urllib.parse.urljoin(url, htmldecode(match.group(1)))
for tag in ("Home Page", " Download URL"):
pos = page.find(tag)
if pos!=-1:
match = HREF.search(page,pos)
if match:
yield urllib.parse.urljoin(url, htmldecode(match.group(1)))
user_agent = "Python-urllib/%s setuptools/%s" % (
sys.version[:3], require('setuptools')[0].version
)
class ContentChecker(object):
"""
A null content checker that defines the interface for checking content
"""
def feed(self, block):
"""
Feed a block of data to the hash.
"""
return
def is_valid(self):
"""
Check the hash. Return False if validation fails.
"""
return True
def report(self, reporter, template):
"""
Call reporter with information about the checker (hash name)
substituted into the template.
"""
return
class HashChecker(ContentChecker):
pattern = re.compile(
r'(?Psha1|sha224|sha384|sha256|sha512|md5)='
r'(?P[a-f0-9]+)'
)
def __init__(self, hash_name, expected):
self.hash_name = hash_name
self.hash = hashlib.new(hash_name)
self.expected = expected
@classmethod
def from_url(cls, url):
"Construct a (possibly null) ContentChecker from a URL"
fragment = urllib.parse.urlparse(url)[-1]
if not fragment:
return ContentChecker()
match = cls.pattern.search(fragment)
if not match:
return ContentChecker()
return cls(**match.groupdict())
def feed(self, block):
self.hash.update(block)
def is_valid(self):
return self.hash.hexdigest() == self.expected
def report(self, reporter, template):
msg = template % self.hash_name
return reporter(msg)
class PackageIndex(Environment):
"""A distribution index that scans web pages for download URLs"""
def __init__(
self, index_url="https://pypi.python.org/simple", hosts=('*',),
ca_bundle=None, verify_ssl=True, *args, **kw
):
Environment.__init__(self,*args,**kw)
self.index_url = index_url + "/"[:not index_url.endswith('/')]
self.scanned_urls = {}
self.fetched_urls = {}
self.package_pages = {}
self.allows = re.compile('|'.join(map(translate,hosts))).match
self.to_scan = []
if verify_ssl and ssl_support.is_available and (ca_bundle or ssl_support.find_ca_bundle()):
self.opener = ssl_support.opener_for(ca_bundle)
else: self.opener = urllib.request.urlopen
def process_url(self, url, retrieve=False):
"""Evaluate a URL as a possible download, and maybe retrieve it"""
if url in self.scanned_urls and not retrieve:
return
self.scanned_urls[url] = True
if not URL_SCHEME(url):
self.process_filename(url)
return
else:
dists = list(distros_for_url(url))
if dists:
if not self.url_ok(url):
return
self.debug("Found link: %s", url)
if dists or not retrieve or url in self.fetched_urls:
list(map(self.add, dists))
return # don't need the actual page
if not self.url_ok(url):
self.fetched_urls[url] = True
return
self.info("Reading %s", url)
self.fetched_urls[url] = True # prevent multiple fetch attempts
f = self.open_url(url, "Download error on %s: %%s -- Some packages may not be found!" % url)
if f is None: return
self.fetched_urls[f.url] = True
if 'html' not in f.headers.get('content-type', '').lower():
f.close() # not html, we can't process it
return
base = f.url # handle redirects
page = f.read()
if not isinstance(page, str): # We are in Python 3 and got bytes. We want str.
if isinstance(f, urllib.error.HTTPError):
# Errors have no charset, assume latin1:
charset = 'latin-1'
else:
charset = f.headers.get_param('charset') or 'latin-1'
page = page.decode(charset, "ignore")
f.close()
for match in HREF.finditer(page):
link = urllib.parse.urljoin(base, htmldecode(match.group(1)))
self.process_url(link)
if url.startswith(self.index_url) and getattr(f,'code',None)!=404:
page = self.process_index(url, page)
def process_filename(self, fn, nested=False):
# process filenames or directories
if not os.path.exists(fn):
self.warn("Not found: %s", fn)
return
if os.path.isdir(fn) and not nested:
path = os.path.realpath(fn)
for item in os.listdir(path):
self.process_filename(os.path.join(path,item), True)
dists = distros_for_filename(fn)
if dists:
self.debug("Found: %s", fn)
list(map(self.add, dists))
def url_ok(self, url, fatal=False):
s = URL_SCHEME(url)
if (s and s.group(1).lower()=='file') or self.allows(urllib.parse.urlparse(url)[1]):
return True
msg = ("\nNote: Bypassing %s (disallowed host; see "
"http://bit.ly/1dg9ijs for details).\n")
if fatal:
raise DistutilsError(msg % url)
else:
self.warn(msg, url)
def scan_egg_links(self, search_path):
dirs = filter(os.path.isdir, search_path)
egg_links = (
(path, entry)
for path in dirs
for entry in os.listdir(path)
if entry.endswith('.egg-link')
)
list(itertools.starmap(self.scan_egg_link, egg_links))
def scan_egg_link(self, path, entry):
with open(os.path.join(path, entry)) as raw_lines:
# filter non-empty lines
lines = list(filter(None, map(str.strip, raw_lines)))
if len(lines) != 2:
# format is not recognized; punt
return
egg_path, setup_path = lines
for dist in find_distributions(os.path.join(path, egg_path)):
dist.location = os.path.join(path, *lines)
dist.precedence = SOURCE_DIST
self.add(dist)
def process_index(self,url,page):
"""Process the contents of a PyPI page"""
def scan(link):
# Process a URL to see if it's for a package page
if link.startswith(self.index_url):
parts = list(map(
urllib.parse.unquote, link[len(self.index_url):].split('/')
))
if len(parts)==2 and '#' not in parts[1]:
# it's a package page, sanitize and index it
pkg = safe_name(parts[0])
ver = safe_version(parts[1])
self.package_pages.setdefault(pkg.lower(),{})[link] = True
return to_filename(pkg), to_filename(ver)
return None, None
# process an index page into the package-page index
for match in HREF.finditer(page):
try:
scan(urllib.parse.urljoin(url, htmldecode(match.group(1))))
except ValueError:
pass
pkg, ver = scan(url) # ensure this page is in the page index
if pkg:
# process individual package page
for new_url in find_external_links(url, page):
# Process the found URL
base, frag = egg_info_for_url(new_url)
if base.endswith('.py') and not frag:
if ver:
new_url+='#egg=%s-%s' % (pkg,ver)
else:
self.need_version_info(url)
self.scan_url(new_url)
return PYPI_MD5.sub(
lambda m: '%s' % m.group(1,3,2), page
)
else:
return "" # no sense double-scanning non-package pages
def need_version_info(self, url):
self.scan_all(
"Page at %s links to .py file(s) without version info; an index "
"scan is required.", url
)
def scan_all(self, msg=None, *args):
if self.index_url not in self.fetched_urls:
if msg: self.warn(msg,*args)
self.info(
"Scanning index of all packages (this may take a while)"
)
self.scan_url(self.index_url)
def find_packages(self, requirement):
self.scan_url(self.index_url + requirement.unsafe_name+'/')
if not self.package_pages.get(requirement.key):
# Fall back to safe version of the name
self.scan_url(self.index_url + requirement.project_name+'/')
if not self.package_pages.get(requirement.key):
# We couldn't find the target package, so search the index page too
self.not_found_in_index(requirement)
for url in list(self.package_pages.get(requirement.key,())):
# scan each page that might be related to the desired package
self.scan_url(url)
def obtain(self, requirement, installer=None):
self.prescan()
self.find_packages(requirement)
for dist in self[requirement.key]:
if dist in requirement:
return dist
self.debug("%s does not match %s", requirement, dist)
return super(PackageIndex, self).obtain(requirement,installer)
def check_hash(self, checker, filename, tfp):
"""
checker is a ContentChecker
"""
checker.report(self.debug,
"Validating %%s checksum for %s" % filename)
if not checker.is_valid():
tfp.close()
os.unlink(filename)
raise DistutilsError(
"%s validation failed for %s; "
"possible download problem?" % (
checker.hash.name, os.path.basename(filename))
)
def add_find_links(self, urls):
"""Add `urls` to the list that will be prescanned for searches"""
for url in urls:
if (
self.to_scan is None # if we have already "gone online"
or not URL_SCHEME(url) # or it's a local file/directory
or url.startswith('file:')
or list(distros_for_url(url)) # or a direct package link
):
# then go ahead and process it now
self.scan_url(url)
else:
# otherwise, defer retrieval till later
self.to_scan.append(url)
def prescan(self):
"""Scan urls scheduled for prescanning (e.g. --find-links)"""
if self.to_scan:
list(map(self.scan_url, self.to_scan))
self.to_scan = None # from now on, go ahead and process immediately
def not_found_in_index(self, requirement):
if self[requirement.key]: # we've seen at least one distro
meth, msg = self.info, "Couldn't retrieve index page for %r"
else: # no distros seen for this name, might be misspelled
meth, msg = (self.warn,
"Couldn't find index page for %r (maybe misspelled?)")
meth(msg, requirement.unsafe_name)
self.scan_all()
def download(self, spec, tmpdir):
"""Locate and/or download `spec` to `tmpdir`, returning a local path
`spec` may be a ``Requirement`` object, or a string containing a URL,
an existing local filename, or a project/version requirement spec
(i.e. the string form of a ``Requirement`` object). If it is the URL
of a .py file with an unambiguous ``#egg=name-version`` tag (i.e., one
that escapes ``-`` as ``_`` throughout), a trivial ``setup.py`` is
automatically created alongside the downloaded file.
If `spec` is a ``Requirement`` object or a string containing a
project/version requirement spec, this method returns the location of
a matching distribution (possibly after downloading it to `tmpdir`).
If `spec` is a locally existing file or directory name, it is simply
returned unchanged. If `spec` is a URL, it is downloaded to a subpath
of `tmpdir`, and the local filename is returned. Various errors may be
raised if a problem occurs during downloading.
"""
if not isinstance(spec,Requirement):
scheme = URL_SCHEME(spec)
if scheme:
# It's a url, download it to tmpdir
found = self._download_url(scheme.group(1), spec, tmpdir)
base, fragment = egg_info_for_url(spec)
if base.endswith('.py'):
found = self.gen_setup(found,fragment,tmpdir)
return found
elif os.path.exists(spec):
# Existing file or directory, just return it
return spec
else:
try:
spec = Requirement.parse(spec)
except ValueError:
raise DistutilsError(
"Not a URL, existing file, or requirement spec: %r" %
(spec,)
)
return getattr(self.fetch_distribution(spec, tmpdir),'location',None)
def fetch_distribution(
self, requirement, tmpdir, force_scan=False, source=False,
develop_ok=False, local_index=None
):
"""Obtain a distribution suitable for fulfilling `requirement`
`requirement` must be a ``pkg_resources.Requirement`` instance.
If necessary, or if the `force_scan` flag is set, the requirement is
searched for in the (online) package index as well as the locally
installed packages. If a distribution matching `requirement` is found,
the returned distribution's ``location`` is the value you would have
gotten from calling the ``download()`` method with the matching
distribution's URL or filename. If no matching distribution is found,
``None`` is returned.
If the `source` flag is set, only source distributions and source
checkout links will be considered. Unless the `develop_ok` flag is
set, development and system eggs (i.e., those using the ``.egg-info``
format) will be ignored.
"""
# process a Requirement
self.info("Searching for %s", requirement)
skipped = {}
dist = None
def find(req, env=None):
if env is None:
env = self
# Find a matching distribution; may be called more than once
for dist in env[req.key]:
if dist.precedence==DEVELOP_DIST and not develop_ok:
if dist not in skipped:
self.warn("Skipping development or system egg: %s",dist)
skipped[dist] = 1
continue
if dist in req and (dist.precedence<=SOURCE_DIST or not source):
return dist
if force_scan:
self.prescan()
self.find_packages(requirement)
dist = find(requirement)
if local_index is not None:
dist = dist or find(requirement, local_index)
if dist is None:
if self.to_scan is not None:
self.prescan()
dist = find(requirement)
if dist is None and not force_scan:
self.find_packages(requirement)
dist = find(requirement)
if dist is None:
self.warn(
"No local packages or download links found for %s%s",
(source and "a source distribution of " or ""),
requirement,
)
else:
self.info("Best match: %s", dist)
return dist.clone(location=self.download(dist.location, tmpdir))
def fetch(self, requirement, tmpdir, force_scan=False, source=False):
"""Obtain a file suitable for fulfilling `requirement`
DEPRECATED; use the ``fetch_distribution()`` method now instead. For
backward compatibility, this routine is identical but returns the
``location`` of the downloaded distribution instead of a distribution
object.
"""
dist = self.fetch_distribution(requirement,tmpdir,force_scan,source)
if dist is not None:
return dist.location
return None
def gen_setup(self, filename, fragment, tmpdir):
match = EGG_FRAGMENT.match(fragment)
dists = match and [
d for d in
interpret_distro_name(filename, match.group(1), None) if d.version
] or []
if len(dists)==1: # unambiguous ``#egg`` fragment
basename = os.path.basename(filename)
# Make sure the file has been downloaded to the temp dir.
if os.path.dirname(filename) != tmpdir:
dst = os.path.join(tmpdir, basename)
from setuptools.command.easy_install import samefile
if not samefile(filename, dst):
shutil.copy2(filename, dst)
filename=dst
with open(os.path.join(tmpdir, 'setup.py'), 'w') as file:
file.write(
"from setuptools import setup\n"
"setup(name=%r, version=%r, py_modules=[%r])\n"
% (
dists[0].project_name, dists[0].version,
os.path.splitext(basename)[0]
)
)
return filename
elif match:
raise DistutilsError(
"Can't unambiguously interpret project/version identifier %r; "
"any dashes in the name or version should be escaped using "
"underscores. %r" % (fragment,dists)
)
else:
raise DistutilsError(
"Can't process plain .py files without an '#egg=name-version'"
" suffix to enable automatic setup script generation."
)
dl_blocksize = 8192
def _download_to(self, url, filename):
self.info("Downloading %s", url)
# Download the file
fp, info = None, None
try:
checker = HashChecker.from_url(url)
fp = self.open_url(strip_fragment(url))
if isinstance(fp, urllib.error.HTTPError):
raise DistutilsError(
"Can't download %s: %s %s" % (url, fp.code,fp.msg)
)
headers = fp.info()
blocknum = 0
bs = self.dl_blocksize
size = -1
if "content-length" in headers:
# Some servers return multiple Content-Length headers :(
sizes = get_all_headers(headers, 'Content-Length')
size = max(map(int, sizes))
self.reporthook(url, filename, blocknum, bs, size)
with open(filename,'wb') as tfp:
while True:
block = fp.read(bs)
if block:
checker.feed(block)
tfp.write(block)
blocknum += 1
self.reporthook(url, filename, blocknum, bs, size)
else:
break
self.check_hash(checker, filename, tfp)
return headers
finally:
if fp: fp.close()
def reporthook(self, url, filename, blocknum, blksize, size):
pass # no-op
def open_url(self, url, warning=None):
if url.startswith('file:'):
return local_open(url)
try:
return open_with_auth(url, self.opener)
except (ValueError, http_client.InvalidURL) as v:
msg = ' '.join([str(arg) for arg in v.args])
if warning:
self.warn(warning, msg)
else:
raise DistutilsError('%s %s' % (url, msg))
except urllib.error.HTTPError as v:
return v
except urllib.error.URLError as v:
if warning:
self.warn(warning, v.reason)
else:
raise DistutilsError("Download error for %s: %s"
% (url, v.reason))
except http_client.BadStatusLine as v:
if warning:
self.warn(warning, v.line)
else:
raise DistutilsError(
'%s returned a bad status line. The server might be '
'down, %s' %
(url, v.line)
)
except http_client.HTTPException as v:
if warning:
self.warn(warning, v)
else:
raise DistutilsError("Download error for %s: %s"
% (url, v))
def _download_url(self, scheme, url, tmpdir):
# Determine download filename
#
name, fragment = egg_info_for_url(url)
if name:
while '..' in name:
name = name.replace('..','.').replace('\\','_')
else:
name = "__downloaded__" # default if URL has no path contents
if name.endswith('.egg.zip'):
name = name[:-4] # strip the extra .zip before download
filename = os.path.join(tmpdir,name)
# Download the file
#
if scheme=='svn' or scheme.startswith('svn+'):
return self._download_svn(url, filename)
elif scheme=='git' or scheme.startswith('git+'):
return self._download_git(url, filename)
elif scheme.startswith('hg+'):
return self._download_hg(url, filename)
elif scheme=='file':
return urllib.request.url2pathname(urllib.parse.urlparse(url)[2])
else:
self.url_ok(url, True) # raises error if not allowed
return self._attempt_download(url, filename)
def scan_url(self, url):
self.process_url(url, True)
def _attempt_download(self, url, filename):
headers = self._download_to(url, filename)
if 'html' in headers.get('content-type','').lower():
return self._download_html(url, headers, filename)
else:
return filename
def _download_html(self, url, headers, filename):
file = open(filename)
for line in file:
if line.strip():
# Check for a subversion index page
if re.search(r'([^- ]+ - )?Revision \d+:', line):
# it's a subversion index page:
file.close()
os.unlink(filename)
return self._download_svn(url, filename)
break # not an index page
file.close()
os.unlink(filename)
raise DistutilsError("Unexpected HTML page found at "+url)
def _download_svn(self, url, filename):
url = url.split('#',1)[0] # remove any fragment for svn's sake
creds = ''
if url.lower().startswith('svn:') and '@' in url:
scheme, netloc, path, p, q, f = urllib.parse.urlparse(url)
if not netloc and path.startswith('//') and '/' in path[2:]:
netloc, path = path[2:].split('/',1)
auth, host = splituser(netloc)
if auth:
if ':' in auth:
user, pw = auth.split(':',1)
creds = " --username=%s --password=%s" % (user, pw)
else:
creds = " --username="+auth
netloc = host
parts = scheme, netloc, url, p, q, f
url = urllib.parse.urlunparse(parts)
self.info("Doing subversion checkout from %s to %s", url, filename)
os.system("svn checkout%s -q %s %s" % (creds, url, filename))
return filename
@staticmethod
def _vcs_split_rev_from_url(url, pop_prefix=False):
scheme, netloc, path, query, frag = urllib.parse.urlsplit(url)
scheme = scheme.split('+', 1)[-1]
# Some fragment identification fails
path = path.split('#',1)[0]
rev = None
if '@' in path:
path, rev = path.rsplit('@', 1)
# Also, discard fragment
url = urllib.parse.urlunsplit((scheme, netloc, path, query, ''))
return url, rev
def _download_git(self, url, filename):
filename = filename.split('#',1)[0]
url, rev = self._vcs_split_rev_from_url(url, pop_prefix=True)
self.info("Doing git clone from %s to %s", url, filename)
os.system("git clone --quiet %s %s" % (url, filename))
if rev is not None:
self.info("Checking out %s", rev)
os.system("(cd %s && git checkout --quiet %s)" % (
filename,
rev,
))
return filename
def _download_hg(self, url, filename):
filename = filename.split('#',1)[0]
url, rev = self._vcs_split_rev_from_url(url, pop_prefix=True)
self.info("Doing hg clone from %s to %s", url, filename)
os.system("hg clone --quiet %s %s" % (url, filename))
if rev is not None:
self.info("Updating to %s", rev)
os.system("(cd %s && hg up -C -r %s >&-)" % (
filename,
rev,
))
return filename
def debug(self, msg, *args):
log.debug(msg, *args)
def info(self, msg, *args):
log.info(msg, *args)
def warn(self, msg, *args):
log.warn(msg, *args)
# This pattern matches a character entity reference (a decimal numeric
# references, a hexadecimal numeric reference, or a named reference).
entity_sub = re.compile(r'&(#(\d+|x[\da-fA-F]+)|[\w.:-]+);?').sub
def uchr(c):
if not isinstance(c, int):
return c
if c>255: return six.unichr(c)
return chr(c)
def decode_entity(match):
what = match.group(1)
if what.startswith('#x'):
what = int(what[2:], 16)
elif what.startswith('#'):
what = int(what[1:])
else:
what = six.moves.html_entities.name2codepoint.get(what, match.group(0))
return uchr(what)
def htmldecode(text):
"""Decode HTML entities in the given text."""
return entity_sub(decode_entity, text)
def socket_timeout(timeout=15):
def _socket_timeout(func):
def _socket_timeout(*args, **kwargs):
old_timeout = socket.getdefaulttimeout()
socket.setdefaulttimeout(timeout)
try:
return func(*args, **kwargs)
finally:
socket.setdefaulttimeout(old_timeout)
return _socket_timeout
return _socket_timeout
def _encode_auth(auth):
"""
A function compatible with Python 2.3-3.3 that will encode
auth from a URL suitable for an HTTP header.
>>> str(_encode_auth('username%3Apassword'))
'dXNlcm5hbWU6cGFzc3dvcmQ='
Long auth strings should not cause a newline to be inserted.
>>> long_auth = 'username:' + 'password'*10
>>> chr(10) in str(_encode_auth(long_auth))
False
"""
auth_s = urllib.parse.unquote(auth)
# convert to bytes
auth_bytes = auth_s.encode()
# use the legacy interface for Python 2.3 support
encoded_bytes = base64.encodestring(auth_bytes)
# convert back to a string
encoded = encoded_bytes.decode()
# strip the trailing carriage return
return encoded.replace('\n','')
class Credential(object):
"""
A username/password pair. Use like a namedtuple.
"""
def __init__(self, username, password):
self.username = username
self.password = password
def __iter__(self):
yield self.username
yield self.password
def __str__(self):
return '%(username)s:%(password)s' % vars(self)
class PyPIConfig(configparser.RawConfigParser):
def __init__(self):
"""
Load from ~/.pypirc
"""
defaults = dict.fromkeys(['username', 'password', 'repository'], '')
configparser.RawConfigParser.__init__(self, defaults)
rc = os.path.join(os.path.expanduser('~'), '.pypirc')
if os.path.exists(rc):
self.read(rc)
@property
def creds_by_repository(self):
sections_with_repositories = [
section for section in self.sections()
if self.get(section, 'repository').strip()
]
return dict(map(self._get_repo_cred, sections_with_repositories))
def _get_repo_cred(self, section):
repo = self.get(section, 'repository').strip()
return repo, Credential(
self.get(section, 'username').strip(),
self.get(section, 'password').strip(),
)
def find_credential(self, url):
"""
If the URL indicated appears to be a repository defined in this
config, return the credential for that repository.
"""
for repository, cred in self.creds_by_repository.items():
if url.startswith(repository):
return cred
def open_with_auth(url, opener=urllib.request.urlopen):
"""Open a urllib2 request, handling HTTP authentication"""
scheme, netloc, path, params, query, frag = urllib.parse.urlparse(url)
# Double scheme does not raise on Mac OS X as revealed by a
# failing test. We would expect "nonnumeric port". Refs #20.
if netloc.endswith(':'):
raise http_client.InvalidURL("nonnumeric port: ''")
if scheme in ('http', 'https'):
auth, host = splituser(netloc)
else:
auth = None
if not auth:
cred = PyPIConfig().find_credential(url)
if cred:
auth = str(cred)
info = cred.username, url
log.info('Authenticating as %s for %s (from .pypirc)' % info)
if auth:
auth = "Basic " + _encode_auth(auth)
parts = scheme, host, path, params, query, frag
new_url = urllib.parse.urlunparse(parts)
request = urllib.request.Request(new_url)
request.add_header("Authorization", auth)
else:
request = urllib.request.Request(url)
request.add_header('User-Agent', user_agent)
fp = opener(request)
if auth:
# Put authentication info back into request URL if same host,
# so that links found on the page will work
s2, h2, path2, param2, query2, frag2 = urllib.parse.urlparse(fp.url)
if s2==scheme and h2==host:
parts = s2, netloc, path2, param2, query2, frag2
fp.url = urllib.parse.urlunparse(parts)
return fp
# adding a timeout to avoid freezing package_index
open_with_auth = socket_timeout(_SOCKET_TIMEOUT)(open_with_auth)
def fix_sf_url(url):
return url # backward compatibility
def local_open(url):
"""Read a local path, with special support for directories"""
scheme, server, path, param, query, frag = urllib.parse.urlparse(url)
filename = urllib.request.url2pathname(path)
if os.path.isfile(filename):
return urllib.request.urlopen(url)
elif path.endswith('/') and os.path.isdir(filename):
files = []
for f in os.listdir(filename):
filepath = os.path.join(filename, f)
if f == 'index.html':
with open(filepath, 'r') as fp:
body = fp.read()
break
elif os.path.isdir(filepath):
f += '/'
files.append('<a href="{name}">{name}</a>'.format(name=f))
else:
tmpl = ("<html><head><title>{url} "
"{files}