Files
archy/core/target/debug/deps/libserde_json-7a610f3facf1b7ad.rmeta
T

3437 lines
923 KiB
Plaintext
Raw Normal View History

2026-01-24 22:59:20 +00:00
rust
Ij#rustc 1.93.0 (254b59607 2026-01-19)Á³VOÐêùÿ²?ÑL¼§Ì±-a7a40eb546f9e2b0Áá\ƒ¦è3$|]åŒ[IÚ tæ-14b12edc9f8cd90bÁë&Gf·Ã ¬ëñq:¤»b-bb76018b1173caf6Áõ…·fÊ ¦%g--c48c539199cbc88bÁà 9m Ù„«ÐÒþá•cB;-030c5b0bba47cc8fÁrustc_std_workspace_coreÁÛ¹þÓ7>H%¸ÚÉ­-4b81d37a5530864dÁüÃùs<Uß7VyóHr#QÏ-c66cc7807550ce25Á miniz_oxideÁõFÖˆÚ™ª‹"ÞXzLVª-62cbc7af83058505Áadler2Á—wÉD‘嵯|6¨%Œ
+-2f171dd2394b4b62Á hashbrownÁ,ïcV¼¨ø¢:Ê\'È߈-9571ba9e0f6c7a90Árustc_std_workspace_allocÁ%¥Èxµù·¼5Ä3Bœ-aac566ad65903fa4Á
std_detectÁMmáýZ^9õ Îà§e˜÷e-2edb296e590136d8Árustc_demangleÁ@¼§VÉNb˜æ¨fHÌ+V3-53b132e4a2fa6e26Ácfg_ifÁfÝv.Å"ÒÜuPp¹ˆ¶-f76b385d7d4d7f3eÁ addr2lineÁÕú-WiúQVÓ¬
µT§5-fe25100bd73e48e4ÁgimliÁ¹xLáÇí÷‘o±Ñ8£Å-265ba9e6e4f70b3fÁobjectÁÔ³ÝzÓÿ¶ò°öM›¼òü`-9ae0d1f8ea52a318ÁmemchrÁRÎ÷׎™te~QÓ¿ØC\Ò-0bff3c8e8f4e489eÁ  –©HtGNÏ·ˆ!á-d69228d077d46f36Á
serde_coreÁep@Ú»î¿îYªñ[-e5150d61a69beeacÁzmijÁ|¸.#g»AÁàn h%E-2958e57d3abb7cfbÁitoaÁkæ4ïMŠ€0×ú à˜-470c3536ec7ad19bÁì3당¡ÚR$ŽýŠT`¤-ae9d1e764ef9df69Á'lexicalÁ<<ifloat_roundtripÁŒsÜi'£ $¿<— Œ¡Ü—'NumberDeserializerÁ”½<ˆarbitrary_precisionÁ¬’üˆ'if_checking_recursion_limitÁÜÊå<Ÿåunbounded_depthÁŒ©åÜŸåâ­Œpreserve_orderÁ„éÔßâmemÁµë
„˜ÔŽâIndexMapÁDáë
„ÀÔ¶âMapImplÁ<¹<—ë
„¡Ô—âVacantEntryImplÁ|<î”ë
„ø”Ôî”âOccupiedEntryImplÁŒð–<Ζë
„Ø–ÔΖâIterImplÁDÆ÷<¤÷ë
„®÷Ô¤÷â IterMutImplÁ\£ý<ýë
„‹ýÔýâ IntoIterImplÁdè‚<Æ‚ë
„ЂÔÆ‚âKeysImplÁD¤†<‚†ë
„Œ†Ô‚†â
ValuesImplÁTå‰<Éë
„͉ÔÉâ
ValuesMutImplÁl·<•ë
„ŸÔ•âIntoValuesImplÁtŠ‘ë
„òÔè<“ raw_valueÁ\¬“invalid_numberÁt®§<‰§ì ¬“§ü‰§invalid_raw_valueÁŒ ¨<…¨®\¨¬…¨NumberStrEmitterÁ„”õ<ëôì ¬õôüëôRawValueStrEmitterÁ”ë—<Ì—®\Ö—¬Ì—serÁón<Ün,æn|ÜnŒÛn to_raw_valueÁd¸®¬ÖRawValueÁDÆ'®%#®¬³ÎNumberFromStringÁ„Õ< ì ¬ªü  NumberValueEmitterÁ”ë˜<˜ì ¬Ì˜ü˜ Æt«™<†™ì ¬ü†™ RawValueEmitterÁ|‘º<ò¹®\ü¹¬ò¹ øŒÄº<©º®\³º¬©ºö
impÁÁ<, |Œ•û<Úo<¸o ŒÂoܸo ErrorCodeÁLp<<ì ¬Fü<œ<ì ¬‹üì ¬ÏüÅ ì IntoDeserializerÁ„æ<´ì ¬¾ü´ MapAccessÁLø)ì '%'TOKENÁ,™ì ¬ðüæÍ ì ¬ôüê NumberKeyÁL‰r<àqì ¬êqüàq¦„Ìy<Ÿyì ¬©yüŸyÆtç€<€ì ¬Ì€ü€Ê ”¬¡<ø ì ¬‚¡üø NumberFieldDeserializerÁ¼è¦<¿¦ì ¬É¦ü¿¦æBorrowedRawDeserializerÁ¼—  ® ¬ï æOwnedRawDeserializerÁ¤ô  ® ¬º æ <” ® ¬” æVisitorÁ<†  ® ¬ß @œp<€p®\Šp¬€p³áserdeÁ __privateÁ 
  
triÁmacrosÁ!jsonÁ!
json_internalÁ!json_internal_vecÁ!json_unexpectedÁ!json_expect_expr_commaÁdeÁ'''''''''' '
' ' '
'''''''''''' DeserializerÁAAreadÁAscratchÁAremaining_depthÁ'F'deÁFF 'JJ from_readerÁ'M'aÁM
from_sliceÁ'PˆP÷'overflowÁ' ParserNumberÁTF64ÁU
UìTU64ÁX
XìTI64Á[
[ì'^visitÁ_Ï_^ invalid_typeÁ'cÏccÏcŠ gcpeekÁc peek_or_nullÁceat_charÁc next_charÁcnext_char_or_nullÁcerrorÁc
peek_errorÁcparse_whitespaceÁcpeek_invalid_typeÁcdeserialize_numberÁr'anyÁr¬cdo_deserialize_i128Áu¨!u¬cdo_deserialize_u128Áx¨!x¬cscan_integer128Ác fix_positionÁ| c parse_identÁc
parse_integerÁc parse_numberÁc
parse_decimalÁcparse_exponentÁcf64_from_partsÁcparse_long_integerÁcparse_decimal_overflowÁcparse_exponent_overflowÁcparse_any_signed_numberÁcparse_any_numberÁcparse_object_colonÁcend_seqÁcend_mapÁc ignore_valueÁcignore_integerÁcignore_decimalÁcignore_exponentÁ'÷'POW10Á '!'Ž
'check_recursionÁ'˜Ï˜˜˜deserialize_anyÁœ¬˜deserialize_boolÁž¬˜deserialize_charÁ ¬˜deserialize_strÁ¢¬˜deserialize_stringÁ¤¬˜deserialize_bytesÁ¦¬˜deserialize_byte_bufÁ¨¬˜deserialize_optionÁª¬˜deserialize_unitÁ¬¬˜deserialize_unit_structÁ®¬˜deserialize_newtype_structÁ°¬˜deserialize_seqÁ²¬˜deserialize_tupleÁ´¬˜deserialize_tuple_structÁ¬˜deserialize_mapÁ¸¬˜deserialize_structÁº¬˜deserialize_enumÁ¼¬˜deserialize_identifierÁ¾¬˜deserialize_ignored_anyÁÀ¬' SeqAccessÁˆÂÂÂfirstÁ'LjÇÇ ' ËÏˈËËËnext_element_seedÁÐÐhas_next_elementÁÒÏÒˆÒ'øÖˆÖÖÖÛ+'
ÛˆÛÛ ' ßÏ߈ßßß
next_key_seedÁää has_next_keyÁæÏæˆæßnext_value_seedÁê¬'
VariantAccessÁìˆìì' ðˆðð '
ôÏôˆôôôVariantÁô variant_seedÁú¬'üÏüˆüüü unit_variantÁünewtype_variant_seedÁü
tuple_variantÁ¬ü¸¬'UnitVariantAccessÁˆˆˆˆ'ŒˆŒŒ 'ψµ/Ä/¬'˜Ï˜ˆ˜˜˜„0˜˜0ž˜¼0 ¬˜¸¢¬'MapKeyÁ¤ˆ¤¤'deserialize_numeric_keyÁ'©Ï©ˆ©'­Ï­ˆ­­­¥&²¬­Ä&´¬­Š(¬­ó(¸¬­Æ*º¬­Å'¼¬­æ'¾¬'StreamDeserializerÁÀÏÀÀÀÀÐ ÀfailedÁÀoutputÁÀÄ 'ÉÏÉÉÉ É byte_offsetÁÉpeek_end_of_valueÁ'ÐÏÐÐнХ Õ '×Ï××'
from_traitÁÛÏÛÛ'òßß'âˆâ'÷åˆåà èèèèèèèèèè è
è è è
èèèùerrÁèýûèýÈ ýäýclassifyÁýis_ioÁý is_syntaxÁýis_dataÁýis_eofÁý
io_error_kindÁèïè ErrorImplÁˆcodeÁˆÈ ˆäèÊŒMessageÁ
ìŒIoÁ
ìŒEofWhileParsingListÁ
ŒEofWhileParsingObjectÁ
ŒEofWhileParsingStringÁ
ŒEofWhileParsingValueÁ
Œ
ExpectedColonÁ
ŒExpectedListCommaOrEndÁ
ŒExpectedObjectCommaOrEndÁŸ
ŒExpectedSomeIdentÁ¡
ŒExpectedSomeValueÁ£
ŒExpectedDoubleQuoteÁ¥
Œ
InvalidEscapeÁ§
Œ
InvalidNumberÁ©
ŒNumberOutOfRangeÁ«
ŒInvalidUnicodeCodePointÁ­
Œ"ControlCharacterWhileParsingStringÁ¯
ŒKeyMustBeAStringÁ±
ŒExpectedNumericKeyÁ³
ŒFloatKeyMustBeFiniteÁµ
ŒLoneLeadingSurrogateInHexEscapeÁ·
Œ
TrailingCommaÁ¹
ŒTrailingCharactersÁ»
ŒUnexpectedEndOfHexEscapeÁ½
ŒRecursionLimitExceededÁ¿
èÁsyntaxÁÁioÁÁ "ÄèÆÍèÈsourceÁèÊÍèÌÍèÎÍèÐcustomÁÑдÐ
invalid_valueÁè Õÿ@ÖèJsonUnexpectedÁØ
؈Øìè
܈ÜÍè
make_errorÁèparse_line_colÁèstarts_with_digitÁ
ââââââââââ â
â â â
âââMapÁóõ-ó¬ó
âÑ ÷õ-÷¬âú ú
with_capacityÁúclearÁúgetÁþú contains_keyÁ”Dúget_mutÁ”Dú
get_key_valueÁ”DúinsertÁúremoveÁ”Dú remove_entryÁ”DúappendÁúentryÁŒŒú¾ úis_emptyÁú£ ú§ úkeysÁúú
values_mutÁú into_valuesÁúretainÁª@ú sort_keysÁâš>âœÈœËâŸÕâ⢢£â¥”D¥Ø¥öâ©”D©÷â¬Íâ ® serializeÁ¯ÈE¯â
²Ï² deserializeÁ´´³
´¸Ï¸ValueÁ¸ expectingÁ¸
visit_unitÁ¼¸ visit_mapÁ¾¬â ÀòÁâ ÃextendÁÄâdelegate_iteratorÁâ
ÇÏÇÇinto_deserializerÁâËÏËËüIâEntryÁψÏVacantÁÑ
ÑìÏOccupiedÁÔ
Ôìâ VacantEntryÁ׈×vacantÁâ
OccupiedEntryÁÚˆÚoccupiedÁâ÷ ݈⩠߈âáˆákeyÁá or_insertÁáor_insert_withÁåª@á
and_modifyÁçª@âéˆé‚LéíDâíˆí‚Lí‰Dí¹Díinto_mutÁííDíûDí‘Eâöˆö½öIntoIterÁöŠ âÝ ûˆâýˆý½ýÕMýŠ âˆ
ˆâ½ÕMŠ â
âå
ˆâˆâ½ˆâí 
  

SerializerÁ¢¢ª@¢writerÁ¢ formatterÁ§ýO§ ªˆªýOªprettyÁ®ýO®ª@®with_formatterÁ®
into_innerÁ³ˆ³ýO³ª@³Ò³³ SerializeSeqÁ³SerializeTupleÁ³SerializeTupleStructÁ³SerializeTupleVariantÁ³ SerializeMapÁ³SerializeStructÁ³SerializeStructVariantÁ³serialize_boolÁ³ serialize_i8Á³
serialize_i16Á³
serialize_i32Á³
serialize_i64Á³serialize_i128Á³ serialize_u8Á³
serialize_u16Á³
serialize_u32Á³
serialize_u64Á³serialize_u128Á³
serialize_f32Á³
serialize_f64Á³serialize_charÁÍ ³
serialize_strÁ³serialize_bytesÁ³serialize_unitÁ³serialize_unit_structÁ³serialize_unit_variantÁ³serialize_newtype_structÁÔ³serialize_newtype_variantÁÖ³serialize_noneÁ³serialize_someÁÙ³
serialize_seqÁ³serialize_tupleÁ³serialize_tuple_structÁ³serialize_tuple_variantÁ³
serialize_mapÁ³serialize_structÁ³serialize_struct_variantÁ³ collect_strÁâââAdapterÁå'serÁåýOåª@åŽPåœPåà âìYìýOìª@ìÕCompoundÁñˆñýOñª@ñŸCõõøˆøýOøª@øÒøøserialize_elementÁþøÏˆýOª@ÒÕZÏŠˆŠýOŠª@ŠÒŠŠserialize_fieldÁŠÏˆýOª@Òð[ÏœˆœýOœª@œÒœœ
serialize_keyÁ¢œserialize_valueÁ¤œÏ §ˆ§ýO§ª@§Ò§§ð[­§Ï
°ˆ°ýO°ª@°Ò°°ð[°ÏMapKeySerializerÁ¹ˆ¹ýO¹ª@¹key_must_be_a_stringÁfloat_key_must_be_finiteÁ ÀˆÀýOÀª@ÀÒÀÀ¨UÀ‡VÀ¥VÈÀÏQÀãQÀùQÀ•RÀ²RÀÆRÀÝRÀûRÀ‘SÀ¥SÀºSÀÏSÀäSÀúSÀŽTÀ£TÀ¸TÀÍTÀãTÀøTÀUÞ À½UÀÔUÀêUÀÍVãÀöVÀŒWæÀªWÀ¿WÀÖWÀôWÀ“XÀ¨XÀÀXÀàXï
CharEscapeÁñQuoteÁò
ñReverseSolidusÁô
ñSolidusÁö
ñ BackspaceÁø
ñFormFeedÁú
ñLineFeedÁü
ñCarriageReturnÁþ
ñTabÁ
ñ AsciiControlÁ
ìœ
write_nullÁýO
write_boolÁˆýOwrite_i8ÁŠýO write_i16ÁŒýO write_i32ÁŽýO write_i64ÁýO
write_i128ÁýOwrite_u8ÁýO write_u16ÁýO write_u32Á˜ýO write_u64ÁšýO
write_u128ÁœýO write_f32ÁžýO write_f64Á ýOwrite_number_strÁ¢ýO begin_stringÁ¤ýO
end_stringÁ¦ýOwrite_string_fragmentÁ¨ýOwrite_char_escapeÁªýOªª
HEX_DIGITSÁ­ write_byte_arrayÁ¯ýO begin_arrayÁ±ýO end_arrayÁ³ýObegin_array_valueÁµýOend_array_valueÁ·ýO begin_objectÁ¹ýO
end_objectÁ»ýObegin_object_keyÁ½ýOend_object_keyÁ¿ýObegin_object_valueÁÁýOend_object_valueÁÃýOwrite_raw_fragmentÁÅýO 
ÈˆÈ È with_indentÁ̈Ì>ψÏìhÑýOχiÓýOÏ iÕýOÏÁi×ýOÏàiÙýOÏüiÛýOÏ–jÝýOÏÔjßýOÏöjáýOformat_escaped_strÁãýOãª@format_escaped_str_contentsÁæýOæª@BBÁTTÁNNÁFFÁRRÁQUÁBSÁUUÁ__ÁESCAPEÁò  to_writerÁôýOôto_writer_prettyÁ÷ýO÷ñú
to_vec_prettyÁüïþto_string_prettyÁindentÁýO˜ 
  
Í͘WriterFormatterÁˆ'bÁinnerÁ˜ˆ¬qwriteÁflushÁ˜io_errorÁ˜ ˜  parse_indexÁ¦‰D§¦¹D©¬r¦ is_objectÁ¦ as_objectÁ¦
as_object_mutÁ¦is_arrayÁ¦as_arrayÁ¦ as_array_mutÁ¦ is_stringÁ¦¦ is_numberÁ¦ as_numberÁ¦is_i64Á¦is_u64Á¦is_f64Á¦as_i64Á¦as_u64Á¦as_f64Á¦
is_booleanÁ¦as_boolÁ¦is_nullÁ¦as_nullÁ¦Ã ¿ ¿ Á ¦ pointer_mutÁà à Š¦takeÁ¦sort_all_objectsÁÉ>Ë>ÌDEFAULTÁÎÎÎÎÎÎÎÎÎÎ Î
Î Î Î
ÎÎÎÎÎÎÎÎÎÎÎÎÎÎÎÎÎíÏí–Hï©Hï ValueVisitorÁñ
ïóÏóÌHóÙHó
visit_boolÁ÷üHó visit_i64ÁùüHó
visit_i128ÁûüHó visit_u64ÁýüHó
visit_u128ÁÿüHó visit_f64Á üHó visit_strÁƒ üHó visit_stringÁüHó
visit_noneÁüHó
visit_someÁ©HóêH üHó visit_seqÁ ¬ó…I ¬Î÷Î÷Î!Î visit_arrayÁ˜ Ϙ ¬ÎÏ  ¥&ž ¬ Æ*  ¬Œ+¢ ¬Î¤ Ϥ ¤ ¥&§ ¬¤ Š(© ¬¤ Æ*« ¬¤ ó(­ ¬¤ Ä&¯ ¬¤ ä&± ¬¤ „'³ ¬¤ £'µ ¬¤ Å'· ¬¤ æ'¹ ¬¤ ¬(» ¬¤ Ì(½ ¬¤ )¿ ¬¤ ¼)Á ¬¤ Ý)à ¬¤ …*Å ¬¤ ¤*Ç ¬¤ æ*É ¬¤ Œ+Ë ¬ÎEnumDeserializerÁÍ variantÁÍ ˜ÎÐ ÏÐ Ð µ/Ð Ä/Ô ¬Ô Î× Ï× × üIÎÛ ÏÛ Û üIÎVariantDeserializerÁß ˜Îá Ïá á „0á ˜0å á ¼0ç ¬á ¸é ¬ÎSeqDeserializerÁë £ Î í  Î
ï Ïï ï ¨,ò ï  size_hintÁÎMapDeserializerÁõ £ õ ˜Î ø  Î ú Ïú ú à-ý ú ª.ÿ ú é€Îdeserialize_value_ref_numberÁÎvisit_array_refÁƒ
σ
¬Î

Ï

¥&
¬
Æ*
¬
Œ+
¬Î
Ï

¥&
¬
Š(
¬
Æ*
¬
ó(˜
¬
Ä&š
¬
ä&œ
¬
„'ž
¬
£' 
¬
Å'¢
¬
æ'¤
¬
¬(¦
¬
Ì(¨
¬
)ª
¬
¼)¬
¬
Ý)®
¬
…*°
¬
¤*²
¬
æ*´
¬
Œ+
¬ÎEnumRefDeserializerÁ¸
ϸ
¥~¸
˜Î¼
ϼ
¼
µ/¼
Ä/À
¬À
ÎVariantRefDeserializerÁÃ
ÏÃ
˜ÎÆ
ÏÆ
Æ
„0Æ
˜0Ê
Æ
¼0Ì
®
¸Î
¬ÎSeqRefDeserializerÁÐ
ÏÐ
£ ÎÓ
ÏÓ
 ÎÖ
ÏÖ
Ö
¨,Ù
Ö
é€ÎMapRefDeserializerÁÜ
ÏÜ
£ Ü
˜Îà
Ïà
 Îã
Ïã
ã
à-æ
ã
ª.è
ã
é€ÎMapKeyDeserializerÁë
Ïë
‚LÎñ2Îï
Ïï
ï
¥&ò
•
Ä&ô
•
Š(ö
•
ó(ø
•
Æ*ú
¬Î
KeyClassifierÁü
ÎKeyClassÁþ
ŸCÿ
ÿ
ìÎ Ï ÌH –H ©HÎ Ï ÌH ÙH Œy üH ¥y üHÎ ´ üH 
unexpectedÁÎBorrowedCowStrDeserializerÁ Ï ˜Î Ï  Î Ï  ¥&œ ¬ Æ*ž ¬Î  Ï    µ/  Ä/¤ ÎUnitOnlyÁ¦
Ψ Ϩ ¨ „0¨ ˜0¬ ¨ ¼0® ¬¨ ¸° ¬ï² ² ² ² ² ² ² ² ²  from_integerÁ² ¼ ï² ¾ ï² À ï² Â ï² Ä ï² Æ ˆÆ ï² É ï² Ë ï² Í Í ï²  Ð Ð ÍÐ Ð ïÔ ² 
Ö Ö ï²  Ù Ù òÛ ¬r²  Ý õ-Ý ¬Ý òà ¬rà ² 
ã ï² å å ïöè è è è è è è è è IndexÁñ 
index_intoÁò 'vÁñ index_into_mutÁô º‘ñ index_or_insertÁö º‘è ø ¨‘ù º‘ø Ä‘û º‘ø ã‘ý º‘ý è  ¨‘ º‘ Ä‘ƒ º‘ ã‘ º‘è  ¨‘ˆ º‘ đРº‘ 㑌 º‘è Ž Ž ¨‘ º‘Ž Ä‘ º‘Ž ã‘ º‘è privateÁ SealedÁ     è TypeÁ
 ˆ ìè ¡ ˆ¡ Íè ¤ ¬r¤ ؤ ö§ NULLÁè © ¬r© ÷
partial_eqÁ¬ ¬ ¬ eq_i64Á¬ eq_u64Á¬ eq_f32Á¬ eq_f64Á¬ eq_boolÁ¬ eq_strÁ¬ µ Õ¬ · Õ¬ ¹ Õ¬ » Õ¬ ½ Õ¬ ¿ Õ¬ partialeq_numericÁ            
     
Â Â Â Â Â Õ ëGÖ ÈEÖ Â ëOÙ
Â Û ÒÛ Û ÏQÛ ãQÛ ùQÛ •RÛ ²RÛ ÆRÛ ÝRÛ ûRÛ ‘SÛ ¥SÛ ºSÛ ÏSÛ äSÛ úSÛ ŽTÛ £TÛ ¸TÛ ÍTÛ ãTÛ øTÛ UÛ ¨UÛ ½Uô Û ÔUÛ êUÛ ‡VÛ ¥Vù Û ÍVû Û öVÛ ŒWþ Û ªWÛ ¿WÛ ÖWÛ ôWÛ “XÛ ¨XÛ ÀXÛ àX
  SerializeVecÁ
œ •R
ÿ

œ ²RŽ
ŸC


next_keyÁÂ ÝR
ÿ


 
Ò

ÕZ˜

ÏÂ 
Ò

ÕZž

ÏÂ ¡
Ò¡
¡
ð[¤
¡
ÏÂ §
Ò§
§
ð[ª
§
ÏÂ ­
Ò­
­
‰]°
­
¦]²
­
ÏÂ ×^µ
 _ «_ ¹
Ò¹
¹
ÏQ¹
ãQ¹
ùQ¹
•R¹
²R¹
ÆR¹
ÝR¹
‡V¹
¥VÄ
¹
ûR¹
S¹
¥S¹
ºS¹
ÏS¹
äS¹
úS¹
ŽT¹
£T¹
¸T¹
ÍT¹
ãT¹
øT¹
U¹
¨U¹
½U¹
ÔU¹
êU¹
ÍVØ
¹
öV¹
ŒWÛ
¹
ªW¹
¿W¹
ÖW¹
ôW¹
“X¹
¨X¹
ÀX¹
àXä
 æ
Òæ
æ
ð[é
æ
ÏÂ  ì
Òì
ì
ð[ï
ì
Ïto_valueÁò

from_valueÁô
˜@ö
ö
ö
ö
ö
ö
ö
ö
ö
£ LineColIteratorÁ¬r£ È colÁ
start_of_lineÁˆ¬rˆ ˆÈ ˆÖ¢ˆÉ5ެr޽ޥ numberÁ 
  
¦Õ©¢ªžG¬ës¬ùs¬‡t¬•t¬£t¬±t¬from_f64Á¬as_i128Á¬as_u128Á¬ from_i128Á¬ from_u128Á¬as_f32Á¬from_f32ÁºÍ¼Í¾ëG¿ÈEÁÏÁ–HéHÃ
NumberVisitorÁÅ
ÃÇÏÇÌHÇÙHÇxËüHǦxÍüHÍ ÇÀxÐüHÇÙxÒüHÒ ÇóxÕüHÕ ¥&!ÚÏÚ ÝÏÝ
àïimpl_from_unsignedÁimpl_from_signedÁ äà‹œææææææææææ æ
æReadÁòÏò¥ òîòdiscardÁòÆ ò
peek_positionÁòÉ5ò parse_strÁú'sÁò
parse_str_rawÁü‡ªò
ignore_strÁòdecode_hex_escapeÁòshould_early_return_if_failedÁò
set_failedÁæPositionÁÈ äæ ReferenceÁ¬q'cÁBorrowedÁ
ìCopiedÁŒ
Œìæ¬qÊ«šæµ£ chÁæ SliceReadÁˆîöæStrReadÁˆdelegateÁæü“ ‹”梢 æ¥æ§§parse_str_bytesÁ©‡ª©©ª@æ­Ï­­¥ ­î­©­Æ ­Ù©­É5­ö©‡ª­‘ª¸‡ª¸ ­¯ª­Áª­Úª­ÿªæ¿ˆ¿ ¿position_of_indexÁ¿skip_to_escapeÁÃChunkÁÃSTEPÁà ONE_BYTESÁ¿skip_to_escape_slowÁ¿õ­È‡ªÈȪ@È'fÁæÍˆæÏˆÏ¥ ÏîÏ©ÏÆ ÏÙ©ÏÉ5Ïö©×‡ªÏ‘ªÙ‡ªÙ ϯªÏÁªÏÚªÏÿªæàˆà æ ãˆæ
åˆå¥ åîå©åÆ åÙ©åÉ5åö©í‡ªí 呪ð‡ªå¯ªåÁªåÚªåÿªæ öÏöæ ùÏùù¥ ùîù©ùÆ ùÙ©ùÉ5ùö©‡ªù‘ª‡ªù¯ªùÁªùÚªùÿªæFusedÁæ
ˆæˆæ is_escapeÁæ next_or_eofÁÏæ peek_or_eofÁÏæà ÏæšÏš‡ªšš æ parse_escapeÁŸÏŸæparse_unicode_escapeÁ¢Ï¢æpush_wtf8_codepointÁæ
ignore_escapeÁ¦Ï¦ædecode_hex_val_slowÁæbuild_hex_tableÁª ª æHEX0Á­ æHEX1Á¯ ædecode_four_hex_digitsÁ˜deserialize_i8Á²¬˜deserialize_i16Á´¬˜deserialize_i32Á¬˜deserialize_i64Á¸¬˜deserialize_u8Áº¬˜deserialize_u16Á¼¬˜deserialize_u32Á¾¬˜deserialize_u64ÁÀ¬˜deserialize_f32Á¬˜deserialize_f64ÁĬ˜deserialize_i128ÁƬ˜deserialize_u128ÁȬ©!ʬ­©¸Ì¬­Ǹά­æ¸Ð¬­…¹Ò¬­ݺÔ¬­¤¹Ö¬­¹Ø¬­á¹Ú¬­€ºÜ¬­ýºÞ¬­Ÿºà¬­¾ºâ¬­ä&䬭„'欭£'謭¬(ꬭÌ(쬭)¼)ð¬­Ý)ò¬­…*ô¬­¤*ö¬­æ*ø¬­Œ+ú¬èCategoryÁüý9ý
üSyntaxÁÿ
üDataÁ
üEofÁƒ
è è è
ÈèèŠÕ茘èŽÍâIterÁˆ£ âˆÈâˆÍ∽¥ é€âžˆž next_backÁ⡈¡¾ ⤈âIterMutÁ¦ˆ¦£ ⩈©Í⬈¬½¬¥ ¬é€â±ˆ±ÆÀâ´ˆ´¾ â·ˆâÕM¹£ â »Íâ!½½½¥ ½é€â"ÁÆÀâ#þ â$âKeysÁƈƣ â%ɈÉÈâ&̈ÌÍâ'ψϽϥ Ïé€â(ÔˆÔÆÀâ)׈׾ â*ÚˆâValuesÁ܈ܣ â+߈ßÈâ,âˆâÍâ-åˆå½å¥ åé€â.êˆêÆÀâ/íˆí¾ â0ðˆâ ValuesMutÁòˆò£ â1õˆõÍâ2øˆø½ø¥ øé€â3ýˆýÆÀâ4ˆ¾ â5ƒˆâ
IntoValuesÁ£ â6Íâ7½¥ é€â8ÆÀâ9¾ â:StateÁEmptyÁ
FirstÁ
RestÁ
˜œÕCompactFormatterÁž
 È¢Í¤>PrettyFormatterÁ¦ˆ¦current_indentÁ¦ has_valueÁ¦†p«ˆ«È®ˆ®ÍÌH±NullÁ²
±BoolÁ´
´ì±NumberÁ·
·ì±º
ºì±ArrayÁ½
½ì±ObjectÁÀ
ÀìÃÈŘÈÕ Ê¢ËµÄ&ͬ©¸Ï¬ǸѬæ¸Ó¬…¹Õ¬ݺ׬¤¹Ù¬¹Û¬á¹Ý¬€ºß¬ýºá¬Ÿºã¬¾ºå¬ä&ç¬ „'é¬ £'ë¬ Å'í¬ æ'﬊(ñ¬¬(ó¬Ì(õ¬ó(÷¬)ù¬¼)û¬Ý)ý¬…*ÿ¬¤*¬æ*ƒ¬¤ ©¸¬¤ Ǹ¬¤ 測¤ …¹¬¤ ݺ¬¤ ¤¹¬¤ ¹¬¤ Ṭ¤ €º¬¤ ýº¬¤ Ÿº¬¤ ¾º¬
Ä&¬
©¸Ÿ¬
Ǹ¡¬
渣¬
…¹¥¬
ݺ§¬
¤¹©¬
¹«¬
á¹­¬
€º¯¬
ýº±¬
Ÿº³¬
¾ºµ¬
ä&·¬
„'¹¬
£'»¬
Å'½¬
æ'¿¬
Š(Á¬
¬(ì
Ì(Ŭ
ó(Ǭ
)ɬ
¼)ˬ
Ý)ͬ
…*Ϭ
¤*Ѭ
æ*Ó¬
©¸Õ¬
Ǹ׬
æ¸Ù¬
…¹Û¬
ݺݬ
¤¹ß¬
¹á¬
á¹ã¬
€ºå¬
ýºç¬
Ÿºé¬
¾ºë¬ï
©¸í¬ï
Ǹï¬ï
æ¸ñ¬ï
…¹ó¬ï
¤¹õ¬ï
¹÷¬ï
á¹ù¬ï
€ºû¬ï
Ÿºý¬ï
¾ºÿ¬ï
ݺ¬ï
ýºƒ¬ï
ä&¬ï
„'¬ï
£'¬ï
Å'¬ï
æ'¬ï
¬(¬ï
Ì(¬ï
)•
¼)¬ï
Ý)¬ï
…*¬ï
¤*¬ï
æ*¬ï
Œ+Ÿ¬ Ä&¡¬ ©¸£¬ Ǹ¥¬ 渧¬ …¹©¬ ݺ«¬ ¤¹­¬ ¹¯¬ á¹±¬ €º³¬ ýºµ¬ Ÿº·¬ ¾º¹¬ ä&»¬ „'½¬ £'¿¬ Å'Á¬ æ'ì Š(Ŭ ¬(Ǭ Ì(ɬ ó(ˬ )ͬ ¼)Ϭ Ý)Ѭ …*Ó¬ ¤*Õ¬ æ*׬ Œ+Ù¬² Ûï² Ýï² ßï² áï² ãï² åï² çï² éï² ëï² íï¬ ïÕ¬ ñÕ¬ óˆóÕ¬  öˆöÕ¬ 
ùÕ¬  ûÕ¬  ýˆýÕ¬ 
ˆÕ¬ ƒÕ¬ Õ¬ ˆÕ¬ ŠˆŠÕ¬ Õ¬ Õ¬ ˆÕ¬ ˆÕ¬ Õ¬ Õ¬ ˆÕ¬ žˆžÕ¬ ¡Õ¬ £Õ¬ ¥ˆ¥Õ¬ ¨ˆ¨Õ¬ «Õ¬ ­Õ¬  ¯ˆ¯Õ¬ !²ˆ²Õ¬ "µÕ¬ #·Õ¬ $¹ˆ¹Õ¬ %¼ˆ¼Õ¬ &¿Õ¬ 'ÁÕ¬ (ÈÃÕ¬ )ƈÆÕ¬ *ÉÕ¬ +ËÕ¬ ,͈ÍÕ¬ -ЈÐÕ¬ .ÓÕ¬ /ÕÕ¬ 0׈×Õ¬ 1ÚˆÚÕ¬ 2ÝÕ¬ 3ßÕ¬ 4áˆáÕ¬ 5äˆäÕ¬ 6çÕ¬ 7éÕ¬ 8ëˆëÕ¬ 9îˆîÕ÷Éñ óÈ
öÕø˜ú¢ûµÍýPosIntÁþ
þìýNegIntÁ
ìýFloatÁ
ìÈÚ¥&¬Ú©¸¬ÚǸ¬Ú測څ¹¬Úݺ¬Ú¤¹¬Ú¹¬ÚṬڀº¬ÚýºŸ¬ÚŸº¡¬Ú¾º£¬ÚÄ&¥¬Úä&§¬Ú„'©¬Ú£'«¬ÚÅ'­¬Úæ'¯¬ÚŠ(±¬Ú¬(³¬ÚÌ(µ¬Úó(·¬Ú)¹¬Ú¼)»¬ÚÝ)½¬Ú…*¿¬Ú¤*Á¬ÚÆ*Ã¬Úæ*Ŭڌ+Ǭݥ&ɬݩ¸Ë¬ÝǸÍ¬Ýæ¸Ï¬Ý…¹Ñ¬ÝݺӬݤ¹Õ¬Ý¹×¬Ýá¹Ù¬Ý€ºÛ¬ÝýºÝ¬ÝŸºß¬Ý¾ºá¬ÝÄ&ã¬Ýä&å¬Ý„'ç¬Ý£'é¬ÝÅ'ë¬Ýæ'í¬ÝŠ(ï¬Ý¬(ñ¬ÝÌ(ó¬Ýó(õ¬Ý)÷¬Ý¼)ù¬ÝÝ)û¬Ý…*ý¬Ý¤*ÿ¬ÝÆ*¬Ýæ*ƒ¬ÝŒ+¬ïïïïïïïïïïb
f
i
j
k
l
m
n
o
p
q
q
r
u
x
{
{
|
~
~




ƒ




ˆ

Š

Œ

Ž


˜
°
¼
Ð
Ò
ä
æ
ê
Î
Ï
Õ
þ
ÿ



ƒ


Ç
Ç
Ç
É
Ë
Ë
Ë
Í
Í
Í
Ï
Ï
Ï
Ó
Ó
Ô
Ô
Þ
Þ
Þ
à
á
ý
þ
þ













Œ












ž
ž
 
 
£
£
¥
¨
¨
©
«
«
­
­
­
¯
»
»
»
Ä
ã
ç
ë
ï
ð
ñ
ó
Ï
Ð
Ô
Ö
Ù
â
ð
ð
þ
þ






¢
¢
¤
¤
­
­


Æ
È
à
ã
æ
ï


ˆ
ˆ
Š
Š
Œ
Œ
Ž
Ž








˜
˜
š
š
œ
œ
ž
ž
 
 
¢
¢
¢
¤
¤
¦
¦
¨
¨
¨
ª
ª
¯
¯
¯
±
±
³
³
µ
µ
·
·
¹
¹
»
»
½
½
¿
¿
Á
Á
Ã
Ã
Å
Å
Å
Ñ
Ñ
Ó
Ó
Õ
Õ
×
×
Ù
Ù
Û
Û
Ý
Ý
ß
ß
á
á
ã
ã
ã
æ
æ
æ
ô
÷
ú
ü
þ






˜
˜
˜
 
 
¡
¥
§
©
«
¬
­
®
¯
°
±
²
³
´
µ

·
¸
¹
º
»
¼
½
¾
¿
¿
Ã
Ã
Ç
È
Ë
ö
ö
ö
ƒ


ò
ô
ý
ÿ

Ù
Û
æ
è
ê
Š
Š
Š




ž
Ä
Å
Ö
Ø
ò
ô
ö
ù
û
ý

ƒ

ˆ
Š
Œ
Ž




£
£
£
§
«
¯
°
±
²
³
´
´


·
¸
¸
¸
º
º
»
¼
¼
¾
¾
À
À
Ö
ó
ô
ù
û
þ

˜
˜
ž
ž
¤
¤
ª
ª
°
°
²
²
Ä
Ô
Õ
Ø
Û
ä
é
é
ï
ï

Œ


§
§
ª
ª
­
®
¯
°
±
²
´
µ
¸
»
»
»
½
½
½
¿
Ê
Ê
Ê
Ý
å
ô
õ
ö
÷
ø
ù
þ
ÿ



°
±
²
³
´
µ
»
¼
¾
¾
Â
Ã
Ç
Ñ
Ò
Ó
Ô
Õ
Ö
Ü
Ý
ß
ß
ç
è
é
ê
ë
ì
ò
ó
õ
õ
ö
ù
ü
ý
þ
ÿ









š
Ÿ
Ÿ
¢
¢
¥
¦
ˆ







˜
˜
˜
œ

 
£
«
«
«
¯
°
³

¼
¼
¼
¿
À
Â
Ä
Ë
Î
Î
Î
Ò
Ó
Ö
Ù
á
ä
ä
ä
è
é
ì
ï
÷
÷
÷
û
ü
ÿ

ˆ
ˆ
ˆ

Œ
Ž

š


¡
£
£
£
­
°
°
°
Ä
Æ
É
É
Ë
Ë
ð
ð
ò
ò
õ
õ
ø
ø
ú
ú
ü
ü
ÿ
ÿ








Œ
Œ
Ž
Ž






˜
˜
š
š


 
 
¢
¢
¤
¤
§
§
ª
ª
¬
¬
®
®
±
±
´
´


¸
¸
»
»
¾
¾
À
À
Â
Â
Å
Å
È
È
Ê
Ê
Ì
Ì
Ï
Ï
Ò
Ò
Ô
Ô
Ö
Ö
Ù
Ù
Ü
Ü
Þ
Þ
à
à
ã
ã
æ
æ
è
è
ê
ê
í
í
ð
ð
ô
÷
÷
ù
û
û
Š
ñ ò¡ŠÔvññ÷ÉòÔä7å‘ÊûÏå; 8AACœ'D§'Eµ'ÃÕ~zdš=Ïè<²+Å'ÆÛ+'B_’ß!c±ˆ׋Ïð<ÖÖøÙ'ÚÛ+'
§­Ôî«tˆ׋Ï‚=ììÈ.ï':ü”ɼ½7Ôˆ׋ÏŠ=Ï‚=ˆˆè0'f墳^ÿŒˆ׋ÏŠ=ÛÏå;¤¤Ì2§'&£Møqˆ׋ÏÞKÀÀ¿4Ä'ÅÐ 'Æ5'Ç5'ÈÄ 'Z¥‰³W2ÉëÏÖNòŽþüýþý9ÿ־龃ú¾îL=E¢òáîÞî¬âîžîî£îà`îú  ¡Ñ
íÓ¶neò¢Ëfùùú8è¬ e{¶i2å`ŒŽá9ìý9ì”:´:˜Ö:šø:œ™;ž³;Ÿ Ö;¡¢û; £¤™<
¥¦·< §¨×< ©ªñ<
«¬‹=­®¨=¯°Ì=±²û=³´˜>µ·>·¸Ø>¹º„?»¼ž?½¾½?¿Àâ?3Úf‡bv÷†ÏÁ‘å`Á‘å`ˆˆ¬9½9èŠÈ èäèÜ6Æ’‡C
à`Á‘;Á‘«AÁ‘å`ØØÙÇAÛìè °‡TêsˆÄóóŸCö
â–ˆCbIÖçÉHÉHÊHœÜ3ËÚ¢×€Jܱ²³ÍÉ´µÞÉì·¸÷ɹ캻¼ì½¾§Ê¿ìÀÁÁÊÂì=Bùž\.¤§Þø–žø–ø–£ø–»bø–¦˜ø– 8”Dø–µ™à`ø–®Aø–Ø;ø–Ï©<·³ «xä@F2VϪJø–¥—Ò—·Jø–´š ø–ÏÁ‘  Ïø–ÏÁ‘®J ˆø–ÞÍ¿£ â8M=õ)ôŽˆà`–›ÞK–›òJ–›©K–›ÖN–›®J ˆø–à`¦¦ùÀ¨£ â¢`Äñ2êÏUˆÞKšœòJšœ©KšœÖNšœ®Jø–à`¹¹ÕMº£ â«¡!Ã:þgÞKŒòJŒ©KŒÖNŒÞÆÆæÂÈ£ â ·zÅÓ¡g;ˆà`ìÞKìòJì©KìÖNìÞÜÜŠÄÞ£ âj€È!,¤Â ˆà`ÞžÞKÞžòJÞž©KÞžÖNÞžà`òò°Åô£ â1%*#Ã3ÖˆÞKПòJП©KПÖNПà`ÄÆ£ âóÊù4²§nÞK· òJ· ©K· ÖN· ±A ˆ¢¢ëO¥ŽP¦œPL_
ˆ‹4ðÜýOª@‹`åå€YéŽPêœPëà ‚AKC´ªPèYסÝ¡£¶ÇÈǘÚÇéÊÞ\¯¬âÅ¢žÅ¢Å¢çAñõŸCö÷¢¬8sÎ9N­ˆסÝ¡íA¯£óA¯£ùA¯£ÿA¯£ŠB¯£‘B¯£±A¹¹×^½ŸLתêg\dˆסݡޞžŸŠÈ ¨’Ýy~áïà`û¤Äû¤û¤Þ¦¦ÍȨìÈ©‚ɪ†p„õæÖóÿ£ˆà`É¥ÄɥɥÞÒ—£Ò—¬âÒ—žÒ—Ò—»bÒ—à`Ò—å`Ò—ßqœ¶qNÅH½Ï°vˆ¬qÄÒ—Ä 8Ò—Ø;Ò—Ï©<ññò½w × É<_ `ÏÔvÒ—Ôvø–å;ø–Ïå;Ò—Ï‚=Í Í ~Î ¥~ÎÏ ˜Î•)Œ„féÏ Ò—ÏÁ‘  ÏÒ—ÏÁ‘Š=ß ß ¨à ˜Î÷J$î›7ö°Ïè<ë ë ˜€ì £ Îþ&G—›µÏð<õ õ ú€ö £ Î÷ ˜Î+<%!#ÉwÏå;èšÏå;éÏ‚=¸
¸
Á…º
¥~λ
˜Îtý†ÖCõÞÏÏŠ=Ã
Ã
¦†Å
˜ÎòY= ,úuÏÏè<Ð
Ð
¡‡Ò
£ ÎÑú¥ïÏÏð<Ü
Ü
ŽˆÞ
£ Îß
˜ÎP‰¹X,¾áÏÏå;ë
ë
“‰í
LÎ=f5ö_PÏÏà;ü
ü
ý
ªŠ šÅ”àsÞbÏ©<š®Ïå;  ò‹ ˜Î“f.õ÷,_pÏÏ‚=ޮϊ=¦ ¦ §  û˜ }qéZ ÏúÒ—úÒ—úÒ—úÒ—úÒ—úÒ—úÒ—úÒ—úÒ—úÒ—úÒ—úÒ—úÒ—úÒ—¥—úÒ— 8úÒ—º½¾Ü«¿ìÀÁOwnedÁÂìr^!™¿ÆˆúÒ—ߊúÒ—ø–úÒ—ßAßA­âAbufÁ«<ãA¾ «<µ[<™é•E•EEGlobalÁ Ï€ûkW¬ súÒ—ø²ÍúÒ— 8
ªJÒ—ø²ªJÒ—õ-¬úÒ—úÒ—ø°ú°û°Ðü°ý°þ°ìHˈXêE>ø²ñ ñ ñ ¥—ñ  8ϳ   ¥— ƒµå`  ž µ”  ìè  YZ÷ˆ¦˜Ò—¬rÒ—žÒ—žÒ—«±žÒ—ž«±Ò—žÒ—¥—ž¥—Ò—žÒ—žÒ—ž ˆÒ—ž ˆÒ—žÒ—žÒ—ž·ž¤·žÒ—žÒ—ž·ž¤·žÒ—žÒ—ž·ž¤·žÒ—žÒ—ž·ž¤·žÒ—žÒ—ž·ž¤·žÒ—žÒ—ž·ž¤·žÒ—žÒ—ž·ž¤·žÒ—žÒ—ž·ž¤·žÒ—žÒ—ž·ž¤·žÒ—žÒ—ž·ž¤·žÒ—žÒ—ž·ž¤·žÒ—žÒ—ž·ž¤·®AÒ—±AÙ Ù Ú ëO n}6ÏçA

ôšŠ
œ &µ¬ä'óЋíAŒ½óAŒ½ùA

•RŒ
ÿ
 
œ ï\e?¬~ÿAŽ

ŸC


À›£›W¨á!±Aµ
µ

×^ F˜iFãA ]ŠB—¾‘B

ÝR
ÿ
 

 n“U—)&pNÞK§¢£ È Ö¢á¢G[9²öûsdÞߊ¬âߊžߊߊ£ߊ»bߊþýþÿ¦åìÁåƒìÜåìó>ßMž†üáäÀÞäÀžäÀäÀ£äÀ»bäÀå`ߊà`ߊ®AߊØ;ߊÏ©<ÅÅÆæ ¤Ré×~`Ïå;ߊÏå; 8ߊÏúߊTUVÖWìXYëZì[\]ì¹?
›¯ýh~úߊúߊúߊúߊúߊúߊúߊúߊúߊúߊìŠÜ«ìŒù«ŽìZ˳éXHQ„¬qʫ֡µ£ æ˜Ú¬æ<Öw”è…Yòµ£ æ˜Ú¬æ<Öw”è…YÐÏ¡ä¬îæœöæ;âÀ`<ˆò…Lj¡­Ÿ¤­æb HQ„.ˆòÝLj¡ 8׋òªÈÏŠ…ÇŠÝÇñ±ó˜
­¤ó¤ ±


ï
ë
 ÚñÝ
ËÂï ë Ö
Ð
ßÖú õ ã
Ü
ôìˆÐ Í ¼
¸
   ü예á ß Æ
Ã
¨ ¦ ÐÀ¬¦½¹ÏÆåÜøòŽ×À¤·¦Å¹ÚÆð܃òüýüˆýüœóÉÆßÜ ž«¦Ã±óñýüDZõñŠüŸóœÈ±µ ±· ±¹ » 
½ ±¿ ÉHï±ñó
ö
ù±ûý

ı
Š
±

±
ž
¡±£¥
¨
«±­¯
²
µ±·¹
¼
¿±ÁÃ
Æ
ɱËÍ
Ð
Ó±Õ×
Ú
ݱßá
ä
ç±éë
î
öñ¦ýŒü¡óűøñ¨ýŽüÎù¬ó©¦»¹ÌÆâÜõò¢ž®¦±¼ñ Û±Ý±ß±á±ã±å±ç±é±ë±í±¼ ±¾ ±À ± ±Ä ±Æ ±É ±Ë ±Í ±Ð ±Ö ±ã ±å ±àñññññññññññÆŒÊùÌˆÜØ±¡  ºñÈùÐùÕùšó¤žÌ¦É±Ë
¢óʱúñ©ý¥ó¤ ±©ó© ±®óÕ ±¾ñ²óí±Áñ¸óñ ü
ÇÅÀóÙ ±Ý ±ÃóÇóË
× ±Û 
ö
ý
󞱦Á¹ÔÆêÜýò¡´¦Ã¹×ÆíÜò³
À¹Û Ù ¹
µ
ìåøñ

ñ

Šñ¡

ñ§

œñ­
Ž
§ñæ
Ž
°ñì

ǞϦ ü
ø   ÉHŽ 
˜  š ÉH› 
¥Íãö
­Ïåù
ÔvÃå;
è<>ð<=Š=#ÞK #ÖN?þ8áÞ
¬âFž@£ìà`*ú#bå`õÏ1;«AÄ»b!¦˜®AØ;©<ªJ·J ®JòJ©K1±A1`çAíAóAùAÿAŠB‘Bßà;ñ  ì¡òŠ5309Á16Ább'b'Átb't'Ánb'n'Áfb'f'Árb'r'Á"b'"'Á\b'\\'Áub'u'Á256Á\»Û
±ü¤Û#ÍÒ—,³Û( Value::NullÁtrueÁ¼Âl
 ¬Âl 
˜$ü®l, Å,ºl %„ül ‰m ÿ3 Tül ¢ËO ¢ËZÿüãl* Æ,ôl +k¢Ëw¢ËfalseÁfalseÁüÃÀ  ׋ü—ÀM ˆ$¼À &J׋ R::should_early_return_if_failedÁ\êú  0 $ôû
ø°Tþú þú   
 $„û 09 
 !0
\“û  A|§û  T§û  §û 


$­û A9 
!A \Áû  a|Õû TÕû Õû  $Ûû a9 !a
f¨CPF`!91ó
 ‡û  „ùú
ø° ˆû  ¬  °û 
Î ´û 
ë  "
    µû  ¬¢û
ø° ¶û   » Þû Ýâû 
ú "
 ãû ¬Ðû
ø° äû  ü ©üœúå ø°ú°û°Ðü°ý°þ°ìHˈXêE>TÅú ¹ú 
¡¨T[)­¬«Õè½ÕèÏJIHÕèZÕèl¦ LÂü DÎü  Ïü 4àü  éü  üðü´ 
Döü öü  ûü @  ýü ü•ýw ì›ý  D¯ý 
¯ý    
  ¶ý  =
Dœ›ý 
©
Q b ·ý 
o ü•ý#  ÿý  ÿÿ
Ìý 
 
dÔý Õý  
 ßý ,äý  ¬Ôý # 7 èý  
ý  L‰ý % / ü‰ýƒ  ‹þ  Œþ   <–þ  œþ & (
Lüÿü¥ 
ˆ£þ ø
 ¦øˆðü´ 
?E £þ ,©þ  ¯þ  °þ ªüƒü­ ü¾üò üÜüÔ üÇý" T­ü ,œü ÆñòÔkÎÍÃçLÇý ñÛÚ·ªNAÙNV]shiftÁÃtableÁäÚ¬Á{
?256Á256Á256Á256Áƒ
TV#£Ã/6=
TY#£Ã/6=Ÿ
T\#£Ã/6=<Í>
ŒŽ%õ‘1BoxÁ샚íƒlÕ°Ù[¢'õþ²{©?
Œ%õ‘1”‘9@Ìít
ØÙ'ØØÙÇAÛìè °‡Têsb™;›;œ;ÞÉ;ìž;Ÿ;UnsignedÁ ;ì¡;¢;SignedÁ£;ì¤;¥;Üå¦;ì§;¨;CharÁ©;ìª;«;StrÁ¬;ì­;®;BytesÁ¯;ì°;±;UnitÁ²;³;Ó´;µ;
NewtypeStructÁ ¶;·;SeqÁ
¸;¹;ŸC º;»;EnumÁ ¼;½; UnitVariantÁ
¾;¿;NewtypeVariantÁÀ;Á; TupleVariantÁÂ;Ã;
StructVariantÁÄ;Å;OtherÁÆ;ì²Ëª[e]ÀÉPX4«‘
ÏÒ(ÏÑÒÇJÓìÔÕâJÖ왣@•2gèy××ÿJÙšKâ:6[nZ³u¬³Dã‘
ÏÕ(”ý4ÚÚ¨KÜÅKâ%ÃRô¾%ôgndÁÆ
ñƒ&ñ òóßbôõñbö÷Œcøù cúû¶cüýËcþÿàcûcƒ‹dì°};–jàÜãê
±µ%Ò—17>
±¸%Ò—1ߊ9@
±»%Ò—1¥—9@
±¾%Ò—1ßAßA­âAϱ«<ãA¾ «<µ[<™éÒ—þ²w~4á$
±Á%Ò—1ø–9@¾ž
þ
 &þ
ÿ
 ŸC ìÎïÌ+7k2 _¥—gn|Û"
 ž '  ž µ”  ìè  YZ÷c Ò—nu
ýÿ%äÀ18?
ý%äÀ18?
ý%äÀ18?DÚ"
Ö Š-ŠÜ«ìŒù«ŽìZ˳éXHQ„Ö Ö˜4ï"
Ö -öˆ9ˉAH!'èâö
æ³á,©dÖd,÷dò\ìf ßTœg â
÷D¨g å d²gA ¿4”ÀgÀ
,ûgùý4‚hûïL¯h þæo„ºh ñ4Ìh ú¹olÔh üànLÏi ôo„Úi ÷ëOTìi¢Í¡TŸj ô
µ¡D«j ò
ŸCµjó÷É4ºjñÌH,Âj±ª
"µ #ÉŒíN $á|íO %÷´¼P &ü p
# Serde JSONÁËüNK JSON is a ubiquitous open-standard format that uses human-readable text toÁüd85 transmit data objects consisting of key-value pairs.ÁË ```jsonÁ,­ܳ "name": "John Doe",Á”Ï "age": 43,Á¤â "address": {Áü÷*' "street": "10 Downing Street",Áä¢ "city": "London"ÁT¿ },ÁœÊ "phones": [ÁÔÞ "+44 1234567",ÁÌù "+44 2345678"ÁL“, ```Á«Ëü¯LI There are three common ways that you might find yourself needing to workÁÜü with JSON data in Rust.Á˜ËüœOL - **As text data.** An unprocessed string of JSON data that you receive onÁüìIF an HTTP endpoint, read from a file, or prepare to send to a remoteÁ server.ÁüÅKH - **As an untyped or loosely typed representation.** Maybe you want toÁü‘KH check that some JSON data is valid before passing it on, but withoutÁüÝNK knowing the structure of what it contains. Or you want to do very basicÁü¬<9 manipulations like insert a key in a particular spot.ÁüéOL - **As a strongly typed Rust data structure.** When you expect all or mostÁü¹MJ of your data to conform to a particular structure and want to get realÁü‡ EB work done without JSON's loosey-goosey nature tripping you up.ÁÍ ËüÑ IF Serde JSON provides efficient, flexible, safe ways of converting dataÁü›
*' between each of these representations.ÁÆ
ËüÊ
&# # Operating on untyped JSON valuesÁñ
Ëüõ
JG Any valid JSON data can be manipulated in the following recursive enumÁüÀ HE representation. This data structure is [`serde_json::Value`][value].Á Ë< Ú‘ü• $! # use serde_json::{Number, Map};Á ÌÀ  # #[allow(dead_code)]Á„Ú 
enum Value {Á 
Null,Áœù  Bool(bool),Á¼
 Number(Number),Á¼¥
 String(String),ÁÔ½
 Array(Vec<Value>),矯
# Object(Map<String, Value>),Á
Í‘<‚Ú‘ŠËüŽIF A string of JSON data can be parsed into a `serde_json::Value` by theÁüØMJ [`serde_json::from_str`][from_str] function. There is also [`from_slice`]Áü¦NK for parsing from a byte slice `&[u8]` and [`from_reader`] for parsing fromÁüõ/, any `io::Read` like a File or a TCP stream.Á¥ËÚ‘ü±$! use serde_json::{Result, Value};ÁÖËüÚ(% fn untyped_example() -> Result<()> {ÁüƒJG // Some JSON input data as a &str. Maybe this comes from the user.Á´Î let data = r#"Á
üó# "name": "John Doe",ÁÔ— "age": 43,Áܲ "phones": [ÁüÎ" "+44 1234567",Áüñ! "+44 2345678"ÁŒ“„¥
}"#;ÁËüº;8 // Parse the string of data into serde_json::Value.Áüö30 let v: Value = serde_json::from_str(data)?;ÁªËü®EB // Access parts of the data by indexing with square brackets.ÁüôOL println!("Please call {} at the number {}", v["name"], v["phones"][0]);ÁÄË Ok(())Á,×Í‘´œŒã # fn main() {Áüõ%" # untyped_example().unwrap();Á< # }ÁÚ‘«Ëü¯MJ The result of square bracket indexing like `v["name"]` is a borrow of theÁüýOL data at that index, so the type is `&Value`. A JSON map can be indexed withÁüÍLI string keys, while a JSON array can be indexed with integer keys. If theÁüšNK type of the data is not right for the type with which it is being indexed,ÁüéNK or if a map does not contain the key being indexed, or if the index into aÁü¸C@ vector is out of bounds, the returned element is `Value::Null`.ÁüËü€MJ When a `Value` is printed, it is printed as a JSON string. So in the codeÁüÎKH above, the output looks like `Please call "John Doe" at the number "+44ÁüšKH 1234567"`. The quotation marks appear because `v["name"]` is a `&Value`ÁüæIF containing a JSON string and its JSON representation is `"John Doe"`.Áü°OL Printing as a plain string without quotation marks involves converting fromÁü€KH a JSON string to a Rust string with [`as_str()`] or avoiding the use ofÁüÌ2/ `Value` as described in the following section.ÁÿËüƒ&# [`as_str()`]: crate::Value::as_strÁªËü®LI The `Value` representation is sufficient for very basic tasks but can beÁüûIF tedious to work with for anything more significant. Error handling isÁüÅLI verbose to implement correctly, for example imagine trying to detect theÁü’ PM presence of unrecognized fields in the input data. The compiler is powerlessÁüã PM to help you when you make a mistake, for example imagine typoing `v["name"]`Áü´!JG as `v["nmae"]` in one of the dozens of places it is used in your code.Áÿ!Ëüƒ"41 # Parsing JSON as strongly typed data structuresÁ¸"Ëü¼"PM Serde provides a powerful way of mapping JSON data into Rust data structuresÁÔ# largely automatically.Á¨#Ë<¬#Ú‘ü´#(% use serde::{Deserialize, Serialize};ÁÜÝ# use serde_json::Result;Áù#Ëüý#%" #[derive(Serialize, Deserialize)]Áœ£$ struct Person {Á¬·$ name: String,Á„Í$
age: u8,ÁäÞ$ phones: Vec<String>,Á,û$Í‘%Ëü…%&# fn typed_example() -> Result<()> {Áü¬%J‘¢´÷%ã¢lŽ&£üœ&#—£ÔÀ&£ÜÛ&ä£ü÷&"ˆ¤üš'!³¤Œ¼'ܤ„Î'õ¤ß'Ëüã'MJ // Parse the string of data into a Person object. This is exactly theÁü±(NK // same function as the one that produced serde_json::Value above, butÁü€)74 // now we are asking it for a Person as output.Áü¸)41 let p: Person = serde_json::from_str(data)?;Áí)Ëüñ)B? // Do things just like with any other Rust data structure.Áü´*IF println!("Please call {} at the number {}", p.name, p.phones[0]);Áþ*Ët‚+Ô§,‘+Í‘,—+´œŒ+‚¨ü¯+# # typed_example().unwrap();Á<Ó+ɨ<Û+Ú‘ã+Ëüç+PM This is the same `serde_json::from_str` function as before, but this time weÁü¸,HE assign the return value to a variable of type `Person` so Serde willÁü-PM automatically interpret the input data as a `Person` and produce informativeÁüÒ-PM error messages if the layout does not conform to what a `Person` is expectedÁŒ£. to look like.Áµ.Ëü¹.
\Å7 });ÁÑ7ËüÕ7>; println!("first phone number: {}", john["phones"][0]);Á”8Ëü˜874 // Convert to a string of JSON and print it outÁüÐ8)& println!("{}", john.to_string());Á,ú8Í‘<€9Ú‘ˆ9ËüŒ9KH The `Value::to_string()` function converts a `serde_json::Value` into aÁÔØ9 `String` of JSON text.Áó9Ëü÷9PM One neat thing about the `json!` macro is that variables and expressions canÁüÈ:NK be interpolated directly into the JSON value as you are building it. SerdeÁü—;NK will check at compile time that the value you are interpolating is able toÁÜæ; be represented as JSON.Á<Ë<†<Ú‘ÜŽ< # use serde_json::json;Á,ª<´œü°<$! # fn random_phone() -> u16 { 0 }Á,Õ<´œüÛ< let full_name = "John Doe";ÁÜû< let age_last_year = 42;Á—=Ëü›=0- // The type of `john` is `serde_json::Value`Á´Ì= let john = json!({ÁÔã= "name": full_name,Áüþ=! "age": age_last_year + 1,Áœ >Þü´>-* format!("+44 {}", random_phone())ÁLâ>¼‘<ì> });Á<ô>Ú‘ü>Ëü€?LI This is amazingly convenient, but we have the problem we had before withÁüÍ?OL `Value`: the IDE and Rust compiler cannot help us if we get it wrong. SerdeÁü@LI JSON provides a better way of serializing strongly-typed data structuresÁœê@ into JSON text.Áþ@Ëü‚A2/ # Creating JSON by serializing data structuresÁµAËü¹A96 A data structure can be converted to a JSON string byÁüóA74 [`serde_json::to_string`][to_string]. There is alsoÁü«BFC [`serde_json::to_vec`][to_vec] which serializes to a `Vec<u8>` andÁüòBLI [`serde_json::to_writer`][to_writer] which serializes to any `io::Write`Áü¿C# such as a File or a TCP stream.ÁãCË<çCÚ‘üïC(Ú·ܘDЏ´DËü¸D%¹¸¤ÞD struct Address {Á¼óD street: String,Á¬‹E city: String,Á,¡EÍ‘§EËü«E)& fn print_an_address() -> Result<()> {ÁüÕE // Some data structure.ÁüõE let address = Address {Áü•F30 street: "10 Downing Street".to_owned(),ÁüÉF&# city: "London".to_owned(),ÁTðF };ÁûFËüÿF)& // Serialize it to a JSON string.Áü©G1. let j = serde_json::to_string(&address)?;ÁÛGËüßG=: // Print, write to a file, or send to an HTTP server.ÁÔH println!("{}", j);Á¸HËt¼HÔ§,ËHÍ‘,ÑH´œŒ×H‚¨üéH&# # print_an_address().unwrap();Á<Iɨ<˜IÚ‘ IËü¤IMJ Any type that implements Serde's `Serialize` trait can be serialized thisÁüòIMJ way. This includes built-in Rust standard library types like `Vec<T>` andÁüÀJC@ `HashMap<K, V>`, as well as any structs or enums annotated withÁÜ„K `#[derive(Serialize)]`.Á Kˤ¤K # No-std supportÁ¹KËü½KLI As long as there is a memory allocator, it is possible to use serde_jsonÁüŠLLI without the rest of the Rust standard library. Disable the default "std"Áü×L+( feature and enable the "alloc" feature:ÁƒMË\‡M ```tomlÁ”“M [dependencies]Áü¦MTQ serde_json = { version = "1.0", default-features = false, features = ["alloc"] }Á<ûMÚ‘ƒNËü‡NHE For JSON support in Serde without a memory allocator, please see theÁôÐN [`serde-json-core`] crate.ÁïNËüóN  [value]: crate::value::ValueÁü”O# [from_str]: crate::de::from_strÁü¸O'$ [from_slice]: crate::de::from_sliceÁüàO)& [from_reader]: crate::de::from_readerÁüŠP&# [to_string]: crate::ser::to_stringÁü±P  [to_vec]: crate::ser::to_vecÁüÒP&# [to_writer]: crate::ser::to_writerÁÄùP [macro]: crate::jsonÁü’QSP [`serde-json-core`]: https://github.com/rust-embedded-community/serde-json-coreÁ¡êQ íQ ¢R8¹lîQ üQ7"https://docs.rs/serde_json/1.0.149ÁüþQ$
÷2 å 2A ¿42À
2ùý2ûï2 þæo2 ñ2 ú¹o2 üàn2 ôo2 ÷ëO
2¢Í¡ 2 ô
µ¡ 2 ò
ŸC
2ó÷É 2ñÌH2±ª2"µ2#É2$á2%÷2&Ý3à3ã3”œdÚ3„ÉdÏ3üÜd Å3ŒÁe¡´e ·e ¾e8°4¸et²eLÉeœûe«<œTôe!´áfgC4 4ý34ò3õ3è3ë3ììgá3ä3Ö3Ù3ü¢h@Ð3Ó3Å3È3º3½3¯3²3üÂi5©3¬3ž3¡3“3j8Œ33€3ƒ3u3x3e3h3V3Y3„âkïk ók ¹m ùk ‡l, úk8¿ ûk& ük8ï$ýk, l ƒl …l$ „l- †l*‰l Œl ¶m8,l, œl8¿ l Ÿl °m8³$­l'±l8Û
4³l'¹l8ý4»l'Ál8ÒÃl Ål Él8Æl*Ël8Îl$ Ñl8³$ßl'ãl8Û
4ål'ël8ý4íl'ól8õl øl ül88ùl*þl84m8³$ˆm'Œm8Û
4Žm'”m8ý4m'œm8žm ¡m ¥m88¢m$ ¦m% ·mTÉm4ÍmŒ—
ü8 5 Construct a `serde_json::Value` from a JSON literal.Á9 Ë<= Ú‘ÜE «Ó,a ´œ¼g  let value = json!({Á¤  "code": 200,ÁÄ”  "success": true,Á¤­  "payload": {ÁÌ  "features": [ÁÄÜ  "serde",Á´õ  "json"Á ],Áä›  "homepage": nullÁL¸  ÚÖ Ú‘Ò ËüÖP M Variables or expressions can be interpolated into the JSON literal. Any typeÁü§M J interpolated into an array element or object value must implement Serde'sÁüõJ G `Serialize` trait, while any type interpolated into an object key mustÁüÀF C implement `Into<String>`. If the `Serialize` implementation of theÁü‡M J interpolated type decides to fail, or if the interpolated type contains aÁüÕ; 8 map with non-string keys, the `json!` macro will panic.Á Ë<• Ú‘Ü «Ó ´œœ¿  let code = 200;ÁüÓ) & let features = vec!["serde", "json"];Áý ˼ ™ø¬™  "code": code,Áü¯  "success": code == 200,Á¤Ï óøüä$ ! features[0]: features[1]ÁL‰ ¨ú<“ ÚÖ<› Ú‘£ Ëü§? < Trailing commas are allowed inside both arrays and objects.Áç Ë Ú‘Üó «Ó, ´œ¼•  let value = json!([ÁŒ­  "notice",Át¿ "the",ÁœÎ  "trailing",Á¤â  "comma -->",Á  ]);Á<ÿ Ú‘&|‡
8; ©
¿  ú
, û
 ü
, ý
8ª
& 8ƒ  *  Œ ¼ , 8,— 'œ 8µ  «  ¬ , ­  ® ´ , ¯ 8ª  µ % ½ Ô£ ¡     8° t” &|„ 3< ¾ ¼M  ± Ë  ² 8ƒ  ¹ Ê , º  » È , ¼ 8elemsÁ &  8ï $ Ç 
É *Í  Ð ƒ , Ú 8 'à 8Ÿ 'ë 8œí  ð  ñ ý , ò  ó û , ô 8ÿ… $ ú 
ü %   ¯ É  ° 8ƒ  · È , ¸  ¹ Å , º 8ÿ… & À 8ï $ Æ 
Ç *Ë  Î  , Ø 8 'Þ 8Ÿ 'é 8œë  î  ï û , ð  ñ ø , ò 8ÿ… $ ù 
ú %   ¨ Ô  © 8ƒ  ° Á , ±  ² ¿ , ³ 8ÿ…,´ & ¹ 8ï $ ¾ 
À 8É  , È  É Ò , Ê 8restÁ & Ï 8Ð 
Ó *Ö  Ù » , ã 8 'é 8µ  ø  ù µ  ú 8ƒ   ª  ,   ƒ  ,  8ÿ…,… $ Š 
Œ , Ž 8, ' 8µl  £  ¤ © 8É  , ¬  ­ ³ , ® 8íŠ 
´ % ¼  â Ž  ã 8ƒ  ê û , ë  ì ù , í 8ÿ… & ó 8ï $ ø 
ú 8  ,   ƒ Œ ,  8íŠ$… &  8Š 
 *   õ ,  8 '£ 8µ  ²  ³ ï  ´ 8ƒ  » ä  , ¼  ½ Å , ¾ 8ÿ…,¿ $ Ä 
Æ , È 8 'Î 8µ  Ý  Þ ã 8  , æ  ç í , è 8íŠ 
î % ö   Ê  ž 8ƒ  ¥  , ¦  § ´ , ¨ 8ÿ… & ® 8ï $ ³ 
µ 8  , ¾  ¿ È , À 8íŠ & Å 8Æ 
É *Ì  Ï ² , Ù 8 'ß 8µ  î  ï ¬  ð 8ƒ  ÷ ¡  , ø  ù  , ú 8ÿ… $  
 ,  8,… 'Š 8µ    š   8 ,› , £  ¤ ª , ¥ 8íŠ 
« % ³  Û   Ü 8ƒ  ã ô , ä  å ò , æ 8ÿ… & ì 8ï $ ñ 
ó  ö  , ÷  ø  , ù 8ƒ & ÿ 8 
ƒ ,     , ˆ 8íŠ$‰ &  8Ž 
 *    , ¡ 8 '§ 8µ    · û  ¸ 8ƒ  ¿ ð  , À  Á É , Â 8ÿ… $ È 
Ê , Ì 8 'Ò 8µ  á  â ï  ã î , ä  å ì , æ 8ƒ 
í , ò  ó ù , ô 8íŠ 
ú %   § Ü  ¨ 8ƒ  ¯ À , °  ± ¾ , ² 8ÿ… & ¸ 8ï $ ½ 
¿  Â Î , Ã  Ä Ì , Å 8
Æ & É 8Ê 
Í , Ð  Ñ Ú , Ò 8íŠ & × 8Ø 
Û *Þ  á É , ë 8 'ñ 8µ     à   8ƒ   ¸  , Š    , Œ 8ÿ…, $  
 ,  8,— 'œ 8µ  «  ¬ ·  ­  , ®  ¯ ´ , ° 8
± 
µ , º  » Á , ¼ 8íŠ 
 % Ê   ¼   Š 8ƒ,‹   ¢ ,      ,  8ÿ…,• & š 8ï$ $ Ÿ 
¡ , ¤ 8¥  & © 8ï $ ® , °  ± º , ² 8íŠ & · 8¸ 
» *¾  Á ¥ , Ë 8 'Ñ 8µ  à  á Ÿ  â 8ƒ  é  
, ê  ë ó , ì 8ÿ… $ ò 
ô , ö 8 'ü 8µ    Œ  ,  8¥  $  ,     , ˜ 8íŠ$™ 
ž % ¦  ê   ë 8ƒ  ò ƒ , ó  ô  , õ 8ÿ… & û 8ï $  
 ,  8¸ $† & Š 8ï$ *   í , ž 8 '¤ 8µ  ³  ´ ç  µ 8ƒ  ¼ æ  , ½  ¾ Æ , ¿ 8ÿ… $ Å 
Ç , É 8 'Ï 8µ  Þ  ß å , à 8¸  % î  ¡ Ê  ¢ 8ƒ  © º , ª  « · , ¬ 8ÿ…,­ & ² 8ï $ ¸ 
¹ $ ¼ , ¾  ¿ È , À 8íŠ & Å 8Æ 
É *Ì  Ï , Ù 8 'ß 8µ  î  ï Ž  ð 8ƒ  ÷ ƒ , ø  ù , ú 8ÿ… $ 
,  Œ , 8íŠ 
%  Ï …! 
 Ð 8ƒ  × è , Ø  Ù å , Ú 8ÿ… & à 8ï $ æ 
ç , ê 8à‹ & õ 8ö , ù  ú ƒ! , û 8íŠ & €! 8! 
„! *‡!  Š! ¾! , ”! 8,•! 'š! 8á|œ!  «!  ¬! ¸! , ­! 8à‹T®! % ¿!  Æ% å%   Ç% 8½4È% , Ï% 8½4Ð% & Ö% 8Û,×%  Ý% Þ%  à% á%  ã% ä% *ç%  ê% ë% % ì%  ¯& ð&   °& 8½4±& , ¸& 8½4¹& & ¿& 8Û,À&  Æ& Ò& , Ç&  È& Ð& , É& 8LÊ& & Í& 8Î&  Ñ&  Ô& à& , Õ& 8˜,Ö& & Û& 8ï$Ü& $ â& , ä&  å& î& , æ& 8íŠ$ç& & ë& 8ì& 
ï& *ò&  õ& ( 8ÿ& 8 ƒ' …' , ‡' 8½4ˆ'  Ž' 8íD4'  •' ¯'  ' Ÿ' , —'  ˜' ' , ™' 8Lš'  ž'   ' 8intoÁ$¡'  ¥' ¦' $ §' , ©' 8˜,ª' % °' , º' 8,»' 'À' 8µlÂ'  Ï'  Ð' û'  Ñ' 8½4Ò' , Ù' 8½4Ú'  á' â'  ä' î' , å'  æ' ì' , ç' 8íŠ$è' 
í'  ð' ú' , ñ'  ò' ø' , ó' 8íŠ$ô' 
ù' % ü' % ƒ(  ½( )  ¾( 8½4¿( , Æ( 8½4Ç( & Í( 8Û,Î(  Ô( à( , Õ(  Ö( Þ( , ×( 8LØ( & Û( 8Ü(  ß(  â( î( , ã( 8˜,ä( & é( 8ï$ê( , ð( 8à‹Tñ( & û( 8ü( , ÿ(  €) ‰) , ) 8íŠ$) & †) 8‡) 
Š) *)  ) Å) , š) 8,) ' ) 8á|¢)  ±)  ²) ¾) , ³) 8à‹T´) % ¿) % Æ)  * ´*  ƒ* 8½4„* , * 8½4Œ* & * 8Û,“*  ™* ¥* , š*  * £* , œ* 8L* &  * 8¡*  ¤*  §* ³* , ¨* 8˜,©* & ®* 8ï$¯* *¶*  ¹* ú*  8Ã* 8 Ç* É* , Ë* 8½4Ì*  Ò* 8íD4Ó*  Ù* ó*  Ú* ã* , Û*  Ü* á* , Ý* 8LÞ*  â*  ä* 8×®$å*  é* ê* $ ë* , í* 8˜,î* % ô* % û*  Ÿ+ â+    + 8½4¡+ , ¨+ 8½4©+ & ¯+ 8Û,°+  ¶+ Â+ , ·+  ¸+ À+ , ¹+ 8Lº+ & ½+ 8¾+  Á+  Ä+ Ø+ & Å+ 8É $Ç+ , Ì+  Í+ Ö+ , Î+ 8íŠ$Ï+ & Ó+ 8Ô+ 
×+ , Ú+ 8¬$Û+ & ß+ 8à+ *ä+  ç+ Ò, , ñ+ 8,ò+ '÷+ 8µlù+  †,  ‡, Ë,   ˆ, 8½4‰, , , 8½4,  ˜, ¡, , ™,  š, Ÿ, , , 8Lœ,   ,  £, À, , ¤, 8,¥, 'ª, 8µl¬,  ¹,  º, ¿, 8É $», , Â,  Ã, É, , Ä, 8íŠ$Å, 
Ê, % Ì, % Ó,  ÷, º-   ø, 8½4ù, , €- 8½4- & ‡- 8Û,ˆ-  Ž- š- , -  - ˜- , - 8L- & •- 8-  ™-  œ- °- & - 8 $Ÿ- , ¤-  ¥- ®- , ¦- 8íŠ$§- & «- 8¬- 
¯- , ²- 8¬$³- & ·- 8¸- *¼-  ¿- ª. , É- 8,Ê- 'Ï- 8µlÑ-  Þ-  ß- £.   à- 8½4á- , è- 8½4é-  ð- ù- , ñ-  ò- ÷- , ó- 8Lô-  ø-  û- ˜. , ü- 8,ý- '. 8µl„.  .  . —. 8 $“. , š.  . ¡. , œ. 8íŠ$. 
¢. % ¤. % «.  Ð. ”/   Ñ. 8½4Ò. , Ù. 8½4Ú. & à. 8Û,á.  ç. ó. , è.  é. ñ. , ê. 8Lë. & î. 8ï.  ò.  õ. Š/ & ö. 8 ,ø. , þ.  ÿ. ˆ/ , €/ 8íŠ$/ & …/ 8†/ 
‰/ , Œ/ 8¬$/ & / 8/ */  ™/ …0 , £/ 8,¤/ '©/ 8µl«/  ¸/  ¹/ þ/   º/ 8½4»/ , Â/ 8½4Ã/  Ê/ Ó/ , Ë/  Ì/ Ñ/ , Í/ 8LÎ/  Ò/  Õ/ ó/ , Ö/ 8,×/ 'Ü/ 8µlÞ/  ë/  ì/ ò/ 8 ,í/ , õ/  ö/ ü/ , ÷/ 8íŠ$ø/ 
ý/ % ÿ/ % †0  ¬0 ú0   ­0 8½4®0 , µ0 8½4¶0 & ¼0 8Û,½0  Ã0 Ï0 , Ä0  Å0 Í0 , Æ0 8LÇ0 & Ê0 8Ë0  Î0  Ñ0 ð0 & Ò0  Ô0 â0 , Õ0  Ö0 à0 , ×0 8ƒ,Ø0 & Ý0 8Þ0 
á0 , ä0  å0 î0 , æ0 8íŠ$ç0 & ë0 8ì0 
ï0 , ò0 8¬$ó0 & ÷0 8ø0 *ü0  ÿ0 ò1 , ‰1 8,Š1 '
Â2 & Å2 8Æ2 
É2 , Ì2  Í2 Ö2 , Î2 8íŠ$Ï2 & Ó2 8Ô2 
×2 , Ú2 8¬$Û2 & ß2 8à2 *ä2  ç2 Ø3 , ñ2 8,ò2 '÷2 8µlù2  †3  ‡3 Ñ3   ˆ3 8½4‰3 , 3 8½43  ˜3 ¡3 , ™3  š3 Ÿ3 , 3 8Lœ3   3  £3 Æ3 , ¤3 8,¥3 'ª3 8µl¬3  ¹3  º3 Å3  »3 Ä3 , ¼3  ½3 Â3 , ¾3 8
¿3 
Ã3 , È3  É3 Ï3 , Ê3 8íŠ$Ë3 
Ð3 % Ò3 % Ù3  4 â4   —4 8½4˜4 , Ÿ4 8½4 4 & ¦4 8Û,§4  ­4 ¹4 , ®4  ¯4 ·4 , °4 8L±4 & ´4 8µ4  ¸4  »4 Ø4  & ¼4 , ¾4 8˜,¿4 & Ä4 8ï$Å4 $ Ê4 , Ì4  Í4 Ö4 , Î4 8íŠ$Ï4 & Ó4 8Ô4 
×4 , Ú4 8¬$Û4 & ß4 8à4 *ä4  ç4 Ö5 , ñ4 8,ò4 '÷4 8µlù4  †5  ‡5 Ï5 
 ˆ5 8½4‰5 , 5 8½45  ˜5 ¡5 , ™5  š5 Ÿ5 , 5 8Lœ5   5  £5 Â5 , ¤5 8,¥5 'ª5 8µl¬5  ¹5  º5 Á5 , »5 8˜,¼5 $ Ä5 , Æ5  Ç5 Í5 , È5 8íŠ$É5 
Î5 % Ð5 % ×5  ™6 Ö6   š6 8½46 , ¢6 8½4£6 & ©6 8Û,ª6  °6 ¼6 , ±6  ²6 º6 , ³6 8L´6 & ·6 8¸6  »6  ¾6 Ì6 & ¿6 , Á6 8˜,Â6 & Ç6 8ï$È6 , Î6 8¬$Ï6 & Ó6 8Ô6 *Ø6  Û6 ¾7 , å6 8,æ6 'ë6 8µlí6  ú6  û6 ·7  ü6 8½4ý6 , „7 8½4…7  Œ7 •7 , 7  Ž7 “7 , 7 8L7  ”7  —7 ¶7 , ˜7 8,™7 'ž7 8µl 7  ­7  ®7 µ7 , ¯7 8˜,°7 % ¸7 % ¿7  8 À8   8 8½48 , ˜8 8½4™8 & Ÿ8 8Û, 8  ¦8 ²8 , §8  ¨8 °8 , ©8 8Lª8 & ­8 8®8  ±8  ´8 ¶8 & µ8 , ¸8 8¬$¹8 & ½8 8¾8 *Â8  Å8 9 , ÿ8 8,€9 '…9 8µl‡9  ”9  •9 9 % —9 % ž9  ÿ9 ¯:   €: 8½4: , ˆ: 8½4‰: & : 8Û,:  : ¢: , —:  ˜:  : , ™: 8Lš: & : 8ž:  ¡:  ¤: ¥: , §: 8¬$¨: & ¬: 8­: *±:  ´: Œ; , î: 8,ï: 'ô: 8µlö:  ƒ;  „; …; % †; % ;  Ð; “<   Ñ; 8½4Ò; , Ù; 8½4Ú; & à; 8Û,á;  ç; è;  ê; ù; & ë; , í;  î; ÷; , ï; 8íŠ$ð; & ô; 8õ; 
ø;  û; < , ü; 8colonÁ,ý; & < 8ƒ< , †<  ‡< < , ˆ< 8¬$‰< & < 8Ž< 
< *•<  ˜< Œ= , æ< 8,ç< 'ì< 8á|î<  ý<  þ< …= , ÿ< 8ÈÞ,€= % †= % =  Û= ©>   Ü= 8½4Ý= , ä= 8½4å= & ë= 8Û,ì=  ò= þ= , ó=  ô= ü= , õ= 8Lö= & ù= 8ú= 
ý=  €> > $ > , ƒ>  „> > , …> 8íŠ$†> & Š> 8> 
Ž>  > ¨> , > 8commaÁ,“> & ˜> 8™> , œ>  > ¦> , ž> 8¬$Ÿ> & £> 8¤> 
§> *«>  ®> ¢? , ü> 8,ý> '? 8á|„?  “?  ”? ? , •? 8Œâ,? % œ? % £?  ¹@ ø@   º@ 8½4»@ , Â@ 8½4Ã@ & É@ 8Û,Ê@  Ð@ Ñ@  Ó@ î@  Ô@ Þ@ , Õ@ 8LÖ@ & Ù@ 8ï$Ú@ & à@ , â@  ã@ ì@ , ä@ 8íŠ$å@ & é@ 8ê@ 
í@ , ð@ 8¬$ñ@ & õ@ 8ö@ *ú@  ý@ ×A , ‡A 8,ˆA 'A 8µlA  œA  A ÐA  žA 8½4ŸA , ¦A 8½4§A  ®A ³A , ¯A 8L°A  µA ÁA & ¶A , ¸A  ¹A ¿A , ºA 8íŠ$»A 
ÀA  ÃA ÏA & ÄA , ÆA  ÇA ÍA , ÈA 8íŠ$ÉA 
ÎA % ÑA % ØA  ˜B ÜB   ™B 8½4šB , ¡B 8½4¢B & ¨B 8Û,©B  ¯B »B , °B  ±B ¹B , ²B 8L³B & ¶B 8·B 
ºB  ½B ÒB & ¾B , ÀB  ÁB ÐB , ÂB 8à‹TÃB & ÍB 8ÎB  ÑB , ÔB 8¬$ÕB & ÙB 8ÚB *ÞB  áB ¡C , ëB 8,ìB 'ñB 8÷´óB  ‰C  ŠC šC , C  ŒC ˜C , C 8à‹TŽC  ™C % C % ¢C  ÔC —D   ÕC 8½4ÖC , ÝC 8½4ÞC & äC 8Û,åC  ëC ÷C , ìC  íC õC , îC 8LïC & òC 8óC 
öC  ùC D , úC 8ûC & ýC 8þC , D  D D , ƒD 8íŠ$„D & ˆD 8‰D 
ŒD , D 8¬$D & ”D 8•D *™D  œD úD , ¦D 8,§D '¬D 8µl®D  »D  ¼D óD  ½D 8½4¾D , ÅD 8½4ÆD  ÍD ÚD , ÎD  ÏD ÔD , ÐD 8LÑD 
ÕD , ×D 8ØD  ÜD æD , ÝD  ÞD äD , ßD 8íŠ$àD 
åD  èD òD , éD  êD ðD , ëD 8íŠ$ìD 
ñD % ôD % ûD  ýF G 8É $þF *„G  ‡G ©G , G 8,G '—G 8ÌH,™G 'žG 8ÍÉ$ G % ªG  ±G ¶G 8 $²G *¸G  »G ãG , ÅG 8,ÆG 'ËG 8ÌH,ÍG 'ÒG 8ÞÉ$ÔG  ØG ÝG 8 $ÙG % äG  ëG ñG 8 ,ìG *óG  öG ŸH , €H 8,H '†H 8ÌH,ˆH 'H 8ÞÉ$H  “H ™H 8 ,”H %  H  §H ªH  ¨H ©H *
UnexpectedÁTÍ™;':forward_to_deserialize_anyÁÔå';ž©ò=ä¬>­?µ@ü9(ÜßÐÓÄǬŸ»üº%°£¦˜¬åŒ|€ÌÉtÌè]d‡=”™*ü±'¸ õ÷üÞ!ÑüÚ'ÄÆ¸¨ªœÓŸÔòü¹85 A structure that deserializes JSON into Rust values.ÁBB©â­Æ ŠAACœ'D§'Eµ'ÃÕ~zdš=­ÆÃÕ~zdš=CDE[]<“$“'AA­Æ„ < 'AAßAßA­âAϱ«<ãA¾ «<µ[<™éþ²œ¶'AAüÝ:ÏGHHG©âÐ çòÐÏ|‡ AACœ'D§'Eµ'ÃÕ~zdš=ÐIâceÜß
üž HE Create a JSON deserializer from one of the possible serde_json inputÁ sources.Áü Ëü„
PM When reading from a source against which short reads are not efficient, suchÁüÙ
OL as a [`File`], you will want to apply your own buffering because serde_jsonÁü­ :7 will not buffer the input. See [`std::io::BufReader`].Áì Ëüô HE Typically it is more convenient to use one of these methods instead:ÁÁ ËôÉ  - Deserializer::from_strÁüì  - Deserializer::from_sliceÁü‘
! - Deserializer::from_readerÁ·
ËÜ¿
 [`File`]: std::fs::FileÁæ
Ðö‹FF
IÏМ
üÅC»¯ ² Â8 »7¼­KK­‰ Ê ­ÆAACœ'D§'Eµ'ÃÕ~zdš=óÅLWYü»%ü30 Creates a JSON deserializer from an `io::Read`.ÁÇËüÏJG Reader-based deserializers do not support deserializing borrowed typesÁüžKH like `&str`, since the `std::io::Read` trait has no non-copying methodsÁüîHE -- everything it does involves copying bytes out of the data source.Á\­Æõ’JJ
L­ÆreaderÁ4Îü¡*ˆNNAACœ'D§'Eµ'ÃÕ~zdš=…ÇO¦ü†*üÒ/, Creates a JSON deserializer from a `&[u8]`.ÁT ˆ
è–MM
OˆbytesÁ,˜üó(ˆQQAACœ'D§'Eµ'ÃÕ~zdš=ÝÇRøüÕ#ü¢.+ Creates a JSON deserializer from a `&str`.ÁDÜ ˆÕ˜PP
Rˆö 嬵 Ë Ý Ñ ó, Ò8 Ó& Ô8Û
Û710ÁÝ à, â8 ã& ä8Û$ ê, ì8Š í& î8ï*õ ø Ú8,‚, ˆ8Š   Ô 8Š *, ž8Ë™ Ÿ¡8Š ¤ ¦7ñ™¨« ® É
, ¯8Ë™ ° ²8Š ´ 7ñ™¸», ¾8Œš ¿ Á8Š Ã Å7ñ™Ç$ Ê% Ûäà£Ã¹?
›¯ýh~UVXY[\VW£ÃYZ£Ã\]£ÃTT
V2•5•£ÃTTìžTT2•7•TT
YL•O•£ÃTTÑŸTTL•Q•TT
\f•i•£ÃTT¶ £TTŒì£Ã_bü„],‡'£Ã÷³ê³í³î³Òï³ìð³ñ³ò³ìäs{©¶÷³Ï«<Á‘^Ï`¬aa`^©â÷³ ©<÷³Ï„Ð
_Ï÷³$•visitorÁ<DFü×2'£Ã Ö;Á‘^ ò^
bexpÁíüÖ!'ÏdedeЋ à!á‹Lã!ö‹fgijklmnopqrux{|~ƒˆŠŒŽÛ!jlüï##ü„"^[ The `Deserializer::end` method should be called after a value has been fully deserialized.Áüç"]Z This allows the `Deserializer` to validate that the input stream is at the end or that itÁüÉ#! only has trailing whitespace.Áö#œ œö‹ê³í³î³Òï³ìð³ñ³ò³ìäs{©¶Á‘c ú#c
fÏÐ$ÿ#ü‰&eüÀ%DA Turn a JSON deserializer into an iterator over values of type T.ÁL&ö‹òŽchhc©âÖ š&Ø;ÖϤÙ&
gÏÐÖ$&35ü’83$ 8 ö‹ê³í³î³Òï³ìð³ñ³ò³ìäs{©¶ÃçÁ‘c ¥8c
iÏÐ$ª8üì8(dï8'ž žö‹ê³í³î³Òï³ìð³ñ³ò³ìäs{©¶Á‘c ü8c
jÏÐ$9´Ó9DÖ9'Ÿ Ÿö‹c ß9c
kÏÐ$ä9ü”:-L—:'   ö‹íªc ¡:c
lÏÐ$¦:üè:-Œë:'¡ ¡ö‹¬c ý:c
mÏÐ$;ü–<+,™<'¢ ¢ö‹õ‘Á‘c Ÿ<c
nÏÐ$ <±
4¦<üò=0Tõ='£ £ö‹õ‘Á‘c €>c
oÏÐ$>±
4‡>ü@4@'¤ ¤ö‹íªc ¡@c
pÏÐ$¦@üêB<ŒíB'¥¦ ¥ö‹ ¦Ö;¦Á‘c ÿBc
qÏÐ$„C£ŠCü“Q|”¡Q§ §ö‹¬ê³í³î³Òï³ìð³ñ³ò³ìäs{©¶œ³¨!«<Á‘c¨!s¬tst ½Qc©âœ³ ºQ©<œ³¨!ŒýQ
rÏШ!œ³$ÂQ‰¢<ÈQ$´QHJüáY}œïY¨ ¨ö‹œ³¡³c¨!v¬wwv ŒZc¯´ ‰ZÀ´ŒÌZ
uÏШ!œ³$‘Z‰¢<—Z$ƒZ:<ü¼`}œÊ`© ©ö‹œ³¡³c¨!y¬zyz ç`c¯´ ä`À´Œ§a
xÏШ!œ³$ì`‰¢<ò`$Þ`:<ü g=|£g'ª« ªö‹ «¥—á§c ³gc
{ÏÐ$¸gϱ¾gü°m+d³m'¬ ¬ö‹Á‘Á‘c Àmc
|ÏÐ$Ám8Çm\÷m|<closure_kind>Á}<closure_signature>Á}<upvars>Á}}|}Ðõ‘Á‘ ö‹ü n5\£n'­® ­ö‹ ®Ž˜á§c ¯nc
~ÏÐ$´nÛ,ºnürCl“r'¯ ¯ö‹ê³í³î³Òï³ìð³ñ³ò³ìäs{©¶£ÃÁ‘c ¡rc
ÏÐ$¦rpositiveÁD¬rüÊ€TdÍ€'° °ö‹‘¼c Ú€c
ÏÐ$߀¼Då€ s
;¹C-Œ[—æÄSJœÁ[= ¶è\ö[M¨ã"4„+\0IΕ 2a\|ÛA»H•\[RêßÊ\ysKÒpË]WPÞMþ4]mä•Hà=j]Ä®]-¬f ]uµ8W€Ô]m  ^«|M$D@^ÖÛ`-Ut^̹xª©^UHß^¯–P.5_[¼äypH_rë]£Œ~_'³:ïå³_ñ_ kßÝç_í·ËEWÕ`ôRŸ‹V¥R`±'‡.¬N‡`ñ(:W"½`—Y„v5ò`Ãüo%ÔÂ&aôûË.‰s\ax}?½5È‘aÖ\,C:Æa 4³÷ÓÈûa‡Ðz„]1b©„™å´ebÔåÿ"›b„ ï_SõÐb¥èê7¨2cÏ¢åER:cÁ…¯k“pc2gFx³¤cþ@BXVàÙcŸh)÷5,dÆÂótC7Ddx³0REydVà¼fY–¯d6 6à÷½ãdCCØu­esTNÓØNeìÇô„Gƒeèù1e¸eax~Z¾îe= øÖÓ"f β¶ÌˆWf_äÿjfù°»îßbÂf8jê—ûöf†Då}º,gÔJ#¯Žôag‰ìZ²q–gë$§ñÌgwWÓˆh×”Ê,ë5h
:ý7ÊekhHDþbž¡hZÕ½û…gÕh±J­zgÁ
i¯N¬¬à¸@iZb××çtiñ:Í
ß ªiÖD hTài VÈB®ijkzÓ„IjsYH åj¤7-4ï³j
…8ëèjLð¦†Á%k0V(ô˜wSk»k21UˆýÞj¾k*do^Ëók5= 6~Ã'l ŽÃ]´]lÑÇ8šºlÆùÆ@é4Çl7¸ø#ýl#s:V!2mëOBÉ«©fmæã’»TœmpÎ;5Ž´Ñm б!nr-3ª;n™güßRJqnû—眥nßaú}!Ûn,}¼î”âovœk*:Eo”ƒµbzo=$qE}°oÌmÍ–œäo\È€¼ÃpÏ9}ÐUPpCˆœDë „pTªÃ&)¹pé”4osïpÝÁ%¨#qVA1/XqkY‘ýº¶Žqã×zÞ42ÃqÜÂþ÷qSñŸ›rþ-rÔöC¡¿br‰ô”‰Én—r«1úë{JÍr _|sNsÍv[Ð0â6sTr½šlsÐtÇ"¶à¡sRy«ãXÖs†¦Wï tÈöÝquAtztUÎÒutž˜ÑêG«tcÿÂ2± át<¿sÝOu ¯PßÔ£Jugm’ e¦€uÀwNþÏ´uñÊâýêuÖþL­~B vŒ> XSTv/NÈîåg‰v»azjßÁ¿v}Œ¢+ÙóvZœ/vÏ(wpƒû-T_w&2½œb“w°~ìÙ:Èw\žç4@IþwùÂ!Èí2x¸óT):©gx¥0ª³ˆ“xg^Jp5|Òxö\ÌBy3tâ<y1 ¨/L
ry=È’;Ÿ¦yMzw
Ç4Üyp¬Šfü zŒW-€; Fzo­8`Š‹{zel#|67±zG,…åz^Y÷!Eæ{Û—:5ëÏP{Ò=‰æ…{F+ƒßDº{L8û± kð{_zžÎ…$|ö‡FB§Y|úTÏk‰|8*ÃÆ«
Ä|Çôs¸V
ù|øñf¬P/};—Àkc}
=!°w˜}LŒ)\È”Î}°÷™9ý~œuˆ<ä7~ªKÝm~â[@JOª¢~ÚrÐãT×~ä*
ºÙ‚nQ:B)#ÊåÈv3t¬< Èë…óÌá¨íÎüÃá”Ðá ãá Žä éá ÷á, êá8methodÁ4ëá& ñá8Û,òá*ùá üá ¼â8!”†â ˜â ™â µâ, šâ8Âå4›â$ ¡â8!”£â% ¶â% ½â Äâ àâ , Åâ8Âå4Æâ& Ìâ8Û,Íâ$ Òâ, Ôâ8ˆ,Õâ& Úâ8Û,Ûâ*ââ åâ ‹ä8 ïâ, òâ8Âå4óâ ùâ8¬ úâ ûâ üâ ã8$ýâ$ ã8‰¢<ƒã& Šã8¬ Œã(ã8ý4’ã ˜ã8¬ ™ã'šã8ÌH,œã ¡ã8$,«ã8¬ ½ã& ¾ã8Àã'Âã8³<Äã Ëã:ÏÌã Ïã$ Ðã Úã …ä8$èã ìã, íã8ˆ,îã óã ûã8‰¢<ôã% Œäüºä(»“ä –ä ·ä8Æ —ä šä ¶ä8<›ä £ä7»
Œ¥äü‘ä(ÜÇä ãä –å éä öä, êä ëä ôä, ìä8bodyÁ$íä& ñä8òä
õä*øä ûä “å, …å †å Œå, ‡å8ýë$ˆå
å% ”åäèæ|õæ …ç ‰ê ‹ç ¤ç, Œç8thisÁ$ç& ‘ç8Û,’ç, ˜ç ™ç ¢ç, šç8ýë$›ç& Ÿç8 ç
£ç*¦ç ©ç †ê 8Ž
ܳç Îç Ðç é, Þç8«í$ßç ãç8µ|äçôç7í ÷ç% øç8†è, ‰è8«í$Šè Žè8µ|èŸè7ì ¢è ¤è ƒé84¶è8½è Àè ôè, Áè8«í$Âè Æè8Ï TÇè Ñè óè8ÊLÒè'Ûè8â?´Ýè% õè, ˜é8«í$™é, žé Ÿé ¥é,  é8ýë$¡é
¦é8Ž
ܱé Ìé Îé €ê, Üé8«í$Ýé áé8µ|âéòé7í õé% öé% ‡êüŒêFÏ8ÁššÁ©â׋ –êò׋ÏL™ê•‹œž²´¸º¼¾ÀÂÄÆÈ ¢¤¦¨ª¬®°²´¸º¼¾Àç;è;ê;ì;î;ð;ò;ö;ø;ú;ü;€<<ô;þ;„<†<ˆ<Š<Œ<Ž<<<”<<˜<š<œ<ž< <¢<¤<¼°Â ²È¦¼¸¬¾œ²Ä¢¸´¨¾º®Àž´Æ¤ºªÀ‘êƒTÙê,ÞꘘÁ‘ü€ëb|ƒë•‹œ³ê³í³î³Òï³ìð³ñ³ò³ìäs{©¶œ³Ï«<Á‘˜¬˜¯´ “ë©<œ³Ï„Ñë
œÏ8׋œ³$–뉢<œëFHü˜€c„›€•‹œ³É÷˜¬ŸŸ˜¯´ ¬€Õø„ê€
žÏ8׋œ³$¯€‰¢<µ€8:ü±Œc„´Œ•‹œ³É÷˜¬¡¡˜¯´ ÅŒÕø„ƒ
 Ï8׋œ³$ÈŒ‰¢<ÎŒ8:üÌb•‹œ³É÷˜¬££˜¯´ ßÕøŽ
¢Ï8׋œ³‰¢8:üÀ”e”Ô•‹œ³É÷˜¬¥¥˜¯´ Ö”Õø„”•
¤Ï8׋œ³$Ù”‰¢<ß”8:ü–®düÝ•IF Parses a JSON string as bytes. Note that this function does not checkÁü«–52 whether the bytes represent a valid UTF-8 string.Áå–Ëüí–FC The relevant part of the JSON specification is Section 8.2 of [RFCÁT¸— 7159]:ÁÇ—ËüÏ—KH > When all the strings represented in a JSON text are composed entirelyÁüŸ˜EB > of Unicode characters (however escaped), then that JSON text isÁüé˜GD > interoperable in the sense that all software implementations thatÁüµ™JG > parse it will agree on the contents of names and of string values inÁÌ„š > objects and arrays.Á,¢šü¬šLI > However, the ABNF in this specification allows member names and stringÁüýšLI > values to contain bit sequences that cannot encode Unicode characters;ÁüΛKH > for example, "\uDEAD" (a single unpaired UTF-16 surrogate). InstancesÁüžœIF > of this have been observed, for example, when a library truncates aÁüìœC@ > UTF-16 string without checking whether the truncation split aÁü´HE > surrogate pair. The behavior of software that receives JSON textsÁüžKH > containing such values is unpredictable; for example, implementationsÁüÑžLI > might return different values for the length of a string value or evenÁü¢Ÿ&# > suffer fatal runtime exceptions.ÁÍŸËüÕŸ30 [RFC 7159]: https://tools.ietf.org/html/rfc7159Á Ëü• HE The behavior of serde_json is specified to fail on non-UTF-8 stringsÁüâ GD when deserializing into Rust UTF-8 string types such as String, andÁü®¡KH succeed with the bytes representing the [WTF-8] encoding of code pointsÁüþ¡)& when deserializing using this method.Á¬¢Ëü´¢/, [WTF-8]: https://simonsapin.github.io/wtf-8Áè¢Ëüð¢KH Escape sequences are processed as usual, and for `\uXXXX` escapes it isÁüÀ£JG still checked if the hex number represents a valid Unicode code point.Á¤Ët—¤ # ExamplesÁª¤Ëü²¤JG You can use this to parse JSON strings containing invalid UTF-8 bytes,ÁÜ¥ or unpaired surrogates.Á¡¥Ë<©¥Ú‘ìµ¥ use serde_bytes::ByteBuf;Á×¥Ëüߥ96 fn look_at_bytes() -> Result<(), serde_json::Error> {Áü¦85 let json_data = b"\"some bytes: \xe5\x00\xe5\"";ÁüÚ¦@= let bytes: ByteBuf = serde_json::from_slice(json_data)?;ÁŸ§Ëü§§'$ assert_eq!(b'\xe5', bytes[12]);ÁüÓ§%" assert_eq!(b'\0', bytes[13]);Áüý§'$ assert_eq!(b'\xe5', bytes[14]);Á©¨Ët±¨
$¬Â‰¢<¸ÂACüÅb|„Å•‹œ³É÷˜¬³³˜¯´ ”ÅÕø„ÒÅ
²Ï8׋œ³$—ʼn¢<Å8:ü›ÌqŒžÌ•‹œ³É÷˜¬µµ˜¯´ °ÌÕø„ûÌ
´Ï8׋œ³$³Ì_lenÁ$¹Ì‰¢<ÆÌEGüÄÍ´ÄÇÍ•‹Ÿœ³É÷˜¬··˜¯´ àÍÕø„çÎ
Ï8׋œ³$ìÍýœ,úÍ«¡$—Ή¢<¬ÎLNü°Ïb|³Ï•‹œ³É÷˜¬¹¹˜¯´ ÃÏÕøÐ
¸Ï8׋œ³$ÆÏ‰¢<ÌÏ8:üÊÖÔÍÖ•‹Ÿ 
Ÿœ³É÷˜¬»»˜¯´ àÖÕø„ü×
ºÏ8׋œ³$ìÖýœ,úÖ_fieldsÁ<—׉¢<Á×RTüÎâ»ü¼áYV Parses an enum as an object like `{"$KEY":$VALUE}`, where $VALUE is either a straightÁüšâ! value, a `[..]`, or a `{..}`.Á„ÑâÕ‹ þ¥œ³É÷˜¬½½ ƒã˜¯´ ââÕø„øã
¼Ï8׋œ³$îâýœ,üâ _variantsÁL‘㉢<½ãTVü—ëi´šë•‹œ³É÷˜¬¿¿˜¯´ ±ëÕø„ïë
¾Ï8׋œ³$´ë‰¢<ºë8:ü¸ìj¼»ì•‹œ³É÷˜¬ÁÁ˜¯´ ÓìÕø„‘í
ÀÏ8׋œ³$Ö쉢<Üì8:ÜòíLùí'ˆÃÄÃÄЋ ‡îЈŠî‘¬Ü”î²+Å'ÆÛ+'B_’ß!c±ˆÐB_’ß!c±Åƃî}Ãt”î' ˆö‹\µî,µî'ÂÂüÅî ˆÈÉÉÈЋ ÎÑÊÊîÈüìî+ïî'¯­©¬ÇÇ
ʈÐóîüÉïHÏ̈ÍÎÎÌÍåó ×ï÷óLÚï׋ˆæïë‹ÏÐê<ë<ÐÎïÓïBDÍT˜ð,ðËËÁ‘ü±ðvŒ´ðÄ Äë‹ê³í³î³Òï³ìð³ñ³ò³ìäs{©¶ø°ú°û°Ðü°ý°þ°ìHˈXêE>ã°Ïâ;Á‘ËÑÑ ÉðË©âã° Æðà;ã°ÏÄŽñ
Ðψ׋ã°$ÎðseedÁ$ÔðJLü¶ñr„¹ñ'Å Åë‹ê³í³î³Òï³ìð³ñ³ò³ìäs{©¶Á‘ÏÓˆÔÕÓÕÔ øñåó Óñ÷óLÖñίâñ
Òψ׋seqÁóñÊñÏñFHÔܨúL¯ú'ˆ×Ø×ØЋ ½ú‘¬Àú‘¬ÜÊúÖÖøÙ'ÚÛ+'
§­Ôî«tˆÐ
§­Ôî«tÙÚ¹úvx×tÊú'ÖÖ¯­\ëú,ëú'ÖÖüûú ˆÜÝÜÝЋ „û‘¬‡û‚¶Þ€ûÜü¢û+¥û'¯­‚¶ÛÛ
ވЩûüÿûHÏàˆáâáâàåó ü÷óLüίœü¹Œãäêò<ó<õ<êä„ü‰üFHáTÎü,ÓüßßÁ‘üçürlêüÆ Æ¹Œõ-ê³í³î³Òï³ìð³ñ³ò³ìäs{©¶ø°ú°û°Ðü°ý°þ°ìHˈXêE>¹ºÏâ;Á‘ßõ-åå ûüߩ⹺ øüà;¹ºÏÄÀý
äψ׋¹º$€ýÿ±$†ýGIüèýWdëý'Ç Ç¹ŒͳÏçˆèéèçé ™þåó þ÷óL„þίþ
æÏˆ׋
”þøýýýCEèüÀˆl|ÈÈ È¹Œœ³ê³í³î³Òï³ìð³ñ³ò³ìäs{©¶œ³Ïâ;Á‘߬ëë ֈ߯´ Óˆà;œ³ÏÄ“‰
êψ׋œ³$Ûˆÿ±$áˆGIü‘Šl˜Š'ˆíîîíЋ ªŠ‘¬­Š‘¬Ü·ŠììÈ.ï':ü”ɼ½7ÔˆÐ:ü”ɼ½7Ô力ikíg·Š'ì쯭ü׊$ˆñòñòЋ àŠ‘¬ãŠ›ÁóÜŠñü‚‹+…‹'¯­›Áðð
óˆÐ‰‹üÖ‹MÏõˆö÷õö÷åó ä‹÷óLç‹ίó‹øùú„=…=†=úÛ‹à‹BDöTªŒ,¯ŒôôÁ‘dÂŒ<ÇŒôôüÜŒldߌœ³ê³í³î³Òï³ìð³ñ³ò³ìäs{©¶º¿Á‘ô¬ûûô¯´ ìŒý¿į
úψ׋œ³$ïŒÿ±$õŒ9;üÕŽPÏýˆþÿýþÿåó ãŽ÷óLæŽίòŽŒ==Ž=’=”=ÚŽߎ\^þüüÁ‘üÅ#á§üü
ψ׋ü¤l¤§ã°ê³í³î³Òï³ìð³ñ³ò³ìäs{©¶ú±Á‘üƒƒü´² ¼ƲÄ÷
ψ׋ã°$¿ÿ±9;üÄ‘mlÇ‘œ³É÷ü¬ü¯´ Õ‘Õø„ ’
ψ׋œ³$Ø‘«¡$Þ‘‰¢<ë‘CEüÿ’t‚“¾¥œ³É÷ü¬ü¯´ ‘“Õø„ð“
ψ׋œ³$”“fieldsÁ4𓉢<»“HJüÜ”#Œã”'ˆŠŠЋ ù”‘¬ü”‘¬܆•ˆˆè0'f墳^ÿŒˆÐf墳^ÿŒõ”ikg†•'ˆˆ¯­ü¦•(ˆŽŽЋ ¯•‘¬²•œÎ«•üÕ•+Ø•'¯­œÎŒŒ
ˆÐÜ•ü­–Qψåó »–÷óL¾–ίÊ–Û„=…=†=²–·–BDT…—,Š—Á‘d<¢—Ûü·—ldº—Ûœ³ê³í³î³Òï³ìð³ñ³ò³ìäs{©¶º¿ÛÁ‘¬¯´ Ç—ý¿ÄŠ˜
ψ׋œ³$Ê—ÿ±$З9;üŒ™Tψššåó š™÷óLί©™Ûœž ¢Œ==Ž=’=”= ž¢‘™–™\^šTç™,왘˜Á‘ü€š#dƒšÛ᧘˜
ψ׋$šüÀšm¤ÃšÛã°ÀɘŸŸ˜´² ØšƲÄ”›
žÏˆ׋ã°$Ûš_seedÁ,áš=?ü´œnl·œÛœ³É÷˜¬¡¡˜¯´ ÅœÕø„‘
 Ïˆ׋œ³$Èœ«¡$Μ_visitorÁDÛœJLü§žtªžÛ¾¥œ³É÷˜¬££˜¯´ ¹žÕø„šŸ
¢Ïˆ׋œ³$¼ž©¥<žÀ×DäžCEĤ¡4«¡'ˆ¥¦¥¦Ћ ¶¡‘¬¹¡‘¬ÜᤤÌ2§'&£MøqˆÐ&£Møq§²¡ik¥gá'¤¤¯­üã¡$¼ð¡ ˆ¢ î¨ Ž¢ œ¢, ¢8Âå4¢& –¢8Û,—¢*ž¢ ¡¢ Ó£8 «¢, ®¢8Âå4¯¢ µ¢8¬ ¶¢ ·¢ ¸¢ É¢8$¹¢$ ½¢8‰¢<¿¢& Æ¢8¬ È¢(Ë¢8ý4΢ Ô¢8¬ Õ¢'Ö¢8ÌH,Ø¢ Ý¢8$,ç¢8¬ ù¢
8$Ð¥ Ô¥ ç¥7ì$Õ¥#Ù¥7õ$Ü¥ á¥7$ã¥*é¥ ì¥ í¥8 ÿ¥*¦84„¦8‹¦ ަ »¦8$¦ “¦8”¦ –¦8à ,—¦ œ¦ º¦8ÊL¦'¦¦8˜>”¨¦$ ¼¦8Ù¦8˜,ݦ ã¦8å¦ è¦ é¦ „§8$ê¦ î¦8ï¦ ñ¦, ò¦8¤­Dó¦ û¦ ƒ§8‰¢<ü¦% …§8,”§8š§ § ž§ ­§8$Ÿ§ £§8¤§ ¦§8î$§§ «§ ¬§ ¯§ Ĩ8$Á§ ŧ ʧ7$Ƨ*̧8$ϧ Ó§8Ô§ Ö§8Œ D×§ ß§ à§$ á§8 ó§*õ§84ø§8ÿ§ ‚¨ µ¨8$ƒ¨ ‡¨8ˆ¨ Ѝ8Ï T‹¨ •¨ ´¨8ÊL–¨'Ÿ¨8·<œ¡¨$ ¶¨8ÒÓ¨ Õ¨ Û¨8˜,Ö¨% ì¨üñ¨6Ϫˆ«¬¬ª«åó ÿ¨÷óL©¯ŽÊö¨û¨#%üó©PÏ®ˆ¯°¯®°åó ª÷óL¹ª¯Ž±²ÌÎÐÒÔÖØÚÜÞàâ´¸º¼¾äæèêìîðòôöøúç;è;ì;î;ð;ò;ô;ö;ø;ú;ü;þ;€<<ê;Ž<”< <Š<Œ<„<†<ˆ<<<<˜<š<œ<ž<¢<¤<Òè´ØîºÞôÎäúÔêðÚ¼àöÐæ²Öì¸ÜòÌâ¾øø©ý©|Tʪ,Ϫ­­Á‘üñªb|ôª¯Žœ³É÷­¬³³­¯´ „«Õø„«
²Ïˆ׋œ³$‡«‰¢<«9;üܳc„ß³¯Žœ³É÷­¬µµ­¯´ ð³Õø„®´
´Ïˆ׋œ³$󳉢<ù³9;üÝ»e”à»¯Žœ³É÷­¬··­¯´ ó»Õø„±¼
ψ׋œ³$ö»‰¢<ü»9;ü§½Ôª½¯ŽŸœ³É÷­¬¹¹­¯´ ŽÕø„—¾
¸Ïˆ׋œ³$Ƚÿ
$ν‰¢<â½BDü¼ÀÁ„¿À¯ŽŸ¾¥œ³É÷­¬»»­¯´ ÐÀÕø„ìÁ
ºÏˆ׋œ³$ÜÀÿ
$êÀvariantsÁD†Á‰¢<±ÁSUü×ÂdŒÚÂ¯Žœ³É÷­¬½½­¯´ ìÂÕø„ªÃ
¼Ïˆ׋œ³$<õÂ9;ü†Äg¤‰Ä¯Žœ³É÷­¬¿¿­¯´ žÄÕø„ÜÄ
¾Ïˆ׋œ³$¡Ä‰¢<§Ä9;üÀÌ(ü‹ÇB? Iterator that deserializes a stream into multiple JSON values.ÁÎÇËüÒÇMJ A stream deserializer can be created from any JSON deserializer using theÁü È%" `Deserializer::into_iter` method.ÁÆÈËüÊÈ[X The data can consist of any JSON value. Values need to be a self-delineating value e.g.Áü¦ÉZW arrays, objects, or strings, or be followed by whitespace or a self-delineating value.ÁÊË<…ÊÚ‘üÊ*' use serde_json::{Deserializer, Value};Á¸ÊË|¼Ê©ËüÌÊA> let data = "{\"k\": 3}1\"cool\"\"stuff\" 3{} [0, 1, 2]";ÁŽËËü’ËGD let stream = Deserializer::from_str(data).into_iter::<Value>();ÁÚËËìÞË for value in stream {ÁüüË+( println!("{}", value.unwrap());ÁL¨Ì¨ú,²ÌÍ‘<¸ÌÚ‘”ËÌÏÁÂÃÃÁÂЋ ãÌî© æÌòŽZ¥‰³W2ÉëÄÅÆÇÈÞÌ68:<œïÌïÌ'ÀÀö‹lˆÍ4ˆÍ'ÀÀd›Í4›Í'ÀÀ´­Í4­Í'ÀÀŠ›„Ñ{·Ë…YÚÖôÉÍDÉÍ'ÀÀŠ›„Ñ{·Ë…YÚ ÏüìÍhÏÊËÌËÌÊЋ öÍî© ùÍá‹|§Îÿ©¤¿ÎòŽÍÎÏñÍ468:ܾÑüÛÎIF Create a JSON stream deserializer from one of the possible serde_jsonÁ”©Ï input sources.ÁÀÏËüÈÏHÉŽ•ÐËüÐ/, - Deserializer::from_str(...).into_iter()ÁüÑÐ1. - Deserializer::from_slice(...).into_iter()Áü‡Ñ2/ - Deserializer::from_reader(...).into_iter()ÁÅÑÐòŽÉÉ
ÍÏÐÖœ$ÉÑüÅÝ"üÓÓJG Returns the number of bytes so far deserialized into a successful `T`.Á¢ÔËüªÔLI If a stream deserializer returns an EOF error, new data can be joined toÁüûÔ41 `old_data[stream.byte_offset()..]` to try again.Á´ÕË<¼ÕÚ‘äÈÕ let data = b"[0] [1] [";ÁéÕËüñÕ85 let de = serde_json::Deserializer::from_slice(data);Áü®Ö0- let mut stream = de.into_iter::<Vec<i32>>();ÁüãÖ(% assert_eq!(0, stream.byte_offset());Á×Ëü˜×+( println!("{:?}", stream.next()); // [0]ÁüÈ×(% assert_eq!(3, stream.byte_offset());Áõ×Ëüý×+( println!("{:?}", stream.next()); // [1]Áü­Ø(% assert_eq!(7, stream.byte_offset());ÁÚØËüâØ-* println!("{:?}", stream.next()); // errorÁü”Ù(% assert_eq!(8, stream.byte_offset());ÁÁÙËüÉÙMJ // If err.is_eof(), can join the remaining data to new data and continue.Áü›Ú2/ let remaining = &data[stream.byte_offset()..];Á<ÒÚÚ‘ÞÚËüæÚLI *Note:* In the future this method may be changed to return the number ofÁü·ÛJG bytes so far deserialized into a successful T *or* syntactically validÁü†ÜHE JSON skipped over due to a type error. See [serde-rs/json#70] for anÁôÓÜ example illustrating this.ÁöÜËüþÜB? [serde-rs/json#70]: https://github.com/serde-rs/json/issues/70Á\ÌÝÉ ÉòŽÉ ØÝÉ
ÎÏÐÖ$ÙÝü‰Þ-ŒŒÞ'Ê ÊòŽá§É žÞÉ
ÏÏÐÖ$£Þü„âoÏÑÒÓÒÑÓЋ Žâî© ‘âá‹LÌâÿ©¤ÞâòŽÔÕßKàKÕ‰â=?ACLúâ$ÿâÐÐê³í³î³Òï³ìð³ñ³ò³ìäs{©¶ÖÁ‘ü–ã'$™ãË ËòŽø°ú°û°Ðü°ý°þ°ì
# ExampleÁèüËüìü# Reading the contents of a file.ÁýË<”ýÚ‘Üœý use serde::Deserialize;Á¸ýËÔ¼ý use std::error::Error;Á´×ý use std::fs::File;ÁÜîý use std::io::BufReader;ÁÄŠþ use std::path::Path;Á£þËü§þ! #[derive(Deserialize, Debug)]ÁŒÉþ struct User {ÁäÛþ fingerprint: String,ÁÌøþ location: String,Á,’ÿÍ‘˜ÿËüœÿUR fn read_user_from_file<P: AsRef<Path>>(path: P) -> Result<User, Box<dyn Error>> {Áüòÿ74 // Open the file in read-only mode with buffer.Áüª€%" let file = File::open(path)?;ÁüЀ*' let reader = BufReader::new(file);Áû€Ëüÿ€GD // Read the JSON contents of the file as an instance of `User`.ÁüÇ1. let u = serde_json::from_reader(reader)?;ÁùËìý // Return the `User`.Ál›‚
Ok(u)Á,©‚Í‘¯‚Ë|³‚©Ë<Âɨ´Ë‚ # fn fake_main() {Áüâ‚:7 let u = read_user_from_file("test.json").unwrap();Áìƒ println!("{:#?}", u);Á,»ƒÍ‘<ÁƒÚ‘ɃËü̓0- Reading from a persistent socket connection.ÁþƒË<‚„Ú‘ÜŠ„塦„ËÔª„•¢Üńעüá„+( use std::net::{TcpListener, TcpStream};ÁËü‘…!©£Œ³…Ó£äÅ…í£Ìâ…’¤,ü…Í‘‚†Ëü††a^ fn read_user_from_stream(stream: &mut BufReader<TcpStream>) -> Result<User, Box<dyn Error>> {Áüè†C@ let mut de = serde_json::Deserializer::from_reader(stream);Áü¬‡,) let u = User::deserialize(&mut de)?;ÁÙ‡Ël݇š¨,ë‡Í‘ñ‡Ë|õ‡©Ë<…ˆɨ´ˆã¨ü¤ˆDA let listener = TcpListener::bind("127.0.0.1:4000").unwrap();ÁéˆËüíˆ/, for tcp_stream in listener.incoming() {ÁüC@ let mut buffered = BufReader::new(tcp_stream.unwrap());Áüá‰DA println!("{:#?}", read_user_from_stream(&mut buffered));ÁL¦Š¨ú,°ŠÍ‘<¶ŠÚ‘¾ŠËdŠ # ErrorsÁÏŠËüÓŠMJ This conversion can fail if the structure of the input does not match theÁü¡‹PM structure expected by `T`, for example if `T` is a struct type but the inputÁüò‹OL contains something other than a JSON map. It can also fail if the structureÁüÂŒOL is correct but `T`'s implementation of `Deserialize` decides that somethingÁü’OL is wrong with the data, for example required struct fields are missing fromÁüâKH the JSON map or some number is too big to fit in the expected primitiveÁL®Ž type.Á»ºŽ ½Ž ÍŽ8<¾Ž ÆŽ7,ÈŽ¼¸Ž\†­Æê³í³î³Òï³ìð³ñ³ò³ìäs{©¶ϳÁ‘àááà­‰ ©âϳ æ’Þ;ϳ¤Ò
ß­ÆϳrdrÁ˜JLEGü½˜Tü”@= Deserialize an instance of type `T` from bytes of JSON text.ÁÕËý çËÚ‘Üóå¡Ëü“‘!©£Œµ‘Ó£äÇ‘í£Ìä‘’¤,þ‘Í‘„’Ë|ˆ’©Ëü˜’%" // The type of `j` is `&[u8]`Á”¾’ let j = b"ÁlÑ’£üß’85 \"fingerprint\": \"0xF9BA143B95FF6D82\",Áü˜“0- \"location\": \"Menlo Park, CA\"Á|É“ }";ÁÙ“ËüÝ“96 let u: User = serde_json::from_slice(j).unwrap();Á엔Ʃ,µ”Í‘<»”Ú‘ÔËdÇ”ϱÔ”ËüØ”Mñ±ü¦•PȲü÷•O¢³üÇ–Oû³ü——OÔ´üç—K­µL³˜TĘˆ˜è·ˆãäãäð¸ Ó˜Ø;ϳˆœý˜
âˆϳ Ö˜Ϙ<>üç¡Qü¿™C@ Deserialize an instance of type `T` from a string of JSON text.ÁƒšËl‡šý •šË<™šÚ‘Ü¡šå¡½šËüÁš!©£ŒãšÓ£äõší£Ì’›’¤,¬›Í‘²›Ë|¶›©ËüÆ›$! // The type of `j` is `&str`ÁŒë› let j = "Álý›£ü‹œ8¦»üÄœ0è»|õœ¡¼Ëü‰74 let u: User = serde_json::from_str(j).unwrap();ÁìÁƩ͑ڑíËϱþËü‚žMñ±üОPȲü¡ŸO¢³üñŸOû³üÁ OÔ´ü‘¡K­µLÝ¡Dî¡ô™è·ˆæçæçð¸ û¡þ¿œ¤¢
åˆϳö þ¡÷¡-/lâmü6
3 When serializing or deserializing JSON goes wrong.Á,êmùûˆŒØÙßàáü˜@C
ö
èéâõY
èê4r
ÉHèìDz
×5èíÍ$•
Á]èï,›
à`èðã`èð
å`èñÛ

Yèòà„
Ôvèóâ
bèõæ
Ú èöÃ ,
äè÷ ErrorKindÁL¹
¥HèøL<
+ŒK
üb!
ü‰!
ø
éëÄÆd°
·”Â
§„Ú
˜šˆŠTˆ
{”°
c„²
üÅO
L This type represents all possible errors that can occur when serializing orÁä•
 deserializing JSON data.Á
Á‘¬ e{¶i2úœ•

èùùâõ샚íƒlÕ°Ù[¢'õÍ•þ²”ï
ü­A
> Alias for a `Result` with the error type `serde_json::Error`.Á4ø
üü©âø² ÿ
ê³í³î³Òï³ìð³ñ³ò³ìäs{©¶ø²Á‘Y[
Á‘þÿƒÜå
ü°:
7 One-based line number at which the error was detected.Áï
Ëü÷G
D Characters in the first line of the input (before the first newlineÁìÃ
 character) are in line 1.Á$ì
Ì ÌÁ‘ý ñ
ý
þ
ìž
ü¤<
9 One-based column number at which the error was detected.Áå
ËüíC
@ The first character in the input and any characters immediatelyÁüµ 2
/ following a newline character are in column 1.Áì
Ëüô I
F Note that errors may occur in column 0, for example if a read from anÁüÂ
D
A I/O stream fails immediately following a previously read newlineÁt
character.Á4¥
Í ÍÁ‘ý ¬
ý
ÿ$­
ü¯"
üá (
% Categorizes the cause of this error.ÁŽ
Ëü– F
C - `Category::Io` - failure to read or write bytes on an I/O streamÁüá E
B - `Category::Syntax` - input that is not syntactically valid JSONÁü«
B
? - `Category::Data` - input data that is semantically incorrectÁüò
8
5 - `Category::Eof` - unexpected end of the input dataÁD¶
Î ÎÁ‘îý ¿
ý

Ü•
ü©G
D Returns true if this error was caused by a failure to read or writeÁÜõ
 bytes on an I/O stream.Á,œ
Ï ÏÁ‘ý ¢
ý

üÌ
üæ?
< Returns true if this error was caused by input that was not瓻
 syntactically valid JSON.ÁLÓ
Ð ÐÁ‘ý Ý
ý

ì˜
ü¥@
= Returns true if this error was caused by input data that wasÁÜê
 semantically incorrect.ÁŠ
Ëü’L
I For example, JSON containing a number is semantically incorrect when theÁüã0
- type being deserialized into holds a String.Á<Ÿ
Ñ ÑÁ‘ý §
ý
ƒ
äâ
üíL
I Returns true if this error was caused by prematurely reaching the end ofÁœ¾
 the input data.ÁÖ
ËüÞJ
G Callers that process streaming input may be interested in retrying theÁü­0
- deserialization once more data is available.Á4é
Ò ÒÁ‘ý ð
ý

ü£+0
üµ K
H The kind reported by the underlying standard library I/O error, if thisÁü…!J
G error was caused by a failure to read or write bytes on an I/O stream.ÁÔ!
ËlÜ!
ý î!
Ë<ö!
Ú‘Ô‚"
 use serde_json::Value;Áü¡")
& use std::io::{self, ErrorKind, Read};Á¬Ï"
 use std::process;Áé"
Ëüñ"/
, struct ReaderThatWillTimeOut<'a>(&'a [u8]);Á¥#
Ëü­#1
. impl<'a> Read for ReaderThatWillTimeOut<'a> {Áüã#A
> fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {Áü©$"
 if self.0.is_empty() {ÁüÐ$E
B Err(io::Error::new(ErrorKind::TimedOut, "timed out"))Á¤š%
 } else {Áü³%
 self.0.read(buf)ÁlØ%
Lê%
¨ú,ø%
Í‘&
Ë|Š&
©Ëüž&:
7 let reader = ReaderThatWillTimeOut(br#" {"k": "#);ÁÝ&
Ëüå&>
; let _: Value = match serde_json::from_reader(reader) {矬'
 Ok(value) => value,ÁÜÌ'
 Err(error) => {Áüì'G
D if error.io_error_kind() == Some(ErrorKind::TimedOut) {Áü¸(U
R // Maybe this application needs to retry certain kinds of errors.Á)
Ëìš)
 # return;Áļ)
 } else {ÁüÙ)2
/ eprintln!("error: {}", error);Áü*%
" process::exit(1);ÁŒº*
lÐ*
ìäTâ*
äß,ñ*
Í‘<û*
Ú‘»‰+
 Œ+
œ+
8<+
•+
7,—+
¼‡+
lª+
Ó ÓÁ‘ø°ú°û°Ðü°ý°þ°ìHˈXêE>¥H*¦H§HNotFoundÁ¨H©HPermissionDeniedÁªH«HConnectionRefusedÁ¬H­HConnectionResetÁ®H¯HHostUnreachableÁ°H±HNetworkUnreachableÁ²H³HConnectionAbortedÁ´HµH NotConnectedÁ¶H·H AddrInUseÁ¸H¹HAddrNotAvailableÁ ºH»H NetworkDownÁ
¼H½H
BrokenPipeÁ ¾H¿H
AlreadyExistsÁ ÀHÁH
WouldBlockÁ
ÂHÃH
NotADirectoryÁÄHÅH IsADirectoryÁÆHÇHDirectoryNotEmptyÁÈHÉHReadOnlyFilesystemÁÊHËHFilesystemLoopÁÌHÍHStaleNetworkFileHandleÁÎHÏH InvalidInputÁÐHÑH InvalidDataÁÒHÓHTimedOutÁÔHÕH WriteZeroÁÖH×H StorageFullÁØHÙH NotSeekableÁÚHÛH
QuotaExceededÁÜHÝH FileTooLargeÁÞHßH ResourceBusyÁàHáHExecutableFileBusyÁâHãHDeadlockÁäHåHCrossesDevicesÁæHçH TooManyLinksÁ èHéHInvalidFilenameÁ!êHëHArgumentListTooLongÁ"ìHíH InterruptedÁ#îHïH UnsupportedÁ$ðHñH
UnexpectedEofÁ%òHóH OutOfMemoryÁ&ôHõH
InProgressÁ'öH÷H¦û(øHùH
UncategorizedÁ)SïÇl\œ±ý ¸+
ý
$¹+
ô¤3
Ȏ2
 ì2
ü2
8<í2
õ2
7,÷2
¼ç2
”‘üÌ¥:
üÉ36
3 Convert a `serde_json::Error` into an `io::Error`.Á„4
ËüŒ4I
F JSON syntax and data errors are turned into `InvalidData` I/O errors.ÁüÚ4:
7 EOF errors are turned into `UnexpectedEof` I/O errors.Á™5
Ë<¡5
Ú‘„­5
use std::io;ÁÂ5
Ë”Ê5
 enum MyError {Á´á5
 Io(io::Error),Áüü5
 Json(serde_json::Error),Á,¡6
Í‘«6
Ëü³6.
+ impl From<serde_json::Error> for MyError {Áüæ64
1 fn from(err: serde_json::Error) -> MyError {ÁüŸ7,
) use serde_json::error::Category;ÁüÐ7"
 match err.classify() {Áü÷7!
 Category::Io => {Áü8+
( MyError::Io(err.into())ÁŒÍ8
÷éüã8F
C Category::Syntax | Category::Data | Category::Eof => {矨9&
# MyError::Json(err)ÁŒÙ9
÷élï9
ìäL:
¨ú,:
Í‘<™:
Ú‘$¨:
Á‘”‘
 ­:
„³=
Lº=
èÍ•Ü6Æ’‡C
Š|Ê=
$Ê=
興õ‘\ß=
$ß=
興lð=
4ð=
興̂>
L>
õ‘3Úf‡bv÷†Ž˜šœžŸ ¡¢£¤¥¦§¨©ª«¬­®¯°±²³´µ·¸¹º»¼½¾¿ÀŽÔöõ‘”‘õ‘˜šœž   ¢

¤  ¦  ¨

ª¬®°²´¸º¼¾ÀŸºŸºŒŒ
ŽŸºŸºÔöõ‘ŒŒõ‚DÕ>
ŒŒÔöŒŒ
”‘õ‘ŒŒãƒL¬?
ŒŒ”‘œß?
ŒŒõ‘ŒŒõ‘¬ž@
ŒŒõ‘ŒŒõ‘¬Þ@
ŒŒõ‘ŒŒõ‘¤¢A
ŒŒõ‘ŒŒõ‘lìA
ŒŒõ‘ŒŒõ‘´ÁB
ŒŒõ‘ŒŒõ‘ÄŸC
ŒŒõ‘ŒŒõ‘ŒÿC
ŒŒõ‘ŒŒõ‘ŒÎD
ŒŒõ‘ŒŒõ‘œ“E
ŒŒõ‘ŒŒõ‘lÎE
ŒŒõ‘ŒŒõ‘lúE
ŒŒõ‘ŒŒõ‘„ËF
ŒŒõ‘ŒŒõ‘¼†G
ŒŒõ‘ŒŒõ‘üÜG"
ŒŒõ‘ŒŒõ‘„©H
ŒŒõ‘ŒŒõ‘”öH
ŒŒõ‘ŒŒõ‘¤¿I
ŒŒõ‘ŒŒõ‘üˆJ
ŒŒõ‘ŒŒõ‘lðJ
ŒŒõ‘ŒŒõ‘”ÉK
ŒŒõ‘ŒŒõ‘ĈL
ŒŒõ‘ŒŒõ‘´öL
ŒŒõ‘ŒŒõ‘T‘M
Á‘ÂÃÄü®MI
4¼M
õ‘Á‘ÁÁ
½9$ÃM
È $ÔM
ä4áM
üìO#
¡ÏO
 ÒO
ÙO
8°4ÓO
tÍO
óO
”‘Á‘ÁÁ
ÃÃ ,öO
üÙQb
dçQ
Á‘ª@Á‘Áª@ÅÅÁ©âÔ’ ôQ
ԒѺԠR
Ô’ѺÁ‘,µR
ÄÔ’$÷Q
þ ýQ
GIÔ´S
õ‘Çæ`ÇüÕS4
ØS
ÔÕÖ Ôõ‘ ÕÁ`Á`œÃ`è Á]Ä`ϱÁ]Ê­\É:•Öê³í³î³Òï³ìð³ñ³ò³ìäs{©¶ѼѼÒ¼ štÀ.Æ ÜS
Æ
Ç$ÝS
þ ãS
ü’f"
Á‘ÉÐÉü×f9
»½f
 Àf
Ðf
8<Áf
Éf
7,Ëf
¼»f
4Úf
× ×Á‘ø°ú°û°Ðü°ý°þ°ìHˈXêE> ×ÏÈ áf
È
É$âf
´Œh
Á‘Ëæ`Ëü©h4
¬h
ØÙÚ ØÁ‘ ÙÁ`Á`œÃ`è Á]Ä`ϱÁ]Ê­\É:•Ú€•Ê °h
Ê
Ë$±h
þ ·h
Ôi
Í•Íæ`Íü®i4
±i
ÛÜÝ ÛÍ• ÜÁ`Á`œÃ`è Á]Ä`ϱÁ]Ê­\É:•Ý€•Ì µi
Ì
Í$¶i
þ ¼i
¤õl
Á‘Ïá`Ïüm4
“m
Þßà ÞÁ‘ ßÁ`Á`œÃ`è Á]Ä`ϱÁ]Ê­\É:•à€•Î —m
Î
Ï$˜m
þ žm
Ĉo
Á‘ÑÓÔ;’;“;ÓÑÔü³o&
4¶o
ø²Á‘ÐÒÒÐ„Í ½o
å`ø²<Ào
Ñø²msgÁÉo
(*ü—pF
dšp
áâ™;›;œ;ÞÉ;ìž;Ÿ;‹ø ;ì¡;¢;¬ø£;ì¤;¥;Üå¦;ì§;¨;åø©;ìª;«;‚ù¬;ì­;®;žù¯;ì°;±;¼ù²;³;Ó´;µ;àù ¶;·;ýù
¸;¹;ŸC º;»; ú ¼;½;´ú
¾;¿;ÏúÀ;Á;íúÂ;Ã;‰ûÄ;Å;¦ûÆ;ì²Ëª[e]ÀÉá âÖ;âÁ‘ÐT²p
Ð
ÓunexpÁ,§p
£¾p
ü‡rG
lŠr
ãä™;›;œ;ÞÉ;ìž;Ÿ;‹ø ;ì¡;¢;¬ø£;ì¤;¥;Üå¦;ì§;¨;åø©;ìª;«;‚ù¬;ì­;®;žù¯;ì°;±;¼ù²;³;Ó´;µ;àù ¶;·;ýù
¸;¹;ŸC º;»; ú ¼;½;´ú
¾;¿;ÏúÀ;Á;íúÂ;Ã;‰ûÄ;Å;¦ûÆ;ì²Ëª[e]ÀÉã äÖ;äÁ‘ÐT£r
Ð
Ô´¡,˜r
£¯r
Ìës
Á‘Ö¬AÖü—t&
4št
ø²Á‘Õ××Õ„Í ¡t
Žž<¤t
Öø²¨­t
 tôt
èˆÚÚº–°‡TêsÙÛ™;›;œ;ÞÉ;ìž;Ÿ;‹ø ;ì¡;¢;¬ø£;ì¤;¥;Üå¦;ì§;¨;åø©;ìª;«;‚ù¬;ì­;®;žù¯;ì°;±;¼ù²;³;Ó´;µ;àù ¶;·;ýù
¸;¹;ŸC º;»; ú ¼;½;´ú
¾;¿;ÏúÀ;Á;íúÂ;Ã;‰ûÄ;Å;¦ûÆ;ì²Ëª[e]ÀɈº–Ö蟨º–ØØ
Ùˆƒu
”‡u
èØØŸ¨üu'
ˆÝݺ–Þæ`Þ¢u
üËu<
Îu
åæç 庖 æÁ`Á`œÃ`è Á]Ä`ϱÁ]Ê­\É:•ç€•Ü Òu
Ü
Þˆ$Óu
œPLÙu
üÿy'
Tz
襗Á‘
ߨz
ü“|=
t|
èè 襗ø°ú°û°Ðü°ý°þ°ìHˈXêE> ª|
ਥ|
ü …)
Œ£…
èé é ¼…
áî,µ…
\ñmü)& A map of String to serde_json::Value.Á*Ëü.OL By default the map is backed by a [`BTreeMap`]. Enable the `preserve_order`Áü~63 feature of serde_json to use [`IndexMap`] instead.ÁµËü¹,) [`BTreeMap`]: std::collections::BTreeMapÁüæ$! [`IndexMap`]: indexmap::IndexMapÁùmó÷Ï×ÚÝßûˆ¦¹ÆÜòùâãÌH,·±âäÉHâåg4£¦âæÍÁ]âèà`âéã`â馻bâë¦ÁbâëªÃbâì£ÖNâíÞ ÄÁâîÔbâï btree_mapÁLš *âñdD¥ð
âòœ@œ©2¬Â$¤•į µûýÔÍÚܵ·Ìí¨L¾™LÍŠü…)tvdf¤’üì%" Represents a JSON key/value type.Áõ-ô¬õôõ©âò³ ¡Ì¢ ¤óóŸCö
â–ˆCbIÖçò³÷³–ˆCbIÖçöVX[]”­­âóóð
ð
dô
rootÁÀ õ
lengthÁÀ ö
áË ÷
_markerÁÀ Ï D jèjò³÷³þ²”ì»Æ É é8Æ Ê Í è8 Ö7ë
„ØüÄ'âõ-ø¬ùøù•· ùÌ¢ üª¸¼Úø–ûüýþŒ¤¥Ôø Makes a new empty Map.Á¬ø–úú
ûüÍ -ü€ :7 Makes a new empty Map with the given initial capacity.ÁlÔ ø–úú
ücapacityÁDâ ¼ˆ
üÍ (% Clears the map, removing all values.Á,
ê êø–ú
ú
ý
ü¹yüÇ
>; Returns a reference to the value corresponding to the key.ÁŠËü’LI The key may be any borrowed form of the map's key type, but the orderingÁüãC@ on the borrowed form *must* match the ordering on the key type.ÁÀëì ëø– ì”Dø°ú°û°Ðü°ý°þ°ìHˈXêE> ëÒ—ú”Dÿÿ Çúªâ³À Ħ¥—³ÀóÀ¢£³À¨»b³À
þ³À‚LÎ`büÕxüÞC@ Returns true if the map contains a value for the specified key.Á¦Ëü®Lâ½üÿC·¾íî íø– î³Àú”D ìú¯Á éÀÁÔÁ½äÁÃôÁ
³ÀLó<>üüü‚FC Returns a mutable reference to the value corresponding to the key.ÁÍËüÕLâ½ü¦C·¾ïð ïø– ð³Àø°ú°û°Ðü°ý°þ°ìHˈXêE> ïÒ—ú”Dƒƒ Žú¯Á ÀÁÔÁñäÁ÷ôÁ
³À$“L<>ü›Žü±63 Returns the key-value pair matching the given key.ÁìËüôLâ½üÅC·¾ñò ñø– ò³Àø°ú°û°Ðü°ý°þ°ìHˈXêE> ñ¥— ñÒ—ú”D ³ú¯Á °ÀÁÔÁäÁŸôÁ
³À$´Lº<>üÝ>üß*' Inserts a key-value pair into the map.ÁŽËü–A> If the map did not have this key present, `None` is returned.ÁÜËüäKH If the map did have this key present, the value is updated, and the oldÁ´´ value is returned.Á4äó óø–¥—Ò—ø°ú°û°Ðü°ý°þ°ìHˈXêE>Ò—ú ëú
 ö¥¿ üä&üë!IF Removes a key from the map, returning the value at the key if the keyÁô¹" was previously in the map.ÁÜ"Ëüä"Lâ½üµ#C·¾ý#Ëü…$B? If serde_json's "preserve_order" is enabled, `.remove(key)` isÁüÌ$JG equivalent to [`.swap_remove(key)`][Self::swap_remove], replacing thisÁü›%GD entry's position with the last element. If you need to preserve theÁüç%.+ relative order of the keys in the map, useÁüš&74 [`.shift_remove(key)`][Self::shift_remove] instead.Á4ë&ôõ ôø– õ³ÀüÌú”Dˆˆ õ&ú¯Á ò&ÀÁL´'ÔÁÓ'äÁÙ'ôÁ$Þ'
³À$ú&L€'<>ü¶.ü›)IF Removes a key from the map, returning the stored key and value if theÁüé)" key was previously in the map.Á*Ëü˜*Lâ½üé*C·¾±+Ëü¹+HE If serde_json's "preserve_order" is enabled, `.remove_entry(key)` isÁü†,GD equivalent to [`.swap_remove_entry(key)`][Self::swap_remove_entry],ÁüÒ,IF replacing this entry's position with the last element. If you need toÁü -;8 preserve the relative order of the keys in the map, useÁüà-C@ [`.shift_remove_entry(key)`][Self::shift_remove_entry] instead.Ád½.ö÷ öø– ÷³Àø°ú°û°Ðü°ý°þ°ìHˈXêE>´šú”DŠŠ Í.ú¯Á Ê.ÀÁL–/ÔÁµ/äÁ»/ôÁ$À/
³À$Ò.LØ.<>
# let _ =Á|ük match val {ÁüŒl-* Value::String(s) => Some(s.as_str()),Áüºl-* Value::Array(arr) => arr[0].as_str(),Áüèl30 Value::Object(map) => map["type"].as_str(),Á”œm _ => None,Á,¯mÍ‘<µm # ;Á<½mÚ‘8”D¦¦ªâº™ Êm¦¥—º™L…nú™ n£º™¦n»bº™$«nø–§¨¨˜©˜¨`b\·n4¼n¥¥Ò—üÑn$,ÔnŽ Žø– º™ ŽÒ—¥ Ún¥
¨8º™$Ûnö,ánüÇqnüŸoIF Mutably access an element of this map. Panics if the given key is notÁ¼éo present in the map.ÁpË<…pÚ‘Üp«Ó,©p´œü¯p+( # let mut map = serde_json::Map::new();ÁüÛp<9 # map.insert("key".to_owned(), serde_json::Value::Null);Á,˜q´œüžq  map["key"] = json!("value");Á<¿qÚ‘8”Dªª·ý ÌqÈýLŠrÜý¥rìý«rüý$°rø–«¸ «35ü¼r0L¿r ø– º™ Ò—© Ér©
«8º™$Îrö,Ôrü¹s!ø–­á`­üïsGòs ø– Á`Á`œÃ`è Á]Ä`ϱÁ]Ê­\É:•€•¬ ös¬
­$÷sœPLýsü’u1»ät çt u8÷èt ët Žu8<ìt ôt7,öt$ ût8<ýt …u7á<‡uüât/ø–¯¯A¯üØumLÛu ø–´Üê³í³î³Òï³ìð³ñ³ò³ìäs{©¶´Ü²A´Ü³A®ÈE°° èu®­Ý åu±A´Ü´®v
¯´Ü$éu
serializerÁTïu68ÄØvdävü©x5ϳ³ø–´Ú;´®xüóxh\öx©Hê³í³î³Òï³ìð³ñ³ò³ìäs{©¶ø–Ú‰ Ïç;²©Hµµ²©âÚ‰ ‚yå;Ú‰ ϬÅy
´ÏÚ‰  deserializerÁd…y=?têy<ñyâþ™«xä@F2V·.*âþ™üƒz&Ϲ¹þ™º»¼¾«<¬<Ü<â<¼»¾ˆzT¸z,½z¸¸ø–üæzBLéz˜ þ™ ˜Á`Á`œÃ`è Á]Ä`ϱÁ]Ê­\É:•€•¸ óz¸
»Ï$ôzœPLúzü‰|`TŒ|þ™ê³í³î³Òï³ìð³ñ³ò³ìäs{©¶þ™Ï«<üH¸üH½½¸©â³ —|;³ Lß|
¼Ï³ $š|*,ü„~»´} ·} ß}8÷¸} »} Þ}8<¼} Ä}7,Æ}$ Ë}8<Í} Õ}7á<×}ü²}/L‡~þ™÷³ê³í³î³Òï³ìð³ñ³ò³ìäs{©¶¢ ÷³Ïò<¸¬¿¿¸Ì¢ ‘~ð<÷³Ï”ð~
¾Ï÷³$”~‰¢<ž~9;ü¹9ø–Á¬JÁüù[ø²ø–ÀÂÂÀ„Í †‚®Jø²ü¯‚$ø²¯J´š´¼‚
Áø²£ $‰‚=?ü¬ƒ3ø–ĹJÄüæƒ[4郚 šø–ø²ÃÅÅ óƒÃ„Í ðƒõ“ üœ„$‡” ´©„
Äø²$øƒ£ $þƒ24ôð„Œý„  Œ •… À… –… ³…, —…8ÿ
$˜…& œ…8Û,, £… ¤… ±…, ¥…8genericsÁD¦…& ®…8¯…
²…*µ…, ¸…8¡ $¹…& ½…8¾…*Â… Å… ŽŒ08$Ï…, Ô… Õ… ß…, Ö…8ø• D×…
à…8ÂDâ…8
ë…, ï…8ÿ
$ð…, õ… ö… €†, ÷…8ø• Dø…
 ƒ† ®ˆ8!$‘†8½$–† ›†, 8¡ $ž†% ¢†+ °† ±† ¸†8þ4²†8 Ɔ8¥ $Ɇ ͆ ׆ Ά8φ8$Ó†(Ù†8Ó4܆ â†8$ã†'ç†8½$é† í† ï† ž‡8$ …‡8£ $†‡ Ї8¥ $‹‡  + ¬‡ ­‡ ´‡8þ4®‡8 ‡8é€LŇ · Ô‡ χ8$Ї(Ö‡ Ù‡ î‡8,Ú‡$ ߇8Ó4ᇠç‡8,è‡ í‡ ð‡ ¤ˆ8$‚ˆ †ˆ8£ $‡ˆ ‹ˆ8é€LŒˆ •ˆ –ˆ8$¹ˆ, ¾ˆ ¿ˆ Ɉ, Àˆ8ø• DÁˆ
ʈ8ŒœÌˆ8
àˆ, äˆ8ÿ
$åˆ, êˆ ëˆ õˆ, ìˆ8ø• Díˆ
öˆ øˆ ˆŠ
+ †‰ ‡‰ މ8þ4ˆ‰8 œ‰8ÆÀLŸ‰ ¨‰ ²‰ ©‰8ª‰8$®‰(´‰8Ó4·‰ ½‰8$¾‰'‰8½$ĉ ȉ ʉ þ‰8$܉ à‰8£ $በå‰8ÆÀLæ‰ ï‰ ð‰8$“Š, ˜Š ™Š £Š, šŠ8ø• D›Š
¤Š8ExactSizeIteratorÁŒ¦Š8
¸Š, ¼Š8ÿ
$½Š, Š Ê ÍŠ, ÄŠ8ø• DÅŠ
Ί Њ Ë+ ÞŠ ߊ æŠ8þ4àŠ8 ôŠ8¾ ÷Š úŠ €‹ ûŠ8$üŠ(‚‹8,…‹ ‹‹ ¹‹8$ ¡‹8£ $¢‹ ¦‹8¾ §‹ ª‹ «‹8$΋, Ó‹ Ô‹ Þ‹, Õ‹8ø• DÖ‹
ß‹8£lá‹8
ï‹, ó‹8ÿ
$ô‹, ù‹ ú‹ „Œ, û‹8ø• Dü‹
…Œ ‡Œ ˆŒü“ŒAÏÈÈø–ÉÊÅ Æ Ê˜ŒŒÛŒdàŒÇÇø–üúŒ0ŒýŒø–ø–ÏÁ‘Å ÇÇ
ÊÏ$üÃFÏÌÌèšÍÎÅ Æ ÎÈŒŽd•ŽËËèšü¯Ž0Œ²ŽèšèšÏÁ‘Å ËË
ÎÏ$ÄŽ”úüÈPM A view into a single entry in a map, which may either be vacant or occupied.Áü™B? This enum is constructed from the [`entry`] method on [`Map`].ÁÜËÌà [`entry`]: Map::entryÁ,ƒ‘ˆÐÐÏÑÒÇJÓìÔÕâJÖ왣@•2g舙£@•2gèÑÒÔÕÒÓ××ÿJÙšKâ:6[nZ³uˆ‚ª ÕÖÚÚ¨KÜÅKâ%ÃRô¾%ôˆ‚ª ‰‘作“‘ A vacant Entry.Áä½ÏÏ
Òˆä½ä½ñª ‚ª Ïϧ¬ |²‘ÏÏñª ¥¾´È‘ An occupied Entry.Á¥¾ÏÏ
Õˆ¥¾¥¾µ« ‚ª ÏϹ­ Œì‘Ïϵ« Ô¹’üƒ’52 A vacant Entry. It is part of the [`Entry`] enum.Á\Ä’ˆØØñª :6[nZ³uÙÐ’ÜÚ’4Ú’â××

ÿJŽ
LÀ 
handleÁÀ 
dormant_mapÁÀ 
áÀ 
ê·À ¬5Ž ì ´ˆ¥—Ò—þ²䳓üú’85 An occupied Entry. It is part of the [`Entry`] enum.Ál¾“ˆÛÛµ« %ÃRô¾%ôÜÌ“üÖ“DÖ“âÚÚ˜
˜
¨K
Ñ® À ž
ã® À Ÿ
áÀ  
ê·À ¿™n…ƒ×ßÓˆ¥—Ò—þ²Ä¢”»ü“ ÿ“ Ÿ”8Æ €” ƒ” ž”8<„” Œ”7ë
„Ž”üú“'|§”âˆÞÞ²¯ ·”Ôþ•»Ø• Û• û•8Æ Ü• ß• ú•8<à• è•7ë
„ê•üÖ•'Œƒ–âˆààÓ± •–”º—ˆâ₪ ãäåç¿—䥙üÓ—,) Returns a reference to this entry's key.Á„˜ËtŒ˜äŒŸ˜Ë<§˜Ú‘ü³˜)& let mut map = serde_json::Map::new();Áüá˜30 assert_eq!(map.entry("serde").key(), &"serde");Á<™™Ú‘¬™ ‚ª ¥—á °™á
ãˆ$±™üÂ7üšJG Ensures a value is in the entry by inserting the default if empty, andÁü‘›:7 returns a mutable reference to the value in the entry.ÁЛËtØ›äŒë›Ë<ó›Ú‘Üÿ›«Ó,Ÿœ´œü©œ)ó´ üל,) map.entry("serde").or_insert(json!(12));ÁˆËü! assert_eq!(map["serde"], 12);ÁÚ‘‚ª Ò—¤·áá
äˆ><ÙüÓ¢cü™ŸJG Ensures a value is in the entry by inserting the result of the defaultÁüèŸJG function if empty, and returns a mutable reference to the value in theÁT·  entry.ÁÆ ËtΠäŒá Ë<é Ú‘Üõ «Ó,•¡´œüŸ¡)ó´ üÍ¡85 map.entry("serde").or_insert_with(|| json!("hoho"));ÁŠ¢Ëü’¢0- assert_eq!(map["serde"], "hoho".to_owned());Á<Ç¢Ú‘tÚ¢‚ª ª@¤·áª@ææá©âÙ¾ é¢Ù¾ Œ¤£Ù¾ Ò—,°£
åˆÙ¾ $ì¢><ò¢OQü­©QüܤDA Provides in-place mutable access to an occupied entry before anyÁü¥¥# potential inserts into the map.ÁÍ¥ËtÕ¥äŒè¥Ë<ð¥Ú‘Üü¥«Ó,œ¦´œü¦¦)ó´ ´Ô¦ map.entry("serde")Áüï¦+( .and_modify(|e| *e = json!("rust"))ÁüŸ§! .or_insert(json!("cpp"));ÁŧËüͧ$! assert_eq!(map["serde"], "cpp");Áö§Ë´þ§ÏÀ ü™¨+ïÀ üɨ!¤Á ï¨Ëü÷¨%" assert_eq!(map["serde"], "rust");Á<¡©Ú‘T´©‚ª Ù¾ ‚ª áª@èèá‚¿ ¿©œÙ¾  œÒ—”멜پ ÚÄ 
çˆÙ¾ $©þ È©dfÄ쫈êêñª ëìñ«äï¯ü‹¬IF Gets a reference to the key that would be used when inserting a valueÁäÙ¬ through the VacantEntry.Áú¬Ët‚­äŒ•­Ë<­Ú‘ü©­ use serde_json::map::Entry;ÁÍ­ËüÕ­)ó´ ƒ®Ëô‹® match map.entry("serde") {Áü®®" Entry::Vacant(vacant) => {ÁüÕ®/, assert_eq!(vacant.key(), &"serde");ÁL‰¯¨úü—¯/, Entry::Occupied(_) => unimplemented!(),Á,˯Í‘<Õ¯Ú‘ö¯ ñª ¥—é ú¯é
ëˆ$û¯ü»´2ü³°IF Sets the value of the entry with the VacantEntry's key, and returns aÁä± mutable reference to it.Á¢±Ëtª±äŒ½±Ë<űÚ‘Üѱ«Ó,ñ±´œüû±œÆ Ÿ²Ëü§²)ó´ Õ²ËôݲêÆ ü€³"’Ç ü§³)& vacant.insert(json!("hoho"));ÁLÕ³¨úüã³/„È ,—´Í‘<¡´Ú‘4´ñª Ò—¤·éé
ìˆ$É´˜,Ï´Ô›µˆî ïðñòóôõ µäĹü¼µ-* Gets a reference to the key in the entry.ÁîµËtöµäŒ‰¶Ë<‘¶Ú‘Ü«Ó,½¶´œüǶœÆ ë¶Ëüó¶)ó´ ü¡·.+ map.insert("serde".to_owned(), json!(12));ÁÔ·ËôÜ·êÆ üÿ·&# Entry::Occupied(occupied) => {Áüª¸1. assert_eq!(occupied.key(), &"serde");ÁLศúüî¸-* Entry::Vacant(_) => unimplemented!(),Á, ¹Í‘<ª¹Ú‘˹ž žµ« ž¥—í Ϲí
ïˆ$йÜŽ¾üŠº/, Gets a reference to the value in the entry.Á¾ºËtƺäŒÙºË<áºÚ‘Üíº«Ó,»´œü—»œÆ »»Ë
„Òöü¾ö'DëöâˆüüÍ¿rangeÁÀ šÌ·À OçjåQÿˆ¥—Ò—ôöüŠù4ˆþþˆœÿ¯J°J±JùLÅù$ÊùýýÚï ¤·lòùD÷ùýýšœü¡ú$L¤úˆœˆœ°Jýý
ˆ$®ú¤½ü»—ü šü ºü8Æ ›ü žü ¹ü8<Ÿü §ü7ë
„©üü•ü'\Âü∃ƒ¤¤ùÀ¨çð À ©Ì·À ªê·À ¦Èvl‹}è'ˆ¥—Ò—Îüüôþ(ø–¯J°J±JL£ÿ$¨ÿ´šlÄÿDÉÿŒüðÿ$Lóÿø–ø–°J
$ýÿŒˆ‚»â å …‚8Æ æ é „‚8 ò7ë
„ôüà'dâ´´ÕM¸çð À ¹Ì·À ºáÀ ùW Éý¤Ì[¥—Ò—þ²ŒÄ…»ž… ¡… Á…8Æ ¢… ¥… À…8<¦… ®…7ë
„°…üœ…'DɅ∊ŠÊÊæÂζqÀ ù¬âR˜æÄˆ¥—Ò—Ò…œ»Ûˆ Þˆ þˆ8Æ ߈ ∠ýˆ8<㈠ëˆ7ë
„íˆüÙˆ'T†‰âˆŒŒÓÓŠÄ×¶qÀ ̪¥
{(%ˆ¥—Ò—‘‰´ÍŒ»§Œ ªŒ ÊŒ8Æ «Œ ®Œ ÉŒ8<¯Œ ·Œ7ë
„¹Œü¥Œ'lҌ∎ŽÜܰÅà¶qÀ ¾Èkú°;Vˆ¥—Ò—àŒœ¦» ƒ £8Æ   ¢8<ˆ 7ë
„’üþ'âññÄÆõ¶qÀ JËä¬Í¼¿¥—Ò—þ²\Ån»€n ƒn “n8<„n Œn7,Žn¼þmü30 Serialize a Rust data structure into JSON data.ÁÍn¢ñ¹¾¿ñãæéêëìíîïðñòô÷úüþžŸ¦,HùÊLOŒý4Zû˜@nö
4…ÉH­ØßAÍÁ]å`š²$‡² 
FpCategoryÁTœìΜœ²›sÚ Ÿ
ImpossibleÁTί
  SerializeÁLÚ®A¡ü9(AD36%(Lg¬v þÔáïçàâTÓ¬‘ºL¬ªü»)œÂƒiküÍ.üç63 A structure for serializing Rust values into JSON.ÁýO£ª@¤£¤©âýO ã‚¿ ¤æ¢¢ëO¥ŽP¦œPL_
ˆ‹4ðÜ
Ù¾ L_
ˆ‹4ðÜ¥¦dfi æû¤L‚4‚¢¢
d‘L‘¢¢Ù¾ ü¢-ýO¨¨ùƒ
§ß
¢¢ëO¥ŽP¦œPL_
ˆ‹4ðÜ
û¤©XZì‹üÖ" Creates a new JSON serializer.Á
ø…
§§
©
ŽP4–üñFˆ«ýO¬¬«©âס úßס¢¢ëO¥ŽP¦œPL_
ˆ‹4ðÜסÉ¥­ö^`ü€ ü¾/, Creates a new JSON pretty print serializer.Á4‡ס†ˆ
ªª
­ˆסŽP4ŽüïEýO¯ª@°¯°ùƒ
ô‚¿ ÷é…
Ù¾ “„
±².035üª 6ü»IF Creates a new JSON visitor whose output will be written to the writerÁt‰  specified.Át± 
Ù¾ “„
®®
±
Ù¾ ŽP4À œPLË äØ
ü—
.+ Unwrap the `Writer` from the `Serializer`.ÁTß
“„
®®
²
Ù¾ 
ü” eˆ´ýOµª@´µæ‡
©âÝ¡   ÷‡
Ý¡ ˜¡·¸¹º»¼½¾¿ÀÁÂÃÄÅÆÇÈÉÊËÌÍÏÐÑÒÓÔÖØÙÛÜÝÞßàáâ²A³A´AµA¶A·A¸A¹AºA»A¼A½A¾A¿AÀAÁAÂAÃAÄAÅAÆAÇAÈAÉAÊAÎAÏAÐAÑAÓAËAÌAÕAÖA×AØAÙAÚAÛAâAÇÝÊàÍÐÓÀÖÃÙÆÜÉßÌâÏÒÂØÅÛÈÞËáÑÔÁÄ ËÎÉÌ<€  ³³T’ ,— ³³Á‘Œ«  ³³¯£œ×  ³³¯£Ì…
¤Š
³³¯£Ô¹
¬¾
³³¯£Œî

³³¯£¤š³³¯£Üɴγ³¯£üŽ2t‘˜¡á§³³
ÀˆסÝ¡˜üÄ.˜¡á§³³
ÁˆסÝ¡˜üô0˜¡á§³³
ˆסÝ¡$…˜,‹ü§0˜¡á§³³
ÈסÝ¡˜üÚ0˜¡á§³³
ĈסÝ¡˜üÿ2t‚˜¡á§³³
ňסÝ¡$‘˜,—üµ.˜¡á§³³
ƈסÝ¡˜üå0˜¡á§³³
LjסÝ¡˜ü˜0l›˜¡á§³³
ȈסÝ¡˜üË0˜¡á§³³
ɈסÝ¡˜üð2˜¡á§³³
ʈסÝ¡$‚˜ü¦0˜¡á§³³
ˈסÝ¡˜üÐ!0lÓ!˜¡á§³³
̈סÝ¡$á!˜,ç!üú$2tý$˜¡á§³³
͈סÝ¡$Œ%˜,’% ƒ&ÍÍüØ&1lÛ&¢˜¡ ¢á§³ ö&³
ψסÝ¡$é&˜,ï&ü(4|„(£˜¡ £Ž˜á§³ ¡(³
ЈסÝ¡$”(˜,š(ü¿)%tÂ)˜¡á§³³
шסÝ¡$Ñ)üá*A¬ä*˜¡Ÿá§³³
ÒˆסÝ¡$ú*ýœ,€+üÜ+•´ß+˜¡ŸŸá§³³
ÓˆסÝ¡$ÿ+ýœ,,_variant_indexÁtª,¥~<Ç,üç-{ü£-1. Serialize newtypes without an object wrapper.ÁÄê-¤˜¡Ÿ ¤ã°á§³ÕÕ ¨.³ªâã° ƒ.®Aã°LØ.
ÔˆסÝ¡ã°$†.ýœ,Œ.˜,¡.CEü /×Ì£/¥˜¡ŸŸ ¥ã°á§³×× ·0³ó¢
½/„£
Lí0
ÖˆסÝ¡ã°$É/ýœ,×/» 
tô/¥~<0˜,°0LNü·7%tº7˜¡á§³³
؈סÝ¡$É7ü–8\t™8¦˜¡ ¦ã°á§³ÚÚ ¸8³ó¢
¨8„£
Lè8
ÙˆסÝ¡ã°$«8˜,±824ü°9Hl³9˜¡ø°ú°û°Ðü°ý°þ°ìHˈXêE>ê³í³î³Òï³ìð³ñ³ò³ìäs{©¶˜¡´AÁ‘³³
ÛˆסÝ¡$Á9¾ Ç9ü¡>D|¤>˜¡ê³í³î³Òï³ìð³ñ³ò³ìäs{©¶˜¡µAÁ‘³³
܈סÝ¡$´>¾ º>ü§?…´ª?˜¡Ÿê³í³î³Òï³ìð³ñ³ò³ìäs{©¶˜¡¶AÁ‘³³
݈סÝ¡$Ê?ýœ,Ø?¾ õ?üî@üñ@˜¡ŸŸê³í³î³Òï³ìð³ñ³ò³ìäs{©¶˜¡·AÁ‘³³
ÞˆסÝ¡$’Aýœ, A» 
t½A¥~<ÚA¾ ùAüŒGHlG˜¡ª§
ê³í³î³Òï³ìð³ñ³ò³ìäs{©¶˜¡¸AÁ‘³³
߈סÝ¡$G¾ £GüÿKZ„‚L˜¡Ÿê³í³î³Òï³ìð³ñ³ò³ìäs{©¶˜¡¹AÁ‘³³
àˆסÝ¡$“Lÿ
$™L¾ ­Lü±OÅÄ´O˜¡ŸŸê³í³î³Òï³ìð³ñ³ò³ìäs{©¶˜¡ºAÁ‘³³
áˆסÝ¡$ÖOýœ,äO» 
tP¥~<žP¾ ½PüÃUW\ÆU§˜¡ §ã°á§³ãã âU³ó¢
ÒUå`ã°<V
âˆסÝ¡ã°$ÕU˜,ÛU:<„­V,¸VüÈV&<ÏVYæýOçª@èèçææ‡
ÝVß
æVסY$àVÝ¡Y$éV¢´
œýV±´
´žWë¡‚AKC´ªPèéêë$×V]_æegæO4ýVåå YסhLžWåå YÝ¡ÄÂW,ÂWååø°ú°û°Ðü°ý°þ°ìHˈXêE>”‘üïWpYíýOîª@ïíîïæ‡
úWß
ýW÷‡
L»Xø
LÕXë¡ðŒ`ð$ôW1368üöX/LùX¨© ¨ë¡ ©€•ì ƒYì
ðYסÝ¡$ˆYö ŽYüÇb#¡ºb ½b Äb8°4¾bt¸bDÐbˆòýOóª@ôôòóæ‡
Ýbß
äbסˆàbÝ¡ˆçb³¹
ìÿb¹
¯£¢¬8sÎ9N­õö÷Ùb[]òceòñbññ¯£gÿbññ˜¡d¦c,¦cññÅ¢üêdaˆùýOúª@ûùúûæ‡
ódß
öd÷‡
L¯eø
LÁe¯£üýþèAéAêAìAþïdJLOQ<Òe×eøøTäe,éeøøÁ‘ü‹fdŒŽfª« ª¯£ «ã°á§øÿÿ £føó¢
 f„£
Låf
þˆסÝ¡ã°$¨f˜,®f24Ô¿lÂl¯£á§øø
ˆסÝ¡$Ælü•pcˆýOƒª@ƒæ‡
žpß
¡p÷‡
LÜpø
Lîp¯£îAïAðAòAšpJLOQ<ÿp„qTq,–qÁ‘ü¸qdŒ»q¬­ ¬¯£ ­ã°á§ˆˆ Ðqó¢
Íq„£
Lr
ˆסÝ¡ã°$Õq˜,Ûq24Ôörùr¯£á§
ˆסÝ¡$ýrüÁsiˆýOŒª@Œæ‡
Êsß
Ís÷‡
LŽtø
L t¯£ŽôAõAöAøAÆsJLOQ<±t¶tŠŠTÃt,ÈtŠŠÁ‘üêtb|ít®¯ ®¯£ ¯ã°á§Š €uŠó¢
ýt„£
LÂu
ˆסÝ¡ã°$…u˜,‹u24Ô¦v©v¯£á§ŠŠ
ˆסÝ¡$­vüñvjˆýOª@æ‡
úvß
ýv÷‡
L¿wø
LÑw¯£˜úAûAüAþAövJLOQ<âwçwTôw,ùwÁ‘ü›xb|žx°± °¯£ ±ã°á§šš ±xó¢
®x„£
Lóx
ˆסÝ¡ã°$¶x˜,¼x24Ô×yÚy¯£á§
ˆסÝ¡$Þyü¿aˆýOžª@ŸŸžæ‡
Èß
Ë÷‡
L„€ø
L–€¯£ ¡¢¤¦€BB‚B„B‰B¤¢¦ÄWY\^<§€¬€œœT¹€,¾€œœÁ‘üà€^l〲³ ²¯£ ³ã°á§œ££ ô€œó¢
񀄣
L´
¢ˆסÝ¡ã°$ù€‚Lÿ€68ü ‡b|£‡´µ ´¯£ µã°á§œ¥¥ ¶‡œó¢
³‡„£
Lø‡
¤ˆסÝ¡ã°$»‡˜,Á‡68Ô“¯£á§œœ
¦ˆסÝ¡üêdˆ¨ýO©ª@ª¨©ªæ‡
óß
ö÷‡
L²‘ø
LÄ‘¯£«¬­¯‹BŒBBB­¯ïOQSU<Õ‘Ú‘§§Tç‘,ì‘§§Á‘üŽ’u|‘’· ¯£Ÿ ·ã°á§§®® ¤’§ó¢
¡’„£
Lù’
­ˆסÝ¡ã°$©’‚L¯’˜,Â’?AÔø˜û˜¯£á§§§
¯ˆסÝ¡$ÿ˜ü½›kˆ±ýO²ª@³³±²æ‡
Æ›ß
É›÷‡
LŒœø
Lžœ¯£´µ¸’B“B”B—B¸›OQSU<¯œ´œ°°TÁœ,Æœ°°Á‘üèœu|뜸¹ ¸¯£Ÿ ¹ã°á§°·· þœ°ó¢
ûœ„£

ˆסݡ㰂L˜?AÔÈ Ë ¯£á§°°
¸ˆסÝ¡$Ï ü±¦)„¸¦ˆºýO»ª@¼¼º»æ‡
ͦß
Ô¦³¹
Ц¹
צ³¹
ìᦹ
 ¹¤ŸLתêg\d½ɦOQºVXºKᦹ¹˜¡üø¨"¤û¨Á‘
¾üÕ©&ÄØ©Á‘
¿üºªgˆÁýOª@ÃÁÃÂæ‡
êß
ƪ÷‡
L…«ø
L—«¹¤ÄÅÆÇÈÊËÌÍÎÏÐÑÒÓÔÕÖרÙÚÛÜÝÞàáâãåæèéêëìíîï²A³AÉAÐAÑA´AµA¶A·A¸A¹AºA»A¼A½A¾A¿AÀAÁAÂAÃAÄAÅAÆAÇAÈAÊAÎAÏAÓAËAÌAÕAÖA×AØAÙAÚAÛAâAÈÞáÑÔê×íÚÇÝàãæÓéÖìÙïÆÜâåÒèÕëØîÛ¿ª¿ÂÅÈ<¨«­«ÀÀTº«,¿«ÀÀÁ‘üá«1l䫺¹¤ ºá§À ÿ«À
ƈסÝ¡$ò«˜,ø«üÔ¬´×¬¹¤ŸŸá§ÀÀ
LjסÝ¡$÷¬ýœ,…­» 
t¢­¥~<¿­ü­®{İ®»¹¤Ÿ »ã°á§ÀÉÉ î®Àó¢
É®„£
Lž¯
ȈסÝ¡ã°$Ì®ýœ,Ò®˜,ç®@BŒØ¯dݯÀÀ¯
¯
î€
²
voidÁ£
³
okÁ£
´
à £
Õaýì¨ÛÁ‘œ‡°tŒ°ÀÀ¦á
̸°¤½°ÀÀ¦á
Ôï°¬ô°ÀÀ¦á
Œ§±d¬±ÀÀ¦á
¤Ö±|Û±ÀÀ¦á
܈²´²ÀÀ¦á
ü²2tŲ¹¤á§ÀÀ
шסÝ¡$Ô²˜,Ú²ü•¶.d˜¶¹¤á§ÀÀ
ÒˆסÝ¡$¥¶˜,«¶üâ¹0lå¹¹¤á§ÀÀ
ÓˆסÝ¡$ó¹˜,ù¹ü²½0lµ½¹¤á§ÀÀ
ÔˆסÝ¡$ý˜,ɽü‚Á0l…Á¹¤á§ÀÀ
ÕˆסÝ¡$“Á˜,™ÁüÒÄ2tÕŤá§ÀÀ
ÖˆסÝ¡$äĘ,êÄü¥È.d¨È¹¤á§ÀÀ
׈סÝ¡$µÈ˜,»ÈüòË0lõ˹¤á§ÀÀ
؈סÝ¡$ƒÌ˜,‰ÌüÂÏ0lÅϹ¤á§ÀÀ
ÙˆסÝ¡$ÓϘ,ÙÏü’Ó0l•Ó¹¤á§ÀÀ
ÚˆסÝ¡$£Ó˜,©ÓüâÖ2tåÖ¹¤á§ÀÀ
ÛˆסÝ¡$ôÖ˜,úÖüµÚ0l¸Ú¹¤á§ÀÀ
܈סÝ¡$ÆÚ˜,ÌÚüäÞ0lçÞ¹¤á§ÀÀ
݈סÝ¡$õÞ˜,ûÞü“ã2t–㹤á§ÀÀ
ÞˆסÝ¡$¥ã˜,«ã „äÞÞü”ä5|—ä¼¹¤ ¼Ž˜á§À µäÀ
àˆסÝ¡$§ä_valueÁ4­äüûä%tþ乤á§ÀÀ
áˆסÝ¡$åüÒåA¬Õ幤Ÿá§ÀÀ
âˆסÝ¡$ëåýœ,ñåüÅæÙÌÈæ½¹¤ŸŸ ½ã°á§Àää ÞçÀó¢
âæ„£
Lӏ
ãˆסÝ¡ã°$îæýœ,üæ» 
t™ç_variantÁD¶çâí
4Öç\^üÔè%t×蹤á§ÀÀ
åˆסÝ¡$æèü«é\t®é¾¹¤ ¾ã°á§Àçç ÍéÀó¢
½é„£
Lýé
æˆסÝ¡ã°$Àé˜,Æé68ü·êIlºê¹¤ª§
ê³í³î³Òï³ìð³ñ³ò³ìäs{©¶¹¤´AÁ‘ÀÀ
èˆסÝ¡$Èê«¡$Îêü²ëE|µë¹¤ê³í³î³Òï³ìð³ñ³ò³ìäs{©¶¹¤µAÁ‘ÀÀ
éˆסÝ¡$Åë«¡$Ëëü©ì´¬ì¹¤Ÿê³í³î³Òï³ìð³ñ³ò³ìäs{©¶¹¤¶AÁ‘ÀÀ
êˆסÝ¡$Ììýœ,Úì«¡$÷ìüáíżäí¹¤ŸŸê³í³î³Òï³ìð³ñ³ò³ìäs{©¶¹¤·AÁ‘ÀÀ
ëˆסÝ¡$…îýœ,“î» 
t°î×ð
DÍî«¡$íîüØïIlÛ﹤ª§
ê³í³î³Òï³ìð³ñ³ò³ìäs{©¶¹¤¸AÁ‘ÀÀ
ìˆסÝ¡$éï«¡$ïïüÓð\„Ö𹤟ê³í³î³Òï³ìð³ñ³ò³ìäs{©¶¹¤¹AÁ‘ÀÀ
íˆסÝ¡$çðýœ,íð«¡$‚ñüáñÇÄäñ¹¤ŸŸê³í³î³Òï³ìð³ñ³ò³ìäs{©¶¹¤ºAÁ‘ÀÀ
îˆסÝ¡$†òýœ,”ò» 
t±ò×ð
DÎò«¡$îòüÚóW\Ý󿹤 ¿ã°á§Àðð ùóÀó¢
éóƒ³
<©ô
ïˆסÝ¡ã°$ìó˜,òó68œ’ÁüÔÀ=: Represents a character escape code in a type-safe manner.ÁT›ÁÏÿ°};–jàòóôõö÷øùúûüýþÿƒóõ÷ùûýÿƒÏÿ,ÉÁĬÁ An escaped quote `"`Á(ññÏÿ<>ññÏÿtûÁüÔÁ" An escaped reverse solidus `\`Á3ññÏÿGIññÏÿ<®ÂÔ An escaped solidus `/`Á*ññÏÿ>@ññÏÿLüÂü»Â<9 An escaped backspace character (usually escaped as `\b`)ÁMññÏÿacññÏÿDÌÃü‹Ã<9 An escaped form feed character (usually escaped as `\f`)ÁMññÏÿacññÏÿD›ÄüÚÃ<9 An escaped line feed character (usually escaped as `\n`)ÁMññÏÿacññÏÿtðÄü©ÄB? An escaped carriage return character (usually escaped as `\r`)ÁSññÏÿgiññÏÿ¿Åü„Å63 An escaped tab character (usually escaped as `\t`)ÁGññÏÿ[]ññÏÿ!¿üÈÅ@= An escaped ASCII plane control character (usually escaped asÁüÆ/, `\u00XX` where `XX` are two hex characters)Á!¿ññ
ƒ!¿!¿Ïÿññˆ‹ ÎÆññœãÇüÖÆ_\ This trait abstracts away serializing the JSON control characters, which allows the user toÁü¶Ç,) optionally pretty print the JSON output.ÁLíǪâüãÇð[ž ž !†ˆŠŒŽ˜šœž ¢¤¦¨ª¯±³µ·¹»½¿ÁÃÅˆŠŒŽ˜šœž ¢¤¦¨ª¯±³µ·¹»½¿ÁÃųР¹¦¿¯ÅœµŒ¢»¨Á˜±ˆž·Ž¤½ªÃšüÂÈfüýÇ2/ Writes a `null` value to the specified writer.ÁTÅÈÀÁ À¦  Áסê³í³î³Òï³ìð³ñ³ò³ìäs{©¶”‘ýO ÓȪâס ÐÈ÷‡
LžÉ
¦ ס$ØÈŽP4ÞÈ,.ü¬ÊsüÜÉ=: Writes a `true` or `false` value to the specified writer.ÁT¯ÊÂà ¦  Ãסè ýO ½Êâ‘ ºÊ÷‡
L•Ë
ˆ¦ ס$ÂÊŽP4Èʘ,ØÊ57ü’Íoü¿Ì@= Writes an integer value like `-123` to the specified writer.ÁD•ÍÄŠĦ  Åסè ýO ¡Íâ‘ žÍ÷‡
L÷Í
Ц ס$¦ÍŽP4¬Í˜,¼Í57üáÏqüŽÏ@´“ LäÏÆÇ Æ¦  Çסè ýO ñÏâ‘ îÏ÷‡
LÈÐ
Œ¦ ס$öÏŽP4üϘ,ŒÐ57ü²ÒqüßÑ@´“ LµÒÈÉ È¦  Éסè ýO ÂÒâ‘ ¿Ò÷‡
L™Ó
ަ ס$ÇÒŽP4ÍÒ˜,ÝÒ57üƒÕqü°Ô@´“ L†ÕÊË Ê¦  Ëסè ýO “Õâ‘ Õ÷‡
LêÕ
¦ ס$˜ÕŽP4žÕ˜,®Õ57üÔ×sü×@´“ T××ÌÍ Ì¦  Íסè ýO å×â‘ â×÷‡
L½Ø
¦ ס$ê׎P4ðט,€Ø57ü¦ÚoüÔÙ?< Writes an integer value like `123` to the specified writer.ÁD©ÚÎÏ Î¦  Ïסè ýO µÚâ‘ ²Ú÷‡
L‹Û
¦ ס$ºÚŽP4ÀÚ˜,ÐÚ57üôÜqü¢Ü?Ä› L÷ÜÐÑ Ð¦  Ñסè ýO „Ýâ‘ Ý÷‡
LÛÝ
¦ ס$‰ÝŽP4ݘ,ŸÝ57üÄßqüòÞ?Ä› LÇßÒÓ Ò¦  Óסè ýO Ôßâ‘ Ñß÷‡
L«à
˜¦ ס$ÙߎP4ßߘ,ïß57ü”âqüÂá?Ä› L—âÔÕ Ô¦  Õסè ýO ¤ââ‘ ¡â÷‡
Lûâ
š¦ ס$©âŽP4¯â˜,¿â57üääsü’ä?Ä› TçäÖ× Ö¦  ×סè ýO õäâ‘ òä÷‡
LÍå
œ¦ ס$úäŽP4€å˜,å57üˆìqüäæLI Writes a floating point value like `-31.26e+12` to the specified writer.ÁµçËœ½ç # Special casesÁÕçËüÝçFC This function **does not** check for NaN or infinity. If the inputÁü¨èIF number is not a finite float, the printed representation will be someÁüöè85 correctly formatted but unspecified numerical value.Á³éËü»éHE Please check [`is_finite`] yourself before calling this function, orÁüˆêHE check [`is_nan`] and [`is_infinite`] and handle those cases yourselfÁüÕê(% with a different `Formatter` method.Á‚ëËüŠë! [`is_finite`]: f32::is_finiteÁܰë [`is_nan`]: f32::is_nanÁüÐë%" [`is_infinite`]: f32::is_infiniteÁL‹ìØÙ ئ  Ùסè ýOŸŸ ˜ìâ‘ •ì÷‡
Lïì
ž¦ ס$ìŽP4£ì˜,³ì57ü±óqüîLÓ£ ÞîËœæî´¤ þîËü†ïFݤ üÑïI­¥ üŸð8€¦ ÜðËüäðHΦ ü±ñH § üþñ(ò§ «òËü³ò! [`is_finite`]: f64::is_finiteÁÜÙò [`is_nan`]: f64::is_nanÁüùò%" [`is_infinite`]: f64::is_infiniteÁL´óÚÛ Ú¦  Ûסè ýO¡¡ Áóâ‘ ¾ó÷‡
L˜ô
 ¦ ס$ÆóŽP4Ìó˜,Üó57üˆöyü¶õ?< Writes a number that has already been rendered to a string.Á„‹öÜÝÞ Ü¦  Ýס Þè ýO££ Ÿöâ‘ œö÷‡
L÷ö
¢¦ ס$¤öŽP4ªö˜,ºö57üÑøhü¾÷<9 Called before each series of `write_string_fragment` andÁüÿ÷?< `write_char_escape`. Writes a `"` to the specified writer.ÁdÔøßà ߦ  àסè ýO¥¥ äøâ‘ áø÷‡
L¯ù
¤¦ ס$éøŽP4ïø,.üýúfüëù;8 Called after each series of `write_string_fragment` andÁü«ú?б T€ûáâ ᦠ âסè ýO§§ Žûâ‘ ‹û÷‡
LÙû
¦¦ ס$“ûŽP4™û,.ü„ýü•üB? Writes a string fragment that doesn't need any escaping to theÁ¬Üü specified writer.Á¬‡ýãäå 㦠 äס åè ýO©©  ýâ‘ ý÷‡
Lûý
¨¦ ס$¥ýŽP4«ýfragmentÁD»ý=?ü“ÿüÅþ;8 Writes a character escape code to the specified writer.ÁŒ–ÿæç æ¦  çסÏÿè ýO«« «ÿâ‘ ¨ÿ÷‡
L
ª¦ ס$°ÿŽP4¶ÿ char_escapeÁ\Æÿ@B„¬€ÜæƒTíƒ0123456789abcdefþƒüþˆzü®‡LI Writes the representation of a byte array. Formatters can choose whetherÁüÿ‡IF to represent bytes as a JSON array of integers (the default), or someÁü͈,) JSON string encoding like hex or base64.Á„èéê è¦  éס ꎘè ýO°° •‰â‘ ’‰÷‡
Lî‰
¯¦ ס$š‰ŽP4 ‰˜,°‰57ü©güÉŒ=: Called before every array. Writes a `[` to the specifiedÁ\ writer.Á\¬ëì ë¦  ìסè ýO²² »â‘ ¸÷‡
L†Ž
±¦ סŽP4Æ,.ü eüÁŽ<9 Called after every array. Writes a `]` to the specifiedÁ\ˆ¾ íî í¦  îסè ýO´´ °â‘ ­÷‡

³¦ סŽP4»,.ü¦‘zü¶?< Called before every array value. Writes a `,` if needed toÁÌú the specified writer.ÁŒ©‘ïð ï¦  ðסè ýO ¾‘â‘ »‘÷‡
L–’
µ¦ ס$ÑŽP4É‘Û+,Ù‘57üÌ“lü–“# Called after every array value.Á|Ï“ñò ñ¦  òסè ýO¸¸ â“â‘ ß“÷‡
L®”
·¦ ס$ç“_writerÁ<í“35üº•hüÙ”>; Called before every object. Writes a `{` to the specifiedÁ\œ•ˆ¾ d½•óô ó¦  ôסè ýOºº ͕①ʕ÷‡
L˜–
¹¦ ס$Ò•ŽP4Ø•,.ü³—füÓ–=: Called after every object. Writes a `}` to the specifiedÁ\•—ˆ¾ T¶—õö õ¦  öסè ýO¼¼ Ä—â‘ Á—÷‡
L˜
»¦ ס$É—ŽP4Ï—,.ü€™yüʘ# Called before every object key.Á„ƒ™÷ø ÷¦  øסè ýO¾¾ —™â‘ ”™÷‡
Lï™
½¦ ס$œ™ŽP4¢™Û+,²™57ü”œküïšB? Called after every object key. A `:` should be written to theÁü¶›-* specified writer by either this method orÁÌè› `begin_object_value`.Át—œùú ù¦  úסè ýOÀÀ ©œâ‘ ¦œ÷‡
Lõœ
¿¦ ס$®œ™Å <´œ-/üÄžnü A> Called before every object value. A `:` should be written toÁüæ1. the specified writer by either this method orÁ¬œž `end_object_key`.Á”Çžûü û¦  üסè ýO ݞ①ڞ÷‡
L¨Ÿ
Á¦ ס$➎P4èž,.üš müãŸ$! Called after every object value.Á„ ýþ ý¦  þסè ýOÄÄ ± â‘ ® ÷‡
Lý 
æ ס$¶ ™Å <¼ -/ü™¢~ü¨¡DA Writes a raw JSON fragment that doesn't need any escaping to theÁ¬ñ¡ȵ ”œ¢ÿ ÿ¦  ס è ýOÆÆ ²¢â‘ ¯¢÷‡
L£
Ŧ ס$·¢ŽP4½¢†· DÍ¢68üפ#û¤äʦˆÉÉÉ¥ÊËϦ¤Í§üí¦[X Construct a pretty printer formatter that defaults to using two spaces for indentation.ÁÔ§É¥ÈÈ
ʈü÷¨,ü›¨WT Construct a pretty printer formatter that uses the `indent` string for indentation.Á\þ¨ˆ˜É¥ÈÈ
ˈ†p4Š©ü¤ª(ˆÍÍÉ¥ÎÅΩª¤Óª<֪ɥÌÌ
Έü’«*ˆÐÐÉ¥ÑÓÕ×ÙÛÝßá±³µ·¹»½Áà ßÛ×ÓáÝÙÕÑ—«üÑ«g\Ô«ƒ É¥ ƒסè ÏýOÒÒ ã«Ïâ‘ à«÷‡
L®¬
шס$諎P4î«.0ü¹­eL¼­ É¥ סè ÏýOÔÔ É­Ïâ‘ Æ­÷‡
L”®
Óˆס$έŽP4Ô­.0ü–°zŒ™° É¥ סè ÏýOÖÖ ®°Ïâ‘ «°÷‡
L†±
Õˆס$³°ŽP4¹°Û+,ɰ79ü­²l|°²ˆ ˆÉ¥ סè ÏýOØØ òÏâ‘ À²÷‡
L³
׈ס$Ȳ™Å <β/1üç³hd곊 ŠÉ¥ סè ÏýOÚÚ ú³Ïâ‘ ÷³÷‡
LÅ´
Ùˆס$ÿ³ŽP4…´.0üеfTÓµŒ ŒÉ¥ סè ÏýOÜÜ áµÏâ‘ Þµ÷‡
L¦
Ûˆס$济P4ìµ.0ü®¸y„±¸Ž ŽÉ¥ סè ÏýOÞÞ ŸÏ①¸÷‡
L¹
݈ס$ʸŽP4иÛ+,à¸79üĺn”Ǻ É¥ סè ÏýOàà ݺÏâ‘ Úº÷‡
L¨»
߈ס$⺎P4èº.0üò»m„õ» É¥ סè ÏýOââ ‰¼Ïâ‘ †¼÷‡
LÕ¼
áˆס$޼™Å <”¼/1ü½” ½ 
 Ù¾  è ýOäª@åäå Á½ªâ
³½ªâÙ¾ ¶½é…
L‘¾©Š
L¬¾
ã
Ù¾ ŽP4¹½œPLɽ˜,ܽQSLNüÈ¿±ÜË¿˜ 
 ˜Ù¾  è ýOçª@èèç ú¿ôç 翆è ê¿é…
LÔÀ©Š
LïÀ
æ
Ù¾ ŽP4ò¿œPL†À˜,ÀHJLNd’͘Íd¯ÍµÍdÌÍÒÍdéÍïÍd†ÎŒÎd£Î©ÎdÀÎÆÎdÞÎäÎd˜ÏžÏÄËÐ4ÒÐuuuuuuuubtnufruuuuuuuuuuuuuuuuuu"\ßÐü«Ýmü¿ÚC@ Serialize the given data structure as JSON into the I/O stream.ÁƒÛËü‡ÛOL Serialization guarantees it only feeds valid UTF-8 sequences to the writer.Á×ÛËdÛÛϱèÛËüìÛLI Serialization can fail if `T`'s implementation of `Serialize` decides toÁü¹Ü85 fail, or if `T` contains a map with non-string keys.ÁL²Ýš
šϳá§ýOõöõö ÔÝùƒ
¼Ýªâϳ ¿Ýé…
LóÝ®AϳLŽÞ
ô
ϳŽP4Âݘ,ÍÝPRKMüæátüçÞJG Serialize the given data structure as pretty-printed JSON into the I/OÁ\²ß stream.Á¾ßËüÂßOãî ’àËd–àϱ£àËü§àLáï üôà8·ð „íá
ϳá§ýOøùøù –âùƒ
þáÚò âé…
Lµâõò LÐâ
÷
ϳŽP4„â˜,â?ACEüåOü¬ã=: Serialize the given data structure as a JSON byte vector.ÁêãËdîãϱûãËüÿãLáï üÌä8·ð 4–åœ œø²ê³í³î³Òï³ìð³ñ³ò³ìäs{©¶ЊÁ‘ûû §åªâø² å®Aø²LÔå
úø²˜, å(*ü¼èVüÊæLI Serialize the given data structure as a pretty-printed JSON byte vector.Á—çËd›çϱ¨çËü¬çLáï üùç8·ð lÃè ø²ø ýý Ûèöø Ñèˆù Lˆé
üø²˜,Ôè "üæëQü…ê;8 Serialize the given data structure as a String of JSON.ÁÁêËdÅêϱÒêËüÖêLáï ü£ë8·ð Líëž žø²ê³í³î³Òï³ìð³ñ³ò³ìäs{©¶¥—Á‘ÿÿ ìöø ÷ëˆù L­ì
þø²˜,úë "üÒïXüâíJG Serialize the given data structure as a pretty-printed String of JSON.Á­îËd±îϱ¾îËüÂîLáï üï8·ð „ÙïŸ Ÿø²ý  ôïöø êïˆù L ð
ø²˜,íï "üÜñ_4ßñ ¡  
 ¡Ž˜è ýOƒƒ íñôç æñé…
L±ò

wrÁéñÔä õñö ÿñ57lønüMJ The Value enum, a loosely typed way of representing any valid JSON value.ÁN˼R # Constructing JSONÁjËünMÞÉü¼*´ÊçËÚ‘ÌóýÊË|‘©Ëü¡4ÁËÔÖýËüñ Ì´‘Ç̼¨åÌôÀ„ÍìߪÍÏÍ\‹äÍËü›>ƒÎÚËüÞ7ÕÎü–)•Ï͑ڑÎËüÒKêÏÔž½Ð¹Ëü½PëÐüŽNÄÑüÝN›ÒܬñÒÈËÚ‘ÜÔ«Ó´œüö$ÛÓ,› ´œü¡ ”ÔÜÁ »ÔÝ Ëüá 0êÔ´’
¢ÕÔ©
ÀÕüÄ
!ãÕœæ
Þüú
-™Ö ¼‘ ÚÖ Ú‘ ËüÆ IÚžü >; [`serde_json::from_str`][from_str] function. There is alsoÁüÏ HE [`from_slice`][from_slice] for parsing from a byte slice `&[u8]` andÁü˜
OL [`from_reader`][from_reader] for parsing from any `io::Read` like a File orÁŒè
 a TCP stream.Áú
Ë
Ú‘ü†)& use serde_json::{json, Value, Error};Á°Ëü´/, fn untyped_example() -> Result<(), Error> {ÁüäJ‘¢´¯ã¢£üÔ#—£Ôø£Ü“ä£ü¯"ˆ¤üÒ!³¤Œôܤ„†õ¤Ëü›;™¥ü×3Ý¥ËüE¤¦üÕOò¦¥ËÔ§Í‘´œüÄ! # untyped_example().unwrap();ÁÚ‘îËÄò„ìü‹#ðéü¯'œêü×)Ìê,€o¥Î² è ¬  ò
ô
±,”ù˜@¦ö
ÉH­ÕßAˆÍÁ]Šà`ã`å`Œˆ ÕœšsŽDeserializeOwnedÁ„®Þ;
®A›‘ñ ëOT‹Ù ëOÚ ŸC«ó÷Éñœ†i[¬®M?üÞ!2ä$'L…öL”çÜ£Ȭĸ”䨬€œ|Ÿ~¬¸q¤€%Ò—á`ü›%<ž%¢£¤ ¢Ò— £Á`Á`œÃ`è Á]Ä`ϱÁ]Ê­\É:•¤€• ¢%
$£%œPL©%´¾*Ò—˜æ`˜ü¿04üÛ*%" Display a JSON value as a string.Á…+Ë<+Ú‘Ü™+«Ó,¹+´œüÃ+JG let json = json!({ "city": "London", "street": "10 Downing Street" });Á,Ë´š, // Compact format:Á4µ, //ÁüÀ,52 // {"city":"London","street":"10 Downing Street"}Áüú,&# let compact = format!("{}", json);Á¼¥- assert_eq!(compact,ÁüÁ-B? "{\"city\":\"London\",\"street\":\"10 Downing Street\"}");Áˆ.ˬ. // Pretty format:Á4ª.ª” Dµ. // {ÁÔÂ. // "city": "London",Áüá.&# // "street": "10 Downing Street"ÁDŒ/ // }Áü™/'$ let pretty = format!("{:#}", json);Á´Å/ assert_eq!(pretty,Áüà/NK "{\n \"city\": \"London\",\n \"street\": \"10 Downing Street\"\n}");Á<³0Ú‘Â0¥¦§ ¥Ò— ¦Á`Á`œÃ`è Á]Ä`ϱÁ]Ê­\É:•§€• Æ0
˜$Ç0þ Í0üþ0"|…1ˆš¬qš¬qˆ1¼› ü¯1!¬q¬qíô°‘§NÅH½Ï°vœ•1™1=,¯1 ˆÁ`Á`œÃ`è Á]Ä`ϱÁ]Ê­\É:•¬qüå12ˆž¬qŸžŸ‘§ ¡àä¡ ê1î1ü¦24,©2¨© ¨‘§ ©Ž˜ê³í³î³Òï³ìð³ñ³ò³ìäs{©¶”‘ ¯2
 ˆ¬q$´2ϱº2ü”5%,—5ª ª‘§è  5
¡ˆ¬q$¢5üô5'D÷5Ñ•”‘
¢ €6œ9˜ð¸£ˆ¹£¥¹££˜£Á‘Ñ•ˆ:˜ð¸¤ˆ¹¤¥¹¤¤˜¤û  ü«:(\®:« «ª§
 ½:
¥ö º:TË;Ò—§©«¬­®¯°±²³´µ·¸¹º»¼½¾¿ÃÇÈüÝF7üÜ;JG Index into a JSON array or map. A string index can be used to access aÁü«<LI value in a map, and a usize index can be used to access an element of anÁTü< array.Á=Ëü“=GD Returns `None` if the type of `self` does not match the type of theÁüß=KH index, for example if the index is a string and `self` is an array or aÁü¯>JG number. Also returns `None` if the given key does not exist in the mapÁüþ>=: or the given index is not within the bounds of the array.ÁÀ?Ë<È?Ú‘ÜÔ?«Ó,ô?´œüþ?63 let object = json!({ "A": 65, "B": 66, "C": 67 });Áü¹@52 assert_eq!(*object.get("A").unwrap(), json!(65));Áó@Ëüû@)& let array = json!([ "A", "B", "C" ]);Áü©A30 assert_eq!(*array.get(2).unwrap(), json!("C"));ÁáAËüéA%" assert_eq!(array.get("A"), None);Á<“BÚ‘ŸBËü§BLI Square brackets can also be used to index into a value in a more conciseÁüøBLI way. This returns `Value::Null` in cases where `get` would have returnedÁ\ÉC `None`.ÁÙCË<áCÚ‘ÜíC«Ó,D´œÄ—D let object = json!({Áü´D "A": ["a", "á", "à"],ÁÔØD "B": ["b", "bÌ"],Áü÷D(% "C": ["c", "ć", "ć̣", "ḉ"],Á<¤EÚÖü°E+( assert_eq!(object["B"][0], json!("b"));ÁàEËüèE)& assert_eq!(object["D"], json!(null));Áü–F63 assert_eq!(object[0]["x"]["y"]["z"], json!(null));Á<ÑFÚ‘äF¬ ¬Ò—ø°ú°û°Ðü°ý°þ°ìHˈXêE>€¯ ¦¬r¨¨ òF¦©â èFñ ,ëF
§$óFö,ùF,.üÔMCüÁGIF Mutably index into a JSON array or map. A string index can be used toÁüHGD access a value in a map, and a usize index can be used to access anÁÄÛH element of an array.ÁøHËü€IGê£ üÌIKº¤ üœJJŽ¥ üëJ=ᥠ­KË<µKÚ‘ÜÁK«Ó,áK´œüëK:7 let mut object = json!({ "A": 65, "B": 66, "C": 67 });ÁüªL.+ *object.get_mut("A").unwrap() = json!(69);ÁÝLËüåL-* let mut array = json!([ "A", "B", "C" ]);Áü—M,) *array.get_mut(2).unwrap() = json!("D");Á<ÈMÚ‘<ÛM­ ­Ò—ø°ú°û°Ðü°ý°þ°ìHˈXêE>‘µ ¦¬rªª íM¦ü¯ ãM° ,æM
©$òMö,øM$&üúRüÈNFC Returns true if the `Value` is an Object. Returns false otherwise.Á“OËü›ODA For any Value on which `is_object` returns true, `as_object` andÁüäOJG `as_object_mut` are guaranteed to return the map representation of theÁ\³P object.ÁÃPË<ËPÚ‘Ü×P«Ó,÷P´œüQGD let obj = json!({ "a": { "nested": true }, "b": ["an", "array"] });ÁÍQËìÕQ assert!(obj.is_object());Áü÷Q" assert!(obj["a"].is_object());ÁžRËܦR // array, not an objectÁüÆR# assert!(!obj["b"].is_object());Á<îRÚ‘LS® ®Ò—¦ ‹S¦
«$ŒSü¨W6üÊSIF If the `Value` is an Object, returns the associated Map. Returns NoneÁt˜T otherwise.Á«TË<³TÚ‘Ü¿T«Ó,ßT´œüéTEB let v = json!({ "a": { "nested": true }, "b": ["an", "array"] });Á³UËü»U30 // The length of `{"nested": true}` is 1 entry.ÁüóU52 assert_eq!(v["a"].as_object().unwrap().len(), 1);Á­VËüµV41 // The array `["an", "array"]` is not an object.ÁüîV)& assert_eq!(v["b"].as_object(), None);Á<œWÚ‘L¯W¯ ¯Ò—ø°ú°û°Ðü°ý°þ°ìHˈXêE> ¯ø–¦ ¹W¦
¬$ºWüž[BüÏXDA If the `Value` is an Object, returns the associated mutable Map.ÁܘY Returns None otherwise.Á¸YË<ÀYÚ‘ÜÌY«Ó,ìY´œ
returned.Á¶±Ëü¾±MJ For more information read [RFC6901](https://tools.ietf.org/html/rfc6901).Á²Ët˜²äŒ«²Ë<³²Ú‘Ü¿²«Ó,ß²´œ´é² let data = json!({Át„³ "x": {Áä—³ "y": ["z", "zz"]ÁL¸³¨ú<ƳÚÖÒ³ËüÚ³>; assert_eq!(data.pointer("/x/y/1").unwrap(), &json!("zz"));Áü´-* assert_eq!(data.pointer("/a/b/c"), None);Á<Ï´Ú‘<â´Âà ÂÒ— Ãø°ú°û°Ðü°ý°þ°ìHˈXêE>Ù›
¦ ê´¦
¿$ë´à <ñ´õ¶¿ð¸Àˆ¹À¥¹ÀÀ¿À ¥—|¾·¿ð¸Áˆ¹Á¥¹ÁÁ¿Á¾†¥—ø°ú°û°Ðü°ý°þ°ìHˈXêE>¾†׸¿ð¸Âˆ¹Â¥¹Â¿­ž
 ¶ƒüÅÅBüž¹IF Looks up a value by a JSON Pointer and returns a mutable reference toÁ|ì¹ that value.Á€ºËüˆºIÑ“
üÖº8¤”
“»Ëü›»Mò”
üí»JÉ•
ü¼¼G
lˆ½í–
š½Ëü¢½M
ô½Ë¤ü½ # Example of UseÁ•¾Ë<¾Ú‘Ô©¾ëàȾË|о©Ëüä¾*' let s = r#"{"x": 1.0, "y": 2.0}"#;Áü“¿@= let mut value: Value = serde_json::from_str(s).unwrap();ÁØ¿Ëüà¿.+ // Check value using read-only pointerÁü“À;8 assert_eq!(value.pointer("/x"), Some(&1.0.into()));ÁüÓÀ.+ // Change value with direct assignmentÁü†Á74 *value.pointer_mut("/x").unwrap() = 1.5.into();ÁüÂÁ+( // Check that new value was writtenÁüòÁ;8 assert_eq!(value.pointer("/x"), Some(&1.5.into()));Áü²Â0- // Or change the value only if it existsÁüçÂ96 value.pointer_mut("/x").map(|v| *v = 1.5.into());Á¥ÃËü­ÃJG // "Steal" ownership of a value. Can replace with any valid Value.ÁüüÃFC let old_x = value.pointer_mut("/x").map(Value::take).unwrap();ÁüÇÄ assert_eq!(old_x, 1.5);ÁüëÄ?< assert_eq!(value.pointer("/x").unwrap(), &Value::Null);Á,¯ÅÍ‘<¹ÅÚ‘\ÌÅÄÅ ÄÒ— Åø°ú°û°Ðü°ý°þ°ìHˈXêE>›ª
¦ ØÅ¦
Ã$ÝÅà <ãÅëÇÃð¸Äˆ¹Ä¥¹ÄÄÃĺ
|´ÈÃð¸Åˆ¹Å¥¹ÅÅÃÅ Ò—¥—ø°ú°û°Ðü°ý°þ°ìHˈXêE>ݬ
DÑÉÃð¸Æˆ¹Æ¥¹ÆÆÃÆÓŸ
æ¬
 ¶ƒü»Ìü¡ÊFC Takes the value out of the `Value`, leaving a `Null` in its place.ÁìÊË<ôÊڑ܀˫Ó, Ë´œüªË$! let mut v = json!({ "x": "y" });ÁüÓË*' assert_eq!(v["x"].take(), json!("y"));Áü‚Ì(% assert_eq!(v, json!({ "x": null }));Á<¯ÌÚ‘$ÂÌÆ ÆÒ—Ò—¦ Ç̦
Ç$ÌÌüÎÑ"üÍGD Reorders the entries of all `Value::Object` nested within this JSONÁüÜÍ.+ value according to `str`'s usual ordering.ÁÎËü—ÎH¥ëüäÎIöë²ÏËüºÏDÓìüƒÐEB destroys the original source order or insertion order of the JSONÁüÍÐKH objects in favor of an alphanumerical order that matches how a BTreeMapÁüÑ,) with the same contents would be ordered.Á„ÕÑÇ ÇÒ—¦ æÑ¦
È$ëÑ´•Úü¢Õ'$ The default value is `Value::Null`.ÁÊÕËüÎÕJG This is useful for handling omitted `Value` fields when deserializing.Á™ÖËtÖ䌬ÖË<°ÖÚ‘ì¸Ö # use serde::Deserialize;ÁÔÖÖëàñÖËÔõÖ #[derive(Deserialize)]Á¬× struct Settings {Áœ¦×
¸
Ã
Ð
Ü
ë
ü
ý
þ
¦ § ,ùÎÐÊLŒÎÑŸC6óÎÒ÷É4NñÎÓÌH,h±ÎÔƒºÎÖœ±Î×ÉHÎØœ«<ÎÚ­ÿßAÎÛÍÁ]ÎÜîªcÎÝà„ÔvÎÞbÎà DeserializeÁ\ØØ;ÎáDeserializeSeedÁ|åà;Îâ
EnumAccessÁT‰=Î䌅D•Ö;ÎåÈ„Ÿ Îæøð<Îç²+LÀè<Îè§…™;ÎéÈ.l׊=Î곩<ÎëÄ…ÔýÎì å;Îãü EH7:|*,¬?œZìsòõ¬–ç¼ìÙóËÎL‰À²”©£üÁ¯ÈadNQ>A/2 #òôáãüö!Ôüè$ÏîîÒ—ïÚ;ïíü¡lÚ‰ ê³í³î³Òï³ìð³ñ³ò³ìäs{©¶Ò—±Š í©Hððí⊠°óŠ Äô
ïÏÚ‰ ™Š d³$&œœÎþ§× É<_ `ò.*Îññþ§üº'Ïôôþ§õö÷ùûýÿ ƒ … ‡ ‰ «<¬<­<µ<·<À<Â<Ç<Ì<Ð<Ø<Ú<Ü<à<â< öýù ƒ ÿû÷ ¿óóÒ—ü‘BL”ÉÊË Éþ§ ÊÁ`Á`œÃ`è Á]Ä`ϱÁ]Ê­\É:•Ë€•ó žó
öÏœPL¥üÃ7þ§ê³í³î³Òï³ìð³ñ³ò³ìäs{©¶Ò—³ óüHøøóÙ Ñ
÷ϳ ˜"$üÕ 5þ§ÚÉ
óüHúúóÙ â 
ùϳ ˜"$üØ
n
þ§ÚÉ
óüHüüóÙ æ
ê „µ 
ûϳ 
˜
*,üŠ
5L
þ§ÚÉ
óüHþþóÙ

ýϳ 
˜, 
"$ünTþ§ÚÉ
óüHóÙ ê „ê
ÿϳ ˜*,ü¿5þ§ÚÉ
óüHóÙ Ì
ϳ ˜"$ü³m»ã æ Ž8÷ç ê 8 ó7$ ú8 7á<†üá/Ìþ§ ÌÚÉ
óüH ÐóÙ Àê
ƒ ϳ ˜*,üÓ;»ƒ  ®8÷ Š ­8< 7,•$ š8 ¤7áü/þ§¥—ÚÉ
óüHóÙ ã
ϳ ˜"$üë*þ§ÚÉ
óüHˆ ˆ óÙ ù
ϳ üéþ§Ú‰ šÄ
ó©HŠ Š ó⊠÷óŠ ÄÑ
ÏÚ‰ ™Š d€+-üá*þ§ÚÉ
óüHŒ Œ óÙ ï
ϳ üßuþ§÷³ê³í³î³Òï³ìð³ñ³ò³ìäs{©¶Ò—÷³Ïê<ó¬Ž Ž óÌ¢ ìè<÷³Ï
Ï÷³‰¢9;üˆu»Î Ñ ù8÷Ò Õ ø8 Þ7$ å8 ï7áüÌ/Lþ§÷³ê³í³î³Òï³ìð³ñ³ò³ìäs{©¶Ò—‹’ ó¬  óÌ¢ Ä’ tî
Ï÷³$˜‰¢+-´Ò'Ò—ÕvÖvDï'ô'  Á‘ü…(,Dˆ(Í Íê³í³î³Òï³ìð³ñ³ò³ìäs{©¶Ò—Á‘ ”(
ö ‘(üØ(#ø–• – ÕvÖvD‚)‡)Á‘ü˜)+D›)Î Îê³í³î³Òï³ìð³ñ³ò³ìäs{©¶ø–Á‘ §)
ö ¤)üê)”÷) Š* Ç/ * ž*, *8Âå4*& ˜*8Û,™** * £* Ä/6+ ­* ®* Ø*8¢¯* ²* ×*8Æ ³* ¶* Ö*8<·* ¿*7ì ¬Á*8 â*, å*8Âå4æ* ì*8¬ í* î* ï* €+8$ð*$ ô*8‰¢<ö*& ý*8¬ ÿ*(+8ý4…+ +8¬ Œ+'+8ÌH,+$ ”+8,+ +8$,¥+8¬ ·+& ¸+8³<º+ Á+:ÏÂ+ Å+$ Æ+ Ð+ ø,8,Þ+8$ä+ é+ î,8ÌH,û+'€,8÷É4, ˆ, Š,8Ôä ‰,*Œ,8Ôä , ,8¥&|,  , ¨,8‰¢<¡,$ ©,8 »,*½,8À, Ã, ß,8$Ä, È,8´dÉ, Õ, Þ, Ö,8‰¢<×,$ à,+ ƒ- „- ©-8¢…- ˆ- ¨-8<‰- -7ì ¬“-8 ³-, ¶-8Âå4·- ½-8¬ ¾- ¿- À- Ñ-8$Á-$ Å-8‰¢<Ç-& Î-8¬ Ð-(Ó-8ý4Ö- Ü-8¬ Ý-'Þ-8ÌH,à-$ å-8,ç- ì-8$,ö-8¬ ˆ.& ‰.8³<. .:Ï“. .$ —. ¡. ¾/8,¯.8$µ. º. ´/8ÌH,Ì.'Ñ.8÷É4Ó. Ù. Û.8Ôä Ú.*Ý.8Ôä à. á., â.8Âå4ã. é. ñ.8‰¢<ê.$ ò.8 „/*†/8$‰/ /8¥&|Ž/ / ¥/8‰¢<ž/$ ¦/% Å/üÊ/k\Í/ζƒ÷³¡Ï¬š š Ì¢ Þ/Ý¢d¨0
˜ Ï÷³ƒ,á/‰¢<ô/Ù/24ü¢39Ïœ œ ø– ž   ¢ ÍÏÑÓÕ×ÙÛÝßáãåçéëíïñóõ÷ùûýÿƒç;è; <¤<ê;ì;î;ð;ò;ô;ö;ø;ú;ü;þ;€<<„<†<ˆ<Š<Œ<Ž<<<”<<˜<š<œ<ž<¢<ç¢ ×íƒÝóÍãùž ÓéÿÙïß
$ëNñôD‡O‰¢<²O<>ü¶S£Ô¹SÒ—Ÿ÷³¡¤ ¬® ® ¤ Ì¢ ÔSÝ¢dÌT
­ Ï÷³$àSÿ
$îS‰¢<ŠT35ü·Wf„ºWÒ—÷³¡¤ ¬° ° ¤ Ì¢ ËWÝ¢dX
¯ Ï÷³$ÎW‰¢<ÔW+-ü¶Yf„¹YÒ—÷³¡¤ ¬² ² ¤ Ì¢ ÊYÝ¢dZ
± Ï÷³$ÍY‰¢<ÓY+-ü×Ze|ÚZÒ—÷³¡¤ ¬´ ´ ¤ Ì¢ êZÝ¢d¯[
³ Ï÷³$íZ‰¢<óZ+-ü÷[h”ú[Ò—÷³¡¤ ¬¤ Ì¢ \Ý¢dÒ\
µ Ï÷³$\‰¢<\+-ü¸^gŒ»^Ò—÷³¡¤ ¬¸ ¸ ¤ Ì¢ Í^Ý¢d’_
· Ï÷³$Ð^‰¢<Ö^+-üÜ_j¤ß_Ò—÷³¡¤ ¬º º ¤ Ì¢ ô_Ý¢d¹`
¹ Ï÷³$÷_‰¢<ý_+-ü×bf„ÚbÒ—÷³¡¤ ¬¼ ¼ ¤ Ì¢ ëbÝ¢d°c
» Ï÷³$îb‰¢<ôb+-üÒd‚¼ÕdÒ—Ÿ÷³¡¤ ¬¾ ¾ ¤ Ì¢ ídÝ¢dÇe
½ Ï÷³$ðdýœ,öd‰¢<e46üfe|fÒ—÷³¡¤ ¬À À ¤ Ì¢  fÝ¢dåf
¿ Ï÷³$£f‰¢<©f+-üŽhtŒ‘hÒ—÷³¡¤ ¬  ¤ Ì¢ £hÝ¢dõh
Á Ï÷³$¦h«¡$¬h‰¢<¹h46üºi·ĽiÒ—Ÿ÷³¡¤ ¬Ä Ä ¤ Ì¢ ÖiÝ¢däj
à Ï÷³$âiýœ,ði«¡$j‰¢<¢j=?ü©ke|¬kÒ—÷³¡¤ ¬Æ Æ ¤ Ì¢ ¼kÝ¢dl
Å Ï÷³$¿k‰¢<Åk+-ü®mÆ”±mÒ—Ÿ¾¥÷³¡¤ ¬È È ¤ Ì¢ ÄmÝ¢dçn
Ç Ï÷³$Ðmýœ,Þm©¥<ûm‰¢<¥n=?üÌpl´ÏpÒ—÷³¡¤ ¬Ê Ê ¤ Ì¢ æpÝ¢d«q
É Ï÷³$ép‰¢<ïp+-üóqm¼öqÒ—÷³¡¤ ¬Ì Ì ¤ Ì¢ ŽrÝ¢dÓr
Ë Ï÷³$r‰¢<—r+-¼¡s„¨sÎ訕)Œ„féÎ Ï |¿s<¿sÎÍ Í ¥—¤Ôs,ÔsÎÍ Í üÌüís.ÏÑ Ñ è¨Ò Ó Ô „=…=†=Ô òsT¢t,§tÐ Ð Á‘dºt<¿tÐ Ð ß©üãt~dætè¨÷³ê³í³î³Òï³ìð³ñ³ò³ìäs{©¶÷³Ïâ;ß©Á‘Ð ¬Õ Õ Ð Ì¢ ótà;÷³Ï¤Ìu
Ô Ï÷³$ötÿ±$üt9;‡wÔ ð¸Ö ˆ¹Ö ¥¹Ö Ö Ô Ö ÷³÷³â;ëߩߩü¢w0ÏØ Ø Ò—Ù Ú Å Æ Ú §wŒÙwdÞw× × Ò—üøw0ŒûwÒ—Ò—ÏÁ‘Å × ×
Ú Ï$xüÁx5ÏÜ Ü Ã©Ý Þ Å Æ Þ ÆxŒýxd‚yÛ Û Ã©üœy0ŒŸyééÏÁ‘Å Û Û
Þ Ï$±yÔåyœìyÎß©÷J$î›7ö°à ¤†z,†zÎß ß üÌüŸz4Ïâ â ß©ã ä å ç é Œ==Ž==”=å ç ä é ¤zTÚz,ßzá á Á‘üóz*dözß©á§á á
ä Ï$ƒ{ü¨|o¤«|ß©ϳê³í³î³Òï³ìð³ñ³ò³ìäs{©¶ϳÏâ;Á‘á æ æ á ð¸ À|à;ϳϤ‚}
å Ïϳ$Ã|ÿ±$É|9;ü—pß©÷³¡á ¬è è á Ì¢ ¨Ý¢
ç Ï÷³«¡‰¢46ü½„¥tÀ„ß©¾¥÷³¡á ¬ê ê á Ì¢ τݢdÕ…
é Ï÷³$Û„©¥<鄉¢<“…9;´ƒ‰|ЉÎ™ªþ&G—›µì Ô ‰$ ‰Îë ë ¼>¼>ÕM¿>ϱ«<À>phantomÁ«<Á>capÁ«<Â>á«<Ã>÷ «<Ä>Ï«<Ö“<]¿‘FÒ—þ²¤¿‰™ªî üÚ‰݉惙ªí
ï  ·ï
ô Ï´äŽ|ëŽÎÔª+<%!#Éwö ÷ ü4$Îõ õ Úö ¤»Îõ õ ṳ̈ÔÔªù üï'òÎø–Ôªø ø
ù 
öü‚‘,Ïû û Ôªü ý ÿ
ò<ó<õ<=ý
ÿ ‡‘Tµ‘,º‘ú ú Á‘üΑulÑ‘Ñ ÑÔªϳ·šú þ þ  â‘ú ð¸ ß‘“”¤®’
ý Ïϳ$ç‘ÿ±$í‘/1üœ•o|Ÿ•Ò ÒÔªϳˆ“ú 

 ²•ú 𸠯•“”¤ö•
ÿ Ïϳ$·•ÿ±$½•/1üÄ—$LÇ—Ó ÓÔªª§
ú  Ñ—ú
Ï$Ò—üþ˜)ä‹™ ¨™ åž ®™ ¼™, ¯™8Âå4°™& ¶™8Û,·™*¾™ Á™ âž6+ Ë™ Ì™ ö™8¢Í™ Й õ™8Æ Ñ™ Ô™ ô™8<Õ™ Ý™7ì ¬ß™8 €š, ƒš8Âå4„š Šš8¬ ‹š Œš š žš8$Žš$ ’š8‰¢<”š& ›š8¬ š( š8ý4£š ©š8¬ ªš'«š8ÌH,­š$ ²š8,´š ¹š8$,Ú8¬ Õš& Öš8³<Øš ßš:Ïàš ãš$ äš îš –œ8,üš8$‚› ‡› Œœ8ÌH,™›'ž›8÷É4 › ¦› ¨›8Ôä §›*ª›8Ôä ­› ®›8¥&|¯› ¾› Æ›8‰¢<¿›$ Ç›8 Ù›*Û›8Þ› á› ý›8$â› æ›8´dç› ó› ü› ô›8‰¢<õ›$ þ›+ ¡œ ¢œ Çœ8¢£œ ¦œ Æœ8<§œ ¯œ7ì ¬±œ8 Ñœ, Ôœ8Âå4Õœ Ûœ8¬ Üœ Ýœ Þœ ïœ8$ßœ$ ãœ8‰¢<åœ& ìœ8¬ îœ(ñœ8ý4ôœ úœ8¬ ûœ'üœ8ÌH,þœ$ ƒ8,… Š8$,”8¬ ¦& §8³ °:ϱ ´$ µ ¿ Üž88 Ø Òž8ÌH'ï8÷É ÷ ù8Ôä ø*û8Ôä þ ÿ, €ž8Âå4ž ‡ž ž8‰¢<ˆž$ ž8 ¢ž*¤ž8$§ž «ž8¥&|¬ž »ž Þ8‰¢<¼ž$ Äž% ãžüèžq|ëžÎ Ï
Ò—÷³¡Ï
¬


Ì¢ €ŸÝ¢dÌŸ
ƒ
Ï÷³ƒ,ƒŸ‰¢<˜Ÿûž79üÉ¢>Ï

蚈
Ÿ¡£¥§©«­¯±³µ·¹»½¿ÁÃÅÇÉËÍÏÑÓç;è; <¤<ê;ì;î;ð;ò;ô;ö;ø;ú;ü;þ;€<<„<†<ˆ<Š<Œ<Ž<<<”<<˜<š<œ<ž<¢<©¿
¯ÅŸµË¥»
Ñ«Á±Ç¡·Í§½
ӭóɣ¹Ï΢TŽ£,“£

Á‘ü§£k|ª£èš÷³ê³í³î³Òï³ìð³ñ³ò³ìäs{©¶¢èšÏç;
¬Š
Š

Ì¢ º£Ý¢d…¤
Ï÷³$½£‰¢<ã/1üº§Ì„½§èšŸ¾¥÷³¥³
¬Œ
Œ

Ì¢ ΧÝ¢dù¨
Ï÷³$Ú§ýœ,è§€¨L…¨‰¢<±¨CEüÜ®m¼ß®èš÷³¡
¬Ž
Ž

Ì¢ ÷®Ý¢d¼¯
Ï÷³$ú®‰¢<€¯/1üß±1Ï

é
Õ×ÙÛÝßáãåçéë
˜
š
œ
ž
 
¢
¤
¦
¨
ª
¬
®
°
²
´
ç;è;ì;î;ð;ò;ô;ö;ø;ú;ü;þ;€<<Ž< <”<ê;„<†<ˆ<Š<Œ<<<<˜<š<œ<ž<¢<¤< 
Õë
¦
Û
á¬
œ
ç²
¢
×
¨
ݘ
®
ãž
´
é¤
Ù
ª
ßš
°
åä±T—²,œ²

Á‘ü°²e|³²é÷³¡
¬


Ì¢ òÝ¢dˆ³
Ï÷³$Ʋ‰¢<̲/1üýºh”€»é÷³¡
¬


Ì¢ “»Ý¢dØ»
Ï÷³$–»‰¢<œ»/1üó¼Ä„ö¼éŸ¾¥÷³¡
¬


Ì¢ ‡½Ý¢dª¾
Ï÷³$“½ÿ
$¡½ñôD½½‰¢<è½BDüïÁ£ÔòÁéŸ÷³¡
¬


Ì¢ ÂÝ¢d…Ã
˜
Ï÷³$™Âÿ
$§Â‰¢<ÃÂ8:üðÅf„óÅé÷³¡
¬


Ì¢ „ÆÝ¢dÉÆ
š
Ï÷³$‡Æ‰¢<Æ/1üðÇf„óÇé÷³¡
¬


Ì¢ „ÈÝ¢dÉÈ
œ
Ï÷³$‡È‰¢<È/1üŽÉe|‘Éé÷³¡
¬Ÿ
Ÿ

Ì¢ ¡ÉÝ¢dæÉ
ž
Ï÷³$¤É‰¢<ªÉ/1ü–Ëh”™Ëé÷³¡
¬¡
¡

Ì¢ ¬ËÝ¢dñË
 
Ï÷³$¯Ë‰¢<µË/1ü¶ÌgŒ¹Ìé÷³¡
£
£

Ì¢ ËÌÝ¢dÍ
¢
Ï÷³$Î̉¢<ÔÌ/1üüÎj¤ÿÎé÷³¡
´
¥

Ì¢ ”ÏÝ¢dÙÏ
¤
Ï÷³$—ω¢<Ï/1ü Ðf„£Ðé÷³¡
¤
§

Ì¢ ´ÐÝ¢dùÐ
¦
Ï÷³$·Ð‰¢<½Ð/1üœÒ¼ŸÒéŸ÷³¡
©
©

Ì¢ ·ÒÝ¢d‘Ó
¨
Ï÷³$ºÒýœ,ÀÒ‰¢<ÕÒ9;ü×Óe|ÚÓé÷³¡
¬«
«

Ì¢ êÓÝ¢d¯Ô
ª
Ï÷³$íÓ‰¢<óÓ/1üÜÕtŒßÕé÷³¡
¬­
­

Ì¢ ñÕÝ¢dÃÖ
¬
Ï÷³$ôÕ«¡$úÕ‰¢<‡Ö9;üˆ×·Ä‹×éŸ÷³¡
¬¯
¯

Ì¢ ¤×Ý¢d²Ø
®
Ï÷³$°×ýœ,¾×«¡$Û׉¢<ð×CEü÷Øe|úØé÷³¡
±
±

Ì¢ ŠÙÝ¢dÏÙ
°
Ï÷³$Ù‰¢<“Ù/1üüÚÆ”ÿÚ韾¥÷³¡
¬³
³

Ì¢ ’ÛÝ¢dµÜ
²
Ï÷³$žÛýœ,¬Û©¥<ÉÛ‰¢<óÛCEüžÞl´¡Þé÷³¡
µ
µ

Ì¢ ¸ÞÝ¢dýÞ
´
Ï÷³$»Þ‰¢<ÁÞ/1üÂßm¼Åßé÷³¡
¬·
·

Ì¢ ÝßÝ¢d¢à
Ï÷³$à߉¢<æß/1üÜàœãàÎϹ
¹
½«tý†ÖCõÞº
»
÷àŒ‚á<‚áθ
¸
ÏÌ™á,™áθ
¸
ø°ú°û°Ðü°ý°þ°ìHˈXêE>éü·á6Ͻ
½
½«¾
¿
À
„=…=†=À
¼áTôá,ùá¼
¼
Á‘dŒâ<‘â¼
¼
Ьü½âxdÀ⽫÷³ê³í³î³Òï³ìð³ñ³ò³ìäs{©¶ŠŒ½«Ï…=Á‘¼
¬Á
Á
¼
Ì¢ ÍâÊŒ¤ ã
À
Ï÷³$Ðâÿ±$Öâ/1ÞäÀ
ð¸Â
ˆ¹Â
¥¹Â
Â
À
Â
÷³éëÃ
Ã
¦†Å
˜ÎòY= ,úu›Õüùä"´€åÎÏÄ
Ä
ЬòY= ,úuÅ
—åÌ¢å,¢åÎÃ
Ã
…ÑüÀå<ÏÇ
Ç
ЬÈ
É
Ê
Ì
Î
Œ==Ž==”=Ì
Ê
Î
É
ÅåTƒæ,ˆæÆ
Æ
Á‘üœæ*dŸæЬá§Æ
Æ
É
Ï$¬æüÑço¤ÔçЬϳˆ“Æ
Ë
Ë
Æ
ð¸ éç“”¤«è
Ê
Ïϳ$ìçÿ±$òç/1üÀêplÃêЬ÷³¡Æ
¬Í
Í
Æ
Ì¢ ÑêÝ¢d£ë
Ì
Ï÷³$Ôê«¡$Úꉢ<çê9;üêï¥tíïЬ¾¥÷³¡Æ
¬Ï
Ï
Æ
Ì¢ üïÝ¢d‚ñ
Î
Ï÷³$ˆð©¥<–ð‰¢<Àð9;ô°ô”·ôÎÏÑ
Ñ
ˬÑú¥ïÒ
ÊôìÕô$ÕôÎÐ
Ð
ÙiÙiÍ¿Üi÷ ®iÝi
end_or_lenÁ®iÞiê·®it¸%ýN(ÏÒ—ü÷ô!ÏÔ
Ô
ˬÕ
üôüŸõ#¢õÎÝ®ˬÓ
Ó
Õ
Ïî,¦õü€ö4Ï×
×
ˬØ
Ù
Û
ê<ë<ï<Û
Ù
…öT»ö,ÀöÖ
Ö
Á‘üÔöyŒ×öÔ Ôˬϳ·šÖ
Ú
Ú
 ìöÖ
ð¸ éö“”¤¸÷
Ù
Ïϳ$ñöÿ±$÷ö/1üæø$LéøÕ Õˬª§
Ö
 óøÖ
Û
Ï$ôøô ú”§úÎÏÝ
Ý
Œ­P‰¹X,¾áÞ
ß
ºúüÅú9$ÅúÎÜ
Ü
èš°JÌ„û,„ûÎÜ
Ü
…Ñü¢û!Ïá
á
Œ­â
§ûüÊû,ÍûÎ蚌­à
à
â
Ï
Ñûüåü4Ïä
ä
Œ­å
æ
è
ê
ò<ó<õ<=æ
è
ê
êüT ý,¥ýã
ã
Á‘ü¹ýul¼ýÖ ÖŒ­ϳ·šã
ç
ç
 Íýã
ð¸ Êý“”¤™þ
æ
Ïϳ$Òýÿ±$Øý/1üo|× ×Œ­ϳˆ“ã
é
é
 £ã
𸠠“”¤ç
è
Ïϳÿ±/1üµƒ$L¸ƒØ ØŒ­ª§
ã
 ċ
ê
Ï$Ãôï„”ö„ÎÏì
ì
Ù­=f5ö_Pí
‰…””…”…Îë
ë
º½¾Ü«¿ìÀÁæ°Âìr^!™¿ÆÏü«…$¼¸… Ð… ²‹ Ö… ä…, ×…8Âå4Ø…& Þ…8Û,ß…*æ… é… ®†8ñ2¼ó… І ‹† §†, Œ†8Âå4$ “†8!”•†% ¨†% ¯† ¶† Ò† , ·†8Âå4¸†& ¾†8Û,¿†$ Ć, Ɔ8ˆ,dž& ̆8Û,͆*Ô† ׆ ¯‹8 á†, ä†8Âå4å† ë†8¬ ì† í† î† ÿ†8$ï†$ ó†8‰¢<õ†& ü†8¬ þ†(8ý4„‡ Ї8¬ ‹‡'Œ‡8ÌH,އ$ “‡8,•‡ š‡8$,¤‡8¬ ¶‡& ·‡8³<¹‡ À‡:ÏÁ‡ ć$ Ň χ ©‹!8݇8á‡8å‡ è‡8,ê‡'ï‡8dñ‡'ý‡8÷Dÿ‡ ‡ˆ ‘ˆ ˆˆ8$‰ˆ ˆ8‚LŽˆ% ’ˆ8,¡ˆ8§ˆ ªˆ «ˆ µˆ8¬ˆ ®ˆ8î$¯ˆ ³ˆ ´ˆ ·ˆ ɉ
8$Ɉ ͈ àˆ7ì$Έ#Òˆ7õ$Õˆ Úˆ7óã$܈*âˆ åˆ æˆ8 øˆ*úˆ84ýˆ8„‰ ‡‰ º‰8,ˆ‰'8Š@4 •‰ ¹‰8ÊL–‰'Ÿ‰8˜>”¡‰$ ³‰7ì µ‰$ ¶‰7ì ¸‰$ »‰8؉8À£4܉ ã‰8å‰ è‰ é‰ ü‰8ê‰ ì‰, í‰8ˆ,î‰ ó‰ û‰8‰¢<ô‰% ý‰8ŒŠ8Š ’Š “Š Š8”Š –Š8î$—Š ›Š œŠ žŠ8is_someÁ<ŸŠ ¦Š §Š ©Š ‡‹84»Š8Š ÅŠ øŠ8,ÆŠ'ËŠ8Š@4ÍŠ ÓŠ ÷Š8ÊLÔŠ'ÝŠ8˜>”ߊ$ ñŠ7ì óŠ$ ôŠ7ì öŠ% ùŠ8Ò–‹ ˜‹ Ÿ‹8À£4™‹% °‹üµ‹>Ïð
ð
Ù­ñ
ò
íïñóõ÷ùûýÿƒô
ö
ø
ú
Ÿç;è;ì;î;ð;ò;ö;ø;ú;ü;€<<ô;þ;ê;Ž<”< <„<†<ˆ<Š<Œ<<<<˜<š<œ<ž<¢<¤<ø
ñ÷ýô
íƒú
óŸùÿö
ïõò
ûº‹Tú‹,ÿ‹ï
ï
Á‘ü“Œe|–ŒÙ­÷³¡ï
¬ó
ó
ï
Ì¢ ¦ŒÝ¢dëŒ
ò
Ï÷³$©Œ‰¢<¯Œ/1üÍ“f„ГÙ­÷³¡ï
¬õ
õ
ï
Ì¢ á“Ý¢d¦”
ô
Ï÷³$䓉¢<ê“/1ü†—h”‰—Ù­÷³¡ï
¬÷
÷
ï
Ì¢ œ—Ý¢dá—
ö
Ï÷³$Ÿ—‰¢<¥—/1üÓ˜¤ÔÖ˜Ù­Ÿ÷³¡ï
¬ù
ù
ï
Ì¢ ñ˜Ý¢dê™
ø
Ï÷³$ý˜ýœ,‹™‰¢<¨™9;ü´šÄ„·šÙ­Ÿ¾¥÷³¡ï
¬û
û
ï
Ì¢ Țݢdë›
ú
Ï÷³$Ôšÿ
$âšñôDþš‰¢<©›BD¤“žlšžÎš®šÅ”àsÞbý
0+Îü
ü
š®lªžD¯žÎ‰…ïÌ+7k2 ÿ
 ¥—‰…ÛÁÛÁÎþ
þ
ÛÁÛÁÎ¥—‰…þ
þ
Õÿ4žÎþ
þ
¥—ü¶Ÿ0σ ƒ š® â;ã; »ŸTíŸ,òŸ  ‰…ü‰ x\Œ š®Ú‰ ê³í³î³Òï³ìð³ñ³ò³ìäs{©¶š®Ïâ;±Š  ©H   ⊠˜ óŠ Äè 
ÏÚ‰ $› ™Š d¡ /1ü¼¡(ψ ˆ š® Š «<¬<Ì<Ð<Š Á¡Të¡,ð¡  ‰…ü‡¢BLŠ¢ÙÚÛ Ùš® ÚÁ`Á`œÃ`è Á]Ä`ϱÁ]Ê­\É:•Û€•  ”¢
Š Ï$•¢œPL›¢üƒ£XL†£Üš® Üê³í³î³Òï³ìð³ñ³ò³ìäs{©¶š®Ï«<³  üHŒ Œ  œ£ Ù £ê LÑ£
ϳ $“£ö ™£.0üÀ¦]»ަ ‘¦ ¹¦8÷’¦ •¦ ¸¦8<–¦ ž¦7, ¦$ ¥¦8<§¦ ¯¦7á<±¦üŒ¦/dæš®¥—Í… üHŽ Ž  ٠Цê L“§
ϳ $Ó¦ö Ù¦.0Tʩҗ üç©Ydê©ÎÝÞ ÝÒ— ÞÖ;ÞüH üH   ú© ©âŠ ÷©;Š„¯ª
Š$û©£ª13ü«"T «Îß ßÒ—™;›;œ;ÞÉ;ìž;Ÿ;‹ø ;ì¡;¢;¬ø£;ì¤;¥;Üå¦;ì§;¨;åø©;ìª;«;‚ù¬;ì­;®;žù¯;ì°;±;¼ù²;³;Ó´;µ;àù ¶;·;ýù
¸;¹;ŸC º;»; ú ¼;½;´ú
¾;¿;ÏúÀ;Á;íúÂ;Ã;‰ûÄ;Å;¦ûÆ;ì²Ëª[e]ÀÉß  ««
$¬«ü®&Ô—®ÎÏ  Þ®“f.õ÷,_p ²®¤½®,½®Î  ³çüÖ®)Ï  Þ®˜ Û®ü†¯$‰¯Î³çÞ® 
˜ Ϙ,¯üã¯CÏš š Þ® œ ž ¡£¥§©«­¯±³µ·¹»½¿ÁÃÅÇÉËÍÏÑÓÕ×Ùç;è; <ê;ì;î;ð;ò;ô;ö;ø;ú;ü;þ;€<<„<†<ˆ<Š<Œ<Ž<<<”<<˜<š<œ<ž<¢<¤<½­Ãٳɣ¹Ï©¿Õ¯ÅµË¥œ »Ñ«Áױǡ·Í§Óž è¯T­°,²°  Á‘üưi|ɰÞ®÷³¡ ¬   Ì¢ Ù°Ý¢„ž±
œ Ï÷³$ܰ‰¢<â°/1ü™´Â„œ´àÞ® ྥ÷³¡ ¬Ÿ Ÿ  δ Ì¢ ­´Ý¢„ʵ
ž Ï÷³$¹´ýœ,Ç´€¨LÜ´‰¢<ˆµCEü¸AÏ¡ ¡ Þ®¢ £ ¤ „=…=†=¤ †¸Tɸ,θ    Á‘dá¸<渠   °¯üÿ¸|d‚¹Þ®ϳê³í³î³Òï³ìð³ñ³ò³ìäs{©¶Ö“ޮυ=Á‘  ¥ ¥   𸠹“”Äâ¹
¤ Ïϳ$’¹ÿ±$˜¹/1|ÛºDâºÎ°¯û˜ }qéZ § 0+Φ ¦ °¯üíº-Ï© © °¯ª « ¬ ® ° Œ==Ž=’=”=¬ ® « ° òºT¡»,¦»¨ ¨ Á‘üº»*d½»°¯á§¨ ¨
« Ï$Ê»ü¼t¤„¼°¯ϳˆ“¨ ­ ­ ¨ 𸠙¼“”Äܼ
¬ Ïϳ$œ¼™Ö,¢¼/1üü½ulÿ½°¯÷³¡¨ ¬¯ ¯ ¨ Ì¢ ¾Ý¢„à¾
® Ï÷³$¾«¡$–¾À×D£¾9;üö¿ªtù¿°¯¾¥÷³¡¨ ¬± ± ¨ Ì¢ ˆÀÝ¢Á
° Ï÷³$”À©¥<¢ÀÀ×DÌÀ9;DêÛ$îÛÌH,
±² ³ ŸC"
ó² ´ ÷É4:
ñ² µ V
º² · œ<[
±² ¸ 4x
ÉH² ¹ ­
ßA² º d
Ž|
¬+
oìF
`bPR¬i
C|„
5Ì–

 °

 
Ä
, ·
 ¸
Â
, ¹
8º
& ¼
8Û

Ã
*Æ
 É

, Ó
 Ô
û
 8
8ž
 ë
, ì
8í
 ï
8
ñ
8ÌH
 û
ñ
8 
8ï$
 

8Ôä 
& 
, ˜
8
(
8$ 
 ¥
ã
8ÌH
'À
8փ
 È
Ñ
8Ôä É
 Ê
8×®
 Ï
Ð

ü
% ƒ
Ä–
Ò—½ ü½ ¼Â
üµ?
< Convert 32-bit floating point number to `Value::Number`, orÁüù%
" `Value::Null` if infinite or NaN.Á£
Ë
䌾
Ë
Ú‘ÔÒ
ëàñ
˼ù
 let f: f32 = 13.37;Áä•
 let x: Value = f.into();Á
Ú‘
Ò—¼ ¼
½ þ Ê
Ĥ
Ò—¿ ü¿ ¼Ð
üÃ?
< Convert 64-bit floating point number to `Value::Number`, orÁü‡%
Í£±
Ë
äŒÌ
Ë
Ú‘Ôà
ëàÿ
˼‡
 let f: f64 = 13.37;犣
Þ¤
Ú‘
Ò—¾ ¾
¿ þ Ø
̲
Ò—Á üÁ Ä–
üÒ
%
" Convert boolean to `Value::Bool`.Áü
Ët„
äŒ
Ë
Ú‘Ô«
ëàÊ
Ë”Ò
 let b = false;Áäé
 let x: Value = b.into();Á
Ú‘$™
Ò—À À
Á þ ž
ÜÑ
Ò—Ã üà ÔÏ
üó (
% Convert `String` to `Value::String`.Á 
Ë
䌻
Ë
Ú‘ÔÏ
ëàî
Ëüö
'
$ let s: String = "lorem".to_owned();犢
 let x: Value = s.into();Á
Ú‘
¥—Ò—Â Â
à þ ×
ÌŽ
8ááÒ—Å üÅ Ä
ü®,
) Convert string slice to `Value::String`.Áß
Ë
äŒú
Ë<
Ú‘ÔŽ
ëà­
ËÔµ
 let s: &str = "lorem";ÁäÔ
Ø«
Ú‘$„
â âÒ—Ä  Œ
Ä
Å 8þ 
üÉ%
ˆÇ Ç Ò—È üÈ Î
üÁ
üõ4
1 Convert copy-on-write string to `Value::String`.Á®
Ë
äŒÉ
Ë
Ú‘ÔÝ
ëàÌü
 use std::borrow::Cow;Áš
蟢-
* let s: Cow<str> = Cow::Borrowed("lorem");ÁäÔ
Ø«
Ú‘
Ë<‰
Ú‘Ô•
ëàÌ´
§°Ò
ËüÚ5
2 let s: Cow<str> = Cow::Owned("lorem".to_owned());Áä”
Ø«
Ú‘
¾±Ò—Æ Æ
È ˆþ É
Ü“
Ò—Ê üÊ Ô
üµ(
% Convert `Number` to `Value::Number`.Áâ
Ë
äŒý
Ë<…
Ú‘ü‘$
! use serde_json::{Number, Value};Áº
ËäÂ
 let n = Number::from(7);Áäã
 let x: Value = n.into();Á<„
Ú‘$“
ߊÒ—É É
Ê þ ˜
üÏ'
Ò—Ì üÌ ü˜&
üý6
3 Convert map (with string keys) to `Value::Object`.Á¸
Ë
äŒÓ
Ë
Ú‘üç!
 use serde_json::{Map, Value};Á
ËÜ•
 let mut m = Map::new();Áüµ1
. m.insert("Lorem".to_owned(), "ipsum".into());Áäë
 let x: Value = m.into();Á
Ú‘$
ø–Ò—Ë Ë
Ì þ  
üã+
Î Î „Í è
÷ø²Ò—
Ò—Ï üÏ ')Ôô
ü•&
# Convert a `Vec` to `Value::Array`.ÁÀ
Ë
äŒÛ
Ë
Ú‘Ôï
ëàŽ
Ëü–,
) let v = vec!["lorem", "ipsum", "dolor"];犂
 let x: Value = v.into();Á
Ú‘
¼²Ò—Í Í
Ï ø²þ ü
üØ;
Ñ ÍÒ Ñ Ò „Í Ý
Í
ë¹
Ò—Ô üÔ )+( ó
ôš
$
´³Ò—Ð Ð
Ô ø²Íƒ
ü† 1
8ã× × ãð¸
Þϳ
÷ϳÒ—\–
Ò—Ø üØ 79Ä£"
ü¾ &
# Convert a slice to `Value::Array`.Áé
Ë
䌄!
Ë<Œ!
Ú‘Ô˜!
ëà·!
Ëü¿!2
/ let v: &[&str] = &["lorem", "ipsum", "dolor"];Áäö!
к<—"
Ú‘$¦"
ä äγÒ—Ö  ®"
Ö
Ø 8ϳþ «"
ü‰#.
Ú Ú „Í Ž#
ë¹\#
Ò—Û ¬JÛ ü¦(8
ü¾#H
E Create a `Value::Array` by collecting an iterator of array elements.Á$
Ët“$
䌦$
Ë<®$
Ú‘Ôº$
ëàÙ$
Ëüá$*
' let v = std::iter::repeat(42).take(5);Áü%
 let x: Value = v.collect();Á<´%
Ú‘À%
Ë<È%
Ú‘ÔÔ%
ëàó%
Ëüû%4
1 let v: Vec<_> = vec!["lorem", "ipsum", "dolor"];Áü´&+
( let x: Value = v.into_iter().collect();Á<ä&
Ú‘ð&
Ë<ø&
Ú‘ü„'
 use std::iter::FromIterator;ÁÔ©'
ëàÈ'
ËüÐ'E
B let x: Value = Value::from_iter(vec!["lorem", "ipsum", "dolor"]);Á<š(
Ú‘L©(
¬rÒ—Ù ¬rÜ Ü Ù ©âÏÆ ³(
®JÏÆ´¶(
ÏÆ¯Jø²DÃ(
Û ø²ÏÆ£ $Î(
<>ü«)D
õ-Þ ¬ß ß Þ •· °)
Ì¢ Á)
÷ò³¥—d³)
÷÷³Ò—\Ä)
Ò—à ¬Jà CEHJü’,=
üö)J
G Create a `Value::Object` by collecting an iterator of key-value pairs.ÁÅ*
Ë
H üû A ´Ú¡Ã
 Æ
Í
8°

t×
õ æ æ¦ õ Ò—ø°ú°û°Ðü°ý°þ°ìHˈXêE>ºÞñ æ
ñ
ô ¦ 
¥¿ ñ
"$ü·
A ü¢ L I Panic if array index out of bounds. If key is not already in the object,Áüó K H insert it with a value of null. Panic if Value is a type that cannot beÁüà L I indexed into, except if Value is null then it can be treated as an emptyÁ\”
É· ¡¦
 ©
°
8°

÷ ç ç¦ ÷ Ò—¦âñ Ê
ñ
ö ¦ 
¥¿ Õ
"$¤ü
ù û ý ò ô ö ý ù û ü—;  ú è è ú Ò—ø°ú°û°Ðü°ý°þ°ìHˈXêE>Îãø ¥ ø
ù  ¥¿ °  üÃG  ü é é ü Ò—ø°ú°û°Ðü°ý°þ°ìHˈXêE>„åø Õ ø
û  ¥¿ à  üÿ@ |‚ þ ê ê þ Ò—ºæø  ø
ý $— ¥¿   Î ý ð¸ÿ ˆ¹ÿ ¥¹ÿ ÿ ý ÿ ݬ
  Ýç”õ  ƒ ò ô ö  ƒ üŽ; T‘  ë ë  Ò—ø°ú°û°Ðü°ý°þ°ìHˈXêE>Êè œ 
 ¥¿ §  üºG   ì ì  Ò—ø°ú°û°Ðü°ý°þ°ìHˈXêE>ÿé Ì 
ƒ  ¥¿ ×  üö@   í í  Ò—´ë  
 ¥¿   ¬× ¥—ˆ Š Œ ò ô ö Š ˆ Œ üó;   î   Ò—ø°ú°û°Ðü°ý°þ°ìHˈXêE>Úì  
ˆ $† ¥¿ Œ  üÚG   ï 綾  Ò—ø°ú°û°Ðü°ý°þ°ìHˈXêE>‘î ì 
Š  ¥¿ ÷  üÑ@   ð 𥗠 Ò—Èï ä 
Œ  ¥¿ ï  üÁ1 8ñ ñ Úò Æ ñ ϳ ƒµ ò ô ö  9;üù;   ò òƒµ  Ò—ø°ú°û°Ðü°ý°þ°ìHˈXêE>±ñŽ  Ž
8ϳ ¥¿  ')üàG   ó óƒµ  Ò—ø°ú°û°Ðü°ý°þ°ìHˈXêE>óòŽ ò Ž
8ϳ ¥¿ ý ')ü×@   ô ôƒµ  Ò—µôŽ ê Ž
8ϳ ¥¿ õ ')\û <ÿ è ! 4—!   ž œ! ž ž ¬¥! œÂ! üÝ!% ¥—üŠ". 8õœ õœ Úò " ϳ4²" ƒµ$â" è ˆŸ Ÿ ½µYZ÷ž   ·½µGè ·½µ 
ž ˆç" Lë" è   ·ìø" ˆ¢ ¢ ½µ£ æ`£ ý" üœ#< Ÿ# ö÷ø ö½µ ÷Á`Á`œÃ`è Á]Ä`ϱÁ]Ê­\É:•ø€•¡  £# ¡
£ ˆ$¤# œPLª# üÐ03 ¬r¥ ¥ ü¯ Õ0 ° ,ý0 Ò—¦ § ¨˜©˜§ $&\Š1 41 ¤ ¤ Ò—ü–9# ü¤1C @ Index into a `serde_json::Value` using the syntax `value[0]` orÁŒì1  `value["k"]`.Á2 ËüŠ2J G Returns `Value::Null` if the type of `self` does not match the type ofÁüÙ2J G the index, for example if the index is a string and `self` is an arrayÁü¨3K H or a number. Also returns `Value::Null` if the given key does not existÁüø3H E in the map or the given index is not within the bounds of the array.ÁÅ4 ËüÍ4F C For retrieving deeply nested values, you should have a look at theÁä˜5  `Value::pointer` method.Á¹5 ËtÁ5 äŒÔ5 Ë
Œ¬
 ¾
 Í Ä
 ß
, Å
 Æ
 Ý
, Ç
8ÕÈ
& Ê
8Û
 Ñ
 Ü
, Ò
 Ó
 Ú
, Ô
8Õ
& ×
8Ø

Û

Þ
*á
 ä
 Ë, î
 ï
 Ä, ð
 ñ
 Â/8$ÿ
8ÛL„  , Ž 8  8
 8ÌH,—   œ 8 ¯ 8Õ²  ´  Ç  µ 8 $ º 8î & Á  à , Ä 8Å (É 8õ  Ñ  Ž , ç 8Õè  ê  ü 8 $ ï 
ñ 8î 8ø 8 û 8 8Û  ¹ 8ÌH  ¿ 8
Á , Å 8Æ  É  Ê
8 Û 8ÕÞ  à  õ  á 8 $ æ 8î & í  ï 8ÌH (÷ 8õ  ÿ  ¼
,
8Õ
 ˜
 ª
8î ,™
$ ž

 
8
8¦
8 ©
8
 Ý
:ˆÞ
 à
8Û
 ë
, ì
8í
 ï
8
ñ
 õ
:ˆö
8ÌH
 ÿ
 ÿ8 8Õ  © 8$ œ8î & £ ¥, ¦8§(«8õ ³ ñ, É8ÕÊ Ì ß
Í8$ Ò
Ô8î 8Û8 Þ8 :ˆ 8ÛL—  , ¡8¢ ¤8
¦ ª:ˆ«8®8ÌH ¸ ¸8 Ê8ÕÍ Ï â Ð8$ Õ8î ,×& Ü Þ, ß8à(ä8õ ì ª, 8Õƒ  ˜
8$‡$ 
8î 88 
Ã
Å<Ü“ÜÙ Ú
Ž
µ
·
¸
,ù Ä ÊLŒ Å ý4%û Æ ŸC>ó Ç µ¡DV ò
 É ÌH,`± Ê œ<{± Ë ÉH Í ×5 Î ­»ßA Ï å` Ð Û
Y Ñ î€
¯
Â Ó 
L‡®AÂ Ô ü(#&
|2üüGíïÝß´lÐüˆ!ÃŲ´|¯¥”Ä–d܇üî#xzfhÄ”Ò—Ö ¯AÖ üÁr Ò—´Ü³‡ Õ ÈE× ×  ÑÕ ­Ý ÎÈ œŸ
Ö ´Üä‡ TØ%'Ä䬩üà )& Serializer whose output is a `Value`.ÁŠ
ËüŽ
PM This is the serializer that backs [`serde_json::to_value`][crate::to_value].Áüß
KH Unlike the main serde_json serializer which goes from some serializableÁü« =: value of type `T` to JSON text, this one goes from `T` toÁÄé  `serde_json::Value`.Á Ëü† 0- The `to_value` function is implementable as:Á· Ë Ú‘Ìà  use serde::Serialize;ÁüÝ # use serde_json::{Error, Value};Á
Ëü…
85 pub fn to_value<T>(input: T) -> Result<Value, Error>Á
 whereÁ¬È
 T: Serialize,Á
üä
63 input.serialize(serde_json::value::Serializer)Á,͑ڑà¼n}6ÏÚ )Ù Ù à¼üÁ%à¼Ü Ý Þ ß à á â ã ä å æ ç è é ê ë ì í î ï ð ñ ò ó ô ö ÷ ø ù û ý þ
ƒ
²A³A´AµA¶A·A¸A¹AºA»A¼A½A¾A¿AÀAÁAÂAÃAÄAÅAÆAÇAÈAÉAÊAÎAÏAÐAÑAÓAËAÌAÕAÖA×AØAÙAÚAÛAâAç ý ê
í ƒ
ð
ó ö ù æ é ì
ï
ò ø å û è þ ë
î
ñ
ô ÷ òÛ Û Ò—T‚,‡Û Û Á‘Œ›Û Û Œ½œÁÛ Û Œ½Ìé¤îÛ Û Œ½Ô—¬œÛ Û ×½ŒÏÛ Û —¾¤õÛ Û —¾Üž´£Û Û ‰¿üç5༌Ü
Û Û
å ˜,ÿü×1༌Ü
Û Û
æ ˜üÍ3༌Ü