
    wg$R                        d Z ddlmZ ddlmZ ddlmZmZ ddlm	Z	m
Z
mZ ddlmZmZ ddlmZ ddlmZmZ dd	lmZmZ dd
lmZ ddlmZ ddlmZ ddlmZ ddlm Z m!Z! ddl"m#Z#m$Z$ ddl%m&Z& ddl'm(Z( ddl)m*Z* ddl+m,Z,m-Z-m.Z.m/Z/ ddl0m1Z1 ddl2m3Z3 ddl4m5Z5m6Z6m7Z7m8Z8m9Z9m:Z:m;Z;m<Z<m=Z=m>Z>  G d de5      Z? G d de?e6      Z@ G d de9e?      ZA G d de?e7      ZB G d d e>      ZC G d! d"eCe=      ZD G d# d$e:      ZE G d% d&eEe;      ZFd' ZGd( ZHy))*zl
Continuous Random Variables Module

See Also
========
sympy.stats.crv_types
sympy.stats.rv
sympy.stats.frv
    )Basic)cacheit)Lambda	PoleError)Inanoo)EqNe)S)Dummysymbols)_sympifysympify)	factorial)exp)	Piecewise)
DiracDelta)Integral	integrate)AndOr)PolynomialError)poly)series)	FiniteSetIntersectionIntervalUnion)solveset)reduce_rational_inequalities)
RandomDomainSingleDomainConditionalDomain	is_randomProductDomainPSpaceSinglePSpacerandom_symbolsNamedArgsMixinDistributionc                       e Zd ZdZdZd Zy)ContinuousDomainzX
    A domain with continuous support

    Represented using symbols and Intervals.
    Tc                     t        d      )Nz#Not Implemented for generic Domains)NotImplementedErrorselfs    T/home/mcse/projects/flask/flask-venv/lib/python3.12/site-packages/sympy/stats/crv.py
as_booleanzContinuousDomain.as_boolean,   s    !"GHH    N)__name__
__module____qualname____doc__is_Continuousr3    r4   r2   r-   r-   $   s    
 MIr4   r-   c                       e Zd ZdZddZd Zy)SingleContinuousDomainzj
    A univariate domain with continuous support

    Represented using a single symbol and interval.
    Nc                     || j                   }|s|S t        |      t        | j                         k7  rt        d      t        || j                  | j
                  ffi |S )NzValues should be equal)r   	frozenset
ValueErrorr   symbolset)r1   expr	variableskwargss       r2   compute_expectationz*SingleContinuousDomain.compute_expectation6   sZ    IKY9T\\#::566t{{DHH5@@@r4   c                 L    | j                   j                  | j                        S N)rA   as_relationalr@   r0   s    r2   r3   z!SingleContinuousDomain.as_boolean@   s    xx%%dkk22r4   rG   r5   r6   r7   r8   rE   r3   r:   r4   r2   r<   r<   0   s    
A3r4   r<   c                       e Zd ZdZddZd Zy)ProductContinuousDomainzE
    A collection of independent domains with continuous support
    Nc                     || j                   }| j                  D ]:  }t        |      t        |j                         z  }|s' |j                  ||fi |}< |S rG   )r   domainsr>   rE   )r1   rB   rC   rD   domaindomain_varss         r2   rE   z+ProductContinuousDomain.compute_expectationI   sa    Ill 	OF#I.6>>1JJK1v11$NvN	O r4   c                 h    t        | j                  D cg c]  }|j                          c} S c c}w rG   )r   rM   r3   )r1   rN   s     r2   r3   z"ProductContinuousDomain.as_booleanR   s(    t||DVV&&(DEEDs   /rG   rI   r:   r4   r2   rK   rK   D   s    Fr4   rK   c                   .    e Zd ZdZddZd Zed        Zy)ConditionalContinuousDomainzo
    A domain with continuous support that has been further restricted by a
    condition such as $x > 3$.
    Nc                    || j                   }|s|S | j                  j                  ||      }|j                  t	        |j
                        }}| j                  g}|ri|j                         }|j                  rIt        |t              r|j                  |j                         nt        |t              rt        d      |j                  r|j                   r&|t#        |j$                  |j&                  z
        z  }n|j(                  t+        | j                         z  }	t-        |	      dk7  rt        d       |	j                         }
t/        |      D ]Y  \  }}|d   |
k(  st1        ||
      }t3        |d   |d         }|j5                  |      }|
|j6                  |j8                  f||<   [ nt;        d|z        |rit=        |g|i |S )NzOr not implemented here   z-Multivariate Inequalities not yet implementedr      z+Condition %s is not a relational or Boolean)r   
fulldomainrE   functionlistlimits	conditionpop
is_Boolean
isinstancer   extendargsr   r/   is_Relationalis_Equalityr   lhsrhsfree_symbolsrA   len	enumerate!reduce_rational_inequalities_wrapr   	intersectleftright	TypeErrorr   )r1   rB   rC   rD   
fullintgrl	integrandrY   
conditionscondr   r@   ilimitcintvllintvlintvls                   r2   rE   z/ConditionalContinuousDomain.compute_expectation\   s   IK__88yI
&//j6G6G1H6	nn%
>>#DdC(%%dii0b)-.GHH####DHHtxx,?!@@I"//#dll2CCG7|q(1KM M )W[[]F$-f$5 
J5 8v-%F $f&.F &.eAha%AF$*$4$4V$<E)/U[[(IF1I
J  ADHJ J? D 	5F5f55r4   c                 ^    t        | j                  j                         | j                        S rG   )r   rV   r3   rZ   r0   s    r2   r3   z&ConditionalContinuousDomain.as_boolean   s     4??--/@@r4   c                     t        | j                        dk(  rC| j                  j                  t	        | j
                  t        | j                        d         z  S t        d      )NrT   r   z)Set of Conditional Domain not Implemented)re   r   rV   rA   rg   rZ   tupler/   r0   s    r2   rA   zConditionalContinuousDomain.set   s[    t||!OO''*Kdll 3A 6+8 8 9 &;= =r4   rG   )r5   r6   r7   r8   rE   r3   propertyrA   r:   r4   r2   rR   rR   V   s'    
-6^A = =r4   rR   c                       e Zd Zd Zy)ContinuousDistributionc                       | j                   | S rG   )pdf)r1   r_   s     r2   __call__zContinuousDistribution.__call__   s    txxr4   N)r5   r6   r7   r}   r:   r4   r2   rz   rz      s    r4   rz   c                       e Zd ZdZ ee e      Zd Zed        Z	e
d        Zd Zd Ze
d        Zd Zd	 Ze
d
        Zd Zd ZddZe
d        Zd Zd Zy)SingleContinuousDistributiona   Continuous distribution of a single variable.

    Explanation
    ===========

    Serves as superclass for Normal/Exponential/UniformDistribution etc....

    Represented by parameters for each of the specific classes.  E.g
    NormalDistribution is represented by a mean and standard deviation.

    Provides methods for pdf, cdf, and sampling.

    See Also
    ========

    sympy.stats.crv_types.*
    c                 `    t        t        t        |            }t        j                  | g| S rG   )rX   mapr   r   __new__)clsr_   s     r2   r   z$SingleContinuousDistribution.__new__   s'    C&'}}S(4((r4   c                       y rG   r:   )r_   s    r2   checkz"SingleContinuousDistribution.check   s    r4   c                     t        ddt              \  }}| j                  j                  }| j	                  |      }t        |j                         |||ffi |}t        |||k\  fd      }t        ||      S )zB Compute the CDF from the PDF.

        Returns a Lambda.
        x, zTrealr   r   T)	r   r   rA   startr|   r   doitr   r   )r1   rD   xz
left_boundr|   cdfs          r2   compute_cdfz(SingleContinuousDistribution.compute_cdf   sq     vDe41XX^^
 hhqk
Q
A$6A&Aa:o.	:a~r4   c                      y rG   r:   r1   r   s     r2   _cdfz!SingleContinuousDistribution._cdf       r4   c                 x    t        |      dk(  r| j                  |      }||S   | j                  di ||      S z Cumulative density function r   r:   )re   r   r   )r1   r   rD   r   s       r2   r   z SingleContinuousDistribution.cdf   sC    v;!))A,C
)t)&)!,,r4   c                     t        ddt              \  }}| j                  |      }t        t	        t
        |z  |z        |z  || j                  f      }t        ||      S )zV Compute the characteristic function from the PDF.

        Returns a Lambda.
        x, tTr   )r   r   r|   r   r   r   rA   r   )r1   rD   r   tr|   cfs         r2   compute_characteristic_functionz<SingleContinuousDistribution.compute_characteristic_function   sS     vDe41hhqks1Q3q5z#~488}5a}r4   c                      y rG   r:   r1   r   s     r2   _characteristic_functionz5SingleContinuousDistribution._characteristic_function   r   r4   c                 x    t        |      dk(  r| j                  |      }||S   | j                  di ||      S )z Characteristic function r   r:   )re   r   r   )r1   r   rD   r   s       r2   characteristic_functionz4SingleContinuousDistribution.characteristic_function   sF    v;!..q1B~	=3t33=f=a@@r4   c                     t        ddt              \  }}| j                  |      }t        t	        ||z        |z  || j
                  f      }t        ||      S )zY Compute the moment generating function from the PDF.

        Returns a Lambda.
        r   Tr   )r   r   r|   r   r   rA   r   )r1   rD   r   r   r|   mgfs         r2   "compute_moment_generating_functionz?SingleContinuousDistribution.compute_moment_generating_function   sP     vDe41hhqkAE
S(1dhh-8a~r4   c                      y rG   r:   r   s     r2   _moment_generating_functionz8SingleContinuousDistribution._moment_generating_function   r   r4   c                 `    |s| j                  |      }||S   | j                  di ||      S )z Moment generating function r:   )r   r   )r1   r   rD   r   s       r2   moment_generating_functionz7SingleContinuousDistribution.moment_generating_function   s=    66q9?J@6t66@@CCr4   c           	         |r	 t        ||      }|j                  rt        j                  S t	        dd      }| j                  |      }|+t        || j                  |      z  || j                  ffi |S |j                         }t        t        ||d|dz         j                         |      }	d}
t        |dz         D ]:  }|
|j                  ||z        |	j                  ||z        z  t        |      z  z  }
< |
S t!        || j                  |      z  || j                  ffi |S # t        $ r. t        || j                  |      z  || j                  ffi |cY S w xY w)z- Expectation of expression over distribution r   Tr   r   rT   )r   is_zeror   Zeror   r   r   r|   rA   degreer   removeOrangecoeff_monomialr   r   r   )r1   rB   varevaluaterD   pr   r   degtaylorresultks               r2   expectationz(SingleContinuousDistribution.expectation  s_   RsO9966M#D)66q9;$TDHHSM%9C?UfUUhhjfS!Qa8@@BAFs1u hAa..sax86;P;PQRVWQW;XX[def[gggFh D488C=03/LVLL # R !5TXXQ&QQRs   'D* A
D* 7BD* *4E! E!c           	         t        ddt              \  }}| j                  j                  }| j	                  |      }t        ||||ffi |}t        ||z
  || j                        }t        |t        ||dk\  |dk  z  ft        df            S )zG Compute the Quantile from the PDF.

        Returns a Lambda.
        zx, pTr   r   rT   )
r   r   rA   r   r|   r   r    r   r   r   )r1   rD   r   r   r   r|   r   quantiles           r2   compute_quantilez-SingleContinuousDistribution.compute_quantile  s     vDe41XX^^
hhqkaQ/:6:C!GQ1aHqAv!q&.A#Cc4[QRRr4   c                      y rG   r:   r   s     r2   	_quantilez&SingleContinuousDistribution._quantile%  r   r4   c                 x    t        |      dk(  r| j                  |      }||S   | j                  di ||      S r   )re   r   r   )r1   r   rD   r   s       r2   r   z%SingleContinuousDistribution.quantile(  sE    v;!~~a(H#.$t$$.v.q11r4   NT)r5   r6   r7   r8   r   r	   rA   r   staticmethodr   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r:   r4   r2   r   r      s    $ B3
C)    -  A  DM, S S2r4   r   c                       e Zd ZdZdZdZed        ZddZd Z	e
d        Ze
d        Ze
d	        Ze
d
        Zd Zd ZddZy)ContinuousPSpacez Continuous Probability Space

    Represents the likelihood of an event space defined over a continuum.

    Represented with a ContinuousDomain and a PDF (Lambda-Like)
    Tc                 H     | j                   | j                  j                   S rG   )densityrN   r   r0   s    r2   r|   zContinuousPSpace.pdf<  s    t||T[[0011r4   Nc                    || j                   }nt        |      }|j                  |D ci c]  }||j                   c}      }t        d |D              } | j                  j
                  | j                  |z  |fi |S c c}w )Nc              3   4   K   | ]  }|j                     y wrG   r@   ).0rvs     r2   	<genexpr>z7ContinuousPSpace.compute_expectation.<locals>.<genexpr>H  s     ";299";   )valuesr>   xreplacer@   rN   rE   r|   )r1   rB   rvsr   rD   r   domain_symbolss          r2   rE   z$ContinuousPSpace.compute_expectation@  s}    ;++CC.C}}c:b"))m:;"";s";;.t{{..txx$*"(* 	*	 ;s   Bc           	         || j                   v r{t        t        | j                         t        |g      z
        }t        d |D              } | j                  j
                  | j                  |fi |}t        |j                  |      S t        dd      }t        | | j
                  t        ||z
        fi |      S )Nc              3   4   K   | ]  }|j                     y wrG   r   )r   rss     r2   r   z3ContinuousPSpace.compute_density.<locals>.<genexpr>R  s     >"BII>r   r   Tr   )r   rw   rA   r>   rN   rE   r|   r   r@   r   r   )r1   rB   rD   randomsymbolsr   r|   r   s          r2   compute_densityz ContinuousPSpace.compute_densityM  s    4;;!#dkk"2Yv5F"FGM>>>G1$++11$((GNvNC$++s++#D!a111*TAX2FQ&QRRr4   c                 N   | j                   j                  j                  st        d       | j                  |fi |}t        ddt              \  }}| j                   j                  j                  }t         ||      |||ffi |}t        |||k\  fd      }t        ||      S )Nz0CDF not well defined on multivariate expressionsr   Tr   r   )rN   rA   is_Intervalr?   r   r   r   r   r   r   r   )r1   rB   rD   dr   r   r   r   s           r2   r   zContinuousPSpace.compute_cdfY  s    {{**BD D !D  00vDe41[[__**
 !q*a0;F;a:o.	:a~r4   c                 *   | j                   j                  j                  st        d       | j                  |fi |}t        ddt              \  }}t        t        t        |z  |z         ||      z  |t         t        ffi |}t        ||      S )NzCCharacteristic function of multivariate expressions not implementedr   Tr   )rN   rA   r   r/   r   r   r   r   r   r   r	   r   )r1   rB   rD   r   r   r   r   s          r2   r   z0ContinuousPSpace.compute_characteristic_functioni  s    {{**%&kll D  00vDe41s1Q3q5z!A$RC??a}r4   c                    | j                   j                  j                  st        d       | j                  |fi |}t        ddt              \  }}t        t        ||z         ||      z  |t         t        ffi |}t        ||      S )NzFMoment generating function of multivariate expressions not implementedr   Tr   )rN   rA   r   r/   r   r   r   r   r   r	   r   )r1   rB   rD   r   r   r   r   s          r2   r   z3ContinuousPSpace.compute_moment_generating_functions  s~    {{**%&noo D  00vDe41AE
QqT)AsB<B6Ba~r4   c                 
   | j                   j                  j                  st        d       | j                  |fi |}t        dd      }t        dd      }t         ||      |z
  || j                        }t        ||      S )Nz5Quantile not well defined on multivariate expressionsr   Tr   r   )positive)rN   rA   r   r?   r   r   r    r   )r1   rB   rD   r   r   r   r   s          r2   r   z!ContinuousPSpace.compute_quantile}  s}    {{**GI I DT,V,#D!#%AaD1Ha2a""r4   c                    t        dd      d}t        |t              r(t        |j                  d   |j                  d         }d}	 | j                  |      }| j                  D cg c]  }|j                  |j                  k(  s|  c}d   } | j                  |fi |j                  t        j                  u st        |j                  t              r"|st        j                  S t        j                  S t        |j                  t              r*t!        fd|j                  j                  D              S t#               |j                  ffi S c c}w # t$        $ r ddlm} |j*                  |j,                  z
  }t/        |      s| j(                  }|j,                  }	n ||fi }d}	t        |t0              s$dd	lm}
  |
|| j6                  j                  
      }t9        |      }|j;                  |j=                  |j>                  |	            }|s|cY S t        j                  |z
  cY S w xY w)Nr   Tr   Fr   rT   c              3   h   K   | ])  }t        |t              rt               |ffi  + y wrG   )r]   r   r   )r   subsetrD   r|   r   s     r2   r   z/ContinuousPSpace.probability.<locals>.<genexpr>  s9      FAG(268(D c!fq&k<V<Fs   /2)r   )ContinuousDistributionHandmade)rA   ) r   r]   r   r
   r_   wherer   r@   r   rA   r   EmptySetr   r   Oner   sumr   r/   sympy.stats.rvr   rb   rc   r%   rz   sympy.stats.crv_typesr   rN   SingleContinuousPSpaceprobability	__class__value)r1   rZ   rD   cond_invrN   r   r   rB   denscompr   spacer   r|   r   s     `          @@r2   r   zContinuousPSpace.probability  s   #D!i$9>>!,innQ.?@IH 	>ZZ	*F#{{Ibii6==.H"I!LB&$&&r4V4CzzQZZ':fjj)+L%-qvv81558&**e, FZZ__F F F CFQ

O>v>> J # 	>.==9==0DT?|| }}t.v.d$:;P5dP*1d3E&&y':':5;;'MNF!)6=quuv~=	>sE   E' +E"
E"A E' /E' ?AE' E' "E' 'CI/IIc                 <   t        t        |            }t        |      dk(  r|j                  | j                        st        d      t        |      d   }t        ||      }|j                  | j                  j                        }t        |j                  |      S )NrT   z2Multiple continuous random variables not supportedr   )r>   r)   re   issubsetr   r/   rw   rg   rh   rN   rA   r<   r@   )r1   rZ   r   r   intervals        r2   r   zContinuousPSpace.where  s    y12CA#,,t{{";%DF F3Z]4YC%%dkkoo6%bii::r4   c           	         |j                  | j                  D ci c]  }||j                   c}      }t        | j                  |      }|r| j
                  D ci c]  }|t        t        |             }} |j                  | j                  fi |}| j                  |j                  |      z  }t        t        |j
                        |      }	t        |	      S c c}w c c}w rG   )r   r   r@   rR   rN   r   r   strrE   r|   r   rw   r   )
r1   rZ   	normalizerD   r   rN   replacementnormr|   r   s
             r2   conditional_spacez"ContinuousPSpace.conditional_space  s    &&'L"BII'LM	,T[[)D :>F2Bc"g.FKF-6--dhhA&AD((T]];77C U6>>2C8G00 (M Gs   CC$NFr   )r5   r6   r7   r8   r9   is_realrx   r|   rE   r   r   r   r   r   r   r   r   r   r:   r4   r2   r   r   1  s     MG2 2*
S       # #'>R;1r4   r   c                   ^    e Zd ZdZed        Zed        ZddZddZd Z	d Z
d	 Zd
 Zd Zy)r   a  
    A continuous probability space over a single univariate variable.

    These consist of a Symbol and a SingleContinuousDistribution

    This class is normally accessed through the various random variable
    functions, Normal, Exponential, Uniform, etc....
    c                 .    | j                   j                  S rG   )distributionrA   r0   s    r2   rA   zSingleContinuousPSpace.set  s      $$$r4   c                 T    t        t        | j                        | j                        S rG   )r<   r   r@   rA   r0   s    r2   rN   zSingleContinuousPSpace.domain  s    %gdkk&:DHHEEr4   Nc                 V    | j                   | j                  j                  |||      iS )zp
        Internal sample method.

        Returns dictionary mapping RandomSymbol to realization value.
        )libraryseed)r   r   sample)r1   sizer   r   s       r2   r   zSingleContinuousPSpace.sample  s,     

D--44T7QU4VWWr4   c                    |xs | j                   f}| j                   |vr|S t        |      }|j                  |D ci c]  }||j                   c}      }| j                   j                  }	  | j                  j
                  ||fd|i|S c c}w # t        $ r) t        || j                  z  || j                  ffi |cY S w xY w)Nr   )
r   r   r   r@   r   r   r   r   r|   rA   )r1   rB   r   r   rD   r   r   s          r2   rE   z*SingleContinuousPSpace.compute_expectation  s    "djj]::S K~}}c:b"))m:;JJ	F04$$00qV8VvVV	 ;
  	FD488Oa]EfEE	Fs   B.B /CCc                     || j                   k(  r4t        dd      }t        | | j                  j                  |fi |      S t        j                  | |fi |S )Nr   Tr   )r   r   r   r   r   r   r   )r1   rB   rD   r   s       r2   r   z"SingleContinuousPSpace.compute_cdf  sX    4::c%A!2T..221??@@#//dEfEEr4   c                     || j                   k(  r4t        dd      }t        | | j                  j                  |fi |      S t        j                  | |fi |S Nr   Tr   )r   r   r   r   r   r   r   r1   rB   rD   r   s       r2   r   z6SingleContinuousPSpace.compute_characteristic_function   sY    4::c%A!FT..FFqSFSTT#CCD$YRXYYr4   c                     || j                   k(  r4t        dd      }t        | | j                  j                  |fi |      S t        j                  | |fi |S r  )r   r   r   r   r   r   r   r  s       r2   r   z9SingleContinuousPSpace.compute_moment_generating_function  sY    4::c%A!IT..II!VvVWW#FFtT\U[\\r4   c                    || j                   k(  r| j                  S t        dd      t        |z
  | j                   t        j
                        }t        |t              rFt        |j                        dk(  r.|j                  d   t        j
                  u r|j                  d   }|j                  st        d|d| j                         | j                  | j                         t        fd	|D              }t        |      S )
NyTr   rU   r   rT   zCan not solve z for c              3   d   K   | ]'  } |      t        |j                              z   ) y wrG   )absdiff)r   gfxr	  s     r2   r   z9SingleContinuousPSpace.compute_density.<locals>.<genexpr>  s&     4AAQVVAY'4s   -0)r   r   r   r    r   Realsr]   r   re   r_   is_FiniteSetr?   r   r   r   )r1   rB   rD   gsfyr  r	  s        @@r2   r   z&SingleContinuousPSpace.compute_density  s    4::<<#D!dQh

AGG4b,'277|q RWWQZ177%:WWQZ$

KLL!!$**-444a}r4   c                     || j                   k(  r4t        dd      }t        | | j                  j                  |fi |      S t        j                  | |fi |S )Nr   Tr   )r   r   r   r   r   r   r   )r1   rB   rD   r   s       r2   r   z'SingleContinuousPSpace.compute_quantile  sX    4::c%A!7T..77DVDEE#44T4J6JJr4   )r:   scipyNr   )r5   r6   r7   r8   rx   rA   rN   r   rE   r   r   r   r   r   r:   r4   r2   r   r     sZ     % % F FXFFZ]"Kr4   r   c                 Z    	 t        | |fi |S # t        $ r t        d| d   z        w xY w)Nz!Reduction of condition failed %s
r   )r!   r   r?   )rn   r   rD   s      r2   _reduce_inequalitiesr  '  s@    O+JFvFF O=
1MNNOs    *c           
      z   | j                   rt        | gg|d      S t        | t              r.t	        | j
                  D cg c]  }t        |gg|d       c} S t        | t              rG| j
                  D cg c]  }t        |gg|d       }}|d   }|D ]  } |j                  |      } |S y c c}w c c}w )NF)
relationalr   )r`   r  r]   r   r   r_   r   rh   )rZ   r   arg	intervalsr   rp   s         r2   rg   rg   .  s    #i[M35II)R  ~~' ,cUGSUK ' ( 	()S! ~~' *C5'35I '	 'aL 	AAA	 "''s    B39B8N)Ir8   sympy.core.basicr   sympy.core.cacher   sympy.core.functionr   r   sympy.core.numbersr   r   r	   sympy.core.relationalr
   r   sympy.core.singletonr   sympy.core.symbolr   r   sympy.core.sympifyr   r   (sympy.functions.combinatorial.factorialsr   &sympy.functions.elementary.exponentialr   $sympy.functions.elementary.piecewiser   'sympy.functions.special.delta_functionsr   sympy.integrals.integralsr   r   sympy.logic.boolalgr   r   sympy.polys.polyerrorsr   sympy.polys.polytoolsr   sympy.series.seriesr   sympy.sets.setsr   r   r   r   sympy.solvers.solvesetr    sympy.solvers.inequalitiesr!   r   r"   r#   r$   r%   r&   r'   r(   r)   r*   r+   r-   r<   rK   rR   rz   r   r   r   r  rg   r:   r4   r2   <module>r/     s    # $ 1 + + * " . 0 > 6 : > ; ) 2 & & F F + C[ [ [	I| 	I3-| 3(Fm-= F$?="24E ?=D\ 
Q2#9> Q2h]1v ]1@TK-| TKlOr4   