["bdk_sqlite",{"t":"GPPFNNNNNNNNNNNNNENNNNNNNNNNOO","n":["Error","Network","Sqlite","Store","borrow","borrow","borrow_mut","borrow_mut","fmt","fmt","fmt","from","from","into","into","new","read","rusqlite","to_string","try_from","try_from","try_into","try_into","type_id","type_id","vzip","vzip","write","expected","given"],"q":[[0,"bdk_sqlite"],[28,"bdk_sqlite::Error"],[30,"bdk_sqlite::store"],[31,"core::fmt"],[32,"rusqlite"],[33,"rusqlite::error"],[34,"core::result"],[35,"core::cmp"],[36,"serde::de"],[37,"serde::ser"],[38,"core::marker"],[39,"bdk_chain::tx_data_traits"],[40,"bdk_chain::changeset"],[41,"core::option"],[42,"alloc::string"],[43,"core::any"]],"i":[0,6,6,0,3,6,3,6,3,6,6,3,6,3,6,3,3,0,6,3,6,3,6,3,6,3,6,3,20,20],"f":"````{{{b{c}}}{{b{e}}}{}{}}0{{{b{dc}}}{{b{de}}}{}{}}0{{{b{{f{ce}}}}{b{dh}}}j{}{}}{{{b{l}}{b{dh}}}j}0{cc{}}0{ce{}{}}0{n{{Ab{{f{ce}}A`}}}{AdAfAhAj}{AlAfAhAj}}{{{b{d{f{ce}}}}}{{Ab{{B`{{An{ce}}}}l}}}{AdAfAhAj}{AlAfAhAj}}`{{{b{c}}}Bb{}}{c{{Ab{e}}}{}{}}000{{{b{c}}}Bd{}}055{{{b{d{f{ce}}}}{b{{An{ce}}}}}{{Ab{Bfl}}}{AdAfAhAj}{AlAfAhAj}}``","D":"Ah","p":[[1,"reference"],[0,"mut"],[5,"Store",0,30],[5,"Formatter",31],[8,"Result",31],[6,"Error",0],[5,"Connection",32],[6,"Error",33],[6,"Result",34],[10,"Ord",35],[10,"Deserialize",36],[10,"Serialize",37],[10,"Send",38],[10,"Anchor",39],[5,"CombinedChangeSet",40],[6,"Option",41],[5,"String",42],[5,"TypeId",43],[1,"unit"],[15,"Network",28]],"r":[[3,30]],"b":[[9,"impl-Debug-for-Error"],[10,"impl-Display-for-Error"]],"c":"OjAAAAAAAAA=","e":"OzAAAAEAABIAAwAFAAYAEgAJAB0AAQA="}],\
["bdk_testenv",{"t":"FEEEONNEOENNNNNNNNNNNNNNNNNNN","n":["TestEnv","anyhow","bitcoincore_rpc","bitcoind","bitcoind","borrow","borrow_mut","electrsd","electrsd","electrum_client","electrum_client","from","genesis_hash","into","invalidate_blocks","make_checkpoint_tip","mine_blocks","mine_empty_block","new","reorg","reorg_empty_blocks","reset_electrsd","rpc_client","send","try_from","try_into","type_id","vzip","wait_until_electrum_sees_block"],"q":[[0,"bdk_testenv"],[29,"electrum_client::api"],[30,"bitcoin::blockdata::block"],[31,"anyhow"],[32,"bdk_chain::local_chain"],[33,"bitcoin::address"],[34,"core::option"],[35,"alloc::vec"],[36,"bitcoincore_rpc::client"],[37,"bitcoin_units::amount"],[38,"bitcoin::blockdata::transaction"],[39,"core::result"],[40,"core::any"]],"i":[0,0,0,0,3,3,3,0,3,0,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3],"f":"`````{{{b{c}}}{{b{e}}}{}{}}{{{b{dc}}}{{b{de}}}{}{}}```{{{b{f}}}{{b{{`{h}}}}}}{cc{}}{{{b{f}}}{{l{j}}}}{ce{}{}}{{{b{f}}n}{{l{A`}}}}{{{b{f}}}Ab}{{{b{f}}n{Af{Ad}}}{{l{{Ah{j}}}}}}{{{b{f}}}{{l{{Aj{nj}}}}}}{{}{{l{f}}}}{{{b{f}}n}{{l{{Ah{j}}}}}}{{{b{f}}n}{{l{{Ah{{Aj{nj}}}}}}}}{f{{l{f}}}}{{{b{f}}}{{b{{`{Al}}}}}}{{{b{f}}{b{{Ad{An}}}}B`}{{l{Bb}}}}{c{{Bd{e}}}{}{}}0{{{b{c}}}Bf{}}<{{{b{f}}}{{l{A`}}}}","D":"An","p":[[1,"reference"],[0,"mut"],[5,"TestEnv",0],[10,"ElectrumApi",29],[5,"BlockHash",30],[8,"Result",31],[1,"usize"],[1,"unit"],[5,"CheckPoint",32],[5,"Address",33],[6,"Option",34],[5,"Vec",35],[1,"tuple"],[10,"RpcApi",36],[6,"NetworkChecked",33],[5,"Amount",37],[5,"Txid",38],[6,"Result",39],[5,"TypeId",40]],"r":[],"b":[],"c":"OjAAAAAAAAA=","e":"OzAAAAEAAA4ABAAAAAAAAgAIABYAAAAZAAMA"}],\
["bdk_tmp_plan",{"t":"FKPPPPFFGGFFPPPGPPONNNNNNNNNNNNNNNNMNNNNNNNNNNNNNNNNNNOOONNNNNNNNNNNNNNNNNNNNOOOOOONNNNNNNNOONHNNNNOOOOOOONONNNNNNNNNNNNNNNNNNNNNNNNNONNNNNNNNNNNNNNNNNOOOOOOOO","n":["Assets","CanDerive","Complete","DerivationError","Incomplete","Legacy","Plan","PlanKey","PlanState","RequiredSignatures","Requirements","SatisfactionMaterial","Segwitv0","SigHashP2wpkh","SigHashTaproot","SigningError","TapKey","TapScript","asset_key","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","can_derive","clone","clone","clone","clone","clone","clone","clone","clone_into","clone_into","clone_into","clone_into","clone_into","clone_into","clone_into","default","default","default","default","derivation_hint","descriptor_key","ecdsa_sigs","expected_weight","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","from","from","from","from","from","from","from","from","from","from","from","hash160","hash160_images","hash160_preimages","hash256","hash256_images","hash256_preimages","into","into","into","into","into","into","into","into","keys","max_locktime","min_version","plan_satisfaction","required_locktime","required_sequence","requirements","requires_hash_preimages","ripemd160","ripemd160_images","ripemd160_preimages","schnorr_sigs","sha256","sha256_images","sha256_preimages","sign_with_keymap","signatures","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","to_string","try_complete","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_into","try_into","try_into","try_into","try_into","try_into","try_into","try_into","txo_age","type_id","type_id","type_id","type_id","type_id","type_id","type_id","type_id","vzip","vzip","vzip","vzip","vzip","vzip","vzip","vzip","witness_version","final_script_sig","final_script_witness","keys","keys","leaf_hash","merkle_root","plan_key","plan_keys"],"q":[[0,"bdk_tmp_plan"],[151,"bdk_tmp_plan::PlanState"],[153,"bdk_tmp_plan::RequiredSignatures"],[159,"miniscript::descriptor::key"],[160,"bitcoin::bip32"],[161,"core::option"],[162,"bdk_tmp_plan::requirements"],[163,"core::clone"],[164,"bdk_tmp_plan::template"],[165,"core::fmt"],[166,"bitcoin::crypto::sighash"],[167,"miniscript::descriptor"],[168,"bitcoin::blockdata::locktime::absolute"],[169,"bitcoin::blockdata::transaction"],[170,"secp256k1"],[171,"core::result"],[172,"core::borrow"],[173,"secp256k1::context"],[174,"alloc::string"],[175,"core::any"],[176,"bitcoin::blockdata::script::witness_version"]],"i":[0,0,42,10,42,9,0,0,0,0,0,0,9,10,10,0,9,9,11,42,7,9,10,11,12,13,14,42,7,9,10,11,12,13,14,3,7,9,10,11,12,13,14,7,9,10,11,12,13,14,7,9,13,14,11,11,13,12,7,9,10,10,11,12,13,14,42,7,9,10,10,10,10,11,12,13,14,14,7,13,14,7,13,42,7,9,10,11,12,13,14,14,14,12,0,12,12,12,7,14,7,13,13,14,7,13,9,7,7,9,10,11,12,13,14,10,12,42,7,9,10,11,12,13,14,42,7,9,10,11,12,13,14,14,42,7,9,10,11,12,13,14,42,7,9,10,11,12,13,14,12,45,45,46,47,48,49,49,48],"f":"```````````````````{{{b{c}}}{{b{e}}}{}{}}0000000{{{b{dc}}}{{b{de}}}{}{}}0000000{{{b{f}}{b{h}}}{{l{j}}}}{{{b{{n{c}}}}}{{n{c}}}A`}{{{b{{Ab{c}}}}}{{Ab{c}}}A`}{{{b{Ad}}}Ad}{{{b{{Af{c}}}}}{{Af{c}}}A`}{{{b{{Ah{c}}}}}{{Ah{c}}}A`}{{{b{Aj}}}Aj}{{{b{{Al{c}}}}}{{Al{c}}}A`}{{{b{c}}{b{de}}}An{}{}}000000{{}{{n{c}}}{}}{{}{{Ab{c}}}{}}{{}Aj}{{}{{Al{c}}}{}}```{{{b{{Ah{c}}}}}B`A`}{{{b{{n{c}}}}{b{dBb}}}BdBf}{{{b{{Ab{c}}}}{b{dBb}}}BdBf}{{{b{Ad}}{b{dBb}}}Bd}0{{{b{{Af{c}}}}{b{dBb}}}BdBf}{{{b{{Ah{c}}}}{b{dBb}}}BdBf}{{{b{Aj}}{b{dBb}}}Bd}{{{b{{Al{c}}}}{b{dBb}}}BdBf}{cc{}}000{BhAd}{BjAd}{BlAd}3333``````{ce{}{}}0000000``{{{b{{Ah{c}}}}}{{l{Bn}}}A`}{{{b{{C`{h}}}}{b{{Al{c}}}}}{{l{{Ah{c}}}}}{fA`}}{{{b{{Ah{c}}}}}{{l{Cb}}}A`}{{{b{{Ah{c}}}}}{{l{Cd}}}A`}{{{b{{Ah{c}}}}}{{n{c}}}A`}{{{b{{n{c}}}}}Cf{}}```````{{{b{{Ab{Ch}}}}B`{b{Cj}}{b{{Cl{c}}}}{l{Cn}}{l{D`}}{b{d{Db{e}}}}{b{dAj}}{b{{Dd{g}}}}}{{Df{CfAd}}}{{Dj{Dh}}}{{Dj{Dl}}}{DnE`}}`{{{b{c}}}e{}{}}000000{{{b{c}}}Eb{}}{{{b{{Ah{c}}}}{b{Aj}}}{{Ed{c}}}A`}{c{{Df{e}}}{}{}}000000000000000`{{{b{c}}}Ef{}}0000000<<<<<<<<{{{b{{Ah{c}}}}}{{l{Eh}}}A`}````````","D":"Fl","p":[[1,"reference"],[0,"mut"],[10,"CanDerive",0],[5,"DefiniteDescriptorKey",159],[5,"DerivationPath",160],[6,"Option",161],[5,"Requirements",0,162],[10,"Clone",163],[6,"RequiredSignatures",0,162],[6,"SigningError",0,162],[5,"PlanKey",0,164],[5,"Plan",0],[5,"SatisfactionMaterial",0],[5,"Assets",0],[1,"unit"],[1,"usize"],[5,"Formatter",165],[8,"Result",165],[10,"Debug",165],[6,"P2wpkhError",166],[6,"Error",160],[6,"TaprootError",166],[1,"u32"],[6,"Descriptor",167],[6,"LockTime",168],[5,"Sequence",169],[1,"bool"],[6,"DescriptorPublicKey",159],[8,"KeyMap",167],[6,"Prevouts",166],[6,"TapSighashType",166],[6,"EcdsaSighashType",166],[5,"SighashCache",166],[5,"Secp256k1",170],[6,"Result",171],[5,"TxOut",169],[10,"Borrow",172],[5,"Transaction",169],[10,"Signing",173],[10,"Verification",173],[5,"String",174],[6,"PlanState",0],[5,"TypeId",175],[6,"WitnessVersion",176],[15,"Complete",151],[15,"Legacy",153],[15,"Segwitv0",153],[15,"TapScript",153],[15,"TapKey",153]],"r":[[7,164],[9,162],[10,162],[15,162]],"b":[[60,"impl-Display-for-SigningError"],[61,"impl-Debug-for-SigningError"],[70,"impl-From%3CP2wpkhError%3E-for-SigningError"],[71,"impl-From%3CError%3E-for-SigningError"],[72,"impl-From%3CTaprootError%3E-for-SigningError"]],"c":"OjAAAAAAAAA=","e":"OzAAAAEAAGkAEAABAAEABAABAA4AAgAUACIAOwAHAEcAAgBOAAAAUQAAAFwAAQBfAAAAYgAAAGQAAABoAAAAawAAAG0AKQCaAAEA"}],\
-["bdk_wallet",{"t":"PPEPGPFEEGEFNNDNNNNNNNNENNNNNNNNNOOCQNNNNNNNNNNQNNNNNNNNNNOOCDNONCONNNEENNNNNNNNNNNNNONNNNOHNNNNCOOOPPPIGEGIKTIKRGFPPPPEKGPPPPTIPPPPPPPPPPNNNNNNNNNNNNNNNNNENNNNNNNNNNNNNMNNMNNNNNCNNNNNNNNNNNNNNNNNNNNNNNNNNCNONMNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNMNNNNNNNNNMNNNNNNMNNNNNNNNNNNNNNNNONNNNNNNNNMNNNNCNNNNNNNNNNNMNNNCNNNNNNNNNNNNNNNNNNNONNNNNNNNNNHHPPGPPPPPPPPPPPNNNNNNNNNNNNNNNNNNPPPGPFIPPIPPPPPPPPPPPGFGPPPPPGGPPPPNNNNNNNNNNNNNNNNNNNNNNNNNNOONNNNNNNNNNNNNNNNNNNNNNNNNNNNONNNNNNNNNNONNONNNNNONNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNOOOOOOOOOOOOOOOOOOOOOOOOFFFFFFFFKIFFFFNNNNNNNNNNNNNNNNNNNNNNNNMNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNPKGGGRRKGPKKFKPPPRGIPPPPPRPFPKGPPPFFGFPIPPPHMNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNMMNNNNNNNNNNNNNNNNNNNNNNNONNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNMNNNNNNNNNNNNNNNNNNNNMNNNNNNMNNNNNNNNNNNNNNNNNNNOONHNMNNHNMNNOONNNNNNMNNNNNMNHNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNKMMMFGFPIPPPKGPPPPPPGGPFFNNONNNNNNNNNNNNNNNNNNNNNNNNNNNNOONNNNNCONNNNNNNNNCCNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNOOOONNNNNNNNNNNMNONONNNNNNNNONNNNNNNNNNNNNNNCNNNNNNNNNNNNNNNONNNNNNNNNNNNNNNNNCNNNNNNNNNNNNONNNNNNNNHOOOOOOOOPPFPKFIGGPFPFNNNNNNNNNNNNNNNNNNMNNNHNNNOONNNNNNNNNNNNNNNNNNNNNONNNNNNNNNNNNNNNNNNNNNNNNNNNNNOOOOOOOGPPGPPPPPPPGPPPPPPPPPPPPPPPPPPNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNOOOOOOFIOONNNNNNNNNNNOONNNNNNPPPPPPPKPPPPPPPPPPPPPPPPFKGGGFFFPGKPNOONONNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNMNNNNNNNNNNNNNNNNNMNNNMNONONNNNNNNNOONNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNOGGPPPGPPPPPFGPPNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNOO","n":["External","Foreign","HdKeyPaths","Internal","KeychainKind","Local","LocalOutput","SignOptions","TxBuilder","Utxo","Wallet","WeightedUtxo","as_byte","as_ref","bitcoin","borrow","borrow","borrow","borrow","borrow_mut","borrow_mut","borrow_mut","borrow_mut","chain","clone","clone","clone","clone","clone_into","clone_into","clone_into","clone_into","cmp","confirmation_time","derivation_index","descriptor","descriptor","deserialize","deserialize","eq","eq","eq","eq","fmt","fmt","fmt","fmt","fragment","from","from","from","from","hash","hash","into","into","into","into","is_spent","keychain","keys","miniscript","outpoint","outpoint","partial_cmp","psbt","satisfaction_weight","sequence","serialize","serialize","signer","template","to_owned","to_owned","to_owned","to_owned","try_from","try_from","try_from","try_from","try_into","try_into","try_into","try_into","txout","txout","type_id","type_id","type_id","type_id","utxo","version","vzip","vzip","vzip","vzip","wallet","outpoint","psbt_input","sequence","Bare","Bare","Bare","DerivedDescriptor","Descriptor","DescriptorError","DescriptorPublicKey","ExtendedDescriptor","ExtractPolicy","FALSE","HdKeyPaths","IntoWalletDescriptor","Key","Legacy","Miniscript","MultiXPub","Pkh","Pkh","Pkh","Policy","ScriptContext","Segwitv0","Sh","Sh","Sh","Single","TRUE","TapKeyOrigins","Tr","Tr","Tr","Wpkh","Wpkh","Wpkh","Wsh","Wsh","Wsh","XPub","address","as_enum","as_enum","as_inner","as_node","at_derivation_index","borrow","borrow","borrow","borrow","borrow_mut","borrow_mut","borrow_mut","borrow_mut","branches","build_template","build_template_mall","calc_checksum","check_global_consensus_validity","check_global_consensus_validity","check_global_consensus_validity","check_global_policy_validity","check_global_policy_validity","check_global_validity","check_local_consensus_validity","check_local_consensus_validity","check_local_consensus_validity","check_local_policy_validity","check_local_policy_validity","check_local_policy_validity","check_local_validity","check_pk","check_pk","check_pk","check_terminal_non_malleable","check_terminal_non_malleable","check_terminal_non_malleable","check_witness","check_witness","check_witness","checksum","clone","clone","clone","clone","clone_into","clone_into","clone_into","clone_into","cmp","cmp","cmp","cmp","contains_raw_pkh","derive","derived_descriptor","derived_descriptor","desc_type","descriptor_id","deserialize","deserialize","dust_value","encode","eq","eq","eq","eq","error","explicit_script","ext","ext_check","extract_policy","extract_policy","extract_policy","find_derivation_index_for_spk","fmt","fmt","fmt","fmt","fmt","fmt","for_each_key","for_each_key","from","from","from","from","from","from","from","from","from","from","from_ast","from_components_unchecked","from_str","from_str","from_str_ext","from_str_insane","from_tree","from_tree","get_nth_child","get_nth_pk","get_satisfaction","get_satisfaction_mall","has_mixed_timelocks","has_repeated_keys","has_wildcard","hash","hash","hash","hash","into","into","into","into","into_inner","into_single_descriptors","into_wallet_descriptor","into_wallet_descriptor","is_deriveable","is_multipath","is_non_malleable","iter","iter_pk","lift","lift","lift_check","max_satisfaction_size","max_satisfaction_size","max_satisfaction_size","max_satisfaction_size","max_satisfaction_weight","max_satisfaction_witness_elements","max_weight_to_satisfy","name_str","name_str","name_str","new_bare","new_pk","new_pkh","new_sh","new_sh_sortedmulti","new_sh_with_wpkh","new_sh_with_wsh","new_sh_wpkh","new_sh_wsh","new_sh_wsh_sortedmulti","new_tr","new_wpkh","new_wsh","new_wsh_sortedmulti","node","other_top_level_checks","parse","parse_descriptor","parse_insane","parse_with_ext","partial_cmp","partial_cmp","partial_cmp","partial_cmp","pk_len","pk_len","pk_len","plan","plan_mall","policy","requires_sig","sanity_check","sanity_check","satisfy","satisfy","satisfy_malleable","script_code","script_pubkey","script_size","serialize","serialize","sig_type","sig_type","sig_type","substitute_raw_pkh","template","to_owned","to_owned","to_owned","to_owned","to_string","to_string","to_string_with_secret","top_level_checks","top_level_type_check","translate_pk","translate_pk","try_from","try_from","try_from","try_from","try_into","try_into","try_into","try_into","ty","type_id","type_id","type_id","type_id","unsigned_script_sig","vzip","vzip","vzip","vzip","within_resource_limits","calc_checksum","calc_checksum_bytes","Base58","Bip32","Error","ExternalAndInternalAreTheSame","HardenedDerivationXpub","Hex","InvalidDescriptorCharacter","InvalidDescriptorChecksum","InvalidHdKeyPath","Key","Miniscript","MultiPath","Pk","Policy","borrow","borrow_mut","fmt","fmt","from","from","from","from","from","from","from","from","into","to_string","try_from","try_into","type_id","vzip","AbsoluteTimelock","AddOnLeaf","AddOnPartialComplete","BuildSatisfaction","Complete","Condition","ConditionMap","EcdsaSignature","Fingerprint","FoldedConditionMap","Hash160Preimage","Hash256Preimage","IncompatibleConditions","IndexOutOfRange","MixedTimelockUnits","Multisig","None","None","NotEnoughItemsSelected","Partial","PartialComplete","PkOrF","Policy","PolicyError","Psbt","PsbtTimelocks","Pubkey","RelativeTimelock","Ripemd160Preimage","Satisfaction","SatisfiableItem","SchnorrSignature","Sha256Preimage","Thresh","XOnlyPubkey","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","clone","clone","clone","clone","clone","clone","clone_into","clone_into","clone_into","clone_into","clone_into","clone_into","contribution","csv","default","eq","eq","eq","eq","eq","eq","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","from","from","from","from","from","from","from","from","from","get_condition","hash","hash","id","id","into","into","into","into","into","into","into","is_leaf","is_leaf","is_null","item","partial_cmp","requires_path","satisfaction","serialize","serialize","serialize","serialize","serialize","timelock","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","to_string","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_into","try_into","try_into","try_into","try_into","try_into","try_into","type_id","type_id","type_id","type_id","type_id","type_id","type_id","vzip","vzip","vzip","vzip","vzip","vzip","vzip","current_height","input_max_height","psbt","condition","conditions","conditions","items","items","m","m","n","n","sorted","sorted","hash","hash","hash","hash","items","keys","threshold","threshold","value","value","Bip44","Bip44Public","Bip49","Bip49Public","Bip84","Bip84Public","Bip86","Bip86Public","DescriptorTemplate","DescriptorTemplateOut","P2Pkh","P2TR","P2Wpkh","P2Wpkh_P2Sh","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","build","build","build","build","build","build","build","build","build","build","build","build","build","from","from","from","from","from","from","from","from","from","from","from","from","into","into","into","into","into","into","into","into","into","into","into","into","into_wallet_descriptor","into_wallet_descriptor","into_wallet_descriptor","into_wallet_descriptor","into_wallet_descriptor","into_wallet_descriptor","into_wallet_descriptor","into_wallet_descriptor","into_wallet_descriptor","into_wallet_descriptor","into_wallet_descriptor","into_wallet_descriptor","into_wallet_descriptor","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_into","try_into","try_into","try_into","try_into","try_into","try_into","try_into","try_into","try_into","try_into","try_into","type_id","type_id","type_id","type_id","type_id","type_id","type_id","type_id","type_id","type_id","type_id","type_id","vzip","vzip","vzip","vzip","vzip","vzip","vzip","vzip","vzip","vzip","vzip","vzip","Bip32","DerivableKey","DescriptorKey","DescriptorPublicKey","DescriptorSecretKey","Entropy","Error","ExtScriptContext","ExtendedKey","FullKey","GeneratableDefaultOptions","GeneratableKey","GeneratedKey","IntoDescriptorKey","InvalidChecksum","InvalidNetwork","InvalidScriptContext","Key","KeyError","KeyMap","Legacy","Message","Miniscript","MultiXPrv","MultiXPub","Options","Private","PrivateKeyGenerateOptions","Public","ScriptContext","ScriptContextEnum","Segwitv0","Single","Single","SinglePriv","SinglePub","SinglePubKey","SortedMultiVec","Tap","ValidNetworks","XOnly","XPrv","XPub","any_network","as_enum","at_derivation_index","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","build_template","check_global_consensus_validity","check_global_policy_validity","check_global_validity","check_local_consensus_validity","check_local_policy_validity","check_local_validity","check_pk","check_terminal_non_malleable","check_witness","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone_into","clone_into","clone_into","clone_into","clone_into","clone_into","clone_into","clone_into","clone_into","cmp","cmp","cmp","cmp","compressed","default","deref","derive","deserialize","encode","eq","eq","eq","eq","eq","eq","eq","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","for_each_key","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from_public","from_secret","from_str","from_str","from_tree","full_derivation_path","full_derivation_paths","generate","generate_default","generate_default_with_aux_rand","generate_with_aux_rand","generate_with_entropy","generate_with_entropy_default","has_secret","has_wildcard","hash","hash","hash","hash","into","into","into","into","into","into","into","into","into","into","into","into","into_assets","into_descriptor_key","into_descriptor_key","into_descriptor_key","into_descriptor_key","into_descriptor_key","into_descriptor_key","into_descriptor_key","into_extended_key","into_extended_key","into_extended_key","into_key","into_single_keys","into_single_keys","into_xprv","into_xpub","is_deriveable","is_legacy","is_legacy","is_multipath","is_multipath","is_segwit_v0","is_segwit_v0","is_taproot","is_taproot","is_uncompressed","is_x_only_key","k","key","key","lift","mainnet_network","master_fingerprint","max_satisfaction_size","max_satisfaction_size","max_satisfaction_witness_elements","merge_networks","n","name_str","new","num_der_paths","origin","origin","other_top_level_checks","override_valid_networks","partial_cmp","partial_cmp","partial_cmp","partial_cmp","pk_len","pks","sanity_check","satisfy","script_size","serialize","sig_type","sorted_node","test_networks","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","to_public","to_string","to_string","to_string","to_string","top_level_checks","top_level_type_check","translate_pk","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_into","try_into","try_into","try_into","try_into","try_into","try_into","try_into","try_into","try_into","try_into","try_into","type_id","type_id","type_id","type_id","type_id","type_id","type_id","type_id","type_id","type_id","type_id","type_id","vzip","vzip","vzip","vzip","vzip","vzip","vzip","vzip","vzip","vzip","vzip","vzip","PsbtUtils","fee_amount","fee_rate","get_utxo_for","AddressInfo","ApplyBlockError","Balance","CannotConnect","ChangeSet","Descriptor","Descriptor","Descriptor","IsDust","LoadError","LoadedDescriptorDoesNotMatch","LoadedGenesisDoesNotMatch","LoadedNetworkDoesNotMatch","MissingDescriptor","MissingGenesis","MissingNetwork","NewError","NewOrLoadError","UnexpectedConnectedToHash","Update","Wallet","add","add_signer","address","all_unbounded_spk_iters","apply_block","apply_block_connected_to","apply_unconfirmed_txs","apply_update","as_ref","balance","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","build_fee_bump","build_tx","calculate_fee","calculate_fee_rate","cancel_tx","chain","chain","checkpoints","clone","clone","clone_into","clone_into","coin_selection","confirmed","default","default","deref","derivation_index","derivation_of_spk","descriptor_checksum","deserialize","eq","eq","error","export","finalize_psbt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","from","from","from","from","from","from","from","from","from","from","get_descriptor_for_keychain","get_psbt_input","get_signers","get_tx","get_utxo","graph","immature","index","indexed_tx_graph","insert_checkpoint","insert_tx","insert_txout","into","into","into","into","into","into","into","into","is_dust","is_mine","keychain","keychains","last_active_indices","latest_checkpoint","list_output","list_unspent","list_unused_addresses","load_from_changeset","local_chain","mark_used","network","network","new","new_or_load","new_or_load_with_genesis_hash","new_with_genesis_hash","next_derivation_index","next_unused_address","peek_address","policies","public_descriptor","reveal_addresses_to","reveal_next_address","secp_ctx","sent_and_received","serialize","sign","signer","spk_index","staged","start_full_scan","start_sync_with_revealed_spks","take_staged","to_owned","to_owned","to_string","to_string","to_string","to_string","to_string","to_string","total","transactions","trusted_pending","trusted_spendable","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_into","try_into","try_into","try_into","try_into","try_into","try_into","try_into","tx_builder","tx_graph","type_id","type_id","type_id","type_id","type_id","type_id","type_id","type_id","unbounded_spk_iter","unbroadcast_transactions","unmark_used","untrusted_pending","vzip","vzip","vzip","vzip","vzip","vzip","vzip","vzip","wallet_name_from_descriptor","connected_to_hash","expected_hash","expected","expected","got","got","got","keychain","BnBNoExactMatch","BnBTotalTriesExceeded","BranchAndBoundCoinSelection","Change","CoinSelectionAlgorithm","CoinSelectionResult","DefaultCoinSelectionAlgorithm","Error","Excess","InsufficientFunds","LargestFirstCoinSelection","NoChange","OldestFirstCoinSelection","borrow","borrow","borrow","borrow","borrow","borrow","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","clone","clone","clone","clone_into","clone_into","clone_into","coin_select","coin_select","coin_select","coin_select","decide_change","default","default","default","excess","fee_amount","fmt","fmt","fmt","fmt","fmt","fmt","fmt","from","from","from","from","from","from","into","into","into","into","into","into","local_selected_amount","new","selected","selected_amount","to_owned","to_owned","to_owned","to_string","try_from","try_from","try_from","try_from","try_from","try_from","try_into","try_into","try_into","try_into","try_into","try_into","type_id","type_id","type_id","type_id","type_id","type_id","vzip","vzip","vzip","vzip","vzip","vzip","available","needed","amount","change_fee","dust_threshold","fee","remaining_amount","BuildFeeBumpError","CoinSelection","Conversion","CreateTxError","Descriptor","FeeRateTooLow","FeeRateUnavailable","FeeTooLow","IrreplaceableTransaction","LockTime","MiniscriptPsbt","MiniscriptPsbtError","MissingKeyOrigin","MissingNonWitnessUtxo","NoRecipients","NoUtxosSelected","OutputBelowDustLimit","OutputUpdate","Policy","Psbt","RbfSequence","RbfSequenceCsv","SpendingPolicyRequired","TransactionConfirmed","TransactionNotFound","UnknownUtxo","UnknownUtxo","UtxoUpdate","Version0","Version1Csv","borrow","borrow","borrow","borrow_mut","borrow_mut","borrow_mut","clone","clone_into","fmt","fmt","fmt","fmt","fmt","fmt","from","from","from","from","from","from","from","from","into","into","into","to_owned","to_string","to_string","to_string","try_from","try_from","try_from","try_into","try_into","try_into","type_id","type_id","type_id","vzip","vzip","vzip","csv","rbf","requested","required","required","required","FullyNodedExport","WalletExport","blockheight","blockheight","borrow","borrow_mut","change_descriptor","descriptor","deserialize","export_wallet","fmt","fmt","from","from_str","into","label","label","serialize","to_string","try_from","try_into","type_id","vzip","All","Dummy","Exclude","External","Fingerprint","Include","InputIndexOutOfRange","InputSigner","InvalidKey","InvalidNonWitnessUtxo","InvalidSighash","Legacy","MiniscriptPsbt","MissingHdKeypath","MissingKey","MissingNonWitnessUtxo","MissingWitnessScript","MissingWitnessUtxo","NonStandardSighash","None","PkHash","Psbt","Segwitv0","SighashTaproot","SignOptions","SignerCommon","SignerContext","SignerError","SignerId","SignerOrdering","SignerWrapper","SignersContainer","Tap","TapLeavesOptions","TransactionSigner","UserCanceled","add_external","allow_all_sighashes","allow_grinding","as_key_map","assume_height","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","build","clone","clone","clone","clone","clone","clone","clone","clone_into","clone_into","clone_into","clone_into","clone_into","clone_into","clone_into","cmp","cmp","default","default","default","default","deref","descriptor_secret_key","descriptor_secret_key","descriptor_secret_key","descriptor_secret_key","eq","eq","eq","eq","find","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","from","from","from","from","from","from","from","from","from","from","hash","id","id","id","id","ids","into","into","into","into","into","into","into","into","new","new","partial_cmp","partial_cmp","remove","sign_input","sign_input","sign_input","sign_input","sign_transaction","sign_transaction","sign_with_tap_internal_key","signers","tap_leaves_options","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","to_string","trust_witness_utxo","try_finalize","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_into","try_into","try_into","try_into","try_into","try_into","try_into","try_into","type_id","type_id","type_id","type_id","type_id","type_id","type_id","type_id","vzip","vzip","vzip","vzip","vzip","vzip","vzip","vzip","is_internal_key","AddForeignUtxoError","AddUtxoError","Bip69Lexicographic","ChangeAllowed","ChangeForbidden","ChangeSpendPolicy","InvalidOutpoint","InvalidTxid","MissingUtxo","OnlyChange","Shuffle","TxBuilder","TxOrdering","UnknownUtxo","Untouched","add_data","add_foreign_utxo","add_foreign_utxo_with_sequence","add_global_xpubs","add_recipient","add_unspendable","add_utxo","add_utxos","allow_dust","borrow","borrow","borrow","borrow","borrow","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","change_policy","clone","clone","clone","clone_into","clone_into","clone_into","cmp","cmp","coin_selection","current_height","default","default","do_not_spend_change","drain_to","drain_wallet","enable_rbf","enable_rbf_with_sequence","eq","eq","fee_absolute","fee_rate","finish","finish_with_aux_rand","fmt","fmt","fmt","fmt","fmt","fmt","fmt","from","from","from","from","from","hash","hash","include_output_redeem_witness_script","into","into","into","into","into","manually_selected_only","nlocktime","only_spend_change","only_witness_utxo","ordering","partial_cmp","partial_cmp","policy_path","set_recipients","sighash","sort_tx","sort_tx_with_aux_rand","to_owned","to_owned","to_owned","to_string","to_string","try_from","try_from","try_from","try_from","try_from","try_into","try_into","try_into","try_into","try_into","type_id","type_id","type_id","type_id","type_id","unspendable","version","vzip","vzip","vzip","vzip","vzip","foreign_utxo","input_txid"],"q":[[0,"bdk_wallet"],[97,"bdk_wallet::Utxo"],[100,"bdk_wallet::descriptor"],[352,"bdk_wallet::descriptor::checksum"],[354,"bdk_wallet::descriptor::error"],[386,"bdk_wallet::descriptor::policy"],[533,"bdk_wallet::descriptor::policy::BuildSatisfaction"],[536,"bdk_wallet::descriptor::policy::Satisfaction"],[547,"bdk_wallet::descriptor::policy::SatisfiableItem"],[557,"bdk_wallet::descriptor::template"],[693,"bdk_wallet::keys"],[994,"bdk_wallet::psbt"],[998,"bdk_wallet::wallet"],[1201,"bdk_wallet::wallet::ApplyBlockError"],[1203,"bdk_wallet::wallet::NewOrLoadError"],[1209,"bdk_wallet::wallet::coin_selection"],[1301,"bdk_wallet::wallet::coin_selection::Error"],[1303,"bdk_wallet::wallet::coin_selection::Excess"],[1308,"bdk_wallet::wallet::error"],[1379,"bdk_wallet::wallet::error::CreateTxError"],[1385,"bdk_wallet::wallet::export"],[1408,"bdk_wallet::wallet::signer"],[1585,"bdk_wallet::wallet::signer::SignerContext"],[1586,"bdk_wallet::wallet::tx_builder"],[1703,"bdk_wallet::wallet::tx_builder::AddForeignUtxoError"],[1705,"bdk_wallet::types"],[1706,"core::cmp"],[1707,"core::result"],[1708,"serde::de"],[1709,"core::fmt"],[1710,"core::hash"],[1711,"bitcoin::blockdata::transaction"],[1712,"core::option"],[1713,"serde::ser"],[1714,"core::any"],[1715,"miniscript::descriptor"],[1716,"bitcoin::network"],[1717,"bitcoin::address"],[1718,"miniscript"],[1719,"miniscript::miniscript"],[1720,"miniscript::miniscript::decode"],[1721,"miniscript::miniscript::context"],[1722,"miniscript::iter::tree"],[1723,"miniscript::descriptor::key"],[1724,"alloc::vec"],[1725,"miniscript::miniscript::satisfy"],[1726,"miniscript::plan"],[1727,"bitcoin_hashes::sha256"],[1728,"miniscript::miniscript::hash256"],[1729,"bitcoin_hashes::ripemd160"],[1730,"bitcoin_hashes::hash160"],[1731,"core::clone"],[1732,"secp256k1"],[1733,"bitcoin::crypto::key"],[1734,"secp256k1::context"],[1735,"bdk_chain::descriptor_ext"],[1736,"miniscript::blanket_traits"],[1737,"bitcoin::blockdata::script::owned"],[1738,"miniscript::miniscript::analyzable"],[1739,"secp256k1::context::alloc_only"],[1740,"bitcoin::blockdata::script::borrowed"],[1741,"core::ops::range"],[1742,"core::ops::function"],[1743,"miniscript::descriptor::segwitv0"],[1744,"miniscript::descriptor::sh"],[1745,"miniscript::descriptor::bare"],[1746,"miniscript::descriptor::tr"],[1747,"miniscript::miniscript::types"],[1748,"miniscript::miniscript::types::extra_props"],[1749,"miniscript::expression"],[1750,"miniscript::miniscript::iter"],[1751,"miniscript::policy::semantic"],[1752,"miniscript::policy"],[1753,"bitcoin_units::weight"],[1754,"alloc::collections::btree::map"],[1755,"alloc::string"],[1756,"bitcoin::bip32"],[1757,"base58ck::error"],[1758,"hex_conservative::error"],[1759,"miniscript::descriptor::sortedmulti"],[1760,"core::str::traits"],[1761,"core::convert"],[1762,"core::default"],[1763,"rand_core"],[1764,"bitcoin_units::amount"],[1765,"bitcoin_units::fee_rate"],[1766,"bdk_chain::keychain"],[1767,"alloc::sync"],[1768,"core::iter::traits::iterator"],[1769,"bitcoin::blockdata::block"],[1770,"bdk_chain::local_chain"],[1771,"bdk_chain::chain_data"],[1772,"core::iter::traits::collect"],[1773,"bdk_chain::tx_graph"],[1774,"bitcoin::psbt"],[1775,"bdk_chain::spk_client"],[1776,"bitcoin::psbt::map::input"],[1777,"bdk_wallet::wallet::utils"],[1778,"core::iter::traits::double_ended"],[1779,"bdk_chain::keychain::txout_index"],[1780,"bitcoin::psbt::error"],[1781,"core::marker"],[1782,"bitcoin::blockdata::script::push_bytes::primitive"],[1783,"bitcoin::blockdata::locktime::absolute"]],"i":[1,8,0,1,0,8,0,0,0,0,0,0,1,1,0,1,6,7,8,1,6,7,8,0,1,6,7,8,1,6,7,8,1,6,6,0,0,1,6,1,6,7,8,1,6,7,8,0,1,6,7,8,1,6,1,6,7,8,6,6,0,0,8,6,1,0,7,8,1,6,0,0,1,6,7,8,1,6,7,8,1,6,7,8,8,6,1,6,7,8,7,0,1,6,7,8,0,248,248,248,94,249,24,0,0,0,0,0,0,31,0,0,33,0,0,35,94,249,24,0,0,0,94,249,24,35,31,0,94,249,24,94,249,24,94,249,24,35,24,54,55,31,31,24,24,54,55,31,24,54,55,31,31,31,31,0,33,54,55,33,55,33,33,54,55,33,54,55,33,33,54,55,33,54,55,33,54,55,0,24,54,55,31,24,54,55,31,24,54,55,31,31,24,24,24,24,24,24,31,24,31,24,54,55,31,0,24,31,31,69,24,31,24,24,24,54,55,31,31,24,31,24,24,24,24,24,24,24,54,55,31,31,31,24,31,31,31,24,31,31,31,24,24,31,31,24,24,54,55,31,24,54,55,31,31,24,93,94,24,24,31,31,31,24,31,31,33,54,55,31,24,31,24,33,54,55,24,24,24,24,24,24,24,24,24,24,24,24,24,24,31,33,31,24,31,31,24,54,55,31,33,54,55,24,24,0,31,24,31,24,31,31,24,24,31,24,31,33,54,55,31,0,24,54,55,31,24,31,24,33,33,24,31,24,54,55,31,24,54,55,31,31,24,54,55,31,24,24,54,55,31,31,0,0,74,74,0,74,74,74,74,74,74,74,74,74,74,74,74,74,74,74,74,74,74,74,74,74,74,74,74,74,74,74,74,74,121,119,119,0,122,0,0,121,120,0,121,121,119,119,119,121,122,71,119,122,122,0,0,0,71,71,120,121,121,0,0,121,121,121,120,120,121,122,73,123,119,71,120,121,122,73,123,119,71,120,121,122,73,123,71,120,121,122,73,123,71,73,123,123,120,121,122,73,123,119,120,121,122,73,123,119,119,71,120,121,122,122,73,73,123,119,71,73,120,123,121,73,120,121,122,73,123,119,71,121,122,123,73,123,73,73,120,121,122,73,123,123,120,121,122,73,123,71,119,120,121,122,73,123,119,71,120,121,122,73,123,119,71,120,121,122,73,123,119,71,120,121,122,73,123,119,71,250,250,250,251,252,253,252,253,252,253,252,253,252,253,254,255,256,257,258,259,259,258,260,261,0,0,0,0,0,0,0,0,0,0,0,0,0,0,126,128,129,130,132,134,135,136,137,138,139,140,126,128,129,130,132,134,135,136,137,138,139,140,124,126,128,129,130,132,134,135,136,137,138,139,140,126,128,129,130,132,134,135,136,137,138,139,140,126,128,129,130,132,134,135,136,137,138,139,140,125,126,128,129,130,132,134,135,136,137,138,139,140,126,128,129,130,132,134,135,136,137,138,139,140,126,128,129,130,132,134,135,136,137,138,139,140,126,128,129,130,132,134,135,136,137,138,139,140,126,128,129,130,132,134,135,136,137,138,139,140,117,0,0,0,0,158,158,0,0,147,0,0,0,0,117,117,117,33,0,0,30,117,117,103,35,158,151,0,151,0,0,30,35,103,0,0,0,0,30,0,147,103,35,0,262,35,151,143,148,30,144,117,142,35,103,145,146,147,151,143,148,30,144,117,142,35,103,145,146,147,142,33,33,33,33,33,33,33,33,33,143,30,144,142,35,103,145,146,147,143,30,144,142,35,103,145,146,147,142,35,145,147,144,144,143,35,35,142,30,142,35,103,145,146,147,148,30,144,117,117,142,142,35,35,103,103,145,146,147,142,151,151,151,143,148,30,144,117,117,117,142,35,35,103,145,146,147,148,148,35,103,142,35,35,158,161,161,158,158,161,151,35,142,35,145,147,151,143,148,30,144,117,142,35,103,145,146,147,35,127,133,143,143,148,35,103,133,151,143,143,35,103,151,151,35,262,30,35,103,262,30,262,30,35,35,142,145,146,142,0,35,33,142,142,0,142,33,142,35,145,146,33,148,142,35,145,147,33,142,142,142,142,35,33,142,0,143,30,144,142,35,103,145,146,147,103,117,142,35,103,33,33,142,151,143,148,30,144,117,142,35,103,145,146,147,151,143,148,30,144,117,142,35,103,145,146,147,151,143,148,30,144,117,142,35,103,145,146,147,151,143,148,30,144,117,142,35,103,145,146,147,0,168,168,168,0,0,0,202,0,199,200,201,0,0,201,201,201,200,200,200,0,0,202,0,0,171,172,195,172,172,172,172,172,172,172,171,172,185,195,199,200,201,202,171,172,185,195,199,200,201,202,172,172,172,172,172,213,185,172,171,185,171,185,0,171,171,185,195,172,172,172,171,171,195,0,0,172,171,171,172,185,195,195,199,199,200,200,201,201,202,202,171,172,185,185,185,195,199,200,201,202,172,172,172,172,172,185,171,195,213,172,172,172,171,172,185,195,199,200,201,202,210,172,195,172,185,172,172,172,172,172,172,172,172,213,172,172,172,172,172,172,172,172,172,172,172,172,172,171,172,0,172,172,172,172,172,171,185,171,195,199,200,201,202,171,172,171,171,171,172,185,195,199,200,201,202,171,172,185,195,199,200,201,202,0,172,171,172,185,195,199,200,201,202,172,172,172,171,171,172,185,195,199,200,201,202,0,263,263,264,265,264,265,266,266,225,225,0,226,0,0,0,0,0,225,0,226,0,225,226,224,220,221,222,225,226,224,220,221,222,220,221,222,220,221,222,223,220,221,222,0,220,221,222,224,224,225,225,226,224,220,221,222,225,226,224,220,221,222,225,226,224,220,221,222,224,222,224,224,220,221,222,225,225,226,224,220,221,222,225,226,224,220,221,222,225,226,224,220,221,222,225,226,224,220,221,222,267,267,268,269,269,268,269,0,207,227,0,207,207,192,207,192,207,207,0,207,207,207,207,207,227,207,207,207,207,207,192,192,207,192,227,207,207,227,207,192,227,207,192,227,227,227,227,207,207,192,192,227,207,207,207,207,207,207,192,227,207,192,227,227,207,192,227,207,192,227,207,192,227,207,192,227,207,192,270,270,271,271,272,273,0,0,274,229,229,229,229,229,229,229,229,229,229,229,229,274,229,229,229,229,229,229,229,234,230,234,198,230,234,198,0,198,198,198,231,198,198,198,198,198,198,198,234,230,198,231,198,0,0,0,0,0,0,0,0,231,0,0,198,70,197,197,70,197,230,198,231,232,173,70,197,234,230,198,231,232,173,70,197,234,70,230,231,232,173,70,197,234,230,231,232,173,70,197,234,230,173,173,70,197,234,232,235,232,232,232,230,231,173,234,70,230,198,198,231,232,173,70,197,234,230,230,230,198,231,232,173,70,197,234,230,235,232,232,232,70,230,198,231,232,173,70,197,234,232,70,230,173,70,239,232,232,232,174,232,197,70,197,230,231,232,173,70,197,234,198,197,197,230,198,231,232,173,70,197,234,230,198,231,232,173,70,197,234,230,198,231,232,173,70,197,234,230,198,231,232,173,70,197,234,275,0,0,245,244,244,0,242,242,242,244,245,0,0,243,245,191,191,191,191,191,191,191,191,191,191,243,242,245,244,191,243,242,245,244,191,191,245,244,191,245,244,245,244,191,191,245,244,191,191,191,191,191,245,244,191,191,191,191,191,243,243,242,242,245,244,191,243,242,245,244,245,244,191,191,243,242,245,244,191,191,191,191,191,245,244,191,191,191,245,245,191,245,244,243,242,191,243,242,245,244,191,243,242,245,244,191,243,242,245,244,191,191,191,243,242,245,244,276,276],"f":"````````````{{{d{b}}}f}{{{d{b}}}{{d{{h{f}}}}}}`{{{d{c}}}{{d{e}}}{}{}}000{{{d{jc}}}{{d{je}}}{}{}}000`{{{d{b}}}b}{{{d{l}}}l}{{{d{n}}}n}{{{d{A`}}}A`}{{{d{c}}{d{je}}}Ab{}{}}000{{{d{b}}{d{b}}}Ad}````{c{{Af{b}}}Ah}{c{{Af{l}}}Ah}{{{d{b}}{d{b}}}Aj}{{{d{l}}{d{l}}}Aj}{{{d{n}}{d{n}}}Aj}{{{d{A`}}{d{A`}}}Aj}{{{d{b}}{d{jAl}}}An}{{{d{l}}{d{jAl}}}An}{{{d{n}}{d{jAl}}}An}{{{d{A`}}{d{jAl}}}An}`{cc{}}000{{{d{b}}{d{jc}}}AbB`}{{{d{l}}{d{jc}}}AbB`}{ce{}{}}000````{{{d{A`}}}Bb}`{{{d{b}}{d{b}}}{{Bd{Ad}}}}``{{{d{A`}}}{{Bd{Bf}}}}{{{d{b}}c}AfBh}{{{d{l}}c}AfBh}``{{{d{c}}}e{}{}}000{c{{Af{e}}}{}{}}0000000{{{d{A`}}}{{d{Bj}}}}`{{{d{c}}}Bl{}}000`{{}{{d{Bn}}}}::::``````````````````````````````````````````{{{d{{C`{c}}}}Cb}{{Af{CdCf}}}{ChCj}}{{}Cl}0{{{d{{Cn{ce}}}}}{{d{{D`{ce}}}}}ChDb}{{{d{{d{{Cn{ce}}}}}}}{{Dd{{d{{Cn{ce}}}}}}}ChDb}{{{d{{C`{Df}}}}Dh}{{Af{{C`{Dj}}Dl}}}}{{{d{c}}}{{d{e}}}{}{}}000{{{d{jc}}}{{d{je}}}{}{}}000{{{d{{Cn{ce}}}}}{{Dn{{d{{Cn{ce}}}}}}}ChDb}{{{d{{Cn{ce}}}}{d{g}}}{{Eb{{E`{c}}}}}{CjCh}Db{{Ed{c}}}}0`{{{d{{Cn{c{Db{}{{Ef{e}}}}}}}}}{{Af{AbEh}}}Ch{{Fj{}{{Ej{El}}{En{F`}}{Fb{Fd}}{Ff{Fh}}}}ChChChCh}}{{{d{{Cn{cFl}}}}}{{Af{AbEh}}}Ch}{{{d{{Cn{cFn}}}}}{{Af{AbEh}}}Ch}2022102102{{{d{c}}}{{Af{AbEh}}}Ch}00{{{d{{D`{c{Db{}{{Ef{e}}}}}}}}}{{Af{AbEh}}}Ch{{Fj{}{{Ej{El}}{En{F`}}{Fb{Fd}}{Ff{Fh}}}}ChChChCh}}{{{d{{D`{cFl}}}}}{{Af{AbEh}}}Ch}{{{d{{D`{cFn}}}}}{{Af{AbEh}}}Ch}{{{d{{h{{Dn{f}}}}}}}{{Af{AbEh}}}}00`{{{d{{C`{c}}}}}{{C`{c}}}{G`Ch}}{{{d{Fl}}}Fl}{{{d{Fn}}}Fn}{{{d{{Cn{ce}}}}}{{Cn{ce}}}{G`Ch}{G`Db}}{{{d{c}}{d{je}}}Ab{}{}}000{{{d{{C`{c}}}}{d{{C`{c}}}}}Ad{GbCh}}{{{d{Fl}}{d{Fl}}}Ad}{{{d{Fn}}{d{Fn}}}Ad}{{{d{{Cn{ce}}}}{d{{Cn{ce}}}}}AdChDb}{{{d{{Cn{ce}}}}}AjChDb}{{{d{{C`{Df}}}}Dh}{{Af{{C`{Dj}}Dl}}}}{{{d{{C`{Dj}}}}{d{{Gd{c}}}}}{{Af{{C`{Gf}}Dl}}}Gh}{{{d{{C`{Df}}}}{d{{Gd{c}}}}Dh}{{Af{{C`{Gf}}Dl}}}Gh}{{{d{{C`{c}}}}}GjCh}{{{d{{C`{Df}}}}}Gl}{c{{Af{{C`{e}}}}}AhGn}{c{{Af{{Cn{eg}}}}}AhGnDb}{{{d{{C`{Df}}}}}H`}{{{d{{Cn{ce}}}}}Hb{CjCh}Db}{{{d{{C`{c}}}}{d{{C`{c}}}}}Aj{HdCh}}{{{d{Fl}}{d{Fl}}}Aj}{{{d{Fn}}{d{Fn}}}Aj}{{{d{{Cn{ce}}}}{d{{Cn{ce}}}}}AjChDb}`{{{d{{C`{c}}}}}{{Af{HbCf}}}{ChCj}}`{{{d{{Cn{ce}}}}{d{Hf}}}{{Af{AbHh}}}ChDb}{{{d{Hj}}{d{Hl}}Hn{d{{Gd{I`}}}}}{{Af{{Bd{Ib}}Id}}}}{{{d{{C`{Df}}}}{d{Hl}}Hn{d{{Gd{I`}}}}}{{Af{{Bd{Ib}}Id}}}}{{{d{{Cn{Dfc}}}}{d{Hl}}Hn{d{{Gd{I`}}}}}{{Af{{Bd{Ib}}Id}}}Db}{{{d{{C`{Df}}}}{d{{Gd{c}}}}{d{If}}{Ih{Dh}}}{{Af{{Bd{{Ij{Dh{C`{Gf}}}}}}Dl}}}Gh}{{{d{{C`{c}}}}{d{jAl}}}{{Af{AbIl}}}Ch}0{{{d{Fl}}{d{jAl}}}{{Af{AbIl}}}}{{{d{Fn}}{d{jAl}}}{{Af{AbIl}}}}{{{d{{Cn{ce}}}}{d{jAl}}}{{Af{AbIl}}}ChDb}0{{{d{{C`{c}}}}e}AjCh{{J`{{d{c}}}{{In{Aj}}}}}}{{{d{{Cn{ce}}}}g}AjChDb{{J`{{d{c}}}{{In{Aj}}}}}}{{{Jb{c}}}{{C`{c}}}Ch}{{{Jd{c}}}{{C`{c}}}Ch}{{{Jf{c}}}{{C`{c}}}Ch}{{{Jh{c}}}{{C`{c}}}Ch}{{{Jj{c}}}{{C`{c}}}Ch}{cc{}}{{{Jl{c}}}{{C`{c}}}Ch}111{{{D`{ce}}}{{Af{{Cn{ce}}Cf}}}ChDb}{{{D`{ce}}JnK`}{{Cn{ce}}}ChDb}{{{d{Bn}}}{{Af{{C`{c}}Cf}}}Gn}{{{d{Bn}}}{{Af{{Cn{ce}}Cf}}}GnDb}{{{d{Bn}}{d{Hf}}}{{Af{{Cn{ce}}Cf}}}GnDb}1{{{d{Kb}}}{{Af{{C`{c}}Cf}}}Gn}{{{d{Kb}}}{{Af{{Cn{ce}}Cf}}}GnDb}{{{d{{Cn{ce}}}}Kd}{{Bd{{d{{Cn{ce}}}}}}}ChDb}{{{d{{Cn{ce}}}}Kd}{{Bd{c}}}ChDb}{{{d{{C`{c}}}}e}{{Af{{Ij{{Dn{{Dn{f}}}}Hb}}Cf}}}{ChCj}{{Kf{c}}}}0{{{d{{Cn{ce}}}}}AjChDb}0{{{d{{C`{Df}}}}}Aj}{{{d{{C`{c}}}}{d{je}}}Ab{KhCh}B`}{{{d{Fl}}{d{jc}}}AbB`}{{{d{Fn}}{d{jc}}}AbB`}{{{d{{Cn{ce}}}}{d{jg}}}AbChDbB`}{ce{}{}}000{{{Cn{ce}}}{{D`{ce}}}ChDb}{{{C`{Df}}}{{Af{{Dn{{C`{Df}}}}Cf}}}}{{Kj{d{{Gd{I`}}}}Cb}{{Af{{Ij{KlKn}}Id}}}}{{Kl{d{{Gd{I`}}}}Cb}{{Af{{Ij{KlKn}}Id}}}}99:{{{d{{Cn{ce}}}}}{{L`{ce}}}ChDb}{{{d{{Cn{ce}}}}}{{Lb{ce}}}ChDb}{{{d{{C`{c}}}}}{{Af{{Ld{c}}Cf}}}Ch}{{{d{{Cn{ce}}}}}{{Af{{Ld{c}}Cf}}}ChDb}{{{d{{Cn{ce}}}}}{{Af{AbLf}}}ChDb}{{{d{{Cn{c{Db{}{{Ef{e}}}}}}}}}{{Bd{Kd}}}Ch{{Fj{}{{Ej{El}}{En{F`}}{Fb{Fd}}{Ff{Fh}}}}ChChChCh}}{{{d{{Cn{cFl}}}}}{{Bd{Kd}}}Ch}{{{d{{Cn{cFn}}}}}{{Bd{Kd}}}Ch}{{{d{{Cn{ce}}}}}{{Af{KdCf}}}ChDb}{{{d{{C`{c}}}}}{{Af{KdCf}}}Ch}1{{{d{{C`{c}}}}}{{Af{LhCf}}}Ch}{{}{{d{Bn}}}}00{{{Cn{cLj}}}{{Af{{C`{c}}Cf}}}Ch}{c{{C`{c}}}Ch}{c{{Af{{C`{c}}Cf}}}Ch}{{{Cn{cFl}}}{{Af{{C`{c}}Cf}}}Ch}{{Kd{Dn{c}}}{{Af{{C`{c}}Cf}}}Ch}{{{Jb{c}}}{{C`{c}}}Ch}{{{Jj{c}}}{{C`{c}}}Ch}4{{{Cn{cFn}}}{{Af{{C`{c}}Cf}}}Ch}3{{c{Bd{{Ll{c}}}}}{{Af{{C`{c}}Cf}}}Ch}614`{{{d{{Cn{c{Db{}{{Ef{e}}}}}}}}}{{Af{AbCf}}}Ch{{Fj{}{{Ej{El}}{En{F`}}{Fb{Fd}}{Ff{Fh}}}}ChChChCh}}{{{d{If}}}{{Af{{Cn{c}}Cf}}}Db}{{{d{{Gd{c}}}}{d{Bn}}}{{Af{{Ij{{C`{Df}}{M`{DfLn}}}}Cf}}}Mb}1{{{d{If}}{d{Hf}}}{{Af{{Cn{c}}Cf}}}Db}{{{d{{C`{c}}}}{d{{C`{c}}}}}{{Bd{Ad}}}{MdCh}}{{{d{Fl}}{d{Fl}}}{{Bd{Ad}}}}{{{d{Fn}}{d{Fn}}}{{Bd{Ad}}}}{{{d{{Cn{ce}}}}{d{{Cn{ce}}}}}{{Bd{Ad}}}ChDb}{{{d{c}}}KdCh}00{{{C`{Dj}}{d{c}}}{{Af{Mf{C`{Dj}}}}}{{Ed{Dj}}}}0`{{{d{{Cn{ce}}}}}AjChDb}{{{d{{C`{c}}}}}{{Af{AbCf}}}Ch}{{{d{{Cn{ce}}}}}{{Af{AbHh}}}ChDb}{{{d{{C`{c}}}}{d{jMh}}e}{{Af{AbCf}}}{ChCj}{{Kf{c}}}}{{{d{{Cn{ce}}}}g}{{Af{{Dn{{Dn{f}}}}Cf}}}{CjCh}Db{{Kf{c}}}}0{{{d{{C`{c}}}}}{{Af{HbCf}}}{ChCj}}{{{d{{C`{c}}}}}Hb{ChCj}}{{{d{{Cn{ce}}}}}KdChDb}{{{d{{C`{c}}}}e}AfChBh}{{{d{{Cn{ce}}}}g}AfChDbBh}{{}Mj}00{{{d{{Cn{ce}}}}{d{{M`{Fhc}}}}}{{Cn{ce}}}ChDb}`{{{d{c}}}e{}{}}000{{{d{c}}}Ml{}}0{{{d{{C`{Df}}}}{d{{M`{DfLn}}}}}Ml}{{{d{{Cn{c{Db{}{{Ef{e}}}}}}}}}{{Af{AbCf}}}Ch{{Fj{}{{Ej{El}}{En{F`}}{Fb{Fd}}{Ff{Fh}}}}ChChChCh}}0{{{d{{C`{c}}}}{d{ji}}}{{Af{{Mn{g}}}}}ChCh{}{{N`{ceg}}}}{{{d{{Cn{ce}}}}{d{jk}}}{{Af{{Mn{i}}}}}ChDbCh{}{{N`{cgi}}}}{c{{Af{e}}}{}{}}0000000`{{{d{c}}}Bl{}}000={ce{}{}}000{{{d{{Cn{ce}}}}}AjChDb}{{{d{Bn}}}{{Af{MlId}}}}{{{d{Bn}}}{{Af{{Nb{f}}Id}}}}``````````````{{{d{c}}}{{d{e}}}{}{}}{{{d{jc}}}{{d{je}}}{}{}}{{{d{Id}}{d{jAl}}}An}0{cc{}}{CfId}{NdId}{NfId}{NhId}{NjId}{NlId}{NnId}>{{{d{c}}}Ml{}}{c{{Af{e}}}{}{}}0{{{d{c}}}Bl{}}{ce{}{}}```````````````````````````````````>>>>>>>======={{{d{O`}}}O`}{{{d{Ob}}}Ob}{{{d{Od}}}Od}{{{d{Ib}}}Ib}{{{d{Of}}}Of}{{{d{Hn}}}Hn}{{{d{c}}{d{je}}}Ab{}{}}00000``{{}Of}{{{d{O`}}{d{O`}}}Aj}{{{d{Ob}}{d{Ob}}}Aj}{{{d{Od}}{d{Od}}}Aj}{{{d{Ib}}{d{Ib}}}Aj}{{{d{Of}}{d{Of}}}Aj}{{{d{Nn}}{d{Nn}}}Aj}{{{d{O`}}{d{jAl}}}An}{{{d{Ob}}{d{jAl}}}An}{{{d{Od}}{d{jAl}}}An}{{{d{Ib}}{d{jAl}}}An}{{{d{Of}}{d{jAl}}}An}{{{d{Nn}}{d{jAl}}}An}0{{{d{Hn}}{d{jAl}}}An}{cc{}}0{AjOd}1{ObIb}2222{{{d{Ib}}{d{{M`{Ml{Dn{Kd}}}}}}}{{Af{OfNn}}}}{{{d{O`}}{d{jc}}}AbB`}{{{d{Of}}{d{jc}}}AbB`}{{{d{Ob}}}Ml}`{ce{}{}}000000{{{d{Ob}}}Aj}{{{d{Od}}}Aj}{{{d{Of}}}Aj}`{{{d{Of}}{d{Of}}}{{Bd{Ad}}}}{{{d{Ib}}}Aj}`{{{d{O`}}c}AfBh}{{{d{Ob}}c}AfBh}{{{d{Od}}c}AfBh}{{{d{Ib}}c}AfBh}{{{d{Of}}c}AfBh}`{{{d{c}}}e{}{}}00000{{{d{c}}}Ml{}}{c{{Af{e}}}{}{}}0000000000000{{{d{c}}}Bl{}}000000>>>>>>>``````````````````````````````````````{{{d{c}}}{{d{e}}}{}{}}00000000000{{{d{jc}}}{{d{je}}}{}{}}00000000000{{OhCb}{{Af{OjId}}}}{{{Ol{c}}Cb}{{Af{OjId}}}{{On{Fl}}}}{{{A@`{c}}Cb}{{Af{OjId}}}{{On{Fn}}}}{{{A@b{c}}Cb}{{Af{OjId}}}{{On{Fn}}}}{{{A@d{c}}Cb}{{Af{OjId}}}{{On{A@f}}}}{{{A@h{c}}Cb}{{Af{OjId}}}{{A@j{Fl}}}}{{{A@l{c}}Cb}{{Af{OjId}}}{{A@j{Fl}}}}{{{A@n{c}}Cb}{{Af{OjId}}}{{A@j{Fn}}}}{{{AA`{c}}Cb}{{Af{OjId}}}{{A@j{Fn}}}}{{{AAb{c}}Cb}{{Af{OjId}}}{{A@j{Fn}}}}{{{AAd{c}}Cb}{{Af{OjId}}}{{A@j{Fn}}}}{{{AAf{c}}Cb}{{Af{OjId}}}{{A@j{A@f}}}}{{{AAh{c}}Cb}{{Af{OjId}}}{{A@j{A@f}}}}{cc{}}00000000000{ce{}{}}00000000000{{Oj{d{{Gd{I`}}}}Cb}{{Af{{Ij{KlKn}}Id}}}}{{c{d{{Gd{I`}}}}Cb}{{Af{{Ij{{C`{Df}}{M`{DfLn}}}}Id}}}{}}00000000000{c{{Af{e}}}{}{}}00000000000000000000000{{{d{c}}}Bl{}}00000000000444444444444```````````````````````````````````````````{{}AAj}{{}Cl}{{DfDh}{{Af{DjDl}}}}{{{d{c}}}{{d{e}}}{}{}}00000000000{{{d{jc}}}{{d{je}}}{}{}}00000000000{{{d{{AAl{ce}}}}{d{g}}}{{Eb{{E`{c}}}}}{CjCh}Db{{Ed{c}}}}{{{d{{Cn{c{Db{}{{Ef{e}}}}}}}}}{{Af{AbEh}}}Ch{{Fj{}{{Ej{El}}{En{F`}}{Fb{Fd}}{Ff{Fh}}}}ChChChCh}}00000{{{d{c}}}{{Af{AbEh}}}Ch}{{{d{{D`{c{Db{}{{Ef{e}}}}}}}}}{{Af{AbEh}}}Ch{{Fj{}{{Ej{El}}{En{F`}}{Fb{Fd}}{Ff{Fh}}}}ChChChCh}}{{{d{{h{{Dn{f}}}}}}}{{Af{AbEh}}}}{{{d{{AAn{ce}}}}}{{AAn{ce}}}G`Db}{{{d{Cl}}}Cl}{{{d{AB`}}}AB`}{{{d{{AAl{ce}}}}}{{AAl{ce}}}{G`Ch}{G`Db}}{{{d{Df}}}Df}{{{d{Ln}}}Ln}{{{d{ABb}}}ABb}{{{d{ABd}}}ABd}{{{d{ABf}}}ABf}{{{d{c}}{d{je}}}Ab{}{}}00000000{{{d{{AAl{ce}}}}{d{{AAl{ce}}}}}Ad{GbCh}{GbDb}}{{{d{Df}}{d{Df}}}Ad}{{{d{ABb}}{d{ABb}}}Ad}{{{d{ABf}}{d{ABf}}}Ad}`{{}AB`}{{{d{{AAn{ce}}}}}{{d{g}}}{}Db{}}{{DfDh}{{Af{DjDl}}}}{c{{Af{Df}}}Ah}{{{d{{AAl{ce}}}}}Hb{CjCh}Db}{{{d{Cl}}{d{Cl}}}Aj}{{{d{{AAl{ce}}}}{d{{AAl{ce}}}}}Aj{HdCh}{HdDb}}{{{d{Df}}{d{Df}}}Aj}{{{d{Ln}}{d{Ln}}}Aj}{{{d{ABb}}{d{ABb}}}Aj}{{{d{ABd}}{d{ABd}}}Aj}{{{d{ABf}}{d{ABf}}}Aj}{{{d{{ABh{c}}}}{d{jAl}}}An{ABjDb}}{{{d{Cl}}{d{jAl}}}An}{{{d{AB`}}{d{jAl}}}An}{{{d{Nj}}{d{jAl}}}An}0{{{d{{AAl{ce}}}}{d{jAl}}}{{Af{AbIl}}}ChDb}0{{{d{Df}}{d{jAl}}}{{Af{AbIl}}}}0{{{d{Ln}}{d{jAl}}}{{Af{AbIl}}}}0{{{d{ABb}}{d{jAl}}}{{Af{AbIl}}}}{{{d{ABd}}{d{jAl}}}{{Af{AbIl}}}}{{{d{ABf}}{d{jAl}}}{{Af{AbIl}}}}{{{d{{AAl{ce}}}}g}AjChDb{{J`{{d{c}}}{{In{Aj}}}}}}{cc{}}{ABl{{ABn{c}}}Db}{AC`{{ABn{c}}}Db}2222{CfNj}{NfNj}44{DjDf}55555{{DfAAj}{{ABh{c}}}Db}{{LnAAj}{{ABh{c}}}Db}{{{d{Bn}}}{{Af{Df}}}}{{{d{Bn}}}{{Af{Ln}}}}{{{d{Kb}}}{{Af{{AAl{ce}}Cf}}}{ACbCh}Db}{{{d{Df}}}{{Bd{ACd}}}}{{{d{Df}}}{{Dn{ACd}}}}{c{{Af{{AAn{{ACl{}{{ACf{e}}{ACh{c}}{ACj{g}}}}i}}g}}}{}{{ACn{{h{f}}}}AD`}ABjDb}{{}{{Af{{AAn{ADbc}}e}}}Db{}}{{{d{jc}}}{{Af{{AAn{ADbe}}g}}}{ADdADf}Db{}}{{c{d{je}}}{{Af{{AAn{{ACl{}{{ACf{g}}{ACh{c}}{ACj{i}}}}k}}i}}}{}{ADdADf}{{ACn{{h{f}}}}AD`}ABjDb}{{ce}{{Af{{AAn{{ACl{}{{ACf{e}}{ACh{c}}{ACj{g}}}}i}}g}}}{}{{ACn{{h{f}}}}AD`}ABjDb}{c{{Af{{AAn{ADbe}}g}}}{}Db{}}{{{d{{ABn{c}}}}}AjDb}{{{d{Df}}}Aj}{{{d{{AAl{ce}}}}{d{jg}}}Ab{KhCh}{KhDb}B`}{{{d{Df}}{d{jc}}}AbB`}{{{d{ABb}}{d{jc}}}AbB`}{{{d{ABf}}{d{jc}}}AbB`}{ce{}{}}00000000000{DfADh}{On{{Af{{ABh{c}}Nj}}}Db}{{A@j{Bd{ADj}}ACd}{{Af{{ABh{c}}Nj}}}Db}{{{AAn{ec}}}{{Af{{ABh{c}}Nj}}}Db{{On{c}}}}{{{AAn{ec}}{Bd{ADj}}ACd}{{Af{{ABh{c}}Nj}}}Db{{A@j{c}}}}{{{ABh{c}}}{{Af{{ABh{c}}Nj}}}Db}{Df{{Af{{ABh{c}}Nj}}}Db}{Ln{{Af{{ABh{c}}Nj}}}Db}{A@j{{Af{{ABn{c}}Nj}}}Db}{{{ABn{c}}}{{Af{{ABn{c}}Nj}}}Db}{{{AAn{ec}}}{{Af{{ABn{c}}Nj}}}Db{{A@j{c}}}}{{{AAn{ce}}}c{}Db}{Df{{Dn{Df}}}}{Ln{{Dn{Ln}}}}{{{ABn{c}}Cb}{{Bd{AC`}}}Db}{{{ABn{c}}Cb{d{{Gd{e}}}}}ABlDbMb}{{{d{Df}}}Aj}{{}Aj}{{{d{Cl}}}Aj}2{{{d{Ln}}}Aj}212133{{{d{{AAl{ce}}}}}KdChDb}``{{{d{{AAl{ce}}}}}{{Af{{Ld{c}}Cf}}}ChDb}{{}AAj}{{{d{Df}}}ADl}{{{d{{Cn{c{Db{}{{Ef{e}}}}}}}}}{{Bd{Kd}}}Ch{{Fj{}{{Ej{El}}{En{F`}}{Fb{Fd}}{Ff{Fh}}}}ChChChCh}}44{{{d{AAj}}{d{AAj}}}AAj}5{{}{{d{Bn}}}}{{Kd{Dn{c}}}{{Af{{AAl{ce}}Cf}}}ChDb}{{{d{Df}}}Kd}``{{{d{{Cn{c{Db{}{{Ef{e}}}}}}}}}{{Af{AbCf}}}Ch{{Fj{}{{Ej{El}}{En{F`}}{Fb{Fd}}{Ff{Fh}}}}ChChChCh}}{{{ABh{c}}AAj}{{ABh{c}}}Db}{{{d{{AAl{ce}}}}{d{{AAl{ce}}}}}{{Bd{Ad}}}{MdCh}{MdDb}}{{{d{Df}}{d{Df}}}{{Bd{Ad}}}}{{{d{ABb}}{d{ABb}}}{{Bd{Ad}}}}{{{d{ABf}}{d{ABf}}}{{Bd{Ad}}}}{{{d{c}}}KdCh}{{{d{{AAl{ce}}}}}{{d{{h{c}}}}}ChDb}{{{d{{AAl{ce}}}}}{{Af{AbCf}}}ChDb}{{{d{{AAl{ce}}}}g}{{Af{{Dn{{Dn{f}}}}Cf}}}{CjCh}Db{{Kf{c}}}}{{{d{{AAl{ce}}}}}KdChDb}{{{d{Df}}c}AfBh}{{}Mj}{{{d{{AAl{ce}}}}}{{D`{ce}}}{CjCh}Db}{{}AAj}{{{d{c}}}e{}{}}00000000{{{d{Ln}}{d{{Gd{c}}}}}{{Af{DfADn}}}Mb}{{{d{c}}}Ml{}}000{{{d{{Cn{c{Db{}{{Ef{e}}}}}}}}}{{Af{AbCf}}}Ch{{Fj{}{{Ej{El}}{En{F`}}{Fb{Fd}}{Ff{Fh}}}}ChChChCh}}0{{{d{{AAl{ce}}}}{d{jk}}}{{Af{{AAl{ge}}{Mn{i}}}}}ChDbCh{}{{N`{cgi}}}}{c{{Af{e}}}{}{}}00000000000000000000000{{{d{c}}}Bl{}}00000000000{ce{}{}}00000000000`{{{d{AE`}}}{{Bd{AEb}}}}{{{d{AE`}}}{{Bd{AEd}}}}{{{d{AE`}}Kd}{{Bd{Bj}}}}`````````````````````{{AEfAEf}AEf}{{{d{jAEh}}bAEj{AEn{AEl}}}Ab}`{{{d{AEh}}}{{M`{b{`{{AFd{}{{AF`{{AFb{Hb}}}}}}G`}}}}}}{{{d{jAEh}}{d{AFf}}Dh}{{Af{AbAFh}}}}{{{d{jAEh}}{d{AFf}}DhAFj}{{Af{AbAFl}}}}{{{d{jAEh}}c}Ab{{AG`{}{{AF`{{Ij{{d{AFn}}H`}}}}}}}}{{{d{jAEh}}c}{{Af{AbAFh}}}{{AGd{AGb}}}}{{{d{AEh}}}{{d{{AGh{AGf}}}}}}{{{d{AEh}}}AEf}{{{d{c}}}{{d{e}}}{}{}}0000000{{{d{jc}}}{{d{je}}}{}{}}0000000{{{d{jAEh}}AGj}{{Af{{AGn{AGl}}AH`}}}}{{{d{jAEh}}}{{AGn{AGl}}}}{{{d{AEh}}{d{AFn}}}{{Af{AEbAHb}}}}{{{d{AEh}}{d{AFn}}}{{Af{AEdAHb}}}}{{{d{jAEh}}{d{AFn}}}Ab}``{{{d{AEh}}}AHd}{{{d{AEf}}}AEf}{{{d{AGb}}}AGb}{{{d{c}}{d{je}}}Ab{}{}}0``{{}AEf}{{}AGb}{{{d{AHf}}}{{d{c}}}{}}{{{d{AEh}}b}{{Bd{Dh}}}}{{{d{AEh}}{d{If}}}{{Bd{{Ij{bDh}}}}}}{{{d{AEh}}b}Ml}{c{{Af{AEf}}}Ah}{{{d{AEf}}{d{AEf}}}Aj}{{{d{AHf}}{d{AHf}}}Aj}``{{{d{AEh}}{d{jAHh}}AHj}{{Af{AjAHl}}}}{{{d{AEf}}{d{jAl}}}{{Af{AbIl}}}}0{{{d{AEh}}{d{jAl}}}An}{{{d{AGb}}{d{jAl}}}An}{{{d{AHf}}{d{jAl}}}An}0{{{d{AHn}}{d{jAl}}}An}0{{{d{AI`}}{d{jAl}}}An}0{{{d{AIb}}{d{jAl}}}An}0{{{d{AId}}{d{jAl}}}An}0{cc{}}0{{{AIf{b}}}AGb}{AIhAGb}222222{{{d{AEh}}b}{{d{Kl}}}}{{{d{AEh}}l{Bd{AIj}}Aj}{{Af{AIlAIn}}}}{{{d{AEh}}b}{{AEn{Hl}}}}{{{d{AEh}}AGj}{{Bd{{AJ`{{AEn{AFn}}AGf}}}}}}{{{d{AEh}}Bb}{{Bd{l}}}}````{{{d{jAEh}}AFj}{{Af{AjAJb}}}}{{{d{jAEh}}AFn}Aj}{{{d{jAEh}}BbBj}Ab}{ce{}{}}0000000{{{d{AJd}}{d{If}}}Aj}{{{d{AEh}}{d{If}}}Aj}`{{{d{AEh}}}{{`{{AFd{}{{AF`{{Ij{{d{b}}{d{Kl}}}}}}}}}}}}`{{{d{AEh}}}AJf}{{{d{AEh}}}{{`{{AFd{}{{AF`{l}}}}}}}}0{{{d{AEh}}b}{{`{{AJh{}{{AF`{AHf}}}}}}}}{AJj{{Af{AEhAI`}}}}{{{d{AEh}}}{{d{AJl}}}}{{{d{jAEh}}bDh}Aj}{{{d{AEh}}}Cb}`{{ccCb}{{Af{AEhAHn}}}Kj}{{cc{Bd{AJj}}Cb}{{Af{AEhAIb}}}Kj}{{cc{Bd{AJj}}CbAJn}{{Af{AEhAIb}}}Kj}{{ccCbAJn}{{Af{AEhAHn}}}Kj}{{{d{AEh}}b}Dh}{{{d{jAEh}}b}AHf}{{{d{AEh}}bDh}AHf}{{{d{AEh}}b}{{Af{{Bd{Ib}}Id}}}}{{{d{AEh}}b}{{d{Kl}}}}{{{d{jAEh}}bDh}{{`{{AFd{}{{AF`{AHf}}}}}}}}4{{{d{AEh}}}{{d{{Gd{I`}}}}}}{{{d{AEh}}{d{AFn}}}{{Ij{AEbAEb}}}}{{{d{AEf}}c}AfBh}{{{d{AEh}}{d{jAHh}}AHj}{{Af{AjAHl}}}}`{{{d{AEh}}}{{d{{AK`{b}}}}}}{{{d{AEh}}}{{Bd{{d{AJj}}}}}}{{{d{AEh}}}{{AKb{b}}}}{{{d{AEh}}}AKd}{{{d{jAEh}}}{{Bd{AJj}}}}{{{d{c}}}e{}{}}0{{{d{c}}}Ml{}}00000{{{d{AEf}}}AEb}{{{d{AEh}}}{{`{{AFd{}{{AF`{{AJ`{{AEn{AFn}}AGf}}}}}}}}}}`1{c{{Af{e}}}{}{}}000000000000000`{{{d{AEh}}}{{d{{AGh{AGf}}}}}}{{{d{c}}}Bl{}}0000000{{{d{AEh}}b}{{`{{AFd{}{{AF`{{AFb{Hb}}}}}}G`}}}}{{{d{AEh}}}{{`{{AFd{}{{AF`{{AKf{{AEn{AFn}}AGf}}}}}}}}}}{{{d{jAEh}}bDh}Aj}`{ce{}{}}0000000{{c{Bd{c}}Cb{d{{Gd{I`}}}}}{{Af{MlId}}}Kj}`````````````````````{{{d{c}}}{{d{e}}}{}{}}00000{{{d{jc}}}{{d{je}}}{}{}}00000{{{d{AKh}}}AKh}{{{d{AKj}}}AKj}{{{d{AKl}}}AKl}{{{d{c}}{d{je}}}Ab{}{}}00{{{d{AKn}}{Dn{n}}{Dn{n}}AEdH`{d{If}}}{{Af{AL`ALb}}}}{{{d{AKh}}{Dn{n}}{Dn{n}}AEdH`{d{If}}}{{Af{AL`ALb}}}}{{{d{AKj}}{Dn{n}}{Dn{n}}AEdH`{d{If}}}{{Af{AL`ALb}}}}{{{d{AKl}}{Dn{n}}{Dn{n}}AEdH`{d{If}}}{{Af{AL`ALb}}}}{{H`AEd{d{If}}}ALd}{{}AKh}{{}AKj}{{}AKl}``{{{d{ALb}}{d{jAl}}}An}0{{{d{ALd}}{d{jAl}}}An}{{{d{AL`}}{d{jAl}}}An}{{{d{AKh}}{d{jAl}}}An}{{{d{AKj}}{d{jAl}}}An}{{{d{AKl}}{d{jAl}}}An}{cc{}}00000{ce{}{}}00000{{{d{AL`}}}H`}{H`AKl}`1{{{d{c}}}e{}{}}00{{{d{c}}}Ml{}}{c{{Af{e}}}{}{}}00000000000{{{d{c}}}Bl{}}00000666666`````````````````````````````````````{{{d{c}}}{{d{e}}}{}{}}00{{{d{jc}}}{{d{je}}}{}{}}00{{{d{ALf}}}ALf}{{{d{c}}{d{je}}}Ab{}{}}{{{d{ALf}}{d{jAl}}}An}0{{{d{AIn}}{d{jAl}}}An}0{{{d{AH`}}{d{jAl}}}An}0>{ALbAIn}{IdAIn}{NnAIn}{ALfAIn}{cc{}}{ALhAIn}1{ce{}{}}00{{{d{c}}}e{}{}}{{{d{c}}}Ml{}}00{c{{Af{e}}}{}{}}00000{{{d{c}}}Bl{}}00444``````````{{{d{c}}}{{d{e}}}{}{}}{{{d{jc}}}{{d{je}}}{}{}}{{{d{ALj}}}{{Bd{Ml}}}}{{{d{ALj}}}Ml}{c{{Af{ALj}}}Ah}{{{d{AEh}}{d{Bn}}Aj}{{Af{ALj{d{Bn}}}}}}{{{d{ALj}}{d{jAl}}}An}0={{{d{Bn}}}{{Af{ALjc}}}{}}<``{{{d{ALj}}c}AfBh};::9=````````````````````````````````````{{{d{jHl}}ALlAEj{AEn{AEl}}}{{Bd{{AEn{AEl}}}}}}``{{{d{Hl}}{d{{Gd{I`}}}}}Kn}`::::::::99999999{{Kn{d{{C`{Df}}}}{d{{Gd{I`}}}}}Hl}{{{d{ALl}}}ALl}{{{d{ALn}}}ALn}{{{d{{AM`{c}}}}}{{AM`{c}}}{G`AMbABjG`}}{{{d{AEj}}}AEj}{{{d{Hl}}}Hl}{{{d{AHj}}}AHj}{{{d{AMd}}}AMd}{{{d{c}}{d{je}}}Ab{}{}}000000{{{d{ALl}}{d{ALl}}}Ad}{{{d{AEj}}{d{AEj}}}Ad}{{}AEj}{{}Hl}{{}AHj}{{}AMd}{{{d{{AM`{c}}}}}{{d{e}}}{AMbABjG`}{}}{{{d{AMf}}}{{Bd{Ln}}}}{{{d{{AM`{{AMh{AC`}}}}}}}{{Bd{Ln}}}}{{{d{{AM`{AMj}}}}}{{Bd{Ln}}}}{{{d{{AM`{{AMl{AC`}}}}}}}{{Bd{Ln}}}}{{{d{ALl}}{d{ALl}}}Aj}{{{d{ALn}}{d{ALn}}}Aj}{{{d{AEj}}{d{AEj}}}Aj}{{{d{AMd}}{d{AMd}}}Aj}{{{d{Hl}}ALl}{{Bd{{d{{AEn{AEl}}}}}}}}{{{d{ALl}}{d{jAl}}}An}{{{d{AHl}}{d{jAl}}}An}0{{{d{ALn}}{d{jAl}}}An}{{{d{{AM`{c}}}}{d{jAl}}}An{ABjAMbABjG`}}{{{d{AEj}}{d{jAl}}}An}{{{d{Hl}}{d{jAl}}}An}{{{d{AHj}}{d{jAl}}}An}{{{d{AMd}}{d{jAl}}}An}{FhALl}{ADlALl}{cc{}}0000000{{{d{ALl}}{d{jc}}}AbB`}{{{d{AMf}}{d{{Gd{I`}}}}}ALl}{{{d{{AM`{{AMh{AC`}}}}}}{d{{Gd{I`}}}}}ALl}{{{d{{AM`{{AMl{AC`}}}}}}{d{{Gd{I`}}}}}ALl}{{{d{{AM`{AMj}}}}{d{{Gd{I`}}}}}ALl}{{{d{Hl}}}{{Dn{{d{ALl}}}}}}{ce{}{}}0000000{{cALn}{{AM`{c}}}{AMbABjG`}}{{}Hl}{{{d{ALl}}{d{ALl}}}{{Bd{Ad}}}}{{{d{AEj}}{d{AEj}}}{{Bd{Ad}}}}{{{d{jHl}}ALlAEj}{{Bd{{AEn{AEl}}}}}}{{{d{AMn}}{d{jAHh}}Kd{d{AHj}}{d{{Gd{I`}}}}}{{Af{AbAHl}}}}{{{d{{AM`{AMj}}}}{d{jAHh}}Kd{d{AHj}}{d{{Gd{I`}}}}}{{Af{AbAHl}}}}{{{d{{AM`{{AMl{AC`}}}}}}{d{jAHh}}Kd{d{AHj}}{d{{Gd{I`}}}}}{{Af{AbAHl}}}}{{{d{{AM`{{AMh{AC`}}}}}}{d{jAHh}}Kd{d{AHj}}{d{{Gd{I`}}}}}{{Af{AbAHl}}}}{{{d{AEl}}{d{jAHh}}{d{AHj}}{d{{Gd{I`}}}}}{{Af{AbAHl}}}}{{{d{c}}{d{jAHh}}{d{AHj}}{d{{Gd{I`}}}}}{{Af{AbAHl}}}{}}`{{{d{Hl}}}{{Dn{{d{{AEn{AEl}}}}}}}}`{{{d{c}}}e{}{}}000000{{{d{c}}}Ml{}}``{c{{Af{e}}}{}{}}000000000000000{{{d{c}}}Bl{}}0000000{ce{}{}}0000000````````````````{{{d{j{AGn{c}}}}{d{e}}}{{d{j{AGn{c}}}}}{}{{ANb{AN`}}}}{{{d{j{AGn{c}}}}BbAIlLh}{{Af{{d{j{AGn{c}}}}ANd}}}{}}{{{d{j{AGn{c}}}}BbAIlLhBf}{{Af{{d{j{AGn{c}}}}ANd}}}{}}{{{d{j{AGn{c}}}}}{{d{j{AGn{c}}}}}{}}{{{d{j{AGn{c}}}}HbAEb}{{d{j{AGn{c}}}}}{}}{{{d{j{AGn{c}}}}Bb}{{d{j{AGn{c}}}}}{}}{{{d{j{AGn{c}}}}Bb}{{Af{{d{j{AGn{c}}}}ANf}}}{}}{{{d{j{AGn{c}}}}{d{{h{Bb}}}}}{{Af{{d{j{AGn{c}}}}ANf}}}{}}{{{d{j{AGn{c}}}}Aj}{{d{j{AGn{c}}}}}{}}{{{d{c}}}{{d{e}}}{}{}}0000{{{d{jc}}}{{d{je}}}{}{}}0000{{{d{j{AGn{c}}}}ANh}{{d{j{AGn{c}}}}}{}}{{{d{{AGn{c}}}}}{{AGn{c}}}G`}{{{d{ANj}}}ANj}{{{d{ANh}}}ANh}{{{d{c}}{d{je}}}Ab{}{}}00{{{d{ANj}}{d{ANj}}}Ad}{{{d{ANh}}{d{ANh}}}Ad}{{{AGn{c}}e}{{AGn{e}}}{}AKn}{{{d{j{AGn{c}}}}Dh}{{d{j{AGn{c}}}}}{}}{{}ANj}{{}ANh}{{{d{j{AGn{c}}}}}{{d{j{AGn{c}}}}}{}}{{{d{j{AGn{c}}}}Hb}{{d{j{AGn{c}}}}}{}}11{{{d{j{AGn{c}}}}Bf}{{d{j{AGn{c}}}}}{}}{{{d{ANj}}{d{ANj}}}Aj}{{{d{ANh}}{d{ANh}}}Aj}{{{d{j{AGn{c}}}}AEb}{{d{j{AGn{c}}}}}{}}{{{d{j{AGn{c}}}}AEd}{{d{j{AGn{c}}}}}{}}{{{AGn{c}}}{{Af{AHhAIn}}}AKn}{{{AGn{c}}{d{je}}}{{Af{AHhAIn}}}AKnADf}{{{d{{AGn{c}}}}{d{jAl}}}AnABj}{{{d{ANf}}{d{jAl}}}An}0{{{d{ANd}}{d{jAl}}}An}0{{{d{ANj}}{d{jAl}}}An}{{{d{ANh}}{d{jAl}}}An}{cc{}}0000{{{d{ANj}}{d{jc}}}AbB`}{{{d{ANh}}{d{jc}}}AbB`}{{{d{j{AGn{c}}}}}{{d{j{AGn{c}}}}}{}}{ce{}{}}00001{{{d{j{AGn{c}}}}ANl}{{d{j{AGn{c}}}}}{}}22{{{d{j{AGn{c}}}}ANj}{{d{j{AGn{c}}}}}{}}{{{d{ANj}}{d{ANj}}}{{Bd{Ad}}}}{{{d{ANh}}{d{ANh}}}{{Bd{Ad}}}}{{{d{j{AGn{c}}}}{M`{Ml{Dn{Kd}}}}b}{{d{j{AGn{c}}}}}{}}{{{d{j{AGn{c}}}}{Dn{{Ij{HbAEb}}}}}{{d{j{AGn{c}}}}}{}}{{{d{j{AGn{c}}}}AIj}{{d{j{AGn{c}}}}}{}}{{ANj{d{jAFn}}}Ab}{{ANj{d{jAFn}}{d{jc}}}AbADf}{{{d{c}}}e{}{}}00{{{d{c}}}Ml{}}0{c{{Af{e}}}{}{}}000000000{{{d{c}}}Bl{}}0000{{{d{j{AGn{c}}}}{Dn{Bb}}}{{d{j{AGn{c}}}}}{}}{{{d{j{AGn{c}}}}ANn}{{d{j{AGn{c}}}}}{}}?????``","D":"FG`","p":[[6,"KeychainKind",0,1705],[1,"reference"],[1,"u8"],[1,"slice"],[0,"mut"],[5,"LocalOutput",0,1705],[5,"WeightedUtxo",0,1705],[6,"Utxo",0,1705],[1,"unit"],[6,"Ordering",1706],[6,"Result",1707],[10,"Deserializer",1708],[1,"bool"],[5,"Formatter",1709],[8,"Result",1709],[10,"Hasher",1710],[5,"OutPoint",1711],[6,"Option",1712],[5,"Sequence",1711],[10,"Serializer",1713],[5,"TxOut",1711],[5,"TypeId",1714],[1,"str"],[6,"Descriptor",100,1715],[6,"Network",1716],[5,"Address",1717],[6,"Error",1718],[10,"MiniscriptKey",1718],[10,"ToPublicKey",1718],[6,"ScriptContextEnum",693],[5,"Miniscript",100,1719],[6,"Terminal",1720],[10,"ScriptContext",693,1721],[6,"Tree",1722],[6,"DescriptorPublicKey",693,1723],[1,"u32"],[5,"DefiniteDescriptorKey",1723],[6,"ConversionError",1723],[5,"Vec",1724],[6,"Placeholder",1725],[5,"Satisfaction",1725],[10,"AssetProvider",1726],[17,"Key"],[6,"ScriptContextError",1721],[17,"Sha256"],[5,"Hash",1727],[17,"Hash256"],[5,"Hash",1728],[17,"Ripemd160"],[5,"Hash",1729],[17,"Hash160"],[5,"Hash",1730],[10,"ParseableKey",1720],[6,"Legacy",100,1721],[6,"Segwitv0",100,1721],[10,"Clone",1731],[10,"Ord",1706],[5,"Secp256k1",1732],[5,"PublicKey",1733],[10,"Verification",1734],[6,"DescriptorType",1715],[5,"DescriptorId",1735],[10,"FromStrKey",1736],[1,"u64"],[5,"ScriptBuf",1737],[10,"PartialEq",1706],[5,"ExtParams",1738],[6,"AnalysisError",1738],[10,"ExtractPolicy",100],[5,"SignersContainer",1408],[6,"BuildSatisfaction",386],[6,"All",1739],[5,"Policy",386],[6,"Error",354],[5,"Script",1740],[5,"Range",1741],[1,"tuple"],[5,"Error",1709],[17,"Output"],[10,"FnMut",1742],[5,"Wpkh",1743],[5,"Sh",1744],[5,"Bare",1745],[5,"Pkh",1745],[5,"Wsh",1743],[5,"Tr",1746],[5,"Type",1747],[5,"ExtData",1748],[5,"Tree",1749],[1,"usize"],[10,"Satisfier",1725],[10,"Hash",1710],[10,"IntoWalletDescriptor",100],[8,"ExtendedDescriptor",100],[8,"KeyMap",693,1715],[5,"Iter",1750],[5,"PkIter",1750],[6,"Policy",1751],[6,"LiftError",1752],[5,"Weight",1753],[6,"BareCtx",1721],[6,"TapTree",1746],[6,"DescriptorSecretKey",693,1723],[5,"BTreeMap",1754],[10,"Signing",1734],[10,"PartialOrd",1706],[5,"Plan",1726],[5,"TxIn",1711],[6,"SigType",1721],[5,"String",1755],[6,"TranslateErr",1718],[10,"Translator",1718],[1,"array"],[6,"ParsePublicKeyError",1733],[6,"Error",1756],[6,"Error",1757],[6,"KeyError",693],[6,"HexToBytesError",1758],[6,"PolicyError",386],[6,"PkOrF",386],[6,"SatisfiableItem",386],[6,"Satisfaction",386],[5,"Condition",386],[10,"DescriptorTemplate",557],[8,"DescriptorTemplateOut",557],[5,"P2Pkh",557],[10,"IntoDescriptorKey",693],[5,"P2Wpkh_P2Sh",557],[5,"P2Wpkh",557],[5,"P2TR",557],[6,"Tap",1721],[5,"Bip44",557],[10,"DerivableKey",693],[5,"Bip44Public",557],[5,"Bip49",557],[5,"Bip49Public",557],[5,"Bip84",557],[5,"Bip84Public",557],[5,"Bip86",557],[5,"Bip86Public",557],[8,"ValidNetworks",693],[5,"SortedMultiVec",693,1759],[5,"GeneratedKey",693],[5,"PrivateKeyGenerateOptions",693],[5,"SinglePub",693,1723],[5,"SinglePriv",693,1723],[6,"SinglePubKey",693,1723],[6,"DescriptorKey",693],[10,"Debug",1709],[5,"Xpub",1756],[6,"ExtendedKey",693],[5,"Xpriv",1756],[10,"FromStr",1760],[5,"DerivationPath",1756],[17,"Entropy"],[17,"Options"],[17,"Error"],[10,"GeneratableKey",693],[10,"AsMut",1761],[10,"Default",1762],[10,"GeneratableDefaultOptions",693],[10,"CryptoRng",1763],[10,"RngCore",1763],[5,"Assets",1726],[8,"KeySource",1756],[5,"Fingerprint",1756],[5,"DescriptorKeyParseError",1723],[10,"PsbtUtils",994],[5,"Amount",1764],[5,"FeeRate",1765],[5,"Balance",998,1766],[5,"Wallet",998],[5,"SignerOrdering",1408],[10,"TransactionSigner",1408],[5,"Arc",1767],[17,"Item"],[8,"Indexed",1766],[10,"Iterator",1768],[5,"Block",1769],[5,"CannotConnectError",1770],[5,"BlockId",1771],[6,"ApplyHeaderError",1770],[5,"Transaction",1711],[10,"IntoIterator",1772],[5,"Update",998],[10,"Into",1761],[5,"ConfirmationTimeHeightAnchor",1771],[5,"TxGraph",1773],[5,"Txid",1711],[8,"DefaultCoinSelectionAlgorithm",1209],[5,"TxBuilder",1586],[6,"BuildFeeBumpError",1308],[6,"CalculateFeeError",1773],[5,"CheckPointIter",1770],[5,"AddressInfo",998],[5,"Psbt",1774],[5,"SignOptions",1408],[6,"SignerError",1408],[6,"NewError",998],[6,"LoadError",998],[6,"NewOrLoadError",998],[6,"ApplyBlockError",998],[5,"FullScanResult",1775],[5,"SyncResult",1775],[5,"PsbtSighashType",1776],[5,"Input",1776],[6,"CreateTxError",1308],[5,"CanonicalTx",1773],[5,"AlterCheckPointError",1770],[10,"IsDust",998,1777],[5,"CheckPoint",1770],[10,"DoubleEndedIterator",1778],[8,"ChangeSet",998],[5,"LocalChain",1770],[5,"BlockHash",1769],[5,"KeychainTxOutIndex",1779],[5,"FullScanRequest",1775],[5,"SyncRequest",1775],[5,"TxNode",1773],[5,"LargestFirstCoinSelection",1209],[5,"OldestFirstCoinSelection",1209],[5,"BranchAndBoundCoinSelection",1209],[10,"CoinSelectionAlgorithm",1209],[5,"CoinSelectionResult",1209],[6,"Error",1209],[6,"Excess",1209],[6,"MiniscriptPsbtError",1308],[6,"Error",1780],[5,"FullyNodedExport",1385],[6,"SignerId",1408],[6,"SignerContext",1408],[5,"SignerWrapper",1408],[10,"Sized",1781],[6,"TapLeavesOptions",1408],[10,"SignerCommon",1408],[5,"DescriptorMultiXKey",1723],[5,"PrivateKey",1733],[5,"DescriptorXKey",1723],[10,"InputSigner",1408],[5,"PushBytes",1782],[10,"AsRef",1761],[6,"AddForeignUtxoError",1586],[6,"AddUtxoError",1586],[6,"ChangeSpendPolicy",1586],[6,"TxOrdering",1586],[6,"LockTime",1783],[1,"i32"],[15,"Foreign",97],[8,"DerivedDescriptor",100],[15,"PsbtTimelocks",533],[15,"Complete",536],[15,"Partial",536],[15,"PartialComplete",536],[15,"Sha256Preimage",547],[15,"Hash256Preimage",547],[15,"Ripemd160Preimage",547],[15,"Hash160Preimage",547],[15,"Thresh",547],[15,"Multisig",547],[15,"AbsoluteTimelock",547],[15,"RelativeTimelock",547],[10,"ExtScriptContext",693],[15,"UnexpectedConnectedToHash",1201],[15,"LoadedGenesisDoesNotMatch",1203],[15,"LoadedNetworkDoesNotMatch",1203],[15,"LoadedDescriptorDoesNotMatch",1203],[15,"InsufficientFunds",1301],[15,"Change",1303],[15,"NoChange",1303],[15,"RbfSequenceCsv",1379],[15,"LockTime",1379],[15,"FeeTooLow",1379],[15,"FeeRateTooLow",1379],[8,"WalletExport",1385],[15,"Tap",1585],[15,"InvalidTxid",1703]],"r":[[2,100],[4,1705],[6,1705],[7,1408],[8,1586],[9,1705],[10,998],[11,1705],[70,998],[71,100],[104,1715],[106,1723],[113,1721],[114,1719],[119,386],[120,1721],[121,1721],[155,352],[696,1723],[697,1723],[712,1715],[722,1721],[727,1723],[728,1723],[729,1723],[730,1759],[1000,1766],[1006,1777]],"b":[[193,"impl-Descriptor%3CDefiniteDescriptorKey%3E"],[194,"impl-Descriptor%3CDescriptorPublicKey%3E"],[213,"impl-Display-for-Descriptor%3CPk%3E"],[214,"impl-Debug-for-Descriptor%3CPk%3E"],[217,"impl-Display-for-Miniscript%3CPk,+Ctx%3E"],[218,"impl-Debug-for-Miniscript%3CPk,+Ctx%3E"],[221,"impl-From%3CWpkh%3CPk%3E%3E-for-Descriptor%3CPk%3E"],[222,"impl-From%3CSh%3CPk%3E%3E-for-Descriptor%3CPk%3E"],[223,"impl-From%3CBare%3CPk%3E%3E-for-Descriptor%3CPk%3E"],[224,"impl-From%3CPkh%3CPk%3E%3E-for-Descriptor%3CPk%3E"],[225,"impl-From%3CWsh%3CPk%3E%3E-for-Descriptor%3CPk%3E"],[227,"impl-From%3CTr%3CPk%3E%3E-for-Descriptor%3CPk%3E"],[370,"impl-Debug-for-Error"],[371,"impl-Display-for-Error"],[373,"impl-From%3CError%3E-for-Error"],[374,"impl-From%3CParsePublicKeyError%3E-for-Error"],[375,"impl-From%3CError%3E-for-Error"],[376,"impl-From%3CError%3E-for-Error"],[377,"impl-From%3CKeyError%3E-for-Error"],[378,"impl-From%3CHexToBytesError%3E-for-Error"],[379,"impl-From%3CPolicyError%3E-for-Error"],[461,"impl-Debug-for-PolicyError"],[462,"impl-Display-for-PolicyError"],[811,"impl-Display-for-KeyError"],[812,"impl-Debug-for-KeyError"],[813,"impl-Debug-for-SortedMultiVec%3CPk,+Ctx%3E"],[814,"impl-Display-for-SortedMultiVec%3CPk,+Ctx%3E"],[815,"impl-Debug-for-DescriptorPublicKey"],[816,"impl-Display-for-DescriptorPublicKey"],[817,"impl-Debug-for-DescriptorSecretKey"],[818,"impl-Display-for-DescriptorSecretKey"],[824,"impl-From%3CXpub%3E-for-ExtendedKey%3CCtx%3E"],[825,"impl-From%3CXpriv%3E-for-ExtendedKey%3CCtx%3E"],[830,"impl-From%3CError%3E-for-KeyError"],[831,"impl-From%3CError%3E-for-KeyError"],[874,"impl-IntoDescriptorKey%3CCtx%3E-for-GeneratedKey%3CK,+Ctx%3E"],[875,"impl-DerivableKey%3CCtx%3E-for-GeneratedKey%3CK,+Ctx%3E"],[1071,"impl-Display-for-Balance"],[1072,"impl-Debug-for-Balance"],[1075,"impl-Display-for-AddressInfo"],[1076,"impl-Debug-for-AddressInfo"],[1077,"impl-Display-for-NewError"],[1078,"impl-Debug-for-NewError"],[1079,"impl-Debug-for-LoadError"],[1080,"impl-Display-for-LoadError"],[1081,"impl-Display-for-NewOrLoadError"],[1082,"impl-Debug-for-NewOrLoadError"],[1083,"impl-Debug-for-ApplyBlockError"],[1084,"impl-Display-for-ApplyBlockError"],[1087,"impl-From%3CFullScanResult%3CKeychainKind%3E%3E-for-Update"],[1088,"impl-From%3CSyncResult%3E-for-Update"],[1250,"impl-Display-for-Error"],[1251,"impl-Debug-for-Error"],[1346,"impl-Debug-for-MiniscriptPsbtError"],[1347,"impl-Display-for-MiniscriptPsbtError"],[1348,"impl-Debug-for-CreateTxError"],[1349,"impl-Display-for-CreateTxError"],[1350,"impl-Display-for-BuildFeeBumpError"],[1351,"impl-Debug-for-BuildFeeBumpError"],[1353,"impl-From%3CError%3E-for-CreateTxError"],[1354,"impl-From%3CError%3E-for-CreateTxError"],[1355,"impl-From%3CPolicyError%3E-for-CreateTxError"],[1356,"impl-From%3CMiniscriptPsbtError%3E-for-CreateTxError"],[1358,"impl-From%3CError%3E-for-CreateTxError"],[1395,"impl-Display-for-FullyNodedExport"],[1396,"impl-Debug-for-FullyNodedExport"],[1488,"impl-SignerCommon-for-SignerWrapper%3CDescriptorMultiXKey%3CXpriv%3E%3E"],[1489,"impl-SignerCommon-for-SignerWrapper%3CPrivateKey%3E"],[1490,"impl-SignerCommon-for-SignerWrapper%3CDescriptorXKey%3CXpriv%3E%3E"],[1497,"impl-Display-for-SignerError"],[1498,"impl-Debug-for-SignerError"],[1505,"impl-From%3CHash%3E-for-SignerId"],[1506,"impl-From%3CFingerprint%3E-for-SignerId"],[1517,"impl-SignerCommon-for-SignerWrapper%3CDescriptorMultiXKey%3CXpriv%3E%3E"],[1518,"impl-SignerCommon-for-SignerWrapper%3CDescriptorXKey%3CXpriv%3E%3E"],[1519,"impl-SignerCommon-for-SignerWrapper%3CPrivateKey%3E"],[1535,"impl-InputSigner-for-SignerWrapper%3CPrivateKey%3E"],[1536,"impl-InputSigner-for-SignerWrapper%3CDescriptorXKey%3CXpriv%3E%3E"],[1537,"impl-InputSigner-for-SignerWrapper%3CDescriptorMultiXKey%3CXpriv%3E%3E"],[1645,"impl-Debug-for-AddUtxoError"],[1646,"impl-Display-for-AddUtxoError"],[1647,"impl-Display-for-AddForeignUtxoError"],[1648,"impl-Debug-for-AddForeignUtxoError"]],"c":"OjAAAAEAAAAAAAUAEAAAAMEAAwEPAR8DeANrBQ==","e":"OzAAAAEAAHEDfgADAAAACAABAAsAAAAOABMAJgAJADUAAQA+AAAAQQAAAEUADwBXAAMAXQADAGoAAAB4AAAAjAABAI8AAACRAAcAnAAAAJ4AAQChAAAApAABAKcAAQCrAAEArgABALEAAQC0AAsAxQADAMoAAwDTAAEA1gAMAOQAAADqAAAA9wADAAIBAAAIAQEADAEBABMBAQApAQMALgEBADwBAQA/AQEAQwEFAE4BBwBXAQMAXAEDAHEBAwB2AQYAfgEEAKYBGQDCAQ4A0wEAANUBAADbAQEA6gEAAO0BBADzASIAPAIXAFUCCwB5AjwA5AIXAAYDFQAdAwEAIAMAACIDFQA5AwEAPwMBAEMDAABLAwEAWAMDAGgDAABrAwQAcQMBAIEDAQCGAwAAkAMAAJUDAwCeAwAAogMIAKwDAwCzAy8A/AMAAAQEAAAGBA8AHgQDACQEAgAqBAIAMAQNAEAEAQB3BAAAfwQHAIsEDwCdBAcAqQQHAMcEEQDaBAIA3gQCAOMEBgD6BBsAOwUNAEoFAwBPBQAAVAUPAG4FAQByBQAAdAUBAHcFAAB7BQUAqgUPALsFFADRBQYA2QUKAOwFAADuBQIA/AUBAAAGAgAEBgAACAYHABIGHwBLBgkAVgYHAGAGAQBnBgEAbQYGAHkGAQCGBgEAjQYTAKMGBAA="}],\
+["bdk_wallet",{"t":"PPEPGPFEEGEFNNDNNNNNNNNENNNNNNNNNOOCQNNNNNNNNNNQNNNNNNNNNNOOCDNONCONNNEENNNNNNNNNNNNNONNNNOHNNNNCOOOPPPIGEGIKTIKRGFPPPPEKGPPPPTIPPPPPPPPPPNNNNNNNNNNNNNNNNNENNNNNNNNNNNNNMNNMNNNNNCNNNNNNNNNNNNNNNNNNNNNNNNNNCNONMNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNMNNNNNNNNNMNNNNNNMNNNNNNNNNNNNNNNNONNNNNNNNNMNNNNCNNNNNNNNNNNMNNNCNNNNNNNNNNNNNNNNNNNONNNNNNNNNNHHPPGPPPPPPPPPPPNNNNNNNNNNNNNNNNNNPPPGPFIPPIPPPPPPPPPPPGFGPPPPPGGPPPPNNNNNNNNNNNNNNNNNNNNNNNNNNOONNNNNNNNNNNNNNNNNNNNNNNNNNNNONNNNNNNNNNONNONNNNNONNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNOOOOOOOOOOOOOOOOOOOOOOOOFFFFFFFFKIFFFFNNNNNNNNNNNNNNNNNNNNNNNNMNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNPKGGGRRKGPKKFKPPPRGIPPPPPRPFPKGPPPFFGFPIPPPHMNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNMMNNNNNNNNNNNNNNNNNNNNNNNONNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNMNNNNNNNNNNNNNNNNNNNNMNNNNNNMNNNNNNNNNNNNNNNNNNNOONHNMNNHNMNNOONNNNNNMNNNNNMNHNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNKMMMFGFPIPPPKGPPPPPPGGPFFNNONNNNNNNNNNNNNNNNNNNNNNNNNNNNOONNNNNCONNNNNNNNNCCNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNOOOONNNNNNNNNNNMNONONNNNNNNNONNNNNNNNNNNNNNNCNNNNNNNNNNNNNNNONNNNNNNNNNNNNNNNNCNNNNNNNNNNNNONNNNNNNNHOOOOOOOOPPFPKFIGGPFPFNNNNNNNNNNNNNNNNNNMNNNHNNNOONNNNNNNNNNNNNNNNNNNNNONNNNNNNNNNNNNNNNNNNNNNNNNNNNNOOOOOOOGPPGPPPPPPPGPPPPPPPPPPPPPPPPPPNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNOOOOOOFIOONNNNNNNNNNNOONNNNNNPPPPPPPKPPPPPPPPPPPPPPPPFKGGGFFFPGKPNOONONNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNMNNNNNNNNNNNNNNNNNMNNNMNONONNNNNNNNOONNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNOGGPPGPPPPPPFGPPNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNOOOO","n":["External","Foreign","HdKeyPaths","Internal","KeychainKind","Local","LocalOutput","SignOptions","TxBuilder","Utxo","Wallet","WeightedUtxo","as_byte","as_ref","bitcoin","borrow","borrow","borrow","borrow","borrow_mut","borrow_mut","borrow_mut","borrow_mut","chain","clone","clone","clone","clone","clone_into","clone_into","clone_into","clone_into","cmp","confirmation_time","derivation_index","descriptor","descriptor","deserialize","deserialize","eq","eq","eq","eq","fmt","fmt","fmt","fmt","fragment","from","from","from","from","hash","hash","into","into","into","into","is_spent","keychain","keys","miniscript","outpoint","outpoint","partial_cmp","psbt","satisfaction_weight","sequence","serialize","serialize","signer","template","to_owned","to_owned","to_owned","to_owned","try_from","try_from","try_from","try_from","try_into","try_into","try_into","try_into","txout","txout","type_id","type_id","type_id","type_id","utxo","version","vzip","vzip","vzip","vzip","wallet","outpoint","psbt_input","sequence","Bare","Bare","Bare","DerivedDescriptor","Descriptor","DescriptorError","DescriptorPublicKey","ExtendedDescriptor","ExtractPolicy","FALSE","HdKeyPaths","IntoWalletDescriptor","Key","Legacy","Miniscript","MultiXPub","Pkh","Pkh","Pkh","Policy","ScriptContext","Segwitv0","Sh","Sh","Sh","Single","TRUE","TapKeyOrigins","Tr","Tr","Tr","Wpkh","Wpkh","Wpkh","Wsh","Wsh","Wsh","XPub","address","as_enum","as_enum","as_inner","as_node","at_derivation_index","borrow","borrow","borrow","borrow","borrow_mut","borrow_mut","borrow_mut","borrow_mut","branches","build_template","build_template_mall","calc_checksum","check_global_consensus_validity","check_global_consensus_validity","check_global_consensus_validity","check_global_policy_validity","check_global_policy_validity","check_global_validity","check_local_consensus_validity","check_local_consensus_validity","check_local_consensus_validity","check_local_policy_validity","check_local_policy_validity","check_local_policy_validity","check_local_validity","check_pk","check_pk","check_pk","check_terminal_non_malleable","check_terminal_non_malleable","check_terminal_non_malleable","check_witness","check_witness","check_witness","checksum","clone","clone","clone","clone","clone_into","clone_into","clone_into","clone_into","cmp","cmp","cmp","cmp","contains_raw_pkh","derive","derived_descriptor","derived_descriptor","desc_type","descriptor_id","deserialize","deserialize","dust_value","encode","eq","eq","eq","eq","error","explicit_script","ext","ext_check","extract_policy","extract_policy","extract_policy","find_derivation_index_for_spk","fmt","fmt","fmt","fmt","fmt","fmt","for_each_key","for_each_key","from","from","from","from","from","from","from","from","from","from","from_ast","from_components_unchecked","from_str","from_str","from_str_ext","from_str_insane","from_tree","from_tree","get_nth_child","get_nth_pk","get_satisfaction","get_satisfaction_mall","has_mixed_timelocks","has_repeated_keys","has_wildcard","hash","hash","hash","hash","into","into","into","into","into_inner","into_single_descriptors","into_wallet_descriptor","into_wallet_descriptor","is_deriveable","is_multipath","is_non_malleable","iter","iter_pk","lift","lift","lift_check","max_satisfaction_size","max_satisfaction_size","max_satisfaction_size","max_satisfaction_size","max_satisfaction_weight","max_satisfaction_witness_elements","max_weight_to_satisfy","name_str","name_str","name_str","new_bare","new_pk","new_pkh","new_sh","new_sh_sortedmulti","new_sh_with_wpkh","new_sh_with_wsh","new_sh_wpkh","new_sh_wsh","new_sh_wsh_sortedmulti","new_tr","new_wpkh","new_wsh","new_wsh_sortedmulti","node","other_top_level_checks","parse","parse_descriptor","parse_insane","parse_with_ext","partial_cmp","partial_cmp","partial_cmp","partial_cmp","pk_len","pk_len","pk_len","plan","plan_mall","policy","requires_sig","sanity_check","sanity_check","satisfy","satisfy","satisfy_malleable","script_code","script_pubkey","script_size","serialize","serialize","sig_type","sig_type","sig_type","substitute_raw_pkh","template","to_owned","to_owned","to_owned","to_owned","to_string","to_string","to_string_with_secret","top_level_checks","top_level_type_check","translate_pk","translate_pk","try_from","try_from","try_from","try_from","try_into","try_into","try_into","try_into","ty","type_id","type_id","type_id","type_id","unsigned_script_sig","vzip","vzip","vzip","vzip","within_resource_limits","calc_checksum","calc_checksum_bytes","Base58","Bip32","Error","ExternalAndInternalAreTheSame","HardenedDerivationXpub","Hex","InvalidDescriptorCharacter","InvalidDescriptorChecksum","InvalidHdKeyPath","Key","Miniscript","MultiPath","Pk","Policy","borrow","borrow_mut","fmt","fmt","from","from","from","from","from","from","from","from","into","to_string","try_from","try_into","type_id","vzip","AbsoluteTimelock","AddOnLeaf","AddOnPartialComplete","BuildSatisfaction","Complete","Condition","ConditionMap","EcdsaSignature","Fingerprint","FoldedConditionMap","Hash160Preimage","Hash256Preimage","IncompatibleConditions","IndexOutOfRange","MixedTimelockUnits","Multisig","None","None","NotEnoughItemsSelected","Partial","PartialComplete","PkOrF","Policy","PolicyError","Psbt","PsbtTimelocks","Pubkey","RelativeTimelock","Ripemd160Preimage","Satisfaction","SatisfiableItem","SchnorrSignature","Sha256Preimage","Thresh","XOnlyPubkey","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","clone","clone","clone","clone","clone","clone","clone_into","clone_into","clone_into","clone_into","clone_into","clone_into","contribution","csv","default","eq","eq","eq","eq","eq","eq","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","from","from","from","from","from","from","from","from","from","get_condition","hash","hash","id","id","into","into","into","into","into","into","into","is_leaf","is_leaf","is_null","item","partial_cmp","requires_path","satisfaction","serialize","serialize","serialize","serialize","serialize","timelock","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","to_string","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_into","try_into","try_into","try_into","try_into","try_into","try_into","type_id","type_id","type_id","type_id","type_id","type_id","type_id","vzip","vzip","vzip","vzip","vzip","vzip","vzip","current_height","input_max_height","psbt","condition","conditions","conditions","items","items","m","m","n","n","sorted","sorted","hash","hash","hash","hash","items","keys","threshold","threshold","value","value","Bip44","Bip44Public","Bip49","Bip49Public","Bip84","Bip84Public","Bip86","Bip86Public","DescriptorTemplate","DescriptorTemplateOut","P2Pkh","P2TR","P2Wpkh","P2Wpkh_P2Sh","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","build","build","build","build","build","build","build","build","build","build","build","build","build","from","from","from","from","from","from","from","from","from","from","from","from","into","into","into","into","into","into","into","into","into","into","into","into","into_wallet_descriptor","into_wallet_descriptor","into_wallet_descriptor","into_wallet_descriptor","into_wallet_descriptor","into_wallet_descriptor","into_wallet_descriptor","into_wallet_descriptor","into_wallet_descriptor","into_wallet_descriptor","into_wallet_descriptor","into_wallet_descriptor","into_wallet_descriptor","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_into","try_into","try_into","try_into","try_into","try_into","try_into","try_into","try_into","try_into","try_into","try_into","type_id","type_id","type_id","type_id","type_id","type_id","type_id","type_id","type_id","type_id","type_id","type_id","vzip","vzip","vzip","vzip","vzip","vzip","vzip","vzip","vzip","vzip","vzip","vzip","Bip32","DerivableKey","DescriptorKey","DescriptorPublicKey","DescriptorSecretKey","Entropy","Error","ExtScriptContext","ExtendedKey","FullKey","GeneratableDefaultOptions","GeneratableKey","GeneratedKey","IntoDescriptorKey","InvalidChecksum","InvalidNetwork","InvalidScriptContext","Key","KeyError","KeyMap","Legacy","Message","Miniscript","MultiXPrv","MultiXPub","Options","Private","PrivateKeyGenerateOptions","Public","ScriptContext","ScriptContextEnum","Segwitv0","Single","Single","SinglePriv","SinglePub","SinglePubKey","SortedMultiVec","Tap","ValidNetworks","XOnly","XPrv","XPub","any_network","as_enum","at_derivation_index","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","build_template","check_global_consensus_validity","check_global_policy_validity","check_global_validity","check_local_consensus_validity","check_local_policy_validity","check_local_validity","check_pk","check_terminal_non_malleable","check_witness","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone_into","clone_into","clone_into","clone_into","clone_into","clone_into","clone_into","clone_into","clone_into","cmp","cmp","cmp","cmp","compressed","default","deref","derive","deserialize","encode","eq","eq","eq","eq","eq","eq","eq","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","for_each_key","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from_public","from_secret","from_str","from_str","from_tree","full_derivation_path","full_derivation_paths","generate","generate_default","generate_default_with_aux_rand","generate_with_aux_rand","generate_with_entropy","generate_with_entropy_default","has_secret","has_wildcard","hash","hash","hash","hash","into","into","into","into","into","into","into","into","into","into","into","into","into_assets","into_descriptor_key","into_descriptor_key","into_descriptor_key","into_descriptor_key","into_descriptor_key","into_descriptor_key","into_descriptor_key","into_extended_key","into_extended_key","into_extended_key","into_key","into_single_keys","into_single_keys","into_xprv","into_xpub","is_deriveable","is_legacy","is_legacy","is_multipath","is_multipath","is_segwit_v0","is_segwit_v0","is_taproot","is_taproot","is_uncompressed","is_x_only_key","k","key","key","lift","mainnet_network","master_fingerprint","max_satisfaction_size","max_satisfaction_size","max_satisfaction_witness_elements","merge_networks","n","name_str","new","num_der_paths","origin","origin","other_top_level_checks","override_valid_networks","partial_cmp","partial_cmp","partial_cmp","partial_cmp","pk_len","pks","sanity_check","satisfy","script_size","serialize","sig_type","sorted_node","test_networks","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","to_public","to_string","to_string","to_string","to_string","top_level_checks","top_level_type_check","translate_pk","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_into","try_into","try_into","try_into","try_into","try_into","try_into","try_into","try_into","try_into","try_into","try_into","type_id","type_id","type_id","type_id","type_id","type_id","type_id","type_id","type_id","type_id","type_id","type_id","vzip","vzip","vzip","vzip","vzip","vzip","vzip","vzip","vzip","vzip","vzip","vzip","PsbtUtils","fee_amount","fee_rate","get_utxo_for","AddressInfo","ApplyBlockError","Balance","CannotConnect","ChangeSet","Descriptor","Descriptor","Descriptor","IsDust","LoadError","LoadedDescriptorDoesNotMatch","LoadedGenesisDoesNotMatch","LoadedNetworkDoesNotMatch","MissingDescriptor","MissingGenesis","MissingNetwork","NewError","NewOrLoadError","UnexpectedConnectedToHash","Update","Wallet","add","add_signer","address","all_unbounded_spk_iters","apply_block","apply_block_connected_to","apply_unconfirmed_txs","apply_update","as_ref","balance","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","build_fee_bump","build_tx","calculate_fee","calculate_fee_rate","cancel_tx","chain","chain","checkpoints","clone","clone","clone_into","clone_into","coin_selection","confirmed","default","default","deref","derivation_index","derivation_of_spk","descriptor_checksum","deserialize","eq","eq","error","export","finalize_psbt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","from","from","from","from","from","from","from","from","from","from","get_descriptor_for_keychain","get_psbt_input","get_signers","get_tx","get_utxo","graph","immature","index","indexed_tx_graph","insert_checkpoint","insert_tx","insert_txout","into","into","into","into","into","into","into","into","is_dust","is_mine","keychain","keychains","last_active_indices","latest_checkpoint","list_output","list_unspent","list_unused_addresses","load_from_changeset","local_chain","mark_used","network","network","new","new_or_load","new_or_load_with_genesis_hash","new_with_genesis_hash","next_derivation_index","next_unused_address","peek_address","policies","public_descriptor","reveal_addresses_to","reveal_next_address","secp_ctx","sent_and_received","serialize","sign","signer","spk_index","staged","start_full_scan","start_sync_with_revealed_spks","take_staged","to_owned","to_owned","to_string","to_string","to_string","to_string","to_string","to_string","total","transactions","trusted_pending","trusted_spendable","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_into","try_into","try_into","try_into","try_into","try_into","try_into","try_into","tx_builder","tx_graph","type_id","type_id","type_id","type_id","type_id","type_id","type_id","type_id","unbounded_spk_iter","unbroadcast_transactions","unmark_used","untrusted_pending","vzip","vzip","vzip","vzip","vzip","vzip","vzip","vzip","wallet_name_from_descriptor","connected_to_hash","expected_hash","expected","expected","got","got","got","keychain","BnBNoExactMatch","BnBTotalTriesExceeded","BranchAndBoundCoinSelection","Change","CoinSelectionAlgorithm","CoinSelectionResult","DefaultCoinSelectionAlgorithm","Error","Excess","InsufficientFunds","LargestFirstCoinSelection","NoChange","OldestFirstCoinSelection","borrow","borrow","borrow","borrow","borrow","borrow","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","clone","clone","clone","clone_into","clone_into","clone_into","coin_select","coin_select","coin_select","coin_select","decide_change","default","default","default","excess","fee_amount","fmt","fmt","fmt","fmt","fmt","fmt","fmt","from","from","from","from","from","from","into","into","into","into","into","into","local_selected_amount","new","selected","selected_amount","to_owned","to_owned","to_owned","to_string","try_from","try_from","try_from","try_from","try_from","try_from","try_into","try_into","try_into","try_into","try_into","try_into","type_id","type_id","type_id","type_id","type_id","type_id","vzip","vzip","vzip","vzip","vzip","vzip","available","needed","amount","change_fee","dust_threshold","fee","remaining_amount","BuildFeeBumpError","CoinSelection","Conversion","CreateTxError","Descriptor","FeeRateTooLow","FeeRateUnavailable","FeeTooLow","IrreplaceableTransaction","LockTime","MiniscriptPsbt","MiniscriptPsbtError","MissingKeyOrigin","MissingNonWitnessUtxo","NoRecipients","NoUtxosSelected","OutputBelowDustLimit","OutputUpdate","Policy","Psbt","RbfSequence","RbfSequenceCsv","SpendingPolicyRequired","TransactionConfirmed","TransactionNotFound","UnknownUtxo","UnknownUtxo","UtxoUpdate","Version0","Version1Csv","borrow","borrow","borrow","borrow_mut","borrow_mut","borrow_mut","clone","clone_into","fmt","fmt","fmt","fmt","fmt","fmt","from","from","from","from","from","from","from","from","into","into","into","to_owned","to_string","to_string","to_string","try_from","try_from","try_from","try_into","try_into","try_into","type_id","type_id","type_id","vzip","vzip","vzip","csv","rbf","requested","required","required","required","FullyNodedExport","WalletExport","blockheight","blockheight","borrow","borrow_mut","change_descriptor","descriptor","deserialize","export_wallet","fmt","fmt","from","from_str","into","label","label","serialize","to_string","try_from","try_into","type_id","vzip","All","Dummy","Exclude","External","Fingerprint","Include","InputIndexOutOfRange","InputSigner","InvalidKey","InvalidNonWitnessUtxo","InvalidSighash","Legacy","MiniscriptPsbt","MissingHdKeypath","MissingKey","MissingNonWitnessUtxo","MissingWitnessScript","MissingWitnessUtxo","NonStandardSighash","None","PkHash","Psbt","Segwitv0","SighashTaproot","SignOptions","SignerCommon","SignerContext","SignerError","SignerId","SignerOrdering","SignerWrapper","SignersContainer","Tap","TapLeavesOptions","TransactionSigner","UserCanceled","add_external","allow_all_sighashes","allow_grinding","as_key_map","assume_height","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","build","clone","clone","clone","clone","clone","clone","clone","clone_into","clone_into","clone_into","clone_into","clone_into","clone_into","clone_into","cmp","cmp","default","default","default","default","deref","descriptor_secret_key","descriptor_secret_key","descriptor_secret_key","descriptor_secret_key","eq","eq","eq","eq","find","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","from","from","from","from","from","from","from","from","from","from","hash","id","id","id","id","ids","into","into","into","into","into","into","into","into","new","new","partial_cmp","partial_cmp","remove","sign_input","sign_input","sign_input","sign_input","sign_transaction","sign_transaction","sign_with_tap_internal_key","signers","tap_leaves_options","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","to_string","trust_witness_utxo","try_finalize","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_into","try_into","try_into","try_into","try_into","try_into","try_into","try_into","type_id","type_id","type_id","type_id","type_id","type_id","type_id","type_id","vzip","vzip","vzip","vzip","vzip","vzip","vzip","vzip","is_internal_key","AddForeignUtxoError","AddUtxoError","ChangeAllowed","ChangeForbidden","ChangeSpendPolicy","Custom","InvalidOutpoint","InvalidTxid","MissingUtxo","OnlyChange","Shuffle","TxBuilder","TxOrdering","UnknownUtxo","Untouched","add_data","add_foreign_utxo","add_foreign_utxo_with_sequence","add_global_xpubs","add_recipient","add_unspendable","add_utxo","add_utxos","allow_dust","borrow","borrow","borrow","borrow","borrow","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","change_policy","clone","clone","clone","clone_into","clone_into","clone_into","cmp","coin_selection","current_height","default","default","do_not_spend_change","drain_to","drain_wallet","enable_rbf","enable_rbf_with_sequence","eq","fee_absolute","fee_rate","finish","finish_with_aux_rand","fmt","fmt","fmt","fmt","fmt","fmt","fmt","from","from","from","from","from","hash","include_output_redeem_witness_script","into","into","into","into","into","manually_selected_only","nlocktime","only_spend_change","only_witness_utxo","ordering","partial_cmp","policy_path","set_recipients","sighash","sort_tx","sort_tx_with_aux_rand","to_owned","to_owned","to_owned","to_string","to_string","try_from","try_from","try_from","try_from","try_from","try_into","try_into","try_into","try_into","try_into","type_id","type_id","type_id","type_id","type_id","unspendable","version","vzip","vzip","vzip","vzip","vzip","foreign_utxo","input_txid","input_sort","output_sort"],"q":[[0,"bdk_wallet"],[97,"bdk_wallet::Utxo"],[100,"bdk_wallet::descriptor"],[352,"bdk_wallet::descriptor::checksum"],[354,"bdk_wallet::descriptor::error"],[386,"bdk_wallet::descriptor::policy"],[533,"bdk_wallet::descriptor::policy::BuildSatisfaction"],[536,"bdk_wallet::descriptor::policy::Satisfaction"],[547,"bdk_wallet::descriptor::policy::SatisfiableItem"],[557,"bdk_wallet::descriptor::template"],[693,"bdk_wallet::keys"],[994,"bdk_wallet::psbt"],[998,"bdk_wallet::wallet"],[1201,"bdk_wallet::wallet::ApplyBlockError"],[1203,"bdk_wallet::wallet::NewOrLoadError"],[1209,"bdk_wallet::wallet::coin_selection"],[1301,"bdk_wallet::wallet::coin_selection::Error"],[1303,"bdk_wallet::wallet::coin_selection::Excess"],[1308,"bdk_wallet::wallet::error"],[1379,"bdk_wallet::wallet::error::CreateTxError"],[1385,"bdk_wallet::wallet::export"],[1408,"bdk_wallet::wallet::signer"],[1585,"bdk_wallet::wallet::signer::SignerContext"],[1586,"bdk_wallet::wallet::tx_builder"],[1699,"bdk_wallet::wallet::tx_builder::AddForeignUtxoError"],[1701,"bdk_wallet::wallet::tx_builder::TxOrdering"],[1703,"bdk_wallet::types"],[1704,"core::cmp"],[1705,"core::result"],[1706,"serde::de"],[1707,"core::fmt"],[1708,"core::hash"],[1709,"bitcoin::blockdata::transaction"],[1710,"core::option"],[1711,"serde::ser"],[1712,"core::any"],[1713,"miniscript::descriptor"],[1714,"bitcoin::network"],[1715,"bitcoin::address"],[1716,"miniscript"],[1717,"miniscript::miniscript"],[1718,"miniscript::miniscript::decode"],[1719,"miniscript::miniscript::context"],[1720,"miniscript::iter::tree"],[1721,"miniscript::descriptor::key"],[1722,"alloc::vec"],[1723,"miniscript::miniscript::satisfy"],[1724,"miniscript::plan"],[1725,"bitcoin_hashes::sha256"],[1726,"miniscript::miniscript::hash256"],[1727,"bitcoin_hashes::ripemd160"],[1728,"bitcoin_hashes::hash160"],[1729,"core::clone"],[1730,"secp256k1"],[1731,"bitcoin::crypto::key"],[1732,"secp256k1::context"],[1733,"bdk_chain::descriptor_ext"],[1734,"miniscript::blanket_traits"],[1735,"bitcoin::blockdata::script::owned"],[1736,"miniscript::miniscript::analyzable"],[1737,"secp256k1::context::alloc_only"],[1738,"bitcoin::blockdata::script::borrowed"],[1739,"core::ops::range"],[1740,"core::ops::function"],[1741,"miniscript::descriptor::bare"],[1742,"miniscript::descriptor::segwitv0"],[1743,"miniscript::descriptor::tr"],[1744,"miniscript::descriptor::sh"],[1745,"miniscript::miniscript::types"],[1746,"miniscript::miniscript::types::extra_props"],[1747,"miniscript::expression"],[1748,"miniscript::miniscript::iter"],[1749,"miniscript::policy::semantic"],[1750,"miniscript::policy"],[1751,"bitcoin_units::weight"],[1752,"alloc::collections::btree::map"],[1753,"alloc::string"],[1754,"hex_conservative::error"],[1755,"base58ck::error"],[1756,"bitcoin::bip32"],[1757,"miniscript::descriptor::sortedmulti"],[1758,"core::str::traits"],[1759,"core::convert"],[1760,"core::default"],[1761,"rand_core"],[1762,"bitcoin_units::amount"],[1763,"bitcoin_units::fee_rate"],[1764,"bdk_chain::keychain"],[1765,"alloc::sync"],[1766,"core::iter::traits::iterator"],[1767,"bitcoin::blockdata::block"],[1768,"bdk_chain::local_chain"],[1769,"bdk_chain::chain_data"],[1770,"core::iter::traits::collect"],[1771,"bdk_chain::tx_graph"],[1772,"bitcoin::psbt"],[1773,"bdk_chain::spk_client"],[1774,"bitcoin::psbt::map::input"],[1775,"bdk_wallet::wallet::utils"],[1776,"core::iter::traits::double_ended"],[1777,"bdk_chain::keychain::txout_index"],[1778,"bitcoin::psbt::error"],[1779,"core::marker"],[1780,"bitcoin::blockdata::script::push_bytes::primitive"],[1781,"bitcoin::blockdata::locktime::absolute"]],"i":[1,8,0,1,0,8,0,0,0,0,0,0,1,1,0,1,6,7,8,1,6,7,8,0,1,6,7,8,1,6,7,8,1,6,6,0,0,1,6,1,6,7,8,1,6,7,8,0,1,6,7,8,1,6,1,6,7,8,6,6,0,0,8,6,1,0,7,8,1,6,0,0,1,6,7,8,1,6,7,8,1,6,7,8,8,6,1,6,7,8,7,0,1,6,7,8,0,248,248,248,94,249,24,0,0,0,0,0,0,31,0,0,33,0,0,35,94,249,24,0,0,0,94,249,24,35,31,0,94,249,24,94,249,24,94,249,24,35,24,54,55,31,31,24,24,54,55,31,24,54,55,31,31,31,31,0,33,54,55,33,55,33,33,54,55,33,54,55,33,33,54,55,33,54,55,33,54,55,0,24,54,55,31,24,54,55,31,24,54,55,31,31,24,24,24,24,24,24,31,24,31,24,54,55,31,0,24,31,31,69,24,31,24,24,24,54,55,31,31,24,31,24,24,24,24,24,24,24,54,55,31,31,31,24,31,31,31,24,31,31,31,24,24,31,31,24,24,54,55,31,24,54,55,31,31,24,93,94,24,24,31,31,31,24,31,31,33,54,55,31,24,31,24,33,54,55,24,24,24,24,24,24,24,24,24,24,24,24,24,24,31,33,31,24,31,31,24,54,55,31,33,54,55,24,24,0,31,24,31,24,31,31,24,24,31,24,31,33,54,55,31,0,24,54,55,31,24,31,24,33,33,24,31,24,54,55,31,24,54,55,31,31,24,54,55,31,24,24,54,55,31,31,0,0,74,74,0,74,74,74,74,74,74,74,74,74,74,74,74,74,74,74,74,74,74,74,74,74,74,74,74,74,74,74,74,74,121,115,115,0,122,0,0,121,120,0,121,121,115,115,115,121,122,71,115,122,122,0,0,0,71,71,120,121,121,0,0,121,121,121,120,120,121,122,73,123,115,71,120,121,122,73,123,115,71,120,121,122,73,123,71,120,121,122,73,123,71,73,123,123,120,121,122,73,123,115,120,121,122,73,123,115,115,71,120,121,122,122,73,73,123,115,71,73,120,123,121,73,120,121,122,73,123,115,71,121,122,123,73,123,73,73,120,121,122,73,123,123,120,121,122,73,123,71,115,120,121,122,73,123,115,71,120,121,122,73,123,115,71,120,121,122,73,123,115,71,120,121,122,73,123,115,71,250,250,250,251,252,253,252,253,252,253,252,253,252,253,254,255,256,257,258,259,259,258,260,261,0,0,0,0,0,0,0,0,0,0,0,0,0,0,126,128,129,130,132,134,135,136,137,138,139,140,126,128,129,130,132,134,135,136,137,138,139,140,124,126,128,129,130,132,134,135,136,137,138,139,140,126,128,129,130,132,134,135,136,137,138,139,140,126,128,129,130,132,134,135,136,137,138,139,140,125,126,128,129,130,132,134,135,136,137,138,139,140,126,128,129,130,132,134,135,136,137,138,139,140,126,128,129,130,132,134,135,136,137,138,139,140,126,128,129,130,132,134,135,136,137,138,139,140,126,128,129,130,132,134,135,136,137,138,139,140,116,0,0,0,0,158,158,0,0,147,0,0,0,0,116,116,116,33,0,0,30,116,116,103,35,158,151,0,151,0,0,30,35,103,0,0,0,0,30,0,147,103,35,0,262,35,151,143,148,30,144,116,142,35,103,145,146,147,151,143,148,30,144,116,142,35,103,145,146,147,142,33,33,33,33,33,33,33,33,33,143,30,144,142,35,103,145,146,147,143,30,144,142,35,103,145,146,147,142,35,145,147,144,144,143,35,35,142,30,142,35,103,145,146,147,148,30,144,116,116,142,142,35,35,103,103,145,146,147,142,151,151,151,143,148,30,144,116,116,116,142,35,35,103,145,146,147,148,148,35,103,142,35,35,158,161,161,158,158,161,151,35,142,35,145,147,151,143,148,30,144,116,142,35,103,145,146,147,35,127,133,143,143,148,35,103,133,151,143,143,35,103,151,151,35,262,30,35,103,262,30,262,30,35,35,142,145,146,142,0,35,33,142,142,0,142,33,142,35,145,146,33,148,142,35,145,147,33,142,142,142,142,35,33,142,0,143,30,144,142,35,103,145,146,147,103,116,142,35,103,33,33,142,151,143,148,30,144,116,142,35,103,145,146,147,151,143,148,30,144,116,142,35,103,145,146,147,151,143,148,30,144,116,142,35,103,145,146,147,151,143,148,30,144,116,142,35,103,145,146,147,0,168,168,168,0,0,0,202,0,199,200,201,0,0,201,201,201,200,200,200,0,0,202,0,0,171,172,195,172,172,172,172,172,172,172,171,172,185,195,199,200,201,202,171,172,185,195,199,200,201,202,172,172,172,172,172,213,185,172,171,185,171,185,0,171,171,185,195,172,172,172,171,171,195,0,0,172,171,171,172,185,195,195,199,199,200,200,201,201,202,202,171,172,185,185,185,195,199,200,201,202,172,172,172,172,172,185,171,195,213,172,172,172,171,172,185,195,199,200,201,202,210,172,195,172,185,172,172,172,172,172,172,172,172,213,172,172,172,172,172,172,172,172,172,172,172,172,172,171,172,0,172,172,172,172,172,171,185,171,195,199,200,201,202,171,172,171,171,171,172,185,195,199,200,201,202,171,172,185,195,199,200,201,202,0,172,171,172,185,195,199,200,201,202,172,172,172,171,171,172,185,195,199,200,201,202,0,263,263,264,265,264,265,266,266,225,225,0,226,0,0,0,0,0,225,0,226,0,225,226,224,220,221,222,225,226,224,220,221,222,220,221,222,220,221,222,223,220,221,222,0,220,221,222,224,224,225,225,226,224,220,221,222,225,226,224,220,221,222,225,226,224,220,221,222,224,222,224,224,220,221,222,225,225,226,224,220,221,222,225,226,224,220,221,222,225,226,224,220,221,222,225,226,224,220,221,222,267,267,268,269,269,268,269,0,207,227,0,207,207,192,207,192,207,207,0,207,207,207,207,207,227,207,207,207,207,207,192,192,207,192,227,207,207,227,207,192,227,207,192,227,227,227,227,207,207,192,192,227,207,207,207,207,207,207,192,227,207,192,227,227,207,192,227,207,192,227,207,192,227,207,192,227,207,192,270,270,271,271,272,273,0,0,274,229,229,229,229,229,229,229,229,229,229,229,229,274,229,229,229,229,229,229,229,234,230,234,198,230,234,198,0,198,198,198,231,198,198,198,198,198,198,198,234,230,198,231,198,0,0,0,0,0,0,0,0,231,0,0,198,70,197,197,70,197,230,198,231,232,173,70,197,234,230,198,231,232,173,70,197,234,70,230,231,232,173,70,197,234,230,231,232,173,70,197,234,230,173,173,70,197,234,232,235,232,232,232,230,231,173,234,70,230,198,198,231,232,173,70,197,234,230,230,230,198,231,232,173,70,197,234,230,235,232,232,232,70,230,198,231,232,173,70,197,234,232,70,230,173,70,239,232,232,232,174,232,197,70,197,230,231,232,173,70,197,234,198,197,197,230,198,231,232,173,70,197,234,230,198,231,232,173,70,197,234,230,198,231,232,173,70,197,234,230,198,231,232,173,70,197,234,275,0,0,244,244,0,245,242,242,242,244,245,0,0,243,245,191,191,191,191,191,191,191,191,191,191,243,242,245,244,191,243,242,245,244,191,191,245,244,191,245,244,244,191,191,245,244,191,191,191,191,191,244,191,191,191,191,191,243,243,242,242,245,244,191,243,242,245,244,244,191,191,243,242,245,244,191,191,191,191,191,244,191,191,191,245,245,191,245,244,243,242,191,243,242,245,244,191,243,242,245,244,191,243,242,245,244,191,191,191,243,242,245,244,276,276,277,277],"f":"````````````{{{d{b}}}f}{{{d{b}}}{{d{{h{f}}}}}}`{{{d{c}}}{{d{e}}}{}{}}000{{{d{jc}}}{{d{je}}}{}{}}000`{{{d{b}}}b}{{{d{l}}}l}{{{d{n}}}n}{{{d{A`}}}A`}{{{d{c}}{d{je}}}Ab{}{}}000{{{d{b}}{d{b}}}Ad}````{c{{Af{b}}}Ah}{c{{Af{l}}}Ah}{{{d{b}}{d{b}}}Aj}{{{d{l}}{d{l}}}Aj}{{{d{n}}{d{n}}}Aj}{{{d{A`}}{d{A`}}}Aj}{{{d{b}}{d{jAl}}}An}{{{d{l}}{d{jAl}}}An}{{{d{n}}{d{jAl}}}An}{{{d{A`}}{d{jAl}}}An}`{cc{}}000{{{d{b}}{d{jc}}}AbB`}{{{d{l}}{d{jc}}}AbB`}{ce{}{}}000````{{{d{A`}}}Bb}`{{{d{b}}{d{b}}}{{Bd{Ad}}}}``{{{d{A`}}}{{Bd{Bf}}}}{{{d{b}}c}AfBh}{{{d{l}}c}AfBh}``{{{d{c}}}e{}{}}000{c{{Af{e}}}{}{}}0000000{{{d{A`}}}{{d{Bj}}}}`{{{d{c}}}Bl{}}000`{{}{{d{Bn}}}}::::``````````````````````````````````````````{{{d{{C`{c}}}}Cb}{{Af{CdCf}}}{ChCj}}{{}Cl}0{{{d{{Cn{ce}}}}}{{d{{D`{ce}}}}}ChDb}{{{d{{d{{Cn{ce}}}}}}}{{Dd{{d{{Cn{ce}}}}}}}ChDb}{{{d{{C`{Df}}}}Dh}{{Af{{C`{Dj}}Dl}}}}{{{d{c}}}{{d{e}}}{}{}}000{{{d{jc}}}{{d{je}}}{}{}}000{{{d{{Cn{ce}}}}}{{Dn{{d{{Cn{ce}}}}}}}ChDb}{{{d{{Cn{ce}}}}{d{g}}}{{Eb{{E`{c}}}}}{CjCh}Db{{Ed{c}}}}0`{{{d{{Cn{c{Db{}{{Ef{e}}}}}}}}}{{Af{AbEh}}}Ch{{Fj{}{{Ej{El}}{En{F`}}{Fb{Fd}}{Ff{Fh}}}}ChChChCh}}{{{d{{Cn{cFl}}}}}{{Af{AbEh}}}Ch}{{{d{{Cn{cFn}}}}}{{Af{AbEh}}}Ch}2022102102{{{d{c}}}{{Af{AbEh}}}Ch}00{{{d{{D`{c{Db{}{{Ef{e}}}}}}}}}{{Af{AbEh}}}Ch{{Fj{}{{Ej{El}}{En{F`}}{Fb{Fd}}{Ff{Fh}}}}ChChChCh}}{{{d{{D`{cFl}}}}}{{Af{AbEh}}}Ch}{{{d{{D`{cFn}}}}}{{Af{AbEh}}}Ch}{{{d{{h{{Dn{f}}}}}}}{{Af{AbEh}}}}00`{{{d{{C`{c}}}}}{{C`{c}}}{G`Ch}}{{{d{Fl}}}Fl}{{{d{Fn}}}Fn}{{{d{{Cn{ce}}}}}{{Cn{ce}}}{G`Ch}{G`Db}}{{{d{c}}{d{je}}}Ab{}{}}000{{{d{{C`{c}}}}{d{{C`{c}}}}}Ad{GbCh}}{{{d{Fl}}{d{Fl}}}Ad}{{{d{Fn}}{d{Fn}}}Ad}{{{d{{Cn{ce}}}}{d{{Cn{ce}}}}}AdChDb}{{{d{{Cn{ce}}}}}AjChDb}{{{d{{C`{Df}}}}Dh}{{Af{{C`{Dj}}Dl}}}}{{{d{{C`{Df}}}}{d{{Gd{c}}}}Dh}{{Af{{C`{Gf}}Dl}}}Gh}{{{d{{C`{Dj}}}}{d{{Gd{c}}}}}{{Af{{C`{Gf}}Dl}}}Gh}{{{d{{C`{c}}}}}GjCh}{{{d{{C`{Df}}}}}Gl}{c{{Af{{C`{e}}}}}AhGn}{c{{Af{{Cn{eg}}}}}AhGnDb}{{{d{{C`{Df}}}}}H`}{{{d{{Cn{ce}}}}}Hb{CjCh}Db}{{{d{{C`{c}}}}{d{{C`{c}}}}}Aj{HdCh}}{{{d{Fl}}{d{Fl}}}Aj}{{{d{Fn}}{d{Fn}}}Aj}{{{d{{Cn{ce}}}}{d{{Cn{ce}}}}}AjChDb}`{{{d{{C`{c}}}}}{{Af{HbCf}}}{ChCj}}`{{{d{{Cn{ce}}}}{d{Hf}}}{{Af{AbHh}}}ChDb}{{{d{Hj}}{d{Hl}}Hn{d{{Gd{I`}}}}}{{Af{{Bd{Ib}}Id}}}}{{{d{{C`{Df}}}}{d{Hl}}Hn{d{{Gd{I`}}}}}{{Af{{Bd{Ib}}Id}}}}{{{d{{Cn{Dfc}}}}{d{Hl}}Hn{d{{Gd{I`}}}}}{{Af{{Bd{Ib}}Id}}}Db}{{{d{{C`{Df}}}}{d{{Gd{c}}}}{d{If}}{Ih{Dh}}}{{Af{{Bd{{Ij{Dh{C`{Gf}}}}}}Dl}}}Gh}{{{d{{C`{c}}}}{d{jAl}}}{{Af{AbIl}}}Ch}0{{{d{Fl}}{d{jAl}}}{{Af{AbIl}}}}{{{d{Fn}}{d{jAl}}}{{Af{AbIl}}}}{{{d{{Cn{ce}}}}{d{jAl}}}{{Af{AbIl}}}ChDb}0{{{d{{C`{c}}}}e}AjCh{{J`{{d{c}}}{{In{Aj}}}}}}{{{d{{Cn{ce}}}}g}AjChDb{{J`{{d{c}}}{{In{Aj}}}}}}{{{Jb{c}}}{{C`{c}}}Ch}{{{Jd{c}}}{{C`{c}}}Ch}{{{Jf{c}}}{{C`{c}}}Ch}{{{Jh{c}}}{{C`{c}}}Ch}{{{Jj{c}}}{{C`{c}}}Ch}{cc{}}{{{Jl{c}}}{{C`{c}}}Ch}111{{{D`{ce}}}{{Af{{Cn{ce}}Cf}}}ChDb}{{{D`{ce}}JnK`}{{Cn{ce}}}ChDb}{{{d{Bn}}}{{Af{{C`{c}}Cf}}}Gn}{{{d{Bn}}}{{Af{{Cn{ce}}Cf}}}GnDb}{{{d{Bn}}{d{Hf}}}{{Af{{Cn{ce}}Cf}}}GnDb}1{{{d{Kb}}}{{Af{{C`{c}}Cf}}}Gn}{{{d{Kb}}}{{Af{{Cn{ce}}Cf}}}GnDb}{{{d{{Cn{ce}}}}Kd}{{Bd{{d{{Cn{ce}}}}}}}ChDb}{{{d{{Cn{ce}}}}Kd}{{Bd{c}}}ChDb}{{{d{{C`{c}}}}e}{{Af{{Ij{{Dn{{Dn{f}}}}Hb}}Cf}}}{ChCj}{{Kf{c}}}}0{{{d{{Cn{ce}}}}}AjChDb}0{{{d{{C`{Df}}}}}Aj}{{{d{{C`{c}}}}{d{je}}}Ab{KhCh}B`}{{{d{Fl}}{d{jc}}}AbB`}{{{d{Fn}}{d{jc}}}AbB`}{{{d{{Cn{ce}}}}{d{jg}}}AbChDbB`}{ce{}{}}000{{{Cn{ce}}}{{D`{ce}}}ChDb}{{{C`{Df}}}{{Af{{Dn{{C`{Df}}}}Cf}}}}{{Kj{d{{Gd{I`}}}}Cb}{{Af{{Ij{KlKn}}Id}}}}{{Kl{d{{Gd{I`}}}}Cb}{{Af{{Ij{KlKn}}Id}}}}99:{{{d{{Cn{ce}}}}}{{L`{ce}}}ChDb}{{{d{{Cn{ce}}}}}{{Lb{ce}}}ChDb}{{{d{{C`{c}}}}}{{Af{{Ld{c}}Cf}}}Ch}{{{d{{Cn{ce}}}}}{{Af{{Ld{c}}Cf}}}ChDb}{{{d{{Cn{ce}}}}}{{Af{AbLf}}}ChDb}{{{d{{Cn{c{Db{}{{Ef{e}}}}}}}}}{{Bd{Kd}}}Ch{{Fj{}{{Ej{El}}{En{F`}}{Fb{Fd}}{Ff{Fh}}}}ChChChCh}}{{{d{{Cn{cFl}}}}}{{Bd{Kd}}}Ch}{{{d{{Cn{cFn}}}}}{{Bd{Kd}}}Ch}{{{d{{Cn{ce}}}}}{{Af{KdCf}}}ChDb}{{{d{{C`{c}}}}}{{Af{KdCf}}}Ch}1{{{d{{C`{c}}}}}{{Af{LhCf}}}Ch}{{}{{d{Bn}}}}00{{{Cn{cLj}}}{{Af{{C`{c}}Cf}}}Ch}{c{{C`{c}}}Ch}{c{{Af{{C`{c}}Cf}}}Ch}{{{Cn{cFl}}}{{Af{{C`{c}}Cf}}}Ch}{{Kd{Dn{c}}}{{Af{{C`{c}}Cf}}}Ch}{{{Jd{c}}}{{C`{c}}}Ch}{{{Jl{c}}}{{C`{c}}}Ch}4{{{Cn{cFn}}}{{Af{{C`{c}}Cf}}}Ch}3{{c{Bd{{Ll{c}}}}}{{Af{{C`{c}}Cf}}}Ch}614`{{{d{{Cn{c{Db{}{{Ef{e}}}}}}}}}{{Af{AbCf}}}Ch{{Fj{}{{Ej{El}}{En{F`}}{Fb{Fd}}{Ff{Fh}}}}ChChChCh}}{{{d{If}}}{{Af{{Cn{c}}Cf}}}Db}{{{d{{Gd{c}}}}{d{Bn}}}{{Af{{Ij{{C`{Df}}{M`{DfLn}}}}Cf}}}Mb}1{{{d{If}}{d{Hf}}}{{Af{{Cn{c}}Cf}}}Db}{{{d{{C`{c}}}}{d{{C`{c}}}}}{{Bd{Ad}}}{MdCh}}{{{d{Fl}}{d{Fl}}}{{Bd{Ad}}}}{{{d{Fn}}{d{Fn}}}{{Bd{Ad}}}}{{{d{{Cn{ce}}}}{d{{Cn{ce}}}}}{{Bd{Ad}}}ChDb}{{{d{c}}}KdCh}00{{{C`{Dj}}{d{c}}}{{Af{Mf{C`{Dj}}}}}{{Ed{Dj}}}}0`{{{d{{Cn{ce}}}}}AjChDb}{{{d{{C`{c}}}}}{{Af{AbCf}}}Ch}{{{d{{Cn{ce}}}}}{{Af{AbHh}}}ChDb}{{{d{{C`{c}}}}{d{jMh}}e}{{Af{AbCf}}}{ChCj}{{Kf{c}}}}{{{d{{Cn{ce}}}}g}{{Af{{Dn{{Dn{f}}}}Cf}}}{CjCh}Db{{Kf{c}}}}0{{{d{{C`{c}}}}}{{Af{HbCf}}}{ChCj}}{{{d{{C`{c}}}}}Hb{ChCj}}{{{d{{Cn{ce}}}}}KdChDb}{{{d{{C`{c}}}}e}AfChBh}{{{d{{Cn{ce}}}}g}AfChDbBh}{{}Mj}00{{{d{{Cn{ce}}}}{d{{M`{Fhc}}}}}{{Cn{ce}}}ChDb}`{{{d{c}}}e{}{}}000{{{d{c}}}Ml{}}0{{{d{{C`{Df}}}}{d{{M`{DfLn}}}}}Ml}{{{d{{Cn{c{Db{}{{Ef{e}}}}}}}}}{{Af{AbCf}}}Ch{{Fj{}{{Ej{El}}{En{F`}}{Fb{Fd}}{Ff{Fh}}}}ChChChCh}}0{{{d{{C`{c}}}}{d{ji}}}{{Af{{Mn{g}}}}}ChCh{}{{N`{ceg}}}}{{{d{{Cn{ce}}}}{d{jk}}}{{Af{{Mn{i}}}}}ChDbCh{}{{N`{cgi}}}}{c{{Af{e}}}{}{}}0000000`{{{d{c}}}Bl{}}000={ce{}{}}000{{{d{{Cn{ce}}}}}AjChDb}{{{d{Bn}}}{{Af{MlId}}}}{{{d{Bn}}}{{Af{{Nb{f}}Id}}}}``````````````{{{d{c}}}{{d{e}}}{}{}}{{{d{jc}}}{{d{je}}}{}{}}{{{d{Id}}{d{jAl}}}An}0{NdId}{CfId}{NfId}{NhId}{NjId}{NlId}{NnId}{cc{}}>{{{d{c}}}Ml{}}{c{{Af{e}}}{}{}}0{{{d{c}}}Bl{}}{ce{}{}}```````````````````````````````````>>>>>>>======={{{d{O`}}}O`}{{{d{Ob}}}Ob}{{{d{Od}}}Od}{{{d{Ib}}}Ib}{{{d{Of}}}Of}{{{d{Hn}}}Hn}{{{d{c}}{d{je}}}Ab{}{}}00000``{{}Of}{{{d{O`}}{d{O`}}}Aj}{{{d{Ob}}{d{Ob}}}Aj}{{{d{Od}}{d{Od}}}Aj}{{{d{Ib}}{d{Ib}}}Aj}{{{d{Of}}{d{Of}}}Aj}{{{d{Nf}}{d{Nf}}}Aj}{{{d{O`}}{d{jAl}}}An}{{{d{Ob}}{d{jAl}}}An}{{{d{Od}}{d{jAl}}}An}{{{d{Ib}}{d{jAl}}}An}{{{d{Of}}{d{jAl}}}An}{{{d{Nf}}{d{jAl}}}An}0{{{d{Hn}}{d{jAl}}}An}{cc{}}00{AjOd}{ObIb}2222{{{d{Ib}}{d{{M`{Ml{Dn{Kd}}}}}}}{{Af{OfNf}}}}{{{d{O`}}{d{jc}}}AbB`}{{{d{Of}}{d{jc}}}AbB`}{{{d{Ob}}}Ml}`{ce{}{}}000000{{{d{Ob}}}Aj}{{{d{Od}}}Aj}{{{d{Of}}}Aj}`{{{d{Of}}{d{Of}}}{{Bd{Ad}}}}{{{d{Ib}}}Aj}`{{{d{O`}}c}AfBh}{{{d{Ob}}c}AfBh}{{{d{Od}}c}AfBh}{{{d{Ib}}c}AfBh}{{{d{Of}}c}AfBh}`{{{d{c}}}e{}{}}00000{{{d{c}}}Ml{}}{c{{Af{e}}}{}{}}0000000000000{{{d{c}}}Bl{}}000000>>>>>>>``````````````````````````````````````{{{d{c}}}{{d{e}}}{}{}}00000000000{{{d{jc}}}{{d{je}}}{}{}}00000000000{{OhCb}{{Af{OjId}}}}{{{Ol{c}}Cb}{{Af{OjId}}}{{On{Fl}}}}{{{A@`{c}}Cb}{{Af{OjId}}}{{On{Fn}}}}{{{A@b{c}}Cb}{{Af{OjId}}}{{On{Fn}}}}{{{A@d{c}}Cb}{{Af{OjId}}}{{On{A@f}}}}{{{A@h{c}}Cb}{{Af{OjId}}}{{A@j{Fl}}}}{{{A@l{c}}Cb}{{Af{OjId}}}{{A@j{Fl}}}}{{{A@n{c}}Cb}{{Af{OjId}}}{{A@j{Fn}}}}{{{AA`{c}}Cb}{{Af{OjId}}}{{A@j{Fn}}}}{{{AAb{c}}Cb}{{Af{OjId}}}{{A@j{Fn}}}}{{{AAd{c}}Cb}{{Af{OjId}}}{{A@j{Fn}}}}{{{AAf{c}}Cb}{{Af{OjId}}}{{A@j{A@f}}}}{{{AAh{c}}Cb}{{Af{OjId}}}{{A@j{A@f}}}}{cc{}}00000000000{ce{}{}}00000000000{{Oj{d{{Gd{I`}}}}Cb}{{Af{{Ij{KlKn}}Id}}}}{{c{d{{Gd{I`}}}}Cb}{{Af{{Ij{{C`{Df}}{M`{DfLn}}}}Id}}}{}}00000000000{c{{Af{e}}}{}{}}00000000000000000000000{{{d{c}}}Bl{}}00000000000444444444444```````````````````````````````````````````{{}AAj}{{}Cl}{{DfDh}{{Af{DjDl}}}}{{{d{c}}}{{d{e}}}{}{}}00000000000{{{d{jc}}}{{d{je}}}{}{}}00000000000{{{d{{AAl{ce}}}}{d{g}}}{{Eb{{E`{c}}}}}{CjCh}Db{{Ed{c}}}}{{{d{{Cn{c{Db{}{{Ef{e}}}}}}}}}{{Af{AbEh}}}Ch{{Fj{}{{Ej{El}}{En{F`}}{Fb{Fd}}{Ff{Fh}}}}ChChChCh}}00000{{{d{c}}}{{Af{AbEh}}}Ch}{{{d{{D`{c{Db{}{{Ef{e}}}}}}}}}{{Af{AbEh}}}Ch{{Fj{}{{Ej{El}}{En{F`}}{Fb{Fd}}{Ff{Fh}}}}ChChChCh}}{{{d{{h{{Dn{f}}}}}}}{{Af{AbEh}}}}{{{d{{AAn{ce}}}}}{{AAn{ce}}}G`Db}{{{d{Cl}}}Cl}{{{d{AB`}}}AB`}{{{d{{AAl{ce}}}}}{{AAl{ce}}}{G`Ch}{G`Db}}{{{d{Df}}}Df}{{{d{Ln}}}Ln}{{{d{ABb}}}ABb}{{{d{ABd}}}ABd}{{{d{ABf}}}ABf}{{{d{c}}{d{je}}}Ab{}{}}00000000{{{d{{AAl{ce}}}}{d{{AAl{ce}}}}}Ad{GbCh}{GbDb}}{{{d{Df}}{d{Df}}}Ad}{{{d{ABb}}{d{ABb}}}Ad}{{{d{ABf}}{d{ABf}}}Ad}`{{}AB`}{{{d{{AAn{ce}}}}}{{d{g}}}{}Db{}}{{DfDh}{{Af{DjDl}}}}{c{{Af{Df}}}Ah}{{{d{{AAl{ce}}}}}Hb{CjCh}Db}{{{d{Cl}}{d{Cl}}}Aj}{{{d{{AAl{ce}}}}{d{{AAl{ce}}}}}Aj{HdCh}{HdDb}}{{{d{Df}}{d{Df}}}Aj}{{{d{Ln}}{d{Ln}}}Aj}{{{d{ABb}}{d{ABb}}}Aj}{{{d{ABd}}{d{ABd}}}Aj}{{{d{ABf}}{d{ABf}}}Aj}{{{d{{ABh{c}}}}{d{jAl}}}An{ABjDb}}{{{d{Cl}}{d{jAl}}}An}{{{d{AB`}}{d{jAl}}}An}{{{d{Nh}}{d{jAl}}}An}0{{{d{{AAl{ce}}}}{d{jAl}}}{{Af{AbIl}}}ChDb}0{{{d{Df}}{d{jAl}}}{{Af{AbIl}}}}0{{{d{Ln}}{d{jAl}}}{{Af{AbIl}}}}0{{{d{ABb}}{d{jAl}}}{{Af{AbIl}}}}{{{d{ABd}}{d{jAl}}}{{Af{AbIl}}}}{{{d{ABf}}{d{jAl}}}{{Af{AbIl}}}}{{{d{{AAl{ce}}}}g}AjChDb{{J`{{d{c}}}{{In{Aj}}}}}}{ABl{{ABn{c}}}Db}{cc{}}{AC`{{ABn{c}}}Db}1111{NnNh}2{CfNh}3{DjDf}44444{{DfAAj}{{ABh{c}}}Db}{{LnAAj}{{ABh{c}}}Db}{{{d{Bn}}}{{Af{Df}}}}{{{d{Bn}}}{{Af{Ln}}}}{{{d{Kb}}}{{Af{{AAl{ce}}Cf}}}{ACbCh}Db}{{{d{Df}}}{{Bd{ACd}}}}{{{d{Df}}}{{Dn{ACd}}}}{c{{Af{{AAn{{ACl{}{{ACf{e}}{ACh{c}}{ACj{g}}}}i}}g}}}{}{{ACn{{h{f}}}}AD`}ABjDb}{{}{{Af{{AAn{ADbc}}e}}}Db{}}{{{d{jc}}}{{Af{{AAn{ADbe}}g}}}{ADdADf}Db{}}{{c{d{je}}}{{Af{{AAn{{ACl{}{{ACf{g}}{ACh{c}}{ACj{i}}}}k}}i}}}{}{ADdADf}{{ACn{{h{f}}}}AD`}ABjDb}{{ce}{{Af{{AAn{{ACl{}{{ACf{e}}{ACh{c}}{ACj{g}}}}i}}g}}}{}{{ACn{{h{f}}}}AD`}ABjDb}{c{{Af{{AAn{ADbe}}g}}}{}Db{}}{{{d{{ABn{c}}}}}AjDb}{{{d{Df}}}Aj}{{{d{{AAl{ce}}}}{d{jg}}}Ab{KhCh}{KhDb}B`}{{{d{Df}}{d{jc}}}AbB`}{{{d{ABb}}{d{jc}}}AbB`}{{{d{ABf}}{d{jc}}}AbB`}{ce{}{}}00000000000{DfADh}{On{{Af{{ABh{c}}Nh}}}Db}{{A@j{Bd{ADj}}ACd}{{Af{{ABh{c}}Nh}}}Db}{{{AAn{ec}}}{{Af{{ABh{c}}Nh}}}Db{{On{c}}}}{{{AAn{ec}}{Bd{ADj}}ACd}{{Af{{ABh{c}}Nh}}}Db{{A@j{c}}}}{{{ABh{c}}}{{Af{{ABh{c}}Nh}}}Db}{Df{{Af{{ABh{c}}Nh}}}Db}{Ln{{Af{{ABh{c}}Nh}}}Db}{A@j{{Af{{ABn{c}}Nh}}}Db}{{{ABn{c}}}{{Af{{ABn{c}}Nh}}}Db}{{{AAn{ec}}}{{Af{{ABn{c}}Nh}}}Db{{A@j{c}}}}{{{AAn{ce}}}c{}Db}{Df{{Dn{Df}}}}{Ln{{Dn{Ln}}}}{{{ABn{c}}Cb}{{Bd{AC`}}}Db}{{{ABn{c}}Cb{d{{Gd{e}}}}}ABlDbMb}{{{d{Df}}}Aj}{{}Aj}{{{d{Cl}}}Aj}2{{{d{Ln}}}Aj}212133{{{d{{AAl{ce}}}}}KdChDb}``{{{d{{AAl{ce}}}}}{{Af{{Ld{c}}Cf}}}ChDb}{{}AAj}{{{d{Df}}}ADl}{{{d{{Cn{c{Db{}{{Ef{e}}}}}}}}}{{Bd{Kd}}}Ch{{Fj{}{{Ej{El}}{En{F`}}{Fb{Fd}}{Ff{Fh}}}}ChChChCh}}44{{{d{AAj}}{d{AAj}}}AAj}5{{}{{d{Bn}}}}{{Kd{Dn{c}}}{{Af{{AAl{ce}}Cf}}}ChDb}{{{d{Df}}}Kd}``{{{d{{Cn{c{Db{}{{Ef{e}}}}}}}}}{{Af{AbCf}}}Ch{{Fj{}{{Ej{El}}{En{F`}}{Fb{Fd}}{Ff{Fh}}}}ChChChCh}}{{{ABh{c}}AAj}{{ABh{c}}}Db}{{{d{{AAl{ce}}}}{d{{AAl{ce}}}}}{{Bd{Ad}}}{MdCh}{MdDb}}{{{d{Df}}{d{Df}}}{{Bd{Ad}}}}{{{d{ABb}}{d{ABb}}}{{Bd{Ad}}}}{{{d{ABf}}{d{ABf}}}{{Bd{Ad}}}}{{{d{c}}}KdCh}{{{d{{AAl{ce}}}}}{{d{{h{c}}}}}ChDb}{{{d{{AAl{ce}}}}}{{Af{AbCf}}}ChDb}{{{d{{AAl{ce}}}}g}{{Af{{Dn{{Dn{f}}}}Cf}}}{CjCh}Db{{Kf{c}}}}{{{d{{AAl{ce}}}}}KdChDb}{{{d{Df}}c}AfBh}{{}Mj}{{{d{{AAl{ce}}}}}{{D`{ce}}}{CjCh}Db}{{}AAj}{{{d{c}}}e{}{}}00000000{{{d{Ln}}{d{{Gd{c}}}}}{{Af{DfADn}}}Mb}{{{d{c}}}Ml{}}000{{{d{{Cn{c{Db{}{{Ef{e}}}}}}}}}{{Af{AbCf}}}Ch{{Fj{}{{Ej{El}}{En{F`}}{Fb{Fd}}{Ff{Fh}}}}ChChChCh}}0{{{d{{AAl{ce}}}}{d{jk}}}{{Af{{AAl{ge}}{Mn{i}}}}}ChDbCh{}{{N`{cgi}}}}{c{{Af{e}}}{}{}}00000000000000000000000{{{d{c}}}Bl{}}00000000000{ce{}{}}00000000000`{{{d{AE`}}}{{Bd{AEb}}}}{{{d{AE`}}}{{Bd{AEd}}}}{{{d{AE`}}Kd}{{Bd{Bj}}}}`````````````````````{{AEfAEf}AEf}{{{d{jAEh}}bAEj{AEn{AEl}}}Ab}`{{{d{AEh}}}{{M`{b{`{{AFd{}{{AF`{{AFb{Hb}}}}}}G`}}}}}}{{{d{jAEh}}{d{AFf}}Dh}{{Af{AbAFh}}}}{{{d{jAEh}}{d{AFf}}DhAFj}{{Af{AbAFl}}}}{{{d{jAEh}}c}Ab{{AG`{}{{AF`{{Ij{{d{AFn}}H`}}}}}}}}{{{d{jAEh}}c}{{Af{AbAFh}}}{{AGd{AGb}}}}{{{d{AEh}}}{{d{{AGh{AGf}}}}}}{{{d{AEh}}}AEf}{{{d{c}}}{{d{e}}}{}{}}0000000{{{d{jc}}}{{d{je}}}{}{}}0000000{{{d{jAEh}}AGj}{{Af{{AGn{AGl}}AH`}}}}{{{d{jAEh}}}{{AGn{AGl}}}}{{{d{AEh}}{d{AFn}}}{{Af{AEbAHb}}}}{{{d{AEh}}{d{AFn}}}{{Af{AEdAHb}}}}{{{d{jAEh}}{d{AFn}}}Ab}``{{{d{AEh}}}AHd}{{{d{AEf}}}AEf}{{{d{AGb}}}AGb}{{{d{c}}{d{je}}}Ab{}{}}0``{{}AEf}{{}AGb}{{{d{AHf}}}{{d{c}}}{}}{{{d{AEh}}b}{{Bd{Dh}}}}{{{d{AEh}}{d{If}}}{{Bd{{Ij{bDh}}}}}}{{{d{AEh}}b}Ml}{c{{Af{AEf}}}Ah}{{{d{AEf}}{d{AEf}}}Aj}{{{d{AHf}}{d{AHf}}}Aj}``{{{d{AEh}}{d{jAHh}}AHj}{{Af{AjAHl}}}}{{{d{AEf}}{d{jAl}}}{{Af{AbIl}}}}0{{{d{AEh}}{d{jAl}}}An}{{{d{AGb}}{d{jAl}}}An}{{{d{AHf}}{d{jAl}}}An}0{{{d{AHn}}{d{jAl}}}An}0{{{d{AI`}}{d{jAl}}}An}0{{{d{AIb}}{d{jAl}}}An}0{{{d{AId}}{d{jAl}}}An}0{cc{}}0{{{AIf{b}}}AGb}{AIhAGb}222222{{{d{AEh}}b}{{d{Kl}}}}{{{d{AEh}}l{Bd{AIj}}Aj}{{Af{AIlAIn}}}}{{{d{AEh}}b}{{AEn{Hl}}}}{{{d{AEh}}AGj}{{Bd{{AJ`{{AEn{AFn}}AGf}}}}}}{{{d{AEh}}Bb}{{Bd{l}}}}````{{{d{jAEh}}AFj}{{Af{AjAJb}}}}{{{d{jAEh}}AFn}Aj}{{{d{jAEh}}BbBj}Ab}{ce{}{}}0000000{{{d{AJd}}{d{If}}}Aj}{{{d{AEh}}{d{If}}}Aj}`{{{d{AEh}}}{{`{{AFd{}{{AF`{{Ij{{d{b}}{d{Kl}}}}}}}}}}}}`{{{d{AEh}}}AJf}{{{d{AEh}}}{{`{{AFd{}{{AF`{l}}}}}}}}0{{{d{AEh}}b}{{`{{AJh{}{{AF`{AHf}}}}}}}}{AJj{{Af{AEhAI`}}}}{{{d{AEh}}}{{d{AJl}}}}{{{d{jAEh}}bDh}Aj}{{{d{AEh}}}Cb}`{{ccCb}{{Af{AEhAHn}}}Kj}{{cc{Bd{AJj}}Cb}{{Af{AEhAIb}}}Kj}{{cc{Bd{AJj}}CbAJn}{{Af{AEhAIb}}}Kj}{{ccCbAJn}{{Af{AEhAHn}}}Kj}{{{d{AEh}}b}Dh}{{{d{jAEh}}b}AHf}{{{d{AEh}}bDh}AHf}{{{d{AEh}}b}{{Af{{Bd{Ib}}Id}}}}{{{d{AEh}}b}{{d{Kl}}}}{{{d{jAEh}}bDh}{{`{{AFd{}{{AF`{AHf}}}}}}}}4{{{d{AEh}}}{{d{{Gd{I`}}}}}}{{{d{AEh}}{d{AFn}}}{{Ij{AEbAEb}}}}{{{d{AEf}}c}AfBh}{{{d{AEh}}{d{jAHh}}AHj}{{Af{AjAHl}}}}`{{{d{AEh}}}{{d{{AK`{b}}}}}}{{{d{AEh}}}{{Bd{{d{AJj}}}}}}{{{d{AEh}}}{{AKb{b}}}}{{{d{AEh}}}AKd}{{{d{jAEh}}}{{Bd{AJj}}}}{{{d{c}}}e{}{}}0{{{d{c}}}Ml{}}00000{{{d{AEf}}}AEb}{{{d{AEh}}}{{`{{AFd{}{{AF`{{AJ`{{AEn{AFn}}AGf}}}}}}}}}}`1{c{{Af{e}}}{}{}}000000000000000`{{{d{AEh}}}{{d{{AGh{AGf}}}}}}{{{d{c}}}Bl{}}0000000{{{d{AEh}}b}{{`{{AFd{}{{AF`{{AFb{Hb}}}}}}G`}}}}{{{d{AEh}}}{{`{{AFd{}{{AF`{{AKf{{AEn{AFn}}AGf}}}}}}}}}}{{{d{jAEh}}bDh}Aj}`{ce{}{}}0000000{{c{Bd{c}}Cb{d{{Gd{I`}}}}}{{Af{MlId}}}Kj}`````````````````````{{{d{c}}}{{d{e}}}{}{}}00000{{{d{jc}}}{{d{je}}}{}{}}00000{{{d{AKh}}}AKh}{{{d{AKj}}}AKj}{{{d{AKl}}}AKl}{{{d{c}}{d{je}}}Ab{}{}}00{{{d{AKn}}{Dn{n}}{Dn{n}}AEdH`{d{If}}}{{Af{AL`ALb}}}}{{{d{AKh}}{Dn{n}}{Dn{n}}AEdH`{d{If}}}{{Af{AL`ALb}}}}{{{d{AKj}}{Dn{n}}{Dn{n}}AEdH`{d{If}}}{{Af{AL`ALb}}}}{{{d{AKl}}{Dn{n}}{Dn{n}}AEdH`{d{If}}}{{Af{AL`ALb}}}}{{H`AEd{d{If}}}ALd}{{}AKh}{{}AKj}{{}AKl}``{{{d{ALb}}{d{jAl}}}An}0{{{d{ALd}}{d{jAl}}}An}{{{d{AL`}}{d{jAl}}}An}{{{d{AKh}}{d{jAl}}}An}{{{d{AKj}}{d{jAl}}}An}{{{d{AKl}}{d{jAl}}}An}{cc{}}00000{ce{}{}}00000{{{d{AL`}}}H`}{H`AKl}`1{{{d{c}}}e{}{}}00{{{d{c}}}Ml{}}{c{{Af{e}}}{}{}}00000000000{{{d{c}}}Bl{}}00000666666`````````````````````````````````````{{{d{c}}}{{d{e}}}{}{}}00{{{d{jc}}}{{d{je}}}{}{}}00{{{d{ALf}}}ALf}{{{d{c}}{d{je}}}Ab{}{}}{{{d{ALf}}{d{jAl}}}An}0{{{d{AIn}}{d{jAl}}}An}0{{{d{AH`}}{d{jAl}}}An}0>>{ALhAIn}{ALbAIn}{NfAIn}{ALfAIn}{IdAIn}{cc{}}{ce{}{}}00{{{d{c}}}e{}{}}{{{d{c}}}Ml{}}00{c{{Af{e}}}{}{}}00000{{{d{c}}}Bl{}}00444``````````{{{d{c}}}{{d{e}}}{}{}}{{{d{jc}}}{{d{je}}}{}{}}{{{d{ALj}}}{{Bd{Ml}}}}{{{d{ALj}}}Ml}{c{{Af{ALj}}}Ah}{{{d{AEh}}{d{Bn}}Aj}{{Af{ALj{d{Bn}}}}}}{{{d{ALj}}{d{jAl}}}An}0<{{{d{Bn}}}{{Af{ALjc}}}{}}<``{{{d{ALj}}c}AfBh};::9=````````````````````````````````````{{{d{jHl}}ALlAEj{AEn{AEl}}}{{Bd{{AEn{AEl}}}}}}``{{{d{Hl}}{d{{Gd{I`}}}}}Kn}`::::::::99999999{{Kn{d{{C`{Df}}}}{d{{Gd{I`}}}}}Hl}{{{d{ALl}}}ALl}{{{d{ALn}}}ALn}{{{d{{AM`{c}}}}}{{AM`{c}}}{G`AMbABjG`}}{{{d{AEj}}}AEj}{{{d{Hl}}}Hl}{{{d{AHj}}}AHj}{{{d{AMd}}}AMd}{{{d{c}}{d{je}}}Ab{}{}}000000{{{d{ALl}}{d{ALl}}}Ad}{{{d{AEj}}{d{AEj}}}Ad}{{}AEj}{{}Hl}{{}AHj}{{}AMd}{{{d{{AM`{c}}}}}{{d{e}}}{AMbABjG`}{}}{{{d{AMf}}}{{Bd{Ln}}}}{{{d{{AM`{{AMh{AC`}}}}}}}{{Bd{Ln}}}}{{{d{{AM`{AMj}}}}}{{Bd{Ln}}}}{{{d{{AM`{{AMl{AC`}}}}}}}{{Bd{Ln}}}}{{{d{ALl}}{d{ALl}}}Aj}{{{d{ALn}}{d{ALn}}}Aj}{{{d{AEj}}{d{AEj}}}Aj}{{{d{AMd}}{d{AMd}}}Aj}{{{d{Hl}}ALl}{{Bd{{d{{AEn{AEl}}}}}}}}{{{d{ALl}}{d{jAl}}}An}{{{d{AHl}}{d{jAl}}}An}0{{{d{ALn}}{d{jAl}}}An}{{{d{{AM`{c}}}}{d{jAl}}}An{ABjAMbABjG`}}{{{d{AEj}}{d{jAl}}}An}{{{d{Hl}}{d{jAl}}}An}{{{d{AHj}}{d{jAl}}}An}{{{d{AMd}}{d{jAl}}}An}{FhALl}{ADlALl}{cc{}}0000000{{{d{ALl}}{d{jc}}}AbB`}{{{d{AMf}}{d{{Gd{I`}}}}}ALl}{{{d{{AM`{AMj}}}}{d{{Gd{I`}}}}}ALl}{{{d{{AM`{{AMl{AC`}}}}}}{d{{Gd{I`}}}}}ALl}{{{d{{AM`{{AMh{AC`}}}}}}{d{{Gd{I`}}}}}ALl}{{{d{Hl}}}{{Dn{{d{ALl}}}}}}{ce{}{}}0000000{{cALn}{{AM`{c}}}{AMbABjG`}}{{}Hl}{{{d{ALl}}{d{ALl}}}{{Bd{Ad}}}}{{{d{AEj}}{d{AEj}}}{{Bd{Ad}}}}{{{d{jHl}}ALlAEj}{{Bd{{AEn{AEl}}}}}}{{{d{AMn}}{d{jAHh}}Kd{d{AHj}}{d{{Gd{I`}}}}}{{Af{AbAHl}}}}{{{d{{AM`{{AMl{AC`}}}}}}{d{jAHh}}Kd{d{AHj}}{d{{Gd{I`}}}}}{{Af{AbAHl}}}}{{{d{{AM`{{AMh{AC`}}}}}}{d{jAHh}}Kd{d{AHj}}{d{{Gd{I`}}}}}{{Af{AbAHl}}}}{{{d{{AM`{AMj}}}}{d{jAHh}}Kd{d{AHj}}{d{{Gd{I`}}}}}{{Af{AbAHl}}}}{{{d{AEl}}{d{jAHh}}{d{AHj}}{d{{Gd{I`}}}}}{{Af{AbAHl}}}}{{{d{c}}{d{jAHh}}{d{AHj}}{d{{Gd{I`}}}}}{{Af{AbAHl}}}{}}`{{{d{Hl}}}{{Dn{{d{{AEn{AEl}}}}}}}}`{{{d{c}}}e{}{}}000000{{{d{c}}}Ml{}}``{c{{Af{e}}}{}{}}000000000000000{{{d{c}}}Bl{}}0000000{ce{}{}}0000000````````````````{{{d{j{AGn{c}}}}{d{e}}}{{d{j{AGn{c}}}}}{}{{ANb{AN`}}}}{{{d{j{AGn{c}}}}BbAIlLh}{{Af{{d{j{AGn{c}}}}ANd}}}{}}{{{d{j{AGn{c}}}}BbAIlLhBf}{{Af{{d{j{AGn{c}}}}ANd}}}{}}{{{d{j{AGn{c}}}}}{{d{j{AGn{c}}}}}{}}{{{d{j{AGn{c}}}}HbAEb}{{d{j{AGn{c}}}}}{}}{{{d{j{AGn{c}}}}Bb}{{d{j{AGn{c}}}}}{}}{{{d{j{AGn{c}}}}Bb}{{Af{{d{j{AGn{c}}}}ANf}}}{}}{{{d{j{AGn{c}}}}{d{{h{Bb}}}}}{{Af{{d{j{AGn{c}}}}ANf}}}{}}{{{d{j{AGn{c}}}}Aj}{{d{j{AGn{c}}}}}{}}{{{d{c}}}{{d{e}}}{}{}}0000{{{d{jc}}}{{d{je}}}{}{}}0000{{{d{j{AGn{c}}}}ANh}{{d{j{AGn{c}}}}}{}}{{{d{{AGn{c}}}}}{{AGn{c}}}G`}{{{d{ANj}}}ANj}{{{d{ANh}}}ANh}{{{d{c}}{d{je}}}Ab{}{}}00{{{d{ANh}}{d{ANh}}}Ad}{{{AGn{c}}e}{{AGn{e}}}{}AKn}{{{d{j{AGn{c}}}}Dh}{{d{j{AGn{c}}}}}{}}{{}ANj}{{}ANh}{{{d{j{AGn{c}}}}}{{d{j{AGn{c}}}}}{}}{{{d{j{AGn{c}}}}Hb}{{d{j{AGn{c}}}}}{}}11{{{d{j{AGn{c}}}}Bf}{{d{j{AGn{c}}}}}{}}{{{d{ANh}}{d{ANh}}}Aj}{{{d{j{AGn{c}}}}AEb}{{d{j{AGn{c}}}}}{}}{{{d{j{AGn{c}}}}AEd}{{d{j{AGn{c}}}}}{}}{{{AGn{c}}}{{Af{AHhAIn}}}AKn}{{{AGn{c}}{d{je}}}{{Af{AHhAIn}}}AKnADf}{{{d{{AGn{c}}}}{d{jAl}}}AnABj}{{{d{ANf}}{d{jAl}}}An}0{{{d{ANd}}{d{jAl}}}An}0{{{d{ANj}}{d{jAl}}}An}{{{d{ANh}}{d{jAl}}}An}{cc{}}0000{{{d{ANh}}{d{jc}}}AbB`}>{ce{}{}}0000?{{{d{j{AGn{c}}}}ANl}{{d{j{AGn{c}}}}}{}}{{{d{j{AGn{c}}}}}{{d{j{AGn{c}}}}}{}}0{{{d{j{AGn{c}}}}ANj}{{d{j{AGn{c}}}}}{}}{{{d{ANh}}{d{ANh}}}{{Bd{Ad}}}}{{{d{j{AGn{c}}}}{M`{Ml{Dn{Kd}}}}b}{{d{j{AGn{c}}}}}{}}{{{d{j{AGn{c}}}}{Dn{{Ij{HbAEb}}}}}{{d{j{AGn{c}}}}}{}}{{{d{j{AGn{c}}}}AIj}{{d{j{AGn{c}}}}}{}}{{{d{ANj}}{d{jAFn}}}Ab}{{{d{ANj}}{d{jAFn}}{d{jc}}}AbADf}{{{d{c}}}e{}{}}00{{{d{c}}}Ml{}}0{c{{Af{e}}}{}{}}000000000{{{d{c}}}Bl{}}0000{{{d{j{AGn{c}}}}{Dn{Bb}}}{{d{j{AGn{c}}}}}{}}{{{d{j{AGn{c}}}}ANn}{{d{j{AGn{c}}}}}{}}?????````","D":"FGd","p":[[6,"KeychainKind",0,1703],[1,"reference"],[1,"u8"],[1,"slice"],[0,"mut"],[5,"LocalOutput",0,1703],[5,"WeightedUtxo",0,1703],[6,"Utxo",0,1703],[1,"unit"],[6,"Ordering",1704],[6,"Result",1705],[10,"Deserializer",1706],[1,"bool"],[5,"Formatter",1707],[8,"Result",1707],[10,"Hasher",1708],[5,"OutPoint",1709],[6,"Option",1710],[5,"Sequence",1709],[10,"Serializer",1711],[5,"TxOut",1709],[5,"TypeId",1712],[1,"str"],[6,"Descriptor",100,1713],[6,"Network",1714],[5,"Address",1715],[6,"Error",1716],[10,"MiniscriptKey",1716],[10,"ToPublicKey",1716],[6,"ScriptContextEnum",693],[5,"Miniscript",100,1717],[6,"Terminal",1718],[10,"ScriptContext",693,1719],[6,"Tree",1720],[6,"DescriptorPublicKey",693,1721],[1,"u32"],[5,"DefiniteDescriptorKey",1721],[6,"ConversionError",1721],[5,"Vec",1722],[6,"Placeholder",1723],[5,"Satisfaction",1723],[10,"AssetProvider",1724],[17,"Key"],[6,"ScriptContextError",1719],[17,"Sha256"],[5,"Hash",1725],[17,"Hash256"],[5,"Hash",1726],[17,"Ripemd160"],[5,"Hash",1727],[17,"Hash160"],[5,"Hash",1728],[10,"ParseableKey",1718],[6,"Legacy",100,1719],[6,"Segwitv0",100,1719],[10,"Clone",1729],[10,"Ord",1704],[5,"Secp256k1",1730],[5,"PublicKey",1731],[10,"Verification",1732],[6,"DescriptorType",1713],[5,"DescriptorId",1733],[10,"FromStrKey",1734],[1,"u64"],[5,"ScriptBuf",1735],[10,"PartialEq",1704],[5,"ExtParams",1736],[6,"AnalysisError",1736],[10,"ExtractPolicy",100],[5,"SignersContainer",1408],[6,"BuildSatisfaction",386],[6,"All",1737],[5,"Policy",386],[6,"Error",354],[5,"Script",1738],[5,"Range",1739],[1,"tuple"],[5,"Error",1707],[17,"Output"],[10,"FnMut",1740],[5,"Pkh",1741],[5,"Wpkh",1742],[5,"Tr",1743],[5,"Sh",1744],[5,"Bare",1741],[5,"Wsh",1742],[5,"Type",1745],[5,"ExtData",1746],[5,"Tree",1747],[1,"usize"],[10,"Satisfier",1723],[10,"Hash",1708],[10,"IntoWalletDescriptor",100],[8,"ExtendedDescriptor",100],[8,"KeyMap",693,1713],[5,"Iter",1748],[5,"PkIter",1748],[6,"Policy",1749],[6,"LiftError",1750],[5,"Weight",1751],[6,"BareCtx",1719],[6,"TapTree",1743],[6,"DescriptorSecretKey",693,1721],[5,"BTreeMap",1752],[10,"Signing",1732],[10,"PartialOrd",1704],[5,"Plan",1724],[5,"TxIn",1709],[6,"SigType",1719],[5,"String",1753],[6,"TranslateErr",1716],[10,"Translator",1716],[1,"array"],[6,"HexToBytesError",1754],[6,"PolicyError",386],[6,"KeyError",693],[6,"Error",1755],[6,"ParsePublicKeyError",1731],[6,"Error",1756],[6,"PkOrF",386],[6,"SatisfiableItem",386],[6,"Satisfaction",386],[5,"Condition",386],[10,"DescriptorTemplate",557],[8,"DescriptorTemplateOut",557],[5,"P2Pkh",557],[10,"IntoDescriptorKey",693],[5,"P2Wpkh_P2Sh",557],[5,"P2Wpkh",557],[5,"P2TR",557],[6,"Tap",1719],[5,"Bip44",557],[10,"DerivableKey",693],[5,"Bip44Public",557],[5,"Bip49",557],[5,"Bip49Public",557],[5,"Bip84",557],[5,"Bip84Public",557],[5,"Bip86",557],[5,"Bip86Public",557],[8,"ValidNetworks",693],[5,"SortedMultiVec",693,1757],[5,"GeneratedKey",693],[5,"PrivateKeyGenerateOptions",693],[5,"SinglePub",693,1721],[5,"SinglePriv",693,1721],[6,"SinglePubKey",693,1721],[6,"DescriptorKey",693],[10,"Debug",1707],[5,"Xpub",1756],[6,"ExtendedKey",693],[5,"Xpriv",1756],[10,"FromStr",1758],[5,"DerivationPath",1756],[17,"Entropy"],[17,"Options"],[17,"Error"],[10,"GeneratableKey",693],[10,"AsMut",1759],[10,"Default",1760],[10,"GeneratableDefaultOptions",693],[10,"CryptoRng",1761],[10,"RngCore",1761],[5,"Assets",1724],[8,"KeySource",1756],[5,"Fingerprint",1756],[5,"DescriptorKeyParseError",1721],[10,"PsbtUtils",994],[5,"Amount",1762],[5,"FeeRate",1763],[5,"Balance",998,1764],[5,"Wallet",998],[5,"SignerOrdering",1408],[10,"TransactionSigner",1408],[5,"Arc",1765],[17,"Item"],[8,"Indexed",1764],[10,"Iterator",1766],[5,"Block",1767],[5,"CannotConnectError",1768],[5,"BlockId",1769],[6,"ApplyHeaderError",1768],[5,"Transaction",1709],[10,"IntoIterator",1770],[5,"Update",998],[10,"Into",1759],[5,"ConfirmationTimeHeightAnchor",1769],[5,"TxGraph",1771],[5,"Txid",1709],[8,"DefaultCoinSelectionAlgorithm",1209],[5,"TxBuilder",1586],[6,"BuildFeeBumpError",1308],[6,"CalculateFeeError",1771],[5,"CheckPointIter",1768],[5,"AddressInfo",998],[5,"Psbt",1772],[5,"SignOptions",1408],[6,"SignerError",1408],[6,"NewError",998],[6,"LoadError",998],[6,"NewOrLoadError",998],[6,"ApplyBlockError",998],[5,"FullScanResult",1773],[5,"SyncResult",1773],[5,"PsbtSighashType",1774],[5,"Input",1774],[6,"CreateTxError",1308],[5,"CanonicalTx",1771],[5,"AlterCheckPointError",1768],[10,"IsDust",998,1775],[5,"CheckPoint",1768],[10,"DoubleEndedIterator",1776],[8,"ChangeSet",998],[5,"LocalChain",1768],[5,"BlockHash",1767],[5,"KeychainTxOutIndex",1777],[5,"FullScanRequest",1773],[5,"SyncRequest",1773],[5,"TxNode",1771],[5,"LargestFirstCoinSelection",1209],[5,"OldestFirstCoinSelection",1209],[5,"BranchAndBoundCoinSelection",1209],[10,"CoinSelectionAlgorithm",1209],[5,"CoinSelectionResult",1209],[6,"Error",1209],[6,"Excess",1209],[6,"MiniscriptPsbtError",1308],[6,"Error",1778],[5,"FullyNodedExport",1385],[6,"SignerId",1408],[6,"SignerContext",1408],[5,"SignerWrapper",1408],[10,"Sized",1779],[6,"TapLeavesOptions",1408],[10,"SignerCommon",1408],[5,"DescriptorXKey",1721],[5,"PrivateKey",1731],[5,"DescriptorMultiXKey",1721],[10,"InputSigner",1408],[5,"PushBytes",1780],[10,"AsRef",1759],[6,"AddForeignUtxoError",1586],[6,"AddUtxoError",1586],[6,"ChangeSpendPolicy",1586],[6,"TxOrdering",1586],[6,"LockTime",1781],[1,"i32"],[15,"Foreign",97],[8,"DerivedDescriptor",100],[15,"PsbtTimelocks",533],[15,"Complete",536],[15,"Partial",536],[15,"PartialComplete",536],[15,"Sha256Preimage",547],[15,"Hash256Preimage",547],[15,"Ripemd160Preimage",547],[15,"Hash160Preimage",547],[15,"Thresh",547],[15,"Multisig",547],[15,"AbsoluteTimelock",547],[15,"RelativeTimelock",547],[10,"ExtScriptContext",693],[15,"UnexpectedConnectedToHash",1201],[15,"LoadedGenesisDoesNotMatch",1203],[15,"LoadedNetworkDoesNotMatch",1203],[15,"LoadedDescriptorDoesNotMatch",1203],[15,"InsufficientFunds",1301],[15,"Change",1303],[15,"NoChange",1303],[15,"RbfSequenceCsv",1379],[15,"LockTime",1379],[15,"FeeTooLow",1379],[15,"FeeRateTooLow",1379],[8,"WalletExport",1385],[15,"Tap",1585],[15,"InvalidTxid",1699],[15,"Custom",1701]],"r":[[2,100],[4,1703],[6,1703],[7,1408],[8,1586],[9,1703],[10,998],[11,1703],[70,998],[71,100],[104,1713],[106,1721],[113,1719],[114,1717],[119,386],[120,1719],[121,1719],[155,352],[696,1721],[697,1721],[712,1713],[722,1719],[727,1721],[728,1721],[729,1721],[730,1757],[1000,1764],[1006,1775]],"b":[[193,"impl-Descriptor%3CDescriptorPublicKey%3E"],[194,"impl-Descriptor%3CDefiniteDescriptorKey%3E"],[213,"impl-Display-for-Descriptor%3CPk%3E"],[214,"impl-Debug-for-Descriptor%3CPk%3E"],[217,"impl-Debug-for-Miniscript%3CPk,+Ctx%3E"],[218,"impl-Display-for-Miniscript%3CPk,+Ctx%3E"],[221,"impl-From%3CPkh%3CPk%3E%3E-for-Descriptor%3CPk%3E"],[222,"impl-From%3CWpkh%3CPk%3E%3E-for-Descriptor%3CPk%3E"],[223,"impl-From%3CTr%3CPk%3E%3E-for-Descriptor%3CPk%3E"],[224,"impl-From%3CSh%3CPk%3E%3E-for-Descriptor%3CPk%3E"],[225,"impl-From%3CBare%3CPk%3E%3E-for-Descriptor%3CPk%3E"],[227,"impl-From%3CWsh%3CPk%3E%3E-for-Descriptor%3CPk%3E"],[370,"impl-Debug-for-Error"],[371,"impl-Display-for-Error"],[372,"impl-From%3CHexToBytesError%3E-for-Error"],[373,"impl-From%3CError%3E-for-Error"],[374,"impl-From%3CPolicyError%3E-for-Error"],[375,"impl-From%3CKeyError%3E-for-Error"],[376,"impl-From%3CError%3E-for-Error"],[377,"impl-From%3CParsePublicKeyError%3E-for-Error"],[378,"impl-From%3CError%3E-for-Error"],[461,"impl-Debug-for-PolicyError"],[462,"impl-Display-for-PolicyError"],[811,"impl-Display-for-KeyError"],[812,"impl-Debug-for-KeyError"],[813,"impl-Display-for-SortedMultiVec%3CPk,+Ctx%3E"],[814,"impl-Debug-for-SortedMultiVec%3CPk,+Ctx%3E"],[815,"impl-Display-for-DescriptorPublicKey"],[816,"impl-Debug-for-DescriptorPublicKey"],[817,"impl-Debug-for-DescriptorSecretKey"],[818,"impl-Display-for-DescriptorSecretKey"],[823,"impl-From%3CXpub%3E-for-ExtendedKey%3CCtx%3E"],[825,"impl-From%3CXpriv%3E-for-ExtendedKey%3CCtx%3E"],[830,"impl-From%3CError%3E-for-KeyError"],[832,"impl-From%3CError%3E-for-KeyError"],[874,"impl-IntoDescriptorKey%3CCtx%3E-for-GeneratedKey%3CK,+Ctx%3E"],[875,"impl-DerivableKey%3CCtx%3E-for-GeneratedKey%3CK,+Ctx%3E"],[1071,"impl-Display-for-Balance"],[1072,"impl-Debug-for-Balance"],[1075,"impl-Debug-for-AddressInfo"],[1076,"impl-Display-for-AddressInfo"],[1077,"impl-Debug-for-NewError"],[1078,"impl-Display-for-NewError"],[1079,"impl-Display-for-LoadError"],[1080,"impl-Debug-for-LoadError"],[1081,"impl-Debug-for-NewOrLoadError"],[1082,"impl-Display-for-NewOrLoadError"],[1083,"impl-Display-for-ApplyBlockError"],[1084,"impl-Debug-for-ApplyBlockError"],[1087,"impl-From%3CFullScanResult%3CKeychainKind%3E%3E-for-Update"],[1088,"impl-From%3CSyncResult%3E-for-Update"],[1250,"impl-Display-for-Error"],[1251,"impl-Debug-for-Error"],[1346,"impl-Display-for-MiniscriptPsbtError"],[1347,"impl-Debug-for-MiniscriptPsbtError"],[1348,"impl-Display-for-CreateTxError"],[1349,"impl-Debug-for-CreateTxError"],[1350,"impl-Debug-for-BuildFeeBumpError"],[1351,"impl-Display-for-BuildFeeBumpError"],[1354,"impl-From%3CError%3E-for-CreateTxError"],[1355,"impl-From%3CError%3E-for-CreateTxError"],[1356,"impl-From%3CPolicyError%3E-for-CreateTxError"],[1357,"impl-From%3CMiniscriptPsbtError%3E-for-CreateTxError"],[1358,"impl-From%3CError%3E-for-CreateTxError"],[1395,"impl-Display-for-FullyNodedExport"],[1396,"impl-Debug-for-FullyNodedExport"],[1488,"impl-SignerCommon-for-SignerWrapper%3CDescriptorXKey%3CXpriv%3E%3E"],[1489,"impl-SignerCommon-for-SignerWrapper%3CPrivateKey%3E"],[1490,"impl-SignerCommon-for-SignerWrapper%3CDescriptorMultiXKey%3CXpriv%3E%3E"],[1497,"impl-Debug-for-SignerError"],[1498,"impl-Display-for-SignerError"],[1505,"impl-From%3CHash%3E-for-SignerId"],[1506,"impl-From%3CFingerprint%3E-for-SignerId"],[1517,"impl-SignerCommon-for-SignerWrapper%3CPrivateKey%3E"],[1518,"impl-SignerCommon-for-SignerWrapper%3CDescriptorMultiXKey%3CXpriv%3E%3E"],[1519,"impl-SignerCommon-for-SignerWrapper%3CDescriptorXKey%3CXpriv%3E%3E"],[1535,"impl-InputSigner-for-SignerWrapper%3CDescriptorMultiXKey%3CXpriv%3E%3E"],[1536,"impl-InputSigner-for-SignerWrapper%3CDescriptorXKey%3CXpriv%3E%3E"],[1537,"impl-InputSigner-for-SignerWrapper%3CPrivateKey%3E"],[1643,"impl-Debug-for-AddUtxoError"],[1644,"impl-Display-for-AddUtxoError"],[1645,"impl-Display-for-AddForeignUtxoError"],[1646,"impl-Debug-for-AddForeignUtxoError"]],"c":"OjAAAAEAAAAAAAUAEAAAAMEAAwEPAR8DeANrBQ==","e":"OzAAAAEAAG0DfAADAAAACAABAAsAAAAOABMAJgAJADUAAQA+AAAAQQAAAEUADwBXAAMAXQADAGoAAAB4AAAAjAABAI8AAACRAAcAnAAAAJ4AAQChAAAApAABAKcAAQCrAAEArgABALEAAQC0AAsAxQADAMoAAwDTAAEA1gAMAOQAAADqAAAA9wADAAIBAAAIAQEADAEBABMBAQApAQMALgEBADwBAQA/AQEAQwEFAE4BBwBXAQMAXAEDAHEBCgB+AQQApgEZAMIBDgDUAQEA2wEBAOoBAADtAQQA8wEiADwCFwBVAgsAeQI8AOQCFwAGAxUAHQMBACADAAAiAxYAOgMAAD8DAABBAwAAQwMAAEsDAQBYAwMAaAMAAGsDBABxAwEAgQMBAIYDAACQAwAAlQMDAJ4DAACiAwgArAMDALMDLwD8AwAABAQAAAYEDwAeBAMAJAQCACoEAgAwBA0AQAQBAHcEAAB/BAcAiwQPAJ0EBwCpBAcAxwQRANoEAgDeBAIA4wQGAPoEGwA7BQ0ASwUEAFQFDwBuBQEAcgUAAHQFAQB3BQAAewUFAKoFDwC7BRQA0QUGANkFCgDsBQAA7gUCAPwFAQAABgIABAYAAAgGBwASBh8ASwYJAFYGBgBfBgEAZgYAAGsGBgB3BgAAgwYAAIkGEwCfBgQA"}],\
["example_bitcoind_rpc_polling",{"t":"PSISSSGPSPFGSPPNNNNHNNNNNNNNNNONNNNNNNNNNNNNNHNOOOHNNNNNNNNNNNNNNNONNNOO","n":["Block","CHANNEL_BOUND","ChangeSet","DB_COMMIT_DELAY","DB_MAGIC","DB_PATH","Emission","Live","MEMPOOL_EMIT_DELAY","Mempool","RpcArgs","RpcCommands","STDOUT_PRINT_DELAY","Sync","Tip","augment_args","augment_args_for_update","augment_subcommands","augment_subcommands_for_update","await_flag","borrow","borrow","borrow","borrow_mut","borrow_mut","borrow_mut","clone","clone","clone_into","clone_into","fallback_height","fmt","fmt","fmt","from","from","from","from_arg_matches","from_arg_matches","from_arg_matches_mut","from_arg_matches_mut","has_subcommand","into","into","into","main","new_client","rpc_cookie","rpc_password","rpc_user","start_ctrlc_handler","to_owned","to_owned","try_from","try_from","try_from","try_into","try_into","try_into","type_id","type_id","type_id","update_from_arg_matches","update_from_arg_matches","update_from_arg_matches_mut","update_from_arg_matches_mut","url","vzip","vzip","vzip","rpc_args","rpc_args"],"q":[[0,"example_bitcoind_rpc_polling"],[70,"example_bitcoind_rpc_polling::RpcCommands"],[72,"clap::builder::command"],[73,"core::sync::atomic"],[74,"core::time"],[75,"core::fmt"],[76,"clap::parser::matches::arg_matches"],[77,"clap::error"],[78,"core::result"],[79,"anyhow"],[80,"bitcoincore_rpc::client"],[81,"alloc::sync"],[82,"core::any"]],"i":[10,0,0,0,0,0,0,8,0,10,0,0,0,8,10,7,7,8,8,0,10,7,8,10,7,8,7,8,7,8,7,10,7,8,10,7,8,7,8,7,8,8,10,7,8,0,7,7,7,7,0,7,8,10,7,8,10,7,8,10,7,8,7,8,7,8,7,10,7,8,21,22],"f":"```````````````{bb}000{{{f{d}}h}j}{{{f{c}}}{{f{e}}}{}{}}00{{{f{lc}}}{{f{le}}}{}{}}00{{{f{n}}}n}{{{f{A`}}}A`}{{{f{c}}{f{le}}}Ab{}{}}0`{{{f{Ad}}{f{lAf}}}Ah}{{{f{n}}{f{lAf}}}Ah}{{{f{A`}}{f{lAf}}}Ah}{cc{}}00{{{f{Aj}}}{{An{nAl}}}}{{{f{Aj}}}{{An{A`Al}}}}{{{f{lAj}}}{{An{nAl}}}}{{{f{lAj}}}{{An{A`Al}}}}{{{f{B`}}}j}{ce{}{}}00{{}{{Bb{Ab}}}}{{{f{n}}}{{Bb{Bd}}}}```{{}{{Bf{d}}}}{{{f{c}}}e{}{}}0{c{{An{e}}}{}{}}00000{{{f{c}}}Bh{}}00{{{f{ln}}{f{Aj}}}{{An{AbAl}}}}{{{f{lA`}}{f{Aj}}}{{An{AbAl}}}}{{{f{ln}}{f{lAj}}}{{An{AbAl}}}}{{{f{lA`}}{f{lAj}}}{{An{AbAl}}}}`:::``","D":"Bb","p":[[8,"Command",72],[5,"AtomicBool",73],[1,"reference"],[5,"Duration",74],[1,"bool"],[0,"mut"],[5,"RpcArgs",0],[6,"RpcCommands",0],[1,"unit"],[6,"Emission",0],[5,"Formatter",75],[8,"Result",75],[5,"ArgMatches",76],[5,"Error",77],[6,"Result",78],[1,"str"],[8,"Result",79],[5,"Client",80],[5,"Arc",81],[5,"TypeId",82],[15,"Sync",70],[15,"Live",70]],"r":[],"b":[],"c":"OjAAAAAAAAA=","e":"OzAAAAEAADcACgAAAAEAAwAAAAUAAgAKAAIADwAPACAAAgAmAAQALgABADMADwBEAAQA"}],\
["example_cli",{"t":"PGFPPPGGFPPFPGIIPPPPPPPIPPPGEONNNNNNNNENNNNNNNNNNNNNNNNOOENNNNNNNNNNNOOHOONONNNNNNNNNNNNNNNNNNNNNNNNNNNNHNNNOOOOHONNNNNNNNNNOONHNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNOOOOOOOOOOO","n":["Address","AddressCmd","Args","Balance","BranchAndBound","ChainSpecific","CoinSelectionAlgo","Commands","CreateTxChange","External","Index","Init","Internal","Keychain","KeychainChangeSet","KeychainTxGraph","LargestFirst","List","List","New","NewestFirst","Next","OldestFirst","PlannedUtxo","Send","SmallestFirst","TxOut","TxOutCmd","anyhow","args","augment_args","augment_args_for_update","augment_subcommands","augment_subcommands","augment_subcommands","augment_subcommands_for_update","augment_subcommands_for_update","augment_subcommands_for_update","bdk_file_store","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","change_descriptor","change_keychain","clap","clone","clone","clone","clone","clone","clone_into","clone_into","clone_into","clone_into","clone_into","cmp","command","cp_limit","create_tx","db","db_path","default","descriptor","deserialize","eq","equivalent","equivalent","fmt","fmt","fmt","fmt","fmt","fmt","fmt","from","from","from","from","from","from","from","from","from_arg_matches","from_arg_matches","from_arg_matches","from_arg_matches","from_arg_matches_mut","from_arg_matches_mut","from_arg_matches_mut","from_arg_matches_mut","from_str","handle_commands","has_subcommand","has_subcommand","has_subcommand","index","index","index","index_changeset","init","init_changeset","into","into","into","into","into","into","into","into","into_app","into_app_for_update","keymap","network","partial_cmp","planned_utxos","serialize","to_owned","to_owned","to_owned","to_owned","to_owned","to_string","to_string","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_into","try_into","try_into","try_into","try_into","try_into","try_into","try_into","type_id","type_id","type_id","type_id","type_id","type_id","type_id","type_id","update_from_arg_matches","update_from_arg_matches","update_from_arg_matches","update_from_arg_matches","update_from_arg_matches_mut","update_from_arg_matches_mut","update_from_arg_matches_mut","update_from_arg_matches_mut","vzip","vzip","vzip","vzip","vzip","vzip","vzip","vzip","change","addr_cmd","address","chain_specific","coin_select","txout_cmd","value","confirmed","spent","unconfirmed","unspent"],"q":[[0,"example_cli"],[176,"example_cli::AddressCmd"],[177,"example_cli::Commands"],[183,"example_cli::TxOutCmd"],[187,"clap::builder::command"],[188,"core::clone"],[189,"clap::derive"],[190,"core::cmp"],[191,"miniscript::descriptor::key"],[192,"alloc::collections::btree::map"],[193,"bitcoin::address"],[194,"bitcoin::blockdata::transaction"],[195,"core::option"],[196,"anyhow"],[197,"bdk_chain::tx_data_traits"],[198,"bdk_chain::chain_oracle"],[199,"core::result"],[200,"serde::de"],[201,"core::fmt"],[202,"clap::parser::matches::arg_matches"],[203,"clap::error"],[204,"std::sync::mutex"],[205,"bdk_file_store::store"],[206,"bitcoin::network"],[207,"core::default"],[208,"serde::ser"],[209,"core::convert"],[210,"core::marker"],[211,"core::ops::function"],[212,"bdk_tmp_plan"],[213,"alloc::vec"],[214,"alloc::string"],[215,"core::any"]],"i":[4,0,0,4,8,4,0,0,0,11,9,0,11,0,0,0,8,9,10,9,8,9,8,0,4,8,4,0,0,52,34,34,4,9,10,4,9,10,0,21,52,34,4,8,9,10,11,21,52,34,4,8,9,10,11,34,21,0,4,8,9,10,11,4,8,9,10,11,11,34,34,0,52,34,8,34,11,11,11,11,4,8,8,9,10,11,11,21,52,34,4,8,9,10,11,34,4,9,10,34,4,9,10,8,0,4,9,10,14,21,52,21,0,52,21,52,34,4,8,9,10,11,34,34,52,34,11,0,11,4,8,9,10,11,8,11,21,52,34,4,8,9,10,11,21,52,34,4,8,9,10,11,21,52,34,4,8,9,10,11,34,4,9,10,34,4,9,10,21,52,34,4,8,9,10,11,60,61,62,62,62,63,62,64,64,64,64],"f":"``````````````````````````````{bb}0000000`{{{d{c}}}{{d{e}}}{}{}}0000000{{{d{fc}}}{{d{fe}}}{}{}}0000000```{{{d{{h{ce}}}}}{{h{ce}}}{jl}{jn}}{{{d{A`}}}A`}{{{d{Ab}}}Ab}{{{d{Ad}}}Ad}{{{d{Af}}}Af}{{{d{c}}{d{fe}}}Ah{}{}}0000{{{d{Af}}{d{Af}}}Aj}``{{{d{f{Al{c}}}}{d{e}}{d{{Bb{AnB`}}}}A`BdBf}{{C`{{Bn{Bh{Bl{Bj}}}}}}}CbCd}``{{}A`}`{c{{Cf{Af}}}Ch}{{{d{Af}}{d{Af}}}Cj}{{{d{c}}{d{e}}}Cj{}{}}0{{{d{{h{ce}}}}{d{fCl}}}Cn{D`l}{D`n}}{{{d{A`}}{d{fCl}}}Cn}0{{{d{Ab}}{d{fCl}}}Cn}{{{d{Ad}}{d{fCl}}}Cn}{{{d{Af}}{d{fCl}}}Cn}0{cc{}}0000000{{{d{Db}}}{{Cf{{Dd{ce}}Df}}}ln}{{{d{Db}}}{{Cf{{h{ce}}Df}}}ln}{{{d{Db}}}{{Cf{AbDf}}}}{{{d{Db}}}{{Cf{AdDf}}}}{{{d{fDb}}}{{Cf{{Dd{ce}}Df}}}ln}{{{d{fDb}}}{{Cf{{h{ce}}Df}}}ln}{{{d{fDb}}}{{Cf{AbDf}}}}{{{d{fDb}}}{{Cf{AdDf}}}}{{{d{Dh}}}{{Cf{A`c}}}{}}{{{d{{Dj{{Al{c}}}}}}{d{{Dj{{Dl{e}}}}}}{d{{Dj{g}}}}{d{{Bb{AnB`}}}}Dnk{h{mi}}}{{C`{Ah}}}Cb{E`EbEdEf{Ej{{Eh{c}}}}ElEnD`}Cdn{{Fb{i{d{Bh}}}{{F`{{C`{Ah}}}}}}}l}{{{d{Dh}}}Cj}00````{{{d{{Ff{Fd}}}}{d{Dh}}}{{C`{{Fh{ceg}}}}}ln{E`EbEfEdD`ElEn}}`{ce{}{}}0000000{{}b}0``{{{d{Af}}{d{Af}}}{{Bl{Aj}}}}{{{d{{Al{c}}}}{d{e}}{d{{Fj{g}}}}}{{Cf{{Fn{{Fl{gc}}}}}}}CbCd{jG`}}{{{d{Af}}c}CfGb}{{{d{c}}}e{}{}}0000{{{d{c}}}Gd{}}0{c{{Cf{e}}}{}{}}000000000000000{{{d{c}}}Gf{}}0000000{{{d{f{Dd{ce}}}}{d{Db}}}{{Cf{AhDf}}}ln}{{{d{f{h{ce}}}}{d{Db}}}{{Cf{AhDf}}}ln}{{{d{fAb}}{d{Db}}}{{Cf{AhDf}}}}{{{d{fAd}}{d{Db}}}{{Cf{AhDf}}}}{{{d{f{Dd{ce}}}}{d{fDb}}}{{Cf{AhDf}}}ln}{{{d{f{h{ce}}}}{d{fDb}}}{{Cf{AhDf}}}ln}{{{d{fAb}}{d{fDb}}}{{Cf{AhDf}}}}{{{d{fAd}}{d{fDb}}}{{Cf{AhDf}}}}{ce{}{}}0000000```````````","D":"E`","p":[[8,"Command",187],[1,"reference"],[0,"mut"],[6,"Commands",0],[10,"Clone",188],[10,"Subcommand",189],[10,"Args",189],[6,"CoinSelectionAlgo",0],[6,"AddressCmd",0],[6,"TxOutCmd",0],[6,"Keychain",0],[1,"unit"],[6,"Ordering",190],[8,"KeychainTxGraph",0],[6,"DescriptorPublicKey",191],[6,"DescriptorSecretKey",191],[5,"BTreeMap",192],[5,"Address",193],[1,"u64"],[5,"Transaction",194],[5,"CreateTxChange",0],[6,"Option",195],[1,"tuple"],[8,"Result",196],[10,"Anchor",197],[10,"ChainOracle",198],[6,"Result",199],[10,"Deserializer",200],[1,"bool"],[5,"Formatter",201],[8,"Result",201],[10,"Debug",201],[5,"ArgMatches",202],[5,"Args",0],[5,"Error",203],[1,"str"],[5,"Mutex",204],[5,"Store",205],[6,"Network",206],[10,"Default",207],[10,"Append",197],[10,"DeserializeOwned",200],[10,"Serialize",208],[8,"KeychainChangeSet",0],[10,"From",209],[10,"Send",210],[10,"Sync",210],[17,"Output"],[10,"FnOnce",211],[1,"u8"],[1,"slice"],[5,"Init",0],[5,"Assets",212],[8,"PlannedUtxo",0],[5,"Vec",213],[10,"CanDerive",212],[10,"Serializer",208],[5,"String",214],[5,"TypeId",215],[15,"List",176],[15,"Address",177],[15,"Send",177],[15,"TxOut",177],[15,"List",183]],"r":[],"b":[[81,"impl-Display-for-CoinSelectionAlgo"],[82,"impl-Debug-for-CoinSelectionAlgo"],[85,"impl-Debug-for-Keychain"],[86,"impl-Display-for-Keychain"]],"c":"OjAAAAAAAAA=","e":"OzAAAAEAAJMAEQAAAAAAAgABAAUABQANAAQAFQAAABcAAQAaAAAAHAABAB8AKQBKAA0AYAAMAG4AAABwAAAAewABAH4AMgCyAAAAtAACAA=="}],\
["example_electrum",{"t":"ISSFGPFPNNNNNNONNNNNNNNNNNNNNONNNNNNNNNNNNNNNNNNNHNNNNNNNNNNNNNNNNNNNNNOOOOOOOOO","n":["ChangeSet","DB_MAGIC","DB_PATH","ElectrumArgs","ElectrumCommands","Scan","ScanOptions","Sync","augment_args","augment_args","augment_args_for_update","augment_args_for_update","augment_subcommands","augment_subcommands_for_update","batch_size","borrow","borrow","borrow","borrow_mut","borrow_mut","borrow_mut","client","clone","clone","clone","clone_into","clone_into","clone_into","electrum_args","electrum_url","eq","fmt","fmt","fmt","from","from","from","from_arg_matches","from_arg_matches","from_arg_matches","from_arg_matches_mut","from_arg_matches_mut","from_arg_matches_mut","has_subcommand","into","into","into","into_app","into_app_for_update","main","to_owned","to_owned","to_owned","try_from","try_from","try_from","try_into","try_into","try_into","type_id","type_id","type_id","update_from_arg_matches","update_from_arg_matches","update_from_arg_matches","update_from_arg_matches_mut","update_from_arg_matches_mut","update_from_arg_matches_mut","vzip","vzip","vzip","all_spks","electrum_args","electrum_args","scan_options","scan_options","stop_gap","unconfirmed","unused_spks","utxos"],"q":[[0,"example_electrum"],[71,"example_electrum::ElectrumCommands"],[80,"clap::builder::command"],[81,"bitcoin::network"],[82,"electrum_client::client"],[83,"anyhow"],[84,"core::fmt"],[85,"clap::parser::matches::arg_matches"],[86,"clap::error"],[87,"core::result"],[88,"core::any"]],"i":[0,0,0,0,0,8,0,8,4,9,4,9,8,8,9,8,4,9,8,4,9,4,8,4,9,8,4,9,8,4,9,8,4,9,8,4,9,8,4,9,8,4,9,8,8,4,9,9,9,0,8,4,9,8,4,9,8,4,9,8,4,9,8,4,9,8,4,9,8,4,9,19,20,19,20,19,20,19,19,19],"f":"````````{bb}00000`{{{d{c}}}{{d{e}}}{}{}}00{{{d{fc}}}{{d{fe}}}{}{}}00{{{d{h}}j}{{n{l}}}}{{{d{A`}}}A`}{{{d{h}}}h}{{{d{Ab}}}Ab}{{{d{c}}{d{fe}}}Ad{}{}}00{{{d{A`}}}h}`{{{d{Ab}}{d{Ab}}}Af}{{{d{A`}}{d{fAh}}}Aj}{{{d{h}}{d{fAh}}}Aj}{{{d{Ab}}{d{fAh}}}Aj}{cc{}}00{{{d{Al}}}{{B`{A`An}}}}{{{d{Al}}}{{B`{hAn}}}}{{{d{Al}}}{{B`{AbAn}}}}{{{d{fAl}}}{{B`{A`An}}}}{{{d{fAl}}}{{B`{hAn}}}}{{{d{fAl}}}{{B`{AbAn}}}}{{{d{Bb}}}Af}{ce{}{}}00{{}b}0{{}{{n{Ad}}}}{{{d{c}}}e{}{}}00{c{{B`{e}}}{}{}}00000{{{d{c}}}Bd{}}00{{{d{fA`}}{d{Al}}}{{B`{AdAn}}}}{{{d{fh}}{d{Al}}}{{B`{AdAn}}}}{{{d{fAb}}{d{Al}}}{{B`{AdAn}}}}{{{d{fA`}}{d{fAl}}}{{B`{AdAn}}}}{{{d{fh}}{d{fAl}}}{{B`{AdAn}}}}{{{d{fAb}}{d{fAl}}}{{B`{AdAn}}}};;;`````````","D":"An","p":[[8,"Command",80],[1,"reference"],[0,"mut"],[5,"ElectrumArgs",0],[6,"Network",81],[5,"Client",82],[8,"Result",83],[6,"ElectrumCommands",0],[5,"ScanOptions",0],[1,"unit"],[1,"bool"],[5,"Formatter",84],[8,"Result",84],[5,"ArgMatches",85],[5,"Error",86],[6,"Result",87],[1,"str"],[5,"TypeId",88],[15,"Sync",71],[15,"Scan",71]],"r":[],"b":[],"c":"OjAAAAAAAAA=","e":"OzAAAAEAAEEACAAAAAUABwAAAAkABQAQAA0AHwADACYABgAwABcASQADAA=="}],\
(function() {var type_impls = {
"bdk_chain":[["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-Append-for-BTreeMap%3CK,+V%3E\" class=\"impl\"><a class=\"src rightside\" href=\"src/bdk_chain/tx_data_traits.rs.html#134-144\">source</a><a href=\"#impl-Append-for-BTreeMap%3CK,+V%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl<K: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html\" title=\"trait core::cmp::Ord\">Ord</a>, V> <a class=\"trait\" href=\"bdk_chain/trait.Append.html\" title=\"trait bdk_chain::Append\">Append</a> for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html\" title=\"struct alloc::collections::btree::map::BTreeMap\">BTreeMap</a><K, V></h3></section></summary><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.append\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"src/bdk_chain/tx_data_traits.rs.html#135-139\">source</a><a href=\"#method.append\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"bdk_chain/trait.Append.html#tymethod.append\" class=\"fn\">append</a>(&mut self, other: Self)</h4></section></summary><div class='docblock'>Append another object of the same type onto <code>self</code>.</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.is_empty\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"src/bdk_chain/tx_data_traits.rs.html#141-143\">source</a><a href=\"#method.is_empty\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"bdk_chain/trait.Append.html#tymethod.is_empty\" class=\"fn\">is_empty</a>(&self) -> <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.bool.html\">bool</a></h4></section></summary><div class='docblock'>Returns whether the structure is considered empty.</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.take\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"src/bdk_chain/tx_data_traits.rs.html#125-131\">source</a><a href=\"#method.take\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"bdk_chain/trait.Append.html#method.take\" class=\"fn\">take</a>(&mut self) -> <a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/core/option/enum.Option.html\" title=\"enum core::option::Option\">Option</a><Self></h4></section></summary><div class='docblock'>Take the value, replacing it with the default value.</div></details></div></details>","Append","bdk_chain::local_chain::ChangeSet"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-BTreeMap%3CK,+V%3E\" class=\"impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/collections/btree/map.rs.html#610\">source</a><a href=\"#impl-BTreeMap%3CK,+V%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl<K, V> <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html\" title=\"struct alloc::collections::btree::map::BTreeMap\">BTreeMap</a><K, V></h3></section></summary><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.new\" class=\"method\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.0.0, const since 1.66.0\">1.0.0 (const: 1.66.0)</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/collections/btree/map.rs.html#629\">source</a></span><h4 class=\"code-header\">pub const fn <a href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html#tymethod.new\" class=\"fn\">new</a>() -> <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html\" title=\"struct alloc::collections::btree::map::BTreeMap\">BTreeMap</a><K, V></h4></section></summary><div class=\"docblock\"><p>Makes a new, empty <code>BTreeMap</code>.</p>\n<p>Does not allocate anything on its own.</p>\n<h5 id=\"examples\"><a class=\"doc-anchor\" href=\"#examples\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::collections::BTreeMap;\n\n<span class=\"kw\">let </span><span class=\"kw-2\">mut </span>map = BTreeMap::new();\n\n<span class=\"comment\">// entries can now be inserted into the empty map\n</span>map.insert(<span class=\"number\">1</span>, <span class=\"string\">\"a\"</span>);</code></pre></div>\n</div></details></div></details>",0,"bdk_chain::local_chain::ChangeSet"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-BTreeMap%3CK,+V,+A%3E\" class=\"impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/collections/btree/map.rs.html#2359\">source</a><a href=\"#impl-BTreeMap%3CK,+V,+A%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl<K, V, A> <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html\" title=\"struct alloc::collections::btree::map::BTreeMap\">BTreeMap</a><K, V, A><div class=\"where\">where\n A: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/alloc/trait.Allocator.html\" title=\"trait core::alloc::Allocator\">Allocator</a> + <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/clone/trait.Clone.html\" title=\"trait core::clone::Clone\">Clone</a>,</div></h3></section></summary><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.iter\" class=\"method\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.0.0\">1.0.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/collections/btree/map.rs.html#2380\">source</a></span><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html#tymethod.iter\" class=\"fn\">iter</a>(&self) -> <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.Iter.html\" title=\"struct alloc::collections::btree::map::Iter\">Iter</a><'_, K, V> <a href=\"#\" class=\"tooltip\" data-notable-ty=\"Iter<'_, K, V>\">ⓘ</a></h4></section></summary><div class=\"docblock\"><p>Gets an iterator over the entries of the map, sorted by key.</p>\n<h5 id=\"examples\"><a class=\"doc-anchor\" href=\"#examples\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::collections::BTreeMap;\n\n<span class=\"kw\">let </span><span class=\"kw-2\">mut </span>map = BTreeMap::new();\nmap.insert(<span class=\"number\">3</span>, <span class=\"string\">\"c\"</span>);\nmap.insert(<span class=\"number\">2</span>, <span class=\"string\">\"b\"</span>);\nmap.insert(<span class=\"number\">1</span>, <span class=\"string\">\"a\"</span>);\n\n<span class=\"kw\">for </span>(key, value) <span class=\"kw\">in </span>map.iter() {\n <span class=\"macro\">println!</span>(<span class=\"string\">\"{key}: {value}\"</span>);\n}\n\n<span class=\"kw\">let </span>(first_key, first_value) = map.iter().next().unwrap();\n<span class=\"macro\">assert_eq!</span>((<span class=\"kw-2\">*</span>first_key, <span class=\"kw-2\">*</span>first_value), (<span class=\"number\">1</span>, <span class=\"string\">\"a\"</span>));</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.iter_mut\" class=\"method\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.0.0\">1.0.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/collections/btree/map.rs.html#2411\">source</a></span><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html#tymethod.iter_mut\" class=\"fn\">iter_mut</a>(&mut self) -> <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.IterMut.html\" title=\"struct alloc::collections::btree::map::IterMut\">IterMut</a><'_, K, V> <a href=\"#\" class=\"tooltip\" data-notable-ty=\"IterMut<'_, K, V>\">ⓘ</a></h4></section></summary><div class=\"docblock\"><p>Gets a mutable iterator over the entries of the map, sorted by key.</p>\n<h5 id=\"examples-1\"><a class=\"doc-anchor\" href=\"#examples-1\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::collections::BTreeMap;\n\n<span class=\"kw\">let </span><span class=\"kw-2\">mut </span>map = BTreeMap::from([\n (<span class=\"string\">\"a\"</span>, <span class=\"number\">1</span>),\n (<span class=\"string\">\"b\"</span>, <span class=\"number\">2</span>),\n (<span class=\"string\">\"c\"</span>, <span class=\"number\">3</span>),\n]);\n\n<span class=\"comment\">// add 10 to the value if the key isn't \"a\"\n</span><span class=\"kw\">for </span>(key, value) <span class=\"kw\">in </span>map.iter_mut() {\n <span class=\"kw\">if </span>key != <span class=\"kw-2\">&</span><span class=\"string\">\"a\" </span>{\n <span class=\"kw-2\">*</span>value += <span class=\"number\">10</span>;\n }\n}</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.keys\" class=\"method\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.0.0\">1.0.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/collections/btree/map.rs.html#2436\">source</a></span><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html#tymethod.keys\" class=\"fn\">keys</a>(&self) -> <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.Keys.html\" title=\"struct alloc::collections::btree::map::Keys\">Keys</a><'_, K, V> <a href=\"#\" class=\"tooltip\" data-notable-ty=\"Keys<'_, K, V>\">ⓘ</a></h4></section></summary><div class=\"docblock\"><p>Gets an iterator over the keys of the map, in sorted order.</p>\n<h5 id=\"examples-2\"><a class=\"doc-anchor\" href=\"#examples-2\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::collections::BTreeMap;\n\n<span class=\"kw\">let </span><span class=\"kw-2\">mut </span>a = BTreeMap::new();\na.insert(<span class=\"number\">2</span>, <span class=\"string\">\"b\"</span>);\na.insert(<span class=\"number\">1</span>, <span class=\"string\">\"a\"</span>);\n\n<span class=\"kw\">let </span>keys: Vec<<span class=\"kw\">_</span>> = a.keys().cloned().collect();\n<span class=\"macro\">assert_eq!</span>(keys, [<span class=\"number\">1</span>, <span class=\"number\">2</span>]);</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.values\" class=\"method\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.0.0\">1.0.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/collections/btree/map.rs.html#2455\">source</a></span><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html#tymethod.values\" class=\"fn\">values</a>(&self) -> <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.Values.html\" title=\"struct alloc::collections::btree::map::Values\">Values</a><'_, K, V> <a href=\"#\" class=\"tooltip\" data-notable-ty=\"Values<'_, K, V>\">ⓘ</a></h4></section></summary><div class=\"docblock\"><p>Gets an iterator over the values of the map, in order by key.</p>\n<h5 id=\"examples-3\"><a class=\"doc-anchor\" href=\"#examples-3\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::collections::BTreeMap;\n\n<span class=\"kw\">let </span><span class=\"kw-2\">mut </span>a = BTreeMap::new();\na.insert(<span class=\"number\">1</span>, <span class=\"string\">\"hello\"</span>);\na.insert(<span class=\"number\">2</span>, <span class=\"string\">\"goodbye\"</span>);\n\n<span class=\"kw\">let </span>values: Vec<<span class=\"kw-2\">&</span>str> = a.values().cloned().collect();\n<span class=\"macro\">assert_eq!</span>(values, [<span class=\"string\">\"hello\"</span>, <span class=\"string\">\"goodbye\"</span>]);</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.values_mut\" class=\"method\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.10.0\">1.10.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/collections/btree/map.rs.html#2479\">source</a></span><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html#tymethod.values_mut\" class=\"fn\">values_mut</a>(&mut self) -> <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.ValuesMut.html\" title=\"struct alloc::collections::btree::map::ValuesMut\">ValuesMut</a><'_, K, V> <a href=\"#\" class=\"tooltip\" data-notable-ty=\"ValuesMut<'_, K, V>\">ⓘ</a></h4></section></summary><div class=\"docblock\"><p>Gets a mutable iterator over the values of the map, in order by key.</p>\n<h5 id=\"examples-4\"><a class=\"doc-anchor\" href=\"#examples-4\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::collections::BTreeMap;\n\n<span class=\"kw\">let </span><span class=\"kw-2\">mut </span>a = BTreeMap::new();\na.insert(<span class=\"number\">1</span>, String::from(<span class=\"string\">\"hello\"</span>));\na.insert(<span class=\"number\">2</span>, String::from(<span class=\"string\">\"goodbye\"</span>));\n\n<span class=\"kw\">for </span>value <span class=\"kw\">in </span>a.values_mut() {\n value.push_str(<span class=\"string\">\"!\"</span>);\n}\n\n<span class=\"kw\">let </span>values: Vec<String> = a.values().cloned().collect();\n<span class=\"macro\">assert_eq!</span>(values, [String::from(<span class=\"string\">\"hello!\"</span>),\n String::from(<span class=\"string\">\"goodbye!\"</span>)]);</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.len\" class=\"method\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.0.0, const unstable\">1.0.0 (const: <a href=\"https://github.com/rust-lang/rust/issues/71835\" title=\"Tracking issue for const_btree_len\">unstable</a>)</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/collections/btree/map.rs.html#2503\">source</a></span><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html#tymethod.len\" class=\"fn\">len</a>(&self) -> <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.usize.html\">usize</a></h4></section></summary><div class=\"docblock\"><p>Returns the number of elements in the map.</p>\n<h5 id=\"examples-5\"><a class=\"doc-anchor\" href=\"#examples-5\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::collections::BTreeMap;\n\n<span class=\"kw\">let </span><span class=\"kw-2\">mut </span>a = BTreeMap::new();\n<span class=\"macro\">assert_eq!</span>(a.len(), <span class=\"number\">0</span>);\na.insert(<span class=\"number\">1</span>, <span class=\"string\">\"a\"</span>);\n<span class=\"macro\">assert_eq!</span>(a.len(), <span class=\"number\">1</span>);</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.is_empty\" class=\"method\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.0.0, const unstable\">1.0.0 (const: <a href=\"https://github.com/rust-lang/rust/issues/71835\" title=\"Tracking issue for const_btree_len\">unstable</a>)</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/collections/btree/map.rs.html#2526\">source</a></span><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html#tymethod.is_empty\" class=\"fn\">is_empty</a>(&self) -> <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.bool.html\">bool</a></h4></section></summary><div class=\"docblock\"><p>Returns <code>true</code> if the map contains no elements.</p>\n<h5 id=\"examples-6\"><a class=\"doc-anchor\" href=\"#examples-6\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::collections::BTreeMap;\n\n<span class=\"kw\">let </span><span class=\"kw-2\">mut </span>a = BTreeMap::new();\n<span class=\"macro\">assert!</span>(a.is_empty());\na.insert(<span class=\"number\">1</span>, <span class=\"string\">\"a\"</span>);\n<span class=\"macro\">assert!</span>(!a.is_empty());</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.lower_bound\" class=\"method\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/collections/btree/map.rs.html#2570-2573\">source</a><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html#tymethod.lower_bound\" class=\"fn\">lower_bound</a><Q>(&self, bound: <a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/core/ops/range/enum.Bound.html\" title=\"enum core::ops::range::Bound\">Bound</a><<a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.reference.html\">&Q</a>>) -> <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.Cursor.html\" title=\"struct alloc::collections::btree::map::Cursor\">Cursor</a><'_, K, V><div class=\"where\">where\n K: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/borrow/trait.Borrow.html\" title=\"trait core::borrow::Borrow\">Borrow</a><Q> + <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html\" title=\"trait core::cmp::Ord\">Ord</a>,\n Q: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html\" title=\"trait core::cmp::Ord\">Ord</a> + ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,</div></h4></section><span class=\"item-info\"><div class=\"stab unstable\"><span class=\"emoji\">🔬</span><span>This is a nightly-only experimental API. (<code>btree_cursors</code>)</span></div></span></summary><div class=\"docblock\"><p>Returns a <a href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.Cursor.html\" title=\"struct alloc::collections::btree::map::Cursor\"><code>Cursor</code></a> pointing at the gap before the smallest key\ngreater than the given bound.</p>\n<p>Passing <code>Bound::Included(x)</code> will return a cursor pointing to the\ngap before the smallest key greater than or equal to <code>x</code>.</p>\n<p>Passing <code>Bound::Excluded(x)</code> will return a cursor pointing to the\ngap before the smallest key greater than <code>x</code>.</p>\n<p>Passing <code>Bound::Unbounded</code> will return a cursor pointing to the\ngap before the smallest key in the map.</p>\n<h5 id=\"examples-7\"><a class=\"doc-anchor\" href=\"#examples-7\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"attr\">#![feature(btree_cursors)]\n\n</span><span class=\"kw\">use </span>std::collections::BTreeMap;\n<span class=\"kw\">use </span>std::ops::Bound;\n\n<span class=\"kw\">let </span>map = BTreeMap::from([\n (<span class=\"number\">1</span>, <span class=\"string\">\"a\"</span>),\n (<span class=\"number\">2</span>, <span class=\"string\">\"b\"</span>),\n (<span class=\"number\">3</span>, <span class=\"string\">\"c\"</span>),\n (<span class=\"number\">4</span>, <span class=\"string\">\"d\"</span>),\n]);\n\n<span class=\"kw\">let </span>cursor = map.lower_bound(Bound::Included(<span class=\"kw-2\">&</span><span class=\"number\">2</span>));\n<span class=\"macro\">assert_eq!</span>(cursor.peek_prev(), <span class=\"prelude-val\">Some</span>((<span class=\"kw-2\">&</span><span class=\"number\">1</span>, <span class=\"kw-2\">&</span><span class=\"string\">\"a\"</span>)));\n<span class=\"macro\">assert_eq!</span>(cursor.peek_next(), <span class=\"prelude-val\">Some</span>((<span class=\"kw-2\">&</span><span class=\"number\">2</span>, <span class=\"kw-2\">&</span><span class=\"string\">\"b\"</span>)));\n\n<span class=\"kw\">let </span>cursor = map.lower_bound(Bound::Excluded(<span class=\"kw-2\">&</span><span class=\"number\">2</span>));\n<span class=\"macro\">assert_eq!</span>(cursor.peek_prev(), <span class=\"prelude-val\">Some</span>((<span class=\"kw-2\">&</span><span class=\"number\">2</span>, <span class=\"kw-2\">&</span><span class=\"string\">\"b\"</span>)));\n<span class=\"macro\">assert_eq!</span>(cursor.peek_next(), <span class=\"prelude-val\">Some</span>((<span class=\"kw-2\">&</span><span class=\"number\">3</span>, <span class=\"kw-2\">&</span><span class=\"string\">\"c\"</span>)));\n\n<span class=\"kw\">let </span>cursor = map.lower_bound(Bound::Unbounded);\n<span class=\"macro\">assert_eq!</span>(cursor.peek_prev(), <span class=\"prelude-val\">None</span>);\n<span class=\"macro\">assert_eq!</span>(cursor.peek_next(), <span class=\"prelude-val\">Some</span>((<span class=\"kw-2\">&</span><span class=\"number\">1</span>, <span class=\"kw-2\">&</span><span class=\"string\">\"a\"</span>)));</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.lower_bound_mut\" class=\"method\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/collections/btree/map.rs.html#2623-2626\">source</a><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html#tymethod.lower_bound_mut\" class=\"fn\">lower_bound_mut</a><Q>(&mut self, bound: <a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/core/ops/range/enum.Bound.html\" title=\"enum core::ops::range::Bound\">Bound</a><<a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.reference.html\">&Q</a>>) -> <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.CursorMut.html\" title=\"struct alloc::collections::btree::map::CursorMut\">CursorMut</a><'_, K, V, A><div class=\"where\">where\n K: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/borrow/trait.Borrow.html\" title=\"trait core::borrow::Borrow\">Borrow</a><Q> + <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html\" title=\"trait core::cmp::Ord\">Ord</a>,\n Q: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html\" title=\"trait core::cmp::Ord\">Ord</a> + ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,</div></h4></section><span class=\"item-info\"><div class=\"stab unstable\"><span class=\"emoji\">🔬</span><span>This is a nightly-only experimental API. (<code>btree_cursors</code>)</span></div></span></summary><div class=\"docblock\"><p>Returns a <a href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.CursorMut.html\" title=\"struct alloc::collections::btree::map::CursorMut\"><code>CursorMut</code></a> pointing at the gap before the smallest key\ngreater than the given bound.</p>\n<p>Passing <code>Bound::Included(x)</code> will return a cursor pointing to the\ngap before the smallest key greater than or equal to <code>x</code>.</p>\n<p>Passing <code>Bound::Excluded(x)</code> will return a cursor pointing to the\ngap before the smallest key greater than <code>x</code>.</p>\n<p>Passing <code>Bound::Unbounded</code> will return a cursor pointing to the\ngap before the smallest key in the map.</p>\n<h5 id=\"examples-8\"><a class=\"doc-anchor\" href=\"#examples-8\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"attr\">#![feature(btree_cursors)]\n\n</span><span class=\"kw\">use </span>std::collections::BTreeMap;\n<span class=\"kw\">use </span>std::ops::Bound;\n\n<span class=\"kw\">let </span><span class=\"kw-2\">mut </span>map = BTreeMap::from([\n (<span class=\"number\">1</span>, <span class=\"string\">\"a\"</span>),\n (<span class=\"number\">2</span>, <span class=\"string\">\"b\"</span>),\n (<span class=\"number\">3</span>, <span class=\"string\">\"c\"</span>),\n (<span class=\"number\">4</span>, <span class=\"string\">\"d\"</span>),\n]);\n\n<span class=\"kw\">let </span><span class=\"kw-2\">mut </span>cursor = map.lower_bound_mut(Bound::Included(<span class=\"kw-2\">&</span><span class=\"number\">2</span>));\n<span class=\"macro\">assert_eq!</span>(cursor.peek_prev(), <span class=\"prelude-val\">Some</span>((<span class=\"kw-2\">&</span><span class=\"number\">1</span>, <span class=\"kw-2\">&mut </span><span class=\"string\">\"a\"</span>)));\n<span class=\"macro\">assert_eq!</span>(cursor.peek_next(), <span class=\"prelude-val\">Some</span>((<span class=\"kw-2\">&</span><span class=\"number\">2</span>, <span class=\"kw-2\">&mut </span><span class=\"string\">\"b\"</span>)));\n\n<span class=\"kw\">let </span><span class=\"kw-2\">mut </span>cursor = map.lower_bound_mut(Bound::Excluded(<span class=\"kw-2\">&</span><span class=\"number\">2</span>));\n<span class=\"macro\">assert_eq!</span>(cursor.peek_prev(), <span class=\"prelude-val\">Some</span>((<span class=\"kw-2\">&</span><span class=\"number\">2</span>, <span class=\"kw-2\">&mut </span><span class=\"string\">\"b\"</span>)));\n<span class=\"macro\">assert_eq!</span>(cursor.peek_next(), <span class=\"prelude-val\">Some</span>((<span class=\"kw-2\">&</span><span class=\"number\">3</span>, <span class=\"kw-2\">&mut </span><span class=\"string\">\"c\"</span>)));\n\n<span class=\"kw\">let </span><span class=\"kw-2\">mut </span>cursor = map.lower_bound_mut(Bound::Unbounded);\n<span class=\"macro\">assert_eq!</span>(cursor.peek_prev(), <span class=\"prelude-val\">None</span>);\n<span class=\"macro\">assert_eq!</span>(cursor.peek_next(), <span class=\"prelude-val\">Some</span>((<span class=\"kw-2\">&</span><span class=\"number\">1</span>, <span class=\"kw-2\">&mut </span><span class=\"string\">\"a\"</span>)));</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.upper_bound\" class=\"method\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/collections/btree/map.rs.html#2693-2696\">source</a><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html#tymethod.upper_bound\" class=\"fn\">upper_bound</a><Q>(&self, bound: <a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/core/ops/range/enum.Bound.html\" title=\"enum core::ops::range::Bound\">Bound</a><<a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.reference.html\">&Q</a>>) -> <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.Cursor.html\" title=\"struct alloc::collections::btree::map::Cursor\">Cursor</a><'_, K, V><div class=\"where\">where\n K: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/borrow/trait.Borrow.html\" title=\"trait core::borrow::Borrow\">Borrow</a><Q> + <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html\" title=\"trait core::cmp::Ord\">Ord</a>,\n Q: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html\" title=\"trait core::cmp::Ord\">Ord</a> + ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,</div></h4></section><span class=\"item-info\"><div class=\"stab unstable\"><span class=\"emoji\">🔬</span><span>This is a nightly-only experimental API. (<code>btree_cursors</code>)</span></div></span></summary><div class=\"docblock\"><p>Returns a <a href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.Cursor.html\" title=\"struct alloc::collections::btree::map::Cursor\"><code>Cursor</code></a> pointing at the gap after the greatest key\nsmaller than the given bound.</p>\n<p>Passing <code>Bound::Included(x)</code> will return a cursor pointing to the\ngap after the greatest key smaller than or equal to <code>x</code>.</p>\n<p>Passing <code>Bound::Excluded(x)</code> will return a cursor pointing to the\ngap after the greatest key smaller than <code>x</code>.</p>\n<p>Passing <code>Bound::Unbounded</code> will return a cursor pointing to the\ngap after the greatest key in the map.</p>\n<h5 id=\"examples-9\"><a class=\"doc-anchor\" href=\"#examples-9\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"attr\">#![feature(btree_cursors)]\n\n</span><span class=\"kw\">use </span>std::collections::BTreeMap;\n<span class=\"kw\">use </span>std::ops::Bound;\n\n<span class=\"kw\">let </span>map = BTreeMap::from([\n (<span class=\"number\">1</span>, <span class=\"string\">\"a\"</span>),\n (<span class=\"number\">2</span>, <span class=\"string\">\"b\"</span>),\n (<span class=\"number\">3</span>, <span class=\"string\">\"c\"</span>),\n (<span class=\"number\">4</span>, <span class=\"string\">\"d\"</span>),\n]);\n\n<span class=\"kw\">let </span>cursor = map.upper_bound(Bound::Included(<span class=\"kw-2\">&</span><span class=\"number\">3</span>));\n<span class=\"macro\">assert_eq!</span>(cursor.peek_prev(), <span class=\"prelude-val\">Some</span>((<span class=\"kw-2\">&</span><span class=\"number\">3</span>, <span class=\"kw-2\">&</span><span class=\"string\">\"c\"</span>)));\n<span class=\"macro\">assert_eq!</span>(cursor.peek_next(), <span class=\"prelude-val\">Some</span>((<span class=\"kw-2\">&</span><span class=\"number\">4</span>, <span class=\"kw-2\">&</span><span class=\"string\">\"d\"</span>)));\n\n<span class=\"kw\">let </span>cursor = map.upper_bound(Bound::Excluded(<span class=\"kw-2\">&</span><span class=\"number\">3</span>));\n<span class=\"macro\">assert_eq!</span>(cursor.peek_prev(), <span class=\"prelude-val\">Some</span>((<span class=\"kw-2\">&</span><span class=\"number\">2</span>, <span class=\"kw-2\">&</span><span class=\"string\">\"b\"</span>)));\n<span class=\"macro\">assert_eq!</span>(cursor.peek_next(), <span class=\"prelude-val\">Some</span>((<span class=\"kw-2\">&</span><span class=\"number\">3</span>, <span class=\"kw-2\">&</span><span class=\"string\">\"c\"</span>)));\n\n<span class=\"kw\">let </span>cursor = map.upper_bound(Bound::Unbounded);\n<span class=\"macro\">assert_eq!</span>(cursor.peek_prev(), <span class=\"prelude-val\">Some</span>((<span class=\"kw-2\">&</span><span class=\"number\">4</span>, <span class=\"kw-2\">&</span><span class=\"string\">\"d\"</span>)));\n<span class=\"macro\">assert_eq!</span>(cursor.peek_next(), <span class=\"prelude-val\">None</span>);</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.upper_bound_mut\" class=\"method\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/collections/btree/map.rs.html#2746-2749\">source</a><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html#tymethod.upper_bound_mut\" class=\"fn\">upper_bound_mut</a><Q>(&mut self, bound: <a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/core/ops/range/enum.Bound.html\" title=\"enum core::ops::range::Bound\">Bound</a><<a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.reference.html\">&Q</a>>) -> <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.CursorMut.html\" title=\"struct alloc::collections::btree::map::CursorMut\">CursorMut</a><'_, K, V, A><div class=\"where\">where\n K: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/borrow/trait.Borrow.html\" title=\"trait core::borrow::Borrow\">Borrow</a><Q> + <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html\" title=\"trait core::cmp::Ord\">Ord</a>,\n Q: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html\" title=\"trait core::cmp::Ord\">Ord</a> + ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,</div></h4></section><span class=\"item-info\"><div class=\"stab unstable\"><span class=\"emoji\">🔬</span><span>This is a nightly-only experimental API. (<code>btree_cursors</code>)</span></div></span></summary><div class=\"docblock\"><p>Returns a <a href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.CursorMut.html\" title=\"struct alloc::collections::btree::map::CursorMut\"><code>CursorMut</code></a> pointing at the gap after the greatest key\nsmaller than the given bound.</p>\n<p>Passing <code>Bound::Included(x)</code> will return a cursor pointing to the\ngap after the greatest key smaller than or equal to <code>x</code>.</p>\n<p>Passing <code>Bound::Excluded(x)</code> will return a cursor pointing to the\ngap after the greatest key smaller than <code>x</code>.</p>\n<p>Passing <code>Bound::Unbounded</code> will return a cursor pointing to the\ngap after the greatest key in the map.</p>\n<h5 id=\"examples-10\"><a class=\"doc-anchor\" href=\"#examples-10\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"attr\">#![feature(btree_cursors)]\n\n</span><span class=\"kw\">use </span>std::collections::BTreeMap;\n<span class=\"kw\">use </span>std::ops::Bound;\n\n<span class=\"kw\">let </span><span class=\"kw-2\">mut </span>map = BTreeMap::from([\n (<span class=\"number\">1</span>, <span class=\"string\">\"a\"</span>),\n (<span class=\"number\">2</span>, <span class=\"string\">\"b\"</span>),\n (<span class=\"number\">3</span>, <span class=\"string\">\"c\"</span>),\n (<span class=\"number\">4</span>, <span class=\"string\">\"d\"</span>),\n]);\n\n<span class=\"kw\">let </span><span class=\"kw-2\">mut </span>cursor = map.upper_bound_mut(Bound::Included(<span class=\"kw-2\">&</span><span class=\"number\">3</span>));\n<span class=\"macro\">assert_eq!</span>(cursor.peek_prev(), <span class=\"prelude-val\">Some</span>((<span class=\"kw-2\">&</span><span class=\"number\">3</span>, <span class=\"kw-2\">&mut </span><span class=\"string\">\"c\"</span>)));\n<span class=\"macro\">assert_eq!</span>(cursor.peek_next(), <span class=\"prelude-val\">Some</span>((<span class=\"kw-2\">&</span><span class=\"number\">4</span>, <span class=\"kw-2\">&mut </span><span class=\"string\">\"d\"</span>)));\n\n<span class=\"kw\">let </span><span class=\"kw-2\">mut </span>cursor = map.upper_bound_mut(Bound::Excluded(<span class=\"kw-2\">&</span><span class=\"number\">3</span>));\n<span class=\"macro\">assert_eq!</span>(cursor.peek_prev(), <span class=\"prelude-val\">Some</span>((<span class=\"kw-2\">&</span><span class=\"number\">2</span>, <span class=\"kw-2\">&mut </span><span class=\"string\">\"b\"</span>)));\n<span class=\"macro\">assert_eq!</span>(cursor.peek_next(), <span class=\"prelude-val\">Some</span>((<span class=\"kw-2\">&</span><span class=\"number\">3</span>, <span class=\"kw-2\">&mut </span><span class=\"string\">\"c\"</span>)));\n\n<span class=\"kw\">let </span><span class=\"kw-2\">mut </span>cursor = map.upper_bound_mut(Bound::Unbounded);\n<span class=\"macro\">assert_eq!</span>(cursor.peek_prev(), <span class=\"prelude-val\">Some</span>((<span class=\"kw-2\">&</span><span class=\"number\">4</span>, <span class=\"kw-2\">&mut </span><span class=\"string\">\"d\"</span>)));\n<span class=\"macro\">assert_eq!</span>(cursor.peek_next(), <span class=\"prelude-val\">None</span>);</code></pre></div>\n</div></details></div></details>",0,"bdk_chain::local_chain::ChangeSet"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-BTreeMap%3CK,+V,+A%3E\" class=\"impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/collections/btree/map.rs.html#634\">source</a><a href=\"#impl-BTreeMap%3CK,+V,+A%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl<K, V, A> <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html\" title=\"struct alloc::collections::btree::map::BTreeMap\">BTreeMap</a><K, V, A><div class=\"where\">where\n A: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/alloc/trait.Allocator.html\" title=\"trait core::alloc::Allocator\">Allocator</a> + <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/clone/trait.Clone.html\" title=\"trait core::clone::Clone\">Clone</a>,</div></h3></section></summary><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.clear\" class=\"method\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.0.0\">1.0.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/collections/btree/map.rs.html#648\">source</a></span><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html#tymethod.clear\" class=\"fn\">clear</a>(&mut self)</h4></section></summary><div class=\"docblock\"><p>Clears the map, removing all elements.</p>\n<h5 id=\"examples\"><a class=\"doc-anchor\" href=\"#examples\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::collections::BTreeMap;\n\n<span class=\"kw\">let </span><span class=\"kw-2\">mut </span>a = BTreeMap::new();\na.insert(<span class=\"number\">1</span>, <span class=\"string\">\"a\"</span>);\na.clear();\n<span class=\"macro\">assert!</span>(a.is_empty());</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.new_in\" class=\"method\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/collections/btree/map.rs.html#674\">source</a><h4 class=\"code-header\">pub const fn <a href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html#tymethod.new_in\" class=\"fn\">new_in</a>(alloc: A) -> <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html\" title=\"struct alloc::collections::btree::map::BTreeMap\">BTreeMap</a><K, V, A></h4></section><span class=\"item-info\"><div class=\"stab unstable\"><span class=\"emoji\">🔬</span><span>This is a nightly-only experimental API. (<code>btreemap_alloc</code>)</span></div></span></summary><div class=\"docblock\"><p>Makes a new empty BTreeMap with a reasonable choice for B.</p>\n<h5 id=\"examples-1\"><a class=\"doc-anchor\" href=\"#examples-1\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::collections::BTreeMap;\n<span class=\"kw\">use </span>std::alloc::Global;\n\n<span class=\"kw\">let </span><span class=\"kw-2\">mut </span>map = BTreeMap::new_in(Global);\n\n<span class=\"comment\">// entries can now be inserted into the empty map\n</span>map.insert(<span class=\"number\">1</span>, <span class=\"string\">\"a\"</span>);</code></pre></div>\n</div></details></div></details>",0,"bdk_chain::local_chain::ChangeSet"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-BTreeMap%3CK,+V,+A%3E\" class=\"impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/collections/btree/map.rs.html#679\">source</a><a href=\"#impl-BTreeMap%3CK,+V,+A%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl<K, V, A> <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html\" title=\"struct alloc::collections::btree::map::BTreeMap\">BTreeMap</a><K, V, A><div class=\"where\">where\n A: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/alloc/trait.Allocator.html\" title=\"trait core::alloc::Allocator\">Allocator</a> + <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/clone/trait.Clone.html\" title=\"trait core::clone::Clone\">Clone</a>,</div></h3></section></summary><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.get\" class=\"method\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.0.0\">1.0.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/collections/btree/map.rs.html#696-699\">source</a></span><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html#tymethod.get\" class=\"fn\">get</a><Q>(&self, key: <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.reference.html\">&Q</a>) -> <a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/core/option/enum.Option.html\" title=\"enum core::option::Option\">Option</a><<a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.reference.html\">&V</a>><div class=\"where\">where\n K: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/borrow/trait.Borrow.html\" title=\"trait core::borrow::Borrow\">Borrow</a><Q> + <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html\" title=\"trait core::cmp::Ord\">Ord</a>,\n Q: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html\" title=\"trait core::cmp::Ord\">Ord</a> + ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,</div></h4></section></summary><div class=\"docblock\"><p>Returns a reference to the value corresponding to the key.</p>\n<p>The key may be any borrowed form of the map’s key type, but the ordering\non the borrowed form <em>must</em> match the ordering on the key type.</p>\n<h5 id=\"examples\"><a class=\"doc-anchor\" href=\"#examples\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::collections::BTreeMap;\n\n<span class=\"kw\">let </span><span class=\"kw-2\">mut </span>map = BTreeMap::new();\nmap.insert(<span class=\"number\">1</span>, <span class=\"string\">\"a\"</span>);\n<span class=\"macro\">assert_eq!</span>(map.get(<span class=\"kw-2\">&</span><span class=\"number\">1</span>), <span class=\"prelude-val\">Some</span>(<span class=\"kw-2\">&</span><span class=\"string\">\"a\"</span>));\n<span class=\"macro\">assert_eq!</span>(map.get(<span class=\"kw-2\">&</span><span class=\"number\">2</span>), <span class=\"prelude-val\">None</span>);</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.get_key_value\" class=\"method\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.40.0\">1.40.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/collections/btree/map.rs.html#724-727\">source</a></span><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html#tymethod.get_key_value\" class=\"fn\">get_key_value</a><Q>(&self, k: <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.reference.html\">&Q</a>) -> <a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/core/option/enum.Option.html\" title=\"enum core::option::Option\">Option</a><(<a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.reference.html\">&K</a>, <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.reference.html\">&V</a>)><div class=\"where\">where\n K: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/borrow/trait.Borrow.html\" title=\"trait core::borrow::Borrow\">Borrow</a><Q> + <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html\" title=\"trait core::cmp::Ord\">Ord</a>,\n Q: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html\" title=\"trait core::cmp::Ord\">Ord</a> + ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,</div></h4></section></summary><div class=\"docblock\"><p>Returns the key-value pair corresponding to the supplied key.</p>\n<p>The supplied key may be any borrowed form of the map’s key type, but the ordering\non the borrowed form <em>must</em> match the ordering on the key type.</p>\n<h5 id=\"examples-1\"><a class=\"doc-anchor\" href=\"#examples-1\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::collections::BTreeMap;\n\n<span class=\"kw\">let </span><span class=\"kw-2\">mut </span>map = BTreeMap::new();\nmap.insert(<span class=\"number\">1</span>, <span class=\"string\">\"a\"</span>);\n<span class=\"macro\">assert_eq!</span>(map.get_key_value(<span class=\"kw-2\">&</span><span class=\"number\">1</span>), <span class=\"prelude-val\">Some</span>((<span class=\"kw-2\">&</span><span class=\"number\">1</span>, <span class=\"kw-2\">&</span><span class=\"string\">\"a\"</span>)));\n<span class=\"macro\">assert_eq!</span>(map.get_key_value(<span class=\"kw-2\">&</span><span class=\"number\">2</span>), <span class=\"prelude-val\">None</span>);</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.first_key_value\" class=\"method\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.66.0\">1.66.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/collections/btree/map.rs.html#751-753\">source</a></span><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html#tymethod.first_key_value\" class=\"fn\">first_key_value</a>(&self) -> <a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/core/option/enum.Option.html\" title=\"enum core::option::Option\">Option</a><(<a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.reference.html\">&K</a>, <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.reference.html\">&V</a>)><div class=\"where\">where\n K: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html\" title=\"trait core::cmp::Ord\">Ord</a>,</div></h4></section></summary><div class=\"docblock\"><p>Returns the first key-value pair in the map.\nThe key in this pair is the minimum key in the map.</p>\n<h5 id=\"examples-2\"><a class=\"doc-anchor\" href=\"#examples-2\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::collections::BTreeMap;\n\n<span class=\"kw\">let </span><span class=\"kw-2\">mut </span>map = BTreeMap::new();\n<span class=\"macro\">assert_eq!</span>(map.first_key_value(), <span class=\"prelude-val\">None</span>);\nmap.insert(<span class=\"number\">1</span>, <span class=\"string\">\"b\"</span>);\nmap.insert(<span class=\"number\">2</span>, <span class=\"string\">\"a\"</span>);\n<span class=\"macro\">assert_eq!</span>(map.first_key_value(), <span class=\"prelude-val\">Some</span>((<span class=\"kw-2\">&</span><span class=\"number\">1</span>, <span class=\"kw-2\">&</span><span class=\"string\">\"b\"</span>)));</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.first_entry\" class=\"method\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.66.0\">1.66.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/collections/btree/map.rs.html#779-781\">source</a></span><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html#tymethod.first_entry\" class=\"fn\">first_entry</a>(&mut self) -> <a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/core/option/enum.Option.html\" title=\"enum core::option::Option\">Option</a><<a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/entry/struct.OccupiedEntry.html\" title=\"struct alloc::collections::btree::map::entry::OccupiedEntry\">OccupiedEntry</a><'_, K, V, A>><div class=\"where\">where\n K: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html\" title=\"trait core::cmp::Ord\">Ord</a>,</div></h4></section></summary><div class=\"docblock\"><p>Returns the first entry in the map for in-place manipulation.\nThe key of this entry is the minimum key in the map.</p>\n<h5 id=\"examples-3\"><a class=\"doc-anchor\" href=\"#examples-3\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::collections::BTreeMap;\n\n<span class=\"kw\">let </span><span class=\"kw-2\">mut </span>map = BTreeMap::new();\nmap.insert(<span class=\"number\">1</span>, <span class=\"string\">\"a\"</span>);\nmap.insert(<span class=\"number\">2</span>, <span class=\"string\">\"b\"</span>);\n<span class=\"kw\">if let </span><span class=\"prelude-val\">Some</span>(<span class=\"kw-2\">mut </span>entry) = map.first_entry() {\n <span class=\"kw\">if </span><span class=\"kw-2\">*</span>entry.key() > <span class=\"number\">0 </span>{\n entry.insert(<span class=\"string\">\"first\"</span>);\n }\n}\n<span class=\"macro\">assert_eq!</span>(<span class=\"kw-2\">*</span>map.get(<span class=\"kw-2\">&</span><span class=\"number\">1</span>).unwrap(), <span class=\"string\">\"first\"</span>);\n<span class=\"macro\">assert_eq!</span>(<span class=\"kw-2\">*</span>map.get(<span class=\"kw-2\">&</span><span class=\"number\">2</span>).unwrap(), <span class=\"string\">\"b\"</span>);</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.pop_first\" class=\"method\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.66.0\">1.66.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/collections/btree/map.rs.html#813-815\">source</a></span><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html#tymethod.pop_first\" class=\"fn\">pop_first</a>(&mut self) -> <a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/core/option/enum.Option.html\" title=\"enum core::option::Option\">Option</a><<a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.tuple.html\">(K, V)</a>><div class=\"where\">where\n K: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html\" title=\"trait core::cmp::Ord\">Ord</a>,</div></h4></section></summary><div class=\"docblock\"><p>Removes and returns the first element in the map.\nThe key of this element is the minimum key that was in the map.</p>\n<h5 id=\"examples-4\"><a class=\"doc-anchor\" href=\"#examples-4\">§</a>Examples</h5>\n<p>Draining elements in ascending order, while keeping a usable map each iteration.</p>\n\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::collections::BTreeMap;\n\n<span class=\"kw\">let </span><span class=\"kw-2\">mut </span>map = BTreeMap::new();\nmap.insert(<span class=\"number\">1</span>, <span class=\"string\">\"a\"</span>);\nmap.insert(<span class=\"number\">2</span>, <span class=\"string\">\"b\"</span>);\n<span class=\"kw\">while let </span><span class=\"prelude-val\">Some</span>((key, _val)) = map.pop_first() {\n <span class=\"macro\">assert!</span>(map.iter().all(|(k, _v)| <span class=\"kw-2\">*</span>k > key));\n}\n<span class=\"macro\">assert!</span>(map.is_empty());</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.last_key_value\" class=\"method\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.66.0\">1.66.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/collections/btree/map.rs.html#834-836\">source</a></span><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html#tymethod.last_key_value\" class=\"fn\">last_key_value</a>(&self) -> <a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/core/option/enum.Option.html\" title=\"enum core::option::Option\">Option</a><(<a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.reference.html\">&K</a>, <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.reference.html\">&V</a>)><div class=\"where\">where\n K: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html\" title=\"trait core::cmp::Ord\">Ord</a>,</div></h4></section></summary><div class=\"docblock\"><p>Returns the last key-value pair in the map.\nThe key in this pair is the maximum key in the map.</p>\n<h5 id=\"examples-5\"><a class=\"doc-anchor\" href=\"#examples-5\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::collections::BTreeMap;\n\n<span class=\"kw\">let </span><span class=\"kw-2\">mut </span>map = BTreeMap::new();\nmap.insert(<span class=\"number\">1</span>, <span class=\"string\">\"b\"</span>);\nmap.insert(<span class=\"number\">2</span>, <span class=\"string\">\"a\"</span>);\n<span class=\"macro\">assert_eq!</span>(map.last_key_value(), <span class=\"prelude-val\">Some</span>((<span class=\"kw-2\">&</span><span class=\"number\">2</span>, <span class=\"kw-2\">&</span><span class=\"string\">\"a\"</span>)));</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.last_entry\" class=\"method\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.66.0\">1.66.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/collections/btree/map.rs.html#862-864\">source</a></span><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html#tymethod.last_entry\" class=\"fn\">last_entry</a>(&mut self) -> <a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/core/option/enum.Option.html\" title=\"enum core::option::Option\">Option</a><<a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/entry/struct.OccupiedEntry.html\" title=\"struct alloc::collections::btree::map::entry::OccupiedEntry\">OccupiedEntry</a><'_, K, V, A>><div class=\"where\">where\n K: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html\" title=\"trait core::cmp::Ord\">Ord</a>,</div></h4></section></summary><div class=\"docblock\"><p>Returns the last entry in the map for in-place manipulation.\nThe key of this entry is the maximum key in the map.</p>\n<h5 id=\"examples-6\"><a class=\"doc-anchor\" href=\"#examples-6\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::collections::BTreeMap;\n\n<span class=\"kw\">let </span><span class=\"kw-2\">mut </span>map = BTreeMap::new();\nmap.insert(<span class=\"number\">1</span>, <span class=\"string\">\"a\"</span>);\nmap.insert(<span class=\"number\">2</span>, <span class=\"string\">\"b\"</span>);\n<span class=\"kw\">if let </span><span class=\"prelude-val\">Some</span>(<span class=\"kw-2\">mut </span>entry) = map.last_entry() {\n <span class=\"kw\">if </span><span class=\"kw-2\">*</span>entry.key() > <span class=\"number\">0 </span>{\n entry.insert(<span class=\"string\">\"last\"</span>);\n }\n}\n<span class=\"macro\">assert_eq!</span>(<span class=\"kw-2\">*</span>map.get(<span class=\"kw-2\">&</span><span class=\"number\">1</span>).unwrap(), <span class=\"string\">\"a\"</span>);\n<span class=\"macro\">assert_eq!</span>(<span class=\"kw-2\">*</span>map.get(<span class=\"kw-2\">&</span><span class=\"number\">2</span>).unwrap(), <span class=\"string\">\"last\"</span>);</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.pop_last\" class=\"method\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.66.0\">1.66.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/collections/btree/map.rs.html#896-898\">source</a></span><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html#tymethod.pop_last\" class=\"fn\">pop_last</a>(&mut self) -> <a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/core/option/enum.Option.html\" title=\"enum core::option::Option\">Option</a><<a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.tuple.html\">(K, V)</a>><div class=\"where\">where\n K: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html\" title=\"trait core::cmp::Ord\">Ord</a>,</div></h4></section></summary><div class=\"docblock\"><p>Removes and returns the last element in the map.\nThe key of this element is the maximum key that was in the map.</p>\n<h5 id=\"examples-7\"><a class=\"doc-anchor\" href=\"#examples-7\">§</a>Examples</h5>\n<p>Draining elements in descending order, while keeping a usable map each iteration.</p>\n\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::collections::BTreeMap;\n\n<span class=\"kw\">let </span><span class=\"kw-2\">mut </span>map = BTreeMap::new();\nmap.insert(<span class=\"number\">1</span>, <span class=\"string\">\"a\"</span>);\nmap.insert(<span class=\"number\">2</span>, <span class=\"string\">\"b\"</span>);\n<span class=\"kw\">while let </span><span class=\"prelude-val\">Some</span>((key, _val)) = map.pop_last() {\n <span class=\"macro\">assert!</span>(map.iter().all(|(k, _v)| <span class=\"kw-2\">*</span>k < key));\n}\n<span class=\"macro\">assert!</span>(map.is_empty());</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.contains_key\" class=\"method\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.0.0\">1.0.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/collections/btree/map.rs.html#919-922\">source</a></span><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html#tymethod.contains_key\" class=\"fn\">contains_key</a><Q>(&self, key: <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.reference.html\">&Q</a>) -> <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.bool.html\">bool</a><div class=\"where\">where\n K: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/borrow/trait.Borrow.html\" title=\"trait core::borrow::Borrow\">Borrow</a><Q> + <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html\" title=\"trait core::cmp::Ord\">Ord</a>,\n Q: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html\" title=\"trait core::cmp::Ord\">Ord</a> + ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,</div></h4></section></summary><div class=\"docblock\"><p>Returns <code>true</code> if the map contains a value for the specified key.</p>\n<p>The key may be any borrowed form of the map’s key type, but the ordering\non the borrowed form <em>must</em> match the ordering on the key type.</p>\n<h5 id=\"examples-8\"><a class=\"doc-anchor\" href=\"#examples-8\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::collections::BTreeMap;\n\n<span class=\"kw\">let </span><span class=\"kw-2\">mut </span>map = BTreeMap::new();\nmap.insert(<span class=\"number\">1</span>, <span class=\"string\">\"a\"</span>);\n<span class=\"macro\">assert_eq!</span>(map.contains_key(<span class=\"kw-2\">&</span><span class=\"number\">1</span>), <span class=\"bool-val\">true</span>);\n<span class=\"macro\">assert_eq!</span>(map.contains_key(<span class=\"kw-2\">&</span><span class=\"number\">2</span>), <span class=\"bool-val\">false</span>);</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.get_mut\" class=\"method\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.0.0\">1.0.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/collections/btree/map.rs.html#946-949\">source</a></span><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html#tymethod.get_mut\" class=\"fn\">get_mut</a><Q>(&mut self, key: <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.reference.html\">&Q</a>) -> <a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/core/option/enum.Option.html\" title=\"enum core::option::Option\">Option</a><<a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.reference.html\">&mut V</a>><div class=\"where\">where\n K: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/borrow/trait.Borrow.html\" title=\"trait core::borrow::Borrow\">Borrow</a><Q> + <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html\" title=\"trait core::cmp::Ord\">Ord</a>,\n Q: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html\" title=\"trait core::cmp::Ord\">Ord</a> + ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,</div></h4></section></summary><div class=\"docblock\"><p>Returns a mutable reference to the value corresponding to the key.</p>\n<p>The key may be any borrowed form of the map’s key type, but the ordering\non the borrowed form <em>must</em> match the ordering on the key type.</p>\n<h5 id=\"examples-9\"><a class=\"doc-anchor\" href=\"#examples-9\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::collections::BTreeMap;\n\n<span class=\"kw\">let </span><span class=\"kw-2\">mut </span>map = BTreeMap::new();\nmap.insert(<span class=\"number\">1</span>, <span class=\"string\">\"a\"</span>);\n<span class=\"kw\">if let </span><span class=\"prelude-val\">Some</span>(x) = map.get_mut(<span class=\"kw-2\">&</span><span class=\"number\">1</span>) {\n <span class=\"kw-2\">*</span>x = <span class=\"string\">\"b\"</span>;\n}\n<span class=\"macro\">assert_eq!</span>(map[<span class=\"kw-2\">&</span><span class=\"number\">1</span>], <span class=\"string\">\"b\"</span>);</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.insert\" class=\"method\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.0.0\">1.0.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/collections/btree/map.rs.html#984-986\">source</a></span><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html#tymethod.insert\" class=\"fn\">insert</a>(&mut self, key: K, value: V) -> <a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/core/option/enum.Option.html\" title=\"enum core::option::Option\">Option</a><V><div class=\"where\">where\n K: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html\" title=\"trait core::cmp::Ord\">Ord</a>,</div></h4></section></summary><div class=\"docblock\"><p>Inserts a key-value pair into the map.</p>\n<p>If the map did not have this key present, <code>None</code> is returned.</p>\n<p>If the map did have this key present, the value is updated, and the old\nvalue is returned. The key is not updated, though; this matters for\ntypes that can be <code>==</code> without being identical. See the <a href=\"index.html#insert-and-complex-keys\">module-level\ndocumentation</a> for more.</p>\n<h5 id=\"examples-10\"><a class=\"doc-anchor\" href=\"#examples-10\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::collections::BTreeMap;\n\n<span class=\"kw\">let </span><span class=\"kw-2\">mut </span>map = BTreeMap::new();\n<span class=\"macro\">assert_eq!</span>(map.insert(<span class=\"number\">37</span>, <span class=\"string\">\"a\"</span>), <span class=\"prelude-val\">None</span>);\n<span class=\"macro\">assert_eq!</span>(map.is_empty(), <span class=\"bool-val\">false</span>);\n\nmap.insert(<span class=\"number\">37</span>, <span class=\"string\">\"b\"</span>);\n<span class=\"macro\">assert_eq!</span>(map.insert(<span class=\"number\">37</span>, <span class=\"string\">\"c\"</span>), <span class=\"prelude-val\">Some</span>(<span class=\"string\">\"b\"</span>));\n<span class=\"macro\">assert_eq!</span>(map[<span class=\"kw-2\">&</span><span class=\"number\">37</span>], <span class=\"string\">\"c\"</span>);</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.try_insert\" class=\"method\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/collections/btree/map.rs.html#1019-1021\">source</a><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html#tymethod.try_insert\" class=\"fn\">try_insert</a>(\n &mut self,\n key: K,\n value: V\n) -> <a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/core/result/enum.Result.html\" title=\"enum core::result::Result\">Result</a><<a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.reference.html\">&mut V</a>, <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/entry/struct.OccupiedError.html\" title=\"struct alloc::collections::btree::map::entry::OccupiedError\">OccupiedError</a><'_, K, V, A>><div class=\"where\">where\n K: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html\" title=\"trait core::cmp::Ord\">Ord</a>,</div></h4></section><span class=\"item-info\"><div class=\"stab unstable\"><span class=\"emoji\">🔬</span><span>This is a nightly-only experimental API. (<code>map_try_insert</code>)</span></div></span></summary><div class=\"docblock\"><p>Tries to insert a key-value pair into the map, and returns\na mutable reference to the value in the entry.</p>\n<p>If the map already had this key present, nothing is updated, and\nan error containing the occupied entry and the value is returned.</p>\n<h5 id=\"examples-11\"><a class=\"doc-anchor\" href=\"#examples-11\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"attr\">#![feature(map_try_insert)]\n\n</span><span class=\"kw\">use </span>std::collections::BTreeMap;\n\n<span class=\"kw\">let </span><span class=\"kw-2\">mut </span>map = BTreeMap::new();\n<span class=\"macro\">assert_eq!</span>(map.try_insert(<span class=\"number\">37</span>, <span class=\"string\">\"a\"</span>).unwrap(), <span class=\"kw-2\">&</span><span class=\"string\">\"a\"</span>);\n\n<span class=\"kw\">let </span>err = map.try_insert(<span class=\"number\">37</span>, <span class=\"string\">\"b\"</span>).unwrap_err();\n<span class=\"macro\">assert_eq!</span>(err.entry.key(), <span class=\"kw-2\">&</span><span class=\"number\">37</span>);\n<span class=\"macro\">assert_eq!</span>(err.entry.get(), <span class=\"kw-2\">&</span><span class=\"string\">\"a\"</span>);\n<span class=\"macro\">assert_eq!</span>(err.value, <span class=\"string\">\"b\"</span>);</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.remove\" class=\"method\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.0.0\">1.0.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/collections/btree/map.rs.html#1047-1050\">source</a></span><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html#tymethod.remove\" class=\"fn\">remove</a><Q>(&mut self, key: <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.reference.html\">&Q</a>) -> <a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/core/option/enum.Option.html\" title=\"enum core::option::Option\">Option</a><V><div class=\"where\">where\n K: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/borrow/trait.Borrow.html\" title=\"trait core::borrow::Borrow\">Borrow</a><Q> + <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html\" title=\"trait core::cmp::Ord\">Ord</a>,\n Q: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html\" title=\"trait core::cmp::Ord\">Ord</a> + ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,</div></h4></section></summary><div class=\"docblock\"><p>Removes a key from the map, returning the value at the key if the key\nwas previously in the map.</p>\n<p>The key may be any borrowed form of the map’s key type, but the ordering\non the borrowed form <em>must</em> match the ordering on the key type.</p>\n<h5 id=\"examples-12\"><a class=\"doc-anchor\" href=\"#examples-12\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::collections::BTreeMap;\n\n<span class=\"kw\">let </span><span class=\"kw-2\">mut </span>map = BTreeMap::new();\nmap.insert(<span class=\"number\">1</span>, <span class=\"string\">\"a\"</span>);\n<span class=\"macro\">assert_eq!</span>(map.remove(<span class=\"kw-2\">&</span><span class=\"number\">1</span>), <span class=\"prelude-val\">Some</span>(<span class=\"string\">\"a\"</span>));\n<span class=\"macro\">assert_eq!</span>(map.remove(<span class=\"kw-2\">&</span><span class=\"number\">1</span>), <span class=\"prelude-val\">None</span>);</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.remove_entry\" class=\"method\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.45.0\">1.45.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/collections/btree/map.rs.html#1072-1075\">source</a></span><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html#tymethod.remove_entry\" class=\"fn\">remove_entry</a><Q>(&mut self, key: <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.reference.html\">&Q</a>) -> <a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/core/option/enum.Option.html\" title=\"enum core::option::Option\">Option</a><<a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.tuple.html\">(K, V)</a>><div class=\"where\">where\n K: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/borrow/trait.Borrow.html\" title=\"trait core::borrow::Borrow\">Borrow</a><Q> + <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html\" title=\"trait core::cmp::Ord\">Ord</a>,\n Q: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html\" title=\"trait core::cmp::Ord\">Ord</a> + ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,</div></h4></section></summary><div class=\"docblock\"><p>Removes a key from the map, returning the stored key and value if the key\nwas previously in the map.</p>\n<p>The key may be any borrowed form of the map’s key type, but the ordering\non the borrowed form <em>must</em> match the ordering on the key type.</p>\n<h5 id=\"examples-13\"><a class=\"doc-anchor\" href=\"#examples-13\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::collections::BTreeMap;\n\n<span class=\"kw\">let </span><span class=\"kw-2\">mut </span>map = BTreeMap::new();\nmap.insert(<span class=\"number\">1</span>, <span class=\"string\">\"a\"</span>);\n<span class=\"macro\">assert_eq!</span>(map.remove_entry(<span class=\"kw-2\">&</span><span class=\"number\">1</span>), <span class=\"prelude-val\">Some</span>((<span class=\"number\">1</span>, <span class=\"string\">\"a\"</span>)));\n<span class=\"macro\">assert_eq!</span>(map.remove_entry(<span class=\"kw-2\">&</span><span class=\"number\">1</span>), <span class=\"prelude-val\">None</span>);</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.retain\" class=\"method\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.53.0\">1.53.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/collections/btree/map.rs.html#1110-1113\">source</a></span><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html#tymethod.retain\" class=\"fn\">retain</a><F>(&mut self, f: F)<div class=\"where\">where\n K: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html\" title=\"trait core::cmp::Ord\">Ord</a>,\n F: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/ops/function/trait.FnMut.html\" title=\"trait core::ops::function::FnMut\">FnMut</a>(<a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.reference.html\">&K</a>, <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.reference.html\">&mut V</a>) -> <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.bool.html\">bool</a>,</div></h4></section></summary><div class=\"docblock\"><p>Retains only the elements specified by the predicate.</p>\n<p>In other words, remove all pairs <code>(k, v)</code> for which <code>f(&k, &mut v)</code> returns <code>false</code>.\nThe elements are visited in ascending key order.</p>\n<h5 id=\"examples-14\"><a class=\"doc-anchor\" href=\"#examples-14\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::collections::BTreeMap;\n\n<span class=\"kw\">let </span><span class=\"kw-2\">mut </span>map: BTreeMap<i32, i32> = (<span class=\"number\">0</span>..<span class=\"number\">8</span>).map(|x| (x, x<span class=\"kw-2\">*</span><span class=\"number\">10</span>)).collect();\n<span class=\"comment\">// Keep only the elements with even-numbered keys.\n</span>map.retain(|<span class=\"kw-2\">&</span>k, <span class=\"kw\">_</span>| k % <span class=\"number\">2 </span>== <span class=\"number\">0</span>);\n<span class=\"macro\">assert!</span>(map.into_iter().eq(<span class=\"macro\">vec!</span>[(<span class=\"number\">0</span>, <span class=\"number\">0</span>), (<span class=\"number\">2</span>, <span class=\"number\">20</span>), (<span class=\"number\">4</span>, <span class=\"number\">40</span>), (<span class=\"number\">6</span>, <span class=\"number\">60</span>)]));</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.append\" class=\"method\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.11.0\">1.11.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/collections/btree/map.rs.html#1150-1153\">source</a></span><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html#tymethod.append\" class=\"fn\">append</a>(&mut self, other: &mut <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html\" title=\"struct alloc::collections::btree::map::BTreeMap\">BTreeMap</a><K, V, A>)<div class=\"where\">where\n K: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html\" title=\"trait core::cmp::Ord\">Ord</a>,\n A: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/clone/trait.Clone.html\" title=\"trait core::clone::Clone\">Clone</a>,</div></h4></section></summary><div class=\"docblock\"><p>Moves all elements from <code>other</code> into <code>self</code>, leaving <code>other</code> empty.</p>\n<p>If a key from <code>other</code> is already present in <code>self</code>, the respective\nvalue from <code>self</code> will be overwritten with the respective value from <code>other</code>.</p>\n<h5 id=\"examples-15\"><a class=\"doc-anchor\" href=\"#examples-15\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::collections::BTreeMap;\n\n<span class=\"kw\">let </span><span class=\"kw-2\">mut </span>a = BTreeMap::new();\na.insert(<span class=\"number\">1</span>, <span class=\"string\">\"a\"</span>);\na.insert(<span class=\"number\">2</span>, <span class=\"string\">\"b\"</span>);\na.insert(<span class=\"number\">3</span>, <span class=\"string\">\"c\"</span>); <span class=\"comment\">// Note: Key (3) also present in b.\n\n</span><span class=\"kw\">let </span><span class=\"kw-2\">mut </span>b = BTreeMap::new();\nb.insert(<span class=\"number\">3</span>, <span class=\"string\">\"d\"</span>); <span class=\"comment\">// Note: Key (3) also present in a.\n</span>b.insert(<span class=\"number\">4</span>, <span class=\"string\">\"e\"</span>);\nb.insert(<span class=\"number\">5</span>, <span class=\"string\">\"f\"</span>);\n\na.append(<span class=\"kw-2\">&mut </span>b);\n\n<span class=\"macro\">assert_eq!</span>(a.len(), <span class=\"number\">5</span>);\n<span class=\"macro\">assert_eq!</span>(b.len(), <span class=\"number\">0</span>);\n\n<span class=\"macro\">assert_eq!</span>(a[<span class=\"kw-2\">&</span><span class=\"number\">1</span>], <span class=\"string\">\"a\"</span>);\n<span class=\"macro\">assert_eq!</span>(a[<span class=\"kw-2\">&</span><span class=\"number\">2</span>], <span class=\"string\">\"b\"</span>);\n<span class=\"macro\">assert_eq!</span>(a[<span class=\"kw-2\">&</span><span class=\"number\">3</span>], <span class=\"string\">\"d\"</span>); <span class=\"comment\">// Note: \"c\" has been overwritten.\n</span><span class=\"macro\">assert_eq!</span>(a[<span class=\"kw-2\">&</span><span class=\"number\">4</span>], <span class=\"string\">\"e\"</span>);\n<span class=\"macro\">assert_eq!</span>(a[<span class=\"kw-2\">&</span><span class=\"number\">5</span>], <span class=\"string\">\"f\"</span>);</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.range\" class=\"method\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.17.0\">1.17.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/collections/btree/map.rs.html#1205-1209\">source</a></span><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html#tymethod.range\" class=\"fn\">range</a><T, R>(&self, range: R) -> <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.Range.html\" title=\"struct alloc::collections::btree::map::Range\">Range</a><'_, K, V> <a href=\"#\" class=\"tooltip\" data-notable-ty=\"Range<'_, K, V>\">ⓘ</a><div class=\"where\">where\n T: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html\" title=\"trait core::cmp::Ord\">Ord</a> + ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,\n K: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/borrow/trait.Borrow.html\" title=\"trait core::borrow::Borrow\">Borrow</a><T> + <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html\" title=\"trait core::cmp::Ord\">Ord</a>,\n R: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/ops/range/trait.RangeBounds.html\" title=\"trait core::ops::range::RangeBounds\">RangeBounds</a><T>,</div></h4></section></summary><div class=\"docblock\"><p>Constructs a double-ended iterator over a sub-range of elements in the map.\nThe simplest way is to use the range syntax <code>min..max</code>, thus <code>range(min..max)</code> will\nyield elements from min (inclusive) to max (exclusive).\nThe range may also be entered as <code>(Bound<T>, Bound<T>)</code>, so for example\n<code>range((Excluded(4), Included(10)))</code> will yield a left-exclusive, right-inclusive\nrange from 4 to 10.</p>\n<h5 id=\"panics\"><a class=\"doc-anchor\" href=\"#panics\">§</a>Panics</h5>\n<p>Panics if range <code>start > end</code>.\nPanics if range <code>start == end</code> and both bounds are <code>Excluded</code>.</p>\n<h5 id=\"examples-16\"><a class=\"doc-anchor\" href=\"#examples-16\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::collections::BTreeMap;\n<span class=\"kw\">use </span>std::ops::Bound::Included;\n\n<span class=\"kw\">let </span><span class=\"kw-2\">mut </span>map = BTreeMap::new();\nmap.insert(<span class=\"number\">3</span>, <span class=\"string\">\"a\"</span>);\nmap.insert(<span class=\"number\">5</span>, <span class=\"string\">\"b\"</span>);\nmap.insert(<span class=\"number\">8</span>, <span class=\"string\">\"c\"</span>);\n<span class=\"kw\">for </span>(<span class=\"kw-2\">&</span>key, <span class=\"kw-2\">&</span>value) <span class=\"kw\">in </span>map.range((Included(<span class=\"kw-2\">&</span><span class=\"number\">4</span>), Included(<span class=\"kw-2\">&</span><span class=\"number\">8</span>))) {\n <span class=\"macro\">println!</span>(<span class=\"string\">\"{key}: {value}\"</span>);\n}\n<span class=\"macro\">assert_eq!</span>(<span class=\"prelude-val\">Some</span>((<span class=\"kw-2\">&</span><span class=\"number\">5</span>, <span class=\"kw-2\">&</span><span class=\"string\">\"b\"</span>)), map.range(<span class=\"number\">4</span>..).next());</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.range_mut\" class=\"method\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.17.0\">1.17.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/collections/btree/map.rs.html#1245-1249\">source</a></span><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html#tymethod.range_mut\" class=\"fn\">range_mut</a><T, R>(&mut self, range: R) -> <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.RangeMut.html\" title=\"struct alloc::collections::btree::map::RangeMut\">RangeMut</a><'_, K, V> <a href=\"#\" class=\"tooltip\" data-notable-ty=\"RangeMut<'_, K, V>\">ⓘ</a><div class=\"where\">where\n T: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html\" title=\"trait core::cmp::Ord\">Ord</a> + ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,\n K: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/borrow/trait.Borrow.html\" title=\"trait core::borrow::Borrow\">Borrow</a><T> + <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html\" title=\"trait core::cmp::Ord\">Ord</a>,\n R: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/ops/range/trait.RangeBounds.html\" title=\"trait core::ops::range::RangeBounds\">RangeBounds</a><T>,</div></h4></section></summary><div class=\"docblock\"><p>Constructs a mutable double-ended iterator over a sub-range of elements in the map.\nThe simplest way is to use the range syntax <code>min..max</code>, thus <code>range(min..max)</code> will\nyield elements from min (inclusive) to max (exclusive).\nThe range may also be entered as <code>(Bound<T>, Bound<T>)</code>, so for example\n<code>range((Excluded(4), Included(10)))</code> will yield a left-exclusive, right-inclusive\nrange from 4 to 10.</p>\n<h5 id=\"panics-1\"><a class=\"doc-anchor\" href=\"#panics-1\">§</a>Panics</h5>\n<p>Panics if range <code>start > end</code>.\nPanics if range <code>start == end</code> and both bounds are <code>Excluded</code>.</p>\n<h5 id=\"examples-17\"><a class=\"doc-anchor\" href=\"#examples-17\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::collections::BTreeMap;\n\n<span class=\"kw\">let </span><span class=\"kw-2\">mut </span>map: BTreeMap<<span class=\"kw-2\">&</span>str, i32> =\n [(<span class=\"string\">\"Alice\"</span>, <span class=\"number\">0</span>), (<span class=\"string\">\"Bob\"</span>, <span class=\"number\">0</span>), (<span class=\"string\">\"Carol\"</span>, <span class=\"number\">0</span>), (<span class=\"string\">\"Cheryl\"</span>, <span class=\"number\">0</span>)].into();\n<span class=\"kw\">for </span>(<span class=\"kw\">_</span>, balance) <span class=\"kw\">in </span>map.range_mut(<span class=\"string\">\"B\"</span>..<span class=\"string\">\"Cheryl\"</span>) {\n <span class=\"kw-2\">*</span>balance += <span class=\"number\">100</span>;\n}\n<span class=\"kw\">for </span>(name, balance) <span class=\"kw\">in </span><span class=\"kw-2\">&</span>map {\n <span class=\"macro\">println!</span>(<span class=\"string\">\"{name} => {balance}\"</span>);\n}</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.entry\" class=\"method\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.0.0\">1.0.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/collections/btree/map.rs.html#1277-1279\">source</a></span><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html#tymethod.entry\" class=\"fn\">entry</a>(&mut self, key: K) -> <a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/entry/enum.Entry.html\" title=\"enum alloc::collections::btree::map::entry::Entry\">Entry</a><'_, K, V, A><div class=\"where\">where\n K: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html\" title=\"trait core::cmp::Ord\">Ord</a>,</div></h4></section></summary><div class=\"docblock\"><p>Gets the given key’s corresponding entry in the map for in-place manipulation.</p>\n<h5 id=\"examples-18\"><a class=\"doc-anchor\" href=\"#examples-18\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::collections::BTreeMap;\n\n<span class=\"kw\">let </span><span class=\"kw-2\">mut </span>count: BTreeMap<<span class=\"kw-2\">&</span>str, usize> = BTreeMap::new();\n\n<span class=\"comment\">// count the number of occurrences of letters in the vec\n</span><span class=\"kw\">for </span>x <span class=\"kw\">in </span>[<span class=\"string\">\"a\"</span>, <span class=\"string\">\"b\"</span>, <span class=\"string\">\"a\"</span>, <span class=\"string\">\"c\"</span>, <span class=\"string\">\"a\"</span>, <span class=\"string\">\"b\"</span>] {\n count.entry(x).and_modify(|curr| <span class=\"kw-2\">*</span>curr += <span class=\"number\">1</span>).or_insert(<span class=\"number\">1</span>);\n}\n\n<span class=\"macro\">assert_eq!</span>(count[<span class=\"string\">\"a\"</span>], <span class=\"number\">3</span>);\n<span class=\"macro\">assert_eq!</span>(count[<span class=\"string\">\"b\"</span>], <span class=\"number\">2</span>);\n<span class=\"macro\">assert_eq!</span>(count[<span class=\"string\">\"c\"</span>], <span class=\"number\">1</span>);</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.split_off\" class=\"method\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.11.0\">1.11.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/collections/btree/map.rs.html#1336-1339\">source</a></span><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html#tymethod.split_off\" class=\"fn\">split_off</a><Q>(&mut self, key: <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.reference.html\">&Q</a>) -> <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html\" title=\"struct alloc::collections::btree::map::BTreeMap\">BTreeMap</a><K, V, A><div class=\"where\">where\n Q: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html\" title=\"trait core::cmp::Ord\">Ord</a> + ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,\n K: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/borrow/trait.Borrow.html\" title=\"trait core::borrow::Borrow\">Borrow</a><Q> + <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html\" title=\"trait core::cmp::Ord\">Ord</a>,\n A: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/clone/trait.Clone.html\" title=\"trait core::clone::Clone\">Clone</a>,</div></h4></section></summary><div class=\"docblock\"><p>Splits the collection into two at the given key. Returns everything after the given key,\nincluding the key.</p>\n<h5 id=\"examples-19\"><a class=\"doc-anchor\" href=\"#examples-19\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::collections::BTreeMap;\n\n<span class=\"kw\">let </span><span class=\"kw-2\">mut </span>a = BTreeMap::new();\na.insert(<span class=\"number\">1</span>, <span class=\"string\">\"a\"</span>);\na.insert(<span class=\"number\">2</span>, <span class=\"string\">\"b\"</span>);\na.insert(<span class=\"number\">3</span>, <span class=\"string\">\"c\"</span>);\na.insert(<span class=\"number\">17</span>, <span class=\"string\">\"d\"</span>);\na.insert(<span class=\"number\">41</span>, <span class=\"string\">\"e\"</span>);\n\n<span class=\"kw\">let </span>b = a.split_off(<span class=\"kw-2\">&</span><span class=\"number\">3</span>);\n\n<span class=\"macro\">assert_eq!</span>(a.len(), <span class=\"number\">2</span>);\n<span class=\"macro\">assert_eq!</span>(b.len(), <span class=\"number\">3</span>);\n\n<span class=\"macro\">assert_eq!</span>(a[<span class=\"kw-2\">&</span><span class=\"number\">1</span>], <span class=\"string\">\"a\"</span>);\n<span class=\"macro\">assert_eq!</span>(a[<span class=\"kw-2\">&</span><span class=\"number\">2</span>], <span class=\"string\">\"b\"</span>);\n\n<span class=\"macro\">assert_eq!</span>(b[<span class=\"kw-2\">&</span><span class=\"number\">3</span>], <span class=\"string\">\"c\"</span>);\n<span class=\"macro\">assert_eq!</span>(b[<span class=\"kw-2\">&</span><span class=\"number\">17</span>], <span class=\"string\">\"d\"</span>);\n<span class=\"macro\">assert_eq!</span>(b[<span class=\"kw-2\">&</span><span class=\"number\">41</span>], <span class=\"string\">\"e\"</span>);</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.extract_if\" class=\"method\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/collections/btree/map.rs.html#1391-1394\">source</a><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html#tymethod.extract_if\" class=\"fn\">extract_if</a><F>(&mut self, pred: F) -> <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.ExtractIf.html\" title=\"struct alloc::collections::btree::map::ExtractIf\">ExtractIf</a><'_, K, V, F, A> <a href=\"#\" class=\"tooltip\" data-notable-ty=\"ExtractIf<'_, K, V, F, A>\">ⓘ</a><div class=\"where\">where\n K: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html\" title=\"trait core::cmp::Ord\">Ord</a>,\n F: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/ops/function/trait.FnMut.html\" title=\"trait core::ops::function::FnMut\">FnMut</a>(<a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.reference.html\">&K</a>, <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.reference.html\">&mut V</a>) -> <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.bool.html\">bool</a>,</div></h4></section><span class=\"item-info\"><div class=\"stab unstable\"><span class=\"emoji\">🔬</span><span>This is a nightly-only experimental API. (<code>btree_extract_if</code>)</span></div></span></summary><div class=\"docblock\"><p>Creates an iterator that visits all elements (key-value pairs) in\nascending key order and uses a closure to determine if an element should\nbe removed. If the closure returns <code>true</code>, the element is removed from\nthe map and yielded. If the closure returns <code>false</code>, or panics, the\nelement remains in the map and will not be yielded.</p>\n<p>The iterator also lets you mutate the value of each element in the\nclosure, regardless of whether you choose to keep or remove it.</p>\n<p>If the returned <code>ExtractIf</code> is not exhausted, e.g. because it is dropped without iterating\nor the iteration short-circuits, then the remaining elements will be retained.\nUse <a href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html#method.retain\" title=\"method alloc::collections::btree::map::BTreeMap::retain\"><code>retain</code></a> with a negated predicate if you do not need the returned iterator.</p>\n<h5 id=\"examples-20\"><a class=\"doc-anchor\" href=\"#examples-20\">§</a>Examples</h5>\n<p>Splitting a map into even and odd keys, reusing the original map:</p>\n\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"attr\">#![feature(btree_extract_if)]\n</span><span class=\"kw\">use </span>std::collections::BTreeMap;\n\n<span class=\"kw\">let </span><span class=\"kw-2\">mut </span>map: BTreeMap<i32, i32> = (<span class=\"number\">0</span>..<span class=\"number\">8</span>).map(|x| (x, x)).collect();\n<span class=\"kw\">let </span>evens: BTreeMap<<span class=\"kw\">_</span>, <span class=\"kw\">_</span>> = map.extract_if(|k, _v| k % <span class=\"number\">2 </span>== <span class=\"number\">0</span>).collect();\n<span class=\"kw\">let </span>odds = map;\n<span class=\"macro\">assert_eq!</span>(evens.keys().copied().collect::<Vec<<span class=\"kw\">_</span>>>(), [<span class=\"number\">0</span>, <span class=\"number\">2</span>, <span class=\"number\">4</span>, <span class=\"number\">6</span>]);\n<span class=\"macro\">assert_eq!</span>(odds.keys().copied().collect::<Vec<<span class=\"kw\">_</span>>>(), [<span class=\"number\">1</span>, <span class=\"number\">3</span>, <span class=\"number\">5</span>, <span class=\"number\">7</span>]);</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.into_keys\" class=\"method\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.54.0\">1.54.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/collections/btree/map.rs.html#1445\">source</a></span><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html#tymethod.into_keys\" class=\"fn\">into_keys</a>(self) -> <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.IntoKeys.html\" title=\"struct alloc::collections::btree::map::IntoKeys\">IntoKeys</a><K, V, A> <a href=\"#\" class=\"tooltip\" data-notable-ty=\"IntoKeys<K, V, A>\">ⓘ</a></h4></section></summary><div class=\"docblock\"><p>Creates a consuming iterator visiting all the keys, in sorted order.\nThe map cannot be used after calling this.\nThe iterator element type is <code>K</code>.</p>\n<h5 id=\"examples-21\"><a class=\"doc-anchor\" href=\"#examples-21\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::collections::BTreeMap;\n\n<span class=\"kw\">let </span><span class=\"kw-2\">mut </span>a = BTreeMap::new();\na.insert(<span class=\"number\">2</span>, <span class=\"string\">\"b\"</span>);\na.insert(<span class=\"number\">1</span>, <span class=\"string\">\"a\"</span>);\n\n<span class=\"kw\">let </span>keys: Vec<i32> = a.into_keys().collect();\n<span class=\"macro\">assert_eq!</span>(keys, [<span class=\"number\">1</span>, <span class=\"number\">2</span>]);</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.into_values\" class=\"method\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.54.0\">1.54.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/collections/btree/map.rs.html#1467\">source</a></span><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html#tymethod.into_values\" class=\"fn\">into_values</a>(self) -> <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.IntoValues.html\" title=\"struct alloc::collections::btree::map::IntoValues\">IntoValues</a><K, V, A> <a href=\"#\" class=\"tooltip\" data-notable-ty=\"IntoValues<K, V, A>\">ⓘ</a></h4></section></summary><div class=\"docblock\"><p>Creates a consuming iterator visiting all the values, in order by key.\nThe map cannot be used after calling this.\nThe iterator element type is <code>V</code>.</p>\n<h5 id=\"examples-22\"><a class=\"doc-anchor\" href=\"#examples-22\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::collections::BTreeMap;\n\n<span class=\"kw\">let </span><span class=\"kw-2\">mut </span>a = BTreeMap::new();\na.insert(<span class=\"number\">1</span>, <span class=\"string\">\"hello\"</span>);\na.insert(<span class=\"number\">2</span>, <span class=\"string\">\"goodbye\"</span>);\n\n<span class=\"kw\">let </span>values: Vec<<span class=\"kw-2\">&</span>str> = a.into_values().collect();\n<span class=\"macro\">assert_eq!</span>(values, [<span class=\"string\">\"hello\"</span>, <span class=\"string\">\"goodbye\"</span>]);</code></pre></div>\n</div></details></div></details>",0,"bdk_chain::local_chain::ChangeSet"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-Clone-for-BTreeMap%3CK,+V,+A%3E\" class=\"impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.0.0\">1.0.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/collections/btree/map.rs.html#207\">source</a></span><a href=\"#impl-Clone-for-BTreeMap%3CK,+V,+A%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl<K, V, A> <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/clone/trait.Clone.html\" title=\"trait core::clone::Clone\">Clone</a> for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html\" title=\"struct alloc::collections::btree::map::BTreeMap\">BTreeMap</a><K, V, A><div class=\"where\">where\n K: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/clone/trait.Clone.html\" title=\"trait core::clone::Clone\">Clone</a>,\n V: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/clone/trait.Clone.html\" title=\"trait core::clone::Clone\">Clone</a>,\n A: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/alloc/trait.Allocator.html\" title=\"trait core::alloc::Allocator\">Allocator</a> + <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/clone/trait.Clone.html\" title=\"trait core::clone::Clone\">Clone</a>,</div></h3></section></summary><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.clone\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/collections/btree/map.rs.html#208\">source</a><a href=\"#method.clone\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/clone/trait.Clone.html#tymethod.clone\" class=\"fn\">clone</a>(&self) -> <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html\" title=\"struct alloc::collections::btree::map::BTreeMap\">BTreeMap</a><K, V, A></h4></section></summary><div class='docblock'>Returns a copy of the value. <a href=\"https://doc.rust-lang.org/nightly/core/clone/trait.Clone.html#tymethod.clone\">Read more</a></div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.clone_from\" class=\"method trait-impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.0.0\">1.0.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/core/clone.rs.html#169\">source</a></span><a href=\"#method.clone_from\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/clone/trait.Clone.html#method.clone_from\" class=\"fn\">clone_from</a>(&mut self, source: <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.reference.html\">&Self</a>)</h4></section></summary><div class='docblock'>Performs copy-assignment from <code>source</code>. <a href=\"https://doc.rust-lang.org/nightly/core/clone/trait.Clone.html#method.clone_from\">Read more</a></div></details></div></details>","Clone","bdk_chain::local_chain::ChangeSet"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-Debug-for-BTreeMap%3CK,+V,+A%3E\" class=\"impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.0.0\">1.0.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/collections/btree/map.rs.html#2312\">source</a></span><a href=\"#impl-Debug-for-BTreeMap%3CK,+V,+A%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl<K, V, A> <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/fmt/trait.Debug.html\" title=\"trait core::fmt::Debug\">Debug</a> for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html\" title=\"struct alloc::collections::btree::map::BTreeMap\">BTreeMap</a><K, V, A><div class=\"where\">where\n K: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/fmt/trait.Debug.html\" title=\"trait core::fmt::Debug\">Debug</a>,\n V: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/fmt/trait.Debug.html\" title=\"trait core::fmt::Debug\">Debug</a>,\n A: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/alloc/trait.Allocator.html\" title=\"trait core::alloc::Allocator\">Allocator</a> + <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/clone/trait.Clone.html\" title=\"trait core::clone::Clone\">Clone</a>,</div></h3></section></summary><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.fmt\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/collections/btree/map.rs.html#2313\">source</a><a href=\"#method.fmt\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/fmt/trait.Debug.html#tymethod.fmt\" class=\"fn\">fmt</a>(&self, f: &mut <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/core/fmt/struct.Formatter.html\" title=\"struct core::fmt::Formatter\">Formatter</a><'_>) -> <a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/core/result/enum.Result.html\" title=\"enum core::result::Result\">Result</a><<a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.unit.html\">()</a>, <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/core/fmt/struct.Error.html\" title=\"struct core::fmt::Error\">Error</a>></h4></section></summary><div class='docblock'>Formats the value using the given formatter. <a href=\"https://doc.rust-lang.org/nightly/core/fmt/trait.Debug.html#tymethod.fmt\">Read more</a></div></details></div></details>","Debug","bdk_chain::local_chain::ChangeSet"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-Default-for-BTreeMap%3CK,+V%3E\" class=\"impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.0.0\">1.0.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/collections/btree/map.rs.html#2278\">source</a></span><a href=\"#impl-Default-for-BTreeMap%3CK,+V%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl<K, V> <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/default/trait.Default.html\" title=\"trait core::default::Default\">Default</a> for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html\" title=\"struct alloc::collections::btree::map::BTreeMap\">BTreeMap</a><K, V></h3></section></summary><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.default\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/collections/btree/map.rs.html#2280\">source</a><a href=\"#method.default\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/default/trait.Default.html#tymethod.default\" class=\"fn\">default</a>() -> <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html\" title=\"struct alloc::collections::btree::map::BTreeMap\">BTreeMap</a><K, V></h4></section></summary><div class=\"docblock\"><p>Creates an empty <code>BTreeMap</code>.</p>\n</div></details></div></details>","Default","bdk_chain::local_chain::ChangeSet"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-Deserialize%3C'de%3E-for-BTreeMap%3CK,+V%3E\" class=\"impl\"><a class=\"src rightside\" href=\"https://docs.rs/serde/1.0.203/src/serde/de/impls.rs.html#1568-1574\">source</a><a href=\"#impl-Deserialize%3C'de%3E-for-BTreeMap%3CK,+V%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl<'de, K, V> <a class=\"trait\" href=\"https://docs.rs/serde/1.0.203/serde/de/trait.Deserialize.html\" title=\"trait serde::de::Deserialize\">Deserialize</a><'de> for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html\" title=\"struct alloc::collections::btree::map::BTreeMap\">BTreeMap</a><K, V><div class=\"where\">where\n K: <a class=\"trait\" href=\"https://docs.rs/serde/1.0.203/serde/de/trait.Deserialize.html\" title=\"trait serde::de::Deserialize\">Deserialize</a><'de> + <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html\" title=\"trait core::cmp::Ord\">Ord</a>,\n V: <a class=\"trait\" href=\"https://docs.rs/serde/1.0.203/serde/de/trait.Deserialize.html\" title=\"trait serde::de::Deserialize\">Deserialize</a><'de>,</div></h3></section></summary><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.deserialize\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://docs.rs/serde/1.0.203/src/serde/de/impls.rs.html#1568-1574\">source</a><a href=\"#method.deserialize\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://docs.rs/serde/1.0.203/serde/de/trait.Deserialize.html#tymethod.deserialize\" class=\"fn\">deserialize</a><D>(\n deserializer: D\n) -> <a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/core/result/enum.Result.html\" title=\"enum core::result::Result\">Result</a><<a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html\" title=\"struct alloc::collections::btree::map::BTreeMap\">BTreeMap</a><K, V>, <D as <a class=\"trait\" href=\"https://docs.rs/serde/1.0.203/serde/de/trait.Deserializer.html\" title=\"trait serde::de::Deserializer\">Deserializer</a><'de>>::<a class=\"associatedtype\" href=\"https://docs.rs/serde/1.0.203/serde/de/trait.Deserializer.html#associatedtype.Error\" title=\"type serde::de::Deserializer::Error\">Error</a>><div class=\"where\">where\n D: <a class=\"trait\" href=\"https://docs.rs/serde/1.0.203/serde/de/trait.Deserializer.html\" title=\"trait serde::de::Deserializer\">Deserializer</a><'de>,</div></h4></section></summary><div class='docblock'>Deserialize this value from the given Serde deserializer. <a href=\"https://docs.rs/serde/1.0.203/serde/de/trait.Deserialize.html#tymethod.deserialize\">Read more</a></div></details></div></details>","Deserialize<'de>","bdk_chain::local_chain::ChangeSet"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-Drop-for-BTreeMap%3CK,+V,+A%3E\" class=\"impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.7.0\">1.7.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/collections/btree/map.rs.html#187\">source</a></span><a href=\"#impl-Drop-for-BTreeMap%3CK,+V,+A%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl<K, V, A> <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/ops/drop/trait.Drop.html\" title=\"trait core::ops::drop::Drop\">Drop</a> for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html\" title=\"struct alloc::collections::btree::map::BTreeMap\">BTreeMap</a><K, V, A><div class=\"where\">where\n A: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/alloc/trait.Allocator.html\" title=\"trait core::alloc::Allocator\">Allocator</a> + <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/clone/trait.Clone.html\" title=\"trait core::clone::Clone\">Clone</a>,</div></h3></section></summary><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.drop\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/collections/btree/map.rs.html#188\">source</a><a href=\"#method.drop\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/ops/drop/trait.Drop.html#tymethod.drop\" class=\"fn\">drop</a>(&mut self)</h4></section></summary><div class='docblock'>Executes the destructor for this type. <a href=\"https://doc.rust-lang.org/nightly/core/ops/drop/trait.Drop.html#tymethod.drop\">Read more</a></div></details></div></details>","Drop","bdk_chain::local_chain::ChangeSet"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-Extend%3C(%26K,+%26V)%3E-for-BTreeMap%3CK,+V,+A%3E\" class=\"impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.2.0\">1.2.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/collections/btree/map.rs.html#2254-2255\">source</a></span><a href=\"#impl-Extend%3C(%26K,+%26V)%3E-for-BTreeMap%3CK,+V,+A%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl<'a, K, V, A> <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/iter/traits/collect/trait.Extend.html\" title=\"trait core::iter::traits::collect::Extend\">Extend</a><(<a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.reference.html\">&'a K</a>, <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.reference.html\">&'a V</a>)> for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html\" title=\"struct alloc::collections::btree::map::BTreeMap\">BTreeMap</a><K, V, A><div class=\"where\">where\n K: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html\" title=\"trait core::cmp::Ord\">Ord</a> + <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Copy.html\" title=\"trait core::marker::Copy\">Copy</a>,\n V: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Copy.html\" title=\"trait core::marker::Copy\">Copy</a>,\n A: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/alloc/trait.Allocator.html\" title=\"trait core::alloc::Allocator\">Allocator</a> + <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/clone/trait.Clone.html\" title=\"trait core::clone::Clone\">Clone</a>,</div></h3></section></summary><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.extend\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/collections/btree/map.rs.html#2257\">source</a><a href=\"#method.extend\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/iter/traits/collect/trait.Extend.html#tymethod.extend\" class=\"fn\">extend</a><I>(&mut self, iter: I)<div class=\"where\">where\n I: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/iter/traits/collect/trait.IntoIterator.html\" title=\"trait core::iter::traits::collect::IntoIterator\">IntoIterator</a><Item = (<a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.reference.html\">&'a K</a>, <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.reference.html\">&'a V</a>)>,</div></h4></section></summary><div class='docblock'>Extends a collection with the contents of an iterator. <a href=\"https://doc.rust-lang.org/nightly/core/iter/traits/collect/trait.Extend.html#tymethod.extend\">Read more</a></div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.extend_one\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/collections/btree/map.rs.html#2262\">source</a><a href=\"#method.extend_one\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/iter/traits/collect/trait.Extend.html#method.extend_one\" class=\"fn\">extend_one</a>(&mut self, _: (<a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.reference.html\">&'a K</a>, <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.reference.html\">&'a V</a>))</h4></section></summary><span class=\"item-info\"><div class=\"stab unstable\"><span class=\"emoji\">🔬</span><span>This is a nightly-only experimental API. (<code>extend_one</code>)</span></div></span><div class='docblock'>Extends a collection with exactly one element.</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.extend_reserve\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/core/iter/traits/collect.rs.html#460\">source</a><a href=\"#method.extend_reserve\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/iter/traits/collect/trait.Extend.html#method.extend_reserve\" class=\"fn\">extend_reserve</a>(&mut self, additional: <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.usize.html\">usize</a>)</h4></section></summary><span class=\"item-info\"><div class=\"stab unstable\"><span class=\"emoji\">🔬</span><span>This is a nightly-only experimental API. (<code>extend_one</code>)</span></div></span><div class='docblock'>Reserves capacity in a collection for the given number of additional elements. <a href=\"https://doc.rust-lang.org/nightly/core/iter/traits/collect/trait.Extend.html#method.extend_reserve\">Read more</a></div></details></div></details>","Extend<(&'a K, &'a V)>","bdk_chain::local_chain::ChangeSet"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-Extend%3C(K,+V)%3E-for-BTreeMap%3CK,+V,+A%3E\" class=\"impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.0.0\">1.0.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/collections/btree/map.rs.html#2239\">source</a></span><a href=\"#impl-Extend%3C(K,+V)%3E-for-BTreeMap%3CK,+V,+A%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl<K, V, A> <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/iter/traits/collect/trait.Extend.html\" title=\"trait core::iter::traits::collect::Extend\">Extend</a><<a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.tuple.html\">(K, V)</a>> for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html\" title=\"struct alloc::collections::btree::map::BTreeMap\">BTreeMap</a><K, V, A><div class=\"where\">where\n K: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html\" title=\"trait core::cmp::Ord\">Ord</a>,\n A: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/alloc/trait.Allocator.html\" title=\"trait core::alloc::Allocator\">Allocator</a> + <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/clone/trait.Clone.html\" title=\"trait core::clone::Clone\">Clone</a>,</div></h3></section></summary><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.extend\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/collections/btree/map.rs.html#2241\">source</a><a href=\"#method.extend\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/iter/traits/collect/trait.Extend.html#tymethod.extend\" class=\"fn\">extend</a><T>(&mut self, iter: T)<div class=\"where\">where\n T: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/iter/traits/collect/trait.IntoIterator.html\" title=\"trait core::iter::traits::collect::IntoIterator\">IntoIterator</a><Item = <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.tuple.html\">(K, V)</a>>,</div></h4></section></summary><div class='docblock'>Extends a collection with the contents of an iterator. <a href=\"https://doc.rust-lang.org/nightly/core/iter/traits/collect/trait.Extend.html#tymethod.extend\">Read more</a></div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.extend_one\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/collections/btree/map.rs.html#2248\">source</a><a href=\"#method.extend_one\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/iter/traits/collect/trait.Extend.html#method.extend_one\" class=\"fn\">extend_one</a>(&mut self, _: <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.tuple.html\">(K, V)</a>)</h4></section></summary><span class=\"item-info\"><div class=\"stab unstable\"><span class=\"emoji\">🔬</span><span>This is a nightly-only experimental API. (<code>extend_one</code>)</span></div></span><div class='docblock'>Extends a collection with exactly one element.</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.extend_reserve\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/core/iter/traits/collect.rs.html#460\">source</a><a href=\"#method.extend_reserve\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/iter/traits/collect/trait.Extend.html#method.extend_reserve\" class=\"fn\">extend_reserve</a>(&mut self, additional: <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.usize.html\">usize</a>)</h4></section></summary><span class=\"item-info\"><div class=\"stab unstable\"><span class=\"emoji\">🔬</span><span>This is a nightly-only experimental API. (<code>extend_one</code>)</span></div></span><div class='docblock'>Reserves capacity in a collection for the given number of additional elements. <a href=\"https://doc.rust-lang.org/nightly/core/iter/traits/collect/trait.Extend.html#method.extend_reserve\">Read more</a></div></details></div></details>","Extend<(K, V)>","bdk_chain::local_chain::ChangeSet"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-From%3C%5B(K,+V);+N%5D%3E-for-BTreeMap%3CK,+V%3E\" class=\"impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.56.0\">1.56.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/collections/btree/map.rs.html#2338\">source</a></span><a href=\"#impl-From%3C%5B(K,+V);+N%5D%3E-for-BTreeMap%3CK,+V%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl<K, V, const N: <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.usize.html\">usize</a>> <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/convert/trait.From.html\" title=\"trait core::convert::From\">From</a><[<a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.tuple.html\">(K, V)</a>; <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.array.html\">N</a>]> for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html\" title=\"struct alloc::collections::btree::map::BTreeMap\">BTreeMap</a><K, V><div class=\"where\">where\n K: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html\" title=\"trait core::cmp::Ord\">Ord</a>,</div></h3></section></summary><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.from\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/collections/btree/map.rs.html#2348\">source</a><a href=\"#method.from\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/convert/trait.From.html#tymethod.from\" class=\"fn\">from</a>(arr: [<a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.tuple.html\">(K, V)</a>; <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.array.html\">N</a>]) -> <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html\" title=\"struct alloc::collections::btree::map::BTreeMap\">BTreeMap</a><K, V></h4></section></summary><div class=\"docblock\"><p>Converts a <code>[(K, V); N]</code> into a <code>BTreeMap<(K, V)></code>.</p>\n\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::collections::BTreeMap;\n\n<span class=\"kw\">let </span>map1 = BTreeMap::from([(<span class=\"number\">1</span>, <span class=\"number\">2</span>), (<span class=\"number\">3</span>, <span class=\"number\">4</span>)]);\n<span class=\"kw\">let </span>map2: BTreeMap<<span class=\"kw\">_</span>, <span class=\"kw\">_</span>> = [(<span class=\"number\">1</span>, <span class=\"number\">2</span>), (<span class=\"number\">3</span>, <span class=\"number\">4</span>)].into();\n<span class=\"macro\">assert_eq!</span>(map1, map2);</code></pre></div>\n</div></details></div></details>","From<[(K, V); N]>","bdk_chain::local_chain::ChangeSet"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-FromIterator%3C(K,+V)%3E-for-BTreeMap%3CK,+V%3E\" class=\"impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.0.0\">1.0.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/collections/btree/map.rs.html#2224\">source</a></span><a href=\"#impl-FromIterator%3C(K,+V)%3E-for-BTreeMap%3CK,+V%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl<K, V> <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/iter/traits/collect/trait.FromIterator.html\" title=\"trait core::iter::traits::collect::FromIterator\">FromIterator</a><<a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.tuple.html\">(K, V)</a>> for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html\" title=\"struct alloc::collections::btree::map::BTreeMap\">BTreeMap</a><K, V><div class=\"where\">where\n K: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html\" title=\"trait core::cmp::Ord\">Ord</a>,</div></h3></section></summary><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.from_iter\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/collections/btree/map.rs.html#2225\">source</a><a href=\"#method.from_iter\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/iter/traits/collect/trait.FromIterator.html#tymethod.from_iter\" class=\"fn\">from_iter</a><T>(iter: T) -> <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html\" title=\"struct alloc::collections::btree::map::BTreeMap\">BTreeMap</a><K, V><div class=\"where\">where\n T: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/iter/traits/collect/trait.IntoIterator.html\" title=\"trait core::iter::traits::collect::IntoIterator\">IntoIterator</a><Item = <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.tuple.html\">(K, V)</a>>,</div></h4></section></summary><div class='docblock'>Creates a value from an iterator. <a href=\"https://doc.rust-lang.org/nightly/core/iter/traits/collect/trait.FromIterator.html#tymethod.from_iter\">Read more</a></div></details></div></details>","FromIterator<(K, V)>","bdk_chain::local_chain::ChangeSet"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-Hash-for-BTreeMap%3CK,+V,+A%3E\" class=\"impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.0.0\">1.0.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/collections/btree/map.rs.html#2268\">source</a></span><a href=\"#impl-Hash-for-BTreeMap%3CK,+V,+A%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl<K, V, A> <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/hash/trait.Hash.html\" title=\"trait core::hash::Hash\">Hash</a> for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html\" title=\"struct alloc::collections::btree::map::BTreeMap\">BTreeMap</a><K, V, A><div class=\"where\">where\n K: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/hash/trait.Hash.html\" title=\"trait core::hash::Hash\">Hash</a>,\n V: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/hash/trait.Hash.html\" title=\"trait core::hash::Hash\">Hash</a>,\n A: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/alloc/trait.Allocator.html\" title=\"trait core::alloc::Allocator\">Allocator</a> + <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/clone/trait.Clone.html\" title=\"trait core::clone::Clone\">Clone</a>,</div></h3></section></summary><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.hash\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/collections/btree/map.rs.html#2269\">source</a><a href=\"#method.hash\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/hash/trait.Hash.html#tymethod.hash\" class=\"fn\">hash</a><H>(&self, state: <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.reference.html\">&mut H</a>)<div class=\"where\">where\n H: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/hash/trait.Hasher.html\" title=\"trait core::hash::Hasher\">Hasher</a>,</div></h4></section></summary><div class='docblock'>Feeds this value into the given <a href=\"https://doc.rust-lang.org/nightly/core/hash/trait.Hasher.html\" title=\"trait core::hash::Hasher\"><code>Hasher</code></a>. <a href=\"https://doc.rust-lang.org/nightly/core/hash/trait.Hash.html#tymethod.hash\">Read more</a></div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.hash_slice\" class=\"method trait-impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.3.0\">1.3.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/core/hash/mod.rs.html#238-240\">source</a></span><a href=\"#method.hash_slice\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/hash/trait.Hash.html#method.hash_slice\" class=\"fn\">hash_slice</a><H>(data: &<a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.slice.html\">[Self]</a>, state: <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.reference.html\">&mut H</a>)<div class=\"where\">where\n H: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/hash/trait.Hasher.html\" title=\"trait core::hash::Hasher\">Hasher</a>,\n Self: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,</div></h4></section></summary><div class='docblock'>Feeds a slice of this type into the given <a href=\"https://doc.rust-lang.org/nightly/core/hash/trait.Hasher.html\" title=\"trait core::hash::Hasher\"><code>Hasher</code></a>. <a href=\"https://doc.rust-lang.org/nightly/core/hash/trait.Hash.html#method.hash_slice\">Read more</a></div></details></div></details>","Hash","bdk_chain::local_chain::ChangeSet"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-Index%3C%26Q%3E-for-BTreeMap%3CK,+V,+A%3E\" class=\"impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.0.0\">1.0.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/collections/btree/map.rs.html#2319-2322\">source</a></span><a href=\"#impl-Index%3C%26Q%3E-for-BTreeMap%3CK,+V,+A%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl<K, Q, V, A> <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/ops/index/trait.Index.html\" title=\"trait core::ops::index::Index\">Index</a><<a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.reference.html\">&Q</a>> for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html\" title=\"struct alloc::collections::btree::map::BTreeMap\">BTreeMap</a><K, V, A><div class=\"where\">where\n A: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/alloc/trait.Allocator.html\" title=\"trait core::alloc::Allocator\">Allocator</a> + <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/clone/trait.Clone.html\" title=\"trait core::clone::Clone\">Clone</a>,\n K: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/borrow/trait.Borrow.html\" title=\"trait core::borrow::Borrow\">Borrow</a><Q> + <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html\" title=\"trait core::cmp::Ord\">Ord</a>,\n Q: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html\" title=\"trait core::cmp::Ord\">Ord</a> + ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,</div></h3></section></summary><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.index\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/collections/btree/map.rs.html#2332\">source</a><a href=\"#method.index\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/ops/index/trait.Index.html#tymethod.index\" class=\"fn\">index</a>(&self, key: <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.reference.html\">&Q</a>) -> <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.reference.html\">&V</a></h4></section></summary><div class=\"docblock\"><p>Returns a reference to the value corresponding to the supplied key.</p>\n<h5 id=\"panics\"><a class=\"doc-anchor\" href=\"#panics\">§</a>Panics</h5>\n<p>Panics if the key is not present in the <code>BTreeMap</code>.</p>\n</div></details><details class=\"toggle\" open><summary><section id=\"associatedtype.Output\" class=\"associatedtype trait-impl\"><a href=\"#associatedtype.Output\" class=\"anchor\">§</a><h4 class=\"code-header\">type <a href=\"https://doc.rust-lang.org/nightly/core/ops/index/trait.Index.html#associatedtype.Output\" class=\"associatedtype\">Output</a> = V</h4></section></summary><div class='docblock'>The returned type after indexing.</div></details></div></details>","Index<&Q>","bdk_chain::local_chain::ChangeSet"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-IntoDeserializer%3C'de,+E%3E-for-BTreeMap%3CK,+V%3E\" class=\"impl\"><a class=\"src rightside\" href=\"https://docs.rs/serde/1.0.203/src/serde/de/value.rs.html#1425-1429\">source</a><a href=\"#impl-IntoDeserializer%3C'de,+E%3E-for-BTreeMap%3CK,+V%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl<'de, K, V, E> <a class=\"trait\" href=\"https://docs.rs/serde/1.0.203/serde/de/trait.IntoDeserializer.html\" title=\"trait serde::de::IntoDeserializer\">IntoDeserializer</a><'de, E> for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html\" title=\"struct alloc::collections::btree::map::BTreeMap\">BTreeMap</a><K, V><div class=\"where\">where\n K: <a class=\"trait\" href=\"https://docs.rs/serde/1.0.203/serde/de/trait.IntoDeserializer.html\" title=\"trait serde::de::IntoDeserializer\">IntoDeserializer</a><'de, E> + <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Eq.html\" title=\"trait core::cmp::Eq\">Eq</a> + <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html\" title=\"trait core::cmp::Ord\">Ord</a>,\n V: <a class=\"trait\" href=\"https://docs.rs/serde/1.0.203/serde/de/trait.IntoDeserializer.html\" title=\"trait serde::de::IntoDeserializer\">IntoDeserializer</a><'de, E>,\n E: <a class=\"trait\" href=\"https://docs.rs/serde/1.0.203/serde/de/trait.Error.html\" title=\"trait serde::de::Error\">Error</a>,</div></h3></section></summary><div class=\"impl-items\"><details class=\"toggle\" open><summary><section id=\"associatedtype.Deserializer\" class=\"associatedtype trait-impl\"><a href=\"#associatedtype.Deserializer\" class=\"anchor\">§</a><h4 class=\"code-header\">type <a href=\"https://docs.rs/serde/1.0.203/serde/de/trait.IntoDeserializer.html#associatedtype.Deserializer\" class=\"associatedtype\">Deserializer</a> = <a class=\"struct\" href=\"https://docs.rs/serde/1.0.203/serde/de/value/struct.MapDeserializer.html\" title=\"struct serde::de::value::MapDeserializer\">MapDeserializer</a><'de, <<a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html\" title=\"struct alloc::collections::btree::map::BTreeMap\">BTreeMap</a><K, V> as <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/iter/traits/collect/trait.IntoIterator.html\" title=\"trait core::iter::traits::collect::IntoIterator\">IntoIterator</a>>::<a class=\"associatedtype\" href=\"https://doc.rust-lang.org/nightly/core/iter/traits/collect/trait.IntoIterator.html#associatedtype.IntoIter\" title=\"type core::iter::traits::collect::IntoIterator::IntoIter\">IntoIter</a>, E></h4></section></summary><div class='docblock'>The type of the deserializer being converted into.</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.into_deserializer\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://docs.rs/serde/1.0.203/src/serde/de/value.rs.html#1433\">source</a><a href=\"#method.into_deserializer\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://docs.rs/serde/1.0.203/serde/de/trait.IntoDeserializer.html#tymethod.into_deserializer\" class=\"fn\">into_deserializer</a>(\n self\n) -> <<a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html\" title=\"struct alloc::collections::btree::map::BTreeMap\">BTreeMap</a><K, V> as <a class=\"trait\" href=\"https://docs.rs/serde/1.0.203/serde/de/trait.IntoDeserializer.html\" title=\"trait serde::de::IntoDeserializer\">IntoDeserializer</a><'de, E>>::<a class=\"associatedtype\" href=\"https://docs.rs/serde/1.0.203/serde/de/trait.IntoDeserializer.html#associatedtype.Deserializer\" title=\"type serde::de::IntoDeserializer::Deserializer\">Deserializer</a></h4></section></summary><div class='docblock'>Convert this value into a deserializer.</div></details></div></details>","IntoDeserializer<'de, E>","bdk_chain::local_chain::ChangeSet"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-IntoIterator-for-BTreeMap%3CK,+V,+A%3E\" class=\"impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.0.0\">1.0.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/collections/btree/map.rs.html#1636\">source</a></span><a href=\"#impl-IntoIterator-for-BTreeMap%3CK,+V,+A%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl<K, V, A> <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/iter/traits/collect/trait.IntoIterator.html\" title=\"trait core::iter::traits::collect::IntoIterator\">IntoIterator</a> for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html\" title=\"struct alloc::collections::btree::map::BTreeMap\">BTreeMap</a><K, V, A><div class=\"where\">where\n A: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/alloc/trait.Allocator.html\" title=\"trait core::alloc::Allocator\">Allocator</a> + <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/clone/trait.Clone.html\" title=\"trait core::clone::Clone\">Clone</a>,</div></h3></section></summary><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.into_iter\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/collections/btree/map.rs.html#1641\">source</a><a href=\"#method.into_iter\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/iter/traits/collect/trait.IntoIterator.html#tymethod.into_iter\" class=\"fn\">into_iter</a>(self) -> <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.IntoIter.html\" title=\"struct alloc::collections::btree::map::IntoIter\">IntoIter</a><K, V, A> <a href=\"#\" class=\"tooltip\" data-notable-ty=\"IntoIter<K, V, A>\">ⓘ</a></h4></section></summary><div class=\"docblock\"><p>Gets an owning iterator over the entries of the map, sorted by key.</p>\n</div></details><details class=\"toggle\" open><summary><section id=\"associatedtype.Item\" class=\"associatedtype trait-impl\"><a href=\"#associatedtype.Item\" class=\"anchor\">§</a><h4 class=\"code-header\">type <a href=\"https://doc.rust-lang.org/nightly/core/iter/traits/collect/trait.IntoIterator.html#associatedtype.Item\" class=\"associatedtype\">Item</a> = <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.tuple.html\">(K, V)</a></h4></section></summary><div class='docblock'>The type of the elements being iterated over.</div></details><details class=\"toggle\" open><summary><section id=\"associatedtype.IntoIter\" class=\"associatedtype trait-impl\"><a href=\"#associatedtype.IntoIter\" class=\"anchor\">§</a><h4 class=\"code-header\">type <a href=\"https://doc.rust-lang.org/nightly/core/iter/traits/collect/trait.IntoIterator.html#associatedtype.IntoIter\" class=\"associatedtype\">IntoIter</a> = <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.IntoIter.html\" title=\"struct alloc::collections::btree::map::IntoIter\">IntoIter</a><K, V, A></h4></section></summary><div class='docblock'>Which kind of iterator are we turning this into?</div></details></div></details>","IntoIterator","bdk_chain::local_chain::ChangeSet"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-Ord-for-BTreeMap%3CK,+V,+A%3E\" class=\"impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.0.0\">1.0.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/collections/btree/map.rs.html#2304\">source</a></span><a href=\"#impl-Ord-for-BTreeMap%3CK,+V,+A%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl<K, V, A> <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html\" title=\"trait core::cmp::Ord\">Ord</a> for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html\" title=\"struct alloc::collections::btree::map::BTreeMap\">BTreeMap</a><K, V, A><div class=\"where\">where\n K: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html\" title=\"trait core::cmp::Ord\">Ord</a>,\n V: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html\" title=\"trait core::cmp::Ord\">Ord</a>,\n A: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/alloc/trait.Allocator.html\" title=\"trait core::alloc::Allocator\">Allocator</a> + <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/clone/trait.Clone.html\" title=\"trait core::clone::Clone\">Clone</a>,</div></h3></section></summary><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.cmp\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/collections/btree/map.rs.html#2306\">source</a><a href=\"#method.cmp\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html#tymethod.cmp\" class=\"fn\">cmp</a>(&self, other: &<a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html\" title=\"struct alloc::collections::btree::map::BTreeMap\">BTreeMap</a><K, V, A>) -> <a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/core/cmp/enum.Ordering.html\" title=\"enum core::cmp::Ordering\">Ordering</a></h4></section></summary><div class='docblock'>This method returns an <a href=\"https://doc.rust-lang.org/nightly/core/cmp/enum.Ordering.html\" title=\"enum core::cmp::Ordering\"><code>Ordering</code></a> between <code>self</code> and <code>other</code>. <a href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html#tymethod.cmp\">Read more</a></div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.max\" class=\"method trait-impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.21.0\">1.21.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/core/cmp.rs.html#856-858\">source</a></span><a href=\"#method.max\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html#method.max\" class=\"fn\">max</a>(self, other: Self) -> Self<div class=\"where\">where\n Self: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,</div></h4></section></summary><div class='docblock'>Compares and returns the maximum of two values. <a href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html#method.max\">Read more</a></div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.min\" class=\"method trait-impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.21.0\">1.21.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/core/cmp.rs.html#877-879\">source</a></span><a href=\"#method.min\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html#method.min\" class=\"fn\">min</a>(self, other: Self) -> Self<div class=\"where\">where\n Self: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,</div></h4></section></summary><div class='docblock'>Compares and returns the minimum of two values. <a href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html#method.min\">Read more</a></div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.clamp\" class=\"method trait-impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.50.0\">1.50.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/core/cmp.rs.html#902-905\">source</a></span><a href=\"#method.clamp\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html#method.clamp\" class=\"fn\">clamp</a>(self, min: Self, max: Self) -> Self<div class=\"where\">where\n Self: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a> + <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.PartialOrd.html\" title=\"trait core::cmp::PartialOrd\">PartialOrd</a>,</div></h4></section></summary><div class='docblock'>Restrict a value to a certain interval. <a href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html#method.clamp\">Read more</a></div></details></div></details>","Ord","bdk_chain::local_chain::ChangeSet"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-PartialEq-for-BTreeMap%3CK,+V,+A%3E\" class=\"impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.0.0\">1.0.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/collections/btree/map.rs.html#2286\">source</a></span><a href=\"#impl-PartialEq-for-BTreeMap%3CK,+V,+A%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl<K, V, A> <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.PartialEq.html\" title=\"trait core::cmp::PartialEq\">PartialEq</a> for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html\" title=\"struct alloc::collections::btree::map::BTreeMap\">BTreeMap</a><K, V, A><div class=\"where\">where\n K: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.PartialEq.html\" title=\"trait core::cmp::PartialEq\">PartialEq</a>,\n V: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.PartialEq.html\" title=\"trait core::cmp::PartialEq\">PartialEq</a>,\n A: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/alloc/trait.Allocator.html\" title=\"trait core::alloc::Allocator\">Allocator</a> + <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/clone/trait.Clone.html\" title=\"trait core::clone::Clone\">Clone</a>,</div></h3></section></summary><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.eq\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/collections/btree/map.rs.html#2287\">source</a><a href=\"#method.eq\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.PartialEq.html#tymethod.eq\" class=\"fn\">eq</a>(&self, other: &<a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html\" title=\"struct alloc::collections::btree::map::BTreeMap\">BTreeMap</a><K, V, A>) -> <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.bool.html\">bool</a></h4></section></summary><div class='docblock'>This method tests for <code>self</code> and <code>other</code> values to be equal, and is used\nby <code>==</code>.</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.ne\" class=\"method trait-impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.0.0\">1.0.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/core/cmp.rs.html#263\">source</a></span><a href=\"#method.ne\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.PartialEq.html#method.ne\" class=\"fn\">ne</a>(&self, other: <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.reference.html\">&Rhs</a>) -> <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.bool.html\">bool</a></h4></section></summary><div class='docblock'>This method tests for <code>!=</code>. The default implementation is almost always\nsufficient, and should not be overridden without very good reason.</div></details></div></details>","PartialEq","bdk_chain::local_chain::ChangeSet"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-PartialOrd-for-BTreeMap%3CK,+V,+A%3E\" class=\"impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.0.0\">1.0.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/collections/btree/map.rs.html#2296\">source</a></span><a href=\"#impl-PartialOrd-for-BTreeMap%3CK,+V,+A%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl<K, V, A> <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.PartialOrd.html\" title=\"trait core::cmp::PartialOrd\">PartialOrd</a> for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html\" title=\"struct alloc::collections::btree::map::BTreeMap\">BTreeMap</a><K, V, A><div class=\"where\">where\n K: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.PartialOrd.html\" title=\"trait core::cmp::PartialOrd\">PartialOrd</a>,\n V: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.PartialOrd.html\" title=\"trait core::cmp::PartialOrd\">PartialOrd</a>,\n A: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/alloc/trait.Allocator.html\" title=\"trait core::alloc::Allocator\">Allocator</a> + <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/clone/trait.Clone.html\" title=\"trait core::clone::Clone\">Clone</a>,</div></h3></section></summary><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.partial_cmp\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/collections/btree/map.rs.html#2298\">source</a><a href=\"#method.partial_cmp\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.PartialOrd.html#tymethod.partial_cmp\" class=\"fn\">partial_cmp</a>(&self, other: &<a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html\" title=\"struct alloc::collections::btree::map::BTreeMap\">BTreeMap</a><K, V, A>) -> <a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/core/option/enum.Option.html\" title=\"enum core::option::Option\">Option</a><<a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/core/cmp/enum.Ordering.html\" title=\"enum core::cmp::Ordering\">Ordering</a>></h4></section></summary><div class='docblock'>This method returns an ordering between <code>self</code> and <code>other</code> values if one exists. <a href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.PartialOrd.html#tymethod.partial_cmp\">Read more</a></div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.lt\" class=\"method trait-impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.0.0\">1.0.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/core/cmp.rs.html#1179\">source</a></span><a href=\"#method.lt\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.PartialOrd.html#method.lt\" class=\"fn\">lt</a>(&self, other: <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.reference.html\">&Rhs</a>) -> <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.bool.html\">bool</a></h4></section></summary><div class='docblock'>This method tests less than (for <code>self</code> and <code>other</code>) and is used by the <code><</code> operator. <a href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.PartialOrd.html#method.lt\">Read more</a></div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.le\" class=\"method trait-impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.0.0\">1.0.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/core/cmp.rs.html#1197\">source</a></span><a href=\"#method.le\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.PartialOrd.html#method.le\" class=\"fn\">le</a>(&self, other: <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.reference.html\">&Rhs</a>) -> <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.bool.html\">bool</a></h4></section></summary><div class='docblock'>This method tests less than or equal to (for <code>self</code> and <code>other</code>) and is used by the <code><=</code>\noperator. <a href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.PartialOrd.html#method.le\">Read more</a></div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.gt\" class=\"method trait-impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.0.0\">1.0.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/core/cmp.rs.html#1214\">source</a></span><a href=\"#method.gt\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.PartialOrd.html#method.gt\" class=\"fn\">gt</a>(&self, other: <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.reference.html\">&Rhs</a>) -> <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.bool.html\">bool</a></h4></section></summary><div class='docblock'>This method tests greater than (for <code>self</code> and <code>other</code>) and is used by the <code>></code> operator. <a href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.PartialOrd.html#method.gt\">Read more</a></div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.ge\" class=\"method trait-impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.0.0\">1.0.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/core/cmp.rs.html#1232\">source</a></span><a href=\"#method.ge\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.PartialOrd.html#method.ge\" class=\"fn\">ge</a>(&self, other: <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.reference.html\">&Rhs</a>) -> <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.bool.html\">bool</a></h4></section></summary><div class='docblock'>This method tests greater than or equal to (for <code>self</code> and <code>other</code>) and is used by the <code>>=</code>\noperator. <a href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.PartialOrd.html#method.ge\">Read more</a></div></details></div></details>","PartialOrd","bdk_chain::local_chain::ChangeSet"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-Serialize-for-BTreeMap%3CK,+V%3E\" class=\"impl\"><a class=\"src rightside\" href=\"https://docs.rs/serde/1.0.203/src/serde/ser/impls.rs.html#495-499\">source</a><a href=\"#impl-Serialize-for-BTreeMap%3CK,+V%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl<K, V> <a class=\"trait\" href=\"https://docs.rs/serde/1.0.203/serde/ser/trait.Serialize.html\" title=\"trait serde::ser::Serialize\">Serialize</a> for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html\" title=\"struct alloc::collections::btree::map::BTreeMap\">BTreeMap</a><K, V><div class=\"where\">where\n K: <a class=\"trait\" href=\"https://docs.rs/serde/1.0.203/serde/ser/trait.Serialize.html\" title=\"trait serde::ser::Serialize\">Serialize</a>,\n V: <a class=\"trait\" href=\"https://docs.rs/serde/1.0.203/serde/ser/trait.Serialize.html\" title=\"trait serde::ser::Serialize\">Serialize</a>,</div></h3></section></summary><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.serialize\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://docs.rs/serde/1.0.203/src/serde/ser/impls.rs.html#495-499\">source</a><a href=\"#method.serialize\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://docs.rs/serde/1.0.203/serde/ser/trait.Serialize.html#tymethod.serialize\" class=\"fn\">serialize</a><S>(\n &self,\n serializer: S\n) -> <a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/core/result/enum.Result.html\" title=\"enum core::result::Result\">Result</a><<S as <a class=\"trait\" href=\"https://docs.rs/serde/1.0.203/serde/ser/trait.Serializer.html\" title=\"trait serde::ser::Serializer\">Serializer</a>>::<a class=\"associatedtype\" href=\"https://docs.rs/serde/1.0.203/serde/ser/trait.Serializer.html#associatedtype.Ok\" title=\"type serde::ser::Serializer::Ok\">Ok</a>, <S as <a class=\"trait\" href=\"https://docs.rs/serde/1.0.203/serde/ser/trait.Serializer.html\" title=\"trait serde::ser::Serializer\">Serializer</a>>::<a class=\"associatedtype\" href=\"https://docs.rs/serde/1.0.203/serde/ser/trait.Serializer.html#associatedtype.Error\" title=\"type serde::ser::Serializer::Error\">Error</a>><div class=\"where\">where\n S: <a class=\"trait\" href=\"https://docs.rs/serde/1.0.203/serde/ser/trait.Serializer.html\" title=\"trait serde::ser::Serializer\">Serializer</a>,</div></h4></section></summary><div class='docblock'>Serialize this value into the given Serde serializer. <a href=\"https://docs.rs/serde/1.0.203/serde/ser/trait.Serialize.html#tymethod.serialize\">Read more</a></div></details></div></details>","Serialize","bdk_chain::local_chain::ChangeSet"],["<section id=\"impl-Eq-for-BTreeMap%3CK,+V,+A%3E\" class=\"impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.0.0\">1.0.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/collections/btree/map.rs.html#2293\">source</a></span><a href=\"#impl-Eq-for-BTreeMap%3CK,+V,+A%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl<K, V, A> <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Eq.html\" title=\"trait core::cmp::Eq\">Eq</a> for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html\" title=\"struct alloc::collections::btree::map::BTreeMap\">BTreeMap</a><K, V, A><div class=\"where\">where\n K: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Eq.html\" title=\"trait core::cmp::Eq\">Eq</a>,\n V: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Eq.html\" title=\"trait core::cmp::Eq\">Eq</a>,\n A: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/alloc/trait.Allocator.html\" title=\"trait core::alloc::Allocator\">Allocator</a> + <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/clone/trait.Clone.html\" title=\"trait core::clone::Clone\">Clone</a>,</div></h3></section>","Eq","bdk_chain::local_chain::ChangeSet"],["<section id=\"impl-UnwindSafe-for-BTreeMap%3CK,+V,+A%3E\" class=\"impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.64.0\">1.64.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/collections/btree/map.rs.html#198-202\">source</a></span><a href=\"#impl-UnwindSafe-for-BTreeMap%3CK,+V,+A%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl<K, V, A> <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/panic/unwind_safe/trait.UnwindSafe.html\" title=\"trait core::panic::unwind_safe::UnwindSafe\">UnwindSafe</a> for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html\" title=\"struct alloc::collections::btree::map::BTreeMap\">BTreeMap</a><K, V, A><div class=\"where\">where\n A: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/alloc/trait.Allocator.html\" title=\"trait core::alloc::Allocator\">Allocator</a> + <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/clone/trait.Clone.html\" title=\"trait core::clone::Clone\">Clone</a> + <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/panic/unwind_safe/trait.UnwindSafe.html\" title=\"trait core::panic::unwind_safe::UnwindSafe\">UnwindSafe</a>,\n K: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/panic/unwind_safe/trait.RefUnwindSafe.html\" title=\"trait core::panic::unwind_safe::RefUnwindSafe\">RefUnwindSafe</a>,\n V: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/panic/unwind_safe/trait.RefUnwindSafe.html\" title=\"trait core::panic::unwind_safe::RefUnwindSafe\">RefUnwindSafe</a>,</div></h3></section>","UnwindSafe","bdk_chain::local_chain::ChangeSet"]],
-"bdk_wallet":[["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-Append-for-BTreeMap%3CK,+V%3E\" class=\"impl\"><a href=\"#impl-Append-for-BTreeMap%3CK,+V%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl<K, V> Append for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html\" title=\"struct alloc::collections::btree::map::BTreeMap\">BTreeMap</a><K, V><div class=\"where\">where\n K: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html\" title=\"trait core::cmp::Ord\">Ord</a>,</div></h3></section></summary><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.append\" class=\"method trait-impl\"><a href=\"#method.append\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a class=\"fn\">append</a>(&mut self, other: <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html\" title=\"struct alloc::collections::btree::map::BTreeMap\">BTreeMap</a><K, V>)</h4></section></summary><div class='docblock'>Append another object of the same type onto <code>self</code>.</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.is_empty\" class=\"method trait-impl\"><a href=\"#method.is_empty\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a class=\"fn\">is_empty</a>(&self) -> <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.bool.html\">bool</a></h4></section></summary><div class='docblock'>Returns whether the structure is considered empty.</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.take\" class=\"method trait-impl\"><a href=\"#method.take\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a class=\"fn\">take</a>(&mut self) -> <a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/core/option/enum.Option.html\" title=\"enum core::option::Option\">Option</a><Self></h4></section></summary><div class='docblock'>Take the value, replacing it with the default value.</div></details></div></details>","Append","bdk_wallet::descriptor::policy::ConditionMap","bdk_wallet::descriptor::policy::FoldedConditionMap","bdk_wallet::descriptor::HdKeyPaths","bdk_wallet::descriptor::TapKeyOrigins","bdk_wallet::keys::KeyMap"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-BTreeMap%3CK,+V%3E\" class=\"impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/collections/btree/map.rs.html#610\">source</a><a href=\"#impl-BTreeMap%3CK,+V%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl<K, V> <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html\" title=\"struct alloc::collections::btree::map::BTreeMap\">BTreeMap</a><K, V></h3></section></summary><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.new\" class=\"method\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.0.0, const since 1.66.0\">1.0.0 (const: 1.66.0)</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/collections/btree/map.rs.html#629\">source</a></span><h4 class=\"code-header\">pub const fn <a href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html#tymethod.new\" class=\"fn\">new</a>() -> <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html\" title=\"struct alloc::collections::btree::map::BTreeMap\">BTreeMap</a><K, V></h4></section></summary><div class=\"docblock\"><p>Makes a new, empty <code>BTreeMap</code>.</p>\n<p>Does not allocate anything on its own.</p>\n<h5 id=\"examples\"><a class=\"doc-anchor\" href=\"#examples\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::collections::BTreeMap;\n\n<span class=\"kw\">let </span><span class=\"kw-2\">mut </span>map = BTreeMap::new();\n\n<span class=\"comment\">// entries can now be inserted into the empty map\n</span>map.insert(<span class=\"number\">1</span>, <span class=\"string\">\"a\"</span>);</code></pre></div>\n</div></details></div></details>",0,"bdk_wallet::descriptor::policy::ConditionMap","bdk_wallet::descriptor::policy::FoldedConditionMap","bdk_wallet::descriptor::HdKeyPaths","bdk_wallet::descriptor::TapKeyOrigins","bdk_wallet::keys::KeyMap"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-BTreeMap%3CK,+V,+A%3E\" class=\"impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/collections/btree/map.rs.html#2359\">source</a><a href=\"#impl-BTreeMap%3CK,+V,+A%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl<K, V, A> <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html\" title=\"struct alloc::collections::btree::map::BTreeMap\">BTreeMap</a><K, V, A><div class=\"where\">where\n A: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/alloc/trait.Allocator.html\" title=\"trait core::alloc::Allocator\">Allocator</a> + <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/clone/trait.Clone.html\" title=\"trait core::clone::Clone\">Clone</a>,</div></h3></section></summary><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.iter\" class=\"method\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.0.0\">1.0.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/collections/btree/map.rs.html#2380\">source</a></span><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html#tymethod.iter\" class=\"fn\">iter</a>(&self) -> <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.Iter.html\" title=\"struct alloc::collections::btree::map::Iter\">Iter</a><'_, K, V></h4></section></summary><div class=\"docblock\"><p>Gets an iterator over the entries of the map, sorted by key.</p>\n<h5 id=\"examples\"><a class=\"doc-anchor\" href=\"#examples\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::collections::BTreeMap;\n\n<span class=\"kw\">let </span><span class=\"kw-2\">mut </span>map = BTreeMap::new();\nmap.insert(<span class=\"number\">3</span>, <span class=\"string\">\"c\"</span>);\nmap.insert(<span class=\"number\">2</span>, <span class=\"string\">\"b\"</span>);\nmap.insert(<span class=\"number\">1</span>, <span class=\"string\">\"a\"</span>);\n\n<span class=\"kw\">for </span>(key, value) <span class=\"kw\">in </span>map.iter() {\n <span class=\"macro\">println!</span>(<span class=\"string\">\"{key}: {value}\"</span>);\n}\n\n<span class=\"kw\">let </span>(first_key, first_value) = map.iter().next().unwrap();\n<span class=\"macro\">assert_eq!</span>((<span class=\"kw-2\">*</span>first_key, <span class=\"kw-2\">*</span>first_value), (<span class=\"number\">1</span>, <span class=\"string\">\"a\"</span>));</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.iter_mut\" class=\"method\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.0.0\">1.0.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/collections/btree/map.rs.html#2411\">source</a></span><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html#tymethod.iter_mut\" class=\"fn\">iter_mut</a>(&mut self) -> <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.IterMut.html\" title=\"struct alloc::collections::btree::map::IterMut\">IterMut</a><'_, K, V></h4></section></summary><div class=\"docblock\"><p>Gets a mutable iterator over the entries of the map, sorted by key.</p>\n<h5 id=\"examples-1\"><a class=\"doc-anchor\" href=\"#examples-1\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::collections::BTreeMap;\n\n<span class=\"kw\">let </span><span class=\"kw-2\">mut </span>map = BTreeMap::from([\n (<span class=\"string\">\"a\"</span>, <span class=\"number\">1</span>),\n (<span class=\"string\">\"b\"</span>, <span class=\"number\">2</span>),\n (<span class=\"string\">\"c\"</span>, <span class=\"number\">3</span>),\n]);\n\n<span class=\"comment\">// add 10 to the value if the key isn't \"a\"\n</span><span class=\"kw\">for </span>(key, value) <span class=\"kw\">in </span>map.iter_mut() {\n <span class=\"kw\">if </span>key != <span class=\"kw-2\">&</span><span class=\"string\">\"a\" </span>{\n <span class=\"kw-2\">*</span>value += <span class=\"number\">10</span>;\n }\n}</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.keys\" class=\"method\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.0.0\">1.0.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/collections/btree/map.rs.html#2436\">source</a></span><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html#tymethod.keys\" class=\"fn\">keys</a>(&self) -> <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.Keys.html\" title=\"struct alloc::collections::btree::map::Keys\">Keys</a><'_, K, V></h4></section></summary><div class=\"docblock\"><p>Gets an iterator over the keys of the map, in sorted order.</p>\n<h5 id=\"examples-2\"><a class=\"doc-anchor\" href=\"#examples-2\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::collections::BTreeMap;\n\n<span class=\"kw\">let </span><span class=\"kw-2\">mut </span>a = BTreeMap::new();\na.insert(<span class=\"number\">2</span>, <span class=\"string\">\"b\"</span>);\na.insert(<span class=\"number\">1</span>, <span class=\"string\">\"a\"</span>);\n\n<span class=\"kw\">let </span>keys: Vec<<span class=\"kw\">_</span>> = a.keys().cloned().collect();\n<span class=\"macro\">assert_eq!</span>(keys, [<span class=\"number\">1</span>, <span class=\"number\">2</span>]);</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.values\" class=\"method\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.0.0\">1.0.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/collections/btree/map.rs.html#2455\">source</a></span><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html#tymethod.values\" class=\"fn\">values</a>(&self) -> <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.Values.html\" title=\"struct alloc::collections::btree::map::Values\">Values</a><'_, K, V></h4></section></summary><div class=\"docblock\"><p>Gets an iterator over the values of the map, in order by key.</p>\n<h5 id=\"examples-3\"><a class=\"doc-anchor\" href=\"#examples-3\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::collections::BTreeMap;\n\n<span class=\"kw\">let </span><span class=\"kw-2\">mut </span>a = BTreeMap::new();\na.insert(<span class=\"number\">1</span>, <span class=\"string\">\"hello\"</span>);\na.insert(<span class=\"number\">2</span>, <span class=\"string\">\"goodbye\"</span>);\n\n<span class=\"kw\">let </span>values: Vec<<span class=\"kw-2\">&</span>str> = a.values().cloned().collect();\n<span class=\"macro\">assert_eq!</span>(values, [<span class=\"string\">\"hello\"</span>, <span class=\"string\">\"goodbye\"</span>]);</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.values_mut\" class=\"method\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.10.0\">1.10.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/collections/btree/map.rs.html#2479\">source</a></span><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html#tymethod.values_mut\" class=\"fn\">values_mut</a>(&mut self) -> <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.ValuesMut.html\" title=\"struct alloc::collections::btree::map::ValuesMut\">ValuesMut</a><'_, K, V></h4></section></summary><div class=\"docblock\"><p>Gets a mutable iterator over the values of the map, in order by key.</p>\n<h5 id=\"examples-4\"><a class=\"doc-anchor\" href=\"#examples-4\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::collections::BTreeMap;\n\n<span class=\"kw\">let </span><span class=\"kw-2\">mut </span>a = BTreeMap::new();\na.insert(<span class=\"number\">1</span>, String::from(<span class=\"string\">\"hello\"</span>));\na.insert(<span class=\"number\">2</span>, String::from(<span class=\"string\">\"goodbye\"</span>));\n\n<span class=\"kw\">for </span>value <span class=\"kw\">in </span>a.values_mut() {\n value.push_str(<span class=\"string\">\"!\"</span>);\n}\n\n<span class=\"kw\">let </span>values: Vec<String> = a.values().cloned().collect();\n<span class=\"macro\">assert_eq!</span>(values, [String::from(<span class=\"string\">\"hello!\"</span>),\n String::from(<span class=\"string\">\"goodbye!\"</span>)]);</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.len\" class=\"method\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.0.0, const unstable\">1.0.0 (const: <a href=\"https://github.com/rust-lang/rust/issues/71835\" title=\"Tracking issue for const_btree_len\">unstable</a>)</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/collections/btree/map.rs.html#2503\">source</a></span><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html#tymethod.len\" class=\"fn\">len</a>(&self) -> <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.usize.html\">usize</a></h4></section></summary><div class=\"docblock\"><p>Returns the number of elements in the map.</p>\n<h5 id=\"examples-5\"><a class=\"doc-anchor\" href=\"#examples-5\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::collections::BTreeMap;\n\n<span class=\"kw\">let </span><span class=\"kw-2\">mut </span>a = BTreeMap::new();\n<span class=\"macro\">assert_eq!</span>(a.len(), <span class=\"number\">0</span>);\na.insert(<span class=\"number\">1</span>, <span class=\"string\">\"a\"</span>);\n<span class=\"macro\">assert_eq!</span>(a.len(), <span class=\"number\">1</span>);</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.is_empty\" class=\"method\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.0.0, const unstable\">1.0.0 (const: <a href=\"https://github.com/rust-lang/rust/issues/71835\" title=\"Tracking issue for const_btree_len\">unstable</a>)</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/collections/btree/map.rs.html#2526\">source</a></span><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html#tymethod.is_empty\" class=\"fn\">is_empty</a>(&self) -> <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.bool.html\">bool</a></h4></section></summary><div class=\"docblock\"><p>Returns <code>true</code> if the map contains no elements.</p>\n<h5 id=\"examples-6\"><a class=\"doc-anchor\" href=\"#examples-6\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::collections::BTreeMap;\n\n<span class=\"kw\">let </span><span class=\"kw-2\">mut </span>a = BTreeMap::new();\n<span class=\"macro\">assert!</span>(a.is_empty());\na.insert(<span class=\"number\">1</span>, <span class=\"string\">\"a\"</span>);\n<span class=\"macro\">assert!</span>(!a.is_empty());</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.lower_bound\" class=\"method\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/collections/btree/map.rs.html#2570-2573\">source</a><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html#tymethod.lower_bound\" class=\"fn\">lower_bound</a><Q>(&self, bound: <a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/core/ops/range/enum.Bound.html\" title=\"enum core::ops::range::Bound\">Bound</a><<a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.reference.html\">&Q</a>>) -> <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.Cursor.html\" title=\"struct alloc::collections::btree::map::Cursor\">Cursor</a><'_, K, V><div class=\"where\">where\n K: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/borrow/trait.Borrow.html\" title=\"trait core::borrow::Borrow\">Borrow</a><Q> + <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html\" title=\"trait core::cmp::Ord\">Ord</a>,\n Q: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html\" title=\"trait core::cmp::Ord\">Ord</a> + ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,</div></h4></section><span class=\"item-info\"><div class=\"stab unstable\"><span class=\"emoji\">🔬</span><span>This is a nightly-only experimental API. (<code>btree_cursors</code>)</span></div></span></summary><div class=\"docblock\"><p>Returns a <a href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.Cursor.html\" title=\"struct alloc::collections::btree::map::Cursor\"><code>Cursor</code></a> pointing at the gap before the smallest key\ngreater than the given bound.</p>\n<p>Passing <code>Bound::Included(x)</code> will return a cursor pointing to the\ngap before the smallest key greater than or equal to <code>x</code>.</p>\n<p>Passing <code>Bound::Excluded(x)</code> will return a cursor pointing to the\ngap before the smallest key greater than <code>x</code>.</p>\n<p>Passing <code>Bound::Unbounded</code> will return a cursor pointing to the\ngap before the smallest key in the map.</p>\n<h5 id=\"examples-7\"><a class=\"doc-anchor\" href=\"#examples-7\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"attr\">#![feature(btree_cursors)]\n\n</span><span class=\"kw\">use </span>std::collections::BTreeMap;\n<span class=\"kw\">use </span>std::ops::Bound;\n\n<span class=\"kw\">let </span>map = BTreeMap::from([\n (<span class=\"number\">1</span>, <span class=\"string\">\"a\"</span>),\n (<span class=\"number\">2</span>, <span class=\"string\">\"b\"</span>),\n (<span class=\"number\">3</span>, <span class=\"string\">\"c\"</span>),\n (<span class=\"number\">4</span>, <span class=\"string\">\"d\"</span>),\n]);\n\n<span class=\"kw\">let </span>cursor = map.lower_bound(Bound::Included(<span class=\"kw-2\">&</span><span class=\"number\">2</span>));\n<span class=\"macro\">assert_eq!</span>(cursor.peek_prev(), <span class=\"prelude-val\">Some</span>((<span class=\"kw-2\">&</span><span class=\"number\">1</span>, <span class=\"kw-2\">&</span><span class=\"string\">\"a\"</span>)));\n<span class=\"macro\">assert_eq!</span>(cursor.peek_next(), <span class=\"prelude-val\">Some</span>((<span class=\"kw-2\">&</span><span class=\"number\">2</span>, <span class=\"kw-2\">&</span><span class=\"string\">\"b\"</span>)));\n\n<span class=\"kw\">let </span>cursor = map.lower_bound(Bound::Excluded(<span class=\"kw-2\">&</span><span class=\"number\">2</span>));\n<span class=\"macro\">assert_eq!</span>(cursor.peek_prev(), <span class=\"prelude-val\">Some</span>((<span class=\"kw-2\">&</span><span class=\"number\">2</span>, <span class=\"kw-2\">&</span><span class=\"string\">\"b\"</span>)));\n<span class=\"macro\">assert_eq!</span>(cursor.peek_next(), <span class=\"prelude-val\">Some</span>((<span class=\"kw-2\">&</span><span class=\"number\">3</span>, <span class=\"kw-2\">&</span><span class=\"string\">\"c\"</span>)));\n\n<span class=\"kw\">let </span>cursor = map.lower_bound(Bound::Unbounded);\n<span class=\"macro\">assert_eq!</span>(cursor.peek_prev(), <span class=\"prelude-val\">None</span>);\n<span class=\"macro\">assert_eq!</span>(cursor.peek_next(), <span class=\"prelude-val\">Some</span>((<span class=\"kw-2\">&</span><span class=\"number\">1</span>, <span class=\"kw-2\">&</span><span class=\"string\">\"a\"</span>)));</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.lower_bound_mut\" class=\"method\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/collections/btree/map.rs.html#2623-2626\">source</a><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html#tymethod.lower_bound_mut\" class=\"fn\">lower_bound_mut</a><Q>(&mut self, bound: <a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/core/ops/range/enum.Bound.html\" title=\"enum core::ops::range::Bound\">Bound</a><<a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.reference.html\">&Q</a>>) -> <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.CursorMut.html\" title=\"struct alloc::collections::btree::map::CursorMut\">CursorMut</a><'_, K, V, A><div class=\"where\">where\n K: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/borrow/trait.Borrow.html\" title=\"trait core::borrow::Borrow\">Borrow</a><Q> + <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html\" title=\"trait core::cmp::Ord\">Ord</a>,\n Q: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html\" title=\"trait core::cmp::Ord\">Ord</a> + ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,</div></h4></section><span class=\"item-info\"><div class=\"stab unstable\"><span class=\"emoji\">🔬</span><span>This is a nightly-only experimental API. (<code>btree_cursors</code>)</span></div></span></summary><div class=\"docblock\"><p>Returns a <a href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.CursorMut.html\" title=\"struct alloc::collections::btree::map::CursorMut\"><code>CursorMut</code></a> pointing at the gap before the smallest key\ngreater than the given bound.</p>\n<p>Passing <code>Bound::Included(x)</code> will return a cursor pointing to the\ngap before the smallest key greater than or equal to <code>x</code>.</p>\n<p>Passing <code>Bound::Excluded(x)</code> will return a cursor pointing to the\ngap before the smallest key greater than <code>x</code>.</p>\n<p>Passing <code>Bound::Unbounded</code> will return a cursor pointing to the\ngap before the smallest key in the map.</p>\n<h5 id=\"examples-8\"><a class=\"doc-anchor\" href=\"#examples-8\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"attr\">#![feature(btree_cursors)]\n\n</span><span class=\"kw\">use </span>std::collections::BTreeMap;\n<span class=\"kw\">use </span>std::ops::Bound;\n\n<span class=\"kw\">let </span><span class=\"kw-2\">mut </span>map = BTreeMap::from([\n (<span class=\"number\">1</span>, <span class=\"string\">\"a\"</span>),\n (<span class=\"number\">2</span>, <span class=\"string\">\"b\"</span>),\n (<span class=\"number\">3</span>, <span class=\"string\">\"c\"</span>),\n (<span class=\"number\">4</span>, <span class=\"string\">\"d\"</span>),\n]);\n\n<span class=\"kw\">let </span><span class=\"kw-2\">mut </span>cursor = map.lower_bound_mut(Bound::Included(<span class=\"kw-2\">&</span><span class=\"number\">2</span>));\n<span class=\"macro\">assert_eq!</span>(cursor.peek_prev(), <span class=\"prelude-val\">Some</span>((<span class=\"kw-2\">&</span><span class=\"number\">1</span>, <span class=\"kw-2\">&mut </span><span class=\"string\">\"a\"</span>)));\n<span class=\"macro\">assert_eq!</span>(cursor.peek_next(), <span class=\"prelude-val\">Some</span>((<span class=\"kw-2\">&</span><span class=\"number\">2</span>, <span class=\"kw-2\">&mut </span><span class=\"string\">\"b\"</span>)));\n\n<span class=\"kw\">let </span><span class=\"kw-2\">mut </span>cursor = map.lower_bound_mut(Bound::Excluded(<span class=\"kw-2\">&</span><span class=\"number\">2</span>));\n<span class=\"macro\">assert_eq!</span>(cursor.peek_prev(), <span class=\"prelude-val\">Some</span>((<span class=\"kw-2\">&</span><span class=\"number\">2</span>, <span class=\"kw-2\">&mut </span><span class=\"string\">\"b\"</span>)));\n<span class=\"macro\">assert_eq!</span>(cursor.peek_next(), <span class=\"prelude-val\">Some</span>((<span class=\"kw-2\">&</span><span class=\"number\">3</span>, <span class=\"kw-2\">&mut </span><span class=\"string\">\"c\"</span>)));\n\n<span class=\"kw\">let </span><span class=\"kw-2\">mut </span>cursor = map.lower_bound_mut(Bound::Unbounded);\n<span class=\"macro\">assert_eq!</span>(cursor.peek_prev(), <span class=\"prelude-val\">None</span>);\n<span class=\"macro\">assert_eq!</span>(cursor.peek_next(), <span class=\"prelude-val\">Some</span>((<span class=\"kw-2\">&</span><span class=\"number\">1</span>, <span class=\"kw-2\">&mut </span><span class=\"string\">\"a\"</span>)));</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.upper_bound\" class=\"method\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/collections/btree/map.rs.html#2693-2696\">source</a><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html#tymethod.upper_bound\" class=\"fn\">upper_bound</a><Q>(&self, bound: <a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/core/ops/range/enum.Bound.html\" title=\"enum core::ops::range::Bound\">Bound</a><<a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.reference.html\">&Q</a>>) -> <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.Cursor.html\" title=\"struct alloc::collections::btree::map::Cursor\">Cursor</a><'_, K, V><div class=\"where\">where\n K: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/borrow/trait.Borrow.html\" title=\"trait core::borrow::Borrow\">Borrow</a><Q> + <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html\" title=\"trait core::cmp::Ord\">Ord</a>,\n Q: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html\" title=\"trait core::cmp::Ord\">Ord</a> + ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,</div></h4></section><span class=\"item-info\"><div class=\"stab unstable\"><span class=\"emoji\">🔬</span><span>This is a nightly-only experimental API. (<code>btree_cursors</code>)</span></div></span></summary><div class=\"docblock\"><p>Returns a <a href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.Cursor.html\" title=\"struct alloc::collections::btree::map::Cursor\"><code>Cursor</code></a> pointing at the gap after the greatest key\nsmaller than the given bound.</p>\n<p>Passing <code>Bound::Included(x)</code> will return a cursor pointing to the\ngap after the greatest key smaller than or equal to <code>x</code>.</p>\n<p>Passing <code>Bound::Excluded(x)</code> will return a cursor pointing to the\ngap after the greatest key smaller than <code>x</code>.</p>\n<p>Passing <code>Bound::Unbounded</code> will return a cursor pointing to the\ngap after the greatest key in the map.</p>\n<h5 id=\"examples-9\"><a class=\"doc-anchor\" href=\"#examples-9\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"attr\">#![feature(btree_cursors)]\n\n</span><span class=\"kw\">use </span>std::collections::BTreeMap;\n<span class=\"kw\">use </span>std::ops::Bound;\n\n<span class=\"kw\">let </span>map = BTreeMap::from([\n (<span class=\"number\">1</span>, <span class=\"string\">\"a\"</span>),\n (<span class=\"number\">2</span>, <span class=\"string\">\"b\"</span>),\n (<span class=\"number\">3</span>, <span class=\"string\">\"c\"</span>),\n (<span class=\"number\">4</span>, <span class=\"string\">\"d\"</span>),\n]);\n\n<span class=\"kw\">let </span>cursor = map.upper_bound(Bound::Included(<span class=\"kw-2\">&</span><span class=\"number\">3</span>));\n<span class=\"macro\">assert_eq!</span>(cursor.peek_prev(), <span class=\"prelude-val\">Some</span>((<span class=\"kw-2\">&</span><span class=\"number\">3</span>, <span class=\"kw-2\">&</span><span class=\"string\">\"c\"</span>)));\n<span class=\"macro\">assert_eq!</span>(cursor.peek_next(), <span class=\"prelude-val\">Some</span>((<span class=\"kw-2\">&</span><span class=\"number\">4</span>, <span class=\"kw-2\">&</span><span class=\"string\">\"d\"</span>)));\n\n<span class=\"kw\">let </span>cursor = map.upper_bound(Bound::Excluded(<span class=\"kw-2\">&</span><span class=\"number\">3</span>));\n<span class=\"macro\">assert_eq!</span>(cursor.peek_prev(), <span class=\"prelude-val\">Some</span>((<span class=\"kw-2\">&</span><span class=\"number\">2</span>, <span class=\"kw-2\">&</span><span class=\"string\">\"b\"</span>)));\n<span class=\"macro\">assert_eq!</span>(cursor.peek_next(), <span class=\"prelude-val\">Some</span>((<span class=\"kw-2\">&</span><span class=\"number\">3</span>, <span class=\"kw-2\">&</span><span class=\"string\">\"c\"</span>)));\n\n<span class=\"kw\">let </span>cursor = map.upper_bound(Bound::Unbounded);\n<span class=\"macro\">assert_eq!</span>(cursor.peek_prev(), <span class=\"prelude-val\">Some</span>((<span class=\"kw-2\">&</span><span class=\"number\">4</span>, <span class=\"kw-2\">&</span><span class=\"string\">\"d\"</span>)));\n<span class=\"macro\">assert_eq!</span>(cursor.peek_next(), <span class=\"prelude-val\">None</span>);</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.upper_bound_mut\" class=\"method\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/collections/btree/map.rs.html#2746-2749\">source</a><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html#tymethod.upper_bound_mut\" class=\"fn\">upper_bound_mut</a><Q>(&mut self, bound: <a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/core/ops/range/enum.Bound.html\" title=\"enum core::ops::range::Bound\">Bound</a><<a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.reference.html\">&Q</a>>) -> <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.CursorMut.html\" title=\"struct alloc::collections::btree::map::CursorMut\">CursorMut</a><'_, K, V, A><div class=\"where\">where\n K: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/borrow/trait.Borrow.html\" title=\"trait core::borrow::Borrow\">Borrow</a><Q> + <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html\" title=\"trait core::cmp::Ord\">Ord</a>,\n Q: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html\" title=\"trait core::cmp::Ord\">Ord</a> + ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,</div></h4></section><span class=\"item-info\"><div class=\"stab unstable\"><span class=\"emoji\">🔬</span><span>This is a nightly-only experimental API. (<code>btree_cursors</code>)</span></div></span></summary><div class=\"docblock\"><p>Returns a <a href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.CursorMut.html\" title=\"struct alloc::collections::btree::map::CursorMut\"><code>CursorMut</code></a> pointing at the gap after the greatest key\nsmaller than the given bound.</p>\n<p>Passing <code>Bound::Included(x)</code> will return a cursor pointing to the\ngap after the greatest key smaller than or equal to <code>x</code>.</p>\n<p>Passing <code>Bound::Excluded(x)</code> will return a cursor pointing to the\ngap after the greatest key smaller than <code>x</code>.</p>\n<p>Passing <code>Bound::Unbounded</code> will return a cursor pointing to the\ngap after the greatest key in the map.</p>\n<h5 id=\"examples-10\"><a class=\"doc-anchor\" href=\"#examples-10\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"attr\">#![feature(btree_cursors)]\n\n</span><span class=\"kw\">use </span>std::collections::BTreeMap;\n<span class=\"kw\">use </span>std::ops::Bound;\n\n<span class=\"kw\">let </span><span class=\"kw-2\">mut </span>map = BTreeMap::from([\n (<span class=\"number\">1</span>, <span class=\"string\">\"a\"</span>),\n (<span class=\"number\">2</span>, <span class=\"string\">\"b\"</span>),\n (<span class=\"number\">3</span>, <span class=\"string\">\"c\"</span>),\n (<span class=\"number\">4</span>, <span class=\"string\">\"d\"</span>),\n]);\n\n<span class=\"kw\">let </span><span class=\"kw-2\">mut </span>cursor = map.upper_bound_mut(Bound::Included(<span class=\"kw-2\">&</span><span class=\"number\">3</span>));\n<span class=\"macro\">assert_eq!</span>(cursor.peek_prev(), <span class=\"prelude-val\">Some</span>((<span class=\"kw-2\">&</span><span class=\"number\">3</span>, <span class=\"kw-2\">&mut </span><span class=\"string\">\"c\"</span>)));\n<span class=\"macro\">assert_eq!</span>(cursor.peek_next(), <span class=\"prelude-val\">Some</span>((<span class=\"kw-2\">&</span><span class=\"number\">4</span>, <span class=\"kw-2\">&mut </span><span class=\"string\">\"d\"</span>)));\n\n<span class=\"kw\">let </span><span class=\"kw-2\">mut </span>cursor = map.upper_bound_mut(Bound::Excluded(<span class=\"kw-2\">&</span><span class=\"number\">3</span>));\n<span class=\"macro\">assert_eq!</span>(cursor.peek_prev(), <span class=\"prelude-val\">Some</span>((<span class=\"kw-2\">&</span><span class=\"number\">2</span>, <span class=\"kw-2\">&mut </span><span class=\"string\">\"b\"</span>)));\n<span class=\"macro\">assert_eq!</span>(cursor.peek_next(), <span class=\"prelude-val\">Some</span>((<span class=\"kw-2\">&</span><span class=\"number\">3</span>, <span class=\"kw-2\">&mut </span><span class=\"string\">\"c\"</span>)));\n\n<span class=\"kw\">let </span><span class=\"kw-2\">mut </span>cursor = map.upper_bound_mut(Bound::Unbounded);\n<span class=\"macro\">assert_eq!</span>(cursor.peek_prev(), <span class=\"prelude-val\">Some</span>((<span class=\"kw-2\">&</span><span class=\"number\">4</span>, <span class=\"kw-2\">&mut </span><span class=\"string\">\"d\"</span>)));\n<span class=\"macro\">assert_eq!</span>(cursor.peek_next(), <span class=\"prelude-val\">None</span>);</code></pre></div>\n</div></details></div></details>",0,"bdk_wallet::descriptor::policy::ConditionMap","bdk_wallet::descriptor::policy::FoldedConditionMap","bdk_wallet::descriptor::HdKeyPaths","bdk_wallet::descriptor::TapKeyOrigins","bdk_wallet::keys::KeyMap"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-BTreeMap%3CK,+V,+A%3E\" class=\"impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/collections/btree/map.rs.html#634\">source</a><a href=\"#impl-BTreeMap%3CK,+V,+A%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl<K, V, A> <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html\" title=\"struct alloc::collections::btree::map::BTreeMap\">BTreeMap</a><K, V, A><div class=\"where\">where\n A: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/alloc/trait.Allocator.html\" title=\"trait core::alloc::Allocator\">Allocator</a> + <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/clone/trait.Clone.html\" title=\"trait core::clone::Clone\">Clone</a>,</div></h3></section></summary><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.clear\" class=\"method\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.0.0\">1.0.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/collections/btree/map.rs.html#648\">source</a></span><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html#tymethod.clear\" class=\"fn\">clear</a>(&mut self)</h4></section></summary><div class=\"docblock\"><p>Clears the map, removing all elements.</p>\n<h5 id=\"examples\"><a class=\"doc-anchor\" href=\"#examples\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::collections::BTreeMap;\n\n<span class=\"kw\">let </span><span class=\"kw-2\">mut </span>a = BTreeMap::new();\na.insert(<span class=\"number\">1</span>, <span class=\"string\">\"a\"</span>);\na.clear();\n<span class=\"macro\">assert!</span>(a.is_empty());</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.new_in\" class=\"method\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/collections/btree/map.rs.html#674\">source</a><h4 class=\"code-header\">pub const fn <a href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html#tymethod.new_in\" class=\"fn\">new_in</a>(alloc: A) -> <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html\" title=\"struct alloc::collections::btree::map::BTreeMap\">BTreeMap</a><K, V, A></h4></section><span class=\"item-info\"><div class=\"stab unstable\"><span class=\"emoji\">🔬</span><span>This is a nightly-only experimental API. (<code>btreemap_alloc</code>)</span></div></span></summary><div class=\"docblock\"><p>Makes a new empty BTreeMap with a reasonable choice for B.</p>\n<h5 id=\"examples-1\"><a class=\"doc-anchor\" href=\"#examples-1\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::collections::BTreeMap;\n<span class=\"kw\">use </span>std::alloc::Global;\n\n<span class=\"kw\">let </span><span class=\"kw-2\">mut </span>map = BTreeMap::new_in(Global);\n\n<span class=\"comment\">// entries can now be inserted into the empty map\n</span>map.insert(<span class=\"number\">1</span>, <span class=\"string\">\"a\"</span>);</code></pre></div>\n</div></details></div></details>",0,"bdk_wallet::descriptor::policy::ConditionMap","bdk_wallet::descriptor::policy::FoldedConditionMap","bdk_wallet::descriptor::HdKeyPaths","bdk_wallet::descriptor::TapKeyOrigins","bdk_wallet::keys::KeyMap"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-BTreeMap%3CK,+V,+A%3E\" class=\"impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/collections/btree/map.rs.html#679\">source</a><a href=\"#impl-BTreeMap%3CK,+V,+A%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl<K, V, A> <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html\" title=\"struct alloc::collections::btree::map::BTreeMap\">BTreeMap</a><K, V, A><div class=\"where\">where\n A: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/alloc/trait.Allocator.html\" title=\"trait core::alloc::Allocator\">Allocator</a> + <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/clone/trait.Clone.html\" title=\"trait core::clone::Clone\">Clone</a>,</div></h3></section></summary><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.get\" class=\"method\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.0.0\">1.0.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/collections/btree/map.rs.html#696-699\">source</a></span><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html#tymethod.get\" class=\"fn\">get</a><Q>(&self, key: <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.reference.html\">&Q</a>) -> <a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/core/option/enum.Option.html\" title=\"enum core::option::Option\">Option</a><<a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.reference.html\">&V</a>><div class=\"where\">where\n K: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/borrow/trait.Borrow.html\" title=\"trait core::borrow::Borrow\">Borrow</a><Q> + <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html\" title=\"trait core::cmp::Ord\">Ord</a>,\n Q: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html\" title=\"trait core::cmp::Ord\">Ord</a> + ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,</div></h4></section></summary><div class=\"docblock\"><p>Returns a reference to the value corresponding to the key.</p>\n<p>The key may be any borrowed form of the map’s key type, but the ordering\non the borrowed form <em>must</em> match the ordering on the key type.</p>\n<h5 id=\"examples\"><a class=\"doc-anchor\" href=\"#examples\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::collections::BTreeMap;\n\n<span class=\"kw\">let </span><span class=\"kw-2\">mut </span>map = BTreeMap::new();\nmap.insert(<span class=\"number\">1</span>, <span class=\"string\">\"a\"</span>);\n<span class=\"macro\">assert_eq!</span>(map.get(<span class=\"kw-2\">&</span><span class=\"number\">1</span>), <span class=\"prelude-val\">Some</span>(<span class=\"kw-2\">&</span><span class=\"string\">\"a\"</span>));\n<span class=\"macro\">assert_eq!</span>(map.get(<span class=\"kw-2\">&</span><span class=\"number\">2</span>), <span class=\"prelude-val\">None</span>);</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.get_key_value\" class=\"method\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.40.0\">1.40.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/collections/btree/map.rs.html#724-727\">source</a></span><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html#tymethod.get_key_value\" class=\"fn\">get_key_value</a><Q>(&self, k: <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.reference.html\">&Q</a>) -> <a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/core/option/enum.Option.html\" title=\"enum core::option::Option\">Option</a><(<a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.reference.html\">&K</a>, <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.reference.html\">&V</a>)><div class=\"where\">where\n K: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/borrow/trait.Borrow.html\" title=\"trait core::borrow::Borrow\">Borrow</a><Q> + <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html\" title=\"trait core::cmp::Ord\">Ord</a>,\n Q: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html\" title=\"trait core::cmp::Ord\">Ord</a> + ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,</div></h4></section></summary><div class=\"docblock\"><p>Returns the key-value pair corresponding to the supplied key.</p>\n<p>The supplied key may be any borrowed form of the map’s key type, but the ordering\non the borrowed form <em>must</em> match the ordering on the key type.</p>\n<h5 id=\"examples-1\"><a class=\"doc-anchor\" href=\"#examples-1\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::collections::BTreeMap;\n\n<span class=\"kw\">let </span><span class=\"kw-2\">mut </span>map = BTreeMap::new();\nmap.insert(<span class=\"number\">1</span>, <span class=\"string\">\"a\"</span>);\n<span class=\"macro\">assert_eq!</span>(map.get_key_value(<span class=\"kw-2\">&</span><span class=\"number\">1</span>), <span class=\"prelude-val\">Some</span>((<span class=\"kw-2\">&</span><span class=\"number\">1</span>, <span class=\"kw-2\">&</span><span class=\"string\">\"a\"</span>)));\n<span class=\"macro\">assert_eq!</span>(map.get_key_value(<span class=\"kw-2\">&</span><span class=\"number\">2</span>), <span class=\"prelude-val\">None</span>);</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.first_key_value\" class=\"method\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.66.0\">1.66.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/collections/btree/map.rs.html#751-753\">source</a></span><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html#tymethod.first_key_value\" class=\"fn\">first_key_value</a>(&self) -> <a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/core/option/enum.Option.html\" title=\"enum core::option::Option\">Option</a><(<a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.reference.html\">&K</a>, <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.reference.html\">&V</a>)><div class=\"where\">where\n K: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html\" title=\"trait core::cmp::Ord\">Ord</a>,</div></h4></section></summary><div class=\"docblock\"><p>Returns the first key-value pair in the map.\nThe key in this pair is the minimum key in the map.</p>\n<h5 id=\"examples-2\"><a class=\"doc-anchor\" href=\"#examples-2\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::collections::BTreeMap;\n\n<span class=\"kw\">let </span><span class=\"kw-2\">mut </span>map = BTreeMap::new();\n<span class=\"macro\">assert_eq!</span>(map.first_key_value(), <span class=\"prelude-val\">None</span>);\nmap.insert(<span class=\"number\">1</span>, <span class=\"string\">\"b\"</span>);\nmap.insert(<span class=\"number\">2</span>, <span class=\"string\">\"a\"</span>);\n<span class=\"macro\">assert_eq!</span>(map.first_key_value(), <span class=\"prelude-val\">Some</span>((<span class=\"kw-2\">&</span><span class=\"number\">1</span>, <span class=\"kw-2\">&</span><span class=\"string\">\"b\"</span>)));</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.first_entry\" class=\"method\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.66.0\">1.66.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/collections/btree/map.rs.html#779-781\">source</a></span><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html#tymethod.first_entry\" class=\"fn\">first_entry</a>(&mut self) -> <a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/core/option/enum.Option.html\" title=\"enum core::option::Option\">Option</a><<a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/entry/struct.OccupiedEntry.html\" title=\"struct alloc::collections::btree::map::entry::OccupiedEntry\">OccupiedEntry</a><'_, K, V, A>><div class=\"where\">where\n K: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html\" title=\"trait core::cmp::Ord\">Ord</a>,</div></h4></section></summary><div class=\"docblock\"><p>Returns the first entry in the map for in-place manipulation.\nThe key of this entry is the minimum key in the map.</p>\n<h5 id=\"examples-3\"><a class=\"doc-anchor\" href=\"#examples-3\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::collections::BTreeMap;\n\n<span class=\"kw\">let </span><span class=\"kw-2\">mut </span>map = BTreeMap::new();\nmap.insert(<span class=\"number\">1</span>, <span class=\"string\">\"a\"</span>);\nmap.insert(<span class=\"number\">2</span>, <span class=\"string\">\"b\"</span>);\n<span class=\"kw\">if let </span><span class=\"prelude-val\">Some</span>(<span class=\"kw-2\">mut </span>entry) = map.first_entry() {\n <span class=\"kw\">if </span><span class=\"kw-2\">*</span>entry.key() > <span class=\"number\">0 </span>{\n entry.insert(<span class=\"string\">\"first\"</span>);\n }\n}\n<span class=\"macro\">assert_eq!</span>(<span class=\"kw-2\">*</span>map.get(<span class=\"kw-2\">&</span><span class=\"number\">1</span>).unwrap(), <span class=\"string\">\"first\"</span>);\n<span class=\"macro\">assert_eq!</span>(<span class=\"kw-2\">*</span>map.get(<span class=\"kw-2\">&</span><span class=\"number\">2</span>).unwrap(), <span class=\"string\">\"b\"</span>);</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.pop_first\" class=\"method\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.66.0\">1.66.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/collections/btree/map.rs.html#813-815\">source</a></span><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html#tymethod.pop_first\" class=\"fn\">pop_first</a>(&mut self) -> <a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/core/option/enum.Option.html\" title=\"enum core::option::Option\">Option</a><<a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.tuple.html\">(K, V)</a>><div class=\"where\">where\n K: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html\" title=\"trait core::cmp::Ord\">Ord</a>,</div></h4></section></summary><div class=\"docblock\"><p>Removes and returns the first element in the map.\nThe key of this element is the minimum key that was in the map.</p>\n<h5 id=\"examples-4\"><a class=\"doc-anchor\" href=\"#examples-4\">§</a>Examples</h5>\n<p>Draining elements in ascending order, while keeping a usable map each iteration.</p>\n\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::collections::BTreeMap;\n\n<span class=\"kw\">let </span><span class=\"kw-2\">mut </span>map = BTreeMap::new();\nmap.insert(<span class=\"number\">1</span>, <span class=\"string\">\"a\"</span>);\nmap.insert(<span class=\"number\">2</span>, <span class=\"string\">\"b\"</span>);\n<span class=\"kw\">while let </span><span class=\"prelude-val\">Some</span>((key, _val)) = map.pop_first() {\n <span class=\"macro\">assert!</span>(map.iter().all(|(k, _v)| <span class=\"kw-2\">*</span>k > key));\n}\n<span class=\"macro\">assert!</span>(map.is_empty());</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.last_key_value\" class=\"method\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.66.0\">1.66.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/collections/btree/map.rs.html#834-836\">source</a></span><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html#tymethod.last_key_value\" class=\"fn\">last_key_value</a>(&self) -> <a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/core/option/enum.Option.html\" title=\"enum core::option::Option\">Option</a><(<a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.reference.html\">&K</a>, <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.reference.html\">&V</a>)><div class=\"where\">where\n K: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html\" title=\"trait core::cmp::Ord\">Ord</a>,</div></h4></section></summary><div class=\"docblock\"><p>Returns the last key-value pair in the map.\nThe key in this pair is the maximum key in the map.</p>\n<h5 id=\"examples-5\"><a class=\"doc-anchor\" href=\"#examples-5\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::collections::BTreeMap;\n\n<span class=\"kw\">let </span><span class=\"kw-2\">mut </span>map = BTreeMap::new();\nmap.insert(<span class=\"number\">1</span>, <span class=\"string\">\"b\"</span>);\nmap.insert(<span class=\"number\">2</span>, <span class=\"string\">\"a\"</span>);\n<span class=\"macro\">assert_eq!</span>(map.last_key_value(), <span class=\"prelude-val\">Some</span>((<span class=\"kw-2\">&</span><span class=\"number\">2</span>, <span class=\"kw-2\">&</span><span class=\"string\">\"a\"</span>)));</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.last_entry\" class=\"method\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.66.0\">1.66.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/collections/btree/map.rs.html#862-864\">source</a></span><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html#tymethod.last_entry\" class=\"fn\">last_entry</a>(&mut self) -> <a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/core/option/enum.Option.html\" title=\"enum core::option::Option\">Option</a><<a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/entry/struct.OccupiedEntry.html\" title=\"struct alloc::collections::btree::map::entry::OccupiedEntry\">OccupiedEntry</a><'_, K, V, A>><div class=\"where\">where\n K: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html\" title=\"trait core::cmp::Ord\">Ord</a>,</div></h4></section></summary><div class=\"docblock\"><p>Returns the last entry in the map for in-place manipulation.\nThe key of this entry is the maximum key in the map.</p>\n<h5 id=\"examples-6\"><a class=\"doc-anchor\" href=\"#examples-6\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::collections::BTreeMap;\n\n<span class=\"kw\">let </span><span class=\"kw-2\">mut </span>map = BTreeMap::new();\nmap.insert(<span class=\"number\">1</span>, <span class=\"string\">\"a\"</span>);\nmap.insert(<span class=\"number\">2</span>, <span class=\"string\">\"b\"</span>);\n<span class=\"kw\">if let </span><span class=\"prelude-val\">Some</span>(<span class=\"kw-2\">mut </span>entry) = map.last_entry() {\n <span class=\"kw\">if </span><span class=\"kw-2\">*</span>entry.key() > <span class=\"number\">0 </span>{\n entry.insert(<span class=\"string\">\"last\"</span>);\n }\n}\n<span class=\"macro\">assert_eq!</span>(<span class=\"kw-2\">*</span>map.get(<span class=\"kw-2\">&</span><span class=\"number\">1</span>).unwrap(), <span class=\"string\">\"a\"</span>);\n<span class=\"macro\">assert_eq!</span>(<span class=\"kw-2\">*</span>map.get(<span class=\"kw-2\">&</span><span class=\"number\">2</span>).unwrap(), <span class=\"string\">\"last\"</span>);</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.pop_last\" class=\"method\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.66.0\">1.66.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/collections/btree/map.rs.html#896-898\">source</a></span><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html#tymethod.pop_last\" class=\"fn\">pop_last</a>(&mut self) -> <a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/core/option/enum.Option.html\" title=\"enum core::option::Option\">Option</a><<a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.tuple.html\">(K, V)</a>><div class=\"where\">where\n K: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html\" title=\"trait core::cmp::Ord\">Ord</a>,</div></h4></section></summary><div class=\"docblock\"><p>Removes and returns the last element in the map.\nThe key of this element is the maximum key that was in the map.</p>\n<h5 id=\"examples-7\"><a class=\"doc-anchor\" href=\"#examples-7\">§</a>Examples</h5>\n<p>Draining elements in descending order, while keeping a usable map each iteration.</p>\n\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::collections::BTreeMap;\n\n<span class=\"kw\">let </span><span class=\"kw-2\">mut </span>map = BTreeMap::new();\nmap.insert(<span class=\"number\">1</span>, <span class=\"string\">\"a\"</span>);\nmap.insert(<span class=\"number\">2</span>, <span class=\"string\">\"b\"</span>);\n<span class=\"kw\">while let </span><span class=\"prelude-val\">Some</span>((key, _val)) = map.pop_last() {\n <span class=\"macro\">assert!</span>(map.iter().all(|(k, _v)| <span class=\"kw-2\">*</span>k < key));\n}\n<span class=\"macro\">assert!</span>(map.is_empty());</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.contains_key\" class=\"method\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.0.0\">1.0.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/collections/btree/map.rs.html#919-922\">source</a></span><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html#tymethod.contains_key\" class=\"fn\">contains_key</a><Q>(&self, key: <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.reference.html\">&Q</a>) -> <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.bool.html\">bool</a><div class=\"where\">where\n K: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/borrow/trait.Borrow.html\" title=\"trait core::borrow::Borrow\">Borrow</a><Q> + <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html\" title=\"trait core::cmp::Ord\">Ord</a>,\n Q: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html\" title=\"trait core::cmp::Ord\">Ord</a> + ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,</div></h4></section></summary><div class=\"docblock\"><p>Returns <code>true</code> if the map contains a value for the specified key.</p>\n<p>The key may be any borrowed form of the map’s key type, but the ordering\non the borrowed form <em>must</em> match the ordering on the key type.</p>\n<h5 id=\"examples-8\"><a class=\"doc-anchor\" href=\"#examples-8\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::collections::BTreeMap;\n\n<span class=\"kw\">let </span><span class=\"kw-2\">mut </span>map = BTreeMap::new();\nmap.insert(<span class=\"number\">1</span>, <span class=\"string\">\"a\"</span>);\n<span class=\"macro\">assert_eq!</span>(map.contains_key(<span class=\"kw-2\">&</span><span class=\"number\">1</span>), <span class=\"bool-val\">true</span>);\n<span class=\"macro\">assert_eq!</span>(map.contains_key(<span class=\"kw-2\">&</span><span class=\"number\">2</span>), <span class=\"bool-val\">false</span>);</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.get_mut\" class=\"method\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.0.0\">1.0.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/collections/btree/map.rs.html#946-949\">source</a></span><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html#tymethod.get_mut\" class=\"fn\">get_mut</a><Q>(&mut self, key: <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.reference.html\">&Q</a>) -> <a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/core/option/enum.Option.html\" title=\"enum core::option::Option\">Option</a><<a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.reference.html\">&mut V</a>><div class=\"where\">where\n K: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/borrow/trait.Borrow.html\" title=\"trait core::borrow::Borrow\">Borrow</a><Q> + <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html\" title=\"trait core::cmp::Ord\">Ord</a>,\n Q: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html\" title=\"trait core::cmp::Ord\">Ord</a> + ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,</div></h4></section></summary><div class=\"docblock\"><p>Returns a mutable reference to the value corresponding to the key.</p>\n<p>The key may be any borrowed form of the map’s key type, but the ordering\non the borrowed form <em>must</em> match the ordering on the key type.</p>\n<h5 id=\"examples-9\"><a class=\"doc-anchor\" href=\"#examples-9\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::collections::BTreeMap;\n\n<span class=\"kw\">let </span><span class=\"kw-2\">mut </span>map = BTreeMap::new();\nmap.insert(<span class=\"number\">1</span>, <span class=\"string\">\"a\"</span>);\n<span class=\"kw\">if let </span><span class=\"prelude-val\">Some</span>(x) = map.get_mut(<span class=\"kw-2\">&</span><span class=\"number\">1</span>) {\n <span class=\"kw-2\">*</span>x = <span class=\"string\">\"b\"</span>;\n}\n<span class=\"macro\">assert_eq!</span>(map[<span class=\"kw-2\">&</span><span class=\"number\">1</span>], <span class=\"string\">\"b\"</span>);</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.insert\" class=\"method\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.0.0\">1.0.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/collections/btree/map.rs.html#984-986\">source</a></span><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html#tymethod.insert\" class=\"fn\">insert</a>(&mut self, key: K, value: V) -> <a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/core/option/enum.Option.html\" title=\"enum core::option::Option\">Option</a><V><div class=\"where\">where\n K: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html\" title=\"trait core::cmp::Ord\">Ord</a>,</div></h4></section></summary><div class=\"docblock\"><p>Inserts a key-value pair into the map.</p>\n<p>If the map did not have this key present, <code>None</code> is returned.</p>\n<p>If the map did have this key present, the value is updated, and the old\nvalue is returned. The key is not updated, though; this matters for\ntypes that can be <code>==</code> without being identical. See the <a href=\"index.html#insert-and-complex-keys\">module-level\ndocumentation</a> for more.</p>\n<h5 id=\"examples-10\"><a class=\"doc-anchor\" href=\"#examples-10\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::collections::BTreeMap;\n\n<span class=\"kw\">let </span><span class=\"kw-2\">mut </span>map = BTreeMap::new();\n<span class=\"macro\">assert_eq!</span>(map.insert(<span class=\"number\">37</span>, <span class=\"string\">\"a\"</span>), <span class=\"prelude-val\">None</span>);\n<span class=\"macro\">assert_eq!</span>(map.is_empty(), <span class=\"bool-val\">false</span>);\n\nmap.insert(<span class=\"number\">37</span>, <span class=\"string\">\"b\"</span>);\n<span class=\"macro\">assert_eq!</span>(map.insert(<span class=\"number\">37</span>, <span class=\"string\">\"c\"</span>), <span class=\"prelude-val\">Some</span>(<span class=\"string\">\"b\"</span>));\n<span class=\"macro\">assert_eq!</span>(map[<span class=\"kw-2\">&</span><span class=\"number\">37</span>], <span class=\"string\">\"c\"</span>);</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.try_insert\" class=\"method\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/collections/btree/map.rs.html#1019-1021\">source</a><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html#tymethod.try_insert\" class=\"fn\">try_insert</a>(\n &mut self,\n key: K,\n value: V\n) -> <a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/core/result/enum.Result.html\" title=\"enum core::result::Result\">Result</a><<a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.reference.html\">&mut V</a>, <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/entry/struct.OccupiedError.html\" title=\"struct alloc::collections::btree::map::entry::OccupiedError\">OccupiedError</a><'_, K, V, A>><div class=\"where\">where\n K: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html\" title=\"trait core::cmp::Ord\">Ord</a>,</div></h4></section><span class=\"item-info\"><div class=\"stab unstable\"><span class=\"emoji\">🔬</span><span>This is a nightly-only experimental API. (<code>map_try_insert</code>)</span></div></span></summary><div class=\"docblock\"><p>Tries to insert a key-value pair into the map, and returns\na mutable reference to the value in the entry.</p>\n<p>If the map already had this key present, nothing is updated, and\nan error containing the occupied entry and the value is returned.</p>\n<h5 id=\"examples-11\"><a class=\"doc-anchor\" href=\"#examples-11\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"attr\">#![feature(map_try_insert)]\n\n</span><span class=\"kw\">use </span>std::collections::BTreeMap;\n\n<span class=\"kw\">let </span><span class=\"kw-2\">mut </span>map = BTreeMap::new();\n<span class=\"macro\">assert_eq!</span>(map.try_insert(<span class=\"number\">37</span>, <span class=\"string\">\"a\"</span>).unwrap(), <span class=\"kw-2\">&</span><span class=\"string\">\"a\"</span>);\n\n<span class=\"kw\">let </span>err = map.try_insert(<span class=\"number\">37</span>, <span class=\"string\">\"b\"</span>).unwrap_err();\n<span class=\"macro\">assert_eq!</span>(err.entry.key(), <span class=\"kw-2\">&</span><span class=\"number\">37</span>);\n<span class=\"macro\">assert_eq!</span>(err.entry.get(), <span class=\"kw-2\">&</span><span class=\"string\">\"a\"</span>);\n<span class=\"macro\">assert_eq!</span>(err.value, <span class=\"string\">\"b\"</span>);</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.remove\" class=\"method\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.0.0\">1.0.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/collections/btree/map.rs.html#1047-1050\">source</a></span><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html#tymethod.remove\" class=\"fn\">remove</a><Q>(&mut self, key: <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.reference.html\">&Q</a>) -> <a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/core/option/enum.Option.html\" title=\"enum core::option::Option\">Option</a><V><div class=\"where\">where\n K: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/borrow/trait.Borrow.html\" title=\"trait core::borrow::Borrow\">Borrow</a><Q> + <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html\" title=\"trait core::cmp::Ord\">Ord</a>,\n Q: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html\" title=\"trait core::cmp::Ord\">Ord</a> + ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,</div></h4></section></summary><div class=\"docblock\"><p>Removes a key from the map, returning the value at the key if the key\nwas previously in the map.</p>\n<p>The key may be any borrowed form of the map’s key type, but the ordering\non the borrowed form <em>must</em> match the ordering on the key type.</p>\n<h5 id=\"examples-12\"><a class=\"doc-anchor\" href=\"#examples-12\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::collections::BTreeMap;\n\n<span class=\"kw\">let </span><span class=\"kw-2\">mut </span>map = BTreeMap::new();\nmap.insert(<span class=\"number\">1</span>, <span class=\"string\">\"a\"</span>);\n<span class=\"macro\">assert_eq!</span>(map.remove(<span class=\"kw-2\">&</span><span class=\"number\">1</span>), <span class=\"prelude-val\">Some</span>(<span class=\"string\">\"a\"</span>));\n<span class=\"macro\">assert_eq!</span>(map.remove(<span class=\"kw-2\">&</span><span class=\"number\">1</span>), <span class=\"prelude-val\">None</span>);</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.remove_entry\" class=\"method\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.45.0\">1.45.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/collections/btree/map.rs.html#1072-1075\">source</a></span><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html#tymethod.remove_entry\" class=\"fn\">remove_entry</a><Q>(&mut self, key: <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.reference.html\">&Q</a>) -> <a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/core/option/enum.Option.html\" title=\"enum core::option::Option\">Option</a><<a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.tuple.html\">(K, V)</a>><div class=\"where\">where\n K: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/borrow/trait.Borrow.html\" title=\"trait core::borrow::Borrow\">Borrow</a><Q> + <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html\" title=\"trait core::cmp::Ord\">Ord</a>,\n Q: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html\" title=\"trait core::cmp::Ord\">Ord</a> + ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,</div></h4></section></summary><div class=\"docblock\"><p>Removes a key from the map, returning the stored key and value if the key\nwas previously in the map.</p>\n<p>The key may be any borrowed form of the map’s key type, but the ordering\non the borrowed form <em>must</em> match the ordering on the key type.</p>\n<h5 id=\"examples-13\"><a class=\"doc-anchor\" href=\"#examples-13\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::collections::BTreeMap;\n\n<span class=\"kw\">let </span><span class=\"kw-2\">mut </span>map = BTreeMap::new();\nmap.insert(<span class=\"number\">1</span>, <span class=\"string\">\"a\"</span>);\n<span class=\"macro\">assert_eq!</span>(map.remove_entry(<span class=\"kw-2\">&</span><span class=\"number\">1</span>), <span class=\"prelude-val\">Some</span>((<span class=\"number\">1</span>, <span class=\"string\">\"a\"</span>)));\n<span class=\"macro\">assert_eq!</span>(map.remove_entry(<span class=\"kw-2\">&</span><span class=\"number\">1</span>), <span class=\"prelude-val\">None</span>);</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.retain\" class=\"method\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.53.0\">1.53.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/collections/btree/map.rs.html#1110-1113\">source</a></span><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html#tymethod.retain\" class=\"fn\">retain</a><F>(&mut self, f: F)<div class=\"where\">where\n K: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html\" title=\"trait core::cmp::Ord\">Ord</a>,\n F: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/ops/function/trait.FnMut.html\" title=\"trait core::ops::function::FnMut\">FnMut</a>(<a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.reference.html\">&K</a>, <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.reference.html\">&mut V</a>) -> <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.bool.html\">bool</a>,</div></h4></section></summary><div class=\"docblock\"><p>Retains only the elements specified by the predicate.</p>\n<p>In other words, remove all pairs <code>(k, v)</code> for which <code>f(&k, &mut v)</code> returns <code>false</code>.\nThe elements are visited in ascending key order.</p>\n<h5 id=\"examples-14\"><a class=\"doc-anchor\" href=\"#examples-14\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::collections::BTreeMap;\n\n<span class=\"kw\">let </span><span class=\"kw-2\">mut </span>map: BTreeMap<i32, i32> = (<span class=\"number\">0</span>..<span class=\"number\">8</span>).map(|x| (x, x<span class=\"kw-2\">*</span><span class=\"number\">10</span>)).collect();\n<span class=\"comment\">// Keep only the elements with even-numbered keys.\n</span>map.retain(|<span class=\"kw-2\">&</span>k, <span class=\"kw\">_</span>| k % <span class=\"number\">2 </span>== <span class=\"number\">0</span>);\n<span class=\"macro\">assert!</span>(map.into_iter().eq(<span class=\"macro\">vec!</span>[(<span class=\"number\">0</span>, <span class=\"number\">0</span>), (<span class=\"number\">2</span>, <span class=\"number\">20</span>), (<span class=\"number\">4</span>, <span class=\"number\">40</span>), (<span class=\"number\">6</span>, <span class=\"number\">60</span>)]));</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.append\" class=\"method\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.11.0\">1.11.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/collections/btree/map.rs.html#1150-1153\">source</a></span><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html#tymethod.append\" class=\"fn\">append</a>(&mut self, other: &mut <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html\" title=\"struct alloc::collections::btree::map::BTreeMap\">BTreeMap</a><K, V, A>)<div class=\"where\">where\n K: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html\" title=\"trait core::cmp::Ord\">Ord</a>,\n A: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/clone/trait.Clone.html\" title=\"trait core::clone::Clone\">Clone</a>,</div></h4></section></summary><div class=\"docblock\"><p>Moves all elements from <code>other</code> into <code>self</code>, leaving <code>other</code> empty.</p>\n<p>If a key from <code>other</code> is already present in <code>self</code>, the respective\nvalue from <code>self</code> will be overwritten with the respective value from <code>other</code>.</p>\n<h5 id=\"examples-15\"><a class=\"doc-anchor\" href=\"#examples-15\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::collections::BTreeMap;\n\n<span class=\"kw\">let </span><span class=\"kw-2\">mut </span>a = BTreeMap::new();\na.insert(<span class=\"number\">1</span>, <span class=\"string\">\"a\"</span>);\na.insert(<span class=\"number\">2</span>, <span class=\"string\">\"b\"</span>);\na.insert(<span class=\"number\">3</span>, <span class=\"string\">\"c\"</span>); <span class=\"comment\">// Note: Key (3) also present in b.\n\n</span><span class=\"kw\">let </span><span class=\"kw-2\">mut </span>b = BTreeMap::new();\nb.insert(<span class=\"number\">3</span>, <span class=\"string\">\"d\"</span>); <span class=\"comment\">// Note: Key (3) also present in a.\n</span>b.insert(<span class=\"number\">4</span>, <span class=\"string\">\"e\"</span>);\nb.insert(<span class=\"number\">5</span>, <span class=\"string\">\"f\"</span>);\n\na.append(<span class=\"kw-2\">&mut </span>b);\n\n<span class=\"macro\">assert_eq!</span>(a.len(), <span class=\"number\">5</span>);\n<span class=\"macro\">assert_eq!</span>(b.len(), <span class=\"number\">0</span>);\n\n<span class=\"macro\">assert_eq!</span>(a[<span class=\"kw-2\">&</span><span class=\"number\">1</span>], <span class=\"string\">\"a\"</span>);\n<span class=\"macro\">assert_eq!</span>(a[<span class=\"kw-2\">&</span><span class=\"number\">2</span>], <span class=\"string\">\"b\"</span>);\n<span class=\"macro\">assert_eq!</span>(a[<span class=\"kw-2\">&</span><span class=\"number\">3</span>], <span class=\"string\">\"d\"</span>); <span class=\"comment\">// Note: \"c\" has been overwritten.\n</span><span class=\"macro\">assert_eq!</span>(a[<span class=\"kw-2\">&</span><span class=\"number\">4</span>], <span class=\"string\">\"e\"</span>);\n<span class=\"macro\">assert_eq!</span>(a[<span class=\"kw-2\">&</span><span class=\"number\">5</span>], <span class=\"string\">\"f\"</span>);</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.range\" class=\"method\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.17.0\">1.17.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/collections/btree/map.rs.html#1205-1209\">source</a></span><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html#tymethod.range\" class=\"fn\">range</a><T, R>(&self, range: R) -> <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.Range.html\" title=\"struct alloc::collections::btree::map::Range\">Range</a><'_, K, V><div class=\"where\">where\n T: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html\" title=\"trait core::cmp::Ord\">Ord</a> + ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,\n K: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/borrow/trait.Borrow.html\" title=\"trait core::borrow::Borrow\">Borrow</a><T> + <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html\" title=\"trait core::cmp::Ord\">Ord</a>,\n R: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/ops/range/trait.RangeBounds.html\" title=\"trait core::ops::range::RangeBounds\">RangeBounds</a><T>,</div></h4></section></summary><div class=\"docblock\"><p>Constructs a double-ended iterator over a sub-range of elements in the map.\nThe simplest way is to use the range syntax <code>min..max</code>, thus <code>range(min..max)</code> will\nyield elements from min (inclusive) to max (exclusive).\nThe range may also be entered as <code>(Bound<T>, Bound<T>)</code>, so for example\n<code>range((Excluded(4), Included(10)))</code> will yield a left-exclusive, right-inclusive\nrange from 4 to 10.</p>\n<h5 id=\"panics\"><a class=\"doc-anchor\" href=\"#panics\">§</a>Panics</h5>\n<p>Panics if range <code>start > end</code>.\nPanics if range <code>start == end</code> and both bounds are <code>Excluded</code>.</p>\n<h5 id=\"examples-16\"><a class=\"doc-anchor\" href=\"#examples-16\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::collections::BTreeMap;\n<span class=\"kw\">use </span>std::ops::Bound::Included;\n\n<span class=\"kw\">let </span><span class=\"kw-2\">mut </span>map = BTreeMap::new();\nmap.insert(<span class=\"number\">3</span>, <span class=\"string\">\"a\"</span>);\nmap.insert(<span class=\"number\">5</span>, <span class=\"string\">\"b\"</span>);\nmap.insert(<span class=\"number\">8</span>, <span class=\"string\">\"c\"</span>);\n<span class=\"kw\">for </span>(<span class=\"kw-2\">&</span>key, <span class=\"kw-2\">&</span>value) <span class=\"kw\">in </span>map.range((Included(<span class=\"kw-2\">&</span><span class=\"number\">4</span>), Included(<span class=\"kw-2\">&</span><span class=\"number\">8</span>))) {\n <span class=\"macro\">println!</span>(<span class=\"string\">\"{key}: {value}\"</span>);\n}\n<span class=\"macro\">assert_eq!</span>(<span class=\"prelude-val\">Some</span>((<span class=\"kw-2\">&</span><span class=\"number\">5</span>, <span class=\"kw-2\">&</span><span class=\"string\">\"b\"</span>)), map.range(<span class=\"number\">4</span>..).next());</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.range_mut\" class=\"method\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.17.0\">1.17.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/collections/btree/map.rs.html#1245-1249\">source</a></span><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html#tymethod.range_mut\" class=\"fn\">range_mut</a><T, R>(&mut self, range: R) -> <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.RangeMut.html\" title=\"struct alloc::collections::btree::map::RangeMut\">RangeMut</a><'_, K, V><div class=\"where\">where\n T: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html\" title=\"trait core::cmp::Ord\">Ord</a> + ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,\n K: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/borrow/trait.Borrow.html\" title=\"trait core::borrow::Borrow\">Borrow</a><T> + <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html\" title=\"trait core::cmp::Ord\">Ord</a>,\n R: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/ops/range/trait.RangeBounds.html\" title=\"trait core::ops::range::RangeBounds\">RangeBounds</a><T>,</div></h4></section></summary><div class=\"docblock\"><p>Constructs a mutable double-ended iterator over a sub-range of elements in the map.\nThe simplest way is to use the range syntax <code>min..max</code>, thus <code>range(min..max)</code> will\nyield elements from min (inclusive) to max (exclusive).\nThe range may also be entered as <code>(Bound<T>, Bound<T>)</code>, so for example\n<code>range((Excluded(4), Included(10)))</code> will yield a left-exclusive, right-inclusive\nrange from 4 to 10.</p>\n<h5 id=\"panics-1\"><a class=\"doc-anchor\" href=\"#panics-1\">§</a>Panics</h5>\n<p>Panics if range <code>start > end</code>.\nPanics if range <code>start == end</code> and both bounds are <code>Excluded</code>.</p>\n<h5 id=\"examples-17\"><a class=\"doc-anchor\" href=\"#examples-17\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::collections::BTreeMap;\n\n<span class=\"kw\">let </span><span class=\"kw-2\">mut </span>map: BTreeMap<<span class=\"kw-2\">&</span>str, i32> =\n [(<span class=\"string\">\"Alice\"</span>, <span class=\"number\">0</span>), (<span class=\"string\">\"Bob\"</span>, <span class=\"number\">0</span>), (<span class=\"string\">\"Carol\"</span>, <span class=\"number\">0</span>), (<span class=\"string\">\"Cheryl\"</span>, <span class=\"number\">0</span>)].into();\n<span class=\"kw\">for </span>(<span class=\"kw\">_</span>, balance) <span class=\"kw\">in </span>map.range_mut(<span class=\"string\">\"B\"</span>..<span class=\"string\">\"Cheryl\"</span>) {\n <span class=\"kw-2\">*</span>balance += <span class=\"number\">100</span>;\n}\n<span class=\"kw\">for </span>(name, balance) <span class=\"kw\">in </span><span class=\"kw-2\">&</span>map {\n <span class=\"macro\">println!</span>(<span class=\"string\">\"{name} => {balance}\"</span>);\n}</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.entry\" class=\"method\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.0.0\">1.0.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/collections/btree/map.rs.html#1277-1279\">source</a></span><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html#tymethod.entry\" class=\"fn\">entry</a>(&mut self, key: K) -> <a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/entry/enum.Entry.html\" title=\"enum alloc::collections::btree::map::entry::Entry\">Entry</a><'_, K, V, A><div class=\"where\">where\n K: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html\" title=\"trait core::cmp::Ord\">Ord</a>,</div></h4></section></summary><div class=\"docblock\"><p>Gets the given key’s corresponding entry in the map for in-place manipulation.</p>\n<h5 id=\"examples-18\"><a class=\"doc-anchor\" href=\"#examples-18\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::collections::BTreeMap;\n\n<span class=\"kw\">let </span><span class=\"kw-2\">mut </span>count: BTreeMap<<span class=\"kw-2\">&</span>str, usize> = BTreeMap::new();\n\n<span class=\"comment\">// count the number of occurrences of letters in the vec\n</span><span class=\"kw\">for </span>x <span class=\"kw\">in </span>[<span class=\"string\">\"a\"</span>, <span class=\"string\">\"b\"</span>, <span class=\"string\">\"a\"</span>, <span class=\"string\">\"c\"</span>, <span class=\"string\">\"a\"</span>, <span class=\"string\">\"b\"</span>] {\n count.entry(x).and_modify(|curr| <span class=\"kw-2\">*</span>curr += <span class=\"number\">1</span>).or_insert(<span class=\"number\">1</span>);\n}\n\n<span class=\"macro\">assert_eq!</span>(count[<span class=\"string\">\"a\"</span>], <span class=\"number\">3</span>);\n<span class=\"macro\">assert_eq!</span>(count[<span class=\"string\">\"b\"</span>], <span class=\"number\">2</span>);\n<span class=\"macro\">assert_eq!</span>(count[<span class=\"string\">\"c\"</span>], <span class=\"number\">1</span>);</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.split_off\" class=\"method\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.11.0\">1.11.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/collections/btree/map.rs.html#1336-1339\">source</a></span><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html#tymethod.split_off\" class=\"fn\">split_off</a><Q>(&mut self, key: <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.reference.html\">&Q</a>) -> <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html\" title=\"struct alloc::collections::btree::map::BTreeMap\">BTreeMap</a><K, V, A><div class=\"where\">where\n Q: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html\" title=\"trait core::cmp::Ord\">Ord</a> + ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,\n K: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/borrow/trait.Borrow.html\" title=\"trait core::borrow::Borrow\">Borrow</a><Q> + <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html\" title=\"trait core::cmp::Ord\">Ord</a>,\n A: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/clone/trait.Clone.html\" title=\"trait core::clone::Clone\">Clone</a>,</div></h4></section></summary><div class=\"docblock\"><p>Splits the collection into two at the given key. Returns everything after the given key,\nincluding the key.</p>\n<h5 id=\"examples-19\"><a class=\"doc-anchor\" href=\"#examples-19\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::collections::BTreeMap;\n\n<span class=\"kw\">let </span><span class=\"kw-2\">mut </span>a = BTreeMap::new();\na.insert(<span class=\"number\">1</span>, <span class=\"string\">\"a\"</span>);\na.insert(<span class=\"number\">2</span>, <span class=\"string\">\"b\"</span>);\na.insert(<span class=\"number\">3</span>, <span class=\"string\">\"c\"</span>);\na.insert(<span class=\"number\">17</span>, <span class=\"string\">\"d\"</span>);\na.insert(<span class=\"number\">41</span>, <span class=\"string\">\"e\"</span>);\n\n<span class=\"kw\">let </span>b = a.split_off(<span class=\"kw-2\">&</span><span class=\"number\">3</span>);\n\n<span class=\"macro\">assert_eq!</span>(a.len(), <span class=\"number\">2</span>);\n<span class=\"macro\">assert_eq!</span>(b.len(), <span class=\"number\">3</span>);\n\n<span class=\"macro\">assert_eq!</span>(a[<span class=\"kw-2\">&</span><span class=\"number\">1</span>], <span class=\"string\">\"a\"</span>);\n<span class=\"macro\">assert_eq!</span>(a[<span class=\"kw-2\">&</span><span class=\"number\">2</span>], <span class=\"string\">\"b\"</span>);\n\n<span class=\"macro\">assert_eq!</span>(b[<span class=\"kw-2\">&</span><span class=\"number\">3</span>], <span class=\"string\">\"c\"</span>);\n<span class=\"macro\">assert_eq!</span>(b[<span class=\"kw-2\">&</span><span class=\"number\">17</span>], <span class=\"string\">\"d\"</span>);\n<span class=\"macro\">assert_eq!</span>(b[<span class=\"kw-2\">&</span><span class=\"number\">41</span>], <span class=\"string\">\"e\"</span>);</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.extract_if\" class=\"method\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/collections/btree/map.rs.html#1391-1394\">source</a><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html#tymethod.extract_if\" class=\"fn\">extract_if</a><F>(&mut self, pred: F) -> <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.ExtractIf.html\" title=\"struct alloc::collections::btree::map::ExtractIf\">ExtractIf</a><'_, K, V, F, A><div class=\"where\">where\n K: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html\" title=\"trait core::cmp::Ord\">Ord</a>,\n F: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/ops/function/trait.FnMut.html\" title=\"trait core::ops::function::FnMut\">FnMut</a>(<a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.reference.html\">&K</a>, <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.reference.html\">&mut V</a>) -> <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.bool.html\">bool</a>,</div></h4></section><span class=\"item-info\"><div class=\"stab unstable\"><span class=\"emoji\">🔬</span><span>This is a nightly-only experimental API. (<code>btree_extract_if</code>)</span></div></span></summary><div class=\"docblock\"><p>Creates an iterator that visits all elements (key-value pairs) in\nascending key order and uses a closure to determine if an element should\nbe removed. If the closure returns <code>true</code>, the element is removed from\nthe map and yielded. If the closure returns <code>false</code>, or panics, the\nelement remains in the map and will not be yielded.</p>\n<p>The iterator also lets you mutate the value of each element in the\nclosure, regardless of whether you choose to keep or remove it.</p>\n<p>If the returned <code>ExtractIf</code> is not exhausted, e.g. because it is dropped without iterating\nor the iteration short-circuits, then the remaining elements will be retained.\nUse <a href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html#method.retain\" title=\"method alloc::collections::btree::map::BTreeMap::retain\"><code>retain</code></a> with a negated predicate if you do not need the returned iterator.</p>\n<h5 id=\"examples-20\"><a class=\"doc-anchor\" href=\"#examples-20\">§</a>Examples</h5>\n<p>Splitting a map into even and odd keys, reusing the original map:</p>\n\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"attr\">#![feature(btree_extract_if)]\n</span><span class=\"kw\">use </span>std::collections::BTreeMap;\n\n<span class=\"kw\">let </span><span class=\"kw-2\">mut </span>map: BTreeMap<i32, i32> = (<span class=\"number\">0</span>..<span class=\"number\">8</span>).map(|x| (x, x)).collect();\n<span class=\"kw\">let </span>evens: BTreeMap<<span class=\"kw\">_</span>, <span class=\"kw\">_</span>> = map.extract_if(|k, _v| k % <span class=\"number\">2 </span>== <span class=\"number\">0</span>).collect();\n<span class=\"kw\">let </span>odds = map;\n<span class=\"macro\">assert_eq!</span>(evens.keys().copied().collect::<Vec<<span class=\"kw\">_</span>>>(), [<span class=\"number\">0</span>, <span class=\"number\">2</span>, <span class=\"number\">4</span>, <span class=\"number\">6</span>]);\n<span class=\"macro\">assert_eq!</span>(odds.keys().copied().collect::<Vec<<span class=\"kw\">_</span>>>(), [<span class=\"number\">1</span>, <span class=\"number\">3</span>, <span class=\"number\">5</span>, <span class=\"number\">7</span>]);</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.into_keys\" class=\"method\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.54.0\">1.54.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/collections/btree/map.rs.html#1445\">source</a></span><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html#tymethod.into_keys\" class=\"fn\">into_keys</a>(self) -> <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.IntoKeys.html\" title=\"struct alloc::collections::btree::map::IntoKeys\">IntoKeys</a><K, V, A></h4></section></summary><div class=\"docblock\"><p>Creates a consuming iterator visiting all the keys, in sorted order.\nThe map cannot be used after calling this.\nThe iterator element type is <code>K</code>.</p>\n<h5 id=\"examples-21\"><a class=\"doc-anchor\" href=\"#examples-21\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::collections::BTreeMap;\n\n<span class=\"kw\">let </span><span class=\"kw-2\">mut </span>a = BTreeMap::new();\na.insert(<span class=\"number\">2</span>, <span class=\"string\">\"b\"</span>);\na.insert(<span class=\"number\">1</span>, <span class=\"string\">\"a\"</span>);\n\n<span class=\"kw\">let </span>keys: Vec<i32> = a.into_keys().collect();\n<span class=\"macro\">assert_eq!</span>(keys, [<span class=\"number\">1</span>, <span class=\"number\">2</span>]);</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.into_values\" class=\"method\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.54.0\">1.54.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/collections/btree/map.rs.html#1467\">source</a></span><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html#tymethod.into_values\" class=\"fn\">into_values</a>(self) -> <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.IntoValues.html\" title=\"struct alloc::collections::btree::map::IntoValues\">IntoValues</a><K, V, A></h4></section></summary><div class=\"docblock\"><p>Creates a consuming iterator visiting all the values, in order by key.\nThe map cannot be used after calling this.\nThe iterator element type is <code>V</code>.</p>\n<h5 id=\"examples-22\"><a class=\"doc-anchor\" href=\"#examples-22\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::collections::BTreeMap;\n\n<span class=\"kw\">let </span><span class=\"kw-2\">mut </span>a = BTreeMap::new();\na.insert(<span class=\"number\">1</span>, <span class=\"string\">\"hello\"</span>);\na.insert(<span class=\"number\">2</span>, <span class=\"string\">\"goodbye\"</span>);\n\n<span class=\"kw\">let </span>values: Vec<<span class=\"kw-2\">&</span>str> = a.into_values().collect();\n<span class=\"macro\">assert_eq!</span>(values, [<span class=\"string\">\"hello\"</span>, <span class=\"string\">\"goodbye\"</span>]);</code></pre></div>\n</div></details></div></details>",0,"bdk_wallet::descriptor::policy::ConditionMap","bdk_wallet::descriptor::policy::FoldedConditionMap","bdk_wallet::descriptor::HdKeyPaths","bdk_wallet::descriptor::TapKeyOrigins","bdk_wallet::keys::KeyMap"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-Clone-for-BTreeMap%3CK,+V,+A%3E\" class=\"impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.0.0\">1.0.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/collections/btree/map.rs.html#207\">source</a></span><a href=\"#impl-Clone-for-BTreeMap%3CK,+V,+A%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl<K, V, A> <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/clone/trait.Clone.html\" title=\"trait core::clone::Clone\">Clone</a> for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html\" title=\"struct alloc::collections::btree::map::BTreeMap\">BTreeMap</a><K, V, A><div class=\"where\">where\n K: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/clone/trait.Clone.html\" title=\"trait core::clone::Clone\">Clone</a>,\n V: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/clone/trait.Clone.html\" title=\"trait core::clone::Clone\">Clone</a>,\n A: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/alloc/trait.Allocator.html\" title=\"trait core::alloc::Allocator\">Allocator</a> + <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/clone/trait.Clone.html\" title=\"trait core::clone::Clone\">Clone</a>,</div></h3></section></summary><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.clone\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/collections/btree/map.rs.html#208\">source</a><a href=\"#method.clone\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/clone/trait.Clone.html#tymethod.clone\" class=\"fn\">clone</a>(&self) -> <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html\" title=\"struct alloc::collections::btree::map::BTreeMap\">BTreeMap</a><K, V, A></h4></section></summary><div class='docblock'>Returns a copy of the value. <a href=\"https://doc.rust-lang.org/nightly/core/clone/trait.Clone.html#tymethod.clone\">Read more</a></div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.clone_from\" class=\"method trait-impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.0.0\">1.0.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/core/clone.rs.html#169\">source</a></span><a href=\"#method.clone_from\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/clone/trait.Clone.html#method.clone_from\" class=\"fn\">clone_from</a>(&mut self, source: <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.reference.html\">&Self</a>)</h4></section></summary><div class='docblock'>Performs copy-assignment from <code>source</code>. <a href=\"https://doc.rust-lang.org/nightly/core/clone/trait.Clone.html#method.clone_from\">Read more</a></div></details></div></details>","Clone","bdk_wallet::descriptor::policy::ConditionMap","bdk_wallet::descriptor::policy::FoldedConditionMap","bdk_wallet::descriptor::HdKeyPaths","bdk_wallet::descriptor::TapKeyOrigins","bdk_wallet::keys::KeyMap"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-Debug-for-BTreeMap%3CK,+V,+A%3E\" class=\"impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.0.0\">1.0.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/collections/btree/map.rs.html#2312\">source</a></span><a href=\"#impl-Debug-for-BTreeMap%3CK,+V,+A%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl<K, V, A> <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/fmt/trait.Debug.html\" title=\"trait core::fmt::Debug\">Debug</a> for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html\" title=\"struct alloc::collections::btree::map::BTreeMap\">BTreeMap</a><K, V, A><div class=\"where\">where\n K: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/fmt/trait.Debug.html\" title=\"trait core::fmt::Debug\">Debug</a>,\n V: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/fmt/trait.Debug.html\" title=\"trait core::fmt::Debug\">Debug</a>,\n A: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/alloc/trait.Allocator.html\" title=\"trait core::alloc::Allocator\">Allocator</a> + <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/clone/trait.Clone.html\" title=\"trait core::clone::Clone\">Clone</a>,</div></h3></section></summary><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.fmt\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/collections/btree/map.rs.html#2313\">source</a><a href=\"#method.fmt\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/fmt/trait.Debug.html#tymethod.fmt\" class=\"fn\">fmt</a>(&self, f: &mut <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/core/fmt/struct.Formatter.html\" title=\"struct core::fmt::Formatter\">Formatter</a><'_>) -> <a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/core/result/enum.Result.html\" title=\"enum core::result::Result\">Result</a><<a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.unit.html\">()</a>, <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/core/fmt/struct.Error.html\" title=\"struct core::fmt::Error\">Error</a>></h4></section></summary><div class='docblock'>Formats the value using the given formatter. <a href=\"https://doc.rust-lang.org/nightly/core/fmt/trait.Debug.html#tymethod.fmt\">Read more</a></div></details></div></details>","Debug","bdk_wallet::descriptor::policy::ConditionMap","bdk_wallet::descriptor::policy::FoldedConditionMap","bdk_wallet::descriptor::HdKeyPaths","bdk_wallet::descriptor::TapKeyOrigins","bdk_wallet::keys::KeyMap"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-Default-for-BTreeMap%3CK,+V%3E\" class=\"impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.0.0\">1.0.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/collections/btree/map.rs.html#2278\">source</a></span><a href=\"#impl-Default-for-BTreeMap%3CK,+V%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl<K, V> <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/default/trait.Default.html\" title=\"trait core::default::Default\">Default</a> for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html\" title=\"struct alloc::collections::btree::map::BTreeMap\">BTreeMap</a><K, V></h3></section></summary><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.default\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/collections/btree/map.rs.html#2280\">source</a><a href=\"#method.default\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/default/trait.Default.html#tymethod.default\" class=\"fn\">default</a>() -> <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html\" title=\"struct alloc::collections::btree::map::BTreeMap\">BTreeMap</a><K, V></h4></section></summary><div class=\"docblock\"><p>Creates an empty <code>BTreeMap</code>.</p>\n</div></details></div></details>","Default","bdk_wallet::descriptor::policy::ConditionMap","bdk_wallet::descriptor::policy::FoldedConditionMap","bdk_wallet::descriptor::HdKeyPaths","bdk_wallet::descriptor::TapKeyOrigins","bdk_wallet::keys::KeyMap"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-Deserialize%3C'de%3E-for-BTreeMap%3CK,+V%3E\" class=\"impl\"><a class=\"src rightside\" href=\"https://docs.rs/serde/1.0.203/src/serde/de/impls.rs.html#1568-1574\">source</a><a href=\"#impl-Deserialize%3C'de%3E-for-BTreeMap%3CK,+V%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl<'de, K, V> <a class=\"trait\" href=\"https://docs.rs/serde/1.0.203/serde/de/trait.Deserialize.html\" title=\"trait serde::de::Deserialize\">Deserialize</a><'de> for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html\" title=\"struct alloc::collections::btree::map::BTreeMap\">BTreeMap</a><K, V><div class=\"where\">where\n K: <a class=\"trait\" href=\"https://docs.rs/serde/1.0.203/serde/de/trait.Deserialize.html\" title=\"trait serde::de::Deserialize\">Deserialize</a><'de> + <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html\" title=\"trait core::cmp::Ord\">Ord</a>,\n V: <a class=\"trait\" href=\"https://docs.rs/serde/1.0.203/serde/de/trait.Deserialize.html\" title=\"trait serde::de::Deserialize\">Deserialize</a><'de>,</div></h3></section></summary><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.deserialize\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://docs.rs/serde/1.0.203/src/serde/de/impls.rs.html#1568-1574\">source</a><a href=\"#method.deserialize\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://docs.rs/serde/1.0.203/serde/de/trait.Deserialize.html#tymethod.deserialize\" class=\"fn\">deserialize</a><D>(\n deserializer: D\n) -> <a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/core/result/enum.Result.html\" title=\"enum core::result::Result\">Result</a><<a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html\" title=\"struct alloc::collections::btree::map::BTreeMap\">BTreeMap</a><K, V>, <D as <a class=\"trait\" href=\"https://docs.rs/serde/1.0.203/serde/de/trait.Deserializer.html\" title=\"trait serde::de::Deserializer\">Deserializer</a><'de>>::<a class=\"associatedtype\" href=\"https://docs.rs/serde/1.0.203/serde/de/trait.Deserializer.html#associatedtype.Error\" title=\"type serde::de::Deserializer::Error\">Error</a>><div class=\"where\">where\n D: <a class=\"trait\" href=\"https://docs.rs/serde/1.0.203/serde/de/trait.Deserializer.html\" title=\"trait serde::de::Deserializer\">Deserializer</a><'de>,</div></h4></section></summary><div class='docblock'>Deserialize this value from the given Serde deserializer. <a href=\"https://docs.rs/serde/1.0.203/serde/de/trait.Deserialize.html#tymethod.deserialize\">Read more</a></div></details></div></details>","Deserialize<'de>","bdk_wallet::descriptor::policy::ConditionMap","bdk_wallet::descriptor::policy::FoldedConditionMap","bdk_wallet::descriptor::HdKeyPaths","bdk_wallet::descriptor::TapKeyOrigins","bdk_wallet::keys::KeyMap"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-Drop-for-BTreeMap%3CK,+V,+A%3E\" class=\"impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.7.0\">1.7.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/collections/btree/map.rs.html#187\">source</a></span><a href=\"#impl-Drop-for-BTreeMap%3CK,+V,+A%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl<K, V, A> <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/ops/drop/trait.Drop.html\" title=\"trait core::ops::drop::Drop\">Drop</a> for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html\" title=\"struct alloc::collections::btree::map::BTreeMap\">BTreeMap</a><K, V, A><div class=\"where\">where\n A: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/alloc/trait.Allocator.html\" title=\"trait core::alloc::Allocator\">Allocator</a> + <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/clone/trait.Clone.html\" title=\"trait core::clone::Clone\">Clone</a>,</div></h3></section></summary><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.drop\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/collections/btree/map.rs.html#188\">source</a><a href=\"#method.drop\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/ops/drop/trait.Drop.html#tymethod.drop\" class=\"fn\">drop</a>(&mut self)</h4></section></summary><div class='docblock'>Executes the destructor for this type. <a href=\"https://doc.rust-lang.org/nightly/core/ops/drop/trait.Drop.html#tymethod.drop\">Read more</a></div></details></div></details>","Drop","bdk_wallet::descriptor::policy::ConditionMap","bdk_wallet::descriptor::policy::FoldedConditionMap","bdk_wallet::descriptor::HdKeyPaths","bdk_wallet::descriptor::TapKeyOrigins","bdk_wallet::keys::KeyMap"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-Extend%3C(%26K,+%26V)%3E-for-BTreeMap%3CK,+V,+A%3E\" class=\"impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.2.0\">1.2.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/collections/btree/map.rs.html#2254-2255\">source</a></span><a href=\"#impl-Extend%3C(%26K,+%26V)%3E-for-BTreeMap%3CK,+V,+A%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl<'a, K, V, A> <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/iter/traits/collect/trait.Extend.html\" title=\"trait core::iter::traits::collect::Extend\">Extend</a><(<a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.reference.html\">&'a K</a>, <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.reference.html\">&'a V</a>)> for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html\" title=\"struct alloc::collections::btree::map::BTreeMap\">BTreeMap</a><K, V, A><div class=\"where\">where\n K: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html\" title=\"trait core::cmp::Ord\">Ord</a> + <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Copy.html\" title=\"trait core::marker::Copy\">Copy</a>,\n V: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Copy.html\" title=\"trait core::marker::Copy\">Copy</a>,\n A: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/alloc/trait.Allocator.html\" title=\"trait core::alloc::Allocator\">Allocator</a> + <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/clone/trait.Clone.html\" title=\"trait core::clone::Clone\">Clone</a>,</div></h3></section></summary><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.extend\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/collections/btree/map.rs.html#2257\">source</a><a href=\"#method.extend\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/iter/traits/collect/trait.Extend.html#tymethod.extend\" class=\"fn\">extend</a><I>(&mut self, iter: I)<div class=\"where\">where\n I: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/iter/traits/collect/trait.IntoIterator.html\" title=\"trait core::iter::traits::collect::IntoIterator\">IntoIterator</a><Item = (<a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.reference.html\">&'a K</a>, <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.reference.html\">&'a V</a>)>,</div></h4></section></summary><div class='docblock'>Extends a collection with the contents of an iterator. <a href=\"https://doc.rust-lang.org/nightly/core/iter/traits/collect/trait.Extend.html#tymethod.extend\">Read more</a></div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.extend_one\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/collections/btree/map.rs.html#2262\">source</a><a href=\"#method.extend_one\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/iter/traits/collect/trait.Extend.html#method.extend_one\" class=\"fn\">extend_one</a>(&mut self, _: (<a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.reference.html\">&'a K</a>, <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.reference.html\">&'a V</a>))</h4></section></summary><span class=\"item-info\"><div class=\"stab unstable\"><span class=\"emoji\">🔬</span><span>This is a nightly-only experimental API. (<code>extend_one</code>)</span></div></span><div class='docblock'>Extends a collection with exactly one element.</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.extend_reserve\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/core/iter/traits/collect.rs.html#460\">source</a><a href=\"#method.extend_reserve\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/iter/traits/collect/trait.Extend.html#method.extend_reserve\" class=\"fn\">extend_reserve</a>(&mut self, additional: <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.usize.html\">usize</a>)</h4></section></summary><span class=\"item-info\"><div class=\"stab unstable\"><span class=\"emoji\">🔬</span><span>This is a nightly-only experimental API. (<code>extend_one</code>)</span></div></span><div class='docblock'>Reserves capacity in a collection for the given number of additional elements. <a href=\"https://doc.rust-lang.org/nightly/core/iter/traits/collect/trait.Extend.html#method.extend_reserve\">Read more</a></div></details></div></details>","Extend<(&'a K, &'a V)>","bdk_wallet::descriptor::policy::ConditionMap","bdk_wallet::descriptor::policy::FoldedConditionMap","bdk_wallet::descriptor::HdKeyPaths","bdk_wallet::descriptor::TapKeyOrigins","bdk_wallet::keys::KeyMap"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-Extend%3C(K,+V)%3E-for-BTreeMap%3CK,+V,+A%3E\" class=\"impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.0.0\">1.0.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/collections/btree/map.rs.html#2239\">source</a></span><a href=\"#impl-Extend%3C(K,+V)%3E-for-BTreeMap%3CK,+V,+A%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl<K, V, A> <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/iter/traits/collect/trait.Extend.html\" title=\"trait core::iter::traits::collect::Extend\">Extend</a><<a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.tuple.html\">(K, V)</a>> for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html\" title=\"struct alloc::collections::btree::map::BTreeMap\">BTreeMap</a><K, V, A><div class=\"where\">where\n K: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html\" title=\"trait core::cmp::Ord\">Ord</a>,\n A: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/alloc/trait.Allocator.html\" title=\"trait core::alloc::Allocator\">Allocator</a> + <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/clone/trait.Clone.html\" title=\"trait core::clone::Clone\">Clone</a>,</div></h3></section></summary><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.extend\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/collections/btree/map.rs.html#2241\">source</a><a href=\"#method.extend\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/iter/traits/collect/trait.Extend.html#tymethod.extend\" class=\"fn\">extend</a><T>(&mut self, iter: T)<div class=\"where\">where\n T: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/iter/traits/collect/trait.IntoIterator.html\" title=\"trait core::iter::traits::collect::IntoIterator\">IntoIterator</a><Item = <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.tuple.html\">(K, V)</a>>,</div></h4></section></summary><div class='docblock'>Extends a collection with the contents of an iterator. <a href=\"https://doc.rust-lang.org/nightly/core/iter/traits/collect/trait.Extend.html#tymethod.extend\">Read more</a></div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.extend_one\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/collections/btree/map.rs.html#2248\">source</a><a href=\"#method.extend_one\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/iter/traits/collect/trait.Extend.html#method.extend_one\" class=\"fn\">extend_one</a>(&mut self, _: <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.tuple.html\">(K, V)</a>)</h4></section></summary><span class=\"item-info\"><div class=\"stab unstable\"><span class=\"emoji\">🔬</span><span>This is a nightly-only experimental API. (<code>extend_one</code>)</span></div></span><div class='docblock'>Extends a collection with exactly one element.</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.extend_reserve\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/core/iter/traits/collect.rs.html#460\">source</a><a href=\"#method.extend_reserve\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/iter/traits/collect/trait.Extend.html#method.extend_reserve\" class=\"fn\">extend_reserve</a>(&mut self, additional: <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.usize.html\">usize</a>)</h4></section></summary><span class=\"item-info\"><div class=\"stab unstable\"><span class=\"emoji\">🔬</span><span>This is a nightly-only experimental API. (<code>extend_one</code>)</span></div></span><div class='docblock'>Reserves capacity in a collection for the given number of additional elements. <a href=\"https://doc.rust-lang.org/nightly/core/iter/traits/collect/trait.Extend.html#method.extend_reserve\">Read more</a></div></details></div></details>","Extend<(K, V)>","bdk_wallet::descriptor::policy::ConditionMap","bdk_wallet::descriptor::policy::FoldedConditionMap","bdk_wallet::descriptor::HdKeyPaths","bdk_wallet::descriptor::TapKeyOrigins","bdk_wallet::keys::KeyMap"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-From%3C%5B(K,+V);+N%5D%3E-for-BTreeMap%3CK,+V%3E\" class=\"impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.56.0\">1.56.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/collections/btree/map.rs.html#2338\">source</a></span><a href=\"#impl-From%3C%5B(K,+V);+N%5D%3E-for-BTreeMap%3CK,+V%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl<K, V, const N: <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.usize.html\">usize</a>> <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/convert/trait.From.html\" title=\"trait core::convert::From\">From</a><[<a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.tuple.html\">(K, V)</a>; <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.array.html\">N</a>]> for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html\" title=\"struct alloc::collections::btree::map::BTreeMap\">BTreeMap</a><K, V><div class=\"where\">where\n K: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html\" title=\"trait core::cmp::Ord\">Ord</a>,</div></h3></section></summary><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.from\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/collections/btree/map.rs.html#2348\">source</a><a href=\"#method.from\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/convert/trait.From.html#tymethod.from\" class=\"fn\">from</a>(arr: [<a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.tuple.html\">(K, V)</a>; <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.array.html\">N</a>]) -> <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html\" title=\"struct alloc::collections::btree::map::BTreeMap\">BTreeMap</a><K, V></h4></section></summary><div class=\"docblock\"><p>Converts a <code>[(K, V); N]</code> into a <code>BTreeMap<(K, V)></code>.</p>\n\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::collections::BTreeMap;\n\n<span class=\"kw\">let </span>map1 = BTreeMap::from([(<span class=\"number\">1</span>, <span class=\"number\">2</span>), (<span class=\"number\">3</span>, <span class=\"number\">4</span>)]);\n<span class=\"kw\">let </span>map2: BTreeMap<<span class=\"kw\">_</span>, <span class=\"kw\">_</span>> = [(<span class=\"number\">1</span>, <span class=\"number\">2</span>), (<span class=\"number\">3</span>, <span class=\"number\">4</span>)].into();\n<span class=\"macro\">assert_eq!</span>(map1, map2);</code></pre></div>\n</div></details></div></details>","From<[(K, V); N]>","bdk_wallet::descriptor::policy::ConditionMap","bdk_wallet::descriptor::policy::FoldedConditionMap","bdk_wallet::descriptor::HdKeyPaths","bdk_wallet::descriptor::TapKeyOrigins","bdk_wallet::keys::KeyMap"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-FromIterator%3C(K,+V)%3E-for-BTreeMap%3CK,+V%3E\" class=\"impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.0.0\">1.0.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/collections/btree/map.rs.html#2224\">source</a></span><a href=\"#impl-FromIterator%3C(K,+V)%3E-for-BTreeMap%3CK,+V%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl<K, V> <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/iter/traits/collect/trait.FromIterator.html\" title=\"trait core::iter::traits::collect::FromIterator\">FromIterator</a><<a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.tuple.html\">(K, V)</a>> for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html\" title=\"struct alloc::collections::btree::map::BTreeMap\">BTreeMap</a><K, V><div class=\"where\">where\n K: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html\" title=\"trait core::cmp::Ord\">Ord</a>,</div></h3></section></summary><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.from_iter\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/collections/btree/map.rs.html#2225\">source</a><a href=\"#method.from_iter\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/iter/traits/collect/trait.FromIterator.html#tymethod.from_iter\" class=\"fn\">from_iter</a><T>(iter: T) -> <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html\" title=\"struct alloc::collections::btree::map::BTreeMap\">BTreeMap</a><K, V><div class=\"where\">where\n T: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/iter/traits/collect/trait.IntoIterator.html\" title=\"trait core::iter::traits::collect::IntoIterator\">IntoIterator</a><Item = <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.tuple.html\">(K, V)</a>>,</div></h4></section></summary><div class='docblock'>Creates a value from an iterator. <a href=\"https://doc.rust-lang.org/nightly/core/iter/traits/collect/trait.FromIterator.html#tymethod.from_iter\">Read more</a></div></details></div></details>","FromIterator<(K, V)>","bdk_wallet::descriptor::policy::ConditionMap","bdk_wallet::descriptor::policy::FoldedConditionMap","bdk_wallet::descriptor::HdKeyPaths","bdk_wallet::descriptor::TapKeyOrigins","bdk_wallet::keys::KeyMap"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-Hash-for-BTreeMap%3CK,+V,+A%3E\" class=\"impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.0.0\">1.0.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/collections/btree/map.rs.html#2268\">source</a></span><a href=\"#impl-Hash-for-BTreeMap%3CK,+V,+A%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl<K, V, A> <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/hash/trait.Hash.html\" title=\"trait core::hash::Hash\">Hash</a> for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html\" title=\"struct alloc::collections::btree::map::BTreeMap\">BTreeMap</a><K, V, A><div class=\"where\">where\n K: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/hash/trait.Hash.html\" title=\"trait core::hash::Hash\">Hash</a>,\n V: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/hash/trait.Hash.html\" title=\"trait core::hash::Hash\">Hash</a>,\n A: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/alloc/trait.Allocator.html\" title=\"trait core::alloc::Allocator\">Allocator</a> + <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/clone/trait.Clone.html\" title=\"trait core::clone::Clone\">Clone</a>,</div></h3></section></summary><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.hash\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/collections/btree/map.rs.html#2269\">source</a><a href=\"#method.hash\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/hash/trait.Hash.html#tymethod.hash\" class=\"fn\">hash</a><H>(&self, state: <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.reference.html\">&mut H</a>)<div class=\"where\">where\n H: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/hash/trait.Hasher.html\" title=\"trait core::hash::Hasher\">Hasher</a>,</div></h4></section></summary><div class='docblock'>Feeds this value into the given <a href=\"https://doc.rust-lang.org/nightly/core/hash/trait.Hasher.html\" title=\"trait core::hash::Hasher\"><code>Hasher</code></a>. <a href=\"https://doc.rust-lang.org/nightly/core/hash/trait.Hash.html#tymethod.hash\">Read more</a></div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.hash_slice\" class=\"method trait-impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.3.0\">1.3.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/core/hash/mod.rs.html#238-240\">source</a></span><a href=\"#method.hash_slice\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/hash/trait.Hash.html#method.hash_slice\" class=\"fn\">hash_slice</a><H>(data: &<a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.slice.html\">[Self]</a>, state: <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.reference.html\">&mut H</a>)<div class=\"where\">where\n H: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/hash/trait.Hasher.html\" title=\"trait core::hash::Hasher\">Hasher</a>,\n Self: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,</div></h4></section></summary><div class='docblock'>Feeds a slice of this type into the given <a href=\"https://doc.rust-lang.org/nightly/core/hash/trait.Hasher.html\" title=\"trait core::hash::Hasher\"><code>Hasher</code></a>. <a href=\"https://doc.rust-lang.org/nightly/core/hash/trait.Hash.html#method.hash_slice\">Read more</a></div></details></div></details>","Hash","bdk_wallet::descriptor::policy::ConditionMap","bdk_wallet::descriptor::policy::FoldedConditionMap","bdk_wallet::descriptor::HdKeyPaths","bdk_wallet::descriptor::TapKeyOrigins","bdk_wallet::keys::KeyMap"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-Index%3C%26Q%3E-for-BTreeMap%3CK,+V,+A%3E\" class=\"impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.0.0\">1.0.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/collections/btree/map.rs.html#2319-2322\">source</a></span><a href=\"#impl-Index%3C%26Q%3E-for-BTreeMap%3CK,+V,+A%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl<K, Q, V, A> <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/ops/index/trait.Index.html\" title=\"trait core::ops::index::Index\">Index</a><<a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.reference.html\">&Q</a>> for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html\" title=\"struct alloc::collections::btree::map::BTreeMap\">BTreeMap</a><K, V, A><div class=\"where\">where\n A: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/alloc/trait.Allocator.html\" title=\"trait core::alloc::Allocator\">Allocator</a> + <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/clone/trait.Clone.html\" title=\"trait core::clone::Clone\">Clone</a>,\n K: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/borrow/trait.Borrow.html\" title=\"trait core::borrow::Borrow\">Borrow</a><Q> + <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html\" title=\"trait core::cmp::Ord\">Ord</a>,\n Q: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html\" title=\"trait core::cmp::Ord\">Ord</a> + ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,</div></h3></section></summary><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.index\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/collections/btree/map.rs.html#2332\">source</a><a href=\"#method.index\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/ops/index/trait.Index.html#tymethod.index\" class=\"fn\">index</a>(&self, key: <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.reference.html\">&Q</a>) -> <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.reference.html\">&V</a></h4></section></summary><div class=\"docblock\"><p>Returns a reference to the value corresponding to the supplied key.</p>\n<h5 id=\"panics\"><a class=\"doc-anchor\" href=\"#panics\">§</a>Panics</h5>\n<p>Panics if the key is not present in the <code>BTreeMap</code>.</p>\n</div></details><details class=\"toggle\" open><summary><section id=\"associatedtype.Output\" class=\"associatedtype trait-impl\"><a href=\"#associatedtype.Output\" class=\"anchor\">§</a><h4 class=\"code-header\">type <a href=\"https://doc.rust-lang.org/nightly/core/ops/index/trait.Index.html#associatedtype.Output\" class=\"associatedtype\">Output</a> = V</h4></section></summary><div class='docblock'>The returned type after indexing.</div></details></div></details>","Index<&Q>","bdk_wallet::descriptor::policy::ConditionMap","bdk_wallet::descriptor::policy::FoldedConditionMap","bdk_wallet::descriptor::HdKeyPaths","bdk_wallet::descriptor::TapKeyOrigins","bdk_wallet::keys::KeyMap"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-IntoAssets-for-BTreeMap%3CDescriptorPublicKey,+DescriptorSecretKey%3E\" class=\"impl\"><a href=\"#impl-IntoAssets-for-BTreeMap%3CDescriptorPublicKey,+DescriptorSecretKey%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl IntoAssets for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html\" title=\"struct alloc::collections::btree::map::BTreeMap\">BTreeMap</a><<a class=\"enum\" href=\"bdk_wallet/keys/enum.DescriptorPublicKey.html\" title=\"enum bdk_wallet::keys::DescriptorPublicKey\">DescriptorPublicKey</a>, <a class=\"enum\" href=\"bdk_wallet/keys/enum.DescriptorSecretKey.html\" title=\"enum bdk_wallet::keys::DescriptorSecretKey\">DescriptorSecretKey</a>></h3></section></summary><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.into_assets\" class=\"method trait-impl\"><a href=\"#method.into_assets\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a class=\"fn\">into_assets</a>(self) -> Assets</h4></section></summary><div class='docblock'>Convert <code>self</code> into a <code>Assets</code> struct</div></details></div></details>","IntoAssets","bdk_wallet::keys::KeyMap"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-IntoDeserializer%3C'de,+E%3E-for-BTreeMap%3CK,+V%3E\" class=\"impl\"><a class=\"src rightside\" href=\"https://docs.rs/serde/1.0.203/src/serde/de/value.rs.html#1425-1429\">source</a><a href=\"#impl-IntoDeserializer%3C'de,+E%3E-for-BTreeMap%3CK,+V%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl<'de, K, V, E> <a class=\"trait\" href=\"https://docs.rs/serde/1.0.203/serde/de/trait.IntoDeserializer.html\" title=\"trait serde::de::IntoDeserializer\">IntoDeserializer</a><'de, E> for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html\" title=\"struct alloc::collections::btree::map::BTreeMap\">BTreeMap</a><K, V><div class=\"where\">where\n K: <a class=\"trait\" href=\"https://docs.rs/serde/1.0.203/serde/de/trait.IntoDeserializer.html\" title=\"trait serde::de::IntoDeserializer\">IntoDeserializer</a><'de, E> + <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Eq.html\" title=\"trait core::cmp::Eq\">Eq</a> + <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html\" title=\"trait core::cmp::Ord\">Ord</a>,\n V: <a class=\"trait\" href=\"https://docs.rs/serde/1.0.203/serde/de/trait.IntoDeserializer.html\" title=\"trait serde::de::IntoDeserializer\">IntoDeserializer</a><'de, E>,\n E: <a class=\"trait\" href=\"https://docs.rs/serde/1.0.203/serde/de/trait.Error.html\" title=\"trait serde::de::Error\">Error</a>,</div></h3></section></summary><div class=\"impl-items\"><details class=\"toggle\" open><summary><section id=\"associatedtype.Deserializer\" class=\"associatedtype trait-impl\"><a href=\"#associatedtype.Deserializer\" class=\"anchor\">§</a><h4 class=\"code-header\">type <a href=\"https://docs.rs/serde/1.0.203/serde/de/trait.IntoDeserializer.html#associatedtype.Deserializer\" class=\"associatedtype\">Deserializer</a> = <a class=\"struct\" href=\"https://docs.rs/serde/1.0.203/serde/de/value/struct.MapDeserializer.html\" title=\"struct serde::de::value::MapDeserializer\">MapDeserializer</a><'de, <<a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html\" title=\"struct alloc::collections::btree::map::BTreeMap\">BTreeMap</a><K, V> as <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/iter/traits/collect/trait.IntoIterator.html\" title=\"trait core::iter::traits::collect::IntoIterator\">IntoIterator</a>>::<a class=\"associatedtype\" href=\"https://doc.rust-lang.org/nightly/core/iter/traits/collect/trait.IntoIterator.html#associatedtype.IntoIter\" title=\"type core::iter::traits::collect::IntoIterator::IntoIter\">IntoIter</a>, E></h4></section></summary><div class='docblock'>The type of the deserializer being converted into.</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.into_deserializer\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://docs.rs/serde/1.0.203/src/serde/de/value.rs.html#1433\">source</a><a href=\"#method.into_deserializer\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://docs.rs/serde/1.0.203/serde/de/trait.IntoDeserializer.html#tymethod.into_deserializer\" class=\"fn\">into_deserializer</a>(\n self\n) -> <<a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html\" title=\"struct alloc::collections::btree::map::BTreeMap\">BTreeMap</a><K, V> as <a class=\"trait\" href=\"https://docs.rs/serde/1.0.203/serde/de/trait.IntoDeserializer.html\" title=\"trait serde::de::IntoDeserializer\">IntoDeserializer</a><'de, E>>::<a class=\"associatedtype\" href=\"https://docs.rs/serde/1.0.203/serde/de/trait.IntoDeserializer.html#associatedtype.Deserializer\" title=\"type serde::de::IntoDeserializer::Deserializer\">Deserializer</a></h4></section></summary><div class='docblock'>Convert this value into a deserializer.</div></details></div></details>","IntoDeserializer<'de, E>","bdk_wallet::descriptor::policy::ConditionMap","bdk_wallet::descriptor::policy::FoldedConditionMap","bdk_wallet::descriptor::HdKeyPaths","bdk_wallet::descriptor::TapKeyOrigins","bdk_wallet::keys::KeyMap"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-IntoIterator-for-BTreeMap%3CK,+V,+A%3E\" class=\"impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.0.0\">1.0.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/collections/btree/map.rs.html#1636\">source</a></span><a href=\"#impl-IntoIterator-for-BTreeMap%3CK,+V,+A%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl<K, V, A> <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/iter/traits/collect/trait.IntoIterator.html\" title=\"trait core::iter::traits::collect::IntoIterator\">IntoIterator</a> for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html\" title=\"struct alloc::collections::btree::map::BTreeMap\">BTreeMap</a><K, V, A><div class=\"where\">where\n A: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/alloc/trait.Allocator.html\" title=\"trait core::alloc::Allocator\">Allocator</a> + <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/clone/trait.Clone.html\" title=\"trait core::clone::Clone\">Clone</a>,</div></h3></section></summary><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.into_iter\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/collections/btree/map.rs.html#1641\">source</a><a href=\"#method.into_iter\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/iter/traits/collect/trait.IntoIterator.html#tymethod.into_iter\" class=\"fn\">into_iter</a>(self) -> <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.IntoIter.html\" title=\"struct alloc::collections::btree::map::IntoIter\">IntoIter</a><K, V, A></h4></section></summary><div class=\"docblock\"><p>Gets an owning iterator over the entries of the map, sorted by key.</p>\n</div></details><details class=\"toggle\" open><summary><section id=\"associatedtype.Item\" class=\"associatedtype trait-impl\"><a href=\"#associatedtype.Item\" class=\"anchor\">§</a><h4 class=\"code-header\">type <a href=\"https://doc.rust-lang.org/nightly/core/iter/traits/collect/trait.IntoIterator.html#associatedtype.Item\" class=\"associatedtype\">Item</a> = <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.tuple.html\">(K, V)</a></h4></section></summary><div class='docblock'>The type of the elements being iterated over.</div></details><details class=\"toggle\" open><summary><section id=\"associatedtype.IntoIter\" class=\"associatedtype trait-impl\"><a href=\"#associatedtype.IntoIter\" class=\"anchor\">§</a><h4 class=\"code-header\">type <a href=\"https://doc.rust-lang.org/nightly/core/iter/traits/collect/trait.IntoIterator.html#associatedtype.IntoIter\" class=\"associatedtype\">IntoIter</a> = <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.IntoIter.html\" title=\"struct alloc::collections::btree::map::IntoIter\">IntoIter</a><K, V, A></h4></section></summary><div class='docblock'>Which kind of iterator are we turning this into?</div></details></div></details>","IntoIterator","bdk_wallet::descriptor::policy::ConditionMap","bdk_wallet::descriptor::policy::FoldedConditionMap","bdk_wallet::descriptor::HdKeyPaths","bdk_wallet::descriptor::TapKeyOrigins","bdk_wallet::keys::KeyMap"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-Ord-for-BTreeMap%3CK,+V,+A%3E\" class=\"impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.0.0\">1.0.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/collections/btree/map.rs.html#2304\">source</a></span><a href=\"#impl-Ord-for-BTreeMap%3CK,+V,+A%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl<K, V, A> <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html\" title=\"trait core::cmp::Ord\">Ord</a> for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html\" title=\"struct alloc::collections::btree::map::BTreeMap\">BTreeMap</a><K, V, A><div class=\"where\">where\n K: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html\" title=\"trait core::cmp::Ord\">Ord</a>,\n V: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html\" title=\"trait core::cmp::Ord\">Ord</a>,\n A: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/alloc/trait.Allocator.html\" title=\"trait core::alloc::Allocator\">Allocator</a> + <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/clone/trait.Clone.html\" title=\"trait core::clone::Clone\">Clone</a>,</div></h3></section></summary><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.cmp\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/collections/btree/map.rs.html#2306\">source</a><a href=\"#method.cmp\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html#tymethod.cmp\" class=\"fn\">cmp</a>(&self, other: &<a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html\" title=\"struct alloc::collections::btree::map::BTreeMap\">BTreeMap</a><K, V, A>) -> <a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/core/cmp/enum.Ordering.html\" title=\"enum core::cmp::Ordering\">Ordering</a></h4></section></summary><div class='docblock'>This method returns an <a href=\"https://doc.rust-lang.org/nightly/core/cmp/enum.Ordering.html\" title=\"enum core::cmp::Ordering\"><code>Ordering</code></a> between <code>self</code> and <code>other</code>. <a href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html#tymethod.cmp\">Read more</a></div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.max\" class=\"method trait-impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.21.0\">1.21.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/core/cmp.rs.html#856-858\">source</a></span><a href=\"#method.max\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html#method.max\" class=\"fn\">max</a>(self, other: Self) -> Self<div class=\"where\">where\n Self: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,</div></h4></section></summary><div class='docblock'>Compares and returns the maximum of two values. <a href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html#method.max\">Read more</a></div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.min\" class=\"method trait-impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.21.0\">1.21.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/core/cmp.rs.html#877-879\">source</a></span><a href=\"#method.min\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html#method.min\" class=\"fn\">min</a>(self, other: Self) -> Self<div class=\"where\">where\n Self: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,</div></h4></section></summary><div class='docblock'>Compares and returns the minimum of two values. <a href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html#method.min\">Read more</a></div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.clamp\" class=\"method trait-impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.50.0\">1.50.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/core/cmp.rs.html#902-905\">source</a></span><a href=\"#method.clamp\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html#method.clamp\" class=\"fn\">clamp</a>(self, min: Self, max: Self) -> Self<div class=\"where\">where\n Self: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a> + <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.PartialOrd.html\" title=\"trait core::cmp::PartialOrd\">PartialOrd</a>,</div></h4></section></summary><div class='docblock'>Restrict a value to a certain interval. <a href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html#method.clamp\">Read more</a></div></details></div></details>","Ord","bdk_wallet::descriptor::policy::ConditionMap","bdk_wallet::descriptor::policy::FoldedConditionMap","bdk_wallet::descriptor::HdKeyPaths","bdk_wallet::descriptor::TapKeyOrigins","bdk_wallet::keys::KeyMap"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-PartialEq-for-BTreeMap%3CK,+V,+A%3E\" class=\"impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.0.0\">1.0.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/collections/btree/map.rs.html#2286\">source</a></span><a href=\"#impl-PartialEq-for-BTreeMap%3CK,+V,+A%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl<K, V, A> <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.PartialEq.html\" title=\"trait core::cmp::PartialEq\">PartialEq</a> for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html\" title=\"struct alloc::collections::btree::map::BTreeMap\">BTreeMap</a><K, V, A><div class=\"where\">where\n K: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.PartialEq.html\" title=\"trait core::cmp::PartialEq\">PartialEq</a>,\n V: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.PartialEq.html\" title=\"trait core::cmp::PartialEq\">PartialEq</a>,\n A: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/alloc/trait.Allocator.html\" title=\"trait core::alloc::Allocator\">Allocator</a> + <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/clone/trait.Clone.html\" title=\"trait core::clone::Clone\">Clone</a>,</div></h3></section></summary><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.eq\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/collections/btree/map.rs.html#2287\">source</a><a href=\"#method.eq\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.PartialEq.html#tymethod.eq\" class=\"fn\">eq</a>(&self, other: &<a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html\" title=\"struct alloc::collections::btree::map::BTreeMap\">BTreeMap</a><K, V, A>) -> <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.bool.html\">bool</a></h4></section></summary><div class='docblock'>This method tests for <code>self</code> and <code>other</code> values to be equal, and is used\nby <code>==</code>.</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.ne\" class=\"method trait-impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.0.0\">1.0.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/core/cmp.rs.html#263\">source</a></span><a href=\"#method.ne\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.PartialEq.html#method.ne\" class=\"fn\">ne</a>(&self, other: <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.reference.html\">&Rhs</a>) -> <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.bool.html\">bool</a></h4></section></summary><div class='docblock'>This method tests for <code>!=</code>. The default implementation is almost always\nsufficient, and should not be overridden without very good reason.</div></details></div></details>","PartialEq","bdk_wallet::descriptor::policy::ConditionMap","bdk_wallet::descriptor::policy::FoldedConditionMap","bdk_wallet::descriptor::HdKeyPaths","bdk_wallet::descriptor::TapKeyOrigins","bdk_wallet::keys::KeyMap"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-PartialOrd-for-BTreeMap%3CK,+V,+A%3E\" class=\"impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.0.0\">1.0.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/collections/btree/map.rs.html#2296\">source</a></span><a href=\"#impl-PartialOrd-for-BTreeMap%3CK,+V,+A%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl<K, V, A> <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.PartialOrd.html\" title=\"trait core::cmp::PartialOrd\">PartialOrd</a> for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html\" title=\"struct alloc::collections::btree::map::BTreeMap\">BTreeMap</a><K, V, A><div class=\"where\">where\n K: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.PartialOrd.html\" title=\"trait core::cmp::PartialOrd\">PartialOrd</a>,\n V: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.PartialOrd.html\" title=\"trait core::cmp::PartialOrd\">PartialOrd</a>,\n A: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/alloc/trait.Allocator.html\" title=\"trait core::alloc::Allocator\">Allocator</a> + <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/clone/trait.Clone.html\" title=\"trait core::clone::Clone\">Clone</a>,</div></h3></section></summary><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.partial_cmp\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/collections/btree/map.rs.html#2298\">source</a><a href=\"#method.partial_cmp\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.PartialOrd.html#tymethod.partial_cmp\" class=\"fn\">partial_cmp</a>(&self, other: &<a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html\" title=\"struct alloc::collections::btree::map::BTreeMap\">BTreeMap</a><K, V, A>) -> <a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/core/option/enum.Option.html\" title=\"enum core::option::Option\">Option</a><<a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/core/cmp/enum.Ordering.html\" title=\"enum core::cmp::Ordering\">Ordering</a>></h4></section></summary><div class='docblock'>This method returns an ordering between <code>self</code> and <code>other</code> values if one exists. <a href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.PartialOrd.html#tymethod.partial_cmp\">Read more</a></div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.lt\" class=\"method trait-impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.0.0\">1.0.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/core/cmp.rs.html#1179\">source</a></span><a href=\"#method.lt\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.PartialOrd.html#method.lt\" class=\"fn\">lt</a>(&self, other: <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.reference.html\">&Rhs</a>) -> <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.bool.html\">bool</a></h4></section></summary><div class='docblock'>This method tests less than (for <code>self</code> and <code>other</code>) and is used by the <code><</code> operator. <a href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.PartialOrd.html#method.lt\">Read more</a></div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.le\" class=\"method trait-impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.0.0\">1.0.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/core/cmp.rs.html#1197\">source</a></span><a href=\"#method.le\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.PartialOrd.html#method.le\" class=\"fn\">le</a>(&self, other: <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.reference.html\">&Rhs</a>) -> <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.bool.html\">bool</a></h4></section></summary><div class='docblock'>This method tests less than or equal to (for <code>self</code> and <code>other</code>) and is used by the <code><=</code>\noperator. <a href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.PartialOrd.html#method.le\">Read more</a></div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.gt\" class=\"method trait-impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.0.0\">1.0.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/core/cmp.rs.html#1214\">source</a></span><a href=\"#method.gt\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.PartialOrd.html#method.gt\" class=\"fn\">gt</a>(&self, other: <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.reference.html\">&Rhs</a>) -> <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.bool.html\">bool</a></h4></section></summary><div class='docblock'>This method tests greater than (for <code>self</code> and <code>other</code>) and is used by the <code>></code> operator. <a href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.PartialOrd.html#method.gt\">Read more</a></div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.ge\" class=\"method trait-impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.0.0\">1.0.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/core/cmp.rs.html#1232\">source</a></span><a href=\"#method.ge\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.PartialOrd.html#method.ge\" class=\"fn\">ge</a>(&self, other: <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.reference.html\">&Rhs</a>) -> <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.bool.html\">bool</a></h4></section></summary><div class='docblock'>This method tests greater than or equal to (for <code>self</code> and <code>other</code>) and is used by the <code>>=</code>\noperator. <a href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.PartialOrd.html#method.ge\">Read more</a></div></details></div></details>","PartialOrd","bdk_wallet::descriptor::policy::ConditionMap","bdk_wallet::descriptor::policy::FoldedConditionMap","bdk_wallet::descriptor::HdKeyPaths","bdk_wallet::descriptor::TapKeyOrigins","bdk_wallet::keys::KeyMap"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-Serialize-for-BTreeMap%3CK,+V%3E\" class=\"impl\"><a class=\"src rightside\" href=\"https://docs.rs/serde/1.0.203/src/serde/ser/impls.rs.html#495-499\">source</a><a href=\"#impl-Serialize-for-BTreeMap%3CK,+V%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl<K, V> <a class=\"trait\" href=\"https://docs.rs/serde/1.0.203/serde/ser/trait.Serialize.html\" title=\"trait serde::ser::Serialize\">Serialize</a> for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html\" title=\"struct alloc::collections::btree::map::BTreeMap\">BTreeMap</a><K, V><div class=\"where\">where\n K: <a class=\"trait\" href=\"https://docs.rs/serde/1.0.203/serde/ser/trait.Serialize.html\" title=\"trait serde::ser::Serialize\">Serialize</a>,\n V: <a class=\"trait\" href=\"https://docs.rs/serde/1.0.203/serde/ser/trait.Serialize.html\" title=\"trait serde::ser::Serialize\">Serialize</a>,</div></h3></section></summary><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.serialize\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://docs.rs/serde/1.0.203/src/serde/ser/impls.rs.html#495-499\">source</a><a href=\"#method.serialize\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://docs.rs/serde/1.0.203/serde/ser/trait.Serialize.html#tymethod.serialize\" class=\"fn\">serialize</a><S>(\n &self,\n serializer: S\n) -> <a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/core/result/enum.Result.html\" title=\"enum core::result::Result\">Result</a><<S as <a class=\"trait\" href=\"https://docs.rs/serde/1.0.203/serde/ser/trait.Serializer.html\" title=\"trait serde::ser::Serializer\">Serializer</a>>::<a class=\"associatedtype\" href=\"https://docs.rs/serde/1.0.203/serde/ser/trait.Serializer.html#associatedtype.Ok\" title=\"type serde::ser::Serializer::Ok\">Ok</a>, <S as <a class=\"trait\" href=\"https://docs.rs/serde/1.0.203/serde/ser/trait.Serializer.html\" title=\"trait serde::ser::Serializer\">Serializer</a>>::<a class=\"associatedtype\" href=\"https://docs.rs/serde/1.0.203/serde/ser/trait.Serializer.html#associatedtype.Error\" title=\"type serde::ser::Serializer::Error\">Error</a>><div class=\"where\">where\n S: <a class=\"trait\" href=\"https://docs.rs/serde/1.0.203/serde/ser/trait.Serializer.html\" title=\"trait serde::ser::Serializer\">Serializer</a>,</div></h4></section></summary><div class='docblock'>Serialize this value into the given Serde serializer. <a href=\"https://docs.rs/serde/1.0.203/serde/ser/trait.Serialize.html#tymethod.serialize\">Read more</a></div></details></div></details>","Serialize","bdk_wallet::descriptor::policy::ConditionMap","bdk_wallet::descriptor::policy::FoldedConditionMap","bdk_wallet::descriptor::HdKeyPaths","bdk_wallet::descriptor::TapKeyOrigins","bdk_wallet::keys::KeyMap"],["<section id=\"impl-Eq-for-BTreeMap%3CK,+V,+A%3E\" class=\"impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.0.0\">1.0.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/collections/btree/map.rs.html#2293\">source</a></span><a href=\"#impl-Eq-for-BTreeMap%3CK,+V,+A%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl<K, V, A> <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Eq.html\" title=\"trait core::cmp::Eq\">Eq</a> for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html\" title=\"struct alloc::collections::btree::map::BTreeMap\">BTreeMap</a><K, V, A><div class=\"where\">where\n K: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Eq.html\" title=\"trait core::cmp::Eq\">Eq</a>,\n V: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Eq.html\" title=\"trait core::cmp::Eq\">Eq</a>,\n A: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/alloc/trait.Allocator.html\" title=\"trait core::alloc::Allocator\">Allocator</a> + <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/clone/trait.Clone.html\" title=\"trait core::clone::Clone\">Clone</a>,</div></h3></section>","Eq","bdk_wallet::descriptor::policy::ConditionMap","bdk_wallet::descriptor::policy::FoldedConditionMap","bdk_wallet::descriptor::HdKeyPaths","bdk_wallet::descriptor::TapKeyOrigins","bdk_wallet::keys::KeyMap"],["<section id=\"impl-UnwindSafe-for-BTreeMap%3CK,+V,+A%3E\" class=\"impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.64.0\">1.64.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/collections/btree/map.rs.html#198-202\">source</a></span><a href=\"#impl-UnwindSafe-for-BTreeMap%3CK,+V,+A%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl<K, V, A> <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/panic/unwind_safe/trait.UnwindSafe.html\" title=\"trait core::panic::unwind_safe::UnwindSafe\">UnwindSafe</a> for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html\" title=\"struct alloc::collections::btree::map::BTreeMap\">BTreeMap</a><K, V, A><div class=\"where\">where\n A: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/alloc/trait.Allocator.html\" title=\"trait core::alloc::Allocator\">Allocator</a> + <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/clone/trait.Clone.html\" title=\"trait core::clone::Clone\">Clone</a> + <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/panic/unwind_safe/trait.UnwindSafe.html\" title=\"trait core::panic::unwind_safe::UnwindSafe\">UnwindSafe</a>,\n K: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/panic/unwind_safe/trait.RefUnwindSafe.html\" title=\"trait core::panic::unwind_safe::RefUnwindSafe\">RefUnwindSafe</a>,\n V: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/panic/unwind_safe/trait.RefUnwindSafe.html\" title=\"trait core::panic::unwind_safe::RefUnwindSafe\">RefUnwindSafe</a>,</div></h3></section>","UnwindSafe","bdk_wallet::descriptor::policy::ConditionMap","bdk_wallet::descriptor::policy::FoldedConditionMap","bdk_wallet::descriptor::HdKeyPaths","bdk_wallet::descriptor::TapKeyOrigins","bdk_wallet::keys::KeyMap"]]
+"bdk_wallet":[["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-Append-for-BTreeMap%3CK,+V%3E\" class=\"impl\"><a class=\"src rightside\" href=\"src/bdk_chain/tx_data_traits.rs.html#134\">source</a><a href=\"#impl-Append-for-BTreeMap%3CK,+V%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl<K, V> <a class=\"trait\" href=\"bdk_chain/tx_data_traits/trait.Append.html\" title=\"trait bdk_chain::tx_data_traits::Append\">Append</a> for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html\" title=\"struct alloc::collections::btree::map::BTreeMap\">BTreeMap</a><K, V><div class=\"where\">where\n K: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html\" title=\"trait core::cmp::Ord\">Ord</a>,</div></h3></section></summary><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.append\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"src/bdk_chain/tx_data_traits.rs.html#135\">source</a><a href=\"#method.append\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"bdk_chain/tx_data_traits/trait.Append.html#tymethod.append\" class=\"fn\">append</a>(&mut self, other: <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html\" title=\"struct alloc::collections::btree::map::BTreeMap\">BTreeMap</a><K, V>)</h4></section></summary><div class='docblock'>Append another object of the same type onto <code>self</code>.</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.is_empty\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"src/bdk_chain/tx_data_traits.rs.html#141\">source</a><a href=\"#method.is_empty\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"bdk_chain/tx_data_traits/trait.Append.html#tymethod.is_empty\" class=\"fn\">is_empty</a>(&self) -> <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.bool.html\">bool</a></h4></section></summary><div class='docblock'>Returns whether the structure is considered empty.</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.take\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"src/bdk_chain/tx_data_traits.rs.html#125\">source</a><a href=\"#method.take\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"bdk_chain/tx_data_traits/trait.Append.html#method.take\" class=\"fn\">take</a>(&mut self) -> <a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/core/option/enum.Option.html\" title=\"enum core::option::Option\">Option</a><Self></h4></section></summary><div class='docblock'>Take the value, replacing it with the default value.</div></details></div></details>","Append","bdk_wallet::descriptor::policy::ConditionMap","bdk_wallet::descriptor::policy::FoldedConditionMap","bdk_wallet::descriptor::HdKeyPaths","bdk_wallet::descriptor::TapKeyOrigins","bdk_wallet::keys::KeyMap"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-BTreeMap%3CK,+V%3E\" class=\"impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/collections/btree/map.rs.html#610\">source</a><a href=\"#impl-BTreeMap%3CK,+V%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl<K, V> <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html\" title=\"struct alloc::collections::btree::map::BTreeMap\">BTreeMap</a><K, V></h3></section></summary><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.new\" class=\"method\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.0.0, const since 1.66.0\">1.0.0 (const: 1.66.0)</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/collections/btree/map.rs.html#629\">source</a></span><h4 class=\"code-header\">pub const fn <a href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html#tymethod.new\" class=\"fn\">new</a>() -> <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html\" title=\"struct alloc::collections::btree::map::BTreeMap\">BTreeMap</a><K, V></h4></section></summary><div class=\"docblock\"><p>Makes a new, empty <code>BTreeMap</code>.</p>\n<p>Does not allocate anything on its own.</p>\n<h5 id=\"examples\"><a class=\"doc-anchor\" href=\"#examples\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::collections::BTreeMap;\n\n<span class=\"kw\">let </span><span class=\"kw-2\">mut </span>map = BTreeMap::new();\n\n<span class=\"comment\">// entries can now be inserted into the empty map\n</span>map.insert(<span class=\"number\">1</span>, <span class=\"string\">\"a\"</span>);</code></pre></div>\n</div></details></div></details>",0,"bdk_wallet::descriptor::policy::ConditionMap","bdk_wallet::descriptor::policy::FoldedConditionMap","bdk_wallet::descriptor::HdKeyPaths","bdk_wallet::descriptor::TapKeyOrigins","bdk_wallet::keys::KeyMap"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-BTreeMap%3CK,+V,+A%3E\" class=\"impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/collections/btree/map.rs.html#2359\">source</a><a href=\"#impl-BTreeMap%3CK,+V,+A%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl<K, V, A> <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html\" title=\"struct alloc::collections::btree::map::BTreeMap\">BTreeMap</a><K, V, A><div class=\"where\">where\n A: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/alloc/trait.Allocator.html\" title=\"trait core::alloc::Allocator\">Allocator</a> + <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/clone/trait.Clone.html\" title=\"trait core::clone::Clone\">Clone</a>,</div></h3></section></summary><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.iter\" class=\"method\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.0.0\">1.0.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/collections/btree/map.rs.html#2380\">source</a></span><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html#tymethod.iter\" class=\"fn\">iter</a>(&self) -> <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.Iter.html\" title=\"struct alloc::collections::btree::map::Iter\">Iter</a><'_, K, V></h4></section></summary><div class=\"docblock\"><p>Gets an iterator over the entries of the map, sorted by key.</p>\n<h5 id=\"examples\"><a class=\"doc-anchor\" href=\"#examples\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::collections::BTreeMap;\n\n<span class=\"kw\">let </span><span class=\"kw-2\">mut </span>map = BTreeMap::new();\nmap.insert(<span class=\"number\">3</span>, <span class=\"string\">\"c\"</span>);\nmap.insert(<span class=\"number\">2</span>, <span class=\"string\">\"b\"</span>);\nmap.insert(<span class=\"number\">1</span>, <span class=\"string\">\"a\"</span>);\n\n<span class=\"kw\">for </span>(key, value) <span class=\"kw\">in </span>map.iter() {\n <span class=\"macro\">println!</span>(<span class=\"string\">\"{key}: {value}\"</span>);\n}\n\n<span class=\"kw\">let </span>(first_key, first_value) = map.iter().next().unwrap();\n<span class=\"macro\">assert_eq!</span>((<span class=\"kw-2\">*</span>first_key, <span class=\"kw-2\">*</span>first_value), (<span class=\"number\">1</span>, <span class=\"string\">\"a\"</span>));</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.iter_mut\" class=\"method\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.0.0\">1.0.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/collections/btree/map.rs.html#2411\">source</a></span><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html#tymethod.iter_mut\" class=\"fn\">iter_mut</a>(&mut self) -> <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.IterMut.html\" title=\"struct alloc::collections::btree::map::IterMut\">IterMut</a><'_, K, V></h4></section></summary><div class=\"docblock\"><p>Gets a mutable iterator over the entries of the map, sorted by key.</p>\n<h5 id=\"examples-1\"><a class=\"doc-anchor\" href=\"#examples-1\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::collections::BTreeMap;\n\n<span class=\"kw\">let </span><span class=\"kw-2\">mut </span>map = BTreeMap::from([\n (<span class=\"string\">\"a\"</span>, <span class=\"number\">1</span>),\n (<span class=\"string\">\"b\"</span>, <span class=\"number\">2</span>),\n (<span class=\"string\">\"c\"</span>, <span class=\"number\">3</span>),\n]);\n\n<span class=\"comment\">// add 10 to the value if the key isn't \"a\"\n</span><span class=\"kw\">for </span>(key, value) <span class=\"kw\">in </span>map.iter_mut() {\n <span class=\"kw\">if </span>key != <span class=\"kw-2\">&</span><span class=\"string\">\"a\" </span>{\n <span class=\"kw-2\">*</span>value += <span class=\"number\">10</span>;\n }\n}</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.keys\" class=\"method\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.0.0\">1.0.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/collections/btree/map.rs.html#2436\">source</a></span><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html#tymethod.keys\" class=\"fn\">keys</a>(&self) -> <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.Keys.html\" title=\"struct alloc::collections::btree::map::Keys\">Keys</a><'_, K, V></h4></section></summary><div class=\"docblock\"><p>Gets an iterator over the keys of the map, in sorted order.</p>\n<h5 id=\"examples-2\"><a class=\"doc-anchor\" href=\"#examples-2\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::collections::BTreeMap;\n\n<span class=\"kw\">let </span><span class=\"kw-2\">mut </span>a = BTreeMap::new();\na.insert(<span class=\"number\">2</span>, <span class=\"string\">\"b\"</span>);\na.insert(<span class=\"number\">1</span>, <span class=\"string\">\"a\"</span>);\n\n<span class=\"kw\">let </span>keys: Vec<<span class=\"kw\">_</span>> = a.keys().cloned().collect();\n<span class=\"macro\">assert_eq!</span>(keys, [<span class=\"number\">1</span>, <span class=\"number\">2</span>]);</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.values\" class=\"method\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.0.0\">1.0.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/collections/btree/map.rs.html#2455\">source</a></span><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html#tymethod.values\" class=\"fn\">values</a>(&self) -> <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.Values.html\" title=\"struct alloc::collections::btree::map::Values\">Values</a><'_, K, V></h4></section></summary><div class=\"docblock\"><p>Gets an iterator over the values of the map, in order by key.</p>\n<h5 id=\"examples-3\"><a class=\"doc-anchor\" href=\"#examples-3\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::collections::BTreeMap;\n\n<span class=\"kw\">let </span><span class=\"kw-2\">mut </span>a = BTreeMap::new();\na.insert(<span class=\"number\">1</span>, <span class=\"string\">\"hello\"</span>);\na.insert(<span class=\"number\">2</span>, <span class=\"string\">\"goodbye\"</span>);\n\n<span class=\"kw\">let </span>values: Vec<<span class=\"kw-2\">&</span>str> = a.values().cloned().collect();\n<span class=\"macro\">assert_eq!</span>(values, [<span class=\"string\">\"hello\"</span>, <span class=\"string\">\"goodbye\"</span>]);</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.values_mut\" class=\"method\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.10.0\">1.10.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/collections/btree/map.rs.html#2479\">source</a></span><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html#tymethod.values_mut\" class=\"fn\">values_mut</a>(&mut self) -> <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.ValuesMut.html\" title=\"struct alloc::collections::btree::map::ValuesMut\">ValuesMut</a><'_, K, V></h4></section></summary><div class=\"docblock\"><p>Gets a mutable iterator over the values of the map, in order by key.</p>\n<h5 id=\"examples-4\"><a class=\"doc-anchor\" href=\"#examples-4\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::collections::BTreeMap;\n\n<span class=\"kw\">let </span><span class=\"kw-2\">mut </span>a = BTreeMap::new();\na.insert(<span class=\"number\">1</span>, String::from(<span class=\"string\">\"hello\"</span>));\na.insert(<span class=\"number\">2</span>, String::from(<span class=\"string\">\"goodbye\"</span>));\n\n<span class=\"kw\">for </span>value <span class=\"kw\">in </span>a.values_mut() {\n value.push_str(<span class=\"string\">\"!\"</span>);\n}\n\n<span class=\"kw\">let </span>values: Vec<String> = a.values().cloned().collect();\n<span class=\"macro\">assert_eq!</span>(values, [String::from(<span class=\"string\">\"hello!\"</span>),\n String::from(<span class=\"string\">\"goodbye!\"</span>)]);</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.len\" class=\"method\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.0.0, const unstable\">1.0.0 (const: <a href=\"https://github.com/rust-lang/rust/issues/71835\" title=\"Tracking issue for const_btree_len\">unstable</a>)</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/collections/btree/map.rs.html#2503\">source</a></span><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html#tymethod.len\" class=\"fn\">len</a>(&self) -> <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.usize.html\">usize</a></h4></section></summary><div class=\"docblock\"><p>Returns the number of elements in the map.</p>\n<h5 id=\"examples-5\"><a class=\"doc-anchor\" href=\"#examples-5\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::collections::BTreeMap;\n\n<span class=\"kw\">let </span><span class=\"kw-2\">mut </span>a = BTreeMap::new();\n<span class=\"macro\">assert_eq!</span>(a.len(), <span class=\"number\">0</span>);\na.insert(<span class=\"number\">1</span>, <span class=\"string\">\"a\"</span>);\n<span class=\"macro\">assert_eq!</span>(a.len(), <span class=\"number\">1</span>);</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.is_empty\" class=\"method\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.0.0, const unstable\">1.0.0 (const: <a href=\"https://github.com/rust-lang/rust/issues/71835\" title=\"Tracking issue for const_btree_len\">unstable</a>)</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/collections/btree/map.rs.html#2526\">source</a></span><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html#tymethod.is_empty\" class=\"fn\">is_empty</a>(&self) -> <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.bool.html\">bool</a></h4></section></summary><div class=\"docblock\"><p>Returns <code>true</code> if the map contains no elements.</p>\n<h5 id=\"examples-6\"><a class=\"doc-anchor\" href=\"#examples-6\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::collections::BTreeMap;\n\n<span class=\"kw\">let </span><span class=\"kw-2\">mut </span>a = BTreeMap::new();\n<span class=\"macro\">assert!</span>(a.is_empty());\na.insert(<span class=\"number\">1</span>, <span class=\"string\">\"a\"</span>);\n<span class=\"macro\">assert!</span>(!a.is_empty());</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.lower_bound\" class=\"method\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/collections/btree/map.rs.html#2570-2573\">source</a><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html#tymethod.lower_bound\" class=\"fn\">lower_bound</a><Q>(&self, bound: <a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/core/ops/range/enum.Bound.html\" title=\"enum core::ops::range::Bound\">Bound</a><<a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.reference.html\">&Q</a>>) -> <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.Cursor.html\" title=\"struct alloc::collections::btree::map::Cursor\">Cursor</a><'_, K, V><div class=\"where\">where\n K: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/borrow/trait.Borrow.html\" title=\"trait core::borrow::Borrow\">Borrow</a><Q> + <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html\" title=\"trait core::cmp::Ord\">Ord</a>,\n Q: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html\" title=\"trait core::cmp::Ord\">Ord</a> + ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,</div></h4></section><span class=\"item-info\"><div class=\"stab unstable\"><span class=\"emoji\">🔬</span><span>This is a nightly-only experimental API. (<code>btree_cursors</code>)</span></div></span></summary><div class=\"docblock\"><p>Returns a <a href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.Cursor.html\" title=\"struct alloc::collections::btree::map::Cursor\"><code>Cursor</code></a> pointing at the gap before the smallest key\ngreater than the given bound.</p>\n<p>Passing <code>Bound::Included(x)</code> will return a cursor pointing to the\ngap before the smallest key greater than or equal to <code>x</code>.</p>\n<p>Passing <code>Bound::Excluded(x)</code> will return a cursor pointing to the\ngap before the smallest key greater than <code>x</code>.</p>\n<p>Passing <code>Bound::Unbounded</code> will return a cursor pointing to the\ngap before the smallest key in the map.</p>\n<h5 id=\"examples-7\"><a class=\"doc-anchor\" href=\"#examples-7\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"attr\">#![feature(btree_cursors)]\n\n</span><span class=\"kw\">use </span>std::collections::BTreeMap;\n<span class=\"kw\">use </span>std::ops::Bound;\n\n<span class=\"kw\">let </span>map = BTreeMap::from([\n (<span class=\"number\">1</span>, <span class=\"string\">\"a\"</span>),\n (<span class=\"number\">2</span>, <span class=\"string\">\"b\"</span>),\n (<span class=\"number\">3</span>, <span class=\"string\">\"c\"</span>),\n (<span class=\"number\">4</span>, <span class=\"string\">\"d\"</span>),\n]);\n\n<span class=\"kw\">let </span>cursor = map.lower_bound(Bound::Included(<span class=\"kw-2\">&</span><span class=\"number\">2</span>));\n<span class=\"macro\">assert_eq!</span>(cursor.peek_prev(), <span class=\"prelude-val\">Some</span>((<span class=\"kw-2\">&</span><span class=\"number\">1</span>, <span class=\"kw-2\">&</span><span class=\"string\">\"a\"</span>)));\n<span class=\"macro\">assert_eq!</span>(cursor.peek_next(), <span class=\"prelude-val\">Some</span>((<span class=\"kw-2\">&</span><span class=\"number\">2</span>, <span class=\"kw-2\">&</span><span class=\"string\">\"b\"</span>)));\n\n<span class=\"kw\">let </span>cursor = map.lower_bound(Bound::Excluded(<span class=\"kw-2\">&</span><span class=\"number\">2</span>));\n<span class=\"macro\">assert_eq!</span>(cursor.peek_prev(), <span class=\"prelude-val\">Some</span>((<span class=\"kw-2\">&</span><span class=\"number\">2</span>, <span class=\"kw-2\">&</span><span class=\"string\">\"b\"</span>)));\n<span class=\"macro\">assert_eq!</span>(cursor.peek_next(), <span class=\"prelude-val\">Some</span>((<span class=\"kw-2\">&</span><span class=\"number\">3</span>, <span class=\"kw-2\">&</span><span class=\"string\">\"c\"</span>)));\n\n<span class=\"kw\">let </span>cursor = map.lower_bound(Bound::Unbounded);\n<span class=\"macro\">assert_eq!</span>(cursor.peek_prev(), <span class=\"prelude-val\">None</span>);\n<span class=\"macro\">assert_eq!</span>(cursor.peek_next(), <span class=\"prelude-val\">Some</span>((<span class=\"kw-2\">&</span><span class=\"number\">1</span>, <span class=\"kw-2\">&</span><span class=\"string\">\"a\"</span>)));</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.lower_bound_mut\" class=\"method\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/collections/btree/map.rs.html#2623-2626\">source</a><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html#tymethod.lower_bound_mut\" class=\"fn\">lower_bound_mut</a><Q>(&mut self, bound: <a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/core/ops/range/enum.Bound.html\" title=\"enum core::ops::range::Bound\">Bound</a><<a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.reference.html\">&Q</a>>) -> <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.CursorMut.html\" title=\"struct alloc::collections::btree::map::CursorMut\">CursorMut</a><'_, K, V, A><div class=\"where\">where\n K: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/borrow/trait.Borrow.html\" title=\"trait core::borrow::Borrow\">Borrow</a><Q> + <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html\" title=\"trait core::cmp::Ord\">Ord</a>,\n Q: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html\" title=\"trait core::cmp::Ord\">Ord</a> + ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,</div></h4></section><span class=\"item-info\"><div class=\"stab unstable\"><span class=\"emoji\">🔬</span><span>This is a nightly-only experimental API. (<code>btree_cursors</code>)</span></div></span></summary><div class=\"docblock\"><p>Returns a <a href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.CursorMut.html\" title=\"struct alloc::collections::btree::map::CursorMut\"><code>CursorMut</code></a> pointing at the gap before the smallest key\ngreater than the given bound.</p>\n<p>Passing <code>Bound::Included(x)</code> will return a cursor pointing to the\ngap before the smallest key greater than or equal to <code>x</code>.</p>\n<p>Passing <code>Bound::Excluded(x)</code> will return a cursor pointing to the\ngap before the smallest key greater than <code>x</code>.</p>\n<p>Passing <code>Bound::Unbounded</code> will return a cursor pointing to the\ngap before the smallest key in the map.</p>\n<h5 id=\"examples-8\"><a class=\"doc-anchor\" href=\"#examples-8\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"attr\">#![feature(btree_cursors)]\n\n</span><span class=\"kw\">use </span>std::collections::BTreeMap;\n<span class=\"kw\">use </span>std::ops::Bound;\n\n<span class=\"kw\">let </span><span class=\"kw-2\">mut </span>map = BTreeMap::from([\n (<span class=\"number\">1</span>, <span class=\"string\">\"a\"</span>),\n (<span class=\"number\">2</span>, <span class=\"string\">\"b\"</span>),\n (<span class=\"number\">3</span>, <span class=\"string\">\"c\"</span>),\n (<span class=\"number\">4</span>, <span class=\"string\">\"d\"</span>),\n]);\n\n<span class=\"kw\">let </span><span class=\"kw-2\">mut </span>cursor = map.lower_bound_mut(Bound::Included(<span class=\"kw-2\">&</span><span class=\"number\">2</span>));\n<span class=\"macro\">assert_eq!</span>(cursor.peek_prev(), <span class=\"prelude-val\">Some</span>((<span class=\"kw-2\">&</span><span class=\"number\">1</span>, <span class=\"kw-2\">&mut </span><span class=\"string\">\"a\"</span>)));\n<span class=\"macro\">assert_eq!</span>(cursor.peek_next(), <span class=\"prelude-val\">Some</span>((<span class=\"kw-2\">&</span><span class=\"number\">2</span>, <span class=\"kw-2\">&mut </span><span class=\"string\">\"b\"</span>)));\n\n<span class=\"kw\">let </span><span class=\"kw-2\">mut </span>cursor = map.lower_bound_mut(Bound::Excluded(<span class=\"kw-2\">&</span><span class=\"number\">2</span>));\n<span class=\"macro\">assert_eq!</span>(cursor.peek_prev(), <span class=\"prelude-val\">Some</span>((<span class=\"kw-2\">&</span><span class=\"number\">2</span>, <span class=\"kw-2\">&mut </span><span class=\"string\">\"b\"</span>)));\n<span class=\"macro\">assert_eq!</span>(cursor.peek_next(), <span class=\"prelude-val\">Some</span>((<span class=\"kw-2\">&</span><span class=\"number\">3</span>, <span class=\"kw-2\">&mut </span><span class=\"string\">\"c\"</span>)));\n\n<span class=\"kw\">let </span><span class=\"kw-2\">mut </span>cursor = map.lower_bound_mut(Bound::Unbounded);\n<span class=\"macro\">assert_eq!</span>(cursor.peek_prev(), <span class=\"prelude-val\">None</span>);\n<span class=\"macro\">assert_eq!</span>(cursor.peek_next(), <span class=\"prelude-val\">Some</span>((<span class=\"kw-2\">&</span><span class=\"number\">1</span>, <span class=\"kw-2\">&mut </span><span class=\"string\">\"a\"</span>)));</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.upper_bound\" class=\"method\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/collections/btree/map.rs.html#2693-2696\">source</a><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html#tymethod.upper_bound\" class=\"fn\">upper_bound</a><Q>(&self, bound: <a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/core/ops/range/enum.Bound.html\" title=\"enum core::ops::range::Bound\">Bound</a><<a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.reference.html\">&Q</a>>) -> <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.Cursor.html\" title=\"struct alloc::collections::btree::map::Cursor\">Cursor</a><'_, K, V><div class=\"where\">where\n K: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/borrow/trait.Borrow.html\" title=\"trait core::borrow::Borrow\">Borrow</a><Q> + <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html\" title=\"trait core::cmp::Ord\">Ord</a>,\n Q: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html\" title=\"trait core::cmp::Ord\">Ord</a> + ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,</div></h4></section><span class=\"item-info\"><div class=\"stab unstable\"><span class=\"emoji\">🔬</span><span>This is a nightly-only experimental API. (<code>btree_cursors</code>)</span></div></span></summary><div class=\"docblock\"><p>Returns a <a href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.Cursor.html\" title=\"struct alloc::collections::btree::map::Cursor\"><code>Cursor</code></a> pointing at the gap after the greatest key\nsmaller than the given bound.</p>\n<p>Passing <code>Bound::Included(x)</code> will return a cursor pointing to the\ngap after the greatest key smaller than or equal to <code>x</code>.</p>\n<p>Passing <code>Bound::Excluded(x)</code> will return a cursor pointing to the\ngap after the greatest key smaller than <code>x</code>.</p>\n<p>Passing <code>Bound::Unbounded</code> will return a cursor pointing to the\ngap after the greatest key in the map.</p>\n<h5 id=\"examples-9\"><a class=\"doc-anchor\" href=\"#examples-9\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"attr\">#![feature(btree_cursors)]\n\n</span><span class=\"kw\">use </span>std::collections::BTreeMap;\n<span class=\"kw\">use </span>std::ops::Bound;\n\n<span class=\"kw\">let </span>map = BTreeMap::from([\n (<span class=\"number\">1</span>, <span class=\"string\">\"a\"</span>),\n (<span class=\"number\">2</span>, <span class=\"string\">\"b\"</span>),\n (<span class=\"number\">3</span>, <span class=\"string\">\"c\"</span>),\n (<span class=\"number\">4</span>, <span class=\"string\">\"d\"</span>),\n]);\n\n<span class=\"kw\">let </span>cursor = map.upper_bound(Bound::Included(<span class=\"kw-2\">&</span><span class=\"number\">3</span>));\n<span class=\"macro\">assert_eq!</span>(cursor.peek_prev(), <span class=\"prelude-val\">Some</span>((<span class=\"kw-2\">&</span><span class=\"number\">3</span>, <span class=\"kw-2\">&</span><span class=\"string\">\"c\"</span>)));\n<span class=\"macro\">assert_eq!</span>(cursor.peek_next(), <span class=\"prelude-val\">Some</span>((<span class=\"kw-2\">&</span><span class=\"number\">4</span>, <span class=\"kw-2\">&</span><span class=\"string\">\"d\"</span>)));\n\n<span class=\"kw\">let </span>cursor = map.upper_bound(Bound::Excluded(<span class=\"kw-2\">&</span><span class=\"number\">3</span>));\n<span class=\"macro\">assert_eq!</span>(cursor.peek_prev(), <span class=\"prelude-val\">Some</span>((<span class=\"kw-2\">&</span><span class=\"number\">2</span>, <span class=\"kw-2\">&</span><span class=\"string\">\"b\"</span>)));\n<span class=\"macro\">assert_eq!</span>(cursor.peek_next(), <span class=\"prelude-val\">Some</span>((<span class=\"kw-2\">&</span><span class=\"number\">3</span>, <span class=\"kw-2\">&</span><span class=\"string\">\"c\"</span>)));\n\n<span class=\"kw\">let </span>cursor = map.upper_bound(Bound::Unbounded);\n<span class=\"macro\">assert_eq!</span>(cursor.peek_prev(), <span class=\"prelude-val\">Some</span>((<span class=\"kw-2\">&</span><span class=\"number\">4</span>, <span class=\"kw-2\">&</span><span class=\"string\">\"d\"</span>)));\n<span class=\"macro\">assert_eq!</span>(cursor.peek_next(), <span class=\"prelude-val\">None</span>);</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.upper_bound_mut\" class=\"method\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/collections/btree/map.rs.html#2746-2749\">source</a><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html#tymethod.upper_bound_mut\" class=\"fn\">upper_bound_mut</a><Q>(&mut self, bound: <a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/core/ops/range/enum.Bound.html\" title=\"enum core::ops::range::Bound\">Bound</a><<a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.reference.html\">&Q</a>>) -> <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.CursorMut.html\" title=\"struct alloc::collections::btree::map::CursorMut\">CursorMut</a><'_, K, V, A><div class=\"where\">where\n K: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/borrow/trait.Borrow.html\" title=\"trait core::borrow::Borrow\">Borrow</a><Q> + <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html\" title=\"trait core::cmp::Ord\">Ord</a>,\n Q: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html\" title=\"trait core::cmp::Ord\">Ord</a> + ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,</div></h4></section><span class=\"item-info\"><div class=\"stab unstable\"><span class=\"emoji\">🔬</span><span>This is a nightly-only experimental API. (<code>btree_cursors</code>)</span></div></span></summary><div class=\"docblock\"><p>Returns a <a href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.CursorMut.html\" title=\"struct alloc::collections::btree::map::CursorMut\"><code>CursorMut</code></a> pointing at the gap after the greatest key\nsmaller than the given bound.</p>\n<p>Passing <code>Bound::Included(x)</code> will return a cursor pointing to the\ngap after the greatest key smaller than or equal to <code>x</code>.</p>\n<p>Passing <code>Bound::Excluded(x)</code> will return a cursor pointing to the\ngap after the greatest key smaller than <code>x</code>.</p>\n<p>Passing <code>Bound::Unbounded</code> will return a cursor pointing to the\ngap after the greatest key in the map.</p>\n<h5 id=\"examples-10\"><a class=\"doc-anchor\" href=\"#examples-10\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"attr\">#![feature(btree_cursors)]\n\n</span><span class=\"kw\">use </span>std::collections::BTreeMap;\n<span class=\"kw\">use </span>std::ops::Bound;\n\n<span class=\"kw\">let </span><span class=\"kw-2\">mut </span>map = BTreeMap::from([\n (<span class=\"number\">1</span>, <span class=\"string\">\"a\"</span>),\n (<span class=\"number\">2</span>, <span class=\"string\">\"b\"</span>),\n (<span class=\"number\">3</span>, <span class=\"string\">\"c\"</span>),\n (<span class=\"number\">4</span>, <span class=\"string\">\"d\"</span>),\n]);\n\n<span class=\"kw\">let </span><span class=\"kw-2\">mut </span>cursor = map.upper_bound_mut(Bound::Included(<span class=\"kw-2\">&</span><span class=\"number\">3</span>));\n<span class=\"macro\">assert_eq!</span>(cursor.peek_prev(), <span class=\"prelude-val\">Some</span>((<span class=\"kw-2\">&</span><span class=\"number\">3</span>, <span class=\"kw-2\">&mut </span><span class=\"string\">\"c\"</span>)));\n<span class=\"macro\">assert_eq!</span>(cursor.peek_next(), <span class=\"prelude-val\">Some</span>((<span class=\"kw-2\">&</span><span class=\"number\">4</span>, <span class=\"kw-2\">&mut </span><span class=\"string\">\"d\"</span>)));\n\n<span class=\"kw\">let </span><span class=\"kw-2\">mut </span>cursor = map.upper_bound_mut(Bound::Excluded(<span class=\"kw-2\">&</span><span class=\"number\">3</span>));\n<span class=\"macro\">assert_eq!</span>(cursor.peek_prev(), <span class=\"prelude-val\">Some</span>((<span class=\"kw-2\">&</span><span class=\"number\">2</span>, <span class=\"kw-2\">&mut </span><span class=\"string\">\"b\"</span>)));\n<span class=\"macro\">assert_eq!</span>(cursor.peek_next(), <span class=\"prelude-val\">Some</span>((<span class=\"kw-2\">&</span><span class=\"number\">3</span>, <span class=\"kw-2\">&mut </span><span class=\"string\">\"c\"</span>)));\n\n<span class=\"kw\">let </span><span class=\"kw-2\">mut </span>cursor = map.upper_bound_mut(Bound::Unbounded);\n<span class=\"macro\">assert_eq!</span>(cursor.peek_prev(), <span class=\"prelude-val\">Some</span>((<span class=\"kw-2\">&</span><span class=\"number\">4</span>, <span class=\"kw-2\">&mut </span><span class=\"string\">\"d\"</span>)));\n<span class=\"macro\">assert_eq!</span>(cursor.peek_next(), <span class=\"prelude-val\">None</span>);</code></pre></div>\n</div></details></div></details>",0,"bdk_wallet::descriptor::policy::ConditionMap","bdk_wallet::descriptor::policy::FoldedConditionMap","bdk_wallet::descriptor::HdKeyPaths","bdk_wallet::descriptor::TapKeyOrigins","bdk_wallet::keys::KeyMap"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-BTreeMap%3CK,+V,+A%3E\" class=\"impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/collections/btree/map.rs.html#634\">source</a><a href=\"#impl-BTreeMap%3CK,+V,+A%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl<K, V, A> <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html\" title=\"struct alloc::collections::btree::map::BTreeMap\">BTreeMap</a><K, V, A><div class=\"where\">where\n A: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/alloc/trait.Allocator.html\" title=\"trait core::alloc::Allocator\">Allocator</a> + <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/clone/trait.Clone.html\" title=\"trait core::clone::Clone\">Clone</a>,</div></h3></section></summary><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.clear\" class=\"method\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.0.0\">1.0.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/collections/btree/map.rs.html#648\">source</a></span><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html#tymethod.clear\" class=\"fn\">clear</a>(&mut self)</h4></section></summary><div class=\"docblock\"><p>Clears the map, removing all elements.</p>\n<h5 id=\"examples\"><a class=\"doc-anchor\" href=\"#examples\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::collections::BTreeMap;\n\n<span class=\"kw\">let </span><span class=\"kw-2\">mut </span>a = BTreeMap::new();\na.insert(<span class=\"number\">1</span>, <span class=\"string\">\"a\"</span>);\na.clear();\n<span class=\"macro\">assert!</span>(a.is_empty());</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.new_in\" class=\"method\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/collections/btree/map.rs.html#674\">source</a><h4 class=\"code-header\">pub const fn <a href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html#tymethod.new_in\" class=\"fn\">new_in</a>(alloc: A) -> <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html\" title=\"struct alloc::collections::btree::map::BTreeMap\">BTreeMap</a><K, V, A></h4></section><span class=\"item-info\"><div class=\"stab unstable\"><span class=\"emoji\">🔬</span><span>This is a nightly-only experimental API. (<code>btreemap_alloc</code>)</span></div></span></summary><div class=\"docblock\"><p>Makes a new empty BTreeMap with a reasonable choice for B.</p>\n<h5 id=\"examples-1\"><a class=\"doc-anchor\" href=\"#examples-1\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::collections::BTreeMap;\n<span class=\"kw\">use </span>std::alloc::Global;\n\n<span class=\"kw\">let </span><span class=\"kw-2\">mut </span>map = BTreeMap::new_in(Global);\n\n<span class=\"comment\">// entries can now be inserted into the empty map\n</span>map.insert(<span class=\"number\">1</span>, <span class=\"string\">\"a\"</span>);</code></pre></div>\n</div></details></div></details>",0,"bdk_wallet::descriptor::policy::ConditionMap","bdk_wallet::descriptor::policy::FoldedConditionMap","bdk_wallet::descriptor::HdKeyPaths","bdk_wallet::descriptor::TapKeyOrigins","bdk_wallet::keys::KeyMap"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-BTreeMap%3CK,+V,+A%3E\" class=\"impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/collections/btree/map.rs.html#679\">source</a><a href=\"#impl-BTreeMap%3CK,+V,+A%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl<K, V, A> <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html\" title=\"struct alloc::collections::btree::map::BTreeMap\">BTreeMap</a><K, V, A><div class=\"where\">where\n A: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/alloc/trait.Allocator.html\" title=\"trait core::alloc::Allocator\">Allocator</a> + <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/clone/trait.Clone.html\" title=\"trait core::clone::Clone\">Clone</a>,</div></h3></section></summary><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.get\" class=\"method\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.0.0\">1.0.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/collections/btree/map.rs.html#696-699\">source</a></span><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html#tymethod.get\" class=\"fn\">get</a><Q>(&self, key: <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.reference.html\">&Q</a>) -> <a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/core/option/enum.Option.html\" title=\"enum core::option::Option\">Option</a><<a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.reference.html\">&V</a>><div class=\"where\">where\n K: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/borrow/trait.Borrow.html\" title=\"trait core::borrow::Borrow\">Borrow</a><Q> + <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html\" title=\"trait core::cmp::Ord\">Ord</a>,\n Q: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html\" title=\"trait core::cmp::Ord\">Ord</a> + ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,</div></h4></section></summary><div class=\"docblock\"><p>Returns a reference to the value corresponding to the key.</p>\n<p>The key may be any borrowed form of the map’s key type, but the ordering\non the borrowed form <em>must</em> match the ordering on the key type.</p>\n<h5 id=\"examples\"><a class=\"doc-anchor\" href=\"#examples\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::collections::BTreeMap;\n\n<span class=\"kw\">let </span><span class=\"kw-2\">mut </span>map = BTreeMap::new();\nmap.insert(<span class=\"number\">1</span>, <span class=\"string\">\"a\"</span>);\n<span class=\"macro\">assert_eq!</span>(map.get(<span class=\"kw-2\">&</span><span class=\"number\">1</span>), <span class=\"prelude-val\">Some</span>(<span class=\"kw-2\">&</span><span class=\"string\">\"a\"</span>));\n<span class=\"macro\">assert_eq!</span>(map.get(<span class=\"kw-2\">&</span><span class=\"number\">2</span>), <span class=\"prelude-val\">None</span>);</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.get_key_value\" class=\"method\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.40.0\">1.40.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/collections/btree/map.rs.html#724-727\">source</a></span><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html#tymethod.get_key_value\" class=\"fn\">get_key_value</a><Q>(&self, k: <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.reference.html\">&Q</a>) -> <a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/core/option/enum.Option.html\" title=\"enum core::option::Option\">Option</a><(<a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.reference.html\">&K</a>, <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.reference.html\">&V</a>)><div class=\"where\">where\n K: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/borrow/trait.Borrow.html\" title=\"trait core::borrow::Borrow\">Borrow</a><Q> + <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html\" title=\"trait core::cmp::Ord\">Ord</a>,\n Q: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html\" title=\"trait core::cmp::Ord\">Ord</a> + ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,</div></h4></section></summary><div class=\"docblock\"><p>Returns the key-value pair corresponding to the supplied key.</p>\n<p>The supplied key may be any borrowed form of the map’s key type, but the ordering\non the borrowed form <em>must</em> match the ordering on the key type.</p>\n<h5 id=\"examples-1\"><a class=\"doc-anchor\" href=\"#examples-1\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::collections::BTreeMap;\n\n<span class=\"kw\">let </span><span class=\"kw-2\">mut </span>map = BTreeMap::new();\nmap.insert(<span class=\"number\">1</span>, <span class=\"string\">\"a\"</span>);\n<span class=\"macro\">assert_eq!</span>(map.get_key_value(<span class=\"kw-2\">&</span><span class=\"number\">1</span>), <span class=\"prelude-val\">Some</span>((<span class=\"kw-2\">&</span><span class=\"number\">1</span>, <span class=\"kw-2\">&</span><span class=\"string\">\"a\"</span>)));\n<span class=\"macro\">assert_eq!</span>(map.get_key_value(<span class=\"kw-2\">&</span><span class=\"number\">2</span>), <span class=\"prelude-val\">None</span>);</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.first_key_value\" class=\"method\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.66.0\">1.66.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/collections/btree/map.rs.html#751-753\">source</a></span><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html#tymethod.first_key_value\" class=\"fn\">first_key_value</a>(&self) -> <a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/core/option/enum.Option.html\" title=\"enum core::option::Option\">Option</a><(<a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.reference.html\">&K</a>, <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.reference.html\">&V</a>)><div class=\"where\">where\n K: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html\" title=\"trait core::cmp::Ord\">Ord</a>,</div></h4></section></summary><div class=\"docblock\"><p>Returns the first key-value pair in the map.\nThe key in this pair is the minimum key in the map.</p>\n<h5 id=\"examples-2\"><a class=\"doc-anchor\" href=\"#examples-2\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::collections::BTreeMap;\n\n<span class=\"kw\">let </span><span class=\"kw-2\">mut </span>map = BTreeMap::new();\n<span class=\"macro\">assert_eq!</span>(map.first_key_value(), <span class=\"prelude-val\">None</span>);\nmap.insert(<span class=\"number\">1</span>, <span class=\"string\">\"b\"</span>);\nmap.insert(<span class=\"number\">2</span>, <span class=\"string\">\"a\"</span>);\n<span class=\"macro\">assert_eq!</span>(map.first_key_value(), <span class=\"prelude-val\">Some</span>((<span class=\"kw-2\">&</span><span class=\"number\">1</span>, <span class=\"kw-2\">&</span><span class=\"string\">\"b\"</span>)));</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.first_entry\" class=\"method\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.66.0\">1.66.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/collections/btree/map.rs.html#779-781\">source</a></span><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html#tymethod.first_entry\" class=\"fn\">first_entry</a>(&mut self) -> <a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/core/option/enum.Option.html\" title=\"enum core::option::Option\">Option</a><<a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/entry/struct.OccupiedEntry.html\" title=\"struct alloc::collections::btree::map::entry::OccupiedEntry\">OccupiedEntry</a><'_, K, V, A>><div class=\"where\">where\n K: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html\" title=\"trait core::cmp::Ord\">Ord</a>,</div></h4></section></summary><div class=\"docblock\"><p>Returns the first entry in the map for in-place manipulation.\nThe key of this entry is the minimum key in the map.</p>\n<h5 id=\"examples-3\"><a class=\"doc-anchor\" href=\"#examples-3\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::collections::BTreeMap;\n\n<span class=\"kw\">let </span><span class=\"kw-2\">mut </span>map = BTreeMap::new();\nmap.insert(<span class=\"number\">1</span>, <span class=\"string\">\"a\"</span>);\nmap.insert(<span class=\"number\">2</span>, <span class=\"string\">\"b\"</span>);\n<span class=\"kw\">if let </span><span class=\"prelude-val\">Some</span>(<span class=\"kw-2\">mut </span>entry) = map.first_entry() {\n <span class=\"kw\">if </span><span class=\"kw-2\">*</span>entry.key() > <span class=\"number\">0 </span>{\n entry.insert(<span class=\"string\">\"first\"</span>);\n }\n}\n<span class=\"macro\">assert_eq!</span>(<span class=\"kw-2\">*</span>map.get(<span class=\"kw-2\">&</span><span class=\"number\">1</span>).unwrap(), <span class=\"string\">\"first\"</span>);\n<span class=\"macro\">assert_eq!</span>(<span class=\"kw-2\">*</span>map.get(<span class=\"kw-2\">&</span><span class=\"number\">2</span>).unwrap(), <span class=\"string\">\"b\"</span>);</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.pop_first\" class=\"method\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.66.0\">1.66.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/collections/btree/map.rs.html#813-815\">source</a></span><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html#tymethod.pop_first\" class=\"fn\">pop_first</a>(&mut self) -> <a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/core/option/enum.Option.html\" title=\"enum core::option::Option\">Option</a><<a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.tuple.html\">(K, V)</a>><div class=\"where\">where\n K: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html\" title=\"trait core::cmp::Ord\">Ord</a>,</div></h4></section></summary><div class=\"docblock\"><p>Removes and returns the first element in the map.\nThe key of this element is the minimum key that was in the map.</p>\n<h5 id=\"examples-4\"><a class=\"doc-anchor\" href=\"#examples-4\">§</a>Examples</h5>\n<p>Draining elements in ascending order, while keeping a usable map each iteration.</p>\n\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::collections::BTreeMap;\n\n<span class=\"kw\">let </span><span class=\"kw-2\">mut </span>map = BTreeMap::new();\nmap.insert(<span class=\"number\">1</span>, <span class=\"string\">\"a\"</span>);\nmap.insert(<span class=\"number\">2</span>, <span class=\"string\">\"b\"</span>);\n<span class=\"kw\">while let </span><span class=\"prelude-val\">Some</span>((key, _val)) = map.pop_first() {\n <span class=\"macro\">assert!</span>(map.iter().all(|(k, _v)| <span class=\"kw-2\">*</span>k > key));\n}\n<span class=\"macro\">assert!</span>(map.is_empty());</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.last_key_value\" class=\"method\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.66.0\">1.66.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/collections/btree/map.rs.html#834-836\">source</a></span><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html#tymethod.last_key_value\" class=\"fn\">last_key_value</a>(&self) -> <a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/core/option/enum.Option.html\" title=\"enum core::option::Option\">Option</a><(<a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.reference.html\">&K</a>, <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.reference.html\">&V</a>)><div class=\"where\">where\n K: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html\" title=\"trait core::cmp::Ord\">Ord</a>,</div></h4></section></summary><div class=\"docblock\"><p>Returns the last key-value pair in the map.\nThe key in this pair is the maximum key in the map.</p>\n<h5 id=\"examples-5\"><a class=\"doc-anchor\" href=\"#examples-5\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::collections::BTreeMap;\n\n<span class=\"kw\">let </span><span class=\"kw-2\">mut </span>map = BTreeMap::new();\nmap.insert(<span class=\"number\">1</span>, <span class=\"string\">\"b\"</span>);\nmap.insert(<span class=\"number\">2</span>, <span class=\"string\">\"a\"</span>);\n<span class=\"macro\">assert_eq!</span>(map.last_key_value(), <span class=\"prelude-val\">Some</span>((<span class=\"kw-2\">&</span><span class=\"number\">2</span>, <span class=\"kw-2\">&</span><span class=\"string\">\"a\"</span>)));</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.last_entry\" class=\"method\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.66.0\">1.66.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/collections/btree/map.rs.html#862-864\">source</a></span><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html#tymethod.last_entry\" class=\"fn\">last_entry</a>(&mut self) -> <a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/core/option/enum.Option.html\" title=\"enum core::option::Option\">Option</a><<a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/entry/struct.OccupiedEntry.html\" title=\"struct alloc::collections::btree::map::entry::OccupiedEntry\">OccupiedEntry</a><'_, K, V, A>><div class=\"where\">where\n K: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html\" title=\"trait core::cmp::Ord\">Ord</a>,</div></h4></section></summary><div class=\"docblock\"><p>Returns the last entry in the map for in-place manipulation.\nThe key of this entry is the maximum key in the map.</p>\n<h5 id=\"examples-6\"><a class=\"doc-anchor\" href=\"#examples-6\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::collections::BTreeMap;\n\n<span class=\"kw\">let </span><span class=\"kw-2\">mut </span>map = BTreeMap::new();\nmap.insert(<span class=\"number\">1</span>, <span class=\"string\">\"a\"</span>);\nmap.insert(<span class=\"number\">2</span>, <span class=\"string\">\"b\"</span>);\n<span class=\"kw\">if let </span><span class=\"prelude-val\">Some</span>(<span class=\"kw-2\">mut </span>entry) = map.last_entry() {\n <span class=\"kw\">if </span><span class=\"kw-2\">*</span>entry.key() > <span class=\"number\">0 </span>{\n entry.insert(<span class=\"string\">\"last\"</span>);\n }\n}\n<span class=\"macro\">assert_eq!</span>(<span class=\"kw-2\">*</span>map.get(<span class=\"kw-2\">&</span><span class=\"number\">1</span>).unwrap(), <span class=\"string\">\"a\"</span>);\n<span class=\"macro\">assert_eq!</span>(<span class=\"kw-2\">*</span>map.get(<span class=\"kw-2\">&</span><span class=\"number\">2</span>).unwrap(), <span class=\"string\">\"last\"</span>);</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.pop_last\" class=\"method\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.66.0\">1.66.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/collections/btree/map.rs.html#896-898\">source</a></span><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html#tymethod.pop_last\" class=\"fn\">pop_last</a>(&mut self) -> <a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/core/option/enum.Option.html\" title=\"enum core::option::Option\">Option</a><<a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.tuple.html\">(K, V)</a>><div class=\"where\">where\n K: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html\" title=\"trait core::cmp::Ord\">Ord</a>,</div></h4></section></summary><div class=\"docblock\"><p>Removes and returns the last element in the map.\nThe key of this element is the maximum key that was in the map.</p>\n<h5 id=\"examples-7\"><a class=\"doc-anchor\" href=\"#examples-7\">§</a>Examples</h5>\n<p>Draining elements in descending order, while keeping a usable map each iteration.</p>\n\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::collections::BTreeMap;\n\n<span class=\"kw\">let </span><span class=\"kw-2\">mut </span>map = BTreeMap::new();\nmap.insert(<span class=\"number\">1</span>, <span class=\"string\">\"a\"</span>);\nmap.insert(<span class=\"number\">2</span>, <span class=\"string\">\"b\"</span>);\n<span class=\"kw\">while let </span><span class=\"prelude-val\">Some</span>((key, _val)) = map.pop_last() {\n <span class=\"macro\">assert!</span>(map.iter().all(|(k, _v)| <span class=\"kw-2\">*</span>k < key));\n}\n<span class=\"macro\">assert!</span>(map.is_empty());</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.contains_key\" class=\"method\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.0.0\">1.0.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/collections/btree/map.rs.html#919-922\">source</a></span><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html#tymethod.contains_key\" class=\"fn\">contains_key</a><Q>(&self, key: <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.reference.html\">&Q</a>) -> <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.bool.html\">bool</a><div class=\"where\">where\n K: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/borrow/trait.Borrow.html\" title=\"trait core::borrow::Borrow\">Borrow</a><Q> + <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html\" title=\"trait core::cmp::Ord\">Ord</a>,\n Q: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html\" title=\"trait core::cmp::Ord\">Ord</a> + ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,</div></h4></section></summary><div class=\"docblock\"><p>Returns <code>true</code> if the map contains a value for the specified key.</p>\n<p>The key may be any borrowed form of the map’s key type, but the ordering\non the borrowed form <em>must</em> match the ordering on the key type.</p>\n<h5 id=\"examples-8\"><a class=\"doc-anchor\" href=\"#examples-8\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::collections::BTreeMap;\n\n<span class=\"kw\">let </span><span class=\"kw-2\">mut </span>map = BTreeMap::new();\nmap.insert(<span class=\"number\">1</span>, <span class=\"string\">\"a\"</span>);\n<span class=\"macro\">assert_eq!</span>(map.contains_key(<span class=\"kw-2\">&</span><span class=\"number\">1</span>), <span class=\"bool-val\">true</span>);\n<span class=\"macro\">assert_eq!</span>(map.contains_key(<span class=\"kw-2\">&</span><span class=\"number\">2</span>), <span class=\"bool-val\">false</span>);</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.get_mut\" class=\"method\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.0.0\">1.0.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/collections/btree/map.rs.html#946-949\">source</a></span><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html#tymethod.get_mut\" class=\"fn\">get_mut</a><Q>(&mut self, key: <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.reference.html\">&Q</a>) -> <a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/core/option/enum.Option.html\" title=\"enum core::option::Option\">Option</a><<a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.reference.html\">&mut V</a>><div class=\"where\">where\n K: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/borrow/trait.Borrow.html\" title=\"trait core::borrow::Borrow\">Borrow</a><Q> + <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html\" title=\"trait core::cmp::Ord\">Ord</a>,\n Q: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html\" title=\"trait core::cmp::Ord\">Ord</a> + ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,</div></h4></section></summary><div class=\"docblock\"><p>Returns a mutable reference to the value corresponding to the key.</p>\n<p>The key may be any borrowed form of the map’s key type, but the ordering\non the borrowed form <em>must</em> match the ordering on the key type.</p>\n<h5 id=\"examples-9\"><a class=\"doc-anchor\" href=\"#examples-9\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::collections::BTreeMap;\n\n<span class=\"kw\">let </span><span class=\"kw-2\">mut </span>map = BTreeMap::new();\nmap.insert(<span class=\"number\">1</span>, <span class=\"string\">\"a\"</span>);\n<span class=\"kw\">if let </span><span class=\"prelude-val\">Some</span>(x) = map.get_mut(<span class=\"kw-2\">&</span><span class=\"number\">1</span>) {\n <span class=\"kw-2\">*</span>x = <span class=\"string\">\"b\"</span>;\n}\n<span class=\"macro\">assert_eq!</span>(map[<span class=\"kw-2\">&</span><span class=\"number\">1</span>], <span class=\"string\">\"b\"</span>);</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.insert\" class=\"method\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.0.0\">1.0.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/collections/btree/map.rs.html#984-986\">source</a></span><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html#tymethod.insert\" class=\"fn\">insert</a>(&mut self, key: K, value: V) -> <a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/core/option/enum.Option.html\" title=\"enum core::option::Option\">Option</a><V><div class=\"where\">where\n K: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html\" title=\"trait core::cmp::Ord\">Ord</a>,</div></h4></section></summary><div class=\"docblock\"><p>Inserts a key-value pair into the map.</p>\n<p>If the map did not have this key present, <code>None</code> is returned.</p>\n<p>If the map did have this key present, the value is updated, and the old\nvalue is returned. The key is not updated, though; this matters for\ntypes that can be <code>==</code> without being identical. See the <a href=\"index.html#insert-and-complex-keys\">module-level\ndocumentation</a> for more.</p>\n<h5 id=\"examples-10\"><a class=\"doc-anchor\" href=\"#examples-10\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::collections::BTreeMap;\n\n<span class=\"kw\">let </span><span class=\"kw-2\">mut </span>map = BTreeMap::new();\n<span class=\"macro\">assert_eq!</span>(map.insert(<span class=\"number\">37</span>, <span class=\"string\">\"a\"</span>), <span class=\"prelude-val\">None</span>);\n<span class=\"macro\">assert_eq!</span>(map.is_empty(), <span class=\"bool-val\">false</span>);\n\nmap.insert(<span class=\"number\">37</span>, <span class=\"string\">\"b\"</span>);\n<span class=\"macro\">assert_eq!</span>(map.insert(<span class=\"number\">37</span>, <span class=\"string\">\"c\"</span>), <span class=\"prelude-val\">Some</span>(<span class=\"string\">\"b\"</span>));\n<span class=\"macro\">assert_eq!</span>(map[<span class=\"kw-2\">&</span><span class=\"number\">37</span>], <span class=\"string\">\"c\"</span>);</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.try_insert\" class=\"method\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/collections/btree/map.rs.html#1019-1021\">source</a><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html#tymethod.try_insert\" class=\"fn\">try_insert</a>(\n &mut self,\n key: K,\n value: V\n) -> <a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/core/result/enum.Result.html\" title=\"enum core::result::Result\">Result</a><<a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.reference.html\">&mut V</a>, <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/entry/struct.OccupiedError.html\" title=\"struct alloc::collections::btree::map::entry::OccupiedError\">OccupiedError</a><'_, K, V, A>><div class=\"where\">where\n K: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html\" title=\"trait core::cmp::Ord\">Ord</a>,</div></h4></section><span class=\"item-info\"><div class=\"stab unstable\"><span class=\"emoji\">🔬</span><span>This is a nightly-only experimental API. (<code>map_try_insert</code>)</span></div></span></summary><div class=\"docblock\"><p>Tries to insert a key-value pair into the map, and returns\na mutable reference to the value in the entry.</p>\n<p>If the map already had this key present, nothing is updated, and\nan error containing the occupied entry and the value is returned.</p>\n<h5 id=\"examples-11\"><a class=\"doc-anchor\" href=\"#examples-11\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"attr\">#![feature(map_try_insert)]\n\n</span><span class=\"kw\">use </span>std::collections::BTreeMap;\n\n<span class=\"kw\">let </span><span class=\"kw-2\">mut </span>map = BTreeMap::new();\n<span class=\"macro\">assert_eq!</span>(map.try_insert(<span class=\"number\">37</span>, <span class=\"string\">\"a\"</span>).unwrap(), <span class=\"kw-2\">&</span><span class=\"string\">\"a\"</span>);\n\n<span class=\"kw\">let </span>err = map.try_insert(<span class=\"number\">37</span>, <span class=\"string\">\"b\"</span>).unwrap_err();\n<span class=\"macro\">assert_eq!</span>(err.entry.key(), <span class=\"kw-2\">&</span><span class=\"number\">37</span>);\n<span class=\"macro\">assert_eq!</span>(err.entry.get(), <span class=\"kw-2\">&</span><span class=\"string\">\"a\"</span>);\n<span class=\"macro\">assert_eq!</span>(err.value, <span class=\"string\">\"b\"</span>);</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.remove\" class=\"method\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.0.0\">1.0.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/collections/btree/map.rs.html#1047-1050\">source</a></span><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html#tymethod.remove\" class=\"fn\">remove</a><Q>(&mut self, key: <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.reference.html\">&Q</a>) -> <a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/core/option/enum.Option.html\" title=\"enum core::option::Option\">Option</a><V><div class=\"where\">where\n K: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/borrow/trait.Borrow.html\" title=\"trait core::borrow::Borrow\">Borrow</a><Q> + <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html\" title=\"trait core::cmp::Ord\">Ord</a>,\n Q: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html\" title=\"trait core::cmp::Ord\">Ord</a> + ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,</div></h4></section></summary><div class=\"docblock\"><p>Removes a key from the map, returning the value at the key if the key\nwas previously in the map.</p>\n<p>The key may be any borrowed form of the map’s key type, but the ordering\non the borrowed form <em>must</em> match the ordering on the key type.</p>\n<h5 id=\"examples-12\"><a class=\"doc-anchor\" href=\"#examples-12\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::collections::BTreeMap;\n\n<span class=\"kw\">let </span><span class=\"kw-2\">mut </span>map = BTreeMap::new();\nmap.insert(<span class=\"number\">1</span>, <span class=\"string\">\"a\"</span>);\n<span class=\"macro\">assert_eq!</span>(map.remove(<span class=\"kw-2\">&</span><span class=\"number\">1</span>), <span class=\"prelude-val\">Some</span>(<span class=\"string\">\"a\"</span>));\n<span class=\"macro\">assert_eq!</span>(map.remove(<span class=\"kw-2\">&</span><span class=\"number\">1</span>), <span class=\"prelude-val\">None</span>);</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.remove_entry\" class=\"method\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.45.0\">1.45.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/collections/btree/map.rs.html#1072-1075\">source</a></span><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html#tymethod.remove_entry\" class=\"fn\">remove_entry</a><Q>(&mut self, key: <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.reference.html\">&Q</a>) -> <a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/core/option/enum.Option.html\" title=\"enum core::option::Option\">Option</a><<a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.tuple.html\">(K, V)</a>><div class=\"where\">where\n K: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/borrow/trait.Borrow.html\" title=\"trait core::borrow::Borrow\">Borrow</a><Q> + <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html\" title=\"trait core::cmp::Ord\">Ord</a>,\n Q: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html\" title=\"trait core::cmp::Ord\">Ord</a> + ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,</div></h4></section></summary><div class=\"docblock\"><p>Removes a key from the map, returning the stored key and value if the key\nwas previously in the map.</p>\n<p>The key may be any borrowed form of the map’s key type, but the ordering\non the borrowed form <em>must</em> match the ordering on the key type.</p>\n<h5 id=\"examples-13\"><a class=\"doc-anchor\" href=\"#examples-13\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::collections::BTreeMap;\n\n<span class=\"kw\">let </span><span class=\"kw-2\">mut </span>map = BTreeMap::new();\nmap.insert(<span class=\"number\">1</span>, <span class=\"string\">\"a\"</span>);\n<span class=\"macro\">assert_eq!</span>(map.remove_entry(<span class=\"kw-2\">&</span><span class=\"number\">1</span>), <span class=\"prelude-val\">Some</span>((<span class=\"number\">1</span>, <span class=\"string\">\"a\"</span>)));\n<span class=\"macro\">assert_eq!</span>(map.remove_entry(<span class=\"kw-2\">&</span><span class=\"number\">1</span>), <span class=\"prelude-val\">None</span>);</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.retain\" class=\"method\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.53.0\">1.53.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/collections/btree/map.rs.html#1110-1113\">source</a></span><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html#tymethod.retain\" class=\"fn\">retain</a><F>(&mut self, f: F)<div class=\"where\">where\n K: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html\" title=\"trait core::cmp::Ord\">Ord</a>,\n F: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/ops/function/trait.FnMut.html\" title=\"trait core::ops::function::FnMut\">FnMut</a>(<a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.reference.html\">&K</a>, <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.reference.html\">&mut V</a>) -> <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.bool.html\">bool</a>,</div></h4></section></summary><div class=\"docblock\"><p>Retains only the elements specified by the predicate.</p>\n<p>In other words, remove all pairs <code>(k, v)</code> for which <code>f(&k, &mut v)</code> returns <code>false</code>.\nThe elements are visited in ascending key order.</p>\n<h5 id=\"examples-14\"><a class=\"doc-anchor\" href=\"#examples-14\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::collections::BTreeMap;\n\n<span class=\"kw\">let </span><span class=\"kw-2\">mut </span>map: BTreeMap<i32, i32> = (<span class=\"number\">0</span>..<span class=\"number\">8</span>).map(|x| (x, x<span class=\"kw-2\">*</span><span class=\"number\">10</span>)).collect();\n<span class=\"comment\">// Keep only the elements with even-numbered keys.\n</span>map.retain(|<span class=\"kw-2\">&</span>k, <span class=\"kw\">_</span>| k % <span class=\"number\">2 </span>== <span class=\"number\">0</span>);\n<span class=\"macro\">assert!</span>(map.into_iter().eq(<span class=\"macro\">vec!</span>[(<span class=\"number\">0</span>, <span class=\"number\">0</span>), (<span class=\"number\">2</span>, <span class=\"number\">20</span>), (<span class=\"number\">4</span>, <span class=\"number\">40</span>), (<span class=\"number\">6</span>, <span class=\"number\">60</span>)]));</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.append\" class=\"method\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.11.0\">1.11.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/collections/btree/map.rs.html#1150-1153\">source</a></span><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html#tymethod.append\" class=\"fn\">append</a>(&mut self, other: &mut <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html\" title=\"struct alloc::collections::btree::map::BTreeMap\">BTreeMap</a><K, V, A>)<div class=\"where\">where\n K: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html\" title=\"trait core::cmp::Ord\">Ord</a>,\n A: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/clone/trait.Clone.html\" title=\"trait core::clone::Clone\">Clone</a>,</div></h4></section></summary><div class=\"docblock\"><p>Moves all elements from <code>other</code> into <code>self</code>, leaving <code>other</code> empty.</p>\n<p>If a key from <code>other</code> is already present in <code>self</code>, the respective\nvalue from <code>self</code> will be overwritten with the respective value from <code>other</code>.</p>\n<h5 id=\"examples-15\"><a class=\"doc-anchor\" href=\"#examples-15\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::collections::BTreeMap;\n\n<span class=\"kw\">let </span><span class=\"kw-2\">mut </span>a = BTreeMap::new();\na.insert(<span class=\"number\">1</span>, <span class=\"string\">\"a\"</span>);\na.insert(<span class=\"number\">2</span>, <span class=\"string\">\"b\"</span>);\na.insert(<span class=\"number\">3</span>, <span class=\"string\">\"c\"</span>); <span class=\"comment\">// Note: Key (3) also present in b.\n\n</span><span class=\"kw\">let </span><span class=\"kw-2\">mut </span>b = BTreeMap::new();\nb.insert(<span class=\"number\">3</span>, <span class=\"string\">\"d\"</span>); <span class=\"comment\">// Note: Key (3) also present in a.\n</span>b.insert(<span class=\"number\">4</span>, <span class=\"string\">\"e\"</span>);\nb.insert(<span class=\"number\">5</span>, <span class=\"string\">\"f\"</span>);\n\na.append(<span class=\"kw-2\">&mut </span>b);\n\n<span class=\"macro\">assert_eq!</span>(a.len(), <span class=\"number\">5</span>);\n<span class=\"macro\">assert_eq!</span>(b.len(), <span class=\"number\">0</span>);\n\n<span class=\"macro\">assert_eq!</span>(a[<span class=\"kw-2\">&</span><span class=\"number\">1</span>], <span class=\"string\">\"a\"</span>);\n<span class=\"macro\">assert_eq!</span>(a[<span class=\"kw-2\">&</span><span class=\"number\">2</span>], <span class=\"string\">\"b\"</span>);\n<span class=\"macro\">assert_eq!</span>(a[<span class=\"kw-2\">&</span><span class=\"number\">3</span>], <span class=\"string\">\"d\"</span>); <span class=\"comment\">// Note: \"c\" has been overwritten.\n</span><span class=\"macro\">assert_eq!</span>(a[<span class=\"kw-2\">&</span><span class=\"number\">4</span>], <span class=\"string\">\"e\"</span>);\n<span class=\"macro\">assert_eq!</span>(a[<span class=\"kw-2\">&</span><span class=\"number\">5</span>], <span class=\"string\">\"f\"</span>);</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.range\" class=\"method\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.17.0\">1.17.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/collections/btree/map.rs.html#1205-1209\">source</a></span><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html#tymethod.range\" class=\"fn\">range</a><T, R>(&self, range: R) -> <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.Range.html\" title=\"struct alloc::collections::btree::map::Range\">Range</a><'_, K, V><div class=\"where\">where\n T: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html\" title=\"trait core::cmp::Ord\">Ord</a> + ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,\n K: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/borrow/trait.Borrow.html\" title=\"trait core::borrow::Borrow\">Borrow</a><T> + <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html\" title=\"trait core::cmp::Ord\">Ord</a>,\n R: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/ops/range/trait.RangeBounds.html\" title=\"trait core::ops::range::RangeBounds\">RangeBounds</a><T>,</div></h4></section></summary><div class=\"docblock\"><p>Constructs a double-ended iterator over a sub-range of elements in the map.\nThe simplest way is to use the range syntax <code>min..max</code>, thus <code>range(min..max)</code> will\nyield elements from min (inclusive) to max (exclusive).\nThe range may also be entered as <code>(Bound<T>, Bound<T>)</code>, so for example\n<code>range((Excluded(4), Included(10)))</code> will yield a left-exclusive, right-inclusive\nrange from 4 to 10.</p>\n<h5 id=\"panics\"><a class=\"doc-anchor\" href=\"#panics\">§</a>Panics</h5>\n<p>Panics if range <code>start > end</code>.\nPanics if range <code>start == end</code> and both bounds are <code>Excluded</code>.</p>\n<h5 id=\"examples-16\"><a class=\"doc-anchor\" href=\"#examples-16\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::collections::BTreeMap;\n<span class=\"kw\">use </span>std::ops::Bound::Included;\n\n<span class=\"kw\">let </span><span class=\"kw-2\">mut </span>map = BTreeMap::new();\nmap.insert(<span class=\"number\">3</span>, <span class=\"string\">\"a\"</span>);\nmap.insert(<span class=\"number\">5</span>, <span class=\"string\">\"b\"</span>);\nmap.insert(<span class=\"number\">8</span>, <span class=\"string\">\"c\"</span>);\n<span class=\"kw\">for </span>(<span class=\"kw-2\">&</span>key, <span class=\"kw-2\">&</span>value) <span class=\"kw\">in </span>map.range((Included(<span class=\"kw-2\">&</span><span class=\"number\">4</span>), Included(<span class=\"kw-2\">&</span><span class=\"number\">8</span>))) {\n <span class=\"macro\">println!</span>(<span class=\"string\">\"{key}: {value}\"</span>);\n}\n<span class=\"macro\">assert_eq!</span>(<span class=\"prelude-val\">Some</span>((<span class=\"kw-2\">&</span><span class=\"number\">5</span>, <span class=\"kw-2\">&</span><span class=\"string\">\"b\"</span>)), map.range(<span class=\"number\">4</span>..).next());</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.range_mut\" class=\"method\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.17.0\">1.17.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/collections/btree/map.rs.html#1245-1249\">source</a></span><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html#tymethod.range_mut\" class=\"fn\">range_mut</a><T, R>(&mut self, range: R) -> <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.RangeMut.html\" title=\"struct alloc::collections::btree::map::RangeMut\">RangeMut</a><'_, K, V><div class=\"where\">where\n T: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html\" title=\"trait core::cmp::Ord\">Ord</a> + ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,\n K: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/borrow/trait.Borrow.html\" title=\"trait core::borrow::Borrow\">Borrow</a><T> + <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html\" title=\"trait core::cmp::Ord\">Ord</a>,\n R: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/ops/range/trait.RangeBounds.html\" title=\"trait core::ops::range::RangeBounds\">RangeBounds</a><T>,</div></h4></section></summary><div class=\"docblock\"><p>Constructs a mutable double-ended iterator over a sub-range of elements in the map.\nThe simplest way is to use the range syntax <code>min..max</code>, thus <code>range(min..max)</code> will\nyield elements from min (inclusive) to max (exclusive).\nThe range may also be entered as <code>(Bound<T>, Bound<T>)</code>, so for example\n<code>range((Excluded(4), Included(10)))</code> will yield a left-exclusive, right-inclusive\nrange from 4 to 10.</p>\n<h5 id=\"panics-1\"><a class=\"doc-anchor\" href=\"#panics-1\">§</a>Panics</h5>\n<p>Panics if range <code>start > end</code>.\nPanics if range <code>start == end</code> and both bounds are <code>Excluded</code>.</p>\n<h5 id=\"examples-17\"><a class=\"doc-anchor\" href=\"#examples-17\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::collections::BTreeMap;\n\n<span class=\"kw\">let </span><span class=\"kw-2\">mut </span>map: BTreeMap<<span class=\"kw-2\">&</span>str, i32> =\n [(<span class=\"string\">\"Alice\"</span>, <span class=\"number\">0</span>), (<span class=\"string\">\"Bob\"</span>, <span class=\"number\">0</span>), (<span class=\"string\">\"Carol\"</span>, <span class=\"number\">0</span>), (<span class=\"string\">\"Cheryl\"</span>, <span class=\"number\">0</span>)].into();\n<span class=\"kw\">for </span>(<span class=\"kw\">_</span>, balance) <span class=\"kw\">in </span>map.range_mut(<span class=\"string\">\"B\"</span>..<span class=\"string\">\"Cheryl\"</span>) {\n <span class=\"kw-2\">*</span>balance += <span class=\"number\">100</span>;\n}\n<span class=\"kw\">for </span>(name, balance) <span class=\"kw\">in </span><span class=\"kw-2\">&</span>map {\n <span class=\"macro\">println!</span>(<span class=\"string\">\"{name} => {balance}\"</span>);\n}</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.entry\" class=\"method\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.0.0\">1.0.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/collections/btree/map.rs.html#1277-1279\">source</a></span><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html#tymethod.entry\" class=\"fn\">entry</a>(&mut self, key: K) -> <a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/entry/enum.Entry.html\" title=\"enum alloc::collections::btree::map::entry::Entry\">Entry</a><'_, K, V, A><div class=\"where\">where\n K: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html\" title=\"trait core::cmp::Ord\">Ord</a>,</div></h4></section></summary><div class=\"docblock\"><p>Gets the given key’s corresponding entry in the map for in-place manipulation.</p>\n<h5 id=\"examples-18\"><a class=\"doc-anchor\" href=\"#examples-18\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::collections::BTreeMap;\n\n<span class=\"kw\">let </span><span class=\"kw-2\">mut </span>count: BTreeMap<<span class=\"kw-2\">&</span>str, usize> = BTreeMap::new();\n\n<span class=\"comment\">// count the number of occurrences of letters in the vec\n</span><span class=\"kw\">for </span>x <span class=\"kw\">in </span>[<span class=\"string\">\"a\"</span>, <span class=\"string\">\"b\"</span>, <span class=\"string\">\"a\"</span>, <span class=\"string\">\"c\"</span>, <span class=\"string\">\"a\"</span>, <span class=\"string\">\"b\"</span>] {\n count.entry(x).and_modify(|curr| <span class=\"kw-2\">*</span>curr += <span class=\"number\">1</span>).or_insert(<span class=\"number\">1</span>);\n}\n\n<span class=\"macro\">assert_eq!</span>(count[<span class=\"string\">\"a\"</span>], <span class=\"number\">3</span>);\n<span class=\"macro\">assert_eq!</span>(count[<span class=\"string\">\"b\"</span>], <span class=\"number\">2</span>);\n<span class=\"macro\">assert_eq!</span>(count[<span class=\"string\">\"c\"</span>], <span class=\"number\">1</span>);</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.split_off\" class=\"method\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.11.0\">1.11.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/collections/btree/map.rs.html#1336-1339\">source</a></span><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html#tymethod.split_off\" class=\"fn\">split_off</a><Q>(&mut self, key: <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.reference.html\">&Q</a>) -> <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html\" title=\"struct alloc::collections::btree::map::BTreeMap\">BTreeMap</a><K, V, A><div class=\"where\">where\n Q: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html\" title=\"trait core::cmp::Ord\">Ord</a> + ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,\n K: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/borrow/trait.Borrow.html\" title=\"trait core::borrow::Borrow\">Borrow</a><Q> + <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html\" title=\"trait core::cmp::Ord\">Ord</a>,\n A: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/clone/trait.Clone.html\" title=\"trait core::clone::Clone\">Clone</a>,</div></h4></section></summary><div class=\"docblock\"><p>Splits the collection into two at the given key. Returns everything after the given key,\nincluding the key.</p>\n<h5 id=\"examples-19\"><a class=\"doc-anchor\" href=\"#examples-19\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::collections::BTreeMap;\n\n<span class=\"kw\">let </span><span class=\"kw-2\">mut </span>a = BTreeMap::new();\na.insert(<span class=\"number\">1</span>, <span class=\"string\">\"a\"</span>);\na.insert(<span class=\"number\">2</span>, <span class=\"string\">\"b\"</span>);\na.insert(<span class=\"number\">3</span>, <span class=\"string\">\"c\"</span>);\na.insert(<span class=\"number\">17</span>, <span class=\"string\">\"d\"</span>);\na.insert(<span class=\"number\">41</span>, <span class=\"string\">\"e\"</span>);\n\n<span class=\"kw\">let </span>b = a.split_off(<span class=\"kw-2\">&</span><span class=\"number\">3</span>);\n\n<span class=\"macro\">assert_eq!</span>(a.len(), <span class=\"number\">2</span>);\n<span class=\"macro\">assert_eq!</span>(b.len(), <span class=\"number\">3</span>);\n\n<span class=\"macro\">assert_eq!</span>(a[<span class=\"kw-2\">&</span><span class=\"number\">1</span>], <span class=\"string\">\"a\"</span>);\n<span class=\"macro\">assert_eq!</span>(a[<span class=\"kw-2\">&</span><span class=\"number\">2</span>], <span class=\"string\">\"b\"</span>);\n\n<span class=\"macro\">assert_eq!</span>(b[<span class=\"kw-2\">&</span><span class=\"number\">3</span>], <span class=\"string\">\"c\"</span>);\n<span class=\"macro\">assert_eq!</span>(b[<span class=\"kw-2\">&</span><span class=\"number\">17</span>], <span class=\"string\">\"d\"</span>);\n<span class=\"macro\">assert_eq!</span>(b[<span class=\"kw-2\">&</span><span class=\"number\">41</span>], <span class=\"string\">\"e\"</span>);</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.extract_if\" class=\"method\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/collections/btree/map.rs.html#1391-1394\">source</a><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html#tymethod.extract_if\" class=\"fn\">extract_if</a><F>(&mut self, pred: F) -> <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.ExtractIf.html\" title=\"struct alloc::collections::btree::map::ExtractIf\">ExtractIf</a><'_, K, V, F, A><div class=\"where\">where\n K: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html\" title=\"trait core::cmp::Ord\">Ord</a>,\n F: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/ops/function/trait.FnMut.html\" title=\"trait core::ops::function::FnMut\">FnMut</a>(<a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.reference.html\">&K</a>, <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.reference.html\">&mut V</a>) -> <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.bool.html\">bool</a>,</div></h4></section><span class=\"item-info\"><div class=\"stab unstable\"><span class=\"emoji\">🔬</span><span>This is a nightly-only experimental API. (<code>btree_extract_if</code>)</span></div></span></summary><div class=\"docblock\"><p>Creates an iterator that visits all elements (key-value pairs) in\nascending key order and uses a closure to determine if an element should\nbe removed. If the closure returns <code>true</code>, the element is removed from\nthe map and yielded. If the closure returns <code>false</code>, or panics, the\nelement remains in the map and will not be yielded.</p>\n<p>The iterator also lets you mutate the value of each element in the\nclosure, regardless of whether you choose to keep or remove it.</p>\n<p>If the returned <code>ExtractIf</code> is not exhausted, e.g. because it is dropped without iterating\nor the iteration short-circuits, then the remaining elements will be retained.\nUse <a href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html#method.retain\" title=\"method alloc::collections::btree::map::BTreeMap::retain\"><code>retain</code></a> with a negated predicate if you do not need the returned iterator.</p>\n<h5 id=\"examples-20\"><a class=\"doc-anchor\" href=\"#examples-20\">§</a>Examples</h5>\n<p>Splitting a map into even and odd keys, reusing the original map:</p>\n\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"attr\">#![feature(btree_extract_if)]\n</span><span class=\"kw\">use </span>std::collections::BTreeMap;\n\n<span class=\"kw\">let </span><span class=\"kw-2\">mut </span>map: BTreeMap<i32, i32> = (<span class=\"number\">0</span>..<span class=\"number\">8</span>).map(|x| (x, x)).collect();\n<span class=\"kw\">let </span>evens: BTreeMap<<span class=\"kw\">_</span>, <span class=\"kw\">_</span>> = map.extract_if(|k, _v| k % <span class=\"number\">2 </span>== <span class=\"number\">0</span>).collect();\n<span class=\"kw\">let </span>odds = map;\n<span class=\"macro\">assert_eq!</span>(evens.keys().copied().collect::<Vec<<span class=\"kw\">_</span>>>(), [<span class=\"number\">0</span>, <span class=\"number\">2</span>, <span class=\"number\">4</span>, <span class=\"number\">6</span>]);\n<span class=\"macro\">assert_eq!</span>(odds.keys().copied().collect::<Vec<<span class=\"kw\">_</span>>>(), [<span class=\"number\">1</span>, <span class=\"number\">3</span>, <span class=\"number\">5</span>, <span class=\"number\">7</span>]);</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.into_keys\" class=\"method\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.54.0\">1.54.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/collections/btree/map.rs.html#1445\">source</a></span><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html#tymethod.into_keys\" class=\"fn\">into_keys</a>(self) -> <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.IntoKeys.html\" title=\"struct alloc::collections::btree::map::IntoKeys\">IntoKeys</a><K, V, A></h4></section></summary><div class=\"docblock\"><p>Creates a consuming iterator visiting all the keys, in sorted order.\nThe map cannot be used after calling this.\nThe iterator element type is <code>K</code>.</p>\n<h5 id=\"examples-21\"><a class=\"doc-anchor\" href=\"#examples-21\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::collections::BTreeMap;\n\n<span class=\"kw\">let </span><span class=\"kw-2\">mut </span>a = BTreeMap::new();\na.insert(<span class=\"number\">2</span>, <span class=\"string\">\"b\"</span>);\na.insert(<span class=\"number\">1</span>, <span class=\"string\">\"a\"</span>);\n\n<span class=\"kw\">let </span>keys: Vec<i32> = a.into_keys().collect();\n<span class=\"macro\">assert_eq!</span>(keys, [<span class=\"number\">1</span>, <span class=\"number\">2</span>]);</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.into_values\" class=\"method\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.54.0\">1.54.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/collections/btree/map.rs.html#1467\">source</a></span><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html#tymethod.into_values\" class=\"fn\">into_values</a>(self) -> <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.IntoValues.html\" title=\"struct alloc::collections::btree::map::IntoValues\">IntoValues</a><K, V, A></h4></section></summary><div class=\"docblock\"><p>Creates a consuming iterator visiting all the values, in order by key.\nThe map cannot be used after calling this.\nThe iterator element type is <code>V</code>.</p>\n<h5 id=\"examples-22\"><a class=\"doc-anchor\" href=\"#examples-22\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::collections::BTreeMap;\n\n<span class=\"kw\">let </span><span class=\"kw-2\">mut </span>a = BTreeMap::new();\na.insert(<span class=\"number\">1</span>, <span class=\"string\">\"hello\"</span>);\na.insert(<span class=\"number\">2</span>, <span class=\"string\">\"goodbye\"</span>);\n\n<span class=\"kw\">let </span>values: Vec<<span class=\"kw-2\">&</span>str> = a.into_values().collect();\n<span class=\"macro\">assert_eq!</span>(values, [<span class=\"string\">\"hello\"</span>, <span class=\"string\">\"goodbye\"</span>]);</code></pre></div>\n</div></details></div></details>",0,"bdk_wallet::descriptor::policy::ConditionMap","bdk_wallet::descriptor::policy::FoldedConditionMap","bdk_wallet::descriptor::HdKeyPaths","bdk_wallet::descriptor::TapKeyOrigins","bdk_wallet::keys::KeyMap"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-Clone-for-BTreeMap%3CK,+V,+A%3E\" class=\"impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.0.0\">1.0.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/collections/btree/map.rs.html#207\">source</a></span><a href=\"#impl-Clone-for-BTreeMap%3CK,+V,+A%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl<K, V, A> <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/clone/trait.Clone.html\" title=\"trait core::clone::Clone\">Clone</a> for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html\" title=\"struct alloc::collections::btree::map::BTreeMap\">BTreeMap</a><K, V, A><div class=\"where\">where\n K: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/clone/trait.Clone.html\" title=\"trait core::clone::Clone\">Clone</a>,\n V: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/clone/trait.Clone.html\" title=\"trait core::clone::Clone\">Clone</a>,\n A: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/alloc/trait.Allocator.html\" title=\"trait core::alloc::Allocator\">Allocator</a> + <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/clone/trait.Clone.html\" title=\"trait core::clone::Clone\">Clone</a>,</div></h3></section></summary><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.clone\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/collections/btree/map.rs.html#208\">source</a><a href=\"#method.clone\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/clone/trait.Clone.html#tymethod.clone\" class=\"fn\">clone</a>(&self) -> <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html\" title=\"struct alloc::collections::btree::map::BTreeMap\">BTreeMap</a><K, V, A></h4></section></summary><div class='docblock'>Returns a copy of the value. <a href=\"https://doc.rust-lang.org/nightly/core/clone/trait.Clone.html#tymethod.clone\">Read more</a></div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.clone_from\" class=\"method trait-impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.0.0\">1.0.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/core/clone.rs.html#169\">source</a></span><a href=\"#method.clone_from\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/clone/trait.Clone.html#method.clone_from\" class=\"fn\">clone_from</a>(&mut self, source: <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.reference.html\">&Self</a>)</h4></section></summary><div class='docblock'>Performs copy-assignment from <code>source</code>. <a href=\"https://doc.rust-lang.org/nightly/core/clone/trait.Clone.html#method.clone_from\">Read more</a></div></details></div></details>","Clone","bdk_wallet::descriptor::policy::ConditionMap","bdk_wallet::descriptor::policy::FoldedConditionMap","bdk_wallet::descriptor::HdKeyPaths","bdk_wallet::descriptor::TapKeyOrigins","bdk_wallet::keys::KeyMap"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-Debug-for-BTreeMap%3CK,+V,+A%3E\" class=\"impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.0.0\">1.0.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/collections/btree/map.rs.html#2312\">source</a></span><a href=\"#impl-Debug-for-BTreeMap%3CK,+V,+A%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl<K, V, A> <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/fmt/trait.Debug.html\" title=\"trait core::fmt::Debug\">Debug</a> for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html\" title=\"struct alloc::collections::btree::map::BTreeMap\">BTreeMap</a><K, V, A><div class=\"where\">where\n K: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/fmt/trait.Debug.html\" title=\"trait core::fmt::Debug\">Debug</a>,\n V: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/fmt/trait.Debug.html\" title=\"trait core::fmt::Debug\">Debug</a>,\n A: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/alloc/trait.Allocator.html\" title=\"trait core::alloc::Allocator\">Allocator</a> + <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/clone/trait.Clone.html\" title=\"trait core::clone::Clone\">Clone</a>,</div></h3></section></summary><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.fmt\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/collections/btree/map.rs.html#2313\">source</a><a href=\"#method.fmt\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/fmt/trait.Debug.html#tymethod.fmt\" class=\"fn\">fmt</a>(&self, f: &mut <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/core/fmt/struct.Formatter.html\" title=\"struct core::fmt::Formatter\">Formatter</a><'_>) -> <a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/core/result/enum.Result.html\" title=\"enum core::result::Result\">Result</a><<a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.unit.html\">()</a>, <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/core/fmt/struct.Error.html\" title=\"struct core::fmt::Error\">Error</a>></h4></section></summary><div class='docblock'>Formats the value using the given formatter. <a href=\"https://doc.rust-lang.org/nightly/core/fmt/trait.Debug.html#tymethod.fmt\">Read more</a></div></details></div></details>","Debug","bdk_wallet::descriptor::policy::ConditionMap","bdk_wallet::descriptor::policy::FoldedConditionMap","bdk_wallet::descriptor::HdKeyPaths","bdk_wallet::descriptor::TapKeyOrigins","bdk_wallet::keys::KeyMap"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-Default-for-BTreeMap%3CK,+V%3E\" class=\"impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.0.0\">1.0.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/collections/btree/map.rs.html#2278\">source</a></span><a href=\"#impl-Default-for-BTreeMap%3CK,+V%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl<K, V> <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/default/trait.Default.html\" title=\"trait core::default::Default\">Default</a> for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html\" title=\"struct alloc::collections::btree::map::BTreeMap\">BTreeMap</a><K, V></h3></section></summary><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.default\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/collections/btree/map.rs.html#2280\">source</a><a href=\"#method.default\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/default/trait.Default.html#tymethod.default\" class=\"fn\">default</a>() -> <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html\" title=\"struct alloc::collections::btree::map::BTreeMap\">BTreeMap</a><K, V></h4></section></summary><div class=\"docblock\"><p>Creates an empty <code>BTreeMap</code>.</p>\n</div></details></div></details>","Default","bdk_wallet::descriptor::policy::ConditionMap","bdk_wallet::descriptor::policy::FoldedConditionMap","bdk_wallet::descriptor::HdKeyPaths","bdk_wallet::descriptor::TapKeyOrigins","bdk_wallet::keys::KeyMap"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-Deserialize%3C'de%3E-for-BTreeMap%3CK,+V%3E\" class=\"impl\"><a class=\"src rightside\" href=\"https://docs.rs/serde/1.0.203/src/serde/de/impls.rs.html#1568-1574\">source</a><a href=\"#impl-Deserialize%3C'de%3E-for-BTreeMap%3CK,+V%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl<'de, K, V> <a class=\"trait\" href=\"https://docs.rs/serde/1.0.203/serde/de/trait.Deserialize.html\" title=\"trait serde::de::Deserialize\">Deserialize</a><'de> for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html\" title=\"struct alloc::collections::btree::map::BTreeMap\">BTreeMap</a><K, V><div class=\"where\">where\n K: <a class=\"trait\" href=\"https://docs.rs/serde/1.0.203/serde/de/trait.Deserialize.html\" title=\"trait serde::de::Deserialize\">Deserialize</a><'de> + <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html\" title=\"trait core::cmp::Ord\">Ord</a>,\n V: <a class=\"trait\" href=\"https://docs.rs/serde/1.0.203/serde/de/trait.Deserialize.html\" title=\"trait serde::de::Deserialize\">Deserialize</a><'de>,</div></h3></section></summary><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.deserialize\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://docs.rs/serde/1.0.203/src/serde/de/impls.rs.html#1568-1574\">source</a><a href=\"#method.deserialize\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://docs.rs/serde/1.0.203/serde/de/trait.Deserialize.html#tymethod.deserialize\" class=\"fn\">deserialize</a><D>(\n deserializer: D\n) -> <a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/core/result/enum.Result.html\" title=\"enum core::result::Result\">Result</a><<a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html\" title=\"struct alloc::collections::btree::map::BTreeMap\">BTreeMap</a><K, V>, <D as <a class=\"trait\" href=\"https://docs.rs/serde/1.0.203/serde/de/trait.Deserializer.html\" title=\"trait serde::de::Deserializer\">Deserializer</a><'de>>::<a class=\"associatedtype\" href=\"https://docs.rs/serde/1.0.203/serde/de/trait.Deserializer.html#associatedtype.Error\" title=\"type serde::de::Deserializer::Error\">Error</a>><div class=\"where\">where\n D: <a class=\"trait\" href=\"https://docs.rs/serde/1.0.203/serde/de/trait.Deserializer.html\" title=\"trait serde::de::Deserializer\">Deserializer</a><'de>,</div></h4></section></summary><div class='docblock'>Deserialize this value from the given Serde deserializer. <a href=\"https://docs.rs/serde/1.0.203/serde/de/trait.Deserialize.html#tymethod.deserialize\">Read more</a></div></details></div></details>","Deserialize<'de>","bdk_wallet::descriptor::policy::ConditionMap","bdk_wallet::descriptor::policy::FoldedConditionMap","bdk_wallet::descriptor::HdKeyPaths","bdk_wallet::descriptor::TapKeyOrigins","bdk_wallet::keys::KeyMap"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-Drop-for-BTreeMap%3CK,+V,+A%3E\" class=\"impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.7.0\">1.7.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/collections/btree/map.rs.html#187\">source</a></span><a href=\"#impl-Drop-for-BTreeMap%3CK,+V,+A%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl<K, V, A> <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/ops/drop/trait.Drop.html\" title=\"trait core::ops::drop::Drop\">Drop</a> for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html\" title=\"struct alloc::collections::btree::map::BTreeMap\">BTreeMap</a><K, V, A><div class=\"where\">where\n A: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/alloc/trait.Allocator.html\" title=\"trait core::alloc::Allocator\">Allocator</a> + <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/clone/trait.Clone.html\" title=\"trait core::clone::Clone\">Clone</a>,</div></h3></section></summary><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.drop\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/collections/btree/map.rs.html#188\">source</a><a href=\"#method.drop\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/ops/drop/trait.Drop.html#tymethod.drop\" class=\"fn\">drop</a>(&mut self)</h4></section></summary><div class='docblock'>Executes the destructor for this type. <a href=\"https://doc.rust-lang.org/nightly/core/ops/drop/trait.Drop.html#tymethod.drop\">Read more</a></div></details></div></details>","Drop","bdk_wallet::descriptor::policy::ConditionMap","bdk_wallet::descriptor::policy::FoldedConditionMap","bdk_wallet::descriptor::HdKeyPaths","bdk_wallet::descriptor::TapKeyOrigins","bdk_wallet::keys::KeyMap"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-Extend%3C(%26K,+%26V)%3E-for-BTreeMap%3CK,+V,+A%3E\" class=\"impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.2.0\">1.2.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/collections/btree/map.rs.html#2254-2255\">source</a></span><a href=\"#impl-Extend%3C(%26K,+%26V)%3E-for-BTreeMap%3CK,+V,+A%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl<'a, K, V, A> <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/iter/traits/collect/trait.Extend.html\" title=\"trait core::iter::traits::collect::Extend\">Extend</a><(<a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.reference.html\">&'a K</a>, <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.reference.html\">&'a V</a>)> for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html\" title=\"struct alloc::collections::btree::map::BTreeMap\">BTreeMap</a><K, V, A><div class=\"where\">where\n K: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html\" title=\"trait core::cmp::Ord\">Ord</a> + <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Copy.html\" title=\"trait core::marker::Copy\">Copy</a>,\n V: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Copy.html\" title=\"trait core::marker::Copy\">Copy</a>,\n A: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/alloc/trait.Allocator.html\" title=\"trait core::alloc::Allocator\">Allocator</a> + <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/clone/trait.Clone.html\" title=\"trait core::clone::Clone\">Clone</a>,</div></h3></section></summary><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.extend\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/collections/btree/map.rs.html#2257\">source</a><a href=\"#method.extend\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/iter/traits/collect/trait.Extend.html#tymethod.extend\" class=\"fn\">extend</a><I>(&mut self, iter: I)<div class=\"where\">where\n I: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/iter/traits/collect/trait.IntoIterator.html\" title=\"trait core::iter::traits::collect::IntoIterator\">IntoIterator</a><Item = (<a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.reference.html\">&'a K</a>, <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.reference.html\">&'a V</a>)>,</div></h4></section></summary><div class='docblock'>Extends a collection with the contents of an iterator. <a href=\"https://doc.rust-lang.org/nightly/core/iter/traits/collect/trait.Extend.html#tymethod.extend\">Read more</a></div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.extend_one\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/collections/btree/map.rs.html#2262\">source</a><a href=\"#method.extend_one\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/iter/traits/collect/trait.Extend.html#method.extend_one\" class=\"fn\">extend_one</a>(&mut self, _: (<a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.reference.html\">&'a K</a>, <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.reference.html\">&'a V</a>))</h4></section></summary><span class=\"item-info\"><div class=\"stab unstable\"><span class=\"emoji\">🔬</span><span>This is a nightly-only experimental API. (<code>extend_one</code>)</span></div></span><div class='docblock'>Extends a collection with exactly one element.</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.extend_reserve\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/core/iter/traits/collect.rs.html#460\">source</a><a href=\"#method.extend_reserve\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/iter/traits/collect/trait.Extend.html#method.extend_reserve\" class=\"fn\">extend_reserve</a>(&mut self, additional: <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.usize.html\">usize</a>)</h4></section></summary><span class=\"item-info\"><div class=\"stab unstable\"><span class=\"emoji\">🔬</span><span>This is a nightly-only experimental API. (<code>extend_one</code>)</span></div></span><div class='docblock'>Reserves capacity in a collection for the given number of additional elements. <a href=\"https://doc.rust-lang.org/nightly/core/iter/traits/collect/trait.Extend.html#method.extend_reserve\">Read more</a></div></details></div></details>","Extend<(&'a K, &'a V)>","bdk_wallet::descriptor::policy::ConditionMap","bdk_wallet::descriptor::policy::FoldedConditionMap","bdk_wallet::descriptor::HdKeyPaths","bdk_wallet::descriptor::TapKeyOrigins","bdk_wallet::keys::KeyMap"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-Extend%3C(K,+V)%3E-for-BTreeMap%3CK,+V,+A%3E\" class=\"impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.0.0\">1.0.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/collections/btree/map.rs.html#2239\">source</a></span><a href=\"#impl-Extend%3C(K,+V)%3E-for-BTreeMap%3CK,+V,+A%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl<K, V, A> <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/iter/traits/collect/trait.Extend.html\" title=\"trait core::iter::traits::collect::Extend\">Extend</a><<a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.tuple.html\">(K, V)</a>> for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html\" title=\"struct alloc::collections::btree::map::BTreeMap\">BTreeMap</a><K, V, A><div class=\"where\">where\n K: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html\" title=\"trait core::cmp::Ord\">Ord</a>,\n A: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/alloc/trait.Allocator.html\" title=\"trait core::alloc::Allocator\">Allocator</a> + <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/clone/trait.Clone.html\" title=\"trait core::clone::Clone\">Clone</a>,</div></h3></section></summary><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.extend\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/collections/btree/map.rs.html#2241\">source</a><a href=\"#method.extend\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/iter/traits/collect/trait.Extend.html#tymethod.extend\" class=\"fn\">extend</a><T>(&mut self, iter: T)<div class=\"where\">where\n T: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/iter/traits/collect/trait.IntoIterator.html\" title=\"trait core::iter::traits::collect::IntoIterator\">IntoIterator</a><Item = <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.tuple.html\">(K, V)</a>>,</div></h4></section></summary><div class='docblock'>Extends a collection with the contents of an iterator. <a href=\"https://doc.rust-lang.org/nightly/core/iter/traits/collect/trait.Extend.html#tymethod.extend\">Read more</a></div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.extend_one\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/collections/btree/map.rs.html#2248\">source</a><a href=\"#method.extend_one\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/iter/traits/collect/trait.Extend.html#method.extend_one\" class=\"fn\">extend_one</a>(&mut self, _: <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.tuple.html\">(K, V)</a>)</h4></section></summary><span class=\"item-info\"><div class=\"stab unstable\"><span class=\"emoji\">🔬</span><span>This is a nightly-only experimental API. (<code>extend_one</code>)</span></div></span><div class='docblock'>Extends a collection with exactly one element.</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.extend_reserve\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/core/iter/traits/collect.rs.html#460\">source</a><a href=\"#method.extend_reserve\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/iter/traits/collect/trait.Extend.html#method.extend_reserve\" class=\"fn\">extend_reserve</a>(&mut self, additional: <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.usize.html\">usize</a>)</h4></section></summary><span class=\"item-info\"><div class=\"stab unstable\"><span class=\"emoji\">🔬</span><span>This is a nightly-only experimental API. (<code>extend_one</code>)</span></div></span><div class='docblock'>Reserves capacity in a collection for the given number of additional elements. <a href=\"https://doc.rust-lang.org/nightly/core/iter/traits/collect/trait.Extend.html#method.extend_reserve\">Read more</a></div></details></div></details>","Extend<(K, V)>","bdk_wallet::descriptor::policy::ConditionMap","bdk_wallet::descriptor::policy::FoldedConditionMap","bdk_wallet::descriptor::HdKeyPaths","bdk_wallet::descriptor::TapKeyOrigins","bdk_wallet::keys::KeyMap"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-From%3C%5B(K,+V);+N%5D%3E-for-BTreeMap%3CK,+V%3E\" class=\"impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.56.0\">1.56.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/collections/btree/map.rs.html#2338\">source</a></span><a href=\"#impl-From%3C%5B(K,+V);+N%5D%3E-for-BTreeMap%3CK,+V%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl<K, V, const N: <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.usize.html\">usize</a>> <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/convert/trait.From.html\" title=\"trait core::convert::From\">From</a><[<a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.tuple.html\">(K, V)</a>; <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.array.html\">N</a>]> for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html\" title=\"struct alloc::collections::btree::map::BTreeMap\">BTreeMap</a><K, V><div class=\"where\">where\n K: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html\" title=\"trait core::cmp::Ord\">Ord</a>,</div></h3></section></summary><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.from\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/collections/btree/map.rs.html#2348\">source</a><a href=\"#method.from\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/convert/trait.From.html#tymethod.from\" class=\"fn\">from</a>(arr: [<a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.tuple.html\">(K, V)</a>; <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.array.html\">N</a>]) -> <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html\" title=\"struct alloc::collections::btree::map::BTreeMap\">BTreeMap</a><K, V></h4></section></summary><div class=\"docblock\"><p>Converts a <code>[(K, V); N]</code> into a <code>BTreeMap<(K, V)></code>.</p>\n\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::collections::BTreeMap;\n\n<span class=\"kw\">let </span>map1 = BTreeMap::from([(<span class=\"number\">1</span>, <span class=\"number\">2</span>), (<span class=\"number\">3</span>, <span class=\"number\">4</span>)]);\n<span class=\"kw\">let </span>map2: BTreeMap<<span class=\"kw\">_</span>, <span class=\"kw\">_</span>> = [(<span class=\"number\">1</span>, <span class=\"number\">2</span>), (<span class=\"number\">3</span>, <span class=\"number\">4</span>)].into();\n<span class=\"macro\">assert_eq!</span>(map1, map2);</code></pre></div>\n</div></details></div></details>","From<[(K, V); N]>","bdk_wallet::descriptor::policy::ConditionMap","bdk_wallet::descriptor::policy::FoldedConditionMap","bdk_wallet::descriptor::HdKeyPaths","bdk_wallet::descriptor::TapKeyOrigins","bdk_wallet::keys::KeyMap"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-FromIterator%3C(K,+V)%3E-for-BTreeMap%3CK,+V%3E\" class=\"impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.0.0\">1.0.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/collections/btree/map.rs.html#2224\">source</a></span><a href=\"#impl-FromIterator%3C(K,+V)%3E-for-BTreeMap%3CK,+V%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl<K, V> <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/iter/traits/collect/trait.FromIterator.html\" title=\"trait core::iter::traits::collect::FromIterator\">FromIterator</a><<a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.tuple.html\">(K, V)</a>> for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html\" title=\"struct alloc::collections::btree::map::BTreeMap\">BTreeMap</a><K, V><div class=\"where\">where\n K: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html\" title=\"trait core::cmp::Ord\">Ord</a>,</div></h3></section></summary><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.from_iter\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/collections/btree/map.rs.html#2225\">source</a><a href=\"#method.from_iter\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/iter/traits/collect/trait.FromIterator.html#tymethod.from_iter\" class=\"fn\">from_iter</a><T>(iter: T) -> <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html\" title=\"struct alloc::collections::btree::map::BTreeMap\">BTreeMap</a><K, V><div class=\"where\">where\n T: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/iter/traits/collect/trait.IntoIterator.html\" title=\"trait core::iter::traits::collect::IntoIterator\">IntoIterator</a><Item = <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.tuple.html\">(K, V)</a>>,</div></h4></section></summary><div class='docblock'>Creates a value from an iterator. <a href=\"https://doc.rust-lang.org/nightly/core/iter/traits/collect/trait.FromIterator.html#tymethod.from_iter\">Read more</a></div></details></div></details>","FromIterator<(K, V)>","bdk_wallet::descriptor::policy::ConditionMap","bdk_wallet::descriptor::policy::FoldedConditionMap","bdk_wallet::descriptor::HdKeyPaths","bdk_wallet::descriptor::TapKeyOrigins","bdk_wallet::keys::KeyMap"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-Hash-for-BTreeMap%3CK,+V,+A%3E\" class=\"impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.0.0\">1.0.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/collections/btree/map.rs.html#2268\">source</a></span><a href=\"#impl-Hash-for-BTreeMap%3CK,+V,+A%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl<K, V, A> <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/hash/trait.Hash.html\" title=\"trait core::hash::Hash\">Hash</a> for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html\" title=\"struct alloc::collections::btree::map::BTreeMap\">BTreeMap</a><K, V, A><div class=\"where\">where\n K: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/hash/trait.Hash.html\" title=\"trait core::hash::Hash\">Hash</a>,\n V: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/hash/trait.Hash.html\" title=\"trait core::hash::Hash\">Hash</a>,\n A: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/alloc/trait.Allocator.html\" title=\"trait core::alloc::Allocator\">Allocator</a> + <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/clone/trait.Clone.html\" title=\"trait core::clone::Clone\">Clone</a>,</div></h3></section></summary><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.hash\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/collections/btree/map.rs.html#2269\">source</a><a href=\"#method.hash\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/hash/trait.Hash.html#tymethod.hash\" class=\"fn\">hash</a><H>(&self, state: <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.reference.html\">&mut H</a>)<div class=\"where\">where\n H: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/hash/trait.Hasher.html\" title=\"trait core::hash::Hasher\">Hasher</a>,</div></h4></section></summary><div class='docblock'>Feeds this value into the given <a href=\"https://doc.rust-lang.org/nightly/core/hash/trait.Hasher.html\" title=\"trait core::hash::Hasher\"><code>Hasher</code></a>. <a href=\"https://doc.rust-lang.org/nightly/core/hash/trait.Hash.html#tymethod.hash\">Read more</a></div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.hash_slice\" class=\"method trait-impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.3.0\">1.3.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/core/hash/mod.rs.html#238-240\">source</a></span><a href=\"#method.hash_slice\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/hash/trait.Hash.html#method.hash_slice\" class=\"fn\">hash_slice</a><H>(data: &<a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.slice.html\">[Self]</a>, state: <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.reference.html\">&mut H</a>)<div class=\"where\">where\n H: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/hash/trait.Hasher.html\" title=\"trait core::hash::Hasher\">Hasher</a>,\n Self: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,</div></h4></section></summary><div class='docblock'>Feeds a slice of this type into the given <a href=\"https://doc.rust-lang.org/nightly/core/hash/trait.Hasher.html\" title=\"trait core::hash::Hasher\"><code>Hasher</code></a>. <a href=\"https://doc.rust-lang.org/nightly/core/hash/trait.Hash.html#method.hash_slice\">Read more</a></div></details></div></details>","Hash","bdk_wallet::descriptor::policy::ConditionMap","bdk_wallet::descriptor::policy::FoldedConditionMap","bdk_wallet::descriptor::HdKeyPaths","bdk_wallet::descriptor::TapKeyOrigins","bdk_wallet::keys::KeyMap"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-Index%3C%26Q%3E-for-BTreeMap%3CK,+V,+A%3E\" class=\"impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.0.0\">1.0.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/collections/btree/map.rs.html#2319-2322\">source</a></span><a href=\"#impl-Index%3C%26Q%3E-for-BTreeMap%3CK,+V,+A%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl<K, Q, V, A> <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/ops/index/trait.Index.html\" title=\"trait core::ops::index::Index\">Index</a><<a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.reference.html\">&Q</a>> for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html\" title=\"struct alloc::collections::btree::map::BTreeMap\">BTreeMap</a><K, V, A><div class=\"where\">where\n A: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/alloc/trait.Allocator.html\" title=\"trait core::alloc::Allocator\">Allocator</a> + <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/clone/trait.Clone.html\" title=\"trait core::clone::Clone\">Clone</a>,\n K: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/borrow/trait.Borrow.html\" title=\"trait core::borrow::Borrow\">Borrow</a><Q> + <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html\" title=\"trait core::cmp::Ord\">Ord</a>,\n Q: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html\" title=\"trait core::cmp::Ord\">Ord</a> + ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,</div></h3></section></summary><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.index\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/collections/btree/map.rs.html#2332\">source</a><a href=\"#method.index\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/ops/index/trait.Index.html#tymethod.index\" class=\"fn\">index</a>(&self, key: <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.reference.html\">&Q</a>) -> <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.reference.html\">&V</a></h4></section></summary><div class=\"docblock\"><p>Returns a reference to the value corresponding to the supplied key.</p>\n<h5 id=\"panics\"><a class=\"doc-anchor\" href=\"#panics\">§</a>Panics</h5>\n<p>Panics if the key is not present in the <code>BTreeMap</code>.</p>\n</div></details><details class=\"toggle\" open><summary><section id=\"associatedtype.Output\" class=\"associatedtype trait-impl\"><a href=\"#associatedtype.Output\" class=\"anchor\">§</a><h4 class=\"code-header\">type <a href=\"https://doc.rust-lang.org/nightly/core/ops/index/trait.Index.html#associatedtype.Output\" class=\"associatedtype\">Output</a> = V</h4></section></summary><div class='docblock'>The returned type after indexing.</div></details></div></details>","Index<&Q>","bdk_wallet::descriptor::policy::ConditionMap","bdk_wallet::descriptor::policy::FoldedConditionMap","bdk_wallet::descriptor::HdKeyPaths","bdk_wallet::descriptor::TapKeyOrigins","bdk_wallet::keys::KeyMap"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-IntoAssets-for-BTreeMap%3CDescriptorPublicKey,+DescriptorSecretKey%3E\" class=\"impl\"><a href=\"#impl-IntoAssets-for-BTreeMap%3CDescriptorPublicKey,+DescriptorSecretKey%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl IntoAssets for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html\" title=\"struct alloc::collections::btree::map::BTreeMap\">BTreeMap</a><<a class=\"enum\" href=\"bdk_wallet/keys/enum.DescriptorPublicKey.html\" title=\"enum bdk_wallet::keys::DescriptorPublicKey\">DescriptorPublicKey</a>, <a class=\"enum\" href=\"bdk_wallet/keys/enum.DescriptorSecretKey.html\" title=\"enum bdk_wallet::keys::DescriptorSecretKey\">DescriptorSecretKey</a>></h3></section></summary><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.into_assets\" class=\"method trait-impl\"><a href=\"#method.into_assets\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a class=\"fn\">into_assets</a>(self) -> Assets</h4></section></summary><div class='docblock'>Convert <code>self</code> into a <code>Assets</code> struct</div></details></div></details>","IntoAssets","bdk_wallet::keys::KeyMap"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-IntoDeserializer%3C'de,+E%3E-for-BTreeMap%3CK,+V%3E\" class=\"impl\"><a class=\"src rightside\" href=\"https://docs.rs/serde/1.0.203/src/serde/de/value.rs.html#1425-1429\">source</a><a href=\"#impl-IntoDeserializer%3C'de,+E%3E-for-BTreeMap%3CK,+V%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl<'de, K, V, E> <a class=\"trait\" href=\"https://docs.rs/serde/1.0.203/serde/de/trait.IntoDeserializer.html\" title=\"trait serde::de::IntoDeserializer\">IntoDeserializer</a><'de, E> for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html\" title=\"struct alloc::collections::btree::map::BTreeMap\">BTreeMap</a><K, V><div class=\"where\">where\n K: <a class=\"trait\" href=\"https://docs.rs/serde/1.0.203/serde/de/trait.IntoDeserializer.html\" title=\"trait serde::de::IntoDeserializer\">IntoDeserializer</a><'de, E> + <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Eq.html\" title=\"trait core::cmp::Eq\">Eq</a> + <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html\" title=\"trait core::cmp::Ord\">Ord</a>,\n V: <a class=\"trait\" href=\"https://docs.rs/serde/1.0.203/serde/de/trait.IntoDeserializer.html\" title=\"trait serde::de::IntoDeserializer\">IntoDeserializer</a><'de, E>,\n E: <a class=\"trait\" href=\"https://docs.rs/serde/1.0.203/serde/de/trait.Error.html\" title=\"trait serde::de::Error\">Error</a>,</div></h3></section></summary><div class=\"impl-items\"><details class=\"toggle\" open><summary><section id=\"associatedtype.Deserializer\" class=\"associatedtype trait-impl\"><a href=\"#associatedtype.Deserializer\" class=\"anchor\">§</a><h4 class=\"code-header\">type <a href=\"https://docs.rs/serde/1.0.203/serde/de/trait.IntoDeserializer.html#associatedtype.Deserializer\" class=\"associatedtype\">Deserializer</a> = <a class=\"struct\" href=\"https://docs.rs/serde/1.0.203/serde/de/value/struct.MapDeserializer.html\" title=\"struct serde::de::value::MapDeserializer\">MapDeserializer</a><'de, <<a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html\" title=\"struct alloc::collections::btree::map::BTreeMap\">BTreeMap</a><K, V> as <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/iter/traits/collect/trait.IntoIterator.html\" title=\"trait core::iter::traits::collect::IntoIterator\">IntoIterator</a>>::<a class=\"associatedtype\" href=\"https://doc.rust-lang.org/nightly/core/iter/traits/collect/trait.IntoIterator.html#associatedtype.IntoIter\" title=\"type core::iter::traits::collect::IntoIterator::IntoIter\">IntoIter</a>, E></h4></section></summary><div class='docblock'>The type of the deserializer being converted into.</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.into_deserializer\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://docs.rs/serde/1.0.203/src/serde/de/value.rs.html#1433\">source</a><a href=\"#method.into_deserializer\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://docs.rs/serde/1.0.203/serde/de/trait.IntoDeserializer.html#tymethod.into_deserializer\" class=\"fn\">into_deserializer</a>(\n self\n) -> <<a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html\" title=\"struct alloc::collections::btree::map::BTreeMap\">BTreeMap</a><K, V> as <a class=\"trait\" href=\"https://docs.rs/serde/1.0.203/serde/de/trait.IntoDeserializer.html\" title=\"trait serde::de::IntoDeserializer\">IntoDeserializer</a><'de, E>>::<a class=\"associatedtype\" href=\"https://docs.rs/serde/1.0.203/serde/de/trait.IntoDeserializer.html#associatedtype.Deserializer\" title=\"type serde::de::IntoDeserializer::Deserializer\">Deserializer</a></h4></section></summary><div class='docblock'>Convert this value into a deserializer.</div></details></div></details>","IntoDeserializer<'de, E>","bdk_wallet::descriptor::policy::ConditionMap","bdk_wallet::descriptor::policy::FoldedConditionMap","bdk_wallet::descriptor::HdKeyPaths","bdk_wallet::descriptor::TapKeyOrigins","bdk_wallet::keys::KeyMap"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-IntoIterator-for-BTreeMap%3CK,+V,+A%3E\" class=\"impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.0.0\">1.0.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/collections/btree/map.rs.html#1636\">source</a></span><a href=\"#impl-IntoIterator-for-BTreeMap%3CK,+V,+A%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl<K, V, A> <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/iter/traits/collect/trait.IntoIterator.html\" title=\"trait core::iter::traits::collect::IntoIterator\">IntoIterator</a> for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html\" title=\"struct alloc::collections::btree::map::BTreeMap\">BTreeMap</a><K, V, A><div class=\"where\">where\n A: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/alloc/trait.Allocator.html\" title=\"trait core::alloc::Allocator\">Allocator</a> + <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/clone/trait.Clone.html\" title=\"trait core::clone::Clone\">Clone</a>,</div></h3></section></summary><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.into_iter\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/collections/btree/map.rs.html#1641\">source</a><a href=\"#method.into_iter\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/iter/traits/collect/trait.IntoIterator.html#tymethod.into_iter\" class=\"fn\">into_iter</a>(self) -> <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.IntoIter.html\" title=\"struct alloc::collections::btree::map::IntoIter\">IntoIter</a><K, V, A></h4></section></summary><div class=\"docblock\"><p>Gets an owning iterator over the entries of the map, sorted by key.</p>\n</div></details><details class=\"toggle\" open><summary><section id=\"associatedtype.Item\" class=\"associatedtype trait-impl\"><a href=\"#associatedtype.Item\" class=\"anchor\">§</a><h4 class=\"code-header\">type <a href=\"https://doc.rust-lang.org/nightly/core/iter/traits/collect/trait.IntoIterator.html#associatedtype.Item\" class=\"associatedtype\">Item</a> = <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.tuple.html\">(K, V)</a></h4></section></summary><div class='docblock'>The type of the elements being iterated over.</div></details><details class=\"toggle\" open><summary><section id=\"associatedtype.IntoIter\" class=\"associatedtype trait-impl\"><a href=\"#associatedtype.IntoIter\" class=\"anchor\">§</a><h4 class=\"code-header\">type <a href=\"https://doc.rust-lang.org/nightly/core/iter/traits/collect/trait.IntoIterator.html#associatedtype.IntoIter\" class=\"associatedtype\">IntoIter</a> = <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.IntoIter.html\" title=\"struct alloc::collections::btree::map::IntoIter\">IntoIter</a><K, V, A></h4></section></summary><div class='docblock'>Which kind of iterator are we turning this into?</div></details></div></details>","IntoIterator","bdk_wallet::descriptor::policy::ConditionMap","bdk_wallet::descriptor::policy::FoldedConditionMap","bdk_wallet::descriptor::HdKeyPaths","bdk_wallet::descriptor::TapKeyOrigins","bdk_wallet::keys::KeyMap"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-Ord-for-BTreeMap%3CK,+V,+A%3E\" class=\"impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.0.0\">1.0.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/collections/btree/map.rs.html#2304\">source</a></span><a href=\"#impl-Ord-for-BTreeMap%3CK,+V,+A%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl<K, V, A> <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html\" title=\"trait core::cmp::Ord\">Ord</a> for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html\" title=\"struct alloc::collections::btree::map::BTreeMap\">BTreeMap</a><K, V, A><div class=\"where\">where\n K: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html\" title=\"trait core::cmp::Ord\">Ord</a>,\n V: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html\" title=\"trait core::cmp::Ord\">Ord</a>,\n A: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/alloc/trait.Allocator.html\" title=\"trait core::alloc::Allocator\">Allocator</a> + <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/clone/trait.Clone.html\" title=\"trait core::clone::Clone\">Clone</a>,</div></h3></section></summary><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.cmp\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/collections/btree/map.rs.html#2306\">source</a><a href=\"#method.cmp\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html#tymethod.cmp\" class=\"fn\">cmp</a>(&self, other: &<a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html\" title=\"struct alloc::collections::btree::map::BTreeMap\">BTreeMap</a><K, V, A>) -> <a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/core/cmp/enum.Ordering.html\" title=\"enum core::cmp::Ordering\">Ordering</a></h4></section></summary><div class='docblock'>This method returns an <a href=\"https://doc.rust-lang.org/nightly/core/cmp/enum.Ordering.html\" title=\"enum core::cmp::Ordering\"><code>Ordering</code></a> between <code>self</code> and <code>other</code>. <a href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html#tymethod.cmp\">Read more</a></div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.max\" class=\"method trait-impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.21.0\">1.21.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/core/cmp.rs.html#856-858\">source</a></span><a href=\"#method.max\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html#method.max\" class=\"fn\">max</a>(self, other: Self) -> Self<div class=\"where\">where\n Self: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,</div></h4></section></summary><div class='docblock'>Compares and returns the maximum of two values. <a href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html#method.max\">Read more</a></div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.min\" class=\"method trait-impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.21.0\">1.21.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/core/cmp.rs.html#877-879\">source</a></span><a href=\"#method.min\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html#method.min\" class=\"fn\">min</a>(self, other: Self) -> Self<div class=\"where\">where\n Self: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,</div></h4></section></summary><div class='docblock'>Compares and returns the minimum of two values. <a href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html#method.min\">Read more</a></div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.clamp\" class=\"method trait-impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.50.0\">1.50.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/core/cmp.rs.html#902-905\">source</a></span><a href=\"#method.clamp\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html#method.clamp\" class=\"fn\">clamp</a>(self, min: Self, max: Self) -> Self<div class=\"where\">where\n Self: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a> + <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.PartialOrd.html\" title=\"trait core::cmp::PartialOrd\">PartialOrd</a>,</div></h4></section></summary><div class='docblock'>Restrict a value to a certain interval. <a href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html#method.clamp\">Read more</a></div></details></div></details>","Ord","bdk_wallet::descriptor::policy::ConditionMap","bdk_wallet::descriptor::policy::FoldedConditionMap","bdk_wallet::descriptor::HdKeyPaths","bdk_wallet::descriptor::TapKeyOrigins","bdk_wallet::keys::KeyMap"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-PartialEq-for-BTreeMap%3CK,+V,+A%3E\" class=\"impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.0.0\">1.0.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/collections/btree/map.rs.html#2286\">source</a></span><a href=\"#impl-PartialEq-for-BTreeMap%3CK,+V,+A%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl<K, V, A> <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.PartialEq.html\" title=\"trait core::cmp::PartialEq\">PartialEq</a> for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html\" title=\"struct alloc::collections::btree::map::BTreeMap\">BTreeMap</a><K, V, A><div class=\"where\">where\n K: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.PartialEq.html\" title=\"trait core::cmp::PartialEq\">PartialEq</a>,\n V: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.PartialEq.html\" title=\"trait core::cmp::PartialEq\">PartialEq</a>,\n A: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/alloc/trait.Allocator.html\" title=\"trait core::alloc::Allocator\">Allocator</a> + <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/clone/trait.Clone.html\" title=\"trait core::clone::Clone\">Clone</a>,</div></h3></section></summary><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.eq\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/collections/btree/map.rs.html#2287\">source</a><a href=\"#method.eq\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.PartialEq.html#tymethod.eq\" class=\"fn\">eq</a>(&self, other: &<a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html\" title=\"struct alloc::collections::btree::map::BTreeMap\">BTreeMap</a><K, V, A>) -> <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.bool.html\">bool</a></h4></section></summary><div class='docblock'>This method tests for <code>self</code> and <code>other</code> values to be equal, and is used\nby <code>==</code>.</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.ne\" class=\"method trait-impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.0.0\">1.0.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/core/cmp.rs.html#263\">source</a></span><a href=\"#method.ne\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.PartialEq.html#method.ne\" class=\"fn\">ne</a>(&self, other: <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.reference.html\">&Rhs</a>) -> <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.bool.html\">bool</a></h4></section></summary><div class='docblock'>This method tests for <code>!=</code>. The default implementation is almost always\nsufficient, and should not be overridden without very good reason.</div></details></div></details>","PartialEq","bdk_wallet::descriptor::policy::ConditionMap","bdk_wallet::descriptor::policy::FoldedConditionMap","bdk_wallet::descriptor::HdKeyPaths","bdk_wallet::descriptor::TapKeyOrigins","bdk_wallet::keys::KeyMap"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-PartialOrd-for-BTreeMap%3CK,+V,+A%3E\" class=\"impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.0.0\">1.0.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/collections/btree/map.rs.html#2296\">source</a></span><a href=\"#impl-PartialOrd-for-BTreeMap%3CK,+V,+A%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl<K, V, A> <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.PartialOrd.html\" title=\"trait core::cmp::PartialOrd\">PartialOrd</a> for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html\" title=\"struct alloc::collections::btree::map::BTreeMap\">BTreeMap</a><K, V, A><div class=\"where\">where\n K: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.PartialOrd.html\" title=\"trait core::cmp::PartialOrd\">PartialOrd</a>,\n V: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.PartialOrd.html\" title=\"trait core::cmp::PartialOrd\">PartialOrd</a>,\n A: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/alloc/trait.Allocator.html\" title=\"trait core::alloc::Allocator\">Allocator</a> + <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/clone/trait.Clone.html\" title=\"trait core::clone::Clone\">Clone</a>,</div></h3></section></summary><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.partial_cmp\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/collections/btree/map.rs.html#2298\">source</a><a href=\"#method.partial_cmp\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.PartialOrd.html#tymethod.partial_cmp\" class=\"fn\">partial_cmp</a>(&self, other: &<a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html\" title=\"struct alloc::collections::btree::map::BTreeMap\">BTreeMap</a><K, V, A>) -> <a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/core/option/enum.Option.html\" title=\"enum core::option::Option\">Option</a><<a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/core/cmp/enum.Ordering.html\" title=\"enum core::cmp::Ordering\">Ordering</a>></h4></section></summary><div class='docblock'>This method returns an ordering between <code>self</code> and <code>other</code> values if one exists. <a href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.PartialOrd.html#tymethod.partial_cmp\">Read more</a></div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.lt\" class=\"method trait-impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.0.0\">1.0.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/core/cmp.rs.html#1179\">source</a></span><a href=\"#method.lt\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.PartialOrd.html#method.lt\" class=\"fn\">lt</a>(&self, other: <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.reference.html\">&Rhs</a>) -> <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.bool.html\">bool</a></h4></section></summary><div class='docblock'>This method tests less than (for <code>self</code> and <code>other</code>) and is used by the <code><</code> operator. <a href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.PartialOrd.html#method.lt\">Read more</a></div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.le\" class=\"method trait-impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.0.0\">1.0.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/core/cmp.rs.html#1197\">source</a></span><a href=\"#method.le\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.PartialOrd.html#method.le\" class=\"fn\">le</a>(&self, other: <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.reference.html\">&Rhs</a>) -> <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.bool.html\">bool</a></h4></section></summary><div class='docblock'>This method tests less than or equal to (for <code>self</code> and <code>other</code>) and is used by the <code><=</code>\noperator. <a href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.PartialOrd.html#method.le\">Read more</a></div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.gt\" class=\"method trait-impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.0.0\">1.0.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/core/cmp.rs.html#1214\">source</a></span><a href=\"#method.gt\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.PartialOrd.html#method.gt\" class=\"fn\">gt</a>(&self, other: <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.reference.html\">&Rhs</a>) -> <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.bool.html\">bool</a></h4></section></summary><div class='docblock'>This method tests greater than (for <code>self</code> and <code>other</code>) and is used by the <code>></code> operator. <a href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.PartialOrd.html#method.gt\">Read more</a></div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.ge\" class=\"method trait-impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.0.0\">1.0.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/core/cmp.rs.html#1232\">source</a></span><a href=\"#method.ge\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.PartialOrd.html#method.ge\" class=\"fn\">ge</a>(&self, other: <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.reference.html\">&Rhs</a>) -> <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.bool.html\">bool</a></h4></section></summary><div class='docblock'>This method tests greater than or equal to (for <code>self</code> and <code>other</code>) and is used by the <code>>=</code>\noperator. <a href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.PartialOrd.html#method.ge\">Read more</a></div></details></div></details>","PartialOrd","bdk_wallet::descriptor::policy::ConditionMap","bdk_wallet::descriptor::policy::FoldedConditionMap","bdk_wallet::descriptor::HdKeyPaths","bdk_wallet::descriptor::TapKeyOrigins","bdk_wallet::keys::KeyMap"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-Serialize-for-BTreeMap%3CK,+V%3E\" class=\"impl\"><a class=\"src rightside\" href=\"https://docs.rs/serde/1.0.203/src/serde/ser/impls.rs.html#495-499\">source</a><a href=\"#impl-Serialize-for-BTreeMap%3CK,+V%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl<K, V> <a class=\"trait\" href=\"https://docs.rs/serde/1.0.203/serde/ser/trait.Serialize.html\" title=\"trait serde::ser::Serialize\">Serialize</a> for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html\" title=\"struct alloc::collections::btree::map::BTreeMap\">BTreeMap</a><K, V><div class=\"where\">where\n K: <a class=\"trait\" href=\"https://docs.rs/serde/1.0.203/serde/ser/trait.Serialize.html\" title=\"trait serde::ser::Serialize\">Serialize</a>,\n V: <a class=\"trait\" href=\"https://docs.rs/serde/1.0.203/serde/ser/trait.Serialize.html\" title=\"trait serde::ser::Serialize\">Serialize</a>,</div></h3></section></summary><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.serialize\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://docs.rs/serde/1.0.203/src/serde/ser/impls.rs.html#495-499\">source</a><a href=\"#method.serialize\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://docs.rs/serde/1.0.203/serde/ser/trait.Serialize.html#tymethod.serialize\" class=\"fn\">serialize</a><S>(\n &self,\n serializer: S\n) -> <a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/core/result/enum.Result.html\" title=\"enum core::result::Result\">Result</a><<S as <a class=\"trait\" href=\"https://docs.rs/serde/1.0.203/serde/ser/trait.Serializer.html\" title=\"trait serde::ser::Serializer\">Serializer</a>>::<a class=\"associatedtype\" href=\"https://docs.rs/serde/1.0.203/serde/ser/trait.Serializer.html#associatedtype.Ok\" title=\"type serde::ser::Serializer::Ok\">Ok</a>, <S as <a class=\"trait\" href=\"https://docs.rs/serde/1.0.203/serde/ser/trait.Serializer.html\" title=\"trait serde::ser::Serializer\">Serializer</a>>::<a class=\"associatedtype\" href=\"https://docs.rs/serde/1.0.203/serde/ser/trait.Serializer.html#associatedtype.Error\" title=\"type serde::ser::Serializer::Error\">Error</a>><div class=\"where\">where\n S: <a class=\"trait\" href=\"https://docs.rs/serde/1.0.203/serde/ser/trait.Serializer.html\" title=\"trait serde::ser::Serializer\">Serializer</a>,</div></h4></section></summary><div class='docblock'>Serialize this value into the given Serde serializer. <a href=\"https://docs.rs/serde/1.0.203/serde/ser/trait.Serialize.html#tymethod.serialize\">Read more</a></div></details></div></details>","Serialize","bdk_wallet::descriptor::policy::ConditionMap","bdk_wallet::descriptor::policy::FoldedConditionMap","bdk_wallet::descriptor::HdKeyPaths","bdk_wallet::descriptor::TapKeyOrigins","bdk_wallet::keys::KeyMap"],["<section id=\"impl-Eq-for-BTreeMap%3CK,+V,+A%3E\" class=\"impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.0.0\">1.0.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/collections/btree/map.rs.html#2293\">source</a></span><a href=\"#impl-Eq-for-BTreeMap%3CK,+V,+A%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl<K, V, A> <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Eq.html\" title=\"trait core::cmp::Eq\">Eq</a> for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html\" title=\"struct alloc::collections::btree::map::BTreeMap\">BTreeMap</a><K, V, A><div class=\"where\">where\n K: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Eq.html\" title=\"trait core::cmp::Eq\">Eq</a>,\n V: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Eq.html\" title=\"trait core::cmp::Eq\">Eq</a>,\n A: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/alloc/trait.Allocator.html\" title=\"trait core::alloc::Allocator\">Allocator</a> + <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/clone/trait.Clone.html\" title=\"trait core::clone::Clone\">Clone</a>,</div></h3></section>","Eq","bdk_wallet::descriptor::policy::ConditionMap","bdk_wallet::descriptor::policy::FoldedConditionMap","bdk_wallet::descriptor::HdKeyPaths","bdk_wallet::descriptor::TapKeyOrigins","bdk_wallet::keys::KeyMap"],["<section id=\"impl-UnwindSafe-for-BTreeMap%3CK,+V,+A%3E\" class=\"impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.64.0\">1.64.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/collections/btree/map.rs.html#198-202\">source</a></span><a href=\"#impl-UnwindSafe-for-BTreeMap%3CK,+V,+A%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl<K, V, A> <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/panic/unwind_safe/trait.UnwindSafe.html\" title=\"trait core::panic::unwind_safe::UnwindSafe\">UnwindSafe</a> for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/collections/btree/map/struct.BTreeMap.html\" title=\"struct alloc::collections::btree::map::BTreeMap\">BTreeMap</a><K, V, A><div class=\"where\">where\n A: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/alloc/trait.Allocator.html\" title=\"trait core::alloc::Allocator\">Allocator</a> + <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/clone/trait.Clone.html\" title=\"trait core::clone::Clone\">Clone</a> + <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/panic/unwind_safe/trait.UnwindSafe.html\" title=\"trait core::panic::unwind_safe::UnwindSafe\">UnwindSafe</a>,\n K: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/panic/unwind_safe/trait.RefUnwindSafe.html\" title=\"trait core::panic::unwind_safe::RefUnwindSafe\">RefUnwindSafe</a>,\n V: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/panic/unwind_safe/trait.RefUnwindSafe.html\" title=\"trait core::panic::unwind_safe::RefUnwindSafe\">RefUnwindSafe</a>,</div></h3></section>","UnwindSafe","bdk_wallet::descriptor::policy::ConditionMap","bdk_wallet::descriptor::policy::FoldedConditionMap","bdk_wallet::descriptor::HdKeyPaths","bdk_wallet::descriptor::TapKeyOrigins","bdk_wallet::keys::KeyMap"]]
};if (window.register_type_impls) {window.register_type_impls(type_impls);} else {window.pending_type_impls = type_impls;}})()
\ No newline at end of file