📄 liblog-f1ce6776ce589c15.rmeta
/home/palash/git/iron_learn/target/debug/deps/liblog-f1ce6776ce589c15.rmeta
Language: rmeta • Lines: 3974
rust
,z#rustc 1.92.0 (ded5c06cf 2025-12-08)��١�	�T�6a��D�
-5080178c80bf7a93��**�٭T��HО�9�-3e2e950d4bac10b5��error�,�|�<�|�,�||�|
	__log_key�L�y�<�xkv�$�xt�x
__log_value�\�|�<�|�$�|t�|
__log_value_sval����<ćkv_sval�L·�ć
__log_value_serde�����<؊kv_serde�T��؊
__log_value_error�����<��kv_std�D�����serde�,�}�<
serde_core�d���}�<�}�$�}t�}p$�~���~�,�~̙~ܘ~�D����~�,�~��~��~b\�����,�̞ܝ	KeyValues�L���<���$��t��set_boxed_logger�����<���,��|���
kv_support�T��<��$�t�tests�,���$����macros�
__log�
log_enabled�

__log_enabled�
__log_logger�
�
�
�
�
�	LOGGER�STATE�
UNINITIALIZED�INITIALIZING�INITIALIZED�MAX_LOG_LEVEL_FILTER�LOG_LEVEL_NAMES�SET_LOGGER_ERROR�LEVEL_PARSE_ERROR�!�#�%�%from_str�(�*�*max�*to_level_filter�*�*�	//	*increment_severity�*decrement_severity�4�6�8�8�	;�	=�=�	=to_level�=�=�	BB	=�	=�	
G'a�Gget�J�Jbuilder�J�Jmetadata�Jlevel�J�J�
Q	Jmodule_path_static�J�T	Jfile_static�J�	X�X�
X�X�X�X�X�
X�X�X�X�	Xbuild�
e>g�g�g�g�l�l�
l�l�l�r>Log�tenabled�tlog�tflush�	NopLogger�x
z�
z�
z�~�~�
~�
~�
set_max_level�set_max_level_racy�	max_level�
set_logger��	set_logger_inner��F�set_logger_racy�����logger��NOP�
__private_api�����������	�
���Value����sealed��KVs����into_kvs��������������
��
���log_impl��L���
���K�����
���loc�STATIC_MAX_LEVEL�
�

�
�
info�
�
trace�Level����
��Warn��
�Info��
���
�Trace��
����������������LevelFilter��Off��
���
���
���
���
���
�� !��"��#��$��%��&����MaybeStaticStr����Static��
���Borrowed��
��'��(����)����*��+����,����-����.������/����Record���������
����	0����1����
RecordBuilder����record�2����Metadata�������3����4����5��6����7����8����9������:����MetadataBuilder�����;����<��=����>����?����@������A����SetLoggerError��
��B��ParseLevelError��
��C��DE��F���GlobalLogger��
���"8"8$8$8'8)8)8)8-8.8283858587878:8<8<8<8@8A8E8F8I8M8N8O8P8Q8S8T8V8W8[8\8]8^8_8`8a8b8c8d8e8j8k8o8p8q8r8u8u8u8v8v8v8w8{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�8t�������������������T���_U���(���(��(�(��(��(�(��(�_�(�`�(��(�������������������)����(�)�t�(�_�(��)��)���)��)�)��)��)�)��)�_�)�`�)��)�(��)�(�t�)�_�)������������\��>w��2���,��,���,��,�,��,��,�,�`�,�_�,����������
����	�e$܎S����_�-�_�����Gl�x.ڢ�������Gl�x.ڢ8������������?�����/���/��/�/��/��/�/�`�/�_�/���������LFͅ����0��0�0��0��0�0�`�0�_�0���������LFͅ8txxy��N�R���t8��_������=���G���_�2�_������kZ�)�H���2��2�2��2�_�2��
��3����_�����/�dZt�3������������������������������!���4�����������������������#���6�����������������������������������������������%�8�(�;�����e�r�zx~
���
�
���#���*�6�*�/�_
#�`F�t#�_�t�ȇ����8,��&0���8�ˇ�8,߇%1����8���8,��%2���8,�87>6����8�-�88?1��J��
�Q��			�KԘ'K�����
�'�L��)Lƙ�˙
�'�M�(M�����
�'�N��(
	Nߚ��
�'�O��)O�����
�'�Pқ)
P�����
�',ɛQ��	���
�'	�Rڜ!


R��
���
�'
�S�� S�����
�'�Tܝ T�����
�'�U��!


U��
���
�'
�ޞ
��������)\��eo�w$�~t��S�_�4��
��(�����������\��>w��2}��D��
��(�E3�F:A̤�
��&�21�38?�ȋ
��&�21�38?
 txy�����������������������|��|�FromStr�<�|�t��|���|�[mem��|�	�,��\�k�l�r
�d�v�L�{�\�������������b\�}���D�~���
���,�(��$�4��$�A��,�M��,�[�������! A lightweight logging facade.�����IF The `log` crate provides a single logging API that abstracts over the���MJ actual logging implementation. Libraries can use the logging API provided���MJ by this crate, and the consumer of those libraries can choose the logging���:7 implementation that is most suitable for its use case.�����OL If no logging implementation is selected, the facade falls back to a "noop"���KH implementation that ignores all log messages. The overhead in this case���>; is very small - just an integer load, comparison and jump.�����PM A log request consists of a _target_, a _level_, and a _body_. A target is a���PM string which defaults to the module path of the location of the log request,���	OL though that default may be overridden. Logger implementations typically use���	C@ the target to filter requests based on some user configuration.��
�\�
 # Usage��
���
RO The basic use of the log crate is through the five logging macros: [`error!`],���30 [`warn!`], [`info!`], [`debug!`] and [`trace!`]���?< where `error!` represents the highest-priority log messages���IF and `trace!` the lowest. The log messages are filtered by configuring���<9 the log level to exclude messages with a lower priority.���
IF Each of these macros accept format strings similarly to [`println!`].��
��
���
" [`error!`]: ./macro.error.html���  [`warn!`]: ./macro.warn.html���  [`info!`]: ./macro.info.html���" [`debug!`]: ./macro.debug.html���" [`trace!`]: ./macro.trace.html���IF [`println!`]: https://doc.rust-lang.org/stable/std/macro.println.html�����]Z Avoid writing expressions with side-effects in log statements. They may not be evaluated.����� ## In libraries�����GD Libraries should link only to the `log` crate, and use the provided���NK macros to log whatever information will be useful to downstream consumers.�����
 ### Examples���<� ```���.+ # #[derive(Debug)] pub struct Yak(String);���1. # impl Yak { fn shave(&mut self, _: u32) {} }���52 # fn find_a_razor() -> Result<u32, u32> { Ok(1) }�ԩ use log::{info, warn};�����)& pub fn shave_the_yak(yak: &mut Yak) {���JG     info!(target: "yak_events", "Commencing yak shaving for {yak:?}");���t�     loop {���"         match find_a_razor() {���             Ok(razor) => {���41                 info!("Razor located: {razor}");���%"                 yak.shave(razor);���                 break;���             }��             Err(err) => {���GD                 warn!("Unable to locate a razor: {err}, retrying");����al�
         }�L�     }�,� }��� # fn main() {}�<��\���� ## In executables�����UR Executables should choose a logging implementation and initialize it early in the���LI runtime of the program. Logging implementations will typically include a���:7 function to do this. Any log messages generated before���63 the implementation is initialized will be ignored.�����A> The executable itself may use the `log` crate to log as well.���|� ### Warning�����41 The logging system may only be initialized once.���̕ ## Structured logging�����FC If you enable the `kv` feature you can associate structured values���MJ with your log records. If we take the example from before, we can include���DA some additional context besides what's in the formatted message:���<��\ܙ # use serde::Serialize;���96 # #[derive(Debug, Serialize)] pub struct Yak(String);���1�\��@= # fn find_a_razor() -> Result<u32, std::io::Error> { Ok(1) }���" # #[cfg(feature = "kv_serde")]��� # fn main() {�ԗ�]����)�]��IF     info!(target: "yak_events", yak:serde; "Commencing yak shaving");�� �t� �_�� "�_�� �_�� 2/                 info!(razor; "Razor located");���!%�`��!�`��!�a܅"             Err(e) => {���"GD                 warn!(e:err; "Unable to locate a razor, retrying");���"�al�"�bL�#�b,�#�b<�# # }���#'$ # #[cfg(not(feature = "kv_serde"))]���#�b<�#�\�#���#96 See the [`kv`] module documentation for more details.��$���$'$ # Available logging implementations��$���$:7 In order to produce log output executables have to use���%74 a logger implementation compatible with the facade.���%<9 There are many available implementations to choose from,���&+( here are some of the most popular ones:��&��& * Simple minimal loggers:���&     * [env_logger]���&     * [colog]���&     * [simple_logger]���'     * [simplelog]��'     * [pretty_env_logger]���'     * [stderrlog]���'     * [flexi_logger]���'     * [call_logger]���(     * [std-logger]��(     * [structured-logger]���(     * [clang_log]���(     * [ftail]���(&# * Complex configurable frameworks:���)     * [log4rs]���)     * [logforth]���)
     * [fern]���)     * [spdlog-rs]���)$! * Adaptors for other facilities:���*     * [syslog]���*     * [slog-stdlog]���*"     * [systemd-journal-logger]���*     * [android_log]���*     * [win_dbg_logger]���+     * [db_logger]�ĝ+     * [log-to-defmt]�Զ+     * [logcontrol-log]���+ * For WebAssembly binaries:���+     * [console_log]��, * For dynamic libraries:���,b_     * You may need to construct an FFI-safe wrapper over `log` to initialize in your libraries���-
 * Utilities:���-     * [log_err]���-     * [log-reload]���-     * [alterable_logger]��-���- # Implementing a Logger��.���.PM Loggers implement the [`Log`] trait. Here's a very basic example that simply���.KH logs all messages at the [`Error`][level_link], [`Warn`][level_link] or���/*' [`Info`][level_link] levels to stdout:��/�<�/�\��/'$ use log::{Record, Level, Metadata};��0�Ć0 struct SimpleLogger;��0���0$! impl log::Log for SimpleLogger {���085     fn enabled(&self, metadata: &Metadata) -> bool {���1+(         metadata.level() <= Level::Info�L�1�b�1���1(%     fn log(&self, record: &Record) {���10-         if self.enabled(record.metadata()) {���2C@             println!("{} - {}", record.level(), record.args());�l�2�bL�2�b�2���2     fn flush(&self) {}�,�3�b�3���3�b<�3�\�3���3MJ Loggers are installed by calling the [`set_logger`] function. The maximum���4OL log level also needs to be adjusted via the [`set_max_level`] function. The���4MJ logging facade uses this as an optimization to improve performance of log���5IF messages at levels that are disabled. It's important to set it, as it���5OL defaults to [`Off`][filter_link], so no log messages will ever be captured!���6NK In the case of our example logger, we'll want to set the maximum log level���7JG to [`Info`][filter_link], since we ignore any [`Debug`][level_link] or���7MJ [`Trace`][level_link] level log messages. A logging implementation should���8>; provide a function that wraps a call to [`set_logger`] and���8=: [`set_max_level`], handling initialization of the logger:��9�<�9�\��9! # use log::{Level, Metadata};���9 # struct SimpleLogger;���9&# # impl log::Log for SimpleLogger {���:96 #   fn enabled(&self, _: &Metadata) -> bool { false }���:)& #   fn log(&self, _: &log::Record) {}���: #   fn flush(&self) {}�<�;�n��;�b��;+( use log::{SetLoggerError, LevelFilter};��;���;/, static LOGGER: SimpleLogger = SimpleLogger;��<���<1. pub fn init() -> Result<(), SetLoggerError> {���<      log::set_logger(&LOGGER)���<<9         .map(|()| log::set_max_level(LevelFilter::Info))�,�=�b<�=�\�=���=PM Implementations that adjust their configurations at runtime should take care���>,) to adjust the maximum log level as well.��>���> # Use with `std`��>���>OL `set_logger` requires you to provide a `&'static Log`, which can be hard to���?DA obtain if your logger depends on some runtime configuration. The���?PM `set_boxed_logger` function is available with the `std` Cargo feature. It is���@MJ identical to `set_logger` except that it takes a `Box<Log>` rather than a���A `&'static Log`:��A�<�A�\��AC@ # use log::{Level, LevelFilter, Log, SetLoggerError, Metadata};���A����B&����B9׊��B)��ԍCʋ<�C�n��C�b��C # #[cfg(feature = "std")]���C1����D52     log::set_boxed_logger(Box::new(SimpleLogger))���D<�,�E�b<�E�\�E�ԘE # Compile time filters��E���Eb_ Log levels can be statically disabled at compile time by enabling one of these Cargo features:��F���F * `max_level_off`���F * `max_level_error`���F * `max_level_warn`���F * `max_level_info`���F * `max_level_debug`���G * `max_level_trace`��G���GZW Log invocations at disabled levels will be skipped and will not even be present in the���H^[ resulting binary. These features control the value of the `STATIC_MAX_LEVEL` constant. The���Ha^ logging macros check this value before logging a message. By default, no levels are disabled.��I���I^[ It is possible to override this level for release builds only with the following features:��J��J * `release_max_level_off`���J * `release_max_level_error`���J * `release_max_level_warn`��K * `release_max_level_info`���K * `release_max_level_debug`���K * `release_max_level_trace`��K���Kc` Libraries should avoid using the max level features because they're global and can't be changed���L once they're set.��L���L`] For example, a crate can disable trace level logs in debug builds and trace, debug, and info���MB? level logs in release builds with the following configuration:��N�\�N ```toml���N [dependencies]���NWT log = { version = "0.4", features = ["max_level_debug", "release_max_level_warn"] }�<�O�\̖O # Crate Feature Flags��O���OXU The following crate feature flags are available in addition to the filters. They are���P$! configured in your `Cargo.toml`.��P���Pc` * `std` allows use of `std` crate instead of the default `core`. Enables using `std::error` and���Q'$   `set_boxed_logger` functionality.���Qa^ * `serde` enables support for serialization and deserialization of `Level` and `LevelFilter`.��R�\�R����R����R:7 log = { version = "0.4", features = ["std", "serde"] }�<�S�\�S�܎S # Version compatibility��S���S\Y The 0.3 and 0.4 versions of the `log` crate are almost entirely compatible. Log messages���Tc` made using `log` 0.3 will forward transparently to a logger implementation using `log` 0.4. Log���Tb_ messages made using `log` 0.4 will forward to a logger implementation using `log` 0.3, but the���Ua^ module path and file name information associated with the message will unfortunately be lost.��V�ܸV [`Log`]: trait.Log.html���V! [level_link]: enum.Level.html���V(% [filter_link]: enum.LevelFilter.html���W&# [`set_logger`]: fn.set_logger.html���W,) [`set_max_level`]: fn.set_max_level.html���W63 [`try_set_logger_raw`]: fn.try_set_logger_raw.html���X85 [`shutdown_logger_raw`]: fn.shutdown_logger_raw.html���X:7 [env_logger]: https://docs.rs/env_logger/*/env_logger/���Y+( [colog]: https://docs.rs/colog/*/colog/���YEB [simple_logger]: https://github.com/borntyping/rust-simple_logger���Z96 [simplelog]: https://github.com/drakulix/simplelog.rs���ZOL [pretty_env_logger]: https://docs.rs/pretty_env_logger/*/pretty_env_logger/���[74 [stderrlog]: https://docs.rs/stderrlog/*/stderrlog/���[@= [flexi_logger]: https://docs.rs/flexi_logger/*/flexi_logger/���\=: [call_logger]: https://docs.rs/call_logger/*/call_logger/���\:7 [std-logger]: https://docs.rs/std-logger/*/std_logger/���].+ [syslog]: https://docs.rs/syslog/*/syslog/���]=: [slog-stdlog]: https://docs.rs/slog-stdlog/*/slog_stdlog/���].+ [log4rs]: https://docs.rs/log4rs/*/log4rs/���^41 [logforth]: https://docs.rs/logforth/*/logforth/���^(% [fern]: https://docs.rs/fern/*/fern/���_41 [spdlog-rs]: https://docs.rs/spdlog-rs/*/spdlog/���_^[ [systemd-journal-logger]: https://docs.rs/systemd-journal-logger/*/systemd_journal_logger/���`=: [android_log]: https://docs.rs/android_log/*/android_log/���`FC [win_dbg_logger]: https://docs.rs/win_dbg_logger/*/win_dbg_logger/���a74 [db_logger]: https://docs.rs/db_logger/*/db_logger/���a@= [log-to-defmt]: https://docs.rs/log-to-defmt/*/log_to_defmt/���b=: [console_log]: https://docs.rs/console_log/*/console_log/���bTQ [structured-logger]: https://docs.rs/structured-logger/latest/structured_logger/���cFC [logcontrol-log]: https://docs.rs/logcontrol-log/*/logcontrol_log/���c1. [log_err]: https://docs.rs/log_err/*/log_err/���d:7 [log-reload]: https://docs.rs/log-reload/*/log_reload/���dKH [alterable_logger]: https://docs.rs/alterable_logger/*/alterable_logger���e;8 [clang_log]: https://docs.rs/clang_log/latest/clang_log���e/, [ftail]: https://docs.rs/ftail/latest/ftail���f�f�g8�l�f�f7=https://prev.rust-lang.org/logos/rust-logo-128x128-blk-v2.png���f?$�f8���f�g7&https://prev.rust-lang.org/favicon.ico���g($�g8�l�g�g7https://docs.rs/log/0.4.29���g��f�
 txy����������������������#�$�$��H-$�t�@$��S$�[�Hi$�	�|$��$��$
��$��$��$��$��$��$b%���%���
.%��>%��N%��^%��n%��~%��#�#�#��{$D�|$��|-$��|@$@$S$S$i$i$T�}4�}������8�4�t�'|�|$��%��8�4�&�,�8�4�&�8�$�$�8�4�&�,�8�4�&�8�$�$�,�8lvl��&�8�$�$�,���
,�8key��&�8��,���&�,�8capture�<�&�8��-�,����,�8�,�&�8�$�-�$��%�,���,�8arg��&�8���*��� �� 8�8����,�8���%�8�8����,�8,�'�8����8����,�8,�'�8�L����� ,�8,�'�8�l�'�8�
��� ,�8�4�$�,�8,�'�8�l�'�8�\�	���,���,�8����$�8���$����,�8�4�$�,�8,�'�8�l�'�8�
\�	���$�,�8,�'�8�l�'�8����$���� ,��� � � 
,� 8,� '� 8�L� 	� � � ,� 8��� $� ,� 8,� '� 8�\� 	� � � 	,� 8��� ,� � � &� ,� 8��<� 
� � ,� � � ,� 8�,� 
� $� � 8� � � � 8� $� %� %� �!�"8�4�!&�!,�!8�4�!&�!8�$�!$�!8�4�!&�!,�!8�4�!&�"8�$�"$�",�"8���"&�"8�$�"$�",�"�"�",�"8���"&�"8��"�"*�"�"�%�"�%8�"8���"�",�"8���"%�"8�"8���"�",�"8,�"'�"8���"�"8���"�",�"8,�"'�"8�L�"�#�#�#�%,�#8,�#'�#8�l�#'�#8�
�#�#�%,�#8�4�#$�#,�#8,�#'�#8�l�#'�#8�\�#	�#�#�$,�#�$�$,�$8���$�$$�$8���$$�$�$�$�$,�$8�4�$$�$,�$8,�$'�$8�l�$'�$8�
\�$	�$�$�$$�$,�$8,�$'�$8�l�$'�$8��$�$�$$�$�%�%$�%%�%%�%Ħk��cMJ Determines if a message logged at the specified level in that module will�t�c be logged.��c���cOL This can be used to avoid expensive computation of log message arguments if���d(% the message would be ignored anyway.��d�t�d # Examples��d�<�d�\��d)& use log::{debug, log_enabled, Level};��e���e$! # struct Data { x: u32, y: u32 }���e96 # fn expensive_call() -> Data { Data { x: 0, y: 0 } }���f74 # let my_logger = log::__private_api::GlobalLogger;���f#  if log_enabled!(Level::Debug) {���f$!     let data = expensive_call();���g>;     debug!("expensive debug data: {} {}", data.x, data.y);�,�g�b�g���g52 if log_enabled!(target: "Global", Level::Debug) {���h#     let data = expensive_call();���hOL    debug!(target: "Global", "expensive debug data: {} {}", data.x, data.y);�,�h�b�i���i63 if log_enabled!(logger: my_logger, Level::Debug) {���i#����iO��,�j�b<�j�\�j���jQN This macro accepts the same `target` and `logger` arguments as [`macro@log`].�'|�k�$�k�r�l�l8�4�l&�l,�l8�4�l&�l8�$�l$�l8�4�l&�l,�l8�4�l&�l8�$�l$�l,�l8���l&�l8�$�l*�l�l�m�l�m,�l8,�l'�l8�l�l	�l�l�m8�4�l&�l,�l8,�l'�l8�d�l	�m�m�m,�m8�4�m$�m8�4�m&�m,�m8�4�m$�m,�m8���m%�m�m�n8�4�m&�m,�m8�4�m&�m8�$�m$�n,�n8���n&�n8�$�n*�n�n�o�n�o,�n8,�n'�n8�l�n	�n�n�o8�4�n&�n,�n8,�n'�n8�d�n	�n�n�n,�n8�4�n$�n8�4�n&�n,�n8,�n'�n8�l�n'�n8�
\�n	�o�o�o$�o,�o8���o%�o�o�o8�4�o&�o,�o8�4�o&�o8�$�o$�o,�o8���o&�o8�$�o*�o�o�p�o�p,�p8,�p'�p8�l�p	�p�p�p8�4�p&�p,�p8,�p'�p8�d�p	�p�p�p8__log_global_logger���p$�p8�4�p&�p,�p8�4�p$�p,�p8���p%�p�q�q,�q8���q&�q8�$�q*�q�q�r�q�r,�q8,�q'�q8�l�q	�q�q�r8�4�q&�q,�q8,�q'�q8�d�q	�q�q�q8����q$�q8�4�q&�q,�q8,�r'�r8�l�r'�r8�
\�r	�r�r�r$�r,�r8���r%�r��r��r�r�r8�4�rt�r'|�r�$�r�u�s�s8�4�s&�s,�s8�4�s&�s8�$�s$�s8�4�s&�s,�s8�4�s&�s8�$�s$�s,�s8���s&�s8�$�s*�s�s�u�s�u8�t8���t�t,�t8���t%�t8���t�t,�t8,�t'�t8���t�t8���t�t,�t8,�t'�t8�L�t�t�t�t,�t8,�t'�t8�l�t'�u8�
<�u�u�u,�u8�4�u$�u8���u$�u,�u8�4�u%�ųv��v�v�v8�4�vt�v'|�v�$�v�w�v�v8����v*�v�v�w�v�w,�v8,�v'�v8�l�v'�w8�d�w%�w�w�w,�w8�4�w&�w8�$�w*�w�w�w�w�w�w�w�w,�w8�4�w%�w��z��z�z�z8�4�zt�z'|�z�$�{�|�{�{,�{�{�{,�{8�$�{&�{8��{
�{*�{�{�{8�l�{	�{�{�{74key value support requires the `kv` feature of `log`���{6%�|ē��څ݅�8�4ޅt؅'|��$��������,������,��8�$��&��8���
��*��Ć��8�lΆ	ۆ܆��7���݆6%��쏉�шԈۈ8�4Ոtψ'|ވ�$��������,��8�$��&��8�$��*��É��8�l͉	ډۉ��7Icapturing values as `sval::Value` requites the `kv_sval` feature of `log`��܉K%���������8�4�t�'|���$ƌ�̌׌,͌8�$Ό&Ҍ8�$ӌ*ٌ܌�8�l�	��܍7Ocapturing values as `serde::Serialize` requites the `kv_serde` feature of `log`����Q%��׏�������8�4��t��'|���$��������,��8�$��&��8�$��*������8�l��	������7Ncapturing values as `std::error::Error` requites the `kv_std` feature of `log`����P%����}*%%%%���4��t���̩�,������b��v��XU�t~�-��ԫ�l���8�ˇdч�8��\���8���(�������ʈ!|ш�8` 0@P`��8죉�����J����������F	���Ŕ%�("�"���)������(��)!��!
"$���,���ޕ&�($�$���C\������(��)����������������;t������Less��������Greater��ji�/޾#��#
$$���,������(&'�t�t'D����%%�2�ܗ4Dߗ����������������������q�aX�(�(�t%�%
'�,�ܬ��()�_)�Κ6њ�����(��^�^��^��[�^buf��[����e�S����������������������q�aX�3ÅÅą��:����(՚(
)$֚�ܚT���(+,-./23���(TÛ�8����������������;t����(**
+u�������+( Returns the most verbose logging level.����(**
,���,�֞96 Converts the `Level` to the equivalent `LevelFilter`.�|�����(�)*��*
-$�����$���52 Returns the string representation of the `Level`.�Ϡ��נFC This returns the same string as the `fmt::Display` implementation.�4�����(��*��*
.$�����+���1. Iterate through all supported logging levels.�������KH The order of iteration is from more severe to less severe log messages.����t�������<���\��� use log::Level;�ѣ��٣#  let mut levels = Level::iter();�������2/ assert_eq!(Some(Level::Error), levels.next());����2/ assert_eq!(Some(Level::Trace), levels.last());�<���\$��0**
/�Y��//����Map����	����<�}�Ta!N������������,M�[�}�81�8�(�3������J��������J�(\��˔�ڔ"�/ĥ/<closure_kind>�1<closure_signature>�1<upvars>�11/�����(��/, Get the next-highest `Level` from this one.�������`] If the current `Level` is at the highest level, the returned `Level` will be the same as the����
 current one.����t����§�<ʧ�\�֧������� let level = Level::Info;�������96 assert_eq!(Level::Debug, level.increment_severity());��ݨNK assert_eq!(Level::Trace, level.increment_severity().increment_severity());����pm assert_eq!(Level::Trace, level.increment_severity().increment_severity().increment_severity()); // max level�<���\������(�(*˪*
2$̪���(�ī.+ Get the next-lowest `Level` from this one.�������_\ If the current `Level` is at the lowest level, the returned `Level` will be the same as the��������t�������<���\���������ǭ������85 assert_eq!(Level::Warn, level.decrement_severity());����NK assert_eq!(Level::Error, level.decrement_severity().decrement_severity());����pm assert_eq!(Level::Error, level.decrement_severity().decrement_severity().decrement_severity()); // min level�<���\������(�(*��*
3$���÷%�)5�5���#������)��(4��4
5$���,���ø&�)7�7���=\������)��(��6��6
7$���,������)9:�t�t:D����88�2���:Dĺ����������������������q�aX�)�)�t8Ժ8
:�,ͺ���!�)<�_<�Ž6Ƚ�����)��^�^��^��[�^��[����e�S����;̽;
<$ͽ�ӽ����)>?@ABEF���.T���8����������������;t����)==
>̊˾������2/ Returns the most verbose logging level filter.����)==
?���'���.+ Converts `self` to the equivalent `Level`.�������30 Returns `None` if `self` is `LevelFilter::Off`.�D�����)�=��=
@$�����$���;8 Returns the string representation of the `LevelFilter`.�������F��4�����)��=��=
A$�����+���30 Iterate through all supported filtering levels.�������B? The order of iteration is from less to more verbose filtering.����t�������<���\̶� use log::LevelFilter;�������)& let mut levels = LevelFilter::iter();�������63 assert_eq!(Some(LevelFilter::Off), levels.next());����85 assert_eq!(Some(LevelFilter::Trace), levels.last());�<���\$��C==
B�]��BB����ƒ���	����<�}�Ta!N���D���)�3����v�J��������J�)\�������"��B��B��DǔD�DDB����(���52 Get the next-highest `LevelFilter` from this one.�������`] If the current `LevelFilter` is at the highest level, the returned `LevelFilter` will be the��� same as the current one.����t�������<���\�����������)& let level_filter = LevelFilter::Info;�������FC assert_eq!(LevelFilter::Debug, level_filter.increment_severity());����[X assert_eq!(LevelFilter::Trace, level_filter.increment_severity().increment_severity());����}z assert_eq!(LevelFilter::Trace, level_filter.increment_severity().increment_severity().increment_severity()); // max level�<���\������)�)=��=
E$�����(���41 Get the next-lowest `LevelFilter` from this one.�������_\ If the current `LevelFilter` is at the lowest level, the returned `LevelFilter` will be the����۱���t�������<���\̘���������)˲������EB assert_eq!(LevelFilter::Warn, level_filter.decrement_severity());����[X assert_eq!(LevelFilter::Error, level_filter.decrement_severity().decrement_severity());����nk assert_eq!(LevelFilter::Off, level_filter.decrement_severity().decrement_severity().decrement_severity());������ assert_eq!(LevelFilter::Off, level_filter.decrement_severity().decrement_severity().decrement_severity().decrement_severity()); // min level�<���\������)�)=��=
F$������HH�,I�������,�3G��G
I�$������KK�-LMNOPQSTVW�����%��� Returns a new builder.�<���.JJ
L����)��� The message body.�$�����-�����	Arguments���pieces��[����[����[k�ĉ�����J��J
M�$�����'���%" Metadata about the log directive.�D�����-��/J��J
N�$�������'$ The verbosity level of the message.�,�����-�(J��J
O�$��������,) The name of the target of the directive.�4�����-�3J��J
P�$�����,���#  The module path of the message.�\�����-����������������;t����3J��J
Q�$����Q��RǔR�RRQR�E�F�3���8���@= The module path of the message, if it is a `'static` string.�������-����������������;t�����J��J
S�$�����%���+( The source file containing the message.�$�����-��J��J
T�$����T��UǔU�UUTU���3���1���HE The source file containing the message, if it is a `'static` string.�\�����-��J��J
V�$�����!���$! The line containing the message.�$�����-����������������;t���J��J
W�$���ĉ�YY�.Z[\]^_`abcdɉ���!��" Construct new `RecordBuilder`.����䔊 The default options are:�������" - `args`: [`format_args!("")`]���1. - `metadata`: [`Metadata::builder().build()`]�ܚ� - `module_path`: `None`���� - `file`: `None`��Ӌ - `line`: `None`�����NK [`format_args!("")`]: https://doc.rust-lang.org/std/macro.format_args.html��njMJ [`Metadata::builder().build()`]: struct.MetadataBuilder.html#method.build����.XX
Z����J�ː1. Set [`args`](struct.Record.html#method.args).�$�����.����X��X
[�$���$�����L����� Set [`metadata`](struct.Record.html#method.metadata). Construct a `Metadata` object with [`MetadataBuilder`](struct.MetadataBuilder.html).�D�����.�/��XƓX
\�$˓�Dѓ���?�Ɣ?< Set [`Metadata::level`](struct.Metadata.html#method.level).�,�����.�(��X��X
]�$���,����C���@= Set [`Metadata::target`](struct.Metadata.html#method.target)�4�����.�3��X��X
^�$���4���ΘN���>; Set [`module_path`](struct.Record.html#method.module_path)�\՘���.����X�X
_�$��$���Z���TQ Set [`module_path`](struct.Record.html#method.module_path) to a `'static` string������.����X��X
`�$���$�����G���0- Set [`file`](struct.Record.html#method.file)�$����.����X�X
a�$��$���۞S���GD Set [`file`](struct.Record.html#method.file) to a `'static` string.�\����.����X�X
b�$��$���ɠC���0- Set [`line`](struct.Record.html#method.line)�$Р���.����XՠX
c�$ڠ�	$����!�ͣ,) Invoke the builder and return a `Record`�,�����.�-X��X
d�$���դ"8���.f�f���<���.ee
f8�ҭ�hh�/ijk׭���'����<���0gg
i�䩯��'��,�����/�(g��g
j�$�������,��4�����/�3g��g
k�$��䆶�mm�0nopq���ͷ#���&# Construct a new `MetadataBuilder`.�Զ��ܶ�����䅷 - `level`: `Level::Info`���� - `target`: `""`�Է�0ll
n���?���<9 Setter for [`level`](struct.Metadata.html#method.level).�,����0�(��l�l
o�$��������E�޺>; Setter for [`target`](struct.Metadata.html#method.target).�4�����0�3��l��l
p�$»�4Ȼ��#���  Returns a `Metadata` object.�,����0�/l��l
q�$�����$8���1s�s��<��1rr
s8�Ծ���>; A trait encapsulating the operations required of a logger.�޾tt���Ծ�	���$�����$�t��=��0��$��O��B��6uvwuvwuwv���/���DA Determines if a log message with the specified metadata would be�\�� logged.�ο��ֿFC This is used by the `log_enabled!` macro to allow callers to avoid����JG expensive computation of log message arguments if the message would be���� discarded anyway.������� # For implementors�������@= This method isn't called automatically by the `log!` macros.����PM It's up to an implementation of the `Log` trait to call `enabled` in its own����GD `log` method implementation to guarantee that filtering is applied.�<��������������������?���t��t
u��$���D�������� Logs the `Record`.���������������GD Note that `enabled` is *not* necessarily called before this method.����C@ Implementations of `log` should perform all necessary filtering�|�� internally.�������������������
����	�e$܎S����3t��t
v��$���4��������! Flushes any buffered records.���������������@�����WT It can be called manually on shut-down to ensure any in-flight records are flushed.�,�������3t��t
w��$�����L���1�N�R���y-(xx�1����1{|}uvw|{}���'<�������1������������?���z��z
{$����̂��������1����������
����	�e$܎S����3z��z
|$����|��,�����1�3z��z
}$�����08������2��t�2���2���uvw���57���.<�������2������������?���~��~
�8�2$���D������������2����������
����	�e$܎S����3~��~
�8�2$���4��|��,�����2�3~��~
�8�2$�����(���&# Sets the global maximum log level.�������OL Generally, this should only be called by the active logging implementation.�������qn Note that `Trace` is the maximum level, because it provides the maximum amount of detail in the emitted logs.�l���)�3
��,�����4���1. A thread-unsafe version of [`set_max_level`].�������LI This function is available on all platforms, even those that do not have����<9 support for atomics that is needed by [`set_max_level`].�������?< In almost all cases, [`set_max_level`] should be preferred.����d��	 # Safety�������IF This function is only safe to call when it cannot race with any other����52 calls to `set_max_level` or `set_max_level_racy`.�������MJ This can be upheld by (for example) making sure that **there are no other����B? threads**, and (on embedded) that **interrupts are disabled**.�������JG It is safe to use all other logging functions while this function runs����#  (including all logging macros).�������,������)�3
��,�����!���*' Returns the current maximum log level.�������[X The [`log!`], [`error!`], [`warn!`], [`info!`], [`debug!`], and [`trace!`] macros check����LI this value and discard any message logged at a higher level. The maximum����74 log level is set by the [`set_max_level`] function.������� [`log!`]: macro.log.html����  [`error!`]: macro.error.html��� [`warn!`]: macro.warn.html���� [`info!`]: macro.info.html����  [`debug!`]: macro.debug.html����  [`trace!`]: macro.trace.html����,��L���)
����I���/, Sets the global logger to a `&'static Log`.�������OL This function may only be called once in the lifetime of a program. Any log����PM events that occur before the call to `set_logger` completes will be ignored.�������GD This function does not typically need to be called manually. Logger����MJ implementations should provide an initialization method that installs the���� logger internally.������� # Availability�������NK This method is available even when the `std` feature is disabled. However,����LI it is currently unavailable on `thumbv6` targets, which lack support for����IF some atomic operations which are used by this function. Even on those����30 targets, [`set_logger_racy`] will be available.����d��	 # Errors�������:7 An error is returned if a logger has already been set.����t�������<���\���GD use log::{error, info, warn, Record, Level, Metadata, LevelFilter};�������*' static MY_LOGGER: MyLogger = MyLogger;������� struct MyLogger;�������  impl log::Log for MyLogger {����8����+��L���b������(ۀ���0�����CŁl���bL���bԚ���,���b������
 # fn main(){����)& log::set_logger(&MY_LOGGER).unwrap();����*' log::set_max_level(LevelFilter::Info);������� info!("hello log");���� warn!("warning");���� error!("oops");�<���n<���\������0- [`set_logger_racy`]: fn.set_logger_racy.html�T������������������������q�aX�3�2
��4��������ǔ�������3t�����o�������������������3�����3������
���make_logger�\��MO�ρU���.+ A thread-unsafe version of [`set_logger`].�������LɃ���96 support for atomics that is needed by [`set_logger`].�������<9 In almost all cases, [`set_logger`] should be preferred.����d��Ņ������I����/, calls to `set_logger` or `set_logger_racy`.�������M�����B܇������FC It is safe to use other logging functions while this function runs����#��������&�|݁����
��4��ć$�2��_���6������2��^�^��^��[�^��[����e�S��������
�$�������%�2��_����6�������2��^�^��^��[�^��[����e�S��������
�$�������#��&# Returns a reference to the logger.�������EB If a logger has not been set, a no-op implementation is returned.�4���
�������1����ߔ��8�4�tݔ�\Y WARNING: this is not part of the crate's public API and is subject to change at any time�l�����������p����4�����,�����
�t���D�����4����ֿL�����Location�D������\����
\����L����b��y-���������������s��*dfUWFH��,�����3�T�4���������������a�����������?D�������������������;t����
����
����$���/����3������7D��3����������������;t����3��
��$�������3������7D��3���
��$����3���uvw�����.<������3������������?������
�$��D���������3����������
����	�e$܎S����3���
�$��4�|�,����3�3���
�$���	�D�	�������������ֿ����[����[����[k�ĉ������(��������ѫ��filename��R���	�R��col��R��	_filename��R���n��*�����������������;t����
���3���L�	�����	t���	
����4�	�$�	�,�	kvs��
@B�������������ֿ����[����[����[k�ĉ������(��������ѫ�����R���	�R�����R��·�R���n��*���3���������L�������������<�t���
������4��$��,�target_module_path_and_loc�ԧ����������E<�����(�����������
����4��,��4�-/��*P|�������ѫ�����R���	�R�����R��·�R���n��*
����'���.+ The statically resolved maximum log level.�������OL See the crate level documentation for information on how to configure this.�������PM This value is checked by the log macros, but not by the `Log`ger returned by��ܖMJ the [`logger`] function. Code that manually calls functions on that value����0- should compare the level against this value.�ۗ��ߗ [`logger`]: fn.logger.html�����)���� The standard logging macro.�����LI This macro will generically log with the specified `Level` and `format!`��� based argument list.���<��\�� use log::{log, Level};�����! let data = (42, "Forty-two");���! let private_data = "private";�����B? log!(Level::Error, "Received errors: {}, {}", data.0, data.1);�<��\����OL Optionally, you can specify a `target` argument to attach a specific target���OL to the log record. By default, the target is the module path of the caller.���<��\��������!����!����L� log!(���     target: "app_events",���     Level::Error,���"     "Received errors: {}, {}",���	     data.0, data.1�4�	 );�<�	�\�	���	PM And optionally, you can specify a `logger` argument to use a specific logger���
)& instead of the default global logger.��
�<�
�\��
 # struct MyLogger {}���
 # impl Log for MyLogger {���@= #     fn enabled(&self, _metadata: &log::Metadata) -> bool {��� #         false�\� #     }���1. #     fn log(&self, _record: &log::Record) {}�� #     fn flush(&self) {}�<��n�� use log::{log, Level, Log};�����!����!���
���
  let my_logger = MyLogger {};�L�
����
     logger: my_logger,���
����"������4���<��\����TQ The `logger` argument accepts a value that implements the `Log` trait. The value���&# will be borrowed within the macro.�����VS Note that the global level set via Cargo features, or through `set_max_level` will���RO still apply, even when a custom logger is supplied with the `logger` argument.��4��\�����'|�.%����8�4�&�,�8�4�&�8�$�$�8�4�&�,�8�4�&�8�$�$�,�8���&�8�$�$�,���,�8���&�8���*�����,�8,�'�8�,�	���8�4�&�,�8,�'�8�d�	���,�8�4�$�8�4�&�,�8�4�$�,�8���$�,���,�8����%���8�4�&�,�8�4�&�8�$�$�,�8���&�8�$�$�,���,�8���&�8���*�����,�8,�'�8�,�	���8�4�&�,�8,�'�8�d�	���,�8�4�$�8�4�&�,�8,�'�8�l�'�8�
\�	���$�,�8���$�,���,�8����%���8�4�&�,�8�4�&�8�$�$�,�8���&�8�$�$�,���,�8���&�8���*�����,�8,�'�8�,�	���8�4�&�,�8,�'�8�d�	���8����$�8�4�&�,�8�4�$�,�8���$�,���,�8����%���,�8���&�8�$�$�,���,�8���&�8���*�����,�8,�'�8�,�	���8�4�&�,�8,�'�8�d�	���8����$�8�4�&�,�8,�'�8�l�'�8�
\�	���$�,�8���$�,���,�8����%���(��%&# Logs a message at the error level.��%�t�%���%�<�%�\��% use log::error;��&���&7����&1. let (err_info, port) = ("No connection", 22);��'���'/, error!("Error: {err_info} on port {port}");���'HE error!(target: "app_events", "App Error: {err_info}, Port: {port}");���'EB error!(logger: my_logger, "App Error: {err_info}, Port: {port}");�<�(�\�4�(�\�(��(��('|�(>%�)�0�*�*8�4�*&�*,�*8�4�*&�*8�$�*$�*8�4�*&�*,�*8�4�*&�*8�$�*$�*,�*�*�*,�*8���*&�*8��*�**�*�*�+�*�+,�+8,�+'�+8�
�+	�+�+�+8�4�+&�+,�+8,�+'�+8�d�+	�+�+�+,�+8�4�+$�+8�4�+&�+,�+8�4�+$�+,�+8,�+'�+8�,�+'�+8�,�+$�+,�+�+�+,�+8���+�+%�+�,�-
8�4�,&�,,�-8�4�-&�-8�$�-$�-,�-�-�-,�-8���-&�-8��-�-*�-�-�.�-�.,�-8,�-'�-8�
�-	�-�-�-8�4�-&�-,�-8,�-'�-8�d�-	�-�-�-,�-8�4�-$�-,�-8,�-'�-8�,�-'�-8�,�-$�-,�-�-�-,�-8���-�-%�.�/�/
8�4�/&�/,�/8�4�/&�/8�$�/$�/,�/�/�/,�/8���/&�/8��/�/*�/�/�0�/�0,�/8,�/'�/8�
�/	�/�/�08�4�/&�/,�/8�4�/$�/,�/8,�/'�/8�,�/'�/8�,�/$�/,�/�/�0,�/8���/�0%�0�0�0,�0�0�0,�08���0&�08��0�0*�0�0�0,�08,�0'�08�
�0	�0�0�0
,�08,�0'�08�,�0'�08�,�0$�0,�0�0�0,�08���0�0��4��0%" Logs a message at the warn level.��1�t�1���1�<�1�\��1 use log::warn;��1���17����2+( let warn_description = "Invalid Input";��2���2*' warn!("Warning! {warn_description}!");���2NK warn!(target: "input_events", "App received warning: {warn_description}");���3IF warn!(logger: my_logger, "App received warning: {warn_description}");�<�3�\�4�4�\�4��4��4'|�4N%�4�<�5�68�4�5&�5,�58�4�5&�68�$�6$�68�4�6&�6,�68�4�6&�68�$�6$�6,�6�6�6,�68���6&�68��6�6*�6�6�7�6�7,�68,�6'�68�
�6	�6�6�78�4�6&�6,�68,�6'�68�d�6	�6�6�6,�68�4�6$�68�4�6&�6,�68�4�6$�6,�78,�7'�78�,�7'�78�$�7$�7,�7�7�7,�78���7�7%�7�8�8
8�4�8&�8,�88�4�8&�88�$�8$�8,�8�8�8,�88���8&�88��8�8*�8�8�9�8�9,�88,�8'�88�
�8	�8�8�98�4�8&�8,�88,�8'�88�d�8	�9�9�9,�98�4�9$�9,�98,�9'�98�,�9'�98�$�9$�9,�9�9�9,�98���9�9%�9�:�:
8�4�:&�:,�:8�4�:&�:8�$�:$�:,�:�:�:,�:8���:&�:8��:�:*�:�:�;�:�;,�:8,�:'�:8�
�;	�;�;�;8�4�;&�;,�;8�4�;$�;,�;8,�;'�;8�,�;'�;8�$�;$�;,�;�;�;,�;8���;�;%�;�;�;,�;�;�;,�;8���;&�;8��;�;*�;�;�<,�;8,�;'�;8�
�;	�<�<�<
,�<8,�<'�<8�,�<'�<8�$�<$�<,�<�<�<,�<8���<�<��A��<%" Logs a message at the info level.��<�t�<���<�<�<�\��< use log::info;��<���=7����=1. # struct Connection { port: u32, speed: f32 }���=96 let conn_info = Connection { port: 40, speed: 3.20 };��>���>NK info!("Connected to port {} at {} Mb/s", conn_info.port, conn_info.speed);�T�> info!(���?$!     target: "connection_events",���?52     "Successful connection, port: {}, speed: {}",���?'$     conn_info.port, conn_info.speed�4�@��T�@��Ԛ@����@5����@'��4�A��<�A�\�4�A�\�A��A��A'|�A^%�A�I�C�C8�4�C&�C,�C8�4�C&�C8�$�C$�C8�4�C&�C,�C8�4�C&�C8�$�C$�C,�C�C�C,�C8���C&�C8��C�C*�C�C�D�C�D,�C8,�C'�C8�
�C	�C�C�D8�4�C&�C,�C8,�C'�C8�d�C	�C�C�D,�D8�4�D$�D8�4�D&�D,�D8�4�D$�D,�D8,�D'�D8�,�D'�D8�$�D$�D,�D�D�D,�D8���D�D%�D�E�E
8�4�E&�E,�E8�4�E&�E8�$�E$�E,�E�E�E,�E8���E&�E8��E�E*�E�E�F�E�F,�E8,�E'�F8�
�F	�F�F�F8�4�F&�F,�F8,�F'�F8�d�F	�F�F�F,�F8�4�F$�F,�F8,�F'�F8�,�F'�F8�$�F$�F,�F�F�F,�F8���F�F%�F�G�H
8�4�G&�G,�G8�4�G&�G8�$�G$�G,�G�G�H,�G8���G&�G8��H�H*�H�H�H�H�H,�H8,�H'�H8�
�H	�H�H�H8�4�H&�H,�H8�4�H$�H,�H8,�H'�H8�,�H'�H8�$�H$�H,�H�H�H,�H8���H�H%�H�I�I,�I�I�I,�I8���I&�I8��I�I*�I�I�I,�I8,�I'�I8�
�I	�I�I�I
,�I8,�I'�I8�,�I'�I8�$�I$�I,�I�I�I,�I8���I�I��M��I&# Logs a message at the debug level.��I�t�I���I�<�J�\��J use log::debug;��J���J7����J(% # struct Position { x: f32, y: f32 }���K/, let pos = Position { x: 3.234, y: -1.223 };��K���K74 debug!("New position: x: {}, y: {}", pos.x, pos.y);���KMJ debug!(target: "app_events", "New position: x: {}, y: {}", pos.x, pos.y);���LJG debug!(logger: my_logger, "New position: x: {}, y: {}", pos.x, pos.y);�<�M�\�4�M�\�M��M��M'|�Mn%�M�U�N�O8�4�N&�O,�O8�4�O&�O8�$�O$�O8�4�O&�O,�O8�4�O&�O8�$�O$�O,�O�O�O,�O8���O&�O8��O�O*�O�O�P�O�P,�O8,�O'�O8�
�O	�O�O�P8�4�O&�O,�O8,�O'�O8�d�O	�O�O�O,�O8�4�O$�O8�4�O&�O,�P8�4�P$�P,�P8,�P'�P8�,�P'�P8�,�P$�P,�P�P�P,�P8���P�P%�P�Q�Q
8�4�Q&�Q,�Q8�4�Q&�Q8�$�Q$�Q,�Q�Q�Q,�Q8���Q&�Q8��Q�Q*�Q�Q�R�Q�R,�Q8,�Q'�Q8�
�Q	�Q�Q�R8�4�Q&�R,�R8,�R'�R8�d�R	�R�R�R,�R8�4�R$�R,�R8,�R'�R8�,�R'�R8�,�R$�R,�R�R�R,�R8���R�R%�R�S�S
8�4�S&�S,�S8�4�S&�S8�$�S$�S,�S�S�S,�S8���S&�S8��S�S*�S�S�T�S�T,�T8,�T'�T8�
�T	�T�T�T8�4�T&�T,�T8�4�T$�T,�T8,�T'�T8�,�T'�T8�,�T$�T,�T�T�T,�T8���T�T%�T�T�U,�T�T�U,�T8���T&�T8��T�U*�U�U�U,�U8,�U'�U8�
�U	�U�U�U
,�U8,�U'�U8�,�U'�U8�,�U$�U,�U�U�U,�U8���U�U��Z��U&# Logs a message at the trace level.��U�t�U���U�<�U�\��V use log::trace;��V���V7����V(����V/ȗ�W���W63 trace!("Position is: x: {}, y: {}", pos.x, pos.y);���W74 trace!(target: "app_events", "x is {} and y is {}",���X>;        if pos.x >= 0.0 { "positive" } else { "negative" },���X?<        if pos.y >= 0.0 { "positive" } else { "negative" });���Y41 trace!(logger: my_logger, "x is {} and y is {}",���Y>����Z?��<�Z�\�4�Z�\�Z��Z��Z'|�Z~%�[�c�\�\8�4�\&�\,�\8�4�\&�\8�$�\$�\8�4�\&�\,�\8�4�\&�\8�$�\$�\,�\�\�\,�\8���\&�\8��\�\*�\�]�]�]�],�]8,�]'�]8�
�]	�]�]�]8�4�]&�],�]8,�]'�]8�d�]	�]�]�],�]8�4�]$�]8�4�]&�],�]8�4�]$�],�]8,�]'�]8�,�]'�]8�,�]$�],�]�]�],�]8���]�]%�]�_�_
8�4�_&�_,�_8�4�_&�_8�$�_$�_,�_�_�_,�_8���_&�_8��_�_*�_�_�`�_�`,�_8,�_'�_8�
�_	�_�_�`8�4�_&�_,�_8,�_'�_8�d�_	�_�_�_,�_8�4�_$�_,�_8,�_'�_8�,�_'�_8�,�_$�_,�`�`�`,�`8���`�`%�`�a�a
8�4�a&�a,�a8�4�a&�a8�$�a$�a,�a�a�a,�a8���a&�a8��a�a*�a�a�b�a�b,�a8,�a'�a8�
�a	�a�a�b8�4�a&�a,�a8�4�a$�a,�a8,�a'�a8�,�a'�a8�,�a$�b,�b�b�b,�b8���b�b%�b�b�b,�b�b�b,�b8���b&�b8��b�b*�b�b�b,�b8,�b'�b8�
�b	�b�b�b
,�b8,�b'�b8�,�b'�b8�,�b$�b,�b�b�b,�b8���b�btĎ���FC An enum representing the available verbosity levels of the logger.�����IF Typical usage includes: checking if a certain `Level` is enabled with����GD [`log_enabled!`](macro.log_enabled.html), specifying the `Level` of����C@ [`log!`](macro.log.html), and comparing a `Level` directly to a��ō+( [`LevelFilter`](enum.LevelFilter.html).�,͎�(T���_U�����������������,���َ The "error" level.������#  Designates very serious errors.�_���(rt���(�8$���Ǒ The "warn" level.�����$! Designates hazardous situations.�_���(rt���($���� The "info" level.�������" Designates useful information.�]���(pr���(,���� The "debug" level.�������*' Designates lower priority information.�f���(y{���(,���̓ The "trace" level.�����GD Designates very low priority, often extremely verbose, information.�����(�����((��!�(���"$���(�(����
�,�� ��"�(H��#�(#�(���57����(��(����
�L������$�(���"�)+.08�:>@���(�3����
���P��%�(���"$����(��(������
�T������&�(���"$����(��(������
�����(��'�(��_�"$�����(��^�^��^��[�^��[����e�S��������
�,���� ��(�(��`�"$����(���3�������������`���
���$�������ܴ���MJ An enum representing the available verbosity level filters of the logger.�����JG A `LevelFilter` may be compared directly to a [`Level`]. Use this type����TQ to get and set the maximum log level with [`max_level()`] and [`set_max_level`].������� [`Level`]: enum.Level.html����&# [`max_level()`]: fn.max_level.html��ܳ,��	\��))�������������������������&# A level lower than all log levels.�	7���)JL���),ٵ���)& Corresponds to the `Error` log level.�	:���)MO���)$����(% Corresponds to the `Warn` log level.�	9���)LN���)$ȶ���(% Corresponds to the `Info` log level.�	9���)LN���),���Ҷ)& Corresponds to the `Debug` log level.�	:���)MO���),�����)& Corresponds to the `Trace` log level.�	:���)MO���)(��)�)���"$���)�)����
�,�� ��*�)H��+�)+�)���57����)��)����
�L������,�)���"�)+.08�:>@���)�3����
���P��-�)���"$����)��)������
�T����ɴ.�)���"$����)��)���ɴ�
�ɴ��(δ/�)��_�"$�����)��^�^��^��[�^��[����e�S�����δ�
�,δ�� մ0�)��`�"$����)����3����մ�������
���$մ�������
t������,\��>w��2���������,���3�,��6"
6"��
��6"6"���,����d�������"
�"��
���"�"�3�,����<�����3 ��1����,( ��2����,���FI57���,�,� ���
��,��!��3����,�����5�<>AC8�MQS���,�3�!���
����H"��4����,mp*.4����,�����[]����,��,�"���
��L����#��5����,���?B57����,��,���#���
������P$��6����,�����57����,��,���$���
��T���� %��7����,��`���57����,���3����%���������`���
����$������(&��8����,��_�hk57�����,��^�^��^��[�^��[����e�S�����&���
��,���������#  The "payload" of a log message.����L�� # Use�������KH `Record` structures are passed as parameters to the [`log`][method.log]����EB method of the [`Log`] trait. Logger implementors manipulate these����LI structures in order to display log messages. `Record`s are automatically����C@ created by the [`log!`] macro and so are not seen by log users.�������JG Note that the [`level()`] and [`target()`] accessors are equivalent to����JG `self.metadata().level()` and `self.metadata().target()` respectively.����LI These methods are provided as a convenience for users of this structure.����l��
 # Example�������HE The following example shows a simple logger that displays the level,����B? module path, and message of any `Record` that is passed to it.����<���\ğ��~������$����=:    fn enabled(&self, _metadata: &log::Metadata) -> bool {�|��        true�D��    }�������,)    fn log(&self, record: &log::Record) {����0-        if !self.enabled(record.metadata()) {����            return;�d��	        }�������"        println!("{}:{} -- {}",����#                  record.level(),����$!                 record.target(),����#                  record.args());�D�������    fn flush(&self) {}�,���b<���\������-* [method.log]: trait.Log.html#tymethod.log�ܵ�����Ҍ���0- [`level()`]: struct.Record.html#method.level����2/ [`target()`]: struct.Record.html#method.target�4����������-�e$܎S������������D�����/Ģ�$���������'\��������������������;t����,��� $���������$������('��9����-���57���-�-�'���
��,��((��:����-��_���57�����-��^�^��^��[�^��[����e�S�����(���
��,����䊉���/, Builder for [`Record`](struct.Record.html).�������\Y Typically should only be used by log library creators or for testing and "shim loggers".����XU The `RecordBuilder` can set the different parameters of `Record` object, and returns��Ѐ.+ the created object when `build` is called.����t�������<���\잁 use log::{Level, Record};�������" let record = Record::builder()���1.                 .args(format_args!("Error!"))����(%                 .level(Level::Error)����$!                 .target("myApp")���,)                 .file(Some("server.rs"))����$!                 .line(Some(144))����0-                 .module_path(Some("server"))���                 .build();�<���\������HE Alternatively, use [`MetadataBuilder`](struct.MetadataBuilder.html):�ل�<݄�\��.+ use log::{Record, Level, MetadataBuilder};�������/, let error_metadata = MetadataBuilder::new()��ȅ,)                         .target("myApp")����0-                         .level(Level::Error)����%"                         .build();�̆��І"����-*                 .metadata(error_metadata)����1���Ӈ$!                 .line(Some(433))����)&                 .file(Some("app.rs"))����0���ӈ�<��\l�������T�.Gl�x.ڢ������4�����-()��;����.��_�RT35�����.��^�^��^��[�^��[����e�S�����)���
��,���伎����! Metadata about a log message.�ԥ�Lإ������@= `Metadata` structs are created when users of the library use���� logging macros.�������B? They are consumed by implementations of the `Log` trait in the���� `enabled` method.�������DA `Record`s use `Metadata` to determine the log message's severity�|� and target.������DA Users should use the `log_enabled!` macro in their code to avoid����(% constructing expensive log messages.���t������<���\���'�~��������é��ǩ ����8����+��Lͪ�bת��۪(ۀ���0�����CŁl���bL���bԑ���,���b������ # fn main(){}�<Ȭ�\D������/����?������d��,�����(|��4�����3(+٬<����/���np35���/�/�+٬�
��,٬,�=����/�����3�:<?A8�KOQ���/�3�,��
���H-�>����/��*.>����/�����[]����/��/�-��
��L���.�?����/���cf57����/��/���.��
�����P/��@����/���	57����/��/���/���
��T���� 0��A����/��`���57����/����3����0���������
����$������(1��B����/��_�y|57�����/��^�^��^��[�^��[����e�S�����1���
��,�����Ƶ��30 Builder for [`Metadata`](struct.Metadata.html).�������\�����^[ The `MetadataBuilder` can set the different parameters of a `Metadata` object, and returns��ز.�����l�������<���\̥� let target = "myApp";����&# use log::{Level, MetadataBuilder};���)& let metadata = MetadataBuilder::new()����,)                     .level(Level::Debug)����'$                     .target(target)���!                     .build();�<���\|ѵ����0���LFͅ����D����/2��C����0���RT3�:<?A8�KOQ���0�3�2���
����H3��D����0��(,D����0���Y[����0��0�3���
��L����4��E����0�����57����0��0���4���
������P5��F����0���_b57����0��0���5���
��T���� 6��G����0��`�57����0����3����6���������
����$������(7��H����0��_���57�����0��^�^��^��[�^��[����e�S�����7���
��,���� #��RO The type returned by [`set_logger`] if [`set_logger`] has already been called.�����ņ&�t���2=���G�����3�2 #4�3�2��
������3(A��N�2��_�"$�����2��^�^��^��[�^��[����e�S�����A���
�,����m#�ɉZW The type returned by [`from_str`] when the string doesn't match any of the log levels.�������XU [`from_str`]: https://doc.rust-lang.org/std/str/trait.FromStr.html#tymethod.from_str�|Ӌ�2kZ�)�H���3�2m#4�3�2��
�����3(B��O�2��_�"$�����2��^�^��^��[�^��[����e�S�����B���
�,����HC��P�2P�2���57����2��2�C���
�L����DËQ�2���"�)+.08�:>@���2�3�DË�
���� The global logger proxy.�d��3�/�dZ�O'���3(E�R�3��_�!#�����3��^�^��^��[�^��[����e�S�����E��
�,���=���i���U����#L�*<�/*�4#�9��>0�C��J��O��V��[k�`ؽgL�n\�s�x��}H�����4��Ơ�O��ޡ������~�����K��A��@�������K�������ȭ�-��������m����p��ǨA�׽����D��%F�+��34��;=�A�G��OD��Wh�]��e4��m%�s��{�����D���S�����4�����Q�����L���������L��������D������4����
�
�
D�
"�
)�
0,�
7t=�D�KD�R�~X"<^};d�;j�:py:v:|�9�:�:9�@9��9��8��8�v3��2��2�J2��1��1�P1�V1��0��0�J1�0�
0��-�O-�,�,�+,f+l+$�**�*0�)6�)<�*BW!H{ N� TK!Z�`�fXl6r�x�~��E�K������
������
�=
�C
�������h�n�o
�u
�?��n	�� [&,2�8Z>`DJ*=GJXgl�struct.Metadata.html�https://docs.rs/colog/*/colog/�3https://docs.rs/alterable_logger/*/alterable_logger�enum.Level.html�
std-logger��
https://docs.rs/fern/*/fern/�error!�warn!�	db_logger���(https://docs.rs/env_logger/*/env_logger/�ſ�call_logger���$https://docs.rs/logforth/*/logforth/�����win_dbg_logger�����(https://docs.rs/log-reload/*/log_reload/������_max_level()���4https://doc.rust-lang.org/std/macro.format_args.html�����7https://doc.rust-lang.org/stable/std/macro.println.html�����flexi_logger��� https://docs.rs/log4rs/*/log4rs/�������android_log�����log!���"https://docs.rs/log_err/*/log_err/�����fn.logger.html�������struct.MetadataBuilder.html�����./macro.trace.html��������
	stderrlog�����"https://docs.rs/ftail/latest/ftail����systemd-journal-logger�����log_enabled!��	��*https://docs.rs/console_log/*/console_log/����
����fn.try_set_logger_raw.html�����struct.Record.html�����./macro.debug.html��������
tpretty_env_logger�macro.debug.html�����fn.set_logger_racy.html�*https://docs.rs/clang_log/latest/clang_log��	��slog-stdlog��������0https://docs.rs/logcontrol-log/*/logcontrol_log/����������enum.LevelFilter.html������	����	�����./macro.info.html�macro.warn.html������	simplelog���������;https://docs.rs/structured-logger/latest/structured_logger/��	��syslog�������,https://docs.rs/log-to-defmt/*/log_to_defmt/��������fn.set_logger.html��������	��./macro.warn.html�Metadata::target������
simple_logger�������(https://docs.rs/std-logger/*/std_logger/���	spdlog-rs�����&https://docs.rs/db_logger/*/db_logger/���������trait.Log.html�������./macro.error.html�Metadata::level�������colog�����*https://docs.rs/call_logger/*/call_logger/����fern�������0https://docs.rs/win_dbg_logger/*/win_dbg_logger/�������alterable_logger������fn.max_level.html�����������Metadata::builder().build()���
env_logger�����,https://docs.rs/flexi_logger/*/flexi_logger/����
�logforth�������*https://docs.rs/android_log/*/android_log/����macro.log.html�����
log-reload���������
������format_args!("")�����println!�������&https://docs.rs/stderrlog/*/stderrlog/���log4rs�����
��@https://docs.rs/systemd-journal-logger/*/systemd_journal_logger/�����macro.log_enabled.html���log_err����������4https://doc.rust-lang.org/std/str/trait.FromStr.html�����target()������trace!���������6https://docs.rs/pretty_env_logger/*/pretty_env_logger/����macro.trace.html���ftail������*https://docs.rs/slog-stdlog/*/slog_stdlog/���������console_log��������fn.shutdown_logger_raw.html���������level()������debug!�macro.info.html�������(https://github.com/drakulix/simplelog.rs������	clang_log���� https://docs.rs/syslog/*/syslog/��������logcontrol-log��������fn.set_max_level.html�����������info!�������0https://github.com/borntyping/rust-simple_logger�macro.error.html�������structured-logger����#https://docs.rs/spdlog-rs/*/spdlog/�������log-to-defmt�������������
������������������ſ����������
������������	macro@log����
��
���
�tt�H����������������������I�I�I�H�J��������1tOFFERRORWARNINFODEBUGTRACEJattempted to set a logger after the logging system was already initializedJFattempted to convert a string that doesn't match an existing log levelF��������������������i0�KjzЉ�_T]�O���-��P�g2�/�!��y�IA����D�ve�A,ۢ�?�����.C��Xn���^�Ֆa�_��H�zOEM�<�8Fv��FO2��k`����S��z��[_$+Ё�8k�}��`+9��k����ȸ/�������^=-�ek�@E�kRBm5��)G�N����m�Xq
d��M���i��6p8r6��7�J�R&|G������6���>R��"��W���3Xf2GX�E�L�2��=_��Ez�q�><���|��nɋ�6	I��		lD�M�M޻�H�_�
D	6���ڣV�����`if'x��a�"�W���c�П�r$��;��̏�A�-��'�q�c�Y1+MR��?������.��å���T:Ad'w?��]y@a���f(�Z�>\�KJ}B��r�����m�C���?ia�[�	���gJ1�U@v��]і�C�]]ޢ������s�|�`,�7�I�2;t��4$h��a,-��J�TG�^��y�/�.p��\��}[D�d�>�`Qթ�sg83�,C?O�~ U}΋�V�$�;��`���d�
C�����6�b�@�+�"�����K�s`���NN�c��¿��)
D�lj	��,��@�:7�����T_��8�Z�Y.(V&���:~�3�[7�P\�uT�X,�5��*7��A�V��:�.S��H(�����=��+�޳;�afe��P��f��w���NAJ�D�җ�(G��|]f�"�Jg[L��Ė.V? 4��?&���P�2�49�;\�|��"\`��,{�]hU���
��f�H�ހ��v���E��Fv���.�58���-q��Ķ��i�˹���߯g�����|L�힟�*�y�����.��@�Ғ���R5�3��*m�'����
78@�צ�BА"^��=�y��s�����O������|��9����Vߩ��*\�O�/E-��M�0��#X�3PZ�<��.Բ���Wo�H|Q8p���C}Ws&P�)�α��
	��}�۩i�Ma�}�+�2�Ć@)-��v!3v����49x��n���Ս�^s�� jOD�#�M���u�wȖL��\�g|ek-V�B�H����bUN�p�//,fUp���D=�+���BɆh̩Ķ���H�^=c��\푑iI��Q9�Nj��@�D��A���AK�$w$C}�d��OI��a&#�k[�g�fV���cW��|J‹�ܙ�ԟ�Q�7(��(/V8
:�-]������Pc��Z�^u�.Xד��s�9�5e�`��T�����C(O6I)CU�`g�Y����
�#�*S���Nj&�9c�~r�0����"�(�<�3V������}�|:�k���jpB"�xO�1uPV�
����[���y��{����;�+^�;0�^�]��|c�/
��P��t=�ä>g6���4����>L]P6��H����G��C�����"V��7���t�2Qj�:�,	�|�����Mq�'�=)�s!�3v��Cd��kl8���e_H,7fk��VPl��hs�/bX��1�����GCPV�+�0�S�Լ�(MҊH4�ު�&��DM�W?�i?�ƌ�	Zri���l_�F͒"�+C�����BN�OK1�q���ڛB�>Sc1c@�6�ܖ��o��+����m���9B?�~B�>��WV�%Z?����$���P��
�_��DE�h��,�5З�8�ݪ�<�� ����S��_V�rr1��.��u/̫!�*8�`i8
,�b��OMݟG�$�����l�i4Y��k8��+~q�s�
���2��y�߁Ew`֓w��wm�;��@Ń��w��qT��uO֛1,a��o��=/�
:,�<�Ǚ�N٨E�뷏���7�_
�8h���Ot�oе��Y�sۘG�\�@v*�[j�5X��q<' y�_�>��1&��f��_�!	{���V���FyX0#�H�&Ȃ�����v����w��7%���k`ե��.{Q�P�Gu��H��\2�KMf��*#�a���]}����a�Y2*�T�r���s�+�=*��O!�
�������WP�T�ø��ۿ����O`��͂����!M����;���5�i��(f�) ܴ#��?׎������$��񵙰�m��>l��!�����#�͑)wg�m[{Z�����/V��a����bO�)��)���M���ڹ�^�<X$����/�av�}�:��E�IeH~>�nը��������T[��c�7�	���5�ؿk4�>J`��Vu#��I��H�g�V��H�|��sLf�QH��0�a%k��ۓ���j1������Y���j`f�ҷ�j���<�L�y����65�C;S:�@\�j��b&�cYl��]i���;π��	,��;�b��U��g�x�9��)����y=F�KA���O����f;0�O��j�W:,���4����e!��m��2I#۰��P�5UzX�wԝ��-7~Ky���w���28�pI�lސd��]����=�eh��3��x��ahu…ۿ����t�5����̇��jY�fIh��N���'k�K����i��O�5i^� �v Qt'kB�R6�W�>t�R�������%���-�z���c�<N6�	�ƩzU�C�PEg�'nW2tR
F5m��Qx������Þ]nRւ�t��!YM�z"l>�Ɂ��C�+�q�1x|�R���q�=x��c�n��mM���Ʈ�����_Zc�9���R����C�5�2g���`V�Pd�59�n���>E��H���&`��fc�%wDn�u0ɯ�E��և�W���-C���/�Ff�<�D����?�EH��ߐ�d�b���Ґ�V�7ʸ�<\<t������i��;�q����꥽Vͽ���C�%���,	�T\7�t1S3��
�J�QL{K"�ڒ��:��K4$̷��i���,Z�V������{[<�,�oi]	A�8]�4�o(
��|v����ȅ���#��E�]�o�}����-��K�/E���3�ZE���D�d�\R1Iގq*���l!VW2��j!���M����2�d�F@@�CZ�/v�jr���Y��n���ՖMx�FDzC�;�f,�|`�Сt��'��WnL�-��+�*eݴ02��z
U�x��iH���ӯ�#� 't�n�#e��0E�O�غ|f@�s�Mj�}�X	mms#xF�`$�����wU4~��Ë��4��_ƃ��:���Y:�V��
)��\��7'��: ����_��T���K,Q���eLػ��ʂ>��!8�����ȤF�A�9��9��V3V/������Cg�NX�k��<y��E�|�����6w3�F��˚ �֥׸^3�4�:�*�,If�3��K�o�xOk�fwn��ws9�^�����m^���5����ЗC����qP�#R*�:�0����]�ߥB)����6r�@ OWa���Wi��ZФ�S[��	�^ ���o��m���gu�kЃ�﫣���>��j���t�g�Y�H4˻/��ܿϰYs��P����=L���V������i�����`mM+�B�ɍ���,����O�H€#�Jg����L��'dp~x�0J2���8K���Sܘ�ţ|F�ś��M�p��M?skm
Cw������>�4�I1>+���V���/�m:���Ti8~-�Ja9E��T:��({�[i�Ɇ <���K~I7T3
Ne��VQd�"�e�U�Pa`�����ۅPYA�6�Sb�)���Nq��	��|�En�>�ͽS��}�.g�V�e��y��O�����0k�P��r������K�'Ϗ<
S�$�?�M��Bo��t]�&�{,�x����$&�Z�g�4O0��i�[��6����]#x�7�_1�o�C�M56�x�5#[�Rt��9E����V�6l�~���;eR
%������ֳ���n�ZqB亗6�.gb��t��0ѡ�nj���1��V�7iM68/���'͆4��3�w�:�_(�K����E�(�u�����i]öҤL`'F� XƵ&ՌX3��^rC�i_�EM�^6����̘�u��jJ0��K:��	�!J/{$�u�<[�<��*X�:�ޖ��0,�DGP1���V���=�( ���t�@��Ԣ�Io���Ъ�x1TZT��~�.�q�K�++�ʯN�p"�x�Z�t��9N���Yz&M�u��ܲ��Н����f��/I�6�
��C��'Պ�̇���p�<{&��*ϕ���aT�n�Ex1߸�[�i� �`��A�����^�(�E���ݓ<C�Q���rI�+���������;$DD���V����_�_�_�_�_�_�__=ՒQ%�`�`� j�u�wyz{#|A}o~�~&<S�E�������a�}�������p�������Y���W�E����>�����T�p��������������3���w�)�����b������x�U���p�����(��������k�����k�j����u�9�����0������J�����^���]�	���9�`�������^�t�������i���2������w�
�x5��� ����%�������i���e�����������X���������s�������s�	��@������
z$�I�~ ;!Y!�!�!�!�!]"{"�"#s#�#�#$�$�$�%�'�'j(�(N)�)5*S*�*�*�*�*W+u+�+,m,�,�,-�-�-y.�.>/V/�/�/�/&0�0�0'1M1~1�12�2�243e34H4�-4<"<@<�<�<�<
=g=�=N'>ODlD�DQ&E�HI)IXI�I�IWJ}J�JKOK�K�KdL�L4MeMN~P�P�P@QdQ�QR6R�R�RKS|STLTU�U�UV�V	X#XAX�XY"Y�Y�YZ�Z�Z�!^�`h�-������
:'�.��m���|�����`�������y��
�����6�u�Q�k�������������q�������K!�!�!�!m"�"�#$�$Z'b'j'r'z'�'E*�*�*�*g+�+},-�-�.�.�/0�0D1j12�2Q344�;�<�=AD�D�HFI�ItJ�J;K�K�LQMpP�P]Q�Q"R�RhS8T�UV�W3XYY�YaZ�Z))))))))) 




&
))))))(((((((((((''%%&�^�`aUo�uxEyRzA{Y|w}�~�~+Ai�[��������݂�������
���������-��Œ��:���ݚ'���S�����-���B���[�]������ɪx�%����@��|���m����8���g���v�����3�{�������H���ؿQ���]�:�6���;��N��,�i���������������������������s����
��g�
3��B h � $!l!"�"#�#-$�$'�'�'.(T(�(�()8)�)�)�)*f*+�+,�,'-�-�.�./@/[/�/�/90�0�122�2x3[4�;<'<E<�<�< =�=
DTD�D�H�HIkIJ�JbKL�LxMCP�P�P�QIR�R�S_T}U�U�U/V�W�WXTX5Y�Y@ZvZ�Z�%�`�`�`�`�`�`�`�`�`�`�`�j�u�wyz{|<}Y~^~d~j~�~!7M|2�@���Ԁ��[�w�������k�����τT���Q�?�(����8�Ǐ�N�j�א�����ב����.���q�#��͗��]�|���ܞ
��r�O��j���â"�
������f�����Ĩe�d����o�3�ӭ��*�����=�D����Y�~���W����3�[���{���Y�o��������d����,�����q���r����������������d���'�,�0�4�8�<�@�D�J�P�U�Y�]�a�����������������T�}���������o���������������a�n���������
vx��D��S y !5!W!�!�!�!�!W"y"�"#m#�#�#$�$�$�%�%�'�'�'?(e(�(�(#)I)�)�)	*/*Q*�*�*�*�*Q+s+�+,g,�,�,-�-�-g.t.�.�./9/S/v/�/�/�/�/0$0z0�0�0!1E1K1v1|1�122�2�2�2.3]3c344@4F4�4�;<<:<�<�<�<==a=�=�=I>CDJDfD�D�DLE�H�HI#IRIVI�I�I�IQJuJ{J�J�JKGKMK�K�K�K^L�L�L!M.M]McMNrPyP�P�P�P:Q^QbQ�Q�Q�Q.R4R�R�R�REStSzSTTDTJT�T�U�U�UV�V�WXX?X�XY Y�Y�YZaZ�Z�ZR[V[][b[i[n[s[z[�[�[�[�[�[�[�[�[�[�[�[�[�[�[�[�[�[�[�[�[�[�[�[�[\\\\\\\$\)\.\3\8\=\D\I\N\S\Y\_\g\m\u\}\�\�\�\�\�\�\�\�\�\�\�\�\�\�\�\�\�\�\]]]]!])]1]7]>]E]K]R]Y]_]e]l]s]z]�]�]�]�]�]�]�]�]�]�]�]�]�]�]�]�]�]�]�]�]�]^
^^^^"^(^.^4^:^@^F^L^R^X^^^d^j^p^v^|^�^�^�^�^�^�^�^�^�^�^�^�^�^�^�^�^�^�^�^�^�^______$_*_0_6_<_B_H_N_T_Z_`_f_l_r_x_~_�_�_�_�_�_�`�`�`�`�`�`�`�`�`Ro�uxByOz>{V|t}a~g~o~�~&<S�E�����}���ǂ��Մ�������{��p����ݑ��o�$�֔�ǚ������=��������,�r�E�G�ϥ��������b��Ӭs�*�ʮf��B�W������"���Q��`��ݷ���v������i�!�2��¿;���G�$� �����%���8�i�'�*�2�6�:�>�B�H�N�W�[�_�e�����������������������s���������������c�y���}�p����
��ez ��@ U � !Y!�!�"#�#$�$�%'�'�',(A(�(�()%)�)�)�)*S*�*�+,�,-�-i.{.�.�./>/X/y/�/�/!0&0�0�0H1y1~122�2�2`3e34C4H4�;�;<"<@<�<�<=
=�=�=DHDOD�D�D�H�H�HITIXI�I�IxJ�J�JJKOK�K�K�L�L#M`MeM>PwP~P�P�P`Q�Q�Q1R6R�R�RwS|S
TGTLTxU�U�UV�W�W	XAX"Y�Y<ZcZ�ZU[[[`[g[l[q[x[[�[�[�[�[�[�[�[�[�[�[�[�[�[�[�[�[�[�[�[�[�[�[�[�[\	\\\\\"\'\,\1\6\;\B\G\L\Q\V\\\d\j\r\z\�\�\�\�\�\�\�\�\�\�\�\�\�\�\�\�\�\�\]]]]]&].]4];]B]H]O]V]\]b]i]p]w]~]�]�]�]�]�]�]�]�]�]�]�]�]�]�]�]�]�]�]�]�]^^
^^^^%^+^1^7^=^C^I^O^U^[^a^g^m^s^y^^�^�^�^�^�^�^�^�^�^�^�^�^�^�^�^�^�^�^�^�^�^_	____!_'_-_3_9_?_E_K_Q_W_]_c_i_o_u_{_�_�_�_�_�_�_�~�~3Iq�;�c����B�i�n�����Z�x�����B���A�/� �6�{�(���Տ5�\�������ɑp������a���)���M�u�ƞ��d�9�ˠT���������ۤ��P�~���F�E����P����k����ӯ
�2�~�ܰC�q�I�����M�����m�<�[�����λ�L���ܽ)�¾���a���k�����[������������]���}�������=�m�������V���t��������.�k������q��=��L r !.!G!�!�!�!�!?"i"�"�"U##�#$�$�$G%�%&'�'�'8(^(�(�()B)�)�)*(*A*�*�*�*�*9+c+�+�+O,y,�,-�-�-?.q.�.�.//K/f/�/�/�/0b0�0	1@1f1�12m2�23M3�3404�4�;<2<P<�<�<�<I=�=+>"D_D�D.E�HIIBI�I�I9JpJ�J�J7K�K�K@L}L�L+MMM�MXP�P�P"QYQ}Q�QR�R�R'SdS�ST4T�T�U�U�U
V�V�W�WX/X�X�XYmY�YZGZ�Z�Z;[�~�~-Ck�5�]���܀5�c�a�����M�r�����:���4�"��.�)����Ϗ(�V���ސ���Ñc������T���!����@�d����\�,���G�֡��٢�v���x�C�m���9�8����C����^��������!�v�ϰ6�`�A�ֲ���;���`�/�N�}���Ȼr�?�����#������[���e�����F�����	�����~�W���j���w���4�Z�����}�I���[����������e������h��4��C i � %!A!�!�!�!�!0"c"�"�"F#y#�#$�$�$)%�% '�'�'/(U(�(�()9)�)�)�)*;**�*�*�**+]+�+�+@,s,�,�,�-�-!.k.�.�.&/B/]/�/�/�/�/S0�0�0-1S1�1�1^2�23:3�344�4�;
<)<G<�<�<�<:=m=>DVDrDE�H�HI/I�I�I*J]J�J�J$K�K�K1LjL�L%M:M�MEP�P�PQFQjQ�QRuR�RSQS�ST!T�T~U�U�UV�V�W�W
X)X�X�X
Y^Y�Y�YAZwZ�Z-[�~�~5Ks�=�e����F�k�r�����^�z�����F���E�3�$�:��,���׏9�^�����ˑt��� ���e���-���Q�w�ʞ��h�=�ϠX����	�����ߤ��T�����J�I�����T����o����կ�4����G�s�M����!�O���q�@�_�����л��P�����ƾ���c���m����������������_��������B�o�������[�����h�@������v��B��Q w 
!3!I!�!�!�!�!D"k"�"�"Z#�#�#
$�$�$i%('�'�'=(c(�(�(!)G)�)�)*-*C*�*�*�*�*>+e+�+�+T,{,�,-�-�-P.�.�.6/P/k/�/�/�/0g0�01B1h1�1	2r2�23O3�324�4�;<7<U<�<�<�<N=�=0>+DdD�D3E�HI!IDI�I�I>JrJ�J�J9K�K�KELLMOM�MZP�P�P'Q[QQ�Q R�R�R,SfS�S6T�T�U�U�UV�V�W�WX1X�X�XYrY�YZIZ�Z�Z@[
������������	��.�������.�������;����!���(���T�����.���C���\�^���������y�&�����A���}���n����9���h���w�����4�}��������I����R���^�;�8���<��O���������������������4�i %!m!"�"#�#.$�$ '�'U(�(9)�)*g*+�+,�,(-�-�./�/:0�0�132�2y3\4�;!=�=D�D�HlIJ�JcKL�LyMDP�P�QJR�R�S`T~U�U0V�W�WUX6Y�YAZwZ�Z
���ނ������	��������.���ǒ��;���ޚ(���U�����/���D���]�_������˪z�'����B��~���o����:���i���x�����5������K��ۿR���^�;�9���<��O�������������������m!"�"#�#.$�$g*+�+,�,(-�-�./�.�/;0�0�142�2{3]4"=�=�DmIJ�JdKL�LzM�P�QKR�R�SaT�U�U0V�W�WUX6Y�Y�Zt~�~X�J�������̂��ڄ��
����������u�����t�)�۔�җ̚���B��������1�Ȣw�J���L�ԥ��
�
���g��جx�/�Ϯk��\����'���V��e����"�������n�7��ǿ@���L�)���%���*���=�n���������w�������}�|"�W ![!�!�"
#�#$�$�'C(�(')�)
*U*�*�+,�,-�-/|/(0�0�1!2�2g3J4=�=�DZI�I�JQK�K�LgM�P�Q8R�R~SNT�UV�WCX$Y�YeZ�ZT���Wdq{�!Y��-7Y���)6@J�
",9CM�����	 *4��Xbmz�������
��#i+���������m��%s.4-MT�_�\	4"�"#k#^�3"[�"#j#�#4/�/�U�W�W�,"T[�0"XJ�v�b���J���I�7�(�0���=�����x�$���i����U���r�G���b����������^���T�S����^�"���y���������Q�W�����+���y�H�g���T��������h���r�����������d���M�����`�����{�I���!I"�"_#�#�$r%�*C+�+Y,�,�-Y.r01�1}2 3�3�4Y=;>>E�IIJ
K�KPLMN2Q�Q�R7S�S�T�V�XwY
ZE[�~v�h�����5����^�`ڀa���p���͏T�ܐ����b��k����^�9��t�ƻ�����%�������X����c	�> � ?!�!�!�!a"�"w#$�$'�'*(�()�)�)9*�*�*�*[+�+q,�,�-y.�.V/�/�/�0+1Q1�1�2834�;�<k=DpD�H-I�I[J�J"K�KhL8M<P�PDQhQ	R�ROSTvUV�W'X�XY�Y:Z�Z���8'�.�;9D�HhP�U�WWZ���*'�.�;-D�H\P�U�WKZ��	 $(5ASgz�������������,0G_cjnuy�������������
#'.59@DKRahosw~�������������	
&*18?FMT[bipw������������������ $+29=DKRYm�����������&+05:?DINSX]bgt|��������������	
			&	.	6	>	I	`	g	n	u	�	�	�	�	�	�	�	�	�	�	�	�	�	�	�	�	�	






"
*
.
6
:
B
F
N
V
h
s
x
�
�
�
�
�
�
�
�
�
�
�
�
�
�
�
�
�
�
�
�
�
�
	
2:HMUejrv~�������������������
+3;CKS[_gos{��������������




 
(
0
4
<
D
H
P
X
\
d
l
t
x
�
�
�
�
�
�
�
�
�
�
�
�
�
�
�
�
�

&*2:OT\`h~�������������������	!'-39?EKQW]ciou{����������������������#)/5;AGMSY_elsz�������������������
")07>ELSZahov}������������������	%,3:AHOV]dkry�������������������!(/6=DKRY`gnu|��������R'Z'b'j'r'z'�.�.�;<D�HkP�U�WYZ�n�����}�DŽȄɄʄ˄̄̈́ڏa���Α��������������z��������	�
������������������������د9�:�;�y�z�{�|�R�n�o�p�ջٻݻ�
���������s�������M!�!o"�"�#$�$G*�*i+�+,-�-0�0l1
2�2S364�<�=�DHI�I�J=K�K�LSM�P�Q$R�RjS:TV5XY�Y�ZaVo�uxFySzB{Z|x}��t����
��_�p q�ɗ?���s�����΄ߏf���ӑ��{����ݯ<�}�W�q����������x���R!�!�!�!t"#�#$�$L*�*�*�*n+�+�,
-�-�/0�0D1q12�2X3;4=�=�DMI�ItJ�JBK�K�LXM�P]Q�Q)R�RoS?TV:XYY�Y�Z=+RC17$<*QB\0H6#)PA/G5"; (O@.F4!:'N?-E39&>X,D28%�����	%�e�f\core_intrinsics�	derive_eq�����i0�Kjz�3�z/t:}Ԕ���i0�Kjz�Er^�4r������(��Z��i0�Kjz�Yw�T����m��\����i0�Kjz�Z��A/���t
f�}�J���derive_clone_copy���i0�Kjz���v�H����ܝ ���i0�Kjz�i?(F�O���������Z��i0�Kjz�K��T����
��}����fmt_helpers_for_derive��_�_i0�Kjz�V�v����m���\����i0�Kjz�0����������������i0�Kjz�s��~�����������i0�Kjz� �������`���O\�����i0�Kjz�W�$_�0�	]�6�����i0�Kjz�3���������(`��i0�Kjz�쒗�޸����������i0�Kjz���ISJ��~
$��u���������i0�Kjz�|L�Bw�B���� ���i0�Kjz�?$�k�u������P��i0�Kjz��u,B�]q�
��u�=����`�`i0�Kjz�b�ޝ�I=�$��������i0�KjzнL"��������������i0�KjzГ�q���r����"��i0�Kjz�o�%龎�U����������i0�Kjz�p�a�8H~	$���������i0�Kjz�d>����]����)���i0�Kjz�gbXzV�-��C��������i0�Kjz�0�t��J��	 �����`�`i0�KjzЧ�
ʪ'�ԧ�[�i0�Kjz�S�Qz�G2���ڜ!\��i0�Kjz�/���Z�����C���i0�Kjz��YЊ�0q�

�`����i0�Kjz��\$��%�
������i0�Kjz��!��@w����������_�_i0�Kjz�C��
��t#��������i0�Kjzоܟ���'�t	c$������i0�Kjzе�(��n7
��Ԙ'���i0�KjzЧ�N� o#�X�������_�_i0�Kjz��5����3�	�������_�_i0�KjzЌ�N�5P�����W��i0�Kjz�l_�r ��
�z�����_�_i0�Kjz�\��5������C���i0�Kjz�:�#Kq�d��
�������i0�Kjz�h�����~$��Y������i0�Kjz�#��ς�]G��E�����_�_i0�Kjz�qR=�G�����6���i0�Kjz�AB��G�d���������_�_i0�Kjz�	{�K཈��	����`�`i0�Kjz�B�$J�/����	��i0�Kjz�Ld�]�>��������`�`i0�Kjz��R��N
�	J	����i0�Kjz��+�=��6/��қ)�	��i0�Kjz�H�(<*���U�����`�`i0�KjzЃ�aGZ%����C3	��i0�Kjz��8?����
��E�����i0�Kjz��y���f�tD
������i0�Kjz��_&Ӳ��O��Ь=�	��i0�Kjz�[!�N1�f���	�����_�_i0�Kjz�Tj6����	�����_�_i0�Kjzз�������b��	����i0�Kjz��ᇺ5�$�����i0�KjzЫX��W���	�>
����i0�Kjz�7�����+����)���i0�Kjz��s�����4��
����i0�Kjz�9���E|��
����������i0�Kjz�V��E��<����!e��i0�Kjz�`k�!�J�:t��.������i0�Kjz�<.[�f��S�����i0�Kjz��H�t����(�������_�_i0�Kjz����:T�k���S��i0�Kjz�X�
�3��.�"�*
����i0�Kjz�/��6�\4�3�%w%O%/%%�%�%�%[%3%%�$�%�%g%?%%�$�%�%o%G%'%�$�%�%{%S%%�$�%�%c%;%%�$�%�%k%C%#%�%_%7%%�$%�$�%�%s%K%+%�$�%�%%W%�%%�%�1|0*.�+�)J'1�.l*8(�3�/--+�(o&820�-�+k)'�2�0�.Z,�)�'73x1Y/�,�*�(�%2�/�-u+1)�&�2�0Y.),�){'3C1$/�,�*f(�3�1�/\-:+�(�&g2K0�-�.�,8*�'i3J&�+�%�1�0I.,�)k'31/�*V(�3�/L-*+�(�&W2;0�-�+�):'�21�.,(*�'Y3�1{/-�*�(:&(20�-�+[)'�2�0z.J,�)�''3h1I/�,�*�(�3�1�/�-e+!)�&�2l0.�.�,\*((�3_&�+�hODHT +�����5�������49x�p"�x��<�� ����65�C;.�		lD�M#x1߸�[�%�[�	���8[���y���)
D�lO*m�'���tq
d��M�����6h��,�5�8�`i��q�1x|�[,	�T\7�u�ś��M�����ȸ/�R&|G��iH���9E��T:��Н����/�
:,�<�����,���M�z"l>�Y����#��E���K4$̷�y��q<' y���^�(�E�(��s�+�=j	��,��@P|ek-V���W:,��9g�4O0�����jJ0��K�'nW2tRT�R5�3��s�Q�7(����H|Q8p��V��7���c�7�!�+^�;0�^�'��: ���Z�>\�K4MR��?���.�
��C��' E���D�d��ms#xF�`�Xf2GX�EOMݟG�$��jY�fIh��Hg�Y�H4˻����K,Q��Ys��P����sLf�QH��'�0�S�Լ�fk��VPl����FyX0#��^�<X$�j�}�X	m�g�m[{Z��"\`��f,{�]hU�g��>L]P6����e_H,7�s�|�`,�7=
)��\��7�6�Sb�)��[D�d�>D`���d�
CI��kl8����qP�#�П�r$��*\�uT�V5UzX�w=��-�z��P����|L�o�<���_��DE��Պ�̇��!9�;\�|e]	A�8]�~j���t��Bo��t]��K"�ڒ��:x�+�2�Ć@�ۢ�?����a�_��H�z
i�[��6��C�PEgS��}�|:��&���:Tg6���4������/�avrr1��.����i��;�q��x1��>�4��
Cw�����m�;��@���������H(�����Z�i�����`��/
��P��z
U�xුt=�ä>�Ë��4���><���|��!w$C}�d�˚����$������ȤF�����̘�ub���Ґ�Vn�C�����"�]öҤL`��A����'����T[� �*S����Y�sۘG������l�i�f�<�D��k&�{,�x��(G��|]`���L��'d������|�y*���l!V�
%��������L�2��=_�]�o�}��5�i��(f��H�|��&�`+9��k�����K����cW��|J�K����i�J���V���]��|c�;0�O��j80E�O�غ|�^3�4�:��ۅPYA���[j�5X�'x��a�"(����iĶ��i��m����]#x����Mq��q�c�Y1+-h���O�:��	�!
�9����zIA����D� �v Qt'Lt��!YX�i� �`&t�n�#e���WV�%Z?����$&�Z��~r�0�����9�5e�`�nɋ�6	I�"	���5�ؿ"Rt��9E���DM�W?�i?��
78@�צu��?�EHlE�kRBm5�+���BɆh�_�
D	6�%��@�D��A�0ɯ�E���h�ߥB)кmM+�B����^rC�i_	��8K����-��M�0}۩i�Ma�}��bUN�p���_T]��Y:�V����({�[i����L��\�g�n���^�Ֆ	��_��T�����`if'@ OWa��Ӽ�;�b��U3H�^=c��\��b&�cYl�0�V�e��y��//,fUp��H�g�V�%=�eh�C���?ia7W2��j!��Ё�8k�}�Ok�fw�
F5m��U��m�����7�_1�o�/�.p��B��-q��l��+~q�s�n��ws9�^�)-��v!3v�w`֓w��w���g�x�9�4<�L�y���-��Ez�q� 	�ƩzURk��<y��E��S��}�.g��wU4~�ޝJ}B��r�5����%�OVߩ��*\{����m�C6H�ހ��vi�m�X�c��¿N!	{���V���^��y�AV�
���뫱_�>��1&����m��>lm:���T�7��A�VX/�!��y�����!M
A�9��9�ɨ�u/̫!�*�bO�)��)�O���-��"�xO�1uP���n���ՉQx������V��T����M޻�H�$[�<��*J/{$�u�<ԝ��-7~>���.�58�kʂ>��!8��]������P�Pa`�����nը����X,�5��*W�a���]}�̩Ķ����;π��	,�2�n���Ս|`�Сt��ve�A,�`Qթ�sE˚ �֥׸�З�8�ݪ��)����y=5y�߁E�?��]y@2��
��f�h��=�y��w����{[|�t�@��9���R�`.gb��t���S[��	���ƌ�	Zr�o��+�������&`��ff���NNM\�@v*���ڣV�&�-��'�,���.�/(/V8
:�-��H�&Ȃ���w��qT���uO֛1�	��|�e��VQd��BА"^v�Z�Y.(VSL�-��+��=�( ��*��O!�
��ӯ�#� '�i8~-�Ja��hs�/bX��*eݴ02���p~x�0J2���C�M56�x����6rݻm���9B�V�$�;��H�c�<N6�Q~���;eR����>R�� 4��?&�c����BN�O�c�%wDn�ug\R1Iގq�,-��J�TG@i0�Kjz�k4�>J`�#�(MҊH��)G�N���v��FO2���GCPV�+��*�,If�3�Þ]nRւ�Wf��/I�6WP�T�ø
���rI�+*'F� XƵ&���Yz&M�H��\2�KS:�@\�j�/��7�_
�8����_Zc�_�;�afe�\OI��a&#���]i���1�ҷ�j���,�i��z�pI�lސdA��m��2;��c�n��m],a��o��=�R���q�=x\���w��7��p�<{&�"�~ U}΋�G�IeH~>�P��r���q�����rw3�F�����{����;��4$h��a?9�Nj�a���f(�3�a����\<t����pWi��ZФ�;��̏�A+��P�2�4d�#�͑)w��ۿ������:�.S�Y�|�����6�L��Ė.V?bֳ���n�Z�qB亗6���4����e!:�EM�^6
�.C��X.Բ���Wo����i��6p�P��f�]k[�g�fV���3�w�:�_"��W���3�å��0��Cg�NX��1�����8
,�b����W���c�)^ ���o���M���҉t�oе����
���2���Mf��*#�7ʸ�<o��\��}C�����>���I#۰��P�<����.�qk���jpB��w���NAJ^V3V/�����X�:�ޖ�4�ު�&���aT�n�E$M���Ʈ��^��'͆4��En�>����"�e�U��v��]і�:TZT��~c��Z�^u����$���
	��}لZ�t��9N@�6�ܖ���������	�,Z�V��{��V�6l��F�KA��6�u��ܲ������
�#�9�n���dR*�:�0����-��Kʃ��O����k`����S�
�@�+�"��Kf@�s�M�?�~B�>���f�"�Jg[a�H����G��_ƃ��:��������6�bJ��^s�� ��Ǚ�N���ߐ�d�m�Vͽ��s��K�o�x���P��
��4�o(
��|t1S3��v'Ϗ<
S�$�%���k`���0ѡ�nj�ՌX3��C}Ws&P�$�����v����ȀgJ1�U@9Ԣ�Io��) ܴ#��0�a%k��(�C�%���t���C(O6I��"�(�<�힟�*�y�pI1>+����g83�,C?OF�;�f,�����.{Q���/�Fj��0k��E�(�u��P�g2��I�2;t�>~I7T3
N��5#[��kB�R6�W�M7iM68/�Nj&�9c��2Qj�:�,	�����;���OEM�<�8F���D=���}�:��Ep��M?skm���ݓ<C�Q)�0,�DGP12�d�F@@��P�Gu�>E��H�e푑iI��Q��Mx�FDzC����K�s`L���AK�$��#�Jg���?�M����O�/E|
�J�QL{w>t�R���N�B�>Sc1c�*�T�r��z��[_$+~�3�[7�PUC�]]ޢ;)CU�`g�Y��T:Ad'w1^=-�ek�@��j`f+V�Pd�5c�O�5i^Ki���l_�F���Nq����.�q�K��t��M���u�wȌ�3��x��D�|����:7����Q͒"�+C�����E��Fvj��]����Bahu…ۿ�E�T_��8R��!������W���-Ci����]�8r6��7�J=��+��[�@�Ғ��r�.Xד��s�3v��Cd�ۓ���j1)���a�Y2‹�ܙ�ԟ����C�5a�Vu#��I�$�����m^���ЗC��������v��K1�q�����jr���Yٌ�*ϕ���#�CZ�/v���O����f7Ky���w?B�H�����3V������)�α���N���'k�I<�,�oi}������++�ʯN��2g���`b���28@V���/��s�����O�xSܘ�ţ|F�4Y��k8��O`��͂��S��_V�������/V����̇��G�?׎���gu�kЃ����D�җ�_Ɂ��C�+ZjOD�#����eLػ�¥/E���3�Z��=L���V���#X�3PZ~/��ܿϰ���M���ڹ����߯g�n� <���K����1��V��'�=)�s!����'��Wn�������<٨E�뷏�����t�5�F(�K������O�H����f��_��������Y�*@<c�O&w�l�	�6S�&zC@d[|p^����K"c��bM�� MY�%)���Gtu/S�%o���Y�0"L]T����z|�^��B�6-q{~O�!������W����R��E����;sU��	���v���
���>�Y��W� ����E=��3H��������J�;}n
�T��y���ANB0r����[��Th�eCq��:�����+0gK���Zi4O���?2���A+f�/F�N��o~���%K	u�5>����j,4����������e<x��'�M���"�,0L�s���������J����0t_�l�����S$P4L khd/�g�>���������d3�K*
i*.|<8^_H;du7xr9/��;;^`c"3o�u��E.���!��;�,���_�`���sU����6��*��+�ud����|�p���(�jr��G��?lO�(~p����z�IRj	��9\������"���� B�l-��\�����Sw���_9y��������3
������sSA*�>�2��/�+�p����KP����������0�L\R���<n��!�N)}��'�:����8#hY$rRl\��&��%R�EHp������Cqh26�<��������Z�SF|R��Z�05���hu[R ;�yh-A��,78xD/��m������s`xW��i	f>_�P��	!%^`|"z������\�fM���Z�l'�n[@bYeC���T�������}a-_����^�1��'g}<�t���>Z�����j�5����
(��vd P��y�dz�$d]'A	#IZ'fB�T}#"6(���� \(!0
Z"�=_1H������(Q��,��� �
��#����jU�Bd��~�����o��v�;q{�����	f��!.%o~9O^/{������mlPA����3;R	W	~O������0���y��@#�
A�I�ok��Hw���a�-+-X\Z%���a��e�7mC���}����	�aW�D������@<c�O&w�l�	�6S�W/home/palash/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/log-0.4.29/src/lib.rs� �F��r|�拏L�=�s���A?#EB@A$"JNN;PL?QQPDS4@J=J#!!##J^HO/26*K#5&H
VM;7B5GNE:2A#*J#3&H
(:(;8=,'%# cQL+(%9,
)1D
NPNJPOKN?>"':*,02!=Q-PEQND':*26=c[_b_   daCXY%d(b;]dcb")'-79;,F:P8A>;/>/5)5_>G8A>UG2;L<0UA1A;A@@AABBCCABBBBC5QPPQQRRSSQRRRRS=-
"0''!'',(04G2'$NN*1EJA @XV;!NGJHD,D(KOz)
'
/L(0*)J7 ;+.B<
!=
/%$$%%
0>39:K+(6P(77254e!>Su/&73d!=Su/&ENKU'-D+	.-
-
..(*)D7 A+.BB
!$=5)+**++
7"38.*@K+(8G.;=25:e!.K`�/&79d!.J`s�/&ED,.
$
LFMDKKMIC%>	-1
#$%$	.13-&.+0*(;)=,0*.,#1&(3*E?!8
0,#M88
)(D2X4%02!/!!5
0]Y/#2)%-%1I/0-1&#.2%*1'!'6 SR((7#'F
6Q!
�S)
DF,
EJ.
CUF
YaD
5N?
LZ=
5J!
AV1
1(%"
ACEE)(!9,
)1D
>.,#1&4]_/'*-("7!+!!*!$
AF#
CL'
%*'?IKOEUL4LH$&E\&.!5#%#5(%#"5(%#'Pr
"+C2M=@
J6NCK$-
7O`CC+\M8!!!-$-EIGPNL,JG% 
;'8N+0PQHNOMJ4
;H+!9,
)1D
*+1"L "E%"(9
B($
&/M:=
J0NCG$'X*9
[a
&S'''=(/([Y'  (=)/)'F&L=@HFE86+

\/PQN1IJNLLNN>B@@B
H%+/--//+/--//0+.
/)'')))''))0+.
%##%%)3
57!9=432535G7G HH$'+))++)3
 ,&"-* &,,(-* .'"/)!"&.-(/,%5/'-<6>5=5=6>>
*)5<>>====>>>>4<6>5=5=6>>
#$B&!$3!95-0!955F./ &><52+'C., &3<52($,&!37<52*,!
;"$)&
9F=?+->A!'#)4U /% ) );'$'#$'
"�<���o�TO�j�Z/home/palash/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/log-0.4.29/src/macros.rs� wwi\gŖør�� `�o���F?#EB@A$ M""CPP""
#Q*A2 ""!
#U'WSWO4
;94;
=9@
(#@;
q�K(?as
WOK(?a
'820IFcKDnN6.]P8.F#D&8,+OJbJDmM5.\O7.E"C&82:O%6(6(bJDmM5.\O7.E"C'8)08NKcKDnN6.]P8.F#D'8)078?@5?@cKDnN6.]P8.F#DNP)*%:8$%?6$P7$PRIB^4,|6,j!�IB(*EP ,@/5O ,-/+%.9
668 8*)*O 5! d!6"!^
!5 !]
ҫ�C�0�r��2Ҭ
Y/home/palash/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/log-0.4.29/src/serde.rs� �d�&G���B���G��b� ^
.2OE
TRRTT
'A
 5 Q1D3%[(E%cL4Z(
= V&E
/ Q1N$M4)
Q!E
\`^^``
-A
&;&Q8D.%[(E%^L4Z(
C&V&K
 5&Q8N$Z4)!
X
%V5
B
+#
:
+!
<!
I
%#
A
%!
42244%(
'42244%+
:88::'-
'54455'-
??H$=A??AA%(
.=A??AA%+
&CGEEGG'-
.@BAABB'-
&?FU��8NP;���&�a/home/palash/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/log-0.4.29/src/__private_api.rs� 컇8iX�7�"��oQ��]34
%H 2>>
5#%5K# _)/'!"J$HM-(?A8VX\V! R!]V���.Mi�Xs�
L�zk�s�v�xx86_64-unknown-linux-gnu���Pz��Na�i��M�
-f1ce6776ce589c15�i0�Kjz���	R�&�
������D�"D�����������������	����������
�
����������������������������������������������������!D����^�&]�]��؅rust-end-file