Uname: Linux web3.us.cloudlogin.co 5.10.226-xeon-hst #2 SMP Fri Sep 13 12:28:44 UTC 2024 x86_64
Software: Apache
PHP version: 8.1.31 [ PHP INFO ] PHP os: Linux
Server Ip: 162.210.96.117
Your Ip: 3.147.65.146
User: edustar (269686) | Group: tty (888)
Safe Mode: OFF
Disable Function:
NONE

name : _pydecimal.cpython-310.opt-2.pyc
o

^bD}�
@sn	gd�ZeZdZdZdZddlZddlZddl	Z	z
ddl
mZedd�Z
Wn
ey3d	d
�Z
YnwdZdZd
ZdZdZdZdZdZdZdZe	jdkrTdZdZdZndZdZdZeedZGdd�de�ZGdd�de�Z Gdd�de�Z!Gd d!�d!e!�Z"Gd"d#�d#ee#�Z$Gd$d%�d%e!�Z%Gd&d'�d'e!e#�Z&Gd(d)�d)e�Z'Gd*d+�d+e!�Z(Gd,d-�d-e�Z)Gd.d/�d/e�Z*Gd0d1�d1e'e)�Z+Gd2d3�d3e'e)e*�Z,Gd4d5�d5ee-�Z.e e$e'e+e)e,e!e*e.g	Z/e"e!e%e!e&e!e(e!iZ0eeeeeeeefZ1ddl2Z2e2�3d6�Z4d7d8�Z5d9d:�Z6[2d�d;d<�Z7Gd=d>�d>e8�Z9d�d@dA�Z:ej;�<e9�GdBdC�dCe8�Z=GdDdE�dEe8�Z>GdFdG�dGe8�Z?d�dHdI�Z@eAjBZCdJdK�ZDdLdM�ZEdNdO�ZFdPdQ�ZGd�dSdT�ZHdUdV�ZIdWdX�ZJGdYdZ�dZe8�ZKeK�jLZMd�d[d\�ZNd]d^�ZOd_d`�ZPdadbdcdddedfdgdhdidj�	fdkdl�ZQd�dmdn�ZRd�dodp�ZSe>dqee$e+e!ggdrdsdddt�ZTe>duee$e+e!e e,ggdv�ZUe>dueggdv�ZVddlWZWeW�XdweWjYeWjZB�j[Z\eW�Xdx�j[Z]eW�Xdy�j[Z^eW�XdzeWjYeWj_B�Z`[WzddlaZbWn
e�y�Ynwd�d{d|�Zcd}d~�Zddd��Zed�d�d��Zfd�d��Zgd�d��Zhe9d��Zie9d��Zje9d��Zke9d�Zle9d�Zme9d��ZneiejfZoe	jpjqZre	jpjsZte	jpjuZvewdherd�er�Zx[	dS)�)%�Decimal�Context�DecimalTuple�DefaultContext�BasicContext�ExtendedContext�DecimalException�Clamped�InvalidOperation�DivisionByZero�Inexact�Rounded�	Subnormal�Overflow�	Underflow�FloatOperation�DivisionImpossible�InvalidContext�ConversionSyntax�DivisionUndefined�
ROUND_DOWN�
ROUND_HALF_UP�ROUND_HALF_EVEN�
ROUND_CEILING�ROUND_FLOOR�ROUND_UP�ROUND_HALF_DOWN�
ROUND_05UP�
setcontext�
getcontext�localcontext�MAX_PREC�MAX_EMAX�MIN_EMIN�	MIN_ETINY�HAVE_THREADS�HAVE_CONTEXTVARZdecimalz1.70z2.4.2�N)�
namedtuplerzsign digits exponentcG�|S�N�)�argsr*r*�3/usr/local/python-3.10/lib/python3.10/_pydecimal.py�<lambda>�sr-rrrrrrrrTl����l��N�Zol������N�Zoi@�Ti����c@�eZdZ	dd�ZdS)rcGsdSr)r*��self�contextr+r*r*r,�handle��zDecimalException.handleN��__name__�
__module__�__qualname__r3r*r*r*r,r�src@�eZdZdS)rN�r6r7r8r*r*r*r,r��rc@r/)r	cGs,|rt|dj|djdd�}|�|�StS)Nr&�nT)�_dec_from_triple�_sign�_int�_fix_nan�_NaN)r1r2r+�ansr*r*r,r3�s
zInvalidOperation.handleNr5r*r*r*r,r	�sr	c@r/)rcG�tSr)�rAr0r*r*r,r3r4zConversionSyntax.handleNr5r*r*r*r,rsrc@r/)r
cGst|Sr))�_SignedInfinity�r1r2�signr+r*r*r,r3szDivisionByZero.handleNr5r*r*r*r,r

sr
c@r/)rcGrCr)rDr0r*r*r,r3"r4zDivisionImpossible.handleNr5r*r*r*r,r�rc@r/)rcGrCr)rDr0r*r*r,r3-r4zDivisionUndefined.handleNr5r*r*r*r,r%rHrc@r9)rNr:r*r*r*r,r0r;rc@r/)rcGrCr)rDr0r*r*r,r3Gr4zInvalidContext.handleNr5r*r*r*r,r<s
rc@r9)rNr:r*r*r*r,rJr;rc@r9)r
Nr:r*r*r*r,r
Vr;r
c@r/)rcGs�|jttttfvr
t|S|dkr)|jtkrt|St|d|j|j	|jd�S|dkrE|jt
kr6t|St|d|j|j	|jd�SdS)Nr&�9r.)�roundingrrrrrErr=�prec�EmaxrrFr*r*r,r3ws"�
�
��zOverflow.handleNr5r*r*r*r,rasrc@r9)rNr:r*r*r*r,r�r;rc@r9)rNr:r*r*r*r,r�r;rZdecimal_contextcCs4	zt��WStyt�}t�|�|YSwr))�_current_context_var�get�LookupErrorr�set�r2r*r*r,r�s

�rcCs.	|tttfvr|��}|��t�|�dSr))rrr�copy�clear_flagsrMrPrQr*r*r,r�s
rcCs	|durt�}t|�Sr))r�_ContextManager)�ctxr*r*r,r�s#rc
@sleZdZ	dZd�dd�Zedd��Zdd	�Zd
d�Zd�dd
�Z	dd�Z
dd�Zdd�Zd�dd�Z
d�dd�Zd�dd�Zd�dd�Zd�dd�Zd�dd�Zd d!�Zd"d#�Zd$d%�Zd&d'�Zd�d)d*�Zd�d+d,�Zd�d-d.�Zd�d/d0�Zd�d2d3�Zd�d4d5�ZeZd�d6d7�Zd�d8d9�Zd�d:d;�Z e Z!d�d<d=�Z"d>d?�Z#d�d@dA�Z$d�dBdC�Z%d�dDdE�Z&d�dFdG�Z'd�dHdI�Z(d�dJdK�Z)d�dLdM�Z*d�dNdO�Z+dPdQ�Z,dRdS�Z-e-Z.e/dTdU��Z0e/dVdW��Z1dXdY�Z2dZd[�Z3d\d]�Z4d^d_�Z5d`da�Z6dbdc�Z7ddde�Z8dfdg�Z9dhdi�Z:djdk�Z;dldm�Z<dndo�Z=e>e6e7e8e9e:e;e<e=dp�Z?d�dqdr�Z@dsdt�ZAdudv�ZBd�dwdx�ZCd�dydz�ZDd{d|�ZEd�d}d~�ZFd�dd��ZGd�d�d��ZHd�d�d��ZId�d�d��ZJd�d��ZKd�d��ZLd�d�d��ZMd�d�d��ZNeNZOd�d�d��ZPd�d�d��ZQd�d�d��ZRd�d��ZSd�d��ZTd�d��ZUd�d��ZVd�d�d��ZWd�d�d��ZXd�d�d��ZYd�d��ZZd�d��Z[d�d�d��Z\d�d�d��Z]d�d��Z^d�d��Z_d�d��Z`d�d��Zad�d�d��Zbd�d��Zcd�d��Zdd�d��Zed�d�d��Zfd�d��Zgd�d��Zhd�d�d„Zid�dĄZjd�d�dƄZkd�d�dȄZld�dʄZmd�d̄Znd�d�d΄Zod�d�dЄZpd�d�d҄Zqd�d�dԄZrd�d�dքZsd�d�d؄Ztd�d�dڄZud�d�d܄Zvd�d�dބZwd�d�d�Zxd�d�Zyd�d�d�Zzd�d�d�Z{d�d�d�Z|d�d�Z}d�d�Z~d�d�Zd�d�d�Z�dS)�r)�_expr?r>�_is_special�0NcCs~	t�|�}t|t�r�t|���dd��}|dur(|dur t�}|�t	d|�S|�
d�dkr3d|_nd|_|�
d�}|durd|�
d	�pEd}t|�
d
�pMd�}tt||��|_
|t|�|_d|_|S|�
d
�}|dur�tt|prd���d�|_
|�
d�r�d|_q�d|_nd|_
d|_d|_|St|t�r�|dkr�d|_nd|_d|_tt|��|_
d|_|St|t�r�|j|_|j|_|j
|_
|j|_|St|t�r�|j|_t|j�|_
t|j�|_d|_|St|ttf��r�t|�dkr�td��t|dt��r|ddv�std��|d|_|ddk�rd|_
|d|_d|_|Sg}	|dD]+}
t|
t��rMd|
k�r9dk�rMntd��|	�sF|
dk�rK|	�|
��q%td��|ddv�rkd�tt|	��|_
|d|_d|_|St|dt��r�d�tt|	�p|dg��|_
|d|_d|_|Std��t|t��r�|du�r�t�}|�td�t�|�}|j|_|j|_|j
|_
|j|_|St d|��)N�_�zInvalid literal for Decimal: %rrG�-r.r&�intZfrac�exprXF�diag�signal�Nr<�FT�ztInvalid tuple size in creation of Decimal from list or tuple.  The list or tuple should have exactly three elements.�r&r.z|Invalid sign.  The first value in the tuple should be an integer; either 0 for a positive number or 1 for a negative number.��	zTThe second value in the tuple must be composed of integers in the range 0 through 9.�r<r`zUThe third value in the tuple must be an integer, or one of the strings 'F', 'n', 'N'.�;strict semantics for mixing floats and Decimals are enabledzCannot convert %r to Decimal)!�object�__new__�
isinstance�str�_parser�strip�replacer�_raise_errorr�groupr>r\r?�lenrVrW�lstrip�absr�_WorkReprGr]�list�tuple�
ValueError�append�join�map�floatr�
from_float�	TypeError)�cls�valuer2r1�m�intpart�fracpartr]r^�digitsZdigitr*r*r,ri
s�

�

�





�&�
�

�
�
�
zDecimal.__new__cCs�	t|t�r|dkrdnd}d}tt|��}n=t|t�rPt�|�s&t�|�r,|t|��St�	d|�dkr7d}nd}t|��
�\}}|��d}t|d|�}ntd��t
|||�}|tura|S||�S)Nr&r.g�?�zargument must be int or float.)rjr\rkrsr{�_math�isinf�isnan�repr�copysign�as_integer_ratio�
bit_lengthr}r=r)r~�frG�k�coeffr<�d�resultr*r*r,r|�s&

zDecimal.from_floatcCs*	|jr|j}|dkr
dS|dkrdSdS)Nr<r.r`rdr&)rWrV)r1r]r*r*r,�_isnan�szDecimal._isnancCs	|jdkr
|jrdSdSdS)Nra���r.r&)rVr>�r1r*r*r,�_isinfinity�s
zDecimal._isinfinitycCs~	|��}|durd}n|��}|s|r=|durt�}|dkr&|�td|�S|dkr1|�td|�S|r8|�|�S|�|�SdS)NFrd�sNaNr&)r�rror	r@)r1�otherr2�self_is_nan�other_is_nanr*r*r,�_check_nans�s(	��

zDecimal._check_nanscCsx	|durt�}|js|jr:|��r|�td|�S|��r$|�td|�S|��r/|�td|�S|��r:|�td|�SdS)Nzcomparison involving sNaNzcomparison involving NaNr&)rrW�is_snanror	�is_qnan�r1r�r2r*r*r,�_compare_check_nans	s2
����zDecimal._compare_check_nanscCs	|jp|jdkS�NrX�rWr?r�r*r*r,�__bool__*szDecimal.__bool__cCs	|js|jr|��}|��}||krdS||krdSdS|s)|s#dSd|jS|s0d|jS|j|jkr8dS|j|jkr@dS|��}|��}||krw|jd|j|j}|jd|j|j}||krhdS||krrd|jSd|jS||kr�d|jSd|jS)Nr&r�r.rX)rWr�r>�adjustedr?rV)r1r�Zself_infZ	other_inf�
self_adjustedZother_adjusted�self_paddedZother_paddedr*r*r,�_cmp1s@


zDecimal._cmpcCs<t||dd�\}}|tur|S|�||�rdS|�|�dkS)NT)�equality_opFr&)�_convert_for_comparison�NotImplementedr�r�r�r*r*r,�__eq__qszDecimal.__eq__cCs<t||�\}}|tur
|S|�||�}|rdS|�|�dkS�NFr&�r�r�r�r��r1r�r2rBr*r*r,�__lt__y�zDecimal.__lt__cCs<t||�\}}|tur
|S|�||�}|rdS|�|�dkSr�r�r�r*r*r,�__le__�r�zDecimal.__le__cCs<t||�\}}|tur
|S|�||�}|rdS|�|�dkSr�r�r�r*r*r,�__gt__�r�zDecimal.__gt__cCs<t||�\}}|tur
|S|�||�}|rdS|�|�dkSr�r�r�r*r*r,�__ge__�r�zDecimal.__ge__cCs@	t|dd�}|js|r|jr|�||�}|r|St|�|��S�NT��raiseit)�_convert_otherrWr�rr�r�r*r*r,�compare�szDecimal.comparecCs�	|jr|��rtd��|��rt�|�S|jrtStS|jdkr*t	d|jt
�}nt	t|jt
�}t|j
�|t
}|dkrA|n|}|dkrJdS|S)Nz"Cannot hash a signaling NaN value.r&�
r����)rWr�r}�is_nanrh�__hash__r>�_PyHASH_INFrV�pow�_PyHASH_MODULUS�
_PyHASH_10INVr\r?)r1Zexp_hashZhash_rBr*r*r,r��s

zDecimal.__hash__cCs	t|jttt|j��|j�Sr))rr>rvrzr\r?rVr�r*r*r,�as_tuple�szDecimal.as_tuplecCs�	|jr|��rtd��td��|sdSt|j�}|jdkr)|d|jd}}n@|j}|dkrI|ddkrI|d}|d8}|dkrI|ddks7|j}t||@��d|�}|rc||L}||8}d||>}|j	ro|}||fS)Nz#cannot convert NaN to integer ratioz(cannot convert Infinity to integer ratiorcr&r�r.r�)
rWr�rw�
OverflowErrorr\r?rV�minr�r>)r1r<r�Zd5Zd2Zshift2r*r*r,r��s0


�zDecimal.as_integer_ratiocCs	dt|�S)Nz
Decimal('%s'))rkr�r*r*r,�__repr__szDecimal.__repr__Fc	Cs`	ddg|j}|jr'|jdkr|dS|jdkr |d|jS|d|jS|jt|j�}|jdkr;|d	kr;|}n|s@d
}n|jdkrN|d
dd
}n|d
dd
}|dkrgd}d
d||j}n&|t|j�kr}|jd|t|j�}d}n|jd|�}d
|j|d�}||kr�d}n|dur�t�}ddg|jd||}||||S)NrZr[raZInfinityr<�NaNr�r&���r.rXrb�.�e�Ez%+d)r>rWrVr?rqr�capitals)	r1�engr2rG�
leftdigits�dotplacer�r�r]r*r*r,�__str__s<


zDecimal.__str__cCs	|jd|d�S)NT)r�r2)r��r1r2r*r*r,�
to_eng_string;szDecimal.to_eng_stringcCsT	|jr|j|d�}|r|S|durt�}|s!|jtkr!|��}n|��}|�|�S�NrQ)rWr�rrJr�copy_abs�copy_negate�_fix�r1r2rBr*r*r,�__neg__Ds

zDecimal.__neg__cCsT	|jr|j|d�}|r|S|durt�}|s!|jtkr!|��}nt|�}|�|�Sr�)rWr�rrJrr�rr�r�r*r*r,�__pos__Zs

zDecimal.__pos__TcCsN	|s|��S|jr|j|d�}|r|S|jr|j|d�}|S|j|d�}|Sr�)r�rWr�r>r�r�)r1�roundr2rBr*r*r,�__abs__os�zDecimal.__abs__c
Cs`	t|�}|tur|S|durt�}|js|jrB|�||�}|r"|S|��r:|j|jkr6|��r6|�td�St	|�S|��rBt	|�St
|j|j�}d}|jt
krX|j|jkrXd}|st|stt
|j|j�}|rgd}t|d|�}|�|�}|S|s�t||j|jd�}|�||j�}|�|�}|S|s�t||j|jd�}|�||j�}|�|�}|St|�}t|�}t|||j�\}}t�}	|j|jkr�|j|jkr�t|d|�}|�|�}|S|j|jkr�||}}|jdkr�d|	_|j|j|_|_�qd|	_n|jdk�r	d|	_d\|_|_nd|	_|jdk�r|j|j|	_n|j|j|	_|j|	_t	|	�}|�|�}|S)Nz
-INF + INFr&r.rX)r&r&)r�r�rrWr�r�r>ror	rr�rVrJrr=r��maxrK�_rescalert�
_normalizerGr\r])
r1r�r2rBr]ZnegativezerorG�op1�op2r�r*r*r,�__add__�s~






zDecimal.__add__cCsJ	t|�}|tur|S|js|jr|j||d�}|r|S|j|��|d�Sr�)r�r�rWr�r�r�r�r*r*r,�__sub__�szDecimal.__sub__cC�$	t|�}|tur|S|j||d�Sr�)r�r�r�r�r*r*r,�__rsub__�s
zDecimal.__rsub__cCs@	t|�}|tur|S|durt�}|j|jA}|js|jrH|�||�}|r(|S|��r8|s4|�td�St	|S|��rH|sD|�td�St	|S|j
|j
}|rR|s_t|d|�}|�|�}|S|j
dkrrt||j
|�}|�|�}|S|j
dkr�t||j
|�}|�|�}|St|�}t|�}t|t|j|j�|�}|�|�}|S)Nz(+-)INF * 0z0 * (+-)INFrX�1)r�r�rr>rWr�r�ror	rErVr=r�r?rtrkr\)r1r�r2Z
resultsignrBZ	resultexpr�r�r*r*r,�__mul__�sJ





zDecimal.__mul__cCs�	t|�}|turtS|durt�}|j|jA}|js|jrP|�||�}|r(|S|��r6|��r6|�td�S|��r>t	|S|��rP|�t
d�t|d|���S|sa|sZ|�t
d�S|�td|�S|sl|j|j}d}nnt|j�t|j�|jd}|j|j|}t|�}t|�}	|dkr�t|jd||	j�\}}
nt|j|	jd|�\}}
|
r�|d	dkr�|d7}n"|j|j}||kr�|ddkr�|d}|d7}||kr�|ddks�t|t|�|�}|�|�S)
Nz(+-)INF/(+-)INFzDivision by infinityrXz0 / 0zx / 0r&r.r�r�)r�r�rr>rWr�r�ror	rErr=�Etinyrr
rVrqr?rKrt�divmodr\rkr�)r1r�r2rGrBr]r��shiftr�r��	remainder�	ideal_expr*r*r,�__truediv__,sV��
zDecimal.__truediv__cCs	|j|jA}|��r|j}nt|j|j�}|��|��}|r(|��s(|dkr5t|dd�|�||j�fS||jkr�t	|�}t	|�}|j
|j
krV|jd|j
|j
9_n
|jd|j
|j
9_t|j|j�\}}	|d|jkr�t|t
|�d�t|jt
|	�|�fS|�td�}
|
|
fS)Nr�rXr&r�z%quotient too large in //, % or divmod)r>r�rVr�r�r=r�rJrKrtr]r\r�rkror)r1r�r2rGr��expdiffr�r��q�rrBr*r*r,�_dividegs2
�
��zDecimal._dividecCr�r�)r�r�r�r�r*r*r,�__rtruediv__��
zDecimal.__rtruediv__cCs�	t|�}|tur|S|durt�}|�||�}|r||fS|j|jA}|��r@|��r6|�td�}||fSt||�td�fS|s[|sN|�t	d�}||fS|�t
d|�|�td�fS|�||�\}}|�|�}||fS)Nzdivmod(INF, INF)�INF % xzdivmod(0, 0)�x // 0�x % 0)
r�r�rr�r>r�ror	rErr
r�r�)r1r�r2rBrGZquotientr�r*r*r,�
__divmod__�s6
�
�
zDecimal.__divmod__cCr�r�)r�r�r�r�r*r*r,�__rdivmod__�r�zDecimal.__rdivmod__cCs�	t|�}|tur|S|durt�}|�||�}|r|S|��r&|�td�S|s6|r0|�td�S|�td�S|�||�d}|�	|�}|S)Nr�r�z0 % 0r.)
r�r�rr�r�ror	rr�r�)r1r�r2rBr�r*r*r,�__mod__�s$
zDecimal.__mod__cCr�r�)r�r�r�r�r*r*r,�__rmod__�r�zDecimal.__rmod__cCs�	|durt�}t|dd�}|�||�}|r|S|��r"|�td�S|s2|r,|�td�S|�td�S|��r?t|�}|�|�St	|j
|j
�}|sTt|jd|�}|�|�S|�
�|�
�}||jdkrh|�t�S|dkrx|�||j�}|�|�St|�}t|�}|j|jkr�|jd	|j|j9_n
|jd	|j|j9_t|j|j�\}}	d
|	|d@|jkr�|	|j8}	|d7}|d	|jkr�|�t�S|j}
|	dkr�d|
}
|	}	t|
t|	�|�}|�|�S)NTr�zremainder_near(infinity, x)zremainder_near(x, 0)zremainder_near(0, 0)rXr.r�r�rdr&)rr�r�r�ror	rrr�r�rVr=r>r�rKrr�rJrtr]r\r�rk)r1r�r2rB�ideal_exponentr�r�r�r�r�rGr*r*r,�remainder_near�sb���






zDecimal.remainder_nearcCs�	t|�}|tur|S|durt�}|�||�}|r|S|��r2|��r*|�td�St|j|jAS|sG|rA|�t	d|j|jA�S|�t
d�S|�||�dS)Nz
INF // INFr�z0 // 0r&)r�r�rr�r�ror	rEr>r
rr�r�r*r*r,�__floordiv__'s(
�zDecimal.__floordiv__cCr�r�)r�r�r�r�r*r*r,�
__rfloordiv__Cr�zDecimal.__rfloordiv__cCs@	|��r|��r
td��|jrdnd}t|�St|�}t|�S)Nz%Cannot convert signaling NaN to floatz-nan�nan)r�r�rwr>rkr{�r1�sr*r*r,�	__float__Js�zDecimal.__float__cCsp	|jr|��rtd��|��rtd��d|j}|jdkr*|t|j�d|jS|t|jd|j�p5d�S)NzCannot convert NaN to integerz"Cannot convert infinity to integerr�r&r�rX)	rWr�rwr�r�r>rVr\r?r�r*r*r,�__int__Ts

zDecimal.__int__cCr(r)r*r�r*r*r,�realcszDecimal.realcCstd�S�Nr&�rr�r*r*r,�imaggszDecimal.imagcCr(r)r*r�r*r*r,�	conjugatekr4zDecimal.conjugatecCstt|��Sr))�complexr{r�r*r*r,�__complex__n�zDecimal.__complex__cCsT	|j}|j|j}t|�|kr&|t|�|d��d�}t|j||jd�St|�S)NrXT)	r?rK�clamprqrrr=r>rVr)r1r2�payloadZmax_payload_lenr*r*r,r@qszDecimal._fix_nancCsB	|jr|��r
|�|�St|�S|��}|��}|sA|j|g|j}tt	|j
|�|�}||j
kr=|�t�t
|jd|�St|�St|j�|j
|j}||krd|�td|j�}|�t�|�t�|S||k}|rl|}|j
|kr�t|j�|j
|}	|	dkr�t
|jd|d�}d}	|j|j}
|
||	�}|jd|	�p�d}|dkr�tt|�d�}t|�|jkr�|dd�}|d7}||kr�|�td|j�}nt
|j||�}|r�|r�|�t�|r�|�t�|r�|�t�|�t�|s�|�t�|S|r�|�t�|jdk�r|j
|k�r|�t�|jd|j
|}
t
|j|
|�St|�S)NrX�
above Emaxr&r�r.r�)rWr�r@rr��EtoprLrr�r�rVrorr=r>rqr?rKrrr�_pick_rounding_functionrJrkr\rr
)r1r2r�r	�exp_maxZnew_expZexp_minrBZself_is_subnormalr�Zrounding_method�changedr�r�r*r*r,r�}sp	













zDecimal._fixcCs	t|j|�r	dSdS)Nr&r�)�
_all_zerosr?�r1rKr*r*r,�_round_down�szDecimal._round_downcCs	|�|�Sr))rrr*r*r,�	_round_up�szDecimal._round_upcCs(	|j|dvr
dSt|j|�rdSdS)NZ56789r.r&r�)r?r
rr*r*r,�_round_half_up�szDecimal._round_half_upcCs	t|j|�r	dS|�|�S)Nr���_exact_halfr?rrr*r*r,�_round_half_down�s
zDecimal._round_half_downcCs6	t|j|�r|dks|j|ddvrdS|�|�S)Nr&r.�02468r�rrr*r*r,�_round_half_even�s��
zDecimal._round_half_evencCs	|jr	|�|�S|�|�Sr)�r>rrr*r*r,�_round_ceiling�
zDecimal._round_ceilingcCs	|js	|�|�S|�|�Sr)rrr*r*r,�_round_floor
rzDecimal._round_floorcCs.	|r|j|ddvr|�|�S|�|�S)Nr.Z05)r?rrr*r*r,�_round_05ups
zDecimal._round_05up)rrrrrrrrcCsb	|durt|t�std��tdd|�}|�|�S|jr)|��r%td��td��t|�	dt
��S)Nz+Second argument to round should be integralr&r��cannot round a NaN�cannot round an infinity)rjr\r}r=�quantizerWr�rwr�r�r)r1r<r]r*r*r,�	__round__&s.

zDecimal.__round__cC�0	|jr|��rtd��td��t|�dt��S�Nrrr&)rWr�rwr�r\r�rr�r*r*r,�	__floor__d�zDecimal.__floor__cCr r!)rWr�rwr�r\r�rr�r*r*r,�__ceil__sr#zDecimal.__ceil__cCs	t|dd�}t|dd�}|js|jrn|durt�}|jdkr&|�td|�S|jdkr2|�td|�S|jdkr:|}q�|jdkrB|}q�|jdkrX|sO|�td�St|j|jA}q�|jdkrm|se|�td�St|j|jA}nt|j|jAt	t
|j�t
|j��|j|j�}|�||�S)	NTr�r`r�r<razINF * 0 in fmaz0 * INF in fma)
r�rWrrVror	rEr>r=rkr\r?r�)r1r��thirdr2�productr*r*r,�fma�s@





�
��
�zDecimal.fmacCs�	t|�}|tur|St|�}|tur|S|durt�}|��}|��}|��}|s.|s.|rb|dkr9|�td|�S|dkrD|�td|�S|dkrO|�td|�S|rV|�|�S|r]|�|�S|�|�S|��rn|��rn|��st|�td�S|dkr~|�td�S|s�|�td�S|��|j	kr�|�td�S|s�|s�|�td�S|�
�r�d}n|j}tt
|��}t|���}t|���}	|j
|td	|j|�|}t|	j�D]}
t|d	|�}q�t||	j
|�}t|t|�d�S)
Nrdr�z@pow() 3rd argument not allowed unless all arguments are integersr&zApow() 2nd argument cannot be negative when 3rd argument specifiedzpow() 3rd argument cannot be 0zSinsufficient precision: pow() 3rd argument must not have more than precision digitszXat least one of pow() 1st argument and 2nd argument must be nonzero; 0**0 is not definedr�)r�r�rr�ror	r@�
_isintegerr�rK�_isevenr>rsr\rt�to_integral_valuer�r]�ranger=rk)r1r��modulor2r�r�Z
modulo_is_nanrG�base�exponent�ir*r*r,�
_power_modulo�s����


�������zDecimal._power_modulocCsV	t|�}|j|j}}|ddkr |d}|d7}|ddkst|�}|j|j}}|ddkr?|d}|d7}|ddks1|dkr�||9}|ddkr[|d}|d7}|ddksM|dkradS|d|}	|jdkro|	}	|��r�|jdkr�|jt|�}
t|	|
|d�}nd}tddd||	|�S|jdk�rg|d}|dvr�||@|kr�dSt	|�d}
|dd}|t
t|��kr�dSt|
||�}
t|||�}|
dus�|dur�dS|
|kr�dSd	|
}nj|d	k�rOt	|�d
d}
t
d	|
|�\}}|�rdS|d	dk�r|d	}|
d8}
|d	dk�s	|dd}|t
t|��k�r)dSt|
||�}
t|||�}|
du�sA|du�rCdS|
|k�rJdSd|
}ndS|d|k�rZdS|
|}tdt|�|�S|dk�rv|d|d}}n�|dk�r�t
tt||���|k�r�dSt	|�}|dk�r�t
tt|�|��|k�r�dS|d|}}|d|dk�r�dk�r�nn|d}|d}|d|dk�r�dk�s�n|d	|d	k�r�dk�rnn|d	}|d	}|d	|d	k�rdk�s�n|dk�rX|dk�r||k�rdSt
||�\}}|dk�r!dSdt	|�|>}	t
|||d�\}}||k�r>�qJ||d||}�q,||k�rT|dk�sVdS|}|dk�rj||dt|�k�rjdS||}||9}|d|k�r{dSt|�}|���r�|jdk�r�|jt|�}
t||
|t
|��}nd}td|d|||�S)Nr�r&r.r�rX)rd����]�Ar��rbrdT�d)rtr\r]rGr(r>rVr�r=�_nbitsrqrk�_decimal_lshift_exactr�rs�	_log10_lb)r1r��p�x�xc�xe�y�yc�yer.r�ZzerosZ
last_digitr�Zemaxr�r�r<Zxc_bits�rem�ar�r�Zstr_xcr*r*r,�_power_exacts�9���


�



&&$"�$"�


� zDecimal._power_exactcCs,	|dur|�|||�St|�}|tur|S|durt�}|�||�}|r'|S|s3|s1|�td�StSd}|jdkrQ|�	�rE|�
�sDd}n|rM|�td�S|��}|sb|jdkr^t|dd�St
|S|��ru|jdkrot
|St|dd�S|tkr�|�	�r�|jdkr�d}n
||jkr�|j}nt|�}|j|}|d|jkr�d|j}|�t�n|�t�|�t�d|j}t|dd||�S|��}|��r�|jdk|dkkr�t|dd�St
|Sd}d}	|��|��}
|dk|jdkk�r|
tt|j��k�rt|d|jd�}n|��}|
tt|��k�rt|d|d�}|du�r@|�||jd�}|du�r@|dk�r>td|j|j�}d}	|du�r�|j}t|�}
|
j|
j}}t|�}|j|j}}|jdk�rg|}d	}	t||||||�\}}|d
dtt|��|d�r��q�|d	7}�qjt|t|�|�}|	�r|�	��st|j�|jk�r�|jdt|j�}t|j|jd||j|�}|� �}|�!�t"D]}d|j#|<�q�|�$|�}|�t�|j%t&�r�|�t'�|j%t(�r�|�t(d|j�t't&ttt)fD]}|j%|�r|�|��q�|S|�$|�}|S)
Nz0 ** 0r&r.z+x ** y with x negative and y not an integerrXr�FTrbr�r�r)*r0r�r�rr�ror	�_Oner>r(r)r�r=rEr�rKr\rVrrr��_log10_exp_boundrqrkrLr�rDr?rtr]rG�_dpowerrRrS�_signals�trapsr��flagsr
rrr)r1r�r,r2rBZresult_signZ
multiplierr]Zself_adj�exactZboundr�r;r<r=r>r?r@rA�extrar�r�Z
newcontext�	exceptionr*r*r,�__pow__�s�
��






�


�



"��



�
�zDecimal.__pow__cCr�r�)r�r�rNr�r*r*r,�__rpow__�	r�zDecimal.__rpow__cCs�	|durt�}|jr|j|d�}|r|S|�|�}|��r |S|s)t|jdd�S|j|��g|j	}t
|j�}|j}|j|ddkr]||kr]|d7}|d8}|j|ddkr]||ksHt|j|jd|�|�S)NrQrXr&r.)
rrWr�r�r�r=r>rLr	rrqr?rV)r1r2rB�dupr�endr]r*r*r,�	normalize�	s(

�zDecimal.normalizecCs�	t|dd�}|durt�}|dur|j}|js|jr?|�||�}|r%|S|��s-|��r?|��r9|��r9t|�S|�td�S|�	�|j
krM|jksTn|�td�S|sct|j
d|j
�}|�|�S|��}||jkrr|�td�S||j
d|jkr�|�td�S|�|j
|�}|��|jkr�|�td�St|j�|jkr�|�td�S|r�|��|jkr�|�t�|j
|j
kr�||kr�|�t�|�t�|�|�}|S)	NTr�zquantize with one INFz)target exponent out of bounds in quantizerXz9exponent of quantize result too large for current contextr.z7quantize result has too many digits for current context)r�rrJrWr�r�rror	r�rVrLr=r>r�r�rKr�rqr?�Eminr
rr)r1r]rJr2rBr�r*r*r,r�	sb��

����



zDecimal.quantizecCsF	t|dd�}|js
|jr|��r|��p|��o|��S|j|jkSr�)r�rWr��is_infiniterVr�r*r*r,�same_quantum%
s�zDecimal.same_quantumcCs�	|jrt|�S|st|jd|�S|j|kr%t|j|jd|j||�St|j�|j|}|dkr>t|jd|d�}d}|j|}|||�}|jd|�pPd}|dkr]tt	|�d�}t|j||�S)NrXr&r�r.)
rWrr=r>rVr?rqr
rkr\)r1r]rJr�Z
this_functionrr�r*r*r,r�4
s&

�

zDecimal._rescalecCsh	|dkr	td��|js|st|�S|�|��d||�}|��|��kr2|�|��d||�}|S)Nr&z'argument should be at least 1 in _roundr.)rwrWrr�r�)r1�placesrJrBr*r*r,�_roundV
s	
zDecimal._roundcCs�	|jr|j|d�}|r|St|�S|jdkrt|�S|s$t|jdd�S|dur+t�}|dur2|j}|�d|�}||krA|�	t
�|�	t�|S)NrQr&rX)rWr�rrVr=r>rrJr�rorr�r1rJr2rBr*r*r,�to_integral_exactm
s&	


zDecimal.to_integral_exactcCs^	|durt�}|dur|j}|jr |j|d�}|r|St|�S|jdkr)t|�S|�d|�S)NrQr&)rrJrWr�rrVr�rXr*r*r,r*�
s
zDecimal.to_integral_valuecCs�	|durt�}|jr"|j|d�}|r|S|��r"|jdkr"t|�S|s3t|jd|jd�}|�|�S|jdkr>|�	t
d�S|jd}t|�}|j
d?}|j
d@r`|jd}t|j�d?d}n|j}t|j�dd?}||}|dkr}|d|9}d	}	n
t|d|�\}}
|
}	||8}d|}	||}||kr�q�||d?}q�|	o�|||k}	|	r�|dkr�|d|}n|d|9}||7}n
|d
dkr�|d7}tdt|�|�}|��}|�t�}
|�|�}|
|_|S)NrQr&rXrdr.zsqrt(-x), x > 0r�r7Tr�)rrWr�r�r>rr=rVr�ror	rKrtr]r\rqr?r�rk�
_shallow_copy�
_set_roundingrrJ)r1r2rBrK�opr��c�lr�rKr�r<r�rJr*r*r,�sqrt�
sd





�


zDecimal.sqrtcCs�	t|dd�}|durt�}|js|jr@|��}|��}|s |r@|dkr-|dkr-|�|�S|dkr:|dkr:|�|�S|�||�S|�|�}|dkrN|�|�}|dkrU|}n|}|�|�S�NTr�r.r&r��r�rrWr�r�r�r��
compare_total�r1r�r2ZsnZonr]rBr*r*r,r�s(



	
zDecimal.maxcCs�	t|dd�}|durt�}|js|jr@|��}|��}|s |r@|dkr-|dkr-|�|�S|dkr:|dkr:|�|�S|�||�S|�|�}|dkrN|�|�}|dkrU|}n|}|�|�Sr`rarcr*r*r,r�*s(




zDecimal.mincCs:	|jrdS|jdkr
dS|j|jd�}|dt|�kS)NFr&TrX)rWrVr?rq)r1�restr*r*r,r(Ls
zDecimal._isintegercCs(	|r|jdkr
dS|jd|jdvS)Nr&Tr�r)rVr?r�r*r*r,r)UszDecimal._isevencCs.	z|jt|j�dWStyYdSw)Nr.r&)rVrqr?r}r�r*r*r,r�[s�zDecimal.adjustedcCs	|Sr)r*r�r*r*r,�	canonicalc�zDecimal.canonicalcCs0	t|dd�}|�||�}|r|S|j||d�S�NTr�rQ)r�r�r�r�r*r*r,�compare_signalkszDecimal.compare_signalcCsR	t|dd�}|jr|jstS|js|jrtS|j}|��}|��}|s&|r�||krPt|j�|jf}t|j�|jf}||krD|rBtStS||krN|rLtStStS|rk|dkrXtS|dkr^tS|dkrdtS|dkrjtSn|dkrqtS|dkrwtS|dkr}tS|dkr�tS||kr�tS||kr�tS|j|jkr�|r�tStS|j|jkr�|r�tStStS)NTr�r.rd)	r�r>�_NegativeOnerEr�rqr?�_ZerorV)r1r�r2rGZself_nanZ	other_nanZself_keyZ	other_keyr*r*r,rbwsj�zDecimal.compare_totalcCs(	t|dd�}|��}|��}|�|�Sr�)r�r�rb)r1r�r2r��or*r*r,�compare_total_mag�s

zDecimal.compare_total_magcCs	td|j|j|j�Sr�)r=r?rVrWr�r*r*r,r���zDecimal.copy_abscCs0	|jrtd|j|j|j�Std|j|j|j�S)Nr&r.)r>r=r?rVrWr�r*r*r,r��szDecimal.copy_negatecCs$	t|dd�}t|j|j|j|j�Sr�)r�r=r>r?rVrWr�r*r*r,�	copy_sign�s

�zDecimal.copy_signcCs�	|durt�}|j|d�}|r|S|��dkrtS|stS|��dkr(t|�S|j}|��}|jdkrK|t	t
|jdd��krKtdd|jd�}n�|jdkrj|t	t
|�
�dd��krjtdd|�
�d�}nr|jdkr�||kr�tddd|dd|�}nX|jdkr�||dkr�tdd|d|d�}n>t|�}|j|j}}|jdkr�|}d}	t||||�\}	}
|	d
dt	t
|	��|dr�q�|d7}q�tdt
|	�|
�}|��}|�t�}|�|�}||_|S)NrQr�r.r&rbr�rXrITr�r�)rr�r�rjrErrKr�r>rqrkrLr=r�rtr\r]rG�_dexprZr[rr�rJ)r1r2rBr;�adjr\r]r�rLr�r]rJr*r*r,r]�sN$( 
 �

zDecimal.expcCs	dS)NTr*r�r*r*r,�is_canonical'rfzDecimal.is_canonicalcCs
	|jSr))rWr�r*r*r,�	is_finite/�zDecimal.is_finitecC�	|jdkS)Nra�rVr�r*r*r,rT7�
zDecimal.is_infinitecCs	|jdvS)Nrfrur�r*r*r,r�;rvzDecimal.is_nancCs,	|js|sdS|durt�}|j|��kS�NF)rWrrSr�r�r*r*r,�	is_normal?�
zDecimal.is_normalcCrt)Nr<rur�r*r*r,r�GrvzDecimal.is_qnancCrt�Nr.)r>r�r*r*r,�	is_signedKrvzDecimal.is_signedcCrt)Nr`rur�r*r*r,r�OrvzDecimal.is_snancCs,	|js|sdS|durt�}|��|jkSrw)rWrr�rSr�r*r*r,�is_subnormalSryzDecimal.is_subnormalcCs	|jo	|jdkSr�r�r�r*r*r,�is_zero[szDecimal.is_zerocCs�	|jt|j�d}|dkrtt|dd��dS|dkr-ttd|dd��dSt|�}|j|j}}|dkrUt|d|�}t|�}t|�t|�||kS|ttd||��dS)Nr.�r�r�r�r&�rVrqr?rkrtr\r]�r1rpr\r]r��numZdenr*r*r,�
_ln_exp_bound_szDecimal._ln_exp_boundc
Cs	|durt�}|j|d�}|r|S|stS|��dkrtS|tkr$tS|jdkr/|�t	d�St
|�}|j|j}}|j
}||��d}	t|||�}|ddttt|���|dr_qd|d7}qFtt|d	k�tt|��|�}|��}|�t�}	|�|�}|	|_|S)
NrQr.zln of a negative valuerdTr�r�rbr&)rr��_NegativeInfinityr��	_InfinityrErjr>ror	rtr\r]rKr��_dlogrqrkrsr=rZr[rr�rJ�
r1r2rBr\r]r�r;rVr�rJr*r*r,�lnxs@
�$�

z
Decimal.lncCs�	|jt|j�d}|dkrtt|��dS|dkr%ttd|��dSt|�}|j|j}}|dkrQt|d|�}td|�}t|�t|�||kdStd||�}t|�||dkdS)	Nr.r�r�r&r���rdZ231rr�r*r*r,rF�szDecimal._log10_exp_boundc
CsH	|durt�}|j|d�}|r|S|stS|��dkrtS|jdkr)|�td�S|jddkrM|jdd�dt	|j�dkrMt
|jt	|j�d�}nDt|�}|j
|j}}|j}||��d}	t|||�}|d	d
t	tt|���|dr}q�|d7}qdtt
|dk�tt|��|�}|��}|�t�}	|�|�}|	|_|S)NrQr.zlog10 of a negative valuer&r�rXrdTr�r�rb)rr�r�r�r�r>ror	r?rqrrVrtr\r]rKrF�_dlog10rkrsr=rZr[rr�rJr�r*r*r,�log10�s@
�.$�

z
Decimal.log10cCsX	|j|d�}|r|S|durt�}|��rtS|s!|�tdd�St|���}|�|�S)NrQzlogb(0)r.)	r�rr�r�ror
rr�r�r�r*r*r,�logb�s
zDecimal.logbcCs8	|jdks|jdkr
dS|jD]	}|dvrdSqdS)Nr&FZ01T)r>rVr?)r1�digr*r*r,�
_islogical
s
�zDecimal._islogicalcCs�|jt|�}|dkrd||}n|dkr||jd�}|jt|�}|dkr3d||}||fS|dkr?||jd�}||fS)Nr&rX)rKrq)r1r2�opa�opbZdifr*r*r,�
_fill_logical'
s�zDecimal._fill_logicalcC�|	|durt�}t|dd�}|��r|��s|�t�S|�||j|j�\}}d�dd�t||�D��}t	d|�
d�p;dd�S)NTr�rZcSs$g|]\}}tt|�t|�@��qSr*�rkr\��.0rC�br*r*r,�
<listcomp>B
�$z'Decimal.logical_and.<locals>.<listcomp>r&rX�rr�r�ror	r�r?ry�zipr=rr�r1r�r2r�r�r�r*r*r,�logical_and4
�
zDecimal.logical_andcCs*	|durt�}|�tdd|jd�|�S)Nr&r�)r�logical_xorr=rKr�r*r*r,�logical_invertE
s�zDecimal.logical_invertcCr�)NTr�rZcSs$g|]\}}tt|�t|�B��qSr*r�r�r*r*r,r�Z
r�z&Decimal.logical_or.<locals>.<listcomp>r&rXr�r�r*r*r,�
logical_orL
r�zDecimal.logical_orcCr�)NTr�rZcSs$g|]\}}tt|�t|�A��qSr*r�r�r*r*r,r�k
r�z'Decimal.logical_xor.<locals>.<listcomp>r&rXr�r�r*r*r,r�]
r�zDecimal.logical_xorcCs�	t|dd�}|durt�}|js|jr@|��}|��}|s |r@|dkr-|dkr-|�|�S|dkr:|dkr:|�|�S|�||�S|���|���}|dkrR|�|�}|dkrY|}n|}|�|�Sr`�	r�rrWr�r�r�r�r�rbrcr*r*r,�max_magn
�(



zDecimal.max_magcCs�	t|dd�}|durt�}|js|jr@|��}|��}|s |r@|dkr-|dkr-|�|�S|dkr:|dkr:|�|�S|�||�S|���|���}|dkrR|�|�}|dkrY|}n|}|�|�Sr`r�rcr*r*r,�min_mag�
r�zDecimal.min_magcCs�	|durt�}|j|d�}|r|S|��dkrtS|��dkr+tdd|j|���S|��}|�t	�|�
�|�|�}||krC|S|�tdd|�
�d�|�S)NrQr�r.r&rIr�)rr�r�r�r=rKr	rRr[r�_ignore_all_flagsr�r�r��r1r2rBZnew_selfr*r*r,�
next_minus�
�&

�zDecimal.next_minuscCs�	|durt�}|j|d�}|r|S|��dkrtS|��dkr+tdd|j|���S|��}|�t	�|�
�|�|�}||krC|S|�tdd|�
�d�|�S)NrQr.r�rIr&r�)rr�r�r�r=rKr	rRr[rr�r�r�r�r�r*r*r,�	next_plus�
r�zDecimal.next_pluscCs�	t|dd�}|durt�}|�||�}|r|S|�|�}|dkr&|�|�S|dkr0|�|�}n|�|�}|��rM|�t	d|j
�|�t�|�t�|S|�
�|jkro|�t�|�t�|�t�|�t�|so|�t�|S)NTr�r&r�z Infinite result from next_toward)r�rr�r�rnr�r�r�rorr>rrr�rSrr
r)r1r�r2rBZ
comparisonr*r*r,�next_toward�
s:


�

�




zDecimal.next_towardcCs�	|��rdS|��r
dS|��}|dkrdS|dkrdS|��r(|jr&dSdS|dur/t�}|j|d	�r<|jr:d
SdS|jrAdSd
S)Nr�r�r.z	+Infinityr�z	-Infinityz-Zeroz+ZerorQz
-Subnormalz
+Subnormalz-Normalz+Normal)r�r�r�r}r>rr|)r1r2�infr*r*r,�number_classs.zDecimal.number_classcC�
	td�S�Nr�rr�r*r*r,�radix0sz
Decimal.radixcCs�	|durt�}t|dd�}|�||�}|r|S|jdkr"|�t�S|jt|�kr1|jks7n|�t�S|��r?t	|�St|�}|j
}|jt|�}|dkrXd||}n|dkrc||d�}||d�|d|�}t|j
|�d�pxd|j�S�NTr�r&rX�rr�r�rVror	rKr\r�rr?rqr=r>rr)r1r�r2rB�torot�rotdig�topadZrotatedr*r*r,�rotate4s0

 
�zDecimal.rotatecCs�	|durt�}t|dd�}|�||�}|r|S|jdkr"|�t�Sd|j|j}d|j|j}|t|�kr>|ksDn|�t�S|�	�rLt
|�St|j|j
|jt|��}|�|�}|S)NTr�r&r�rd)rr�r�rVror	rLrKr\r�rr=r>r?r�)r1r�r2rBZliminfZlimsupr�r*r*r,�scalebUs$



zDecimal.scalebcCs	|durt�}t|dd�}|�||�}|r|S|jdkr"|�t�S|jt|�kr1|jks7n|�t�S|��r?t	|�St|�}|j
}|jt|�}|dkrXd||}n|dkrc||d�}|dkrn|d|�}n|d|}||jd�}t|j
|�d�p�d|j�Sr�r�)r1r�r2rBr�r�r�Zshiftedr*r*r,r�ns6

 
�z
Decimal.shiftcCs|jt|�ffSr))�	__class__rkr�r*r*r,�
__reduce__�szDecimal.__reduce__cC�t|�tur|S|�t|��Sr)��typerr�rkr�r*r*r,�__copy__��zDecimal.__copy__cCr�r)r�)r1�memor*r*r,�__deepcopy__�r�zDecimal.__deepcopy__cCs.	|durt�}t||d�}|jr-t|j|�}t|���}|ddkr'|d7}t|||�S|ddur<ddg|j|d<|ddkrMt	|j|j
|jd�}|j}|d}|dur�|ddvrg|�
|d	|�}n!|dd
vru|�||�}n|ddvr�t|j
�|kr�|�
||�}|s�|jdkr�|dd
vr�|�d|�}|jt|j
�}	|ddvr�|s�|dur�d	|}
q�d	}
n|dd
vr�|	}
n|ddvr�|jdkr�|	d
kr�|	}
nd	}
|
dkr�d}d|
|j
}n'|
t|j
�kr�|j
d|
t|j
�}d}n|j
d|
��pd}|j
|
d�}|	|
}
t|j|||
|�S)N)�_localeconvr��%�g�Grd�	precision�eEr.zfF%ZgGr&r�rXrZ)r�_parse_format_specifierrW�_format_signr>rkr��
_format_alignr�r=r?rVrJrWr�rq�_format_number)r1Z	specifierr2r��specrG�bodyrJr�r�r�r�r�r]r*r*r,�
__format__�s\
zDecimal.__format__)rXN)NNr))FN)TN)�r6r7r8�	__slots__ri�classmethodr|r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r��__radd__r�r�r��__rmul__r�r�r�r�r�r�r�r�r�r�r�r��	__trunc__�propertyr�rrrr@r�rrrrrrrr�dictr
rr"r$r'r0rDrNrOrRrrUr�rWrYr*�to_integralr_r�r�r(r)r�rerhrbrlr�r�rnr]rqrrrTr�rxr�r{r�r|r}r�r�rFr�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,rs

,

 !
@

	
	
	
	2

4
	


V


7
;
!

$



K




f	�
>

,U
n
Y


="



c
*"	


I

K


2

3









.*

!
'rFcCs(	t�t�}||_||_||_||_|Sr))rhrirr>r?rVrW)rGZcoefficientr.Zspecialr1r*r*r,r=�s
r=c@s&eZdZ	dd�Zdd�Zdd�ZdS)rTcCs|��|_dSr))rR�new_context)r1r�r*r*r,�__init__�z_ContextManager.__init__cCst�|_t|j�|jSr))r�
saved_contextrr�r�r*r*r,�	__enter__s
z_ContextManager.__enter__cCst|j�dSr))rr�)r1�t�v�tbr*r*r,�__exit__r�z_ContextManager.__exit__N)r6r7r8r�r�r�r*r*r*r,rTs
rTc@s�eZdZ				d�dd�Zdd�Zdd�Zdd	�Zd
d�Zdd
�Zdd�Z	dd�Z
dd�Zdd�Zdd�Z
e
Zd�dd�Zdd�Zdd�Zdd�ZdZd d!�Zd"d#�Zd$d%�Zd�d'd(�Zd)d*�Zd+d,�Zd-d.�Zd/d0�Zd1d2�Zd3d4�Zd5d6�Zd7d8�Zd9d:�Z d;d<�Z!d=d>�Z"d?d@�Z#dAdB�Z$dCdD�Z%dEdF�Z&dGdH�Z'dIdJ�Z(dKdL�Z)dMdN�Z*dOdP�Z+dQdR�Z,dSdT�Z-dUdV�Z.dWdX�Z/dYdZ�Z0d[d\�Z1d]d^�Z2d_d`�Z3dadb�Z4dcdd�Z5dedf�Z6dgdh�Z7didj�Z8dkdl�Z9dmdn�Z:dodp�Z;dqdr�Z<dsdt�Z=dudv�Z>dwdx�Z?dydz�Z@d{d|�ZAd}d~�ZBdd��ZCd�d��ZDd�d��ZEd�d��ZFd�d�d��ZGd�d��ZHd�d��ZId�d��ZJd�d��ZKd�d��ZLd�d��ZMd�d��ZNd�d��ZOd�d��ZPd�d��ZQd�d��ZRd�d��ZSd�d��ZTd�d��ZUeUZVdS)�rNc
s<zt}
Wn	ty
Ynw|dur|n|
j|_|dur|n|
j|_|dur(|n|
j|_|dur2|n|
j|_|dur<|n|
j|_|durF|n|
j|_|	durRg|_n|	|_�dur`|
j	�
�|_	nt�t�stt�fdd�t
�D��|_	n�|_	�dur�t�t
d�|_dSt�t�s�t�fdd�t
�D��|_dS�|_dS)Nc3� �|]}|t|�v�fVqdSr)�r\�r�r��rIr*r,�	<genexpr>I��z#Context.__init__.<locals>.<genexpr>r&c3r�r)r�r��rJr*r,r�Pr�)r�	NameErrorrKrJrSrLr�r�_ignored_flagsrIrRrjr�rH�fromkeysrJ)r1rKrJrSrLr�rrJrIr�Zdcr*)rJrIr,r�0s0�

 
zContext.__init__cCs�t|t�std|��|dkr||krtd||||f��n%|dkr1||kr0td||||f��n||ks9||krCtd||||f��t�|||�S)Nz%s must be an integer�-infz%s must be in [%s, %d]. got: %sr�z%s must be in [%d, %s]. got: %sz%s must be in [%d, %d]. got %s)rjr\r}rwrh�__setattr__)r1�namerZvminZvmaxr*r*r,�_set_integer_checkTs
��zContext._set_integer_checkcCs`t|t�std|��|D]}|tvrtd|��q
tD]}||vr(td|��qt�|||�S)Nz%s must be a signal dictz%s is not a valid signal dict)rjr�r}rH�KeyErrorrhr�)r1r�r��keyr*r*r,�_set_signal_dictbs
��zContext._set_signal_dictcCs�|dkr|�||dd�S|dkr|�||dd�S|dkr$|�||dd�S|dkr0|�||dd�S|d	kr<|�||dd�S|d
krQ|tvrJtd|��t�|||�S|dksY|d
kr_|�||�S|dkrjt�|||�Std|��)NrKr.r�rSr�r&rLr�rrJz%s: invalid rounding moderJrIr�z.'decimal.Context' object has no attribute '%s')r��_rounding_modesr}rhr�r��AttributeError)r1r�rr*r*r,r�ms*�zContext.__setattr__cCstd|��)Nz%s cannot be deleted)r�)r1r�r*r*r,�__delattr__�rzContext.__delattr__c	CsNdd�|j��D�}dd�|j��D�}|j|j|j|j|j|j|j	||ffS)NcS�g|]\}}|r|�qSr*r*�r��sigr�r*r*r,r���z&Context.__reduce__.<locals>.<listcomp>cSr�r*r*r�r*r*r,r��r�)
rJ�itemsrIr�rKrJrSrLr�r)r1rJrIr*r*r,r��s��zContext.__reduce__cCs~	g}|�dt|��dd�|j��D�}|�dd�|�d�dd�|j��D�}|�dd�|�d�d�|�d	S)
NzrContext(prec=%(prec)d, rounding=%(rounding)s, Emin=%(Emin)d, Emax=%(Emax)d, capitals=%(capitals)d, clamp=%(clamp)dcS�g|]	\}}|r|j�qSr*�r6)r�r�r�r*r*r,r���z$Context.__repr__.<locals>.<listcomp>zflags=[z, �]cSr�r*r�)r�r�r�r*r*r,r��r�ztraps=[�))rx�varsrJr�ryrI)r1r��namesr*r*r,r��s�zContext.__repr__cC�	|jD]}d|j|<qdSr�r��r1�flagr*r*r,rS��
�zContext.clear_flagscCr�r�r�r�r*r*r,�clear_traps�rzContext.clear_trapsc
Cs0	t|j|j|j|j|j|j|j|j|j	�	}|Sr))
rrKrJrSrLr�rrJrIr��r1Zncr*r*r,rZ�s�zContext._shallow_copyc
Cs8	t|j|j|j|j|j|j|j��|j	��|j
�	}|Sr))rrKrJrSrLr�rrJrRrIr�rr*r*r,rR�s�zContext.copycGs\	t�||�}||jvr|�j|g|�R�Sd|j|<|j|s*|�j|g|�R�S||��rz)�_condition_maprNr�r3rJrI)r1Z	conditionZexplanationr+�errorr*r*r,ro�s


zContext._raise_errorcCs	|jt�Sr))�
_ignore_flagsrHr�r*r*r,r��rvzContext._ignore_all_flagscGs	|jt|�|_t|�Sr))r�ru)r1rJr*r*r,r�szContext._ignore_flagscGs:	|rt|dttf�r|d}|D]}|j�|�qdSr�)rjrvrur��remove)r1rJr�r*r*r,�
_regard_flags�s�zContext._regard_flagscC�	t|j|jd�Srz)r\rSrKr�r*r*r,r��rmz
Context.EtinycCrrz)r\rLrKr�r*r*r,r	�rmzContext.EtopcCs	|j}||_|Sr))rJ)r1r�rJr*r*r,r[�szContext._set_roundingrXcCsl	t|t�r||��ksd|vr|�td�St||d�}|��r1t|j�|j	|j
kr1|�td�S|�|�S)NrYzAtrailing or leading whitespace and underscores are not permitted.rQzdiagnostic info too long in NaN)rjrkrmrorrr�rqr?rKrr�)r1r�r�r*r*r,�create_decimal�s��
zContext.create_decimalcCs	t�|�}|�|�Sr))rr|r�)r1r�r�r*r*r,�create_decimal_from_floats

z!Context.create_decimal_from_floatcC�	t|dd�}|j|d�Srg)r�r��r1rCr*r*r,rs!szContext.abscC�4	t|dd�}|j||d�}|turtd|��|S�NTr�rQ�Unable to convert %s to Decimal)r�r�r�r}�r1rCr�r�r*r*r,�add6�
zContext.addcCst|�|��Sr))rkr�rr*r*r,�_applyKr�zContext._applycC�	t|t�s
td��|��S)Nz,canonical requires a Decimal as an argument.)rjrr}rerr*r*r,reN�
zContext.canonicalcC�	t|dd�}|j||d�Srg)r�r��r1rCr�r*r*r,r�[s zContext.comparecCrrg)r�rhrr*r*r,rh�zContext.compare_signalcC�	t|dd�}|�|�Sr�)r�rbrr*r*r,rb�s
zContext.compare_totalcCrr�)r�rlrr*r*r,rl�s
zContext.compare_total_magcC�	t|dd�}|��Sr�)r�r�rr*r*r,r���	zContext.copy_abscCs	t|dd�}t|�Sr�)r�rrr*r*r,�copy_decimal�rzContext.copy_decimalcCrr�)r�r�rr*r*r,r��rzContext.copy_negatecCrr�)r�rnrr*r*r,rn��
zContext.copy_signcCr
r)r�r�r�r}rr*r*r,�divideszContext.dividecCr
r)r�r�r�r}rr*r*r,�
divide_int+�zContext.divide_intcCr
r)r�r�r�r}rr*r*r,r�BrzContext.divmodcCrrg)r�r]rr*r*r,r]W�zContext.expcCs	t|dd�}|j|||d�Srg)r�r')r1rCr�r]r*r*r,r'oszContext.fmacCr)Nz/is_canonical requires a Decimal as an argument.)rjrr}rqrr*r*r,rq�rzContext.is_canonicalcCrr�)r�rrrr*r*r,rr�szContext.is_finitecCrr�)r�rTrr*r*r,rT��zContext.is_infinitecCrr�)r�r�rr*r*r,r���zContext.is_nancCrrg)r�rxrr*r*r,rx�szContext.is_normalcCrr�)r�r�rr*r*r,r��r"zContext.is_qnancCrr�)r�r{rr*r*r,r{��
zContext.is_signedcCrr�)r�r�rr*r*r,r��r#zContext.is_snancCrrg)r�r|rr*r*r,r|�zContext.is_subnormalcCrr�)r�r}rr*r*r,r}%r$zContext.is_zerocCrrg)r�r�rr*r*r,r�6r%z
Context.lncCrrg)r�r�rr*r*r,r�L�z
Context.log10cCrrg)r�r�rr*r*r,r�hszContext.logbcCrrg)r�r�rr*r*r,r���zContext.logical_andcCrrg)r�r�rr*r*r,r��szContext.logical_invertcCrrg)r�r�rr*r*r,r��r'zContext.logical_orcCrrg)r�r�rr*r*r,r��r'zContext.logical_xorcCrrg)r�r�rr*r*r,r��r'zContext.maxcCrrg)r�r�rr*r*r,r��
zContext.max_magcCrrg)r�r�rr*r*r,r�r'zContext.mincCrrg)r�r�rr*r*r,r�-r(zContext.min_magcCrrg)r�r�rr*r*r,�minus>�
z
Context.minuscCr
r)r�r�r�r}rr*r*r,�multiplyOszContext.multiplycCrrg)r�r�rr*r*r,r�o�zContext.next_minuscCrrg)r�r�rr*r*r,r��r,zContext.next_pluscCrrg)r�r�rr*r*r,r��rzContext.next_towardcCrrg)r�rRrr*r*r,rR�r!zContext.normalizecCrrg)r�r�rr*r*r,r��s.zContext.number_classcCrrg)r�r�rr*r*r,�plusr*zContext.pluscCs6	t|dd�}|j|||d�}|turtd|��|Sr)r�rNr�r})r1rCr�r,r�r*r*r,�powersHz
Context.powercCrrg)r�rrr*r*r,res6zContext.quantizecCr�r�rr�r*r*r,r��rsz
Context.radixcCr
r)r�r�r�r}rr*r*r,r��szContext.remaindercCrrg)r�r�rr*r*r,r��szContext.remainder_nearcCrrg)r�r�rr*r*r,r��szContext.rotatecCrr�)r�rUrr*r*r,rUrzContext.same_quantumcCrrg)r�r�rr*r*r,r�$szContext.scalebcCrrg)r�r�rr*r*r,r�7sz
Context.shiftcCrrg)r�r_rr*r*r,r_UszContext.sqrtcCr
r)r�r�r�r}rr*r*r,�subtractur zContext.subtractcCrrg)r�r�rr*r*r,r��r&zContext.to_eng_stringcCrrg)r�r�rr*r*r,�
to_sci_string�szContext.to_sci_stringcCrrg)r�rYrr*r*r,rY�szContext.to_integral_exactcCrrg)r�r*rr*r*r,r*�szContext.to_integral_value)	NNNNNNNNNr))rX)Wr6r7r8r�r�r�r�r�r�r�rSrrZrRr�ror�rrr�r�r	r[r	r
rsrrrer�rhrbrlr�rr�rnrrr�r]r'rqrrrTr�rxr�r{r�r|r}r�r�r�r�r�r�r�r�r�r�r�r)r+r�r�r�rRr�r-r.rr�r�r�r�rUr�r�r_r/r�r0rYr*r�r*r*r*r,rs�
�$



$#


%
 #2
P:&" rc@s"eZdZdZddd�Zdd�ZdS)rt�rGr\r]NcCsj|durd|_d|_d|_dSt|t�r$|j|_t|j�|_|j|_dS|d|_|d|_|d|_dS)Nr&r.rd)rGr\r]rjrr>r?rV)r1rr*r*r,r��s



z_WorkRep.__init__cCsd|j|j|jfS)Nz(%r, %r, %r)r1r�r*r*r,r�sz_WorkRep.__repr__r))r6r7r8r�r�r�r*r*r*r,rt�s
rtcCs�	|j|jkr|}|}n|}|}tt|j��}tt|j��}|jtd||d�}||jd|kr9d|_||_|jd|j|j9_|j|_||fS)Nr�rdr.r�)r]rqrkr\r�)r�r�rK�tmpr�Ztmp_lenZ	other_lenr]r*r*r,r�sr�cCs`	|dkrdS|dkr|d|Stt|��}t|�t|�d��}||kr)dS|d|S)Nr&r�rX)rkrsrq�rstrip)r<r�Zstr_nZval_nr*r*r,r9(s
r9cCsJ	|dks	|dkr
td��d}||kr#||||d?}}||ks|S)Nr&z3Both arguments to _sqrt_nearest should be positive.r.)rw)r<rCr�r*r*r,�
_sqrt_nearest=s�r4cCs4	d|>||?}}|d||d@|d@|kS)Nr.rdr*)r<r�r�r�r*r*r,�_rshift_nearestLs r5cCs(	t||�\}}|d||d@|kS)Nrdr.)r�)rCr�r�r�r*r*r,�_div_nearestTsr6r3c		Cs	||}d}||krt|�||>|ks#||krXt|�||?|krXt||d>|t||t||�|��}|d7}||krJt|�||>|ks#||krXt|�||?|ks#tdtt|��d|�}t||�}t||�}t|ddd�D]}t||�t|||�}qyt|||�S)Nr&r.���rbr�)rsr6r4r5r\rqrkr+)	r<�M�Lr?�R�TZyshift�wr�r*r*r,�_ilog\s.������

r=c
Cs�	|d7}tt|��}||||dk}|dkrKd|}|||}|dkr.|d|9}nt|d|�}t||�}t|�}t|||�}||}	n
d}t|d|�}	t|	|d�S�Nrdr.r&r�r7)rqrkr6r=�
_log10_digits)
r]r�r;r^r�r8r��log_dZlog_10Zlog_tenpowerr*r*r,r��s"

r�c	Cs�	|d7}tt|��}||||dk}|dkr:|||}|dkr*|d|9}nt|d|�}t|d|�}nd}|r_ttt|���d}||dkr\t|t||�d|�}qad}nd}t||d�Sr>)rqrkr6r=rsr?)	r]r�r;r^r�r�r@rLZ	f_log_tenr*r*r,r��s$r�c@seZdZ	dd�Zdd�ZdS)�
_Log10MemoizecCs
d|_dS)NZ/23025850929940456840179914546843642076011014886)r�r�r*r*r,r��s
z_Log10Memoize.__init__cCs�	|dkr	td��|t|j�krBd}	d||d}tttd||�d��}||d�d|kr3q8|d7}q|�d�dd	�|_t|jd|d
��S)Nr&zp should be nonnegativerbTr�rdr7rXr�r.)rwrqr�rkr6r=r3r\)r1r;rLr8r�r*r*r,�	getdigits�s�	z_Log10Memoize.getdigitsN)r6r7r8r�rBr*r*r*r,rA�srAc	Cs�	t||>|�}tdtt|��d|�}t||�}||>}t|ddd�D]
}t|||||�}q)t|ddd�D]}||d>}t||||�}q?||S)Nr7rbr.r&r�rd)r8r\rqrkr6r+)	r<r8r9r:r;r?ZMshiftr/r�r*r*r,�_iexp�s
rCc	Cs�	|d7}td|tt|��d�}||}||}|dkr%|d|}n|d|}t|t|��\}}t|d|�}tt|d|�d�||dfS)Nrdr&r.r�i�rb)r�rqrkr�r?r6rC)	r]r�r;rLr�r�ZcshiftZquotrBr*r*r,ro$s rocCs�	ttt|���|}t||||d�}||}|dkr&||d|}n
t||d|�}|dkratt|��|dk|dkkrSd|ddd|}	}
|	|
fSd|d|}	}
|	|
fSt||d|d�\}	}
t|	d�}	|
d7}
|	|
fS)Nr.r&r�)rqrkrsr�r6ro)r=r>r@rAr;r�Zlxcr�Zpcr�r]r*r*r,rGHs"��
rGr7�F�5�(�r~�r�r�)	r��2�3�4�5�6�7�8rIcCs2	|dkr	td��t|�}dt|�||dS)Nr&z0The argument to _log10_lb should be nonnegative.r7)rwrkrq)r]Z
correctionZstr_cr*r*r,r:rs
r:cCsN	t|t�r|St|t�rt|�S|rt|t�rt�|�S|r%td|��tS)Nr)rjrr\r{r|r}r�)r�r�Zallow_floatr*r*r,r�}s


r�cCs�	t|t�r
||fSt|tj�r*|js#t|jtt|j	�|j
�|j�}|t|j�fS|r:t|tj
�r:|jdkr:|j}t|t�rWt�}|rJd|jt<n|�td�|t�|�fSttfS)Nr&r.rg)rjr�_numbersZRationalrWr=r>rkr\r?�denominatorrV�	numeratorZComplexrr�r{rrJrror|r�)r1r�r�r2r*r*r,r��s*
�
�r�r6i?Bi���)rKrJrIrJrLrSr�rre)rKrJrIrJa�        # A numeric string consists of:
#    \s*
    (?P<sign>[-+])?              # an optional sign, followed by either...
    (
        (?=\d|\.\d)              # ...a number (with at least one digit)
        (?P<int>\d*)             # having a (possibly empty) integer part
        (\.(?P<frac>\d*))?       # followed by an optional fractional part
        (E(?P<exp>[-+]?\d+))?    # followed by an optional exponent, or...
    |
        Inf(inity)?              # ...an infinity, or...
    |
        (?P<signal>s)?           # ...an (optionally signaling)
        NaN                      # NaN
        (?P<diag>\d*)            # with (possibly empty) diagnostic info.
    )
#    \s*
    \Z
z0*$z50*$z�\A
(?:
   (?P<fill>.)?
   (?P<align>[<>=^])
)?
(?P<sign>[-+ ])?
(?P<alt>\#)?
(?P<zeropad>0)?
(?P<minimumwidth>(?!0)\d+)?
(?P<thousands_sep>,)?
(?:\.(?P<precision>0|(?!0)\d+))?
(?P<type>[eEfFgGn%])?
\Z
cCs�	t�|�}|durtd|��|��}|d}|d}|ddu|d<|dr<|dur2td|��|dur<td|��|p?d|d<|pEd|d<|d	durRd
|d	<t|dpXd�|d<|d
durjt|d
�|d
<|d
dkr�|ddus||ddvr�d|d
<|ddkr�d|d<|dur�t��}|ddur�td|��|d|d<|d|d<|d|d<|S|ddur�d|d<ddg|d<d|d<|S)NzInvalid format specifier: �fill�align�zeropadz7Fill character conflicts with '0' in format specifier: z2Alignment conflicts with '0' in format specifier: � �>rGr[�minimumwidthrXr�r&r�ZgGnr.r<r��
thousands_sepzJExplicit thousands separator conflicts with 'n' type in format specifier: �grouping�
decimal_pointrZrbr�)�_parse_format_specifier_regex�matchrw�	groupdictr\�_locale�
localeconv)�format_specr�r�Zformat_dictrSrTr*r*r,r�sX
����r�c	Cs�	|d}|d}||t|�t|�}|d}|dkr%|||}|S|dkr1|||}|S|dkr=|||}|S|dkrYt|�d}|d|�||||d�}|Std	��)
NrXrSrT�<rW�=�^rdzUnrecognised alignment field)rqrw)	rGr�r�rXrSZpaddingrTr�Zhalfr*r*r,r�ms&�	�� �r�cCsn	ddlm}m}|s
gS|ddkr&t|�dkr&||dd�||d��S|dtjkr3|dd�Std��)Nr&)�chain�repeatr�rdr�z unrecognised format for grouping)�	itertoolsrerfrqr_�CHAR_MAXrw)rZrerfr*r*r,�_group_lengths�sricCs�	|d}|d}g}t|�D]@}|dkrtd��ttt|�|d�|�}|�d|t|�||d��|d|�}||8}|sI|dkrIqj|t|�8}qtt|�|d�}|�d|t|�||d��|�t|��S)NrYrZr&zgroup length should be positiver.rX)rirwr�r�rqrxry�reversed)r�r��	min_width�seprZ�groupsr^r*r*r,�_insert_thousands_sep�s"$$rncCs"	|rdS|ddvr|dSdS)Nr[rGz +rZr*)�is_negativer�r*r*r,r��sr�cCs�	t||�}|s|dr|d|}|dks|ddvr/ddddd�|d}|d	�||�7}|dd
kr9|d
7}|drJ|dt|�t|�}nd}t|||�}t||||�S)
NZaltr[r&r�r�r�r�)r�r�r�r�z{0}{1:+}r�rUrX)r��formatrqrnr�)ror�r�r]r�rGZecharrkr*r*r,r��s
r�ZInfz-Infr�r�rdr))F)r&)r3)FF)r.)y�__all__r6Z	__xname__�__version__Z__libmpdec_version__�mathr�ZnumbersrP�sys�collectionsr'Z_namedtupler�ImportErrorrrrrrrrrr$r%�maxsizer r!r"r#�ArithmeticErrorrrr	r�ZeroDivisionErrorr
rrrrrr
rrr}rrHrr�ZcontextvarsZ
ContextVarrMrrrrhrr=�Number�registerrTrrtr�r\r�r8r9r4r5r6r=r�r�rArBr?rCrorGr:r�r�rrr�re�compile�VERBOSE�
IGNORECASEr]rlr
r�DOTALLr\�localer_r�r�rirnr�r�r�r�rArjrErirE�	hash_info�modulusr�r�r�r�Z_PyHASH_NANr�r�r*r*r*r,�<module>slc#�

&
���

.
^

0",#
%$
+�

*���
��

��
P
%
)
© 2025 GrazzMean