pyGoEdge-UserPanel/.venv/Lib/site-packages/dns/__pycache__/rdata.cpython-312.pyc

<EFBFBD>
g<>
i<>|<00><00><><00>UdZd
dl
Z
d
dlZd
dlZd
dlZd
dlZd
dlZd
dlZd
dlm	Z	
d
dl
mZmZm
Z

d
dlZd
dlZd
dlZd
dlZd
dlZd
dlZd
dlZd
dlZd
dlZd
dlZdZdZGd<07>dej6j8<00>Zed	fd
<EFBFBD>
Zed	fd<0B>
Zed	fd<0C>
Z d
Z!d<0E>Z"d<0F>Z#ejHjJZ&ejHjHGd<10>d<11><00>Z'ejHjHGd<12>de'<27><00>Z(iZ)ee
ejTjVejXjZfefe.d<dZ/da0d.d<16>
Z1d.d<17>
Z2				d/dejTjVe3zdejXjZe3zdejhjje3zdejljndzde8dejljndzdejljrdzde'fd <20>Z:	d0dejTjVe3zdejXjZe3zd!ejvjxdejljndzde'f
d"<22>Z=	d0dejTjVe3zdejXjZe3zd#e>d$e?d%e?dejljndzde'fd&<26>Z@Gd'<27>d(ej6j8<00>ZAd)ejTj<>fd*ede?d+e3d,e8dejTjVddfd-<2D>ZCy)1z
DNS rdata.<2E>N)
<01>
import_module)<03>Any<6E>Dict<63>Tuple<6C> Tc
<00><00>eZ
dZd
Zy)<03>NoRelativeRdataOrderingz<67>An attempt was made to do an ordered comparison of one or more
    rdata with relative names.  The only reliable way of sorting rdata
    is to use non-relativized rdata.

    N)<04>__name__<5F>
__module__<EFBFBD>__qualname__<5F>__doc__<5F><00><00>8E:\Project\pygoedge\.venv\Lib\site-packages\dns/rdata.pyr	r	4s<00><00>rr	<00>
 c	<00><><00>|
s|j
<00>S|jtd
t|<00>
|
<01>D<00>cgc]
}||||
z<00><02>c}<03>
j
<00>Sc
c}w)zXBreak a binary string into chunks of chunksize characters separated by
    a space.
    r)<04>decode<64>join<69>range<67>len)<04>data<74>	chunksize<7A>	separator<6F>
is    r<00>
_wordbreakr<sZ<00><00>
<15><13>{<7B>{<7B>}<7D><1C><14>><3E>><3E>*/<2F>
<01>3<EFBFBD>t<EFBFBD>9<EFBFBD>i<EFBFBD>*H<>I<>*H<>Q<EFBFBD><14>a<EFBFBD>!<21>i<EFBFBD>-<2D>	 <20>*H<>I<><06><0C>f<EFBFBD>h<EFBFBD><0F><>Is<00>Ac<00>B<00>t
tj|<00>
|
|<02>S)
zConvert a binary string into its hex encoding, broken up into chunks
    of chunksize characters separated by a separator.
    )r<00>binascii<69>hexlify<66>rrr<00>kws    r<00>_hexifyr!Ks<00><00>
<16>h<EFBFBD>&<26>&<26>t<EFBFBD>,<2C>i<EFBFBD><19>C<>Crc<00>B<00>t
tj|<00>
|
|<02>S)
z<>Convert a binary string into its base64 encoding, broken up into chunks
    of chunksize characters separated by a separator.
    )r<00>base64<36>	b64encoders    r<00>
_base64ifyr%Ss<00><00>
<16>f<EFBFBD>&<26>&<26>t<EFBFBD>,<2C>i<EFBFBD><19>C<>Crs"\c
<00>
<00>t
|t<00>r|j<00>}t
|t<00>st|<00>
}d
}
|D]>}|tvr|
dt|<02>
zz
}
<01>|dk\r|dkr|
t|<02>
z
}
<01>6|
d|d<05><04>z
}
<01>@|
S)z7Escape the characters in a quoted string which need it.<2E><00>
\r<00><00>03d)<06>
isinstance<EFBFBD>str<74>encode<64>	bytearray<61>	__escaped<65>chr)<03>qstring<6E>text<78>
cs   r<00>	_escapifyr4`s<><00><00><12>'<27>3<EFBFBD><1F><19>.<2E>.<2E>"<22><07><15>g<EFBFBD>y<EFBFBD>)<29><1B>G<EFBFBD>$<24><07>
<0A>D<EFBFBD>
<14>
<01><0C>	<09>><3E><10>D<EFBFBD>3<EFBFBD>q<EFBFBD>6<EFBFBD>M<EFBFBD>!<21>D<EFBFBD>
<0E>$<24>Y<EFBFBD>1<EFBFBD>t<EFBFBD>8<EFBFBD><10>C<EFBFBD>
<01>F<EFBFBD>N<EFBFBD>D<EFBFBD><10>b<EFBFBD><11>3<EFBFBD><07>L<EFBFBD> <20>D<EFBFBD>
<15><10>Krc
<00>l<00>t
t|<00>
d
z
dd<02>D]}
||
dk7s
<01>|d|
d
zc
S|dd
S)z<>Determine the index of greatest byte that isn't all zeros, and
    return the bitmap that contains all the bytes less than that index.
    <20>
<00><><EFBFBD><EFBFBD><EFBFBD>r)rr)<02>whatrs  r<00>_truncate_bitmapr9ssH<00><00>
<13>3<EFBFBD>t<EFBFBD>9<EFBFBD>q<EFBFBD>=<3D>"<22>b<EFBFBD>
)<29>
<01><0F>
<01>7<EFBFBD>a<EFBFBD><<3C><17>
<01>A<EFBFBD>
<01>E<EFBFBD>?<3F>"<22>*<2A><10>
<01>!<21>9<EFBFBD>rc<00><><00>eZ
dZd
Zgd<02>
Zdejjdejjddfd<07>Z
d<08>Zd	<09>Zd
<EFBFBD>Z
dejjfd<0B>Zdefd<0C>Z		d=d
ej"j$dzdedeeefdefd<10>Z			d>dedej"j0dzd
ej"j$dzdeddf
d<14>Z				d?dedzdej"j0dzd
ej"j$dzdededzf
d<15>Zd@d
ej"j$dzddfd<17>Zd@d
ej"j$dzdefd<18>Zd<19>Zd<1A>Zd<1B>Z d<1C>Z!d<1D>Z"d<1E>Z#d<1F>Z$d <20>Z%d!<21>Z&d"<22>Z'e(			dAdejjdejjd#ejRjTd
ej"j$dzded$ej"j$dzddfd%<25><05>Z+e(	d@dejjdejjd&ejXjZd
ej"j$dzddf
d'<27><05>Z.d(eddfd)<29>Z/e(d*<2A><00>Z0e(d+<2B><00>Z1e(			dBd,ed-ed.edzd/edef
d0<EFBFBD><05>Z2e(d1<64><00>Z3e(d2<64><00>Z4e(d3<64><00>Z5e(d4<64><00>Z6e(d5<64><00>Z7e(dCd6<64>
<01>Z8e(d7<64><00>Z9e(d8<64><00>Z:e(d9<64><00>Z;e(d:<3A><00>Z<e(d;<3B><00>Z=e(d<<3C><00>Z>y)D<>Rdataz#Base class for all DNS rdata types.)<03>rdclass<73>rdtype<70>	rdcommentr<r=<00>returnNc<00>j<00>|j
|
<01>
|_
|j|<02>
|_d
|_y
)z<>Initialize an rdata.

        *rdclass*, an ``int`` is the rdataclass of the Rdata.

        *rdtype*, an ``int`` is the rdatatype of the Rdata.
        N)<05>_as_rdataclassr<<00>
_as_rdatatyper=r>)<03>selfr<r=s   r<00>__init__zRdata.__init__<5F>s/<00><00><1C>*<2A>*<2A>7<EFBFBD>3<><04><0C><1A>(<28>(<28><16>0<><04><0B><1D><04>rc
<00>v<00>tjjd
<01>|jjD<00><00>
S)Nc
3<00>6K
<00>|]}
t
|
dg<00><00>
<01>

<00>y
<01>w
)<02>	__slots__N)
<01>getattr)<02>.0<EFBFBD>clss  r<00>	<genexpr>z'Rdata._get_all_slots.<locals>.<genexpr><3E>s<00><00><><00>-
<EFBFBD>5K<EFBFBD>c<EFBFBD>G<EFBFBD>C<EFBFBD><1B>b<EFBFBD>)<29>5K<35>s<00>
)<05>	itertools<6C>chain<69>
from_iterable<6C>	__class__<5F>__mro__<5F>
rCs
 r<00>_get_all_slotszRdata._get_all_slots<74>s0<00><00><18><EFBFBD><EFBFBD>,<2C>,<2C>-
<EFBFBD>59<EFBFBD>^<5E>^<5E>5K<35>5K<35>-
<EFBFBD>
<EFBFBD>	
rc
<00>R<00>i}
|j
<00>D]}t||<02>|
|<<00>|
S<00>
N)rRrH)rC<00>state<74>slots   r<00>__getstate__zRdata.__getstate__<5F>s1<00><00><13><05><18>'<27>'<27>)<29>D<EFBFBD>!<21>$<24><04>-<2D>E<EFBFBD>$<24>K<EFBFBD>*<2A><14>rc<00><><00>|
j
<00>D]\}}tj|||<03>
<00>t|d
<01>stj|d
d<00>
yy)Nr>)<04>items<6D>object<63>__setattr__<5F>hasattr)rCrUrV<00>vals    r<00>__setstate__zRdata.__setstate__<5F>sK<00><00><1E><1B><1B><1D>I<EFBFBD>D<EFBFBD>#<23><12><1E><1E>t<EFBFBD>T<EFBFBD>3<EFBFBD>/<2F>'<27><16>t<EFBFBD>[<5B>)<29>
<13><1E><1E>t<EFBFBD>[<5B>$<24>7<>*rc

<00>6<00>tjjS)
a<>
Return the type a Rdata covers.

        DNS SIG/RRSIG rdatas apply to a specific type; this type is
        returned by the covers() function.  If the rdata type is not
        SIG or RRSIG, dns.rdatatype.NONE is returned.  This is useful when
        creating rdatasets, allowing the rdataset to contain only RRSIGs
        of a particular type, e.g. RRSIG(NS).

        Returns a ``dns.rdatatype.RdataType``.
        )<03>dns<6E>	rdatatype<70>NONErQs
 r<00>coverszRdata.covers<72>s<00><00><13>}<7D>}<7D>!<21>!<21>!rc
<00>B<00>|j
<00>d
z|jzS)z<>Return a 32-bit type value, the least significant 16 bits of
        which are the ordinary DNS type, and the upper 16 bits of which are
        the "covered" type, if any.

        Returns an ``int``.
        <20>)rcr=rQs
 r<00>extended_rdatatypezRdata.extended_rdatatype<70>s<00><00><14>{<7B>{<7B>}<7D><02>"<22>T<EFBFBD>[<5B>[<5B>0<>0r<00>origin<69>
relativizer c
<00><00>t<00>
)
zEConvert an rdata to text format.

        Returns a ``str``.
        <20>
<01>NotImplementedError<6F>rCrgrhr s    r<00>to_textz
Rdata.to_text<78>s
<00><00>"<22>!r<00>file<6C>compress<73>canonicalizec
<00><00>t<00>
rTrj<00>rCrnrorgrps     r<00>_to_wirezRdata._to_wire<72>s
<00><00>"<22>!rc<00><><00>|
r|j
|
|||<04>
y
tj<00>}|j
||||<04>
|j<00>S)z~Convert an rdata to wire format.

        Returns a ``bytes`` if no output file was specified, or ``None`` otherwise.
        N)rs<00>io<69>BytesIO<49>getvalue)rCrnrorgrp<00>
fs      r<00>to_wirez
Rdata.to_wire<72>sG<00><00><10>

<11>M<EFBFBD>M<EFBFBD>$<24><08>&<26>,<2C>?<3F><17><12>
<EFBFBD>
<EFBFBD><0C>A<EFBFBD><10>M<EFBFBD>M<EFBFBD>!<21>X<EFBFBD>v<EFBFBD>|<7C><<3C><14>:<3A>:<3A><<3C>r<00>GenericRdatac<00>p<00>|j
|
<01>
<01>
}|<02>J<00>
t|j|j|<02>S)zrCreates a dns.rdata.GenericRdata equivalent of this rdata.

        Returns a ``dns.rdata.GenericRdata``.
        )
rg)ryrzr<r=<00>rCrg<00>wires   r<00>
to_genericzRdata.to_generic<69>s7<00><00>
<14>|<7C>|<7C>6<EFBFBD>|<7C>*<2A><04><13><1F><1F><1F><1B>D<EFBFBD>L<EFBFBD>L<EFBFBD>$<24>+<2B>+<2B>t<EFBFBD><<3C><rc<00>4<00>|j
|
d
<01><02>}|<02>J<00>
|S)z<>Convert rdata to a format suitable for digesting in hashes.  This
        is also the DNSSEC canonical form.

        Returns a ``bytes``.
        T)rgrp)
ryr|s   r<00>
to_digestablezRdata.to_digestable
s'<00><00><14>|<7C>|<7C>6<EFBFBD><04>|<7C>=<3D><04><13><1F><1F><1F><13>rc
<00><>
<00>|j
<00>}
|
tjjk(rd
}n%dtjj	|
<01>
zdz}dtj
j	|j<00>
zdztjj	|j<00>
z|zdzt|<00>
zdzS)Nr'<00>
(<28>
)z<DNS <20>
 z rdata: <20>
>)	rcr`rarbrm<00>
rdataclassr<r=r,)rCrc<00>ctexts   r<00>__repr__zRdata.__repr__
s<><00><00><15><1B><1B><1D><06><11>S<EFBFBD>]<5D>]<5D>'<27>'<27>'<27><16>E<EFBFBD><17>#<23>-<2D>-<2D>/<2F>/<2F><06>7<>7<>#<23>=<3D>E<EFBFBD><13><11>n<EFBFBD>n<EFBFBD>$<24>$<24>T<EFBFBD>\<5C>\<5C>2<>

3<><11>
<12><12>m<EFBFBD>m<EFBFBD>#<23>#<23>D<EFBFBD>K<EFBFBD>K<EFBFBD>0<>
1<><14>	
<14>
<19>
<19><12>$<24>i<EFBFBD>

<18><12>
<12>		
rc
<00>"<00>|j
<00>SrT)
rmrQs
 r<00>__str__z
Rdata.__str__
s<00><00><13>|<7C>|<7C>~<7E>rc<00><>
<00>d
}d
}	|j
<00>}d}	|
j
<00>}d}tr	||k7r|r
yy|s|rt<00>
||k(r
y||kDr
yy#tjj$r4
tr)|j
tjj
<00>
}d}Y<00><>wxYw
#tjj$r4
tr)|
j
tjj
<00>
}d}Y<00><>wxYw
)a
Compare an rdata with another rdata of the same rdtype and
        rdclass.

        For rdata with only absolute names:
            Return < 0 if self < other in the DNSSEC ordering, 0 if self
            == other, and > 0 if self > other.
        For rdata with at least one relative names:
            The rdata sorts before any rdata with only absolute names.
            When compared with another relative rdata, all names are
            made absolute as if they were relative to the root, as the
            proper origin is not available.  While this creates a stable
            ordering, it is NOT guaranteed to be the DNSSEC ordering.
            In the future, all ordering comparisons for rdata with
            relative names will be disallowed.
        rFTr7r6r)r<>r`<00>name<6D>NeedAbsoluteNameOrOrigin<69>_allow_relative_comparisons<6E>rootr	)rC<00>other<65>our<75>their<69>our_relative<76>their_relatives      r<00>_cmpz
Rdata._cmp 
s<><00><00>"<12><03><13><05>	 <20><16>$<24>$<24>&<26>C<EFBFBD> <20>L<EFBFBD>
	"<22><19>'<27>'<27>)<29>E<EFBFBD>"<22>N<EFBFBD>
'<27><1B>~<7E>-<2D> <20><1D><1C>
<19>^<5E>)<29>)<29><0E>%<25><<3C><14>
<10>5<EFBFBD>[<5B><14><15><>5<13>x<EFBFBD>x<EFBFBD>0<>0<>	 <20>*<2A><1A>(<28>(<28><13><18><18><1D><1D>7<><03><1F>L<EFBFBD>	 <20><><13>x<EFBFBD>x<EFBFBD>0<>0<>	"<22>*<2A><1D>+<2B>+<2B>C<EFBFBD>H<EFBFBD>H<EFBFBD>M<EFBFBD>M<EFBFBD>:<3A><05>!<21>N<EFBFBD>	"<22>s$<00>A<00>B%<00>AB"<03>!
B"<03>%AC6<03>5
C6c<00>$<00>t
|
t<00>s
y
|j|
jk7s|j|
jk7r
y
d
}d
}	|j	<00>}	|
j	<00>}||k7r
y
||k(S#t
jj$r.
|j	t
jj<00>
}d}Y<00>fwxYw
#t
jj$r.
|
j	t
jj<00>
}d}Y<00><>wxYw
)NFT)	r+r;r<r=r<>r`r<>r<>r<>)rCr<>r<>r<>r<>r<>s      r<00>__eq__zRdata.__eq__R
s<><00><00><19>%<25><15>'<27><18><0F><<3C><<3C>5<EFBFBD>=<3D>=<3D>(<28>D<EFBFBD>K<EFBFBD>K<EFBFBD>5<EFBFBD><<3C><<3C>,G<><18><1C><0C><1E><0E>	 <20><16>$<24>$<24>&<26>C<EFBFBD>	"<22><19>'<27>'<27>)<29>E<EFBFBD><18>><3E>)<29><18><12>e<EFBFBD>|<7C><1B><><13>x<EFBFBD>x<EFBFBD>0<>0<>	 <20><16>$<24>$<24>S<EFBFBD>X<EFBFBD>X<EFBFBD>]<5D>]<5D>3<>C<EFBFBD><1F>L<EFBFBD>	 <20><>
<13>x<EFBFBD>x<EFBFBD>0<>0<>	"<22><19>'<27>'<27><03><08><08>
<0A>
<0A>6<>E<EFBFBD>!<21>N<EFBFBD>	"<22>s&<00>
A6<00>C<00>6AC
<03>
C
<03>AD<03>
Dc<00><><00>t
|
t<00>s
y
|j|
jk7s|j|
jk7r
y
|j	|
<01>
S<00>NT)r+r;r<r=r<><00>rCr<>s  r<00>__ne__zRdata.__ne__g
sC<00><00><19>%<25><15>'<27><17><0F><<3C><<3C>5<EFBFBD>=<3D>=<3D>(<28>D<EFBFBD>K<EFBFBD>K<EFBFBD>5<EFBFBD><<3C><<3C>,G<><17><17>;<3B>;<3B>u<EFBFBD>%<25>%<25>%rc<00><><00>t
|
t<00>r2|j|
jk7s|j|
jk7rtS|j|
<01>
d
kS<00>Nr<00>r+r;r<r=<00>NotImplementedr<64>r<>s  r<00>__lt__zRdata.__lt__n
<00>F<00><00><1A>5<EFBFBD>%<25>(<28><13>|<7C>|<7C>u<EFBFBD>}<7D>}<7D>,<2C><13>{<7B>{<7B>e<EFBFBD>l<EFBFBD>l<EFBFBD>*<2A>!<21>!<21><13>y<EFBFBD>y<EFBFBD><15><1F>!<21>#<23>#rc<00><><00>t
|
t<00>r2|j|
jk7s|j|
jk7rtS|j|
<01>
d
kSr<>r<>r<>s  r<00>__le__zRdata.__le__w
<00>F<00><00><1A>5<EFBFBD>%<25>(<28><13>|<7C>|<7C>u<EFBFBD>}<7D>}<7D>,<2C><13>{<7B>{<7B>e<EFBFBD>l<EFBFBD>l<EFBFBD>*<2A>!<21>!<21><13>y<EFBFBD>y<EFBFBD><15><1F>1<EFBFBD>$<24>$rc<00><><00>t
|
t<00>r2|j|
jk7s|j|
jk7rtS|j|
<01>
d
k\Sr<>r<>r<>s  r<00>__ge__zRdata.__ge__<5F>
r<>rc<00><><00>t
|
t<00>r2|j|
jk7s|j|
jk7rtS|j|
<01>
d
kDSr<>r<>r<>s  r<00>__gt__zRdata.__gt__<5F>
r<>rc
<00>f<00>t
|jtjj<00>
<00>
SrT)<05>hashr<68>r`r<>r<>rQs
 r<00>__hash__zRdata.__hash__<5F>
s <00><00><13>D<EFBFBD>&<26>&<26>s<EFBFBD>x<EFBFBD>x<EFBFBD>}<7D>}<7D>5<>6<>6r<00>tok<6F>
relativize_toc
<00><00>t<00>
rTrj)rJr<r=r<>rgrhr<>s       r<00>	from_textzRdata.from_text<78>
s
<00><00>"<22>!r<00>parserc
<00><00>t<00>
rTrj<00>rJr<r=r<>rgs     r<00>from_wire_parserzRdata.from_wire_parser<65>
s
<00><00>"<22>!r<00>kwargsc
<00><>
<00><00>
<01>t
j<00>j<00>
j}<02>
D]\}|d
k(r
<01>	||v
r&t	d<02>j
j<00>d|<03>d<02><05>
<00>
|dvs
<01>8t	d<05>j
j<00>d|<03>d<02><05>
<00>
<00>
<01>fd<07>|D<00>}<00>j
|<04>}<05>
jd
<01>j<00>}|<06>tj|d
|<06>
|S)a<>

        Create a new Rdata instance based on the instance replace was
        invoked on. It is possible to pass different parameters to
        override the corresponding properties of the base Rdata.

        Any field specific to the Rdata type can be replaced, but the
        *rdtype* and *rdclass* fields cannot.

        Returns an instance of the same Rdata subclass as *self*.
        r><00>
'z' object has no attribute '<27>r<r=zCannot overwrite 'z
' attribute 'c
3<00>V<00>K
<00>|] }
<01>j
|
t<00>|
<01><00><00>
<01>

<00>"y<00>w
rT)<02>getrH)rI<00>keyr<79>rCs  <20><>rrKz Rdata.replace.<locals>.<genexpr><3E>
s$<00><><00><><00>J<>z<EFBFBD><03><06>
<EFBFBD>
<EFBFBD>3<EFBFBD><07><04>c<EFBFBD> 2<>3<>z<EFBFBD>s<00>&)
)<0B>inspect<63>	signaturerD<00>
parameters<EFBFBD>AttributeErrorrOr
r<>r>rZr[)rCr<>r<>r<><00>args<67>rdr>s``     r<00>replacez
Rdata.replace<63>
s<><00><><00><1D>&<26>&<26>t<EFBFBD>}<7D>}<7D>5<>@<40>@<40>
<EFBFBD><1A>C<EFBFBD><12>k<EFBFBD>!<21><18><12>*<2A>$<24>$<24><17><04><0E><0E>/<2F>/<2F>0<>0K<30>C<EFBFBD>5<EFBFBD>PQ<50>R<><12><12><13>+<2B>+<2B>$<24>(<28><14><1E><1E>)@<40>)@<40>(A<><1D>s<EFBFBD>e<EFBFBD>ST<53>U<><12><12><1A>K
<01>z<EFBFBD>J<><04><1C>T<EFBFBD>^<5E>^<5E>T<EFBFBD>
"<22><02><1B>J<EFBFBD>J<EFBFBD>{<7B>D<EFBFBD>N<EFBFBD>N<EFBFBD>;<3B>	<09><14> <20><12><1E><1E>r<EFBFBD>;<3B>	<09>:<3A><11>	rc<00>T<00>tjjj|
<01>
SrT)r`r<><00>
RdataClass<EFBFBD>make<6B>rJ<00>values  rrAzRdata._as_rdataclass<73>
s<00><00><12>~<7E>~<7E>(<28>(<28>-<2D>-<2D>e<EFBFBD>4<>4rc<00>T<00>tjjj|
<01>
SrT)r`ra<00>	RdataTyper<65>r<>s  rrBzRdata._as_rdatatype<70>
s<00><00><12>}<7D>}<7D>&<26>&<26>+<2B>+<2B>E<EFBFBD>2<>2rr<>r-<00>
max_length<EFBFBD>empty_okc<00>,
<00>|r!t
|
t<00>r|
j<00>}n:t
|
t<00>rt	|
<01>
}nt
|
t<00>r|
}ntd
<01>
<00>
|<03>t
|<05>
|kDrtd<02>
<00>
|st
|<05>
dk(rtd<04>
<00>
|S)Nz	not bytesztoo longrzempty bytes not allowed)r+r,r-r.<00>bytes<65>
ValueErrorr)rJr<>r-r<>r<><00>bvalues      r<00>	_as_byteszRdata._as_bytes<65>
s<><00><00><12>j<EFBFBD><15><03>,<2C><1A>\<5C>\<5C>^<5E>F<EFBFBD>
<17><05>y<EFBFBD>
)<29><1A>5<EFBFBD>\<5C>F<EFBFBD>
<17><05>u<EFBFBD>
%<25><1A>F<EFBFBD><1C>[<5B>)<29>)<29><15>!<21>c<EFBFBD>&<26>k<EFBFBD>J<EFBFBD>&><3E><1C>Z<EFBFBD>(<28>(<28><17>C<EFBFBD><06>K<EFBFBD>1<EFBFBD>,<2C><1C>6<>7<>7<><15>
rc<00><><00>t
|
t<00>rtjj	|
<01>
St
|
tjj
<00>st
d
<01>
<00>
|
S)Nz
not a name)r+r,r`r<>r<><00>Namer<65>r<>s  r<00>_as_namezRdata._as_name<6D>
sE<00><00>
<16>e<EFBFBD>S<EFBFBD>!<21><16>8<EFBFBD>8<EFBFBD>%<25>%<25>e<EFBFBD>,<2C>,<2C><1B>E<EFBFBD>3<EFBFBD>8<EFBFBD>8<EFBFBD>=<3D>=<3D>1<><1C>\<5C>*<2A>*<2A><14>rc<00>f<00>t
|
t<00>std
<01>
<00>
|
dks|
dkDrtd<04>
<00>
|
S)N<>not an integerr<00><>znot a uint8<74>r+<00>intr<74>r<>s  r<00>	_as_uint8zRdata._as_uint8
s5<00><00><19>%<25><13>%<25><1C>-<2D>.<2E>.<2E><10>1<EFBFBD>9<EFBFBD><05><03><0B><1C>]<5D>+<2B>+<2B><14>rc<00>f<00>t
|
t<00>std
<01>
<00>
|
dks|
dkDrtd<04>
<00>
|
S)Nr<4E>ri<><69>znot a uint16r<36>r<>s  r<00>
_as_uint16zRdata._as_uint16	s5<00><00><19>%<25><13>%<25><1C>-<2D>.<2E>.<2E><10>1<EFBFBD>9<EFBFBD><05><05>
<0A><1C>^<5E>,<2C>,<2C><14>rc<00>f<00>t
|
t<00>std
<01>
<00>
|
dks|
dkDrtd<04>
<00>
|
S)Nr<4E>rl<00><EFBFBD>znot a uint32r<32>r<>s  r<00>
_as_uint32zRdata._as_uint32s6<00><00><19>%<25><13>%<25><1C>-<2D>.<2E>.<2E><10>1<EFBFBD>9<EFBFBD><05>
<EFBFBD>*<2A><1C>^<5E>,<2C>,<2C><14>rc<00>f<00>t
|
t<00>std
<01>
<00>
|
dks|
dkDrtd<04>
<00>
|
S)Nr<4E>rl<00><EFBFBD><EFBFBD>znot a uint48r<38>r<>s  r<00>
_as_uint48zRdata._as_uint48s6<00><00><19>%<25><13>%<25><1C>-<2D>.<2E>.<2E><10>1<EFBFBD>9<EFBFBD><05><0F>/<2F><1C>^<5E>,<2C>,<2C><14>rc<00><><00>t
|
t<00>std
<01>
<00>
|<02>|
|krtd<02>
<00>
|<03>|
|kDrtd<03>
<00>
|
S)Nr<4E>zvalue too smallzvalue too larger<65>)rJr<><00>low<6F>highs    r<00>_as_intz
Rdata._as_int!sL<00><00><19>%<25><13>%<25><1C>-<2D>.<2E>.<2E><0E>?<3F>u<EFBFBD>s<EFBFBD>{<7B><1C>.<2E>/<2F>/<2F><0F><1B><05><04><0C><1C>.<2E>/<2F>/<2F><14>rc<00>Z
<00>t
|
t<00>rtjj	|
<01>
St
|
t
<00>rtjj
|
<01>
St
|
tj<00>r)tjj
|
j<00>
Std
<01>
<00>
)Nznot an IPv4 address)r+r,r`<00>ipv4rpr<><00>	inet_ntoa<6F>	ipaddress<73>IPv4Address<73>packedr<64>r<>s  r<00>_as_ipv4_addresszRdata._as_ipv4_address+<00>u<00><00><15>e<EFBFBD>S<EFBFBD>!<21><16>8<EFBFBD>8<EFBFBD>(<28>(<28><15>/<2F>/<2F>
<17><05>u<EFBFBD>
%<25><16>8<EFBFBD>8<EFBFBD>%<25>%<25>e<EFBFBD>,<2C>,<2C>
<17><05>y<EFBFBD>4<>4<>
5<><16>8<EFBFBD>8<EFBFBD>%<25>%<25>e<EFBFBD>l<EFBFBD>l<EFBFBD>3<>3<><1C>2<>3<>3rc<00>Z
<00>t
|
t<00>rtjj	|
<01>
St
|
t
<00>rtjj
|
<01>
St
|
tj<00>r)tjj
|
j<00>
Std
<01>
<00>
)Nznot an IPv6 address)r+r,r`<00>ipv6rpr<>r<>r<><00>IPv6Addressr<73>r<>r<>s  r<00>_as_ipv6_addresszRdata._as_ipv6_address6r<>rc<00><<00>t
|
t<00>r|
Std
<01>
<00>
)Nz
not a boolean)r+<00>boolr<6C>r<>s  r<00>_as_boolzRdata._as_boolAs<00><00><15>e<EFBFBD>T<EFBFBD>"<22><18>L<EFBFBD><1C>_<EFBFBD>-<2D>-rc<00><><00>t
|
t<00>r+|j|
d
tjj
<00>St
|
t<00>rtjj|
<01>
Std<02>
<00>
)Nrz	not a TTL)	r+r<>r<>r`<00>ttl<74>MAX_TTLr,r<>r<>r<>s  r<00>_as_ttlz
Rdata._as_ttlHsQ<00><00><15>e<EFBFBD>S<EFBFBD>!<21><16>;<3B>;<3B>u<EFBFBD>a<EFBFBD><13><17><17><1F><1F>9<>9<>
<17><05>s<EFBFBD>
#<23><16>7<EFBFBD>7<EFBFBD>$<24>$<24>U<EFBFBD>+<2B>+<2B><1C>[<5B>)<29>)rc<00>^<00><02>	<00>|
<01>
f
S#t$r
t<00>f
d
<01>|
D<00><00>
cYSwxYw
)Nc
3<00>.<00>
K
<00>|]}
<00>|
<01>
<00>
<01>

<00>y<00>w
rTr)rI<00>
v<>as_values  <20>rrKz"Rdata._as_tuple.<locals>.<genexpr>Zs<00><><00><><00>4<>e<EFBFBD><11><18>!<21><1B>e<EFBFBD>s<00>
)<02>	Exception<6F>tuple)rJr<>r<>s  `r<00>	_as_tuplezRdata._as_tupleQs9<00><><00>	5<><1D>U<EFBFBD>O<EFBFBD>%<25>%<25><><18>	5<><19>4<>e<EFBFBD>4<>4<>4<>	5<>s<00><00>,<03>
,c<00>F<00>t
|
<01>
}tj|<02>

|SrT)<03>list<73>random<6F>shuffle)rJ<00>iterablerYs   r<00>_processing_orderzRdata._processing_order^s<00><00><14>X<EFBFBD><0E><05><0E><0E><0E>u<EFBFBD><1D><14>rr<><00>NNF)NNNFrT<00>NTN)FNT)NN)?r
rrr
rGr`r<>r<>rar<>rDrRrWr^rcr<>rfr<>r<>r<>rr,rrm<00>CompressTypersr<>ryr~r<>r<>r<>r<>r<>r<>r<>r<>r<>r<>r<><00>classmethod<6F>	tokenizer<65>	Tokenizerr<72>r}<00>Parserr<72>r<>rArBr<>r<>r<>r<>r<>r<>r<>r<>r<>r<>r<>r<>r
rrrr;r;<00>sz<00><00>-<2D>2<>I<EFBFBD><1E><14><1E><1E>*<2A>*<2A><1E><14>
<0A>
<0A>'<27>'<27><1E>
<0E>	<1E> 
<EFBFBD>
<15>8<>"<22><03>
<0A>
<0A>/<2F>/<2F>"<22>1<>C<EFBFBD>1<>(,<2C><1F>"<22><13><08><08>
<0A>
<0A><04>$<24>"<22><19>"<22><13>3<EFBFBD><03>8<EFBFBD>n<EFBFBD>	"<22>


<0A>"<22> 26<32>'+<2B>"<22>"<22><11>"<22><16>(<28>(<28>'<27>'<27>$<24>.<2E>"<22><14><08><08>
<0A>
<0A><04>$<24>	"<22>
<1B>"<22>
<0E>
"<22> <20>15<31>'+<2B>"<22> <20><11>D<EFBFBD>j<EFBFBD> <20><16>(<28>(<28>'<27>'<27>$<24>.<2E> <20><14><08><08>
<0A>
<0A><04>$<24>	 <20>
<1B> <20>
<0F><14><1C>
 <20>0=<3D><13><18><18><1D><1D><14>!5<>=<3D><1E>=<3D><14>C<EFBFBD>H<EFBFBD>H<EFBFBD>M<EFBFBD>M<EFBFBD>D<EFBFBD>$8<><14>E<EFBFBD><14>
<EFBFBD>"
<1E>0<16>d
<1C>*&<26>$<24>%<25>%<25>$<24>
7<><11>(,<2C><1F>.2<EFBFBD>	"<22><14><1E><1E>*<2A>*<2A>	"<22><14>
<0A>
<0A>'<27>'<27>	"<22><11>]<5D>]<5D>
$<24>
$<24>		"<22>
<14><08><08>
<0A>
<0A><04>$<24>	"<22><19>
	"<22><1B>x<EFBFBD>x<EFBFBD>}<7D>}<7D>t<EFBFBD>+<2B>	"<22>
<11>	"<22><11>	"<22><11>(,<2C>"<22><14><1E><1E>*<2A>*<2A>"<22><14>
<0A>
<0A>'<27>'<27>"<22><14><08><08><0F><0F>	"<22>
<14><08><08>
<0A>
<0A><04>$<24>"<22>
<11>
"<22><11>"<22>(<12><03>(<12><07>(<12>Z
<11>
5<><11>
5<><11>
3<><11>
3<><11><1D>!%<25><1D><16><12><16><15><16><18>$<24>J<EFBFBD>	<16>
<17><16>
<0F>
<16><11><16>*<11><15><11><15><11><15><11><15><11><15><11><15><11><15><11><15><11><15><11><15><11><15><11><15><11>4<><11>4<><11>4<><11>4<><11>.<2E><11>.<2E><11>*<2A><11>*<2A><11>5<><11>5<><11><15><11>rr;c	<00>N
<00><00>eZ
dZd
Zdg
Zdejjdejjde
ddf<08>f
d<07>Z		ddejjdzd	ed
eeefdefd<0B>Ze	dd<0C>
<01>Zdd
<0A>
Zddejjdzddfd<0E>Zedd<0F>
<01>Z<17>x
ZS)rzz<>Generic Rdata Class

    This class is used for rdata types for which we have no better
    implementation.  It implements the DNS "unknown RRs" scheme.
    rr<r=r?Nc<00>4<00>
<01>t<00>|<00>|
|<02>
||_yrT)<03>superrDr)rCr<r=rrOs    <20>rrDzGenericRdata.__init__os<00><><00>	<0E><07><18><17>&<26>)<29><18><04>	rrgrhr c<00>b<00>d
t
|j<00>
<00>d<02>t|jf
i|<03>
<01>
zS)Nz\# r<>)rrr!rls    rrmzGenericRdata.to_textxs/<00><00><16>c<EFBFBD>$<24>)<29>)<29>n<EFBFBD>%<25>Q<EFBFBD>'<27>'<27>$<24>)<29>)<29>*B<>r<EFBFBD>*B<>B<>Brc<00><>
<00>|j
<00>}|j<00>r|jd
k7rtjjd<02>
<00>
|j
<00>}|jd<03>
j<00>}	tj|	<09>
}
t|
<EFBFBD>
|k7rtjjd<04>
<00>
||
||
<EFBFBD>S)N<>\#z$generic rdata does not start with \#Tz'generic rdata hex data has wrong length)r<><00>
is_identifierr<72>r`<00>	exception<6F>SyntaxError<6F>get_int<6E>!concatenate_remaining_identifiersr-r<00>	unhexlifyr)rJr<r=r<>rgrhr<><00>token<65>length<74>hexrs           rr<>zGenericRdata.from_text<78>s<><00><00><14><07><07>	<09><05><14>"<22>"<22>$<24><05><0B><0B>u<EFBFBD>(<<3C><15>-<2D>-<2D>+<2B>+<2B>,S<>T<>T<><14><1B><1B><1D><06><11>3<>3<>D<EFBFBD>9<>@<40>@<40>B<><03><17>!<21>!<21>#<23>&<26><04><0E>t<EFBFBD>9<EFBFBD><06><1E><15>-<2D>-<2D>+<2B>+<2B>,U<>V<>V<><12>7<EFBFBD>F<EFBFBD>D<EFBFBD>)<29>)rc<00>:<00>|
j
|j<00>

yrT)<02>writerrrs     rrszGenericRdata._to_wire<72>s<00><00><0C>
<EFBFBD>
<EFBFBD>4<EFBFBD>9<EFBFBD>9<EFBFBD>rc
<00><00>|SrTr)rCrgs  rr~zGenericRdata.to_generic<69>s<00><00><13>rc<00>2<00>||
||j
<00><00>SrT)
<01>
get_remainingr<67>s     rr<>zGenericRdata.from_wire_parser<65>s<00><00><12>7<EFBFBD>F<EFBFBD>F<EFBFBD>$8<>$8<>$:<3A>;<3B>;rr<>r
r
rT)r
rrr
rGr`r<>r<>rar<>r<>rDr<>r<>r<>rr,rrmr
r<>rsr~r<><00>
__classcell__)
rOs
@rrzrzes<><00><><00><08><18><08>I<EFBFBD><19><14><1E><1E>*<2A>*<2A><19><14>
<0A>
<0A>'<27>'<27><19><14>	<19>

<0E><19>(,<2C><1F>C
<01><13><08><08>
<0A>
<0A><04>$<24>C
<01><19>C
<01><13>3<EFBFBD><03>8<EFBFBD>n<EFBFBD>	C
<01>


<0A>C
<01><11>OS<4F>*<2A><11>*<2A>
<1E>
<14><13><18><18><1D><1D><14>!5<>
<14><1E>
<14><11>
<<3C><11>
<rrz<00>_rdata_classeszdns.rdtypesc<00><><00>tj||
f<02>
}|s<>tjtjj|
f<02>
}|s<>t
r<>tjj
|<00>
}tjj
|
<01>
}|jd
d<02>}	tdjt||g<03>
<00>
}t||<05>}|t||
f<|s|rt}|t||
f<|S#t$ro
	tdjtd|g<03>
<00>
}t||<05>}|ttjj|
f<|t||
f<n#t$r
YnwxYw
Y<00><>wxYw
)N<>
-<2D>
_<>
.<2E>ANY)r
r<>r`r<>r$
<00>_dynamic_load_allowedrmrar<>rr<00>_module_prefixrH<00>ImportErrorrz)r<r=<00>use_genericrJ<00>rdclass_text<78>rdtype_text<78>mods       r<00>get_rdata_classr,
<00>sN
<00><00>
<18>
<1C>
<1C>g<EFBFBD>v<EFBFBD>.<2E>
/<2F>C<EFBFBD><0E><1C> <20> <20>#<23>.<2E>.<2E>"4<>"4<>f<EFBFBD>!=<3D>><3E><03><12>,<2C><1E>><3E>><3E>1<>1<>'<27>:<3A>L<EFBFBD><1D>-<2D>-<2D>/<2F>/<2F><06>7<>K<EFBFBD>%<25>-<2D>-<2D>c<EFBFBD>3<EFBFBD>7<>K<EFBFBD>

<19>#<23><17>H<EFBFBD>H<EFBFBD>n<EFBFBD>l<EFBFBD>K<EFBFBD>H<>I<><12><03><1E>c<EFBFBD>;<3B>/<2F><03>47<34><0E><07><16>0<>1<><0F>;<3B><1A><03>,/<2F><0E><07><16>(<28>)<29><0E>J<EFBFBD><4A><1F>
<19><19>'<27><03><08><08>.<2E>%<25><1B>1U<31>(V<>W<>C<EFBFBD>!<21>#<23>{<7B>3<>C<EFBFBD>CF<43>N<EFBFBD>C<EFBFBD>N<EFBFBD>N<EFBFBD>$6<>$6<><06>#?<3F>@<40>8;<3B>N<EFBFBD>G<EFBFBD>V<EFBFBD>#4<>5<><35>"<22>
<19><18>
<19><>

<19>s7<00>"8C1<00>1	E)<03>;AE<02>
E)<03>	E#<05> E)<03>"
E#<05>#E)<03>(
E)c
<00>
<00>tjjD]'}
ttjj
|
d
<01>
<00>)ttjjtjjd
<01>
|rd
ayy)a<>
Load all rdata types for which dnspython has a non-generic implementation.

    Normally dnspython loads DNS rdatatype implementations on demand, but in some
    specialized cases loading all types at an application-controlled time is preferred.

    If *disable_dynamic_load*, a ``bool``, is ``True`` then dnspython will not attempt
    to use its dynamic loading mechanism if an unknown type is subsequently encountered,
    and will simply use the ``GenericRdata`` class.
    FN)	r`rar<>r,
r<><00>IN<49>CH<43>
Ar%
)<02>disable_dynamic_loadr=s  r<00>load_all_typesr2
<00>s^<00><00><16>-<2D>-<2D>)<29>)<29><06><17><03><0E><0E>)<29>)<29>6<EFBFBD>5<EFBFBD>9<>*<2A>
<14>C<EFBFBD>N<EFBFBD>N<EFBFBD>%<25>%<25>s<EFBFBD>}<7D>}<7D><EFBFBD><EFBFBD><05>><3E><1B>!&<26><1D>	rr<r=r<>rgrhr<><00>
idna_codecr?c
<00>n<00>t
|t<00>r!tjj	||<06>
<01>}t
|tjj<00>std<02>
<00>
tjjj|<00>
}tjjj|
<01>
}
t||
<01>}|<07>J<00>
tjjtjj<00>
5
d}|tk7r<>|j!<00>}	|j#|	<09>

|	j%<00>r<>|	j&dk(r<>tj)||
||||<05>}
t+||
|
j,dt/|
j,<00>
|<03>}|j1<00>}||
j,k7rtjjd<06>
<00>
|<08>|j)||
||||<05>}|j3<00>}	|	j4<00>!t6j9|d|	j4<00>
|cddd<03>
S#1s
w
Y

yxYw
)a3Build an rdata object from text format.

    This function attempts to dynamically load a class which
    implements the specified rdata class and type.  If there is no
    class-and-type-specific implementation, the GenericRdata class
    is used.

    Once a class is chosen, its from_text() class method is called
    with the parameters to this function.

    If *tok* is a ``str``, then a tokenizer is created and the string
    is used as its input.

    *rdclass*, a ``dns.rdataclass.RdataClass`` or ``str``, the rdataclass.

    *rdtype*, a ``dns.rdatatype.RdataType`` or ``str``, the rdatatype.

    *tok*, a ``dns.tokenizer.Tokenizer`` or a ``str``.

    *origin*, a ``dns.name.Name`` (or ``None``), the
    origin to use for relative names.

    *relativize*, a ``bool``.  If true, name will be relativized.

    *relativize_to*, a ``dns.name.Name`` (or ``None``), the origin to use
    when relativizing names.  If not set, the *origin* value will be used.

    *idna_codec*, a ``dns.name.IDNACodec``, specifies the IDNA
    encoder/decoder to use if a tokenizer needs to be created.  If
    ``None``, the default IDNA 2003 encoder/decoder is used.  If a
    tokenizer is not created, then the codec associated with the tokenizer
    is the one that is used.

    Returns an instance of the chosen Rdata subclass.

    )
r3
z#tok must be a string or a TokenizerNr
rz9compressed data in generic syntax form of known rdatatyper>)r+r,r`r
r
r<>r<>r<>r<>rar<>r,
r
<00>ExceptionWrapperr
rzr<><00>ungetr
r<>r<><00>	from_wirerrry<00>get_eol_as_token<65>commentrZr[)r<r=r<>rgrhr<>r3
rJ<00>rdatar
<00>grdata<74>rwires            rr<>r<><00>s<>
<00><00>Z
<12>#<23>s<EFBFBD><1B><11>m<EFBFBD>m<EFBFBD>%<25>%<25>c<EFBFBD>j<EFBFBD>%<25>A<><03><15>c<EFBFBD>3<EFBFBD>=<3D>=<3D>2<>2<>3<><18>><3E>?<3F>?<3F><11>n<EFBFBD>n<EFBFBD>'<27>'<27>,<2C>,<2C>W<EFBFBD>5<>G<EFBFBD>
<10>]<5D>]<5D>
$<24>
$<24>
)<29>
)<29>&<26>
1<>F<EFBFBD>
<19>'<27>6<EFBFBD>
*<2A>C<EFBFBD><0E>?<3F><1A>?<3F>	<0C><1D><1D>	'<27>	'<27><03>
<0A>
<0A>(A<>(A<>	B<><14><05><0E>,<2C><1E><17>G<EFBFBD>G<EFBFBD>I<EFBFBD>E<EFBFBD><0F>I<EFBFBD>I<EFBFBD>e<EFBFBD><1C><14>"<22>"<22>$<24><15><1B><1B><05>)=<3D>&<26>/<2F>/<2F><1B>V<EFBFBD>S<EFBFBD>&<26>*<2A>m<EFBFBD><12><06>"<22><1B>V<EFBFBD>V<EFBFBD>[<5B>[<5B>!<21>S<EFBFBD><16><1B><1B>5E<35>v<EFBFBD><12><05><1E>
<0A>
<0A><0F><05><18>F<EFBFBD>K<EFBFBD>K<EFBFBD>'<27><1D>-<2D>-<2D>3<>3<>-<2D><16><16>
<11>=<3D><17>M<EFBFBD>M<EFBFBD><17><16><13>f<EFBFBD>j<EFBFBD>-<2D><0E>E<EFBFBD><14>$<24>$<24>&<26><05><10>=<3D>=<3D>$<24><12><1E><1E>u<EFBFBD>k<EFBFBD>5<EFBFBD>=<3D>=<3D>A<><14>K

C
<01>	B<>	B<>s
<00>:D'H+<03>+H4r<>c<00><>
<00>tjjj|<00>
}tjj
j|
<01>
}
t
||
<01>}|<04>J<00>
tjjtjj<00>
5
|j||
||<03>cd
d
d
<01>
S#1s
w
Y

y
xYw
)aBuild an rdata object from wire format

    This function attempts to dynamically load a class which
    implements the specified rdata class and type.  If there is no
    class-and-type-specific implementation, the GenericRdata class
    is used.

    Once a class is chosen, its from_wire() class method is called
    with the parameters to this function.

    *rdclass*, a ``dns.rdataclass.RdataClass`` or ``str``, the rdataclass.

    *rdtype*, a ``dns.rdatatype.RdataType`` or ``str``, the rdatatype.

    *parser*, a ``dns.wire.Parser``, the parser, which should be
    restricted to the rdata length.

    *origin*, a ``dns.name.Name`` (or ``None``).  If not ``None``,
    then names will be relativized to this origin.

    Returns an instance of the chosen Rdata subclass.
    N)r`r<>r<>r<>rar<>r,
r
r5
<00>	FormErrorr<72>)r<r=r<>rgrJs     rr<>r<>1s<><00><00>:<12>n<EFBFBD>n<EFBFBD>'<27>'<27>,<2C>,<2C>W<EFBFBD>5<>G<EFBFBD>
<10>]<5D>]<5D>
$<24>
$<24>
)<29>
)<29>&<26>
1<>F<EFBFBD>
<19>'<27>6<EFBFBD>
*<2A>C<EFBFBD><0E>?<3F><1A>?<3F>	<0C><1D><1D>	'<27>	'<27><03>
<0A>
<0A>(?<3F>(?<3F>	@<40><12>#<23>#<23>G<EFBFBD>V<EFBFBD>V<EFBFBD>V<EFBFBD>D<>
A
<01>	@<40>	@<40>s<00>B8<03>8C
r}<00>current<6E>rdlenc<00><><00>tjj||<03>}|j|<04>
5
t	||
||<05>cd
d
d
<01>
S#1s
w
Y

y
xYw
)a1Build an rdata object from wire format

    This function attempts to dynamically load a class which
    implements the specified rdata class and type.  If there is no
    class-and-type-specific implementation, the GenericRdata class
    is used.

    Once a class is chosen, its from_wire() class method is called
    with the parameters to this function.

    *rdclass*, an ``int``, the rdataclass.

    *rdtype*, an ``int``, the rdatatype.

    *wire*, a ``bytes``, the wire-format message.

    *current*, an ``int``, the offset in wire of the beginning of
    the rdata.

    *rdlen*, an ``int``, the length of the wire-format rdata

    *origin*, a ``dns.name.Name`` (or ``None``).  If not ``None``,
    then names will be relativized to this origin.

    Returns an instance of the chosen Rdata subclass.
    N)r`r}r	
<00>restrict_tor<6F>)r<r=r}r?
r@
rgr<>s       rr7
r7
VsA<00><00>D
<11>X<EFBFBD>X<EFBFBD>_<EFBFBD>_<EFBFBD>T<EFBFBD>7<EFBFBD>
+<2B>F<EFBFBD>	<0F>	<1B>	<1B>E<EFBFBD>	"<22><1F><07><16><16><16>@<40>
#<23>	"<22>	"<22>s<00>A
<03>
Ac<00><00>eZ
dZd
ZddhZdZy)<06>RdatatypeExistszDNS rdatatype already exists.r<r=zKThe rdata type with class {rdclass:d} and rdtype {rdtype:d} already exists.N)r
rrr
<00>supp_kwargs<67>fmtrrrrD
rD
}s<00><00>'<27><1C>h<EFBFBD>'<27>K<EFBFBD>
	<1C>rrD
F<>implementationr*
<00>is_singletonc<00><>
<00>tjjj|
<01>
}
t	||
<01>}|t
k7stjj
|
<01>
r
t||
<01>
<01><00>
t|t<00>rt|t<00>r|}nt||jdd<03><00>}|t||
f<tjj|
||<03>
y)a)Dynamically register a module to handle an rdatatype.

    *implementation*, a subclass of ``dns.rdata.Rdata`` implementing the type,
    or a module containing such a class named by its text form.

    *rdtype*, an ``int``, the rdatatype to register.

    *rdtype_text*, a ``str``, the textual form of the rdatatype.

    *is_singleton*, a ``bool``, indicating if the type is a singleton (i.e.
    RRsets of the type can have only one member.)

    *rdclass*, the rdataclass of the type, or ``dns.rdataclass.ANY`` if
    it applies to all classes.
    r<>r!
r"
N)r`rar<>r<>r,
rz<00>is_metatyperD
r+<00>type<70>
issubclassr;rHr<>r
<00>
register_type)rG
r=r*
rH
r<<00>existing_cls<6C>impclasss       rrM
rM
<00>s<><00><00>.<11>]<5D>]<5D>
$<24>
$<24>
)<29>
)<29>&<26>
1<>F<EFBFBD>"<22>7<EFBFBD>F<EFBFBD>3<>L<EFBFBD><13>|<7C>#<23>s<EFBFBD>}<7D>}<7D>'@<40>'@<40><16>'H<><1D>g<EFBFBD>f<EFBFBD>=<3D>=<3D><11>.<2E>$<24>'<27>J<EFBFBD>~<7E>u<EFBFBD>,M<>!<21><08><1A>><3E>;<3B>+><3E>+><3E>s<EFBFBD>C<EFBFBD>+H<>I<><08>(0<>N<EFBFBD>G<EFBFBD>V<EFBFBD>$<24>%<25><07>M<EFBFBD>M<EFBFBD><1F><1F><06><0B>\<5C>Br)
T)NTNNrT)Dr
r#rr<>rur<>rLr<><00>	importlibr<00>typingrrr<00>
dns.exceptionr`<00>
dns.immutable<6C>dns.ipv4<76>dns.ipv6<76>dns.name<6D>dns.rdataclass<73>
dns.rdatatype<70>
dns.tokenizer<65>dns.ttl<74>dns.wire<72>
_chunksizer<EFBFBD>r
<00>DNSExceptionr	rr!r%r/r4r9<00>	immutable<6C>constify<66>	_constifyr;rzr
r<>r<>rar<><00>__annotations__r&
r%
r,
r2
r,r
r
r<>r<>r<><00>	IDNACodecr<63>r}r	
r<>r<>r<>r7
rD
r.
rM
rrr<00><module>rc

sv<00>


<01>$
<11>
<0A><0F><0E>	<09><10><10>
<0A>#<23>#<23>#<23><14><14><0F><0F><0F><15><14><14><0E><0F>
<0F>
<EFBFBD>#<23><1B>
<08>c<EFBFBD>m<EFBFBD>m<EFBFBD>8<>8<>
<08> *<2A>T<EFBFBD>	
<0F>'<27>$<24>
D
<01> *<2A>T<EFBFBD>
D
<01>
<13>	<09>
<10>&
<15>
<10>M<EFBFBD>M<EFBFBD>"<22>"<22>	<09><05><1D><1D>
<18>
<18>_
<15>_
<15><19>_
<15>D<05><1D><1D>
<18>
<18>0
<<3C>5<EFBFBD>0
<<3C><19>0
<<3C>h
<07>
<0F><04>U<EFBFBD>3<EFBFBD>><3E>><3E>4<>4<>c<EFBFBD>m<EFBFBD>m<EFBFBD>6M<36>6M<36>M<>N<>PS<50>S<>T<>
<02><1F><0E><1C><15>
<0F>8
&<26>8$(<28><1B>*.<2E>,0<>Z

<15>
<10>^<5E>^<5E>
&<26>
&<26><13>
,<2C>Z

<15><0F>M<EFBFBD>M<EFBFBD>#<23>#<23>c<EFBFBD>)<29>Z

<15>

<0A><1D><1D>	 <20>	 <20>3<EFBFBD>	&<26>Z

<15>
<10>H<EFBFBD>H<EFBFBD>M<EFBFBD>M<EFBFBD>D<EFBFBD> <20>	Z

<15>
<15>Z

<15><17>8<EFBFBD>8<EFBFBD>=<3D>=<3D>4<EFBFBD>'<27>
Z

<15><14><08><08>"<22>"<22>T<EFBFBD>)<29>Z

<15><0B>Z

<15>B$(<28>	"
E
<01>
<10>^<5E>^<5E>
&<26>
&<26><13>
,<2C>"
E
<01><0F>M<EFBFBD>M<EFBFBD>#<23>#<23>c<EFBFBD>)<29>"
E
<01>
<10>H<EFBFBD>H<EFBFBD>O<EFBFBD>O<EFBFBD>"
E
<01>
<10>H<EFBFBD>H<EFBFBD>M<EFBFBD>M<EFBFBD>D<EFBFBD> <20>	"
E
<01>
<0B>"
E
<01>V
$(<28>
$
A
<01>
<10>^<5E>^<5E>
&<26>
&<26><13>
,<2C>$
A
<01><0F>M<EFBFBD>M<EFBFBD>#<23>#<23>c<EFBFBD>)<29>$
A
<01><10>$
A
<01><11>	$
A
<01>
<0F>$
A
<01>
<10>H<EFBFBD>H<EFBFBD>M<EFBFBD>M<EFBFBD>D<EFBFBD> <20>
$
A
<01><0B>$
A
<01>N

<06>c<EFBFBD>m<EFBFBD>m<EFBFBD>0<>0<>
<06><1F>),<2C><1E><1E>):<3A>):<3A> 
C
<01><17> 
C
<01><0F> 
C
<01><15> 
C
<01><17>	 
C
<01>
<11>^<5E>^<5E>
&<26>
&<26> 
C
<01>
<EFBFBD>
 
C
r