Current File : /home/mmdealscpanel/yummmdeals.com/__init__.pyc.tar
lib64/python2.7/xml/sax/__init__.pyc000064400000007241150351324060013106 0ustar00�
{fc@sjdZddlmZddlmZmZddlmZmZm	Z	m
Z
mZe�d�Ze�d�Z
dgZdZer�dd	lZndd	lZdd	lZejjr�d
ejkr�ejd
jd�Zn[dZejd
 dkr/ejje�r/ejje�jd�Zngd�Zejd
 dkrZd�Zn	d�Z[d	S(s�Simple API for XML (SAX) implementation for Python.

This module provides an implementation of the SAX 2 interface;
information about the Java version of the interface can be found at
http://www.megginson.com/SAX/.  The Python version of the interface is
documented at <...>.

This package contains the following modules:

handler -- Base classes and constants which define the SAX 2 API for
           the 'client-side' of SAX for Python.

saxutils -- Implementation of the convenience classes commonly used to
            work with SAX.

xmlreader -- Base classes and constants which define the SAX 2 API for
             the parsers used with SAX for Python.

expatreader -- Driver that allows use of the Expat parser with SAX.
i����(tInputSource(tContentHandlertErrorHandler(tSAXExceptiontSAXNotRecognizedExceptiontSAXParseExceptiontSAXNotSupportedExceptiontSAXReaderNotAvailablecCs4t�}|j|�|j|�|j|�dS(N(tmake_parsertsetContentHandlertsetErrorHandlertparse(tsourcethandlerterrorHandlertparser((s(/usr/lib64/python2.7/xml/sax/__init__.pyRs	

cCs�yddlm}Wn!tk
r7ddlm}nX|dkrPt�}nt�}|j|�|j|�t�}|j	||��|j
|�dS(Ni����(tStringIO(t	cStringIORtImportErrortNoneRRR	R
Rt
setByteStreamR(tstringR
RRRtinpsrc((s(/usr/lib64/python2.7/xml/sax/__init__.pytparseString#s
	

	sxml.sax.expatreaderiNt
PY_SAX_PARSERt,spython.xml.sax.parseritjavacCs}xg|tD][}yt|�SWqtk
rU}ddl}||jkrf�qfqtk
reqXqWtdd��dS(s&Creates and returns a SAX parser.

    Creates the first parser it is able to instantiate of the ones
    given in the list created by doing parser_list +
    default_parser_list.  The lists must contain the names of Python
    modules containing both a SAX parser and a create_parser function.i����NsNo parsers found(tdefault_parser_listt_create_parserRtsystmodulesRR(tparser_listtparser_nameteR((s(/usr/lib64/python2.7/xml/sax/__init__.pyRGs	
cCs2ddlm}|j|dt��}|j�S(Ni����(timpi(torg.python.coreR"t
importNametglobalst
create_parser(R R"t
drv_module((s(/usr/lib64/python2.7/xml/sax/__init__.pyRbscCs"t|iidg�}|j�S(NR&(t
__import__R&(R R'((s(/usr/lib64/python2.7/xml/sax/__init__.pyRhs(t__doc__t	xmlreaderRR
RRt_exceptionsRRRRRRRRt_falsetxml.sax.expatreadertxmltosRtflagstignore_environmenttenvirontsplitt_keytplatformtregistrytcontainsKeytgetPropertyRR(((s(/usr/lib64/python2.7/xml/sax/__init__.pyt<module>s*(	%	lib64/python2.7/xml/dom/__init__.pyc000064400000014517150351650440013102 0ustar00�
{fc@s:dZdd=d��YZdZdZdZdZdZdZd	Zd
Z	dZ
dZd
ZdZ
dZdZdZdZdefd��YZdefd��YZdefd��YZdefd��YZdefd��YZdefd��YZdefd ��YZd!efd"��YZd#efd$��YZd%efd&��YZd'efd(��YZd)efd*��YZd+efd,��YZd-efd.��YZ d/efd0��YZ!d1efd2��YZ"d3efd4��YZ#d5d>d6��YZ$d7Z%d8Z&d9Z'd<Z)d<Z*d:d;l+m,Z,m-Z-d<S(?s
W3C Document Object Model implementation for Python.

The Python mapping of the Document Object Model is documented in the
Python Library Reference in the section on the xml.dom package.

This package contains the following modules:

minidom -- A simple implementation of the Level 1 DOM with namespace
           support added (based on the Level 2 specification) and other
           minor Level 2 functionality.

pulldom -- DOM builder supporting on-demand tree-building for selected
           subtrees of the document.

tNodecBsVeZdZdZdZdZdZdZdZdZ	dZ
d	Zd
ZdZ
dZRS(
s$Class giving the NodeType constants.iiiiiiiii	i
ii(t__name__t
__module__t__doc__tELEMENT_NODEtATTRIBUTE_NODEt	TEXT_NODEtCDATA_SECTION_NODEtENTITY_REFERENCE_NODEtENTITY_NODEtPROCESSING_INSTRUCTION_NODEtCOMMENT_NODEt
DOCUMENT_NODEtDOCUMENT_TYPE_NODEtDOCUMENT_FRAGMENT_NODEt
NOTATION_NODE(((s(/usr/lib64/python2.7/xml/dom/__init__.pyRs	iiiiiiiii	i
iii
iiitDOMExceptioncBs eZdZd�Zd�ZRS(smAbstract base class for DOM exceptions.
    Exceptions with specific codes are specializations of this class.cOs5|jtkrtd��ntj|||�dS(Ns0DOMException should not be instantiated directly(t	__class__RtRuntimeErrort	Exceptiont__init__(tselftargstkw((s(/usr/lib64/python2.7/xml/dom/__init__.pyRAscCs|jS(N(tcode(R((s(/usr/lib64/python2.7/xml/dom/__init__.pyt	_get_codeGs(RRRRR(((s(/usr/lib64/python2.7/xml/dom/__init__.pyR=s	tIndexSizeErrcBseZeZRS((RRtINDEX_SIZE_ERRR(((s(/usr/lib64/python2.7/xml/dom/__init__.pyRKstDomstringSizeErrcBseZeZRS((RRtDOMSTRING_SIZE_ERRR(((s(/usr/lib64/python2.7/xml/dom/__init__.pyRNstHierarchyRequestErrcBseZeZRS((RRtHIERARCHY_REQUEST_ERRR(((s(/usr/lib64/python2.7/xml/dom/__init__.pyRQstWrongDocumentErrcBseZeZRS((RRtWRONG_DOCUMENT_ERRR(((s(/usr/lib64/python2.7/xml/dom/__init__.pyR TstInvalidCharacterErrcBseZeZRS((RRtINVALID_CHARACTER_ERRR(((s(/usr/lib64/python2.7/xml/dom/__init__.pyR"WstNoDataAllowedErrcBseZeZRS((RRtNO_DATA_ALLOWED_ERRR(((s(/usr/lib64/python2.7/xml/dom/__init__.pyR$ZstNoModificationAllowedErrcBseZeZRS((RRtNO_MODIFICATION_ALLOWED_ERRR(((s(/usr/lib64/python2.7/xml/dom/__init__.pyR&]stNotFoundErrcBseZeZRS((RRt
NOT_FOUND_ERRR(((s(/usr/lib64/python2.7/xml/dom/__init__.pyR(`stNotSupportedErrcBseZeZRS((RRtNOT_SUPPORTED_ERRR(((s(/usr/lib64/python2.7/xml/dom/__init__.pyR*cstInuseAttributeErrcBseZeZRS((RRtINUSE_ATTRIBUTE_ERRR(((s(/usr/lib64/python2.7/xml/dom/__init__.pyR,fstInvalidStateErrcBseZeZRS((RRtINVALID_STATE_ERRR(((s(/usr/lib64/python2.7/xml/dom/__init__.pyR.ist	SyntaxErrcBseZeZRS((RRt
SYNTAX_ERRR(((s(/usr/lib64/python2.7/xml/dom/__init__.pyR0lstInvalidModificationErrcBseZeZRS((RRtINVALID_MODIFICATION_ERRR(((s(/usr/lib64/python2.7/xml/dom/__init__.pyR2ostNamespaceErrcBseZeZRS((RRt
NAMESPACE_ERRR(((s(/usr/lib64/python2.7/xml/dom/__init__.pyR4rstInvalidAccessErrcBseZeZRS((RRtINVALID_ACCESS_ERRR(((s(/usr/lib64/python2.7/xml/dom/__init__.pyR6ust
ValidationErrcBseZeZRS((RRtVALIDATION_ERRR(((s(/usr/lib64/python2.7/xml/dom/__init__.pyR8xstUserDataHandlercBs&eZdZdZdZdZdZRS(sBClass giving the operation constants for UserDataHandler.handle().iiii(RRRtNODE_CLONEDt
NODE_IMPORTEDtNODE_DELETEDtNODE_RENAMED(((s(/usr/lib64/python2.7/xml/dom/__init__.pyR:{s
s$http://www.w3.org/XML/1998/namespaceshttp://www.w3.org/2000/xmlns/shttp://www.w3.org/1999/xhtmli����(tgetDOMImplementationtregisterDOMImplementationN(((.RRRRRR!R#R%R'R)R+R-R/R1R3R5R7R9RRRRRR R"R$R&R(R*R,R.R0R2R4R6R8R:t
XML_NAMESPACEtXMLNS_NAMESPACEtXHTML_NAMESPACEtNonetEMPTY_NAMESPACEtEMPTY_PREFIXtdomregR?R@(((s(/usr/lib64/python2.7/xml/dom/__init__.pyt<module>sR
usr/lib64/python2.7/xml/__init__.pyc000064400000002066150352134030013121 0ustar00�
{fc@s�dZddddgZd
Zydd	lZWnek
rAn]Xy
ejZWnek
rbn<Xeekr�dd	lZej	j
e	�eeje<n[d	S(s�Core XML support for Python.

This package contains four sub-packages:

dom -- The W3C Document Object Model.  This supports DOM Level 1 +
       Namespaces.

parsers -- Python wrappers for XML parsers (currently only supports Expat).

sax -- The Simple API for XML, developed by XML-Dev, led by David
       Megginson and ported to Python by Lars Marius Garshol.  This
       supports the SAX 2 API.

etree -- The ElementTree XML library.  This is a subset of the full
       ElementTree XML release.

tdomtparserstsaxtetreeiiii����N(iii(
t__doc__t__all__t_MINIMUM_XMLPLUS_VERSIONt_xmlplustImportErrortversion_infotvtAttributeErrortsyst__path__textendtmodulest__name__(((s$/usr/lib64/python2.7/xml/__init__.pyt<module>s


lib64/python2.7/sqlite3/__init__.pyc000064400000000244150352263220013074 0ustar00�
{fc@sddlTdS(i����(t*N(tdbapi2(((s(/usr/lib64/python2.7/sqlite3/__init__.pyt<module>tlib64/python2.7/test/__init__.pyc000064400000000174150361163400012470 0ustar00�
zfc@sdS(N((((s%/usr/lib64/python2.7/test/__init__.pyt<module>tlib64/python2.7/json/__init__.pyc000064400000033146150364324760012502 0ustar00�
{fc@s,dZdZddddddgZdZd	d
lmZd	dlmZeded
e	de	de	dddddddd�Zee	e	e	ddddded�
Zee	e	e	ddddded�
Z
edddddd�Zdddddddd�Zdddddddd�ZdS(s�JSON (JavaScript Object Notation) <http://json.org> is a subset of
JavaScript syntax (ECMA-262 3rd edition) used as a lightweight data
interchange format.

:mod:`json` exposes an API familiar to users of the standard library
:mod:`marshal` and :mod:`pickle` modules. It is the externally maintained
version of the :mod:`json` library contained in Python 2.6, but maintains
compatibility with Python 2.4 and Python 2.5 and (currently) has
significant performance advantages, even without using the optional C
extension for speedups.

Encoding basic Python object hierarchies::

    >>> import json
    >>> json.dumps(['foo', {'bar': ('baz', None, 1.0, 2)}])
    '["foo", {"bar": ["baz", null, 1.0, 2]}]'
    >>> print json.dumps("\"foo\bar")
    "\"foo\bar"
    >>> print json.dumps(u'\u1234')
    "\u1234"
    >>> print json.dumps('\\')
    "\\"
    >>> print json.dumps({"c": 0, "b": 0, "a": 0}, sort_keys=True)
    {"a": 0, "b": 0, "c": 0}
    >>> from StringIO import StringIO
    >>> io = StringIO()
    >>> json.dump(['streaming API'], io)
    >>> io.getvalue()
    '["streaming API"]'

Compact encoding::

    >>> import json
    >>> json.dumps([1,2,3,{'4': 5, '6': 7}], sort_keys=True, separators=(',',':'))
    '[1,2,3,{"4":5,"6":7}]'

Pretty printing::

    >>> import json
    >>> print json.dumps({'4': 5, '6': 7}, sort_keys=True,
    ...                  indent=4, separators=(',', ': '))
    {
        "4": 5,
        "6": 7
    }

Decoding JSON::

    >>> import json
    >>> obj = [u'foo', {u'bar': [u'baz', None, 1.0, 2]}]
    >>> json.loads('["foo", {"bar":["baz", null, 1.0, 2]}]') == obj
    True
    >>> json.loads('"\\"foo\\bar"') == u'"foo\x08ar'
    True
    >>> from StringIO import StringIO
    >>> io = StringIO('["streaming API"]')
    >>> json.load(io)[0] == 'streaming API'
    True

Specializing JSON object decoding::

    >>> import json
    >>> def as_complex(dct):
    ...     if '__complex__' in dct:
    ...         return complex(dct['real'], dct['imag'])
    ...     return dct
    ...
    >>> json.loads('{"__complex__": true, "real": 1, "imag": 2}',
    ...     object_hook=as_complex)
    (1+2j)
    >>> from decimal import Decimal
    >>> json.loads('1.1', parse_float=Decimal) == Decimal('1.1')
    True

Specializing JSON object encoding::

    >>> import json
    >>> def encode_complex(obj):
    ...     if isinstance(obj, complex):
    ...         return [obj.real, obj.imag]
    ...     raise TypeError(repr(obj) + " is not JSON serializable")
    ...
    >>> json.dumps(2 + 1j, default=encode_complex)
    '[2.0, 1.0]'
    >>> json.JSONEncoder(default=encode_complex).encode(2 + 1j)
    '[2.0, 1.0]'
    >>> ''.join(json.JSONEncoder(default=encode_complex).iterencode(2 + 1j))
    '[2.0, 1.0]'


Using json.tool from the shell to validate and pretty-print::

    $ echo '{"json":"obj"}' | python -m json.tool
    {
        "json": "obj"
    }
    $ echo '{ 1.2:3.4}' | python -m json.tool
    Expecting property name enclosed in double quotes: line 1 column 3 (char 2)
s2.0.9tdumptdumpstloadtloadstJSONDecodertJSONEncodersBob Ippolito <bob@redivi.com>i(R(Rtskipkeystensure_asciitcheck_circulart	allow_nantindentt
separatorstencodingsutf-8tdefaultcKs�|ru|ru|ru|ru|dkru|dkru|dkru|	dkru|
dkru|ru|rutj|�}
n`|dkr�t}n|d|d|d|d|d|d|d|	d	|
d
||�	j|�}
x|
D]}|j|�q�WdS(s�	Serialize ``obj`` as a JSON formatted stream to ``fp`` (a
    ``.write()``-supporting file-like object).

    If ``skipkeys`` is true then ``dict`` keys that are not basic types
    (``str``, ``unicode``, ``int``, ``long``, ``float``, ``bool``, ``None``)
    will be skipped instead of raising a ``TypeError``.

    If ``ensure_ascii`` is true (the default), all non-ASCII characters in the
    output are escaped with ``\uXXXX`` sequences, and the result is a ``str``
    instance consisting of ASCII characters only.  If ``ensure_ascii`` is
    false, some chunks written to ``fp`` may be ``unicode`` instances.
    This usually happens because the input contains unicode strings or the
    ``encoding`` parameter is used. Unless ``fp.write()`` explicitly
    understands ``unicode`` (as in ``codecs.getwriter``) this is likely to
    cause an error.

    If ``check_circular`` is false, then the circular reference check
    for container types will be skipped and a circular reference will
    result in an ``OverflowError`` (or worse).

    If ``allow_nan`` is false, then it will be a ``ValueError`` to
    serialize out of range ``float`` values (``nan``, ``inf``, ``-inf``)
    in strict compliance of the JSON specification, instead of using the
    JavaScript equivalents (``NaN``, ``Infinity``, ``-Infinity``).

    If ``indent`` is a non-negative integer, then JSON array elements and
    object members will be pretty-printed with that indent level. An indent
    level of 0 will only insert newlines. ``None`` is the most compact
    representation.  Since the default item separator is ``', '``,  the
    output might include trailing whitespace when ``indent`` is specified.
    You can use ``separators=(',', ': ')`` to avoid this.

    If ``separators`` is an ``(item_separator, dict_separator)`` tuple
    then it will be used instead of the default ``(', ', ': ')`` separators.
    ``(',', ':')`` is the most compact JSON representation.

    ``encoding`` is the character encoding for str instances, default is UTF-8.

    ``default(obj)`` is a function that should return a serializable version
    of obj or raise TypeError. The default simply raises TypeError.

    If *sort_keys* is true (default: ``False``), then the output of
    dictionaries will be sorted by key.

    To use a custom ``JSONEncoder`` subclass (e.g. one that overrides the
    ``.default()`` method to serialize additional types), specify it with
    the ``cls`` kwarg; otherwise ``JSONEncoder`` is used.

    sutf-8RRRR	R
RRR
t	sort_keysN(tNonet_default_encodert
iterencodeRtwrite(tobjtfpRRRR	tclsR
RRR
Rtkwtiterabletchunk((s%/usr/lib64/python2.7/json/__init__.pyRzs5
$&	
cKs�|rp|rp|rp|rp|dkrp|dkrp|dkrp|dkrp|	dkrp|
rp|rptj|�S|dkr�t}n|d|d|d|d|d|d|d|d	|	d
|
|�	j|�S(sSerialize ``obj`` to a JSON formatted ``str``.

    If ``skipkeys`` is true then ``dict`` keys that are not basic types
    (``str``, ``unicode``, ``int``, ``long``, ``float``, ``bool``, ``None``)
    will be skipped instead of raising a ``TypeError``.


    If ``ensure_ascii`` is false, all non-ASCII characters are not escaped, and
    the return value may be a ``unicode`` instance. See ``dump`` for details.

    If ``check_circular`` is false, then the circular reference check
    for container types will be skipped and a circular reference will
    result in an ``OverflowError`` (or worse).

    If ``allow_nan`` is false, then it will be a ``ValueError`` to
    serialize out of range ``float`` values (``nan``, ``inf``, ``-inf``) in
    strict compliance of the JSON specification, instead of using the
    JavaScript equivalents (``NaN``, ``Infinity``, ``-Infinity``).

    If ``indent`` is a non-negative integer, then JSON array elements and
    object members will be pretty-printed with that indent level. An indent
    level of 0 will only insert newlines. ``None`` is the most compact
    representation.  Since the default item separator is ``', '``,  the
    output might include trailing whitespace when ``indent`` is specified.
    You can use ``separators=(',', ': ')`` to avoid this.

    If ``separators`` is an ``(item_separator, dict_separator)`` tuple
    then it will be used instead of the default ``(', ', ': ')`` separators.
    ``(',', ':')`` is the most compact JSON representation.

    ``encoding`` is the character encoding for str instances, default is UTF-8.

    ``default(obj)`` is a function that should return a serializable version
    of obj or raise TypeError. The default simply raises TypeError.

    If *sort_keys* is true (default: ``False``), then the output of
    dictionaries will be sorted by key.

    To use a custom ``JSONEncoder`` subclass (e.g. one that overrides the
    ``.default()`` method to serialize additional types), specify it with
    the ``cls`` kwarg; otherwise ``JSONEncoder`` is used.

    sutf-8RRRR	R
RRR
RN(RRtencodeR(RRRRR	RR
RRR
RR((s%/usr/lib64/python2.7/json/__init__.pyR�s/
$&
	tobject_hooktobject_pairs_hookc	Ks=t|j�d|d|d|d|d|d|d||�S(s�Deserialize ``fp`` (a ``.read()``-supporting file-like object containing
    a JSON document) to a Python object.

    If the contents of ``fp`` is encoded with an ASCII based encoding other
    than utf-8 (e.g. latin-1), then an appropriate ``encoding`` name must
    be specified. Encodings that are not ASCII based (such as UCS-2) are
    not allowed, and should be wrapped with
    ``codecs.getreader(fp)(encoding)``, or simply decoded to a ``unicode``
    object and passed to ``loads()``

    ``object_hook`` is an optional function that will be called with the
    result of any object literal decode (a ``dict``). The return value of
    ``object_hook`` will be used instead of the ``dict``. This feature
    can be used to implement custom decoders (e.g. JSON-RPC class hinting).

    ``object_pairs_hook`` is an optional function that will be called with the
    result of any object literal decoded with an ordered list of pairs.  The
    return value of ``object_pairs_hook`` will be used instead of the ``dict``.
    This feature can be used to implement custom decoders that rely on the
    order that the key and value pairs are decoded (for example,
    collections.OrderedDict will remember the order of insertion). If
    ``object_hook`` is also defined, the ``object_pairs_hook`` takes priority.

    To use a custom ``JSONDecoder`` subclass, specify it with the ``cls``
    kwarg; otherwise ``JSONDecoder`` is used.

    RRRtparse_floatt	parse_inttparse_constantR(Rtread(	RRRRRRRRR((s%/usr/lib64/python2.7/json/__init__.pyRs
	c	Ks|dkrh|dkrh|dkrh|dkrh|dkrh|dkrh|dkrh|rhtj|�S|dkr}t}n|dk	r�||d<n|dk	r�||d<n|dk	r�||d<n|dk	r�||d<n|dk	r�||d<n|d||�j|�S(s�Deserialize ``s`` (a ``str`` or ``unicode`` instance containing a JSON
    document) to a Python object.

    If ``s`` is a ``str`` instance and is encoded with an ASCII based encoding
    other than utf-8 (e.g. latin-1) then an appropriate ``encoding`` name
    must be specified. Encodings that are not ASCII based (such as UCS-2)
    are not allowed and should be decoded to ``unicode`` first.

    ``object_hook`` is an optional function that will be called with the
    result of any object literal decode (a ``dict``). The return value of
    ``object_hook`` will be used instead of the ``dict``. This feature
    can be used to implement custom decoders (e.g. JSON-RPC class hinting).

    ``object_pairs_hook`` is an optional function that will be called with the
    result of any object literal decoded with an ordered list of pairs.  The
    return value of ``object_pairs_hook`` will be used instead of the ``dict``.
    This feature can be used to implement custom decoders that rely on the
    order that the key and value pairs are decoded (for example,
    collections.OrderedDict will remember the order of insertion). If
    ``object_hook`` is also defined, the ``object_pairs_hook`` takes priority.

    ``parse_float``, if specified, will be called with the string
    of every JSON float to be decoded. By default this is equivalent to
    float(num_str). This can be used to use another datatype or parser
    for JSON floats (e.g. decimal.Decimal).

    ``parse_int``, if specified, will be called with the string
    of every JSON int to be decoded. By default this is equivalent to
    int(num_str). This can be used to use another datatype or parser
    for JSON integers (e.g. float).

    ``parse_constant``, if specified, will be called with one of the
    following strings: -Infinity, Infinity, NaN.
    This can be used to raise an exception if invalid JSON numbers
    are encountered.

    To use a custom ``JSONDecoder`` subclass, specify it with the ``cls``
    kwarg; otherwise ``JSONDecoder`` is used.

    RRRRRRN(Rt_default_decodertdecodeR(	tsRRRRRRRR((s%/usr/lib64/python2.7/json/__init__.pyR&s"*$
	




N(t__doc__t__version__t__all__t
__author__tdecoderRtencoderRtFalsetTrueRRRRR RR(((s%/usr/lib64/python2.7/json/__init__.pyt<module>cs6		E	;	#lib64/python2.7/pydoc_data/__init__.pyc000064400000000202150470200760013612 0ustar00�
|fc@sdS(N((((s+/usr/lib64/python2.7/pydoc_data/__init__.pyt<module>tlib64/python2.7/lib2to3/fixes/__init__.pyc000064400000000205150471304450014104 0ustar00�
{fc@sdS(N((((s./usr/lib64/python2.7/lib2to3/fixes/__init__.pyt<module>tlib64/python2.7/lib2to3/pgen2/__init__.pyc000064400000000256150471304530014006 0ustar00�
{fc@s
dZdS(sThe pgen2 package.N(t__doc__(((s./usr/lib64/python2.7/lib2to3/pgen2/__init__.pyt<module>tlib64/python2.7/lib2to3/__init__.pyc000064400000000177150472457410013004 0ustar00�
{fc@sdS(N((((s(/usr/lib64/python2.7/lib2to3/__init__.pyt<module>t