add-determinism 0.7.3

RPM buildroot helper to strip nondeterministic bits in files
Documentation

��g�,cs��OoOOFEoEo+OLoOOXO5oOOX1oXMX1O	O
X1o	X	MX
1OOX	1oO
OX1oXMX
1d)z~Abstract Base Classes (ABCs) for numbers, according to PEP 3141.

TODO: Fill out more detailed documentation on the operators.�)�ABCMeta�abstractmethod)�Number�Complex�Real�Rational�Integralcs �XoOoOoOoOoOoOod)ri%z�All numbers inherit from this class.

If you just want to check if an argument x is a number, without
caring what kind, use isinstance(x, Number).
�N)�__name__�
__module__�__qualname__�__firstlineno__�__doc__�	__slots__Z__hash__�__static_attributes__r�� /usr/lib64/python3.14/numbers.pyrr%s���
�I��Hrr)Z	metaclasscsL[�XoOoOojOoOoXO1oOoX	XO11o
X	XO11oXO1oXO	1o
XO
1oXO1oOoO
oXO1oXO1oXO1oXO1oXO1oXO1oXO1oXO1oXO1oOoQod)ri9aNComplex defines the operations that work on the builtin complex type.

In short, those are: a conversion to complex, .real, .imag, +, -,
*, /, **, abs(), .conjugate, ==, and !=.

If it is given heterogeneous arguments, and doesn't have special
knowledge about them, it should fall back to the builtin complex
type as described below.
rc��d)z<Return a builtin complex instance. Called for complex(self).Nr��self� r�__complex__ZComplex.__complex__Fs�rcs�QO6g!)z)True if self != 0. Called for bool(self).rrrrr�__bool__ZComplex.__bool__Js���q�y�rc��Wb)zHRetrieve the real component of this number.

This should subclass Real.
�ZNotImplementedErrorrrr�realZComplex.realN�
��"�!rcr)zMRetrieve the imaginary component of this number.

This should subclass Real.
rrrr�imagZComplex.imagWrrcr)zself + otherr�rZother�  r�__add__ZComplex.__add__`�
��"�!rcr)zother + selfrrrr�__radd__ZComplex.__radd__er rcr)z-selfrrrr�__neg__ZComplex.__neg__jr rcr)z+selfrrrr�__pos__ZComplex.__pos__or rcs�T'*!)zself - otherrrrr�__sub__ZComplex.__sub__ts���f�}�rcs�Q'Q*!)zother - selfrrrr�__rsub__ZComplex.__rsub__xs���u�u�}�rcr)zself * otherrrrr�__mul__ZComplex.__mul__|r rcr)zother * selfrrrr�__rmul__ZComplex.__rmul__�r rcr)z5self / other: Should promote to float when necessary.rrrr�__truediv__ZComplex.__truediv__�r rcr)zother / selfrrrr�__rtruediv__ZComplex.__rtruediv__�r rcr)zDself ** exponent; should promote to float or complex when necessary.r)r�exponentrr�__pow__ZComplex.__pow__�r rcr)zbase ** selfr)rZbaserr�__rpow__ZComplex.__rpow__�r rcr)z7Returns the Real distance from 0. Called for abs(self).rrrr�__abs__ZComplex.__abs__�r rcr)z$(x+y*i).conjugate() returns (x-y*i).rrrr�	conjugateZComplex.conjugate�r rcr)z
self == otherrrrr�__eq__ZComplex.__eq__�r rN)r	r
rrr
rrrr�propertyrrrr!r"r#r$r%r&r'r(r)r+r,r-r.r/r�__classdictcell__�Z
__classdict__�@rrr9sp������I��K��K����"���"���"���"��"��"��"��"��"��"��"��"����"��"��"��"��"��"��"��"��"��"��"��"��"��"��"��"��"��"rrcs[�XoOoOojOoOoXO1oXO1oXO1o	XO1o
XOO	g1oO
oOo
XO1oXO
1oXO1oXO1oXO1oXO1oOoXO1oXO1oOoOoQod)ri�z�To Complex, Real adds the operations that work on real numbers.

In short, those are: a conversion to float, trunc(), divmod,
%, <, <=, >, and >=.

Real also provides defaults for the derived operations.
rcr)zLAny Real can be converted to a native float object.

Called for float(self).rrrr�	__float__ZReal.__float__��
��
"�!rcr)atrunc(self): Truncates self to an Integral.

Returns an Integral i such that:
  * i > 0 iff self > 0;
  * abs(i) <= abs(self);
  * for any Integral j satisfying the first two conditions,
    abs(i) >= abs(j) [i.e. i has "maximal" abs among those].
i.e. "truncate towards 0".
rrrr�	__trunc__ZReal.__trunc__�s
��"�!rcr)z$Finds the greatest Integral <= self.rrrr�	__floor__ZReal.__floor__�r rcr)z!Finds the least Integral >= self.rrrr�__ceil__Z
Real.__ceil__�r rNcr)z�Rounds self to ndigits decimal places, defaulting to 0.

If ndigits is omitted or None, returns an Integral, otherwise
returns a Real. Rounds half toward even.
r)rZndigitsrr�	__round__ZReal.__round__�rrcs�T*T*0!)z�divmod(self, other): The pair (self // other, self % other).

Sometimes this can be computed faster than the pair of
operations.
rrrr�
__divmod__ZReal.__divmod__�s���
�t�|�,�,rcs�T*T*0!)z�divmod(other, self): The pair (other // self, other % self).

Sometimes this can be computed faster than the pair of
operations.
rrrr�__rdivmod__ZReal.__rdivmod__�s���
�u�|�,�,rcr)z)self // other: The floor() of self/other.rrrr�__floordiv__ZReal.__floordiv__�r rcr)z)other // self: The floor() of other/self.rrrr�
__rfloordiv__ZReal.__rfloordiv__�r rcr)zself % otherrrrr�__mod__ZReal.__mod__�r rcr)zother % selfrrrr�__rmod__Z
Real.__rmod__�r rcr)zJself < other

< on Reals defines a total ordering, except perhaps for NaN.rrrr�__lt__ZReal.__lt__r5rcr)z
self <= otherrrrr�__le__ZReal.__le__	r rc�*�WWQ11!)z(complex(self) == complex(float(self), 0))�complex�floatrrrrZReal.__complex__s���u�T�{�#�#rc��Q3!)z&Real numbers are their real component.rrrrrZ	Real.real����u�rcr)z)Real numbers have no imaginary component.rrrrrrZ	Real.imag���rcrE)zConjugate is a no-op for Reals.rrrrr.ZReal.conjugates	���u�r�N)r	r
rrr
rrr4r6r7r8r9r:r;r<r=r>r?r@rArr0rrr.rr1r2r3rrr�s'������I��"��"��
"��
"��"��"��"��"��"��"�-�-��"��"��"��"��"��"��"��"��"��"��"��"�
$���������rrcs`[�XoOoOojOoOoXXO11oXXO11o	Oo
OoQod)ri$z6.numerator and .denominator should be in lowest terms.rcrrHrrrr�	numeratorZRational.numerator)r rcrrHrrrr�denominatorZRational.denominator.r rcsX�WQM1WQM1*!)z�float(self) = self.numerator / self.denominator

It's important that this conversion use the integer's "true"
division rather than casting one side to float before dividing
so that ratios of huge integers convert without overflowing.

)�intrIrJrrrr4ZRational.__float__4s#���4�>�>�"�S��)9�)9�%:�:�:rN)
r	r
rrr
rr0rrIrJr4rr1r2r3rrr$sH����@��I�
��"���"���"���"�;rrcs&[�XoOoOojOoOoXO1oOoXOOg1o	XO1o
XO	1oXO
1oXO1o
XO1oXO
1oXO1oXO1oXO1oXO1oXO1oOoXO1oXO1oOoQod)ri?z�Integral adds methods that work on integral numbers.

In short, these are conversion to int, pow with modulus, and the
bit-string operations.
rcr)z	int(self)rrrr�__int__ZIntegral.__int__Hr rcs�WQ1!)z6Called whenever an index is needed, such as in slicing)rKrrr�	__index__ZIntegral.__index__Ms���4�y�rNcr)aself ** exponent % modulus, but maybe faster.

Accept the modulus argument if you want to support the
3-argument version of pow(). Raise a TypeError if exponent < 0
or any argument isn't Integral. Otherwise, just implement the
2-argument version described in Complex.
r)rr*Zmoduluss   rr+ZIntegral.__pow__Qs
��"�!rcr)z
self << otherrrrr�
__lshift__ZIntegral.__lshift__\r rcr)z
other << selfrrrr�__rlshift__ZIntegral.__rlshift__ar rcr)z
self >> otherrrrr�
__rshift__ZIntegral.__rshift__fr rcr)z
other >> selfrrrr�__rrshift__ZIntegral.__rrshift__kr rcr)zself & otherrrrr�__and__ZIntegral.__and__pr rcr)zother & selfrrrr�__rand__ZIntegral.__rand__ur rcr)zself ^ otherrrrr�__xor__ZIntegral.__xor__zr rcr)zother ^ selfrrrr�__rxor__ZIntegral.__rxor__r rcr)zself | otherrrrr�__or__ZIntegral.__or__�r rcr)zother | selfrrrr�__ror__ZIntegral.__ror__�r rcr)z~selfrrrr�
__invert__ZIntegral.__invert__�r rcrB)zfloat(self) == float(int(self)))rDrKrrrr4ZIntegral.__float__�s���S��Y��rcrE)z"Integers are their own numerators.rrrrrIZIntegral.numerator�rFrcr)z!Integers have a denominator of 1.irrrrrJZIntegral.denominator�rGrrH)r	r
rrr
rrrLrMr+rNrOrPrQrRrSrTrUrVrWrXr4r0rIrJrr1r2r3rrr?sE������I��"��"���"��"��"��"��"��"��"��"��"��"��"��"��"��"��"��"��"��"��"��"��"��"��"��"�
 ��������rrN)r
ZabcrrZ__all__rrZregisterrCrrDrrrKrrr�<module>rYs���@�:(�
?��	�w�	�(n"�f�n"�`�����s�7�s�j�
�
�e��;�t�;�6a�x�a�F	���#�r