rust #rustc 1.76.0 (07dca489a 2024-02-04) JSY׃(h.N9-66d8041607d2929b20@vϑ+I-693a8f23970c5917c\i %LRlU-13fc9d1ed9c7a2bcrustc_std_workspace_core vJ][.(b{-5af394d9b1f07bdc"E~+-e9d126c51bb8b2bbu$5mS-39c59240bfdfab27 "mL7e?^]-65c422a3ad95273dcfg_if :Xc^,I-7e6330a6c0cb9441 miniz_oxideCMFrf1=f<-306712ebb1ee1a3fadler}s9ycK )2 -349c574f342b0d30 hashbrownKs~曁X5-ce1d65fb391ae98brustc_std_workspace_allocQMzR#|.廍܅ -8933a2fb54d88492 std_detect >1~-b93dac2525ec4d1erustc_demanglex>)F0-a6e97aae2681ad8f addr2line)˂K-1ff34b0cf871cb60gimliӸWFf_Vmgq-0c110dd0650d6cb7object:[fu#r-dcd9be90ae2cb505memchrTivpJ5-516789932d161b4eIph:=jvl-a57e2388c0aea9b1 rstest_reuseL LL L tests  &    H decoder_tests x |  v      encoder_tests     YY Y  Y naive        55 5  5 ( '  '   ' * *  *   * RRR R  chunked_encoderSink  write_encoded_bytesChunkedEncoder'eEengineSBUF_SIZE CHUNK_SIZE  StringSink'astring"""display&&&&&&&&& Base64Display////bytes/&5555&::::& FormatterSink??'b?&CCCCreadHdecoderIIIIIIIIIIBASE64_CHUNK_SIZEIDECODED_CHUNK_SIZEI DecoderReaderUUURUUinnerU b64_buffer[ U b64_offsetUb64_lenUdecoded_buffer_ Udecoded_offsetU decoded_lenUtotal_b64_decodedUpadding_offsetIeeeeIjjjjn n jflush_decoded_bufjread_from_delegatej decode_to_bufs s s j into_innerIxxxx| Hwriteencoder MAX_INPUT_LENMIN_ENCODE_CHUNK_SIZE EncoderWriterWdelegate extra_input extra_input_occupied_lenoutput output_occupied_lenpanicked  finishwrite_final_leftoverswrite_to_delegate write_all_encoded_output   flushencoder_string_writerEncoderStringWriter from_consumer StrConsumerconsumeUtf8SingleCodeUnitWriter str_consumer   general_purposeINPUT_CHUNK_LENDECODED_CHUNK_LENDECODED_CHUNK_SUFFIXCHUNKS_PER_FAST_LOOP_BLOCKINPUT_BLOCK_LENDECODED_BLOCK_LENGeneralPurposeEstimate num_chunksdecoded_len_estimate" decode_helper  decode_chunk decode_chunk_precise   write_u64 decode_suffix#   INVALID_VALUEConfigDecodeEstimateinternal_encodeBLOCKS_PER_FAST_LOOP LOW_SIX_BITSLOW_SIX_BITS_U8internal_decoded_len_estimateinternal_decodeconfig encode_table   decode_table  read_u64with_encode_paddingwith_decode_allow_trailing_bitswith_decode_padding_mode<encode_paddingSTANDARDSTANDARD_NO_PADURL_SAFEURL_SAFE_NO_PADPADNO_PAD  Engine$$$%%& encode_string encode_slice decode_vec decode_slice  decode_slice_unchecked $'$"alphabet ALPHABET_SIZEfrom_str_unchecked  '(CRYPTBCRYPT IMAP_MUTF7BIN_HEX encode_engineencode_engine_stringencode_engine_sliceencode_with_padding encoded_len add_padding source decode_enginedecode_engine_vecdecode_engine_slice"     PAD_BYTEGeneralPurpose& & &GeneralPurposeConfig'decode_allow_trailing_bitsdecode_padding_mode DecodePaddingMode Indifferent RequireCanonical  RequireNone DecodeMetadata    Alphabetsymbols   ParseAlphabetError InvalidLength DuplicatedByte  UnprintableByte   ReservedByte      EncodeSliceErrorOutputSliceTooSmall  DecodeError InvalidByte   7 InvalidLastSymbol   InvalidPadding   DecodeSliceError9  9    77777!7%7%7>7>7>7G7G7i7i7i7q7q7r7s7s7|7|777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777  α#M//3&4&֋ڒ ;< ??B&˾ڹDEMUU YIZI[I]I^I_IaIbIcIdIݦ׏*fUU YIZI[I]I^I_IaIbIcIdIݦ׏*yJJMȷ.Jȷ.JLȷ.JL烲J 7::: +հ©+؀"""M2&&&ēPP3'34QMQQQ455௨ԓmRMRRRRRR5SSSSMS66€MSSSSSSS 7M77 8 8 ֙ğґTTTTTMTT9MUUUUUUMUU:  7:  :ղɈģMVVVVVVMVV9 9㏬׬:MXXXXXXMXXXV"C? :xU:/eU   M1!1M K11\\]\1024 ]]]]]]]]]]]]^^]^]^+_]]]]]^_]]]]_`]``]```]BUF_SIZE `]( Ra] a1024 a]# Sa] a4 b]$ Tb] b3  cR]c\c]cccR]BUF_SIZE cT]c`c]cccT]DECODED_CHUNK_SIZE dR]dod]dddR]BUF_SIZE eT]epe]eeeT]DECODED_CHUNK_SIZEY fT]f}f]fffT]DECODED_CHUNK_SIZE| g]Y( g]t g1024 g ]g]g ]gh]g]  ]hh]h]h. i] ]gg`hih]h]_ j]' j] j3 k]kk]kkk]MIN_ENCODE_CHUNK_SIZE l]ll]lll]BUF_SIZE! l]ll]lll]MIN_ENCODE_CHUNK_SIZE" m]mm]mmm]BUF_SIZEn]!n]n8o]#o]o6o]&p]p2p],p]p4,]]qq]q]q]Lr]`qrq]q]q]q]_.s]]ss]s]s]E]tt]t]kt]]s`s`tts]s]s]s]t]t]_v]vv]vv256Dv]vv]vv256Vw]ww]ww256Wx]xx]xx8 x]xx]xx256y)yzy255z@]zz]zz64z]zz]zz256  {{ {  {   || |  |  |   }} P SQz]@{~{z]|~|Q|,}&}} ~] &] 4 ?  0x3F4?z4!ŀz4ŀ0x3FHH Hz]@HH HЁ]HoH HH@]HII  ܂ ~܂  ܂  ܂~ I Ń H ۃ ۃ H- II  I I]̄]]H^I  ҂HoՅՅII IIFHH~G~G~]Ɓ]z܂]]܂܂]Ń]ۃۃ`ՅՅՅ,&ƁGɈ@]ɈɈ]ɈɈ64H@]]64LLL z]M M]MߊM MM@] MOӋN  N O   ~     ~   ]O N.  N< zOO Ǎ O O]؍]؍]MOߊ ߊ ɋMююOO OOKLMK ~K]ߊޏ]]Ӌ]z]]]`؍,&ޏzL]]256Lے]ےے]ےے256Y# X YYZZXQXR_۔_H R__^Q_Q__۔ѕpaddingܕeeR ReedQdQddmޗmJ mmlQmQlRlRޗӘmodeߘq~p- p qQqpSPp~~Sq~SQ_S~Sr~r0 ߜrrQߜrr]Pr~~Sr~SQ_S~St~s- ֟stQ֟tsSPs~~St~SQ_S~Su~u0 ͢uuQ͢uu]Pu~~Su~ܣSQ_ܣܣS~Sܣw w wBQw_x;x x y yyyy xy y y8yħx֧QxQQR֧_@] Ө]Ө64 ]]] ALPHABET_SIZE]]] ALPHABET_SIZE z]@  « d  ]q ͬ ì  ]ì           $    ]]]Uկ   qð  S   ~  z]ì]ͬz]]]]`~ð,6 source_bytes] ]]] ALPHABET_SIZE ݬ f   [zڵ ]ڵ!  & ST  ǷǷǷ     ]  ٸ ϸ  ]ϸ   ȹȹȹ  z ~z ѻoz ǻٷ ٷ ) . STٷ &     + STٷ!!ÿ]"# $$!#$ ]#${%& ''!(( &'(&('*!]*!]!*]&%#ٷ ٷ ('%&% + ,,!-.,-.-, +,,{/011 22+012021(4554 55- ST440/+#"!ٷ21/0/6!]6!]!6] +# $8"8#" : ]: ] :]  ! ¸ ¸  < <   ">??  ?>?& ST>>   ٷ    @  yST еڵ]FT¸]ϸ]ٸz]]ȹȹzz^Tzz[Tz]]]]c`z]]zzeTz``S, byte probe_index! probe_byte+׶]]z]*B@ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/@@*g *+*S*_,B@ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_@@,g ,-,S,_/B@./0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz@@.g ./.S._0B@./ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789@@0g 00/S0_2B@ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+,@@2g 232S2_4C@!"#$%&'()*+,-0123456789@ABCDEFGHIJKLMNPQRSTUVXYZ[`abcdehijklmpqr@@4h 454S4_    ]]]    ]]]  $          ]           ]         ]  ]          ]    $     ]        ]  ]    .            -    ] ]  ]]]]]]]$ ]]]]]] bytes_len complete_input_chunkscomplete_chunk_output  encoded_remR=zRzRb'='# Tz# Tz$  Tz V]z  V]z XV&H K(NO .O .O /O /O 9OP 1P 1Q 1Q "Q 9Q ;QRI Correct, fast, and configurable [base64][] decoding and encoding. Base64LH transports binary data efficiently in contexts where only plain text isMK allowed. C [base64]: https://developer.mozilla.org/en-US/docs/Glossary/Base64F # Usage I Use an [`Engine`] to decode or encode base64, configured with the base64L? alphabet and padding behavior best suited to your application.B ## Engine setupH There is more than one way to encode a stream of bytes as “base64”.K. Different applications use different encoding1$ [alphabets][alphabet::Alphabet] and'D [padding behaviors][engine::general_purpose::GeneralPurposeConfig].G ### Encoding alphabetH Almost all base64 [alphabets][alphabet::Alphabet] use `A-Z`, `a-z`, andKM `0-9`, which gives nearly 64 characters (26 + 26 + 10 = 62), but they differP" in their choice of their final 2.%L Most applications use the [standard][alphabet::STANDARD] alphabet specifiedOL in [RFC 4648][rfc-alphabet]. If that’s all you need, you can get startedO$ quickly by using the pre-configured'P [`STANDARD`][engine::general_purpose::STANDARD] engine, which is also availableSG in the [`prelude`] module as shown here, if you prefer a minimal `use` J footprint.    ```   use base64::prelude::*;  1 # fn main() -> Result<(), base64::DecodeError> { 4I assert_eq!(BASE64_STANDARD.decode(b"+uwgVQA=")?, b"\xFA\xEC\x20\x55\0"); LG assert_eq!(BASE64_STANDARD.encode(b"\xFF\xEC\x20\x55\0"), "/+wgVQA="); J # Ok(())  # }  ```  H [rfc-alphabet]: https://datatracker.ietf.org/doc/html/rfc4648#section-4 K A Other common alphabets are available in the [`alphabet`] module. D #### URL-safe alphabetK The standard alphabet uses `+` and `/` as its two non-alphanumeric tokens,NJ which cannot be safely used in URL’s without encoding them as `%2B` andM `%2F`. V To avoid that, some applications use a [“URL-safe” alphabet][alphabet::URL_SAFE],YJ which uses `-` and `_` instead. To use that alternative alphabet, use theMM [`URL_SAFE`][engine::general_purpose::URL_SAFE] engine. This example doesn'tPD use [`prelude`] to show what a more explicit `use` would look like.GȊ > use base64::{engine::general_purpose::URL_SAFE, Engine as _};A4B assert_eq!(URL_SAFE.decode(b"-uwgVQA=")?, b"\xFA\xEC\x20\x55\0");E@ assert_eq!(URL_SAFE.encode(b"\xFF\xEC\x20\x55\0"), "_-wgVQA=");Cۃ  ### Padding charactersK Each base64 character represents 6 bits (2⁶ = 64) of the original binaryNE data, and every 3 bytes of input binary data will encode to 4 base64H2 characters (8 bits × 3 = 6 bits × 4 = 24 bits).5K When the input is not an even multiple of 3 bytes in length, [canonical][]NI base64 encoders insert padding characters at the end, so that the outputL" length is always a multiple of 4:%G [canonical]: https://datatracker.ietf.org/doc/html/rfc4648#section-3.5J > use base64::{engine::general_purpose::STANDARD, Engine as _};A) assert_eq!(STANDARD.encode(b""), "");,- assert_eq!(STANDARD.encode(b"f"), "Zg==");0- assert_eq!(STANDARD.encode(b"fo"), "Zm8=");0- assert_eq!(STANDARD.encode(b"foo"), "Zm9v");0K Canonical encoding ensures that base64 encodings will be exactly the same,NJ byte-for-byte, regardless of input length. But the `=` padding charactersMD aren’t necessary for decoding, and they may be omitted by using aG; [`NO_PAD`][engine::general_purpose::NO_PAD] configuration:> E use base64::{engine::general_purpose::STANDARD_NO_PAD, Engine as _};H0 assert_eq!(STANDARD_NO_PAD.encode(b""), ""); 32 assert_eq!(STANDARD_NO_PAD.encode(b"f"), "Zg"); 53 assert_eq!(STANDARD_NO_PAD.encode(b"fo"), "Zm8"); 64 assert_eq!(STANDARD_NO_PAD.encode(b"foo"), "Zm9v");!7!!J The pre-configured `NO_PAD` engines will reject inputs containing padding!MI `=` characters. To encode without padding and still accept padding while"LK decoding, create an [engine][engine::general_purpose::GeneralPurpose] with#N0 that [padding mode][engine::DecodePaddingMode].#3$$ $$$ G # use base64::{engine::general_purpose::STANDARD_NO_PAD, Engine as _};$JW assert_eq!(STANDARD_NO_PAD.decode(b"Zm8="), Err(base64::DecodeError::InvalidPadding));%Z&& ### Further customization&&@ Decoding and encoding behavior can be customized by creating an&CL [engine][engine::GeneralPurpose] with an [alphabet][alphabet::Alphabet] and'O7 [padding configuration][engine::GeneralPurposeConfig]:':(( ((( - use base64::{engine, alphabet, Engine as _};(0)E // bizarro-world base64: +/ as the first symbols instead of the last)H let alphabet =)` alphabet::Alphabet::new("+/ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789")*c .unwrap();*+[ // a very weird config that encodes with padding but requires no padding when decoding...?+^7 let crazy_config = engine::GeneralPurposeConfig::new()+:+ .with_decode_allow_trailing_bits(true),. .with_encode_padding(true),"G .with_decode_padding_mode(engine::DecodePaddingMode::RequireNone);,J-I let crazy_engine = engine::GeneralPurpose::new(&alphabet, crazy_config);-L./ let encoded = crazy_engine.encode(b"abc 123");.2... ## Memory allocation..M The [decode][Engine::decode()] and [encode][Engine::encode()] engine methods.PG allocate memory for their results – `decode` returns a `Vec` and/JL `encode` returns a `String`. To instead decode or encode into a buffer that0O3 you allocated, use one of the alternative methods:061 #### Decoding11_ | Method | Output | Allocates memory |1b_ | -------------------------- | ----------------------------- | ----------------------------- |2b_ | [`Engine::decode`] | returns a new `Vec` | always |2b_ | [`Engine::decode_vec`] | appends to provided `Vec` | if `Vec` lacks capacity |3bE | [`Engine::decode_slice`] | writes to provided `&[u8]` | never4H5 #### Encoding55_ | Method | Output | Allocates memory |5b_ | -------------------------- | ---------------------------- | ------------------------------ |5b_ | [`Engine::encode`] | returns a new `String` | always |6b_ | [`Engine::encode_string`] | appends to provided `String` | if `String` lacks capacity |7b_ | [`Engine::encode_slice`] | writes to provided `&[u8]` | never |8b9 ## Input and output996 The `base64` crate can [decode][Engine::decode()] and990 [encode][Engine::encode()] values in memory, or93+ [`DecoderReader`][read::DecoderReader] and:.G [`EncoderWriter`][write::EncoderWriter] provide streaming decoding and:JI encoding for any [readable][std::io::Read] or [writable][std::io::Write];L byte stream.;;;<< <<<  # use std::io;<F use base64::{engine::general_purpose::STANDARD, read::DecoderReader}; Result<(), Box> {=; let mut input = io::stdin();> = let mut decoder = DecoderReader::new(&mut input, &STANDARD);>@, io::copy(&mut decoder, &mut io::stdout())?;>/ۃ? ????????? @G use base64::{engine::general_purpose::STANDARD, write::EncoderWriter};@JAA; let mut output = io::stdout();A"> let mut encoder = EncoderWriter::new(&mut output, &STANDARD);AA+ io::copy(&mut io::stdin(), &mut encoder)?;B.ۃB BBC #### DisplayCC> If you only need a base64 representation for implementing theCA* [`Display`][std::fmt::Display] trait, useC-+ [`Base64Display`][display::Base64Display]:D.DDI use base64::{display::Base64Display, engine::general_purpose::STANDARD};DLE> let value = Base64Display::new(b"\0\x01\x02\x03", &STANDARD);EA> assert_eq!("base64: AAECAw==", format!("base64: {}", value));EAFF # PanicsF FK If length calculations result in overflowing `usize`, a panic will result.FN&H ( . . / / 9 1 1 1 " 9;ٷKLL /  $3(; :  ^ Aٷٷp           M77 7 7  y  encoded1JJ ƷQJƷQ J2ٷƷQJ2 J JQ777 7 7 7O  yO O O JOsink] ]`]                 $ αα    O          $ٷ  α !/7 7Oα7 !       $ٷ##H$% ""F77 7H 7  yH "" %# La Enables base64'd output anywhere you might use a `Display` implementation, like a format string.deiqL% let data = vec![0x0, 0x1, 0x2, 0x3];(4 let wrapper = Base64Display::new(&data, &STANDARD);7@ assert_eq!("base64: AAECAw==", format!("base64: {}", wrapper));CL/?&'(&(~M&* M&+J&- ^&.&ٷٷ+Y A convenience wrapper for base64'ing bytes into a format string without heap allocation.\ 012012III1//3&4&֋ڒ 01I֋ڒ 34&// 0&&//ƷQ1I0ٷ678867//3&4&֋ڒ 67I9F3 Create a `Base64Display` with the provided engine.6 6 7I55 967I<ٷ;<=<=;H>B777 7H 7MMMflagsJMfillJMJMwidthJM precisionJMbufJҠ᷷7  y :: >;<I formatter   &@A@AA@  AA@??B&˾ڹ@A˾ڹB   &?? @MMMJMJMJMJMJMJҠ᷷A GٷDEDEED IFG    CC L 77 7I 7  yI C C GDE  M MMM MMM MM MM  MM"> Implementations of `io::Read` to transparently decode base64.AMIf U~B FHRSTU( IK9 IL2) IM> IOC %IPioH IQ. ٷ  8 ٷ  ]  I]  I]4 Q A `Read` implementation that decodes base64 data read from an underlying reader.T   # Examples    use std::io::Read;  use std::io::Cursor; % use base64::engine::general_purpose;(  ^ // use a cursor as the simplest possible `Read` -- in real code this is probably a file, etc.a 3 let mut wrapped_reader = Cursor::new(b"YXNkZg==");6 4 let mut decoder = base64::read::DecoderReader::new(7  &mut wrapped_reader, ! &general_purpose::STANDARD);$  ' // handle errors as you normally would*  let mut result = Vec::new(); + decoder.read_to_end(&mut result).unwrap();.  " assert_eq!(b"asdf", &result[..]);%    VWXXVWJ J  J JV UU YIZI[I]I^I_IaIbIcIdIݦ׏*VJJݦ׏*YZ[]^_abcd  IUU VJ  IUUJ   IUUz]\c]   IUU]    IUU](  IUUz]`c]  IUU]  IUU]  IUU]  IUUG ٷfghhfg    Ii ؁4  777 7I 7MMMJMJMJMJMJMJҠ᷷7e e ifJJ  8 ٷklmlmk    UU YIZI[I]I^I_IaIbIcIdIݦ׏*kJJnqrsw ˄˄, B Create a new decoder that will read from the provided reader `r`.E  J kJjj nkJJreader  dnn]enn]D  I77 7 7  y] Fj j qkJJ  !5 ! I7 7Ɖj" j rkJJ" &Z & I77 7] 7Ɖj& j skJJ' b64_len_to_decode' ' + sttttstJJ VV  UU YIZI[I]I^I_IaIbIcIdIݦ׏*JJ4 suÌuuusuJJ 9 svÌvvvsvJJ ]]? V Unwraps this `DecoderReader`, returning the base reader which it reads base64 encodedX ? Jjj wkJJ? ?E ٷyz{yz{? ? ? ? J|? ДD7 & Decode input from the wrapped reader.@) @ Z Under non-error circumstances, this returns `Ok` with the value being the number of bytes@]  written in `buf`.A A [ Where possible, this function buffers base64 to minimize the number of read() calls to theA^  delegate reader.B B  # ErrorsB B W Any errors emitted by the delegate reader are returned. Decoding errors due to invalidBZ F base64 are also possible, and will have `io::ErrorKind::InvalidData`.CI D 77 7J 7ƉxD x |yJJD D f||]WM M MM MMM MM MM  MM"? Implementations of `io::Write` to transparently handle base64.BM  C G( * / %4  ErrorKindA >L  7 ٷٝٝƞٷY j ]  ]"  ]5 [ A `Write` implementation that base64 encodes data before delegating to the wrapped writer.^  \ Because base64 has special handling for the end of the input data (padding, etc), there's a_ Y `finish()` method on this type that encodes any leftover input bytes and adds padding if\ ] appropriate. It's called automatically when deallocated (see the `Drop` implementation), but` ] any error that occurs when invoking the underlying writer will be suppressed. If you want to` . handle such errors, call `finish()` yourself.1      use std::io::Write; (  \ // use a vec as the simplest possible `Write` -- in real code this is probably a file, etc._ Y let mut enc = base64::write::EncoderWriter::new(Vec::new(), &general_purpose::STANDARD);\    * ! enc.write_all(b"asdf").unwrap(); $   @ // could leave this out to be called by Drop, if you don't care C = // about handling errors or getting the delegate writer back @ & let delegate = enc.finish().unwrap(); )   $ // base64 was written to the writer ' ( assert_eq!(b"YXNkZg==", &delegate[..]); +          \ Calling `write()` (or related methods) or `finish()` after `finish()` has completed without _ ! error is invalid and will panic. $      \ Base64 encoding itself does not generate errors, but errors from the wrapped writer will be _ ) returned as per the contract of `Write`.,   # Performance  S It has some minor performance loss compared to encoding slices (a couple percent).V $ It does not do any heap allocation.'   # Limitations  ] Owing to the specification of the `write` and `flush` methods on the `Write` trait and their` Z implications for a buffering implementation, these methods may not behave as expected. In] \ particular, calling `write_all` on this interface may fail with `io::ErrorKind::WriteZero`._ O See the documentation of the `Write` trait implementation for further details.R   L  L J ȷ.JLȷ. ȴ  J    L(  z]k]  ]  z]l]  ]  H ٷ    K ɸ4  777 7K 7MMMJMJMJMJMJMJҠ᷷7  JL  9 ٷ    ȷ.JL ƻƻA F Create a new encoder that will write to the provided delegate writer.I   L J JL    l]m](% Y Encode all remaining buffered data and write it, including any trailing incomplete input"\  triples and associated padding.## # K Once this succeeds, no further writes or calls to this method are allowed.#N $ \ This may write to the delegate writer multiple times if the delegate writer does not accept$_ 3 all input provided to its `write` each invocation.%6 % Z If you don't care about error handling, it is not necessary to call this function, as the&] 2 equivalent finalization is done by the Drop impl.&5 ' 5 Returns the writer that this was constructed around.'8 ' ' ' J The first error that is not of `ErrorKind::Interrupted` will be returned.(M ( 7 7  yL(  JL( ,1 , 7 7  y-  JL- 7H 7 7 7]7  JL7 current_output_len7 : ÌJL Ր ]  ȷ.JLB4 B 7 7B  JLB M X Unwraps this `EncoderWriter`, returning the base writer it writes base64 encoded outputG[  to.H H X Normally this method should not be needed, since `finish()` returns the inner writer ifH[ V it completes successfully. That will also ensure all data has been flushed, which theHY ' `into_inner()` function does *not* do.I* J V Calling this method after `finish()` has completed successfully will panic, since theJY " writer has already been returned.J% K V This method may be useful if the writer implements additional APIs beyond the `Write`KY S trait. Note that the inner writer might be in an error state or have an incompleteLV  base64 string written to it.L M L JLM NG ٷN N N N LN V2 4 Encode input and then write to the delegate writer.N7 O ȕO] Z of `input` consumed. The value may be `0`, which interacts poorly with `write_all`, whichP] Y interprets `Ok(0)` as an error, despite it being allowed by the contract of `write`. SeeP\ C for more on that.QF R \ If the previous call to `write` provided more (encoded) data than the delegate writer couldR_ \ accept in a single call to its `write`, the remaining data is buffered. As long as bufferedS_ [ data is present, subsequent calls to `write` will try to write the remaining buffered dataS^ \ to the delegate and return either `Ok(0)` -- and therefore not consume any of `input` -- orT_  an error.U U U U 8 Any errors emitted by the delegate writer are returned.U; V 77 7L 7ƉV  JLV inputV ] ÌJL ] ÌJL ÌJL ! V Because this is usually treated as OK to call multiple times, it will *not* flush anyY - incomplete chunks of input or write padding.0  ҂ L The first error that is not of [`ErrorKind::Interrupted`] will be returned.ڂO  7 7L  JL B ٷ    M   7 7MŅ  JLʅ PT (6G'B =` A `Write` implementation that base64-encodes data using the provided config and accumulates theLc^ resulting base64 utf8 `&str` in a [StrConsumer] implementation (typically `String`), which isa! then exposed via `into_inner()`.$ Buffer base64 in a new String:"(S let mut enc = base64::write::EncoderStringWriter::new(&general_purpose::STANDARD);V$ // get the resulting String# let b64_string = enc.into_inner();&% assert_eq!("YXNkZg==", &b64_string);(D Or, append to an existing `String`, which implements `StrConsumer`:G(( let mut buf = String::from("base64: ");+A let mut enc = base64::write::EncoderStringWriter::from_consumer(D &mut buf,$$% // release the &mut reference on buf( let _ = enc.into_inner();& assert_eq!("base64: YXNkZg==", &buf); )    ^ Because it has to validate that the base64 is UTF-8, it is about 80% as fast as writing plain a bytes to a `io::Write`.     O J烲JO烲  : ȷ.J؀O Aٷ    烲JO  <M Create a EncoderStringWriter that will append to the provided `StrConsumer`. P O J JO   X Encode all remaining buffered data, including any trailing incomplete input triples and[ associated padding.A Returns the base64-encoded form of the accumulated written data.D O JO6ٷ烲JO!\ Create a EncoderStringWriter that will encode into a new `String` with the provided config._ J JOٷ N477 7N 7Ɖ JO%7 7N JOD An abstraction around consuming `str`s produced by base64 encoding.G !) Consume the base64 encoded data in `buf`,77 7 7 4K As for io::Write, `StrConsumer` is implemented automatically for `&mut S`.Nٷ7O Oڃ 77 7O 7 7O* Pushes the str onto the end of the String-ٷO 77 7O 7 /PP O؀ P>ٷ O477 7O 7Ɖ P%7 7O PtdٷԜٷMF Provides the [Engine] abstraction and out of the box implementations.IMz/ 9/  9 ;6: 1 23soٷۍٷɋɋ͌ٷB Provides the [GeneralPurpose] engine and associated config types.E,W6o$549 "Jzٷeԏٷϐ $+  $:5J4Z9r 2 ٷٷВВ]]!]']]]! P ]]ٷP-]P /  .ٷP ' 7 7P]    777 7P 7 7R  ySV estimate& 3 padding_mode v]DD 777 7] 7 7  yVD Dindex_at_start_of_inputD&D Dv]UU777 7] 7 7V VV&V Vw]x]X+X 7 7Y YvalueY $+ 5: 4J 9b 2o v ٷٷ ƟƟ  777 7] 7] 7Rۙ  input_index  output_index & 3  x]" zٷPK5 Create a `GeneralPurpose` engine from an [Alphabet].8G While not very expensive to initialize, ideally these should be cachedJ' if the engine will be used repeatedly.*7 7SQP,}&} %ٷP  Q  P C 777 7P 7 7]      ! ]  44zAQA7 7P]PA A input_lenA BB777 7P 7 7ۙB BBB͙CE!E7 7P 7PE EFAG 7 7S~G|,Ɉ]]KBK 7 7SK},]ے]OO7 7O  OUٷQXY Create a new config with `padding` = `true`, `decode_allow_trailing_bits` = `false`, andU\D `decode_padding_mode = DecodePaddingMode::RequireCanonicalPadding`.VGVY This probably matches most people's expectations, but consider disabling padding to saveV\W a few bytes unless you specifically need it for compatibility with some legacy system.WZXQ^=G Create a new config based on `self` with an updated `padding` setting.ZJZ\ If `padding` is `true`, encoding will append either 1 or 2 `=` padding characters as needed[_6 to produce an output whose length is a multiple of 4.[9\[ Padding is not needed for correct decoding and only serves to waste bytes, but it's in the\^C [spec](https://datatracker.ietf.org/doc/html/rfc4648#section-3.2).]F]\ For new applications, consider not using padding if the decoders you're using don't require]_ padding to be present.^^QQѕܕdGZ Create a new config based on `self` with an updated `decode_allow_trailing_bits` setting.`]`U Most users will not need to configure this. It's useful if you need to decode base64`XU produced by a buggy encoder that has bits set in the unused space on the last base64aXd character as per [forgiving-base64 decode](https://infra.spec.whatwg.org/#forgiving-base64-decode).bgI If invalid trailing bits are present and this is `true`, those bits willcLL be silently ignored, else `DecodeError::InvalidLastSymbol` will be emitted.cOdQQ lLS Create a new config based on `self` with an updated `decode_padding_mode` setting.eVfY Padding is not useful in terms of representing encoded data -- it makes no difference tof\\ the decoder if padding is present or not, so if you have some un-padded input to decode, itg_W is perfectly fine to use `DecodePaddingMode::Indifferent` to prevent errors from beinghZ emitted.h i However, since in practicei [people who learned nothing from BER vs DER seem to expect base64 to have one canonical encoding](https://eprint.iacr.org/2022/361),iR the default setting is the stricter `DecodePaddingMode::RequireCanonicalPadding`.jUkV Or, if "canonical" in your circumstance means _no_ padding rather than padding to thekYF next multiple of four, there's `DecodePaddingMode::RequireNoPadding`.kIlQRQӘߘm%ٷQn* Delegates to [GeneralPurposeConfig::new].n-nQ o$ٷQo o7 7Qo op"[ A [GeneralPurpose] engine using the [alphabet::STANDARD] base64 alphabet and [PAD] config.o^pPr)^ A [GeneralPurpose] engine using the [alphabet::STANDARD] base64 alphabet and [NO_PAD] config.qarPs"[ A [GeneralPurpose] engine using the [alphabet::URL_SAFE] base64 alphabet and [PAD] config.r^sPu)^ A [GeneralPurpose] engine using the [alphabet::URL_SAFE] base64 alphabet and [NO_PAD] config.tauPw#U Include padding bytes when encoding, and require that they be present when decoding.uXv_ This is the standard per the base64 RFC, but consider using [NO_PAD] instead as padding servesvb little purpose in practice.wwQx&G Don't add padding when encoding, and require no padding when decoding.xJxQ7ٷ  An `Engine` provides low-level encoding and decoding operations that all other higher-level parts of the API use. Users of the library will generally not need to implement this.\ Different implementations offer different characteristics. The library currently ships with_P [GeneralPurpose] that offers good speed and works on any CPU, with more choicesS coming later, like a constant-time one when side channel resistance is called for, and vendor-specific vectorized ones for more speed.h See [general_purpose::STANDARD_NO_PAD] if you just want standard base64. Otherwise, when possible, it'sk^ recommended to store the engine in a `const` so that references to it won't pose any lifetimea9 issues, and to avoid repeating the cost of engine setup. < [ Since almost nobody will need to implement `Engine`, docs for internal methods are hidden. ^     $ $ The config type used by this engine ' #( The decode estimate used by this engine +DO This is not meant to be called directly; it is only for `Engine` implementors.R1 See the other `encode*` functions on this trait.4Z Encode the `input` bytes into the `output` buffer based on the mapping in `encode_table`.]7 `output` will be long enough to hold the encoded data.:% Returns the number of bytes written.(: No padding should be written; that is handled separately.=L Must not write any bytes into the output slice other than the encoded data.O/ 777 7 7 7] RRT As an optimization to prevent the decoded length from being calculated twice, it isWW sometimes helpful to have a conservative estimate of the decoded size before doing theZ] decoding, so this calculation is done separately and passed to [Engine::decode()] as needed.`/ 7 7] ͨ  R1 See the other `decode*` functions on this trait.46 Decode `input` base64 bytes into the `output` buffer.9j `decode_estimate` is the result of [Engine::internal_decoded_len_estimate()], which is passed in to avoidm3 calculating it again (expensive on short inputs).`6X Each complete 4-byte chunk of encoded data decodes to 3 bytes of decoded data, but this[< function must also handle the final possibly partial chunk.?\ If the input length is not a multiple of 4, or uses padding bytes to reach a multiple of 4,_P the trailing 2 or 3 bytes must decode to 1 or 2 bytes, respectively, as per theS8 [RFC](https://tools.ietf.org/html/rfc4648#section-3.5).;U Decoding must not write any bytes into the output slice other than the decoded data.X] Non-canonical trailing bits in the final tokens or non-canonical padding must be reported as`2 errors unless the engine is configured otherwise.5 ! Panics if `output` is too small.$ /      777 7 7 7ۙ     decode_estimate!""$ Returns the config for this engine.!'"7 7 7" "'4? Encode arbitrary octets as base64 using the provided `Engine`."B Returns a `String`.## # Example# # ```rust# F use base64::{Engine as _, engine::{self, general_purpose}, alphabet};#I$= let b64 = general_purpose::STANDARD.encode(b"hello world~");$@ println!("{}", b64);$%. const CUSTOM_ENGINE: engine::GeneralPurpose =%1O engine::GeneralPurpose::new(&alphabet::URL_SAFE, general_purpose::NO_PAD);%R&8 let b64_url = CUSTOM_ENGINE.encode(b"hello internet~");&;&0&' &&' &'''  '&$'7 7O'''  '''c'77 7 7O'( ' input_bytes' '2J< Encode arbitrary octets as base64 into a supplied `String`.+?_ Writes into the supplied `String`, which may allocate if its internal buffer isn't big enough.,b-- -- -I.1.R/ fn main() {/! let mut buf = String::new();/$H general_purpose::STANDARD.encode_string(b"hello world~", &mut buf);/K println!("{}", buf);00 buf.clear();0? CUSTOM_ENGINE.encode_string(b"hello internet~", &mut buf);1B1 }112022 222 2222  22$2 77 7 7O222  22 output_buf2 3r3777 7 7 7O33 33 3 3>9 Encode arbitrary octets as base64 into a supplied slice.6<( Writes into the supplied output buffer.7+7] This is useful if you wish to avoid allocation entirely (e.g. encoding into a stack-resident7`! or statically-allocated buffer).8$88 89Ӄ1999 4 use base64::{Engine as _, engine::general_purpose};97 let s = b"hello internet!";: let mut buf = Vec::new();:@ // make sure we'll have a slice big enough for base64 + padding:C$ buf.resize(s.len() * 4 / 3 + 4, 0);;';R let bytes_written = general_purpose::STANDARD.encode_slice(s, &mut buf).unwrap();;U<1 // shorten our vec down to just what was written<4 buf.truncate(bytes_written);< =K assert_eq!(s, general_purpose::STANDARD.decode(&buf).unwrap().as_slice());=N=> 77 7 7  y]U>>>  >>> ??777 7 7 7?@ ?? ? ?JJ# Decode the input into a new `Vec`.E&EE EE F use base64::{Engine as _, alphabet, engine::{self, general_purpose}};EIF& let bytes = general_purpose::STANDARDF). .decode("aGVsbG8gd29ybGR+Cg==").unwrap();F1 println!("{:?}", bytes);GG // custom engine setupG- let bytes_url = engine::GeneralPurpose::new(G0" &alphabet::URL_SAFE,H%& general_purpose::NO_PAD)H)0 .decode("aGVsbG8gaW50ZXJuZXR-Cg").unwrap();H3 println!("{:?}", bytes_url);I II2IJ IIJ IIII  II$J7 7  y666161Jz888Global ڜqVJJJ  JJJyJ77 7 7KK JK JW~/ Decode the `input` into the supplied `buffer`.O2O\ Writes into the supplied `Vec`, which may allocate if its internal buffer isn't big enough.O_8 Returns a `Result` containing an empty tuple, aka `()`.P;PQ QQ QIQ1L engine::GeneralPurpose::new(&alphabet::URL_SAFE, general_purpose::PAD);ROSS use base64::Engine;S' let mut buffer = Vec::::new();S* // with the default engineS" general_purpose::STANDARDT!D .decode_vec("aGVsbG8gd29ybGR+Cg==", &mut buffer,).unwrap();TG println!("{:?}", buffer);U!U buffer.clear();UU // with a custom engineU CUSTOM_ENGINE.decode_vec(U!$ "aGVsbG8gaW50ZXJuZXR-Cg==",V' &mut buffer,V ).unwrap();VW!WWW3WW WWW WWWW  WW$W 77 7 7XXX  XXbufferXYY777 7 7 7YY YY ǡYYd1 Decode the input into the provided output slice.`4`Z Returns the number of bytes written to the slice, or an error if `output` is smaller than`] the estimated decoded length.a!a` This will not write any bytes past exactly what is decoded (no stray garbage bytes at the end).acb@ See [crate::decoded_len_estimate] for calculating buffer sizes.bCc] See [Engine::decode_slice_unchecked] for a version that panics instead of returning an errorc`# if the output buffer is too small.d&d 77 7 7  y]Xddd  deeթթee777 7 7 7۩eg ef feޫiÌ XjÌ S]oãj4k2 Returns the number of bytes written to the slice.k5kkcllCmb See [Engine::decode_slice] for a version that returns an error instead of panicking if the outputme buffer is too small.nnn nH Panics if the provided output buffer is too small for the decoded data.nKo77 7 7  y]Vooo  ooppp777 7 7 7pq pp ppsÌt> The minimal level of configuration that engines must support.tAty!D Returns `true` if padding should be added after the encoded output.tGuL Padding is added outside the engine's encode() since the engine may be useduOK to encode only a chunk of the overall output, so it can't always know whenvNG the output is "done" and would therefore need padding (if configured).vJy7 7y y{_ The decode estimate used by an engine implementation. Users do not need to interact with this;yb$ it is only for engine implementors.z'z^ Implementors may store relevant data here when constructing this to avoid having to calculateza# them again during actual decoding.{&|~(Z Returns a conservative (err on the side of too big) estimate of the decoded length to use|]! for pre-allocating buffers, etc.|$}W The estimate must be no larger than the next largest complete triple of decoded bytes.}Z[ That is, the final quad of tokens to decode may be assumed to be complete with no padding.~^~7 7] ٷSMΆ]S  decoded_bytes҆  padding_index MNK Provides [Alphabet] and constants for alphabets commonly used in the wild.NN2[ convertpyJerrorTiٷ  ] ٷS 3 7 7S ,]DG Create an `Alphabet` from a string of 64 unique printable ASCII bytes.J7 The `=` byte is not allowed as it is used for padding.:7 7 ,3 Create a `&str` from the symbols in the `Alphabet`67 7S 7  (ٷ7S  T 5 7 7  ySST  7ܞ $(ٷT$8$777 7T 7MMMJMJMJMJMJMJҠ᷷7$ $%(((9(( ((( (( ((  (("ٷT*D The standard alphabet (with `+` and `/`) specified in [RFC 4648][].(G)D [RFC 4648]: https://datatracker.ietf.org/doc/html/rfc4648#section-4)G*S,D The URL-safe alphabet (with `-` and `_`) specified in [RFC 4648][].+G+D [RFC 4648]: https://datatracker.ietf.org/doc/html/rfc4648#section-5+G,S.J The `crypt(3)` alphabet (with `.` and `/` as the _first_ two characters).-M-\ Not standardized, but folk wisdom on the net asserts that this alphabet is what crypt uses.-_.S/ The bcrypt alphabet./0S2= The alphabet used in IMAP-modified UTF-7 (with `+` and `,`).1@1B See [RFC 3501](https://tools.ietf.org/html/rfc3501#section-5.1.3)1E2 S4' The alphabet used in BinHex 4.0 files.3*3W See [BinHex 4.0 Definition](http://files.stairways.com/other/binhex-40-specs-info.txt)3Z4SN N8 :J J{ ' $ ( 2 ) D v (  ٷ 1 K Encode arbitrary octets as base64 using the [`STANDARD` engine](STANDARD).N   See [Engine::encode].  :      0.21.0    Use Engine::encode <  :             $  O   O REncode arbitrary octets as base64 using the provided `Engine` into a new `String`.U    :           <  :             $  7 7O       t ;Encode arbitrary octets as base64 into a supplied `String`.>   See [Engine::encode_string].  :          Use Engine::encode_string C  :             $  77 7O 7                 <    See [Engine::encode_slice].   ;                  Use Engine::encode_slice   B   77 7 7                777 7 7 7]     expected_encoded_size  J W Calculate the base64 encoded length for a given input length, optionally including anyZ  appropriate padding bytes.  [ Returns `None` if the encoded length can't be represented in `usize`. This will happen for^ H input lengths in approximately the top quarter of the range of `usize`.K  ]  Q ! 7] 7]! unpadded_output_len! ! %& ٷU%8 % 777 7U 7MMMJMJMJMJMJMJҠ᷷7%  % & '& ' =' '  ' ' '  ' '  ' '  ' '" ٷUN<ٷOCٷP P'% $/ (? } 6 J B ٷ q    ! ٷV 4   777 7V 7MMMJMJMJMJMJMJҠ᷷7       !  >              " ٷV& ٷX8  777 7X 7MMMJMJMJMJMJMJҠ᷷7    &  >              " ٷX9  7 7X   7   + ٷX  VX  G 7 Decode base64 using the [`STANDARD` engine](STANDARD).:   See [Engine::decode].  ?          Use Engine::decode <  ?             $     p E Decode from string reference as octets using the specified [Engine].H  Ѐ *Returns a `Result` containing a `Vec`.-  Ņ?           <  Ά?             $  7 7       шш܈܈ ( Decode from string reference as octets.+   See [Engine::decode_vec].  ?             $  ?          Use Engine::decode_vec @  77 7 7         ǡ    " ã!4 !  See [Engine::decode_slice].! ! ?! "   ! " " " " " Use Engine::decode_slice" !B " 77 7 7۩# " " " " " " # ԑԑߑߑ(8 ` Returns a conservative estimate of the decoded size of `encoded_len` base64 symbols (rounded up#c ' to the next group of 3 decoded bytes).$* $ _ The resulting length will be a safe choice for the size of a decode buffer, but may have up to%b 1 2 trailing bytes that won't end up being needed.%4 & & & & " use base64::decoded_len_estimate;&% & ( assert_eq!(3, decoded_len_estimate(1));&+ ( assert_eq!(3, decoded_len_estimate(2));'+ ( assert_eq!(3, decoded_len_estimate(3));'+ ( assert_eq!(3, decoded_len_estimate(4));'+ - // start of the next quad of encoded symbols(0 ( assert_eq!(6, decoded_len_estimate(5));(+ ( ( ]] /) P9ٷQYٷR, Preconfigured engines for common use cases./0f These are re-exports of `const` engines in [crate::engine::general_purpose], renamed with a `BASE64_`4i@ prefix for those who prefer to `use` the entire path to a name.C@ < use base64::prelude::{Engine as _, BASE64_STANDARD_NO_PAD};?M assert_eq!("c29tZSBieXRlcw", &BASE64_STANDARD_NO_PAD.encode(b"some bytes"));PR(BASE64_STANDARD BASE64_STANDARD_NO_PAD BASE64_URL_SAFE BASE64_URL_SAFE_NO_PAD (Ş/(/RRz! A general-purpose base64 engine.$E - It uses no vector CPU instructions, so it will work on any system.H% - It is reasonably fast (~2-3GiB/s).( - It is not constant-time, though, so it is vulnerable to timing side-channel attacks. For loading cryptographic keys, etc, it is suggested to use the forthcoming constant-time implementation.*Pē ~z] z]QJٷP777 7P 7MMMJMJMJMJMJMJҠ᷷7 JٷP7 7PP SD Contains configuration parameters for base64 encoding and decoding.PGQQ, # use base64::engine::GeneralPurposeConfig;Q/) let config = GeneralPurposeConfig::new()Q,! .with_encode_padding(false);Q$; // further customize using `.with_*` methods as neededR>RR7 The constants [PAD] and [NO_PAD] cover most use cases.R:S0 To specify the characters used, see [Alphabet].S3+SQTTT TT&TRSKٷQ7 7QQS SSKٷQSKٷQ777 7Q 7MMMJMJMJMJMJMJҠ᷷7S S2 Controls how pad bytes are handled when decoding.5> Each [Engine] must support at least the behavior indicated byAD [DecodePaddingMode::RequireCanonical], and may support other modes.G.R௨ԓm U Canonical padding is allowed, but any fewer padding bytes than that is also allowed.X.RRQ Padding must be canonical (0, 1, or 2 `=` as needed to produce a 4 byte suffix).T.ݴRݴݴR [ Padding must be absent -- for when you want predictable padding, without any wasted bytes.^.RRLٷR7 7RR ĸĸLĸٷRLٷR777 7R 7MMMJMJMJMJMJMJҠ᷷7  LٷRLٷR77 7R 7R  MٷRMٷRM M 7 7R ф0 Metadata about the result of a decode operation3/܄S ]( MٷSMٷS77 7S 7S  ńMٷSMٷSN N 7 7Sń ńɄNٷS777 7S 7MMMJMJMJMJMJMJҠ᷷7Ʉ Ʉ G An alphabet defines the 64 ASCII characters (symbols) used for base64.JA Common alphabets are provided as constants, and custom alphabetsDA can be made via `from_str` or the `TryFrom` implementation.D& Building and using a custom Alphabet:){ let custom = base64::alphabet::Alphabet::new("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/").unwrap();~2 let engine = base64::engine::GeneralPurpose::new(5 &custom,+ base64::engine::general_purpose::PAD);. Building a const: use base64::alphabet::Alphabet;# static CUSTOM: Alphabet = {< // Result::unwrap() isn't const yet, but panic!() is OK?^ match Alphabet::new("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/") {a Ok(x) => x,9 Err(_) => panic!("creation of alphabet failed"),< }  }; Building lazily:   use base64::{  alphabet::Alphabet, E engine::{general_purpose::GeneralPurpose, GeneralPurposeConfig}, H  use once_cell::sync::Lazy;  - static CUSTOM: Lazy = Lazy::new(|| 0_ Alphabet::new("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/").unwrap() b );  0 S€ ' z]] NٷS7 7SS    NٷS777 7S 7MMMJMJMJMJMJMJҠ᷷7    OٷSOٷSO O 7 7S   ] OٷSOٷS77 7S 7S   "> Possible errors when constructing an [Alphabet] from a `str`.!A1"T֙ğґzTzTzT" ! Alphabets must be 64 ASCII bytes"$1TT All bytes must be unique#1 zT #z8 All bytes must be printable (in the range `[32, 126]`).#;1 zT $z `=` cannot be used$1 zT $z"OٷT777 7T 7MMMJMJMJMJMJMJҠ᷷7" ""PٷTPٷTP P 7 7T" "" QٷTQٷT77 7T 7T" " $ 3 Errors that can occur while encoding into a slice.$6 8$ U% ! The provided slice is too small.%$ 8UU$ SٷU7 7UU$  $ $ SٷU777 7U 7MMMJMJMJMJMJMJҠ᷷7$  $ $ SٷUSٷU77 7U 7U$  $ $ SٷUSٷUS S 7 7U$  $  & Errors that can occur while decoding.) : VղɈģ]zV]zVT An invalid byte was found in the input. The offset and offending byte are provided.W \ Padding characters (`=`) interspersed in the encoded form will be treated as invalid bytes._ : ]zV  ] z $ The length of the input is invalid.' O A typical cause of this is stray trailing whitespace or other separator bytes.R \ In the case where excess trailing bytes have produced an invalid length *and* the last byte_ [ is also an invalid base64 symbol (as would be the case for whitespace, etc), `InvalidByte`^ N will be emitted instead of `InvalidLength` to make the issue easier to debug.Q :VV] The last non-padding input symbol's encoded 6 bits have nonzero bits that will be discarded.` 5 This is indicative of corrupted or truncated Base64.8 [ Unlike `InvalidByte`, which reports symbols that aren't in the alphabet, this error is for^ F symbols that are in the alphabet but represent nonsensical encodings. I : ]zV   ]  z  U The nature of the padding was not as configured: absent or incorrect when it must be X 3 canonical, or present when it must be absent, etc. 6 :VV TٷV7 7VV    TٷV777 7V 7MMMJMJMJMJMJMJҠ᷷7    UٷVUٷV77 7V 7V    σσVσٷVσσσVσٷVσσσVσσ σσσσVσσ σσσ7 7V    3 Errors that can occur while decoding into a slice.6 ? X㏬׬:VX A [DecodeError] occurred ? VX  V ' The provided slice _may_ be too small.*  Y The check is conservative (assumes the last triplet of output bytes will all be needed).\ ?XX WٷX7 7XX    WٷX777 7X 7MMMJMJMJMJMJMJҠ᷷7    XٷXXٷX77 7X 7X    XٷXXٷXX X 7 7X   ٷٷٷٷٷٷٷٷٷٷ ٷٷ ٷЃٷ ٷ ٷljٷ ٷٷËٷ' ٷٷD ٷºٷ ٷ ٷٷٷٷٷٷV ٷٷٷٷٷٷٷٷٷńٷٷٷٷٷٷٷܗٷٷٷٷٛٷDٷDٷٷVٷVٷžٷٷ ٷ ٷٷٷ ٷ ٷٷϩٷBٷCٷݪٷٷٷٷٷٷٷٷٷٷ ٷ!ٷٷٷٷ(ٷٷ2ٷٷ3ٷ3ٷٷ>ٷٷ?ٷ?ٷٷٷKٷٷXٷٷYٷYٷĩٷeٷٷfٷfٷٷpٷٷpٷqٷ׹ٷٷٷٷٷ ٷٷٷ%ٷ%ٷٷٷ  ٷٷ  ٷٷ ٷ ٷٷٷ& ٷ& ٷٷ  ٷ ٷٷ ٷ ٷٷÈٷ؍ٷ  ٷƑٷ# ٷٷٷٷٷٷְٷְٷٷٷٷٷٷǼٷǼٷٷٷٷٷٷٷٷٷٷٷٷٷٷٷٷٷٷٷٷٷٷٷٷٷٷٷٷٷׁٷׁٷٷٷٷ̅ٷٷٷٷٷЎٷЎٷٷ5jalphabet::STANDARD Hwrite::EncoderWriterreadablestd::fmt::Display!engine::general_purpose::URL_SAFEpadding configuration'engine::general_purpose::GeneralPurposeEngine::decodestd::io&8https://developer.mozilla.org/en-US/docs/Glossary/Base64standardalphabet::URL_SAFE(engine::GeneralPurposeEngine::decode_slice std::io::Read,Engine::encode_slice writableengine::general_purpose“URL-safe” alphabetengine::DecodePaddingModeEngine::decode_vecalphabet::Alphabet(-engine::general_purpose::GeneralPurposeConfig!engine::general_purpose::STANDARDEngine::encode_stringŸEngine::encodedisplay::Base64Display-https://datatracker.ietf.org/doc/html/rfc4648std::io::Write~( std::fmtRFC 4648Ԥengine::GeneralPurposeConfig( alphabetsŸ padding mode ( padding behaviorsread::DecoderReader~( engine::general_purpose::NO_PAD Ǣ'ȣ( Π/, Ψ' %ԤɧΠ(M ΨU~ ɧ,(Ǣ ȣ'ErrorKind::Interrupted??(STANDARD engine(®®'('' BinHex 4.0 Definition#https://tools.ietf.org/html/rfc35016RFC 35019http://files.stairways.com/other/binhex-40-specs-info.txtگگ66-2Engine::decode()crate::decoded_len_estimate'Engine::internal_decoded_len_estimate()Engine::decode_slice_uncheckedǢ%Engine::internal_decoded_len_estimate(#DecodePaddingMode::RequireCanonical general_purpose::STANDARD_NO_PAD RFC#https://tools.ietf.org/html/rfc4648Ǣ(۳2 ݱݱǢ(۳2-2forgiving-base64 decodeŸ Ÿ _people who learned nothing from BER vs DER seem to expect base64 to have one canonical encoding63GeneralPurposeConfig::new https://eprint.iacr.org/2022/361(յ66(3,( (spechttps://infra.spec.whatwg.org/2յŸ3( (,,2 crate::engine::general_purpose crate::engineչչ(®9Ǣ(®9'®(Ǣ'9' Ǣ=>==>-=>==>-=>==>-=>==>-=>==>-=>==>-ohgl1/C H8aohgl1=2 ~;ohgl1s|;ohgl1ÁJcohgl1Ac]濉ohgl1: 7*1ohgl1%rohgl131Cohgl1wvFohgl1tI0鿉ohgl1zۿohgl1}c嚿ohgl1()- ohgl1ңFohgl1 (-ohgl1Q|'!ohgl1,)CxĿohgl14Ƿ ⿉ohgl13wX!ohgl1cB ohgl1 yohgl1`=DIcohgl1-~- ohgl1fHh9c$5ohgl1d\+Xohgl1L>w ohgl1@!"뿉ohgl19Xohgl1 ͦt5ohgl1L1<vohgl1tpgSohgl1UKQgohgl1ozzϿohgl1T>)Qohgl1S@{9l{ohgl1;öohgl1 _Y&ohgl18_.7Hohgl1Ϝ¿/.}ohgl15c/Ba|ohgl1Ik!<ohgl1BZߊohgl1J-d￉ohgl1,N5tohgl1x8ohgl1xЈP{ohgl1S9!ohgl1c2WUohgl1\LPohgl1^7Q7dohgl1+jCohgl1Yb@ohgl1X} ǿohgl1g7ohgl19 u+cohgl1dr3 Dohgl1ڼNmohgl1XBKohgl1UװM࿉ohgl1𙚰!ohgl1L5]^ohgl1]<47ohgl1m翉ohgl1Sܡ9\ohgl1m]{' ׿ohgl162W޿ohgl1$*,ohgl1[g'ohgl1NR%"ohgl1qohgl1H1b ohgl1on&7ؿohgl1B(|}ohgl1:ϋ6nohgl1Av-ohgl1۶oohgl19Rohgl1]/#-ohgl1}[ohgl1r6Zohgl1?ʙCT׿ohgl1nbIohgl1ވ ohgl1Jw?W̜Ϳohgl1KkHkHmohgl1N84ohgl1>?@M,`ohgl18+xRohgl1)Xohgl1?ohgl1xQ#İohgl18MX7ݿohgl16 jMohgl1M%Y(uohgl1YJ0ohgl1/bƿohgl1Vx)Nohgl1/d͛ohgl1Q;ohgl1#-P v\ohgl10B>+tͿohgl1`>:ohgl1'%>Kohgl1Zmohgl1~*Tohgl1_3"λ]ohgl1z+ohgl1`Xa>ohgl1 jJohgl1;e_\%ohgl1Pw-Gohgl1rNsohgl1[Z$:Rohgl1wL¦ܿohgl1Yz:ohgl1Aohgl1ᶻGohgl1ԡ4юֿohgl1sohgl1)!ohgl1c!ohgl1dMh1ohgl1ei ohgl1vE-3ohgl1FGiohgl1!ƴohgl1 21+ohgl1{Hohgl1,#%ohgl1Tzg%[ohgl1Jyohgl1[lJ%=ؿohgl1">C\ohgl1 yƚ\ohgl1ohgl1ɿzuohgl1Q})cohgl1'Oaaohgl1{i1$Gտohgl1 ohgl1`K bHohgl1 8Mohgl1B+ ohgl10^Ͽohgl1APy 8oohgl1Z" Hӿohgl1|w#ohgl1+ohgl1nohgl1Ĭ+8HFohgl1CϤohgl1+p~ohgl1@N+ohgl1dohgl1fL]뿉ohgl1߉ܿohgl1C`49ohgl1Vm9<dohgl1T۟p#ohgl1>2'ϝohgl1O\݃/ohgl1NMb)Dohgl1B# ohgl1Eh]ʿohgl1փ+<Ͽohgl1{4 1@K,ohgl1YKohgl19AC<ohgl1˦;ohgl1TFohgl1P`ptohgl1z[mC)|ohgl1,!Oٿohgl1+i'Fohgl1`RDc ohgl1\:#pohgl15a꿉ohgl1Fཨ*ohgl1 cbohgl1u?տohgl1Pm5/apohgl1iRKB%ohgl1,3Hqnohgl1jSCԩohgl12<0johgl1sV椚D2ohgl1jw/ohgl1wH~`ohgl1wW7ohgl15waxݿohgl1j㱡Xohgl1$%5:ohgl14sMM>ohgl1=vohgl1)ohgl1!4"ohgl1QqK4ohgl1>黅ohgl1q`:ȿohgl1a9>Thohgl1zR}ohgl1b[W뿉ohgl1MBl5[ohgl1i%tYT-ohgl1?:Ɲohgl12|3ohgl1pcD뿉ohgl1UۄHohgl1%Zy$ ohgl1'%.Wohgl1Epohgl1܁{խohgl16oVͿohgl1W_迉ohgl1b,mf翉ohgl1dpg+ohgl1ly4ohgl18ͭ1ƿohgl1@vHL+ohgl1!o ƫohgl1> ohgl1 ohgl1ո"+ohgl1.Oohgl185 ɿohgl1_h0@ohgl1PnjCohgl16Lt忉ohgl16~\!ohgl1rR Eohgl1n*oohgl1=LO+3Iohgl1Ʒ}sʿohgl1$i;".=Pvohgl1 ohgl10ohgl18 /ohgl1ύNHXف]ohgl1#ulohgl1kw3Puohgl1$K'ohgl1]Q!ohgl1!n$Eohgl1|Ωg]4ohgl1} ohgl1i^x[6ohgl1W2 ohgl1n=)mohgl1q=94_ohgl1ohgl1*࿉ohgl1,[Kohgl1]R}￉ohgl1teMhohgl1x^ohgl1lPohgl1΁ohgl1kPՁohgl1nE|Uohgl1`'.5}ohgl1Lr(2迉ohgl1E=6ohgl1-Qohgl1EJohgl1;%ohgl1e>xHrohgl1S,/ohgl1mTڿohgl1-]Yohgl1)Կ㿉ohgl1!6Ƕohgl1(:ohgl1Ԝohgl1Oxohgl1gv=Ms%ohgl1˘຿ohgl13룓ڿohgl1?hWΤohgl1>݉qWohgl1I8;'aohgl1i#Gohgl1]hf%濉ohgl1zޒW(ohgl1DuJohgl12.Ɇohgl1EiS`"ohgl1j@yohgl1!WAohgl1N|Vmohgl1%V rohgl1f]ohgl149(oohgl1pڝ.7ohgl1fihohgl1ȵ/?%ohgl1kr }ohgl1)%-6uohgl1! /ohgl1A_ohgl1}$ohgl1ߛaohgl1brɉvohgl1#,~ohgl17¤ohgl1Kwohgl1Xohgl1/њJcohgl1 @ohgl1WL_ohgl1,5Hohgl15NW3ohgl1>:ʿohgl1qXq-ݠohgl1+kl쿉ohgl1Ss_ZWohgl1r뿉ohgl1d>]ohgl1Obֿohgl1EUohgl1C;lohgl1hKwohgl11Y8ohgl1GEpݴohgl1xH,ohgl1&1!ohgl1jYohgl1p_Rohgl1Q0ohgl1EWohgl1}$7K;ohgl13Q] Iohgl1@Gpohgl1SqK}ohgl1  ^ohgl10M2e}쿉ohgl17/ohgl1=\bnyzohgl1/\/ȿohgl1v:ohgl1+]E;ohgl19T/ohgl1NGyhohgl1>ohgl1 ɿohgl1Oycohgl1)+eohgl1`F.ohgl1þ! ؿohgl1F$<4 ohgl1Hbx1Hpohgl1 lQsohgl1Ta3.ohgl1>u뿉ohgl1؝D롿ohgl1;~?Ojohgl1 Tn忉ohgl1lYHMohgl1gs=/ohgl1 @󱿉ohgl1fqohgl1P";mwohgl1֓/rohgl1ʩ!ohgl14Z1gohgl1v OoWuohgl1:~Ĝ[꿉ohgl1Dk>*9ohgl1r ,˿ohgl1: 1ohgl1@cHohgl1n)=Kohgl1$6HPohgl1I`ջ{ohgl12 W:kohgl1@?$nտohgl1s=maohgl1/ÎbZohgl1Bk`oohgl1Wh:}ohgl1cohgl1TiЍPohgl1\+3s-`|ohgl1\׸fohgl1ǁ&/Lohgl138ohgl1 8:1@ohgl1OS1¿ohgl1²ohgl1ڄj7ohgl1\hya?طohgl147K߿ohgl1w7`ohgl1Xr ؿohgl1H)ohgl1u8*`ohgl1}c.ohgl1Ejz߿ohgl16:9 ohgl1Ə$z㿉ohgl1%5Uohgl1%#_;Rohgl1B;׿ohgl1&YCԿohgl1w#G\$nohgl1~g@ohgl13Iohgl1hJohgl1][CXohgl1Q kohgl1;~D&ohgl1濾q6ohgl1d1g-H˿ohgl1΢=ohgl1^Yjhohgl1Гc}{vwohgl1[Կohgl1#y ohgl1鿯ypmohgl1"Vcѿohgl1x}\Aohgl1{Q -ohgl1}uw@쿉ohgl1<5aT]ohgl1ɬTohgl1,&VEohgl1&2ohgl1ƮN{ohgl1Bjbݚohgl1Ոohgl1:WXdohgl1Bаܶohgl1xo7"dohgl1%Ќ'ohgl1C)A+ohgl12MXohgl12_ohgl1 ɿohgl1xlC}^vohgl1/T ohgl1pNڿohgl1 cohgl1I0D,"ohgl1pohgl15}*ohgl1ۑwohgl1E6Qohgl1 ɿohgl1P Pohgl1lFǴq>ohgl1^,ohgl15^rohgl1z͈ohgl1rĿohgl1:''o׿ohgl19Z 俉ohgl101vohgl1 {Wohgl1Xo"ohgl1 KTGohgl1% ohgl1+( /ohgl1d{пohgl1ޣNohgl1cYr=ohgl10".;Hohgl1XCpXohgl1ϮRlLohgl1 =2 ohgl1 xD ohgl18$}ohgl13Kɿohgl1HWz;ohgl1 $Oohgl1 6U)hohgl1bvohgl1UvYSoOohgl1%`gɿohgl1,U'nohgl1=hkYohgl1(4neohgl1j靽ohgl1z%Ϳohgl1 i>ohgl1PR ohgl1FO4ohgl1'/2vohgl1}O8뿉ohgl1?">{ʿohgl1qJ;o쿉ohgl1?Zohgl1Eݬ0ohgl1WTS)ohgl1]Oȧohgl1L7ohgl16SSSohgl1]ue>ohgl1f5,PPohgl1sMI@dVohgl12E54ohgl1CYpohgl1bnPohgl1.[0ƿohgl1ّohgl1Œohgl1J8Wohgl1Qdmcohgl1Z1ۿohgl1ރBձohgl1Wkou|!rohgl1673ohgl1L`PE:ohgl14vxeԐohgl1V2coohgl13 @ohgl1w928lohgl1CCohgl1;P~߿ohgl1J%]ohgl1ġxlXv>ohgl1Nohgl1 UEAohgl1E}BHohgl1dٿohgl1Scohgl16;ohgl15 忉ohgl1N 󒿉ohgl1GZrŹWohgl1Hhdohgl1'bohgl1*tohgl1l$ΠUohgl1 ohgl14xÿohgl1?199eɿohgl1.ohgl1mohgl1s-+_`ohgl1|+ mOohgl1M eohgl1;ohgl1Aohgl1 azohgl1<Uohgl1ʴѳfohgl10 (ohgl1X9ohgl1X 5qohgl1>$|˿ohgl1D}ohgl1\-迉ohgl1DUQ]Aohgl1: ]seohgl1[sBˋohgl1)qԁdp1ohgl1b޾ohgl10Ԩ&Dohgl1 %/f ohgl1?Kohgl1x johgl1FTԞMOohgl1qnZohgl1p =&ohgl1MzNׂohgl1Umohgl1&(e\@ohgl1._ohgl1 5kohgl1ohgl1O7gohgl1}N~T&ohgl1 6i'Rпohgl1F 8eohgl1L+&/Έohgl1p_ohgl1 Xgohgl1X7R+ohgl1x[L@>ohgl1 Ŋ]ohgl1ohgl1t\3 ɿohgl1벶ƛܿohgl1$=ohgl1aoohgl1 \⿉ohgl1uvcпohgl14&ohgl1ʯu/=ohgl1,i9ohgl1? GŠ3ohgl1`%5ohgl18msz(Qohgl1*݈?!ohgl1z0Nohgl1!?ohgl1\*ohgl1 וlAvohgl1t뺍ohgl1b ohgl1xw*-ohgl1U׀q91Lfgk X !!f"""]##d$$& &Y++ +,/#16W7;;?@ESFJKP Q,UUaVVYUZZ:[\|^L`g``ab-bbc?dgddCe]eIffghfiiajk6ln qsuv7xxxyz{{|@}Z}F~~!gS *Or De5he Mu(M|%TAr[,8i =4eD^# :k$Soq_w!C`}z9Vs]1b7z2{ 0U5MF | */[q^B a*kzI\Smj}U* O:GX)t :  ]!w" *1[s^]` b\dTefxUz{9}Q}~7`xxPlc70_ai|6eO~h-\1cv,                                                      """"!!!"!"!"!"Ң.>h.5PT ~L:g3,G:Y˿=\#L*Ik|:5D]hkZ QN   & B ^    X   = SzN8Q|& &!C""J##Q$$%a&g*++.066k:-;??DEIJ2PQ)TAUXY[\J^_}`AaaBbTccnddregmhSiiNj k(kn.prtuxLxxz{o}q_&VΓKls#Kʚ{ĜE؟ 0թ{w-ծ?jHذ5۲A˴(/Gd<d=ZC,t8DKpz ɤӤޤ0Lɦަoz'B]okv~Ь̭۬ٯ %Wbmfóγn+6Aζ!,K(%ǹѹٹ9Tؾ,Kq/Nnf|P[mFXb<FPX`hpxHSew-;]ITfxvdoSg{`oM"6+6HZvY;vA 2)19A!,7?y            4 P l   " <      (6j!)1*E__ x@OdQ!!_"y""V##]$$%m&x&&&R+++%/16P7:;;;??p@@jE|E7FLFJJfK{KPPQQU$UUUZVVmYY9ZNZZ3[\u^D`_```aaaaaab&bbbc8d`ddIT\goz*2=EP[ckv #+3;CKS[cks{ #+3;CKS[cks{'ŤϤڤ7S'ŦЦ v.Ir}6׬M!^iqoʳҳw2=E׶(3R -ù͹չݹ %@߾ 3RĿ6Uw nmW_q^EBLT\dlt|#OWi{ BdPXjksg% x(>V2:La$V}bSJ$9%-5= (3;            ; W    + C    ( >s %-9&1N<gkr!!."h""C##J$$%Z&t&|&&`*++.056V:;;;>??w@kDnEE>FzIJJmKPPPQTU,UUoXqYY@Z[\C^_N`g``:aaaaaaab-b?ccAdgddEe]efgfhLiiGjk!kkkklll l+lmsnppprsstuuuvw7xxxFz\zdzlztzzzzzzN{X{`{h{r{}{{{{*}B}Z}~~ ܃\?QJ,>jˌӌی؏ODeŖږQk9ƚwڛi1П(iAp]rΩTi(!Pe&Ѯ;X D԰#'VDz@o:ն{ C`8R9V1yMb"127 #+6>FQYdlw$,7?GOZemx#+3;CNYait '2:EPXckv &.9ALW_gr}'/7?GOW_gow'/7?GOW_gown/prtr`HPۦ/ʧ$>Yi#Lʬɰ|-7ݳ7WD5PEd{ֿ )Hg:GxYj|R`bt7VxcuJ~&`t>pMi^EWuZ"9]pM#k/   0 L h    6 m      2JAYk9e5K];!!U"s""R##Y$$%i&}*++.0l697:;;;V??:@@#EyEFIF~JJ;KxKPPmQQT!UUU:VV'Y|YZKZZ[\`^-`Y``bbpbbc%dXdydePe%ffguh[iiVjk/n~nppq:sss(uuu,vvxzxxyQz{u|5}M}"~~܁KJ\Έ7Iɑ3DciXyЖ\_{.V՚0tyĝQ˞t<tL{$h9ݩ,_3۬,[5J~3Sð2a Kz׳Iִ Vh=]2RoGo(He&Nο)X-@(rYy?1Ԧ7R`:u.sֳ'N۶;.I<[tͿ ?^{7%,cu I.[m0Ln\n9wVj-_C| b7,a>Pk(/fL[<U(   ) E a    / c      +<:RoZ(T'DS1!!K"l""K##R$$%b&h*++.0[6(7:;d;;6??@{@ErEEBF^JJKqKjPPPQQTUUUVoVYuYYDZcZ [\K^`R``ab_bbpcdEdodeIeffgnhTiiOj knwn[pppssstuuvvxlxxyJz{d|.}F}~~tƁCU0B‘ )=YWNoɖUMt$L˚|ޛmf>Ğaٟ2mEta&֩%X,ɬ%T.֮@t)Iٰױ+ZDsųB̴DVٶ+K(He=e>[D} "Q&9!`rGg*-[o^w<Χ@[m%N̬űE;;ݵ[H7R=!Ih}ڿ-LkhK|]M V#9[}EO+eyCuR!nz:>bR(   2 N j    8 r      4LC[p>j7Mb@!!Z"u""T##[$$%k&.0q6>7:;q?G@>EFJHKPzQTU?VVBYZZ\2`[``bbubbc*dZd~d$eRe*ffgwh]iiXjk[nphsVu9vx|xxySz{z|7}O}'~~y!ˑ8Fhn ]~Җ^d}3[ښ5v~ƝV͞yAvN})j>ߩ.a5.]7 O8XȰ4cM|ܳK۴[mBb7WtLt-Mj+Sӿ+Z/B *w^~i/ h$+=6^l TO Z   @ VPR}' '!D"".066l:0;??DEIJ3PQ*TDUXY\_`EbUccdse n:prtuxNxx{p}}kt$L|F|x.@k 6B)0=eD-u9ELjj'@9oPZ   @ VPR}' '!D"".067n:1;??DEIJ5P Q,TEUXY\``EbUccdse n?rDEIJ$PPT3UUaVvXYUZ\_o`4bFccddem prtuw>xx{a}~cQqޖ=5vmi\'˲V5f6 ;##0$k$$s%%j&&&'9'h''#(|(()_*f***o+v++++'(*(n(u(((((((()<)L)S)Z)a))))))):*A*H*O*m*******C+J+Q+a+h+}++++++ݦ&~߳l~dvewGY1;;?@{EKFJzKPQ#UU~YMZnpqssuuvL^9KP..0g00$111K223336556g66:777T889;Y;; <_<<=j??)@@GDDDHYIIYJKKLNOQ}RR0TkUZqZ[ikj{klmnov=g=TU w]wwxbxx.0f00#111J223~335556f669777S889;X;;<^<<=i??(@@FDDDHXIIXJKKLM.OPRR/TTZpZZijjzklmnov wf==TjU\wwxaxxy./W001x111222e33-555W66*777K889:N;;;V<<=?@z@DDNIIM&OPRR'TT\Zbjrklmnov]==TVU.0\00 1}116223j332555\66/777P889:S;;<[<< =?"@@DDSIIM+OPRR,TTaZgjwklmnowb==T[URR]2c?Wf5,Ov'b- w    QuCo9C!_""/1z6G7:;~?P@KEFJQKPQTUOYZ\;``xbc/d1e/fdnpuscuBv xxy|,~ s$i:[~ .C`rGg|cr* [b^ & &b &  u     tLMNOPQ r  &&&&  &  & &    & &  &   &   &   &  Т%% 4Kmuն+uC!}v&<T"`QH )  qL!f"^*ZA^L`8ab?dCefkxDzz{(}@}~ –NiĚuכfΟf>mZ̩Qݪ%M$Ϯ9~ $S=l8Ҷx6vJ/bM"ƾ2! ۑ0GZ͸QT@% ͑"9MD]`dkr#+:KO`ivz    $ + / 6 = D K _ f o v z   " ) 1 8 D U Y j x     % ) - E ^ r v z ~   3 H P X a i y    ! ) 1 9 > C Q n  6;@E`hpx&+3;@Hhp#(-27<DINSX]bgl (:V[chp $9>FKYo +05INSchp  0GR`ejo}&.6>FX`hp!&+05:OTns{  %-5JRZv~  $(,38=BGLQV[chmuz&*.26:>BFJQV[`ejy,19>CKdw| $,16>CK[jot|  %-AFNS[`emrw (08=V[ck "*/4<BHNTZ`flrx~ !(/6=DKRY`gnu|     $ + 2 9 @ G N U \ c j q x  ! !!! !'!.!5!?n8   ohgl1 ]_'8    ohgl1 zm ߊٷohgl1/pke1   ohgl1јВ60   ohgl1 \n0   ohgl1ͪ:ʢohgl1Oycohgl1mTvohgl19AC<ohgl1?Kohgl1rohgl1)X\ohgl1ġxlXv>qohgl1.GLohgl1ո"+Iohgl1>c$5ohgl1@?$nohgl1&bohgl1Oɬ&.ohgl1n*oQohgl1)+eohgl1>?@M,`Zohgl1\+3s-`|ohgl1/\/ȼohgl1L+&/ohgl11nohgl12|3'ohgl1Ta3.ohgl1F$<4 ohgl15~ ohgl1f5,PP[ohgl18_.7H)ohgl18MX7_ohgl1S@{9l{&ohgl1Vm9<dohgl1Jh9`ohgl1" N::ohgl149(oohgl16:9 ohgl10".;H;ohgl1w928lmohgl1 E)AȎohgl1|].6ܱ%ohgl1][CXohgl1I0D,"$ohgl1vE-3ohgl1 qF8zohgl1XCpX<ohgl1/C H8aohgl1`=DIcohgl1H)ohgl1 UEAsohgl1ԘL`ohgl1t\3 ohgl1fO@ohgl1}\P{ohgl1]R}gohgl1EiS`"ohgl19T/ohgl1UvYSoOFohgl1PR Nohgl162WEohgl1WL_ohgl1&YCohgl1[Z$:Rtohgl1:WXdohgl1 {W3ohgl1-]Ywohgl1CYp^ohgl1%#_;Rohgl1P`ptohgl1<5aT]ohgl1Yb@7ohgl1H1b Johgl1J-d.ohgl1c!|ohgl1`K bHohgl1&(e\@ohgl1_h0@Lohgl1,i9ohgl1_bi~!ohgl1dy1qn~uohgl1۶oOohgl1o̳ ohgl1濾q6ohgl10~q0"ohgl1#ulYohgl1#-P v\gohgl1Kwohgl1Vx)Ndohgl1j@yohgl1Ejzohgl1Wkou|!rgohgl1}N~T&ohgl1>qԁdp1ohgl1nbIUohgl1Xo"4ohgl1Œbohgl1;󇠡uohgl1 cbohgl1brɉvohgl1L6ohgl1!4"ohgl1W,,xHeohgl1TiЍPohgl1dMh1}ohgl1&!r =ohgl1}|<ohgl1wvFohgl1q/Hohgl1r ,ohgl1x johgl1,[Kfohgl1,3Hqnohgl1"Eohgl1Ik!<,ohgl1𙚰!?ohgl1 yƚ\ohgl1@vHL+Eohgl1 ohgl18ohgl1T۟p#ohgl1l$ΠU~ohgl1 Hohgl1 =2 >ohgl1kPՁlohgl1J#fohgl1\JƦohgl1 $OCohgl1F 8eohgl19 /ohgl1c2WU3ohgl1,{6ohgl1C;lohgl1 Xgohgl1$`0 #ohgl1 ͦt5 ohgl1T>)Q%ohgl1Jw?W̜Wohgl1u8*`ohgl1ei ~ohgl1dohgl1CϤohgl1Fཨ*ohgl16k,4gohgl1qν̛ohgl16LtNohgl1f]ohgl18$}@ohgl1CCnohgl1ƽohgl1)N ohgl1DLohgl1v:ohgl1  ^ohgl1ly4Cohgl1lFǴq>+ohgl1FO4Oohgl10Ԩ&Dohgl1 5kohgl1ohgl1{4 1@K,ohgl1TFohgl14P\hohgl14Z1gohgl1Ԝ{ohgl14vxeԐjohgl1YO uAohgl1UװM>ohgl1@װ:ohgl1 @ohgl1\׸fohgl1j.Iwohgl1{i1$GՎohgl1a9>Th!ohgl1KCАL>ohgl1rR EPohgl1$=ohgl1x{:Tpohgl1,U'nHohgl1x[L@>ohgl1Ip49ohgl1nE|Umohgl1Pw-Grohgl1~g@ohgl1szohgl1ÁJcohgl1/d͛eohgl1 ohgl1Ə$zohgl14&ohgl10Vohgl1751ohgl1 KTG5ohgl1鿯ypm ohgl1'b|ohgl1Hbx1Hpohgl15 xohgl1\LP4ohgl1z ohgl1ESohgl1! /ohgl1,N5t/ohgl14 7ohgl1%Ќ'ohgl1 ohgl1Eݬ0Uohgl1M eohgl1cohgl1 Iohgl1nh 9ohgl1 8:1@ohgl13Q] Iohgl16~\!Oohgl1s=maohgl15waxohgl1E=6pohgl1›iohgl1/}4Vohgl1ރBձfohgl1p =&ohgl1b  ohgl1N.#o.ohgl1ArQ8ohgl1%5Uohgl18mohgl1þ! ohgl1ƙ.U$Qohgl1>$%5:ohgl1>2'ϝohgl18msz(Qohgl1C)A+ohgl1$Z+Ɏ2ohgl1$i;".=PvTohgl1`'.5}nohgl131Cohgl1W2 aohgl10M2e}ohgl1C`49ohgl1: 1ohgl1r6ZSohgl1^7Q7d5ohgl1N84Yohgl1q=94_cohgl1 6U)hDohgl1'/2vPohgl1Z1eohgl1gv=Ms%}ohgl1?">{Rohgl1X9ohgl1 <ohgl1jh#4Iohgl1XBK=ohgl1,)Cxohgl1z[mC)|ohgl1 dDa\ ohgl1D}ohgl1lYHMohgl13Iohgl1EJrohgl1SqK}ohgl1WLtohgl14~Nohgl1'Oaaohgl1 yPsnohgl1nQNohgl1NR%"Hohgl1WTS)Vohgl1 Tnohgl1VR[ohgl1 6i'Rohgl1ύNHXف]Xohgl1;XYohgl1 MZohgl1m.n[Rohgl1*]=ohgl1I`ջ{ohgl1`U[oohgl1/bcohgl1Bjbݚohgl1eohgl1d1g-Hohgl1fHh9w ohgl18+xR[ohgl1|~8y!ohgl1ozz$ohgl1܁{խ-ohgl1#y ohgl15}*&ohgl18Idtwohgl1|Dvn^ohgl1ˎ1~ohgl1 וlAvohgl1`)œohgl1I !4ohgl1|Ωg]4^ohgl1>݉qWohgl1;~D&ohgl1:ϋ6nMohgl1n=)mbohgl1fqohgl1OS1ohgl1 ˏ)mohgl11IW-aohgl1S,/uohgl16SSSYohgl1+TPohgl1fXfpohgl1%=3MVohgl1\:D5ohgl1}$ohgl1Dk>*9ohgl19#!ohgl1BHODQohgl1kr }ohgl1z͈.ohgl1FTԞMOohgl1U+-ohgl1EWohgl1gs=/ohgl19RPohgl1DUQ]Aohgl1u?շohgl1 )ohgl1YJ0bohgl1GZrŹWzohgl1E6Q(ohgl1S9!2ohgl1V2cokohgl14sMM>ohgl1vœohgl1>黅ohgl1qXq-ݠohgl1!?ohgl1aoohgl1()- ohgl1Qdmcdohgl1W_/ohgl1j靽Kohgl1Q})cohgl13 @lohgl1}c ohgl10 (ohgl17prꡰohgl18ͭ1Dohgl1 lQsohgl1L`PE:iohgl1}[Rohgl1`Xa>oohgl1hεtץohgl1٥dohgl1pڝ.7ohgl1ԡ4юyohgl1ۑw'ohgl1ّaohgl1Q|'!ohgl1Ոohgl1j㱡Xohgl1zR}"ohgl11Y8ohgl1Sܡ9\Cohgl1mohgl1U׀Zohgl1P?ohgl1EUohgl1+ohgl1 i>Mohgl1?199eɁohgl1Q = ohgl1󅐡ohgl1x80ohgl15ɔ ohgl1.(ۍQ*ohgl1~*Tlohgl1ܸu(ohgl1u"qohgl1*t}ohgl1z+nohgl1\*ohgl1)!{ohgl15c/Ba|+ohgl1@*ohgl1|G "ohgl1 xD ?ohgl1%Zy$ *ohgl1\9mohgl12<0johgl1teMhhohgl1ϮRlL=ohgl1wH~`ohgl1E}BHtohgl1HWz;Bohgl1 %/f ohgl14$ohgl1L1<v!ohgl1!Q:*hohgl1}c.ohgl1ڼNm<ohgl185 Kohgl1B !~|ohgl1_3"λ]mohgl1xo7"dohgl1% 6ohgl1C'-!&ohgl1`%Bqohgl1!R ohgl1 "rd :Y+ohgl1*Fohgl1췓G-ݑohgl1Ϝ¿/.}*ohgl1ǁ&/Lohgl1o61#ohgl1%}2Ɖohgl1dr3 D;ohgl101v2ohgl146ohgl1X7R+ohgl1ld8k[ohgl1Q;fohgl1qJ;oSohgl1'%>Kjohgl1> Gohgl1؝Dohgl1+]E;ohgl1;G~,ohgl1FGiohgl1tI0 ohgl1Ĭ+8HFohgl1e>xHrtohgl1C\ohgl1{v(ohgl1!n$E]ohgl1,5Hohgl1/ÎbZohgl1Nrohgl16;wohgl1 ohgl1΁kohgl1;ohgl1 azohgl1˘~ohgl1Q0ohgl1B# ohgl1֓/rohgl1:~Ĝ[ohgl150Nohgl1f8ohgl1bnP_ohgl1%rohgl1@!"ohgl1;ö'ohgl1ңF ohgl1sV椚D2ohgl1΢=ohgl12MXohgl1p%ohgl1!ƴohgl1^Yjhohgl1^,,ohgl1pV(ohgl1J8Wcohgl1v hqgohgl1փ+<Ϩohgl1#&ohgl1NMb)Dohgl1jY1ohgl1`F.ohgl1Lm۳$ohgl1Wh:}ohgl1=2 ~;ohgl1Ox|ohgl1벶ƛohgl12E54]ohgl1m䐺:;ohgl1ᶻGxohgl1ɬTohgl1^8˜ohgl1$6HPohgl1? GŠ3ohgl1-Qqohgl11=*ӧ-ohgl12_ohgl1 Ŋ]ohgl1s|;ohgl16 jM`ohgl1?:Ɲ&ohgl1ƮN{ohgl1N yohgl1LFohgl1 (-ohgl1?hWΤohgl1.ohgl1/њJcohgl1Qܴ ohgl15^r-ohgl1*ג)ohgl1usE ohgl1ޣN9ohgl1.)Y~Xohgl1cB ohgl1z0Nohgl1xw*- ohgl1dohgl1+p~ohgl1jYohgl1WFjrkohgl1css?ohgl1X} 8ohgl1O7gohgl1ɿzuohgl1fL]ohgl1ȵ/?%ohgl1,&VEohgl1nohgl1r/ohgl1t뺍 ohgl1L7Xohgl1<Uohgl1@N+ohgl1MzNׂohgl1} _ohgl1wL¦uohgl12.Ɇohgl19Xohgl1J%]pohgl1ߛaohgl1ohgl1,#%ohgl1[sBˋohgl1'%.W+ohgl1@cHohgl1rohgl1[ ohgl1"Vc ohgl1{Hohgl1lPjohgl1=hkYIohgl1uvcohgl1BZߊ-ohgl1B+ ohgl1pW_ohgl1_1 ohgl1b[W#ohgl1:''o0ohgl1?oF$δohgl1Tzg%[ohgl1on&7Kohgl1[lJ%=؇ohgl1:t'Wohgl10 O)w/8ohgl1d*cN4ohgl1=LO+3IRohgl1$K'[ohgl1Av-Nohgl1xH,ohgl1k,cohgl1G0ohgl1.[0`ohgl1&2ohgl1`%5ohgl1T8/'ohgl1MBl5[$ohgl1!6Ƕyohgl147Kohgl18 /Wohgl1673hohgl1e:Aohgl1E/:ڐohgl1;%sohgl1d>]ohgl1@Gpohgl1x}\Aohgl1?ʙCTTohgl1M@GOohgl1KkHkHmXohgl1cI;Wohgl1Jyohgl1QqK4ohgl1 J8@ohgl1bMi)ohgl15NW3ohgl1dgO.ohgl1xQ#İ^ohgl1!WAohgl1M%Y(uaohgl1Yz:vohgl19Z 1ohgl1?ZTohgl1Eh]ʧohgl1L5]^@ohgl1x^iohgl1p_Rohgl1Pm5/apohgl1%`gGohgl1G\wzohgl1d{8ohgl1;e_\%qohgl1-7 e ohgl1qnZohgl1uh,ohgl1i#Gohgl1+jC6ohgl1 jJpohgl1PnjCMohgl1jm}Johgl1NGyhohgl1Mo,ohgl1Ep,ohgl1dpg<1ohgl1GEpݴohgl1P";mwohgl1ڄj7ohgl1>uohgl14nvnʲohgl1hKwohgl1i^x[6`ohgl1 yohgl1ey/ohgl1Q7 {cohgl1FrPohgl1Ʒ}sSohgl1-~- ohgl1APy 8oohgl1xЈP{1ohgl1,!Oٰohgl1߉ܟohgl1Гc}{vw ohgl1gaBw{űohgl1tpgS"ohgl1o(sx}ohgl1ohgl1*݈?!ohgl1|Y ohgl1\hya?طohgl1kw3PuZohgl1g79ohgl1}uw@ohgl1._ohgl1S~?Qohgl1eIohgl1Ac]ohgl1/-%ohgl1\-ohgl1Aohgl1/͚#4ohgl1 i3'ohgl138ohgl13wX!ohgl1 _Y&(ohgl1[g'Gohgl1A_ohgl1w7`ohgl1: 7*1ohgl1]<47Aohgl13룓ohgl1 21+ohgl1˦;ohgl1zޒW(ohgl17¤ohgl1²ohgl1hJohgl1`RDc ohgl1}O8Qohgl1;N.ohgl1ި%ohgl1 f>+Bohgl1b޾ohgl1=4 Hohgl1Bk`oohgl1jw/ohgl1wW7ohgl1ʯu/=ohgl1X 5qohgl1b ohgl1B(|}Lohgl1p_ohgl1YKohgl14Ƿ ohgl1\:#pohgl1gkHohgl1Zmkohgl1|w#ohgl1bvEohgl1)$|ˏohgl18ohgl1RO;bohgl1!JJ&ohgl1~e+ohgl1O\݃/ohgl1n)=Kohgl1*eohgl1\-ohgl1&1!ohgl1UKQg#ohgl1s-+_`ohgl1iRKB%ohgl13KAohgl1!Rׇohgl19 u+c:ohgl1B3Kohgl10B>+thohgl1)ohgl17/ohgl1EUohgl1qIohgl1duohgl1ވ Vohgl1e C?3ohgl1 Uohgl1d\+Xohgl1Scvohgl1v OoWuohgl1qohgl1`>:iohgl1m]{' Dohgl1$[&p}K ZiJC~NqmRu e1muP`j1DOJSdp N(QnM2QT7U6@,=,0z`dD=w' o/j)2`, ):.UTw$ Qu:yjSO.W'o9Ky:ZL e(Hf]#eR\7X`Gdb*@ S'2R*FxSM(f0O{R3r.>!c@O@/"RGPqX?\pzX3;j|&"7*Y_9MxqyyPQ68r(m) :lPd2V$ $D0n4+X7Wvl N^SF;>@ v^}2]/4;meR`$Nb>PwC? aT07'Sr-h.mx}=7cZLe26ssv= |`)[gDX/c;R`@+78a6 )(8Z\`>~'P+) jd+(@R~F71t^M MQPcPJ-v2k;`^B,G@.5uE;X}dGPIyZ8z`>RzO ]4&$KfD N6d>.K\G)^#HV&i|"?s-Ev%XPDtxCS5oy-I5]xdku2#Sft_a8f6;qo9[R+}OFt4~FV"E-'_VJ=]9u'[U_u~C,Z4{T+3gE"WAVn`M U(_(S~[&N=I 1ENq}BPI?C5c3:u"^bZy*HAnC.0E+{PSfvN?!lU1Ft s}jhE h F}ukg{llgYvCA_ccyyo HY.Pk'6||\}XY:r{eX8d=hy#A%%?|Z;uev tzPe7=ln;X)>M\[:Kv(Ls zxz|0mNDBuJ_J78>/%q8$6|jZCS0g,qk_e1% ~%pt30d hfGLTluL:8Dkp}K ZiJC~Nq^/home/dwhitfield/.cargo/registry/src/index.crates.io-6f17d22bba15001f/base64-0.21.7/src/lib.rs %x\iRML G MCL2(HLQ&PP(TK-85MK LEON ZNQH-8B5FD OI6OM&K-8B-111ONH?-8I4678NMO4-8K[DP;-81Id_;/#KM3QKP7ccccIccccc:4/KM+6Jb1,<7 <"+2_?S R#0=43 dS!3T7'47 Z.&1?8 ETb/home/dwhitfield/.cargo/registry/src/index.crates.io-6f17d22bba15001f/base64-0.21.7/src/display.rs =W=ŜXeM)8D,%].,3;M: ?I7;#JS`-S 0E2 H  I  0,>"4T= p1U"XUOM)c/home/dwhitfield/.cargo/registry/src/index.crates.io-6f17d22bba15001f/base64-0.21.7/src/read/mod.rs JKZģ#]B & I3~;'u޿,Zv/home/dwhitfield/.cargo/registry/src/index.crates.io-6f17d22bba15001f/base64-0.21.7/src/write/encoder_string_writer.rs he@璫IMt0# db%#)W% ')H),E%%)*b@@DUC\ `I'?9d(BR; ,H1&O7'.'VZ2A;dN&, a )*.0$'*2CH6A@>8  *.0$'*2CH+ "R)E>8  K.>Od/home/dwhitfield/.cargo/registry/src/index.crates.io-6f17d22bba15001f/base64-0.21.7/src/write/mod.rs CS9lq C ? ^Y1}/Phx/home/dwhitfield/.cargo/registry/src/index.crates.io-6f17d22bba15001f/base64-0.21.7/src/engine/general_purpose/decode.rs S`VEj aD"$`] '/-M9!K$O!4(6@Z 1."Y.cdX &&%+7Mc`a7c;X]6,RO4 b]"daa"_0"a1,4__c3Xb'!",'%",(&"-(&"-0J@ ;Cc2J!" c30' ZVZ]F##K (+@F3)$d.R\Kb -$2!Q+2!-) $2!-) $2!-) $2!-) $2!-) $2!-) $2!-) $ _ $!!2  .7 2 4-6[N '-6SN "= 'I=Q  '$3&V3I\"(62|DI~\e/home/dwhitfield/.cargo/registry/src/index.crates.io-6f17d22bba15001f/base64-0.21.7/src/engine/mod.rs 0%PUd@J% 50%%"  A`Tlb=_S=75 ,0)W9b?-BTIW\_eWW9>r;`DdX@]e:)/.,'GNE6W@);> `J1R: $DgN6W)P!G! )QM I90? 0A0e)0;<$"H,Z9%S %+ #- `H1C?P 0+N.6!5*.8% )QT TG'F, $7d@N6T /'&L&$&,& )##e 4T.(2K2R'GB ,9b&hHe+%+ - T@C@'* ,9:hHjP/&e "!M* ,BLTSOWXK&c(b'b)_c-6BH-]Yc4 '#>.T(+ )(B7FϏc/home/dwhitfield/.cargo/registry/src/index.crates.io-6f17d22bba15001f/base64-0.21.7/src/alphabet.rs VH5tqpFO#!KEE*6/$ @b= I1c'-4+:104&2 O?K)*;  *)WF8KM&HPk&)4.*"9,N& /;#5+%<B )!@+?SQSM #,HH=HHH=HN`:H;HAF?H+[;2a/home/dwhitfield/.cargo/registry/src/index.crates.io-6f17d22bba15001f/base64-0.21.7/src/encode.rs 1R(MBa$j4{%#%.%O=%4V=%R?!D%8,= C7'+(c ?-Y7";C>I *$?<[_LM/\$ T" 1*6b; $OQ1T9GD*7'))?N #* EE0e )666666677788888 'EEEEEEEFFFGGGGG !9 K((8:&65<,.>$+@%_"82KM;/")2"92/6:C,  J(+:&5<"1>$+@).J2bL"I2/=J,  -$%5<>$'226Y'(2MYS5H  1$%5<>$'26b.(2^OQ5G  )%<*+'(2OYS5H )F-< # -;, U>%# ='k{ۯ7pa/home/dwhitfield/.cargo/registry/src/index.crates.io-6f17d22bba15001f/base64-0.21.7/src/decode.rs N8L3^3k*t[H%#*'\d,WdcVe=cN"];$;e]6MB #%7'!/a)?EN #)@9; .&);=%JI.=%1$,%A5%5 C7''d+c5&,,,,1,; 4  ;60 C(.25%65<"),>$+2A^@*%(7:-E.H;*;/85  AV3  KV=  >X)3B)C1&  -"287E7E7EA A;(.)75<" %>$+2A^c,07-'Z?EMC= bw&gu>g/home/dwhitfield/.cargo/registry/src/index.crates.io-6f17d22bba15001f/base64-0.21.7/src/read/decoder.rs ~_Ymw}cte49)G$%U)b78%+!/&7$5 =(_RbdT.&21#J;(3-;;5A;;J3'5"" PVDK-(>%5)W )&>PL* >4C7% 1E65 edC>U"]($5F V%*7N##'I&F!>230=SDcbIKV[),C-,Z40X@!04283; tPŏNqh/home/dwhitfield/.cargo/registry/src/index.crates.io-6f17d22bba15001f/base64-0.21.7/src/write/encoder.rs :YWώC{ S )9/W(_`]aa2)`]+%DA*(, `% `-W(a^`S8aa"d^.J%u!^ eK;k+ % ^CV*80* 7W*<"6/=/>Vb(_d)^9dbWG7A**8E3:";G/d#2DL48dd!,RL$)  KJ1: S28/%M 3"a1@9 ,#h9 TZYXW\YWZ+D=c d*4D73: cccccccc>cccccccc:9 3*#.N+FNQ0\0\^ [']2'`['\ X/(/ 4- (RD.,'; HDSE1U!GAF 3H0-%?;4"&,aLa_!B"/F Od>cKdD% b]]lQTN/ [ad_#Z^NS' (2''_Tb^_Tb^Yc CKE ?UyJC?!N513Wb/home/dwhitfield/.cargo/registry/src/index.crates.io-6f17d22bba15001f/base64-0.21.7/src/prelude.rs i0$ĠNSJ0jD-8@QESEV9 tQKgCja6k*<x86_64-unknown-linux-gnuLB|p(base64-ab5978f82f0243f6ohgl1 ?f