ServerSync/lib/nacl/bindings/__pycache__/utils.cpython-314.pyc

+
u<10>i<EFBFBD><00><00>j<00>^R
IH
t^RIHtHt^RIHtRRltRRltRR	lt	R
Rlt
RR
ltR
#)<0E>N)<02>ffi<66>lib)
<01>ensurec

<00><<00>V^8<>dQ
h
R
\R\R\/#)<04><00>inp1<70>inp2<70>return)<02>bytes<65>bool)
<01>formats
"<22>:/tmp/pip-target-zhdecbcm/lib/python/nacl/bindings/utils.py<70>__annotate__rs!<00><00>
<17>
<17><05>
<17>U<EFBFBD>
<17>t<EFBFBD>
<17>c<04>8<00>\
\V\4\PR
7\
\V
\4\PR
7\\
V4
\
V
4
4p\P!RV4p\P!RV4p\P!W0\
V4
4\P!WA\
V
4
4\
V4
\
V
4
8Hp\P!W4V4^8HpT;
'dT#)z9
Compare contents of two memory regions in constant time
<EFBFBD>
<01>raisingzchar [])r<00>
isinstancer<00>exc<78>	TypeError<6F>max<61>lenr<00>new<65>memmover<00>
sodium_memcmp)rr	<00>ln<6C>buf1<66>buf2<66>eqL<71>eqCs&&     rrrs<><00><00><0B>:<3A>d<EFBFBD>E<EFBFBD>"<22>C<EFBFBD>M<EFBFBD>M<EFBFBD>:<3A>
<EFBFBD>:<3A>d<EFBFBD>E<EFBFBD>"<22>C<EFBFBD>M<EFBFBD>M<EFBFBD>:<3A>	<0C>S<EFBFBD><14>Y<EFBFBD><03>D<EFBFBD>	<09>	"<22>B<EFBFBD><0E>7<EFBFBD>7<EFBFBD>9<EFBFBD>b<EFBFBD>!<21>D<EFBFBD><0E>7<EFBFBD>7<EFBFBD>9<EFBFBD>b<EFBFBD>!<21>D<EFBFBD><07>K<EFBFBD>K<EFBFBD><04>C<EFBFBD><04>I<EFBFBD>&<26><07>K<EFBFBD>K<EFBFBD><04>C<EFBFBD><04>I<EFBFBD>&<26>

<0A>d<EFBFBD>)<29>s<EFBFBD>4<EFBFBD>y<EFBFBD>
 <20>C<EFBFBD>

<0A>
<1B>
<1B>D<EFBFBD><02>
+<2B>q<EFBFBD>
0<EFBFBD>C<EFBFBD><0E>;<3B>;<3B>3<EFBFBD>rc

<00><<00>V^8<>dQ
h
R
\R\R\/#<00>r<00>
s<>	blocksizer
<00>r<00>int)
r
s
"rrr)s!<00><00>
(<28>
(<28>%<25>
(<28>C<EFBFBD>
(<28>E<EFBFBD>
(rc<04>:<00>\
\V\4\PR
7\
\V
\
4\PR
7V
^8:d\Ph
\V4
pW!,p\P!RV4p\P!R^
4p\P!W@V4\P!WTW!V4p\
V^8HR\PR
7\P!WE^,4R,#)z<>
Pad the input bytearray ``s`` to a multiple of ``blocksize``
using the ISO/IEC 7816-4 algorithm

:param s: input bytes string
:type s: bytes
:param blocksize:
:type blocksize: int
:return: padded string
:rtype: bytes
r<00>unsigned char []<5D>	size_t []zPadding failure<72>NNN)rrrrrr&<00>
ValueErrorrrrrr<00>
sodium_pad<EFBFBD>CryptoError<6F>buffer)r#r$<00>s_len<65>m_len<65>buf<75>p_len<65>rcs&&     rr,r,)s<><00><00><0B>:<3A>a<EFBFBD><15><1F><13><1D><1D>7<>
<EFBFBD>:<3A>i<EFBFBD><13>%<25>s<EFBFBD>}<7D>}<7D>=<3D><10>A<EFBFBD>~<7E><11>n<EFBFBD>n<EFBFBD><1C><0F>
<01>F<EFBFBD>E<EFBFBD><11><1D>E<EFBFBD>

<0A>'<27>'<27>$<24>e<EFBFBD>
,<2C>C<EFBFBD><0F>G<EFBFBD>G<EFBFBD>K<EFBFBD><11>#<23>E<EFBFBD><07>K<EFBFBD>K<EFBFBD><03><05><1E>	<0C><1E><1E><05>E<EFBFBD>e<EFBFBD>	<<3C>B<EFBFBD>
<EFBFBD>2<EFBFBD><11>7<EFBFBD>%<25>s<EFBFBD><EFBFBD><EFBFBD>?<3F><0E>:<3A>:<3A>c<EFBFBD><11>8<EFBFBD>$<24>Q<EFBFBD>'<27>'rc

<00><<00>V^8<>dQ
h
R
\R\R\/#r"r%)
r
s
"rrrCs!<00><00>
<19>
<19>E<EFBFBD>
<19>c<EFBFBD>
<19>e<EFBFBD>
rc<04>j
<00>\
\V\4\PR
7\
\V
\
4\PR
7\
V4
p\P!R^
4p\P!W0W!4pV^8wd\P!R4
h
VRV^,
#)z<>
Remove ISO/IEC 7816-4 padding from the input byte array ``s``

:param s: input bytes string
:type s: bytes
:param blocksize:
:type blocksize: int
:return: unpadded string
:rtype: bytes
rr)zUnpadding failureN)rrrrrr&rrrr<00>sodium_unpadr-)r#r$r/<00>u_lenr3s&&   rr6r6Cs<><00><00><0B>:<3A>a<EFBFBD><15><1F><13><1D><1D>7<>
<EFBFBD>:<3A>i<EFBFBD><13>%<25>s<EFBFBD>}<7D>}<7D>=<3D><0F>
<01>F<EFBFBD>E<EFBFBD><0F>G<EFBFBD>G<EFBFBD>K<EFBFBD><11>#<23>E<EFBFBD>	<0C>	<19>	<19>%<25>E<EFBFBD>	5<>B<EFBFBD>	<09>Q<EFBFBD>w<EFBFBD><11>o<EFBFBD>o<EFBFBD>1<>2<>2<><0C>Z<EFBFBD>u<EFBFBD>Q<EFBFBD>x<EFBFBD>=<3D>rc

<00>0<00>V^8<>dQ
h
R
\R\/#)r<00>inpr
<00>
r)
r
s
"rrrXs<00><00>
"<22>
"<22>%<25>
"<22>E<EFBFBD>
"rc
<04>,
<00>\
\V\4\PR
7\V4
p
\P!RV
4p\P!W V
4\P!W!4\P!W!4R,#)aC

Increment the value of a byte-sequence interpreted
as the little-endian representation of a unsigned big integer.

:param inp: input bytes buffer
:type inp: bytes
:return: a byte-sequence representing, as a little-endian
         unsigned big integer, the value ``to_int(inp)``
         incremented by one.
:rtype: bytes

rr(r*)rrrrrrrrrr<00>sodium_incrementr.)r9rr1s&  rr<r<Xsc<00><00><0B>:<3A>c<EFBFBD>5<EFBFBD>!<21>3<EFBFBD>=<3D>=<3D>9<>	<0C>S<EFBFBD><18>B<EFBFBD>

<0A>'<27>'<27>$<24>b<EFBFBD>
)<29>C<EFBFBD><07>K<EFBFBD>K<EFBFBD><03>"<22><1D><07><18><18><13>!<21><0E>:<3A>:<3A>c<EFBFBD><1E>q<EFBFBD>!<21>!rc

<00><<00>V^8<>dQ
h
R
\R\R\/#)r<00>
a<>
br
r:)
r
s
"rrrqs!<00><00>
$<24>
$<24>%<25>
$<24>E<EFBFBD>
$<24>e<EFBFBD>
$rc<04>*<00>\
\V\4\PR
7\
\V
\4\PR
7\V4
p\
\V
4
V8H\PR
7\P!RV4p\P!RV4p\P!W0V4\P!WAV4\P!W4V4\P!W24R,#)a<>

Given a couple of *same-sized* byte sequences, interpreted as the
little-endian representation of two unsigned integers, compute
the modular addition of the represented values, in constant time for
a given common length of the byte sequences.

:param a: input bytes buffer
:type a: bytes
:param b: input bytes buffer
:type b: bytes
:return: a byte-sequence representing, as a little-endian big integer,
         the integer value of ``(to_int(a) + to_int(b)) mod 2^(8*len(a))``
:rtype: bytes
rr(r*)rrrrrrrrrr<00>
sodium_addr.)r>r?r<00>buf_a<5F>buf_bs&&   rrArAqs<><00><00><0B>:<3A>a<EFBFBD><15><1F><13><1D><1D>7<>
<EFBFBD>:<3A>a<EFBFBD><15><1F><13><1D><1D>7<>	<0C>Q<EFBFBD><16>B<EFBFBD>
<EFBFBD>3<EFBFBD>q<EFBFBD>6<EFBFBD>R<EFBFBD><<3C><13><1D><1D>/<2F><0F>G<EFBFBD>G<EFBFBD>&<26><02>+<2B>E<EFBFBD><0F>G<EFBFBD>G<EFBFBD>&<26><02>+<2B>E<EFBFBD><07>K<EFBFBD>K<EFBFBD><05>"<22><1D><07>K<EFBFBD>K<EFBFBD><05>"<22><1D><07>N<EFBFBD>N<EFBFBD>5<EFBFBD><12>$<24><0E>:<3A>:<3A>e<EFBFBD> <20><11>#<23>#r)<0C>nacl.exceptions<6E>
exceptionsr<00>nacl._sodiumrrrrr,r6r<rA<00>rr<00><module>rH
s)<00>


<01>
<1E>!<21>"<22>
<17>*
(<28>4
<19>*
"<22>2
$r