Struct example_cli::Init

source Â·

pub struct Init<CS: Subcommand, S: Args, C>where
-    C: Default + Merge + Serialize + DeserializeOwned + Debug + Send + Sync + 'static,{
+    C: Default + Merge + Serialize + DeserializeOwned + Debug + Send + Sync + 'static,

{
     pub args: Args<CS, S>,
     pub keymap: KeyMap,
     pub index: KeychainTxOutIndex<Keychain>,
diff --git a/docs/.vuepress/public/docs-rs/bdk/nightly/latest/search-index.js b/docs/.vuepress/public/docs-rs/bdk/nightly/latest/search-index.js
index 8d794642b5..e2e66ed700 100644
--- a/docs/.vuepress/public/docs-rs/bdk/nightly/latest/search-index.js
+++ b/docs/.vuepress/public/docs-rs/bdk/nightly/latest/search-index.js
@@ -1,16 +1,16 @@
 var searchIndex = new Map(JSON.parse('[\
 ["bdk_bitcoind_rpc",{"t":"KFFEONNNNNNONNNNNNMNNNNNNNNNNNN","n":["BitcoindRpcErrorExt","BlockEvent","Emitter","bitcoincore_rpc","block","block_hash","block_height","borrow","borrow","borrow_mut","borrow_mut","checkpoint","connected_to","fmt","from","from","into","into","is_not_found_error","mempool","new","next_block","next_header","try_from","try_from","try_into","try_into","type_id","type_id","vzip","vzip"],"q":[[0,"bdk_bitcoind_rpc"],[31,"bitcoin::blockdata::block"],[32,"bdk_chain::chain_data"],[33,"core::fmt"],[34,"bitcoin::blockdata::transaction"],[35,"alloc::vec"],[36,"bitcoincore_rpc::error"],[37,"core::result"],[38,"bitcoincore_rpc::client"],[39,"bdk_chain::local_chain"],[40,"core::option"],[41,"core::any"]],"i":[0,0,0,0,1,1,1,12,1,12,1,1,1,1,12,1,12,1,10,12,12,12,12,12,1,12,1,12,1,12,1],"f":"`````{{{d{{b{c}}}}}f{}}{{{d{{b{c}}}}}h{}}{{{d{c}}}{{d{e}}}{}{}}0{{{d{jc}}}{{d{je}}}{}{}}0`{{{d{{b{c}}}}}l{}}{{{d{{b{c}}}}{d{jn}}}A`Ab}{cc{}}0{ce{}{}}0{{{d{Ad}}}Af}{{{d{j{Ah{c}}}}}{{Bd{{B`{{An{AjAl}}}}Bb}}}Bf}{{{d{c}}Bhh}{{Ah{c}}}Bf}{{{d{j{Ah{c}}}}}{{Bd{{Bl{{b{Bj}}}}Bb}}}Bf}{{{d{j{Ah{c}}}}}{{Bd{{Bl{{b{Bn}}}}Bb}}}Bf}{c{{Bd{e}}}{}{}}000{{{d{c}}}C`{}}077","D":"Bd","p":[[5,"BlockEvent",0],[1,"reference"],[5,"BlockHash",31],[1,"u32"],[0,"mut"],[5,"BlockId",32],[5,"Formatter",33],[8,"Result",33],[10,"Debug",33],[10,"BitcoindRpcErrorExt",0],[1,"bool"],[5,"Emitter",0],[5,"Transaction",34],[1,"u64"],[1,"tuple"],[5,"Vec",35],[6,"Error",36],[6,"Result",37],[10,"RpcApi",38],[5,"CheckPoint",39],[5,"Block",31],[6,"Option",40],[5,"Header",31],[5,"TypeId",41]],"r":[],"b":[],"c":"OjAAAAAAAAA=","e":"OzAAAAEAAA0ABAAEAAAACAADAA4AAAAYAAcA"}],\
-["bdk_chain",{"t":"KKSFFSKGRFGPPRRRRKFRFFIEEIRRRRKKRRKFFKEPPNNMNNNNNNEONNNNNNNNNNNNNNNNNNNNNONNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNOOMMNNNNNNNNNMNNNNNMNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNMNNNNNNNNMNNNNNOOONCCNNNNNNNNNNNNMNNNMNOEMMNNCMENNNNONNNNNNNMMNNDCDNNNNNOCEMNNNNNNNNNNNNNNNNNNNNNNNNNONNNNNNNNNNNNNNNNNNNNNCONNNNNNNNNNNONNNNNNNNNNOOOFFNNNNNNNNNNNNNNNNNNNNNNNNNOONNNNNNNNNNNNNNNNONNNNRKMMMMMCCFSPGPFTTNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNONNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNOOOOFNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNFGTPFFFFPFFTNNNNNONNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNONNNNNNNNNNNNNNNNNNNNNONNNNNNNNNNNNNNNNNNNNNNNNNNNONNNNNNNNNNNNNNNNONNNNNNNNSHFFFFNNNNNNNNNNNOONOONNNNNNNOONNNNNNNNNOONNNNNOONNNNNNNNONNNNNNNNTGFFPPTTTFFFFNNNOONNNNNNNNNNNNNNNNNNNNONNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNOONNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNOONNONOONNNNNNNNNNNNNNNNNNN","n":["Anchor","AnchorFromBlockPosition","BIP32_MAX_INDEX","Balance","BlockId","COINBASE_MATURITY","ChainOracle","ChainPosition","ChangeSet","ConfirmationBlockTime","ConfirmationTime","Confirmed","Confirmed","CreateError","CreateError","CreateParams","CreateParams","DescriptorExt","DescriptorId","Error","FullTxOut","Impl","Indexed","IndexedTxGraph","Indexer","KeychainIndexed","LoadError","LoadError","LoadParams","LoadParams","Merge","PersistAsyncWith","PersistError","PersistError","PersistWith","Persisted","SpkIterator","Staged","TxGraph","Unconfirmed","Unconfirmed","add","all_zeros","anchor_block","anchor_block","anchor_block","as_byte_array","as_raw_hash","as_ref","as_ref","bitcoin","block_id","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","chain_position","clone","clone","clone","clone","clone","clone","clone","clone","clone_into","clone_into","clone_into","clone_into","clone_into","clone_into","clone_into","clone_into","cloned","cmp","cmp","cmp","cmp","cmp","cmp","cmp","column_result","column_result","column_result","column_result","column_result","column_result","column_result","column_result","column_result","confirmation_height_upper_bound","confirmation_height_upper_bound","confirmation_height_upper_bound","confirmation_height_upper_bound","confirmation_time","confirmed","create","create","create","create_async","default","default","default","deref","deref","deref_mut","descriptor","descriptor_id","deserialize","deserialize","deserialize","deserialize","deserialize","dust_value","engine","eq","eq","eq","eq","eq","eq","eq","eq","equivalent","equivalent","equivalent","equivalent","equivalent","equivalent","equivalent","equivalent","equivalent","equivalent","equivalent","equivalent","equivalent","equivalent","equivalent","equivalent","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from_block_position","from_block_position","from_block_position","from_byte_array","from_engine","from_raw_hash","from_slice","from_slice_delegated","from_str","get_chain_tip","hash","hash","hash","hash","hash","hash","height","immature","index","indexed_tx_graph","indexer","into","into","into","into","into","into","into","into","into","into","into_fallible","into_iter","is_block_in_chain","is_confirmed","is_confirmed","is_confirmed_and_spendable","is_empty","is_mature","is_on_coinbase","keychain_txout","load","load","load","load_async","local_chain","merge","miniscript","new","new_with_range","next","nth","outpoint","partial_cmp","partial_cmp","partial_cmp","partial_cmp","partial_cmp","partial_cmp","partial_cmp","persist","persist","persist","persist_async","rusqlite","rusqlite_impl","serde","serialize","serialize","serialize","serialize","serialize","spent_by","spk_client","spk_txout","staged","take","take","to_byte_array","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","to_raw_hash","to_sql","to_sql","to_sql","to_sql","to_sql","to_sql","to_sql","to_sql","to_sql","to_string","to_string","total","transpose_into_fallible","trusted_pending","trusted_spendable","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","tx_graph","txout","type_id","type_id","type_id","type_id","type_id","type_id","type_id","type_id","type_id","type_id","unconfirmed","untrusted_pending","vzip","vzip","vzip","vzip","vzip","vzip","vzip","vzip","vzip","vzip","height","last_seen","time","ChangeSet","IndexedTxGraph","apply_block","apply_block_relevant","apply_changeset","apply_update","as_ref","batch_insert_relevant","batch_insert_relevant_unconfirmed","batch_insert_unconfirmed","borrow","borrow","borrow_mut","borrow_mut","clone","clone_into","default","default","deserialize","eq","fmt","fmt","from","from","from","from","graph","index","indexer","initial_changeset","insert_anchor","insert_seen_at","insert_tx","insert_txout","into","into","is_empty","merge","new","serialize","to_owned","try_from","try_from","try_into","try_into","tx_graph","type_id","type_id","vzip","vzip","ChangeSet","Indexer","apply_changeset","index_tx","index_txout","initial_changeset","is_tx_relevant","keychain_txout","spk_txout","ChangeSet","DEFAULT_LOOKAHEAD","DescriptorAlreadyAssigned","InsertDescriptorError","KeychainAlreadyAssigned","KeychainTxOutIndex","LAST_REVEALED_TABLE_NAME","SCHEMA_NAME","all_unbounded_spk_iters","apply_changeset","apply_changeset","borrow","borrow","borrow","borrow_mut","borrow_mut","borrow_mut","clone","clone","clone","clone_into","clone_into","clone_into","default","default","deserialize","eq","eq","fmt","fmt","fmt","fmt","from","from","from","from_sqlite","get_descriptor","index_of_spk","index_tx","index_txout","initial_changeset","inner","insert_descriptor","into","into","into","is_empty","is_tx_relevant","is_used","keychain_outpoints","keychain_outpoints_in_range","keychains","last_revealed","last_revealed_index","last_revealed_indices","last_used_index","last_used_indices","lookahead","lookahead_to_target","mark_used","merge","net_value","new","next_index","next_unused_spk","outpoints","persist_to_sqlite","reveal_next_spk","reveal_to_target","reveal_to_target_multi","revealed_keychain_spks","revealed_spks","sent_and_received","serialize","spk_at_index","to_owned","to_owned","to_owned","to_string","try_from","try_from","try_from","try_into","try_into","try_into","txout","txouts","txouts_in_tx","type_id","type_id","type_id","unbounded_spk_iter","unmark_used","unused_keychain_spks","unused_spks","vzip","vzip","vzip","descriptor","existing_assignment","existing_assignment","keychain","SpkTxOutIndex","all_spks","apply_changeset","borrow","borrow_mut","clone","clone_into","default","fmt","from","index_of_spk","index_tx","index_txout","initial_changeset","insert_spk","into","is_relevant","is_tx_relevant","is_used","mark_used","net_value","outpoints","outputs_in_range","scan","scan_txout","sent_and_received","spk_at_index","to_owned","try_from","try_into","txout","txouts","txouts_in_tx","type_id","unmark_used","unused_spks","vzip","AlterCheckPointError","ApplyHeaderError","BLOCKS_TABLE_NAME","CannotConnect","CannotConnectError","ChangeSet","CheckPoint","CheckPointIter","InconsistentBlocks","LocalChain","MissingGenesisError","SCHEMA_NAME","apply_changeset","apply_header","apply_header_connected_to","apply_update","block_id","blocks","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","clone","clone","clone","clone","clone","clone","clone","clone_into","clone_into","clone_into","clone_into","clone_into","clone_into","clone_into","default","deserialize","disconnect_from","eq","eq","eq","eq","eq","eq","eq","extend","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","from","from","from","from","from","from","from","from","from","from_block_ids","from_blocks","from_changeset","from_genesis_hash","from_header","from_iter","from_iter","from_sqlite","from_tip","genesis_hash","get","get","get_chain_tip","hash","height","height","initial_changeset","insert","insert_block","into","into","into","into","into","into","into","into","into_fallible","into_iter","into_iter","is_block_in_chain","is_empty","iter","iter_checkpoints","merge","new","next","original_hash","persist_to_sqlite","prev","push","range","range","serialize","tip","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","to_string","to_string","to_string","to_string","transpose_into_fallible","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_include_height","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_hash","vzip","vzip","vzip","vzip","vzip","vzip","vzip","vzip","SCHEMAS_TABLE_NAME","migrate_schema","FullScanRequest","FullScanResult","SyncRequest","SyncResult","borrow","borrow","borrow","borrow","borrow_mut","borrow_mut","borrow_mut","borrow_mut","chain_outpoints","chain_spks","chain_spks_for_keychain","chain_tip","chain_tip","chain_txids","chain_update","chain_update","from","from","from","from","from_chain_tip","from_chain_tip","from_keychain_txout_index","graph_update","graph_update","inspect_outpoints","inspect_spks","inspect_spks_for_all_keychains","inspect_spks_for_keychain","inspect_txids","into","into","into","into","last_active_indices","outpoints","populate_with_revealed_spks","set_outpoints","set_spks","set_spks_for_keychain","set_txids","spks","spks_by_keychain","try_from","try_from","try_from","try_from","try_into","try_into","try_into","try_into","txids","type_id","type_id","type_id","type_id","vzip","vzip","vzip","vzip","ANCHORS_TABLE_NAME","CalculateFeeError","CanonicalTx","ChangeSet","MissingTxOut","NegativeFee","SCHEMA_NAME","TXOUTS_TABLE_NAME","TXS_TABLE_NAME","TxAncestors","TxDescendants","TxGraph","TxNode","all_anchors","all_txouts","anchor_heights","anchors","anchors","apply_changeset","apply_update","as_ref","balance","batch_insert_unconfirmed","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","calculate_fee","chain_position","checked_sum","checked_sum","checked_sum","checked_sum","clone","clone","clone","clone","clone_into","clone_into","clone_into","clone_into","cmp","cmp","default","default","deref","deserialize","direct_conflicts","eq","eq","eq","eq","eq","equivalent","equivalent","equivalent","equivalent","equivalent","equivalent","filter_chain_txouts","filter_chain_unspents","floating_txouts","fmt","fmt","fmt","fmt","fmt","fmt","from","from","from","from","from","from","from","from_sqlite","full_txs","get_chain_position","get_chain_spend","get_tx","get_tx_node","get_txout","initial_changeset","insert_anchor","insert_seen_at","insert_tx","insert_txout","into","into","into","into","into","into","into","into_fallible","into_fallible","into_iter","into_iter","is_empty","is_empty","last_seen","last_seen_unconfirmed","list_canonical_txs","map_anchors","map_anchors","merge","new","next","next","outspends","partial_cmp","partial_cmp","persist_to_sqlite","serialize","to_owned","to_owned","to_owned","to_owned","to_string","transpose_into_fallible","transpose_into_fallible","try_balance","try_filter_chain_txouts","try_filter_chain_unspents","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_get_chain_position","try_get_chain_spend","try_into","try_into","try_into","try_into","try_into","try_into","try_into","try_list_canonical_txs","tx","tx_node","tx_outputs","tx_spends","txid","txouts","txouts","txs","txs_with_no_anchor_or_last_seen","type_id","type_id","type_id","type_id","type_id","type_id","type_id","update_last_seen_unconfirmed","vzip","vzip","vzip","vzip","vzip","vzip","vzip","walk_ancestors","walk_conflicts","walk_descendants"],"q":[[0,"bdk_chain"],[331,"bdk_chain::ConfirmationTime"],[334,"bdk_chain::indexed_tx_graph"],[384,"bdk_chain::indexer"],[393,"bdk_chain::indexer::keychain_txout"],[491,"bdk_chain::indexer::keychain_txout::InsertDescriptorError"],[495,"bdk_chain::indexer::spk_txout"],[532,"bdk_chain::local_chain"],[702,"bdk_chain::rusqlite_impl"],[704,"bdk_chain::spk_client"],[768,"bdk_chain::tx_graph"],[946,"bdk_chain::balance"],[947,"bdk_chain::descriptor_ext"],[948,"bdk_chain::tx_data_traits"],[949,"bdk_chain::chain_data"],[950,"bitcoin_hashes::sha256"],[951,"core::clone"],[952,"bdk_chain::spk_iter"],[953,"core::cmp"],[954,"bdk_chain::persist"],[955,"rusqlite::types::value_ref"],[956,"rusqlite::types::from_sql"],[957,"bitcoin_units::amount"],[958,"bitcoin::network"],[959,"bitcoin::blockdata::script::owned"],[960,"miniscript::descriptor::key"],[961,"miniscript::descriptor"],[962,"bitcoin::blockdata::transaction"],[963,"bitcoin::blockdata::block"],[964,"serde::de"],[965,"core::option"],[966,"core::result"],[967,"core::future::future"],[968,"alloc::boxed"],[969,"core::pin"],[970,"core::borrow"],[971,"core::fmt"],[972,"bitcoin_hashes"],[973,"bdk_chain::chain_oracle"],[974,"core::hash"],[975,"core::slice::index"],[976,"fallible_iterator"],[977,"core::iter::traits::iterator"],[978,"core::ops::range"],[979,"serde::ser"],[980,"rusqlite::types::to_sql"],[981,"rusqlite"],[982,"alloc::string"],[983,"core::any"],[984,"core::iter::traits::collect"],[985,"core::default"],[986,"alloc::collections::btree::map"],[987,"rusqlite::transaction"],[988,"core::iter::traits::double_ended"],[989,"core::iter::traits::exact_size"],[990,"alloc::collections::btree::set"],[991,"alloc::vec"],[992,"core::marker"],[993,"core::ops::function"],[994,"bitcoin::blockdata::script::borrowed"],[995,"core::convert"],[996,"alloc::sync"],[997,"std::collections::hash::set"]],"i":[0,0,0,0,0,0,0,0,75,0,0,12,14,40,45,40,45,0,0,63,0,0,0,0,0,0,40,45,40,45,0,0,40,45,0,0,0,0,0,12,14,1,2,3,5,6,2,2,2,2,0,6,22,1,12,14,5,6,15,20,2,2,16,22,1,12,14,5,6,15,20,2,16,15,1,12,14,5,6,15,2,16,1,12,14,5,6,15,2,16,12,12,14,5,6,15,20,2,22,22,22,22,22,22,22,22,22,3,3,12,6,6,1,40,45,20,20,1,5,6,22,20,20,16,47,1,14,5,6,2,47,2,1,12,14,5,6,15,20,2,1,1,12,12,14,14,5,5,6,6,15,15,20,20,2,2,1,1,12,14,5,6,15,20,2,2,2,2,22,22,22,1,12,14,14,5,5,5,6,15,20,2,2,16,59,5,6,2,2,2,2,2,2,63,12,14,5,6,2,5,5,1,2,0,0,22,1,12,14,5,6,15,20,2,16,16,16,63,12,14,15,70,15,15,0,40,45,20,20,0,70,0,16,16,16,16,15,12,14,5,6,15,20,2,40,45,20,20,0,0,0,1,14,5,6,2,15,0,0,75,70,70,2,1,12,14,5,6,15,2,16,2,22,22,22,22,22,22,22,22,22,1,2,1,16,1,1,22,1,12,14,5,6,15,20,2,16,22,1,12,14,5,6,15,20,2,16,0,15,22,1,12,14,5,6,15,20,2,16,14,1,22,1,12,14,5,6,15,20,2,16,131,132,131,0,0,82,82,82,82,82,82,82,82,82,83,82,83,83,83,82,83,83,83,82,83,82,83,83,83,82,82,83,82,82,82,82,82,82,83,83,83,82,83,83,82,83,82,83,83,82,83,82,83,84,0,84,84,84,84,84,0,0,0,0,95,0,95,0,90,90,93,93,93,93,95,90,93,95,90,93,95,90,93,95,90,93,90,90,95,90,93,95,95,90,93,95,90,90,93,93,93,93,93,93,93,93,95,90,90,93,93,93,93,93,90,93,93,93,93,93,93,93,90,93,93,93,93,93,90,93,93,93,93,93,93,90,93,93,95,90,95,93,95,90,93,95,90,93,93,93,93,95,90,93,93,93,93,93,95,90,133,133,134,134,0,97,97,97,97,97,97,97,97,97,97,97,97,97,97,97,97,97,97,97,97,97,97,97,97,97,97,97,97,97,97,97,97,97,97,97,97,0,0,106,110,0,0,0,0,110,0,0,106,105,105,105,105,111,106,113,111,105,106,107,112,109,110,113,111,105,106,107,112,109,110,111,105,106,107,112,109,110,111,105,106,107,112,109,110,106,106,105,111,105,106,107,112,109,110,111,111,105,106,107,107,112,112,109,109,110,110,113,111,105,106,106,107,112,109,110,111,105,105,105,111,106,106,106,105,105,111,105,105,111,111,112,105,111,105,113,111,105,106,107,112,109,110,113,113,111,105,106,111,105,106,111,113,112,106,111,111,111,105,106,105,111,105,106,107,112,109,110,107,112,109,110,113,113,111,105,106,107,112,109,110,109,113,111,105,106,107,112,109,110,113,111,105,106,107,112,109,110,112,113,111,105,106,107,112,109,110,0,0,0,0,0,0,114,135,117,136,114,135,117,136,114,114,117,114,117,114,135,136,114,135,117,136,114,117,117,135,136,114,114,117,117,114,114,135,117,136,136,114,114,114,114,117,114,114,117,114,135,117,136,114,135,117,136,114,114,135,117,136,114,135,117,136,89,0,0,0,123,123,89,89,89,0,0,0,0,85,85,89,124,89,85,85,85,85,85,128,129,85,124,125,123,89,128,129,85,124,125,123,89,85,125,128,128,129,129,85,124,125,89,85,124,125,89,124,125,85,89,124,89,85,85,124,125,123,89,124,124,125,125,123,123,85,85,85,85,124,125,123,123,89,128,129,85,124,125,123,89,89,85,85,85,85,85,85,85,85,85,85,85,128,129,85,124,125,123,89,128,129,128,129,85,89,89,124,85,85,89,89,85,128,129,85,124,125,89,89,85,124,125,89,123,128,129,85,85,85,128,129,85,124,125,123,89,85,85,128,129,85,124,125,123,89,85,124,125,85,85,124,89,89,89,85,128,129,85,124,125,123,89,85,128,129,85,124,125,123,89,85,85,85],"f":"`````````````````````````````````````````{{bb}b}{{}d}{{{h{f}}}j}{{{h{j}}}j}{{{h{l}}}j}{{{h{d}}}{{h{c}}}{}}{{{h{d}}}{{h{n}}}}{{{h{d}}}{{h{{Ab{A`}}}}}}{{{h{d}}}{{h{{Ad{A`}}}}}}``{{{h{c}}}{{h{e}}}{}{}}0000000200{{{h{Afc}}}{{h{Afe}}}{}{}}000000000`{{{h{b}}}b}{{{h{{Ah{c}}}}}{{Ah{c}}}Aj}{{{h{Al}}}Al}:{{{h{l}}}l}{{{h{{An{c}}}}}{{An{c}}}Aj}{{{h{d}}}d}{{{h{{B`{c}}}}}{{B`{c}}}Aj}{{{h{c}}{h{Afe}}}Bb{}{}}0000000{{{Ah{{h{c}}}}}{{Ah{c}}}Aj}{{{h{{Ah{c}}}}{h{{Ah{c}}}}}BdBf}{{{h{Al}}{h{Al}}}Bd}{{{h{j}}{h{j}}}Bd}{{{h{l}}{h{l}}}Bd}{{{h{{An{c}}}}{h{{An{c}}}}}BdBf}{{{h{{Bh{c}}}}{h{{Bh{c}}}}}BdBf}{{{h{d}}{h{d}}}Bd}{Bj{{Bn{{Bl{d}}}}}}{Bj{{Bn{{Bl{C`}}}}}}{Bj{{Bn{{Bl{Cb}}}}}}{Bj{{Bn{{Bl{Cd}}}}}}{Bj{{Bn{{Bl{{Ch{Cf}}}}}}}}{Bj{{Bn{{Bl{Cj}}}}}}{Bj{{Bn{{Bl{Cl}}}}}}{Bj{{Bn{{Bl{Cn}}}}}}{Bj{{Bn{{Bl{c}}}}}{fD`}}{{{h{f}}}Db}0{{{h{{Ah{c}}}}}{{Dd{Db}}}f}{{{h{l}}}Db}``{{{h{Afc}}e}{{Eb{{E`{}{{Df{e}}{Dh{g}}{Dj{i}}{Dl{k}}{Dn{m}}}}i}}}{}{}{}{}{}{}}{{{h{Afc}}e}{{Eh{{Ef{Ed}}}}}{}{}}{{{h{Afc}}}{{Eb{{Bh{e}}}}}{}{{E`{c}}}}{{{h{Afc}}}{{Eb{{Bh{e}}}}}{}{{Ej{c}}}}{{}b}{{}j}{{}l}{{{h{{Bl{c}}}}}{{h{e}}}{}{}}{{{h{{Bh{c}}}}}{{h{e}}}{}{}}{{{h{Af{Bh{c}}}}}{{h{Afe}}}{}{}}{{{h{{B`{c}}}}}{{h{c}}}{{El{{Ch{Cf}}}}}}{{{h{En}}}d}{c{{Eb{b}}}F`}{c{{Eb{Al}}}F`}{c{{Eb{j}}}F`}{c{{Eb{l}}}F`}{c{{Eb{d}}}F`}{{{h{En}}}Fb}{{}c{}}{{{h{b}}{h{b}}}Fd}{{{h{{Ah{c}}}}{h{{Ah{c}}}}}FdFf}{{{h{Al}}{h{Al}}}Fd}{{{h{j}}{h{j}}}Fd}{{{h{l}}{h{l}}}Fd}{{{h{{An{c}}}}{h{{An{c}}}}}FdFf}{{{h{{Bh{c}}}}{h{{Bh{c}}}}}FdFf}{{{h{d}}{h{d}}}Fd}{{{h{c}}{h{e}}}Fd{}{}}000000000000000{{{h{b}}{h{AfFh}}}Fj}0{{{h{{Ah{c}}}}{h{AfFh}}}FjFl}{{{h{Al}}{h{AfFh}}}Fj}{{{h{j}}{h{AfFh}}}Fj}{{{h{l}}{h{AfFh}}}Fj}{{{h{{An{c}}}}{h{AfFh}}}FjFl}{{{h{{Bh{c}}}}{h{AfFh}}}FjFl}{{{h{d}}{h{AfFh}}}Fj}000{c{{Bl{c}}}{}}{Fnc{}}{cc{}}000{{{Ah{l}}}Al}1{{{G`{{h{Db}}{h{Cn}}}}}j}{{{G`{DbCn}}}j}3333{nd}4{{{h{Gb}}jGd}Gf}{{{h{Gb}}jGd}j}{{{h{Gb}}jGd}l}{cd{}}04{{{h{{Ab{A`}}}}}{{Eb{dGh}}}}0{{{h{Gj}}}{{Eb{dc}}}{}}{{{h{{Gn{}{{Gl{c}}}}}}}{{Eb{jc}}}Fl}{{{h{{Ah{c}}}}{h{Afe}}}BbH`Hb}{{{h{Al}}{h{Afc}}}BbHb}{{{h{j}}{h{Afc}}}BbHb}{{{h{l}}{h{Afc}}}BbHb}{{{h{d}}{h{Afc}}}BbHb}```{{{h{d}}c}{{h{e}}}{{Hd{{Ab{A`}}}}}{}}``{ce{}{}}000000000{c{{Hf{g}}}{}{}{{Hj{}{{Hh{e}}}}}}1{{{h{{Gn{}{{Gl{c}}}}}}jj}{{Eb{{Dd{Fd}}c}}}Fl}{{{h{{Ah{c}}}}}Fd{}}{{{h{Al}}}Fd}{{{h{{An{c}}}}Db}Fdf}{{{h{Hl}}}Fd}1``{{{h{Afc}}e}{{Eb{{Dd{{E`{}{{Df{g}}{Dh{e}}{Dj{i}}{Dl{k}}{Dn{m}}}}}}k}}}{}{}{}{}{}{}}{{{h{Afc}}e}{{Eh{{Ef{Ed}}}}}{}{}}{{{h{Afc}}}{{Eb{{Dd{{Bh{e}}}}}}}{}{{E`{c}}}}{{{h{Afc}}}{{Eb{{Dd{{Bh{e}}}}}}}{}{{Ej{c}}}}`{{{h{AfHl}}Hl}Bb}`{c{{B`{c}}}{{El{{Ch{Cf}}}}}}{{ce}{{B`{c}}}{{El{{Ch{Cf}}}}}{{Hn{Db}}}}{{{h{Af{B`{c}}}}}{{Dd{e}}}{{El{{Ch{Cf}}}}}{}}{{{h{Af{B`{c}}}}Gd}{{Dd{e}}}{{El{{Ch{Cf}}}}}{}}`{{{h{{Ah{c}}}}{h{{Ah{c}}}}}{{Dd{Bd}}}I`}{{{h{Al}}{h{Al}}}{{Dd{Bd}}}}{{{h{j}}{h{j}}}{{Dd{Bd}}}}{{{h{l}}{h{l}}}{{Dd{Bd}}}}{{{h{{An{c}}}}{h{{An{c}}}}}{{Dd{Bd}}}I`}{{{h{{Bh{c}}}}{h{{Bh{c}}}}}{{Dd{Bd}}}I`}{{{h{d}}{h{d}}}{{Dd{Bd}}}}{{{h{Afc}}{h{e}}}{{Eb{Bbg}}}{}{}{}}{{{h{Afc}}{h{e}}}{{Eh{{Ef{Ed}}}}}{}{}}{{{h{Af{Bh{e}}}}{h{Afc}}}{{Eb{Fd}}}{}{{E`{c}}}}{{{h{Af{Bh{e}}}}{h{Afc}}}{{Eb{Fd}}}{}{{Ej{c}}}}```{{{h{b}}c}EbIb}{{{h{Al}}c}EbIb}{{{h{j}}c}EbIb}{{{h{l}}c}EbIb}{{{h{d}}c}EbIb}```{{{h{Af{If{}{{Id{c}}}}}}}{{h{Afc}}}Hl}{{{h{AfHl}}}{{Dd{Hl}}}}0{dc{}}{{{h{c}}}e{}{}}0000000{dn}{{{h{{Bl{c}}}}}{{Ij{Ih}}}{fIl}}{{{h{{Bl{Cj}}}}}{{Ij{Ih}}}}{{{h{{Bl{d}}}}}{{Ij{Ih}}}}{{{h{{Bl{Cd}}}}}{{Ij{Ih}}}}{{{h{{Bl{C`}}}}}{{Ij{Ih}}}}{{{h{{Bl{Cn}}}}}{{Ij{Ih}}}}{{{h{{Bl{{Ch{Cf}}}}}}}{{Ij{Ih}}}}{{{h{{Bl{Cl}}}}}{{Ij{Ih}}}}{{{h{{Bl{Cb}}}}}{{Ij{Ih}}}}{{{h{c}}}In{}}0{{{h{b}}}C`}{c{{J`{i}}}{}{}{}{{Hj{}{{Hh{{Eb{eg}}}}}}}}`1{c{{Eb{e}}}{}{}}0000000000000000000``{{{h{c}}}Jb{}}000000000{FbAl}`{ce{}{}}000000000`````{{{h{Af{Jd{ce}}}}GbDb}{{Jf{c}}}{Gff}Jh}{{{h{Af{Jd{ce}}}}{h{Gb}}Db}{{Jf{c}}}{Gff}Jh}{{{h{Af{Jd{ce}}}}{Jf{c}}}BbfJh}{{{h{Af{Jd{ce}}}}{Jj{c}}}{{Jf{c}}}fJh}{{{h{{Jd{ce}}}}}{{h{{Jj{c}}}}}{}{}}{{{h{Af{Jd{ce}}}}i}{{Jf{c}}}fJh{{Jl{}{{Hh{c}}}}}{{Jl{}{{Hh{{G`{{h{Cj}}g}}}}}}}}{{{h{Af{Jd{ce}}}}g}{{Jf{c}}}fJh{{Jl{}{{Hh{{G`{{h{Cj}}Fb}}}}}}}}{{{h{Af{Jd{ce}}}}g}{{Jf{c}}}fJh{{Jl{}{{Hh{{G`{CjFb}}}}}}}}{{{h{c}}}{{h{e}}}{}{}}0{{{h{Afc}}}{{h{Afe}}}{}{}}0{{{h{{Jf{ce}}}}}{{Jf{ce}}}AjAj}{{{h{c}}{h{Afe}}}Bb{}{}}{{}{{Jd{ce}}}{}Jn}{{}{{Jf{ce}}}{}Jn}{c{{Eb{{Jf{eg}}}}}F`{BfK`}K`}{{{h{{Jf{ce}}}}{h{{Jf{ce}}}}}FdFfFf}{{{h{{Jd{ce}}}}{h{AfFh}}}FjFlFl}{{{h{{Jf{ce}}}}{h{AfFh}}}FjFlFl}{cc{}}{{{Kb{c}}}{{Jf{ce}}}{}Jn}1{Kd{{Jf{cKd}}}{}}{{{h{{Jd{ce}}}}}{{h{{Jj{c}}}}}{}{}}``{{{h{{Jd{ce}}}}}{{Jf{c}}}fJh}{{{h{Af{Jd{ce}}}}Clc}{{Jf{c}}}fJh}{{{h{Af{Jd{ce}}}}ClFb}{{Jf{c}}}fJh}{{{h{Af{Jd{ce}}}}Cj}{{Jf{c}}}fJh}{{{h{Af{Jd{ce}}}}KfKh}{{Jf{c}}}fJh}{ce{}{}}0{{{h{{Jf{ce}}}}}FdfHl}{{{h{Af{Jf{ce}}}}{Jf{ce}}}BbfHl}{c{{Jd{ec}}}{}{}}{{{h{{Jf{ce}}}}g}Eb{BfIl}IlIb}{{{h{c}}}e{}{}}{c{{Eb{e}}}{}{}}000`{{{h{c}}}Jb{}}077``{{{h{Af{Jh{}{{Id{c}}}}}}c}Bb{}}{{{h{Af{Jh{}{{Id{c}}}}}}{h{Cj}}}c{}}{{{h{Af{Jh{}{{Id{c}}}}}}Kf{h{Kh}}}c{}}{{{h{{Jh{}{{Id{c}}}}}}}c{}}{{{h{{Jh{}{{Id{c}}}}}}{h{Cj}}}Fd{}}``````````{{{h{{Kj{c}}}}}{{Kl{c{B`{{Ch{Cf}}}}}}}{AjBfFl}}{{{h{Af{Kj{c}}}}e}Bb{AjBfFl}{}}{{{h{Af{Kj{c}}}}Kd}Bb{AjBfFl}}{{{h{c}}}{{h{e}}}{}{}}00{{{h{Afc}}}{{h{Afe}}}{}{}}00{{{h{{Kj{c}}}}}{{Kj{c}}}Aj}{{{h{{Kn{c}}}}}{{Kn{c}}}Aj}{{{h{Kd}}}Kd}{{{h{c}}{h{Afe}}}Bb{}{}}00{{}{{Kj{c}}}{}}{{}Kd}{c{{Eb{Kd}}}F`}{{{h{{Kn{c}}}}{h{{Kn{c}}}}}FdFf}{{{h{Kd}}{h{Kd}}}Fd}{{{h{{Kj{c}}}}{h{AfFh}}}FjFl}{{{h{{Kn{c}}}}{h{AfFh}}}FjFl}0{{{h{Kd}}{h{AfFh}}}Fj}{cc{}}00{{{h{L`}}}{{Ij{Kd}}}}{{{h{{Kj{c}}}}c}{{Dd{{h{{Ch{Cf}}}}}}}{AjBfFl}}{{{h{{Kj{c}}}}Cd}{{Dd{{h{{G`{cDb}}}}}}}{AjBfFl}}{{{h{Af{Kj{c}}}}{h{Cj}}}e{AjBfFl}{}}{{{h{Af{Kj{c}}}}Kf{h{Kh}}}e{AjBfFl}{}}{{{h{{Kj{c}}}}}e{AjBfFl}{}}{{{h{{Kj{c}}}}}{{h{{Lb{{G`{cDb}}}}}}}{AjBfFl}}{{{h{Af{Kj{c}}}}c{Ch{Cf}}}{{Eb{Fd{Kn{c}}}}}{AjBfFl}}{ce{}{}}00{{{h{Kd}}}Fd}{{{h{{Kj{c}}}}{h{Cj}}}Fd{AjBfFl}}{{{h{{Kj{c}}}}cDb}Fd{AjBfFl}}{{{h{{Kj{c}}}}c}{{`{{Lf{}{{Hh{{Ld{Kf}}}}}}}}}{AjBfFl}}{{{h{{Kj{c}}}}e}{{`{{Lf{}{{Hh{{Lh{cKf}}}}}}}}}{AjBfFl}{{Hn{c}}}}{{{h{{Kj{c}}}}}{{`{{Lf{}{{Hh{{G`{c{h{{Ch{Cf}}}}}}}}}}Lj}}}{AjBfFl}}`{{{h{{Kj{c}}}}c}{{Dd{Db}}}{AjBfFl}}{{{h{{Kj{c}}}}}{{Kl{cDb}}}{AjBfFl}}10{{{h{{Kj{c}}}}}Db{AjBfFl}}{{{h{Af{Kj{c}}}}cDb}Bb{AjBfFl}}{{{h{Af{Kj{c}}}}cDb}Fd{AjBfFl}}{{{h{AfKd}}Kd}Bb}{{{h{{Kj{c}}}}{h{Cj}}e}Ll{AjBfFl}{{Hn{c}}}}{Db{{Kj{c}}}{}}{{{h{{Kj{c}}}}c}{{Dd{{G`{DbFd}}}}}{AjBfFl}}{{{h{Af{Kj{c}}}}c}{{Dd{{G`{{Ld{Cd}}Kd}}}}}{AjBfFl}}{{{h{{Kj{c}}}}}{{h{{Ln{{Lh{cKf}}}}}}}{AjBfFl}}{{{h{Kd}}{h{L`}}}{{Ij{Bb}}}}2{{{h{Af{Kj{c}}}}cDb}{{Dd{{G`{{M`{{Ld{Cd}}}}Kd}}}}}{AjBfFl}}{{{h{Af{Kj{c}}}}{h{{Kl{cDb}}}}}Kd{AjBfFl}}{{{h{{Kj{c}}}}c}{{`{{Lf{}{{Hh{{Ld{Cd}}}}}}}}}{AjBfFl}}{{{h{{Kj{c}}}}e}{{`{{Hj{}{{Hh{{Lh{cCd}}}}}}}}}{AjBfFl}{{Hn{c}}}}{{{h{{Kj{c}}}}{h{Cj}}e}{{G`{C`C`}}}{AjBfFl}{{Hn{c}}}}{{{h{Kd}}c}EbIb}{{{h{{Kj{c}}}}cDb}{{Dd{Cd}}}{AjBfFl}}{{{h{c}}}e{}{}}00{{{h{c}}}In{}}{c{{Eb{e}}}{}{}}00000{{{h{{Kj{c}}}}Kf}{{Dd{{Lh{c{h{Kh}}}}}}}{AjBfFl}}{{{h{{Kj{c}}}}}{{`{{Lf{}{{Hh{{Lh{c{G`{Kf{h{Kh}}}}}}}}}}Lj}}}{AjBfFl}}{{{h{{Kj{c}}}}Cl}{{`{{Lf{}{{Hh{{Lh{c{G`{Kf{h{Kh}}}}}}}}}}}}}{AjBfFl}}{{{h{c}}}Jb{}}00{{{h{{Kj{c}}}}c}{{Dd{{B`{{Ch{Cf}}}}}}}{AjBfFl}}{{{h{Af{Kj{c}}}}cDb}Fd{AjBfFl}}{{{h{{Kj{c}}}}c}{{`{{Lf{}{{Hh{{Ld{Cd}}}}}}Aj}}}{AjBfFl}}{{{h{{Kj{c}}}}}{{`{{Lf{}{{Hh{{Lh{cCd}}}}}}Aj}}}{AjBfFl}}{ce{}{}}00`````{{{h{{Lb{c}}}}}{{h{{Kl{cCd}}}}}{AjBfFl}}{{{h{Af{Lb{c}}}}e}Bb{AjBfFl}{}}{{{h{c}}}{{h{e}}}{}{}}{{{h{Afc}}}{{h{Afe}}}{}{}}{{{h{{Lb{c}}}}}{{Lb{c}}}Aj}{{{h{c}}{h{Afe}}}Bb{}{}}{{}{{Lb{c}}}{}}{{{h{{Lb{c}}}}{h{AfFh}}}FjFl}{cc{}}{{{h{{Lb{c}}}}Cd}{{Dd{{h{c}}}}}{AjBfFl}}{{{h{Af{Lb{c}}}}{h{Cj}}}e{AjBfFl}{}}{{{h{Af{Lb{c}}}}Kf{h{Kh}}}e{AjBfFl}{}}{{{h{{Lb{c}}}}}e{AjBfFl}{}}{{{h{Af{Lb{c}}}}cCd}Fd{AjBfFl}}>{{{h{{Lb{c}}}}{h{Cj}}}Fd{AjBfFl}}0{{{h{{Lb{c}}}}{h{c}}}Fd{AjBfFl}}{{{h{Af{Lb{c}}}}{h{c}}}Fd{AjBfFl}}{{{h{{Lb{c}}}}{h{Cj}}e}Ll{AjBfFl}{{Hn{c}}}}{{{h{{Lb{c}}}}}{{h{{Ln{{G`{cKf}}}}}}}{AjBfFl}}{{{h{{Lb{c}}}}e}{{`{{Lf{}{{Hh{{G`{{h{c}}Kf}}}}}}}}}{AjBfFl}{{Hn{c}}}}{{{h{Af{Lb{c}}}}{h{Cj}}}{{Ln{c}}}{AjBfFl}}{{{h{Af{Lb{c}}}}Kf{h{Kh}}}{{Dd{{h{c}}}}}{AjBfFl}}{{{h{{Lb{c}}}}{h{Cj}}e}{{G`{C`C`}}}{AjBfFl}{{Hn{c}}}}{{{h{{Lb{c}}}}{h{c}}}{{Dd{Cd}}}{AjBfFl}}{{{h{c}}}e{}{}}{c{{Eb{e}}}{}{}}0{{{h{{Lb{c}}}}Kf}{{Dd{{G`{{h{c}}{h{Kh}}}}}}}{AjBfFl}}{{{h{{Lb{c}}}}}{{`{{Lf{}{{Hh{{G`{{h{c}}Kf{h{Kh}}}}}}}}Lj}}}{AjBfFl}}{{{h{{Lb{c}}}}Cl}{{`{{Lf{}{{Hh{{G`{{h{c}}Kf{h{Kh}}}}}}}}}}}{AjBfFl}}{{{h{c}}}Jb{}}={{{h{{Lb{c}}}}e}{{`{{Lf{}{{Hh{{G`{{h{c}}Cd}}}}}}Aj}}}{AjBfFl}{{Hn{c}}}}{ce{}{}}````````````{{{h{AfMb}}{h{Md}}}{{Eb{BbMf}}}}{{{h{AfMb}}{h{Mh}}Db}{{Eb{MdMj}}}}{{{h{AfMb}}{h{Mh}}Dbj}{{Eb{MdMl}}}}{{{h{AfMb}}Mn}{{Eb{MdMj}}}}{{{h{Mn}}}j}`{{{h{c}}}{{h{e}}}{}{}}0000000{{{h{Afc}}}{{h{Afe}}}{}{}}0000000{{{h{Mn}}}Mn}{{{h{Mb}}}Mb}{{{h{Md}}}Md}{{{h{Mf}}}Mf}{{{h{N`}}}N`}{{{h{Mj}}}Mj}{{{h{Ml}}}Ml}{{{h{c}}{h{Afe}}}Bb{}{}}000000{{}Md}{c{{Eb{Md}}}F`}{{{h{AfMb}}j}{{Eb{MdMf}}}}{{{h{Mn}}{h{Mn}}}Fd}{{{h{Mb}}{h{Mb}}}Fd}{{{h{Md}}{h{Md}}}Fd}{{{h{Mf}}{h{Mf}}}Fd}{{{h{N`}}{h{N`}}}Fd}{{{h{Mj}}{h{Mj}}}Fd}{{{h{Ml}}{h{Ml}}}Fd}{{Mnc}{{Eb{MnMn}}}{{Jl{}{{Hh{j}}}}}}{{{h{Mn}}{h{AfFh}}}Fj}{{{h{Mb}}{h{AfFh}}}Fj}{{{h{Md}}{h{AfFh}}}Fj}{{{h{Mf}}{h{AfFh}}}Fj}0{{{h{N`}}{h{AfFh}}}Fj}0{{{h{Mj}}{h{AfFh}}}Fj}0{{{h{Ml}}{h{AfFh}}}Fj}0{cc{}}000{cMd{{Jl{}{{Hh{{G`{Db{Dd{Cn}}}}}}}}}}1111{c{{Eb{Mn{Dd{Mn}}}}}{{Jl{}{{Hh{j}}}}}}{{{Kl{DbCn}}}{{Eb{MbMf}}}}{Md{{Eb{MbMf}}}}{Cn{{G`{MbMd}}}}{{{h{Mh}}Db}Mn}{cMd{{Jl{}{{Hh{{G`{DbCn}}}}}}}}6{{{h{L`}}}{{Ij{Md}}}}{Mn{{Eb{MbMf}}}}{{{h{Mb}}}Cn}{{{h{Mn}}Db}{{Dd{Mn}}}}{{{h{Mb}}Db}{{Dd{Mn}}}}{{{h{Mb}}}{{Eb{jc}}}{}}{{{h{Mn}}}Cn}{{{h{Mn}}}Db}`{{{h{Mb}}}Md}{{Mnj}Mn}{{{h{AfMb}}j}{{Eb{MdN`}}}}{ce{}{}}0000000{c{{Hf{g}}}{}{}{{Hj{}{{Hh{e}}}}}}1{Mnc{}}{{{h{Mb}}jj}{{Eb{{Dd{Fd}}c}}}{}}{{{h{Md}}}Fd}{{{h{Mn}}}Nb}{{{h{Mb}}}Nb}{{{h{AfMd}}Md}Bb}{jMn}{{{h{AfNb}}}{{Dd{c}}}{}}`{{{h{Md}}{h{L`}}}{{Ij{Bb}}}}{{{h{Mn}}}{{Dd{Mn}}}}{{Mnj}{{Eb{MnMn}}}}{{{h{Mn}}c}{{`{{Hj{}{{Hh{Mn}}}}}}}{{Hn{Db}}}}{{{h{Mb}}c}{{`{{Hj{}{{Hh{Mn}}}}}}}{{Hn{Db}}}}{{{h{Md}}c}EbIb}{{{h{Mb}}}Mn}{{{h{c}}}e{}{}}000000{{{h{c}}}In{}}000{c{{J`{i}}}{}{}{}{{Hj{}{{Hh{{Eb{eg}}}}}}}}{c{{Eb{e}}}{}{}}0000000`00000000{{{h{c}}}Jb{}}0000000`{ce{}{}}0000000`{{{h{L`}}{h{Gj}}{h{{Ab{{h{{Ab{{h{Gj}}}}}}}}}}}{{Ij{Bb}}}}````{{{h{c}}}{{h{e}}}{}{}}000{{{h{Afc}}}{{h{Afe}}}{}{}}000{{Nde}Nd{{Lj{}{{Hh{Kf}}}}Nf}{{Jl{}{{Nh{c}}{Hh{Kf}}}}}}{{Nde}Nd{{Lj{}{{Hh{Cd}}}}Nf}{{Jl{}{{Nh{c}}{Hh{Cd}}}}}}{{{Nj{c}}cg}{{Nj{c}}}{BfAj}{{Hj{}{{Hh{{Ld{Cd}}}}}}Nf}{{Jl{}{{Nh{e}}}}}}``{{Nde}Nd{{Lj{}{{Hh{Cl}}}}Nf}{{Jl{}{{Nh{c}}{Hh{Cl}}}}}}``{cc{}}000{MnNd}{Mn{{Nj{c}}}{BfAj}}{{Mn{h{{Kj{c}}}}}{{Nj{c}}}{FlBfAj}}``{{Ndc}Nd{{Nl{{h{Kf}}}}NfNn}}{{Ndc}Nd{{Nl{{h{O`}}}}NfNn}}{{{Nj{c}}e}{{Nj{c}}}{NfBfAj}{{Nl{cDb{h{O`}}}}NfNnAj}}{{{Nj{c}}ce}{{Nj{c}}}{NfBfAj}{{Nl{Db{h{O`}}}}NfNn}}{{Ndc}Nd{{Nl{{h{Cl}}}}NfNn}}{ce{}{}}000``{{Nd{h{{Kj{c}}}}e}Nd{AjBfFlNfNn}{{Hn{c}}}}{{Nde}Nd{{Lj{}{{Hh{Kf}}}}Nf}{{Jl{}{{Nh{c}}}}}}{{Nde}Nd{{Lj{}{{Hh{Cd}}}}Nf}{{Jl{}{{Nh{c}}}}}}>{{Nde}Nd{{Lj{}{{Hh{Cl}}}}Nf}{{Jl{}{{Nh{c}}}}}}``{c{{Eb{e}}}{}{}}0000000`{{{h{c}}}Jb{}}0006666`````````````{{{h{{Jj{c}}}}}{{h{{Ln{{G`{cCl}}}}}}}{}}{{{h{{Jj{c}}}}}{{`{{Hj{}{{Hh{{G`{Kf{h{Kh}}}}}}}}}}}{}}{{{h{{Kb{c}}}}}{{`{{Hj{}{{Hh{Db}}}}}}}f}``{{{h{Af{Jj{c}}}}{Kb{c}}}Bb{AjBf}}{{{h{Af{Jj{c}}}}{Jj{c}}}{{Kb{c}}}{AjBf}}{{{h{{Jj{c}}}}}{{h{{Jj{c}}}}}{}}{{{h{{Jj{c}}}}{h{e}}jik}bf{{Gn{}{{Gl{Ob}}}}}Aj{{Jl{}{{Hh{{G`{gKf}}}}}}}{{Nl{{h{g}}Cd}{{Od{Fd}}}}}}{{{h{Af{Jj{c}}}}e}{{Kb{c}}}{AjBf}{{Jl{}{{Hh{{G`{CjFb}}}}}}}}{{{h{c}}}{{h{e}}}{}{}}000000{{{h{Afc}}}{{h{Afe}}}{}{}}000000{{{h{{Jj{c}}}}{h{Cj}}}{{Eb{C`Of}}}{}}`{c{{Dd{C`}}}{}}{c{{Dd{Ll}}}{}}10{{{h{{Jj{c}}}}}{{Jj{c}}}Aj}{{{h{{Oh{ce}}}}}{{Oh{ce}}}AjAj}{{{h{{Oj{ce}}}}}{{Oj{ce}}}AjAj}{{{h{{Kb{c}}}}}{{Kb{c}}}Aj}{{{h{c}}{h{Afe}}}Bb{}{}}000{{{h{{Oh{ce}}}}{h{{Oh{ce}}}}}BdBfBf}{{{h{{Oj{ce}}}}{h{{Oj{ce}}}}}BdBfBf}{{}{{Jj{c}}}{}}{{}{{Kb{c}}}{}}{{{h{{Oh{ce}}}}}{{h{g}}}{}{}{}}{c{{Eb{{Kb{e}}}}}F`{BfK`}}{{{h{{Jj{c}}}}{h{Cj}}}{{`{{Hj{}{{Hh{{G`{GdCl}}}}}}}}}{}}{{{h{{Jj{c}}}}{h{{Jj{c}}}}}FdFf}{{{h{{Oh{ce}}}}{h{{Oh{ce}}}}}FdFfFf}{{{h{{Oj{ce}}}}{h{{Oj{ce}}}}}FdFfFf}{{{h{Of}}{h{Of}}}Fd}{{{h{{Kb{c}}}}{h{{Kb{c}}}}}FdFf}{{{h{c}}{h{e}}}Fd{}{}}00000{{{h{{Jj{c}}}}{h{e}}ji}{{`{{Hj{}{{Hh{{G`{g{An{c}}}}}}}}}}}f{{Gn{}{{Gl{Ob}}}}}Aj{{Jl{}{{Hh{{G`{gKf}}}}}}}}0{{{h{{Jj{c}}}}}{{`{{Hj{}{{Hh{{G`{Kf{h{Kh}}}}}}}}}}}{}}{{{h{{Jj{c}}}}{h{AfFh}}}FjFl}{{{h{{Oh{ce}}}}{h{AfFh}}}FjFlFl}{{{h{{Oj{ce}}}}{h{AfFh}}}FjFlFl}{{{h{Of}}{h{AfFh}}}Fj}0{{{h{{Kb{c}}}}{h{AfFh}}}FjFl}{cc{}}000000{{{h{L`}}}{{Ij{{Kb{c}}}}}{fAjBfIlD`}}{{{h{{Jj{c}}}}}{{`{{Hj{}{{Hh{{Oh{{Ol{Cj}}c}}}}}}}}}{}}{{{h{{Jj{c}}}}{h{e}}jCl}{{Dd{{Ah{{h{c}}}}}}}f{{Gn{}{{Gl{Ob}}}}}}{{{h{{Jj{c}}}}{h{e}}jKf}{{Dd{{G`{{Ah{{h{c}}}}Cl}}}}}f{{Gn{}{{Gl{Ob}}}}}}{{{h{{Jj{c}}}}Cl}{{Dd{{Ol{Cj}}}}}{}}{{{h{{Jj{c}}}}Cl}{{Dd{{Oh{{Ol{Cj}}c}}}}}{}}{{{h{{Jj{c}}}}Kf}{{Dd{{h{Kh}}}}}{}}{{{h{{Jj{c}}}}}{{Kb{c}}}{AjBf}}{{{h{Af{Jj{c}}}}Clc}{{Kb{c}}}{AjBf}}{{{h{Af{Jj{c}}}}ClFb}{{Kb{c}}}{AjBf}}{{{h{Af{Jj{c}}}}e}{{Kb{c}}}{AjBf}{{On{{Ol{Cj}}}}}}{{{h{Af{Jj{c}}}}KfKh}{{Kb{c}}}{AjBf}}{ce{}{}}000000{c{{Hf{g}}}{}{}{{Hj{}{{Hh{e}}}}}}011{{{h{{Jj{c}}}}}Fd{}}{{{h{{Kb{c}}}}}FdBf}``{{{h{{Jj{c}}}}{h{e}}j}{{`{{Hj{}{{Hh{{Oj{{Ol{Cj}}c}}}}}}}}}fGn}{{{Jj{c}}g}{{Jj{e}}}{AjBf}{AjBf}{{Nl{c}{{Od{e}}}}}}{{{Kb{c}}g}{{Kb{e}}}BfBf{{Nl{c}{{Od{e}}}}}}{{{h{Af{Kb{c}}}}{Kb{c}}}BbBf}{c{{Jj{e}}}{{Jl{}{{Hh{Cj}}}}}{AjBf}}{{{h{Af{A@`{cg}}}}}{{Dd{i}}}{}{}{{Nl{Gd{Ol{Cj}}}{{Od{{Dd{e}}}}}}}{}}{{{h{Af{A@b{cg}}}}}{{Dd{i}}}{}{}{{Nl{GdCl}{{Od{{Dd{e}}}}}}}{}}{{{h{{Jj{c}}}}Kf}{{h{{A@d{Cl}}}}}{}}{{{h{{Oh{ce}}}}{h{{Oh{ce}}}}}{{Dd{Bd}}}I`I`}{{{h{{Oj{ce}}}}{h{{Oj{ce}}}}}{{Dd{Bd}}}I`I`}{{{h{{Kb{c}}}}{h{L`}}}{{Ij{Bb}}}{fAjBfIlD`}}{{{h{{Kb{c}}}}e}Eb{BfIl}Ib}{{{h{c}}}e{}{}}000{{{h{c}}}In{}}{c{{J`{i}}}{}{}{}{{Hj{}{{Hh{{Eb{eg}}}}}}}}0{{{h{{Jj{c}}}}{h{e}}jik}{{Eb{b}}}fGnAj{{Jl{}{{Hh{{G`{gKf}}}}}}}{{Nl{{h{g}}Cd}{{Od{Fd}}}}}}{{{h{{Jj{c}}}}{h{e}}ji}{{`{{Hj{}{{Hh{{Eb{{G`{g{An{c}}}}}}}}}}}}}fGnAj{{Jl{}{{Hh{{G`{gKf}}}}}}}}0{c{{Eb{e}}}{}{}}000000{{{h{{Jj{c}}}}{h{e}}jCl}{{Eb{{Dd{{Ah{{h{c}}}}}}}}}fGn}{{{h{{Jj{c}}}}{h{e}}jKf}{{Eb{{Dd{{G`{{Ah{{h{c}}}}Cl}}}}}}}fGn}2222222{{{h{{Jj{c}}}}{h{e}}j}{{`{{Hj{}{{Hh{{Eb{{Oj{{Ol{Cj}}c}}}}}}}}}}}fGn}``{{{h{{Jj{c}}}}Cl}{{Dd{{Kl{Db{h{Kh}}}}}}}{}}{{{h{{Jj{c}}}}Cl}{{`{{Lf{}{{Hh{{G`{Db{h{{A@d{Cl}}}}}}}}}}}}}{}}`{{{h{{Kb{c}}}}}{{`{{Hj{}{{Hh{{G`{Kf{h{Kh}}}}}}}}}}}{}}``{{{h{{Jj{c}}}}}{{`{{Hj{}{{Hh{{Oh{{Ol{Cj}}c}}}}}}}}}{}}{{{h{c}}}Jb{}}000000{{{h{Af{Jj{c}}}}Fb}{{Kb{c}}}{AjBf}}{ce{}{}}000000{{{h{{Jj{c}}}}ei}{{A@`{ci}}}{AjBf}{{On{{Ol{Cj}}}}}{}{{Nl{Gd{Ol{Cj}}}{{Od{{Dd{g}}}}}}}}{{{h{{Jj{c}}}}{h{Cj}}g}{{A@b{cg}}}{}{}{{Nl{GdCl}{{Od{{Dd{e}}}}}}}}{{{h{{Jj{c}}}}Clg}{{A@b{cg}}}{AjBf}{}{{Nl{GdCl}{{Od{{Dd{e}}}}}}}}","D":"CEj","p":[[5,"Balance",0,946],[5,"DescriptorId",0,947],[10,"Anchor",0,948],[1,"reference"],[5,"BlockId",0,949],[5,"ConfirmationBlockTime",0,949],[5,"Hash",950],[1,"u8"],[1,"slice"],[1,"array"],[0,"mut"],[6,"ChainPosition",0,949],[10,"Clone",951],[6,"ConfirmationTime",0,949],[5,"FullTxOut",0,949],[5,"SpkIterator",0,952],[1,"unit"],[6,"Ordering",953],[10,"Ord",953],[5,"Persisted",0,954],[6,"ValueRef",955],[5,"Impl",0],[8,"FromSqlResult",956],[5,"Amount",957],[6,"Network",958],[5,"ScriptBuf",959],[6,"DescriptorPublicKey",960],[6,"Descriptor",961],[5,"Transaction",962],[5,"Txid",962],[5,"BlockHash",963],[10,"DeserializeOwned",964],[1,"u32"],[6,"Option",965],[17,"CreateParams"],[17,"LoadParams"],[17,"CreateError"],[17,"LoadError"],[17,"PersistError"],[10,"PersistWith",0,954],[6,"Result",966],[10,"Future",967],[5,"Box",968],[5,"Pin",969],[10,"PersistAsyncWith",0,954],[10,"Borrow",970],[10,"DescriptorExt",0,947],[10,"Deserializer",964],[1,"u64"],[1,"bool"],[10,"PartialEq",953],[5,"Formatter",971],[8,"Result",971],[10,"Debug",971],[1,"never"],[1,"tuple"],[5,"Block",963],[1,"usize"],[10,"AnchorFromBlockPosition",0,948],[5,"FromSliceError",972],[1,"str"],[17,"Error"],[10,"ChainOracle",0,973],[10,"Hash",974],[10,"Hasher",974],[10,"SliceIndex",975],[5,"IntoFallible",976],[17,"Item"],[10,"Iterator",977],[10,"Merge",0,948],[10,"RangeBounds",978],[10,"PartialOrd",953],[10,"Serializer",979],[17,"ChangeSet"],[10,"Staged",0,954],[6,"ToSqlOutput",980],[8,"Result",981],[10,"Serialize",979],[5,"String",982],[5,"Convert",976],[5,"TypeId",983],[5,"IndexedTxGraph",334],[5,"ChangeSet",334],[10,"Indexer",384],[5,"TxGraph",768],[10,"IntoIterator",984],[10,"Default",985],[10,"Deserialize",964],[5,"ChangeSet",768],[5,"ChangeSet",393],[5,"OutPoint",962],[5,"TxOut",962],[5,"KeychainTxOutIndex",393],[5,"BTreeMap",986],[6,"InsertDescriptorError",393],[5,"Transaction",987],[5,"SpkTxOutIndex",495],[8,"Indexed",0],[10,"DoubleEndedIterator",988],[8,"KeychainIndexed",0],[10,"ExactSizeIterator",989],[5,"SignedAmount",957],[5,"BTreeSet",990],[5,"Vec",991],[5,"LocalChain",532],[5,"ChangeSet",532],[5,"MissingGenesisError",532],[5,"Header",963],[5,"CannotConnectError",532],[6,"ApplyHeaderError",532],[5,"CheckPoint",532],[5,"AlterCheckPointError",532],[5,"CheckPointIter",532],[5,"SyncRequest",704],[10,"Send",992],[17,"IntoIter"],[5,"FullScanRequest",704],[10,"FnMut",993],[10,"Sync",992],[5,"Script",994],[6,"Infallible",995],[17,"Output"],[6,"CalculateFeeError",768],[5,"TxNode",768],[5,"CanonicalTx",768],[5,"Arc",996],[10,"Into",995],[5,"TxAncestors",768],[5,"TxDescendants",768],[5,"HashSet",997],[15,"Confirmed",331],[15,"Unconfirmed",331],[15,"DescriptorAlreadyAssigned",491],[15,"KeychainAlreadyAssigned",491],[5,"SyncResult",704],[5,"FullScanResult",704]],"r":[[0,948],[1,948],[2,952],[3,946],[4,949],[6,973],[7,949],[9,949],[10,949],[17,947],[18,947],[20,949],[23,334],[24,384],[30,948],[31,954],[34,954],[35,954],[36,952],[37,954],[38,768],[224,384],[258,384]],"b":[[48,"impl-AsRef%3C%5Bu8%5D%3E-for-DescriptorId"],[49,"impl-AsRef%3C%5Bu8;+%3C%24hash+as+%24crate::Hash%3E::LEN%5D%3E-for-DescriptorId"],[98,"impl-FromSql-for-Impl%3CDescriptorId%3E"],[99,"impl-FromSql-for-Impl%3CAmount%3E"],[100,"impl-FromSql-for-Impl%3CNetwork%3E"],[101,"impl-FromSql-for-Impl%3CScriptBuf%3E"],[102,"impl-FromSql-for-Impl%3CDescriptor%3CDescriptorPublicKey%3E%3E"],[103,"impl-FromSql-for-Impl%3CTransaction%3E"],[104,"impl-FromSql-for-Impl%3CTxid%3E"],[105,"impl-FromSql-for-Impl%3CBlockHash%3E"],[106,"impl-FromSql-for-Impl%3CA%3E"],[156,"impl-Display-for-Balance"],[157,"impl-Debug-for-Balance"],[164,"impl-UpperHex-for-DescriptorId"],[165,"impl-Display-for-DescriptorId"],[166,"impl-Debug-for-DescriptorId"],[167,"impl-LowerHex-for-DescriptorId"],[176,"impl-From%3C(%26u32,+%26BlockHash)%3E-for-BlockId"],[177,"impl-From%3C(u32,+BlockHash)%3E-for-BlockId"],[272,"impl-ToSql-for-Impl%3CA%3E"],[273,"impl-ToSql-for-Impl%3CTransaction%3E"],[274,"impl-ToSql-for-Impl%3CDescriptorId%3E"],[275,"impl-ToSql-for-Impl%3CScriptBuf%3E"],[276,"impl-ToSql-for-Impl%3CAmount%3E"],[277,"impl-ToSql-for-Impl%3CBlockHash%3E"],[278,"impl-ToSql-for-Impl%3CDescriptor%3CDescriptorPublicKey%3E%3E"],[279,"impl-ToSql-for-Impl%3CTxid%3E"],[280,"impl-ToSql-for-Impl%3CNetwork%3E"],[357,"impl-From%3CChangeSet%3CA%3E%3E-for-ChangeSet%3CA,+IA%3E"],[359,"impl-From%3CChangeSet%3E-for-ChangeSet%3CA,+ChangeSet%3E"],[402,"impl-Indexer-for-KeychainTxOutIndex%3CK%3E"],[403,"impl-KeychainTxOutIndex%3CK%3E"],[422,"impl-Display-for-InsertDescriptorError%3CK%3E"],[423,"impl-Debug-for-InsertDescriptorError%3CK%3E"],[594,"impl-Display-for-MissingGenesisError"],[595,"impl-Debug-for-MissingGenesisError"],[596,"impl-Display-for-AlterCheckPointError"],[597,"impl-Debug-for-AlterCheckPointError"],[598,"impl-Display-for-CannotConnectError"],[599,"impl-Debug-for-CannotConnectError"],[600,"impl-Display-for-ApplyHeaderError"],[601,"impl-Debug-for-ApplyHeaderError"],[616,"impl-FromIterator%3C(u32,+BlockHash)%3E-for-ChangeSet"],[617,"impl-FromIterator%3C(u32,+Option%3CBlockHash%3E)%3E-for-ChangeSet"],[843,"impl-Display-for-CalculateFeeError"],[844,"impl-Debug-for-CalculateFeeError"]],"c":"OjAAAAAAAAA=","e":"OzAAAAEAAAUCVQAYAAEAJwAAACoAAQAtAAIAMQACADUAFABLAA8AXAAPAG8AAAB2AAUAfgAEAIQAJgCvAAAAsQABALcAAAC6AAMAvwACAMMABADLAAAA2QAAAOEAAADoAAAA6wABAO4ABgD5AAAA+wAFAAMBAAAHAQgAEQEKACABEwA2AQkAQgEJAFUBAABZAQsAZgEAAGgBAABzAQEAdgEFAH0BAwCTAQAAlQEUALABAgC5AQAA0wEAANUBCQDiAQIA6QECAPIBBgD7AQIAAQIAAAsCAgARAgAAFAIAACcCHwBIAgYAUAIKAF8CAABpAgEAcAIAAIACAwCGAgAAiAIAAI8CAACRAgoAnQIHAKYCDwC3AgcAxQIHAPACBwD5AgcAFQMAABgDDQAoAxEAOwMKAEkDBQBrAwEAbgMAAHQDAAB2AwEAeQMBAHwDBQCHAwYAkAMGAKEDBgCpAwYA"}],\
-["bdk_coin_select",{"t":"FFGGFFPIPFGPPPFGFPPSPPPPPFNNNNOONNNNNNNNNNNNNNNNNNNNNNNNNNONNNNNNNNNNNNNNNNNHNNNONONNNNNNNNOOONNNNNNNNNNNNNNNNNNNNNNNNNNNNNNONNNNNNNNNNNNNNNNONNOOOONNNNONOOOOONNNNONNNNNNOOOONNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNONNNNNNNNNNNNOOON","n":["Bnb","BnbIter","BnbLimit","BranchStrategy","CoinSelector","CoinSelectorOpt","Continue","DecideStrategy","Duration","ExcessStrategy","ExcessStrategyKind","MinAbsoluteFee","MinDrainValue","Rounds","Selection","SelectionConstraint","SelectionError","SkipBoth","SkipInclusion","TXIN_BASE_WEIGHT","TargetFee","TargetValue","ToDrain","ToFee","ToRecipient","WeightedValue","advertise_new_score","all_selected","apply_selection","backtrack","base_weight","best_score","best_strategy","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","candidate","candidates","clone","clone","clone","clone","clone","clone","clone","clone","clone_into","clone_into","clone_into","clone_into","clone_into","clone_into","clone_into","clone_into","cmp","coin_select_bnb","current_excess","current_weight","deselect","drain_value","drain_waste","drain_weight","effective_target","effective_value","eq","eq","equivalent","equivalent","equivalent","equivalent","excess","excess_strategies","fee","feerate","finish","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","forward","from","from","from","from","from","from","from","from","from","from","from","from","from","from","fund_outputs","hash","input_count","into","into","into","into","into","into","into","into","into","into","into","into","into_fallible","into_iter","into_iter","is_empty","is_segwit","is_selected","long_term_feerate","long_term_feerate","max_extra_target","min_absolute_fee","min_drain_value","new","new","new","next","opts","partial_cmp","pool","pool_pos","recipient_value","rem_abs","rem_eff","select","select_all","select_until_finished","selected","selected","selected_absolute_value","selected_count","selected_effective_value","selected_indexes","selected_waste","selected_weight","selection","spend_drain_weight","target_feerate","target_value","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","to_string","to_string","to_string","transpose_into_fallible","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","unselected","unselected_indexes","value","vzip","vzip","vzip","vzip","vzip","vzip","vzip","vzip","vzip","vzip","vzip","vzip","waste","weight","weight","will_continue"],"q":[[0,"bdk_coin_select"],[241,"bdk_coin_select::bnb"],[242,"core::cmp"],[243,"bdk_coin_select::coin_selector"],[244,"core::iter::traits::iterator"],[245,"core::option"],[246,"core::convert"],[247,"core::result"],[248,"core::fmt"],[249,"core::time"],[250,"bitcoin::blockdata::transaction"],[251,"core::hash"],[252,"fallible_iterator"],[253,"alloc::vec"],[254,"core::marker"],[255,"alloc::string"],[256,"core::any"]],"i":[0,0,0,0,0,0,43,0,22,0,0,18,18,22,0,0,0,43,43,0,18,18,11,11,11,0,2,6,7,2,16,2,7,43,2,35,22,15,16,6,17,18,7,11,12,43,2,35,22,15,16,6,17,18,7,11,12,6,6,15,16,6,17,18,7,11,12,15,16,6,17,18,7,11,12,11,0,6,6,6,12,16,16,6,15,18,11,18,18,11,11,7,7,12,12,6,15,16,6,17,17,18,18,7,11,11,12,2,43,2,35,22,22,22,15,16,6,17,18,7,11,12,16,11,15,43,2,35,22,15,16,6,17,18,7,11,12,35,2,35,6,15,6,16,16,16,16,16,2,15,6,35,6,11,2,2,12,2,2,6,6,6,6,7,6,6,6,6,6,6,2,16,16,16,15,16,6,17,18,7,11,12,17,18,11,35,43,2,35,22,15,16,6,17,18,7,11,12,43,2,35,22,15,16,6,17,18,7,11,12,43,2,35,22,15,16,6,17,18,7,11,12,6,6,15,43,2,35,22,15,16,6,17,18,7,11,12,12,15,12,43],"f":"``````````````````````````{{{f{b{d{c}}}}c}hj}{{{f{l}}}h}{{{f{n}}{f{{A`{c}}}}}{{`{{Ad{}{{Ab{{f{c}}}}}}}}}{}}{{{f{b{d{c}}}}}hj}``{{{f{n}}}{{Aj{{f{Af}}{f{Ah}}}}}}{{{f{c}}}{{f{e}}}{}{}}00000000000{{{f{bc}}}{{f{be}}}{}{}}00000000000{{{f{l}}Al}{{f{An}}}}`{{{f{An}}}An}{{{f{B`}}}B`}{{{f{l}}}l}{{{f{Bb}}}Bb}{{{f{Bd}}}Bd}{{{f{n}}}n}{{{f{Af}}}Af}{{{f{Ah}}}Ah}{{{f{c}}{f{be}}}Bf{}{}}0000000{{{f{Af}}{f{Af}}}Bh}{{cl}{{Bj{l}}}{{Bn{Bl}}}}{{{f{l}}}C`}{{{f{l}}}Cb}{{{f{bl}}Al}h}`{{{f{B`}}}C`}`3{{{f{An}}Cd}C`}{{{f{Bd}}{f{Bd}}}h}{{{f{Af}}{f{Af}}}h}{{{f{c}}{f{e}}}h{}{}}000```{{{f{Ah}}}Cd}{{{f{l}}}{{Cf{nBb}}}}{{{f{An}}{f{bCh}}}Cj}{{{f{B`}}{f{bCh}}}Cj}{{{f{l}}{f{bCh}}}Cj}{{{f{Bb}}{f{bCh}}}Cj}0{{{f{Bd}}{f{bCh}}}Cj}0{{{f{n}}{f{bCh}}}Cj}{{{f{Af}}{f{bCh}}}Cj}0{{{f{Ah}}{f{bCh}}}Cj}{{{f{b{d{c}}}}h}Bfj}{cc{}}00{AlBl}{ClBl}222222222{{{f{{A`{Cn}}}}{f{Cn}}Cb}B`}{{{f{Af}}{f{bc}}}BfD`}`{ce{}{}}00000000000{c{{Db{g}}}{}{}{{Ad{}{{Ab{e}}}}}}{{{d{c}}{f{{Dd{c}}}}}{{Df{c}}}j}2{{{f{l}}}h}`{{{f{l}}Al}h}{{{f{B`}}}Cd}````{{l{Dh{{Aj{Al{f{An}}}}}}c}{{d{c}}}j}{{DjCbh}An}{{{f{{Dh{An}}}}{f{B`}}}l}{{{f{b{Df{c}}}}}{{Bj{e}}}{jDlDn}{}}`{{{f{Af}}{f{Af}}}{{Bj{Bh}}}}`````{{{f{bl}}Al}h}{{{f{bl}}}Bf}{{{f{bl}}}{{Cf{nBb}}}}{{{f{l}}}{{`{{Ad{}{{Ab{{Aj{Al{f{An}}}}}}}}}}}}`{{{f{l}}}Dj}{{{f{l}}}Al}{{{f{l}}}C`}{{{f{l}}}{{`{{Ad{}{{Ab{Al}}}}}}}}1{{{f{l}}}Cb}````{{{f{c}}}e{}{}}0000000{{{f{c}}}E`{}}00{c{{Eb{i}}}{}{}{}{{Ad{}{{Ab{{Cf{eg}}}}}}}}{c{{Cf{e}}}{}{}}00000000000000000000000{{{f{c}}}Ed{}}00000000000:6`{ce{}{}}00000000000```{{{f{Ef}}}h}","D":"Hl","p":[[0,"mut"],[5,"Bnb",0,241],[1,"reference"],[1,"bool"],[10,"Ord",242],[5,"CoinSelector",0,243],[5,"Selection",0,243],[1,"slice"],[17,"Item"],[10,"Iterator",244],[6,"ExcessStrategyKind",0,243],[5,"ExcessStrategy",0,243],[1,"tuple"],[1,"usize"],[5,"WeightedValue",0,243],[5,"CoinSelectorOpt",0,243],[5,"SelectionError",0,243],[6,"SelectionConstraint",0,243],[1,"unit"],[6,"Ordering",242],[6,"Option",245],[6,"BnbLimit",0,241],[10,"Into",246],[1,"i64"],[1,"u32"],[1,"f32"],[6,"Result",247],[5,"Formatter",248],[8,"Result",248],[5,"Duration",249],[5,"TxOut",250],[10,"Hasher",251],[5,"IntoFallible",252],[8,"DecideStrategy",0,241],[5,"BnbIter",0,241],[5,"Vec",253],[1,"u64"],[10,"Copy",254],[10,"Display",248],[5,"String",255],[5,"Convert",252],[5,"TypeId",256],[6,"BranchStrategy",0,241]],"r":[[0,241],[1,241],[2,241],[3,241],[4,243],[5,243],[7,241],[9,243],[10,243],[14,243],[15,243],[16,243],[25,243],[76,241]],"b":[[99,"impl-Display-for-SelectionError"],[100,"impl-Debug-for-SelectionError"],[101,"impl-Debug-for-SelectionConstraint"],[102,"impl-Display-for-SelectionConstraint"],[104,"impl-Debug-for-ExcessStrategyKind"],[105,"impl-Display-for-ExcessStrategyKind"],[111,"impl-From%3Cusize%3E-for-BnbLimit"],[112,"impl-From%3CDuration%3E-for-BnbLimit"]],"c":"OjAAAAAAAAA=","e":"OzAAAAEAAKsAGAAAAAAAAgAAAAYAAAAJAAIADgADABcAAgAcAAEAIAAAACIAKgBQAAIAVgAIAGAACwBwAAEAewABAIwAAQCPAAEAlwANAKYAAACoAAAAqwAAAK8ACgC7ACUA4gAMAPAAAQA="}],\
+["bdk_chain",{"t":"KKSFFSKGRFGPPRRRRKFRFFIEEIRRRRKKRRKFFKEPPNNMNNNNNNEONNNNNNNNNNNNNNNNNNNNNONNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNOOMMNNNNNNNNNMNNNNNMNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNMNNNNNNNNMNNNNNOOONCCNNNNNNNNNNNNMNNNMNOEMMNNCMENNNNONNNNNNNMMNNDCDNNNNNOCEMNNNNNNNNNNNNNNNNNNNNNNNNNONNNNNNNNNNNNNNNNNNNNNCONNNNNNNNNNNONNNNNNNNNNOOOFFNNNNNNNNNNNNNNNNNNNNNNNNNOONNNNNNNNNNNNNNNNONNNNRKMMMMMCCFSPGPFTTNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNONNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNOOOOFNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNFGTPFFFFPFFTNNNNNONNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNONNNNNNNNNNNNNNNNNNNNNONNNNNNNNNNNNNNNNNNNNNNNNNNNONNNNNNNNNNNNNNNNONNNNNNNNSHFFFFNNNNNNNNNNNOONOONNNNNNNOONNNNNNNNNOONNNNNOONNNNNNNNONNNNNNNNTGFFPPTTTFFFFNNNOONNNNNNNNNNNNNNNNNNNNONNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNOONNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNOONNONOONNNNNNNNNNNNNNNNNNN","n":["Anchor","AnchorFromBlockPosition","BIP32_MAX_INDEX","Balance","BlockId","COINBASE_MATURITY","ChainOracle","ChainPosition","ChangeSet","ConfirmationBlockTime","ConfirmationTime","Confirmed","Confirmed","CreateError","CreateError","CreateParams","CreateParams","DescriptorExt","DescriptorId","Error","FullTxOut","Impl","Indexed","IndexedTxGraph","Indexer","KeychainIndexed","LoadError","LoadError","LoadParams","LoadParams","Merge","PersistAsyncWith","PersistError","PersistError","PersistWith","Persisted","SpkIterator","Staged","TxGraph","Unconfirmed","Unconfirmed","add","all_zeros","anchor_block","anchor_block","anchor_block","as_byte_array","as_raw_hash","as_ref","as_ref","bitcoin","block_id","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","chain_position","clone","clone","clone","clone","clone","clone","clone","clone","clone_into","clone_into","clone_into","clone_into","clone_into","clone_into","clone_into","clone_into","cloned","cmp","cmp","cmp","cmp","cmp","cmp","cmp","column_result","column_result","column_result","column_result","column_result","column_result","column_result","column_result","column_result","confirmation_height_upper_bound","confirmation_height_upper_bound","confirmation_height_upper_bound","confirmation_height_upper_bound","confirmation_time","confirmed","create","create","create","create_async","default","default","default","deref","deref","deref_mut","descriptor","descriptor_id","deserialize","deserialize","deserialize","deserialize","deserialize","dust_value","engine","eq","eq","eq","eq","eq","eq","eq","eq","equivalent","equivalent","equivalent","equivalent","equivalent","equivalent","equivalent","equivalent","equivalent","equivalent","equivalent","equivalent","equivalent","equivalent","equivalent","equivalent","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from_block_position","from_block_position","from_block_position","from_byte_array","from_engine","from_raw_hash","from_slice","from_slice_delegated","from_str","get_chain_tip","hash","hash","hash","hash","hash","hash","height","immature","index","indexed_tx_graph","indexer","into","into","into","into","into","into","into","into","into","into","into_fallible","into_iter","is_block_in_chain","is_confirmed","is_confirmed","is_confirmed_and_spendable","is_empty","is_mature","is_on_coinbase","keychain_txout","load","load","load","load_async","local_chain","merge","miniscript","new","new_with_range","next","nth","outpoint","partial_cmp","partial_cmp","partial_cmp","partial_cmp","partial_cmp","partial_cmp","partial_cmp","persist","persist","persist","persist_async","rusqlite","rusqlite_impl","serde","serialize","serialize","serialize","serialize","serialize","spent_by","spk_client","spk_txout","staged","take","take","to_byte_array","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","to_raw_hash","to_sql","to_sql","to_sql","to_sql","to_sql","to_sql","to_sql","to_sql","to_sql","to_string","to_string","total","transpose_into_fallible","trusted_pending","trusted_spendable","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","tx_graph","txout","type_id","type_id","type_id","type_id","type_id","type_id","type_id","type_id","type_id","type_id","unconfirmed","untrusted_pending","vzip","vzip","vzip","vzip","vzip","vzip","vzip","vzip","vzip","vzip","height","last_seen","time","ChangeSet","IndexedTxGraph","apply_block","apply_block_relevant","apply_changeset","apply_update","as_ref","batch_insert_relevant","batch_insert_relevant_unconfirmed","batch_insert_unconfirmed","borrow","borrow","borrow_mut","borrow_mut","clone","clone_into","default","default","deserialize","eq","fmt","fmt","from","from","from","from","graph","index","indexer","initial_changeset","insert_anchor","insert_seen_at","insert_tx","insert_txout","into","into","is_empty","merge","new","serialize","to_owned","try_from","try_from","try_into","try_into","tx_graph","type_id","type_id","vzip","vzip","ChangeSet","Indexer","apply_changeset","index_tx","index_txout","initial_changeset","is_tx_relevant","keychain_txout","spk_txout","ChangeSet","DEFAULT_LOOKAHEAD","DescriptorAlreadyAssigned","InsertDescriptorError","KeychainAlreadyAssigned","KeychainTxOutIndex","LAST_REVEALED_TABLE_NAME","SCHEMA_NAME","all_unbounded_spk_iters","apply_changeset","apply_changeset","borrow","borrow","borrow","borrow_mut","borrow_mut","borrow_mut","clone","clone","clone","clone_into","clone_into","clone_into","default","default","deserialize","eq","eq","fmt","fmt","fmt","fmt","from","from","from","from_sqlite","get_descriptor","index_of_spk","index_tx","index_txout","initial_changeset","inner","insert_descriptor","into","into","into","is_empty","is_tx_relevant","is_used","keychain_outpoints","keychain_outpoints_in_range","keychains","last_revealed","last_revealed_index","last_revealed_indices","last_used_index","last_used_indices","lookahead","lookahead_to_target","mark_used","merge","net_value","new","next_index","next_unused_spk","outpoints","persist_to_sqlite","reveal_next_spk","reveal_to_target","reveal_to_target_multi","revealed_keychain_spks","revealed_spks","sent_and_received","serialize","spk_at_index","to_owned","to_owned","to_owned","to_string","try_from","try_from","try_from","try_into","try_into","try_into","txout","txouts","txouts_in_tx","type_id","type_id","type_id","unbounded_spk_iter","unmark_used","unused_keychain_spks","unused_spks","vzip","vzip","vzip","descriptor","existing_assignment","existing_assignment","keychain","SpkTxOutIndex","all_spks","apply_changeset","borrow","borrow_mut","clone","clone_into","default","fmt","from","index_of_spk","index_tx","index_txout","initial_changeset","insert_spk","into","is_relevant","is_tx_relevant","is_used","mark_used","net_value","outpoints","outputs_in_range","scan","scan_txout","sent_and_received","spk_at_index","to_owned","try_from","try_into","txout","txouts","txouts_in_tx","type_id","unmark_used","unused_spks","vzip","AlterCheckPointError","ApplyHeaderError","BLOCKS_TABLE_NAME","CannotConnect","CannotConnectError","ChangeSet","CheckPoint","CheckPointIter","InconsistentBlocks","LocalChain","MissingGenesisError","SCHEMA_NAME","apply_changeset","apply_header","apply_header_connected_to","apply_update","block_id","blocks","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","clone","clone","clone","clone","clone","clone","clone","clone_into","clone_into","clone_into","clone_into","clone_into","clone_into","clone_into","default","deserialize","disconnect_from","eq","eq","eq","eq","eq","eq","eq","extend","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","from","from","from","from","from","from","from","from","from","from_block_ids","from_blocks","from_changeset","from_genesis_hash","from_header","from_iter","from_iter","from_sqlite","from_tip","genesis_hash","get","get","get_chain_tip","hash","height","height","initial_changeset","insert","insert_block","into","into","into","into","into","into","into","into","into_fallible","into_iter","into_iter","is_block_in_chain","is_empty","iter","iter_checkpoints","merge","new","next","original_hash","persist_to_sqlite","prev","push","range","range","serialize","tip","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","to_string","to_string","to_string","to_string","transpose_into_fallible","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_include_height","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_hash","vzip","vzip","vzip","vzip","vzip","vzip","vzip","vzip","SCHEMAS_TABLE_NAME","migrate_schema","FullScanRequest","FullScanResult","SyncRequest","SyncResult","borrow","borrow","borrow","borrow","borrow_mut","borrow_mut","borrow_mut","borrow_mut","chain_outpoints","chain_spks","chain_spks_for_keychain","chain_tip","chain_tip","chain_txids","chain_update","chain_update","from","from","from","from","from_chain_tip","from_chain_tip","from_keychain_txout_index","graph_update","graph_update","inspect_outpoints","inspect_spks","inspect_spks_for_all_keychains","inspect_spks_for_keychain","inspect_txids","into","into","into","into","last_active_indices","outpoints","populate_with_revealed_spks","set_outpoints","set_spks","set_spks_for_keychain","set_txids","spks","spks_by_keychain","try_from","try_from","try_from","try_from","try_into","try_into","try_into","try_into","txids","type_id","type_id","type_id","type_id","vzip","vzip","vzip","vzip","ANCHORS_TABLE_NAME","CalculateFeeError","CanonicalTx","ChangeSet","MissingTxOut","NegativeFee","SCHEMA_NAME","TXOUTS_TABLE_NAME","TXS_TABLE_NAME","TxAncestors","TxDescendants","TxGraph","TxNode","all_anchors","all_txouts","anchor_heights","anchors","anchors","apply_changeset","apply_update","as_ref","balance","batch_insert_unconfirmed","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","calculate_fee","chain_position","checked_sum","checked_sum","checked_sum","checked_sum","clone","clone","clone","clone","clone_into","clone_into","clone_into","clone_into","cmp","cmp","default","default","deref","deserialize","direct_conflicts","eq","eq","eq","eq","eq","equivalent","equivalent","equivalent","equivalent","equivalent","equivalent","filter_chain_txouts","filter_chain_unspents","floating_txouts","fmt","fmt","fmt","fmt","fmt","fmt","from","from","from","from","from","from","from","from_sqlite","full_txs","get_chain_position","get_chain_spend","get_tx","get_tx_node","get_txout","initial_changeset","insert_anchor","insert_seen_at","insert_tx","insert_txout","into","into","into","into","into","into","into","into_fallible","into_fallible","into_iter","into_iter","is_empty","is_empty","last_seen","last_seen_unconfirmed","list_canonical_txs","map_anchors","map_anchors","merge","new","next","next","outspends","partial_cmp","partial_cmp","persist_to_sqlite","serialize","to_owned","to_owned","to_owned","to_owned","to_string","transpose_into_fallible","transpose_into_fallible","try_balance","try_filter_chain_txouts","try_filter_chain_unspents","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_get_chain_position","try_get_chain_spend","try_into","try_into","try_into","try_into","try_into","try_into","try_into","try_list_canonical_txs","tx","tx_node","tx_outputs","tx_spends","txid","txouts","txouts","txs","txs_with_no_anchor_or_last_seen","type_id","type_id","type_id","type_id","type_id","type_id","type_id","update_last_seen_unconfirmed","vzip","vzip","vzip","vzip","vzip","vzip","vzip","walk_ancestors","walk_conflicts","walk_descendants"],"q":[[0,"bdk_chain"],[331,"bdk_chain::ConfirmationTime"],[334,"bdk_chain::indexed_tx_graph"],[384,"bdk_chain::indexer"],[393,"bdk_chain::indexer::keychain_txout"],[491,"bdk_chain::indexer::keychain_txout::InsertDescriptorError"],[495,"bdk_chain::indexer::spk_txout"],[532,"bdk_chain::local_chain"],[702,"bdk_chain::rusqlite_impl"],[704,"bdk_chain::spk_client"],[768,"bdk_chain::tx_graph"],[946,"bdk_chain::balance"],[947,"bdk_chain::descriptor_ext"],[948,"bdk_chain::tx_data_traits"],[949,"bdk_chain::chain_data"],[950,"bitcoin_hashes::sha256"],[951,"core::clone"],[952,"bdk_chain::spk_iter"],[953,"core::cmp"],[954,"bdk_chain::persist"],[955,"rusqlite::types::value_ref"],[956,"rusqlite::types::from_sql"],[957,"bitcoin::blockdata::block"],[958,"bitcoin::blockdata::transaction"],[959,"bitcoin_units::amount"],[960,"miniscript::descriptor::key"],[961,"miniscript::descriptor"],[962,"bitcoin::network"],[963,"serde::de"],[964,"bitcoin::blockdata::script::owned"],[965,"core::option"],[966,"core::result"],[967,"core::future::future"],[968,"alloc::boxed"],[969,"core::pin"],[970,"core::borrow"],[971,"core::fmt"],[972,"bitcoin_hashes"],[973,"bdk_chain::chain_oracle"],[974,"core::hash"],[975,"core::slice::index"],[976,"fallible_iterator"],[977,"core::iter::traits::iterator"],[978,"core::ops::range"],[979,"serde::ser"],[980,"rusqlite::types::to_sql"],[981,"rusqlite"],[982,"alloc::string"],[983,"core::any"],[984,"core::iter::traits::collect"],[985,"core::default"],[986,"alloc::collections::btree::map"],[987,"rusqlite::transaction"],[988,"core::iter::traits::double_ended"],[989,"core::iter::traits::exact_size"],[990,"alloc::collections::btree::set"],[991,"alloc::vec"],[992,"core::marker"],[993,"core::ops::function"],[994,"bitcoin::blockdata::script::borrowed"],[995,"core::convert"],[996,"alloc::sync"],[997,"std::collections::hash::set"]],"i":[0,0,0,0,0,0,0,0,75,0,0,12,14,40,45,40,45,0,0,63,0,0,0,0,0,0,40,45,40,45,0,0,40,45,0,0,0,0,0,12,14,1,2,3,5,6,2,2,2,2,0,6,22,1,12,14,5,6,15,20,2,2,16,22,1,12,14,5,6,15,20,2,16,15,1,12,14,5,6,15,2,16,1,12,14,5,6,15,2,16,12,12,14,5,6,15,20,2,22,22,22,22,22,22,22,22,22,3,3,12,6,6,1,40,45,20,20,1,5,6,22,20,20,16,47,1,14,5,6,2,47,2,1,12,14,5,6,15,20,2,1,1,12,12,14,14,5,5,6,6,15,15,20,20,2,2,1,1,12,14,5,6,15,20,2,2,2,2,22,22,22,1,12,14,14,5,5,5,6,15,20,2,2,16,59,5,6,2,2,2,2,2,2,63,12,14,5,6,2,5,5,1,2,0,0,22,1,12,14,5,6,15,20,2,16,16,16,63,12,14,15,70,15,15,0,40,45,20,20,0,70,0,16,16,16,16,15,12,14,5,6,15,20,2,40,45,20,20,0,0,0,1,14,5,6,2,15,0,0,75,70,70,2,1,12,14,5,6,15,2,16,2,22,22,22,22,22,22,22,22,22,1,2,1,16,1,1,22,1,12,14,5,6,15,20,2,16,22,1,12,14,5,6,15,20,2,16,0,15,22,1,12,14,5,6,15,20,2,16,14,1,22,1,12,14,5,6,15,20,2,16,131,132,131,0,0,82,82,82,82,82,82,82,82,82,83,82,83,83,83,82,83,83,83,82,83,82,83,83,83,82,82,83,82,82,82,82,82,82,83,83,83,82,83,83,82,83,82,83,83,82,83,82,83,84,0,84,84,84,84,84,0,0,0,0,95,0,95,0,90,90,93,93,93,93,95,90,93,95,90,93,95,90,93,95,90,93,90,90,95,90,93,95,95,90,93,95,90,90,93,93,93,93,93,93,93,93,95,90,90,93,93,93,93,93,90,93,93,93,93,93,93,93,90,93,93,93,93,93,90,93,93,93,93,93,93,90,93,93,95,90,95,93,95,90,93,95,90,93,93,93,93,95,90,93,93,93,93,93,95,90,133,133,134,134,0,97,97,97,97,97,97,97,97,97,97,97,97,97,97,97,97,97,97,97,97,97,97,97,97,97,97,97,97,97,97,97,97,97,97,97,97,0,0,106,110,0,0,0,0,110,0,0,106,105,105,105,105,111,106,113,111,105,106,107,112,109,110,113,111,105,106,107,112,109,110,111,105,106,107,112,109,110,111,105,106,107,112,109,110,106,106,105,111,105,106,107,112,109,110,111,111,105,106,107,107,112,112,109,109,110,110,113,111,105,106,106,107,112,109,110,111,105,105,105,111,106,106,106,105,105,111,105,105,111,111,112,105,111,105,113,111,105,106,107,112,109,110,113,113,111,105,106,111,105,106,111,113,112,106,111,111,111,105,106,105,111,105,106,107,112,109,110,107,112,109,110,113,113,111,105,106,107,112,109,110,109,113,111,105,106,107,112,109,110,113,111,105,106,107,112,109,110,112,113,111,105,106,107,112,109,110,0,0,0,0,0,0,114,135,117,136,114,135,117,136,114,114,117,114,117,114,135,136,114,135,117,136,114,117,117,135,136,114,114,117,117,114,114,135,117,136,136,114,114,114,114,117,114,114,117,114,135,117,136,114,135,117,136,114,114,135,117,136,114,135,117,136,89,0,0,0,123,123,89,89,89,0,0,0,0,85,85,89,124,89,85,85,85,85,85,128,129,85,124,125,123,89,128,129,85,124,125,123,89,85,125,128,128,129,129,85,124,125,89,85,124,125,89,124,125,85,89,124,89,85,85,124,125,123,89,124,124,125,125,123,123,85,85,85,85,124,125,123,123,89,128,129,85,124,125,123,89,89,85,85,85,85,85,85,85,85,85,85,85,128,129,85,124,125,123,89,128,129,128,129,85,89,89,124,85,85,89,89,85,128,129,85,124,125,89,89,85,124,125,89,123,128,129,85,85,85,128,129,85,124,125,123,89,85,85,128,129,85,124,125,123,89,85,124,125,85,85,124,89,89,89,85,128,129,85,124,125,123,89,85,128,129,85,124,125,123,89,85,85,85],"f":"`````````````````````````````````````````{{bb}b}{{}d}{{{h{f}}}j}{{{h{j}}}j}{{{h{l}}}j}{{{h{d}}}{{h{c}}}{}}{{{h{d}}}{{h{n}}}}{{{h{d}}}{{h{{Ab{A`}}}}}}{{{h{d}}}{{h{{Ad{A`}}}}}}``{{{h{c}}}{{h{e}}}{}{}}0000000100{{{h{Afc}}}{{h{Afe}}}{}{}}000000000`{{{h{b}}}b}{{{h{{Ah{c}}}}}{{Ah{c}}}Aj}{{{h{Al}}}Al}:{{{h{l}}}l}{{{h{{An{c}}}}}{{An{c}}}Aj}{{{h{d}}}d}{{{h{{B`{c}}}}}{{B`{c}}}Aj}{{{h{c}}{h{Afe}}}Bb{}{}}0000000{{{Ah{{h{c}}}}}{{Ah{c}}}Aj}{{{h{{Ah{c}}}}{h{{Ah{c}}}}}BdBf}{{{h{Al}}{h{Al}}}Bd}{{{h{j}}{h{j}}}Bd}{{{h{l}}{h{l}}}Bd}{{{h{{An{c}}}}{h{{An{c}}}}}BdBf}{{{h{{Bh{c}}}}{h{{Bh{c}}}}}BdBf}{{{h{d}}{h{d}}}Bd}{Bj{{Bn{{Bl{d}}}}}}{Bj{{Bn{{Bl{C`}}}}}}{Bj{{Bn{{Bl{Cb}}}}}}{Bj{{Bn{{Bl{Cd}}}}}}{Bj{{Bn{{Bl{{Ch{Cf}}}}}}}}{Bj{{Bn{{Bl{Cj}}}}}}{Bj{{Bn{{Bl{c}}}}}{fCl}}{Bj{{Bn{{Bl{Cn}}}}}}{Bj{{Bn{{Bl{D`}}}}}}{{{h{f}}}Db}0{{{h{{Ah{c}}}}}{{Dd{Db}}}f}{{{h{l}}}Db}``{{{h{Afc}}e}{{Eb{{E`{}{{Df{e}}{Dh{g}}{Dj{i}}{Dl{k}}{Dn{m}}}}i}}}{}{}{}{}{}{}}{{{h{Afc}}e}{{Eh{{Ef{Ed}}}}}{}{}}{{{h{Afc}}}{{Eb{{Bh{e}}}}}{}{{E`{c}}}}{{{h{Afc}}}{{Eb{{Bh{e}}}}}{}{{Ej{c}}}}{{}b}{{}j}{{}l}{{{h{{Bl{c}}}}}{{h{e}}}{}{}}{{{h{{Bh{c}}}}}{{h{e}}}{}{}}{{{h{Af{Bh{c}}}}}{{h{Afe}}}{}{}}{{{h{{B`{c}}}}}{{h{c}}}{{El{{Ch{Cf}}}}}}{{{h{En}}}d}{c{{Eb{b}}}F`}{c{{Eb{Al}}}F`}{c{{Eb{j}}}F`}{c{{Eb{l}}}F`}{c{{Eb{d}}}F`}{{{h{En}}}Fb}{{}c{}}{{{h{b}}{h{b}}}Fd}{{{h{{Ah{c}}}}{h{{Ah{c}}}}}FdFf}{{{h{Al}}{h{Al}}}Fd}{{{h{j}}{h{j}}}Fd}{{{h{l}}{h{l}}}Fd}{{{h{{An{c}}}}{h{{An{c}}}}}FdFf}{{{h{{Bh{c}}}}{h{{Bh{c}}}}}FdFf}{{{h{d}}{h{d}}}Fd}{{{h{c}}{h{e}}}Fd{}{}}000000000000000{{{h{b}}{h{AfFh}}}Fj}0{{{h{{Ah{c}}}}{h{AfFh}}}FjFl}{{{h{Al}}{h{AfFh}}}Fj}{{{h{j}}{h{AfFh}}}Fj}{{{h{l}}{h{AfFh}}}Fj}{{{h{{An{c}}}}{h{AfFh}}}FjFl}{{{h{{Bh{c}}}}{h{AfFh}}}FjFl}{{{h{d}}{h{AfFh}}}Fj}000{Fnc{}}{cc{}}{c{{Bl{c}}}{}}111{{{Ah{l}}}Al}{{{G`{{h{Db}}{h{C`}}}}}j}3{{{G`{DbC`}}}j}444{nd}55{{{h{Gb}}jGd}Gf}{{{h{Gb}}jGd}j}{{{h{Gb}}jGd}l}{cd{}}04{{{h{{Ad{A`}}}}}{{Eb{dGh}}}}0{{{h{Gj}}}{{Eb{dc}}}{}}{{{h{{Gn{}{{Gl{c}}}}}}}{{Eb{jc}}}Fl}{{{h{{Ah{c}}}}{h{Afe}}}BbH`Hb}{{{h{Al}}{h{Afc}}}BbHb}{{{h{j}}{h{Afc}}}BbHb}{{{h{l}}{h{Afc}}}BbHb}{{{h{d}}{h{Afc}}}BbHb}```{{{h{d}}c}{{h{e}}}{{Hd{{Ad{A`}}}}}{}}``{ce{}{}}000000000{c{{Hf{g}}}{}{}{{Hj{}{{Hh{e}}}}}}1{{{h{{Gn{}{{Gl{c}}}}}}jj}{{Eb{{Dd{Fd}}c}}}Fl}{{{h{{Ah{c}}}}}Fd{}}{{{h{Al}}}Fd}{{{h{{An{c}}}}Db}Fdf}{{{h{Hl}}}Fd}1``{{{h{Afc}}e}{{Eb{{Dd{{E`{}{{Df{g}}{Dh{e}}{Dj{i}}{Dl{k}}{Dn{m}}}}}}k}}}{}{}{}{}{}{}}{{{h{Afc}}e}{{Eh{{Ef{Ed}}}}}{}{}}{{{h{Afc}}}{{Eb{{Dd{{Bh{e}}}}}}}{}{{E`{c}}}}{{{h{Afc}}}{{Eb{{Dd{{Bh{e}}}}}}}{}{{Ej{c}}}}`{{{h{AfHl}}Hl}Bb}`{c{{B`{c}}}{{El{{Ch{Cf}}}}}}{{ce}{{B`{c}}}{{El{{Ch{Cf}}}}}{{Hn{Db}}}}{{{h{Af{B`{c}}}}}{{Dd{e}}}{{El{{Ch{Cf}}}}}{}}{{{h{Af{B`{c}}}}Gd}{{Dd{e}}}{{El{{Ch{Cf}}}}}{}}`{{{h{{Ah{c}}}}{h{{Ah{c}}}}}{{Dd{Bd}}}I`}{{{h{Al}}{h{Al}}}{{Dd{Bd}}}}{{{h{j}}{h{j}}}{{Dd{Bd}}}}{{{h{l}}{h{l}}}{{Dd{Bd}}}}{{{h{{An{c}}}}{h{{An{c}}}}}{{Dd{Bd}}}I`}{{{h{{Bh{c}}}}{h{{Bh{c}}}}}{{Dd{Bd}}}I`}{{{h{d}}{h{d}}}{{Dd{Bd}}}}{{{h{Afc}}{h{e}}}{{Eb{Bbg}}}{}{}{}}{{{h{Afc}}{h{e}}}{{Eh{{Ef{Ed}}}}}{}{}}{{{h{Af{Bh{e}}}}{h{Afc}}}{{Eb{Fd}}}{}{{E`{c}}}}{{{h{Af{Bh{e}}}}{h{Afc}}}{{Eb{Fd}}}{}{{Ej{c}}}}```{{{h{b}}c}EbIb}{{{h{Al}}c}EbIb}{{{h{j}}c}EbIb}{{{h{l}}c}EbIb}{{{h{d}}c}EbIb}```{{{h{Af{If{}{{Id{c}}}}}}}{{h{Afc}}}Hl}{{{h{AfHl}}}{{Dd{Hl}}}}0{dc{}}{{{h{c}}}e{}{}}0000000{dn}{{{h{{Bl{Cd}}}}}{{Ij{Ih}}}}{{{h{{Bl{Cb}}}}}{{Ij{Ih}}}}{{{h{{Bl{Cn}}}}}{{Ij{Ih}}}}{{{h{{Bl{c}}}}}{{Ij{Ih}}}{fIl}}{{{h{{Bl{Cj}}}}}{{Ij{Ih}}}}{{{h{{Bl{D`}}}}}{{Ij{Ih}}}}{{{h{{Bl{{Ch{Cf}}}}}}}{{Ij{Ih}}}}{{{h{{Bl{C`}}}}}{{Ij{Ih}}}}{{{h{{Bl{d}}}}}{{Ij{Ih}}}}{{{h{c}}}In{}}0{{{h{b}}}Cd}{c{{J`{i}}}{}{}{}{{Hj{}{{Hh{{Eb{eg}}}}}}}}`1{c{{Eb{e}}}{}{}}0000000000000000000``{{{h{c}}}Jb{}}000000000{FbAl}`{ce{}{}}000000000`````{{{h{Af{Jd{ce}}}}GbDb}{{Jf{c}}}{Gff}Jh}{{{h{Af{Jd{ce}}}}{h{Gb}}Db}{{Jf{c}}}{Gff}Jh}{{{h{Af{Jd{ce}}}}{Jf{c}}}BbfJh}{{{h{Af{Jd{ce}}}}{Jj{c}}}{{Jf{c}}}fJh}{{{h{{Jd{ce}}}}}{{h{{Jj{c}}}}}{}{}}{{{h{Af{Jd{ce}}}}i}{{Jf{c}}}fJh{{Jl{}{{Hh{c}}}}}{{Jl{}{{Hh{{G`{{h{Cn}}g}}}}}}}}{{{h{Af{Jd{ce}}}}g}{{Jf{c}}}fJh{{Jl{}{{Hh{{G`{{h{Cn}}Fb}}}}}}}}{{{h{Af{Jd{ce}}}}g}{{Jf{c}}}fJh{{Jl{}{{Hh{{G`{CnFb}}}}}}}}{{{h{c}}}{{h{e}}}{}{}}0{{{h{Afc}}}{{h{Afe}}}{}{}}0{{{h{{Jf{ce}}}}}{{Jf{ce}}}AjAj}{{{h{c}}{h{Afe}}}Bb{}{}}{{}{{Jd{ce}}}{}Jn}{{}{{Jf{ce}}}{}Jn}{c{{Eb{{Jf{eg}}}}}F`{BfK`}K`}{{{h{{Jf{ce}}}}{h{{Jf{ce}}}}}FdFfFf}{{{h{{Jd{ce}}}}{h{AfFh}}}FjFlFl}{{{h{{Jf{ce}}}}{h{AfFh}}}FjFlFl}{cc{}}{{{Kb{c}}}{{Jf{ce}}}{}Jn}{Kd{{Jf{cKd}}}{}}2{{{h{{Jd{ce}}}}}{{h{{Jj{c}}}}}{}{}}``{{{h{{Jd{ce}}}}}{{Jf{c}}}fJh}{{{h{Af{Jd{ce}}}}Cbc}{{Jf{c}}}fJh}{{{h{Af{Jd{ce}}}}CbFb}{{Jf{c}}}fJh}{{{h{Af{Jd{ce}}}}Cn}{{Jf{c}}}fJh}{{{h{Af{Jd{ce}}}}KfKh}{{Jf{c}}}fJh}{ce{}{}}0{{{h{{Jf{ce}}}}}FdfHl}{{{h{Af{Jf{ce}}}}{Jf{ce}}}BbfHl}{c{{Jd{ec}}}{}{}}{{{h{{Jf{ce}}}}g}Eb{BfIl}IlIb}{{{h{c}}}e{}{}}{c{{Eb{e}}}{}{}}000`{{{h{c}}}Jb{}}077``{{{h{Af{Jh{}{{Id{c}}}}}}c}Bb{}}{{{h{Af{Jh{}{{Id{c}}}}}}{h{Cn}}}c{}}{{{h{Af{Jh{}{{Id{c}}}}}}Kf{h{Kh}}}c{}}{{{h{{Jh{}{{Id{c}}}}}}}c{}}{{{h{{Jh{}{{Id{c}}}}}}{h{Cn}}}Fd{}}``````````{{{h{{Kj{c}}}}}{{Kl{c{B`{{Ch{Cf}}}}}}}{AjBfFl}}{{{h{Af{Kj{c}}}}Kd}Bb{AjBfFl}}{{{h{Af{Kj{c}}}}e}Bb{AjBfFl}{}}{{{h{c}}}{{h{e}}}{}{}}00{{{h{Afc}}}{{h{Afe}}}{}{}}00{{{h{{Kj{c}}}}}{{Kj{c}}}Aj}{{{h{{Kn{c}}}}}{{Kn{c}}}Aj}{{{h{Kd}}}Kd}{{{h{c}}{h{Afe}}}Bb{}{}}00{{}{{Kj{c}}}{}}{{}Kd}{c{{Eb{Kd}}}F`}{{{h{{Kn{c}}}}{h{{Kn{c}}}}}FdFf}{{{h{Kd}}{h{Kd}}}Fd}{{{h{{Kj{c}}}}{h{AfFh}}}FjFl}{{{h{{Kn{c}}}}{h{AfFh}}}FjFl}0{{{h{Kd}}{h{AfFh}}}Fj}{cc{}}00{{{h{L`}}}{{Ij{Kd}}}}{{{h{{Kj{c}}}}c}{{Dd{{h{{Ch{Cf}}}}}}}{AjBfFl}}{{{h{{Kj{c}}}}D`}{{Dd{{h{{G`{cDb}}}}}}}{AjBfFl}}{{{h{Af{Kj{c}}}}{h{Cn}}}e{AjBfFl}{}}{{{h{Af{Kj{c}}}}Kf{h{Kh}}}e{AjBfFl}{}}{{{h{{Kj{c}}}}}e{AjBfFl}{}}{{{h{{Kj{c}}}}}{{h{{Lb{{G`{cDb}}}}}}}{AjBfFl}}{{{h{Af{Kj{c}}}}c{Ch{Cf}}}{{Eb{Fd{Kn{c}}}}}{AjBfFl}}{ce{}{}}00{{{h{Kd}}}Fd}{{{h{{Kj{c}}}}{h{Cn}}}Fd{AjBfFl}}{{{h{{Kj{c}}}}cDb}Fd{AjBfFl}}{{{h{{Kj{c}}}}c}{{`{{Lf{}{{Hh{{Ld{Kf}}}}}}}}}{AjBfFl}}{{{h{{Kj{c}}}}e}{{`{{Lf{}{{Hh{{Lh{cKf}}}}}}}}}{AjBfFl}{{Hn{c}}}}{{{h{{Kj{c}}}}}{{`{{Lf{}{{Hh{{G`{c{h{{Ch{Cf}}}}}}}}}}Lj}}}{AjBfFl}}`{{{h{{Kj{c}}}}c}{{Dd{Db}}}{AjBfFl}}{{{h{{Kj{c}}}}}{{Kl{cDb}}}{AjBfFl}}10{{{h{{Kj{c}}}}}Db{AjBfFl}}{{{h{Af{Kj{c}}}}cDb}Bb{AjBfFl}}{{{h{Af{Kj{c}}}}cDb}Fd{AjBfFl}}{{{h{AfKd}}Kd}Bb}{{{h{{Kj{c}}}}{h{Cn}}e}Ll{AjBfFl}{{Hn{c}}}}{Db{{Kj{c}}}{}}{{{h{{Kj{c}}}}c}{{Dd{{G`{DbFd}}}}}{AjBfFl}}{{{h{Af{Kj{c}}}}c}{{Dd{{G`{{Ld{D`}}Kd}}}}}{AjBfFl}}{{{h{{Kj{c}}}}}{{h{{Ln{{Lh{cKf}}}}}}}{AjBfFl}}{{{h{Kd}}{h{L`}}}{{Ij{Bb}}}}2{{{h{Af{Kj{c}}}}cDb}{{Dd{{G`{{M`{{Ld{D`}}}}Kd}}}}}{AjBfFl}}{{{h{Af{Kj{c}}}}{h{{Kl{cDb}}}}}Kd{AjBfFl}}{{{h{{Kj{c}}}}c}{{`{{Lf{}{{Hh{{Ld{D`}}}}}}}}}{AjBfFl}}{{{h{{Kj{c}}}}e}{{`{{Hj{}{{Hh{{Lh{cD`}}}}}}}}}{AjBfFl}{{Hn{c}}}}{{{h{{Kj{c}}}}{h{Cn}}e}{{G`{CdCd}}}{AjBfFl}{{Hn{c}}}}{{{h{Kd}}c}EbIb}{{{h{{Kj{c}}}}cDb}{{Dd{D`}}}{AjBfFl}}{{{h{c}}}e{}{}}00{{{h{c}}}In{}}{c{{Eb{e}}}{}{}}00000{{{h{{Kj{c}}}}Kf}{{Dd{{Lh{c{h{Kh}}}}}}}{AjBfFl}}{{{h{{Kj{c}}}}}{{`{{Lf{}{{Hh{{Lh{c{G`{Kf{h{Kh}}}}}}}}}}Lj}}}{AjBfFl}}{{{h{{Kj{c}}}}Cb}{{`{{Lf{}{{Hh{{Lh{c{G`{Kf{h{Kh}}}}}}}}}}}}}{AjBfFl}}{{{h{c}}}Jb{}}00{{{h{{Kj{c}}}}c}{{Dd{{B`{{Ch{Cf}}}}}}}{AjBfFl}}{{{h{Af{Kj{c}}}}cDb}Fd{AjBfFl}}{{{h{{Kj{c}}}}c}{{`{{Lf{}{{Hh{{Ld{D`}}}}}}Aj}}}{AjBfFl}}{{{h{{Kj{c}}}}}{{`{{Lf{}{{Hh{{Lh{cD`}}}}}}Aj}}}{AjBfFl}}{ce{}{}}00`````{{{h{{Lb{c}}}}}{{h{{Kl{cD`}}}}}{AjBfFl}}{{{h{Af{Lb{c}}}}e}Bb{AjBfFl}{}}{{{h{c}}}{{h{e}}}{}{}}{{{h{Afc}}}{{h{Afe}}}{}{}}{{{h{{Lb{c}}}}}{{Lb{c}}}Aj}{{{h{c}}{h{Afe}}}Bb{}{}}{{}{{Lb{c}}}{}}{{{h{{Lb{c}}}}{h{AfFh}}}FjFl}{cc{}}{{{h{{Lb{c}}}}D`}{{Dd{{h{c}}}}}{AjBfFl}}{{{h{Af{Lb{c}}}}{h{Cn}}}e{AjBfFl}{}}{{{h{Af{Lb{c}}}}Kf{h{Kh}}}e{AjBfFl}{}}{{{h{{Lb{c}}}}}e{AjBfFl}{}}{{{h{Af{Lb{c}}}}cD`}Fd{AjBfFl}}>{{{h{{Lb{c}}}}{h{Cn}}}Fd{AjBfFl}}0{{{h{{Lb{c}}}}{h{c}}}Fd{AjBfFl}}{{{h{Af{Lb{c}}}}{h{c}}}Fd{AjBfFl}}{{{h{{Lb{c}}}}{h{Cn}}e}Ll{AjBfFl}{{Hn{c}}}}{{{h{{Lb{c}}}}}{{h{{Ln{{G`{cKf}}}}}}}{AjBfFl}}{{{h{{Lb{c}}}}e}{{`{{Lf{}{{Hh{{G`{{h{c}}Kf}}}}}}}}}{AjBfFl}{{Hn{c}}}}{{{h{Af{Lb{c}}}}{h{Cn}}}{{Ln{c}}}{AjBfFl}}{{{h{Af{Lb{c}}}}Kf{h{Kh}}}{{Dd{{h{c}}}}}{AjBfFl}}{{{h{{Lb{c}}}}{h{Cn}}e}{{G`{CdCd}}}{AjBfFl}{{Hn{c}}}}{{{h{{Lb{c}}}}{h{c}}}{{Dd{D`}}}{AjBfFl}}{{{h{c}}}e{}{}}{c{{Eb{e}}}{}{}}0{{{h{{Lb{c}}}}Kf}{{Dd{{G`{{h{c}}{h{Kh}}}}}}}{AjBfFl}}{{{h{{Lb{c}}}}}{{`{{Lf{}{{Hh{{G`{{h{c}}Kf{h{Kh}}}}}}}}Lj}}}{AjBfFl}}{{{h{{Lb{c}}}}Cb}{{`{{Lf{}{{Hh{{G`{{h{c}}Kf{h{Kh}}}}}}}}}}}{AjBfFl}}{{{h{c}}}Jb{}}={{{h{{Lb{c}}}}e}{{`{{Lf{}{{Hh{{G`{{h{c}}D`}}}}}}Aj}}}{AjBfFl}{{Hn{c}}}}{ce{}{}}````````````{{{h{AfMb}}{h{Md}}}{{Eb{BbMf}}}}{{{h{AfMb}}{h{Mh}}Db}{{Eb{MdMj}}}}{{{h{AfMb}}{h{Mh}}Dbj}{{Eb{MdMl}}}}{{{h{AfMb}}Mn}{{Eb{MdMj}}}}{{{h{Mn}}}j}`{{{h{c}}}{{h{e}}}{}{}}0000000{{{h{Afc}}}{{h{Afe}}}{}{}}0000000{{{h{Mn}}}Mn}{{{h{Mb}}}Mb}{{{h{Md}}}Md}{{{h{Mf}}}Mf}{{{h{N`}}}N`}{{{h{Mj}}}Mj}{{{h{Ml}}}Ml}{{{h{c}}{h{Afe}}}Bb{}{}}000000{{}Md}{c{{Eb{Md}}}F`}{{{h{AfMb}}j}{{Eb{MdMf}}}}{{{h{Mn}}{h{Mn}}}Fd}{{{h{Mb}}{h{Mb}}}Fd}{{{h{Md}}{h{Md}}}Fd}{{{h{Mf}}{h{Mf}}}Fd}{{{h{N`}}{h{N`}}}Fd}{{{h{Mj}}{h{Mj}}}Fd}{{{h{Ml}}{h{Ml}}}Fd}{{Mnc}{{Eb{MnMn}}}{{Jl{}{{Hh{j}}}}}}{{{h{Mn}}{h{AfFh}}}Fj}{{{h{Mb}}{h{AfFh}}}Fj}{{{h{Md}}{h{AfFh}}}Fj}{{{h{Mf}}{h{AfFh}}}Fj}0{{{h{N`}}{h{AfFh}}}Fj}0{{{h{Mj}}{h{AfFh}}}Fj}0{{{h{Ml}}{h{AfFh}}}Fj}0{cc{}}000{cMd{{Jl{}{{Hh{{G`{Db{Dd{C`}}}}}}}}}}1111{c{{Eb{Mn{Dd{Mn}}}}}{{Jl{}{{Hh{j}}}}}}{{{Kl{DbC`}}}{{Eb{MbMf}}}}{Md{{Eb{MbMf}}}}{C`{{G`{MbMd}}}}{{{h{Mh}}Db}Mn}{cMd{{Jl{}{{Hh{{G`{DbC`}}}}}}}}6{{{h{L`}}}{{Ij{Md}}}}{Mn{{Eb{MbMf}}}}{{{h{Mb}}}C`}{{{h{Mn}}Db}{{Dd{Mn}}}}{{{h{Mb}}Db}{{Dd{Mn}}}}{{{h{Mb}}}{{Eb{jc}}}{}}{{{h{Mn}}}C`}{{{h{Mn}}}Db}`{{{h{Mb}}}Md}{{Mnj}Mn}{{{h{AfMb}}j}{{Eb{MdN`}}}}{ce{}{}}0000000{c{{Hf{g}}}{}{}{{Hj{}{{Hh{e}}}}}}1{Mnc{}}{{{h{Mb}}jj}{{Eb{{Dd{Fd}}c}}}{}}{{{h{Md}}}Fd}{{{h{Mn}}}Nb}{{{h{Mb}}}Nb}{{{h{AfMd}}Md}Bb}{jMn}{{{h{AfNb}}}{{Dd{c}}}{}}`{{{h{Md}}{h{L`}}}{{Ij{Bb}}}}{{{h{Mn}}}{{Dd{Mn}}}}{{Mnj}{{Eb{MnMn}}}}{{{h{Mn}}c}{{`{{Hj{}{{Hh{Mn}}}}}}}{{Hn{Db}}}}{{{h{Mb}}c}{{`{{Hj{}{{Hh{Mn}}}}}}}{{Hn{Db}}}}{{{h{Md}}c}EbIb}{{{h{Mb}}}Mn}{{{h{c}}}e{}{}}000000{{{h{c}}}In{}}000{c{{J`{i}}}{}{}{}{{Hj{}{{Hh{{Eb{eg}}}}}}}}{c{{Eb{e}}}{}{}}0000000`00000000{{{h{c}}}Jb{}}0000000`{ce{}{}}0000000`{{{h{L`}}{h{Gj}}{h{{Ad{{h{{Ad{{h{Gj}}}}}}}}}}}{{Ij{Bb}}}}````{{{h{c}}}{{h{e}}}{}{}}000{{{h{Afc}}}{{h{Afe}}}{}{}}000{{Nde}Nd{{Lj{}{{Hh{Kf}}}}Nf}{{Jl{}{{Nh{c}}{Hh{Kf}}}}}}{{Nde}Nd{{Lj{}{{Hh{D`}}}}Nf}{{Jl{}{{Nh{c}}{Hh{D`}}}}}}{{{Nj{c}}cg}{{Nj{c}}}{BfAj}{{Hj{}{{Hh{{Ld{D`}}}}}}Nf}{{Jl{}{{Nh{e}}}}}}``{{Nde}Nd{{Lj{}{{Hh{Cb}}}}Nf}{{Jl{}{{Nh{c}}{Hh{Cb}}}}}}``{cc{}}000{MnNd}{Mn{{Nj{c}}}{BfAj}}{{Mn{h{{Kj{c}}}}}{{Nj{c}}}{FlBfAj}}``{{Ndc}Nd{{Nl{{h{Kf}}}}NfNn}}{{Ndc}Nd{{Nl{{h{O`}}}}NfNn}}{{{Nj{c}}e}{{Nj{c}}}{NfBfAj}{{Nl{cDb{h{O`}}}}NfNnAj}}{{{Nj{c}}ce}{{Nj{c}}}{NfBfAj}{{Nl{Db{h{O`}}}}NfNn}}{{Ndc}Nd{{Nl{{h{Cb}}}}NfNn}}{ce{}{}}000``{{Nd{h{{Kj{c}}}}e}Nd{AjBfFlNfNn}{{Hn{c}}}}{{Nde}Nd{{Lj{}{{Hh{Kf}}}}Nf}{{Jl{}{{Nh{c}}}}}}{{Nde}Nd{{Lj{}{{Hh{D`}}}}Nf}{{Jl{}{{Nh{c}}}}}}>{{Nde}Nd{{Lj{}{{Hh{Cb}}}}Nf}{{Jl{}{{Nh{c}}}}}}``{c{{Eb{e}}}{}{}}0000000`{{{h{c}}}Jb{}}0006666`````````````{{{h{{Jj{c}}}}}{{h{{Ln{{G`{cCb}}}}}}}{}}{{{h{{Jj{c}}}}}{{`{{Hj{}{{Hh{{G`{Kf{h{Kh}}}}}}}}}}}{}}{{{h{{Kb{c}}}}}{{`{{Hj{}{{Hh{Db}}}}}}}f}``{{{h{Af{Jj{c}}}}{Kb{c}}}Bb{AjBf}}{{{h{Af{Jj{c}}}}{Jj{c}}}{{Kb{c}}}{AjBf}}{{{h{{Jj{c}}}}}{{h{{Jj{c}}}}}{}}{{{h{{Jj{c}}}}{h{e}}jik}bf{{Gn{}{{Gl{Ob}}}}}Aj{{Jl{}{{Hh{{G`{gKf}}}}}}}{{Nl{{h{g}}D`}{{Od{Fd}}}}}}{{{h{Af{Jj{c}}}}e}{{Kb{c}}}{AjBf}{{Jl{}{{Hh{{G`{CnFb}}}}}}}}{{{h{c}}}{{h{e}}}{}{}}000000{{{h{Afc}}}{{h{Afe}}}{}{}}000000{{{h{{Jj{c}}}}{h{Cn}}}{{Eb{CdOf}}}{}}`{c{{Dd{Cd}}}{}}{c{{Dd{Ll}}}{}}01{{{h{{Jj{c}}}}}{{Jj{c}}}Aj}{{{h{{Oh{ce}}}}}{{Oh{ce}}}AjAj}{{{h{{Oj{ce}}}}}{{Oj{ce}}}AjAj}{{{h{{Kb{c}}}}}{{Kb{c}}}Aj}{{{h{c}}{h{Afe}}}Bb{}{}}000{{{h{{Oh{ce}}}}{h{{Oh{ce}}}}}BdBfBf}{{{h{{Oj{ce}}}}{h{{Oj{ce}}}}}BdBfBf}{{}{{Jj{c}}}{}}{{}{{Kb{c}}}{}}{{{h{{Oh{ce}}}}}{{h{g}}}{}{}{}}{c{{Eb{{Kb{e}}}}}F`{BfK`}}{{{h{{Jj{c}}}}{h{Cn}}}{{`{{Hj{}{{Hh{{G`{GdCb}}}}}}}}}{}}{{{h{{Jj{c}}}}{h{{Jj{c}}}}}FdFf}{{{h{{Oh{ce}}}}{h{{Oh{ce}}}}}FdFfFf}{{{h{{Oj{ce}}}}{h{{Oj{ce}}}}}FdFfFf}{{{h{Of}}{h{Of}}}Fd}{{{h{{Kb{c}}}}{h{{Kb{c}}}}}FdFf}{{{h{c}}{h{e}}}Fd{}{}}00000{{{h{{Jj{c}}}}{h{e}}ji}{{`{{Hj{}{{Hh{{G`{g{An{c}}}}}}}}}}}f{{Gn{}{{Gl{Ob}}}}}Aj{{Jl{}{{Hh{{G`{gKf}}}}}}}}0{{{h{{Jj{c}}}}}{{`{{Hj{}{{Hh{{G`{Kf{h{Kh}}}}}}}}}}}{}}{{{h{{Jj{c}}}}{h{AfFh}}}FjFl}{{{h{{Oh{ce}}}}{h{AfFh}}}FjFlFl}{{{h{{Oj{ce}}}}{h{AfFh}}}FjFlFl}{{{h{Of}}{h{AfFh}}}Fj}0{{{h{{Kb{c}}}}{h{AfFh}}}FjFl}{cc{}}000000{{{h{L`}}}{{Ij{{Kb{c}}}}}{fAjBfIlCl}}{{{h{{Jj{c}}}}}{{`{{Hj{}{{Hh{{Oh{{Ol{Cn}}c}}}}}}}}}{}}{{{h{{Jj{c}}}}{h{e}}jCb}{{Dd{{Ah{{h{c}}}}}}}f{{Gn{}{{Gl{Ob}}}}}}{{{h{{Jj{c}}}}{h{e}}jKf}{{Dd{{G`{{Ah{{h{c}}}}Cb}}}}}f{{Gn{}{{Gl{Ob}}}}}}{{{h{{Jj{c}}}}Cb}{{Dd{{Ol{Cn}}}}}{}}{{{h{{Jj{c}}}}Cb}{{Dd{{Oh{{Ol{Cn}}c}}}}}{}}{{{h{{Jj{c}}}}Kf}{{Dd{{h{Kh}}}}}{}}{{{h{{Jj{c}}}}}{{Kb{c}}}{AjBf}}{{{h{Af{Jj{c}}}}Cbc}{{Kb{c}}}{AjBf}}{{{h{Af{Jj{c}}}}CbFb}{{Kb{c}}}{AjBf}}{{{h{Af{Jj{c}}}}e}{{Kb{c}}}{AjBf}{{On{{Ol{Cn}}}}}}{{{h{Af{Jj{c}}}}KfKh}{{Kb{c}}}{AjBf}}{ce{}{}}000000{c{{Hf{g}}}{}{}{{Hj{}{{Hh{e}}}}}}011{{{h{{Jj{c}}}}}Fd{}}{{{h{{Kb{c}}}}}FdBf}``{{{h{{Jj{c}}}}{h{e}}j}{{`{{Hj{}{{Hh{{Oj{{Ol{Cn}}c}}}}}}}}}fGn}{{{Jj{c}}g}{{Jj{e}}}{AjBf}{AjBf}{{Nl{c}{{Od{e}}}}}}{{{Kb{c}}g}{{Kb{e}}}BfBf{{Nl{c}{{Od{e}}}}}}{{{h{Af{Kb{c}}}}{Kb{c}}}BbBf}{c{{Jj{e}}}{{Jl{}{{Hh{Cn}}}}}{AjBf}}{{{h{Af{A@`{cg}}}}}{{Dd{i}}}{}{}{{Nl{Gd{Ol{Cn}}}{{Od{{Dd{e}}}}}}}{}}{{{h{Af{A@b{cg}}}}}{{Dd{i}}}{}{}{{Nl{GdCb}{{Od{{Dd{e}}}}}}}{}}{{{h{{Jj{c}}}}Kf}{{h{{A@d{Cb}}}}}{}}{{{h{{Oh{ce}}}}{h{{Oh{ce}}}}}{{Dd{Bd}}}I`I`}{{{h{{Oj{ce}}}}{h{{Oj{ce}}}}}{{Dd{Bd}}}I`I`}{{{h{{Kb{c}}}}{h{L`}}}{{Ij{Bb}}}{fAjBfIlCl}}{{{h{{Kb{c}}}}e}Eb{BfIl}Ib}{{{h{c}}}e{}{}}000{{{h{c}}}In{}}{c{{J`{i}}}{}{}{}{{Hj{}{{Hh{{Eb{eg}}}}}}}}0{{{h{{Jj{c}}}}{h{e}}jik}{{Eb{b}}}fGnAj{{Jl{}{{Hh{{G`{gKf}}}}}}}{{Nl{{h{g}}D`}{{Od{Fd}}}}}}{{{h{{Jj{c}}}}{h{e}}ji}{{`{{Hj{}{{Hh{{Eb{{G`{g{An{c}}}}}}}}}}}}}fGnAj{{Jl{}{{Hh{{G`{gKf}}}}}}}}0{c{{Eb{e}}}{}{}}000000{{{h{{Jj{c}}}}{h{e}}jCb}{{Eb{{Dd{{Ah{{h{c}}}}}}}}}fGn}{{{h{{Jj{c}}}}{h{e}}jKf}{{Eb{{Dd{{G`{{Ah{{h{c}}}}Cb}}}}}}}fGn}2222222{{{h{{Jj{c}}}}{h{e}}j}{{`{{Hj{}{{Hh{{Eb{{Oj{{Ol{Cn}}c}}}}}}}}}}}fGn}``{{{h{{Jj{c}}}}Cb}{{Dd{{Kl{Db{h{Kh}}}}}}}{}}{{{h{{Jj{c}}}}Cb}{{`{{Lf{}{{Hh{{G`{Db{h{{A@d{Cb}}}}}}}}}}}}}{}}`{{{h{{Kb{c}}}}}{{`{{Hj{}{{Hh{{G`{Kf{h{Kh}}}}}}}}}}}{}}``{{{h{{Jj{c}}}}}{{`{{Hj{}{{Hh{{Oh{{Ol{Cn}}c}}}}}}}}}{}}{{{h{c}}}Jb{}}000000{{{h{Af{Jj{c}}}}Fb}{{Kb{c}}}{AjBf}}{ce{}{}}000000{{{h{{Jj{c}}}}ei}{{A@`{ci}}}{AjBf}{{On{{Ol{Cn}}}}}{}{{Nl{Gd{Ol{Cn}}}{{Od{{Dd{g}}}}}}}}{{{h{{Jj{c}}}}{h{Cn}}g}{{A@b{cg}}}{}{}{{Nl{GdCb}{{Od{{Dd{e}}}}}}}}{{{h{{Jj{c}}}}Cbg}{{A@b{cg}}}{AjBf}{}{{Nl{GdCb}{{Od{{Dd{e}}}}}}}}","D":"CEj","p":[[5,"Balance",0,946],[5,"DescriptorId",0,947],[10,"Anchor",0,948],[1,"reference"],[5,"BlockId",0,949],[5,"ConfirmationBlockTime",0,949],[5,"Hash",950],[1,"u8"],[1,"array"],[1,"slice"],[0,"mut"],[6,"ChainPosition",0,949],[10,"Clone",951],[6,"ConfirmationTime",0,949],[5,"FullTxOut",0,949],[5,"SpkIterator",0,952],[1,"unit"],[6,"Ordering",953],[10,"Ord",953],[5,"Persisted",0,954],[6,"ValueRef",955],[5,"Impl",0],[8,"FromSqlResult",956],[5,"BlockHash",957],[5,"Txid",958],[5,"Amount",959],[6,"DescriptorPublicKey",960],[6,"Descriptor",961],[6,"Network",962],[10,"DeserializeOwned",963],[5,"Transaction",958],[5,"ScriptBuf",964],[1,"u32"],[6,"Option",965],[17,"CreateParams"],[17,"LoadParams"],[17,"CreateError"],[17,"LoadError"],[17,"PersistError"],[10,"PersistWith",0,954],[6,"Result",966],[10,"Future",967],[5,"Box",968],[5,"Pin",969],[10,"PersistAsyncWith",0,954],[10,"Borrow",970],[10,"DescriptorExt",0,947],[10,"Deserializer",963],[1,"u64"],[1,"bool"],[10,"PartialEq",953],[5,"Formatter",971],[8,"Result",971],[10,"Debug",971],[1,"never"],[1,"tuple"],[5,"Block",957],[1,"usize"],[10,"AnchorFromBlockPosition",0,948],[5,"FromSliceError",972],[1,"str"],[17,"Error"],[10,"ChainOracle",0,973],[10,"Hash",974],[10,"Hasher",974],[10,"SliceIndex",975],[5,"IntoFallible",976],[17,"Item"],[10,"Iterator",977],[10,"Merge",0,948],[10,"RangeBounds",978],[10,"PartialOrd",953],[10,"Serializer",979],[17,"ChangeSet"],[10,"Staged",0,954],[6,"ToSqlOutput",980],[8,"Result",981],[10,"Serialize",979],[5,"String",982],[5,"Convert",976],[5,"TypeId",983],[5,"IndexedTxGraph",334],[5,"ChangeSet",334],[10,"Indexer",384],[5,"TxGraph",768],[10,"IntoIterator",984],[10,"Default",985],[10,"Deserialize",963],[5,"ChangeSet",768],[5,"ChangeSet",393],[5,"OutPoint",958],[5,"TxOut",958],[5,"KeychainTxOutIndex",393],[5,"BTreeMap",986],[6,"InsertDescriptorError",393],[5,"Transaction",987],[5,"SpkTxOutIndex",495],[8,"Indexed",0],[10,"DoubleEndedIterator",988],[8,"KeychainIndexed",0],[10,"ExactSizeIterator",989],[5,"SignedAmount",959],[5,"BTreeSet",990],[5,"Vec",991],[5,"LocalChain",532],[5,"ChangeSet",532],[5,"MissingGenesisError",532],[5,"Header",957],[5,"CannotConnectError",532],[6,"ApplyHeaderError",532],[5,"CheckPoint",532],[5,"AlterCheckPointError",532],[5,"CheckPointIter",532],[5,"SyncRequest",704],[10,"Send",992],[17,"IntoIter"],[5,"FullScanRequest",704],[10,"FnMut",993],[10,"Sync",992],[5,"Script",994],[6,"Infallible",995],[17,"Output"],[6,"CalculateFeeError",768],[5,"TxNode",768],[5,"CanonicalTx",768],[5,"Arc",996],[10,"Into",995],[5,"TxAncestors",768],[5,"TxDescendants",768],[5,"HashSet",997],[15,"Confirmed",331],[15,"Unconfirmed",331],[15,"DescriptorAlreadyAssigned",491],[15,"KeychainAlreadyAssigned",491],[5,"SyncResult",704],[5,"FullScanResult",704]],"r":[[0,948],[1,948],[2,952],[3,946],[4,949],[6,973],[7,949],[9,949],[10,949],[17,947],[18,947],[20,949],[23,334],[24,384],[30,948],[31,954],[34,954],[35,954],[36,952],[37,954],[38,768],[224,384],[258,384]],"b":[[48,"impl-AsRef%3C%5Bu8;+%3C%24hash+as+%24crate::Hash%3E::LEN%5D%3E-for-DescriptorId"],[49,"impl-AsRef%3C%5Bu8%5D%3E-for-DescriptorId"],[98,"impl-FromSql-for-Impl%3CDescriptorId%3E"],[99,"impl-FromSql-for-Impl%3CBlockHash%3E"],[100,"impl-FromSql-for-Impl%3CTxid%3E"],[101,"impl-FromSql-for-Impl%3CAmount%3E"],[102,"impl-FromSql-for-Impl%3CDescriptor%3CDescriptorPublicKey%3E%3E"],[103,"impl-FromSql-for-Impl%3CNetwork%3E"],[104,"impl-FromSql-for-Impl%3CA%3E"],[105,"impl-FromSql-for-Impl%3CTransaction%3E"],[106,"impl-FromSql-for-Impl%3CScriptBuf%3E"],[156,"impl-Display-for-Balance"],[157,"impl-Debug-for-Balance"],[164,"impl-Debug-for-DescriptorId"],[165,"impl-UpperHex-for-DescriptorId"],[166,"impl-Display-for-DescriptorId"],[167,"impl-LowerHex-for-DescriptorId"],[175,"impl-From%3C(%26u32,+%26BlockHash)%3E-for-BlockId"],[177,"impl-From%3C(u32,+BlockHash)%3E-for-BlockId"],[272,"impl-ToSql-for-Impl%3CAmount%3E"],[273,"impl-ToSql-for-Impl%3CTxid%3E"],[274,"impl-ToSql-for-Impl%3CTransaction%3E"],[275,"impl-ToSql-for-Impl%3CA%3E"],[276,"impl-ToSql-for-Impl%3CNetwork%3E"],[277,"impl-ToSql-for-Impl%3CScriptBuf%3E"],[278,"impl-ToSql-for-Impl%3CDescriptor%3CDescriptorPublicKey%3E%3E"],[279,"impl-ToSql-for-Impl%3CBlockHash%3E"],[280,"impl-ToSql-for-Impl%3CDescriptorId%3E"],[357,"impl-From%3CChangeSet%3CA%3E%3E-for-ChangeSet%3CA,+IA%3E"],[358,"impl-From%3CChangeSet%3E-for-ChangeSet%3CA,+ChangeSet%3E"],[402,"impl-KeychainTxOutIndex%3CK%3E"],[403,"impl-Indexer-for-KeychainTxOutIndex%3CK%3E"],[422,"impl-Debug-for-InsertDescriptorError%3CK%3E"],[423,"impl-Display-for-InsertDescriptorError%3CK%3E"],[594,"impl-Debug-for-MissingGenesisError"],[595,"impl-Display-for-MissingGenesisError"],[596,"impl-Debug-for-AlterCheckPointError"],[597,"impl-Display-for-AlterCheckPointError"],[598,"impl-Display-for-CannotConnectError"],[599,"impl-Debug-for-CannotConnectError"],[600,"impl-Debug-for-ApplyHeaderError"],[601,"impl-Display-for-ApplyHeaderError"],[616,"impl-FromIterator%3C(u32,+BlockHash)%3E-for-ChangeSet"],[617,"impl-FromIterator%3C(u32,+Option%3CBlockHash%3E)%3E-for-ChangeSet"],[843,"impl-Display-for-CalculateFeeError"],[844,"impl-Debug-for-CalculateFeeError"]],"c":"OjAAAAAAAAA=","e":"OzAAAAEAAAUCVAAYAAEAJwAAACoAAQAtAAIAMQACADUAFABLAA8AXAAPAG8AAAB2AAUAfgAEAIQAJQCrAAAArwABALIAAAC2AAAAugADAL8AAgDDAAQAywAAANkAAADhAAAA6AAAAOsAAQDuAAYA+QAAAPsABQADAQAABwEIABEBCgAgARMANgEJAEIBCQBVAQAAWQELAGYBAQBzAQEAdgEFAH0BAwCUARUAsAECALkBAADTAQAA1QEJAOIBAgDpAQIA8gEGAPsBAgABAgAACwICABECAAAUAgAAJwIfAEgCBgBQAgoAXwIAAGkCAQBwAgAAgAIDAIYCAACIAgAAjwIAAJECCgCdAgcApgIPALcCBwDFAgcA8AIHAPkCBwAVAwAAGAMNACgDEQA7AwoASQMFAGsDAQBuAwAAdAMAAHYDAQB5AwEAfAMFAIcDBgCQAwYAoQMGAKkDBgA="}],\
+["bdk_coin_select",{"t":"FFGGFFPIPFGPPPFGFPPSPPPPPFNNNNOONNNNNNNNNNNNNNNNNNNNNNNNNNONNNNNNNNNNNNNNNNNHNNNONONNNNNNNNOOONNNNNNNNNNNNNNNNNNNNNNNNNNNNNNONNNNNNNNNNNNNNNNONNOOOONNNNONOOOOONNNNONNNNNNOOOONNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNONNNNNNNNNNNNOOON","n":["Bnb","BnbIter","BnbLimit","BranchStrategy","CoinSelector","CoinSelectorOpt","Continue","DecideStrategy","Duration","ExcessStrategy","ExcessStrategyKind","MinAbsoluteFee","MinDrainValue","Rounds","Selection","SelectionConstraint","SelectionError","SkipBoth","SkipInclusion","TXIN_BASE_WEIGHT","TargetFee","TargetValue","ToDrain","ToFee","ToRecipient","WeightedValue","advertise_new_score","all_selected","apply_selection","backtrack","base_weight","best_score","best_strategy","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","candidate","candidates","clone","clone","clone","clone","clone","clone","clone","clone","clone_into","clone_into","clone_into","clone_into","clone_into","clone_into","clone_into","clone_into","cmp","coin_select_bnb","current_excess","current_weight","deselect","drain_value","drain_waste","drain_weight","effective_target","effective_value","eq","eq","equivalent","equivalent","equivalent","equivalent","excess","excess_strategies","fee","feerate","finish","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","forward","from","from","from","from","from","from","from","from","from","from","from","from","from","from","fund_outputs","hash","input_count","into","into","into","into","into","into","into","into","into","into","into","into","into_fallible","into_iter","into_iter","is_empty","is_segwit","is_selected","long_term_feerate","long_term_feerate","max_extra_target","min_absolute_fee","min_drain_value","new","new","new","next","opts","partial_cmp","pool","pool_pos","recipient_value","rem_abs","rem_eff","select","select_all","select_until_finished","selected","selected","selected_absolute_value","selected_count","selected_effective_value","selected_indexes","selected_waste","selected_weight","selection","spend_drain_weight","target_feerate","target_value","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","to_string","to_string","to_string","transpose_into_fallible","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","unselected","unselected_indexes","value","vzip","vzip","vzip","vzip","vzip","vzip","vzip","vzip","vzip","vzip","vzip","vzip","waste","weight","weight","will_continue"],"q":[[0,"bdk_coin_select"],[241,"bdk_coin_select::bnb"],[242,"core::cmp"],[243,"bdk_coin_select::coin_selector"],[244,"core::iter::traits::iterator"],[245,"core::option"],[246,"core::convert"],[247,"core::result"],[248,"core::fmt"],[249,"core::time"],[250,"bitcoin::blockdata::transaction"],[251,"core::hash"],[252,"fallible_iterator"],[253,"alloc::vec"],[254,"core::marker"],[255,"alloc::string"],[256,"core::any"]],"i":[0,0,0,0,0,0,43,0,22,0,0,18,18,22,0,0,0,43,43,0,18,18,11,11,11,0,2,6,7,2,16,2,7,43,2,35,22,15,16,6,17,18,7,11,12,43,2,35,22,15,16,6,17,18,7,11,12,6,6,15,16,6,17,18,7,11,12,15,16,6,17,18,7,11,12,11,0,6,6,6,12,16,16,6,15,18,11,18,18,11,11,7,7,12,12,6,15,16,6,17,17,18,18,7,11,11,12,2,43,2,35,22,22,22,15,16,6,17,18,7,11,12,16,11,15,43,2,35,22,15,16,6,17,18,7,11,12,35,2,35,6,15,6,16,16,16,16,16,2,15,6,35,6,11,2,2,12,2,2,6,6,6,6,7,6,6,6,6,6,6,2,16,16,16,15,16,6,17,18,7,11,12,17,18,11,35,43,2,35,22,15,16,6,17,18,7,11,12,43,2,35,22,15,16,6,17,18,7,11,12,43,2,35,22,15,16,6,17,18,7,11,12,6,6,15,43,2,35,22,15,16,6,17,18,7,11,12,12,15,12,43],"f":"``````````````````````````{{{f{b{d{c}}}}c}hj}{{{f{l}}}h}{{{f{n}}{f{{A`{c}}}}}{{`{{Ad{}{{Ab{{f{c}}}}}}}}}{}}{{{f{b{d{c}}}}}hj}``{{{f{n}}}{{Aj{{f{Af}}{f{Ah}}}}}}{{{f{c}}}{{f{e}}}{}{}}00000000000{{{f{bc}}}{{f{be}}}{}{}}00000000000{{{f{l}}Al}{{f{An}}}}`{{{f{An}}}An}{{{f{B`}}}B`}{{{f{l}}}l}{{{f{Bb}}}Bb}{{{f{Bd}}}Bd}{{{f{n}}}n}{{{f{Af}}}Af}{{{f{Ah}}}Ah}{{{f{c}}{f{be}}}Bf{}{}}0000000{{{f{Af}}{f{Af}}}Bh}{{cl}{{Bj{l}}}{{Bn{Bl}}}}{{{f{l}}}C`}{{{f{l}}}Cb}{{{f{bl}}Al}h}`{{{f{B`}}}C`}`3{{{f{An}}Cd}C`}{{{f{Bd}}{f{Bd}}}h}{{{f{Af}}{f{Af}}}h}{{{f{c}}{f{e}}}h{}{}}000```{{{f{Ah}}}Cd}{{{f{l}}}{{Cf{nBb}}}}{{{f{An}}{f{bCh}}}Cj}{{{f{B`}}{f{bCh}}}Cj}{{{f{l}}{f{bCh}}}Cj}{{{f{Bb}}{f{bCh}}}Cj}0{{{f{Bd}}{f{bCh}}}Cj}0{{{f{n}}{f{bCh}}}Cj}{{{f{Af}}{f{bCh}}}Cj}0{{{f{Ah}}{f{bCh}}}Cj}{{{f{b{d{c}}}}h}Bfj}{cc{}}000{ClBl}{AlBl}22222222{{{f{{A`{Cn}}}}{f{Cn}}Cb}B`}{{{f{Af}}{f{bc}}}BfD`}`{ce{}{}}00000000000{c{{Db{g}}}{}{}{{Ad{}{{Ab{e}}}}}}{{{d{c}}{f{{Dd{c}}}}}{{Df{c}}}j}2{{{f{l}}}h}`{{{f{l}}Al}h}{{{f{B`}}}Cd}````{{l{Dh{{Aj{Al{f{An}}}}}}c}{{d{c}}}j}{{DjCbh}An}{{{f{{Dh{An}}}}{f{B`}}}l}{{{f{b{Df{c}}}}}{{Bj{e}}}{jDlDn}{}}`{{{f{Af}}{f{Af}}}{{Bj{Bh}}}}`````{{{f{bl}}Al}h}{{{f{bl}}}Bf}{{{f{bl}}}{{Cf{nBb}}}}{{{f{l}}}{{`{{Ad{}{{Ab{{Aj{Al{f{An}}}}}}}}}}}}`{{{f{l}}}Dj}{{{f{l}}}Al}{{{f{l}}}C`}{{{f{l}}}{{`{{Ad{}{{Ab{Al}}}}}}}}1{{{f{l}}}Cb}````{{{f{c}}}e{}{}}0000000{{{f{c}}}E`{}}00{c{{Eb{i}}}{}{}{}{{Ad{}{{Ab{{Cf{eg}}}}}}}}{c{{Cf{e}}}{}{}}00000000000000000000000{{{f{c}}}Ed{}}00000000000:6`{ce{}{}}00000000000```{{{f{Ef}}}h}","D":"Hl","p":[[0,"mut"],[5,"Bnb",0,241],[1,"reference"],[1,"bool"],[10,"Ord",242],[5,"CoinSelector",0,243],[5,"Selection",0,243],[1,"slice"],[17,"Item"],[10,"Iterator",244],[6,"ExcessStrategyKind",0,243],[5,"ExcessStrategy",0,243],[1,"tuple"],[1,"usize"],[5,"WeightedValue",0,243],[5,"CoinSelectorOpt",0,243],[5,"SelectionError",0,243],[6,"SelectionConstraint",0,243],[1,"unit"],[6,"Ordering",242],[6,"Option",245],[6,"BnbLimit",0,241],[10,"Into",246],[1,"i64"],[1,"u32"],[1,"f32"],[6,"Result",247],[5,"Formatter",248],[8,"Result",248],[5,"Duration",249],[5,"TxOut",250],[10,"Hasher",251],[5,"IntoFallible",252],[8,"DecideStrategy",0,241],[5,"BnbIter",0,241],[5,"Vec",253],[1,"u64"],[10,"Copy",254],[10,"Display",248],[5,"String",255],[5,"Convert",252],[5,"TypeId",256],[6,"BranchStrategy",0,241]],"r":[[0,241],[1,241],[2,241],[3,241],[4,243],[5,243],[7,241],[9,243],[10,243],[14,243],[15,243],[16,243],[25,243],[76,241]],"b":[[99,"impl-Debug-for-SelectionError"],[100,"impl-Display-for-SelectionError"],[101,"impl-Display-for-SelectionConstraint"],[102,"impl-Debug-for-SelectionConstraint"],[104,"impl-Debug-for-ExcessStrategyKind"],[105,"impl-Display-for-ExcessStrategyKind"],[112,"impl-From%3CDuration%3E-for-BnbLimit"],[113,"impl-From%3Cusize%3E-for-BnbLimit"]],"c":"OjAAAAAAAAA=","e":"OzAAAAEAAKsAGAAAAAAAAgAAAAYAAAAJAAIADgADABcAAgAcAAEAIAAAACIAKgBQAAIAVgAIAGAACwBxAAEAewABAIwAAQCPAAEAlwANAKYAAACoAAAAqwAAAK8ACgC7ACUA4gAMAPAAAQA="}],\
 ["bdk_electrum",{"t":"FENNENNNNONNNNNNNNN","n":["BdkElectrumClient","bdk_chain","borrow","borrow_mut","electrum_client","fetch_tx","fmt","from","full_scan","inner","into","new","populate_tx_cache","sync","transaction_broadcast","try_from","try_into","type_id","vzip"],"q":[[0,"bdk_electrum"],[19,"bdk_electrum::bdk_electrum_client"],[20,"bitcoin::blockdata::transaction"],[21,"alloc::sync"],[22,"electrum_client::types"],[23,"core::result"],[24,"electrum_client::api"],[25,"core::fmt"],[26,"bdk_chain::spk_client"],[27,"core::cmp"],[28,"core::clone"],[29,"bdk_chain::tx_graph"],[30,"core::convert"],[31,"core::any"]],"i":[0,0,3,3,0,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{c}}}}h}{{A`{{l{j}}n}}}Ab}{{{b{{f{c}}}}{b{dAd}}}AfAh}{cc{}}{{{b{{f{c}}}}{Aj{e}}AlAlAn}{{A`{{B`{e}}n}}}Ab{BbBd}}`{ce{}{}}{c{{f{c}}}Ab}{{{b{{f{c}}}}g}BfAb{}{{Bj{{Bh{e}}}}}}{{{b{{f{c}}}}BlAlAn}{{A`{Bnn}}}Ab}{{{b{{f{c}}}}{b{j}}}{{A`{hn}}}Ab}{c{{A`{e}}}{}{}}0{{{b{c}}}C`{}}6","D":"Af","p":[[1,"reference"],[0,"mut"],[5,"BdkElectrumClient",0,19],[5,"Txid",20],[5,"Transaction",20],[5,"Arc",21],[6,"Error",22],[6,"Result",23],[10,"ElectrumApi",24],[5,"Formatter",25],[8,"Result",25],[10,"Debug",25],[5,"FullScanRequest",26],[1,"usize"],[1,"bool"],[5,"FullScanResult",26],[10,"Ord",27],[10,"Clone",28],[1,"unit"],[5,"TxGraph",29],[10,"AsRef",30],[5,"SyncRequest",26],[5,"SyncResult",26],[5,"TypeId",31]],"r":[[0,19]],"b":[],"c":"OjAAAAAAAAA=","e":"OzAAAAEAAAgAAwACAAMABwAAABAAAwA="}],\
 ["bdk_esplora",{"t":"IKKEMMMM","n":["Error","EsploraAsyncExt","EsploraExt","esplora_client","full_scan","full_scan","sync","sync"],"q":[[0,"bdk_esplora"],[8,"bdk_esplora::blocking_ext"],[9,"bdk_chain::spk_client"],[10,"core::result"],[11,"core::cmp"],[12,"core::clone"],[13,"bdk_esplora::async_ext"],[14,"core::future::future"],[15,"alloc::boxed"],[16,"core::pin"],[17,"core::marker"]],"i":[0,0,0,0,1,10,1,10],"f":"````{{{d{b}}{f{c}}hh}{{n{{j{c}}l}}}{A`Ab}}{{{d{Ad}}{f{c}}hh}{{Aj{{Ah{Af}}}}}{A`AbAl}}{{{d{b}}Anh}{{n{B`l}}}}{{{d{Ad}}Anh}{{Aj{{Ah{Af}}}}}}","D":"A`","p":[[10,"EsploraExt",0,8],[1,"reference"],[5,"FullScanRequest",9],[1,"usize"],[5,"FullScanResult",9],[8,"Error",0,8],[6,"Result",10],[10,"Ord",11],[10,"Clone",12],[10,"EsploraAsyncExt",0,13],[10,"Future",14],[5,"Box",15],[5,"Pin",16],[10,"Send",17],[5,"SyncRequest",9],[5,"SyncResult",9]],"r":[[0,8],[1,13],[2,8]],"b":[],"c":"OjAAAAAAAAA=","e":"OjAAAAEAAAAAAAAAEAAAAAQA"}],\
-["bdk_file_store",{"t":"FPFGPPPGFNNNNNNNNNNNNONNNNNNNNNNNNNNNNNNNNNNNNONNNNNNNNNNNNNNNNNNNNNNNNNNNNOO","n":["AggregateChangesetsError","Bincode","EntryIter","FileError","InvalidMagicBytes","Io","Io","IterError","Store","aggregate_changesets","append_changeset","borrow","borrow","borrow","borrow","borrow","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","changeset","create_new","drop","fmt","fmt","fmt","fmt","fmt","fmt","fmt","from","from","from","from","from","from","from","into","into","into","into","into","into_fallible","into_iter","iter_changesets","iter_error","new","next","open","open_or_create_new","to_string","to_string","to_string","transpose_into_fallible","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","vzip","vzip","vzip","vzip","vzip","expected","got"],"q":[[0,"bdk_file_store"],[75,"bdk_file_store::FileError"],[77,"bdk_file_store::store"],[78,"core::option"],[79,"core::result"],[80,"bdk_chain::tx_data_traits"],[81,"serde::ser"],[82,"serde::de"],[83,"core::marker"],[84,"std::io::error"],[85,"std::path"],[86,"core::convert"],[87,"bdk_file_store::entry_iter"],[88,"core::fmt"],[89,"fallible_iterator"],[90,"core::iter::traits::iterator"],[91,"std::fs"],[92,"alloc::string"],[93,"core::any"]],"i":[0,20,0,0,16,20,16,0,0,2,2,19,20,2,5,16,19,20,2,5,16,5,2,19,20,20,2,5,5,16,16,19,20,20,2,5,16,16,19,20,2,5,16,19,19,2,5,19,19,2,2,20,5,16,19,19,20,2,5,16,19,20,2,5,16,19,20,2,5,16,19,20,2,5,16,32,32],"f":"`````````{{{f{b{d{c}}}}}{{l{{h{c}}{j{c}}}}}{nA`AbAdAf}}{{{f{b{d{c}}}}{f{c}}}{{l{AhAj}}}{nA`AbAdAf}}{{{f{c}}}{{f{e}}}{}{}}0000{{{f{bc}}}{{f{be}}}{}{}}0000`{{{f{{An{Al}}}}c}{{l{{d{e}}B`}}}{{Bd{Bb}}}{nA`AbAdAf}}{{{f{b{Bf{c}}}}}Ah{}}{{{f{Bh}}{f{bBj}}}Bl}0{{{f{{d{c}}}}{f{bBj}}}Bl{AfAdBn}}{{{f{{j{c}}}}{f{bBj}}}BlBn}{{{f{{j{c}}}}{f{bBj}}}Bl{}}{{{f{B`}}{f{bBj}}}Bl}0{cc{}}0{AjBh}111{AjB`}{ce{}{}}0000{c{{C`{g}}}{}{}{{Cd{}{{Cb{e}}}}}}1{{{f{b{d{c}}}}}{{Bf{c}}}{nA`AbAdAf}}`{{Cf{f{bCh}}}{{Bf{c}}}{}}{{{f{b{Bf{c}}}}}{{h{e}}}Ab{}}>>{{{f{c}}}Cj{}}00{c{{Cl{i}}}{}{}{}{{Cd{}{{Cb{{l{eg}}}}}}}}{c{{l{e}}}{}{}}000000000{{{f{c}}}Cn{}}000088888``","D":"Cl","p":[[0,"mut"],[5,"Store",0,77],[1,"reference"],[6,"Option",78],[5,"AggregateChangesetsError",0,77],[6,"Result",79],[10,"Merge",80],[10,"Serialize",81],[10,"DeserializeOwned",82],[10,"Send",83],[10,"Sync",83],[1,"unit"],[5,"Error",84],[1,"u8"],[1,"slice"],[6,"FileError",0],[5,"Path",85],[10,"AsRef",86],[5,"EntryIter",0,87],[6,"IterError",0,87],[5,"Formatter",88],[8,"Result",88],[10,"Debug",88],[5,"IntoFallible",89],[17,"Item"],[10,"Iterator",90],[1,"u64"],[5,"File",91],[5,"String",92],[5,"Convert",89],[5,"TypeId",93],[15,"InvalidMagicBytes",75]],"r":[[0,77],[2,87],[7,87],[8,77]],"b":[[24,"impl-Display-for-IterError"],[25,"impl-Debug-for-IterError"],[27,"impl-Debug-for-AggregateChangesetsError%3CC%3E"],[28,"impl-Display-for-AggregateChangesetsError%3CC%3E"],[29,"impl-Display-for-FileError"],[30,"impl-Debug-for-FileError"]],"c":"OjAAAAAAAAA=","e":"OzAAAAEAAC8ACAAMAAkAGAAHACIAAAAmAAAALQAAADAAAQA0AAIAOAAVAA=="}],\
+["bdk_file_store",{"t":"FPFGPPPGFNNNNNNNNNNNNONNNNNNNNNNNNNNNNNNNNNNNNONNNNNNNNNNNNNNNNNNNNNNNNNNNNOO","n":["AggregateChangesetsError","Bincode","EntryIter","FileError","InvalidMagicBytes","Io","Io","IterError","Store","aggregate_changesets","append_changeset","borrow","borrow","borrow","borrow","borrow","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","changeset","create_new","drop","fmt","fmt","fmt","fmt","fmt","fmt","fmt","from","from","from","from","from","from","from","into","into","into","into","into","into_fallible","into_iter","iter_changesets","iter_error","new","next","open","open_or_create_new","to_string","to_string","to_string","transpose_into_fallible","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","vzip","vzip","vzip","vzip","vzip","expected","got"],"q":[[0,"bdk_file_store"],[75,"bdk_file_store::FileError"],[77,"bdk_file_store::store"],[78,"core::option"],[79,"core::result"],[80,"bdk_chain::tx_data_traits"],[81,"serde::ser"],[82,"serde::de"],[83,"core::marker"],[84,"std::io::error"],[85,"std::path"],[86,"core::convert"],[87,"bdk_file_store::entry_iter"],[88,"core::fmt"],[89,"fallible_iterator"],[90,"core::iter::traits::iterator"],[91,"std::fs"],[92,"alloc::string"],[93,"core::any"]],"i":[0,20,0,0,16,20,16,0,0,2,2,19,20,2,5,16,19,20,2,5,16,5,2,19,20,20,2,5,5,16,16,19,20,20,2,5,16,16,19,20,2,5,16,19,19,2,5,19,19,2,2,20,5,16,19,19,20,2,5,16,19,20,2,5,16,19,20,2,5,16,19,20,2,5,16,32,32],"f":"`````````{{{f{b{d{c}}}}}{{l{{h{c}}{j{c}}}}}{nA`AbAdAf}}{{{f{b{d{c}}}}{f{c}}}{{l{AhAj}}}{nA`AbAdAf}}{{{f{c}}}{{f{e}}}{}{}}0000{{{f{bc}}}{{f{be}}}{}{}}0000`{{{f{{An{Al}}}}c}{{l{{d{e}}B`}}}{{Bd{Bb}}}{nA`AbAdAf}}{{{f{b{Bf{c}}}}}Ah{}}{{{f{Bh}}{f{bBj}}}Bl}0{{{f{{d{c}}}}{f{bBj}}}Bl{AfAdBn}}{{{f{{j{c}}}}{f{bBj}}}BlBn}{{{f{{j{c}}}}{f{bBj}}}Bl{}}{{{f{B`}}{f{bBj}}}Bl}0{cc{}}0{AjBh}111{AjB`}{ce{}{}}0000{c{{C`{g}}}{}{}{{Cd{}{{Cb{e}}}}}}1{{{f{b{d{c}}}}}{{Bf{c}}}{nA`AbAdAf}}`{{Cf{f{bCh}}}{{Bf{c}}}{}}{{{f{b{Bf{c}}}}}{{h{e}}}Ab{}}>>{{{f{c}}}Cj{}}00{c{{Cl{i}}}{}{}{}{{Cd{}{{Cb{{l{eg}}}}}}}}{c{{l{e}}}{}{}}000000000{{{f{c}}}Cn{}}000088888``","D":"Cl","p":[[0,"mut"],[5,"Store",0,77],[1,"reference"],[6,"Option",78],[5,"AggregateChangesetsError",0,77],[6,"Result",79],[10,"Merge",80],[10,"Serialize",81],[10,"DeserializeOwned",82],[10,"Send",83],[10,"Sync",83],[1,"unit"],[5,"Error",84],[1,"u8"],[1,"slice"],[6,"FileError",0],[5,"Path",85],[10,"AsRef",86],[5,"EntryIter",0,87],[6,"IterError",0,87],[5,"Formatter",88],[8,"Result",88],[10,"Debug",88],[5,"IntoFallible",89],[17,"Item"],[10,"Iterator",90],[1,"u64"],[5,"File",91],[5,"String",92],[5,"Convert",89],[5,"TypeId",93],[15,"InvalidMagicBytes",75]],"r":[[0,77],[2,87],[7,87],[8,77]],"b":[[24,"impl-Debug-for-IterError"],[25,"impl-Display-for-IterError"],[27,"impl-Debug-for-AggregateChangesetsError%3CC%3E"],[28,"impl-Display-for-AggregateChangesetsError%3CC%3E"],[29,"impl-Display-for-FileError"],[30,"impl-Debug-for-FileError"]],"c":"OjAAAAAAAAA=","e":"OzAAAAEAAC8ACAAMAAkAGAAHACIAAAAmAAAALQAAADAAAQA0AAIAOAAVAA=="}],\
 ["bdk_hwi",{"t":"FNNNNNNNNNNNN","n":["HWISigner","borrow","borrow_mut","fmt","from","from_device","id","into","sign_transaction","try_from","try_into","type_id","vzip"],"q":[[0,"bdk_hwi"],[13,"bdk_hwi::signer"],[14,"core::fmt"],[15,"hwi::types"],[16,"hwi::error"],[17,"core::result"],[18,"secp256k1::context::alloc_only"],[19,"secp256k1"],[20,"bdk_wallet::wallet::signer"],[21,"bitcoin::psbt"],[22,"core::any"]],"i":[0,3,3,3,3,3,3,3,3,3,3,3,3],"f":"`{{{b{c}}}{{b{e}}}{}{}}{{{b{dc}}}{{b{de}}}{}{}}{{{b{f}}{b{dh}}}j}{cc{}}{{{b{l}}n}{{Ab{fA`}}}}{{{b{f}}{b{{Af{Ad}}}}}Ah}{ce{}{}}{{{b{f}}{b{dAj}}{b{Al}}{b{{Af{Ad}}}}}{{Ab{AnB`}}}}{c{{Ab{e}}}{}{}}0{{{b{c}}}Bb{}}3","D":"j","p":[[1,"reference"],[0,"mut"],[5,"HWISigner",0,13],[5,"Formatter",14],[8,"Result",14],[5,"HWIDevice",15],[5,"HWIChain",15],[6,"Error",16],[6,"Result",17],[6,"All",18],[5,"Secp256k1",19],[6,"SignerId",20],[5,"Psbt",21],[5,"SignOptions",20],[1,"unit"],[6,"SignerError",20],[5,"TypeId",22]],"r":[[0,13]],"b":[],"c":"OjAAAAAAAAA=","e":"OzAAAAEAAAgAAwACAAIABwAAAAkABAA="}],\
 ["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":"GGFGFPPPFGFGPPPPPPPEPPPPKGGGFGPFPPPPPPPPPIPFFGPPPFGTTFFNNONOONNNNNNNONDNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNDOONNNNNNNNNNNNNNNNCOONNNNNNNNNNNNNNONCOQNNNNNNNNNNNNNNNNNNNNNNNNNNNNCCDNNNNNNNNNNNNNNNNNNNNNQNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNONNOOONNNNNNNNNNNNNNNNNNNMNNOOONNNCONNNNNNNNNNNNNONNNNDNNNONNNNNONNNNNNNCNNNECONNNDDNNNNNNNOCENNNNNNOENNNNNNNNNNNNNNNOONONNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNCNONONNNNNNNNNNNNNNNNNNNOOHNNNNNNNNNNNNNNNNHOOOOOOOOOOOOOOOOPPFPKFIGGPFPFNNNNNNNNNNNNNNNNNNMNNNHNNNOONNNNNNNNNNNNNNNNNNNNNONNNNNNNNNNNNNNNNNNNNNNNNNNNNNOOOOOOOPPPIGEGIKTIKRGFPPPPEKGPPPPTIPPPPPPPPPPNNNNNNNNNNNNNNNNNENNNNNNNNNNNNNMNNMNNNNNCNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNCNONMNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNMNNNNNNNNNMNNNNNNMNNNNNNNNNNNNNNNNONNNNNNNNNMNNNNCNNNNNNNNNNNMNNNCNNNNNNNNNNNNNNNNNNNONNNNNNNNNNHPPGPPPPPPPPPPPNNNNNNNNNNNNNNNNNNNPPPGPFIPPIPPPPPPPPPPPGFGPPPPPGGPPPPNNNNNNNNNNNNNNNNNNNNNNNNNNOONNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNONNNNNNNNNNONNONNNNNONNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNOOOOOOOOOOOOOOOOOOOOOOOOFFFFFFFFKIFFFFNNNNNNNNNNNNNNNNNNNNNNNNMNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNGPPGPPPPPPPGPPPPPPPPPPPPPPPPPPNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNOOOOOOFIOONNNNNNNNNNNOONNNNNNPKGGGRRKGPKKFKPPPRGIPPPPPRPFPKGPPPFFGFPIPPPHMNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNMMNNNNNNNNNNNNNNNNNNNNNNNONNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNMNNNNNNNNNNNNNNNNNNNNMNNNNNNMNNNNNNNNNNNNNNNNNNNOONHNMNNHNMNNOONNNNNNMNNNNNMNHNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNKMMMSHPPPPPPPKPPPPPPPPPPPPPPPPFKGGGFFFPGKPNOONONNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNMNNNNNNNNNNNNNNNNNMNNNMNONONNNNNNNNOONNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNOGGPPGPPPPPPFGPPNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNOOOO","n":["AddForeignUtxoError","AddUtxoError","AddressInfo","ApplyBlockError","Balance","CannotConnect","ChangeAllowed","ChangeForbidden","ChangeSet","ChangeSpendPolicy","CreateParams","CreateWithPersistError","Custom","Descriptor","Descriptor","Descriptor","External","Foreign","Genesis","HdKeyPaths","Internal","InvalidChangeSet","InvalidOutpoint","InvalidTxid","IsDust","KeychainKind","LoadError","LoadMismatch","LoadParams","LoadWithPersistError","Local","LocalOutput","Mismatch","MissingDescriptor","MissingGenesis","MissingNetwork","MissingUtxo","Network","OnlyChange","Persist","Persist","PersistedWallet","Shuffle","SignOptions","TxBuilder","TxOrdering","UnexpectedConnectedToHash","UnknownUtxo","Untouched","Update","Utxo","WALLET_SCHEMA_NAME","WALLET_TABLE_NAME","Wallet","WeightedUtxo","add","add_signer","address","all_unbounded_spk_iters","allow_all_sighashes","allow_grinding","apply_block","apply_block_connected_to","apply_unconfirmed_txs","apply_update","as_byte","as_ref","as_ref","assume_height","balance","bitcoin","borrow","borrow","borrow","borrow","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","borrow_mut","borrow_mut","borrow_mut","borrow_mut","build_fee_bump","build_tx","calculate_fee","calculate_fee_rate","cancel_tx","chain","chain","change_descriptor","checkpoints","clone","clone","clone","clone","clone","clone","clone","clone_into","clone_into","clone_into","clone_into","clone_into","clone_into","clone_into","cmp","coin_selection","confirmation_time","confirmed","create","create","create","create","create_wallet","create_wallet_async","create_wallet_no_persist","create_with_params","default","default","default","default","deref","derivation_index","derivation_index","derivation_of_spk","descriptor","descriptor","descriptor","descriptor_checksum","descriptors","deserialize","deserialize","deserialize","deserialize","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","equivalent","equivalent","equivalent","equivalent","equivalent","equivalent","equivalent","equivalent","equivalent","equivalent","equivalent","equivalent","error","export","file_store","finalize_psbt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fragment","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from_sqlite","genesis_hash","genesis_hash","get_psbt_input","get_signers","get_tx","get_utxo","graph","hash","hash","immature","index","indexer","insert_checkpoint","insert_tx","insert_txout","into","into","into","into","into","into","into","into","into","into","into","into","into","into","into","into","is_dust","is_empty","is_mine","is_spent","keychain","keychain","keychains","keymap","keymap","keys","last_active_indices","latest_checkpoint","list_output","list_unspent","list_unused_addresses","load","load","load","load","load_wallet","load_wallet_async","load_wallet_no_persist","load_with_params","local_chain","local_chain","lookahead","lookahead","mark_used","merge","miniscript","network","network","network","network","new","new","next_derivation_index","next_unused_address","outpoint","outpoint","partial_cmp","peek_address","persist","persist","persist","persist_to_sqlite","policies","psbt","public_descriptor","reveal_addresses_to","reveal_next_address","rusqlite","rusqlite_impl","satisfaction_weight","secp_ctx","sent_and_received","sequence","serde","serde_json","serialize","serialize","serialize","serialize","set_keymap","set_keymaps","sign","sign_with_tap_internal_key","signer","signer","spk_index","staged","staged","start_full_scan","start_sync_with_revealed_spks","take_staged","tap_leaves_options","template","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","to_string","to_string","to_string","to_string","to_string","to_string","total","transactions","trust_witness_utxo","trusted_pending","trusted_spendable","try_finalize","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_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","try_into","try_into","try_into","try_into","tx_builder","tx_graph","tx_graph","txout","txout","type_id","type_id","type_id","type_id","type_id","type_id","type_id","type_id","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","utxo","version","vzip","vzip","vzip","vzip","vzip","vzip","vzip","vzip","vzip","vzip","vzip","vzip","vzip","vzip","vzip","vzip","wallet_name_from_descriptor","foreign_utxo","input_txid","connected_to_hash","expected_hash","expected","expected","expected","keychain","loaded","loaded","loaded","input_sort","output_sort","outpoint","psbt_input","sequence","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","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","equivalent","equivalent","equivalent","equivalent","equivalent","equivalent","equivalent","equivalent","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","Base58","Bip32","Error","ExternalAndInternalAreTheSame","HardenedDerivationXpub","Hex","InvalidDescriptorCharacter","InvalidDescriptorChecksum","InvalidHdKeyPath","Key","Miniscript","MultiPath","Pk","Policy","borrow","borrow_mut","eq","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","equivalent","equivalent","equivalent","equivalent","equivalent","equivalent","equivalent","equivalent","equivalent","equivalent","equivalent","equivalent","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","clone","clone","clone","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","clone_into","clone_into","clone_into","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","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","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","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","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","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","eq","equivalent","equivalent","equivalent","equivalent","equivalent","equivalent","equivalent","equivalent","equivalent","equivalent","equivalent","equivalent","equivalent","equivalent","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","SCHEMAS_TABLE_NAME","migrate_schema","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","descriptor_secret_key","eq","eq","eq","eq","equivalent","equivalent","equivalent","equivalent","equivalent","equivalent","equivalent","equivalent","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","equivalent","equivalent","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"],[430,"bdk_wallet::AddForeignUtxoError"],[432,"bdk_wallet::ApplyBlockError"],[434,"bdk_wallet::LoadMismatch"],[441,"bdk_wallet::TxOrdering"],[443,"bdk_wallet::Utxo"],[446,"bdk_wallet::coin_selection"],[538,"bdk_wallet::coin_selection::Error"],[540,"bdk_wallet::coin_selection::Excess"],[545,"bdk_wallet::descriptor"],[805,"bdk_wallet::descriptor::checksum"],[806,"bdk_wallet::descriptor::error"],[839,"bdk_wallet::descriptor::policy"],[998,"bdk_wallet::descriptor::policy::BuildSatisfaction"],[1001,"bdk_wallet::descriptor::policy::Satisfaction"],[1012,"bdk_wallet::descriptor::policy::SatisfiableItem"],[1022,"bdk_wallet::descriptor::template"],[1206,"bdk_wallet::error"],[1277,"bdk_wallet::error::CreateTxError"],[1283,"bdk_wallet::export"],[1306,"bdk_wallet::keys"],[1622,"bdk_wallet::psbt"],[1626,"bdk_wallet::rusqlite_impl"],[1628,"bdk_wallet::signer"],[1814,"bdk_wallet::signer::SignerContext"],[1815,"bdk_wallet::tx_builder"],[1930,"bdk_wallet::tx_builder::AddForeignUtxoError"],[1932,"bdk_wallet::tx_builder::TxOrdering"],[1934,"bdk_chain::balance"],[1935,"bdk_wallet::wallet"],[1936,"bdk_wallet::types"],[1937,"bdk_wallet::wallet::signer"],[1938,"alloc::sync"],[1939,"bitcoin::blockdata::script::owned"],[1940,"bdk_chain"],[1941,"core::iter::traits::iterator"],[1942,"core::clone"],[1943,"alloc::collections::btree::map"],[1944,"bitcoin::blockdata::block"],[1945,"bdk_chain::local_chain"],[1946,"core::result"],[1947,"bdk_chain::chain_data"],[1948,"bitcoin::blockdata::transaction"],[1949,"core::iter::traits::collect"],[1950,"core::convert"],[1951,"bdk_chain::tx_graph"],[1952,"bdk_wallet::wallet::coin_selection"],[1953,"bdk_wallet::wallet::tx_builder"],[1954,"bdk_wallet::wallet::error"],[1955,"bitcoin_units::amount"],[1956,"bitcoin_units::fee_rate"],[1957,"bdk_wallet::wallet::changeset"],[1958,"core::cmp"],[1959,"rusqlite::transaction"],[1960,"rusqlite"],[1961,"bdk_file_store::store"],[1962,"bdk_wallet::wallet::params"],[1963,"bdk_wallet::wallet::persisted"],[1964,"core::option"],[1965,"alloc::string"],[1966,"serde::de"],[1967,"bitcoin::psbt"],[1968,"core::fmt"],[1969,"bdk_chain::indexer::keychain_txout"],[1970,"bdk_chain::indexed_tx_graph"],[1971,"bdk_chain::spk_client"],[1972,"bitcoin::psbt::map::input"],[1973,"core::hash"],[1974,"bdk_wallet::wallet::utils"],[1975,"bitcoin::blockdata::script::borrowed"],[1976,"miniscript::descriptor"],[1977,"core::iter::traits::double_ended"],[1978,"bitcoin::network"],[1979,"secp256k1::context::alloc_only"],[1980,"secp256k1"],[1981,"serde::ser"],[1982,"core::any"],[1983,"alloc::vec"],[1984,"bitcoin::address"],[1985,"miniscript"],[1986,"miniscript::miniscript"],[1987,"miniscript::miniscript::decode"],[1988,"miniscript::miniscript::context"],[1989,"miniscript::iter::tree"],[1990,"miniscript::descriptor::key"],[1991,"miniscript::miniscript::satisfy"],[1992,"miniscript::plan"],[1993,"bitcoin_hashes::sha256"],[1994,"miniscript::miniscript::hash256"],[1995,"bitcoin_hashes::ripemd160"],[1996,"bitcoin_hashes::hash160"],[1997,"bitcoin::crypto::key"],[1998,"secp256k1::context"],[1999,"bdk_chain::descriptor_ext"],[2000,"miniscript::blanket_traits"],[2001,"miniscript::miniscript::analyzable"],[2002,"core::ops::range"],[2003,"core::ops::function"],[2004,"miniscript::descriptor::bare"],[2005,"miniscript::descriptor::segwitv0"],[2006,"miniscript::descriptor::tr"],[2007,"miniscript::descriptor::sh"],[2008,"miniscript::miniscript::types"],[2009,"miniscript::miniscript::types::extra_props"],[2010,"miniscript::expression"],[2011,"miniscript::miniscript::iter"],[2012,"miniscript::policy::semantic"],[2013,"miniscript::policy"],[2014,"bitcoin_units::weight"],[2015,"hex_conservative::error"],[2016,"base58ck::error"],[2017,"bitcoin::bip32"],[2018,"bitcoin::psbt::error"],[2019,"bdk_wallet::wallet::export"],[2020,"miniscript::descriptor::sortedmulti"],[2021,"core::str::traits"],[2022,"core::default"],[2023,"rand_core"],[2024,"rusqlite::error"],[2025,"core::marker"],[2026,"bitcoin::blockdata::script::push_bytes::primitive"],[2027,"bitcoin::blockdata::locktime::absolute"],[2028,"bdk_chain::rusqlite_impl"]],"i":[0,0,0,0,0,71,257,257,0,0,0,0,258,70,60,61,5,42,61,0,5,58,255,255,0,0,0,0,0,0,42,0,60,60,60,60,255,61,257,58,70,0,258,0,0,0,71,256,258,0,0,43,43,0,0,1,3,53,3,63,63,3,3,3,3,5,5,3,63,3,0,48,52,1,5,40,41,42,43,58,70,3,26,53,60,61,71,48,52,1,5,40,41,42,43,58,70,3,26,53,60,61,71,3,3,3,3,3,0,26,43,3,1,5,40,41,42,43,26,1,5,40,41,42,43,26,5,0,40,1,3,3,3,3,48,48,48,3,52,1,43,26,53,3,40,3,0,43,0,3,52,1,5,40,43,1,5,40,41,42,43,58,53,60,61,1,1,5,5,40,40,41,41,42,42,53,53,0,0,0,3,1,1,5,40,41,42,43,58,58,70,70,3,26,53,53,60,60,61,71,71,0,48,52,1,5,40,41,42,43,43,43,43,43,58,58,70,3,26,26,26,53,60,60,61,71,43,48,52,3,3,3,3,26,5,40,1,53,43,3,3,3,48,52,1,5,40,41,42,43,58,70,3,26,53,60,61,71,89,43,3,40,40,53,3,48,52,0,26,3,3,3,3,3,3,3,3,52,52,52,3,3,43,48,52,3,43,0,48,52,3,43,48,52,3,3,42,40,5,3,3,3,3,43,3,0,3,3,3,0,0,41,3,3,42,0,0,1,5,40,43,3,3,3,63,0,0,3,3,3,3,3,3,63,0,1,5,40,41,42,43,26,1,58,70,53,60,71,1,3,63,1,1,63,48,52,1,5,40,41,42,43,58,70,3,26,53,60,61,71,48,52,1,5,40,41,42,43,58,70,3,26,53,60,61,71,0,3,43,42,40,48,52,1,5,40,41,42,43,58,70,3,26,53,60,61,71,3,3,3,1,41,0,48,52,1,5,40,41,42,43,58,70,3,26,53,60,61,71,0,261,261,262,262,263,264,265,265,263,264,265,266,266,267,267,267,114,114,0,115,0,0,0,0,0,114,0,115,0,114,115,113,108,109,110,114,115,113,108,109,110,108,109,110,108,109,110,111,108,109,110,0,108,109,110,113,113,114,114,115,113,108,109,110,114,115,113,108,109,110,114,115,113,108,109,110,113,110,113,113,108,109,110,114,114,115,113,108,109,110,114,115,113,108,109,110,114,115,113,108,109,110,114,115,113,108,109,110,268,268,269,270,270,269,270,91,271,116,0,0,0,0,0,0,122,0,0,124,0,0,126,91,271,116,0,0,0,91,271,116,126,122,0,91,271,116,91,271,116,91,271,116,126,116,143,144,122,122,116,116,143,144,122,116,143,144,122,122,122,122,0,124,143,144,124,144,124,124,143,144,124,143,144,124,124,143,144,124,143,144,124,143,144,0,116,143,144,122,116,143,144,122,116,143,144,122,122,116,116,116,116,116,116,122,116,122,116,143,144,122,116,116,143,143,144,144,122,122,0,116,122,122,153,116,122,116,116,116,143,144,122,122,116,122,116,116,116,116,116,116,116,143,144,122,122,122,116,122,122,122,116,122,122,122,116,116,122,122,116,116,143,144,122,116,143,144,122,122,116,49,91,116,116,122,122,122,116,122,122,124,143,144,122,116,122,116,124,143,144,116,116,116,116,116,116,116,116,116,116,116,116,116,116,122,124,122,116,122,122,116,143,144,122,124,143,144,116,116,0,122,116,122,116,122,122,116,116,122,116,122,124,143,144,122,0,116,143,144,122,116,122,116,124,124,116,122,116,143,144,122,116,143,144,122,122,116,143,144,122,116,116,143,144,122,122,0,51,51,0,51,51,51,51,51,51,51,51,51,51,51,51,51,51,51,51,51,51,51,51,51,51,51,51,51,51,51,51,51,51,192,185,185,0,193,0,0,192,191,0,192,192,185,185,185,192,193,154,185,193,193,0,0,0,154,154,191,192,192,0,0,192,192,192,191,191,192,193,97,194,185,154,191,192,193,97,194,185,154,191,192,193,97,194,154,191,192,193,97,194,154,97,194,194,191,192,193,97,194,185,191,191,192,192,193,193,97,97,194,194,185,185,191,192,193,97,194,185,185,154,191,192,193,193,97,97,194,185,154,97,191,194,192,97,191,192,193,97,194,185,154,192,193,194,97,194,97,97,191,192,193,97,194,194,191,192,193,97,194,154,185,191,192,193,97,194,185,154,191,192,193,97,194,185,154,191,192,193,97,194,185,154,191,192,193,97,194,185,154,272,272,272,273,274,275,274,275,274,275,274,275,274,275,276,277,278,279,280,281,281,280,282,283,0,0,0,0,0,0,0,0,0,0,0,0,0,0,197,199,200,201,203,205,206,207,208,209,210,211,197,199,200,201,203,205,206,207,208,209,210,211,195,197,199,200,201,203,205,206,207,208,209,210,211,197,199,200,201,203,205,206,207,208,209,210,211,197,199,200,201,203,205,206,207,208,209,210,211,197,199,200,201,203,205,206,207,208,209,210,211,197,199,200,201,203,205,206,207,208,209,210,211,197,199,200,201,203,205,206,207,208,209,210,211,196,197,199,200,201,203,205,206,207,208,209,210,211,197,199,200,201,203,205,206,207,208,209,210,211,197,199,200,201,203,205,206,207,208,209,210,211,197,199,200,201,203,205,206,207,208,209,210,211,197,199,200,201,203,205,206,207,208,209,210,211,197,199,200,201,203,205,206,207,208,209,210,211,0,82,212,0,82,82,35,82,35,82,82,0,82,82,82,82,82,212,82,82,82,82,82,35,35,82,35,212,82,82,212,82,35,212,82,35,212,212,212,212,82,82,35,35,212,82,82,82,82,82,82,35,212,82,35,212,212,82,35,212,82,35,212,82,35,212,82,35,212,82,35,284,284,285,285,286,287,0,0,288,214,214,214,214,214,214,214,214,214,214,214,214,288,214,214,214,214,214,214,214,190,0,0,0,0,231,231,0,0,221,0,0,0,0,190,190,190,124,0,0,121,190,190,177,126,231,224,0,224,0,0,121,126,177,0,0,0,0,121,0,221,177,126,0,289,126,224,217,222,121,218,190,216,126,177,219,220,221,224,217,222,121,218,190,216,126,177,219,220,221,216,124,124,124,124,124,124,124,124,124,217,121,218,216,126,177,219,220,221,217,121,218,216,126,177,219,220,221,216,126,219,221,218,218,217,126,126,216,121,190,216,126,177,219,220,221,121,121,216,216,126,126,177,177,219,219,220,220,221,221,222,121,218,190,190,216,216,126,126,177,177,219,220,221,216,224,224,224,217,222,121,218,190,190,190,216,126,126,177,219,220,221,222,222,126,177,216,126,126,231,234,234,231,231,234,224,126,216,126,219,221,224,217,222,121,218,190,216,126,177,219,220,221,126,198,204,217,217,222,126,177,204,224,217,217,126,177,224,224,126,289,121,126,177,289,121,289,121,126,126,216,219,220,216,0,126,124,216,216,0,216,124,216,126,219,220,124,222,216,126,219,221,124,216,216,216,216,126,124,216,0,217,121,218,216,126,177,219,220,221,177,190,216,126,177,124,124,216,224,217,222,121,218,190,216,126,177,219,220,221,224,217,222,121,218,190,216,126,177,219,220,221,224,217,222,121,218,190,216,126,177,219,220,221,224,217,222,121,218,190,216,126,177,219,220,221,0,241,241,241,0,0,247,243,247,64,243,247,64,0,64,64,64,244,64,64,64,64,64,64,64,247,243,64,244,64,0,0,0,0,0,0,0,0,244,0,0,64,83,63,63,83,63,243,64,244,245,6,83,63,247,243,64,244,245,6,83,63,247,83,243,244,245,6,83,63,247,243,244,245,6,83,63,247,243,6,6,83,63,247,245,248,248,245,245,245,243,244,6,247,243,243,244,244,6,6,247,247,83,243,64,64,244,245,6,83,63,247,243,243,243,64,244,245,6,83,63,247,243,248,245,245,245,83,243,64,244,245,6,83,63,247,245,83,243,6,83,252,245,245,245,7,245,63,83,63,243,244,245,6,83,63,247,64,63,63,243,64,244,245,6,83,63,247,243,64,244,245,6,83,63,247,243,64,244,245,6,83,63,247,243,64,244,245,6,83,63,247,290,0,0,257,257,0,258,255,255,255,257,258,0,0,256,258,34,34,34,34,34,34,34,34,34,34,256,255,258,257,34,256,255,258,257,34,34,258,257,34,258,257,257,34,34,258,257,34,34,34,34,34,257,257,257,34,34,34,34,34,256,256,255,255,258,257,34,256,255,258,257,257,34,34,256,255,258,257,34,34,34,34,34,257,34,34,34,258,258,34,258,257,256,255,34,256,255,258,257,34,256,255,258,257,34,256,255,258,257,34,34,34,256,255,258,257,261,261,266,266],"f":"```````````````````````````````````````````````````````{{bb}b}{{{h{df}}jl{A`{n}}}Ab}`{{{h{f}}}{{An{j{`{{Aj{}{{Ad{{Ah{Af}}}}}}Al}}}}}}``{{{h{df}}{h{B`}}Bb}{{Bf{AbBd}}}}{{{h{df}}{h{B`}}BbBh}{{Bf{AbBj}}}}{{{h{df}}c}Ab{{Cb{}{{Ad{{C`{{h{Bl}}Bn}}}}}}}}{{{h{df}}c}{{Bf{AbBd}}}{{Cf{Cd}}}}{{{h{j}}}Ch}{{{h{j}}}{{h{{Cj{Ch}}}}}}{{{h{f}}}{{h{{Cn{Cl}}}}}}`{{{h{f}}}b}`{{{h{c}}}{{h{e}}}{}{}}000000000000000{{{h{dc}}}{{h{de}}}{}{}}000000000000000{{{h{df}}D`}{{Bf{{Dd{Db}}Df}}}}{{{h{df}}}{{Dd{Db}}}}{{{h{f}}{h{Bl}}}{{Bf{DhDj}}}}{{{h{f}}{h{Bl}}}{{Bf{DlDj}}}}{{{h{df}}{h{Bl}}}Ab}```{{{h{f}}}Dn}{{{h{b}}}b}{{{h{j}}}j}{{{h{E`}}}E`}{{{h{Eb}}}Eb}{{{h{Ed}}}Ed}{{{h{Ef}}}Ef}{{{h{Cd}}}Cd}{{{h{c}}{h{de}}}Ab{}{}}000000{{{h{j}}{h{j}}}Eh}```{{{h{dEj}}c}{{Bf{fe}}}{}{}}{{{h{dEl}}c}{{Bf{fe}}}{}{}}{{{h{d{En{Ef}}}}c}{{Bf{fe}}}{}{}}{{cc}F`{FbAl}}{{F`{h{dc}}}{{Bf{Fd}}}{}}0{F`{{Bf{fFf}}}}0{{}Fh}{{}b}{{}Ef}{{}Cd}{{{h{Fj}}}{{h{c}}}{}}{{{h{f}}j}{{Fl{Bb}}}}`{{{h{f}}Af}{{Fl{{C`{jBb}}}}}}```{{{h{f}}j}Fn}{{Fhcc}FhFb}{c{{Bf{b}}}G`}{c{{Bf{j}}}G`}{c{{Bf{E`}}}G`}{c{{Bf{Ef}}}G`}{{{h{b}}{h{b}}}Gb}{{{h{j}}{h{j}}}Gb}{{{h{E`}}{h{E`}}}Gb}{{{h{Eb}}{h{Eb}}}Gb}{{{h{Ed}}{h{Ed}}}Gb}{{{h{Ef}}{h{Ef}}}Gb}{{{h{{Gd{c}}}}{h{{Gd{c}}}}}GbGf}{{{h{Fj}}{h{Fj}}}Gb}{{{h{Gh}}{h{Gh}}}Gb}{{{h{Gj}}{h{Gj}}}Gb}{{{h{c}}{h{e}}}Gb{}{}}00000000000```{{{h{f}}{h{dGl}}Gn}{{Bf{GbH`}}}}{{{h{b}}{h{dHb}}}{{Bf{AbHd}}}}0{{{h{j}}{h{dHb}}}Hf}{{{h{E`}}{h{dHb}}}Hf}{{{h{Eb}}{h{dHb}}}Hf}{{{h{Ed}}{h{dHb}}}Hf}{{{h{Ef}}{h{dHb}}}Hf}{{{h{{Gd{c}}}}{h{dHb}}}HfHh}{{{h{{Gd{c}}}}{h{dHb}}}HfHj}{{{h{{Hl{c}}}}{h{dHb}}}HfHj}{{{h{{Hl{c}}}}{h{dHb}}}HfHh}{{{h{f}}{h{dHb}}}Hf}{{{h{Cd}}{h{dHb}}}Hf}{{{h{Fj}}{h{dHb}}}Hf}0{{{h{Gh}}{h{dHb}}}Hf}0{{{h{Gj}}{h{dHb}}}Hf}{{{h{Hn}}{h{dHb}}}Hf}0`{cc{}}000000{{{I`{Cl}}}Ef}1{IbEf}{{{Id{ClIb}}}Ef}{IfEf}4{Gj{{Gd{c}}}{}}555{{{Ih{j}}}Cd}{IjCd}77{GjGh}88{{{h{Ej}}}{{Il{Ef}}}}{{F`In}F`}{{FhIn}Fh}{{{h{f}}E`{Fl{J`}}Gb}{{Bf{JbJd}}}}{{{h{f}}j}{{A`{Jf}}}}{{{h{f}}D`}{{Fl{{Jh{{A`{Bl}}Cl}}}}}}{{{h{f}}Jj}{{Fl{E`}}}}`{{{h{j}}{h{dc}}}AbJl}{{{h{E`}}{h{dc}}}AbJl}```{{{h{df}}Bh}{{Bf{GbJn}}}}{{{h{df}}Bl}Gb}{{{h{df}}JjK`}Ab}{ce{}{}}000000000000000{{{h{Kb}}{h{Kd}}}Gb}{{{h{Ef}}}Gb}{{{h{f}}Af}Gb}```{{{h{f}}}{{`{{Aj{}{{Ad{{C`{j{h{Kf}}}}}}}}}}}}{{F`jKh}F`}{{FhjKh}Fh}``{{{h{f}}}Kj}{{{h{f}}}{{`{{Aj{}{{Ad{E`}}}}}}}}0{{{h{f}}j}{{`{{Kl{}{{Ad{Fj}}}}}}}}{{{h{dEj}}c}{{Bf{{Fl{f}}e}}}{}{}}{{{h{dEl}}c}{{Bf{{Fl{f}}e}}}{}{}}{{{h{d{En{Ef}}}}c}{{Bf{{Fl{f}}e}}}{}{}}{{}Fh}{{Fh{h{dc}}}{{Bf{{Fl{Fd}}}}}{}}0{{FhEf}{{Bf{{Fl{f}}Gh}}}}{{EfFh}{{Bf{{Fl{f}}Gh}}}}{{{h{f}}}{{h{Kn}}}}`{{F`Bb}F`}{{FhBb}Fh}{{{h{df}}jBb}Gb}{{{h{dEf}}Ef}Ab}`{{F`L`}F`}{{FhL`}Fh}{{{h{f}}}L`}`{{cc}F`Fb}<{{{h{f}}j}Bb}{{{h{df}}j}Fj}{{{h{Ed}}}Jj}`{{{h{j}}{h{j}}}{{Fl{Eh}}}}{{{h{f}}jBb}Fj}{{{h{dEl}}{h{c}}}{{Bf{Abe}}}{}{}}{{{h{dEj}}{h{c}}}{{Bf{Abe}}}{}{}}{{{h{d{En{Ef}}}}{h{c}}}{{Bf{Abe}}}{}{}}{{{h{Ef}}{h{Ej}}}{{Il{Ab}}}}{{{h{f}}j}{{Bf{{Fl{Lb}}Ff}}}}`{{{h{f}}j}{{h{Kf}}}}{{{h{df}}jBb}{{`{{Aj{}{{Ad{Fj}}}}}}}}:```{{{h{f}}}{{h{{Lf{Ld}}}}}}{{{h{f}}{h{Bl}}}{{C`{DhDh}}}}{{{h{Ed}}}{{Fl{Lh}}}}``{{{h{b}}c}BfLj}{{{h{j}}c}BfLj}{{{h{E`}}c}BfLj}{{{h{Ef}}c}BfLj}{{{h{df}}jKh}Ab}{{{h{df}}c}Ab{{Cb{}{{Ad{{C`{jKh}}}}}}}}{{{h{f}}{h{dGl}}Gn}{{Bf{GbH`}}}}```{{{h{f}}}{{h{{Ll{j}}}}}}{{{h{f}}}{{Fl{{h{Ef}}}}}}{{{h{df}}}{{h{dc}}}{}}{{{h{f}}}{{Ln{j}}}}{{{h{f}}}M`}{{{h{df}}}{{Fl{Ef}}}}``{{{h{c}}}e{}{}}000000{{{h{c}}}Fn{}}00000{{{h{b}}}Dh}{{{h{f}}}{{`{{Aj{}{{Ad{{Jh{{A`{Bl}}Cl}}}}}}}}}}``1`{c{{Bf{e}}}{}{}}0000000000000000000000000000000`{{{h{f}}}{{h{{Cn{Cl}}}}}}`{{{h{Ed}}}{{h{K`}}}}`{{{h{c}}}Mb{}}000000000000000{{{h{f}}j}{{`{{Aj{}{{Ad{{Ah{Af}}}}}}Al}}}}{{{h{f}}}{{`{{Aj{}{{Ad{{Md{{A`{Bl}}Cl}}}}}}}}}}{{{h{df}}jBb}Gb}``{{}{{h{Mf}}}}{ce{}{}}000000000000000{{c{Fl{c}}L`{h{{Lf{Ld}}}}}{{Bf{FnFf}}}Fb}`````````````````````````````{{{h{c}}}{{h{e}}}{}{}}00000{{{h{dc}}}{{h{de}}}{}{}}00000{{{h{Mh}}}Mh}{{{h{Mj}}}Mj}{{{h{Ml}}}Ml}{{{h{c}}{h{de}}}Ab{}{}}00{{{h{Mn}}{N`{Eb}}{N`{Eb}}DlBn{h{Kd}}}{{Bf{NbNd}}}}{{{h{Mh}}{N`{Eb}}{N`{Eb}}DlBn{h{Kd}}}{{Bf{NbNd}}}}{{{h{Mj}}{N`{Eb}}{N`{Eb}}DlBn{h{Kd}}}{{Bf{NbNd}}}}{{{h{Ml}}{N`{Eb}}{N`{Eb}}DlBn{h{Kd}}}{{Bf{NbNd}}}}{{BnDl{h{Kd}}}Nf}{{}Mh}{{}Mj}{{}Ml}``{{{h{Nd}}{h{dHb}}}Hf}0{{{h{Nf}}{h{dHb}}}Hf}{{{h{Nb}}{h{dHb}}}Hf}{{{h{Mh}}{h{dHb}}}Hf}{{{h{Mj}}{h{dHb}}}Hf}{{{h{Ml}}{h{dHb}}}Hf}{cc{}}00000{ce{}{}}00000{{{h{Nb}}}Bn}{BnMl}`1{{{h{c}}}e{}{}}00{{{h{c}}}Fn{}}{c{{Bf{e}}}{}{}}00000000000{{{h{c}}}Mb{}}00000666666`````````````````````````````````````````````{{{h{{Nh{c}}}}L`}{{Bf{NjNl}}}{NnO`}}{{}Ob}0{{{h{{Od{ce}}}}}{{h{{Of{ce}}}}}NnOh}{{{h{{h{{Od{ce}}}}}}}{{Oj{{h{{Od{ce}}}}}}}NnOh}{{{h{{Nh{Ol}}}}Bb}{{Bf{{Nh{On}}A@`}}}}{{{h{c}}}{{h{e}}}{}{}}000{{{h{dc}}}{{h{de}}}{}{}}000{{{h{{Od{ce}}}}}{{N`{{h{{Od{ce}}}}}}}NnOh}{{{h{{Od{ce}}}}{h{g}}}{{A@d{{A@b{c}}}}}{O`Nn}Oh{{A@f{c}}}}0`{{{h{{Od{c{Oh{}{{A@h{e}}}}}}}}}{{Bf{AbA@j}}}Nn{{AAl{}{{A@l{A@n}}{AA`{AAb}}{AAd{AAf}}{AAh{AAj}}}}NnNnNnNn}}{{{h{{Od{cAAn}}}}}{{Bf{AbA@j}}}Nn}{{{h{{Od{cAB`}}}}}{{Bf{AbA@j}}}Nn}2022102102{{{h{c}}}{{Bf{AbA@j}}}Nn}00{{{h{{Of{c{Oh{}{{A@h{e}}}}}}}}}{{Bf{AbA@j}}}Nn{{AAl{}{{A@l{A@n}}{AA`{AAb}}{AAd{AAf}}{AAh{AAj}}}}NnNnNnNn}}{{{h{{Of{cAAn}}}}}{{Bf{AbA@j}}}Nn}{{{h{{Of{cAB`}}}}}{{Bf{AbA@j}}}Nn}{{{h{{Cj{{N`{Ch}}}}}}}{{Bf{AbA@j}}}}00`{{{h{{Nh{c}}}}}{{Nh{c}}}{AlNn}}{{{h{AAn}}}AAn}{{{h{AB`}}}AB`}{{{h{{Od{ce}}}}}{{Od{ce}}}{AlNn}{AlOh}}{{{h{c}}{h{de}}}Ab{}{}}000{{{h{{Nh{c}}}}{h{{Nh{c}}}}}Eh{ABbNn}}{{{h{AAn}}{h{AAn}}}Eh}{{{h{AB`}}{h{AB`}}}Eh}{{{h{{Od{ce}}}}{h{{Od{ce}}}}}EhNnOh}{{{h{{Od{ce}}}}}GbNnOh}{{{h{{Nh{Ol}}}}Bb}{{Bf{{Nh{On}}A@`}}}}{{{h{{Nh{On}}}}{h{{Lf{c}}}}}{{Bf{{Nh{ABd}}A@`}}}ABf}{{{h{{Nh{Ol}}}}{h{{Lf{c}}}}Bb}{{Bf{{Nh{ABd}}A@`}}}ABf}{{{h{{Nh{c}}}}}ABhNn}{{{h{{Nh{Ol}}}}}ABj}{c{{Bf{{Nh{e}}}}}G`ABl}{c{{Bf{{Od{eg}}}}}G`ABlOh}{{{h{{Nh{Ol}}}}}Bn}{{{h{{Od{ce}}}}}Af{O`Nn}Oh}{{{h{{Nh{c}}}}{h{{Nh{c}}}}}Gb{GfNn}}{{{h{AAn}}{h{AAn}}}Gb}{{{h{AB`}}{h{AB`}}}Gb}{{{h{{Od{ce}}}}{h{{Od{ce}}}}}GbNnOh}{{{h{c}}{h{e}}}Gb{}{}}0000000`{{{h{{Nh{c}}}}}{{Bf{AfNl}}}{NnO`}}`{{{h{{Od{ce}}}}{h{ABn}}}{{Bf{AbAC`}}}NnOh}{{{h{ACb}}{h{Jf}}ACd{h{{Lf{Ld}}}}}{{Bf{{Fl{Lb}}Ff}}}}{{{h{{Nh{Ol}}}}{h{Jf}}ACd{h{{Lf{Ld}}}}}{{Bf{{Fl{Lb}}Ff}}}}{{{h{{Od{Olc}}}}{h{Jf}}ACd{h{{Lf{Ld}}}}}{{Bf{{Fl{Lb}}Ff}}}Oh}{{{h{{Nh{Ol}}}}{h{{Lf{c}}}}{h{Kd}}{ACf{Bb}}}{{Bf{{Fl{{C`{Bb{Nh{ABd}}}}}}A@`}}}ABf}{{{h{{Nh{c}}}}{h{dHb}}}{{Bf{AbHd}}}Nn}0{{{h{AAn}}{h{dHb}}}{{Bf{AbHd}}}}{{{h{AB`}}{h{dHb}}}{{Bf{AbHd}}}}{{{h{{Od{ce}}}}{h{dHb}}}{{Bf{AbHd}}}NnOh}0{{{h{{Nh{c}}}}e}GbNn{{ACj{{h{c}}}{{ACh{Gb}}}}}}{{{h{{Od{ce}}}}g}GbNnOh{{ACj{{h{c}}}{{ACh{Gb}}}}}}{{{ACl{c}}}{{Nh{c}}}Nn}{{{ACn{c}}}{{Nh{c}}}Nn}{cc{}}{{{AD`{c}}}{{Nh{c}}}Nn}{{{ADb{c}}}{{Nh{c}}}Nn}{{{ADd{c}}}{{Nh{c}}}Nn}{{{ADf{c}}}{{Nh{c}}}Nn}444{{{Of{ce}}}{{Bf{{Od{ce}}Nl}}}NnOh}{{{Of{ce}}ADhADj}{{Od{ce}}}NnOh}{{{h{Mf}}}{{Bf{{Nh{c}}Nl}}}ABl}{{{h{Mf}}}{{Bf{{Od{ce}}Nl}}}ABlOh}{{{h{Mf}}{h{ABn}}}{{Bf{{Od{ce}}Nl}}}ABlOh}1{{{h{ADl}}}{{Bf{{Nh{c}}Nl}}}ABl}{{{h{ADl}}}{{Bf{{Od{ce}}Nl}}}ABlOh}{{{h{{Od{ce}}}}ADn}{{Fl{{h{{Od{ce}}}}}}}NnOh}{{{h{{Od{ce}}}}ADn}{{Fl{c}}}NnOh}{{{h{{Nh{c}}}}e}{{Bf{{C`{{N`{{N`{Ch}}}}Af}}Nl}}}{NnO`}{{AE`{c}}}}0{{{h{{Od{ce}}}}}GbNnOh}0{{{h{{Nh{Ol}}}}}Gb}{{{h{{Nh{c}}}}{h{de}}}Ab{AEbNn}Jl}{{{h{AAn}}{h{dc}}}AbJl}{{{h{AB`}}{h{dc}}}AbJl}{{{h{{Od{ce}}}}{h{dg}}}AbNnOhJl}{ce{}{}}000{{{Od{ce}}}{{Of{ce}}}NnOh}{{{Nh{Ol}}}{{Bf{{N`{{Nh{Ol}}}}Nl}}}}{{Fb{h{{Lf{Ld}}}}L`}{{Bf{{C`{KfKh}}Ff}}}}{{Kf{h{{Lf{Ld}}}}L`}{{Bf{{C`{KfKh}}Ff}}}}99:{{{h{{Od{ce}}}}}{{AEd{ce}}}NnOh}{{{h{{Od{ce}}}}}{{AEf{ce}}}NnOh}{{{h{{Nh{c}}}}}{{Bf{{AEh{c}}Nl}}}Nn}{{{h{{Od{ce}}}}}{{Bf{{AEh{c}}Nl}}}NnOh}{{{h{{Od{ce}}}}}{{Bf{AbAEj}}}NnOh}{{{h{{Od{c{Oh{}{{A@h{e}}}}}}}}}{{Fl{ADn}}}Nn{{AAl{}{{A@l{A@n}}{AA`{AAb}}{AAd{AAf}}{AAh{AAj}}}}NnNnNnNn}}{{{h{{Od{cAAn}}}}}{{Fl{ADn}}}Nn}{{{h{{Od{cAB`}}}}}{{Fl{ADn}}}Nn}{{{h{{Od{ce}}}}}{{Bf{ADnNl}}}NnOh}{{{h{{Nh{c}}}}}{{Bf{ADnNl}}}Nn}1{{{h{{Nh{c}}}}}{{Bf{AElNl}}}Nn}{{}{{h{Mf}}}}00{{{Od{cAEn}}}{{Bf{{Nh{c}}Nl}}}Nn}{c{{Nh{c}}}Nn}{c{{Bf{{Nh{c}}Nl}}}Nn}{{{Od{cAAn}}}{{Bf{{Nh{c}}Nl}}}Nn}{{ADn{N`{c}}}{{Bf{{Nh{c}}Nl}}}Nn}{{{ACn{c}}}{{Nh{c}}}Nn}{{{AD`{c}}}{{Nh{c}}}Nn}4{{{Od{cAB`}}}{{Bf{{Nh{c}}Nl}}}Nn}3{{c{Fl{{AF`{c}}}}}{{Bf{{Nh{c}}Nl}}}Nn}614`{{{h{{Od{c{Oh{}{{A@h{e}}}}}}}}}{{Bf{AbNl}}}Nn{{AAl{}{{A@l{A@n}}{AA`{AAb}}{AAd{AAf}}{AAh{AAj}}}}NnNnNnNn}}{{{h{Kd}}}{{Bf{{Od{c}}Nl}}}Oh}{{{h{{Lf{c}}}}{h{Mf}}}{{Bf{{C`{{Nh{Ol}}{An{OlAFb}}}}Nl}}}AFd}1{{{h{Kd}}{h{ABn}}}{{Bf{{Od{c}}Nl}}}Oh}{{{h{{Nh{c}}}}{h{{Nh{c}}}}}{{Fl{Eh}}}{AFfNn}}{{{h{AAn}}{h{AAn}}}{{Fl{Eh}}}}{{{h{AB`}}{h{AB`}}}{{Fl{Eh}}}}{{{h{{Od{ce}}}}{h{{Od{ce}}}}}{{Fl{Eh}}}NnOh}{{{h{c}}}ADnNn}00{{{Nh{On}}{h{c}}}{{Bf{AFh{Nh{On}}}}}{{A@f{On}}}}0`{{{h{{Od{ce}}}}}GbNnOh}{{{h{{Nh{c}}}}}{{Bf{AbNl}}}Nn}{{{h{{Od{ce}}}}}{{Bf{AbAC`}}}NnOh}{{{h{{Nh{c}}}}{h{dAFj}}e}{{Bf{AbNl}}}{NnO`}{{AE`{c}}}}{{{h{{Od{ce}}}}g}{{Bf{{N`{{N`{Ch}}}}Nl}}}{O`Nn}Oh{{AE`{c}}}}0{{{h{{Nh{c}}}}}{{Bf{AfNl}}}{NnO`}}{{{h{{Nh{c}}}}}Af{NnO`}}{{{h{{Od{ce}}}}}ADnNnOh}{{{h{{Nh{c}}}}e}BfNnLj}{{{h{{Od{ce}}}}g}BfNnOhLj}{{}AFl}00{{{h{{Od{ce}}}}{h{{An{AAjc}}}}}{{Od{ce}}}NnOh}`{{{h{c}}}e{}{}}000{{{h{c}}}Fn{}}0{{{h{{Nh{Ol}}}}{h{{An{OlAFb}}}}}Fn}{{{h{{Od{c{Oh{}{{A@h{e}}}}}}}}}{{Bf{AbNl}}}Nn{{AAl{}{{A@l{A@n}}{AA`{AAb}}{AAd{AAf}}{AAh{AAj}}}}NnNnNnNn}}0{{{h{{Nh{c}}}}{h{di}}}{{Bf{{AFn{g}}}}}NnNn{}{{AG`{ceg}}}}{{{h{{Od{ce}}}}{h{dk}}}{{Bf{{AFn{i}}}}}NnOhNn{}{{AG`{cgi}}}}{c{{Bf{e}}}{}{}}0000000`{{{h{c}}}Mb{}}000={ce{}{}}000{{{h{{Od{ce}}}}}GbNnOh}{{{h{Mf}}}{{Bf{FnFf}}}}``````````````{{{h{c}}}{{h{e}}}{}{}}{{{h{dc}}}{{h{de}}}{}{}}{{{h{Ff}}{h{Ff}}}Gb}{{{h{Ff}}{h{dHb}}}Hf}0{NlFf}{AGbFf}{AGdFf}{AGfFf}{AGhFf}{AGjFf}{AGlFf}{cc{}}>{{{h{c}}}Fn{}}{c{{Bf{e}}}{}{}}0{{{h{c}}}Mb{}}{ce{}{}}```````````````````````````````````???????>>>>>>>{{{h{AGn}}}AGn}{{{h{AH`}}}AH`}{{{h{AHb}}}AHb}{{{h{Lb}}}Lb}{{{h{AHd}}}AHd}{{{h{ACd}}}ACd}{{{h{c}}{h{de}}}Ab{}{}}00000``{{}AHd}{{{h{AGn}}{h{AGn}}}Gb}{{{h{AH`}}{h{AH`}}}Gb}{{{h{AHb}}{h{AHb}}}Gb}{{{h{Lb}}{h{Lb}}}Gb}{{{h{AHd}}{h{AHd}}}Gb}{{{h{AGb}}{h{AGb}}}Gb}{{{h{c}}{h{e}}}Gb{}{}}00000000000{{{h{AGn}}{h{dHb}}}Hf}{{{h{AH`}}{h{dHb}}}Hf}{{{h{AHb}}{h{dHb}}}Hf}{{{h{Lb}}{h{dHb}}}Hf}{{{h{AHd}}{h{dHb}}}Hf}{{{h{AGb}}{h{dHb}}}Hf}0{{{h{ACd}}{h{dHb}}}Hf}{cc{}}0{GbAHb}1{AH`Lb}2222{{{h{Lb}}{h{{An{Fn{N`{ADn}}}}}}}{{Bf{AHdAGb}}}}{{{h{AGn}}{h{dc}}}AbJl}{{{h{AHd}}{h{dc}}}AbJl}{{{h{AH`}}}Fn}`{ce{}{}}000000{{{h{AH`}}}Gb}{{{h{AHb}}}Gb}{{{h{AHd}}}Gb}`{{{h{AHd}}{h{AHd}}}{{Fl{Eh}}}}{{{h{Lb}}}Gb}`{{{h{AGn}}c}BfLj}{{{h{AH`}}c}BfLj}{{{h{AHb}}c}BfLj}{{{h{Lb}}c}BfLj}{{{h{AHd}}c}BfLj}`{{{h{c}}}e{}{}}00000{{{h{c}}}Fn{}}{c{{Bf{e}}}{}{}}0000000000000{{{h{c}}}Mb{}}000000>>>>>>>``````````````````````````````````````{{{h{c}}}{{h{e}}}{}{}}00000000000{{{h{dc}}}{{h{de}}}{}{}}00000000000{{AHfL`}{{Bf{AHhFf}}}}{{{AHj{c}}L`}{{Bf{AHhFf}}}{{AHl{AAn}}}}{{{AHn{c}}L`}{{Bf{AHhFf}}}{{AHl{AB`}}}}{{{AI`{c}}L`}{{Bf{AHhFf}}}{{AHl{AB`}}}}{{{AIb{c}}L`}{{Bf{AHhFf}}}{{AHl{AId}}}}{{{AIf{c}}L`}{{Bf{AHhFf}}}{{AIh{AAn}}}}{{{AIj{c}}L`}{{Bf{AHhFf}}}{{AIh{AAn}}}}{{{AIl{c}}L`}{{Bf{AHhFf}}}{{AIh{AB`}}}}{{{AIn{c}}L`}{{Bf{AHhFf}}}{{AIh{AB`}}}}{{{AJ`{c}}L`}{{Bf{AHhFf}}}{{AIh{AB`}}}}{{{AJb{c}}L`}{{Bf{AHhFf}}}{{AIh{AB`}}}}{{{AJd{c}}L`}{{Bf{AHhFf}}}{{AIh{AId}}}}{{{AJf{c}}L`}{{Bf{AHhFf}}}{{AIh{AId}}}}{{{h{{AHj{c}}}}}{{AHj{c}}}{Al{AHl{AAn}}}}{{{h{{AHn{c}}}}}{{AHn{c}}}{Al{AHl{AB`}}}}{{{h{{AI`{c}}}}}{{AI`{c}}}{Al{AHl{AB`}}}}{{{h{{AIb{c}}}}}{{AIb{c}}}{Al{AHl{AId}}}}{{{h{{AIf{c}}}}}{{AIf{c}}}{Al{AIh{AAn}}}}{{{h{{AIj{c}}}}}{{AIj{c}}}{Al{AIh{AAn}}}}{{{h{{AIl{c}}}}}{{AIl{c}}}{Al{AIh{AB`}}}}{{{h{{AIn{c}}}}}{{AIn{c}}}{Al{AIh{AB`}}}}{{{h{{AJ`{c}}}}}{{AJ`{c}}}{Al{AIh{AB`}}}}{{{h{{AJb{c}}}}}{{AJb{c}}}{Al{AIh{AB`}}}}{{{h{{AJd{c}}}}}{{AJd{c}}}{Al{AIh{AId}}}}{{{h{{AJf{c}}}}}{{AJf{c}}}{Al{AIh{AId}}}}{{{h{c}}{h{de}}}Ab{}{}}00000000000{{{h{{AHj{c}}}}{h{dHb}}}Hf{Hh{AHl{AAn}}}}{{{h{{AHn{c}}}}{h{dHb}}}Hf{Hh{AHl{AB`}}}}{{{h{{AI`{c}}}}{h{dHb}}}Hf{Hh{AHl{AB`}}}}{{{h{{AIb{c}}}}{h{dHb}}}Hf{Hh{AHl{AId}}}}{{{h{{AIf{c}}}}{h{dHb}}}Hf{Hh{AIh{AAn}}}}{{{h{{AIj{c}}}}{h{dHb}}}Hf{Hh{AIh{AAn}}}}{{{h{{AIl{c}}}}{h{dHb}}}Hf{Hh{AIh{AB`}}}}{{{h{{AIn{c}}}}{h{dHb}}}Hf{Hh{AIh{AB`}}}}{{{h{{AJ`{c}}}}{h{dHb}}}Hf{Hh{AIh{AB`}}}}{{{h{{AJb{c}}}}{h{dHb}}}Hf{Hh{AIh{AB`}}}}{{{h{{AJd{c}}}}{h{dHb}}}Hf{Hh{AIh{AId}}}}{{{h{{AJf{c}}}}{h{dHb}}}Hf{Hh{AIh{AId}}}}{cc{}}00000000000{ce{}{}}00000000000{{AHh{h{{Lf{Ld}}}}L`}{{Bf{{C`{KfKh}}Ff}}}}{{c{h{{Lf{Ld}}}}L`}{{Bf{{C`{{Nh{Ol}}{An{OlAFb}}}}Ff}}}{}}00000000000{{{h{c}}}e{}{}}00000000000{c{{Bf{e}}}{}{}}00000000000000000000000{{{h{c}}}Mb{}}00000000000555555555555``````````````````````````````{{{h{c}}}{{h{e}}}{}{}}00{{{h{dc}}}{{h{de}}}{}{}}00{{{h{AJh}}}AJh}{{{h{c}}{h{de}}}Ab{}{}}{{{h{AJh}}{h{dHb}}}Hf}0{{{h{Jd}}{h{dHb}}}Hf}0{{{h{Df}}{h{dHb}}}Hf}0={FfJd}{AJjJd}{AJhJd}{NdJd}{cc{}}{AGbJd}1{ce{}{}}00{{{h{c}}}e{}{}}{{{h{c}}}Fn{}}00{c{{Bf{e}}}{}{}}00000{{{h{c}}}Mb{}}00444``````````{{{h{c}}}{{h{e}}}{}{}}{{{h{dc}}}{{h{de}}}{}{}}{{{h{AJl}}}{{Fl{Fn}}}}{{{h{AJl}}}Fn}{c{{Bf{AJl}}}G`}{{{h{f}}{h{Mf}}Gb}{{Bf{AJl{h{Mf}}}}}}{{{h{AJl}}{h{dHb}}}Hf}0={{{h{Mf}}}{{Bf{AJlc}}}{}}<``{{{h{AJl}}c}BfLj};::9=```````````````````````````````````````````{{}AJn}{{}Ob}{{OlBb}{{Bf{OnA@`}}}};;;;;;;;;;;;::::::::::::{{{h{{AK`{ce}}}}{h{g}}}{{A@d{{A@b{c}}}}}{O`Nn}Oh{{A@f{c}}}}{{{h{{Od{c{Oh{}{{A@h{e}}}}}}}}}{{Bf{AbA@j}}}Nn{{AAl{}{{A@l{A@n}}{AA`{AAb}}{AAd{AAf}}{AAh{AAj}}}}NnNnNnNn}}00000{{{h{c}}}{{Bf{AbA@j}}}Nn}{{{h{{Of{c{Oh{}{{A@h{e}}}}}}}}}{{Bf{AbA@j}}}Nn{{AAl{}{{A@l{A@n}}{AA`{AAb}}{AAd{AAf}}{AAh{AAj}}}}NnNnNnNn}}{{{h{{Cj{{N`{Ch}}}}}}}{{Bf{AbA@j}}}}{{{h{{AKb{ce}}}}}{{AKb{ce}}}AlOh}{{{h{Ob}}}Ob}{{{h{AKd}}}AKd}{{{h{{AK`{ce}}}}}{{AK`{ce}}}{AlNn}{AlOh}}{{{h{Ol}}}Ol}{{{h{AFb}}}AFb}{{{h{AKf}}}AKf}{{{h{AKh}}}AKh}{{{h{AKj}}}AKj}{{{h{c}}{h{de}}}Ab{}{}}00000000{{{h{{AK`{ce}}}}{h{{AK`{ce}}}}}Eh{ABbNn}{ABbOh}}{{{h{Ol}}{h{Ol}}}Eh}{{{h{AKf}}{h{AKf}}}Eh}{{{h{AKj}}{h{AKj}}}Eh}`{{}AKd}{{{h{{AKb{ce}}}}}{{h{g}}}{}Oh{}}{{OlBb}{{Bf{OnA@`}}}}{c{{Bf{Ol}}}G`}{{{h{{AK`{ce}}}}}Af{O`Nn}Oh}{{{h{Ob}}{h{Ob}}}Gb}{{{h{AGl}}{h{AGl}}}Gb}{{{h{{AK`{ce}}}}{h{{AK`{ce}}}}}Gb{GfNn}{GfOh}}{{{h{Ol}}{h{Ol}}}Gb}{{{h{AFb}}{h{AFb}}}Gb}{{{h{AKf}}{h{AKf}}}Gb}{{{h{AKh}}{h{AKh}}}Gb}{{{h{AKj}}{h{AKj}}}Gb}{{{h{c}}{h{e}}}Gb{}{}}0000000000000{{{h{{AKl{c}}}}{h{dHb}}}Hf{HhOh}}{{{h{Ob}}{h{dHb}}}Hf}{{{h{AKd}}{h{dHb}}}Hf}{{{h{AGl}}{h{dHb}}}Hf}0{{{h{{AK`{ce}}}}{h{dHb}}}{{Bf{AbHd}}}NnOh}0{{{h{Ol}}{h{dHb}}}{{Bf{AbHd}}}}0{{{h{AFb}}{h{dHb}}}{{Bf{AbHd}}}}0{{{h{AKf}}{h{dHb}}}{{Bf{AbHd}}}}{{{h{AKh}}{h{dHb}}}{{Bf{AbHd}}}}{{{h{AKj}}{h{dHb}}}{{Bf{AbHd}}}}{{{h{{AK`{ce}}}}g}GbNnOh{{ACj{{h{c}}}{{ACh{Gb}}}}}}{AKn{{AL`{c}}}Oh}{cc{}}{ALb{{AL`{c}}}Oh}1111{AGjAGl}{NlAGl}333{OnOl}4444{{OlAJn}{{AKl{c}}}Oh}{{AFbAJn}{{AKl{c}}}Oh}{{{h{Mf}}}{{Bf{Ol}}}}{{{h{Mf}}}{{Bf{AFb}}}}{{{h{ADl}}}{{Bf{{AK`{ce}}Nl}}}{ALdNn}Oh}{{{h{Ol}}}{{Fl{ALf}}}}{{{h{Ol}}}{{N`{ALf}}}}{c{{Bf{{AKb{{ALn{}{{ALh{e}}{ALj{c}}{ALl{g}}}}i}}g}}}{}{{AM`{{Cj{Ch}}}}AMb}HhOh}{{}{{Bf{{AKb{AMdc}}e}}}Oh{}}{{{h{dc}}}{{Bf{{AKb{AMde}}g}}}{AMfAMh}Oh{}}{{c{h{de}}}{{Bf{{AKb{{ALn{}{{ALh{g}}{ALj{c}}{ALl{i}}}}k}}i}}}{}{AMfAMh}{{AM`{{Cj{Ch}}}}AMb}HhOh}{{ce}{{Bf{{AKb{{ALn{}{{ALh{e}}{ALj{c}}{ALl{g}}}}i}}g}}}{}{{AM`{{Cj{Ch}}}}AMb}HhOh}{c{{Bf{{AKb{AMde}}g}}}{}Oh{}}{{{h{{AL`{c}}}}}GbOh}{{{h{Ol}}}Gb}{{{h{{AK`{ce}}}}{h{dg}}}Ab{AEbNn}{AEbOh}Jl}{{{h{Ol}}{h{dc}}}AbJl}{{{h{AKf}}{h{dc}}}AbJl}{{{h{AKj}}{h{dc}}}AbJl}{ce{}{}}00000000000{OlAMj}{AHl{{Bf{{AKl{c}}AGl}}}Oh}{{AIh{Fl{AMl}}ALf}{{Bf{{AKl{c}}AGl}}}Oh}{{{AKb{ec}}{Fl{AMl}}ALf}{{Bf{{AKl{c}}AGl}}}Oh{{AIh{c}}}}{{{AKb{ec}}}{{Bf{{AKl{c}}AGl}}}Oh{{AHl{c}}}}{{{AKl{c}}}{{Bf{{AKl{c}}AGl}}}Oh}{Ol{{Bf{{AKl{c}}AGl}}}Oh}{AFb{{Bf{{AKl{c}}AGl}}}Oh}{AIh{{Bf{{AL`{c}}AGl}}}Oh}{{{AL`{c}}}{{Bf{{AL`{c}}AGl}}}Oh}{{{AKb{ec}}}{{Bf{{AL`{c}}AGl}}}Oh{{AIh{c}}}}{{{AKb{ce}}}c{}Oh}{Ol{{N`{Ol}}}}{AFb{{N`{AFb}}}}{{{AL`{c}}L`}{{Fl{ALb}}}Oh}{{{AL`{c}}L`{h{{Lf{e}}}}}AKnOhAFd}{{{h{Ol}}}Gb}{{}Gb}{{{h{Ob}}}Gb}2{{{h{AFb}}}Gb}212133{{{h{{AK`{ce}}}}}ADnNnOh}``{{{h{{AK`{ce}}}}}{{Bf{{AEh{c}}Nl}}}NnOh}{{}AJn}{{{h{Ol}}}AMn}{{{h{{Od{c{Oh{}{{A@h{e}}}}}}}}}{{Fl{ADn}}}Nn{{AAl{}{{A@l{A@n}}{AA`{AAb}}{AAd{AAf}}{AAh{AAj}}}}NnNnNnNn}}44{{{h{AJn}}{h{AJn}}}AJn}5{{}{{h{Mf}}}}{{ADn{N`{c}}}{{Bf{{AK`{ce}}Nl}}}NnOh}{{{h{Ol}}}ADn}``{{{h{{Od{c{Oh{}{{A@h{e}}}}}}}}}{{Bf{AbNl}}}Nn{{AAl{}{{A@l{A@n}}{AA`{AAb}}{AAd{AAf}}{AAh{AAj}}}}NnNnNnNn}}{{{AKl{c}}AJn}{{AKl{c}}}Oh}{{{h{{AK`{ce}}}}{h{{AK`{ce}}}}}{{Fl{Eh}}}{AFfNn}{AFfOh}}{{{h{Ol}}{h{Ol}}}{{Fl{Eh}}}}{{{h{AKf}}{h{AKf}}}{{Fl{Eh}}}}{{{h{AKj}}{h{AKj}}}{{Fl{Eh}}}}{{{h{c}}}ADnNn}{{{h{{AK`{ce}}}}}{{h{{Cj{c}}}}}NnOh}{{{h{{AK`{ce}}}}}{{Bf{AbNl}}}NnOh}{{{h{{AK`{ce}}}}g}{{Bf{{N`{{N`{Ch}}}}Nl}}}{O`Nn}Oh{{AE`{c}}}}{{{h{{AK`{ce}}}}}ADnNnOh}{{{h{Ol}}c}BfLj}{{}AFl}{{{h{{AK`{ce}}}}}{{Of{ce}}}{O`Nn}Oh}{{}AJn}{{{h{c}}}e{}{}}00000000{{{h{AFb}}{h{{Lf{c}}}}}{{Bf{OlAN`}}}AFd}{{{h{c}}}Fn{}}000{{{h{{Od{c{Oh{}{{A@h{e}}}}}}}}}{{Bf{AbNl}}}Nn{{AAl{}{{A@l{A@n}}{AA`{AAb}}{AAd{AAf}}{AAh{AAj}}}}NnNnNnNn}}0{{{h{{AK`{ce}}}}{h{dk}}}{{Bf{{AK`{ge}}{AFn{i}}}}}NnOhNn{}{{AG`{cgi}}}}{c{{Bf{e}}}{}{}}00000000000000000000000{{{h{c}}}Mb{}}00000000000{ce{}{}}00000000000`{{{h{ANb}}}{{Fl{Dh}}}}{{{h{ANb}}}{{Fl{Dl}}}}{{{h{ANb}}ADn}{{Fl{K`}}}}`{{{h{Ej}}{h{Mf}}{h{{Cj{{h{{Cj{{h{Mf}}}}}}}}}}}{{Bf{AbANd}}}}````````````````````````````````````{{{h{dJf}}ANfl{A`{n}}}{{Fl{{A`{n}}}}}}``{{{h{Jf}}{h{{Lf{Ld}}}}}Kh}`{{{h{c}}}{{h{e}}}{}{}}0000000{{{h{dc}}}{{h{de}}}{}{}}0000000{{Kh{h{{Nh{Ol}}}}{h{{Lf{Ld}}}}}Jf}{{{h{ANf}}}ANf}{{{h{ANh}}}ANh}{{{h{{ANj{c}}}}}{{ANj{c}}}{AlANlHhAl}}{{{h{l}}}l}{{{h{Jf}}}Jf}{{{h{Gn}}}Gn}{{{h{ANn}}}ANn}{{{h{c}}{h{de}}}Ab{}{}}000000{{{h{ANf}}{h{ANf}}}Eh}{{{h{l}}{h{l}}}Eh}{{}l}{{}Jf}{{}Gn}{{}ANn}{{{h{{ANj{c}}}}}{{h{e}}}{ANlHhAl}{}}{{{h{AO`}}}{{Fl{AFb}}}}0{{{h{{ANj{AOb}}}}}{{Fl{AFb}}}}{{{h{{ANj{{AOd{ALb}}}}}}}{{Fl{AFb}}}}{{{h{{ANj{{AOf{ALb}}}}}}}{{Fl{AFb}}}}{{{h{ANf}}{h{ANf}}}Gb}{{{h{ANh}}{h{ANh}}}Gb}{{{h{l}}{h{l}}}Gb}{{{h{ANn}}{h{ANn}}}Gb}{{{h{c}}{h{e}}}Gb{}{}}0000000{{{h{Jf}}ANf}{{Fl{{h{{A`{n}}}}}}}}{{{h{ANf}}{h{dHb}}}Hf}{{{h{H`}}{h{dHb}}}Hf}0{{{h{ANh}}{h{dHb}}}Hf}{{{h{{ANj{c}}}}{h{dHb}}}Hf{HhANlHhAl}}{{{h{l}}{h{dHb}}}Hf}{{{h{Jf}}{h{dHb}}}Hf}{{{h{Gn}}{h{dHb}}}Hf}{{{h{ANn}}{h{dHb}}}Hf}{AAjANf}{AMnANf}{cc{}}0000000{{{h{ANf}}{h{dc}}}AbJl}{{{h{AO`}}{h{{Lf{Ld}}}}}ANf}{{{h{{ANj{{AOf{ALb}}}}}}{h{{Lf{Ld}}}}}ANf}{{{h{{ANj{{AOd{ALb}}}}}}{h{{Lf{Ld}}}}}ANf}{{{h{{ANj{AOb}}}}{h{{Lf{Ld}}}}}ANf}{{{h{Jf}}}{{N`{{h{ANf}}}}}}{ce{}{}}0000000{{cANh}{{ANj{c}}}{ANlHhAl}}{{}Jf}{{{h{ANf}}{h{ANf}}}{{Fl{Eh}}}}{{{h{l}}{h{l}}}{{Fl{Eh}}}}{{{h{dJf}}ANfl}{{Fl{{A`{n}}}}}}{{{h{AOh}}{h{dGl}}ADn{h{Gn}}{h{{Lf{Ld}}}}}{{Bf{AbH`}}}}{{{h{{ANj{AOb}}}}{h{dGl}}ADn{h{Gn}}{h{{Lf{Ld}}}}}{{Bf{AbH`}}}}{{{h{{ANj{{AOd{ALb}}}}}}{h{dGl}}ADn{h{Gn}}{h{{Lf{Ld}}}}}{{Bf{AbH`}}}}{{{h{{ANj{{AOf{ALb}}}}}}{h{dGl}}ADn{h{Gn}}{h{{Lf{Ld}}}}}{{Bf{AbH`}}}}{{{h{n}}{h{dGl}}{h{Gn}}{h{{Lf{Ld}}}}}{{Bf{AbH`}}}}{{{h{c}}{h{dGl}}{h{Gn}}{h{{Lf{Ld}}}}}{{Bf{AbH`}}}{}}`{{{h{Jf}}}{{N`{{h{{A`{n}}}}}}}}`{{{h{c}}}e{}{}}000000{{{h{c}}}Fn{}}``{c{{Bf{e}}}{}{}}000000000000000{{{h{c}}}Mb{}}0000000{ce{}{}}0000000````````````````{{{h{d{Dd{c}}}}{h{e}}}{{h{d{Dd{c}}}}}{}{{AOl{AOj}}}}{{{h{d{Dd{c}}}}JjJbAEl}{{Bf{{h{d{Dd{c}}}}AOn}}}{}}{{{h{d{Dd{c}}}}JjJbAElLh}{{Bf{{h{d{Dd{c}}}}AOn}}}{}}{{{h{d{Dd{c}}}}}{{h{d{Dd{c}}}}}{}}{{{h{d{Dd{c}}}}AfDh}{{h{d{Dd{c}}}}}{}}{{{h{d{Dd{c}}}}Jj}{{h{d{Dd{c}}}}}{}}{{{h{d{Dd{c}}}}Jj}{{Bf{{h{d{Dd{c}}}}B@`}}}{}}{{{h{d{Dd{c}}}}{h{{Cj{Jj}}}}}{{Bf{{h{d{Dd{c}}}}B@`}}}{}}{{{h{d{Dd{c}}}}Gb}{{h{d{Dd{c}}}}}{}}{{{h{c}}}{{h{e}}}{}{}}0000{{{h{dc}}}{{h{de}}}{}{}}0000{{{h{d{Dd{c}}}}B@b}{{h{d{Dd{c}}}}}{}}{{{h{{Dd{c}}}}}{{Dd{c}}}Al}{{{h{B@d}}}B@d}{{{h{B@b}}}B@b}{{{h{c}}{h{de}}}Ab{}{}}00{{{h{B@b}}{h{B@b}}}Eh}{{{Dd{c}}e}{{Dd{e}}}{}Mn}{{{h{d{Dd{c}}}}Bb}{{h{d{Dd{c}}}}}{}}{{}B@d}{{}B@b}{{{h{d{Dd{c}}}}}{{h{d{Dd{c}}}}}{}}{{{h{d{Dd{c}}}}Af}{{h{d{Dd{c}}}}}{}}11{{{h{d{Dd{c}}}}Lh}{{h{d{Dd{c}}}}}{}}{{{h{B@b}}{h{B@b}}}Gb}{{{h{c}}{h{e}}}Gb{}{}}0{{{h{d{Dd{c}}}}Dh}{{h{d{Dd{c}}}}}{}}{{{h{d{Dd{c}}}}Dl}{{h{d{Dd{c}}}}}{}}{{{Dd{c}}}{{Bf{GlJd}}}Mn}{{{Dd{c}}{h{de}}}{{Bf{GlJd}}}MnAMh}{{{h{{Dd{c}}}}{h{dHb}}}HfHh}{{{h{B@`}}{h{dHb}}}Hf}0{{{h{AOn}}{h{dHb}}}Hf}0{{{h{B@d}}{h{dHb}}}Hf}{{{h{B@b}}{h{dHb}}}Hf}{cc{}}0000{{{h{B@b}}{h{dc}}}AbJl}?{ce{}{}}0000{{{h{d{Dd{c}}}}}{{h{d{Dd{c}}}}}{}}{{{h{d{Dd{c}}}}B@f}{{h{d{Dd{c}}}}}{}}11{{{h{d{Dd{c}}}}B@d}{{h{d{Dd{c}}}}}{}}{{{h{B@b}}{h{B@b}}}{{Fl{Eh}}}}{{{h{d{Dd{c}}}}{An{Fn{N`{ADn}}}}j}{{h{d{Dd{c}}}}}{}}{{{h{d{Dd{c}}}}{N`{{C`{AfDh}}}}}{{h{d{Dd{c}}}}}{}}{{{h{d{Dd{c}}}}J`}{{h{d{Dd{c}}}}}{}}{{{h{B@d}}{h{dBl}}}Ab}{{{h{B@d}}{h{dBl}}{h{dc}}}AbAMh}{{{h{c}}}e{}{}}00{{{h{c}}}Fn{}}0{c{{Bf{e}}}{}{}}000000000{{{h{c}}}Mb{}}0000{{{h{d{Dd{c}}}}{N`{Jj}}}{{h{d{Dd{c}}}}}{}}{{{h{d{Dd{c}}}}B@h}{{h{d{Dd{c}}}}}{}}?????````","D":"G@`","p":[[5,"Balance",0,1934],[0,"mut"],[5,"Wallet",0,1935],[1,"reference"],[6,"KeychainKind",0,1936],[5,"SignerOrdering",1628,1937],[10,"TransactionSigner",1628,1937],[5,"Arc",1938],[1,"unit"],[17,"Item"],[5,"ScriptBuf",1939],[8,"Indexed",1940],[10,"Iterator",1941],[10,"Clone",1942],[5,"BTreeMap",1943],[5,"Block",1944],[1,"u32"],[5,"CannotConnectError",1945],[6,"Result",1946],[5,"BlockId",1947],[6,"ApplyHeaderError",1945],[5,"Transaction",1948],[1,"u64"],[1,"tuple"],[10,"IntoIterator",1949],[5,"Update",0,1935],[10,"Into",1950],[1,"u8"],[1,"slice"],[5,"ConfirmationBlockTime",1947],[5,"TxGraph",1951],[5,"Txid",1948],[8,"DefaultCoinSelectionAlgorithm",446,1952],[5,"TxBuilder",1815,1953],[6,"BuildFeeBumpError",1206,1954],[5,"Amount",1955],[6,"CalculateFeeError",1951],[5,"FeeRate",1956],[5,"CheckPointIter",1945],[5,"LocalOutput",0,1936],[5,"WeightedUtxo",0,1936],[6,"Utxo",0,1936],[5,"ChangeSet",0,1957],[6,"Ordering",1958],[5,"Transaction",1959],[5,"Connection",1960],[5,"Store",1961],[5,"CreateParams",0,1962],[10,"IntoWalletDescriptor",545],[8,"PersistedWallet",0,1963],[6,"Error",806],[5,"LoadParams",0,1962],[5,"AddressInfo",0,1935],[6,"Option",1964],[5,"String",1965],[10,"Deserializer",1966],[1,"bool"],[6,"LoadWithPersistError",0,1963],[10,"PartialEq",1958],[6,"LoadError",0,1935],[6,"LoadMismatch",0,1935],[5,"Psbt",1967],[5,"SignOptions",1628,1937],[6,"SignerError",1628,1937],[5,"Formatter",1968],[5,"Error",1968],[8,"Result",1968],[10,"Debug",1968],[10,"Display",1968],[6,"CreateWithPersistError",0,1963],[6,"ApplyBlockError",0,1935],[5,"ChangeSet",1951],[5,"ChangeSet",1969],[5,"ChangeSet",1970],[5,"ChangeSet",1945],[5,"FullScanResult",1971],[5,"SyncResult",1971],[8,"Result",1960],[5,"BlockHash",1944],[5,"PsbtSighashType",1972],[5,"Input",1972],[6,"CreateTxError",1206,1954],[5,"SignersContainer",1628,1937],[5,"CanonicalTx",1951],[5,"OutPoint",1948],[10,"Hasher",1973],[5,"AlterCheckPointError",1945],[5,"TxOut",1948],[10,"IsDust",0,1974],[5,"Script",1975],[8,"ExtendedDescriptor",545],[8,"KeyMap",1306,1976],[5,"CheckPoint",1945],[10,"DoubleEndedIterator",1977],[5,"LocalChain",1945],[6,"Network",1978],[5,"Policy",839],[6,"All",1979],[5,"Secp256k1",1980],[5,"Sequence",1948],[10,"Serializer",1981],[5,"KeychainTxOutIndex",1969],[5,"FullScanRequest",1971],[5,"SyncRequest",1971],[5,"TypeId",1982],[5,"TxNode",1951],[1,"str"],[5,"LargestFirstCoinSelection",446,1952],[5,"OldestFirstCoinSelection",446,1952],[5,"BranchAndBoundCoinSelection",446,1952],[10,"CoinSelectionAlgorithm",446,1952],[5,"Vec",1983],[5,"CoinSelectionResult",446,1952],[6,"Error",446,1952],[6,"Excess",446,1952],[6,"Descriptor",545,1976],[5,"Address",1984],[6,"Error",1985],[10,"MiniscriptKey",1985],[10,"ToPublicKey",1985],[6,"ScriptContextEnum",1306],[5,"Miniscript",545,1986],[6,"Terminal",1987],[10,"ScriptContext",1306,1988],[6,"Tree",1989],[6,"DescriptorPublicKey",1306,1990],[5,"DefiniteDescriptorKey",1990],[6,"ConversionError",1990],[6,"Placeholder",1991],[5,"Satisfaction",1991],[10,"AssetProvider",1992],[17,"Key"],[6,"ScriptContextError",1988],[17,"Sha256"],[5,"Hash",1993],[17,"Hash256"],[5,"Hash",1994],[17,"Ripemd160"],[5,"Hash",1995],[17,"Hash160"],[5,"Hash",1996],[10,"ParseableKey",1987],[6,"Legacy",545,1988],[6,"Segwitv0",545,1988],[10,"Ord",1958],[5,"PublicKey",1997],[10,"Verification",1998],[6,"DescriptorType",1976],[5,"DescriptorId",1999],[10,"FromStrKey",2000],[5,"ExtParams",2001],[6,"AnalysisError",2001],[10,"ExtractPolicy",545],[6,"BuildSatisfaction",839],[5,"Range",2002],[17,"Output"],[10,"FnMut",2003],[5,"Pkh",2004],[5,"Wpkh",2005],[5,"Wsh",2005],[5,"Tr",2006],[5,"Bare",2004],[5,"Sh",2007],[5,"Type",2008],[5,"ExtData",2009],[5,"Tree",2010],[1,"usize"],[10,"Satisfier",1991],[10,"Hash",1973],[5,"Iter",2011],[5,"PkIter",2011],[6,"Policy",2012],[6,"LiftError",2013],[5,"Weight",2014],[6,"BareCtx",1988],[6,"TapTree",2006],[6,"DescriptorSecretKey",1306,1990],[10,"Signing",1998],[10,"PartialOrd",1958],[5,"Plan",1992],[5,"TxIn",1948],[6,"SigType",1988],[6,"TranslateErr",1985],[10,"Translator",1985],[6,"PolicyError",839],[6,"HexToBytesError",2015],[6,"ParsePublicKeyError",1997],[6,"Error",2016],[6,"Error",2017],[6,"KeyError",1306],[6,"PkOrF",839],[6,"SatisfiableItem",839],[6,"Satisfaction",839],[5,"Condition",839],[10,"DescriptorTemplate",1022],[8,"DescriptorTemplateOut",1022],[5,"P2Pkh",1022],[10,"IntoDescriptorKey",1306],[5,"P2Wpkh_P2Sh",1022],[5,"P2Wpkh",1022],[5,"P2TR",1022],[6,"Tap",1988],[5,"Bip44",1022],[10,"DerivableKey",1306],[5,"Bip44Public",1022],[5,"Bip49",1022],[5,"Bip49Public",1022],[5,"Bip84",1022],[5,"Bip84Public",1022],[5,"Bip86",1022],[5,"Bip86Public",1022],[6,"MiniscriptPsbtError",1206,1954],[6,"Error",2018],[5,"FullyNodedExport",1283,2019],[8,"ValidNetworks",1306],[5,"SortedMultiVec",1306,2020],[5,"GeneratedKey",1306],[5,"PrivateKeyGenerateOptions",1306],[5,"SinglePub",1306,1990],[5,"SinglePriv",1306,1990],[6,"SinglePubKey",1306,1990],[6,"DescriptorKey",1306],[5,"Xpub",2017],[6,"ExtendedKey",1306],[5,"Xpriv",2017],[10,"FromStr",2021],[5,"DerivationPath",2017],[17,"Entropy"],[17,"Options"],[17,"Error"],[10,"GeneratableKey",1306],[10,"AsMut",1950],[10,"Default",2022],[10,"GeneratableDefaultOptions",1306],[10,"CryptoRng",2023],[10,"RngCore",2023],[5,"Assets",1992],[8,"KeySource",2017],[5,"Fingerprint",2017],[5,"DescriptorKeyParseError",1990],[10,"PsbtUtils",1622],[6,"Error",2024],[6,"SignerId",1628,1937],[6,"SignerContext",1628,1937],[5,"SignerWrapper",1628,1937],[10,"Sized",2025],[6,"TapLeavesOptions",1628,1937],[10,"SignerCommon",1628,1937],[5,"PrivateKey",1997],[5,"DescriptorMultiXKey",1990],[5,"DescriptorXKey",1990],[10,"InputSigner",1628,1937],[5,"PushBytes",2026],[10,"AsRef",1950],[6,"AddForeignUtxoError",1815,1953],[6,"AddUtxoError",1815,1953],[6,"ChangeSpendPolicy",1815,1953],[6,"TxOrdering",1815,1953],[6,"LockTime",2027],[1,"i32"],[15,"InvalidTxid",1930],[15,"UnexpectedConnectedToHash",432],[15,"Network",434],[15,"Genesis",434],[15,"Descriptor",434],[15,"Custom",1932],[15,"Foreign",443],[15,"InsufficientFunds",538],[15,"Change",540],[15,"NoChange",540],[8,"DerivedDescriptor",545],[15,"PsbtTimelocks",998],[15,"Complete",1001],[15,"Partial",1001],[15,"PartialComplete",1001],[15,"Sha256Preimage",1012],[15,"Hash256Preimage",1012],[15,"Ripemd160Preimage",1012],[15,"Hash160Preimage",1012],[15,"Thresh",1012],[15,"Multisig",1012],[15,"AbsoluteTimelock",1012],[15,"RelativeTimelock",1012],[15,"RbfSequenceCsv",1277],[15,"LockTime",1277],[15,"FeeTooLow",1277],[15,"FeeRateTooLow",1277],[8,"WalletExport",1283],[10,"ExtScriptContext",1306],[15,"Tap",1814]],"r":[[0,1953],[1,1953],[2,1935],[3,1935],[4,1934],[8,1957],[9,1953],[10,1962],[11,1963],[19,545],[24,1974],[25,1936],[26,1935],[27,1935],[28,1962],[29,1963],[31,1936],[41,1963],[43,1937],[44,1953],[45,1953],[49,1935],[50,1936],[53,1935],[54,1936],[127,1935],[177,1935],[178,1935],[310,1940],[325,1935],[326,1935],[334,545],[386,1935],[429,1935],[448,1952],[450,1952],[451,1952],[452,1952],[453,1952],[454,1952],[456,1952],[458,1952],[481,1952],[549,1976],[551,1990],[558,1988],[559,1986],[564,839],[565,1988],[566,1988],[600,805],[1206,1954],[1209,1954],[1217,1954],[1283,2019],[1284,2019],[1309,1990],[1310,1990],[1325,1976],[1335,1988],[1340,1990],[1341,1990],[1342,1990],[1343,2020],[1626,2028],[1627,2028],[1635,1937],[1652,1937],[1653,1937],[1654,1937],[1655,1937],[1656,1937],[1657,1937],[1658,1937],[1659,1937],[1661,1937],[1662,1937],[1815,1953],[1816,1953],[1819,1953],[1826,1953],[1827,1953]],"b":[[130,"impl-PersistWith%3CTransaction%3C\'c%3E%3E-for-Wallet"],[131,"impl-PersistWith%3CConnection%3E-for-Wallet"],[132,"impl-PersistWith%3CStore%3CChangeSet%3E%3E-for-Wallet"],[133,"impl-Wallet"],[181,"impl-Debug-for-Balance"],[182,"impl-Display-for-Balance"],[188,"impl-Debug-for-LoadWithPersistError%3CE%3E"],[189,"impl-Display-for-LoadWithPersistError%3CE%3E"],[190,"impl-Display-for-CreateWithPersistError%3CE%3E"],[191,"impl-Debug-for-CreateWithPersistError%3CE%3E"],[194,"impl-Display-for-AddressInfo"],[195,"impl-Debug-for-AddressInfo"],[196,"impl-Debug-for-LoadError"],[197,"impl-Display-for-LoadError"],[199,"impl-Debug-for-ApplyBlockError"],[200,"impl-Display-for-ApplyBlockError"],[209,"impl-From%3CChangeSet%3CConfirmationBlockTime%3E%3E-for-ChangeSet"],[211,"impl-From%3CChangeSet%3E-for-ChangeSet"],[212,"impl-From%3CChangeSet%3CConfirmationBlockTime,+ChangeSet%3E%3E-for-ChangeSet"],[213,"impl-From%3CChangeSet%3E-for-ChangeSet"],[219,"impl-From%3CFullScanResult%3CKeychainKind%3E%3E-for-Update"],[220,"impl-From%3CSyncResult%3E-for-Update"],[273,"impl-PersistWith%3CTransaction%3C\'c%3E%3E-for-Wallet"],[274,"impl-PersistWith%3CConnection%3E-for-Wallet"],[275,"impl-PersistWith%3CStore%3CChangeSet%3E%3E-for-Wallet"],[276,"impl-Wallet"],[300,"impl-PersistWith%3CConnection%3E-for-Wallet"],[301,"impl-PersistWith%3CTransaction%3C\'c%3E%3E-for-Wallet"],[302,"impl-PersistWith%3CStore%3CChangeSet%3E%3E-for-Wallet"],[328,"impl-Wallet"],[329,"impl-Staged-for-Wallet"],[487,"impl-Display-for-Error"],[488,"impl-Debug-for-Error"],[638,"impl-Descriptor%3CDefiniteDescriptorKey%3E"],[639,"impl-Descriptor%3CDescriptorPublicKey%3E"],[666,"impl-Display-for-Descriptor%3CPk%3E"],[667,"impl-Debug-for-Descriptor%3CPk%3E"],[670,"impl-Display-for-Miniscript%3CPk,+Ctx%3E"],[671,"impl-Debug-for-Miniscript%3CPk,+Ctx%3E"],[674,"impl-From%3CPkh%3CPk%3E%3E-for-Descriptor%3CPk%3E"],[675,"impl-From%3CWpkh%3CPk%3E%3E-for-Descriptor%3CPk%3E"],[677,"impl-From%3CWsh%3CPk%3E%3E-for-Descriptor%3CPk%3E"],[678,"impl-From%3CTr%3CPk%3E%3E-for-Descriptor%3CPk%3E"],[679,"impl-From%3CBare%3CPk%3E%3E-for-Descriptor%3CPk%3E"],[680,"impl-From%3CSh%3CPk%3E%3E-for-Descriptor%3CPk%3E"],[823,"impl-Display-for-Error"],[824,"impl-Debug-for-Error"],[825,"impl-From%3CError%3E-for-Error"],[826,"impl-From%3CPolicyError%3E-for-Error"],[827,"impl-From%3CHexToBytesError%3E-for-Error"],[828,"impl-From%3CParsePublicKeyError%3E-for-Error"],[829,"impl-From%3CError%3E-for-Error"],[830,"impl-From%3CError%3E-for-Error"],[831,"impl-From%3CKeyError%3E-for-Error"],[926,"impl-Debug-for-PolicyError"],[927,"impl-Display-for-PolicyError"],[1244,"impl-Display-for-MiniscriptPsbtError"],[1245,"impl-Debug-for-MiniscriptPsbtError"],[1246,"impl-Display-for-CreateTxError"],[1247,"impl-Debug-for-CreateTxError"],[1248,"impl-Display-for-BuildFeeBumpError"],[1249,"impl-Debug-for-BuildFeeBumpError"],[1251,"impl-From%3CError%3E-for-CreateTxError"],[1252,"impl-From%3CError%3E-for-CreateTxError"],[1253,"impl-From%3CMiniscriptPsbtError%3E-for-CreateTxError"],[1254,"impl-From%3CError%3E-for-CreateTxError"],[1256,"impl-From%3CPolicyError%3E-for-CreateTxError"],[1293,"impl-Display-for-FullyNodedExport"],[1294,"impl-Debug-for-FullyNodedExport"],[1439,"impl-Display-for-KeyError"],[1440,"impl-Debug-for-KeyError"],[1441,"impl-Display-for-SortedMultiVec%3CPk,+Ctx%3E"],[1442,"impl-Debug-for-SortedMultiVec%3CPk,+Ctx%3E"],[1443,"impl-Display-for-DescriptorPublicKey"],[1444,"impl-Debug-for-DescriptorPublicKey"],[1445,"impl-Display-for-DescriptorSecretKey"],[1446,"impl-Debug-for-DescriptorSecretKey"],[1451,"impl-From%3CXpub%3E-for-ExtendedKey%3CCtx%3E"],[1453,"impl-From%3CXpriv%3E-for-ExtendedKey%3CCtx%3E"],[1458,"impl-From%3CError%3E-for-KeyError"],[1459,"impl-From%3CError%3E-for-KeyError"],[1502,"impl-DerivableKey%3CCtx%3E-for-GeneratedKey%3CK,+Ctx%3E"],[1503,"impl-IntoDescriptorKey%3CCtx%3E-for-GeneratedKey%3CK,+Ctx%3E"],[1709,"impl-SignerCommon-for-SignerWrapper%3CPrivateKey%3E"],[1710,"impl-SignerCommon-for-SignerWrapper%3CDescriptorMultiXKey%3CXpriv%3E%3E"],[1711,"impl-SignerCommon-for-SignerWrapper%3CDescriptorXKey%3CXpriv%3E%3E"],[1726,"impl-Debug-for-SignerError"],[1727,"impl-Display-for-SignerError"],[1734,"impl-From%3CHash%3E-for-SignerId"],[1735,"impl-From%3CFingerprint%3E-for-SignerId"],[1746,"impl-SignerCommon-for-SignerWrapper%3CDescriptorXKey%3CXpriv%3E%3E"],[1747,"impl-SignerCommon-for-SignerWrapper%3CDescriptorMultiXKey%3CXpriv%3E%3E"],[1748,"impl-SignerCommon-for-SignerWrapper%3CPrivateKey%3E"],[1764,"impl-InputSigner-for-SignerWrapper%3CPrivateKey%3E"],[1765,"impl-InputSigner-for-SignerWrapper%3CDescriptorMultiXKey%3CXpriv%3E%3E"],[1766,"impl-InputSigner-for-SignerWrapper%3CDescriptorXKey%3CXpriv%3E%3E"],[1874,"impl-Debug-for-AddUtxoError"],[1875,"impl-Display-for-AddUtxoError"],[1876,"impl-Display-for-AddForeignUtxoError"],[1877,"impl-Debug-for-AddForeignUtxoError"]],"c":"OjAAAAEAAAAAAAUAEAAAAH4CyALUAgUFhAXsBQ==","e":"OzAAAAEAAA4EgwAUAAAAOAAAAEMAAQBHACAAbQAAAHEADgCDAAIAiwAEAJgAGQC0AAAAtgATANIAAADUAAIA2AAAANwAAQDgAAAA6wABAAQBAAASAQIAIAEAACsBAAAtAQIANgEAADwBBQBHAQAASgEAAE8BDQBjAR8AiAEPAJ4BDwDMAREA3wECAOMBAgDoAQYA/wEbACcCAAA1AgAASQIBAEwCAABOAgcAWQIAAFsCAQBeAgAAYQIBAGQCAQBoAgEAawIBAG4CAQBxAgsAggIDAIcCCwCYAgEAmwIJAKYCAwCvAgAAvAIDAMcCAADNAgEA0QIBANgCAQDuAgMA8wIBAAEDAQAEAwEACAMFABMDBwAcAwMAIQMDADUDCwBDAwQAawMZAIcDGgCkAwAApgMAAKwDAQC7AwAAvgMEAMQDIgANBBcAJgQvAG4ESADVBA0A5AQDAOkEAADuBA8ACAUBAAwFAAAOBQEAEQUAABUFBQBJBRcAawUVAIIFAQCFBQAAhwUlAK4FAACzBQEAuAUAAL8FAQDMBQMA3AUAAN8FBADlBQEA9QUBAPoFAAAEBgAACQYDABIGAAAWBggAIAYDACcGLwCGBg8AlwYUAK4GDgC+BgoA0QYAANMGAgDhBgEA5QYCAOkGAADtBgcA9wYfADAHCQA7BwYARAcBAEsHAgBSBwYAXgcAAGoHAABwBxMAhgcEAA=="}],\
+["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,"TaprootError",166],[6,"Error",160],[6,"P2wpkhError",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-Debug-for-SigningError"],[61,"impl-Display-for-SigningError"],[70,"impl-From%3CTaprootError%3E-for-SigningError"],[71,"impl-From%3CError%3E-for-SigningError"],[72,"impl-From%3CP2wpkhError%3E-for-SigningError"]],"c":"OjAAAAAAAAA=","e":"OzAAAAEAAGkAEAABAAEABAABAA4AAgAUACIAOwAHAEcAAgBOAAAAUQAAAFwAAQBfAAAAYgAAAGQAAABoAAAAawAAAG0AKQCaAAEA"}],\
+["bdk_wallet",{"t":"GGFGFPPPFGFGPPPPPPPEPPPPKGGGFGPFPPPPPPPPPIPFFGPPPFGTTFFNNONOONNNNNNNONDNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNDOONNNNNNNNNNNNNNNNCOONNNNNNNNNNNNNNONCOQNNNNNNNNNNNNNNNNNNNNNNNNNNNNCCDNNNNNNNNNNNNNNNNNNNNNQNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNONNOOONNNNNNNNNNNNNNNNNNNMNNOOONNNCONNNNNNNNNNNNNONNNNDNNNONNNNNONNNNNNNCNNNECONNNDDNNNNNNNOCENNNNNNOENNNNNNNNNNNNNNNOONONNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNCNONONNNNNNNNNNNNNNNNNNNOOHNNNNNNNNNNNNNNNNHOOOOOOOOOOOOOOOOPPFPKFIGGPFPFNNNNNNNNNNNNNNNNNNMNNNHNNNOONNNNNNNNNNNNNNNNNNNNNONNNNNNNNNNNNNNNNNNNNNNNNNNNNNOOOOOOOPPPIGEGIKTIKRGFPPPPEKGPPPPTIPPPPPPPPPPNNNNNNNNNNNNNNNNNENNNNNNNNNNNNNMNNMNNNNNCNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNCNONMNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNMNNNNNNNNNMNNNNNNMNNNNNNNNNNNNNNNNONNNNNNNNNMNNNNCNNNNNNNNNNNMNNNCNNNNNNNNNNNNNNNNNNNONNNNNNNNNNHPPGPPPPPPPPPPPNNNNNNNNNNNNNNNNNNNPPPGPFIPPIPPPPPPPPPPPGFGPPPPPGGPPPPNNNNNNNNNNNNNNNNNNNNNNNNNNOONNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNONNNNNNNNNNONNONNNNNONNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNOOOOOOOOOOOOOOOOOOOOOOOOFFFFFFFFKIFFFFNNNNNNNNNNNNNNNNNNNNNNNNMNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNGPPGPPPPPPPGPPPPPPPPPPPPPPPPPPNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNOOOOOOFIOONNNNNNNNNNNOONNNNNNPKGGGRRKGPKKFKPPPRGIPPPPPRPFPKGPPPFFGFPIPPPHMNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNMMNNNNNNNNNNNNNNNNNNNNNNNONNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNMNNNNNNNNNNNNNNNNNNNNMNNNNNNMNNNNNNNNNNNNNNNNNNNOONHNMNNHNMNNOONNNNNNMNNNNNMNHNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNKMMMSHPPPPPPPKPPPPPPPPPPPPPPPPFKGGGFFFPGKPNOONONNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNMNNNNNNNNNNNNNNNNNMNNNMNONONNNNNNNNOONNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNOGGPPGPPPPPPFGPPNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNOOOO","n":["AddForeignUtxoError","AddUtxoError","AddressInfo","ApplyBlockError","Balance","CannotConnect","ChangeAllowed","ChangeForbidden","ChangeSet","ChangeSpendPolicy","CreateParams","CreateWithPersistError","Custom","Descriptor","Descriptor","Descriptor","External","Foreign","Genesis","HdKeyPaths","Internal","InvalidChangeSet","InvalidOutpoint","InvalidTxid","IsDust","KeychainKind","LoadError","LoadMismatch","LoadParams","LoadWithPersistError","Local","LocalOutput","Mismatch","MissingDescriptor","MissingGenesis","MissingNetwork","MissingUtxo","Network","OnlyChange","Persist","Persist","PersistedWallet","Shuffle","SignOptions","TxBuilder","TxOrdering","UnexpectedConnectedToHash","UnknownUtxo","Untouched","Update","Utxo","WALLET_SCHEMA_NAME","WALLET_TABLE_NAME","Wallet","WeightedUtxo","add","add_signer","address","all_unbounded_spk_iters","allow_all_sighashes","allow_grinding","apply_block","apply_block_connected_to","apply_unconfirmed_txs","apply_update","as_byte","as_ref","as_ref","assume_height","balance","bitcoin","borrow","borrow","borrow","borrow","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","borrow_mut","borrow_mut","borrow_mut","borrow_mut","build_fee_bump","build_tx","calculate_fee","calculate_fee_rate","cancel_tx","chain","chain","change_descriptor","checkpoints","clone","clone","clone","clone","clone","clone","clone","clone_into","clone_into","clone_into","clone_into","clone_into","clone_into","clone_into","cmp","coin_selection","confirmation_time","confirmed","create","create","create","create","create_wallet","create_wallet_async","create_wallet_no_persist","create_with_params","default","default","default","default","deref","derivation_index","derivation_index","derivation_of_spk","descriptor","descriptor","descriptor","descriptor_checksum","descriptors","deserialize","deserialize","deserialize","deserialize","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","equivalent","equivalent","equivalent","equivalent","equivalent","equivalent","equivalent","equivalent","equivalent","equivalent","equivalent","equivalent","error","export","file_store","finalize_psbt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fragment","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from_sqlite","genesis_hash","genesis_hash","get_psbt_input","get_signers","get_tx","get_utxo","graph","hash","hash","immature","index","indexer","insert_checkpoint","insert_tx","insert_txout","into","into","into","into","into","into","into","into","into","into","into","into","into","into","into","into","is_dust","is_empty","is_mine","is_spent","keychain","keychain","keychains","keymap","keymap","keys","last_active_indices","latest_checkpoint","list_output","list_unspent","list_unused_addresses","load","load","load","load","load_wallet","load_wallet_async","load_wallet_no_persist","load_with_params","local_chain","local_chain","lookahead","lookahead","mark_used","merge","miniscript","network","network","network","network","new","new","next_derivation_index","next_unused_address","outpoint","outpoint","partial_cmp","peek_address","persist","persist","persist","persist_to_sqlite","policies","psbt","public_descriptor","reveal_addresses_to","reveal_next_address","rusqlite","rusqlite_impl","satisfaction_weight","secp_ctx","sent_and_received","sequence","serde","serde_json","serialize","serialize","serialize","serialize","set_keymap","set_keymaps","sign","sign_with_tap_internal_key","signer","signer","spk_index","staged","staged","start_full_scan","start_sync_with_revealed_spks","take_staged","tap_leaves_options","template","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","to_string","to_string","to_string","to_string","to_string","to_string","total","transactions","trust_witness_utxo","trusted_pending","trusted_spendable","try_finalize","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_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","try_into","try_into","try_into","try_into","tx_builder","tx_graph","tx_graph","txout","txout","type_id","type_id","type_id","type_id","type_id","type_id","type_id","type_id","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","utxo","version","vzip","vzip","vzip","vzip","vzip","vzip","vzip","vzip","vzip","vzip","vzip","vzip","vzip","vzip","vzip","vzip","wallet_name_from_descriptor","foreign_utxo","input_txid","connected_to_hash","expected_hash","expected","expected","expected","keychain","loaded","loaded","loaded","input_sort","output_sort","outpoint","psbt_input","sequence","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","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","equivalent","equivalent","equivalent","equivalent","equivalent","equivalent","equivalent","equivalent","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","Base58","Bip32","Error","ExternalAndInternalAreTheSame","HardenedDerivationXpub","Hex","InvalidDescriptorCharacter","InvalidDescriptorChecksum","InvalidHdKeyPath","Key","Miniscript","MultiPath","Pk","Policy","borrow","borrow_mut","eq","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","equivalent","equivalent","equivalent","equivalent","equivalent","equivalent","equivalent","equivalent","equivalent","equivalent","equivalent","equivalent","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","clone","clone","clone","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","clone_into","clone_into","clone_into","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","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","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","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","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","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","eq","equivalent","equivalent","equivalent","equivalent","equivalent","equivalent","equivalent","equivalent","equivalent","equivalent","equivalent","equivalent","equivalent","equivalent","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","SCHEMAS_TABLE_NAME","migrate_schema","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","descriptor_secret_key","eq","eq","eq","eq","equivalent","equivalent","equivalent","equivalent","equivalent","equivalent","equivalent","equivalent","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","equivalent","equivalent","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"],[430,"bdk_wallet::AddForeignUtxoError"],[432,"bdk_wallet::ApplyBlockError"],[434,"bdk_wallet::LoadMismatch"],[441,"bdk_wallet::TxOrdering"],[443,"bdk_wallet::Utxo"],[446,"bdk_wallet::coin_selection"],[538,"bdk_wallet::coin_selection::Error"],[540,"bdk_wallet::coin_selection::Excess"],[545,"bdk_wallet::descriptor"],[805,"bdk_wallet::descriptor::checksum"],[806,"bdk_wallet::descriptor::error"],[839,"bdk_wallet::descriptor::policy"],[998,"bdk_wallet::descriptor::policy::BuildSatisfaction"],[1001,"bdk_wallet::descriptor::policy::Satisfaction"],[1012,"bdk_wallet::descriptor::policy::SatisfiableItem"],[1022,"bdk_wallet::descriptor::template"],[1206,"bdk_wallet::error"],[1277,"bdk_wallet::error::CreateTxError"],[1283,"bdk_wallet::export"],[1306,"bdk_wallet::keys"],[1622,"bdk_wallet::psbt"],[1626,"bdk_wallet::rusqlite_impl"],[1628,"bdk_wallet::signer"],[1814,"bdk_wallet::signer::SignerContext"],[1815,"bdk_wallet::tx_builder"],[1930,"bdk_wallet::tx_builder::AddForeignUtxoError"],[1932,"bdk_wallet::tx_builder::TxOrdering"],[1934,"bdk_chain::balance"],[1935,"bdk_wallet::wallet"],[1936,"bdk_wallet::types"],[1937,"bdk_wallet::wallet::signer"],[1938,"alloc::sync"],[1939,"bitcoin::blockdata::script::owned"],[1940,"bdk_chain"],[1941,"core::iter::traits::iterator"],[1942,"core::clone"],[1943,"alloc::collections::btree::map"],[1944,"bitcoin::blockdata::block"],[1945,"bdk_chain::local_chain"],[1946,"core::result"],[1947,"bdk_chain::chain_data"],[1948,"bitcoin::blockdata::transaction"],[1949,"core::iter::traits::collect"],[1950,"core::convert"],[1951,"bdk_chain::tx_graph"],[1952,"bdk_wallet::wallet::coin_selection"],[1953,"bdk_wallet::wallet::tx_builder"],[1954,"bdk_wallet::wallet::error"],[1955,"bitcoin_units::amount"],[1956,"bitcoin_units::fee_rate"],[1957,"bdk_wallet::wallet::changeset"],[1958,"core::cmp"],[1959,"bdk_file_store::store"],[1960,"bdk_wallet::wallet::params"],[1961,"rusqlite::transaction"],[1962,"rusqlite"],[1963,"bdk_wallet::wallet::persisted"],[1964,"core::option"],[1965,"alloc::string"],[1966,"serde::de"],[1967,"bitcoin::psbt"],[1968,"core::fmt"],[1969,"bdk_chain::indexer::keychain_txout"],[1970,"bdk_chain::indexed_tx_graph"],[1971,"bdk_chain::spk_client"],[1972,"bitcoin::psbt::map::input"],[1973,"core::hash"],[1974,"bdk_wallet::wallet::utils"],[1975,"bitcoin::blockdata::script::borrowed"],[1976,"miniscript::descriptor"],[1977,"core::iter::traits::double_ended"],[1978,"bitcoin::network"],[1979,"secp256k1::context::alloc_only"],[1980,"secp256k1"],[1981,"serde::ser"],[1982,"core::any"],[1983,"alloc::vec"],[1984,"bitcoin::address"],[1985,"miniscript"],[1986,"miniscript::miniscript::private"],[1987,"miniscript::miniscript::decode"],[1988,"miniscript::miniscript::context"],[1989,"miniscript::iter::tree"],[1990,"miniscript::descriptor::key"],[1991,"miniscript::miniscript::satisfy"],[1992,"miniscript::plan"],[1993,"bitcoin_hashes::sha256"],[1994,"miniscript::miniscript::hash256"],[1995,"bitcoin_hashes::ripemd160"],[1996,"bitcoin_hashes::hash160"],[1997,"bitcoin::crypto::key"],[1998,"secp256k1::context"],[1999,"bdk_chain::descriptor_ext"],[2000,"miniscript::blanket_traits"],[2001,"miniscript::miniscript::analyzable"],[2002,"core::ops::range"],[2003,"core::ops::function"],[2004,"miniscript::descriptor::segwitv0"],[2005,"miniscript::descriptor::bare"],[2006,"miniscript::descriptor::sh"],[2007,"miniscript::descriptor::tr"],[2008,"miniscript::miniscript::types"],[2009,"miniscript::miniscript::types::extra_props"],[2010,"miniscript::expression"],[2011,"miniscript::miniscript::iter"],[2012,"miniscript::policy::semantic"],[2013,"miniscript::policy"],[2014,"bitcoin_units::weight"],[2015,"hex_conservative::error"],[2016,"bitcoin::bip32"],[2017,"base58ck::error"],[2018,"bitcoin::psbt::error"],[2019,"bdk_wallet::wallet::export"],[2020,"miniscript::descriptor::sortedmulti"],[2021,"core::str::traits"],[2022,"core::default"],[2023,"rand_core"],[2024,"rusqlite::error"],[2025,"core::marker"],[2026,"bitcoin::blockdata::script::push_bytes::primitive"],[2027,"bitcoin::blockdata::locktime::absolute"],[2028,"bdk_chain::rusqlite_impl"]],"i":[0,0,0,0,0,71,257,257,0,0,0,0,258,70,60,61,5,42,61,0,5,58,255,255,0,0,0,0,0,0,42,0,60,60,60,60,255,61,257,58,70,0,258,0,0,0,71,256,258,0,0,43,43,0,0,1,3,53,3,63,63,3,3,3,3,5,5,3,63,3,0,46,52,1,5,40,41,42,43,58,70,3,26,53,60,61,71,46,52,1,5,40,41,42,43,58,70,3,26,53,60,61,71,3,3,3,3,3,0,26,43,3,1,5,40,41,42,43,26,1,5,40,41,42,43,26,5,0,40,1,3,3,3,3,46,46,46,3,52,1,43,26,53,3,40,3,0,43,0,3,52,1,5,40,43,1,5,40,41,42,43,58,53,60,61,1,1,5,5,40,40,41,41,42,42,53,53,0,0,0,3,1,1,5,40,41,42,43,58,58,70,70,3,26,53,53,60,60,61,71,71,0,46,52,1,5,40,41,42,43,43,43,43,43,58,58,70,3,26,26,26,53,60,60,61,71,43,46,52,3,3,3,3,26,5,40,1,53,43,3,3,3,46,52,1,5,40,41,42,43,58,70,3,26,53,60,61,71,89,43,3,40,40,53,3,46,52,0,26,3,3,3,3,3,3,3,3,52,52,52,3,3,43,46,52,3,43,0,46,52,3,43,46,52,3,3,42,40,5,3,3,3,3,43,3,0,3,3,3,0,0,41,3,3,42,0,0,1,5,40,43,3,3,3,63,0,0,3,3,3,3,3,3,63,0,1,5,40,41,42,43,26,1,58,70,53,60,71,1,3,63,1,1,63,46,52,1,5,40,41,42,43,58,70,3,26,53,60,61,71,46,52,1,5,40,41,42,43,58,70,3,26,53,60,61,71,0,3,43,42,40,46,52,1,5,40,41,42,43,58,70,3,26,53,60,61,71,3,3,3,1,41,0,46,52,1,5,40,41,42,43,58,70,3,26,53,60,61,71,0,261,261,262,262,263,264,265,265,263,264,265,266,266,267,267,267,114,114,0,115,0,0,0,0,0,114,0,115,0,114,115,113,108,109,110,114,115,113,108,109,110,108,109,110,108,109,110,111,108,109,110,0,108,109,110,113,113,114,114,115,113,108,109,110,114,115,113,108,109,110,114,115,113,108,109,110,113,110,113,113,108,109,110,114,114,115,113,108,109,110,114,115,113,108,109,110,114,115,113,108,109,110,114,115,113,108,109,110,268,268,269,270,270,269,270,91,271,116,0,0,0,0,0,0,122,0,0,124,0,0,126,91,271,116,0,0,0,91,271,116,126,122,0,91,271,116,91,271,116,91,271,116,126,116,143,144,122,122,116,116,143,144,122,116,143,144,122,122,122,122,0,124,143,144,124,144,124,124,143,144,124,143,144,124,124,143,144,124,143,144,124,143,144,0,116,143,144,122,116,143,144,122,116,143,144,122,122,116,116,116,116,116,116,122,116,122,116,143,144,122,116,116,143,143,144,144,122,122,0,116,122,122,153,116,122,116,116,116,143,144,122,122,116,122,116,116,116,116,116,116,116,143,144,122,122,122,116,122,122,122,116,122,122,122,116,116,122,122,116,116,143,144,122,116,143,144,122,122,116,47,91,116,116,122,122,122,116,122,122,124,143,144,122,116,122,116,124,143,144,116,116,116,116,116,116,116,116,116,116,116,116,116,116,122,124,122,116,122,122,116,143,144,122,124,143,144,116,116,0,122,116,122,116,122,122,116,116,122,116,122,124,143,144,122,0,116,143,144,122,116,122,116,124,124,116,122,116,143,144,122,116,143,144,122,122,116,143,144,122,116,116,143,144,122,122,0,51,51,0,51,51,51,51,51,51,51,51,51,51,51,51,51,51,51,51,51,51,51,51,51,51,51,51,51,51,51,51,51,51,192,189,189,0,193,0,0,192,191,0,192,192,189,189,189,192,193,154,189,193,193,0,0,0,154,154,191,192,192,0,0,192,192,192,191,191,192,193,97,194,189,154,191,192,193,97,194,189,154,191,192,193,97,194,154,191,192,193,97,194,154,97,194,194,191,192,193,97,194,189,191,191,192,192,193,193,97,97,194,194,189,189,191,192,193,97,194,189,189,154,191,192,193,193,97,97,194,189,154,97,191,194,192,97,191,192,193,97,194,189,154,192,193,194,97,194,97,97,191,192,193,97,194,194,191,192,193,97,194,154,189,191,192,193,97,194,189,154,191,192,193,97,194,189,154,191,192,193,97,194,189,154,191,192,193,97,194,189,154,272,272,272,273,274,275,274,275,274,275,274,275,274,275,276,277,278,279,280,281,281,280,282,283,0,0,0,0,0,0,0,0,0,0,0,0,0,0,197,199,200,201,203,205,206,207,208,209,210,211,197,199,200,201,203,205,206,207,208,209,210,211,195,197,199,200,201,203,205,206,207,208,209,210,211,197,199,200,201,203,205,206,207,208,209,210,211,197,199,200,201,203,205,206,207,208,209,210,211,197,199,200,201,203,205,206,207,208,209,210,211,197,199,200,201,203,205,206,207,208,209,210,211,197,199,200,201,203,205,206,207,208,209,210,211,196,197,199,200,201,203,205,206,207,208,209,210,211,197,199,200,201,203,205,206,207,208,209,210,211,197,199,200,201,203,205,206,207,208,209,210,211,197,199,200,201,203,205,206,207,208,209,210,211,197,199,200,201,203,205,206,207,208,209,210,211,197,199,200,201,203,205,206,207,208,209,210,211,0,82,212,0,82,82,35,82,35,82,82,0,82,82,82,82,82,212,82,82,82,82,82,35,35,82,35,212,82,82,212,82,35,212,82,35,212,212,212,212,82,82,35,35,212,82,82,82,82,82,82,35,212,82,35,212,212,82,35,212,82,35,212,82,35,212,82,35,212,82,35,284,284,285,285,286,287,0,0,288,214,214,214,214,214,214,214,214,214,214,214,214,288,214,214,214,214,214,214,214,186,0,0,0,0,231,231,0,0,221,0,0,0,0,186,186,186,124,0,0,121,186,186,177,126,231,224,0,224,0,0,121,126,177,0,0,0,0,121,0,221,177,126,0,289,126,224,217,222,121,218,186,216,126,177,219,220,221,224,217,222,121,218,186,216,126,177,219,220,221,216,124,124,124,124,124,124,124,124,124,217,121,218,216,126,177,219,220,221,217,121,218,216,126,177,219,220,221,216,126,219,221,218,218,217,126,126,216,121,186,216,126,177,219,220,221,121,121,216,216,126,126,177,177,219,219,220,220,221,221,222,121,218,186,186,216,216,126,126,177,177,219,220,221,216,224,224,224,217,222,121,218,186,186,186,216,126,126,177,219,220,221,222,222,126,177,216,126,126,231,234,234,231,231,234,224,126,216,126,219,221,224,217,222,121,218,186,216,126,177,219,220,221,126,198,204,217,217,222,126,177,204,224,217,217,126,177,224,224,126,289,121,126,177,289,121,289,121,126,126,216,219,220,216,0,126,124,216,216,0,216,124,216,126,219,220,124,222,216,126,219,221,124,216,216,216,216,126,124,216,0,217,121,218,216,126,177,219,220,221,177,186,216,126,177,124,124,216,224,217,222,121,218,186,216,126,177,219,220,221,224,217,222,121,218,186,216,126,177,219,220,221,224,217,222,121,218,186,216,126,177,219,220,221,224,217,222,121,218,186,216,126,177,219,220,221,0,241,241,241,0,0,247,243,247,64,243,247,64,0,64,64,64,244,64,64,64,64,64,64,64,247,243,64,244,64,0,0,0,0,0,0,0,0,244,0,0,64,83,63,63,83,63,243,64,244,245,6,83,63,247,243,64,244,245,6,83,63,247,83,243,244,245,6,83,63,247,243,244,245,6,83,63,247,243,6,6,83,63,247,245,248,248,245,245,245,243,244,6,247,243,243,244,244,6,6,247,247,83,243,64,64,244,245,6,83,63,247,243,243,243,64,244,245,6,83,63,247,243,248,245,245,245,83,243,64,244,245,6,83,63,247,245,83,243,6,83,252,245,245,245,7,245,63,83,63,243,244,245,6,83,63,247,64,63,63,243,64,244,245,6,83,63,247,243,64,244,245,6,83,63,247,243,64,244,245,6,83,63,247,243,64,244,245,6,83,63,247,290,0,0,257,257,0,258,255,255,255,257,258,0,0,256,258,34,34,34,34,34,34,34,34,34,34,256,255,258,257,34,256,255,258,257,34,34,258,257,34,258,257,257,34,34,258,257,34,34,34,34,34,257,257,257,34,34,34,34,34,256,256,255,255,258,257,34,256,255,258,257,257,34,34,256,255,258,257,34,34,34,34,34,257,34,34,34,258,258,34,258,257,256,255,34,256,255,258,257,34,256,255,258,257,34,256,255,258,257,34,34,34,256,255,258,257,261,261,266,266],"f":"```````````````````````````````````````````````````````{{bb}b}{{{h{df}}jl{A`{n}}}Ab}`{{{h{f}}}{{An{j{`{{Aj{}{{Ad{{Ah{Af}}}}}}Al}}}}}}``{{{h{df}}{h{B`}}Bb}{{Bf{AbBd}}}}{{{h{df}}{h{B`}}BbBh}{{Bf{AbBj}}}}{{{h{df}}c}Ab{{Cb{}{{Ad{{C`{{h{Bl}}Bn}}}}}}}}{{{h{df}}c}{{Bf{AbBd}}}{{Cf{Cd}}}}{{{h{j}}}Ch}{{{h{j}}}{{h{{Cj{Ch}}}}}}{{{h{f}}}{{h{{Cn{Cl}}}}}}`{{{h{f}}}b}`{{{h{c}}}{{h{e}}}{}{}}000000000000000{{{h{dc}}}{{h{de}}}{}{}}000000000000000{{{h{df}}D`}{{Bf{{Dd{Db}}Df}}}}{{{h{df}}}{{Dd{Db}}}}{{{h{f}}{h{Bl}}}{{Bf{DhDj}}}}{{{h{f}}{h{Bl}}}{{Bf{DlDj}}}}{{{h{df}}{h{Bl}}}Ab}```{{{h{f}}}Dn}{{{h{b}}}b}{{{h{j}}}j}{{{h{E`}}}E`}{{{h{Eb}}}Eb}{{{h{Ed}}}Ed}{{{h{Ef}}}Ef}{{{h{Cd}}}Cd}{{{h{c}}{h{de}}}Ab{}{}}000000{{{h{j}}{h{j}}}Eh}```{{{h{d{Ej{Ef}}}}c}{{Bf{fe}}}{}{}}{{cc}El{EnAl}}{{{h{dF`}}c}{{Bf{fe}}}{}{}}{{{h{dFb}}c}{{Bf{fe}}}{}{}}{{El{h{dc}}}{{Bf{Fd}}}{}}0{El{{Bf{fFf}}}}0{{}Fh}{{}b}{{}Ef}{{}Cd}{{{h{Fj}}}{{h{c}}}{}}{{{h{f}}j}{{Fl{Bb}}}}`{{{h{f}}Af}{{Fl{{C`{jBb}}}}}}```{{{h{f}}j}Fn}{{Fhcc}FhEn}{c{{Bf{b}}}G`}{c{{Bf{j}}}G`}{c{{Bf{E`}}}G`}{c{{Bf{Ef}}}G`}{{{h{b}}{h{b}}}Gb}{{{h{j}}{h{j}}}Gb}{{{h{E`}}{h{E`}}}Gb}{{{h{Eb}}{h{Eb}}}Gb}{{{h{Ed}}{h{Ed}}}Gb}{{{h{Ef}}{h{Ef}}}Gb}{{{h{{Gd{c}}}}{h{{Gd{c}}}}}GbGf}{{{h{Fj}}{h{Fj}}}Gb}{{{h{Gh}}{h{Gh}}}Gb}{{{h{Gj}}{h{Gj}}}Gb}{{{h{c}}{h{e}}}Gb{}{}}00000000000```{{{h{f}}{h{dGl}}Gn}{{Bf{GbH`}}}}{{{h{b}}{h{dHb}}}{{Bf{AbHd}}}}0{{{h{j}}{h{dHb}}}Hf}{{{h{E`}}{h{dHb}}}Hf}{{{h{Eb}}{h{dHb}}}Hf}{{{h{Ed}}{h{dHb}}}Hf}{{{h{Ef}}{h{dHb}}}Hf}{{{h{{Gd{c}}}}{h{dHb}}}HfHh}{{{h{{Gd{c}}}}{h{dHb}}}HfHj}{{{h{{Hl{c}}}}{h{dHb}}}HfHh}{{{h{{Hl{c}}}}{h{dHb}}}HfHj}{{{h{f}}{h{dHb}}}Hf}{{{h{Cd}}{h{dHb}}}Hf}{{{h{Fj}}{h{dHb}}}Hf}0{{{h{Gh}}{h{dHb}}}Hf}0{{{h{Gj}}{h{dHb}}}Hf}{{{h{Hn}}{h{dHb}}}Hf}0`{cc{}}000000{{{I`{Cl}}}Ef}{IbEf}{IdEf}3{{{If{ClIb}}}Ef}{Gj{{Gd{c}}}{}}555{IhCd}{{{Ij{j}}}Cd}77{GjGh}888{{{h{F`}}}{{Il{Ef}}}}{{ElIn}El}{{FhIn}Fh}{{{h{f}}E`{Fl{J`}}Gb}{{Bf{JbJd}}}}{{{h{f}}j}{{A`{Jf}}}}{{{h{f}}D`}{{Fl{{Jh{{A`{Bl}}Cl}}}}}}{{{h{f}}Jj}{{Fl{E`}}}}`{{{h{j}}{h{dc}}}AbJl}{{{h{E`}}{h{dc}}}AbJl}```{{{h{df}}Bh}{{Bf{GbJn}}}}{{{h{df}}Bl}Gb}{{{h{df}}JjK`}Ab}{ce{}{}}000000000000000{{{h{Kb}}{h{Kd}}}Gb}{{{h{Ef}}}Gb}{{{h{f}}Af}Gb}```{{{h{f}}}{{`{{Aj{}{{Ad{{C`{j{h{Kf}}}}}}}}}}}}{{EljKh}El}{{FhjKh}Fh}``{{{h{f}}}Kj}{{{h{f}}}{{`{{Aj{}{{Ad{E`}}}}}}}}0{{{h{f}}j}{{`{{Kl{}{{Ad{Fj}}}}}}}}{{}Fh}{{{h{d{Ej{Ef}}}}c}{{Bf{{Fl{f}}e}}}{}{}}{{{h{dF`}}c}{{Bf{{Fl{f}}e}}}{}{}}{{{h{dFb}}c}{{Bf{{Fl{f}}e}}}{}{}}{{Fh{h{dc}}}{{Bf{{Fl{Fd}}}}}{}}0{{FhEf}{{Bf{{Fl{f}}Gh}}}}{{EfFh}{{Bf{{Fl{f}}Gh}}}}{{{h{f}}}{{h{Kn}}}}`{{ElBb}El}{{FhBb}Fh}{{{h{df}}jBb}Gb}{{{h{dEf}}Ef}Ab}`{{ElL`}El}{{FhL`}Fh}{{{h{f}}}L`}`{{cc}ElEn}?{{{h{f}}j}Bb}{{{h{df}}j}Fj}{{{h{Ed}}}Jj}`{{{h{j}}{h{j}}}{{Fl{Eh}}}}{{{h{f}}jBb}Fj}{{{h{dF`}}{h{c}}}{{Bf{Abe}}}{}{}}{{{h{d{Ej{Ef}}}}{h{c}}}{{Bf{Abe}}}{}{}}{{{h{dFb}}{h{c}}}{{Bf{Abe}}}{}{}}{{{h{Ef}}{h{F`}}}{{Il{Ab}}}}{{{h{f}}j}{{Bf{{Fl{Lb}}Ff}}}}`{{{h{f}}j}{{h{Kf}}}}{{{h{df}}jBb}{{`{{Aj{}{{Ad{Fj}}}}}}}}:```{{{h{f}}}{{h{{Lf{Ld}}}}}}{{{h{f}}{h{Bl}}}{{C`{DhDh}}}}{{{h{Ed}}}{{Fl{Lh}}}}``{{{h{b}}c}BfLj}{{{h{j}}c}BfLj}{{{h{E`}}c}BfLj}{{{h{Ef}}c}BfLj}{{{h{df}}jKh}Ab}{{{h{df}}c}Ab{{Cb{}{{Ad{{C`{jKh}}}}}}}}{{{h{f}}{h{dGl}}Gn}{{Bf{GbH`}}}}```{{{h{f}}}{{h{{Ll{j}}}}}}{{{h{df}}}{{h{dc}}}{}}{{{h{f}}}{{Fl{{h{Ef}}}}}}{{{h{f}}}{{Ln{j}}}}{{{h{f}}}M`}{{{h{df}}}{{Fl{Ef}}}}``{{{h{c}}}e{}{}}000000{{{h{c}}}Fn{}}00000{{{h{b}}}Dh}{{{h{f}}}{{`{{Aj{}{{Ad{{Jh{{A`{Bl}}Cl}}}}}}}}}}``1`{c{{Bf{e}}}{}{}}0000000000000000000000000000000`{{{h{f}}}{{h{{Cn{Cl}}}}}}`{{{h{Ed}}}{{h{K`}}}}`{{{h{c}}}Mb{}}000000000000000{{{h{f}}j}{{`{{Aj{}{{Ad{{Ah{Af}}}}}}Al}}}}{{{h{f}}}{{`{{Aj{}{{Ad{{Md{{A`{Bl}}Cl}}}}}}}}}}{{{h{df}}jBb}Gb}``{{}{{h{Mf}}}}{ce{}{}}000000000000000{{c{Fl{c}}L`{h{{Lf{Ld}}}}}{{Bf{FnFf}}}En}`````````````````````````````{{{h{c}}}{{h{e}}}{}{}}00000{{{h{dc}}}{{h{de}}}{}{}}00000{{{h{Mh}}}Mh}{{{h{Mj}}}Mj}{{{h{Ml}}}Ml}{{{h{c}}{h{de}}}Ab{}{}}00{{{h{Mn}}{N`{Eb}}{N`{Eb}}DlBn{h{Kd}}}{{Bf{NbNd}}}}{{{h{Mh}}{N`{Eb}}{N`{Eb}}DlBn{h{Kd}}}{{Bf{NbNd}}}}{{{h{Mj}}{N`{Eb}}{N`{Eb}}DlBn{h{Kd}}}{{Bf{NbNd}}}}{{{h{Ml}}{N`{Eb}}{N`{Eb}}DlBn{h{Kd}}}{{Bf{NbNd}}}}{{BnDl{h{Kd}}}Nf}{{}Mh}{{}Mj}{{}Ml}``{{{h{Nd}}{h{dHb}}}Hf}0{{{h{Nf}}{h{dHb}}}Hf}{{{h{Nb}}{h{dHb}}}Hf}{{{h{Mh}}{h{dHb}}}Hf}{{{h{Mj}}{h{dHb}}}Hf}{{{h{Ml}}{h{dHb}}}Hf}{cc{}}00000{ce{}{}}00000{{{h{Nb}}}Bn}{BnMl}`1{{{h{c}}}e{}{}}00{{{h{c}}}Fn{}}{c{{Bf{e}}}{}{}}00000000000{{{h{c}}}Mb{}}00000666666`````````````````````````````````````````````{{{h{{Nh{c}}}}L`}{{Bf{NjNl}}}{NnO`}}{{}Ob}0{{{h{{Od{ce}}}}}{{h{{Of{ce}}}}}NnOh}{{{h{{h{{Od{ce}}}}}}}{{Oj{{h{{Od{ce}}}}}}}NnOh}{{{h{{Nh{Ol}}}}Bb}{{Bf{{Nh{On}}A@`}}}}{{{h{c}}}{{h{e}}}{}{}}000{{{h{dc}}}{{h{de}}}{}{}}000{{{h{{Od{ce}}}}}{{N`{{h{{Od{ce}}}}}}}NnOh}{{{h{{Od{ce}}}}{h{g}}}{{A@d{{A@b{c}}}}}{O`Nn}Oh{{A@f{c}}}}0`{{{h{{Od{c{Oh{}{{A@h{e}}}}}}}}}{{Bf{AbA@j}}}Nn{{AAl{}{{A@l{A@n}}{AA`{AAb}}{AAd{AAf}}{AAh{AAj}}}}NnNnNnNn}}{{{h{{Od{cAAn}}}}}{{Bf{AbA@j}}}Nn}{{{h{{Od{cAB`}}}}}{{Bf{AbA@j}}}Nn}2022102102{{{h{c}}}{{Bf{AbA@j}}}Nn}00{{{h{{Of{c{Oh{}{{A@h{e}}}}}}}}}{{Bf{AbA@j}}}Nn{{AAl{}{{A@l{A@n}}{AA`{AAb}}{AAd{AAf}}{AAh{AAj}}}}NnNnNnNn}}{{{h{{Of{cAAn}}}}}{{Bf{AbA@j}}}Nn}{{{h{{Of{cAB`}}}}}{{Bf{AbA@j}}}Nn}{{{h{{Cj{{N`{Ch}}}}}}}{{Bf{AbA@j}}}}00`{{{h{{Nh{c}}}}}{{Nh{c}}}{AlNn}}{{{h{AAn}}}AAn}{{{h{AB`}}}AB`}{{{h{{Od{ce}}}}}{{Od{ce}}}{AlNn}{AlOh}}{{{h{c}}{h{de}}}Ab{}{}}000{{{h{{Nh{c}}}}{h{{Nh{c}}}}}Eh{ABbNn}}{{{h{AAn}}{h{AAn}}}Eh}{{{h{AB`}}{h{AB`}}}Eh}{{{h{{Od{ce}}}}{h{{Od{ce}}}}}EhNnOh}{{{h{{Od{ce}}}}}GbNnOh}{{{h{{Nh{Ol}}}}Bb}{{Bf{{Nh{On}}A@`}}}}{{{h{{Nh{Ol}}}}{h{{Lf{c}}}}Bb}{{Bf{{Nh{ABd}}A@`}}}ABf}{{{h{{Nh{On}}}}{h{{Lf{c}}}}}{{Bf{{Nh{ABd}}A@`}}}ABf}{{{h{{Nh{c}}}}}ABhNn}{{{h{{Nh{Ol}}}}}ABj}{c{{Bf{{Nh{e}}}}}G`ABl}{c{{Bf{{Od{eg}}}}}G`ABlOh}{{{h{{Nh{Ol}}}}}Bn}{{{h{{Od{ce}}}}}Af{O`Nn}Oh}{{{h{{Nh{c}}}}{h{{Nh{c}}}}}Gb{GfNn}}{{{h{AAn}}{h{AAn}}}Gb}{{{h{AB`}}{h{AB`}}}Gb}{{{h{{Od{ce}}}}{h{{Od{ce}}}}}GbNnOh}{{{h{c}}{h{e}}}Gb{}{}}0000000`{{{h{{Nh{c}}}}}{{Bf{AfNl}}}{NnO`}}`{{{h{{Od{ce}}}}{h{ABn}}}{{Bf{AbAC`}}}NnOh}{{{h{ACb}}{h{Jf}}ACd{h{{Lf{Ld}}}}}{{Bf{{Fl{Lb}}Ff}}}}{{{h{{Nh{Ol}}}}{h{Jf}}ACd{h{{Lf{Ld}}}}}{{Bf{{Fl{Lb}}Ff}}}}{{{h{{Od{Olc}}}}{h{Jf}}ACd{h{{Lf{Ld}}}}}{{Bf{{Fl{Lb}}Ff}}}Oh}{{{h{{Nh{Ol}}}}{h{{Lf{c}}}}{h{Kd}}{ACf{Bb}}}{{Bf{{Fl{{C`{Bb{Nh{ABd}}}}}}A@`}}}ABf}{{{h{{Nh{c}}}}{h{dHb}}}{{Bf{AbHd}}}Nn}0{{{h{AAn}}{h{dHb}}}{{Bf{AbHd}}}}{{{h{AB`}}{h{dHb}}}{{Bf{AbHd}}}}{{{h{{Od{ce}}}}{h{dHb}}}{{Bf{AbHd}}}NnOh}0{{{h{{Nh{c}}}}e}GbNn{{ACj{{h{c}}}{{ACh{Gb}}}}}}{{{h{{Od{ce}}}}g}GbNnOh{{ACj{{h{c}}}{{ACh{Gb}}}}}}{{{ACl{c}}}{{Nh{c}}}Nn}{{{ACn{c}}}{{Nh{c}}}Nn}{{{AD`{c}}}{{Nh{c}}}Nn}{cc{}}{{{ADb{c}}}{{Nh{c}}}Nn}{{{ADd{c}}}{{Nh{c}}}Nn}{{{ADf{c}}}{{Nh{c}}}Nn}333{{{Of{ce}}}{{Bf{{Od{ce}}Nl}}}NnOh}{{{Of{ce}}ADhADj}{{Od{ce}}}NnOh}{{{h{Mf}}}{{Bf{{Nh{c}}Nl}}}ABl}{{{h{Mf}}}{{Bf{{Od{ce}}Nl}}}ABlOh}{{{h{Mf}}{h{ABn}}}{{Bf{{Od{ce}}Nl}}}ABlOh}1{{{h{ADl}}}{{Bf{{Nh{c}}Nl}}}ABl}{{{h{ADl}}}{{Bf{{Od{ce}}Nl}}}ABlOh}{{{h{{Od{ce}}}}ADn}{{Fl{{h{{Od{ce}}}}}}}NnOh}{{{h{{Od{ce}}}}ADn}{{Fl{c}}}NnOh}{{{h{{Nh{c}}}}e}{{Bf{{C`{{N`{{N`{Ch}}}}Af}}Nl}}}{NnO`}{{AE`{c}}}}0{{{h{{Od{ce}}}}}GbNnOh}0{{{h{{Nh{Ol}}}}}Gb}{{{h{{Nh{c}}}}{h{de}}}Ab{AEbNn}Jl}{{{h{AAn}}{h{dc}}}AbJl}{{{h{AB`}}{h{dc}}}AbJl}{{{h{{Od{ce}}}}{h{dg}}}AbNnOhJl}{ce{}{}}000{{{Od{ce}}}{{Of{ce}}}NnOh}{{{Nh{Ol}}}{{Bf{{N`{{Nh{Ol}}}}Nl}}}}{{En{h{{Lf{Ld}}}}L`}{{Bf{{C`{KfKh}}Ff}}}}{{Kf{h{{Lf{Ld}}}}L`}{{Bf{{C`{KfKh}}Ff}}}}99:{{{h{{Od{ce}}}}}{{AEd{ce}}}NnOh}{{{h{{Od{ce}}}}}{{AEf{ce}}}NnOh}{{{h{{Nh{c}}}}}{{Bf{{AEh{c}}Nl}}}Nn}{{{h{{Od{ce}}}}}{{Bf{{AEh{c}}Nl}}}NnOh}{{{h{{Od{ce}}}}}{{Bf{AbAEj}}}NnOh}{{{h{{Od{c{Oh{}{{A@h{e}}}}}}}}}{{Fl{ADn}}}Nn{{AAl{}{{A@l{A@n}}{AA`{AAb}}{AAd{AAf}}{AAh{AAj}}}}NnNnNnNn}}{{{h{{Od{cAAn}}}}}{{Fl{ADn}}}Nn}{{{h{{Od{cAB`}}}}}{{Fl{ADn}}}Nn}{{{h{{Od{ce}}}}}{{Bf{ADnNl}}}NnOh}{{{h{{Nh{c}}}}}{{Bf{ADnNl}}}Nn}1{{{h{{Nh{c}}}}}{{Bf{AElNl}}}Nn}{{}{{h{Mf}}}}00{{{Od{cAEn}}}{{Bf{{Nh{c}}Nl}}}Nn}{c{{Nh{c}}}Nn}{c{{Bf{{Nh{c}}Nl}}}Nn}{{{Od{cAAn}}}{{Bf{{Nh{c}}Nl}}}Nn}{{ADn{N`{c}}}{{Bf{{Nh{c}}Nl}}}Nn}{{{ADf{c}}}{{Nh{c}}}Nn}{{{ACl{c}}}{{Nh{c}}}Nn}4{{{Od{cAB`}}}{{Bf{{Nh{c}}Nl}}}Nn}3{{c{Fl{{AF`{c}}}}}{{Bf{{Nh{c}}Nl}}}Nn}614`{{{h{{Od{c{Oh{}{{A@h{e}}}}}}}}}{{Bf{AbNl}}}Nn{{AAl{}{{A@l{A@n}}{AA`{AAb}}{AAd{AAf}}{AAh{AAj}}}}NnNnNnNn}}{{{h{Kd}}}{{Bf{{Od{c}}Nl}}}Oh}{{{h{{Lf{c}}}}{h{Mf}}}{{Bf{{C`{{Nh{Ol}}{An{OlAFb}}}}Nl}}}AFd}1{{{h{Kd}}{h{ABn}}}{{Bf{{Od{c}}Nl}}}Oh}{{{h{{Nh{c}}}}{h{{Nh{c}}}}}{{Fl{Eh}}}{AFfNn}}{{{h{AAn}}{h{AAn}}}{{Fl{Eh}}}}{{{h{AB`}}{h{AB`}}}{{Fl{Eh}}}}{{{h{{Od{ce}}}}{h{{Od{ce}}}}}{{Fl{Eh}}}NnOh}{{{h{c}}}ADnNn}00{{{Nh{On}}{h{c}}}{{Bf{AFh{Nh{On}}}}}{{A@f{On}}}}0`{{{h{{Od{ce}}}}}GbNnOh}{{{h{{Nh{c}}}}}{{Bf{AbNl}}}Nn}{{{h{{Od{ce}}}}}{{Bf{AbAC`}}}NnOh}{{{h{{Nh{c}}}}{h{dAFj}}e}{{Bf{AbNl}}}{NnO`}{{AE`{c}}}}{{{h{{Od{ce}}}}g}{{Bf{{N`{{N`{Ch}}}}Nl}}}{O`Nn}Oh{{AE`{c}}}}0{{{h{{Nh{c}}}}}{{Bf{AfNl}}}{NnO`}}{{{h{{Nh{c}}}}}Af{NnO`}}{{{h{{Od{ce}}}}}ADnNnOh}{{{h{{Nh{c}}}}e}BfNnLj}{{{h{{Od{ce}}}}g}BfNnOhLj}{{}AFl}00{{{h{{Od{ce}}}}{h{{An{AAjc}}}}}{{Od{ce}}}NnOh}`{{{h{c}}}e{}{}}000{{{h{c}}}Fn{}}0{{{h{{Nh{Ol}}}}{h{{An{OlAFb}}}}}Fn}{{{h{{Od{c{Oh{}{{A@h{e}}}}}}}}}{{Bf{AbNl}}}Nn{{AAl{}{{A@l{A@n}}{AA`{AAb}}{AAd{AAf}}{AAh{AAj}}}}NnNnNnNn}}0{{{h{{Nh{c}}}}{h{di}}}{{Bf{{AFn{g}}}}}NnNn{}{{AG`{ceg}}}}{{{h{{Od{ce}}}}{h{dk}}}{{Bf{{AFn{i}}}}}NnOhNn{}{{AG`{cgi}}}}{c{{Bf{e}}}{}{}}0000000`{{{h{c}}}Mb{}}000={ce{}{}}000{{{h{{Od{ce}}}}}GbNnOh}{{{h{Mf}}}{{Bf{FnFf}}}}``````````````{{{h{c}}}{{h{e}}}{}{}}{{{h{dc}}}{{h{de}}}{}{}}{{{h{Ff}}{h{Ff}}}Gb}{{{h{Ff}}{h{dHb}}}Hf}0{cc{}}{AGbFf}{AGdFf}{AGfFf}{AGhFf}{NlFf}{AGjFf}{AGlFf}>{{{h{c}}}Fn{}}{c{{Bf{e}}}{}{}}0{{{h{c}}}Mb{}}{ce{}{}}```````````````````````````````````???????>>>>>>>{{{h{AGn}}}AGn}{{{h{AH`}}}AH`}{{{h{AHb}}}AHb}{{{h{Lb}}}Lb}{{{h{AHd}}}AHd}{{{h{ACd}}}ACd}{{{h{c}}{h{de}}}Ab{}{}}00000``{{}AHd}{{{h{AGn}}{h{AGn}}}Gb}{{{h{AH`}}{h{AH`}}}Gb}{{{h{AHb}}{h{AHb}}}Gb}{{{h{Lb}}{h{Lb}}}Gb}{{{h{AHd}}{h{AHd}}}Gb}{{{h{AGj}}{h{AGj}}}Gb}{{{h{c}}{h{e}}}Gb{}{}}00000000000{{{h{AGn}}{h{dHb}}}Hf}{{{h{AH`}}{h{dHb}}}Hf}{{{h{AHb}}{h{dHb}}}Hf}{{{h{Lb}}{h{dHb}}}Hf}{{{h{AHd}}{h{dHb}}}Hf}{{{h{AGj}}{h{dHb}}}Hf}0{{{h{ACd}}{h{dHb}}}Hf}{cc{}}0{GbAHb}1{AH`Lb}2222{{{h{Lb}}{h{{An{Fn{N`{ADn}}}}}}}{{Bf{AHdAGj}}}}{{{h{AGn}}{h{dc}}}AbJl}{{{h{AHd}}{h{dc}}}AbJl}{{{h{AH`}}}Fn}`{ce{}{}}000000{{{h{AH`}}}Gb}{{{h{AHb}}}Gb}{{{h{AHd}}}Gb}`{{{h{AHd}}{h{AHd}}}{{Fl{Eh}}}}{{{h{Lb}}}Gb}`{{{h{AGn}}c}BfLj}{{{h{AH`}}c}BfLj}{{{h{AHb}}c}BfLj}{{{h{Lb}}c}BfLj}{{{h{AHd}}c}BfLj}`{{{h{c}}}e{}{}}00000{{{h{c}}}Fn{}}{c{{Bf{e}}}{}{}}0000000000000{{{h{c}}}Mb{}}000000>>>>>>>``````````````````````````````````````{{{h{c}}}{{h{e}}}{}{}}00000000000{{{h{dc}}}{{h{de}}}{}{}}00000000000{{AHfL`}{{Bf{AHhFf}}}}{{{AHj{c}}L`}{{Bf{AHhFf}}}{{AHl{AAn}}}}{{{AHn{c}}L`}{{Bf{AHhFf}}}{{AHl{AB`}}}}{{{AI`{c}}L`}{{Bf{AHhFf}}}{{AHl{AB`}}}}{{{AIb{c}}L`}{{Bf{AHhFf}}}{{AHl{AId}}}}{{{AIf{c}}L`}{{Bf{AHhFf}}}{{AIh{AAn}}}}{{{AIj{c}}L`}{{Bf{AHhFf}}}{{AIh{AAn}}}}{{{AIl{c}}L`}{{Bf{AHhFf}}}{{AIh{AB`}}}}{{{AIn{c}}L`}{{Bf{AHhFf}}}{{AIh{AB`}}}}{{{AJ`{c}}L`}{{Bf{AHhFf}}}{{AIh{AB`}}}}{{{AJb{c}}L`}{{Bf{AHhFf}}}{{AIh{AB`}}}}{{{AJd{c}}L`}{{Bf{AHhFf}}}{{AIh{AId}}}}{{{AJf{c}}L`}{{Bf{AHhFf}}}{{AIh{AId}}}}{{{h{{AHj{c}}}}}{{AHj{c}}}{Al{AHl{AAn}}}}{{{h{{AHn{c}}}}}{{AHn{c}}}{Al{AHl{AB`}}}}{{{h{{AI`{c}}}}}{{AI`{c}}}{Al{AHl{AB`}}}}{{{h{{AIb{c}}}}}{{AIb{c}}}{Al{AHl{AId}}}}{{{h{{AIf{c}}}}}{{AIf{c}}}{Al{AIh{AAn}}}}{{{h{{AIj{c}}}}}{{AIj{c}}}{Al{AIh{AAn}}}}{{{h{{AIl{c}}}}}{{AIl{c}}}{Al{AIh{AB`}}}}{{{h{{AIn{c}}}}}{{AIn{c}}}{Al{AIh{AB`}}}}{{{h{{AJ`{c}}}}}{{AJ`{c}}}{Al{AIh{AB`}}}}{{{h{{AJb{c}}}}}{{AJb{c}}}{Al{AIh{AB`}}}}{{{h{{AJd{c}}}}}{{AJd{c}}}{Al{AIh{AId}}}}{{{h{{AJf{c}}}}}{{AJf{c}}}{Al{AIh{AId}}}}{{{h{c}}{h{de}}}Ab{}{}}00000000000{{{h{{AHj{c}}}}{h{dHb}}}Hf{Hh{AHl{AAn}}}}{{{h{{AHn{c}}}}{h{dHb}}}Hf{Hh{AHl{AB`}}}}{{{h{{AI`{c}}}}{h{dHb}}}Hf{Hh{AHl{AB`}}}}{{{h{{AIb{c}}}}{h{dHb}}}Hf{Hh{AHl{AId}}}}{{{h{{AIf{c}}}}{h{dHb}}}Hf{Hh{AIh{AAn}}}}{{{h{{AIj{c}}}}{h{dHb}}}Hf{Hh{AIh{AAn}}}}{{{h{{AIl{c}}}}{h{dHb}}}Hf{Hh{AIh{AB`}}}}{{{h{{AIn{c}}}}{h{dHb}}}Hf{Hh{AIh{AB`}}}}{{{h{{AJ`{c}}}}{h{dHb}}}Hf{Hh{AIh{AB`}}}}{{{h{{AJb{c}}}}{h{dHb}}}Hf{Hh{AIh{AB`}}}}{{{h{{AJd{c}}}}{h{dHb}}}Hf{Hh{AIh{AId}}}}{{{h{{AJf{c}}}}{h{dHb}}}Hf{Hh{AIh{AId}}}}{cc{}}00000000000{ce{}{}}00000000000{{AHh{h{{Lf{Ld}}}}L`}{{Bf{{C`{KfKh}}Ff}}}}{{c{h{{Lf{Ld}}}}L`}{{Bf{{C`{{Nh{Ol}}{An{OlAFb}}}}Ff}}}{}}00000000000{{{h{c}}}e{}{}}00000000000{c{{Bf{e}}}{}{}}00000000000000000000000{{{h{c}}}Mb{}}00000000000555555555555``````````````````````````````{{{h{c}}}{{h{e}}}{}{}}00{{{h{dc}}}{{h{de}}}{}{}}00{{{h{AJh}}}AJh}{{{h{c}}{h{de}}}Ab{}{}}{{{h{AJh}}{h{dHb}}}Hf}0{{{h{Jd}}{h{dHb}}}Hf}0{{{h{Df}}{h{dHb}}}Hf}0={NdJd}{AJjJd}{FfJd}{AGjJd}{cc{}}{AJhJd}1{ce{}{}}00{{{h{c}}}e{}{}}{{{h{c}}}Fn{}}00{c{{Bf{e}}}{}{}}00000{{{h{c}}}Mb{}}00444``````````{{{h{c}}}{{h{e}}}{}{}}{{{h{dc}}}{{h{de}}}{}{}}{{{h{AJl}}}{{Fl{Fn}}}}{{{h{AJl}}}Fn}{c{{Bf{AJl}}}G`}{{{h{f}}{h{Mf}}Gb}{{Bf{AJl{h{Mf}}}}}}{{{h{AJl}}{h{dHb}}}Hf}0={{{h{Mf}}}{{Bf{AJlc}}}{}}<``{{{h{AJl}}c}BfLj};::9=```````````````````````````````````````````{{}AJn}{{}Ob}{{OlBb}{{Bf{OnA@`}}}};;;;;;;;;;;;::::::::::::{{{h{{AK`{ce}}}}{h{g}}}{{A@d{{A@b{c}}}}}{O`Nn}Oh{{A@f{c}}}}{{{h{{Od{c{Oh{}{{A@h{e}}}}}}}}}{{Bf{AbA@j}}}Nn{{AAl{}{{A@l{A@n}}{AA`{AAb}}{AAd{AAf}}{AAh{AAj}}}}NnNnNnNn}}00000{{{h{c}}}{{Bf{AbA@j}}}Nn}{{{h{{Of{c{Oh{}{{A@h{e}}}}}}}}}{{Bf{AbA@j}}}Nn{{AAl{}{{A@l{A@n}}{AA`{AAb}}{AAd{AAf}}{AAh{AAj}}}}NnNnNnNn}}{{{h{{Cj{{N`{Ch}}}}}}}{{Bf{AbA@j}}}}{{{h{{AKb{ce}}}}}{{AKb{ce}}}AlOh}{{{h{Ob}}}Ob}{{{h{AKd}}}AKd}{{{h{{AK`{ce}}}}}{{AK`{ce}}}{AlNn}{AlOh}}{{{h{Ol}}}Ol}{{{h{AFb}}}AFb}{{{h{AKf}}}AKf}{{{h{AKh}}}AKh}{{{h{AKj}}}AKj}{{{h{c}}{h{de}}}Ab{}{}}00000000{{{h{{AK`{ce}}}}{h{{AK`{ce}}}}}Eh{ABbNn}{ABbOh}}{{{h{Ol}}{h{Ol}}}Eh}{{{h{AKf}}{h{AKf}}}Eh}{{{h{AKj}}{h{AKj}}}Eh}`{{}AKd}{{{h{{AKb{ce}}}}}{{h{g}}}{}Oh{}}{{OlBb}{{Bf{OnA@`}}}}{c{{Bf{Ol}}}G`}{{{h{{AK`{ce}}}}}Af{O`Nn}Oh}{{{h{Ob}}{h{Ob}}}Gb}{{{h{AGd}}{h{AGd}}}Gb}{{{h{{AK`{ce}}}}{h{{AK`{ce}}}}}Gb{GfNn}{GfOh}}{{{h{Ol}}{h{Ol}}}Gb}{{{h{AFb}}{h{AFb}}}Gb}{{{h{AKf}}{h{AKf}}}Gb}{{{h{AKh}}{h{AKh}}}Gb}{{{h{AKj}}{h{AKj}}}Gb}{{{h{c}}{h{e}}}Gb{}{}}0000000000000{{{h{{AKl{c}}}}{h{dHb}}}Hf{HhOh}}{{{h{Ob}}{h{dHb}}}Hf}{{{h{AKd}}{h{dHb}}}Hf}{{{h{AGd}}{h{dHb}}}Hf}0{{{h{{AK`{ce}}}}{h{dHb}}}{{Bf{AbHd}}}NnOh}0{{{h{Ol}}{h{dHb}}}{{Bf{AbHd}}}}0{{{h{AFb}}{h{dHb}}}{{Bf{AbHd}}}}0{{{h{AKf}}{h{dHb}}}{{Bf{AbHd}}}}{{{h{AKh}}{h{dHb}}}{{Bf{AbHd}}}}{{{h{AKj}}{h{dHb}}}{{Bf{AbHd}}}}{{{h{{AK`{ce}}}}g}GbNnOh{{ACj{{h{c}}}{{ACh{Gb}}}}}}{cc{}}{AKn{{AL`{c}}}Oh}{ALb{{AL`{c}}}Oh}22222{AGfAGd}{NlAGd}44{OnOl}5555{{OlAJn}{{AKl{c}}}Oh}{{AFbAJn}{{AKl{c}}}Oh}{{{h{Mf}}}{{Bf{Ol}}}}{{{h{Mf}}}{{Bf{AFb}}}}{{{h{ADl}}}{{Bf{{AK`{ce}}Nl}}}{ALdNn}Oh}{{{h{Ol}}}{{Fl{ALf}}}}{{{h{Ol}}}{{N`{ALf}}}}{c{{Bf{{AKb{{ALn{}{{ALh{e}}{ALj{c}}{ALl{g}}}}i}}g}}}{}{{AM`{{Cj{Ch}}}}AMb}HhOh}{{}{{Bf{{AKb{AMdc}}e}}}Oh{}}{{{h{dc}}}{{Bf{{AKb{AMde}}g}}}{AMfAMh}Oh{}}{{c{h{de}}}{{Bf{{AKb{{ALn{}{{ALh{g}}{ALj{c}}{ALl{i}}}}k}}i}}}{}{AMfAMh}{{AM`{{Cj{Ch}}}}AMb}HhOh}{{ce}{{Bf{{AKb{{ALn{}{{ALh{e}}{ALj{c}}{ALl{g}}}}i}}g}}}{}{{AM`{{Cj{Ch}}}}AMb}HhOh}{c{{Bf{{AKb{AMde}}g}}}{}Oh{}}{{{h{{AL`{c}}}}}GbOh}{{{h{Ol}}}Gb}{{{h{{AK`{ce}}}}{h{dg}}}Ab{AEbNn}{AEbOh}Jl}{{{h{Ol}}{h{dc}}}AbJl}{{{h{AKf}}{h{dc}}}AbJl}{{{h{AKj}}{h{dc}}}AbJl}{ce{}{}}00000000000{OlAMj}{AHl{{Bf{{AKl{c}}AGd}}}Oh}{{AIh{Fl{AMl}}ALf}{{Bf{{AKl{c}}AGd}}}Oh}{{{AKb{ec}}{Fl{AMl}}ALf}{{Bf{{AKl{c}}AGd}}}Oh{{AIh{c}}}}{{{AKb{ec}}}{{Bf{{AKl{c}}AGd}}}Oh{{AHl{c}}}}{{{AKl{c}}}{{Bf{{AKl{c}}AGd}}}Oh}{Ol{{Bf{{AKl{c}}AGd}}}Oh}{AFb{{Bf{{AKl{c}}AGd}}}Oh}{AIh{{Bf{{AL`{c}}AGd}}}Oh}{{{AL`{c}}}{{Bf{{AL`{c}}AGd}}}Oh}{{{AKb{ec}}}{{Bf{{AL`{c}}AGd}}}Oh{{AIh{c}}}}{{{AKb{ce}}}c{}Oh}{Ol{{N`{Ol}}}}{AFb{{N`{AFb}}}}{{{AL`{c}}L`}{{Fl{ALb}}}Oh}{{{AL`{c}}L`{h{{Lf{e}}}}}AKnOhAFd}{{{h{Ol}}}Gb}{{}Gb}{{{h{Ob}}}Gb}2{{{h{AFb}}}Gb}212133{{{h{{AK`{ce}}}}}ADnNnOh}``{{{h{{AK`{ce}}}}}{{Bf{{AEh{c}}Nl}}}NnOh}{{}AJn}{{{h{Ol}}}AMn}{{{h{{Od{c{Oh{}{{A@h{e}}}}}}}}}{{Fl{ADn}}}Nn{{AAl{}{{A@l{A@n}}{AA`{AAb}}{AAd{AAf}}{AAh{AAj}}}}NnNnNnNn}}44{{{h{AJn}}{h{AJn}}}AJn}5{{}{{h{Mf}}}}{{ADn{N`{c}}}{{Bf{{AK`{ce}}Nl}}}NnOh}{{{h{Ol}}}ADn}``{{{h{{Od{c{Oh{}{{A@h{e}}}}}}}}}{{Bf{AbNl}}}Nn{{AAl{}{{A@l{A@n}}{AA`{AAb}}{AAd{AAf}}{AAh{AAj}}}}NnNnNnNn}}{{{AKl{c}}AJn}{{AKl{c}}}Oh}{{{h{{AK`{ce}}}}{h{{AK`{ce}}}}}{{Fl{Eh}}}{AFfNn}{AFfOh}}{{{h{Ol}}{h{Ol}}}{{Fl{Eh}}}}{{{h{AKf}}{h{AKf}}}{{Fl{Eh}}}}{{{h{AKj}}{h{AKj}}}{{Fl{Eh}}}}{{{h{c}}}ADnNn}{{{h{{AK`{ce}}}}}{{h{{Cj{c}}}}}NnOh}{{{h{{AK`{ce}}}}}{{Bf{AbNl}}}NnOh}{{{h{{AK`{ce}}}}g}{{Bf{{N`{{N`{Ch}}}}Nl}}}{O`Nn}Oh{{AE`{c}}}}{{{h{{AK`{ce}}}}}ADnNnOh}{{{h{Ol}}c}BfLj}{{}AFl}{{{h{{AK`{ce}}}}}{{Of{ce}}}{O`Nn}Oh}{{}AJn}{{{h{c}}}e{}{}}00000000{{{h{AFb}}{h{{Lf{c}}}}}{{Bf{OlAN`}}}AFd}{{{h{c}}}Fn{}}000{{{h{{Od{c{Oh{}{{A@h{e}}}}}}}}}{{Bf{AbNl}}}Nn{{AAl{}{{A@l{A@n}}{AA`{AAb}}{AAd{AAf}}{AAh{AAj}}}}NnNnNnNn}}0{{{h{{AK`{ce}}}}{h{dk}}}{{Bf{{AK`{ge}}{AFn{i}}}}}NnOhNn{}{{AG`{cgi}}}}{c{{Bf{e}}}{}{}}00000000000000000000000{{{h{c}}}Mb{}}00000000000{ce{}{}}00000000000`{{{h{ANb}}}{{Fl{Dh}}}}{{{h{ANb}}}{{Fl{Dl}}}}{{{h{ANb}}ADn}{{Fl{K`}}}}`{{{h{F`}}{h{Mf}}{h{{Cj{{h{{Cj{{h{Mf}}}}}}}}}}}{{Bf{AbANd}}}}````````````````````````````````````{{{h{dJf}}ANfl{A`{n}}}{{Fl{{A`{n}}}}}}``{{{h{Jf}}{h{{Lf{Ld}}}}}Kh}`{{{h{c}}}{{h{e}}}{}{}}0000000{{{h{dc}}}{{h{de}}}{}{}}0000000{{Kh{h{{Nh{Ol}}}}{h{{Lf{Ld}}}}}Jf}{{{h{ANf}}}ANf}{{{h{ANh}}}ANh}{{{h{{ANj{c}}}}}{{ANj{c}}}{AlANlHhAl}}{{{h{l}}}l}{{{h{Jf}}}Jf}{{{h{Gn}}}Gn}{{{h{ANn}}}ANn}{{{h{c}}{h{de}}}Ab{}{}}000000{{{h{ANf}}{h{ANf}}}Eh}{{{h{l}}{h{l}}}Eh}{{}l}{{}Jf}{{}Gn}{{}ANn}{{{h{{ANj{c}}}}}{{h{e}}}{ANlHhAl}{}}{{{h{AO`}}}{{Fl{AFb}}}}0{{{h{{ANj{AOb}}}}}{{Fl{AFb}}}}{{{h{{ANj{{AOd{ALb}}}}}}}{{Fl{AFb}}}}{{{h{{ANj{{AOf{ALb}}}}}}}{{Fl{AFb}}}}{{{h{ANf}}{h{ANf}}}Gb}{{{h{ANh}}{h{ANh}}}Gb}{{{h{l}}{h{l}}}Gb}{{{h{ANn}}{h{ANn}}}Gb}{{{h{c}}{h{e}}}Gb{}{}}0000000{{{h{Jf}}ANf}{{Fl{{h{{A`{n}}}}}}}}{{{h{ANf}}{h{dHb}}}Hf}{{{h{H`}}{h{dHb}}}Hf}0{{{h{ANh}}{h{dHb}}}Hf}{{{h{{ANj{c}}}}{h{dHb}}}Hf{HhANlHhAl}}{{{h{l}}{h{dHb}}}Hf}{{{h{Jf}}{h{dHb}}}Hf}{{{h{Gn}}{h{dHb}}}Hf}{{{h{ANn}}{h{dHb}}}Hf}{AAjANf}{AMnANf}{cc{}}0000000{{{h{ANf}}{h{dc}}}AbJl}{{{h{AO`}}{h{{Lf{Ld}}}}}ANf}{{{h{{ANj{AOb}}}}{h{{Lf{Ld}}}}}ANf}{{{h{{ANj{{AOf{ALb}}}}}}{h{{Lf{Ld}}}}}ANf}{{{h{{ANj{{AOd{ALb}}}}}}{h{{Lf{Ld}}}}}ANf}{{{h{Jf}}}{{N`{{h{ANf}}}}}}{ce{}{}}0000000{{cANh}{{ANj{c}}}{ANlHhAl}}{{}Jf}{{{h{ANf}}{h{ANf}}}{{Fl{Eh}}}}{{{h{l}}{h{l}}}{{Fl{Eh}}}}{{{h{dJf}}ANfl}{{Fl{{A`{n}}}}}}{{{h{AOh}}{h{dGl}}ADn{h{Gn}}{h{{Lf{Ld}}}}}{{Bf{AbH`}}}}{{{h{{ANj{AOb}}}}{h{dGl}}ADn{h{Gn}}{h{{Lf{Ld}}}}}{{Bf{AbH`}}}}{{{h{{ANj{{AOf{ALb}}}}}}{h{dGl}}ADn{h{Gn}}{h{{Lf{Ld}}}}}{{Bf{AbH`}}}}{{{h{{ANj{{AOd{ALb}}}}}}{h{dGl}}ADn{h{Gn}}{h{{Lf{Ld}}}}}{{Bf{AbH`}}}}{{{h{n}}{h{dGl}}{h{Gn}}{h{{Lf{Ld}}}}}{{Bf{AbH`}}}}{{{h{c}}{h{dGl}}{h{Gn}}{h{{Lf{Ld}}}}}{{Bf{AbH`}}}{}}`{{{h{Jf}}}{{N`{{h{{A`{n}}}}}}}}`{{{h{c}}}e{}{}}000000{{{h{c}}}Fn{}}``{c{{Bf{e}}}{}{}}000000000000000{{{h{c}}}Mb{}}0000000{ce{}{}}0000000````````````````{{{h{d{Dd{c}}}}{h{e}}}{{h{d{Dd{c}}}}}{}{{AOl{AOj}}}}{{{h{d{Dd{c}}}}JjJbAEl}{{Bf{{h{d{Dd{c}}}}AOn}}}{}}{{{h{d{Dd{c}}}}JjJbAElLh}{{Bf{{h{d{Dd{c}}}}AOn}}}{}}{{{h{d{Dd{c}}}}}{{h{d{Dd{c}}}}}{}}{{{h{d{Dd{c}}}}AfDh}{{h{d{Dd{c}}}}}{}}{{{h{d{Dd{c}}}}Jj}{{h{d{Dd{c}}}}}{}}{{{h{d{Dd{c}}}}Jj}{{Bf{{h{d{Dd{c}}}}B@`}}}{}}{{{h{d{Dd{c}}}}{h{{Cj{Jj}}}}}{{Bf{{h{d{Dd{c}}}}B@`}}}{}}{{{h{d{Dd{c}}}}Gb}{{h{d{Dd{c}}}}}{}}{{{h{c}}}{{h{e}}}{}{}}0000{{{h{dc}}}{{h{de}}}{}{}}0000{{{h{d{Dd{c}}}}B@b}{{h{d{Dd{c}}}}}{}}{{{h{{Dd{c}}}}}{{Dd{c}}}Al}{{{h{B@d}}}B@d}{{{h{B@b}}}B@b}{{{h{c}}{h{de}}}Ab{}{}}00{{{h{B@b}}{h{B@b}}}Eh}{{{Dd{c}}e}{{Dd{e}}}{}Mn}{{{h{d{Dd{c}}}}Bb}{{h{d{Dd{c}}}}}{}}{{}B@d}{{}B@b}{{{h{d{Dd{c}}}}}{{h{d{Dd{c}}}}}{}}{{{h{d{Dd{c}}}}Af}{{h{d{Dd{c}}}}}{}}11{{{h{d{Dd{c}}}}Lh}{{h{d{Dd{c}}}}}{}}{{{h{B@b}}{h{B@b}}}Gb}{{{h{c}}{h{e}}}Gb{}{}}0{{{h{d{Dd{c}}}}Dh}{{h{d{Dd{c}}}}}{}}{{{h{d{Dd{c}}}}Dl}{{h{d{Dd{c}}}}}{}}{{{Dd{c}}}{{Bf{GlJd}}}Mn}{{{Dd{c}}{h{de}}}{{Bf{GlJd}}}MnAMh}{{{h{{Dd{c}}}}{h{dHb}}}HfHh}{{{h{B@`}}{h{dHb}}}Hf}0{{{h{AOn}}{h{dHb}}}Hf}0{{{h{B@d}}{h{dHb}}}Hf}{{{h{B@b}}{h{dHb}}}Hf}{cc{}}0000{{{h{B@b}}{h{dc}}}AbJl}?{ce{}{}}0000{{{h{d{Dd{c}}}}}{{h{d{Dd{c}}}}}{}}{{{h{d{Dd{c}}}}B@f}{{h{d{Dd{c}}}}}{}}11{{{h{d{Dd{c}}}}B@d}{{h{d{Dd{c}}}}}{}}{{{h{B@b}}{h{B@b}}}{{Fl{Eh}}}}{{{h{d{Dd{c}}}}{An{Fn{N`{ADn}}}}j}{{h{d{Dd{c}}}}}{}}{{{h{d{Dd{c}}}}{N`{{C`{AfDh}}}}}{{h{d{Dd{c}}}}}{}}{{{h{d{Dd{c}}}}J`}{{h{d{Dd{c}}}}}{}}{{{h{B@d}}{h{dBl}}}Ab}{{{h{B@d}}{h{dBl}}{h{dc}}}AbAMh}{{{h{c}}}e{}{}}00{{{h{c}}}Fn{}}0{c{{Bf{e}}}{}{}}000000000{{{h{c}}}Mb{}}0000{{{h{d{Dd{c}}}}{N`{Jj}}}{{h{d{Dd{c}}}}}{}}{{{h{d{Dd{c}}}}B@h}{{h{d{Dd{c}}}}}{}}?????````","D":"G@`","p":[[5,"Balance",0,1934],[0,"mut"],[5,"Wallet",0,1935],[1,"reference"],[6,"KeychainKind",0,1936],[5,"SignerOrdering",1628,1937],[10,"TransactionSigner",1628,1937],[5,"Arc",1938],[1,"unit"],[17,"Item"],[5,"ScriptBuf",1939],[8,"Indexed",1940],[10,"Iterator",1941],[10,"Clone",1942],[5,"BTreeMap",1943],[5,"Block",1944],[1,"u32"],[5,"CannotConnectError",1945],[6,"Result",1946],[5,"BlockId",1947],[6,"ApplyHeaderError",1945],[5,"Transaction",1948],[1,"u64"],[1,"tuple"],[10,"IntoIterator",1949],[5,"Update",0,1935],[10,"Into",1950],[1,"u8"],[1,"slice"],[5,"ConfirmationBlockTime",1947],[5,"TxGraph",1951],[5,"Txid",1948],[8,"DefaultCoinSelectionAlgorithm",446,1952],[5,"TxBuilder",1815,1953],[6,"BuildFeeBumpError",1206,1954],[5,"Amount",1955],[6,"CalculateFeeError",1951],[5,"FeeRate",1956],[5,"CheckPointIter",1945],[5,"LocalOutput",0,1936],[5,"WeightedUtxo",0,1936],[6,"Utxo",0,1936],[5,"ChangeSet",0,1957],[6,"Ordering",1958],[5,"Store",1959],[5,"CreateParams",0,1960],[10,"IntoWalletDescriptor",545],[5,"Transaction",1961],[5,"Connection",1962],[8,"PersistedWallet",0,1963],[6,"Error",806],[5,"LoadParams",0,1960],[5,"AddressInfo",0,1935],[6,"Option",1964],[5,"String",1965],[10,"Deserializer",1966],[1,"bool"],[6,"LoadWithPersistError",0,1963],[10,"PartialEq",1958],[6,"LoadError",0,1935],[6,"LoadMismatch",0,1935],[5,"Psbt",1967],[5,"SignOptions",1628,1937],[6,"SignerError",1628,1937],[5,"Formatter",1968],[5,"Error",1968],[8,"Result",1968],[10,"Debug",1968],[10,"Display",1968],[6,"CreateWithPersistError",0,1963],[6,"ApplyBlockError",0,1935],[5,"ChangeSet",1951],[5,"ChangeSet",1969],[5,"ChangeSet",1945],[5,"ChangeSet",1970],[5,"SyncResult",1971],[5,"FullScanResult",1971],[8,"Result",1962],[5,"BlockHash",1944],[5,"PsbtSighashType",1972],[5,"Input",1972],[6,"CreateTxError",1206,1954],[5,"SignersContainer",1628,1937],[5,"CanonicalTx",1951],[5,"OutPoint",1948],[10,"Hasher",1973],[5,"AlterCheckPointError",1945],[5,"TxOut",1948],[10,"IsDust",0,1974],[5,"Script",1975],[8,"ExtendedDescriptor",545],[8,"KeyMap",1306,1976],[5,"CheckPoint",1945],[10,"DoubleEndedIterator",1977],[5,"LocalChain",1945],[6,"Network",1978],[5,"Policy",839],[6,"All",1979],[5,"Secp256k1",1980],[5,"Sequence",1948],[10,"Serializer",1981],[5,"KeychainTxOutIndex",1969],[5,"FullScanRequest",1971],[5,"SyncRequest",1971],[5,"TypeId",1982],[5,"TxNode",1951],[1,"str"],[5,"LargestFirstCoinSelection",446,1952],[5,"OldestFirstCoinSelection",446,1952],[5,"BranchAndBoundCoinSelection",446,1952],[10,"CoinSelectionAlgorithm",446,1952],[5,"Vec",1983],[5,"CoinSelectionResult",446,1952],[6,"Error",446,1952],[6,"Excess",446,1952],[6,"Descriptor",545,1976],[5,"Address",1984],[6,"Error",1985],[10,"MiniscriptKey",1985],[10,"ToPublicKey",1985],[6,"ScriptContextEnum",1306],[5,"Miniscript",545,1986],[6,"Terminal",1987],[10,"ScriptContext",1306,1988],[6,"Tree",1989],[6,"DescriptorPublicKey",1306,1990],[5,"DefiniteDescriptorKey",1990],[6,"ConversionError",1990],[6,"Placeholder",1991],[5,"Satisfaction",1991],[10,"AssetProvider",1992],[17,"Key"],[6,"ScriptContextError",1988],[17,"Sha256"],[5,"Hash",1993],[17,"Hash256"],[5,"Hash",1994],[17,"Ripemd160"],[5,"Hash",1995],[17,"Hash160"],[5,"Hash",1996],[10,"ParseableKey",1987],[6,"Legacy",545,1988],[6,"Segwitv0",545,1988],[10,"Ord",1958],[5,"PublicKey",1997],[10,"Verification",1998],[6,"DescriptorType",1976],[5,"DescriptorId",1999],[10,"FromStrKey",2000],[5,"ExtParams",2001],[6,"AnalysisError",2001],[10,"ExtractPolicy",545],[6,"BuildSatisfaction",839],[5,"Range",2002],[17,"Output"],[10,"FnMut",2003],[5,"Wsh",2004],[5,"Pkh",2005],[5,"Sh",2006],[5,"Bare",2005],[5,"Tr",2007],[5,"Wpkh",2004],[5,"Type",2008],[5,"ExtData",2009],[5,"Tree",2010],[1,"usize"],[10,"Satisfier",1991],[10,"Hash",1973],[5,"Iter",2011],[5,"PkIter",2011],[6,"Policy",2012],[6,"LiftError",2013],[5,"Weight",2014],[6,"BareCtx",1988],[6,"TapTree",2007],[6,"DescriptorSecretKey",1306,1990],[10,"Signing",1998],[10,"PartialOrd",1958],[5,"Plan",1992],[5,"TxIn",1948],[6,"SigType",1988],[6,"TranslateErr",1985],[10,"Translator",1985],[6,"HexToBytesError",2015],[6,"KeyError",1306],[6,"Error",2016],[6,"Error",2017],[6,"PolicyError",839],[6,"ParsePublicKeyError",1997],[6,"PkOrF",839],[6,"SatisfiableItem",839],[6,"Satisfaction",839],[5,"Condition",839],[10,"DescriptorTemplate",1022],[8,"DescriptorTemplateOut",1022],[5,"P2Pkh",1022],[10,"IntoDescriptorKey",1306],[5,"P2Wpkh_P2Sh",1022],[5,"P2Wpkh",1022],[5,"P2TR",1022],[6,"Tap",1988],[5,"Bip44",1022],[10,"DerivableKey",1306],[5,"Bip44Public",1022],[5,"Bip49",1022],[5,"Bip49Public",1022],[5,"Bip84",1022],[5,"Bip84Public",1022],[5,"Bip86",1022],[5,"Bip86Public",1022],[6,"MiniscriptPsbtError",1206,1954],[6,"Error",2018],[5,"FullyNodedExport",1283,2019],[8,"ValidNetworks",1306],[5,"SortedMultiVec",1306,2020],[5,"GeneratedKey",1306],[5,"PrivateKeyGenerateOptions",1306],[5,"SinglePub",1306,1990],[5,"SinglePriv",1306,1990],[6,"SinglePubKey",1306,1990],[6,"DescriptorKey",1306],[5,"Xpub",2016],[6,"ExtendedKey",1306],[5,"Xpriv",2016],[10,"FromStr",2021],[5,"DerivationPath",2016],[17,"Entropy"],[17,"Options"],[17,"Error"],[10,"GeneratableKey",1306],[10,"AsMut",1950],[10,"Default",2022],[10,"GeneratableDefaultOptions",1306],[10,"CryptoRng",2023],[10,"RngCore",2023],[5,"Assets",1992],[8,"KeySource",2016],[5,"Fingerprint",2016],[5,"DescriptorKeyParseError",1990],[10,"PsbtUtils",1622],[6,"Error",2024],[6,"SignerId",1628,1937],[6,"SignerContext",1628,1937],[5,"SignerWrapper",1628,1937],[10,"Sized",2025],[6,"TapLeavesOptions",1628,1937],[10,"SignerCommon",1628,1937],[5,"PrivateKey",1997],[5,"DescriptorXKey",1990],[5,"DescriptorMultiXKey",1990],[10,"InputSigner",1628,1937],[5,"PushBytes",2026],[10,"AsRef",1950],[6,"AddForeignUtxoError",1815,1953],[6,"AddUtxoError",1815,1953],[6,"ChangeSpendPolicy",1815,1953],[6,"TxOrdering",1815,1953],[6,"LockTime",2027],[1,"i32"],[15,"InvalidTxid",1930],[15,"UnexpectedConnectedToHash",432],[15,"Network",434],[15,"Genesis",434],[15,"Descriptor",434],[15,"Custom",1932],[15,"Foreign",443],[15,"InsufficientFunds",538],[15,"Change",540],[15,"NoChange",540],[8,"DerivedDescriptor",545],[15,"PsbtTimelocks",998],[15,"Complete",1001],[15,"Partial",1001],[15,"PartialComplete",1001],[15,"Sha256Preimage",1012],[15,"Hash256Preimage",1012],[15,"Ripemd160Preimage",1012],[15,"Hash160Preimage",1012],[15,"Thresh",1012],[15,"Multisig",1012],[15,"AbsoluteTimelock",1012],[15,"RelativeTimelock",1012],[15,"RbfSequenceCsv",1277],[15,"LockTime",1277],[15,"FeeTooLow",1277],[15,"FeeRateTooLow",1277],[8,"WalletExport",1283],[10,"ExtScriptContext",1306],[15,"Tap",1814]],"r":[[0,1953],[1,1953],[2,1935],[3,1935],[4,1934],[8,1957],[9,1953],[10,1960],[11,1963],[19,545],[24,1974],[25,1936],[26,1935],[27,1935],[28,1960],[29,1963],[31,1936],[41,1963],[43,1937],[44,1953],[45,1953],[49,1935],[50,1936],[53,1935],[54,1936],[127,1935],[177,1935],[178,1935],[310,1940],[325,1935],[326,1935],[334,545],[386,1935],[429,1935],[448,1952],[450,1952],[451,1952],[452,1952],[453,1952],[454,1952],[456,1952],[458,1952],[481,1952],[549,1976],[551,1990],[558,1988],[559,1986],[564,839],[565,1988],[566,1988],[600,805],[1206,1954],[1209,1954],[1217,1954],[1283,2019],[1284,2019],[1309,1990],[1310,1990],[1325,1976],[1335,1988],[1340,1990],[1341,1990],[1342,1990],[1343,2020],[1626,2028],[1627,2028],[1635,1937],[1652,1937],[1653,1937],[1654,1937],[1655,1937],[1656,1937],[1657,1937],[1658,1937],[1659,1937],[1661,1937],[1662,1937],[1815,1953],[1816,1953],[1819,1953],[1826,1953],[1827,1953]],"b":[[130,"impl-PersistWith%3CStore%3CChangeSet%3E%3E-for-Wallet"],[131,"impl-Wallet"],[132,"impl-PersistWith%3CTransaction%3C\'c%3E%3E-for-Wallet"],[133,"impl-PersistWith%3CConnection%3E-for-Wallet"],[181,"impl-Display-for-Balance"],[182,"impl-Debug-for-Balance"],[188,"impl-Debug-for-LoadWithPersistError%3CE%3E"],[189,"impl-Display-for-LoadWithPersistError%3CE%3E"],[190,"impl-Debug-for-CreateWithPersistError%3CE%3E"],[191,"impl-Display-for-CreateWithPersistError%3CE%3E"],[194,"impl-Display-for-AddressInfo"],[195,"impl-Debug-for-AddressInfo"],[196,"impl-Display-for-LoadError"],[197,"impl-Debug-for-LoadError"],[199,"impl-Debug-for-ApplyBlockError"],[200,"impl-Display-for-ApplyBlockError"],[209,"impl-From%3CChangeSet%3CConfirmationBlockTime%3E%3E-for-ChangeSet"],[210,"impl-From%3CChangeSet%3E-for-ChangeSet"],[211,"impl-From%3CChangeSet%3E-for-ChangeSet"],[213,"impl-From%3CChangeSet%3CConfirmationBlockTime,+ChangeSet%3E%3E-for-ChangeSet"],[218,"impl-From%3CSyncResult%3E-for-Update"],[219,"impl-From%3CFullScanResult%3CKeychainKind%3E%3E-for-Update"],[273,"impl-Wallet"],[274,"impl-PersistWith%3CStore%3CChangeSet%3E%3E-for-Wallet"],[275,"impl-PersistWith%3CTransaction%3C\'c%3E%3E-for-Wallet"],[276,"impl-PersistWith%3CConnection%3E-for-Wallet"],[300,"impl-PersistWith%3CTransaction%3C\'c%3E%3E-for-Wallet"],[301,"impl-PersistWith%3CStore%3CChangeSet%3E%3E-for-Wallet"],[302,"impl-PersistWith%3CConnection%3E-for-Wallet"],[328,"impl-Staged-for-Wallet"],[329,"impl-Wallet"],[487,"impl-Display-for-Error"],[488,"impl-Debug-for-Error"],[638,"impl-Descriptor%3CDescriptorPublicKey%3E"],[639,"impl-Descriptor%3CDefiniteDescriptorKey%3E"],[666,"impl-Debug-for-Descriptor%3CPk%3E"],[667,"impl-Display-for-Descriptor%3CPk%3E"],[670,"impl-Display-for-Miniscript%3CPk,+Ctx%3E"],[671,"impl-Debug-for-Miniscript%3CPk,+Ctx%3E"],[674,"impl-From%3CWsh%3CPk%3E%3E-for-Descriptor%3CPk%3E"],[675,"impl-From%3CPkh%3CPk%3E%3E-for-Descriptor%3CPk%3E"],[676,"impl-From%3CSh%3CPk%3E%3E-for-Descriptor%3CPk%3E"],[678,"impl-From%3CBare%3CPk%3E%3E-for-Descriptor%3CPk%3E"],[679,"impl-From%3CTr%3CPk%3E%3E-for-Descriptor%3CPk%3E"],[680,"impl-From%3CWpkh%3CPk%3E%3E-for-Descriptor%3CPk%3E"],[823,"impl-Display-for-Error"],[824,"impl-Debug-for-Error"],[826,"impl-From%3CHexToBytesError%3E-for-Error"],[827,"impl-From%3CKeyError%3E-for-Error"],[828,"impl-From%3CError%3E-for-Error"],[829,"impl-From%3CError%3E-for-Error"],[830,"impl-From%3CError%3E-for-Error"],[831,"impl-From%3CPolicyError%3E-for-Error"],[832,"impl-From%3CParsePublicKeyError%3E-for-Error"],[926,"impl-Display-for-PolicyError"],[927,"impl-Debug-for-PolicyError"],[1244,"impl-Debug-for-MiniscriptPsbtError"],[1245,"impl-Display-for-MiniscriptPsbtError"],[1246,"impl-Display-for-CreateTxError"],[1247,"impl-Debug-for-CreateTxError"],[1248,"impl-Debug-for-BuildFeeBumpError"],[1249,"impl-Display-for-BuildFeeBumpError"],[1251,"impl-From%3CError%3E-for-CreateTxError"],[1252,"impl-From%3CError%3E-for-CreateTxError"],[1253,"impl-From%3CError%3E-for-CreateTxError"],[1254,"impl-From%3CPolicyError%3E-for-CreateTxError"],[1256,"impl-From%3CMiniscriptPsbtError%3E-for-CreateTxError"],[1293,"impl-Debug-for-FullyNodedExport"],[1294,"impl-Display-for-FullyNodedExport"],[1439,"impl-Display-for-KeyError"],[1440,"impl-Debug-for-KeyError"],[1441,"impl-Display-for-SortedMultiVec%3CPk,+Ctx%3E"],[1442,"impl-Debug-for-SortedMultiVec%3CPk,+Ctx%3E"],[1443,"impl-Display-for-DescriptorPublicKey"],[1444,"impl-Debug-for-DescriptorPublicKey"],[1445,"impl-Display-for-DescriptorSecretKey"],[1446,"impl-Debug-for-DescriptorSecretKey"],[1452,"impl-From%3CXpub%3E-for-ExtendedKey%3CCtx%3E"],[1453,"impl-From%3CXpriv%3E-for-ExtendedKey%3CCtx%3E"],[1459,"impl-From%3CError%3E-for-KeyError"],[1460,"impl-From%3CError%3E-for-KeyError"],[1502,"impl-DerivableKey%3CCtx%3E-for-GeneratedKey%3CK,+Ctx%3E"],[1503,"impl-IntoDescriptorKey%3CCtx%3E-for-GeneratedKey%3CK,+Ctx%3E"],[1709,"impl-SignerCommon-for-SignerWrapper%3CPrivateKey%3E"],[1710,"impl-SignerCommon-for-SignerWrapper%3CDescriptorXKey%3CXpriv%3E%3E"],[1711,"impl-SignerCommon-for-SignerWrapper%3CDescriptorMultiXKey%3CXpriv%3E%3E"],[1726,"impl-Display-for-SignerError"],[1727,"impl-Debug-for-SignerError"],[1734,"impl-From%3CHash%3E-for-SignerId"],[1735,"impl-From%3CFingerprint%3E-for-SignerId"],[1746,"impl-SignerCommon-for-SignerWrapper%3CPrivateKey%3E"],[1747,"impl-SignerCommon-for-SignerWrapper%3CDescriptorMultiXKey%3CXpriv%3E%3E"],[1748,"impl-SignerCommon-for-SignerWrapper%3CDescriptorXKey%3CXpriv%3E%3E"],[1764,"impl-InputSigner-for-SignerWrapper%3CPrivateKey%3E"],[1765,"impl-InputSigner-for-SignerWrapper%3CDescriptorMultiXKey%3CXpriv%3E%3E"],[1766,"impl-InputSigner-for-SignerWrapper%3CDescriptorXKey%3CXpriv%3E%3E"],[1874,"impl-Display-for-AddUtxoError"],[1875,"impl-Debug-for-AddUtxoError"],[1876,"impl-Display-for-AddForeignUtxoError"],[1877,"impl-Debug-for-AddForeignUtxoError"]],"c":"OjAAAAEAAAAAAAUAEAAAAH4CyALUAgUFhAXsBQ==","e":"OzAAAAEAAA4EhAAUAAAAOAAAAEMAAQBHACAAbQAAAHEADgCDAAAAhQABAIsABACYABkAtAAAALYAEwDSAAIA1gABANsAAQDfAAAA6wABAAQBAAATAQIAIAEAACsBAAAtAQIANgEAADwBBQBHAQAASQEAAE8BDQBjAR8AiAEPAJ4BDwDMAREA3wECAOMBAgDoAQYA/wEbACcCAAA1AgAASQIBAEwCAABOAgcAWQIAAFsCAQBeAgAAYQIBAGQCAQBoAgEAawIBAG4CAQBxAgsAggIDAIcCCwCYAgEAmwIKAKcCAgCvAgAAvAIDAMcCAADNAgEA0QIBANgCAQDuAgMA8wIBAAEDAQAEAwEACAMFABMDBwAcAwMAIQMDADUDBAA7AwYAQwMEAGsDGQCHAxoApAMAAKYDAACsAwEAuwMAAL4DBADEAyIADQQXACYELwBuBEgA1QQNAOQEAwDpBAAA7gQPAAgFAQAMBQAADgUBABEFAAAVBQUASQUXAGsFFQCCBQEAhQUAAIcFJACtBQEAtAUBALgFAAC/BQEAzAUDANwFAADfBQQA5QUBAPUFAQD6BQAABAYAAAkGAwASBgAAFgYIACAGAwAnBi8AhgYPAJcGFACuBg4AvgYKANEGAADTBgIA4QYBAOUGAgDpBgAA7QYHAPcGHwAwBwkAOwcGAEQHAQBLBwIAUgcGAF4HAABqBwAAcAcTAIYHBAA="}],\
 ["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":"PGFPPPGGFPPFPGIIPPPPPPPIPPPGEONNNNNNNNENNNNNNNNNNNNNNNNOOENNNNNNNNNNNOOHOONONNNNNNNNNNNNNNNNNNNNNNNNNNNNNHNNNOOOOHONNNNNNNNNNOONHNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNOOOOOOOOOOO","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","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"],[177,"example_cli::AddressCmd"],[178,"example_cli::Commands"],[184,"example_cli::TxOutCmd"],[188,"clap::builder::command"],[189,"core::clone"],[190,"clap::derive"],[191,"core::cmp"],[192,"miniscript::descriptor::key"],[193,"alloc::collections::btree::map"],[194,"bitcoin::address"],[195,"bitcoin::blockdata::transaction"],[196,"core::option"],[197,"anyhow"],[198,"bdk_chain::tx_data_traits"],[199,"bdk_chain::chain_oracle"],[200,"core::result"],[201,"serde::de"],[202,"core::fmt"],[203,"clap::parser::matches::arg_matches"],[204,"clap::error"],[205,"std::sync::mutex"],[206,"bdk_file_store::store"],[207,"bitcoin::network"],[208,"core::default"],[209,"serde::ser"],[210,"core::convert"],[211,"core::marker"],[212,"core::ops::function"],[213,"bdk_tmp_plan"],[214,"alloc::vec"],[215,"alloc::string"],[216,"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,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{}{}}00{{{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",188],[1,"reference"],[0,"mut"],[6,"Commands",0],[10,"Clone",189],[10,"Subcommand",190],[10,"Args",190],[6,"CoinSelectionAlgo",0],[6,"AddressCmd",0],[6,"TxOutCmd",0],[6,"Keychain",0],[1,"unit"],[6,"Ordering",191],[8,"KeychainTxGraph",0],[6,"DescriptorPublicKey",192],[6,"DescriptorSecretKey",192],[5,"BTreeMap",193],[5,"Address",194],[1,"u64"],[5,"Transaction",195],[5,"CreateTxChange",0],[6,"Option",196],[1,"tuple"],[8,"Result",197],[10,"Anchor",198],[10,"ChainOracle",199],[6,"Result",200],[10,"Deserializer",201],[1,"bool"],[5,"Formatter",202],[8,"Result",202],[10,"Debug",202],[5,"ArgMatches",203],[5,"Args",0],[5,"Error",204],[1,"str"],[5,"Mutex",205],[5,"Store",206],[6,"Network",207],[10,"Default",208],[10,"Merge",198],[10,"DeserializeOwned",201],[10,"Serialize",209],[8,"KeychainChangeSet",0],[10,"From",210],[10,"Send",211],[10,"Sync",211],[17,"Output"],[10,"FnOnce",212],[1,"u8"],[1,"slice"],[5,"Init",0],[5,"Assets",213],[8,"PlannedUtxo",0],[5,"Vec",214],[10,"CanDerive",213],[10,"Serializer",209],[5,"String",215],[5,"TypeId",216],[15,"List",177],[15,"Address",178],[15,"Send",178],[15,"TxOut",178],[15,"List",184]],"r":[],"b":[[82,"impl-Display-for-CoinSelectionAlgo"],[83,"impl-Debug-for-CoinSelectionAlgo"],[86,"impl-Debug-for-Keychain"],[87,"impl-Display-for-Keychain"]],"c":"OjAAAAAAAAA=","e":"OzAAAAEAAJQAEQAAAAAAAgABAAUABQANAAQAFQAAABcAAQAaAAAAHAABAB8AKQBKAA4AYQAMAG8AAABxAAAAfAABAH8AMgCzAAAAtQACAA=="}],\
+["example_cli",{"t":"PGFPPPGGFPPFPGIIPPPPPPPIPPPGEONNNNNNNNENNNNNNNNNNNNNNNNOOENNNNNNNNNNNOOHOONONNNNNNNNNNNNNNNNNNNNNNNNNNNNNHNNNOOOOHONNNNNNNNNNOONHNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNOOOOOOOOOOO","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","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"],[177,"example_cli::AddressCmd"],[178,"example_cli::Commands"],[184,"example_cli::TxOutCmd"],[188,"clap::builder::command"],[189,"core::clone"],[190,"clap::derive"],[191,"core::cmp"],[192,"miniscript::descriptor::key"],[193,"alloc::collections::btree::map"],[194,"bitcoin::address"],[195,"bitcoin::blockdata::transaction"],[196,"core::option"],[197,"anyhow"],[198,"bdk_chain::tx_data_traits"],[199,"bdk_chain::chain_oracle"],[200,"core::result"],[201,"serde::de"],[202,"core::fmt"],[203,"clap::parser::matches::arg_matches"],[204,"clap::error"],[205,"std::sync::mutex"],[206,"bdk_file_store::store"],[207,"bitcoin::network"],[208,"core::default"],[209,"serde::ser"],[210,"core::convert"],[211,"core::marker"],[212,"core::ops::function"],[213,"bdk_tmp_plan"],[214,"alloc::vec"],[215,"alloc::string"],[216,"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,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{}{}}00{{{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",188],[1,"reference"],[0,"mut"],[6,"Commands",0],[10,"Clone",189],[10,"Subcommand",190],[10,"Args",190],[6,"CoinSelectionAlgo",0],[6,"AddressCmd",0],[6,"TxOutCmd",0],[6,"Keychain",0],[1,"unit"],[6,"Ordering",191],[8,"KeychainTxGraph",0],[6,"DescriptorPublicKey",192],[6,"DescriptorSecretKey",192],[5,"BTreeMap",193],[5,"Address",194],[1,"u64"],[5,"Transaction",195],[5,"CreateTxChange",0],[6,"Option",196],[1,"tuple"],[8,"Result",197],[10,"Anchor",198],[10,"ChainOracle",199],[6,"Result",200],[10,"Deserializer",201],[1,"bool"],[5,"Formatter",202],[8,"Result",202],[10,"Debug",202],[5,"ArgMatches",203],[5,"Args",0],[5,"Error",204],[1,"str"],[5,"Mutex",205],[5,"Store",206],[6,"Network",207],[10,"Default",208],[10,"Merge",198],[10,"DeserializeOwned",201],[10,"Serialize",209],[8,"KeychainChangeSet",0],[10,"From",210],[10,"Send",211],[10,"Sync",211],[17,"Output"],[10,"FnOnce",212],[1,"u8"],[1,"slice"],[5,"Init",0],[5,"Assets",213],[8,"PlannedUtxo",0],[5,"Vec",214],[10,"CanDerive",213],[10,"Serializer",209],[5,"String",215],[5,"TypeId",216],[15,"List",177],[15,"Address",178],[15,"Send",178],[15,"TxOut",178],[15,"List",184]],"r":[],"b":[[82,"impl-Debug-for-CoinSelectionAlgo"],[83,"impl-Display-for-CoinSelectionAlgo"],[86,"impl-Display-for-Keychain"],[87,"impl-Debug-for-Keychain"]],"c":"OjAAAAAAAAA=","e":"OzAAAAEAAJQAEQAAAAAAAgABAAUABQANAAQAFQAAABcAAQAaAAAAHAABAB8AKQBKAA4AYQAMAG8AAABxAAAAfAABAH8AMgCzAAAAtQACAA=="}],\
 ["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=="}],\
 ["example_esplora",{"t":"ISSFGPFPNNNNNNNNNNNNNNNNNNNNNONNNNNNNNNNNNNNNNNNHONNNNNNNNNNNNNNNNNNNNNOOOOOOOOO","n":["ChangeSet","DB_MAGIC","DB_PATH","EsploraArgs","EsploraCommands","Scan","ScanOptions","Sync","augment_args","augment_args","augment_args_for_update","augment_args_for_update","augment_subcommands","augment_subcommands_for_update","borrow","borrow","borrow","borrow_mut","borrow_mut","borrow_mut","client","clone","clone","clone","clone_into","clone_into","clone_into","eq","esplora_args","esplora_url","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","parallel_requests","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","esplora_args","esplora_args","scan_options","scan_options","stop_gap","unconfirmed","unused_spks","utxos"],"q":[[0,"example_esplora"],[71,"example_esplora::EsploraCommands"],[80,"clap::builder::command"],[81,"bitcoin::network"],[82,"esplora_client::blocking"],[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,8,4,9,8,4,9,4,8,4,9,8,4,9,9,8,4,8,4,9,8,4,9,8,4,9,8,4,9,8,8,4,9,9,9,0,9,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{Ab}}{d{Ab}}}Af}{{{d{A`}}}h}`{{{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,"EsploraArgs",0],[6,"Network",81],[5,"BlockingClient",82],[8,"Result",83],[6,"EsploraCommands",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":"OzAAAAEAAEEACAAAAAUABwAAAAkAFAAfAAIAJQAGAC8AAgAzABQASQADAA=="}],\
 ["wallet_electrum_example",{"t":"SSSSSSSSH","n":["BATCH_SIZE","DB_MAGIC","ELECTRUM_URL","EXTERNAL_DESC","INTERNAL_DESC","NETWORK","SEND_AMOUNT","STOP_GAP","main"],"q":[[0,"wallet_electrum_example"],[9,"anyhow"],[10,"core::result"]],"i":[0,0,0,0,0,0,0,0,0],"f":"````````{{}{{f{bd}}}}","D":"`","p":[[1,"unit"],[5,"Error",9],[6,"Result",10]],"r":[],"b":[],"c":"OjAAAAAAAAA=","e":"OzAAAAEAAAkAAQAAAAkA"}],\
diff --git a/docs/.vuepress/public/docs-rs/bdk/nightly/latest/src/bdk_chain/balance.rs.html b/docs/.vuepress/public/docs-rs/bdk/nightly/latest/src/bdk_chain/balance.rs.html
index 5cd22a3ac7..5fe8b2cbc3 100644
--- a/docs/.vuepress/public/docs-rs/bdk/nightly/latest/src/bdk_chain/balance.rs.html
+++ b/docs/.vuepress/public/docs-rs/bdk/nightly/latest/src/bdk_chain/balance.rs.html
@@ -51,19 +51,11 @@
 51
 52
 53
-54
-55
-56
-57
 use bitcoin::Amount;
 
 /// Balance, differentiated into various categories.
 #[derive(Debug, PartialEq, Eq, Clone, Default)]
-#[cfg_attr(
-    feature = "serde",
-    derive(serde::Deserialize, serde::Serialize),
-    serde(crate = "serde_crate",)
-)]
+#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
 pub struct Balance {
     /// All coinbase outputs not yet matured
     pub immature: Amount,
diff --git a/docs/.vuepress/public/docs-rs/bdk/nightly/latest/src/bdk_chain/chain_data.rs.html b/docs/.vuepress/public/docs-rs/bdk/nightly/latest/src/bdk_chain/chain_data.rs.html
index 8edaa7a60b..a8a917d84d 100644
--- a/docs/.vuepress/public/docs-rs/bdk/nightly/latest/src/bdk_chain/chain_data.rs.html
+++ b/docs/.vuepress/public/docs-rs/bdk/nightly/latest/src/bdk_chain/chain_data.rs.html
@@ -273,18 +273,6 @@
 273
 274
 275
-276
-277
-278
-279
-280
-281
-282
-283
-284
-285
-286
-287
 
use bitcoin::{hashes::Hash, BlockHash, OutPoint, TxOut, Txid};
 
 use crate::{Anchor, AnchorFromBlockPosition, COINBASE_MATURITY};
@@ -329,11 +317,7 @@
 
 /// Block height and timestamp at which a transaction is confirmed.
 #[derive(Debug, Clone, PartialEq, Eq, Copy, PartialOrd, Ord, core::hash::Hash)]
-#[cfg_attr(
-    feature = "serde",
-    derive(serde::Deserialize, serde::Serialize),
-    serde(crate = "serde_crate")
-)]
+#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
 pub enum ConfirmationTime {
     /// The transaction is confirmed
     Confirmed {
@@ -378,11 +362,7 @@
 /// `BlockId` implements [`Anchor`]. When a transaction is anchored to `BlockId`, the confirmation
 /// block and anchor block are the same block.
 #[derive(Debug, Clone, PartialEq, Eq, Copy, PartialOrd, Ord, core::hash::Hash)]
-#[cfg_attr(
-    feature = "serde",
-    derive(serde::Deserialize, serde::Serialize),
-    serde(crate = "serde_crate")
-)]
+#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
 pub struct BlockId {
     /// The height of the block.
     pub height: u32,
@@ -436,11 +416,7 @@
 ///
 /// Refer to [`Anchor`] for more details.
 #[derive(Debug, Default, Clone, PartialEq, Eq, Copy, PartialOrd, Ord, core::hash::Hash)]
-#[cfg_attr(
-    feature = "serde",
-    derive(serde::Deserialize, serde::Serialize),
-    serde(crate = "serde_crate")
-)]
+#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
 pub struct ConfirmationBlockTime {
     /// The anchor block.
     pub block_id: BlockId,
diff --git a/docs/.vuepress/public/docs-rs/bdk/nightly/latest/src/bdk_chain/indexed_tx_graph.rs.html b/docs/.vuepress/public/docs-rs/bdk/nightly/latest/src/bdk_chain/indexed_tx_graph.rs.html
index 8beb87a3b4..1fc733624a 100644
--- a/docs/.vuepress/public/docs-rs/bdk/nightly/latest/src/bdk_chain/indexed_tx_graph.rs.html
+++ b/docs/.vuepress/public/docs-rs/bdk/nightly/latest/src/bdk_chain/indexed_tx_graph.rs.html
@@ -357,9 +357,6 @@
 357
 358
 359
-360
-361
-362
 
//! Contains the [`IndexedTxGraph`] and associated types. Refer to the
 //! [`IndexedTxGraph`] documentation for more.
 use core::fmt::Debug;
@@ -668,13 +665,10 @@
 #[cfg_attr(
     feature = "serde",
     derive(serde::Deserialize, serde::Serialize),
-    serde(
-        crate = "serde_crate",
-        bound(
-            deserialize = "A: Ord + serde::Deserialize<'de>, IA: serde::Deserialize<'de>",
-            serialize = "A: Ord + serde::Serialize, IA: serde::Serialize"
-        )
-    )
+    serde(bound(
+        deserialize = "A: Ord + serde::Deserialize<'de>, IA: serde::Deserialize<'de>",
+        serialize = "A: Ord + serde::Serialize, IA: serde::Serialize"
+    ))
 )]
 #[must_use]
 pub struct ChangeSet<A, IA> {
diff --git a/docs/.vuepress/public/docs-rs/bdk/nightly/latest/src/bdk_chain/indexer/keychain_txout.rs.html b/docs/.vuepress/public/docs-rs/bdk/nightly/latest/src/bdk_chain/indexer/keychain_txout.rs.html
index 162223a16e..babaf2c353 100644
--- a/docs/.vuepress/public/docs-rs/bdk/nightly/latest/src/bdk_chain/indexer/keychain_txout.rs.html
+++ b/docs/.vuepress/public/docs-rs/bdk/nightly/latest/src/bdk_chain/indexer/keychain_txout.rs.html
@@ -875,10 +875,6 @@
 875
 876
 877
-878
-879
-880
-881
 
//! [`KeychainTxOutIndex`] controls how script pubkeys are revealed for multiple keychains and
 //! indexes [`TxOut`]s with them.
 
@@ -1724,11 +1720,7 @@
 /// [`apply_changeset`]: crate::keychain_txout::KeychainTxOutIndex::apply_changeset
 /// [`merge`]: Self::merge
 #[derive(Clone, Debug, Default, PartialEq)]
-#[cfg_attr(
-    feature = "serde",
-    derive(serde::Deserialize, serde::Serialize),
-    serde(crate = "serde_crate")
-)]
+#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
 #[must_use]
 pub struct ChangeSet {
     /// Contains for each descriptor_id the last revealed index of derivation
diff --git a/docs/.vuepress/public/docs-rs/bdk/nightly/latest/src/bdk_chain/lib.rs.html b/docs/.vuepress/public/docs-rs/bdk/nightly/latest/src/bdk_chain/lib.rs.html
index e65be067db..4220ce75f0 100644
--- a/docs/.vuepress/public/docs-rs/bdk/nightly/latest/src/bdk_chain/lib.rs.html
+++ b/docs/.vuepress/public/docs-rs/bdk/nightly/latest/src/bdk_chain/lib.rs.html
@@ -191,9 +191,9 @@
 #[macro_use]
 extern crate alloc;
 #[cfg(feature = "rusqlite")]
-pub extern crate rusqlite_crate as rusqlite;
+pub extern crate rusqlite;
 #[cfg(feature = "serde")]
-pub extern crate serde_crate as serde;
+pub extern crate serde;
 
 #[cfg(feature = "std")]
 #[macro_use]
diff --git a/docs/.vuepress/public/docs-rs/bdk/nightly/latest/src/bdk_chain/local_chain.rs.html b/docs/.vuepress/public/docs-rs/bdk/nightly/latest/src/bdk_chain/local_chain.rs.html
index bbd3248e0c..7a5f581a84 100644
--- a/docs/.vuepress/public/docs-rs/bdk/nightly/latest/src/bdk_chain/local_chain.rs.html
+++ b/docs/.vuepress/public/docs-rs/bdk/nightly/latest/src/bdk_chain/local_chain.rs.html
@@ -896,10 +896,6 @@
 896
 897
 898
-899
-900
-901
-902
 
//! The [`LocalChain`] is a local implementation of [`ChainOracle`].
 
 use core::convert::Infallible;
@@ -1533,11 +1529,7 @@
 
 /// The [`ChangeSet`] represents changes to [`LocalChain`].
 #[derive(Debug, Default, Clone, PartialEq)]
-#[cfg_attr(
-    feature = "serde",
-    derive(serde::Deserialize, serde::Serialize),
-    serde(crate = "serde_crate")
-)]
+#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
 pub struct ChangeSet {
     /// Changes to the [`LocalChain`] blocks.
     ///
diff --git a/docs/.vuepress/public/docs-rs/bdk/nightly/latest/src/bdk_chain/rusqlite_impl.rs.html b/docs/.vuepress/public/docs-rs/bdk/nightly/latest/src/bdk_chain/rusqlite_impl.rs.html
index 4b89fdfbea..20f6b20668 100644
--- a/docs/.vuepress/public/docs-rs/bdk/nightly/latest/src/bdk_chain/rusqlite_impl.rs.html
+++ b/docs/.vuepress/public/docs-rs/bdk/nightly/latest/src/bdk_chain/rusqlite_impl.rs.html
@@ -687,7 +687,7 @@
     }
 }
 
-impl<A: Anchor + serde_crate::de::DeserializeOwned> FromSql for Impl<A> {
+impl<A: Anchor + serde::de::DeserializeOwned> FromSql for Impl<A> {
     fn column_result(value: ValueRef<'_>) -> FromSqlResult<Self> {
         serde_json::from_str(value.as_str()?)
             .map(Impl)
@@ -695,7 +695,7 @@
     }
 }
 
-impl<A: Anchor + serde_crate::Serialize> ToSql for Impl<A> {
+impl<A: Anchor + serde::Serialize> ToSql for Impl<A> {
     fn to_sql(&self) -> rusqlite::Result<ToSqlOutput<'_>> {
         serde_json::to_string(&self.0)
             .map(Into::into)
diff --git a/docs/.vuepress/public/docs-rs/bdk/nightly/latest/src/bdk_chain/tx_graph.rs.html b/docs/.vuepress/public/docs-rs/bdk/nightly/latest/src/bdk_chain/tx_graph.rs.html
index 4f943f6fe3..26845f10d7 100644
--- a/docs/.vuepress/public/docs-rs/bdk/nightly/latest/src/bdk_chain/tx_graph.rs.html
+++ b/docs/.vuepress/public/docs-rs/bdk/nightly/latest/src/bdk_chain/tx_graph.rs.html
@@ -1581,9 +1581,6 @@
 1581
 1582
 1583
-1584
-1585
-1586
 
//! Module for structures that store and traverse transactions.
 //!
 //! [`TxGraph`] contains transactions and indexes them so you can easily traverse the graph of
@@ -2814,13 +2811,10 @@
 #[cfg_attr(
     feature = "serde",
     derive(serde::Deserialize, serde::Serialize),
-    serde(
-        crate = "serde_crate",
-        bound(
-            deserialize = "A: Ord + serde::Deserialize<'de>",
-            serialize = "A: Ord + serde::Serialize",
-        )
-    )
+    serde(bound(
+        deserialize = "A: Ord + serde::Deserialize<'de>",
+        serialize = "A: Ord + serde::Serialize",
+    ))
 )]
 #[must_use]
 pub struct ChangeSet<A = ()> {
diff --git a/docs/.vuepress/public/docs-rs/bdk/nightly/latest/trait.impl/bdk_chain/persist/trait.PersistWith.js b/docs/.vuepress/public/docs-rs/bdk/nightly/latest/trait.impl/bdk_chain/persist/trait.PersistWith.js
index f6b21a7527..35e40869ee 100644
--- a/docs/.vuepress/public/docs-rs/bdk/nightly/latest/trait.impl/bdk_chain/persist/trait.PersistWith.js
+++ b/docs/.vuepress/public/docs-rs/bdk/nightly/latest/trait.impl/bdk_chain/persist/trait.PersistWith.js
@@ -1,3 +1,3 @@
 (function() {var implementors = {
-"bdk_wallet":[["impl PersistWith<Connection> for Wallet"],["impl PersistWith<Store<ChangeSet>> for Wallet"],["impl<'c> PersistWith<Transaction<'c>> for Wallet"]]
+"bdk_wallet":[["impl PersistWith<Store<ChangeSet>> for Wallet"],["impl PersistWith<Connection> for Wallet"],["impl<'c> PersistWith<Transaction<'c>> for Wallet"]]
 };if (window.register_implementors) {window.register_implementors(implementors);} else {window.pending_implementors = implementors;}})()
\ No newline at end of file
diff --git a/docs/.vuepress/public/docs-rs/bdk/nightly/latest/trait.impl/core/iter/traits/iterator/trait.Iterator.js b/docs/.vuepress/public/docs-rs/bdk/nightly/latest/trait.impl/core/iter/traits/iterator/trait.Iterator.js
index 773f3c0da6..cc422a2b13 100644
--- a/docs/.vuepress/public/docs-rs/bdk/nightly/latest/trait.impl/core/iter/traits/iterator/trait.Iterator.js
+++ b/docs/.vuepress/public/docs-rs/bdk/nightly/latest/trait.impl/core/iter/traits/iterator/trait.Iterator.js
@@ -1,5 +1,5 @@
 (function() {var implementors = {
 "bdk_chain":[["impl Iterator for CheckPointIter"],["impl<'g, A, F, O> Iterator for TxAncestors<'g, A, F>where\n    F: FnMut(usize, Arc<Transaction>) -> Option<O>,
"],["impl<'g, A, F, O> Iterator for TxDescendants<'g, A, F>where\n    F: FnMut(usize, Txid) -> Option<O>,
"],["impl<D> Iterator for SpkIterator<D>where\n    D: Borrow<Descriptor<DescriptorPublicKey>>,"]],
 "bdk_coin_select":[["impl<'c, 'f, S: Ord + Copy + Display> Iterator for BnbIter<'c, 'f, S>"]],
-"bdk_file_store":[["impl<'t, T> Iterator for EntryIter<'t, T>where\n    T: DeserializeOwned,"]]
+"bdk_file_store":[["impl<'t, T> Iterator for EntryIter<'t, T>where\n    T: DeserializeOwned,"]]
 };if (window.register_implementors) {window.register_implementors(implementors);} else {window.pending_implementors = implementors;}})()
\ No newline at end of file
diff --git a/docs/.vuepress/public/docs-rs/bdk/nightly/latest/trait.impl/rusqlite/types/from_sql/trait.FromSql.js b/docs/.vuepress/public/docs-rs/bdk/nightly/latest/trait.impl/rusqlite/types/from_sql/trait.FromSql.js
index 5f30edbf74..ed39ab69c5 100644
--- a/docs/.vuepress/public/docs-rs/bdk/nightly/latest/trait.impl/rusqlite/types/from_sql/trait.FromSql.js
+++ b/docs/.vuepress/public/docs-rs/bdk/nightly/latest/trait.impl/rusqlite/types/from_sql/trait.FromSql.js
@@ -1,3 +1,3 @@
 (function() {var implementors = {
-"bdk_chain":[["impl FromSql for Impl<DescriptorId>"],["impl FromSql for Impl<Amount>"],["impl FromSql for Impl<BlockHash>"],["impl FromSql for Impl<Descriptor<DescriptorPublicKey>>"],["impl FromSql for Impl<Network>"],["impl FromSql for Impl<ScriptBuf>"],["impl FromSql for Impl<Transaction>"],["impl FromSql for Impl<Txid>"],["impl<A: Anchor + DeserializeOwned> FromSql for Impl<A>"]]
+"bdk_chain":[["impl FromSql for Impl<DescriptorId>"],["impl FromSql for Impl<Amount>"],["impl FromSql for Impl<BlockHash>"],["impl FromSql for Impl<Descriptor<DescriptorPublicKey>>"],["impl FromSql for Impl<Network>"],["impl FromSql for Impl<ScriptBuf>"],["impl FromSql for Impl<Transaction>"],["impl FromSql for Impl<Txid>"],["impl<A: Anchor + DeserializeOwned> FromSql for Impl<A>"]]
 };if (window.register_implementors) {window.register_implementors(implementors);} else {window.pending_implementors = implementors;}})()
\ No newline at end of file
diff --git a/docs/.vuepress/public/docs-rs/bdk/nightly/latest/trait.impl/rusqlite/types/to_sql/trait.ToSql.js b/docs/.vuepress/public/docs-rs/bdk/nightly/latest/trait.impl/rusqlite/types/to_sql/trait.ToSql.js
index a9eb9778dd..67bf41ab53 100644
--- a/docs/.vuepress/public/docs-rs/bdk/nightly/latest/trait.impl/rusqlite/types/to_sql/trait.ToSql.js
+++ b/docs/.vuepress/public/docs-rs/bdk/nightly/latest/trait.impl/rusqlite/types/to_sql/trait.ToSql.js
@@ -1,3 +1,3 @@
 (function() {var implementors = {
-"bdk_chain":[["impl ToSql for Impl<DescriptorId>"],["impl ToSql for Impl<Amount>"],["impl ToSql for Impl<BlockHash>"],["impl ToSql for Impl<Descriptor<DescriptorPublicKey>>"],["impl ToSql for Impl<Network>"],["impl ToSql for Impl<ScriptBuf>"],["impl ToSql for Impl<Transaction>"],["impl ToSql for Impl<Txid>"],["impl<A: Anchor + Serialize> ToSql for Impl<A>"]]
+"bdk_chain":[["impl ToSql for Impl<DescriptorId>"],["impl ToSql for Impl<Amount>"],["impl ToSql for Impl<BlockHash>"],["impl ToSql for Impl<Descriptor<DescriptorPublicKey>>"],["impl ToSql for Impl<Network>"],["impl ToSql for Impl<ScriptBuf>"],["impl ToSql for Impl<Transaction>"],["impl ToSql for Impl<Txid>"],["impl<A: Anchor + Serialize> ToSql for Impl<A>"]]
 };if (window.register_implementors) {window.register_implementors(implementors);} else {window.pending_implementors = implementors;}})()
\ No newline at end of file
diff --git a/docs/.vuepress/public/docs-rs/bdk/nightly/latest/trait.impl/serde/de/trait.Deserialize.js b/docs/.vuepress/public/docs-rs/bdk/nightly/latest/trait.impl/serde/de/trait.Deserialize.js
index 580ed0bab5..bda5251158 100644
--- a/docs/.vuepress/public/docs-rs/bdk/nightly/latest/trait.impl/serde/de/trait.Deserialize.js
+++ b/docs/.vuepress/public/docs-rs/bdk/nightly/latest/trait.impl/serde/de/trait.Deserialize.js
@@ -1,5 +1,5 @@
 (function() {var implementors = {
-"bdk_chain":[["impl<'de> Deserialize<'de> for ConfirmationTime"],["impl<'de> Deserialize<'de> for ChangeSet"],["impl<'de> Deserialize<'de> for ChangeSet"],["impl<'de> Deserialize<'de> for Balance"],["impl<'de> Deserialize<'de> for BlockId"],["impl<'de> Deserialize<'de> for ConfirmationBlockTime"],["impl<'de> Deserialize<'de> for DescriptorId"],["impl<'de, A> Deserialize<'de> for ChangeSet<A>where\n    A: Ord + Deserialize<'de>,
"],["impl<'de, A, IA> Deserialize<'de> for ChangeSet<A, IA>where\n    A: Ord + Deserialize<'de>,\n    IA: Deserialize<'de>,"]],
-"bdk_wallet":[["impl<'de> Deserialize<'de> for KeychainKind"],["impl<'de> Deserialize<'de> for FullyNodedExport"],["impl<'de> Deserialize<'de> for ChangeSet"],["impl<'de> Deserialize<'de> for LocalOutput"]],
-"example_cli":[["impl<'de> Deserialize<'de> for Keychain"]]
+"bdk_chain":[["impl<'de> Deserialize<'de> for ConfirmationTime"],["impl<'de> Deserialize<'de> for ChangeSet"],["impl<'de> Deserialize<'de> for ChangeSet"],["impl<'de> Deserialize<'de> for Balance"],["impl<'de> Deserialize<'de> for BlockId"],["impl<'de> Deserialize<'de> for ConfirmationBlockTime"],["impl<'de> Deserialize<'de> for DescriptorId"],["impl<'de, A> Deserialize<'de> for ChangeSet<A>where\n    A: Ord + Deserialize<'de>,
"],["impl<'de, A, IA> Deserialize<'de> for ChangeSet<A, IA>where\n    A: Ord + Deserialize<'de>,\n    IA: Deserialize<'de>,"]],
+"bdk_wallet":[["impl<'de> Deserialize<'de> for KeychainKind"],["impl<'de> Deserialize<'de> for FullyNodedExport"],["impl<'de> Deserialize<'de> for ChangeSet"],["impl<'de> Deserialize<'de> for LocalOutput"]],
+"example_cli":[["impl<'de> Deserialize<'de> for Keychain"]]
 };if (window.register_implementors) {window.register_implementors(implementors);} else {window.pending_implementors = implementors;}})()
\ No newline at end of file
diff --git a/docs/.vuepress/public/docs-rs/bdk/nightly/latest/trait.impl/serde/ser/trait.Serialize.js b/docs/.vuepress/public/docs-rs/bdk/nightly/latest/trait.impl/serde/ser/trait.Serialize.js
index ebbda338c6..28cc8a8922 100644
--- a/docs/.vuepress/public/docs-rs/bdk/nightly/latest/trait.impl/serde/ser/trait.Serialize.js
+++ b/docs/.vuepress/public/docs-rs/bdk/nightly/latest/trait.impl/serde/ser/trait.Serialize.js
@@ -1,5 +1,5 @@
 (function() {var implementors = {
-"bdk_chain":[["impl Serialize for ConfirmationTime"],["impl Serialize for ChangeSet"],["impl Serialize for ChangeSet"],["impl Serialize for Balance"],["impl Serialize for BlockId"],["impl Serialize for ConfirmationBlockTime"],["impl Serialize for DescriptorId"],["impl<A> Serialize for ChangeSet<A>where\n    A: Ord + Serialize,
"],["impl<A, IA> Serialize for ChangeSet<A, IA>where\n    A: Ord + Serialize,\n    IA: Serialize,"]],
-"bdk_wallet":[["impl Serialize for PkOrF"],["impl Serialize for Satisfaction"],["impl Serialize for SatisfiableItem"],["impl Serialize for KeychainKind"],["impl Serialize for Condition"],["impl Serialize for Policy"],["impl Serialize for FullyNodedExport"],["impl Serialize for ChangeSet"],["impl Serialize for LocalOutput"]],
-"example_cli":[["impl Serialize for Keychain"]]
+"bdk_chain":[["impl Serialize for ConfirmationTime"],["impl Serialize for ChangeSet"],["impl Serialize for ChangeSet"],["impl Serialize for Balance"],["impl Serialize for BlockId"],["impl Serialize for ConfirmationBlockTime"],["impl Serialize for DescriptorId"],["impl<A> Serialize for ChangeSet<A>where\n    A: Ord + Serialize,
"],["impl<A, IA> Serialize for ChangeSet<A, IA>where\n    A: Ord + Serialize,\n    IA: Serialize,"]],
+"bdk_wallet":[["impl Serialize for PkOrF"],["impl Serialize for Satisfaction"],["impl Serialize for SatisfiableItem"],["impl Serialize for KeychainKind"],["impl Serialize for Condition"],["impl Serialize for Policy"],["impl Serialize for FullyNodedExport"],["impl Serialize for ChangeSet"],["impl Serialize for LocalOutput"]],
+"example_cli":[["impl Serialize for Keychain"]]
 };if (window.register_implementors) {window.register_implementors(implementors);} else {window.pending_implementors = implementors;}})()
\ No newline at end of file
diff --git a/docs/.vuepress/public/docs-rs/bdk/nightly/latest/type.impl/alloc/boxed/struct.Box.js b/docs/.vuepress/public/docs-rs/bdk/nightly/latest/type.impl/alloc/boxed/struct.Box.js
index e88917d29d..49bc476fc1 100644
--- a/docs/.vuepress/public/docs-rs/bdk/nightly/latest/type.impl/alloc/boxed/struct.Box.js
+++ b/docs/.vuepress/public/docs-rs/bdk/nightly/latest/type.impl/alloc/boxed/struct.Box.js
@@ -1,3 +1,3 @@
 (function() {var type_impls = {
-"bdk_esplora":[["1.64.0 Â· sourceÂ§impl<T> AsFd for Box<T>where\n    T: AsFd + ?Sized,
sourceÂ§fn as_fd(&self) -> BorrowedFd<'_>
Borrows the file descriptor. Read more
","AsFd","bdk_esplora::blocking_ext::Error"],["1.5.0 Â· sourceÂ§impl<T, A> AsMut<T> for Box<T, A>where\n    A: Allocator,\n    T: ?Sized,
sourceÂ§fn as_mut(&mut self) -> &mut T
Converts this type into a mutable reference of the (usually inferred) input type.
","AsMut","bdk_esplora::blocking_ext::Error"],["1.63.0 Â· sourceÂ§impl<T> AsRawFd for Box<T>where\n    T: AsRawFd,
sourceÂ§fn as_raw_fd(&self) -> i32
Extracts the raw file descriptor. Read more
","AsRawFd","bdk_esplora::blocking_ext::Error"],["1.5.0 Â· sourceÂ§impl<T, A> AsRef<T> for Box<T, A>where\n    A: Allocator,\n    T: ?Sized,
sourceÂ§fn as_ref(&self) -> &T
Converts this type into a shared reference of the (usually inferred) input type.
","AsRef","bdk_esplora::blocking_ext::Error"],["Â§impl<T> AsyncBufRead for Box<T>where\n    T: AsyncBufRead + Unpin + ?Sized,
Â§fn poll_fill_buf(\n    self: Pin<&mut Box<T>>,\n    cx: &mut Context<'_>\n) -> Poll<Result<&[u8], Error>>
Attempt to return the contents of the internal buffer, filling it with more data\nfrom the inner reader if it is empty. Read more
Â§fn consume(self: Pin<&mut Box<T>>, amt: usize)
Tells this buffer that amt bytes have been consumed from the buffer,\nso they should no longer be returned in calls to poll_read. Read more
","AsyncBufRead","bdk_esplora::blocking_ext::Error"],["Â§impl<T> AsyncBufRead for Box<T>where\n    T: AsyncBufRead + Unpin + ?Sized,
Â§fn poll_fill_buf(\n    self: Pin<&mut Box<T>>,\n    cx: &mut Context<'_>\n) -> Poll<Result<&[u8], Error>>
Attempts to return the contents of the internal buffer, filling it with more data\nfrom the inner reader if it is empty. Read more
Â§fn consume(self: Pin<&mut Box<T>>, amt: usize)
Tells this buffer that amt bytes have been consumed from the buffer,\nso they should no longer be returned in calls to poll_read. Read more
","AsyncBufRead","bdk_esplora::blocking_ext::Error"],["sourceÂ§impl<Args, F, A> AsyncFn<Args> for Box<F, A>where\n    Args: Tuple,\n    F: AsyncFn<Args> + ?Sized,\n    A: Allocator,
sourceÂ§extern "rust-call" fn async_call(\n    &self,\n    args: Args\n) -> <Box<F, A> as AsyncFnMut<Args>>::CallRefFuture<'_>
ð¬This is a nightly-only experimental API. (async_fn_traits)Call the AsyncFn, returning a future which may borrow from the called closure.
","AsyncFn","bdk_esplora::blocking_ext::Error"],["sourceÂ§impl<Args, F, A> AsyncFnMut<Args> for Box<F, A>where\n    Args: Tuple,\n    F: AsyncFnMut<Args> + ?Sized,\n    A: Allocator,
Â§type CallRefFuture<'a> = <F as AsyncFnMut<Args>>::CallRefFuture<'a>\nwhere\n    Box<F, A>: 'a
ð¬This is a nightly-only experimental API. (async_fn_traits)Future returned by AsyncFnMut::async_call_mut and AsyncFn::async_call.
sourceÂ§extern "rust-call" fn async_call_mut(\n    &mut self,\n    args: Args\n) -> <Box<F, A> as AsyncFnMut<Args>>::CallRefFuture<'_>
ð¬This is a nightly-only experimental API. (async_fn_traits)Call the AsyncFnMut, returning a future which may borrow from the called closure.
","AsyncFnMut","bdk_esplora::blocking_ext::Error"],["sourceÂ§impl<Args, F, A> AsyncFnOnce<Args> for Box<F, A>where\n    Args: Tuple,\n    F: AsyncFnOnce<Args> + ?Sized,\n    A: Allocator,
Â§type Output = <F as AsyncFnOnce<Args>>::Output
ð¬This is a nightly-only experimental API. (async_fn_traits)Output type of the called closureâs future.
Â§type CallOnceFuture = <F as AsyncFnOnce<Args>>::CallOnceFuture
ð¬This is a nightly-only experimental API. (async_fn_traits)Future returned by AsyncFnOnce::async_call_once.
sourceÂ§extern "rust-call" fn async_call_once(\n    self,\n    args: Args\n) -> <Box<F, A> as AsyncFnOnce<Args>>::CallOnceFuture
ð¬This is a nightly-only experimental API. (async_fn_traits)Call the AsyncFnOnce, returning a future which may move out of the called closure.
","AsyncFnOnce","bdk_esplora::blocking_ext::Error"],["sourceÂ§impl<S> AsyncIterator for Box<S>where\n    S: AsyncIterator + Unpin + ?Sized,
Â§type Item = <S as AsyncIterator>::Item
ð¬This is a nightly-only experimental API. (async_iterator)The type of items yielded by the async iterator.
sourceÂ§fn poll_next(\n    self: Pin<&mut Box<S>>,\n    cx: &mut Context<'_>\n) -> Poll<Option<<Box<S> as AsyncIterator>::Item>>
ð¬This is a nightly-only experimental API. (async_iterator)Attempt to pull out the next value of this async iterator, registering the\ncurrent task for wakeup if the value is not yet available, and returning\nNone if the async iterator is exhausted. Read more
sourceÂ§fn size_hint(&self) -> (usize, Option<usize>)
ð¬This is a nightly-only experimental API. (async_iterator)Returns the bounds on the remaining length of the async iterator. Read more
","AsyncIterator","bdk_esplora::blocking_ext::Error"],["Â§impl<T> AsyncRead for Box<T>where\n    T: AsyncRead + Unpin + ?Sized,
Â§fn poll_read(\n    self: Pin<&mut Box<T>>,\n    cx: &mut Context<'_>,\n    buf: &mut ReadBuf<'_>\n) -> Poll<Result<(), Error>>
Attempts to read from the AsyncRead into buf. Read more
","AsyncRead","bdk_esplora::blocking_ext::Error"],["Â§impl<T> AsyncRead for Box<T>where\n    T: AsyncRead + Unpin + ?Sized,
Â§fn poll_read(\n    self: Pin<&mut Box<T>>,\n    cx: &mut Context<'_>,\n    buf: &mut [u8]\n) -> Poll<Result<usize, Error>>
Attempt to read from the AsyncRead into buf. Read more
Â§fn poll_read_vectored(\n    self: Pin<&mut Box<T>>,\n    cx: &mut Context<'_>,\n    bufs: &mut [IoSliceMut<'_>]\n) -> Poll<Result<usize, Error>>
Attempt to read from the AsyncRead into bufs using vectored\nIO operations. Read more
","AsyncRead","bdk_esplora::blocking_ext::Error"],["Â§impl<T> AsyncSeek for Box<T>where\n    T: AsyncSeek + Unpin + ?Sized,
Â§fn poll_seek(\n    self: Pin<&mut Box<T>>,\n    cx: &mut Context<'_>,\n    pos: SeekFrom\n) -> Poll<Result<u64, Error>>
Attempt to seek to an offset, in bytes, in a stream. Read more
","AsyncSeek","bdk_esplora::blocking_ext::Error"],["Â§impl<T> AsyncSeek for Box<T>where\n    T: AsyncSeek + Unpin + ?Sized,
Â§fn start_seek(self: Pin<&mut Box<T>>, pos: SeekFrom) -> Result<(), Error>
Attempts to seek to an offset, in bytes, in a stream. Read more
Â§fn poll_complete(\n    self: Pin<&mut Box<T>>,\n    cx: &mut Context<'_>\n) -> Poll<Result<u64, Error>>
Waits for a seek operation to complete. Read more
","AsyncSeek","bdk_esplora::blocking_ext::Error"],["Â§impl<T> AsyncWrite for Box<T>where\n    T: AsyncWrite + Unpin + ?Sized,
Â§fn poll_write(\n    self: Pin<&mut Box<T>>,\n    cx: &mut Context<'_>,\n    buf: &[u8]\n) -> Poll<Result<usize, Error>>
Attempt to write bytes from buf into the object. Read more
Â§fn poll_write_vectored(\n    self: Pin<&mut Box<T>>,\n    cx: &mut Context<'_>,\n    bufs: &[IoSlice<'_>]\n) -> Poll<Result<usize, Error>>
Attempt to write bytes from bufs into the object using vectored\nIO operations. Read more
Â§fn poll_flush(\n    self: Pin<&mut Box<T>>,\n    cx: &mut Context<'_>\n) -> Poll<Result<(), Error>>
Attempt to flush the object, ensuring that any buffered data reach\ntheir destination. Read more
Â§fn poll_close(\n    self: Pin<&mut Box<T>>,\n    cx: &mut Context<'_>\n) -> Poll<Result<(), Error>>
Attempt to close the object. Read more
","AsyncWrite","bdk_esplora::blocking_ext::Error"],["Â§impl<T> AsyncWrite for Box<T>where\n    T: AsyncWrite + Unpin + ?Sized,
Â§fn poll_write(\n    self: Pin<&mut Box<T>>,\n    cx: &mut Context<'_>,\n    buf: &[u8]\n) -> Poll<Result<usize, Error>>
Attempt to write bytes from buf into the object. Read more
Â§fn poll_write_vectored(\n    self: Pin<&mut Box<T>>,\n    cx: &mut Context<'_>,\n    bufs: &[IoSlice<'_>]\n) -> Poll<Result<usize, Error>>
Like poll_write, except that it writes from a slice of buffers. Read more
Â§fn is_write_vectored(&self) -> bool
Determines if this writer has an efficient poll_write_vectored\nimplementation. Read more
Â§fn poll_flush(\n    self: Pin<&mut Box<T>>,\n    cx: &mut Context<'_>\n) -> Poll<Result<(), Error>>
Attempts to flush the object, ensuring that any buffered data reach\ntheir destination. Read more
Â§fn poll_shutdown(\n    self: Pin<&mut Box<T>>,\n    cx: &mut Context<'_>\n) -> Poll<Result<(), Error>>
Initiates or attempts to shut down this writer, returning success when\nthe I/O connection has completely shut down. Read more
","AsyncWrite","bdk_esplora::blocking_ext::Error"],["sourceÂ§impl<T> Body for Box<T>where\n    T: Body + Unpin + ?Sized,
Â§type Data = <T as Body>::Data
Values yielded by the Body.
Â§type Error = <T as Body>::Error
The error type this Body might generate.
sourceÂ§fn poll_data(\n    self: Pin<&mut Box<T>>,\n    cx: &mut Context<'_>\n) -> Poll<Option<Result<<Box<T> as Body>::Data, <Box<T> as Body>::Error>>>
Attempt to pull out the next data buffer of this stream.
sourceÂ§fn poll_trailers(\n    self: Pin<&mut Box<T>>,\n    cx: &mut Context<'_>\n) -> Poll<Result<Option<HeaderMap>, <Box<T> as Body>::Error>>
Poll for an optional single HeaderMap of trailers. Read more
sourceÂ§fn is_end_stream(&self) -> bool
Returns true when the end of stream has been reached. Read more
sourceÂ§fn size_hint(&self) -> SizeHint
Returns the bounds on the remaining length of the stream. Read more
sourceÂ§fn data(&mut self) -> Data<'_, Self>where\n    Self: Sized + Unpin,
Returns future that resolves to next data chunk, if any.
sourceÂ§fn trailers(&mut self) -> Trailers<'_, Self>where\n    Self: Sized + Unpin,
Returns future that resolves to trailers, if any.
sourceÂ§fn map_data<F, B>(self, f: F) -> MapData<Self, F>where\n    Self: Sized,\n    F: FnMut(Self::Data) -> B,\n    B: Buf,
Maps this bodyâs data value to a different value.
sourceÂ§fn map_err<F, E>(self, f: F) -> MapErr<Self, F>where\n    Self: Sized,\n    F: FnMut(Self::Error) -> E,
Maps this bodyâs error value to a different value.
sourceÂ§fn collect(self) -> Collect<Self>where\n    Self: Sized,
Turn this body into Collected body which will collect all the DATA frames\nand trailers.
","Body","bdk_esplora::blocking_ext::Error"],["1.1.0 Â· sourceÂ§impl<T, A> Borrow<T> for Box<T, A>where\n    A: Allocator,\n    T: ?Sized,
sourceÂ§fn borrow(&self) -> &T
Immutably borrows from an owned value. Read more
","Borrow","bdk_esplora::blocking_ext::Error"],["1.1.0 Â· sourceÂ§impl<T, A> BorrowMut<T> for Box<T, A>where\n    A: Allocator,\n    T: ?Sized,
sourceÂ§fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value. Read more
","BorrowMut","bdk_esplora::blocking_ext::Error"],["sourceÂ§impl<T> Box<T>
1.0.0 Â· sourcepub fn new(x: T) -> Box<T>
Allocates memory on the heap and then places x into it.
\nThis doesnât actually allocate if T is zero-sized.
\nÂ§Examples
\nlet five = Box::new(5);
\n
sourcepub fn new_uninit() -> Box<MaybeUninit<T>>
ð¬This is a nightly-only experimental API. (new_uninit)
Constructs a new box with uninitialized contents.
\nÂ§Examples
\n#![feature(new_uninit)]\n\nlet mut five = Box::<u32>::new_uninit();\n\nlet five = unsafe {\n    // Deferred initialization:\n    five.as_mut_ptr().write(5);\n\n    five.assume_init()\n};\n\nassert_eq!(*five, 5)
\n
sourcepub fn new_zeroed() -> Box<MaybeUninit<T>>
ð¬This is a nightly-only experimental API. (new_uninit)
Constructs a new Box with uninitialized contents, with the memory\nbeing filled with 0 bytes.
\nSee MaybeUninit::zeroed for examples of correct and incorrect usage\nof this method.
\nÂ§Examples
\n#![feature(new_uninit)]\n\nlet zero = Box::<u32>::new_zeroed();\nlet zero = unsafe { zero.assume_init() };\n\nassert_eq!(*zero, 0)
\n
1.33.0 Â· sourcepub fn pin(x: T) -> Pin<Box<T>>
Constructs a new Pin<Box<T>>. If T does not implement Unpin, then\nx will be pinned in memory and unable to be moved.
\nConstructing and pinning of the Box can also be done in two steps: Box::pin(x)\ndoes the same as Box::into_pin(Box::new(x)). Consider using\ninto_pin if you already have a Box<T>, or if you want to\nconstruct a (pinned) Box in a different way than with Box::new.
\n
sourcepub fn try_new(x: T) -> Result<Box<T>, AllocError>
ð¬This is a nightly-only experimental API. (allocator_api)
Allocates memory on the heap then places x into it,\nreturning an error if the allocation fails
\nThis doesnât actually allocate if T is zero-sized.
\nÂ§Examples
\n#![feature(allocator_api)]\n\nlet five = Box::try_new(5)?;
\n
sourcepub fn try_new_uninit() -> Result<Box<MaybeUninit<T>>, AllocError>
ð¬This is a nightly-only experimental API. (allocator_api)
Constructs a new box with uninitialized contents on the heap,\nreturning an error if the allocation fails
\nÂ§Examples
\n#![feature(allocator_api, new_uninit)]\n\nlet mut five = Box::<u32>::try_new_uninit()?;\n\nlet five = unsafe {\n    // Deferred initialization:\n    five.as_mut_ptr().write(5);\n\n    five.assume_init()\n};\n\nassert_eq!(*five, 5);
\n
sourcepub fn try_new_zeroed() -> Result<Box<MaybeUninit<T>>, AllocError>
ð¬This is a nightly-only experimental API. (allocator_api)
Constructs a new Box with uninitialized contents, with the memory\nbeing filled with 0 bytes on the heap
\nSee MaybeUninit::zeroed for examples of correct and incorrect usage\nof this method.
\nÂ§Examples
\n#![feature(allocator_api, new_uninit)]\n\nlet zero = Box::<u32>::try_new_zeroed()?;\nlet zero = unsafe { zero.assume_init() };\n\nassert_eq!(*zero, 0);
\n
",0,"bdk_esplora::blocking_ext::Error"],["sourceÂ§impl<T> Box<T>where\n    T: ?Sized,
1.4.0 Â· sourcepub unsafe fn from_raw(raw: *mut T) -> Box<T>
Constructs a box from a raw pointer.
\nAfter calling this function, the raw pointer is owned by the\nresulting Box. Specifically, the Box destructor will call\nthe destructor of T and free the allocated memory. For this\nto be safe, the memory must have been allocated in accordance\nwith the memory layout used by Box .
\nÂ§Safety
\nThis function is unsafe because improper use may lead to\nmemory problems. For example, a double-free may occur if the\nfunction is called twice on the same raw pointer.
\nThe safety conditions are described in the memory layout section.
\nÂ§Examples
\nRecreate a Box which was previously converted to a raw pointer\nusing Box::into_raw:
\n\nlet x = Box::new(5);\nlet ptr = Box::into_raw(x);\nlet x = unsafe { Box::from_raw(ptr) };
\nManually create a Box from scratch by using the global allocator:
\n\nuse std::alloc::{alloc, Layout};\n\nunsafe {\n    let ptr = alloc(Layout::new::<i32>()) as *mut i32;\n    // In general .write is required to avoid attempting to destruct\n    // the (uninitialized) previous contents of `ptr`, though for this\n    // simple example `*ptr = 5` would have worked as well.\n    ptr.write(5);\n    let x = Box::from_raw(ptr);\n}
\n
",0,"bdk_esplora::blocking_ext::Error"],["sourceÂ§impl<T, A> Box<T, A>where\n    A: Allocator,
sourcepub fn new_in(x: T, alloc: A) -> Box<T, A>where\n    A: Allocator,
ð¬This is a nightly-only experimental API. (allocator_api)
Allocates memory in the given allocator then places x into it.
\nThis doesnât actually allocate if T is zero-sized.
\nÂ§Examples
\n#![feature(allocator_api)]\n\nuse std::alloc::System;\n\nlet five = Box::new_in(5, System);
\n
sourcepub fn try_new_in(x: T, alloc: A) -> Result<Box<T, A>, AllocError>where\n    A: Allocator,
ð¬This is a nightly-only experimental API. (allocator_api)
Allocates memory in the given allocator then places x into it,\nreturning an error if the allocation fails
\nThis doesnât actually allocate if T is zero-sized.
\nÂ§Examples
\n#![feature(allocator_api)]\n\nuse std::alloc::System;\n\nlet five = Box::try_new_in(5, System)?;
\n
sourcepub fn new_uninit_in(alloc: A) -> Box<MaybeUninit<T>, A>where\n    A: Allocator,
ð¬This is a nightly-only experimental API. (allocator_api)
Constructs a new box with uninitialized contents in the provided allocator.
\nÂ§Examples
\n#![feature(allocator_api, new_uninit)]\n\nuse std::alloc::System;\n\nlet mut five = Box::<u32, _>::new_uninit_in(System);\n\nlet five = unsafe {\n    // Deferred initialization:\n    five.as_mut_ptr().write(5);\n\n    five.assume_init()\n};\n\nassert_eq!(*five, 5)
\n
sourcepub fn try_new_uninit_in(alloc: A) -> Result<Box<MaybeUninit<T>, A>, AllocError>where\n    A: Allocator,
ð¬This is a nightly-only experimental API. (allocator_api)
Constructs a new box with uninitialized contents in the provided allocator,\nreturning an error if the allocation fails
\nÂ§Examples
\n#![feature(allocator_api, new_uninit)]\n\nuse std::alloc::System;\n\nlet mut five = Box::<u32, _>::try_new_uninit_in(System)?;\n\nlet five = unsafe {\n    // Deferred initialization:\n    five.as_mut_ptr().write(5);\n\n    five.assume_init()\n};\n\nassert_eq!(*five, 5);
\n
sourcepub fn new_zeroed_in(alloc: A) -> Box<MaybeUninit<T>, A>where\n    A: Allocator,
ð¬This is a nightly-only experimental API. (allocator_api)
Constructs a new Box with uninitialized contents, with the memory\nbeing filled with 0 bytes in the provided allocator.
\nSee MaybeUninit::zeroed for examples of correct and incorrect usage\nof this method.
\nÂ§Examples
\n#![feature(allocator_api, new_uninit)]\n\nuse std::alloc::System;\n\nlet zero = Box::<u32, _>::new_zeroed_in(System);\nlet zero = unsafe { zero.assume_init() };\n\nassert_eq!(*zero, 0)
\n
sourcepub fn try_new_zeroed_in(alloc: A) -> Result<Box<MaybeUninit<T>, A>, AllocError>where\n    A: Allocator,
ð¬This is a nightly-only experimental API. (allocator_api)
Constructs a new Box with uninitialized contents, with the memory\nbeing filled with 0 bytes in the provided allocator,\nreturning an error if the allocation fails,
\nSee MaybeUninit::zeroed for examples of correct and incorrect usage\nof this method.
\nÂ§Examples
\n#![feature(allocator_api, new_uninit)]\n\nuse std::alloc::System;\n\nlet zero = Box::<u32, _>::try_new_zeroed_in(System)?;\nlet zero = unsafe { zero.assume_init() };\n\nassert_eq!(*zero, 0);
\n
sourcepub fn pin_in(x: T, alloc: A) -> Pin<Box<T, A>>where\n    A: 'static + Allocator,
ð¬This is a nightly-only experimental API. (allocator_api)
Constructs a new Pin<Box<T, A>>. If T does not implement Unpin, then\nx will be pinned in memory and unable to be moved.
\nConstructing and pinning of the Box can also be done in two steps: Box::pin_in(x, alloc)\ndoes the same as Box::into_pin(Box::new_in(x, alloc)). Consider using\ninto_pin if you already have a Box<T, A>, or if you want to\nconstruct a (pinned) Box in a different way than with Box::new_in.
\n
sourcepub fn into_boxed_slice(boxed: Box<T, A>) -> Box<[T], A>
ð¬This is a nightly-only experimental API. (box_into_boxed_slice)
Converts a Box<T> into a Box<[T]>
\nThis conversion does not allocate on the heap and happens in place.
\n
sourcepub fn into_inner(boxed: Box<T, A>) -> T
ð¬This is a nightly-only experimental API. (box_into_inner)
Consumes the Box, returning the wrapped value.
\nÂ§Examples
\n#![feature(box_into_inner)]\n\nlet c = Box::new(5);\n\nassert_eq!(Box::into_inner(c), 5);
\n
",0,"bdk_esplora::blocking_ext::Error"],["sourceÂ§impl<T, A> Box<T, A>where\n    A: Allocator,\n    T: ?Sized,
const: unstable Â· sourcepub unsafe fn from_raw_in(raw: *mut T, alloc: A) -> Box<T, A>
ð¬This is a nightly-only experimental API. (allocator_api)
Constructs a box from a raw pointer in the given allocator.
\nAfter calling this function, the raw pointer is owned by the\nresulting Box. Specifically, the Box destructor will call\nthe destructor of T and free the allocated memory. For this\nto be safe, the memory must have been allocated in accordance\nwith the memory layout used by Box .
\nÂ§Safety
\nThis function is unsafe because improper use may lead to\nmemory problems. For example, a double-free may occur if the\nfunction is called twice on the same raw pointer.
\nÂ§Examples
\nRecreate a Box which was previously converted to a raw pointer\nusing Box::into_raw_with_allocator:
\n\n#![feature(allocator_api)]\n\nuse std::alloc::System;\n\nlet x = Box::new_in(5, System);\nlet (ptr, alloc) = Box::into_raw_with_allocator(x);\nlet x = unsafe { Box::from_raw_in(ptr, alloc) };
\nManually create a Box from scratch by using the system allocator:
\n\n#![feature(allocator_api, slice_ptr_get)]\n\nuse std::alloc::{Allocator, Layout, System};\n\nunsafe {\n    let ptr = System.allocate(Layout::new::<i32>())?.as_mut_ptr() as *mut i32;\n    // In general .write is required to avoid attempting to destruct\n    // the (uninitialized) previous contents of `ptr`, though for this\n    // simple example `*ptr = 5` would have worked as well.\n    ptr.write(5);\n    let x = Box::from_raw_in(ptr, System);\n}
\n
1.4.0 Â· sourcepub fn into_raw(b: Box<T, A>) -> *mut T
Consumes the Box, returning a wrapped raw pointer.
\nThe pointer will be properly aligned and non-null.
\nAfter calling this function, the caller is responsible for the\nmemory previously managed by the Box. In particular, the\ncaller should properly destroy T and release the memory, taking\ninto account the memory layout used by Box. The easiest way to\ndo this is to convert the raw pointer back into a Box with the\nBox::from_raw function, allowing the Box destructor to perform\nthe cleanup.
\nNote: this is an associated function, which means that you have\nto call it as Box::into_raw(b) instead of b.into_raw(). This\nis so that there is no conflict with a method on the inner type.
\nÂ§Examples
\nConverting the raw pointer back into a Box with Box::from_raw\nfor automatic cleanup:
\n\nlet x = Box::new(String::from(\"Hello\"));\nlet ptr = Box::into_raw(x);\nlet x = unsafe { Box::from_raw(ptr) };
\nManual cleanup by explicitly running the destructor and deallocating\nthe memory:
\n\nuse std::alloc::{dealloc, Layout};\nuse std::ptr;\n\nlet x = Box::new(String::from(\"Hello\"));\nlet ptr = Box::into_raw(x);\nunsafe {\n    ptr::drop_in_place(ptr);\n    dealloc(ptr as *mut u8, Layout::new::<String>());\n}
\nNote: This is equivalent to the following:
\n\nlet x = Box::new(String::from(\"Hello\"));\nlet ptr = Box::into_raw(x);\nunsafe {\n    drop(Box::from_raw(ptr));\n}
\n
sourcepub fn into_raw_with_allocator(b: Box<T, A>) -> (*mut T, A)
ð¬This is a nightly-only experimental API. (allocator_api)
Consumes the Box, returning a wrapped raw pointer and the allocator.
\nThe pointer will be properly aligned and non-null.
\nAfter calling this function, the caller is responsible for the\nmemory previously managed by the Box. In particular, the\ncaller should properly destroy T and release the memory, taking\ninto account the memory layout used by Box. The easiest way to\ndo this is to convert the raw pointer back into a Box with the\nBox::from_raw_in function, allowing the Box destructor to perform\nthe cleanup.
\nNote: this is an associated function, which means that you have\nto call it as Box::into_raw_with_allocator(b) instead of b.into_raw_with_allocator(). This\nis so that there is no conflict with a method on the inner type.
\nÂ§Examples
\nConverting the raw pointer back into a Box with Box::from_raw_in\nfor automatic cleanup:
\n\n#![feature(allocator_api)]\n\nuse std::alloc::System;\n\nlet x = Box::new_in(String::from(\"Hello\"), System);\nlet (ptr, alloc) = Box::into_raw_with_allocator(x);\nlet x = unsafe { Box::from_raw_in(ptr, alloc) };
\nManual cleanup by explicitly running the destructor and deallocating\nthe memory:
\n\n#![feature(allocator_api)]\n\nuse std::alloc::{Allocator, Layout, System};\nuse std::ptr::{self, NonNull};\n\nlet x = Box::new_in(String::from(\"Hello\"), System);\nlet (ptr, alloc) = Box::into_raw_with_allocator(x);\nunsafe {\n    ptr::drop_in_place(ptr);\n    let non_null = NonNull::new_unchecked(ptr);\n    alloc.deallocate(non_null.cast(), Layout::new::<String>());\n}
\n
const: unstable Â· sourcepub fn allocator(b: &Box<T, A>) -> &A
ð¬This is a nightly-only experimental API. (allocator_api)
Returns a reference to the underlying allocator.
\nNote: this is an associated function, which means that you have\nto call it as Box::allocator(&b) instead of b.allocator(). This\nis so that there is no conflict with a method on the inner type.
\n
1.26.0 Â· sourcepub fn leak<'a>(b: Box<T, A>) -> &'a mut Twhere\n    A: 'a,
Consumes and leaks the Box, returning a mutable reference,\n&'a mut T. Note that the type T must outlive the chosen lifetime\n'a. If the type has only static references, or none at all, then this\nmay be chosen to be 'static.
\nThis function is mainly useful for data that lives for the remainder of\nthe programâs life. Dropping the returned reference will cause a memory\nleak. If this is not acceptable, the reference should first be wrapped\nwith the Box::from_raw function producing a Box. This Box can\nthen be dropped which will properly destroy T and release the\nallocated memory.
\nNote: this is an associated function, which means that you have\nto call it as Box::leak(b) instead of b.leak(). This\nis so that there is no conflict with a method on the inner type.
\nÂ§Examples
\nSimple usage:
\n\nlet x = Box::new(41);\nlet static_ref: &'static mut usize = Box::leak(x);\n*static_ref += 1;\nassert_eq!(*static_ref, 42);
\nUnsized data:
\n\nlet x = vec![1, 2, 3].into_boxed_slice();\nlet static_ref = Box::leak(x);\nstatic_ref[0] = 4;\nassert_eq!(*static_ref, [4, 2, 3]);
\n
1.63.0 (const: unstable) Â· sourcepub fn into_pin(boxed: Box<T, A>) -> Pin<Box<T, A>>where\n    A: 'static,
Converts a Box<T> into a Pin<Box<T>>. If T does not implement Unpin, then\n*boxed will be pinned in memory and unable to be moved.
\nThis conversion does not allocate on the heap and happens in place.
\nThis is also available via From.
\nConstructing and pinning a Box with Box::into_pin(Box::new(x))\ncan also be written more concisely using Box::pin(x).\nThis into_pin method is useful if you already have a Box<T>, or you are\nconstructing a (pinned) Box in a different way than with Box::new.
\nÂ§Notes
\nItâs not recommended that crates add an impl like From<Box<T>> for Pin<T>,\nas itâll introduce an ambiguity when calling Pin::from.\nA demonstration of such a poor impl is shown below.
\n\nâstruct Foo; // A type defined in this crate.\nimpl From<Box<()>> for Pin<Foo> {\n    fn from(_: Box<()>) -> Pin<Foo> {\n        Pin::new(Foo)\n    }\n}\n\nlet foo = Box::new(());\nlet bar = Pin::from(foo);
\n
",0,"bdk_esplora::blocking_ext::Error"],["Â§impl<T> Buf for Box<T>where\n    T: Buf + ?Sized,
Â§fn remaining(&self) -> usize
Returns the number of bytes between the current position and the end of\nthe buffer. Read more
Â§fn chunk(&self) -> &[u8] â
Returns a slice starting at the current position and of length between 0\nand Buf::remaining(). Note that this can return shorter slice (this allows\nnon-continuous internal representation). Read more
Â§fn chunks_vectored<'b>(&'b self, dst: &mut [IoSlice<'b>]) -> usize
Fills dst with potentially multiple slices starting at selfâs\ncurrent position. Read more
Â§fn advance(&mut self, cnt: usize)
Advance the internal cursor of the Buf Read more
Â§fn has_remaining(&self) -> bool
Returns true if there are any more bytes to consume Read more
Â§fn copy_to_slice(&mut self, dst: &mut [u8])
Copies bytes from self into dst. Read more
Â§fn get_u8(&mut self) -> u8
Gets an unsigned 8 bit integer from self. Read more
Â§fn get_i8(&mut self) -> i8
Gets a signed 8 bit integer from self. Read more
Â§fn get_u16(&mut self) -> u16
Gets an unsigned 16 bit integer from self in big-endian byte order. Read more
Â§fn get_u16_le(&mut self) -> u16
Gets an unsigned 16 bit integer from self in little-endian byte order. Read more
Â§fn get_u16_ne(&mut self) -> u16
Gets an unsigned 16 bit integer from self in native-endian byte order. Read more
Â§fn get_i16(&mut self) -> i16
Gets a signed 16 bit integer from self in big-endian byte order. Read more
Â§fn get_i16_le(&mut self) -> i16
Gets a signed 16 bit integer from self in little-endian byte order. Read more
Â§fn get_i16_ne(&mut self) -> i16
Gets a signed 16 bit integer from self in native-endian byte order. Read more
Â§fn get_u32(&mut self) -> u32
Gets an unsigned 32 bit integer from self in the big-endian byte order. Read more
Â§fn get_u32_le(&mut self) -> u32
Gets an unsigned 32 bit integer from self in the little-endian byte order. Read more
Â§fn get_u32_ne(&mut self) -> u32
Gets an unsigned 32 bit integer from self in native-endian byte order. Read more
Â§fn get_i32(&mut self) -> i32
Gets a signed 32 bit integer from self in big-endian byte order. Read more
Â§fn get_i32_le(&mut self) -> i32
Gets a signed 32 bit integer from self in little-endian byte order. Read more
Â§fn get_i32_ne(&mut self) -> i32
Gets a signed 32 bit integer from self in native-endian byte order. Read more
Â§fn get_u64(&mut self) -> u64
Gets an unsigned 64 bit integer from self in big-endian byte order. Read more
Â§fn get_u64_le(&mut self) -> u64
Gets an unsigned 64 bit integer from self in little-endian byte order. Read more
Â§fn get_u64_ne(&mut self) -> u64
Gets an unsigned 64 bit integer from self in native-endian byte order. Read more
Â§fn get_i64(&mut self) -> i64
Gets a signed 64 bit integer from self in big-endian byte order. Read more
Â§fn get_i64_le(&mut self) -> i64
Gets a signed 64 bit integer from self in little-endian byte order. Read more
Â§fn get_i64_ne(&mut self) -> i64
Gets a signed 64 bit integer from self in native-endian byte order. Read more
Â§fn get_uint(&mut self, nbytes: usize) -> u64
Gets an unsigned n-byte integer from self in big-endian byte order. Read more
Â§fn get_uint_le(&mut self, nbytes: usize) -> u64
Gets an unsigned n-byte integer from self in little-endian byte order. Read more
Â§fn get_uint_ne(&mut self, nbytes: usize) -> u64
Gets an unsigned n-byte integer from self in native-endian byte order. Read more
Â§fn get_int(&mut self, nbytes: usize) -> i64
Gets a signed n-byte integer from self in big-endian byte order. Read more
Â§fn get_int_le(&mut self, nbytes: usize) -> i64
Gets a signed n-byte integer from self in little-endian byte order. Read more
Â§fn get_int_ne(&mut self, nbytes: usize) -> i64
Gets a signed n-byte integer from self in native-endian byte order. Read more
Â§fn copy_to_bytes(&mut self, len: usize) -> Bytes
Consumes len bytes inside self and returns new instance of Bytes\nwith this data. Read more
Â§fn get_u128(&mut self) -> u128
Gets an unsigned 128 bit integer from self in big-endian byte order. Read more
Â§fn get_u128_le(&mut self) -> u128
Gets an unsigned 128 bit integer from self in little-endian byte order. Read more
Â§fn get_u128_ne(&mut self) -> u128
Gets an unsigned 128 bit integer from self in native-endian byte order. Read more
Â§fn get_i128(&mut self) -> i128
Gets a signed 128 bit integer from self in big-endian byte order. Read more
Â§fn get_i128_le(&mut self) -> i128
Gets a signed 128 bit integer from self in little-endian byte order. Read more
Â§fn get_i128_ne(&mut self) -> i128
Gets a signed 128 bit integer from self in native-endian byte order. Read more
Â§fn get_f32(&mut self) -> f32
Gets an IEEE754 single-precision (4 bytes) floating point number from\nself in big-endian byte order. Read more
Â§fn get_f32_le(&mut self) -> f32
Gets an IEEE754 single-precision (4 bytes) floating point number from\nself in little-endian byte order. Read more
Â§fn get_f32_ne(&mut self) -> f32
Gets an IEEE754 single-precision (4 bytes) floating point number from\nself in native-endian byte order. Read more
Â§fn get_f64(&mut self) -> f64
Gets an IEEE754 double-precision (8 bytes) floating point number from\nself in big-endian byte order. Read more
Â§fn get_f64_le(&mut self) -> f64
Gets an IEEE754 double-precision (8 bytes) floating point number from\nself in little-endian byte order. Read more
Â§fn get_f64_ne(&mut self) -> f64
Gets an IEEE754 double-precision (8 bytes) floating point number from\nself in native-endian byte order. Read more
Â§fn take(self, limit: usize) -> Take<Self>where\n    Self: Sized,
Creates an adaptor which will read at most limit bytes from self. Read more
Â§fn chain<U>(self, next: U) -> Chain<Self, U>where\n    U: Buf,\n    Self: Sized,
Creates an adaptor which will chain this buffer with another. Read more
Â§fn reader(self) -> Reader<Self>where\n    Self: Sized,
Creates an adaptor which implements the Read trait for self. Read more
","Buf","bdk_esplora::blocking_ext::Error"],["Â§impl<T> BufMut for Box<T>where\n    T: BufMut + ?Sized,
Â§fn remaining_mut(&self) -> usize
Returns the number of bytes that can be written from the current\nposition until the end of the buffer is reached. Read more
Â§fn chunk_mut(&mut self) -> &mut UninitSlice
Returns a mutable slice starting at the current BufMut position and of\nlength between 0 and BufMut::remaining_mut(). Note that this can be shorter than the\nwhole remainder of the buffer (this allows non-continuous implementation). Read more
Â§unsafe fn advance_mut(&mut self, cnt: usize)
Advance the internal cursor of the BufMut Read more
Â§fn put_slice(&mut self, src: &[u8])
Transfer bytes into self from src and advance the cursor by the\nnumber of bytes written. Read more
Â§fn put_u8(&mut self, n: u8)
Writes an unsigned 8 bit integer to self. Read more
Â§fn put_i8(&mut self, n: i8)
Writes a signed 8 bit integer to self. Read more
Â§fn put_u16(&mut self, n: u16)
Writes an unsigned 16 bit integer to self in big-endian byte order. Read more
Â§fn put_u16_le(&mut self, n: u16)
Writes an unsigned 16 bit integer to self in little-endian byte order. Read more
Â§fn put_u16_ne(&mut self, n: u16)
Writes an unsigned 16 bit integer to self in native-endian byte order. Read more
Â§fn put_i16(&mut self, n: i16)
Writes a signed 16 bit integer to self in big-endian byte order. Read more
Â§fn put_i16_le(&mut self, n: i16)
Writes a signed 16 bit integer to self in little-endian byte order. Read more
Â§fn put_i16_ne(&mut self, n: i16)
Writes a signed 16 bit integer to self in native-endian byte order. Read more
Â§fn put_u32(&mut self, n: u32)
Writes an unsigned 32 bit integer to self in big-endian byte order. Read more
Â§fn put_u32_le(&mut self, n: u32)
Writes an unsigned 32 bit integer to self in little-endian byte order. Read more
Â§fn put_u32_ne(&mut self, n: u32)
Writes an unsigned 32 bit integer to self in native-endian byte order. Read more
Â§fn put_i32(&mut self, n: i32)
Writes a signed 32 bit integer to self in big-endian byte order. Read more
Â§fn put_i32_le(&mut self, n: i32)
Writes a signed 32 bit integer to self in little-endian byte order. Read more
Â§fn put_i32_ne(&mut self, n: i32)
Writes a signed 32 bit integer to self in native-endian byte order. Read more
Â§fn put_u64(&mut self, n: u64)
Writes an unsigned 64 bit integer to self in the big-endian byte order. Read more
Â§fn put_u64_le(&mut self, n: u64)
Writes an unsigned 64 bit integer to self in little-endian byte order. Read more
Â§fn put_u64_ne(&mut self, n: u64)
Writes an unsigned 64 bit integer to self in native-endian byte order. Read more
Â§fn put_i64(&mut self, n: i64)
Writes a signed 64 bit integer to self in the big-endian byte order. Read more
Â§fn put_i64_le(&mut self, n: i64)
Writes a signed 64 bit integer to self in little-endian byte order. Read more
Â§fn put_i64_ne(&mut self, n: i64)
Writes a signed 64 bit integer to self in native-endian byte order. Read more
Â§fn has_remaining_mut(&self) -> bool
Returns true if there is space in self for more bytes. Read more
Â§fn put<T>(&mut self, src: T)where\n    T: Buf,\n    Self: Sized,
Transfer bytes into self from src and advance the cursor by the\nnumber of bytes written. Read more
Â§fn put_bytes(&mut self, val: u8, cnt: usize)
Put cnt bytes val into self. Read more
Â§fn put_u128(&mut self, n: u128)
Writes an unsigned 128 bit integer to self in the big-endian byte order. Read more
Â§fn put_u128_le(&mut self, n: u128)
Writes an unsigned 128 bit integer to self in little-endian byte order. Read more
Â§fn put_u128_ne(&mut self, n: u128)
Writes an unsigned 128 bit integer to self in native-endian byte order. Read more
Â§fn put_i128(&mut self, n: i128)
Writes a signed 128 bit integer to self in the big-endian byte order. Read more
Â§fn put_i128_le(&mut self, n: i128)
Writes a signed 128 bit integer to self in little-endian byte order. Read more
Â§fn put_i128_ne(&mut self, n: i128)
Writes a signed 128 bit integer to self in native-endian byte order. Read more
Â§fn put_uint(&mut self, n: u64, nbytes: usize)
Writes an unsigned n-byte integer to self in big-endian byte order. Read more
Â§fn put_uint_le(&mut self, n: u64, nbytes: usize)
Writes an unsigned n-byte integer to self in the little-endian byte order. Read more
Â§fn put_uint_ne(&mut self, n: u64, nbytes: usize)
Writes an unsigned n-byte integer to self in the native-endian byte order. Read more
Â§fn put_int(&mut self, n: i64, nbytes: usize)
Writes low nbytes of a signed integer to self in big-endian byte order. Read more
Â§fn put_int_le(&mut self, n: i64, nbytes: usize)
Writes low nbytes of a signed integer to self in little-endian byte order. Read more
Â§fn put_int_ne(&mut self, n: i64, nbytes: usize)
Writes low nbytes of a signed integer to self in native-endian byte order. Read more
Â§fn put_f32(&mut self, n: f32)
Writes  an IEEE754 single-precision (4 bytes) floating point number to\nself in big-endian byte order. Read more
Â§fn put_f32_le(&mut self, n: f32)
Writes  an IEEE754 single-precision (4 bytes) floating point number to\nself in little-endian byte order. Read more
Â§fn put_f32_ne(&mut self, n: f32)
Writes an IEEE754 single-precision (4 bytes) floating point number to\nself in native-endian byte order. Read more
Â§fn put_f64(&mut self, n: f64)
Writes  an IEEE754 double-precision (8 bytes) floating point number to\nself in big-endian byte order. Read more
Â§fn put_f64_le(&mut self, n: f64)
Writes  an IEEE754 double-precision (8 bytes) floating point number to\nself in little-endian byte order. Read more
Â§fn put_f64_ne(&mut self, n: f64)
Writes  an IEEE754 double-precision (8 bytes) floating point number to\nself in native-endian byte order. Read more
Â§fn limit(self, limit: usize) -> Limit<Self>where\n    Self: Sized,
Creates an adaptor which can write at most limit bytes to self. Read more
Â§fn writer(self) -> Writer<Self>where\n    Self: Sized,
Creates an adaptor which implements the Write trait for self. Read more
Â§fn chain_mut<U>(self, next: U) -> Chain<Self, U>where\n    U: BufMut,\n    Self: Sized,
Creates an adapter which will chain this buffer with another. Read more
","BufMut","bdk_esplora::blocking_ext::Error"],["1.0.0 Â· sourceÂ§impl<B> BufRead for Box<B>where\n    B: BufRead + ?Sized,
sourceÂ§fn fill_buf(&mut self) -> Result<&[u8], Error>
Returns the contents of the internal buffer, filling it with more data\nfrom the inner reader if it is empty. Read more
sourceÂ§fn consume(&mut self, amt: usize)
Tells this buffer that amt bytes have been consumed from the buffer,\nso they should no longer be returned in calls to read. Read more
sourceÂ§fn read_until(&mut self, byte: u8, buf: &mut Vec<u8>) -> Result<usize, Error>
Read all bytes into buf until the delimiter byte or EOF is reached. Read more
sourceÂ§fn read_line(&mut self, buf: &mut String) -> Result<usize, Error>
Read all bytes until a newline (the 0xA byte) is reached, and append\nthem to the provided String buffer. Read more
sourceÂ§fn has_data_left(&mut self) -> Result<bool, Error>
ð¬This is a nightly-only experimental API. (buf_read_has_data_left)Check if the underlying Read has any data left to be read. Read more
sourceÂ§fn skip_until(&mut self, byte: u8) -> Result<usize, Error>
ð¬This is a nightly-only experimental API. (bufread_skip_until)Skip all bytes until the delimiter byte or EOF is reached. Read more
1.0.0 Â· sourceÂ§fn split(self, byte: u8) -> Split<Self>where\n    Self: Sized,
Returns an iterator over the contents of this reader split on the byte\nbyte. Read more
1.0.0 Â· sourceÂ§fn lines(self) -> Lines<Self>where\n    Self: Sized,
Returns an iterator over the lines of this reader. Read more
","BufRead","bdk_esplora::blocking_ext::Error"],["1.0.0 Â· sourceÂ§impl<T, A> Clone for Box<T, A>where\n    T: Clone,\n    A: Allocator + Clone,
sourceÂ§fn clone(&self) -> Box<T, A>
Returns a new box with a clone() of this boxâs contents.
\nÂ§Examples
\nlet x = Box::new(5);\nlet y = x.clone();\n\n// The value is the same\nassert_eq!(x, y);\n\n// But they are unique objects\nassert_ne!(&*x as *const i32, &*y as *const i32);
\n
sourceÂ§fn clone_from(&mut self, source: &Box<T, A>)
Copies sourceâs contents into self without creating a new allocation.
\nÂ§Examples
\nlet x = Box::new(5);\nlet mut y = Box::new(10);\nlet yp: *const i32 = &*y;\n\ny.clone_from(&x);\n\n// The value is the same\nassert_eq!(x, y);\n\n// And no allocation occurred\nassert_eq!(yp, &*y);
\n
","Clone","bdk_esplora::blocking_ext::Error"],["sourceÂ§impl<G, R, A> Coroutine<R> for Box<G, A>where\n    G: Coroutine<R> + Unpin + ?Sized,\n    A: Allocator,
Â§type Yield = <G as Coroutine<R>>::Yield
ð¬This is a nightly-only experimental API. (coroutine_trait)The type of value this coroutine yields. Read more
Â§type Return = <G as Coroutine<R>>::Return
ð¬This is a nightly-only experimental API. (coroutine_trait)The type of value this coroutine returns. Read more
sourceÂ§fn resume(\n    self: Pin<&mut Box<G, A>>,\n    arg: R\n) -> CoroutineState<<Box<G, A> as Coroutine<R>>::Yield, <Box<G, A> as Coroutine<R>>::Return>
ð¬This is a nightly-only experimental API. (coroutine_trait)Resumes the execution of this coroutine. Read more
","Coroutine","bdk_esplora::blocking_ext::Error"],["1.0.0 Â· sourceÂ§impl<T, A> Debug for Box<T, A>where\n    T: Debug + ?Sized,\n    A: Allocator,
sourceÂ§fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>
Formats the value using the given formatter. Read more
","Debug","bdk_esplora::blocking_ext::Error"],["1.0.0 Â· sourceÂ§impl<T> Default for Box<T>where\n    T: Default,
sourceÂ§fn default() -> Box<T>
Creates a Box<T>, with the Default value for T.
\n
","Default","bdk_esplora::blocking_ext::Error"],["1.0.0 Â· sourceÂ§impl<T, A> Deref for Box<T, A>where\n    A: Allocator,\n    T: ?Sized,
Â§type Target = T
The resulting type after dereferencing.
sourceÂ§fn deref(&self) -> &T
Dereferences the value.
","Deref","bdk_esplora::blocking_ext::Error"],["1.0.0 Â· sourceÂ§impl<T, A> DerefMut for Box<T, A>where\n    A: Allocator,\n    T: ?Sized,
sourceÂ§fn deref_mut(&mut self) -> &mut T
Mutably dereferences the value.
","DerefMut","bdk_esplora::blocking_ext::Error"],["sourceÂ§impl<'de, T> Deserialize<'de> for Box<T>where\n    T: Deserialize<'de>,
sourceÂ§fn deserialize<D>(\n    deserializer: D\n) -> Result<Box<T>, <D as Deserializer<'de>>::Error>where\n    D: Deserializer<'de>,
Deserialize this value from the given Serde deserializer. Read more
","Deserialize<'de>","bdk_esplora::blocking_ext::Error"],["1.0.0 Â· sourceÂ§impl<T, A> Display for Box<T, A>where\n    T: Display + ?Sized,\n    A: Allocator,
sourceÂ§fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>
Formats the value using the given formatter. Read more
","Display","bdk_esplora::blocking_ext::Error"],["sourceÂ§impl<I> DoubleEndedFallibleIterator for Box<I>where\n    I: DoubleEndedFallibleIterator + ?Sized,
sourceÂ§fn next_back(\n    &mut self\n) -> Result<Option<<I as FallibleIterator>::Item>, <I as FallibleIterator>::Error>
Advances the end of the iterator, returning the last value.
sourceÂ§fn rfold<B, F>(self, init: B, f: F) -> Result<B, Self::Error>where\n    Self: Sized,\n    F: FnMut(B, Self::Item) -> Result<B, Self::Error>,
Applies a function over the elements of the iterator in reverse order, producing a single final value.
sourceÂ§fn try_rfold<B, E, F>(&mut self, init: B, f: F) -> Result<B, E>where\n    Self: Sized,\n    E: From<Self::Error>,\n    F: FnMut(B, Self::Item) -> Result<B, E>,
Applies a function over the elements of the iterator in reverse, producing a single final value. Read more
","DoubleEndedFallibleIterator","bdk_esplora::blocking_ext::Error"],["1.0.0 Â· sourceÂ§impl<I, A> DoubleEndedIterator for Box<I, A>where\n    I: DoubleEndedIterator + ?Sized,\n    A: Allocator,
sourceÂ§fn next_back(&mut self) -> Option<<I as Iterator>::Item>
Removes and returns an element from the end of the iterator. Read more
sourceÂ§fn nth_back(&mut self, n: usize) -> Option<<I as Iterator>::Item>
Returns the nth element from the end of the iterator. Read more
sourceÂ§fn advance_back_by(&mut self, n: usize) -> Result<(), NonZero<usize>>
ð¬This is a nightly-only experimental API. (iter_advance_by)Advances the iterator from the back by n elements. Read more
1.27.0 Â· sourceÂ§fn try_rfold<B, F, R>(&mut self, init: B, f: F) -> Rwhere\n    Self: Sized,\n    F: FnMut(B, Self::Item) -> R,\n    R: Try<Output = B>,
This is the reverse version of Iterator::try_fold(): it takes\nelements starting from the back of the iterator. Read more
1.27.0 Â· sourceÂ§fn rfold<B, F>(self, init: B, f: F) -> Bwhere\n    Self: Sized,\n    F: FnMut(B, Self::Item) -> B,
An iterator method that reduces the iteratorâs elements to a single,\nfinal value, starting from the back. Read more
1.27.0 Â· sourceÂ§fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item>where\n    Self: Sized,\n    P: FnMut(&Self::Item) -> bool,
Searches for an element of an iterator from the back that satisfies a predicate. Read more
","DoubleEndedIterator","bdk_esplora::blocking_ext::Error"],["1.0.0 Â· sourceÂ§impl<T, A> Drop for Box<T, A>where\n    A: Allocator,\n    T: ?Sized,
sourceÂ§fn drop(&mut self)
Executes the destructor for this type. Read more
","Drop","bdk_esplora::blocking_ext::Error"],["1.8.0 Â· sourceÂ§impl<T> Error for Box<T>where\n    T: Error,
sourceÂ§fn description(&self) -> &str
ðDeprecated since 1.42.0: use the Display impl or to_string() Read more
sourceÂ§fn cause(&self) -> Option<&dyn Error>
ðDeprecated since 1.33.0: replaced by Error::source, which can support downcasting
sourceÂ§fn source(&self) -> Option<&(dyn Error + 'static)>
The lower-level source of this error, if any. Read more
sourceÂ§fn provide<'b>(&'b self, request: &mut Request<'b>)
ð¬This is a nightly-only experimental API. (error_generic_member_access)Provides type based access to context intended for error reports. Read more
","Error","bdk_esplora::blocking_ext::Error"],["1.0.0 Â· sourceÂ§impl<I, A> ExactSizeIterator for Box<I, A>where\n    I: ExactSizeIterator + ?Sized,\n    A: Allocator,
sourceÂ§fn len(&self) -> usize
Returns the exact remaining length of the iterator. Read more
sourceÂ§fn is_empty(&self) -> bool
ð¬This is a nightly-only experimental API. (exact_size_is_empty)Returns true if the iterator is empty. Read more
","ExactSizeIterator","bdk_esplora::blocking_ext::Error"],["sourceÂ§impl<I> FallibleIterator for Box<I>where\n    I: FallibleIterator + ?Sized,
Â§type Item = <I as FallibleIterator>::Item
The type being iterated over.
Â§type Error = <I as FallibleIterator>::Error
The error type.
sourceÂ§fn next(\n    &mut self\n) -> Result<Option<<I as FallibleIterator>::Item>, <I as FallibleIterator>::Error>
Advances the iterator and returns the next value. Read more
sourceÂ§fn size_hint(&self) -> (usize, Option<usize>)
Returns bounds on the remaining length of the iterator. Read more
sourceÂ§fn nth(\n    &mut self,\n    n: usize\n) -> Result<Option<<I as FallibleIterator>::Item>, <I as FallibleIterator>::Error>
Returns the nth element of the iterator.
sourceÂ§fn count(self) -> Result<usize, Self::Error>where\n    Self: Sized,
Consumes the iterator, returning the number of remaining items.
sourceÂ§fn last(self) -> Result<Option<Self::Item>, Self::Error>where\n    Self: Sized,
Returns the last element of the iterator.
sourceÂ§fn step_by(self, step: usize) -> StepBy<Self>where\n    Self: Sized,
Returns an iterator starting at the same point, but stepping by the given amount at each iteration. Read more
sourceÂ§fn chain<I>(self, it: I) -> Chain<Self, I>where\n    I: IntoFallibleIterator<Item = Self::Item, Error = Self::Error>,\n    Self: Sized,
Returns an iterator which yields the elements of this iterator followed\nby another.
sourceÂ§fn zip<I>(\n    self,\n    o: I\n) -> Zip<Self, <I as IntoFallibleIterator>::IntoFallibleIter>where\n    Self: Sized,\n    I: IntoFallibleIterator<Error = Self::Error>,
Returns an iterator that yields pairs of this iteratorâs and another\niteratorâs values.
sourceÂ§fn map<F, B>(self, f: F) -> Map<Self, F>where\n    Self: Sized,\n    F: FnMut(Self::Item) -> Result<B, Self::Error>,
Returns an iterator which applies a fallible transform to the elements\nof the underlying iterator.
sourceÂ§fn for_each<F>(self, f: F) -> Result<(), Self::Error>where\n    Self: Sized,\n    F: FnMut(Self::Item) -> Result<(), Self::Error>,
Calls a fallible closure on each element of an iterator.
sourceÂ§fn filter<F>(self, f: F) -> Filter<Self, F>where\n    Self: Sized,\n    F: FnMut(&Self::Item) -> Result<bool, Self::Error>,
Returns an iterator which uses a predicate to determine which values\nshould be yielded. The predicate may fail; such failures are passed to\nthe caller.
sourceÂ§fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>where\n    Self: Sized,\n    F: FnMut(Self::Item) -> Result<Option<B>, Self::Error>,
Returns an iterator which both filters and maps. The closure may fail;\nsuch failures are passed along to the consumer.
sourceÂ§fn enumerate(self) -> Enumerate<Self>where\n    Self: Sized,
Returns an iterator which yields the current iteration count as well\nas the value.
sourceÂ§fn peekable(self) -> Peekable<Self>where\n    Self: Sized,
Returns an iterator that can peek at the next element without consuming\nit.
sourceÂ§fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>where\n    Self: Sized,\n    P: FnMut(&Self::Item) -> Result<bool, Self::Error>,
Returns an iterator that skips elements based on a predicate.
sourceÂ§fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>where\n    Self: Sized,\n    P: FnMut(&Self::Item) -> Result<bool, Self::Error>,
Returns an iterator that yields elements based on a predicate.
sourceÂ§fn skip(self, n: usize) -> Skip<Self>where\n    Self: Sized,
Returns an iterator which skips the first n values of this iterator.
sourceÂ§fn take(self, n: usize) -> Take<Self>where\n    Self: Sized,
Returns an iterator that yields only the first n values of this\niterator.
sourceÂ§fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>where\n    Self: Sized,\n    F: FnMut(&mut St, Self::Item) -> Result<Option<B>, Self::Error>,
Returns an iterator which applies a stateful map to values of this\niterator.
sourceÂ§fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>where\n    Self: Sized,\n    U: IntoFallibleIterator<Error = Self::Error>,\n    F: FnMut(Self::Item) -> Result<U, Self::Error>,
Returns an iterator which maps this iteratorâs elements to iterators, yielding those iteratorsâ values.
sourceÂ§fn fuse(self) -> Fuse<Self>where\n    Self: Sized,
Returns an iterator which yields this iteratorâs elements and ends after\nthe first Ok(None). Read more
sourceÂ§fn inspect<F>(self, f: F) -> Inspect<Self, F>where\n    Self: Sized,\n    F: FnMut(&Self::Item) -> Result<(), Self::Error>,
Returns an iterator which passes each element to a closure before returning it.
sourceÂ§fn by_ref(&mut self) -> &mut Selfwhere\n    Self: Sized,
Borrow an iterator rather than consuming it. Read more
sourceÂ§fn collect<T>(self) -> Result<T, Self::Error>where\n    T: FromIterator<Self::Item>,\n    Self: Sized,
Transforms the iterator into a collection. Read more
sourceÂ§fn partition<B, F>(self, f: F) -> Result<(B, B), Self::Error>where\n    Self: Sized,\n    B: Default + Extend<Self::Item>,\n    F: FnMut(&Self::Item) -> Result<bool, Self::Error>,
Transforms the iterator into two collections, partitioning elements by a closure.
sourceÂ§fn fold<B, F>(self, init: B, f: F) -> Result<B, Self::Error>where\n    Self: Sized,\n    F: FnMut(B, Self::Item) -> Result<B, Self::Error>,
Applies a function over the elements of the iterator, producing a single\nfinal value.
sourceÂ§fn try_fold<B, E, F>(&mut self, init: B, f: F) -> Result<B, E>where\n    Self: Sized,\n    E: From<Self::Error>,\n    F: FnMut(B, Self::Item) -> Result<B, E>,
Applies a function over the elements of the iterator, producing a single final value. Read more
sourceÂ§fn all<F>(&mut self, f: F) -> Result<bool, Self::Error>where\n    Self: Sized,\n    F: FnMut(Self::Item) -> Result<bool, Self::Error>,
Determines if all elements of this iterator match a predicate.
sourceÂ§fn any<F>(&mut self, f: F) -> Result<bool, Self::Error>where\n    Self: Sized,\n    F: FnMut(Self::Item) -> Result<bool, Self::Error>,
Determines if any element of this iterator matches a predicate.
sourceÂ§fn find<F>(&mut self, f: F) -> Result<Option<Self::Item>, Self::Error>where\n    Self: Sized,\n    F: FnMut(&Self::Item) -> Result<bool, Self::Error>,
Returns the first element of the iterator that matches a predicate.
sourceÂ§fn find_map<B, F>(&mut self, f: F) -> Result<Option<B>, Self::Error>where\n    Self: Sized,\n    F: FnMut(Self::Item) -> Result<Option<B>, Self::Error>,
Applies a function to the elements of the iterator, returning the first non-None result.
sourceÂ§fn position<F>(&mut self, f: F) -> Result<Option<usize>, Self::Error>where\n    Self: Sized,\n    F: FnMut(Self::Item) -> Result<bool, Self::Error>,
Returns the position of the first element of this iterator that matches\na predicate. The predicate may fail; such failures are returned to the\ncaller.
sourceÂ§fn max_by_key<B, F>(self, f: F) -> Result<Option<Self::Item>, Self::Error>where\n    Self: Sized,\n    B: Ord,\n    F: FnMut(&Self::Item) -> Result<B, Self::Error>,
Returns the element of the iterator which gives the maximum value from\nthe function.
sourceÂ§fn max_by<F>(self, f: F) -> Result<Option<Self::Item>, Self::Error>where\n    Self: Sized,\n    F: FnMut(&Self::Item, &Self::Item) -> Result<Ordering, Self::Error>,
Returns the element that gives the maximum value with respect to the function.
sourceÂ§fn min_by_key<B, F>(self, f: F) -> Result<Option<Self::Item>, Self::Error>where\n    Self: Sized,\n    B: Ord,\n    F: FnMut(&Self::Item) -> Result<B, Self::Error>,
Returns the element of the iterator which gives the minimum value from\nthe function.
sourceÂ§fn min_by<F>(self, f: F) -> Result<Option<Self::Item>, Self::Error>where\n    Self: Sized,\n    F: FnMut(&Self::Item, &Self::Item) -> Result<Ordering, Self::Error>,
Returns the element that gives the minimum value with respect to the function.
sourceÂ§fn unzip<A, B, FromA, FromB>(self) -> Result<(FromA, FromB), Self::Error>where\n    Self: Sized + FallibleIterator<Item = (A, B)>,\n    FromA: Default + Extend<A>,\n    FromB: Default + Extend<B>,
Converts an iterator of pairs into a pair of containers.
sourceÂ§fn cloned<'a, T>(self) -> Cloned<Self>where\n    Self: Sized + FallibleIterator<Item = &'a T>,\n    T: 'a + Clone,
Returns an iterator which clones all of its elements.
sourceÂ§fn partial_cmp<I>(self, other: I) -> Result<Option<Ordering>, Self::Error>where\n    Self: Sized,\n    I: IntoFallibleIterator<Error = Self::Error>,\n    Self::Item: PartialOrd<<I as IntoFallibleIterator>::Item>,
Lexicographically compares the elements of this iterator to that of\nanother.
sourceÂ§fn eq<I>(self, other: I) -> Result<bool, Self::Error>where\n    Self: Sized,\n    I: IntoFallibleIterator<Error = Self::Error>,\n    Self::Item: PartialEq<<I as IntoFallibleIterator>::Item>,
Determines if the elements of this iterator are equal to those of\nanother.
sourceÂ§fn ne<I>(self, other: I) -> Result<bool, Self::Error>where\n    Self: Sized,\n    I: IntoFallibleIterator<Error = Self::Error>,\n    Self::Item: PartialEq<<I as IntoFallibleIterator>::Item>,
Determines if the elements of this iterator are not equal to those of\nanother.
sourceÂ§fn lt<I>(self, other: I) -> Result<bool, Self::Error>where\n    Self: Sized,\n    I: IntoFallibleIterator<Error = Self::Error>,\n    Self::Item: PartialOrd<<I as IntoFallibleIterator>::Item>,
Determines if the elements of this iterator are lexicographically less\nthan those of another.
sourceÂ§fn le<I>(self, other: I) -> Result<bool, Self::Error>where\n    Self: Sized,\n    I: IntoFallibleIterator<Error = Self::Error>,\n    Self::Item: PartialOrd<<I as IntoFallibleIterator>::Item>,
Determines if the elements of this iterator are lexicographically less\nthan or equal to those of another.
sourceÂ§fn gt<I>(self, other: I) -> Result<bool, Self::Error>where\n    Self: Sized,\n    I: IntoFallibleIterator<Error = Self::Error>,\n    Self::Item: PartialOrd<<I as IntoFallibleIterator>::Item>,
Determines if the elements of this iterator are lexicographically\ngreater than those of another.
sourceÂ§fn ge<I>(self, other: I) -> Result<bool, Self::Error>where\n    Self: Sized,\n    I: IntoFallibleIterator<Error = Self::Error>,\n    Self::Item: PartialOrd<<I as IntoFallibleIterator>::Item>,
Determines if the elements of this iterator are lexicographically\ngreater than or equal to those of another.
sourceÂ§fn iterator(self) -> Iterator<Self>where\n    Self: Sized,
Returns a normal (non-fallible) iterator over Result<Item, Error>.
sourceÂ§fn map_err<B, F>(self, f: F) -> MapErr<Self, F>where\n    F: FnMut(Self::Error) -> B,\n    Self: Sized,
Returns an iterator which applies a transform to the errors of the\nunderlying iterator.
","FallibleIterator","bdk_esplora::blocking_ext::Error"],["1.35.0 Â· sourceÂ§impl<Args, F, A> Fn<Args> for Box<F, A>where\n    Args: Tuple,\n    F: Fn<Args> + ?Sized,\n    A: Allocator,
sourceÂ§extern "rust-call" fn call(\n    &self,\n    args: Args\n) -> <Box<F, A> as FnOnce<Args>>::Output
ð¬This is a nightly-only experimental API. (fn_traits)Performs the call operation.
","Fn","bdk_esplora::blocking_ext::Error"],["1.35.0 Â· sourceÂ§impl<Args, F, A> FnMut<Args> for Box<F, A>where\n    Args: Tuple,\n    F: FnMut<Args> + ?Sized,\n    A: Allocator,
sourceÂ§extern "rust-call" fn call_mut(\n    &mut self,\n    args: Args\n) -> <Box<F, A> as FnOnce<Args>>::Output
ð¬This is a nightly-only experimental API. (fn_traits)Performs the call operation.
","FnMut","bdk_esplora::blocking_ext::Error"],["1.35.0 Â· sourceÂ§impl<Args, F, A> FnOnce<Args> for Box<F, A>where\n    Args: Tuple,\n    F: FnOnce<Args> + ?Sized,\n    A: Allocator,
Â§type Output = <F as FnOnce<Args>>::Output
The returned type after the call operator is used.
sourceÂ§extern "rust-call" fn call_once(\n    self,\n    args: Args\n) -> <Box<F, A> as FnOnce<Args>>::Output
ð¬This is a nightly-only experimental API. (fn_traits)Performs the call operation.
","FnOnce","bdk_esplora::blocking_ext::Error"],["1.6.0 Â· sourceÂ§impl<T> From<T> for Box<T>
sourceÂ§fn from(t: T) -> Box<T>
Converts a T into a Box<T>
\nThe conversion allocates on the heap and moves t\nfrom the stack into it.
\nÂ§Examples
\nlet x = 5;\nlet boxed = Box::new(5);\n\nassert_eq!(Box::from(x), boxed);
\n
","From","bdk_esplora::blocking_ext::Error"],["Â§impl<F> FusedFuture for Box<F>where\n    F: FusedFuture + Unpin + ?Sized,
Â§fn is_terminated(&self) -> bool
Returns true if the underlying future should no longer be polled.
","FusedFuture","bdk_esplora::blocking_ext::Error"],["Â§impl<S> FusedStream for Box<S>where\n    S: FusedStream + Unpin + ?Sized,
Â§fn is_terminated(&self) -> bool
Returns true if the stream should no longer be polled.
","FusedStream","bdk_esplora::blocking_ext::Error"],["1.36.0 Â· sourceÂ§impl<F, A> Future for Box<F, A>where\n    F: Future + Unpin + ?Sized,\n    A: Allocator,
Â§type Output = <F as Future>::Output
The type of value produced on completion.
sourceÂ§fn poll(\n    self: Pin<&mut Box<F, A>>,\n    cx: &mut Context<'_>\n) -> Poll<<Box<F, A> as Future>::Output>
Attempt to resolve the future to a final value, registering\nthe current task for wakeup if the value is not yet available. Read more
","Future","bdk_esplora::blocking_ext::Error"],["1.0.0 Â· sourceÂ§impl<T, A> Hash for Box<T, A>where\n    T: Hash + ?Sized,\n    A: Allocator,
sourceÂ§fn hash<H>(&self, state: &mut H)where\n    H: Hasher,
Feeds this value into the given Hasher. Read more
1.3.0 Â· sourceÂ§fn hash_slice<H>(data: &[Self], state: &mut H)where\n    H: Hasher,\n    Self: Sized,
Feeds a slice of this type into the given Hasher. Read more
","Hash","bdk_esplora::blocking_ext::Error"],["1.22.0 Â· sourceÂ§impl<T, A> Hasher for Box<T, A>where\n    T: Hasher + ?Sized,\n    A: Allocator,
sourceÂ§fn finish(&self) -> u64
Returns the hash value for the values written so far. Read more
sourceÂ§fn write(&mut self, bytes: &[u8])
Writes some data into this Hasher. Read more
sourceÂ§fn write_u8(&mut self, i: u8)
Writes a single u8 into this hasher.
sourceÂ§fn write_u16(&mut self, i: u16)
Writes a single u16 into this hasher.
sourceÂ§fn write_u32(&mut self, i: u32)
Writes a single u32 into this hasher.
sourceÂ§fn write_u64(&mut self, i: u64)
Writes a single u64 into this hasher.
sourceÂ§fn write_u128(&mut self, i: u128)
Writes a single u128 into this hasher.
sourceÂ§fn write_usize(&mut self, i: usize)
Writes a single usize into this hasher.
sourceÂ§fn write_i8(&mut self, i: i8)
Writes a single i8 into this hasher.
sourceÂ§fn write_i16(&mut self, i: i16)
Writes a single i16 into this hasher.
sourceÂ§fn write_i32(&mut self, i: i32)
Writes a single i32 into this hasher.
sourceÂ§fn write_i64(&mut self, i: i64)
Writes a single i64 into this hasher.
sourceÂ§fn write_i128(&mut self, i: i128)
Writes a single i128 into this hasher.
sourceÂ§fn write_isize(&mut self, i: isize)
Writes a single isize into this hasher.
sourceÂ§fn write_length_prefix(&mut self, len: usize)
ð¬This is a nightly-only experimental API. (hasher_prefixfree_extras)Writes a length prefix into this hasher, as part of being prefix-free. Read more
sourceÂ§fn write_str(&mut self, s: &str)
ð¬This is a nightly-only experimental API. (hasher_prefixfree_extras)Writes a single str into this hasher. Read more
","Hasher","bdk_esplora::blocking_ext::Error"],["1.0.0 Â· sourceÂ§impl<I, A> Iterator for Box<I, A>where\n    I: Iterator + ?Sized,\n    A: Allocator,
Â§type Item = <I as Iterator>::Item
The type of the elements being iterated over.
sourceÂ§fn next(&mut self) -> Option<<I as Iterator>::Item>
Advances the iterator and returns the next value. Read more
sourceÂ§fn size_hint(&self) -> (usize, Option<usize>)
Returns the bounds on the remaining length of the iterator. Read more
sourceÂ§fn nth(&mut self, n: usize) -> Option<<I as Iterator>::Item>
Returns the nth element of the iterator. Read more
sourceÂ§fn last(self) -> Option<<I as Iterator>::Item>
Consumes the iterator, returning the last element. Read more
sourceÂ§fn next_chunk<const N: usize>(\n    &mut self\n) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>where\n    Self: Sized,
ð¬This is a nightly-only experimental API. (iter_next_chunk)Advances the iterator and returns an array containing the next N values. Read more
1.0.0 Â· sourceÂ§fn count(self) -> usizewhere\n    Self: Sized,
Consumes the iterator, counting the number of iterations and returning it. Read more
sourceÂ§fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>
ð¬This is a nightly-only experimental API. (iter_advance_by)Advances the iterator by n elements. Read more
1.28.0 Â· sourceÂ§fn step_by(self, step: usize) -> StepBy<Self>where\n    Self: Sized,
Creates an iterator starting at the same point, but stepping by\nthe given amount at each iteration. Read more
1.0.0 Â· sourceÂ§fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>where\n    Self: Sized,\n    U: IntoIterator<Item = Self::Item>,
Takes two iterators and creates a new iterator over both in sequence. Read more
1.0.0 Â· sourceÂ§fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>where\n    Self: Sized,\n    U: IntoIterator,
âZips upâ two iterators into a single iterator of pairs. Read more
sourceÂ§fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>where\n    Self: Sized,\n    G: FnMut() -> Self::Item,
ð¬This is a nightly-only experimental API. (iter_intersperse)Creates a new iterator which places an item generated by separator\nbetween adjacent items of the original iterator. Read more
1.0.0 Â· sourceÂ§fn map<B, F>(self, f: F) -> Map<Self, F>where\n    Self: Sized,\n    F: FnMut(Self::Item) -> B,
Takes a closure and creates an iterator which calls that closure on each\nelement. Read more
1.21.0 Â· sourceÂ§fn for_each<F>(self, f: F)where\n    Self: Sized,\n    F: FnMut(Self::Item),
Calls a closure on each element of an iterator. Read more
1.0.0 Â· sourceÂ§fn filter<P>(self, predicate: P) -> Filter<Self, P>where\n    Self: Sized,\n    P: FnMut(&Self::Item) -> bool,
Creates an iterator which uses a closure to determine if an element\nshould be yielded. Read more
1.0.0 Â· sourceÂ§fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>where\n    Self: Sized,\n    F: FnMut(Self::Item) -> Option<B>,
Creates an iterator that both filters and maps. Read more
1.0.0 Â· sourceÂ§fn enumerate(self) -> Enumerate<Self>where\n    Self: Sized,
Creates an iterator which gives the current iteration count as well as\nthe next value. Read more
1.0.0 Â· sourceÂ§fn peekable(self) -> Peekable<Self>where\n    Self: Sized,
Creates an iterator which can use the peek and peek_mut methods\nto look at the next element of the iterator without consuming it. See\ntheir documentation for more information. Read more
1.0.0 Â· sourceÂ§fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>where\n    Self: Sized,\n    P: FnMut(&Self::Item) -> bool,
Creates an iterator that skips elements based on a predicate. Read more
1.0.0 Â· sourceÂ§fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>where\n    Self: Sized,\n    P: FnMut(&Self::Item) -> bool,
Creates an iterator that yields elements based on a predicate. Read more
1.57.0 Â· sourceÂ§fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>where\n    Self: Sized,\n    P: FnMut(Self::Item) -> Option<B>,
Creates an iterator that both yields elements based on a predicate and maps. Read more
1.0.0 Â· sourceÂ§fn skip(self, n: usize) -> Skip<Self>where\n    Self: Sized,
Creates an iterator that skips the first n elements. Read more
1.0.0 Â· sourceÂ§fn take(self, n: usize) -> Take<Self>where\n    Self: Sized,
Creates an iterator that yields the first n elements, or fewer\nif the underlying iterator ends sooner. Read more
1.0.0 Â· sourceÂ§fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>where\n    Self: Sized,\n    F: FnMut(&mut St, Self::Item) -> Option<B>,
An iterator adapter which, like fold, holds internal state, but\nunlike fold, produces a new iterator. Read more
1.0.0 Â· sourceÂ§fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>where\n    Self: Sized,\n    U: IntoIterator,\n    F: FnMut(Self::Item) -> U,
Creates an iterator that works like map, but flattens nested structure. Read more
sourceÂ§fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>where\n    Self: Sized,\n    F: FnMut(&[Self::Item; N]) -> R,
ð¬This is a nightly-only experimental API. (iter_map_windows)Calls the given function f for each contiguous window of size N over\nself and returns an iterator over the outputs of f. Like slice::windows(),\nthe windows during mapping overlap as well. Read more
1.0.0 Â· sourceÂ§fn fuse(self) -> Fuse<Self>where\n    Self: Sized,
Creates an iterator which ends after the first None. Read more
1.0.0 Â· sourceÂ§fn inspect<F>(self, f: F) -> Inspect<Self, F>where\n    Self: Sized,\n    F: FnMut(&Self::Item),
Does something with each element of an iterator, passing the value on. Read more
1.0.0 Â· sourceÂ§fn by_ref(&mut self) -> &mut Selfwhere\n    Self: Sized,
Borrows an iterator, rather than consuming it. Read more
1.0.0 Â· sourceÂ§fn collect<B>(self) -> Bwhere\n    B: FromIterator<Self::Item>,\n    Self: Sized,
Transforms an iterator into a collection. Read more
sourceÂ§fn collect_into<E>(self, collection: &mut E) -> &mut Ewhere\n    E: Extend<Self::Item>,\n    Self: Sized,
ð¬This is a nightly-only experimental API. (iter_collect_into)Collects all the items from an iterator into a collection. Read more
1.0.0 Â· sourceÂ§fn partition<B, F>(self, f: F) -> (B, B)where\n    Self: Sized,\n    B: Default + Extend<Self::Item>,\n    F: FnMut(&Self::Item) -> bool,
Consumes an iterator, creating two collections from it. Read more
sourceÂ§fn is_partitioned<P>(self, predicate: P) -> boolwhere\n    Self: Sized,\n    P: FnMut(Self::Item) -> bool,
ð¬This is a nightly-only experimental API. (iter_is_partitioned)Checks if the elements of this iterator are partitioned according to the given predicate,\nsuch that all those that return true precede all those that return false. Read more
1.27.0 Â· sourceÂ§fn try_fold<B, F, R>(&mut self, init: B, f: F) -> Rwhere\n    Self: Sized,\n    F: FnMut(B, Self::Item) -> R,\n    R: Try<Output = B>,
An iterator method that applies a function as long as it returns\nsuccessfully, producing a single, final value. Read more
1.27.0 Â· sourceÂ§fn try_for_each<F, R>(&mut self, f: F) -> Rwhere\n    Self: Sized,\n    F: FnMut(Self::Item) -> R,\n    R: Try<Output = ()>,
An iterator method that applies a fallible function to each item in the\niterator, stopping at the first error and returning that error. Read more
1.0.0 Â· sourceÂ§fn fold<B, F>(self, init: B, f: F) -> Bwhere\n    Self: Sized,\n    F: FnMut(B, Self::Item) -> B,
Folds every element into an accumulator by applying an operation,\nreturning the final result. Read more
1.51.0 Â· sourceÂ§fn reduce<F>(self, f: F) -> Option<Self::Item>where\n    Self: Sized,\n    F: FnMut(Self::Item, Self::Item) -> Self::Item,
Reduces the elements to a single one, by repeatedly applying a reducing\noperation. Read more
sourceÂ§fn try_reduce<F, R>(\n    &mut self,\n    f: F\n) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryTypewhere\n    Self: Sized,\n    F: FnMut(Self::Item, Self::Item) -> R,\n    R: Try<Output = Self::Item>,\n    <R as Try>::Residual: Residual<Option<Self::Item>>,
ð¬This is a nightly-only experimental API. (iterator_try_reduce)Reduces the elements to a single one by repeatedly applying a reducing operation. If the\nclosure returns a failure, the failure is propagated back to the caller immediately. Read more
1.0.0 Â· sourceÂ§fn all<F>(&mut self, f: F) -> boolwhere\n    Self: Sized,\n    F: FnMut(Self::Item) -> bool,
Tests if every element of the iterator matches a predicate. Read more
1.0.0 Â· sourceÂ§fn any<F>(&mut self, f: F) -> boolwhere\n    Self: Sized,\n    F: FnMut(Self::Item) -> bool,
Tests if any element of the iterator matches a predicate. Read more
1.0.0 Â· sourceÂ§fn find<P>(&mut self, predicate: P) -> Option<Self::Item>where\n    Self: Sized,\n    P: FnMut(&Self::Item) -> bool,
Searches for an element of an iterator that satisfies a predicate. Read more
1.30.0 Â· sourceÂ§fn find_map<B, F>(&mut self, f: F) -> Option<B>where\n    Self: Sized,\n    F: FnMut(Self::Item) -> Option<B>,
Applies function to the elements of iterator and returns\nthe first non-none result. Read more
sourceÂ§fn try_find<F, R>(\n    &mut self,\n    f: F\n) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryTypewhere\n    Self: Sized,\n    F: FnMut(&Self::Item) -> R,\n    R: Try<Output = bool>,\n    <R as Try>::Residual: Residual<Option<Self::Item>>,
ð¬This is a nightly-only experimental API. (try_find)Applies function to the elements of iterator and returns\nthe first true result or the first error. Read more
1.0.0 Â· sourceÂ§fn position<P>(&mut self, predicate: P) -> Option<usize>where\n    Self: Sized,\n    P: FnMut(Self::Item) -> bool,
Searches for an element in an iterator, returning its index. Read more
1.6.0 Â· sourceÂ§fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>where\n    B: Ord,\n    Self: Sized,\n    F: FnMut(&Self::Item) -> B,
Returns the element that gives the maximum value from the\nspecified function. Read more
1.15.0 Â· sourceÂ§fn max_by<F>(self, compare: F) -> Option<Self::Item>where\n    Self: Sized,\n    F: FnMut(&Self::Item, &Self::Item) -> Ordering,
Returns the element that gives the maximum value with respect to the\nspecified comparison function. Read more
1.6.0 Â· sourceÂ§fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>where\n    B: Ord,\n    Self: Sized,\n    F: FnMut(&Self::Item) -> B,
Returns the element that gives the minimum value from the\nspecified function. Read more
1.15.0 Â· sourceÂ§fn min_by<F>(self, compare: F) -> Option<Self::Item>where\n    Self: Sized,\n    F: FnMut(&Self::Item, &Self::Item) -> Ordering,
Returns the element that gives the minimum value with respect to the\nspecified comparison function. Read more
1.0.0 Â· sourceÂ§fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)where\n    FromA: Default + Extend<A>,\n    FromB: Default + Extend<B>,\n    Self: Sized + Iterator<Item = (A, B)>,
Converts an iterator of pairs into a pair of containers. Read more
1.36.0 Â· sourceÂ§fn copied<'a, T>(self) -> Copied<Self>where\n    T: 'a + Copy,\n    Self: Sized + Iterator<Item = &'a T>,
Creates an iterator which copies all of its elements. Read more
1.0.0 Â· sourceÂ§fn cloned<'a, T>(self) -> Cloned<Self>where\n    T: 'a + Clone,\n    Self: Sized + Iterator<Item = &'a T>,
Creates an iterator which clones all of its elements. Read more
sourceÂ§fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>where\n    Self: Sized,
ð¬This is a nightly-only experimental API. (iter_array_chunks)Returns an iterator over N elements of the iterator at a time. Read more
1.11.0 Â· sourceÂ§fn sum<S>(self) -> Swhere\n    Self: Sized,\n    S: Sum<Self::Item>,
Sums the elements of an iterator. Read more
1.11.0 Â· sourceÂ§fn product<P>(self) -> Pwhere\n    Self: Sized,\n    P: Product<Self::Item>,
Iterates over the entire iterator, multiplying all the elements Read more
sourceÂ§fn cmp_by<I, F>(self, other: I, cmp: F) -> Orderingwhere\n    Self: Sized,\n    I: IntoIterator,\n    F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,
ð¬This is a nightly-only experimental API. (iter_order_by)Lexicographically compares the elements of this Iterator with those\nof another with respect to the specified comparison function. Read more
1.5.0 Â· sourceÂ§fn partial_cmp<I>(self, other: I) -> Option<Ordering>where\n    I: IntoIterator,\n    Self::Item: PartialOrd<<I as IntoIterator>::Item>,\n    Self: Sized,
Lexicographically compares the PartialOrd elements of\nthis Iterator with those of another. The comparison works like short-circuit\nevaluation, returning a result without comparing the remaining elements.\nAs soon as an order can be determined, the evaluation stops and a result is returned. Read more
sourceÂ§fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>where\n    Self: Sized,\n    I: IntoIterator,\n    F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,
ð¬This is a nightly-only experimental API. (iter_order_by)Lexicographically compares the elements of this Iterator with those\nof another with respect to the specified comparison function. Read more
1.5.0 Â· sourceÂ§fn eq<I>(self, other: I) -> boolwhere\n    I: IntoIterator,\n    Self::Item: PartialEq<<I as IntoIterator>::Item>,\n    Self: Sized,
Determines if the elements of this Iterator are equal to those of\nanother. Read more
sourceÂ§fn eq_by<I, F>(self, other: I, eq: F) -> boolwhere\n    Self: Sized,\n    I: IntoIterator,\n    F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,
ð¬This is a nightly-only experimental API. (iter_order_by)Determines if the elements of this Iterator are equal to those of\nanother with respect to the specified equality function. Read more
1.5.0 Â· sourceÂ§fn ne<I>(self, other: I) -> boolwhere\n    I: IntoIterator,\n    Self::Item: PartialEq<<I as IntoIterator>::Item>,\n    Self: Sized,
Determines if the elements of this Iterator are not equal to those of\nanother. Read more
1.5.0 Â· sourceÂ§fn lt<I>(self, other: I) -> boolwhere\n    I: IntoIterator,\n    Self::Item: PartialOrd<<I as IntoIterator>::Item>,\n    Self: Sized,
Determines if the elements of this Iterator are lexicographically\nless than those of another. Read more
1.5.0 Â· sourceÂ§fn le<I>(self, other: I) -> boolwhere\n    I: IntoIterator,\n    Self::Item: PartialOrd<<I as IntoIterator>::Item>,\n    Self: Sized,
Determines if the elements of this Iterator are lexicographically\nless or equal to those of another. Read more
1.5.0 Â· sourceÂ§fn gt<I>(self, other: I) -> boolwhere\n    I: IntoIterator,\n    Self::Item: PartialOrd<<I as IntoIterator>::Item>,\n    Self: Sized,
Determines if the elements of this Iterator are lexicographically\ngreater than those of another. Read more
1.5.0 Â· sourceÂ§fn ge<I>(self, other: I) -> boolwhere\n    I: IntoIterator,\n    Self::Item: PartialOrd<<I as IntoIterator>::Item>,\n    Self: Sized,
Determines if the elements of this Iterator are lexicographically\ngreater than or equal to those of another. Read more
sourceÂ§fn is_sorted_by<F>(self, compare: F) -> boolwhere\n    Self: Sized,\n    F: FnMut(&Self::Item, &Self::Item) -> bool,
ð¬This is a nightly-only experimental API. (is_sorted)Checks if the elements of this iterator are sorted using the given comparator function. Read more
sourceÂ§fn is_sorted_by_key<F, K>(self, f: F) -> boolwhere\n    Self: Sized,\n    F: FnMut(Self::Item) -> K,\n    K: PartialOrd,
ð¬This is a nightly-only experimental API. (is_sorted)Checks if the elements of this iterator are sorted using the given key extraction\nfunction. Read more
","Iterator","bdk_esplora::blocking_ext::Error"],["Â§impl<Sp> LocalSpawn for Box<Sp>where\n    Sp: LocalSpawn + ?Sized,
Â§fn spawn_local_obj(\n    &self,\n    future: LocalFutureObj<'static, ()>\n) -> Result<(), SpawnError>
Spawns a future that will be run to completion. Read more
Â§fn status_local(&self) -> Result<(), SpawnError>
Determines whether the executor is able to spawn new tasks. Read more
","LocalSpawn","bdk_esplora::blocking_ext::Error"],["1.0.0 Â· sourceÂ§impl<T, A> Ord for Box<T, A>where\n    T: Ord + ?Sized,\n    A: Allocator,
sourceÂ§fn cmp(&self, other: &Box<T, A>) -> Ordering
This method returns an Ordering between self and other. Read more
1.21.0 Â· sourceÂ§fn max(self, other: Self) -> Selfwhere\n    Self: Sized,
Compares and returns the maximum of two values. Read more
1.21.0 Â· sourceÂ§fn min(self, other: Self) -> Selfwhere\n    Self: Sized,
Compares and returns the minimum of two values. Read more
1.50.0 Â· sourceÂ§fn clamp(self, min: Self, max: Self) -> Selfwhere\n    Self: Sized + PartialOrd,
Restrict a value to a certain interval. Read more
","Ord","bdk_esplora::blocking_ext::Error"],["1.0.0 Â· sourceÂ§impl<T, A> PartialEq for Box<T, A>where\n    T: PartialEq + ?Sized,\n    A: Allocator,
sourceÂ§fn eq(&self, other: &Box<T, A>) -> bool
This method tests for self and other values to be equal, and is used\nby ==.
sourceÂ§fn ne(&self, other: &Box<T, A>) -> bool
This method tests for !=. The default implementation is almost always\nsufficient, and should not be overridden without very good reason.
","PartialEq","bdk_esplora::blocking_ext::Error"],["1.0.0 Â· sourceÂ§impl<T, A> PartialOrd for Box<T, A>where\n    T: PartialOrd + ?Sized,\n    A: Allocator,
sourceÂ§fn partial_cmp(&self, other: &Box<T, A>) -> Option<Ordering>
This method returns an ordering between self and other values if one exists. Read more
sourceÂ§fn lt(&self, other: &Box<T, A>) -> bool
This method tests less than (for self and other) and is used by the < operator. Read more
sourceÂ§fn le(&self, other: &Box<T, A>) -> bool
This method tests less than or equal to (for self and other) and is used by the <=\noperator. Read more
sourceÂ§fn ge(&self, other: &Box<T, A>) -> bool
This method tests greater than or equal to (for self and other) and is used by the >=\noperator. Read more
sourceÂ§fn gt(&self, other: &Box<T, A>) -> bool
This method tests greater than (for self and other) and is used by the > operator. Read more
","PartialOrd","bdk_esplora::blocking_ext::Error"],["1.0.0 Â· sourceÂ§impl<T, A> Pointer for Box<T, A>where\n    A: Allocator,\n    T: ?Sized,
sourceÂ§fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>
Formats the value using the given formatter. Read more
","Pointer","bdk_esplora::blocking_ext::Error"],["1.0.0 Â· sourceÂ§impl<R> Read for Box<R>where\n    R: Read + ?Sized,
sourceÂ§fn read(&mut self, buf: &mut [u8]) -> Result<usize, Error>
Pull some bytes from this source into the specified buffer, returning\nhow many bytes were read. Read more
sourceÂ§fn read_buf(&mut self, cursor: BorrowedCursor<'_>) -> Result<(), Error>
ð¬This is a nightly-only experimental API. (read_buf)Pull some bytes from this source into the specified buffer. Read more
sourceÂ§fn read_vectored(&mut self, bufs: &mut [IoSliceMut<'_>]) -> Result<usize, Error>
Like read, except that it reads into a slice of buffers. Read more
sourceÂ§fn is_read_vectored(&self) -> bool
ð¬This is a nightly-only experimental API. (can_vector)Determines if this Reader has an efficient read_vectored\nimplementation. Read more
sourceÂ§fn read_to_end(&mut self, buf: &mut Vec<u8>) -> Result<usize, Error>
Read all bytes until EOF in this source, placing them into buf. Read more
sourceÂ§fn read_to_string(&mut self, buf: &mut String) -> Result<usize, Error>
Read all bytes until EOF in this source, appending them to buf. Read more
sourceÂ§fn read_exact(&mut self, buf: &mut [u8]) -> Result<(), Error>
Read the exact number of bytes required to fill buf. Read more
sourceÂ§fn read_buf_exact(&mut self, cursor: BorrowedCursor<'_>) -> Result<(), Error>
ð¬This is a nightly-only experimental API. (read_buf)Read the exact number of bytes required to fill cursor. Read more
1.0.0 Â· sourceÂ§fn by_ref(&mut self) -> &mut Selfwhere\n    Self: Sized,
Creates a âby referenceâ adaptor for this instance of Read. Read more
1.0.0 Â· sourceÂ§fn bytes(self) -> Bytes<Self>where\n    Self: Sized,
Transforms this Read instance to an Iterator over its bytes. Read more
1.0.0 Â· sourceÂ§fn chain<R>(self, next: R) -> Chain<Self, R>where\n    R: Read,\n    Self: Sized,
Creates an adapter which will chain this stream with another. Read more
1.0.0 Â· sourceÂ§fn take(self, limit: u64) -> Take<Self>where\n    Self: Sized,
Creates an adapter which will read at most limit bytes from it. Read more
","Read","bdk_esplora::blocking_ext::Error"],["sourceÂ§impl<R> RngCore for Box<R>where\n    R: RngCore + ?Sized,
sourceÂ§fn next_u32(&mut self) -> u32
Return the next random u32. Read more
sourceÂ§fn next_u64(&mut self) -> u64
Return the next random u64. Read more
sourceÂ§fn fill_bytes(&mut self, dest: &mut [u8])
Fill dest with random data. Read more
sourceÂ§fn try_fill_bytes(&mut self, dest: &mut [u8]) -> Result<(), Error>
Fill dest entirely with random data. Read more
","RngCore","bdk_esplora::blocking_ext::Error"],["1.0.0 Â· sourceÂ§impl<S> Seek for Box<S>where\n    S: Seek + ?Sized,
sourceÂ§fn seek(&mut self, pos: SeekFrom) -> Result<u64, Error>
Seek to an offset, in bytes, in a stream. Read more
sourceÂ§fn stream_position(&mut self) -> Result<u64, Error>
Returns the current seek position from the start of the stream. Read more
1.55.0 Â· sourceÂ§fn rewind(&mut self) -> Result<(), Error>
Rewind to the beginning of a stream. Read more
sourceÂ§fn stream_len(&mut self) -> Result<u64, Error>
ð¬This is a nightly-only experimental API. (seek_stream_len)Returns the length of this stream (in bytes). Read more
sourceÂ§fn seek_relative(&mut self, offset: i64) -> Result<(), Error>
ð¬This is a nightly-only experimental API. (seek_seek_relative)Seeks relative to the current position. Read more
","Seek","bdk_esplora::blocking_ext::Error"],["sourceÂ§impl<T> Serialize for Box<T>where\n    T: Serialize + ?Sized,
sourceÂ§fn serialize<S>(\n    &self,\n    serializer: S\n) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where\n    S: Serializer,
Serialize this value into the given Serde serializer. Read more
","Serialize","bdk_esplora::blocking_ext::Error"],["Â§impl<S, Request> Service<Request> for Box<S>where\n    S: Service<Request> + ?Sized,
Â§type Response = <S as Service<Request>>::Response
Responses given by the service.
Â§type Error = <S as Service<Request>>::Error
Errors produced by the service.
Â§type Future = <S as Service<Request>>::Future
The future response value.
Â§fn poll_ready(\n    &mut self,\n    cx: &mut Context<'_>\n) -> Poll<Result<(), <S as Service<Request>>::Error>>
Returns Poll::Ready(Ok(())) when the service is able to process requests. Read more
Â§fn call(&mut self, request: Request) -> <S as Service<Request>>::Future
Process the request and return the response asynchronously. Read more
","Service","bdk_esplora::blocking_ext::Error"],["Â§impl<S, Item> Sink<Item> for Box<S>where\n    S: Sink<Item> + Unpin + ?Sized,
Â§type Error = <S as Sink<Item>>::Error
The type of value produced by the sink when an error occurs.
Â§fn poll_ready(\n    self: Pin<&mut Box<S>>,\n    cx: &mut Context<'_>\n) -> Poll<Result<(), <Box<S> as Sink<Item>>::Error>>
Attempts to prepare the Sink to receive a value. Read more
Â§fn start_send(\n    self: Pin<&mut Box<S>>,\n    item: Item\n) -> Result<(), <Box<S> as Sink<Item>>::Error>
Begin the process of sending a value to the sink.\nEach call to this function must be preceded by a successful call to\npoll_ready which returned Poll::Ready(Ok(())). Read more
Â§fn poll_flush(\n    self: Pin<&mut Box<S>>,\n    cx: &mut Context<'_>\n) -> Poll<Result<(), <Box<S> as Sink<Item>>::Error>>
Flush any remaining output from this sink. Read more
Â§fn poll_close(\n    self: Pin<&mut Box<S>>,\n    cx: &mut Context<'_>\n) -> Poll<Result<(), <Box<S> as Sink<Item>>::Error>>
Flush any remaining output and close this sink, if necessary. Read more
","Sink","bdk_esplora::blocking_ext::Error"],["Â§impl<T> Source for Box<T>where\n    T: Source + ?Sized,
Â§fn register(\n    &mut self,\n    registry: &Registry,\n    token: Token,\n    interests: Interest\n) -> Result<(), Error>
Register self with the given Registry instance. Read more
Â§fn reregister(\n    &mut self,\n    registry: &Registry,\n    token: Token,\n    interests: Interest\n) -> Result<(), Error>
Re-register self with the given Registry instance. Read more
Â§fn deregister(&mut self, registry: &Registry) -> Result<(), Error>
Deregister self from the given Registry instance. Read more
","Source","bdk_esplora::blocking_ext::Error"],["Â§impl<Sp> Spawn for Box<Sp>where\n    Sp: Spawn + ?Sized,
Â§fn spawn_obj(&self, future: FutureObj<'static, ()>) -> Result<(), SpawnError>
Spawns a future that will be run to completion. Read more
Â§fn status(&self) -> Result<(), SpawnError>
Determines whether the executor is able to spawn new tasks. Read more
","Spawn","bdk_esplora::blocking_ext::Error"],["Â§impl<S> Stream for Box<S>where\n    S: Stream + Unpin + ?Sized,
Â§type Item = <S as Stream>::Item
Values yielded by the stream.
Â§fn poll_next(\n    self: Pin<&mut Box<S>>,\n    cx: &mut Context<'_>\n) -> Poll<Option<<Box<S> as Stream>::Item>>
Attempt to pull out the next value of this stream, registering the\ncurrent task for wakeup if the value is not yet available, and returning\nNone if the stream is exhausted. Read more
Â§fn size_hint(&self) -> (usize, Option<usize>)
Returns the bounds on the remaining length of the stream. Read more
","Stream","bdk_esplora::blocking_ext::Error"],["Â§impl<S> Subscriber for Box<S>where\n    S: Subscriber + ?Sized,
Â§fn register_callsite(&self, metadata: &'static Metadata<'static>) -> Interest
Registers a new callsite with this subscriber, returning whether or not\nthe subscriber is interested in being notified about the callsite. Read more
Â§fn enabled(&self, metadata: &Metadata<'_>) -> bool
Returns true if a span or event with the specified metadata would be\nrecorded. Read more
Â§fn max_level_hint(&self) -> Option<LevelFilter>
Returns the highest verbosity level that this Subscriber will\nenable, or None, if the subscriber does not implement level-based\nfiltering or chooses not to implement this method. Read more
Â§fn new_span(&self, span: &Attributes<'_>) -> Id
Visit the construction of a new span, returning a new span ID for the\nspan being constructed. Read more
Â§fn record(&self, span: &Id, values: &Record<'_>)
Record a set of values on a span. Read more
Â§fn record_follows_from(&self, span: &Id, follows: &Id)
Adds an indication that span follows from the span with the id\nfollows. Read more
Â§fn event_enabled(&self, event: &Event<'_>) -> bool
Determine if an [Event] should be recorded. Read more
Â§fn event(&self, event: &Event<'_>)
Records that an Event has occurred. Read more
Â§fn enter(&self, span: &Id)
Records that a span has been entered. Read more
Â§fn exit(&self, span: &Id)
Records that a span has been exited. Read more
Â§fn clone_span(&self, id: &Id) -> Id
Notifies the subscriber that a span ID has been cloned. Read more
Â§fn try_close(&self, id: Id) -> bool
Notifies the subscriber that a span ID has been dropped, and returns\ntrue if there are now 0 IDs that refer to that span. Read more
Â§fn drop_span(&self, id: Id)
ðDeprecated since 0.1.2: use Subscriber::try_close insteadThis method is deprecated. Read more
Â§fn current_span(&self) -> Current
Returns a type representing this subscriberâs view of the current span. Read more
Â§unsafe fn downcast_raw(&self, id: TypeId) -> Option<*const ()>
If self is the same type as the provided TypeId, returns an untyped\n*const pointer to that type. Otherwise, returns None. Read more
Â§fn on_register_dispatch(&self, subscriber: &Dispatch)
Invoked when this subscriber becomes a [Dispatch]. Read more
","Subscriber","bdk_esplora::blocking_ext::Error"],["Â§impl<T> ToSql for Box<T>where\n    T: ToSql + ?Sized,
Â§fn to_sql(&self) -> Result<ToSqlOutput<'_>, Error>
Converts Rust value to SQLite value
","ToSql","bdk_esplora::blocking_ext::Error"],["Â§impl<'a, T, F> UnsafeFutureObj<'a, T> for Box<F>where\n    F: Future<Output = T> + 'a,
Â§fn into_raw(self) -> *mut dyn Future<Output = T> + 'a
Convert an owned instance into a (conceptually owned) fat pointer. Read more
Â§unsafe fn drop(ptr: *mut dyn Future<Output = T> + 'a)
Drops the future represented by the given fat pointer. Read more
","UnsafeFutureObj<'a, T>","bdk_esplora::blocking_ext::Error"],["Â§impl<T> Value for Box<T>where\n    T: Value + ?Sized,
Â§fn record(&self, key: &Field, visitor: &mut dyn Visit)
Visits this value with the given Visitor.
","Value","bdk_esplora::blocking_ext::Error"],["1.0.0 Â· sourceÂ§impl<W> Write for Box<W>where\n    W: Write + ?Sized,
sourceÂ§fn write(&mut self, buf: &[u8]) -> Result<usize, Error>
Write a buffer into this writer, returning how many bytes were written. Read more
sourceÂ§fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> Result<usize, Error>
Like write, except that it writes from a slice of buffers. Read more
sourceÂ§fn is_write_vectored(&self) -> bool
ð¬This is a nightly-only experimental API. (can_vector)Determines if this Writer has an efficient write_vectored\nimplementation. Read more
sourceÂ§fn flush(&mut self) -> Result<(), Error>
Flush this output stream, ensuring that all intermediately buffered\ncontents reach their destination. Read more
sourceÂ§fn write_all(&mut self, buf: &[u8]) -> Result<(), Error>
Attempts to write an entire buffer into this writer. Read more
sourceÂ§fn write_fmt(&mut self, fmt: Arguments<'_>) -> Result<(), Error>
Writes a formatted string into this writer, returning any error\nencountered. Read more
sourceÂ§fn write_all_vectored(&mut self, bufs: &mut [IoSlice<'_>]) -> Result<(), Error>
ð¬This is a nightly-only experimental API. (write_all_vectored)Attempts to write multiple buffers into this writer. Read more
1.0.0 Â· sourceÂ§fn by_ref(&mut self) -> &mut Selfwhere\n    Self: Sized,
Creates a âby referenceâ adapter for this instance of Write. Read more
","Write","bdk_esplora::blocking_ext::Error"],["sourceÂ§impl<T, U, A> CoerceUnsized<Box<U, A>> for Box<T, A>where\n    T: Unsize<U> + ?Sized,\n    A: Allocator,\n    U: ?Sized,
","CoerceUnsized>","bdk_esplora::blocking_ext::Error"],["sourceÂ§impl<R> CryptoRng for Box<R>where\n    R: CryptoRng + ?Sized,
","CryptoRng","bdk_esplora::blocking_ext::Error"],["sourceÂ§impl<T, A> DerefPure for Box<T, A>where\n    A: Allocator,\n    T: ?Sized,
","DerefPure","bdk_esplora::blocking_ext::Error"],["sourceÂ§impl<T, U> DispatchFromDyn<Box<U>> for Box<T>where\n    T: Unsize<U> + ?Sized,\n    U: ?Sized,
","DispatchFromDyn>","bdk_esplora::blocking_ext::Error"],["1.0.0 Â· sourceÂ§impl<T, A> Eq for Box<T, A>where\n    T: Eq + ?Sized,\n    A: Allocator,
","Eq","bdk_esplora::blocking_ext::Error"],["1.26.0 Â· sourceÂ§impl<I, A> FusedIterator for Box<I, A>where\n    I: FusedIterator + ?Sized,\n    A: Allocator,
","FusedIterator","bdk_esplora::blocking_ext::Error"],["1.33.0 Â· sourceÂ§impl<T, A> Unpin for Box<T, A>where\n    A: Allocator,\n    T: ?Sized,","Unpin","bdk_esplora::blocking_ext::Error"]]
+"bdk_esplora":[["1.64.0 Â· sourceÂ§impl<T> AsFd for Box<T>where\n    T: AsFd + ?Sized,
sourceÂ§fn as_fd(&self) -> BorrowedFd<'_>
Borrows the file descriptor. Read more
","AsFd","bdk_esplora::blocking_ext::Error"],["1.5.0 Â· sourceÂ§impl<T, A> AsMut<T> for Box<T, A>where\n    A: Allocator,\n    T: ?Sized,
sourceÂ§fn as_mut(&mut self) -> &mut T
Converts this type into a mutable reference of the (usually inferred) input type.
","AsMut","bdk_esplora::blocking_ext::Error"],["1.63.0 Â· sourceÂ§impl<T> AsRawFd for Box<T>where\n    T: AsRawFd,
sourceÂ§fn as_raw_fd(&self) -> i32
Extracts the raw file descriptor. Read more
","AsRawFd","bdk_esplora::blocking_ext::Error"],["1.5.0 Â· sourceÂ§impl<T, A> AsRef<T> for Box<T, A>where\n    A: Allocator,\n    T: ?Sized,
sourceÂ§fn as_ref(&self) -> &T
Converts this type into a shared reference of the (usually inferred) input type.
","AsRef","bdk_esplora::blocking_ext::Error"],["Â§impl<T> AsyncBufRead for Box<T>where\n    T: AsyncBufRead + Unpin + ?Sized,
Â§fn poll_fill_buf(\n    self: Pin<&mut Box<T>>,\n    cx: &mut Context<'_>\n) -> Poll<Result<&[u8], Error>>
Attempt to return the contents of the internal buffer, filling it with more data\nfrom the inner reader if it is empty. Read more
Â§fn consume(self: Pin<&mut Box<T>>, amt: usize)
Tells this buffer that amt bytes have been consumed from the buffer,\nso they should no longer be returned in calls to poll_read. Read more
","AsyncBufRead","bdk_esplora::blocking_ext::Error"],["Â§impl<T> AsyncBufRead for Box<T>where\n    T: AsyncBufRead + Unpin + ?Sized,
Â§fn poll_fill_buf(\n    self: Pin<&mut Box<T>>,\n    cx: &mut Context<'_>\n) -> Poll<Result<&[u8], Error>>
Attempts to return the contents of the internal buffer, filling it with more data\nfrom the inner reader if it is empty. Read more
Â§fn consume(self: Pin<&mut Box<T>>, amt: usize)
Tells this buffer that amt bytes have been consumed from the buffer,\nso they should no longer be returned in calls to poll_read. Read more
","AsyncBufRead","bdk_esplora::blocking_ext::Error"],["sourceÂ§impl<Args, F, A> AsyncFn<Args> for Box<F, A>where\n    Args: Tuple,\n    F: AsyncFn<Args> + ?Sized,\n    A: Allocator,
sourceÂ§extern "rust-call" fn async_call(\n    &self,\n    args: Args\n) -> <Box<F, A> as AsyncFnMut<Args>>::CallRefFuture<'_>
ð¬This is a nightly-only experimental API. (async_fn_traits)Call the AsyncFn, returning a future which may borrow from the called closure.
","AsyncFn","bdk_esplora::blocking_ext::Error"],["sourceÂ§impl<Args, F, A> AsyncFnMut<Args> for Box<F, A>where\n    Args: Tuple,\n    F: AsyncFnMut<Args> + ?Sized,\n    A: Allocator,
Â§type CallRefFuture<'a> = <F as AsyncFnMut<Args>>::CallRefFuture<'a>\nwhere\n    Box<F, A>: 'a
ð¬This is a nightly-only experimental API. (async_fn_traits)Future returned by AsyncFnMut::async_call_mut and AsyncFn::async_call.
sourceÂ§extern "rust-call" fn async_call_mut(\n    &mut self,\n    args: Args\n) -> <Box<F, A> as AsyncFnMut<Args>>::CallRefFuture<'_>
ð¬This is a nightly-only experimental API. (async_fn_traits)Call the AsyncFnMut, returning a future which may borrow from the called closure.
","AsyncFnMut","bdk_esplora::blocking_ext::Error"],["sourceÂ§impl<Args, F, A> AsyncFnOnce<Args> for Box<F, A>where\n    Args: Tuple,\n    F: AsyncFnOnce<Args> + ?Sized,\n    A: Allocator,
Â§type Output = <F as AsyncFnOnce<Args>>::Output
ð¬This is a nightly-only experimental API. (async_fn_traits)Output type of the called closureâs future.
Â§type CallOnceFuture = <F as AsyncFnOnce<Args>>::CallOnceFuture
ð¬This is a nightly-only experimental API. (async_fn_traits)Future returned by AsyncFnOnce::async_call_once.
sourceÂ§extern "rust-call" fn async_call_once(\n    self,\n    args: Args\n) -> <Box<F, A> as AsyncFnOnce<Args>>::CallOnceFuture
ð¬This is a nightly-only experimental API. (async_fn_traits)Call the AsyncFnOnce, returning a future which may move out of the called closure.
","AsyncFnOnce","bdk_esplora::blocking_ext::Error"],["sourceÂ§impl<S> AsyncIterator for Box<S>where\n    S: AsyncIterator + Unpin + ?Sized,
Â§type Item = <S as AsyncIterator>::Item
ð¬This is a nightly-only experimental API. (async_iterator)The type of items yielded by the async iterator.
sourceÂ§fn poll_next(\n    self: Pin<&mut Box<S>>,\n    cx: &mut Context<'_>\n) -> Poll<Option<<Box<S> as AsyncIterator>::Item>>
ð¬This is a nightly-only experimental API. (async_iterator)Attempt to pull out the next value of this async iterator, registering the\ncurrent task for wakeup if the value is not yet available, and returning\nNone if the async iterator is exhausted. Read more
sourceÂ§fn size_hint(&self) -> (usize, Option<usize>)
ð¬This is a nightly-only experimental API. (async_iterator)Returns the bounds on the remaining length of the async iterator. Read more
","AsyncIterator","bdk_esplora::blocking_ext::Error"],["Â§impl<T> AsyncRead for Box<T>where\n    T: AsyncRead + Unpin + ?Sized,
Â§fn poll_read(\n    self: Pin<&mut Box<T>>,\n    cx: &mut Context<'_>,\n    buf: &mut ReadBuf<'_>\n) -> Poll<Result<(), Error>>
Attempts to read from the AsyncRead into buf. Read more
","AsyncRead","bdk_esplora::blocking_ext::Error"],["Â§impl<T> AsyncRead for Box<T>where\n    T: AsyncRead + Unpin + ?Sized,
Â§fn poll_read(\n    self: Pin<&mut Box<T>>,\n    cx: &mut Context<'_>,\n    buf: &mut [u8]\n) -> Poll<Result<usize, Error>>
Attempt to read from the AsyncRead into buf. Read more
Â§fn poll_read_vectored(\n    self: Pin<&mut Box<T>>,\n    cx: &mut Context<'_>,\n    bufs: &mut [IoSliceMut<'_>]\n) -> Poll<Result<usize, Error>>
Attempt to read from the AsyncRead into bufs using vectored\nIO operations. Read more
","AsyncRead","bdk_esplora::blocking_ext::Error"],["Â§impl<T> AsyncSeek for Box<T>where\n    T: AsyncSeek + Unpin + ?Sized,
Â§fn poll_seek(\n    self: Pin<&mut Box<T>>,\n    cx: &mut Context<'_>,\n    pos: SeekFrom\n) -> Poll<Result<u64, Error>>
Attempt to seek to an offset, in bytes, in a stream. Read more
","AsyncSeek","bdk_esplora::blocking_ext::Error"],["Â§impl<T> AsyncSeek for Box<T>where\n    T: AsyncSeek + Unpin + ?Sized,
Â§fn start_seek(self: Pin<&mut Box<T>>, pos: SeekFrom) -> Result<(), Error>
Attempts to seek to an offset, in bytes, in a stream. Read more
Â§fn poll_complete(\n    self: Pin<&mut Box<T>>,\n    cx: &mut Context<'_>\n) -> Poll<Result<u64, Error>>
Waits for a seek operation to complete. Read more
","AsyncSeek","bdk_esplora::blocking_ext::Error"],["Â§impl<T> AsyncWrite for Box<T>where\n    T: AsyncWrite + Unpin + ?Sized,
Â§fn poll_write(\n    self: Pin<&mut Box<T>>,\n    cx: &mut Context<'_>,\n    buf: &[u8]\n) -> Poll<Result<usize, Error>>
Attempt to write bytes from buf into the object. Read more
Â§fn poll_write_vectored(\n    self: Pin<&mut Box<T>>,\n    cx: &mut Context<'_>,\n    bufs: &[IoSlice<'_>]\n) -> Poll<Result<usize, Error>>
Attempt to write bytes from bufs into the object using vectored\nIO operations. Read more
Â§fn poll_flush(\n    self: Pin<&mut Box<T>>,\n    cx: &mut Context<'_>\n) -> Poll<Result<(), Error>>
Attempt to flush the object, ensuring that any buffered data reach\ntheir destination. Read more
Â§fn poll_close(\n    self: Pin<&mut Box<T>>,\n    cx: &mut Context<'_>\n) -> Poll<Result<(), Error>>
Attempt to close the object. Read more
","AsyncWrite","bdk_esplora::blocking_ext::Error"],["Â§impl<T> AsyncWrite for Box<T>where\n    T: AsyncWrite + Unpin + ?Sized,
Â§fn poll_write(\n    self: Pin<&mut Box<T>>,\n    cx: &mut Context<'_>,\n    buf: &[u8]\n) -> Poll<Result<usize, Error>>
Attempt to write bytes from buf into the object. Read more
Â§fn poll_write_vectored(\n    self: Pin<&mut Box<T>>,\n    cx: &mut Context<'_>,\n    bufs: &[IoSlice<'_>]\n) -> Poll<Result<usize, Error>>
Like poll_write, except that it writes from a slice of buffers. Read more
Â§fn is_write_vectored(&self) -> bool
Determines if this writer has an efficient poll_write_vectored\nimplementation. Read more
Â§fn poll_flush(\n    self: Pin<&mut Box<T>>,\n    cx: &mut Context<'_>\n) -> Poll<Result<(), Error>>
Attempts to flush the object, ensuring that any buffered data reach\ntheir destination. Read more
Â§fn poll_shutdown(\n    self: Pin<&mut Box<T>>,\n    cx: &mut Context<'_>\n) -> Poll<Result<(), Error>>
Initiates or attempts to shut down this writer, returning success when\nthe I/O connection has completely shut down. Read more
","AsyncWrite","bdk_esplora::blocking_ext::Error"],["sourceÂ§impl<T> Body for Box<T>where\n    T: Body + Unpin + ?Sized,
Â§type Data = <T as Body>::Data
Values yielded by the Body.
Â§type Error = <T as Body>::Error
The error type this Body might generate.
sourceÂ§fn poll_data(\n    self: Pin<&mut Box<T>>,\n    cx: &mut Context<'_>\n) -> Poll<Option<Result<<Box<T> as Body>::Data, <Box<T> as Body>::Error>>>
Attempt to pull out the next data buffer of this stream.
sourceÂ§fn poll_trailers(\n    self: Pin<&mut Box<T>>,\n    cx: &mut Context<'_>\n) -> Poll<Result<Option<HeaderMap>, <Box<T> as Body>::Error>>
Poll for an optional single HeaderMap of trailers. Read more
sourceÂ§fn is_end_stream(&self) -> bool
Returns true when the end of stream has been reached. Read more
sourceÂ§fn size_hint(&self) -> SizeHint
Returns the bounds on the remaining length of the stream. Read more
sourceÂ§fn data(&mut self) -> Data<'_, Self>where\n    Self: Sized + Unpin,
Returns future that resolves to next data chunk, if any.
sourceÂ§fn trailers(&mut self) -> Trailers<'_, Self>where\n    Self: Sized + Unpin,
Returns future that resolves to trailers, if any.
sourceÂ§fn map_data<F, B>(self, f: F) -> MapData<Self, F>where\n    Self: Sized,\n    F: FnMut(Self::Data) -> B,\n    B: Buf,
Maps this bodyâs data value to a different value.
sourceÂ§fn map_err<F, E>(self, f: F) -> MapErr<Self, F>where\n    Self: Sized,\n    F: FnMut(Self::Error) -> E,
Maps this bodyâs error value to a different value.
sourceÂ§fn collect(self) -> Collect<Self>where\n    Self: Sized,
Turn this body into Collected body which will collect all the DATA frames\nand trailers.
","Body","bdk_esplora::blocking_ext::Error"],["1.1.0 Â· sourceÂ§impl<T, A> Borrow<T> for Box<T, A>where\n    A: Allocator,\n    T: ?Sized,
sourceÂ§fn borrow(&self) -> &T
Immutably borrows from an owned value. Read more
","Borrow","bdk_esplora::blocking_ext::Error"],["1.1.0 Â· sourceÂ§impl<T, A> BorrowMut<T> for Box<T, A>where\n    A: Allocator,\n    T: ?Sized,
sourceÂ§fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value. Read more
","BorrowMut","bdk_esplora::blocking_ext::Error"],["sourceÂ§impl<T> Box<T>
1.0.0 Â· sourcepub fn new(x: T) -> Box<T>
Allocates memory on the heap and then places x into it.
\nThis doesnât actually allocate if T is zero-sized.
\nÂ§Examples
\nlet five = Box::new(5);
\n
sourcepub fn new_uninit() -> Box<MaybeUninit<T>>
ð¬This is a nightly-only experimental API. (new_uninit)
Constructs a new box with uninitialized contents.
\nÂ§Examples
\n#![feature(new_uninit)]\n\nlet mut five = Box::<u32>::new_uninit();\n\nlet five = unsafe {\n    // Deferred initialization:\n    five.as_mut_ptr().write(5);\n\n    five.assume_init()\n};\n\nassert_eq!(*five, 5)
\n
sourcepub fn new_zeroed() -> Box<MaybeUninit<T>>
ð¬This is a nightly-only experimental API. (new_uninit)
Constructs a new Box with uninitialized contents, with the memory\nbeing filled with 0 bytes.
\nSee MaybeUninit::zeroed for examples of correct and incorrect usage\nof this method.
\nÂ§Examples
\n#![feature(new_uninit)]\n\nlet zero = Box::<u32>::new_zeroed();\nlet zero = unsafe { zero.assume_init() };\n\nassert_eq!(*zero, 0)
\n
1.33.0 Â· sourcepub fn pin(x: T) -> Pin<Box<T>>
Constructs a new Pin<Box<T>>. If T does not implement Unpin, then\nx will be pinned in memory and unable to be moved.
\nConstructing and pinning of the Box can also be done in two steps: Box::pin(x)\ndoes the same as Box::into_pin(Box::new(x)). Consider using\ninto_pin if you already have a Box<T>, or if you want to\nconstruct a (pinned) Box in a different way than with Box::new.
\n
sourcepub fn try_new(x: T) -> Result<Box<T>, AllocError>
ð¬This is a nightly-only experimental API. (allocator_api)
Allocates memory on the heap then places x into it,\nreturning an error if the allocation fails
\nThis doesnât actually allocate if T is zero-sized.
\nÂ§Examples
\n#![feature(allocator_api)]\n\nlet five = Box::try_new(5)?;
\n
sourcepub fn try_new_uninit() -> Result<Box<MaybeUninit<T>>, AllocError>
ð¬This is a nightly-only experimental API. (allocator_api)
Constructs a new box with uninitialized contents on the heap,\nreturning an error if the allocation fails
\nÂ§Examples
\n#![feature(allocator_api, new_uninit)]\n\nlet mut five = Box::<u32>::try_new_uninit()?;\n\nlet five = unsafe {\n    // Deferred initialization:\n    five.as_mut_ptr().write(5);\n\n    five.assume_init()\n};\n\nassert_eq!(*five, 5);
\n
sourcepub fn try_new_zeroed() -> Result<Box<MaybeUninit<T>>, AllocError>
ð¬This is a nightly-only experimental API. (allocator_api)
Constructs a new Box with uninitialized contents, with the memory\nbeing filled with 0 bytes on the heap
\nSee MaybeUninit::zeroed for examples of correct and incorrect usage\nof this method.
\nÂ§Examples
\n#![feature(allocator_api, new_uninit)]\n\nlet zero = Box::<u32>::try_new_zeroed()?;\nlet zero = unsafe { zero.assume_init() };\n\nassert_eq!(*zero, 0);
\n
",0,"bdk_esplora::blocking_ext::Error"],["sourceÂ§impl<T> Box<T>where\n    T: ?Sized,
1.4.0 Â· sourcepub unsafe fn from_raw(raw: *mut T) -> Box<T>
Constructs a box from a raw pointer.
\nAfter calling this function, the raw pointer is owned by the\nresulting Box. Specifically, the Box destructor will call\nthe destructor of T and free the allocated memory. For this\nto be safe, the memory must have been allocated in accordance\nwith the memory layout used by Box .
\nÂ§Safety
\nThis function is unsafe because improper use may lead to\nmemory problems. For example, a double-free may occur if the\nfunction is called twice on the same raw pointer.
\nThe safety conditions are described in the memory layout section.
\nÂ§Examples
\nRecreate a Box which was previously converted to a raw pointer\nusing Box::into_raw:
\n\nlet x = Box::new(5);\nlet ptr = Box::into_raw(x);\nlet x = unsafe { Box::from_raw(ptr) };
\nManually create a Box from scratch by using the global allocator:
\n\nuse std::alloc::{alloc, Layout};\n\nunsafe {\n    let ptr = alloc(Layout::new::<i32>()) as *mut i32;\n    // In general .write is required to avoid attempting to destruct\n    // the (uninitialized) previous contents of `ptr`, though for this\n    // simple example `*ptr = 5` would have worked as well.\n    ptr.write(5);\n    let x = Box::from_raw(ptr);\n}
\n
",0,"bdk_esplora::blocking_ext::Error"],["sourceÂ§impl<T, A> Box<T, A>where\n    A: Allocator,
sourcepub fn new_in(x: T, alloc: A) -> Box<T, A>where\n    A: Allocator,
ð¬This is a nightly-only experimental API. (allocator_api)
Allocates memory in the given allocator then places x into it.
\nThis doesnât actually allocate if T is zero-sized.
\nÂ§Examples
\n#![feature(allocator_api)]\n\nuse std::alloc::System;\n\nlet five = Box::new_in(5, System);
\n
sourcepub fn try_new_in(x: T, alloc: A) -> Result<Box<T, A>, AllocError>where\n    A: Allocator,
ð¬This is a nightly-only experimental API. (allocator_api)
Allocates memory in the given allocator then places x into it,\nreturning an error if the allocation fails
\nThis doesnât actually allocate if T is zero-sized.
\nÂ§Examples
\n#![feature(allocator_api)]\n\nuse std::alloc::System;\n\nlet five = Box::try_new_in(5, System)?;
\n
sourcepub fn new_uninit_in(alloc: A) -> Box<MaybeUninit<T>, A>where\n    A: Allocator,
ð¬This is a nightly-only experimental API. (allocator_api)
Constructs a new box with uninitialized contents in the provided allocator.
\nÂ§Examples
\n#![feature(allocator_api, new_uninit)]\n\nuse std::alloc::System;\n\nlet mut five = Box::<u32, _>::new_uninit_in(System);\n\nlet five = unsafe {\n    // Deferred initialization:\n    five.as_mut_ptr().write(5);\n\n    five.assume_init()\n};\n\nassert_eq!(*five, 5)
\n
sourcepub fn try_new_uninit_in(alloc: A) -> Result<Box<MaybeUninit<T>, A>, AllocError>where\n    A: Allocator,
ð¬This is a nightly-only experimental API. (allocator_api)
Constructs a new box with uninitialized contents in the provided allocator,\nreturning an error if the allocation fails
\nÂ§Examples
\n#![feature(allocator_api, new_uninit)]\n\nuse std::alloc::System;\n\nlet mut five = Box::<u32, _>::try_new_uninit_in(System)?;\n\nlet five = unsafe {\n    // Deferred initialization:\n    five.as_mut_ptr().write(5);\n\n    five.assume_init()\n};\n\nassert_eq!(*five, 5);
\n
sourcepub fn new_zeroed_in(alloc: A) -> Box<MaybeUninit<T>, A>where\n    A: Allocator,
ð¬This is a nightly-only experimental API. (allocator_api)
Constructs a new Box with uninitialized contents, with the memory\nbeing filled with 0 bytes in the provided allocator.
\nSee MaybeUninit::zeroed for examples of correct and incorrect usage\nof this method.
\nÂ§Examples
\n#![feature(allocator_api, new_uninit)]\n\nuse std::alloc::System;\n\nlet zero = Box::<u32, _>::new_zeroed_in(System);\nlet zero = unsafe { zero.assume_init() };\n\nassert_eq!(*zero, 0)
\n
sourcepub fn try_new_zeroed_in(alloc: A) -> Result<Box<MaybeUninit<T>, A>, AllocError>where\n    A: Allocator,
ð¬This is a nightly-only experimental API. (allocator_api)
Constructs a new Box with uninitialized contents, with the memory\nbeing filled with 0 bytes in the provided allocator,\nreturning an error if the allocation fails,
\nSee MaybeUninit::zeroed for examples of correct and incorrect usage\nof this method.
\nÂ§Examples
\n#![feature(allocator_api, new_uninit)]\n\nuse std::alloc::System;\n\nlet zero = Box::<u32, _>::try_new_zeroed_in(System)?;\nlet zero = unsafe { zero.assume_init() };\n\nassert_eq!(*zero, 0);
\n
sourcepub fn pin_in(x: T, alloc: A) -> Pin<Box<T, A>>where\n    A: 'static + Allocator,
ð¬This is a nightly-only experimental API. (allocator_api)
Constructs a new Pin<Box<T, A>>. If T does not implement Unpin, then\nx will be pinned in memory and unable to be moved.
\nConstructing and pinning of the Box can also be done in two steps: Box::pin_in(x, alloc)\ndoes the same as Box::into_pin(Box::new_in(x, alloc)). Consider using\ninto_pin if you already have a Box<T, A>, or if you want to\nconstruct a (pinned) Box in a different way than with Box::new_in.
\n
sourcepub fn into_boxed_slice(boxed: Box<T, A>) -> Box<[T], A>
ð¬This is a nightly-only experimental API. (box_into_boxed_slice)
Converts a Box<T> into a Box<[T]>
\nThis conversion does not allocate on the heap and happens in place.
\n
sourcepub fn into_inner(boxed: Box<T, A>) -> T
ð¬This is a nightly-only experimental API. (box_into_inner)
Consumes the Box, returning the wrapped value.
\nÂ§Examples
\n#![feature(box_into_inner)]\n\nlet c = Box::new(5);\n\nassert_eq!(Box::into_inner(c), 5);
\n
",0,"bdk_esplora::blocking_ext::Error"],["sourceÂ§impl<T, A> Box<T, A>where\n    A: Allocator,\n    T: ?Sized,
const: unstable Â· sourcepub unsafe fn from_raw_in(raw: *mut T, alloc: A) -> Box<T, A>
ð¬This is a nightly-only experimental API. (allocator_api)
Constructs a box from a raw pointer in the given allocator.
\nAfter calling this function, the raw pointer is owned by the\nresulting Box. Specifically, the Box destructor will call\nthe destructor of T and free the allocated memory. For this\nto be safe, the memory must have been allocated in accordance\nwith the memory layout used by Box .
\nÂ§Safety
\nThis function is unsafe because improper use may lead to\nmemory problems. For example, a double-free may occur if the\nfunction is called twice on the same raw pointer.
\nÂ§Examples
\nRecreate a Box which was previously converted to a raw pointer\nusing Box::into_raw_with_allocator:
\n\n#![feature(allocator_api)]\n\nuse std::alloc::System;\n\nlet x = Box::new_in(5, System);\nlet (ptr, alloc) = Box::into_raw_with_allocator(x);\nlet x = unsafe { Box::from_raw_in(ptr, alloc) };
\nManually create a Box from scratch by using the system allocator:
\n\n#![feature(allocator_api, slice_ptr_get)]\n\nuse std::alloc::{Allocator, Layout, System};\n\nunsafe {\n    let ptr = System.allocate(Layout::new::<i32>())?.as_mut_ptr() as *mut i32;\n    // In general .write is required to avoid attempting to destruct\n    // the (uninitialized) previous contents of `ptr`, though for this\n    // simple example `*ptr = 5` would have worked as well.\n    ptr.write(5);\n    let x = Box::from_raw_in(ptr, System);\n}
\n
1.4.0 Â· sourcepub fn into_raw(b: Box<T, A>) -> *mut T
Consumes the Box, returning a wrapped raw pointer.
\nThe pointer will be properly aligned and non-null.
\nAfter calling this function, the caller is responsible for the\nmemory previously managed by the Box. In particular, the\ncaller should properly destroy T and release the memory, taking\ninto account the memory layout used by Box. The easiest way to\ndo this is to convert the raw pointer back into a Box with the\nBox::from_raw function, allowing the Box destructor to perform\nthe cleanup.
\nNote: this is an associated function, which means that you have\nto call it as Box::into_raw(b) instead of b.into_raw(). This\nis so that there is no conflict with a method on the inner type.
\nÂ§Examples
\nConverting the raw pointer back into a Box with Box::from_raw\nfor automatic cleanup:
\n\nlet x = Box::new(String::from(\"Hello\"));\nlet ptr = Box::into_raw(x);\nlet x = unsafe { Box::from_raw(ptr) };
\nManual cleanup by explicitly running the destructor and deallocating\nthe memory:
\n\nuse std::alloc::{dealloc, Layout};\nuse std::ptr;\n\nlet x = Box::new(String::from(\"Hello\"));\nlet ptr = Box::into_raw(x);\nunsafe {\n    ptr::drop_in_place(ptr);\n    dealloc(ptr as *mut u8, Layout::new::<String>());\n}
\nNote: This is equivalent to the following:
\n\nlet x = Box::new(String::from(\"Hello\"));\nlet ptr = Box::into_raw(x);\nunsafe {\n    drop(Box::from_raw(ptr));\n}
\n
sourcepub fn into_raw_with_allocator(b: Box<T, A>) -> (*mut T, A)
ð¬This is a nightly-only experimental API. (allocator_api)
Consumes the Box, returning a wrapped raw pointer and the allocator.
\nThe pointer will be properly aligned and non-null.
\nAfter calling this function, the caller is responsible for the\nmemory previously managed by the Box. In particular, the\ncaller should properly destroy T and release the memory, taking\ninto account the memory layout used by Box. The easiest way to\ndo this is to convert the raw pointer back into a Box with the\nBox::from_raw_in function, allowing the Box destructor to perform\nthe cleanup.
\nNote: this is an associated function, which means that you have\nto call it as Box::into_raw_with_allocator(b) instead of b.into_raw_with_allocator(). This\nis so that there is no conflict with a method on the inner type.
\nÂ§Examples
\nConverting the raw pointer back into a Box with Box::from_raw_in\nfor automatic cleanup:
\n\n#![feature(allocator_api)]\n\nuse std::alloc::System;\n\nlet x = Box::new_in(String::from(\"Hello\"), System);\nlet (ptr, alloc) = Box::into_raw_with_allocator(x);\nlet x = unsafe { Box::from_raw_in(ptr, alloc) };
\nManual cleanup by explicitly running the destructor and deallocating\nthe memory:
\n\n#![feature(allocator_api)]\n\nuse std::alloc::{Allocator, Layout, System};\nuse std::ptr::{self, NonNull};\n\nlet x = Box::new_in(String::from(\"Hello\"), System);\nlet (ptr, alloc) = Box::into_raw_with_allocator(x);\nunsafe {\n    ptr::drop_in_place(ptr);\n    let non_null = NonNull::new_unchecked(ptr);\n    alloc.deallocate(non_null.cast(), Layout::new::<String>());\n}
\n
const: unstable Â· sourcepub fn allocator(b: &Box<T, A>) -> &A
ð¬This is a nightly-only experimental API. (allocator_api)
Returns a reference to the underlying allocator.
\nNote: this is an associated function, which means that you have\nto call it as Box::allocator(&b) instead of b.allocator(). This\nis so that there is no conflict with a method on the inner type.
\n
1.26.0 Â· sourcepub fn leak<'a>(b: Box<T, A>) -> &'a mut Twhere\n    A: 'a,
Consumes and leaks the Box, returning a mutable reference,\n&'a mut T. Note that the type T must outlive the chosen lifetime\n'a. If the type has only static references, or none at all, then this\nmay be chosen to be 'static.
\nThis function is mainly useful for data that lives for the remainder of\nthe programâs life. Dropping the returned reference will cause a memory\nleak. If this is not acceptable, the reference should first be wrapped\nwith the Box::from_raw function producing a Box. This Box can\nthen be dropped which will properly destroy T and release the\nallocated memory.
\nNote: this is an associated function, which means that you have\nto call it as Box::leak(b) instead of b.leak(). This\nis so that there is no conflict with a method on the inner type.
\nÂ§Examples
\nSimple usage:
\n\nlet x = Box::new(41);\nlet static_ref: &'static mut usize = Box::leak(x);\n*static_ref += 1;\nassert_eq!(*static_ref, 42);
\nUnsized data:
\n\nlet x = vec![1, 2, 3].into_boxed_slice();\nlet static_ref = Box::leak(x);\nstatic_ref[0] = 4;\nassert_eq!(*static_ref, [4, 2, 3]);
\n
1.63.0 (const: unstable) Â· sourcepub fn into_pin(boxed: Box<T, A>) -> Pin<Box<T, A>>where\n    A: 'static,
Converts a Box<T> into a Pin<Box<T>>. If T does not implement Unpin, then\n*boxed will be pinned in memory and unable to be moved.
\nThis conversion does not allocate on the heap and happens in place.
\nThis is also available via From.
\nConstructing and pinning a Box with Box::into_pin(Box::new(x))\ncan also be written more concisely using Box::pin(x).\nThis into_pin method is useful if you already have a Box<T>, or you are\nconstructing a (pinned) Box in a different way than with Box::new.
\nÂ§Notes
\nItâs not recommended that crates add an impl like From<Box<T>> for Pin<T>,\nas itâll introduce an ambiguity when calling Pin::from.\nA demonstration of such a poor impl is shown below.
\n\nâstruct Foo; // A type defined in this crate.\nimpl From<Box<()>> for Pin<Foo> {\n    fn from(_: Box<()>) -> Pin<Foo> {\n        Pin::new(Foo)\n    }\n}\n\nlet foo = Box::new(());\nlet bar = Pin::from(foo);
\n
",0,"bdk_esplora::blocking_ext::Error"],["Â§impl<T> Buf for Box<T>where\n    T: Buf + ?Sized,
Â§fn remaining(&self) -> usize
Returns the number of bytes between the current position and the end of\nthe buffer. Read more
Â§fn chunk(&self) -> &[u8] â
Returns a slice starting at the current position and of length between 0\nand Buf::remaining(). Note that this can return shorter slice (this allows\nnon-continuous internal representation). Read more
Â§fn chunks_vectored<'b>(&'b self, dst: &mut [IoSlice<'b>]) -> usize
Fills dst with potentially multiple slices starting at selfâs\ncurrent position. Read more
Â§fn advance(&mut self, cnt: usize)
Advance the internal cursor of the Buf Read more
Â§fn has_remaining(&self) -> bool
Returns true if there are any more bytes to consume Read more
Â§fn copy_to_slice(&mut self, dst: &mut [u8])
Copies bytes from self into dst. Read more
Â§fn get_u8(&mut self) -> u8
Gets an unsigned 8 bit integer from self. Read more
Â§fn get_i8(&mut self) -> i8
Gets a signed 8 bit integer from self. Read more
Â§fn get_u16(&mut self) -> u16
Gets an unsigned 16 bit integer from self in big-endian byte order. Read more
Â§fn get_u16_le(&mut self) -> u16
Gets an unsigned 16 bit integer from self in little-endian byte order. Read more
Â§fn get_u16_ne(&mut self) -> u16
Gets an unsigned 16 bit integer from self in native-endian byte order. Read more
Â§fn get_i16(&mut self) -> i16
Gets a signed 16 bit integer from self in big-endian byte order. Read more
Â§fn get_i16_le(&mut self) -> i16
Gets a signed 16 bit integer from self in little-endian byte order. Read more
Â§fn get_i16_ne(&mut self) -> i16
Gets a signed 16 bit integer from self in native-endian byte order. Read more
Â§fn get_u32(&mut self) -> u32
Gets an unsigned 32 bit integer from self in the big-endian byte order. Read more
Â§fn get_u32_le(&mut self) -> u32
Gets an unsigned 32 bit integer from self in the little-endian byte order. Read more
Â§fn get_u32_ne(&mut self) -> u32
Gets an unsigned 32 bit integer from self in native-endian byte order. Read more
Â§fn get_i32(&mut self) -> i32
Gets a signed 32 bit integer from self in big-endian byte order. Read more
Â§fn get_i32_le(&mut self) -> i32
Gets a signed 32 bit integer from self in little-endian byte order. Read more
Â§fn get_i32_ne(&mut self) -> i32
Gets a signed 32 bit integer from self in native-endian byte order. Read more
Â§fn get_u64(&mut self) -> u64
Gets an unsigned 64 bit integer from self in big-endian byte order. Read more
Â§fn get_u64_le(&mut self) -> u64
Gets an unsigned 64 bit integer from self in little-endian byte order. Read more
Â§fn get_u64_ne(&mut self) -> u64
Gets an unsigned 64 bit integer from self in native-endian byte order. Read more
Â§fn get_i64(&mut self) -> i64
Gets a signed 64 bit integer from self in big-endian byte order. Read more
Â§fn get_i64_le(&mut self) -> i64
Gets a signed 64 bit integer from self in little-endian byte order. Read more
Â§fn get_i64_ne(&mut self) -> i64
Gets a signed 64 bit integer from self in native-endian byte order. Read more
Â§fn get_uint(&mut self, nbytes: usize) -> u64
Gets an unsigned n-byte integer from self in big-endian byte order. Read more
Â§fn get_uint_le(&mut self, nbytes: usize) -> u64
Gets an unsigned n-byte integer from self in little-endian byte order. Read more
Â§fn get_uint_ne(&mut self, nbytes: usize) -> u64
Gets an unsigned n-byte integer from self in native-endian byte order. Read more
Â§fn get_int(&mut self, nbytes: usize) -> i64
Gets a signed n-byte integer from self in big-endian byte order. Read more
Â§fn get_int_le(&mut self, nbytes: usize) -> i64
Gets a signed n-byte integer from self in little-endian byte order. Read more
Â§fn get_int_ne(&mut self, nbytes: usize) -> i64
Gets a signed n-byte integer from self in native-endian byte order. Read more
Â§fn copy_to_bytes(&mut self, len: usize) -> Bytes
Consumes len bytes inside self and returns new instance of Bytes\nwith this data. Read more
Â§fn get_u128(&mut self) -> u128
Gets an unsigned 128 bit integer from self in big-endian byte order. Read more
Â§fn get_u128_le(&mut self) -> u128
Gets an unsigned 128 bit integer from self in little-endian byte order. Read more
Â§fn get_u128_ne(&mut self) -> u128
Gets an unsigned 128 bit integer from self in native-endian byte order. Read more
Â§fn get_i128(&mut self) -> i128
Gets a signed 128 bit integer from self in big-endian byte order. Read more
Â§fn get_i128_le(&mut self) -> i128
Gets a signed 128 bit integer from self in little-endian byte order. Read more
Â§fn get_i128_ne(&mut self) -> i128
Gets a signed 128 bit integer from self in native-endian byte order. Read more
Â§fn get_f32(&mut self) -> f32
Gets an IEEE754 single-precision (4 bytes) floating point number from\nself in big-endian byte order. Read more
Â§fn get_f32_le(&mut self) -> f32
Gets an IEEE754 single-precision (4 bytes) floating point number from\nself in little-endian byte order. Read more
Â§fn get_f32_ne(&mut self) -> f32
Gets an IEEE754 single-precision (4 bytes) floating point number from\nself in native-endian byte order. Read more
Â§fn get_f64(&mut self) -> f64
Gets an IEEE754 double-precision (8 bytes) floating point number from\nself in big-endian byte order. Read more
Â§fn get_f64_le(&mut self) -> f64
Gets an IEEE754 double-precision (8 bytes) floating point number from\nself in little-endian byte order. Read more
Â§fn get_f64_ne(&mut self) -> f64
Gets an IEEE754 double-precision (8 bytes) floating point number from\nself in native-endian byte order. Read more
Â§fn take(self, limit: usize) -> Take<Self>where\n    Self: Sized,
Creates an adaptor which will read at most limit bytes from self. Read more
Â§fn chain<U>(self, next: U) -> Chain<Self, U>where\n    U: Buf,\n    Self: Sized,
Creates an adaptor which will chain this buffer with another. Read more
Â§fn reader(self) -> Reader<Self>where\n    Self: Sized,
Creates an adaptor which implements the Read trait for self. Read more
","Buf","bdk_esplora::blocking_ext::Error"],["Â§impl<T> BufMut for Box<T>where\n    T: BufMut + ?Sized,
Â§fn remaining_mut(&self) -> usize
Returns the number of bytes that can be written from the current\nposition until the end of the buffer is reached. Read more
Â§fn chunk_mut(&mut self) -> &mut UninitSlice
Returns a mutable slice starting at the current BufMut position and of\nlength between 0 and BufMut::remaining_mut(). Note that this can be shorter than the\nwhole remainder of the buffer (this allows non-continuous implementation). Read more
Â§unsafe fn advance_mut(&mut self, cnt: usize)
Advance the internal cursor of the BufMut Read more
Â§fn put_slice(&mut self, src: &[u8])
Transfer bytes into self from src and advance the cursor by the\nnumber of bytes written. Read more
Â§fn put_u8(&mut self, n: u8)
Writes an unsigned 8 bit integer to self. Read more
Â§fn put_i8(&mut self, n: i8)
Writes a signed 8 bit integer to self. Read more
Â§fn put_u16(&mut self, n: u16)
Writes an unsigned 16 bit integer to self in big-endian byte order. Read more
Â§fn put_u16_le(&mut self, n: u16)
Writes an unsigned 16 bit integer to self in little-endian byte order. Read more
Â§fn put_u16_ne(&mut self, n: u16)
Writes an unsigned 16 bit integer to self in native-endian byte order. Read more
Â§fn put_i16(&mut self, n: i16)
Writes a signed 16 bit integer to self in big-endian byte order. Read more
Â§fn put_i16_le(&mut self, n: i16)
Writes a signed 16 bit integer to self in little-endian byte order. Read more
Â§fn put_i16_ne(&mut self, n: i16)
Writes a signed 16 bit integer to self in native-endian byte order. Read more
Â§fn put_u32(&mut self, n: u32)
Writes an unsigned 32 bit integer to self in big-endian byte order. Read more
Â§fn put_u32_le(&mut self, n: u32)
Writes an unsigned 32 bit integer to self in little-endian byte order. Read more
Â§fn put_u32_ne(&mut self, n: u32)
Writes an unsigned 32 bit integer to self in native-endian byte order. Read more
Â§fn put_i32(&mut self, n: i32)
Writes a signed 32 bit integer to self in big-endian byte order. Read more
Â§fn put_i32_le(&mut self, n: i32)
Writes a signed 32 bit integer to self in little-endian byte order. Read more
Â§fn put_i32_ne(&mut self, n: i32)
Writes a signed 32 bit integer to self in native-endian byte order. Read more
Â§fn put_u64(&mut self, n: u64)
Writes an unsigned 64 bit integer to self in the big-endian byte order. Read more
Â§fn put_u64_le(&mut self, n: u64)
Writes an unsigned 64 bit integer to self in little-endian byte order. Read more
Â§fn put_u64_ne(&mut self, n: u64)
Writes an unsigned 64 bit integer to self in native-endian byte order. Read more
Â§fn put_i64(&mut self, n: i64)
Writes a signed 64 bit integer to self in the big-endian byte order. Read more
Â§fn put_i64_le(&mut self, n: i64)
Writes a signed 64 bit integer to self in little-endian byte order. Read more
Â§fn put_i64_ne(&mut self, n: i64)
Writes a signed 64 bit integer to self in native-endian byte order. Read more
Â§fn has_remaining_mut(&self) -> bool
Returns true if there is space in self for more bytes. Read more
Â§fn put<T>(&mut self, src: T)where\n    T: Buf,\n    Self: Sized,
Transfer bytes into self from src and advance the cursor by the\nnumber of bytes written. Read more
Â§fn put_bytes(&mut self, val: u8, cnt: usize)
Put cnt bytes val into self. Read more
Â§fn put_u128(&mut self, n: u128)
Writes an unsigned 128 bit integer to self in the big-endian byte order. Read more
Â§fn put_u128_le(&mut self, n: u128)
Writes an unsigned 128 bit integer to self in little-endian byte order. Read more
Â§fn put_u128_ne(&mut self, n: u128)
Writes an unsigned 128 bit integer to self in native-endian byte order. Read more
Â§fn put_i128(&mut self, n: i128)
Writes a signed 128 bit integer to self in the big-endian byte order. Read more
Â§fn put_i128_le(&mut self, n: i128)
Writes a signed 128 bit integer to self in little-endian byte order. Read more
Â§fn put_i128_ne(&mut self, n: i128)
Writes a signed 128 bit integer to self in native-endian byte order. Read more
Â§fn put_uint(&mut self, n: u64, nbytes: usize)
Writes an unsigned n-byte integer to self in big-endian byte order. Read more
Â§fn put_uint_le(&mut self, n: u64, nbytes: usize)
Writes an unsigned n-byte integer to self in the little-endian byte order. Read more
Â§fn put_uint_ne(&mut self, n: u64, nbytes: usize)
Writes an unsigned n-byte integer to self in the native-endian byte order. Read more
Â§fn put_int(&mut self, n: i64, nbytes: usize)
Writes low nbytes of a signed integer to self in big-endian byte order. Read more
Â§fn put_int_le(&mut self, n: i64, nbytes: usize)
Writes low nbytes of a signed integer to self in little-endian byte order. Read more
Â§fn put_int_ne(&mut self, n: i64, nbytes: usize)
Writes low nbytes of a signed integer to self in native-endian byte order. Read more
Â§fn put_f32(&mut self, n: f32)
Writes  an IEEE754 single-precision (4 bytes) floating point number to\nself in big-endian byte order. Read more
Â§fn put_f32_le(&mut self, n: f32)
Writes  an IEEE754 single-precision (4 bytes) floating point number to\nself in little-endian byte order. Read more
Â§fn put_f32_ne(&mut self, n: f32)
Writes an IEEE754 single-precision (4 bytes) floating point number to\nself in native-endian byte order. Read more
Â§fn put_f64(&mut self, n: f64)
Writes  an IEEE754 double-precision (8 bytes) floating point number to\nself in big-endian byte order. Read more
Â§fn put_f64_le(&mut self, n: f64)
Writes  an IEEE754 double-precision (8 bytes) floating point number to\nself in little-endian byte order. Read more
Â§fn put_f64_ne(&mut self, n: f64)
Writes  an IEEE754 double-precision (8 bytes) floating point number to\nself in native-endian byte order. Read more
Â§fn limit(self, limit: usize) -> Limit<Self>where\n    Self: Sized,
Creates an adaptor which can write at most limit bytes to self. Read more
Â§fn writer(self) -> Writer<Self>where\n    Self: Sized,
Creates an adaptor which implements the Write trait for self. Read more
Â§fn chain_mut<U>(self, next: U) -> Chain<Self, U>where\n    U: BufMut,\n    Self: Sized,
Creates an adapter which will chain this buffer with another. Read more
","BufMut","bdk_esplora::blocking_ext::Error"],["1.0.0 Â· sourceÂ§impl<B> BufRead for Box<B>where\n    B: BufRead + ?Sized,
sourceÂ§fn fill_buf(&mut self) -> Result<&[u8], Error>
Returns the contents of the internal buffer, filling it with more data\nfrom the inner reader if it is empty. Read more
sourceÂ§fn consume(&mut self, amt: usize)
Tells this buffer that amt bytes have been consumed from the buffer,\nso they should no longer be returned in calls to read. Read more
sourceÂ§fn read_until(&mut self, byte: u8, buf: &mut Vec<u8>) -> Result<usize, Error>
Read all bytes into buf until the delimiter byte or EOF is reached. Read more
sourceÂ§fn read_line(&mut self, buf: &mut String) -> Result<usize, Error>
Read all bytes until a newline (the 0xA byte) is reached, and append\nthem to the provided String buffer. Read more
sourceÂ§fn has_data_left(&mut self) -> Result<bool, Error>
ð¬This is a nightly-only experimental API. (buf_read_has_data_left)Check if the underlying Read has any data left to be read. Read more
sourceÂ§fn skip_until(&mut self, byte: u8) -> Result<usize, Error>
ð¬This is a nightly-only experimental API. (bufread_skip_until)Skip all bytes until the delimiter byte or EOF is reached. Read more
1.0.0 Â· sourceÂ§fn split(self, byte: u8) -> Split<Self>where\n    Self: Sized,
Returns an iterator over the contents of this reader split on the byte\nbyte. Read more
1.0.0 Â· sourceÂ§fn lines(self) -> Lines<Self>where\n    Self: Sized,
Returns an iterator over the lines of this reader. Read more
","BufRead","bdk_esplora::blocking_ext::Error"],["1.0.0 Â· sourceÂ§impl<T, A> Clone for Box<T, A>where\n    T: Clone,\n    A: Allocator + Clone,
sourceÂ§fn clone(&self) -> Box<T, A>
Returns a new box with a clone() of this boxâs contents.
\nÂ§Examples
\nlet x = Box::new(5);\nlet y = x.clone();\n\n// The value is the same\nassert_eq!(x, y);\n\n// But they are unique objects\nassert_ne!(&*x as *const i32, &*y as *const i32);
\n
sourceÂ§fn clone_from(&mut self, source: &Box<T, A>)
Copies sourceâs contents into self without creating a new allocation.
\nÂ§Examples
\nlet x = Box::new(5);\nlet mut y = Box::new(10);\nlet yp: *const i32 = &*y;\n\ny.clone_from(&x);\n\n// The value is the same\nassert_eq!(x, y);\n\n// And no allocation occurred\nassert_eq!(yp, &*y);
\n
","Clone","bdk_esplora::blocking_ext::Error"],["sourceÂ§impl<G, R, A> Coroutine<R> for Box<G, A>where\n    G: Coroutine<R> + Unpin + ?Sized,\n    A: Allocator,
Â§type Yield = <G as Coroutine<R>>::Yield
ð¬This is a nightly-only experimental API. (coroutine_trait)The type of value this coroutine yields. Read more
Â§type Return = <G as Coroutine<R>>::Return
ð¬This is a nightly-only experimental API. (coroutine_trait)The type of value this coroutine returns. Read more
sourceÂ§fn resume(\n    self: Pin<&mut Box<G, A>>,\n    arg: R\n) -> CoroutineState<<Box<G, A> as Coroutine<R>>::Yield, <Box<G, A> as Coroutine<R>>::Return>
ð¬This is a nightly-only experimental API. (coroutine_trait)Resumes the execution of this coroutine. Read more
","Coroutine","bdk_esplora::blocking_ext::Error"],["1.0.0 Â· sourceÂ§impl<T, A> Debug for Box<T, A>where\n    T: Debug + ?Sized,\n    A: Allocator,
sourceÂ§fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>
Formats the value using the given formatter. Read more
","Debug","bdk_esplora::blocking_ext::Error"],["1.0.0 Â· sourceÂ§impl<T> Default for Box<T>where\n    T: Default,
sourceÂ§fn default() -> Box<T>
Creates a Box<T>, with the Default value for T.
\n
","Default","bdk_esplora::blocking_ext::Error"],["1.0.0 Â· sourceÂ§impl<T, A> Deref for Box<T, A>where\n    A: Allocator,\n    T: ?Sized,
Â§type Target = T
The resulting type after dereferencing.
sourceÂ§fn deref(&self) -> &T
Dereferences the value.
","Deref","bdk_esplora::blocking_ext::Error"],["1.0.0 Â· sourceÂ§impl<T, A> DerefMut for Box<T, A>where\n    A: Allocator,\n    T: ?Sized,
sourceÂ§fn deref_mut(&mut self) -> &mut T
Mutably dereferences the value.
","DerefMut","bdk_esplora::blocking_ext::Error"],["sourceÂ§impl<'de, T> Deserialize<'de> for Box<T>where\n    T: Deserialize<'de>,
sourceÂ§fn deserialize<D>(\n    deserializer: D\n) -> Result<Box<T>, <D as Deserializer<'de>>::Error>where\n    D: Deserializer<'de>,
Deserialize this value from the given Serde deserializer. Read more
","Deserialize<'de>","bdk_esplora::blocking_ext::Error"],["1.0.0 Â· sourceÂ§impl<T, A> Display for Box<T, A>where\n    T: Display + ?Sized,\n    A: Allocator,
sourceÂ§fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>
Formats the value using the given formatter. Read more
","Display","bdk_esplora::blocking_ext::Error"],["sourceÂ§impl<I> DoubleEndedFallibleIterator for Box<I>where\n    I: DoubleEndedFallibleIterator + ?Sized,
sourceÂ§fn next_back(\n    &mut self\n) -> Result<Option<<I as FallibleIterator>::Item>, <I as FallibleIterator>::Error>
Advances the end of the iterator, returning the last value.
sourceÂ§fn rfold<B, F>(self, init: B, f: F) -> Result<B, Self::Error>where\n    Self: Sized,\n    F: FnMut(B, Self::Item) -> Result<B, Self::Error>,
Applies a function over the elements of the iterator in reverse order, producing a single final value.
sourceÂ§fn try_rfold<B, E, F>(&mut self, init: B, f: F) -> Result<B, E>where\n    Self: Sized,\n    E: From<Self::Error>,\n    F: FnMut(B, Self::Item) -> Result<B, E>,
Applies a function over the elements of the iterator in reverse, producing a single final value. Read more
","DoubleEndedFallibleIterator","bdk_esplora::blocking_ext::Error"],["1.0.0 Â· sourceÂ§impl<I, A> DoubleEndedIterator for Box<I, A>where\n    I: DoubleEndedIterator + ?Sized,\n    A: Allocator,
sourceÂ§fn next_back(&mut self) -> Option<<I as Iterator>::Item>
Removes and returns an element from the end of the iterator. Read more
sourceÂ§fn nth_back(&mut self, n: usize) -> Option<<I as Iterator>::Item>
Returns the nth element from the end of the iterator. Read more
sourceÂ§fn advance_back_by(&mut self, n: usize) -> Result<(), NonZero<usize>>
ð¬This is a nightly-only experimental API. (iter_advance_by)Advances the iterator from the back by n elements. Read more
1.27.0 Â· sourceÂ§fn try_rfold<B, F, R>(&mut self, init: B, f: F) -> Rwhere\n    Self: Sized,\n    F: FnMut(B, Self::Item) -> R,\n    R: Try<Output = B>,
This is the reverse version of Iterator::try_fold(): it takes\nelements starting from the back of the iterator. Read more
1.27.0 Â· sourceÂ§fn rfold<B, F>(self, init: B, f: F) -> Bwhere\n    Self: Sized,\n    F: FnMut(B, Self::Item) -> B,
An iterator method that reduces the iteratorâs elements to a single,\nfinal value, starting from the back. Read more
1.27.0 Â· sourceÂ§fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item>where\n    Self: Sized,\n    P: FnMut(&Self::Item) -> bool,
Searches for an element of an iterator from the back that satisfies a predicate. Read more
","DoubleEndedIterator","bdk_esplora::blocking_ext::Error"],["1.0.0 Â· sourceÂ§impl<T, A> Drop for Box<T, A>where\n    A: Allocator,\n    T: ?Sized,
sourceÂ§fn drop(&mut self)
Executes the destructor for this type. Read more
","Drop","bdk_esplora::blocking_ext::Error"],["1.8.0 Â· sourceÂ§impl<T> Error for Box<T>where\n    T: Error,
sourceÂ§fn description(&self) -> &str
ðDeprecated since 1.42.0: use the Display impl or to_string() Read more
sourceÂ§fn cause(&self) -> Option<&dyn Error>
ðDeprecated since 1.33.0: replaced by Error::source, which can support downcasting
sourceÂ§fn source(&self) -> Option<&(dyn Error + 'static)>
The lower-level source of this error, if any. Read more
sourceÂ§fn provide<'b>(&'b self, request: &mut Request<'b>)
ð¬This is a nightly-only experimental API. (error_generic_member_access)Provides type based access to context intended for error reports. Read more
","Error","bdk_esplora::blocking_ext::Error"],["1.0.0 Â· sourceÂ§impl<I, A> ExactSizeIterator for Box<I, A>where\n    I: ExactSizeIterator + ?Sized,\n    A: Allocator,
sourceÂ§fn len(&self) -> usize
Returns the exact remaining length of the iterator. Read more
sourceÂ§fn is_empty(&self) -> bool
ð¬This is a nightly-only experimental API. (exact_size_is_empty)Returns true if the iterator is empty. Read more
","ExactSizeIterator","bdk_esplora::blocking_ext::Error"],["sourceÂ§impl<I> FallibleIterator for Box<I>where\n    I: FallibleIterator + ?Sized,
Â§type Item = <I as FallibleIterator>::Item
The type being iterated over.
Â§type Error = <I as FallibleIterator>::Error
The error type.
sourceÂ§fn next(\n    &mut self\n) -> Result<Option<<I as FallibleIterator>::Item>, <I as FallibleIterator>::Error>
Advances the iterator and returns the next value. Read more
sourceÂ§fn size_hint(&self) -> (usize, Option<usize>)
Returns bounds on the remaining length of the iterator. Read more
sourceÂ§fn nth(\n    &mut self,\n    n: usize\n) -> Result<Option<<I as FallibleIterator>::Item>, <I as FallibleIterator>::Error>
Returns the nth element of the iterator.
sourceÂ§fn count(self) -> Result<usize, Self::Error>where\n    Self: Sized,
Consumes the iterator, returning the number of remaining items.
sourceÂ§fn last(self) -> Result<Option<Self::Item>, Self::Error>where\n    Self: Sized,
Returns the last element of the iterator.
sourceÂ§fn step_by(self, step: usize) -> StepBy<Self>where\n    Self: Sized,
Returns an iterator starting at the same point, but stepping by the given amount at each iteration. Read more
sourceÂ§fn chain<I>(self, it: I) -> Chain<Self, I>where\n    I: IntoFallibleIterator<Item = Self::Item, Error = Self::Error>,\n    Self: Sized,
Returns an iterator which yields the elements of this iterator followed\nby another.
sourceÂ§fn zip<I>(\n    self,\n    o: I\n) -> Zip<Self, <I as IntoFallibleIterator>::IntoFallibleIter>where\n    Self: Sized,\n    I: IntoFallibleIterator<Error = Self::Error>,
Returns an iterator that yields pairs of this iteratorâs and another\niteratorâs values.
sourceÂ§fn map<F, B>(self, f: F) -> Map<Self, F>where\n    Self: Sized,\n    F: FnMut(Self::Item) -> Result<B, Self::Error>,
Returns an iterator which applies a fallible transform to the elements\nof the underlying iterator.
sourceÂ§fn for_each<F>(self, f: F) -> Result<(), Self::Error>where\n    Self: Sized,\n    F: FnMut(Self::Item) -> Result<(), Self::Error>,
Calls a fallible closure on each element of an iterator.
sourceÂ§fn filter<F>(self, f: F) -> Filter<Self, F>where\n    Self: Sized,\n    F: FnMut(&Self::Item) -> Result<bool, Self::Error>,
Returns an iterator which uses a predicate to determine which values\nshould be yielded. The predicate may fail; such failures are passed to\nthe caller.
sourceÂ§fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>where\n    Self: Sized,\n    F: FnMut(Self::Item) -> Result<Option<B>, Self::Error>,
Returns an iterator which both filters and maps. The closure may fail;\nsuch failures are passed along to the consumer.
sourceÂ§fn enumerate(self) -> Enumerate<Self>where\n    Self: Sized,
Returns an iterator which yields the current iteration count as well\nas the value.
sourceÂ§fn peekable(self) -> Peekable<Self>where\n    Self: Sized,
Returns an iterator that can peek at the next element without consuming\nit.
sourceÂ§fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>where\n    Self: Sized,\n    P: FnMut(&Self::Item) -> Result<bool, Self::Error>,
Returns an iterator that skips elements based on a predicate.
sourceÂ§fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>where\n    Self: Sized,\n    P: FnMut(&Self::Item) -> Result<bool, Self::Error>,
Returns an iterator that yields elements based on a predicate.
sourceÂ§fn skip(self, n: usize) -> Skip<Self>where\n    Self: Sized,
Returns an iterator which skips the first n values of this iterator.
sourceÂ§fn take(self, n: usize) -> Take<Self>where\n    Self: Sized,
Returns an iterator that yields only the first n values of this\niterator.
sourceÂ§fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>where\n    Self: Sized,\n    F: FnMut(&mut St, Self::Item) -> Result<Option<B>, Self::Error>,
Returns an iterator which applies a stateful map to values of this\niterator.
sourceÂ§fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>where\n    Self: Sized,\n    U: IntoFallibleIterator<Error = Self::Error>,\n    F: FnMut(Self::Item) -> Result<U, Self::Error>,
Returns an iterator which maps this iteratorâs elements to iterators, yielding those iteratorsâ values.
sourceÂ§fn fuse(self) -> Fuse<Self>where\n    Self: Sized,
Returns an iterator which yields this iteratorâs elements and ends after\nthe first Ok(None). Read more
sourceÂ§fn inspect<F>(self, f: F) -> Inspect<Self, F>where\n    Self: Sized,\n    F: FnMut(&Self::Item) -> Result<(), Self::Error>,
Returns an iterator which passes each element to a closure before returning it.
sourceÂ§fn by_ref(&mut self) -> &mut Selfwhere\n    Self: Sized,
Borrow an iterator rather than consuming it. Read more
sourceÂ§fn collect<T>(self) -> Result<T, Self::Error>where\n    T: FromIterator<Self::Item>,\n    Self: Sized,
Transforms the iterator into a collection. Read more
sourceÂ§fn partition<B, F>(self, f: F) -> Result<(B, B), Self::Error>where\n    Self: Sized,\n    B: Default + Extend<Self::Item>,\n    F: FnMut(&Self::Item) -> Result<bool, Self::Error>,
Transforms the iterator into two collections, partitioning elements by a closure.
sourceÂ§fn fold<B, F>(self, init: B, f: F) -> Result<B, Self::Error>where\n    Self: Sized,\n    F: FnMut(B, Self::Item) -> Result<B, Self::Error>,
Applies a function over the elements of the iterator, producing a single\nfinal value.
sourceÂ§fn try_fold<B, E, F>(&mut self, init: B, f: F) -> Result<B, E>where\n    Self: Sized,\n    E: From<Self::Error>,\n    F: FnMut(B, Self::Item) -> Result<B, E>,
Applies a function over the elements of the iterator, producing a single final value. Read more
sourceÂ§fn all<F>(&mut self, f: F) -> Result<bool, Self::Error>where\n    Self: Sized,\n    F: FnMut(Self::Item) -> Result<bool, Self::Error>,
Determines if all elements of this iterator match a predicate.
sourceÂ§fn any<F>(&mut self, f: F) -> Result<bool, Self::Error>where\n    Self: Sized,\n    F: FnMut(Self::Item) -> Result<bool, Self::Error>,
Determines if any element of this iterator matches a predicate.
sourceÂ§fn find<F>(&mut self, f: F) -> Result<Option<Self::Item>, Self::Error>where\n    Self: Sized,\n    F: FnMut(&Self::Item) -> Result<bool, Self::Error>,
Returns the first element of the iterator that matches a predicate.
sourceÂ§fn find_map<B, F>(&mut self, f: F) -> Result<Option<B>, Self::Error>where\n    Self: Sized,\n    F: FnMut(Self::Item) -> Result<Option<B>, Self::Error>,
Applies a function to the elements of the iterator, returning the first non-None result.
sourceÂ§fn position<F>(&mut self, f: F) -> Result<Option<usize>, Self::Error>where\n    Self: Sized,\n    F: FnMut(Self::Item) -> Result<bool, Self::Error>,
Returns the position of the first element of this iterator that matches\na predicate. The predicate may fail; such failures are returned to the\ncaller.
sourceÂ§fn max_by_key<B, F>(self, f: F) -> Result<Option<Self::Item>, Self::Error>where\n    Self: Sized,\n    B: Ord,\n    F: FnMut(&Self::Item) -> Result<B, Self::Error>,
Returns the element of the iterator which gives the maximum value from\nthe function.
sourceÂ§fn max_by<F>(self, f: F) -> Result<Option<Self::Item>, Self::Error>where\n    Self: Sized,\n    F: FnMut(&Self::Item, &Self::Item) -> Result<Ordering, Self::Error>,
Returns the element that gives the maximum value with respect to the function.
sourceÂ§fn min_by_key<B, F>(self, f: F) -> Result<Option<Self::Item>, Self::Error>where\n    Self: Sized,\n    B: Ord,\n    F: FnMut(&Self::Item) -> Result<B, Self::Error>,
Returns the element of the iterator which gives the minimum value from\nthe function.
sourceÂ§fn min_by<F>(self, f: F) -> Result<Option<Self::Item>, Self::Error>where\n    Self: Sized,\n    F: FnMut(&Self::Item, &Self::Item) -> Result<Ordering, Self::Error>,
Returns the element that gives the minimum value with respect to the function.
sourceÂ§fn unzip<A, B, FromA, FromB>(self) -> Result<(FromA, FromB), Self::Error>where\n    Self: Sized + FallibleIterator<Item = (A, B)>,\n    FromA: Default + Extend<A>,\n    FromB: Default + Extend<B>,
Converts an iterator of pairs into a pair of containers.
sourceÂ§fn cloned<'a, T>(self) -> Cloned<Self>where\n    Self: Sized + FallibleIterator<Item = &'a T>,\n    T: 'a + Clone,
Returns an iterator which clones all of its elements.
sourceÂ§fn partial_cmp<I>(self, other: I) -> Result<Option<Ordering>, Self::Error>where\n    Self: Sized,\n    I: IntoFallibleIterator<Error = Self::Error>,\n    Self::Item: PartialOrd<<I as IntoFallibleIterator>::Item>,
Lexicographically compares the elements of this iterator to that of\nanother.
sourceÂ§fn eq<I>(self, other: I) -> Result<bool, Self::Error>where\n    Self: Sized,\n    I: IntoFallibleIterator<Error = Self::Error>,\n    Self::Item: PartialEq<<I as IntoFallibleIterator>::Item>,
Determines if the elements of this iterator are equal to those of\nanother.
sourceÂ§fn ne<I>(self, other: I) -> Result<bool, Self::Error>where\n    Self: Sized,\n    I: IntoFallibleIterator<Error = Self::Error>,\n    Self::Item: PartialEq<<I as IntoFallibleIterator>::Item>,
Determines if the elements of this iterator are not equal to those of\nanother.
sourceÂ§fn lt<I>(self, other: I) -> Result<bool, Self::Error>where\n    Self: Sized,\n    I: IntoFallibleIterator<Error = Self::Error>,\n    Self::Item: PartialOrd<<I as IntoFallibleIterator>::Item>,
Determines if the elements of this iterator are lexicographically less\nthan those of another.
sourceÂ§fn le<I>(self, other: I) -> Result<bool, Self::Error>where\n    Self: Sized,\n    I: IntoFallibleIterator<Error = Self::Error>,\n    Self::Item: PartialOrd<<I as IntoFallibleIterator>::Item>,
Determines if the elements of this iterator are lexicographically less\nthan or equal to those of another.
sourceÂ§fn gt<I>(self, other: I) -> Result<bool, Self::Error>where\n    Self: Sized,\n    I: IntoFallibleIterator<Error = Self::Error>,\n    Self::Item: PartialOrd<<I as IntoFallibleIterator>::Item>,
Determines if the elements of this iterator are lexicographically\ngreater than those of another.
sourceÂ§fn ge<I>(self, other: I) -> Result<bool, Self::Error>where\n    Self: Sized,\n    I: IntoFallibleIterator<Error = Self::Error>,\n    Self::Item: PartialOrd<<I as IntoFallibleIterator>::Item>,
Determines if the elements of this iterator are lexicographically\ngreater than or equal to those of another.
sourceÂ§fn iterator(self) -> Iterator<Self>where\n    Self: Sized,
Returns a normal (non-fallible) iterator over Result<Item, Error>.
sourceÂ§fn map_err<B, F>(self, f: F) -> MapErr<Self, F>where\n    F: FnMut(Self::Error) -> B,\n    Self: Sized,
Returns an iterator which applies a transform to the errors of the\nunderlying iterator.
","FallibleIterator","bdk_esplora::blocking_ext::Error"],["1.35.0 Â· sourceÂ§impl<Args, F, A> Fn<Args> for Box<F, A>where\n    Args: Tuple,\n    F: Fn<Args> + ?Sized,\n    A: Allocator,
sourceÂ§extern "rust-call" fn call(\n    &self,\n    args: Args\n) -> <Box<F, A> as FnOnce<Args>>::Output
ð¬This is a nightly-only experimental API. (fn_traits)Performs the call operation.
","Fn","bdk_esplora::blocking_ext::Error"],["1.35.0 Â· sourceÂ§impl<Args, F, A> FnMut<Args> for Box<F, A>where\n    Args: Tuple,\n    F: FnMut<Args> + ?Sized,\n    A: Allocator,
sourceÂ§extern "rust-call" fn call_mut(\n    &mut self,\n    args: Args\n) -> <Box<F, A> as FnOnce<Args>>::Output
ð¬This is a nightly-only experimental API. (fn_traits)Performs the call operation.
","FnMut","bdk_esplora::blocking_ext::Error"],["1.35.0 Â· sourceÂ§impl<Args, F, A> FnOnce<Args> for Box<F, A>where\n    Args: Tuple,\n    F: FnOnce<Args> + ?Sized,\n    A: Allocator,
Â§type Output = <F as FnOnce<Args>>::Output
The returned type after the call operator is used.
sourceÂ§extern "rust-call" fn call_once(\n    self,\n    args: Args\n) -> <Box<F, A> as FnOnce<Args>>::Output
ð¬This is a nightly-only experimental API. (fn_traits)Performs the call operation.
","FnOnce","bdk_esplora::blocking_ext::Error"],["1.6.0 Â· sourceÂ§impl<T> From<T> for Box<T>
sourceÂ§fn from(t: T) -> Box<T>
Converts a T into a Box<T>
\nThe conversion allocates on the heap and moves t\nfrom the stack into it.
\nÂ§Examples
\nlet x = 5;\nlet boxed = Box::new(5);\n\nassert_eq!(Box::from(x), boxed);
\n
","From","bdk_esplora::blocking_ext::Error"],["Â§impl<F> FusedFuture for Box<F>where\n    F: FusedFuture + Unpin + ?Sized,
Â§fn is_terminated(&self) -> bool
Returns true if the underlying future should no longer be polled.
","FusedFuture","bdk_esplora::blocking_ext::Error"],["Â§impl<S> FusedStream for Box<S>where\n    S: FusedStream + Unpin + ?Sized,
Â§fn is_terminated(&self) -> bool
Returns true if the stream should no longer be polled.
","FusedStream","bdk_esplora::blocking_ext::Error"],["1.36.0 Â· sourceÂ§impl<F, A> Future for Box<F, A>where\n    F: Future + Unpin + ?Sized,\n    A: Allocator,
Â§type Output = <F as Future>::Output
The type of value produced on completion.
sourceÂ§fn poll(\n    self: Pin<&mut Box<F, A>>,\n    cx: &mut Context<'_>\n) -> Poll<<Box<F, A> as Future>::Output>
Attempt to resolve the future to a final value, registering\nthe current task for wakeup if the value is not yet available. Read more
","Future","bdk_esplora::blocking_ext::Error"],["1.0.0 Â· sourceÂ§impl<T, A> Hash for Box<T, A>where\n    T: Hash + ?Sized,\n    A: Allocator,
sourceÂ§fn hash<H>(&self, state: &mut H)where\n    H: Hasher,
Feeds this value into the given Hasher. Read more
1.3.0 Â· sourceÂ§fn hash_slice<H>(data: &[Self], state: &mut H)where\n    H: Hasher,\n    Self: Sized,
Feeds a slice of this type into the given Hasher. Read more
","Hash","bdk_esplora::blocking_ext::Error"],["1.22.0 Â· sourceÂ§impl<T, A> Hasher for Box<T, A>where\n    T: Hasher + ?Sized,\n    A: Allocator,
sourceÂ§fn finish(&self) -> u64
Returns the hash value for the values written so far. Read more
sourceÂ§fn write(&mut self, bytes: &[u8])
Writes some data into this Hasher. Read more
sourceÂ§fn write_u8(&mut self, i: u8)
Writes a single u8 into this hasher.
sourceÂ§fn write_u16(&mut self, i: u16)
Writes a single u16 into this hasher.
sourceÂ§fn write_u32(&mut self, i: u32)
Writes a single u32 into this hasher.
sourceÂ§fn write_u64(&mut self, i: u64)
Writes a single u64 into this hasher.
sourceÂ§fn write_u128(&mut self, i: u128)
Writes a single u128 into this hasher.
sourceÂ§fn write_usize(&mut self, i: usize)
Writes a single usize into this hasher.
sourceÂ§fn write_i8(&mut self, i: i8)
Writes a single i8 into this hasher.
sourceÂ§fn write_i16(&mut self, i: i16)
Writes a single i16 into this hasher.
sourceÂ§fn write_i32(&mut self, i: i32)
Writes a single i32 into this hasher.
sourceÂ§fn write_i64(&mut self, i: i64)
Writes a single i64 into this hasher.
sourceÂ§fn write_i128(&mut self, i: i128)
Writes a single i128 into this hasher.
sourceÂ§fn write_isize(&mut self, i: isize)
Writes a single isize into this hasher.
sourceÂ§fn write_length_prefix(&mut self, len: usize)
ð¬This is a nightly-only experimental API. (hasher_prefixfree_extras)Writes a length prefix into this hasher, as part of being prefix-free. Read more
sourceÂ§fn write_str(&mut self, s: &str)
ð¬This is a nightly-only experimental API. (hasher_prefixfree_extras)Writes a single str into this hasher. Read more
","Hasher","bdk_esplora::blocking_ext::Error"],["1.0.0 Â· sourceÂ§impl<I, A> Iterator for Box<I, A>where\n    I: Iterator + ?Sized,\n    A: Allocator,
Â§type Item = <I as Iterator>::Item
The type of the elements being iterated over.
sourceÂ§fn next(&mut self) -> Option<<I as Iterator>::Item>
Advances the iterator and returns the next value. Read more
sourceÂ§fn size_hint(&self) -> (usize, Option<usize>)
Returns the bounds on the remaining length of the iterator. Read more
sourceÂ§fn nth(&mut self, n: usize) -> Option<<I as Iterator>::Item>
Returns the nth element of the iterator. Read more
sourceÂ§fn last(self) -> Option<<I as Iterator>::Item>
Consumes the iterator, returning the last element. Read more
sourceÂ§fn next_chunk<const N: usize>(\n    &mut self\n) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>where\n    Self: Sized,
ð¬This is a nightly-only experimental API. (iter_next_chunk)Advances the iterator and returns an array containing the next N values. Read more
1.0.0 Â· sourceÂ§fn count(self) -> usizewhere\n    Self: Sized,
Consumes the iterator, counting the number of iterations and returning it. Read more
sourceÂ§fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>
ð¬This is a nightly-only experimental API. (iter_advance_by)Advances the iterator by n elements. Read more
1.28.0 Â· sourceÂ§fn step_by(self, step: usize) -> StepBy<Self>where\n    Self: Sized,
Creates an iterator starting at the same point, but stepping by\nthe given amount at each iteration. Read more
1.0.0 Â· sourceÂ§fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>where\n    Self: Sized,\n    U: IntoIterator<Item = Self::Item>,
Takes two iterators and creates a new iterator over both in sequence. Read more
1.0.0 Â· sourceÂ§fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>where\n    Self: Sized,\n    U: IntoIterator,
âZips upâ two iterators into a single iterator of pairs. Read more
sourceÂ§fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>where\n    Self: Sized,\n    G: FnMut() -> Self::Item,
ð¬This is a nightly-only experimental API. (iter_intersperse)Creates a new iterator which places an item generated by separator\nbetween adjacent items of the original iterator. Read more
1.0.0 Â· sourceÂ§fn map<B, F>(self, f: F) -> Map<Self, F>where\n    Self: Sized,\n    F: FnMut(Self::Item) -> B,
Takes a closure and creates an iterator which calls that closure on each\nelement. Read more
1.21.0 Â· sourceÂ§fn for_each<F>(self, f: F)where\n    Self: Sized,\n    F: FnMut(Self::Item),
Calls a closure on each element of an iterator. Read more
1.0.0 Â· sourceÂ§fn filter<P>(self, predicate: P) -> Filter<Self, P>where\n    Self: Sized,\n    P: FnMut(&Self::Item) -> bool,
Creates an iterator which uses a closure to determine if an element\nshould be yielded. Read more
1.0.0 Â· sourceÂ§fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>where\n    Self: Sized,\n    F: FnMut(Self::Item) -> Option<B>,
Creates an iterator that both filters and maps. Read more
1.0.0 Â· sourceÂ§fn enumerate(self) -> Enumerate<Self>where\n    Self: Sized,
Creates an iterator which gives the current iteration count as well as\nthe next value. Read more
1.0.0 Â· sourceÂ§fn peekable(self) -> Peekable<Self>where\n    Self: Sized,
Creates an iterator which can use the peek and peek_mut methods\nto look at the next element of the iterator without consuming it. See\ntheir documentation for more information. Read more
1.0.0 Â· sourceÂ§fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>where\n    Self: Sized,\n    P: FnMut(&Self::Item) -> bool,
Creates an iterator that skips elements based on a predicate. Read more
1.0.0 Â· sourceÂ§fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>where\n    Self: Sized,\n    P: FnMut(&Self::Item) -> bool,
Creates an iterator that yields elements based on a predicate. Read more
1.57.0 Â· sourceÂ§fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>where\n    Self: Sized,\n    P: FnMut(Self::Item) -> Option<B>,
Creates an iterator that both yields elements based on a predicate and maps. Read more
1.0.0 Â· sourceÂ§fn skip(self, n: usize) -> Skip<Self>where\n    Self: Sized,
Creates an iterator that skips the first n elements. Read more
1.0.0 Â· sourceÂ§fn take(self, n: usize) -> Take<Self>where\n    Self: Sized,
Creates an iterator that yields the first n elements, or fewer\nif the underlying iterator ends sooner. Read more
1.0.0 Â· sourceÂ§fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>where\n    Self: Sized,\n    F: FnMut(&mut St, Self::Item) -> Option<B>,
An iterator adapter which, like fold, holds internal state, but\nunlike fold, produces a new iterator. Read more
1.0.0 Â· sourceÂ§fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>where\n    Self: Sized,\n    U: IntoIterator,\n    F: FnMut(Self::Item) -> U,
Creates an iterator that works like map, but flattens nested structure. Read more
sourceÂ§fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>where\n    Self: Sized,\n    F: FnMut(&[Self::Item; N]) -> R,
ð¬This is a nightly-only experimental API. (iter_map_windows)Calls the given function f for each contiguous window of size N over\nself and returns an iterator over the outputs of f. Like slice::windows(),\nthe windows during mapping overlap as well. Read more
1.0.0 Â· sourceÂ§fn fuse(self) -> Fuse<Self>where\n    Self: Sized,
Creates an iterator which ends after the first None. Read more
1.0.0 Â· sourceÂ§fn inspect<F>(self, f: F) -> Inspect<Self, F>where\n    Self: Sized,\n    F: FnMut(&Self::Item),
Does something with each element of an iterator, passing the value on. Read more
1.0.0 Â· sourceÂ§fn by_ref(&mut self) -> &mut Selfwhere\n    Self: Sized,
Borrows an iterator, rather than consuming it. Read more
1.0.0 Â· sourceÂ§fn collect<B>(self) -> Bwhere\n    B: FromIterator<Self::Item>,\n    Self: Sized,
Transforms an iterator into a collection. Read more
sourceÂ§fn collect_into<E>(self, collection: &mut E) -> &mut Ewhere\n    E: Extend<Self::Item>,\n    Self: Sized,
ð¬This is a nightly-only experimental API. (iter_collect_into)Collects all the items from an iterator into a collection. Read more
1.0.0 Â· sourceÂ§fn partition<B, F>(self, f: F) -> (B, B)where\n    Self: Sized,\n    B: Default + Extend<Self::Item>,\n    F: FnMut(&Self::Item) -> bool,
Consumes an iterator, creating two collections from it. Read more
sourceÂ§fn is_partitioned<P>(self, predicate: P) -> boolwhere\n    Self: Sized,\n    P: FnMut(Self::Item) -> bool,
ð¬This is a nightly-only experimental API. (iter_is_partitioned)Checks if the elements of this iterator are partitioned according to the given predicate,\nsuch that all those that return true precede all those that return false. Read more
1.27.0 Â· sourceÂ§fn try_fold<B, F, R>(&mut self, init: B, f: F) -> Rwhere\n    Self: Sized,\n    F: FnMut(B, Self::Item) -> R,\n    R: Try<Output = B>,
An iterator method that applies a function as long as it returns\nsuccessfully, producing a single, final value. Read more
1.27.0 Â· sourceÂ§fn try_for_each<F, R>(&mut self, f: F) -> Rwhere\n    Self: Sized,\n    F: FnMut(Self::Item) -> R,\n    R: Try<Output = ()>,
An iterator method that applies a fallible function to each item in the\niterator, stopping at the first error and returning that error. Read more
1.0.0 Â· sourceÂ§fn fold<B, F>(self, init: B, f: F) -> Bwhere\n    Self: Sized,\n    F: FnMut(B, Self::Item) -> B,
Folds every element into an accumulator by applying an operation,\nreturning the final result. Read more
1.51.0 Â· sourceÂ§fn reduce<F>(self, f: F) -> Option<Self::Item>where\n    Self: Sized,\n    F: FnMut(Self::Item, Self::Item) -> Self::Item,
Reduces the elements to a single one, by repeatedly applying a reducing\noperation. Read more
sourceÂ§fn try_reduce<F, R>(\n    &mut self,\n    f: F\n) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryTypewhere\n    Self: Sized,\n    F: FnMut(Self::Item, Self::Item) -> R,\n    R: Try<Output = Self::Item>,\n    <R as Try>::Residual: Residual<Option<Self::Item>>,
ð¬This is a nightly-only experimental API. (iterator_try_reduce)Reduces the elements to a single one by repeatedly applying a reducing operation. If the\nclosure returns a failure, the failure is propagated back to the caller immediately. Read more
1.0.0 Â· sourceÂ§fn all<F>(&mut self, f: F) -> boolwhere\n    Self: Sized,\n    F: FnMut(Self::Item) -> bool,
Tests if every element of the iterator matches a predicate. Read more
1.0.0 Â· sourceÂ§fn any<F>(&mut self, f: F) -> boolwhere\n    Self: Sized,\n    F: FnMut(Self::Item) -> bool,
Tests if any element of the iterator matches a predicate. Read more
1.0.0 Â· sourceÂ§fn find<P>(&mut self, predicate: P) -> Option<Self::Item>where\n    Self: Sized,\n    P: FnMut(&Self::Item) -> bool,
Searches for an element of an iterator that satisfies a predicate. Read more
1.30.0 Â· sourceÂ§fn find_map<B, F>(&mut self, f: F) -> Option<B>where\n    Self: Sized,\n    F: FnMut(Self::Item) -> Option<B>,
Applies function to the elements of iterator and returns\nthe first non-none result. Read more
sourceÂ§fn try_find<F, R>(\n    &mut self,\n    f: F\n) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryTypewhere\n    Self: Sized,\n    F: FnMut(&Self::Item) -> R,\n    R: Try<Output = bool>,\n    <R as Try>::Residual: Residual<Option<Self::Item>>,
ð¬This is a nightly-only experimental API. (try_find)Applies function to the elements of iterator and returns\nthe first true result or the first error. Read more
1.0.0 Â· sourceÂ§fn position<P>(&mut self, predicate: P) -> Option<usize>where\n    Self: Sized,\n    P: FnMut(Self::Item) -> bool,
Searches for an element in an iterator, returning its index. Read more
1.6.0 Â· sourceÂ§fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>where\n    B: Ord,\n    Self: Sized,\n    F: FnMut(&Self::Item) -> B,
Returns the element that gives the maximum value from the\nspecified function. Read more
1.15.0 Â· sourceÂ§fn max_by<F>(self, compare: F) -> Option<Self::Item>where\n    Self: Sized,\n    F: FnMut(&Self::Item, &Self::Item) -> Ordering,
Returns the element that gives the maximum value with respect to the\nspecified comparison function. Read more
1.6.0 Â· sourceÂ§fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>where\n    B: Ord,\n    Self: Sized,\n    F: FnMut(&Self::Item) -> B,
Returns the element that gives the minimum value from the\nspecified function. Read more
1.15.0 Â· sourceÂ§fn min_by<F>(self, compare: F) -> Option<Self::Item>where\n    Self: Sized,\n    F: FnMut(&Self::Item, &Self::Item) -> Ordering,
Returns the element that gives the minimum value with respect to the\nspecified comparison function. Read more
1.0.0 Â· sourceÂ§fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)where\n    FromA: Default + Extend<A>,\n    FromB: Default + Extend<B>,\n    Self: Sized + Iterator<Item = (A, B)>,
Converts an iterator of pairs into a pair of containers. Read more
1.36.0 Â· sourceÂ§fn copied<'a, T>(self) -> Copied<Self>where\n    T: 'a + Copy,\n    Self: Sized + Iterator<Item = &'a T>,
Creates an iterator which copies all of its elements. Read more
1.0.0 Â· sourceÂ§fn cloned<'a, T>(self) -> Cloned<Self>where\n    T: 'a + Clone,\n    Self: Sized + Iterator<Item = &'a T>,
Creates an iterator which clones all of its elements. Read more
sourceÂ§fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>where\n    Self: Sized,
ð¬This is a nightly-only experimental API. (iter_array_chunks)Returns an iterator over N elements of the iterator at a time. Read more
1.11.0 Â· sourceÂ§fn sum<S>(self) -> Swhere\n    Self: Sized,\n    S: Sum<Self::Item>,
Sums the elements of an iterator. Read more
1.11.0 Â· sourceÂ§fn product<P>(self) -> Pwhere\n    Self: Sized,\n    P: Product<Self::Item>,
Iterates over the entire iterator, multiplying all the elements Read more
sourceÂ§fn cmp_by<I, F>(self, other: I, cmp: F) -> Orderingwhere\n    Self: Sized,\n    I: IntoIterator,\n    F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,
ð¬This is a nightly-only experimental API. (iter_order_by)Lexicographically compares the elements of this Iterator with those\nof another with respect to the specified comparison function. Read more
1.5.0 Â· sourceÂ§fn partial_cmp<I>(self, other: I) -> Option<Ordering>where\n    I: IntoIterator,\n    Self::Item: PartialOrd<<I as IntoIterator>::Item>,\n    Self: Sized,
Lexicographically compares the PartialOrd elements of\nthis Iterator with those of another. The comparison works like short-circuit\nevaluation, returning a result without comparing the remaining elements.\nAs soon as an order can be determined, the evaluation stops and a result is returned. Read more
sourceÂ§fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>where\n    Self: Sized,\n    I: IntoIterator,\n    F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,
ð¬This is a nightly-only experimental API. (iter_order_by)Lexicographically compares the elements of this Iterator with those\nof another with respect to the specified comparison function. Read more
1.5.0 Â· sourceÂ§fn eq<I>(self, other: I) -> boolwhere\n    I: IntoIterator,\n    Self::Item: PartialEq<<I as IntoIterator>::Item>,\n    Self: Sized,
Determines if the elements of this Iterator are equal to those of\nanother. Read more
sourceÂ§fn eq_by<I, F>(self, other: I, eq: F) -> boolwhere\n    Self: Sized,\n    I: IntoIterator,\n    F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,
ð¬This is a nightly-only experimental API. (iter_order_by)Determines if the elements of this Iterator are equal to those of\nanother with respect to the specified equality function. Read more
1.5.0 Â· sourceÂ§fn ne<I>(self, other: I) -> boolwhere\n    I: IntoIterator,\n    Self::Item: PartialEq<<I as IntoIterator>::Item>,\n    Self: Sized,
Determines if the elements of this Iterator are not equal to those of\nanother. Read more
1.5.0 Â· sourceÂ§fn lt<I>(self, other: I) -> boolwhere\n    I: IntoIterator,\n    Self::Item: PartialOrd<<I as IntoIterator>::Item>,\n    Self: Sized,
Determines if the elements of this Iterator are lexicographically\nless than those of another. Read more
1.5.0 Â· sourceÂ§fn le<I>(self, other: I) -> boolwhere\n    I: IntoIterator,\n    Self::Item: PartialOrd<<I as IntoIterator>::Item>,\n    Self: Sized,
Determines if the elements of this Iterator are lexicographically\nless or equal to those of another. Read more
1.5.0 Â· sourceÂ§fn gt<I>(self, other: I) -> boolwhere\n    I: IntoIterator,\n    Self::Item: PartialOrd<<I as IntoIterator>::Item>,\n    Self: Sized,
Determines if the elements of this Iterator are lexicographically\ngreater than those of another. Read more
1.5.0 Â· sourceÂ§fn ge<I>(self, other: I) -> boolwhere\n    I: IntoIterator,\n    Self::Item: PartialOrd<<I as IntoIterator>::Item>,\n    Self: Sized,
Determines if the elements of this Iterator are lexicographically\ngreater than or equal to those of another. Read more
sourceÂ§fn is_sorted_by<F>(self, compare: F) -> boolwhere\n    Self: Sized,\n    F: FnMut(&Self::Item, &Self::Item) -> bool,
ð¬This is a nightly-only experimental API. (is_sorted)Checks if the elements of this iterator are sorted using the given comparator function. Read more
sourceÂ§fn is_sorted_by_key<F, K>(self, f: F) -> boolwhere\n    Self: Sized,\n    F: FnMut(Self::Item) -> K,\n    K: PartialOrd,
ð¬This is a nightly-only experimental API. (is_sorted)Checks if the elements of this iterator are sorted using the given key extraction\nfunction. Read more
","Iterator","bdk_esplora::blocking_ext::Error"],["Â§impl<Sp> LocalSpawn for Box<Sp>where\n    Sp: LocalSpawn + ?Sized,
Â§fn spawn_local_obj(\n    &self,\n    future: LocalFutureObj<'static, ()>\n) -> Result<(), SpawnError>
Spawns a future that will be run to completion. Read more
Â§fn status_local(&self) -> Result<(), SpawnError>
Determines whether the executor is able to spawn new tasks. Read more
","LocalSpawn","bdk_esplora::blocking_ext::Error"],["1.0.0 Â· sourceÂ§impl<T, A> Ord for Box<T, A>where\n    T: Ord + ?Sized,\n    A: Allocator,
sourceÂ§fn cmp(&self, other: &Box<T, A>) -> Ordering
This method returns an Ordering between self and other. Read more
1.21.0 Â· sourceÂ§fn max(self, other: Self) -> Selfwhere\n    Self: Sized,
Compares and returns the maximum of two values. Read more
1.21.0 Â· sourceÂ§fn min(self, other: Self) -> Selfwhere\n    Self: Sized,
Compares and returns the minimum of two values. Read more
1.50.0 Â· sourceÂ§fn clamp(self, min: Self, max: Self) -> Selfwhere\n    Self: Sized + PartialOrd,
Restrict a value to a certain interval. Read more
","Ord","bdk_esplora::blocking_ext::Error"],["1.0.0 Â· sourceÂ§impl<T, A> PartialEq for Box<T, A>where\n    T: PartialEq + ?Sized,\n    A: Allocator,
sourceÂ§fn eq(&self, other: &Box<T, A>) -> bool
This method tests for self and other values to be equal, and is used\nby ==.
sourceÂ§fn ne(&self, other: &Box<T, A>) -> bool
This method tests for !=. The default implementation is almost always\nsufficient, and should not be overridden without very good reason.
","PartialEq","bdk_esplora::blocking_ext::Error"],["1.0.0 Â· sourceÂ§impl<T, A> PartialOrd for Box<T, A>where\n    T: PartialOrd + ?Sized,\n    A: Allocator,
sourceÂ§fn partial_cmp(&self, other: &Box<T, A>) -> Option<Ordering>
This method returns an ordering between self and other values if one exists. Read more
sourceÂ§fn lt(&self, other: &Box<T, A>) -> bool
This method tests less than (for self and other) and is used by the < operator. Read more
sourceÂ§fn le(&self, other: &Box<T, A>) -> bool
This method tests less than or equal to (for self and other) and is used by the <=\noperator. Read more
sourceÂ§fn ge(&self, other: &Box<T, A>) -> bool
This method tests greater than or equal to (for self and other) and is used by the >=\noperator. Read more
sourceÂ§fn gt(&self, other: &Box<T, A>) -> bool
This method tests greater than (for self and other) and is used by the > operator. Read more
","PartialOrd","bdk_esplora::blocking_ext::Error"],["1.0.0 Â· sourceÂ§impl<T, A> Pointer for Box<T, A>where\n    A: Allocator,\n    T: ?Sized,
sourceÂ§fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>
Formats the value using the given formatter. Read more
","Pointer","bdk_esplora::blocking_ext::Error"],["1.0.0 Â· sourceÂ§impl<R> Read for Box<R>where\n    R: Read + ?Sized,
sourceÂ§fn read(&mut self, buf: &mut [u8]) -> Result<usize, Error>
Pull some bytes from this source into the specified buffer, returning\nhow many bytes were read. Read more
sourceÂ§fn read_buf(&mut self, cursor: BorrowedCursor<'_>) -> Result<(), Error>
ð¬This is a nightly-only experimental API. (read_buf)Pull some bytes from this source into the specified buffer. Read more
sourceÂ§fn read_vectored(&mut self, bufs: &mut [IoSliceMut<'_>]) -> Result<usize, Error>
Like read, except that it reads into a slice of buffers. Read more
sourceÂ§fn is_read_vectored(&self) -> bool
ð¬This is a nightly-only experimental API. (can_vector)Determines if this Reader has an efficient read_vectored\nimplementation. Read more
sourceÂ§fn read_to_end(&mut self, buf: &mut Vec<u8>) -> Result<usize, Error>
Read all bytes until EOF in this source, placing them into buf. Read more
sourceÂ§fn read_to_string(&mut self, buf: &mut String) -> Result<usize, Error>
Read all bytes until EOF in this source, appending them to buf. Read more
sourceÂ§fn read_exact(&mut self, buf: &mut [u8]) -> Result<(), Error>
Read the exact number of bytes required to fill buf. Read more
sourceÂ§fn read_buf_exact(&mut self, cursor: BorrowedCursor<'_>) -> Result<(), Error>
ð¬This is a nightly-only experimental API. (read_buf)Read the exact number of bytes required to fill cursor. Read more
1.0.0 Â· sourceÂ§fn by_ref(&mut self) -> &mut Selfwhere\n    Self: Sized,
Creates a âby referenceâ adaptor for this instance of Read. Read more
1.0.0 Â· sourceÂ§fn bytes(self) -> Bytes<Self>where\n    Self: Sized,
Transforms this Read instance to an Iterator over its bytes. Read more
1.0.0 Â· sourceÂ§fn chain<R>(self, next: R) -> Chain<Self, R>where\n    R: Read,\n    Self: Sized,
Creates an adapter which will chain this stream with another. Read more
1.0.0 Â· sourceÂ§fn take(self, limit: u64) -> Take<Self>where\n    Self: Sized,
Creates an adapter which will read at most limit bytes from it. Read more
","Read","bdk_esplora::blocking_ext::Error"],["sourceÂ§impl<R> RngCore for Box<R>where\n    R: RngCore + ?Sized,
sourceÂ§fn next_u32(&mut self) -> u32
Return the next random u32. Read more
sourceÂ§fn next_u64(&mut self) -> u64
Return the next random u64. Read more
sourceÂ§fn fill_bytes(&mut self, dest: &mut [u8])
Fill dest with random data. Read more
sourceÂ§fn try_fill_bytes(&mut self, dest: &mut [u8]) -> Result<(), Error>
Fill dest entirely with random data. Read more
","RngCore","bdk_esplora::blocking_ext::Error"],["1.0.0 Â· sourceÂ§impl<S> Seek for Box<S>where\n    S: Seek + ?Sized,
sourceÂ§fn seek(&mut self, pos: SeekFrom) -> Result<u64, Error>
Seek to an offset, in bytes, in a stream. Read more
sourceÂ§fn stream_position(&mut self) -> Result<u64, Error>
Returns the current seek position from the start of the stream. Read more
1.55.0 Â· sourceÂ§fn rewind(&mut self) -> Result<(), Error>
Rewind to the beginning of a stream. Read more
sourceÂ§fn stream_len(&mut self) -> Result<u64, Error>
ð¬This is a nightly-only experimental API. (seek_stream_len)Returns the length of this stream (in bytes). Read more
sourceÂ§fn seek_relative(&mut self, offset: i64) -> Result<(), Error>
ð¬This is a nightly-only experimental API. (seek_seek_relative)Seeks relative to the current position. Read more
","Seek","bdk_esplora::blocking_ext::Error"],["sourceÂ§impl<T> Serialize for Box<T>where\n    T: Serialize + ?Sized,
sourceÂ§fn serialize<S>(\n    &self,\n    serializer: S\n) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where\n    S: Serializer,
Serialize this value into the given Serde serializer. Read more
","Serialize","bdk_esplora::blocking_ext::Error"],["Â§impl<S, Request> Service<Request> for Box<S>where\n    S: Service<Request> + ?Sized,
Â§type Response = <S as Service<Request>>::Response
Responses given by the service.
Â§type Error = <S as Service<Request>>::Error
Errors produced by the service.
Â§type Future = <S as Service<Request>>::Future
The future response value.
Â§fn poll_ready(\n    &mut self,\n    cx: &mut Context<'_>\n) -> Poll<Result<(), <S as Service<Request>>::Error>>
Returns Poll::Ready(Ok(())) when the service is able to process requests. Read more
Â§fn call(&mut self, request: Request) -> <S as Service<Request>>::Future
Process the request and return the response asynchronously. Read more
","Service","bdk_esplora::blocking_ext::Error"],["Â§impl<S, Item> Sink<Item> for Box<S>where\n    S: Sink<Item> + Unpin + ?Sized,
Â§type Error = <S as Sink<Item>>::Error
The type of value produced by the sink when an error occurs.
Â§fn poll_ready(\n    self: Pin<&mut Box<S>>,\n    cx: &mut Context<'_>\n) -> Poll<Result<(), <Box<S> as Sink<Item>>::Error>>
Attempts to prepare the Sink to receive a value. Read more
Â§fn start_send(\n    self: Pin<&mut Box<S>>,\n    item: Item\n) -> Result<(), <Box<S> as Sink<Item>>::Error>
Begin the process of sending a value to the sink.\nEach call to this function must be preceded by a successful call to\npoll_ready which returned Poll::Ready(Ok(())). Read more
Â§fn poll_flush(\n    self: Pin<&mut Box<S>>,\n    cx: &mut Context<'_>\n) -> Poll<Result<(), <Box<S> as Sink<Item>>::Error>>
Flush any remaining output from this sink. Read more
Â§fn poll_close(\n    self: Pin<&mut Box<S>>,\n    cx: &mut Context<'_>\n) -> Poll<Result<(), <Box<S> as Sink<Item>>::Error>>
Flush any remaining output and close this sink, if necessary. Read more
","Sink","bdk_esplora::blocking_ext::Error"],["Â§impl<T> Source for Box<T>where\n    T: Source + ?Sized,
Â§fn register(\n    &mut self,\n    registry: &Registry,\n    token: Token,\n    interests: Interest\n) -> Result<(), Error>
Register self with the given Registry instance. Read more
Â§fn reregister(\n    &mut self,\n    registry: &Registry,\n    token: Token,\n    interests: Interest\n) -> Result<(), Error>
Re-register self with the given Registry instance. Read more
Â§fn deregister(&mut self, registry: &Registry) -> Result<(), Error>
Deregister self from the given Registry instance. Read more
","Source","bdk_esplora::blocking_ext::Error"],["Â§impl<Sp> Spawn for Box<Sp>where\n    Sp: Spawn + ?Sized,
Â§fn spawn_obj(&self, future: FutureObj<'static, ()>) -> Result<(), SpawnError>
Spawns a future that will be run to completion. Read more
Â§fn status(&self) -> Result<(), SpawnError>
Determines whether the executor is able to spawn new tasks. Read more
","Spawn","bdk_esplora::blocking_ext::Error"],["Â§impl<S> Stream for Box<S>where\n    S: Stream + Unpin + ?Sized,
Â§type Item = <S as Stream>::Item
Values yielded by the stream.
Â§fn poll_next(\n    self: Pin<&mut Box<S>>,\n    cx: &mut Context<'_>\n) -> Poll<Option<<Box<S> as Stream>::Item>>
Attempt to pull out the next value of this stream, registering the\ncurrent task for wakeup if the value is not yet available, and returning\nNone if the stream is exhausted. Read more
Â§fn size_hint(&self) -> (usize, Option<usize>)
Returns the bounds on the remaining length of the stream. Read more
","Stream","bdk_esplora::blocking_ext::Error"],["Â§impl<S> Subscriber for Box<S>where\n    S: Subscriber + ?Sized,
Â§fn register_callsite(&self, metadata: &'static Metadata<'static>) -> Interest
Registers a new callsite with this subscriber, returning whether or not\nthe subscriber is interested in being notified about the callsite. Read more
Â§fn enabled(&self, metadata: &Metadata<'_>) -> bool
Returns true if a span or event with the specified metadata would be\nrecorded. Read more
Â§fn max_level_hint(&self) -> Option<LevelFilter>
Returns the highest verbosity level that this Subscriber will\nenable, or None, if the subscriber does not implement level-based\nfiltering or chooses not to implement this method. Read more
Â§fn new_span(&self, span: &Attributes<'_>) -> Id
Visit the construction of a new span, returning a new span ID for the\nspan being constructed. Read more
Â§fn record(&self, span: &Id, values: &Record<'_>)
Record a set of values on a span. Read more
Â§fn record_follows_from(&self, span: &Id, follows: &Id)
Adds an indication that span follows from the span with the id\nfollows. Read more
Â§fn event_enabled(&self, event: &Event<'_>) -> bool
Determine if an [Event] should be recorded. Read more
Â§fn event(&self, event: &Event<'_>)
Records that an Event has occurred. Read more
Â§fn enter(&self, span: &Id)
Records that a span has been entered. Read more
Â§fn exit(&self, span: &Id)
Records that a span has been exited. Read more
Â§fn clone_span(&self, id: &Id) -> Id
Notifies the subscriber that a span ID has been cloned. Read more
Â§fn try_close(&self, id: Id) -> bool
Notifies the subscriber that a span ID has been dropped, and returns\ntrue if there are now 0 IDs that refer to that span. Read more
Â§fn drop_span(&self, id: Id)
ðDeprecated since 0.1.2: use Subscriber::try_close insteadThis method is deprecated. Read more
Â§fn current_span(&self) -> Current
Returns a type representing this subscriberâs view of the current span. Read more
Â§unsafe fn downcast_raw(&self, id: TypeId) -> Option<*const ()>
If self is the same type as the provided TypeId, returns an untyped\n*const pointer to that type. Otherwise, returns None. Read more
Â§fn on_register_dispatch(&self, subscriber: &Dispatch)
Invoked when this subscriber becomes a [Dispatch]. Read more
","Subscriber","bdk_esplora::blocking_ext::Error"],["Â§impl<T> ToSql for Box<T>where\n    T: ToSql + ?Sized,
Â§fn to_sql(&self) -> Result<ToSqlOutput<'_>, Error>
Converts Rust value to SQLite value
","ToSql","bdk_esplora::blocking_ext::Error"],["Â§impl<'a, T, F> UnsafeFutureObj<'a, T> for Box<F>where\n    F: Future<Output = T> + 'a,
Â§fn into_raw(self) -> *mut dyn Future<Output = T> + 'a
Convert an owned instance into a (conceptually owned) fat pointer. Read more
Â§unsafe fn drop(ptr: *mut dyn Future<Output = T> + 'a)
Drops the future represented by the given fat pointer. Read more
","UnsafeFutureObj<'a, T>","bdk_esplora::blocking_ext::Error"],["Â§impl<T> Value for Box<T>where\n    T: Value + ?Sized,
Â§fn record(&self, key: &Field, visitor: &mut dyn Visit)
Visits this value with the given Visitor.
","Value","bdk_esplora::blocking_ext::Error"],["1.0.0 Â· sourceÂ§impl<W> Write for Box<W>where\n    W: Write + ?Sized,
sourceÂ§fn write(&mut self, buf: &[u8]) -> Result<usize, Error>
Write a buffer into this writer, returning how many bytes were written. Read more
sourceÂ§fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> Result<usize, Error>
Like write, except that it writes from a slice of buffers. Read more
sourceÂ§fn is_write_vectored(&self) -> bool
ð¬This is a nightly-only experimental API. (can_vector)Determines if this Writer has an efficient write_vectored\nimplementation. Read more
sourceÂ§fn flush(&mut self) -> Result<(), Error>
Flush this output stream, ensuring that all intermediately buffered\ncontents reach their destination. Read more
sourceÂ§fn write_all(&mut self, buf: &[u8]) -> Result<(), Error>
Attempts to write an entire buffer into this writer. Read more
sourceÂ§fn write_fmt(&mut self, fmt: Arguments<'_>) -> Result<(), Error>
Writes a formatted string into this writer, returning any error\nencountered. Read more
sourceÂ§fn write_all_vectored(&mut self, bufs: &mut [IoSlice<'_>]) -> Result<(), Error>
ð¬This is a nightly-only experimental API. (write_all_vectored)Attempts to write multiple buffers into this writer. Read more
1.0.0 Â· sourceÂ§fn by_ref(&mut self) -> &mut Selfwhere\n    Self: Sized,
Creates a âby referenceâ adapter for this instance of Write. Read more
","Write","bdk_esplora::blocking_ext::Error"],["sourceÂ§impl<T, U, A> CoerceUnsized<Box<U, A>> for Box<T, A>where\n    T: Unsize<U> + ?Sized,\n    A: Allocator,\n    U: ?Sized,
","CoerceUnsized>","bdk_esplora::blocking_ext::Error"],["sourceÂ§impl<R> CryptoRng for Box<R>where\n    R: CryptoRng + ?Sized,
","CryptoRng","bdk_esplora::blocking_ext::Error"],["sourceÂ§impl<T, A> DerefPure for Box<T, A>where\n    A: Allocator,\n    T: ?Sized,
","DerefPure","bdk_esplora::blocking_ext::Error"],["sourceÂ§impl<T, U> DispatchFromDyn<Box<U>> for Box<T>where\n    T: Unsize<U> + ?Sized,\n    U: ?Sized,
","DispatchFromDyn>","bdk_esplora::blocking_ext::Error"],["1.0.0 Â· sourceÂ§impl<T, A> Eq for Box<T, A>where\n    T: Eq + ?Sized,\n    A: Allocator,
","Eq","bdk_esplora::blocking_ext::Error"],["1.26.0 Â· sourceÂ§impl<I, A> FusedIterator for Box<I, A>where\n    I: FusedIterator + ?Sized,\n    A: Allocator,
","FusedIterator","bdk_esplora::blocking_ext::Error"],["1.33.0 Â· sourceÂ§impl<T, A> Unpin for Box<T, A>where\n    A: Allocator,\n    T: ?Sized,","Unpin","bdk_esplora::blocking_ext::Error"]]
 };if (window.register_type_impls) {window.register_type_impls(type_impls);} else {window.pending_type_impls = type_impls;}})()
\ No newline at end of file
diff --git a/docs/.vuepress/public/docs-rs/bdk/nightly/latest/type.impl/alloc/collections/btree/map/struct.BTreeMap.js b/docs/.vuepress/public/docs-rs/bdk/nightly/latest/type.impl/alloc/collections/btree/map/struct.BTreeMap.js
index ab043738ac..56db538b3f 100644
--- a/docs/.vuepress/public/docs-rs/bdk/nightly/latest/type.impl/alloc/collections/btree/map/struct.BTreeMap.js
+++ b/docs/.vuepress/public/docs-rs/bdk/nightly/latest/type.impl/alloc/collections/btree/map/struct.BTreeMap.js
@@ -1,3 +1,3 @@
 (function() {var type_impls = {
-"bdk_wallet":[["sourceÂ§impl<K, V> BTreeMap<K, V>
1.0.0 (const: 1.66.0) Â· sourcepub const fn new() -> BTreeMap<K, V>
Makes a new, empty BTreeMap.
\nDoes not allocate anything on its own.
\nÂ§Examples
\nuse std::collections::BTreeMap;\n\nlet mut map = BTreeMap::new();\n\n// entries can now be inserted into the empty map\nmap.insert(1, \"a\");
\n
",0,"bdk_wallet::descriptor::policy::ConditionMap","bdk_wallet::descriptor::policy::FoldedConditionMap","bdk_wallet::descriptor::HdKeyPaths","bdk_wallet::descriptor::TapKeyOrigins","bdk_wallet::keys::KeyMap"],["sourceÂ§impl<K, V, A> BTreeMap<K, V, A>where\n    A: Allocator + Clone,
1.0.0 Â· sourcepub fn iter(&self) -> Iter<'_, K, V>
Gets an iterator over the entries of the map, sorted by key.
\nÂ§Examples
\nuse std::collections::BTreeMap;\n\nlet mut map = BTreeMap::new();\nmap.insert(3, \"c\");\nmap.insert(2, \"b\");\nmap.insert(1, \"a\");\n\nfor (key, value) in map.iter() {\n    println!(\"{key}: {value}\");\n}\n\nlet (first_key, first_value) = map.iter().next().unwrap();\nassert_eq!((*first_key, *first_value), (1, \"a\"));
\n
1.0.0 Â· sourcepub fn iter_mut(&mut self) -> IterMut<'_, K, V>
Gets a mutable iterator over the entries of the map, sorted by key.
\nÂ§Examples
\nuse std::collections::BTreeMap;\n\nlet mut map = BTreeMap::from([\n   (\"a\", 1),\n   (\"b\", 2),\n   (\"c\", 3),\n]);\n\n// add 10 to the value if the key isn't \"a\"\nfor (key, value) in map.iter_mut() {\n    if key != &\"a\" {\n        *value += 10;\n    }\n}
\n
1.0.0 Â· sourcepub fn keys(&self) -> Keys<'_, K, V>
Gets an iterator over the keys of the map, in sorted order.
\nÂ§Examples
\nuse std::collections::BTreeMap;\n\nlet mut a = BTreeMap::new();\na.insert(2, \"b\");\na.insert(1, \"a\");\n\nlet keys: Vec<_> = a.keys().cloned().collect();\nassert_eq!(keys, [1, 2]);
\n
1.0.0 Â· sourcepub fn values(&self) -> Values<'_, K, V>
Gets an iterator over the values of the map, in order by key.
\nÂ§Examples
\nuse std::collections::BTreeMap;\n\nlet mut a = BTreeMap::new();\na.insert(1, \"hello\");\na.insert(2, \"goodbye\");\n\nlet values: Vec<&str> = a.values().cloned().collect();\nassert_eq!(values, [\"hello\", \"goodbye\"]);
\n
1.10.0 Â· sourcepub fn values_mut(&mut self) -> ValuesMut<'_, K, V>
Gets a mutable iterator over the values of the map, in order by key.
\nÂ§Examples
\nuse std::collections::BTreeMap;\n\nlet mut a = BTreeMap::new();\na.insert(1, String::from(\"hello\"));\na.insert(2, String::from(\"goodbye\"));\n\nfor value in a.values_mut() {\n    value.push_str(\"!\");\n}\n\nlet values: Vec<String> = a.values().cloned().collect();\nassert_eq!(values, [String::from(\"hello!\"),\n                    String::from(\"goodbye!\")]);
\n
1.0.0 (const: unstable) Â· sourcepub fn len(&self) -> usize
Returns the number of elements in the map.
\nÂ§Examples
\nuse std::collections::BTreeMap;\n\nlet mut a = BTreeMap::new();\nassert_eq!(a.len(), 0);\na.insert(1, \"a\");\nassert_eq!(a.len(), 1);
\n
1.0.0 (const: unstable) Â· sourcepub fn is_empty(&self) -> bool
Returns true if the map contains no elements.
\nÂ§Examples
\nuse std::collections::BTreeMap;\n\nlet mut a = BTreeMap::new();\nassert!(a.is_empty());\na.insert(1, \"a\");\nassert!(!a.is_empty());
\n
sourcepub fn lower_bound<Q>(&self, bound: Bound<&Q>) -> Cursor<'_, K, V>where\n    K: Borrow<Q> + Ord,\n    Q: Ord + ?Sized,
ð¬This is a nightly-only experimental API. (btree_cursors)
Returns a Cursor pointing at the gap before the smallest key\ngreater than the given bound.
\nPassing Bound::Included(x) will return a cursor pointing to the\ngap before the smallest key greater than or equal to x.
\nPassing Bound::Excluded(x) will return a cursor pointing to the\ngap before the smallest key greater than x.
\nPassing Bound::Unbounded will return a cursor pointing to the\ngap before the smallest key in the map.
\nÂ§Examples
\n#![feature(btree_cursors)]\n\nuse std::collections::BTreeMap;\nuse std::ops::Bound;\n\nlet map = BTreeMap::from([\n    (1, \"a\"),\n    (2, \"b\"),\n    (3, \"c\"),\n    (4, \"d\"),\n]);\n\nlet cursor = map.lower_bound(Bound::Included(&2));\nassert_eq!(cursor.peek_prev(), Some((&1, &\"a\")));\nassert_eq!(cursor.peek_next(), Some((&2, &\"b\")));\n\nlet cursor = map.lower_bound(Bound::Excluded(&2));\nassert_eq!(cursor.peek_prev(), Some((&2, &\"b\")));\nassert_eq!(cursor.peek_next(), Some((&3, &\"c\")));\n\nlet cursor = map.lower_bound(Bound::Unbounded);\nassert_eq!(cursor.peek_prev(), None);\nassert_eq!(cursor.peek_next(), Some((&1, &\"a\")));
\n
sourcepub fn lower_bound_mut<Q>(&mut self, bound: Bound<&Q>) -> CursorMut<'_, K, V, A>where\n    K: Borrow<Q> + Ord,\n    Q: Ord + ?Sized,
ð¬This is a nightly-only experimental API. (btree_cursors)
Returns a CursorMut pointing at the gap before the smallest key\ngreater than the given bound.
\nPassing Bound::Included(x) will return a cursor pointing to the\ngap before the smallest key greater than or equal to x.
\nPassing Bound::Excluded(x) will return a cursor pointing to the\ngap before the smallest key greater than x.
\nPassing Bound::Unbounded will return a cursor pointing to the\ngap before the smallest key in the map.
\nÂ§Examples
\n#![feature(btree_cursors)]\n\nuse std::collections::BTreeMap;\nuse std::ops::Bound;\n\nlet mut map = BTreeMap::from([\n    (1, \"a\"),\n    (2, \"b\"),\n    (3, \"c\"),\n    (4, \"d\"),\n]);\n\nlet mut cursor = map.lower_bound_mut(Bound::Included(&2));\nassert_eq!(cursor.peek_prev(), Some((&1, &mut \"a\")));\nassert_eq!(cursor.peek_next(), Some((&2, &mut \"b\")));\n\nlet mut cursor = map.lower_bound_mut(Bound::Excluded(&2));\nassert_eq!(cursor.peek_prev(), Some((&2, &mut \"b\")));\nassert_eq!(cursor.peek_next(), Some((&3, &mut \"c\")));\n\nlet mut cursor = map.lower_bound_mut(Bound::Unbounded);\nassert_eq!(cursor.peek_prev(), None);\nassert_eq!(cursor.peek_next(), Some((&1, &mut \"a\")));
\n
sourcepub fn upper_bound<Q>(&self, bound: Bound<&Q>) -> Cursor<'_, K, V>where\n    K: Borrow<Q> + Ord,\n    Q: Ord + ?Sized,
ð¬This is a nightly-only experimental API. (btree_cursors)
Returns a Cursor pointing at the gap after the greatest key\nsmaller than the given bound.
\nPassing Bound::Included(x) will return a cursor pointing to the\ngap after the greatest key smaller than or equal to x.
\nPassing Bound::Excluded(x) will return a cursor pointing to the\ngap after the greatest key smaller than x.
\nPassing Bound::Unbounded will return a cursor pointing to the\ngap after the greatest key in the map.
\nÂ§Examples
\n#![feature(btree_cursors)]\n\nuse std::collections::BTreeMap;\nuse std::ops::Bound;\n\nlet map = BTreeMap::from([\n    (1, \"a\"),\n    (2, \"b\"),\n    (3, \"c\"),\n    (4, \"d\"),\n]);\n\nlet cursor = map.upper_bound(Bound::Included(&3));\nassert_eq!(cursor.peek_prev(), Some((&3, &\"c\")));\nassert_eq!(cursor.peek_next(), Some((&4, &\"d\")));\n\nlet cursor = map.upper_bound(Bound::Excluded(&3));\nassert_eq!(cursor.peek_prev(), Some((&2, &\"b\")));\nassert_eq!(cursor.peek_next(), Some((&3, &\"c\")));\n\nlet cursor = map.upper_bound(Bound::Unbounded);\nassert_eq!(cursor.peek_prev(), Some((&4, &\"d\")));\nassert_eq!(cursor.peek_next(), None);
\n
sourcepub fn upper_bound_mut<Q>(&mut self, bound: Bound<&Q>) -> CursorMut<'_, K, V, A>where\n    K: Borrow<Q> + Ord,\n    Q: Ord + ?Sized,
ð¬This is a nightly-only experimental API. (btree_cursors)
Returns a CursorMut pointing at the gap after the greatest key\nsmaller than the given bound.
\nPassing Bound::Included(x) will return a cursor pointing to the\ngap after the greatest key smaller than or equal to x.
\nPassing Bound::Excluded(x) will return a cursor pointing to the\ngap after the greatest key smaller than x.
\nPassing Bound::Unbounded will return a cursor pointing to the\ngap after the greatest key in the map.
\nÂ§Examples
\n#![feature(btree_cursors)]\n\nuse std::collections::BTreeMap;\nuse std::ops::Bound;\n\nlet mut map = BTreeMap::from([\n    (1, \"a\"),\n    (2, \"b\"),\n    (3, \"c\"),\n    (4, \"d\"),\n]);\n\nlet mut cursor = map.upper_bound_mut(Bound::Included(&3));\nassert_eq!(cursor.peek_prev(), Some((&3, &mut \"c\")));\nassert_eq!(cursor.peek_next(), Some((&4, &mut \"d\")));\n\nlet mut cursor = map.upper_bound_mut(Bound::Excluded(&3));\nassert_eq!(cursor.peek_prev(), Some((&2, &mut \"b\")));\nassert_eq!(cursor.peek_next(), Some((&3, &mut \"c\")));\n\nlet mut cursor = map.upper_bound_mut(Bound::Unbounded);\nassert_eq!(cursor.peek_prev(), Some((&4, &mut \"d\")));\nassert_eq!(cursor.peek_next(), None);
\n
",0,"bdk_wallet::descriptor::policy::ConditionMap","bdk_wallet::descriptor::policy::FoldedConditionMap","bdk_wallet::descriptor::HdKeyPaths","bdk_wallet::descriptor::TapKeyOrigins","bdk_wallet::keys::KeyMap"],["sourceÂ§impl<K, V, A> BTreeMap<K, V, A>where\n    A: Allocator + Clone,
1.0.0 Â· sourcepub fn clear(&mut self)
Clears the map, removing all elements.
\nÂ§Examples
\nuse std::collections::BTreeMap;\n\nlet mut a = BTreeMap::new();\na.insert(1, \"a\");\na.clear();\nassert!(a.is_empty());
\n
sourcepub const fn new_in(alloc: A) -> BTreeMap<K, V, A>
ð¬This is a nightly-only experimental API. (btreemap_alloc)
Makes a new empty BTreeMap with a reasonable choice for B.
\nÂ§Examples
\nuse std::collections::BTreeMap;\nuse std::alloc::Global;\n\nlet mut map = BTreeMap::new_in(Global);\n\n// entries can now be inserted into the empty map\nmap.insert(1, \"a\");
\n
",0,"bdk_wallet::descriptor::policy::ConditionMap","bdk_wallet::descriptor::policy::FoldedConditionMap","bdk_wallet::descriptor::HdKeyPaths","bdk_wallet::descriptor::TapKeyOrigins","bdk_wallet::keys::KeyMap"],["sourceÂ§impl<K, V, A> BTreeMap<K, V, A>where\n    A: Allocator + Clone,
1.0.0 Â· sourcepub fn get<Q>(&self, key: &Q) -> Option<&V>where\n    K: Borrow<Q> + Ord,\n    Q: Ord + ?Sized,
Returns a reference to the value corresponding to the key.
\nThe key may be any borrowed form of the mapâs key type, but the ordering\non the borrowed form must match the ordering on the key type.
\nÂ§Examples
\nuse std::collections::BTreeMap;\n\nlet mut map = BTreeMap::new();\nmap.insert(1, \"a\");\nassert_eq!(map.get(&1), Some(&\"a\"));\nassert_eq!(map.get(&2), None);
\n
1.40.0 Â· sourcepub fn get_key_value<Q>(&self, k: &Q) -> Option<(&K, &V)>where\n    K: Borrow<Q> + Ord,\n    Q: Ord + ?Sized,
Returns the key-value pair corresponding to the supplied key.
\nThe supplied key may be any borrowed form of the mapâs key type, but the ordering\non the borrowed form must match the ordering on the key type.
\nÂ§Examples
\nuse std::collections::BTreeMap;\n\nlet mut map = BTreeMap::new();\nmap.insert(1, \"a\");\nassert_eq!(map.get_key_value(&1), Some((&1, &\"a\")));\nassert_eq!(map.get_key_value(&2), None);
\n
1.66.0 Â· sourcepub fn first_key_value(&self) -> Option<(&K, &V)>where\n    K: Ord,
Returns the first key-value pair in the map.\nThe key in this pair is the minimum key in the map.
\nÂ§Examples
\nuse std::collections::BTreeMap;\n\nlet mut map = BTreeMap::new();\nassert_eq!(map.first_key_value(), None);\nmap.insert(1, \"b\");\nmap.insert(2, \"a\");\nassert_eq!(map.first_key_value(), Some((&1, &\"b\")));
\n
1.66.0 Â· sourcepub fn first_entry(&mut self) -> Option<OccupiedEntry<'_, K, V, A>>where\n    K: Ord,
Returns the first entry in the map for in-place manipulation.\nThe key of this entry is the minimum key in the map.
\nÂ§Examples
\nuse std::collections::BTreeMap;\n\nlet mut map = BTreeMap::new();\nmap.insert(1, \"a\");\nmap.insert(2, \"b\");\nif let Some(mut entry) = map.first_entry() {\n    if *entry.key() > 0 {\n        entry.insert(\"first\");\n    }\n}\nassert_eq!(*map.get(&1).unwrap(), \"first\");\nassert_eq!(*map.get(&2).unwrap(), \"b\");
\n
1.66.0 Â· sourcepub fn pop_first(&mut self) -> Option<(K, V)>where\n    K: Ord,
Removes and returns the first element in the map.\nThe key of this element is the minimum key that was in the map.
\nÂ§Examples
\nDraining elements in ascending order, while keeping a usable map each iteration.
\n\nuse std::collections::BTreeMap;\n\nlet mut map = BTreeMap::new();\nmap.insert(1, \"a\");\nmap.insert(2, \"b\");\nwhile let Some((key, _val)) = map.pop_first() {\n    assert!(map.iter().all(|(k, _v)| *k > key));\n}\nassert!(map.is_empty());
\n
1.66.0 Â· sourcepub fn last_key_value(&self) -> Option<(&K, &V)>where\n    K: Ord,
Returns the last key-value pair in the map.\nThe key in this pair is the maximum key in the map.
\nÂ§Examples
\nuse std::collections::BTreeMap;\n\nlet mut map = BTreeMap::new();\nmap.insert(1, \"b\");\nmap.insert(2, \"a\");\nassert_eq!(map.last_key_value(), Some((&2, &\"a\")));
\n
1.66.0 Â· sourcepub fn last_entry(&mut self) -> Option<OccupiedEntry<'_, K, V, A>>where\n    K: Ord,
Returns the last entry in the map for in-place manipulation.\nThe key of this entry is the maximum key in the map.
\nÂ§Examples
\nuse std::collections::BTreeMap;\n\nlet mut map = BTreeMap::new();\nmap.insert(1, \"a\");\nmap.insert(2, \"b\");\nif let Some(mut entry) = map.last_entry() {\n    if *entry.key() > 0 {\n        entry.insert(\"last\");\n    }\n}\nassert_eq!(*map.get(&1).unwrap(), \"a\");\nassert_eq!(*map.get(&2).unwrap(), \"last\");
\n
1.66.0 Â· sourcepub fn pop_last(&mut self) -> Option<(K, V)>where\n    K: Ord,
Removes and returns the last element in the map.\nThe key of this element is the maximum key that was in the map.
\nÂ§Examples
\nDraining elements in descending order, while keeping a usable map each iteration.
\n\nuse std::collections::BTreeMap;\n\nlet mut map = BTreeMap::new();\nmap.insert(1, \"a\");\nmap.insert(2, \"b\");\nwhile let Some((key, _val)) = map.pop_last() {\n    assert!(map.iter().all(|(k, _v)| *k < key));\n}\nassert!(map.is_empty());
\n
1.0.0 Â· sourcepub fn contains_key<Q>(&self, key: &Q) -> boolwhere\n    K: Borrow<Q> + Ord,\n    Q: Ord + ?Sized,
Returns true if the map contains a value for the specified key.
\nThe key may be any borrowed form of the mapâs key type, but the ordering\non the borrowed form must match the ordering on the key type.
\nÂ§Examples
\nuse std::collections::BTreeMap;\n\nlet mut map = BTreeMap::new();\nmap.insert(1, \"a\");\nassert_eq!(map.contains_key(&1), true);\nassert_eq!(map.contains_key(&2), false);
\n
1.0.0 Â· sourcepub fn get_mut<Q>(&mut self, key: &Q) -> Option<&mut V>where\n    K: Borrow<Q> + Ord,\n    Q: Ord + ?Sized,
Returns a mutable reference to the value corresponding to the key.
\nThe key may be any borrowed form of the mapâs key type, but the ordering\non the borrowed form must match the ordering on the key type.
\nÂ§Examples
\nuse std::collections::BTreeMap;\n\nlet mut map = BTreeMap::new();\nmap.insert(1, \"a\");\nif let Some(x) = map.get_mut(&1) {\n    *x = \"b\";\n}\nassert_eq!(map[&1], \"b\");
\n
1.0.0 Â· sourcepub fn insert(&mut self, key: K, value: V) -> Option<V>where\n    K: Ord,
Inserts a key-value pair into the map.
\nIf the map did not have this key present, None is returned.
\nIf 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 == without being identical. See the module-level\ndocumentation for more.
\nÂ§Examples
\nuse std::collections::BTreeMap;\n\nlet mut map = BTreeMap::new();\nassert_eq!(map.insert(37, \"a\"), None);\nassert_eq!(map.is_empty(), false);\n\nmap.insert(37, \"b\");\nassert_eq!(map.insert(37, \"c\"), Some(\"b\"));\nassert_eq!(map[&37], \"c\");
\n
sourcepub fn try_insert(\n    &mut self,\n    key: K,\n    value: V\n) -> Result<&mut V, OccupiedError<'_, K, V, A>>where\n    K: Ord,
ð¬This is a nightly-only experimental API. (map_try_insert)
Tries to insert a key-value pair into the map, and returns\na mutable reference to the value in the entry.
\nIf the map already had this key present, nothing is updated, and\nan error containing the occupied entry and the value is returned.
\nÂ§Examples
\n#![feature(map_try_insert)]\n\nuse std::collections::BTreeMap;\n\nlet mut map = BTreeMap::new();\nassert_eq!(map.try_insert(37, \"a\").unwrap(), &\"a\");\n\nlet err = map.try_insert(37, \"b\").unwrap_err();\nassert_eq!(err.entry.key(), &37);\nassert_eq!(err.entry.get(), &\"a\");\nassert_eq!(err.value, \"b\");
\n
1.0.0 Â· sourcepub fn remove<Q>(&mut self, key: &Q) -> Option<V>where\n    K: Borrow<Q> + Ord,\n    Q: Ord + ?Sized,
Removes a key from the map, returning the value at the key if the key\nwas previously in the map.
\nThe key may be any borrowed form of the mapâs key type, but the ordering\non the borrowed form must match the ordering on the key type.
\nÂ§Examples
\nuse std::collections::BTreeMap;\n\nlet mut map = BTreeMap::new();\nmap.insert(1, \"a\");\nassert_eq!(map.remove(&1), Some(\"a\"));\nassert_eq!(map.remove(&1), None);
\n
1.45.0 Â· sourcepub fn remove_entry<Q>(&mut self, key: &Q) -> Option<(K, V)>where\n    K: Borrow<Q> + Ord,\n    Q: Ord + ?Sized,
Removes a key from the map, returning the stored key and value if the key\nwas previously in the map.
\nThe key may be any borrowed form of the mapâs key type, but the ordering\non the borrowed form must match the ordering on the key type.
\nÂ§Examples
\nuse std::collections::BTreeMap;\n\nlet mut map = BTreeMap::new();\nmap.insert(1, \"a\");\nassert_eq!(map.remove_entry(&1), Some((1, \"a\")));\nassert_eq!(map.remove_entry(&1), None);
\n
1.53.0 Â· sourcepub fn retain<F>(&mut self, f: F)where\n    K: Ord,\n    F: FnMut(&K, &mut V) -> bool,
Retains only the elements specified by the predicate.
\nIn other words, remove all pairs (k, v) for which f(&k, &mut v) returns false.\nThe elements are visited in ascending key order.
\nÂ§Examples
\nuse std::collections::BTreeMap;\n\nlet mut map: BTreeMap<i32, i32> = (0..8).map(|x| (x, x*10)).collect();\n// Keep only the elements with even-numbered keys.\nmap.retain(|&k, _| k % 2 == 0);\nassert!(map.into_iter().eq(vec![(0, 0), (2, 20), (4, 40), (6, 60)]));
\n
1.11.0 Â· sourcepub fn append(&mut self, other: &mut BTreeMap<K, V, A>)where\n    K: Ord,\n    A: Clone,
Moves all elements from other into self, leaving other empty.
\nIf a key from other is already present in self, the respective\nvalue from self will be overwritten with the respective value from other.
\nÂ§Examples
\nuse std::collections::BTreeMap;\n\nlet mut a = BTreeMap::new();\na.insert(1, \"a\");\na.insert(2, \"b\");\na.insert(3, \"c\"); // Note: Key (3) also present in b.\n\nlet mut b = BTreeMap::new();\nb.insert(3, \"d\"); // Note: Key (3) also present in a.\nb.insert(4, \"e\");\nb.insert(5, \"f\");\n\na.append(&mut b);\n\nassert_eq!(a.len(), 5);\nassert_eq!(b.len(), 0);\n\nassert_eq!(a[&1], \"a\");\nassert_eq!(a[&2], \"b\");\nassert_eq!(a[&3], \"d\"); // Note: \"c\" has been overwritten.\nassert_eq!(a[&4], \"e\");\nassert_eq!(a[&5], \"f\");
\n
1.17.0 Â· sourcepub fn range<T, R>(&self, range: R) -> Range<'_, K, V>where\n    T: Ord + ?Sized,\n    K: Borrow<T> + Ord,\n    R: RangeBounds<T>,
Constructs a double-ended iterator over a sub-range of elements in the map.\nThe simplest way is to use the range syntax min..max, thus range(min..max) will\nyield elements from min (inclusive) to max (exclusive).\nThe range may also be entered as (Bound<T>, Bound<T>), so for example\nrange((Excluded(4), Included(10))) will yield a left-exclusive, right-inclusive\nrange from 4 to 10.
\nÂ§Panics
\nPanics if range start > end.\nPanics if range start == end and both bounds are Excluded.
\nÂ§Examples
\nuse std::collections::BTreeMap;\nuse std::ops::Bound::Included;\n\nlet mut map = BTreeMap::new();\nmap.insert(3, \"a\");\nmap.insert(5, \"b\");\nmap.insert(8, \"c\");\nfor (&key, &value) in map.range((Included(&4), Included(&8))) {\n    println!(\"{key}: {value}\");\n}\nassert_eq!(Some((&5, &\"b\")), map.range(4..).next());
\n
1.17.0 Â· sourcepub fn range_mut<T, R>(&mut self, range: R) -> RangeMut<'_, K, V>where\n    T: Ord + ?Sized,\n    K: Borrow<T> + Ord,\n    R: RangeBounds<T>,
Constructs a mutable double-ended iterator over a sub-range of elements in the map.\nThe simplest way is to use the range syntax min..max, thus range(min..max) will\nyield elements from min (inclusive) to max (exclusive).\nThe range may also be entered as (Bound<T>, Bound<T>), so for example\nrange((Excluded(4), Included(10))) will yield a left-exclusive, right-inclusive\nrange from 4 to 10.
\nÂ§Panics
\nPanics if range start > end.\nPanics if range start == end and both bounds are Excluded.
\nÂ§Examples
\nuse std::collections::BTreeMap;\n\nlet mut map: BTreeMap<&str, i32> =\n    [(\"Alice\", 0), (\"Bob\", 0), (\"Carol\", 0), (\"Cheryl\", 0)].into();\nfor (_, balance) in map.range_mut(\"B\"..\"Cheryl\") {\n    *balance += 100;\n}\nfor (name, balance) in &map {\n    println!(\"{name} => {balance}\");\n}
\n
1.0.0 Â· sourcepub fn entry(&mut self, key: K) -> Entry<'_, K, V, A>where\n    K: Ord,
Gets the given keyâs corresponding entry in the map for in-place manipulation.
\nÂ§Examples
\nuse std::collections::BTreeMap;\n\nlet mut count: BTreeMap<&str, usize> = BTreeMap::new();\n\n// count the number of occurrences of letters in the vec\nfor x in [\"a\", \"b\", \"a\", \"c\", \"a\", \"b\"] {\n    count.entry(x).and_modify(|curr| *curr += 1).or_insert(1);\n}\n\nassert_eq!(count[\"a\"], 3);\nassert_eq!(count[\"b\"], 2);\nassert_eq!(count[\"c\"], 1);
\n
1.11.0 Â· sourcepub fn split_off<Q>(&mut self, key: &Q) -> BTreeMap<K, V, A>where\n    Q: Ord + ?Sized,\n    K: Borrow<Q> + Ord,\n    A: Clone,
Splits the collection into two at the given key. Returns everything after the given key,\nincluding the key.
\nÂ§Examples
\nuse std::collections::BTreeMap;\n\nlet mut a = BTreeMap::new();\na.insert(1, \"a\");\na.insert(2, \"b\");\na.insert(3, \"c\");\na.insert(17, \"d\");\na.insert(41, \"e\");\n\nlet b = a.split_off(&3);\n\nassert_eq!(a.len(), 2);\nassert_eq!(b.len(), 3);\n\nassert_eq!(a[&1], \"a\");\nassert_eq!(a[&2], \"b\");\n\nassert_eq!(b[&3], \"c\");\nassert_eq!(b[&17], \"d\");\nassert_eq!(b[&41], \"e\");
\n
sourcepub fn extract_if<F>(&mut self, pred: F) -> ExtractIf<'_, K, V, F, A>where\n    K: Ord,\n    F: FnMut(&K, &mut V) -> bool,
ð¬This is a nightly-only experimental API. (btree_extract_if)
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 true, the element is removed from\nthe map and yielded. If the closure returns false, or panics, the\nelement remains in the map and will not be yielded.
\nThe iterator also lets you mutate the value of each element in the\nclosure, regardless of whether you choose to keep or remove it.
\nIf the returned ExtractIf is not exhausted, e.g. because it is dropped without iterating\nor the iteration short-circuits, then the remaining elements will be retained.\nUse retain with a negated predicate if you do not need the returned iterator.
\nÂ§Examples
\nSplitting a map into even and odd keys, reusing the original map:
\n\n#![feature(btree_extract_if)]\nuse std::collections::BTreeMap;\n\nlet mut map: BTreeMap<i32, i32> = (0..8).map(|x| (x, x)).collect();\nlet evens: BTreeMap<_, _> = map.extract_if(|k, _v| k % 2 == 0).collect();\nlet odds = map;\nassert_eq!(evens.keys().copied().collect::<Vec<_>>(), [0, 2, 4, 6]);\nassert_eq!(odds.keys().copied().collect::<Vec<_>>(), [1, 3, 5, 7]);
\n
1.54.0 Â· sourcepub fn into_keys(self) -> IntoKeys<K, V, A>
Creates a consuming iterator visiting all the keys, in sorted order.\nThe map cannot be used after calling this.\nThe iterator element type is K.
\nÂ§Examples
\nuse std::collections::BTreeMap;\n\nlet mut a = BTreeMap::new();\na.insert(2, \"b\");\na.insert(1, \"a\");\n\nlet keys: Vec<i32> = a.into_keys().collect();\nassert_eq!(keys, [1, 2]);
\n
1.54.0 Â· sourcepub fn into_values(self) -> IntoValues<K, V, A>
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 V.
\nÂ§Examples
\nuse std::collections::BTreeMap;\n\nlet mut a = BTreeMap::new();\na.insert(1, \"hello\");\na.insert(2, \"goodbye\");\n\nlet values: Vec<&str> = a.into_values().collect();\nassert_eq!(values, [\"hello\", \"goodbye\"]);
\n
",0,"bdk_wallet::descriptor::policy::ConditionMap","bdk_wallet::descriptor::policy::FoldedConditionMap","bdk_wallet::descriptor::HdKeyPaths","bdk_wallet::descriptor::TapKeyOrigins","bdk_wallet::keys::KeyMap"],["1.0.0 Â· sourceÂ§impl<K, V, A> Clone for BTreeMap<K, V, A>where\n    K: Clone,\n    V: Clone,\n    A: Allocator + Clone,
sourceÂ§fn clone(&self) -> BTreeMap<K, V, A>
Returns a copy of the value. Read more
1.0.0 Â· sourceÂ§fn clone_from(&mut self, source: &Self)
Performs copy-assignment from source. Read more
","Clone","bdk_wallet::descriptor::policy::ConditionMap","bdk_wallet::descriptor::policy::FoldedConditionMap","bdk_wallet::descriptor::HdKeyPaths","bdk_wallet::descriptor::TapKeyOrigins","bdk_wallet::keys::KeyMap"],["1.0.0 Â· sourceÂ§impl<K, V, A> Debug for BTreeMap<K, V, A>where\n    K: Debug,\n    V: Debug,\n    A: Allocator + Clone,
sourceÂ§fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>
Formats the value using the given formatter. Read more
","Debug","bdk_wallet::descriptor::policy::ConditionMap","bdk_wallet::descriptor::policy::FoldedConditionMap","bdk_wallet::descriptor::HdKeyPaths","bdk_wallet::descriptor::TapKeyOrigins","bdk_wallet::keys::KeyMap"],["1.0.0 Â· sourceÂ§impl<K, V> Default for BTreeMap<K, V>
sourceÂ§fn default() -> BTreeMap<K, V>
Creates an empty BTreeMap.
\n
","Default","bdk_wallet::descriptor::policy::ConditionMap","bdk_wallet::descriptor::policy::FoldedConditionMap","bdk_wallet::descriptor::HdKeyPaths","bdk_wallet::descriptor::TapKeyOrigins","bdk_wallet::keys::KeyMap"],["sourceÂ§impl<'de, K, V> Deserialize<'de> for BTreeMap<K, V>where\n    K: Deserialize<'de> + Ord,\n    V: Deserialize<'de>,
sourceÂ§fn deserialize<D>(\n    deserializer: D\n) -> Result<BTreeMap<K, V>, <D as Deserializer<'de>>::Error>where\n    D: Deserializer<'de>,
Deserialize this value from the given Serde deserializer. Read more
","Deserialize<'de>","bdk_wallet::descriptor::policy::ConditionMap","bdk_wallet::descriptor::policy::FoldedConditionMap","bdk_wallet::descriptor::HdKeyPaths","bdk_wallet::descriptor::TapKeyOrigins","bdk_wallet::keys::KeyMap"],["1.7.0 Â· sourceÂ§impl<K, V, A> Drop for BTreeMap<K, V, A>where\n    A: Allocator + Clone,
sourceÂ§fn drop(&mut self)
Executes the destructor for this type. Read more
","Drop","bdk_wallet::descriptor::policy::ConditionMap","bdk_wallet::descriptor::policy::FoldedConditionMap","bdk_wallet::descriptor::HdKeyPaths","bdk_wallet::descriptor::TapKeyOrigins","bdk_wallet::keys::KeyMap"],["1.2.0 Â· sourceÂ§impl<'a, K, V, A> Extend<(&'a K, &'a V)> for BTreeMap<K, V, A>where\n    K: Ord + Copy,\n    V: Copy,\n    A: Allocator + Clone,
sourceÂ§fn extend<I>(&mut self, iter: I)where\n    I: IntoIterator<Item = (&'a K, &'a V)>,
Extends a collection with the contents of an iterator. Read more
sourceÂ§fn extend_one(&mut self, _: (&'a K, &'a V))
ð¬This is a nightly-only experimental API. (extend_one)Extends a collection with exactly one element.
sourceÂ§fn extend_reserve(&mut self, additional: usize)
ð¬This is a nightly-only experimental API. (extend_one)Reserves capacity in a collection for the given number of additional elements. Read more
","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"],["1.0.0 Â· sourceÂ§impl<K, V, A> Extend<(K, V)> for BTreeMap<K, V, A>where\n    K: Ord,\n    A: Allocator + Clone,
sourceÂ§fn extend<T>(&mut self, iter: T)where\n    T: IntoIterator<Item = (K, V)>,
Extends a collection with the contents of an iterator. Read more
sourceÂ§fn extend_one(&mut self, _: (K, V))
ð¬This is a nightly-only experimental API. (extend_one)Extends a collection with exactly one element.
sourceÂ§fn extend_reserve(&mut self, additional: usize)
ð¬This is a nightly-only experimental API. (extend_one)Reserves capacity in a collection for the given number of additional elements. Read more
","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"],["1.56.0 Â· sourceÂ§impl<K, V, const N: usize> From<[(K, V); N]> for BTreeMap<K, V>where\n    K: Ord,
sourceÂ§fn from(arr: [(K, V); N]) -> BTreeMap<K, V>
Converts a [(K, V); N] into a BTreeMap<(K, V)>.
\n\nuse std::collections::BTreeMap;\n\nlet map1 = BTreeMap::from([(1, 2), (3, 4)]);\nlet map2: BTreeMap<_, _> = [(1, 2), (3, 4)].into();\nassert_eq!(map1, map2);
\n
","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"],["1.0.0 Â· sourceÂ§impl<K, V> FromIterator<(K, V)> for BTreeMap<K, V>where\n    K: Ord,
sourceÂ§fn from_iter<T>(iter: T) -> BTreeMap<K, V>where\n    T: IntoIterator<Item = (K, V)>,
Creates a value from an iterator. Read more
","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"],["1.0.0 Â· sourceÂ§impl<K, V, A> Hash for BTreeMap<K, V, A>where\n    K: Hash,\n    V: Hash,\n    A: Allocator + Clone,
sourceÂ§fn hash<H>(&self, state: &mut H)where\n    H: Hasher,
Feeds this value into the given Hasher. Read more
1.3.0 Â· sourceÂ§fn hash_slice<H>(data: &[Self], state: &mut H)where\n    H: Hasher,\n    Self: Sized,
Feeds a slice of this type into the given Hasher. Read more
","Hash","bdk_wallet::descriptor::policy::ConditionMap","bdk_wallet::descriptor::policy::FoldedConditionMap","bdk_wallet::descriptor::HdKeyPaths","bdk_wallet::descriptor::TapKeyOrigins","bdk_wallet::keys::KeyMap"],["1.0.0 Â· sourceÂ§impl<K, Q, V, A> Index<&Q> for BTreeMap<K, V, A>where\n    A: Allocator + Clone,\n    K: Borrow<Q> + Ord,\n    Q: Ord + ?Sized,
sourceÂ§fn index(&self, key: &Q) -> &V
Returns a reference to the value corresponding to the supplied key.
\nÂ§Panics
\nPanics if the key is not present in the BTreeMap.
\n
Â§type Output = V
The returned type after indexing.
","Index<&Q>","bdk_wallet::descriptor::policy::ConditionMap","bdk_wallet::descriptor::policy::FoldedConditionMap","bdk_wallet::descriptor::HdKeyPaths","bdk_wallet::descriptor::TapKeyOrigins","bdk_wallet::keys::KeyMap"],["Â§impl IntoAssets for BTreeMap<DescriptorPublicKey, DescriptorSecretKey>
Â§fn into_assets(self) -> Assets
Convert self into a Assets struct
","IntoAssets","bdk_wallet::keys::KeyMap"],["sourceÂ§impl<'de, K, V, E> IntoDeserializer<'de, E> for BTreeMap<K, V>where\n    K: IntoDeserializer<'de, E> + Eq + Ord,\n    V: IntoDeserializer<'de, E>,\n    E: Error,
Â§type Deserializer = MapDeserializer<'de, <BTreeMap<K, V> as IntoIterator>::IntoIter, E>
The type of the deserializer being converted into.
sourceÂ§fn into_deserializer(\n    self\n) -> <BTreeMap<K, V> as IntoDeserializer<'de, E>>::Deserializer
Convert this value into a deserializer.
","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"],["1.0.0 Â· sourceÂ§impl<K, V, A> IntoIterator for BTreeMap<K, V, A>where\n    A: Allocator + Clone,
sourceÂ§fn into_iter(self) -> IntoIter<K, V, A>
Gets an owning iterator over the entries of the map, sorted by key.
\n
Â§type Item = (K, V)
The type of the elements being iterated over.
Â§type IntoIter = IntoIter<K, V, A>
Which kind of iterator are we turning this into?
","IntoIterator","bdk_wallet::descriptor::policy::ConditionMap","bdk_wallet::descriptor::policy::FoldedConditionMap","bdk_wallet::descriptor::HdKeyPaths","bdk_wallet::descriptor::TapKeyOrigins","bdk_wallet::keys::KeyMap"],["Â§impl<K, V> Merge for BTreeMap<K, V>where\n    K: Ord,
Â§fn merge(&mut self, other: BTreeMap<K, V>)
Merge another object of the same type onto self.
Â§fn is_empty(&self) -> bool
Returns whether the structure is considered empty.
Â§fn take(&mut self) -> Option<Self>
Take the value, replacing it with the default value.
","Merge","bdk_wallet::descriptor::policy::ConditionMap","bdk_wallet::descriptor::policy::FoldedConditionMap","bdk_wallet::descriptor::HdKeyPaths","bdk_wallet::descriptor::TapKeyOrigins","bdk_wallet::keys::KeyMap"],["1.0.0 Â· sourceÂ§impl<K, V, A> Ord for BTreeMap<K, V, A>where\n    K: Ord,\n    V: Ord,\n    A: Allocator + Clone,
sourceÂ§fn cmp(&self, other: &BTreeMap<K, V, A>) -> Ordering
This method returns an Ordering between self and other. Read more
1.21.0 Â· sourceÂ§fn max(self, other: Self) -> Selfwhere\n    Self: Sized,
Compares and returns the maximum of two values. Read more
1.21.0 Â· sourceÂ§fn min(self, other: Self) -> Selfwhere\n    Self: Sized,
Compares and returns the minimum of two values. Read more
1.50.0 Â· sourceÂ§fn clamp(self, min: Self, max: Self) -> Selfwhere\n    Self: Sized + PartialOrd,
Restrict a value to a certain interval. Read more
","Ord","bdk_wallet::descriptor::policy::ConditionMap","bdk_wallet::descriptor::policy::FoldedConditionMap","bdk_wallet::descriptor::HdKeyPaths","bdk_wallet::descriptor::TapKeyOrigins","bdk_wallet::keys::KeyMap"],["1.0.0 Â· sourceÂ§impl<K, V, A> PartialEq for BTreeMap<K, V, A>where\n    K: PartialEq,\n    V: PartialEq,\n    A: Allocator + Clone,
sourceÂ§fn eq(&self, other: &BTreeMap<K, V, A>) -> bool
This method tests for self and other values to be equal, and is used\nby ==.
1.0.0 Â· sourceÂ§fn ne(&self, other: &Rhs) -> bool
This method tests for !=. The default implementation is almost always\nsufficient, and should not be overridden without very good reason.
","PartialEq","bdk_wallet::descriptor::policy::ConditionMap","bdk_wallet::descriptor::policy::FoldedConditionMap","bdk_wallet::descriptor::HdKeyPaths","bdk_wallet::descriptor::TapKeyOrigins","bdk_wallet::keys::KeyMap"],["1.0.0 Â· sourceÂ§impl<K, V, A> PartialOrd for BTreeMap<K, V, A>where\n    K: PartialOrd,\n    V: PartialOrd,\n    A: Allocator + Clone,
sourceÂ§fn partial_cmp(&self, other: &BTreeMap<K, V, A>) -> Option<Ordering>
This method returns an ordering between self and other values if one exists. Read more
1.0.0 Â· sourceÂ§fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self and other) and is used by the < operator. Read more
1.0.0 Â· sourceÂ§fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self and other) and is used by the <=\noperator. Read more
1.0.0 Â· sourceÂ§fn gt(&self, other: &Rhs) -> bool
This method tests greater than (for self and other) and is used by the > operator. Read more
1.0.0 Â· sourceÂ§fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self and other) and is used by the >=\noperator. Read more
","PartialOrd","bdk_wallet::descriptor::policy::ConditionMap","bdk_wallet::descriptor::policy::FoldedConditionMap","bdk_wallet::descriptor::HdKeyPaths","bdk_wallet::descriptor::TapKeyOrigins","bdk_wallet::keys::KeyMap"],["sourceÂ§impl<K, V> Serialize for BTreeMap<K, V>where\n    K: Serialize,\n    V: Serialize,
sourceÂ§fn serialize<S>(\n    &self,\n    serializer: S\n) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where\n    S: Serializer,
Serialize this value into the given Serde serializer. Read more
","Serialize","bdk_wallet::descriptor::policy::ConditionMap","bdk_wallet::descriptor::policy::FoldedConditionMap","bdk_wallet::descriptor::HdKeyPaths","bdk_wallet::descriptor::TapKeyOrigins","bdk_wallet::keys::KeyMap"],["1.0.0 Â· sourceÂ§impl<K, V, A> Eq for BTreeMap<K, V, A>where\n    K: Eq,\n    V: Eq,\n    A: Allocator + Clone,
","Eq","bdk_wallet::descriptor::policy::ConditionMap","bdk_wallet::descriptor::policy::FoldedConditionMap","bdk_wallet::descriptor::HdKeyPaths","bdk_wallet::descriptor::TapKeyOrigins","bdk_wallet::keys::KeyMap"],["1.64.0 Â· sourceÂ§impl<K, V, A> UnwindSafe for BTreeMap<K, V, A>where\n    A: Allocator + Clone + UnwindSafe,\n    K: RefUnwindSafe,\n    V: RefUnwindSafe,","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":[["sourceÂ§impl<K, V> BTreeMap<K, V>
1.0.0 (const: 1.66.0) Â· sourcepub const fn new() -> BTreeMap<K, V>
Makes a new, empty BTreeMap.
\nDoes not allocate anything on its own.
\nÂ§Examples
\nuse std::collections::BTreeMap;\n\nlet mut map = BTreeMap::new();\n\n// entries can now be inserted into the empty map\nmap.insert(1, \"a\");
\n
",0,"bdk_wallet::descriptor::policy::ConditionMap","bdk_wallet::descriptor::policy::FoldedConditionMap","bdk_wallet::descriptor::HdKeyPaths","bdk_wallet::descriptor::TapKeyOrigins","bdk_wallet::keys::KeyMap"],["sourceÂ§impl<K, V, A> BTreeMap<K, V, A>where\n    A: Allocator + Clone,
1.0.0 Â· sourcepub fn iter(&self) -> Iter<'_, K, V>
Gets an iterator over the entries of the map, sorted by key.
\nÂ§Examples
\nuse std::collections::BTreeMap;\n\nlet mut map = BTreeMap::new();\nmap.insert(3, \"c\");\nmap.insert(2, \"b\");\nmap.insert(1, \"a\");\n\nfor (key, value) in map.iter() {\n    println!(\"{key}: {value}\");\n}\n\nlet (first_key, first_value) = map.iter().next().unwrap();\nassert_eq!((*first_key, *first_value), (1, \"a\"));
\n
1.0.0 Â· sourcepub fn iter_mut(&mut self) -> IterMut<'_, K, V>
Gets a mutable iterator over the entries of the map, sorted by key.
\nÂ§Examples
\nuse std::collections::BTreeMap;\n\nlet mut map = BTreeMap::from([\n   (\"a\", 1),\n   (\"b\", 2),\n   (\"c\", 3),\n]);\n\n// add 10 to the value if the key isn't \"a\"\nfor (key, value) in map.iter_mut() {\n    if key != &\"a\" {\n        *value += 10;\n    }\n}
\n
1.0.0 Â· sourcepub fn keys(&self) -> Keys<'_, K, V>
Gets an iterator over the keys of the map, in sorted order.
\nÂ§Examples
\nuse std::collections::BTreeMap;\n\nlet mut a = BTreeMap::new();\na.insert(2, \"b\");\na.insert(1, \"a\");\n\nlet keys: Vec<_> = a.keys().cloned().collect();\nassert_eq!(keys, [1, 2]);
\n
1.0.0 Â· sourcepub fn values(&self) -> Values<'_, K, V>
Gets an iterator over the values of the map, in order by key.
\nÂ§Examples
\nuse std::collections::BTreeMap;\n\nlet mut a = BTreeMap::new();\na.insert(1, \"hello\");\na.insert(2, \"goodbye\");\n\nlet values: Vec<&str> = a.values().cloned().collect();\nassert_eq!(values, [\"hello\", \"goodbye\"]);
\n
1.10.0 Â· sourcepub fn values_mut(&mut self) -> ValuesMut<'_, K, V>
Gets a mutable iterator over the values of the map, in order by key.
\nÂ§Examples
\nuse std::collections::BTreeMap;\n\nlet mut a = BTreeMap::new();\na.insert(1, String::from(\"hello\"));\na.insert(2, String::from(\"goodbye\"));\n\nfor value in a.values_mut() {\n    value.push_str(\"!\");\n}\n\nlet values: Vec<String> = a.values().cloned().collect();\nassert_eq!(values, [String::from(\"hello!\"),\n                    String::from(\"goodbye!\")]);
\n
1.0.0 (const: unstable) Â· sourcepub fn len(&self) -> usize
Returns the number of elements in the map.
\nÂ§Examples
\nuse std::collections::BTreeMap;\n\nlet mut a = BTreeMap::new();\nassert_eq!(a.len(), 0);\na.insert(1, \"a\");\nassert_eq!(a.len(), 1);
\n
1.0.0 (const: unstable) Â· sourcepub fn is_empty(&self) -> bool
Returns true if the map contains no elements.
\nÂ§Examples
\nuse std::collections::BTreeMap;\n\nlet mut a = BTreeMap::new();\nassert!(a.is_empty());\na.insert(1, \"a\");\nassert!(!a.is_empty());
\n
sourcepub fn lower_bound<Q>(&self, bound: Bound<&Q>) -> Cursor<'_, K, V>where\n    K: Borrow<Q> + Ord,\n    Q: Ord + ?Sized,
ð¬This is a nightly-only experimental API. (btree_cursors)
Returns a Cursor pointing at the gap before the smallest key\ngreater than the given bound.
\nPassing Bound::Included(x) will return a cursor pointing to the\ngap before the smallest key greater than or equal to x.
\nPassing Bound::Excluded(x) will return a cursor pointing to the\ngap before the smallest key greater than x.
\nPassing Bound::Unbounded will return a cursor pointing to the\ngap before the smallest key in the map.
\nÂ§Examples
\n#![feature(btree_cursors)]\n\nuse std::collections::BTreeMap;\nuse std::ops::Bound;\n\nlet map = BTreeMap::from([\n    (1, \"a\"),\n    (2, \"b\"),\n    (3, \"c\"),\n    (4, \"d\"),\n]);\n\nlet cursor = map.lower_bound(Bound::Included(&2));\nassert_eq!(cursor.peek_prev(), Some((&1, &\"a\")));\nassert_eq!(cursor.peek_next(), Some((&2, &\"b\")));\n\nlet cursor = map.lower_bound(Bound::Excluded(&2));\nassert_eq!(cursor.peek_prev(), Some((&2, &\"b\")));\nassert_eq!(cursor.peek_next(), Some((&3, &\"c\")));\n\nlet cursor = map.lower_bound(Bound::Unbounded);\nassert_eq!(cursor.peek_prev(), None);\nassert_eq!(cursor.peek_next(), Some((&1, &\"a\")));
\n
sourcepub fn lower_bound_mut<Q>(&mut self, bound: Bound<&Q>) -> CursorMut<'_, K, V, A>where\n    K: Borrow<Q> + Ord,\n    Q: Ord + ?Sized,
ð¬This is a nightly-only experimental API. (btree_cursors)
Returns a CursorMut pointing at the gap before the smallest key\ngreater than the given bound.
\nPassing Bound::Included(x) will return a cursor pointing to the\ngap before the smallest key greater than or equal to x.
\nPassing Bound::Excluded(x) will return a cursor pointing to the\ngap before the smallest key greater than x.
\nPassing Bound::Unbounded will return a cursor pointing to the\ngap before the smallest key in the map.
\nÂ§Examples
\n#![feature(btree_cursors)]\n\nuse std::collections::BTreeMap;\nuse std::ops::Bound;\n\nlet mut map = BTreeMap::from([\n    (1, \"a\"),\n    (2, \"b\"),\n    (3, \"c\"),\n    (4, \"d\"),\n]);\n\nlet mut cursor = map.lower_bound_mut(Bound::Included(&2));\nassert_eq!(cursor.peek_prev(), Some((&1, &mut \"a\")));\nassert_eq!(cursor.peek_next(), Some((&2, &mut \"b\")));\n\nlet mut cursor = map.lower_bound_mut(Bound::Excluded(&2));\nassert_eq!(cursor.peek_prev(), Some((&2, &mut \"b\")));\nassert_eq!(cursor.peek_next(), Some((&3, &mut \"c\")));\n\nlet mut cursor = map.lower_bound_mut(Bound::Unbounded);\nassert_eq!(cursor.peek_prev(), None);\nassert_eq!(cursor.peek_next(), Some((&1, &mut \"a\")));
\n
sourcepub fn upper_bound<Q>(&self, bound: Bound<&Q>) -> Cursor<'_, K, V>where\n    K: Borrow<Q> + Ord,\n    Q: Ord + ?Sized,
ð¬This is a nightly-only experimental API. (btree_cursors)
Returns a Cursor pointing at the gap after the greatest key\nsmaller than the given bound.
\nPassing Bound::Included(x) will return a cursor pointing to the\ngap after the greatest key smaller than or equal to x.
\nPassing Bound::Excluded(x) will return a cursor pointing to the\ngap after the greatest key smaller than x.
\nPassing Bound::Unbounded will return a cursor pointing to the\ngap after the greatest key in the map.
\nÂ§Examples
\n#![feature(btree_cursors)]\n\nuse std::collections::BTreeMap;\nuse std::ops::Bound;\n\nlet map = BTreeMap::from([\n    (1, \"a\"),\n    (2, \"b\"),\n    (3, \"c\"),\n    (4, \"d\"),\n]);\n\nlet cursor = map.upper_bound(Bound::Included(&3));\nassert_eq!(cursor.peek_prev(), Some((&3, &\"c\")));\nassert_eq!(cursor.peek_next(), Some((&4, &\"d\")));\n\nlet cursor = map.upper_bound(Bound::Excluded(&3));\nassert_eq!(cursor.peek_prev(), Some((&2, &\"b\")));\nassert_eq!(cursor.peek_next(), Some((&3, &\"c\")));\n\nlet cursor = map.upper_bound(Bound::Unbounded);\nassert_eq!(cursor.peek_prev(), Some((&4, &\"d\")));\nassert_eq!(cursor.peek_next(), None);
\n
sourcepub fn upper_bound_mut<Q>(&mut self, bound: Bound<&Q>) -> CursorMut<'_, K, V, A>where\n    K: Borrow<Q> + Ord,\n    Q: Ord + ?Sized,
ð¬This is a nightly-only experimental API. (btree_cursors)
Returns a CursorMut pointing at the gap after the greatest key\nsmaller than the given bound.
\nPassing Bound::Included(x) will return a cursor pointing to the\ngap after the greatest key smaller than or equal to x.
\nPassing Bound::Excluded(x) will return a cursor pointing to the\ngap after the greatest key smaller than x.
\nPassing Bound::Unbounded will return a cursor pointing to the\ngap after the greatest key in the map.
\nÂ§Examples
\n#![feature(btree_cursors)]\n\nuse std::collections::BTreeMap;\nuse std::ops::Bound;\n\nlet mut map = BTreeMap::from([\n    (1, \"a\"),\n    (2, \"b\"),\n    (3, \"c\"),\n    (4, \"d\"),\n]);\n\nlet mut cursor = map.upper_bound_mut(Bound::Included(&3));\nassert_eq!(cursor.peek_prev(), Some((&3, &mut \"c\")));\nassert_eq!(cursor.peek_next(), Some((&4, &mut \"d\")));\n\nlet mut cursor = map.upper_bound_mut(Bound::Excluded(&3));\nassert_eq!(cursor.peek_prev(), Some((&2, &mut \"b\")));\nassert_eq!(cursor.peek_next(), Some((&3, &mut \"c\")));\n\nlet mut cursor = map.upper_bound_mut(Bound::Unbounded);\nassert_eq!(cursor.peek_prev(), Some((&4, &mut \"d\")));\nassert_eq!(cursor.peek_next(), None);
\n
",0,"bdk_wallet::descriptor::policy::ConditionMap","bdk_wallet::descriptor::policy::FoldedConditionMap","bdk_wallet::descriptor::HdKeyPaths","bdk_wallet::descriptor::TapKeyOrigins","bdk_wallet::keys::KeyMap"],["sourceÂ§impl<K, V, A> BTreeMap<K, V, A>where\n    A: Allocator + Clone,
1.0.0 Â· sourcepub fn clear(&mut self)
Clears the map, removing all elements.
\nÂ§Examples
\nuse std::collections::BTreeMap;\n\nlet mut a = BTreeMap::new();\na.insert(1, \"a\");\na.clear();\nassert!(a.is_empty());
\n
sourcepub const fn new_in(alloc: A) -> BTreeMap<K, V, A>
ð¬This is a nightly-only experimental API. (btreemap_alloc)
Makes a new empty BTreeMap with a reasonable choice for B.
\nÂ§Examples
\nuse std::collections::BTreeMap;\nuse std::alloc::Global;\n\nlet mut map = BTreeMap::new_in(Global);\n\n// entries can now be inserted into the empty map\nmap.insert(1, \"a\");
\n
",0,"bdk_wallet::descriptor::policy::ConditionMap","bdk_wallet::descriptor::policy::FoldedConditionMap","bdk_wallet::descriptor::HdKeyPaths","bdk_wallet::descriptor::TapKeyOrigins","bdk_wallet::keys::KeyMap"],["sourceÂ§impl<K, V, A> BTreeMap<K, V, A>where\n    A: Allocator + Clone,
1.0.0 Â· sourcepub fn get<Q>(&self, key: &Q) -> Option<&V>where\n    K: Borrow<Q> + Ord,\n    Q: Ord + ?Sized,
Returns a reference to the value corresponding to the key.
\nThe key may be any borrowed form of the mapâs key type, but the ordering\non the borrowed form must match the ordering on the key type.
\nÂ§Examples
\nuse std::collections::BTreeMap;\n\nlet mut map = BTreeMap::new();\nmap.insert(1, \"a\");\nassert_eq!(map.get(&1), Some(&\"a\"));\nassert_eq!(map.get(&2), None);
\n
1.40.0 Â· sourcepub fn get_key_value<Q>(&self, k: &Q) -> Option<(&K, &V)>where\n    K: Borrow<Q> + Ord,\n    Q: Ord + ?Sized,
Returns the key-value pair corresponding to the supplied key.
\nThe supplied key may be any borrowed form of the mapâs key type, but the ordering\non the borrowed form must match the ordering on the key type.
\nÂ§Examples
\nuse std::collections::BTreeMap;\n\nlet mut map = BTreeMap::new();\nmap.insert(1, \"a\");\nassert_eq!(map.get_key_value(&1), Some((&1, &\"a\")));\nassert_eq!(map.get_key_value(&2), None);
\n
1.66.0 Â· sourcepub fn first_key_value(&self) -> Option<(&K, &V)>where\n    K: Ord,
Returns the first key-value pair in the map.\nThe key in this pair is the minimum key in the map.
\nÂ§Examples
\nuse std::collections::BTreeMap;\n\nlet mut map = BTreeMap::new();\nassert_eq!(map.first_key_value(), None);\nmap.insert(1, \"b\");\nmap.insert(2, \"a\");\nassert_eq!(map.first_key_value(), Some((&1, &\"b\")));
\n
1.66.0 Â· sourcepub fn first_entry(&mut self) -> Option<OccupiedEntry<'_, K, V, A>>where\n    K: Ord,
Returns the first entry in the map for in-place manipulation.\nThe key of this entry is the minimum key in the map.
\nÂ§Examples
\nuse std::collections::BTreeMap;\n\nlet mut map = BTreeMap::new();\nmap.insert(1, \"a\");\nmap.insert(2, \"b\");\nif let Some(mut entry) = map.first_entry() {\n    if *entry.key() > 0 {\n        entry.insert(\"first\");\n    }\n}\nassert_eq!(*map.get(&1).unwrap(), \"first\");\nassert_eq!(*map.get(&2).unwrap(), \"b\");
\n
1.66.0 Â· sourcepub fn pop_first(&mut self) -> Option<(K, V)>where\n    K: Ord,
Removes and returns the first element in the map.\nThe key of this element is the minimum key that was in the map.
\nÂ§Examples
\nDraining elements in ascending order, while keeping a usable map each iteration.
\n\nuse std::collections::BTreeMap;\n\nlet mut map = BTreeMap::new();\nmap.insert(1, \"a\");\nmap.insert(2, \"b\");\nwhile let Some((key, _val)) = map.pop_first() {\n    assert!(map.iter().all(|(k, _v)| *k > key));\n}\nassert!(map.is_empty());
\n
1.66.0 Â· sourcepub fn last_key_value(&self) -> Option<(&K, &V)>where\n    K: Ord,
Returns the last key-value pair in the map.\nThe key in this pair is the maximum key in the map.
\nÂ§Examples
\nuse std::collections::BTreeMap;\n\nlet mut map = BTreeMap::new();\nmap.insert(1, \"b\");\nmap.insert(2, \"a\");\nassert_eq!(map.last_key_value(), Some((&2, &\"a\")));
\n
1.66.0 Â· sourcepub fn last_entry(&mut self) -> Option<OccupiedEntry<'_, K, V, A>>where\n    K: Ord,
Returns the last entry in the map for in-place manipulation.\nThe key of this entry is the maximum key in the map.
\nÂ§Examples
\nuse std::collections::BTreeMap;\n\nlet mut map = BTreeMap::new();\nmap.insert(1, \"a\");\nmap.insert(2, \"b\");\nif let Some(mut entry) = map.last_entry() {\n    if *entry.key() > 0 {\n        entry.insert(\"last\");\n    }\n}\nassert_eq!(*map.get(&1).unwrap(), \"a\");\nassert_eq!(*map.get(&2).unwrap(), \"last\");
\n
1.66.0 Â· sourcepub fn pop_last(&mut self) -> Option<(K, V)>where\n    K: Ord,
Removes and returns the last element in the map.\nThe key of this element is the maximum key that was in the map.
\nÂ§Examples
\nDraining elements in descending order, while keeping a usable map each iteration.
\n\nuse std::collections::BTreeMap;\n\nlet mut map = BTreeMap::new();\nmap.insert(1, \"a\");\nmap.insert(2, \"b\");\nwhile let Some((key, _val)) = map.pop_last() {\n    assert!(map.iter().all(|(k, _v)| *k < key));\n}\nassert!(map.is_empty());
\n
1.0.0 Â· sourcepub fn contains_key<Q>(&self, key: &Q) -> boolwhere\n    K: Borrow<Q> + Ord,\n    Q: Ord + ?Sized,
Returns true if the map contains a value for the specified key.
\nThe key may be any borrowed form of the mapâs key type, but the ordering\non the borrowed form must match the ordering on the key type.
\nÂ§Examples
\nuse std::collections::BTreeMap;\n\nlet mut map = BTreeMap::new();\nmap.insert(1, \"a\");\nassert_eq!(map.contains_key(&1), true);\nassert_eq!(map.contains_key(&2), false);
\n
1.0.0 Â· sourcepub fn get_mut<Q>(&mut self, key: &Q) -> Option<&mut V>where\n    K: Borrow<Q> + Ord,\n    Q: Ord + ?Sized,
Returns a mutable reference to the value corresponding to the key.
\nThe key may be any borrowed form of the mapâs key type, but the ordering\non the borrowed form must match the ordering on the key type.
\nÂ§Examples
\nuse std::collections::BTreeMap;\n\nlet mut map = BTreeMap::new();\nmap.insert(1, \"a\");\nif let Some(x) = map.get_mut(&1) {\n    *x = \"b\";\n}\nassert_eq!(map[&1], \"b\");
\n
1.0.0 Â· sourcepub fn insert(&mut self, key: K, value: V) -> Option<V>where\n    K: Ord,
Inserts a key-value pair into the map.
\nIf the map did not have this key present, None is returned.
\nIf 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 == without being identical. See the module-level\ndocumentation for more.
\nÂ§Examples
\nuse std::collections::BTreeMap;\n\nlet mut map = BTreeMap::new();\nassert_eq!(map.insert(37, \"a\"), None);\nassert_eq!(map.is_empty(), false);\n\nmap.insert(37, \"b\");\nassert_eq!(map.insert(37, \"c\"), Some(\"b\"));\nassert_eq!(map[&37], \"c\");
\n
sourcepub fn try_insert(\n    &mut self,\n    key: K,\n    value: V\n) -> Result<&mut V, OccupiedError<'_, K, V, A>>where\n    K: Ord,
ð¬This is a nightly-only experimental API. (map_try_insert)
Tries to insert a key-value pair into the map, and returns\na mutable reference to the value in the entry.
\nIf the map already had this key present, nothing is updated, and\nan error containing the occupied entry and the value is returned.
\nÂ§Examples
\n#![feature(map_try_insert)]\n\nuse std::collections::BTreeMap;\n\nlet mut map = BTreeMap::new();\nassert_eq!(map.try_insert(37, \"a\").unwrap(), &\"a\");\n\nlet err = map.try_insert(37, \"b\").unwrap_err();\nassert_eq!(err.entry.key(), &37);\nassert_eq!(err.entry.get(), &\"a\");\nassert_eq!(err.value, \"b\");
\n
1.0.0 Â· sourcepub fn remove<Q>(&mut self, key: &Q) -> Option<V>where\n    K: Borrow<Q> + Ord,\n    Q: Ord + ?Sized,
Removes a key from the map, returning the value at the key if the key\nwas previously in the map.
\nThe key may be any borrowed form of the mapâs key type, but the ordering\non the borrowed form must match the ordering on the key type.
\nÂ§Examples
\nuse std::collections::BTreeMap;\n\nlet mut map = BTreeMap::new();\nmap.insert(1, \"a\");\nassert_eq!(map.remove(&1), Some(\"a\"));\nassert_eq!(map.remove(&1), None);
\n
1.45.0 Â· sourcepub fn remove_entry<Q>(&mut self, key: &Q) -> Option<(K, V)>where\n    K: Borrow<Q> + Ord,\n    Q: Ord + ?Sized,
Removes a key from the map, returning the stored key and value if the key\nwas previously in the map.
\nThe key may be any borrowed form of the mapâs key type, but the ordering\non the borrowed form must match the ordering on the key type.
\nÂ§Examples
\nuse std::collections::BTreeMap;\n\nlet mut map = BTreeMap::new();\nmap.insert(1, \"a\");\nassert_eq!(map.remove_entry(&1), Some((1, \"a\")));\nassert_eq!(map.remove_entry(&1), None);
\n
1.53.0 Â· sourcepub fn retain<F>(&mut self, f: F)where\n    K: Ord,\n    F: FnMut(&K, &mut V) -> bool,
Retains only the elements specified by the predicate.
\nIn other words, remove all pairs (k, v) for which f(&k, &mut v) returns false.\nThe elements are visited in ascending key order.
\nÂ§Examples
\nuse std::collections::BTreeMap;\n\nlet mut map: BTreeMap<i32, i32> = (0..8).map(|x| (x, x*10)).collect();\n// Keep only the elements with even-numbered keys.\nmap.retain(|&k, _| k % 2 == 0);\nassert!(map.into_iter().eq(vec![(0, 0), (2, 20), (4, 40), (6, 60)]));
\n
1.11.0 Â· sourcepub fn append(&mut self, other: &mut BTreeMap<K, V, A>)where\n    K: Ord,\n    A: Clone,
Moves all elements from other into self, leaving other empty.
\nIf a key from other is already present in self, the respective\nvalue from self will be overwritten with the respective value from other.
\nÂ§Examples
\nuse std::collections::BTreeMap;\n\nlet mut a = BTreeMap::new();\na.insert(1, \"a\");\na.insert(2, \"b\");\na.insert(3, \"c\"); // Note: Key (3) also present in b.\n\nlet mut b = BTreeMap::new();\nb.insert(3, \"d\"); // Note: Key (3) also present in a.\nb.insert(4, \"e\");\nb.insert(5, \"f\");\n\na.append(&mut b);\n\nassert_eq!(a.len(), 5);\nassert_eq!(b.len(), 0);\n\nassert_eq!(a[&1], \"a\");\nassert_eq!(a[&2], \"b\");\nassert_eq!(a[&3], \"d\"); // Note: \"c\" has been overwritten.\nassert_eq!(a[&4], \"e\");\nassert_eq!(a[&5], \"f\");
\n
1.17.0 Â· sourcepub fn range<T, R>(&self, range: R) -> Range<'_, K, V>where\n    T: Ord + ?Sized,\n    K: Borrow<T> + Ord,\n    R: RangeBounds<T>,
Constructs a double-ended iterator over a sub-range of elements in the map.\nThe simplest way is to use the range syntax min..max, thus range(min..max) will\nyield elements from min (inclusive) to max (exclusive).\nThe range may also be entered as (Bound<T>, Bound<T>), so for example\nrange((Excluded(4), Included(10))) will yield a left-exclusive, right-inclusive\nrange from 4 to 10.
\nÂ§Panics
\nPanics if range start > end.\nPanics if range start == end and both bounds are Excluded.
\nÂ§Examples
\nuse std::collections::BTreeMap;\nuse std::ops::Bound::Included;\n\nlet mut map = BTreeMap::new();\nmap.insert(3, \"a\");\nmap.insert(5, \"b\");\nmap.insert(8, \"c\");\nfor (&key, &value) in map.range((Included(&4), Included(&8))) {\n    println!(\"{key}: {value}\");\n}\nassert_eq!(Some((&5, &\"b\")), map.range(4..).next());
\n
1.17.0 Â· sourcepub fn range_mut<T, R>(&mut self, range: R) -> RangeMut<'_, K, V>where\n    T: Ord + ?Sized,\n    K: Borrow<T> + Ord,\n    R: RangeBounds<T>,
Constructs a mutable double-ended iterator over a sub-range of elements in the map.\nThe simplest way is to use the range syntax min..max, thus range(min..max) will\nyield elements from min (inclusive) to max (exclusive).\nThe range may also be entered as (Bound<T>, Bound<T>), so for example\nrange((Excluded(4), Included(10))) will yield a left-exclusive, right-inclusive\nrange from 4 to 10.
\nÂ§Panics
\nPanics if range start > end.\nPanics if range start == end and both bounds are Excluded.
\nÂ§Examples
\nuse std::collections::BTreeMap;\n\nlet mut map: BTreeMap<&str, i32> =\n    [(\"Alice\", 0), (\"Bob\", 0), (\"Carol\", 0), (\"Cheryl\", 0)].into();\nfor (_, balance) in map.range_mut(\"B\"..\"Cheryl\") {\n    *balance += 100;\n}\nfor (name, balance) in &map {\n    println!(\"{name} => {balance}\");\n}
\n
1.0.0 Â· sourcepub fn entry(&mut self, key: K) -> Entry<'_, K, V, A>where\n    K: Ord,
Gets the given keyâs corresponding entry in the map for in-place manipulation.
\nÂ§Examples
\nuse std::collections::BTreeMap;\n\nlet mut count: BTreeMap<&str, usize> = BTreeMap::new();\n\n// count the number of occurrences of letters in the vec\nfor x in [\"a\", \"b\", \"a\", \"c\", \"a\", \"b\"] {\n    count.entry(x).and_modify(|curr| *curr += 1).or_insert(1);\n}\n\nassert_eq!(count[\"a\"], 3);\nassert_eq!(count[\"b\"], 2);\nassert_eq!(count[\"c\"], 1);
\n
1.11.0 Â· sourcepub fn split_off<Q>(&mut self, key: &Q) -> BTreeMap<K, V, A>where\n    Q: Ord + ?Sized,\n    K: Borrow<Q> + Ord,\n    A: Clone,
Splits the collection into two at the given key. Returns everything after the given key,\nincluding the key.
\nÂ§Examples
\nuse std::collections::BTreeMap;\n\nlet mut a = BTreeMap::new();\na.insert(1, \"a\");\na.insert(2, \"b\");\na.insert(3, \"c\");\na.insert(17, \"d\");\na.insert(41, \"e\");\n\nlet b = a.split_off(&3);\n\nassert_eq!(a.len(), 2);\nassert_eq!(b.len(), 3);\n\nassert_eq!(a[&1], \"a\");\nassert_eq!(a[&2], \"b\");\n\nassert_eq!(b[&3], \"c\");\nassert_eq!(b[&17], \"d\");\nassert_eq!(b[&41], \"e\");
\n
sourcepub fn extract_if<F>(&mut self, pred: F) -> ExtractIf<'_, K, V, F, A>where\n    K: Ord,\n    F: FnMut(&K, &mut V) -> bool,
ð¬This is a nightly-only experimental API. (btree_extract_if)
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 true, the element is removed from\nthe map and yielded. If the closure returns false, or panics, the\nelement remains in the map and will not be yielded.
\nThe iterator also lets you mutate the value of each element in the\nclosure, regardless of whether you choose to keep or remove it.
\nIf the returned ExtractIf is not exhausted, e.g. because it is dropped without iterating\nor the iteration short-circuits, then the remaining elements will be retained.\nUse retain with a negated predicate if you do not need the returned iterator.
\nÂ§Examples
\nSplitting a map into even and odd keys, reusing the original map:
\n\n#![feature(btree_extract_if)]\nuse std::collections::BTreeMap;\n\nlet mut map: BTreeMap<i32, i32> = (0..8).map(|x| (x, x)).collect();\nlet evens: BTreeMap<_, _> = map.extract_if(|k, _v| k % 2 == 0).collect();\nlet odds = map;\nassert_eq!(evens.keys().copied().collect::<Vec<_>>(), [0, 2, 4, 6]);\nassert_eq!(odds.keys().copied().collect::<Vec<_>>(), [1, 3, 5, 7]);
\n
1.54.0 Â· sourcepub fn into_keys(self) -> IntoKeys<K, V, A>
Creates a consuming iterator visiting all the keys, in sorted order.\nThe map cannot be used after calling this.\nThe iterator element type is K.
\nÂ§Examples
\nuse std::collections::BTreeMap;\n\nlet mut a = BTreeMap::new();\na.insert(2, \"b\");\na.insert(1, \"a\");\n\nlet keys: Vec<i32> = a.into_keys().collect();\nassert_eq!(keys, [1, 2]);
\n
1.54.0 Â· sourcepub fn into_values(self) -> IntoValues<K, V, A>
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 V.
\nÂ§Examples
\nuse std::collections::BTreeMap;\n\nlet mut a = BTreeMap::new();\na.insert(1, \"hello\");\na.insert(2, \"goodbye\");\n\nlet values: Vec<&str> = a.into_values().collect();\nassert_eq!(values, [\"hello\", \"goodbye\"]);
\n
",0,"bdk_wallet::descriptor::policy::ConditionMap","bdk_wallet::descriptor::policy::FoldedConditionMap","bdk_wallet::descriptor::HdKeyPaths","bdk_wallet::descriptor::TapKeyOrigins","bdk_wallet::keys::KeyMap"],["1.0.0 Â· sourceÂ§impl<K, V, A> Clone for BTreeMap<K, V, A>where\n    K: Clone,\n    V: Clone,\n    A: Allocator + Clone,
sourceÂ§fn clone(&self) -> BTreeMap<K, V, A>
Returns a copy of the value. Read more
1.0.0 Â· sourceÂ§fn clone_from(&mut self, source: &Self)
Performs copy-assignment from source. Read more
","Clone","bdk_wallet::descriptor::policy::ConditionMap","bdk_wallet::descriptor::policy::FoldedConditionMap","bdk_wallet::descriptor::HdKeyPaths","bdk_wallet::descriptor::TapKeyOrigins","bdk_wallet::keys::KeyMap"],["1.0.0 Â· sourceÂ§impl<K, V, A> Debug for BTreeMap<K, V, A>where\n    K: Debug,\n    V: Debug,\n    A: Allocator + Clone,
sourceÂ§fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>
Formats the value using the given formatter. Read more
","Debug","bdk_wallet::descriptor::policy::ConditionMap","bdk_wallet::descriptor::policy::FoldedConditionMap","bdk_wallet::descriptor::HdKeyPaths","bdk_wallet::descriptor::TapKeyOrigins","bdk_wallet::keys::KeyMap"],["1.0.0 Â· sourceÂ§impl<K, V> Default for BTreeMap<K, V>
sourceÂ§fn default() -> BTreeMap<K, V>
Creates an empty BTreeMap.
\n
","Default","bdk_wallet::descriptor::policy::ConditionMap","bdk_wallet::descriptor::policy::FoldedConditionMap","bdk_wallet::descriptor::HdKeyPaths","bdk_wallet::descriptor::TapKeyOrigins","bdk_wallet::keys::KeyMap"],["sourceÂ§impl<'de, K, V> Deserialize<'de> for BTreeMap<K, V>where\n    K: Deserialize<'de> + Ord,\n    V: Deserialize<'de>,
sourceÂ§fn deserialize<D>(\n    deserializer: D\n) -> Result<BTreeMap<K, V>, <D as Deserializer<'de>>::Error>where\n    D: Deserializer<'de>,
Deserialize this value from the given Serde deserializer. Read more
","Deserialize<'de>","bdk_wallet::descriptor::policy::ConditionMap","bdk_wallet::descriptor::policy::FoldedConditionMap","bdk_wallet::descriptor::HdKeyPaths","bdk_wallet::descriptor::TapKeyOrigins","bdk_wallet::keys::KeyMap"],["1.7.0 Â· sourceÂ§impl<K, V, A> Drop for BTreeMap<K, V, A>where\n    A: Allocator + Clone,
sourceÂ§fn drop(&mut self)
Executes the destructor for this type. Read more
","Drop","bdk_wallet::descriptor::policy::ConditionMap","bdk_wallet::descriptor::policy::FoldedConditionMap","bdk_wallet::descriptor::HdKeyPaths","bdk_wallet::descriptor::TapKeyOrigins","bdk_wallet::keys::KeyMap"],["1.2.0 Â· sourceÂ§impl<'a, K, V, A> Extend<(&'a K, &'a V)> for BTreeMap<K, V, A>where\n    K: Ord + Copy,\n    V: Copy,\n    A: Allocator + Clone,
sourceÂ§fn extend<I>(&mut self, iter: I)where\n    I: IntoIterator<Item = (&'a K, &'a V)>,
Extends a collection with the contents of an iterator. Read more
sourceÂ§fn extend_one(&mut self, _: (&'a K, &'a V))
ð¬This is a nightly-only experimental API. (extend_one)Extends a collection with exactly one element.
sourceÂ§fn extend_reserve(&mut self, additional: usize)
ð¬This is a nightly-only experimental API. (extend_one)Reserves capacity in a collection for the given number of additional elements. Read more
","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"],["1.0.0 Â· sourceÂ§impl<K, V, A> Extend<(K, V)> for BTreeMap<K, V, A>where\n    K: Ord,\n    A: Allocator + Clone,
sourceÂ§fn extend<T>(&mut self, iter: T)where\n    T: IntoIterator<Item = (K, V)>,
Extends a collection with the contents of an iterator. Read more
sourceÂ§fn extend_one(&mut self, _: (K, V))
ð¬This is a nightly-only experimental API. (extend_one)Extends a collection with exactly one element.
sourceÂ§fn extend_reserve(&mut self, additional: usize)
ð¬This is a nightly-only experimental API. (extend_one)Reserves capacity in a collection for the given number of additional elements. Read more
","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"],["1.56.0 Â· sourceÂ§impl<K, V, const N: usize> From<[(K, V); N]> for BTreeMap<K, V>where\n    K: Ord,
sourceÂ§fn from(arr: [(K, V); N]) -> BTreeMap<K, V>
Converts a [(K, V); N] into a BTreeMap<(K, V)>.
\n\nuse std::collections::BTreeMap;\n\nlet map1 = BTreeMap::from([(1, 2), (3, 4)]);\nlet map2: BTreeMap<_, _> = [(1, 2), (3, 4)].into();\nassert_eq!(map1, map2);
\n
","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"],["1.0.0 Â· sourceÂ§impl<K, V> FromIterator<(K, V)> for BTreeMap<K, V>where\n    K: Ord,
sourceÂ§fn from_iter<T>(iter: T) -> BTreeMap<K, V>where\n    T: IntoIterator<Item = (K, V)>,
Creates a value from an iterator. Read more
","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"],["1.0.0 Â· sourceÂ§impl<K, V, A> Hash for BTreeMap<K, V, A>where\n    K: Hash,\n    V: Hash,\n    A: Allocator + Clone,
sourceÂ§fn hash<H>(&self, state: &mut H)where\n    H: Hasher,
Feeds this value into the given Hasher. Read more
1.3.0 Â· sourceÂ§fn hash_slice<H>(data: &[Self], state: &mut H)where\n    H: Hasher,\n    Self: Sized,
Feeds a slice of this type into the given Hasher. Read more
","Hash","bdk_wallet::descriptor::policy::ConditionMap","bdk_wallet::descriptor::policy::FoldedConditionMap","bdk_wallet::descriptor::HdKeyPaths","bdk_wallet::descriptor::TapKeyOrigins","bdk_wallet::keys::KeyMap"],["1.0.0 Â· sourceÂ§impl<K, Q, V, A> Index<&Q> for BTreeMap<K, V, A>where\n    A: Allocator + Clone,\n    K: Borrow<Q> + Ord,\n    Q: Ord + ?Sized,
sourceÂ§fn index(&self, key: &Q) -> &V
Returns a reference to the value corresponding to the supplied key.
\nÂ§Panics
\nPanics if the key is not present in the BTreeMap.
\n
Â§type Output = V
The returned type after indexing.
","Index<&Q>","bdk_wallet::descriptor::policy::ConditionMap","bdk_wallet::descriptor::policy::FoldedConditionMap","bdk_wallet::descriptor::HdKeyPaths","bdk_wallet::descriptor::TapKeyOrigins","bdk_wallet::keys::KeyMap"],["Â§impl IntoAssets for BTreeMap<DescriptorPublicKey, DescriptorSecretKey>
Â§fn into_assets(self) -> Assets
Convert self into a Assets struct
","IntoAssets","bdk_wallet::keys::KeyMap"],["sourceÂ§impl<'de, K, V, E> IntoDeserializer<'de, E> for BTreeMap<K, V>where\n    K: IntoDeserializer<'de, E> + Eq + Ord,\n    V: IntoDeserializer<'de, E>,\n    E: Error,
Â§type Deserializer = MapDeserializer<'de, <BTreeMap<K, V> as IntoIterator>::IntoIter, E>
The type of the deserializer being converted into.
sourceÂ§fn into_deserializer(\n    self\n) -> <BTreeMap<K, V> as IntoDeserializer<'de, E>>::Deserializer
Convert this value into a deserializer.
","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"],["1.0.0 Â· sourceÂ§impl<K, V, A> IntoIterator for BTreeMap<K, V, A>where\n    A: Allocator + Clone,
sourceÂ§fn into_iter(self) -> IntoIter<K, V, A>
Gets an owning iterator over the entries of the map, sorted by key.
\n
Â§type Item = (K, V)
The type of the elements being iterated over.
Â§type IntoIter = IntoIter<K, V, A>
Which kind of iterator are we turning this into?
","IntoIterator","bdk_wallet::descriptor::policy::ConditionMap","bdk_wallet::descriptor::policy::FoldedConditionMap","bdk_wallet::descriptor::HdKeyPaths","bdk_wallet::descriptor::TapKeyOrigins","bdk_wallet::keys::KeyMap"],["Â§impl<K, V> Merge for BTreeMap<K, V>where\n    K: Ord,
Â§fn merge(&mut self, other: BTreeMap<K, V>)
Merge another object of the same type onto self.
Â§fn is_empty(&self) -> bool
Returns whether the structure is considered empty.
Â§fn take(&mut self) -> Option<Self>
Take the value, replacing it with the default value.
","Merge","bdk_wallet::descriptor::policy::ConditionMap","bdk_wallet::descriptor::policy::FoldedConditionMap","bdk_wallet::descriptor::HdKeyPaths","bdk_wallet::descriptor::TapKeyOrigins","bdk_wallet::keys::KeyMap"],["1.0.0 Â· sourceÂ§impl<K, V, A> Ord for BTreeMap<K, V, A>where\n    K: Ord,\n    V: Ord,\n    A: Allocator + Clone,
sourceÂ§fn cmp(&self, other: &BTreeMap<K, V, A>) -> Ordering
This method returns an Ordering between self and other. Read more
1.21.0 Â· sourceÂ§fn max(self, other: Self) -> Selfwhere\n    Self: Sized,
Compares and returns the maximum of two values. Read more
1.21.0 Â· sourceÂ§fn min(self, other: Self) -> Selfwhere\n    Self: Sized,
Compares and returns the minimum of two values. Read more
1.50.0 Â· sourceÂ§fn clamp(self, min: Self, max: Self) -> Selfwhere\n    Self: Sized + PartialOrd,
Restrict a value to a certain interval. Read more
","Ord","bdk_wallet::descriptor::policy::ConditionMap","bdk_wallet::descriptor::policy::FoldedConditionMap","bdk_wallet::descriptor::HdKeyPaths","bdk_wallet::descriptor::TapKeyOrigins","bdk_wallet::keys::KeyMap"],["1.0.0 Â· sourceÂ§impl<K, V, A> PartialEq for BTreeMap<K, V, A>where\n    K: PartialEq,\n    V: PartialEq,\n    A: Allocator + Clone,
sourceÂ§fn eq(&self, other: &BTreeMap<K, V, A>) -> bool
This method tests for self and other values to be equal, and is used\nby ==.
1.0.0 Â· sourceÂ§fn ne(&self, other: &Rhs) -> bool
This method tests for !=. The default implementation is almost always\nsufficient, and should not be overridden without very good reason.
","PartialEq","bdk_wallet::descriptor::policy::ConditionMap","bdk_wallet::descriptor::policy::FoldedConditionMap","bdk_wallet::descriptor::HdKeyPaths","bdk_wallet::descriptor::TapKeyOrigins","bdk_wallet::keys::KeyMap"],["1.0.0 Â· sourceÂ§impl<K, V, A> PartialOrd for BTreeMap<K, V, A>where\n    K: PartialOrd,\n    V: PartialOrd,\n    A: Allocator + Clone,
sourceÂ§fn partial_cmp(&self, other: &BTreeMap<K, V, A>) -> Option<Ordering>
This method returns an ordering between self and other values if one exists. Read more
1.0.0 Â· sourceÂ§fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self and other) and is used by the < operator. Read more
1.0.0 Â· sourceÂ§fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self and other) and is used by the <=\noperator. Read more
1.0.0 Â· sourceÂ§fn gt(&self, other: &Rhs) -> bool
This method tests greater than (for self and other) and is used by the > operator. Read more
1.0.0 Â· sourceÂ§fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self and other) and is used by the >=\noperator. Read more
","PartialOrd","bdk_wallet::descriptor::policy::ConditionMap","bdk_wallet::descriptor::policy::FoldedConditionMap","bdk_wallet::descriptor::HdKeyPaths","bdk_wallet::descriptor::TapKeyOrigins","bdk_wallet::keys::KeyMap"],["sourceÂ§impl<K, V> Serialize for BTreeMap<K, V>where\n    K: Serialize,\n    V: Serialize,
sourceÂ§fn serialize<S>(\n    &self,\n    serializer: S\n) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where\n    S: Serializer,
Serialize this value into the given Serde serializer. Read more
","Serialize","bdk_wallet::descriptor::policy::ConditionMap","bdk_wallet::descriptor::policy::FoldedConditionMap","bdk_wallet::descriptor::HdKeyPaths","bdk_wallet::descriptor::TapKeyOrigins","bdk_wallet::keys::KeyMap"],["1.0.0 Â· sourceÂ§impl<K, V, A> Eq for BTreeMap<K, V, A>where\n    K: Eq,\n    V: Eq,\n    A: Allocator + Clone,
","Eq","bdk_wallet::descriptor::policy::ConditionMap","bdk_wallet::descriptor::policy::FoldedConditionMap","bdk_wallet::descriptor::HdKeyPaths","bdk_wallet::descriptor::TapKeyOrigins","bdk_wallet::keys::KeyMap"],["1.64.0 Â· sourceÂ§impl<K, V, A> UnwindSafe for BTreeMap<K, V, A>where\n    A: Allocator + Clone + UnwindSafe,\n    K: RefUnwindSafe,\n    V: RefUnwindSafe,","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
diff --git a/docs/.vuepress/public/docs-rs/bdk/nightly/latest/type.impl/bdk_wallet/descriptor/enum.Descriptor.js b/docs/.vuepress/public/docs-rs/bdk/nightly/latest/type.impl/bdk_wallet/descriptor/enum.Descriptor.js
index a24f4a6f15..c0a7c05a49 100644
--- a/docs/.vuepress/public/docs-rs/bdk/nightly/latest/type.impl/bdk_wallet/descriptor/enum.Descriptor.js
+++ b/docs/.vuepress/public/docs-rs/bdk/nightly/latest/type.impl/bdk_wallet/descriptor/enum.Descriptor.js
@@ -1,3 +1,3 @@
 (function() {var type_impls = {
-"bdk_wallet":[["Â§impl<Pk> Clone for Descriptor<Pk>where\n    Pk: Clone + MiniscriptKey,
Â§fn clone(&self) -> Descriptor<Pk>
Returns a copy of the value. Read more
1.0.0 Â· sourceÂ§fn clone_from(&mut self, source: &Self)
Performs copy-assignment from source. Read more
","Clone","bdk_wallet::descriptor::ExtendedDescriptor","bdk_wallet::descriptor::DerivedDescriptor"],["Â§impl<Pk> Debug for Descriptor<Pk>where\n    Pk: MiniscriptKey,
Â§fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>
Formats the value using the given formatter. Read more
","Debug","bdk_wallet::descriptor::ExtendedDescriptor","bdk_wallet::descriptor::DerivedDescriptor"],["Â§impl Descriptor<DefiniteDescriptorKey>
pub fn derived_descriptor<C>(\n    &self,\n    secp: &Secp256k1<C>\n) -> Result<Descriptor<PublicKey>, ConversionError>where\n    C: Verification,
Convert all the public keys in the descriptor to [bitcoin::PublicKey] by deriving them or\notherwise converting them. All [bitcoin::secp256k1::XOnlyPublicKey]s are converted to by adding a\ndefault(0x02) y-coordinate.
\nÂ§Examples
\nuse miniscript::descriptor::{Descriptor, DescriptorPublicKey};\nuse miniscript::bitcoin::secp256k1;\nuse std::str::FromStr;\n\n// test from bip 86\nlet secp = secp256k1::Secp256k1::verification_only();\nlet descriptor = Descriptor::<DescriptorPublicKey>::from_str(\"tr(xpub6BgBgsespWvERF3LHQu6CnqdvfEvtMcQjYrcRzx53QJjSxarj2afYWcLteoGVky7D3UKDP9QyrLprQ3VCECoY49yfdDEHGCtMMj92pReUsQ/0/*)\")\n    .expect(\"Valid ranged descriptor\");\nlet result = descriptor.at_derivation_index(0).unwrap().derived_descriptor(&secp).expect(\"Non-hardened derivation\");\nassert_eq!(result.to_string(), \"tr(03cc8a4bc64d897bddc5fbc2f670f7a8ba0b386779106cf1223c6fc5d7cd6fc115)#6qm9h8ym\");
\nÂ§Errors
\nThis function will return an error if hardened derivation is attempted.
\n
",0,"bdk_wallet::descriptor::DerivedDescriptor"],["Â§impl Descriptor<DefiniteDescriptorKey>
pub fn plan<P>(\n    self,\n    provider: &P\n) -> Result<Plan, Descriptor<DefiniteDescriptorKey>>where\n    P: AssetProvider<DefiniteDescriptorKey>,
Returns a plan if the provided assets are sufficient to produce a non-malleable satisfaction
\nIf the assets arenât sufficient for generating a Plan, the descriptor is returned
\n
pub fn plan_mall<P>(\n    self,\n    provider: &P\n) -> Result<Plan, Descriptor<DefiniteDescriptorKey>>where\n    P: AssetProvider<DefiniteDescriptorKey>,
Returns a plan if the provided assets are sufficient to produce a malleable satisfaction
\nIf the assets arenât sufficient for generating a Plan, the descriptor is returned
\n
",0,"bdk_wallet::descriptor::DerivedDescriptor"],["Â§impl Descriptor<DescriptorPublicKey>
pub fn is_deriveable(&self) -> bool
ðDeprecated: use has_wildcards instead
Whether or not the descriptor has any wildcards
\n
pub fn has_wildcard(&self) -> bool
Whether or not the descriptor has any wildcards i.e. /*.
\n
pub fn at_derivation_index(\n    &self,\n    index: u32\n) -> Result<Descriptor<DefiniteDescriptorKey>, ConversionError>
Replaces all wildcards (i.e. /*) in the descriptor with a particular derivation index,\nturning it into a definite descriptor.
\nÂ§Errors
\n\nIf index â¥ 2^31
\n
\n
pub fn derive(\n    &self,\n    index: u32\n) -> Result<Descriptor<DefiniteDescriptorKey>, ConversionError>
ðDeprecated: use at_derivation_index instead
Deprecated name for Self::at_derivation_index.
\n
pub fn derived_descriptor<C>(\n    &self,\n    secp: &Secp256k1<C>,\n    index: u32\n) -> Result<Descriptor<PublicKey>, ConversionError>where\n    C: Verification,
Convert all the public keys in the descriptor to [bitcoin::PublicKey] by deriving them or\notherwise converting them. All [bitcoin::secp256k1::XOnlyPublicKey]s are converted to by adding a\ndefault(0x02) y-coordinate.
\nThis is a shorthand for:
\n\n    .expect(\"Valid ranged descriptor\");\nlet derived_descriptor = descriptor.at_derivation_index(index).unwrap().derived_descriptor(&secp).unwrap();
\nand is only here really here for backwards compatbility.\nSee at_derivation_index and [derived_descriptor] for more documentation.
\nÂ§Errors
\nThis function will return an error if hardened derivation is attempted.
\n
pub fn parse_descriptor<C>(\n    secp: &Secp256k1<C>,\n    s: &str\n) -> Result<(Descriptor<DescriptorPublicKey>, BTreeMap<DescriptorPublicKey, DescriptorSecretKey>), Error>where\n    C: Signing,
Parse a descriptor that may contain secret keys
\nInternally turns every secret key found into the corresponding public key and then returns a\na descriptor that only contains public keys and a map to lookup the secret key given a public key.
\n
pub fn to_string_with_secret(\n    &self,\n    key_map: &BTreeMap<DescriptorPublicKey, DescriptorSecretKey>\n) -> String
Serialize a descriptor to string with its secret keys
\n
pub fn find_derivation_index_for_spk<C>(\n    &self,\n    secp: &Secp256k1<C>,\n    script_pubkey: &Script,\n    range: Range<u32>\n) -> Result<Option<(u32, Descriptor<PublicKey>)>, ConversionError>where\n    C: Verification,
Utility method for deriving the descriptor at each index in a range to find one matching\nscript_pubkey.
\nIf it finds a match then it returns the index it was derived at and the concrete\ndescriptor at that index. If the descriptor is non-derivable then it will simply check the\nscript pubkey against the descriptor and return it if it matches (in this case the index\nreturned will be meaningless).
\n
pub fn is_multipath(&self) -> bool
Whether this descriptor contains a key that has multiple derivation paths.
\n
pub fn into_single_descriptors(\n    self\n) -> Result<Vec<Descriptor<DescriptorPublicKey>>, Error>
Get as many descriptors as different paths in this descriptor.
\nFor multipath descriptors it will return as many descriptors as there is\nâparallelâ paths. For regular descriptors it will just return itself.
\n
",0,"bdk_wallet::descriptor::ExtendedDescriptor"],["Â§impl<Pk> Descriptor<Pk>where\n    Pk: MiniscriptKey + ToPublicKey,
pub fn address(&self, network: Network) -> Result<Address, Error>
Computes the Bitcoin address of the descriptor, if one exists
\nSome descriptors like pk() donât have an address.
\nÂ§Errors
\nFor raw/bare descriptors that donât have an address.
\n
pub fn script_pubkey(&self) -> ScriptBuf
Computes the scriptpubkey of the descriptor.
\n
pub fn unsigned_script_sig(&self) -> ScriptBuf
Computes the scriptSig that will be in place for an unsigned input\nspending an output with this descriptor. For pre-segwit descriptors,\nwhich use the scriptSig for signatures, this returns the empty script.
\nThis is used in Segwit transactions to produce an unsigned transaction\nwhose txid will not change during signing (since only the witness data\nwill change).
\n
pub fn explicit_script(&self) -> Result<ScriptBuf, Error>
Computes the the underlying script before any hashing is done. For\nBare, Pkh and Wpkh this is the scriptPubkey; for ShWpkh and Sh\nthis is the redeemScript; for the others it is the witness script.
\nÂ§Errors
\nIf the descriptor is a taproot descriptor.
\n
pub fn script_code(&self) -> Result<ScriptBuf, Error>
Computes the scriptCode of a transaction output.
\nThe scriptCode is the Script of the previous transaction output being\nserialized in the sighash when evaluating a CHECKSIG & co. OP code.
\nÂ§Errors
\nIf the descriptor is a taproot descriptor.
\n
pub fn get_satisfaction<S>(\n    &self,\n    satisfier: S\n) -> Result<(Vec<Vec<u8>>, ScriptBuf), Error>where\n    S: Satisfier<Pk>,
Returns satisfying non-malleable witness and scriptSig to spend an\noutput controlled by the given descriptor if it possible to\nconstruct one using the satisfier S.
\n
pub fn get_satisfaction_mall<S>(\n    &self,\n    satisfier: S\n) -> Result<(Vec<Vec<u8>>, ScriptBuf), Error>where\n    S: Satisfier<Pk>,
Returns a possilbly mallable satisfying non-malleable witness and scriptSig to spend an\noutput controlled by the given descriptor if it possible to\nconstruct one using the satisfier S.
\n
pub fn satisfy<S>(&self, txin: &mut TxIn, satisfier: S) -> Result<(), Error>where\n    S: Satisfier<Pk>,
Attempts to produce a non-malleable satisfying witness and scriptSig to spend an\noutput controlled by the given descriptor; add the data to a given\nTxIn output.
\n
",0,"bdk_wallet::descriptor::ExtendedDescriptor","bdk_wallet::descriptor::DerivedDescriptor"],["Â§impl<Pk> Descriptor<Pk>where\n    Pk: MiniscriptKey,
pub fn new_pk(pk: Pk) -> Descriptor<Pk>
Create a new pk descriptor
\n
pub fn new_pkh(pk: Pk) -> Result<Descriptor<Pk>, Error>
Create a new PkH descriptor
\n
pub fn new_wpkh(pk: Pk) -> Result<Descriptor<Pk>, Error>
Create a new Wpkh descriptor\nWill return Err if uncompressed key is used
\n
pub fn new_sh_wpkh(pk: Pk) -> Result<Descriptor<Pk>, Error>
Create a new sh wrapped wpkh from Pk.\nErrors when uncompressed keys are supplied
\n
pub fn new_sh(ms: Miniscript<Pk, Legacy>) -> Result<Descriptor<Pk>, Error>
Create a new sh for a given redeem script\nErrors when miniscript exceeds resource limits under p2sh context\nor does not type check at the top level
\n
pub fn new_wsh(ms: Miniscript<Pk, Segwitv0>) -> Result<Descriptor<Pk>, Error>
Create a new wsh descriptor from witness script\nErrors when miniscript exceeds resource limits under p2sh context\nor does not type check at the top level
\n
pub fn new_sh_wsh(ms: Miniscript<Pk, Segwitv0>) -> Result<Descriptor<Pk>, Error>
Create a new sh wrapped wsh descriptor with witness script\nErrors when miniscript exceeds resource limits under wsh context\nor does not type check at the top level
\n
pub fn new_bare(ms: Miniscript<Pk, BareCtx>) -> Result<Descriptor<Pk>, Error>
Create a new bare descriptor from witness script\nErrors when miniscript exceeds resource limits under bare context\nor does not type check at the top level
\n
pub fn new_sh_with_wpkh(wpkh: Wpkh<Pk>) -> Descriptor<Pk>
Create a new sh wrapper for the given wpkh descriptor
\n
pub fn new_sh_with_wsh(wsh: Wsh<Pk>) -> Descriptor<Pk>
Create a new sh wrapper for the given wsh descriptor
\n
pub fn new_sh_sortedmulti(\n    k: usize,\n    pks: Vec<Pk>\n) -> Result<Descriptor<Pk>, Error>
Create a new sh sortedmulti descriptor with threshold k\nand Vec of pks.\nErrors when miniscript exceeds resource limits under p2sh context
\n
pub fn new_sh_wsh_sortedmulti(\n    k: usize,\n    pks: Vec<Pk>\n) -> Result<Descriptor<Pk>, Error>
Create a new sh wrapped wsh sortedmulti descriptor from threshold\nk and Vec of pks\nErrors when miniscript exceeds resource limits under segwit context
\n
pub fn new_wsh_sortedmulti(\n    k: usize,\n    pks: Vec<Pk>\n) -> Result<Descriptor<Pk>, Error>
Create a new wsh sorted multi descriptor\nErrors when miniscript exceeds resource limits under p2sh context
\n
pub fn new_tr(\n    key: Pk,\n    script: Option<TapTree<Pk>>\n) -> Result<Descriptor<Pk>, Error>
Create new tr descriptor\nErrors when miniscript exceeds resource limits under Tap context
\n
pub fn desc_type(&self) -> DescriptorType
Get the [DescriptorType] of Descriptor
\n
pub fn sanity_check(&self) -> Result<(), Error>
Checks whether the descriptor is safe.
\nChecks whether all the spend paths in the descriptor are possible on the\nbitcoin network under the current standardness and consensus rules. Also\nchecks whether the descriptor requires signatures on all spend paths and\nwhether the script is malleable.
\nIn general, all the guarantees of miniscript hold only for safe scripts.\nThe signer may not be able to find satisfactions even if one exists.
\n
pub fn max_weight_to_satisfy(&self) -> Result<Weight, Error>
Computes an upper bound on the difference between a non-satisfied\nTxInâs segwit_weight and a satisfied TxInâs segwit_weight
\nSince this method uses segwit_weight instead of legacy_weight,\nif you want to include only legacy inputs in your transaction,\nyou should remove 1WU from each inputâs max_weight_to_satisfy\nfor a more accurate estimate.
\nIn other words, for segwit inputs or legacy inputs included in\nsegwit transactions, the following will hold for each input if\nthat input was satisfied with the largest possible witness:
\n\nâfor i in 0..transaction.input.len() {\n    assert_eq!(\n        descriptor_for_input[i].max_weight_to_satisfy(),\n        transaction.input[i].segwit_weight() - TxIn::default().segwit_weight()\n    );\n}
\nInstead, for legacy transactions, the following will hold for each input\nif that input was satisfied with the largest possible witness:
\n\nâfor i in 0..transaction.input.len() {\n    assert_eq!(\n        descriptor_for_input[i].max_weight_to_satisfy(),\n        transaction.input[i].legacy_weight() - TxIn::default().legacy_weight()\n    );\n}
\nAssumes all ECDSA signatures are 73 bytes, including push opcode and\nsighash suffix.\nAssumes all Schnorr signatures are 66 bytes, including push opcode and\nsighash suffix.
\nÂ§Errors
\nWhen the descriptor is impossible to safisfy (ex: sh(OP_FALSE)).
\n
pub fn max_satisfaction_weight(&self) -> Result<usize, Error>
ðDeprecated since 10.0.0: Use max_weight_to_satisfy instead. The method to count bytes was redesigned and the results will differ from max_weight_to_satisfy. For more details check rust-bitcoin/rust-miniscript#476.
Computes an upper bound on the weight of a satisfying witness to the\ntransaction.
\nAssumes all ec-signatures are 73 bytes, including push opcode and\nsighash suffix. Includes the weight of the VarInts encoding the\nscriptSig and witness stack length.
\nÂ§Errors
\nWhen the descriptor is impossible to safisfy (ex: sh(OP_FALSE)).
\n
",0,"bdk_wallet::descriptor::ExtendedDescriptor","bdk_wallet::descriptor::DerivedDescriptor"],["Â§impl DescriptorExt for Descriptor<DescriptorPublicKey>
Â§fn dust_value(&self) -> u64
Returns the minimum value (in satoshis) at which an output is broadcastable.\nPanics if the descriptor wildcard is hardened.
Â§fn descriptor_id(&self) -> DescriptorId
Returns the descriptor ID, calculated as the sha256 hash of the spk derived from the\ndescriptor at index 0.
","DescriptorExt","bdk_wallet::descriptor::ExtendedDescriptor"],["Â§impl<'de, Pk> Deserialize<'de> for Descriptor<Pk>where\n    Pk: FromStrKey,
Â§fn deserialize<D>(\n    deserializer: D\n) -> Result<Descriptor<Pk>, <D as Deserializer<'de>>::Error>where\n    D: Deserializer<'de>,
Deserialize this value from the given Serde deserializer. Read more
","Deserialize<'de>","bdk_wallet::descriptor::ExtendedDescriptor","bdk_wallet::descriptor::DerivedDescriptor"],["Â§impl<Pk> Display for Descriptor<Pk>where\n    Pk: MiniscriptKey,
Â§fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>
Formats the value using the given formatter. Read more
","Display","bdk_wallet::descriptor::ExtendedDescriptor","bdk_wallet::descriptor::DerivedDescriptor"],["sourceÂ§impl ExtractPolicy for Descriptor<DescriptorPublicKey>
sourceÂ§fn extract_policy(\n    &self,\n    signers: &SignersContainer,\n    build_sat: BuildSatisfaction<'_>,\n    secp: &Secp256k1<All>\n) -> Result<Option<Policy>, Error>
Extract the spending policy
","ExtractPolicy","bdk_wallet::descriptor::ExtendedDescriptor"],["Â§impl<Pk> ForEachKey<Pk> for Descriptor<Pk>where\n    Pk: MiniscriptKey,
Â§fn for_each_key<'a, F>(&'a self, pred: F) -> boolwhere\n    F: FnMut(&'a Pk) -> bool,
Run a predicate on every key in the descriptor, returning whether\nthe predicate returned true for every key
Â§fn for_any_key<'a, F>(&'a self, pred: F) -> boolwhere\n    F: FnMut(&'a Pk) -> bool,\n    Pk: 'a,
Run a predicate on every key in the descriptor, returning whether\nthe predicate returned true for any key
","ForEachKey","bdk_wallet::descriptor::ExtendedDescriptor","bdk_wallet::descriptor::DerivedDescriptor"],["Â§impl<Pk> From<Bare<Pk>> for Descriptor<Pk>where\n    Pk: MiniscriptKey,
Â§fn from(inner: Bare<Pk>) -> Descriptor<Pk>
Converts to this type from the input type.
","From>","bdk_wallet::descriptor::ExtendedDescriptor","bdk_wallet::descriptor::DerivedDescriptor"],["Â§impl<Pk> From<Pkh<Pk>> for Descriptor<Pk>where\n    Pk: MiniscriptKey,
Â§fn from(inner: Pkh<Pk>) -> Descriptor<Pk>
Converts to this type from the input type.
","From>","bdk_wallet::descriptor::ExtendedDescriptor","bdk_wallet::descriptor::DerivedDescriptor"],["Â§impl<Pk> From<Sh<Pk>> for Descriptor<Pk>where\n    Pk: MiniscriptKey,
Â§fn from(inner: Sh<Pk>) -> Descriptor<Pk>
Converts to this type from the input type.
","From>","bdk_wallet::descriptor::ExtendedDescriptor","bdk_wallet::descriptor::DerivedDescriptor"],["Â§impl<Pk> From<Tr<Pk>> for Descriptor<Pk>where\n    Pk: MiniscriptKey,
Â§fn from(inner: Tr<Pk>) -> Descriptor<Pk>
Converts to this type from the input type.
","From>","bdk_wallet::descriptor::ExtendedDescriptor","bdk_wallet::descriptor::DerivedDescriptor"],["Â§impl<Pk> From<Wpkh<Pk>> for Descriptor<Pk>where\n    Pk: MiniscriptKey,
Â§fn from(inner: Wpkh<Pk>) -> Descriptor<Pk>
Converts to this type from the input type.
","From>","bdk_wallet::descriptor::ExtendedDescriptor","bdk_wallet::descriptor::DerivedDescriptor"],["Â§impl<Pk> From<Wsh<Pk>> for Descriptor<Pk>where\n    Pk: MiniscriptKey,
Â§fn from(inner: Wsh<Pk>) -> Descriptor<Pk>
Converts to this type from the input type.
","From>","bdk_wallet::descriptor::ExtendedDescriptor","bdk_wallet::descriptor::DerivedDescriptor"],["Â§impl<Pk> FromStr for Descriptor<Pk>where\n    Pk: FromStrKey,
Â§type Err = Error
The associated error which can be returned from parsing.
Â§fn from_str(s: &str) -> Result<Descriptor<Pk>, Error>
Parses a string s to return a value of this type. Read more
","FromStr","bdk_wallet::descriptor::ExtendedDescriptor","bdk_wallet::descriptor::DerivedDescriptor"],["Â§impl<Pk> FromTree for Descriptor<Pk>where\n    Pk: FromStrKey,
Â§fn from_tree(top: &Tree<'_>) -> Result<Descriptor<Pk>, Error>
Parse an expression tree into a descriptor.
\n
","FromTree","bdk_wallet::descriptor::ExtendedDescriptor","bdk_wallet::descriptor::DerivedDescriptor"],["Â§impl<Pk> Hash for Descriptor<Pk>where\n    Pk: Hash + MiniscriptKey,
Â§fn hash<__H>(&self, state: &mut __H)where\n    __H: Hasher,
Feeds this value into the given Hasher. Read more
1.3.0 Â· sourceÂ§fn hash_slice<H>(data: &[Self], state: &mut H)where\n    H: Hasher,\n    Self: Sized,
Feeds a slice of this type into the given Hasher. Read more
","Hash","bdk_wallet::descriptor::ExtendedDescriptor","bdk_wallet::descriptor::DerivedDescriptor"],["Â§impl<Pk> Liftable<Pk> for Descriptor<Pk>where\n    Pk: MiniscriptKey,
Â§fn lift(&self) -> Result<Policy<Pk>, Error>
Converts this object into an abstract policy.
","Liftable","bdk_wallet::descriptor::ExtendedDescriptor","bdk_wallet::descriptor::DerivedDescriptor"],["Â§impl<Pk> Ord for Descriptor<Pk>where\n    Pk: Ord + MiniscriptKey,
Â§fn cmp(&self, other: &Descriptor<Pk>) -> Ordering
This method returns an Ordering between self and other. Read more
1.21.0 Â· sourceÂ§fn max(self, other: Self) -> Selfwhere\n    Self: Sized,
Compares and returns the maximum of two values. Read more
1.21.0 Â· sourceÂ§fn min(self, other: Self) -> Selfwhere\n    Self: Sized,
Compares and returns the minimum of two values. Read more
1.50.0 Â· sourceÂ§fn clamp(self, min: Self, max: Self) -> Selfwhere\n    Self: Sized + PartialOrd,
Restrict a value to a certain interval. Read more
","Ord","bdk_wallet::descriptor::ExtendedDescriptor","bdk_wallet::descriptor::DerivedDescriptor"],["Â§impl<Pk> PartialEq for Descriptor<Pk>where\n    Pk: PartialEq + MiniscriptKey,
Â§fn eq(&self, other: &Descriptor<Pk>) -> bool
This method tests for self and other values to be equal, and is used\nby ==.
1.0.0 Â· sourceÂ§fn ne(&self, other: &Rhs) -> bool
This method tests for !=. The default implementation is almost always\nsufficient, and should not be overridden without very good reason.
","PartialEq","bdk_wallet::descriptor::ExtendedDescriptor","bdk_wallet::descriptor::DerivedDescriptor"],["Â§impl<Pk> PartialOrd for Descriptor<Pk>where\n    Pk: PartialOrd + MiniscriptKey,
Â§fn partial_cmp(&self, other: &Descriptor<Pk>) -> Option<Ordering>
This method returns an ordering between self and other values if one exists. Read more
1.0.0 Â· sourceÂ§fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self and other) and is used by the < operator. Read more
1.0.0 Â· sourceÂ§fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self and other) and is used by the <=\noperator. Read more
1.0.0 Â· sourceÂ§fn gt(&self, other: &Rhs) -> bool
This method tests greater than (for self and other) and is used by the > operator. Read more
1.0.0 Â· sourceÂ§fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self and other) and is used by the >=\noperator. Read more
","PartialOrd","bdk_wallet::descriptor::ExtendedDescriptor","bdk_wallet::descriptor::DerivedDescriptor"],["Â§impl<'de, Pk> Serialize for Descriptor<Pk>where\n    Pk: MiniscriptKey,
Â§fn serialize<S>(\n    &self,\n    serializer: S\n) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where\n    S: Serializer,
Serialize this value into the given Serde serializer. Read more
","Serialize","bdk_wallet::descriptor::ExtendedDescriptor","bdk_wallet::descriptor::DerivedDescriptor"],["Â§impl<P, Q> TranslatePk<P, Q> for Descriptor<P>where\n    P: MiniscriptKey,\n    Q: MiniscriptKey,
Â§fn translate_pk<T, E>(\n    &self,\n    t: &mut T\n) -> Result<<Descriptor<P> as TranslatePk<P, Q>>::Output, TranslateErr<E>>where\n    T: Translator<P, Q, E>,
Converts a descriptor using abstract keys to one using specific keys.
\n
Â§type Output = Descriptor<Q>
The associated output type. This must be Self<Q>.
","TranslatePk","bdk_wallet::descriptor::ExtendedDescriptor","bdk_wallet::descriptor::DerivedDescriptor"],["Â§impl<Pk> Eq for Descriptor<Pk>where\n    Pk: Eq + MiniscriptKey,
","Eq","bdk_wallet::descriptor::ExtendedDescriptor","bdk_wallet::descriptor::DerivedDescriptor"],["Â§impl<Pk> StructuralPartialEq for Descriptor<Pk>where\n    Pk: MiniscriptKey,","StructuralPartialEq","bdk_wallet::descriptor::ExtendedDescriptor","bdk_wallet::descriptor::DerivedDescriptor"]]
+"bdk_wallet":[["Â§impl<Pk> Clone for Descriptor<Pk>where\n    Pk: Clone + MiniscriptKey,
Â§fn clone(&self) -> Descriptor<Pk>
Returns a copy of the value. Read more
1.0.0 Â· sourceÂ§fn clone_from(&mut self, source: &Self)
Performs copy-assignment from source. Read more
","Clone","bdk_wallet::descriptor::ExtendedDescriptor","bdk_wallet::descriptor::DerivedDescriptor"],["Â§impl<Pk> Debug for Descriptor<Pk>where\n    Pk: MiniscriptKey,
Â§fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>
Formats the value using the given formatter. Read more
","Debug","bdk_wallet::descriptor::ExtendedDescriptor","bdk_wallet::descriptor::DerivedDescriptor"],["Â§impl Descriptor<DefiniteDescriptorKey>
pub fn derived_descriptor<C>(\n    &self,\n    secp: &Secp256k1<C>\n) -> Result<Descriptor<PublicKey>, ConversionError>where\n    C: Verification,
Convert all the public keys in the descriptor to [bitcoin::PublicKey] by deriving them or\notherwise converting them. All [bitcoin::secp256k1::XOnlyPublicKey]s are converted to by adding a\ndefault(0x02) y-coordinate.
\nÂ§Examples
\nuse miniscript::descriptor::{Descriptor, DescriptorPublicKey};\nuse miniscript::bitcoin::secp256k1;\nuse std::str::FromStr;\n\n// test from bip 86\nlet secp = secp256k1::Secp256k1::verification_only();\nlet descriptor = Descriptor::<DescriptorPublicKey>::from_str(\"tr(xpub6BgBgsespWvERF3LHQu6CnqdvfEvtMcQjYrcRzx53QJjSxarj2afYWcLteoGVky7D3UKDP9QyrLprQ3VCECoY49yfdDEHGCtMMj92pReUsQ/0/*)\")\n    .expect(\"Valid ranged descriptor\");\nlet result = descriptor.at_derivation_index(0).unwrap().derived_descriptor(&secp).expect(\"Non-hardened derivation\");\nassert_eq!(result.to_string(), \"tr(03cc8a4bc64d897bddc5fbc2f670f7a8ba0b386779106cf1223c6fc5d7cd6fc115)#6qm9h8ym\");
\nÂ§Errors
\nThis function will return an error if hardened derivation is attempted.
\n
",0,"bdk_wallet::descriptor::DerivedDescriptor"],["Â§impl Descriptor<DefiniteDescriptorKey>
pub fn plan<P>(\n    self,\n    provider: &P\n) -> Result<Plan, Descriptor<DefiniteDescriptorKey>>where\n    P: AssetProvider<DefiniteDescriptorKey>,
Returns a plan if the provided assets are sufficient to produce a non-malleable satisfaction
\nIf the assets arenât sufficient for generating a Plan, the descriptor is returned
\n
pub fn plan_mall<P>(\n    self,\n    provider: &P\n) -> Result<Plan, Descriptor<DefiniteDescriptorKey>>where\n    P: AssetProvider<DefiniteDescriptorKey>,
Returns a plan if the provided assets are sufficient to produce a malleable satisfaction
\nIf the assets arenât sufficient for generating a Plan, the descriptor is returned
\n
",0,"bdk_wallet::descriptor::DerivedDescriptor"],["Â§impl Descriptor<DescriptorPublicKey>
pub fn is_deriveable(&self) -> bool
ðDeprecated: use has_wildcards instead
Whether or not the descriptor has any wildcards
\n
pub fn has_wildcard(&self) -> bool
Whether or not the descriptor has any wildcards i.e. /*.
\n
pub fn at_derivation_index(\n    &self,\n    index: u32\n) -> Result<Descriptor<DefiniteDescriptorKey>, ConversionError>
Replaces all wildcards (i.e. /*) in the descriptor with a particular derivation index,\nturning it into a definite descriptor.
\nÂ§Errors
\n\nIf index â¥ 2^31
\n
\n
pub fn derive(\n    &self,\n    index: u32\n) -> Result<Descriptor<DefiniteDescriptorKey>, ConversionError>
ðDeprecated: use at_derivation_index instead
Deprecated name for Self::at_derivation_index.
\n
pub fn derived_descriptor<C>(\n    &self,\n    secp: &Secp256k1<C>,\n    index: u32\n) -> Result<Descriptor<PublicKey>, ConversionError>where\n    C: Verification,
Convert all the public keys in the descriptor to [bitcoin::PublicKey] by deriving them or\notherwise converting them. All [bitcoin::secp256k1::XOnlyPublicKey]s are converted to by adding a\ndefault(0x02) y-coordinate.
\nThis is a shorthand for:
\n\n    .expect(\"Valid ranged descriptor\");\nlet derived_descriptor = descriptor.at_derivation_index(index).unwrap().derived_descriptor(&secp).unwrap();
\nand is only here really here for backwards compatibility.\nSee at_derivation_index and [derived_descriptor] for more documentation.
\nÂ§Errors
\nThis function will return an error if hardened derivation is attempted.
\n
pub fn parse_descriptor<C>(\n    secp: &Secp256k1<C>,\n    s: &str\n) -> Result<(Descriptor<DescriptorPublicKey>, BTreeMap<DescriptorPublicKey, DescriptorSecretKey>), Error>where\n    C: Signing,
Parse a descriptor that may contain secret keys
\nInternally turns every secret key found into the corresponding public key and then returns a\na descriptor that only contains public keys and a map to lookup the secret key given a public key.
\n
pub fn to_string_with_secret(\n    &self,\n    key_map: &BTreeMap<DescriptorPublicKey, DescriptorSecretKey>\n) -> String
Serialize a descriptor to string with its secret keys
\n
pub fn find_derivation_index_for_spk<C>(\n    &self,\n    secp: &Secp256k1<C>,\n    script_pubkey: &Script,\n    range: Range<u32>\n) -> Result<Option<(u32, Descriptor<PublicKey>)>, ConversionError>where\n    C: Verification,
Utility method for deriving the descriptor at each index in a range to find one matching\nscript_pubkey.
\nIf it finds a match then it returns the index it was derived at and the concrete\ndescriptor at that index. If the descriptor is non-derivable then it will simply check the\nscript pubkey against the descriptor and return it if it matches (in this case the index\nreturned will be meaningless).
\n
pub fn is_multipath(&self) -> bool
Whether this descriptor contains a key that has multiple derivation paths.
\n
pub fn into_single_descriptors(\n    self\n) -> Result<Vec<Descriptor<DescriptorPublicKey>>, Error>
Get as many descriptors as different paths in this descriptor.
\nFor multipath descriptors it will return as many descriptors as there is\nâparallelâ paths. For regular descriptors it will just return itself.
\n
",0,"bdk_wallet::descriptor::ExtendedDescriptor"],["Â§impl<Pk> Descriptor<Pk>where\n    Pk: MiniscriptKey + ToPublicKey,
pub fn address(&self, network: Network) -> Result<Address, Error>
Computes the Bitcoin address of the descriptor, if one exists
\nSome descriptors like pk() donât have an address.
\nÂ§Errors
\nFor raw/bare descriptors that donât have an address.
\n
pub fn script_pubkey(&self) -> ScriptBuf
Computes the scriptpubkey of the descriptor.
\n
pub fn unsigned_script_sig(&self) -> ScriptBuf
Computes the scriptSig that will be in place for an unsigned input\nspending an output with this descriptor. For pre-segwit descriptors,\nwhich use the scriptSig for signatures, this returns the empty script.
\nThis is used in Segwit transactions to produce an unsigned transaction\nwhose txid will not change during signing (since only the witness data\nwill change).
\n
pub fn explicit_script(&self) -> Result<ScriptBuf, Error>
Computes the the underlying script before any hashing is done. For\nBare, Pkh and Wpkh this is the scriptPubkey; for ShWpkh and Sh\nthis is the redeemScript; for the others it is the witness script.
\nÂ§Errors
\nIf the descriptor is a taproot descriptor.
\n
pub fn script_code(&self) -> Result<ScriptBuf, Error>
Computes the scriptCode of a transaction output.
\nThe scriptCode is the Script of the previous transaction output being\nserialized in the sighash when evaluating a CHECKSIG & co. OP code.
\nÂ§Errors
\nIf the descriptor is a taproot descriptor.
\n
pub fn get_satisfaction<S>(\n    &self,\n    satisfier: S\n) -> Result<(Vec<Vec<u8>>, ScriptBuf), Error>where\n    S: Satisfier<Pk>,
Returns satisfying non-malleable witness and scriptSig to spend an\noutput controlled by the given descriptor if it possible to\nconstruct one using the satisfier S.
\n
pub fn get_satisfaction_mall<S>(\n    &self,\n    satisfier: S\n) -> Result<(Vec<Vec<u8>>, ScriptBuf), Error>where\n    S: Satisfier<Pk>,
Returns a possilbly mallable satisfying non-malleable witness and scriptSig to spend an\noutput controlled by the given descriptor if it possible to\nconstruct one using the satisfier S.
\n
pub fn satisfy<S>(&self, txin: &mut TxIn, satisfier: S) -> Result<(), Error>where\n    S: Satisfier<Pk>,
Attempts to produce a non-malleable satisfying witness and scriptSig to spend an\noutput controlled by the given descriptor; add the data to a given\nTxIn output.
\n
",0,"bdk_wallet::descriptor::ExtendedDescriptor","bdk_wallet::descriptor::DerivedDescriptor"],["Â§impl<Pk> Descriptor<Pk>where\n    Pk: MiniscriptKey,
pub fn new_pk(pk: Pk) -> Descriptor<Pk>
Create a new pk descriptor
\n
pub fn new_pkh(pk: Pk) -> Result<Descriptor<Pk>, Error>
Create a new PkH descriptor
\n
pub fn new_wpkh(pk: Pk) -> Result<Descriptor<Pk>, Error>
Create a new Wpkh descriptor\nWill return Err if uncompressed key is used
\n
pub fn new_sh_wpkh(pk: Pk) -> Result<Descriptor<Pk>, Error>
Create a new sh wrapped wpkh from Pk.\nErrors when uncompressed keys are supplied
\n
pub fn new_sh(ms: Miniscript<Pk, Legacy>) -> Result<Descriptor<Pk>, Error>
Create a new sh for a given redeem script\nErrors when miniscript exceeds resource limits under p2sh context\nor does not type check at the top level
\n
pub fn new_wsh(ms: Miniscript<Pk, Segwitv0>) -> Result<Descriptor<Pk>, Error>
Create a new wsh descriptor from witness script\nErrors when miniscript exceeds resource limits under p2sh context\nor does not type check at the top level
\n
pub fn new_sh_wsh(ms: Miniscript<Pk, Segwitv0>) -> Result<Descriptor<Pk>, Error>
Create a new sh wrapped wsh descriptor with witness script\nErrors when miniscript exceeds resource limits under wsh context\nor does not type check at the top level
\n
pub fn new_bare(ms: Miniscript<Pk, BareCtx>) -> Result<Descriptor<Pk>, Error>
Create a new bare descriptor from witness script\nErrors when miniscript exceeds resource limits under bare context\nor does not type check at the top level
\n
pub fn new_sh_with_wpkh(wpkh: Wpkh<Pk>) -> Descriptor<Pk>
Create a new sh wrapper for the given wpkh descriptor
\n
pub fn new_sh_with_wsh(wsh: Wsh<Pk>) -> Descriptor<Pk>
Create a new sh wrapper for the given wsh descriptor
\n
pub fn new_sh_sortedmulti(\n    k: usize,\n    pks: Vec<Pk>\n) -> Result<Descriptor<Pk>, Error>
Create a new sh sortedmulti descriptor with threshold k\nand Vec of pks.\nErrors when miniscript exceeds resource limits under p2sh context
\n
pub fn new_sh_wsh_sortedmulti(\n    k: usize,\n    pks: Vec<Pk>\n) -> Result<Descriptor<Pk>, Error>
Create a new sh wrapped wsh sortedmulti descriptor from threshold\nk and Vec of pks\nErrors when miniscript exceeds resource limits under segwit context
\n
pub fn new_wsh_sortedmulti(\n    k: usize,\n    pks: Vec<Pk>\n) -> Result<Descriptor<Pk>, Error>
Create a new wsh sorted multi descriptor\nErrors when miniscript exceeds resource limits under p2sh context
\n
pub fn new_tr(\n    key: Pk,\n    script: Option<TapTree<Pk>>\n) -> Result<Descriptor<Pk>, Error>
Create new tr descriptor\nErrors when miniscript exceeds resource limits under Tap context
\n
pub fn desc_type(&self) -> DescriptorType
Get the [DescriptorType] of Descriptor
\n
pub fn sanity_check(&self) -> Result<(), Error>
Checks whether the descriptor is safe.
\nChecks whether all the spend paths in the descriptor are possible on the\nbitcoin network under the current standardness and consensus rules. Also\nchecks whether the descriptor requires signatures on all spend paths and\nwhether the script is malleable.
\nIn general, all the guarantees of miniscript hold only for safe scripts.\nThe signer may not be able to find satisfactions even if one exists.
\n
pub fn max_weight_to_satisfy(&self) -> Result<Weight, Error>
Computes an upper bound on the difference between a non-satisfied\nTxInâs segwit_weight and a satisfied TxInâs segwit_weight
\nSince this method uses segwit_weight instead of legacy_weight,\nif you want to include only legacy inputs in your transaction,\nyou should remove 1WU from each inputâs max_weight_to_satisfy\nfor a more accurate estimate.
\nIn other words, for segwit inputs or legacy inputs included in\nsegwit transactions, the following will hold for each input if\nthat input was satisfied with the largest possible witness:
\n\nâfor i in 0..transaction.input.len() {\n    assert_eq!(\n        descriptor_for_input[i].max_weight_to_satisfy(),\n        transaction.input[i].segwit_weight() - TxIn::default().segwit_weight()\n    );\n}
\nInstead, for legacy transactions, the following will hold for each input\nif that input was satisfied with the largest possible witness:
\n\nâfor i in 0..transaction.input.len() {\n    assert_eq!(\n        descriptor_for_input[i].max_weight_to_satisfy(),\n        transaction.input[i].legacy_weight() - TxIn::default().legacy_weight()\n    );\n}
\nAssumes all ECDSA signatures are 73 bytes, including push opcode and\nsighash suffix.\nAssumes all Schnorr signatures are 66 bytes, including push opcode and\nsighash suffix.
\nÂ§Errors
\nWhen the descriptor is impossible to safisfy (ex: sh(OP_FALSE)).
\n
pub fn max_satisfaction_weight(&self) -> Result<usize, Error>
ðDeprecated since 10.0.0: Use max_weight_to_satisfy instead. The method to count bytes was redesigned and the results will differ from max_weight_to_satisfy. For more details check rust-bitcoin/rust-miniscript#476.
Computes an upper bound on the weight of a satisfying witness to the\ntransaction.
\nAssumes all ec-signatures are 73 bytes, including push opcode and\nsighash suffix. Includes the weight of the VarInts encoding the\nscriptSig and witness stack length.
\nÂ§Errors
\nWhen the descriptor is impossible to safisfy (ex: sh(OP_FALSE)).
\n
",0,"bdk_wallet::descriptor::ExtendedDescriptor","bdk_wallet::descriptor::DerivedDescriptor"],["Â§impl DescriptorExt for Descriptor<DescriptorPublicKey>
Â§fn dust_value(&self) -> u64
Returns the minimum value (in satoshis) at which an output is broadcastable.\nPanics if the descriptor wildcard is hardened.
Â§fn descriptor_id(&self) -> DescriptorId
Returns the descriptor ID, calculated as the sha256 hash of the spk derived from the\ndescriptor at index 0.
","DescriptorExt","bdk_wallet::descriptor::ExtendedDescriptor"],["Â§impl<'de, Pk> Deserialize<'de> for Descriptor<Pk>where\n    Pk: FromStrKey,
Â§fn deserialize<D>(\n    deserializer: D\n) -> Result<Descriptor<Pk>, <D as Deserializer<'de>>::Error>where\n    D: Deserializer<'de>,
Deserialize this value from the given Serde deserializer. Read more
","Deserialize<'de>","bdk_wallet::descriptor::ExtendedDescriptor","bdk_wallet::descriptor::DerivedDescriptor"],["Â§impl<Pk> Display for Descriptor<Pk>where\n    Pk: MiniscriptKey,
Â§fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>
Formats the value using the given formatter. Read more
","Display","bdk_wallet::descriptor::ExtendedDescriptor","bdk_wallet::descriptor::DerivedDescriptor"],["sourceÂ§impl ExtractPolicy for Descriptor<DescriptorPublicKey>
sourceÂ§fn extract_policy(\n    &self,\n    signers: &SignersContainer,\n    build_sat: BuildSatisfaction<'_>,\n    secp: &Secp256k1<All>\n) -> Result<Option<Policy>, Error>
Extract the spending policy
","ExtractPolicy","bdk_wallet::descriptor::ExtendedDescriptor"],["Â§impl<Pk> ForEachKey<Pk> for Descriptor<Pk>where\n    Pk: MiniscriptKey,
Â§fn for_each_key<'a, F>(&'a self, pred: F) -> boolwhere\n    F: FnMut(&'a Pk) -> bool,
Run a predicate on every key in the descriptor, returning whether\nthe predicate returned true for every key
Â§fn for_any_key<'a, F>(&'a self, pred: F) -> boolwhere\n    F: FnMut(&'a Pk) -> bool,\n    Pk: 'a,
Run a predicate on every key in the descriptor, returning whether\nthe predicate returned true for any key
","ForEachKey","bdk_wallet::descriptor::ExtendedDescriptor","bdk_wallet::descriptor::DerivedDescriptor"],["Â§impl<Pk> From<Bare<Pk>> for Descriptor<Pk>where\n    Pk: MiniscriptKey,
Â§fn from(inner: Bare<Pk>) -> Descriptor<Pk>
Converts to this type from the input type.
","From>","bdk_wallet::descriptor::ExtendedDescriptor","bdk_wallet::descriptor::DerivedDescriptor"],["Â§impl<Pk> From<Pkh<Pk>> for Descriptor<Pk>where\n    Pk: MiniscriptKey,
Â§fn from(inner: Pkh<Pk>) -> Descriptor<Pk>
Converts to this type from the input type.
","From>","bdk_wallet::descriptor::ExtendedDescriptor","bdk_wallet::descriptor::DerivedDescriptor"],["Â§impl<Pk> From<Sh<Pk>> for Descriptor<Pk>where\n    Pk: MiniscriptKey,
Â§fn from(inner: Sh<Pk>) -> Descriptor<Pk>
Converts to this type from the input type.
","From>","bdk_wallet::descriptor::ExtendedDescriptor","bdk_wallet::descriptor::DerivedDescriptor"],["Â§impl<Pk> From<Tr<Pk>> for Descriptor<Pk>where\n    Pk: MiniscriptKey,
Â§fn from(inner: Tr<Pk>) -> Descriptor<Pk>
Converts to this type from the input type.
","From>","bdk_wallet::descriptor::ExtendedDescriptor","bdk_wallet::descriptor::DerivedDescriptor"],["Â§impl<Pk> From<Wpkh<Pk>> for Descriptor<Pk>where\n    Pk: MiniscriptKey,
Â§fn from(inner: Wpkh<Pk>) -> Descriptor<Pk>
Converts to this type from the input type.
","From>","bdk_wallet::descriptor::ExtendedDescriptor","bdk_wallet::descriptor::DerivedDescriptor"],["Â§impl<Pk> From<Wsh<Pk>> for Descriptor<Pk>where\n    Pk: MiniscriptKey,
Â§fn from(inner: Wsh<Pk>) -> Descriptor<Pk>
Converts to this type from the input type.
","From>","bdk_wallet::descriptor::ExtendedDescriptor","bdk_wallet::descriptor::DerivedDescriptor"],["Â§impl<Pk> FromStr for Descriptor<Pk>where\n    Pk: FromStrKey,
Â§type Err = Error
The associated error which can be returned from parsing.
Â§fn from_str(s: &str) -> Result<Descriptor<Pk>, Error>
Parses a string s to return a value of this type. Read more
","FromStr","bdk_wallet::descriptor::ExtendedDescriptor","bdk_wallet::descriptor::DerivedDescriptor"],["Â§impl<Pk> FromTree for Descriptor<Pk>where\n    Pk: FromStrKey,
Â§fn from_tree(top: &Tree<'_>) -> Result<Descriptor<Pk>, Error>
Parse an expression tree into a descriptor.
\n
","FromTree","bdk_wallet::descriptor::ExtendedDescriptor","bdk_wallet::descriptor::DerivedDescriptor"],["Â§impl<Pk> Hash for Descriptor<Pk>where\n    Pk: Hash + MiniscriptKey,
Â§fn hash<__H>(&self, state: &mut __H)where\n    __H: Hasher,
Feeds this value into the given Hasher. Read more
1.3.0 Â· sourceÂ§fn hash_slice<H>(data: &[Self], state: &mut H)where\n    H: Hasher,\n    Self: Sized,
Feeds a slice of this type into the given Hasher. Read more
","Hash","bdk_wallet::descriptor::ExtendedDescriptor","bdk_wallet::descriptor::DerivedDescriptor"],["Â§impl<Pk> Liftable<Pk> for Descriptor<Pk>where\n    Pk: MiniscriptKey,
Â§fn lift(&self) -> Result<Policy<Pk>, Error>
Converts this object into an abstract policy.
","Liftable","bdk_wallet::descriptor::ExtendedDescriptor","bdk_wallet::descriptor::DerivedDescriptor"],["Â§impl<Pk> Ord for Descriptor<Pk>where\n    Pk: Ord + MiniscriptKey,
Â§fn cmp(&self, other: &Descriptor<Pk>) -> Ordering
This method returns an Ordering between self and other. Read more
1.21.0 Â· sourceÂ§fn max(self, other: Self) -> Selfwhere\n    Self: Sized,
Compares and returns the maximum of two values. Read more
1.21.0 Â· sourceÂ§fn min(self, other: Self) -> Selfwhere\n    Self: Sized,
Compares and returns the minimum of two values. Read more
1.50.0 Â· sourceÂ§fn clamp(self, min: Self, max: Self) -> Selfwhere\n    Self: Sized + PartialOrd,
Restrict a value to a certain interval. Read more
","Ord","bdk_wallet::descriptor::ExtendedDescriptor","bdk_wallet::descriptor::DerivedDescriptor"],["Â§impl<Pk> PartialEq for Descriptor<Pk>where\n    Pk: PartialEq + MiniscriptKey,
Â§fn eq(&self, other: &Descriptor<Pk>) -> bool
This method tests for self and other values to be equal, and is used\nby ==.
1.0.0 Â· sourceÂ§fn ne(&self, other: &Rhs) -> bool
This method tests for !=. The default implementation is almost always\nsufficient, and should not be overridden without very good reason.
","PartialEq","bdk_wallet::descriptor::ExtendedDescriptor","bdk_wallet::descriptor::DerivedDescriptor"],["Â§impl<Pk> PartialOrd for Descriptor<Pk>where\n    Pk: PartialOrd + MiniscriptKey,
Â§fn partial_cmp(&self, other: &Descriptor<Pk>) -> Option<Ordering>
This method returns an ordering between self and other values if one exists. Read more
1.0.0 Â· sourceÂ§fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self and other) and is used by the < operator. Read more
1.0.0 Â· sourceÂ§fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self and other) and is used by the <=\noperator. Read more
1.0.0 Â· sourceÂ§fn gt(&self, other: &Rhs) -> bool
This method tests greater than (for self and other) and is used by the > operator. Read more
1.0.0 Â· sourceÂ§fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self and other) and is used by the >=\noperator. Read more
","PartialOrd","bdk_wallet::descriptor::ExtendedDescriptor","bdk_wallet::descriptor::DerivedDescriptor"],["Â§impl<'de, Pk> Serialize for Descriptor<Pk>where\n    Pk: MiniscriptKey,
Â§fn serialize<S>(\n    &self,\n    serializer: S\n) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where\n    S: Serializer,
Serialize this value into the given Serde serializer. Read more
","Serialize","bdk_wallet::descriptor::ExtendedDescriptor","bdk_wallet::descriptor::DerivedDescriptor"],["Â§impl<P, Q> TranslatePk<P, Q> for Descriptor<P>where\n    P: MiniscriptKey,\n    Q: MiniscriptKey,
Â§fn translate_pk<T, E>(\n    &self,\n    t: &mut T\n) -> Result<<Descriptor<P> as TranslatePk<P, Q>>::Output, TranslateErr<E>>where\n    T: Translator<P, Q, E>,
Converts a descriptor using abstract keys to one using specific keys.
\n
Â§type Output = Descriptor<Q>
The associated output type. This must be Self<Q>.
","TranslatePk","bdk_wallet::descriptor::ExtendedDescriptor","bdk_wallet::descriptor::DerivedDescriptor"],["Â§impl<Pk> Eq for Descriptor<Pk>where\n    Pk: Eq + MiniscriptKey,
","Eq","bdk_wallet::descriptor::ExtendedDescriptor","bdk_wallet::descriptor::DerivedDescriptor"],["Â§impl<Pk> StructuralPartialEq for Descriptor<Pk>where\n    Pk: MiniscriptKey,","StructuralPartialEq","bdk_wallet::descriptor::ExtendedDescriptor","bdk_wallet::descriptor::DerivedDescriptor"]]
 };if (window.register_type_impls) {window.register_type_impls(type_impls);} else {window.pending_type_impls = type_impls;}})()
\ No newline at end of file
diff --git a/docs/.vuepress/public/docs-rs/bdk/nightly/latest/type.impl/bdk_wallet/export/struct.FullyNodedExport.js b/docs/.vuepress/public/docs-rs/bdk/nightly/latest/type.impl/bdk_wallet/export/struct.FullyNodedExport.js
index 7bdde69565..56f8c2b48d 100644
--- a/docs/.vuepress/public/docs-rs/bdk/nightly/latest/type.impl/bdk_wallet/export/struct.FullyNodedExport.js
+++ b/docs/.vuepress/public/docs-rs/bdk/nightly/latest/type.impl/bdk_wallet/export/struct.FullyNodedExport.js
@@ -1,3 +1,3 @@
 (function() {var type_impls = {
-"bdk_wallet":[["sourceÂ§impl Debug for FullyNodedExport
sourceÂ§fn fmt(&self, f: &mut Formatter<'_>) -> Result
Formats the value using the given formatter. Read more
","Debug","bdk_wallet::wallet::export::WalletExport"],["sourceÂ§impl<'de> Deserialize<'de> for FullyNodedExport
sourceÂ§fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>where\n    __D: Deserializer<'de>,
Deserialize this value from the given Serde deserializer. Read more
","Deserialize<'de>","bdk_wallet::wallet::export::WalletExport"],["sourceÂ§impl Display for FullyNodedExport
sourceÂ§fn fmt(&self, f: &mut Formatter<'_>) -> Result
Formats the value using the given formatter. Read more
","Display","bdk_wallet::wallet::export::WalletExport"],["sourceÂ§impl FromStr for FullyNodedExport
Â§type Err = Error
The associated error which can be returned from parsing.
sourceÂ§fn from_str(s: &str) -> Result<Self, Self::Err>
Parses a string s to return a value of this type. Read more
","FromStr","bdk_wallet::wallet::export::WalletExport"],["sourceÂ§impl FullyNodedExport
sourcepub fn export_wallet(\n    wallet: &Wallet,\n    label: &str,\n    include_blockheight: bool\n) -> Result<Self, &'static str>
Export a wallet
\nThis function returns an error if it determines that the walletâs descriptor(s) are not\nsupported by Bitcoin Core or donât follow the standard derivation paths defined by BIP44\nand others.
\nIf include_blockheight is true, this function will look into the walletâs database\nfor the oldest transaction it knows and use that as the earliest block to rescan.
\nIf the database is empty or include_blockheight is false, the blockheight field\nreturned will be 0.
\n
sourcepub fn descriptor(&self) -> String
Return the external descriptor
\n
sourcepub fn change_descriptor(&self) -> Option<String>
Return the internal descriptor, if present
\n
",0,"bdk_wallet::wallet::export::WalletExport"],["sourceÂ§impl Serialize for FullyNodedExport
sourceÂ§fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>where\n    __S: Serializer,
Serialize this value into the given Serde serializer. Read more","Serialize","bdk_wallet::wallet::export::WalletExport"]]
+"bdk_wallet":[["sourceÂ§impl Debug for FullyNodedExport
sourceÂ§fn fmt(&self, f: &mut Formatter<'_>) -> Result
Formats the value using the given formatter. Read more
","Debug","bdk_wallet::wallet::export::WalletExport"],["sourceÂ§impl<'de> Deserialize<'de> for FullyNodedExport
sourceÂ§fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>where\n    __D: Deserializer<'de>,
Deserialize this value from the given Serde deserializer. Read more
","Deserialize<'de>","bdk_wallet::wallet::export::WalletExport"],["sourceÂ§impl Display for FullyNodedExport
sourceÂ§fn fmt(&self, f: &mut Formatter<'_>) -> Result
Formats the value using the given formatter. Read more
","Display","bdk_wallet::wallet::export::WalletExport"],["sourceÂ§impl FromStr for FullyNodedExport
Â§type Err = Error
The associated error which can be returned from parsing.
sourceÂ§fn from_str(s: &str) -> Result<Self, Self::Err>
Parses a string s to return a value of this type. Read more
","FromStr","bdk_wallet::wallet::export::WalletExport"],["sourceÂ§impl FullyNodedExport
sourcepub fn export_wallet(\n    wallet: &Wallet,\n    label: &str,\n    include_blockheight: bool\n) -> Result<Self, &'static str>
Export a wallet
\nThis function returns an error if it determines that the walletâs descriptor(s) are not\nsupported by Bitcoin Core or donât follow the standard derivation paths defined by BIP44\nand others.
\nIf include_blockheight is true, this function will look into the walletâs database\nfor the oldest transaction it knows and use that as the earliest block to rescan.
\nIf the database is empty or include_blockheight is false, the blockheight field\nreturned will be 0.
\n
sourcepub fn descriptor(&self) -> String
Return the external descriptor
\n
sourcepub fn change_descriptor(&self) -> Option<String>
Return the internal descriptor, if present
\n
",0,"bdk_wallet::wallet::export::WalletExport"],["sourceÂ§impl Serialize for FullyNodedExport
sourceÂ§fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>where\n    __S: Serializer,
Serialize this value into the given Serde serializer. Read more","Serialize","bdk_wallet::wallet::export::WalletExport"]]
 };if (window.register_type_impls) {window.register_type_impls(type_impls);} else {window.pending_type_impls = type_impls;}})()
\ No newline at end of file
diff --git a/docs/.vuepress/public/docs-rs/bdk/nightly/latest/type.impl/std/collections/hash/set/struct.HashSet.js b/docs/.vuepress/public/docs-rs/bdk/nightly/latest/type.impl/std/collections/hash/set/struct.HashSet.js
index 53e44bfb2e..309da3c0b2 100644
--- a/docs/.vuepress/public/docs-rs/bdk/nightly/latest/type.impl/std/collections/hash/set/struct.HashSet.js
+++ b/docs/.vuepress/public/docs-rs/bdk/nightly/latest/type.impl/std/collections/hash/set/struct.HashSet.js
@@ -1,3 +1,3 @@
 (function() {var type_impls = {
-"bdk_wallet":[["1.0.0 Â· sourceÂ§impl<T, S> Clone for HashSet<T, S>where\n    T: Clone,\n    S: Clone,
sourceÂ§fn clone_from(&mut self, other: &HashSet<T, S>)
Overwrites the contents of self with a clone of the contents of source.
\nThis method is preferred over simply assigning source.clone() to self,\nas it avoids reallocation if possible.
\n
sourceÂ§fn clone(&self) -> HashSet<T, S>
Returns a copy of the value. Read more
","Clone","bdk_wallet::keys::ValidNetworks"],["1.0.0 Â· sourceÂ§impl<T, S> Debug for HashSet<T, S>where\n    T: Debug,
sourceÂ§fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>
Formats the value using the given formatter. Read more
","Debug","bdk_wallet::keys::ValidNetworks"],["1.0.0 Â· sourceÂ§impl<T, S> Default for HashSet<T, S>where\n    S: Default,
sourceÂ§fn default() -> HashSet<T, S>
Creates an empty HashSet<T, S> with the Default value for the hasher.
\n
","Default","bdk_wallet::keys::ValidNetworks"],["sourceÂ§impl<'de, T, S> Deserialize<'de> for HashSet<T, S>where\n    T: Deserialize<'de> + Eq + Hash,\n    S: BuildHasher + Default,
sourceÂ§fn deserialize<D>(\n    deserializer: D\n) -> Result<HashSet<T, S>, <D as Deserializer<'de>>::Error>where\n    D: Deserializer<'de>,
Deserialize this value from the given Serde deserializer. Read more
","Deserialize<'de>","bdk_wallet::keys::ValidNetworks"],["1.4.0 Â· sourceÂ§impl<'a, T, S> Extend<&'a T> for HashSet<T, S>where\n    T: 'a + Eq + Hash + Copy,\n    S: BuildHasher,
sourceÂ§fn extend<I>(&mut self, iter: I)where\n    I: IntoIterator<Item = &'a T>,
Extends a collection with the contents of an iterator. Read more
sourceÂ§fn extend_one(&mut self, _: &'a T)
ð¬This is a nightly-only experimental API. (extend_one)Extends a collection with exactly one element.
sourceÂ§fn extend_reserve(&mut self, additional: usize)
ð¬This is a nightly-only experimental API. (extend_one)Reserves capacity in a collection for the given number of additional elements. Read more
","Extend<&'a T>","bdk_wallet::keys::ValidNetworks"],["1.0.0 Â· sourceÂ§impl<T, S> Extend<T> for HashSet<T, S>where\n    T: Eq + Hash,\n    S: BuildHasher,
sourceÂ§fn extend<I>(&mut self, iter: I)where\n    I: IntoIterator<Item = T>,
Extends a collection with the contents of an iterator. Read more
sourceÂ§fn extend_one(&mut self, item: T)
ð¬This is a nightly-only experimental API. (extend_one)Extends a collection with exactly one element.
sourceÂ§fn extend_reserve(&mut self, additional: usize)
ð¬This is a nightly-only experimental API. (extend_one)Reserves capacity in a collection for the given number of additional elements. Read more
","Extend","bdk_wallet::keys::ValidNetworks"],["1.56.0 Â· sourceÂ§impl<T, const N: usize> From<[T; N]> for HashSet<T>where\n    T: Eq + Hash,
sourceÂ§fn from(arr: [T; N]) -> HashSet<T>
Â§Examples
\nuse std::collections::HashSet;\n\nlet set1 = HashSet::from([1, 2, 3, 4]);\nlet set2: HashSet<_> = [1, 2, 3, 4].into();\nassert_eq!(set1, set2);
\n
","From<[T; N]>","bdk_wallet::keys::ValidNetworks"],["1.0.0 Â· sourceÂ§impl<T, S> FromIterator<T> for HashSet<T, S>where\n    T: Eq + Hash,\n    S: BuildHasher + Default,
sourceÂ§fn from_iter<I>(iter: I) -> HashSet<T, S>where\n    I: IntoIterator<Item = T>,
Creates a value from an iterator. Read more
","FromIterator","bdk_wallet::keys::ValidNetworks"],["sourceÂ§impl<T> HashSet<T>
1.0.0 Â· sourcepub fn new() -> HashSet<T>
Creates an empty HashSet.
\nThe hash set is initially created with a capacity of 0, so it will not allocate until it\nis first inserted into.
\nÂ§Examples
\nuse std::collections::HashSet;\nlet set: HashSet<i32> = HashSet::new();
\n
1.0.0 Â· sourcepub fn with_capacity(capacity: usize) -> HashSet<T>
Creates an empty HashSet with at least the specified capacity.
\nThe hash set will be able to hold at least capacity elements without\nreallocating. This method is allowed to allocate for more elements than\ncapacity. If capacity is 0, the hash set will not allocate.
\nÂ§Examples
\nuse std::collections::HashSet;\nlet set: HashSet<i32> = HashSet::with_capacity(10);\nassert!(set.capacity() >= 10);
\n
",0,"bdk_wallet::keys::ValidNetworks"],["sourceÂ§impl<T, S> HashSet<T, S>
1.0.0 Â· sourcepub fn capacity(&self) -> usize
Returns the number of elements the set can hold without reallocating.
\nÂ§Examples
\nuse std::collections::HashSet;\nlet set: HashSet<i32> = HashSet::with_capacity(100);\nassert!(set.capacity() >= 100);
\n
1.0.0 Â· sourcepub fn iter(&self) -> Iter<'_, T>
An iterator visiting all elements in arbitrary order.\nThe iterator element type is &'a T.
\nÂ§Examples
\nuse std::collections::HashSet;\nlet mut set = HashSet::new();\nset.insert(\"a\");\nset.insert(\"b\");\n\n// Will print in an arbitrary order.\nfor x in set.iter() {\n    println!(\"{x}\");\n}
\nÂ§Performance
\nIn the current implementation, iterating over set takes O(capacity) time\ninstead of O(len) because it internally visits empty buckets too.
\n
1.0.0 Â· sourcepub fn len(&self) -> usize
Returns the number of elements in the set.
\nÂ§Examples
\nuse std::collections::HashSet;\n\nlet mut v = HashSet::new();\nassert_eq!(v.len(), 0);\nv.insert(1);\nassert_eq!(v.len(), 1);
\n
1.0.0 Â· sourcepub fn is_empty(&self) -> bool
Returns true if the set contains no elements.
\nÂ§Examples
\nuse std::collections::HashSet;\n\nlet mut v = HashSet::new();\nassert!(v.is_empty());\nv.insert(1);\nassert!(!v.is_empty());
\n
1.6.0 Â· sourcepub fn drain(&mut self) -> Drain<'_, T>
Clears the set, returning all elements as an iterator. Keeps the\nallocated memory for reuse.
\nIf the returned iterator is dropped before being fully consumed, it\ndrops the remaining elements. The returned iterator keeps a mutable\nborrow on the set to optimize its implementation.
\nÂ§Examples
\nuse std::collections::HashSet;\n\nlet mut set = HashSet::from([1, 2, 3]);\nassert!(!set.is_empty());\n\n// print 1, 2, 3 in an arbitrary order\nfor i in set.drain() {\n    println!(\"{i}\");\n}\n\nassert!(set.is_empty());
\n
sourcepub fn extract_if<F>(&mut self, pred: F) -> ExtractIf<'_, T, F>where\n    F: FnMut(&T) -> bool,
ð¬This is a nightly-only experimental API. (hash_extract_if)
Creates an iterator which uses a closure to determine if a value should be removed.
\nIf the closure returns true, then the value is removed and yielded.\nIf the closure returns false, the value will remain in the list and will not be yielded\nby the iterator.
\nIf the returned ExtractIf is not exhausted, e.g. because it is dropped without iterating\nor the iteration short-circuits, then the remaining elements will be retained.\nUse retain with a negated predicate if you do not need the returned iterator.
\nÂ§Examples
\nSplitting a set into even and odd values, reusing the original set:
\n\n#![feature(hash_extract_if)]\nuse std::collections::HashSet;\n\nlet mut set: HashSet<i32> = (0..8).collect();\nlet extracted: HashSet<i32> = set.extract_if(|v| v % 2 == 0).collect();\n\nlet mut evens = extracted.into_iter().collect::<Vec<_>>();\nlet mut odds = set.into_iter().collect::<Vec<_>>();\nevens.sort();\nodds.sort();\n\nassert_eq!(evens, vec![0, 2, 4, 6]);\nassert_eq!(odds, vec![1, 3, 5, 7]);
\n
1.18.0 Â· sourcepub fn retain<F>(&mut self, f: F)where\n    F: FnMut(&T) -> bool,
Retains only the elements specified by the predicate.
\nIn other words, remove all elements e for which f(&e) returns false.\nThe elements are visited in unsorted (and unspecified) order.
\nÂ§Examples
\nuse std::collections::HashSet;\n\nlet mut set = HashSet::from([1, 2, 3, 4, 5, 6]);\nset.retain(|&k| k % 2 == 0);\nassert_eq!(set, HashSet::from([2, 4, 6]));
\nÂ§Performance
\nIn the current implementation, this operation takes O(capacity) time\ninstead of O(len) because it internally visits empty buckets too.
\n
1.0.0 Â· sourcepub fn clear(&mut self)
Clears the set, removing all values.
\nÂ§Examples
\nuse std::collections::HashSet;\n\nlet mut v = HashSet::new();\nv.insert(1);\nv.clear();\nassert!(v.is_empty());
\n
1.7.0 (const: unstable) Â· sourcepub fn with_hasher(hasher: S) -> HashSet<T, S>
Creates a new empty hash set which will use the given hasher to hash\nkeys.
\nThe hash set is also created with the default initial capacity.
\nWarning: hasher is normally randomly generated, and\nis designed to allow HashSets to be resistant to attacks that\ncause many collisions and very poor performance. Setting it\nmanually using this function can expose a DoS attack vector.
\nThe hash_builder passed should implement the BuildHasher trait for\nthe HashMap to be useful, see its documentation for details.
\nÂ§Examples
\nuse std::collections::HashSet;\nuse std::hash::RandomState;\n\nlet s = RandomState::new();\nlet mut set = HashSet::with_hasher(s);\nset.insert(2);
\n
1.7.0 Â· sourcepub fn with_capacity_and_hasher(capacity: usize, hasher: S) -> HashSet<T, S>
Creates an empty HashSet with at least the specified capacity, using\nhasher to hash the keys.
\nThe hash set will be able to hold at least capacity elements without\nreallocating. This method is allowed to allocate for more elements than\ncapacity. If capacity is 0, the hash set will not allocate.
\nWarning: hasher is normally randomly generated, and\nis designed to allow HashSets to be resistant to attacks that\ncause many collisions and very poor performance. Setting it\nmanually using this function can expose a DoS attack vector.
\nThe hash_builder passed should implement the BuildHasher trait for\nthe HashMap to be useful, see its documentation for details.
\nÂ§Examples
\nuse std::collections::HashSet;\nuse std::hash::RandomState;\n\nlet s = RandomState::new();\nlet mut set = HashSet::with_capacity_and_hasher(10, s);\nset.insert(1);
\n
1.9.0 Â· sourcepub fn hasher(&self) -> &S
Returns a reference to the setâs BuildHasher.
\nÂ§Examples
\nuse std::collections::HashSet;\nuse std::hash::RandomState;\n\nlet hasher = RandomState::new();\nlet set: HashSet<i32> = HashSet::with_hasher(hasher);\nlet hasher: &RandomState = set.hasher();
\n
",0,"bdk_wallet::keys::ValidNetworks"],["sourceÂ§impl<T, S> HashSet<T, S>where\n    T: Eq + Hash,\n    S: BuildHasher,
1.0.0 Â· sourcepub fn reserve(&mut self, additional: usize)
Reserves capacity for at least additional more elements to be inserted\nin the HashSet. The collection may reserve more space to speculatively\navoid frequent reallocations. After calling reserve,\ncapacity will be greater than or equal to self.len() + additional.\nDoes nothing if capacity is already sufficient.
\nÂ§Panics
\nPanics if the new allocation size overflows usize.
\nÂ§Examples
\nuse std::collections::HashSet;\nlet mut set: HashSet<i32> = HashSet::new();\nset.reserve(10);\nassert!(set.capacity() >= 10);
\n
1.57.0 Â· sourcepub fn try_reserve(&mut self, additional: usize) -> Result<(), TryReserveError>
Tries to reserve capacity for at least additional more elements to be inserted\nin the HashSet. The collection may reserve more space to speculatively\navoid frequent reallocations. After calling try_reserve,\ncapacity will be greater than or equal to self.len() + additional if\nit returns Ok(()).\nDoes nothing if capacity is already sufficient.
\nÂ§Errors
\nIf the capacity overflows, or the allocator reports a failure, then an error\nis returned.
\nÂ§Examples
\nuse std::collections::HashSet;\nlet mut set: HashSet<i32> = HashSet::new();\nset.try_reserve(10).expect(\"why is the test harness OOMing on a handful of bytes?\");
\n
1.0.0 Â· sourcepub fn shrink_to_fit(&mut self)
Shrinks the capacity of the set as much as possible. It will drop\ndown as much as possible while maintaining the internal rules\nand possibly leaving some space in accordance with the resize policy.
\nÂ§Examples
\nuse std::collections::HashSet;\n\nlet mut set = HashSet::with_capacity(100);\nset.insert(1);\nset.insert(2);\nassert!(set.capacity() >= 100);\nset.shrink_to_fit();\nassert!(set.capacity() >= 2);
\n
1.56.0 Â· sourcepub fn shrink_to(&mut self, min_capacity: usize)
Shrinks the capacity of the set with a lower limit. It will drop\ndown no lower than the supplied limit while maintaining the internal rules\nand possibly leaving some space in accordance with the resize policy.
\nIf the current capacity is less than the lower limit, this is a no-op.
\nÂ§Examples
\nuse std::collections::HashSet;\n\nlet mut set = HashSet::with_capacity(100);\nset.insert(1);\nset.insert(2);\nassert!(set.capacity() >= 100);\nset.shrink_to(10);\nassert!(set.capacity() >= 10);\nset.shrink_to(0);\nassert!(set.capacity() >= 2);
\n
1.0.0 Â· sourcepub fn difference<'a>(\n    &'a self,\n    other: &'a HashSet<T, S>\n) -> Difference<'a, T, S>
Visits the values representing the difference,\ni.e., the values that are in self but not in other.
\nÂ§Examples
\nuse std::collections::HashSet;\nlet a = HashSet::from([1, 2, 3]);\nlet b = HashSet::from([4, 2, 3, 4]);\n\n// Can be seen as `a - b`.\nfor x in a.difference(&b) {\n    println!(\"{x}\"); // Print 1\n}\n\nlet diff: HashSet<_> = a.difference(&b).collect();\nassert_eq!(diff, [1].iter().collect());\n\n// Note that difference is not symmetric,\n// and `b - a` means something else:\nlet diff: HashSet<_> = b.difference(&a).collect();\nassert_eq!(diff, [4].iter().collect());
\n
1.0.0 Â· sourcepub fn symmetric_difference<'a>(\n    &'a self,\n    other: &'a HashSet<T, S>\n) -> SymmetricDifference<'a, T, S>
Visits the values representing the symmetric difference,\ni.e., the values that are in self or in other but not in both.
\nÂ§Examples
\nuse std::collections::HashSet;\nlet a = HashSet::from([1, 2, 3]);\nlet b = HashSet::from([4, 2, 3, 4]);\n\n// Print 1, 4 in arbitrary order.\nfor x in a.symmetric_difference(&b) {\n    println!(\"{x}\");\n}\n\nlet diff1: HashSet<_> = a.symmetric_difference(&b).collect();\nlet diff2: HashSet<_> = b.symmetric_difference(&a).collect();\n\nassert_eq!(diff1, diff2);\nassert_eq!(diff1, [1, 4].iter().collect());
\n
1.0.0 Â· sourcepub fn intersection<'a>(\n    &'a self,\n    other: &'a HashSet<T, S>\n) -> Intersection<'a, T, S>
Visits the values representing the intersection,\ni.e., the values that are both in self and other.
\nWhen an equal element is present in self and other\nthen the resulting Intersection may yield references to\none or the other. This can be relevant if T contains fields which\nare not compared by its Eq implementation, and may hold different\nvalue between the two equal copies of T in the two sets.
\nÂ§Examples
\nuse std::collections::HashSet;\nlet a = HashSet::from([1, 2, 3]);\nlet b = HashSet::from([4, 2, 3, 4]);\n\n// Print 2, 3 in arbitrary order.\nfor x in a.intersection(&b) {\n    println!(\"{x}\");\n}\n\nlet intersection: HashSet<_> = a.intersection(&b).collect();\nassert_eq!(intersection, [2, 3].iter().collect());
\n
1.0.0 Â· sourcepub fn union<'a>(&'a self, other: &'a HashSet<T, S>) -> Union<'a, T, S>
Visits the values representing the union,\ni.e., all the values in self or other, without duplicates.
\nÂ§Examples
\nuse std::collections::HashSet;\nlet a = HashSet::from([1, 2, 3]);\nlet b = HashSet::from([4, 2, 3, 4]);\n\n// Print 1, 2, 3, 4 in arbitrary order.\nfor x in a.union(&b) {\n    println!(\"{x}\");\n}\n\nlet union: HashSet<_> = a.union(&b).collect();\nassert_eq!(union, [1, 2, 3, 4].iter().collect());
\n
1.0.0 Â· sourcepub fn contains<Q>(&self, value: &Q) -> boolwhere\n    T: Borrow<Q>,\n    Q: Hash + Eq + ?Sized,
Returns true if the set contains a value.
\nThe value may be any borrowed form of the setâs value type, but\nHash and Eq on the borrowed form must match those for\nthe value type.
\nÂ§Examples
\nuse std::collections::HashSet;\n\nlet set = HashSet::from([1, 2, 3]);\nassert_eq!(set.contains(&1), true);\nassert_eq!(set.contains(&4), false);
\n
1.9.0 Â· sourcepub fn get<Q>(&self, value: &Q) -> Option<&T>where\n    T: Borrow<Q>,\n    Q: Hash + Eq + ?Sized,
Returns a reference to the value in the set, if any, that is equal to the given value.
\nThe value may be any borrowed form of the setâs value type, but\nHash and Eq on the borrowed form must match those for\nthe value type.
\nÂ§Examples
\nuse std::collections::HashSet;\n\nlet set = HashSet::from([1, 2, 3]);\nassert_eq!(set.get(&2), Some(&2));\nassert_eq!(set.get(&4), None);
\n
sourcepub fn get_or_insert(&mut self, value: T) -> &T
ð¬This is a nightly-only experimental API. (hash_set_entry)
Inserts the given value into the set if it is not present, then\nreturns a reference to the value in the set.
\nÂ§Examples
\n#![feature(hash_set_entry)]\n\nuse std::collections::HashSet;\n\nlet mut set = HashSet::from([1, 2, 3]);\nassert_eq!(set.len(), 3);\nassert_eq!(set.get_or_insert(2), &2);\nassert_eq!(set.get_or_insert(100), &100);\nassert_eq!(set.len(), 4); // 100 was inserted
\n
sourcepub fn get_or_insert_owned<Q>(&mut self, value: &Q) -> &Twhere\n    T: Borrow<Q>,\n    Q: Hash + Eq + ToOwned<Owned = T> + ?Sized,
ð¬This is a nightly-only experimental API. (hash_set_entry)
Inserts an owned copy of the given value into the set if it is not\npresent, then returns a reference to the value in the set.
\nÂ§Examples
\n#![feature(hash_set_entry)]\n\nuse std::collections::HashSet;\n\nlet mut set: HashSet<String> = [\"cat\", \"dog\", \"horse\"]\n    .iter().map(|&pet| pet.to_owned()).collect();\n\nassert_eq!(set.len(), 3);\nfor &pet in &[\"cat\", \"dog\", \"fish\"] {\n    let value = set.get_or_insert_owned(pet);\n    assert_eq!(value, pet);\n}\nassert_eq!(set.len(), 4); // a new \"fish\" was inserted
\n
sourcepub fn get_or_insert_with<Q, F>(&mut self, value: &Q, f: F) -> &Twhere\n    T: Borrow<Q>,\n    Q: Hash + Eq + ?Sized,\n    F: FnOnce(&Q) -> T,
ð¬This is a nightly-only experimental API. (hash_set_entry)
Inserts a value computed from f into the set if the given value is\nnot present, then returns a reference to the value in the set.
\nÂ§Examples
\n#![feature(hash_set_entry)]\n\nuse std::collections::HashSet;\n\nlet mut set: HashSet<String> = [\"cat\", \"dog\", \"horse\"]\n    .iter().map(|&pet| pet.to_owned()).collect();\n\nassert_eq!(set.len(), 3);\nfor &pet in &[\"cat\", \"dog\", \"fish\"] {\n    let value = set.get_or_insert_with(pet, str::to_owned);\n    assert_eq!(value, pet);\n}\nassert_eq!(set.len(), 4); // a new \"fish\" was inserted
\n
1.0.0 Â· sourcepub fn is_disjoint(&self, other: &HashSet<T, S>) -> bool
Returns true if self has no elements in common with other.\nThis is equivalent to checking for an empty intersection.
\nÂ§Examples
\nuse std::collections::HashSet;\n\nlet a = HashSet::from([1, 2, 3]);\nlet mut b = HashSet::new();\n\nassert_eq!(a.is_disjoint(&b), true);\nb.insert(4);\nassert_eq!(a.is_disjoint(&b), true);\nb.insert(1);\nassert_eq!(a.is_disjoint(&b), false);
\n
1.0.0 Â· sourcepub fn is_subset(&self, other: &HashSet<T, S>) -> bool
Returns true if the set is a subset of another,\ni.e., other contains at least all the values in self.
\nÂ§Examples
\nuse std::collections::HashSet;\n\nlet sup = HashSet::from([1, 2, 3]);\nlet mut set = HashSet::new();\n\nassert_eq!(set.is_subset(&sup), true);\nset.insert(2);\nassert_eq!(set.is_subset(&sup), true);\nset.insert(4);\nassert_eq!(set.is_subset(&sup), false);
\n
1.0.0 Â· sourcepub fn is_superset(&self, other: &HashSet<T, S>) -> bool
Returns true if the set is a superset of another,\ni.e., self contains at least all the values in other.
\nÂ§Examples
\nuse std::collections::HashSet;\n\nlet sub = HashSet::from([1, 2]);\nlet mut set = HashSet::new();\n\nassert_eq!(set.is_superset(&sub), false);\n\nset.insert(0);\nset.insert(1);\nassert_eq!(set.is_superset(&sub), false);\n\nset.insert(2);\nassert_eq!(set.is_superset(&sub), true);
\n
1.0.0 Â· sourcepub fn insert(&mut self, value: T) -> bool
Adds a value to the set.
\nReturns whether the value was newly inserted. That is:
\n\nIf the set did not previously contain this value, true is returned.
\nIf the set already contained this value, false is returned,\nand the set is not modified: original value is not replaced,\nand the value passed as argument is dropped.
\n
\nÂ§Examples
\nuse std::collections::HashSet;\n\nlet mut set = HashSet::new();\n\nassert_eq!(set.insert(2), true);\nassert_eq!(set.insert(2), false);\nassert_eq!(set.len(), 1);
\n
1.9.0 Â· sourcepub fn replace(&mut self, value: T) -> Option<T>
Adds a value to the set, replacing the existing value, if any, that is equal to the given\none. Returns the replaced value.
\nÂ§Examples
\nuse std::collections::HashSet;\n\nlet mut set = HashSet::new();\nset.insert(Vec::<i32>::new());\n\nassert_eq!(set.get(&[][..]).unwrap().capacity(), 0);\nset.replace(Vec::with_capacity(10));\nassert_eq!(set.get(&[][..]).unwrap().capacity(), 10);
\n
1.0.0 Â· sourcepub fn remove<Q>(&mut self, value: &Q) -> boolwhere\n    T: Borrow<Q>,\n    Q: Hash + Eq + ?Sized,
Removes a value from the set. Returns whether the value was\npresent in the set.
\nThe value may be any borrowed form of the setâs value type, but\nHash and Eq on the borrowed form must match those for\nthe value type.
\nÂ§Examples
\nuse std::collections::HashSet;\n\nlet mut set = HashSet::new();\n\nset.insert(2);\nassert_eq!(set.remove(&2), true);\nassert_eq!(set.remove(&2), false);
\n
1.9.0 Â· sourcepub fn take<Q>(&mut self, value: &Q) -> Option<T>where\n    T: Borrow<Q>,\n    Q: Hash + Eq + ?Sized,
Removes and returns the value in the set, if any, that is equal to the given one.
\nThe value may be any borrowed form of the setâs value type, but\nHash and Eq on the borrowed form must match those for\nthe value type.
\nÂ§Examples
\nuse std::collections::HashSet;\n\nlet mut set = HashSet::from([1, 2, 3]);\nassert_eq!(set.take(&2), Some(2));\nassert_eq!(set.take(&2), None);
\n
",0,"bdk_wallet::keys::ValidNetworks"],["sourceÂ§impl<'de, T, S, E> IntoDeserializer<'de, E> for HashSet<T, S>where\n    T: IntoDeserializer<'de, E> + Eq + Hash,\n    S: BuildHasher,\n    E: Error,
Â§type Deserializer = SeqDeserializer<<HashSet<T, S> as IntoIterator>::IntoIter, E>
The type of the deserializer being converted into.
sourceÂ§fn into_deserializer(\n    self\n) -> <HashSet<T, S> as IntoDeserializer<'de, E>>::Deserializer
Convert this value into a deserializer.
","IntoDeserializer<'de, E>","bdk_wallet::keys::ValidNetworks"],["1.0.0 Â· sourceÂ§impl<T, S> IntoIterator for HashSet<T, S>
sourceÂ§fn into_iter(self) -> IntoIter<T>
Creates a consuming iterator, that is, one that moves each value out\nof the set in arbitrary order. The set cannot be used after calling\nthis.
\nÂ§Examples
\nuse std::collections::HashSet;\nlet mut set = HashSet::new();\nset.insert(\"a\".to_string());\nset.insert(\"b\".to_string());\n\n// Not possible to collect to a Vec<String> with a regular `.iter()`.\nlet v: Vec<String> = set.into_iter().collect();\n\n// Will print in an arbitrary order.\nfor x in &v {\n    println!(\"{x}\");\n}
\n
Â§type Item = T
The type of the elements being iterated over.
Â§type IntoIter = IntoIter<T>
Which kind of iterator are we turning this into?
","IntoIterator","bdk_wallet::keys::ValidNetworks"],["1.0.0 Â· sourceÂ§impl<T, S> PartialEq for HashSet<T, S>where\n    T: Eq + Hash,\n    S: BuildHasher,
sourceÂ§fn eq(&self, other: &HashSet<T, S>) -> bool
This method tests for self and other values to be equal, and is used\nby ==.
1.0.0 Â· sourceÂ§fn ne(&self, other: &Rhs) -> bool
This method tests for !=. The default implementation is almost always\nsufficient, and should not be overridden without very good reason.
","PartialEq","bdk_wallet::keys::ValidNetworks"],["sourceÂ§impl<T, H> Serialize for HashSet<T, H>where\n    T: Serialize,
sourceÂ§fn serialize<S>(\n    &self,\n    serializer: S\n) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where\n    S: Serializer,
Serialize this value into the given Serde serializer. Read more
","Serialize","bdk_wallet::keys::ValidNetworks"],["1.0.0 Â· sourceÂ§impl<T, S> Eq for HashSet<T, S>where\n    T: Eq + Hash,\n    S: BuildHasher,","Eq","bdk_wallet::keys::ValidNetworks"]]
+"bdk_wallet":[["1.0.0 Â· sourceÂ§impl<T, S> Clone for HashSet<T, S>where\n    T: Clone,\n    S: Clone,
sourceÂ§fn clone_from(&mut self, other: &HashSet<T, S>)
Overwrites the contents of self with a clone of the contents of source.
\nThis method is preferred over simply assigning source.clone() to self,\nas it avoids reallocation if possible.
\n
sourceÂ§fn clone(&self) -> HashSet<T, S>
Returns a copy of the value. Read more
","Clone","bdk_wallet::keys::ValidNetworks"],["1.0.0 Â· sourceÂ§impl<T, S> Debug for HashSet<T, S>where\n    T: Debug,
sourceÂ§fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>
Formats the value using the given formatter. Read more
","Debug","bdk_wallet::keys::ValidNetworks"],["1.0.0 Â· sourceÂ§impl<T, S> Default for HashSet<T, S>where\n    S: Default,
sourceÂ§fn default() -> HashSet<T, S>
Creates an empty HashSet<T, S> with the Default value for the hasher.
\n
","Default","bdk_wallet::keys::ValidNetworks"],["sourceÂ§impl<'de, T, S> Deserialize<'de> for HashSet<T, S>where\n    T: Deserialize<'de> + Eq + Hash,\n    S: BuildHasher + Default,
sourceÂ§fn deserialize<D>(\n    deserializer: D\n) -> Result<HashSet<T, S>, <D as Deserializer<'de>>::Error>where\n    D: Deserializer<'de>,
Deserialize this value from the given Serde deserializer. Read more
","Deserialize<'de>","bdk_wallet::keys::ValidNetworks"],["1.4.0 Â· sourceÂ§impl<'a, T, S> Extend<&'a T> for HashSet<T, S>where\n    T: 'a + Eq + Hash + Copy,\n    S: BuildHasher,
sourceÂ§fn extend<I>(&mut self, iter: I)where\n    I: IntoIterator<Item = &'a T>,
Extends a collection with the contents of an iterator. Read more
sourceÂ§fn extend_one(&mut self, _: &'a T)
ð¬This is a nightly-only experimental API. (extend_one)Extends a collection with exactly one element.
sourceÂ§fn extend_reserve(&mut self, additional: usize)
ð¬This is a nightly-only experimental API. (extend_one)Reserves capacity in a collection for the given number of additional elements. Read more
","Extend<&'a T>","bdk_wallet::keys::ValidNetworks"],["1.0.0 Â· sourceÂ§impl<T, S> Extend<T> for HashSet<T, S>where\n    T: Eq + Hash,\n    S: BuildHasher,
sourceÂ§fn extend<I>(&mut self, iter: I)where\n    I: IntoIterator<Item = T>,
Extends a collection with the contents of an iterator. Read more
sourceÂ§fn extend_one(&mut self, item: T)
ð¬This is a nightly-only experimental API. (extend_one)Extends a collection with exactly one element.
sourceÂ§fn extend_reserve(&mut self, additional: usize)
ð¬This is a nightly-only experimental API. (extend_one)Reserves capacity in a collection for the given number of additional elements. Read more
","Extend","bdk_wallet::keys::ValidNetworks"],["1.56.0 Â· sourceÂ§impl<T, const N: usize> From<[T; N]> for HashSet<T>where\n    T: Eq + Hash,
sourceÂ§fn from(arr: [T; N]) -> HashSet<T>
Â§Examples
\nuse std::collections::HashSet;\n\nlet set1 = HashSet::from([1, 2, 3, 4]);\nlet set2: HashSet<_> = [1, 2, 3, 4].into();\nassert_eq!(set1, set2);
\n
","From<[T; N]>","bdk_wallet::keys::ValidNetworks"],["1.0.0 Â· sourceÂ§impl<T, S> FromIterator<T> for HashSet<T, S>where\n    T: Eq + Hash,\n    S: BuildHasher + Default,
sourceÂ§fn from_iter<I>(iter: I) -> HashSet<T, S>where\n    I: IntoIterator<Item = T>,
Creates a value from an iterator. Read more
","FromIterator","bdk_wallet::keys::ValidNetworks"],["sourceÂ§impl<T> HashSet<T>
1.0.0 Â· sourcepub fn new() -> HashSet<T>
Creates an empty HashSet.
\nThe hash set is initially created with a capacity of 0, so it will not allocate until it\nis first inserted into.
\nÂ§Examples
\nuse std::collections::HashSet;\nlet set: HashSet<i32> = HashSet::new();
\n
1.0.0 Â· sourcepub fn with_capacity(capacity: usize) -> HashSet<T>
Creates an empty HashSet with at least the specified capacity.
\nThe hash set will be able to hold at least capacity elements without\nreallocating. This method is allowed to allocate for more elements than\ncapacity. If capacity is 0, the hash set will not allocate.
\nÂ§Examples
\nuse std::collections::HashSet;\nlet set: HashSet<i32> = HashSet::with_capacity(10);\nassert!(set.capacity() >= 10);
\n
",0,"bdk_wallet::keys::ValidNetworks"],["sourceÂ§impl<T, S> HashSet<T, S>
1.0.0 Â· sourcepub fn capacity(&self) -> usize
Returns the number of elements the set can hold without reallocating.
\nÂ§Examples
\nuse std::collections::HashSet;\nlet set: HashSet<i32> = HashSet::with_capacity(100);\nassert!(set.capacity() >= 100);
\n
1.0.0 Â· sourcepub fn iter(&self) -> Iter<'_, T>
An iterator visiting all elements in arbitrary order.\nThe iterator element type is &'a T.
\nÂ§Examples
\nuse std::collections::HashSet;\nlet mut set = HashSet::new();\nset.insert(\"a\");\nset.insert(\"b\");\n\n// Will print in an arbitrary order.\nfor x in set.iter() {\n    println!(\"{x}\");\n}
\nÂ§Performance
\nIn the current implementation, iterating over set takes O(capacity) time\ninstead of O(len) because it internally visits empty buckets too.
\n
1.0.0 Â· sourcepub fn len(&self) -> usize
Returns the number of elements in the set.
\nÂ§Examples
\nuse std::collections::HashSet;\n\nlet mut v = HashSet::new();\nassert_eq!(v.len(), 0);\nv.insert(1);\nassert_eq!(v.len(), 1);
\n
1.0.0 Â· sourcepub fn is_empty(&self) -> bool
Returns true if the set contains no elements.
\nÂ§Examples
\nuse std::collections::HashSet;\n\nlet mut v = HashSet::new();\nassert!(v.is_empty());\nv.insert(1);\nassert!(!v.is_empty());
\n
1.6.0 Â· sourcepub fn drain(&mut self) -> Drain<'_, T>
Clears the set, returning all elements as an iterator. Keeps the\nallocated memory for reuse.
\nIf the returned iterator is dropped before being fully consumed, it\ndrops the remaining elements. The returned iterator keeps a mutable\nborrow on the set to optimize its implementation.
\nÂ§Examples
\nuse std::collections::HashSet;\n\nlet mut set = HashSet::from([1, 2, 3]);\nassert!(!set.is_empty());\n\n// print 1, 2, 3 in an arbitrary order\nfor i in set.drain() {\n    println!(\"{i}\");\n}\n\nassert!(set.is_empty());
\n
sourcepub fn extract_if<F>(&mut self, pred: F) -> ExtractIf<'_, T, F>where\n    F: FnMut(&T) -> bool,
ð¬This is a nightly-only experimental API. (hash_extract_if)
Creates an iterator which uses a closure to determine if a value should be removed.
\nIf the closure returns true, then the value is removed and yielded.\nIf the closure returns false, the value will remain in the list and will not be yielded\nby the iterator.
\nIf the returned ExtractIf is not exhausted, e.g. because it is dropped without iterating\nor the iteration short-circuits, then the remaining elements will be retained.\nUse retain with a negated predicate if you do not need the returned iterator.
\nÂ§Examples
\nSplitting a set into even and odd values, reusing the original set:
\n\n#![feature(hash_extract_if)]\nuse std::collections::HashSet;\n\nlet mut set: HashSet<i32> = (0..8).collect();\nlet extracted: HashSet<i32> = set.extract_if(|v| v % 2 == 0).collect();\n\nlet mut evens = extracted.into_iter().collect::<Vec<_>>();\nlet mut odds = set.into_iter().collect::<Vec<_>>();\nevens.sort();\nodds.sort();\n\nassert_eq!(evens, vec![0, 2, 4, 6]);\nassert_eq!(odds, vec![1, 3, 5, 7]);
\n
1.18.0 Â· sourcepub fn retain<F>(&mut self, f: F)where\n    F: FnMut(&T) -> bool,
Retains only the elements specified by the predicate.
\nIn other words, remove all elements e for which f(&e) returns false.\nThe elements are visited in unsorted (and unspecified) order.
\nÂ§Examples
\nuse std::collections::HashSet;\n\nlet mut set = HashSet::from([1, 2, 3, 4, 5, 6]);\nset.retain(|&k| k % 2 == 0);\nassert_eq!(set, HashSet::from([2, 4, 6]));
\nÂ§Performance
\nIn the current implementation, this operation takes O(capacity) time\ninstead of O(len) because it internally visits empty buckets too.
\n
1.0.0 Â· sourcepub fn clear(&mut self)
Clears the set, removing all values.
\nÂ§Examples
\nuse std::collections::HashSet;\n\nlet mut v = HashSet::new();\nv.insert(1);\nv.clear();\nassert!(v.is_empty());
\n
1.7.0 (const: unstable) Â· sourcepub fn with_hasher(hasher: S) -> HashSet<T, S>
Creates a new empty hash set which will use the given hasher to hash\nkeys.
\nThe hash set is also created with the default initial capacity.
\nWarning: hasher is normally randomly generated, and\nis designed to allow HashSets to be resistant to attacks that\ncause many collisions and very poor performance. Setting it\nmanually using this function can expose a DoS attack vector.
\nThe hash_builder passed should implement the BuildHasher trait for\nthe HashMap to be useful, see its documentation for details.
\nÂ§Examples
\nuse std::collections::HashSet;\nuse std::hash::RandomState;\n\nlet s = RandomState::new();\nlet mut set = HashSet::with_hasher(s);\nset.insert(2);
\n
1.7.0 Â· sourcepub fn with_capacity_and_hasher(capacity: usize, hasher: S) -> HashSet<T, S>
Creates an empty HashSet with at least the specified capacity, using\nhasher to hash the keys.
\nThe hash set will be able to hold at least capacity elements without\nreallocating. This method is allowed to allocate for more elements than\ncapacity. If capacity is 0, the hash set will not allocate.
\nWarning: hasher is normally randomly generated, and\nis designed to allow HashSets to be resistant to attacks that\ncause many collisions and very poor performance. Setting it\nmanually using this function can expose a DoS attack vector.
\nThe hash_builder passed should implement the BuildHasher trait for\nthe HashMap to be useful, see its documentation for details.
\nÂ§Examples
\nuse std::collections::HashSet;\nuse std::hash::RandomState;\n\nlet s = RandomState::new();\nlet mut set = HashSet::with_capacity_and_hasher(10, s);\nset.insert(1);
\n
1.9.0 Â· sourcepub fn hasher(&self) -> &S
Returns a reference to the setâs BuildHasher.
\nÂ§Examples
\nuse std::collections::HashSet;\nuse std::hash::RandomState;\n\nlet hasher = RandomState::new();\nlet set: HashSet<i32> = HashSet::with_hasher(hasher);\nlet hasher: &RandomState = set.hasher();
\n
",0,"bdk_wallet::keys::ValidNetworks"],["sourceÂ§impl<T, S> HashSet<T, S>where\n    T: Eq + Hash,\n    S: BuildHasher,
1.0.0 Â· sourcepub fn reserve(&mut self, additional: usize)
Reserves capacity for at least additional more elements to be inserted\nin the HashSet. The collection may reserve more space to speculatively\navoid frequent reallocations. After calling reserve,\ncapacity will be greater than or equal to self.len() + additional.\nDoes nothing if capacity is already sufficient.
\nÂ§Panics
\nPanics if the new allocation size overflows usize.
\nÂ§Examples
\nuse std::collections::HashSet;\nlet mut set: HashSet<i32> = HashSet::new();\nset.reserve(10);\nassert!(set.capacity() >= 10);
\n
1.57.0 Â· sourcepub fn try_reserve(&mut self, additional: usize) -> Result<(), TryReserveError>
Tries to reserve capacity for at least additional more elements to be inserted\nin the HashSet. The collection may reserve more space to speculatively\navoid frequent reallocations. After calling try_reserve,\ncapacity will be greater than or equal to self.len() + additional if\nit returns Ok(()).\nDoes nothing if capacity is already sufficient.
\nÂ§Errors
\nIf the capacity overflows, or the allocator reports a failure, then an error\nis returned.
\nÂ§Examples
\nuse std::collections::HashSet;\nlet mut set: HashSet<i32> = HashSet::new();\nset.try_reserve(10).expect(\"why is the test harness OOMing on a handful of bytes?\");
\n
1.0.0 Â· sourcepub fn shrink_to_fit(&mut self)
Shrinks the capacity of the set as much as possible. It will drop\ndown as much as possible while maintaining the internal rules\nand possibly leaving some space in accordance with the resize policy.
\nÂ§Examples
\nuse std::collections::HashSet;\n\nlet mut set = HashSet::with_capacity(100);\nset.insert(1);\nset.insert(2);\nassert!(set.capacity() >= 100);\nset.shrink_to_fit();\nassert!(set.capacity() >= 2);
\n
1.56.0 Â· sourcepub fn shrink_to(&mut self, min_capacity: usize)
Shrinks the capacity of the set with a lower limit. It will drop\ndown no lower than the supplied limit while maintaining the internal rules\nand possibly leaving some space in accordance with the resize policy.
\nIf the current capacity is less than the lower limit, this is a no-op.
\nÂ§Examples
\nuse std::collections::HashSet;\n\nlet mut set = HashSet::with_capacity(100);\nset.insert(1);\nset.insert(2);\nassert!(set.capacity() >= 100);\nset.shrink_to(10);\nassert!(set.capacity() >= 10);\nset.shrink_to(0);\nassert!(set.capacity() >= 2);
\n
1.0.0 Â· sourcepub fn difference<'a>(\n    &'a self,\n    other: &'a HashSet<T, S>\n) -> Difference<'a, T, S>
Visits the values representing the difference,\ni.e., the values that are in self but not in other.
\nÂ§Examples
\nuse std::collections::HashSet;\nlet a = HashSet::from([1, 2, 3]);\nlet b = HashSet::from([4, 2, 3, 4]);\n\n// Can be seen as `a - b`.\nfor x in a.difference(&b) {\n    println!(\"{x}\"); // Print 1\n}\n\nlet diff: HashSet<_> = a.difference(&b).collect();\nassert_eq!(diff, [1].iter().collect());\n\n// Note that difference is not symmetric,\n// and `b - a` means something else:\nlet diff: HashSet<_> = b.difference(&a).collect();\nassert_eq!(diff, [4].iter().collect());
\n
1.0.0 Â· sourcepub fn symmetric_difference<'a>(\n    &'a self,\n    other: &'a HashSet<T, S>\n) -> SymmetricDifference<'a, T, S>
Visits the values representing the symmetric difference,\ni.e., the values that are in self or in other but not in both.
\nÂ§Examples
\nuse std::collections::HashSet;\nlet a = HashSet::from([1, 2, 3]);\nlet b = HashSet::from([4, 2, 3, 4]);\n\n// Print 1, 4 in arbitrary order.\nfor x in a.symmetric_difference(&b) {\n    println!(\"{x}\");\n}\n\nlet diff1: HashSet<_> = a.symmetric_difference(&b).collect();\nlet diff2: HashSet<_> = b.symmetric_difference(&a).collect();\n\nassert_eq!(diff1, diff2);\nassert_eq!(diff1, [1, 4].iter().collect());
\n
1.0.0 Â· sourcepub fn intersection<'a>(\n    &'a self,\n    other: &'a HashSet<T, S>\n) -> Intersection<'a, T, S>
Visits the values representing the intersection,\ni.e., the values that are both in self and other.
\nWhen an equal element is present in self and other\nthen the resulting Intersection may yield references to\none or the other. This can be relevant if T contains fields which\nare not compared by its Eq implementation, and may hold different\nvalue between the two equal copies of T in the two sets.
\nÂ§Examples
\nuse std::collections::HashSet;\nlet a = HashSet::from([1, 2, 3]);\nlet b = HashSet::from([4, 2, 3, 4]);\n\n// Print 2, 3 in arbitrary order.\nfor x in a.intersection(&b) {\n    println!(\"{x}\");\n}\n\nlet intersection: HashSet<_> = a.intersection(&b).collect();\nassert_eq!(intersection, [2, 3].iter().collect());
\n
1.0.0 Â· sourcepub fn union<'a>(&'a self, other: &'a HashSet<T, S>) -> Union<'a, T, S>
Visits the values representing the union,\ni.e., all the values in self or other, without duplicates.
\nÂ§Examples
\nuse std::collections::HashSet;\nlet a = HashSet::from([1, 2, 3]);\nlet b = HashSet::from([4, 2, 3, 4]);\n\n// Print 1, 2, 3, 4 in arbitrary order.\nfor x in a.union(&b) {\n    println!(\"{x}\");\n}\n\nlet union: HashSet<_> = a.union(&b).collect();\nassert_eq!(union, [1, 2, 3, 4].iter().collect());
\n
1.0.0 Â· sourcepub fn contains<Q>(&self, value: &Q) -> boolwhere\n    T: Borrow<Q>,\n    Q: Hash + Eq + ?Sized,
Returns true if the set contains a value.
\nThe value may be any borrowed form of the setâs value type, but\nHash and Eq on the borrowed form must match those for\nthe value type.
\nÂ§Examples
\nuse std::collections::HashSet;\n\nlet set = HashSet::from([1, 2, 3]);\nassert_eq!(set.contains(&1), true);\nassert_eq!(set.contains(&4), false);
\n
1.9.0 Â· sourcepub fn get<Q>(&self, value: &Q) -> Option<&T>where\n    T: Borrow<Q>,\n    Q: Hash + Eq + ?Sized,
Returns a reference to the value in the set, if any, that is equal to the given value.
\nThe value may be any borrowed form of the setâs value type, but\nHash and Eq on the borrowed form must match those for\nthe value type.
\nÂ§Examples
\nuse std::collections::HashSet;\n\nlet set = HashSet::from([1, 2, 3]);\nassert_eq!(set.get(&2), Some(&2));\nassert_eq!(set.get(&4), None);
\n
sourcepub fn get_or_insert(&mut self, value: T) -> &T
ð¬This is a nightly-only experimental API. (hash_set_entry)
Inserts the given value into the set if it is not present, then\nreturns a reference to the value in the set.
\nÂ§Examples
\n#![feature(hash_set_entry)]\n\nuse std::collections::HashSet;\n\nlet mut set = HashSet::from([1, 2, 3]);\nassert_eq!(set.len(), 3);\nassert_eq!(set.get_or_insert(2), &2);\nassert_eq!(set.get_or_insert(100), &100);\nassert_eq!(set.len(), 4); // 100 was inserted
\n
sourcepub fn get_or_insert_owned<Q>(&mut self, value: &Q) -> &Twhere\n    T: Borrow<Q>,\n    Q: Hash + Eq + ToOwned<Owned = T> + ?Sized,
ð¬This is a nightly-only experimental API. (hash_set_entry)
Inserts an owned copy of the given value into the set if it is not\npresent, then returns a reference to the value in the set.
\nÂ§Examples
\n#![feature(hash_set_entry)]\n\nuse std::collections::HashSet;\n\nlet mut set: HashSet<String> = [\"cat\", \"dog\", \"horse\"]\n    .iter().map(|&pet| pet.to_owned()).collect();\n\nassert_eq!(set.len(), 3);\nfor &pet in &[\"cat\", \"dog\", \"fish\"] {\n    let value = set.get_or_insert_owned(pet);\n    assert_eq!(value, pet);\n}\nassert_eq!(set.len(), 4); // a new \"fish\" was inserted
\n
sourcepub fn get_or_insert_with<Q, F>(&mut self, value: &Q, f: F) -> &Twhere\n    T: Borrow<Q>,\n    Q: Hash + Eq + ?Sized,\n    F: FnOnce(&Q) -> T,
ð¬This is a nightly-only experimental API. (hash_set_entry)
Inserts a value computed from f into the set if the given value is\nnot present, then returns a reference to the value in the set.
\nÂ§Examples
\n#![feature(hash_set_entry)]\n\nuse std::collections::HashSet;\n\nlet mut set: HashSet<String> = [\"cat\", \"dog\", \"horse\"]\n    .iter().map(|&pet| pet.to_owned()).collect();\n\nassert_eq!(set.len(), 3);\nfor &pet in &[\"cat\", \"dog\", \"fish\"] {\n    let value = set.get_or_insert_with(pet, str::to_owned);\n    assert_eq!(value, pet);\n}\nassert_eq!(set.len(), 4); // a new \"fish\" was inserted
\n
1.0.0 Â· sourcepub fn is_disjoint(&self, other: &HashSet<T, S>) -> bool
Returns true if self has no elements in common with other.\nThis is equivalent to checking for an empty intersection.
\nÂ§Examples
\nuse std::collections::HashSet;\n\nlet a = HashSet::from([1, 2, 3]);\nlet mut b = HashSet::new();\n\nassert_eq!(a.is_disjoint(&b), true);\nb.insert(4);\nassert_eq!(a.is_disjoint(&b), true);\nb.insert(1);\nassert_eq!(a.is_disjoint(&b), false);
\n
1.0.0 Â· sourcepub fn is_subset(&self, other: &HashSet<T, S>) -> bool
Returns true if the set is a subset of another,\ni.e., other contains at least all the values in self.
\nÂ§Examples
\nuse std::collections::HashSet;\n\nlet sup = HashSet::from([1, 2, 3]);\nlet mut set = HashSet::new();\n\nassert_eq!(set.is_subset(&sup), true);\nset.insert(2);\nassert_eq!(set.is_subset(&sup), true);\nset.insert(4);\nassert_eq!(set.is_subset(&sup), false);
\n
1.0.0 Â· sourcepub fn is_superset(&self, other: &HashSet<T, S>) -> bool
Returns true if the set is a superset of another,\ni.e., self contains at least all the values in other.
\nÂ§Examples
\nuse std::collections::HashSet;\n\nlet sub = HashSet::from([1, 2]);\nlet mut set = HashSet::new();\n\nassert_eq!(set.is_superset(&sub), false);\n\nset.insert(0);\nset.insert(1);\nassert_eq!(set.is_superset(&sub), false);\n\nset.insert(2);\nassert_eq!(set.is_superset(&sub), true);
\n
1.0.0 Â· sourcepub fn insert(&mut self, value: T) -> bool
Adds a value to the set.
\nReturns whether the value was newly inserted. That is:
\n\nIf the set did not previously contain this value, true is returned.
\nIf the set already contained this value, false is returned,\nand the set is not modified: original value is not replaced,\nand the value passed as argument is dropped.
\n
\nÂ§Examples
\nuse std::collections::HashSet;\n\nlet mut set = HashSet::new();\n\nassert_eq!(set.insert(2), true);\nassert_eq!(set.insert(2), false);\nassert_eq!(set.len(), 1);
\n
1.9.0 Â· sourcepub fn replace(&mut self, value: T) -> Option<T>
Adds a value to the set, replacing the existing value, if any, that is equal to the given\none. Returns the replaced value.
\nÂ§Examples
\nuse std::collections::HashSet;\n\nlet mut set = HashSet::new();\nset.insert(Vec::<i32>::new());\n\nassert_eq!(set.get(&[][..]).unwrap().capacity(), 0);\nset.replace(Vec::with_capacity(10));\nassert_eq!(set.get(&[][..]).unwrap().capacity(), 10);
\n
1.0.0 Â· sourcepub fn remove<Q>(&mut self, value: &Q) -> boolwhere\n    T: Borrow<Q>,\n    Q: Hash + Eq + ?Sized,
Removes a value from the set. Returns whether the value was\npresent in the set.
\nThe value may be any borrowed form of the setâs value type, but\nHash and Eq on the borrowed form must match those for\nthe value type.
\nÂ§Examples
\nuse std::collections::HashSet;\n\nlet mut set = HashSet::new();\n\nset.insert(2);\nassert_eq!(set.remove(&2), true);\nassert_eq!(set.remove(&2), false);
\n
1.9.0 Â· sourcepub fn take<Q>(&mut self, value: &Q) -> Option<T>where\n    T: Borrow<Q>,\n    Q: Hash + Eq + ?Sized,
Removes and returns the value in the set, if any, that is equal to the given one.
\nThe value may be any borrowed form of the setâs value type, but\nHash and Eq on the borrowed form must match those for\nthe value type.
\nÂ§Examples
\nuse std::collections::HashSet;\n\nlet mut set = HashSet::from([1, 2, 3]);\nassert_eq!(set.take(&2), Some(2));\nassert_eq!(set.take(&2), None);
\n
",0,"bdk_wallet::keys::ValidNetworks"],["sourceÂ§impl<'de, T, S, E> IntoDeserializer<'de, E> for HashSet<T, S>where\n    T: IntoDeserializer<'de, E> + Eq + Hash,\n    S: BuildHasher,\n    E: Error,
Â§type Deserializer = SeqDeserializer<<HashSet<T, S> as IntoIterator>::IntoIter, E>
The type of the deserializer being converted into.
sourceÂ§fn into_deserializer(\n    self\n) -> <HashSet<T, S> as IntoDeserializer<'de, E>>::Deserializer
Convert this value into a deserializer.
","IntoDeserializer<'de, E>","bdk_wallet::keys::ValidNetworks"],["1.0.0 Â· sourceÂ§impl<T, S> IntoIterator for HashSet<T, S>
sourceÂ§fn into_iter(self) -> IntoIter<T>
Creates a consuming iterator, that is, one that moves each value out\nof the set in arbitrary order. The set cannot be used after calling\nthis.
\nÂ§Examples
\nuse std::collections::HashSet;\nlet mut set = HashSet::new();\nset.insert(\"a\".to_string());\nset.insert(\"b\".to_string());\n\n// Not possible to collect to a Vec<String> with a regular `.iter()`.\nlet v: Vec<String> = set.into_iter().collect();\n\n// Will print in an arbitrary order.\nfor x in &v {\n    println!(\"{x}\");\n}
\n
Â§type Item = T
The type of the elements being iterated over.
Â§type IntoIter = IntoIter<T>
Which kind of iterator are we turning this into?
","IntoIterator","bdk_wallet::keys::ValidNetworks"],["1.0.0 Â· sourceÂ§impl<T, S> PartialEq for HashSet<T, S>where\n    T: Eq + Hash,\n    S: BuildHasher,
sourceÂ§fn eq(&self, other: &HashSet<T, S>) -> bool
This method tests for self and other values to be equal, and is used\nby ==.
1.0.0 Â· sourceÂ§fn ne(&self, other: &Rhs) -> bool
This method tests for !=. The default implementation is almost always\nsufficient, and should not be overridden without very good reason.
","PartialEq","bdk_wallet::keys::ValidNetworks"],["sourceÂ§impl<T, H> Serialize for HashSet<T, H>where\n    T: Serialize,
sourceÂ§fn serialize<S>(\n    &self,\n    serializer: S\n) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where\n    S: Serializer,
Serialize this value into the given Serde serializer. Read more
","Serialize","bdk_wallet::keys::ValidNetworks"],["1.0.0 Â· sourceÂ§impl<T, S> Eq for HashSet<T, S>where\n    T: Eq + Hash,\n    S: BuildHasher,","Eq","bdk_wallet::keys::ValidNetworks"]]
 };if (window.register_type_impls) {window.register_type_impls(type_impls);} else {window.pending_type_impls = type_impls;}})()
\ No newline at end of file
diff --git a/docs/.vuepress/public/docs-rs/bdk/nightly/latest/type.impl/std/primitive.tuple.js b/docs/.vuepress/public/docs-rs/bdk/nightly/latest/type.impl/std/primitive.tuple.js
index 5afbd64c06..0dd8e95dfd 100644
--- a/docs/.vuepress/public/docs-rs/bdk/nightly/latest/type.impl/std/primitive.tuple.js
+++ b/docs/.vuepress/public/docs-rs/bdk/nightly/latest/type.impl/std/primitive.tuple.js
@@ -1,5 +1,5 @@
 (function() {var type_impls = {
-"bdk_chain":[["sourceÂ§impl From<BlockId> for (u32, BlockHash)
sourceÂ§fn from(block_id: BlockId) -> Self
Converts to this type from the input type.
","From","bdk_chain::Indexed"],["sourceÂ§impl<T0, T1> Merge for (T0, T1)where\n    T0: Merge,\n    T1: Merge,
sourceÂ§fn merge(&mut self, _other: Self)
Merge another object of the same type onto self.
sourceÂ§fn is_empty(&self) -> bool
Returns whether the structure is considered empty.
sourceÂ§fn take(&mut self) -> Option<Self>
Take the value, replacing it with the default value.","Merge","bdk_chain::Indexed","bdk_chain::KeychainIndexed"]],
+"bdk_chain":[["sourceÂ§impl From<BlockId> for (u32, BlockHash)
sourceÂ§fn from(block_id: BlockId) -> Self
Converts to this type from the input type.
","From","bdk_chain::Indexed"],["sourceÂ§impl<T0, T1> Merge for (T0, T1)where\n    T0: Merge,\n    T1: Merge,
sourceÂ§fn merge(&mut self, _other: Self)
Merge another object of the same type onto self.
sourceÂ§fn is_empty(&self) -> bool
Returns whether the structure is considered empty.
sourceÂ§fn take(&mut self) -> Option<Self>
Take the value, replacing it with the default value.","Merge","bdk_chain::Indexed","bdk_chain::KeychainIndexed"]],
 "bdk_wallet":[],
 "example_bitcoind_rpc_polling":[],
 "example_cli":[],

ImplementationsÂ§

impl<A> ChainPosition<A>

pub fn is_confirmed(&self) -> bool

impl<A: Clone> ChainPosition<&A>

pub fn cloned(self) -> ChainPosition<A>

impl<A: Anchor> ChainPosition<A>

pub fn confirmation_height_upper_bound(&self) -> Option<u32>

Trait ImplementationsÂ§

impl<A: Clone> Clone for ChainPosition<A>

fn clone(&self) -> ChainPosition<A>

fn clone_from(&mut self, source: &Self)

impl<A: Debug> Debug for ChainPosition<A>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

impl From<ChainPosition<ConfirmationBlockTime>> for ConfirmationTime

fn from(observed_as: ChainPosition<ConfirmationBlockTime>) -> Self

impl<A: Hash> Hash for ChainPosition<A>

fn hash<__H: Hasher>(&self, state: &mut __H)

fn hash_slice<H>(data: &[Self], state: &mut H)where +

Trait ImplementationsÂ§

impl<A: Clone> Clone for ChainPosition<A>

fn clone(&self) -> ChainPosition<A>

fn clone_from(&mut self, source: &Self)

impl<A: Debug> Debug for ChainPosition<A>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

impl From<ChainPosition<ConfirmationBlockTime>> for ConfirmationTime

fn from(observed_as: ChainPosition<ConfirmationBlockTime>) -> Self

impl<A: Hash> Hash for ChainPosition<A>

fn hash<__H: Hasher>(&self, state: &mut __H)

fn hash_slice<H>(data: &[Self], state: &mut H)where H: Hasher, Self: Sized,

impl<A: Ord> Ord for ChainPosition<A>

fn cmp(&self, other: &ChainPosition<A>) -> Ordering

fn max(self, other: Self) -> Selfwhere Self: Sized,

Enum bdk_chain::ConfirmationTimeCopy item path

Enum bdk_chain::ConfirmationTimeCopy item path

Unconfirmed

Fields

ImplementationsÂ§

impl ConfirmationTime

pub fn unconfirmed(last_seen: u64) -> Self

pub fn is_confirmed(&self) -> bool

Trait ImplementationsÂ§

impl Clone for ConfirmationTime

fn clone(&self) -> ConfirmationTime

fn clone_from(&mut self, source: &Self)

impl Debug for ConfirmationTime

fn fmt(&self, f: &mut Formatter<'_>) -> Result

impl<'de> Deserialize<'de> for ConfirmationTime

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>where - __D: Deserializer<'de>,

impl From<ChainPosition<ConfirmationBlockTime>> for ConfirmationTime

fn from(observed_as: ChainPosition<ConfirmationBlockTime>) -> Self

impl Hash for ConfirmationTime

fn hash<__H: Hasher>(&self, state: &mut __H)

fn hash_slice<H>(data: &[Self], state: &mut H)where +

ImplementationsÂ§

impl ConfirmationTime

pub fn unconfirmed(last_seen: u64) -> Self

pub fn is_confirmed(&self) -> bool

Trait ImplementationsÂ§

impl Clone for ConfirmationTime

fn clone(&self) -> ConfirmationTime

fn clone_from(&mut self, source: &Self)

impl Debug for ConfirmationTime

fn fmt(&self, f: &mut Formatter<'_>) -> Result

impl<'de> Deserialize<'de> for ConfirmationTime

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>where + __D: Deserializer<'de>,

impl From<ChainPosition<ConfirmationBlockTime>> for ConfirmationTime

fn from(observed_as: ChainPosition<ConfirmationBlockTime>) -> Self

impl Hash for ConfirmationTime

fn hash<__H: Hasher>(&self, state: &mut __H)

fn hash_slice<H>(data: &[Self], state: &mut H)where H: Hasher, Self: Sized,

impl Ord for ConfirmationTime

fn cmp(&self, other: &ConfirmationTime) -> Ordering

fn max(self, other: Self) -> Selfwhere Self: Sized,

fn min(self, other: Self) -> Selfwhere @@ -24,8 +24,8 @@ by ==.

fn ne(&self, other: &Rhs) -> bool

impl PartialOrd for ConfirmationTime

fn partial_cmp(&self, other: &ConfirmationTime) -> Option<Ordering>

fn lt(&self, other: &Rhs) -> bool

fn le(&self, other: &Rhs) -> bool

fn gt(&self, other: &Rhs) -> bool

fn hash<H: Hasher>(&self, state: &mut H)

fn hash_slice<H>(data: &[Self], state: &mut H)
where +

fn hash<H: Hasher>(&self, state: &mut H)

fn hash_slice<H>(data: &[Self], state: &mut H)
where H: Hasher, Self: Sized,

fn max(self, other: Self) -> Self
where Self: Sized,

Enum bdk_chain::ConfirmationTime

Enum bdk_chain::ConfirmationTime

`Fields`

`ImplementationsÂ§`

`Trait ImplementationsÂ§`

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where - __D: Deserializer<'de>,

fn hash<H: Hasher>(&self, state: &mut H)

fn hash_slice<H>(data: &[Self], state: &mut H)
where +

`ImplementationsÂ§`

`Trait ImplementationsÂ§`

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where + __D: Deserializer<'de>,

fn hash<H: Hasher>(&self, state: &mut H)

fn hash_slice<H>(data: &[Self], state: &mut H)
where H: Hasher, Self: Sized,

fn max(self, other: Self) -> Self
where Self: Sized,

fn min(self, other: Self) -> Self
where @@ -24,8 +24,8 @@ by `==`.

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where - S: Serializer,

`Auto Trait ImplementationsÂ§`

`Blanket ImplementationsÂ§`

impl<T> Any for T
where +operator. Read more

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where + S: Serializer,

`Auto Trait ImplementationsÂ§`

`Blanket ImplementationsÂ§`

impl<T> Any for T
where T: 'static + ?Sized,

impl<T> Borrow<T> for T
where T: ?Sized,

impl<T> BorrowMut<T> for T
where T: ?Sized,

impl<Q, K> Equivalent<K> for Q
where @@ -39,5 +39,5 @@ operator. Clone,

impl<T, U> TryFrom<U> for T
where U: Into<T>,

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

impl<V, T> VZip<V> for T
where - V: MultiLane<T>,

impl<T> DeserializeOwned for T
where - T: for<'de> Deserialize<'de>,

impl<T> DeserializeOwned for T
where + T: for<'de> Deserialize<'de>,