Na}{

File Content: financial.pyo

�
�9Zc��������
���@`�s=��d��Z��d�d�l�m�Z�m�Z�m�Z�d�d�l�Z�d�d�d�d�d�d	�d
�d�d�d
�g
�Z�i	�d�d�6d�d�6d�d�6d�d�6d�d�6d�d�6d�d�6d�d�6d�d�6Z�d����Z	�d�d���Z
�d�d�d���Z�d�d�d���Z�d�d�d���Z
�d����Z�d�d�d���Z�d�d�d���Z�d����Z�d�d �d!�d"�d#���Z�d$����Z�d%����Z�d&����Z�d�S('���s����Some simple financial calculations

patterned after spreadsheet computations.

There is some complexity in each function
so that the functions behave like ufuncs with
broadcasting and being able to be called with scalars
or arrays (or other sequences).

i����(���t���divisiont���absolute_importt���print_functionNt���fvt���pmtt���npert���ipmtt���ppmtt���pvt���ratet���irrt���npvt���mirrt���endi���t���begint���et���bt	���beginningt���startt���finishc���������C`�sX���t��|��t�j���r�|��Sy�t�|��SWn/�t�t�f�k
�rS�g��|��D]�}�t�|�^�q?�SXd��S(���N(���t
���isinstancet���npt���ndarrayt���_when_to_numt���KeyErrort	���TypeError(���t���whent���x(����(����sF���/opt/alt/python27/lib64/python2.7/site-packages/numpy/lib/financial.pyt
���_convert_when���s����c���	������C`�s����t��|���}�t�t�j�|��|�|�|�|�g���\�}��}�}�}�}�d�|��|�}�t�j�|��|�|�|�|���}�t�j�|�j���}�t�j�|��|�k�|�|�d�|��|�|�d�|��|���}�|�|�|�|�S(���s�
��
    Compute the future value.

Given:
     * a present value, `pv`
     * an interest `rate` compounded once per period, of which
       there are
     * `nper` total
     * a (fixed) payment, `pmt`, paid either
     * at the beginning (`when` = {'begin', 1}) or the end
       (`when` = {'end', 0}) of each period

Return:
       the value at the end of the `nper` periods

Parameters
    ----------
    rate : scalar or array_like of shape(M, )
        Rate of interest as decimal (not per cent) per period
    nper : scalar or array_like of shape(M, )
        Number of compounding periods
    pmt : scalar or array_like of shape(M, )
        Payment
    pv : scalar or array_like of shape(M, )
        Present value
    when : {{'begin', 1}, {'end', 0}}, {string, int}, optional
        When payments are due ('begin' (1) or 'end' (0)).
        Defaults to {'end', 0}.

Returns
    -------
    out : ndarray
        Future values.  If all input is scalar, returns a scalar float.  If
        any input is array_like, returns future values for each input element.
        If multiple inputs are array_like, they all must have the same shape.

Notes
    -----
    The future value is computed by solving the equation::

fv +
     pv*(1+rate)**nper +
     pmt*(1 + rate*when)/rate*((1 + rate)**nper - 1) == 0

or, when ``rate == 0``::

fv + pv + pmt * nper == 0

References
    ----------
    .. [WRW] Wheeler, D. A., E. Rathke, and R. Weir (Eds.) (2009, May).
       Open Document Format for Office Applications (OpenDocument)v1.2,
       Part 2: Recalculated Formula (OpenFormula) Format - Annotated Version,
       Pre-Draft 12. Organization for the Advancement of Structured Information
       Standards (OASIS). Billerica, MA, USA. [ODT Document].
       Available:
       http://www.oasis-open.org/committees/documents.php?wg_abbrev=office-formula
       OpenDocument-formula-20090508.odt

Examples
    --------
    What is the future value after 10 years of saving $100 now, with
    an additional monthly savings of $100.  Assume the interest rate is
    5% (annually) compounded monthly?

>>> np.fv(0.05/12, 10*12, -100, -100)
    15692.928894335748

By convention, the negative sign represents cash flow out (i.e. money not
    available today).  Thus, saving $100 a month at 5% annual interest leads
    to $15,692.93 available to spend in 10 years.

If any input is array_like, returns an array of equal shape.  Let's
    compare different interest rates from the example above.

>>> a = np.array((0.05, 0.06, 0.07))/12
    >>> np.fv(a, 10*12, -100, -100)
    array([ 15692.92889434,  16569.87435405,  17509.44688102])

i���(���R���t���mapR���t���asarrayt	���broadcastt���zerost���shapet���where(	���R	���R���R���R���R���t���tempt���mitert���zert���fact(����(����sF���/opt/alt/python27/lib64/python2.7/site-packages/numpy/lib/financial.pyR���$���s����Q0!c���	������C`�s����t��|���}�t�t�j�|��|�|�|�|�g���\�}��}�}�}�}�d�|��|�}�|��d�k�}�t�j�|��d�d�|��t�j�t�j�|��|�|�|�|���j���}�t�j�|�|�k�|�|�d�|��|�|�d�|��|���}�|�|�|�|�S(���s�
��
    Compute the payment against loan principal plus interest.

Given:
     * a present value, `pv` (e.g., an amount borrowed)
     * a future value, `fv` (e.g., 0)
     * an interest `rate` compounded once per period, of which
       there are
     * `nper` total
     * and (optional) specification of whether payment is made
       at the beginning (`when` = {'begin', 1}) or the end
       (`when` = {'end', 0}) of each period

Return:
       the (fixed) periodic payment.

Parameters
    ----------
    rate : array_like
        Rate of interest (per period)
    nper : array_like
        Number of compounding periods
    pv : array_like
        Present value
    fv : array_like,  optional
        Future value (default = 0)
    when : {{'begin', 1}, {'end', 0}}, {string, int}
        When payments are due ('begin' (1) or 'end' (0))

Returns
    -------
    out : ndarray
        Payment against loan plus interest.  If all input is scalar, returns a
        scalar float.  If any input is array_like, returns payment for each
        input element. If multiple inputs are array_like, they all must have
        the same shape.

Notes
    -----
    The payment is computed by solving the equation::

fv +
     pv*(1 + rate)**nper +
     pmt*(1 + rate*when)/rate*((1 + rate)**nper - 1) == 0

or, when ``rate == 0``::

fv + pv + pmt * nper == 0

for ``pmt``.

Note that computing a monthly mortgage payment is only
    one use for this function.  For example, pmt returns the
    periodic deposit one must make to achieve a specified
    future balance given an initial deposit, a fixed,
    periodically compounded interest rate, and the total
    number of periods.

References
    ----------
    .. [WRW] Wheeler, D. A., E. Rathke, and R. Weir (Eds.) (2009, May).
       Open Document Format for Office Applications (OpenDocument)v1.2,
       Part 2: Recalculated Formula (OpenFormula) Format - Annotated Version,
       Pre-Draft 12. Organization for the Advancement of Structured Information
       Standards (OASIS). Billerica, MA, USA. [ODT Document].
       Available:
       http://www.oasis-open.org/committees/documents.php
       ?wg_abbrev=office-formulaOpenDocument-formula-20090508.odt

Examples
    --------
    What is the monthly payment needed to pay off a $200,000 loan in 15
    years at an annual interest rate of 7.5%?

>>> np.pmt(0.075/12, 12*15, 200000)
    -1854.0247200054619

In order to pay-off (i.e., have a future-value of 0) the $200,000 obtained
    today, a monthly payment of $1,854.02 would be required.  Note that this
    example illustrates usage of `fv` having a default value of 0.

i���g��������g�������?R"���(	���R���R���R���R���t���copytoR ���R���R!���R"���(	���R	���R���R���R���R���R#���t���maskt���zR&���(����(����sF���/opt/alt/python27/lib64/python2.7/site-packages/numpy/lib/financial.pyR���~���s����S0'7c������	���C`�s<��t��|���}�t�t�j�|��|�|�|�|�g���\�}��}�}�}�}�t�}�t�j�d�d����9�y�|�d�|��|�|��}�Wn�t�k
�r��t�}�n�XWd�QX|�r��|�|�|�d�S|�|�|�d�}�t�j�|�|�|�|���t�j�d�|����}�t�j	�|��|�|�|�|���}	�t�j
�|	�j���}
�t�j�|��|
�k�|�|
�|�|
���d�Sd�S(���sz��
    Compute the number of periodic payments.

Parameters
    ----------
    rate : array_like
        Rate of interest (per period)
    pmt : array_like
        Payment
    pv : array_like
        Present value
    fv : array_like, optional
        Future value
    when : {{'begin', 1}, {'end', 0}}, {string, int}, optional
        When payments are due ('begin' (1) or 'end' (0))

Notes
    -----
    The number of periods ``nper`` is computed by solving the equation::

fv + pv*(1+rate)**nper + pmt*(1+rate*when)/rate*((1+rate)**nper-1) = 0

but if ``rate = 0`` then::

fv + pv + pmt*nper = 0

Examples
    --------
    If you only had $150/month to pay towards the loan, how long would it take
    to pay-off a loan of $8,000 at 7% annual interest?

>>> print(round(np.nper(0.07/12, -150, 8000), 5))
    64.07335

So, over 64 months would be required to pay off the loan.

The same analysis could be done with several different interest rates
    and/or payments and/or total amounts to produce an entire table.

>>> np.nper(*(np.ogrid[0.07/12: 0.08/12: 0.01/12,
    ...                    -150   : -99     : 50    ,
    ...                    8000   : 9001    : 1000]))
    array([[[  64.07334877,   74.06368256],
            [ 108.07548412,  127.99022654]],
           [[  66.12443902,   76.87897353],
            [ 114.70165583,  137.90124779]]])

t���dividet���raiseg�������?Ng��������(
���R���R���R���R���t���Falset���errstatet���FloatingPointErrort���Truet���logR���R ���R!���R"���(���R	���R���R���R���R���t
���use_zero_rateR)���t���At���BR$���R%���(����(����sF���/opt/alt/python27/lib64/python2.7/site-packages/numpy/lib/financial.pyR�������s����10
-g��������c���������C`�s����t��|���}�t�j�|��|�|�|�|�|���\�}��}�}�}�}�}�t�|��|�|�|�|���}�t�|��|�|�|�|���|��}�yT�t�j�|�d�k�|�d�|��|���}�t�j�t�j�|�d�k�|�d�k���d�|���}�Wn�t�k
�r��n�X|�S(���s
��
    Compute the interest portion of a payment.

Parameters
    ----------
    rate : scalar or array_like of shape(M, )
        Rate of interest as decimal (not per cent) per period
    per : scalar or array_like of shape(M, )
        Interest paid against the loan changes during the life or the loan.
        The `per` is the payment period to calculate the interest amount.
    nper : scalar or array_like of shape(M, )
        Number of compounding periods
    pv : scalar or array_like of shape(M, )
        Present value
    fv : scalar or array_like of shape(M, ), optional
        Future value
    when : {{'begin', 1}, {'end', 0}}, {string, int}, optional
        When payments are due ('begin' (1) or 'end' (0)).
        Defaults to {'end', 0}.

Returns
    -------
    out : ndarray
        Interest portion of payment.  If all input is scalar, returns a scalar
        float.  If any input is array_like, returns interest payment for each
        input element. If multiple inputs are array_like, they all must have
        the same shape.

See Also
    --------
    pmt, pv, ipmt

(���R���R���(���R	���R8���R���R���R���R���t���total(����(����sF���/opt/alt/python27/lib64/python2.7/site-packages/numpy/lib/financial.pyR������s����c���	������C`�s����t��|���}�t�t�j�|��|�|�|�|�g���\�}��}�}�}�}�d�|��|�}�t�j�|��|�|�|�|���}�t�j�|�j���}�t�j�|��|�k�|�|�d�|��|�|�d�|��|���}�|�|�|�|�S(���s�
��
    Compute the present value.

Given:
     * a future value, `fv`
     * an interest `rate` compounded once per period, of which
       there are
     * `nper` total
     * a (fixed) payment, `pmt`, paid either
     * at the beginning (`when` = {'begin', 1}) or the end
       (`when` = {'end', 0}) of each period

Return:
       the value now

Parameters
    ----------
    rate : array_like
        Rate of interest (per period)
    nper : array_like
        Number of compounding periods
    pmt : array_like
        Payment
    fv : array_like, optional
        Future value
    when : {{'begin', 1}, {'end', 0}}, {string, int}, optional
        When payments are due ('begin' (1) or 'end' (0))

Returns
    -------
    out : ndarray, float
        Present value of a series of payments or investments.

Notes
    -----
    The present value is computed by solving the equation::

fv +
     pv*(1 + rate)**nper +
     pmt*(1 + rate*when)/rate*((1 + rate)**nper - 1) = 0

or, when ``rate = 0``::

fv + pv + pmt * nper = 0

for `pv`, which is then returned.

Examples
    --------
    What is the present value (e.g., the initial investment)
    of an investment that needs to total $15692.93
    after 10 years of saving $100 every month?  Assume the
    interest rate is 5% (annually) compounded monthly.

>>> np.pv(0.05/12, 10*12, -100, 15692.93)
    -100.00067131625819

By convention, the negative sign represents cash flow out
    (i.e., money not available today).  Thus, to end up with
    $15,692.93 in 10 years saving $100 a month at 5% annual
    interest, one's initial deposit should also be $100.

If any input is array_like, ``pv`` returns an array of equal shape.
    Let's compare different interest rates in the example above:

>>> a = np.array((0.05, 0.04, 0.03))/12
    >>> np.pv(a, 10*12, -100, 15692.93)
    array([ -100.00067132,  -649.26771385, -1273.78633713])

So, to end up with the same $15692.93 under the same $100 per month
    "savings plan," for annual interest rates of 4% and 3%, one would
    need initial investments of $649.27 and $1273.79, respectively.

i���(���R���R���R���R���R���R ���R!���R"���(	���R	���R���R���R���R���R#���R$���R%���R&���(����(����sF���/opt/alt/python27/lib64/python2.7/site-packages/numpy/lib/financial.pyR������s����V07c���������C`�s����|��d�|�}�|��d�|�d�}�|�|�|�|�|�d�|��|�d�|��|�|�|�|�|�d�|��|�d�|��d�|�|�|�|��|�d�|��|�|�d�|�|��S(���Ni���i���(����(���t���rt���nt���pR���t���yt���wt���t1t���t2(����(����sF���/opt/alt/python27/lib64/python2.7/site-packages/numpy/lib/financial.pyt	���_g_div_gp��s
����'Gg�������?g���ư>id���c���
������C`�s����t��|���}�t�t�j�|��|�|�|�|�g���\�}��}�}�}�}�|�}�d�}	�t�}
�xk�|	�|�k��r��|
�r��|�t�|�|��|�|�|�|���}�t�|�|���}�t�j�|�|�k����}
�|	�d�7}	�|�}�qQ�W|
�s��t�j�|�S|�Sd�S(���s3��
    Compute the rate of interest per period.

Parameters
    ----------
    nper : array_like
        Number of compounding periods
    pmt : array_like
        Payment
    pv : array_like
        Present value
    fv : array_like
        Future value
    when : {{'begin', 1}, {'end', 0}}, {string, int}, optional
        When payments are due ('begin' (1) or 'end' (0))
    guess : float, optional
        Starting guess for solving the rate of interest
    tol : float, optional
        Required tolerance for the solution
    maxiter : int, optional
        Maximum iterations in finding the solution

Notes
    -----
    The rate of interest is computed by iteratively solving the
    (non-linear) equation::

fv + pv*(1+rate)**nper + pmt*(1+rate*when)/rate * ((1+rate)**nper - 1) = 0

for ``rate``.

References
    ----------
    Wheeler, D. A., E. Rathke, and R. Weir (Eds.) (2009, May). Open Document
    Format for Office Applications (OpenDocument)v1.2, Part 2: Recalculated
    Formula (OpenFormula) Format - Annotated Version, Pre-Draft 12.
    Organization for the Advancement of Structured Information Standards
    (OASIS). Billerica, MA, USA. [ODT Document]. Available:
    http://www.oasis-open.org/committees/documents.php?wg_abbrev=office-formula
    OpenDocument-formula-20090508.odt

i����i���N(	���R���R���R���R���R,���RB���t���abst���allt���nan(
���R���R���R���R���R���t���guesst���tolt���maxitert���rnt���itert���closet���rnp1t���diff(����(����sF���/opt/alt/python27/lib64/python2.7/site-packages/numpy/lib/financial.pyR	�����s����+0

c���������C`�s����t��j�|��d�d�d�����}�|�j�d�k�|�j�d�k�@}�|�j�d�k�rN�t��j�S|�|�j�}�d�|�d�}�|�j�t��j�t��j�|�������}�|�S(���s���
    Return the Internal Rate of Return (IRR).

This is the "average" periodically compounded rate of return
    that gives a net present value of 0.0; for a more complete explanation,
    see Notes below.

Parameters
    ----------
    values : array_like, shape(N,)
        Input cash flows per time period.  By convention, net "deposits"
        are negative and net "withdrawals" are positive.  Thus, for
        example, at least the first element of `values`, which represents
        the initial investment, will typically be negative.

Returns
    -------
    out : float
        Internal Rate of Return for periodic input values.

Notes
    -----
    The IRR is perhaps best understood through an example (illustrated
    using np.irr in the Examples section below).  Suppose one invests 100
    units and then makes the following withdrawals at regular (fixed)
    intervals: 39, 59, 55, 20.  Assuming the ending value is 0, one's 100
    unit investment yields 173 units; however, due to the combination of
    compounding and the periodic withdrawals, the "average" rate of return
    is neither simply 0.73/4 nor (1.73)^0.25-1.  Rather, it is the solution
    (for :math:`r`) of the equation:

.. math:: -100 + \frac{39}{1+r} + \frac{59}{(1+r)^2}
     + \frac{55}{(1+r)^3} + \frac{20}{(1+r)^4} = 0

In general, for `values` :math:`= [v_0, v_1, ... v_M]`,
    irr is the solution of the equation: [G]_

.. math:: \sum_{t=0}^M{\frac{v_t}{(1+irr)^{t}}} = 0

References
    ----------
    .. [G] L. J. Gitman, "Principles of Managerial Finance, Brief," 3rd ed.,
       Addison-Wesley, 2003, pg. 348.

Examples
    --------
    >>> round(irr([-100, 39, 59, 55, 20]), 5)
    0.28095
    >>> round(irr([-100, 0, 0, 74]), 5)
    -0.0955
    >>> round(irr([-100, 100, 0, -7]), 5)
    -0.0833
    >>> round(irr([-100, 100, 0, 7]), 5)
    0.06206
    >>> round(irr([-5, 10.5, 1, -8, 1]), 5)
    0.0886

(Compare with the Example given for numpy.lib.financial.npv)

Ni����i����g�������?i���(	���R���t���rootst���imagt���realt���sizeRE���t���itemt���argminRC���(���t���valuest���resR(���R	���(����(����sF���/opt/alt/python27/lib64/python2.7/site-packages/numpy/lib/financial.pyR
���O��s����=
!c���������C`�s=���t��j�|���}�|�d�|��t��j�d�t�|�����j�d�d���S(���s���
    Returns the NPV (Net Present Value) of a cash flow series.

Parameters
    ----------
    rate : scalar
        The discount rate.
    values : array_like, shape(M, )
        The values of the time series of cash flows.  The (fixed) time
        interval between cash flow "events" must be the same as that for
        which `rate` is given (i.e., if `rate` is per year, then precisely
        a year is understood to elapse between each cash flow event).  By
        convention, investments or "deposits" are negative, income or
        "withdrawals" are positive; `values` must begin with the initial
        investment, thus `values[0]` will typically be negative.

Returns
    -------
    out : float
        The NPV of the input cash flow series `values` at the discount
        `rate`.

Notes
    -----
    Returns the result of: [G]_

.. math :: \sum_{t=0}^{M-1}{\frac{values_t}{(1+rate)^{t}}}

References
    ----------
    .. [G] L. J. Gitman, "Principles of Managerial Finance, Brief," 3rd ed.,
       Addison-Wesley, 2003, pg. 346.

Examples
    --------
    >>> np.npv(0.281,[-100, 39, 59, 55, 20])
    -0.0084785916384548798

(Compare with the Example given for numpy.lib.financial.irr)

i���i����t���axis(���R���R���t���aranget���lent���sum(���R	���RT���(����(����sF���/opt/alt/python27/lib64/python2.7/site-packages/numpy/lib/financial.pyR������s����*c���������C`�s����t��j�|��d�t��j��}��|��j�}�|��d�k�}�|��d�k��}�|�j����oN�|�j����sX�t��j�St��j�t�|�|��|�����}�t��j�t�|�|��|�����}�|�|�d�|�d�d�|�d�S(���s��
    Modified internal rate of return.

Parameters
    ----------
    values : array_like
        Cash flows (must contain at least one positive and one negative
        value) or nan is returned.  The first value is considered a sunk
        cost at time zero.
    finance_rate : scalar
        Interest rate paid on the cash flows
    reinvest_rate : scalar
        Interest rate received on the cash flows upon reinvestment

Returns
    -------
    out : float
        Modified internal rate of return

t���dtypei����g�������?i���(���R���R���t���doubleRQ���t���anyRE���RC���R���(���RT���t���finance_ratet
���reinvest_rateR<���t���post���negt���numert���denom(����(����sF���/opt/alt/python27/lib64/python2.7/site-packages/numpy/lib/financial.pyR������s����	(���t���__doc__t
���__future__R����R���R���t���numpyR���t���__all__R���R���R���R���R���R���R5���R���R���RB���R	���R
���R���R���(����(����(����sF���/opt/alt/python27/lib64/python2.7/site-packages/numpy/lib/financial.pyt���<module>
���s.���
	Z\D_		c	<	H	-

Name	Size	Permission
tests	---	0755
__init__.py	1189 bytes	0644
__init__.pyc	1324 bytes	0644
__init__.pyo	1324 bytes	0644
_datasource.py	21266 bytes	0644
_datasource.pyc	21830 bytes	0644
_datasource.pyo	21830 bytes	0644
_iotools.py	32062 bytes	0644
_iotools.pyc	30226 bytes	0644
_iotools.pyo	30226 bytes	0644
_version.py	4867 bytes	0644
_version.pyc	5781 bytes	0644
_version.pyo	5781 bytes	0644
arraypad.py	52079 bytes	0644
arraypad.pyc	49560 bytes	0644
arraypad.pyo	49560 bytes	0644
arraysetops.py	13815 bytes	0644
arraysetops.pyc	13687 bytes	0644
arraysetops.pyo	13687 bytes	0644
arrayterator.py	7203 bytes	0644
arrayterator.pyc	7868 bytes	0644
arrayterator.pyo	7868 bytes	0644
financial.py	23843 bytes	0644
financial.pyc	24785 bytes	0644
financial.pyo	24785 bytes	0644
format.py	28234 bytes	0644
format.pyc	25628 bytes	0644
format.pyo	25628 bytes	0644
function_base.py	150516 bytes	0644
function_base.pyc	136285 bytes	0644
function_base.pyo	136285 bytes	0644
index_tricks.py	26204 bytes	0644
index_tricks.pyc	27361 bytes	0644
index_tricks.pyo	27361 bytes	0644
info.py	6501 bytes	0644
info.pyc	6755 bytes	0644
info.pyo	6755 bytes	0644
nanfunctions.py	46486 bytes	0644
nanfunctions.pyc	45340 bytes	0644
nanfunctions.pyo	45340 bytes	0644
npyio.py	71412 bytes	0644
npyio.pyc	58376 bytes	0644
npyio.pyo	58376 bytes	0644
polynomial.py	38012 bytes	0644
polynomial.pyc	40460 bytes	0644
polynomial.pyo	40460 bytes	0644
recfunctions.py	35012 bytes	0644
recfunctions.pyc	31157 bytes	0644
recfunctions.pyo	31157 bytes	0644
scimath.py	14085 bytes	0644
scimath.pyc	16169 bytes	0644
scimath.pyo	16169 bytes	0644
setup.py	379 bytes	0644
setup.pyc	755 bytes	0644
setup.pyo	755 bytes	0644
shape_base.py	25574 bytes	0644
shape_base.pyc	27079 bytes	0644
shape_base.pyo	27079 bytes	0644
stride_tricks.py	6827 bytes	0644
stride_tricks.pyc	7096 bytes	0644
stride_tricks.pyo	7096 bytes	0644
twodim_base.py	26904 bytes	0644
twodim_base.pyc	29858 bytes	0644
twodim_base.pyo	29858 bytes	0644
type_check.py	15799 bytes	0644
type_check.pyc	17299 bytes	0644
type_check.pyo	17299 bytes	0644
ufunclike.py	4844 bytes	0644
ufunclike.pyc	5643 bytes	0644
ufunclike.pyo	5643 bytes	0644
user_array.py	8000 bytes	0644
user_array.pyc	16669 bytes	0644
user_array.pyo	16669 bytes	0644
utils.py	34996 bytes	0644
utils.pyc	30947 bytes	0644
utils.pyo	30947 bytes	0644