📄 libzune_core-ddf93750e5157d82.rmeta
/home/palash/git/iron_learn/target/debug/deps/libzune_core-ddf93750e5157d82.rmeta
Language: rmeta • Lines: 4582
rust
�#rustc 1.92.0 (ded5c06cf 2025-12-08)���	ⷄ�ۆ��p��-225863f279df55c4��١�	�T�6a��D�
-5080178c80bf7a93��uӰ]����d��!�-06039bcfba61f665��**�٭T��HО�9�-3e2e950d4bac10b5��	�t�#3Ҵη��Ǣ-d25e598578fbf080�rustc_std_workspace_core������Nm��gmY���-327ea4f353b4eb8c���y.:i���gy"1�r-94fdfaf0af91a65d�miniz_oxide�M�^�yTLm�L�d=B-5312b588e5cfab93�adler2��;~�7�ɴ,P?���-1e0b0d62df36c85c�	hashbrown�L�ϫ	2݆y��q-2ed6a8f06fc51a9d�rustc_std_workspace_alloc�a���p��H����6Z�-05b02707a5b2a256�
std_detect�	c�LN����=1�ʶӐ-5978f0713dd5442d�rustc_demangle�X�Fq��UՃ�>7z
��-43b2ff22c18e1125�cfg_if�֦<����ɐ¬�-6a40188dd7d989d2�	addr2line���,2�!xb�"6�!�	-11d54e777384a9e5�gimli��2��I.�ġ�����-35018e994bad7042�object��T �f��Y�
hQec-2dc10b344e05b569�memchr��xZT9�C��I�Mg�-09f2ab7e0d97e07a��~ݤ	����h���-932f22f820d1e5ec�log��
�<�
�,�
|�
�
no_std_writer�l��<��,�|���serde�,��<��<�������
__log_enabled�__error�__warn�__info�__debug�__trace�	bit_depth�to_depth�>bit_type��bit_size�
bytestream�reader�"""""no_std_readers�'''''ZCursor�,�,stream�,�'0�0�
'3�3�3rewind�'7�7read_byte_no_error�7read_exact_bytes�7read_const_bytes�;�;7read_const_bytes_no_error�>�>7
read_bytes�7
peek_bytes�7peek_exact_bytes�7z_seek�7is_eof�7
z_position�7read_remaining�'H�Hseek�'K�K�"std_readers�NNNNNNNU�U�U�U�Y�YU�\�\U�U�
U�
U�
U�
c	U�
U�
""hto_std_seek�"ZByteIoError�j
StdIoError�k
k�jTryFromIntError�n
n�jNotEnoughBytes�q
q�q�jNotEnoughBuffer�u
u�u�jGeneric�y
y�j	SeekError�|
|�jSeekErrorOwned�
�"��"��"��"��"ZReader����inner��temp_buffer�"����
�consume�������
�read_u8��read_u8_err��peek_at��read_fixed_bytes_or_error�������read_fixed_bytes_or_zero�������set_position��eof�������"Mode��BE��
�LE��
"get_single_type�"���read���	traits�����ZByteReaderTrait�������������������
��
��
��
��
��
�ZByteWriterTrait����write_all_bytes��write_const_bytes�����flush_bytes��reserve_capacity�writer�����
std_writer������������������������
���
�ZWriter����buffer��
bytes_written�����write��	write_all���
�write_u8_err�������write_u8����reserve����	inner_ref��	inner_mut��write_single_type�
colorspace���num_components��	has_alpha��is_grayscale��alpha_position��ALL_COLORSPACES������decoder����decoder_error_tolerance_mode��fast_options��cmd_options���new_safe��new_fast��new_cmd���	max_width��
max_height��strict_mode��
use_unsafe��
set_max_width��set_max_height��set_use_unsafe��set_decoder_flags��set_strict_mode��set_byte_endian��byte_endian���inflate_get_confirm_adler��inflate_set_confirm_adler��inflate_get_limit��inflate_set_limit��png_get_confirm_crc��png_set_confirm_crc��png_set_add_alpha_channel��png_get_add_alpha_channel��png_set_strip_to_8bit��png_get_strip_to_8bit��png_decode_animated��png_set_decode_animated���jpeg_get_max_scans��jpeg_set_max_scans��jpeg_get_out_colorspace��jpeg_set_out_colorspace���use_sse2��use_sse3��	use_sse41��use_avx��use_avx2��use_neon���jxl_decode_animated��jxl_set_decode_animated���>�encoder�����>���
���height��depth��quality����effort��	set_width��
set_height��	set_depth��set_quality��set_colorspace��set_num_threads��
set_effort��num_threads��set_strip_metadata��strip_metadata���jpeg_encode_progressive��jpeg_optimized_huffman_tables��set_jpeg_encode_progressive��
��DecodingResult��U8��
���U16��
���F32��
�������Level����
��Warn��
�Info��
���
�Trace��
������������BitDepth��Eight��
�Sixteen��
�Float32��
���
��������BitType���'�
��'�
��(�
	
������
��	max_value�
ByteEndian����
���
��������"	ZSeekFrom��Start��
���End��
���Current��
��"""	��"
��"��"��"
���get_u16_inner_or_default��SIZE_OF_VAL���get_u16_inner_or_die���.��get_u16_be_err��get_u16_le_err��
get_u16_be��
get_u16_le�"���get_u32_inner_or_default���.��get_u32_inner_or_die���.��get_u32_be_err��get_u32_le_err��
get_u32_be��
get_u32_le�"���get_u64_inner_or_default���.��get_u64_inner_or_die���.��get_u64_be_err��get_u64_le_err��
get_u64_be��
get_u64_le�����write_u64_inner_or_die��write_u64_inner_or_none��write_u64_be_err��write_u64_le_err��write_u64_be��write_u64_le�����write_u32_inner_or_die��write_u32_inner_or_none��write_u32_be_err��write_u32_le_err��write_u32_be��write_u32_le�����write_u16_inner_or_die��write_u16_inner_or_none��write_u16_be_err��write_u16_le_err��write_u16_be��write_u16_le��
ColorSpace��RGB��
�RGBA��
�YCbCr��
�Luma��
�LumaA��
�YCCK��
�CMYK��
�BGR��
�BGRA��
���
�ARGB��
�HSL��
�HSV��
�	MultiBand��
�����������������ColorCharacteristics��sRGB��
�Linear��
�����	���
����SingleColorPrimary��x��y��z���>�
�������ColorPrimaries��red��green��blue���>��������RenderingIntent��AbsoluteColorimetric��
�
Saturation��
�RelativeColorimetric��
�
Perceptual��
���������������DecoderFlags��inflate_confirm_adler��png_confirm_crc��jpg_error_on_non_conformance��zune_use_unsafe��
zune_use_sse2��
zune_use_sse3��zune_use_sse41��zune_use_avx��
zune_use_avx2��png_add_alpha_channel��
zune_use_neon��png_strip_16_bit_to_8_bit���!��#�����	���
�>�DecoderOptions������out_colorspace��	max_scans��
deflate_limit����
endianness������
���EncoderFlags���&�jpeg_optimize_huffman��image_strip_metadata����������>�EncoderOptions�����$����$��$��&��$�������	��8586898:8:8;8;8>8>8A8A8B8B8C8C8D8E8F8G8G8J8W8X8X8Y8Y8\8\8_8_8`8`8a8a8b8c8e8f8f8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�8�����������(���(������(z6��ޜ��Q��Q���Q��Q�Q�_�Q�`�Q�����)���)���*����䖞���#��R�_�R��R���R��R�R�����'���'���(��,_.�1��S�_�S��S���S��S�S��R��������O���EPO��T�_�T��T���T��T�T�,,�.�'/�'���G���U��U�V��V�����,�����,�����-��D���` �e���V��V�V��V��V�_�V�_jkl�m�no�p�qr�s�t�uv�w�x�yz�{�|}�~�������� �`���W�����
�"�f+�c��W����������9�{�.��W������"��"��!����V��V�����5���6���6���6���6���6���6���6���6���	���7
���7���7���7
���h
�hBu��Z�_�Z��Z���Z��Z�Z�����8���8�\���{W<��]�_�]���]��]�]����9��9��9��9�źo5�;�_�^��^��^����9��:��:��:�� 6e@�g�_�^��^��^�����:���;���;���;�֝�/V&���_��_�_��_��_�_�_����<��<���<���<���=���=���=���=���=���=���>���>���>���!���#�c�Э��ט�_�`��`��`�_���?��������?���?���?������@�S2s5����b��b��b����@��&���@���@�; B�[���_�c��c��c�_���A�����$������$���$���&���$��������~B��d��d��d�����������������������������������������������������������������������������������������������������������������j���������������������������������7,UH,K,�j�j�j������b�b��1�8�_8�`h��0�����
�,�j7>1�	$�	T�&�
�
�kD�
���kL��#/�l?	��kG�li(�km�ll���k	!�k>�k?G������k��R$�\��k$�l,3�k�5Wu���k$�	T�&��@]��"]��	�j5	BZ
a���"]
�^�j��d�
�d�
�\�
�	�]
��]
�S(����
�S<��R$��n\����]s����	Arguments���pieces��[����[����[k�ĉ������p��p��p��p����
�p�p%�p@�pHP$�"	T�!&��@]��"]��#	�p"	/G
N���"]�pZmܕ#
	̕#
�$��"
	��"
��k$Ԣ"
	Ģ"
�$	�]�
��]�q"�#��!�
�j,�!�R$�!�n\�"���]m�rj�pg�po�pw�pOq�
�p��p����p��p��t�$$�$
#<�$
/L�$�$��$�$�j$	'�jJ�jK�$��#H�j,�$�R,�$�j��R��j�#G�7�`!
�7�`�v"�7�_=��j(7�_'_�X7�`��j�'�j29=��jSIZE_OF_VAL��7�d!
�7�d�v"�7�c=��j(7�c'_�X7�d��j�'�j29=��jSIZE_OF_VAL��H�`!
�H�`
��l(�H�_=��j(H�_'_�XH�`��j�'�j29=��jSIZE_OF_VAL��H�d!
�H�d�~"�H�c=��j(H�c'_�XH�d��j�'�j29=��jSIZE_OF_VAL��Y�`!
�Y�`
�(�Y�_=��j(Y�_'_�XY�`��j�'�j29=��jSIZE_OF_VAL��Y�d!
�Y�d΁#�Y�c=��j(Y�c'_�XY�d��j�'�j29=��jSIZE_OF_VAL�
$�	T�	

;��7
�	�	�	��	��	yk���9�l<��
#�
�	�l3,��
�j	�
�j	�
�j	�
�j	�
�j	����j�	�������&�j,��Z,��nL�����l����1n��l$�	���~Z
)��~Z
!��~Z
����x���~`Z$���,��nT�A$�	���~Z)��~Z
!��~Z
����a���~`Z$���,��n\�A$�	T�
$�
���j<�
���j��j-<�
���j��j-<�
���j��j-<�
���j��j-���������������������;t����jl���,��n��{�
�j�,�j7>12�t�4�j�4���3E�j,�3�b,�3/|�5�j�5���5G�j,�5ِ,�5-Ԁ9�`�9���8Q$�8ِ,�8,|�O�T�O���NM�TT�Oِ,�O-��Q �`�Q���Pf$�Pِ,�P,��T�j�T���SQ�j,�Tِ,�T-ԾW�`�W���WZ$�Wِ,�W,��] �`	�]���]f$�]ِ,�],��b$�`�b���af$�bِ,�b,��d�`�d���c^$�dِ,�c,�f��f$�`�f$�f�f���e��b$�e�bD�e�ew�Ht�h�j�h���gN�j,�hِ,�g-��l�Z�l���k]�ZT�kِ,�k-��`
����ҝ^$��ِ,�/��	���$�`
��$����������b$��bD؟���LT�	�j�	���=	�j,�	�d,�	/T�	�R�	���@	�RD�	��,�	-d�	�v�	���>	�v�	��,�	-|�	�Z�	���L	�ZT�	��,�	-\�	�v�	���<	�v�	��,�	-��$	�v�$	���$F	�v�$	��,�$	-��*		�c��* 	�*	�*	���)[	$�*	��,�)	d2��-"	�c�-	���,f	$�,	��,�,	,��/ 	�c�/	���.j	$�/	��,�/	,,�
��%�V07>�
��%�V07><�
��%�V07>T�
jl#�W.�Y5<|�

jo#�W.�Y5<t�
jr&�W1�j8�j?F|�
jv&�W1�j8�j?F<�
jz#�W.�p5<L�
j}#�W.�p5<t�
j�$�W/�F�F��F��1"`��x9`gL�
�
�%�Z0��8?�

��%����'�����'�����(����Q���7���?�?��?buf��:�?�	�:$x��Lk��v�B�B�BGlobal�����I����

��%�1�?�?��?��:�?�	�:$x��Lk��k��v}�

��%�1�?�?��?��:�?�	�:$x��Lk��v��v}�����,��$��l�
�	<��	4��	4�	�	<�	�	<�
���
��)& Core routines shared by all libraries�����52 This crate provides a set of core routines shared���63 by the decoders and encoders under `zune` umbrella����� It currently contains�����GD - A bytestream reader and writer with endian aware reads and writes���;8 - Colorspace and bit depth information shared by images���'$ - Image decoder and encoder options���85 - A simple enum type to hold image decoding results.�����NK This library is `#[no_std]` with `alloc` feature needed for defining `Vec`���-* which we need for storing decoded  bytes.�����t� # Features���96  - `no_std`: Enables `#[no_std]` compilation support.�����B?  - `serde`: Enables serializing of some of the data structures���     present in the crate������� # Input/Output�����RO zune-image supports many different input and output devices. For input readers���`] we can read anything that implements `BufRead` + `Seek` and provide an optimized routine for���PM handling in memory buffers by using [`ZCursor`](crate::bytestream::ZCursor).��	���	kh For output, we support anything that implements `Write` trait, this includes files, standard io streams�č
 network sockets, etc��
���
_\ In a `no_std` environment. We can write to in memory buffers `&mut [u8]` and `&mut Vec<u8>`�����QN If you have an in memory buffer, use [`ZCursor`](crate::bytestream::ZCursor),���)& it's optimized for in memory buffers.���,�  �������:�;�:�9
�	8�	7�	6�	5�	4���������\�
�
��,�error�,�info�$�	log_enabled�\�

trace�,��$����<��<�{4�kl�T<�C4�7Ԝ����8�4�t�'|������,�8lvl��&�8�$�*�����8�8��,�8ڿ�%�8,�%�������8�4�t�'|�Y	����,���,�8arg��&�8���*���+���8����8�<��7�,���%�������8�4�t�'|�J
����,���,�8���&�8���*���+���8����8�<��7�,���%�������8�4�t�'|�9�	�	�	�	,�	�	�	,�	8���	&�	8��	�	*�	�	�	%�	��	��	�	�	8�4�	t�	'|�	��	�	�	�	,�	�	�	,�	8���	&�	8��	�	*�	�	�	%�	��
��	�
�
8�4�
t�	'|�
i�
�
�
�
,�
�
�
,�
8���
&�
8��
�
*�
�
�
%�
��
��2/ Image bit depth, information and manipulations�L�
���d��S��!��74 Return the equivalent of the image bit type's depth�D��S�R
$����R���<��R
l��R���&��C@ Return the minimum number of bits that can be used to represent��� each pixel in the image�����>; All bit depths below 8 return a bit type of `BitType::U8`.���OL  and all those above 8 and below 16 return a bit type of `BitType::SixTeen`���l�
 # Returns���MJ An enum whose variants represent the minimum size for an unsigned integer���52 which can store the image pixels without overflow���l�
 # Example���<� ```���2/ use zune_core::bit_depth::{BitDepth, BitType};���74 assert_eq!(BitDepth::Eight.bit_type(),BitType::U8);�����:7 assert_eq!(BitDepth::Sixteen.bit_type(),BitType::U16);�<�������)& See also [size_of](BitDepth::size_of)�D��R�S
50��!#��@= Get the number of bytes needed to store a specific bit depth���,���l�����QN For images less than or equal to 8 bits(1 byte), we can use a [`u8`] to store���)& the pixels, and a size_of [`u8`] is 1�����[X For images greater than 8  bits and less than 16 bits(2 bytes), we can use a [`u16`] to���-* store the pixels, a size_of [`u16`] is 2.�<����� '$ use zune_core::bit_depth::BitDepth;��� " let depth = BitDepth::Sixteen;��� 96 // greater 12 bits is greater than 8 and less than 16���!" assert_eq!(depth.size_of(),2);�<�!��<�!�R�j�yS0��#%D�$���R�j�$
$�$��
��2/ A simple implementation of a bytestream reader�|� and writer.�����63 This module contains two main structs that help in���! byte reading and byte writing�����;8 Useful for a lot of image readers and writers, it's put��� here to minimize code reuse�T�
"���<���<���d�j!���	����)��<�
, |�e4�|�^��)��'YT�4�'Nj����4�F"#�&�:"$�"$�;�?"%�LO�^"&����"g�oTb|/D�D7�[tj,�d 
j')�,L.
�'*��Q
�'+�4
9;,.�>#
"��"
�c?
< Wraps an in memory buffer providing it with a `Seek` method���&
# but works in `no_std` environments��
���P
M `std::io::Cursor` is available in std environments, but we also need support���E
B for `no_std` environments so this serves as a drop in replacement�E�--���V�
��V
�v\�
�U���G.//1\�
4�
',,�V|�
D�
',,�j��
�11���
��\�
�U2��#
�
�V�U00
2�V�4�
��
�44���
��\�
�U56��"
��"
 Move forward `num` bytes  from�̦
 the current position.��
���;
8 It doesn't check that position overflowed, new position���A
> may point past the internal buffer, all subsequent reads will���A
> either return an error or zero depending on the method called�$�
���U�j3�
3
5�V$�
num��
��	$
��3
0 Move back `num` bytes from the current position��
��
���B
? This saturates at zero, it can never be negative or wraparound���	$
! when the value becomes too small�4�	
���U�j3�

3
6�V$�

���

��
4
�88���

��\�

�U9:;>ABCDEFG�����������FB>:AE9DGC;rt��&
��
���U�v7�
7
9�V$�
��J
��
����U�����������������������q�aX�W7�

7
:�V$�

��

��]
��
����U��v���7�<<�
7��jt�

;�V�$�
��
!�
�j��J
̽
����U���7�??�
7��t�

>�V�$�
��
!�
�j��G
T�
����U�����������������������q�aX�j�W7�
7
A�V$�
��
��G
T�
����U�����7�
7
B�V$�
��
��J
��
����U�����7�
7
C�V$�
��
��B
4�
���U�V��������������������q�aX�W7�
7
D�V$�
�$�
��#2
4�$
���U��������������������q�aX�W7�$
7
E�V$�$
��%5
T�%
���U��7�%
7
F�V$�%
��%[
t�%
����U�ӫ��7�&
7
G�V$�&
sink�$�&
��*1
�II���*
��\�*
�UJ�J��*B
$�*
���U�I�I�I�,�I��I�I�,�I��I�I�-�I���:41R,��������������������q�aX�YH�+
H
J�V$�+
pos��+
��2+
�LL���2
��\�2
�UM�M��2
$�2
�V�UKK
M�V�,�2
�z\�io�#�NO�D4�INP�d_jNR�,Lm�NS����NT<]�+P�C4DF79�}#-��6�VV�����V\���VD��VWXY\_`abcef�����������\Xc_fWbeaY`����&�����V�vU�U
W�V$���J������V�����U�U
X�V$�����]������V�����U�ZZ�U��t�
Y�V�$���!��j��
J̵
����V���U�]]�
U��t�

\�V�$�
��
!�
�j��GT�����V�����U�U
_�V$�����GT�����V�����U�U
`�V$�����J������V�����U�U
a�V$�����B4����V�V��U�U
b�V$��$���24����V��U�U
c�V$��c<closure_kind>�d<closure_signature>�d<upvars>�ddcd�V�l����5T����V��U�U
e�V$���Ot�����V�ӫ��U�U
f�V$���$���#rt��Vi��	4\�	�V��hh
i$�	��d��W��� �`�klnoqruvyz|}�lm�Y�Wop�Y�Wrst�j�j�Wvwx�j�j�Wz{�Z�W}~�Z�W�����Wq1�� A standard library error���)& Only available with the `std` feature��1jj
l�1�1�Y�Wjj��t�jj�Y�1��0- An error converting from one type to another�2jj
o/222�Y�Wjj��Գ
jj�Y,2��
&# Not enough bytes to satisfy a read�`2jj
rt2w2�j�j�Wjj��,�jj�j,�jj�j~2��52 The output buffer is too small to write the bytes��2jj
v�2�2�j�j�Wjj�,�jj�j,�jj�j�2��$! An error that may occur randomly�3jj
z%3(3�Z�Wjj��d�jj�Z"3��2/ An error that occurred during a seek operation�b3jj
}v3y3�Z�Wjj��d�jj�Zs3��2��3jj
��3�3���Wjj��4�jj����&�W��_���9������W��^�^��^��[�^��[����e�S����������������������q�aXÅÅą��:�������
�$�����*�W�����&$��Y�W��
��,���6�W�����2$��Y�W��
��,���(�W�����$$��Z�W��
��,���'�� The image reader wrapper�����>; This wraps anything that implements [ZByteReaderTrait] and���>; extends the ability of the core trait methods by providing���/, utilities like endian aware byte functions.�����<9 This prevents each implementation from providing its own�<���������V���Z��!�����-/t� ,� "���V�� \� "��ӫ�� $������ ���� �Z���������������<>��!#�� %" Create a new reader from a source���!*' that implements the [ZByteReaderTrait]��!�V�Z��
��Vsource�4�!��#��"! Destroy this reader returning���"&# the underlying source of the bytes���# from which we were decoding�<�#�Z�V��
��V$�#��'?��$#  Skip ahead ignoring `num` bytes��$���$?< For more advanced seek methods see [Self::seek] that allows���%(% moving around via more advanced ways��%�|�% # Arguments���%(%  - num: The number of bytes to skip.��&�l�&����&@=  - `Ok(u64)`: The new position from the start of the stream.���&&#  - `Error` If something went wrong�$�'���Z�j����'�
��V$�'���'��+A��(1. Move back from current position to a previous�d�(	 position��(���(?����)(���)�|�)����*85 - `num`: Positions to move before the current cursor��*�l�*����*@����+&ޞ4�+���Z�j����+�
��V$�+���+��0D��,! Move around a stream of bytes��-���-KH This is analogous to the [std::io::Seek] trait with the same ergonomics���-;8 only implemented to allow use in a `no_std` environment��.�|�.����.&# - `from`: The seek operation type.��.�l�.����/@����/&#  -  Error if something went wrong.�$�0���Z�V����0�
��V$�0�$�0��4��11. Read a single byte from the underlying stream��1���1<9 If an error occurs, it will return `0` as default output���2MJ hence it may be difficult to distinguish a `0` from the underlying source���2 and a `0` from an error.���2)& For that there is [Self::read_u8_err]��3�t�3 # Returns.���3" - The next byte on the stream.�,�3��<�4���Z�v��4�
��V$�4��69��4IF Read a single byte returning an error if the read cannot be satisfied��5�l�5����5 - `Ok(u8)`: The next byte���563 - Error if the byte read could not be satisfied   �\�6���Z��������������������q�aX�v�W��6�
��V$�6��9[��741 Look ahead position bytes and return a reference���874 to num_bytes from that position, or an error if the���8  peek would be out of bounds.��8���8IF This doesn't increment the position, bytes would have to be discarded���9 at a later point.�<�9���Z�j�j��������������������q�aX����W��:�
��V$�:�D�:	num_bytes�L�:��E\��ASP Read a fixed number of known bytes to a buffer and return the bytes or an error���B if it occurred.��B���BSP The size of the `N` value must be small enough to fit the stack space otherwise���C'$ this will cause a stack overflow :)��C���CJG If you can ignore errors, you can use [Self::read_fixed_bytes_or_zero]��D�l�D����D30  - `Ok([u8;N])`: The bytes read from the source���D  - An error if it occurred.�̖E���Z��������������������q�aX���W�����E���t�E
��V�$�E�E�j��IE��GXU Read a fixed bytes to an array and if that is impossible, return an array containing�L�H zeros��H���HGD If you want to handle errors, use [Self::read_fixed_bytes_or_error]�ċI���Z�������I���t�I
��V�$�I�I�j��LK��J52 Move the cursor to a fixed position in the stream��K���KWT This will move the cursor to exacltly `position` bytes from the start of the buffer��K�|�K����L:7 - `position`: The current position to move the cursor.�d�L���Z�j����L�
��V$�L�D�L��Q3��MDA Return true if the underlying buffer can no longer produce bytes��N���NNK This call may be expensive depending on the underlying buffer type, e.g if���Ogd it's a file, we have to ask the os whether we have more contents, or in other words make a syscall.��P���P Use that wisely��P�l�P����PNK  - `Ok(bool)`: True if we are in `EOF`, false if we can produce more bytes���Q$!  - Error if something went wrong��Q���Z����Q�
��V$�Q��T7��R?< Return the current position of the inner reader or an error���R" if that occurred when reading.��S���S[X Like [eof](Self::eof), the perf characteristics may vary depending on underlying reader��T�l�T����T96 - `Ok(u64)`: The current position of the inner reader�D�T���Z����U�
��V$�U��XN��UEB Read a fixed number of bytes from the underlying reader returning���V'$ an error if that can't be satisfied��V���V*' Similar to [std::io::Read::read_exact]��W�l�W����W+(  - `Ok(())`: If the read was successful���WVS  - An error if the read was unsuccessful including failure to fill the whole bytes���X����Z�������X�
��V$�X��X��\K��YJG Read some bytes from the inner reader, and return number of bytes read��Z���ZC@ The implementation may not read bytes enough to fill the buffer��Z���Z$! Similar to [std::io::Read::read]��[�l�[����[>; - `Ok(usize)`: Number of bytes actually read to the buffer���[&# - An error if something went wrong�T�\����Z�������\�
��V$�\��\L�]$�]"��������z�k�$j��z�k�$j��������]"����"�����]"����"������]|�]�]�s�]�^",�]8�
$�]&�]8��]$�],�]8name2�,�]&�]8��]$�^,�^8name3�,�^&�^8��^$�^,�^8name4�,�^&�^8��^$�^,�^8name5�,�^&�^8��^$�^,�^8name6�,�^&�^8��^$�^,�^8int_type�D�^&�^8��^*�^�^�s8$�^�^8��^&�^8���^�^8�<�^�^8��^�^�^�s_+�^�^�_8�4�_�_�_8�4�_8�_,�_8�
$�_�_�_�_8�_8$�_$�_8mode�$�_&�_8�$�_(�_,�_8��D�_�_�b!8,�_8�.\�_&�_8�,�_�`8�$�`'�`8mem��`'�`8�<�`'�`�`,�`8��D�`�`�`�`%�`8�`8�`8space�,�`�`�`�`7��`%�`8�.\�`%�`8$�` �`8�,�` �`8���`�a�a�a8�a8��,�a%�a8,�a8��$�a�a�b8�$�a'�a8��a*�a,�a8��D�a'�a8
from_be_bytes�l�a�a�a8��,�a$�a8�$�b'�b8��b*�b,�b8��D�b'�b8
from_le_bytes�l�b�b�b8��,�b+�b�b�b8�4�b�b�b8�4�b8�c,�c8��,�c�c�c�c8�c8$�c$�c8��$�c&�c8�$�c(�c8�4�c�c,�c8��D�c$�c8�d�c�c�c�g8,�c8�.\�c&�c8�,�c�d8�$�d'�d8���d'�d8�<�d'�d�d,�d8��D�d�d�d�d%�d8�d8�d8��,�d�d�d�d7��d%�d8�.\�d%�d8,�d8$�d �d8�,�d �d8���d�e�e�e8�e8��,�e�e�g8��e�e�e8�e*�e8,�e8��$�e�e�f
8�$�e'�e8��e*�e8��e�e�f,�e8��D�e'�f8��l�f�f�f8��,�f$�f8�$�f'�f8��f*�f8��f�f�f,�f8��D�f'�f8��l�f�f�f8��,�f$�f8��g�g�g8��g*�g8��g�g�g8��g+�g�g�h8��g�g8�4�g	�g�g�h7Read �<�g$�g8�L�g	�g�g�g,�g8��D�g$�g7 as a big endian integer���g+�h�h�i8��h�h8�4�h	�h�h�i7=Returning an error if the underlying buffer cannot support a ���h?$�h8�L�h	�h�h�i,�h8��D�h$�i7 read.�D�i+�i�i�i8�4�i8�i8�i,�i8��,�i�i�i�i8�i8$�i(�i8�4�i�i,�i8��D�i$�i8�d�i�i�i�j8$�j �j,�j8��,�j�j�j8�$�j'�j8��j+�j�j�k8��j�j8�4�j	�j�j�k7��<�j$�j8�L�j	�j�j�j,�j8��D�j$�j7 as a little endian integer���j+�k�k�l8��k�k8�4�k	�k�k�l7����k?$�k8�L�k	�k�k�k,�k8��D�k$�k7��D�k+�l�l�l8�4�l8�l8�l,�l8��,�l�l�l�l8�l8$�l(�l8�4�l�l,�l8��D�l$�l8�d�l�l�l�m8$�m �m,�m8��,�m�m�m8�$�m'�m8��m+�m�m�m8��m�m8�4�m	�m�m�m7��<�m$�m8�L�m	�m�m�m,�m8��D�m$�m7����m+�n�n�n8��n�n8�4�n	�n�n�n7GReturning 0 if the underlying  buffer does not have enough bytes for a ���nI$�n8�L�n	�n�n�n,�n8��D�n$�n7��D�n+�o�o�o8�4�o�o�o8�4�o8�o8�o,�o8��,�o�o�o�o8�o8$�o(�o,�o8��D�o�o�p8$�o �o,�o8�
$�o�o�p8�$�o'�o8��o+�p�p�p8��p�p8�4�p	�p�p�p7��<�p$�p8�L�p	�p�p�p,�p8��D�p$�p7����p+�p�p�q8��p�p8�4�p	�q�q�q7FReturning 0 if the underlying buffer does not have enough bytes for a ���qH$�q8�L�q	�q�q�q,�q8��D�q$�q7��D�q+�q�q�r8�4�q�r�r8�4�r8�r8�r,�r8��,�r�r�r�r8�r8$�r(�r,�r8��D�r�r�r8$�r �r,�r8�
$�r�r�r8�$�r'�r8��r%�s��wB������w����w�Z�����w<$�w����Z�����������������������q�aX�j�Y��w�
��V$�w��w��xL�x�x�������������V�l�W�YT�4����d�j���,L������4+-Ԕ	��52 The de-facto Input trait implemented for readers.�����C@ This provides the basic functions needed to quick and sometimes���PM heap free I/O for the zune image decoders with easy support for extending it���  to multiple implementations.����� # Considerations�����ur If you have an in memory buffer, prefer [`ZCursor`](crate::bytestream::ZCursor) over [`Cursor`](std::io::Cursor).���� We implement this trait for two types, `ZCursor`, and any thing that implements `BufRead`+`Seek`, `Cursor` falls in the latter���sp and since Rust doesn't have specialization for traits, we can only implement it once. This means functions like����} [`read_byte_no_error`](crate::bytestream::ZByteReaderTrait::read_byte_no_error) are slower than they should be for `Cursor`.��	��P������	������ �����������������������������������'��	2/ Read a single byte from the decoder and return���	52 `0` if we can't read the byte, e.g because of EOF��
���
MJ The implementation should try to be as fast as possible as this is called���:7 from some hot loops where it may become the bottleneck��������v���
���$���K��UR Read exact bytes required to fill `buf` or return an error if that isn't possible�����
 ## Arguments���B?  - `buf`: Buffer to fill with bytes from the underlying reader�t�
  ## Errors���
VS In case of an error, the implementation should not increment the internal position����������������
���$�����^��U������b_ This is the same as [`read_exact_bytes`](Self::read_exact_bytes) but implemented as a separate���RO method to allow some implementations to optimize it to cost fewer instructions��������B��t�̂��V���������������������t�
����$���#��j��K��WT Read exact bytes required to fill `buf` or ignore buf entirely if you can't fill it���DA due to an error like the inability to fill the buffer completely������B��l�
 ## Errors���V�̯����������������t�
����$���#��j��H��\Y Read bytes into `buf` returning how many bytes you have read or an error if one occurred�����VS This doesn't guarantee that buf will be filled with bytes for such a guarantee see���0- [`read_exact_bytes`](Self::read_exact_bytes)��������*' - `buf`: The buffer to fill with bytes���t� ## Returns���63  - `Ok(usize)` - Actual bytes read into the buffer���WT  - `Err()` - The error encountered when reading bytes for which we couldn't recover�T��������������
���$�����H��GD Reads data into provided buffer but does not advance read position.�����T��������������
���$�����K���������������
���$�����C��,) Seek into a new position from the buffer�����b_ This is similar to the [seek](std::io::Seek::seek) function in the [Seek](std::io::Seek) trait���30 but implemented to work for no-std environments�4������V�����
���$��$���#3��1. Report whether we are at the end of a stream.�� �t�  ## Warning��� da This may cause an additional syscall e.g when we are reading from a file, we must query the file���!`] multiple times to check if we really are at the end of the file and the user didn't sneakily���!2/ add more contents to it hence use it with care��"�t�"��"EB - `Ok(bool)` - The answer to whether or not we are at end of file���#_\ - `Err()` - The error that occurred when we queried the underlying reader if we were at EOF�4�#��������$�
���$�$��%6��$41 Return the current position of the inner cursor.��$���$;8 This can be used to check the advancement of the cursor�T�%��������%�
���$�%��'\��%EB Read all bytes remaining in this input to `sink` until we hit eof��&�l�&����&>; - `Ok(usize)` The actual number of bytes added to the sink���'74 - `Err()` An error that occurred when reading bytes�t�'������ӫ����'�
���$�'��$�'��)��(C@ The writer trait implemented for zune-image library of encoders��(���(=: Anything that implements this trait can be used as a sink���) for writing encoded images��b������)������ �����������������,E��)GD Write some bytes into the sink returning number of bytes written or���*&# an error if something bad happened��*���*WT An implementation is free to write less bytes that are in buf, so the bytes written���+,) cannot be guaranteed to be fully written�\�,������������,�
���$�,��,��.F��,JG Write all bytes to the buffer or return an error if something occurred��-���-PM This will always write all bytes, if it can't fully write all bytes, it will�l�-
 error out�|�.������������.�
���$�.��.��0[��.KH Write a fixed number of bytes and error out if we can't write the bytes��/���/jg This is provided to allow for optimized writes where possible. (when the compiler can const fold them)���0���������������0���t�0
����$�0��0#�0�j��36��0)& Ensure bytes are written to the sink.��1���1NK Implementations should treat this like linux `fsync`, and should implement���2>; whatever writer's implementation of fsync should look like��2���2`] After this, the encoder should be able to guarantee that all in-core data is synced with the���3 storage decive�\�3��������3�
���$�3��7H��4QN A hint to tell the implementation how big of a size we expect the image to be���4WT An implementation like in memory `Vec` can use this to reserve additional memory to���5&# prevent reallocation when encoding��5���5VS This is just a hint, akin to calling `Vec::reserve` and should be treated as such.���6`] If your implementation doesn't support such, e.g file or mutable slices, it's okay to return�d�7	 `Ok(())`���7�����j����7�
���$�7�$�7T�4�����d�j��!��������313 t�T��Write�,'����dFj��!t*�3�U8�����Z��V,]�V���������������KM��D\�����V��������
��V$�����E|�����V��������
��V$�����Z������V�������������t�
��V�$���"��j��5\����V�����
��V$���D�����V�j�����
��V$��L�$���������`Z^v�� 9`Z^v�� 9������������������������������'��*' Encapsulates a simple Byte writer with���#  support for Endian aware writes�<���������V�����������Y�����VY������fh��4�����V��l�����j��$����������������������13��B��0- Write bytes from the buf into the bytestream���*' and return how many bytes were written���|�����63 - `buf`: The bytes to be written to the bytestream���l�����+( - `Ok(usize)` - Number of bytes written���SP This number may be less than `buf.len()` if the length of the buffer is greater���'$ than the internal bytestream length�,�����ZW If you want to be sure that all bytes were written, see [`write_all`](Self::write_all)���,��������������
��V$�����
C��	=: Write all bytes from `buf` into the bytestream and return���
=: and panic if not all bytes were written to the bytestream��
�|�����85 - `buf`: The bytes to be written into the bytestream���d�	# Returns���DA - `Ok(())`: Indicates all bytes were written into the bytestream���DA - `Err(&static str)`: In case all the bytes could not be written���
 to the stream�L�
������������
�
��V$�
��
��!��" Create a new bytestream writer���C@ Bytes are written from the start to the end and not assumptions���30 are made of the nature of the underlying stream���|�����V����
��Vdata�$���D��85 Write a single byte into the bytestream or error out���  if there is not enough space���l���<�����'$ use zune_core::bytestream::ZWriter;��� let mut buf = [0;10];���2/ let mut stream  =  ZWriter::new(&mut buf[..]);���-* assert!(stream.write_u8_err(34).is_ok());�<���d�	 No space�<�����'��ԥ let mut no_space = [];���52 let mut stream = ZWriter::new(&mut no_space[..]);���.+ assert!(stream.write_u8_err(32).is_err());�<�����d������v�����
��V$�byte�$���m��@= Write a fixed compile time known number of bytes to the sink�����WT This is provided since some implementations can optimize such writes by eliminating��� some redundant code.���������������������t�
��V�$���$�"��j��$��41 Write a single byte in the stream or don't write���C@ anything if the buffer is full and cannot support the byte read���D������v���
��V$���$���$��63 Return the number of bytes written by this encoder�����PM The encoder keeps information of how many bytes were written and this method��� returns that value.���l�����  Number of bytes written�l������j���
��V$���#H��+( Reserve some additional space to write.�����UR Some sinks like `Vec<u8>` allow reallocation and to prevent too much reallocation���:7 one can use this to reserve additional space to encode���l� ��,� ��<� ���� '���� EB let space_needed = 10; // Assume the image will fit into 10 bytes���!  let mut output = Vec::new();���!-* let mut sink = ZWriter::new(&mut output);���! // now reserve some space���"'$sink.reserve(space_needed).unwrap();���"KH // at this point, we can assume that ZWriter allocated space for output�<�#��<�#�����j����#�
��V$�#
additional�T�#��%��$0- Consume the writer and return the inner sink���$ we were writing to.��$���%0- After this, the writer can no longer be used�,�%���V��
��V$�%�&��%30 Return an immutable reference to the inner sink�L�&������V��&�
��V$�&��'%��&0- Return a mutable reference to the inner sink�L�'������V��'�
��V$�'��'��'�(�>�(�(",�(8�
$�(&�(8��($�(,�(8��,�(&�(8��($�(,�(8��,�(&�(8��($�(,�(8��,�(&�(8��($�(,�(8��,�(&�(8��($�(,�(8��,�(&�(8��($�(,�(8��D�(&�(8��(*�(�(�>8$�(�(8��(&�(8���(�(8�<�(�)8��)�)�)�>S+�)�)�)8�4�)�)�)8�4�)8�),�)8�
$�)�)�)�)8�)8$�)$�)8��$�)&�),�)8��D�)$�)8��$�)&�)8�$�)(�)8�4�)�)�)�)$�)8�d�)�*�*�-8�+8bytes�,�,�,8,�,8��$�,�,�-8�$�,'�,8��,*�,8��$�, �,8to_be_bytes�\�,�,�,$�,8�$�,'�,8��-*�-8��$�- �-8to_le_bytes�\�-�-�-%�-8$�- �-8���-�-�-�-8��,�-+�-�-�.8�4�-�.�.8�4�.8�.,�.8��,�.�.�.�.8�.8$�.$�.8��$�.&�.,�.8��D�.$�.8��$�.&�.8�$�.�.�28�08��,�0�08,�08��$�0�0�18�$�1'�18��1*�18��$�1 �18��\�1�1�1$�18�$�1'�18��1*�18��$�1 �18��\�1�1�1%�18�28�2�28$�2 �28���2�2�2�28��,�2%�2+�2�2�38��2�28�4�2	�2�2�37Write �D�2$�28�L�2	�2�2�2,�28��D�2$�27����2+�3�3�48��3�38�4�3	�3�3�47����3?$�38�L�3	�3�3�3,�38��D�3$�37 write.�L�3+�4�4�48�4�48�48�4,�48��,�4�4�4�48�48$�4$�48��$�4&�4,�48��D�4(�48�4�4�4�4�4$�48�d�4�4�4�58$�5 �5,�58�
$�5�5�58��$�5$�58�$�5'�58��5+�5�5�68��5�58�4�5	�5�5�67��D�5$�58�L�5	�5�5�5,�58��D�5$�57����5+�6�6�78��6�68�4�6	�6�6�77����6?$�68�L�6	�6�6�7,�68��D�6$�77��L�7+�7�7�78�4�78�78�7,�78��,�7�7�7�78�78$�7$�78��$�7&�7,�78��D�7(�78�4�7�7�7�7$�78�d�7�7�8�88$�8 �8,�88�
$�8�8�88��$�8$�88�$�8'�88��8+�8�8�98��8�88�4�8	�8�8�97��D�8$�88�L�8	�8�8�8,�88��D�8$�87����8+�9�9�:8��9�98�4�9	�9�9�:77Or don't write anything if the reader cannot support a ���99$�98�L�9	�9�9�9,�98��D�9$�97��L�:+�:�:�:8�4�:8�:8�:,�:8��,�:�:�:�:8�:8$�:$�:8��$�:&�:,�:8��D�:�:�;8$�: �:,�:8��,�:�;�;8��$�;$�;8�$�;'�;8��;+�;�;�;8��;�;8�4�;	�;�;�;7��D�;$�;8�L�;	�;�;�;,�;8��D�;$�;7����;+�<�<�<8��<�<8�4�<	�<�<�<7����<9$�<8�L�<	�<�<�<,�<8��D�<$�<7��L�<+�<�<�=8�4�<8�=8�=,�=8��,�=�=�=�=8�=8$�=$�=8��$�=&�=,�=8��D�=�=�>8$�= �=,�=8��,�=�=�=8��$�=$�=8�$�='�=8��=%�>��
��<9 Image Colorspace information and manipulation utilities.�T�
������|��Z������+��=: Number of color channels present for a certain colorspace�����LI E.g. RGB returns 3 since it contains R,G and B colors to make up a pixel�t����Z�j���
�$���%L����Z���
�$���(d����Z���
�$���3��63 Returns the position of the alpha pixel in a pixel�������^[ That is for an array of color components say `[0,1,2,3]` if the image has an alpha channel���c` and is in RGBA format, this will return `Some(3)`, indicating alpha is found in the third index���a^ but if the image is in `ARGB` format, it will return `Some(0)` indicating alpha is found in  �\� index 0�����<9 If an image doesn't have an alpha channel returns `None`���t����ZҎ���
�$���,��-* Encapsulates all colorspaces supported by�|� the library�����0- This explicitly leaves out multi-band images�|��Z�j`
����`NG�j|�� Decoder and Encoder Options� ��$:7 This module exposes a struct for which all implemented��_,) decoders get shared options for decoding�����VS All supported options are put into one _Options to allow for global configurations���NK options e.g the same  `DecoderOption` can be reused for all other decoders���<����?t����At�����%��\�<��������+T�����5T������+���1����`
���!d���`
���
 \�
��`
���)��(
 Initializers��b�����+#��)>; Create the decoder with options  setting most configurable���))& options to be their safe counterparts��*���*?< This is the same as `default` option as default initializes���*! options to the  safe variant.��+���+@= Note, decoders running on this will be slower as it disables���+  platform specific intrinsics�D�+�b��
���.#��,DA Create the decoder with options setting the configurable options��- to the fast  counterparts��-���-FC This enables platform specific code paths and enable use of unsafe�D�.�b��
���1"��/A> Create the decoder options with the following characteristics��/���/ - Use unsafe paths.���0WT - Ignore error checksuming, e.g in png we do not confirm adler and crc in this mode���0" - Enable fast intrinsics paths�<�1�b��
���2��2,) Global options respected by all decoders��b�������������3&��263 Get maximum width configured for which the decoder���3;8 should not try to decode images greater than this width�L�3���b�j��3�
�$�3��5'��4>; Get maximum height configured for which the decoder should���452 not try to decode images greater than this height�T�5���b�j��5�
�$�5��6!��5<9 Return true whether the decoder should be in strict mode�ԥ6 And reject most errors�\�6���b��6�
�$�6��8&��70- Return true if the decoder should use unsafe�ܯ8 routines where possible�T�8���b��8�
�$�8��;4��9:7 Set maximum width for which the decoder should not try���9+( decoding images greater than that width��:�|�:���:���:)& * `width`:  The maximum width allowed��:���: returns: DecoderOptions�l�;�b�j�b��
�$�;�,�;��=6��;;8 Set maximum height for which the decoder should not try���<,) decoding images greater than that height�|�<���=���=*' * `height`: The maximum height allowed��=���=ՠ�=�t�=�b�j�b��
�$�>�$4�>��B2��>96 Whether the routines can use unsafe platform specific��? intrinsics when necessary��?���?<9 Platform intrinsics are implemented for operations which���@@= the compiler can't auto-vectorize, or we can do a marginably���@ better job at it��@���@1. All decoders with unsafe routines respect it.��A���AB? Treat this with caution, disabling it will cause slowdowns but���A/, it's provided for mainly for debugging use.��B���BC@ - Respected by: `png` and `jpeg`(decoders with unsafe routines)�t�B�b�b��
�$�C��C��D;��D��b�`�b��
�$�D�,�D��G3��D>; Set whether the decoder should be in standards conforming/�|�E strict mode��E���EGD This reduces the error tolerance level for the decoders and invalid���F+( samples will be rejected by the decoder��F�|�F���F�d�F	 * `yes`:��G�ܕGՠ�G�|�G�b�b��
�$�G��G��M<��I?< Set the byte endian for which raw samples will be stored in���I96 in case a single pixel sample spans more than a byte.��J���J@= The default is usually native endian hence big endian values���J@= will be converted to little endian on little endian systems,��K���KRO and little endian values will be converted to big endian on big endian systems��L�|�L���L���L;8 * `endian`: The endianness to which to set the bytes to��L���Lՠ|�M�b�T�b��
�$�Mendian�4�M��N-��NKH Get the byte endian for which samples that span more than one byte will�t�N be treated�\�O���b�T��O�
�$�O��O��O PNG specific options��b��������������P5��O.+ Whether the inflate decoder should confirm���P adler checksums���P���b��P�
�$�P��R=��Q2/ Set whether the inflate decoder should confirm���Q�̇R�b�b��
�$�R��R��S.��S30 Get default inflate limit for which the decoder���S&# will not try to decompress further���S���b�j��T�
�$�T��U8��T96 Set the default inflate limit for which decompressors���T/, relying on inflate won't surpass this limit�-\�U��U�b�j�b��
�$�Ulimit�,�U��W/��V.����V crc 32 checksums���W���b��W�
�$�W��X7��W.+ Set whether the png decoder should confirm���X CRC 32 checksums�-\�X��X�b�b��
�$�X��X��[=��Y>; Set whether the png decoder should add an alpha channel to���Y images where possible.��Z���Z1. For Luma images, it converts it to Luma+Alpha��Z���Z.+ For RGB images it converts it to RGB+Alpha�̜[�b�b��
�$�[��[��]5��\;8 Return true whether the png decoder should add an alpha���\$! channel to images where possible�̒]���b��]�
�$�]��_9��]@= Whether the png decoder should reduce 16 bit images to 8 bit���^ images implicitly.��^���^�� Equivalent to [png::Transformations::STRIP_16](https://docs.rs/png/latest/png/struct.Transformations.html#associatedconstant.STRIP_16)���_�b�b��
�$�`��`��a1��`EB Return a boolean indicating whether the png decoder should reduce���a,) 16 bit images to 8 bit images implicitly���a���b��b�
�$�b��c/��b@= Return whether `zune-image` should decode animated images or���c63 whether we should just decode the first frame only���c���b��c�
�$�c��eA��d>; Set  whether `zune-image` should decode animated images or���d6����e�b�b��
�$�e��K��f��f JPEG specific options��b������g/��f0- Get maximum scans for which the jpeg decoder���g.+ should not go above for progressive images���g���b�j��g�
�$�g��i=��h74 Set maximum scans for which the jpeg decoder should���h*' not exceed when reconstructing images.���i�b�j�b��
�$�i�?L�i��k9��jFC Get expected output colorspace set by the user for which the image���j)& is expected to be reconstructed into.��k���k" This may be different from the���k���b�Z��k�
�$�k��nH��lJG Set expected colorspace for which the jpeg output is expected to be in��l���la^ This is mainly provided as is, we do not guarantee the decoder can convert to all colorspaces���m>; and the decoder can change it internally when it sees fit.�-\�n��n�b�Z�b��
�$�n�T�n��q��o Intrinsics support��o���o)& These routines are compiled depending���p=: on the platform they are used, if compiled for a platform���pGD it doesn't support,(e.g avx2 on Arm), it will always return `false`��b��������r��q'$ Use SSE 2 code paths where possible��q���q74 This checks for existence of SSE2 first and returns��r false if it's not present�D�r���b��r�
�$�r��z��y" Use SSE 3 paths where possible��y��y���y:7 This also checks for SSE3 support and returns false if���z it's not present�D�z���b��z�
�$�z������! Use SSE4 paths where possible�������@= This also checks for sse 4.1 support and returns false if it��� is not present�L�����b����
�$��쑊��  Use AVX paths where possible�������>; This also checks for AVX support and returns false if it's�|މ not present�<�����b����
�$�����͐! Use avx2 paths where possible������C@ This also checks for AVX2 support and returns false if it's not�\Ñ present�D�����b����
�$���јDؘ���b���
�$����䛜 JPEG_XL specific options��b���ҝ/�Ҝ@�����6���ߝ���b���
�$�����A���>�����6������b�b��
�$ܟ��M����b����ʩ��1. Create a default and sane option for decoders�������" The following are the defaults�š��͡ - All decoders���     - max_width: 16536�܃�     - max_height: 16535����;8     - use_unsafe: Use unsafe intrinsics where possible.���T� - JPEG����\Y     - max_scans: 100 (progressive images only, artificial cap to prevent a specific DOS)��ۣSP     - error_on_non_conformance: False (slightly corrupt images will be allowed)�l��
 - DEFLATE��Ť[X     - deflate_limit: 1GB (will not continue decoding deflate archives larger than this)�L�� - PNG����mj   - endianness: Default endianess is Big Endian when decoding 16 bit images to be viewed as 8 byte images����A>   - confirm_crc: False (CRC will not be confirmed to be safe)���LI   - strip_16_bit_to_8: False, 16 bit images are handled as 16 bit images����KH   - add alpha: False, alpha channel is not added where it isn't present����JG   - decode_animated: True: All frames in an animated image are decoded�ۨ�T�  - JXL���KH    - decode_animated: True: All frames in an animated image are decoded�©�<ͩ�b��
�\�<�����)D�	����5T�	���ԫ	+��	��	�d�����	<�	�d��
���
	�d�������������������p	��
	  Create  new encode options��	�|�	��,�	��Ԭ	 * `width`: Image width���	 * `height`: Image height���&	# * `colorspace`:  Image colorspaces�ԗ	 * `depth`: Image depth��	�ܾ	 returns: EncoderOptions��	��	�j�j�Z�R�d��
��,�	�$4�
	�T�
	�$,�
	��"	��8	5 Get the width for which the image will be encoded in�,�	���d�j��	�
�$�	�	��5	2 Get height for which the image will be encoded in��	���	 returns: usize��	�d�		 # Panics���	 If height is zero�4�	���d�j��	�
�$�	��%	��8	5 Get the depth for which the image will be encoded in�,�	���d�R��	�
�$�	��!	��<	9 Get the quality for which the image will be encoded with��	�d�		  # Lossy���?	< - Higher quality means some images take longer to write and��	 are big but they look good��	���7	4 - Lower quality means small images and low quality.��	�t�	 # Lossless���B	? - High quality indicates more time is spent in making the file�\�	 smaller��	���H	E - Low quality indicates less time is spent in making the file bigger�<�	���d�v��	�
�$�	��,	��=	: Get the colorspace for which the image will be encoded in�T�	���d�Z��	�
�$�	�� 	4�	���d�v��	�
�$�	��0	��)	& Set width for the image to be encoded�L�	�d�j�d��
�$�	�,�	��2	��*	' Set height for the image to be encoded�T�	�d�j�d��
�$�	�$4�	��3	��)	& Set depth for the image to be encoded�L�	�d�R�d��
�$�	�$,�	��1	��*	' Set quality of the image to be encoded��	���"	 Quality is clamped from 0..100��	���A	> Quality means different options depending on the encoder, see��� 	 [get_quality](Self::quality)�\�	�d�v�d��
�$�	�$<�	��?	��.	+ Set colorspace for the image to be encoded�t�	�d�Z�d��
�$�	�T�	��!5	�� @	= Set the number of threads allowed for multithreaded encoding��� 	 where supported�� 	��� "	 Zero means use a single thread�|�!	�d�v�d��
�$�!	threads�<�!	��"/	T�"	�d�v�d��
�$�"	�$4�"	��$%	��":	7 Return number of threads configured for multithreading���#	 where possible��#	���#-	* This is used for multi-threaded encoders,�Ԇ$	 currently only jpeg-xl�\�$	���d�v��$	�
�$�$	��'6	��$A	> Set whether the encoder should remove metadata from the image��%	���%C	@ When set to `true`, supported encoders will strip away metadata���&H	E from the resulting image. If set to false, where supported, encoders���&(	% will not remove metadata from images���'	�d�d��
�$�'	��'	��)*	��(D	A Whether or not the encoder should remove metadata from the image��(	���(V	S The default value is false, and encoders that respect this try to preserve as much���).	+ data as possible from one image to another�t�)	���d��)	�
�$�)	��*	��*	
 JPEG options��d�����,3	��*H	E Whether the jpeg encoder should encode the image in progressive mode��+	���+	 Default is `false`.��+	���+U	R This may be used to create slightly smaller images at the cost of more processing�D�,	 time���,	���d��,	�
�$�,	��.9	��-S	P Whether the jpeg encoder should optimize huffman tables to create smaller files���."	 at the cost of processing time��.	���.	χ��.	���d��/	�
�$�/	��0?	��/M	J Set whether the jpeg encoder should encode the imagei in progressive mode��0	���0	 Default is `false`���0	�d�d��
�$�0	��0	t���
 Decoding results for images�4����
�?��|�
��
��&
# A simple enum that can hold decode�Ԅ
 results of most images�3��
t�
���Q���7���������ӫ������������T�T��
��T�Tӫ�����<�
��ӫ�U�U��
��U�U�������D�
����^V^V��
�^V^V������D�
������
�����"
��A
> Return the contents if the enum stores `Vec<u8>` or otherwise���
 return `None`.��
���=
: Useful for de-sugaring the result of a decoding operation���
 into raw bytes��
�l�
��<�
����*
' use zune_core::result::DecodingResult;���/
, let data = DecodingResult::U8(vec![0;100]);���<
9 // we know this won't fail because we created it with u8���!
 assert!(data.u8().is_some());��
���0
- let data = DecodingResult::U16(vec![0;100]);���9
6 // it should now return nothing since the type is u18���!
 assert!(data.u8().is_none());��
�<�
���
�����������������;t���ӫ��
�$�
��$
��	B
? Return the contents if the enum stores `Vec<u16>` or otherwise���	
���	
���
=
˒��

���

�l�

��<�

����
*
��/
����<
9 // we know this will fail because we created it with u16���"
 assert!(data.u16().is_none());��
��
���0
����
;
8 // it should now return something since the type is u16���
"
 assert!(data.u16().is_some());��
�<�
���
�����������������;t�������
�$�
t�,��Qz6��ޜ����������������,����Q���Q�4�j$����Q���Q$����Q���Q,����Q���Q,����Q���Q �*�Q(�+�Q���!#���Q�Q���
�,��,�Q���!�(*-/8�9=?���Q���
��H�-�Q-�Q���46����Q��Q���
�L���(	�.�Q��_�!#�����Q��^�^��^��[�^��[����e�S�����	��
�,��� 
�/�Q��`�!#����Q������
��������`���
���$��������� The image bit depth.�����2/ The library successfully supports depths up to���:7 16 bits, as the underlying storage is usually a `u16`.�����B? This allows us to comfortably support a wide variety of images���'$ e.g 10 bit av1, 16 bit png and ppm.�3��D��R�䖞���#������������,��� U8 bit depth.�����2/ Images with such bit depth use [`u8`] to store���.+ pixels and use the whole range from 0-255.�����41 It is currently the smallest supported bit depth��� by the library.�����C@ For images with bit depths lower than this, they will be scaled��� to this bit depth�s���R�����R<��� U16 bit depth�����SP Images with such bit depths use [`u16`] to store values and use the whole range�|� i.e 0-65535�����2/ Data is stored and processed in native endian.�����R�����R<�	��30 Floating point 32 bit data, range is 0.0 to 1.0��	�Ԙ	 Uses f32 to store data�o���R�����R<�	��	$! Bit depth information is unknown�3���RFH���R �0�R(�1�R���!#���R�R���
�,�(
�2�R��_�!#�����R��^�^��^��[�^��[����e�S�����
��
�,����3�R���!�(*-/8�9=?���R���
��H�4�R4�R���46����R��R���
�L�������	2/ The underlying bit representation of the image��
���
.+ This represents the minimum rust type that���
1. can be used to represent image data, required���%" by `Channel` struct in zune-image�3��<��S��,_.�1������������.+ Images represented using a [`u8`] as their�� underlying pixel storage�a���Stv���S�
��/, Images represented using a [`u16`] as their��
 underlying pixel storage.�c���Svx���S���
/, Images represented using a [`f32`] as their���
�J���S]_���S �5�S(�6�S���!#���S�S���
�,�(�7�S��_�!#�����S��^�^��^��[�^��[����e�S�������
�,����8�S���!�(*-/8�9=?���S���
��H�9�S9�S���46����S��S���
�L�����#��0- Get the max value supported by the bit depth�����30 During conversion from one bit depth to another�����52 larger values should be clamped to this bit depth��<��$�l���L��R�k
��6��&��$'$ Byte endianness of returned samples���$C@ this is useful when the decoder returns samples which span more���%2/ than one byte yet the type returned is `&[u8]`��%���%DA This helps you interpret how those bytes should be reconstructed�Բ& to a higher order type�T�'�TO���EPO�������'�' Little Endian byte-order�*���T=?���T�'̽' Big Endian byte-order�'���T:<���T �&>�T(�&?�T���!#���T�T��&�
�,�&( �&@�T��_�!#�����T��^�^��^��[�^��[����e�S����� �&�
�,�&��!�&A�T���!�(*-/8�9=?���T�!�&�
��&H"�&B�TB�T���46����T��T�"�&�
�L�&����	L��VD���` �e���������V���V���VLQ	LQ��
�LQLQ�V��������Q	�Q��
��Q�Q�V��������Q	�Q��
��Q�Q�V������� #�C�VH$�D�VD�V���46����V��V�$��
�L���%�E�V���!�(*-/8�9=?���V�%��
��(&�F�V���!#���V�V�&��
�,�('�G�V��_�!#�����V��^�^��^��[�^��[����e�S�����'��
�,����7�^#�����7�^���7�^�Z������#%�7�_,Ĩs"���Z���k�7�_�
��V 7�_�� 7�_�7�_X7�_"�j~=���j�7�cC��s"���Z����������������������q�aX�k�W�7�c�
��V 7�c�� 7�c�7�cX7�c"�jC>���j�7�i;�7�g7�g Read u16 as a big endian integer����9�gA�7�gH�7�h7�hFReturning an error if the underlying buffer cannot support a u16 read.����;�hg�7�hnt�s���Z���7�i�
��V 7�i�7�l;�7�j7�j#Read u16 as a little endian integer����=�jD�7�jK�7�k7�k�����?�kg�7�knt�s���Z���7�l�
��V 7�l�7�o%�7�m7�m�����A�mA�7�mH�7�n7�nPReturning 0 if the underlying  buffer does not have enough bytes for a u16 read.����C�nq�7�nxT�t���Z�k�7�o�
��V 7�o�7�r%�7�p7�p�����E�pD�7�pK�7�p7�pOReturning 0 if the underlying buffer does not have enough bytes for a u16 read.����G�pp�7�pwT�t���Z�k�7�r�
��V 7�r�H�^#�����H�^���H�^�Z������#%�H�_,��t"���Z���l�H�_�
��V H�_�� H�_�H�_XH�_"�j?���j�H�cC��t"���Z����������������������q�aX�l�W�H�c�
��V H�c�� H�c�H�cXH�c"�j�?���j�H�i;�H�gH�g Read u32 as a big endian integer����J�gA�H�gH�H�hH�hFReturning an error if the underlying buffer cannot support a u32 read.����L�hg�H�hnt�t���Z���H�i�
��V H�i�H�l;�H�jH�j#Read u32 as a little endian integer����N�jD�H�jK�H�kH�k�����P�kg�H�knt�u���Z���H�l�
��V H�lH�o�H�mH�m�����R�mA�H�mH�H�nH�nPReturning 0 if the underlying  buffer does not have enough bytes for a u32 read.����T�nq�H�nxT�u���Z�l�H�o�
��V H�oH�r�H�pH�p�����V�pD�H�pK�H�pH�pOReturning 0 if the underlying buffer does not have enough bytes for a u32 read.����X�pp�H�pwT�u���Z�l�H�r�
��V H�r�Y�^#�����Y�^���Y�^�Z������#%�Y�_,��u"���Z���Y�_�
��V Y�_�� Y�_�Y�_XY�_"�j�@���j�Y�cC��v"���Z�����Y�c�
��V Y�c�� Y�c�Y�cXY�c"�jdA���j�Y�i;�Y�gY�g Read u64 as a big endian integer����[�gA�Y�gH�Y�hY�hFReturning an error if the underlying buffer cannot support a u64 read.����]�hg�Y�hnt�v���Z���Y�i�
��V Y�i�Y�l;�Y�jY�j#Read u64 as a little endian integer����_�jD�Y�jK�Y�kY�k�����a�kg�Y�knt�v���Z���Y�l�
��V Y�lY�o�Y�mY�m�����c�mA�Y�mH�Y�nY�nPReturning 0 if the underlying  buffer does not have enough bytes for a u64 read.����e�nq�Y�nxT�v���Z�Y�o�
��V Y�oY�r�Y�pY�p�����g�pD�Y�pK�Y�pY�pOReturning 0 if the underlying buffer does not have enough bytes for a u64 read.����i�pp�Y�pwT�v���Z�Y�r�
��V Y�r�l�(#�����l�(��l�(��������$&�l�)L��>����������l�)�
��V l�)�� l�)�� l�)�l�.1��>��������l�.�
��V l�.�� l�.�� l�.�l�4E�l�2l�2!Write u64 as a big endian integer����n�2B�l�2I�l�3l�3GReturning an error if the underlying buffer cannot support a u64 write.����p�3h�l�3o��>�������l�4�
��V l�4�� l�4�l�7E�l�5l�5$Write u64 as a little endian integer����r�5E�l�5L�l�6l�6�����t�6h�l�6o��>�������l�7�
��V l�7�� l�7�l�:)�l�8l�8�����v�8B�l�8I�l�9l�9BOr don\'t write anything if the reader cannot support a u64 write.�AOr don't write anything if the reader cannot support a u64 write.��x�9b�l�9id�?�����l�:�
��V l�:�� l�:�l�=)�l�;l�;�����z�;E�l�;L�l�<l�<�����|�<b�l�<id�?�����l�=�
��V l�=�� l�=�}�(#�����}�(��}�(��������$&�}�)L��?������l�����}�)�
��V }�)�� }�)�� }�)�}�.1��?������l���}�.�
��V }�.�� }�.�� }�.�}�4E�}�2}�2!Write u32 as a big endian integer�����2B�}�2I�}�3}�3GReturning an error if the underlying buffer cannot support a u32 write.�݂���3h�}�3o��@�����l���}�4�
��V }�4�� }�4�}�7E�}�5}�5$Write u32 as a little endian integer������5E�}�5L�}�6}�6݂݂���6h�}�6o��@�����l���}�7�
��V }�7�� }�7�}�:)�}�8}�8�������8B�}�8I�}�9}�9BOr don\'t write anything if the reader cannot support a u32 write.�AOr don't write anything if the reader cannot support a u32 write.����9b�}�9id�@�����l�}�:�
��V }�:�� }�:�}�=)�}�;}�;�������;E�}�;L�}�<}�<�������<b�}�<id�@�����l�}�=�
��V }�=�� }�=���(#�������(����(��������&(���)L��A������k�������)�
��V ��)�� ��)�� ��)���.1��A������k�����.�
��V ��.�� ��.�� ��.���4E���2��2!Write u16 as a big endian integer�׌���2B���2I���3��3GReturning an error if the underlying buffer cannot support a u16 write.������3h���3o��A�����k�����4�
��V ��4�� ��4���7E���5��5$Write u16 as a little endian integer������5E���5L���6��6�������6h���6o��A�����k�����7�
��V ��7�� ��7���:)���8��8׌׌���8B���8I���9��9BOr don\'t write anything if the reader cannot support a u16 write.�AOr don't write anything if the reader cannot support a u16 write.����9b���9id�A�����k���:�
��V ��:�� ��:���=)���;��;�������;E���;L���<��<������<b���<id�A�����k���=�
��V ��=�� ��=����" All possible image colorspaces���1. Some of them aren't yet supported exist here.�3��T��Z�h
�hBu�������������������������������������		�

���

�����Z��� Red, Green , Blue�#���Z68���Z$��� Red, Green, Blue, Alpha�)���Z<>���Z,��� YUV colorspace� ���Z35���Z$�Ĩ Grayscale colorspace�&���Z9;���Z,���#  Grayscale with alpha colorspace�2���ZEG���Z$����Z���Z$���! Cyan , Magenta, Yellow, Black�0���ZCE���Z��� Blue, Green, Red�"���Z57���Z$��� Blue, Green, Red, Alpha�)���Z<>���Z<�� The colorspace is unknown�+���Z>@���Z$�ķ Alpha Red Green Blue�&���Z9;���Z��� Hue,Saturation,Lightness����~ Conversion from RGB to HSL and back matches that of Python [colorsys](https://docs.python.org/3/library/colorsys.html) module���2/ Color type is expected to be in floating point�����Z���Z�
�� Hue, Saturation,Value������~ Conversion from RGB to HSV and back matches that of Python [colorsys](https://docs.python.org/3/library/colorsys.html) module���	2�����Z�����ZuT��
&# Multiple arbitrary image channels.��
���
JG This introduces **limited** support for multi-band/multichannel images�� that can have n channels.�����_\ The library contains optimized and well-supported routines for up to 4 image channels as is���SP more common out there, but some pipelines may require multi-band image support.��
���
VS For operations, multi-band images are assumed to be n-channel images with no alpha���
a^ to allow for generic processing, without necessarily caring for the underlying interpretation�uT��
�uTuT���Z���������� ����Z(����Z���#%���Z�Z����
�,�(����Z��_�#%�����Z��^�^��^��[�^��[����e�S��������
�,�������Z���#�*,/18�;?A���Z����
��H����Z��Z���79����Z��Z����
�L������� Color characteristics�����41 Gives more information about values in a certain�t� colorspace����]�\���{W<������$�"��   Normal default gamma setting��� $! The float contains gamma present�� ��� *' The default gamma value is 2.2 but for���!85 decoders that allow specifying gamma values,e.g PNG,���!>; the gamma value becomes the specified value by the decoder�"���]69���]4�"��"#  Linear transfer characteristics���"%" The image is in linear colorspace�`���]su���] ����](����]���#%���]�]����
�,�(����]��_�#%�����]��^�^��^��[�^��[����e�S��������
�,���H����]��]���79����]��]����
�L����$��".+ Represents a single channel color primary.��#���#>; This can be viewed as a 3D coordinate of the color primary���# for a given colorspace���$�^�źo5�;���T�$�$��T�$�$��T�$�$��8��$��^���#%�^��
�(��$��^��_�#%�����^��^�^��^��[�^��[����e�S�������$�
�,�$�� ��$��^(��$��^���#%���^�^���$�
�,�$̎&��%=: A collection of red,green and blue color primaries placed���%'$ in one struct for easy manipulation�t�&�^�� 6e@�g�����&��& Red color primaries��&���^�'��& Green color primaries�,�'���^��'Į' Blue color primaries�$�'���^8��%��^���#%�^��
�(��%��^��_�#%�����^��^�^��^��[�^��[����e�S�������%�
�,�%�� ��&��^(��&��^���#%���^�^���&�
�,�&��*��'XU Rendering intents indicate what one may want to do with colors outside of it's gamut��(��(���( Further reading���(c`  - [IBM Rendering Intent](https://www.ibm.com/docs/en/i/7.5?topic=management-rendering-intents)���)TQ  - [ColorGate Blog](https://blog.colorgate.com/en/rendering-intent-explained)   �|�*�_�֝�/V&��������������*���_���_T�+���_���_��+���_���_T�+���_���_��*��_���#�*,/18�;?A���_���*�
��*H��*��_��_���79����_��_���*�
�L�*��(��*��_���#%���_�_���*�
�,�* ��*��_(��*��_��_�#%�����_��^�^��^��[�^��[����e�S�������*�
�,�*�̼� d��`c�Э��ט����������������"�������"|������"�������"|������"l������"l������"t������"d������"l������"�������"l������"�������"�������"����� ����`(����`��_�#%�����`��^�^��^��[�^��[����e�S��������
�,���(����`���#%���`�`����
�,�8����`���#%�`��
�̂�� Decoder options�����:7 Not all options are respected by decoders all decoders�!t��bS2s5�����������L�����j��!T�!����jԧ$t�$����Z��&L�&����j��&l�&����j��',�'����`��(T�(����T(����b��_�#%�����b��^�^��^��[�^��[����e�S��������
�,��� ����b(����b���#%���b�b����
�,���	'd�	��c; B�[������	��	�����	��	�����	��	��� ��	��c(��	��c��_�#%�����c��^�^��^��[�^��[����e�S�������	�
�,�	��(��	��c���#%���c�c���	�
�,�	8��	��c���#%�c��
���	��-	* Options shared by some of the encoders in���&	# the `zune-` family of image crates�(t�	�d����~B����������	,�	����j��	4�	����j��	T�	����Z|�	<�	����v��	,�	����R|�	\�	����v|�	4�	����v̺	,�	����c(��	��d��_�#%�����d��^�^��^��[�^��[����e�S�������	�
�,�	�� ��	��d(��	��d���#%���d�d���	�
�,�	�k�r�s	�tju�

�u�
$�v)�
/Tw4�
:�w?�
E0xJ�
P�xU�yZ�y_@zd�&
j�{o�}t~y��~�����
�������������݀�8����x�����������������͔�@����˚�
��ŸS�!�"�X)�/�\6�<�wCY�I�O�V��\�c �i�p��v�}���������Q��������$���'�����,�,���.�����0�`����������5�����	�Z���"�)��/�
6J�<��B�I��O��U��[N�a��g!�mղs��y;���I�����������ט�����������w�����[��r��������‡�u��Ά�Y~�n}�|	�z
z�ybt!�q'Lp-bo3�d9d?�cE�cK�bQ�bW�c]EbcKbi2\os[uy[{.\��Z�jZ�pZ�W�BV�HV��V��U�9U�?U�lQ��P��P�hQ�/P��O��O�fM�lM��L�zL��K�KvLKAJI#9H)DG/PF5�E;�DA�CG�BM�AS�@Y4@_�?ej>k�=q�<w�;};��:�y9��8�n7��6�6��5�o4��3�`2��1��0�{0�J/�g.�'-�h,��!�� �� ��![ �
����%�+M1S7=C�I�O3U9[�a�g�m�s�y�����n��%����
�I�O���
�t	�z	�1
�	�����B��03h������������������crate::bytestream::ZCursor�,�crate::bytestream������������)����BitDepth::size_of��)��������)�������*std::io::Read::read_exact���
Self::seek�
std::io::Seek�std::io���
std::io::Read�Self::read_u8_err�Self::read_fixed_bytes_or_zero�Self::read_fixed_bytes_or_error�std::io::Read::read��	Self::eof���������������������������������������������������6��,���std::io::Cursor�7crate::bytestream::ZByteReaderTrait::read_byte_no_error�Seek�����Cursor�#crate::bytestream::ZByteReaderTrait���Self::read_exact_bytes��
std::io::Seek::seek����������G����
������������������������
������������������������	Self::write_all��������8https://blog.colorgate.com/en/rendering-intent-explained�colorsys�/https://docs.python.org/3/library/colorsys.html�IBM Rendering Intent�Dhttps://www.ibm.com/docs/en/i/7.5?topic=management-rendering-intents�ColorGate Blog�������������������������png::Transformations::STRIP_16�png�:https://docs.rs/png/latest/png/struct.Transformations.html�png::Transformations�����������������	get_quality�
Self::quality�����������������H���������������I�I�I�H�J��������3��������H���������������I�I�I�H�J��������3���������H���������������I�I�I�H�J��������3����������H���������������I�I�I�H�J��������3���������H���������������I�I�I�H�J��������3��������H���������������I�I�I�H�J��������3��������H���������������I�I�I�H�J��������3Unknown bit type���N��+e�g?�f껺�꽉����((@��0��p
N�k�&���ׁ�w����NQ�s��'L��/����l|�/�G
��8r['���
��������c;��pM��臷��S������U�r�>9��LEWor6��J�W܌�$��(d�"Kad��`�Gq������J����*L<�*�͏}�,N��4�*�~LR��~�� o��%�T���YX�(���yQ��~�b�8_�̿o'O]^��@��4�����~>�R�b�e�����$s���/Ⱥ�����&4��h��aah�/��+2t%��g��r��'\�aHF�����S<Doj*��E^�W�,䬴�&
�T�ڲM��hOeG��{���0�>��7��&��M��� ׽���l%���L�G{8mMWR���7Ro/���	�V�Hr��P��Q
3�a��K��d���\�c�LM�� �5AD�`���k����\���!�$'՗{�q���ȬX��u���DƩf����Ln+Kކ�}��%��"ׅOs:v7��՝�F�J�1��˽�d�������^F��K3�鏣���b����@�f���i�T��Û�=L�����}��>;����ois��0�5M�+m�*�a�jg� fnڥ_:�ͤ=�9gʡ�3ۮ.����]��C۸yy�
�"�(V��G��?A3���A�b	�H�¤7Ǽ����J���

�0^t�9`�&��*LT�����bO�{6 |�q�g�	<��³vT{p�|���I�SV�����E��{d#E\����B�>ϡ�i8�s�����GL!J��T`��B��?��0N>��t�K9b!�Ѣ$O�C2��B~.]�n!�['�4xw[SAL
'�-ٙ���w6Le�n&��A,���-��>d�M�4
�r{Q�Q/0P�D���
��ǵ��OB�T���{ԗ�Y�m��d�ж�`[�A�ΌȔ@u�o��xb����Ӗ&-5 1�\�Y9�H��L�����ad�(C�e�Y�\y���%�]�d�g\�S@���?0!6״dZ��]�M�g!:�PBccǃ�5������"��
Թ^J�Af����8/%�Np��D�
)=�JbS�ZR�V��f���:�����FM���i�f��(|��r_��R�)PDi�T�	
�H$H�a�}���x��=(�椸��T��~I��5d���KC����A Ԭ *q�c��뱏,�G�Tc����Z:t]+<{h�KJ(
��	�%�R��M���%�vV�"�E�+�h��$C���гΥC��?��@F�B^��@h4Uͫ��1�C�}��U�.��!E�oܽ�Ǽv����:r�C:i$��C�*!K�D��-Þ�%�Z�7�h���z�Ƴ��tX�I+G�K-]m��J�WEW?������k_nh�@�4�(�kmv)m�@����W��eͽ�?�q����3M�?��U��M�u�=�QY�a�Of[�y8��U�ZA�`H��f�t����{ԲC�{���Oh9w5�:3���^��}8n��Jb���!�������~�C�-e9t(	�y��Z�׍��붭G��:�"��E��������	��S�<ٺ��?�����1��ȩ����{�_a�Ը�,'�����=ˡN;���d��[�c��R��/��}�
j�-u"�$���	��n�|o�X"l���+ҽY��p΢��$BrB�B�&f��9��;�;�T�Yf��[řm��V�42q���&❡���1!F��h��&�j�%r7���!��V�v*ű?�+����b��f#h��~�6��7uʞu.�M$*��	*
�n}����g�Oo`"<<����~���A;���Q��2LtOyǩW?���|I�F���Ǖ��;����7"�5rl�%Xuֿ��:1�Y�_�?���"�ۢH���Xh^����M�{��F�[���ҠH}ݨ2NZR�%��*=j5��E��)>��^��b`%:�(�zjVI�m�*�,���	a��FmD����M��
oAc�z�������>���mZQ�A�D�d��H��3��q"j�a@�`횪���s�N���ODŽ���T �)Gi�ٱ��lJ���d+��C�P��g�N�O��e)L�Ӧ4��eYi�$��Dhp��V(Vz�"����K���w��O�;�y���G&�zo�&�WTR͕�ѐ����v��]H�B��C�4�PbM�K�`�3/�D�JGV�w��8n��T���d���sO��\�"��J��g��R��#��I���䔖��A�����p�{��k�@�eg��y��E�Z���*I� 
���y�����g�[s�vx����Eϭؘg'��v��V�A�uW�_�5q�;��#�RU�i|�;yN��f�k������1�9�����aJ�M[Z�"������ؽ�1P�z�DbQ���q �Fv2��$��ݓ��W#A�R¯d��)���Ƞ8�`Ni��q��t�tщ�� ��`~g9&O���������nb0�T���X���I1�aZ��Ԓ�Π��i<ね=E��:�n�:�q"�\@/��Bo��w��ϯ��VA~rgK��R��-�u~�mp=S�sl�
�N�/�#Q��e��$\��rֹ^�ɚ���0��&��ima��
9�©���Yn����Kln	w���}��nr–�O��z���ɧ��#R�!�o����$@�ɭy"�A�|艘��lL�x��! Ĝ2�G�f�z��K��x.>�%�v�I�⏒�d!��S�oj�U���7�uQ�2��ZC�b�É0�[']8��UqVx@��x���vd�Gy	��ŚAV3�BЄ��Z�8=�!>\�Y�I��c���m��^[	)����p6���*X��|����j�Ƙ��@<ˊ]hɡ8�L��y_�3���vٰ��ʃjI����0gLJV���$�y����6���*�"HI��[h��U�����\xo���Ù��^�<�¿�c�˫ܤ���`O�X���fb
b��Z-E�PGdՊrY8$�	�h�S����ߥ0���5*�x�{#hY-�Oo~w����H��~���$t���r��Ş�j��Ey`�5<J��юª����
��A�%dNJ֖=�:v��$xƚ�0~��ږk�=���۪7O��mѿg`U3���A������y`�s��t���,�$�δM%���B�K�ʂ6C�{��o�3o~	�|���3h�[T,z�D��-�k�Pd�_m_��rB��>
IQ�P�܌�ռh� ��s-���`vߦld�k���nP�d���v�̗!�1�j�W��+-��y��n�m����E����!��g�qv&V!���􆨁}�%V���-YA;	Cp_k|���$)8A�PS]������Xm�"[�\��Jom>���zϛ���%�� �{�d_Y�Ã�u}lv�����LT�g�C�1e��x�3�ۤ�C�l1�﷟E�� ���"�`j��E�9���+P��ឱ�zy���S���Z7"�����8��� u3��r������g:�W��@퓣�wS��,<=��ف�B�70p���������?�������h��U��<���g��Fo�H@�/���q��h6>��(3�iaQ������X莦nE�������h_�E��i&��@�x%�2����H�5�5�B����O��v�"�xnY�wi�����	�TX̳x��g�M�s���!����j���?M�9�
q�cu,��:�ف�mf�qs��Jh�|�=4D/XPv@k�S7����M����P&T��;��A�.I92�j�
!+�J�jvv`��̕����'(�xʟm���Uˍ���tt=��k�0e��Mٮ��ȼ�P�%Ark̓R>Tֶ�J�/��k�`��P�3v1"�P�Xx��"��n����C���<eU_�@@ة�,�8�T�	\ɲ.�;�?�N
������N3���{l��U=��UT�D�Co9ʗtm��fRb��;�nM �lU�D�9
l��LC�:�y���{;�#�d��d�3����+j�3�F>�<�G�eq�U�=�F�@������o�sˊ]Nw�%�Jw��W�ǟmo�Sv�_ݸ
y���eQ�w����"3��M!�QU��Vl�#���‹)H�RN����(��0�\+-�{��x�)V�=a�1�7SSQ�Ǭ���}���V��r���jd�gl'vtC5����Cy)d�+Ŀa:lŧ���Nm�pI�<��b���O��L0��w�Y�G���ƒ���,7daK\�o	TLk	�~TL��~��'��r@8��8��E�̻/e�cbړ���	2h���J�o>�"+gKҷ(�*�ȭ��T�Vd��
��q]B�Hݥs掁0"'�y�/��Jig5v�z%������šJ��f�Cy����	ʋi�{�s���:�t���!R��l�#:�g(g��eb��0�w7J�ǂ���/d��m���[d�z�n�)dȮxj�G�ne4�`xlJ��7�M�h�;H���V�"e��������iSV���>�W�9�8Kj�z������Y���柒$��x�E��.h�eUM�Ң[�Ovg�3���Q� � ɲ���5Ӿk糫OQ6��t�MW��@bLS�$����Z<��ڡfA='W�xch���5&Y
��d;��1J�V�c9}%�G��4 C��2��`�����T5Q]̢����
�X˘ ���J+�k����QR����!�F������1����w�~�n���œ��7�ǫȥ7J�[�1�G}3�@�ym�ww����N���6u���n�ڻ,�Fog��~3���EXn���b"��`��|����a��'n�(�mʉ�9�0s�����R�z���$$�]*?��`g.��}�Ġ}XM:�|�x<���M�n,}}�a��0�ĕ�-�&lZ��d��F�`{2������b��V%�.�6{t3�:�+��
���n�W���� �ћ0.�Jl�<��څ�K��g!��q�CA�
�� �X0ss�Ʋ�6����%�\�]������&�k�=T�ߒ
��o`7����c���R����R��]�����K�����,�$K���3�KZ��>;E��6Y/��ry�o�Q@P����E!`MN��E��G���MG/�*�}�ۚ�����5Q�����%S�"k��6�A}����5kN�������$E�ઓ#�CՓ���
k�7z���tص�i��\>��M�)�#R<�ʲ�I0��W?����@"��>���Ak�O�aH�q�lm�ހ�b�f�׺ư�V�*6�#;�����:��Æ�˓n�N���5�<x��6�D�[�)3n���_�]з�$�X���6K���ϕ}|�Z�[������DͩcT�෈�PF���!F����
zf)���G�
�I �i6o�I��G'Q�@�E�D7�x��$4Y��9*�u���zY��,M�6���
�5Q�W���w��� �˻]�-��G���[���?�#c(꽒/�Y�(_�*���M3G�X��Ǡ��EhSY�5�o�K��W�8 ~���F��G1����I�2	�ɔ5_��*�~_BV�/G�2@�̚��xy��{�Q�dk�G44m�\�`�����c�Wh]�G�~�+m��Ғ��M���Q��D�e�`��3��?`�G����[��4Bq��s�\�Y(>-���8�&���H��;i��4�vޝ��3�%p����d\e�Gd�{#�,X]�9d(n
ƸAqy�Y=dS��Ka�џuVT?��p�01|�?]PJs����j2]�q:��R:k�0��װ�u����p�M�4�0KEY�����Psy�`�!ͅy�W�'��zE��)�Zqk^�P�t|}i�������K͌�z�x���A����!�-3ޘ)�M{;�%m$V�������[=�%A+�����
�/���qQ���0�"7+����Iv���<Q9�;���"�}��z��=9|KIK�'�,5�̨45K5"����B(�)��N��5[�a�,Ґ�&��
m�u31)H�+�Q�:��.����~nv����������;!�kG�A4g{�ӬJ��T���"�z�&�@��Y�xu����Y��4�Dߛ%����MB{P�a �V0��n��9�)��N�����@u��,:�x0�U��F��ײ"%h�/
S��T	¹���zr+P-X"�_LZb��z�ŦrG쫼R�T]>TOt؄�f�
B�SbV�9%-
���4��y���3f?��e�13��X���r�!�N=�
o��s��++��Xb�%��7%�m�j9�ڐk0}|
m�����'Q]!�/�"��KJ�_��k{�i�'m ���6J�5�5�ͷ���ºUԛ�4ˁ��'b����D����,�	v-'��֛��Y�Ο����r�<7������6�Q�I�MK?s���\ �~j�Y��Q�8�y�@!Еe?�s���ُ��e���+��Ʉ��7��lXLӷi�����%ey�Ŋ� �4N:�r�l��(�'eSb���@�����ֲ6��ʵ���Us��j'��/�S�������(6?)�ִVL�{�z՝4�5<�\d����c�k����#�@E����`�05�k�za��=(�
6�U�`ڜ�GM�w�>e����M8������QRI�9�!�ʪ��� N�W[
��˕h����L2�f@f:{���Eݩ���kR�6�`�3�U�޸��[*�����ߗ�y��F�7|�����K٣훜R��6g�R#X�F�wo���J�����W�$��8����=�),�&��m����M#z|�Q%c�аd���>j��xB� K��O,
��N�=�����5��w�A?�l�wO�hA��ķ�8.�H��Dy�r%���.J]�!2\�8�O�Z}̊��F/plic���QO�)�½v﹯�=��C"�g��4
}Z��"�Y��-��k%0����֊��DI4Gb��Ɂ�"�iIu�2J�^��|!'�Y4hU^��L~.4�&��������]��p1�-��1�$'���?\
�Ѓ��)�����#|�j�EoTn(�vpmRX/���%�'��9`9�f��a[4cJ�~Q�~&3P��ۋ��-i-��~�0����RJ�����xSZ��C���I���������������������*	^�^9m�m\nC|�������3�F�'W�^�_b`ba`bc�cUd�d�d/eIeze�e�h�k�k�mTn�n;pSplp�p�p*q�r�s~t�t�u*v�vxw�wTxy�y�ygz�z�{�{;|�|x}�}8~�~Y�5����R���.���������F�Z�����p�����%�:�N�����b�v������*�G���������>��������.�����A�
���]�K���F��
���p�G	�&������-�v�>����
��w�+	���]�����.�w
����J����S���~�����D���/���6�����Y����������t
��
�!�3���9�.���i�G���{���"m�
ZZ����	�
�c9
�v��
q�G
�[�U��o����� �!�"#\#$�$�%A'U(D)5*$+
,�,K-�-�-b..�3�3�3"4g4�5r6b7�
7A:�:-;�;"<�<�=J>3?{?�@�A7CjC�D�EeF�FzG�G�G7HNH�H�H�H�K=N�N�N,OkO�O�OPPnP�P�PQ)Q�Q�QZRxRS�
TVVrWX�X�X�XY)Y�Y�Y`ZsZ�Z�Z(\�\^]�]�]^f^�^1_O_�_�_�_R`qa�b@c�c�c�c%dCd�deze�e�efwf�f�f/gEg�g�g�g�g�g[hyh�hiSiqijrj�jk�k�k�l�m�n�oppp�pQq|q�r[sUtOu�uv2v�v�v�w�x�y�z�z_{�{�|�}
�����!��<���O���B�n�W���_�����_��������*�����K������
�~�������!�@����|��������-�������Q�p��3�R�������������1�P����6���*�b�������*�I����/��-�l�����+�J�������S�r������������#�>�Y�t������������1�L�h�����N�m��������������6�Q�n���<�T�s�����
�'�C�[�z�)�H������������������*�E�b���0�H�g�!^�^�d4m�m[nC|�x�����O����=�����3�F,G^
NsT\�b/f�������d;e�e(p�pqt�z�{}��(�9�J�^�r�������6�������E�����X���Y�t�M�U���@�<�J#>(|-n.�3.4[C@GUGjG�H|N�N�N�N�N�OP~PQQ�QjR�T�T�T�T�X�XY�YpZ�Z\\$\�]^v^A_�_�_�b�b�c�c5de�e�eCfVfif�g�g�gkh�hciLj�o|u�z�(�)�1�9�A�I�Q�Y�a�i�q�y�����������2��������������b�0�D�����B��(� ���;�	�!���!�)�<�����d�������y���_������M�e���T�l�:���t�s�A�Y�))))))'''''''(()(()'''(((((((((((((('''





((((((((((((('(((((( ^�^�_�`�a�b7c�c�d
e^e�h|k�k3m�mYn�o?pWp�pnr�s�t�t�u?v�v�w�wixy�yz�z|A|�}�}M~�~n�J������C�̂����'�H������'�O�r���܅�'�<�����Ɇ�C�d�����Ӈ�\����������č��������̕��G���^���/��ˤ,�����ۥ������S�5���[�����]���*������������:�;�c������D���K�����]�������I����������~�����@�����1�����0����o���	�
���
�9��?�f�c7�Y�H� k!E"�"�#�$�%'
)�)�*�+�,-�--.k3�34�556&7�7:�:�:t;�;i<�=>�>H?P@�A�BsDcE4F�FGG�G�G�GH9HSH~H�HzK�MCN�N�N�NO0OVOoO�O�O�O1P�P<Q�Q�RZTVAV7W]W�WXKXqX�X<Y#Z�Z�[�\�\#]I]�]�])^�^~_�_Ja�bc+cec�c�cVd=e�ef|f�f�f�fg1gJgug�gh�hi�i�j�jk�k�lm{nuo pup�pVqIrstu�uvGv�v�w_xZySz�zt{�|}�~s,���Ё�����d�ޅ��I��Њ‹�$�J�}���܌�G�m�������J�p���Ҏ�6�o���������Ñ1�\����S�=�–�����������e�i�����ǜ�c�I��M�����	�\�B��1�W�p�����գ��y����������'�B�]�x�����ɧ����5�P���������Ϊ���:�U�����ɬ���+���[�̮V�����¯ݯ���.�I���z�~W�^�^�^�^�^Z_`_f_l_r_x_~_�_^`^a\bc�cQd�d�d+eEeve�e�h�k�k�m�m�m�m�m�m=nBnGnLnQn�n�n�n�n�n*p7pOpgp�p�p�pq%q�r�sltyt�t�uv%v�v�vsw�wOx�x�y�ybz�z�z�{�{�{8|�|�|�|�|�|�|�|f}s}�}3~�~�~LT�0�����N�ց)�����������B�W���ۄ��8�l������!�6�K���Æ؆,�^�s���͇��%�B�����݉��9�Ӌ�����s���*��ߏ<���X�F����9�A���ڟk�B�"�����ӥ��(�d�q�2�:���ٺ޺����r�&�����P�X�����)�r����F�}��N�����y�����������5�:�@�����*���)�1�����U�q��������������b�o����.���,�4�)�|�e�C���w���h�HV�IOU����	�
�^4
�q��l�B�W�P��j����� �!}"#W#$�$�%='Q(@)/*+,�,F-�-�-\.z.�3�3�3�3�34b4�5n6]7�7<:�:(;�;<�<�=E>.?v?�@�A3CeC�D�EaF�F�FwG�G�G�G�G3HKHgH�H�H�H�K9N�N�N�N�NO(OAOgO�O�O�O�O�OPiP�P�P	Q'Q�Q�QURvRSS�T*VRVHWnW�WX\X�X�X�XY'Y�Y�Y[ZqZ�Z�Z$\�\�\4]Z]�]�]�]^a^�^,_M_�_�_�_M`ma�bc<cvc�c�c�c dAd�deue�e�eftf�f�f�f�f+gBg^g�g�g�g�g�gVhwh�hiNioij_jlj�j�j�j�k�k�k�l�m�n�o�opkp�p�pLqbqvq�rVsPtIu�u�uvv,v�v�v�v�w�x�y�z�z�zY{�{�|�}����������6��;�H�…;�g�P���[���Ӌ��5�[�������X�~������&�[������!�G�������ѐ��ԑE�z�����͔�>���v������˗�)���™ڙ��K�n��1�P���������؜��+�N����4���&�^���џ��$�G��
�-�{�)�B�h����������%�H���ʤ�M�p���֥�������9�T�o�������ۧ���,�G�b�z���H�k���ܩ���ƪ����2�M�h���6�N�q����	�#�=�U�x�#�F������������կ��&�A�\��*�B�e���������Ʊ˱ѱֱܱ����������
����"�'�,�1�7�<�B�G�M�R�X�]�c�h�n�s�x�}�������������������������òɲϲղ۲������������"�)�/�6�<�C�I�P�V�\�b�h�o�u�|���������������������³ɳϳճ۳������������ �&�,�2�8�>�D�J�P�V�\�b�h�n�t�z�����������������������´ȴδԴڴ���������
����"�(�.�4�:�@�F�L�R�X�^�d�j�p�v�|�����������������������ĵʵеֵܵ�������������$�*�0�6�<�B�H�N�T�Z�`�f�l�r�x�~�����������������������ƶ̶Ҷض޶������������ �&�,�2�8�>�D�J�P�V�\�b�h�n�t�z����������������^�^�^�^d_j_p_v_|_�_�_�`�a�b4c�c�d�dIe�hgk�k/m�m�m�m�m@nEnJnOnVn�n�n�n�o,p;pSp�p�pqYr�snt~t�t�uv*v�v�vxw�wTxy�y�y�z�z�{�{=|�|�|�|�|�|h}x}�}8~�~�~NY�5����ہ.����������F�����߄$�;�p���م��%�:�}���dž�/�b�����ч�G�������Ջ���u��������������}�2��˛;�I����֢��(�����٥��f�v�6�����P� ���F�����R�o�H���������������%���&�N���������8�>�����/���+�6�����[�s�����E�������d�������i���.���+�������{����m���MSZ���	�
���
x$o�*qQ	�N"�D{3� V!0"�"�#�$�%�&�(�)�*�+�,�,�-.U3�3�3�3�3�5 67�7�9�:�:_;�;T<�=>�>3?;@�A�B^DNEF�F�FG|G�G�G�GH7HPHjH�HeK�M?N�N�N�NO.OCOmO�O�O�OP�P)Q�QxRSVTV-V5WJW�W�WIX^X�X)YZ�Z�[�\�\!]6]�]�]^�^k_�_5a�bccccxc�cCd*e�efyf�f�f�f�f/gGgag�g�g�hiqiajrj�jk�k�ljmfn`o�oppp�pQq4rs�s�t�u�uv2v�v{wJxEy>z�z�z_{�|j}�~^��������׃��=�O�Ʌ��4���̊��Ջ"�7�{���ڌ�E�Z�������H�]������#�m�����������.�H�~�ϔ@�*�������������p�R�e�����Ü��P�6���I�������I�/�ܢ/�D�n�����£��f��r��������#�>�Y�t�����ŧ����1�L���m�ީ{���ʪ���6�Q���s�Ŭ�
�'�z�H���R�������ٯ���*�E���g�������ıɱϱԱڱ߱������������� �%�*�/�5�:�@�E�K�P�V�[�a�f�l�q�v�{���������������������������Ʋ̲Ҳز߲������������&�,�3�9�@�F�M�S�Y�_�e�l�r�y����������������������Ƴ̳ҳس߳������������#�)�/�5�;�A�G�M�S�Y�_�e�k�q�w�}�����������������������Ŵ˴Ѵ״ݴ���������
����%�+�1�7�=�C�I�O�U�[�a�g�m�s�y������������������������ǵ͵ӵٵߵ��������	����!�'�-�3�9�?�E�K�Q�W�]�c�i�o�u�{�����������������������öɶ϶ն۶��������������#�)�/�5�;�A�G�M�S�Y�_�e�k�q�w�}����������������de7ene�e�h�k�k�o4pIpap�p�p�p�p"q�r�s�svt�tnu�u�vXw�w4x�x�y�yDz|z�z�{�{�{%|�|p}�}~�~#�����<����|�������9�Q���҄�0�c�{�����0�E�����҆$�U�m���ć܇���2�o���ˉ�'���݋�
�1�}��؍��єD��Ϛ���ƟW�%��4���˥��D�n����h�]����$������U�����(�'���0���d���[���
�~���s�����i�������`������+�l����������h�?�/���c�U���Q���	�
�8!
�
�^��S�){D�=��L�m�m� �!j"�"F#$�$�%$':(/)*
+�+�,4-x-�-A.j.|3�34*4�5[6L7�7):�:;�;<~<�=,>?]?v@�A CWC�D�EHFG�G�G�G�G)HCH]H�H�H�H�K(NJN�N�N�N�N!O:O`OyO�O�O�O�OPXPzP�PQQsQ�Q>RfR�RSaT#VKVAWgW�WXUX{X�X�X�XY�Y�YJZlZZ�Z�[�\�\-]S]�]�]�]^P^r^_=_�_�_�_6`\a�bc5coc�c�c�cd1d�d�dde�e�e�ef�f�f�f�f!g;gTg�g�g�g�g�g?hgh�h�h=i_ij6jij�j�j�j�k�k�k�l�m�n�o�opLp}p�p-q^qnqrrAs;t4ufu�u�uv$vtv�v�v�w�x�y{z�z�z0{�{�|�}�~���]�р��ۂ�҄�E����F�/�u�:�׊̋�.�T�������Q�w��������T�z���܎�@�y�����ʐ��͑;�p�������
�.�ҕ��e�����������"�����ՙ�:�^��,�@���p�����ќ�!�>���$�q�	�W���ʟ��7�۠��j��;�a�z�����ߣ���8���Ť٤6�`���ѥ��������3�N�i�������է��&�A�\�u���1�[���̩�����ڪ���+�F�a�{��I�a���Ҭ��7�P�h��6�����ݮ]�����ί���:�U�o��=�U����de1efe|e�h�k�k�o.pApYpnp�p�p�pq�r�s�spt�tbu�ulvLw�w(x�x�y�y8ziz�z�{�{�{|�|j}�}~{~�	�w�Հ0�c��p���؂���1�I���ʄ�(�[�s���݅�(�=�����ʆ�M�e�����ԇ���,�f���‰����׋���w��ύ���ْĔ7������{���J����.���¥ݥ�/�h��O�T�P�����	�������H���������#�i�W���F����q���f�����`�������K��������f������������[�2�&���V��H���Ky���	�
�2
�
�Q��J� r7}0�|C�d�`� �!]"�"@#�#�$�%'4(")*�*�+�,&-r-�-8.d.s3�34$4�5N6?7�7:�:;�;�;u<�=#>?T?i@�ACQC�D{E?FG�G�G�G�G H:HTH�H�H�H�KNDN�N�N�N�NO1OWOpO�O�O�O�OPJPtP�P�PQeQ�Q0R`R�RS[TVBV8W^W�WXLXrX�X�X�XY�Y�Y<ZfZyZ�Z�[�\�\$]J]�]�]�]�]B^l^_7_�_�_�_(`Ta�bc,cfc�c�c�cd+d�d�dVe�e�e�ef}f�f�f�fg2gKgg�g�g�g�g1hah�h�h/iYi�i!jcj�j�j�j�k�k�k�l�m�n�o�o�o>pwp�pqXqeqdr3s-t&uQu�u�uvvfv�v�v�wzxtymz�z�z"{�{�|�}�~���O�À�͂	�Ą��?����7� �f�+�ъË�%�K�~���݌�H�n��������K�q���ӎ�7�p���������đ2�g���������(�Õ��V��������������ϙ�+�X��&�:���j�����Ȝ��8�ӝ��b��N�����ޟ�1�̠���[��2�X�q�����֣��2�����Ӥ'�Z���˥�~������*�E�`�{�����̧���8�S�o���"�U���Ʃ������Ѫ��"�=�X�u��C�[���̬���.�J�b���0�t���ԮW�����ů����1�L�i��7�O����d e9ere�e�h�k�kpMpep�p�pq�r�st�truv#v�v�v\w�w8x�x�y�yHz�z�{�{)|}�}~�~�~/R�����@�����������?�U���؄�4�i������4�I�����ֆ(�[�q���ʇ����4�t���Љ�,������C��ݍǏ$��֔I��ܚ��$�?���˟\�*�
�6�����V����b�
�����1�V������Z�����-���5�����i���r�����/�x�����n�������y���
�=��������2��m�D�4���h�
\��S����	�
�:(
�e��X�.�K�D��Q�r�t� �!q"#H#$�$�%)'<(4)#*+�+�,9-z-�-H.l.�3�34,4�5b6Q7�70:�:;�;	<�<�=1>?b?}@�A'CYC�D�EMFG�G�G�G�G0HHHbH�H�H�H�K-NLN�N�N�NO&O?OeO~O�O�O�O�OP]P|P�PQQxQ�QCRhR�RcT(VPVFWlW�WXZX�X�X�X�XY�Y�YOZnZ�Z�Z�[�\�\2]X]�]�]�]^U^t^_?_�_�_�_;`ba�bc:ctc�c�c�cd3d�d�die�e�e�ef�f�f�f�f(g@gYg�g�g�g�g�gDhih�h�hBiaijJj�j�j�j�k�k�k�l�m�n�o�oQpp�p2q`qsqwrFs@t9uzu�uv)vyv�v�v�w�x�y�z�z5{�{�|�}�~��b�ր����ׄ%����K�4�z�?�يы��3�Y�������V�|�������$�Y������E�~�����ϐ��ґ@�w��������0�ו��j�����������'�����י�?�`��.�B���r�����֜�&�@���&�v��\���ϟ��9����o��@�f���������#�:���Ǥۤ;�b���ӥ�������8�S�n�������ڧ���+�F�a�w���6�]���Ω���Īߪ���0�K�f�}�$�K�c���Ԭ�"�<�R�j��8������_�����ӯ�	�$�?�Z�q��?�W���e_e�h}k�k�o�por�s�t�t�u@v�v�w�wjxy�yz�z|�}�}N~�~o�K������D�����(���P����D����]����������������������H���_���0�����.������6���\�����^���+�����������;�<�d���E���L���������J�����������A�����2��1��r���	�
���
�:��@�g�d8�Z�I� l!F"�"�#�$�%')�)�*�+�,-�-..l34�566'7�7:�:�:u;�;j<�=>�>I?Q@�A�BtDdE5FG�GHH{K�MDN�NOWO�O�O2P�P=Q�Q�R[TBV^WXrX�X=Y$Z�Z�[�\J]�]*^�^_`Ka�b,c�c�cWd>e�ef�fgvg	h�hi�i�jk�l�m|nvo"p�pJrst
u�uIv�w`x[yTz{w{�|�}�~t/�����������g�����J������K����n����q���7�������]���T�>�����������f�j��d�J��
�]�C���X������z������������������������\���W���{�e_e�h}k�k�ppr�s�t�t�uBv�v�w�wkxy�y
z�z|�}�}P~�~p�L�����E�΂)�(�:���L�P�`��s�����D������]������ƍ��������Ε��J��`���1���ͤ��7���^�����_���,�����������=�=�e���F���M��������������B�����3��1��r���	�
���
�:��@�g�d8�Z�I� l!F"�"�#�$�%')�)�*�+�,-�-..l34�566'7�7:�:�:u;�;j<�=>�>I?Q@�A�BtDdE5FBG�GWGHlGH{K�M2P�P=Q�Q�R�X=Y$Z�Z*^�^_`Ka�cWd>e�eEf�fXfgkfvg	h�hi�i�jk�l�m}nwo#p�pKrstu�uJv�wax\yUz{x{�|�}�~u0���ҁ�����h����K����]��T�>�Ö���f��d�J�
�]�C�z�����������������\�ͮ��{��dMe�hkk�k�p]r�s�t�t�u.v�v|w�wXxy�y�y�z||}�}<~�~]�9����R�߁2������>����2���	�K������������������6�ϛM����ڢ�����z�>�$���J���s�L��������������)�*�R���3���:���u���������m�����/��	��� ��q��^���	�
���
|(s�.uU
�R&�H7� Z!4"�"�#�$�%�&�(�)�*�+�,�,�-.Z3�3�5$67�7�9�:�:c;�;X<�=>�>7??@�A�BbDRE#F�GHmHiK�M�NOEO�O�O P�P+Q�QzR0VLW�W`X�X+YZ�Z�\8]�]^�^m_�_9aczc�cEd,e�e�f�fdg�g�hisivjk�lnmjndop�p8rst�t�u6vwNxIyBz�zc{�|n}�~b�������ۃ��S�ͅ��8���׋9����\����_���%�������K�єB�,�������r�T���R�8���K�1�F���ģ�h���t�����o����u�|�J�����i��)K*�*�*�*I+,G,�,�,�,T1d2({(�(�(�(�(�(�()!)+)5)@)M)�)�)�)�)�)�)**)*3*>*�*++++5+?+�,�-�-�-.
..V.`.j.u.�.�.�.�.�.&/0/:/D/�/�/�/�/�/�/�0�0�0�0@1J1^1�1�1�1�1P2Z26p�p$qxt�z�{r}ߋ�p�����n�Skjp�u�z�G�)7�9<.RxR�RSjS�S�S�AD�D�ELG�G�G]H�HI|I�I:J�J�J\KL^L�L!M�M.N�N�NHO�OP�P�P�T�U\V�445JQ�Q�Q=|=�=A>�>?n?�?3@�@�@bAsTh9�;=wR�RSiS�S�SrTD�D�EKG�G�G\H�HI{I�I9J�J�J[K�K]L�L M�M-N�N�NGO�OP�P�PIQ�U[V�V35(7�Q�Q-R{=�=@>�>?m?�?2@�@�@aA�A�T�h�k�k=�քg����Y�ȇZ�&
�
cIB��r�!o"#$�%�-F.`6�7.:�:;{@%C�D�E�G.H�H`a�f&g�gu��G,5t=�=9>�>?\?�?!@�@�@ZA�A�G05x=�==>�>?`?�?%@�@�@^A�A$eve�h�k�k�p�r�s�tyu
v�vcw�w?x�x�y�yOz�{0|�}#~�~<� �����G�"������y���1������,�����Q�&���2�����d�2��"�k����@������c�����6���>���r��������������"�����u�L�<���p�a�����	�
�-
�j��]�3�PI��V�w�y� �!v"#$�$�%.'9)(*+,�,>-�-M.�34�5g6V7�75:�:!;�;<�<�=6>?g?�@�A,C�D�ERF�K2NbP�P}QHRS�X�YTZ�ZZ^_�_@`gad�dne�eIh�hGij�j�k�l�m�n�oYp:qrNsHtAu�u�v�w�x�y�z={�{�|�}�~�j���	���$������S�<���G����o��D����+���{�$���t���@�����;����)������������~�3�^�^�d�d/eze-m�mTn�olp�p�sgz�{;|�|�������"�ׅ{�����*�������&���ץ-���N�
�����D���Y���C�����0{>#2(p-b.�3�3"4OC�FGzG�GNH�H=N�N�N,OkO�O�OPrP�PQ�Q^RTTV3W�WGX�X�XY�YdZwZ�[�\]�]�]�]j^5_�_�_�bcac�c�c)d�d~e�efwf�fEg�g�g�g_h�hWij�oOu�z���ʊ�� �y�،C����F����k�����,�����%�����������̙�U�#�7�c��5�����۟.����ڢ-�l����/���ФW�ȥ���l���R�éy�r�@�X�ìG�_�-���P�f�4�L� p�Njv�;���*G\NqT�[�b-f��������Ŧ���m�p���j�/���GNNeT�[�b!fۊ��t�
������֬a�8;BFMT[_cgkosw�����������%6:>BFJW[_cg|�����������������
!8?Ccjn���������!%)-159=DKRY`dkrv}��������������
*.5<RV]drv}����������������		"	*	2	A	I	Q	Y	h	{	�	�	�	�	�	�	�	�	�	�	�	

 
(
0
;
E
J
T
Y
o
s
{
�
�
�
�
�
�
�
�
�
�
�
�
�
�
�
�
'/7OWn�������������$)19AINV[jr�����������
	

 
1
B
[
l
q
�
�
�
�
�
�
�
�
�
�
,@SXhx��������.E\ot����?`}�����
,KP`p���������
 %-5CP_gu�������(>Cb����������� (4<AFRWchpu������������������$)-19=EIQUYaow|������������������	
%)159AQ^ckv{����������������7?DZp����������"4FJRrz��������#BZr�������(<AIg�������#/4AFRWchsx�����������������	#?KP^chmuz���������������
".3:?GLQYp�������������2Of������
'<]emrw����������   ! & + 3 G O l � � � � � � � � � � � � � � � !	!!!! !(!.!4!:!@!F!L!R!X!^!d!j!p!v!|!�!�!�!�!�!�!�!�!�!�!�!�!�!�!�!�!�!�!�!�!�!""""""&"-"4";"B"I"P"W"^"e"l"s"z"�"�"�"�"�"�"�"�"�"�"�"�"�"�"�"�"�"�"�"#
###"#)#0#7#>#E#L#S#Z#a#h#o#v#}#�#�#�#�#�#�#�#�#�#�#�#�#�#�#�#�#�#�#$	$$$$%$,$3$:$A$H$O$V$]$d$k$r$y$�$�$�$�$�$�$�$�$�$�$�$�$�$�$�$�$�$�$�$%%%%!%(%/%6%=%D%K%R%Y%`%g%n%u%|%�%�%�%�%�%�%�%�%�%�%�%�%�%�%�%�%�%�%&&&&&$&+&2&9&@&G&N&U&\&c&j&q&x&&�&�&�&�&�&�&�&�&�&�&�&�&�&�&�&�&�&�&'''' '''.'5'<'C'J'Q'X'_'f'm't'{'�'�'�'�'�'�'�'�'�'�'�'�'�'�'�'�'�'�'(#p!�2�C�W�k�|���ʋ����E�M���8GMGbGrN|N�N�N�N�T�T�T�T\\\�b�b;fNfaf!�)�1�9�A�I�Q�Y�a�i�q�y�������×���	���!�Ǧ���o��d<e�e�e�e�pqqttt"t't,t1t6t;t@tEt�z�{
}}}}!}&}+}0}5}:}?}����8�����c�d�e�f�g�h�i�j�k�l�m�n�o�p�q�Z�ƾǾȾɾʾ˾̾;ξϾоc�d�e�f�g�~���������V�W�X�Y�Z�[�\�]�^�_�`�RSTUVWXYZ[\������������R#S#T#U#J(K(L(M(N(O(�-�-p.�3P4Q4R4S4T4U4V4W4X4Y4Z4[4\4]4^4_4`4aCbCcC�H�HP�PQ�QlR�XY�Y�Z
^x^C_�_�e�c7de�e�gmh�heiXjYjZj[j\j]j�o�o�o�o�o�o�u�u�u�u�u�u�z�z�z�z�z�z������4�5�6�7�8�9�Ô4�����d�F��D�*��=�#�>�ߤf����a�ҩ��g�n�<���u�[��_�`�a�b8c�c ���ӷH�ɸ}�j������� �@ ��!�	"�r!�� �; �U�N�j�k�puq+v�v�dAe�e�pqJt�z�{D}����=�����r�_�Ѿh���a�]�V#P(�-u.�3a4dC�H�OP�PQ"Q�QqR�X�X"Y�YpZ�Z�]^}^H_�_�_�c�c<de�e�e�g�g�grh�hji^j�o�u�z�:���Ȕ9������ٙ��i�0�K���I��/��B�	�(�C�ɤ�k�ե��y���f�ש��M�l�T�s�A���z�A�`�f;��1�E��:���_0�sD��Qe�/�C�����.�rB��Pd�V-�A��9��,�q�@�Oc8�U+��?���7��*�p>��b�6�vT��=��5���o<���a4�u�S��3G�����`2t�F�R�G�G��}�<b��Z���N��+e�g�|KB�&����,���Z���N��+e�g�v�Lt1��~$�u���core_intrinsics�derive_clone_copy����N��+e�g�m�I��}z��Y�jD����N��+e�g$����(��Y}����fmt_helpers_for_derive��_�_�N��+e�g7�5����� <���j�����N��+e�gRR��7J[gt(�I}�J��������N��+e�gU��	��+�����6h����N��+e�g�0�Ё�7]��H�nq����N��+e�g�5�taZ wt[]��������N��+e�g�6Iz�`~$�&��������N��+e�g����
����}�;Ej���N��+e�g����������@���'����N��+e�gnoMB?�1���Y�hg����N��+e�g�6�G���tY��������N��+e�g2�&���t RS��������N��+e�gXɤ�
�'h~($�	�������N��+e�g�As�c��=����5E����N��+e�g�|�;I��H�mA����N��+e�g�--"���m~$�$��������N��+e�gX�Br�i�$crate::const_format_args�<��"]���Z
fmt_internals�const_fmt_arguments_new����N��+e�g��׭�4[��}�9b����N��+e�gPѣ��Y��7�pp����N��+e�g�G�F[E����?�i���N��+e�gk�=��g��Y�gA1���N��+e�g��w�BT�D~$���������N��+e�g��t
f`u�� 0V������_�_�N��+e�g����{���(�N������_�_�N��+e�gy���G<�m����3h���N��+e�gc�+��d8���H�kg1���N��+e�g�	)�Н@�Jbx�����_�_�N��+e�g�_�=q�$crate::panic::panic_2021���#��]panic_internals���S�R�N��+e�gvK���q���}�8B����N��+e�g��ާ0�jA��7�pD$���N��+e�g�hP�6�����>�����N��+e�g�k<����Su�=����`�`�N��+e�gd}��x_k~ $�T�������N��+e�g?����F��l�<b����N��+e�g2V$���e�'<�	������N��+e�gu��ue"
H���,���N��+e�g��׽��k�����2B|���N��+e�g�ƌ���y
��H�jD����N��+e�g�܊���<�$������N��+e�g��03����:��"]��������N��+e�g���Ir���}�6hF	���N��+e�gT
�9xi���7�nqu	���N��+e�g��oN��y�KR������_�_�N��+e�gFY����
�]������_�_�N��+e�gi ʆּ��l�;E
���N��+e�g@q�&a;��	jW	�����_�_�N��+e�g(�쉚�
t'�U	�������N��+e�gOa=������&,x
���N��+e�gA.�zpb��H�hg�
���N��+e�g�|C�1�(����
���N��+e�g6z%\S�r�ci��O\������N��+e�g
�U�	�����������S�R�N��+e�g�C��$@���}�5E����N��+e�g��e^n#���7�mA����N��+e�g���@>r���u���]��"�N��+e�g^<�-�D���Q�������N��+e�g�����~$�*�������N��+e�g\�/�6����l�9b����N��+e�g%�[����xt	Ji_�������N��+e�g�u��znҍ�'�X�����_�_�N��+e�gM�������H�gA4
���N��+e�g+�8ș=��-l{�����_�_�N��+e�g
�%z�_Q���&g
���N��+e�g����e�ا�C`�������N��+e�gFK����Aq��}�3h�
���N��+e�gJ	47���7�kg+���N��+e�g�)Ǹ\�����t�Z�"�N��+e�g^����	��Pe�f\��	derive_eq������N��+e�g�}K���t�bd
�������N��+e�gy,(��<��l�8B���N��+e�gej��-���	�h���������N��+e�g8j�H	1�R~'$�	
�������N��+e�g~ܿ0*�t3o8�������N��+e�gUc��C<�k���*,����N��+e�g�WQMR슭��_}��������N��+e�g�
��=���}�2BA���N��+e�g��۶����7�jDp���N��+e�gL��zs����s���"�N��+e�g�=�bP �tePc�������N��+e�geu���6H��e�������N��+e�g���+c����l�6h7���N��+e�g g��ri���	Lh2������N��+e�gxX�
�ʘ����%&i���N��+e�g�ރ�aO��~$�f�������N��+e�g��#nS�o��Y�pp����N��+e�g�	�\���"_E�����_�_�N��+e�g���`+���7�hgc���N��+e�g>�O0!
�~$�/�������N��+e�g�9wf�u���g?��������N��+e�g2�+�fO��l�5E���N��+e�g6�OON�~~	$���������N��+e�gR�.eW�>6���,5���N��+e�gNt{4S�gva������N��+e�g��֍��|����$&����N��+e�g>������Y�pD����N��+e�g̗#�vy�t]^��������N��+e�g9�uå�a��7�gA\���N��+e�gZ�f\.U����<b����N��+e�g���[b�RtmQ�������N��+e�gX�Y�}�:���l�3h����N��+e�g�����=��f�	������N��+e�g��I-K�6���,"���N��+e�g�G�Vק��x���������N��+e�g�~�F3������(����N��+e�g��$��>����Y�nq����N��+e�g6�GjV�~$���������N��+e�g`N͔�(Ht!mc��������N��+e�gUB�D������;E����N��+e�gʀ�-͟�~$�&R�������N��+e�gLݰ(�lg����	����N��+e�gFEG@�����l�2B���N��+e�g��+�(�&�qe���������N��+e�g6�@�x��F���2P���N��+e�gL��)�{F~matches���(��|Z��}s�N��+e�gT-MGӭ_��{�����_�_�N��+e�gC.,��J���Y�mA"���N��+e�g��Պ�v����Z
������N��+e�g�R@:'�L�~!$�#�������N��+e�g�g����:�`�����N��+e�g��eU;�}����9b����N��+e�g;]�~�����H�pp���N��+e�g/m�u;9����&	���N��+e�g�,@�ָ\�gr������_�_�N��+e�g���¿����d������_�_�N��+e�gc㘬���bb��N��+e�g�X��W��t�~��������N��+e�g��ؼ*�a����B���}s�N��+e�g5��)�����Y�kgt���N��+e�g�OF�2w�Q�WZ��������N��+e�gYR�mE��!�h������_�_�N��+e�gbiS�GVb7:c�����N��+e�gu�Y�$u�����8BD���N��+e�g��=���H�pDs���N��+e�gK#d���I�<�%l�����N��+e�g҈�t�K��tdj�������N��+e�gE��t�~�=;�������po�N��+e�g�4�&UƼ����#2�po�N��+e�gV*����n��n�����c�:����������a�=��������Q����|��&�������u�C����������e���~�)�����O�����6�
�����9�����-���x�w�"���l������F���Z������/���y�$�����i����^������4����L�����r����g�>����������]�A��������U�1���������{�S�*������p�G��������������X�J�
��������������T&9
�!|q
,�%��k�����
m�	k��d�
ZvT2�����u#��
��	�=�h����~�
8	�.5B
��G����}����E������F���
����	�l��
�t�v�<���M��k�t��W]5���Tg
�t	5�2����tH����
�7��g����X"?	�G���6�<������rDW
?�=�
J�D����%�6���
��	��8���
�'�yW������H%
�d�f�,���D)
]/	�7MTa
�f��%��"����d
"�����e��
���(���2
��7���[���m������5�w}|����
��	[-�X�����n����
�\����&�,��}Gd	�l��[�d����ODHT �������E�r_��R����2��`[MK?s��;I����0v���	��/�G
��	���&
�T-�8n��T�Փ���
k�13��X�%�ad�(C�rB��>����%�]��s��Jh�:�|�x<�v)8A�PS]�AL
'�-o�~��'��r'Q�~&3P����,�8�T�����A;���ږk�=����3�F>�<��3��?`���&�@��Y5AD�`<���aJ�M39�8Kj�H[h��U���{ �V0�fA='W�xVh��aah�&��D�e�`��7��lXLB��nP���g�Oo`"<����n�ڻj���r�8g�[s�v*n(�vpmR��]Nw�%��,:�x0�U�!ͅy�W���MB{P�a��L����
���4�"m��d�ж�y}���x����Z�׍����8�����X��ƒ���#-��~�0���>e����MW8.�H��u�^�ɚ��OT��Û�=LL�����(6LpM��臷
�Y��p΢���ҠH}���o����X��`�05�S��j���?M��юª���bړ���	*A Ԭ *q�$@�ɭyY)dȮxj�@���P&T��~nv����	
3�a��K�9�TX̳x���"�P�Xx��M��� ׽2$C���гΣ��ȼ�P�%�
IQ�P�ܡE�+�h���	)����n�N���5�	�V�Hr�7v�����L�q]B�Hݥ0�����:��Z<��ڡU$�	�h��}�%V���-��lm�ހ�b�VT?��p�0�3�U�޸�a�ǂ���/=�xb�����|�
������� ��`~g>E����������$��x�L�OQ6��tR��@"��>�$��(d�<eU_�@@������xSZ�i�f��(|��<7����9�>;���NXb�%��7%)� N�[����c�PWEW?����&❡���X/����9�
q�c��_ݸ
y�x%�2����ma��
9�Q©���YnR��S���� � ɲ�PU3���A�ӷi��C���w��O�P��Q8��x�)V�I�<��b� ��V�"e�D���l%��3���B(�-3ޘ)�M{���C�*!K�����5*�x�,���-�rp1�-�ʼn7Ro/���6�u31)H�Z�7�h��@8��8��E(�LC�:�y�=ˡN;��YA;	Cp����=��C|ٺ��?����'Q�@�E�
ƸAqy��8�y�@!Е>��f�Cy��6Q�A�D�d�4�0KEY���T �)Gi��*�"HI��z�GL!J��Th!+�J�j�s��'L��/e��Mٮ�/��Jig53=�QY�a����R��]��QRI�9Y%�T������W�$�i1�\�Y9�H~�U�ZA�`�'Q]!�/-�{�d_Y�ö�ɔ5_��*����%ey�D
zf)���5rl�%X����Nm�p
���n�WB�70p�������Psy�`�mv)m�W���w������|I�F�h��~�6��c�LM�� �;#z|�Q%cm�N���6ui��d���s�Of[�y8���Ka�џu�ۋ��-i���c���R��n	w���}T�[�1�Gf�G�
�I ��s-���`v�)��N����>ϡ�i8f��;��A�.���
��A�%�a�Ը�,�����QR�`��g!��q�Ʋ�6����ry�o�Q@P���T	¹���#��I��"��Ɂ�"�(�mʉ�9p�{ԗ�Y�xٙ���w6p<=��ف��bQ���q �7�{l��U=�������1�b�M%���B���++��(�}���V`��B��?�iD�[�)3n����iSFg(g��eb;��Y�J`MN��E�����šJ5�a��0x�'eSb��G4
�r{Qt`[�A�Όz���#R�!W��zr+P�H��3�]�q:����}��%��"C7��&��1YX�(���/��+2t%'���,�$K�K��O,
��pћ0.�Jl���6Y/�㑑$O�C2��l�V�*6�#;���;�;�T�V���>�W�G��$BrB��{��F�[���M3G�X��
�H$H�a��8n��Jb���*�~LR���U��M�u������L2�f]��6�Q�I�:��RJ��Y=dS��%�vV�"��bS�ZR���$$�]*?�s��.J]�!2w�\�`����'\�aHF)a[4cJ�~�6״dZ�����nr–�Uj�-u"�$��xu��>j��xB� o�k0}|
m+'�������z����I��6K���N�=����qDy�r%�vϕ}|�Z���)������j�Y��Q�=PGdՊrY8�\����B�e@/��Bo�G��m��^[m�I�⏒�d`������?�Ark̓R>T�T���"�z
�(_�*���@�`횪��	:��������d��[�p6���*Xo�鏣��I��g��r��(u,��:������b��|x����E+{�ӬJ���t���!9�(V��GW��)>��^�����ʃju�$\��r�NI92�j�
�o���J��h��m����Ml?�f껺��ֲ6��ʵI������y`��uQ�2��c�2@�̚���#R<�ʲ��O��\�"�� �!�1�j�W�`�&��*LT]��{ԲC�aZ��Ԓ��Cҷ(�*��-�CA�
�ׄ�f�׺ư���"�ۢH�{�s���:8�{��o��;��#�RU�/5���������v�"���aH�q����zϛ�ۤ�C�l1�������$��c��R��۸yy�
�"V�=E��:�nE؄�f�
B� ��c��ch���5&W�Yf��[��	v-'��֛6���Xh�з�$�X����$s�#���3��XPv@k�S��iaQ��������7"����!�Fa[Z�"��4Xm�"[ز���"�`j�o>�"+gK,���'(���Ln+KކB��"3��M�*=j5��E�K�ʂ6C�"k��6�A}�����5kN���m�j9��*�b`%:�(���mp=S�sK��
oAc�zh_�E�����F����L�G{8m4i6o�I��G����J+�k_ɡ8�L��ys��g�N�O�\�8�O�Z}x�2NZR�%���	��S�<�,�G�Tc���!��V�v*��JGV�w�gLJV��w�
�X˘ ^��Y��4M�Ң[�OvN�Zqk^�P��k�za��=T���c;���¿�c�˫~Y
��d;��X��mf�q��q"j�a���Ak�O�G&�zo�&�b��z�Ŧ��{;�#Gd�{#�,�*
�n}����_��k{�i�/����	�3����+j\
�Ѓ��1J�V�c9}Yf�z��K��^d������GFM��󖬐ZC�b�É0d�����K����d���\�:t3�:�+��~E�ઓ#�C����Ǖ��;��ois��0�O�H@����J����{h�KJ�<x��6ӭ�"7+������������g�M�s����H��;i���c��뱏��P�3v1�����K͌��!�ʪ��Z������tC5���R��l�#:�:�d+��C�PUˍ�����r�l��(F��5Ӿk�Q�fRb��;�<��³vTa��z�Ƴ���"l���+����	ʋi�7D����M�7z���t��Æ�˓n�tt=��k�0�W[
��˕h\�䔖��A#���?�#c(���K٣�eBЄ��Z�j�����)+m��Ғ�z�D��-��1��˽�Fk����QJs����j2������S<D*'��/�S��K��~�C�-������{�_�ߦld�k���"��KJ�.qVx@��xf3M�?ܹ"�g��4
}B�&f��9�꽒/�Y�`�5<J����x�3º������("�A�|�Z�8����je9t(	�y��"��
Թ^�D�9
l�A�b	�H�Y��(��0K�'�,5��MW��@bS�`{2���{�5<�\dOA��ķ�tű?�+���y���3#�OB�T��wi&��@����L~.��iIu�2�}Z��"�Y�~��&4��%Le�n&��Aq��8�&����e)L��Cy)d�+=�),�&k�R��-�u~J���I1�B�Q��2LtO�dk�G44m�z��=9|KI�Ŀa:lŧ�|�=4D/���0�>��08=�!>\�Yk=�F�@���	�kG�A4g�T]>TOtT�g�C�1e��﷟E�� ����PF���'��zE��)����lJ���
l�
�N�/L�Q/0P�D�u!��S�oa�o	TLk%�~_BV�/G��3h�[T,�

�0^t�9\�_m_���DͩcT�����d\e���̻/e�c)���e��@J��g��R!��ռh� ��E��.h�eUM����lL[��M�n,}}w՗{�q���?m�ww���h�$�y��x�1P�z�D6�E��{d#Ed@f:{���^�F�7|���d�@�����H�I��c�l�$��Dhp[�a�,Ґ�n��9�Q]̢���]%�G��4 CZWTR͕�ѐ�+P��ឿo9ʗtm�����ߗ�y�c�z�x�����*�,��4Y��9���1����H��f�t�̾vv`��̕��2h���J�+�.����D����,�5�۪7O�rG쫼R����T�.)PDi�T�	�Iv���<Q�����l|���t�tщ=���b��f#���/Ⱥ���$O��z����V�,�$�Η?�q���ո���œ��dŊ� �4N:EQ�Ǭ��Gy	���h��U��<����+��Ʉ��A�d��d���UT�D�C��s��t����W܌�>9��LEW��C����OeG��{�/3o~	�|��������T5\�Z���*'A����!���:v��$x�Z��d��Fz)��N��5��O��L0�!b�8_�̿og�3���QOJ�^��|!'�[��������@����W�ܤ���`��G���[�f?��e�$8r['��
�����^�SV����c���� ̀}3�@�yg4�PbM�K[d�z�n�?�/��}�
�̊��F/y5M�+m�*P���U�r��&-5 }�3�%p��%�'��9�\���!�$'>���b"��`m�D�
)=�J��N��+e�g��+-����\+-�{zY��,M�6� Ĝ2�G�]G�ne4�`A��6���ykR�6�`�`��1�9��2SbV�9%-!9�;��:�ͤ=�9gSW��@퓣��@u��#�@E��R�1�C�}��"��E����̨45K5"��ڲM��h.)H�RN����T��~�@h4Uͫ���v��V�A�-�{#hY-�O�
b��Z-E���w�Y�G�"���]��CU%�\�]��Շ�аd���n�b�e���"�Y4hU^�{��k�@�%nM �lU��xʟm�����-��k%0���o�s�
���p�M����Z:t]+<�Ȕ@u�o�{Oh9w5�:�v�z%��4�R�z��rxy��{�Q��ͷ���º2G����[���Ǡ��EhS��@<ˊ]hr_�3���v�t7����M��ȬX��u��@��KC�������H�5��<����~��4Bq��s��J�Af������7uʞu.��/�*�}蝖���Ġ}XMu����]�ΈJ�5�5�12q�����!F������wS��,�4�&���Ň#|�j�EoT�6>��(3������nb@y��n�m�� �˻]�-�uW�_�5q�.Gq��������k����=@�f���i�Kx.>�%�v_G�eq�U�O�)�½v�{�qQ���0�Ş�j��Ey�Ӧ4��eYi7�ǫȥ7Je0�T���XA���
�5Q���eͽ��O�X���fb�^����M���5Q�����{�z՝4NR��M����<��څ�K�Fv2��$�8E�oܽ�ǩ�`g.��}�t����E!��&��
m�#Q��e��M�>d�M�s'�y�2~3���EXnl�@��4� "Kad��`��0s����q>���mZODŽ�����%SÙ(�
6�U�`U}�,N��4�]H�B��C�Eݩ���_����KlS���&�k�f�k����1�x��!\�!���`9�f���Vd��
��/�AV3�iƚ�0~�ސ��u}l��b����J=(�椸�j�Ƙ�q�q�g�	`�W�8 ~���1!F���:�q"�\F��r�!�N=&;�%m$V�����%�� ��0��&��iPa��'n�o��V(Vz��\�Y(>-���Dߛ%����%r7���ׅOs:v7Dr�C:i$����i<�D@F�B^���ֶ�J�/��s�N���
�k�Pd�'O]^����k_nh�����_�]�I��5d�����vd�g�DƩf���A`Ni��q<t|}i����R:k�0��Y�5�o�K����g�qv&V�*�u����4�vޝ��eg��y��E&i|�;yN��0bO�{6 |_����~>�R!yQ��~�!�QU��Vle?�s����?�"��n�����՝�F�JE�p
N�k�plic���QzUԛ�4�3��Y�Ο�7��G��:��"����K���w�~�nc� u3��r��R#X�F�wg��װ�u��uֿ��:1�?)�ִVLM5�B����O�KZ��>;E��;�y���¤7Ǽ��Z����֊�D��-Þ�%��Ù��^�<}d���v�̦����v��B~.]�n!�mdNJ֖=�V��f����v����:�o~w�����ʡ�3ۮ.�T������[�8/%�Np���h��&�j�d�g\�S���G���MG��#���‹���X莦n��	a��FmV%�.�6{}(@��0�w����NQ�ۚ���ٗ!���􆨁��!������K-]m��J���\xo��|M$*��	��g��Fo�1|�?]P���r���j(
��	�%ٟ_k|���$������,\��Jom>������}�M��o`7�ȊD7�x��$��C��?���yǩW?��~�� o��LS�$���T@�4�(�k�*L<�*�͏tX�I+G��=�%A+����ĕ�-�&ly	\ɲ.�;���[*��b��?A3���X�`�3/�D���N3���or6��J�R��6g�f�[']8��Ue��E�9�������8�����h�;H�C��DI4Gb�Wh]�G�~��zjVI�m����I�2	�,7daK\$>��M�)��ڜ�GM�w�V	�~TL�&�m��V�4�I0��W?�ɣ�e�Y�\y����Z7"��3���^��}����'b���4�PBccǃ���R¯d��):X]�9d(n�ϭؘg'�,ص�i��\��a�jg�Qd�gl'vd��m���>�mo�Sv
,�Fog��k/���q��h��VA~rgK�It���r��� �X0ss�����Us��jJ��0�w7J<['�4xw[Sn�5��w�Ar?�l�wO�hs�n�|o�X���"�}����\ �~<�������s掁0"1������;!
�{����MWR���5��zy���S��W�,�,�"%h�/
S����ؽ5=a�1�7SS��k�`���������h��0N>��t�jH��~���$����Ƞ8�;]�M�g!:��s����gI� 
���y( fnڥ_R?�N
����-X"�_LZ&���ׁ��ݓ��W#A9�
o��s�'xnY�wi���^F��K3H��J���[9&O����?��|����n�����p�$��eQ�w��xlJ��7�MB��
��ǵ�v�w��ϯ�Hoj*��E^+��mѿg`��Y�_�?����|����p�+�Q�:�K9b!�Ѣk��E����!���F��G1��Jw��W����柒�KS����ߥ0�'m ���601�$'���?����
�/���j�U���7b�U�.��!���M���Q�@���?0!��=T�ߒ
������g:��{p�|���IbOU0����	
��*Z5�w�^4�����p��.�������9����������t����L���zy,���0�����&w���������BF<������������}�������]�d;��)O*b�0����b]�����t�����|u��t�V&���~V&��	[Qn_y���&��|8<w*Yq�{������`���^g���n��Q������t�f&Rq���PG���1
�����is3aK:���A�l�-���Q����	~�dPy���1_qN����7[ D'�(j�z�����G��|��=S<�bq���$���~"�r8!�[sKJXEJ�l�*5	��0.Z��w�$0���a����Zs�����,8+�[��0��6x����#�x��p�������1�:�9y���:4U>#��r�����;C��������������������w8y(�����Q������L�������������A��������|�����RA�������+P���7)���1�����p"����%	y�������(F(t�[����������p��%h6H��N�������
��Z���k���f@C�g�m_3��sK��V���?��|�}#�?S�������������v��_�������rsE�~Q�iq-�2��*����=CFK	�����,bly���"�~����#�Z5kH&�u���0����M������i��Fg��+*
gdkX�$����M���|]W8������M�����������]�7JbM�����4A��������p���)��L��#gl5%����C�������&�">GmW��9���=���Vk6�#5�<�Q>��Bu�Y;��l���TU|
���0'���t����������SCM����	��>y��IV�Gh�M!A���l%ib�	lr���G��F�v��GD���������(pYI��*���C���iH:74������M�������TI��FW������"���_/@����
�n,Hatn�T/Y�^1S2p��M�Q��]������G dH�?���'�����$S��,f:2�S��u����o��7�#������T���pI)G*��
�>��D�����L�R""lT��e��J��8��H�����XA!���H�OtgK��Q�����dfTRAQ's��(����Y��Dud���gj�d���fbTA���H�!��������P�����+r�X���S�<#�K7�(�`+����0������-�U�	Lof�������%N�����CJ0������%�3J=���J�0�uS�M�3��QqC�p�����x�4b�����?QH��'p[�!j�����VT��/��qZeR���L���Gd`��������]|)��
l���X�kPz���x����KXN&gG����\����b��*����1r��{�pjH;kw��<4%,w�1���[��Z�y�%Jcw�x��������7�BTB�������da��0wIQ��65
U�l����a�o6�V�������\�Xw?4{kx@������������J��@�����H����������Q��������������X.���Xy��8sy���N�+���tO��"z>��)Q������6l�������X%���q�(����e�y�A%�7���[;��������W���'�"��N��E����������������f`T�
zH�[��-�S5�	#E��7��=����h^l@��H����w�����N7��(5l����wd��������R��]I���C���5�Gj6xJ���e"x%D*sm����������L�6.�NL�����]�d�<F���>���O{7�
�.�i�;r4|QT5�) 4�,��b�����������@)��r)^)��Z4�O�V�O<N-w ��a���X������������Jm�M���Mx&�����M�F/0e���KQ���������gc�w����e������(���v�$OU0����	
��*Z5\/home/palash/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/zune-core-0.5.0/src/lib.rs� ����<��>'�@^_�:\�>*67H<(9O.:CSaQl`R*+

5q�C���N_�:��y�j/home/palash/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/zune-core-0.5.0/src/bytestream/writer.rs� �X�gI�Q��U��� �Z�B�#_9+$*'5/;0X,
_I;-BB=IIJ+)'H8(!
=%,72,:3K(E\."$.!9H+1;U!+0Z?
,J%2",PO1558$5,!S,
Y1>A#)980>1>A#)989V|R+Y|R+Vv6,Yv6,
�t�L;�%l��\�x/home/palash/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/zune-core-0.5.0/src/bytestream/writer/no_std_writer.rs� ��sk��g`�5LIS$�
�FMa9&K%9>(L$N
9>(aF
9>(<K35K%L%a%<N����
P�hkJ��{�&�^/home/palash/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/zune-core-0.5.0/src/serde.rs� ��G�QXK�u'�I/1��?#_" L ,E
?9,E
9*,E
9%,E
95r?ZL�!�'%!�t��\/home/palash/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/zune-core-0.5.0/src/log.rs� �z���q�%�5����&�
J#_B2DV%3


 
#
 
#
a�ƞD{0���ㆨ_8b/home/palash/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/zune-core-0.5.0/src/bit_depth.rs� ��B]�P*z<�;��W�'�#_33;C(-739HX7
8
)3/2&-3!4"	4!<(,/.
58:,(
*'  
H CTR:7<?.-(++8
E
V.`2,'>'*7::8
,(D3E-!z�9fWş �p��j/home/palash/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/zune-core-0.5.0/src/bytestream/reader.rs� �*�׊�m�4�Ƨ����y�)BP5-9PQMQL9;D@G
!. 51+":#)77)@$/<4=?W@Z,8.130
--(99-++%??0=*'*/*! 
&+$ (D--E+F:6D-=E+H=&P@+E+K 6AR!.'
&(N";@09<%Nb":#."
*=I
/G0#,&
XX,O8$c.=%
]LL.?:\?R7ISlS):D'`>> J,/0[U)OH)C+R#S,
9N2BA@PN2>*IH'U{H&X{H&U�2%X�2%
%C T�9:�q\��U����+�c/home/palash/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/zune-core-0.5.0/src/colorspace.rs� 0ծom�@�������+�#_=#2&-	 

(
&
	 
"

!�7	�7	+O"dX[f%BQ2NQ 3
,K/1;chfA:)*))
.115) %)/=C
(*/?' >('##"YdU-����zx�}����h/home/palash/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/zune-core-0.5.0/src/options/decoder.rs� a�,R������GL���#_)"#%4H-)$---**)(2
"1#---**#"#52'E(3(J(LW($N#(@(B(?(@(I(@(=(1(';.-'3-'DB(+ ($%";.!@6C.D&E%*"I"K*#:F\')":-;@-C:.A(0)/5 -#?0. ; 
@1/ ="
>"AE6G4H9 *
B
CL0 :7*0
D>EEW@ C"
P43<)7D0
8+5>4?$
36#3>*
C63D0
@)<)E�@4
J18-E;6'C;H.
536</D$
K.'@OfCO*
*>H,<"%I
A
C$6!E;G
*'?%I
A
C$6!E;G
*&E&J
A
C$8!E;I
*%C$H
A
C$5!E;F
*&H%I
A
C$6!E;G
*%I
(
7A
*E;6'C;H.
"6' @aX`rFQPOP-%%!%<+
����2��KF�Ɨ`
�h/home/palash/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/zune-core-0.5.0/src/options/encoder.rs� ��}h�mя����b�1�#_ ##'D#@#F".'"**1
$
!+ M!
=):$$=,AD#<GM(B3'.7
/9
.:
/'F%8.
3F&
E'<$
6
?2,FHM-=/
I[31)MZ
:+X'@)RF0
��¢3L
�C�7�_/home/palash/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/zune-core-0.5.0/src/result.rs� ��^e�餯����lY�6�H#_ 'FB/4A&5>&)4
GB/4A'5@'+5
Cœ�t�P�G=���7,	c/home/palash/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/zune-core-0.5.0/src/bytestream.rs� J$�1tM�2ĩ�N�#_37"< 611oEx�0c�Q�փ�Y�j/home/palash/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/zune-core-0.5.0/src/bytestream/traits.rs� uBX��j��u��	��8�#_2<=:6DQ!v�t�7:R?,ZG[PZgWG[c\IG[Pa[5/;\MLMP1g8H6ie7Jd89@;JC<aD>L+\1JOUKPo`.SCe;V\+[eM`Qe��e�U�G��3y/home/palash/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/zune-core-0.5.0/src/bytestream/reader/no_std_readers.rs� 'sMkmܙ����C��d�3�:)@'QF%"*
"'@FF) 98G)+;7-JQ0%;%(M
d= 2*K$.
:Q= 2*K$.
N)N5?IC3Q% I.%,KA4#)B
98<!b#.52N+
 4I--,SI4#)-+ 
7FE	. CHw@s
_����ʟ�v/home/palash/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/zune-core-0.5.0/src/bytestream/reader/std_readers.rs� F]|`j_�pM�vg�d
:)X9-%Q '6de7p,G7U)<
d#Q,N3N*0Q9+Q*%P9+IB9#)<;V;
�	��	����O��u/home/palash/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/zune-core-0.5.0/src/bytestream/writer/std_writer.rs� 8��ov��3�F�^V�%;K:L>a"<7KJ}fe	�^L��8����S(`/home/palash/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/zune-core-0.5.0/src/options.rs� Q{1q3x����
L��
 ;-WO!!
'����#�A����D†��G�B����I����P�ϕ��n���%�<�	�x86_64-unknown-linux-gnu��р���m��a��9(u	zune_core�-ddf93750e5157d82��N��+e�g����H
���������9��������
������������������������������
�����������������������������������������������M�������rust-end-file