/home/lnzliplg/www/dateutil.zip
PKa�\�^����_version.pynu�[���"""
Contains information about the dateutil version.
"""

VERSION_MAJOR = 2
VERSION_MINOR = 6
VERSION_PATCH = 1

VERSION_TUPLE = (VERSION_MAJOR, VERSION_MINOR, VERSION_PATCH)
VERSION = '.'.join(map(str, VERSION_TUPLE))
PKa�\^tR����'__pycache__/parser.cpython-36.opt-1.pycnu�[���3

6�cY���@sdZddlmZddlZddlZddlZddlZddlZddlm	Z	ddl
mZddlm
Z
mZmZddlmZdd	lmZd
dgZGdd
�d
e�ZGdd�de�ZGdd�de�ZGdd�de�ZGdd�de�Ze�Zddd
�ZGdd�de�Ze�Zdd�Zdd�Z dS)a�
This module offers a generic date/time string parser which is able to parse
most known formats to represent a date and/or time.

This module attempts to be forgiving with regards to unlikely input formats,
returning a datetime object even for dates which are ambiguous. If an element
of a date/time stamp is omitted, the following rules are applied:
- If AM or PM is left unspecified, a 24-hour clock is assumed, however, an hour
  on a 12-hour clock (``0 <= hour <= 12``) *must* be specified if AM or PM is
  specified.
- If a time zone is omitted, a timezone-naive datetime is returned.

If any other elements are missing, they are taken from the
:class:`datetime.datetime` object passed to the parameter ``default``. If this
results in a day number exceeding the valid number of days per month, the
value falls back to the end of the month.

Additional resources about date/time string formats can be found below:

- `A summary of the international standard date and time notation
  <http://www.cl.cam.ac.uk/~mgk25/iso-time.html>`_
- `W3C Date and Time Formats <http://www.w3.org/TR/NOTE-datetime>`_
- `Time Formats (Planetary Rings Node) <http://pds-rings.seti.org/tools/time_formats.html>`_
- `CPAN ParseDate module
  <http://search.cpan.org/~muir/Time-modules-2013.0912/lib/Time/ParseDate.pm>`_
- `Java SimpleDateFormat Class
  <https://docs.oracle.com/javase/6/docs/api/java/text/SimpleDateFormat.html>`_
�)�unicode_literalsN)�StringIO)�
monthrange)�	text_type�binary_type�
integer_types�)�
relativedelta)�tz�parse�
parserinfoc@sneZdZejd�Zdd�Zdd�Zdd�Zdd	�Z	d
d�Z
edd
��Zedd��Z
edd��Zedd��ZdS)�_timelexz([.,])cCsdt|t�r|j�}t|t�r$t|�}t|dd�dkrHtdj|jj	d���||_
g|_g|_d|_
dS)N�readz8Parser must be a string or character stream, not {itype})ZitypeF)�
isinstancer�decoderr�getattr�	TypeError�format�	__class__�__name__�instream�	charstack�
tokenstack�eof)�selfr�r�/usr/lib/python3.6/parser.py�__init__4s

z_timelex.__init__cCs�|jr|jjd�Sd}d}d}�x�|j�s|jr>|jjd�}n&|jjd�}x|dkrb|jjd�}qLW|srd|_Pq"|s�|}|j|�r�d}n$|j|�r�d}n|j|�r�d	}PnPq"|dk�r�d}|j|�r�||7}n$|d
kr�||7}d}n|jj	|�Pq"|dk�rX|j|��r||7}n>|d
k�s:|dk�rHt
|�d
k�rH||7}d}n|jj	|�Pq"|dk�r�d}|d
k�s||j|��r�||7}n6|j|��r�|dd
k�r�||7}d}n|jj	|�Pq"|dkr"|d
k�s�|j|��r�||7}q"|j|��r|dd
k�r||7}d}q"|jj	|�Pq"W|dk�r�|�sN|jd
�dk�sN|ddk�r�|jj
|�}|d}x(|dd�D]}|�rp|jj	|��qpW|dk�r�|jd
�dk�r�|jdd
�}|S)a�
        This function breaks the time string into lexical units (tokens), which
        can be parsed by the parser. Lexical units are demarcated by changes in
        the character set, so any continuous string of letters is considered
        one unit, any continuous string of numbers is considered one unit.

        The main complication arises from the fact that dots ('.') can be used
        both as separators (e.g. "Sep.20.2009") or decimal points (e.g.
        "4:30:21.447"). As such, it is necessary to read the full context of
        any dot-separated strings before breaking it into tokens; as such, this
        function maintains a "token stack", for when the ambiguous context
        demands that multiple tokens be parsed at once.
        rFNr�T�a�0� �.�a.�,��0.z.,���r')r#r&r')r�poprrrr�isword�isnum�isspace�append�len�count�_split_decimal�split�replace)rZseenletters�token�state�nextchar�l�tokrrr�	get_tokenDs�








"


 z_timelex.get_tokencCs|S)Nr)rrrr�__iter__�sz_timelex.__iter__cCs|j�}|dkrt�|S)N)r7�
StopIteration)rr2rrr�__next__�sz_timelex.__next__cCs|j�S)N)r:)rrrr�next�sz
_timelex.nextcCst||��S)N)�list)�cls�srrrr0�sz_timelex.splitcCs|j�S)z5 Whether or not the next character is part of a word )�isalpha)r=r4rrrr)�sz_timelex.iswordcCs|j�S)z0 Whether the next character is part of a number )�isdigit)r=r4rrrr*�sz_timelex.isnumcCs|j�S)z* Whether the next character is whitespace )r+)r=r4rrrr+�sz_timelex.isspaceN)r�
__module__�__qualname__�re�compiler/rr7r8r:r;�classmethodr0r)r*r+rrrrr
0s
mr
c@s,eZdZdd�Zdd�Zdd�Zdd�Zd	S)
�_resultbasecCs x|jD]}t||d�qWdS)N)�	__slots__�setattr)r�attrrrrr�sz_resultbase.__init__cCsNg}x6|jD],}t||�}|dk	r|jd|t|�f�qWd|dj|�fS)Nz%s=%sz%s(%s)z, )rGrr,�repr�join)rZ	classnamer5rI�valuerrr�_repr�s
z_resultbase._reprcst�fdd��jD��S)Nc3s|]}t�|�dk	VqdS)N)r)�.0rI)rrr�	<genexpr>�sz&_resultbase.__len__.<locals>.<genexpr>)�sumrG)rr)rr�__len__�sz_resultbase.__len__cCs|j|jj�S)N)rMrr)rrrr�__repr__�sz_resultbase.__repr__N)rrArBrrMrQrRrrrrrF�srFc@s�eZdZdZdddddddd	d
ddd
ddddddgZdcdddedfdgdhdigZdjdkdldmdndodpdqdrdsdtdugZdvdwdxgZdydzgZdFdGdHgZ	dgZ
iZd{dJdK�ZdLdM�Z
dNdO�ZdPdQ�ZdRdS�ZdTdU�ZdVdW�ZdXdY�ZdZd[�Zd\d]�Zd|d^d_�Zd`da�ZdbS)}ra�
    Class which handles what inputs are accepted. Subclass this to customize
    the language and acceptable values for each parameter.

    :param dayfirst:
            Whether to interpret the first value in an ambiguous 3-integer date
            (e.g. 01/05/09) as the day (``True``) or month (``False``). If
            ``yearfirst`` is set to ``True``, this distinguishes between YDM
            and YMD. Default is ``False``.

    :param yearfirst:
            Whether to interpret the first value in an ambiguous 3-integer date
            (e.g. 01/05/09) as the year. If ``True``, the first number is taken
            to be the year, otherwise the last number is taken to be the year.
            Default is ``False``.
    r!r"r$�;�-�/�'ZatZon�andZad�m�tZof�stZndZrdZth�Mon�Monday�Tue�Tuesday�Wed�	Wednesday�Thu�Thursday�Fri�Friday�Sat�Saturday�Sun�Sunday�Jan�January�Feb�February�Mar�March�Apr�April�May�Jun�June�Jul�July�Aug�August�Sep�Sept�	September�Oct�October�Nov�November�Dec�December�h�hour�hours�minute�minutesr>�second�seconds�amr�pm�p�UTCZGMT�ZFcCs�|j|j�|_|j|j�|_|j|j�|_|j|j�|_|j|j	�|_
|j|j�|_|j|j
�|_||_||_tj�j|_|jdd|_dS)N�d)�_convert�JUMP�_jump�WEEKDAYS�	_weekdays�MONTHS�_months�HMS�_hms�AMPM�_ampm�UTCZONE�_utczone�PERTAIN�_pertain�dayfirst�	yearfirst�timeZ	localtimeZtm_year�_year�_century)rr�r�rrrrszparserinfo.__init__cCsPi}xFt|�D]:\}}t|t�r<x&|D]}|||j�<q&Wq|||j�<qW|S)N)�	enumerater�tuple�lower)rZlstZdct�i�vrrrr�*s

zparserinfo._convertcCs|j�|jkS)N)r�r�)r�namerrr�jump4szparserinfo.jumpcCsHt|�tdd�|jj�D��krDy|j|j�Stk
rBYnXdS)Ncss|]}t|�VqdS)N)r-)rN�nrrrrO8sz%parserinfo.weekday.<locals>.<genexpr>)r-�minr��keysr��KeyError)rr�rrr�weekday7s zparserinfo.weekdaycCsLt|�tdd�|jj�D��krHy|j|j�dStk
rFYnXdS)Ncss|]}t|�VqdS)N)r-)rNr�rrrrO@sz#parserinfo.month.<locals>.<genexpr>r)r-r�r�r�r�r�)rr�rrr�month?s zparserinfo.monthcCs(y|j|j�Stk
r"dSXdS)N)r�r�r�)rr�rrr�hmsGszparserinfo.hmscCs(y|j|j�Stk
r"dSXdS)N)r�r�r�)rr�rrr�ampmMszparserinfo.ampmcCs|j�|jkS)N)r�r�)rr�rrr�pertainSszparserinfo.pertaincCs|j�|jkS)N)r�r�)rr�rrr�utczoneVszparserinfo.utczonecCs||jkrdS|jj|�S)Nr)r��TZOFFSET�get)rr�rrr�tzoffsetYs
zparserinfo.tzoffsetcCsJ|dkrF|rF||j7}t||j�dkrF||jkr>|d7}n|d8}|S)Nr��2)r��absr�)r�year�century_specifiedrrr�convertyear_s


zparserinfo.convertyearcCsl|jdk	r|j|j|j�|_|jdkr.|js8|jdkrFd|_d|_n"|jdkrh|jrh|j|j�rhd|_dS)Nrr�r�T)r�r�r�r��tznamer�)r�resrrr�validateis
zparserinfo.validateN)r[r\)r]r^)r_r`)rarb)rcrd)rerf)rgrh)rirj)rkrl)rmrn)rorp)rqrq)rrrs)rtru)rvrw)rxryrz)r{r|)r}r~)rr�)r�r�r�)rXr�r�)r>r�r�)r�r)r�r�)FF)F)rrArB�__doc__r�r�r�r�r�r�r�r�rr�r�r�r�r�r�r�r�r�r�r�rrrrr�sV




csPeZdZ�fdd�Zedd��Zedd��Zdd�Z�fd	d
�Zdd�Z	�Z
S)
�_ymdcs$t|j|�j||�d|_||_dS)NF)�superrrr��tzstr)rr��args�kwargs)rrrrwsz
_ymd.__init__cCs&yt|�|kStk
r dSXdS)NF)�int�
ValueError)r2r�rrr�token_could_be_year|sz_ymd.token_could_be_yearcs�fdd�|D�S)Ncsg|]}tj|��r|�qSr)r�r�)rNr2)r�rr�
<listcomp>�sz3_ymd.find_potential_year_tokens.<locals>.<listcomp>r)r��tokensr)r�r�find_potential_year_tokens�sz_ymd.find_potential_year_tokenscCsFx@t|�D]4\}}tj||�}t|�dkr
t|d�dkr
|Sq
WdS)zk
        attempt to deduce if a pre 100 year was lost
         due to padded zeros being taken off
        rrr%N)r�r�r�r-)rr��indexr2Zpotential_year_tokensrrr�find_probable_year_index�sz_ymd.find_probable_year_indexcsNt|d�r&|j�r4t|�dkr4d|_n|dkr4d|_t|j|�jt|��dS)NrQr%Tr�)�hasattrr@r-r�r�rr,r�)r�val)rrrr,�s
z_ymd.appendcCs,t|�}d\}}}|dkr&td���n�|dks>|d	kr�|dkr�|d
krT||}||=|dksd|dkr�|ddkrz|d}n|d}�n�|dkr�|ddkr�|\}}n8|ddkr�|\}}n"|r�|ddkr�|\}}n|\}}�nB|dk�r"|dk�r|\}}}�n |dk�rF|ddk�s.|�r:|ddk�r:|\}}}n
|\}}}n�|dk�rv|ddk�rj|\}}}n
|\}}}n�|ddk�s�|jtj|j��dk�s�|�r�|ddk�r�|ddk�r�|�r�|ddk�r�|\}}}n
|\}}}n8|ddk�s|�r|ddk�r|\}}}n
|\}}}|||fS)N�zMore than three YMD valuesrr%r��)NNNr'r'r')r-r�r�r
r0r�)r�mstridxr�r�Zlen_ymdr�r��dayrrr�resolve_ymd�sR







"
""
z_ymd.resolve_ymd)rrArBr�staticmethodr�r�r�r,r��
__classcell__rr)rrr�vs
	r�c@sFeZdZd
dd�Zddd�ZGdd�de�Zdd	d
�Zedd��Z	dS)�parserNcCs|pt�|_dS)N)r�info)rr�rrrr�szparser.__init__FcKsV|dkr tjj�jddddd�}|j|f|�\}}|dkrBtd��t|�dkrVtd��i}x&dD]}	t||	�}
|
dk	r`|
||	<q`Wd|kr�|jdkr�|jn|j}|jdkr�|jn|j}|j	dkr�|j	n|j	}
|
t
||�d
kr�t
||�d
|d<|jf|�}|jdk	�r$|j	�r$|tj|jd�}|�s8t
|tj��sJ|�r�|j|k�r�t
|tj��rh||j|j�}n|j|j�}t
|tj��r�|}n<t
|t��r�tj|�}n$t
|t��r�tj|j|�}ntd��|j|d�}nf|j�r�|jtjk�r�|jtj�d�}n>|jdk�r|jtj�d�}n |j�r8|jtj|j|j�d�}|jdd��rN||fS|SdS)aV

        Parse the date/time string into a :class:`datetime.datetime` object.

        :param timestr:
            Any date/time string using the supported formats.

        :param default:
            The default datetime object, if this is a datetime object and not
            ``None``, elements specified in ``timestr`` replace elements in the
            default object.

        :param ignoretz:
            If set ``True``, time zones in parsed strings are ignored and a
            naive :class:`datetime.datetime` object is returned.

        :param tzinfos:
            Additional time zone names / aliases which may be present in the
            string. This argument maps time zone names (and optionally offsets
            from those time zones) to time zones. This parameter can be a
            dictionary with timezone aliases mapping time zone names to time
            zones or a function taking two parameters (``tzname`` and
            ``tzoffset``) and returning a time zone.

            The timezones to which the names are mapped can be an integer
            offset from UTC in minutes or a :class:`tzinfo` object.

            .. doctest::
               :options: +NORMALIZE_WHITESPACE

                >>> from dateutil.parser import parse
                >>> from dateutil.tz import gettz
                >>> tzinfos = {"BRST": -10800, "CST": gettz("America/Chicago")}
                >>> parse("2012-01-19 17:21:00 BRST", tzinfos=tzinfos)
                datetime.datetime(2012, 1, 19, 17, 21, tzinfo=tzoffset(u'BRST', -10800))
                >>> parse("2012-01-19 17:21:00 CST", tzinfos=tzinfos)
                datetime.datetime(2012, 1, 19, 17, 21,
                                  tzinfo=tzfile('/usr/share/zoneinfo/America/Chicago'))

            This parameter is ignored if ``ignoretz`` is set.

        :param **kwargs:
            Keyword arguments as passed to ``_parse()``.

        :return:
            Returns a :class:`datetime.datetime` object or, if the
            ``fuzzy_with_tokens`` option is ``True``, returns a tuple, the
            first element being a :class:`datetime.datetime` object, the second
            a tuple containing the fuzzy tokens.

        :raises ValueError:
            Raised for invalid or unknown string format, if the provided
            :class:`tzinfo` is not in a valid format, or if an invalid date
            would be created.

        :raises TypeError:
            Raised for non-string or character stream input.

        :raises OverflowError:
            Raised if the parsed date exceeds the largest valid C integer on
            your system.
        Nr)r�r�r��microsecondzUnknown string formatzString does not contain a date.r�r�r�r�r�r�r�r)r�z9Offset must be tzinfo subclass, tz string, or int offset.)�tzinfo�fuzzy_with_tokensF)r�r�r�r�r�r�r�)�datetimeZnowr1�_parser�r-rr�r�r�rr�r	r�collections�Callabler�r�r�r�rr
r�rr�ZtzlocalZtzutc)r�timestr�defaultZignoretzZtzinfosr�r��skipped_tokens�replrIrLZcyearZcmonthZcday�retZtzdatar�rrrr�s\?

zparser.parsec@s&eZdZddddddddd	d
dgZdS)
zparser._resultr�r�r�r�r�r�r�r�r�r�r�N)rrArBrGrrrr�_resultisr�cCsJ
|rd}|j}|dkr|j}|dkr*|j}|j�}tj|�}d }	t�}
�y�t|�}d!}t|�}
d}�xJ||
k�r�y||}t	|�}Wnt
k
r�d}YnX|dk	�r�t||�}|d7}t|�dk�rH|d"k�rH|jdk�rH||
k�s||dk�rH|j||�dk�rH||d}t
|dd��|_|dk�r�t
|dd��|_qf|d	k�st|d	k�r||djd
�d	k�r||d}|�r�||djd
�d#k�r�|j|dd��|j|dd��|j|dd��n<t
|dd��|_t
|dd��|_t|dd��\|_|_qf|d$k�r�||d}|j|dd��|j|dd	��|j|d	d��|dk�r�t
|dd��|_t
|dd��|_|dk�r�t
|dd��|_qf||
k�r�|j||�dk	�s|d|
k�r0||dk�r0|j||d�dk	�r0||dk�r|d7}|j||�}�x�|dk�rZt
|�|_|d�r�t
d|d�|_nL|dk�r�t
|�|_|d�r�t
d|d�|_n|dk�r�t|�\|_|_|d7}||
k�s�|dk�r�Py||}t	|�}Wnt
k
�r�PYn8X|d7}|d7}||
k�r(|j||�}|dk	�r(|}�q(Wqf||
k�r�||ddk�r�|j||d�dk	�r�|j||d�}|dk�r�t
|�|_|d}|�r�t
d|�|_n|dk�r�t|�\|_|_qf|d|
k�rf||dk�rft
|�|_|d7}t	||�}t
|�|_|d�r$t
d|d�|_|d7}||
k�r�||dk�r�t||d�\|_|_|d7}qf||
k�r�||d%k�r�||}|j|�|d7}||
k�r�|j||��r�y|j||�WnJt
k
�r|j||�}|dk	�r|j|�t|�d}nd&SYnX|d7}||
k�r�|||k�r�|d7}|j||�}|dk	�rj|j|�t|�d}n|j||�|d7}qf||
k�s�|j||��rH|d|
k�r4|j||d�dk	�r4t
|�|_|jdk�r|j||d�dk�r|jd7_n*|jdk�r*|j||d�dk�r*d|_|d7}n
|j|�|d7}qf|j||�dk	�r�t
|�|_|jdk�r�|j||�dk�r�|jd7_n&|jdk�r�|j||�dk�r�d|_|d7}qf|�s�d'S|d7}qf|j||�}|dk	�r||_|d7}qf|j||�}|dk	�	r:|j|�t|�d}|d7}||
krf||d(k�r�||}|d7}|j||�|d7}||
k�	r8|||k�	r8|d7}|j||�|d7}qf|d|
krf||||dk�o�dknrf|j||d�rfyt
||d�}Wnt
k
�	rYnX|jt|j|���|d7}qf|j||�}|dk	�
r0d}|�	rl|jdk	�	rld}|jdk�	r�|�	r�d}nt
d)��n2d|jk�	o�dkn�	s�|�	r�d}nt
d*��|�
r|dk�	r�|jdk�	r�|jd7_n|dk�
r|jdk�
rd|_||_n|�
r&|j|
|	||�}	|d7}qf|jdk	�
r�t||�dk�
r�|jdk�
r�|jdk�
r�dd�||D��
r�|||_|j|j�|_|d7}||
krf||d+krfd,||dk||<d|_|j|j�rfd|_qf|jdk	�rz||d-k�rzd/||dk}|d7}t||�}|dk�rZt
||dd��dt
||dd��d|_nz|d|
k�r�||ddk�r�t
||�dt
||d�d|_|d7}n*|dk�r�t
||dd��d|_nd0S|d7}|j|9_|d|
krf|j||�rf||ddkrf||ddkrfdt||d�k�oDdknrfdd�||dD�rf||d|_|d7}qf|j||��p�|�s�d1S|j|
|	||�}	|d7}qfW|j|||�\}}}|dk	�r�||_ |j!|_!|dk	�r�||_|dk	�r�||_"Wnt#t
t$fk
�
rd2SX|j%|��
s,d3S|�
r>|t&|
�fS|dfSdS)4a
        Private method which performs the heavy lifting of parsing, called from
        ``parse()``, which passes on its ``kwargs`` to this function.

        :param timestr:
            The string to parse.

        :param dayfirst:
            Whether to interpret the first value in an ambiguous 3-integer date
            (e.g. 01/05/09) as the day (``True``) or month (``False``). If
            ``yearfirst`` is set to ``True``, this distinguishes between YDM
            and YMD. If set to ``None``, this value is retrieved from the
            current :class:`parserinfo` object (which itself defaults to
            ``False``).

        :param yearfirst:
            Whether to interpret the first value in an ambiguous 3-integer date
            (e.g. 01/05/09) as the year. If ``True``, the first number is taken
            to be the year, otherwise the last number is taken to be the year.
            If this is set to ``None``, the value is retrieved from the current
            :class:`parserinfo` object (which itself defaults to ``False``).

        :param fuzzy:
            Whether to allow fuzzy parsing, allowing for string like "Today is
            January 1, 2047 at 8:21:00AM".

        :param fuzzy_with_tokens:
            If ``True``, ``fuzzy`` is automatically set to True, and the parser
            will return a tuple where the first element is the parsed
            :class:`datetime.datetime` datetimestamp and the second element is
            a tuple containing the portions of the string which were ignored:

            .. doctest::

                >>> from dateutil.parser import parse
                >>> parse("Today is January 1, 2047 at 8:21:00AM", fuzzy_with_tokens=True)
                (datetime.datetime(2047, 1, 1, 8, 21), (u'Today is ', u' ', u'at '))

        TNr%rrr���:�r"�r���
r!�<rTrUFzNo hour specified with zAM or PM flag.zInvalid hour specified for z12-hour clock.�cSsg|]}|tjkr|�qSr)�string�ascii_uppercase)rN�xrrrr��sz!parser._parse.<locals>.<listcomp>�+i�(�)cSsg|]}|tjkr|�qSr)r�r�)rNr�rrrr�s���r')r%r�r')r�r�r�)rTrUr")NN)NN)rTrUz%No hour specified with AM or PM flag.z)Invalid hour specified for 12-hour clock.)r�rT)r�rT)r�rTr')r'r)NN)NN)NN)NN)'r�r�r�r�r
r0r<r�r-�floatr�r�r�r�r��findr,�_parsemsr�r�r�r�r�r�r��strr��_skip_tokenr�r�r�r�r�r�r��
IndexError�AssertionErrorr�r�)rr�r�r�Zfuzzyr�r�r�r5�last_skipped_token_ir�Zymdr��len_lr�Z
value_reprrL�len_lir>�idxZnewidxZ
sec_remainder�sepZval_is_ampm�signalr�r�r�rrrr�ns�)


$
, 

























&
$$



  




2



4 &

.&




z
parser._parsecCs8||dkr"|d||7<n|j||�|}|S)Nrr')r,)r�r�r�r5rrrr�-s
zparser._skip_token)N)NFN)NNFF)
rrArBrrrFr�r�r�r�rrrrr��s


Ar�cKs(|rt|�j|f|�Stj|f|�SdS)a)

    Parse a string in one of the supported formats, using the
    ``parserinfo`` parameters.

    :param timestr:
        A string containing a date/time stamp.

    :param parserinfo:
        A :class:`parserinfo` object containing parameters for the parser.
        If ``None``, the default arguments to the :class:`parserinfo`
        constructor are used.

    The ``**kwargs`` parameter takes the following keyword arguments:

    :param default:
        The default datetime object, if this is a datetime object and not
        ``None``, elements specified in ``timestr`` replace elements in the
        default object.

    :param ignoretz:
        If set ``True``, time zones in parsed strings are ignored and a naive
        :class:`datetime` object is returned.

    :param tzinfos:
            Additional time zone names / aliases which may be present in the
            string. This argument maps time zone names (and optionally offsets
            from those time zones) to time zones. This parameter can be a
            dictionary with timezone aliases mapping time zone names to time
            zones or a function taking two parameters (``tzname`` and
            ``tzoffset``) and returning a time zone.

            The timezones to which the names are mapped can be an integer
            offset from UTC in minutes or a :class:`tzinfo` object.

            .. doctest::
               :options: +NORMALIZE_WHITESPACE

                >>> from dateutil.parser import parse
                >>> from dateutil.tz import gettz
                >>> tzinfos = {"BRST": -10800, "CST": gettz("America/Chicago")}
                >>> parse("2012-01-19 17:21:00 BRST", tzinfos=tzinfos)
                datetime.datetime(2012, 1, 19, 17, 21, tzinfo=tzoffset(u'BRST', -10800))
                >>> parse("2012-01-19 17:21:00 CST", tzinfos=tzinfos)
                datetime.datetime(2012, 1, 19, 17, 21,
                                  tzinfo=tzfile('/usr/share/zoneinfo/America/Chicago'))

            This parameter is ignored if ``ignoretz`` is set.

    :param dayfirst:
        Whether to interpret the first value in an ambiguous 3-integer date
        (e.g. 01/05/09) as the day (``True``) or month (``False``). If
        ``yearfirst`` is set to ``True``, this distinguishes between YDM and
        YMD. If set to ``None``, this value is retrieved from the current
        :class:`parserinfo` object (which itself defaults to ``False``).

    :param yearfirst:
        Whether to interpret the first value in an ambiguous 3-integer date
        (e.g. 01/05/09) as the year. If ``True``, the first number is taken to
        be the year, otherwise the last number is taken to be the year. If
        this is set to ``None``, the value is retrieved from the current
        :class:`parserinfo` object (which itself defaults to ``False``).

    :param fuzzy:
        Whether to allow fuzzy parsing, allowing for string like "Today is
        January 1, 2047 at 8:21:00AM".

    :param fuzzy_with_tokens:
        If ``True``, ``fuzzy`` is automatically set to True, and the parser
        will return a tuple where the first element is the parsed
        :class:`datetime.datetime` datetimestamp and the second element is
        a tuple containing the portions of the string which were ignored:

        .. doctest::

            >>> from dateutil.parser import parse
            >>> parse("Today is January 1, 2047 at 8:21:00AM", fuzzy_with_tokens=True)
            (datetime.datetime(2047, 1, 1, 8, 21), (u'Today is ', u' ', u'at '))

    :return:
        Returns a :class:`datetime.datetime` object or, if the
        ``fuzzy_with_tokens`` option is ``True``, returns a tuple, the
        first element being a :class:`datetime.datetime` object, the second
        a tuple containing the fuzzy tokens.

    :raises ValueError:
        Raised for invalid or unknown string format, if the provided
        :class:`tzinfo` is not in a valid format, or if an invalid date
        would be created.

    :raises OverflowError:
        Raised if the parsed date exceeds the largest valid C integer on
        your system.
    N)r�r�
DEFAULTPARSER)r�rr�rrrr<s_c@s$eZdZGdd�de�Zdd�ZdS)�	_tzparserc@s<eZdZddddddgZGdd�de�Zd	d
�Zdd�Zd
S)z_tzparser._result�stdabbr�	stdoffset�dstabbr�	dstoffset�start�endc@seZdZdddddddgZdS)	z_tzparser._result._attrr��weekr��yday�jydayr�r�N)rrArBrGrrrr�_attr�srcCs
|jd�S)N�)rM)rrrrrR�sz_tzparser._result.__repr__cCs"tj|�|j�|_|j�|_dS)N)rFrrrr)rrrrr�s

z_tzparser._result.__init__N)rrArBrGrFrrRrrrrrr��s
r�cCs�|j�}tj|�}�y�t|�}d}�x�||k�r�|}x(||kr\dd�||D�r\|d7}q6W||k�r�|js�d}dj|||��|_nd}dj|||��|_|}||ko�||dks�||dd
k�r�||dk�r�d||dk}|d7}nd}t||�}	|	dk�rJt||t||dd��d
t||dd��d|�n�|d|k�r�||ddk�r�t||t||�d
t||d�d|�|d7}n4|	dk�r�t||t||dd��d
|�ndS|d7}|j�r�Pq&Pq&W||k�r0x*t	||�D]}||dk�rd||<�qW|d7}||k�r>�n�d|j
d�k�oXdkn�r�dd�||d�D��r�x�|j|jfD]�}
t||�|
_
|d7}||d	k�r�t||d�d }|d7}nt||�}|d7}|�r||
_t||�dd|
_nt||�|
_|d7}t||�|
_|d7}�q�W||k�r�||d!k�rjd#||dk}|d7}nd}|jt||�||_�nL|j
d�dk�r�||d�j
d�dk�r�dd�||d�D��r֐x|j|jfD�]�}
||dk�r|d7}t||�|
_n�||dk�r�|d7}t||�|
_
|d7}|d7}t||�|
_|
jdk�r\d$|
_|d7}|d7}t||�dd|
_nt||�d|
_|d7}||k�r�||dk�r�|d7}t||�}	|	dk�rt||dd��d
t||dd��d|
_n�|d|k�r�||ddk�r�t||�d
t||d�d|
_|d7}|d|k�r�||ddk�r�|d7}|
jt||�7_n*|	dk�r�t||dd��d
|
_ndS|d7}|d7}�q�WWntttfk
�r�dSX|S)%NrcSsg|]}|dkr|�qS)z0123456789:,-+r)rNr�rrrr��sz#_tzparser.parse.<locals>.<listcomp>rrr
rr�rT�
0123456789r�r%ir�r�rSr$r��	cSs*g|]"}|dkr|D]}|dkr|�qqS)r$rr)rNr��yrrrr��s
�rUc
Ss*g|]"}|dkr|D]}|dkr|�qqS)	r$rU�J�Mr"rTr�r)r$rUrrr"rTr�r)rNr�rrrrr�srrr�)r�rT)r�rTr')rr'r'r')rTr�r')r'rr')r�r
r0r-rrKrrHr��ranger.rrr�r	r�r�r�rrrr
r�r�r�)rr�r�r5r�r��jZoffattrrr�r�rLrrrr�s�



" *

 

"


(
4 & 
z_tzparser.parseN)rrArBrFr�rrrrrr�srcCs
tj|�S)N)�DEFAULTTZPARSERr)r�rrr�_parsetzQsrcCsFd|krt|�dfS|jd�\}}t|�t|jdd�dd��fSdS)z9Parse a I[.F] seconds value into (seconds, microseconds).r"rr�r N)r�r0�ljust)rLr��frrrr�Usr�)N)!r�Z
__future__rr�r�r�r�rC�iorZcalendarrZsixrrrr
r	r
�__all__�objectr
rFrr<r�r�rrrrrr�rrrr�<module>s<#oX
e.PKa�\mw��� __pycache__/tzwin.cpython-36.pycnu�[���3

6�cY;�@sddlTdS)�)�*N)Ztz.win�rr�/usr/lib/python3.6/tzwin.py�<module>sPKa�\tz�t�t�&__pycache__/rrule.cpython-36.opt-1.pycnu�[���3

6�cY���@sJdZddlZddlZddlZddlZyddlmZWn ek
rTddlmZYnXddl	m
Z
mZddlm
Z
mZddlZddlmZddlmZd	d
ddd
ddddddddddddgZedgddgddgddgdd gdd!gdd"gdd#gdd$gdd%gdd&gdd'gddgd"�Zee�Zeedd��eedd��eedd(��ZZZeeeeeeeeeeeeeedd"��Zee�ZeedNd��eedOd��eedPd��ZZZeeeeeeeeeeeeeedd"��Zee�Z dQZ!dRZ"dddddd d!gd?Z#[[[ed4=ed4=e d=ee�Zee�Zdd
dddddgZ$eed"��\Z%Z&Z'Z(Z)Z*Z+da,da-Gd@dA�dAe�ZedBdC�ed"�D��\Z.Z/Z0Z1Z2Z3Z4Z5dDdE�Z6GdFdG�dGe7�Z8GdHd	�d	e8�Z9GdIdJ�dJe7�Z:GdKd
�d
e8�Z;GdLdM�dMe7�Z<e<�Z=dS)Sz�
The rrule module offers a small, complete, and very fast, implementation of
the recurrence rules documented in the
`iCalendar RFC <http://www.ietf.org/rfc/rfc2445.txt>`_,
including support for caching of results.
�N)�gcd)�advance_iterator�
integer_types)�_thread�range�)�weekday)�warn�rrule�rruleset�rrulestr�YEARLY�MONTHLY�WEEKLY�DAILY�HOURLY�MINUTELY�SECONDLY�MO�TU�WE�TH�FR�SA�SU�����������	�
��� �<�[�y��������1�O�n�;�Z�x��������0�N�m�7cs"eZdZdZd�fdd�	Z�ZS)rz7
    This version of weekday does not allow n = 0.
    Ncs&|dkrtd��tt|�j||�dS)NrzCan't create weekday with n==0)�
ValueError�superr�__init__)�selfZwkday�n)�	__class__��/usr/lib/python3.6/rrule.pyrCDszweekday.__init__)N)�__name__�
__module__�__qualname__�__doc__rC�
__classcell__rGrG)rFrHr@srccs|]}t|�VqdS)N)r)�.0�xrGrGrH�	<genexpr>KsrPcs�fdd�}|S)zT
    Decorator for rruleset methods which may invalidate the
    cached length.
    cs�|f|�|�}|j�|S)N)�_invalidate_cache)rD�args�kwargs�rv)�frGrH�
inner_funcSsz&_invalidates_cache.<locals>.inner_funcrG)rUrVrG)rUrH�_invalidates_cacheNsrWc@sneZdZddd�Zdd�Zdd�Zdd	�Zd
d�Zdd
�Zdd�Z	ddd�Z
ddd�Zddd�Zddd�Z
dS)�	rrulebaseFcCs4|rg|_tj�|_|j�nd|_d|_d|_dS)NF)�_cacher�
allocate_lock�_cache_lockrQ�_cache_complete�_len)rD�cacherGrGrHrC\s

zrrulebase.__init__cCs.|jrt|j�S|jdkr"|j�S|j�SdS)N)r\�iterrY�_iter�_iter_cached)rDrGrGrH�__iter__fs


zrrulebase.__iter__cCs>|jdk	r4g|_d|_|j�|_|jj�r4|jj�d|_dS)NF)rYr\r`�
_cache_genr[�locked�releaser])rDrGrGrHrQns



zrrulebase._invalidate_cacheccs�d}|j}|j}|jj}|jj}x�|r�|t|�kr�|�|jr@Py$xtd�D]}|jt	|��qLWWn&t
k
r�d|_}d|_PYnX|�||V|d7}q"Wx ||jkr�||V|d7}q�WdS)Nrr&Tr)rcrYr[�acquirere�lenr\r�appendr�
StopIterationr])rD�i�genr^rfre�jrGrGrHrays.


zrrulebase._iter_cachedcCs�|jr|j|St|t�rd|jr:|jdkr:tt|��|Sttj||j	pJd|j
pTtj|jp\d��Sn`|dkr�t|�}y"xt
|d�D]}t|�}q�WWntk
r�t�YnX|Stt|��|SdS)Nrr)r\rY�
isinstance�slice�step�listr_�	itertools�islice�start�stop�sys�maxsizerrri�
IndexError)rD�itemrkrj�resrGrGrH�__getitem__�s$



zrrulebase.__getitem__cCs:|jr||jkSx$|D]}||kr&dS||krdSqWdS)NTF)r\rY)rDrxrjrGrGrH�__contains__�s

zrrulebase.__contains__cCs|jdkrx|D]}qW|jS)z� Returns the number of recurrences in this set. It will have go
            trough the whole recurrence, if this hasn't been done before. N)r])rDrOrGrGrH�count�s

zrrulebase.countcCsX|jr|j}n|}d}|r8x8|D]}||kr.P|}q Wnx|D]}||krLP|}q>W|S)z� Returns the last recurrence before the given datetime instance. The
            inc keyword defines what happens if dt is an occurrence. With
            inc=True, if dt itself is an occurrence, it will be returned. N)r\rY)rD�dt�incrk�lastrjrGrGrH�before�s


zrrulebase.beforecCsP|jr|j}n|}|r2x4|D]}||kr|SqWnx|D]}||kr8|Sq8WdS)z� Returns the first recurrence after the given datetime instance. The
            inc keyword defines what happens if dt is an occurrence. With
            inc=True, if dt itself is an occurrence, it will be returned.  N)r\rY)rDr}r~rkrjrGrGrH�after�s


zrrulebase.afterNccsh|jr|j}n|}|r dd�}ndd�}d}x6|D].}|||�r2|dk	rZ|d7}||krZP|Vq2WdS)aH
        Generator which yields up to `count` recurrences after the given
        datetime instance, equivalent to `after`.

        :param dt:
            The datetime at which to start generating recurrences.

        :param count:
            The maximum number of recurrences to generate. If `None` (default),
            dates are generated until the recurrence rule is exhausted.

        :param inc:
            If `dt` is an instance of the rule and `inc` is `True`, it is
            included in the output.

        :yields: Yields a sequence of `datetime` objects.
        cSs||kS)NrG)�dc�dtcrGrGrH�<lambda>�sz"rrulebase.xafter.<locals>.<lambda>cSs||kS)NrG)r�r�rGrGrHr��srNr)r\rY)rDr}r|r~rk�comprE�drGrGrH�xafter�s


zrrulebase.xafterrc	Cs�|jr|j}n|}d}g}|r`x�|D]6}||kr4Pq$|sP||krZd}|j|�q$|j|�q$Wn@x>|D]6}||krvPqf|s�||kr�d}|j|�qf|j|�qfW|S)a Returns all the occurrences of the rrule between after and before.
        The inc keyword defines what happens if after and/or before are
        themselves occurrences. With inc=True, they will be included in the
        list, if they are found in the recurrence set. FT)r\rYrh)	rDr�r�r~r|rkZstarted�lrjrGrGrH�betweens.

zrrulebase.between)F)F)F)NF)Fr)rIrJrKrCrbrQrarzr{r|r�r�r�r�rGrGrGrHrX[s




)rXcsJeZdZdZd�fdd�	Zdd�Zd	d
�Zdd�Zd
d�Zdd�Z	�Z
S)r
a|
    That's the base of the rrule operation. It accepts all the keywords
    defined in the RFC as its constructor parameters (except byday,
    which was renamed to byweekday) and more. The constructor prototype is::

            rrule(freq)

    Where freq must be one of YEARLY, MONTHLY, WEEKLY, DAILY, HOURLY, MINUTELY,
    or SECONDLY.

    .. note::
        Per RFC section 3.3.10, recurrence instances falling on invalid dates
        and times are ignored rather than coerced:

            Recurrence rules may generate recurrence instances with an invalid
            date (e.g., February 30) or nonexistent local time (e.g., 1:30 AM
            on a day where the local time is moved forward by an hour at 1:00
            AM).  Such recurrence instances MUST be ignored and MUST NOT be
            counted as part of the recurrence set.

        This can lead to possibly surprising behavior when, for example, the
        start date occurs at the end of the month:

        >>> from dateutil.rrule import rrule, MONTHLY
        >>> from datetime import datetime
        >>> start_date = datetime(2014, 12, 31)
        >>> list(rrule(freq=MONTHLY, count=4, dtstart=start_date))
        ... # doctest: +NORMALIZE_WHITESPACE
        [datetime.datetime(2014, 12, 31, 0, 0),
         datetime.datetime(2015, 1, 31, 0, 0),
         datetime.datetime(2015, 3, 31, 0, 0),
         datetime.datetime(2015, 5, 31, 0, 0)]

    Additionally, it supports the following keyword arguments:

    :param cache:
        If given, it must be a boolean value specifying to enable or disable
        caching of results. If you will use the same rrule instance multiple
        times, enabling caching will improve the performance considerably.
    :param dtstart:
        The recurrence start. Besides being the base for the recurrence,
        missing parameters in the final recurrence instances will also be
        extracted from this date. If not given, datetime.now() will be used
        instead.
    :param interval:
        The interval between each freq iteration. For example, when using
        YEARLY, an interval of 2 means once every two years, but with HOURLY,
        it means once every two hours. The default interval is 1.
    :param wkst:
        The week start day. Must be one of the MO, TU, WE constants, or an
        integer, specifying the first day of the week. This will affect
        recurrences based on weekly periods. The default week start is got
        from calendar.firstweekday(), and may be modified by
        calendar.setfirstweekday().
    :param count:
        How many occurrences will be generated.

        .. note::
            As of version 2.5.0, the use of the ``until`` keyword together
            with the ``count`` keyword is deprecated per RFC-2445 Sec. 4.3.10.
    :param until:
        If given, this must be a datetime instance, that will specify the
        limit of the recurrence. The last recurrence in the rule is the greatest
        datetime that is less than or equal to the value specified in the
        ``until`` parameter.

        .. note::
            As of version 2.5.0, the use of the ``until`` keyword together
            with the ``count`` keyword is deprecated per RFC-2445 Sec. 4.3.10.
    :param bysetpos:
        If given, it must be either an integer, or a sequence of integers,
        positive or negative. Each given integer will specify an occurrence
        number, corresponding to the nth occurrence of the rule inside the
        frequency period. For example, a bysetpos of -1 if combined with a
        MONTHLY frequency, and a byweekday of (MO, TU, WE, TH, FR), will
        result in the last work day of every month.
    :param bymonth:
        If given, it must be either an integer, or a sequence of integers,
        meaning the months to apply the recurrence to.
    :param bymonthday:
        If given, it must be either an integer, or a sequence of integers,
        meaning the month days to apply the recurrence to.
    :param byyearday:
        If given, it must be either an integer, or a sequence of integers,
        meaning the year days to apply the recurrence to.
    :param byweekno:
        If given, it must be either an integer, or a sequence of integers,
        meaning the week numbers to apply the recurrence to. Week numbers
        have the meaning described in ISO8601, that is, the first week of
        the year is that containing at least four days of the new year.
    :param byweekday:
        If given, it must be either an integer (0 == MO), a sequence of
        integers, one of the weekday constants (MO, TU, etc), or a sequence
        of these constants. When given, these variables will define the
        weekdays where the recurrence will be applied. It's also possible to
        use an argument n for the weekday instances, which will mean the nth
        occurrence of this weekday in the period. For example, with MONTHLY,
        or with YEARLY and BYMONTH, using FR(+1) in byweekday will specify the
        first friday of the month where the recurrence happens. Notice that in
        the RFC documentation, this is specified as BYDAY, but was renamed to
        avoid the ambiguity of that keyword.
    :param byhour:
        If given, it must be either an integer, or a sequence of integers,
        meaning the hours to apply the recurrence to.
    :param byminute:
        If given, it must be either an integer, or a sequence of integers,
        meaning the minutes to apply the recurrence to.
    :param bysecond:
        If given, it must be either an integer, or a sequence of integers,
        meaning the seconds to apply the recurrence to.
    :param byeaster:
        If given, it must be either an integer, or a sequence of integers,
        positive or negative. Each integer will define an offset from the
        Easter Sunday. Passing the offset 0 to byeaster will yield the Easter
        Sunday itself. This is an extension to the RFC specification.
     NrFc
sRtt|�j|�|s(tjj�jdd�}n*t|tj�sFtjj|j��}n|jdd�}||_	|j
|_||_||_
||_i|_|r�t|tj�r�tjj|j��}||_|dk	r�|r�tdt�|dkr�tj�|_nt|t�r�||_n|j|_|dkr�d|_n�t|t��r:|dk�s(d|k�odkn�r0td��|f|_nLt|�|_x@|jD]6}|dk�sxd|k�ondkn�rLtd���qLW|j�r�|j|jd<|dk�r:|
dk�r:|	dk�r:|
dk�r:|dk�r:|tk�r|dk�r�|j}d|jd<|j}	d|jd<n8|tk�r|j}	d|jd<n|tk�r:|j�}
d|jd	<|dk�rLd|_ n<t|t��r^|f}tt!t"|���|_ d|jk�r�|j |jd<|
dk�r�d|_#n0t|
t��r�|
f}
tt!t"|
���|_#|j#|jd
<|dk	�rt$�s�ddl%m$a$t|t��r�|f|_&ntt!|��|_&|j&|jd<nd|_&|	dk�r6f|_'f|_(npt|	t��rH|	f}	t"|	�}	tt!d
d�|	D���|_'tt!dd�|	D���|_(d|jk�r�tt)j*|j'|j(��|jd<|dk�r�d|_+n0t|t��r�|f}tt!t"|���|_+|j+|jd<|
dk�rd|_,d|_-�n8t|
t��st.|
d��r |
f}
t"�|_,t"�|_-x`|
D]X}t|t��rT|j,j/|�n8|j0�sh|tk�rx|j,j/|j�n|j-j/|j|j0f��q6W|j,�s�d|_,n|j-�s�d|_-|j,dk	�r�tt!|j,��|_,dd�|j,D�}nt�}|j-dk	�rtt!|j-��|_-dd�|j-D�}nt�}d	|jk�r:tt)j*||��|jd	<|dk�rf|t1k�r^t"|j2f�|_3nd|_3nXt|t��rx|f}|t1k�r�|j4|j2|dd�|_3n
t"|�|_3tt!|j3��|_3|j3|jd<|dk�r�|t5k�r�t"|j6f�|_7nd|_7nXt|t��r�|f}|t5k�r|j4|j6|dd�|_7n
t"|�|_7tt!|j7��|_7|j7|jd<|dk�rj|t8k�rb|j9f|_:nd|_:nbt|t��r||f}t"|�|_:|t8k�r�|j4|j9|dd�|_:n
t"|�|_:tt!|j:��|_:|j:|jd<|jt1k�r�d|_;nng|_;xP|j3D]F}x>|j7D]4}x,|j:D]"}|j;j<tj=||||jd���qW�q�W�q�W|j;j>�t|j;�|_;dS)Nr)Zmicrosecondz�Using both 'count' and 'until' is inconsistent with RFC 2445 and has been deprecated in dateutil. Future versions will raise an error.inz:bysetpos must be between 1 and 366, or between -366 and -1�bysetpos�bymonth�
bymonthday�	byweekday�	byyearday)�easter�byeastercss|]}|dkr|VqdS)rNrG)rNrOrGrGrHrPsz!rrule.__init__.<locals>.<genexpr>css|]}|dkr|VqdS)rNrG)rNrOrGrGrHrPs�byweeknorEcSsg|]}t|��qSrG)r)rNrOrGrGrH�
<listcomp>Isz"rrule.__init__.<locals>.<listcomp>cSsg|]}t|��qSrG)r)rNrOrGrGrHr�Os�)rs�byxxx�base�byhourr*�byminute�bysecond)�tzinfoi����i����)?rBr
rC�datetimeZnow�replacerm�fromordinal�	toordinal�_dtstartr��_tzinfo�_freq�	_interval�_count�_original_rule�_untilr	�DeprecationWarning�calendarZfirstweekday�_wkstrr�	_bysetposrA�tupler
�month�dayrr�_bymonth�sorted�set�
_byyeardayr��dateutil�	_byeaster�_bymonthday�_bynmonthdayrq�chain�	_byweekno�
_byweekday�_bynweekday�hasattr�addrEr�hour�_byhour�_rrule__construct_bysetr�minute�	_byminuter�second�	_bysecond�_timesetrh�time�sort)rD�freq�dtstart�interval�wkstr|�untilr�r�r�r�r�r�r�r�r�r�r^�pos�wdayZorig_byweekdayZorig_bynweekdayr�r�r�)rFrGrHrC�sL
(

(





























zrrule.__init__c
Cs�g}dgd\}}}|jrD|j|jjd��|jj�dd�\}}}dt|jg}|jdkrr|jdt|j��|jr�|jdt	t
|j��d	d
��|jdk	r�|jdt|j��|jr�|j|jjd��|j
jd
�dk	�rDt|j
�}g}xJ|d
D]>}|j�r(|jdj|jt	|�d	d
�d��q�|jt	|��q�W||d
<n|j
}d}	xFd4D]>\}
}|j|�}|�rT|j|	j|
d$jd%d&�|D��d'���qTW|jd(j|��d)j|�S)5z�
        Output a string that would generate this RRULE if passed to rrulestr.
        This is mostly compatible with RFC2445, except for the
        dateutil-specific extension BYEASTER.
        NrzDTSTART:%Y%m%dT%H%M%Sr"zFREQ=rz	INTERVAL=zWKST=rrzCOUNT=zUNTIL=%Y%m%dT%H%M%Sr�z{n:+d}{wday})rEr�z
{name}={vals}�BYSETPOSr��BYMONTHr��
BYMONTHDAYr��	BYYEARDAYr��BYWEEKNOr��BYDAY�BYHOURr��BYMINUTEr��BYSECONDr��BYEASTERr��,css|]}t|�VqdS)N)�str)rN�vrGrGrHrP�sz rrule.__str__.<locals>.<genexpr>)�name�vals�;�
�r�r��r�r��r�r��r�r��r�r��r�r��r�r��r�r��r�r��r�r�)
r�r�r�r�r�r�r�r�r�r�)r�rhZstrftime�	timetuple�	FREQNAMESr�r�r�r��reprrr�r�r��get�dictrE�format�join)
rD�output�h�m�s�partsZ
original_ruleZwday_stringsr�Zpartfmtr��key�valuerGrGrH�__str__�sT
 



z
rrule.__str__cKsN|j|j|j|j|j|j|jdkr&dndd�}|j|j�|j|�t	f|�S)z�Return new rrule with same attributes except for those attributes given new
           values by whichever keyword arguments are specified.NFT)r�r|r�r�r�r�r^)
r�r�r�r�r�r�rY�updater�r
)rDrSZ
new_kwargsrGrGrHr��s
z
rrule.replacec5cs�|jj�\	}}}}}}}}}	|j}
|j}|j}|j}
|j}|j}|j}|j	}|j
}|j}|j}|j
}|j}|j}|j}t|�}|j||�t|jt|jt|jt|jt|jt|jt|ji|
}|
tkr�|j}n�t|jt|j t|j!i|
}|
tko�|jo�||jk�s<|
tk�r|j�r||jk�s<|
tk�rB|j�rB||jk�rBf}n||||�}d}|j"}�xX||||�\}} }!d}"�x$|| |!�D�]}#|�r�|j#|#|k�s�|�r�|j$|#�s�|�r�|j%|#|k�s�|j&�r�|j&|#�s�|�r�|j'|#�s�|�s�|�r|j(|#|k�r|j)|#|k�s�|�r�|#|j*k�rP|#d|k�rP|j*|#|k�s�|#|j*k�r�|#d|j*|k�r�|j+|#|j*|k�r�d||#<d}"�q�W|�r�|�r�g}$x�|D]�}%|%dk�r�t,|%t-|��\}&}'nt,|%dt-|��\}&}'y&dd�|| |!�D�|&}#||'}(Wnt.k
�r$Yn6Xt/j0j1|j2|#�})t/j/j3|)|(�}*|*|$k�r�|$j4|*��q�W|$j5�xh|$D]`}*|
�r�|*|
k�r�||_6dS|*|jk�rn|dk	�r�|d8}|dk�r�||_6dS|d7}|*V�qnWn�x�|| |!�D]�}#|#dk	�r�t/j0j1|j2|#�})xv|D]n}(t/j/j3|)|(�}*|
�r4|*|
k�r4||_6dS|*|jk�r|dk	�rf|d8}|dk�rf||_6dS|d7}|*V�qW�q�Wd}+|
tk�r�||7}|t/j7k�r�||_6dS|j||��n^|
tk�r.||7}|dk�rt,|d�\},}-|-}||,7}|dk�rd}|d8}|t/j7k�r||_6dS|j||��n�|
tk�r�||k�rd||dd||jd	7}n||||jd	7}|}d}+�n�|
tk�r�||7}d}+�nx|
tk�r|"�r�|d
|||7}|�r�|j8||jdd�\}.}nt,||d�\}.}|.�r||.7}d}+||||�}�n|
tk�r�|"�rD|d
|d|||7}d}/d}0x�t9|0t:||0��D]v}1|�r�|j8||jdd�\}2}nt,||d�\}2}t,||2d�\},}|,�r�||,7}d}+d}"|�s�||k�r`d}/P�q`W|/�s�t;d��||||�}�n"|
tk�r|"�r,|d|d|d|||7}d}0d}/x�t9d|0t:||0��D]�}1|�rl|j8||jdd�\}3}nt,||d�\}3}t,||3d�\},}|,�r�||,7}t,|d�\},}|,�r�||,7}d}+|�s�||k�rJ|�s�||k�rJ|�s�||k�rJd}/P�qJW|/�st;d��||||�}|+�r\|dk�r\t<j=||�d}4||4k�r\x\||4k�r�||48}|d7}|dk�r�d}|d7}|t/j7k�r�||_6dSt<j=||�d}4�qFW|j||��q\WdS)NrFrTcSsg|]}|dk	r|�qS)NrG)rNrOrGrGrHr�@szrrule._iter.<locals>.<listcomp>r(r"r#�r�)r�r�r�i�r*z$Invalid combination of interval and zbyhour resulting in empty rule.iQiz!Invalid combination of interval, z&byhour and byminute resulting in emptyz rule.��
i�zCInvalid combination of interval and byhour resulting in empty rule.i�QzGInvalid combination of interval, byhour and byminute resulting in emptyzMInvalid combination of interval, byhour and byminute resulting in empty rule.)>r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r��	_iterinfo�rebuildr
�ydaysetr�mdaysetr�wdaysetr�ddaysetrrrr��htimeset�mtimeset�stimesetr��mmask�wnomask�wdaymask�	nwdaymask�
eastermask�mdaymask�	nmdaymask�yearlen�nextyearlen�divmodrgrwr��dater��yearordinalZcombinerhr�r]ZMAXYEAR�_rrule__mod_distancerrrAr�Z
monthrange)5rD�yearr�r�r�r�r�rZyearday�_r�r�r�r�r�r�r�r�r�r�Zbynmonthdayr�r�r�r��iiZ	getdaysetZtimesetZ
gettimeset�totalr|Zdaysetrs�endZfilteredrjZposlistr�ZdayposZtimeposr�rryZfixday�div�modZndaysZvalidZrep_raterlZnhoursZnminutesZdaysinmonthrGrGrHr`�s�

 
















"





zrrule._itercCspt�}t|t�r|f}x@|D]8}t|j|�}|dksJt|||�ddkr|j|�qWt|�dkrltd��|S)a
        If a `BYXXX` sequence is passed to the constructor at the same level as
        `FREQ` (e.g. `FREQ=HOURLY,BYHOUR={2,4,7},INTERVAL=3`), there are some
        specifications which cannot be reached given some starting conditions.

        This occurs whenever the interval is not coprime with the base of a
        given unit and the difference between the starting position and the
        ending position is not coprime with the greatest common denominator
        between the interval and the base. For example, with a FREQ of hourly
        starting at 17:00 and an interval of 4, the only valid values for
        BYHOUR would be {21, 1, 5, 9, 13, 17}, because 4 and 24 are not
        coprime.

        :param start:
            Specifies the starting position.
        :param byxxx:
            An iterable containing the list of allowed values.
        :param base:
            The largest allowable value for the specified frequency (e.g.
            24 hours, 60 minutes).

        This does not preserve the type of the iterable, returning a set, since
        the values should be unique and the order is irrelevant, this will
        speed up later lookups.

        In the event of an empty set, raises a :exception:`ValueError`, as this
        results in an empty rrule.
        rrz+Invalid rrule byxxx generates an empty set.)	r�rmrrr�rr�rgrA)rDrsr�r�ZcsetZnumZi_gcdrGrGrHZ__construct_byset�s

zrrule.__construct_bysetcCsLd}xBtd|d�D]0}t||j|�\}}||7}||kr||fSqWdS)a�
        Calculates the next value in a sequence where the `FREQ` parameter is
        specified along with a `BYXXX` parameter at the same "level"
        (e.g. `HOURLY` specified with `BYHOUR`).

        :param value:
            The old value of the component.
        :param byxxx:
            The `BYXXX` set, which should have been generated by
            `rrule._construct_byset`, or something else which checks that a
            valid rule is present.
        :param base:
            The largest allowable value for the specified frequency (e.g.
            24 hours, 60 minutes).

        If a valid value is not found after `base` iterations (the maximum
        number before the sequence would start to repeat), this raises a
        :exception:`ValueError`, as no valid values were found.

        This returns a tuple of `divmod(n*interval, base)`, where `n` is the
        smallest number of `interval` repetitions until the next specified
        value in `byxxx` is found.
        rrN)rrr�)rDr�r�r�ZaccumulatorrrrGrGrHZ__mod_distanceszrrule.__mod_distance)NrNNNNNNNNNNNNNF)rIrJrKrLrCr�r�r`r�rrMrGrG)rFrHr
.st{>/c@sveZdZddddddddd	d
ddd
ddgZdd�Zdd�Zdd�Zdd�Zdd�Zdd�Z	dd�Z
dd�Zd d!�Zd"S)#r�r
�lastyear�	lastmonthr	r
r
�yearweekdayr�mrangerrrrrrcCs&x|jD]}t||d�qW||_dS)N)�	__slots__�setattrr
)rDr
�attrrGrGrHrCDsz_iterinfo.__init__cCs�|j}||jk�r2dtj|�|_dtj|d�|_tj|dd�}|j�|_	|j
�|_tj|dd�j
�}|jdkr�t|_
t|_t|_t|d�|_t|_n&t|_
t|_t|_t|d�|_t|_|js�d|_�n`dg|jd|_d|j|jd}}|dk�r"d}|j|j|jd}n
|j|}t|d�\}	}
|	|
d}x�|jD]�}|dk�rh||d7}d|k�o||kn�s��qN|dk�r�||dd}
||k�r�|
d|8}
n|}
x8td�D],}d|j|
<|
d7}
|j|
|jk�r�P�q�W�qNWd|jk�rr||d}
||k�r,|
d|8}
|
|jk�rrx8td�D],}d|j|
<|
d7}
|j|
|jk�rBP�qBW|�r2d|jk�rtj|ddd�j
�}d||jd}dtj|d�}|dk�r�d}d|||jddd}nd|j|dd}nd}||jk�r2xt|�D]}
d|j|
<�qW|j�r�||j k�sR||jk�r�g}|j!t"k�r�|j#�r�x:|j#D]"}|j$|j|d|d���qrWnd|jfg}n$|j!t%k�r�|j|d|d�g}|�r�dg|j|_&x�|D]�\}}|d8}x�|jD]�\}}|dk�r8||dd}
|
|j|
|d8}
n*||dd}
|
d|j|
|d7}
||
k�ov|kn�r�d|j&|
<�q�W�q�W|j'�r�dg|jd|_(t)j)|�j�|j	}x|j'D]}d|j(||<�q�W||_||_ dS)	Nimrrr#r�4���r)*r
rr�Zisleapr	r
r�rr�r
rr�M365MASKr�MDAY365MASKr�NMDAY365MASKr�WDAYMASKr�	M365RANGEr�M366MASK�MDAY366MASK�NMDAY366MASK�	M366RANGEr�rr�rrr�rr�r
r�rhrrr�rr�)rDrr��rrZ	firstydayr�Zno1wkstZ	firstwkstZwyearlenrrZnumweeksrErjrlZlyearweekdayZlno1wkstZlyearlenZ	lnumweeksZranges�firstrZeyday�offsetrGrGrHr�Is�












$
z_iterinfo.rebuildcCstt|j��d|jfS)Nr)rprr	)rDrr�r�rGrGrHr��sz_iterinfo.ydaysetcCsLdg|j}|j|d|d�\}}xt||�D]}|||<q2W|||fS)Nr)r	rr)rDrr�r��dsetrsrrjrGrGrHr��s
z_iterinfo.mdaysetcCsldg|jd}tj|||�j�|j}|}x4td�D](}|||<|d7}|j||jjkr6Pq6W|||fS)Nr#r)	r	r�rr�r
rrr
r�)rDrr�r�r+rjrsrlrGrGrHr��sz_iterinfo.wdaysetcCs:dg|j}tj|||�j�|j}|||<|||dfS)Nr)r	r�rr�r
)rDrr�r�r+rjrGrGrHr��sz_iterinfo.ddaysetc	CsPg}|j}x8|jD].}x(|jD]}|jtj||||jd��qWqW|j�|S)N)r�)r
r�r�rhr�r�r�r�)rDr�r�r��tsetr(rGrGrHr��sz_iterinfo.htimesetcCs@g}|j}x(|jD]}|jtj||||jd��qW|j�|S)N)r�)r
r�rhr�r�r�r�)rDr�r�r�r,r(rGrGrHr�sz_iterinfo.mtimesetcCstj||||jjd�fS)N)r�)r�r�r
r�)rDr�r�r�rGrGrHr�s
z_iterinfo.stimesetN)
rIrJrKrrCr�r�r�r�r�r�rrrGrGrGrHr�>s
r�csjeZdZdZGdd�de�Zd�fdd�	Zedd��Zed	d
��Z	edd��Z
ed
d��Zdd�Z�Z
S)raL The rruleset type allows more complex recurrence setups, mixing
    multiple rules, dates, exclusion rules, and exclusion dates. The type
    constructor takes the following keyword arguments:

    :param cache: If True, caching of results will be enabled, improving
                  performance of multiple queries considerably. c@s@eZdZdd�Zdd�ZeZdd�Zdd�Zd	d
�Zdd�Z	d
S)zrruleset._genitemcCs>yt|�|_|j|�Wntk
r,YnX||_||_dS)N)rr}rhri�genlistrk)rDr-rkrGrGrHrC
s
zrruleset._genitem.__init__cCs^yt|j�|_WnHtk
rX|jd|kr<tj|j�n|jj|�tj|j�YnXdS)Nr)	rrkr}rir-�heapq�heappop�remove�heapify)rDrGrGrH�__next__szrruleset._genitem.__next__cCs|j|jkS)N)r})rD�otherrGrGrH�__lt__szrruleset._genitem.__lt__cCs|j|jkS)N)r})rDr3rGrGrH�__gt__"szrruleset._genitem.__gt__cCs|j|jkS)N)r})rDr3rGrGrH�__eq__%szrruleset._genitem.__eq__cCs|j|jkS)N)r})rDr3rGrGrH�__ne__(szrruleset._genitem.__ne__N)
rIrJrKrCr2�nextr4r5r6r7rGrGrGrH�_genitem	s	
r9Fcs,tt|�j|�g|_g|_g|_g|_dS)N)rBrrC�_rrule�_rdate�_exrule�_exdate)rDr^)rFrGrHrC+s
zrruleset.__init__cCs|jj|�dS)z\ Include the given :py:class:`rrule` instance in the recurrence set
            generation. N)r:rh)rDr
rGrGrHr
2szrruleset.rrulecCs|jj|�dS)z_ Include the given :py:class:`datetime` instance in the recurrence
            set generation. N)r;rh)rD�rdaterGrGrHr>8szrruleset.rdatecCs|jj|�dS)z� Include the given rrule instance in the recurrence set exclusion
            list. Dates which are part of the given recurrence rules will not
            be generated, even if some inclusive rrule or rdate matches them.
        N)r<rh)rD�exrulerGrGrHr?>szrruleset.exrulecCs|jj|�dS)z� Include the given datetime instance in the recurrence set
            exclusion list. Dates included that way will not be generated,
            even if some inclusive rrule or rdate matches them. N)r=rh)rD�exdaterGrGrHr@Fszrruleset.exdateccslg}|jj�|j|t|j��x$dd�|jD�D]}|j||�q2Wg}|jj�|j|t|j��x$dd�|jD�D]}|j||�qxWd}d}tj|�tj|�x�|�r`|d}|s�||j	k�r:xB|o�|d|k�r|d}t
|�|o�|d|kr�tj||�q�W|�s$||dk�r4|d7}|j	V|j	}t
|�|r�|d|kr�tj||�q�W||_dS)NcSsg|]}t|��qSrG)r_)rNrOrGrGrHr�Qsz"rruleset._iter.<locals>.<listcomp>cSsg|]}t|��qSrG)r_)rNrOrGrGrHr�Vsrr)
r;r�r9r_r:r=r<r.r1r}r�heapreplacer])rDZrlistrkZexlistZlastdtrZritemZexitemrGrGrHr`Ms<



zrruleset._iter)F)rIrJrKrL�objectr9rCrWr
r>r?r@r`rMrGrG)rFrHrs"c@s�eZdZeeeeeee	d�Z
dddddddd	�Zd
d�Zdd
�Z
eZeZe
Ze
Ze
Ze
Ze
Ze
Ze
Ze
Ze
Zdd�Zdd�Zdd�Zdd�ZeZddd�Zddd�Zdd�Z dS) �	_rrulestr)r
rrrrrrrrrrrr!r")rrrrrrrcKst|�||j�<dS)N)�int�lower)rD�rrkwargsr�r�rSrGrGrH�_handle_int{sz_rrulestr._handle_intcKs dd�|jd�D�||j�<dS)NcSsg|]}t|��qSrG)rD)rNrOrGrGrHr�sz._rrulestr._handle_int_list.<locals>.<listcomp>r�)�splitrE)rDrFr�r�rSrGrGrH�_handle_int_list~sz_rrulestr._handle_int_listcKs|j||d<dS)Nr�)�	_freq_map)rDrFr�r�rSrGrGrH�_handle_FREQ�sz_rrulestr._handle_FREQcKsVtsddlmay$tj||jd�|jd�d�|d<Wntk
rPtd��YnXdS)Nr)�parser�ignoretz�tzinfos)rMrNr�zinvalid until date)rLr��parser�rA)rDrFr�r�rSrGrGrH�
_handle_UNTIL�sz_rrulestr._handle_UNTILcKs|j||d<dS)Nr�)�_weekday_map)rDrFr�r�rSrGrGrH�_handle_WKST�sz_rrulestr._handle_WKSTcKs�g}x�|jd�D]�}d|krD|jd�}|d}t|ddd	��}	n^t|�r�x"tt|��D]}
||
dkrZPqZW|d|
�p~d}	||
d�}|	r�t|	�}	ntd��|jt|j||	��qW||d<dS)
z:
        Two ways to specify this: +1MO or MO(+1)
        r��(rrNz+-0123456789z$Invalid (empty) BYDAY specification.r�r)rHrDrgrrArh�weekdaysrQ)rDrFr�r�rSr�r�Zsplt�wrErjrGrGrH�_handle_BYWEEKDAY�s"

z_rrulestr._handle_BYWEEKDAYNFc
Cs�|jd�dkr.|jd�\}}|dkr2td��n|}i}x�|jd�D]�}	|	jd�\}}|j�}|j�}y t|d|�|||||d�WqBtk
r�td	|��YqBttfk
r�td
||f��YqBXqBWtf||d�|��S)
N�:r�RRULEzunknown parameter namer��=Z_handle_)rMrNzunknown parameter '%s'zinvalid '%s': %s)r�r^r)�findrHrA�upper�getattr�AttributeError�KeyErrorr
)
rD�liner�r^rMrNr�r�rFZpairrGrGrH�_parse_rfc_rrule�s&
z_rrulestr._parse_rfc_rrulec	Cs�|rd}d}|j�}|j�s$td��|r�|j�}	d}
xr|
t|	�kr�|	|
j�}|sZ|	|
=q6|
dkr�|ddkr�|	|
d|dd�7<|	|
=q6|
d7}
q6Wn|j�}	|r�t|	�dkr�|jd�dks�|jd�r�|j	|	d||||d�Sg}g}
g}g}�x�|	D�]�}|�s�q|jd�dk�r,d	}|}n|jdd�\}}|jd
�}|�sTtd��|d}|dd�}|d	k�r�x|D]}td|���qxW|j
|��q|d
k�r�x$|D]}|dk�r�td|���q�W|
j
|�n�|dk�r
x|D]}td|���q�W|j
|�n�|dk�rFx$|D]}|dk�rtd|���qW|j
|�nV|dk�r�x|D]}td|���qVWt�s~ddlmatj
|||d�}ntd|���qW|�s�t|�dk�s�|
�s�|�s�|�r�t�r�|
�s�|�r�ddlmat|d�}x&|D]}|j|j	||||d���q�Wx:|
D]2}x*|jd�D]}|jtj
|||d���q0W�q Wx&|D]}|j|j	||||d���q\Wx:|D]2}x*|jd�D]}|jtj
|||d���q�W�q�W|�r�|�r�|j|�|S|j	|d||||d�SdS)NTzempty stringr� rrWzRRULE:)r^r�rMrNrXr�zempty property namezunsupported RRULE parm: ZRDATEzVALUE=DATE-TIMEzunsupported RDATE parm: ZEXRULEzunsupported EXRULE parm: ZEXDATEzunsupported EXDATE parm: ZDTSTARTzunsupported DTSTART parm: )rL)rMrNzunsupported property: )r^)r�rMrNr�)r�r^rMrNrr)r[�striprA�
splitlinesrg�rstriprHrZ�
startswithr`rhrLr�rOrr
r>r?r@)rDr�r�r^ZunfoldZforcesetZ
compatiblerMrN�linesrjr_Z	rrulevalsZ	rdatevalsZ
exrulevalsZ
exdatevalsr�r�ZparmsZparmZrsetZdatestrrGrGrH�
_parse_rfc�s�	 























z_rrulestr._parse_rfccKs|j|f|�S)N)rg)rDr�rSrGrGrH�__call__Dsz_rrulestr.__call__)NFFN)NFFFFFN)!rIrJrKr
rrrrrrrJrQrGrIZ_handle_INTERVALZ
_handle_COUNTZ_handle_BYSETPOSZ_handle_BYMONTHZ_handle_BYMONTHDAYZ_handle_BYYEARDAYZ_handle_BYEASTERZ_handle_BYWEEKNOZ_handle_BYHOURZ_handle_BYMINUTEZ_handle_BYSECONDrKrPrRrVZ
_handle_BYDAYr`rgrhrGrGrGrHrCnsN

irCi��i��i��)
rrr*r+r,r-r.r/r0r1r2r3r4)
rrr5r6r7r8r9r:r;r<r=r>r?)>rLrqr�r�ruZmathr�ImportErrorZ	fractionsZsixrrZ	six.movesrrr.Z_commonrZweekdaybase�warningsr	�__all__r�r$rprZM29ZM30ZM31r%r r&r!r'r#r"r�r
rrrrrrr�rLrrrrrrrrTrWrBrXr
r�rrCrrGrGrGrH�<module>sl�.@.@(
TDm[PKa�\�[/'__pycache__/easter.cpython-36.opt-1.pycnu�[���3

6�cYE
�@s4dZddlZddddgZdZdZd	Zefd
d�ZdS)zx
This module offers a generic easter computing method for any given year, using
Western, Orthodox or Julian algorithms.
�N�easter�
EASTER_JULIAN�EASTER_ORTHODOX�EASTER_WESTERN���cCsld|kodkns td��|}|d}d}|dkr�d|dd}||d|d	}|d
kr�d}|dkr�||d
d|d
dd}n�|d
}||dd|ddd|dd}||dd|dd|dd|d}||d|d
||dd	}|||}	d|	d|	ddd}
d|	dd}tjt|�t|�t|
��S)a�
    This method was ported from the work done by GM Arts,
    on top of the algorithm by Claus Tondering, which was
    based in part on the algorithm of Ouding (1940), as
    quoted in "Explanatory Supplement to the Astronomical
    Almanac", P.  Kenneth Seidelmann, editor.

    This algorithm implements three different easter
    calculation methods:

    1 - Original calculation in Julian calendar, valid in
        dates after 326 AD
    2 - Original method, with date converted to Gregorian
        calendar, valid in years 1583 to 4099
    3 - Revised method, in Gregorian calendar, valid in
        years 1583 to 4099 as well

    These methods are represented by the constants:

    * ``EASTER_JULIAN   = 1``
    * ``EASTER_ORTHODOX = 2``
    * ``EASTER_WESTERN  = 3``

    The default method is method 3.

    More about the algorithm may be found at:

    http://users.chariot.net.au/~gmarts/eastalg.htm

    and

    http://www.tondering.dk/claus/calendar.html

    rrzinvalid method�r����r�
i@�d���
��������(��)�
ValueError�datetimeZdate�int)Zyear�method�y�g�e�i�j�c�h�p�d�m�r+�/usr/lib/python3.6/easter.pyrs($",0$)�__doc__r�__all__rrrrr+r+r+r,�<module>sPKa�\W�eFF)__pycache__/_version.cpython-36.opt-1.pycnu�[���3

6�cY��@s.dZdZdZdZeeefZdjeee��ZdS)z2
Contains information about the dateutil version.
����.N)	�__doc__Z
VERSION_MAJORZ
VERSION_MINORZ
VERSION_PATCHZ
VERSION_TUPLE�join�map�str�VERSION�r
r
�/usr/lib/python3.6/_version.py�<module>s

PKa�\�}��|�|�!__pycache__/parser.cpython-36.pycnu�[���3

6�cY���@sdZddlmZddlZddlZddlZddlZddlZddlm	Z	ddl
mZddlm
Z
mZmZddlmZdd	lmZd
dgZGdd
�d
e�ZGdd�de�ZGdd�de�ZGdd�de�ZGdd�de�Ze�Zddd
�ZGdd�de�Ze�Zdd�Zdd�Z dS)a�
This module offers a generic date/time string parser which is able to parse
most known formats to represent a date and/or time.

This module attempts to be forgiving with regards to unlikely input formats,
returning a datetime object even for dates which are ambiguous. If an element
of a date/time stamp is omitted, the following rules are applied:
- If AM or PM is left unspecified, a 24-hour clock is assumed, however, an hour
  on a 12-hour clock (``0 <= hour <= 12``) *must* be specified if AM or PM is
  specified.
- If a time zone is omitted, a timezone-naive datetime is returned.

If any other elements are missing, they are taken from the
:class:`datetime.datetime` object passed to the parameter ``default``. If this
results in a day number exceeding the valid number of days per month, the
value falls back to the end of the month.

Additional resources about date/time string formats can be found below:

- `A summary of the international standard date and time notation
  <http://www.cl.cam.ac.uk/~mgk25/iso-time.html>`_
- `W3C Date and Time Formats <http://www.w3.org/TR/NOTE-datetime>`_
- `Time Formats (Planetary Rings Node) <http://pds-rings.seti.org/tools/time_formats.html>`_
- `CPAN ParseDate module
  <http://search.cpan.org/~muir/Time-modules-2013.0912/lib/Time/ParseDate.pm>`_
- `Java SimpleDateFormat Class
  <https://docs.oracle.com/javase/6/docs/api/java/text/SimpleDateFormat.html>`_
�)�unicode_literalsN)�StringIO)�
monthrange)�	text_type�binary_type�
integer_types�)�
relativedelta)�tz�parse�
parserinfoc@sneZdZejd�Zdd�Zdd�Zdd�Zdd	�Z	d
d�Z
edd
��Zedd��Z
edd��Zedd��ZdS)�_timelexz([.,])cCsdt|t�r|j�}t|t�r$t|�}t|dd�dkrHtdj|jj	d���||_
g|_g|_d|_
dS)N�readz8Parser must be a string or character stream, not {itype})ZitypeF)�
isinstancer�decoderr�getattr�	TypeError�format�	__class__�__name__�instream�	charstack�
tokenstack�eof)�selfr�r�/usr/lib/python3.6/parser.py�__init__4s

z_timelex.__init__cCs�|jr|jjd�Sd}d}d}�x�|j�s|jr>|jjd�}n&|jjd�}x|dkrb|jjd�}qLW|srd|_Pq"|s�|}|j|�r�d}n$|j|�r�d}n|j|�r�d	}PnPq"|dk�r�d}|j|�r�||7}n$|d
kr�||7}d}n|jj	|�Pq"|dk�rX|j|��r||7}n>|d
k�s:|dk�rHt
|�d
k�rH||7}d}n|jj	|�Pq"|dk�r�d}|d
k�s||j|��r�||7}n6|j|��r�|dd
k�r�||7}d}n|jj	|�Pq"|dkr"|d
k�s�|j|��r�||7}q"|j|��r|dd
k�r||7}d}q"|jj	|�Pq"W|dk�r�|�sN|jd
�dk�sN|ddk�r�|jj
|�}|d}x(|dd�D]}|�rp|jj	|��qpW|dk�r�|jd
�dk�r�|jdd
�}|S)a�
        This function breaks the time string into lexical units (tokens), which
        can be parsed by the parser. Lexical units are demarcated by changes in
        the character set, so any continuous string of letters is considered
        one unit, any continuous string of numbers is considered one unit.

        The main complication arises from the fact that dots ('.') can be used
        both as separators (e.g. "Sep.20.2009") or decimal points (e.g.
        "4:30:21.447"). As such, it is necessary to read the full context of
        any dot-separated strings before breaking it into tokens; as such, this
        function maintains a "token stack", for when the ambiguous context
        demands that multiple tokens be parsed at once.
        rFNr�T�a�0� �.�a.�,��0.z.,���r')r#r&r')r�poprrrr�isword�isnum�isspace�append�len�count�_split_decimal�split�replace)rZseenletters�token�state�nextchar�l�tokrrr�	get_tokenDs�








"


 z_timelex.get_tokencCs|S)Nr)rrrr�__iter__�sz_timelex.__iter__cCs|j�}|dkrt�|S)N)r7�
StopIteration)rr2rrr�__next__�sz_timelex.__next__cCs|j�S)N)r:)rrrr�next�sz
_timelex.nextcCst||��S)N)�list)�cls�srrrr0�sz_timelex.splitcCs|j�S)z5 Whether or not the next character is part of a word )�isalpha)r=r4rrrr)�sz_timelex.iswordcCs|j�S)z0 Whether the next character is part of a number )�isdigit)r=r4rrrr*�sz_timelex.isnumcCs|j�S)z* Whether the next character is whitespace )r+)r=r4rrrr+�sz_timelex.isspaceN)r�
__module__�__qualname__�re�compiler/rr7r8r:r;�classmethodr0r)r*r+rrrrr
0s
mr
c@s,eZdZdd�Zdd�Zdd�Zdd�Zd	S)
�_resultbasecCs x|jD]}t||d�qWdS)N)�	__slots__�setattr)r�attrrrrr�sz_resultbase.__init__cCsNg}x6|jD],}t||�}|dk	r|jd|t|�f�qWd|dj|�fS)Nz%s=%sz%s(%s)z, )rGrr,�repr�join)rZ	classnamer5rI�valuerrr�_repr�s
z_resultbase._reprcst�fdd��jD��S)Nc3s|]}t�|�dk	VqdS)N)r)�.0rI)rrr�	<genexpr>�sz&_resultbase.__len__.<locals>.<genexpr>)�sumrG)rr)rr�__len__�sz_resultbase.__len__cCs|j|jj�S)N)rMrr)rrrr�__repr__�sz_resultbase.__repr__N)rrArBrrMrQrRrrrrrF�srFc@s�eZdZdZdddddddd	d
ddd
ddddddgZdcdddedfdgdhdigZdjdkdldmdndodpdqdrdsdtdugZdvdwdxgZdydzgZdFdGdHgZ	dgZ
iZd{dJdK�ZdLdM�Z
dNdO�ZdPdQ�ZdRdS�ZdTdU�ZdVdW�ZdXdY�ZdZd[�Zd\d]�Zd|d^d_�Zd`da�ZdbS)}ra�
    Class which handles what inputs are accepted. Subclass this to customize
    the language and acceptable values for each parameter.

    :param dayfirst:
            Whether to interpret the first value in an ambiguous 3-integer date
            (e.g. 01/05/09) as the day (``True``) or month (``False``). If
            ``yearfirst`` is set to ``True``, this distinguishes between YDM
            and YMD. Default is ``False``.

    :param yearfirst:
            Whether to interpret the first value in an ambiguous 3-integer date
            (e.g. 01/05/09) as the year. If ``True``, the first number is taken
            to be the year, otherwise the last number is taken to be the year.
            Default is ``False``.
    r!r"r$�;�-�/�'ZatZon�andZad�m�tZof�stZndZrdZth�Mon�Monday�Tue�Tuesday�Wed�	Wednesday�Thu�Thursday�Fri�Friday�Sat�Saturday�Sun�Sunday�Jan�January�Feb�February�Mar�March�Apr�April�May�Jun�June�Jul�July�Aug�August�Sep�Sept�	September�Oct�October�Nov�November�Dec�December�h�hour�hours�minute�minutesr>�second�seconds�amr�pm�p�UTCZGMT�ZFcCs�|j|j�|_|j|j�|_|j|j�|_|j|j�|_|j|j	�|_
|j|j�|_|j|j
�|_||_||_tj�j|_|jdd|_dS)N�d)�_convert�JUMP�_jump�WEEKDAYS�	_weekdays�MONTHS�_months�HMS�_hms�AMPM�_ampm�UTCZONE�_utczone�PERTAIN�_pertain�dayfirst�	yearfirst�timeZ	localtimeZtm_year�_year�_century)rr�r�rrrrszparserinfo.__init__cCsPi}xFt|�D]:\}}t|t�r<x&|D]}|||j�<q&Wq|||j�<qW|S)N)�	enumerater�tuple�lower)rZlstZdct�i�vrrrr�*s

zparserinfo._convertcCs|j�|jkS)N)r�r�)r�namerrr�jump4szparserinfo.jumpcCsHt|�tdd�|jj�D��krDy|j|j�Stk
rBYnXdS)Ncss|]}t|�VqdS)N)r-)rN�nrrrrO8sz%parserinfo.weekday.<locals>.<genexpr>)r-�minr��keysr��KeyError)rr�rrr�weekday7s zparserinfo.weekdaycCsLt|�tdd�|jj�D��krHy|j|j�dStk
rFYnXdS)Ncss|]}t|�VqdS)N)r-)rNr�rrrrO@sz#parserinfo.month.<locals>.<genexpr>r)r-r�r�r�r�r�)rr�rrr�month?s zparserinfo.monthcCs(y|j|j�Stk
r"dSXdS)N)r�r�r�)rr�rrr�hmsGszparserinfo.hmscCs(y|j|j�Stk
r"dSXdS)N)r�r�r�)rr�rrr�ampmMszparserinfo.ampmcCs|j�|jkS)N)r�r�)rr�rrr�pertainSszparserinfo.pertaincCs|j�|jkS)N)r�r�)rr�rrr�utczoneVszparserinfo.utczonecCs||jkrdS|jj|�S)Nr)r��TZOFFSET�get)rr�rrr�tzoffsetYs
zparserinfo.tzoffsetcCsJ|dkrF|rF||j7}t||j�dkrF||jkr>|d7}n|d8}|S)Nr��2)r��absr�)r�year�century_specifiedrrr�convertyear_s


zparserinfo.convertyearcCsl|jdk	r|j|j|j�|_|jdkr.|js8|jdkrFd|_d|_n"|jdkrh|jrh|j|j�rhd|_dS)Nrr�r�T)r�r�r�r��tznamer�)r�resrrr�validateis
zparserinfo.validateN)r[r\)r]r^)r_r`)rarb)rcrd)rerf)rgrh)rirj)rkrl)rmrn)rorp)rqrq)rrrs)rtru)rvrw)rxryrz)r{r|)r}r~)rr�)r�r�r�)rXr�r�)r>r�r�)r�r)r�r�)FF)F)rrArB�__doc__r�r�r�r�r�r�r�r�rr�r�r�r�r�r�r�r�r�r�r�rrrrr�sV




csPeZdZ�fdd�Zedd��Zedd��Zdd�Z�fd	d
�Zdd�Z	�Z
S)
�_ymdcs$t|j|�j||�d|_||_dS)NF)�superrrr��tzstr)rr��args�kwargs)rrrrwsz
_ymd.__init__cCs&yt|�|kStk
r dSXdS)NF)�int�
ValueError)r2r�rrr�token_could_be_year|sz_ymd.token_could_be_yearcs�fdd�|D�S)Ncsg|]}tj|��r|�qSr)r�r�)rNr2)r�rr�
<listcomp>�sz3_ymd.find_potential_year_tokens.<locals>.<listcomp>r)r��tokensr)r�r�find_potential_year_tokens�sz_ymd.find_potential_year_tokenscCsFx@t|�D]4\}}tj||�}t|�dkr
t|d�dkr
|Sq
WdS)zk
        attempt to deduce if a pre 100 year was lost
         due to padded zeros being taken off
        rrr%N)r�r�r�r-)rr��indexr2Zpotential_year_tokensrrr�find_probable_year_index�sz_ymd.find_probable_year_indexcsNt|d�r&|j�r4t|�dkr4d|_n|dkr4d|_t|j|�jt|��dS)NrQr%Tr�)�hasattrr@r-r�r�rr,r�)r�val)rrrr,�s
z_ymd.appendcCs,t|�}d\}}}|dkr&td���n�|dks>|d	kr�|dkr�|d
krT||}||=|dksd|dkr�|ddkrz|d}n|d}�n�|dkr�|ddkr�|\}}n8|ddkr�|\}}n"|r�|ddkr�|\}}n|\}}�nB|dk�r"|dk�r|\}}}�n |dk�rF|ddk�s.|�r:|ddk�r:|\}}}n
|\}}}n�|dk�rv|ddk�rj|\}}}n
|\}}}n�|ddk�s�|jtj|j��dk�s�|�r�|ddk�r�|ddk�r�|�r�|ddk�r�|\}}}n
|\}}}n8|ddk�s|�r|ddk�r|\}}}n
|\}}}|||fS)N�zMore than three YMD valuesrr%r��)NNNr'r'r')r-r�r�r
r0r�)r�mstridxr�r�Zlen_ymdr�r��dayrrr�resolve_ymd�sR







"
""
z_ymd.resolve_ymd)rrArBr�staticmethodr�r�r�r,r��
__classcell__rr)rrr�vs
	r�c@sFeZdZd
dd�Zddd�ZGdd�de�Zdd	d
�Zedd��Z	dS)�parserNcCs|pt�|_dS)N)r�info)rr�rrrr�szparser.__init__FcKsV|dkr tjj�jddddd�}|j|f|�\}}|dkrBtd��t|�dkrVtd��i}x&dD]}	t||	�}
|
dk	r`|
||	<q`Wd|kr�|jdkr�|jn|j}|jdkr�|jn|j}|j	dkr�|j	n|j	}
|
t
||�d
kr�t
||�d
|d<|jf|�}|jdk	�r$|j	�r$|tj|jd�}|�s8t
|tj��sJ|�r�|j|k�r�t
|tj��rh||j|j�}n|j|j�}t
|tj��r�|}n<t
|t��r�tj|�}n$t
|t��r�tj|j|�}ntd��|j|d�}nf|j�r�|jtjk�r�|jtj�d�}n>|jdk�r|jtj�d�}n |j�r8|jtj|j|j�d�}|jdd��rN||fS|SdS)aV

        Parse the date/time string into a :class:`datetime.datetime` object.

        :param timestr:
            Any date/time string using the supported formats.

        :param default:
            The default datetime object, if this is a datetime object and not
            ``None``, elements specified in ``timestr`` replace elements in the
            default object.

        :param ignoretz:
            If set ``True``, time zones in parsed strings are ignored and a
            naive :class:`datetime.datetime` object is returned.

        :param tzinfos:
            Additional time zone names / aliases which may be present in the
            string. This argument maps time zone names (and optionally offsets
            from those time zones) to time zones. This parameter can be a
            dictionary with timezone aliases mapping time zone names to time
            zones or a function taking two parameters (``tzname`` and
            ``tzoffset``) and returning a time zone.

            The timezones to which the names are mapped can be an integer
            offset from UTC in minutes or a :class:`tzinfo` object.

            .. doctest::
               :options: +NORMALIZE_WHITESPACE

                >>> from dateutil.parser import parse
                >>> from dateutil.tz import gettz
                >>> tzinfos = {"BRST": -10800, "CST": gettz("America/Chicago")}
                >>> parse("2012-01-19 17:21:00 BRST", tzinfos=tzinfos)
                datetime.datetime(2012, 1, 19, 17, 21, tzinfo=tzoffset(u'BRST', -10800))
                >>> parse("2012-01-19 17:21:00 CST", tzinfos=tzinfos)
                datetime.datetime(2012, 1, 19, 17, 21,
                                  tzinfo=tzfile('/usr/share/zoneinfo/America/Chicago'))

            This parameter is ignored if ``ignoretz`` is set.

        :param **kwargs:
            Keyword arguments as passed to ``_parse()``.

        :return:
            Returns a :class:`datetime.datetime` object or, if the
            ``fuzzy_with_tokens`` option is ``True``, returns a tuple, the
            first element being a :class:`datetime.datetime` object, the second
            a tuple containing the fuzzy tokens.

        :raises ValueError:
            Raised for invalid or unknown string format, if the provided
            :class:`tzinfo` is not in a valid format, or if an invalid date
            would be created.

        :raises TypeError:
            Raised for non-string or character stream input.

        :raises OverflowError:
            Raised if the parsed date exceeds the largest valid C integer on
            your system.
        Nr)r�r�r��microsecondzUnknown string formatzString does not contain a date.r�r�r�r�r�r�r�r)r�z9Offset must be tzinfo subclass, tz string, or int offset.)�tzinfo�fuzzy_with_tokensF)r�r�r�r�r�r�r�)�datetimeZnowr1�_parser�r-rr�r�r�rr�r	r�collections�Callabler�r�r�r�rr
r�rr�ZtzlocalZtzutc)r�timestr�defaultZignoretzZtzinfosr�r��skipped_tokens�replrIrLZcyearZcmonthZcday�retZtzdatar�rrrr�s\?

zparser.parsec@s&eZdZddddddddd	d
dgZdS)
zparser._resultr�r�r�r�r�r�r�r�r�r�r�N)rrArBrGrrrr�_resultisr�cCst
|rd}|j}|dkr|j}|dkr*|j}|j�}tj|�}d }	t�}
�y�t|�}d!}t|�}
d}�xt||
k�r�y||}t	|�}Wnt
k
r�d}YnX|dk	�r�t||�}|d7}t|�dk�rH|d"k�rH|jdk�rH||
k�s||dk�rH|j||�dk�rH||d}t
|dd��|_|dk�r�t
|dd��|_qf|d	k�st|d	k�r||djd
�d	k�r||d}|�r�||djd
�d#k�r�|j|dd��|j|dd��|j|dd��n<t
|dd��|_t
|dd��|_t|dd��\|_|_qf|d$k�r�||d}|j|dd��|j|dd	��|j|d	d��|dk�r�t
|dd��|_t
|dd��|_|dk�r�t
|dd��|_qf||
k�r�|j||�dk	�s|d|
k�r0||dk�r0|j||d�dk	�r0||dk�r|d7}|j||�}�x�|dk�rZt
|�|_|d�r�t
d|d�|_nL|dk�r�t
|�|_|d�r�t
d|d�|_n|dk�r�t|�\|_|_|d7}||
k�s�|dk�r�Py||}t	|�}Wnt
k
�r�PYn8X|d7}|d7}||
k�r(|j||�}|dk	�r(|}�q(Wqf||
k�r�||ddk�r�|j||d�dk	�r�|j||d�}|dk�r�t
|�|_|d}|�r�t
d|�|_n|dk�r�t|�\|_|_qf|d|
k�rf||dk�rft
|�|_|d7}t	||�}t
|�|_|d�r$t
d|d�|_|d7}||
k�r�||dk�r�t||d�\|_|_|d7}qf||
k�r�||d%k�r�||}|j|�|d7}||
k�r�|j||��r�y|j||�WnXt
k
�r|j||�}|dk	�r|j|�|d&k�st�t|�d}nd'SYnX|d7}||
k�r�|||k�r�|d7}|j||�}|dk	�r�|j|�t|�d}|d(k�s�t�n|j||�|d7}qf||
k�s�|j||��rd|d|
k�rP|j||d�dk	�rPt
|�|_|jdk�r|j||d�dk�r|jd7_n*|jdk�rF|j||d�dk�rFd|_|d7}n
|j|�|d7}qf|j||�dk	�r�t
|�|_|jdk�r�|j||�dk�r�|jd7_n&|jdk�r�|j||�dk�r�d|_|d7}qf|�s�d)S|d7}qf|j||�}|dk	�r||_|d7}qf|j||�}|dk	�	rd|j|�|d*k�sNt�t|�d}|d7}||
krf||d+k�r�||}|d7}|j||�|d7}||
k�	rb|||k�	rb|d7}|j||�|d7}qf|d|
krf||||dk�	odknrf|j||d�rfyt
||d�}Wnt
k
�	rDYnX|jt|j|���|d7}qf|j||�}|dk	�
rZd}|�	r�|jdk	�	r�d}|jdk�	r�|�	r�d}nt
d,��n2d|jk�	o�dkn�	s�|�	r�d}nt
d-��|�
r:|dk�
r|jdk�
r|jd7_n|dk�
r2|jdk�
r2d|_||_n|�
rP|j|
|	||�}	|d7}qf|jdk	�rt||�dk�r|jdk�r|jdk�rdd�||D��r|||_|j|j�|_|d7}||
krf||d.krfd/||dk||<d|_|j|j�rfd|_qf|jdk	�r�||d0k�r�d2||dk}|d7}t||�}|dk�r�t
||dd��dt
||dd��d|_nz|d|
k�r�||ddk�r�t
||�dt
||d�d|_|d7}n*|dk�r�t
||dd��d|_nd3S|d7}|j|9_|d|
krf|j||�rf||ddkrf||ddkrfdt||d�k�ondknrfdd�||dD�rf||d|_|d7}qf|j||��p�|�s�d4S|j|
|	||�}	|d7}qfW|j |||�\}}}|dk	�
r||_!|j"|_"|dk	�
r||_|dk	�
r&||_#Wnt$t
tfk
�
rDd5SX|j%|��
sVd6S|�
rh|t&|
�fS|dfSdS)7a
        Private method which performs the heavy lifting of parsing, called from
        ``parse()``, which passes on its ``kwargs`` to this function.

        :param timestr:
            The string to parse.

        :param dayfirst:
            Whether to interpret the first value in an ambiguous 3-integer date
            (e.g. 01/05/09) as the day (``True``) or month (``False``). If
            ``yearfirst`` is set to ``True``, this distinguishes between YDM
            and YMD. If set to ``None``, this value is retrieved from the
            current :class:`parserinfo` object (which itself defaults to
            ``False``).

        :param yearfirst:
            Whether to interpret the first value in an ambiguous 3-integer date
            (e.g. 01/05/09) as the year. If ``True``, the first number is taken
            to be the year, otherwise the last number is taken to be the year.
            If this is set to ``None``, the value is retrieved from the current
            :class:`parserinfo` object (which itself defaults to ``False``).

        :param fuzzy:
            Whether to allow fuzzy parsing, allowing for string like "Today is
            January 1, 2047 at 8:21:00AM".

        :param fuzzy_with_tokens:
            If ``True``, ``fuzzy`` is automatically set to True, and the parser
            will return a tuple where the first element is the parsed
            :class:`datetime.datetime` datetimestamp and the second element is
            a tuple containing the portions of the string which were ignored:

            .. doctest::

                >>> from dateutil.parser import parse
                >>> parse("Today is January 1, 2047 at 8:21:00AM", fuzzy_with_tokens=True)
                (datetime.datetime(2047, 1, 1, 8, 21), (u'Today is ', u' ', u'at '))

        TNr%rrr���:�r"�r���
r!�<rTrUFzNo hour specified with zAM or PM flag.zInvalid hour specified for z12-hour clock.�cSsg|]}|tjkr|�qSr)�string�ascii_uppercase)rN�xrrrr��sz!parser._parse.<locals>.<listcomp>�+i�(�)cSsg|]}|tjkr|�qSr)r�r�)rNr�rrrr�s���r')r%r�r')r�r�r�)rTrUr"r')NNr')NNr')rTrUz%No hour specified with AM or PM flag.z)Invalid hour specified for 12-hour clock.)r�rT)r�rT)r�rTr')r'r)NN)NN)NN)NN)'r�r�r�r�r
r0r<r�r-�floatr�r�r�r�r��findr,�_parsemsr�r�r�r��AssertionErrorr�r�r��strr��_skip_tokenr�r�r�r�r�r�r��
IndexErrorr�r�)rr�r�r�Zfuzzyr�r�r�r5�last_skipped_token_ir�Zymdr��len_lr�Z
value_reprrL�len_lir>�idxZnewidxZ
sec_remainder�sepZval_is_ampm�signalr�r�r�rrrr�ns)


$
, 

























&
$$



  




2



4 &

.&




z
parser._parsecCs8||dkr"|d||7<n|j||�|}|S)Nrr')r,)r�r�r�r5rrrr�-s
zparser._skip_token)N)NFN)NNFF)
rrArBrrrFr�r�r�r�rrrrr��s


Ar�cKs(|rt|�j|f|�Stj|f|�SdS)a)

    Parse a string in one of the supported formats, using the
    ``parserinfo`` parameters.

    :param timestr:
        A string containing a date/time stamp.

    :param parserinfo:
        A :class:`parserinfo` object containing parameters for the parser.
        If ``None``, the default arguments to the :class:`parserinfo`
        constructor are used.

    The ``**kwargs`` parameter takes the following keyword arguments:

    :param default:
        The default datetime object, if this is a datetime object and not
        ``None``, elements specified in ``timestr`` replace elements in the
        default object.

    :param ignoretz:
        If set ``True``, time zones in parsed strings are ignored and a naive
        :class:`datetime` object is returned.

    :param tzinfos:
            Additional time zone names / aliases which may be present in the
            string. This argument maps time zone names (and optionally offsets
            from those time zones) to time zones. This parameter can be a
            dictionary with timezone aliases mapping time zone names to time
            zones or a function taking two parameters (``tzname`` and
            ``tzoffset``) and returning a time zone.

            The timezones to which the names are mapped can be an integer
            offset from UTC in minutes or a :class:`tzinfo` object.

            .. doctest::
               :options: +NORMALIZE_WHITESPACE

                >>> from dateutil.parser import parse
                >>> from dateutil.tz import gettz
                >>> tzinfos = {"BRST": -10800, "CST": gettz("America/Chicago")}
                >>> parse("2012-01-19 17:21:00 BRST", tzinfos=tzinfos)
                datetime.datetime(2012, 1, 19, 17, 21, tzinfo=tzoffset(u'BRST', -10800))
                >>> parse("2012-01-19 17:21:00 CST", tzinfos=tzinfos)
                datetime.datetime(2012, 1, 19, 17, 21,
                                  tzinfo=tzfile('/usr/share/zoneinfo/America/Chicago'))

            This parameter is ignored if ``ignoretz`` is set.

    :param dayfirst:
        Whether to interpret the first value in an ambiguous 3-integer date
        (e.g. 01/05/09) as the day (``True``) or month (``False``). If
        ``yearfirst`` is set to ``True``, this distinguishes between YDM and
        YMD. If set to ``None``, this value is retrieved from the current
        :class:`parserinfo` object (which itself defaults to ``False``).

    :param yearfirst:
        Whether to interpret the first value in an ambiguous 3-integer date
        (e.g. 01/05/09) as the year. If ``True``, the first number is taken to
        be the year, otherwise the last number is taken to be the year. If
        this is set to ``None``, the value is retrieved from the current
        :class:`parserinfo` object (which itself defaults to ``False``).

    :param fuzzy:
        Whether to allow fuzzy parsing, allowing for string like "Today is
        January 1, 2047 at 8:21:00AM".

    :param fuzzy_with_tokens:
        If ``True``, ``fuzzy`` is automatically set to True, and the parser
        will return a tuple where the first element is the parsed
        :class:`datetime.datetime` datetimestamp and the second element is
        a tuple containing the portions of the string which were ignored:

        .. doctest::

            >>> from dateutil.parser import parse
            >>> parse("Today is January 1, 2047 at 8:21:00AM", fuzzy_with_tokens=True)
            (datetime.datetime(2047, 1, 1, 8, 21), (u'Today is ', u' ', u'at '))

    :return:
        Returns a :class:`datetime.datetime` object or, if the
        ``fuzzy_with_tokens`` option is ``True``, returns a tuple, the
        first element being a :class:`datetime.datetime` object, the second
        a tuple containing the fuzzy tokens.

    :raises ValueError:
        Raised for invalid or unknown string format, if the provided
        :class:`tzinfo` is not in a valid format, or if an invalid date
        would be created.

    :raises OverflowError:
        Raised if the parsed date exceeds the largest valid C integer on
        your system.
    N)r�r�
DEFAULTPARSER)r�rr�rrrr<s_c@s$eZdZGdd�de�Zdd�ZdS)�	_tzparserc@s<eZdZddddddgZGdd�de�Zd	d
�Zdd�Zd
S)z_tzparser._result�stdabbr�	stdoffset�dstabbr�	dstoffset�start�endc@seZdZdddddddgZdS)	z_tzparser._result._attrr��weekr��yday�jydayr�r�N)rrArBrGrrrr�_attr�srcCs
|jd�S)N�)rM)rrrrrR�sz_tzparser._result.__repr__cCs"tj|�|j�|_|j�|_dS)N)rFrrrr)rrrrr�s

z_tzparser._result.__init__N)rrArBrGrFrrRrrrrrr��s
r�cCsZ|j�}tj|�}�y$t|�}d}�x�||k�r�|}x(||kr\dd�||D�r\|d7}q6W||k�r�|js�d}dj|||��|_nd}dj|||��|_|}||ko�||dks�||dd
k�r�||dk�r�d||dk}|d7}nd }t||�}	|	dk�rJt||t||dd��d
t||dd��d|�n�|d|k�r�||ddk�r�t||t||�d
t||d�d|�|d7}n4|	dk�r�t||t||dd��d
|�ndS|d7}|j�r�Pq&Pq&W||k�rBx*t	||�D]}||dk�rd||<�qW||dk�s:t
�|d7}||k�rP�n�d|jd�k�ojdkn�r�dd�||d�D��r�x�|j|j
fD]�}
t||�|
_|d7}||d	k�r�t||d�d!}|d7}nt||�}|d7}|�r||
_t||�dd|
_nt||�|
_|d7}t||�|
_|d7}�q�W||k�r6||d"k�r|d$||dk}|d7}nd}|jt||�||_�n�|jd�dk�r6||d�jd�dk�r6dd�||d�D��r6�xF|j|j
fD�]4}
||dk�r|d7}t||�|
_n�||dk�r�|d7}t||�|
_|d7}||d%k�sXt
�|d7}t||�|
_|
jdk�r�d&|
_|d7}||d'k�s�t
�|d7}t||�dd|
_nt||�d|
_|d7}||k�r�||dk�r�|d7}t||�}	|	dk�r>t||dd��d
t||dd��d|
_n�|d|k�r�||ddk�r�t||�d
t||d�d|
_|d7}|d|k�r�||ddk�r�|d7}|
jt||�7_n*|	dk�r�t||dd��d
|
_ndS|d7}||k�s||dk�st
�|d7}�q�W||k�s6t
�Wnttt
fk
�rTdSX|S)(NrcSsg|]}|dkr|�qS)z0123456789:,-+r)rNr�rrrr��sz#_tzparser.parse.<locals>.<listcomp>rrr
rr�rT�
0123456789r�r%ir�r�rSr$r��	cSs*g|]"}|dkr|D]}|dkr|�qqS)r$rr)rNr��yrrrr��s
�rUc
Ss*g|]"}|dkr|D]}|dkr|�qqS)	r$rU�J�Mr"rTr�r)r$rUrrr"rTr�r)rNr�rrrrr�srrr"r�)r�rT)r�rTr')rr'r'r')rTr�r')r'r)rTr"r')rTr")r�r
r0r-rrKrrHr��ranger�r.rrr�r	r�r�r�rrrr
r�r�)rr�r�r5r�r��jZoffattrrr�r�rLrrrr�s�



" *

 

"


(
4 & 
z_tzparser.parseN)rrArBrFr�rrrrrr�srcCs
tj|�S)N)�DEFAULTTZPARSERr)r�rrr�_parsetzQsrcCsFd|krt|�dfS|jd�\}}t|�t|jdd�dd��fSdS)z9Parse a I[.F] seconds value into (seconds, microseconds).r"rr�r N)r�r0�ljust)rLr��frrrr�Usr�)N)!r�Z
__future__rr�r�r�r�rC�iorZcalendarrZsixrrrr
r	r
�__all__�objectr
rFrr<r�r�rrrrrr�rrrr�<module>s<#oX
e.PKa�\�􄩦�#__pycache__/__init__.cpython-36.pycnu�[���3

6�cYE�@sddlmZdS)�)�VERSIONN)Z_versionr�__version__�rr�/usr/lib/python3.6/__init__.py�<module>sPKa�\mw���&__pycache__/tzwin.cpython-36.opt-1.pycnu�[���3

6�cY;�@sddlTdS)�)�*N)Ztz.win�rr�/usr/lib/python3.6/tzwin.py�<module>sPKa�\tz�t�t� __pycache__/rrule.cpython-36.pycnu�[���3

6�cY���@sJdZddlZddlZddlZddlZyddlmZWn ek
rTddlmZYnXddl	m
Z
mZddlm
Z
mZddlZddlmZddlmZd	d
ddd
ddddddddddddgZedgddgddgddgdd gdd!gdd"gdd#gdd$gdd%gdd&gdd'gddgd"�Zee�Zeedd��eedd��eedd(��ZZZeeeeeeeeeeeeeedd"��Zee�ZeedNd��eedOd��eedPd��ZZZeeeeeeeeeeeeeedd"��Zee�Z dQZ!dRZ"dddddd d!gd?Z#[[[ed4=ed4=e d=ee�Zee�Zdd
dddddgZ$eed"��\Z%Z&Z'Z(Z)Z*Z+da,da-Gd@dA�dAe�ZedBdC�ed"�D��\Z.Z/Z0Z1Z2Z3Z4Z5dDdE�Z6GdFdG�dGe7�Z8GdHd	�d	e8�Z9GdIdJ�dJe7�Z:GdKd
�d
e8�Z;GdLdM�dMe7�Z<e<�Z=dS)Sz�
The rrule module offers a small, complete, and very fast, implementation of
the recurrence rules documented in the
`iCalendar RFC <http://www.ietf.org/rfc/rfc2445.txt>`_,
including support for caching of results.
�N)�gcd)�advance_iterator�
integer_types)�_thread�range�)�weekday)�warn�rrule�rruleset�rrulestr�YEARLY�MONTHLY�WEEKLY�DAILY�HOURLY�MINUTELY�SECONDLY�MO�TU�WE�TH�FR�SA�SU�����������	�
��� �<�[�y��������1�O�n�;�Z�x��������0�N�m�7cs"eZdZdZd�fdd�	Z�ZS)rz7
    This version of weekday does not allow n = 0.
    Ncs&|dkrtd��tt|�j||�dS)NrzCan't create weekday with n==0)�
ValueError�superr�__init__)�selfZwkday�n)�	__class__��/usr/lib/python3.6/rrule.pyrCDszweekday.__init__)N)�__name__�
__module__�__qualname__�__doc__rC�
__classcell__rGrG)rFrHr@srccs|]}t|�VqdS)N)r)�.0�xrGrGrH�	<genexpr>KsrPcs�fdd�}|S)zT
    Decorator for rruleset methods which may invalidate the
    cached length.
    cs�|f|�|�}|j�|S)N)�_invalidate_cache)rD�args�kwargs�rv)�frGrH�
inner_funcSsz&_invalidates_cache.<locals>.inner_funcrG)rUrVrG)rUrH�_invalidates_cacheNsrWc@sneZdZddd�Zdd�Zdd�Zdd	�Zd
d�Zdd
�Zdd�Z	ddd�Z
ddd�Zddd�Zddd�Z
dS)�	rrulebaseFcCs4|rg|_tj�|_|j�nd|_d|_d|_dS)NF)�_cacher�
allocate_lock�_cache_lockrQ�_cache_complete�_len)rD�cacherGrGrHrC\s

zrrulebase.__init__cCs.|jrt|j�S|jdkr"|j�S|j�SdS)N)r\�iterrY�_iter�_iter_cached)rDrGrGrH�__iter__fs


zrrulebase.__iter__cCs>|jdk	r4g|_d|_|j�|_|jj�r4|jj�d|_dS)NF)rYr\r`�
_cache_genr[�locked�releaser])rDrGrGrHrQns



zrrulebase._invalidate_cacheccs�d}|j}|j}|jj}|jj}x�|r�|t|�kr�|�|jr@Py$xtd�D]}|jt	|��qLWWn&t
k
r�d|_}d|_PYnX|�||V|d7}q"Wx ||jkr�||V|d7}q�WdS)Nrr&Tr)rcrYr[�acquirere�lenr\r�appendr�
StopIterationr])rD�i�genr^rfre�jrGrGrHrays.


zrrulebase._iter_cachedcCs�|jr|j|St|t�rd|jr:|jdkr:tt|��|Sttj||j	pJd|j
pTtj|jp\d��Sn`|dkr�t|�}y"xt
|d�D]}t|�}q�WWntk
r�t�YnX|Stt|��|SdS)Nrr)r\rY�
isinstance�slice�step�listr_�	itertools�islice�start�stop�sys�maxsizerrri�
IndexError)rD�itemrkrj�resrGrGrH�__getitem__�s$



zrrulebase.__getitem__cCs:|jr||jkSx$|D]}||kr&dS||krdSqWdS)NTF)r\rY)rDrxrjrGrGrH�__contains__�s

zrrulebase.__contains__cCs|jdkrx|D]}qW|jS)z� Returns the number of recurrences in this set. It will have go
            trough the whole recurrence, if this hasn't been done before. N)r])rDrOrGrGrH�count�s

zrrulebase.countcCsX|jr|j}n|}d}|r8x8|D]}||kr.P|}q Wnx|D]}||krLP|}q>W|S)z� Returns the last recurrence before the given datetime instance. The
            inc keyword defines what happens if dt is an occurrence. With
            inc=True, if dt itself is an occurrence, it will be returned. N)r\rY)rD�dt�incrk�lastrjrGrGrH�before�s


zrrulebase.beforecCsP|jr|j}n|}|r2x4|D]}||kr|SqWnx|D]}||kr8|Sq8WdS)z� Returns the first recurrence after the given datetime instance. The
            inc keyword defines what happens if dt is an occurrence. With
            inc=True, if dt itself is an occurrence, it will be returned.  N)r\rY)rDr}r~rkrjrGrGrH�after�s


zrrulebase.afterNccsh|jr|j}n|}|r dd�}ndd�}d}x6|D].}|||�r2|dk	rZ|d7}||krZP|Vq2WdS)aH
        Generator which yields up to `count` recurrences after the given
        datetime instance, equivalent to `after`.

        :param dt:
            The datetime at which to start generating recurrences.

        :param count:
            The maximum number of recurrences to generate. If `None` (default),
            dates are generated until the recurrence rule is exhausted.

        :param inc:
            If `dt` is an instance of the rule and `inc` is `True`, it is
            included in the output.

        :yields: Yields a sequence of `datetime` objects.
        cSs||kS)NrG)�dc�dtcrGrGrH�<lambda>�sz"rrulebase.xafter.<locals>.<lambda>cSs||kS)NrG)r�r�rGrGrHr��srNr)r\rY)rDr}r|r~rk�comprE�drGrGrH�xafter�s


zrrulebase.xafterrc	Cs�|jr|j}n|}d}g}|r`x�|D]6}||kr4Pq$|sP||krZd}|j|�q$|j|�q$Wn@x>|D]6}||krvPqf|s�||kr�d}|j|�qf|j|�qfW|S)a Returns all the occurrences of the rrule between after and before.
        The inc keyword defines what happens if after and/or before are
        themselves occurrences. With inc=True, they will be included in the
        list, if they are found in the recurrence set. FT)r\rYrh)	rDr�r�r~r|rkZstarted�lrjrGrGrH�betweens.

zrrulebase.between)F)F)F)NF)Fr)rIrJrKrCrbrQrarzr{r|r�r�r�r�rGrGrGrHrX[s




)rXcsJeZdZdZd�fdd�	Zdd�Zd	d
�Zdd�Zd
d�Zdd�Z	�Z
S)r
a|
    That's the base of the rrule operation. It accepts all the keywords
    defined in the RFC as its constructor parameters (except byday,
    which was renamed to byweekday) and more. The constructor prototype is::

            rrule(freq)

    Where freq must be one of YEARLY, MONTHLY, WEEKLY, DAILY, HOURLY, MINUTELY,
    or SECONDLY.

    .. note::
        Per RFC section 3.3.10, recurrence instances falling on invalid dates
        and times are ignored rather than coerced:

            Recurrence rules may generate recurrence instances with an invalid
            date (e.g., February 30) or nonexistent local time (e.g., 1:30 AM
            on a day where the local time is moved forward by an hour at 1:00
            AM).  Such recurrence instances MUST be ignored and MUST NOT be
            counted as part of the recurrence set.

        This can lead to possibly surprising behavior when, for example, the
        start date occurs at the end of the month:

        >>> from dateutil.rrule import rrule, MONTHLY
        >>> from datetime import datetime
        >>> start_date = datetime(2014, 12, 31)
        >>> list(rrule(freq=MONTHLY, count=4, dtstart=start_date))
        ... # doctest: +NORMALIZE_WHITESPACE
        [datetime.datetime(2014, 12, 31, 0, 0),
         datetime.datetime(2015, 1, 31, 0, 0),
         datetime.datetime(2015, 3, 31, 0, 0),
         datetime.datetime(2015, 5, 31, 0, 0)]

    Additionally, it supports the following keyword arguments:

    :param cache:
        If given, it must be a boolean value specifying to enable or disable
        caching of results. If you will use the same rrule instance multiple
        times, enabling caching will improve the performance considerably.
    :param dtstart:
        The recurrence start. Besides being the base for the recurrence,
        missing parameters in the final recurrence instances will also be
        extracted from this date. If not given, datetime.now() will be used
        instead.
    :param interval:
        The interval between each freq iteration. For example, when using
        YEARLY, an interval of 2 means once every two years, but with HOURLY,
        it means once every two hours. The default interval is 1.
    :param wkst:
        The week start day. Must be one of the MO, TU, WE constants, or an
        integer, specifying the first day of the week. This will affect
        recurrences based on weekly periods. The default week start is got
        from calendar.firstweekday(), and may be modified by
        calendar.setfirstweekday().
    :param count:
        How many occurrences will be generated.

        .. note::
            As of version 2.5.0, the use of the ``until`` keyword together
            with the ``count`` keyword is deprecated per RFC-2445 Sec. 4.3.10.
    :param until:
        If given, this must be a datetime instance, that will specify the
        limit of the recurrence. The last recurrence in the rule is the greatest
        datetime that is less than or equal to the value specified in the
        ``until`` parameter.

        .. note::
            As of version 2.5.0, the use of the ``until`` keyword together
            with the ``count`` keyword is deprecated per RFC-2445 Sec. 4.3.10.
    :param bysetpos:
        If given, it must be either an integer, or a sequence of integers,
        positive or negative. Each given integer will specify an occurrence
        number, corresponding to the nth occurrence of the rule inside the
        frequency period. For example, a bysetpos of -1 if combined with a
        MONTHLY frequency, and a byweekday of (MO, TU, WE, TH, FR), will
        result in the last work day of every month.
    :param bymonth:
        If given, it must be either an integer, or a sequence of integers,
        meaning the months to apply the recurrence to.
    :param bymonthday:
        If given, it must be either an integer, or a sequence of integers,
        meaning the month days to apply the recurrence to.
    :param byyearday:
        If given, it must be either an integer, or a sequence of integers,
        meaning the year days to apply the recurrence to.
    :param byweekno:
        If given, it must be either an integer, or a sequence of integers,
        meaning the week numbers to apply the recurrence to. Week numbers
        have the meaning described in ISO8601, that is, the first week of
        the year is that containing at least four days of the new year.
    :param byweekday:
        If given, it must be either an integer (0 == MO), a sequence of
        integers, one of the weekday constants (MO, TU, etc), or a sequence
        of these constants. When given, these variables will define the
        weekdays where the recurrence will be applied. It's also possible to
        use an argument n for the weekday instances, which will mean the nth
        occurrence of this weekday in the period. For example, with MONTHLY,
        or with YEARLY and BYMONTH, using FR(+1) in byweekday will specify the
        first friday of the month where the recurrence happens. Notice that in
        the RFC documentation, this is specified as BYDAY, but was renamed to
        avoid the ambiguity of that keyword.
    :param byhour:
        If given, it must be either an integer, or a sequence of integers,
        meaning the hours to apply the recurrence to.
    :param byminute:
        If given, it must be either an integer, or a sequence of integers,
        meaning the minutes to apply the recurrence to.
    :param bysecond:
        If given, it must be either an integer, or a sequence of integers,
        meaning the seconds to apply the recurrence to.
    :param byeaster:
        If given, it must be either an integer, or a sequence of integers,
        positive or negative. Each integer will define an offset from the
        Easter Sunday. Passing the offset 0 to byeaster will yield the Easter
        Sunday itself. This is an extension to the RFC specification.
     NrFc
sRtt|�j|�|s(tjj�jdd�}n*t|tj�sFtjj|j��}n|jdd�}||_	|j
|_||_||_
||_i|_|r�t|tj�r�tjj|j��}||_|dk	r�|r�tdt�|dkr�tj�|_nt|t�r�||_n|j|_|dkr�d|_n�t|t��r:|dk�s(d|k�odkn�r0td��|f|_nLt|�|_x@|jD]6}|dk�sxd|k�ondkn�rLtd���qLW|j�r�|j|jd<|dk�r:|
dk�r:|	dk�r:|
dk�r:|dk�r:|tk�r|dk�r�|j}d|jd<|j}	d|jd<n8|tk�r|j}	d|jd<n|tk�r:|j�}
d|jd	<|dk�rLd|_ n<t|t��r^|f}tt!t"|���|_ d|jk�r�|j |jd<|
dk�r�d|_#n0t|
t��r�|
f}
tt!t"|
���|_#|j#|jd
<|dk	�rt$�s�ddl%m$a$t|t��r�|f|_&ntt!|��|_&|j&|jd<nd|_&|	dk�r6f|_'f|_(npt|	t��rH|	f}	t"|	�}	tt!d
d�|	D���|_'tt!dd�|	D���|_(d|jk�r�tt)j*|j'|j(��|jd<|dk�r�d|_+n0t|t��r�|f}tt!t"|���|_+|j+|jd<|
dk�rd|_,d|_-�n8t|
t��st.|
d��r |
f}
t"�|_,t"�|_-x`|
D]X}t|t��rT|j,j/|�n8|j0�sh|tk�rx|j,j/|j�n|j-j/|j|j0f��q6W|j,�s�d|_,n|j-�s�d|_-|j,dk	�r�tt!|j,��|_,dd�|j,D�}nt�}|j-dk	�rtt!|j-��|_-dd�|j-D�}nt�}d	|jk�r:tt)j*||��|jd	<|dk�rf|t1k�r^t"|j2f�|_3nd|_3nXt|t��rx|f}|t1k�r�|j4|j2|dd�|_3n
t"|�|_3tt!|j3��|_3|j3|jd<|dk�r�|t5k�r�t"|j6f�|_7nd|_7nXt|t��r�|f}|t5k�r|j4|j6|dd�|_7n
t"|�|_7tt!|j7��|_7|j7|jd<|dk�rj|t8k�rb|j9f|_:nd|_:nbt|t��r||f}t"|�|_:|t8k�r�|j4|j9|dd�|_:n
t"|�|_:tt!|j:��|_:|j:|jd<|jt1k�r�d|_;nng|_;xP|j3D]F}x>|j7D]4}x,|j:D]"}|j;j<tj=||||jd���qW�q�W�q�W|j;j>�t|j;�|_;dS)Nr)Zmicrosecondz�Using both 'count' and 'until' is inconsistent with RFC 2445 and has been deprecated in dateutil. Future versions will raise an error.inz:bysetpos must be between 1 and 366, or between -366 and -1�bysetpos�bymonth�
bymonthday�	byweekday�	byyearday)�easter�byeastercss|]}|dkr|VqdS)rNrG)rNrOrGrGrHrPsz!rrule.__init__.<locals>.<genexpr>css|]}|dkr|VqdS)rNrG)rNrOrGrGrHrPs�byweeknorEcSsg|]}t|��qSrG)r)rNrOrGrGrH�
<listcomp>Isz"rrule.__init__.<locals>.<listcomp>cSsg|]}t|��qSrG)r)rNrOrGrGrHr�Os�)rs�byxxx�base�byhourr*�byminute�bysecond)�tzinfoi����i����)?rBr
rC�datetimeZnow�replacerm�fromordinal�	toordinal�_dtstartr��_tzinfo�_freq�	_interval�_count�_original_rule�_untilr	�DeprecationWarning�calendarZfirstweekday�_wkstrr�	_bysetposrA�tupler
�month�dayrr�_bymonth�sorted�set�
_byyeardayr��dateutil�	_byeaster�_bymonthday�_bynmonthdayrq�chain�	_byweekno�
_byweekday�_bynweekday�hasattr�addrEr�hour�_byhour�_rrule__construct_bysetr�minute�	_byminuter�second�	_bysecond�_timesetrh�time�sort)rD�freq�dtstart�interval�wkstr|�untilr�r�r�r�r�r�r�r�r�r�r^�pos�wdayZorig_byweekdayZorig_bynweekdayr�r�r�)rFrGrHrC�sL
(

(





























zrrule.__init__c
Cs�g}dgd\}}}|jrD|j|jjd��|jj�dd�\}}}dt|jg}|jdkrr|jdt|j��|jr�|jdt	t
|j��d	d
��|jdk	r�|jdt|j��|jr�|j|jjd��|j
jd
�dk	�rDt|j
�}g}xJ|d
D]>}|j�r(|jdj|jt	|�d	d
�d��q�|jt	|��q�W||d
<n|j
}d}	xFd4D]>\}
}|j|�}|�rT|j|	j|
d$jd%d&�|D��d'���qTW|jd(j|��d)j|�S)5z�
        Output a string that would generate this RRULE if passed to rrulestr.
        This is mostly compatible with RFC2445, except for the
        dateutil-specific extension BYEASTER.
        NrzDTSTART:%Y%m%dT%H%M%Sr"zFREQ=rz	INTERVAL=zWKST=rrzCOUNT=zUNTIL=%Y%m%dT%H%M%Sr�z{n:+d}{wday})rEr�z
{name}={vals}�BYSETPOSr��BYMONTHr��
BYMONTHDAYr��	BYYEARDAYr��BYWEEKNOr��BYDAY�BYHOURr��BYMINUTEr��BYSECONDr��BYEASTERr��,css|]}t|�VqdS)N)�str)rN�vrGrGrHrP�sz rrule.__str__.<locals>.<genexpr>)�name�vals�;�
�r�r��r�r��r�r��r�r��r�r��r�r��r�r��r�r��r�r��r�r�)
r�r�r�r�r�r�r�r�r�r�)r�rhZstrftime�	timetuple�	FREQNAMESr�r�r�r��reprrr�r�r��get�dictrE�format�join)
rD�output�h�m�s�partsZ
original_ruleZwday_stringsr�Zpartfmtr��key�valuerGrGrH�__str__�sT
 



z
rrule.__str__cKsN|j|j|j|j|j|j|jdkr&dndd�}|j|j�|j|�t	f|�S)z�Return new rrule with same attributes except for those attributes given new
           values by whichever keyword arguments are specified.NFT)r�r|r�r�r�r�r^)
r�r�r�r�r�r�rY�updater�r
)rDrSZ
new_kwargsrGrGrHr��s
z
rrule.replacec5cs�|jj�\	}}}}}}}}}	|j}
|j}|j}|j}
|j}|j}|j}|j	}|j
}|j}|j}|j
}|j}|j}|j}t|�}|j||�t|jt|jt|jt|jt|jt|jt|ji|
}|
tkr�|j}n�t|jt|j t|j!i|
}|
tko�|jo�||jk�s<|
tk�r|j�r||jk�s<|
tk�rB|j�rB||jk�rBf}n||||�}d}|j"}�xX||||�\}} }!d}"�x$|| |!�D�]}#|�r�|j#|#|k�s�|�r�|j$|#�s�|�r�|j%|#|k�s�|j&�r�|j&|#�s�|�r�|j'|#�s�|�s�|�r|j(|#|k�r|j)|#|k�s�|�r�|#|j*k�rP|#d|k�rP|j*|#|k�s�|#|j*k�r�|#d|j*|k�r�|j+|#|j*|k�r�d||#<d}"�q�W|�r�|�r�g}$x�|D]�}%|%dk�r�t,|%t-|��\}&}'nt,|%dt-|��\}&}'y&dd�|| |!�D�|&}#||'}(Wnt.k
�r$Yn6Xt/j0j1|j2|#�})t/j/j3|)|(�}*|*|$k�r�|$j4|*��q�W|$j5�xh|$D]`}*|
�r�|*|
k�r�||_6dS|*|jk�rn|dk	�r�|d8}|dk�r�||_6dS|d7}|*V�qnWn�x�|| |!�D]�}#|#dk	�r�t/j0j1|j2|#�})xv|D]n}(t/j/j3|)|(�}*|
�r4|*|
k�r4||_6dS|*|jk�r|dk	�rf|d8}|dk�rf||_6dS|d7}|*V�qW�q�Wd}+|
tk�r�||7}|t/j7k�r�||_6dS|j||��n^|
tk�r.||7}|dk�rt,|d�\},}-|-}||,7}|dk�rd}|d8}|t/j7k�r||_6dS|j||��n�|
tk�r�||k�rd||dd||jd	7}n||||jd	7}|}d}+�n�|
tk�r�||7}d}+�nx|
tk�r|"�r�|d
|||7}|�r�|j8||jdd�\}.}nt,||d�\}.}|.�r||.7}d}+||||�}�n|
tk�r�|"�rD|d
|d|||7}d}/d}0x�t9|0t:||0��D]v}1|�r�|j8||jdd�\}2}nt,||d�\}2}t,||2d�\},}|,�r�||,7}d}+d}"|�s�||k�r`d}/P�q`W|/�s�t;d��||||�}�n"|
tk�r|"�r,|d|d|d|||7}d}0d}/x�t9d|0t:||0��D]�}1|�rl|j8||jdd�\}3}nt,||d�\}3}t,||3d�\},}|,�r�||,7}t,|d�\},}|,�r�||,7}d}+|�s�||k�rJ|�s�||k�rJ|�s�||k�rJd}/P�qJW|/�st;d��||||�}|+�r\|dk�r\t<j=||�d}4||4k�r\x\||4k�r�||48}|d7}|dk�r�d}|d7}|t/j7k�r�||_6dSt<j=||�d}4�qFW|j||��q\WdS)NrFrTcSsg|]}|dk	r|�qS)NrG)rNrOrGrGrHr�@szrrule._iter.<locals>.<listcomp>r(r"r#�r�)r�r�r�i�r*z$Invalid combination of interval and zbyhour resulting in empty rule.iQiz!Invalid combination of interval, z&byhour and byminute resulting in emptyz rule.��
i�zCInvalid combination of interval and byhour resulting in empty rule.i�QzGInvalid combination of interval, byhour and byminute resulting in emptyzMInvalid combination of interval, byhour and byminute resulting in empty rule.)>r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r��	_iterinfo�rebuildr
�ydaysetr�mdaysetr�wdaysetr�ddaysetrrrr��htimeset�mtimeset�stimesetr��mmask�wnomask�wdaymask�	nwdaymask�
eastermask�mdaymask�	nmdaymask�yearlen�nextyearlen�divmodrgrwr��dater��yearordinalZcombinerhr�r]ZMAXYEAR�_rrule__mod_distancerrrAr�Z
monthrange)5rD�yearr�r�r�r�r�rZyearday�_r�r�r�r�r�r�r�r�r�r�Zbynmonthdayr�r�r�r��iiZ	getdaysetZtimesetZ
gettimeset�totalr|Zdaysetrs�endZfilteredrjZposlistr�ZdayposZtimeposr�rryZfixday�div�modZndaysZvalidZrep_raterlZnhoursZnminutesZdaysinmonthrGrGrHr`�s�

 
















"





zrrule._itercCspt�}t|t�r|f}x@|D]8}t|j|�}|dksJt|||�ddkr|j|�qWt|�dkrltd��|S)a
        If a `BYXXX` sequence is passed to the constructor at the same level as
        `FREQ` (e.g. `FREQ=HOURLY,BYHOUR={2,4,7},INTERVAL=3`), there are some
        specifications which cannot be reached given some starting conditions.

        This occurs whenever the interval is not coprime with the base of a
        given unit and the difference between the starting position and the
        ending position is not coprime with the greatest common denominator
        between the interval and the base. For example, with a FREQ of hourly
        starting at 17:00 and an interval of 4, the only valid values for
        BYHOUR would be {21, 1, 5, 9, 13, 17}, because 4 and 24 are not
        coprime.

        :param start:
            Specifies the starting position.
        :param byxxx:
            An iterable containing the list of allowed values.
        :param base:
            The largest allowable value for the specified frequency (e.g.
            24 hours, 60 minutes).

        This does not preserve the type of the iterable, returning a set, since
        the values should be unique and the order is irrelevant, this will
        speed up later lookups.

        In the event of an empty set, raises a :exception:`ValueError`, as this
        results in an empty rrule.
        rrz+Invalid rrule byxxx generates an empty set.)	r�rmrrr�rr�rgrA)rDrsr�r�ZcsetZnumZi_gcdrGrGrHZ__construct_byset�s

zrrule.__construct_bysetcCsLd}xBtd|d�D]0}t||j|�\}}||7}||kr||fSqWdS)a�
        Calculates the next value in a sequence where the `FREQ` parameter is
        specified along with a `BYXXX` parameter at the same "level"
        (e.g. `HOURLY` specified with `BYHOUR`).

        :param value:
            The old value of the component.
        :param byxxx:
            The `BYXXX` set, which should have been generated by
            `rrule._construct_byset`, or something else which checks that a
            valid rule is present.
        :param base:
            The largest allowable value for the specified frequency (e.g.
            24 hours, 60 minutes).

        If a valid value is not found after `base` iterations (the maximum
        number before the sequence would start to repeat), this raises a
        :exception:`ValueError`, as no valid values were found.

        This returns a tuple of `divmod(n*interval, base)`, where `n` is the
        smallest number of `interval` repetitions until the next specified
        value in `byxxx` is found.
        rrN)rrr�)rDr�r�r�ZaccumulatorrrrGrGrHZ__mod_distanceszrrule.__mod_distance)NrNNNNNNNNNNNNNF)rIrJrKrLrCr�r�r`r�rrMrGrG)rFrHr
.st{>/c@sveZdZddddddddd	d
ddd
ddgZdd�Zdd�Zdd�Zdd�Zdd�Zdd�Z	dd�Z
dd�Zd d!�Zd"S)#r�r
�lastyear�	lastmonthr	r
r
�yearweekdayr�mrangerrrrrrcCs&x|jD]}t||d�qW||_dS)N)�	__slots__�setattrr
)rDr
�attrrGrGrHrCDsz_iterinfo.__init__cCs�|j}||jk�r2dtj|�|_dtj|d�|_tj|dd�}|j�|_	|j
�|_tj|dd�j
�}|jdkr�t|_
t|_t|_t|d�|_t|_n&t|_
t|_t|_t|d�|_t|_|js�d|_�n`dg|jd|_d|j|jd}}|dk�r"d}|j|j|jd}n
|j|}t|d�\}	}
|	|
d}x�|jD]�}|dk�rh||d7}d|k�o||kn�s��qN|dk�r�||dd}
||k�r�|
d|8}
n|}
x8td�D],}d|j|
<|
d7}
|j|
|jk�r�P�q�W�qNWd|jk�rr||d}
||k�r,|
d|8}
|
|jk�rrx8td�D],}d|j|
<|
d7}
|j|
|jk�rBP�qBW|�r2d|jk�rtj|ddd�j
�}d||jd}dtj|d�}|dk�r�d}d|||jddd}nd|j|dd}nd}||jk�r2xt|�D]}
d|j|
<�qW|j�r�||j k�sR||jk�r�g}|j!t"k�r�|j#�r�x:|j#D]"}|j$|j|d|d���qrWnd|jfg}n$|j!t%k�r�|j|d|d�g}|�r�dg|j|_&x�|D]�\}}|d8}x�|jD]�\}}|dk�r8||dd}
|
|j|
|d8}
n*||dd}
|
d|j|
|d7}
||
k�ov|kn�r�d|j&|
<�q�W�q�W|j'�r�dg|jd|_(t)j)|�j�|j	}x|j'D]}d|j(||<�q�W||_||_ dS)	Nimrrr#r�4���r)*r
rr�Zisleapr	r
r�rr�r
rr�M365MASKr�MDAY365MASKr�NMDAY365MASKr�WDAYMASKr�	M365RANGEr�M366MASK�MDAY366MASK�NMDAY366MASK�	M366RANGEr�rr�rrr�rr�r
r�rhrrr�rr�)rDrr��rrZ	firstydayr�Zno1wkstZ	firstwkstZwyearlenrrZnumweeksrErjrlZlyearweekdayZlno1wkstZlyearlenZ	lnumweeksZranges�firstrZeyday�offsetrGrGrHr�Is�












$
z_iterinfo.rebuildcCstt|j��d|jfS)Nr)rprr	)rDrr�r�rGrGrHr��sz_iterinfo.ydaysetcCsLdg|j}|j|d|d�\}}xt||�D]}|||<q2W|||fS)Nr)r	rr)rDrr�r��dsetrsrrjrGrGrHr��s
z_iterinfo.mdaysetcCsldg|jd}tj|||�j�|j}|}x4td�D](}|||<|d7}|j||jjkr6Pq6W|||fS)Nr#r)	r	r�rr�r
rrr
r�)rDrr�r�r+rjrsrlrGrGrHr��sz_iterinfo.wdaysetcCs:dg|j}tj|||�j�|j}|||<|||dfS)Nr)r	r�rr�r
)rDrr�r�r+rjrGrGrHr��sz_iterinfo.ddaysetc	CsPg}|j}x8|jD].}x(|jD]}|jtj||||jd��qWqW|j�|S)N)r�)r
r�r�rhr�r�r�r�)rDr�r�r��tsetr(rGrGrHr��sz_iterinfo.htimesetcCs@g}|j}x(|jD]}|jtj||||jd��qW|j�|S)N)r�)r
r�rhr�r�r�r�)rDr�r�r�r,r(rGrGrHr�sz_iterinfo.mtimesetcCstj||||jjd�fS)N)r�)r�r�r
r�)rDr�r�r�rGrGrHr�s
z_iterinfo.stimesetN)
rIrJrKrrCr�r�r�r�r�r�rrrGrGrGrHr�>s
r�csjeZdZdZGdd�de�Zd�fdd�	Zedd��Zed	d
��Z	edd��Z
ed
d��Zdd�Z�Z
S)raL The rruleset type allows more complex recurrence setups, mixing
    multiple rules, dates, exclusion rules, and exclusion dates. The type
    constructor takes the following keyword arguments:

    :param cache: If True, caching of results will be enabled, improving
                  performance of multiple queries considerably. c@s@eZdZdd�Zdd�ZeZdd�Zdd�Zd	d
�Zdd�Z	d
S)zrruleset._genitemcCs>yt|�|_|j|�Wntk
r,YnX||_||_dS)N)rr}rhri�genlistrk)rDr-rkrGrGrHrC
s
zrruleset._genitem.__init__cCs^yt|j�|_WnHtk
rX|jd|kr<tj|j�n|jj|�tj|j�YnXdS)Nr)	rrkr}rir-�heapq�heappop�remove�heapify)rDrGrGrH�__next__szrruleset._genitem.__next__cCs|j|jkS)N)r})rD�otherrGrGrH�__lt__szrruleset._genitem.__lt__cCs|j|jkS)N)r})rDr3rGrGrH�__gt__"szrruleset._genitem.__gt__cCs|j|jkS)N)r})rDr3rGrGrH�__eq__%szrruleset._genitem.__eq__cCs|j|jkS)N)r})rDr3rGrGrH�__ne__(szrruleset._genitem.__ne__N)
rIrJrKrCr2�nextr4r5r6r7rGrGrGrH�_genitem	s	
r9Fcs,tt|�j|�g|_g|_g|_g|_dS)N)rBrrC�_rrule�_rdate�_exrule�_exdate)rDr^)rFrGrHrC+s
zrruleset.__init__cCs|jj|�dS)z\ Include the given :py:class:`rrule` instance in the recurrence set
            generation. N)r:rh)rDr
rGrGrHr
2szrruleset.rrulecCs|jj|�dS)z_ Include the given :py:class:`datetime` instance in the recurrence
            set generation. N)r;rh)rD�rdaterGrGrHr>8szrruleset.rdatecCs|jj|�dS)z� Include the given rrule instance in the recurrence set exclusion
            list. Dates which are part of the given recurrence rules will not
            be generated, even if some inclusive rrule or rdate matches them.
        N)r<rh)rD�exrulerGrGrHr?>szrruleset.exrulecCs|jj|�dS)z� Include the given datetime instance in the recurrence set
            exclusion list. Dates included that way will not be generated,
            even if some inclusive rrule or rdate matches them. N)r=rh)rD�exdaterGrGrHr@Fszrruleset.exdateccslg}|jj�|j|t|j��x$dd�|jD�D]}|j||�q2Wg}|jj�|j|t|j��x$dd�|jD�D]}|j||�qxWd}d}tj|�tj|�x�|�r`|d}|s�||j	k�r:xB|o�|d|k�r|d}t
|�|o�|d|kr�tj||�q�W|�s$||dk�r4|d7}|j	V|j	}t
|�|r�|d|kr�tj||�q�W||_dS)NcSsg|]}t|��qSrG)r_)rNrOrGrGrHr�Qsz"rruleset._iter.<locals>.<listcomp>cSsg|]}t|��qSrG)r_)rNrOrGrGrHr�Vsrr)
r;r�r9r_r:r=r<r.r1r}r�heapreplacer])rDZrlistrkZexlistZlastdtrZritemZexitemrGrGrHr`Ms<



zrruleset._iter)F)rIrJrKrL�objectr9rCrWr
r>r?r@r`rMrGrG)rFrHrs"c@s�eZdZeeeeeee	d�Z
dddddddd	�Zd
d�Zdd
�Z
eZeZe
Ze
Ze
Ze
Ze
Ze
Ze
Ze
Ze
Zdd�Zdd�Zdd�Zdd�ZeZddd�Zddd�Zdd�Z dS) �	_rrulestr)r
rrrrrrrrrrrr!r")rrrrrrrcKst|�||j�<dS)N)�int�lower)rD�rrkwargsr�r�rSrGrGrH�_handle_int{sz_rrulestr._handle_intcKs dd�|jd�D�||j�<dS)NcSsg|]}t|��qSrG)rD)rNrOrGrGrHr�sz._rrulestr._handle_int_list.<locals>.<listcomp>r�)�splitrE)rDrFr�r�rSrGrGrH�_handle_int_list~sz_rrulestr._handle_int_listcKs|j||d<dS)Nr�)�	_freq_map)rDrFr�r�rSrGrGrH�_handle_FREQ�sz_rrulestr._handle_FREQcKsVtsddlmay$tj||jd�|jd�d�|d<Wntk
rPtd��YnXdS)Nr)�parser�ignoretz�tzinfos)rMrNr�zinvalid until date)rLr��parser�rA)rDrFr�r�rSrGrGrH�
_handle_UNTIL�sz_rrulestr._handle_UNTILcKs|j||d<dS)Nr�)�_weekday_map)rDrFr�r�rSrGrGrH�_handle_WKST�sz_rrulestr._handle_WKSTcKs�g}x�|jd�D]�}d|krD|jd�}|d}t|ddd	��}	n^t|�r�x"tt|��D]}
||
dkrZPqZW|d|
�p~d}	||
d�}|	r�t|	�}	ntd��|jt|j||	��qW||d<dS)
z:
        Two ways to specify this: +1MO or MO(+1)
        r��(rrNz+-0123456789z$Invalid (empty) BYDAY specification.r�r)rHrDrgrrArh�weekdaysrQ)rDrFr�r�rSr�r�Zsplt�wrErjrGrGrH�_handle_BYWEEKDAY�s"

z_rrulestr._handle_BYWEEKDAYNFc
Cs�|jd�dkr.|jd�\}}|dkr2td��n|}i}x�|jd�D]�}	|	jd�\}}|j�}|j�}y t|d|�|||||d�WqBtk
r�td	|��YqBttfk
r�td
||f��YqBXqBWtf||d�|��S)
N�:r�RRULEzunknown parameter namer��=Z_handle_)rMrNzunknown parameter '%s'zinvalid '%s': %s)r�r^r)�findrHrA�upper�getattr�AttributeError�KeyErrorr
)
rD�liner�r^rMrNr�r�rFZpairrGrGrH�_parse_rfc_rrule�s&
z_rrulestr._parse_rfc_rrulec	Cs�|rd}d}|j�}|j�s$td��|r�|j�}	d}
xr|
t|	�kr�|	|
j�}|sZ|	|
=q6|
dkr�|ddkr�|	|
d|dd�7<|	|
=q6|
d7}
q6Wn|j�}	|r�t|	�dkr�|jd�dks�|jd�r�|j	|	d||||d�Sg}g}
g}g}�x�|	D�]�}|�s�q|jd�dk�r,d	}|}n|jdd�\}}|jd
�}|�sTtd��|d}|dd�}|d	k�r�x|D]}td|���qxW|j
|��q|d
k�r�x$|D]}|dk�r�td|���q�W|
j
|�n�|dk�r
x|D]}td|���q�W|j
|�n�|dk�rFx$|D]}|dk�rtd|���qW|j
|�nV|dk�r�x|D]}td|���qVWt�s~ddlmatj
|||d�}ntd|���qW|�s�t|�dk�s�|
�s�|�s�|�r�t�r�|
�s�|�r�ddlmat|d�}x&|D]}|j|j	||||d���q�Wx:|
D]2}x*|jd�D]}|jtj
|||d���q0W�q Wx&|D]}|j|j	||||d���q\Wx:|D]2}x*|jd�D]}|jtj
|||d���q�W�q�W|�r�|�r�|j|�|S|j	|d||||d�SdS)NTzempty stringr� rrWzRRULE:)r^r�rMrNrXr�zempty property namezunsupported RRULE parm: ZRDATEzVALUE=DATE-TIMEzunsupported RDATE parm: ZEXRULEzunsupported EXRULE parm: ZEXDATEzunsupported EXDATE parm: ZDTSTARTzunsupported DTSTART parm: )rL)rMrNzunsupported property: )r^)r�rMrNr�)r�r^rMrNrr)r[�striprA�
splitlinesrg�rstriprHrZ�
startswithr`rhrLr�rOrr
r>r?r@)rDr�r�r^ZunfoldZforcesetZ
compatiblerMrN�linesrjr_Z	rrulevalsZ	rdatevalsZ
exrulevalsZ
exdatevalsr�r�ZparmsZparmZrsetZdatestrrGrGrH�
_parse_rfc�s�	 























z_rrulestr._parse_rfccKs|j|f|�S)N)rg)rDr�rSrGrGrH�__call__Dsz_rrulestr.__call__)NFFN)NFFFFFN)!rIrJrKr
rrrrrrrJrQrGrIZ_handle_INTERVALZ
_handle_COUNTZ_handle_BYSETPOSZ_handle_BYMONTHZ_handle_BYMONTHDAYZ_handle_BYYEARDAYZ_handle_BYEASTERZ_handle_BYWEEKNOZ_handle_BYHOURZ_handle_BYMINUTEZ_handle_BYSECONDrKrPrRrVZ
_handle_BYDAYr`rgrhrGrGrGrHrCnsN

irCi��i��i��)
rrr*r+r,r-r.r/r0r1r2r3r4)
rrr5r6r7r8r9r:r;r<r=r>r?)>rLrqr�r�ruZmathr�ImportErrorZ	fractionsZsixrrZ	six.movesrrr.Z_commonrZweekdaybase�warningsr	�__all__r�r$rprZM29ZM30ZM31r%r r&r!r'r#r"r�r
rrrrrrr�rLrrrrrrrrTrWrBrXr
r�rrCrrGrGrGrH�<module>sl�.@.@(
TDm[PKa�\W�eFF#__pycache__/_version.cpython-36.pycnu�[���3

6�cY��@s.dZdZdZdZeeefZdjeee��ZdS)z2
Contains information about the dateutil version.
����.N)	�__doc__Z
VERSION_MAJORZ
VERSION_MINORZ
VERSION_PATCHZ
VERSION_TUPLE�join�map�str�VERSION�r
r
�/usr/lib/python3.6/_version.py�<module>s

PKa�\�[/!__pycache__/easter.cpython-36.pycnu�[���3

6�cYE
�@s4dZddlZddddgZdZdZd	Zefd
d�ZdS)zx
This module offers a generic easter computing method for any given year, using
Western, Orthodox or Julian algorithms.
�N�easter�
EASTER_JULIAN�EASTER_ORTHODOX�EASTER_WESTERN���cCsld|kodkns td��|}|d}d}|dkr�d|dd}||d|d	}|d
kr�d}|dkr�||d
d|d
dd}n�|d
}||dd|ddd|dd}||dd|dd|dd|d}||d|d
||dd	}|||}	d|	d|	ddd}
d|	dd}tjt|�t|�t|
��S)a�
    This method was ported from the work done by GM Arts,
    on top of the algorithm by Claus Tondering, which was
    based in part on the algorithm of Ouding (1940), as
    quoted in "Explanatory Supplement to the Astronomical
    Almanac", P.  Kenneth Seidelmann, editor.

    This algorithm implements three different easter
    calculation methods:

    1 - Original calculation in Julian calendar, valid in
        dates after 326 AD
    2 - Original method, with date converted to Gregorian
        calendar, valid in years 1583 to 4099
    3 - Revised method, in Gregorian calendar, valid in
        years 1583 to 4099 as well

    These methods are represented by the constants:

    * ``EASTER_JULIAN   = 1``
    * ``EASTER_ORTHODOX = 2``
    * ``EASTER_WESTERN  = 3``

    The default method is method 3.

    More about the algorithm may be found at:

    http://users.chariot.net.au/~gmarts/eastalg.htm

    and

    http://www.tondering.dk/claus/calendar.html

    rrzinvalid method�r����r�
i@�d���
��������(��)�
ValueError�datetimeZdate�int)Zyear�method�y�g�e�i�j�c�h�p�d�m�r+�/usr/lib/python3.6/easter.pyrs($",0$)�__doc__r�__all__rrrrr+r+r+r,�<module>sPKa�\�􄩦�)__pycache__/__init__.cpython-36.opt-1.pycnu�[���3

6�cYE�@sddlmZdS)�)�VERSIONN)Z_versionr�__version__�rr�/usr/lib/python3.6/__init__.py�<module>sPKa�\T�O��7�7(__pycache__/relativedelta.cpython-36.pycnu�[���3

6�cYiZ�@s�ddlZddlZddlZddlmZddlmZddlmZddl	m
Z
edd�ed	�D��\Z
ZZZZZZZd
ddd
ddddgZGdd
�d
e�Zdd�ZdS)�N)�copysign)�
integer_types)�warn�)�weekdayccs|]}t|�VqdS)N)r)�.0�x�r	�#/usr/lib/python3.6/relativedelta.py�	<genexpr>
sr��
relativedelta�MO�TU�WE�TH�FR�SA�SUc@s�eZdZdZd%dd�Zdd�Zedd	��Zejd
d	��Zdd�Z	d
d�Z
dd�Zdd�Zdd�Z
dd�Zdd�Zdd�ZeZdd�ZeZdd�ZdZdd �Zd!d"�ZeZd#d$�ZdS)&r
a�
    The relativedelta type is based on the specification of the excellent
    work done by M.-A. Lemburg in his
    `mx.DateTime <http://www.egenix.com/files/python/mxDateTime.html>`_ extension.
    However, notice that this type does *NOT* implement the same algorithm as
    his work. Do *NOT* expect it to behave like mx.DateTime's counterpart.

    There are two different ways to build a relativedelta instance. The
    first one is passing it two date/datetime classes::

        relativedelta(datetime1, datetime2)

    The second one is passing it any number of the following keyword arguments::

        relativedelta(arg1=x,arg2=y,arg3=z...)

        year, month, day, hour, minute, second, microsecond:
            Absolute information (argument is singular); adding or subtracting a
            relativedelta with absolute information does not perform an aritmetic
            operation, but rather REPLACES the corresponding value in the
            original datetime with the value(s) in relativedelta.

        years, months, weeks, days, hours, minutes, seconds, microseconds:
            Relative information, may be negative (argument is plural); adding
            or subtracting a relativedelta with relative information performs
            the corresponding aritmetic operation on the original datetime value
            with the information in the relativedelta.

        weekday:
            One of the weekday instances (MO, TU, etc). These instances may
            receive a parameter N, specifying the Nth weekday, which could
            be positive or negative (like MO(+1) or MO(-2). Not specifying
            it is the same as specifying +1. You can also use an integer,
            where 0=MO.

        leapdays:
            Will add given days to the date found, if year is a leap
            year, and the date found is post 28 of february.

        yearday, nlyearday:
            Set the yearday or the non-leap year day (jump leap days).
            These are converted to day/month/leapdays information.

    Here is the behavior of operations with relativedelta:

    1. Calculate the absolute year, using the 'year' argument, or the
       original datetime year, if the argument is not present.

    2. Add the relative 'years' argument to the absolute year.

    3. Do steps 1 and 2 for month/months.

    4. Calculate the absolute day, using the 'day' argument, or the
       original datetime day, if the argument is not present. Then,
       subtract from the day until it fits in the year and month
       found after their operations.

    5. Add the relative 'days' argument to the absolute day. Notice
       that the 'weeks' argument is multiplied by 7 and added to
       'days'.

    6. Do steps 1 and 2 for hour/hours, minute/minutes, second/seconds,
       microsecond/microseconds.

    7. If the 'weekday' argument is present, calculate the weekday,
       with the given (wday, nth) tuple. wday is the index of the
       weekday (0-6, 0=Mon), and nth is the number of weeks to add
       forward or backward, depending on its signal. Notice that if
       the calculated date is already Monday, for example, using
       (0, 1) or (0, -1) won't change the day.
    NrcCstdd�||fD��rtd��|o$|�r�t|tj�o>t|tj�sHtd��t|tj�t|tj�kr�t|tj�s~tjj|j��}nt|tj�s�tjj|j��}d|_d|_	d|_
d|_d|_d|_
d|_d|_d|_d|_d|_d|_d|_d|_d|_d|_d|_|j|jd|j|j}|j|�|j|�}||k�rFtj}d}n
tj}d}x.|||��r~||7}|j|�|j|�}�qRW||}|j|j
d|_|j|_�nV||_||_	||d	|_
||_||_|	|_
|
|_||_||_|
|_||_||_||_||_||_td
d�||
|||||fD���r4tdt�t|t ��rLt!||_n||_d}|�rb|}n|�r||}|dk�r|d|_|�r�ddddddddddddg}x\t"|�D]D\}}||k�r�|d|_|dk�r�||_n|||d|_P�q�Wtd|��|j#�dS)Ncss"|]}|dk	o|t|�kVqdS)N)�int)rrr	r	r
rcsz)relativedelta.__init__.<locals>.<genexpr>zGNon-integer years and months are ambiguous and not currently supported.z&relativedelta only diffs datetime/dater�ri�Qrcss"|]}|dk	ot|�|kVqdS)N)r)rrr	r	r
r�sz2Non-integer value passed as absolute information. z4This is not a well-defined condition and will raise zerrors in future versions.�;��Z�x������ii0iNinzinvalid year day (%d)���zfNon-integer value passed as absolute information. This is not a well-defined condition and will raise z�Non-integer value passed as absolute information. This is not a well-defined condition and will raise errors in future versions.r)$�any�
ValueError�
isinstance�datetime�date�	TypeError�fromordinal�	toordinal�years�months�days�leapdays�hours�minutes�seconds�microseconds�year�month�dayr�hour�minute�second�microsecond�	_has_time�_set_months�__radd__�operator�gt�ltr�DeprecationWarningr�weekdays�	enumerate�_fix)�selfZdt1Zdt2r(r)r*r+�weeksr,r-r.r/r0r1r2rZyeardayZ	nlyeardayr3r4r5r6ZdtmZcompareZ	incrementZdeltaZydayZydayidx�idxZydaysr	r	r
�__init__[s�









zrelativedelta.__init__cCs�t|j�dkrHt|j�}t|j|d�\}}|||_|j||7_t|j�dkr�t|j�}t|j|d�\}}|||_|j||7_t|j�dkr�t|j�}t|j|d�\}}|||_|j||7_t|j�dk�r"t|j�}t|j|d�\}}|||_|j||7_t|j�dk�rlt|j�}t|j|d�\}}|||_|j	||7_	|j�s�|j�s�|j�s�|j�s�|j
dk	�s�|jdk	�s�|jdk	�s�|j
dk	�r�d	|_nd
|_dS)Ni?Bi@Br�<���rrr)�absr/�_sign�divmodr.r-r,r*r)r(r3r4r5r6r7)rA�s�div�modr	r	r
r@�s<









 zrelativedelta._fixcCs
|jdS)Nr)r*)rAr	r	r
rB�szrelativedelta.weekscCs|j|jd|d|_dS)Nr)r*rB)rA�valuer	r	r
rB�scCsR||_t|j�dkrHt|j�}t|j|d�\}}|||_|||_nd|_dS)NrHrr)r)rIrJrKr()rAr)rLrMrNr	r	r
r8s

zrelativedelta._set_monthsc	Cs�t|j�}t|jd|j|d�}t|�}t|jd||d�}t|�}t|jd||d�}t|�}t|jd||�}|j|j|j	||||||j
|j|j|j
|j|j|j|j|jd�S)aA
        Return a version of this object represented entirely using integer
        values for the relative attributes.

        >>> relativedelta(days=1.5, hours=2).normalized()
        relativedelta(days=1, hours=14)

        :return:
            Returns a :class:`dateutil.relativedelta.relativedelta` object.
        rGrHrE�
�g��.A)r(r)r*r,r-r.r/r+r0r1r2rr3r4r5r6)rr*�roundr,r-r.r/�	__class__r(r)r+r0r1r2rr3r4r5r6)	rAr*Zhours_fr,Z	minutes_fr-Z	seconds_fr.r/r	r	r
�
normalizeds 
zrelativedelta.normalizedc
Cslt|t��r|j|j|j|j|j|j|j|j|j|j|j|j|j|j	|j	|j
p`|j
|jdk	rp|jn|j|jdk	r�|jn|j|j
dk	r�|j
n|j
|jdk	r�|jn|j|jdk	r�|jn|j|jdk	r�|jn|j|jdk	r�|jn|j|jdk	r�|jn|jd�St|tj��rp|j|j|j|j|j|j|j|j|j|j	|j	|j
|j|j|j
|j|j|j|j|jd�St|tj��s�tS|j�r�t|tj��r�tjj|j��}|j�p�|j|j}|j�p�|j}|j�r:dt|j�k�o�dkn�s�t�||j7}|dk�r |d7}|d8}n|dk�r:|d8}|d7}ttj||�d|j
�pV|j
�}|||d�}x*dD]"}t||�}|dk	�rl|||<�qlW|j}|j
�r�|d	k�r�tj |��r�||j
7}|j!f|�tj||j|j|j|j	d
�}	|j�rh|jj|jj"�pd}
}t|�dd}|dk�r<|d|	j�|
d7}n||	j�|
d7}|d9}|	tj|d
�7}	|	S)N)r(r)r*r,r-r.r/r+r0r1r2rr3r4r5r6rr)r0r1r2r3r4r5r6�)r*r,r-r.r/rr)r*)r3r4r5r6r)#r"r
rSr(r)r*r,r-r.r/r+r0r1r2rr3r4r5r6r#Z	timedeltar$�NotImplementedr7r&r'rI�AssertionError�min�calendarZ
monthrange�getattrZisleap�replace�n)
rA�otherr0r1r2�repl�attrrOr*�retrZnthZjumpdaysr	r	r
�__add__/s�










&









zrelativedelta.__add__cCs
|j|�S)N)ra)rAr]r	r	r
r9�szrelativedelta.__radd__cCs|j�j|�S)N)�__neg__r9)rAr]r	r	r
�__rsub__�szrelativedelta.__rsub__cCs
t|t�stS|j|j|j|j|j|j|j|j|j|j|j|j	|j	|j
|j
|jpb|j|jdk	rr|jn|j|j
dk	r�|j
n|j
|jdk	r�|jn|j|jdk	r�|jn|j|jdk	r�|jn|j|jdk	r�|jn|j|jdk	r�|jn|j|jdk	�r|jn|jd�S)N)r(r)r*r,r-r.r/r+r0r1r2rr3r4r5r6)r"r
rVrSr(r)r*r,r-r.r/r+r0r1r2rr3r4r5r6)rAr]r	r	r
�__sub__�s6







zrelativedelta.__sub__cCsX|j|j|j|j|j|j|j|j|j|j	|j
|j|j|j
|j|j|jd�S)N)r(r)r*r,r-r.r/r+r0r1r2rr3r4r5r6)rSr(r)r*r,r-r.r/r+r0r1r2rr3r4r5r6)rAr	r	r
rb�s 
zrelativedelta.__neg__cCs�|jo�|jo�|jo�|jo�|jo�|jo�|jo�|jo�|jdko�|j	dko�|j
dko�|jdko�|jdko�|j
dko�|jdko�|jdkS)N)r(r)r*r,r-r.r/r+r0r1r2rr3r4r5r6)rAr	r	r
�__bool__�s 






zrelativedelta.__bool__cCs�yt|�}Wntk
r tSX|jt|j|�t|j|�t|j|�t|j|�t|j	|�t|j
|�t|j|�|j|j
|j|j|j|j|j|j|jd�S)N)r(r)r*r,r-r.r/r+r0r1r2rr3r4r5r6)�floatr%rVrSrr(r)r*r,r-r.r/r+r0r1r2rr3r4r5r6)rAr]�fr	r	r
�__mul__�s(zrelativedelta.__mul__cCsNt|t�stS|js|jr~|js*|jr.dS|jj|jjkrBdS|jj|jj}}||kr~|sj|dkov|pv|dkr~dS|j|jk�oL|j|jk�oL|j|jk�oL|j|jk�oL|j	|j	k�oL|j
|j
k�oL|j|jk�oL|j|jk�oL|j
|j
k�oL|j|jk�oL|j|jk�oL|j|jk�oL|j|jk�oL|j|jk�oL|j|jkS)NFr)r"r
rVrr\r(r)r*r,r-r.r/r+r0r1r2r3r4r5r6)rAr]Zn1Zn2r	r	r
�__eq__�s2
&zrelativedelta.__eq__cCs|j|�S)N)ri)rAr]r	r	r
�__ne__szrelativedelta.__ne__cCs0ydt|�}Wntk
r$tSX|j|�S)Nr)rfr%rVrh)rAr]Z
reciprocalr	r	r
�__div__s
zrelativedelta.__div__cCs�g}x.dD]&}t||�}|r
|jd	j||d
��q
Wx6dD].}t||�}|dk	r:|jdj|t|�d
��q:Wdj|jjdj|�d�S)Nr(r)r*r+r,r-r.r/z{attr}={value:+g})r_rOr0r1r2rr3r4r5r6z{attr}={value}z{classname}({attrs})z, )Z	classnameZattrs)r(r)r*r+r,r-r.r/)r0r1r2rr3r4r5r6)rZ�append�format�reprrS�__name__�join)rA�lr_rOr	r	r
�__repr__s


zrelativedelta.__repr__)NNrrrrrrrrrNNNNNNNNNN)ro�
__module__�__qualname__�__doc__rDr@�propertyrB�setterr8rTrar9rcrdrbreZ__nonzero__rh�__rmul__ri�__hash__rjrk�__truediv__rrr	r	r	r
r
s6G
y!
#WcCsttd|��S)Nr)rr)rr	r	r
rJ"srJ)r#rYr:ZmathrZsixr�warningsrZ_commonr�tuple�rangerrrrrrrr>�__all__�objectr
rJr	r	r	r
�<module>s(PKa�\v=��ee(__pycache__/_common.cpython-36.opt-1.pycnu�[���3

6�cY�@sdZGdd�de�ZdS)z'
Common code used in multiple modules.
c@s:eZdZddgZddd�Zdd�Zdd�ZdZd	d
�ZdS)�weekday�nNcCs||_||_dS)N)rr)�selfrr�r�/usr/lib/python3.6/_common.py�__init__	szweekday.__init__cCs ||jkr|S|j|j|�SdS)N)r�	__class__r)rrrrr�__call__
s
zweekday.__call__cCs:y |j|jks|j|jkrdSWntk
r4dSXdS)NFT)rr�AttributeError)r�otherrrr�__eq__szweekday.__eq__cCs&d	|j}|js|Sd||jfSdS)
N�MO�TU�WE�TH�FR�SA�SUz%s(%+d))rr
rrrrr)rr)r�srrr�__repr__s
zweekday.__repr__)N)	�__name__�
__module__�__qualname__�	__slots__rrr�__hash__rrrrrrs
rN)�__doc__�objectrrrrr�<module>sPKa�\�ol��7�7.__pycache__/relativedelta.cpython-36.opt-1.pycnu�[���3

6�cYiZ�@s�ddlZddlZddlZddlmZddlmZddlmZddl	m
Z
edd�ed	�D��\Z
ZZZZZZZd
ddd
ddddgZGdd
�d
e�Zdd�ZdS)�N)�copysign)�
integer_types)�warn�)�weekdayccs|]}t|�VqdS)N)r)�.0�x�r	�#/usr/lib/python3.6/relativedelta.py�	<genexpr>
sr��
relativedelta�MO�TU�WE�TH�FR�SA�SUc@s�eZdZdZd%dd�Zdd�Zedd	��Zejd
d	��Zdd�Z	d
d�Z
dd�Zdd�Zdd�Z
dd�Zdd�Zdd�ZeZdd�ZeZdd�ZdZdd �Zd!d"�ZeZd#d$�ZdS)&r
a�
    The relativedelta type is based on the specification of the excellent
    work done by M.-A. Lemburg in his
    `mx.DateTime <http://www.egenix.com/files/python/mxDateTime.html>`_ extension.
    However, notice that this type does *NOT* implement the same algorithm as
    his work. Do *NOT* expect it to behave like mx.DateTime's counterpart.

    There are two different ways to build a relativedelta instance. The
    first one is passing it two date/datetime classes::

        relativedelta(datetime1, datetime2)

    The second one is passing it any number of the following keyword arguments::

        relativedelta(arg1=x,arg2=y,arg3=z...)

        year, month, day, hour, minute, second, microsecond:
            Absolute information (argument is singular); adding or subtracting a
            relativedelta with absolute information does not perform an aritmetic
            operation, but rather REPLACES the corresponding value in the
            original datetime with the value(s) in relativedelta.

        years, months, weeks, days, hours, minutes, seconds, microseconds:
            Relative information, may be negative (argument is plural); adding
            or subtracting a relativedelta with relative information performs
            the corresponding aritmetic operation on the original datetime value
            with the information in the relativedelta.

        weekday:
            One of the weekday instances (MO, TU, etc). These instances may
            receive a parameter N, specifying the Nth weekday, which could
            be positive or negative (like MO(+1) or MO(-2). Not specifying
            it is the same as specifying +1. You can also use an integer,
            where 0=MO.

        leapdays:
            Will add given days to the date found, if year is a leap
            year, and the date found is post 28 of february.

        yearday, nlyearday:
            Set the yearday or the non-leap year day (jump leap days).
            These are converted to day/month/leapdays information.

    Here is the behavior of operations with relativedelta:

    1. Calculate the absolute year, using the 'year' argument, or the
       original datetime year, if the argument is not present.

    2. Add the relative 'years' argument to the absolute year.

    3. Do steps 1 and 2 for month/months.

    4. Calculate the absolute day, using the 'day' argument, or the
       original datetime day, if the argument is not present. Then,
       subtract from the day until it fits in the year and month
       found after their operations.

    5. Add the relative 'days' argument to the absolute day. Notice
       that the 'weeks' argument is multiplied by 7 and added to
       'days'.

    6. Do steps 1 and 2 for hour/hours, minute/minutes, second/seconds,
       microsecond/microseconds.

    7. If the 'weekday' argument is present, calculate the weekday,
       with the given (wday, nth) tuple. wday is the index of the
       weekday (0-6, 0=Mon), and nth is the number of weeks to add
       forward or backward, depending on its signal. Notice that if
       the calculated date is already Monday, for example, using
       (0, 1) or (0, -1) won't change the day.
    NrcCstdd�||fD��rtd��|o$|�r�t|tj�o>t|tj�sHtd��t|tj�t|tj�kr�t|tj�s~tjj|j��}nt|tj�s�tjj|j��}d|_d|_	d|_
d|_d|_d|_
d|_d|_d|_d|_d|_d|_d|_d|_d|_d|_d|_|j|jd|j|j}|j|�|j|�}||k�rFtj}d}n
tj}d}x.|||��r~||7}|j|�|j|�}�qRW||}|j|j
d|_|j|_�nV||_||_	||d	|_
||_||_|	|_
|
|_||_||_|
|_||_||_||_||_||_td
d�||
|||||fD���r4tdt�t|t ��rLt!||_n||_d}|�rb|}n|�r||}|dk�r|d|_|�r�ddddddddddddg}x\t"|�D]D\}}||k�r�|d|_|dk�r�||_n|||d|_P�q�Wtd|��|j#�dS)Ncss"|]}|dk	o|t|�kVqdS)N)�int)rrr	r	r
rcsz)relativedelta.__init__.<locals>.<genexpr>zGNon-integer years and months are ambiguous and not currently supported.z&relativedelta only diffs datetime/dater�ri�Qrcss"|]}|dk	ot|�|kVqdS)N)r)rrr	r	r
r�sz2Non-integer value passed as absolute information. z4This is not a well-defined condition and will raise zerrors in future versions.�;��Z�x������ii0iNinzinvalid year day (%d)���zfNon-integer value passed as absolute information. This is not a well-defined condition and will raise z�Non-integer value passed as absolute information. This is not a well-defined condition and will raise errors in future versions.r)$�any�
ValueError�
isinstance�datetime�date�	TypeError�fromordinal�	toordinal�years�months�days�leapdays�hours�minutes�seconds�microseconds�year�month�dayr�hour�minute�second�microsecond�	_has_time�_set_months�__radd__�operator�gt�ltr�DeprecationWarningr�weekdays�	enumerate�_fix)�selfZdt1Zdt2r(r)r*r+�weeksr,r-r.r/r0r1r2rZyeardayZ	nlyeardayr3r4r5r6ZdtmZcompareZ	incrementZdeltaZydayZydayidx�idxZydaysr	r	r
�__init__[s�









zrelativedelta.__init__cCs�t|j�dkrHt|j�}t|j|d�\}}|||_|j||7_t|j�dkr�t|j�}t|j|d�\}}|||_|j||7_t|j�dkr�t|j�}t|j|d�\}}|||_|j||7_t|j�dk�r"t|j�}t|j|d�\}}|||_|j||7_t|j�dk�rlt|j�}t|j|d�\}}|||_|j	||7_	|j�s�|j�s�|j�s�|j�s�|j
dk	�s�|jdk	�s�|jdk	�s�|j
dk	�r�d	|_nd
|_dS)Ni?Bi@Br�<���rrr)�absr/�_sign�divmodr.r-r,r*r)r(r3r4r5r6r7)rA�s�div�modr	r	r
r@�s<









 zrelativedelta._fixcCs
|jdS)Nr)r*)rAr	r	r
rB�szrelativedelta.weekscCs|j|jd|d|_dS)Nr)r*rB)rA�valuer	r	r
rB�scCsR||_t|j�dkrHt|j�}t|j|d�\}}|||_|||_nd|_dS)NrHrr)r)rIrJrKr()rAr)rLrMrNr	r	r
r8s

zrelativedelta._set_monthsc	Cs�t|j�}t|jd|j|d�}t|�}t|jd||d�}t|�}t|jd||d�}t|�}t|jd||�}|j|j|j	||||||j
|j|j|j
|j|j|j|j|jd�S)aA
        Return a version of this object represented entirely using integer
        values for the relative attributes.

        >>> relativedelta(days=1.5, hours=2).normalized()
        relativedelta(days=1, hours=14)

        :return:
            Returns a :class:`dateutil.relativedelta.relativedelta` object.
        rGrHrE�
�g��.A)r(r)r*r,r-r.r/r+r0r1r2rr3r4r5r6)rr*�roundr,r-r.r/�	__class__r(r)r+r0r1r2rr3r4r5r6)	rAr*Zhours_fr,Z	minutes_fr-Z	seconds_fr.r/r	r	r
�
normalizeds 
zrelativedelta.normalizedc
CsFt|t��r|j|j|j|j|j|j|j|j|j|j|j|j|j|j	|j	|j
p`|j
|jdk	rp|jn|j|jdk	r�|jn|j|j
dk	r�|j
n|j
|jdk	r�|jn|j|jdk	r�|jn|j|jdk	r�|jn|j|jdk	r�|jn|j|jdk	r�|jn|jd�St|tj��rp|j|j|j|j|j|j|j|j|j|j	|j	|j
|j|j|j
|j|j|j|j|jd�St|tj��s�tS|j�r�t|tj��r�tjj|j��}|j�p�|j|j}|j�p�|j}|j�r||j7}|dk�r�|d7}|d8}n|dk�r|d8}|d7}ttj||�d|j
�p0|j
�}|||d�}x*dD]"}t||�}|dk	�rF|||<�qFW|j}|j
�r�|d	k�r�tj|��r�||j
7}|jf|�tj||j|j|j|j	d
�}	|j�rB|jj|jj �p�d}
}t!|�dd}|dk�r|d|	j�|
d7}n||	j�|
d7}|d9}|	tj|d
�7}	|	S)N)r(r)r*r,r-r.r/r+r0r1r2rr3r4r5r6rr)r0r1r2r3r4r5r6�)r*r,r-r.r/rr)r*)r3r4r5r6r)"r"r
rSr(r)r*r,r-r.r/r+r0r1r2rr3r4r5r6r#Z	timedeltar$�NotImplementedr7r&r'�min�calendarZ
monthrange�getattrZisleap�replace�nrI)
rA�otherr0r1r2�repl�attrrOr*�retrZnthZjumpdaysr	r	r
�__add__/s�




















zrelativedelta.__add__cCs
|j|�S)N)r`)rAr\r	r	r
r9�szrelativedelta.__radd__cCs|j�j|�S)N)�__neg__r9)rAr\r	r	r
�__rsub__�szrelativedelta.__rsub__cCs
t|t�stS|j|j|j|j|j|j|j|j|j|j|j|j	|j	|j
|j
|jpb|j|jdk	rr|jn|j|j
dk	r�|j
n|j
|jdk	r�|jn|j|jdk	r�|jn|j|jdk	r�|jn|j|jdk	r�|jn|j|jdk	r�|jn|j|jdk	�r|jn|jd�S)N)r(r)r*r,r-r.r/r+r0r1r2rr3r4r5r6)r"r
rVrSr(r)r*r,r-r.r/r+r0r1r2rr3r4r5r6)rAr\r	r	r
�__sub__�s6







zrelativedelta.__sub__cCsX|j|j|j|j|j|j|j|j|j|j	|j
|j|j|j
|j|j|jd�S)N)r(r)r*r,r-r.r/r+r0r1r2rr3r4r5r6)rSr(r)r*r,r-r.r/r+r0r1r2rr3r4r5r6)rAr	r	r
ra�s 
zrelativedelta.__neg__cCs�|jo�|jo�|jo�|jo�|jo�|jo�|jo�|jo�|jdko�|j	dko�|j
dko�|jdko�|jdko�|j
dko�|jdko�|jdkS)N)r(r)r*r,r-r.r/r+r0r1r2rr3r4r5r6)rAr	r	r
�__bool__�s 






zrelativedelta.__bool__cCs�yt|�}Wntk
r tSX|jt|j|�t|j|�t|j|�t|j|�t|j	|�t|j
|�t|j|�|j|j
|j|j|j|j|j|j|jd�S)N)r(r)r*r,r-r.r/r+r0r1r2rr3r4r5r6)�floatr%rVrSrr(r)r*r,r-r.r/r+r0r1r2rr3r4r5r6)rAr\�fr	r	r
�__mul__�s(zrelativedelta.__mul__cCsNt|t�stS|js|jr~|js*|jr.dS|jj|jjkrBdS|jj|jj}}||kr~|sj|dkov|pv|dkr~dS|j|jk�oL|j|jk�oL|j|jk�oL|j|jk�oL|j	|j	k�oL|j
|j
k�oL|j|jk�oL|j|jk�oL|j
|j
k�oL|j|jk�oL|j|jk�oL|j|jk�oL|j|jk�oL|j|jk�oL|j|jkS)NFr)r"r
rVrr[r(r)r*r,r-r.r/r+r0r1r2r3r4r5r6)rAr\Zn1Zn2r	r	r
�__eq__�s2
&zrelativedelta.__eq__cCs|j|�S)N)rh)rAr\r	r	r
�__ne__szrelativedelta.__ne__cCs0ydt|�}Wntk
r$tSX|j|�S)Nr)rer%rVrg)rAr\Z
reciprocalr	r	r
�__div__s
zrelativedelta.__div__cCs�g}x.dD]&}t||�}|r
|jd	j||d
��q
Wx6dD].}t||�}|dk	r:|jdj|t|�d
��q:Wdj|jjdj|�d�S)Nr(r)r*r+r,r-r.r/z{attr}={value:+g})r^rOr0r1r2rr3r4r5r6z{attr}={value}z{classname}({attrs})z, )Z	classnameZattrs)r(r)r*r+r,r-r.r/)r0r1r2rr3r4r5r6)rY�append�format�reprrS�__name__�join)rA�lr^rOr	r	r
�__repr__s


zrelativedelta.__repr__)NNrrrrrrrrrNNNNNNNNNN)rn�
__module__�__qualname__�__doc__rDr@�propertyrB�setterr8rTr`r9rbrcrardZ__nonzero__rg�__rmul__rh�__hash__rirj�__truediv__rqr	r	r	r
r
s6G
y!
#WcCsttd|��S)Nr)rr)rr	r	r
rJ"srJ)r#rXr:ZmathrZsixr�warningsrZ_commonr�tuple�rangerrrrrrrr>�__all__�objectr
rJr	r	r	r
�<module>s(PKa�\v=��ee"__pycache__/_common.cpython-36.pycnu�[���3

6�cY�@sdZGdd�de�ZdS)z'
Common code used in multiple modules.
c@s:eZdZddgZddd�Zdd�Zdd�ZdZd	d
�ZdS)�weekday�nNcCs||_||_dS)N)rr)�selfrr�r�/usr/lib/python3.6/_common.py�__init__	szweekday.__init__cCs ||jkr|S|j|j|�SdS)N)r�	__class__r)rrrrr�__call__
s
zweekday.__call__cCs:y |j|jks|j|jkrdSWntk
r4dSXdS)NFT)rr�AttributeError)r�otherrrr�__eq__szweekday.__eq__cCs&d	|j}|js|Sd||jfSdS)
N�MO�TU�WE�TH�FR�SA�SUz%s(%+d))rr
rrrrr)rr)r�srrr�__repr__s
zweekday.__repr__)N)	�__name__�
__module__�__qualname__�	__slots__rrr�__hash__rrrrrrs
rN)�__doc__�objectrrrrr�<module>sPKa�\��L�
_common.pynu�[���"""
Common code used in multiple modules.
"""


class weekday(object):
    __slots__ = ["weekday", "n"]

    def __init__(self, weekday, n=None):
        self.weekday = weekday
        self.n = n

    def __call__(self, n):
        if n == self.n:
            return self
        else:
            return self.__class__(self.weekday, n)

    def __eq__(self, other):
        try:
            if self.weekday != other.weekday or self.n != other.n:
                return False
        except AttributeError:
            return False
        return True

    __hash__ = None

    def __repr__(self):
        s = ("MO", "TU", "WE", "TH", "FR", "SA", "SU")[self.weekday]
        if not self.n:
            return s
        else:
            return "%s(%+d)" % (s, self.n)
PKa�\�9�;;tzwin.pynu�[���# tzwin has moved to dateutil.tz.win
from .tz.win import *
PKa�\�,�EE__init__.pynu�[���# -*- coding: utf-8 -*-
from ._version import VERSION as __version__
PKa�\�	/�����rrule.pynu�[���# -*- coding: utf-8 -*-
"""
The rrule module offers a small, complete, and very fast, implementation of
the recurrence rules documented in the
`iCalendar RFC <http://www.ietf.org/rfc/rfc2445.txt>`_,
including support for caching of results.
"""
import itertools
import datetime
import calendar
import sys

try:
    from math import gcd
except ImportError:
    from fractions import gcd

from six import advance_iterator, integer_types
from six.moves import _thread, range
import heapq

from ._common import weekday as weekdaybase

# For warning about deprecation of until and count
from warnings import warn

__all__ = ["rrule", "rruleset", "rrulestr",
           "YEARLY", "MONTHLY", "WEEKLY", "DAILY",
           "HOURLY", "MINUTELY", "SECONDLY",
           "MO", "TU", "WE", "TH", "FR", "SA", "SU"]

# Every mask is 7 days longer to handle cross-year weekly periods.
M366MASK = tuple([1]*31+[2]*29+[3]*31+[4]*30+[5]*31+[6]*30 +
                 [7]*31+[8]*31+[9]*30+[10]*31+[11]*30+[12]*31+[1]*7)
M365MASK = list(M366MASK)
M29, M30, M31 = list(range(1, 30)), list(range(1, 31)), list(range(1, 32))
MDAY366MASK = tuple(M31+M29+M31+M30+M31+M30+M31+M31+M30+M31+M30+M31+M31[:7])
MDAY365MASK = list(MDAY366MASK)
M29, M30, M31 = list(range(-29, 0)), list(range(-30, 0)), list(range(-31, 0))
NMDAY366MASK = tuple(M31+M29+M31+M30+M31+M30+M31+M31+M30+M31+M30+M31+M31[:7])
NMDAY365MASK = list(NMDAY366MASK)
M366RANGE = (0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335, 366)
M365RANGE = (0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334, 365)
WDAYMASK = [0, 1, 2, 3, 4, 5, 6]*55
del M29, M30, M31, M365MASK[59], MDAY365MASK[59], NMDAY365MASK[31]
MDAY365MASK = tuple(MDAY365MASK)
M365MASK = tuple(M365MASK)

FREQNAMES = ['YEARLY', 'MONTHLY', 'WEEKLY', 'DAILY', 'HOURLY', 'MINUTELY', 'SECONDLY']

(YEARLY,
 MONTHLY,
 WEEKLY,
 DAILY,
 HOURLY,
 MINUTELY,
 SECONDLY) = list(range(7))

# Imported on demand.
easter = None
parser = None


class weekday(weekdaybase):
    """
    This version of weekday does not allow n = 0.
    """
    def __init__(self, wkday, n=None):
        if n == 0:
            raise ValueError("Can't create weekday with n==0")

        super(weekday, self).__init__(wkday, n)


MO, TU, WE, TH, FR, SA, SU = weekdays = tuple(weekday(x) for x in range(7))


def _invalidates_cache(f):
    """
    Decorator for rruleset methods which may invalidate the
    cached length.
    """
    def inner_func(self, *args, **kwargs):
        rv = f(self, *args, **kwargs)
        self._invalidate_cache()
        return rv

    return inner_func


class rrulebase(object):
    def __init__(self, cache=False):
        if cache:
            self._cache = []
            self._cache_lock = _thread.allocate_lock()
            self._invalidate_cache()
        else:
            self._cache = None
            self._cache_complete = False
            self._len = None

    def __iter__(self):
        if self._cache_complete:
            return iter(self._cache)
        elif self._cache is None:
            return self._iter()
        else:
            return self._iter_cached()

    def _invalidate_cache(self):
        if self._cache is not None:
            self._cache = []
            self._cache_complete = False
            self._cache_gen = self._iter()

            if self._cache_lock.locked():
                self._cache_lock.release()

        self._len = None

    def _iter_cached(self):
        i = 0
        gen = self._cache_gen
        cache = self._cache
        acquire = self._cache_lock.acquire
        release = self._cache_lock.release
        while gen:
            if i == len(cache):
                acquire()
                if self._cache_complete:
                    break
                try:
                    for j in range(10):
                        cache.append(advance_iterator(gen))
                except StopIteration:
                    self._cache_gen = gen = None
                    self._cache_complete = True
                    break
                release()
            yield cache[i]
            i += 1
        while i < self._len:
            yield cache[i]
            i += 1

    def __getitem__(self, item):
        if self._cache_complete:
            return self._cache[item]
        elif isinstance(item, slice):
            if item.step and item.step < 0:
                return list(iter(self))[item]
            else:
                return list(itertools.islice(self,
                                             item.start or 0,
                                             item.stop or sys.maxsize,
                                             item.step or 1))
        elif item >= 0:
            gen = iter(self)
            try:
                for i in range(item+1):
                    res = advance_iterator(gen)
            except StopIteration:
                raise IndexError
            return res
        else:
            return list(iter(self))[item]

    def __contains__(self, item):
        if self._cache_complete:
            return item in self._cache
        else:
            for i in self:
                if i == item:
                    return True
                elif i > item:
                    return False
        return False

    # __len__() introduces a large performance penality.
    def count(self):
        """ Returns the number of recurrences in this set. It will have go
            trough the whole recurrence, if this hasn't been done before. """
        if self._len is None:
            for x in self:
                pass
        return self._len

    def before(self, dt, inc=False):
        """ Returns the last recurrence before the given datetime instance. The
            inc keyword defines what happens if dt is an occurrence. With
            inc=True, if dt itself is an occurrence, it will be returned. """
        if self._cache_complete:
            gen = self._cache
        else:
            gen = self
        last = None
        if inc:
            for i in gen:
                if i > dt:
                    break
                last = i
        else:
            for i in gen:
                if i >= dt:
                    break
                last = i
        return last

    def after(self, dt, inc=False):
        """ Returns the first recurrence after the given datetime instance. The
            inc keyword defines what happens if dt is an occurrence. With
            inc=True, if dt itself is an occurrence, it will be returned.  """
        if self._cache_complete:
            gen = self._cache
        else:
            gen = self
        if inc:
            for i in gen:
                if i >= dt:
                    return i
        else:
            for i in gen:
                if i > dt:
                    return i
        return None

    def xafter(self, dt, count=None, inc=False):
        """
        Generator which yields up to `count` recurrences after the given
        datetime instance, equivalent to `after`.

        :param dt:
            The datetime at which to start generating recurrences.

        :param count:
            The maximum number of recurrences to generate. If `None` (default),
            dates are generated until the recurrence rule is exhausted.

        :param inc:
            If `dt` is an instance of the rule and `inc` is `True`, it is
            included in the output.

        :yields: Yields a sequence of `datetime` objects.
        """

        if self._cache_complete:
            gen = self._cache
        else:
            gen = self

        # Select the comparison function
        if inc:
            comp = lambda dc, dtc: dc >= dtc
        else:
            comp = lambda dc, dtc: dc > dtc

        # Generate dates
        n = 0
        for d in gen:
            if comp(d, dt):
                if count is not None:
                    n += 1
                    if n > count:
                        break

                yield d

    def between(self, after, before, inc=False, count=1):
        """ Returns all the occurrences of the rrule between after and before.
        The inc keyword defines what happens if after and/or before are
        themselves occurrences. With inc=True, they will be included in the
        list, if they are found in the recurrence set. """
        if self._cache_complete:
            gen = self._cache
        else:
            gen = self
        started = False
        l = []
        if inc:
            for i in gen:
                if i > before:
                    break
                elif not started:
                    if i >= after:
                        started = True
                        l.append(i)
                else:
                    l.append(i)
        else:
            for i in gen:
                if i >= before:
                    break
                elif not started:
                    if i > after:
                        started = True
                        l.append(i)
                else:
                    l.append(i)
        return l


class rrule(rrulebase):
    """
    That's the base of the rrule operation. It accepts all the keywords
    defined in the RFC as its constructor parameters (except byday,
    which was renamed to byweekday) and more. The constructor prototype is::

            rrule(freq)

    Where freq must be one of YEARLY, MONTHLY, WEEKLY, DAILY, HOURLY, MINUTELY,
    or SECONDLY.

    .. note::
        Per RFC section 3.3.10, recurrence instances falling on invalid dates
        and times are ignored rather than coerced:

            Recurrence rules may generate recurrence instances with an invalid
            date (e.g., February 30) or nonexistent local time (e.g., 1:30 AM
            on a day where the local time is moved forward by an hour at 1:00
            AM).  Such recurrence instances MUST be ignored and MUST NOT be
            counted as part of the recurrence set.

        This can lead to possibly surprising behavior when, for example, the
        start date occurs at the end of the month:

        >>> from dateutil.rrule import rrule, MONTHLY
        >>> from datetime import datetime
        >>> start_date = datetime(2014, 12, 31)
        >>> list(rrule(freq=MONTHLY, count=4, dtstart=start_date))
        ... # doctest: +NORMALIZE_WHITESPACE
        [datetime.datetime(2014, 12, 31, 0, 0),
         datetime.datetime(2015, 1, 31, 0, 0),
         datetime.datetime(2015, 3, 31, 0, 0),
         datetime.datetime(2015, 5, 31, 0, 0)]

    Additionally, it supports the following keyword arguments:

    :param cache:
        If given, it must be a boolean value specifying to enable or disable
        caching of results. If you will use the same rrule instance multiple
        times, enabling caching will improve the performance considerably.
    :param dtstart:
        The recurrence start. Besides being the base for the recurrence,
        missing parameters in the final recurrence instances will also be
        extracted from this date. If not given, datetime.now() will be used
        instead.
    :param interval:
        The interval between each freq iteration. For example, when using
        YEARLY, an interval of 2 means once every two years, but with HOURLY,
        it means once every two hours. The default interval is 1.
    :param wkst:
        The week start day. Must be one of the MO, TU, WE constants, or an
        integer, specifying the first day of the week. This will affect
        recurrences based on weekly periods. The default week start is got
        from calendar.firstweekday(), and may be modified by
        calendar.setfirstweekday().
    :param count:
        How many occurrences will be generated.

        .. note::
            As of version 2.5.0, the use of the ``until`` keyword together
            with the ``count`` keyword is deprecated per RFC-2445 Sec. 4.3.10.
    :param until:
        If given, this must be a datetime instance, that will specify the
        limit of the recurrence. The last recurrence in the rule is the greatest
        datetime that is less than or equal to the value specified in the
        ``until`` parameter.

        .. note::
            As of version 2.5.0, the use of the ``until`` keyword together
            with the ``count`` keyword is deprecated per RFC-2445 Sec. 4.3.10.
    :param bysetpos:
        If given, it must be either an integer, or a sequence of integers,
        positive or negative. Each given integer will specify an occurrence
        number, corresponding to the nth occurrence of the rule inside the
        frequency period. For example, a bysetpos of -1 if combined with a
        MONTHLY frequency, and a byweekday of (MO, TU, WE, TH, FR), will
        result in the last work day of every month.
    :param bymonth:
        If given, it must be either an integer, or a sequence of integers,
        meaning the months to apply the recurrence to.
    :param bymonthday:
        If given, it must be either an integer, or a sequence of integers,
        meaning the month days to apply the recurrence to.
    :param byyearday:
        If given, it must be either an integer, or a sequence of integers,
        meaning the year days to apply the recurrence to.
    :param byweekno:
        If given, it must be either an integer, or a sequence of integers,
        meaning the week numbers to apply the recurrence to. Week numbers
        have the meaning described in ISO8601, that is, the first week of
        the year is that containing at least four days of the new year.
    :param byweekday:
        If given, it must be either an integer (0 == MO), a sequence of
        integers, one of the weekday constants (MO, TU, etc), or a sequence
        of these constants. When given, these variables will define the
        weekdays where the recurrence will be applied. It's also possible to
        use an argument n for the weekday instances, which will mean the nth
        occurrence of this weekday in the period. For example, with MONTHLY,
        or with YEARLY and BYMONTH, using FR(+1) in byweekday will specify the
        first friday of the month where the recurrence happens. Notice that in
        the RFC documentation, this is specified as BYDAY, but was renamed to
        avoid the ambiguity of that keyword.
    :param byhour:
        If given, it must be either an integer, or a sequence of integers,
        meaning the hours to apply the recurrence to.
    :param byminute:
        If given, it must be either an integer, or a sequence of integers,
        meaning the minutes to apply the recurrence to.
    :param bysecond:
        If given, it must be either an integer, or a sequence of integers,
        meaning the seconds to apply the recurrence to.
    :param byeaster:
        If given, it must be either an integer, or a sequence of integers,
        positive or negative. Each integer will define an offset from the
        Easter Sunday. Passing the offset 0 to byeaster will yield the Easter
        Sunday itself. This is an extension to the RFC specification.
     """
    def __init__(self, freq, dtstart=None,
                 interval=1, wkst=None, count=None, until=None, bysetpos=None,
                 bymonth=None, bymonthday=None, byyearday=None, byeaster=None,
                 byweekno=None, byweekday=None,
                 byhour=None, byminute=None, bysecond=None,
                 cache=False):
        super(rrule, self).__init__(cache)
        global easter
        if not dtstart:
            dtstart = datetime.datetime.now().replace(microsecond=0)
        elif not isinstance(dtstart, datetime.datetime):
            dtstart = datetime.datetime.fromordinal(dtstart.toordinal())
        else:
            dtstart = dtstart.replace(microsecond=0)
        self._dtstart = dtstart
        self._tzinfo = dtstart.tzinfo
        self._freq = freq
        self._interval = interval
        self._count = count

        # Cache the original byxxx rules, if they are provided, as the _byxxx
        # attributes do not necessarily map to the inputs, and this can be
        # a problem in generating the strings. Only store things if they've
        # been supplied (the string retrieval will just use .get())
        self._original_rule = {}

        if until and not isinstance(until, datetime.datetime):
            until = datetime.datetime.fromordinal(until.toordinal())
        self._until = until

        if count is not None and until:
            warn("Using both 'count' and 'until' is inconsistent with RFC 2445"
                 " and has been deprecated in dateutil. Future versions will "
                 "raise an error.", DeprecationWarning)

        if wkst is None:
            self._wkst = calendar.firstweekday()
        elif isinstance(wkst, integer_types):
            self._wkst = wkst
        else:
            self._wkst = wkst.weekday

        if bysetpos is None:
            self._bysetpos = None
        elif isinstance(bysetpos, integer_types):
            if bysetpos == 0 or not (-366 <= bysetpos <= 366):
                raise ValueError("bysetpos must be between 1 and 366, "
                                 "or between -366 and -1")
            self._bysetpos = (bysetpos,)
        else:
            self._bysetpos = tuple(bysetpos)
            for pos in self._bysetpos:
                if pos == 0 or not (-366 <= pos <= 366):
                    raise ValueError("bysetpos must be between 1 and 366, "
                                     "or between -366 and -1")

        if self._bysetpos:
            self._original_rule['bysetpos'] = self._bysetpos

        if (byweekno is None and byyearday is None and bymonthday is None and
                byweekday is None and byeaster is None):
            if freq == YEARLY:
                if bymonth is None:
                    bymonth = dtstart.month
                    self._original_rule['bymonth'] = None
                bymonthday = dtstart.day
                self._original_rule['bymonthday'] = None
            elif freq == MONTHLY:
                bymonthday = dtstart.day
                self._original_rule['bymonthday'] = None
            elif freq == WEEKLY:
                byweekday = dtstart.weekday()
                self._original_rule['byweekday'] = None

        # bymonth
        if bymonth is None:
            self._bymonth = None
        else:
            if isinstance(bymonth, integer_types):
                bymonth = (bymonth,)

            self._bymonth = tuple(sorted(set(bymonth)))

            if 'bymonth' not in self._original_rule:
                self._original_rule['bymonth'] = self._bymonth

        # byyearday
        if byyearday is None:
            self._byyearday = None
        else:
            if isinstance(byyearday, integer_types):
                byyearday = (byyearday,)

            self._byyearday = tuple(sorted(set(byyearday)))
            self._original_rule['byyearday'] = self._byyearday

        # byeaster
        if byeaster is not None:
            if not easter:
                from dateutil import easter
            if isinstance(byeaster, integer_types):
                self._byeaster = (byeaster,)
            else:
                self._byeaster = tuple(sorted(byeaster))

            self._original_rule['byeaster'] = self._byeaster
        else:
            self._byeaster = None

        # bymonthday
        if bymonthday is None:
            self._bymonthday = ()
            self._bynmonthday = ()
        else:
            if isinstance(bymonthday, integer_types):
                bymonthday = (bymonthday,)

            bymonthday = set(bymonthday)            # Ensure it's unique

            self._bymonthday = tuple(sorted(x for x in bymonthday if x > 0))
            self._bynmonthday = tuple(sorted(x for x in bymonthday if x < 0))

            # Storing positive numbers first, then negative numbers
            if 'bymonthday' not in self._original_rule:
                self._original_rule['bymonthday'] = tuple(
                    itertools.chain(self._bymonthday, self._bynmonthday))

        # byweekno
        if byweekno is None:
            self._byweekno = None
        else:
            if isinstance(byweekno, integer_types):
                byweekno = (byweekno,)

            self._byweekno = tuple(sorted(set(byweekno)))

            self._original_rule['byweekno'] = self._byweekno

        # byweekday / bynweekday
        if byweekday is None:
            self._byweekday = None
            self._bynweekday = None
        else:
            # If it's one of the valid non-sequence types, convert to a
            # single-element sequence before the iterator that builds the
            # byweekday set.
            if isinstance(byweekday, integer_types) or hasattr(byweekday, "n"):
                byweekday = (byweekday,)

            self._byweekday = set()
            self._bynweekday = set()
            for wday in byweekday:
                if isinstance(wday, integer_types):
                    self._byweekday.add(wday)
                elif not wday.n or freq > MONTHLY:
                    self._byweekday.add(wday.weekday)
                else:
                    self._bynweekday.add((wday.weekday, wday.n))

            if not self._byweekday:
                self._byweekday = None
            elif not self._bynweekday:
                self._bynweekday = None

            if self._byweekday is not None:
                self._byweekday = tuple(sorted(self._byweekday))
                orig_byweekday = [weekday(x) for x in self._byweekday]
            else:
                orig_byweekday = tuple()

            if self._bynweekday is not None:
                self._bynweekday = tuple(sorted(self._bynweekday))
                orig_bynweekday = [weekday(*x) for x in self._bynweekday]
            else:
                orig_bynweekday = tuple()

            if 'byweekday' not in self._original_rule:
                self._original_rule['byweekday'] = tuple(itertools.chain(
                    orig_byweekday, orig_bynweekday))

        # byhour
        if byhour is None:
            if freq < HOURLY:
                self._byhour = set((dtstart.hour,))
            else:
                self._byhour = None
        else:
            if isinstance(byhour, integer_types):
                byhour = (byhour,)

            if freq == HOURLY:
                self._byhour = self.__construct_byset(start=dtstart.hour,
                                                      byxxx=byhour,
                                                      base=24)
            else:
                self._byhour = set(byhour)

            self._byhour = tuple(sorted(self._byhour))
            self._original_rule['byhour'] = self._byhour

        # byminute
        if byminute is None:
            if freq < MINUTELY:
                self._byminute = set((dtstart.minute,))
            else:
                self._byminute = None
        else:
            if isinstance(byminute, integer_types):
                byminute = (byminute,)

            if freq == MINUTELY:
                self._byminute = self.__construct_byset(start=dtstart.minute,
                                                        byxxx=byminute,
                                                        base=60)
            else:
                self._byminute = set(byminute)

            self._byminute = tuple(sorted(self._byminute))
            self._original_rule['byminute'] = self._byminute

        # bysecond
        if bysecond is None:
            if freq < SECONDLY:
                self._bysecond = ((dtstart.second,))
            else:
                self._bysecond = None
        else:
            if isinstance(bysecond, integer_types):
                bysecond = (bysecond,)

            self._bysecond = set(bysecond)

            if freq == SECONDLY:
                self._bysecond = self.__construct_byset(start=dtstart.second,
                                                        byxxx=bysecond,
                                                        base=60)
            else:
                self._bysecond = set(bysecond)

            self._bysecond = tuple(sorted(self._bysecond))
            self._original_rule['bysecond'] = self._bysecond

        if self._freq >= HOURLY:
            self._timeset = None
        else:
            self._timeset = []
            for hour in self._byhour:
                for minute in self._byminute:
                    for second in self._bysecond:
                        self._timeset.append(
                            datetime.time(hour, minute, second,
                                          tzinfo=self._tzinfo))
            self._timeset.sort()
            self._timeset = tuple(self._timeset)

    def __str__(self):
        """
        Output a string that would generate this RRULE if passed to rrulestr.
        This is mostly compatible with RFC2445, except for the
        dateutil-specific extension BYEASTER.
        """

        output = []
        h, m, s = [None] * 3
        if self._dtstart:
            output.append(self._dtstart.strftime('DTSTART:%Y%m%dT%H%M%S'))
            h, m, s = self._dtstart.timetuple()[3:6]

        parts = ['FREQ=' + FREQNAMES[self._freq]]
        if self._interval != 1:
            parts.append('INTERVAL=' + str(self._interval))

        if self._wkst:
            parts.append('WKST=' + repr(weekday(self._wkst))[0:2])

        if self._count is not None:
            parts.append('COUNT=' + str(self._count))

        if self._until:
            parts.append(self._until.strftime('UNTIL=%Y%m%dT%H%M%S'))

        if self._original_rule.get('byweekday') is not None:
            # The str() method on weekday objects doesn't generate
            # RFC2445-compliant strings, so we should modify that.
            original_rule = dict(self._original_rule)
            wday_strings = []
            for wday in original_rule['byweekday']:
                if wday.n:
                    wday_strings.append('{n:+d}{wday}'.format(
                        n=wday.n,
                        wday=repr(wday)[0:2]))
                else:
                    wday_strings.append(repr(wday))

            original_rule['byweekday'] = wday_strings
        else:
            original_rule = self._original_rule

        partfmt = '{name}={vals}'
        for name, key in [('BYSETPOS', 'bysetpos'),
                          ('BYMONTH', 'bymonth'),
                          ('BYMONTHDAY', 'bymonthday'),
                          ('BYYEARDAY', 'byyearday'),
                          ('BYWEEKNO', 'byweekno'),
                          ('BYDAY', 'byweekday'),
                          ('BYHOUR', 'byhour'),
                          ('BYMINUTE', 'byminute'),
                          ('BYSECOND', 'bysecond'),
                          ('BYEASTER', 'byeaster')]:
            value = original_rule.get(key)
            if value:
                parts.append(partfmt.format(name=name, vals=(','.join(str(v)
                                                             for v in value))))

        output.append(';'.join(parts))
        return '\n'.join(output)

    def replace(self, **kwargs):
        """Return new rrule with same attributes except for those attributes given new
           values by whichever keyword arguments are specified."""
        new_kwargs = {"interval": self._interval,
                      "count": self._count,
                      "dtstart": self._dtstart,
                      "freq": self._freq,
                      "until": self._until,
                      "wkst": self._wkst,
                      "cache": False if self._cache is None else True }
        new_kwargs.update(self._original_rule)
        new_kwargs.update(kwargs)
        return rrule(**new_kwargs)

    def _iter(self):
        year, month, day, hour, minute, second, weekday, yearday, _ = \
            self._dtstart.timetuple()

        # Some local variables to speed things up a bit
        freq = self._freq
        interval = self._interval
        wkst = self._wkst
        until = self._until
        bymonth = self._bymonth
        byweekno = self._byweekno
        byyearday = self._byyearday
        byweekday = self._byweekday
        byeaster = self._byeaster
        bymonthday = self._bymonthday
        bynmonthday = self._bynmonthday
        bysetpos = self._bysetpos
        byhour = self._byhour
        byminute = self._byminute
        bysecond = self._bysecond

        ii = _iterinfo(self)
        ii.rebuild(year, month)

        getdayset = {YEARLY: ii.ydayset,
                     MONTHLY: ii.mdayset,
                     WEEKLY: ii.wdayset,
                     DAILY: ii.ddayset,
                     HOURLY: ii.ddayset,
                     MINUTELY: ii.ddayset,
                     SECONDLY: ii.ddayset}[freq]

        if freq < HOURLY:
            timeset = self._timeset
        else:
            gettimeset = {HOURLY: ii.htimeset,
                          MINUTELY: ii.mtimeset,
                          SECONDLY: ii.stimeset}[freq]
            if ((freq >= HOURLY and
                 self._byhour and hour not in self._byhour) or
                (freq >= MINUTELY and
                 self._byminute and minute not in self._byminute) or
                (freq >= SECONDLY and
                 self._bysecond and second not in self._bysecond)):
                timeset = ()
            else:
                timeset = gettimeset(hour, minute, second)

        total = 0
        count = self._count
        while True:
            # Get dayset with the right frequency
            dayset, start, end = getdayset(year, month, day)

            # Do the "hard" work ;-)
            filtered = False
            for i in dayset[start:end]:
                if ((bymonth and ii.mmask[i] not in bymonth) or
                    (byweekno and not ii.wnomask[i]) or
                    (byweekday and ii.wdaymask[i] not in byweekday) or
                    (ii.nwdaymask and not ii.nwdaymask[i]) or
                    (byeaster and not ii.eastermask[i]) or
                    ((bymonthday or bynmonthday) and
                     ii.mdaymask[i] not in bymonthday and
                     ii.nmdaymask[i] not in bynmonthday) or
                    (byyearday and
                     ((i < ii.yearlen and i+1 not in byyearday and
                       -ii.yearlen+i not in byyearday) or
                      (i >= ii.yearlen and i+1-ii.yearlen not in byyearday and
                       -ii.nextyearlen+i-ii.yearlen not in byyearday)))):
                    dayset[i] = None
                    filtered = True

            # Output results
            if bysetpos and timeset:
                poslist = []
                for pos in bysetpos:
                    if pos < 0:
                        daypos, timepos = divmod(pos, len(timeset))
                    else:
                        daypos, timepos = divmod(pos-1, len(timeset))
                    try:
                        i = [x for x in dayset[start:end]
                             if x is not None][daypos]
                        time = timeset[timepos]
                    except IndexError:
                        pass
                    else:
                        date = datetime.date.fromordinal(ii.yearordinal+i)
                        res = datetime.datetime.combine(date, time)
                        if res not in poslist:
                            poslist.append(res)
                poslist.sort()
                for res in poslist:
                    if until and res > until:
                        self._len = total
                        return
                    elif res >= self._dtstart:
                        if count is not None:
                            count -= 1
                            if count < 0:
                                self._len = total
                                return
                        total += 1
                        yield res
            else:
                for i in dayset[start:end]:
                    if i is not None:
                        date = datetime.date.fromordinal(ii.yearordinal + i)
                        for time in timeset:
                            res = datetime.datetime.combine(date, time)
                            if until and res > until:
                                self._len = total
                                return
                            elif res >= self._dtstart:
                                if count is not None:
                                    count -= 1
                                    if count < 0:
                                        self._len = total
                                        return

                                total += 1
                                yield res

            # Handle frequency and interval
            fixday = False
            if freq == YEARLY:
                year += interval
                if year > datetime.MAXYEAR:
                    self._len = total
                    return
                ii.rebuild(year, month)
            elif freq == MONTHLY:
                month += interval
                if month > 12:
                    div, mod = divmod(month, 12)
                    month = mod
                    year += div
                    if month == 0:
                        month = 12
                        year -= 1
                    if year > datetime.MAXYEAR:
                        self._len = total
                        return
                ii.rebuild(year, month)
            elif freq == WEEKLY:
                if wkst > weekday:
                    day += -(weekday+1+(6-wkst))+self._interval*7
                else:
                    day += -(weekday-wkst)+self._interval*7
                weekday = wkst
                fixday = True
            elif freq == DAILY:
                day += interval
                fixday = True
            elif freq == HOURLY:
                if filtered:
                    # Jump to one iteration before next day
                    hour += ((23-hour)//interval)*interval

                if byhour:
                    ndays, hour = self.__mod_distance(value=hour,
                                                      byxxx=self._byhour,
                                                      base=24)
                else:
                    ndays, hour = divmod(hour+interval, 24)

                if ndays:
                    day += ndays
                    fixday = True

                timeset = gettimeset(hour, minute, second)
            elif freq == MINUTELY:
                if filtered:
                    # Jump to one iteration before next day
                    minute += ((1439-(hour*60+minute))//interval)*interval

                valid = False
                rep_rate = (24*60)
                for j in range(rep_rate // gcd(interval, rep_rate)):
                    if byminute:
                        nhours, minute = \
                            self.__mod_distance(value=minute,
                                                byxxx=self._byminute,
                                                base=60)
                    else:
                        nhours, minute = divmod(minute+interval, 60)

                    div, hour = divmod(hour+nhours, 24)
                    if div:
                        day += div
                        fixday = True
                        filtered = False

                    if not byhour or hour in byhour:
                        valid = True
                        break

                if not valid:
                    raise ValueError('Invalid combination of interval and ' +
                                     'byhour resulting in empty rule.')

                timeset = gettimeset(hour, minute, second)
            elif freq == SECONDLY:
                if filtered:
                    # Jump to one iteration before next day
                    second += (((86399 - (hour * 3600 + minute * 60 + second))
                                // interval) * interval)

                rep_rate = (24 * 3600)
                valid = False
                for j in range(0, rep_rate // gcd(interval, rep_rate)):
                    if bysecond:
                        nminutes, second = \
                            self.__mod_distance(value=second,
                                                byxxx=self._bysecond,
                                                base=60)
                    else:
                        nminutes, second = divmod(second+interval, 60)

                    div, minute = divmod(minute+nminutes, 60)
                    if div:
                        hour += div
                        div, hour = divmod(hour, 24)
                        if div:
                            day += div
                            fixday = True

                    if ((not byhour or hour in byhour) and
                            (not byminute or minute in byminute) and
                            (not bysecond or second in bysecond)):
                        valid = True
                        break

                if not valid:
                    raise ValueError('Invalid combination of interval, ' +
                                     'byhour and byminute resulting in empty' +
                                     ' rule.')

                timeset = gettimeset(hour, minute, second)

            if fixday and day > 28:
                daysinmonth = calendar.monthrange(year, month)[1]
                if day > daysinmonth:
                    while day > daysinmonth:
                        day -= daysinmonth
                        month += 1
                        if month == 13:
                            month = 1
                            year += 1
                            if year > datetime.MAXYEAR:
                                self._len = total
                                return
                        daysinmonth = calendar.monthrange(year, month)[1]
                    ii.rebuild(year, month)

    def __construct_byset(self, start, byxxx, base):
        """
        If a `BYXXX` sequence is passed to the constructor at the same level as
        `FREQ` (e.g. `FREQ=HOURLY,BYHOUR={2,4,7},INTERVAL=3`), there are some
        specifications which cannot be reached given some starting conditions.

        This occurs whenever the interval is not coprime with the base of a
        given unit and the difference between the starting position and the
        ending position is not coprime with the greatest common denominator
        between the interval and the base. For example, with a FREQ of hourly
        starting at 17:00 and an interval of 4, the only valid values for
        BYHOUR would be {21, 1, 5, 9, 13, 17}, because 4 and 24 are not
        coprime.

        :param start:
            Specifies the starting position.
        :param byxxx:
            An iterable containing the list of allowed values.
        :param base:
            The largest allowable value for the specified frequency (e.g.
            24 hours, 60 minutes).

        This does not preserve the type of the iterable, returning a set, since
        the values should be unique and the order is irrelevant, this will
        speed up later lookups.

        In the event of an empty set, raises a :exception:`ValueError`, as this
        results in an empty rrule.
        """

        cset = set()

        # Support a single byxxx value.
        if isinstance(byxxx, integer_types):
            byxxx = (byxxx, )

        for num in byxxx:
            i_gcd = gcd(self._interval, base)
            # Use divmod rather than % because we need to wrap negative nums.
            if i_gcd == 1 or divmod(num - start, i_gcd)[1] == 0:
                cset.add(num)

        if len(cset) == 0:
            raise ValueError("Invalid rrule byxxx generates an empty set.")

        return cset

    def __mod_distance(self, value, byxxx, base):
        """
        Calculates the next value in a sequence where the `FREQ` parameter is
        specified along with a `BYXXX` parameter at the same "level"
        (e.g. `HOURLY` specified with `BYHOUR`).

        :param value:
            The old value of the component.
        :param byxxx:
            The `BYXXX` set, which should have been generated by
            `rrule._construct_byset`, or something else which checks that a
            valid rule is present.
        :param base:
            The largest allowable value for the specified frequency (e.g.
            24 hours, 60 minutes).

        If a valid value is not found after `base` iterations (the maximum
        number before the sequence would start to repeat), this raises a
        :exception:`ValueError`, as no valid values were found.

        This returns a tuple of `divmod(n*interval, base)`, where `n` is the
        smallest number of `interval` repetitions until the next specified
        value in `byxxx` is found.
        """
        accumulator = 0
        for ii in range(1, base + 1):
            # Using divmod() over % to account for negative intervals
            div, value = divmod(value + self._interval, base)
            accumulator += div
            if value in byxxx:
                return (accumulator, value)


class _iterinfo(object):
    __slots__ = ["rrule", "lastyear", "lastmonth",
                 "yearlen", "nextyearlen", "yearordinal", "yearweekday",
                 "mmask", "mrange", "mdaymask", "nmdaymask",
                 "wdaymask", "wnomask", "nwdaymask", "eastermask"]

    def __init__(self, rrule):
        for attr in self.__slots__:
            setattr(self, attr, None)
        self.rrule = rrule

    def rebuild(self, year, month):
        # Every mask is 7 days longer to handle cross-year weekly periods.
        rr = self.rrule
        if year != self.lastyear:
            self.yearlen = 365 + calendar.isleap(year)
            self.nextyearlen = 365 + calendar.isleap(year + 1)
            firstyday = datetime.date(year, 1, 1)
            self.yearordinal = firstyday.toordinal()
            self.yearweekday = firstyday.weekday()

            wday = datetime.date(year, 1, 1).weekday()
            if self.yearlen == 365:
                self.mmask = M365MASK
                self.mdaymask = MDAY365MASK
                self.nmdaymask = NMDAY365MASK
                self.wdaymask = WDAYMASK[wday:]
                self.mrange = M365RANGE
            else:
                self.mmask = M366MASK
                self.mdaymask = MDAY366MASK
                self.nmdaymask = NMDAY366MASK
                self.wdaymask = WDAYMASK[wday:]
                self.mrange = M366RANGE

            if not rr._byweekno:
                self.wnomask = None
            else:
                self.wnomask = [0]*(self.yearlen+7)
                # no1wkst = firstwkst = self.wdaymask.index(rr._wkst)
                no1wkst = firstwkst = (7-self.yearweekday+rr._wkst) % 7
                if no1wkst >= 4:
                    no1wkst = 0
                    # Number of days in the year, plus the days we got
                    # from last year.
                    wyearlen = self.yearlen+(self.yearweekday-rr._wkst) % 7
                else:
                    # Number of days in the year, minus the days we
                    # left in last year.
                    wyearlen = self.yearlen-no1wkst
                div, mod = divmod(wyearlen, 7)
                numweeks = div+mod//4
                for n in rr._byweekno:
                    if n < 0:
                        n += numweeks+1
                    if not (0 < n <= numweeks):
                        continue
                    if n > 1:
                        i = no1wkst+(n-1)*7
                        if no1wkst != firstwkst:
                            i -= 7-firstwkst
                    else:
                        i = no1wkst
                    for j in range(7):
                        self.wnomask[i] = 1
                        i += 1
                        if self.wdaymask[i] == rr._wkst:
                            break
                if 1 in rr._byweekno:
                    # Check week number 1 of next year as well
                    # TODO: Check -numweeks for next year.
                    i = no1wkst+numweeks*7
                    if no1wkst != firstwkst:
                        i -= 7-firstwkst
                    if i < self.yearlen:
                        # If week starts in next year, we
                        # don't care about it.
                        for j in range(7):
                            self.wnomask[i] = 1
                            i += 1
                            if self.wdaymask[i] == rr._wkst:
                                break
                if no1wkst:
                    # Check last week number of last year as
                    # well. If no1wkst is 0, either the year
                    # started on week start, or week number 1
                    # got days from last year, so there are no
                    # days from last year's last week number in
                    # this year.
                    if -1 not in rr._byweekno:
                        lyearweekday = datetime.date(year-1, 1, 1).weekday()
                        lno1wkst = (7-lyearweekday+rr._wkst) % 7
                        lyearlen = 365+calendar.isleap(year-1)
                        if lno1wkst >= 4:
                            lno1wkst = 0
                            lnumweeks = 52+(lyearlen +
                                            (lyearweekday-rr._wkst) % 7) % 7//4
                        else:
                            lnumweeks = 52+(self.yearlen-no1wkst) % 7//4
                    else:
                        lnumweeks = -1
                    if lnumweeks in rr._byweekno:
                        for i in range(no1wkst):
                            self.wnomask[i] = 1

        if (rr._bynweekday and (month != self.lastmonth or
                                year != self.lastyear)):
            ranges = []
            if rr._freq == YEARLY:
                if rr._bymonth:
                    for month in rr._bymonth:
                        ranges.append(self.mrange[month-1:month+1])
                else:
                    ranges = [(0, self.yearlen)]
            elif rr._freq == MONTHLY:
                ranges = [self.mrange[month-1:month+1]]
            if ranges:
                # Weekly frequency won't get here, so we may not
                # care about cross-year weekly periods.
                self.nwdaymask = [0]*self.yearlen
                for first, last in ranges:
                    last -= 1
                    for wday, n in rr._bynweekday:
                        if n < 0:
                            i = last+(n+1)*7
                            i -= (self.wdaymask[i]-wday) % 7
                        else:
                            i = first+(n-1)*7
                            i += (7-self.wdaymask[i]+wday) % 7
                        if first <= i <= last:
                            self.nwdaymask[i] = 1

        if rr._byeaster:
            self.eastermask = [0]*(self.yearlen+7)
            eyday = easter.easter(year).toordinal()-self.yearordinal
            for offset in rr._byeaster:
                self.eastermask[eyday+offset] = 1

        self.lastyear = year
        self.lastmonth = month

    def ydayset(self, year, month, day):
        return list(range(self.yearlen)), 0, self.yearlen

    def mdayset(self, year, month, day):
        dset = [None]*self.yearlen
        start, end = self.mrange[month-1:month+1]
        for i in range(start, end):
            dset[i] = i
        return dset, start, end

    def wdayset(self, year, month, day):
        # We need to handle cross-year weeks here.
        dset = [None]*(self.yearlen+7)
        i = datetime.date(year, month, day).toordinal()-self.yearordinal
        start = i
        for j in range(7):
            dset[i] = i
            i += 1
            # if (not (0 <= i < self.yearlen) or
            #    self.wdaymask[i] == self.rrule._wkst):
            # This will cross the year boundary, if necessary.
            if self.wdaymask[i] == self.rrule._wkst:
                break
        return dset, start, i

    def ddayset(self, year, month, day):
        dset = [None] * self.yearlen
        i = datetime.date(year, month, day).toordinal() - self.yearordinal
        dset[i] = i
        return dset, i, i + 1

    def htimeset(self, hour, minute, second):
        tset = []
        rr = self.rrule
        for minute in rr._byminute:
            for second in rr._bysecond:
                tset.append(datetime.time(hour, minute, second,
                                          tzinfo=rr._tzinfo))
        tset.sort()
        return tset

    def mtimeset(self, hour, minute, second):
        tset = []
        rr = self.rrule
        for second in rr._bysecond:
            tset.append(datetime.time(hour, minute, second, tzinfo=rr._tzinfo))
        tset.sort()
        return tset

    def stimeset(self, hour, minute, second):
        return (datetime.time(hour, minute, second,
                tzinfo=self.rrule._tzinfo),)


class rruleset(rrulebase):
    """ The rruleset type allows more complex recurrence setups, mixing
    multiple rules, dates, exclusion rules, and exclusion dates. The type
    constructor takes the following keyword arguments:

    :param cache: If True, caching of results will be enabled, improving
                  performance of multiple queries considerably. """

    class _genitem(object):
        def __init__(self, genlist, gen):
            try:
                self.dt = advance_iterator(gen)
                genlist.append(self)
            except StopIteration:
                pass
            self.genlist = genlist
            self.gen = gen

        def __next__(self):
            try:
                self.dt = advance_iterator(self.gen)
            except StopIteration:
                if self.genlist[0] is self:
                    heapq.heappop(self.genlist)
                else:
                    self.genlist.remove(self)
                    heapq.heapify(self.genlist)

        next = __next__

        def __lt__(self, other):
            return self.dt < other.dt

        def __gt__(self, other):
            return self.dt > other.dt

        def __eq__(self, other):
            return self.dt == other.dt

        def __ne__(self, other):
            return self.dt != other.dt

    def __init__(self, cache=False):
        super(rruleset, self).__init__(cache)
        self._rrule = []
        self._rdate = []
        self._exrule = []
        self._exdate = []

    @_invalidates_cache
    def rrule(self, rrule):
        """ Include the given :py:class:`rrule` instance in the recurrence set
            generation. """
        self._rrule.append(rrule)

    @_invalidates_cache
    def rdate(self, rdate):
        """ Include the given :py:class:`datetime` instance in the recurrence
            set generation. """
        self._rdate.append(rdate)

    @_invalidates_cache
    def exrule(self, exrule):
        """ Include the given rrule instance in the recurrence set exclusion
            list. Dates which are part of the given recurrence rules will not
            be generated, even if some inclusive rrule or rdate matches them.
        """
        self._exrule.append(exrule)

    @_invalidates_cache
    def exdate(self, exdate):
        """ Include the given datetime instance in the recurrence set
            exclusion list. Dates included that way will not be generated,
            even if some inclusive rrule or rdate matches them. """
        self._exdate.append(exdate)

    def _iter(self):
        rlist = []
        self._rdate.sort()
        self._genitem(rlist, iter(self._rdate))
        for gen in [iter(x) for x in self._rrule]:
            self._genitem(rlist, gen)
        exlist = []
        self._exdate.sort()
        self._genitem(exlist, iter(self._exdate))
        for gen in [iter(x) for x in self._exrule]:
            self._genitem(exlist, gen)
        lastdt = None
        total = 0
        heapq.heapify(rlist)
        heapq.heapify(exlist)
        while rlist:
            ritem = rlist[0]
            if not lastdt or lastdt != ritem.dt:
                while exlist and exlist[0] < ritem:
                    exitem = exlist[0]
                    advance_iterator(exitem)
                    if exlist and exlist[0] is exitem:
                        heapq.heapreplace(exlist, exitem)
                if not exlist or ritem != exlist[0]:
                    total += 1
                    yield ritem.dt
                lastdt = ritem.dt
            advance_iterator(ritem)
            if rlist and rlist[0] is ritem:
                heapq.heapreplace(rlist, ritem)
        self._len = total


class _rrulestr(object):

    _freq_map = {"YEARLY": YEARLY,
                 "MONTHLY": MONTHLY,
                 "WEEKLY": WEEKLY,
                 "DAILY": DAILY,
                 "HOURLY": HOURLY,
                 "MINUTELY": MINUTELY,
                 "SECONDLY": SECONDLY}

    _weekday_map = {"MO": 0, "TU": 1, "WE": 2, "TH": 3,
                    "FR": 4, "SA": 5, "SU": 6}

    def _handle_int(self, rrkwargs, name, value, **kwargs):
        rrkwargs[name.lower()] = int(value)

    def _handle_int_list(self, rrkwargs, name, value, **kwargs):
        rrkwargs[name.lower()] = [int(x) for x in value.split(',')]

    _handle_INTERVAL = _handle_int
    _handle_COUNT = _handle_int
    _handle_BYSETPOS = _handle_int_list
    _handle_BYMONTH = _handle_int_list
    _handle_BYMONTHDAY = _handle_int_list
    _handle_BYYEARDAY = _handle_int_list
    _handle_BYEASTER = _handle_int_list
    _handle_BYWEEKNO = _handle_int_list
    _handle_BYHOUR = _handle_int_list
    _handle_BYMINUTE = _handle_int_list
    _handle_BYSECOND = _handle_int_list

    def _handle_FREQ(self, rrkwargs, name, value, **kwargs):
        rrkwargs["freq"] = self._freq_map[value]

    def _handle_UNTIL(self, rrkwargs, name, value, **kwargs):
        global parser
        if not parser:
            from dateutil import parser
        try:
            rrkwargs["until"] = parser.parse(value,
                                             ignoretz=kwargs.get("ignoretz"),
                                             tzinfos=kwargs.get("tzinfos"))
        except ValueError:
            raise ValueError("invalid until date")

    def _handle_WKST(self, rrkwargs, name, value, **kwargs):
        rrkwargs["wkst"] = self._weekday_map[value]

    def _handle_BYWEEKDAY(self, rrkwargs, name, value, **kwargs):
        """
        Two ways to specify this: +1MO or MO(+1)
        """
        l = []
        for wday in value.split(','):
            if '(' in wday:
                # If it's of the form TH(+1), etc.
                splt = wday.split('(')
                w = splt[0]
                n = int(splt[1][:-1])
            elif len(wday):
                # If it's of the form +1MO
                for i in range(len(wday)):
                    if wday[i] not in '+-0123456789':
                        break
                n = wday[:i] or None
                w = wday[i:]
                if n:
                    n = int(n)
            else:
                raise ValueError("Invalid (empty) BYDAY specification.")

            l.append(weekdays[self._weekday_map[w]](n))
        rrkwargs["byweekday"] = l

    _handle_BYDAY = _handle_BYWEEKDAY

    def _parse_rfc_rrule(self, line,
                         dtstart=None,
                         cache=False,
                         ignoretz=False,
                         tzinfos=None):
        if line.find(':') != -1:
            name, value = line.split(':')
            if name != "RRULE":
                raise ValueError("unknown parameter name")
        else:
            value = line
        rrkwargs = {}
        for pair in value.split(';'):
            name, value = pair.split('=')
            name = name.upper()
            value = value.upper()
            try:
                getattr(self, "_handle_"+name)(rrkwargs, name, value,
                                               ignoretz=ignoretz,
                                               tzinfos=tzinfos)
            except AttributeError:
                raise ValueError("unknown parameter '%s'" % name)
            except (KeyError, ValueError):
                raise ValueError("invalid '%s': %s" % (name, value))
        return rrule(dtstart=dtstart, cache=cache, **rrkwargs)

    def _parse_rfc(self, s,
                   dtstart=None,
                   cache=False,
                   unfold=False,
                   forceset=False,
                   compatible=False,
                   ignoretz=False,
                   tzinfos=None):
        global parser
        if compatible:
            forceset = True
            unfold = True
        s = s.upper()
        if not s.strip():
            raise ValueError("empty string")
        if unfold:
            lines = s.splitlines()
            i = 0
            while i < len(lines):
                line = lines[i].rstrip()
                if not line:
                    del lines[i]
                elif i > 0 and line[0] == " ":
                    lines[i-1] += line[1:]
                    del lines[i]
                else:
                    i += 1
        else:
            lines = s.split()
        if (not forceset and len(lines) == 1 and (s.find(':') == -1 or
                                                  s.startswith('RRULE:'))):
            return self._parse_rfc_rrule(lines[0], cache=cache,
                                         dtstart=dtstart, ignoretz=ignoretz,
                                         tzinfos=tzinfos)
        else:
            rrulevals = []
            rdatevals = []
            exrulevals = []
            exdatevals = []
            for line in lines:
                if not line:
                    continue
                if line.find(':') == -1:
                    name = "RRULE"
                    value = line
                else:
                    name, value = line.split(':', 1)
                parms = name.split(';')
                if not parms:
                    raise ValueError("empty property name")
                name = parms[0]
                parms = parms[1:]
                if name == "RRULE":
                    for parm in parms:
                        raise ValueError("unsupported RRULE parm: "+parm)
                    rrulevals.append(value)
                elif name == "RDATE":
                    for parm in parms:
                        if parm != "VALUE=DATE-TIME":
                            raise ValueError("unsupported RDATE parm: "+parm)
                    rdatevals.append(value)
                elif name == "EXRULE":
                    for parm in parms:
                        raise ValueError("unsupported EXRULE parm: "+parm)
                    exrulevals.append(value)
                elif name == "EXDATE":
                    for parm in parms:
                        if parm != "VALUE=DATE-TIME":
                            raise ValueError("unsupported EXDATE parm: "+parm)
                    exdatevals.append(value)
                elif name == "DTSTART":
                    for parm in parms:
                        raise ValueError("unsupported DTSTART parm: "+parm)
                    if not parser:
                        from dateutil import parser
                    dtstart = parser.parse(value, ignoretz=ignoretz,
                                           tzinfos=tzinfos)
                else:
                    raise ValueError("unsupported property: "+name)
            if (forceset or len(rrulevals) > 1 or rdatevals
                    or exrulevals or exdatevals):
                if not parser and (rdatevals or exdatevals):
                    from dateutil import parser
                rset = rruleset(cache=cache)
                for value in rrulevals:
                    rset.rrule(self._parse_rfc_rrule(value, dtstart=dtstart,
                                                     ignoretz=ignoretz,
                                                     tzinfos=tzinfos))
                for value in rdatevals:
                    for datestr in value.split(','):
                        rset.rdate(parser.parse(datestr,
                                                ignoretz=ignoretz,
                                                tzinfos=tzinfos))
                for value in exrulevals:
                    rset.exrule(self._parse_rfc_rrule(value, dtstart=dtstart,
                                                      ignoretz=ignoretz,
                                                      tzinfos=tzinfos))
                for value in exdatevals:
                    for datestr in value.split(','):
                        rset.exdate(parser.parse(datestr,
                                                 ignoretz=ignoretz,
                                                 tzinfos=tzinfos))
                if compatible and dtstart:
                    rset.rdate(dtstart)
                return rset
            else:
                return self._parse_rfc_rrule(rrulevals[0],
                                             dtstart=dtstart,
                                             cache=cache,
                                             ignoretz=ignoretz,
                                             tzinfos=tzinfos)

    def __call__(self, s, **kwargs):
        return self._parse_rfc(s, **kwargs)


rrulestr = _rrulestr()

# vim:ts=4:sw=4:et
PKa�\_ސ��$�$!tz/__pycache__/win.cpython-36.pycnu�[���3

6�cY�,�@s�ddlZddlZddlmZddlmZyddlZddlmZWnek
r\e	d��YnXddl
mZdd	d
gZej
d�ZdZd
ZdZdd�Ze�ZGdd
�d
e�ZGdd�de�ZGdd�de�ZGdd	�d	e�Zdd�Zdd�ZdS)�N)�winreg)�	text_type)�wintypesz#Running tzwin on non-Windows system�)�tzrangebase�tzwin�
tzwinlocal�tzres�z7SOFTWARE\Microsoft\Windows NT\CurrentVersion\Time Zonesz4SOFTWARE\Microsoft\Windows\CurrentVersion\Time Zonesz4SYSTEM\CurrentControlSet\Control\TimeZoneInformationcCsLtjdtj�}ytj|t�j�t}Wntk
r>t}YnX|j�|S)N)r�ConnectRegistry�HKEY_LOCAL_MACHINE�OpenKey�TZKEYNAMENTZCloseZWindowsError�TZKEYNAME9X)�handle�	TZKEYNAME�r�/usr/lib/python3.6/win.py�
_settzkeynames
rc@s6eZdZdZejej�Zd
dd�Z	dd�Z
dd�Zd	S)r	z{
    Class for accessing `tzres.dll`, which contains timezone name related
    resources.

    .. versionadded:: 2.5.0
    �	tzres.dllcCs@tjd�}tjtjtjtjf|j_|j|_tj|�|_	||_
dS)N�user32)�ctypesZWinDLLrZ	HINSTANCEZUINT�LPWSTRZc_int�LoadStringWZargtypes�_tzres�	tzres_loc)�selfrrrrr�__init__1s
ztzres.__init__cCs<|j�}tjtj|�tj�}|j|jj||d�}|d|�S)a�
        Load a timezone name from a DLL offset (integer).

        >>> from dateutil.tzwin import tzres
        >>> tzr = tzres()
        >>> print(tzr.load_name(112))
        'Eastern Standard Time'

        :param offset:
            A positive integer value referring to a string from the tzres dll.

        ..note:
            Offsets found in the registry are generally of the form
            `@tzres.dll,-114`. The offset in this case if 114, not -114.

        rN)	�p_wcharr�castZbyrefrrrrZ_handle)r�offsetZresourceZlpBufferZncharrrr�	load_name?sztzres.load_namec	CsH|jd�s|S|jd�}yt|d�}Wntd��YnX|j|�S)a�
        Parse strings as returned from the Windows registry into the time zone
        name as defined in the registry.

        >>> from dateutil.tzwin import tzres
        >>> tzr = tzres()
        >>> print(tzr.name_from_string('@tzres.dll,-251'))
        'Dateline Daylight Time'
        >>> print(tzr.name_from_string('Eastern Standard Time'))
        'Eastern Standard Time'

        :param tzname_str:
            A timezone name string as returned from a Windows registry key.

        :return:
            Returns the localized timezone string from tzres.dll if the string
            is of the form `@tzres.dll,-offset`, else returns the input string.
        �@z,-rzMalformed timezone string.)�
startswith�split�int�
ValueErrorr!)rZ
tzname_strZ	name_spltr rrr�name_from_stringUs

ztzres.name_from_stringN)r)�__name__�
__module__�__qualname__�__doc__rZPOINTERrZWCHARrrr!r'rrrrr	(s

c@sPeZdZdZdd�Zdd�Zedd��Zdd	�Zd
d�Z	dd
�Z
edd��ZdS)�	tzwinbasezBtzinfo class based on win32's timezones available in the registry.cCstd��dS)Nz#tzwinbase is an abstract base class)�NotImplementedError)rrrrrvsztzwinbase.__init__cCs�t|t�stS|j|jko�|j|jko�|j|jko�|j|jko�|j|jko�|j|jko�|j	|j	ko�|j
|j
ko�|j|jko�|j|jko�|j
|j
ko�|j|jkS)N)�
isinstancer,�NotImplemented�_std_offset�_dst_offset�
_stddayofweek�
_dstdayofweek�_stdweeknumber�_dstweeknumber�_stdhour�_dsthour�
_stdminute�
_dstminute�	_std_abbr�	_dst_abbr)r�otherrrr�__eq__ys
ztzwinbase.__eq__csVtjdtj��>}tj|t��&��fdd�ttj��d�D�}WdQRXWdQRX|S)z4Return a list of all time zones known to the system.Ncsg|]}tj�|��qSr)rZEnumKey)�.0�i)�tzkeyrr�
<listcomp>�sz"tzwinbase.list.<locals>.<listcomp>r)rrrr
r�range�QueryInfoKey)r�resultr)r@r�list�s

*ztzwinbase.listcCs|jS)N)�_display)rrrr�display�sztzwinbase.displaycCsT|js
dSt||j|j|j|j|j�}t||j|j|j	|j
|j�}||j8}||fS)a�
        For a given year, get the DST on and off transition times, expressed
        always on the standard time side. For zones with no transitions, this
        function returns ``None``.

        :param year:
            The year whose transitions you would like to query.

        :return:
            Returns a :class:`tuple` of :class:`datetime.datetime` objects,
            ``(dston, dstoff)`` for zones with an annual DST transition, or
            ``None`` for fixed offset zones.
        N)
�hasdst�picknthweekday�	_dstmonthr3r7r9r5�	_stdmonthr2r6r8r4�_dst_base_offset)r�yearZdstonZdstoffrrr�transitions�s
ztzwinbase.transitionscCs
|jdkS)Nr)rJ)rrrr�_get_hasdst�sztzwinbase._get_hasdstcCs|jS)N)�_dst_base_offset_)rrrrrL�sztzwinbase._dst_base_offsetN)
r(r)r*r+rr=�staticmethodrErGrNrO�propertyrLrrrrr,ts	r,c@s$eZdZdd�Zdd�Zdd�ZdS)rc	Cs||_tjdtj��8}td�jt|d�}tj||��}t|�}WdQRXWdQRX|d|_	|d|_
|d|_tj
d|d�}|d|d	}||d
}tj|d�|_tj|d�|_|dd
�\|_|_|_|_|_|dd�\|_|_|_|_|_|j|j|_|j�|_dS)Nz{kn}\{name})�kn�nameZStdZDlt�Displayz=3l16hZTZIrr�)�minutes��	��)�_namerrrr�formatrr
�valuestodictr:r;rF�struct�unpack�datetime�	timedeltar0r1rKr2r4r6r8rJr3r5r7r9rPrOrH)	rrTr�	tzkeynamer@�keydict�tup�	stdoffset�	dstoffsetrrrr�s"


  ztzwin.__init__cCsdt|j�S)Nz	tzwin(%s))�reprr\)rrrr�__repr__�sztzwin.__repr__cCs|j|jffS)N)�	__class__r\)rrrr�
__reduce__�sztzwin.__reduce__N)r(r)r*rrirkrrrrr�s&c@s,eZdZdd�Zdd�Zdd�Zdd�Zd	S)
rc
 Csntjdtj���}tj|t��}t|�}WdQRX|d|_|d|_yBtd�j	t
|jd�}tj||��}t|�}|d|_WdQRXWntk
r�d|_YnXWdQRX|d|d}||d}t
j|d	�|_t
j|d	�|_tjd
|d�}	|	dd
�\|_|_|_|_|	d|_tjd
|d�}	|	dd
�\|_|_|_|_|	d|_|j|j|_|j�|_dS)NZStandardNameZDaylightNamez	{kn}\{sn})rSZsnrUZBiasZStandardBiasZDaylightBias)rWz=8hZ
StandardStartr�r
Z
DaylightStart) rrrr
�TZLOCALKEYNAMEr^r:r;rr]rrF�OSErrorrarbr0r1r_r`rKr4r6r8r2rJr5r7r9r3rPrOrH)
rrZ
tzlocalkeyrdrcr@Z_keydictrfrgrerrrr�s2





ztzwinlocal.__init__cCsdS)Nztzwinlocal()r)rrrrrisztzwinlocal.__repr__cCsdt|j�S)Nztzwinlocal(%s))rhr:)rrrr�__str__sztzwinlocal.__str__cCs
|jffS)N)rj)rrrrrk#sztzwinlocal.__reduce__N)r(r)r*rrirorkrrrrr�s.c	CsTtj||d||�}|j||j�ddd�}||dt}|j|krP|t8}|S)z> dayofweek == 0 means Sunday, whichweek 5 means last instance rr
)Zday)ra�replaceZ
isoweekday�ONEWEEK�month)	rMrrZ	dayofweekZhourZminuteZ	whichweek�firstZ
weekdayoneZwdrrrrI's
rIcCs�i}tj|�d}d}x�t|�D]v}tj||�\}}}|tjksJ|tjkr\|d@r�|d}n2|tjkr�|jd�r�|pxt�}|j	|�}|j
d�}|||<q W|S)	z0Convert a registry key's values to a dictionary.rN�� z@tzres�ll)rrCrBZ	EnumValueZ	REG_DWORDZREG_DWORD_LITTLE_ENDIANZREG_SZr#r	r'�rstrip)�keyZdout�sizeZtz_resr?Zkey_name�valueZdtyperrrr^5s





r^)rar_Z	six.movesrZsixrrrr&�ImportErrorZ_commonr�__all__rbrqrrrmrr�objectr	r,rrrIr^rrrr�<module>s,

LJ/:PKa�\)XH_a�a� tz/__pycache__/tz.cpython-36.pycnu�[���3

6�cY���@s�dZddlZddlZddlZddlZddlZddlZddlmZddl	m
Z
mZmZddl	m
Z
mZddl	mZyddlmZmZWnek
r�dZZYnXejd�Zejjd�Zej�ZGd	d
�d
ej�ZGdd�dej�ZGd
d�de�ZGdd�de�ZGdd�de�Z Gdd�de�Z!Gdd�de
�Z"Gdd�de"�Z#Gdd�de�Z$Gdd�de�Z%Gdd�de�Z&ej'dk�r�d d!gZ(d"d#d$d%gZ)ngZ(gZ)d0d&d'�Z*d1d(d)�Z+d2d*d+�Z,d,d-�Z-Gd.d/�d/e�Z.dS)3a{
This module offers timezone implementations subclassing the abstract
:py:`datetime.tzinfo` type. There are classes to handle tzfile format files
(usually are in :file:`/etc/localtime`, :file:`/usr/share/zoneinfo`, etc), TZ
environment string (in all known formats), given ranges (with help from
relative deltas), local machine timezone, fixed offset timezone, and UTC
timezone.
�N)�string_types�)�tzname_in_python2�_tzinfo�_total_seconds)�tzrangebase�enfold)�_validate_fromutc_inputs)�tzwin�
tzwinlocalc@sbeZdZdZdd�Zdd�Zedd��Zdd	�Ze	d
d��Z
dd
�ZdZdd�Z
dd�ZejZdS)�tzutczD
    This is a tzinfo object that represents the UTC time zone.
    cCstS)N)�ZERO)�self�dt�r�/usr/lib/python3.6/tz.py�	utcoffset$sztzutc.utcoffsetcCstS)N)r
)rrrrr�dst'sz	tzutc.dstcCsdS)N�UTCr)rrrrr�tzname*sztzutc.tznamecCsdS)a6
        Whether or not the "wall time" of a given datetime is ambiguous in this
        zone.

        :param dt:
            A :py:class:`datetime.datetime`, naive or time zone aware.


        :return:
            Returns ``True`` if ambiguous, ``False`` otherwise.

        .. versionadded:: 2.6.0
        Fr)rrrrr�is_ambiguous.sztzutc.is_ambiguouscCs|S)z�
        Fast track version of fromutc() returns the original ``dt`` object for
        any valid :py:class:`datetime.datetime` object.
        r)rrrrr�fromutc>sz
tzutc.fromutccCs0t|ttf�stSt|t�p.t|t�o.|jtkS)N)�
isinstancer�tzoffset�NotImplemented�_offsetr
)r�otherrrr�__eq__Fs
ztzutc.__eq__NcCs
||kS)Nr)rrrrr�__ne__Osztzutc.__ne__cCsd|jjS)Nz%s())�	__class__�__name__)rrrr�__repr__Rsztzutc.__repr__)r �
__module__�__qualname__�__doc__rrrrrr	rr�__hash__rr!�object�
__reduce__rrrrr src@sjeZdZdZdd�Zdd�Zdd�Zedd	��Ze	d
d��Z
dd
�Zdd�ZdZ
dd�Zdd�ZejZdS)ra1
    A simple class for representing a fixed offset from UTC.

    :param name:
        The timezone name, to be returned when ``tzname()`` is called.

    :param offset:
        The time zone offset in seconds, or (since version 2.6.0, represented
        as a :py:class:`datetime.timedelta` object.
    cCs>||_yt|�}Wnttfk
r*YnXtj|d�|_dS)N)�seconds)�_namer�	TypeError�AttributeError�datetime�	timedeltar)r�name�offsetrrr�__init__csztzoffset.__init__cCs|jS)N)r)rrrrrrmsztzoffset.utcoffsetcCstS)N)r
)rrrrrrpsztzoffset.dstcCs|jS)N)r))rrrrrrssztzoffset.tznamecCs
||jS)N)r)rrrrrrwsztzoffset.fromutccCsdS)a6
        Whether or not the "wall time" of a given datetime is ambiguous in this
        zone.

        :param dt:
            A :py:class:`datetime.datetime`, naive or time zone aware.


        :return:
            Returns ``True`` if ambiguous, ``False`` otherwise.

        .. versionadded:: 2.6.0
        Fr)rrrrrr{sztzoffset.is_ambiguouscCst|t�stS|j|jkS)N)rrrr)rrrrrr�s
ztzoffset.__eq__NcCs
||kS)Nr)rrrrrr�sztzoffset.__ne__cCs"d|jjt|j�tt|j��fS)Nz
%s(%s, %s))rr �reprr)�intrr)rrrrr!�sztzoffset.__repr__)r r"r#r$r0rrrrr	rrrr%rr!r&r'rrrrrXs

rcsxeZdZdZ�fdd�Zdd�Zdd�Zedd	��Zd
d�Z	dd
�Z
ddd�Zdd�ZdZ
dd�Zdd�ZejZ�ZS)�tzlocalzR
    A :class:`tzinfo` subclass built around the ``time`` timezone functions.
    cs`tt|�j�tjtjd�|_tjr:tjtj	d�|_
n|j|_
|j
|j|_t|j�|_
dS)N)r()�superr3r0r,r-�time�timezone�_std_offsetZdaylightZaltzone�_dst_offset�
_dst_saved�bool�_hasdst)r)rrrr0�sztzlocal.__init__cCs,|dkr|jrdS|j|�r"|jS|jSdS)N)r;�_isdstr8r7)rrrrrr�s

ztzlocal.utcoffsetcCs0|dkr|jrdS|j|�r(|j|jStSdS)N)r;r<r8r7r
)rrrrrr�s

ztzlocal.dstcCstj|j|�S)N)r5rr<)rrrrrr�sztzlocal.tznamecCs$|j|�}|o"||j||j�kS)a6
        Whether or not the "wall time" of a given datetime is ambiguous in this
        zone.

        :param dt:
            A :py:class:`datetime.datetime`, naive or time zone aware.


        :return:
            Returns ``True`` if ambiguous, ``False`` otherwise.

        .. versionadded:: 2.6.0
        )�
_naive_is_dstr9)rrZ	naive_dstrrrr�s
ztzlocal.is_ambiguouscCst|�}tj|tj�jS)N)�_datetime_to_timestampr5�	localtimer6Ztm_isdst)rr�	timestamprrrr=�sztzlocal._naive_is_dstTcCsF|js
dS|j|�}t|dd�}|j|�rB|dk	r>|j|�SdS|S)NF�foldT)r;r=�getattrr�_fold)rrZ
fold_naiveZdstvalrArrrr<�s

ztzlocal._isdstcCs&t|t�stS|j|jko$|j|jkS)N)rr3rr7r8)rrrrrrs
ztzlocal.__eq__NcCs
||kS)Nr)rrrrrrsztzlocal.__ne__cCsd|jjS)Nz%s())rr )rrrrr!sztzlocal.__repr__)T)r r"r#r$r0rrrrrr=r<rr%rr!r&r'�
__classcell__rr)rrr3�s		
(r3c@sReZdZdddddddgZdd	�Zd
d�Zdd
�ZdZdd�Zdd�Z	dd�Z
dS)�_ttinfor/�delta�isdst�abbr�isstd�isgmt�	dstoffsetcCs x|jD]}t||d�qWdS)N)�	__slots__�setattr)r�attrrrrr0sz_ttinfo.__init__cCsRg}x6|jD],}t||�}|dk	r|jd|t|�f�qWd|jjdj|�fS)Nz%s=%sz%s(%s)z, )rLrB�appendr1rr �join)r�lrN�valuerrrr!s
z_ttinfo.__repr__cCsbt|t�stS|j|jko`|j|jko`|j|jko`|j|jko`|j|jko`|j|jko`|j	|j	kS)N)
rrErr/rFrGrHrIrJrK)rrrrrr$s
z_ttinfo.__eq__NcCs
||kS)Nr)rrrrrr2sz_ttinfo.__ne__cCs(i}x|jD]}t||d�||<qW|S)N)rLrB)r�stater.rrr�__getstate__5sz_ttinfo.__getstate__cCs,x&|jD]}||krt||||�qWdS)N)rLrM)rrSr.rrr�__setstate__;sz_ttinfo.__setstate__)r r"r#rLr0r!rr%rrTrUrrrrrEs
rEc@s,eZdZdZdddddddd	gZd
d�ZdS)
�_tzfilezw
    Lightweight class for holding the relevant transition and time zone
    information read from binary tzfiles.
    �
trans_list�trans_list_utc�	trans_idx�ttinfo_list�
ttinfo_std�
ttinfo_dst�
ttinfo_before�ttinfo_firstcKs(x"|jD]}t|||j|d��qWdS)N)�attrsrM�get)r�kwargsrNrrrr0Isz_tzfile.__init__N)r r"r#r$r_r0rrrrrVAsrVcs�eZdZdZd&�fdd�	Zdd�Zdd�Zd'd
d�Zdd
�Zdd�Z	dd�Z
d(dd�Zdd�Zdd�Z
dd�Zedd��Zdd�ZdZdd�Zd d!�Zd"d#�Zd$d%�Z�ZS))�tzfilea�
    This is a ``tzinfo`` subclass thant allows one to use the ``tzfile(5)``
    format timezone files to extract current and historical zone information.

    :param fileobj:
        This can be an opened file stream or a file name that the time zone
        information can be read from.

    :param filename:
        This is an optional parameter specifying the source of the time zone
        information in the event that ``fileobj`` is a file object. If omitted
        and ``fileobj`` is a file stream, this parameter will be set either to
        ``fileobj``'s ``name`` attribute or to ``repr(fileobj)``.

    See `Sources for Time Zone and Daylight Saving Time Data
    <http://www.twinsun.com/tz/tz-link.htm>`_ for more information. Time zone
    files can be compiled from the `IANA Time Zone database files
    <https://www.iana.org/time-zones>`_ with the `zic time zone compiler
    <https://www.freebsd.org/cgi/man.cgi?query=zic&sektion=8>`_
    Nc	s�tt|�j�d}t|t�r2||_t|d�}d}n.|dk	rB||_nt|d�rV|j|_n
t	|�|_|dk	r�|stt
|�}|�}|j|�}WdQRX|j|�dS)NF�rbTr.)
r4rbr0rr�	_filename�open�hasattrr.r1�_ContextWrapper�_read_tzfile�_set_tzdata)r�fileobj�filenameZfile_opened_hereZfile_stream�tzobj)rrrr0ds"




ztzfile.__init__cCs*x$tjD]}t|d|t||��qWdS)z= Set the time zone data of this object from a _tzfile object �_N)rVr_rMrB)rrlrNrrrri|sztzfile._set_tzdatacs�t��|jd�j�dkr td��|jd�tjd|jd��\}}}}}}|rnttjd||j|d����_ng�_|r�tjd||j|���_ng�_g}x(t	|�D]}	|j
tjd	|jd
���q�W|j|�j�}
|r�|j|dtj
�|�rtjd||j|��}|�r"tjd||j|��}g�_x�t	|�D]�}	||	\}
}}d
|
dd
}
t�}|
|_tjd�|_tj|
d�|_||_|
||
jd|��|_||	k�o�||	dk|_||	k�o�||	dk|_�jj
|��q2W�fdd��jD��_d�_d�_d�_�j�r؈j�s$�jd�_�_n�x�t	|ddd�D]V}	�j|	}�j�r`|j�r`|�_n�j�rx|j�rx|�_�j�r6�j�r6P�q6W�j�r��j�r��j�_x,�jD]}|j�s�|�_P�q�W�jd�_d}g�_xlt�j�D]^\}	}|j�s
|j}|}n*|dk	�r*|j||_|�j|	<|�p2d}�jj
�j|	|��q�Wd}x~t t	t!�j���D]h}	�j|	}|j�r�|j�p�|dk�s�|j||_n|j}t"|jtj��s�tj|jd�|_|�j|	<�qhWt#�j��_t#�j��_t#�j��_�S)N�ZTZifzmagic not found�z>6l�z>%dlz>%dBz>lbb��z>%db�<�r)r(�csg|]}�j|�qSr)rZ)�.0�idx)�outrr�
<listcomp>sz'tzfile._read_tzfile.<locals>.<listcomp>r���rz)$rV�read�decode�
ValueError�struct�unpack�listrXrY�rangerO�seek�os�SEEK_CURrZrEr/r,r-rKrFrG�findrHrIrJr[r\r]r^rW�	enumerate�reversed�lenr�tuple)rrjZ
ttisgmtcntZ
ttisstdcntZleapcntZtimecntZtypecntZcharcntZttinfo�irHrIrJZgmtoffrGZabbrind�ttiZ
laststdoffsetr/r)rxrrh�s�
		






	



ztzfile._read_tzfileFcCs6|js
dSt|�}|r|jn|j}tj||�}|dS)Nr)�_trans_listr>Z_trans_list_utc�bisectZbisect_right)rr�in_utcr@rWrwrrr�_find_last_transition^sztzfile._find_last_transitioncCs8|dks|dt|j�kr |jS|dkr.|jS|j|S)Nrr)r�r��_ttinfo_stdZ_ttinfo_before�
_trans_idx)rrwrrr�_get_ttinfoms
ztzfile._get_ttinfocCs|j|�}|j|�S)N)�_resolve_ambiguous_timer�)rrrwrrr�_find_ttinfoxs
ztzfile._find_ttinfocCsnt|tj�std��|j|k	r&td��|j|dd�}|j|�}|tj|jd�}|j	||d�}t
|t|�d�S)a
        The ``tzfile`` implementation of :py:func:`datetime.tzinfo.fromutc`.

        :param dt:
            A :py:class:`datetime.datetime` object.

        :raises TypeError:
            Raised if ``dt`` is not a :py:class:`datetime.datetime` object.

        :raises ValueError:
            Raised if this is called with a ``dt`` which does not have this
            ``tzinfo`` attached.

        :return:
            Returns a :py:class:`datetime.datetime` object representing the
            wall time in ``self``'s time zone.
        z&fromutc() requires a datetime argumentzdt.tzinfo is not selfT)r�)r()rw)rA)rr,r*�tzinfor}r�r�r-r/rrr2)rrrwr�Zdt_outrArrrr}s

ztzfile.fromutccCsd|dkr|j|�}t|�}|j|�}|dks4|dkr8dS|j|d�j|j}|j|}|||kS)a6
        Whether or not the "wall time" of a given datetime is ambiguous in this
        zone.

        :param dt:
            A :py:class:`datetime.datetime`, naive or time zone aware.


        :return:
            Returns ``True`` if ambiguous, ``False`` otherwise.

        .. versionadded:: 2.6.0
        NrFr)r�r>r�r/r�)rrrwr@r�ZodZttrrrr�s


ztzfile.is_ambiguouscCsF|j|�}|j|�}|dks$|dkr(|St|o:|j||��}||S)Nr)r�rCr2r)rrrwrCZ
idx_offsetrrrr��s

ztzfile._resolve_ambiguous_timecCs"|dkrdS|jstS|j|�jS)N)r�r
r�rF)rrrrrr�s
ztzfile.utcoffsetcCs0|dkrdS|jstS|j|�}|js*tS|jS)N)Z_ttinfo_dstr
r�rGrK)rrr�rrrr�s
z
tzfile.dstcCs |js|dkrdS|j|�jS)N)r�r�rH)rrrrrr�sz
tzfile.tznamecCs2t|t�stS|j|jko0|j|jko0|j|jkS)N)rrbrr�r�Z_ttinfo_list)rrrrrr�s

z
tzfile.__eq__cCs
||kS)Nr)rrrrrr�sz
tzfile.__ne__cCsd|jjt|j�fS)Nz%s(%s))rr r1rd)rrrrr!�sztzfile.__repr__cCs
|jd�S)N)�
__reduce_ex__)rrrrr'�sztzfile.__reduce__cCs|jd|jf|jfS)N)rrd�__dict__)rZprotocolrrrr��sztzfile.__reduce_ex__)N)F)N)r r"r#r$r0rirhr�r�r�rrr�rrrrrr%rr!r'r�rDrr)rrrbNs(]
$

	rbc@s6eZdZdZddd�Zdd�Zdd�Zed	d
��ZdS)�tzrangeaQ
    The ``tzrange`` object is a time zone specified by a set of offsets and
    abbreviations, equivalent to the way the ``TZ`` variable can be specified
    in POSIX-like systems, but using Python delta objects to specify DST
    start, end and offsets.

    :param stdabbr:
        The abbreviation for standard time (e.g. ``'EST'``).

    :param stdoffset:
        An integer or :class:`datetime.timedelta` object or equivalent
        specifying the base offset from UTC.

        If unspecified, +00:00 is used.

    :param dstabbr:
        The abbreviation for DST / "Summer" time (e.g. ``'EDT'``).

        If specified, with no other DST information, DST is assumed to occur
        and the default behavior or ``dstoffset``, ``start`` and ``end`` is
        used. If unspecified and no other DST information is specified, it
        is assumed that this zone has no DST.

        If this is unspecified and other DST information is *is* specified,
        DST occurs in the zone but the time zone abbreviation is left
        unchanged.

    :param dstoffset:
        A an integer or :class:`datetime.timedelta` object or equivalent
        specifying the UTC offset during DST. If unspecified and any other DST
        information is specified, it is assumed to be the STD offset +1 hour.

    :param start:
        A :class:`relativedelta.relativedelta` object or equivalent specifying
        the time and time of year that daylight savings time starts. To specify,
        for example, that DST starts at 2AM on the 2nd Sunday in March, pass:

            ``relativedelta(hours=2, month=3, day=1, weekday=SU(+2))``

        If unspecified and any other DST information is specified, the default
        value is 2 AM on the first Sunday in April.

    :param end:
        A :class:`relativedelta.relativedelta` object or equivalent representing
        the time and time of year that daylight savings time ends, with the
        same specification method as in ``start``. One note is that this should
        point to the first time in the *standard* zone, so if a transition
        occurs at 2AM in the DST zone and the clocks are set back 1 hour to 1AM,
        set the `hours` parameter to +1.


    **Examples:**

    .. testsetup:: tzrange

        from dateutil.tz import tzrange, tzstr

    .. doctest:: tzrange

        >>> tzstr('EST5EDT') == tzrange("EST", -18000, "EDT")
        True

        >>> from dateutil.relativedelta import *
        >>> range1 = tzrange("EST", -18000, "EDT")
        >>> range2 = tzrange("EST", -18000, "EDT", -14400,
        ...                  relativedelta(hours=+2, month=4, day=1,
        ...                                weekday=SU(+1)),
        ...                  relativedelta(hours=+1, month=10, day=31,
        ...                                weekday=SU(-1)))
        >>> tzstr('EST5EDT') == range1 == range2
        True

    NcCs@ddlma||_||_yt|�}Wnttfk
r<YnXyt|�}Wnttfk
rbYnX|dk	r|tj|d�|_	nt
|_	|dk	r�tj|d�|_n(|r�|dk	r�|j	tjdd�|_nt
|_|r�|dkr�tjdddtjd
�d�|_
n||_
|�r|dk�rtjdd	d
tjd�d�|_n||_|j|j	|_t|j
�|_dS)Nr)�
relativedelta)r(r)�hours�rn)r��month�day�weekday�
�rr�rrrz)�dateutilr��	_std_abbr�	_dst_abbrrr*r+r,r-r7r
r8�SU�_start_delta�
_end_delta�_dst_base_offset_r:�hasdst)r�stdabbr�	stdoffset�dstabbrrK�start�endrrrr0Js:ztzrange.__init__cCs4|js
dStj|dd�}||j}||j}||fS)a�
        For a given year, get the DST on and off transition times, expressed
        always on the standard time side. For zones with no transitions, this
        function returns ``None``.

        :param year:
            The year whose transitions you would like to query.

        :return:
            Returns a :class:`tuple` of :class:`datetime.datetime` objects,
            ``(dston, dstoff)`` for zones with an annual DST transition, or
            ``None`` for fixed offset zones.
        Nr)r�r,r�r�)rZyearZ	base_yearr�r�rrr�transitionsys

ztzrange.transitionscCsVt|t�stS|j|jkoT|j|jkoT|j|jkoT|j|jkoT|j|jkoT|j|jkS)N)	rr�rr�r�r7r8r�r�)rrrrrr�s
ztzrange.__eq__cCs|jS)N)r�)rrrr�_dst_base_offset�sztzrange._dst_base_offset)NNNNN)	r r"r#r$r0r�r�propertyr�rrrrr�sI
-r�c@s,eZdZdZddd�Zddd�Zdd	�Zd
S)
�tzstra
    ``tzstr`` objects are time zone objects specified by a time-zone string as
    it would be passed to a ``TZ`` variable on POSIX-style systems (see
    the `GNU C Library: TZ Variable`_ for more details).

    There is one notable exception, which is that POSIX-style time zones use an
    inverted offset format, so normally ``GMT+3`` would be parsed as an offset
    3 hours *behind* GMT. The ``tzstr`` time zone object will parse this as an
    offset 3 hours *ahead* of GMT. If you would like to maintain the POSIX
    behavior, pass a ``True`` value to ``posix_offset``.

    The :class:`tzrange` object provides the same functionality, but is
    specified using :class:`relativedelta.relativedelta` objects. rather than
    strings.

    :param s:
        A time zone string in ``TZ`` variable format. This can be a
        :class:`bytes` (2.x: :class:`str`), :class:`str` (2.x: :class:`unicode`)
        or a stream emitting unicode characters (e.g. :class:`StringIO`).

    :param posix_offset:
        Optional. If set to ``True``, interpret strings such as ``GMT+3`` or
        ``UTC+3`` as being 3 hours *behind* UTC rather than ahead, per the
        POSIX standard.

    .. _`GNU C Library: TZ Variable`:
        https://www.gnu.org/software/libc/manual/html_node/TZ-Variable.html
    Fc	Cs�ddlma||_tj|�}|dkr,td��|jd
krJ|rJ|jd9_tj||j|j|j	|j
ddd�|j	s~d|_d|_n&|j
|j�|_|jr�|j
|jdd	�|_t|j�|_dS)Nr)�parserzunknown string format�GMTrrF)r�r�)�isend)r�rrz)r�r��_sZ_parsetzr}r�r�r�r0r�rKr�r��_deltar�r�r:r�)r�sZposix_offset�resrrrr0�s"

ztzstr.__init__rcCs<ddlm}i}|jdk	rr|j|d<|jdk	r`|j|j|j�|d<|jdkrVd|d<qpd|d<q�|jr�|j|d<n*|jdk	r�|j|d<n|jdk	r�|j|d	<|s�|s�d
|d<d|d<|jd�|d<nd|d<d|d<|jd�|d<|j	dk	�r�|j	|d<nd
|d<|�r0|j
|j}|d|j|j
d8<|jf|�S)Nr)r�r�r�rr�r�ZyeardayZ	nlyeardayrnr�r(i i�Qrrz)r�r�r�r�Zweekr�ZydayZjydayr�r5r8r7r(Zdays)r�xr�r�rarFrrrr��s<








ztzstr._deltacCsd|jjt|j�fS)Nz%s(%s))rr r1r�)rrrrr!sztzstr.__repr__N)F)r)r r"r#r$r0r�r!rrrrr��s
 
)r�c@seZdZddd�ZdS)�_tzicalvtzcompNcCs@tj|d�|_tj|d�|_|j|j|_||_||_||_dS)N)r()r,r-�tzoffsetfrom�
tzoffsetto�tzoffsetdiffrGr�rrule)rr�r�rGrr�rrrr0sz_tzicalvtzcomp.__init__)NN)r r"r#r0rrrrr�sr�csZeZdZgf�fdd�	Zdd�Zdd�Zdd�Zd	d
�Zedd��Z	d
d�Z
ejZ�Z
S)�
_tzicalvtzcs*tt|�j�||_||_g|_g|_dS)N)r4r�r0�_tzid�_comps�
_cachedate�
_cachecomp)r�tzid�comps)rrrr0s
z_tzicalvtz.__init__c
Cs
t|j�dkr|jdS|jdd�}y|j|jj||j|�f�Stk
rTYnXd}d}x4|jD]*}|j||�}|rf|s�||krf|}|}qfW|s�x"|jD]}|j	s�|}Pq�W|d}|jj
d||j|�f�|jj
d|�t|j�dk�r|jj�|jj�|S)Nrr)r�r�)r�r��replacer�r��indexrCr}�_find_compdtrG�insert�pop)rrZ
lastcompdtZlastcomp�comp�compdtrrr�
_find_comps4


z_tzicalvtz._find_compcCs2|jtkr|j|�r||j8}|jj|dd�}|S)NT)Zinc)r�r
rCr�Zbefore)rr�rr�rrrr�Is
z_tzicalvtz._find_compdtcCs|dkrdS|j|�jS)N)r�r�)rrrrrrQsz_tzicalvtz.utcoffsetcCs|j|�}|jr|jStSdS)N)r�rGr�r
)rrr�rrrrWs
z_tzicalvtz.dstcCs|j|�jS)N)r�r)rrrrrr^sz_tzicalvtz.tznamecCsdt|j�S)Nz<tzicalvtz %s>)r1r�)rrrrr!bsz_tzicalvtz.__repr__)r r"r#r0r�r�rrrrr!r&r'rDrr)rrr�s*r�c@sBeZdZdZdd�Zdd�Zddd�Zd	d
�Zdd�Zd
d�Z	dS)�tzicala\
    This object is designed to parse an iCalendar-style ``VTIMEZONE`` structure
    as set out in `RFC 2445`_ Section 4.6.5 into one or more `tzinfo` objects.

    :param `fileobj`:
        A file or stream in iCalendar format, which should be UTF-8 encoded
        with CRLF endings.

    .. _`RFC 2445`: https://www.ietf.org/rfc/rfc2445.txt
    c	Csjddlmat|t�r(||_t|d�}nt|dt|��|_t|�}i|_	|�}|j
|j��WdQRXdS)Nr)r��rr.)r�r�rrr�rerBr1rg�_vtz�
_parse_rfcr{)rrjZfobjrrrr0ss
ztzical.__init__cCst|jj��S)z?
        Retrieves the available time zones as a list.
        )r�r��keys)rrrrr��sztzical.keysNcCsP|dkrDt|j�dkr td��nt|j�dkr6td��tt|j��}|jj|�S)a�
        Retrieve a :py:class:`datetime.tzinfo` object by its ``tzid``.

        :param tzid:
            If there is exactly one time zone available, omitting ``tzid``
            or passing :py:const:`None` value returns it. Otherwise a valid
            key (which can be retrieved from :func:`keys`) is required.

        :raises ValueError:
            Raised if ``tzid`` is not specified but there are either more
            or fewer than 1 zone defined.

        :returns:
            Returns either a :py:class:`datetime.tzinfo` object representing
            the relevant time zone or :py:const:`None` if the ``tzid`` was
            not found.
        Nrzno timezones definedrz more than one timezone available)r�r�r}�next�iterr`)rr�rrrr`�s
z
tzical.getcCs�|j�}|std��|ddkr>d|ddk}|dd�}nd}t|�dkrzt|dd��dt|dd��d	|St|�d
kr�t|dd��dt|dd��d	t|dd��|Std|��dS)Nzempty offsetr�+�-rrnr�irsrqzinvalid offset: )r�r�rzr)rzrr)�stripr}r�r2)rr��signalrrr�
_parse_offset�s,<ztzical._parse_offsetcCsH|j�}|std��d}xh|t|�kr�||j�}|s>||=q|dkrv|ddkrv||d|dd�7<||=q|d7}qWd}g}d}d}�x�|D�]�}|s�q�|jdd�\}	}
|	jd�}|s�td��|dj�}	|dd�}|�r$|	d	k�r(|
d)k�rntd|
��|
}d}d}
d}g}d}�q@|	d
k�r|
dk�r�|�rNtd|��|�s\td��|�sjtd��t||�|j|<d}n�|
|k�r|�s�td��|
dk�r�td��|dk�r�td��d}|�r�tj	dj
|�dddd�}t|
||dk||�}|j|�d}ntd|
���q@|�r�|	dk�r2|j|�d}n�|	d*k�rH|j|�n�|	dk�rx|�rltd|	|df��|j
|
�}
nj|	dk�r�|�r�td |d��|j
|
�}n>|	d!k�r�|�r�td"|d��|
}n|	d#k�r�ntd$|	��n>|	d%k�r
|�rtd&|d��|
}n|	d+k�rntd$|	��q�|	d	kr�|
dkr�d}g}d}q�WdS),Nzempty stringr� rF�:�;zempty property nameZBEGIN�STANDARD�DAYLIGHTzunknown component: ZENDZ	VTIMEZONEzcomponent not closed: zmandatory TZID not foundz at least one component is neededzmandatory DTSTART not foundz mandatory TZOFFSETFROM not found�
T)Z
compatibleZignoretz�cachezinvalid component end: ZDTSTART�RRULE�RDATE�EXRULE�EXDATEZTZOFFSETFROMzunsupported %s parm: %s Z
TZOFFSETTOzunsupported TZOFFSETTO parm: ZTZNAMEzunsupported TZNAME parm: �COMMENTzunsupported property: ZTZIDzunsupported TZID parm: �TZURL�
LAST-MODIFIED)r�r�)r�r�r�r�)r�r�r�)�
splitlinesr}r��rstrip�split�upperr�r�r�ZrrulestrrPr�rOr�)rr��linesr��liner�r�ZinvtzZcomptyper.rRZparmsZfounddtstartr�r�Z
rrulelinesrZrrr�rrrr��s�

















ztzical._parse_rfccCsd|jjt|j�fS)Nz%s(%s))rr r1r�)rrrrr!+sztzical.__repr__)N)
r r"r#r$r0r�r`r�r�r!rrrrr�hs

vr�Zwin32z/etc/localtimer?z/usr/share/zoneinfoz/usr/lib/zoneinfoz/usr/share/lib/zoneinfoz
/etc/zoneinfocCsDd}|s,ytjd}Wntk
r*YnX|dks<|dkr�x�tD]v}tjj|�s�|}x*tD] }tjj||�}tjj|�r\Pq\WqBtjj|�rByt	|�}PWqBt
ttfk
r�YqBXqBWt
�}�nz|jd�r�|dd�}tjj|��r
tjj|��rt	|�}nd}�n6�x2tD]l}tjj||�}tjj|��sP|jdd�}tjj|��sP�qyt	|�}PWnt
ttfk
�rzYnX�qWd}tdk	�r�yt|�}Wntk
�r�d}YnX|�s�ddlm}|�j|�}|�s@xb|D]6}|dk�r�yt|�}Wntk
�rYnXP�q�W|dk�r.t�}n|tjk�r@t
�}|S)
NZTZr�rr�rmr)�get_zonefile_instance�
0123456789r�rrz)r�r)r��environ�KeyError�TZFILES�path�isabs�TZPATHSrP�isfilerb�IOError�OSErrorr}r3�
startswithr�r
ZWindowsErrorZdateutil.zoneinfor�r`r�rr5r)r.�tz�filepathrkr�r��crrr�gettz:sz










r�cCsZ|dkr |jdkrtd��|j}|jdd�}|j|d�jt��j|�}|jdd�}||kS)a�
    Given a datetime and a time zone, determine whether or not a given datetime
    would fall in a gap.

    :param dt:
        A :class:`datetime.datetime` (whose time zone will be ignored if ``tz``
        is provided.)

    :param tz:
        A :class:`datetime.tzinfo` with support for the ``fold`` attribute. If
        ``None`` or not provided, the datetime's own time zone will be used.

    :return:
        Returns a boolean value whether or not the "wall time" exists in ``tz``.
    Nz,Datetime is naive and no time zone provided.)r�)r�r}r�Z
astimezoner)rr�Zdt_rtrrr�datetime_exists�s
r�c
Cs�|dkr |jdkrtd��|j}t|dd�}|dk	rLy
|j|�SYnX|j|d�}t|dd�}t|dd�}|j�|j�k}|j�|j�k}|o�|S)a\
    Given a datetime and a time zone, determine whether or not a given datetime
    is ambiguous (i.e if there are two times differentiated only by their DST
    status).

    :param dt:
        A :class:`datetime.datetime` (whose time zone will be ignored if ``tz``
        is provided.)

    :param tz:
        A :class:`datetime.tzinfo` with support for the ``fold`` attribute. If
        ``None`` or not provided, the datetime's own time zone will be used.

    :return:
        Returns a boolean value whether or not the "wall time" is ambiguous in
        ``tz``.

    .. versionadded:: 2.6.0
    Nz,Datetime is naive and no time zone provided.r)r�r)rAr)r�r}rBrr�rrr)rr�Zis_ambiguous_fnZwall_0Zwall_1Zsame_offsetZsame_dstrrr�datetime_ambiguous�s 

r�cCst|jdd�t�S)z�
    Convert a :class:`datetime.datetime` object to an epoch timestamp in seconds
    since January 1, 1970, ignoring the time zone.
    N)r�)rr��EPOCH)rrrrr>�sr>c@s(eZdZdZdd�Zdd�Zdd�ZdS)	rgz^
    Class for wrapping contexts so that they are passed through in a
    with statement.
    cCs
||_dS)N)�context)rrrrrr0�sz_ContextWrapper.__init__cCs|jS)N)r)rrrr�	__enter__�sz_ContextWrapper.__enter__cOsdS)Nr)�argsrarrr�__exit__�sz_ContextWrapper.__exit__N)r r"r#r$r0rrrrrrrg�srg)N)N)N)/r$r,r~r5�sysr�r�ZsixrZ_commonrrrrrr	�winr
r�ImportErrorr-r
ZutcfromtimestamprZ	toordinalZEPOCHORDINALr�rrr3r&rErVrbr�r�r�r�r��platformr�r�r�r�r�r>rgrrrr�<module>	s\
8Fv-
5"jRH
J

.PKa�\_ސ��$�$'tz/__pycache__/win.cpython-36.opt-1.pycnu�[���3

6�cY�,�@s�ddlZddlZddlmZddlmZyddlZddlmZWnek
r\e	d��YnXddl
mZdd	d
gZej
d�ZdZd
ZdZdd�Ze�ZGdd
�d
e�ZGdd�de�ZGdd�de�ZGdd	�d	e�Zdd�Zdd�ZdS)�N)�winreg)�	text_type)�wintypesz#Running tzwin on non-Windows system�)�tzrangebase�tzwin�
tzwinlocal�tzres�z7SOFTWARE\Microsoft\Windows NT\CurrentVersion\Time Zonesz4SOFTWARE\Microsoft\Windows\CurrentVersion\Time Zonesz4SYSTEM\CurrentControlSet\Control\TimeZoneInformationcCsLtjdtj�}ytj|t�j�t}Wntk
r>t}YnX|j�|S)N)r�ConnectRegistry�HKEY_LOCAL_MACHINE�OpenKey�TZKEYNAMENTZCloseZWindowsError�TZKEYNAME9X)�handle�	TZKEYNAME�r�/usr/lib/python3.6/win.py�
_settzkeynames
rc@s6eZdZdZejej�Zd
dd�Z	dd�Z
dd�Zd	S)r	z{
    Class for accessing `tzres.dll`, which contains timezone name related
    resources.

    .. versionadded:: 2.5.0
    �	tzres.dllcCs@tjd�}tjtjtjtjf|j_|j|_tj|�|_	||_
dS)N�user32)�ctypesZWinDLLrZ	HINSTANCEZUINT�LPWSTRZc_int�LoadStringWZargtypes�_tzres�	tzres_loc)�selfrrrrr�__init__1s
ztzres.__init__cCs<|j�}tjtj|�tj�}|j|jj||d�}|d|�S)a�
        Load a timezone name from a DLL offset (integer).

        >>> from dateutil.tzwin import tzres
        >>> tzr = tzres()
        >>> print(tzr.load_name(112))
        'Eastern Standard Time'

        :param offset:
            A positive integer value referring to a string from the tzres dll.

        ..note:
            Offsets found in the registry are generally of the form
            `@tzres.dll,-114`. The offset in this case if 114, not -114.

        rN)	�p_wcharr�castZbyrefrrrrZ_handle)r�offsetZresourceZlpBufferZncharrrr�	load_name?sztzres.load_namec	CsH|jd�s|S|jd�}yt|d�}Wntd��YnX|j|�S)a�
        Parse strings as returned from the Windows registry into the time zone
        name as defined in the registry.

        >>> from dateutil.tzwin import tzres
        >>> tzr = tzres()
        >>> print(tzr.name_from_string('@tzres.dll,-251'))
        'Dateline Daylight Time'
        >>> print(tzr.name_from_string('Eastern Standard Time'))
        'Eastern Standard Time'

        :param tzname_str:
            A timezone name string as returned from a Windows registry key.

        :return:
            Returns the localized timezone string from tzres.dll if the string
            is of the form `@tzres.dll,-offset`, else returns the input string.
        �@z,-rzMalformed timezone string.)�
startswith�split�int�
ValueErrorr!)rZ
tzname_strZ	name_spltr rrr�name_from_stringUs

ztzres.name_from_stringN)r)�__name__�
__module__�__qualname__�__doc__rZPOINTERrZWCHARrrr!r'rrrrr	(s

c@sPeZdZdZdd�Zdd�Zedd��Zdd	�Zd
d�Z	dd
�Z
edd��ZdS)�	tzwinbasezBtzinfo class based on win32's timezones available in the registry.cCstd��dS)Nz#tzwinbase is an abstract base class)�NotImplementedError)rrrrrvsztzwinbase.__init__cCs�t|t�stS|j|jko�|j|jko�|j|jko�|j|jko�|j|jko�|j|jko�|j	|j	ko�|j
|j
ko�|j|jko�|j|jko�|j
|j
ko�|j|jkS)N)�
isinstancer,�NotImplemented�_std_offset�_dst_offset�
_stddayofweek�
_dstdayofweek�_stdweeknumber�_dstweeknumber�_stdhour�_dsthour�
_stdminute�
_dstminute�	_std_abbr�	_dst_abbr)r�otherrrr�__eq__ys
ztzwinbase.__eq__csVtjdtj��>}tj|t��&��fdd�ttj��d�D�}WdQRXWdQRX|S)z4Return a list of all time zones known to the system.Ncsg|]}tj�|��qSr)rZEnumKey)�.0�i)�tzkeyrr�
<listcomp>�sz"tzwinbase.list.<locals>.<listcomp>r)rrrr
r�range�QueryInfoKey)r�resultr)r@r�list�s

*ztzwinbase.listcCs|jS)N)�_display)rrrr�display�sztzwinbase.displaycCsT|js
dSt||j|j|j|j|j�}t||j|j|j	|j
|j�}||j8}||fS)a�
        For a given year, get the DST on and off transition times, expressed
        always on the standard time side. For zones with no transitions, this
        function returns ``None``.

        :param year:
            The year whose transitions you would like to query.

        :return:
            Returns a :class:`tuple` of :class:`datetime.datetime` objects,
            ``(dston, dstoff)`` for zones with an annual DST transition, or
            ``None`` for fixed offset zones.
        N)
�hasdst�picknthweekday�	_dstmonthr3r7r9r5�	_stdmonthr2r6r8r4�_dst_base_offset)r�yearZdstonZdstoffrrr�transitions�s
ztzwinbase.transitionscCs
|jdkS)Nr)rJ)rrrr�_get_hasdst�sztzwinbase._get_hasdstcCs|jS)N)�_dst_base_offset_)rrrrrL�sztzwinbase._dst_base_offsetN)
r(r)r*r+rr=�staticmethodrErGrNrO�propertyrLrrrrr,ts	r,c@s$eZdZdd�Zdd�Zdd�ZdS)rc	Cs||_tjdtj��8}td�jt|d�}tj||��}t|�}WdQRXWdQRX|d|_	|d|_
|d|_tj
d|d�}|d|d	}||d
}tj|d�|_tj|d�|_|dd
�\|_|_|_|_|_|dd�\|_|_|_|_|_|j|j|_|j�|_dS)Nz{kn}\{name})�kn�nameZStdZDlt�Displayz=3l16hZTZIrr�)�minutes��	��)�_namerrrr�formatrr
�valuestodictr:r;rF�struct�unpack�datetime�	timedeltar0r1rKr2r4r6r8rJr3r5r7r9rPrOrH)	rrTr�	tzkeynamer@�keydict�tup�	stdoffset�	dstoffsetrrrr�s"


  ztzwin.__init__cCsdt|j�S)Nz	tzwin(%s))�reprr\)rrrr�__repr__�sztzwin.__repr__cCs|j|jffS)N)�	__class__r\)rrrr�
__reduce__�sztzwin.__reduce__N)r(r)r*rrirkrrrrr�s&c@s,eZdZdd�Zdd�Zdd�Zdd�Zd	S)
rc
 Csntjdtj���}tj|t��}t|�}WdQRX|d|_|d|_yBtd�j	t
|jd�}tj||��}t|�}|d|_WdQRXWntk
r�d|_YnXWdQRX|d|d}||d}t
j|d	�|_t
j|d	�|_tjd
|d�}	|	dd
�\|_|_|_|_|	d|_tjd
|d�}	|	dd
�\|_|_|_|_|	d|_|j|j|_|j�|_dS)NZStandardNameZDaylightNamez	{kn}\{sn})rSZsnrUZBiasZStandardBiasZDaylightBias)rWz=8hZ
StandardStartr�r
Z
DaylightStart) rrrr
�TZLOCALKEYNAMEr^r:r;rr]rrF�OSErrorrarbr0r1r_r`rKr4r6r8r2rJr5r7r9r3rPrOrH)
rrZ
tzlocalkeyrdrcr@Z_keydictrfrgrerrrr�s2





ztzwinlocal.__init__cCsdS)Nztzwinlocal()r)rrrrrisztzwinlocal.__repr__cCsdt|j�S)Nztzwinlocal(%s))rhr:)rrrr�__str__sztzwinlocal.__str__cCs
|jffS)N)rj)rrrrrk#sztzwinlocal.__reduce__N)r(r)r*rrirorkrrrrr�s.c	CsTtj||d||�}|j||j�ddd�}||dt}|j|krP|t8}|S)z> dayofweek == 0 means Sunday, whichweek 5 means last instance rr
)Zday)ra�replaceZ
isoweekday�ONEWEEK�month)	rMrrZ	dayofweekZhourZminuteZ	whichweek�firstZ
weekdayoneZwdrrrrI's
rIcCs�i}tj|�d}d}x�t|�D]v}tj||�\}}}|tjksJ|tjkr\|d@r�|d}n2|tjkr�|jd�r�|pxt�}|j	|�}|j
d�}|||<q W|S)	z0Convert a registry key's values to a dictionary.rN�� z@tzres�ll)rrCrBZ	EnumValueZ	REG_DWORDZREG_DWORD_LITTLE_ENDIANZREG_SZr#r	r'�rstrip)�keyZdout�sizeZtz_resr?Zkey_name�valueZdtyperrrr^5s





r^)rar_Z	six.movesrZsixrrrr&�ImportErrorZ_commonr�__all__rbrqrrrmrr�objectr	r,rrrIr^rrrr�<module>s,

LJ/:PKa�\)XH_a�a�&tz/__pycache__/tz.cpython-36.opt-1.pycnu�[���3

6�cY���@s�dZddlZddlZddlZddlZddlZddlZddlmZddl	m
Z
mZmZddl	m
Z
mZddl	mZyddlmZmZWnek
r�dZZYnXejd�Zejjd�Zej�ZGd	d
�d
ej�ZGdd�dej�ZGd
d�de�ZGdd�de�ZGdd�de�Z Gdd�de�Z!Gdd�de
�Z"Gdd�de"�Z#Gdd�de�Z$Gdd�de�Z%Gdd�de�Z&ej'dk�r�d d!gZ(d"d#d$d%gZ)ngZ(gZ)d0d&d'�Z*d1d(d)�Z+d2d*d+�Z,d,d-�Z-Gd.d/�d/e�Z.dS)3a{
This module offers timezone implementations subclassing the abstract
:py:`datetime.tzinfo` type. There are classes to handle tzfile format files
(usually are in :file:`/etc/localtime`, :file:`/usr/share/zoneinfo`, etc), TZ
environment string (in all known formats), given ranges (with help from
relative deltas), local machine timezone, fixed offset timezone, and UTC
timezone.
�N)�string_types�)�tzname_in_python2�_tzinfo�_total_seconds)�tzrangebase�enfold)�_validate_fromutc_inputs)�tzwin�
tzwinlocalc@sbeZdZdZdd�Zdd�Zedd��Zdd	�Ze	d
d��Z
dd
�ZdZdd�Z
dd�ZejZdS)�tzutczD
    This is a tzinfo object that represents the UTC time zone.
    cCstS)N)�ZERO)�self�dt�r�/usr/lib/python3.6/tz.py�	utcoffset$sztzutc.utcoffsetcCstS)N)r
)rrrrr�dst'sz	tzutc.dstcCsdS)N�UTCr)rrrrr�tzname*sztzutc.tznamecCsdS)a6
        Whether or not the "wall time" of a given datetime is ambiguous in this
        zone.

        :param dt:
            A :py:class:`datetime.datetime`, naive or time zone aware.


        :return:
            Returns ``True`` if ambiguous, ``False`` otherwise.

        .. versionadded:: 2.6.0
        Fr)rrrrr�is_ambiguous.sztzutc.is_ambiguouscCs|S)z�
        Fast track version of fromutc() returns the original ``dt`` object for
        any valid :py:class:`datetime.datetime` object.
        r)rrrrr�fromutc>sz
tzutc.fromutccCs0t|ttf�stSt|t�p.t|t�o.|jtkS)N)�
isinstancer�tzoffset�NotImplemented�_offsetr
)r�otherrrr�__eq__Fs
ztzutc.__eq__NcCs
||kS)Nr)rrrrr�__ne__Osztzutc.__ne__cCsd|jjS)Nz%s())�	__class__�__name__)rrrr�__repr__Rsztzutc.__repr__)r �
__module__�__qualname__�__doc__rrrrrr	rr�__hash__rr!�object�
__reduce__rrrrr src@sjeZdZdZdd�Zdd�Zdd�Zedd	��Ze	d
d��Z
dd
�Zdd�ZdZ
dd�Zdd�ZejZdS)ra1
    A simple class for representing a fixed offset from UTC.

    :param name:
        The timezone name, to be returned when ``tzname()`` is called.

    :param offset:
        The time zone offset in seconds, or (since version 2.6.0, represented
        as a :py:class:`datetime.timedelta` object.
    cCs>||_yt|�}Wnttfk
r*YnXtj|d�|_dS)N)�seconds)�_namer�	TypeError�AttributeError�datetime�	timedeltar)r�name�offsetrrr�__init__csztzoffset.__init__cCs|jS)N)r)rrrrrrmsztzoffset.utcoffsetcCstS)N)r
)rrrrrrpsztzoffset.dstcCs|jS)N)r))rrrrrrssztzoffset.tznamecCs
||jS)N)r)rrrrrrwsztzoffset.fromutccCsdS)a6
        Whether or not the "wall time" of a given datetime is ambiguous in this
        zone.

        :param dt:
            A :py:class:`datetime.datetime`, naive or time zone aware.


        :return:
            Returns ``True`` if ambiguous, ``False`` otherwise.

        .. versionadded:: 2.6.0
        Fr)rrrrrr{sztzoffset.is_ambiguouscCst|t�stS|j|jkS)N)rrrr)rrrrrr�s
ztzoffset.__eq__NcCs
||kS)Nr)rrrrrr�sztzoffset.__ne__cCs"d|jjt|j�tt|j��fS)Nz
%s(%s, %s))rr �reprr)�intrr)rrrrr!�sztzoffset.__repr__)r r"r#r$r0rrrrr	rrrr%rr!r&r'rrrrrXs

rcsxeZdZdZ�fdd�Zdd�Zdd�Zedd	��Zd
d�Z	dd
�Z
ddd�Zdd�ZdZ
dd�Zdd�ZejZ�ZS)�tzlocalzR
    A :class:`tzinfo` subclass built around the ``time`` timezone functions.
    cs`tt|�j�tjtjd�|_tjr:tjtj	d�|_
n|j|_
|j
|j|_t|j�|_
dS)N)r()�superr3r0r,r-�time�timezone�_std_offsetZdaylightZaltzone�_dst_offset�
_dst_saved�bool�_hasdst)r)rrrr0�sztzlocal.__init__cCs,|dkr|jrdS|j|�r"|jS|jSdS)N)r;�_isdstr8r7)rrrrrr�s

ztzlocal.utcoffsetcCs0|dkr|jrdS|j|�r(|j|jStSdS)N)r;r<r8r7r
)rrrrrr�s

ztzlocal.dstcCstj|j|�S)N)r5rr<)rrrrrr�sztzlocal.tznamecCs$|j|�}|o"||j||j�kS)a6
        Whether or not the "wall time" of a given datetime is ambiguous in this
        zone.

        :param dt:
            A :py:class:`datetime.datetime`, naive or time zone aware.


        :return:
            Returns ``True`` if ambiguous, ``False`` otherwise.

        .. versionadded:: 2.6.0
        )�
_naive_is_dstr9)rrZ	naive_dstrrrr�s
ztzlocal.is_ambiguouscCst|�}tj|tj�jS)N)�_datetime_to_timestampr5�	localtimer6Ztm_isdst)rr�	timestamprrrr=�sztzlocal._naive_is_dstTcCsF|js
dS|j|�}t|dd�}|j|�rB|dk	r>|j|�SdS|S)NF�foldT)r;r=�getattrr�_fold)rrZ
fold_naiveZdstvalrArrrr<�s

ztzlocal._isdstcCs&t|t�stS|j|jko$|j|jkS)N)rr3rr7r8)rrrrrrs
ztzlocal.__eq__NcCs
||kS)Nr)rrrrrrsztzlocal.__ne__cCsd|jjS)Nz%s())rr )rrrrr!sztzlocal.__repr__)T)r r"r#r$r0rrrrrr=r<rr%rr!r&r'�
__classcell__rr)rrr3�s		
(r3c@sReZdZdddddddgZdd	�Zd
d�Zdd
�ZdZdd�Zdd�Z	dd�Z
dS)�_ttinfor/�delta�isdst�abbr�isstd�isgmt�	dstoffsetcCs x|jD]}t||d�qWdS)N)�	__slots__�setattr)r�attrrrrr0sz_ttinfo.__init__cCsRg}x6|jD],}t||�}|dk	r|jd|t|�f�qWd|jjdj|�fS)Nz%s=%sz%s(%s)z, )rLrB�appendr1rr �join)r�lrN�valuerrrr!s
z_ttinfo.__repr__cCsbt|t�stS|j|jko`|j|jko`|j|jko`|j|jko`|j|jko`|j|jko`|j	|j	kS)N)
rrErr/rFrGrHrIrJrK)rrrrrr$s
z_ttinfo.__eq__NcCs
||kS)Nr)rrrrrr2sz_ttinfo.__ne__cCs(i}x|jD]}t||d�||<qW|S)N)rLrB)r�stater.rrr�__getstate__5sz_ttinfo.__getstate__cCs,x&|jD]}||krt||||�qWdS)N)rLrM)rrSr.rrr�__setstate__;sz_ttinfo.__setstate__)r r"r#rLr0r!rr%rrTrUrrrrrEs
rEc@s,eZdZdZdddddddd	gZd
d�ZdS)
�_tzfilezw
    Lightweight class for holding the relevant transition and time zone
    information read from binary tzfiles.
    �
trans_list�trans_list_utc�	trans_idx�ttinfo_list�
ttinfo_std�
ttinfo_dst�
ttinfo_before�ttinfo_firstcKs(x"|jD]}t|||j|d��qWdS)N)�attrsrM�get)r�kwargsrNrrrr0Isz_tzfile.__init__N)r r"r#r$r_r0rrrrrVAsrVcs�eZdZdZd&�fdd�	Zdd�Zdd�Zd'd
d�Zdd
�Zdd�Z	dd�Z
d(dd�Zdd�Zdd�Z
dd�Zedd��Zdd�ZdZdd�Zd d!�Zd"d#�Zd$d%�Z�ZS))�tzfilea�
    This is a ``tzinfo`` subclass thant allows one to use the ``tzfile(5)``
    format timezone files to extract current and historical zone information.

    :param fileobj:
        This can be an opened file stream or a file name that the time zone
        information can be read from.

    :param filename:
        This is an optional parameter specifying the source of the time zone
        information in the event that ``fileobj`` is a file object. If omitted
        and ``fileobj`` is a file stream, this parameter will be set either to
        ``fileobj``'s ``name`` attribute or to ``repr(fileobj)``.

    See `Sources for Time Zone and Daylight Saving Time Data
    <http://www.twinsun.com/tz/tz-link.htm>`_ for more information. Time zone
    files can be compiled from the `IANA Time Zone database files
    <https://www.iana.org/time-zones>`_ with the `zic time zone compiler
    <https://www.freebsd.org/cgi/man.cgi?query=zic&sektion=8>`_
    Nc	s�tt|�j�d}t|t�r2||_t|d�}d}n.|dk	rB||_nt|d�rV|j|_n
t	|�|_|dk	r�|stt
|�}|�}|j|�}WdQRX|j|�dS)NF�rbTr.)
r4rbr0rr�	_filename�open�hasattrr.r1�_ContextWrapper�_read_tzfile�_set_tzdata)r�fileobj�filenameZfile_opened_hereZfile_stream�tzobj)rrrr0ds"




ztzfile.__init__cCs*x$tjD]}t|d|t||��qWdS)z= Set the time zone data of this object from a _tzfile object �_N)rVr_rMrB)rrlrNrrrri|sztzfile._set_tzdatacs�t��|jd�j�dkr td��|jd�tjd|jd��\}}}}}}|rnttjd||j|d����_ng�_|r�tjd||j|���_ng�_g}x(t	|�D]}	|j
tjd	|jd
���q�W|j|�j�}
|r�|j|dtj
�|�rtjd||j|��}|�r"tjd||j|��}g�_x�t	|�D]�}	||	\}
}}d
|
dd
}
t�}|
|_tjd�|_tj|
d�|_||_|
||
jd|��|_||	k�o�||	dk|_||	k�o�||	dk|_�jj
|��q2W�fdd��jD��_d�_d�_d�_�j�r؈j�s$�jd�_�_n�x�t	|ddd�D]V}	�j|	}�j�r`|j�r`|�_n�j�rx|j�rx|�_�j�r6�j�r6P�q6W�j�r��j�r��j�_x,�jD]}|j�s�|�_P�q�W�jd�_d}g�_xlt�j�D]^\}	}|j�s
|j}|}n*|dk	�r*|j||_|�j|	<|�p2d}�jj
�j|	|��q�Wd}x~t t	t!�j���D]h}	�j|	}|j�r�|j�p�|dk�s�|j||_n|j}t"|jtj��s�tj|jd�|_|�j|	<�qhWt#�j��_t#�j��_t#�j��_�S)N�ZTZifzmagic not found�z>6l�z>%dlz>%dBz>lbb��z>%db�<�r)r(�csg|]}�j|�qSr)rZ)�.0�idx)�outrr�
<listcomp>sz'tzfile._read_tzfile.<locals>.<listcomp>r���rz)$rV�read�decode�
ValueError�struct�unpack�listrXrY�rangerO�seek�os�SEEK_CURrZrEr/r,r-rKrFrG�findrHrIrJr[r\r]r^rW�	enumerate�reversed�lenr�tuple)rrjZ
ttisgmtcntZ
ttisstdcntZleapcntZtimecntZtypecntZcharcntZttinfo�irHrIrJZgmtoffrGZabbrind�ttiZ
laststdoffsetr/r)rxrrh�s�
		






	



ztzfile._read_tzfileFcCs6|js
dSt|�}|r|jn|j}tj||�}|dS)Nr)�_trans_listr>Z_trans_list_utc�bisectZbisect_right)rr�in_utcr@rWrwrrr�_find_last_transition^sztzfile._find_last_transitioncCs8|dks|dt|j�kr |jS|dkr.|jS|j|S)Nrr)r�r��_ttinfo_stdZ_ttinfo_before�
_trans_idx)rrwrrr�_get_ttinfoms
ztzfile._get_ttinfocCs|j|�}|j|�S)N)�_resolve_ambiguous_timer�)rrrwrrr�_find_ttinfoxs
ztzfile._find_ttinfocCsnt|tj�std��|j|k	r&td��|j|dd�}|j|�}|tj|jd�}|j	||d�}t
|t|�d�S)a
        The ``tzfile`` implementation of :py:func:`datetime.tzinfo.fromutc`.

        :param dt:
            A :py:class:`datetime.datetime` object.

        :raises TypeError:
            Raised if ``dt`` is not a :py:class:`datetime.datetime` object.

        :raises ValueError:
            Raised if this is called with a ``dt`` which does not have this
            ``tzinfo`` attached.

        :return:
            Returns a :py:class:`datetime.datetime` object representing the
            wall time in ``self``'s time zone.
        z&fromutc() requires a datetime argumentzdt.tzinfo is not selfT)r�)r()rw)rA)rr,r*�tzinfor}r�r�r-r/rrr2)rrrwr�Zdt_outrArrrr}s

ztzfile.fromutccCsd|dkr|j|�}t|�}|j|�}|dks4|dkr8dS|j|d�j|j}|j|}|||kS)a6
        Whether or not the "wall time" of a given datetime is ambiguous in this
        zone.

        :param dt:
            A :py:class:`datetime.datetime`, naive or time zone aware.


        :return:
            Returns ``True`` if ambiguous, ``False`` otherwise.

        .. versionadded:: 2.6.0
        NrFr)r�r>r�r/r�)rrrwr@r�ZodZttrrrr�s


ztzfile.is_ambiguouscCsF|j|�}|j|�}|dks$|dkr(|St|o:|j||��}||S)Nr)r�rCr2r)rrrwrCZ
idx_offsetrrrr��s

ztzfile._resolve_ambiguous_timecCs"|dkrdS|jstS|j|�jS)N)r�r
r�rF)rrrrrr�s
ztzfile.utcoffsetcCs0|dkrdS|jstS|j|�}|js*tS|jS)N)Z_ttinfo_dstr
r�rGrK)rrr�rrrr�s
z
tzfile.dstcCs |js|dkrdS|j|�jS)N)r�r�rH)rrrrrr�sz
tzfile.tznamecCs2t|t�stS|j|jko0|j|jko0|j|jkS)N)rrbrr�r�Z_ttinfo_list)rrrrrr�s

z
tzfile.__eq__cCs
||kS)Nr)rrrrrr�sz
tzfile.__ne__cCsd|jjt|j�fS)Nz%s(%s))rr r1rd)rrrrr!�sztzfile.__repr__cCs
|jd�S)N)�
__reduce_ex__)rrrrr'�sztzfile.__reduce__cCs|jd|jf|jfS)N)rrd�__dict__)rZprotocolrrrr��sztzfile.__reduce_ex__)N)F)N)r r"r#r$r0rirhr�r�r�rrr�rrrrrr%rr!r'r�rDrr)rrrbNs(]
$

	rbc@s6eZdZdZddd�Zdd�Zdd�Zed	d
��ZdS)�tzrangeaQ
    The ``tzrange`` object is a time zone specified by a set of offsets and
    abbreviations, equivalent to the way the ``TZ`` variable can be specified
    in POSIX-like systems, but using Python delta objects to specify DST
    start, end and offsets.

    :param stdabbr:
        The abbreviation for standard time (e.g. ``'EST'``).

    :param stdoffset:
        An integer or :class:`datetime.timedelta` object or equivalent
        specifying the base offset from UTC.

        If unspecified, +00:00 is used.

    :param dstabbr:
        The abbreviation for DST / "Summer" time (e.g. ``'EDT'``).

        If specified, with no other DST information, DST is assumed to occur
        and the default behavior or ``dstoffset``, ``start`` and ``end`` is
        used. If unspecified and no other DST information is specified, it
        is assumed that this zone has no DST.

        If this is unspecified and other DST information is *is* specified,
        DST occurs in the zone but the time zone abbreviation is left
        unchanged.

    :param dstoffset:
        A an integer or :class:`datetime.timedelta` object or equivalent
        specifying the UTC offset during DST. If unspecified and any other DST
        information is specified, it is assumed to be the STD offset +1 hour.

    :param start:
        A :class:`relativedelta.relativedelta` object or equivalent specifying
        the time and time of year that daylight savings time starts. To specify,
        for example, that DST starts at 2AM on the 2nd Sunday in March, pass:

            ``relativedelta(hours=2, month=3, day=1, weekday=SU(+2))``

        If unspecified and any other DST information is specified, the default
        value is 2 AM on the first Sunday in April.

    :param end:
        A :class:`relativedelta.relativedelta` object or equivalent representing
        the time and time of year that daylight savings time ends, with the
        same specification method as in ``start``. One note is that this should
        point to the first time in the *standard* zone, so if a transition
        occurs at 2AM in the DST zone and the clocks are set back 1 hour to 1AM,
        set the `hours` parameter to +1.


    **Examples:**

    .. testsetup:: tzrange

        from dateutil.tz import tzrange, tzstr

    .. doctest:: tzrange

        >>> tzstr('EST5EDT') == tzrange("EST", -18000, "EDT")
        True

        >>> from dateutil.relativedelta import *
        >>> range1 = tzrange("EST", -18000, "EDT")
        >>> range2 = tzrange("EST", -18000, "EDT", -14400,
        ...                  relativedelta(hours=+2, month=4, day=1,
        ...                                weekday=SU(+1)),
        ...                  relativedelta(hours=+1, month=10, day=31,
        ...                                weekday=SU(-1)))
        >>> tzstr('EST5EDT') == range1 == range2
        True

    NcCs@ddlma||_||_yt|�}Wnttfk
r<YnXyt|�}Wnttfk
rbYnX|dk	r|tj|d�|_	nt
|_	|dk	r�tj|d�|_n(|r�|dk	r�|j	tjdd�|_nt
|_|r�|dkr�tjdddtjd
�d�|_
n||_
|�r|dk�rtjdd	d
tjd�d�|_n||_|j|j	|_t|j
�|_dS)Nr)�
relativedelta)r(r)�hours�rn)r��month�day�weekday�
�rr�rrrz)�dateutilr��	_std_abbr�	_dst_abbrrr*r+r,r-r7r
r8�SU�_start_delta�
_end_delta�_dst_base_offset_r:�hasdst)r�stdabbr�	stdoffset�dstabbrrK�start�endrrrr0Js:ztzrange.__init__cCs4|js
dStj|dd�}||j}||j}||fS)a�
        For a given year, get the DST on and off transition times, expressed
        always on the standard time side. For zones with no transitions, this
        function returns ``None``.

        :param year:
            The year whose transitions you would like to query.

        :return:
            Returns a :class:`tuple` of :class:`datetime.datetime` objects,
            ``(dston, dstoff)`` for zones with an annual DST transition, or
            ``None`` for fixed offset zones.
        Nr)r�r,r�r�)rZyearZ	base_yearr�r�rrr�transitionsys

ztzrange.transitionscCsVt|t�stS|j|jkoT|j|jkoT|j|jkoT|j|jkoT|j|jkoT|j|jkS)N)	rr�rr�r�r7r8r�r�)rrrrrr�s
ztzrange.__eq__cCs|jS)N)r�)rrrr�_dst_base_offset�sztzrange._dst_base_offset)NNNNN)	r r"r#r$r0r�r�propertyr�rrrrr�sI
-r�c@s,eZdZdZddd�Zddd�Zdd	�Zd
S)
�tzstra
    ``tzstr`` objects are time zone objects specified by a time-zone string as
    it would be passed to a ``TZ`` variable on POSIX-style systems (see
    the `GNU C Library: TZ Variable`_ for more details).

    There is one notable exception, which is that POSIX-style time zones use an
    inverted offset format, so normally ``GMT+3`` would be parsed as an offset
    3 hours *behind* GMT. The ``tzstr`` time zone object will parse this as an
    offset 3 hours *ahead* of GMT. If you would like to maintain the POSIX
    behavior, pass a ``True`` value to ``posix_offset``.

    The :class:`tzrange` object provides the same functionality, but is
    specified using :class:`relativedelta.relativedelta` objects. rather than
    strings.

    :param s:
        A time zone string in ``TZ`` variable format. This can be a
        :class:`bytes` (2.x: :class:`str`), :class:`str` (2.x: :class:`unicode`)
        or a stream emitting unicode characters (e.g. :class:`StringIO`).

    :param posix_offset:
        Optional. If set to ``True``, interpret strings such as ``GMT+3`` or
        ``UTC+3`` as being 3 hours *behind* UTC rather than ahead, per the
        POSIX standard.

    .. _`GNU C Library: TZ Variable`:
        https://www.gnu.org/software/libc/manual/html_node/TZ-Variable.html
    Fc	Cs�ddlma||_tj|�}|dkr,td��|jd
krJ|rJ|jd9_tj||j|j|j	|j
ddd�|j	s~d|_d|_n&|j
|j�|_|jr�|j
|jdd	�|_t|j�|_dS)Nr)�parserzunknown string format�GMTrrF)r�r�)�isend)r�rrz)r�r��_sZ_parsetzr}r�r�r�r0r�rKr�r��_deltar�r�r:r�)r�sZposix_offset�resrrrr0�s"

ztzstr.__init__rcCs<ddlm}i}|jdk	rr|j|d<|jdk	r`|j|j|j�|d<|jdkrVd|d<qpd|d<q�|jr�|j|d<n*|jdk	r�|j|d<n|jdk	r�|j|d	<|s�|s�d
|d<d|d<|jd�|d<nd|d<d|d<|jd�|d<|j	dk	�r�|j	|d<nd
|d<|�r0|j
|j}|d|j|j
d8<|jf|�S)Nr)r�r�r�rr�r�ZyeardayZ	nlyeardayrnr�r(i i�Qrrz)r�r�r�r�Zweekr�ZydayZjydayr�r5r8r7r(Zdays)r�xr�r�rarFrrrr��s<








ztzstr._deltacCsd|jjt|j�fS)Nz%s(%s))rr r1r�)rrrrr!sztzstr.__repr__N)F)r)r r"r#r$r0r�r!rrrrr��s
 
)r�c@seZdZddd�ZdS)�_tzicalvtzcompNcCs@tj|d�|_tj|d�|_|j|j|_||_||_||_dS)N)r()r,r-�tzoffsetfrom�
tzoffsetto�tzoffsetdiffrGr�rrule)rr�r�rGrr�rrrr0sz_tzicalvtzcomp.__init__)NN)r r"r#r0rrrrr�sr�csZeZdZgf�fdd�	Zdd�Zdd�Zdd�Zd	d
�Zedd��Z	d
d�Z
ejZ�Z
S)�
_tzicalvtzcs*tt|�j�||_||_g|_g|_dS)N)r4r�r0�_tzid�_comps�
_cachedate�
_cachecomp)r�tzid�comps)rrrr0s
z_tzicalvtz.__init__c
Cs
t|j�dkr|jdS|jdd�}y|j|jj||j|�f�Stk
rTYnXd}d}x4|jD]*}|j||�}|rf|s�||krf|}|}qfW|s�x"|jD]}|j	s�|}Pq�W|d}|jj
d||j|�f�|jj
d|�t|j�dk�r|jj�|jj�|S)Nrr)r�r�)r�r��replacer�r��indexrCr}�_find_compdtrG�insert�pop)rrZ
lastcompdtZlastcomp�comp�compdtrrr�
_find_comps4


z_tzicalvtz._find_compcCs2|jtkr|j|�r||j8}|jj|dd�}|S)NT)Zinc)r�r
rCr�Zbefore)rr�rr�rrrr�Is
z_tzicalvtz._find_compdtcCs|dkrdS|j|�jS)N)r�r�)rrrrrrQsz_tzicalvtz.utcoffsetcCs|j|�}|jr|jStSdS)N)r�rGr�r
)rrr�rrrrWs
z_tzicalvtz.dstcCs|j|�jS)N)r�r)rrrrrr^sz_tzicalvtz.tznamecCsdt|j�S)Nz<tzicalvtz %s>)r1r�)rrrrr!bsz_tzicalvtz.__repr__)r r"r#r0r�r�rrrrr!r&r'rDrr)rrr�s*r�c@sBeZdZdZdd�Zdd�Zddd�Zd	d
�Zdd�Zd
d�Z	dS)�tzicala\
    This object is designed to parse an iCalendar-style ``VTIMEZONE`` structure
    as set out in `RFC 2445`_ Section 4.6.5 into one or more `tzinfo` objects.

    :param `fileobj`:
        A file or stream in iCalendar format, which should be UTF-8 encoded
        with CRLF endings.

    .. _`RFC 2445`: https://www.ietf.org/rfc/rfc2445.txt
    c	Csjddlmat|t�r(||_t|d�}nt|dt|��|_t|�}i|_	|�}|j
|j��WdQRXdS)Nr)r��rr.)r�r�rrr�rerBr1rg�_vtz�
_parse_rfcr{)rrjZfobjrrrr0ss
ztzical.__init__cCst|jj��S)z?
        Retrieves the available time zones as a list.
        )r�r��keys)rrrrr��sztzical.keysNcCsP|dkrDt|j�dkr td��nt|j�dkr6td��tt|j��}|jj|�S)a�
        Retrieve a :py:class:`datetime.tzinfo` object by its ``tzid``.

        :param tzid:
            If there is exactly one time zone available, omitting ``tzid``
            or passing :py:const:`None` value returns it. Otherwise a valid
            key (which can be retrieved from :func:`keys`) is required.

        :raises ValueError:
            Raised if ``tzid`` is not specified but there are either more
            or fewer than 1 zone defined.

        :returns:
            Returns either a :py:class:`datetime.tzinfo` object representing
            the relevant time zone or :py:const:`None` if the ``tzid`` was
            not found.
        Nrzno timezones definedrz more than one timezone available)r�r�r}�next�iterr`)rr�rrrr`�s
z
tzical.getcCs�|j�}|std��|ddkr>d|ddk}|dd�}nd}t|�dkrzt|dd��dt|dd��d	|St|�d
kr�t|dd��dt|dd��d	t|dd��|Std|��dS)Nzempty offsetr�+�-rrnr�irsrqzinvalid offset: )r�r�rzr)rzrr)�stripr}r�r2)rr��signalrrr�
_parse_offset�s,<ztzical._parse_offsetcCsH|j�}|std��d}xh|t|�kr�||j�}|s>||=q|dkrv|ddkrv||d|dd�7<||=q|d7}qWd}g}d}d}�x�|D�]�}|s�q�|jdd�\}	}
|	jd�}|s�td��|dj�}	|dd�}|�r$|	d	k�r(|
d)k�rntd|
��|
}d}d}
d}g}d}�q@|	d
k�r|
dk�r�|�rNtd|��|�s\td��|�sjtd��t||�|j|<d}n�|
|k�r|�s�td��|
dk�r�td��|dk�r�td��d}|�r�tj	dj
|�dddd�}t|
||dk||�}|j|�d}ntd|
���q@|�r�|	dk�r2|j|�d}n�|	d*k�rH|j|�n�|	dk�rx|�rltd|	|df��|j
|
�}
nj|	dk�r�|�r�td |d��|j
|
�}n>|	d!k�r�|�r�td"|d��|
}n|	d#k�r�ntd$|	��n>|	d%k�r
|�rtd&|d��|
}n|	d+k�rntd$|	��q�|	d	kr�|
dkr�d}g}d}q�WdS),Nzempty stringr� rF�:�;zempty property nameZBEGIN�STANDARD�DAYLIGHTzunknown component: ZENDZ	VTIMEZONEzcomponent not closed: zmandatory TZID not foundz at least one component is neededzmandatory DTSTART not foundz mandatory TZOFFSETFROM not found�
T)Z
compatibleZignoretz�cachezinvalid component end: ZDTSTART�RRULE�RDATE�EXRULE�EXDATEZTZOFFSETFROMzunsupported %s parm: %s Z
TZOFFSETTOzunsupported TZOFFSETTO parm: ZTZNAMEzunsupported TZNAME parm: �COMMENTzunsupported property: ZTZIDzunsupported TZID parm: �TZURL�
LAST-MODIFIED)r�r�)r�r�r�r�)r�r�r�)�
splitlinesr}r��rstrip�split�upperr�r�r�ZrrulestrrPr�rOr�)rr��linesr��liner�r�ZinvtzZcomptyper.rRZparmsZfounddtstartr�r�Z
rrulelinesrZrrr�rrrr��s�

















ztzical._parse_rfccCsd|jjt|j�fS)Nz%s(%s))rr r1r�)rrrrr!+sztzical.__repr__)N)
r r"r#r$r0r�r`r�r�r!rrrrr�hs

vr�Zwin32z/etc/localtimer?z/usr/share/zoneinfoz/usr/lib/zoneinfoz/usr/share/lib/zoneinfoz
/etc/zoneinfocCsDd}|s,ytjd}Wntk
r*YnX|dks<|dkr�x�tD]v}tjj|�s�|}x*tD] }tjj||�}tjj|�r\Pq\WqBtjj|�rByt	|�}PWqBt
ttfk
r�YqBXqBWt
�}�nz|jd�r�|dd�}tjj|��r
tjj|��rt	|�}nd}�n6�x2tD]l}tjj||�}tjj|��sP|jdd�}tjj|��sP�qyt	|�}PWnt
ttfk
�rzYnX�qWd}tdk	�r�yt|�}Wntk
�r�d}YnX|�s�ddlm}|�j|�}|�s@xb|D]6}|dk�r�yt|�}Wntk
�rYnXP�q�W|dk�r.t�}n|tjk�r@t
�}|S)
NZTZr�rr�rmr)�get_zonefile_instance�
0123456789r�rrz)r�r)r��environ�KeyError�TZFILES�path�isabs�TZPATHSrP�isfilerb�IOError�OSErrorr}r3�
startswithr�r
ZWindowsErrorZdateutil.zoneinfor�r`r�rr5r)r.�tz�filepathrkr�r��crrr�gettz:sz










r�cCsZ|dkr |jdkrtd��|j}|jdd�}|j|d�jt��j|�}|jdd�}||kS)a�
    Given a datetime and a time zone, determine whether or not a given datetime
    would fall in a gap.

    :param dt:
        A :class:`datetime.datetime` (whose time zone will be ignored if ``tz``
        is provided.)

    :param tz:
        A :class:`datetime.tzinfo` with support for the ``fold`` attribute. If
        ``None`` or not provided, the datetime's own time zone will be used.

    :return:
        Returns a boolean value whether or not the "wall time" exists in ``tz``.
    Nz,Datetime is naive and no time zone provided.)r�)r�r}r�Z
astimezoner)rr�Zdt_rtrrr�datetime_exists�s
r�c
Cs�|dkr |jdkrtd��|j}t|dd�}|dk	rLy
|j|�SYnX|j|d�}t|dd�}t|dd�}|j�|j�k}|j�|j�k}|o�|S)a\
    Given a datetime and a time zone, determine whether or not a given datetime
    is ambiguous (i.e if there are two times differentiated only by their DST
    status).

    :param dt:
        A :class:`datetime.datetime` (whose time zone will be ignored if ``tz``
        is provided.)

    :param tz:
        A :class:`datetime.tzinfo` with support for the ``fold`` attribute. If
        ``None`` or not provided, the datetime's own time zone will be used.

    :return:
        Returns a boolean value whether or not the "wall time" is ambiguous in
        ``tz``.

    .. versionadded:: 2.6.0
    Nz,Datetime is naive and no time zone provided.r)r�r)rAr)r�r}rBrr�rrr)rr�Zis_ambiguous_fnZwall_0Zwall_1Zsame_offsetZsame_dstrrr�datetime_ambiguous�s 

r�cCst|jdd�t�S)z�
    Convert a :class:`datetime.datetime` object to an epoch timestamp in seconds
    since January 1, 1970, ignoring the time zone.
    N)r�)rr��EPOCH)rrrrr>�sr>c@s(eZdZdZdd�Zdd�Zdd�ZdS)	rgz^
    Class for wrapping contexts so that they are passed through in a
    with statement.
    cCs
||_dS)N)�context)rrrrrr0�sz_ContextWrapper.__init__cCs|jS)N)r)rrrr�	__enter__�sz_ContextWrapper.__enter__cOsdS)Nr)�argsrarrr�__exit__�sz_ContextWrapper.__exit__N)r r"r#r$r0rrrrrrrg�srg)N)N)N)/r$r,r~r5�sysr�r�ZsixrZ_commonrrrrrr	�winr
r�ImportErrorr-r
ZutcfromtimestamprZ	toordinalZEPOCHORDINALr�rrr3r&rErVrbr�r�r�r�r��platformr�r�r�r�r�r>rgrrrr�<module>	s\
8Fv-
5"jRH
J

.PKa�\�r��22&tz/__pycache__/__init__.cpython-36.pycnu�[���3

6�cY��
@s*ddlTdddddddd	d
ddd
dg
ZdS)�)�*ZtzutcZtzoffsetZtzlocalZtzfileZtzrangeZtzstrZtzicalZtzwinZ
tzwinlocalZgettzZenfoldZdatetime_ambiguousZdatetime_existsN)Ztz�__all__�rr�/usr/lib/python3.6/__init__.py�<module>s

PKa�\�r��22,tz/__pycache__/__init__.cpython-36.opt-1.pycnu�[���3

6�cY��
@s*ddlTdddddddd	d
ddd
dg
ZdS)�)�*ZtzutcZtzoffsetZtzlocalZtzfileZtzrangeZtzstrZtzicalZtzwinZ
tzwinlocalZgettzZenfoldZdatetime_ambiguousZdatetime_existsN)Ztz�__all__�rr�/usr/lib/python3.6/__init__.py�<module>s

PKa�\IœA�,�,+tz/__pycache__/_common.cpython-36.opt-1.pycnu�[���3

6�cY�.�@s�ddlmZddlmZddlmZmZmZed�ZddgZdd�Z	e
ed�rZdd	d�ZnGd
d�de�Zddd�Zd
d�Z
Gdd�de�ZGdd�de�Zdd�Zeede�ZdS)�)�PY3)�wraps)�datetime�	timedelta�tzinfo�tzname_in_python2�enfoldcs�fdd�}|S)z�Change unicode output into bytestrings in Python 2

    tzname() API changed in Python 3. It used to return bytes, but was changed
    to unicode strings
    cs$�||�}|dk	r tr |j�}|S)N)r�encode)�args�kwargs�name)�namefunc��/usr/lib/python3.6/_common.py�adjust_encodings
z*tzname_in_python2.<locals>.adjust_encodingr)r
rr)r
rr
s�fold�cCs|j|d�S)a�
        Provides a unified interface for assigning the ``fold`` attribute to
        datetimes both before and after the implementation of PEP-495.

        :param fold:
            The value for the ``fold`` attribute in the returned datetime. This
            should be either 0 or 1.

        :return:
            Returns an object for which ``getattr(dt, 'fold', 0)`` returns
            ``fold`` for all versions of Python. In versions prior to
            Python 3.6, this is a ``_DatetimeWithFold`` object, which is a
            subclass of :py:class:`datetime.datetime` with the ``fold``
            attribute added, if ``fold`` is 1.

        .. versionadded:: 2.6.0
        )r)�replace)�dtrrrrr!sc@s eZdZdZfZedd��ZdS)�_DatetimeWithFoldz�
        This is a class designed to provide a PEP 495-compliant interface for
        Python versions before 3.6. It is used only for dates in a fold, so
        the ``fold`` attribute is fixed at ``1``.

        .. versionadded:: 2.6.0
        cCsdS)Nrr)�selfrrrr@sz_DatetimeWithFold.foldN)�__name__�
__module__�__qualname__�__doc__�	__slots__�propertyrrrrrr6srcCsLt|dd�|kr|S|j�dd�}||j|jf7}|r@t|�St|�SdS)a�
        Provides a unified interface for assigning the ``fold`` attribute to
        datetimes both before and after the implementation of PEP-495.

        :param fold:
            The value for the ``fold`` attribute in the returned datetime. This
            should be either 0 or 1.

        :return:
            Returns an object for which ``getattr(dt, 'fold', 0)`` returns
            ``fold`` for all versions of Python. In versions prior to
            Python 3.6, this is a ``_DatetimeWithFold`` object, which is a
            subclass of :py:class:`datetime.datetime` with the ``fold``
            attribute added, if ``fold`` is 1.

        .. versionadded:: 2.6.0
        rrN�)�getattrZ	timetupleZmicrosecondrrr)rrr
rrrrDscst���fdd��}|S)z�
    The CPython version of ``fromutc`` checks that the input is a ``datetime``
    object and that ``self`` is attached as its ``tzinfo``.
    cs.t|t�std��|j|k	r$td���||�S)Nz&fromutc() requires a datetime argumentzdt.tzinfo is not self)�
isinstancer�	TypeErrorr�
ValueError)rr)�frr�fromutcgs


z)_validate_fromutc_inputs.<locals>.fromutc)r)r"r#r)r"r�_validate_fromutc_inputsbs	r$c@s<eZdZdZdd�Zdd�Zdd�Zdd	�Zed
d��Z	dS)
�_tzinfoz=
    Base class for all ``dateutil`` ``tzinfo`` objects.
    cCsV|j|d�}t|dd�}t|dd�}|j�|j�k}|jdd�|jdd�k}|oT|S)a6
        Whether or not the "wall time" of a given datetime is ambiguous in this
        zone.

        :param dt:
            A :py:class:`datetime.datetime`, naive or time zone aware.


        :return:
            Returns ``True`` if ambiguous, ``False`` otherwise.

        .. versionadded:: 2.6.0
        )rr)rrN)rr�	utcoffset)rrZwall_0Zwall_1Zsame_offsetZsame_dtrrr�is_ambiguousxsz_tzinfo.is_ambiguouscCs4|j|�r,||}t||j�|j�k�}nd}|S)a�
        Determine the fold status of a "wall" datetime, given a representation
        of the same datetime as a (naive) UTC datetime. This is calculated based
        on the assumption that ``dt.utcoffset() - dt.dst()`` is constant for all
        datetimes, and that this offset is the actual number of hours separating
        ``dt_utc`` and ``dt_wall``.

        :param dt_utc:
            Representation of the datetime as UTC

        :param dt_wall:
            Representation of the datetime as "wall time". This parameter must
            either have a `fold` attribute or have a fold-naive
            :class:`datetime.tzinfo` attached, otherwise the calculation may
            fail.
        r)r'�intr&�dst)r�dt_utc�dt_wallZ
delta_wall�_foldrrr�_fold_status�s

z_tzinfo._fold_statuscCst|dd�S)Nrr)r)rrrrrr,�sz
_tzinfo._foldcCsh|j�}|dkrtd��|j�}|dkr0td��||}||7}t|dd�j�}|dkr`td��||S)a�
        Given a timezone-aware datetime in a given timezone, calculates a
        timezone-aware datetime in a new timezone.

        Since this is the one time that we *know* we have an unambiguous
        datetime object, we take this opportunity to determine whether the
        datetime is ambiguous and in a "fold" state (e.g. if it's the first
        occurence, chronologically, of the ambiguous datetime).

        :param dt:
            A timezone-aware :class:`datetime.datetime` object.
        Nz0fromutc() requires a non-None utcoffset() resultz*fromutc() requires a non-None dst() resultr)rz;fromutc(): dt.dst gave inconsistent results; cannot convert)r&r!r)r)rrZdtoffZdtdstZdeltarrr�_fromutc�sz_tzinfo._fromutccCs"|j|�}|j||�}t||d�S)a�
        Given a timezone-aware datetime in a given timezone, calculates a
        timezone-aware datetime in a new timezone.

        Since this is the one time that we *know* we have an unambiguous
        datetime object, we take this opportunity to determine whether the
        datetime is ambiguous and in a "fold" state (e.g. if it's the first
        occurance, chronologically, of the ambiguous datetime).

        :param dt:
            A timezone-aware :class:`datetime.datetime` object.
        )r)r.r-r)rrr+r,rrrr#�s
z_tzinfo.fromutcN)
rrrrr'r-r,r.r$r#rrrrr%ss%r%c@szeZdZdZdd�Zdd�Zdd�Zedd	��Zd
d�Z	dd
�Z
dd�Zdd�Ze
dd��ZdZdd�Zdd�ZejZdS)�tzrangebasea�
    This is an abstract base class for time zones represented by an annual
    transition into and out of DST. Child classes should implement the following
    methods:

        * ``__init__(self, *args, **kwargs)``
        * ``transitions(self, year)`` - this is expected to return a tuple of
          datetimes representing the DST on and off transitions in standard
          time.

    A fully initialized ``tzrangebase`` subclass should also provide the
    following attributes:
        * ``hasdst``: Boolean whether or not the zone uses DST.
        * ``_dst_offset`` / ``_std_offset``: :class:`datetime.timedelta` objects
          representing the respective UTC offsets.
        * ``_dst_abbr`` / ``_std_abbr``: Strings representing the timezone short
          abbreviations in DST and STD, respectively.
        * ``_hasdst``: Whether or not the zone has DST.

    .. versionadded:: 2.6.0
    cCstd��dS)Nz%tzrangebase is an abstract base class)�NotImplementedError)rrrr�__init__�sztzrangebase.__init__cCs*|j|�}|dkrdS|r |jS|jSdS)N)�_isdst�_dst_offset�_std_offset)rr�isdstrrrr&s
ztzrangebase.utcoffsetcCs(|j|�}|dkrdS|r |jStSdS)N)r2�_dst_base_offset�ZERO)rrr5rrrr)s
ztzrangebase.dstcCs|j|�r|jS|jSdS)N)r2Z	_dst_abbrZ	_std_abbr)rrrrr�tznames
ztzrangebase.tznamec
Cs�t|t�std��|j|k	r$td��|j|j�}|dkrF||j|�S|\}}||j8}||j8}||f}|j	dd�}|j
||�}|r�||j}n
||j}t|o�|j
|��}	t||	d�S)z, Given a datetime in UTC, return local time z&fromutc() requires a datetime argumentzdt.tzinfo is not selfN)r)r)rrr rr!�transitions�yearr&r4r�_naive_isdstr3r(r'r)
rrr9�dston�dstoffZutc_transitionsr*r5r+r,rrrr#s$




ztzrangebase.fromutccCsD|js
dS|j|j�\}}|jdd�}||ko>||jkSS)a6
        Whether or not the "wall time" of a given datetime is ambiguous in this
        zone.

        :param dt:
            A :py:class:`datetime.datetime`, naive or time zone aware.


        :return:
            Returns ``True`` if ambiguous, ``False`` otherwise.

        .. versionadded:: 2.6.0
        FN)r)�hasdstr9r:rr6)rr�start�endrrrr'>s
ztzrangebase.is_ambiguouscCsj|js
dS|dkrdS|j|j�}|dkr.dS|jdd�}|j||�}|rb|j|�rb|j|�S|SdS)NF)r)r>r9r:rr;r'r,)rrr9r5rrrr2Tsztzrangebase._isdstcCsT|\}}|jdd�}||kr6||ko.|kn}n||koH|kn}|S)N)r)r)rrr9r<r=r5rrrr;isztzrangebase._naive_isdstcCs|j|jS)N)r3r4)rrrrr6usztzrangebase._dst_base_offsetNcCs
||kS)Nr)r�otherrrr�__ne__{sztzrangebase.__ne__cCsd|jjS)Nz%s(...))�	__class__r)rrrr�__repr__~sztzrangebase.__repr__)rrrrr1r&r)rr8r#r'r2r;rr6�__hash__rBrD�object�
__reduce__rrrrr/�s

!r/cCs|j|jdd|jdS)Ni�Qi@B)ZsecondsZdaysZmicroseconds)Ztdrrr�_total_seconds�srHZ
total_secondsN)r)r)Zsixr�	functoolsrrrrr7�__all__r�hasattrrrr$r%r/rHrrrrr�<module>s

vPKa�\IœA�,�,%tz/__pycache__/_common.cpython-36.pycnu�[���3

6�cY�.�@s�ddlmZddlmZddlmZmZmZed�ZddgZdd�Z	e
ed�rZdd	d�ZnGd
d�de�Zddd�Zd
d�Z
Gdd�de�ZGdd�de�Zdd�Zeede�ZdS)�)�PY3)�wraps)�datetime�	timedelta�tzinfo�tzname_in_python2�enfoldcs�fdd�}|S)z�Change unicode output into bytestrings in Python 2

    tzname() API changed in Python 3. It used to return bytes, but was changed
    to unicode strings
    cs$�||�}|dk	r tr |j�}|S)N)r�encode)�args�kwargs�name)�namefunc��/usr/lib/python3.6/_common.py�adjust_encodings
z*tzname_in_python2.<locals>.adjust_encodingr)r
rr)r
rr
s�fold�cCs|j|d�S)a�
        Provides a unified interface for assigning the ``fold`` attribute to
        datetimes both before and after the implementation of PEP-495.

        :param fold:
            The value for the ``fold`` attribute in the returned datetime. This
            should be either 0 or 1.

        :return:
            Returns an object for which ``getattr(dt, 'fold', 0)`` returns
            ``fold`` for all versions of Python. In versions prior to
            Python 3.6, this is a ``_DatetimeWithFold`` object, which is a
            subclass of :py:class:`datetime.datetime` with the ``fold``
            attribute added, if ``fold`` is 1.

        .. versionadded:: 2.6.0
        )r)�replace)�dtrrrrr!sc@s eZdZdZfZedd��ZdS)�_DatetimeWithFoldz�
        This is a class designed to provide a PEP 495-compliant interface for
        Python versions before 3.6. It is used only for dates in a fold, so
        the ``fold`` attribute is fixed at ``1``.

        .. versionadded:: 2.6.0
        cCsdS)Nrr)�selfrrrr@sz_DatetimeWithFold.foldN)�__name__�
__module__�__qualname__�__doc__�	__slots__�propertyrrrrrr6srcCsLt|dd�|kr|S|j�dd�}||j|jf7}|r@t|�St|�SdS)a�
        Provides a unified interface for assigning the ``fold`` attribute to
        datetimes both before and after the implementation of PEP-495.

        :param fold:
            The value for the ``fold`` attribute in the returned datetime. This
            should be either 0 or 1.

        :return:
            Returns an object for which ``getattr(dt, 'fold', 0)`` returns
            ``fold`` for all versions of Python. In versions prior to
            Python 3.6, this is a ``_DatetimeWithFold`` object, which is a
            subclass of :py:class:`datetime.datetime` with the ``fold``
            attribute added, if ``fold`` is 1.

        .. versionadded:: 2.6.0
        rrN�)�getattrZ	timetupleZmicrosecondrrr)rrr
rrrrDscst���fdd��}|S)z�
    The CPython version of ``fromutc`` checks that the input is a ``datetime``
    object and that ``self`` is attached as its ``tzinfo``.
    cs.t|t�std��|j|k	r$td���||�S)Nz&fromutc() requires a datetime argumentzdt.tzinfo is not self)�
isinstancer�	TypeErrorr�
ValueError)rr)�frr�fromutcgs


z)_validate_fromutc_inputs.<locals>.fromutc)r)r"r#r)r"r�_validate_fromutc_inputsbs	r$c@s<eZdZdZdd�Zdd�Zdd�Zdd	�Zed
d��Z	dS)
�_tzinfoz=
    Base class for all ``dateutil`` ``tzinfo`` objects.
    cCsV|j|d�}t|dd�}t|dd�}|j�|j�k}|jdd�|jdd�k}|oT|S)a6
        Whether or not the "wall time" of a given datetime is ambiguous in this
        zone.

        :param dt:
            A :py:class:`datetime.datetime`, naive or time zone aware.


        :return:
            Returns ``True`` if ambiguous, ``False`` otherwise.

        .. versionadded:: 2.6.0
        )rr)rrN)rr�	utcoffset)rrZwall_0Zwall_1Zsame_offsetZsame_dtrrr�is_ambiguousxsz_tzinfo.is_ambiguouscCs4|j|�r,||}t||j�|j�k�}nd}|S)a�
        Determine the fold status of a "wall" datetime, given a representation
        of the same datetime as a (naive) UTC datetime. This is calculated based
        on the assumption that ``dt.utcoffset() - dt.dst()`` is constant for all
        datetimes, and that this offset is the actual number of hours separating
        ``dt_utc`` and ``dt_wall``.

        :param dt_utc:
            Representation of the datetime as UTC

        :param dt_wall:
            Representation of the datetime as "wall time". This parameter must
            either have a `fold` attribute or have a fold-naive
            :class:`datetime.tzinfo` attached, otherwise the calculation may
            fail.
        r)r'�intr&�dst)r�dt_utc�dt_wallZ
delta_wall�_foldrrr�_fold_status�s

z_tzinfo._fold_statuscCst|dd�S)Nrr)r)rrrrrr,�sz
_tzinfo._foldcCsh|j�}|dkrtd��|j�}|dkr0td��||}||7}t|dd�j�}|dkr`td��||S)a�
        Given a timezone-aware datetime in a given timezone, calculates a
        timezone-aware datetime in a new timezone.

        Since this is the one time that we *know* we have an unambiguous
        datetime object, we take this opportunity to determine whether the
        datetime is ambiguous and in a "fold" state (e.g. if it's the first
        occurence, chronologically, of the ambiguous datetime).

        :param dt:
            A timezone-aware :class:`datetime.datetime` object.
        Nz0fromutc() requires a non-None utcoffset() resultz*fromutc() requires a non-None dst() resultr)rz;fromutc(): dt.dst gave inconsistent results; cannot convert)r&r!r)r)rrZdtoffZdtdstZdeltarrr�_fromutc�sz_tzinfo._fromutccCs"|j|�}|j||�}t||d�S)a�
        Given a timezone-aware datetime in a given timezone, calculates a
        timezone-aware datetime in a new timezone.

        Since this is the one time that we *know* we have an unambiguous
        datetime object, we take this opportunity to determine whether the
        datetime is ambiguous and in a "fold" state (e.g. if it's the first
        occurance, chronologically, of the ambiguous datetime).

        :param dt:
            A timezone-aware :class:`datetime.datetime` object.
        )r)r.r-r)rrr+r,rrrr#�s
z_tzinfo.fromutcN)
rrrrr'r-r,r.r$r#rrrrr%ss%r%c@szeZdZdZdd�Zdd�Zdd�Zedd	��Zd
d�Z	dd
�Z
dd�Zdd�Ze
dd��ZdZdd�Zdd�ZejZdS)�tzrangebasea�
    This is an abstract base class for time zones represented by an annual
    transition into and out of DST. Child classes should implement the following
    methods:

        * ``__init__(self, *args, **kwargs)``
        * ``transitions(self, year)`` - this is expected to return a tuple of
          datetimes representing the DST on and off transitions in standard
          time.

    A fully initialized ``tzrangebase`` subclass should also provide the
    following attributes:
        * ``hasdst``: Boolean whether or not the zone uses DST.
        * ``_dst_offset`` / ``_std_offset``: :class:`datetime.timedelta` objects
          representing the respective UTC offsets.
        * ``_dst_abbr`` / ``_std_abbr``: Strings representing the timezone short
          abbreviations in DST and STD, respectively.
        * ``_hasdst``: Whether or not the zone has DST.

    .. versionadded:: 2.6.0
    cCstd��dS)Nz%tzrangebase is an abstract base class)�NotImplementedError)rrrr�__init__�sztzrangebase.__init__cCs*|j|�}|dkrdS|r |jS|jSdS)N)�_isdst�_dst_offset�_std_offset)rr�isdstrrrr&s
ztzrangebase.utcoffsetcCs(|j|�}|dkrdS|r |jStSdS)N)r2�_dst_base_offset�ZERO)rrr5rrrr)s
ztzrangebase.dstcCs|j|�r|jS|jSdS)N)r2Z	_dst_abbrZ	_std_abbr)rrrrr�tznames
ztzrangebase.tznamec
Cs�t|t�std��|j|k	r$td��|j|j�}|dkrF||j|�S|\}}||j8}||j8}||f}|j	dd�}|j
||�}|r�||j}n
||j}t|o�|j
|��}	t||	d�S)z, Given a datetime in UTC, return local time z&fromutc() requires a datetime argumentzdt.tzinfo is not selfN)r)r)rrr rr!�transitions�yearr&r4r�_naive_isdstr3r(r'r)
rrr9�dston�dstoffZutc_transitionsr*r5r+r,rrrr#s$




ztzrangebase.fromutccCsD|js
dS|j|j�\}}|jdd�}||ko>||jkSS)a6
        Whether or not the "wall time" of a given datetime is ambiguous in this
        zone.

        :param dt:
            A :py:class:`datetime.datetime`, naive or time zone aware.


        :return:
            Returns ``True`` if ambiguous, ``False`` otherwise.

        .. versionadded:: 2.6.0
        FN)r)�hasdstr9r:rr6)rr�start�endrrrr'>s
ztzrangebase.is_ambiguouscCsj|js
dS|dkrdS|j|j�}|dkr.dS|jdd�}|j||�}|rb|j|�rb|j|�S|SdS)NF)r)r>r9r:rr;r'r,)rrr9r5rrrr2Tsztzrangebase._isdstcCsT|\}}|jdd�}||kr6||ko.|kn}n||koH|kn}|S)N)r)r)rrr9r<r=r5rrrr;isztzrangebase._naive_isdstcCs|j|jS)N)r3r4)rrrrr6usztzrangebase._dst_base_offsetNcCs
||kS)Nr)r�otherrrr�__ne__{sztzrangebase.__ne__cCsd|jjS)Nz%s(...))�	__class__r)rrrr�__repr__~sztzrangebase.__repr__)rrrrr1r&r)rr8r#r'r2r;rr6�__hash__rBrD�object�
__reduce__rrrrr/�s

!r/cCs|j|jdd|jdS)Ni�Qi@B)ZsecondsZdaysZmicroseconds)Ztdrrr�_total_seconds�srHZ
total_secondsN)r)r)Zsixr�	functoolsrrrrr7�__all__r�hasattrrrr$r%r/rHrrrrr�<module>s

vPKa�\�N���.�.
tz/_common.pynu�[���from six import PY3

from functools import wraps

from datetime import datetime, timedelta, tzinfo


ZERO = timedelta(0)

__all__ = ['tzname_in_python2', 'enfold']


def tzname_in_python2(namefunc):
    """Change unicode output into bytestrings in Python 2

    tzname() API changed in Python 3. It used to return bytes, but was changed
    to unicode strings
    """
    def adjust_encoding(*args, **kwargs):
        name = namefunc(*args, **kwargs)
        if name is not None and not PY3:
            name = name.encode()

        return name

    return adjust_encoding


# The following is adapted from Alexander Belopolsky's tz library
# https://github.com/abalkin/tz
if hasattr(datetime, 'fold'):
    # This is the pre-python 3.6 fold situation
    def enfold(dt, fold=1):
        """
        Provides a unified interface for assigning the ``fold`` attribute to
        datetimes both before and after the implementation of PEP-495.

        :param fold:
            The value for the ``fold`` attribute in the returned datetime. This
            should be either 0 or 1.

        :return:
            Returns an object for which ``getattr(dt, 'fold', 0)`` returns
            ``fold`` for all versions of Python. In versions prior to
            Python 3.6, this is a ``_DatetimeWithFold`` object, which is a
            subclass of :py:class:`datetime.datetime` with the ``fold``
            attribute added, if ``fold`` is 1.

        .. versionadded:: 2.6.0
        """
        return dt.replace(fold=fold)

else:
    class _DatetimeWithFold(datetime):
        """
        This is a class designed to provide a PEP 495-compliant interface for
        Python versions before 3.6. It is used only for dates in a fold, so
        the ``fold`` attribute is fixed at ``1``.

        .. versionadded:: 2.6.0
        """
        __slots__ = ()

        @property
        def fold(self):
            return 1

    def enfold(dt, fold=1):
        """
        Provides a unified interface for assigning the ``fold`` attribute to
        datetimes both before and after the implementation of PEP-495.

        :param fold:
            The value for the ``fold`` attribute in the returned datetime. This
            should be either 0 or 1.

        :return:
            Returns an object for which ``getattr(dt, 'fold', 0)`` returns
            ``fold`` for all versions of Python. In versions prior to
            Python 3.6, this is a ``_DatetimeWithFold`` object, which is a
            subclass of :py:class:`datetime.datetime` with the ``fold``
            attribute added, if ``fold`` is 1.

        .. versionadded:: 2.6.0
        """
        if getattr(dt, 'fold', 0) == fold:
            return dt

        args = dt.timetuple()[:6]
        args += (dt.microsecond, dt.tzinfo)

        if fold:
            return _DatetimeWithFold(*args)
        else:
            return datetime(*args)


def _validate_fromutc_inputs(f):
    """
    The CPython version of ``fromutc`` checks that the input is a ``datetime``
    object and that ``self`` is attached as its ``tzinfo``.
    """
    @wraps(f)
    def fromutc(self, dt):
        if not isinstance(dt, datetime):
            raise TypeError("fromutc() requires a datetime argument")
        if dt.tzinfo is not self:
            raise ValueError("dt.tzinfo is not self")

        return f(self, dt)

    return fromutc


class _tzinfo(tzinfo):
    """
    Base class for all ``dateutil`` ``tzinfo`` objects.
    """

    def is_ambiguous(self, dt):
        """
        Whether or not the "wall time" of a given datetime is ambiguous in this
        zone.

        :param dt:
            A :py:class:`datetime.datetime`, naive or time zone aware.


        :return:
            Returns ``True`` if ambiguous, ``False`` otherwise.

        .. versionadded:: 2.6.0
        """

        dt = dt.replace(tzinfo=self)

        wall_0 = enfold(dt, fold=0)
        wall_1 = enfold(dt, fold=1)

        same_offset = wall_0.utcoffset() == wall_1.utcoffset()
        same_dt = wall_0.replace(tzinfo=None) == wall_1.replace(tzinfo=None)

        return same_dt and not same_offset

    def _fold_status(self, dt_utc, dt_wall):
        """
        Determine the fold status of a "wall" datetime, given a representation
        of the same datetime as a (naive) UTC datetime. This is calculated based
        on the assumption that ``dt.utcoffset() - dt.dst()`` is constant for all
        datetimes, and that this offset is the actual number of hours separating
        ``dt_utc`` and ``dt_wall``.

        :param dt_utc:
            Representation of the datetime as UTC

        :param dt_wall:
            Representation of the datetime as "wall time". This parameter must
            either have a `fold` attribute or have a fold-naive
            :class:`datetime.tzinfo` attached, otherwise the calculation may
            fail.
        """
        if self.is_ambiguous(dt_wall):
            delta_wall = dt_wall - dt_utc
            _fold = int(delta_wall == (dt_utc.utcoffset() - dt_utc.dst()))
        else:
            _fold = 0

        return _fold

    def _fold(self, dt):
        return getattr(dt, 'fold', 0)

    def _fromutc(self, dt):
        """
        Given a timezone-aware datetime in a given timezone, calculates a
        timezone-aware datetime in a new timezone.

        Since this is the one time that we *know* we have an unambiguous
        datetime object, we take this opportunity to determine whether the
        datetime is ambiguous and in a "fold" state (e.g. if it's the first
        occurence, chronologically, of the ambiguous datetime).

        :param dt:
            A timezone-aware :class:`datetime.datetime` object.
        """

        # Re-implement the algorithm from Python's datetime.py
        dtoff = dt.utcoffset()
        if dtoff is None:
            raise ValueError("fromutc() requires a non-None utcoffset() "
                             "result")

        # The original datetime.py code assumes that `dst()` defaults to
        # zero during ambiguous times. PEP 495 inverts this presumption, so
        # for pre-PEP 495 versions of python, we need to tweak the algorithm.
        dtdst = dt.dst()
        if dtdst is None:
            raise ValueError("fromutc() requires a non-None dst() result")
        delta = dtoff - dtdst

        dt += delta
        # Set fold=1 so we can default to being in the fold for
        # ambiguous dates.
        dtdst = enfold(dt, fold=1).dst()
        if dtdst is None:
            raise ValueError("fromutc(): dt.dst gave inconsistent "
                             "results; cannot convert")
        return dt + dtdst

    @_validate_fromutc_inputs
    def fromutc(self, dt):
        """
        Given a timezone-aware datetime in a given timezone, calculates a
        timezone-aware datetime in a new timezone.

        Since this is the one time that we *know* we have an unambiguous
        datetime object, we take this opportunity to determine whether the
        datetime is ambiguous and in a "fold" state (e.g. if it's the first
        occurance, chronologically, of the ambiguous datetime).

        :param dt:
            A timezone-aware :class:`datetime.datetime` object.
        """
        dt_wall = self._fromutc(dt)

        # Calculate the fold status given the two datetimes.
        _fold = self._fold_status(dt, dt_wall)

        # Set the default fold value for ambiguous dates
        return enfold(dt_wall, fold=_fold)


class tzrangebase(_tzinfo):
    """
    This is an abstract base class for time zones represented by an annual
    transition into and out of DST. Child classes should implement the following
    methods:

        * ``__init__(self, *args, **kwargs)``
        * ``transitions(self, year)`` - this is expected to return a tuple of
          datetimes representing the DST on and off transitions in standard
          time.

    A fully initialized ``tzrangebase`` subclass should also provide the
    following attributes:
        * ``hasdst``: Boolean whether or not the zone uses DST.
        * ``_dst_offset`` / ``_std_offset``: :class:`datetime.timedelta` objects
          representing the respective UTC offsets.
        * ``_dst_abbr`` / ``_std_abbr``: Strings representing the timezone short
          abbreviations in DST and STD, respectively.
        * ``_hasdst``: Whether or not the zone has DST.

    .. versionadded:: 2.6.0
    """
    def __init__(self):
        raise NotImplementedError('tzrangebase is an abstract base class')

    def utcoffset(self, dt):
        isdst = self._isdst(dt)

        if isdst is None:
            return None
        elif isdst:
            return self._dst_offset
        else:
            return self._std_offset

    def dst(self, dt):
        isdst = self._isdst(dt)

        if isdst is None:
            return None
        elif isdst:
            return self._dst_base_offset
        else:
            return ZERO

    @tzname_in_python2
    def tzname(self, dt):
        if self._isdst(dt):
            return self._dst_abbr
        else:
            return self._std_abbr

    def fromutc(self, dt):
        """ Given a datetime in UTC, return local time """
        if not isinstance(dt, datetime):
            raise TypeError("fromutc() requires a datetime argument")

        if dt.tzinfo is not self:
            raise ValueError("dt.tzinfo is not self")

        # Get transitions - if there are none, fixed offset
        transitions = self.transitions(dt.year)
        if transitions is None:
            return dt + self.utcoffset(dt)

        # Get the transition times in UTC
        dston, dstoff = transitions

        dston -= self._std_offset
        dstoff -= self._std_offset

        utc_transitions = (dston, dstoff)
        dt_utc = dt.replace(tzinfo=None)

        isdst = self._naive_isdst(dt_utc, utc_transitions)

        if isdst:
            dt_wall = dt + self._dst_offset
        else:
            dt_wall = dt + self._std_offset

        _fold = int(not isdst and self.is_ambiguous(dt_wall))

        return enfold(dt_wall, fold=_fold)

    def is_ambiguous(self, dt):
        """
        Whether or not the "wall time" of a given datetime is ambiguous in this
        zone.

        :param dt:
            A :py:class:`datetime.datetime`, naive or time zone aware.


        :return:
            Returns ``True`` if ambiguous, ``False`` otherwise.

        .. versionadded:: 2.6.0
        """
        if not self.hasdst:
            return False

        start, end = self.transitions(dt.year)

        dt = dt.replace(tzinfo=None)
        return (end <= dt < end + self._dst_base_offset)

    def _isdst(self, dt):
        if not self.hasdst:
            return False
        elif dt is None:
            return None

        transitions = self.transitions(dt.year)

        if transitions is None:
            return False

        dt = dt.replace(tzinfo=None)

        isdst = self._naive_isdst(dt, transitions)

        # Handle ambiguous dates
        if not isdst and self.is_ambiguous(dt):
            return not self._fold(dt)
        else:
            return isdst

    def _naive_isdst(self, dt, transitions):
        dston, dstoff = transitions

        dt = dt.replace(tzinfo=None)

        if dston < dstoff:
            isdst = dston <= dt < dstoff
        else:
            isdst = not dstoff <= dt < dston

        return isdst

    @property
    def _dst_base_offset(self):
        return self._dst_offset - self._std_offset

    __hash__ = None

    def __ne__(self, other):
        return not (self == other)

    def __repr__(self):
        return "%s(...)" % self.__class__.__name__

    __reduce__ = object.__reduce__


def _total_seconds(td):
    # Python 2.6 doesn't have a total_seconds() method on timedelta objects
    return ((td.seconds + td.days * 86400) * 1000000 +
            td.microseconds) // 1000000


_total_seconds = getattr(timedelta, 'total_seconds', _total_seconds)
PKa�\�U����tz/__init__.pynu�[���from .tz import *

__all__ = ["tzutc", "tzoffset", "tzlocal", "tzfile", "tzrange",
           "tzstr", "tzical", "tzwin", "tzwinlocal", "gettz",
           "enfold", "datetime_ambiguous", "datetime_exists"]
PKa�\��Ɗ����tz/tz.pynu�[���# -*- coding: utf-8 -*-
"""
This module offers timezone implementations subclassing the abstract
:py:`datetime.tzinfo` type. There are classes to handle tzfile format files
(usually are in :file:`/etc/localtime`, :file:`/usr/share/zoneinfo`, etc), TZ
environment string (in all known formats), given ranges (with help from
relative deltas), local machine timezone, fixed offset timezone, and UTC
timezone.
"""
import datetime
import struct
import time
import sys
import os
import bisect

from six import string_types
from ._common import tzname_in_python2, _tzinfo, _total_seconds
from ._common import tzrangebase, enfold
from ._common import _validate_fromutc_inputs

try:
    from .win import tzwin, tzwinlocal
except ImportError:
    tzwin = tzwinlocal = None

ZERO = datetime.timedelta(0)
EPOCH = datetime.datetime.utcfromtimestamp(0)
EPOCHORDINAL = EPOCH.toordinal()


class tzutc(datetime.tzinfo):
    """
    This is a tzinfo object that represents the UTC time zone.
    """
    def utcoffset(self, dt):
        return ZERO

    def dst(self, dt):
        return ZERO

    @tzname_in_python2
    def tzname(self, dt):
        return "UTC"

    def is_ambiguous(self, dt):
        """
        Whether or not the "wall time" of a given datetime is ambiguous in this
        zone.

        :param dt:
            A :py:class:`datetime.datetime`, naive or time zone aware.


        :return:
            Returns ``True`` if ambiguous, ``False`` otherwise.

        .. versionadded:: 2.6.0
        """
        return False

    @_validate_fromutc_inputs
    def fromutc(self, dt):
        """
        Fast track version of fromutc() returns the original ``dt`` object for
        any valid :py:class:`datetime.datetime` object.
        """
        return dt

    def __eq__(self, other):
        if not isinstance(other, (tzutc, tzoffset)):
            return NotImplemented

        return (isinstance(other, tzutc) or
                (isinstance(other, tzoffset) and other._offset == ZERO))

    __hash__ = None

    def __ne__(self, other):
        return not (self == other)

    def __repr__(self):
        return "%s()" % self.__class__.__name__

    __reduce__ = object.__reduce__


class tzoffset(datetime.tzinfo):
    """
    A simple class for representing a fixed offset from UTC.

    :param name:
        The timezone name, to be returned when ``tzname()`` is called.

    :param offset:
        The time zone offset in seconds, or (since version 2.6.0, represented
        as a :py:class:`datetime.timedelta` object.
    """
    def __init__(self, name, offset):
        self._name = name

        try:
            # Allow a timedelta
            offset = _total_seconds(offset)
        except (TypeError, AttributeError):
            pass
        self._offset = datetime.timedelta(seconds=offset)

    def utcoffset(self, dt):
        return self._offset

    def dst(self, dt):
        return ZERO

    @tzname_in_python2
    def tzname(self, dt):
        return self._name

    @_validate_fromutc_inputs
    def fromutc(self, dt):
        return dt + self._offset

    def is_ambiguous(self, dt):
        """
        Whether or not the "wall time" of a given datetime is ambiguous in this
        zone.

        :param dt:
            A :py:class:`datetime.datetime`, naive or time zone aware.


        :return:
            Returns ``True`` if ambiguous, ``False`` otherwise.

        .. versionadded:: 2.6.0
        """
        return False

    def __eq__(self, other):
        if not isinstance(other, tzoffset):
            return NotImplemented

        return self._offset == other._offset

    __hash__ = None

    def __ne__(self, other):
        return not (self == other)

    def __repr__(self):
        return "%s(%s, %s)" % (self.__class__.__name__,
                               repr(self._name),
                               int(_total_seconds(self._offset)))

    __reduce__ = object.__reduce__


class tzlocal(_tzinfo):
    """
    A :class:`tzinfo` subclass built around the ``time`` timezone functions.
    """
    def __init__(self):
        super(tzlocal, self).__init__()

        self._std_offset = datetime.timedelta(seconds=-time.timezone)
        if time.daylight:
            self._dst_offset = datetime.timedelta(seconds=-time.altzone)
        else:
            self._dst_offset = self._std_offset

        self._dst_saved = self._dst_offset - self._std_offset
        self._hasdst = bool(self._dst_saved)

    def utcoffset(self, dt):
        if dt is None and self._hasdst:
            return None

        if self._isdst(dt):
            return self._dst_offset
        else:
            return self._std_offset

    def dst(self, dt):
        if dt is None and self._hasdst:
            return None

        if self._isdst(dt):
            return self._dst_offset - self._std_offset
        else:
            return ZERO

    @tzname_in_python2
    def tzname(self, dt):
        return time.tzname[self._isdst(dt)]

    def is_ambiguous(self, dt):
        """
        Whether or not the "wall time" of a given datetime is ambiguous in this
        zone.

        :param dt:
            A :py:class:`datetime.datetime`, naive or time zone aware.


        :return:
            Returns ``True`` if ambiguous, ``False`` otherwise.

        .. versionadded:: 2.6.0
        """
        naive_dst = self._naive_is_dst(dt)
        return (not naive_dst and
                (naive_dst != self._naive_is_dst(dt - self._dst_saved)))

    def _naive_is_dst(self, dt):
        timestamp = _datetime_to_timestamp(dt)
        return time.localtime(timestamp + time.timezone).tm_isdst

    def _isdst(self, dt, fold_naive=True):
        # We can't use mktime here. It is unstable when deciding if
        # the hour near to a change is DST or not.
        #
        # timestamp = time.mktime((dt.year, dt.month, dt.day, dt.hour,
        #                         dt.minute, dt.second, dt.weekday(), 0, -1))
        # return time.localtime(timestamp).tm_isdst
        #
        # The code above yields the following result:
        #
        # >>> import tz, datetime
        # >>> t = tz.tzlocal()
        # >>> datetime.datetime(2003,2,15,23,tzinfo=t).tzname()
        # 'BRDT'
        # >>> datetime.datetime(2003,2,16,0,tzinfo=t).tzname()
        # 'BRST'
        # >>> datetime.datetime(2003,2,15,23,tzinfo=t).tzname()
        # 'BRST'
        # >>> datetime.datetime(2003,2,15,22,tzinfo=t).tzname()
        # 'BRDT'
        # >>> datetime.datetime(2003,2,15,23,tzinfo=t).tzname()
        # 'BRDT'
        #
        # Here is a more stable implementation:
        #
        if not self._hasdst:
            return False

        # Check for ambiguous times:
        dstval = self._naive_is_dst(dt)
        fold = getattr(dt, 'fold', None)

        if self.is_ambiguous(dt):
            if fold is not None:
                return not self._fold(dt)
            else:
                return True

        return dstval

    def __eq__(self, other):
        if not isinstance(other, tzlocal):
            return NotImplemented

        return (self._std_offset == other._std_offset and
                self._dst_offset == other._dst_offset)

    __hash__ = None

    def __ne__(self, other):
        return not (self == other)

    def __repr__(self):
        return "%s()" % self.__class__.__name__

    __reduce__ = object.__reduce__


class _ttinfo(object):
    __slots__ = ["offset", "delta", "isdst", "abbr",
                 "isstd", "isgmt", "dstoffset"]

    def __init__(self):
        for attr in self.__slots__:
            setattr(self, attr, None)

    def __repr__(self):
        l = []
        for attr in self.__slots__:
            value = getattr(self, attr)
            if value is not None:
                l.append("%s=%s" % (attr, repr(value)))
        return "%s(%s)" % (self.__class__.__name__, ", ".join(l))

    def __eq__(self, other):
        if not isinstance(other, _ttinfo):
            return NotImplemented

        return (self.offset == other.offset and
                self.delta == other.delta and
                self.isdst == other.isdst and
                self.abbr == other.abbr and
                self.isstd == other.isstd and
                self.isgmt == other.isgmt and
                self.dstoffset == other.dstoffset)

    __hash__ = None

    def __ne__(self, other):
        return not (self == other)

    def __getstate__(self):
        state = {}
        for name in self.__slots__:
            state[name] = getattr(self, name, None)
        return state

    def __setstate__(self, state):
        for name in self.__slots__:
            if name in state:
                setattr(self, name, state[name])


class _tzfile(object):
    """
    Lightweight class for holding the relevant transition and time zone
    information read from binary tzfiles.
    """
    attrs = ['trans_list', 'trans_list_utc', 'trans_idx', 'ttinfo_list',
             'ttinfo_std', 'ttinfo_dst', 'ttinfo_before', 'ttinfo_first']

    def __init__(self, **kwargs):
        for attr in self.attrs:
            setattr(self, attr, kwargs.get(attr, None))


class tzfile(_tzinfo):
    """
    This is a ``tzinfo`` subclass thant allows one to use the ``tzfile(5)``
    format timezone files to extract current and historical zone information.

    :param fileobj:
        This can be an opened file stream or a file name that the time zone
        information can be read from.

    :param filename:
        This is an optional parameter specifying the source of the time zone
        information in the event that ``fileobj`` is a file object. If omitted
        and ``fileobj`` is a file stream, this parameter will be set either to
        ``fileobj``'s ``name`` attribute or to ``repr(fileobj)``.

    See `Sources for Time Zone and Daylight Saving Time Data
    <http://www.twinsun.com/tz/tz-link.htm>`_ for more information. Time zone
    files can be compiled from the `IANA Time Zone database files
    <https://www.iana.org/time-zones>`_ with the `zic time zone compiler
    <https://www.freebsd.org/cgi/man.cgi?query=zic&sektion=8>`_
    """

    def __init__(self, fileobj, filename=None):
        super(tzfile, self).__init__()

        file_opened_here = False
        if isinstance(fileobj, string_types):
            self._filename = fileobj
            fileobj = open(fileobj, 'rb')
            file_opened_here = True
        elif filename is not None:
            self._filename = filename
        elif hasattr(fileobj, "name"):
            self._filename = fileobj.name
        else:
            self._filename = repr(fileobj)

        if fileobj is not None:
            if not file_opened_here:
                fileobj = _ContextWrapper(fileobj)

            with fileobj as file_stream:
                tzobj = self._read_tzfile(file_stream)

            self._set_tzdata(tzobj)

    def _set_tzdata(self, tzobj):
        """ Set the time zone data of this object from a _tzfile object """
        # Copy the relevant attributes over as private attributes
        for attr in _tzfile.attrs:
            setattr(self, '_' + attr, getattr(tzobj, attr))

    def _read_tzfile(self, fileobj):
        out = _tzfile()

        # From tzfile(5):
        #
        # The time zone information files used by tzset(3)
        # begin with the magic characters "TZif" to identify
        # them as time zone information files, followed by
        # sixteen bytes reserved for future use, followed by
        # six four-byte values of type long, written in a
        # ``standard'' byte order (the high-order  byte
        # of the value is written first).
        if fileobj.read(4).decode() != "TZif":
            raise ValueError("magic not found")

        fileobj.read(16)

        (
            # The number of UTC/local indicators stored in the file.
            ttisgmtcnt,

            # The number of standard/wall indicators stored in the file.
            ttisstdcnt,

            # The number of leap seconds for which data is
            # stored in the file.
            leapcnt,

            # The number of "transition times" for which data
            # is stored in the file.
            timecnt,

            # The number of "local time types" for which data
            # is stored in the file (must not be zero).
            typecnt,

            # The  number  of  characters  of "time zone
            # abbreviation strings" stored in the file.
            charcnt,

        ) = struct.unpack(">6l", fileobj.read(24))

        # The above header is followed by tzh_timecnt four-byte
        # values  of  type long,  sorted  in ascending order.
        # These values are written in ``standard'' byte order.
        # Each is used as a transition time (as  returned  by
        # time(2)) at which the rules for computing local time
        # change.

        if timecnt:
            out.trans_list_utc = list(struct.unpack(">%dl" % timecnt,
                                                    fileobj.read(timecnt*4)))
        else:
            out.trans_list_utc = []

        # Next come tzh_timecnt one-byte values of type unsigned
        # char; each one tells which of the different types of
        # ``local time'' types described in the file is associated
        # with the same-indexed transition time. These values
        # serve as indices into an array of ttinfo structures that
        # appears next in the file.

        if timecnt:
            out.trans_idx = struct.unpack(">%dB" % timecnt,
                                            fileobj.read(timecnt))
        else:
            out.trans_idx = []

        # Each ttinfo structure is written as a four-byte value
        # for tt_gmtoff  of  type long,  in  a  standard  byte
        # order, followed  by a one-byte value for tt_isdst
        # and a one-byte  value  for  tt_abbrind.   In  each
        # structure, tt_gmtoff  gives  the  number  of
        # seconds to be added to UTC, tt_isdst tells whether
        # tm_isdst should be set by  localtime(3),  and
        # tt_abbrind serves  as an index into the array of
        # time zone abbreviation characters that follow the
        # ttinfo structure(s) in the file.

        ttinfo = []

        for i in range(typecnt):
            ttinfo.append(struct.unpack(">lbb", fileobj.read(6)))

        abbr = fileobj.read(charcnt).decode()

        # Then there are tzh_leapcnt pairs of four-byte
        # values, written in  standard byte  order;  the
        # first  value  of  each pair gives the time (as
        # returned by time(2)) at which a leap second
        # occurs;  the  second  gives the  total  number of
        # leap seconds to be applied after the given time.
        # The pairs of values are sorted in ascending order
        # by time.

        # Not used, for now (but seek for correct file position)
        if leapcnt:
            fileobj.seek(leapcnt * 8, os.SEEK_CUR)

        # Then there are tzh_ttisstdcnt standard/wall
        # indicators, each stored as a one-byte value;
        # they tell whether the transition times associated
        # with local time types were specified as standard
        # time or wall clock time, and are used when
        # a time zone file is used in handling POSIX-style
        # time zone environment variables.

        if ttisstdcnt:
            isstd = struct.unpack(">%db" % ttisstdcnt,
                                  fileobj.read(ttisstdcnt))

        # Finally, there are tzh_ttisgmtcnt UTC/local
        # indicators, each stored as a one-byte value;
        # they tell whether the transition times associated
        # with local time types were specified as UTC or
        # local time, and are used when a time zone file
        # is used in handling POSIX-style time zone envi-
        # ronment variables.

        if ttisgmtcnt:
            isgmt = struct.unpack(">%db" % ttisgmtcnt,
                                  fileobj.read(ttisgmtcnt))

        # Build ttinfo list
        out.ttinfo_list = []
        for i in range(typecnt):
            gmtoff, isdst, abbrind = ttinfo[i]
            # Round to full-minutes if that's not the case. Python's
            # datetime doesn't accept sub-minute timezones. Check
            # http://python.org/sf/1447945 for some information.
            gmtoff = 60 * ((gmtoff + 30) // 60)
            tti = _ttinfo()
            tti.offset = gmtoff
            tti.dstoffset = datetime.timedelta(0)
            tti.delta = datetime.timedelta(seconds=gmtoff)
            tti.isdst = isdst
            tti.abbr = abbr[abbrind:abbr.find('\x00', abbrind)]
            tti.isstd = (ttisstdcnt > i and isstd[i] != 0)
            tti.isgmt = (ttisgmtcnt > i and isgmt[i] != 0)
            out.ttinfo_list.append(tti)

        # Replace ttinfo indexes for ttinfo objects.
        out.trans_idx = [out.ttinfo_list[idx] for idx in out.trans_idx]

        # Set standard, dst, and before ttinfos. before will be
        # used when a given time is before any transitions,
        # and will be set to the first non-dst ttinfo, or to
        # the first dst, if all of them are dst.
        out.ttinfo_std = None
        out.ttinfo_dst = None
        out.ttinfo_before = None
        if out.ttinfo_list:
            if not out.trans_list_utc:
                out.ttinfo_std = out.ttinfo_first = out.ttinfo_list[0]
            else:
                for i in range(timecnt-1, -1, -1):
                    tti = out.trans_idx[i]
                    if not out.ttinfo_std and not tti.isdst:
                        out.ttinfo_std = tti
                    elif not out.ttinfo_dst and tti.isdst:
                        out.ttinfo_dst = tti

                    if out.ttinfo_std and out.ttinfo_dst:
                        break
                else:
                    if out.ttinfo_dst and not out.ttinfo_std:
                        out.ttinfo_std = out.ttinfo_dst

                for tti in out.ttinfo_list:
                    if not tti.isdst:
                        out.ttinfo_before = tti
                        break
                else:
                    out.ttinfo_before = out.ttinfo_list[0]

        # Now fix transition times to become relative to wall time.
        #
        # I'm not sure about this. In my tests, the tz source file
        # is setup to wall time, and in the binary file isstd and
        # isgmt are off, so it should be in wall time. OTOH, it's
        # always in gmt time. Let me know if you have comments
        # about this.
        laststdoffset = None
        out.trans_list = []
        for i, tti in enumerate(out.trans_idx):
            if not tti.isdst:
                offset = tti.offset
                laststdoffset = offset
            else:
                if laststdoffset is not None:
                    # Store the DST offset as well and update it in the list
                    tti.dstoffset = tti.offset - laststdoffset
                    out.trans_idx[i] = tti

                offset = laststdoffset or 0

            out.trans_list.append(out.trans_list_utc[i] + offset)

        # In case we missed any DST offsets on the way in for some reason, make
        # a second pass over the list, looking for the /next/ DST offset.
        laststdoffset = None
        for i in reversed(range(len(out.trans_idx))):
            tti = out.trans_idx[i]
            if tti.isdst:
                if not (tti.dstoffset or laststdoffset is None):
                    tti.dstoffset = tti.offset - laststdoffset
            else:
                laststdoffset = tti.offset

            if not isinstance(tti.dstoffset, datetime.timedelta):
                tti.dstoffset = datetime.timedelta(seconds=tti.dstoffset)

            out.trans_idx[i] = tti

        out.trans_idx = tuple(out.trans_idx)
        out.trans_list = tuple(out.trans_list)
        out.trans_list_utc = tuple(out.trans_list_utc)

        return out

    def _find_last_transition(self, dt, in_utc=False):
        # If there's no list, there are no transitions to find
        if not self._trans_list:
            return None

        timestamp = _datetime_to_timestamp(dt)

        # Find where the timestamp fits in the transition list - if the
        # timestamp is a transition time, it's part of the "after" period.
        trans_list = self._trans_list_utc if in_utc else self._trans_list
        idx = bisect.bisect_right(trans_list, timestamp)

        # We want to know when the previous transition was, so subtract off 1
        return idx - 1        

    def _get_ttinfo(self, idx):
        # For no list or after the last transition, default to _ttinfo_std
        if idx is None or (idx + 1) >= len(self._trans_list):
            return self._ttinfo_std

        # If there is a list and the time is before it, return _ttinfo_before
        if idx < 0:
            return self._ttinfo_before

        return self._trans_idx[idx]

    def _find_ttinfo(self, dt):
        idx = self._resolve_ambiguous_time(dt)

        return self._get_ttinfo(idx)

    def fromutc(self, dt):
        """
        The ``tzfile`` implementation of :py:func:`datetime.tzinfo.fromutc`.

        :param dt:
            A :py:class:`datetime.datetime` object.

        :raises TypeError:
            Raised if ``dt`` is not a :py:class:`datetime.datetime` object.

        :raises ValueError:
            Raised if this is called with a ``dt`` which does not have this
            ``tzinfo`` attached.

        :return:
            Returns a :py:class:`datetime.datetime` object representing the
            wall time in ``self``'s time zone.
        """
        # These isinstance checks are in datetime.tzinfo, so we'll preserve
        # them, even if we don't care about duck typing.
        if not isinstance(dt, datetime.datetime):
            raise TypeError("fromutc() requires a datetime argument")

        if dt.tzinfo is not self:
            raise ValueError("dt.tzinfo is not self")

        # First treat UTC as wall time and get the transition we're in.
        idx = self._find_last_transition(dt, in_utc=True)
        tti = self._get_ttinfo(idx)

        dt_out = dt + datetime.timedelta(seconds=tti.offset)

        fold = self.is_ambiguous(dt_out, idx=idx)

        return enfold(dt_out, fold=int(fold))

    def is_ambiguous(self, dt, idx=None):
        """
        Whether or not the "wall time" of a given datetime is ambiguous in this
        zone.

        :param dt:
            A :py:class:`datetime.datetime`, naive or time zone aware.


        :return:
            Returns ``True`` if ambiguous, ``False`` otherwise.

        .. versionadded:: 2.6.0
        """
        if idx is None:
            idx = self._find_last_transition(dt)

        # Calculate the difference in offsets from current to previous
        timestamp = _datetime_to_timestamp(dt)
        tti = self._get_ttinfo(idx)

        if idx is None or idx <= 0:
            return False

        od = self._get_ttinfo(idx - 1).offset - tti.offset
        tt = self._trans_list[idx]          # Transition time

        return timestamp < tt + od

    def _resolve_ambiguous_time(self, dt):
        idx = self._find_last_transition(dt)

        # If we have no transitions, return the index
        _fold = self._fold(dt)
        if idx is None or idx == 0:
            return idx

        # If it's ambiguous and we're in a fold, shift to a different index.
        idx_offset = int(not _fold and self.is_ambiguous(dt, idx))

        return idx - idx_offset

    def utcoffset(self, dt):
        if dt is None:
            return None

        if not self._ttinfo_std:
            return ZERO

        return self._find_ttinfo(dt).delta

    def dst(self, dt):
        if dt is None:
            return None

        if not self._ttinfo_dst:
            return ZERO

        tti = self._find_ttinfo(dt)

        if not tti.isdst:
            return ZERO

        # The documentation says that utcoffset()-dst() must
        # be constant for every dt.
        return tti.dstoffset

    @tzname_in_python2
    def tzname(self, dt):
        if not self._ttinfo_std or dt is None:
            return None
        return self._find_ttinfo(dt).abbr

    def __eq__(self, other):
        if not isinstance(other, tzfile):
            return NotImplemented
        return (self._trans_list == other._trans_list and
                self._trans_idx == other._trans_idx and
                self._ttinfo_list == other._ttinfo_list)

    __hash__ = None

    def __ne__(self, other):
        return not (self == other)

    def __repr__(self):
        return "%s(%s)" % (self.__class__.__name__, repr(self._filename))

    def __reduce__(self):
        return self.__reduce_ex__(None)

    def __reduce_ex__(self, protocol):
        return (self.__class__, (None, self._filename), self.__dict__)


class tzrange(tzrangebase):
    """
    The ``tzrange`` object is a time zone specified by a set of offsets and
    abbreviations, equivalent to the way the ``TZ`` variable can be specified
    in POSIX-like systems, but using Python delta objects to specify DST
    start, end and offsets.

    :param stdabbr:
        The abbreviation for standard time (e.g. ``'EST'``).

    :param stdoffset:
        An integer or :class:`datetime.timedelta` object or equivalent
        specifying the base offset from UTC.

        If unspecified, +00:00 is used.

    :param dstabbr:
        The abbreviation for DST / "Summer" time (e.g. ``'EDT'``).

        If specified, with no other DST information, DST is assumed to occur
        and the default behavior or ``dstoffset``, ``start`` and ``end`` is
        used. If unspecified and no other DST information is specified, it
        is assumed that this zone has no DST.

        If this is unspecified and other DST information is *is* specified,
        DST occurs in the zone but the time zone abbreviation is left
        unchanged.

    :param dstoffset:
        A an integer or :class:`datetime.timedelta` object or equivalent
        specifying the UTC offset during DST. If unspecified and any other DST
        information is specified, it is assumed to be the STD offset +1 hour.

    :param start:
        A :class:`relativedelta.relativedelta` object or equivalent specifying
        the time and time of year that daylight savings time starts. To specify,
        for example, that DST starts at 2AM on the 2nd Sunday in March, pass:

            ``relativedelta(hours=2, month=3, day=1, weekday=SU(+2))``

        If unspecified and any other DST information is specified, the default
        value is 2 AM on the first Sunday in April.

    :param end:
        A :class:`relativedelta.relativedelta` object or equivalent representing
        the time and time of year that daylight savings time ends, with the
        same specification method as in ``start``. One note is that this should
        point to the first time in the *standard* zone, so if a transition
        occurs at 2AM in the DST zone and the clocks are set back 1 hour to 1AM,
        set the `hours` parameter to +1.


    **Examples:**

    .. testsetup:: tzrange

        from dateutil.tz import tzrange, tzstr

    .. doctest:: tzrange

        >>> tzstr('EST5EDT') == tzrange("EST", -18000, "EDT")
        True

        >>> from dateutil.relativedelta import *
        >>> range1 = tzrange("EST", -18000, "EDT")
        >>> range2 = tzrange("EST", -18000, "EDT", -14400,
        ...                  relativedelta(hours=+2, month=4, day=1,
        ...                                weekday=SU(+1)),
        ...                  relativedelta(hours=+1, month=10, day=31,
        ...                                weekday=SU(-1)))
        >>> tzstr('EST5EDT') == range1 == range2
        True

    """
    def __init__(self, stdabbr, stdoffset=None,
                 dstabbr=None, dstoffset=None,
                 start=None, end=None):

        global relativedelta
        from dateutil import relativedelta

        self._std_abbr = stdabbr
        self._dst_abbr = dstabbr

        try:
            stdoffset = _total_seconds(stdoffset)
        except (TypeError, AttributeError):
            pass

        try:
            dstoffset = _total_seconds(dstoffset)
        except (TypeError, AttributeError):
            pass

        if stdoffset is not None:
            self._std_offset = datetime.timedelta(seconds=stdoffset)
        else:
            self._std_offset = ZERO

        if dstoffset is not None:
            self._dst_offset = datetime.timedelta(seconds=dstoffset)
        elif dstabbr and stdoffset is not None:
            self._dst_offset = self._std_offset + datetime.timedelta(hours=+1)
        else:
            self._dst_offset = ZERO

        if dstabbr and start is None:
            self._start_delta = relativedelta.relativedelta(
                hours=+2, month=4, day=1, weekday=relativedelta.SU(+1))
        else:
            self._start_delta = start

        if dstabbr and end is None:
            self._end_delta = relativedelta.relativedelta(
                hours=+1, month=10, day=31, weekday=relativedelta.SU(-1))
        else:
            self._end_delta = end

        self._dst_base_offset_ = self._dst_offset - self._std_offset
        self.hasdst = bool(self._start_delta)

    def transitions(self, year):
        """
        For a given year, get the DST on and off transition times, expressed
        always on the standard time side. For zones with no transitions, this
        function returns ``None``.

        :param year:
            The year whose transitions you would like to query.

        :return:
            Returns a :class:`tuple` of :class:`datetime.datetime` objects,
            ``(dston, dstoff)`` for zones with an annual DST transition, or
            ``None`` for fixed offset zones.
        """
        if not self.hasdst:
            return None

        base_year = datetime.datetime(year, 1, 1)

        start = base_year + self._start_delta
        end = base_year + self._end_delta

        return (start, end)

    def __eq__(self, other):
        if not isinstance(other, tzrange):
            return NotImplemented

        return (self._std_abbr == other._std_abbr and
                self._dst_abbr == other._dst_abbr and
                self._std_offset == other._std_offset and
                self._dst_offset == other._dst_offset and
                self._start_delta == other._start_delta and
                self._end_delta == other._end_delta)

    @property
    def _dst_base_offset(self):
        return self._dst_base_offset_


class tzstr(tzrange):
    """
    ``tzstr`` objects are time zone objects specified by a time-zone string as
    it would be passed to a ``TZ`` variable on POSIX-style systems (see
    the `GNU C Library: TZ Variable`_ for more details).

    There is one notable exception, which is that POSIX-style time zones use an
    inverted offset format, so normally ``GMT+3`` would be parsed as an offset
    3 hours *behind* GMT. The ``tzstr`` time zone object will parse this as an
    offset 3 hours *ahead* of GMT. If you would like to maintain the POSIX
    behavior, pass a ``True`` value to ``posix_offset``.

    The :class:`tzrange` object provides the same functionality, but is
    specified using :class:`relativedelta.relativedelta` objects. rather than
    strings.

    :param s:
        A time zone string in ``TZ`` variable format. This can be a
        :class:`bytes` (2.x: :class:`str`), :class:`str` (2.x: :class:`unicode`)
        or a stream emitting unicode characters (e.g. :class:`StringIO`).

    :param posix_offset:
        Optional. If set to ``True``, interpret strings such as ``GMT+3`` or
        ``UTC+3`` as being 3 hours *behind* UTC rather than ahead, per the
        POSIX standard.

    .. _`GNU C Library: TZ Variable`:
        https://www.gnu.org/software/libc/manual/html_node/TZ-Variable.html
    """
    def __init__(self, s, posix_offset=False):
        global parser
        from dateutil import parser

        self._s = s

        res = parser._parsetz(s)
        if res is None:
            raise ValueError("unknown string format")

        # Here we break the compatibility with the TZ variable handling.
        # GMT-3 actually *means* the timezone -3.
        if res.stdabbr in ("GMT", "UTC") and not posix_offset:
            res.stdoffset *= -1

        # We must initialize it first, since _delta() needs
        # _std_offset and _dst_offset set. Use False in start/end
        # to avoid building it two times.
        tzrange.__init__(self, res.stdabbr, res.stdoffset,
                         res.dstabbr, res.dstoffset,
                         start=False, end=False)

        if not res.dstabbr:
            self._start_delta = None
            self._end_delta = None
        else:
            self._start_delta = self._delta(res.start)
            if self._start_delta:
                self._end_delta = self._delta(res.end, isend=1)

        self.hasdst = bool(self._start_delta)

    def _delta(self, x, isend=0):
        from dateutil import relativedelta
        kwargs = {}
        if x.month is not None:
            kwargs["month"] = x.month
            if x.weekday is not None:
                kwargs["weekday"] = relativedelta.weekday(x.weekday, x.week)
                if x.week > 0:
                    kwargs["day"] = 1
                else:
                    kwargs["day"] = 31
            elif x.day:
                kwargs["day"] = x.day
        elif x.yday is not None:
            kwargs["yearday"] = x.yday
        elif x.jyday is not None:
            kwargs["nlyearday"] = x.jyday
        if not kwargs:
            # Default is to start on first sunday of april, and end
            # on last sunday of october.
            if not isend:
                kwargs["month"] = 4
                kwargs["day"] = 1
                kwargs["weekday"] = relativedelta.SU(+1)
            else:
                kwargs["month"] = 10
                kwargs["day"] = 31
                kwargs["weekday"] = relativedelta.SU(-1)
        if x.time is not None:
            kwargs["seconds"] = x.time
        else:
            # Default is 2AM.
            kwargs["seconds"] = 7200
        if isend:
            # Convert to standard time, to follow the documented way
            # of working with the extra hour. See the documentation
            # of the tzinfo class.
            delta = self._dst_offset - self._std_offset
            kwargs["seconds"] -= delta.seconds + delta.days * 86400
        return relativedelta.relativedelta(**kwargs)

    def __repr__(self):
        return "%s(%s)" % (self.__class__.__name__, repr(self._s))


class _tzicalvtzcomp(object):
    def __init__(self, tzoffsetfrom, tzoffsetto, isdst,
                 tzname=None, rrule=None):
        self.tzoffsetfrom = datetime.timedelta(seconds=tzoffsetfrom)
        self.tzoffsetto = datetime.timedelta(seconds=tzoffsetto)
        self.tzoffsetdiff = self.tzoffsetto - self.tzoffsetfrom
        self.isdst = isdst
        self.tzname = tzname
        self.rrule = rrule


class _tzicalvtz(_tzinfo):
    def __init__(self, tzid, comps=[]):
        super(_tzicalvtz, self).__init__()

        self._tzid = tzid
        self._comps = comps
        self._cachedate = []
        self._cachecomp = []

    def _find_comp(self, dt):
        if len(self._comps) == 1:
            return self._comps[0]

        dt = dt.replace(tzinfo=None)

        try:
            return self._cachecomp[self._cachedate.index((dt, self._fold(dt)))]
        except ValueError:
            pass

        lastcompdt = None
        lastcomp = None

        for comp in self._comps:
            compdt = self._find_compdt(comp, dt)

            if compdt and (not lastcompdt or lastcompdt < compdt):
                lastcompdt = compdt
                lastcomp = comp

        if not lastcomp:
            # RFC says nothing about what to do when a given
            # time is before the first onset date. We'll look for the
            # first standard component, or the first component, if
            # none is found.
            for comp in self._comps:
                if not comp.isdst:
                    lastcomp = comp
                    break
            else:
                lastcomp = comp[0]

        self._cachedate.insert(0, (dt, self._fold(dt)))
        self._cachecomp.insert(0, lastcomp)

        if len(self._cachedate) > 10:
            self._cachedate.pop()
            self._cachecomp.pop()

        return lastcomp

    def _find_compdt(self, comp, dt):
        if comp.tzoffsetdiff < ZERO and self._fold(dt):
            dt -= comp.tzoffsetdiff

        compdt = comp.rrule.before(dt, inc=True)

        return compdt

    def utcoffset(self, dt):
        if dt is None:
            return None

        return self._find_comp(dt).tzoffsetto

    def dst(self, dt):
        comp = self._find_comp(dt)
        if comp.isdst:
            return comp.tzoffsetdiff
        else:
            return ZERO

    @tzname_in_python2
    def tzname(self, dt):
        return self._find_comp(dt).tzname

    def __repr__(self):
        return "<tzicalvtz %s>" % repr(self._tzid)

    __reduce__ = object.__reduce__


class tzical(object):
    """
    This object is designed to parse an iCalendar-style ``VTIMEZONE`` structure
    as set out in `RFC 2445`_ Section 4.6.5 into one or more `tzinfo` objects.

    :param `fileobj`:
        A file or stream in iCalendar format, which should be UTF-8 encoded
        with CRLF endings.

    .. _`RFC 2445`: https://www.ietf.org/rfc/rfc2445.txt
    """
    def __init__(self, fileobj):
        global rrule
        from dateutil import rrule

        if isinstance(fileobj, string_types):
            self._s = fileobj
            # ical should be encoded in UTF-8 with CRLF
            fileobj = open(fileobj, 'r')
        else:
            self._s = getattr(fileobj, 'name', repr(fileobj))
            fileobj = _ContextWrapper(fileobj)

        self._vtz = {}

        with fileobj as fobj:
            self._parse_rfc(fobj.read())

    def keys(self):
        """
        Retrieves the available time zones as a list.
        """
        return list(self._vtz.keys())

    def get(self, tzid=None):
        """
        Retrieve a :py:class:`datetime.tzinfo` object by its ``tzid``.

        :param tzid:
            If there is exactly one time zone available, omitting ``tzid``
            or passing :py:const:`None` value returns it. Otherwise a valid
            key (which can be retrieved from :func:`keys`) is required.

        :raises ValueError:
            Raised if ``tzid`` is not specified but there are either more
            or fewer than 1 zone defined.

        :returns:
            Returns either a :py:class:`datetime.tzinfo` object representing
            the relevant time zone or :py:const:`None` if the ``tzid`` was
            not found.
        """
        if tzid is None:
            if len(self._vtz) == 0:
                raise ValueError("no timezones defined")
            elif len(self._vtz) > 1:
                raise ValueError("more than one timezone available")
            tzid = next(iter(self._vtz))

        return self._vtz.get(tzid)

    def _parse_offset(self, s):
        s = s.strip()
        if not s:
            raise ValueError("empty offset")
        if s[0] in ('+', '-'):
            signal = (-1, +1)[s[0] == '+']
            s = s[1:]
        else:
            signal = +1
        if len(s) == 4:
            return (int(s[:2]) * 3600 + int(s[2:]) * 60) * signal
        elif len(s) == 6:
            return (int(s[:2]) * 3600 + int(s[2:4]) * 60 + int(s[4:])) * signal
        else:
            raise ValueError("invalid offset: " + s)

    def _parse_rfc(self, s):
        lines = s.splitlines()
        if not lines:
            raise ValueError("empty string")

        # Unfold
        i = 0
        while i < len(lines):
            line = lines[i].rstrip()
            if not line:
                del lines[i]
            elif i > 0 and line[0] == " ":
                lines[i-1] += line[1:]
                del lines[i]
            else:
                i += 1

        tzid = None
        comps = []
        invtz = False
        comptype = None
        for line in lines:
            if not line:
                continue
            name, value = line.split(':', 1)
            parms = name.split(';')
            if not parms:
                raise ValueError("empty property name")
            name = parms[0].upper()
            parms = parms[1:]
            if invtz:
                if name == "BEGIN":
                    if value in ("STANDARD", "DAYLIGHT"):
                        # Process component
                        pass
                    else:
                        raise ValueError("unknown component: "+value)
                    comptype = value
                    founddtstart = False
                    tzoffsetfrom = None
                    tzoffsetto = None
                    rrulelines = []
                    tzname = None
                elif name == "END":
                    if value == "VTIMEZONE":
                        if comptype:
                            raise ValueError("component not closed: "+comptype)
                        if not tzid:
                            raise ValueError("mandatory TZID not found")
                        if not comps:
                            raise ValueError(
                                "at least one component is needed")
                        # Process vtimezone
                        self._vtz[tzid] = _tzicalvtz(tzid, comps)
                        invtz = False
                    elif value == comptype:
                        if not founddtstart:
                            raise ValueError("mandatory DTSTART not found")
                        if tzoffsetfrom is None:
                            raise ValueError(
                                "mandatory TZOFFSETFROM not found")
                        if tzoffsetto is None:
                            raise ValueError(
                                "mandatory TZOFFSETFROM not found")
                        # Process component
                        rr = None
                        if rrulelines:
                            rr = rrule.rrulestr("\n".join(rrulelines),
                                                compatible=True,
                                                ignoretz=True,
                                                cache=True)
                        comp = _tzicalvtzcomp(tzoffsetfrom, tzoffsetto,
                                              (comptype == "DAYLIGHT"),
                                              tzname, rr)
                        comps.append(comp)
                        comptype = None
                    else:
                        raise ValueError("invalid component end: "+value)
                elif comptype:
                    if name == "DTSTART":
                        rrulelines.append(line)
                        founddtstart = True
                    elif name in ("RRULE", "RDATE", "EXRULE", "EXDATE"):
                        rrulelines.append(line)
                    elif name == "TZOFFSETFROM":
                        if parms:
                            raise ValueError(
                                "unsupported %s parm: %s " % (name, parms[0]))
                        tzoffsetfrom = self._parse_offset(value)
                    elif name == "TZOFFSETTO":
                        if parms:
                            raise ValueError(
                                "unsupported TZOFFSETTO parm: "+parms[0])
                        tzoffsetto = self._parse_offset(value)
                    elif name == "TZNAME":
                        if parms:
                            raise ValueError(
                                "unsupported TZNAME parm: "+parms[0])
                        tzname = value
                    elif name == "COMMENT":
                        pass
                    else:
                        raise ValueError("unsupported property: "+name)
                else:
                    if name == "TZID":
                        if parms:
                            raise ValueError(
                                "unsupported TZID parm: "+parms[0])
                        tzid = value
                    elif name in ("TZURL", "LAST-MODIFIED", "COMMENT"):
                        pass
                    else:
                        raise ValueError("unsupported property: "+name)
            elif name == "BEGIN" and value == "VTIMEZONE":
                tzid = None
                comps = []
                invtz = True

    def __repr__(self):
        return "%s(%s)" % (self.__class__.__name__, repr(self._s))


if sys.platform != "win32":
    TZFILES = ["/etc/localtime", "localtime"]
    TZPATHS = ["/usr/share/zoneinfo",
               "/usr/lib/zoneinfo",
               "/usr/share/lib/zoneinfo",
               "/etc/zoneinfo"]
else:
    TZFILES = []
    TZPATHS = []


def gettz(name=None):
    tz = None
    if not name:
        try:
            name = os.environ["TZ"]
        except KeyError:
            pass
    if name is None or name == ":":
        for filepath in TZFILES:
            if not os.path.isabs(filepath):
                filename = filepath
                for path in TZPATHS:
                    filepath = os.path.join(path, filename)
                    if os.path.isfile(filepath):
                        break
                else:
                    continue
            if os.path.isfile(filepath):
                try:
                    tz = tzfile(filepath)
                    break
                except (IOError, OSError, ValueError):
                    pass
        else:
            tz = tzlocal()
    else:
        if name.startswith(":"):
            name = name[:-1]
        if os.path.isabs(name):
            if os.path.isfile(name):
                tz = tzfile(name)
            else:
                tz = None
        else:
            for path in TZPATHS:
                filepath = os.path.join(path, name)
                if not os.path.isfile(filepath):
                    filepath = filepath.replace(' ', '_')
                    if not os.path.isfile(filepath):
                        continue
                try:
                    tz = tzfile(filepath)
                    break
                except (IOError, OSError, ValueError):
                    pass
            else:
                tz = None
                if tzwin is not None:
                    try:
                        tz = tzwin(name)
                    except WindowsError:
                        tz = None

                if not tz:
                    from dateutil.zoneinfo import get_zonefile_instance
                    tz = get_zonefile_instance().get(name)

                if not tz:
                    for c in name:
                        # name must have at least one offset to be a tzstr
                        if c in "0123456789":
                            try:
                                tz = tzstr(name)
                            except ValueError:
                                pass
                            break
                    else:
                        if name in ("GMT", "UTC"):
                            tz = tzutc()
                        elif name in time.tzname:
                            tz = tzlocal()
    return tz


def datetime_exists(dt, tz=None):
    """
    Given a datetime and a time zone, determine whether or not a given datetime
    would fall in a gap.

    :param dt:
        A :class:`datetime.datetime` (whose time zone will be ignored if ``tz``
        is provided.)

    :param tz:
        A :class:`datetime.tzinfo` with support for the ``fold`` attribute. If
        ``None`` or not provided, the datetime's own time zone will be used.

    :return:
        Returns a boolean value whether or not the "wall time" exists in ``tz``.
    """
    if tz is None:
        if dt.tzinfo is None:
            raise ValueError('Datetime is naive and no time zone provided.')
        tz = dt.tzinfo

    dt = dt.replace(tzinfo=None)

    # This is essentially a test of whether or not the datetime can survive
    # a round trip to UTC.
    dt_rt = dt.replace(tzinfo=tz).astimezone(tzutc()).astimezone(tz)
    dt_rt = dt_rt.replace(tzinfo=None)

    return dt == dt_rt


def datetime_ambiguous(dt, tz=None):
    """
    Given a datetime and a time zone, determine whether or not a given datetime
    is ambiguous (i.e if there are two times differentiated only by their DST
    status).

    :param dt:
        A :class:`datetime.datetime` (whose time zone will be ignored if ``tz``
        is provided.)

    :param tz:
        A :class:`datetime.tzinfo` with support for the ``fold`` attribute. If
        ``None`` or not provided, the datetime's own time zone will be used.

    :return:
        Returns a boolean value whether or not the "wall time" is ambiguous in
        ``tz``.

    .. versionadded:: 2.6.0
    """
    if tz is None:
        if dt.tzinfo is None:
            raise ValueError('Datetime is naive and no time zone provided.')

        tz = dt.tzinfo

    # If a time zone defines its own "is_ambiguous" function, we'll use that.
    is_ambiguous_fn = getattr(tz, 'is_ambiguous', None)
    if is_ambiguous_fn is not None:
        try:
            return tz.is_ambiguous(dt)
        except:
            pass

    # If it doesn't come out and tell us it's ambiguous, we'll just check if
    # the fold attribute has any effect on this particular date and time.
    dt = dt.replace(tzinfo=tz)
    wall_0 = enfold(dt, fold=0)
    wall_1 = enfold(dt, fold=1)

    same_offset = wall_0.utcoffset() == wall_1.utcoffset()
    same_dst = wall_0.dst() == wall_1.dst()

    return not (same_offset and same_dst)


def _datetime_to_timestamp(dt):
    """
    Convert a :class:`datetime.datetime` object to an epoch timestamp in seconds
    since January 1, 1970, ignoring the time zone.
    """
    return _total_seconds((dt.replace(tzinfo=None) - EPOCH))


class _ContextWrapper(object):
    """
    Class for wrapping contexts so that they are passed through in a
    with statement.
    """
    def __init__(self, context):
        self.context = context

    def __enter__(self):
        return self.context

    def __exit__(*args, **kwargs):
        pass

# vim:ts=4:sw=4:et
PKa�\��9Å,�,	tz/win.pynu�[���# This code was originally contributed by Jeffrey Harris.
import datetime
import struct

from six.moves import winreg
from six import text_type

try:
    import ctypes
    from ctypes import wintypes
except ValueError:
    # ValueError is raised on non-Windows systems for some horrible reason.
    raise ImportError("Running tzwin on non-Windows system")

from ._common import tzrangebase

__all__ = ["tzwin", "tzwinlocal", "tzres"]

ONEWEEK = datetime.timedelta(7)

TZKEYNAMENT = r"SOFTWARE\Microsoft\Windows NT\CurrentVersion\Time Zones"
TZKEYNAME9X = r"SOFTWARE\Microsoft\Windows\CurrentVersion\Time Zones"
TZLOCALKEYNAME = r"SYSTEM\CurrentControlSet\Control\TimeZoneInformation"


def _settzkeyname():
    handle = winreg.ConnectRegistry(None, winreg.HKEY_LOCAL_MACHINE)
    try:
        winreg.OpenKey(handle, TZKEYNAMENT).Close()
        TZKEYNAME = TZKEYNAMENT
    except WindowsError:
        TZKEYNAME = TZKEYNAME9X
    handle.Close()
    return TZKEYNAME


TZKEYNAME = _settzkeyname()


class tzres(object):
    """
    Class for accessing `tzres.dll`, which contains timezone name related
    resources.

    .. versionadded:: 2.5.0
    """
    p_wchar = ctypes.POINTER(wintypes.WCHAR)        # Pointer to a wide char

    def __init__(self, tzres_loc='tzres.dll'):
        # Load the user32 DLL so we can load strings from tzres
        user32 = ctypes.WinDLL('user32')

        # Specify the LoadStringW function
        user32.LoadStringW.argtypes = (wintypes.HINSTANCE,
                                       wintypes.UINT,
                                       wintypes.LPWSTR,
                                       ctypes.c_int)

        self.LoadStringW = user32.LoadStringW
        self._tzres = ctypes.WinDLL(tzres_loc)
        self.tzres_loc = tzres_loc

    def load_name(self, offset):
        """
        Load a timezone name from a DLL offset (integer).

        >>> from dateutil.tzwin import tzres
        >>> tzr = tzres()
        >>> print(tzr.load_name(112))
        'Eastern Standard Time'

        :param offset:
            A positive integer value referring to a string from the tzres dll.

        ..note:
            Offsets found in the registry are generally of the form
            `@tzres.dll,-114`. The offset in this case if 114, not -114.

        """
        resource = self.p_wchar()
        lpBuffer = ctypes.cast(ctypes.byref(resource), wintypes.LPWSTR)
        nchar = self.LoadStringW(self._tzres._handle, offset, lpBuffer, 0)
        return resource[:nchar]

    def name_from_string(self, tzname_str):
        """
        Parse strings as returned from the Windows registry into the time zone
        name as defined in the registry.

        >>> from dateutil.tzwin import tzres
        >>> tzr = tzres()
        >>> print(tzr.name_from_string('@tzres.dll,-251'))
        'Dateline Daylight Time'
        >>> print(tzr.name_from_string('Eastern Standard Time'))
        'Eastern Standard Time'

        :param tzname_str:
            A timezone name string as returned from a Windows registry key.

        :return:
            Returns the localized timezone string from tzres.dll if the string
            is of the form `@tzres.dll,-offset`, else returns the input string.
        """
        if not tzname_str.startswith('@'):
            return tzname_str

        name_splt = tzname_str.split(',-')
        try:
            offset = int(name_splt[1])
        except:
            raise ValueError("Malformed timezone string.")

        return self.load_name(offset)


class tzwinbase(tzrangebase):
    """tzinfo class based on win32's timezones available in the registry."""
    def __init__(self):
        raise NotImplementedError('tzwinbase is an abstract base class')

    def __eq__(self, other):
        # Compare on all relevant dimensions, including name.
        if not isinstance(other, tzwinbase):
            return NotImplemented

        return  (self._std_offset == other._std_offset and
                 self._dst_offset == other._dst_offset and
                 self._stddayofweek == other._stddayofweek and
                 self._dstdayofweek == other._dstdayofweek and
                 self._stdweeknumber == other._stdweeknumber and
                 self._dstweeknumber == other._dstweeknumber and
                 self._stdhour == other._stdhour and
                 self._dsthour == other._dsthour and
                 self._stdminute == other._stdminute and
                 self._dstminute == other._dstminute and
                 self._std_abbr == other._std_abbr and
                 self._dst_abbr == other._dst_abbr)

    @staticmethod
    def list():
        """Return a list of all time zones known to the system."""
        with winreg.ConnectRegistry(None, winreg.HKEY_LOCAL_MACHINE) as handle:
            with winreg.OpenKey(handle, TZKEYNAME) as tzkey:
                result = [winreg.EnumKey(tzkey, i)
                          for i in range(winreg.QueryInfoKey(tzkey)[0])]
        return result

    def display(self):
        return self._display

    def transitions(self, year):
        """
        For a given year, get the DST on and off transition times, expressed
        always on the standard time side. For zones with no transitions, this
        function returns ``None``.

        :param year:
            The year whose transitions you would like to query.

        :return:
            Returns a :class:`tuple` of :class:`datetime.datetime` objects,
            ``(dston, dstoff)`` for zones with an annual DST transition, or
            ``None`` for fixed offset zones.
        """

        if not self.hasdst:
            return None

        dston = picknthweekday(year, self._dstmonth, self._dstdayofweek,
                               self._dsthour, self._dstminute,
                               self._dstweeknumber)

        dstoff = picknthweekday(year, self._stdmonth, self._stddayofweek,
                                self._stdhour, self._stdminute,
                                self._stdweeknumber)

        # Ambiguous dates default to the STD side
        dstoff -= self._dst_base_offset

        return dston, dstoff

    def _get_hasdst(self):
        return self._dstmonth != 0

    @property
    def _dst_base_offset(self):
        return self._dst_base_offset_


class tzwin(tzwinbase):

    def __init__(self, name):
        self._name = name

        # multiple contexts only possible in 2.7 and 3.1, we still support 2.6
        with winreg.ConnectRegistry(None, winreg.HKEY_LOCAL_MACHINE) as handle:
            tzkeyname = text_type("{kn}\\{name}").format(kn=TZKEYNAME, name=name)
            with winreg.OpenKey(handle, tzkeyname) as tzkey:
                keydict = valuestodict(tzkey)

        self._std_abbr = keydict["Std"]
        self._dst_abbr = keydict["Dlt"]

        self._display = keydict["Display"]

        # See http://ww_winreg.jsiinc.com/SUBA/tip0300/rh0398.htm
        tup = struct.unpack("=3l16h", keydict["TZI"])
        stdoffset = -tup[0]-tup[1]          # Bias + StandardBias * -1
        dstoffset = stdoffset-tup[2]        # + DaylightBias * -1
        self._std_offset = datetime.timedelta(minutes=stdoffset)
        self._dst_offset = datetime.timedelta(minutes=dstoffset)

        # for the meaning see the win32 TIME_ZONE_INFORMATION structure docs
        # http://msdn.microsoft.com/en-us/library/windows/desktop/ms725481(v=vs.85).aspx
        (self._stdmonth,
         self._stddayofweek,   # Sunday = 0
         self._stdweeknumber,  # Last = 5
         self._stdhour,
         self._stdminute) = tup[4:9]

        (self._dstmonth,
         self._dstdayofweek,   # Sunday = 0
         self._dstweeknumber,  # Last = 5
         self._dsthour,
         self._dstminute) = tup[12:17]

        self._dst_base_offset_ = self._dst_offset - self._std_offset
        self.hasdst = self._get_hasdst()

    def __repr__(self):
        return "tzwin(%s)" % repr(self._name)

    def __reduce__(self):
        return (self.__class__, (self._name,))


class tzwinlocal(tzwinbase):
    def __init__(self):
        with winreg.ConnectRegistry(None, winreg.HKEY_LOCAL_MACHINE) as handle:
            with winreg.OpenKey(handle, TZLOCALKEYNAME) as tzlocalkey:
                keydict = valuestodict(tzlocalkey)

            self._std_abbr = keydict["StandardName"]
            self._dst_abbr = keydict["DaylightName"]

            try:
                tzkeyname = text_type('{kn}\\{sn}').format(kn=TZKEYNAME,
                                                          sn=self._std_abbr)
                with winreg.OpenKey(handle, tzkeyname) as tzkey:
                    _keydict = valuestodict(tzkey)
                    self._display = _keydict["Display"]
            except OSError:
                self._display = None

        stdoffset = -keydict["Bias"]-keydict["StandardBias"]
        dstoffset = stdoffset-keydict["DaylightBias"]

        self._std_offset = datetime.timedelta(minutes=stdoffset)
        self._dst_offset = datetime.timedelta(minutes=dstoffset)

        # For reasons unclear, in this particular key, the day of week has been
        # moved to the END of the SYSTEMTIME structure.
        tup = struct.unpack("=8h", keydict["StandardStart"])

        (self._stdmonth,
         self._stdweeknumber,  # Last = 5
         self._stdhour,
         self._stdminute) = tup[1:5]

        self._stddayofweek = tup[7]

        tup = struct.unpack("=8h", keydict["DaylightStart"])

        (self._dstmonth,
         self._dstweeknumber,  # Last = 5
         self._dsthour,
         self._dstminute) = tup[1:5]

        self._dstdayofweek = tup[7]

        self._dst_base_offset_ = self._dst_offset - self._std_offset
        self.hasdst = self._get_hasdst()

    def __repr__(self):
        return "tzwinlocal()"

    def __str__(self):
        # str will return the standard name, not the daylight name.
        return "tzwinlocal(%s)" % repr(self._std_abbr)

    def __reduce__(self):
        return (self.__class__, ())


def picknthweekday(year, month, dayofweek, hour, minute, whichweek):
    """ dayofweek == 0 means Sunday, whichweek 5 means last instance """
    first = datetime.datetime(year, month, 1, hour, minute)

    # This will work if dayofweek is ISO weekday (1-7) or Microsoft-style (0-6),
    # Because 7 % 7 = 0
    weekdayone = first.replace(day=((dayofweek - first.isoweekday()) % 7) + 1)
    wd = weekdayone + ((whichweek - 1) * ONEWEEK)
    if (wd.month != month):
        wd -= ONEWEEK

    return wd


def valuestodict(key):
    """Convert a registry key's values to a dictionary."""
    dout = {}
    size = winreg.QueryInfoKey(key)[1]
    tz_res = None

    for i in range(size):
        key_name, value, dtype = winreg.EnumValue(key, i)
        if dtype == winreg.REG_DWORD or dtype == winreg.REG_DWORD_LITTLE_ENDIAN:
            # If it's a DWORD (32-bit integer), it's stored as unsigned - convert
            # that to a proper signed integer
            if value & (1 << 31):
                value = value - (1 << 32)
        elif dtype == winreg.REG_SZ:
            # If it's a reference to the tzres DLL, load the actual string
            if value.startswith('@tzres'):
                tz_res = tz_res or tzres()
                value = tz_res.name_from_string(value)

            value = value.rstrip('\x00')    # Remove trailing nulls

        dout[key_name] = value

    return dout
PKa�\�-r1zoneinfo/__pycache__/rebuild.cpython-36.opt-1.pycnu�[���3

6�cY��@sfddlZddlZddlZddlZddlZddlmZddlmZm	Z	m
Z
ddgdfdd�Zdd�ZdS)	�N)�
check_call)�tar_open�METADATA_FN�ZONEFILENAMEZgzc-sHtj��tjj�d�}tjjt�}�zt|��v}x|D]}|j|��q6W�fdd�|D�}	yt	dd|g|	�Wn,t
k
r�}
zt|
��WYdd}
~
XnXWdQRXttjj|t
�d��}tj||dd	d
�WdQRXtjj|t�}t|d|��6}x.tj|�D] }
tjj||
�}|j||
��qWWdQRXWdtj��XdS)z�Rebuild the internal timezone info in dateutil/zoneinfo/zoneinfo*tar*

    filename is the timezone tarball from ftp.iana.org/tz.

    Zzoneinfocsg|]}tjj�|��qS�)�os�path�join)�.0�n)�tmpdirr�/usr/lib/python3.6/rebuild.py�
<listcomp>szrebuild.<locals>.<listcomp>Zzicz-dN�w�T)�indentZ	sort_keyszw:%s)�tempfileZmkdtemprrr	�dirname�__file__r�extractr�OSError�_print_on_nosuchfile�openr�json�dumpr�listdir�add�shutilZrmtree)�filename�tag�formatZ
zonegroupsZmetadataZzonedirZ	moduledirZtf�nameZ	filepaths�e�f�target�entryZ	entrypathr)rr
�rebuilds*

 r&cCs|jdkrtjd�dS)zdPrint helpful troubleshooting message

    e is an exception raised by subprocess.check_call()

    �zzCould not find zic. Perhaps you need to install libc-bin or some other package that provides it, or it's not in your PATH?N)�errno�logging�error)r"rrr
r*s
r)
r)rrrr�
subprocessrZdateutil.zoneinforrrr&rrrrr
�<module>sPKa�\4����,zoneinfo/__pycache__/__init__.cpython-36.pycnu�[���3

6�cY[�@s�ddlZddlZddlmZddlmZddlmZddlm	Z	ddl
mZddd	d
gZdZ
dZejZeed
�sxdd�ZGdd�de�Zdd�ZGdd�de�Ze�Zddd�Zdd�Zdd	�ZdS)�N)�TarFile)�get_data)�BytesIO)�closing)�tzfile�get_zonefile_instance�gettz�gettz_db_metadataZrebuildzdateutil-zoneinfo.tar.gzZMETADATA�__exit__cOsttj||��S)N)rr�open)�args�kwargs�r�/usr/lib/python3.6/__init__.py�tar_opensrc@seZdZdd�ZdS)rcCst|jffS)N)rZ	_filename)�selfrrr�
__reduce__sztzfile.__reduce__N)�__name__�
__module__�__qualname__rrrrrrsrcCsJytttt��Stk
rD}ztjdj|j|j	��dSd}~XnXdS)NzI/O error({0}): {1})
rrr�ZONEFILENAME�IOError�warnings�warn�format�errno�strerror)�errr�getzoneinfofile_streams
rc@s eZdZddd�Zddd�ZdS)�ZoneInfoFileNcs�|dk	r�t|dd����t�fdd��j�D���_t�fdd��j�D��}�jj|�y.�j�jt��}|j�j	d�}t
j|��_Wnt
k
r�d�_YnXWdQRXnt��_d�_dS)N�r)Zfileobj�modec3s:|]2}|j�r|jtkr|jt�j|�|jd�fVqdS))�filenameN)�isfile�name�METADATA_FNr�extractfile)�.0Zzf)�tfrr�	<genexpr>/sz(ZoneInfoFile.__init__.<locals>.<genexpr>c3s0|](}|j�s|j�r|j�j|jfVqdS)N)ZislnkZissymr$�zonesZlinkname)r'Zzl)rrrr)7szUTF-8)r�dictZ
getmembersr*�updater&Z	getmemberr%�read�decode�json�loads�metadata�KeyError)rZzonefile_streamZlinksZ
metadata_jsonZmetadata_strr)rr(r�__init__'szZoneInfoFile.__init__cCs|jj||�S)ak
        Wrapper for :func:`ZoneInfoFile.zones.get`. This is a convenience method
        for retrieving zones from the zone dictionary.

        :param name:
            The name of the zone to retrieve. (Generally IANA zone names)

        :param default:
            The value to return in the event of a missing key.

        .. versionadded:: 2.6.0

        )r*�get)rr$�defaultrrrr4FszZoneInfoFile.get)N)N)rrrr3r4rrrrr&s
rFcCs2|r
d}nttdd�}|dkr.tt��}|t_|S)a%
    This is a convenience function which provides a :class:`ZoneInfoFile`
    instance using the data provided by the ``dateutil`` package. By default, it
    caches a single instance of the ZoneInfoFile object and returns that.

    :param new_instance:
        If ``True``, a new instance of :class:`ZoneInfoFile` is instantiated and
        used as the cached instance for the next call. Otherwise, new instances
        are created only as necessary.

    :return:
        Returns a :class:`ZoneInfoFile` object.

    .. versionadded:: 2.6
    N�_cached_instance)�getattrrrrr6)Znew_instanceZzifrrrr`s
cCs8tjdt�tt�dkr(tjtt���tdjj	|�S)a+
    This retrieves a time zone from the local zoneinfo tarball that is packaged
    with dateutil.

    :param name:
        An IANA-style time zone name, as found in the zoneinfo file.

    :return:
        Returns a :class:`dateutil.tz.tzfile` time zone object.

    .. warning::
        It is generally inadvisable to use this function, and it is only
        provided for API compatibility with earlier versions. This is *not*
        equivalent to ``dateutil.tz.gettz()``, which selects an appropriate
        time zone based on the inputs, favoring system zoneinfo. This is ONLY
        for accessing the dateutil-specific zoneinfo (which may be out of
        date compared to the system zoneinfo).

    .. deprecated:: 2.6
        If you need to use a specific zoneinfofile over the system zoneinfo,
        instantiate a :class:`dateutil.zoneinfo.ZoneInfoFile` object and call
        :func:`dateutil.zoneinfo.ZoneInfoFile.get(name)` instead.

        Use :func:`get_zonefile_instance` to retrieve an instance of the
        dateutil-provided zoneinfo.
    z�zoneinfo.gettz() will be removed in future versions, to use the dateutil-provided zoneinfo files, instantiate a ZoneInfoFile object and use ZoneInfoFile.zones.get() instead. See the documentation for details.r)
rr�DeprecationWarning�len�_CLASS_ZONE_INSTANCE�appendrrr*r4)r$rrrr}s
cCs2tjdt�tt�dkr(tjtt���tdjS)a! Get the zonefile metadata

    See `zonefile_metadata`_

    :returns:
        A dictionary with the database metadata

    .. deprecated:: 2.6
        See deprecation warning in :func:`zoneinfo.gettz`. To get metadata,
        query the attribute ``zoneinfo.ZoneInfoFile.metadata``.
    z�zoneinfo.gettz_db_metadata() will be removed in future versions, to use the dateutil-provided zoneinfo files, ZoneInfoFile object and query the 'metadata' attribute instead. See the documentation for details.r)	rrr8r9r:r;rrr1rrrrr	�s
)F)rr/ZtarfilerZpkgutilr�ior�
contextlibrZdateutil.tzr�__all__rr%rr�hasattrr�objectr�listr:rrr	rrrr�<module>s&
7
&PKa�\�-r+zoneinfo/__pycache__/rebuild.cpython-36.pycnu�[���3

6�cY��@sfddlZddlZddlZddlZddlZddlmZddlmZm	Z	m
Z
ddgdfdd�Zdd�ZdS)	�N)�
check_call)�tar_open�METADATA_FN�ZONEFILENAMEZgzc-sHtj��tjj�d�}tjjt�}�zt|��v}x|D]}|j|��q6W�fdd�|D�}	yt	dd|g|	�Wn,t
k
r�}
zt|
��WYdd}
~
XnXWdQRXttjj|t
�d��}tj||dd	d
�WdQRXtjj|t�}t|d|��6}x.tj|�D] }
tjj||
�}|j||
��qWWdQRXWdtj��XdS)z�Rebuild the internal timezone info in dateutil/zoneinfo/zoneinfo*tar*

    filename is the timezone tarball from ftp.iana.org/tz.

    Zzoneinfocsg|]}tjj�|��qS�)�os�path�join)�.0�n)�tmpdirr�/usr/lib/python3.6/rebuild.py�
<listcomp>szrebuild.<locals>.<listcomp>Zzicz-dN�w�T)�indentZ	sort_keyszw:%s)�tempfileZmkdtemprrr	�dirname�__file__r�extractr�OSError�_print_on_nosuchfile�openr�json�dumpr�listdir�add�shutilZrmtree)�filename�tag�formatZ
zonegroupsZmetadataZzonedirZ	moduledirZtf�nameZ	filepaths�e�f�target�entryZ	entrypathr)rr
�rebuilds*

 r&cCs|jdkrtjd�dS)zdPrint helpful troubleshooting message

    e is an exception raised by subprocess.check_call()

    �zzCould not find zic. Perhaps you need to install libc-bin or some other package that provides it, or it's not in your PATH?N)�errno�logging�error)r"rrr
r*s
r)
r)rrrr�
subprocessrZdateutil.zoneinforrrr&rrrrr
�<module>sPKa�\4����2zoneinfo/__pycache__/__init__.cpython-36.opt-1.pycnu�[���3

6�cY[�@s�ddlZddlZddlmZddlmZddlmZddlm	Z	ddl
mZddd	d
gZdZ
dZejZeed
�sxdd�ZGdd�de�Zdd�ZGdd�de�Ze�Zddd�Zdd�Zdd	�ZdS)�N)�TarFile)�get_data)�BytesIO)�closing)�tzfile�get_zonefile_instance�gettz�gettz_db_metadataZrebuildzdateutil-zoneinfo.tar.gzZMETADATA�__exit__cOsttj||��S)N)rr�open)�args�kwargs�r�/usr/lib/python3.6/__init__.py�tar_opensrc@seZdZdd�ZdS)rcCst|jffS)N)rZ	_filename)�selfrrr�
__reduce__sztzfile.__reduce__N)�__name__�
__module__�__qualname__rrrrrrsrcCsJytttt��Stk
rD}ztjdj|j|j	��dSd}~XnXdS)NzI/O error({0}): {1})
rrr�ZONEFILENAME�IOError�warnings�warn�format�errno�strerror)�errr�getzoneinfofile_streams
rc@s eZdZddd�Zddd�ZdS)�ZoneInfoFileNcs�|dk	r�t|dd����t�fdd��j�D���_t�fdd��j�D��}�jj|�y.�j�jt��}|j�j	d�}t
j|��_Wnt
k
r�d�_YnXWdQRXnt��_d�_dS)N�r)Zfileobj�modec3s:|]2}|j�r|jtkr|jt�j|�|jd�fVqdS))�filenameN)�isfile�name�METADATA_FNr�extractfile)�.0Zzf)�tfrr�	<genexpr>/sz(ZoneInfoFile.__init__.<locals>.<genexpr>c3s0|](}|j�s|j�r|j�j|jfVqdS)N)ZislnkZissymr$�zonesZlinkname)r'Zzl)rrrr)7szUTF-8)r�dictZ
getmembersr*�updater&Z	getmemberr%�read�decode�json�loads�metadata�KeyError)rZzonefile_streamZlinksZ
metadata_jsonZmetadata_strr)rr(r�__init__'szZoneInfoFile.__init__cCs|jj||�S)ak
        Wrapper for :func:`ZoneInfoFile.zones.get`. This is a convenience method
        for retrieving zones from the zone dictionary.

        :param name:
            The name of the zone to retrieve. (Generally IANA zone names)

        :param default:
            The value to return in the event of a missing key.

        .. versionadded:: 2.6.0

        )r*�get)rr$�defaultrrrr4FszZoneInfoFile.get)N)N)rrrr3r4rrrrr&s
rFcCs2|r
d}nttdd�}|dkr.tt��}|t_|S)a%
    This is a convenience function which provides a :class:`ZoneInfoFile`
    instance using the data provided by the ``dateutil`` package. By default, it
    caches a single instance of the ZoneInfoFile object and returns that.

    :param new_instance:
        If ``True``, a new instance of :class:`ZoneInfoFile` is instantiated and
        used as the cached instance for the next call. Otherwise, new instances
        are created only as necessary.

    :return:
        Returns a :class:`ZoneInfoFile` object.

    .. versionadded:: 2.6
    N�_cached_instance)�getattrrrrr6)Znew_instanceZzifrrrr`s
cCs8tjdt�tt�dkr(tjtt���tdjj	|�S)a+
    This retrieves a time zone from the local zoneinfo tarball that is packaged
    with dateutil.

    :param name:
        An IANA-style time zone name, as found in the zoneinfo file.

    :return:
        Returns a :class:`dateutil.tz.tzfile` time zone object.

    .. warning::
        It is generally inadvisable to use this function, and it is only
        provided for API compatibility with earlier versions. This is *not*
        equivalent to ``dateutil.tz.gettz()``, which selects an appropriate
        time zone based on the inputs, favoring system zoneinfo. This is ONLY
        for accessing the dateutil-specific zoneinfo (which may be out of
        date compared to the system zoneinfo).

    .. deprecated:: 2.6
        If you need to use a specific zoneinfofile over the system zoneinfo,
        instantiate a :class:`dateutil.zoneinfo.ZoneInfoFile` object and call
        :func:`dateutil.zoneinfo.ZoneInfoFile.get(name)` instead.

        Use :func:`get_zonefile_instance` to retrieve an instance of the
        dateutil-provided zoneinfo.
    z�zoneinfo.gettz() will be removed in future versions, to use the dateutil-provided zoneinfo files, instantiate a ZoneInfoFile object and use ZoneInfoFile.zones.get() instead. See the documentation for details.r)
rr�DeprecationWarning�len�_CLASS_ZONE_INSTANCE�appendrrr*r4)r$rrrr}s
cCs2tjdt�tt�dkr(tjtt���tdjS)a! Get the zonefile metadata

    See `zonefile_metadata`_

    :returns:
        A dictionary with the database metadata

    .. deprecated:: 2.6
        See deprecation warning in :func:`zoneinfo.gettz`. To get metadata,
        query the attribute ``zoneinfo.ZoneInfoFile.metadata``.
    z�zoneinfo.gettz_db_metadata() will be removed in future versions, to use the dateutil-provided zoneinfo files, ZoneInfoFile object and query the 'metadata' attribute instead. See the documentation for details.r)	rrr8r9r:r;rrr1rrrrr	�s
)F)rr/ZtarfilerZpkgutilr�ior�
contextlibrZdateutil.tzr�__all__rr%rr�hasattrr�objectr�listr:rrr	rrrr�<module>s&
7
&PKa�\�
 �[[zoneinfo/__init__.pynu�[���# -*- coding: utf-8 -*-
import warnings
import json

from tarfile import TarFile
from pkgutil import get_data
from io import BytesIO
from contextlib import closing

from dateutil.tz import tzfile

__all__ = ["get_zonefile_instance", "gettz", "gettz_db_metadata", "rebuild"]

ZONEFILENAME = "dateutil-zoneinfo.tar.gz"
METADATA_FN = 'METADATA'

# python2.6 compatability. Note that TarFile.__exit__ != TarFile.close, but
# it's close enough for python2.6
tar_open = TarFile.open
if not hasattr(TarFile, '__exit__'):
    def tar_open(*args, **kwargs):
        return closing(TarFile.open(*args, **kwargs))


class tzfile(tzfile):
    def __reduce__(self):
        return (gettz, (self._filename,))


def getzoneinfofile_stream():
    try:
        return BytesIO(get_data(__name__, ZONEFILENAME))
    except IOError as e:  # TODO  switch to FileNotFoundError?
        warnings.warn("I/O error({0}): {1}".format(e.errno, e.strerror))
        return None


class ZoneInfoFile(object):
    def __init__(self, zonefile_stream=None):
        if zonefile_stream is not None:
            with tar_open(fileobj=zonefile_stream, mode='r') as tf:
                # dict comprehension does not work on python2.6
                # TODO: get back to the nicer syntax when we ditch python2.6
                # self.zones = {zf.name: tzfile(tf.extractfile(zf),
                #               filename = zf.name)
                #              for zf in tf.getmembers() if zf.isfile()}
                self.zones = dict((zf.name, tzfile(tf.extractfile(zf),
                                                   filename=zf.name))
                                  for zf in tf.getmembers()
                                  if zf.isfile() and zf.name != METADATA_FN)
                # deal with links: They'll point to their parent object. Less
                # waste of memory
                # links = {zl.name: self.zones[zl.linkname]
                #        for zl in tf.getmembers() if zl.islnk() or zl.issym()}
                links = dict((zl.name, self.zones[zl.linkname])
                             for zl in tf.getmembers() if
                             zl.islnk() or zl.issym())
                self.zones.update(links)
                try:
                    metadata_json = tf.extractfile(tf.getmember(METADATA_FN))
                    metadata_str = metadata_json.read().decode('UTF-8')
                    self.metadata = json.loads(metadata_str)
                except KeyError:
                    # no metadata in tar file
                    self.metadata = None
        else:
            self.zones = dict()
            self.metadata = None

    def get(self, name, default=None):
        """
        Wrapper for :func:`ZoneInfoFile.zones.get`. This is a convenience method
        for retrieving zones from the zone dictionary.

        :param name:
            The name of the zone to retrieve. (Generally IANA zone names)

        :param default:
            The value to return in the event of a missing key.

        .. versionadded:: 2.6.0

        """
        return self.zones.get(name, default)


# The current API has gettz as a module function, although in fact it taps into
# a stateful class. So as a workaround for now, without changing the API, we
# will create a new "global" class instance the first time a user requests a
# timezone. Ugly, but adheres to the api.
#
# TODO: Remove after deprecation period.
_CLASS_ZONE_INSTANCE = list()


def get_zonefile_instance(new_instance=False):
    """
    This is a convenience function which provides a :class:`ZoneInfoFile`
    instance using the data provided by the ``dateutil`` package. By default, it
    caches a single instance of the ZoneInfoFile object and returns that.

    :param new_instance:
        If ``True``, a new instance of :class:`ZoneInfoFile` is instantiated and
        used as the cached instance for the next call. Otherwise, new instances
        are created only as necessary.

    :return:
        Returns a :class:`ZoneInfoFile` object.

    .. versionadded:: 2.6
    """
    if new_instance:
        zif = None
    else:
        zif = getattr(get_zonefile_instance, '_cached_instance', None)

    if zif is None:
        zif = ZoneInfoFile(getzoneinfofile_stream())

        get_zonefile_instance._cached_instance = zif

    return zif


def gettz(name):
    """
    This retrieves a time zone from the local zoneinfo tarball that is packaged
    with dateutil.

    :param name:
        An IANA-style time zone name, as found in the zoneinfo file.

    :return:
        Returns a :class:`dateutil.tz.tzfile` time zone object.

    .. warning::
        It is generally inadvisable to use this function, and it is only
        provided for API compatibility with earlier versions. This is *not*
        equivalent to ``dateutil.tz.gettz()``, which selects an appropriate
        time zone based on the inputs, favoring system zoneinfo. This is ONLY
        for accessing the dateutil-specific zoneinfo (which may be out of
        date compared to the system zoneinfo).

    .. deprecated:: 2.6
        If you need to use a specific zoneinfofile over the system zoneinfo,
        instantiate a :class:`dateutil.zoneinfo.ZoneInfoFile` object and call
        :func:`dateutil.zoneinfo.ZoneInfoFile.get(name)` instead.

        Use :func:`get_zonefile_instance` to retrieve an instance of the
        dateutil-provided zoneinfo.
    """
    warnings.warn("zoneinfo.gettz() will be removed in future versions, "
                  "to use the dateutil-provided zoneinfo files, instantiate a "
                  "ZoneInfoFile object and use ZoneInfoFile.zones.get() "
                  "instead. See the documentation for details.",
                  DeprecationWarning)

    if len(_CLASS_ZONE_INSTANCE) == 0:
        _CLASS_ZONE_INSTANCE.append(ZoneInfoFile(getzoneinfofile_stream()))
    return _CLASS_ZONE_INSTANCE[0].zones.get(name)


def gettz_db_metadata():
    """ Get the zonefile metadata

    See `zonefile_metadata`_

    :returns:
        A dictionary with the database metadata

    .. deprecated:: 2.6
        See deprecation warning in :func:`zoneinfo.gettz`. To get metadata,
        query the attribute ``zoneinfo.ZoneInfoFile.metadata``.
    """
    warnings.warn("zoneinfo.gettz_db_metadata() will be removed in future "
                  "versions, to use the dateutil-provided zoneinfo files, "
                  "ZoneInfoFile object and query the 'metadata' attribute "
                  "instead. See the documentation for details.",
                  DeprecationWarning)

    if len(_CLASS_ZONE_INSTANCE) == 0:
        _CLASS_ZONE_INSTANCE.append(ZoneInfoFile(getzoneinfofile_stream()))
    return _CLASS_ZONE_INSTANCE[0].metadata
PKa�\����!zoneinfo/dateutil-zoneinfo.tar.gznu�[�����!8Y�dateutil-zoneinfo.tar�]`�֝jhHoCMB˦o�!$�.z�@B%!��GAEA�
Ei�)�A�ҋ+
D�"�{�4��f��3�IHv�;�{�ʹ
�hܴqDc��Lt��c��7ᵷx�M�@����;��c
���}|�M�b���m�Є�xE���F����?�O>$�~�'�Qn
�*�N���L��H�2vp\床OS-���ёC���?���
��+�ԡu���G��%����oX�:���F�*��&��#�\'62.����.�G�ī2��G��?߫o�h��/}h��CǭN���O~c���"��}��}�MA��ޑ�}�}�������5��1��������? 2�wT@ ���k
�����l��6����������MϽ�{�����sAf>�ёf?ST�)Ќo��	���������/귿�[����?x�:��]�7>�Od�G��O�����k���v�jt�w��'���_3t�?|_���7�O\���߄>�	��#�&DJ|�G�I?"�[�#������G�Ge��1R���޺8�Y��?�z�O�xg��Et������.�̯s���O�s��s�z�{��F`r�&`�:�n�!���k"��;����d�?�_$����5z�٫��
���S���97�b�N�t�82�yR�6��"�ByP��>��Q�ԏ+�X�-,m+��D���y�[K�)�Z�|!{��2�޵��l8�-��,?�g�)C�GG9�����7sVn�R��Y�Vig�rn���:�s���7J�gJj�I�i���Qk|uA����Zk�n����j�	+U�C5EMU�{lv���p�6���k7��_^s�ts���4�MR�'�:��vU�n��w��ZQ��`S���jj���j�Gm<���I�Ojp�Φ�v�!�g�\���*_8C/�p��.t��Y�l��Dg�o:[�Z��zk�3�ey��kל9r�ʝ'o��r�w����
>��_��dV	��BϤ�ޓ\��p�n4å�$�-.t�j��⏶�Y]JKR9E*���5L.��o�d~_*޲U�Ԋ��є��7�G���_
	������K.��O?��<_���C�u\�����#�9Fw@{�<�y2�8�Xd���1���Hc���'#�Q��<Ny�2�xҘe�q��c���/#�aFnj<�y<3�f�q��c���7�&�qF�<�y�3�Ҹg����H`d02���	F�#s�E�`d�02O�+��F�#�H�ad��C��#F�#�9�ȼbdn12��c��3F�#�9�ȼcd�12���AF�!����|ddN22/����O�LP7��ھ�F�z�˕�ȁY���]z���+��#9���?��em�����	�>���Gd���_�v����0b����7��O��a��Gd)�������_��?ƃo�dl��DS��3���<��>?��c��W�[k����/����}���'�߷/�=ٱ�Kokڸ˶����w4�a�f�fݹs�mיϭ��\p���z`~����փ-:y���y�q$_��3lGjd?ve������m'׼m���F۵�O�7��R�l��O.��sh��-޳��h��ښ;�]5O�b-��aR�ҋ�|��:ܜy��=�G�Z.�Z4�ZxBY�<q��h���ZH/��L-^�V½{jI�ϴRy���<�Z�Ĵ�r����,n�ku�|�5�7�;�G�*�}G�\;��*�ɡ���ᮟ��{���?,�[��Dn��3���'�����m��d��z�N���F���[刖�z�����
��o��N{�X9]�����s�>ʱ���7��\�T�U�~�(M΋4����u���sx��,���&?z�>�]�Re��ih2�M/c�adڠ�E�}�B�L#���J(O��R(S��Z@�#S��i��T��r�L;F�#ӏ�)��4dd*22���LKF�&#ӓ�)
$�22U���LYF�-#S�����f��FT�.':32��֌LmF�7#S��i�+�;�(�*ў��$�3�0�0�0�0�$0�,�eB��	I"Pte8�
�I.�$(�l�,H��l˂�ԧ*���/�Y�DYp�.ʂ�ɢ,xVe�����Y�?�EY�3�K!z$��M�$2�,2�42�<2�D�2b(^�T2�\I2�f#ٔ����V���0���������D��㣳0����������xd�V8�M��OcZ�n?ھYsƶsj����9KL���%�k�\�s呤����L*�[城Q���H��$����TJ�TM*ǚҾKI ?|L����A�0���9ߣ�9��~#F���Y`���$�g�)�υ O�Mz^��ܰ��9)f�6-����m��}�����,���ƶ��3靳%n�vw�n��q��[g���w��kҹ"-�ӽԤ�s?�;_�]��]��t��~���H�<��~N�!I��^).F�<��^�u���rə��4l���ϴ��L�)�K&W2"��Ѣi��d�U�?!#J�}RF������S3�'g�O��{H{�����#�F�+��gy�0�BJ@{	)�)����<�=�F_��m�I�vm�������f����j	��/;�k�#�h��}�d��`He�P�Ϝ��&��W=Z��v���c�K��v�']���H�S��[�:F�*}?}��t���;�^�Θ�l�!ҹ���9j�׏8��t�`������9/ݼ']~�+畣^�s�-5Ͻ�R�K���NN��lq9>O+qRu���TwI�Ο�<Z&�d��wX&�3d2�1�|�V���V�8K1�DX�����HT�hg��F;7ک��юEōv.*m�����Qq����lT�����;��w>#F>kt �` ��Ax����F��  $F>Pot���!��ACx���F�� �DT��@½��s��`D��,*qtp�g~t�����_��up|°�g:����?�?����o`��� ��S�e��Q~f�A��۵Y�.��w�W猋W�~��i�P�q^���� n���J�Gm�;?�uE��緜�w|�\�q�J���<)�s����jeuM�k�ZkNu�OK5�p���p����'��
�-)��[�R?{�ug�N��I�_���sk�W�r�_�M�mu�;�w^�n?�����K�qUQ�9�۹s];�΋���]'�;w����e۞���=_��V¹wY���n���<u_�-�)�>}�_������u΃A��C�_(�K�Q��[����r�ʉ�]���'��3�{���x���}|�q�w��C�ƏM�g|
g+�7Ε�T��Q���W~:O9�r�S��O�*�>IU.�J��|�9�]�j�	ʵ>+���
����
�W�_�5n�2n�v0n]ofXZC*8��T�R�	�����*M1��^,������x�z�b'���׷�~�b�>`�e����ݼE.�l�\~�\��]�8�eY/W��G��2B�R?D�Z+@�V�]�^���+Xw��{���{,��:�^s�-��Ÿ��ӎ�u&�Խ6릨�w���O�Zٷ�&ٯ�tٿ�l9�'I�?N6����OF�Aw��[��z�;���l��7��Xo4��n�[Eo<!Hn�,�UVnZ�|_��>�[S�?�c��c��D�s�fr��E�.7<��ֻt��E�k/�=�]�{M�#�z�#ǜ�{7� ��K�����`��7�:=���Ǥ��ݏ�c�F�OF�w�n"z�����<�_E]��/i[_��[R�]AN�-+"ɉ^�D�i9��M=��<��Q}d�"yԞM����Ǭ����P��8]�ŧ�������ϓ�|n���Ç7��'��|T�˼]Nq)��pYM<�;%2��N܏���!��#��-��E�2{8?toI�$��,�X�@b��	$�X�@���	$�X�@∮/	$��$��P��Kb��.	&�D�����œ���E�����Ŕ���E������H��"��B��b�Ȃ�Ȣ�)	/#�/#0�,�0#1#�1#2#�2���hg�U�-Y�Qp%��X�;M�
<!�7�ě�H"��B$1gdA����M�$q��&��*�=<8�=<8	��zd�]�)���D xn
���)(�sS`����M���<7
xn
�s�rЀצ����M���<7xn
&��P�)��sS`���.<t�)�0r�a�`��<t�)�0r�a����.���"P����³sP���*���K���
�t
R��~�Jt�w����:.t�)x1rC������]�`&��,��/ˢ�/��zYt�#d�]�Ew=@�uw <�]�Ew�O�j@�H�(��-]t�r@����o�Ew}�.��Ge�]_+��&Ytקˢ�>[�$�8Ew}�.�둲�'ꢻ,��zg]t�{颻^W�ƺ讗�Ew��.��A�9��S��s��ߗ�+]u
���N����3w�9�)�3r0g���A��;#wF��9У�C���>#}F����0�	�`d3�Ȇ��M#F6�l�$0�Q@�Jf��
#�F6�l����`d$#��fH���M#F6�l0�d0��`�6�l��7��'j���_���]������^��`d\T���}|��8��_���%�_��]�c��k���c�YGW����l��f�Ƈ�y�[�EcF��Oɻε�w/)��,�}�O�kKl�	�J��{G��&ہ��o[T��\.�\+�UF>�o�|4��џ���R�յ�O����7]���t��k�K�,�.��t�ۮ�s�p���ҵ�]���*H?׭'�SW��Ly�`��j���'sd7
�|}/j��[l���J^O�J�0O+}��̗㵲�W��0�VL%K�
ى�d%��Ft�*;��Γ_�<�xs�̛;�k�/�C�������:���N�
N��4��6߮a�y��R?z~�U�Va'8$�t�_'�=6�)X�����l�4^f��ӗ�!Qb@�K*�ė�@�ʟdE@�K���̤��L����:R
$r�H�H1��H�H9���z q#A�F*�č�D$nk��("q�.��ʟ�"qK�kV �+R$V�6H�HqDb�F��B�� �AbE
$��@V"$V�FH�H��X�*!�"eBbE�ĉ
H*�t	����Ȥ`"�ʘ�LJ&(1�M$P����&��H�VJ"�B~�	�+�H�D�c�	�8Y�_v"��He'R�&��G�*����-'z�yeO�_��_�����,�\30��2�uw��;Ҿ9��Y���b�8U�O��V��\���V
������.U���鑧�䱿�3����$҇!�:WXTMʋ�M����#�>�#���	�I4��p��G��>�Χ�N��ݡ�C6�>l��X��6�> l}H }P���@������mJ��������~>O���>��3�oN�Ḱ9���s7�ь���y��͏~�/��[Z����H�9��������R�M�D���4�v�����ҝ[��靥{G:���JR�䇋�I�ee�I���ˮC�h9#K빬��ܖ�z�)-ϛ�z>9U˷|��术�w���L*�:^/�q�Tx�!����L~E.:"Z*%��%T*�L.�)���KU�J�s���p��\���=�O+�?�^��Z�U��vkJby���+���U��/Wk�B�^�Kٽ�.�?�N�t��<O}��8!�ܺ@�u@�j�yU�����56F7��y�L�}���|C��~�ni��ar��1-0O
�\��d>W@�{T���\�&�~���`�l����F3�I��{��fjM�$�Qc��^��!M{i!׿�Ck��B|,��)���,7�d�Z�Hoy���j�$����Z�u�����Bo��Ck_����G-�^a���6��Zr�
?H��.$wy��u�S�v�c����r�����Qk�^sH�Vv=r�$�w��z��X-��4=:��})Q�q�������)��.���?{U0��<�^H�$ǭtJ�;��շ�KC�����JC�''��.%<��'�Wk��N�I��iI[?�G�J�FΙ��:�Y=v�>&��6�g�>�rگ���	1��Ç��q�Yj��m]ʋ�x�q����i�Dk�)��S�o�#�el=s�Y����#Qo!V��B����53
��@b*��V�S��@b-��\4z����`Ff1����lfdF32��l�1����ȇ��|c�#�AQYb������J����B*$%@�$5@!�!�aV�SRE>��z
)�)�����a�X�Ȋ�z
��)�"f�@�S�ì"����0�	��R�SHYPO!u��X%�aVRRRRRRR �Oj࿁�~Bj$EB�]�L���:��B
�:
��(cŚV+�QH�PG!�B��K�Qn�5+����kV2QG���NJ&�(G�M�Q6�5+�����kV:QG�׬x��2�?+�����kV@�QH������IQ?!U�2��B�:
)$�(�����R��Z��B��lh:9J�����z��B
�hI*
$%E���H���	�*��uRW�QHaQG!�E��uR[�Q�D��UuR^�QH}QG!F�Tu���~�j�$�W��ݢ~��\.�W�Ҩ��R��Bj�:J��_�j���Q��u�WVq�Q����9��+�:�XF���*�W���|e�Ge��+�>�qOQ�b���w�ߍ��/s�U�:�Ϸ/ܺk���Y�M�O�M��_��r�6B�c�7�+uߑo�G�+��Ϲ�(p�sG����R8
�Lu���(�p��hR��X�	��:�;^z��Q�\�Q��x[�Ja�Rۣme\j��|j+�}[�I���mb��*v��쒭���Vٔ�Q%v��j��ju\l�s4q����~������6�/r;j��Vsi[��m���e����W�s6ӠV6��;l>c�5��Z8��޴�������Ka������Wu�r������m
�8m
�z;��o�tomk�s��I}�-��t[�rEm!�l!w�5{��z�UGة����1��[+�Zlw��C>�����Ӷ6�:�}8��j��5s8�[
�"���P�c��Ng'::���e[?G�Ϧٺ�|��}q����1������58�f��lS��;����WA[���]芭o�����;b�����W���^ǀ件�3V9�'mq��uV?���dې.��wlC��8�۰�s�RG[���f[��>��el#7�8F-	p����6fr)��W�����pə�5K���eM�Z�ywR�5-���Ϭ�5�}����׏�}�Y������G�=��n���d�0�D �F��#Jt�%J��-`D�0�DQ��(�F��#Jt�%��60�D �F�($����D'Q��(�
F��#J�%����`D�j0�D7Q��(�F��#J�%
���taD��0�DIQ�%�(QF��	#J�%�B=��0�DWQ�,�(�F��#J�%
��0�DeQ�3�(QF�h
#JԆ%zÈ�aD��0�DuQ�;�(QF�h#Jԇ%�À�I��#)��)�+K��aq\Y`D7���#:CW�
Q�Q�Q�8�,0�q\YB�Ы(�+K	�8�,)0�߉���#J�#J#J2#JR#Jr#J�#J�#J�#J�#J#J2JR����$	F�d	
=�&�}�4�,Q0�$S0�$U0�$W0�$Y0�$[0�$]0�$_0�$a0�$c0�$e��$g0�$i@�5F�6Q�7Q�8Q�9Q�:Q�;Q�<Q�=Q�>�����;
k{���ojX�Uo�V�V~l?�|i;��ϸ���ǟ�}�~��
�^����?Oƃo�2����O^�:}U�I�W'��&��mm���U�n[o^�o��[J�7��\�ڱ�֠~��ر�H�~�HwlY�K��/�q|�֑�����}����_����U��u����Z�i�^Ȗ�Vk�-��~��}h��5����|��=���I���ce7q���ũ����R��9D�3���]����>��(8��IZ.�*@�$V-�
���U���tfLQ\�h��TŪ@W1��)$�bU Q�G#�22��J�h�U�De�$:c� Q���X%H��*A�7V	űJ�h�U�Du�$�cu Q�y�=��/r�-ٹVv���k�s�����W)!�/e�b�fa�%k��g��3��|B׿t��I�����F�E�?����_�}|����O��?_��O���>Z�����X߷�mC�~[J�[��ίO%۶����pձ�I���{7t�����x�x�wL��34���Y�kw^�w�+��R��eӝ�����8��ȩ�[�����{Z�Mo9�}Jk4SuZ�j�'��6i3_��6����4m�6+�W�꫆�/��,������pSm�*��]���}O����6I�%��ζ��Z������"Z�tvP.hk�qv�vk���vv�Ժ��vM��u;�S�d��c�E�9Y�z�WY���K�c:{�GH}z*�(�)�agߢ��?:c��i��os��/��?��9`�-mද�AS�iq�>V٬�'�C���P���$%4k�+3[J�u&�'%n�L:)��R�9��`i�����zicV\u��X��������?�j�Ç
p�1[�rr7�;����MϢ��^�Y���NsXe�ixx�'4Đ��0C�BC
9

7 
9�4�K����^~@�XHF�HCgˣሳ�ѐ_%1�%�*&�t��ė�RW_v�b⋘��CxVLh�L�x��,)c1��-���"&4�_Ą&�b⋘��C\L|� &��P�����KCxKLh�<"&41�SĄ&��}1��)�$�15�#ń&�<pc1�����	MLx_ILhb�bBS�hLT�^"&41��'�	ML-x�X1��).FS
�S��f����z�kbBSx����T�^%&41%ၧ�	MLMx`�'<0Q�����T��+&41eʈ	ML]�1��)$���?�-���Ą&�6<0��ŧ8OQf�
��"�� ��W�_�����g��3=Q��
0e_�-+�_泤�����o�!�#S�:yA�S��QT��~�S�oV8A��X�5U�YE?2Tn�c.�EJ��������sRP+-[���`毷�FA����
^�����P�:�w.�X��آw���5u����@����r�u�����Ƚ�3i�XM�ۊ�Po�OO/
>M��E(�����)�4��?HA����i����m�AS��E�C��Չ3�!]���}GhC���uӆ�Y*'z%Q�xSN*ܕ��`yĕ��ʣ�V��0H���A}�[���@��)�[��g�}x[�2&0��3Gk{1������(�z~�4jMظ���b4�Nظ��e��Ɖp�#Zظ*��qC�e���u�i�(ց/g%�/l�YI�8��u�i��q%3ց"	w;c�Iظ���eԘ�ƽ�	77c�@Mظ�b�2�Eظ9b�2�F�8M�'��[��)*M�$a�H���2ց_���k����$l\Ռu��&l�Mظ�u��4a��X>C6�\�:���q;�eb��qK3ց'	;G�6N�Ǚ���՗��k+ց[��$�/��)����`�oӐ���?����L.�g�?�~��}���(�oz�v)�~і�hCp�s}�(uCYYJq�F��M
�>?�T=\����������{���x��gC��状���k���|��y
���/�u�Wݔ/m�/_�zT��Xi8�[.�:�(�q�\x�
E�`�\d��1T.��ԥ�\<<B)(��PJUn���WJ)��_/s��({��^n	���
�n�וĚJ����;T��?&W���Tk�Y�^|��^c�����ɞ��5��kn]e�:0V�=�]����5v�az�����3�������ϭ��wT|��<f�\.�l>WF	�{N���R��~r)����r÷��f�)[�0OX�7i���zCo�e!M��
�b�Vm��ޚ�����Ï��4����b���z����׷��tnX������b�K������������;���t�pU�u9�˃rׅ�n����'8�[g�=��Pz�!�Z�2"'�����j��G�oD�vѣ/M0b���1���y���Ì�g��G+���A��J�������C�_���<��%%��B9�a>#ќ�'��`$���'m�m��5A9g�1�H_}�ةƘ�0}lϡƸ�k�(s�-_��Ç�-�RL���\�gDV��EV��V���N��X�#���5�Ȱǽ�/X��ly�Sxdq!f�1�Ox�7���rq���\T�H�|�X��3q�ab'N>L�ɇ���m�9���@b,΍E�sq�ab/ΑE�9���8G�Tqn&f3�i�1M�X�i�lL� vc���3�1Mc���vL��"<0��3��f�cz)#��g����4N̪�i���i�f��4���f��4
RL� �4����z`zF
�YE0=�Mx`VL�8/<0�
�i��`���i��U�]�YmDn#<0�r�������Fx`V!�4�D"�)���Fx`V%�6Džfu���R"���J�6Kt��l5Dn�.r����b"���L�6޺�m^VDnS�Yݐې����!�!�CnCj�܆�
�rR>�6�~�d��@RA�6��@RC�4��@RE�6���mH�ېB"�!�DnCJ�܆��
)&rRM�6���mH=�ې�"�!EnCJ
$5ENC�
$UENC�
$uEnC
�܆T�
)-rR[�6���mHu�ې�"�!�EnC
�܆T�
)1��9
)2�T9
)3���
)4r�9�����m�
��b#�!�Fn�?��n�E�5K�g>�[���#"����x>��3�g��ϙ�@ ��.�޵ϫ�ܴJ>Ue�����g��g��r\h��Y�&��yo�%��t�:_�Y�x/[�]+�e��h+�v���ܒ�
��W+�r٦���J�c���U�4uuT���V-�Vݲ����ͷi�����a����6��.v��]�X�M��?2����UHg���t~����2�3����
\�.�$���*�;@�C�K�Ek���K^Ѫ�=C{
>����.�(�� >�E�ړ�/�7�_^�y�⏦=�B{���0���h����
A{���:��y�]���tw��Qp��}�KN��bxd�ȁѱqY��&߀'�蛭�/���fl�'���J؜JL��Y���fu��5�J�:Do����A�+��Ѷ��Y�J�j5���8ѯ�����G^���2�ݚG��q�w�������A��/c�<ܰ�~�b	����ѝ���y��Ǘ�N�}(�|c���Y.��ܜS��#ǹ.�7�^�H�\��p{�GdV��/��Q@����J�Ӽ���~�G���菅u�?X�[�[�K�7��'2K�����l�� �/�9��[x��<o�V��m��Os�9'��;^U��(���8�Qx�x��A_G���΢#��bC�/u��(��,T�Q�3��TeO[鼗�er䷹��*N�Ӝ�s�|D��lOuAxoA�b��_��J�����Te#2~�?d�>!�>%�>��g���z�XNȟZԳ�rB��-��^��0��g�:E=��CԳ=E>H{FԳ�;E=[,'�$��m�gW��gx=P�J����������s���N���]��?��ZZ�Վ]g>��^�@ڳ�g�޷�:�KF�M�9���C=��};�a?�%���*��Z����qLNw���q|��tb��8�xS:�v�����4����H��6���g�q�M�L���	�����J��m�yG���{?ٞ��6�E��r[o9�O�j��롭�����*[��u��=�8�(=�U��lդF��/9�:kw�����j�����ƒ������&��k�u����5��a
���6��S?�����W�ݿ�{6�����9�j�{]T�/����u��z+���/0��j[�񯨍F�uX����mMZ�-��Q��"�T��٬@{���>�Ћ�Rعj���R󭳜-�ޖZN��l�^q����j�����g'�^��~����5�/��:�*�v�y�ֹ����Z���]�kݾ���>�&�X���sL�״UN[��R�=j���>=�ըr�Rt�wԾ�sj1�Ԙ3g�~�;��_�i�O��}�
����-nQ�spt��N,��
)>��sh�ARB�	�Bm��:�����RR��jҞb҈�[ԑ�oH���UG�(��Y�:6�6�>�K&�ʙ�=I�����P��W�(�H$�lq��;�}�'�o����;�#�<~U�/����%,x'>�jH�)\
�x��!��x�mq�Z���D<WA�!._K|�U��s���; qv��;L�"�!��[L|��U�y��&q��%~�2�o���2O�I&���L|E'�8�J'��d�.:��_�I~(��D<�}�\�i��O�k�ۨt�Q�$���I<�#���I|G��8�J'��ήbA9���ba4�:���h�tjIЩ%]@����tjI#Щ%�@����Oz�N-i*�����v��J��N-i�t�Z� �	:���١�+�Ԓ��SK��N-i:��Xh�Z�N�h��5�Z�p.�=�Ԓ��SK�N-�:��E@�#tj/���K��J���	�B�(�H�Щ}!Ab�B��4cҭ�*Ƥ_�Ԓ��7�c��e�В�I�С-.k:�7�#b�C��[�X�Щ%�C��4�Z�=tjI�Щ%�C����%� :����В2�&�CK�$mdd}D��4�Z�ItjI+ѩ%�D��4�Z�MtjI;ѩ%�D��4�Z�QtjIKѡ%=�� ME��tHڊ-�+�4�Z�YtjIkѩ%�E�vZ4�.:����Ԓ�J���F��	Z�:~^>ٓW��-<�����t������{zg��2��|���r,&���xѴB��N�m�߲��Ku-E:Ĥ
i�R,�b�K���x(�i�g�xVck唚��a��v4�~�5��69�kp`�)r����?ͧ�3���J�_�a)�/U	Ƚ�p�cZ�)�C����u7���=s���5����pTbX�A�̖�K���JiҨNZ��ڔ��;���1��:���o�-����<)�&�k=���M��4k����-��kp=�}�ya��
~��Q���JްN߿e��Ͱ._3w]����f)��9��đ����z�,O�uZ���'���֧f_sT�bi�>H����ns��]a���̱[��_�j��7l�;̓^�7�b�����󐐊a���Vo��P�Hʰ<Æ�)`NLߘ6�x����
�Fl�*e��Qsn�G��Q��f�ظ�a�"{�%�9I�s=�;�n3Ƹ����̕�fV>Չ��W^j����Y�#��b�5ѳ?=���k�^f���!�.4Qv����
H 
J�_h`��B���(�� ����
��
H&�-L 
\�@�0�4�ai��@ƾ��H&�5L 
l�@�04�y�i���`�	�H�&�>L 
~�@"L �&��Hd�	$B�)`�0�D�<"L����Gd��#��i`�80yD�<"L�&���Gd��#B��`�X0wD. ��I�GD��#����`�t0yD<�<"L&�H�GD��#2��!a�0yDL&"'�
�G$��#���Ya�0yDZ�<".L�&��G$��#"���a��0yDj�<"6L�q�$������0yDx�<"=L&���G�G"�GB���Y���{���k���hX����e���'��+��=3��'z`d\TV�??�'�?�/+�_�VH�6�?o����V�f�{M��V�{�U6ڿ*�[�/��-ܘ okUF��]�~�d��Ǝ/�+;sW3v.kb�:�[�=���g�Je�܆}�Te_�tc��ˍ5�1��~�8�O92�8\z�r�Z{���c�T������3%��('��)��3�[QBq�����[���A���)?6)k�i�Y9[�q.�����S�O����S�2˸��)�⡱ƥOR���mƕ��+��M���'(��R��7��{5Vn��b�Ҩ�r�X�q�b.��f���;<���ƽ�!�c�wt���>� *_C檓�7�,�ĬW�M�Rh+щ�����A��`�2�S�e���0I����ˊ�ƔG:ȸ|h l�}�8��IHgᡃ��%*4�4P��'
<iP��IO(x���A��'
<i���4`p�w4(|�A����^� �@B��(|v�kT(|�B�
�4�P��A��'
4>i���I�Ot(|�C�
�4qyy�@�XBC�SBi@b	

Jq��T������e構���������Ӏ�e�i��2�4pq�y���
`\΍1�2.�F��s�-.��
|a������-lp\�zdm�b�'mf�,���O��,c��Wc����|��o��]��E���eo�@�
�o�m��`�d�7.>ܰqʑ:U��r�P��ǎ�M9~)}�)'w���2��u�p�|�����ĚH\��W�^��-\�|�ђ��n���T��?��r���R
�\����K3��\N�qe�����W;�I������n��_Q��j�/�?{ܬ6�|�x���\6���w�41�=�k�==S�om���
K��9UKoUNq�kq���)�=�-���lJ�М�]�y����3��9_�4�|�l7����#��%�ۦx�d.:x�b�g��;��P�_/���
�mVɰ��יh�f��|(Ź�:��j�tH��"�ҡE��ËhK�і3�-j1��1~����A)"��^,�mY��!�hK�і����e��@��a�hKCі��-
D[&��4Tmi� �ҐҰA�����hKCі��-
%D[N��4�miX!���B���hKCі��-
5D[n��4�mi�!���C����!�hK�і�"�-
G\<��$.���6��&���(��<Ly�b�
Wp��}4lQJ����*
a�fݎ�<�1�鐨D�FŌ�5*fY?����r��-4>::nxl�~Y���'�f����"=Z���Y�£?��=��y�wC�A��1�OG!���p�w__�@I�~���?�ڦ���e��t�k����'��?��ߤvHl|tV�@o�'���w������x��z�6�?3�/7fʥ��k2f/�Ҙ3k�1wF�x�Se^�=c~�,e��4ca��Fw�E�l���۔�5j)�/�2>��,�,�ɩ,�>PY�c������Jc��<ɤ�z�n�V[k�Wk�u�u�]��&���h��fl,���x�[�ӟ$eӑ���㝔-)������NI�YV�<i����ʗ�G(_�]h|m�l������!c��|�7%�������WA�5���{���u���u{\O}_|	y�]y��@O��p�r�B%�`�������˔C\�#u�R~�M]�(zS;�('��m�Z{^��2��3NHP~hW�1B7�0�6X��+멤�a��ͯ�t�r��%�����O�*���1.�J��r��;F�n�7ռ���T���7%]�)�>ћJ]#zS����oR]�mJN��J.�b%w��J��J���)��J�������u��ݤ�z�(�\T)<�!P�(�6�(:B6�y�7^�|�(^�^¼M/�[/Uj�^ꇕz�[��e������c�ܲr��'���r�yde`�\��Vr�r�H/�j��Z�z��d��u�~��[a��`	��OW��ko�v�kO;��Y�N�Jج�&��M�J�=��>�ke��d�v�e����$9�8�\v�n>)�M��n	����_�Ko����pbc���r��o�� �I�\zpTY�i�szH�}�Y�zh�����g�p����=ir��-V|"�����)r�e��6qq�u�x�m��v��������z������<��7Mz����·��]nx�]��w;�&w7��=�^�{��.���G��:(G�9��n�A��c�U�9��
�o�uzLy]�I�����Ǧ�����,��6D�Z=nQ{yp���:�_Ҷ�߷�<Ի��r[VD������rR��z��+y����E�=���|��Y1[;b�>�q�_��z���'s�~��\���=Ͽ��߻�%Y�
��'L9v)���|�}~�T���W�4������B;~����ez����Z
<$�r��hÒ���Gڊ6,�+ڰ��hÒ�2��2�ޢK��3��2��2��2�I�Y���nj�Ɍ�ˌ�͌��8!i4.8I:�N�Vん�׸�$i6.8I��N�v㌅��8c!i8�XH:�M��I�q�I�tq�ɫ@�v\p���$��'I�q�I�z\p���$��'I�q�I�~\$��mj�hOSm�|@�@�	(����96�=M��i�hOS�@{�b��/�3P8����9��)~�pN1D����8���N��@�_9��aۚb�cmk�5(�S��u�?޶�؃B:��)��Nq�t�E(�S<B!�b
������B:�(�)N��N�
�t�W(�S�B!��
��PH���B:Ű����k[SL{�mM��5Ÿ����k[S�C!��
��P ���9�@��3r,�$��1�&�ȱr��(�S�d�8	!�X���c&
�m�9v2r�d���q��c)#�SF��@���[9�2r�e�8�ȱ���-#�\F���{9�2rf�8�ȱ���1#�d �eF��@�ό�9N3r�f�x��1���6,1�n�9��c8#�qF���9�3r\Rlg����q��c=#�{F����9�3r�gd��>���#�F��+C�]3�ȑ��#0�O�W`d��Ȟ��}#{F���!�G0��`d?�Ȟ��|#{F�@���3���f���C�ɒ<#�F���?ك0�ad/��~��=	#�F�&��O٣0�O���8K�8�%yF�-��]ٿ0��ad��^���#{F�5��m�� #���>H^����<#�F�>���1�B;��#�!)���5}�^��_��坽�ů�<�����>����?���?��������'�ށ>���,����x��l�K���f��C��<m��i����m�~��C��ȇky(ٵ��Z��ZV}=��~�+���M����}^�'��������ޝ�\?�S��iފ|�r��Q2��>�M.6o�ٿ6m%�%���J�f���6����)T��#U�\���턨쭙**{��<���jv���+|���+p����Jʟ]qˮ�eWܲ+n���\q˶-�mۂ�[�_���ČP�6��
x�>����?�Ys�el�?�ݵ��;��;�]q|�=ݾs�
ۮ�<�}�x�\�˭�}l�?׶�Ͽ�v���~����u��K{�9/ϸ&]I^�:GTӮN=�ֵ�t}h��zS�檿T(����0D�]*�z��o�;���w����;��y��W����'���9՜.1?i9�uQ]��K9#O��jΗrq�)pP�[5D�{9��+�鶷����}g�U�kwx��޹!�$�)'xhE�x_-ڡ�T,���R�R�6Vg��/i%�w�%�I�����Gie~��,�U��T��s��
�8+j1�2�Z)r�Tydw�JSE���]�V��V����{�I�G�_��>�jH��5�i��~�Zk�P����u�,Ҽ�bӀv�q7>�/�}{v�հ�mt���z�^�k
ʛb:��Z7�C[�5�Z맍�5xw���➶FC;Y-SG:wjo2��#�~{Ӷ
!E�[�y+�f��ְ"9a��Ý?:�����☋�e�{�ɝ-ޱ�fv�_6���f[D�W����u��3�=ZAT���[d�m����8�ד�?͘�����ۘ-���|�4Ɓ4α@��:��x��@�^���{�ӝ�s9��ɜ/��@�\>q.�x�O\��'���g��7p������J��!�|�\>q	.���O����[@�\>q.�x�O\��'�a�s�X/vq;����D6@<Ď'." >" N" ^��D�^·�3G��Sd�Ud�Wd�Yd��2w)������:�D�2��3��4���(iJ�m��Iϑ
ב
lŸ�������֋�g�# 
@6@:�l���@S$/�d��H��>�5H:�AOZ$�@6@��l`�H��H?�
�� $��  -A@z�,�4Y�
����F� ��?i
��Yi��d�=�H��! B@Z�,��Yi��%d�M�"�O�H���S��U@�+d�Y�H���v! ���I���Iˀ�g@�4���I؞�E����~֗�����������_��̧��%e:�ϲ�_h�L��N�aI��מv���za�o6J�U5ںkV��}_��w#���K�o�N�i�e��p��v����?�O�s�����-��^b�?���A�d���Ҍ�v�I_�����U=m�i�ޚ���ܖ/�yJ�Y�*Y����&M��9�[�;b��NL-���Zhc��«�[�13-Eڞ��!���.�K�>H-��{��RK֋����#�t�f��g����a/�����q7{��
-F��V|[�(]����Tnk��GK�*��ju�Y���^�t�����7��=OM��8��^s�k�
��紲֙�d��e5
�j��ia��T��Z��g�b�/��l
���j.��n>{�tw���u�z�u{����
6������hf��ҷ�=���5�{hՒ��K�᮷��k���?���5��r�M{�W'�[���f��n}�k�Ŭ���/{���Sk���֎����n�\!�����.>�w]�����h{�	�{l�i�5��k��nk��5rRk��#�}bY�
v�F�V�F_jh�qw���V����Xc��?��:`z���?�%J���_�w8mW��>�+{��������'<�Қh~͚x�#kR��֤���#n����ku��u���1)�ul���q3�Y]�����|�_�?|�:�]��T���T����F�G�����#c]�_8e�l�N�;�'`�BO\D����J�/�Y��@�'<+qH<�7%�›_1g�8��9���+����a �^���H|�W$N�+����hQ��F�~ ��+�E�^�8�H��!��+��I�����r�_gM�W$]�W$m�W$}�W$��W$�����r��Y7�I;�������1�<"i	��^�4^�t^��^��^�4^�t^��^��^�4^�t^��8>��"i�"���^���c�$�	�%xE�&xE�'xE�(xE�)xE�*�/�+xE�,xE�-xE�.xE�/Q1>h�d��e�b,�k��������d��x�f����w��I�P	&����g����q�IEE�&�gmDE��a�HT�I'Q&�DE��ސ4�$��v�L�	$
E%�tHZ��0�)*¤�����"Lڊ�0�+*¤���΢"LZ���$q��\T�c�5X{Q&����.�Y�Z�J0�1�4a�eT�I�Q&}FE�4���ը�^�"�/�Ⱥ��0i7*¤�����S���������|d}GEx��#�<*¤�(2��K�˂�Fo��z1q�_/'�坕�#�����z��?����C��?�?��94!:>|�9��>O���|�����?��Q�Ӱ����b������oy�Ν䇻v�J�'�]�YSsX“];���Tj&�j�ƒ[*��'�fK��$�}P̒�}�n'oX�/�l*�尥�kvS��-���6��	�fB��hB�V�d�\%�&$��*��c2r�U�d�lS�$#gS�%#g�jB�tׄ���IS5��Z�g���n���g�U��[�k^�Zs���Z^K�����uf�O���'٤M�x7	I���Z|6�YZX��75L��>�l�
[�;�~��Z���z;
��}����+�
��05zm_���7ɍ��Im�,98�Ԧ��J�^m	��&��f	���v5��y����Ζ)Rr�Uu-���1�����f֊dk���mG���j�bi�=>9"�K����N+/�v)�f��Ԯ7?1u����S�6��g�啐j�a5E��j�
L�}k�%��:9�HK_�)�oJ���R4���-�N�?��e�w��F�L�v�g��:x�A��O��S��%uh�LCsS���2
۱�2�{F��%s,#��H1Y����-yTlo��}
�DŽ7��]U1y�gu�˿��̳X���9|�đ��)r/58r��9f�祆�X�Nk=j��H�9���.S���I^L�"� ="
!=b!�-�#�\Q
��
�Q���QL��$�!="�ab
�����(��h�􈨈���(��h�XzD�|,="�fN�����#��c����h�XzDt~,="Z?��K���H���@�;�$�<�#��H���k��H��5ˀH�^�k����k��;I�#��G$bB�a�H�Z�5��"���I6��tI>��� ="AzDR����I
�#��G$-H�H^PJ'�A)�da���t��M$9"}R�H�R:I�'�!�O$EH�H��>�W�`YB�D҄��	�I�'�)�O$UH�H�VH�Y��$]H�H��$aH�HƐ.��!]"9C�D��t�d
�I�%�7�K$qH�H�$uH�H�$y�@C�$����? I �%�A�K$�H�H�.�$"]"YD�D҈t���I$�%�IЖ���%�$��d�C��H�4�dHR�t���I*�%�U�K$�H�H^�.��J���V���0����je�l)��ǧV+�����d�u�<8.!6.:.!�Y\
�������7{�OV���簘��
���)����g�sG��6O���s��U�XV7��k:��k+�Y�-��w��o(s8uÏ3�)���nܮXw����x�~��۩ߖݑ|зC��w,�Dv>������G.=r�yA�n���=g�{F]���]�G�>G�������ﯳ83/B�j���x�Q~#S�P��XlB��"�-yu�B"����X�j��X�AT�"�3y��ȣ�h
1��؃�-rE����@�:ZJDw�Rځ\�i$�g�BٹPv.�����?/>p���Џ�}˓�~͓��*O
�����|�
�������<��O�.��{����&�'�m��d��&s\�v%���L����a�$ϛ�_�9�#y����~�M�D���|�n�^r��x�.���J��@��g�R�r{�t�RJ��z�k~F��%�r�K�?��WXu˨8︮$�T*��E�ܱ�R��1����Z��r���sd��O7M�<�רq��\s�*�ց�z�9�u��t���ӻMt�w��Uu��ů}n�߽���1+�r�d�2J��sr�m��z�w��K
6-��}�h4�M�2���x��I��Fp�zS/�i:H�~@	���z`�^p��f��Rk�Ŭ5F�C��V��3Z�o���>ܰN������h�(����3":\�#�7:��w<SW�\���rJ��(�N���Op(=�ΐ{F}��3B��:eDNzO�];��3\�*8߈�G_�`ĸ��cv�5���+�����c�(nci��N��;��P���2D�dDD-ӱ\�*�̥,K���Y�I�5ʬ����n�cZ��ς�����3�Wp�`]��=�9�s�}�|j�Iˢ�a���s�n?��Hi�<19����4�Qae���
���g������FZ�KO�9e���>.s�1>w��D�
���!���/OeD��6&�k�煒��]����~���Hn������"���*�c�*=����_���}�ӎ��
;|�ޡ`i��zky�]σ"{F���5��yA$r�v�C~ق�=#�'��r�b[
b��Nk�ZG�C������#"�K�
�H��
�+"�[!��\@���<#r�F������;"�{D. ��\@��<$R���ж�5�$�C;Cχ���о�k�Q^����1Wy�,�Ɯ�uhc�s�ס�DϏ9���R�s���3�C;Aט�D* �)B~�:��"�C�*�:����ס�+�:���C{��1��\��z	X@��ש=�;��T6P| R�����5b�S[E�?b��
"�D.?�\��:�~t�XB��ש��;�Wx��7�s�(�G����w�#��:5�q�����L�ש��ˀ?�Nm<�\����E�N�w�#&�:5�q����Ԧ�N��\�"�X��Ԣ^���;���lv�:�H�ש���e�1^�f��e�3^���w.��:�E���ש�x�2��S{�w.��:�)�sp�ש
�ˀ�N-�w.R1,��`�a��Z��+ռ������^q��ǥ�06�O~��	��',л��n����!�<��
дk���3V��h��[�Q�G���������������������uk�(RJY�N��z��6G�R�~i}��
3����_*�_ު~qr��uFY��Da����oz%�9,�	߅n��Law��ݦ!��ۨ�u=-��Y��;]�ɜ���ifz�~0i�vhb�pt�Ȁ�h�zڱ�����'��'~�+�:f��w��l�!�{��}%[� 
�k 
��#
�cv#
�k�yc`chcyc�|�#w�p�w�;�:w�>�i�]�3��h�1�����Lw�"�):�	�E�ct&�5:�	���w��\�;�g.���̥Y�x7�%�����*횆;K�.�@9ɻ��.턫|Z�s��]���y:�	�>���:�	��@�
tV�#�&xW�YM�Π����Ag5�;��j�w	���:�	�-tV�c�&x��YM�Ρ����Cg5�;��j�w�ކwEx7ѮmxG���N޵}��Y��<����78iH�໢���ݤ���z�.�a��̂ǕX�Yg,X[Y�:���X]OܙVA���S�}�K����w�;�l�Kqw���ns��'o��ץ��rV��~O�ɜm��n��5&��������=�#ZG���"��z�'��K'~O��I'wTO˓N��$��bJg_�-�[qհF����1~��^���2.|S����Om�ꗚN1�W�\a�q���r�3ҕCī�	ҵ�(1/#R�_�P�5��=[V�g\��Q���q�F��zɶ�
��^J:e���}�m����˘+������\/�׬+��\_yQ�8C��?ګ}�����l������XM�	'VHK���<^�g�N����jH�[@�O��C��d@���ܛ��s.1���y�7j=��� \���s��&\��|HD��|>$��~>�Q�k?�S�hõ6���õ,���õ������ε���hĵ��4*q�o��5:��-�P��`D+��Q�NpY��|"z�	.�`|N�z�y�d|N�t����4N�Y5�bV
�h7.�E@:>�q]#��R@=ޕIׄ~�1��DAZj1��DCZj�H7P��Ӷ�� :�L*���(IK,VW-i����
�&-�p����IK-Ai��(-�$����^5ԫ�z�P�VC����o���n	c�$�G6����k�|�������t�'~�+x\��k_*���cW�3&>���]��ݷ0"�����s�ծ�R��_��uɀ����ui������]ߩ�w߻ŧt}�ں}��u���o{���&�s.��r���?���UӴ�<^���C��0�ˏ:u���k���������n��Ou�����}��kfz̯̈K.�t��*�������-�0����/�4�Lj��V-�W1㳪��f�.d|~����������>� ���l��o:����zٻ��.�Tvv�Ϣv������Q{+�8��؜�/'ձ��ǣr2cft�2�#��M��8}ԑǮ:��1�Xd���U�:Q�r����N�ܗ}r��Y��ef�^�Q֙-F��O3�έX�Q�g.p�0��ɓ�G��}��6��.5��ȭ?(��
��˥:d]�m�}�D����u��e��������d�0���bӿ̺g���{�+'%�[�Jھp��ˢJI�9J�3�|��֨�2��(����r����k��*�=2[|�GV����gݟ�]�_��ѕ�����`����ԮU^�j�~��v�GG���Q~ۿs�X�qT͕k��%����C�����b�a�7�κX��r�^�1��;�Rj߇�4�IMmx��F����w։H�Hm��D|Ӊ�R嗎�&�]J�<>8��Ő��Ƈֻ|1,��.FT�Hı̋ͮ��H�-��{?�rź�Vk�i=sAj���GlɓS�N�߮����r|��S;v�/�ㅱ#�����bt9�H�;���H���]wU����<�ۇ墺��p�g���Ѳ����Q��_u��*���Gl���#��5Wf96���7+�E�ُ���?��~,�oր����7�Rb8��F
���_n�#!�ZT™���zW���;�J�D%-+�v�5|N��_��z<�'{�̬�>�g�3��Q�[�S���]yYvj���Լ/i���r�s��28j\�����HWOf�GM����TF騉B�枊��ZX�<�3��|�ȳ����U�}���c���qV������8.ſ�j�
�}7��ݠ�w���LHk�Haܴ��fQfr�!�eG�cW�)O|��2`*�\��#����J����8KN���xK�,���ň�K���Lp�Α,&'�cr�L&'�e�$�L��i�`4m��M��4u���`6M�i��M��or��i�8E�r�:���0�� �)��#�;9BƓ#�<M'�i:xO�	�|�N��t�����4��@S	�4��Z@��=��PD���@
�R(�F�Bu�
��P@� �j)P7(B� e�E�!�P�:X�x<��X+ݣX��p�B�
E5+��5�R(�ְBQ%����Xw(B�!e�E�A�Pdf�B�Q+]cMb�b���$�(V(8X�x:���V(�X��`��S+�P�b���
E�,V(�g�BQ/���٬P��b��'��
�چP�(��ƑBu�
�u�P@�#�j)P�X�X�
�{V(fF�B��QQ�P�V(��b������,V(Ff�B�#�
{6+�Y�Pe�BQ9��Jt���
���PT���u��	�����B5�
���P|�
�+��5�YV(Q��
�V(f]d�B9�
��P�;�
�K��P<|���TV(Ja�"6��:�PD��BQ"��jt����0z~�٬PT�k�ݤP@�f��x������S�z�
ſ��Ba\d��q���
E�#�P,He�"�+�SY���
��TV(�xV(:��Bq_<+c/�B��+�.�B!a��]co�
�#��
�P4Oe��\+t�g`��]c�@
��P��k�#X��M��O�B���/�W�B1+���lV(�d�Bad�B�7����Y�h��
�+�Q�PLv�B�
�`+բX��H�ؓ�B�O�؛�BQ�
�+�����Wa��'��L�ƾ�
���a���,V(�e�BO��ϰB19�
�W�mX��|��
�W�uX��|Ş�����G�6?��������r7�������1#S������z�����`���!����|e^_�e�{Q7vL���	��)%�Eþ��nԖ�:.�Uy��4�sqi�����.��@˖��L�_�'�����_�Jڮ�>r�VJگ�]����k���1�ew
}�3z�5�3D�g�{Z�o|�_�b�~��wuh�@x�A}�J�Z�Ҿb�{��j?�ӫ*���(��XJ���^k�6MJ�!>4y�V�O�Xgؗ�7�v^��Fѿ�}���o
�G�'{C_��x���O՛��5���˳B���)b�����!bH�\-�?Jڣ��4#�_"���]�
}�Y��޵BK���j���ǜ��̟��Wz�)�vݝz����M_�;v�u��Y����[bt�З�;��A?�Xﺫ�3a�����Z��I�}���h�E�v���/@����j=6t�{���yXpl./�����%>���;��2g@��80}8�
n=n�tmP�����$-���zBd-�L����%ns�I>��e�a��k���G��C�o&�\a	ɱ�Eu����Ĕ���S�ρ�~EO�x_K�ٯ���6.�S}|n��D�B��l�6a�3�S͵��I�4���K��N�˳~ma�����:�ݯ-���iH2�"�%�Ô$�ҒdHMbU��$@�R�4���y�\������!0]k&�@�O�qU���U�����X��tl��t̥1c7Lu�cl�)�t�
�0���"ӱg�cO�L�����X��t�
�x`�n<0f7�
�c@��ҙ��Ҙ���B�k�И�� @
ӱ����c�if���L�ֳ�I~� �0S5�cS� ��X"�1���ILdž��j<0�*0�ۣ�a���%��e��vL����x`�[`����t�t���$���W��5�c�㿧4�c/� ���f�1c�E�<�cl����tl��t���tl��t���t,I灱�1c�E�F��"B$��x��ƍyP����"ӱ��1Kd:���tl��2c�E�T�cn���t���:ӱ$��."�2c�E�\�cl����t�
����y`\^`:Ɔ��<0f�E�f�cl���t�
���q�"d3�|E�f:���t������+B:�16\�C�/|;<���|���;�XXh�/���@o��)���E��R||J1�7�Z��J�/�����mѴǬ��)K����*��\��!k�i�|��s��oc�w��������l�������$�Ή���z��'vVVMV?�l���_Y�п��Q�KjFIK�=%�v(k��hў�#�Y�V���Mk�Og�o�ͷ�'�ln�򔵱{��)~������3A��Bs3+`���YK�9�s�#�7���}�q��t}��;[���]y�{Op�mO�[�S�}93�o?��dẄW���`R'��Ħ���ʑգ
|�c����'�+X�?�y��y��Oߘ���N��<�e�u�ӝʹ;Tk�j���&�U.$�Q/���}��S�G�KMQs�5��R�\��y9�a]9�¼��ܺ�U�������7��yV���{ƚֽj�R\�����JI��Gޠ��֫��E����kMSʘSղ��0˹��k���~�_bV��`�7>ʼ?)Ҫԯ�Y9���@���
�XUj7P��:cU���R�_���3���j��_+5W~��Z�R���ɳ��}Yu��0�d��Y��˿�h�?o����� g���d��(s��xgo% =Im�*Li:��*Ϫ�&&ZA)����h+��>%Կ�������"��1#����]��l�e��bo��r�Y��Z�l=ӭ��?ȴ%����2Ii�e�}|�ҡi�ڱC{�ㅥVd�@3r翬�rm��U#��g�]^��v�eSb&W�}X[��?F��)��h�T�9��˯�ڻO���56�%�h�Qs���t�ꗷ�|d�N�ќ������a��k
L�f*1�qӇ+�樃c��r�ԄȦJ™G�D��JⶖjR�JҲ��c�*��4�F|}�|<���b���'�Rg�6G��VJ�\st�
Vj��fj�5-b����^We�2.�Mu|�#��S�'�[*&&�Oe�T&�V'��?V��m�&��3W�B'��u��Q(�����ea'����W��y����S��	���������0p$I,@�X%�&K��4�Ф�I�ZO��Ұ@����4�0�a-*
kTiX�J�ZW��Ұ@����4���a-n�-b�4��-�E@����4�0�!-2
i�iH�LCZg�@Ӑ@����4���!-6
i���p�^��G�a,9��w��N�t�r��ܼ\|������kx^.�==cg�<�}Z�a�p����
ccT�vRx�T�al}���WTy����������L^.^���@�0�<]c��a�N6�������l�	����;��
c?Py;W�a�6������ql�	������<�k�0�����~&�y~B��als6��������a, ���'"ƚc��^c�O(L���7(�׫�)��T��OS��OU���a2�Od�O(`��a�O(d�,f�Q&��H��C��6���쿌�쿁���3��2
�_���gƞf�O(���R���T���b"�6��������E����h��?�b�d��Xe�n2��Ά�P@��'���f�]Tf�Uf��c/+��-f��f��,f��
��r��=&c�Y�?1��o�����<�=�2��Lf�n�� ���*��I
���Uf�q
��4��{��R��@���,f�mMf�#,f�uLf�3Tf�6��p��m����쿸�쿩���c
���*��,���Tf��(�+X���<�=o1�_j2��i1�������������쿛����p���������쿩����E��K���f�5Uf��*��[<�=o2������4y��
��Wl4��o����7��s�b���f���؈0��|ņ��?�+6&��Uf��"x;�[�P|�ۡ�1���S�@�������@��)�8��{����F��ܑ�߅[�|��p����6�Y+��_�9���ڂ�V7-��ݧX[���x�[���P�^��m�o�]�6�Џ�la����+�n�Ek/<�ެ�־����u5's�v`F�j�?�L���J;�PK;ڠ�z,��p���M��X'�9�=�:u�pz�&�̖M��?�.$/�.�~��Y�\*M���(��jv�p-�����H�ռrк�A�zN�wT5�x\�g�g4�=���y�Ƴ�YϞ�h<{~I��s����X�g�Ϟ��`�j��Ϟ�h4{�~Y���>�g��=�x��S���j�g��5�=��x�<[���X�g�4�=�	<{v<{n.��ُ:���=�4�i��Ƴ��g�.�g�oh8�i�Q�١��c�j�A[����hǺ[ѫ��6,����\��nj̄�Z�e�{�G5����-[i=�\T{���z�٥��ZL�
�Pc�քv�˱ۨ�G��i���&h����/�v����l�⦏W,�'>�Ɨ��%D�R���k���:kI>�Ԥe��a����DCۓo=��ڝ�Vrl9hs6Z�B�A{��]y;�5ӭԼ3ZZ�"5-�km\�i�̕�ܡ�鳴'�;�&�ў�h�N�W�4��z�Ӊ������Xt��5�b�9��e�����Zȫ�=� � |�p�[��O�_�?�|�Ξ/ƌ!����+'?E�`e`�Ō?O+:.m���oW,f��
��Y�?�񯰘�‡��вk�)�0㟫1��Uf��5f�)*3�G5f��Uf��4f�a*3�Z3�**3��3��M>$�7��낰Ō�����Ō���?���/��G8c��YcƞV0O
��☱7/��7
����	���QD��y}���Vt^��Vt^�R+:����׏ъ��_���i�l�y}�Pt^!��W���Z����t��z�ڢ�}Z�y}���Pt^�S(:�_-��o׊��WiE����Z�y}?��>M(:��ի��ͅ��z������zc^�B��+��ޘ��}�1��zc^����K3�)<����#��C�`�
��T0sR`�h1s��1s�2s�1s�Uf�j���S���Ҙ�_T����y=����y=�f�5y^����ǒ�����}���}���	�����{������x���"����*3�i<����}(��T1s���z(Y��k����ܣf�3�F3����9o��1s�����};���1s��R�̝�K3w�[,}��9o�2s��R�̽��̽�*xk"�D:V���d�s�k�:"nd�:���a7��
�y��h�v�]��#9�����3�*>�o�mo�+�EO��W�%/�e��\��\�r�m��;~l�lk.�{u��O_���Ͷ-.O^�IG�sRy���l�wQ��^�h����ꑊ���.�G���2J=�\��5�v�-�յv��:�1ۺ���?|`�T�#�vw�)ox��F{���qնY��-)-m���䬰����':�x��b����!���q�������>�.i����W�la�{w�	�ns�{_Γ��S�9��)f����6�����)���ُE�2��W�}¿�y�e�ɒ�͓��O�l�^��>?s��ä���*���}��S����]��I�+4Q.��⾜�ټr"�}5��y-��;/�����y�0�2�M��g��^ղW�)%�;�%m��{)i�RZ�c�f+��8{s�Rv���r�~J�5i�
o�1�W�3����o�?��Y����rtu�<�����UjW�W-u��V욽��J���~�s����k�t)��i��`>4y��v�o�:���Ь�w���L��	n���J�Hw���JÓ
܍2�+�wv��?�4YU��tb+E��kL�g���G�0Cz~e��a�9��%�͈�_�#�4�]Y�n�e��b��n��TZ�Mq���Ai3��ۖ�Hi;e��]�iJ��^�M�*;��;^xՌ���9��.�^5��|����kO*]w�c&<�t����{�6�}�O�-Rz�ɶ��W���c{�+G�����G����nǦ�f��Wݏ,�l>�3���[�c���g��mn%f�7�1���g���m���)	���tU��'nk�$�<jOZ&*Î}f>��9������ʛ#Wlv'��Lu�[�Q�;̔��ѕ?0S�w��mW�"����R�Uf�9[���D�X���&�	�)Oe���Z(��`�p)�T���7)X��uc��̅���`�n�-T�P���Y��_��#�aD�#��v��v?1Z?��Ҭ@�f����ڠ���"EF��/�kH��O�kJ��XҬ�g����f��4��Y?�(�Hi�`J�~T���Ҭ��f��`yֿ��hi�`K�f��4��Y?�/����� �Y?�1��i֟�no�4�p�M��)P�"pH)����p���ݬd���t�"�Ɋ�,7+LVƸYxRa ��
�c
+�vV�(�D�YxHa���-�73�b<�"�3��<�b�����3�<�_������
���y�?L�~��g�]��'�Yh��"��͊@g��7+�MV*�Y(o��
��-���nVv�<÷�<�?��"��Ί�v����RX�cgE`6���"0VaE�e7+�V�ܬ�1Yp�Y�k�"��͊@3�?7+���)P�X�ngE�]c���g���(����"�RXx�����"0�Ί�7&+ݬ|h�"��y<���NJ�j��H7+sV�Y��"��Ί��
+���RX�"����i;+-LV���"P�dE�I�X@Y��͊��bʊ�F��͊���ʊ��"ˊ��bˊ����J�P��C�e%�U��Cf%`���0�d%�����'V��<��P��J@��b�J�C
+�vV���=o����=qV����9������f%`��J�7+o��p�0�d%��f%`��J�cvV�UX	hcg%`��	`%�+��`%�	��)`%@TX	���J@c����nVʛ�lv����V8_�y`%���C�J�+6�p�bS�J�+6�p�b��J�+6���ko�qM�/|;��D�.%����߄ѩw��G`�/�p`�W����Ͻ��<.��Ϝw&uȨ��ʸ�͹�|;��9O�{">��9]ʶ��9׾5��+ul9�O��/������s�Xb���+�v�|cgn����vʗ}M��K:���d���;k|���渣�ZF{����䱶�ev9�6��쐅�E��>)��]�B5�,T����0�7�&����u7�O�N��@K�ᵠ��xM(��Bt^��݀׈��N��kE�?�^��kF�?�n��kG^?j��5��#���ZR��'���R��+�����?^_nw�����L�)��Ԟ��^��Z� ������n�px���]��)�?�(��|�Q!�̸f3֜�?�I��D,����,�zйoM?i���r��We�w�t���%H?���K�k�=˹�m�.��p^^�k\9]R��琉�� ���Q�uJ�_MN�k��2�8Dg�C�T7�g�o>��� ��;l4��
^����d9g��AFc�j9`�&��1Wn�i�$k��1FP_�\r��[�]/�I�䰯��?mqFdL��8,7���h���l�\�h��E�u7�h�b�lk��h;-Wn��9�}�
r�Kۥ�1���3Fd�ir�G����o8�玕:����2�~<���1������d&A�!53z��{	Ս��Ƚ���b딑c?�&9�9#;�^���Z~���ѭ������������4��+�J`�7�E砊�1��h���뤄F}�	���J)r��N�Ћ��WKþ	��?�Q�A��G����.���KK�S8GU=%���u���MJm�Ǚ�{���3m�Vc��t�wOH�i�'��i<��uy Q�S�'��� M�'w�������a�η��E'��G�-�����"���h�����""s�O���/�boz.��\�I\�+�\�s$.��\�������|��E�&�:@�p��,q��AϏ��E���E�)���2��.�N.�l;���E>��1�(BR���E���,H0��d�eA�Q�dcM����t�4���i�D�	H�$!a#$"iZ���iAB��II�$&EHNҴ A)B����J�$+iZ���iAҒ��K�$/iZ���iA���L�$3iZ��T�dLl�������6��!�1b“�IO�$>iZ�8 �����iZ�l @��iZ�i8���l�@A�s�q@����m8H�� M�4-ҴHH�0!M�4�@�q@`!M�"�8 �P�!-��"�
iY8t0"��C�iZB�i��`D�iZJ�i0���D�E)Ҳ�(X���E@#iZ^�i��� F�iZf�i����F��q>LNh���֠�����5�u�@�Ip���8&���b��!�[rJ�ȡqw���t�`P����~�/!>�BwƵ }�z��9C�=����ii_՝ƾ5]�W|���n��$�w]����Ə%��O�X�RyQ��QS��#��&��ғ��S���'�5>פ��>�k���^h�R�2�u�u
�1�~�F�)È�+6;���bz���F�dAnY�=���y��y=�)����R��H�����[� �[�z��Ȅ���%n!v�Bt��𑸅p��B<'qQ���5��.r�~��rQS��#v��ך[���s��[�k�-��|����Ox��xT��c�[�{��8ĎFxo��X#r��0�d�僤�^Q���%���%��{�|		��z��m�$�5�7(�f�����R�����gT"d\��Zs�n�8G��¾���}U����c�%О3����f��,��'�f�T��+�G�=����˾gݗ߮�r����_q��{�q\��n)���֛�9�R&�{N*�m���޼�V(x�X�����/���t�!�|^F�	��:0�6�?`g����O�ub���'�z1���O�uc=���q�	���A�ud���3��1Ο�� �2U�mg���8�/�יq���zY��;Qx퉢ܡ��:�u����GdL�;�3�����pA
�LIH96i�P/�ߩ�>���%����C�����{<9�n�0T�_��	�{
����q)�^,q�T1���qX�����@��z���g���T᮪O֑g1�O~����@o�����78i��u+����濧𿏅��.�2��ݘ��X��%�܏z⮼���2}O�F���,�с='s����fz����&v��i�Ȁ֏Ev�Y��c�O���I��1KD�3[v��~n�Y���t��~!�}����藚���s��N�肎��~����z����H�t�.��p����l����h��|{��K/�TBst/G�rt-G�rt+G�rt)G�rt'Ggrt%GGrt#G'rt!GrtG�qtG�qtG�qtG�qtGgqtGGqtG'qtGqtG�pt
G�ptG�pt	G�ptGgptGGptG'ptGpt�F�ot�F�ot�F�ot�F�ot�Fgot�FGot�F'ot�Fot�F�nt�F�nt�F�nt�F�nt�Fgnt�FGnt�F'nt�Fnt�F�mt�F�mt�F�mt�F�mt�Fgmt�FGmt�F'mt�Fmt�F�lt�F�lt�F�lt�F�lt�Fglt�FGlt�F'lt�Flt�F�kt�F�kt�F�kt�F�kt�Fgkt�FG��˨��X�vͬo	�
��Qj@�j�4 2�5Ee����CQ/�l-Q�(z�G=��Ԡ�:�|8�F�� �Qg��u��y��t�7꼠�F�$�7�:o���F��:���Q!:o��,�Ɲ"o�i�����(��7�X"oܹ$�Q;D>�c�ȇs���Ed�=n�7���yc�:o�yS�=/뼱g��{�X���=�7�La�P�7���ь7�D���'R�>��эn�l�(G
 FD;��=��Q#"E@?����ٲ���#""FDE���1"BbD�ĈH��#"&FDM���=1"�bDňHJ�#"*FDUR�YI�t%e��-@YV���5�-M.q1"����#�/FD`�y���b/�@Dƈ���#�3FDh���� RcD�ƈ��Q#"7FDo���4I��E����"Dt���4Qd��
�;FDx����1"�cDħ	@w^�ȏ�#V�PH)�J@�F��*`�ʀ�F��J`�J��F��j���#V�L��P�*�+	E�&��P���+F�.��`�*�+
F�6��`�+F�>�a�*�+E�F�"Q���+E�N�Ba�*�+F�V�ba�+F�^��a�*�+�|�W�h��a��F�F�p��a�J��F�x��a��'�3K�/|;��43�wG��nO�
	
��nqiqÒ������C����	�y����M�_��?�+xL'�M]W��WZ�,�T�.t��-,4�����׽H|���"�{��J��?����eg/�W㦯���^E���ءP�_�H�fɘ71w~��s���X��9@N]�f��+�1fk^+fk^+fk^+fkc+��!��e�ޏ������q��~'V��^�&�޴�?��x7���|�Z�
�ӹ�ƴ���W�������ߓ�Z��}k�mi�y��5���O��V���`�z~����*��m�y��,>��1�����˪|�Y��w�>�k�����ބ��e��wZ|�K���j�y����a�y��,>�?\��t��+*���_��?U����*������X|�d��l1o������"d�?.���"��/~�a���p�^�k�-�?�z���ݛg�̭q���1+y�W������<���=>�����|@�ə�mTy&�����(z|~�U�FV��󹛿q|>w�7��/��L�����8>��yDfi��#�0K�n���N�Y���_���]?>?�b�v���X�Y���#,fi׏ϯf1K�~|~��,����s|>�������W��]?>�S�Y�����Ү���b�v��������Of�����[EY��Xyf1��c�p�'�C�76.)���ߛ��ݴ������w��/^�y]��Ǵ�km��Qk��:�U֎��o��F���#�d�@�� YF+�d7
R!�C�?�S}����}O��f����[P�߄����&:�����?�k��7�YZ�?����2��Xxp�M�ü󿻙��W���������1MP��My#��3ߛ��-W���,��V�����y��w��z'g����z/3�\����<���bU��v�hU�6�hQ���hM���hI�v�k��Vц-��n�@A�q�G�q�G�q�G�q�Gkq�GKq�G+�ܾ��l��͔�sK�G�o�l�vI��g������3&ڄ�u%�h���h���h�V�h��h�}�om����&�}��7�|��7�{��7�z��7�y��7�x��7�w�u7�v�e7�u�U7�t�E7�s�m�ђ��ъ{n���h����h���ۿ���^��坿����S�o���߮��-`���V>�k���TY�9��
#���l�k�H���$��J���d��/Hu@�$���"�'YC�R%��R��<%��T��\%��UlB��J��d8K��dxK��d�K�����Sf����1"&�E�2YD6�E�3YDF�E�4YDV��c]#f�E�6YDv�E�7YC�S'k�r���5KG|g���&�^[,V�>��Y;�>�^Ϙ�z����`��5Ce��i�U��*�^�
�^1*�^�V����z�WX�������d�+�b�Kd���v���yV������b��C�U���^;V�v��z�VX��@��s^�>Gel��+�ǩ��Q�W�?��J�&�Do�j� V�����5�X5�a�j�g��[`}bՌ��N�j���}�W�����m�:�]��]��]��X��m^n�y��&
�@�"���������7,�{����<�����}kk_dGY�s��۩��z���_r^/���A����D�ߟ~BU���Ew��;����v�vdj��p|�258�Q�_�����H��
�K<=k��>adjJ܈�6�	����?!��=��;�[�?�ؚ*���%kQ����%�voU��.
^+,�[e�s���;9��w/L��k-�',O�g�X�^pNla�|m��~�C]5���Adsuu�:ڇ�~�G-Kh%��5Տkk����Ņ�[6��9&�[�cen�>��\���;[��<'l�>��?R��t��%�_�g����ZVn��E�nw�O����x��O�~s��������O�~j��^j:T˭?��Bg�r�D�ﲮ�A�*��ɎV���Z㝃Ԁ�Z�UԦ�i�zj`b�4���Bz�TC��aA_��>~BD�Vı<�ٕ/���K����r�U�����3s�6�U˖���Ny^m�
�}|�ڡ�����we�B�����P�}ss�"jT���R������]�-��?�2q�gB���G���`(τv<���Lh��3�U<\��l�gB��	��x&'�L���3��τZX<��Lȡ�L���3��*τ�h<�k�c�	��,p�gB��+r�<ڠ�L�3��gBYτ\t��M3!'��y&4���H�gBC,�	�K�P��3�τ����/��[	����Jh�+f%4��	-*�2kτ�T�	
�x&4��Pg�gB��w%�筤��3��τfk<��Lh��3�*τ�i<���L(���0ττN�<j.�L�K�gB~τN�lj4τ��x&ĺ�k�	]�x&��3��gB��3!��3��U�	���L(Ye�c��])�O^)�mhn�������ڦ$=�<���{�CCn�B��ߞ���L�c�����>�1�O_����e��<�̣�'W�;F�r�Q����8?�Y>��u��E܊܊̊�6���+=�����Ws�"�јz��L���x�@Y��_�"�����v��--�>�������	cR���_!�7�?{�w3�K|�^�!��3:�Y?��.�����e�_��&��e/�l��q��{G�t���.�#�U�m��'����K����˾��Z{\e��/�ʹֺ˯�m��v�]|e��⌏��v�k�J�&�*GO�?�,�`�^��S����٫�3�U�Qm��vW�C�N�A�*;k�_�Uk�%��i{h�ng���:�~�+c��9[�W��Ϳ�Dz~iW���9�\
ON�ens5��3 }��ɪ	Φ_tɳ8�ۂFۜ���-�Wmg��-,��3ܧ�-��!9�x����{��U���{Tn�q�Z���Z��f�۲-9��v�fg��{\���rvh���c�Ύ��"�ȑ;�ۢ�=+G�Ze�|f��嵯]]wMs�LX���Pg���\�9��=Z�q�Lk������;�����f��P�{4��UNvl����;'?����ќ�r�)Wm�e������ϖ��ˮ��+����'�rƗ�t%D�q&�1\��}��۞v%�4s&-�w
;^�9|�d�w��x�`�Hg599��M�yU�oKIΑG?Pږ��%���u�E�s��q�������k|��|"}���짝&.s=��8`�kҼNN�b�K�֟��|��?����n,���xk7�;"=�D�Ū��OV�ՠ�U��w��mv;x��m��dŮ�Q��J2߂O�x���C�+Z�ϵ0>5��\�:���Zv6��Dd�e���HH[z�y&&�-��,��t����_��$�@���	�b��n[r],�|og�e��Ŗ�n[.�XlY�f�e��Ŗl;�-km,�|lg��u�-��Yl�dc�e��Ŗ8�-��Ŗ���a��2��Xt��5��.$�(������%���`�e7]#P���7�.�2�.gl,�|̾� ,��ƾ�9l��`¢�6�.�:YtY�b�e��E�],�p���Ƣ��}�pHt�a�%��|Xt� D�8�_#]�Xt9J�L,�|ƾ�:�_)]��"X���A�E�O\,��`_l0]��/6�.��,�����2Lf��k�.���E���
@ǢKg'�.c�A�E��t��ǢK3�.��E�X�y�,�D�Xt9Ǿ��,�l�Yt�jc�e�̢K��E��2�.�],��d_lN]f9Yt�t��2�}�HYt��d��i�.͜,���5�+�.���!Ȳ�2��lYt�hc��*]#��C��,�����E�}�
�̢K&�b0��b�/64�.O;YtY�b�%�ɢ�L�.������2�ҥ��?���A��;�7л�o��[j'�Ǎ~'
�~��
����������?��;��H#/c�-i'Y���V���=�m����,��U�G=gɶu]>���>�t�O:K/�k�t�1����^.�Z�*�f�\��/l�+��3޳�7~�|��J�Fɕ�U��z�6�i�R;�Y�t���==��U����Y�P]�o���|���t�Z��!�5���ը[]�3��p�5�n�/�z��
ߓ��8�� 5���lxR�e~�l��9# }��ɪ�FӉ�8�Yv#0ѐ�F��O�!�*���rX�OF�O'9��~)�x}�ٕ���-�~'�t�s�Z�Fj��r��?_�%�t���Ѯ�����.wv�����A92`��s�]�	)z�b��R���;��g�Lx����G��:�sZ=Z&:{��4z�E;{�
F鬒�����أQ��f����P�wPzdqY�ќ�R�)g��2K�����s�7�McP�W��S��rNgBd��p�%g����-ՙ���HZ�v��1|�hy����xZy����.�3�J�ª�)�nit�+rj�����i_i9?;�Uq�2�:��d<���dv�1a��S�������E���&{9<��D)�Z��#���U����j��:XB�B�h%����t����t�jҥן�����Ӏ�QL�\Ei@;�i@��4`��i@'ơy�N`~2
�v�i@{ӀzN��N`�2
�v�i�^Ӏ/�L���|f���5Ӏ/lL��L޳1
�)3
x��4`��4@�1
�%3
�ic��dbc���4���4���i@]�i��N�>Ӏ�N��L��L�L��LNH<{�&3
�Bbp�����^q2
xAb���4@��|�d�4`��i�H�i�3N�v�i�!3
2�<-3
�d0
��y����4��/b����IL|e��IL��"F1
�X�4��/b����]L�s��4� ���eL6r���4`��4���4`��i�8�i��N��L�:��4�$:��4�Ds��4�����L���Ld�PfpPbPVf�QbpVf�Xb�L���v2
x�`�i�T�i����R�/q���4 ���V��N����e�
%�}d�e%��2Ӏ�Ӏ�2��ij�+�3
x���d�����?`3Ӏ�N�/L�9��L8��L&;�D�H6�-�����M3�o�t�g@���wg�w��KhPp� ���m��Ԥ�w������^���wM�8>!.e���u��ߴ�7$,��{7��u�/<.����aa�7O*Y�(_�"n{�A��7ڋ_�"���+nOy@�1�G<�B�O/�*���J<�l�ܸZ�5T�;��?D� ^?,^�F����O��_jZR�d���j�uL�R�e�r�S�����w���L���z՝�^m�z�O։~�-k��@���.֚0Y�F���,���[�Ӳ��p�0����X�lѿD{����Ѻz�o�n��}��7^����ɔ�z��Ot9~���n1(�1��Z1��1���bX�81��$1���z�8�ٕ4����b���咁z�������m��!u�S���:����W;�=�wlM�T�s=��1��11��b�WYb��o�]��#v��S=���n�-Ի�)ڟ{F��_z�	z��zﮑz��鱍豗d�Q����>�ߏ��G>��?����ߨ(>��iq������ߊqO����H�ؗz|�WĄV�!�V�5t=��\}�=)k�>lo}��G�[F��?�J����<���NG�h)�yPXSL�8�� �5���Y��q�/��ܛ��gw�O8��O~�V��������/�'�0��t�-�+�;{����*;���*���_�;7�O�hE]G���`�[H���Ӧ0�O9����F!�h;�FL)��V1�h�
��Q�ÈiF�R���C��2pH9ZiG�!�h8�-��e�b1i8�#-���e��\�
LjK�5�(Q��x_.�*QwHW�D�!m��C�R��%
)LҘ(;�2QvHg�)��D�!���Cje��&�)N�Ҝ(;�:QvHw���D�!퉲C�U���a�(;@Qv���	D���4ex �Ah0A���(;�Qv���D�:����BT`�"@	S�4�FHa��k����)"�0e���PÔ��9L٫�5BQu��AD��(U8��D�`�(;@Qv�'��QD����Te�"��E�`�(;@��/�aD��(�U8��F�`�(;@Qv�7��qD�戲�e�#��G�`�(;@Qv�?���D�1"U8���a�(;@#Qv�G���D�&��Te�$��I�`�(;@'Qv�O���D�F��(%�pJ ��:�*E�V���D�b���e�%�pK� �(;���7�]_�V@ �%��P"�2Ʀ�ޕ̷��)npjr�;�~��ݼ�;$(�����X�,�
��-���-�������ڻ��.tL����m�?�a��^�篺��1��;}�����$H��)		#�&
�w��7�=���z�_x�<�{�_v����|;��0���#cF�����N�b�O���Ȥ4��ݱ#�n��q�����u�_`����n���{�{������&�V�-�������:0�+yF�zX�{�=0�옾����7��?�u`�7�=#�e�������+�~��x��u�w���L����78Ȼ�������f���7���Z7�g�����7�=/�gj�����7��?�u�7�=#��=-�������4@��������ý����i��������v���	0��Z�y��3�?����{���'�o���'��m�����@���3�o���'��i����`O����[7�o���'��n�ݵ�!��i��{`�61}���O���ڻ��C�?����;����?oa����7��?��w��g���� /���:�Eht��_�	|[Bl��� �����'a��~��x���^���i��{`��y��n_�+�������g����w���?��5���_�'��i�zF��zZ�{�{`�w�c���~��x����@���a���^��󿷂�v���	0��Zx{F��{Z�{����TL����O���:���3�?���߻���_�0}#n?�o<�D��`��f������Dӷ���'��o�:�{�g��=�+�&��;����G�F����@�ʭ��yH�zX�{����:1}���O����=#��<,�����.L�?����`�A�{zF�{X�{����1}���O����]���a��{`�o21}���O����]x��O��w�g�q����`�ӿ�7����n�a�?X	�������@�����a�pW�HpX�/����ݽ��x�'~�.x,�/�2����_��o�Q��Q確#��x9��ʉ!����ZV���)�/m(
�HŞ-+�3��t�z�8�D_�d�҆�|Z�y��QZ�J/��S��r�e�F����r���kV��^.���(V��K��-ޟ�"U��G��[z�Y��`�0�J�^z��U�j����~1�zP���Qc��z͕�F��{u)�����uz��rR�a{ćC�Iu;"֫�]�o�.��1�jb�����'��2W�wN��gMV)zӉcyV;=0�%)h��zpd�ҫ��+����}"��b��jR�+���[�J-�~.�tV1Z�}Wl=��f��-y��v��z��F����F���/�"�%F�\-E�!F��+u>�M���*��az̄�F�����5�s��=Z�3z��z/�F�>?软�0bC��c�6�5ϋ��~R����#��GsV�����c�s������E%&Lj�>[�2'���˽a$D���L1�[�ۆI>5�eQưc���9	����xZ�4rE���@Rg�⨰2RJ�qt�3Rj�Ebj~i#-¥��2�UyC����;E"}��d�}����2��F��5ԁ!���b�G��sʋ�[z^�}-�@	�)�§��H�I�|��DˆɄ
#&FL,��\!�0b�a�DÈɆ#%~`��$����1	1b"�/Ɉ#&%FLL���1A)B�b�DňɊ#&-FL\���1�1bc�DƈɌ#&5FLl���1�1b�c�D�Ɏ#&=FL|���0"`D ��`�#�F� (H`D��`�#�F�@0"�P� ��`�#�
F�.`0"�`D��`�#�F�>�0"aD ˆ`�	#�F&�N�$@Q�ˆ@E�
#E-�\�0"�aDÈ@����4�j�0"�Q��� ���"�F<�����#�F@��1"bD@Ĉ���#�#FH��()XbD������"�'FP��H1"�bD@ň���#�+FX��h)�s�"�R�ň�K�#0Fa���1" cDP��f߂��qLp��&r��&�M�KNn|�����w�����k}4c�����ﵭ3���W.���pW���ײ�y���~ЂT�M��{M�w��w%pQ����6f��&�"�e׮!*:**.Ɍ0�(2W6��V��՗�4m�Ѭl��KX��5[L�,+����e][M����PM%��.�gʹs��<�9��J�em)�6����do���_�\ϠJ�^[k��VJ�]+��m+q��h�
�N����:�g�%��!�p�X�
w�w�p��E��e=C��R��;ʭ��'��+��?�o�I�튽�1���{�H톻
�'}�����C��a���/�R�ɀ��M�t2R�sr������뺡R��T�_&��5�d6�Bc'†��L���!�Kޝ���������g��4��mH�>r������|��s �~$�����w�"G�̒���c����_vbgBJ}��p�����H���?+�Ϝ/��[<�.���!=�CsjH�|���H	��#L���v1$�}
���aT�.H��a̱!�0ܳe�����e�!�����o�ɩv)��b�;@��ʑS��Խ��ݻ�d��<��ii򒑆��F�����h��Zą���������4d
^�e��s"ߐr��s[,�r�l����Hӗ��gN�fξ_���]�=�&�y�W��4�ӋN+b��`���
P(A0�xH3��w��{K�}e�'��o ���-8��������9���}�]�|�"���	�����dy	�?����1��?�l$(����+%�+d�[9���Wp��s��3���q�S�c9�w�p��4��������K�;���I����'��?)���+��oc ����F1 ��!G����������;��������6��?%P
�D�����P���L�?L"�?�@���D�{��B����������Ph�S]��C��G���9�Tס�������?�u(H��Ca"���~(���P���|?���G��y���X���|��o���]&�o����א����#�ߘ|?��.�A��72���ő���_��0��_���_o �?�#�_ ���/��C&�o��/&�BI�?�|?&��D� ����OK�G�7��w3���8��WV�M�WX�_���eXH|E�%��|?/���2����?����?����M&���O��������%�Gy����x���"-�O�9����/��S(�����=�ʝ�>N;8��kOg�0�3�^�P�h��'�ƴ��v4kY�K��?�u�S�7_ z��_�gxC���s`+��]���)ZC5[j��1��K��}�Қ,��0Bkjv!Rk	6��v[@+�b˺��[��Bj}�����f�Q�o��튭�1�1��b��!ݿ�u0�4�\��l��{5��R�O�pl���d��y��R����eӤ��Š٣$~QG185�u]146��I�����b��/��������׺�vA~U�����G���Iw=-j�C�����w�J)*�!F͕b���1��	iu�{�IH����u3 �k�Y*
�d�?3O���#���"��K���8̷��0�1἗4”/������Z�.L��ѫ���6v�NH{ӵq)/@��Y�K�y�URr�1��<��K���(���S�����^���.Ҥ_����qi��ڔ�ΐ��k�
!M�Ц�~����l?���ZV�))'r��sl���b���e��wf�8}�"i������Ҭ�.��q#�9O4=4�lR��Bv��������4�����L�I�`��X��=��*G�?N#�Ǒ�﬑��̑�oH��G��'���O��"�����E��1���F����#��X$��H"��h�%�i���gi�8�#4�#8��چ�M��G�?�����K���~Hx�����H���s�W��Os������/��o �A��D�?Y#��N"����\"�?^$�?M"�-��%���(�������'r�O��s�?�S]�B���u(8�]��W�k�h��C!"�Ou
���P���%�E��M� T�$��E�G�?X#��T"�?H$��'���E�c$��{��(l�ے��#��E������~<�D6>�_q������O����������.����������#�BI�"�~L���p���"���Z$������g���q��?����?����~� ���(�����%��V"�?Q$�O|E!&�O|EA&�?R"���O�����
K0�x����x������?�s'�xj��h"�s��g�s�p�?�]�kOWa���~���j^�jLsi5�BK-�_bm��RG�R��[���R�gXe���b�G�g��z@l��JWC5Ul�i���K�k�''��,�i��s5��j����j�5��u[@}�E�K˺��V5�[Z��#�>~���Ͷ}���mW��s8�{Y�
�Jk?i���i�vG�G]����w�t��|���=/v:��e���`�%p�]�.�4{��/ja	NM�B2�ZBc㴰�G,&��Zx�K�wC-����?i��mvu߽_���2W�5?��ޖ\��w==�%8��̝c�;x��b�D�1�Q��_Vk��I�؃jq
���֥i�O�w
xf�8��?s�8hc;���yI-ː�A����a�MĄ�{,	�~G�^�������ە��6�p�k�ژc���ݠݳ%�5.e���l���^�Οl�DLN���4�m�A۩�b�K�ޞ���/�k~��,��t���vM�����t9�j��
��&���X��l�]����*�R̉\b�9�M�m�k���wf�e����{Zf�Ng�Yf���<�Y<4ͼ�z�i���SL3�
%&i&��?����,�9���^�M,�`�5�=\�k�۸���׌x��#��E���^#���,�$��$�O>	J��F�����"���.�"���.�k�'���4�\�c5�\�4�
\��k�,�Oi��[����OY�� ���g!���H����?���_d!���F�����N����.�/��� ��C$�?�E��y������|������]$�n!�?@$���B�?���((��4�G,�;k�X�S]�BC���:�5��\��C"�Ou
���P��S]��D�?�|?����A��?H����F���������`!�?Y$���B�?^$�_�B�?H$��B��	�~8� r�_���oL�ߏ
=�]�j�t��ߠ��Os��_����"��^$�?�B��H�?�B�?�|?%����A0��$��I��O$��B���F�������F�� {��J����?����v� ���(�����%���H����?����?����H��&f�"{���+}�V�K�������a&�W��������)��}�'O��W���(�}���Y�8b����������p�����ESN�_��5�_�_}��2��֠����t=�?����7���a�H��WS�g�t���p���j�E�%�ו�Ǣ��W�fw��*Wk`|ק�E\Ͽv�BRp���_��'�6A��a�b�#yru��B"p��A��$���hkz�5).�:ޖV���o˵';��Z'Y92�lz�WZ�udZ3�õ��H0Qf�}��j�u���W��[1��|l!�q�P��V�)�~���E���f�omxNy��Za�O�w>�Fݒ�l}����^�l{�Ya{�����N�ߕ]�Z®�N��}"�w]k�=�.ޏ_����<��x7��rJ=`R>�JQ�U��u���o���C��'�+g�F�g�=���4��p���z~�0��W�
�Ϙx��a��s�����7(��wD��ܡ�8�oo�$:8��twvr�;?9��n%rk'%vZ=%��c��+���V�W����]�5�gM����Q��~��*���}�������ˀϹht��;">����m���
T�Re<󚂈
�����
�����!4$"6&"6("6*"6,"6."60"62"64"66"68"6:ChxDl|���!1 BP b` bp b�0� A�@A�`a��A���ͩ�bs* �؜
$6��U�_,���
�-""""C6D8�t�x!�11111 BP"b`"bpr��>=᷽�=|ox�o�Hꓜa���ʃ��a�nO�������w�geجi���h�p<�-8ʚnM��X3�l�z�Wf���Sӭ�C#��?�W��o&��ݡ�y6U
P�)�\Dž��_P�*}F�V���uX�):��am�Y}���Z����ߒ�?:D<��Dž���L�!(�������I��@G�=3Ǟ�V���j���Ϥ��Uk��.�Ư7���b��t�U�p�7o"��p����R{B�b���z�ᇸ/�L�ȱ��їd�ؖ<���k��=A�jv/��p�qm�oZ�'b{r�E�i��q�w���w?��W�N|���N���܏[��?�qI��,�o��9��9�7�9��U�Y���2��uJ<J����۽�)�>��=��=��6��V��Kؗ��f+#��M��&�+f~Ic9�f��Z6�@e@Du`��!���mr����("�"*"�"*	"�	"*
"�
"*"�"*"�"*
"�
"*"�"*"�CP DT!DT"DT#DT$DT%DT��]�W�I��H�l}����Ez7�"==�!���q�7 ݑ�7�:�/�����KO�[ӭ�àJ�\�@z�?k��ٓ��*�=��ϛ.=�34,B���)��=n���N#U���P���S����n��=U���������a�B���C�Q�9f�Ts,�}���W�DG�=���_��p�G`�����nGFV�Hk^�G����ۿ*�?&=ӆ��<����M����l�(GF�c|�����?\�U�S�/nkZR?k�xGvF��)4��8%P��=���.z�Z_������93�Rr���kb����zw�ԯ{�O��Z.�n�e�����'�2KN��^iБ��k��v���k�u�5#�Z����!a!:�=������ۧy�P�r���ŠfXnO����k��=�7��?H����g�£S��I���f���I}��L�a�����+5���+g��+������z���=1�S>�����z��I������z���V4��'͖�e���r�?�H�SHp����ܜRo�-+i�==ٖ���&�����&:�X3=���z�Wq��N�{�x8���_��?�����)���U�_kF�D[�mJ^��D8������?��0���/$4To�*mk�=ՑU)�Q���"t�Wi��f[Sli�l�C���_��Qi�˷��^�Ui�G;�����S���_����,{j�����ۿ*�?5۞��1���*m��4[z�}��o�А�K����?��u��%5��K>o$��E~]����8�n��{p���_4�g ��/�u}oP�H0x#6�z�L?)����f�H2g�`f���a%�_e������3��W���E��_��e͛b���?C���c����E�`��W��7���7�(:�n�D���$�%�}~G"�wmo��%]�ϰ&W�쏫�?,��#B���ZE�U��-��DK;�1q�/�l�۽M@�n�F��E��,z��������x�:�o[ZZ	Tt�y�:�/�D�$��ׄs��z��ʇ�㿶{��Q���~.�__�_���W��8U�����uG�K�+/5*�Q��;�m]���7oݠ����-˗*[���s�m�.�ܞ4F�1+7r�]��]����ݶ��n���{���k���~��-��`x���oo��Ǔ�?�@����S1��S|b��i������3�$(g�e�ڟ�/8���c���/�*��K����y�Mﭮ�x��u�]���?)�F���`�Qg�����a�e�<�iz��	|����W|�th��xG����|:+�	ɾ�>���F�{� ��3jL��_f��uSbZ�~��ĭ��ӹ`�3I��
�g���`���yj󐞵�����Z'$��s�	^�5j�G��%7�f�k�m���~�b�;@?��5(�y�u�k��-n���^��9jd<�H\��t2�C)���7��C�����:[�By���V!�1�1�1�1��
%7�B	B��P��c+� ��
%?�B	B�V(-a��"[���V(AH��I���le�'[�!��a�B��P�pe{J@�"b�2��e�C�2�f�C3�PF�pf!�V&AX�IڥV&A���I�le�:[���_�a�ZB�%S�@D�k�"�)���@Dj "=�"�HD�
"�)��J+��B/]�tb)(���BDj!"��b�f,����r�H;D�"�)��4DD*""���HKD�&"ғ�7P�!Д��yzٵZ%�LrLH&Z+|�E������k�}|�?0�!e��:�_���Y��h�G�t��.�[o	��b��~�^�D��p ��b�I��2�J1�
-�ۗ�x,�å�}��r�opI��%���S�m�'N����'����C�s��p���}��;c�v�/��6P}�q��wݍU�;�~���G�Q��;�}]б�L5����X�=��7w"G�|��z������&��Y�è�f�z���~�vf����@�?��#���>�����B�φ����^����9�2�����2d�]���2�ӓ��j�������T'�Kn/ro�s�?����ڝ?��k�Ͼ,����k�T��
�G+�,��$%J�e�b���{�[#[
����[To���vVZ�L�[~�Nm��|�-���뭕6��������r�(ާ�n=(�歴�N:������C��,]�U�}%Og8�S:�{G���W�@����cj��>�!8|"2���
%, ���LJ7�Y
?�?%���m{�n�lT��X���zP�f#�k���^�����1��3�G�o�JԐ!��#JL�B�/���#5��P��YE�[��1u�����j��6�������7��Ai�P�K�u��o�7��Uˆ?*#�yB�]�Q��o�1��c������u\��JR^?Ւt���ꤎ�� �ܭ���vok�js/�Sk�R���'?%ط��'m�'L^=MI[�V��QJ������8i�:�_%���j��[�ꔩf7��s|��9Z!?�d��[����o�NW��3օ3�U��E-���<~N�Y��B�[M��=
�~�ص�jdܻ�zڧĮ%��|�D�Df���-�^ �k "�zW�d�����zY� ,�fQ��z]��#a�4�HD$"�!����dBDB��d��X�H.Jd��ߑd���cG��^ ��ұ^ Kt@>Jt���HB�@Dċ'\�k
�d�<@LD$'K�@PD$)"��'�	���ED�""y����ȈHfD$4"�����FD�#"���HvD$<K�@z�+�g�R@~�z��F�^)���1�^���5��J���(�Wj�O	�+BA�R��k�+��z�@8�W��^��P��v��ń!
�Qa]� ,�(.�(0�(2�(4�(6�(8�(:�(<�(>�(@�(B�(D�(FA�Q��0!�8!�@!�H!�P!�X!�`!�h!�p!�x!��!��!��!���<
�����P#���!��!��!��!��!��!��!��!��q7���q��K|0����xn^>��P�۾.��˫�6�>�+��ߡ�������9�{⳼���Z���9��(�
\D��sq��L��hp"�\�XҀ�;3	�wgƣ�W��q�GY�l����HH��_�l:����������,�V�lf�G�c�D?Vh9��R���6Żr^�[�[Q���oͳNͶ�U��K���B�����Y���U}[tn~�����?���p'2s�D*H�ء)�q����7����c"��ޟu+�50����s!UԿ~��l��]9Gl�g���}�OU�_G�#��꿲�j���L�"q�ةf���{��-e~��ݾ���	�X�Ϻ�����up�]�K�ߜ��eMꃻU���&S�a�_u�n�7~e=g�,�c�~z���3�ڽ���*��^;���F�`]���of��m���fj���>U��is�_c�M�����}Wp(t�z(�1�=����*���\��+۬�┚�C�Z��J�ރ�:\CŻ�f'/�-l*�ۺ_�9��P��|�w>���o��&���7xüCj�~��[&��6�3����'�fMS�w��6?����s��b��剻�Vk#���
���Rڬ�-��當��qNM�vG
�]�s|�A�Z����;���w�����
��?v���Q:}���y�r�˛�Q�W�t�4>Y�Bp�%�bB{}ʇ	S�h>�a�Q��5"?��w���j��O�=�k��|�C����ޓ^���~U���g�:��;�{\-5��d��S
���!n���?Q��)�v�w{�����y]1��L2SV�v�]66CI�Xq���51j���z]\`STjשԇ���\��w�*^�ɪz6t�E����@�o@����T�������1\��hsc�	����1��q������1��q�j�}:j�S�w�: "������
6���&�#G�<�/�
��D��Iްdj�	��D�"�a�B�"r��D�"r���CD�!"��o��9D�"r���DD2.""'����MD�'"ry��\ED�""g����]D�/"ry����|f=�iD�5"r�y�7��qD�9"r����g)x���GD�#� � � � �& �.0m@D}@D�@D�@D�@D�@D�@D�@D�`�}"M	�0�
:�x�!�&4��5u��5u��5u����#D�$��K��M��"N�-ya�gkz�ݚZ)�q��5ўf�r����������ݑ�7Ú������ӂ�$g�*�����?ƞ��nm��������_���+��]�s6����H��'p��;m6�uL>�|����GZ�UpdS�p�\����g�/�n4��>Ѻ��Ӆ�U�G���!��g�=.������K���~hg>�Гj��^6���u)0��O�������vQ��'��~�9�sj���yԬ�vo�JO�/;��t��%��#���])�����!�]bw
�C�c�x���!��C�;�8��HN��
�n���pG��a��t��q:��.C��l(�2[F��r���M�gn�:s�p癛���>4�s��
�N������UZ��]tU����tkv�l�S�����E��-3K����&��gV��U�?_&����ՙ�KN�iǕ�����9���#���)�N��:v�y�f���
GZ��ٔ�=�^8����GW��>��O4����F]�3C�x�Y�z��:ʹn�?���g��o���(�zT���iB����:��E|�/O���r�l���5b������Iѥ�^�'/���(ߏ�(�R(�(���S��Ly��T��<��x���}�@c�k�4��G��hw���x7)�סmC�R��z���R���z��.S�?J@�nS����
��7
�>�JUT��0=h��MaK��r�.���!z��)��WZ���������lQZ�wy���^����u����l�u|��
�(�CM&}�����?cqU��D?��W�i�LJx�����V8���I����j�ɂ�E�!N8�wu>/ݽ�g�0ڌQ��:�|X�x���7
�rJ��vW�<���k�r���B��:B���q�o�_�1�V5�u��_����/}�g�����x�ʠ�F��㜼��La�1V�<\�(	QB��͏h�R�ޝ|b�sB�K>����
���?�?ձ?��y�u\?�Oz����b��\��u%y��j��x[�dն?CI�UR�&(/؟��O�8Z�<}����0e��O_\Wpt��guP����ϸ�����|V��լ���s|�Ws��L;������|ޑG��=����0s�e��fx���C���ԇ�AZ$�{/��g,�7tH#�@%��!�R�H+�@-D�C�"��F�;�>����CD�1E,�D������tdX���H;$ 5��E�"^��ED�""uYj�""��W�#����҈�?�Yw�
~�8��@uD�;"Ri���GD�#���r�D�� AQ�4 �<0�@D�@D�@D�@D�@D�@D�@D�@D	ADAD)AD9a�����p?M�@ya��2��R��r��������҃����2��R��r�$	e�!H"�C�(D�)D�*D�+D�,D�-D�.D�/D�0��P��K�L��mHu�ڵ	[�E���h?���T���NI���[���0���`}�7O������-���BW��=��`~�a8��/����N��s�HdD$��ugxC8�k���
/�u$���i�1��?C"J�����?*}��u�����ˌ�����z���]�O��o��Kpn:ƿu,�y���;�iy\9�i���f�����<��J5��ԭ�V{��w5������̐.��ww�Pή>�<�C��C��m�{������iR������k�����l�hP�%�Y���w��l�w�vp����;�l�t���n�'�4vu.��~��Ky|p�xg�H�Zg�1,2�;��nlˇ��}�����ۗ_��vq���Vz:9{�|��=Hsz��28�1�?Kn�ߠ���*�wM�m���u�/�8���B�5�'Úe$�:Wh%2��2���dX��dX�ɰ>œa
e��ɰ�3�aM�ɰ�9ɰv�ɰk�eB�a�Óa��$�O��S'V�B�u��������'�J�Vb0�A�Vb4�a-:r��+mZ��A��V�a��a�M+1ZȰҦ�5dXi�J�2�F��$#V:��k[2�UdXwӊ.�.2�_�dX���c��am�$�(O�Us�a�MT�&�����xk��^9ۿ\u�Ohx��_=�{L��T:�O�Y��8�����~�o,���u�㱹��;]>7O���油�J�[�Ln�Ж��ܕ��O�55�jO�����e��>��S�?���g�����!�nN�\~�@Ad���g�,^��_}a|P�|�ň���m�	�����?�/�y]�=D��,����խ��|��5v^��E�W~��5<5_��q��^�u���n��/�����Ȳ�٦[=B��B�������[x�����������-t���^�ki7]�˧����5�6�:�����z�u����r%�^���~U=���e�U�c�t�?�/=U�	D�����#_2;�߿avh�n]�o��kK���ʳ�Ch�뿧��K��ʪj��
<\n�
�?de��n��]]�o|���p�O�V��_n�g��8�;�V�W��f�?Кd�N���χ��ʌ����?�R��,z���ߒo�<�1+T_L
�R�G]�hK׆� ��ԥ���{�o���t�Na�ޛ!�?W��7*�"��d��p�}kP��?�d���?&����Q�)����k�5�b�]w�		
-q�c�5�:Ś�l�ۿ��x��lk�����`(�/�9B?��:���o��U����C�7[���-�?��n�����9��3k��K>���uK������:z����g��=v�;f�;}WvYj	�
;��P�u��ܻXx?~���ԏ��G�)�`�I�8*E��W]���S�q�A���r�L�(;?��u�p�`������<���աB�3&�p��\�n����
J�b';�r�l�XA"�S�;;��Ic�[;)¦A�p��;��{d�ыN��G�Z%5k�k�{�4(;
�ݤx���VN7(6+��ai}�
Ի��J���g��J�F������Z�^c��hD�А�ؘ�ؠ�ب�ذ�ظ����Ȉ�Ј�؈��������B b b 0�`@Ā`A��������N @B���5�`aúN hJ��c�.���Y
;|�U�_,���
�-"""⅁P6�K� �/,M��C�D� D�0p
������!'W�ѩw��t�O������R�Օ���?���>��}�B�o��7R��OW^����/�ì�I��x�U�إ���|�^�Wg��.�.N/�7E���y��0������ꅜ��r�OM^`9�yg�
;[}]��g_���&��W�?����o�&���Zw�Vi3�f�n��@�1В�?�@D���&����q��RI��!D(��!R�	ݞ��;���-=�1�
��/3�ۂK��T�%���>�v��L�?������'e�U�{�c�WDx��ߊ�$������mM��/������zJ�o�w��;
W�.Y���F�n��U�	|��7�u�uC䱺�#m�~ݝ�W���\�a��{7A�7К4��d�������j��x���nK����t��M��+v0���T�7A�O�NΞR��5�������O����n�_nኹ���j�~gW*q������u��*0��M��t�3��Nջ���Y&��`0�*�p�< ^u7p����eU�@�U�2���az������ߔ��A�O�ɴ��*�=���?�s����ia_�����U��rd�8�W������?�:2��t:�>���mKwd&��g�2���CL|�?Iz�_�������W�ae�������o�X�E�׻�,�i��s5��j����j�5��u[@}�E�K˺��V5�[Z��#�>~���Ͷ}���mW��s8�{Y�
�Jk?i���i�vG�G]����w�t��|���=/v:��e���`�%p�]�.�4{��/ja	NM�B2�ZBc㴰�G,&��Zx�K�wC-����?i��mvu߽_���2W�5?��ޖ\��w==�%8��̝c�;x��b�D�1�Q��_Vk��I�؃jq
���֥i�O�w
xf�8��?s�8hc;���yI-ː�A����a�MĄ�{,	�~G�^�\�o����;f4r�^h�6)��
��:Z��3���>������m\z�-?f����w������������!>1F1N1V1^1f1n1v1~��bf∙p�%D�'f�!�B\1��⋙q�1f�!�1�1�1�1��!�1�11111&�ɇ�d&b�!�'"�("�)+�!VY��1��!nY�<�.���e1��q������1���!�Y�!�8C�sD�uD�w&�,H �1�1����D�"��p�!���y
9|��xG�K,�S�mi���x���А�������5��ܓ�^�܀��э����'���o
���w���H�`Z]pG�l�c��;�T�_4�tS�-0w:�Z�e���H!pY���VB�� 3��y!8u@AH�1!46� l�*�����"�.�l�E�<q���9��}���_ܧ�\s�������滞�[K�}�&}皣Rb����h!旇b��؃�q
�P�֙���V<3�<�B���A����͏/���<4�}aX���	�_�}jazD��/�~/��;�*|X��͂1��ձs�,�g�Y�2� iY�j��l�?X8ݜ�,�4k��6l�z�S;�&��5��u>��0O:�I��į m�!uJW���M�1��q��T�΂�5��Y��Q�
w�s"�9Ǟ7�+�n�o�;�[���n�q�(̜=�<+��0{\�y��o���տ}��$���m��XoR�a	ez��'�J�8f6 �	��#Ptj ��E*���d�U2�	��	x�L&��J&`��L-��@%)�	�7�	h%�	b�1x�( pL X@&@�4. ����&�E%p��L�S%���L�}*��f2)*���f2w�d���$dr�db2��d�2�	�S � d�P���x�d���t�6�	�#�	f��Dd�����^#���*�	��L&��	��$cDCD�!"��t�H<D$"I��DDD2""!���HLD$'C ("��!�#��!I���ED�""��ĈHdD$3"I���FDr3�#"������HzD$>"�E�ѣŠ�K~����5�+�%>8�kpW^�f��gζed9��ړ+�����G��	����W������@�_��S^5kx��۽K2߫�����}��=./�}
�W�r6`���7!�#�50����s!������)��¾��Cp����*vF��2�?�jv���|���F�?V����hb�J�y'��u��,�V�67r���c��i�箦뇘��;m`�u���O澉�+�.�9:!]�i;���תQ�9FD�{
ۀnM��W��7)���&''�oP��q��0��N���o�]f��}~�="~�?�gB���'�l���3��l�s��>++�������@�ܬ���ʰ�Ȯ�=`���2n��!���?#˞���U�0>��_��<���_}nOt�t�ְ���vo�Ѕ�4���]����.�^%b�:�%��ܺ���0"�E��'��\W�;����Ϟ�)����?3W�E�/�	���d{�5M�Vy���������?�U�K��Y�+q�突��Oq�>�is��[\�{�2G��+��=܅3#_�J��E�%����o�4��φ��0\�ka�p=�o�51���*�����GFV�5;МaOO�U)�C�Me��-�u�{F�7��9�ϤO=߲����~Z�����~�w��Ͷu���7�mW<.]l���]4�k���w=�],4�k���w�Yh~����e��]�\4�����\:�{��W�;Ok�
W�F�:��9��k��
�=[�\�R�jI��,��E�ɖ�K���xKJ�\�d��-��7����)��b���'N:q�2yIw-m�iה_-}�A�cx�&.��jri����f۵��y���/Ŝ�%��c������-ωygF[�/{@�q��e��TqV��e��8q��ū�\��e��q�7�v���{�cEeÒ�Q���x�S$�^^�#�C��SokF�P��a� b�0��A��A��A�B�0B�PbR�Ĥ�ˆ��$��}mdxq��/N��J��Ӿ����}���}�axq�W/��}��R�´��u񴯫����iS���fӴ0�1�1�1�1�1�1�1�1�1���HD�C�"R�!���聈AD� "U�.�HD�
"R郈BD!"���R�V�H-�@/D�"����tCD�!"��z��r�~a�?T������,�kZe[W���e��D��z���)�?{��W-�{���ki�����]w�[�0��v��+qz�+*��\%�W���j��tӅd���?\"^!���PO�^��X�?&-i�5-ǚ�Ȩr��F��	������S���z�xi��1y���^�r\�w�j��W�o��ì�Y��h�{z����Qv���P���R����F���e_�ٺ
ξ�Cp�x������k����s��5sͣ���60�޺��7����ܼ��a����
8�j�Z�k�ƽ��[,�Ze5߫	ȹ
)<,��U��B�Kr\�g�����.X��e� �gc���c���^�)��Y�I�OSv�33����>;�2Ӕ]�̙�4e�"���~�p�yc�f������9�t����뿣��[u�W��G9�>��Okշ����a�������x���s�7�ogi�f��i�Ζ�K�f��.˝��m�l����D?��P�0��框�'c}��1f�t9�����ό"\�Yp��2�R�岢.��p٬O.�!\>�������X��٧�*�=���2�B���d��[����}�,_���rxŜ6��]���v�jdN|��q��?�$��_hy�[_�vY^z�ė��nye�-�_}w�嵜_���<˚�V�O��
�?��8׵��S�כ'��>��F��k�O&�:���Hܤ5p����ķ?�l�sW�;��[�$ݞ���S�����r�Y����ĵ��u��\d��ׇ߽}���ww~��Q�{/�x��㙮䝉n��+���=����s�TK�W"J�]��V��Ɩ������aZ�h �T��,�	{�s�K��}�-�����-�����`2-�FˡU�eB�0C-�Z	[�!�"�"�"�"�"� "�""�$"�&"�("�*"�,Ch]�-�0Che��4ChmDlq�ȡ�ٶd��l[2h}6k"�mKQ��%�H`ےA4�m� "ضdl[2��-Dێ"�!D	ێ"�!D"FC��-D[}у���QĜ=D�M4��ŰJ��<��[3�[S�ՠ��\������/6\l��Ky�� ��F�ϮF�.h��s����|�%�\�4�m���m.e����@��V�@��V��9�}��K-�Kc"����Kd��V��"��2o��h�+^:�?��kZi1�Y33�����BMae�_������/)��(�
��k�叠��;���l�S<[w���D��=\�w����U�﫹_t��������\ZM��R��X������햺�mb=�*����ͳ�w= 6�l����*6�4����5Ó\��S׶�Ԉok�~�]7���8����o�ЂR��M�^2Y��S���ض��$�]-�	Ŷ�V��j�Y�#=��F��mk�'��Lc���!��nj���6d�Xg����c]�R2�z��;I=���̤�U�
��6�R��]4�ي��e)X�R.0��\`/K��b�b\� �J��j�P�WqS�nXU���s7��}Rve
�c�Dxg���ړA}����Y��=�����L�[��Z�Sl��*m�P�c������Z�y}�$Y���o�^\�s�k��7�X��[�}pr����!;�Rp�\CHfs)4v�!l����������.��n�>�v��c�~���#�z�Yp'?�w==\�Gr��OK}+rT�,):�19&:I��q�ۡ�{�QC\��R��LC�ojK��m��?�
z�7mpn}�����44m�6�O=)a���p�]fi#��Rb���D�i�o3���ҘC�ı/��ݳA�-����ۉ{g��[��%�3j)ᜭw
m�-C��6�h�?�I�ڭ�4�&]�M^{FJ۽K����R�/����%q�q��ϸ�	����osYwNj٭��r��Z��9\n�Z��V.�@m�[Q܌}����%I�^?�;��4�p0Eɯ�W��yԮQ���,;��Y���%�|�'n>�I���h�����e�!���*Yad�1�.66Ǝ.�(c�zi!�X_<D"EsMy��!�SO0��>#���g O��D����<�4��I��3���yj�T�!Z�S?ˑ��A&O=�#O��L��i�<�"���%��~L&O��^cT3/
����yi�p���SC�3O
��<5D<����SC�3O�[��F0O
,`���<5���0Y��40��40�!��yj`
��橁1�Sk����]�>c��v�Q�Lb�:�"�<5��yi`"��yi`C`"2�y�Ԯ�8��R�"�~���<5��E�<�E���SO�ZYɼ��T� ;���2<K�Le�9�$d,��Z�Q-��e��u�E���S�pLf�IQ���?��滚t}S��x�tkV��:�����K��a��st�O�?mS���4Gշ_f����T����_��_����g�._��/���{���6+��#|�9��&�'f['fW�ϐ�˭���O�k�pjp����R����T?�A�Ղ������	�vL�д=P��&'|��?�]���9��j)��<����ry̡4i�K�
�l$�[�̐�8/Y�:;����qAP�Dl��@Ub�S��H_y�_��
� O:�&7��:r��ҔG���_� 9��/��JSGgȘ�'evϐu�)��+���\�&�k�m<��!吏P=1���U�y���s���.N��U�����/�(
�(;X�Cv�S�%y��H^�$�l�����o�Q1�^cHS1��@�	��y�L�<[I�œ���9*�����b�����T�C�S1��D�r���4����*�IT�/3P1�KT�K*��4{F*�8*�
T�7ᨘ��T��Q1�W�b�G�|���7�k��%*濗��� Q1��L�R����T��IT̿g�b~�D�+*�s���Q1?��z�!�=9*����㨘����I�`��y��(s�W�ދ��I�tkj���\&��F�?�o�3��?+�Ϝ/��[<�.���!=�CsjH�|���H	��#L���v1$�}�%�jdU���J3�9�"7v��=[p�R���M�,��u�|i|�rr�]Ji�X���l�r�T�@)uo�l�n,�_�.O:qZ��d�!��7%��!}��9F�6�pSM2��f_�/�
��9�oH9ǎʹ-K�[��ygr���V�3'J3g�/���.�g��<�+U��,����c��!�Y��pf�B��k��!�Y���f�B��s��!�Y���ga��>�>C���,�
XcX�:���`�h��2:��?P���	�@���.,�emX��0���b4b����?Љ���@+���PՍ�b�(��?Ќ���@7��/�N}��@=�@?������,�Y�:���d�h��?P���'��Oы���f�\�e]�IQ��<�
��kK�eX��_�����,[F�-����]�o��T��+9�9�+1�����[�
?͵���e<_wH��޾����"OB�}_�[-����Z�5�^o?��^xL��iQ��g�ž�WJQ)1:h�=D���)�C�{�~H��ĸ�6�����c��<��~��+~�ly�V�ӞH�V^O�6t�[�9�~a\\�q�Αq�P$��K�
�!���52n�$2n4c���#�c7Q#�Jd�+�q[)�qs�d��Jd܆�d�&�a��#�v?Gƭ�HƍfbR�M,��¸�gaT�<mN���,�GF�,.O���������Ri�'���yҠ��8x�ɼ�qH�^���_�a�m��ៈ	罤�|qķ~P�~�%�‚w�6z�WP�>����
��ڸ����Y�K�y�URr�1��<��K���(���S�����^���.Ҥ_����qi��ڔ��P��#BA�C�j�	
���f����e��r"W�9�I�-批[�Jyg&�ӗ-�f�/Μ�-���"�7R��D#��ti���
����#u���%u���'u��qJ7m)�C�RǍ��[긡�_긡{�qL7_Q/�3u��qM7/P�������u���q�J���1"u�̣�{긙H��:n�S�
�:n�P�>P�M{?�u�t���F7
i��:n~��|���C�P��)��P��>�Q��Z�:n&��q�H����"u�dS�~Q��H��̳���3�&]�ɰ�T�!���PS���gu��E�ź��
����C���������E:_R�J�&S?�����ظ�'�8A�X��>O��$�UU?��#�ӓ�ӫ%��].���=%�w.z~k��=pL;9�'��G��
��>�Z��~}�E���z�:}�E�˙"/ܾ�K�׺�b=E^L�U��lW��n�[��G[�e:�G��x���o������E��=���,�e���΂ʊ��ܩh��x�f�#(G>s�J�7���Ԟa�u�pC��c�n��-�
�[�kalU�$��9����d�͝m��)��=�l��٘��x�����F44����'��7:6�o����_x��#��sv:9��y�Zg����e��]�Y���N~Q_98�1cHf946�6��l�a�^��4F��6D~�����w���{|񞡧�����W��u��
�㈳�ܗ侃�8�R����Θ�)r�/���bn0�5L3ĭ[j�j�a�3�?�$��|�9h�@y��iN�򐞣�Cs�0�΄�?�	��8G�>�G|�ݘ�wڐ���8��a�B�cc續�lYj��ݘ�,�`�?��\�:�S��)
W:m��d۩��T�r��	N�w�Z?�ny��1���0%'֘����`�S��3�
��N��2d��9s"U9����-Vʹ[�:��̕�/[�qx�<s���Y�����2�s��$�T�Z5jר�]
�{�@�n�s�HK��F�O6!
�6/����y��Q ߣ@�G��o3���5T�"]/:k��5�@*�A�D>k�#��lgf�ۙ��vf���c�D�
C��#ӎo+��5�"�9��<b��-@>��8���BDn1~!"��g��5D�"ry���c���?��������|DDN2^""7?���O����WD�,"���"Z ����Z �<f�h-@>���kf�����d�h���/h��-@ޓ��2B/�d��8�=$�r:���f�@�>0�t�!�
?X��I2�<��2�Ls�AW��F�ר%4~��I�?�P�?��&�����i�
:C�
4~Ph��
?pi�`����i� �@�ǜ4~�L������4~��I��h(���	��S4~І&��^��[��{?�.?�5�A����4~�b�Q�h�`���Ni�`M}���&�����J�
zG�se?X��	2�<��~2�d:i������b��4�������ȉ�,�DGFf%l�V��p�'8ʚnM��ʞ\Y��>�����ҳs쓫��-;�'4\?��c���7C�3H�#h�t���\����=�p�X�w�w_z��E��e=C��R��;ʭ��'��+��?�o�I�튽�1���{�H톻
�'}�������a��_���>r���d����.E)p�r�uC��٩2�(�������o_󺳘_vbg��{��p������_wƜM5<�K�W�hj���c�\��4	F��-K|�}0�'�KVo�T�M��
[���MUX���0��(�*��-1ک
���
�1PFݖ�T�Q�%���0�C6PF#{�
��hd�AU؇Ua�
T������0�C�PF#{����n!��
��K�MT������0٫��T���^E/�C�R6��*�E����ni`1UaGU������p��
�T׶*���([Z�c��t�[���K��
��u�W����B�E�["�tj�}���L}�-8:�M��7���Եv5<J�+����h�����l�HWs��^X�u�>���vIW�1N}�
��}���<��.Qw��K�`�x�XezƋ�ϰ��ڒ�Z����e�2�/u�W���~�7�W��;�\+~�+ݐ��x.b��3��2<�w���U+��yK6��
��w{��񿼢�ⴾ�I��=K>�R�4�H�8V�q�t�+�[7����>y����T�_��;Ԛ>ٞ���f˪��2���zN�on�s6������Z��`]"�fq�`YZi���!��{,JK���-���ω���Jm����ڮ�*s�Y!�#�t,�r�c�
`5���K>�Z��uR��1Z�-�K]��M�����f���E�k^��V��k^�˛�ڧh����>X�[7Ry�v��?R���5=jլQQ��4Gg�B"�ǒZC�Κ�o0�EEG_�N��q���%=;4y�⣷ɛ��țGj��#9��4��8��le=y�"ysv^"�`�H@��H��D�|�H޼1G�|�H޼�*H���5��ȓaț�ț'k���I��c4��K��Nj�ͧI�ͣ�g�Zc8������A����I�G""		� �5K"B$#/Tʴ��Wk�z��J=�/��-���[�ʥJ�ui�������;�l$H�&+f�;gf���|�~��|����͛
�͟�bmܡ�:"��Oy%8-r�E5q^��p��M���*rr��r�g��˳T����KHOMδ��O��|��4���ԭ�D��i�/�Vx��h��i�O�������q��̤�4�_PP��_������n�7�L�5�p$y�Hs��-�F�N��fIr�����gTs�V;w�v�ʪW��|׫j�r�����	����{���o��1��,Fm���|�~?��GoT^4�S�t��4�\���HW|�����S�_�@hq%Hi�s���d,�zY��fS �vrA��W����v�A.jp�o��<�ҹeJ��ׄ��D��Y�d����:u
ߥ�|!,��wm�%�w
��X�F��D�����DmJV�_m��X:K�>��d�z~ֈ�58F�T�{wh+�ɼ���&�;���C�o���������7u�ݵ�˫N��.�C<�Su��deh�Buز�
�Y0��o�@���{L"��	W_}��G;I���7F_>ŏY�^M��7el�������*�TgPԴԅJ��5��D%��wBV�>��na��~�Ε�ě/�,�&L:ӁϞ�(���?yh�0e�3���vTt)�O����-�+��'��ٓ�l
�����O�s���������NE��:�mY#�A�?qd��8d�I2��YdYdsY���,���,�9�,�,�2�,�M@y�G�+ ���GyL@�1�,�Q�E��#��AE�QA�OE9WA��#q7d�{d��d��"�d�3d��<��$Yd �,���,ҋGY��V��"=�=�-�EW�E.S�E^�E�
�HY@9\A���,r
�,r��,��#��B�H�Y$�.�G�d���E&��"+�"�u!��Hl]��,[< �l+ ���#�����2�E~�#��օ���օ#�"O��"�� ��TE�� �\�"�� ��, ��#�\  ���EN@�H`Y���	� ������H�c��,�7Y���,�$��B���,RQ�E.T�Eb�2�-d��!{$�,r7�Gc�"W
�"_�EN�Ev�E&
�"��"�d�����e�qN+��)�)Ii�)�%��	�(M��nyS_�\7���T���x�W�m�!7�
ʩ��N�9�[�����
�+�nvG�jT���R��W���|��㼏_�����5�8�a�JN�����i\�~_+�G��_4|�4���s���"A���)��-Bn~a!��Js��Ή|��ݸ���m65��N��k��(eO�:ҸVz��m��H�=��A��E���'�):B�Aʆ)��~HJ�1��e(�P@�Ю6��x����.�oؒC�ZJ�$?I�*#Iԇ I��$���$�[F�X�ރQ�H|	Ib=I�w���Z�[H��$^�$��$��HW�{�9$��8$�_+HW�H?S�$�!#I\��#��Oy$�2�ą<���2�ĉ<��n��A<��f�Ď�F5��L�D
��WY��KKHϰS������^���i�
�7��[��oKN����C�;���&�sD�5��ԜM���z�o{����`���6��W�w�Bv
���R�2��LH�G�����V��(�?s,״�aٖ���<�ó�p
hS�T��t�uW�N��0Gس����*�o�7�ˑ�o/l2�_��ta�;��f�%)�ƛ�O�&4]��#�g�K�K���q���f�i���w������	O���wu��`�Pt��e�xۤ���6��)��?RsL��R���}�:O�n��j�~�Vi��u*���7t�~��>���s(���%B����,j�s��Ζ�PYW~\3�������M�Z�}�]u��*��$7��M5K���&��GY����*[7�U�mб���-���tV�y����0��A缼���d3@��i]�&�%��K.�Ϝe
�}r�T����^˚�m�w��m���+G��m��*%�b`�����w.G-q;��z`�����7�ܑ6�#.	�,�&XpO��`�M�����y�`�e�%n\�Z�`�����W�\,�5Xpm���`�����W�!��&ku��`���%`,@X���W�4�'<[�DP.D`��`.��v���`>0���F���X��)`V���xkmH0�!#�=<V�i��1dT���e�5~��?�3,,-!aL	�?�
���������wR�'�Iis"K�V�T8���he��d2�?�������SF�ff%��B����?�6�p�I#�Fh��x���;%������~~��LjfJ�1)E{��{�}�'��������Q���W_`���W��0��˖�O���kٖ���m.��@��rb��ʜ�w�=�����a?{��ɜ�\ÞUL�O>�؟kWe~�����O2W�`��=��񚤎[O�O��1Bg��~,B^\�5�C�`!���V�ɕ��UX�Y�Wa����Uo��U�<��|`�@�}�E��-�,{?�,{'�,{
�m�=!�mE��B���{�ސ�`��f��^����Lj	|�t�F
��듐��b���x���/0��ט>Ƙ1bT�xc����y��RR���D�x��4�o}�a������ߎ�?4#iL��c�?�/���R��iL����=��?�W��I�G�q�?�~����?��mwΛa������/����yׂ+�����J�'����*+o��gͪGN�Xe�<��y�8C�6+��>����*[��@]8@r9/oMț�fK�Wzm����8�Lr6�Ʃ�0��
��0�ڌf(qM8�Xp\t7�Zq�.��ˀ��C���O�����W�\
^�V`����V�`�u0�u0r�F�:^:V##���$!)�t��������o˿��?t3�;<S���\u��J�*ލY)�����4���GN�Pe�T��7Tv�H�ڬ���H��{F�����]��_���g�C�B���
�Ϭ�^�eJ�S�� �[@����?�C��
��B��˔�m���2ep�L��?.SwB��������?AE�� ��zOQ���m~U��oW��km��km�����e/��e��ǎ�L�OH���~�
A����51�dl��8I���»�ӌ�r���p�����9����h���Cyy�b�S�Gϴ�ɺ�u��Z���L!�ci�^o\�Qz\��&�N`����[�ע�����4����X?�A|��Di��4X�Q����6�?�	i��Mh�_���$SF��k���@�{���4�� �����?��_��l{@�R���/3<�s��99�P�
(-�(�zw),�>�c;w�O�1�~�{X�]��5���ek>��LjʈR����_��c�����6�#��gŀm��m����+�����myW��!9�.Ȼ��+d϶y�����[򾼿ƛ!���A��!�"�]��e�����b������!_ɧ�mQN�>��mxW9ü-���V�*��7w��r��^�ğ_��]�9��nVNY֙�>)��arC�bT]�?C����.G���X�K���I����+/*W�w@���~%��Z��5ʵ]��_7����k�����2��#u&��ac��F���ភI�U��������]��Sk���VʝCU�[�(yk~�����4�\n�	���r�_yg����Wbpn�;��:�������Η=r�U�f�U�e*��8�ڬJ�����?$���ɭ�u�n��=����yג};�K���#^���d����@���A/��g�
���v�[�r�Xs��s�6��n�9��;/	�
I��:�_r�^���⃒�����Z'9��w��ֽ刓�J����i�����c�$>���=��YM����<�����}2�p}����bo]��r�/9)q
��q�.*�+��j�2�B�<x�e�Ρ��Yʰe!2��7��
o=��ؙ���'D4��F�>�ģm�������,?��An̂VJ�W�YU������~�"�Y#�3�P�Rg�鞛��^c䌻���\օM���܄���oFs�,�O:ӆ˞<�u�M�?e��S�{�9?�͉K������ƘzS�,J�T�-|>���"��\XLmh���/,�Qa��ZO`��%0�
,�X�,�[`��|�0�,��H���X�6j	�=j+�;�T�@.ݢ�Rяe\*���KEߖq�h��KE3elȲ�dž,dl�2�dž,6d�cC��6d��cC�`�4�!K]�����ؐ��xɸ4Չ���F,N�%��KU�+�Tu��KU��{�X\�����j�!�j���!�L���!�h��p�wiM��!K��!Kw����!K+�T��!KzO���\Uc�'e���P0�rs��ǘ�	c��x��.�0��^	�c�u<�1�2�\�s͒1暩`�5NƘ�c��-����� �dc̵E2�\;gc��=c�
�=L9s�xc�r2�\_��1�O�1��tc���=LGs5�b�u�m����Ř��s��Ř�l����Ř��l���b�uf6�\�%c�ut6�\��1���1�:�s}c�dJØk6�Z�Ԇ1ס
�\=e��N�1���a�u�1ך�\;�{��0�ڐǘ�c��1�J�B��^�X+�1�ꄱV25b���1�we���W0�-c�u��1ס2�\g)s
�1溚ǘ�c�3y��v�0�:c�dJŘk4�Z�Ԋ1�6k%S,�\Yc�9���R0�zQƘkc��e�����1W�O��1�c�dJƘ�q����c��0Ec���j����”�1W�W��1���)����B�p��C���3��#��#�R�Q�������oG���i�[PXЪ��z�b�q�E�فuoa�ȹq����\�?�%%��1��S_	�3sA��zG����+�nm��ث�tN�;lT�����Ns����!���Щ�.���a�}��mG��]
��{��0�ߎ�1D�fa!jp����Th�)p,'Υ){nN�ơ"��"��P����"9ơ"���"1s�H��*���@E�WAE"ɨH��@�I����{TP�`u�*�QX�A@FS$ϙ")+�I����䤑�	S���_���lLɰSX���_jjz)�@����������*[��:b�n���g/��t��e1�9[|�wO�u�E5��<�v���mZ{�Xm�:�=�ǖ���ٗ�S[��a~�#��[P/^>trf�3_w/yjT�3��_��w��3�F���r����"�Us�;wb��o/dĝ_76���q����,��>�7��u�.FՈ�ϐ�q��]���u�������3?��ǡ+�=s�C�\�y&���]=`:sm���_7�S��"��<�)�G���Z���G^�5"���E�hw���C7����ޒ׾�o7|-)�Q�-���틆wo7鞘��3��O��\��������m~aRv�+�%��|;��!7�$;ʣvnԦ.����c���ӵ�c�C��d�������>�pu)�Q�X?�dat������oWA���!z}��ٝ�-�c���V��C�=	��IX`O�z�a�]��)�\��Z*iX�QwO����t6��_^4�K�f|	�ь/2��%`F3��hƗ��`��^n`�h���������ь/>��%�G3�iƗ� � �_�4�K�Z�4�K��Z���͈Ì��H���Ìo�H�'�a<�73�u�0�[���b�z$f|��`Ʒ���RK@3���{W��<�[p|~3��3�����q��5Eb�wyf|_�Č�kq��Č�8�v�Čoxf|��>sid~�~���m��$%c�e�m�����.��ƸKb.�]�oc�%*�.��1��2�.��1��|d�'�Ƹ�!�.�m����ŸKz�]�ecܥV2�]B���˳�	�f��?�kA�}3�uO����@?��Oτ�#S3SⓍ)���IHI����P
�C����^�\���^s,׸���V���izqŻ���'3�`��E��jw�/�D��6'��e��M���������m�U9;B�j����=�5q5���z����L�H���m��8>j�R���
�\�a=��~���QQwQ'��z�.�!�W�1��{�[�z�zO�z�zO�z�zO�z-c���0k}����wM�HKMʰ��(��3`��~}��$���hL����?��{$�dd�3������P�����J��ǤB�MBrrjI�@@��?~A�G��-�ޏ���D1w���?o���,�`�f����+S~��P�XYt�	C��e;&���,j��R�Z��yy�G�QhfF)�W�d��ޱ�X���wM'8��)�4��b
���8�U�'��)plT~��� �ր�ZJ"����x���tjfRzVRrrBI�B���
���'����Q)�I��=���M�%���'d=�5 ��?�����_[��(��wQ���;�w�x�yk��/��y�6=5�C8O��'��x=,{��wk{V@(T�U��Ƶ���A&�0qlsU��? )�8�8�$������Z��Q�1E�������bN뎪�6|Μa6�g=3g���7w?�夫�^X(�_'	vN���&(���'�
����}A�4��z9��cP�'��O��R���ŕ�7�_.���~��z��>�������y���N��~P|s*�w�q�W��@��@������X��؏�s��nT��b���U��"�cMWqu�BW�I�Λ(��4W�
qu^�`ˀ�
����W�u�����6���tU�~�&�:�W�}���}��W�)Eb\�Ճ�b��B���%ھB��=RR�z�'X������jݗ��1	�����2���̴Ē���?�@-��(�?����?��Kͽ�۫����
���#�>���U������.��s�p��(��诛�̭���z}Q~�kr4�po6/|��r�;��.��i�㝒s2��s2��&9��{Dl�񁀭3V��:c���3���:#I����-?�Q�D}��E�u��&:�K��,������_lBr򰰤���~l�W_ ���X�����Ma�r]�o�xnqx����-Sㅏ��>�����+�6�+.�L1�rQ��8�:��}lD�^���|��8@qHߓGp��H�����4Jhk{�]���2"!%%!���_@A����q��_Bq���^a�7u��J!h7�$2��/�ӂg�m��aQA�՗2��1�%�$�>���_��O?m�G��E�ֺ�|u���?n����û�YG���|�M���+y����S����Q
Lp�=������sz��v���w�ȟv��b�w�V�h��Y�	����X!59)���_a��AX�nL�hm�Ki��~ϿKjRz��~������;�_���G��o�L�[�V�{CZ�-Zwx�������f&{�8��C홻[ڱyk�fQ=�i�]Bf����+�H��m�b�-�EAt����#VZ�1릾/VVVH�gw19oHU��`��3���7�j�^g�OL`j$ų5F0�Q��Z�3��7c���u*��u��uo*����}�U������W�VuY�ن�m��c�>¼h��m�}��s/��Bb|�~'5wKc�_�-��˴ܹRjuR[/�&���Gl;9Qҿ �&Ne��k��#ـ>7E�O$��҂
�w�	�ѝmw�,��5��sۘf7���Nsr��K�0!�ǤЩK�.��RX��b׶�����?����		[�Fy%�k�j!]Hѧ�1�3���u{
N��:�w�R��rb_��Rl������J�
��Z�q
.2q�����'�Ie]XC��	v��Y�$mf�-Cȑ,g����D��$�{̗"z�	W��D��b��8)ɥ�����4��o��d�
!9�ؔ�*�ڿ+�9AH�6-u3!3߱�sK�
�D̺p^��5_��s�4�f��ʲҤ3qb��7�W��'M��,������\ѡ������yO3G�&�1����؛yG8G�K�11������E��
usP�DR�n�z��	��
z.Iuq��Nj�2�L�@�,�bh{�H;�@�-�z,�l'.�e�uE,�#�����ҨG�'9�6��I.�z{���c�.�@ߐ�t���/���(p/���h� ,��*�\����,�X��#`J��� ,�
�Z��PK ,��j�� ,�X��?`��C`,@X�#�I`��4�x`�ZU`���`^]`��`^e�J8�`
��<	��0��~�f6f$ԡ��(�Po�0�7?�PoQoΐPovQo&I�7u"���`�fk	����@$��X�B���E�@!��zKP:Qo�aPo�`Qo�bPonfQo�aPo���"��O$ԛI"����X�B��fk�@!���'U��@/���Dԛ��F�َE��U�ɨ7O0�7�_�Qo~Ǣ�\�(w�_�Qo��Po��
ݨ7�Dԛ��7�_�Qo&H�7	cx�pݍ|��S+��F�&�$9��?��iI���I�i�����7����x����g���	�IZ�{?���cJ�||��~�Z�i�۲k�r�f�ó�ʨ����N�3��2��[�,��9�)7����'������; �b����[+��ͱr%�fN��?sn�79������!9��*[φT]w�co�6����Bj$-�j��5����R�9�y5z5�N�.\�r�r궬������ML�'^4���bj�IE�+~6����v�Ԩ=}��?�^4��7����wz��|��27w{K��ys�+����]�V'g�Z/[an�)��v�f�ۜ�7Ѥ�K�3�G���[�d�������M�]C�c3}�[�u���_:�o]sSs�m[u�$Ws�%Kt!�W̡S?7u�u���Ե�sx�I��?��G�^��8�W��.j���W�z,�m�>=������M�O3s:�zwH4��j`��e��Ϙbo�4�7�`�)R� O���~���u/�ta�n��k�!;?�
���Ö���1�f㌕�᭏�G$N3�{��	�����̉>Q�ģ�$������ͣ�0�Y��O�[��f�ӧ��u����œk�q�u�i��.��>��'������c���'x�Mv�3O�9��ʲ�Ig2Lٓ��_���4y�k�)��MN��;Up~�Q�����6���v�M�a�[rv�������v��ݒ�v����v!�]���mo{`���47�^�,�Mme�ko�}uF�(��e=Be=�F���#�|�E�D<��-�wR�N<�{������T�����x-���(�o�|�7<'^���F�m2��!(�q�j�n��a5x9�wܰ��d�1�;ϡ|5�{���	P�w1��obB�"�d�2����M(���Q����(�ҡ���G��e�wz���P��2��K�2��e��C�ˌ2~�	e�
3��7�(�9�x�e��	e����e|�e��L(��{@"����(��{@%��֡�ojF���J��_�CŌ2�s�#f��M(�7�Q�O2���^�2~�e�^=�Wt(�?У��C�ی2~�	e�J3��M(㧙Q�w0��O4��o`BE�QƷ4�����2>R�2>O�2��e����e�^�kz���P��z��3t(�s�(�W�P�3���fBo6��O4���gFeB�aF�҄2�?��E��G�B�2���E�G������u(�o�Q�B��Q�3���ӌ2�lBΌ2~�	e�3���f��M(�_3��61E��Rɵ��l,�]�f�r���O�ϔ�$�=��2bTj�1��.t�7_�U���5�o��?�8&3�X*�������q���u������Q���n��[�c�f�Օ�PG_~\����`v��e�Z�����fos%�[S��G�n�NSee���9�G�rs��;tU�m׳����Z��>�5]�$Q_s��g�p}�v��ͻ�Mu*5��-fҴ�3��y�h��)' ��?rv�g���8���` !	Yصp���pgr���5�r� ��;=%^�.�x��%^��q8*�u(�"��C�N���`Fi�eBi���]o3J�oM(��Q��4��C�Ί�)"8-J��z�v�u(��Qڽ�Ci'�QڍС��Gi�Ci�U���hBi�T��.̤I;M�iҮĤ�#��%x0̱��@�SqNeR�=����lc$��~��@���Q������	�S��]��,����i�;[nBe]�qͤ
F�so7�bh%��>Wry3�T�=&UZ�K禚���F��٣�G�\S��٪�6���s�j�$]���l��4]́�XϨX]�vAl��:�F}�:��tu�����Y�2u5����=	��陥�X��$�G�]�<rֲPd�Yl�ڻp�z����_���צ,���W�@����+�`!m&!�1!�
4P�_�
�W�@���+�`�!=�"�kB���E��A��u.��U�!Mg���鐿�c���ꐿ��_u�_�J�_�t�_
��_����0��0����94���}�2�f}l��X`���O��Kq����9��F�2�k�2��KTd�)�{����C>��X�1��r��K�/ָ�}.���X�ƥK�KW,�*�kh��`��ʣ0�~x|��Vy<��w�LI0f��z0��/]�o[�=��W�]R���/���mI�~�v�QSʽ��㧔�S��-p|j��eSX�4-�iM<+Z�"ڒ��>9�j{�s���?:5}XhJbB�S�_$�_H�w��!�9㈤�I#4�o���5!%+!�T�_!�? ���i�2�N���=�ﴌQúǤf����Y�����M�����lUb����A��5h�?��k���_{i�6�4�[Z����S��A�W������x�%"�w@i��ɉ*�[Dm5;�Qm�blZDY[篰+N������������\Dl��-a뿟E�j���Ak��h-��^�?m�I8*�M�8/�Q�{&��ט�0������5�_V��:�M�K��Ű�T�k۩���y�R�"
LW5��������!���
h��*�~m�y���]8/��?,!%�)&�$���5�_�����B�e��6��
m'�o7|����*�Gđ��`�iOf�#B��7�aR�/�%3�j�
�Q?R;l�-v���i���A��S�vm��U��/����������������������?�A��* ��c��_���g�����st��2>W@)�
���#z����-�?>W@/��k��^����2��F�s�}j힠���`��H�1Y��	�
LM� �?(����	i)������\J�������-M�_����r�S�q�m��(�.
�������Yn�s"��d7���A|�M͸��;��8�ā�_Z.����g������yJp�#r���v�6���U^:'�6*|�mir�9{��Kb��U|��q\�^����\׶���.��w��ֽ刓�J����i�����c�$>���=��YM����<�����}2�p}����bo]��r�/9)q
��q�.*�+��j�2�B�<x�e�Ρ��Yʰe!2��7��
o=��ؙ���'D4��F�>�ģm�������,?��An̂VJ�W�YU������~�"�Y#�3�P�Rg�鞛��^c䌻���\օM���܄���oFs�,�O:ӆ˞<�u�M�?e��c��
ˑ��k*P�S2P��9�+P�PXc�>�/�
�
UBd쀅�C�CT	�q�Jh"�J��Jh�J��J�#�JȍC%4���0�P	���:ơ���2�{{���Ȩ��WP	m�Q	�UP	I2*!�G%�&��ã��Q	��Q	��P	M�Q	�;0fQ	�;0vQ	�;0�Q	�;0�Q	yʨ�&�8TBCxTB59TB��=�sTB
yTB���yTB���}TB���*�-�/�zWF%�_A%�-�Z��*����
�Q	��Q	
�P	��Q	u�P	��Q	5�P	E��s����{�'TB,�J� �J���J袌J���Jh?�_C%�FF%tBA%4KF%�YA%4FF%t�G%4�C%��G%4�C%��J(�C%4�G%ԆC%4�G%�r��^����n�2 ���:�G��g�2/�����W��[P�������;[��%,ז�S#&������V�o���J���)y]�(�9i���+�۾���h[�r��l�}!�5V���6<�m�6�ξ�*�m���6u�b}��$��R�KM��jI-��H-7ߔZ��Yj=�����Rی�>~��;�,뗶��︍
賀5��
�ޙ�כ/�7��neI�w��/���:�&u��^�4=T��[
�X
�ڎ���Y
���vm�v���/)��wlĵ�lT��lԱCl��+�>d���bޚ��h��+%��f�!���Or��7(Y�������)�o�\�C/�yvc�]]x���g���rc���C6�C�����凝b��^��w��1���b6��i��Rb}IJ�i�4�N��th�4�|�4f� )��8v�̎R��l�$a��׻�6�6��ۀ���ͬưYm=�,�vB��y;��Y��jvұmR��=ҫޓ&O\%Myk��8U(W�ď�<�9z�J^<_T`=/��Z��؆���3Z�\�#�ƍ��qc2�iܘ�b7&#�Z2�i���h?&��ƍ�Ȧqc2�iܘ�p7&��ƍ�H�qc2�iܘ�x7&��ƍ�ȧqc2�iܘx�/�qc�	�%o@� ![j��c�Ȗ\��l�x	eK�S(["�B��
N�k(["��l	�,B���Z�$dK��B��[��g![�-�Ð-���iȖp�r�8dK�Ԃ�![�-��-a�<���0�7�GR���,Ϥ,�x'��C)["^J��Tʖ���౔-}���\ʖfc�<���dܲ<��"�f��є%���x6eI��o�l�:���)[:���xʖ��S�D<��%�-�l�U�7P�DЀ�%��%T�@YAj	B���l� eK-(["�A�A
ʖrP�DЃ�%� �-�l� 	eKM(["�BYA:	d�NFЅZ�0�%��� 
eKm(["�C�Aʖ�P�DЇ�%�@�-=S(�ց|�ɟ��:�2�ѷm�G��/}���#R�҇OL�L�/q�P`�o���Q�?�,�,�h�1)!5^��l��I�e���+_��3����e �E0�71�����;����ۗiI]���	�pNX���F{!'L	����h��4N�qB�:'|��	x�o'��O��D�=��,�^�c�Xcژ�QƬ�������T�����M'&˵��E�z�O�cO��բs^޵GH;���n+�"bb�"������'QZ�	l�<&7��{������w<>����+]�/gyS�f���j�T�u٪S�%6#P��#U���j�te�|PY������{������Rg��
U�0\��,]�0|q���j�!-�1�pp�F.Z��GV]�O�<S\4��_!}�_�^���*X��i���Ľ6���7�ҳ��V}*-�*I˧.�U'��{t]m��a�W�X��&��Z쉞!����<�#��UX������T�O#;��%N,8]�K�.�%N,8Xp��$`�Q�������v��h,Vc��-[��g
��Mkߘ���ע�e��_��j�_���S\Lqa����5���G��[�0���������-��h����?����j�`B��h�Yc�Z��c�����)���g��g��
	m�����������o	>�ؤ4c���l�������A�/E��Z��z�r�T$�ec��n>ẵ���_��_|�&����C�[�Uv����kQ��3s��{�PeϨ^�޸e_���?��r�Y
�W����/ǿ���xO�5r-�oCj���j�U5��J�ι���Gޖ�m7���U�/}]m0;]}!;^�%�S�6�Rwh��ت����MmZ���4,Z�q6�>כ��.���?�Ϳ��[�k���j��\�f��Է���x}|&�;d��6I�︞�����!�g4!=��.��K��(��!8���{���;M�;/�"���C��d�����=y9+���JH�61��qBV������/Ay������|,Ƽ5����^)<!"�b��b��bߠ�blt;�_���zb���8�`B2*���%��8��ۄT�'��!���!$� !ߊ�;�#�a���?	a0�#]׈��_�%��/&#�>�M�6FL>0����b��pB���t2��!%2�d���d'����~M&���	�gdb?,�b^D&�b����戓'.��5Nt*�\�B��b%W��nx�{�?*�?u�chgB�骢������X��B+:�uL5�?��2�4HV�zqj�4����X��V)����@���h4��!�޷+y�`,a6kK�'��9V��]|��C7i*��)X�U����~|,�/X�a���`����?��~
|,�7X�q���`��i*��;X�"�DP!�}��#�@-�*�6P!F�>U�(�L*
��*
��Ub�*
�x�X?�X7�X��B���B���B̍Z�j	�� 3�(�(<2�1T����`
foP��Q�}��-	��0{�[Ba���-	�0�$�0[Ϡ0�ɠ0�à0��0
�v��Ba���P�a�y�.f�q0�Y�����;���0Î�m(̰�<`
3�8X��lZ�y(��aP�-eP�a�y�@f�q��v�LDa��Q��Q���(��%X��,�AaVADaV�Aav��~�0�6���(�.1(��p�����[��:��N��?f&�����h	�0�Q��Q�uQ�ň(�F0(�ڊ(��f�Df>
�6
3������-�Q���(̾fP��,�0��AavXDa��Aa�^Da�YDa6GDa�@Da6Nd4`/>�X:P�i�<Ҙ�Q*�B�_@�_ ����:<)-A��iƌ��dc���@���/U�g�=�-˵�j�R�J�'�'V�bO����Q'�S�������˞���=�$�g���W�-�T6�It;��G9����d S�L��
�Tz�5c��-E�6�}�6��7�$�u5[y� j�g�_]�i׊2�z�����(#.�,�"XpG��`�-��k����g���j�3-��Ϟ��Yy���4:+_ѥ4+�s
��n=v
��A(����J�T���ecbZ�p;����<���7���'��/����z�9	�W̦�=�‡	W6���_�2�J��נZ���g�l��9��Y�n4�8Zn;�_���|�+wP#iv����,؀QOi6��7�4���\����(t����cR�ѥ��g!�@_�η$ȩ���ߘf���(�?�iϿ�?���
�����/��=:sx�hc��<��K�7�g�b���
�����+��펊�-���=���q���̑=}-G[fr��gi�{0Lſ���R ��(���-���/�WD�㾮8�F{�X���g�0�i�g�LjIL-��Ew(�YxӾ�����T�Ge(��P>��{�?eX�1-)%���OP����_�����6��$�����e���{�3��Yw��&o�������p��2�.(٠�����Xs�_]<�к@�
}B=�����N7_���E����O�O�?��Sny�nmݬ޾�Y��x�z���潾I`��:
G(��e�|��B�iY�s˷Պ)o.�3U���/T�6���T�*�����z�GQ���Z���ͨ+T[��P��m�����VwX9��(_���T�Z|�pRZ�t�+o~������[U��B�;�lp���5��'Ǫ�#4
�N���ӪD��*�8>Xp~�`�ЪE��U	0�^��W�h�G�V1��W�H���?��b0��
Xj	��p���h�E��~�p����CU3 �Q%@D#j	 �P��X'j	@��(R4�D�
,�X,�Z`��%�V����&`Z�X�
��r孥�W �K�F�#r~@��j��
��V�����3�FS��;���	�C�oߒ�Z�����LOJILHq���d�횜Ҟ?|��^	��cSJ�����.��m.%˚K��Ϫ��z�����\�=�k�8&�.�K���Y��$�hͷ���t`�6-8$�
��%�@.�_���m�`X/��_X��M����L�~d8��Ҩ�ϋ������w�%C\S͚j�Ts)��g���
b-�/*=9aX�H"�RJ���
�^�Rr�?"3!-%=a���?�/��ԞI=����NO���?��_�Ͽg҈��$c�<�������O���m�EƦ����
�T��Qq;?O��W���籪_���U�����^r�w��}�FL���γ�n�V�U\��+��L�.N����ݛ���>U���
��ґr��	�ّ�.9Bi8���(��Ҹ���b��J�z�䦕�*>Ε9��n|��\���7f���QRZ�ˆ�i�'����T�x���DBGR��NJ���3|�t�p��6J�a��\=�4#F=�Փ�Os�d�c��{���4WO���3`�^�0G_G���
�y�6��ƶ�I0�0��h�4�
�8�6$�m�*c��
�
#e�6$(m��1��`����ц�
F�e�6T���`4�@��
�9�6���G�
O��-qL�6H��
i�mТ
�mx���-�R�R_51��_���A����R��7� ��0O~Xg���Uu�/?�Q��tl�i�i�����#�\���|�]�A��W��#<\+�n���n����t2�1n�wZdT�ղ��C��Y��z���.fK����"&4��׭;�p��ם�[�C���gL�zF����S����Uf�c�[<�B��<	�����~�ᳳi���N6K{=a���+���/��/���߂4��h���B����xy�2�;���M��sM�l��\�b���X��d]�;�X��N���a�I��O4���[vp�Ln�7�3~B�8O:�ձ��|����~����f=O��2����^�j�O��Z�;t��%\��h
|�*⏨��4�1����k�8���{$%d��w<���>X�����p�?�r��k�i��h���k�j���:��׬qG���;��Mw�%g�w��;ܫ��s_M��wu�j�v�o=ÿ�^��X{����Q����x�����'���?qG��+Ҁ�ukc��k��9�?/��1��G�2<3�4�a�?�`���̴1v[�����̴��JG������Z��|�}3RG���<��!����4�_�����ߗ4�M���ze�5��T��ߡ�{�ƺ�G�����.���=�|>��~��i{K2���o��h�5a�	s�Ǖ|�wh��R�j`����z�O@m?�U�V��c|ZR��~�����9 P�U�����
����z���}�_]njǘ�z�ג��>�1�Y��5�5~�FS/�<�&��W�O��)m����.�W��7n�/���ol=e��`�A��o���_�3N=���tJ�jek^?��Q�?�/N���:d�p�A7��σTW�����	t��B�m�
��N�!�Q�N
�،@��/T�����zI_-[|�B��xN�
���Z�R�Q�G^����ma5ya3w���t����k�W�|2 ���Z����C���7��z�-3��)����ؽ�/��݉����vj�ǃ���, X@��`
�"�T�ЁZ�`%�RPKЂ�l#�ASj5hJ� M��vA���sܟ� 	m OЄ6�'�B�T�B-A�Na�%(C��u8A���{�a��E����
QK�,�X@$Mqh�CS�8�)��)Fk�^�]�ӌ�i�����
~��%���%O4��f��)����X����V�Y�����d�r]�
����ʜ���Z^��]������u�ɩsΠ�{dZN����镡`O��
��
V��W]���z���{N�%6��/�ž_����Z�:*���Sh3u��6�$���
�C��~iU���Ԁ>UC}Q
����כ �襁����~GS��s��Ä����7:/a���.B�To�K��B؈�j�&���0E��^�h�G���/5��*5����/NW{lxS�>�R�y+U�����QS���˽P!��Z���Tp!vk*Z�!�؍��~�遳��2�����Z?��ĵ���m �X�K�n'ˋqz��m+�cM#v���O�
T��a@-
T���@�
T��a�Be��B�ڵ*CA�b�Z�_A���P	VP�X�V�UP�X�V=�I��fq��E�s2�P�|+�`9*�`�)�`�(�`1	(X�
(X��(Xp�-�(X&�(XD
I�(X&(X��(Xp1�(X:(X�,
,M,����E@��M�=��a��尀�w�!��e����_*
�Uh�G�2]E�򦊂e���%UER�G���}��':��*�
��0�5�٩�������m�����%:�3\�q��5�x\�Ǿ�o�g�,����3F���1J�X%��h>�|���V4�~���ҹ6|����6��4�6�����?�ЩU�.���ҵ�><���y9�x�qm�U~�u�=���	J�
S�oYhۑ���K��d+��}�# �J���k'ׇ@B��}����ߚ�C��O���y���+v�8�[W,��qַ��|��Y�ҳ�:��-=+���Y�ڳ2-�8��q�Tp֏�q�Rp�o��o�q�gy��kS���d��_E�Y�����ି��Y�����rg��
�����%g�	
�S����8е9�	�Ii�v[����O_`����W��Kq���2:�r��{��y�qu�C�O��������zT7VԳ"^q�]Y���O�x/�xw��3���Z��Q��1�^�����h����,o�4��t��{=;��ֳ`����}��+^賰@�=tO��A:&(^�a���H�CfMǗ��?591*@C����c��ݾ}^�!�b�%��V'"�`�^��xO���3Ԧ��M�;����C���i�1����2�k���z�g<��G?G2�v
���J�'y��d���*�j0k����IcG&����R�����
�����_���a���^��ƶ�+�)?��W˃����Ka��[�9 ��:-�m�TN��;�$���f��5Yv���CE�ZK?Q�B���~��1�y|�P�/Щ��i���4��`R�~��;�i����=��Y6K\���ë([���C���[��g2md-�B��L吵$� k1��ZV���<�m�4���������ȿT쀊��Oj����v�c���3�7���Z���%��z��R�R�z,�3�i���?�����K�k��K�n��[���l�$-��P*t_�כ��_N��w��'���;q��S�u���n���A��T��FN��-��)��|El���z����bی
�>~��;�0�4�;�'��L2A�!��h21�#��t1�|_2���0�I���auo��Vb��b�%UĐ��b�ԖD����=�wV��Ll�Ĉ��Ʉv�Lf��D����!�R2y},Ƽ5�LB-�rd����sE�^R�z9�W��1jSޢs®t��_�+������xҟ�K?o��Ѷ- ����%����v�D{�WL}P$m�I��)'Xh`a��Ed��Ed�k�=2�%��"���"�Z28�I֡�
t�D�5���2�Y�)"��""�<'"�<""��!"�� "�\."�<��2Jpd�3d�sd���0�$���$�2�$G��$1�N�L���L���L�_D&YED&�)"�l�`솈L����!���A&�MD&y�A&y�A&�	-q@d��0�$�
��IN�qJ��yn��tp{��%s�(cZBzF)�?��@��W��(���\W���|�uk�?���.��M~�W����);����\�Oeעl%g�Xe���ʞQ���q!ʾH_ep#�@��A�
J����}�FLe����{6>/֪qL�]~�X���uq�X��<���7�z�7H58�K��u��B�	|�#�ٍ�f��fL>N0e��sݍo��[|���/���{��z�LדN��ތO�����������|hI>Tty���'�I{�e}!m��x<�`�KL�}dͿ5�C,ں�?��b�n��Rh��,��č��+�w.�
,�Xp/��b`��h#E�j�H1D�F���@��Xp=�@��������W�HYqIʂ�[R�S�g�{�/��(eA�M)"��,h#�,�� �� z�A�
.�,>�2�� YP3�,h
�l7�l��z�8�CV������ߣ̺�7�CVd]�;I��1ZcB�j�^v�U�{�t��I��SS��;�d�/� F�˥�ed&��h�_x��i�F��I�?٘o�/@{��{�'���w<A�� �?y��i#2�F��NMI��`L>1!E{�vy��c�3�⍥���!P_0����-�O�^�Z�b��M�S�/=���U�ܗ�i�|a-w�:{E�M���ƳW���}�<�������g��C/�^�r��k/����������믎t߰&j��c�g�g�����
f"D�o���}3����i�?ӻ���}K�k�[C&�����k��mgrgo���[���͙ٻ�g��2{��y���9<{ϷC���M�'��/�o�����~���:�V�=�3D�hqG�X5B��Ϻ�u/m���ʗx��B���YJG<�t���0�FoVA>�\�濮`����9���UXƋ�"���s8�4�ITY(-�%HLξ��=K�I���+�|fE۰X�꽓1��&�~�c�o�;&�vQ(C�~ip_���t%A��:`y���(�,�X@$j	*�&��=����>'�p��(zh�����P�9��?����P, 
4�FÀ�0(�{@7j	��p A9���v4S���y��QKÂ4�	H�a���"�*i�2'�
�I��5�rRKГ��4���~(�>(�>(Z��	7jS�Ә"tߔ{��)���<V���h�?�����1n���sy�ג�	���n�+���.�uWXnj�������~����W��U����6V71�k|��k�
�\^U�]>�q����ԏ���wdc��tV?�5F�Dh$�ޑ�O�ڪ���,|�-l�zHؒ�U����yuۙ�C��;��Uw.&�Z�5�]U�=!Y�3j��7�����3�z�@������T2}Y{������Ij-8�7ժ+ok��ޒ�|.j*�G{�q�뱫�k�l�T�����}�����zM&�j�O�u-:�ճ���{�v`N�2�GD���V��U~c�ӽ�O��#�B-��	�PH�*@�1�3ezXC ��	�PHp�*@�=T�AhPQ.���**��Ζ��=`*�P5�N���;]:����`#!�N���
��U��PBK0
����<�bA��**���֡���C��bA��Κ=qGM��������*?���L�H-�F���c�!���!�'��)CMjʰl�h�e�&KԀ�6*)=)Ř�0�� ���?�&���Ӛ@�Z�19�^�?=V������i��4����
�u�k��
�),9uDY���������[���z���A����dC~]-� �)C%���O�';�J_G�`Oտ!�n�P=��(������S�ϳ��[�'�[[7��oo�,^�޽$�y�o����N���-}Y(�e�PaZ����m�b]���E��v-����ҍ������I�+~=>;#Uy�Xu�k�$V�Z*U}G�>����F��eC���ݮ"�N�,��rƪm��v�X��'�0�v}�튱��G�'��(>T}�z�V�U�Ž��TmoƼ�������&��_u{+�T7�t����S�M<���
�V��Z$H�O-D��,�X@j	J��hA-A�����,Ex����	�&	�P>��y��tP�~�i��PK,�X@�~	�P�K��I�BT�$�ꗠU����%�D�/A&�~	:Q�KJS����ԯ���k�q���z*�/:sB��ᩙi�����/�%�O��u��߭��Z@I���~����̕5�{��0˕}�K&�'���,a�Cfm'u�˻,�S��;���A����9��"�ۘ>�zY���5}�e�R�wӖ�����~m���?u����~�ݎ-'u;��2�Z�.gI=��	u{F��퍛��׹�i� ݁��u�N� �q��^W ��j�W|rn�u��Z=�s�:G�f �.���!�Lk�ʹ{��ADʾ'���6T�n=�'�O�ӟ�9F�E���Bʜ���k�k�n���:
�˼�"�;x�)�"�K�~;&�:��T^V�-��5�yK�Vdjf�Jeei:�.�v�i����ˬ05���l�1P@Ʀ�a��Dv��=��>�����&�@+4%��V��P.�WQ�������t�^�><��>�2}�%�^/v�Υ�4��Z�}:XθO�2��R�}:����'KpA�؂��,8|	��N���t�
	N�*����%8������t�n�3�N?+��`���Hp:�����Hp:�]	Naq�����/���ӿ4�'J����a!�t��2k2}�X;������}2����=����|���(�z��kZwp��ڍKG���Ծy��=���ɤ���ҁ~S�S�r1[>/�kq+�@���bA���F�n�xx�h`�fMŁ�ŵ� n?�{E�.�U�� �B�LjiA�вWœϱ,�̈́�]tt�/�����z�NJA�.+�]��vy{VV�W��C8}Ƚ����4�!>E��W4y��h�QN|���$~V%1N|��d��)�"K�TE,7"X��[)�f�HS���O�?c�^[�wk��(��e*�G_��r����Z���KV�m1
[l9��߯��뷇^Kg?��QaM��1Χy@�~F~���J�G�]�	s#U��J��(�G����7i
�ƃ�MT�n�@�e���$�#��*��'�q!���Ɛ�䱷:~�%�1U��p������|:�6���S�(��Q$^F����l�x���U���tV����A���	SC�B�P�Y�@��S��#ԙ�ϛ��+�_�/��e��X]��A��%�/<�%]�y�[�*�G�O�R����u�?�_���N�^���r,�OH6�g�����Jς���v���ϴ/���K�e��b����z�}�(>�K�����ߴ�~��K�G��~Pt��Xp�S�=�RO0���=�})jFXw���ĕ�޵�X�"��_C�0���|����ۯ���`���o����x��^f��29�L:�D�<�F����C�ަ�^�_�x3���E��u�x7E����������������}ϱLL��ĄebB��u$�Zj�C�G9�de�zi��-��B�K%S	�߇�?��
_�;�é��;�o-:o{��׬_J�}"ގ�>/'ۏn
�{Z�}w��wok�o:�8�2��W��w^d�l�7]9�o�$�Ͼ&n����Ř��
{�
U��4�]2O����A�Ia����*p>��@�߀��NoN9����*�zV�k�_W�w��N?rU����5`�Wt��-�Ŀ�R'>Fg{���)����!�U�����(���?�H|���|��NW����و�R�M|�{ZAa
[P�4�t�0GT��~�J�|��U1�
��
��O�?t\����/�$�I-�oy��†�-/>n�,�'�8�eS���Y���k�:�䥮�d[䇒�={I��\by������-%�w�.��Q�䕏OH^�6J�e��h�T�j�e'�lyð�RѾ��ZL�}���z��o�}�����x��U7�'�N2>��|d~�3��D�uǯ��'�K>K�a9�h�|޾���!�͟g1j�䋿�[��J�Օ��SM9ɩ��'9�Ck�ׇ�J�9x���Z�{��Ķ��a�����1=-�R͖�!��"�)���?��!߹��,���_���*�����q�k4��C�'a:�=d�5=ř���CǺh�
�U����-�9ф�4'"\C��
�� ����S�S��)�`װ�"����-@8� ��EX	�P�Ez!����	WQ$|E���"9,��*�_X`���y�2,�l�";-�)\�V�p�[�}nE޴�D�"��R��"�LZ��&�E	w�\��'�E	�ެ�p*�="�Jg��p�
�����Hx�"�Z:�D��"�\:�Dx�"�^:�D��"�`:�Dx��8��Ƅ��������h:�Dx��>���O�����l:�Dx��:�r^!�r^_��G��|�s�W�!G���V�?�
���}��5r|��S����r�~;�h���3���y�91�_�����'N+ퟥE�� ��}�K>����|�������g�B}����堀@���cA@ŵb��`���&�{J�8�+)�G�:����J�W�Z�t-��'o���J����B����T��Hܔ"qU��fg
/\�u�:q]��}�}7�l��J"n�����^��d�p��]��tek����zo-��B�g���
�L�>�M���q�<�w��p�H�G�2��M8��^�T��i��F���E��<뾞�����eI���0��lX:�4�'n�e�J���;�T�J܏��q�
�(`�9
(�J�$�M�`!O��{qɡ3o'f�<�t�#2r��z_����I�e���CF�nN���y��Su99�\/M޲���#�W���_��Ŏo���N���0)��s�o#�m��K>T��ɇ�z�+8�75�U�d�
��u͏�|��p`��A
B�n �G���ȣY��A�U���y%�JO(Ģ�M��m%�{J������q�⼆�T����w�j;�up�Y�ʥ4U�Z��*�V�stzN���GhK<��i<�*��Ϣi�.���xX��1�u4M�3�&a�o`��Y�$�CB:T�tH�̛P��W�_�<y���efx#���'¿��/�B���/���1����ٯ�����U���D���K�'#^1>�1��r���/�'��K�?�w�3����G�/����jh9����n�*�ˎ��rQ�~��hp����W�k�;�5xĥ�;�V�[d��(��	s'B�p��kry8�6���I�乒�+38_�k��Q�KQ�{|A���Ϡ�,�V���Q����t���<oQ$���y��^;��\�S.���\�=�n�_�u�
]$��.j[�d�/��5T��ֲ�/�V�s�C�Y[�Vć��ȷ�l5���|�׈��!����O�c:��hFc������v�"f���E���؞�i�ve{my]�����im��լ4�P+���Mnx�*�x�v&,��� |x��?Ї7�IEdar��5�NJ�ds��u�+�)��H��UV��_c�7|=�w��9���ٰ��&�CW���q"���)p&����쭘����[���F���<fo�򘽽�`�fa0{{�����7d6p@���1��
c0{�a0{���tJ�8(fq�,�∣�,�8+N��bw��,�u-fqE,fqOk1�[�bW��,�UfqX�,N������A���c���t2�����N�����b�5�Ö���W ���$=XR(�w7�C���9��v�_r��b��K��*y�9���_74�.�+WQ
���H���os���`������q�~�������{�,��ǣࡑm$�̔�� l`��)�6�7�y����+�N��j�����ѵ㫮�^[a�伆���~gH����.��]���ҥ�7|�w\�K���p����S��EW�:/�o�6�ީ�0�I��V���mnu�ǹ�#\�V��p�M�t��G��*u�����ά���'��$�, 6\JQ�&Lf
i�]�� ԨU=�g:�Y?���ΨI�K��yf��kȚK���\���,~zP��3��-V��l��U2���R�����u�~��.���˱���a?��Y=r��zl��	�w}!_�{W�>��$��%�o��X�~�H��x�~~�۽��e
~�sMyͬ���%Q̐�?���&$���O��H������I��Ĭ7H��Gb�Z�6��:��j1�=J_
��2iQeF#���+*T�
�2(�ŔbB�ϥk�C<�l��4��r�Sף�
�ul/��&1�i���T6�2��	ݸBL�J2���u~�q%��"ʹ0�\oX�#1�9��[ƣ�ˠ���QΩ�s#y�s��(�z�(�<ʹ�<ʹ�<ʹ(����Q�a7������N���q�5Z�(�1(��2(�60(�^�Q�-f�F	@�=.��\�����:���<F�y��0�����	�f�;�_:�m��ś�N�y-��j����{_J�=Tae��Ի�ޯK1�z�}�E��������ԍd�{��*��3��6��S����YtT�ò��a�U�x`��}+;�ݥ�/��E�q��
�p�(�0
�e{�"�6ԅ����g0�|��
��j�0��K����n����ӌ���5ہu� T�S�ʃ��"Li9�*�������7�P�JR����dd�i�o��a��T�A���J�Z�9�+���/�o�㚎�>�2�М奵_>�{�,���.���ֹ���Gs!�F�MNdۛ���6+�ƉB���o�c/��q�\h��ؖ#��Zݷ�m-����Q[f
���6��kva���љL�m�]��0-��Մb�2�ka���,5W�	n@a�+T4nA�נH܃��H܄��'�B��w����e� nC�D�%�!�gp!�$����p' ��%.���;���Z�{�AX�b8w>�Ź����`����}�Ң ��1�?�p������]"�%�
�n���r^nz���*&���!�^7�{����4�,}Zo��G�JU���+�$�W	����$�������_!�
���	p|��L$�JI�d��_=Ƿ��}ڦ�.�k����A��ߤKieҸh�TP�u��B_���U
�Y]�������������1r8�k�X�ޗ�e�����q��
�Z*��a�__�_v[�_���:�D��#��J㿌�����G�e��xg��_-W#�������{��S���u�F��`����R��9�o��*�2��B�7����og�k���_�t6���|�3��t"i8,��r����O2��Se�ns�g>8�R!��[Š�7��|�*�5Q�0�Pe����q�̼|_���c�G-����]�4�q��gK2�>�6�u�-j�e-=��ƍ�w�"r���9<3Z�"����++��5�9 �Ś�D��S�Z �R�O��d�E����$���g�s2������M��K�?"/7/�0��_�?�L��'�rr���d2!����b�����h;��������?y\�L.D溎��t�:�+FQ^�+�2��~���r\S�����v�9�5��S��fY�n�_��?��y���_i%�ok:N٧��s�
�.Qi�F,�vk��t��j#��t?�����5=Ϗ�F���5����y9��9[P��we!�p
�>
 |"@�T���h�A> |B@����I���'�O
�>=E���
������"4���V��,JY���:���R�4�����A)����
su�
��J�B��K�?���큂�������f�
t\a��,FV���R�P��C�o�/����c���~���_�H�ϰW���Ƭ�Ll��u�B�u�����j�|�uj|�w�N����+[�V�l�V��ڴYӵi�m�f�h3��}kf�N��[���Z}�r��~�f'�9��Y�D%Ys_=g���r�>�r�Gj
�ۭ�������j���M;�i���1�1��v���څS/X�2E�h���}����>�ls-��W�ü2���p��=hh�z� 3��<+�7U9������Jgc��fý���t t tE���!��)��1I�BB'BGBgB�B�B�B�BR$�I�t& t(Eҩ�бI�BS$�
�
��@� Eb�`�Q�aP$�B�	 
   
   ��� RAP�+E&�-��3{+j�9�T��uy��|��)<�_����'�?�\�F]�GQ@�7f��2�C�YV��m��r���fnj���᝘��U�W����?�P���I���r�>�Sy��P�����W�ǁ���X	�����O��o�4+��_V�{�sz�-���O2���}���;����
�Ɯ���bdQʳQ�Q~ώ���2z~�v�߶�ٞ�a6�XM���=۸��
���߰�~\f���Nv҇Y��ְS^[�N�^d��d&;ݴ�6#/�e�
l��Q���mi}����cmM/����cg�4�e��f}��M�
;��c�좫lγ��昿as�?m���[�Νt�fЬf�c+���m^��cƳ�<l�o�e��N�-(g��`{�jۢM3��-~d(�P�_��zP<��e��x���ܦ���h�l@0�0��[P��ʡdR�,-�4�_�N��$WZw�z�*t t�t t �Z�Qr��BgRr 
�
�K�t0 t2 t4�x4t8�;��jT��4�$�O�Nb4�$F@�Nb4�$�@�Nb4�$FA�Mb�`4�$FB�Mb(�`,��м�
 �;��м��;�Ѽ��;�1Ѽ��;�Q�|� �7�����|��
bl4�$G� �;��Ѽ� �;�Ҽ�"�;�1Ҽ�$�;�QҼ�&�W�Y>�E�z�(!/�"����̼�����*�Z�S���/H��
>����<����6�CO
T
"�A�e!BLF!O�L0�����!���PS���4��b��f��?6.V85�!y��:}�<}NNF]��RQ����d�����+ڤG�8�fOD��S_���@|�1Z@v���,6ù>님&�GY�(i_��iU*8�q��t�1�tY�/[��3r#�3r3���9�z�V���������5�7���қ��ƚ��
f��2�g.�k���UIe����kZ������ݍ'��n�r��J�}��?�|R�
��/GW����{�����������0Jc��S����P:�ev��п�Gi����+8z]���<ì��l���R]��o���}�r�yM��\�7j�IV���8�ُY��~�yHb�^X��ڡ1UܭS��EE���YV��pf��t������Q$�����=ޕ�A���}��G����M�_�qJ�?^Ŋ>���x�]��妏`pI�;�KKg�d�y;�u���`j2�s���S�{@~�V�����!��Խ�ˠ�[���2���������wDto>hwX�K���lX�4I�a��&HZ�g�N:Kء�����[·OZ�}WK[S�u��khi��n]���-��7�u|�����mX���t��u�'��v[Xd��H�{aPѧ�Ǎ�c��s&�5���,\9-�:笥}��|̶���C��c�G��M�@�4 4E�$��,I�B�P$MDۘ4�	�T��\��d��l��t��|�Є�Ќ�Д�МI�B�R$M��r��J�љ;���tY�9>���B��Q���GN���?�0-�;�j�
%����l��pN����r�'F�Y�I������Q��`A��i���X��m��%ɮ�1��
fC�Dz%7�W���V��p��r���ᾨ`�+����=��}�m�@���+4�j�G�)�*!���Y����ST��]FX�h��+1�d�"�͍{�D����c/+O�-�5z[Ww���[�۠n^�[��kN8�?)/ߠ��/
�J���?�K�eZ��L
�5�YGK��v=�d"��{��w�f`u[% �-�o�T��U�m^V.�����{�j�J�r��7��?�O������R&��W���n�.'�+g���eR�oޔ�n����]h��WP�E-��R�UZ��,۵����Sxո��:�/�|U{+�l���ޠ/���y���x�!a���+���?-�]b�4xPB����ತ�sŰw�q�+q��u�x5�@��w1#(����S�;��ԣe���r�����a�Yh�������
a����������>
VH�����7Aޗ��1�=V&�O^�F[��_\� ����F�_!ej�B�����Π���
�b�����/�nA�o���/��⯚���(\��y8�0���,}��7�/�`�O*��%�W^�S;n/@��C��$�
t$[�kn�?o�W�����anaF���?�+���7�F�O�� �&�0�ᩥ������;�븾�xC�����{��[��P�����#�O^~�0W꧷�o�W���	E!����v���K�r��������Y�A���^/V�omS��E�ƾ�5�Լ�-��fl�{�eS�m�6aG��iy����mL�'�1�ZSSbS�Ͷ�W~̎_�l����ą�m��d����N�柶����wVئwn��x~����+�[�8���36mV���n6c�(6��2�I��o��
Z��쵶�?\f����r��ms�&�r_�d���r�Nڸ�YC���d?�`�:[���켘�켧�f���e��6v��؅S���r
�h�����.n[l{��lŧ�V��0ۊ�-�X�f�՛0/�
W�.�k���k�{(�.�n�H�
���
��R�>���)����K��"�R@�V��k�{)�.�n�����.�n����3�HĹ"1	@0��4�<(3�HL�L�L�L̈"1%@0'�Ĥ��(��HL̌"15@07@09@0;@0=@0?@0A�:2��1X:]RGL	_~�5��?�.G����g��T��UH!�W	���.7-o�>7W����S*����������.�t\��
�^ٲad���}��M7ys���m�Q�Bѱ坌�9�)�IgQ���)�A���@S�/:�5���hO}S��C��/JD!_� j�P=Qӽ��M?'����y܇�����o�N�#
��qQ��Ѣ�!fSX�lS�G&Sx@�)|�lSę>��˓M��mnj�`��óo�$���:�:
�$ꬿ$��i��k�IQ׋��"{�E�Lԣ�:Q��v�z�_(�Zw����3�h���;��>ך��'�d�t&�a�I10ޤ�ޤj��DR��zCSlD;Ql�k_�~}����~����:#��?�����-�D4h�V�&c�h�$�ŧm6
�)!~�iX���Ι���S4���/W�F~�H���Q�颔gG�F-׈Fϗ���T�l�i�6�4V�ǔ*���I��Ƌ����4��9���>7M:��i�7MS��M�~R4m���=��m"6k�H7�1��Ei�٢��SEa)�Y͍���)��ɦ�3I&�����F��_oo����4�)Ɣ�j��7q����N�!2$�E�}ψ
z��y_4��.Ѽ+[E��?#2�{�h��F�·�v�1-ڴ����y�ŏd�2L4�j���5|֯���d����^��zp��T�4�V���e�3xV;��sU�L����hQ�G�H���h$E�8�oM�������٨���H���q<���)'�2�8" 8# 8$ 8% 8& 8' 8( 8) 8* 8+ 8,Eⴀ฀ༀ���#S$�
N
�
�
N��N�O�8? EB�@	!)19AIP�'Dd����A�2B 	��	EB&	���������
 
�t�x�|��������(������D��7���h�,�/��	a�l�� �	y�Q?"$DF�EBf	��Ѭ�;�_ 7�5��Y#!9�5n���Y�	�H�f�Yؿ@~�@�4[$$DH�EB��@�4[$�H�W�_ G�5���Y��ؿ@�4k|
�H�f��8i�H��f��D�Hi�HȔ�6د@��`��Ҭ�,�	�Ҭ�-�	�Ҭq�+�.��~�u�EA
j��� ���d��J�c�v#ʿM)��]C�:8��)���
�B�$O�b��'P	�jU��������Jc��?K��/��>�uS���߰��p�1����G�4X>�6�ܨ�UK�=a���mYzt�j���'���$Â2%�;/���%��tK��Kj�p)��f��x<��yMy`�Px[]�B��U�������(FvL�:,�!u�83ꨫ�Qa�13ɇ�z�|p�X��m���"���4Β�H���V	����pR���ק��q
���*��g�0��/����_ڰa��~8�
��G�#o��?�֗;j�g�-���s}��&mI:���7�s�o�E8ߨ�w|������_lCҍo�&���4���ߐ�bI-��b	I)6�tbI%%i���O/�a�����������3����v���l�;<�������א��9��LR�I�)ӭ�"�_#���O�|��|"�?�{�x��6��{��)�#�~,/�6��T�b�^9�5�jמWˮ���ъH������:E��"�I�>��/)����}����D~o���'�/�%�g��n"2�i"��y]H��,"�'I=���DJ�$2z?;�����j���6�8I0?��U~����.~�O��(?��~�"~�ޯ�$����)���"��"�"}��M'�w��Èԝ�g��3�g��돫���v�_o��l�s�W�\��|w��f7$ҵ����D��"r�0����L}�H��<}�HS��ҹD��$r�	~Ѧ����ŏ��C�����k7�_�0�E��C�]���М�
3OVf�[-
�0��3;��7383�y3}9L��L�#8L�����7&���~,E�3L�i�~��"�9L���1�o�`��-E�AL����EL�71��`0�_�b��&�����b�?��*����g1LC$���~w��}:�Ȁ/c����t1����L�f0���t�S���x�։�~�a�U�}$s�L���1��c�?�"p��cyL�'��xL����1�oO��}��t��i���g�L���b0�?�`����4�}��%��i�V�ۄ_0�_�`���\�i>�p���4���|�W�!L�_��0��~^�4�'�!��i>�+���د�W��c�oa��?�oxL����1�/�1���4�x
�|�W�7L�_��0��~��4�i�0�|�W�?L�_�1��~>�4�x���f�W�GL�O���( p%���L�_�71��~��4�x�|��(�b�?��4�	�|�W�WL�_�g���h���h��MH��0�O�����B�+��_&���������s#3���'�k;3�?��=�����?!��|��vL�A�1��Z�M�F�YSa~�Y��G�J��{��{�\���}>j�B��+[��5S��O,�`����h�W��h�W�Ic}����=y����`���ӭ����������k�A��$�[e���eC�$p5r>�+e��	C��'<[�pTo�G��4O�?��_�T�������7�<|�-�8��T9� �Pa����v�A���?h�qr��Gh�A����Oh�A8���W���/ny��<CM�7+�3���?7�3��/�e�ey�'�<��[�A��-� ��g��<ϸ���7��ؼ‚,_�)�1j��?�B�����V?�t[�՛��p��m�ߊ�� AT���ڿ:^��K�8����.7��"�^\����%��7]�G���K��-�#�P�K���~�R?�-�+=�10���p�
�r³�(Ϻ]SiϹ�OX�Ww���Œ��|o�x�R������_���q������C2̓F�,�hQ�0��E�X����|����Α����Qy��R�T��|�E9�����ڶg�UnU�7v\�K�VO����L.���"��Nܕɝ-B\��/�G��*�
������!�U}�o��
�N\����O��d��C���n������U�L5�N��?a��0//���:�
�}���G$�F�+T�����|�5%�пg�Z�jJZ��xVX�iư�r��÷�ʊ8���v�4�ݻ�����:<�r�d�u�?2v���Y��K�\{��J�^<m�챭$��;��+��ڋ���K����z�0��/p�w�6���s���FٴdNn�mT��)Lj��vbN-�dT_���F4-���$�w��~��p�O�(���}�]%qKw���D��}�o�$��ik�C{�����
��<�8�ϧ�#~ZQ��e�}�GsJ�ޜ`O�6�$�پ�Q�e%��Gص�(�l,7F+5�Մs���q�q�]6���-7��Ɖ�s���5N>�����d���O[��d��b�a\W�f=b�M\X2sD�=-vjIz�a�����Y�Ӹ̀)��_��3�����w;�_o��l0�1����g�yܧ��Q2w�y�!�LI~�����y�>��֒yW���?�����K�5���e�E�8��Y�ŏ��2�4�L�Ճa�v{�Y��:L3Z��ϊ��ph��>˪g�N[u���f��ZUS��ԏg�V�fD����Zu���,Ԫ��U�Y�U�Q���P��\�Z��P�~dD��ҎZ�l	j�\;j�JP����V�V�Z�;j��JP��hG��]�Zu?�Z�dD���Zu��*ϡVM6�VM�P��6�V�͡VQ��9Ԫ����K�U1��B�������Ԫ'�Uw��V�eG��L	j�g�U�0�V5�Q��5�V]ˡV�oD�:��Zu����vԪ+JP��Q��)A�:��Zut	jվvԪ�ԪvԪ���Uc9ԪR#j�p�j�3�2j��FԪ�r�U�0�V-�P��5�V�ġV=Y�Z�_vԪ{JP�Z�Uו�V}ĎZua	j�t;jթ%�U��Q�ƕ�VM�P�N1�VM�P�4�V��P�v0�VmġV
0�V��C�zֈZ�S�3�j��vԪgJP���V}���+vԪ[KP�>iG�����\;jU}	jձvԪˌ�U��wP���P��tx�sJ��W�<��d�RVN�ߡ�/^�;3�`���_���`$����:�xp|�o�E��a���u����g�ț���#������S��M<Đ���;c�>'��/����'�߹�cAzn�7��I�W�����u�)93�

�~��r�����8��N�_h0�3|���˄���2���V���B}���0�le�@�Xס��%�[���P�A�ˀc�B]S�08�.���1u���P3���H��ț�3x�|
�Tj�����?�zF�N���������x�8���!v}nzq�:��TV��7�2F��%�o���Ϟ�,[���V��l���N�5S���M'}�1��>o�>�6�Vv�
_w��b�����C��K�
w���B�w4qBaZ��+�q�*��o�Z��~���?�1��n�/_r8��������鶤�F�~
m��ihx����m��=��	��ځ5	sw�4u��Ά���&�O
M<:%�“���\���B�z �	v���K�*U�9V��^�w�%v?*�C�^)�|���`��b��
��C���R$�6'"��MC9����3+�	p(n*Eh
��9�i��Y�Zl�����~JU�-�_����e�����w4�P�a�>�?�?F&/���k�I��'�����F��_�a$*!��M��#�z�]A���/�/��P�ç�ϵ��qM�߲�.$7k��9�!�ͩk��#)|�~)�vG�݆\���\�$ٿ��|�uJ����/�%�M�k�z�[��{�t-ƹuv���B;]��e����Xg�k1�%v�#e G�bDw��Z�&\��oX���a��,׬2�-y�2��3k��,�Sǘ����T��vQX��/�r�e|����"˄�9��'U}0L��c&�g���!��b@���QӺ�Rhb��f����:�49 4; 4= 4? t t t t t	 t t
�"�]D��H7QtN���9�N��Q9��I��!*�:�F��)tҝ��S�[i#8��I��N��n�����.�n������F�L�L��rb�`�`�Z��L�L���Y���م��3���t]nf��?�R�1�/�
��'���%x��K��Z}n>ljǟ�8H=�P�g�g<�XD˨��k1~
5�Xj�S��\i���k箂�g_9e]�j�~��B����B�Q�M�P
��C�w��輦���ز��.e;SC��S&���α(웕�k���
oDUKu�b�:.Z-LfU�3rf����#����wYb�A��#�����N�����e�_u�/��%���m츦�ϴ2�jsT��㓎r'���?��->���K�uL���h2Dr!�'��&Q#*��P!�_ז%G��jz��nn��ߐ[�ۦB��:�4��#�Ǡ��?
ħ���`��1$����2�Sx��
��K��n��_��×��_�i�n1�;�y&�7%ˑd5�k�1��T���Y���խ��y�+��ip���䎘ۻ%*�������]-�Oѥ����W���<F.����=�tC���^�|�}���Nxc�%���o1�����c���2iLI��� 6������aH��ogl�vt������W5{o��y;���ހ�A����?��)��������
��Z�b58Խ����r��_�36�Õݛ�Y����͞�����7�מi�ן�oF?>tt;�l}�3{|��������Z�r�)h)@h-@h1@h5@h9@h=@hA@hE@hI@hM@hQ@hU��e�u��Ϥ���Ϥ���Ϥ�������-_�������"=@��%_�Tg����^�/���w(y��^����������zz���k�'��ȆXal����tst�酾���c�_�T
�m�O���%�ä8$7�Zِ��k�!9�RU��p���M��ہ�S��7�M��	_����30>��JU��ja�ߗ�_���zM7@��/�	`�1t{K*�y�#��k��~�*��{�G�3�����'��j���_�?T���c|�*��#��
�?�e����-�'��	�vd�|�7�O���8i�Wfx����3?�X��ވ`kJI=F�€�G���9�paм��&rޚk0�/[�n��� �K��2 �6�.�: �>��#��������l�7�~Ռ��2�B�:��̹B�߳���I+,(����O����}�+��+�O�XG�*�x�U�QsJV��=^&�M���7`*�|���b<�s��L~�V��3���geg�f��}�۫���T��/�������t���6Oݽ���e䊢VaŒ֢��W~����T��t�$�����K�mwZ�m�em�r��âVIN_kǩ=���#���X�D]�v��`��;kdPcm��k��箲=��ٲMD��=4$ά���b5�
�V�’n|v��xǒ������]��nW����נU�e�u(��V����� � � � � �  �" �$ �& �( �* �, �. �0E�ʀ�Ҁ�im:B-��'̝Y譕�5�j����BC�w�$�ߵ�S
��t^{��Ȕ��/���?/�c;��(�rF'�W���O���B�P�E+�x�%����-�{��WU�_!S���\���������fg����".��i"=ı���y��/=��T�oY���ڬܼ93��~S�II�Y"�r�OR�|�޿�J�~��>�P��E���:������*л".Z������\/�GM����^&'��u}��:���)����JA������7^z^���b�̥Zg�NI[T6��$����VB���������}�*��?�P�ϗ�_�";���C+�v������FSvo�/�1�]�C�Vg����5��/W����+���c<��������Dס�/�i�a���-##���F[Z�F���4�Y�����#-5�;�mw�Ƕ�ȶ_�;��YI��l�)��NIo�����v�z������A62p�-��?l��Qc�q�[σ9��]�l����E�d�Dj�S��&Moa�M�c�6�b��U��U��Ǫe߰�k����+�د?d��u��o�v���wl��
��-n�K�A��i2L�����I�m�O�١]�m	�3�aA�m�;e�_Hb�wc�F�#ϊؤW���G�'n`A��j��h(r����5�y�.��^s�S�{�0���
��:���Lj�uJ;29�&�G� �x�&�_�Y��/gh��3�,�נ�����)��N����#Cc����#Cc��H���2)1�Ā�@1"@0$@0&@0(@0*@0,��ĸ������������(ã�Eb��`��`��`��`��`��`��`��`�����������������R$FL�2 3 4 5�c�$���q�2� �ku�W7'-KW���Q������4���|̸���6晃�7�����i6���hj�=�+Z-�ce�k��.�#�t(��|v�4���#A��(���ӑ�1:c�z+����0֓b�]�ј�8_��\~A������1J��J�7_��7e �u�?�;ݛ? ab,�*,���h����5a�_ж9u�8�Hg-�ґ��@�sx��������@Vpx�6{�s���&T���ɶ� )v<���I��HN1�7�ӈS�sj�Ϝ��%.6��=��\߿�����?u�>`�	��}����Z��]��}�;�!	F{|�*nh���x�4�>��n��I\b}%�x�?7�l+.��v�3���sY���*
:�g�I�� �Q!�eà}9���LB����_����dB�b���J�K{�UH��.	�k
U�.w��!]�J���X�B6*b
�^ԠRxA�J�D1*��ZT
�sK:r�����P)8�-��C��<��#���ܒr��疬�P)8�-�fG���A�0��*�%�vT
��KR����Rp�_�̡R�t�_қ"�"*1�J�gDb�T!�D�p�C�pގJa�J���	;*�W����.*�g�vp��vT
�8T
��8��;*�1*�I*%�Q,���J����>��;�A[H��]�XCFznFv^΂9��>����*��}�;�)�8����vo�nk���j���MA�"�wfZ��͉J����D.��y��71��:�NV	�U�w�'�0�c�
�-��{'��YV]F"�L��5��)�L]��W��$�X�'���7�?�=��-�z�����mv���'X?���E�� _w��j����.;K��
���R��G	��?���t��2��{OHw�'�����+��:��F�"��=��B����N�=C�u?!�	��@u+!�}����D7�C��	y.�%�d��2��C�ģ��ȳ]��W���#���UMx����*b���?����]l�!�]H�u�ÝҚ�(�V���I��UҤ���_Q�o�c�w�QN̎"1=��������u�1�b0�a0��sj��_`0�oEz&f�19v1W���_�c~�1��1�g�� SƘ߅ǘ�c��C���K���`�B��������M_���\���1B��a�o�\���s?��/��-����6v~���[��A\�ds���6�6�_��a��,�	0w�r��)鬹s���.Q��F�1wk����8��Aq�s�Kz�%=N�$�y�Yq�.��ז��5�Ž�L�)HK��eӲ�rC�Y1p�Y9��Yծ�Y-ohV_oj���"���n�{������#���x�O�qK����!t�w;`Tn=mj��5H��E�\�V|�e�,�JK@�!���|% �;�-q�S�|�u��s�2i�|hY�ĸO�V��������m(��Q$�͢H�ǡH�`C�0�C��lF�0Ќ"��EB�`7T$�A�pɌ"�E�I3���(��Q$l3�H�L�"��}�H�F$v�"�Y1��E�1���b	S�(��(�Q$d�Q$ěQ$�4�H�jF�Ћ"�&���f	]�(��g�U	'�(�#F�pQ�"�1���b	;��R,��h��}v���|/��9�t������l_�
��2a��_�o�4|���{H����
[`m-2�Z_yEv~���~D�F�����÷� �ۯl�wXT��d��w�r���9߹��|��7���n���G~@8z�����i�'�N~���B��ل��N!�G����ɼܠ���kcf��eya1��󕀐��Avs�fY�T.?����e��{�	,F����^���#�#�͊^�b���1��1�Kx���y��x������9��C#��<F��<F���Q���`��-�?
�$�ք~!��,#|
�>��XF��<Fx�~��1V.���?I�]X����u�������g��x�����_��x��C֊��^6�:_���<,h�xx�\�����Zs��	�g��W��������0�,��d�����8s�o��nj7�C/��3|�T�����׊1��l�?_����$1�\3�B3�-"�h��r3��f�����#�5��}e�j�^k�?>K_��?�
�	�~����˽��qTr���3�l�[�X�.vW,���E]pG�����
��Uj���_����C�t�S�fvo�L�2RǷ
[ko-ZK��\�C|�S���GR����-mw$Y�m`i�2��aQ{�$����T��)�WK��[�D}f�q�ҭ�nKd�I�����K{H{��%�yp�$j�3�^[�K��%���%}
&K��Iٴy��~�b�D�r�¢j�Ϣ��������F�%�_�m�{5T�o�����[�K�J��;ɠ��$��w%���2$a�$>m�ehץ�����aA���Y�_xԒX�%�h�e�Y�%����#�$)�zXR����}�_����{��<;5qa>���
�q:��������H�Rv�$I�ζ�P��XD�c!=�r�-Xʁ�(�%���C9p�G9p͎r �G90قr ɂr`��@��@{ʁf�jP�jA9��g�-(v[P���8!A9p\�r`"�.�[%(���X.A9`���KPL��H���gA9p��D���@?ʁ���*Q�%(������YP�!A9p]�r�+	ʁ�$(�IP�+A9��f	ʁ��K%(�[PdJP,��xԂr`:"�r�ʁ���$(zXP|)f�L�I+H����A����@g����s�_.���������g$-#�̭¶��,n}�K>��6���b�؟U�vǤ�vF�_ٿ�â^E��vE�6-�t��s{Q��3E]#Nuk�~Qd�Ei�e�����4=��5=N�'�y�
iԮ-�^[�J��,��^2_ڧ K*M�$�M[R$7�(R�U�3�H�nD�Z޹H}�gQl�F�MHQ߫����_(�:P:��ҁ�~��-�E:h�!�&�t�犆$�.�O��hhק�	�ۋ�J�w~�h������%�/yvTQҫ㊒�dKSV��&� ����	Mi�@���D��B���WB�~H��71R;*����?�e��K��1�o�Ozc��<�/迃`��b�X�U��~R��E�a��U���]��E�oa��a�?S���D���0�_�b��I1���X��X�7��H1֯�b�_&�X?_��>K��~�c��"��3�0��*�X?�c��"����b��������c��3X%���21�(�X��c�!)�cR���0ֿ.�X�a����a�/�b��c�SE�s�Ec��B�`�볥�c�0��IV.�w��T޼��…���e�_EL��������}9LR|o���U	ŵP2�����M��F�˟t���P�@��ޏ�Y��u�S��xo�*�2���!��2��3�q�����}'�G�
�wY��f�/4��o4��T<$�&>�d�Ю5	�{��=��y]��/'�_X�x���g�'��V���I�I'$�T�>E����rsejֿn#��YPw����;Ey��7���QР<8Y��`��b��jP�+Fy�b1ʃ��ĮQ��`���F��N�wA9�0�����j��#����6��nӥ.��ߣWo�D�Y��d��O�<�4=S#���Xn�S�XP�3�X�n|�Z.+V_�-�����&���U���k�O��x���V��Gn·��
n��|���/�?��9��]�جA�F�:`�u�<
�L
��Ũ��((F0�u��b�2Db��FiP���jP\+F�B�:��Ư�b�B��A��3��
s�'�W��*!��e����k���|��C���5�̇DU��QK�2��~����3!���;�ޅ�_��?ګ�5X�'W˄��������{C�g��Җ�ZZ����.i}�s�s�6�ۈÏ�-���ݑY�n���+�;,�W,ɉ*�8�mq��&ŝ��]�%�bq�[q��Nj#�k"/_�t?����q���I���w5Q�vj�1����QC?�,�u0���]���
0��w��o"�˟�es������2F�����wb�'���3F�s��m������1�gc�X��?���b��Q���R+��w1F����m���c��A��-F���Ē0�����S#d�U��w��C�W�E���_�?)#[W�a���,4d� ���Ʌ�_�
w�A�nF�ȍ-^'�Ầe䊢VaŒ֢��W~����T��t�$�����K�mwZ�m�em�r��âVIN_kǩ=���#���X�D]�v��`��;kdPcm��k��箲=���'��<xL��X�k����5����<��S�D+M/�ʦY�r�V�G��1Ӭ�v�V�|�U}}�56b�6���־W��	��?-�x)R;��zڸe���֟�j2~�^�X�$|��O��:��kڄ���aAOi�w~�:��+��&k��'�#�ζ&�:ך|d�6e�Xkjr��VvB���*Vø����|vB9)��@�ZJ�JGz�b*a�o�n�€t=
�`(�QS@a����"��P,��0(��0�eEa0���`��A_+
��V�|P\��0�`Ea�E0'״(��(6#�BapL� X���u-
�MZOkQ,Ѣ0(Ԣ0�XQ<`Ea���4+
�t+
�A��,QLբ0�nEaG3Ea Ѣ0��&K�1[�(~�&���S-
��(^Ӣ08hEa���KV�XQ����0����Q,ע0K��MT�*.Z%���?"oF|�~F�>7��?
���_-�)��q8�>3/W��^�T]~VvFn�o�d2�G�G�0��S�'r|Ә�v���h#������<�$|���:ee�cM>��ш�6���G괕����?V7Gg��������
��|�
�NlX�Kc�s�����_��@M��z$�5�H6H�������^I.�
T��Tv�Gu>�;�/��y���}K]y�ۭ+��Cg���{����e�3�K)�O����������+�WK���\v��t����Ct���y�������3r�������Y�ܙ����c<���e��M���k�?�<��tT�a4|���d臿#�~�q�����]~Za�o�_��K=�_)��%��w|��:�5=n�3nz��y���]s~k�C�K��m�u�v��?>h���1̥)����/�~�
�G�T���3̟7�+MO1Wμm�����{�k�?e�o-�~��o,�fg^P2���ze���u�モ��7��0
C>�D]��_��-g�����'�	y�
��ǃ��ٓ��^�g��Opa�? �;��r$��%����L���$�2kc�4�������ߵk׭�P>2(���c���Ofm��#؞���F�b{m�a�~n����E�>�`�s^��f0�\��*�g��,���AV��9kL����ߎic�`�E��߇c�o.�ض�6p���8�>vЂVM� v��|�d�-~�6���؄׵�BԶ�=���&6�kM<��m��i�v�f�?>�MYs�����N��Ƕk�O}��\;V�"�:�%�Ї��r�u��4vb��։�<d�t)�:��mʉ�֩��ۦ�[�?��6�h-;��M�@3���mi�զwk�f�L;+�?lf�nm�����ǭ�v��Ͼa�޺��y�uΪ�m���[�rWڸG'Y�ʵ�[�{km���M�y��i�]�C�j�_��?��]��}��m�E��>��u�/ه�|ke���]*	zJHtl+aA�KHO�5p$���ġhym�T��X��\��`��d�hN�h��l��p��t��x��|������C�SR$�	�	
N
�
H���a�8-��q�yi'Gg�c�ġ��"NM�86�Ax�%88 89|���������8>�]��� ��	P�E���,BTgB�:k8
�@u���:���Y�(��"d�C���g 
��qСVB�h�������8B��H��H��o��	�H��	H	�	ȉ
BP�@R�@T�@V�@XT:��;�EBb�@d�@f�@h�@j�@l�@n�@p�@r�@t�@v����& =@ >����)"2BRbr���������HH���xd.* �* + �+ , �, - �- . �. /�+�|��)"��%�����
$
x�u0����R�U�U}��RdR���<�-/'o��<_���e�?
�����?��0�w˟����m�Ye9Q���^b���2�����&�5 n8�kJ��`4!e�cְ)!۬��̴�#M�_�ISpDA!u��T+�5��F�{u?����	�; �? |@�4��BC.�<4đ��x�Cѡ�4.Z�O������L�g��W0���!�/��}	���1��o�J�c:��
b���wƾFf�L��I� � E�D"	Y�H�V�[����Rݕ���*S�]k�^۠���m]h��U5�9�I&bK��}�_򿓐�������4��s���ב�F_��7.�^s��������p~%u�����VsF�"��?ޜ��i�����%���(�|����1���oNJ��
Ֆ���/��|�ك�������Y���Ut�bS�.2W
(�1Wr�`
$��]7{3�]_Tr�����u�G�ݪ���o�(|�f�
#�&�7N�#x�T;�@=2�>��������9��IM�z��[�t%��U�?��'�s�7@���E>xv������{.;�<:Iv�4�yt� {h��x�]�h���0Q��r���o�,8��W��׳��G���/�O��,�3ۋ?/=����1ܥiM-�{-���[�:��c����l\���Wr��#�J�hS�9�U�ڝ�~�^Z�s6���⟝-���M��_Z|��f�J��j���X�О�c�P����sΎ?�;9*�:tA��R+g�wS�n�Xo'�%S��βz�n��|Y��_�F} �vB[���C�B���%9��Y���^p���'����$�בhg�(���v��Um�>�Vv��Q�#GO8/�D��_�����K���w+���c��^>)6��_��!�LC�U��,8�z=�,������z=3M#�Gub�����>?^�?��Fa�;,�D�r�e�ka��,I+��„4�yN��9�2q�INi�Ւ��'U��Ok^_N;�9?��or������������W!k�쵟
99,�oS��XS����-�}��j/�L~Z��S�eF���#�,3/��g�e͟}��<穄��^i-ϝaȟ�D�p�Z����<*���C���C:�I�u�SO��F���ͧ�n>y������E�	�"����|c�l&=G�Q
����CD""	����GB�$"�����DD�""O���f�R�	8��LM-�ʹDdm�U�9��L�X�	�L�%�3k3}ȱ6S�=r��9�oB�8�s�uD�;"r��8�{j������6�j��6�j�=�6�j�] �@m���Am��`+�����8`3��q�vP���!��Y�m	Ֆ��P;l
�s��P;l�s�����v�j瀭!{Cm�9���Cm�=���Cm�A��;Dm�E��{��:�!D�Dm�M�m뀝"[Em�W�h���u�vQ[��u����:+�����!شbm�m��<`㊵y��Q���w���ݣ�N=�^A�Gm�K���v��<�Y{�!�y�&R��"�yV��
�Gj��a�������+h/����+h7��Ӝ�W�~"�
�6�Qj�e��������+hW�ͳ��WоR�l,Ş`g�����<`o��6�������K���;`�	�S�l1�y�S�l2�y�.S�l3E�`���6����k[@���g�[- ��cͳ�^|�[�:õ��^���7�R%��r��fga��J����{٥�C1�GԿ�Q�]���������R]7��u��_��(��M���~�g��'�{��[��*�ӆ*���K�_�u���s�^{�q��r�>u�E��
C_VGl�gェ�m@�M=�z�m�7�ԃ.�Vq@抮��'��D�ݓ��_}:o2�s�}�s�8�).��o�3��7�~i_��	>"~�7�aȝ�"w
��|0r{��������x�:�sӳ��)y���à)��ޜߛ�����d$�3���}!M����U�?����;!���i����w�]����}b�����ci����|ckK����K*ZZ�>'������g��&n��m�
B��/Y�7["t����c�厗_����Cr��wٕ)w�:%���!r����rHnH�:���?آ�t��[B�����P���uR��+ň��I���b�yR��dјb�����}c���b�v�~-b�؟6�l�mT��2��9��gc,��ΣB`�#iJ"e�s5��%6ܧv�P�seH�kZM��F}��Ӎ�h�
�e���@D� �\({�P���dD�3ȉ��)�(�e�q�,�e� ;ʞA~,{~���r$��nCy��y1=G�R�����K�3Ș�g�3e� k�ț�f�9e� wʚ{�[�P��5�P�z@�0�eà�A'�}�^P6�A�0�eà#d�@O(]�l�a�ʆ[��5G�aY�3�Q�XV:����.�u����fsv��[�@���tj���7��m�ͱ*��[�r��x�5n�
]��O�O���J�/2��s�����׮������H����R�*��VR�9DUf���o�6qg��������7{Q�P��c���3v�y|�z�ˮ��#���N�0�� |�`^�� ]��lj�ރ���`Qߢ�d�Y[��{����"־m�|�-r���>�smƔ��Q	�-�o�=&4�ַ]��_�$��/�G戣~}�>��0�h+��~��@���u�KW�K[ܽ������m̽�h�b���{o��w���{+z�b ��`����3s�{D��wK̽�(2�����;��E��s��y��s̽/�{g;���{��{�3��1��.1�'2�>Hb�=Xd�=G13�����;6���f�9����g�̽ϵ1�~���w���{����hs�Qv�ޓṰ�hgn=Gdn�!;s��&��X��fbzFv���:,LW�Oe��������W�,���h���K�L;�ow|l3팔��ow�V�w?UŴ7 ��;��sߙ��{�;?�U ��d:�4�;6 +��*qXS&c'O��3~)��sW Lu�p��0 .�G����!�G$��Iw�G%�����>6"~tB���x	�2P�."^D�$tw\B�4T����)�)��o�4'
�˲�Y}��N{�:�2�ӗ����],����w҆H��o�_;+X�T���_���8��FQwu|�L�4�i*�nA���6&�m�Z;�0�
#�e:\��|��U��k��,���C��Y���y���l\y}�r�q��b��a���-��Z��	+���F�����V����ԉ�����u}�:׷�(��q���Η��b���r�u�o,7]<2U���&����Y����O���SQ�R�eS�vaBՋ��A���#uM��$�x�IS�m�Z�>t�~)P��M/w��]�l�q��b������V�+:UO�Z煙ڬ�&����.-Ih���C��BǦmM�Z|+w�2�م˒�������
�6Wp���
n���K��ޒ<ͩoa�
5G:
Wd6W� ����e6WP/����6W�O���B`s��\�U�+����
>'����d6W�,٘a�#��ę�����a�B��ڦ���	���l�{e!�AMg�'�
c.���Ƈ�=u�[uN��5�y���;��
���-��>K�㗛RZe˩���&U}XHk�hJ�6KH��Ӕ�o�0�TsӔ5B�pg֢zB���Μ�_�;��#[SO;��/ɹ��<�cyz�S��o�3jm7�p>-��y�,�ly��9O?%ܷ)�4w�,a�#�&?����\�p#�G��l�6�ޢ�܀!����6r��Fn���
C�kh#7`!�����n�v��Y���M���.�vo�{d��i��6���q�f֑����	����D�����J*S3��T��RyXJ�	`*�'��T��RyXK�	`.�'��T�SyXL�	`2�'��T�FSYXMe	`6!���'����a��'ܣ�+O�G;.Xy�=�q���K]�%��'��F;����*�e@,��6B+�����v����vd��vd��vdk�F;��sE��ڹ�ю����v|���vd��vd���AD��V-"Z#D�Hē�l#4�LT6��6BC��V���Z+D�X�h��r!��BD��V-\`ͨ[҇��C����
�"Z8D�r�`���Q��"Z>D�~�h�
"�%DDk���""ZFD��(��DD+I��%����C�����'"ZPD���hIњrw�9�v��p�5���vk��1���N�i�V�V��u�6��/��?���ß��bٹ�1[F��}�pu��y�"̉!�-�"�F�
�P����
 ⛠$=�5��������}��?�DjN^������t�PN�>4N�y�2p����h����A�����A�/Jx\�/sy��y���0u�]�T]�6Qw[��*x�u�������8�f�v�6>ͦ�D��Q��-��0h��Ɵo6r@���=��
�^���h2 b}����\��O��̩��_��/��G��W��n4%��Q������0|��R<�(�jtJi�R|6�\���M��� |��`�OT��?H�QX�A�Q)X�G�Q9X�fc���������}
=G�a�{�	����R��,u�R�:'X��dKݻӂ=T(���,u?5����sT0��D�VѰ�`�6(y�t�7�j�b�w�_Sr�e�o���?v��M�����x'v�&B�_��N�\:�X#t�贩ˮS��lX��y��h�ԣ�.��G3|�L=m��z4�֣,�Mw��hx��h~X���|�I�U����y@:�n�j^�����h�Í�F�,��pj2NP.4�e�Iq���Ir�k��g��N����?���M�+���N�dO�ga�)�x�P����P��?_(V�)V�])V��)^��,���W��+��P����P���:�L�S�B��;�j���k��?C�_����u�����������P�Kg�ꦎ��6��GL]�:Ll}�j[�����g؜Z�l��������)N����p���Ծ�<
�23�ŞV��,�K�e���������<]?�Ƿ.�MC3������.�M/C�3��nگ61��n�/01��n�ۜ���v5��w2�?�մOa�zP��;���O������E�k��/q������w��˯��j,����$�AXB6�w�$��I��B�ޡ��\fU_VU���~?O��K�n���Nr���V����0���Ww}�kMՋ�#�hh�;�?o��F�����r�5�Ml�v5[����VW���\7R�|�9y�$[oQ�����s6��r)�I�t�S�[�*�NN�ܫx���)�W�v41��^�[�Ĝ�{�&��[ϔ:�R�6s���k��6�/��7�)��/�y�?n���K�X�v�X|�lv��{�/����q��N�����)+����eΝ�oX�_��R�
-^��}�k���h*�;�]�n1v[���|�����!�Ӎ�4�f�2�֚���u��з�0h5��pGx�!��SM=���=����E]c�&���\6F>p���O���Sƨ��8n�$�J���7��f��̢s��e\�s�ߟ}�\�2����ad~����5F������t#�iF�9���r0���`~����Q�5Ag��bd~����}5=Gb~�����&��O�A������)Bկk�=��YYf��������Pe��/��mx�]��k>qV�μ���9�ݳ��+-VUs�\vUhu�lRY�Z'`j3|��6]�6�}W��CX�б�jg����N_2u��}�ˁIlF��،��;C���u7��6�1!��r��s�Ƿ=?� �z�y!b�2��c���B���
Ɖ�������V9&b�ܷ[��/*D�_� Ƕ�#�ԛ�A���=�f��E�_��0䥏�j3��	l&�����Fi��G]}NN�;CN<5O��Xy�{f��c��b��[Z��k/'=�K�W�ͳ[��	�)*�=�&~+�5�)���PȨ����{�0��yʺG�̝k�G6��k�s��Ȗ�i��!ٲu�@yZw��;x��WK+O�6@���PaF�.ŒO5��5�Yo�f�Q��į�}��s�*�[~A����+�ۼ8�z�
K���Z�P4�p�K�k�$wٰҨ��{D��sT]�Ro~�9K�o���:��Ul�	Tyr����6A��m&��HHr�q�
�6�����.��.��@r�@��&T��⃪f��XH�V@r��P��"z�����<Ζ�"��]�Ɩ�"��]>�z�H=r�O�M��䆲� %�""�)���$�X��j�����THSB�`��Y��p�~֫E�""}݃��ƈ����ΈHiD�5�U��қ��Li��TGD�#"����H}D�?"�D4�h
� �I@D������Y���	��l �D4�h6�t ��@D��fM	"�D4)�hV��b���f��S���D49�hv�� ��AD�x���k7�
ц�v���]ӥ(�Kș23�g������2[��*�K��R�y�̙�Y�"��0��4�95S����mNKO1�����0����Ze��/�?�͒
�s���TGȍ��F�v4��=S�/b�M>�l��>c�W��Z�ȕ[.I�[�%�2c�����6�;�m#���U�������w��'�r]>�#v}G-v{y�)\�%�Ő9O���9MRsQkJ�tF�Y&�[�
u�pa���.�)����z|2W�'G��.�5\�Ί��>��j���#F�[	��\L�b���~����~�b�p1�p��R< �^K!�
�0]��`�.St��Ct��P�#���+��L��W�҇���H�$B�=�
���Ye�1
�QB,E�kb��\�U�Xʀc�=�2��Xe�ͶE	R�Rd����R�$K��KH�R�2KQ�Pڔ���)E��@򔢀�)E
��hbeP�JQ@HMA#袁V�fP��A)
h�({�6��)����P�C)
h
�(�9������
b)ʣ��I���6Q�Ҋe��U���fq�Q-,��"�uA�i�Rӭ^���iq���V������<�lɳ�}$]���?>���Cj��u�̽�p�S�ķ�/��:����y�a큧\���b��⼇N͍�P�W��{�ʈ��4{��� ��PV<�?�<�<m�w��qe����?��M��NK2��S��A�b��!����s�y�o�_r��ΠU�����AZ�u�
������;0sm�c�~�|�����˯�����,�T!ҖI�J4�e�i*F]�ސ�g4CCm�\��b����o�w�~�m
�y�/	�����s �ga��E���g��_���[s����K�Z�2��_�_�uN�^��N����]�Z�Xh����+�X��D�Z��M�%�%������3i MD���l�i6�>�-m��?�/���\N���_2��4zw�cΜ���w��搾�^|�[�0e�?�����n]���s�wxZ�_�{���Χ9�
��ۆ��"��\gɷ��Ҽ����$c
/�?��rni^�="���F��d0�2|��Z�-9�U�/��y���u�����3�?�aj��i�搱�_���s�&_��M>�h�m��|�|�T�@��l5Kg�s�������s����5޺ޓ�ã�l�[;[�oT���m�l�%5[�N���S�l㩽����}g	�Pɵ��{�+T���b�b�jU�?S�W���L5�	�&݄U����:����h������kSi%dpK��<�w؝����w(9Ģmb	A��(ID�&"J����E�Z�н+(h]d����w��t��#��;���p������C�]xG@[z^tG���_�m�y���y���y�����:���y��}��������P�u�{�s�9
�o��AV����|�=W��r��A���ޖݪ]�,�Z�W�\�=��k{���Y{A3���3�Pw�l��D����Ԡ��a���F��.-45>���x����4�������������B
'�p�����^�!N� �}J1�U;�7\�LJ7[.��2�=�L�z���"Q�X�$�~���0J��ls�8�����?P�Ii�m^�s���_�m�%��9~`�����Ag��q�6�n��Y���44;�7-�/
��4<3U�)%��F6"���Y��Z��,�T�k\�u�L�����u6�O�Yly3�ν���F5<T�Ł��U���U�U�U�U	�	U�����	T-
`@�A�(�5�@�8[ ������@ƽ��;�qom�d�[������{kw ��ڠp{s�-���,�qoi����,��dz@f��3����՞2�d���
(�*Pt`L�HD�"�)��4AD�]�2�@D�"�)��4BD*!"��R�H+D�"ҋLPiFJ
T#�!�1�J�p��dL��/��8��_�5ǒ�ݷ��q��D�{���z]a�ߜoNQ�oI0gXR3�H��P��g��%�/���NK��������|_S������?Қ�5՟����
�ř���ymm�"���n�NK7g���u�?�p����ǀ�s������o8�9�;E��hk^��?]��F��}Y��\��>����W����X\�qSh�E�lCYD.h�NJ��2��g_���Ű~�4�J���gdY��|������\r��/ʿo�y��{�Q��O(�����<q�ߜ"�a�����B���S�ݗ��s��~\��_���_�e�������x�u+��oq�z�…_��[<���9�թ\x��b��\�+�b��\�/�뇉���&F.ԉ}��%'5�t��.Ƥ���L���?�]1��Q.�����q��
:�8�i7��b�#s�!�f�iI�8l�qx�hqD�1apqd#�8�[3�{|V�T�j5��n���ܸ������k�b�f�uV���3 �4B.����}��c�Lt]A����T��X��\��`��dx���ʆ*!(�x��|x�"�⁊��ʈ�
��J������IFTRDTT<PYI8��x��"�����
LJ�*2��x�B#�Rお��ʍ*8"*9"*:"*;	PxDTzĻF��k�W�I��N��V�������4����o,�P���֓�nkY���o�`�%$�fQ�,��X��fF��B���/�m���/��?p��v����O�?':3C��4O|�q!��<d�M{T�x�m}��+�,���g���<�"�"�"�"�Q����Pr�l3Z�M����?&3��6�E]e�]���9-�-s�lsZ�_���g���
��x�r�q��</n�Y���6,T�R���Y�w�����Ff	i�T���&Cu�;,�g,|�f��kq��bd0tj0=uj�j�6��A�'�fL4�x��az}i����S�����G���'�r2S� �R�B5N�2V���?~b|�5%�;�/��j�"�r��ɜ���uv���Os��:�2�ϗ�_U�U�]�T���W��έ��Q/������?/�k��~e������Y�W,	5VY3�^�]���z��q���GGٛ���h�j��ّq��K��[l�4���mo��ʨ�WQ�:���M�+�C�1�krJ�>�s��s���/8:~������?x�������Wٻ���|��ݟ��I�hW�5��Z!è�:�g�W�6�|�V�c{8W�~����w]=7|��#⡃��/�䈜�I�g�Q�qć����Ѻ����;��{��O�����[g�1��
�?O7ܖ�t4��g�jOc��*�!��CWl���?s�#هw��8b�՞P��qt�9����1�7 U�X)�&��o�Q�@�up�

>vT-(8#�s���'��rU�AK�!�[�ֺk�X���QEAMQUA]QeQmQuQ}Q�I��U¿��DoT��Q�VT��"������@ͨ,�Fe)P7*K��QY
Ԏ�R�zT����� ��@
�,�He)PG*K����%��@5�,�Ie)PQ*K��R�T��R��T�����-��@u�,�K�T��T��T�Uf�O��JSy
Ԛ�R�ڈ�ޔ'����Sy�;6�՝�S�٨FT{*O��F5��SyjՈ4 T��Ё�S@	*O-�<�a#�T���F4"M�*T��Py
(C�)�
���:T��Py
(D�)�u��Jԝ:Qw
(E��"�BDz���E�o"uA>����S��֌��%���������S��9���3��T���
��H�|���[�rW���n^��q�����*���U��+�l��������UB��U>i*V���X�Š�v��W5�j�8�՜{������=��?������;cW���\��I\��s
�p�*��N��pM��M_�(6�����~b�Ab˴�b�'�p�1s���a�M�\ی�vm���<�u���u켙�x�
��ů��=�u9�S�u��ub��q\��{Pɍ��Y�f�XQ;j!�1Ԑ��[�

q����[7.���b��{n�%���E�X��{U
1�\��?���u\����A.&r�ط��_��b��8.�ʫ\�﫹��~���7��{sG��J54�v�{��%4]�{@5�Oع��\-4]Qx�rT��	\W��U�/��s+�g�0'�!!*"*"*m�	�E�(E�`��Qd���*��(T:�X��Qu���-��JH�Ho�����j������x��⁊�*+��x��⁊�*/��x��"S�
��"Ph�`@�	�Е&�&�H��"Pt�d@�)���H�I6��"P~�d��	(�"Pd����� bP$�`
���9��5�f�s$k����H�`�d6�C��" �d"�9��5�Z�s$k�q��E��" E2@4�d�l��(�YE{rH<�d�|�Ѷ�9; !k�=Hϑ��!)�R�F[��I�;�+��"�O�\���a��E��"�5�3
=�����To�U�7{���o�2�˗������*r�f�`P(�)����ou��kx����U�F�3��Q9�rs�1��ח���
�����%.��P`L�6������bk�lP�W��`����*�[��,Y�����/��9����b�蚱�7��KlПO���4��N��7.K�|ď����o��O�w�OZ~��>��}/%�y��8�����i>��&iR�ץ�����R�U���o�4�T�4��{��=S��E���#���V�e���:,��Nj�OӴ�s�������!
��_�3j�.�p��g���4˾��}�]i��H�mzN�;s�4�yW1�>���*�Ray�cUîj-|�Y�������3�B�ޥ��N�^ �n �~P�
t�j
�'��+��/��3��7��;��?��C��G��K��O��S��W��[��_��c��g��k��o��s��w��{�����������dr@Q'	A/Q7	A?QGQOQWQ_QgQo}����Ցj����v��u�wW�h��k�t�D�>��#f��k����^��U+�?�2�?�j"W���n���t�M�j��?��yY9ٹ}GZ�gd�W��r�w��ߠV+��'�?�6]<*�#*`��Y�&�jԥ�����>"�Y�[��Ց�e��?�|�4��u�?t%���O���Ѡ��k�V�yv_FQ�o�r���������P�y�/�Q�>2X������i���C����Pe�����z�ί0r��~��2���:�ɿ�C^ڠ��4�Ձ�7[�9�l�����J��2x���-	���F}������jQe|hU�"}8����c��:�7�-����K�����:'���� ��ʪ�G?���
�ИCRbP/�FqV,t�l�3v�V�9#Xx���4o���[a���"��[b�_�b�?���w��J,��W�S2��!^}����թC��?�Q���9���ޓ�M�N_b��^Y��/��}^��?~����q�]{�b�WaD��
-�d}��f��F��	M<��;���Y�6T_�7�i�� �A�7��_ySA�z���19Y9VoM�)�'-�Ԕ�qR�?^bL��a͘���E��ȿ�?1g�#�kCK�
S��p�X�ye��'�ê+m�S�^oP��FvX�o�I�	��Jl;������e#����5cZn��'�_m���B5�o��%��R���+=�5|��k��+��9��7W[�8��Lɘ�����?%��)��/������{1d�S؏�-�
��:(��xb�~G���1K�w>���K)��;���4�%�_���)�����s_�>w�Ň���DK3\�r�o�*�����z�/��%v��K���f�f����Y���+�}����ܜ�q�&�uM���k�t��_U�{9��^{���_�Q��O�/J9�����[r�7����*����y���\���o��҃=�S3f�������5#7#�'�]X�?q�w��~��W.���|�q�Ec�/�j6+�Q'�\�-���np�G�Z�W+V�W�s|eBxu����G�y�=):�r3�ٹ����?
�e�g���9;)�<��R����C���΄��9�i3S��do�;E�L��ͩ֜T��&�ׅ������r]�5�?��6�A����NJ�*�]z_j|f���Mj�s��l�{|�+V�-�H|�9��U�V����|��	|ۈ~|�n�}�|�����1R�_C�Ng�K�?n(u�]E�������K��Br�I�W$�<p]�w���O�����pu�l�~���2]�^��D)b}��ݞR��(�ϳ�%㤶RԂ���k���
�QP��E:V�`{Q�7�~�H�ܻ�F9=�ETR<GEEDeED�%��0����������	��$@D" "��H
D$� �s͑(�HD$"���C	7����$BD"!"��P�H*D$"�	FNH��l8�l8�xW� ��Rbs�s�X���M�
`��]b��P����/���-���&�)6>��7��Ap���6�i�glj�5-�\��^��S�K������]��s�8���2=c�U2�����#���b�N��H��u_�sv�O������S������s�����I;��u�2TT��p�ipV����ނ��?z��>c��D�w��Y`<d���I��M�o�7�y��نu��U-�n��=�V�
Fբ�փۤ�����݀{�j'�4-��{�ة��t�sG��]�lstu�Rw[��l_��n!�"�zx�C3s�]�k�Q7f�=��٨�n�_�1�5d���1��n��V1��������bM��n�#Ww6��_0�_���e!�|���QGL}����~���a€�C�;���ovZ3T��p�s�|�P,頙=��U
��B��+yL�A�y��h1G��Թ&jK/�X�T�Y��lCD)#��Qڈ(qD�:�t�'�#� � �& �6 �F �VP�4�`�(O�*���P4�
0�-T���h
`@s��C� *�tf�?�&Q��
0�Q��UTx�"�h`@˨�F�6*���Q��
0�yD~�>*��R��
0��T�m�h$!h%"j&!h'`@C�ZJ�T*���R4�
0��T�ͥh/`@�ɪ�S4�
0��T��&�&j�f�v#����S4�
0��T���h=�j�
*���N�f�b�o]���_z�_���s�?��lq���5���)�{\ʟa�.�+�l���c�P�����/��Ӊ�:�G�ug�t���!����``3�a�?�F��ʍ�435����4઩��;����i�Ŏ���:�Vϯ1��~�[��S���m'?�l�Cn?h��C���]R��y]���|�I����]ߟ)t;������k�L!s{�ǂL��1��z����%�?l�wl!�vSX�9��Ag����W69{��)��BrFl����Z���~ �y6�i�Y+D-�j��P�Ia��.��7���<�{|�<���9�	�
�q+f�?њ����Q�4t\��o�a���y'L#�WF�cJ�rV�_au6@Nl��3q�y�?�8Ǯ�-�sz�s܂���OpNHY,'�4:���������E�Ĵ>�������֦ԋ����Mi���Ϛ2^����<�M�<rƙ5����y�3gd�ly��T�1ٚ��9��V9w�g�?G���L�O�&�h<�4�Dž�6�Zy�0�DwӜ�c����Ms'��=������w��Ȥg����p�a߄2h�g���刨��\@�	A�Q�Q�Q����Dd"����@DfP�
�A�*`5��%Ԥ�P�l�	�b���9,V:MϑA+�(V&Q�l�X	E���b%`�J�.���a#˨IL#�Q��#�Q�̣X	�G�0�b%`!�J�D����d(��++Y��=Gv�f�az�,e�*;=G��f�Az=d-kVm���^֬��9��5����̚U	�Y͚US��#�Y�j����Ԭ��)p��)F��)V@�X���P�
�5��"P�
�5��2P�
�5��BP�
��1X
B�Ԥ�AV��T`9w���hA�YV��U`I�Yք�U`Q�YV��U`Y�Yօ�U`a�YV��U`i�Yֆ�U`q��P�
,!XjR�"+D�*�DԬkD�*�HԬ�D�*�LԬ�D�*�PԬ+E�*�TԬkE�*�X�`��I���4�+Z0�_ђQ�j%�+Z4jV�e|E�F�*�nԬ�k,\<
��ذ�vWw��h�kJٮ*��bp�'��n��
%��P�6�����^�y���W��Q��z����/IY��Y���7�,���9�+!V���y�ώ�{��
�]W=�<�c�7�L�X<��u��1e鐲t�S���ҡ��6�
+�
�xsJj���?�AS���S����j���8�:o��߲s+���->���ҊW��/W��Uvs��d�WG��d�'�mی[7�UnC�Uq���W���mzA�m�����^]<��bQ��Y����ojNJo�D|�`���Oo�����{�M�UY����p;f��>H��v&��v��'����鹎ۛ�����������~=�;�;p�����'_�=��9�r�j�?���x$�=wdc^�s��|���ёU��KF����{`�x|�q���{|����S�i��ն�O��F��w��'�NS�ڲ�~z�|���r������_'������~V��~�Mu��fa�o�wR{�������~E�Ç��9�����g��zȮΟ������ԿL|�~i�&��U�_u�������^�j���D���5�m��z�W{A���v�4�&4���\���gS��/.�&�m{���|�֣Z������((�������x������>��&ſ������<�䍻�G���\28��M7�<-�i����&���,�$DkH�""ZFD���h!�J"��DDk���&"ZND���`Aъ"�%EDk���6������+յ��"��EDKK�-."Z]D���h}�#�FDK��֘�
�E��`�i�XfZ+֙���&+Mk�R����`�i�XmB�ܴf�7�Iv=Њ�%GDkN�:!XvD��`�����GDkO��Z}���#��GD��^=!xD����3�$K���!�K ���Qw�-�c ��@Dρ�ރ&^�AD/B��	"zD�*��YhE�.��a�� ��ADo���"zD�>4i<"z!D�D�����3��g��x'�����x)ʸ�S�.�~Ϧd�Jƭd��q+a���?+
�Q�r����`P��(��.�o�� �_,=��ۊ�I��_%�����j�qޖd��_RYZ���&�aim�����
��K.�̿���#��6E�?؆u�"~�%RzͺV�jRIojӥ�j#�U��O{�m�>��{k7������^����w�X��>�ߙ8��է��;<����5~o�>i�gW��q��#����x=�?p��ӹ�'���ڙ&�n��B:���l\�9�?�9׽'ـ?�dwL;�;��*�����?�q�I���O�1���0���U�g߭6�|;�xj��qz�RǗ��w�Os|eMq|�<�qfx�7�a���N�sm�8�7�g�����핎��~hl���j�>��x��7�4���!�O�o̟���d���Fls\�y��n�㷶�:~�':��8��ǥdG�g;�n��^�O�s
R���R݄�z}�I�C�����ְ��F��5�t���{��lMw��5�v@�|�6U���Z.Y�j5�Q�*ST�7U�fp��m�U�n}U��UjtPuf�k���Y�����l]v7�)���%��Z��Mռ�!��GG|�.r�9��������)3�����st�\�x\����K�eH�O��I,�ɕ�/�X��F�?D����X��R��<K�-��$K��X��R��<K����d���<K�w�,�7�,��"�Կ
�R�E<K�#%����XꯒX�.����d�Ɩ���,��ͳ���R��9`��/�Y�?�g������%����,��g��>���W$���1C�R�y<K�s��f�:Ó�z�g���R��K���X��Y꿀c������Կ�R�IK��3|��
>K���,��hd��i#K��Y��`������,��3����`��RK��w������)���t�Կ����a��wr�Կ������,�70'�R�Ƅ�LX����?Y���R�CF���od��f#K�mF��p�������8X��R�G,�,�������K���,��'��� �Կ��R��£�"��b���6��oc���q�������l,�_ec��K����D����������X�/�X�?U�R�dK�G�X��W�R����T,�fc�����:K���X�����Jꯤ�J�q��L�Dj"��E��;���h��x��)���3��{����aaZ��91�]�����������_Y�����9�"��oKjҨTkJj��_v���$\�������^��ܵ��%_�:�;����w#�)Q2����<ܞ��%�;��,��z����)g�7��+ӛp�c�Fa.j�5c�9ī�Q�����e��r�BFVrޔ�<?�a:m������t��Q�QӲR����l�Fo���=�bfNnn����P^��k�q�k���?�a����u��o����V6�f��*��\�4g%a�����Q���R�����j�g�N��ASu��\cW
S���ʵ�q�~)P�N3�Yt^����Y/}�PPWg�/
�&�u�?�q�e�&Us�&��������gj~4Kn��\g��O���ڊ�R�*�G�4Wq�𜫉a�I����J(ӵ�M��ׅ�=pm� �5�?׉�[�V�x��!�uC�kGQ*\?B����u�>\K*����;\S*��u��;\[*����;\c*���]��ZS�}�%�9��;�]���S��*�%e@ew���ATv?�v	B�PY�Kr	�'�ʮ>޴����ds���?��k����?�b�+�Ϋ!k��$��%⡕9�Ïd�G������>ɪ4�]Hn��sDԈR��*��4�Y���[�o�*�6�o����v��o�+�{
�g������o���|���jV�-��x�M9�ܜ�!9�s| ����V�����7���a�L�tE���x�0��;���5N��b�7�?$Ü�͟�f��`
�W��b����4'�������Q�����)~T������O��������~!��P�V�9�?.#{Z�y��O��S�_���?��"�r���<k��K��7h������iy
��w�i�)������J������}+u-��ܽ��;�����I�2λ�O��J6OK����c�
���W��b�Y��f����c�?������fk��_�Q�_��5'�Xs��c/���t���3�˛�?�'�?_��?E��+��b��o��S+��<���fNɘ���'�C���<�s��k
����?)�/7����������/��k������֤�iI#���|/��P�F�9�?jZ�ٿ��*�/O��@���A�a���"�r��sNRBN���aZV�S�/'��3C��������bSX�9�HN�y��t0���C�"��`o�2��e���kjjnν��Y�G���S�V?�>T�ȿ���m�b��/��(���?ڜ=9/����*�/7�g�����a����O���p���ZSb��V��S.�
VlWq}�1�u�P�o+?ɳ�z>[���e�l�/䳙�C-�3��|�T���j��O��S�U�d�W��W��_s��#�Xj&��X����S�P��*ܹ�=<6s�X�|W�{CU��U�ι�x�@@vN��K`�c����p�
�?y*��Vz���^'D�\' �=GB�9M/��<�r��HD$!�_�C�AD�$BD"!"��P�H*D$�(\e�2�,�p�M�/~��)?[8�F�_��p���1�[�q���u�k����>��+��(:p���K��==�{W
{�h#�u�|�����C/5�}А;t��^��,坋��G�
�cC
5�~�_k�FK�
)�|nSK�5=��Ft�o׭I~��A�"vZ:v�D��̏������{s���U�;I+h8���&3��F�悘�]V2�fw�캍���}Y<#�1��]F���&`.��̕)�%c/���^�p�h/S���p	�R�ަp9ioS��4�.+M��KK�P��RD��"B��¥��.7�.9��:�H�I>��Q,��H���H(���EB� '���u��?.�l���������:�@���%�I7gg�NKγ��C�Gk�(�������r|�]���0e�������)���7��&�'���~Q��:o�!��*� ?���=�9r�w�z�?�&-P�v�y]��bh��%}������RX�Ű�)���=^]-�ܓ#�Z�@�ؼ��=u��h6�g�|ޘc�z���C�\L�X�oH}��_����~�^�����8`gGiৗ�Ak�Iqo~"��)�ɷ�!ɇ���>#��7KÄ7��m�J#�Os	�7�#U���?H�h�8�X�D�7��~��5w��~�K���S���B%!#@4�6���'�CJ�[L��4���ܤ�ۤ��wq��>�3���&�x����".s�s|���\��y|���%��O�.Z����zs�����ļ�Q��j���n+�,_��.P���1q���Ҝ�?q�eW��������S%o� /�j��\�ѐ� :�M�w=
�c�3u66w��'�=ƴܶBMp+T��q3n4݁2P6�%��Q-��jɠx�?P>�%�R-��jɠ�TKe�Z2($!(%"*&!('ՒAA��JJ�dPT�%��R-y3e,��TK~�-�C�Zr��VPbʠ�����LTH}�I�RS�M�M(8"*9eR��TKe�Z2(<ՒA驖�O�dP~�%��$�Z2�j�@�%!HN@
�%1`=���w�HB�d 
Ւ_f=$Ւf=$Y�)�G��Zr� ����zH(�%�c=$�%�#@�g=$Ւ���j�+X��G��9�G��Z�8�#@"R-9����TKn�zHL�%���,� Q��TK�R-y� q����e�H`�%���D�Z2�����̶��_v���]���P%�w��fK^����ч��*�?����e&E�3�|��[k0�X�c��O��}�{��y��6 _�~�.�h-π�s�w�X�m�
���-q'���g-��.���f3U}�f�<�2��`6�~۰l�WچgN���e���m�����#m#����#�F�\�6�[�m��#����FUb�U�*��eۘ��1�Tc߬`��
�=��{>n�gk�w8�6��t���&��	��m��JZ~R%$�Q	�D�`�c3��-��v���?���]�J��6�Y�-��J[�ϲ*��h���m�d۔3l�{橲�ٲכU9�6����a�T�I�U�4�T�������RMik�����Q;�6�yL5���Y���ه���<�ݷn�j��-�y��*������
#��k����5�/�L��ȣ��9j	a)���Q��D�D0h��U�`�.
�A�(-#M#m��4���c�<B�>
�A	A	A�z�6R�IZI����IJ4h)!h*Ҡ����t�@k	As	A{)�
&-�@4���n�hB�jB�l
�A�)
'-'M����r�xB�zB�|
�A�)@P�,�����l��A�yvݐ�;(@��>7��t`
�
Ё1�k(@�P��D:��t`�&2�(
́U��,
́]��0
Ёe��(@�Q���XG:0�t�b_<Q���:
��_�4sr�9{�����N�ӗ���U����/2�s�O�sŞ����č���]�=��B����ǎ��Z��8'_��0V(9[��ӗK�((����|��ܽy<gK�\�+�_B�3|@���dl��FZ;��F+@�Q�A�vU	K��ħa�?��"��b�'��a������X���<��������֜������k��?�P�����W�u^�[R把������o0f���2�����_�b����g48v�z��e�Ks�|� x�4�n�!�kN����N��Y��Θ6͜�F�:���/���Wt}y���_v����̸����產���b5�����{�}|J<n��3���8��4z���Ze����_�:�uP+Փ��	�-�9��i]��ܺ�C���Z|቉�O4�^��	�w��^�̹����+���6�W���~�}�^�_}ô���E�e��Gn�l�[�o�^mz��[�?v���s�Ic��XS�����Q��v8�O��~5������,�����C�8w��ݛ�2��_���;�o��>�p�`�C�����!=��J])8H���U	b�@MKg�
�����+��W��("^UB���xu�
#�UF�+M���F�+��W�6!�+O��էM@�	H�$A��4A"�(B�"J�$��RBDI!��Qb�(5���Qz�(AD�""J�IED��dQ�� a*��� �FDi#����:�:�Z���� }ZH�5
��=Oa���������g����\����O�H�l�����:e����A�Y^������jJ���+���\�5Y�'�ԝ4�R��i�F����Z��nj�W���E�g�"��9|A�R�([��$��g�3�2n��^�t%�3����|���/<ڸΛ"�qc�gcg�?�i7ˊmK-�9�\��e��K�MX���X#u���kf
�_��O�ڷ*[�T��M|G�y5�	�DZ=A�Y>��b9{�8wi�=�Œ�c���<�)W땾��g���1|��1�z���Is�C�ؾEvCM����*xR�Re��p�:�W�h���{�I
�o�{Lx������m^�����iʦ�({n�א�#"^KD����5�-��R�-"^_D�Ɣ5�uF�kMכ-�a�ם�}�
Db�h�v��Q�(D�]I�
�l�]D��`�"�
��l��l�"���S*;�(�r(�r(�r(�r(�r(�r(�r(�r(�r(�r(�r(�r(�r(�r(�r(�r(�r(�r(�r(�]~�?t�W��
PKa�\3+���zoneinfo/rebuild.pynu�[���import logging
import os
import tempfile
import shutil
import json
from subprocess import check_call

from dateutil.zoneinfo import tar_open, METADATA_FN, ZONEFILENAME


def rebuild(filename, tag=None, format="gz", zonegroups=[], metadata=None):
    """Rebuild the internal timezone info in dateutil/zoneinfo/zoneinfo*tar*

    filename is the timezone tarball from ftp.iana.org/tz.

    """
    tmpdir = tempfile.mkdtemp()
    zonedir = os.path.join(tmpdir, "zoneinfo")
    moduledir = os.path.dirname(__file__)
    try:
        with tar_open(filename) as tf:
            for name in zonegroups:
                tf.extract(name, tmpdir)
            filepaths = [os.path.join(tmpdir, n) for n in zonegroups]
            try:
                check_call(["zic", "-d", zonedir] + filepaths)
            except OSError as e:
                _print_on_nosuchfile(e)
                raise
        # write metadata file
        with open(os.path.join(zonedir, METADATA_FN), 'w') as f:
            json.dump(metadata, f, indent=4, sort_keys=True)
        target = os.path.join(moduledir, ZONEFILENAME)
        with tar_open(target, "w:%s" % format) as tf:
            for entry in os.listdir(zonedir):
                entrypath = os.path.join(zonedir, entry)
                tf.add(entrypath, entry)
    finally:
        shutil.rmtree(tmpdir)


def _print_on_nosuchfile(e):
    """Print helpful troubleshooting message

    e is an exception raised by subprocess.check_call()

    """
    if e.errno == 2:
        logging.error(
            "Could not find zic. Perhaps you need to install "
            "libc-bin or some other package that provides it, "
            "or it's not in your PATH?")
PKa�\hq��E
E
	easter.pynu�[���# -*- coding: utf-8 -*-
"""
This module offers a generic easter computing method for any given year, using
Western, Orthodox or Julian algorithms.
"""

import datetime

__all__ = ["easter", "EASTER_JULIAN", "EASTER_ORTHODOX", "EASTER_WESTERN"]

EASTER_JULIAN = 1
EASTER_ORTHODOX = 2
EASTER_WESTERN = 3


def easter(year, method=EASTER_WESTERN):
    """
    This method was ported from the work done by GM Arts,
    on top of the algorithm by Claus Tondering, which was
    based in part on the algorithm of Ouding (1940), as
    quoted in "Explanatory Supplement to the Astronomical
    Almanac", P.  Kenneth Seidelmann, editor.

    This algorithm implements three different easter
    calculation methods:

    1 - Original calculation in Julian calendar, valid in
        dates after 326 AD
    2 - Original method, with date converted to Gregorian
        calendar, valid in years 1583 to 4099
    3 - Revised method, in Gregorian calendar, valid in
        years 1583 to 4099 as well

    These methods are represented by the constants:

    * ``EASTER_JULIAN   = 1``
    * ``EASTER_ORTHODOX = 2``
    * ``EASTER_WESTERN  = 3``

    The default method is method 3.

    More about the algorithm may be found at:

    http://users.chariot.net.au/~gmarts/eastalg.htm

    and

    http://www.tondering.dk/claus/calendar.html

    """

    if not (1 <= method <= 3):
        raise ValueError("invalid method")

    # g - Golden year - 1
    # c - Century
    # h - (23 - Epact) mod 30
    # i - Number of days from March 21 to Paschal Full Moon
    # j - Weekday for PFM (0=Sunday, etc)
    # p - Number of days from March 21 to Sunday on or before PFM
    #     (-6 to 28 methods 1 & 3, to 56 for method 2)
    # e - Extra days to add for method 2 (converting Julian
    #     date to Gregorian date)

    y = year
    g = y % 19
    e = 0
    if method < 3:
        # Old method
        i = (19*g + 15) % 30
        j = (y + y//4 + i) % 7
        if method == 2:
            # Extra dates to convert Julian to Gregorian date
            e = 10
            if y > 1600:
                e = e + y//100 - 16 - (y//100 - 16)//4
    else:
        # New method
        c = y//100
        h = (c - c//4 - (8*c + 13)//25 + 19*g + 15) % 30
        i = h - (h//28)*(1 - (h//28)*(29//(h + 1))*((21 - g)//11))
        j = (y + y//4 + i + 2 - c + c//4) % 7

    # p can be from -6 to 56 corresponding to dates 22 March to 23 May
    # (later dates apply to method 2, although 23 May never actually occurs)
    p = i - j + e
    d = 1 + (p + 27 + (p + 6)//40) % 31
    m = 3 + (p + 26)//30
    return datetime.date(int(y), int(m), int(d))
PKa�\�І�iZiZrelativedelta.pynu�[���# -*- coding: utf-8 -*-
import datetime
import calendar

import operator
from math import copysign

from six import integer_types
from warnings import warn

from ._common import weekday

MO, TU, WE, TH, FR, SA, SU = weekdays = tuple(weekday(x) for x in range(7))

__all__ = ["relativedelta", "MO", "TU", "WE", "TH", "FR", "SA", "SU"]


class relativedelta(object):
    """
    The relativedelta type is based on the specification of the excellent
    work done by M.-A. Lemburg in his
    `mx.DateTime <http://www.egenix.com/files/python/mxDateTime.html>`_ extension.
    However, notice that this type does *NOT* implement the same algorithm as
    his work. Do *NOT* expect it to behave like mx.DateTime's counterpart.

    There are two different ways to build a relativedelta instance. The
    first one is passing it two date/datetime classes::

        relativedelta(datetime1, datetime2)

    The second one is passing it any number of the following keyword arguments::

        relativedelta(arg1=x,arg2=y,arg3=z...)

        year, month, day, hour, minute, second, microsecond:
            Absolute information (argument is singular); adding or subtracting a
            relativedelta with absolute information does not perform an aritmetic
            operation, but rather REPLACES the corresponding value in the
            original datetime with the value(s) in relativedelta.

        years, months, weeks, days, hours, minutes, seconds, microseconds:
            Relative information, may be negative (argument is plural); adding
            or subtracting a relativedelta with relative information performs
            the corresponding aritmetic operation on the original datetime value
            with the information in the relativedelta.

        weekday:
            One of the weekday instances (MO, TU, etc). These instances may
            receive a parameter N, specifying the Nth weekday, which could
            be positive or negative (like MO(+1) or MO(-2). Not specifying
            it is the same as specifying +1. You can also use an integer,
            where 0=MO.

        leapdays:
            Will add given days to the date found, if year is a leap
            year, and the date found is post 28 of february.

        yearday, nlyearday:
            Set the yearday or the non-leap year day (jump leap days).
            These are converted to day/month/leapdays information.

    Here is the behavior of operations with relativedelta:

    1. Calculate the absolute year, using the 'year' argument, or the
       original datetime year, if the argument is not present.

    2. Add the relative 'years' argument to the absolute year.

    3. Do steps 1 and 2 for month/months.

    4. Calculate the absolute day, using the 'day' argument, or the
       original datetime day, if the argument is not present. Then,
       subtract from the day until it fits in the year and month
       found after their operations.

    5. Add the relative 'days' argument to the absolute day. Notice
       that the 'weeks' argument is multiplied by 7 and added to
       'days'.

    6. Do steps 1 and 2 for hour/hours, minute/minutes, second/seconds,
       microsecond/microseconds.

    7. If the 'weekday' argument is present, calculate the weekday,
       with the given (wday, nth) tuple. wday is the index of the
       weekday (0-6, 0=Mon), and nth is the number of weeks to add
       forward or backward, depending on its signal. Notice that if
       the calculated date is already Monday, for example, using
       (0, 1) or (0, -1) won't change the day.
    """

    def __init__(self, dt1=None, dt2=None,
                 years=0, months=0, days=0, leapdays=0, weeks=0,
                 hours=0, minutes=0, seconds=0, microseconds=0,
                 year=None, month=None, day=None, weekday=None,
                 yearday=None, nlyearday=None,
                 hour=None, minute=None, second=None, microsecond=None):

        # Check for non-integer values in integer-only quantities
        if any(x is not None and x != int(x) for x in (years, months)):
            raise ValueError("Non-integer years and months are "
                             "ambiguous and not currently supported.")

        if dt1 and dt2:
            # datetime is a subclass of date. So both must be date
            if not (isinstance(dt1, datetime.date) and
                    isinstance(dt2, datetime.date)):
                raise TypeError("relativedelta only diffs datetime/date")

            # We allow two dates, or two datetimes, so we coerce them to be
            # of the same type
            if (isinstance(dt1, datetime.datetime) !=
                    isinstance(dt2, datetime.datetime)):
                if not isinstance(dt1, datetime.datetime):
                    dt1 = datetime.datetime.fromordinal(dt1.toordinal())
                elif not isinstance(dt2, datetime.datetime):
                    dt2 = datetime.datetime.fromordinal(dt2.toordinal())

            self.years = 0
            self.months = 0
            self.days = 0
            self.leapdays = 0
            self.hours = 0
            self.minutes = 0
            self.seconds = 0
            self.microseconds = 0
            self.year = None
            self.month = None
            self.day = None
            self.weekday = None
            self.hour = None
            self.minute = None
            self.second = None
            self.microsecond = None
            self._has_time = 0

            # Get year / month delta between the two
            months = (dt1.year - dt2.year) * 12 + (dt1.month - dt2.month)
            self._set_months(months)

            # Remove the year/month delta so the timedelta is just well-defined
            # time units (seconds, days and microseconds)
            dtm = self.__radd__(dt2)

            # If we've overshot our target, make an adjustment
            if dt1 < dt2:
                compare = operator.gt
                increment = 1
            else:
                compare = operator.lt
                increment = -1

            while compare(dt1, dtm):
                months += increment
                self._set_months(months)
                dtm = self.__radd__(dt2)

            # Get the timedelta between the "months-adjusted" date and dt1
            delta = dt1 - dtm
            self.seconds = delta.seconds + delta.days * 86400
            self.microseconds = delta.microseconds
        else:
            # Relative information
            self.years = years
            self.months = months
            self.days = days + weeks * 7
            self.leapdays = leapdays
            self.hours = hours
            self.minutes = minutes
            self.seconds = seconds
            self.microseconds = microseconds

            # Absolute information
            self.year = year
            self.month = month
            self.day = day
            self.hour = hour
            self.minute = minute
            self.second = second
            self.microsecond = microsecond

            if any(x is not None and int(x) != x
                   for x in (year, month, day, hour,
                             minute, second, microsecond)):
                # For now we'll deprecate floats - later it'll be an error.
                warn("Non-integer value passed as absolute information. " +
                     "This is not a well-defined condition and will raise " +
                     "errors in future versions.", DeprecationWarning)

            if isinstance(weekday, integer_types):
                self.weekday = weekdays[weekday]
            else:
                self.weekday = weekday

            yday = 0
            if nlyearday:
                yday = nlyearday
            elif yearday:
                yday = yearday
                if yearday > 59:
                    self.leapdays = -1
            if yday:
                ydayidx = [31, 59, 90, 120, 151, 181, 212,
                           243, 273, 304, 334, 366]
                for idx, ydays in enumerate(ydayidx):
                    if yday <= ydays:
                        self.month = idx+1
                        if idx == 0:
                            self.day = yday
                        else:
                            self.day = yday-ydayidx[idx-1]
                        break
                else:
                    raise ValueError("invalid year day (%d)" % yday)

        self._fix()

    def _fix(self):
        if abs(self.microseconds) > 999999:
            s = _sign(self.microseconds)
            div, mod = divmod(self.microseconds * s, 1000000)
            self.microseconds = mod * s
            self.seconds += div * s
        if abs(self.seconds) > 59:
            s = _sign(self.seconds)
            div, mod = divmod(self.seconds * s, 60)
            self.seconds = mod * s
            self.minutes += div * s
        if abs(self.minutes) > 59:
            s = _sign(self.minutes)
            div, mod = divmod(self.minutes * s, 60)
            self.minutes = mod * s
            self.hours += div * s
        if abs(self.hours) > 23:
            s = _sign(self.hours)
            div, mod = divmod(self.hours * s, 24)
            self.hours = mod * s
            self.days += div * s
        if abs(self.months) > 11:
            s = _sign(self.months)
            div, mod = divmod(self.months * s, 12)
            self.months = mod * s
            self.years += div * s
        if (self.hours or self.minutes or self.seconds or self.microseconds
                or self.hour is not None or self.minute is not None or
                self.second is not None or self.microsecond is not None):
            self._has_time = 1
        else:
            self._has_time = 0

    @property
    def weeks(self):
        return self.days // 7

    @weeks.setter
    def weeks(self, value):
        self.days = self.days - (self.weeks * 7) + value * 7

    def _set_months(self, months):
        self.months = months
        if abs(self.months) > 11:
            s = _sign(self.months)
            div, mod = divmod(self.months * s, 12)
            self.months = mod * s
            self.years = div * s
        else:
            self.years = 0

    def normalized(self):
        """
        Return a version of this object represented entirely using integer
        values for the relative attributes.

        >>> relativedelta(days=1.5, hours=2).normalized()
        relativedelta(days=1, hours=14)

        :return:
            Returns a :class:`dateutil.relativedelta.relativedelta` object.
        """
        # Cascade remainders down (rounding each to roughly nearest microsecond)
        days = int(self.days)

        hours_f = round(self.hours + 24 * (self.days - days), 11)
        hours = int(hours_f)

        minutes_f = round(self.minutes + 60 * (hours_f - hours), 10)
        minutes = int(minutes_f)

        seconds_f = round(self.seconds + 60 * (minutes_f - minutes), 8)
        seconds = int(seconds_f)

        microseconds = round(self.microseconds + 1e6 * (seconds_f - seconds))

        # Constructor carries overflow back up with call to _fix()
        return self.__class__(years=self.years, months=self.months,
                              days=days, hours=hours, minutes=minutes,
                              seconds=seconds, microseconds=microseconds,
                              leapdays=self.leapdays, year=self.year,
                              month=self.month, day=self.day,
                              weekday=self.weekday, hour=self.hour,
                              minute=self.minute, second=self.second,
                              microsecond=self.microsecond)

    def __add__(self, other):
        if isinstance(other, relativedelta):
            return self.__class__(years=other.years + self.years,
                                 months=other.months + self.months,
                                 days=other.days + self.days,
                                 hours=other.hours + self.hours,
                                 minutes=other.minutes + self.minutes,
                                 seconds=other.seconds + self.seconds,
                                 microseconds=(other.microseconds +
                                               self.microseconds),
                                 leapdays=other.leapdays or self.leapdays,
                                 year=(other.year if other.year is not None
                                       else self.year),
                                 month=(other.month if other.month is not None
                                        else self.month),
                                 day=(other.day if other.day is not None
                                      else self.day),
                                 weekday=(other.weekday if other.weekday is not None
                                          else self.weekday),
                                 hour=(other.hour if other.hour is not None
                                       else self.hour),
                                 minute=(other.minute if other.minute is not None
                                         else self.minute),
                                 second=(other.second if other.second is not None
                                         else self.second),
                                 microsecond=(other.microsecond if other.microsecond
                                              is not None else
                                              self.microsecond))
        if isinstance(other, datetime.timedelta):
            return self.__class__(years=self.years,
                                  months=self.months,
                                  days=self.days + other.days,
                                  hours=self.hours,
                                  minutes=self.minutes,
                                  seconds=self.seconds + other.seconds,
                                  microseconds=self.microseconds + other.microseconds,
                                  leapdays=self.leapdays,
                                  year=self.year,
                                  month=self.month,
                                  day=self.day,
                                  weekday=self.weekday,
                                  hour=self.hour,
                                  minute=self.minute,
                                  second=self.second,
                                  microsecond=self.microsecond)
        if not isinstance(other, datetime.date):
            return NotImplemented
        elif self._has_time and not isinstance(other, datetime.datetime):
            other = datetime.datetime.fromordinal(other.toordinal())
        year = (self.year or other.year)+self.years
        month = self.month or other.month
        if self.months:
            assert 1 <= abs(self.months) <= 12
            month += self.months
            if month > 12:
                year += 1
                month -= 12
            elif month < 1:
                year -= 1
                month += 12
        day = min(calendar.monthrange(year, month)[1],
                  self.day or other.day)
        repl = {"year": year, "month": month, "day": day}
        for attr in ["hour", "minute", "second", "microsecond"]:
            value = getattr(self, attr)
            if value is not None:
                repl[attr] = value
        days = self.days
        if self.leapdays and month > 2 and calendar.isleap(year):
            days += self.leapdays
        ret = (other.replace(**repl)
               + datetime.timedelta(days=days,
                                    hours=self.hours,
                                    minutes=self.minutes,
                                    seconds=self.seconds,
                                    microseconds=self.microseconds))
        if self.weekday:
            weekday, nth = self.weekday.weekday, self.weekday.n or 1
            jumpdays = (abs(nth) - 1) * 7
            if nth > 0:
                jumpdays += (7 - ret.weekday() + weekday) % 7
            else:
                jumpdays += (ret.weekday() - weekday) % 7
                jumpdays *= -1
            ret += datetime.timedelta(days=jumpdays)
        return ret

    def __radd__(self, other):
        return self.__add__(other)

    def __rsub__(self, other):
        return self.__neg__().__radd__(other)

    def __sub__(self, other):
        if not isinstance(other, relativedelta):
            return NotImplemented   # In case the other object defines __rsub__
        return self.__class__(years=self.years - other.years,
                             months=self.months - other.months,
                             days=self.days - other.days,
                             hours=self.hours - other.hours,
                             minutes=self.minutes - other.minutes,
                             seconds=self.seconds - other.seconds,
                             microseconds=self.microseconds - other.microseconds,
                             leapdays=self.leapdays or other.leapdays,
                             year=(self.year if self.year is not None
                                   else other.year),
                             month=(self.month if self.month is not None else
                                    other.month),
                             day=(self.day if self.day is not None else
                                  other.day),
                             weekday=(self.weekday if self.weekday is not None else
                                      other.weekday),
                             hour=(self.hour if self.hour is not None else
                                   other.hour),
                             minute=(self.minute if self.minute is not None else
                                     other.minute),
                             second=(self.second if self.second is not None else
                                     other.second),
                             microsecond=(self.microsecond if self.microsecond
                                          is not None else
                                          other.microsecond))

    def __neg__(self):
        return self.__class__(years=-self.years,
                             months=-self.months,
                             days=-self.days,
                             hours=-self.hours,
                             minutes=-self.minutes,
                             seconds=-self.seconds,
                             microseconds=-self.microseconds,
                             leapdays=self.leapdays,
                             year=self.year,
                             month=self.month,
                             day=self.day,
                             weekday=self.weekday,
                             hour=self.hour,
                             minute=self.minute,
                             second=self.second,
                             microsecond=self.microsecond)

    def __bool__(self):
        return not (not self.years and
                    not self.months and
                    not self.days and
                    not self.hours and
                    not self.minutes and
                    not self.seconds and
                    not self.microseconds and
                    not self.leapdays and
                    self.year is None and
                    self.month is None and
                    self.day is None and
                    self.weekday is None and
                    self.hour is None and
                    self.minute is None and
                    self.second is None and
                    self.microsecond is None)
    # Compatibility with Python 2.x
    __nonzero__ = __bool__

    def __mul__(self, other):
        try:
            f = float(other)
        except TypeError:
            return NotImplemented

        return self.__class__(years=int(self.years * f),
                             months=int(self.months * f),
                             days=int(self.days * f),
                             hours=int(self.hours * f),
                             minutes=int(self.minutes * f),
                             seconds=int(self.seconds * f),
                             microseconds=int(self.microseconds * f),
                             leapdays=self.leapdays,
                             year=self.year,
                             month=self.month,
                             day=self.day,
                             weekday=self.weekday,
                             hour=self.hour,
                             minute=self.minute,
                             second=self.second,
                             microsecond=self.microsecond)

    __rmul__ = __mul__

    def __eq__(self, other):
        if not isinstance(other, relativedelta):
            return NotImplemented
        if self.weekday or other.weekday:
            if not self.weekday or not other.weekday:
                return False
            if self.weekday.weekday != other.weekday.weekday:
                return False
            n1, n2 = self.weekday.n, other.weekday.n
            if n1 != n2 and not ((not n1 or n1 == 1) and (not n2 or n2 == 1)):
                return False
        return (self.years == other.years and
                self.months == other.months and
                self.days == other.days and
                self.hours == other.hours and
                self.minutes == other.minutes and
                self.seconds == other.seconds and
                self.microseconds == other.microseconds and
                self.leapdays == other.leapdays and
                self.year == other.year and
                self.month == other.month and
                self.day == other.day and
                self.hour == other.hour and
                self.minute == other.minute and
                self.second == other.second and
                self.microsecond == other.microsecond)

    __hash__ = None

    def __ne__(self, other):
        return not self.__eq__(other)

    def __div__(self, other):
        try:
            reciprocal = 1 / float(other)
        except TypeError:
            return NotImplemented

        return self.__mul__(reciprocal)

    __truediv__ = __div__

    def __repr__(self):
        l = []
        for attr in ["years", "months", "days", "leapdays",
                     "hours", "minutes", "seconds", "microseconds"]:
            value = getattr(self, attr)
            if value:
                l.append("{attr}={value:+g}".format(attr=attr, value=value))
        for attr in ["year", "month", "day", "weekday",
                     "hour", "minute", "second", "microsecond"]:
            value = getattr(self, attr)
            if value is not None:
                l.append("{attr}={value}".format(attr=attr, value=repr(value)))
        return "{classname}({attrs})".format(classname=self.__class__.__name__,
                                             attrs=", ".join(l))


def _sign(x):
    return int(copysign(1, x))

# vim:ts=4:sw=4:et
PKa�\�_,�����	parser.pynu�[���# -*- coding: utf-8 -*-
"""
This module offers a generic date/time string parser which is able to parse
most known formats to represent a date and/or time.

This module attempts to be forgiving with regards to unlikely input formats,
returning a datetime object even for dates which are ambiguous. If an element
of a date/time stamp is omitted, the following rules are applied:
- If AM or PM is left unspecified, a 24-hour clock is assumed, however, an hour
  on a 12-hour clock (``0 <= hour <= 12``) *must* be specified if AM or PM is
  specified.
- If a time zone is omitted, a timezone-naive datetime is returned.

If any other elements are missing, they are taken from the
:class:`datetime.datetime` object passed to the parameter ``default``. If this
results in a day number exceeding the valid number of days per month, the
value falls back to the end of the month.

Additional resources about date/time string formats can be found below:

- `A summary of the international standard date and time notation
  <http://www.cl.cam.ac.uk/~mgk25/iso-time.html>`_
- `W3C Date and Time Formats <http://www.w3.org/TR/NOTE-datetime>`_
- `Time Formats (Planetary Rings Node) <http://pds-rings.seti.org/tools/time_formats.html>`_
- `CPAN ParseDate module
  <http://search.cpan.org/~muir/Time-modules-2013.0912/lib/Time/ParseDate.pm>`_
- `Java SimpleDateFormat Class
  <https://docs.oracle.com/javase/6/docs/api/java/text/SimpleDateFormat.html>`_
"""
from __future__ import unicode_literals

import datetime
import string
import time
import collections
import re
from io import StringIO
from calendar import monthrange

from six import text_type, binary_type, integer_types

from . import relativedelta
from . import tz

__all__ = ["parse", "parserinfo"]


class _timelex(object):
    # Fractional seconds are sometimes split by a comma
    _split_decimal = re.compile("([.,])")

    def __init__(self, instream):
        if isinstance(instream, binary_type):
            instream = instream.decode()

        if isinstance(instream, text_type):
            instream = StringIO(instream)

        if getattr(instream, 'read', None) is None:
            raise TypeError('Parser must be a string or character stream, not '
                            '{itype}'.format(itype=instream.__class__.__name__))

        self.instream = instream
        self.charstack = []
        self.tokenstack = []
        self.eof = False

    def get_token(self):
        """
        This function breaks the time string into lexical units (tokens), which
        can be parsed by the parser. Lexical units are demarcated by changes in
        the character set, so any continuous string of letters is considered
        one unit, any continuous string of numbers is considered one unit.

        The main complication arises from the fact that dots ('.') can be used
        both as separators (e.g. "Sep.20.2009") or decimal points (e.g.
        "4:30:21.447"). As such, it is necessary to read the full context of
        any dot-separated strings before breaking it into tokens; as such, this
        function maintains a "token stack", for when the ambiguous context
        demands that multiple tokens be parsed at once.
        """
        if self.tokenstack:
            return self.tokenstack.pop(0)

        seenletters = False
        token = None
        state = None

        while not self.eof:
            # We only realize that we've reached the end of a token when we
            # find a character that's not part of the current token - since
            # that character may be part of the next token, it's stored in the
            # charstack.
            if self.charstack:
                nextchar = self.charstack.pop(0)
            else:
                nextchar = self.instream.read(1)
                while nextchar == '\x00':
                    nextchar = self.instream.read(1)

            if not nextchar:
                self.eof = True
                break
            elif not state:
                # First character of the token - determines if we're starting
                # to parse a word, a number or something else.
                token = nextchar
                if self.isword(nextchar):
                    state = 'a'
                elif self.isnum(nextchar):
                    state = '0'
                elif self.isspace(nextchar):
                    token = ' '
                    break  # emit token
                else:
                    break  # emit token
            elif state == 'a':
                # If we've already started reading a word, we keep reading
                # letters until we find something that's not part of a word.
                seenletters = True
                if self.isword(nextchar):
                    token += nextchar
                elif nextchar == '.':
                    token += nextchar
                    state = 'a.'
                else:
                    self.charstack.append(nextchar)
                    break  # emit token
            elif state == '0':
                # If we've already started reading a number, we keep reading
                # numbers until we find something that doesn't fit.
                if self.isnum(nextchar):
                    token += nextchar
                elif nextchar == '.' or (nextchar == ',' and len(token) >= 2):
                    token += nextchar
                    state = '0.'
                else:
                    self.charstack.append(nextchar)
                    break  # emit token
            elif state == 'a.':
                # If we've seen some letters and a dot separator, continue
                # parsing, and the tokens will be broken up later.
                seenletters = True
                if nextchar == '.' or self.isword(nextchar):
                    token += nextchar
                elif self.isnum(nextchar) and token[-1] == '.':
                    token += nextchar
                    state = '0.'
                else:
                    self.charstack.append(nextchar)
                    break  # emit token
            elif state == '0.':
                # If we've seen at least one dot separator, keep going, we'll
                # break up the tokens later.
                if nextchar == '.' or self.isnum(nextchar):
                    token += nextchar
                elif self.isword(nextchar) and token[-1] == '.':
                    token += nextchar
                    state = 'a.'
                else:
                    self.charstack.append(nextchar)
                    break  # emit token

        if (state in ('a.', '0.') and (seenletters or token.count('.') > 1 or
                                       token[-1] in '.,')):
            l = self._split_decimal.split(token)
            token = l[0]
            for tok in l[1:]:
                if tok:
                    self.tokenstack.append(tok)

        if state == '0.' and token.count('.') == 0:
            token = token.replace(',', '.')

        return token

    def __iter__(self):
        return self

    def __next__(self):
        token = self.get_token()
        if token is None:
            raise StopIteration

        return token

    def next(self):
        return self.__next__()  # Python 2.x support

    @classmethod
    def split(cls, s):
        return list(cls(s))

    @classmethod
    def isword(cls, nextchar):
        """ Whether or not the next character is part of a word """
        return nextchar.isalpha()

    @classmethod
    def isnum(cls, nextchar):
        """ Whether the next character is part of a number """
        return nextchar.isdigit()

    @classmethod
    def isspace(cls, nextchar):
        """ Whether the next character is whitespace """
        return nextchar.isspace()


class _resultbase(object):

    def __init__(self):
        for attr in self.__slots__:
            setattr(self, attr, None)

    def _repr(self, classname):
        l = []
        for attr in self.__slots__:
            value = getattr(self, attr)
            if value is not None:
                l.append("%s=%s" % (attr, repr(value)))
        return "%s(%s)" % (classname, ", ".join(l))

    def __len__(self):
        return (sum(getattr(self, attr) is not None
                    for attr in self.__slots__))

    def __repr__(self):
        return self._repr(self.__class__.__name__)


class parserinfo(object):
    """
    Class which handles what inputs are accepted. Subclass this to customize
    the language and acceptable values for each parameter.

    :param dayfirst:
            Whether to interpret the first value in an ambiguous 3-integer date
            (e.g. 01/05/09) as the day (``True``) or month (``False``). If
            ``yearfirst`` is set to ``True``, this distinguishes between YDM
            and YMD. Default is ``False``.

    :param yearfirst:
            Whether to interpret the first value in an ambiguous 3-integer date
            (e.g. 01/05/09) as the year. If ``True``, the first number is taken
            to be the year, otherwise the last number is taken to be the year.
            Default is ``False``.
    """

    # m from a.m/p.m, t from ISO T separator
    JUMP = [" ", ".", ",", ";", "-", "/", "'",
            "at", "on", "and", "ad", "m", "t", "of",
            "st", "nd", "rd", "th"]

    WEEKDAYS = [("Mon", "Monday"),
                ("Tue", "Tuesday"),
                ("Wed", "Wednesday"),
                ("Thu", "Thursday"),
                ("Fri", "Friday"),
                ("Sat", "Saturday"),
                ("Sun", "Sunday")]
    MONTHS = [("Jan", "January"),
              ("Feb", "February"),
              ("Mar", "March"),
              ("Apr", "April"),
              ("May", "May"),
              ("Jun", "June"),
              ("Jul", "July"),
              ("Aug", "August"),
              ("Sep", "Sept", "September"),
              ("Oct", "October"),
              ("Nov", "November"),
              ("Dec", "December")]
    HMS = [("h", "hour", "hours"),
           ("m", "minute", "minutes"),
           ("s", "second", "seconds")]
    AMPM = [("am", "a"),
            ("pm", "p")]
    UTCZONE = ["UTC", "GMT", "Z"]
    PERTAIN = ["of"]
    TZOFFSET = {}

    def __init__(self, dayfirst=False, yearfirst=False):
        self._jump = self._convert(self.JUMP)
        self._weekdays = self._convert(self.WEEKDAYS)
        self._months = self._convert(self.MONTHS)
        self._hms = self._convert(self.HMS)
        self._ampm = self._convert(self.AMPM)
        self._utczone = self._convert(self.UTCZONE)
        self._pertain = self._convert(self.PERTAIN)

        self.dayfirst = dayfirst
        self.yearfirst = yearfirst

        self._year = time.localtime().tm_year
        self._century = self._year // 100 * 100

    def _convert(self, lst):
        dct = {}
        for i, v in enumerate(lst):
            if isinstance(v, tuple):
                for v in v:
                    dct[v.lower()] = i
            else:
                dct[v.lower()] = i
        return dct

    def jump(self, name):
        return name.lower() in self._jump

    def weekday(self, name):
        if len(name) >= min(len(n) for n in self._weekdays.keys()):
            try:
                return self._weekdays[name.lower()]
            except KeyError:
                pass
        return None

    def month(self, name):
        if len(name) >= min(len(n) for n in self._months.keys()):
            try:
                return self._months[name.lower()] + 1
            except KeyError:
                pass
        return None

    def hms(self, name):
        try:
            return self._hms[name.lower()]
        except KeyError:
            return None

    def ampm(self, name):
        try:
            return self._ampm[name.lower()]
        except KeyError:
            return None

    def pertain(self, name):
        return name.lower() in self._pertain

    def utczone(self, name):
        return name.lower() in self._utczone

    def tzoffset(self, name):
        if name in self._utczone:
            return 0

        return self.TZOFFSET.get(name)

    def convertyear(self, year, century_specified=False):
        if year < 100 and not century_specified:
            year += self._century
            if abs(year - self._year) >= 50:
                if year < self._year:
                    year += 100
                else:
                    year -= 100
        return year

    def validate(self, res):
        # move to info
        if res.year is not None:
            res.year = self.convertyear(res.year, res.century_specified)

        if res.tzoffset == 0 and not res.tzname or res.tzname == 'Z':
            res.tzname = "UTC"
            res.tzoffset = 0
        elif res.tzoffset != 0 and res.tzname and self.utczone(res.tzname):
            res.tzoffset = 0
        return True


class _ymd(list):
    def __init__(self, tzstr, *args, **kwargs):
        super(self.__class__, self).__init__(*args, **kwargs)
        self.century_specified = False
        self.tzstr = tzstr

    @staticmethod
    def token_could_be_year(token, year):
        try:
            return int(token) == year
        except ValueError:
            return False

    @staticmethod
    def find_potential_year_tokens(year, tokens):
        return [token for token in tokens if _ymd.token_could_be_year(token, year)]

    def find_probable_year_index(self, tokens):
        """
        attempt to deduce if a pre 100 year was lost
         due to padded zeros being taken off
        """
        for index, token in enumerate(self):
            potential_year_tokens = _ymd.find_potential_year_tokens(token, tokens)
            if len(potential_year_tokens) == 1 and len(potential_year_tokens[0]) > 2:
                return index

    def append(self, val):
        if hasattr(val, '__len__'):
            if val.isdigit() and len(val) > 2:
                self.century_specified = True
        elif val > 100:
            self.century_specified = True

        super(self.__class__, self).append(int(val))

    def resolve_ymd(self, mstridx, yearfirst, dayfirst):
        len_ymd = len(self)
        year, month, day = (None, None, None)

        if len_ymd > 3:
            raise ValueError("More than three YMD values")
        elif len_ymd == 1 or (mstridx != -1 and len_ymd == 2):
            # One member, or two members with a month string
            if mstridx != -1:
                month = self[mstridx]
                del self[mstridx]

            if len_ymd > 1 or mstridx == -1:
                if self[0] > 31:
                    year = self[0]
                else:
                    day = self[0]

        elif len_ymd == 2:
            # Two members with numbers
            if self[0] > 31:
                # 99-01
                year, month = self
            elif self[1] > 31:
                # 01-99
                month, year = self
            elif dayfirst and self[1] <= 12:
                # 13-01
                day, month = self
            else:
                # 01-13
                month, day = self

        elif len_ymd == 3:
            # Three members
            if mstridx == 0:
                month, day, year = self
            elif mstridx == 1:
                if self[0] > 31 or (yearfirst and self[2] <= 31):
                    # 99-Jan-01
                    year, month, day = self
                else:
                    # 01-Jan-01
                    # Give precendence to day-first, since
                    # two-digit years is usually hand-written.
                    day, month, year = self

            elif mstridx == 2:
                # WTF!?
                if self[1] > 31:
                    # 01-99-Jan
                    day, year, month = self
                else:
                    # 99-01-Jan
                    year, day, month = self

            else:
                if self[0] > 31 or \
                    self.find_probable_year_index(_timelex.split(self.tzstr)) == 0 or \
                   (yearfirst and self[1] <= 12 and self[2] <= 31):
                    # 99-01-01
                    if dayfirst and self[2] <= 12:
                        year, day, month = self
                    else:
                        year, month, day = self
                elif self[0] > 12 or (dayfirst and self[1] <= 12):
                    # 13-01-01
                    day, month, year = self
                else:
                    # 01-13-01
                    month, day, year = self

        return year, month, day


class parser(object):
    def __init__(self, info=None):
        self.info = info or parserinfo()

    def parse(self, timestr, default=None, ignoretz=False, tzinfos=None, **kwargs):
        """
        Parse the date/time string into a :class:`datetime.datetime` object.

        :param timestr:
            Any date/time string using the supported formats.

        :param default:
            The default datetime object, if this is a datetime object and not
            ``None``, elements specified in ``timestr`` replace elements in the
            default object.

        :param ignoretz:
            If set ``True``, time zones in parsed strings are ignored and a
            naive :class:`datetime.datetime` object is returned.

        :param tzinfos:
            Additional time zone names / aliases which may be present in the
            string. This argument maps time zone names (and optionally offsets
            from those time zones) to time zones. This parameter can be a
            dictionary with timezone aliases mapping time zone names to time
            zones or a function taking two parameters (``tzname`` and
            ``tzoffset``) and returning a time zone.

            The timezones to which the names are mapped can be an integer
            offset from UTC in minutes or a :class:`tzinfo` object.

            .. doctest::
               :options: +NORMALIZE_WHITESPACE

                >>> from dateutil.parser import parse
                >>> from dateutil.tz import gettz
                >>> tzinfos = {"BRST": -10800, "CST": gettz("America/Chicago")}
                >>> parse("2012-01-19 17:21:00 BRST", tzinfos=tzinfos)
                datetime.datetime(2012, 1, 19, 17, 21, tzinfo=tzoffset(u'BRST', -10800))
                >>> parse("2012-01-19 17:21:00 CST", tzinfos=tzinfos)
                datetime.datetime(2012, 1, 19, 17, 21,
                                  tzinfo=tzfile('/usr/share/zoneinfo/America/Chicago'))

            This parameter is ignored if ``ignoretz`` is set.

        :param **kwargs:
            Keyword arguments as passed to ``_parse()``.

        :return:
            Returns a :class:`datetime.datetime` object or, if the
            ``fuzzy_with_tokens`` option is ``True``, returns a tuple, the
            first element being a :class:`datetime.datetime` object, the second
            a tuple containing the fuzzy tokens.

        :raises ValueError:
            Raised for invalid or unknown string format, if the provided
            :class:`tzinfo` is not in a valid format, or if an invalid date
            would be created.

        :raises TypeError:
            Raised for non-string or character stream input.

        :raises OverflowError:
            Raised if the parsed date exceeds the largest valid C integer on
            your system.
        """

        if default is None:
            default = datetime.datetime.now().replace(hour=0, minute=0,
                                                      second=0, microsecond=0)

        res, skipped_tokens = self._parse(timestr, **kwargs)

        if res is None:
            raise ValueError("Unknown string format")

        if len(res) == 0:
            raise ValueError("String does not contain a date.")

        repl = {}
        for attr in ("year", "month", "day", "hour",
                     "minute", "second", "microsecond"):
            value = getattr(res, attr)
            if value is not None:
                repl[attr] = value

        if 'day' not in repl:
            # If the default day exceeds the last day of the month, fall back to
            # the end of the month.
            cyear = default.year if res.year is None else res.year
            cmonth = default.month if res.month is None else res.month
            cday = default.day if res.day is None else res.day

            if cday > monthrange(cyear, cmonth)[1]:
                repl['day'] = monthrange(cyear, cmonth)[1]

        ret = default.replace(**repl)

        if res.weekday is not None and not res.day:
            ret = ret+relativedelta.relativedelta(weekday=res.weekday)

        if not ignoretz:
            if (isinstance(tzinfos, collections.Callable) or
                    tzinfos and res.tzname in tzinfos):

                if isinstance(tzinfos, collections.Callable):
                    tzdata = tzinfos(res.tzname, res.tzoffset)
                else:
                    tzdata = tzinfos.get(res.tzname)

                if isinstance(tzdata, datetime.tzinfo):
                    tzinfo = tzdata
                elif isinstance(tzdata, text_type):
                    tzinfo = tz.tzstr(tzdata)
                elif isinstance(tzdata, integer_types):
                    tzinfo = tz.tzoffset(res.tzname, tzdata)
                else:
                    raise ValueError("Offset must be tzinfo subclass, "
                                     "tz string, or int offset.")
                ret = ret.replace(tzinfo=tzinfo)
            elif res.tzname and res.tzname in time.tzname:
                ret = ret.replace(tzinfo=tz.tzlocal())
            elif res.tzoffset == 0:
                ret = ret.replace(tzinfo=tz.tzutc())
            elif res.tzoffset:
                ret = ret.replace(tzinfo=tz.tzoffset(res.tzname, res.tzoffset))

        if kwargs.get('fuzzy_with_tokens', False):
            return ret, skipped_tokens
        else:
            return ret

    class _result(_resultbase):
        __slots__ = ["year", "month", "day", "weekday",
                     "hour", "minute", "second", "microsecond",
                     "tzname", "tzoffset", "ampm"]

    def _parse(self, timestr, dayfirst=None, yearfirst=None, fuzzy=False,
               fuzzy_with_tokens=False):
        """
        Private method which performs the heavy lifting of parsing, called from
        ``parse()``, which passes on its ``kwargs`` to this function.

        :param timestr:
            The string to parse.

        :param dayfirst:
            Whether to interpret the first value in an ambiguous 3-integer date
            (e.g. 01/05/09) as the day (``True``) or month (``False``). If
            ``yearfirst`` is set to ``True``, this distinguishes between YDM
            and YMD. If set to ``None``, this value is retrieved from the
            current :class:`parserinfo` object (which itself defaults to
            ``False``).

        :param yearfirst:
            Whether to interpret the first value in an ambiguous 3-integer date
            (e.g. 01/05/09) as the year. If ``True``, the first number is taken
            to be the year, otherwise the last number is taken to be the year.
            If this is set to ``None``, the value is retrieved from the current
            :class:`parserinfo` object (which itself defaults to ``False``).

        :param fuzzy:
            Whether to allow fuzzy parsing, allowing for string like "Today is
            January 1, 2047 at 8:21:00AM".

        :param fuzzy_with_tokens:
            If ``True``, ``fuzzy`` is automatically set to True, and the parser
            will return a tuple where the first element is the parsed
            :class:`datetime.datetime` datetimestamp and the second element is
            a tuple containing the portions of the string which were ignored:

            .. doctest::

                >>> from dateutil.parser import parse
                >>> parse("Today is January 1, 2047 at 8:21:00AM", fuzzy_with_tokens=True)
                (datetime.datetime(2047, 1, 1, 8, 21), (u'Today is ', u' ', u'at '))

        """
        if fuzzy_with_tokens:
            fuzzy = True

        info = self.info

        if dayfirst is None:
            dayfirst = info.dayfirst

        if yearfirst is None:
            yearfirst = info.yearfirst

        res = self._result()
        l = _timelex.split(timestr)         # Splits the timestr into tokens

        # keep up with the last token skipped so we can recombine
        # consecutively skipped tokens (-2 for when i begins at 0).
        last_skipped_token_i = -2
        skipped_tokens = list()

        try:
            # year/month/day list
            ymd = _ymd(timestr)

            # Index of the month string in ymd
            mstridx = -1

            len_l = len(l)
            i = 0
            while i < len_l:

                # Check if it's a number
                try:
                    value_repr = l[i]
                    value = float(value_repr)
                except ValueError:
                    value = None

                if value is not None:
                    # Token is a number
                    len_li = len(l[i])
                    i += 1

                    if (len(ymd) == 3 and len_li in (2, 4)
                        and res.hour is None and (i >= len_l or (l[i] != ':' and
                                                  info.hms(l[i]) is None))):
                        # 19990101T23[59]
                        s = l[i-1]
                        res.hour = int(s[:2])

                        if len_li == 4:
                            res.minute = int(s[2:])

                    elif len_li == 6 or (len_li > 6 and l[i-1].find('.') == 6):
                        # YYMMDD or HHMMSS[.ss]
                        s = l[i-1]

                        if not ymd and l[i-1].find('.') == -1:
                            #ymd.append(info.convertyear(int(s[:2])))

                            ymd.append(s[:2])
                            ymd.append(s[2:4])
                            ymd.append(s[4:])
                        else:
                            # 19990101T235959[.59]
                            res.hour = int(s[:2])
                            res.minute = int(s[2:4])
                            res.second, res.microsecond = _parsems(s[4:])

                    elif len_li in (8, 12, 14):
                        # YYYYMMDD
                        s = l[i-1]
                        ymd.append(s[:4])
                        ymd.append(s[4:6])
                        ymd.append(s[6:8])

                        if len_li > 8:
                            res.hour = int(s[8:10])
                            res.minute = int(s[10:12])

                            if len_li > 12:
                                res.second = int(s[12:])

                    elif ((i < len_l and info.hms(l[i]) is not None) or
                          (i+1 < len_l and l[i] == ' ' and
                           info.hms(l[i+1]) is not None)):

                        # HH[ ]h or MM[ ]m or SS[.ss][ ]s
                        if l[i] == ' ':
                            i += 1

                        idx = info.hms(l[i])

                        while True:
                            if idx == 0:
                                res.hour = int(value)

                                if value % 1:
                                    res.minute = int(60*(value % 1))

                            elif idx == 1:
                                res.minute = int(value)

                                if value % 1:
                                    res.second = int(60*(value % 1))

                            elif idx == 2:
                                res.second, res.microsecond = \
                                    _parsems(value_repr)

                            i += 1

                            if i >= len_l or idx == 2:
                                break

                            # 12h00
                            try:
                                value_repr = l[i]
                                value = float(value_repr)
                            except ValueError:
                                break
                            else:
                                i += 1
                                idx += 1

                                if i < len_l:
                                    newidx = info.hms(l[i])

                                    if newidx is not None:
                                        idx = newidx

                    elif (i == len_l and l[i-2] == ' ' and
                          info.hms(l[i-3]) is not None):
                        # X h MM or X m SS
                        idx = info.hms(l[i-3])

                        if idx == 0:               # h
                            res.minute = int(value)

                            sec_remainder = value % 1
                            if sec_remainder:
                                res.second = int(60 * sec_remainder)
                        elif idx == 1:             # m
                            res.second, res.microsecond = \
                                _parsems(value_repr)

                        # We don't need to advance the tokens here because the
                        # i == len_l call indicates that we're looking at all
                        # the tokens already.

                    elif i+1 < len_l and l[i] == ':':
                        # HH:MM[:SS[.ss]]
                        res.hour = int(value)
                        i += 1
                        value = float(l[i])
                        res.minute = int(value)

                        if value % 1:
                            res.second = int(60*(value % 1))

                        i += 1

                        if i < len_l and l[i] == ':':
                            res.second, res.microsecond = _parsems(l[i+1])
                            i += 2

                    elif i < len_l and l[i] in ('-', '/', '.'):
                        sep = l[i]
                        ymd.append(value_repr)
                        i += 1

                        if i < len_l and not info.jump(l[i]):
                            try:
                                # 01-01[-01]
                                ymd.append(l[i])
                            except ValueError:
                                # 01-Jan[-01]
                                value = info.month(l[i])

                                if value is not None:
                                    ymd.append(value)
                                    assert mstridx == -1
                                    mstridx = len(ymd)-1
                                else:
                                    return None, None

                            i += 1

                            if i < len_l and l[i] == sep:
                                # We have three members
                                i += 1
                                value = info.month(l[i])

                                if value is not None:
                                    ymd.append(value)
                                    mstridx = len(ymd)-1
                                    assert mstridx == -1
                                else:
                                    ymd.append(l[i])

                                i += 1
                    elif i >= len_l or info.jump(l[i]):
                        if i+1 < len_l and info.ampm(l[i+1]) is not None:
                            # 12 am
                            res.hour = int(value)

                            if res.hour < 12 and info.ampm(l[i+1]) == 1:
                                res.hour += 12
                            elif res.hour == 12 and info.ampm(l[i+1]) == 0:
                                res.hour = 0

                            i += 1
                        else:
                            # Year, month or day
                            ymd.append(value)
                        i += 1
                    elif info.ampm(l[i]) is not None:

                        # 12am
                        res.hour = int(value)

                        if res.hour < 12 and info.ampm(l[i]) == 1:
                            res.hour += 12
                        elif res.hour == 12 and info.ampm(l[i]) == 0:
                            res.hour = 0
                        i += 1

                    elif not fuzzy:
                        return None, None
                    else:
                        i += 1
                    continue

                # Check weekday
                value = info.weekday(l[i])
                if value is not None:
                    res.weekday = value
                    i += 1
                    continue

                # Check month name
                value = info.month(l[i])
                if value is not None:
                    ymd.append(value)
                    assert mstridx == -1
                    mstridx = len(ymd)-1

                    i += 1
                    if i < len_l:
                        if l[i] in ('-', '/'):
                            # Jan-01[-99]
                            sep = l[i]
                            i += 1
                            ymd.append(l[i])
                            i += 1

                            if i < len_l and l[i] == sep:
                                # Jan-01-99
                                i += 1
                                ymd.append(l[i])
                                i += 1

                        elif (i+3 < len_l and l[i] == l[i+2] == ' '
                              and info.pertain(l[i+1])):
                            # Jan of 01
                            # In this case, 01 is clearly year
                            try:
                                value = int(l[i+3])
                            except ValueError:
                                # Wrong guess
                                pass
                            else:
                                # Convert it here to become unambiguous
                                ymd.append(str(info.convertyear(value)))
                            i += 4
                    continue

                # Check am/pm
                value = info.ampm(l[i])
                if value is not None:
                    # For fuzzy parsing, 'a' or 'am' (both valid English words)
                    # may erroneously trigger the AM/PM flag. Deal with that
                    # here.
                    val_is_ampm = True

                    # If there's already an AM/PM flag, this one isn't one.
                    if fuzzy and res.ampm is not None:
                        val_is_ampm = False

                    # If AM/PM is found and hour is not, raise a ValueError
                    if res.hour is None:
                        if fuzzy:
                            val_is_ampm = False
                        else:
                            raise ValueError('No hour specified with ' +
                                             'AM or PM flag.')
                    elif not 0 <= res.hour <= 12:
                        # If AM/PM is found, it's a 12 hour clock, so raise
                        # an error for invalid range
                        if fuzzy:
                            val_is_ampm = False
                        else:
                            raise ValueError('Invalid hour specified for ' +
                                             '12-hour clock.')

                    if val_is_ampm:
                        if value == 1 and res.hour < 12:
                            res.hour += 12
                        elif value == 0 and res.hour == 12:
                            res.hour = 0

                        res.ampm = value

                    elif fuzzy:
                        last_skipped_token_i = self._skip_token(skipped_tokens,
                                                    last_skipped_token_i, i, l)
                    i += 1
                    continue

                # Check for a timezone name
                if (res.hour is not None and len(l[i]) <= 5 and
                        res.tzname is None and res.tzoffset is None and
                        not [x for x in l[i] if x not in
                             string.ascii_uppercase]):
                    res.tzname = l[i]
                    res.tzoffset = info.tzoffset(res.tzname)
                    i += 1

                    # Check for something like GMT+3, or BRST+3. Notice
                    # that it doesn't mean "I am 3 hours after GMT", but
                    # "my time +3 is GMT". If found, we reverse the
                    # logic so that timezone parsing code will get it
                    # right.
                    if i < len_l and l[i] in ('+', '-'):
                        l[i] = ('+', '-')[l[i] == '+']
                        res.tzoffset = None
                        if info.utczone(res.tzname):
                            # With something like GMT+3, the timezone
                            # is *not* GMT.
                            res.tzname = None

                    continue

                # Check for a numbered timezone
                if res.hour is not None and l[i] in ('+', '-'):
                    signal = (-1, 1)[l[i] == '+']
                    i += 1
                    len_li = len(l[i])

                    if len_li == 4:
                        # -0300
                        res.tzoffset = int(l[i][:2])*3600+int(l[i][2:])*60
                    elif i+1 < len_l and l[i+1] == ':':
                        # -03:00
                        res.tzoffset = int(l[i])*3600+int(l[i+2])*60
                        i += 2
                    elif len_li <= 2:
                        # -[0]3
                        res.tzoffset = int(l[i][:2])*3600
                    else:
                        return None, None
                    i += 1

                    res.tzoffset *= signal

                    # Look for a timezone name between parenthesis
                    if (i+3 < len_l and
                        info.jump(l[i]) and l[i+1] == '(' and l[i+3] == ')' and
                        3 <= len(l[i+2]) <= 5 and
                        not [x for x in l[i+2]
                             if x not in string.ascii_uppercase]):
                        # -0300 (BRST)
                        res.tzname = l[i+2]
                        i += 4
                    continue

                # Check jumps
                if not (info.jump(l[i]) or fuzzy):
                    return None, None

                last_skipped_token_i = self._skip_token(skipped_tokens,
                                                last_skipped_token_i, i, l)
                i += 1

            # Process year/month/day
            year, month, day = ymd.resolve_ymd(mstridx, yearfirst, dayfirst)
            if year is not None:
                res.year = year
                res.century_specified = ymd.century_specified

            if month is not None:
                res.month = month

            if day is not None:
                res.day = day

        except (IndexError, ValueError, AssertionError):
            return None, None

        if not info.validate(res):
            return None, None

        if fuzzy_with_tokens:
            return res, tuple(skipped_tokens)
        else:
            return res, None

    @staticmethod
    def _skip_token(skipped_tokens, last_skipped_token_i, i, l):
        if last_skipped_token_i == i - 1:
            # recombine the tokens
            skipped_tokens[-1] += l[i]
        else:
            # just append
            skipped_tokens.append(l[i])
        last_skipped_token_i = i
        return last_skipped_token_i


DEFAULTPARSER = parser()


def parse(timestr, parserinfo=None, **kwargs):
    """

    Parse a string in one of the supported formats, using the
    ``parserinfo`` parameters.

    :param timestr:
        A string containing a date/time stamp.

    :param parserinfo:
        A :class:`parserinfo` object containing parameters for the parser.
        If ``None``, the default arguments to the :class:`parserinfo`
        constructor are used.

    The ``**kwargs`` parameter takes the following keyword arguments:

    :param default:
        The default datetime object, if this is a datetime object and not
        ``None``, elements specified in ``timestr`` replace elements in the
        default object.

    :param ignoretz:
        If set ``True``, time zones in parsed strings are ignored and a naive
        :class:`datetime` object is returned.

    :param tzinfos:
            Additional time zone names / aliases which may be present in the
            string. This argument maps time zone names (and optionally offsets
            from those time zones) to time zones. This parameter can be a
            dictionary with timezone aliases mapping time zone names to time
            zones or a function taking two parameters (``tzname`` and
            ``tzoffset``) and returning a time zone.

            The timezones to which the names are mapped can be an integer
            offset from UTC in minutes or a :class:`tzinfo` object.

            .. doctest::
               :options: +NORMALIZE_WHITESPACE

                >>> from dateutil.parser import parse
                >>> from dateutil.tz import gettz
                >>> tzinfos = {"BRST": -10800, "CST": gettz("America/Chicago")}
                >>> parse("2012-01-19 17:21:00 BRST", tzinfos=tzinfos)
                datetime.datetime(2012, 1, 19, 17, 21, tzinfo=tzoffset(u'BRST', -10800))
                >>> parse("2012-01-19 17:21:00 CST", tzinfos=tzinfos)
                datetime.datetime(2012, 1, 19, 17, 21,
                                  tzinfo=tzfile('/usr/share/zoneinfo/America/Chicago'))

            This parameter is ignored if ``ignoretz`` is set.

    :param dayfirst:
        Whether to interpret the first value in an ambiguous 3-integer date
        (e.g. 01/05/09) as the day (``True``) or month (``False``). If
        ``yearfirst`` is set to ``True``, this distinguishes between YDM and
        YMD. If set to ``None``, this value is retrieved from the current
        :class:`parserinfo` object (which itself defaults to ``False``).

    :param yearfirst:
        Whether to interpret the first value in an ambiguous 3-integer date
        (e.g. 01/05/09) as the year. If ``True``, the first number is taken to
        be the year, otherwise the last number is taken to be the year. If
        this is set to ``None``, the value is retrieved from the current
        :class:`parserinfo` object (which itself defaults to ``False``).

    :param fuzzy:
        Whether to allow fuzzy parsing, allowing for string like "Today is
        January 1, 2047 at 8:21:00AM".

    :param fuzzy_with_tokens:
        If ``True``, ``fuzzy`` is automatically set to True, and the parser
        will return a tuple where the first element is the parsed
        :class:`datetime.datetime` datetimestamp and the second element is
        a tuple containing the portions of the string which were ignored:

        .. doctest::

            >>> from dateutil.parser import parse
            >>> parse("Today is January 1, 2047 at 8:21:00AM", fuzzy_with_tokens=True)
            (datetime.datetime(2047, 1, 1, 8, 21), (u'Today is ', u' ', u'at '))

    :return:
        Returns a :class:`datetime.datetime` object or, if the
        ``fuzzy_with_tokens`` option is ``True``, returns a tuple, the
        first element being a :class:`datetime.datetime` object, the second
        a tuple containing the fuzzy tokens.

    :raises ValueError:
        Raised for invalid or unknown string format, if the provided
        :class:`tzinfo` is not in a valid format, or if an invalid date
        would be created.

    :raises OverflowError:
        Raised if the parsed date exceeds the largest valid C integer on
        your system.
    """
    if parserinfo:
        return parser(parserinfo).parse(timestr, **kwargs)
    else:
        return DEFAULTPARSER.parse(timestr, **kwargs)


class _tzparser(object):

    class _result(_resultbase):

        __slots__ = ["stdabbr", "stdoffset", "dstabbr", "dstoffset",
                     "start", "end"]

        class _attr(_resultbase):
            __slots__ = ["month", "week", "weekday",
                         "yday", "jyday", "day", "time"]

        def __repr__(self):
            return self._repr("")

        def __init__(self):
            _resultbase.__init__(self)
            self.start = self._attr()
            self.end = self._attr()

    def parse(self, tzstr):
        res = self._result()
        l = _timelex.split(tzstr)
        try:

            len_l = len(l)

            i = 0
            while i < len_l:
                # BRST+3[BRDT[+2]]
                j = i
                while j < len_l and not [x for x in l[j]
                                         if x in "0123456789:,-+"]:
                    j += 1
                if j != i:
                    if not res.stdabbr:
                        offattr = "stdoffset"
                        res.stdabbr = "".join(l[i:j])
                    else:
                        offattr = "dstoffset"
                        res.dstabbr = "".join(l[i:j])
                    i = j
                    if (i < len_l and (l[i] in ('+', '-') or l[i][0] in
                                       "0123456789")):
                        if l[i] in ('+', '-'):
                            # Yes, that's right.  See the TZ variable
                            # documentation.
                            signal = (1, -1)[l[i] == '+']
                            i += 1
                        else:
                            signal = -1
                        len_li = len(l[i])
                        if len_li == 4:
                            # -0300
                            setattr(res, offattr, (int(l[i][:2])*3600 +
                                                   int(l[i][2:])*60)*signal)
                        elif i+1 < len_l and l[i+1] == ':':
                            # -03:00
                            setattr(res, offattr,
                                    (int(l[i])*3600+int(l[i+2])*60)*signal)
                            i += 2
                        elif len_li <= 2:
                            # -[0]3
                            setattr(res, offattr,
                                    int(l[i][:2])*3600*signal)
                        else:
                            return None
                        i += 1
                    if res.dstabbr:
                        break
                else:
                    break

            if i < len_l:
                for j in range(i, len_l):
                    if l[j] == ';':
                        l[j] = ','

                assert l[i] == ','

                i += 1

            if i >= len_l:
                pass
            elif (8 <= l.count(',') <= 9 and
                  not [y for x in l[i:] if x != ','
                       for y in x if y not in "0123456789"]):
                # GMT0BST,3,0,30,3600,10,0,26,7200[,3600]
                for x in (res.start, res.end):
                    x.month = int(l[i])
                    i += 2
                    if l[i] == '-':
                        value = int(l[i+1])*-1
                        i += 1
                    else:
                        value = int(l[i])
                    i += 2
                    if value:
                        x.week = value
                        x.weekday = (int(l[i])-1) % 7
                    else:
                        x.day = int(l[i])
                    i += 2
                    x.time = int(l[i])
                    i += 2
                if i < len_l:
                    if l[i] in ('-', '+'):
                        signal = (-1, 1)[l[i] == "+"]
                        i += 1
                    else:
                        signal = 1
                    res.dstoffset = (res.stdoffset+int(l[i]))*signal
            elif (l.count(',') == 2 and l[i:].count('/') <= 2 and
                  not [y for x in l[i:] if x not in (',', '/', 'J', 'M',
                                                     '.', '-', ':')
                       for y in x if y not in "0123456789"]):
                for x in (res.start, res.end):
                    if l[i] == 'J':
                        # non-leap year day (1 based)
                        i += 1
                        x.jyday = int(l[i])
                    elif l[i] == 'M':
                        # month[-.]week[-.]weekday
                        i += 1
                        x.month = int(l[i])
                        i += 1
                        assert l[i] in ('-', '.')
                        i += 1
                        x.week = int(l[i])
                        if x.week == 5:
                            x.week = -1
                        i += 1
                        assert l[i] in ('-', '.')
                        i += 1
                        x.weekday = (int(l[i])-1) % 7
                    else:
                        # year day (zero based)
                        x.yday = int(l[i])+1

                    i += 1

                    if i < len_l and l[i] == '/':
                        i += 1
                        # start time
                        len_li = len(l[i])
                        if len_li == 4:
                            # -0300
                            x.time = (int(l[i][:2])*3600+int(l[i][2:])*60)
                        elif i+1 < len_l and l[i+1] == ':':
                            # -03:00
                            x.time = int(l[i])*3600+int(l[i+2])*60
                            i += 2
                            if i+1 < len_l and l[i+1] == ':':
                                i += 2
                                x.time += int(l[i])
                        elif len_li <= 2:
                            # -[0]3
                            x.time = (int(l[i][:2])*3600)
                        else:
                            return None
                        i += 1

                    assert i == len_l or l[i] == ','

                    i += 1

                assert i >= len_l

        except (IndexError, ValueError, AssertionError):
            return None

        return res


DEFAULTTZPARSER = _tzparser()


def _parsetz(tzstr):
    return DEFAULTTZPARSER.parse(tzstr)


def _parsems(value):
    """Parse a I[.F] seconds value into (seconds, microseconds)."""
    if "." not in value:
        return int(value), 0
    else:
        i, f = value.split(".")
        return int(i), int(f.ljust(6, "0")[:6])


# vim:ts=4:sw=4:et
PKa�\�^����_version.pynu�[���PKa�\^tR����'__pycache__/parser.cpython-36.opt-1.pycnu�[���PKa�\mw��� '�__pycache__/tzwin.cpython-36.pycnu�[���PKa�\tz�t�t�&��__pycache__/rrule.cpython-36.opt-1.pycnu�[���PKa�\�[/'�$__pycache__/easter.cpython-36.opt-1.pycnu�[���PKa�\W�eFF);-__pycache__/_version.cpython-36.opt-1.pycnu�[���PKa�\�}��|�|�!�.__pycache__/parser.cpython-36.pycnu�[���PKa�\�􄩦�#��__pycache__/__init__.cpython-36.pycnu�[���PKa�\mw���&��__pycache__/tzwin.cpython-36.opt-1.pycnu�[���PKa�\tz�t�t� {�__pycache__/rrule.cpython-36.pycnu�[���PKa�\W�eFF#?T__pycache__/_version.cpython-36.pycnu�[���PKa�\�[/!�U__pycache__/easter.cpython-36.pycnu�[���PKa�\�􄩦�)G^__pycache__/__init__.cpython-36.opt-1.pycnu�[���PKa�\T�O��7�7(F___pycache__/relativedelta.cpython-36.pycnu�[���PKa�\v=��ee(w�__pycache__/_common.cpython-36.opt-1.pycnu�[���PKa�\�ol��7�7.4�__pycache__/relativedelta.cpython-36.opt-1.pycnu�[���PKa�\v=��ee"3�__pycache__/_common.cpython-36.pycnu�[���PKa�\��L�
��_common.pynu�[���PKa�\�9�;;$�tzwin.pynu�[���PKa�\�,�EE��__init__.pynu�[���PKa�\�	/������rrule.pynu�[���PKa�\_ސ��$�$!��tz/__pycache__/win.cpython-36.pycnu�[���PKa�\)XH_a�a� �tz/__pycache__/tz.cpython-36.pycnu�[���PKa�\_ސ��$�$'�tz/__pycache__/win.cpython-36.opt-1.pycnu�[���PKa�\)XH_a�a�&��tz/__pycache__/tz.cpython-36.opt-1.pycnu�[���PKa�\�r��22&�0tz/__pycache__/__init__.cpython-36.pycnu�[���PKa�\�r��22,:2tz/__pycache__/__init__.cpython-36.opt-1.pycnu�[���PKa�\IœA�,�,+�3tz/__pycache__/_common.cpython-36.opt-1.pycnu�[���PKa�\IœA�,�,%�`tz/__pycache__/_common.cpython-36.pycnu�[���PKa�\�N���.�.
܍tz/_common.pynu�[���PKa�\�U�����tz/__init__.pynu�[���PKa�\��Ɗ������tz/tz.pynu�[���PKa�\��9Å,�,	ƃtz/win.pynu�[���PKa�\�-r1��zoneinfo/__pycache__/rebuild.cpython-36.opt-1.pycnu�[���PKa�\4����,�zoneinfo/__pycache__/__init__.cpython-36.pycnu�[���PKa�\�-r+��zoneinfo/__pycache__/rebuild.cpython-36.pycnu�[���PKa�\4����2S�zoneinfo/__pycache__/__init__.cpython-36.opt-1.pycnu�[���PKa�\�
 �[[b�zoneinfo/__init__.pynu�[���PKa�\����!zoneinfo/dateutil-zoneinfo.tar.gznu�[���PKa�\3+����&	zoneinfo/rebuild.pynu�[���PKa�\hq��E
E
	�-	easter.pynu�[���PKa�\�І�iZiZ-8	relativedelta.pynu�[���PKa�\�_,�����	֒	parser.pynu�[���PK++�
Z