rust |#rustc 1.76.0 (07dca489a 2024-02-04)20@vϑ+I-693a8f23970c5917c\i %LRlU-13fc9d1ed9c7a2bcrustc_std_workspace_core vJ][.(b{-5af394d9b1f07bdcWerroredd  dddserdeekvfee kv_unstablee eeCellgfff   gfff&gggg   gggg&ah ggg   hggg&hhh   hhhh&nnn   nnnn& KeyValues ߼ ݼ  ɽ ɞ ͞   מ͞Ǟ    set_boxed_loggerԺ غ ܺ   ܺ   غ/Һ7        log tests   macros     info  trace  log_enabled  __log_keyLOGGERSTATE UNINITIALIZED INITIALIZING INITIALIZEDMAX_LOG_LEVEL_FILTERLOG_LEVEL_NAMES SET_LOGGER_ERRORLEVEL_PARSE_ERROR!ok_or##E&&from_str( ( ( ,..max.to_level_filter..3 5799; ; > @@@to_level@@E  G'aGget JJbuilderJJmetadataJlevelJ JQ Jmodule_path_staticJT J file_staticJ XXXXXX XXXXXXbuild ee<hhhh mmmm mss<Logvenabledvvflush NopLoggerz ||| set_max_levelset_max_level_racy max_level set_logger set_logger_innerFset_logger_racyloggerNOP __private_api   STATIC_MAX_LEVELMAX_LEVEL_INNERget_max_level_innerLevel  Warn Info u Trace  LevelFilterOff    u   !"#$%&'(MaybeStaticStrStatic  Borrowed  )*+,-./012Record34 RecordBuilderrecord5Metadata 6789:;<=>MetadataBuilder?@ABCDEFSetLoggerError  GParseLevelError  HIJKL 7 7"7"7(7-7-7-717273 67678787;7?7?7?7C7D7E I7M7N7O7P7Q7S7T7V7W7[7\7]7^7_7`7a7b7c7d7k7l7p7q7r7w7w7w7x7x7x7y7}7}7}7~7~7~7777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777vu.........M.O..u۽x./a.M.//////////M/O//./.a/M/            5    6O  M  ݜdMݜdM  ]  ]f! ֒7! ֒7! ֒7! ֒7! ֒7=! ֒7! ֒7>O! ֒7M! ֒7"ɣ"ɣ"ɣ"ɣ@"ɣ"ɣAO"ɣM"ɣ"ɣtvzz{ ޢ␈]v 7M$  MDM$  UDDDDDMD |z7!,>5&9sev /M*O#a6 M ?* ##p HHH CHHH vpIp)IJpIHIHCp IHII zHHIIHCIHp Jp qJp0KavIp KrKLrLLrL0sLLrLLsL1sMLsMLsM2s NsKsLNs?NLs Nt2 tOFFPtERRORPtWARNPtINFOPtDEBUGPtTRACEPsWPPLt PtPLPPLPP6toQJattempted to set a logger after the logging system was already initializedJJPtRPtRvHRFattempted to convert a string that doesn't match an existing log levelFFPunSPuS|TLTTLTT1 z"TC TU/:U/ UU/MAX_LEVEL_INNER V V;V/ V_   / W WW  WPWW YYYYPYY YYDYYY ZZDZ[ZZ #vz{ ddeJmeme FromStrea    ! '.7 : af f A lightweight logging facade.!F The `log` crate provides a single logging API that abstracts over theIJ actual logging implementation. Libraries can use the logging API providedMJ by this crate, and the consumer of those libraries can choose the loggingM7 implementation that is most suitable for its use case.:L If no logging implementation is selected, the facade falls back to a "noop"OH implementation that ignores all log messages. The overhead in this caseK; is very small - just an integer load, comparison and jump.>M A log request consists of a _target_, a _level_, and a _body_. A target is aPM string which defaults to the module path of the location of the log request,PL though that default may be overridden. Logger implementations typically use O@ the target to filter requests based on some user configuration. C  # Usage  O The basic use of the log crate is through the five logging macros: [`error!`], R0 [`warn!`], [`info!`], [`debug!`] and [`trace!`] 3< where `error!` represents the highest-priority log messages ?F and `trace!` the lowest. The log messages are filtered by configuring I9 the log level to exclude messages with a lower priority. <F Each of these macros accept format strings similarly to [`println!`]. I   [`error!`]: ./macro.error.html " [`warn!`]: ./macro.warn.html  [`info!`]: ./macro.info.html  [`debug!`]: ./macro.debug.html" [`trace!`]: ./macro.trace.html"F [`println!`]: https://doc.rust-lang.org/stable/std/macro.println.htmlI ## In librariesD Libraries should link only to the `log` crate, and use the providedGK macros to log whatever information will be useful to downstream consumers.N ### Examples ```edition2018+ # #[derive(Debug)] pub struct Yak(String);.. # impl Yak { fn shave(&mut self, _: u32) {} }12 # fn find_a_razor() -> Result { Ok(1) }5 use log::{info, warn};& pub fn shave_the_yak(yak: &mut Yak) {)I info!(target: "yak_events", "Commencing yak shaving for {:?}", yak);L loop { match find_a_razor() {" Ok(razor) => {3 info!("Razor located: {}", razor);6" yak.shave(razor);% break; } Err(err) => {F warn!("Unable to locate a razor: {}, retrying", err);Is }  }  } # fn main() {} ``` ## In executablesR Executables should choose a logging implementation and initialize it early in theUI runtime of the program. Logging implementations will typically include aL7 function to do this. Any log messages generated before:3 the implementation is initialized will be ignored.6> The executable itself may use the `log` crate to log as well.A ### Warning1 The logging system may only be initialized once.4 ## Structured loggingL If you enable the `kv_unstable` feature you can associate structured valuesOJ with your log records. If we take the example from before, we can includeMA some additional context besides what's in the formatted message:Dn# # #[macro_use] extern crate serde;&6 # #[derive(Debug, Serialize)] pub struct Yak(String);9o1= # fn find_a_razor() -> Result { Ok(1) }@( # #[cfg(feature = "kv_unstable_serde")]+ # fn main() {+ use log::{info, warn, as_serde, as_error};.p)Q info!(target: "yak_events", yak = as_serde!(yak); "Commencing yak shaving");T q q "r 7 info!(razor = razor; "Razor located"); :r!%s!s!s"S warn!(err = as_error!(err); "Unable to locate a razor, retrying");"Vs"t# u# u# # }#- # #[cfg(not(feature = "kv_unstable_serde"))]#0u#u##$ # Available logging implementations$'$7 In order to produce log output executables have to use$:4 a logger implementation compatible with the facade.$79 There are many available implementations to choose from,%<( here are some of the most popular ones:%+& * Simple minimal loggers:& * [env_logger]& * [simple_logger]& * [simplelog]& * [pretty_env_logger]& * [stderrlog]' * [flexi_logger]' * [call_logger]' * [structured-logger]'# * Complex configurable frameworks:'& * [log4rs]( * [fern](! * Adaptors for other facilities:($ * [syslog]( * [slog-stdlog]( * [systemd-journal-logger])" * [android_log]) * [win_dbg_logger]) * [db_logger]) * [log-to-defmt]) * For WebAssembly binaries:* * [console_log]* * For dynamic libraries:*_ * You may need to construct an FFI-safe wrapper over `log` to initialize in your libraries*b+ # Implementing a Logger++M Loggers implement the [`Log`] trait. Here's a very basic example that simply+PH logs all messages at the [`Error`][level_link], [`Warn`][level_link] or,K' [`Info`][level_link] levels to stdout:-*-n-$ use log::{Record, Level, Metadata};-'- struct SimpleLogger;-.! impl log::Log for SimpleLogger {.$5 fn enabled(&self, metadata: &Metadata) -> bool {.8( metadata.level() <= Level::Info.+u/ /% fn log(&self, record: &Record) {/(- if self.enabled(record.metadata()) {/0@ println!("{} - {}", record.level(), record.args());0Ct0 u0 0 fn flush(&self) {}0u11u1u11J Loggers are installed by calling the [`set_logger`] function. The maximum1ML log level also needs to be adjusted via the [`set_max_level`] function. The1OJ logging facade uses this as an optimization to improve performance of log2MF messages at levels that are disabled. It's important to set it, as it3IL defaults to [`Off`][filter_link], so no log messages will ever be captured!3OK In the case of our example logger, we'll want to set the maximum log level4NG to [`Info`][filter_link], since we ignore any [`Debug`][level_link] or5JJ [`Trace`][level_link] level log messages. A logging implementation should5M; provide a function that wraps a call to [`set_logger`] and6>: [`set_max_level`], handling initialization of the logger:6=7n7 # use log::{Level, Metadata};7! # struct SimpleLogger;7# # impl log::Log for SimpleLogger {7&6 # fn enabled(&self, _: &Metadata) -> bool { false }89& # fn log(&self, _: &log::Record) {}8) # fn flush(&self) {}89u9( use log::{SetLoggerError, LevelFilter};9+9, static LOGGER: SimpleLogger = SimpleLogger;9/:. pub fn init() -> Result<(), SetLoggerError> {:1 log::set_logger(&LOGGER): 9 .map(|()| log::set_max_level(LevelFilter::Info)):<u;u;;M Implementations that adjust their configurations at runtime should take care;P) to adjust the maximum log level as well.<,< # Use with `std`<<L `set_logger` requires you to provide a `&'static Log`, which can be hard to` rather than a>M `&'static Log`:??n?@ # use log::{Level, LevelFilter, Log, SetLoggerError, Metadata};?C?@&@9@)AAuA # #[cfg(feature = "std")]AA12 log::set_boxed_logger(Box::new(SimpleLogger))B5ܟB<uCuCC # Compile time filtersCC] Log levels can be statically disabled at compile time via Cargo features. Log invocations atC`V disabled levels will be skipped and will not even be present in the resulting binary.DYT This level is configured separately for release and debug builds. The features are:DWE * `max_level_off`E * `max_level_error`E * `max_level_warn`F * `max_level_info`F * `max_level_debug`F * `max_level_trace`F * `release_max_level_off`F * `release_max_level_error`G * `release_max_level_warn`G * `release_max_level_info`G * `release_max_level_debug`G * `release_max_level_trace`HH^ These features control the value of the `STATIC_MAX_LEVEL` constant. The logging macros checkHaI this value before logging a message. By default, no levels are disabled.ILI` Libraries should avoid using the max level features because they're global and can't be changedIc once they're set.JJ] For example, a crate can disable trace level logs in debug builds and trace, debug, and infoJ`? level logs in release builds with the following configuration:KBK ```tomlK  [dependencies]LT log = { version = "0.4", features = ["max_level_debug", "release_max_level_warn"] }LWuL # Crate Feature FlagsLMU The following crate feature flags are available in addition to the filters. They areMX! configured in your `Cargo.toml`.M$N` * `std` allows use of `std` crate instead of the default `core`. Enables using `std::error` andNc" `set_boxed_logger` functionality.O%^ * `serde` enables support for serialization and deserialization of `Level` and `LevelFilter`.OaPòP زP7 log = { version = "0.4", features = ["std", "serde"] }P:uPP # Version compatibilityPQY The 0.3 and 0.4 versions of the `log` crate are almost entirely compatible. Log messagesQ\` made using `log` 0.3 will forward transparently to a logger implementation using `log` 0.4. LogQc_ messages made using `log` 0.4 will forward to a logger implementation using `log` 0.3, but theRb^ module path and file name information associated with the message will unfortunately be lost.SaT [`Log`]: trait.Log.htmlT [level_link]: enum.Level.htmlT!% [filter_link]: enum.LevelFilter.htmlT(# [`set_logger`]: fn.set_logger.htmlU&) [`set_max_level`]: fn.set_max_level.htmlU,3 [`try_set_logger_raw`]: fn.try_set_logger_raw.htmlU65 [`shutdown_logger_raw`]: fn.shutdown_logger_raw.htmlV87 [env_logger]: https://docs.rs/env_logger/*/env_logger/V:B [simple_logger]: https://github.com/borntyping/rust-simple_loggerWE6 [simplelog]: https://github.com/drakulix/simplelog.rsW9L [pretty_env_logger]: https://docs.rs/pretty_env_logger/*/pretty_env_logger/XO4 [stderrlog]: https://docs.rs/stderrlog/*/stderrlog/X7= [flexi_logger]: https://docs.rs/flexi_logger/*/flexi_logger/Y@: [call_logger]: https://docs.rs/call_logger/*/call_logger/Y=+ [syslog]: https://docs.rs/syslog/*/syslog/Z.: [slog-stdlog]: https://docs.rs/slog-stdlog/*/slog_stdlog/Z=+ [log4rs]: https://docs.rs/log4rs/*/log4rs/Z.% [fern]: https://docs.rs/fern/*/fern/[([ [systemd-journal-logger]: https://docs.rs/systemd-journal-logger/*/systemd_journal_logger/[^: [android_log]: https://docs.rs/android_log/*/android_log/\=C [win_dbg_logger]: https://docs.rs/win_dbg_logger/*/win_dbg_logger/\F4 [db_logger]: https://docs.rs/db_logger/*/db_logger/]7= [log-to-defmt]: https://docs.rs/log-to-defmt/*/log_to_defmt/]@: [console_log]: https://docs.rs/console_log/*/console_log/^=Q [structured-logger]: https://docs.rs/structured-logger/latest/structured_logger/^T__a _ _` ``%https://www.rust-lang.org/favicon.ico`'` ` `https://docs.rs/log/0.4.20`_b #vz{ [[[J\\ \\a\ \  \ \ ]]]]a]]d[d[e[e\e\e e e e The standard logging macro.I This macro will generically log with the specified `Level` and `format!`L based argument list. # Examplesn use log::{log, Level};~ let data = (42, "Forty-two");! let private_data = "private";!? log!(Level::Error, "Received errors: {}, {}", data.0, data.1);BC log!(target: "app_events", Level::Warn, "App warning: {}, {}, {}",F# data.0, data.1, private_data);&u  \        lvl    key   value          arg                                                                                                                                                                                                                                                                                        # Logs a message at the error level.&n use log::error;~. let (err_info, port) = ("No connection", 22);10 error!("Error: {} on port {}", err_info, port);3G error!(target: "app_events", "App Error: {}, Port: {}", err_info, 22);Ju "\                                  " Logs a message at the warn level.%n use log::warn;~( let warn_description = "Invalid Input";+) warn!("Warning! {}!", warn_description);,M warn!(target: "input_events", "App received warning: {}", warn_description);Pu $\                                  !" Logs a message at the info level.%n use log::info;~. # struct Connection { port: u32, speed: f32 }16 let conn_info = Connection { port: 40, speed: 3.20 };9K info!("Connected to port {} at {} Mb/s", conn_info.port, conn_info.speed);NQ info!(target: "connection_events", "Successful connection, port: {}, speed: {}", T( conn_info.port, conn_info.speed); +!u!! ׊&!\!$"#  """  "" """""" ""  " ##### ## # ###  ###  ### ## ## ###### # ######## ##  # ###$# $$ $ $$$ $ $$ $$ $$$$$$ $ $'# Logs a message at the debug level.$&$$$n$ use log::debug;%%~%% # struct Position { x: f32, y: f32 }%(, let pos = Position { x: 3.234, y: -1.223 };%/&4 debug!("New position: x: {}, y: {}", pos.x, pos.y);&7J debug!(target: "app_events", "New position: x: {}, y: {}", pos.x, pos.y);&M'u'' (']'*((  (((  (( (((((( ((  ( ((()( (( ( )))  )))  ))) )) )) u)))))) ) )))))))) ))  ) )))*) )) ) ))* ) )* ** u****** * *.# Logs a message at the trace level.*&***n* use log::trace;*+~++(+/+3 trace!("Position is: x: {}, y: {}", pos.x, pos.y);+64 trace!(target: "app_events", "x is {} and y is {}",,7; if pos.x >= 0.0 { "positive" } else { "negative" },,>< if pos.y >= 0.0 { "positive" } else { "negative" });-?-u-- *-].0//  ///  // ////// //  / ///0/ // / //0  ///  /// // // /00000 0 00000000 00  0 00000 00 0 000 0 00 00 000000 0 07J Determines if a message logged at the specified level in that module will0M be logged.11L This can be used to avoid expensive computation of log message arguments if1O% the message would be ignored anyway.2(222n2 use log::Level::Debug;2 use log::{debug, log_enabled};3"3 # fn foo() {3 if log_enabled!(Debug) {3! let data = expensive_call();3$; debug!("expensive debug data: {} {}", data.x, data.y);4>u4+ if log_enabled!(target: "Global", Debug) {4. let data = expensive_call();5#L debug!(target: "Global", "expensive debug data: {} {}", data.x, data.y);5Ou56! # struct Data { x: u32, y: u32 }6$6 # fn expensive_call() -> Data { Data { x: 0, y: 0 } }69u6u67 ,7]7977  777  77 777 77 777979 7 777 77 778 88 88 888 88 8 8888 88 8 8 888 888  89999 99 99999 99 9  999  999 99 9 9 9  99999 99:9.9: :9: /:]:;:::::: :: : :::;: :: : :  :  ;;;;;;; ; ;;;;;;;; ;; ; ;;;;;;;; ; ;;f*]]]]pp vppLrr Lrr Lss Ls(sLs!s LPLttuu%. )77 7. 7/ &."āCǁ 77 7. 7/  LessGreaterӳp!Ӂ! "ԁځʂ2͂    y$%$%ӂւ #tقȃ.'(&&D47 7  y..a&& (())))()  P(****(*  L[(++++(+ L.[.-6777 7. 7MMMflagsJMfillJMJMwidthJM precisionJMbufJҠ᷷7  y[ ,, -‡ ./0123( L  ... /u( Returns the most verbose logging level.Ɗ+... 0,6 Converts the `Level` to the equivalent `LevelFilter`.97 7./.. 1$2 Returns the string representation of the `Level`.5C This returns the same string as the `fmt::Display` implementation.F7 7... 2+. Iterate through all supported logging levels.1H The order of iteration is from more severe to less severe log messages.Ku use log::Level; let mut levels = Level::iter();#/ assert_eq!(Some(Level::Error), levels.next());2/ assert_eq!(Some(Level::Trace), levels.last());2uݑ.. 33444434[%/6#77 7/ 7.55 6&/8= 77 7/ 7.7š7 8Úɚ/:;֛ۛ99D:7 7  y//a99 ;;<<<<;<ϝ;====;= /[!/?՞6؞777 7/ 7MMMJMJMJMJMJMJҠ᷷7>ܞ> ?ݞ/ABCDE͟.П L  /@@ A۟/ Returns the most verbose logging level filter.2/@@ BĤ'+ Converts `self` to the equivalent `Level`.ã.0 Returns `None` if `self` is `LevelFilter::Off`.3ˤ7 7/@Ԥ@ Cդ$8 Returns the string representation of the `LevelFilter`.;F7 7/@Ħ@ DŦ+0 Iterate through all supported filtering levels.3ȧ? The order of iteration is from less to more verbose filtering.ЧBu use log::LevelFilter;ƨ& let mut levels = LevelFilter::iter();)3 assert_eq!(Some(LevelFilter::Off), levels.next());65 assert_eq!(Some(LevelFilter::Trace), levels.last());ݩ8u@@ EEFFFFEF[HH  HIԬ׬7 7 HG۬G IHܬĿKKݜdKLMNOPQSTVWɿ% Returns a new builder.޿  ]KJJ LK) The message body.7 7 7 ArgumentspiecesJJJ˽KJJ MK'" Metadata about the log directive.%7 7 7! ֒7KJJ NK$ The verbosity level of the message.'7 7.JJ OK) The name of the target of the directive.,7 7 KJJ PK, The module path of the message.# 7 7  JJ QKQRRRRQR YP[8= The module path of the message, if it is a `'static` string.@7 7  JJ SK%( The source file containing the message.+7 7JJ TKTUUUUTU[1@ 7 7JJ VK!! The line containing the message.$7 7  JJ WKYY  ]YZ[\]^_`abcd! Construct new `RecordBuilder`." The default options are: - `args`: [`format_args!("")`]". - `metadata`: [`Metadata::builder().build()`]1 - `module_path`: `None` - `file`: `None` - `line`: `None`K [`format_args!("")`]: https://doc.rust-lang.org/std/macro.format_args.htmlNJ [`Metadata::builder().build()`]: struct.MetadataBuilder.html#method.buildMXX ZYJ. Set [`args`](struct.Record.html#method.args).17 7JJJ˽Y΂XX [YL Set [`metadata`](struct.Record.html#method.metadata). Construct a `Metadata` object with [`MetadataBuilder`](struct.MetadataBuilder.html).7 7! ֒7YXX \Y?< Set [`Metadata::level`](struct.Metadata.html#method.level).?7 7.XX ]YC= Set [`Metadata::target`](struct.Metadata.html#method.target)@7 7 YXX ^Y N; Set [`module_path`](struct.Record.html#method.module_path)> 7 7  XX _YZQ Set [`module_path`](struct.Record.html#method.module_path) to a `'static` stringT7 7XX `YG- Set [`file`](struct.Record.html#method.file)07 7XX aYSD Set [`file`](struct.Record.html#method.file) to a `'static` string.G 7 7XX bYC- Set [`line`](struct.Record.html#method.line)07 7XX cY!) Invoke the builder and return a `Record`,7 7ݜdYXX dY&ff:gɒ:ee gfii! ֒7ijklǂ'΂"ɣihh jiՃ'܃7 7.hh kiф,؄7 7 ih߄h linn"ɣnopqrŠɗ## Construct a new `MetadataBuilder`.& - `level`: `Level::Info` - `target`: `""`݋mm on?9 Setter for [`level`](struct.Metadata.html#method.level).ɍ<7 7.mm pnE; Setter for [`target`](struct.Metadata.html#method.target).>7 7 nmm qn # Returns a `Metadata` object. 7 7! ֒7nmm rn(ttCuCss ut; A trait encapsulating the operations required of a logger.В>vvvwxywxy֗/A Determines if a log message with the specified metadata would beD logged. C This is used by the `log_enabled!` macro to allow callers to avoidFG expensive computation of log message arguments if the message would beܔJ discarded anyway.ŕ # For implementors͕= This method isn't called automatically by the `log!` macros.@M It's up to an implementation of the `Log` trait to call `enabled` in its ownPD `log` method implementation to guarantee that filtering is applied.Gٗ777 7 7! ֒77vv w Logs the `Record`.ɘD Note that `enabled` is *not* necessarily called before this method.јG@ Implementations of `log` should perform all necessary filteringC internally.777 7 7ݜd7[vv x Ě Flushes any buffered records.!ǚ7 7[v͚v yΚ Cޢ␈]{ϫ٫zzCC}~'777 7C 7! ֒77|ě| }ś777 7C 7ݜd7[|| ~7 7C[|| 07vCߜC.777 7C 7! ֒77 7Cɝ̝777 7C 7ݜd7[Н 7Cѝ ם7 7C[ 7C(# Sets the global maximum log level.ң&L Generally, this should only be called by the active logging implementation.Oͤn Note that `Trace` is the maximum level, because it provides the maximum amount of detail in the emitted logs.Ѥqϥ׷ ҥ  ӥ ͥ! /[ 4. A thread-unsafe version of [`set_max_level`].1I This function is available on all platforms, even those that do not haveL9 support for atomics that is needed by [`set_max_level`].<< In almost all cases, [`set_max_level`] should be preferred.? # Safety K This function is only safe to call when no other level setting function isN+ called while this function still executes.ȩ.J This can be upheld by (for example) making sure that **there are no otherM? threads**, and (on embedded) that **interrupts are disabled**.ɪBG Is is safe to use all other logging functions while this function runsJ (including all logging macros).۫#ҽ,Ȭ/[ ۬!' Returns the current maximum log level.*ԯX The [`log!`], [`error!`], [`warn!`], [`info!`], [`debug!`], and [`trace!`] macros checkد[I this value and discard any message logged at a higher level. The maximumL4 log level is set by the [`set_max_level`] function.7 [`log!`]: macro.log.html [`error!`]: macro.error.htmlڱ  [`warn!`]: macro.warn.html [`info!`]: macro.info.html [`debug!`]: macro.debug.html  [`trace!`]: macro.trace.htmlڲ ҽ, / I, Sets the global logger to a `&'static Log`./L This function may only be called once in the lifetime of a program. Any logOM events that occur before the call to `set_logger` completes will be ignored.P۽D This function does not typically need to be called manually. Logger߽GJ implementations should provide an initialization method that installs theM logger internally. # AvailabilityK This method is available even when the `std` feature is disabled. However,NI it is currently unavailable on `thumbv6` targets, which lack support forLF some atomic operations which are used by this function. Even on thoseI0 targets, [`set_logger_racy`] will be available.3 # Errors 7 An error is returned if a logger has already been set.:nD use log::{error, info, warn, Record, Level, Metadata, LevelFilter};G' static MY_LOGGER: MyLogger = MyLogger;* struct MyLogger; impl log::Log for MyLogger { 8ϑ+u (ϒ0Ct u u # fn main(){& log::set_logger(&MY_LOGGER).unwrap();)' log::set_max_level(LevelFilter::Info);* info!("hello log"); warn!("warning"); error!("oops");u- [`set_logger_racy`]: fn.set_logger_racy.html0    !   y[D  [J Jo    ![[  make_logger U+ A thread-unsafe version of [`set_logger`]..L6 support for atomics that is needed by [`set_logger`].99 In almost all cases, [`set_logger`] should be preferred.<» G This function is only safe to call when no other logger initializationJ7 function is called while this function still executes.:MݽBC It is safe to use other logging functions while this function runsF#& $D6777 7D 7MMMJMJMJMJMJMJҠ᷷7 %D6777 7D 7MMMJMJMJMJMJMJҠ᷷7 ## Returns a reference to the logger.&B If a logger has not been set, a no-op implementation is returned.E C Y WARNING: this is not part of the crate's public API and is subject to change at any time\ j!q{    $  !b 6   $777777JJJ˽7. 7 7   7  7 7[  kvs 2 7. 7     '+ The statically resolved maximum log level..L See the crate level documentation for information on how to configure this.OM This value is checked by the log macros, but not by the `Log`ger returned byPJ the [`logger`] function. Code that manually calls functions on that valueM- should compare the level against this value.0 [`logger`]: fn.logger.html/"/-/WyC An enum representing the available verbosity levels of the logger.vFwF Typical usage includes: checking if a certain `Level` is enabled withwID [`log_enabled!`](macro.log_enabled.html), specifying the `Level` ofwG@ [`log!`](macro.log.html), and comparing a `Level` directly to axC( [`LevelFilter`](enum.LevelFilter.html).x+y.| The "error" level.zz Designates very serious errors.z#..TL} The "warn" level.|}! Designates hazardous situations.}$..~ The "info" level.}} Designates useful information.}"..~ The "debug" level.~~' Designates lower priority information.~*.. The "trace" level.~D Designates very low priority, often extremely verbose, information.G..y.7 7..y yy.y ..77 7. 7.y y y..  7 7.[y yy .77 7. 7.y y y.77 7. 7.y yyςςς.ςς777 7. 7MMMJMJMJMJMJMJҠ᷷7y yςy.77 7. 7[yՆOՆ Նy J An enum representing the available verbosity level filters of the logger.ՒMG A `LevelFilter` may be compared directly to a [`Level`]. Use this typeJQ to get and set the maximum log level with [`max_level()`] and [`set_max_level`].Tǔ [`Level`]: enum.Level.html˔# [`max_level()`]: fn.max_level.html&ҽ, /۽xז# A level lower than all log levels.&֊/֊֊/& Corresponds to the `Error` log level.)ϋ/ϋϋ/Ɨ% Corresponds to the `Warn` log level.(ˌ/ˌˌ/% Corresponds to the `Info` log level.З(ƍ/ƍƍ/& Corresponds to the `Debug` log level.)//& Corresponds to the `Trace` log level.)//֕/7 7//֕ ֕ݕđđđ/ //77 7/ 7/  ǓǓǓ/ǓǓǓǓ/ǓǓǓǓǓ ǓǓǓǓǓǓ ǓǓǓ7 7/[  ݕݕݕ/ݕݕ77 7/ 7/  ݕ/77 7/ 7/ /777 7/ 7MMMJMJMJMJMJMJҠ᷷7 ÚÚÚ/ÚÚ77 7/ 7Ն[ÚÚ Ն ÚÚÚ֫۫  ˝ ˝WW WW˝  מYY YYԞ˝ ݟԞ2 ààà2àà7 722  ! 3 4  7 74[! " !4!577 75 75"  #"677 76 76# $ #677 76 76$  %ȫɩɩɩ$7ɩɩ77 77 7[%ȫѫɩOѫɩ ѫȫ ɩɩɩ&Ϋ׫׫׫%8׫׫777 78 7MMMJMJMJMJMJMJҠ᷷7&Ϋ Ϋ׫ The "payload" of a log message.# # Use H `Record` structures are passed as parameters to the [`log`][method.log]KB method of the [`Log`] trait. Logger implementors manipulate theseEI structures in order to display log messages. `Record`s are automaticallyL@ created by the [`log!`] macro and so are not seen by log users.C˰G Note that the [`level()`] and [`target()`] accessors are equivalent toϰJG `self.metadata().level()` and `self.metadata().target()` respectively.JI These methods are provided as a convenience for users of this structure.L # Example IJE The following example shows a simple logger that displays the level,ȲH? module path, and message of any `Record` that is passed to it.BԳnسߐ$: fn enabled(&self, _metadata: &log::Metadata) -> bool {= true }) fn log(&self, record: &log::Record) {,- if !self.enabled(record.metadata()) {0 return; }  println!("{}:{} -- {}"," record.level(),#! record.target(),ն$ record.args());#ȶ fn flush(&self) {}uuǷϷ* [method.log]: trait.Log.html#tymethod.logӷ-- [`level()`]: struct.Record.html#method.level0/ [`target()`]: struct.Record.html#method.target2Rݜdݜdȹҹҹ! ֒7JJJ˽'      ߺߺ'&87 788' ('9777 79 7MMMJMJMJMJMJMJҠ᷷7( , Builder for [`Record`](struct.Record.html)./Y Typically should only be used by log library creators or for testing and "shim loggers".\U The `RecordBuilder` can set the different parameters of `Record` object, and returnsX+ the created object when `build` is called..n use log::{Level, Record}; let record = Record::builder()". .args(format_args!("Error!"))1% .level(Level::Error)(! .target("myApp")$) .file(Some("server.rs")),! .line(Some(144))$- .module_path(Some("server"))0 .build();uE Alternatively, use [`MetadataBuilder`](struct.MetadataBuilder.html):Hn+ use log::{Record, Level, MetadataBuilder};., let error_metadata = MetadataBuilder::new()/) .target("myApp"),- .level(Level::Error)0" .build();%"* .metadata(error_metadata)-1! .line(Some(433))$& .file(Some("app.rs")))0u   ]]ݜd)(:777 7: 7MMMJMJMJMJMJMJҠ᷷7)  Metadata about a log message.!Ԯ = `Metadata` structs are created when users of the library use@ logging macros.? They are consumed by implementations of the `Log` trait in theB `enabled` method.A `Record`s use `Metadata` to determine the log message's severityD and target.A Users should use the `log_enabled!` macro in their code to avoidD% constructing expensive log messages.(n' 8ϑ+u (ϒ0Ct u u؀ހ # fn main(){}uŁ! ֒7֒7΁؁ ؁. +);7 7;;+ ,*;*<  7 7<[, - +<+=77 7= 7=-  .,=77 7= 7=. / ->77 7> 7>/  0 .>77 7> 7ѫ[0 ѫ 1 /?777 7? 7MMMJMJMJMJMJMJҠ᷷71 0 Builder for [`Metadata`](struct.Metadata.html).3ąȅ\[ The `MetadataBuilder` can set the different parameters of a `Metadata` object, and returns^.۳ Ňnɇ let target = "myApp";܇# use log::{Level, MetadataBuilder};&& let metadata = MetadataBuilder::new())) .level(Level::Debug)Lj,$ .target(target)' .build();!u "ɣɣ! ֒72ω!0?!0@! ! 7 7@[2ω ω3Ӊ !1@!1@77 7@ 7@3Ӊ Ӊ 4މ!2A77 7A 7A4މ މ5 "3A77 7A 7A5  6"4B77 7B 7ѫ[6 ѫ 7"5B777 7B 7MMMJMJMJMJMJMJҠ᷷77 YO The type returned by [`set_logger`] if [`set_logger`] has already been called.R& D[DY[D [;#7D777 7D 7MMMJMJMJMJMJMJҠ᷷7; ZW The type returned by [`from_str`] when the string doesn't match any of the log levels.ZU [`from_str`]: https://doc.rust-lang.org/std/str/trait.FromStr.html#tymethod.from_strX DU[DZ˃[D [<ԄԄ#Ԅ8DԄԄ777 7D 7MMMJMJMJMJMJMJҠ᷷7< Ԅ= #9D#9D77 7D 7D=  >$:D$:D$ $ 7 7D[> LJч C33ƾƾMapɾʾ1ٗµµĵ ŵ䐥փ6L>>. ƙК DEEƾƾ΋ɾʾ1ٗǍ>>/Ū ܋ՎѕϖĚܭΛϛĜߝ  „„ς֛֛ǡ֧֧׫́́ȆȆԄXJ@mG.hdebug!fn.set_logger_racy.htmlpretty_env_logger slog-stdlogfern db_loggerMetadata::target./macro.warn.htmlMetadata::builder().build()0https://github.com/borntyping/rust-simple_logger7https://doc.rust-lang.org/stable/std/macro.println.html;https://docs.rs/structured-logger/latest/structured_logger/*https://docs.rs/android_log/*/android_log/macro.trace.htmlinfo!*https://docs.rs/slog-stdlog/*/slog_stdlog/*https://docs.rs/console_log/*/console_log/./macro.error.htmlsyslogmacro.log.htmlwin_dbg_logger"enum.LevelFilter.htmlformat_args!("")./macro.trace.html*https://docs.rs/call_logger/*/call_logger/&https://docs.rs/stderrlog/*/stderrlog/ https://docs.rs/syslog/*/syslog/enum.Level.html,https://docs.rs/log-to-defmt/*/log_to_defmt/fn.logger.htmlstruct.Record.htmlstruct.Metadata.htmlؗmacro.debug.html./macro.debug.html,https://docs.rs/flexi_logger/*/flexi_logger/ android_logmacro.log_enabled.html! console_log6https://docs.rs/pretty_env_logger/*/pretty_env_logger/https://docs.rs/fern/*/fern/&https://docs.rs/db_logger/*/db_logger/log!fn.set_max_level.html max_level()error! simplelog env_loggerstruct.MetadataBuilder.html call_loggersystemd-journal-loggertrait.Log.htmllevel()macro.warn.html https://docs.rs/log4rs/*/log4rs/ log-to-defmtfn.max_level.html4https://doc.rust-lang.org/std/macro.format_args.html simple_loggeruM(https://docs.rs/env_logger/*/env_logger/ @https://docs.rs/systemd-journal-logger/*/systemd_journal_logger/ log_enabled!println! flexi_loggermacro.info.htmlȗtrace!macro.error.html stderrlog4https://doc.rust-lang.org/std/str/trait.FromStr.html./macro.info.htmlMetadata::levellog4rs"̤͜ѝwarn!structured-loggertarget()v!fn.set_logger.html ؠ֡כ$(https://github.com/drakulix/simplelog.rsu 0https://docs.rs/win_dbg_logger/*/win_dbg_logger/ ٥ҟȗȚѧǛУ"  ̤͜ȥѝ٥ƞؗ!ЩȚؠכƞuʫ ҟЩ֡ ѧ ǛУʫȥav=>==>*s0Ll%ߚ*s0Ll9uf}*s0Ll{%;q*s0Ll9PG*s0LlkDn*s0Ll?Q6& *s0Llq*s0Ll`s|$*s0Ll SB*s0LlƀE*s0LlE0<ɵ{*s0Ll&8PO*s0Ll4a ͣ*s0LlPz|*s0Llq.j*s0Lli$*s0Ll-{5 *s0Ll7n*s0Ll1Ur*s0Ll?_yc*s0Ll NF0H*s0LlFA *s0Llؚ@*s0Ll+d`*s0Ll4bq *s0Ll*'rf*s0Ll X*s0Ll9dѴ|*s0Ll6ߪl*s0Ll`~qn*s0Ll*s0Lli#*s0Ll؊;{*s0LlX*s0LlAdʗ*s0LlZF"*s0Ll1`Ԋ*s0Ll?H*s0LlV7*s0LlC3pT*s0LlND٩ ]*s0LlGTZ*s0Ll;;*s0Ll0Դjx*s0Ll%WT*s0LlΞ.ҧ&*s0Ll?nWQ*s0LlKgp*s0LlYa}qp*s0Ll]ag*s0Ll`01u*s0Llq:@<*s0Ll~_*s0Ll< _NB*s0Ll9@<*s0Lloc*s0LlKZ9z>*s0LlDJf*s0Ll _*s0Llϊjׇ*s0Ll YpY:*s0Ll@k/u *s0Ll"L[*s0Ll8}ɀb*s0Ll.s,*s0Llc*s0Ll{j**s0LlNp*s0LlŃoZUi*s0Ll\$*s0Lljׇ*s0Ll%m2tיA*s0LlG]n*s0Llu*s0LlJ 8*s0Ll=*s0Ll֣M>*s0Ll=k*s0Ll.zAa*s0Llyl}*s0Ll4#;۸*s0LlR 1*s0Ll/| *s0Ll7C*s0Lli/d*s0Ll5x"*s0LlP4*s0Lld)*s0Ll(̋[*s0Ll+߁Wi+*s0LlK~*s0Llx~0*s0Ll g*s0Lln8-Z*s0Ll8%*s0Ll ?%3*s0Llkw*s0LlKcdL}*s0LlJĘ*s0LltwK*s0LlܚK5*s0LlĪgٗj*s0Ll0*s0Ll&>3*s0Ll]*s0Lln<ani*s0Ll~DD-R<*s0Llx\*s0Lldnd$*s0Ll5o*s0Lly1*s0LlBq\5>w*s0LlB9ʏ-*s0Ll|D*s0Llq'# ze*s0LlU{psN*s0Llj3}?*s0LlNlsH*s0Ll\zs*s0Ll-gК*s0Ll??@@=B\BBtCCCFDsDD$eg+\  *su <C  H&.Cp%U$Q7.6>FNVj& S  %   \ t ;+mu{A i!().5//!0)1k1/2234X89B9J::P;<<={? @ABCCoDD########          """"" """""" !!   egIjzw׊`ߛ*]xמGqIdĢSΧɨ(߬[f*ֳi׻<Fc+s,!Qdv^IYy`[;|*Ro3[O9/'k  &  t  2,ca'5(I m  ![(()0...U/01O23347v89:p;6<<=W???"@ABABBCE/:g@gGgOgYgcgmgwgggx~(JՓ{Aj+U+FvԢ pΤ[xl ]v qǭ$=+HϯC%HĴ4T?X/!xƽ#/ifm55 4%IU~rs9'3s1^@+F+vX@l vw>GOW_ju)<dEm%U$S9Od>PV#KA9l& U   '     + ^ C v  Ww;C+3ow7u}=}CK 9 ]    +!k!s!b"((V)))*....7/?////#0+00)111m1u111292222}333g4y4445Z8f8899D9L9 :J:R:::;R;Z;;< <<<<====>??? @@B5BTBBlCCC>DoDDTE[EfEmExEEEEEEEqFxFFFFFFFFFFZGaGhGoGvG}GGGGGGGGGGGGGGGGGGGH HHH&H-H8HCHJHQH\HgHnHyHHHHHHHHHHHHHHHIII"I,I6I@IJIQIXI_IfImItI{IIIIIIIIIIIIIIIIIIIJJJJJ#J*J1J8J?JFJMJTJ[JbJiJpJwJ~JJJJJJJJJJJJJJJJJJJK KKKK&K-K4K;KBKIKPKWK^KeKlKsKzK=gDgKgVg`gjgtg~ggFjztԊ]ܛ Hqž2\3Nzܢؤe=ժg~ɬ.E5PϰR̴>|wS&н+0 Ms/Q] |}l /;jt5N5~`H3kCcJSDKS[fq|&x&@k/IGtC)=qB '\p E Y        N b f z *_| ?f/RsZy`&GO # A e    N!o!w!S(((y)))(..../;/C///0'001-1P1q1y1252=2223333k44447b8n889'9H99/:N:q:::5;V;^;;<$<<<<====O????@AB=BwBBCCCaDDDXEcEjEuE|EEEEEEEuFFFFFFFFFFF^GeGlGsGzGGGGGGGGGGGGGGGGGGGGH HH#H*H5H@HGHNHYHdHkHvHHHHHHHHHHHHHHHIIII)I3I=IGINIUI\IcIjIqIxIIIIIIIIIIIIIIIIIIIIJ JJJ J'J.J5JodKqԫj^ 8?;ӱ6gSD%>ridռYAH^ DnXM"c=%?Z.ZdpU%5]z>f!Q~ M35{JMD: 2f" O   !   i   X ( p  IDo7}'iqw=}4U y  !e!>"q(()i*F...1///00%1g11+222Y33/4v445 888>99F:::L;;<z<<P===>_???@@A+BMBBQCCC#DkDD@EEF,_zٞ Is~Ţ`!ۤ-h[jëYMݭ182± U A;-EX7ļӽP0x7M2|eG<Z,88|S]ixiG}+Sp4\JwF,$t9F:0(_ H      W   Q  i  5:e#iU]c)\ *K o   Q!,"]((|)W*2.../r// 001S11222G334o44z57x88*992:t::8;;;h<</===>X????@A!BCBzB?CCCDdDD.EEF5h )R|(-SҢuRBqhOsثnb:A?ױ:iUH)Bvm hټ]ELbFr\Q$gA#)An3\frW':bCk#S"O5:}O%!I?7h$ Q   #   n   Z - r  K It9)ksy?;9Z ~  !g!C"())n*H...3///00'1i11-222^33D445888@99H:::N;;<<<e==>a???@@A0BRBBVCCC(DmDDEEEFJfT)\h+j=G d,t-"Rew_J[za<}+Sp4\P:0(l  '  u  4.b(6  !\()1.V/01P233479:q;7<<=X??#@ABBCEEFJhTϧʨ)\h+׳k ٻ>H!e-u.#SeyaJ\za<Pl  '  u  /c*7 !)W/01Q23349:r;8<<=}??#@ABBCEOɞ9c;VxEݪѬyϭMXװȳԴ[7ɻ).8U{e tCr| V hP;s~KkR-DMA+!t]    f ~ S' {!)G/0}1A23349:b;(<<=?@BBCEt\lv}!J!o!!")07GNU_fm /6=GNU,(03;{DG0 h !!!!" "Ox4=;$R%%Z&&''w((j)Y**++*+,,#-$%Y&&''v((i)**+++X*,,"-q-Q&& '(++P*V&&'( ++U*1_yFlrfC*T5N%yiQX  n~h]$sI+!C+akw\)?T.  s  2  -,!!Q"|*/012l3V45:;;<w=>@[C-DJE   00&  00&  wxywxy&&     &'     &'     '& &&     '&    '&&&  eg֤ce,3P<ν-z 33Qv$i-ErA'o }Z C     L d (zdPX^$ L!Q(w)&.//0 1N1223478%9-:o:3;;<=M??AuBCC_DD (.P8q?A(.B8c?A#37;?LXl    & * 1 @ D H L P W [ b l      $ 2 9 H T [ b f      # * 1 5 < C J Q X \ c i s  " 3 8 O X n r z ~  + E Q Y ^ c o t  (-5:BGOT[`hmqy} "*.6:BJNVZbjnvz#+37?G[cqu}  (,4<DHPXnv~+08<DZ_gksw{ %+17=CIOU[agmsy  '.5<CJQX_fmt{#*18?FMT[bipw~ &-4;BIPW^elsz&.6>FN(.S8s?AJjzx؊aK Y9==577244/11,..)++'(($%%!""=:>>7;;355022-//*,,())%&&"## 8<<466133.00+--&''#$$ !!<*s0LlÝ u core_intrinsicsfmt_helpers_for_deriveMM*s0Ll߫B CUʛ *s0Ll'X ʛ *s0Ll$aFMaRuʛܛMM*s0Lljn-cʛderive_clone_copy*s0Llg(ՕZ Uʛ derive_eq *s0Ll8ї2W Uʛ*s0LleA` *s0LljKbu ݆ʛܛMM*s0Ll,wby Оʛ*s0LlujОʛ*s0LlI͆nʛ͝*s0Llߑ4ʛ *s0Ll@ -ťUʛ*s0Ll#^Y3uքʛܛMM*s0Ll}nʛ͝*s0Ll[a=ήZ**s0Llgeڤ&yCܢ**s0Llw,vwcK ʛ *s0Ll3LV ʛ*s0LlDLE|aʛ*s0Ll=}uʛܛMM*s0Ll )Aʛ *s0LlҖYОʛ*s0LlG$+Է=}ʛOO*s0Ll%37syنʛ͝*s0Ll bƉ6ܢ**s0LlrFIBnu͕Cܢ**s0Ll섖i0r ̊ʛ *s0Ll RlB ʛOO*s0Llw# ʛOO*s0Ll^H9:uʛܛMM*s0LlR#4hO4~FОʛ*s0LlsX5uʛܛMM*s0LlCtrnʛ͝*s0Ll}\ʛ *s0Llhnr(ηCܢ**s0Ll'xbu ʛܛMM*s0Ll uʛܛMM*s0Ll_< Q,mnʛ͝*s0Ll+nGħIʛ*s0Ll>KfʛOO*s0Ll6usݕʛ͝*s0Llljaʛ *s0Ll)yWcܢ**s0Llc%vܢ**s0Ll._*s0Ll?2fm ʛ *s0Ll7ʛ *s0Ll&Eȅ{ʛOO*s0Ll1T_2Bsʛ͝*s0LluNdɡʛ *s0Ll( maʛ*s0Ll4CCܢ**s0Llr dܢ**s0LlWkr L  X ;  O 2  F )  =   4   +   "             x   o   f   ]   T a D i {[1LW&Dj[1o|)~:GUI# ` | zPpv!<GKk 4}ZK!_lzn*7E9w ODHT *s0Ll,(ZV*s0Ll50MF*s0Llbg llM*s0LlE( *s0Ll桵*s0Ll@#*s0Ll\$*s0Llؚ@*s0Ll´T8D*s0Ll|K#*s0Ll2*s0Ll*s0Lll27*s0Ll&8PO *s0Ll_t*s0Llx3KK;*s0LlIvlbI*s0Llgt?*s0Ll1i-# c,*s0Llq'# zek*s0LlTI֘&%*s0Ll*4*s0Llv,a|*s0Ll' .vd*s0LlM/,?4R*s0LlC3pT*s0LlM3٪?*s0Ll`*s0Ll]*s0LlX-"*s0LlФP*s0Ll'8}N*s0LlUNx%*s0Ll|9*s0Ll&-uaL'*s0Ll`s|$*s0Ll&ϞTiI*s0Ll֣M>*s0LlU,z*s0LlP4*s0Ll~z)*s0LlDļА}*s0Ll}(Г*s0Ll=H'*s0Ll4Y@@{=*s0Ll뵦ft*s0Ll˩yI,*s0LlLl|$*s0LlPz| *s0LlDAI*s0Ll ǘ@h*s0Ll*s0Ll"3k|d0*s0LlKcdwh*s0Ll?FyU_kH*s0Llp|j_1(*s0Ll<cM?*s0Ll9dѴ|*s0LlFn|ce*s0Ll9uf}*s0LlHogqa(i*s0Ll9 gy~):*s0Ll5SKfA^*s0LlRfnf6 *s0Llo.ka`*s0LlW1lP%*s0Llhm)*s0Ll]f *s0Ll YpY:*s0Ll~rVs9L*s0Ll}чvm' *s0Llv_χ{*s0Ll{69|yx*s0Ll8}ɀb*s0LlF|*s0Ll+l*s0LlH9*s0Ll׌IS*s0Llu*s0Ll$iB*s0Ll+߁Wi+*s0Ll#r*s0Ll X*s0Llt":P*s0Ll^܍q[*s0Ll+]XX*s0Ll܇,+Zy*s0Ll#(讓B*s0Ll%ߚ*s0Ll䙏4Κ*s0Ll ܔL*s0LlND٩ ]*s0Llyl}*s0Llߗm(*s0Ll"*s0Ll\ = #U*s0Ll R{*s0Ll{%;q*s0Ll *s0LlUn0ܚ*s0LlGu*s0LlmJ'*s0Ll[e_ɒ2*s0LlŃoZUi*s0Ll05*s0Ll'_*s0LlGTZ*s0Ll9@<*s0Llq*s0LlŚȭQfP*s0Ll mM*s0Ll*aUQ\R*s0Ll\!YF*s0Ll_̵U*s0Lle17f*s0Llq֡t*s0Ll+y& *s0LlD<*s0Ll,k͏*s0LlmA*s0Ll_I˦*s0Ll>L}0*s0Llz`(*s0Ll+da*s0Llr~Z*s0Llѣwzy*s0Ll7n*s0Llld c*s0LlB &*s0Ll4bq 冹*s0Lli$*s0Ll/ 7J*s0Llnd^~ö*s0LltT|4*s0LlΞ.ҧ&*s0LlSk**s0LlCk8*s0Ll+v!v^*s0Ll}o#6*s0Ll=$bB*s0Ll,$N*s0Lli!'31*s0Ll)o)J*s0Ll,-f*s0Llq.j*s0Llm/.*s0Ll~DD-R*s0Ll>؊;{*s0LlQc36*s0Ll4-<K*s0Ll1`Ԋ*s0Llq**s0Ll4lrNϬ*s0Ll4[8Xs*s0Ll}vy*s0Ll:Zu*s0Ll׃xz*s0Ll楌㎬PU*s0Ll6b:*s0LlYЩ1*s0Ll.zAa*s0LlٞB7*s0LlǪuR5w*s0Ll/XFH*s0Ll9--*s0Ll!N *s0Llb:*s0Ll5of*s0LlJ 8*s0Ll$S*s0LlCk*s0Ll g*s0Ll9PG*s0LlV7*s0Ll/| *s0Llr @ *s0Ll`r <*s0LlW jG*s0Ll;- 9`*s0Ll }*s0Ll{N ox*s0Ll^"V~p*s0Ll *s0Lld)*s0LlQA*s0Ll]ag*s0Lli#*s0LlNB*s0LlG *s0Ll46ߟ*s0Ll8ш*s0Ll-_*s0LlA~*s0Ll@ GqC*s0Ll gr*s0Ll){Y*s0LlY+]*s0Ll@k/u *s0Lli/d*s0Ll:#(2'*s0Ll9J3'!6*s0Ll~3 koY[HSeWrb1Afx9,(l-NeMJ.f R[MkZ4lEz 3D.#*Ffxe vZX6BQ] 5/uYI@otm"^DmY^^zu3^ma1]4`<CX6LYMg2c#dD=-nMli.>*3[jer hd]Gg 5 .%bgqvii(pT0sWq7`^y H~ s r]8x UIhD 8lx2 VVc5v `4v@o5JET>mFqK}K wGn0}b7[X[q9E*Mg hx3L7s.>M'mDmW(=_7V31$rtv;Tm[3F|l]%%= x%cm"\p#&R[/home/dwhitfield/.cargo/registry/src/index.crates.io-6f17d22bba15001f/log-0.4.20/src/lib.rs \ [8A?#EB@A$"JNN;PL?QQPD S4@J=J#!!##JHO/26*M#7&J VM;7B5PNE':2A,/*U#;&W 1(;8=,'%# cQL+(%9, )1D NPNJPOKN?>"':*,02!=Q-PEQND':*26=aZX  bMdaC XY%d&b ;]dcb")'-79;F:P8A>/>/)_>G8A>UT@1A;Q39:K+(6P (77 25NKU'-D+ . - - . . (*)D7 AD?! $=5)+**++ 7"38.*@K+(8G .;= 25D,. $ LFMDKKMIC%> -1 #$%$ .13-&$.+0 * (;)=,0*.,#1&(3*E?!8 0,#E88 )(D$2X$0%02!/!!5 0]Y/#2)%-%1I/0-1&#.2%*1'!'6 SR((7#0N 6Q! S) DF, EJ. CUF YaD 5N? LZ= 5J! A$V1 1()" ACEE)(!9, )1D >.,#1&4]_/'*-("7!+!!*!$ AF# CL' %*+?IKOEUL4LH$&1.!5#%#5(%""5(%"'Pr "+C2M=@ O/NCK$- 7O`CC+\M8!!!-$-EIGPNL,JG%  ;'8N+0PQHNOMJ4 ;H+!9, )1D *+1"L "E%2(8 AM%5$ &/M:= K;NCG$'X)8 [a &S'''=(/([Y' (=)/)'F&5+ \/PQN1;<0N % P ' O & O & P ' P ' * % , ' + & + & , '  6& %+/--//+/--//0 +.  /)'')))''))0 +.  %##%% )3  57 !9= 432 535 G7G HH $'+))++ )3  #$B&  !$3!95 -0!95 5F./ &><52 +'C., &3<52 ($,&!37<52 $*! 3"$)& 9F9?+ $->A!'#) 4U  /% ) );'$'#$' g-;^Hs.7omߢQc^ /+OE TRRTT 'A  5 Q1E%cL4Z(D3%[( = V&E / Q1N$M4) Q!E \`^^`` -A &;&Q8E%^L4Z(D.%[( C&V&K  5&Q8N$Z4)! X \5 B +# : +! <! I %# A %!  42244 '*  '42244 '-  :88:: )/  '54455 )/  ??H $=A??AA '*  .=A??AA '-  &CGEEGG )/  .@BAABB )/  &?FUhЖ;),e/home/dwhitfield/.cargo/registry/src/index.crates.io-6f17d22bba15001f/log-0.4.20/src/__private_api.rs R`G<*0I 9]&@% G"d 3% G53%5Vu4!on79]^      !"#$%&'()* + , - . / 0 1 2 3 4 5 6 7 8 9^/home/dwhitfield/.cargo/registry/src/index.crates.io-6f17d22bba15001f/log-0.4.20/src/macros.rs Kz>