From be752292d8fc4b9d5b751608cf8d42183cf871ae Mon Sep 17 00:00:00 2001 From: smol <107521333+a-tiny-kirin@users.noreply.github.com> Date: Sun, 26 May 2024 08:15:36 +0000 Subject: [PATCH] (automated) deploy from commit a721698f753f6bdfe616b382fccc14a12321f55b --- search-index.js | 2 +- search.desc/wiwi/wiwi-desc-0-.js | 2 +- src-files.js | 2 +- src/wiwi/iter/adapter.rs.html | 26 +- src/wiwi/iter/double_ended.rs.html | 53 ++++ src/wiwi/iter/mod.rs.html | 12 + src/wiwi/iter/rev.rs.html | 67 +++++ src/wiwi/serialiser/buffer.rs.html | 22 +- src/wiwi/serialiser/marker.rs.html | 102 +++++++- src/wiwi/serialiser/number.rs.html | 230 +++++++++++++----- .../double_ended/trait.DoubleEndedIterator.js | 3 + trait.impl/core/marker/trait.Freeze.js | 2 +- trait.impl/core/marker/trait.Send.js | 2 +- trait.impl/core/marker/trait.Sync.js | 2 +- trait.impl/core/marker/trait.Unpin.js | 2 +- .../panic/unwind_safe/trait.RefUnwindSafe.js | 2 +- .../panic/unwind_safe/trait.UnwindSafe.js | 2 +- .../double_ended/trait.DoubleEndedIter.js} | 0 wiwi/all.html | 2 +- .../double_ended/trait.DoubleEndedIter.html | 11 + wiwi/iter/index.html | 6 +- wiwi/iter/rev/struct.Rev.html | 11 + wiwi/iter/sidebar-items.js | 2 +- wiwi/iter/struct.Empty.html | 16 +- wiwi/iter/struct.FromFn.html | 16 +- wiwi/iter/struct.IterAdapter.html | 34 ++- wiwi/iter/struct.Map.html | 16 +- wiwi/iter/struct.Peek.html | 16 +- wiwi/iter/struct.RepeatPerItem.html | 16 +- wiwi/iter/struct.Rev.html | 30 +++ wiwi/iter/struct.Tuple1.html | 16 +- wiwi/iter/struct.Tuple10.html | 16 +- wiwi/iter/struct.Tuple11.html | 16 +- wiwi/iter/struct.Tuple12.html | 16 +- wiwi/iter/struct.Tuple13.html | 16 +- wiwi/iter/struct.Tuple14.html | 16 +- wiwi/iter/struct.Tuple15.html | 16 +- wiwi/iter/struct.Tuple16.html | 16 +- wiwi/iter/struct.Tuple17.html | 16 +- wiwi/iter/struct.Tuple18.html | 16 +- wiwi/iter/struct.Tuple19.html | 16 +- wiwi/iter/struct.Tuple2.html | 16 +- wiwi/iter/struct.Tuple20.html | 16 +- wiwi/iter/struct.Tuple21.html | 16 +- wiwi/iter/struct.Tuple22.html | 16 +- wiwi/iter/struct.Tuple23.html | 16 +- wiwi/iter/struct.Tuple24.html | 16 +- wiwi/iter/struct.Tuple25.html | 16 +- wiwi/iter/struct.Tuple26.html | 16 +- wiwi/iter/struct.Tuple27.html | 16 +- wiwi/iter/struct.Tuple28.html | 16 +- wiwi/iter/struct.Tuple29.html | 16 +- wiwi/iter/struct.Tuple3.html | 16 +- wiwi/iter/struct.Tuple30.html | 16 +- wiwi/iter/struct.Tuple31.html | 16 +- wiwi/iter/struct.Tuple32.html | 16 +- wiwi/iter/struct.Tuple4.html | 16 +- wiwi/iter/struct.Tuple5.html | 16 +- wiwi/iter/struct.Tuple6.html | 16 +- wiwi/iter/struct.Tuple7.html | 16 +- wiwi/iter/struct.Tuple8.html | 16 +- wiwi/iter/struct.Tuple9.html | 16 +- wiwi/iter/trait.AsStdIterator.html | 6 +- wiwi/iter/trait.AsWiwiIter.html | 6 +- wiwi/iter/trait.DoubleEndedIter.html | 14 ++ wiwi/iter/trait.IntoStdIterator.html | 6 +- wiwi/iter/trait.IntoWiwiIter.html | 6 +- wiwi/iter/trait.Iter.html | 18 +- wiwi/serialiser/buffer/index.html | 2 +- wiwi/serialiser/buffer/trait.BufferRead.html | 2 +- wiwi/serialiser/buffer/trait.BufferWrite.html | 2 +- wiwi/serialiser/marker/index.html | 2 +- wiwi/serialiser/marker/sidebar-items.js | 2 +- wiwi/serialiser/marker/struct.Marker.html | 12 + wiwi/serialiser/number/index.html | 2 +- .../serialiser/serialise/trait.Serialise.html | 4 +- .../pool/struct.SlicesWrapIter.html | 8 +- 77 files changed, 879 insertions(+), 434 deletions(-) create mode 100644 src/wiwi/iter/double_ended.rs.html create mode 100644 src/wiwi/iter/rev.rs.html create mode 100644 trait.impl/core/iter/traits/double_ended/trait.DoubleEndedIterator.js rename trait.impl/wiwi/{serialiser/serialise/trait.Serialise.js => iter/double_ended/trait.DoubleEndedIter.js} (100%) create mode 100644 wiwi/iter/double_ended/trait.DoubleEndedIter.html create mode 100644 wiwi/iter/rev/struct.Rev.html create mode 100644 wiwi/iter/struct.Rev.html create mode 100644 wiwi/iter/trait.DoubleEndedIter.html create mode 100644 wiwi/serialiser/marker/struct.Marker.html diff --git a/search-index.js b/search-index.js index 3443ac1ec..1238f7b51 100644 --- a/search-index.js +++ b/search-index.js @@ -1,5 +1,5 @@ var searchIndex = new Map(JSON.parse('[\ -["wiwi",{"t":"CCCCCCCCCQCCCCCCCQQQQQCCCCCCFINNNNNNNNNNNNNNNNCCFFFFFFFFFFFNNNNNNNNNNNNNNNNNNNNNNOOOOONNNNNNNNNNNOONNNNNNNNNNNHHHHHHOOOOOOOOOONNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNOONNNNNNNNNNNFFNNNNOOOONNOONNHHOOOOONNNNNNNNNNNNOOOOONNTTTKFKNNNNNNNMMNONMNMNNNNNNNNFNNNNNNNNNNNNNNNNNNNNFFFFFFFRFFKFFFFFFFFFFFFFFNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNCNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNFFNNNNCNENNNNNNNNNNNNNNNNNNNNNNNNNNNNFFFFNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNHHHHHGPPSSSNNHHHNNNNNNNNNNNNFFNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNKKFPFPKKKRRKRRRFRRFFRKFFGFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFPNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNMNMNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNMNMNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNHNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNHNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNMNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNMNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNMNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNOOPFGPNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNCFFNNNNNNNNHNNNNNNNNNNNNNNKTYKMNHHHHSHEFEEEEFTTEEFTNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNEEEEEENNNNNNNEEENNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNENNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNCCCCCCKKNNNMNMMNNMKHMHGKIKPPNNNNMNNNNNHMMHMHMHHHNNNNNNNNNNNNNOOQQQQQQKFNNONNNNNNHMHNNNNNNNNFKRFNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNCNNNMNNNMCNNNNNNNNNFKRFFNNNNNNNNNNNNNNNNNNNNNNNNNNNNMNNNNMNNNNNNNNNNNNNNNNNNNNNNNNNNFNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNFNNNNNNNNNNNNKMMMSGPPPSSSSSNNHHNNNNNNNNNNNNN","n":["auth","bigint","bitstream","chainer","clock_timer","debounce","h","hex","id","int_range","iter","lazy_wrap","lsl","memory_usage","path","prelude","serialiser","smallint_negative_as_unsigned_range","smallint_negative_range","smallint_positive_range","smallint_signed_range","smallint_unsigned_range","string_pool","sudoku","to_maybeuninit","z85","error","flow","Error","Result","borrow","borrow_mut","fmt","fmt","from","from","into","source","to_maybeuninit","to_maybeuninit_drop","to_maybeuninit_mut","to_string","try_from","try_into","type_id","vzip","signin","signup","ClientContinuerS1","ClientContinuerS2","ClientContinuerS3","ServerS2Params","ServerS3Params","SigninRequestS1","SigninRequestS2","SigninRequestS3","SigninResponseS1","SigninResponseS2","SigninResponseS3","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","challenge_signature","encrypted_user_sec_key","encrypted_user_sec_key","encrypted_user_sec_key_nonce","encrypted_user_sec_key_nonce","from","from","from","from","from","from","from","from","from","from","from","hashed_pw_verifier","hashed_pw_verifier_salt","into","into","into","into","into","into","into","into","into","into","into","process_signin_client_final","process_signin_client_s1","process_signin_client_s2","process_signin_client_s3","process_signin_server_s2","process_signin_server_s3","pw_key_salt","pw_verifier","pw_verifier_salt","session_id","session_pub_key","signin_attempt_id","signin_attempt_id","signin_attempt_id","signing_challenge","signing_challenge","to_maybeuninit","to_maybeuninit","to_maybeuninit","to_maybeuninit","to_maybeuninit","to_maybeuninit","to_maybeuninit","to_maybeuninit","to_maybeuninit","to_maybeuninit","to_maybeuninit","to_maybeuninit_drop","to_maybeuninit_drop","to_maybeuninit_drop","to_maybeuninit_drop","to_maybeuninit_drop","to_maybeuninit_drop","to_maybeuninit_drop","to_maybeuninit_drop","to_maybeuninit_drop","to_maybeuninit_drop","to_maybeuninit_drop","to_maybeuninit_mut","to_maybeuninit_mut","to_maybeuninit_mut","to_maybeuninit_mut","to_maybeuninit_mut","to_maybeuninit_mut","to_maybeuninit_mut","to_maybeuninit_mut","to_maybeuninit_mut","to_maybeuninit_mut","to_maybeuninit_mut","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","type_id","type_id","type_id","type_id","type_id","type_id","type_id","type_id","type_id","type_id","type_id","user_id","user_public_key","vzip","vzip","vzip","vzip","vzip","vzip","vzip","vzip","vzip","vzip","vzip","SignupRequest","StoredUnverifiedUserData","borrow","borrow","borrow_mut","borrow_mut","encrypted_user_sec_key","encrypted_user_sec_key","encrypted_user_sec_key_nonce","encrypted_user_sec_key_nonce","from","from","hashed_pw_verifier","hashed_pw_verifier_salt","into","into","process_signup_client","process_signup_server","pw_key_salt","pw_key_salt","pw_verifier","pw_verifier_salt","pw_verifier_salt","to_maybeuninit","to_maybeuninit","to_maybeuninit_drop","to_maybeuninit_drop","to_maybeuninit_mut","to_maybeuninit_mut","try_from","try_from","try_into","try_into","type_id","type_id","user_id","user_id","user_public_key","user_public_key","verification_token","vzip","vzip","BITS","MAX","MIN","Part","U320","UnsignedBigint","add_unchecked","borrow","borrow_mut","clone","clone_into","fmt","from","from_bool","from_le_parts","from_le_parts","inner","into","into_le_parts","into_le_parts","overflowing_add","to_maybeuninit","to_maybeuninit_drop","to_maybeuninit_mut","to_owned","try_from","try_into","type_id","vzip","Encoder","borrow","borrow_mut","from","into","into_bytes","new","to_maybeuninit","to_maybeuninit_drop","to_maybeuninit_mut","try_from","try_into","type_id","vzip","with_output_capacity","write_bits_u128_unchecked","write_bits_u16_unchecked","write_bits_u32_unchecked","write_bits_u64_unchecked","write_bits_u8_unchecked","write_bits_usize_unchecked","ArrayChain","ArrayMutChain","ArrayRefChain","BTreeMapChain","BTreeSetChain","BinaryHeapChain","BitstreamEncoderChain","Chain","HashMapChain","HashSetChain","IntoChainer","LinkedListChain","SliceBoxChain","SliceMutChain","SliceRefChain","StrBoxChain","StrMutChain","StrRefChain","StringChain","StringMutChain","StringRefChain","VecChain","VecDequeChain","VecMutChain","VecRefChain","append","append","append_vec_chain","as_chunks","as_chunks_mut","as_chunks_unchecked","as_chunks_unchecked_mut","as_mut","as_mut","as_rchunks","as_rchunks_mut","as_ref","as_ref","assume_init","assume_init","binary_search","binary_search_by","binary_search_by_key","binary_search_by_key_uninit","binary_search_by_uninit","binary_search_uninit","borrow","borrow","borrow","borrow","borrow","borrow","borrow","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","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","capacity","capacity","capacity","capacity_uninit","capacity_uninit","capacity_uninit","clear","clear","clone","clone_from_slice","clone_into","contains","contains_uninit","copy_from_slice","copy_within","dedup","dedup_by","dedup_by_key","dedup_by_key_mut","dedup_by_mut","default","drain","ends_with","ends_with_uninit","extend_from_slice","extend_from_within","extend_from_within","fill","fill_with","first","first","first","first","first_chunk","first_chunk_mut","first_mut","first_mut","first_mut","flatten","flatten","flatten","fmt","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","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from_raw_parts","from_raw_parts","from_utf16","from_utf16_lossy","from_utf8","from_utf8_unchecked","get","get_mut","get_unchecked","get_unchecked_mut","insert","insert","insert_str","into","into","into","into","into","into","into","into","into","into","into","into","into","into","into","into","into","into","into","into","into","into","into","into_binary_heap","into_bytes","into_bytes","into_bytes_chainer","into_bytes_chainer","into_chainer","into_chainer","into_inner","into_inner","into_inner","into_inner","into_inner","into_inner","into_inner","into_raw_parts","into_sorted_vec","into_sorted_vec_chainer","into_vec_chain","into_vec_chain","is_ascii","is_ascii_uninit","is_empty","is_empty","is_empty","is_empty","is_empty","is_empty_uninit","is_empty_uninit","is_empty_uninit","is_empty_uninit","is_empty_uninit","last","last","last","last_chunk","last_chunk_mut","last_mut","last_mut","leak","len","len","len","len","len","len_uninit","len_uninit","len_uninit","len_uninit","len_uninit","make_ascii_lowercase","make_ascii_uppercase","new","new","new","new","new","new","new","new","new_uninit","new_uninit","new_zeroed","new_zeroed","nonchain_array","nonchain_array","nonchain_array","nonchain_array_chainer_mut","nonchain_array_chainer_ref","nonchain_array_chainer_ref","nonchain_array_mut","nonchain_array_mut","nonchain_boxed_slice","nonchain_boxed_slice_chainer","nonchain_bytes","nonchain_contiguous_mut","nonchain_inner","nonchain_ptr","nonchain_ptr","nonchain_ptr_mut","nonchain_ptr_mut","nonchain_ptr_range","nonchain_ptr_range_mut","nonchain_raw_parts","nonchain_slice","nonchain_slice","nonchain_slice","nonchain_slice","nonchain_slice","nonchain_slice","nonchain_slice","nonchain_slice_chainer_mut","nonchain_slice_chainer_mut","nonchain_slice_chainer_mut","nonchain_slice_chainer_mut","nonchain_slice_chainer_ref","nonchain_slice_chainer_ref","nonchain_slice_chainer_ref","nonchain_slice_chainer_ref","nonchain_slice_chainer_ref","nonchain_slice_chainer_ref","nonchain_slice_chainers_mut","nonchain_slice_chainers_ref","nonchain_slice_mut","nonchain_slice_mut","nonchain_slice_mut","nonchain_slice_mut","nonchain_slice_mut","nonchain_slices","nonchain_slices_mut","nonchain_str","nonchain_str_mut","nonchain_vec","nonchain_vec_deque","nonchain_vec_deque_mut","nonchain_vec_mut","nonchain_vec_mut","pop","pop","pop","pop_uninit","pop_uninit","pop_uninit","push","push","push","push_str","remove","remove","remove_uninit","remove_uninit","repeat","reserve","reserve","reserve","reserve_exact","reserve_exact","reserve_exact","resize","resize_with","retain","retain","retain","retain_mut","reverse","set_len","shrink_to","shrink_to","shrink_to_fit","shrink_to_fit","sort","sort","sort_and_dedup","sort_by","sort_by","sort_by_cached_key","sort_by_cached_key","sort_by_key","sort_by_key","sort_floats","sort_floats","sort_unstable","sort_unstable","sort_unstable_by","sort_unstable_by","sort_unstable_by_key","sort_unstable_by_key","spare_capacity_mut","splice","split","split_at_spare_mut","split_first","split_first_chunk","split_first_chunk_mut","split_first_mut","split_last","split_last_chunk","split_last_chunk_mut","split_last_mut","split_left_off","split_left_off_uninit","split_right_off","split_right_off_uninit","starts_with","starts_with_uninit","swap","swap_remove","swap_remove_uninit","swap_unchecked","swap_with_slice","to_maybeuninit","to_maybeuninit","to_maybeuninit","to_maybeuninit","to_maybeuninit","to_maybeuninit","to_maybeuninit","to_maybeuninit","to_maybeuninit","to_maybeuninit","to_maybeuninit","to_maybeuninit","to_maybeuninit","to_maybeuninit","to_maybeuninit","to_maybeuninit","to_maybeuninit","to_maybeuninit","to_maybeuninit","to_maybeuninit","to_maybeuninit","to_maybeuninit","to_maybeuninit","to_maybeuninit_drop","to_maybeuninit_drop","to_maybeuninit_drop","to_maybeuninit_drop","to_maybeuninit_drop","to_maybeuninit_drop","to_maybeuninit_drop","to_maybeuninit_drop","to_maybeuninit_drop","to_maybeuninit_drop","to_maybeuninit_drop","to_maybeuninit_drop","to_maybeuninit_drop","to_maybeuninit_drop","to_maybeuninit_drop","to_maybeuninit_drop","to_maybeuninit_drop","to_maybeuninit_drop","to_maybeuninit_drop","to_maybeuninit_drop","to_maybeuninit_drop","to_maybeuninit_drop","to_maybeuninit_drop","to_maybeuninit_mut","to_maybeuninit_mut","to_maybeuninit_mut","to_maybeuninit_mut","to_maybeuninit_mut","to_maybeuninit_mut","to_maybeuninit_mut","to_maybeuninit_mut","to_maybeuninit_mut","to_maybeuninit_mut","to_maybeuninit_mut","to_maybeuninit_mut","to_maybeuninit_mut","to_maybeuninit_mut","to_maybeuninit_mut","to_maybeuninit_mut","to_maybeuninit_mut","to_maybeuninit_mut","to_maybeuninit_mut","to_maybeuninit_mut","to_maybeuninit_mut","to_maybeuninit_mut","to_maybeuninit_mut","to_owned","traits","truncate","truncate","truncate_unchecked","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_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","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","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","vzip","vzip","vzip","vzip","vzip","vzip","vzip","vzip","vzip","vzip","vzip","windows","with_capacity","with_capacity","with_capacity","with_capacity","with_capacity","with_capacity","with_output_capacity","with_peek","with_peek_mut","write_bits_u128_unchecked","write_bits_u16_unchecked","write_bits_u32_unchecked","write_bits_u64_unchecked","write_bits_u8_unchecked","ClockTimer","Tick","borrow","borrow","borrow_mut","borrow_mut","builder","builder","chrono","delayed","elapsed","end_time","from","from","into","into","past_due","remaining","run_to_end","start_time","tick","time","to_maybeuninit","to_maybeuninit","to_maybeuninit_drop","to_maybeuninit_drop","to_maybeuninit_mut","to_maybeuninit_mut","total_runtime","try_from","try_from","try_into","try_into","type_id","type_id","vzip","vzip","Builder","BuilderWithEnd","BuilderWithInterval","BuilderWithStart","borrow","borrow","borrow","borrow","borrow_mut","borrow_mut","borrow_mut","borrow_mut","build","from","from","from","from","into","into","into","into","new","to_maybeuninit","to_maybeuninit","to_maybeuninit","to_maybeuninit","to_maybeuninit_drop","to_maybeuninit_drop","to_maybeuninit_drop","to_maybeuninit_drop","to_maybeuninit_mut","to_maybeuninit_mut","to_maybeuninit_mut","to_maybeuninit_mut","try_from","try_from","try_from","try_from","try_into","try_into","try_into","try_into","type_id","type_id","type_id","type_id","vzip","vzip","vzip","vzip","with_duration","with_end_datetime","with_interval","with_start_datetime","debounce","debounce_immediate","debounce_immediate_with_rt","debounce_with_rt","h","DecodeError","InvalidChar","InvalidLength","TABLE_ENCODER_LEN","TABLE_ENCODER_LOWER","TABLE_ENCODER_UPPER","borrow","borrow_mut","decode_hex","encode_hex","encode_hex_upper","fmt","fmt","from","into","to_maybeuninit","to_maybeuninit_drop","to_maybeuninit_mut","to_string","try_from","try_into","type_id","vzip","GeneratedID","IDGenerator","as_signed","as_unsigned","as_unsigned_nonzero","borrow","borrow","borrow_mut","borrow_mut","from","from","from_signed","from_signed_unchecked","from_unsigned","from_unsigned_unchecked","into","into","new","next","to_maybeuninit","to_maybeuninit","to_maybeuninit_drop","to_maybeuninit_drop","to_maybeuninit_mut","to_maybeuninit_mut","try_from","try_from","try_into","try_into","type_id","type_id","unix_time","vzip","vzip","AsStdIterator","AsWiwiIter","Empty","Estimate","FromFn","HardBound","IntoIter","IntoStdIterator","IntoWiwiIter","Item","Item","Iter","Iter","Iter","Iter","IterAdapter","Iterator","Iterator","Map","Peek","PeekItem","Peekable","RepeatPerItem","SizeHint","SizeHintBound","Tuple1","Tuple10","Tuple11","Tuple12","Tuple13","Tuple14","Tuple15","Tuple16","Tuple17","Tuple18","Tuple19","Tuple2","Tuple20","Tuple21","Tuple22","Tuple23","Tuple24","Tuple25","Tuple26","Tuple27","Tuple28","Tuple29","Tuple3","Tuple30","Tuple31","Tuple32","Tuple4","Tuple5","Tuple6","Tuple7","Tuple8","Tuple9","Unknown","batch_invert","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","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","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","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_std_as_wiwi_iter","borrow_std_as_wiwi_iter","borrow_wiwi_as_std_iterator","borrow_wiwi_as_std_iterator","borrow_wiwi_as_std_iterator","borrow_wiwi_as_std_iterator","borrow_wiwi_as_std_iterator","borrow_wiwi_as_std_iterator","borrow_wiwi_as_std_iterator","borrow_wiwi_as_std_iterator","borrow_wiwi_as_std_iterator","borrow_wiwi_as_std_iterator","borrow_wiwi_as_std_iterator","borrow_wiwi_as_std_iterator","borrow_wiwi_as_std_iterator","borrow_wiwi_as_std_iterator","borrow_wiwi_as_std_iterator","borrow_wiwi_as_std_iterator","borrow_wiwi_as_std_iterator","borrow_wiwi_as_std_iterator","borrow_wiwi_as_std_iterator","borrow_wiwi_as_std_iterator","borrow_wiwi_as_std_iterator","borrow_wiwi_as_std_iterator","borrow_wiwi_as_std_iterator","borrow_wiwi_as_std_iterator","borrow_wiwi_as_std_iterator","borrow_wiwi_as_std_iterator","borrow_wiwi_as_std_iterator","borrow_wiwi_as_std_iterator","borrow_wiwi_as_std_iterator","borrow_wiwi_as_std_iterator","borrow_wiwi_as_std_iterator","borrow_wiwi_as_std_iterator","borrow_wiwi_as_std_iterator","borrow_wiwi_as_std_iterator","borrow_wiwi_as_std_iterator","borrow_wiwi_as_std_iterator","borrow_wiwi_as_std_iterator","borrow_wiwi_as_std_iterator","borrow_wiwi_as_std_iterator","convert_std_into_wiwi_iter","convert_std_into_wiwi_iter","convert_wiwi_into_std_iterator","convert_wiwi_into_std_iterator","convert_wiwi_into_std_iterator","convert_wiwi_into_std_iterator","convert_wiwi_into_std_iterator","convert_wiwi_into_std_iterator","convert_wiwi_into_std_iterator","convert_wiwi_into_std_iterator","convert_wiwi_into_std_iterator","convert_wiwi_into_std_iterator","convert_wiwi_into_std_iterator","convert_wiwi_into_std_iterator","convert_wiwi_into_std_iterator","convert_wiwi_into_std_iterator","convert_wiwi_into_std_iterator","convert_wiwi_into_std_iterator","convert_wiwi_into_std_iterator","convert_wiwi_into_std_iterator","convert_wiwi_into_std_iterator","convert_wiwi_into_std_iterator","convert_wiwi_into_std_iterator","convert_wiwi_into_std_iterator","convert_wiwi_into_std_iterator","convert_wiwi_into_std_iterator","convert_wiwi_into_std_iterator","convert_wiwi_into_std_iterator","convert_wiwi_into_std_iterator","convert_wiwi_into_std_iterator","convert_wiwi_into_std_iterator","convert_wiwi_into_std_iterator","convert_wiwi_into_std_iterator","convert_wiwi_into_std_iterator","convert_wiwi_into_std_iterator","convert_wiwi_into_std_iterator","convert_wiwi_into_std_iterator","convert_wiwi_into_std_iterator","convert_wiwi_into_std_iterator","convert_wiwi_into_std_iterator","convert_wiwi_into_std_iterator","count","default","empty","estimate","fmt","fmt","for_each","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","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from_fn","hard_bound","into","into","into","into","into","into","into","into","into","into","into","into","into","into","into","into","into","into","into","into","into","into","into","into","into","into","into","into","into","into","into","into","into","into","into","into","into","into","into","into","into_inner","into_inner","into_inner","into_iter","into_std_hint","into_wiwi_iter","into_wiwi_iter","into_wiwi_iter","into_wiwi_iter","into_wiwi_iter","into_wiwi_iter","into_wiwi_iter","into_wiwi_iter","into_wiwi_iter","into_wiwi_iter","into_wiwi_iter","into_wiwi_iter","into_wiwi_iter","into_wiwi_iter","into_wiwi_iter","into_wiwi_iter","into_wiwi_iter","into_wiwi_iter","into_wiwi_iter","into_wiwi_iter","into_wiwi_iter","into_wiwi_iter","into_wiwi_iter","into_wiwi_iter","into_wiwi_iter","into_wiwi_iter","into_wiwi_iter","into_wiwi_iter","into_wiwi_iter","into_wiwi_iter","into_wiwi_iter","into_wiwi_iter","into_wiwi_iter","into_wiwi_iter","into_wiwi_iter","into_wiwi_iter","into_wiwi_iter","into_wiwi_iter","into_wiwi_iter","map","new","next","next","next","next","next","next","next","next","next","next","next","next","next","next","next","next","next","next","next","next","next","next","next","next","next","next","next","next","next","next","next","next","next","next","next","next","next","next","next","next","peek","peek","peekable","repeat_per_item","size_hint","size_hint","size_hint","size_hint","size_hint","size_hint","size_hint","size_hint","size_hint","size_hint","size_hint","size_hint","size_hint","size_hint","size_hint","size_hint","size_hint","size_hint","size_hint","size_hint","size_hint","size_hint","size_hint","size_hint","size_hint","size_hint","size_hint","size_hint","size_hint","size_hint","size_hint","size_hint","size_hint","size_hint","size_hint","size_hint","size_hint","size_hint","size_hint","split","to_maybeuninit","to_maybeuninit","to_maybeuninit","to_maybeuninit","to_maybeuninit","to_maybeuninit","to_maybeuninit","to_maybeuninit","to_maybeuninit","to_maybeuninit","to_maybeuninit","to_maybeuninit","to_maybeuninit","to_maybeuninit","to_maybeuninit","to_maybeuninit","to_maybeuninit","to_maybeuninit","to_maybeuninit","to_maybeuninit","to_maybeuninit","to_maybeuninit","to_maybeuninit","to_maybeuninit","to_maybeuninit","to_maybeuninit","to_maybeuninit","to_maybeuninit","to_maybeuninit","to_maybeuninit","to_maybeuninit","to_maybeuninit","to_maybeuninit","to_maybeuninit","to_maybeuninit","to_maybeuninit","to_maybeuninit","to_maybeuninit","to_maybeuninit","to_maybeuninit","to_maybeuninit_drop","to_maybeuninit_drop","to_maybeuninit_drop","to_maybeuninit_drop","to_maybeuninit_drop","to_maybeuninit_drop","to_maybeuninit_drop","to_maybeuninit_drop","to_maybeuninit_drop","to_maybeuninit_drop","to_maybeuninit_drop","to_maybeuninit_drop","to_maybeuninit_drop","to_maybeuninit_drop","to_maybeuninit_drop","to_maybeuninit_drop","to_maybeuninit_drop","to_maybeuninit_drop","to_maybeuninit_drop","to_maybeuninit_drop","to_maybeuninit_drop","to_maybeuninit_drop","to_maybeuninit_drop","to_maybeuninit_drop","to_maybeuninit_drop","to_maybeuninit_drop","to_maybeuninit_drop","to_maybeuninit_drop","to_maybeuninit_drop","to_maybeuninit_drop","to_maybeuninit_drop","to_maybeuninit_drop","to_maybeuninit_drop","to_maybeuninit_drop","to_maybeuninit_drop","to_maybeuninit_drop","to_maybeuninit_drop","to_maybeuninit_drop","to_maybeuninit_drop","to_maybeuninit_drop","to_maybeuninit_mut","to_maybeuninit_mut","to_maybeuninit_mut","to_maybeuninit_mut","to_maybeuninit_mut","to_maybeuninit_mut","to_maybeuninit_mut","to_maybeuninit_mut","to_maybeuninit_mut","to_maybeuninit_mut","to_maybeuninit_mut","to_maybeuninit_mut","to_maybeuninit_mut","to_maybeuninit_mut","to_maybeuninit_mut","to_maybeuninit_mut","to_maybeuninit_mut","to_maybeuninit_mut","to_maybeuninit_mut","to_maybeuninit_mut","to_maybeuninit_mut","to_maybeuninit_mut","to_maybeuninit_mut","to_maybeuninit_mut","to_maybeuninit_mut","to_maybeuninit_mut","to_maybeuninit_mut","to_maybeuninit_mut","to_maybeuninit_mut","to_maybeuninit_mut","to_maybeuninit_mut","to_maybeuninit_mut","to_maybeuninit_mut","to_maybeuninit_mut","to_maybeuninit_mut","to_maybeuninit_mut","to_maybeuninit_mut","to_maybeuninit_mut","to_maybeuninit_mut","to_maybeuninit_mut","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_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_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","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","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","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","type_id","type_id","type_id","type_id","type_id","type_id","type_id","type_id","type_id","type_id","type_id","type_id","unknown","vzip","vzip","vzip","vzip","vzip","vzip","vzip","vzip","vzip","vzip","vzip","vzip","vzip","vzip","vzip","vzip","vzip","vzip","vzip","vzip","vzip","vzip","vzip","vzip","vzip","vzip","vzip","vzip","vzip","vzip","vzip","vzip","vzip","vzip","vzip","vzip","vzip","vzip","vzip","vzip","with_lower_estimate","with_lower_hard_bound","with_lower_unknown","with_upper_estimate","with_upper_hard_bound","with_upper_unknown","bound","estimate","Initialised","LazyWrap","LazyWrapState","Uninitialised","as_mut","as_ref","borrow","borrow","borrow_mut","borrow_mut","deref","deref_mut","drop","ensure_initialised","fmt","fmt","from","from","into","into","into_inner","into_inner_initialised","is_initialised","new","to_maybeuninit","to_maybeuninit","to_maybeuninit_drop","to_maybeuninit_drop","to_maybeuninit_mut","to_maybeuninit_mut","to_string","try_from","try_from","try_into","try_into","type_id","type_id","vzip","vzip","callback_api","Script","ScriptBuilder","borrow","borrow","borrow_mut","borrow_mut","from","from","into","into","script","to_maybeuninit","to_maybeuninit","to_maybeuninit_drop","to_maybeuninit_drop","to_maybeuninit_mut","to_maybeuninit_mut","try_from","try_from","try_into","try_into","type_id","type_id","vzip","vzip","Dynamic","MEMORY_USAGE","MemoryUsage","Static","calculate_memory_usage","calculate_values_usage","dynamic_mem_usage_of_val","dynamic_values_usage_of_val","static_mem_usage_of","static_mem_usage_of_val","SEP","basename","ClockTimer","DateTime","GeneratedID","IDGenerator","LazyWrap","LazyWrapState","Local","MAX_UTC","MIN_UTC","String","Tick","TimeDelta","UNIX_EPOCH","abs","add","add","add","add","add","add","add_assign","add_assign","add_assign","borrow","borrow","borrow","borrow_mut","borrow_mut","borrow_mut","checked_add","checked_add_days","checked_add_months","checked_add_signed","checked_sub","checked_sub_days","checked_sub_months","checked_sub_signed","clone","clone","clone","clone_into","clone_into","clone_into","cmp","cmp","date","date_naive","day","day0","days","debounce","debounce_immediate","debounce_immediate_with_rt","debounce_with_rt","decode_hex","decode_z85","default","default","default","default","div","duration_round","duration_trunc","encode_hex","encode_hex_upper","encode_z85","eq","eq","equivalent","equivalent","equivalent","equivalent","fixed_offset","fmt","fmt","fmt","fmt","fmt","format","format_with_items","from","from","from","from","from","from","from","from","from","from","from","from_local","from_naive_utc_and_offset","from_offset","from_std","from_str","from_str","from_str","from_timestamp","from_timestamp_micros","from_timestamp_millis","from_timestamp_nanos","from_utc","h","hash","hash","hour","hours","into","into","into","is_zero","iso_week","max_value","microseconds","milliseconds","min_value","minute","minutes","month","month0","mul","naive_local","naive_utc","nanosecond","nanoseconds","neg","new","now","num_days","num_hours","num_microseconds","num_milliseconds","num_minutes","num_nanoseconds","num_seconds","num_weeks","offset","offset_from_local_date","offset_from_local_datetime","offset_from_utc_date","offset_from_utc_datetime","ordinal","ordinal0","parse_and_remainder","parse_from_rfc2822","parse_from_rfc3339","parse_from_str","partial_cmp","partial_cmp","round_subsecs","second","seconds","signed_duration_since","sub","sub","sub","sub","sub","sub","sub","sub","sub_assign","sub_assign","sub_assign","subsec_nanos","sum","sum","time","timestamp","timestamp_micros","timestamp_millis","timestamp_nanos","timestamp_nanos_opt","timestamp_subsec_micros","timestamp_subsec_millis","timestamp_subsec_nanos","timezone","to_maybeuninit","to_maybeuninit","to_maybeuninit","to_maybeuninit_drop","to_maybeuninit_drop","to_maybeuninit_drop","to_maybeuninit_mut","to_maybeuninit_mut","to_maybeuninit_mut","to_owned","to_owned","to_owned","to_rfc2822","to_rfc3339","to_rfc3339_opts","to_std","to_string","to_string","to_utc","today","trunc_subsecs","try_days","try_from","try_from","try_from","try_hours","try_into","try_into","try_into","try_milliseconds","try_minutes","try_seconds","try_weeks","type_id","type_id","type_id","vzip","vzip","vzip","weekday","weeks","with_day","with_day0","with_hour","with_minute","with_month","with_month0","with_nanosecond","with_ordinal","with_ordinal0","with_second","with_timezone","with_year","year","years_since","zero","buffer","deserialise","error","marker","number","serialise","BufferRead","BufferWrite","read_byte","read_bytes","read_bytes_const","read_bytes_ptr","read_bytes_ptr_const","reserve","with_ptr","write_byte","write_bytes","write_bytes_unchecked","Deserialise","deserialise","deserialise","deserialise_lax","Error","OptionExt","Result","ResultExt","Str","String","borrow","borrow_mut","clone","clone_into","convert_err","convert_err","deref","eq","equivalent","equivalent","err_eof","err_eof","err_f","err_str","err_str","err_string","err_string","error_eof","error_str","error_string","fmt","fmt","from","into","to_maybeuninit","to_maybeuninit_drop","to_maybeuninit_mut","to_owned","to_string","try_from","try_into","type_id","vzip","msg","msg","int_range","smallint_negative_as_unsigned_range","smallint_negative_range","smallint_positive_range","smallint_signed_range","smallint_unsigned_range","Serialise","SerialiseOptions","borrow","borrow_mut","capacity","clone","clone_into","default","fmt","from","into","serialise","serialise","serialise_with_options","to_maybeuninit","to_maybeuninit_drop","to_maybeuninit_mut","to_owned","try_from","try_into","type_id","vzip","GlobalPool","Pool","Raw","String","add","add","add","add","add","add","add","add","add","add","add_assign","add_assign","add_assign","as_ref","as_ref","as_ref","as_ref","borrow","borrow","borrow_mut","clone","clone_into","default","deref","fmt","fmt","from","from","from","into","pool","raw_clone","raw_empty","raw_from_slice","raw_from_slices","raw_from_vec","raw_into_boxed_slice","raw_into_vec","raw_to_slice","string","to_maybeuninit","to_maybeuninit_drop","to_maybeuninit_mut","to_owned","to_string","try_from","try_into","type_id","vzip","GlobalPool","Pool","Raw","SlicesWrap","SlicesWrapIter","borrow","borrow","borrow","borrow_mut","borrow_mut","borrow_mut","borrow_std_as_wiwi_iter","clone","clone_into","convert_std_into_wiwi_iter","default","equivalent","fmt","fmt","from","from","from","hash","into","into","into","into_iter","into_iter","next","raw_clone","raw_clone","raw_empty","raw_from_slice","raw_from_slices","raw_from_slices","raw_from_vec","raw_into_boxed_slice","raw_into_vec","raw_to_slice","raw_to_slice","size_hint","to_boxed_slice","to_maybeuninit","to_maybeuninit","to_maybeuninit","to_maybeuninit_drop","to_maybeuninit_drop","to_maybeuninit_drop","to_maybeuninit_mut","to_maybeuninit_mut","to_maybeuninit_mut","to_owned","to_vec","try_from","try_from","try_from","try_into","try_into","try_into","type_id","type_id","type_id","vzip","vzip","vzip","String","as_bytes","as_str","clear","clone_to","from_str_in","from_utf16","from_utf16_in","from_utf16_lossy","from_utf16_lossy_in","from_utf8","from_utf8_in","from_utf8_lossy","from_utf8_lossy_in","from_utf8_slice","from_utf8_slice_in","from_utf8_unchecked","from_utf8_unchecked_in","from_utf8_unchecked_slice","from_utf8_unchecked_slice_in","insert","insert_str","into_boxed_str","into_bytes","into_other_pool","leak","new","new_in","pop","push","push_str","remove","retain","split_off","split_off_in","to_other_pool","truncate","Board","borrow","borrow_mut","from","into","new","to_maybeuninit","to_maybeuninit_drop","to_maybeuninit_mut","try_from","try_into","type_id","vzip","ToMaybeUninit","to_maybeuninit","to_maybeuninit_drop","to_maybeuninit_mut","BINARY_FRAME_LEN","DecodeError","FrameOverflow","InvalidChar","InvalidLength","STRING_FRAME_LEN","TABLE_DECODER","TABLE_DECODER_LEN","TABLE_ENCODER","TABLE_ENCODER_LEN","borrow","borrow_mut","decode_z85","encode_z85","eq","fmt","fmt","from","into","to_maybeuninit","to_maybeuninit_drop","to_maybeuninit_mut","to_string","try_from","try_into","type_id","vzip"],"q":[[0,"wiwi"],[26,"wiwi::auth"],[28,"wiwi::auth::error"],[46,"wiwi::auth::flow"],[48,"wiwi::auth::flow::signin"],[205,"wiwi::auth::flow::signup"],[247,"wiwi::bigint"],[276,"wiwi::bitstream"],[297,"wiwi::chainer"],[883,"wiwi::clock_timer"],[920,"wiwi::clock_timer::builder"],[974,"wiwi::debounce"],[978,"wiwi::h"],[979,"wiwi::hex"],[1002,"wiwi::id"],[1036,"wiwi::iter"],[1763,"wiwi::iter::SizeHintBound"],[1765,"wiwi::lazy_wrap"],[1804,"wiwi::lsl"],[1805,"wiwi::lsl::callback_api"],[1830,"wiwi::memory_usage"],[1840,"wiwi::path"],[1842,"wiwi::prelude"],[2076,"wiwi::serialiser"],[2082,"wiwi::serialiser::buffer"],[2094,"wiwi::serialiser::deserialise"],[2098,"wiwi::serialiser::error"],[2137,"wiwi::serialiser::error::Error"],[2139,"wiwi::serialiser::number"],[2145,"wiwi::serialiser::serialise"],[2167,"wiwi::string_pool"],[2220,"wiwi::string_pool::pool"],[2285,"wiwi::string_pool::string"],[2322,"wiwi::sudoku"],[2335,"wiwi::to_maybeuninit"],[2339,"wiwi::z85"],[2366,"core::fmt"],[2367,"core::convert"],[2368,"core::error"],[2369,"core::option"],[2370,"core::mem::maybe_uninit"],[2371,"alloc::string"],[2372,"core::result"],[2373,"core::any"],[2374,"alloc::vec"],[2375,"wiwi::chainer::binary_heap"],[2376,"alloc::collections::binary_heap"],[2377,"core::cmp"],[2378,"wiwi::chainer::vec"],[2379,"core::ops::function"],[2380,"wiwi::chainer::slice_box"],[2381,"wiwi::chainer::array"],[2382,"wiwi::chainer::string"],[2383,"core::clone"],[2384,"core::marker"],[2385,"core::ops::range"],[2386,"core::default"],[2387,"alloc::vec::drain"],[2388,"wiwi::chainer::slice_ref"],[2389,"wiwi::chainer::slice_mut"],[2390,"wiwi::chainer::vec_ref"],[2391,"wiwi::chainer::vec_mut"],[2392,"alloc::boxed"],[2393,"wiwi::chainer::array_ref"],[2394,"wiwi::chainer::array_mut"],[2395,"wiwi::chainer::string_ref"],[2396,"wiwi::chainer::string_mut"],[2397,"wiwi::chainer::str_box"],[2398,"wiwi::chainer::str_ref"],[2399,"wiwi::chainer::str_mut"],[2400,"alloc::collections::vec_deque"],[2401,"wiwi::chainer::vec_deque"],[2402,"alloc::collections::linked_list"],[2403,"wiwi::chainer::linked_list"],[2404,"std::collections::hash::map"],[2405,"wiwi::chainer::hash_map"],[2406,"std::collections::hash::set"],[2407,"wiwi::chainer::hash_set"],[2408,"alloc::collections::btree::map"],[2409,"wiwi::chainer::btree_map"],[2410,"alloc::collections::btree::set"],[2411,"wiwi::chainer::btree_set"],[2412,"wiwi::chainer::bitstream"],[2413,"core::slice::index"],[2414,"wiwi::chainer::into_chainer"],[2415,"wiwi::iter::into_iter"],[2416,"wiwi::iter::adapter"],[2417,"alloc::vec::splice"],[2418,"core::slice::iter"],[2419,"chrono::time_delta"],[2420,"chrono::offset::local"],[2421,"chrono::datetime"],[2422,"core::future::future"],[2423,"chrono::offset"],[2424,"tokio::runtime::handle"],[2425,"core::num::nonzero"],[2426,"core::iter::traits::iterator"],[2427,"wiwi::iter::size_hint"],[2428,"wiwi::iter::empty"],[2429,"wiwi::iter::from_fn"],[2430,"wiwi::iter::map"],[2431,"wiwi::iter::peek"],[2432,"wiwi::iter::repeat_per_item"],[2433,"wiwi::iter::tuple"],[2434,"wiwi::lsl::callback_api::script"],[2435,"core::time"],[2436,"chrono::naive"],[2437,"chrono::month"],[2438,"chrono::offset::fixed"],[2439,"chrono::date"],[2440,"chrono::naive::date"],[2441,"chrono::offset::utc"],[2442,"chrono::format::strftime"],[2443,"chrono::format::formatting"],[2444,"chrono::format"],[2445,"core::borrow"],[2446,"std::time"],[2447,"chrono::naive::datetime"],[2448,"core::hash"],[2449,"chrono::naive::isoweek"],[2450,"chrono::naive::time"],[2451,"chrono::weekday"],[2452,"std::ffi::os_str"],[2453,"std::path"],[2454,"wiwi::string_pool::pool::global"],[2455,"core::str::error"],[2456,"wiwiwiwiwi"]],"i":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,0,0,0,0,0,0,0,0,0,0,0,0,0,17,22,13,16,21,24,25,26,20,23,14,17,22,13,16,21,24,25,26,20,23,14,24,25,23,25,23,17,22,13,16,21,24,25,26,20,23,14,25,25,17,22,13,16,21,24,25,26,20,23,14,0,0,0,0,0,0,20,21,20,14,24,21,24,20,26,23,17,22,13,16,21,24,25,26,20,23,14,17,22,13,16,21,24,25,26,20,23,14,17,22,13,16,21,24,25,26,20,23,14,17,22,13,16,21,24,25,26,20,23,14,17,22,13,16,21,24,25,26,20,23,14,17,22,13,16,21,24,25,26,20,23,14,16,26,17,22,13,16,21,24,25,26,20,23,14,0,0,27,28,27,28,27,28,27,28,27,28,28,28,27,28,0,0,27,28,27,27,28,27,28,27,28,27,28,27,28,27,28,27,28,27,28,27,28,28,27,28,29,29,29,0,0,0,29,30,30,30,30,30,30,32,29,30,30,30,29,30,32,30,30,30,30,30,30,30,30,0,35,35,35,35,35,35,35,35,35,35,35,35,35,35,35,35,35,35,35,35,0,0,0,0,0,0,0,92,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,42,45,45,45,45,45,45,45,45,45,45,45,45,48,49,45,45,45,45,45,45,64,65,48,61,62,49,67,68,53,69,70,72,73,74,76,78,80,82,84,86,42,87,45,64,65,48,61,62,49,67,68,53,69,70,72,73,74,76,78,80,82,84,86,42,87,45,53,42,45,53,42,45,53,45,45,45,45,45,45,45,45,45,45,45,45,45,45,45,45,45,45,53,45,45,45,61,62,49,45,45,45,62,49,45,61,62,45,45,64,64,65,65,48,48,61,61,62,62,49,49,67,67,68,68,53,53,69,69,70,70,72,72,73,73,74,74,76,76,78,78,80,80,82,82,84,84,86,86,42,42,87,87,45,45,53,45,53,53,53,53,45,45,45,45,53,45,53,64,65,48,61,62,49,67,68,53,69,70,72,73,74,76,78,80,82,84,86,42,87,45,42,53,87,53,87,92,92,48,61,62,49,67,68,76,53,42,42,61,62,45,45,61,62,49,53,45,61,62,49,53,45,61,62,45,45,45,62,45,45,61,62,49,53,45,61,62,49,53,45,45,45,53,76,78,80,82,42,87,45,48,49,48,49,49,67,68,49,49,68,49,68,45,45,53,76,45,48,45,48,45,45,45,45,48,61,62,49,67,68,45,48,49,68,45,48,62,49,67,68,45,76,76,48,62,49,68,45,76,76,53,53,45,76,76,53,45,53,42,45,53,42,45,53,42,45,53,53,45,53,45,45,53,42,45,53,42,45,45,45,53,42,45,45,45,45,53,45,53,45,62,45,45,62,45,62,45,62,45,45,45,62,45,62,45,62,45,45,45,53,45,45,45,45,45,45,45,45,45,53,53,53,53,45,45,45,45,45,45,45,64,65,48,61,62,49,67,68,53,69,70,72,73,74,76,78,80,82,84,86,42,87,45,64,65,48,61,62,49,67,68,53,69,70,72,73,74,76,78,80,82,84,86,42,87,45,64,65,48,61,62,49,67,68,53,69,70,72,73,74,76,78,80,82,84,86,42,87,45,45,0,53,45,53,64,65,48,61,62,49,67,68,53,69,70,72,73,74,76,78,80,82,84,86,42,87,45,64,65,48,61,62,49,67,68,53,69,70,72,73,74,76,78,80,82,84,86,42,87,45,64,65,48,61,62,49,67,68,53,69,70,72,73,74,76,78,80,82,84,86,42,87,45,64,65,48,61,62,49,67,68,53,69,70,72,73,74,76,78,80,82,84,86,42,87,45,45,53,76,80,82,42,45,87,42,42,87,87,87,87,87,0,0,108,104,108,104,0,108,0,104,104,104,108,104,108,104,104,104,108,104,108,104,108,104,108,104,108,104,104,108,104,108,104,108,104,108,104,0,0,0,0,103,111,112,110,103,111,112,110,110,103,111,112,110,103,111,112,110,103,103,111,112,110,103,111,112,110,103,111,112,110,103,111,112,110,103,111,112,110,103,111,112,110,103,111,112,110,111,111,112,103,0,0,0,0,0,0,118,118,0,0,0,118,118,0,0,0,118,118,118,118,118,118,118,118,118,118,118,118,0,0,119,119,119,122,119,122,119,122,119,119,119,119,119,122,119,122,122,122,119,122,119,122,119,122,119,122,119,122,119,119,122,119,0,0,0,133,0,133,0,0,0,98,125,0,124,129,98,0,127,130,0,0,171,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,133,99,99,132,134,135,136,137,131,133,138,139,140,141,142,143,144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159,160,161,162,163,164,165,166,167,168,169,99,132,134,135,136,137,131,133,138,139,140,141,142,143,144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159,160,161,162,163,164,165,166,167,168,169,124,99,127,99,132,134,135,136,137,138,139,140,141,142,143,144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159,160,161,162,163,164,165,166,167,168,169,129,99,130,99,132,134,135,136,137,138,139,140,141,142,143,144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159,160,161,162,163,164,165,166,167,168,169,125,131,0,131,131,133,125,99,132,134,135,136,137,131,133,138,139,140,141,142,143,144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159,160,161,162,163,164,165,166,167,168,169,0,131,99,132,134,135,136,137,131,133,138,139,140,141,142,143,144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159,160,161,162,163,164,165,166,167,168,169,135,136,137,99,131,98,99,132,134,135,136,137,138,139,140,141,142,143,144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159,160,161,162,163,164,165,166,167,168,169,125,131,125,99,99,132,134,135,136,137,138,139,140,141,142,143,144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159,160,161,162,163,164,165,166,167,168,169,171,136,125,125,99,99,132,135,136,137,125,138,139,140,141,142,143,144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159,160,161,162,163,164,165,166,167,168,169,131,99,132,134,135,136,137,131,133,138,139,140,141,142,143,144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159,160,161,162,163,164,165,166,167,168,169,99,132,134,135,136,137,131,133,138,139,140,141,142,143,144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159,160,161,162,163,164,165,166,167,168,169,99,132,134,135,136,137,131,133,138,139,140,141,142,143,144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159,160,161,162,163,164,165,166,167,168,169,99,132,134,135,136,137,131,133,138,139,140,141,142,143,144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159,160,161,162,163,164,165,166,167,168,169,99,132,134,135,136,137,131,133,138,139,140,141,142,143,144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159,160,161,162,163,164,165,166,167,168,169,99,132,134,135,136,137,131,133,138,139,140,141,142,143,144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159,160,161,162,163,164,165,166,167,168,169,131,99,132,134,135,136,137,131,133,138,139,140,141,142,143,144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159,160,161,162,163,164,165,166,167,168,169,131,131,131,131,131,131,228,229,177,0,0,177,172,172,172,177,172,177,172,172,172,172,172,172,172,177,172,177,172,172,172,172,172,177,172,177,172,177,172,172,177,172,177,172,177,172,177,0,0,0,179,178,179,178,179,178,179,178,0,179,178,179,178,179,178,179,178,179,178,179,178,179,178,0,181,0,0,180,180,0,0,0,0,0,0,0,0,0,0,0,0,0,107,107,0,0,0,107,105,105,107,107,107,107,107,105,107,107,105,107,106,105,107,106,105,107,107,107,105,107,107,107,105,107,106,105,107,106,105,107,107,107,107,107,105,0,0,0,0,0,0,105,107,107,107,105,107,107,0,0,0,105,107,105,105,107,107,107,105,105,107,107,106,107,107,105,107,107,107,107,107,107,107,107,107,106,107,107,106,105,107,107,107,107,107,107,107,107,0,105,107,107,105,105,107,106,105,107,105,105,105,105,107,105,107,107,105,107,107,107,105,105,105,106,105,105,105,105,105,105,105,105,107,106,106,106,106,107,107,107,107,107,107,105,107,107,107,105,107,105,107,107,107,107,107,107,107,105,107,107,105,105,105,107,107,107,107,107,107,107,107,107,107,105,107,106,105,107,106,105,107,106,105,107,106,107,107,107,105,105,107,107,106,107,105,105,107,106,105,105,107,106,105,105,105,105,105,107,106,105,107,106,107,105,107,107,107,107,107,107,107,107,107,107,107,107,107,107,105,0,0,0,0,0,0,0,0,205,205,205,205,205,207,207,207,207,207,0,0,208,0,0,0,0,0,209,209,209,209,209,209,210,206,209,209,209,209,0,212,212,0,212,0,212,0,0,0,209,209,209,209,209,209,209,209,209,209,209,209,209,230,231,0,0,0,0,0,0,0,0,213,213,213,213,213,213,213,213,213,0,214,0,213,213,213,213,213,213,213,213,0,0,216,0,215,215,215,215,215,215,215,215,215,215,215,215,215,215,215,215,215,215,215,215,215,215,215,215,215,215,215,215,215,215,0,216,216,216,216,216,216,216,216,0,215,215,215,215,215,215,215,215,215,0,0,216,0,0,222,221,220,222,221,220,222,221,221,222,221,220,221,220,222,221,220,220,222,221,220,222,220,222,216,221,216,216,216,221,216,216,216,216,221,222,220,222,221,220,222,221,220,222,221,220,221,220,222,221,220,222,221,220,222,221,220,222,221,220,0,215,215,215,215,215,215,215,215,215,215,215,215,215,215,215,215,215,215,215,215,215,215,215,215,215,215,215,215,215,215,215,215,215,215,215,215,0,225,225,225,225,225,225,225,225,225,225,225,225,0,226,226,226,0,0,227,227,227,0,0,0,0,0,227,227,0,0,227,227,227,227,227,227,227,227,227,227,227,227,227],"f":"``````````````````````````````{{{b{c}}}{{b{e}}}{}{}}{{{b{dc}}}{{b{de}}}{}{}}{{{b{f}}{b{dh}}}j}0{cf{{l{`}}}}{cc{}}{ce{}{}}{{{b{f}}}{{A`{{b{n}}}}}}{{{b{c}}}{{b{{Ab{e}}}}}{}{}}{{{b{dc}}}{{b{d{Ab{e}}}}}{}{}}0{{{b{c}}}Ad{}}{c{{Af{e}}}{}{}}0{{{b{c}}}Ah{}}6`````````````;;;;;;;;;;;:::::::::::`````77777777777``66666666666{{AjAl}An}`{{BbBh}{{Bf{{Bd{BjBl}}}}}}{{BlBn}{{Bf{{A`{{Bd{C`Aj}}}}}}}}{{BjCb}{{Bf{{A`{Bn}}}}}}{{C`Cd}{{Bf{{A`{Al}}}}}}``````````999999999998888888888888888888888666666666666666666666655555555555``;;;;;;;;;;;``{{{b{c}}}{{b{e}}}{}{}}0{{{b{dc}}}{{b{de}}}{}{}}0````>>``==`{Cf{{Bf{Ch}}}}`````<<;;;;999988`````>>``````{{CjCj}Cj}32{{{b{Cl}}}Cl}{{{b{c}}{b{de}}}An{}{}}{{{b{Cl}}{b{dh}}}j}{cc{}}{CnD`}{{{Db{c}}}CjD`}{{{Db{Dd}}}Cl}`{ce{}{}}{Cj{{Db{c}}}D`}{Cl{{Db{Dd}}}}{{D`D`}{{Bd{D`Cn}}}}{{{b{c}}}{{b{{Ab{e}}}}}{}{}}{{{b{dc}}}{{b{d{Ab{e}}}}}{}{}}0{{{b{c}}}e{}{}}{c{{Af{e}}}{}{}}0{{{b{c}}}Ah{}}8`{{{b{c}}}{{b{e}}}{}{}}{{{b{dc}}}{{b{de}}}{}{}}>:{Df{{Dj{Dh}}}}{{}Df}877554<{DlDf}{{{b{dDf}}DlDn}An}{{{b{dDf}}DlE`}An}{{{b{dDf}}DlEb}An}{{{b{dDf}}DlDd}An}{{{b{dDf}}DlDh}An}{{{b{dDf}}DlDl}An}`````````````````````````{{{Ed{c}}{b{d{Ef{c}}}}}{{Ed{c}}}Eh}{{{Ej{c}}{b{d{Dj{c}}}}}{{Ej{c}}}{}}{{{Ej{c}}{b{d{Ej{c}}}}}{{Ej{c}}}{}}{{{Ej{c}}e}{{Ej{c}}}{}{{En{{b{{El{{Db{c}}}}}}{b{{El{c}}}}}}}}{{{Ej{c}}e}{{Ej{c}}}{}{{En{{b{d{El{{Db{c}}}}}}{b{d{El{c}}}}}}}}{{{Ej{c}}e}{{Ej{c}}}{}{{En{{b{{El{{Db{c}}}}}}}}}}{{{Ej{c}}e}{{Ej{c}}}{}{{En{{b{d{El{{Db{c}}}}}}}}}}{{{b{d{Ej{c}}}}}{{b{d{El{c}}}}}{}}{{{b{d{Ej{c}}}}}{{b{d{Dj{c}}}}}{}}{{{Ej{c}}e}{{Ej{c}}}{}{{En{{b{{El{c}}}}{b{{El{{Db{c}}}}}}}}}}{{{Ej{c}}e}{{Ej{c}}}{}{{En{{b{d{El{c}}}}{b{d{El{{Db{c}}}}}}}}}}{{{b{{Ej{c}}}}}{{b{{Dj{c}}}}}{}}{{{b{{Ej{c}}}}}{{b{{El{c}}}}}{}}{{{F`{{Ab{c}}}}}{{F`{c}}}{}}{{{Fb{{Ab{c}}}}}{{Fb{c}}}{}}{{{Ej{c}}{b{c}}{b{d{Af{DlDl}}}}}{{Ej{c}}}Eh}{{{Ej{c}}e{b{d{Af{DlDl}}}}}{{Ej{c}}}{}{{Fh{{b{c}}}{{Fd{Ff}}}}}}{{{Ej{c}}{b{e}}g{b{d{Af{DlDl}}}}}{{Ej{c}}}{}Eh{{Fh{{b{c}}}{{Fd{e}}}}}}{{{Ej{c}}{b{e}}g{b{d{Ab{{Af{DlDl}}}}}}}{{Ej{c}}}{}Eh{{Fh{{b{c}}}{{Fd{e}}}}}}{{{Ej{c}}e{b{d{Ab{{Af{DlDl}}}}}}}{{Ej{c}}}{}{{Fh{{b{c}}}{{Fd{Ff}}}}}}{{{Ej{c}}{b{c}}{b{d{Ab{{Af{DlDl}}}}}}}{{Ej{c}}}Eh}{{{b{c}}}{{b{e}}}{}{}}0000000000000000000000{{{b{dc}}}{{b{de}}}{}{}}0000000000000000000000{{Fj{b{dDl}}}Fj}{{{Ed{c}}{b{dDl}}}{{Ed{c}}}{}}{{{Ej{c}}{b{dDl}}}{{Ej{c}}}{}}{{Fj{b{d{Ab{Dl}}}}}Fj}{{{Ed{c}}{b{d{Ab{Dl}}}}}{{Ed{c}}}{}}{{{Ej{c}}{b{d{Ab{Dl}}}}}{{Ej{c}}}{}}{FjFj}{{{Ej{c}}}{{Ej{c}}}{}}{{{b{{Ej{c}}}}}{{Ej{c}}}Fl}{{{Ej{c}}{b{{El{c}}}}}{{Ej{c}}}Fl}{{{b{c}}{b{de}}}An{}{}}{{{Ej{c}}{b{c}}{b{dCn}}}{{Ej{c}}}Fn}{{{Ej{c}}{b{c}}{b{d{Ab{Cn}}}}}{{Ej{c}}}Fn}{{{Ej{c}}{b{{El{c}}}}}{{Ej{c}}}G`}{{{Ej{c}}eDl}{{Ej{c}}}G`{{Gb{Dl}}}}{{{Ej{c}}}{{Ej{c}}}Gd}{{{Ej{c}}e}{{Ej{c}}}{}{{Fh{{b{c}}{b{c}}}{{Fd{Cn}}}}}}{{{Ej{c}}g}{{Ej{c}}}{}Fn{{Fh{{b{c}}}{{Fd{e}}}}}}{{{Ej{c}}g}{{Ej{c}}}{}Fn{{Fh{{b{dc}}}{{Fd{e}}}}}}{{{Ej{c}}e}{{Ej{c}}}{}{{Fh{{b{dc}}{b{dc}}}{{Fd{Cn}}}}}}{{}{{Ej{c}}}Gf}{{{Ej{c}}eg}{{Ej{c}}}{}{{Gb{Dl}}}{{En{{Gh{c}}}}}}{{{Ej{c}}{b{{El{c}}}}{b{dCn}}}{{Ej{c}}}Fn}{{{Ej{c}}{b{{El{c}}}}{b{d{Ab{Cn}}}}}{{Ej{c}}}Fn}>{{Fjc}Fj{{Gb{Dl}}}}{{{Ej{c}}e}{{Ej{c}}}Fl{{Gb{Dl}}}}{{{Ej{c}}c}{{Ej{c}}}Fl}{{{Ej{c}}e}{{Ej{c}}}{}{{Fh{}{{Fd{c}}}}}}{{{Gj{c}}e}{{Gj{c}}}{}{{En{{A`{{b{c}}}}}}}}{{{Gl{c}}e}{{Gl{c}}}{}{{En{{A`{{b{c}}}}}}}}{{{Fb{c}}e}{{Fb{c}}}{}{{En{{A`{{b{c}}}}}}}}{{{Ej{c}}e}{{Ej{c}}}{}{{En{{A`{{b{c}}}}}}}}{{{Ej{c}}e}{{Ej{c}}}{}{{En{{A`{{b{{Db{c}}}}}}}}}}{{{Ej{c}}e}{{Ej{c}}}{}{{En{{A`{{b{d{Db{c}}}}}}}}}}{{{Gl{c}}e}{{Gl{c}}}{}{{En{{A`{{b{dc}}}}}}}}{{{Fb{c}}e}{{Fb{c}}}{}{{En{{A`{{b{dc}}}}}}}}{{{Ej{c}}e}{{Ej{c}}}{}{{En{{A`{{b{dc}}}}}}}}{{{Gj{{Db{c}}}}}{{Gj{c}}}{}}{{{Gl{{Db{c}}}}}{{Gl{c}}}{}}{{{Ej{{Db{c}}}}}{{Ej{c}}}{}}{{{b{{Ej{c}}}}{b{dh}}}jGn}{{{b{{Dj{c}}}}}{{H`{c}}}{}}{cc{}}0{{{b{d{Dj{c}}}}}{{Hb{c}}}{}}1{{{Hd{{El{c}}}}}{{F`{c}}}{}}2{{{b{{El{c}}}}}{{Gj{c}}}{}}3{{{b{d{El{c}}}}}{{Gl{c}}}{}}4{{{Db{c}}}{{Fb{c}}}{}}{{{b{{Db{c}}}}}{{Hf{c}}}{}}66{{{b{d{Db{c}}}}}{{Hh{c}}}{}}7{AdFj}{{{b{Ad}}}Hj}9{{{b{dAd}}}Hl}:{{{Hd{Hn}}}I`};{{{b{Hn}}}Ib}<{{{b{dHn}}}Id}=={{{If{c}}}{{Ih{c}}}{}}{{{Ij{c}}}{{Il{c}}}{}}?{{{In{ceg}}}{{J`{ceg}}}{}{}{}}{cc{}}{{{Jb{ce}}}{{Jd{ce}}}{}{}}1{{{Jf{ce}}}{{Jh{ce}}}{}{}}2{{{Jj{c}}}{{Jl{c}}}{}}3{{{Ef{c}}}{{Ed{c}}}{}}44{DfJn}{{{Dj{c}}}{{Ej{c}}}{}}6{{DhDlDl}Fj}{{DlDl}{{Ej{c}}}{}}{{{b{{El{E`}}}}}{{A`{Fj}}}}{{{b{{El{E`}}}}}Fj}{{{Dj{Dh}}}{{Af{FjK`}}}}{{{Dj{Dh}}}Fj}{{{Ej{c}}eg}{{Ej{c}}}{}{{Kb{{El{c}}}}}{{En{{A`{b}}}}}}{{{Ej{c}}eg}{{Ej{c}}}{}{{Kb{{El{c}}}}}{{En{{A`{{b{d}}}}}}}}{{{Ej{c}}eg}{{Ej{c}}}{}{{Kb{{El{c}}}}}{{En{b}}}}{{{Ej{c}}eg}{{Ej{c}}}{}{{Kb{{El{c}}}}}{{En{{b{d}}}}}}{{FjDlKd}Fj}{{{Ej{c}}Dlc}{{Ej{c}}}{}}{{FjDl{b{Hn}}}Fj}{ce{}{}}0000000000000000000000{{{Ed{c}}}{{Ef{c}}}Eh}{Fj{{Dj{Dh}}}}{Jn{{Dj{Dh}}}}{Fj{{Ej{Dh}}}}{Jn{{Ej{Dh}}}}{{{Kh{}{{Kf{c}}}}}cKj}0{{{F`{c}}}{{Hd{{El{c}}}}}{}}{{{Gj{c}}}{{b{{El{c}}}}}{}}{{{Gl{c}}}{{b{d{El{c}}}}}{}}{{{Fb{c}}}{{Db{c}}}{}}{{{Hf{c}}}{{b{{Db{c}}}}}{}}{{{Hh{c}}}{{b{d{Db{c}}}}}{}}{{{Ih{c}}}{{If{c}}}{}}{Fj{{Bd{DhDlDl}}}}{{{Ed{c}}}{{Dj{c}}}Eh}{{{Ed{c}}}{{Ej{c}}}Eh}{{{Gj{c}}}{{Ej{c}}}Fl}{{{Gl{c}}}{{Ej{c}}}Fl}{{{Ej{Dh}}{b{dCn}}}{{Ej{Dh}}}}{{{Ej{Dh}}{b{d{Ab{Cn}}}}}{{Ej{Dh}}}}{{{Gj{c}}{b{dCn}}}{{Gj{c}}}{}}{{{Gl{c}}{b{dCn}}}{{Gl{c}}}{}}{{{Fb{c}}{b{dCn}}}{{Fb{c}}}{}}{{Fj{b{dCn}}}Fj}{{{Ej{c}}{b{dCn}}}{{Ej{c}}}{}}{{{Gj{c}}{b{d{Ab{Cn}}}}}{{Gj{c}}}{}}{{{Gl{c}}{b{d{Ab{Cn}}}}}{{Gl{c}}}{}}{{{Fb{c}}{b{d{Ab{Cn}}}}}{{Fb{c}}}{}}{{Fj{b{d{Ab{Cn}}}}}Fj}{{{Ej{c}}{b{d{Ab{Cn}}}}}{{Ej{c}}}{}}{{{Gj{c}}e}{{Gj{c}}}{}{{En{{A`{{b{c}}}}}}}}{{{Gl{c}}e}{{Gl{c}}}{}{{En{{A`{{b{c}}}}}}}}{{{Ej{c}}e}{{Ej{c}}}{}{{En{{A`{{b{c}}}}}}}}{{{Ej{c}}e}{{Ej{c}}}{}{{En{{A`{{b{{Db{c}}}}}}}}}}{{{Ej{c}}e}{{Ej{c}}}{}{{En{{A`{{b{d{Db{c}}}}}}}}}}{{{Gl{c}}e}{{Gl{c}}}{}{{En{{A`{{b{dc}}}}}}}}{{{Ej{c}}e}{{Ej{c}}}{}{{En{{A`{{b{dc}}}}}}}}{{{Ej{c}}}{{Gl{c}}}{}}{{{Gj{c}}{b{dDl}}}{{Gj{c}}}{}}{{{Gl{c}}{b{dDl}}}{{Gl{c}}}{}}{{{Fb{c}}{b{dDl}}}{{Fb{c}}}{}}{{Fj{b{dDl}}}Fj}{{{Ej{c}}{b{dDl}}}{{Ej{c}}}{}}{{{Gj{c}}{b{d{Ab{Dl}}}}}{{Gj{c}}}{}}{{{Gl{c}}{b{d{Ab{Dl}}}}}{{Gl{c}}}{}}{{{Fb{c}}{b{d{Ab{Dl}}}}}{{Fb{c}}}{}}{{Fj{b{d{Ab{Dl}}}}}Fj}{{{Ej{c}}{b{d{Ab{Dl}}}}}{{Ej{c}}}{}}{{{Ej{Dh}}}{{Ej{Dh}}}}0{{}Fj}{{}{{Ih{c}}}{}}{{}{{Il{c}}}{}}{{}{{J`{ce}}}{}{}}{{}{{Jd{c}}}{}}{{}{{Ed{c}}}Eh}{{}Jn}{{}{{Ej{c}}}{}}{Dl{{F`{{Ab{c}}}}}{}}{{}{{Fb{{Ab{c}}}}}{}}10{{{b{{Fb{c}}}}}{{b{{Db{c}}}}}{}}{{{b{{Hf{c}}}}}{{b{{Db{c}}}}}{}}{{{b{{Hh{c}}}}}{{b{{Db{c}}}}}{}}{{{b{d{Fb{c}}}}}{{Hh{c}}}{}}{{{b{{Fb{c}}}}}{{Hf{c}}}{}}{{{b{{Hh{c}}}}}{{Hf{c}}}{}}{{{b{d{Fb{c}}}}}{{b{d{Db{c}}}}}{}}{{{b{d{Hh{c}}}}}{{b{d{Db{c}}}}}{}}{{{Ej{c}}}{{Hd{{El{c}}}}}{}}{{{Ej{c}}}{{F`{c}}}{}}{{{b{Fj}}}{{b{{El{Dh}}}}}}{{{b{d{Ih{c}}}}}{{b{d{El{c}}}}}{}}{{{Ej{c}}}{{Dj{c}}}{}}{{{b{{F`{c}}}}}{}{}}{{{b{{Ej{c}}}}}{}{}}{{{b{d{F`{c}}}}}{}{}}{{{b{d{Ej{c}}}}}{}{}}{{{b{{Ej{c}}}}}Kl{}}{{{b{d{Ej{c}}}}}Kl{}}{{{Ej{c}}}{{Bd{DlDl}}}{}}{{{b{{F`{c}}}}}{{b{{El{c}}}}}{}}{{{b{{Gj{c}}}}}{{b{{El{c}}}}}{}}{{{b{{Gl{c}}}}}{{b{{El{c}}}}}{}}{{{b{{Fb{c}}}}}{{b{{El{c}}}}}{}}{{{b{{Hf{c}}}}}{{b{{El{c}}}}}{}}{{{b{{Hh{c}}}}}{{b{{El{c}}}}}{}}{{{b{{Ej{c}}}}}{{b{{El{c}}}}}{}}{{{b{d{F`{c}}}}}{{Gl{c}}}{}}{{{b{d{Fb{c}}}}}{{Gl{c}}}{}}{{{b{d{Hh{c}}}}}{{Gl{c}}}{}}{{{b{d{Ej{c}}}}}{{Gl{c}}}{}}{{{b{{F`{c}}}}}{{Gj{c}}}{}}{{{b{{Gl{c}}}}}{{Gj{c}}}{}}{{{b{{Fb{c}}}}}{{Gj{c}}}{}}{{{b{{Hf{c}}}}}{{Gj{c}}}{}}{{{b{{Hh{c}}}}}{{Gj{c}}}{}}{{{b{{Ej{c}}}}}{{Gj{c}}}{}}{{{b{d{Ih{c}}}}}{{Bd{{Gl{c}}{Gl{c}}}}}{}}{{{b{{Ih{c}}}}}{{Bd{{Gj{c}}{Gj{c}}}}}{}}{{{b{d{F`{c}}}}}{{b{d{El{c}}}}}{}}{{{b{d{Gl{c}}}}}{{b{d{El{c}}}}}{}}{{{b{d{Fb{c}}}}}{{b{d{El{c}}}}}{}}{{{b{d{Hh{c}}}}}{{b{d{El{c}}}}}{}}{{{b{d{Ej{c}}}}}{{b{d{El{c}}}}}{}}{{{b{{Ih{c}}}}}{{Bd{{b{{El{c}}}}{b{{El{c}}}}}}}{}}{{{b{d{Ih{c}}}}}{{Bd{{b{d{El{c}}}}{b{d{El{c}}}}}}}{}}{{{b{Fj}}}{{b{Hn}}}}{{{b{dFj}}}{{b{dHn}}}}{{{b{{Ej{c}}}}}{{b{{Dj{c}}}}}{}}{{{b{{Ih{c}}}}}{{b{{If{c}}}}}{}}{{{b{d{Ih{c}}}}}{{b{d{If{c}}}}}{}}{{{b{dFj}}}{{b{d{Dj{Dh}}}}}}{{{b{d{Ej{c}}}}}{{b{d{Dj{c}}}}}{}}{{Fj{b{d{A`{Kd}}}}}Fj}{{{Ed{c}}{b{d{A`{c}}}}}{{Ed{c}}}Eh}{{{Ej{c}}{b{d{A`{c}}}}}{{Ej{c}}}{}}{{Fj{b{d{Ab{{A`{Kd}}}}}}}Fj}{{{Ed{c}}{b{d{Ab{{A`{c}}}}}}}{{Ed{c}}}Eh}{{{Ej{c}}{b{d{Ab{{A`{c}}}}}}}{{Ej{c}}}{}}{{FjKd}Fj}{{{Ed{c}}c}{{Ed{c}}}Eh}{{{Ej{c}}c}{{Ej{c}}}{}}{{Fj{b{Hn}}}Fj}{{FjDl{b{dKd}}}Fj}{{{Ej{c}}Dl{b{dc}}}{{Ej{c}}}{}}{{FjDl{b{d{Ab{Kd}}}}}Fj}{{{Ej{c}}Dl{b{d{Ab{c}}}}}{{Ej{c}}}{}}{{{Ej{c}}Dl}{{Ej{c}}}G`}{{FjDl}Fj}{{{Ed{c}}Dl}{{Ed{c}}}{}}{{{Ej{c}}Dl}{{Ej{c}}}{}}210{{{Ej{c}}Dlc}{{Ej{c}}}Fl}{{{Ej{c}}Dle}{{Ej{c}}}{}{{Fh{}{{Fd{c}}}}}}{{Fjc}Fj{{Fh{Kd}{{Fd{Cn}}}}}}{{{Ed{c}}e}{{Ed{c}}}Eh{{Fh{{b{c}}}{{Fd{Cn}}}}}}{{{Ej{c}}e}{{Ej{c}}}{}{{Fh{{b{c}}}{{Fd{Cn}}}}}}{{{Ej{c}}e}{{Ej{c}}}{}{{Fh{{b{dc}}}{{Fd{Cn}}}}}}{{{Ej{c}}}{{Ej{c}}}{}}797{FjFj}1{{{Gl{c}}}{{Gl{c}}}Eh}{{{Ej{c}}}{{Ej{c}}}Eh}0{{{Gl{c}}e}{{Gl{c}}}{}{{Fh{{b{c}}{b{c}}}{{Fd{Ff}}}}}}{{{Ej{c}}e}{{Ej{c}}}{}{{Fh{{b{c}}{b{c}}}{{Fd{Ff}}}}}}{{{Gl{c}}g}{{Gl{c}}}{}Eh{{Fh{{b{c}}}{{Fd{e}}}}}}{{{Ej{c}}g}{{Ej{c}}}{}Eh{{Fh{{b{c}}}{{Fd{e}}}}}}10{{{Ej{Kn}}}{{Ej{Kn}}}}{{{Ej{L`}}}{{Ej{L`}}}}765432{{{Ej{c}}e}{{Ej{c}}}{}{{En{{Gl{{Ab{c}}}}}}}}{{{Ej{c}}egi}{{Ej{c}}}{}{{Gb{Dl}}}{{Ld{}{{Lb{c}}}}}{{En{{Lh{Lf}}}}}}{{FjDl}{{Bd{FjFj}}}}{{{Ej{c}}e}{{Ej{c}}}{}{{En{{Gl{c}}{Gl{{Ab{c}}}}}}}}{{{Ej{c}}e}{{Ej{c}}}{}{{En{{A`{{Bd{{b{c}}{Gj{c}}}}}}}}}}{{{Ej{c}}e}{{Ej{c}}}{}{{En{{A`{{Bd{{b{{Db{c}}}}{b{{El{c}}}}}}}}}}}}{{{Ej{c}}e}{{Ej{c}}}{}{{En{{A`{{Bd{{b{d{Db{c}}}}{b{d{El{c}}}}}}}}}}}}{{{Ej{c}}e}{{Ej{c}}}{}{{En{{A`{{Bd{{b{dc}}{Gl{c}}}}}}}}}}3{{{Ej{c}}e}{{Ej{c}}}{}{{En{{A`{{Bd{{b{{El{c}}}}{b{{Db{c}}}}}}}}}}}}{{{Ej{c}}e}{{Ej{c}}}{}{{En{{A`{{Bd{{b{d{El{c}}}}{b{d{Db{c}}}}}}}}}}}}2{{FjDl{b{dFj}}}Fj}{{FjDl{b{d{Ab{Fj}}}}}Fj}10{{{Ej{c}}{b{{El{c}}}}{b{dCn}}}{{Ej{c}}}Fn}{{{Ej{c}}{b{{El{c}}}}{b{d{Ab{Cn}}}}}{{Ej{c}}}Fn}{{{Ej{c}}DlDl}{{Ej{c}}}{}}{{{Ej{c}}Dl{b{dc}}}{{Ej{c}}}{}}{{{Ej{c}}Dl{b{d{Ab{c}}}}}{{Ej{c}}}{}}2{{{Ej{c}}{b{d{El{c}}}}}{{Ej{c}}}{}}{{{b{c}}}{{b{{Ab{e}}}}}{}{}}0000000000000000000000{{{b{dc}}}{{b{d{Ab{e}}}}}{}{}}000000000000000000000000000000000000000000000{{{b{c}}}e{}{}}`{{FjDl}Fj}{{{Ej{c}}Dl}{{Ej{c}}}{}}1{c{{Af{e}}}{}{}}000000000000000000000000000000000000000000000{{{b{c}}}Ah{}}0000000000000000000000{ce{}{}}0000000000000000000000{{{Ej{c}}Dle}{{Ej{c}}}{}{{En{{Lj{c}}}}}}{DlFj}{Dl{{Ih{c}}}{}}{Dl{{J`{ce}}}{}{}}{Dl{{Jd{c}}}{}}{Dl{{Ed{c}}}Eh}{Dl{{Ej{c}}}{}}{DlJn}{{{Ed{c}}e}{{Ed{c}}}{}{{En{{A`{{b{c}}}}}}}}{{{Ed{c}}e}{{Ed{c}}}Eh{{En{{A`{{Ll{c}}}}}}}}{{JnDlDn}Jn}{{JnDlE`}Jn}{{JnDlEb}Jn}{{JnDlDd}Jn}{{JnDlDh}Jn}``{{{b{c}}}{{b{e}}}{}{}}0{{{b{dc}}}{{b{de}}}{}{}}0`{{}Ln}`{{{b{M`}}}Cn}{{{b{M`}}}Mb}{{{b{M`}}}{{Mf{Md}}}}{cc{}}0{ce{}{}}043{{Mhe}An{{Mj{}{{Fd{An}}}}}{{Fh{M`}{{Fd{c}}}}}}3{{{b{dMh}}}{{A`{M`}}}}4{{{b{c}}}{{b{{Ab{e}}}}}{}{}}0{{{b{dc}}}{{b{d{Ab{e}}}}}{}{}}0007{c{{Af{e}}}{}{}}000{{{b{c}}}Ah{}}066````====<<<<{MlMh}88887777<4444333333332222222211117777{{MnMb}N`}{{Mn{Mf{c}}}N`Nb}{{N`Mb}Ml}{{Ln{Mf{c}}}MnNb}{{cDl}{{`{NdFlNfNh}}}{NdNf}}0{{cDl{b{Nj}}}{{`{NdFlNfNh}}}{NdNf}}0{{}Ad}``````{{{b{c}}}{{b{e}}}{}{}}{{{b{dc}}}{{b{de}}}{}{}}{{{b{{El{Dh}}}}}{{Af{{Dj{Dh}}Nl}}}}{{{b{{El{Dh}}}}}Ad}0{{{b{Nl}}{b{dh}}}j}0{cc{}}{ce{}{}}{{{b{c}}}{{b{{Ab{e}}}}}{}{}}{{{b{dc}}}{{b{d{Ab{e}}}}}{}{}}0{{{b{c}}}Ad{}}{c{{Af{e}}}{}{}}0{{{b{c}}}Ah{}}5``{{{b{Nn}}}O`}{{{b{Nn}}}Dd}{{{b{Nn}}}Ob}>>==99{O`{{A`{Nn}}}}{O`Nn}{Dd{{A`{Nn}}}}{DdNn}<<{{}Od}{{{b{dOd}}}{{A`{Nn}}}}==<<<<::::997>>``````````````````````````````````````````````````````````>{{{b{c}}}{{b{e}}}{}{}}000000000000000000000000000000000000000{{{b{dc}}}{{b{de}}}{}{}}000000000000000000000000000000000000000{{{b{d{Oh{}{{Of{c}}}}}}}cOj}{{{b{dc}}}{{Lf{{b{de}}}}}{}{}}{{{b{d{On{}{{Ol{c}}}}}}}cA@`}11111111111111111111111111111111111111{{{A@b{}{{Of{c}}}}}cOj}{cLf{}}{{{A@d{}{{Ol{c}}}}}cA@`}11111111111111111111111111111111111111{{{Oj{}{{Lb{c}}}}}Dl{}}{{}A@f}{{}{{A@h{c}}}{}}{DlA@f}{{{b{A@f}}{b{dh}}}j}{{{b{A@j}}{b{dh}}}j}{{{Oj{}{{Lb{c}}}}e}An{}{{Fh{c}}}}{cc{}}000000000000000000000000000000000000000{e{{A@l{e}}}{}{{Fh{}{{Fd{{A`{c}}}}}}}}5{ce{}{}}000000000000000000000000000000000000000{{{A@n{cg}}}{{Bd{cg}}}Oj{}{{Fh{}{{Fd{e}}}}}}{{{AA`{ec}}}{{Bd{e{A`{{A`{c}}}}}}}{}{{Oj{}{{Lb{c}}}}}}{{{AAb{c}}}{{Bd{c{A`{A`}}}}}Oj}3{A@f{{Bd{Dl{A`{Dl}}}}}}{{{Ld{}{{Lb{c}}{Of{e}}}}}e{}{{Oj{}{{Lb{c}}}}}}55555555555555555555555555555555555555{{{Oj{}{{Lb{c}}}}g}{{A@n{{Oj{}{{Lb{c}}}}g}}}{}{}{{Fh{c}{{Fd{e}}}}}}>{{{b{d{Oj{}{{Lb{c}}}}}}}{{A`{c}}}{}}{{{b{d{Lf{c}}}}}A`Oj}{{{b{d{Lf{c}}}}}A`A@`}{{{b{d{A@h{c}}}}}{{A`{c}}}{}}{{{b{d{A@l{e}}}}}{{A`{c}}}{}{{Fh{}{{Fd{{A`{c}}}}}}}}{{{b{d{A@n{cg}}}}}{{A`{e}}}Oj{}{{Fh{}{{Fd{e}}}}}}{{{b{d{AA`{ec}}}}}A`{}{{Oj{}{{Lb{c}}}}}}{{{b{d{AAb{c}}}}}A`Oj}{{{b{d{AAd{cegikmoAaAcAeAgAiAkAmAoBaBcBeBgBiBkBmBoCaCcCeCgCiCkCmCoDa}}}}}{{A`{Dc}}}OjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOj{}}{{{b{d{AAf{cegikmoAaAcAeAgAiAkAmAoBaBcBeBgBiBkBmBoCaCcCeCgCiCkCmCo}}}}}{{A`{Da}}}OjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOj{}}{{{b{d{AAh{cegikmoAaAcAeAgAiAkAmAoBaBcBeBgBiBkBmBoCaCcCeCgCiCkCm}}}}}{{A`{Co}}}OjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOj{}}{{{b{d{AAj{cegikmoAaAcAeAgAiAkAmAoBaBcBeBgBiBkBmBoCaCcCeCgCiCk}}}}}{{A`{Cm}}}OjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOj{}}{{{b{d{AAl{cegikmoAaAcAeAgAiAkAmAoBaBcBeBgBiBkBmBoCaCcCeCgCi}}}}}{{A`{Ck}}}OjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOj{}}{{{b{d{AAn{cegikmoAaAcAeAgAiAkAmAoBaBcBeBgBiBkBmBoCaCcCeCg}}}}}{{A`{Ci}}}OjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOj{}}{{{b{d{AB`{cegikmoAaAcAeAgAiAkAmAoBaBcBeBgBiBkBmBoCaCcCe}}}}}{{A`{Cg}}}OjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOj{}}{{{b{d{ABb{cegikmoAaAcAeAgAiAkAmAoBaBcBeBgBiBkBmBoCaCc}}}}}{{A`{Ce}}}OjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOj{}}{{{b{d{ABd{cegikmoAaAcAeAgAiAkAmAoBaBcBeBgBiBkBmBoCa}}}}}{{A`{Cc}}}OjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOj{}}{{{b{d{ABf{cegikmoAaAcAeAgAiAkAmAoBaBcBeBgBiBkBmBo}}}}}{{A`{Ca}}}OjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOj{}}{{{b{d{ABh{cegikmoAaAcAeAgAiAkAmAoBaBcBeBgBiBkBm}}}}}{{A`{Bo}}}OjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOj{}}{{{b{d{ABj{cegikmoAaAcAeAgAiAkAmAoBaBcBeBgBiBk}}}}}{{A`{Bm}}}OjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOj{}}{{{b{d{ABl{cegikmoAaAcAeAgAiAkAmAoBaBcBeBgBi}}}}}{{A`{Bk}}}OjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOj{}}{{{b{d{ABn{cegikmoAaAcAeAgAiAkAmAoBaBcBeBg}}}}}{{A`{Bi}}}OjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOj{}}{{{b{d{AC`{cegikmoAaAcAeAgAiAkAmAoBaBcBe}}}}}{{A`{Bg}}}OjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOj{}}{{{b{d{ACb{cegikmoAaAcAeAgAiAkAmAoBaBc}}}}}{{A`{Be}}}OjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOj{}}{{{b{d{ACd{cegikmoAaAcAeAgAiAkAmAoBa}}}}}{{A`{Bc}}}OjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOj{}}{{{b{d{ACf{cegikmoAaAcAeAgAiAkAmAo}}}}}{{A`{Ba}}}OjOjOjOjOjOjOjOjOjOjOjOjOjOjOj{}}{{{b{d{ACh{cegikmoAaAcAeAgAiAkAm}}}}}{{A`{Ao}}}OjOjOjOjOjOjOjOjOjOjOjOjOjOj{}}{{{b{d{ACj{cegikmoAaAcAeAgAiAk}}}}}{{A`{Am}}}OjOjOjOjOjOjOjOjOjOjOjOjOj{}}{{{b{d{ACl{cegikmoAaAcAeAgAi}}}}}{{A`{Ak}}}OjOjOjOjOjOjOjOjOjOjOjOj{}}{{{b{d{ACn{cegikmoAaAcAeAg}}}}}{{A`{Ai}}}OjOjOjOjOjOjOjOjOjOjOj{}}{{{b{d{AD`{cegikmoAaAcAe}}}}}{{A`{Ag}}}OjOjOjOjOjOjOjOjOjOj{}}{{{b{d{ADb{cegikmoAaAc}}}}}{{A`{Ae}}}OjOjOjOjOjOjOjOjOj{}}{{{b{d{ADd{cegikmoAa}}}}}{{A`{Ac}}}OjOjOjOjOjOjOjOj{}}{{{b{d{ADf{cegikmo}}}}}{{A`{Aa}}}OjOjOjOjOjOjOj{}}{{{b{d{ADh{cegikm}}}}}{{A`{o}}}OjOjOjOjOjOj{}}{{{b{d{ADj{cegik}}}}}{{A`{m}}}OjOjOjOjOj{}}{{{b{d{ADl{cegi}}}}}{{A`{k}}}OjOjOjOj{}}{{{b{d{ADn{ceg}}}}}{{A`{i}}}OjOjOj{}}{{{b{d{AE`{ce}}}}}{{A`{g}}}OjOj{}}{{{b{d{AEb{c}}}}}{{A`{e}}}Oj{}}{{{b{d{AEf{}{{AEd{c}}}}}}}{{A`{{b{c}}}}}{}}{{{b{d{AA`{ec}}}}}{{A`{b}}}{}{{Oj{}{{Lb{c}}}}}}{{{Oj{}{{Lb{c}}}}}{{AA`{{Oj{}{{Lb{c}}}}c}}}{}}{{{Oj{}{{Lb{c}}}}Dl}{{AAb{{Oj{}{{Lb{c}}}}}}}{}}{{{b{{Lf{c}}}}}A@fA@`}{{{b{{Lf{c}}}}}{{Bd{Dl{A`{Dl}}}}}Oj}{{{b{{A@h{c}}}}}A@f{}}{{{b{{A@n{cg}}}}}A@fOj{}{{Fh{}{{Fd{e}}}}}}{{{b{{AA`{ec}}}}}A@f{}{{Oj{}{{Lb{c}}}}}}{{{b{{AAb{c}}}}}A@fOj}{{{b{{Oj{}{{Lb{c}}}}}}}A@f{}}{{{b{{AAd{cegikmoAaAcAeAgAiAkAmAoBaBcBeBgBiBkBmBoCaCcCeCgCiCkCmCoDa}}}}}A@fOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOj}{{{b{{AAf{cegikmoAaAcAeAgAiAkAmAoBaBcBeBgBiBkBmBoCaCcCeCgCiCkCmCo}}}}}A@fOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOj}{{{b{{AAh{cegikmoAaAcAeAgAiAkAmAoBaBcBeBgBiBkBmBoCaCcCeCgCiCkCm}}}}}A@fOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOj}{{{b{{AAj{cegikmoAaAcAeAgAiAkAmAoBaBcBeBgBiBkBmBoCaCcCeCgCiCk}}}}}A@fOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOj}{{{b{{AAl{cegikmoAaAcAeAgAiAkAmAoBaBcBeBgBiBkBmBoCaCcCeCgCi}}}}}A@fOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOj}{{{b{{AAn{cegikmoAaAcAeAgAiAkAmAoBaBcBeBgBiBkBmBoCaCcCeCg}}}}}A@fOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOj}{{{b{{AB`{cegikmoAaAcAeAgAiAkAmAoBaBcBeBgBiBkBmBoCaCcCe}}}}}A@fOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOj}{{{b{{ABb{cegikmoAaAcAeAgAiAkAmAoBaBcBeBgBiBkBmBoCaCc}}}}}A@fOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOj}{{{b{{ABd{cegikmoAaAcAeAgAiAkAmAoBaBcBeBgBiBkBmBoCa}}}}}A@fOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOj}{{{b{{ABf{cegikmoAaAcAeAgAiAkAmAoBaBcBeBgBiBkBmBo}}}}}A@fOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOj}{{{b{{ABh{cegikmoAaAcAeAgAiAkAmAoBaBcBeBgBiBkBm}}}}}A@fOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOj}{{{b{{ABj{cegikmoAaAcAeAgAiAkAmAoBaBcBeBgBiBk}}}}}A@fOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOj}{{{b{{ABl{cegikmoAaAcAeAgAiAkAmAoBaBcBeBgBi}}}}}A@fOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOj}{{{b{{ABn{cegikmoAaAcAeAgAiAkAmAoBaBcBeBg}}}}}A@fOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOj}{{{b{{AC`{cegikmoAaAcAeAgAiAkAmAoBaBcBe}}}}}A@fOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOj}{{{b{{ACb{cegikmoAaAcAeAgAiAkAmAoBaBc}}}}}A@fOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOj}{{{b{{ACd{cegikmoAaAcAeAgAiAkAmAoBa}}}}}A@fOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOj}{{{b{{ACf{cegikmoAaAcAeAgAiAkAmAo}}}}}A@fOjOjOjOjOjOjOjOjOjOjOjOjOjOjOj}{{{b{{ACh{cegikmoAaAcAeAgAiAkAm}}}}}A@fOjOjOjOjOjOjOjOjOjOjOjOjOjOj}{{{b{{ACj{cegikmoAaAcAeAgAiAk}}}}}A@fOjOjOjOjOjOjOjOjOjOjOjOjOj}{{{b{{ACl{cegikmoAaAcAeAgAi}}}}}A@fOjOjOjOjOjOjOjOjOjOjOjOj}{{{b{{ACn{cegikmoAaAcAeAg}}}}}A@fOjOjOjOjOjOjOjOjOjOjOj}{{{b{{AD`{cegikmoAaAcAe}}}}}A@fOjOjOjOjOjOjOjOjOjOj}{{{b{{ADb{cegikmoAaAc}}}}}A@fOjOjOjOjOjOjOjOjOj}{{{b{{ADd{cegikmoAa}}}}}A@fOjOjOjOjOjOjOjOj}{{{b{{ADf{cegikmo}}}}}A@fOjOjOjOjOjOjOj}{{{b{{ADh{cegikm}}}}}A@fOjOjOjOjOjOj}{{{b{{ADj{cegik}}}}}A@fOjOjOjOjOj}{{{b{{ADl{cegi}}}}}A@fOjOjOjOj}{{{b{{ADn{ceg}}}}}A@fOjOjOj}{{{b{{AE`{ce}}}}}A@fOjOj}{{{b{{AEb{c}}}}}A@fOj}{A@f{{Bd{A@jA@j}}}}{{{b{c}}}{{b{{Ab{e}}}}}{}{}}000000000000000000000000000000000000000{{{b{dc}}}{{b{d{Ab{e}}}}}{}{}}0000000000000000000000000000000000000000000000000000000000000000000000000000000{c{{Af{e}}}{}{}}0000000000000000000000000000000000000000000000000000000000000000000000000000000{{{b{c}}}Ah{}}000000000000000000000000000000000000000{{}A@f}{ce{}{}}000000000000000000000000000000000000000{{A@fDl}A@f}0{A@fA@f}110``````{{{b{d{AEh{eg}}}}}{{b{dc}}}AEj{{AEl{c}}}{{En{}{{Fd{e}}}}}}{{{b{{AEh{eg}}}}}{{b{c}}}AEj{{AEn{c}}}{{En{}{{Fd{e}}}}}}{{{b{c}}}{{b{e}}}{}{}}0{{{b{dc}}}{{b{de}}}{}{}}0{{{b{{AEh{ce}}}}}{{b{g}}}{}{{En{}{{Fd{c}}}}}{}}{{{b{d{AEh{ce}}}}}{{b{dg}}}{}{{En{}{{Fd{c}}}}}{}}{{{b{d{AEh{ce}}}}}An{}{}}{{{b{{AEh{ce}}}}}An{}{{En{}{{Fd{c}}}}}}{{{b{{AEh{ce}}}}{b{dh}}}jGn{{En{}{{Fd{c}}}}}}{{{b{{AEh{ce}}}}{b{dh}}}jAF`{{En{}{{Fd{c}}}}}}{cc{}}0=={{{AEh{ce}}}{{AFb{ce}}}{}{{En{}{{Fd{c}}}}}}{{{AEh{ce}}}c{}{{En{}{{Fd{c}}}}}}{{{b{{AEh{ce}}}}}Cn{}{{En{}{{Fd{c}}}}}}{e{{AEh{ce}}}{}{{En{}{{Fd{c}}}}}}{{{b{c}}}{{b{{Ab{e}}}}}{}{}}0{{{b{dc}}}{{b{d{Ab{e}}}}}{}{}}000{{{b{c}}}Ad{}}{c{{Af{e}}}{}{}}000{{{b{c}}}Ah{}}0{ce{}{}}0```{{{b{c}}}{{b{e}}}{}{}}0{{{b{dc}}}{{b{de}}}{}{}}0<<22{cAFd{{En{{b{dAFf}}}}}}88777755554433````{{{b{AFh}}}Dl}0{{{b{c}}}DlAFh}0{{}Dl}{{{b{c}}}DlAFj}`{{{b{Hn}}}{{b{Hn}}}}`````````````{{{b{Mb}}}Mb}{{MbMb}Mb}{{{Mf{c}}Mb}{{Mf{c}}}Nb}{{{Mf{c}}AFl}{{Mf{c}}}Nb}{{{Mf{c}}AFn}{}Nb}{{{Mf{c}}AG`}{}Nb}{{{Mf{c}}AGb}{{Mf{c}}}Nb}{{{b{dMb}}Mb}An}{{{b{d{Mf{c}}}}Mb}AnNb}{{{b{d{Mf{c}}}}AFl}AnNb}{{{b{c}}}{{b{e}}}{}{}}00{{{b{dc}}}{{b{de}}}{}{}}00{{{b{Mb}}{b{Mb}}}{{A`{Mb}}}}{{{Mf{c}}AFn}{{A`{{Mf{c}}}}}Nb}{{{Mf{c}}AG`}{{A`{{Mf{c}}}}}Nb}{{{Mf{c}}Mb}{{A`{{Mf{c}}}}}Nb}3210?{{{b{{Mf{c}}}}}{{Mf{c}}}{FlNb}}{{{b{Md}}}Md}{{{b{c}}{b{de}}}An{}{}}00{{{b{Mb}}{b{Mb}}}Ff}{{{b{{Mf{c}}}}{b{{Mf{c}}}}}FfNb}{{{b{{Mf{c}}}}}{{AGd{c}}}Nb}{{{b{{Mf{c}}}}}AGfNb}{{{b{{Mf{c}}}}}EbNb}0{O`Mb}``````{{}Mb}{{}{{Mf{Md}}}}{{}{{Mf{AGh}}}}{{}{{Mf{AGb}}}}{{MbAGj}Mb}{{{Mf{c}}Mb}{{Af{{Mf{c}}}}}Nb}0```{{{b{Mb}}{b{Mb}}}Cn}{{{b{{Mf{c}}}}{b{{Mf{e}}}}}CnNbNb}{{{b{c}}{b{e}}}Cn{}{}}000{{{b{{Mf{c}}}}}{{Mf{AGb}}}Nb}{{{b{Mb}}{b{dh}}}{{Af{AnAGl}}}}0{{{b{{Mf{c}}}}{b{dh}}}{{Af{AnAGl}}}Nb}0{{{b{Md}}{b{dh}}}{{Af{AnAGl}}}}{{{b{{Mf{c}}}}{b{Hn}}}{{AH`{AGn}}}Nb}{{{b{{Mf{c}}}}g}{{AH`{g}}}Nb{{AHd{AHb}}}{{A@`{}{{Lb{e}}}}Fl}}{cc{}}0{AHf{{Mf{Md}}}}{AHf{{Mf{AGh}}}}{{{Mf{Md}}}{{Mf{AGb}}}}{{{Mf{AGh}}}{{Mf{AGb}}}}{{{Mf{Md}}}{{Mf{AGh}}}}{{{Mf{AGh}}}{{Mf{Md}}}}{{{Mf{AGb}}}{{Mf{Md}}}}{{{Mf{AGb}}}{{Mf{AGh}}}}8{AHh{{Mf{c}}}Nb}0{{{b{AGb}}}Md}{AFl{{Af{MbAHj}}}}{{{b{Hn}}}{{Af{{Mf{AGb}}AHl}}}}{{{b{Hn}}}{{Af{{Mf{Md}}AHl}}}}{{{b{Hn}}}{{Af{{Mf{AGh}}AHl}}}}{{O`Eb}{{A`{{Mf{AGh}}}}}}{O`{{A`{{Mf{AGh}}}}}}0{O`{{Mf{AGh}}}}8`{{{b{Mb}}{b{dc}}}AnAHn}{{{b{{Mf{c}}}}{b{de}}}AnNbAHn}{{{b{{Mf{c}}}}}EbNb}{O`Mb}{ce{}{}}00{{{b{Mb}}}Cn}{{{b{{Mf{c}}}}}AI`Nb}{{}Mb}4405455{{MbAGj}Mb}{{{b{{Mf{c}}}}}AHhNb}076{MbMb}{{O`Eb}{{A`{Mb}}}}{{}{{Mf{Md}}}}{{{b{Mb}}}O`}0{{{b{Mb}}}{{A`{O`}}}}11011{{{b{{Mf{c}}}}}bNb}{{{b{Md}}{b{AGf}}}{{AIb{AGb}}}}{{{b{Md}}{b{AHh}}}{{AIb{AGb}}}}{{{b{Md}}{b{AGf}}}AGb}{{{b{Md}}{b{AHh}}}AGb}{{{b{{Mf{c}}}}}EbNb}0{{{b{Hn}}{b{Hn}}}{{Af{{Bd{{Mf{AGb}}{b{Hn}}}}AHl}}}}{{{b{Hn}}}{{Af{{Mf{AGb}}AHl}}}}0{{{b{Hn}}{b{Hn}}}{{Af{{Mf{AGb}}AHl}}}}{{{b{Mb}}{b{Mb}}}{{A`{Ff}}}}{{{b{{Mf{c}}}}{b{{Mf{e}}}}}{{A`{Ff}}}NbNb}{{cE`}e{}{}}6{O`Mb}{{{Mf{c}}g}MbNbNb{{AHd{{Mf{e}}}}}}{{MbMb}Mb}{{{Mf{c}}{Mf{c}}}MbNb}{{{Mf{c}}AFn}{}Nb}{{{Mf{c}}{b{{Mf{c}}}}}MbNb}{{{Mf{c}}AG`}{}Nb}{{{Mf{c}}AFl}{{Mf{c}}}Nb}{{{Mf{c}}AGb}{{Mf{c}}}Nb}{{{Mf{c}}Mb}{{Mf{c}}}Nb}{{{b{dMb}}Mb}An}{{{b{d{Mf{c}}}}Mb}AnNb}{{{b{d{Mf{c}}}}AFl}AnNb}{{{b{Mb}}}AGj}{cMb{{A@`{}{{Lb{{b{Mb}}}}}}}}{cMb{{A@`{}{{Lb{Mb}}}}}}{{{b{{Mf{c}}}}}AIdNb}{{{b{{Mf{c}}}}}O`Nb}000{{{b{{Mf{c}}}}}{{A`{O`}}}Nb}{{{b{{Mf{c}}}}}EbNb}00{{{b{{Mf{c}}}}}cNb}{{{b{c}}}{{b{{Ab{e}}}}}{}{}}00{{{b{dc}}}{{b{d{Ab{e}}}}}{}{}}00000{{{b{c}}}e{}{}}00{{{b{{Mf{c}}}}}AdNb}0{{{b{{Mf{c}}}}AIfCn}AdNb}{{{b{Mb}}}{{Af{AFlAHj}}}}{{{b{c}}}Ad{}}0{{{b{{Mf{c}}}}}{{Mf{AGh}}}Nb}{{}{{AGd{Md}}}}{{cE`}e{}{}}{O`{{A`{Mb}}}}{c{{Af{e}}}{}{}}0010001111{{{b{c}}}Ah{}}00{ce{}{}}00{{{b{{Mf{c}}}}}AIhNb}{O`Mb}{{{b{{Mf{c}}}}Eb}{{A`{{Mf{c}}}}}Nb}000000000{{{b{{Mf{c}}}}{b{e}}}{{Mf{e}}}NbNb}{{{b{{Mf{c}}}}AGj}{{A`{{Mf{c}}}}}Nb}{{{b{{Mf{c}}}}}AGjNb}{{{b{{Mf{c}}}}{Mf{c}}}{{A`{Eb}}}Nb}{{}Mb}````````{{{b{dAIj}}}{{AIl{Dh}}}}{{{b{dAIj}}Dl}{{AIl{{b{{El{Dh}}}}}}}}{{{b{dAIj}}}{{AIl{{b{{Db{Dh}}}}}}}}{{{b{dAIj}}Dl}{{AIl{Dh}}}}3{{{b{dAIn}}Dl}An}{{{b{dAIn}}c}An{{En{Dh}{{Fd{Dl}}}}}}{{{b{dAIn}}Dh}An}{{{b{dAIn}}{b{{El{Dh}}}}}An}0`{{{b{{El{Dh}}}}}{{AIl{c}}}AJ`}{{{b{dc}}}{{AIl{AJ`}}}AIj}1``````{{{b{c}}}{{b{e}}}{}{}}{{{b{dc}}}{{b{de}}}{}{}}{{{b{AJb}}}AJb}{{{b{c}}{b{de}}}An{}{}}{AJd{{AIl{c}}}{}}{{{AIl{ce}}}{{AIl{c}}}{}AJf}{{{b{AJb}}}{{b{Hn}}}}{{{b{AJb}}{b{AJb}}}Cn}{{{b{c}}{b{e}}}Cn{}{}}0{{}{{AIl{c}}}{}}{AJh{{AIl{c}}}{}}{{AJhe}{{AIl{g}}}{{l{Ad}}}{{En{}{{Fd{c}}}}}{}}{{{b{Hn}}}{{AIl{c}}}{}}{{AJh{b{Hn}}}{{AIl{c}}}{}}{c{{AIl{e}}}{{l{Ad}}}{}}{{AJhc}{{AIl{e}}}{{l{Ad}}}{}}{{}AJb}{{{b{Hn}}}AJb}{cAJb{{l{Ad}}}}{{{b{AJb}}{b{dh}}}j}0{cc{}}{ce{}{}}{{{b{c}}}{{b{{Ab{e}}}}}{}{}}{{{b{dc}}}{{b{d{Ab{e}}}}}{}{}}0{{{b{c}}}e{}{}}{{{b{c}}}Ad{}}{c{{Af{e}}}{}{}}0{{{b{c}}}Ah{}}6``````````{{{b{c}}}{{b{e}}}{}{}}{{{b{dc}}}{{b{de}}}{}{}}`{{{b{AJj}}}AJj}{{{b{c}}{b{de}}}An{}{}}{{}AJj}{{{b{AJj}}{b{dh}}}j}=<{{{b{c}}}{{Dj{Dh}}}{AEjAJl}}{{{b{AJl}}{b{dc}}{b{AJj}}}AnAIn}{{{b{c}}{b{AJj}}}{{Dj{Dh}}}{AEjAJl}}>==<::9?````{{{b{{AJn{c}}}}{b{Hn}}}{{AJn{c}}}AK`}{{{AJn{c}}{b{Ad}}}{{AJn{c}}}AK`}{{{AJn{c}}{b{{AJn{e}}}}}{{AJn{c}}}AK`AK`}{{{b{{AJn{c}}}}{b{{AJn{e}}}}}{{AJn{c}}}AK`AK`}{{{AJn{c}}{b{Hn}}}{{AJn{c}}}AK`}{{{b{{AJn{c}}}}{b{Ad}}}{{AJn{c}}}AK`}{{{AJn{c}}Ad}{{AJn{c}}}AK`}{{{b{{AJn{c}}}}Ad}{{AJn{c}}}AK`}{{{AJn{c}}{AJn{e}}}{{AJn{c}}}AK`AK`}{{{b{{AJn{c}}}}{AJn{e}}}{{AJn{c}}}AK`AK`}{{{b{d{AJn{c}}}}{b{{AJn{e}}}}}AnAK`AK`}{{{b{d{AJn{c}}}}{b{Hn}}}AnAK`}{{{b{d{AJn{c}}}}{AJn{e}}}AnAK`AK`}{{{b{{AJn{c}}}}}{{b{Hn}}}AK`}{{{b{{AJn{c}}}}}{{b{{El{Dh}}}}}AK`}{{{b{{AJn{c}}}}}{{b{AKb}}}AK`}{{{b{{AJn{c}}}}}{{b{AKd}}}AK`}{{{b{c}}}{{b{e}}}{}{}}4{{{b{dc}}}{{b{de}}}{}{}}{{{b{{AJn{c}}}}}{{AJn{c}}}AK`}{{{b{c}}{b{de}}}An{}{}}{{}{{AJn{c}}}AK`}8{{{b{{AJn{c}}}}{b{dh}}}jAK`}0{cc{}}{{{b{Hn}}}AJn}{{{Bd{{b{Hn}}c}}}{{AJn{c}}}AK`}{ce{}{}}`{{{b{{AK`{}{{AKf{c}}}}}}{b{c}}}c{}}{{{b{{AK`{}{{AKf{c}}}}}}}c{}}{{{b{{AK`{}{{AKf{c}}}}}}{b{{El{Dh}}}}}c{}}{{{b{{AK`{}{{AKf{c}}}}}}AKh}c{}}{{{b{{AK`{}{{AKf{c}}}}}}{Dj{Dh}}}c{}}{{{b{{AK`{}{{AKf{c}}}}}}c}{{Hd{{El{Dh}}}}}{}}{{{b{{AK`{}{{AKf{c}}}}}}c}{{Dj{Dh}}}{}}{{{b{{AK`{}{{AKf{c}}}}}}{b{c}}}{{b{{El{Dh}}}}}{}}`{{{b{c}}}{{b{{Ab{e}}}}}{}{}}{{{b{dc}}}{{b{d{Ab{e}}}}}{}{}}0{{{b{c}}}e{}{}}{{{b{c}}}Ad{}}{c{{Af{e}}}{}{}}0{{{b{c}}}Ah{}}>`````{{{b{c}}}{{b{e}}}{}{}}00{{{b{dc}}}{{b{de}}}{}{}}00{{{b{dc}}}{{Lf{{b{de}}}}}{}{}}{{{b{AKj}}}AKj}{{{b{c}}{b{de}}}An{}{}}{cLf{}}{{}AKj}{{{b{AKh}}b}Cn}{{{b{AKj}}{b{dh}}}j}{{{b{AKh}}{b{dh}}}j}{cc{}}00{{{b{AKh}}{b{dc}}}AnAHn}{ce{}{}}000{{{b{AKh}}}c{}}{{{b{dAKl}}}{{A`{Dh}}}}{{{b{{AK`{}{{AKf{c}}}}}}{b{c}}}c{}}{{{b{AKj}}{b{c}}}c{}}{{{b{{AK`{}{{AKf{c}}}}}}}c{}}{{{b{{AK`{}{{AKf{c}}}}}}{b{{El{Dh}}}}}c{}}{{{b{{AK`{}{{AKf{c}}}}}}AKh}c{}}{{{b{AKj}}AKh}c{}}{{{b{{AK`{}{{AKf{c}}}}}}{Dj{Dh}}}c{}}{{{b{{AK`{}{{AKf{c}}}}}}c}{{Hd{{El{Dh}}}}}{}}{{{b{{AK`{}{{AKf{c}}}}}}c}{{Dj{Dh}}}{}}{{{b{{AK`{}{{AKf{c}}}}}}{b{c}}}{{b{{El{Dh}}}}}{}}{{{b{AKj}}{b{c}}}{{b{{El{Dh}}}}}{}}{{{b{AKl}}}{{Bd{Dl{A`{Dl}}}}}}{{{b{AKh}}}{{Hd{{El{Dh}}}}}}{{{b{c}}}{{b{{Ab{e}}}}}{}{}}00{{{b{dc}}}{{b{d{Ab{e}}}}}{}{}}00000{{{b{c}}}e{}{}}{{{b{AKh}}}{{Dj{Dh}}}}{c{{Af{e}}}{}{}}00000{{{b{c}}}Ah{}}00{ce{}{}}00`{{{b{{AJn{c}}}}}{{b{{El{Dh}}}}}AK`}{{{b{{AJn{c}}}}}{{b{Hn}}}AK`}{{{b{d{AJn{c}}}}}AnAK`}{{{b{{AJn{c}}}}e}{{AJn{e}}}AK`AK`}{{{b{Hn}}c}{{AJn{c}}}AK`}{{{b{{El{E`}}}}}{{Af{AJnAKn}}}}{{{b{{El{E`}}}}c}{{Af{{AJn{c}}AKn}}}AK`}{{{b{{El{E`}}}}}AJn}{{{b{{El{E`}}}}c}{{AJn{c}}}AK`}{{{Dj{Dh}}}{{Af{AJnK`}}}}{{{Dj{Dh}}c}{{Af{{AJn{c}}K`}}}AK`}{{{b{{El{Dh}}}}}AJn}{{{b{{El{Dh}}}}c}{{AJn{c}}}AK`}{{{b{{El{Dh}}}}}{{Af{AJnAL`}}}}{{{b{{El{Dh}}}}c}{{Af{{AJn{c}}AL`}}}AK`}{{{Dj{Dh}}}AJn}{{{Dj{Dh}}c}{{AJn{c}}}AK`}54{{{b{d{AJn{c}}}}DlKd}AnAK`}{{{b{d{AJn{c}}}}Dl{b{Hn}}}AnAK`}{{{AJn{c}}}{{Hd{Hn}}}AK`}{{{AJn{c}}}{{Dj{Dh}}}AK`}{{{AJn{c}}e}{{AJn{e}}}AK`AK`}{{{AJn{c}}}{{b{dHn}}}AK`}{{}AJn}{c{{AJn{c}}}AK`}{{{b{d{AJn{c}}}}}{{A`{Kd}}}AK`}{{{b{d{AJn{c}}}}Kd}AnAK`}{{{b{d{AJn{c}}}}{b{Hn}}}AnAK`}{{{b{d{AJn{c}}}}Dl}KdAK`}{{{b{d{AJn{c}}}}e}AnAK`{{Fh{Kd}{{Fd{Cn}}}}}}{{{b{d{AJn{c}}}}Dl}{{AJn{c}}}AK`}{{{b{d{AJn{c}}}}Dle}{{AJn{e}}}AK`AK`}{{{b{{AJn{c}}}}e}{{AJn{e}}}AK`AK`}{{{b{d{AJn{c}}}}Dl}AnAK`}`{{{b{c}}}{{b{e}}}{}{}}{{{b{dc}}}{{b{de}}}{}{}}{cc{}}{ce{}{}}{{{Db{{Db{Dh}}}}}ALb}{{{b{c}}}{{b{{Ab{e}}}}}{}{}}{{{b{dc}}}{{b{d{Ab{e}}}}}{}{}}0{c{{Af{e}}}{}{}}0{{{b{c}}}Ah{}}5`{{{b{ALd}}}{{b{{Ab{ALd}}}}}}{{{b{dALd}}}{{b{d{Ab{ALd}}}}}}0``````````:9{{{b{{El{Dh}}}}}{{Af{{Dj{Dh}}ALf}}}}{{{b{{El{Dh}}}}}Ad}{{{b{ALf}}{b{ALf}}}Cn}{{{b{ALf}}{b{dh}}}j}0<;988{{{b{c}}}Ad{}}887<","D":"DAd","p":[[1,"reference"],[0,"mut"],[5,"Error",28],[5,"Formatter",2366],[8,"Result",2366],[10,"Into",2367],[10,"Error",2368],[6,"Option",2369],[20,"MaybeUninit",2370],[5,"String",2371],[6,"Result",2372],[5,"TypeId",2373],[5,"ClientContinuerS3",48],[5,"SigninResponseS3",48],[1,"unit"],[5,"SigninRequestS1",48],[5,"ClientContinuerS1",48],[1,"tuple"],[8,"Result",28],[5,"SigninResponseS1",48],[5,"SigninRequestS2",48],[5,"ClientContinuerS2",48],[5,"SigninResponseS2",48],[5,"SigninRequestS3",48],[5,"ServerS2Params",48],[5,"ServerS3Params",48],[5,"SignupRequest",205],[5,"StoredUnverifiedUserData",205],[10,"UnsignedBigint",247],[5,"U320",247],[1,"bool"],[10,"Part",247],[1,"array"],[1,"u64"],[5,"Encoder",276],[1,"u8"],[5,"Vec",2374],[1,"usize"],[1,"u128"],[1,"u16"],[1,"u32"],[5,"BinaryHeapChain",297,2375],[5,"BinaryHeap",2376],[10,"Ord",2377],[5,"VecChain",297,2378],[1,"slice"],[10,"FnOnce",2379],[5,"SliceBoxChain",297,2380],[5,"ArrayChain",297,2381],[17,"Output"],[6,"Ordering",2377],[10,"FnMut",2379],[5,"StringChain",297,2382],[10,"Clone",2383],[10,"PartialEq",2377],[10,"Copy",2384],[10,"RangeBounds",2385],[10,"PartialOrd",2377],[10,"Default",2386],[5,"Drain",2387],[5,"SliceRefChain",297,2388],[5,"SliceMutChain",297,2389],[10,"Debug",2366],[5,"VecRefChain",297,2390],[5,"VecMutChain",297,2391],[5,"Box",2392],[5,"ArrayRefChain",297,2393],[5,"ArrayMutChain",297,2394],[5,"StringRefChain",297,2395],[5,"StringMutChain",297,2396],[1,"str"],[5,"StrBoxChain",297,2397],[5,"StrRefChain",297,2398],[5,"StrMutChain",297,2399],[5,"VecDeque",2400],[5,"VecDequeChain",297,2401],[5,"LinkedList",2402],[5,"LinkedListChain",297,2403],[5,"HashMap",2404],[5,"HashMapChain",297,2405],[5,"HashSet",2406],[5,"HashSetChain",297,2407],[5,"BTreeMap",2408],[5,"BTreeMapChain",297,2409],[5,"BTreeSet",2410],[5,"BTreeSetChain",297,2411],[5,"BitstreamEncoderChain",297,2412],[5,"FromUtf8Error",2371],[10,"SliceIndex",2413],[1,"char"],[17,"Chain"],[10,"IntoChainer",297,2414],[10,"From",2367],[5,"Range",2385],[1,"f32"],[1,"f64"],[17,"Item"],[10,"IntoIter",1036,2415],[5,"IterAdapter",1036,2416],[5,"Splice",2417],[5,"Windows",2418],[5,"PeekMut",2376],[5,"Builder",920],[5,"Tick",883],[5,"TimeDelta",1842,2419],[5,"Local",1842,2420],[5,"DateTime",1842,2421],[5,"ClockTimer",883],[10,"Future",2422],[5,"BuilderWithInterval",920],[5,"BuilderWithStart",920],[5,"BuilderWithEnd",920],[10,"TimeZone",2423],[10,"Fn",2379],[10,"Send",2384],[10,"Sync",2384],[5,"Handle",2424],[6,"DecodeError",979],[5,"GeneratedID",1002],[1,"i64"],[8,"NonZeroU64",2425],[5,"IDGenerator",1002],[17,"Iter"],[10,"AsWiwiIter",1036,2416],[10,"Iter",1036],[17,"Iterator"],[10,"AsStdIterator",1036,2416],[10,"Iterator",2426],[10,"IntoWiwiIter",1036,2416],[10,"IntoStdIterator",1036,2416],[5,"SizeHint",1036,2427],[5,"Empty",1036,2428],[6,"SizeHintBound",1036,2427],[5,"FromFn",1036,2429],[5,"Map",1036,2430],[5,"Peek",1036,2431],[5,"RepeatPerItem",1036,2432],[5,"Tuple32",1036,2433],[5,"Tuple31",1036,2433],[5,"Tuple30",1036,2433],[5,"Tuple29",1036,2433],[5,"Tuple28",1036,2433],[5,"Tuple27",1036,2433],[5,"Tuple26",1036,2433],[5,"Tuple25",1036,2433],[5,"Tuple24",1036,2433],[5,"Tuple23",1036,2433],[5,"Tuple22",1036,2433],[5,"Tuple21",1036,2433],[5,"Tuple20",1036,2433],[5,"Tuple19",1036,2433],[5,"Tuple18",1036,2433],[5,"Tuple17",1036,2433],[5,"Tuple16",1036,2433],[5,"Tuple15",1036,2433],[5,"Tuple14",1036,2433],[5,"Tuple13",1036,2433],[5,"Tuple12",1036,2433],[5,"Tuple11",1036,2433],[5,"Tuple10",1036,2433],[5,"Tuple9",1036,2433],[5,"Tuple8",1036,2433],[5,"Tuple7",1036,2433],[5,"Tuple6",1036,2433],[5,"Tuple5",1036,2433],[5,"Tuple4",1036,2433],[5,"Tuple3",1036,2433],[5,"Tuple2",1036,2433],[5,"Tuple1",1036,2433],[17,"PeekItem"],[10,"Peekable",1036,2431],[5,"LazyWrap",1765],[10,"Sized",2384],[10,"AsMut",2367],[10,"AsRef",2367],[10,"Display",2366],[6,"LazyWrapState",1765],[5,"Script",1805,2434],[5,"ScriptBuilder",1805,2434],[10,"Dynamic",1830],[10,"Static",1830],[5,"Duration",2435],[5,"Days",2436],[5,"Months",2437],[5,"FixedOffset",2438],[5,"Date",2439],[5,"NaiveDate",2440],[5,"Utc",2441],[1,"i32"],[5,"Error",2366],[5,"StrftimeItems",2442],[5,"DelayedFormat",2443],[6,"Item",2444],[10,"Borrow",2445],[5,"SystemTime",2446],[5,"NaiveDateTime",2447],[5,"OutOfRangeError",2419],[5,"ParseError",2444],[10,"Hasher",2448],[5,"IsoWeek",2449],[6,"LocalResult",2423],[5,"NaiveTime",2450],[6,"SecondsFormat",2443],[6,"Weekday",2451],[10,"BufferRead",2082],[8,"Result",2098],[10,"BufferWrite",2082],[10,"Deserialise",2094],[6,"Error",2098],[10,"ResultExt",2098],[10,"ToString",2371],[10,"OptionExt",2098],[5,"SerialiseOptions",2145],[10,"Serialise",2145],[5,"String",2167,2285],[10,"Pool",2167,2220],[5,"OsStr",2452],[5,"Path",2453],[17,"Raw"],[5,"SlicesWrap",2220],[5,"GlobalPool",2220,2454],[5,"SlicesWrapIter",2220],[5,"FromUtf16Error",2371],[5,"Utf8Error",2455],[5,"Board",2322],[10,"ToMaybeUninit",2335],[6,"DecodeError",2339],[15,"HardBound",1763],[15,"Estimate",1763],[15,"Str",2137],[15,"String",2137]],"r":[[297,2381],[298,2394],[299,2393],[300,2409],[301,2411],[302,2375],[303,2412],[305,2405],[306,2407],[307,2414],[308,2403],[309,2380],[310,2389],[311,2388],[312,2397],[313,2399],[314,2398],[315,2382],[316,2396],[317,2395],[318,2378],[319,2401],[320,2391],[321,2390],[1036,2416],[1037,2416],[1038,2428],[1040,2429],[1042,2415],[1043,2416],[1044,2416],[1051,2416],[1054,2430],[1055,2431],[1057,2431],[1058,2432],[1059,2427],[1060,2427],[1061,2433],[1062,2433],[1063,2433],[1064,2433],[1065,2433],[1066,2433],[1067,2433],[1068,2433],[1069,2433],[1070,2433],[1071,2433],[1072,2433],[1073,2433],[1074,2433],[1075,2433],[1076,2433],[1077,2433],[1078,2433],[1079,2433],[1080,2433],[1081,2433],[1082,2433],[1083,2433],[1084,2433],[1085,2433],[1086,2433],[1087,2433],[1088,2433],[1089,2433],[1090,2433],[1091,2433],[1092,2433],[1259,2428],[1304,2429],[1805,2434],[1806,2434],[1815,2434],[1832,2456],[1842,883],[1843,2421],[1844,1002],[1845,1002],[1846,1765],[1847,1765],[1848,2420],[1851,2285],[1852,883],[1853,2419],[1892,974],[1893,974],[1894,974],[1895,974],[1896,979],[1897,2339],[1905,979],[1906,979],[1907,2339],[1945,978],[2139,0],[2140,0],[2141,0],[2142,0],[2143,0],[2144,0],[2167,2454],[2168,2220],[2170,2285],[2220,2454]],"b":[[32,"impl-Debug-for-Error"],[33,"impl-Display-for-Error"],[329,"impl-AsMut%3C%5BT%5D%3E-for-VecChain%3CT%3E"],[330,"impl-AsMut%3CVec%3CT%3E%3E-for-VecChain%3CT%3E"],[333,"impl-AsRef%3CVec%3CT%3E%3E-for-VecChain%3CT%3E"],[334,"impl-AsRef%3C%5BT%5D%3E-for-VecChain%3CT%3E"],[671,"impl-VecChain%3Cf32%3E"],[672,"impl-VecChain%3Cf64%3E"],[990,"impl-Display-for-DecodeError"],[991,"impl-Debug-for-DecodeError"],[1393,"impl-Iterator-for-IterAdapter%3CI%3E"],[1394,"impl-Iter-for-IterAdapter%3CI%3E"],[1436,"impl-Iter-for-IterAdapter%3CI%3E"],[1437,"impl-Iterator-for-IterAdapter%3CI%3E"],[1779,"impl-Debug-for-LazyWrap%3CT,+F%3E"],[1780,"impl-Display-for-LazyWrap%3CT,+F%3E"],[1857,"impl-Add%3CTimeDelta%3E-for-DateTime%3CTz%3E"],[1858,"impl-Add%3CDuration%3E-for-DateTime%3CTz%3E"],[1859,"impl-Add%3CDays%3E-for-DateTime%3CTz%3E"],[1860,"impl-Add%3CMonths%3E-for-DateTime%3CTz%3E"],[1861,"impl-Add%3CFixedOffset%3E-for-DateTime%3CTz%3E"],[1863,"impl-AddAssign%3CTimeDelta%3E-for-DateTime%3CTz%3E"],[1864,"impl-AddAssign%3CDuration%3E-for-DateTime%3CTz%3E"],[1899,"impl-Default-for-DateTime%3CLocal%3E"],[1900,"impl-Default-for-DateTime%3CUtc%3E"],[1901,"impl-Default-for-DateTime%3CFixedOffset%3E"],[1915,"impl-Display-for-TimeDelta"],[1916,"impl-Debug-for-TimeDelta"],[1917,"impl-Debug-for-DateTime%3CTz%3E"],[1918,"impl-Display-for-DateTime%3CTz%3E"],[1924,"impl-From%3CSystemTime%3E-for-DateTime%3CLocal%3E"],[1925,"impl-From%3CSystemTime%3E-for-DateTime%3CUtc%3E"],[1926,"impl-From%3CDateTime%3CLocal%3E%3E-for-DateTime%3CFixedOffset%3E"],[1927,"impl-From%3CDateTime%3CUtc%3E%3E-for-DateTime%3CFixedOffset%3E"],[1928,"impl-From%3CDateTime%3CLocal%3E%3E-for-DateTime%3CUtc%3E"],[1929,"impl-From%3CDateTime%3CUtc%3E%3E-for-DateTime%3CLocal%3E"],[1930,"impl-From%3CDateTime%3CFixedOffset%3E%3E-for-DateTime%3CLocal%3E"],[1931,"impl-From%3CDateTime%3CFixedOffset%3E%3E-for-DateTime%3CUtc%3E"],[1937,"impl-FromStr-for-DateTime%3CFixedOffset%3E"],[1938,"impl-FromStr-for-DateTime%3CLocal%3E"],[1939,"impl-FromStr-for-DateTime%3CUtc%3E"],[1997,"impl-Sub-for-DateTime%3CTz%3E"],[1998,"impl-Sub%3CDays%3E-for-DateTime%3CTz%3E"],[1999,"impl-Sub%3C%26DateTime%3CTz%3E%3E-for-DateTime%3CTz%3E"],[2000,"impl-Sub%3CMonths%3E-for-DateTime%3CTz%3E"],[2001,"impl-Sub%3CDuration%3E-for-DateTime%3CTz%3E"],[2002,"impl-Sub%3CFixedOffset%3E-for-DateTime%3CTz%3E"],[2003,"impl-Sub%3CTimeDelta%3E-for-DateTime%3CTz%3E"],[2005,"impl-SubAssign%3CTimeDelta%3E-for-DateTime%3CTz%3E"],[2006,"impl-SubAssign%3CDuration%3E-for-DateTime%3CTz%3E"],[2008,"impl-Sum%3C%26TimeDelta%3E-for-TimeDelta"],[2009,"impl-Sum-for-TimeDelta"],[2124,"impl-Display-for-Error"],[2125,"impl-Debug-for-Error"],[2171,"impl-Add%3C%26str%3E-for-%26String%3CP%3E"],[2172,"impl-Add%3C%26String%3E-for-String%3CP%3E"],[2173,"impl-Add%3C%26String%3CP2%3E%3E-for-String%3CP%3E"],[2174,"impl-Add%3C%26String%3CP2%3E%3E-for-%26String%3CP%3E"],[2175,"impl-Add%3C%26str%3E-for-String%3CP%3E"],[2176,"impl-Add%3C%26String%3E-for-%26String%3CP%3E"],[2177,"impl-Add%3CString%3E-for-String%3CP%3E"],[2178,"impl-Add%3CString%3E-for-%26String%3CP%3E"],[2179,"impl-Add%3CString%3CP2%3E%3E-for-String%3CP%3E"],[2180,"impl-Add%3CString%3CP2%3E%3E-for-%26String%3CP%3E"],[2181,"impl-AddAssign%3C%26String%3CP2%3E%3E-for-String%3CP%3E"],[2182,"impl-AddAssign%3C%26str%3E-for-String%3CP%3E"],[2183,"impl-AddAssign%3CString%3CP2%3E%3E-for-String%3CP%3E"],[2184,"impl-AsRef%3Cstr%3E-for-String%3CP%3E"],[2185,"impl-AsRef%3C%5Bu8%5D%3E-for-String%3CP%3E"],[2186,"impl-AsRef%3COsStr%3E-for-String%3CP%3E"],[2187,"impl-AsRef%3CPath%3E-for-String%3CP%3E"],[2195,"impl-Debug-for-String%3CP%3E"],[2196,"impl-Display-for-String%3CP%3E"],[2198,"impl-From%3C%26str%3E-for-String"],[2199,"impl-From%3C(%26str,+P)%3E-for-String%3CP%3E"],[2354,"impl-Display-for-DecodeError"],[2355,"impl-Debug-for-DecodeError"]],"c":"OjAAAAEAAAAAAAoAEAAAAGAHZAeOB5kHngemB6kHywffB/gHDQg=","e":"OzAAAAEAADQHigABAAIACQACAA0AAgARAAUAGAABABsACAAmAAgAMQAlAGIAAQBvAGgA2gABAN4AAADgACMABQEDAAoBDQAaAQkAQwFtALMBAAC1AQAAtwEAALkBAAC7AQEAvwEAAMEBAQDEAQAAxgEAAMgBAADKAQAAzQEBANABAADSAQAA1AEAANYBAADYAQAA2wEBAN4BDAACAgQACQIRABwCAwAhAgYAKQIDAC4CAwAzAggAPQIPAE4CEABgAgQAZgIyAJoCDQCpAgoAuAJPAAkDYQBsAwcAdgMDAHwDAACKAwUAkQMHAJoDCgCvAxsA2gMBAN8DAQDjAwgA7QMGAPYDAAD4AwAA/AMQAA8EAAARBAAAEwQAABYEBQAdBAcARwRQAJkEAACbBCUAwgQAAMQEJQDsBAQAGQUAAEMFAQBGBVUAnQUmAMUFGQHgBgEA4wYCAOoGCAD0BgEA/gYVABgHDgApBwAALgcAADEHAgA1BwMAPAcBAEEHDgBYBwcAYgcBAGUHFQB9BwMAhQcBAJAHAACSBwIAmgcDAKMHAACoBwAAqgcCAK8HAACxBwAAvQcFAMcHAADJBwEAzQcKANkHAQDlBwsA9QcBAPkHAAD7BwIA/wcCAAYIBgAaCAAAHQgxAFEIGQBtCAoAfAgZAJcIAQCkCAgAsggNAMMIAADHCAIAywgAAM8IAADUCAEA1wgJAOIICwDvCCYAGAkJACMJAAAuCQEAMgkCADcJBwA="}],\ +["wiwi",{"t":"CCCCCCCCCQCCCCCCCQQQQQCCCCCCFINNNNNNNNNNNNNNNNCCFFFFFFFFFFFNNNNNNNNNNNNNNNNNNNNNNOOOOONNNNNNNNNNNOONNNNNNNNNNNHHHHHHOOOOOOOOOONNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNOONNNNNNNNNNNFFNNNNOOOONNOONNHHOOOOONNNNNNNNNNNNOOOOONNTTTKFKNNNNNNNMMNONMNMNNNNNNNNFNNNNNNNNNNNNNNNNNNNNFFFFFFFRFFKFFFFFFFFFFFFFFNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNCNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNFFNNNNCNENNNNNNNNNNNNNNNNNNNNNNNNNNNNFFFFNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNHHHHHGPPSSSNNHHHNNNNNNNNNNNNFFNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNKKKFPFPKKKRRKRRRFRRFFRKFFFGFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFPNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNMNMNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNMNMNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNHNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNHNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNMNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNMNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNMNNNMNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNOOPFGPNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNCFFNNNNNNNNHNNNNNNNNNNNNNNKTYKMNHHHHSHEFEEEEFTTEEFTNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNEEEEEENNNNNNNEEENNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNENNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNCCCCCCKKNNNMNMMNNMKHMHGKIKPPNNNNMNNNNNHMMHMHMHHHNNNNNNNNNNNNNOOFNNNNNNNNNNNNQQQQQQKFNNONNNNNNHMHNNNNNNNNFKRFNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNCNNNMNNNMCNNNNNNNNNFKRFFNNNNNNNNNNNNNNNNNNNNNNNNNNNNMNNNNMNNNNNNNNNNNNNNNNNNNNNNNNNNFNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNFNNNNNNNNNNNNKMMMSGPPPSSSSSNNHHNNNNNNNNNNNNN","n":["auth","bigint","bitstream","chainer","clock_timer","debounce","h","hex","id","int_range","iter","lazy_wrap","lsl","memory_usage","path","prelude","serialiser","smallint_negative_as_unsigned_range","smallint_negative_range","smallint_positive_range","smallint_signed_range","smallint_unsigned_range","string_pool","sudoku","to_maybeuninit","z85","error","flow","Error","Result","borrow","borrow_mut","fmt","fmt","from","from","into","source","to_maybeuninit","to_maybeuninit_drop","to_maybeuninit_mut","to_string","try_from","try_into","type_id","vzip","signin","signup","ClientContinuerS1","ClientContinuerS2","ClientContinuerS3","ServerS2Params","ServerS3Params","SigninRequestS1","SigninRequestS2","SigninRequestS3","SigninResponseS1","SigninResponseS2","SigninResponseS3","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","challenge_signature","encrypted_user_sec_key","encrypted_user_sec_key","encrypted_user_sec_key_nonce","encrypted_user_sec_key_nonce","from","from","from","from","from","from","from","from","from","from","from","hashed_pw_verifier","hashed_pw_verifier_salt","into","into","into","into","into","into","into","into","into","into","into","process_signin_client_final","process_signin_client_s1","process_signin_client_s2","process_signin_client_s3","process_signin_server_s2","process_signin_server_s3","pw_key_salt","pw_verifier","pw_verifier_salt","session_id","session_pub_key","signin_attempt_id","signin_attempt_id","signin_attempt_id","signing_challenge","signing_challenge","to_maybeuninit","to_maybeuninit","to_maybeuninit","to_maybeuninit","to_maybeuninit","to_maybeuninit","to_maybeuninit","to_maybeuninit","to_maybeuninit","to_maybeuninit","to_maybeuninit","to_maybeuninit_drop","to_maybeuninit_drop","to_maybeuninit_drop","to_maybeuninit_drop","to_maybeuninit_drop","to_maybeuninit_drop","to_maybeuninit_drop","to_maybeuninit_drop","to_maybeuninit_drop","to_maybeuninit_drop","to_maybeuninit_drop","to_maybeuninit_mut","to_maybeuninit_mut","to_maybeuninit_mut","to_maybeuninit_mut","to_maybeuninit_mut","to_maybeuninit_mut","to_maybeuninit_mut","to_maybeuninit_mut","to_maybeuninit_mut","to_maybeuninit_mut","to_maybeuninit_mut","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","type_id","type_id","type_id","type_id","type_id","type_id","type_id","type_id","type_id","type_id","type_id","user_id","user_public_key","vzip","vzip","vzip","vzip","vzip","vzip","vzip","vzip","vzip","vzip","vzip","SignupRequest","StoredUnverifiedUserData","borrow","borrow","borrow_mut","borrow_mut","encrypted_user_sec_key","encrypted_user_sec_key","encrypted_user_sec_key_nonce","encrypted_user_sec_key_nonce","from","from","hashed_pw_verifier","hashed_pw_verifier_salt","into","into","process_signup_client","process_signup_server","pw_key_salt","pw_key_salt","pw_verifier","pw_verifier_salt","pw_verifier_salt","to_maybeuninit","to_maybeuninit","to_maybeuninit_drop","to_maybeuninit_drop","to_maybeuninit_mut","to_maybeuninit_mut","try_from","try_from","try_into","try_into","type_id","type_id","user_id","user_id","user_public_key","user_public_key","verification_token","vzip","vzip","BITS","MAX","MIN","Part","U320","UnsignedBigint","add_unchecked","borrow","borrow_mut","clone","clone_into","fmt","from","from_bool","from_le_parts","from_le_parts","inner","into","into_le_parts","into_le_parts","overflowing_add","to_maybeuninit","to_maybeuninit_drop","to_maybeuninit_mut","to_owned","try_from","try_into","type_id","vzip","Encoder","borrow","borrow_mut","from","into","into_bytes","new","to_maybeuninit","to_maybeuninit_drop","to_maybeuninit_mut","try_from","try_into","type_id","vzip","with_output_capacity","write_bits_u128_unchecked","write_bits_u16_unchecked","write_bits_u32_unchecked","write_bits_u64_unchecked","write_bits_u8_unchecked","write_bits_usize_unchecked","ArrayChain","ArrayMutChain","ArrayRefChain","BTreeMapChain","BTreeSetChain","BinaryHeapChain","BitstreamEncoderChain","Chain","HashMapChain","HashSetChain","IntoChainer","LinkedListChain","SliceBoxChain","SliceMutChain","SliceRefChain","StrBoxChain","StrMutChain","StrRefChain","StringChain","StringMutChain","StringRefChain","VecChain","VecDequeChain","VecMutChain","VecRefChain","append","append","append_vec_chain","as_chunks","as_chunks_mut","as_chunks_unchecked","as_chunks_unchecked_mut","as_mut","as_mut","as_rchunks","as_rchunks_mut","as_ref","as_ref","assume_init","assume_init","binary_search","binary_search_by","binary_search_by_key","binary_search_by_key_uninit","binary_search_by_uninit","binary_search_uninit","borrow","borrow","borrow","borrow","borrow","borrow","borrow","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","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","capacity","capacity","capacity","capacity_uninit","capacity_uninit","capacity_uninit","clear","clear","clone","clone_from_slice","clone_into","contains","contains_uninit","copy_from_slice","copy_within","dedup","dedup_by","dedup_by_key","dedup_by_key_mut","dedup_by_mut","default","drain","ends_with","ends_with_uninit","extend_from_slice","extend_from_within","extend_from_within","fill","fill_with","first","first","first","first","first_chunk","first_chunk_mut","first_mut","first_mut","first_mut","flatten","flatten","flatten","fmt","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","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from_raw_parts","from_raw_parts","from_utf16","from_utf16_lossy","from_utf8","from_utf8_unchecked","get","get_mut","get_unchecked","get_unchecked_mut","insert","insert","insert_str","into","into","into","into","into","into","into","into","into","into","into","into","into","into","into","into","into","into","into","into","into","into","into","into_binary_heap","into_bytes","into_bytes","into_bytes_chainer","into_bytes_chainer","into_chainer","into_chainer","into_inner","into_inner","into_inner","into_inner","into_inner","into_inner","into_inner","into_raw_parts","into_sorted_vec","into_sorted_vec_chainer","into_vec_chain","into_vec_chain","is_ascii","is_ascii_uninit","is_empty","is_empty","is_empty","is_empty","is_empty","is_empty_uninit","is_empty_uninit","is_empty_uninit","is_empty_uninit","is_empty_uninit","last","last","last","last_chunk","last_chunk_mut","last_mut","last_mut","leak","len","len","len","len","len","len_uninit","len_uninit","len_uninit","len_uninit","len_uninit","make_ascii_lowercase","make_ascii_uppercase","new","new","new","new","new","new","new","new","new_uninit","new_uninit","new_zeroed","new_zeroed","nonchain_array","nonchain_array","nonchain_array","nonchain_array_chainer_mut","nonchain_array_chainer_ref","nonchain_array_chainer_ref","nonchain_array_mut","nonchain_array_mut","nonchain_boxed_slice","nonchain_boxed_slice_chainer","nonchain_bytes","nonchain_contiguous_mut","nonchain_inner","nonchain_ptr","nonchain_ptr","nonchain_ptr_mut","nonchain_ptr_mut","nonchain_ptr_range","nonchain_ptr_range_mut","nonchain_raw_parts","nonchain_slice","nonchain_slice","nonchain_slice","nonchain_slice","nonchain_slice","nonchain_slice","nonchain_slice","nonchain_slice_chainer_mut","nonchain_slice_chainer_mut","nonchain_slice_chainer_mut","nonchain_slice_chainer_mut","nonchain_slice_chainer_ref","nonchain_slice_chainer_ref","nonchain_slice_chainer_ref","nonchain_slice_chainer_ref","nonchain_slice_chainer_ref","nonchain_slice_chainer_ref","nonchain_slice_chainers_mut","nonchain_slice_chainers_ref","nonchain_slice_mut","nonchain_slice_mut","nonchain_slice_mut","nonchain_slice_mut","nonchain_slice_mut","nonchain_slices","nonchain_slices_mut","nonchain_str","nonchain_str_mut","nonchain_vec","nonchain_vec_deque","nonchain_vec_deque_mut","nonchain_vec_mut","nonchain_vec_mut","pop","pop","pop","pop_uninit","pop_uninit","pop_uninit","push","push","push","push_str","remove","remove","remove_uninit","remove_uninit","repeat","reserve","reserve","reserve","reserve_exact","reserve_exact","reserve_exact","resize","resize_with","retain","retain","retain","retain_mut","reverse","set_len","shrink_to","shrink_to","shrink_to_fit","shrink_to_fit","sort","sort","sort_and_dedup","sort_by","sort_by","sort_by_cached_key","sort_by_cached_key","sort_by_key","sort_by_key","sort_floats","sort_floats","sort_unstable","sort_unstable","sort_unstable_by","sort_unstable_by","sort_unstable_by_key","sort_unstable_by_key","spare_capacity_mut","splice","split","split_at_spare_mut","split_first","split_first_chunk","split_first_chunk_mut","split_first_mut","split_last","split_last_chunk","split_last_chunk_mut","split_last_mut","split_left_off","split_left_off_uninit","split_right_off","split_right_off_uninit","starts_with","starts_with_uninit","swap","swap_remove","swap_remove_uninit","swap_unchecked","swap_with_slice","to_maybeuninit","to_maybeuninit","to_maybeuninit","to_maybeuninit","to_maybeuninit","to_maybeuninit","to_maybeuninit","to_maybeuninit","to_maybeuninit","to_maybeuninit","to_maybeuninit","to_maybeuninit","to_maybeuninit","to_maybeuninit","to_maybeuninit","to_maybeuninit","to_maybeuninit","to_maybeuninit","to_maybeuninit","to_maybeuninit","to_maybeuninit","to_maybeuninit","to_maybeuninit","to_maybeuninit_drop","to_maybeuninit_drop","to_maybeuninit_drop","to_maybeuninit_drop","to_maybeuninit_drop","to_maybeuninit_drop","to_maybeuninit_drop","to_maybeuninit_drop","to_maybeuninit_drop","to_maybeuninit_drop","to_maybeuninit_drop","to_maybeuninit_drop","to_maybeuninit_drop","to_maybeuninit_drop","to_maybeuninit_drop","to_maybeuninit_drop","to_maybeuninit_drop","to_maybeuninit_drop","to_maybeuninit_drop","to_maybeuninit_drop","to_maybeuninit_drop","to_maybeuninit_drop","to_maybeuninit_drop","to_maybeuninit_mut","to_maybeuninit_mut","to_maybeuninit_mut","to_maybeuninit_mut","to_maybeuninit_mut","to_maybeuninit_mut","to_maybeuninit_mut","to_maybeuninit_mut","to_maybeuninit_mut","to_maybeuninit_mut","to_maybeuninit_mut","to_maybeuninit_mut","to_maybeuninit_mut","to_maybeuninit_mut","to_maybeuninit_mut","to_maybeuninit_mut","to_maybeuninit_mut","to_maybeuninit_mut","to_maybeuninit_mut","to_maybeuninit_mut","to_maybeuninit_mut","to_maybeuninit_mut","to_maybeuninit_mut","to_owned","traits","truncate","truncate","truncate_unchecked","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_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","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","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","vzip","vzip","vzip","vzip","vzip","vzip","vzip","vzip","vzip","vzip","vzip","windows","with_capacity","with_capacity","with_capacity","with_capacity","with_capacity","with_capacity","with_output_capacity","with_peek","with_peek_mut","write_bits_u128_unchecked","write_bits_u16_unchecked","write_bits_u32_unchecked","write_bits_u64_unchecked","write_bits_u8_unchecked","ClockTimer","Tick","borrow","borrow","borrow_mut","borrow_mut","builder","builder","chrono","delayed","elapsed","end_time","from","from","into","into","past_due","remaining","run_to_end","start_time","tick","time","to_maybeuninit","to_maybeuninit","to_maybeuninit_drop","to_maybeuninit_drop","to_maybeuninit_mut","to_maybeuninit_mut","total_runtime","try_from","try_from","try_into","try_into","type_id","type_id","vzip","vzip","Builder","BuilderWithEnd","BuilderWithInterval","BuilderWithStart","borrow","borrow","borrow","borrow","borrow_mut","borrow_mut","borrow_mut","borrow_mut","build","from","from","from","from","into","into","into","into","new","to_maybeuninit","to_maybeuninit","to_maybeuninit","to_maybeuninit","to_maybeuninit_drop","to_maybeuninit_drop","to_maybeuninit_drop","to_maybeuninit_drop","to_maybeuninit_mut","to_maybeuninit_mut","to_maybeuninit_mut","to_maybeuninit_mut","try_from","try_from","try_from","try_from","try_into","try_into","try_into","try_into","type_id","type_id","type_id","type_id","vzip","vzip","vzip","vzip","with_duration","with_end_datetime","with_interval","with_start_datetime","debounce","debounce_immediate","debounce_immediate_with_rt","debounce_with_rt","h","DecodeError","InvalidChar","InvalidLength","TABLE_ENCODER_LEN","TABLE_ENCODER_LOWER","TABLE_ENCODER_UPPER","borrow","borrow_mut","decode_hex","encode_hex","encode_hex_upper","fmt","fmt","from","into","to_maybeuninit","to_maybeuninit_drop","to_maybeuninit_mut","to_string","try_from","try_into","type_id","vzip","GeneratedID","IDGenerator","as_signed","as_unsigned","as_unsigned_nonzero","borrow","borrow","borrow_mut","borrow_mut","from","from","from_signed","from_signed_unchecked","from_unsigned","from_unsigned_unchecked","into","into","new","next","to_maybeuninit","to_maybeuninit","to_maybeuninit_drop","to_maybeuninit_drop","to_maybeuninit_mut","to_maybeuninit_mut","try_from","try_from","try_into","try_into","type_id","type_id","unix_time","vzip","vzip","AsStdIterator","AsWiwiIter","DoubleEndedIter","Empty","Estimate","FromFn","HardBound","IntoIter","IntoStdIterator","IntoWiwiIter","Item","Item","Iter","Iter","Iter","Iter","IterAdapter","Iterator","Iterator","Map","Peek","PeekItem","Peekable","RepeatPerItem","Rev","SizeHint","SizeHintBound","Tuple1","Tuple10","Tuple11","Tuple12","Tuple13","Tuple14","Tuple15","Tuple16","Tuple17","Tuple18","Tuple19","Tuple2","Tuple20","Tuple21","Tuple22","Tuple23","Tuple24","Tuple25","Tuple26","Tuple27","Tuple28","Tuple29","Tuple3","Tuple30","Tuple31","Tuple32","Tuple4","Tuple5","Tuple6","Tuple7","Tuple8","Tuple9","Unknown","batch_invert","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","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","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","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_std_as_wiwi_iter","borrow_std_as_wiwi_iter","borrow_wiwi_as_std_iterator","borrow_wiwi_as_std_iterator","borrow_wiwi_as_std_iterator","borrow_wiwi_as_std_iterator","borrow_wiwi_as_std_iterator","borrow_wiwi_as_std_iterator","borrow_wiwi_as_std_iterator","borrow_wiwi_as_std_iterator","borrow_wiwi_as_std_iterator","borrow_wiwi_as_std_iterator","borrow_wiwi_as_std_iterator","borrow_wiwi_as_std_iterator","borrow_wiwi_as_std_iterator","borrow_wiwi_as_std_iterator","borrow_wiwi_as_std_iterator","borrow_wiwi_as_std_iterator","borrow_wiwi_as_std_iterator","borrow_wiwi_as_std_iterator","borrow_wiwi_as_std_iterator","borrow_wiwi_as_std_iterator","borrow_wiwi_as_std_iterator","borrow_wiwi_as_std_iterator","borrow_wiwi_as_std_iterator","borrow_wiwi_as_std_iterator","borrow_wiwi_as_std_iterator","borrow_wiwi_as_std_iterator","borrow_wiwi_as_std_iterator","borrow_wiwi_as_std_iterator","borrow_wiwi_as_std_iterator","borrow_wiwi_as_std_iterator","borrow_wiwi_as_std_iterator","borrow_wiwi_as_std_iterator","borrow_wiwi_as_std_iterator","borrow_wiwi_as_std_iterator","borrow_wiwi_as_std_iterator","borrow_wiwi_as_std_iterator","borrow_wiwi_as_std_iterator","borrow_wiwi_as_std_iterator","borrow_wiwi_as_std_iterator","borrow_wiwi_as_std_iterator","convert_std_into_wiwi_iter","convert_std_into_wiwi_iter","convert_wiwi_into_std_iterator","convert_wiwi_into_std_iterator","convert_wiwi_into_std_iterator","convert_wiwi_into_std_iterator","convert_wiwi_into_std_iterator","convert_wiwi_into_std_iterator","convert_wiwi_into_std_iterator","convert_wiwi_into_std_iterator","convert_wiwi_into_std_iterator","convert_wiwi_into_std_iterator","convert_wiwi_into_std_iterator","convert_wiwi_into_std_iterator","convert_wiwi_into_std_iterator","convert_wiwi_into_std_iterator","convert_wiwi_into_std_iterator","convert_wiwi_into_std_iterator","convert_wiwi_into_std_iterator","convert_wiwi_into_std_iterator","convert_wiwi_into_std_iterator","convert_wiwi_into_std_iterator","convert_wiwi_into_std_iterator","convert_wiwi_into_std_iterator","convert_wiwi_into_std_iterator","convert_wiwi_into_std_iterator","convert_wiwi_into_std_iterator","convert_wiwi_into_std_iterator","convert_wiwi_into_std_iterator","convert_wiwi_into_std_iterator","convert_wiwi_into_std_iterator","convert_wiwi_into_std_iterator","convert_wiwi_into_std_iterator","convert_wiwi_into_std_iterator","convert_wiwi_into_std_iterator","convert_wiwi_into_std_iterator","convert_wiwi_into_std_iterator","convert_wiwi_into_std_iterator","convert_wiwi_into_std_iterator","convert_wiwi_into_std_iterator","convert_wiwi_into_std_iterator","convert_wiwi_into_std_iterator","count","default","empty","estimate","fmt","fmt","for_each","for_each_back","for_each_back","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","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from_fn","hard_bound","into","into","into","into","into","into","into","into","into","into","into","into","into","into","into","into","into","into","into","into","into","into","into","into","into","into","into","into","into","into","into","into","into","into","into","into","into","into","into","into","into","into_inner","into_inner","into_inner","into_inner","into_iter","into_std_hint","into_wiwi_iter","into_wiwi_iter","into_wiwi_iter","into_wiwi_iter","into_wiwi_iter","into_wiwi_iter","into_wiwi_iter","into_wiwi_iter","into_wiwi_iter","into_wiwi_iter","into_wiwi_iter","into_wiwi_iter","into_wiwi_iter","into_wiwi_iter","into_wiwi_iter","into_wiwi_iter","into_wiwi_iter","into_wiwi_iter","into_wiwi_iter","into_wiwi_iter","into_wiwi_iter","into_wiwi_iter","into_wiwi_iter","into_wiwi_iter","into_wiwi_iter","into_wiwi_iter","into_wiwi_iter","into_wiwi_iter","into_wiwi_iter","into_wiwi_iter","into_wiwi_iter","into_wiwi_iter","into_wiwi_iter","into_wiwi_iter","into_wiwi_iter","into_wiwi_iter","into_wiwi_iter","into_wiwi_iter","into_wiwi_iter","into_wiwi_iter","map","new","next","next","next","next","next","next","next","next","next","next","next","next","next","next","next","next","next","next","next","next","next","next","next","next","next","next","next","next","next","next","next","next","next","next","next","next","next","next","next","next","next","next_back","next_back","next_back","next_back","peek","peek","peekable","repeat_per_item","rev","rev","size_hint","size_hint","size_hint","size_hint","size_hint","size_hint","size_hint","size_hint","size_hint","size_hint","size_hint","size_hint","size_hint","size_hint","size_hint","size_hint","size_hint","size_hint","size_hint","size_hint","size_hint","size_hint","size_hint","size_hint","size_hint","size_hint","size_hint","size_hint","size_hint","size_hint","size_hint","size_hint","size_hint","size_hint","size_hint","size_hint","size_hint","size_hint","size_hint","size_hint","split","to_maybeuninit","to_maybeuninit","to_maybeuninit","to_maybeuninit","to_maybeuninit","to_maybeuninit","to_maybeuninit","to_maybeuninit","to_maybeuninit","to_maybeuninit","to_maybeuninit","to_maybeuninit","to_maybeuninit","to_maybeuninit","to_maybeuninit","to_maybeuninit","to_maybeuninit","to_maybeuninit","to_maybeuninit","to_maybeuninit","to_maybeuninit","to_maybeuninit","to_maybeuninit","to_maybeuninit","to_maybeuninit","to_maybeuninit","to_maybeuninit","to_maybeuninit","to_maybeuninit","to_maybeuninit","to_maybeuninit","to_maybeuninit","to_maybeuninit","to_maybeuninit","to_maybeuninit","to_maybeuninit","to_maybeuninit","to_maybeuninit","to_maybeuninit","to_maybeuninit","to_maybeuninit","to_maybeuninit_drop","to_maybeuninit_drop","to_maybeuninit_drop","to_maybeuninit_drop","to_maybeuninit_drop","to_maybeuninit_drop","to_maybeuninit_drop","to_maybeuninit_drop","to_maybeuninit_drop","to_maybeuninit_drop","to_maybeuninit_drop","to_maybeuninit_drop","to_maybeuninit_drop","to_maybeuninit_drop","to_maybeuninit_drop","to_maybeuninit_drop","to_maybeuninit_drop","to_maybeuninit_drop","to_maybeuninit_drop","to_maybeuninit_drop","to_maybeuninit_drop","to_maybeuninit_drop","to_maybeuninit_drop","to_maybeuninit_drop","to_maybeuninit_drop","to_maybeuninit_drop","to_maybeuninit_drop","to_maybeuninit_drop","to_maybeuninit_drop","to_maybeuninit_drop","to_maybeuninit_drop","to_maybeuninit_drop","to_maybeuninit_drop","to_maybeuninit_drop","to_maybeuninit_drop","to_maybeuninit_drop","to_maybeuninit_drop","to_maybeuninit_drop","to_maybeuninit_drop","to_maybeuninit_drop","to_maybeuninit_drop","to_maybeuninit_mut","to_maybeuninit_mut","to_maybeuninit_mut","to_maybeuninit_mut","to_maybeuninit_mut","to_maybeuninit_mut","to_maybeuninit_mut","to_maybeuninit_mut","to_maybeuninit_mut","to_maybeuninit_mut","to_maybeuninit_mut","to_maybeuninit_mut","to_maybeuninit_mut","to_maybeuninit_mut","to_maybeuninit_mut","to_maybeuninit_mut","to_maybeuninit_mut","to_maybeuninit_mut","to_maybeuninit_mut","to_maybeuninit_mut","to_maybeuninit_mut","to_maybeuninit_mut","to_maybeuninit_mut","to_maybeuninit_mut","to_maybeuninit_mut","to_maybeuninit_mut","to_maybeuninit_mut","to_maybeuninit_mut","to_maybeuninit_mut","to_maybeuninit_mut","to_maybeuninit_mut","to_maybeuninit_mut","to_maybeuninit_mut","to_maybeuninit_mut","to_maybeuninit_mut","to_maybeuninit_mut","to_maybeuninit_mut","to_maybeuninit_mut","to_maybeuninit_mut","to_maybeuninit_mut","to_maybeuninit_mut","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_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_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","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","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","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","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","unknown","vzip","vzip","vzip","vzip","vzip","vzip","vzip","vzip","vzip","vzip","vzip","vzip","vzip","vzip","vzip","vzip","vzip","vzip","vzip","vzip","vzip","vzip","vzip","vzip","vzip","vzip","vzip","vzip","vzip","vzip","vzip","vzip","vzip","vzip","vzip","vzip","vzip","vzip","vzip","vzip","vzip","with_lower_estimate","with_lower_hard_bound","with_lower_unknown","with_upper_estimate","with_upper_hard_bound","with_upper_unknown","bound","estimate","Initialised","LazyWrap","LazyWrapState","Uninitialised","as_mut","as_ref","borrow","borrow","borrow_mut","borrow_mut","deref","deref_mut","drop","ensure_initialised","fmt","fmt","from","from","into","into","into_inner","into_inner_initialised","is_initialised","new","to_maybeuninit","to_maybeuninit","to_maybeuninit_drop","to_maybeuninit_drop","to_maybeuninit_mut","to_maybeuninit_mut","to_string","try_from","try_from","try_into","try_into","type_id","type_id","vzip","vzip","callback_api","Script","ScriptBuilder","borrow","borrow","borrow_mut","borrow_mut","from","from","into","into","script","to_maybeuninit","to_maybeuninit","to_maybeuninit_drop","to_maybeuninit_drop","to_maybeuninit_mut","to_maybeuninit_mut","try_from","try_from","try_into","try_into","type_id","type_id","vzip","vzip","Dynamic","MEMORY_USAGE","MemoryUsage","Static","calculate_memory_usage","calculate_values_usage","dynamic_mem_usage_of_val","dynamic_values_usage_of_val","static_mem_usage_of","static_mem_usage_of_val","SEP","basename","ClockTimer","DateTime","GeneratedID","IDGenerator","LazyWrap","LazyWrapState","Local","MAX_UTC","MIN_UTC","String","Tick","TimeDelta","UNIX_EPOCH","abs","add","add","add","add","add","add","add_assign","add_assign","add_assign","borrow","borrow","borrow","borrow_mut","borrow_mut","borrow_mut","checked_add","checked_add_days","checked_add_months","checked_add_signed","checked_sub","checked_sub_days","checked_sub_months","checked_sub_signed","clone","clone","clone","clone_into","clone_into","clone_into","cmp","cmp","date","date_naive","day","day0","days","debounce","debounce_immediate","debounce_immediate_with_rt","debounce_with_rt","decode_hex","decode_z85","default","default","default","default","div","duration_round","duration_trunc","encode_hex","encode_hex_upper","encode_z85","eq","eq","equivalent","equivalent","equivalent","equivalent","fixed_offset","fmt","fmt","fmt","fmt","fmt","format","format_with_items","from","from","from","from","from","from","from","from","from","from","from","from_local","from_naive_utc_and_offset","from_offset","from_std","from_str","from_str","from_str","from_timestamp","from_timestamp_micros","from_timestamp_millis","from_timestamp_nanos","from_utc","h","hash","hash","hour","hours","into","into","into","is_zero","iso_week","max_value","microseconds","milliseconds","min_value","minute","minutes","month","month0","mul","naive_local","naive_utc","nanosecond","nanoseconds","neg","new","now","num_days","num_hours","num_microseconds","num_milliseconds","num_minutes","num_nanoseconds","num_seconds","num_weeks","offset","offset_from_local_date","offset_from_local_datetime","offset_from_utc_date","offset_from_utc_datetime","ordinal","ordinal0","parse_and_remainder","parse_from_rfc2822","parse_from_rfc3339","parse_from_str","partial_cmp","partial_cmp","round_subsecs","second","seconds","signed_duration_since","sub","sub","sub","sub","sub","sub","sub","sub","sub_assign","sub_assign","sub_assign","subsec_nanos","sum","sum","time","timestamp","timestamp_micros","timestamp_millis","timestamp_nanos","timestamp_nanos_opt","timestamp_subsec_micros","timestamp_subsec_millis","timestamp_subsec_nanos","timezone","to_maybeuninit","to_maybeuninit","to_maybeuninit","to_maybeuninit_drop","to_maybeuninit_drop","to_maybeuninit_drop","to_maybeuninit_mut","to_maybeuninit_mut","to_maybeuninit_mut","to_owned","to_owned","to_owned","to_rfc2822","to_rfc3339","to_rfc3339_opts","to_std","to_string","to_string","to_utc","today","trunc_subsecs","try_days","try_from","try_from","try_from","try_hours","try_into","try_into","try_into","try_milliseconds","try_minutes","try_seconds","try_weeks","type_id","type_id","type_id","vzip","vzip","vzip","weekday","weeks","with_day","with_day0","with_hour","with_minute","with_month","with_month0","with_nanosecond","with_ordinal","with_ordinal0","with_second","with_timezone","with_year","year","years_since","zero","buffer","deserialise","error","marker","number","serialise","BufferRead","BufferWrite","read_byte","read_bytes","read_bytes_const","read_bytes_ptr","read_bytes_ptr_const","reserve","with_ptr","write_byte","write_bytes","write_bytes_unchecked","Deserialise","deserialise","deserialise","deserialise_lax","Error","OptionExt","Result","ResultExt","Str","String","borrow","borrow_mut","clone","clone_into","convert_err","convert_err","deref","eq","equivalent","equivalent","err_eof","err_eof","err_f","err_str","err_str","err_string","err_string","error_eof","error_str","error_string","fmt","fmt","from","into","to_maybeuninit","to_maybeuninit_drop","to_maybeuninit_mut","to_owned","to_string","try_from","try_into","type_id","vzip","msg","msg","Marker","borrow","borrow_mut","from","into","read_from","to_maybeuninit","to_maybeuninit_drop","to_maybeuninit_mut","try_from","try_into","type_id","vzip","int_range","smallint_negative_as_unsigned_range","smallint_negative_range","smallint_positive_range","smallint_signed_range","smallint_unsigned_range","Serialise","SerialiseOptions","borrow","borrow_mut","capacity","clone","clone_into","default","fmt","from","into","serialise","serialise","serialise_with_options","to_maybeuninit","to_maybeuninit_drop","to_maybeuninit_mut","to_owned","try_from","try_into","type_id","vzip","GlobalPool","Pool","Raw","String","add","add","add","add","add","add","add","add","add","add","add_assign","add_assign","add_assign","as_ref","as_ref","as_ref","as_ref","borrow","borrow","borrow_mut","clone","clone_into","default","deref","fmt","fmt","from","from","from","into","pool","raw_clone","raw_empty","raw_from_slice","raw_from_slices","raw_from_vec","raw_into_boxed_slice","raw_into_vec","raw_to_slice","string","to_maybeuninit","to_maybeuninit_drop","to_maybeuninit_mut","to_owned","to_string","try_from","try_into","type_id","vzip","GlobalPool","Pool","Raw","SlicesWrap","SlicesWrapIter","borrow","borrow","borrow","borrow_mut","borrow_mut","borrow_mut","borrow_std_as_wiwi_iter","clone","clone_into","convert_std_into_wiwi_iter","default","equivalent","fmt","fmt","from","from","from","hash","into","into","into","into_iter","into_iter","next","raw_clone","raw_clone","raw_empty","raw_from_slice","raw_from_slices","raw_from_slices","raw_from_vec","raw_into_boxed_slice","raw_into_vec","raw_to_slice","raw_to_slice","size_hint","to_boxed_slice","to_maybeuninit","to_maybeuninit","to_maybeuninit","to_maybeuninit_drop","to_maybeuninit_drop","to_maybeuninit_drop","to_maybeuninit_mut","to_maybeuninit_mut","to_maybeuninit_mut","to_owned","to_vec","try_from","try_from","try_from","try_into","try_into","try_into","type_id","type_id","type_id","vzip","vzip","vzip","String","as_bytes","as_str","clear","clone_to","from_str_in","from_utf16","from_utf16_in","from_utf16_lossy","from_utf16_lossy_in","from_utf8","from_utf8_in","from_utf8_lossy","from_utf8_lossy_in","from_utf8_slice","from_utf8_slice_in","from_utf8_unchecked","from_utf8_unchecked_in","from_utf8_unchecked_slice","from_utf8_unchecked_slice_in","insert","insert_str","into_boxed_str","into_bytes","into_other_pool","leak","new","new_in","pop","push","push_str","remove","retain","split_off","split_off_in","to_other_pool","truncate","Board","borrow","borrow_mut","from","into","new","to_maybeuninit","to_maybeuninit_drop","to_maybeuninit_mut","try_from","try_into","type_id","vzip","ToMaybeUninit","to_maybeuninit","to_maybeuninit_drop","to_maybeuninit_mut","BINARY_FRAME_LEN","DecodeError","FrameOverflow","InvalidChar","InvalidLength","STRING_FRAME_LEN","TABLE_DECODER","TABLE_DECODER_LEN","TABLE_ENCODER","TABLE_ENCODER_LEN","borrow","borrow_mut","decode_z85","encode_z85","eq","fmt","fmt","from","into","to_maybeuninit","to_maybeuninit_drop","to_maybeuninit_mut","to_string","try_from","try_into","type_id","vzip"],"q":[[0,"wiwi"],[26,"wiwi::auth"],[28,"wiwi::auth::error"],[46,"wiwi::auth::flow"],[48,"wiwi::auth::flow::signin"],[205,"wiwi::auth::flow::signup"],[247,"wiwi::bigint"],[276,"wiwi::bitstream"],[297,"wiwi::chainer"],[883,"wiwi::clock_timer"],[920,"wiwi::clock_timer::builder"],[974,"wiwi::debounce"],[978,"wiwi::h"],[979,"wiwi::hex"],[1002,"wiwi::id"],[1036,"wiwi::iter"],[1790,"wiwi::iter::SizeHintBound"],[1792,"wiwi::lazy_wrap"],[1831,"wiwi::lsl"],[1832,"wiwi::lsl::callback_api"],[1857,"wiwi::memory_usage"],[1867,"wiwi::path"],[1869,"wiwi::prelude"],[2103,"wiwi::serialiser"],[2109,"wiwi::serialiser::buffer"],[2121,"wiwi::serialiser::deserialise"],[2125,"wiwi::serialiser::error"],[2164,"wiwi::serialiser::error::Error"],[2166,"wiwi::serialiser::marker"],[2179,"wiwi::serialiser::number"],[2185,"wiwi::serialiser::serialise"],[2207,"wiwi::string_pool"],[2260,"wiwi::string_pool::pool"],[2325,"wiwi::string_pool::string"],[2362,"wiwi::sudoku"],[2375,"wiwi::to_maybeuninit"],[2379,"wiwi::z85"],[2406,"core::fmt"],[2407,"core::convert"],[2408,"core::error"],[2409,"core::option"],[2410,"core::mem::maybe_uninit"],[2411,"alloc::string"],[2412,"core::result"],[2413,"core::any"],[2414,"alloc::vec"],[2415,"wiwi::chainer::binary_heap"],[2416,"alloc::collections::binary_heap"],[2417,"core::cmp"],[2418,"wiwi::chainer::vec"],[2419,"core::ops::function"],[2420,"wiwi::chainer::slice_box"],[2421,"wiwi::chainer::array"],[2422,"wiwi::chainer::string"],[2423,"core::clone"],[2424,"core::marker"],[2425,"core::ops::range"],[2426,"core::default"],[2427,"alloc::vec::drain"],[2428,"wiwi::chainer::slice_ref"],[2429,"wiwi::chainer::slice_mut"],[2430,"wiwi::chainer::vec_ref"],[2431,"wiwi::chainer::vec_mut"],[2432,"alloc::boxed"],[2433,"wiwi::chainer::array_ref"],[2434,"wiwi::chainer::array_mut"],[2435,"wiwi::chainer::string_ref"],[2436,"wiwi::chainer::string_mut"],[2437,"wiwi::chainer::str_box"],[2438,"wiwi::chainer::str_ref"],[2439,"wiwi::chainer::str_mut"],[2440,"alloc::collections::vec_deque"],[2441,"wiwi::chainer::vec_deque"],[2442,"alloc::collections::linked_list"],[2443,"wiwi::chainer::linked_list"],[2444,"std::collections::hash::map"],[2445,"wiwi::chainer::hash_map"],[2446,"std::collections::hash::set"],[2447,"wiwi::chainer::hash_set"],[2448,"alloc::collections::btree::map"],[2449,"wiwi::chainer::btree_map"],[2450,"alloc::collections::btree::set"],[2451,"wiwi::chainer::btree_set"],[2452,"wiwi::chainer::bitstream"],[2453,"core::slice::index"],[2454,"wiwi::chainer::into_chainer"],[2455,"wiwi::iter::into_iter"],[2456,"wiwi::iter::adapter"],[2457,"alloc::vec::splice"],[2458,"core::slice::iter"],[2459,"chrono::time_delta"],[2460,"chrono::offset::local"],[2461,"chrono::datetime"],[2462,"core::future::future"],[2463,"chrono::offset"],[2464,"tokio::runtime::handle"],[2465,"core::num::nonzero"],[2466,"core::iter::traits::iterator"],[2467,"wiwi::iter::size_hint"],[2468,"wiwi::iter::empty"],[2469,"wiwi::iter::double_ended"],[2470,"wiwi::iter::from_fn"],[2471,"wiwi::iter::map"],[2472,"wiwi::iter::peek"],[2473,"wiwi::iter::repeat_per_item"],[2474,"wiwi::iter::rev"],[2475,"wiwi::iter::tuple"],[2476,"core::iter::traits::double_ended"],[2477,"wiwi::lsl::callback_api::script"],[2478,"core::time"],[2479,"chrono::offset::fixed"],[2480,"chrono::month"],[2481,"chrono::naive"],[2482,"chrono::date"],[2483,"chrono::naive::date"],[2484,"chrono::offset::utc"],[2485,"chrono::format::strftime"],[2486,"chrono::format::formatting"],[2487,"chrono::format"],[2488,"core::borrow"],[2489,"std::time"],[2490,"chrono::naive::datetime"],[2491,"core::hash"],[2492,"chrono::naive::isoweek"],[2493,"chrono::naive::time"],[2494,"chrono::weekday"],[2495,"std::path"],[2496,"std::ffi::os_str"],[2497,"wiwi::string_pool::pool::global"],[2498,"core::str::error"],[2499,"wiwiwiwiwi"]],"i":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,0,0,0,0,0,0,0,0,0,0,0,0,0,17,22,13,16,21,24,25,26,20,23,14,17,22,13,16,21,24,25,26,20,23,14,24,25,23,25,23,17,22,13,16,21,24,25,26,20,23,14,25,25,17,22,13,16,21,24,25,26,20,23,14,0,0,0,0,0,0,20,21,20,14,24,21,24,20,26,23,17,22,13,16,21,24,25,26,20,23,14,17,22,13,16,21,24,25,26,20,23,14,17,22,13,16,21,24,25,26,20,23,14,17,22,13,16,21,24,25,26,20,23,14,17,22,13,16,21,24,25,26,20,23,14,17,22,13,16,21,24,25,26,20,23,14,16,26,17,22,13,16,21,24,25,26,20,23,14,0,0,27,28,27,28,27,28,27,28,27,28,28,28,27,28,0,0,27,28,27,27,28,27,28,27,28,27,28,27,28,27,28,27,28,27,28,27,28,28,27,28,29,29,29,0,0,0,29,30,30,30,30,30,30,32,29,30,30,30,29,30,32,30,30,30,30,30,30,30,30,0,35,35,35,35,35,35,35,35,35,35,35,35,35,35,35,35,35,35,35,35,0,0,0,0,0,0,0,92,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,42,45,45,45,45,45,45,45,45,45,45,45,45,48,49,45,45,45,45,45,45,64,65,48,61,62,49,67,68,53,69,70,72,73,74,76,78,80,82,84,86,42,87,45,64,65,48,61,62,49,67,68,53,69,70,72,73,74,76,78,80,82,84,86,42,87,45,53,42,45,53,42,45,53,45,45,45,45,45,45,45,45,45,45,45,45,45,45,45,45,45,45,53,45,45,45,61,62,49,45,45,45,62,49,45,61,62,45,45,64,64,65,65,48,48,61,61,62,62,49,49,67,67,68,68,53,53,69,69,70,70,72,72,73,73,74,74,76,76,78,78,80,80,82,82,84,84,86,86,42,42,87,87,45,45,53,45,53,53,53,53,45,45,45,45,53,45,53,64,65,48,61,62,49,67,68,53,69,70,72,73,74,76,78,80,82,84,86,42,87,45,42,53,87,53,87,92,92,48,61,62,49,67,68,76,53,42,42,61,62,45,45,61,62,49,53,45,61,62,49,53,45,61,62,45,45,45,62,45,45,61,62,49,53,45,61,62,49,53,45,45,45,53,76,78,80,82,42,87,45,48,49,48,49,49,67,68,49,49,68,49,68,45,45,53,76,45,48,45,48,45,45,45,45,48,61,62,49,67,68,45,48,49,68,45,48,62,49,67,68,45,76,76,48,62,49,68,45,76,76,53,53,45,76,76,53,45,53,42,45,53,42,45,53,42,45,53,53,45,53,45,45,53,42,45,53,42,45,45,45,53,42,45,45,45,45,53,45,53,45,62,45,45,62,45,62,45,62,45,45,45,62,45,62,45,62,45,45,45,53,45,45,45,45,45,45,45,45,45,53,53,53,53,45,45,45,45,45,45,45,64,65,48,61,62,49,67,68,53,69,70,72,73,74,76,78,80,82,84,86,42,87,45,64,65,48,61,62,49,67,68,53,69,70,72,73,74,76,78,80,82,84,86,42,87,45,64,65,48,61,62,49,67,68,53,69,70,72,73,74,76,78,80,82,84,86,42,87,45,45,0,53,45,53,64,65,48,61,62,49,67,68,53,69,70,72,73,74,76,78,80,82,84,86,42,87,45,64,65,48,61,62,49,67,68,53,69,70,72,73,74,76,78,80,82,84,86,42,87,45,64,65,48,61,62,49,67,68,53,69,70,72,73,74,76,78,80,82,84,86,42,87,45,64,65,48,61,62,49,67,68,53,69,70,72,73,74,76,78,80,82,84,86,42,87,45,45,53,76,80,82,42,45,87,42,42,87,87,87,87,87,0,0,108,104,108,104,0,108,0,104,104,104,108,104,108,104,104,104,108,104,108,104,108,104,108,104,108,104,104,108,104,108,104,108,104,108,104,0,0,0,0,103,111,112,110,103,111,112,110,110,103,111,112,110,103,111,112,110,103,103,111,112,110,103,111,112,110,103,111,112,110,103,111,112,110,103,111,112,110,103,111,112,110,103,111,112,110,111,111,112,103,0,0,0,0,0,0,118,118,0,0,0,118,118,0,0,0,118,118,118,118,118,118,118,118,118,118,118,118,0,0,119,119,119,122,119,122,119,122,119,119,119,119,119,122,119,122,122,122,119,122,119,122,119,122,119,122,119,122,119,119,122,119,0,0,0,0,133,0,133,0,0,0,98,125,0,124,129,98,0,127,130,0,0,174,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,133,99,99,132,135,136,137,138,139,131,133,140,141,142,143,144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159,160,161,162,163,164,165,166,167,168,169,170,171,99,132,135,136,137,138,139,131,133,140,141,142,143,144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159,160,161,162,163,164,165,166,167,168,169,170,171,124,99,127,99,132,135,136,137,138,139,140,141,142,143,144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159,160,161,162,163,164,165,166,167,168,169,170,171,129,99,130,99,132,135,136,137,138,139,140,141,142,143,144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159,160,161,162,163,164,165,166,167,168,169,170,171,125,131,0,131,131,133,125,134,134,99,132,135,136,137,138,139,131,133,140,141,142,143,144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159,160,161,162,163,164,165,166,167,168,169,170,171,0,131,99,132,135,136,137,138,139,131,133,140,141,142,143,144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159,160,161,162,163,164,165,166,167,168,169,170,171,136,137,138,139,99,131,98,99,132,135,136,137,138,139,140,141,142,143,144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159,160,161,162,163,164,165,166,167,168,169,170,171,125,131,125,99,99,132,135,136,137,138,139,140,141,142,143,144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159,160,161,162,163,164,165,166,167,168,169,170,171,134,99,99,139,174,137,125,125,134,134,99,99,132,136,137,138,139,125,140,141,142,143,144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159,160,161,162,163,164,165,166,167,168,169,170,171,131,99,132,135,136,137,138,139,131,133,140,141,142,143,144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159,160,161,162,163,164,165,166,167,168,169,170,171,99,132,135,136,137,138,139,131,133,140,141,142,143,144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159,160,161,162,163,164,165,166,167,168,169,170,171,99,132,135,136,137,138,139,131,133,140,141,142,143,144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159,160,161,162,163,164,165,166,167,168,169,170,171,99,132,135,136,137,138,139,131,133,140,141,142,143,144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159,160,161,162,163,164,165,166,167,168,169,170,171,99,132,135,136,137,138,139,131,133,140,141,142,143,144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159,160,161,162,163,164,165,166,167,168,169,170,171,99,132,135,136,137,138,139,131,133,140,141,142,143,144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159,160,161,162,163,164,165,166,167,168,169,170,171,131,99,132,135,136,137,138,139,131,133,140,141,142,143,144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159,160,161,162,163,164,165,166,167,168,169,170,171,131,131,131,131,131,131,232,233,180,0,0,180,175,175,175,180,175,180,175,175,175,175,175,175,175,180,175,180,175,175,175,175,175,180,175,180,175,180,175,175,180,175,180,175,180,175,180,0,0,0,182,181,182,181,182,181,182,181,0,182,181,182,181,182,181,182,181,182,181,182,181,182,181,0,184,0,0,183,183,0,0,0,0,0,0,0,0,0,0,0,0,0,107,107,0,0,0,107,105,105,107,107,107,107,107,105,107,107,105,107,106,105,107,106,105,107,107,107,105,107,107,107,105,107,106,105,107,106,105,107,107,107,107,107,105,0,0,0,0,0,0,105,107,107,107,105,107,107,0,0,0,105,107,105,105,107,107,107,105,105,107,107,106,107,107,105,107,107,107,107,107,107,107,107,107,106,107,107,106,105,107,107,107,107,107,107,107,107,0,105,107,107,105,105,107,106,105,107,105,105,105,105,107,105,107,107,105,107,107,107,105,105,105,106,105,105,105,105,105,105,105,105,107,106,106,106,106,107,107,107,107,107,107,105,107,107,107,105,107,105,107,107,107,107,107,107,107,105,107,107,105,105,105,107,107,107,107,107,107,107,107,107,107,105,107,106,105,107,106,105,107,106,105,107,106,107,107,107,105,105,107,107,106,107,105,105,107,106,105,105,107,106,105,105,105,105,105,107,106,105,107,106,107,105,107,107,107,107,107,107,107,107,107,107,107,107,107,107,105,0,0,0,0,0,0,0,0,208,208,208,208,208,210,210,210,210,210,0,0,211,0,0,0,0,0,212,212,212,212,212,212,213,209,212,212,212,212,0,215,215,0,215,0,215,0,0,0,212,212,212,212,212,212,212,212,212,212,212,212,212,234,235,0,216,216,216,216,216,216,216,216,216,216,216,216,0,0,0,0,0,0,0,0,217,217,217,217,217,217,217,217,217,0,218,0,217,217,217,217,217,217,217,217,0,0,220,0,219,219,219,219,219,219,219,219,219,219,219,219,219,219,219,219,219,219,219,219,219,219,219,219,219,219,219,219,219,219,0,220,220,220,220,220,220,220,220,0,219,219,219,219,219,219,219,219,219,0,0,220,0,0,226,225,224,226,225,224,226,225,225,226,225,224,225,224,226,225,224,224,226,225,224,226,224,226,220,225,220,220,220,225,220,220,220,220,225,226,224,226,225,224,226,225,224,226,225,224,225,224,226,225,224,226,225,224,226,225,224,226,225,224,0,219,219,219,219,219,219,219,219,219,219,219,219,219,219,219,219,219,219,219,219,219,219,219,219,219,219,219,219,219,219,219,219,219,219,219,219,0,229,229,229,229,229,229,229,229,229,229,229,229,0,230,230,230,0,0,231,231,231,0,0,0,0,0,231,231,0,0,231,231,231,231,231,231,231,231,231,231,231,231,231],"f":"``````````````````````````````{{{b{c}}}{{b{e}}}{}{}}{{{b{dc}}}{{b{de}}}{}{}}{{{b{f}}{b{dh}}}j}0{cc{}}{cf{{l{`}}}}{ce{}{}}{{{b{f}}}{{A`{{b{n}}}}}}{{{b{c}}}{{b{{Ab{e}}}}}{}{}}{{{b{dc}}}{{b{d{Ab{e}}}}}{}{}}0{{{b{c}}}Ad{}}{c{{Af{e}}}{}{}}0{{{b{c}}}Ah{}}6`````````````;;;;;;;;;;;:::::::::::`````88888888888``66666666666{{AjAl}An}`{{BbBh}{{Bf{{Bd{BjBl}}}}}}{{BlBn}{{Bf{{A`{{Bd{C`Aj}}}}}}}}{{BjCb}{{Bf{{A`{Bn}}}}}}{{C`Cd}{{Bf{{A`{Al}}}}}}``````````999999999998888888888888888888888666666666666666666666655555555555``;;;;;;;;;;;``{{{b{c}}}{{b{e}}}{}{}}0{{{b{dc}}}{{b{de}}}{}{}}0````??``==`{Cf{{Bf{Ch}}}}`````<<;;;;999988`````>>``````{{CjCj}Cj}32{{{b{Cl}}}Cl}{{{b{c}}{b{de}}}An{}{}}{{{b{Cl}}{b{dh}}}j}{cc{}}{CnD`}{{{Db{c}}}CjD`}{{{Db{Dd}}}Cl}`{ce{}{}}{Cj{{Db{c}}}D`}{Cl{{Db{Dd}}}}{{D`D`}{{Bd{D`Cn}}}}{{{b{c}}}{{b{{Ab{e}}}}}{}{}}{{{b{dc}}}{{b{d{Ab{e}}}}}{}{}}0{{{b{c}}}e{}{}}{c{{Af{e}}}{}{}}0{{{b{c}}}Ah{}}8`{{{b{c}}}{{b{e}}}{}{}}{{{b{dc}}}{{b{de}}}{}{}}>:{Df{{Dj{Dh}}}}{{}Df}877554<{DlDf}{{{b{dDf}}DlDn}An}{{{b{dDf}}DlE`}An}{{{b{dDf}}DlEb}An}{{{b{dDf}}DlDd}An}{{{b{dDf}}DlDh}An}{{{b{dDf}}DlDl}An}`````````````````````````{{{Ed{c}}{b{d{Ef{c}}}}}{{Ed{c}}}Eh}{{{Ej{c}}{b{d{Dj{c}}}}}{{Ej{c}}}{}}{{{Ej{c}}{b{d{Ej{c}}}}}{{Ej{c}}}{}}{{{Ej{c}}e}{{Ej{c}}}{}{{En{{b{{El{{Db{c}}}}}}{b{{El{c}}}}}}}}{{{Ej{c}}e}{{Ej{c}}}{}{{En{{b{d{El{{Db{c}}}}}}{b{d{El{c}}}}}}}}{{{Ej{c}}e}{{Ej{c}}}{}{{En{{b{{El{{Db{c}}}}}}}}}}{{{Ej{c}}e}{{Ej{c}}}{}{{En{{b{d{El{{Db{c}}}}}}}}}}{{{b{d{Ej{c}}}}}{{b{d{Dj{c}}}}}{}}{{{b{d{Ej{c}}}}}{{b{d{El{c}}}}}{}}{{{Ej{c}}e}{{Ej{c}}}{}{{En{{b{{El{c}}}}{b{{El{{Db{c}}}}}}}}}}{{{Ej{c}}e}{{Ej{c}}}{}{{En{{b{d{El{c}}}}{b{d{El{{Db{c}}}}}}}}}}{{{b{{Ej{c}}}}}{{b{{El{c}}}}}{}}{{{b{{Ej{c}}}}}{{b{{Dj{c}}}}}{}}{{{F`{{Ab{c}}}}}{{F`{c}}}{}}{{{Fb{{Ab{c}}}}}{{Fb{c}}}{}}{{{Ej{c}}{b{c}}{b{d{Af{DlDl}}}}}{{Ej{c}}}Eh}{{{Ej{c}}e{b{d{Af{DlDl}}}}}{{Ej{c}}}{}{{Fh{{b{c}}}{{Fd{Ff}}}}}}{{{Ej{c}}{b{e}}g{b{d{Af{DlDl}}}}}{{Ej{c}}}{}Eh{{Fh{{b{c}}}{{Fd{e}}}}}}{{{Ej{c}}{b{e}}g{b{d{Ab{{Af{DlDl}}}}}}}{{Ej{c}}}{}Eh{{Fh{{b{c}}}{{Fd{e}}}}}}{{{Ej{c}}e{b{d{Ab{{Af{DlDl}}}}}}}{{Ej{c}}}{}{{Fh{{b{c}}}{{Fd{Ff}}}}}}{{{Ej{c}}{b{c}}{b{d{Ab{{Af{DlDl}}}}}}}{{Ej{c}}}Eh}{{{b{c}}}{{b{e}}}{}{}}0000000000000000000000{{{b{dc}}}{{b{de}}}{}{}}0000000000000000000000{{Fj{b{dDl}}}Fj}{{{Ed{c}}{b{dDl}}}{{Ed{c}}}{}}{{{Ej{c}}{b{dDl}}}{{Ej{c}}}{}}{{Fj{b{d{Ab{Dl}}}}}Fj}{{{Ed{c}}{b{d{Ab{Dl}}}}}{{Ed{c}}}{}}{{{Ej{c}}{b{d{Ab{Dl}}}}}{{Ej{c}}}{}}{FjFj}{{{Ej{c}}}{{Ej{c}}}{}}{{{b{{Ej{c}}}}}{{Ej{c}}}Fl}{{{Ej{c}}{b{{El{c}}}}}{{Ej{c}}}Fl}{{{b{c}}{b{de}}}An{}{}}{{{Ej{c}}{b{c}}{b{dCn}}}{{Ej{c}}}Fn}{{{Ej{c}}{b{c}}{b{d{Ab{Cn}}}}}{{Ej{c}}}Fn}{{{Ej{c}}{b{{El{c}}}}}{{Ej{c}}}G`}{{{Ej{c}}eDl}{{Ej{c}}}G`{{Gb{Dl}}}}{{{Ej{c}}}{{Ej{c}}}Gd}{{{Ej{c}}e}{{Ej{c}}}{}{{Fh{{b{c}}{b{c}}}{{Fd{Cn}}}}}}{{{Ej{c}}g}{{Ej{c}}}{}Fn{{Fh{{b{c}}}{{Fd{e}}}}}}{{{Ej{c}}g}{{Ej{c}}}{}Fn{{Fh{{b{dc}}}{{Fd{e}}}}}}{{{Ej{c}}e}{{Ej{c}}}{}{{Fh{{b{dc}}{b{dc}}}{{Fd{Cn}}}}}}{{}{{Ej{c}}}Gf}{{{Ej{c}}eg}{{Ej{c}}}{}{{Gb{Dl}}}{{En{{Gh{c}}}}}}{{{Ej{c}}{b{{El{c}}}}{b{dCn}}}{{Ej{c}}}Fn}{{{Ej{c}}{b{{El{c}}}}{b{d{Ab{Cn}}}}}{{Ej{c}}}Fn}>{{Fjc}Fj{{Gb{Dl}}}}{{{Ej{c}}e}{{Ej{c}}}Fl{{Gb{Dl}}}}{{{Ej{c}}c}{{Ej{c}}}Fl}{{{Ej{c}}e}{{Ej{c}}}{}{{Fh{}{{Fd{c}}}}}}{{{Gj{c}}e}{{Gj{c}}}{}{{En{{A`{{b{c}}}}}}}}{{{Gl{c}}e}{{Gl{c}}}{}{{En{{A`{{b{c}}}}}}}}{{{Fb{c}}e}{{Fb{c}}}{}{{En{{A`{{b{c}}}}}}}}{{{Ej{c}}e}{{Ej{c}}}{}{{En{{A`{{b{c}}}}}}}}{{{Ej{c}}e}{{Ej{c}}}{}{{En{{A`{{b{{Db{c}}}}}}}}}}{{{Ej{c}}e}{{Ej{c}}}{}{{En{{A`{{b{d{Db{c}}}}}}}}}}{{{Gl{c}}e}{{Gl{c}}}{}{{En{{A`{{b{dc}}}}}}}}{{{Fb{c}}e}{{Fb{c}}}{}{{En{{A`{{b{dc}}}}}}}}{{{Ej{c}}e}{{Ej{c}}}{}{{En{{A`{{b{dc}}}}}}}}{{{Gj{{Db{c}}}}}{{Gj{c}}}{}}{{{Gl{{Db{c}}}}}{{Gl{c}}}{}}{{{Ej{{Db{c}}}}}{{Ej{c}}}{}}{{{b{{Ej{c}}}}{b{dh}}}jGn}{cc{}}{{{b{{Dj{c}}}}}{{H`{c}}}{}}{{{b{d{Dj{c}}}}}{{Hb{c}}}{}}22{{{Hd{{El{c}}}}}{{F`{c}}}{}}3{{{b{{El{c}}}}}{{Gj{c}}}{}}4{{{b{d{El{c}}}}}{{Gl{c}}}{}}{{{Db{c}}}{{Fb{c}}}{}}66{{{b{{Db{c}}}}}{{Hf{c}}}{}}7{{{b{d{Db{c}}}}}{{Hh{c}}}{}}{AdFj}9{{{b{Ad}}}Hj}::{{{b{dAd}}}Hl};{{{Hd{Hn}}}I`}<{{{b{Hn}}}Ib}={{{b{dHn}}}Id}{{{If{c}}}{{Ih{c}}}{}}?{{{Ij{c}}}{{Il{c}}}{}}{cc{}}{{{In{ceg}}}{{J`{ceg}}}{}{}{}}1{{{Jb{ce}}}{{Jd{ce}}}{}{}}22{{{Jf{ce}}}{{Jh{ce}}}{}{}}3{{{Jj{c}}}{{Jl{c}}}{}}4{{{Ef{c}}}{{Ed{c}}}{}}{DfJn}6{{{Dj{c}}}{{Ej{c}}}{}}7{{DhDlDl}Fj}{{DlDl}{{Ej{c}}}{}}{{{b{{El{E`}}}}}{{A`{Fj}}}}{{{b{{El{E`}}}}}Fj}{{{Dj{Dh}}}{{Af{FjK`}}}}{{{Dj{Dh}}}Fj}{{{Ej{c}}eg}{{Ej{c}}}{}{{Kb{{El{c}}}}}{{En{{A`{b}}}}}}{{{Ej{c}}eg}{{Ej{c}}}{}{{Kb{{El{c}}}}}{{En{{A`{{b{d}}}}}}}}{{{Ej{c}}eg}{{Ej{c}}}{}{{Kb{{El{c}}}}}{{En{b}}}}{{{Ej{c}}eg}{{Ej{c}}}{}{{Kb{{El{c}}}}}{{En{{b{d}}}}}}{{FjDlKd}Fj}{{{Ej{c}}Dlc}{{Ej{c}}}{}}{{FjDl{b{Hn}}}Fj}{ce{}{}}0000000000000000000000{{{Ed{c}}}{{Ef{c}}}Eh}{Fj{{Dj{Dh}}}}{Jn{{Dj{Dh}}}}{Fj{{Ej{Dh}}}}{Jn{{Ej{Dh}}}}{{{Kh{}{{Kf{c}}}}}cKj}0{{{F`{c}}}{{Hd{{El{c}}}}}{}}{{{Gj{c}}}{{b{{El{c}}}}}{}}{{{Gl{c}}}{{b{d{El{c}}}}}{}}{{{Fb{c}}}{{Db{c}}}{}}{{{Hf{c}}}{{b{{Db{c}}}}}{}}{{{Hh{c}}}{{b{d{Db{c}}}}}{}}{{{Ih{c}}}{{If{c}}}{}}{Fj{{Bd{DhDlDl}}}}{{{Ed{c}}}{{Dj{c}}}Eh}{{{Ed{c}}}{{Ej{c}}}Eh}{{{Gj{c}}}{{Ej{c}}}Fl}{{{Gl{c}}}{{Ej{c}}}Fl}{{{Ej{Dh}}{b{dCn}}}{{Ej{Dh}}}}{{{Ej{Dh}}{b{d{Ab{Cn}}}}}{{Ej{Dh}}}}{{{Gj{c}}{b{dCn}}}{{Gj{c}}}{}}{{{Gl{c}}{b{dCn}}}{{Gl{c}}}{}}{{{Fb{c}}{b{dCn}}}{{Fb{c}}}{}}{{Fj{b{dCn}}}Fj}{{{Ej{c}}{b{dCn}}}{{Ej{c}}}{}}{{{Gj{c}}{b{d{Ab{Cn}}}}}{{Gj{c}}}{}}{{{Gl{c}}{b{d{Ab{Cn}}}}}{{Gl{c}}}{}}{{{Fb{c}}{b{d{Ab{Cn}}}}}{{Fb{c}}}{}}{{Fj{b{d{Ab{Cn}}}}}Fj}{{{Ej{c}}{b{d{Ab{Cn}}}}}{{Ej{c}}}{}}{{{Gj{c}}e}{{Gj{c}}}{}{{En{{A`{{b{c}}}}}}}}{{{Gl{c}}e}{{Gl{c}}}{}{{En{{A`{{b{c}}}}}}}}{{{Ej{c}}e}{{Ej{c}}}{}{{En{{A`{{b{c}}}}}}}}{{{Ej{c}}e}{{Ej{c}}}{}{{En{{A`{{b{{Db{c}}}}}}}}}}{{{Ej{c}}e}{{Ej{c}}}{}{{En{{A`{{b{d{Db{c}}}}}}}}}}{{{Gl{c}}e}{{Gl{c}}}{}{{En{{A`{{b{dc}}}}}}}}{{{Ej{c}}e}{{Ej{c}}}{}{{En{{A`{{b{dc}}}}}}}}{{{Ej{c}}}{{Gl{c}}}{}}{{{Gj{c}}{b{dDl}}}{{Gj{c}}}{}}{{{Gl{c}}{b{dDl}}}{{Gl{c}}}{}}{{{Fb{c}}{b{dDl}}}{{Fb{c}}}{}}{{Fj{b{dDl}}}Fj}{{{Ej{c}}{b{dDl}}}{{Ej{c}}}{}}{{{Gj{c}}{b{d{Ab{Dl}}}}}{{Gj{c}}}{}}{{{Gl{c}}{b{d{Ab{Dl}}}}}{{Gl{c}}}{}}{{{Fb{c}}{b{d{Ab{Dl}}}}}{{Fb{c}}}{}}{{Fj{b{d{Ab{Dl}}}}}Fj}{{{Ej{c}}{b{d{Ab{Dl}}}}}{{Ej{c}}}{}}{{{Ej{Dh}}}{{Ej{Dh}}}}0{{}Fj}{{}{{Ih{c}}}{}}{{}{{Il{c}}}{}}{{}{{J`{ce}}}{}{}}{{}{{Jd{c}}}{}}{{}{{Ed{c}}}Eh}{{}Jn}{{}{{Ej{c}}}{}}{Dl{{F`{{Ab{c}}}}}{}}{{}{{Fb{{Ab{c}}}}}{}}10{{{b{{Fb{c}}}}}{{b{{Db{c}}}}}{}}{{{b{{Hf{c}}}}}{{b{{Db{c}}}}}{}}{{{b{{Hh{c}}}}}{{b{{Db{c}}}}}{}}{{{b{d{Fb{c}}}}}{{Hh{c}}}{}}{{{b{{Fb{c}}}}}{{Hf{c}}}{}}{{{b{{Hh{c}}}}}{{Hf{c}}}{}}{{{b{d{Fb{c}}}}}{{b{d{Db{c}}}}}{}}{{{b{d{Hh{c}}}}}{{b{d{Db{c}}}}}{}}{{{Ej{c}}}{{Hd{{El{c}}}}}{}}{{{Ej{c}}}{{F`{c}}}{}}{{{b{Fj}}}{{b{{El{Dh}}}}}}{{{b{d{Ih{c}}}}}{{b{d{El{c}}}}}{}}{{{Ej{c}}}{{Dj{c}}}{}}{{{b{{F`{c}}}}}{}{}}{{{b{{Ej{c}}}}}{}{}}{{{b{d{F`{c}}}}}{}{}}{{{b{d{Ej{c}}}}}{}{}}{{{b{{Ej{c}}}}}Kl{}}{{{b{d{Ej{c}}}}}Kl{}}{{{Ej{c}}}{{Bd{DlDl}}}{}}{{{b{{F`{c}}}}}{{b{{El{c}}}}}{}}{{{b{{Gj{c}}}}}{{b{{El{c}}}}}{}}{{{b{{Gl{c}}}}}{{b{{El{c}}}}}{}}{{{b{{Fb{c}}}}}{{b{{El{c}}}}}{}}{{{b{{Hf{c}}}}}{{b{{El{c}}}}}{}}{{{b{{Hh{c}}}}}{{b{{El{c}}}}}{}}{{{b{{Ej{c}}}}}{{b{{El{c}}}}}{}}{{{b{d{F`{c}}}}}{{Gl{c}}}{}}{{{b{d{Fb{c}}}}}{{Gl{c}}}{}}{{{b{d{Hh{c}}}}}{{Gl{c}}}{}}{{{b{d{Ej{c}}}}}{{Gl{c}}}{}}{{{b{{F`{c}}}}}{{Gj{c}}}{}}{{{b{{Gl{c}}}}}{{Gj{c}}}{}}{{{b{{Fb{c}}}}}{{Gj{c}}}{}}{{{b{{Hf{c}}}}}{{Gj{c}}}{}}{{{b{{Hh{c}}}}}{{Gj{c}}}{}}{{{b{{Ej{c}}}}}{{Gj{c}}}{}}{{{b{d{Ih{c}}}}}{{Bd{{Gl{c}}{Gl{c}}}}}{}}{{{b{{Ih{c}}}}}{{Bd{{Gj{c}}{Gj{c}}}}}{}}{{{b{d{F`{c}}}}}{{b{d{El{c}}}}}{}}{{{b{d{Gl{c}}}}}{{b{d{El{c}}}}}{}}{{{b{d{Fb{c}}}}}{{b{d{El{c}}}}}{}}{{{b{d{Hh{c}}}}}{{b{d{El{c}}}}}{}}{{{b{d{Ej{c}}}}}{{b{d{El{c}}}}}{}}{{{b{{Ih{c}}}}}{{Bd{{b{{El{c}}}}{b{{El{c}}}}}}}{}}{{{b{d{Ih{c}}}}}{{Bd{{b{d{El{c}}}}{b{d{El{c}}}}}}}{}}{{{b{Fj}}}{{b{Hn}}}}{{{b{dFj}}}{{b{dHn}}}}{{{b{{Ej{c}}}}}{{b{{Dj{c}}}}}{}}{{{b{{Ih{c}}}}}{{b{{If{c}}}}}{}}{{{b{d{Ih{c}}}}}{{b{d{If{c}}}}}{}}{{{b{dFj}}}{{b{d{Dj{Dh}}}}}}{{{b{d{Ej{c}}}}}{{b{d{Dj{c}}}}}{}}{{Fj{b{d{A`{Kd}}}}}Fj}{{{Ed{c}}{b{d{A`{c}}}}}{{Ed{c}}}Eh}{{{Ej{c}}{b{d{A`{c}}}}}{{Ej{c}}}{}}{{Fj{b{d{Ab{{A`{Kd}}}}}}}Fj}{{{Ed{c}}{b{d{Ab{{A`{c}}}}}}}{{Ed{c}}}Eh}{{{Ej{c}}{b{d{Ab{{A`{c}}}}}}}{{Ej{c}}}{}}{{FjKd}Fj}{{{Ed{c}}c}{{Ed{c}}}Eh}{{{Ej{c}}c}{{Ej{c}}}{}}{{Fj{b{Hn}}}Fj}{{FjDl{b{dKd}}}Fj}{{{Ej{c}}Dl{b{dc}}}{{Ej{c}}}{}}{{FjDl{b{d{Ab{Kd}}}}}Fj}{{{Ej{c}}Dl{b{d{Ab{c}}}}}{{Ej{c}}}{}}{{{Ej{c}}Dl}{{Ej{c}}}G`}{{FjDl}Fj}{{{Ed{c}}Dl}{{Ed{c}}}{}}{{{Ej{c}}Dl}{{Ej{c}}}{}}210{{{Ej{c}}Dlc}{{Ej{c}}}Fl}{{{Ej{c}}Dle}{{Ej{c}}}{}{{Fh{}{{Fd{c}}}}}}{{Fjc}Fj{{Fh{Kd}{{Fd{Cn}}}}}}{{{Ed{c}}e}{{Ed{c}}}Eh{{Fh{{b{c}}}{{Fd{Cn}}}}}}{{{Ej{c}}e}{{Ej{c}}}{}{{Fh{{b{c}}}{{Fd{Cn}}}}}}{{{Ej{c}}e}{{Ej{c}}}{}{{Fh{{b{dc}}}{{Fd{Cn}}}}}}{{{Ej{c}}}{{Ej{c}}}{}}797{FjFj}1{{{Gl{c}}}{{Gl{c}}}Eh}{{{Ej{c}}}{{Ej{c}}}Eh}0{{{Gl{c}}e}{{Gl{c}}}{}{{Fh{{b{c}}{b{c}}}{{Fd{Ff}}}}}}{{{Ej{c}}e}{{Ej{c}}}{}{{Fh{{b{c}}{b{c}}}{{Fd{Ff}}}}}}{{{Gl{c}}g}{{Gl{c}}}{}Eh{{Fh{{b{c}}}{{Fd{e}}}}}}{{{Ej{c}}g}{{Ej{c}}}{}Eh{{Fh{{b{c}}}{{Fd{e}}}}}}10{{{Ej{Kn}}}{{Ej{Kn}}}}{{{Ej{L`}}}{{Ej{L`}}}}765432{{{Ej{c}}e}{{Ej{c}}}{}{{En{{Gl{{Ab{c}}}}}}}}{{{Ej{c}}egi}{{Ej{c}}}{}{{Gb{Dl}}}{{Ld{}{{Lb{c}}}}}{{En{{Lh{Lf}}}}}}{{FjDl}{{Bd{FjFj}}}}{{{Ej{c}}e}{{Ej{c}}}{}{{En{{Gl{c}}{Gl{{Ab{c}}}}}}}}{{{Ej{c}}e}{{Ej{c}}}{}{{En{{A`{{Bd{{b{c}}{Gj{c}}}}}}}}}}{{{Ej{c}}e}{{Ej{c}}}{}{{En{{A`{{Bd{{b{{Db{c}}}}{b{{El{c}}}}}}}}}}}}{{{Ej{c}}e}{{Ej{c}}}{}{{En{{A`{{Bd{{b{d{Db{c}}}}{b{d{El{c}}}}}}}}}}}}{{{Ej{c}}e}{{Ej{c}}}{}{{En{{A`{{Bd{{b{dc}}{Gl{c}}}}}}}}}}3{{{Ej{c}}e}{{Ej{c}}}{}{{En{{A`{{Bd{{b{{El{c}}}}{b{{Db{c}}}}}}}}}}}}{{{Ej{c}}e}{{Ej{c}}}{}{{En{{A`{{Bd{{b{d{El{c}}}}{b{d{Db{c}}}}}}}}}}}}2{{FjDl{b{dFj}}}Fj}{{FjDl{b{d{Ab{Fj}}}}}Fj}10{{{Ej{c}}{b{{El{c}}}}{b{dCn}}}{{Ej{c}}}Fn}{{{Ej{c}}{b{{El{c}}}}{b{d{Ab{Cn}}}}}{{Ej{c}}}Fn}{{{Ej{c}}DlDl}{{Ej{c}}}{}}{{{Ej{c}}Dl{b{dc}}}{{Ej{c}}}{}}{{{Ej{c}}Dl{b{d{Ab{c}}}}}{{Ej{c}}}{}}2{{{Ej{c}}{b{d{El{c}}}}}{{Ej{c}}}{}}{{{b{c}}}{{b{{Ab{e}}}}}{}{}}0000000000000000000000{{{b{dc}}}{{b{d{Ab{e}}}}}{}{}}000000000000000000000000000000000000000000000{{{b{c}}}e{}{}}`{{FjDl}Fj}{{{Ej{c}}Dl}{{Ej{c}}}{}}1{c{{Af{e}}}{}{}}000000000000000000000000000000000000000000000{{{b{c}}}Ah{}}0000000000000000000000{ce{}{}}0000000000000000000000{{{Ej{c}}Dle}{{Ej{c}}}{}{{En{{Lj{c}}}}}}{DlFj}{Dl{{Ih{c}}}{}}{Dl{{J`{ce}}}{}{}}{Dl{{Jd{c}}}{}}{Dl{{Ed{c}}}Eh}{Dl{{Ej{c}}}{}}{DlJn}{{{Ed{c}}e}{{Ed{c}}}{}{{En{{A`{{b{c}}}}}}}}{{{Ed{c}}e}{{Ed{c}}}Eh{{En{{A`{{Ll{c}}}}}}}}{{JnDlDn}Jn}{{JnDlE`}Jn}{{JnDlEb}Jn}{{JnDlDd}Jn}{{JnDlDh}Jn}``{{{b{c}}}{{b{e}}}{}{}}0{{{b{dc}}}{{b{de}}}{}{}}0`{{}Ln}`{{{b{M`}}}Cn}{{{b{M`}}}Mb}{{{b{M`}}}{{Mf{Md}}}}{cc{}}0{ce{}{}}043{{Mhe}An{{Mj{}{{Fd{An}}}}}{{Fh{M`}{{Fd{c}}}}}}3{{{b{dMh}}}{{A`{M`}}}}4{{{b{c}}}{{b{{Ab{e}}}}}{}{}}0{{{b{dc}}}{{b{d{Ab{e}}}}}{}{}}0007{c{{Af{e}}}{}{}}000{{{b{c}}}Ah{}}066````====<<<<{MlMh}88887777<4444333333332222222211117777{{MnMb}N`}{{Mn{Mf{c}}}N`Nb}{{N`Mb}Ml}{{Ln{Mf{c}}}MnNb}{{cDl}{{`{NdFlNfNh}}}{NdNf}}0{{cDl{b{Nj}}}{{`{NdFlNfNh}}}{NdNf}}0{{}Ad}``````{{{b{c}}}{{b{e}}}{}{}}{{{b{dc}}}{{b{de}}}{}{}}{{{b{{El{Dh}}}}}{{Af{{Dj{Dh}}Nl}}}}{{{b{{El{Dh}}}}}Ad}0{{{b{Nl}}{b{dh}}}j}0{cc{}}{ce{}{}}{{{b{c}}}{{b{{Ab{e}}}}}{}{}}{{{b{dc}}}{{b{d{Ab{e}}}}}{}{}}0{{{b{c}}}Ad{}}{c{{Af{e}}}{}{}}0{{{b{c}}}Ah{}}5``{{{b{Nn}}}O`}{{{b{Nn}}}Dd}{{{b{Nn}}}Ob}>>==99{O`{{A`{Nn}}}}{O`Nn}{Dd{{A`{Nn}}}}{DdNn}<<{{}Od}{{{b{dOd}}}{{A`{Nn}}}}==<<<<::::997>>````````````````````````````````````````````````````````````>{{{b{c}}}{{b{e}}}{}{}}0000000000000000000000000000000000000000{{{b{dc}}}{{b{de}}}{}{}}0000000000000000000000000000000000000000{{{b{d{Oh{}{{Of{c}}}}}}}cOj}{{{b{dc}}}{{Lf{{b{de}}}}}{}{}}{{{b{d{On{}{{Ol{c}}}}}}}cA@`}111111111111111111111111111111111111111{{{A@b{}{{Of{c}}}}}cOj}{cLf{}}{{{A@d{}{{Ol{c}}}}}cA@`}111111111111111111111111111111111111111{{{Oj{}{{Lb{c}}}}}Dl{}}{{}A@f}{{}{{A@h{c}}}{}}{DlA@f}{{{b{A@f}}{b{dh}}}j}{{{b{A@j}}{b{dh}}}j}{{{Oj{}{{Lb{c}}}}e}An{}{{Fh{c}}}}{{A@le}An{}{{Fh{c}}}}0{cc{}}0000000000000000000000000000000000000000{e{{A@n{e}}}{}{{Fh{}{{Fd{{A`{c}}}}}}}}6{ce{}{}}0000000000000000000000000000000000000000{{{AA`{cg}}}{{Bd{cg}}}Oj{}{{Fh{}{{Fd{e}}}}}}{{{AAb{ec}}}{{Bd{e{A`{{A`{c}}}}}}}{}{{Oj{}{{Lb{c}}}}}}{{{AAd{c}}}{{Bd{c{A`{A`}}}}}Oj}{{{AAf{c}}}cA@l}4{A@f{{Bd{Dl{A`{Dl}}}}}}{{{Ld{}{{Lb{c}}{Of{e}}}}}e{}{{Oj{}{{Lb{c}}}}}}666666666666666666666666666666666666666{{{Oj{}{{Lb{c}}}}g}{{AA`{{Oj{}{{Lb{c}}}}g}}}{}{}{{Fh{c}{{Fd{e}}}}}}{{}A@f}{{{b{d{Oj{}{{Lb{c}}}}}}}{{A`{c}}}{}}{{{b{d{Lf{c}}}}}A`A@`}{{{b{d{Lf{c}}}}}A`Oj}{{{b{d{A@h{c}}}}}{{A`{c}}}{}}{{{b{d{A@n{e}}}}}{{A`{c}}}{}{{Fh{}{{Fd{{A`{c}}}}}}}}{{{b{d{AA`{cg}}}}}{{A`{e}}}Oj{}{{Fh{}{{Fd{e}}}}}}{{{b{d{AAb{ec}}}}}A`{}{{Oj{}{{Lb{c}}}}}}{{{b{d{AAd{c}}}}}A`Oj}{{{b{d{AAf{c}}}}}A`A@l}{{{b{d{AAh{cegikmoAaAcAeAgAiAkAmAoBaBcBeBgBiBkBmBoCaCcCeCgCiCkCmCoDa}}}}}{{A`{Dc}}}OjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOj{}}{{{b{d{AAj{cegikmoAaAcAeAgAiAkAmAoBaBcBeBgBiBkBmBoCaCcCeCgCiCkCmCo}}}}}{{A`{Da}}}OjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOj{}}{{{b{d{AAl{cegikmoAaAcAeAgAiAkAmAoBaBcBeBgBiBkBmBoCaCcCeCgCiCkCm}}}}}{{A`{Co}}}OjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOj{}}{{{b{d{AAn{cegikmoAaAcAeAgAiAkAmAoBaBcBeBgBiBkBmBoCaCcCeCgCiCk}}}}}{{A`{Cm}}}OjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOj{}}{{{b{d{AB`{cegikmoAaAcAeAgAiAkAmAoBaBcBeBgBiBkBmBoCaCcCeCgCi}}}}}{{A`{Ck}}}OjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOj{}}{{{b{d{ABb{cegikmoAaAcAeAgAiAkAmAoBaBcBeBgBiBkBmBoCaCcCeCg}}}}}{{A`{Ci}}}OjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOj{}}{{{b{d{ABd{cegikmoAaAcAeAgAiAkAmAoBaBcBeBgBiBkBmBoCaCcCe}}}}}{{A`{Cg}}}OjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOj{}}{{{b{d{ABf{cegikmoAaAcAeAgAiAkAmAoBaBcBeBgBiBkBmBoCaCc}}}}}{{A`{Ce}}}OjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOj{}}{{{b{d{ABh{cegikmoAaAcAeAgAiAkAmAoBaBcBeBgBiBkBmBoCa}}}}}{{A`{Cc}}}OjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOj{}}{{{b{d{ABj{cegikmoAaAcAeAgAiAkAmAoBaBcBeBgBiBkBmBo}}}}}{{A`{Ca}}}OjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOj{}}{{{b{d{ABl{cegikmoAaAcAeAgAiAkAmAoBaBcBeBgBiBkBm}}}}}{{A`{Bo}}}OjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOj{}}{{{b{d{ABn{cegikmoAaAcAeAgAiAkAmAoBaBcBeBgBiBk}}}}}{{A`{Bm}}}OjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOj{}}{{{b{d{AC`{cegikmoAaAcAeAgAiAkAmAoBaBcBeBgBi}}}}}{{A`{Bk}}}OjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOj{}}{{{b{d{ACb{cegikmoAaAcAeAgAiAkAmAoBaBcBeBg}}}}}{{A`{Bi}}}OjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOj{}}{{{b{d{ACd{cegikmoAaAcAeAgAiAkAmAoBaBcBe}}}}}{{A`{Bg}}}OjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOj{}}{{{b{d{ACf{cegikmoAaAcAeAgAiAkAmAoBaBc}}}}}{{A`{Be}}}OjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOj{}}{{{b{d{ACh{cegikmoAaAcAeAgAiAkAmAoBa}}}}}{{A`{Bc}}}OjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOj{}}{{{b{d{ACj{cegikmoAaAcAeAgAiAkAmAo}}}}}{{A`{Ba}}}OjOjOjOjOjOjOjOjOjOjOjOjOjOjOj{}}{{{b{d{ACl{cegikmoAaAcAeAgAiAkAm}}}}}{{A`{Ao}}}OjOjOjOjOjOjOjOjOjOjOjOjOjOj{}}{{{b{d{ACn{cegikmoAaAcAeAgAiAk}}}}}{{A`{Am}}}OjOjOjOjOjOjOjOjOjOjOjOjOj{}}{{{b{d{AD`{cegikmoAaAcAeAgAi}}}}}{{A`{Ak}}}OjOjOjOjOjOjOjOjOjOjOjOj{}}{{{b{d{ADb{cegikmoAaAcAeAg}}}}}{{A`{Ai}}}OjOjOjOjOjOjOjOjOjOjOj{}}{{{b{d{ADd{cegikmoAaAcAe}}}}}{{A`{Ag}}}OjOjOjOjOjOjOjOjOjOj{}}{{{b{d{ADf{cegikmoAaAc}}}}}{{A`{Ae}}}OjOjOjOjOjOjOjOjOj{}}{{{b{d{ADh{cegikmoAa}}}}}{{A`{Ac}}}OjOjOjOjOjOjOjOj{}}{{{b{d{ADj{cegikmo}}}}}{{A`{Aa}}}OjOjOjOjOjOjOj{}}{{{b{d{ADl{cegikm}}}}}{{A`{o}}}OjOjOjOjOjOj{}}{{{b{d{ADn{cegik}}}}}{{A`{m}}}OjOjOjOjOj{}}{{{b{d{AE`{cegi}}}}}{{A`{k}}}OjOjOjOj{}}{{{b{d{AEb{ceg}}}}}{{A`{i}}}OjOjOj{}}{{{b{d{AEd{ce}}}}}{{A`{g}}}OjOj{}}{{{b{d{AEf{c}}}}}{{A`{e}}}Oj{}}{{{b{dA@l}}}{{A`{c}}}{}}{{{b{d{Lf{c}}}}}{{A`{e}}}A@l{}}{{{b{d{Lf{c}}}}}{{A`{e}}}AEh{}}{{{b{d{AAf{c}}}}}A`A@l}{{{b{d{AEl{}{{AEj{c}}}}}}}{{A`{{b{c}}}}}{}}{{{b{d{AAb{ec}}}}}{{A`{b}}}{}{{Oj{}{{Lb{c}}}}}}{{{Oj{}{{Lb{c}}}}}{{AAb{{Oj{}{{Lb{c}}}}c}}}{}}{{{Oj{}{{Lb{c}}}}Dl}{{AAd{{Oj{}{{Lb{c}}}}}}}{}}{A@l{{AAf{A@l}}}}0{{{b{{Lf{c}}}}}{{Bd{Dl{A`{Dl}}}}}Oj}{{{b{{Lf{c}}}}}A@fA@`}{{{b{{A@h{c}}}}}A@f{}}{{{b{{AA`{cg}}}}}A@fOj{}{{Fh{}{{Fd{e}}}}}}{{{b{{AAb{ec}}}}}A@f{}{{Oj{}{{Lb{c}}}}}}{{{b{{AAd{c}}}}}A@fOj}{{{b{{AAf{c}}}}}A@fA@l}{{{b{{Oj{}{{Lb{c}}}}}}}A@f{}}{{{b{{AAh{cegikmoAaAcAeAgAiAkAmAoBaBcBeBgBiBkBmBoCaCcCeCgCiCkCmCoDa}}}}}A@fOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOj}{{{b{{AAj{cegikmoAaAcAeAgAiAkAmAoBaBcBeBgBiBkBmBoCaCcCeCgCiCkCmCo}}}}}A@fOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOj}{{{b{{AAl{cegikmoAaAcAeAgAiAkAmAoBaBcBeBgBiBkBmBoCaCcCeCgCiCkCm}}}}}A@fOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOj}{{{b{{AAn{cegikmoAaAcAeAgAiAkAmAoBaBcBeBgBiBkBmBoCaCcCeCgCiCk}}}}}A@fOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOj}{{{b{{AB`{cegikmoAaAcAeAgAiAkAmAoBaBcBeBgBiBkBmBoCaCcCeCgCi}}}}}A@fOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOj}{{{b{{ABb{cegikmoAaAcAeAgAiAkAmAoBaBcBeBgBiBkBmBoCaCcCeCg}}}}}A@fOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOj}{{{b{{ABd{cegikmoAaAcAeAgAiAkAmAoBaBcBeBgBiBkBmBoCaCcCe}}}}}A@fOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOj}{{{b{{ABf{cegikmoAaAcAeAgAiAkAmAoBaBcBeBgBiBkBmBoCaCc}}}}}A@fOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOj}{{{b{{ABh{cegikmoAaAcAeAgAiAkAmAoBaBcBeBgBiBkBmBoCa}}}}}A@fOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOj}{{{b{{ABj{cegikmoAaAcAeAgAiAkAmAoBaBcBeBgBiBkBmBo}}}}}A@fOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOj}{{{b{{ABl{cegikmoAaAcAeAgAiAkAmAoBaBcBeBgBiBkBm}}}}}A@fOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOj}{{{b{{ABn{cegikmoAaAcAeAgAiAkAmAoBaBcBeBgBiBk}}}}}A@fOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOj}{{{b{{AC`{cegikmoAaAcAeAgAiAkAmAoBaBcBeBgBi}}}}}A@fOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOj}{{{b{{ACb{cegikmoAaAcAeAgAiAkAmAoBaBcBeBg}}}}}A@fOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOj}{{{b{{ACd{cegikmoAaAcAeAgAiAkAmAoBaBcBe}}}}}A@fOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOj}{{{b{{ACf{cegikmoAaAcAeAgAiAkAmAoBaBc}}}}}A@fOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOj}{{{b{{ACh{cegikmoAaAcAeAgAiAkAmAoBa}}}}}A@fOjOjOjOjOjOjOjOjOjOjOjOjOjOjOjOj}{{{b{{ACj{cegikmoAaAcAeAgAiAkAmAo}}}}}A@fOjOjOjOjOjOjOjOjOjOjOjOjOjOjOj}{{{b{{ACl{cegikmoAaAcAeAgAiAkAm}}}}}A@fOjOjOjOjOjOjOjOjOjOjOjOjOjOj}{{{b{{ACn{cegikmoAaAcAeAgAiAk}}}}}A@fOjOjOjOjOjOjOjOjOjOjOjOjOj}{{{b{{AD`{cegikmoAaAcAeAgAi}}}}}A@fOjOjOjOjOjOjOjOjOjOjOjOj}{{{b{{ADb{cegikmoAaAcAeAg}}}}}A@fOjOjOjOjOjOjOjOjOjOjOj}{{{b{{ADd{cegikmoAaAcAe}}}}}A@fOjOjOjOjOjOjOjOjOjOj}{{{b{{ADf{cegikmoAaAc}}}}}A@fOjOjOjOjOjOjOjOjOj}{{{b{{ADh{cegikmoAa}}}}}A@fOjOjOjOjOjOjOjOj}{{{b{{ADj{cegikmo}}}}}A@fOjOjOjOjOjOjOj}{{{b{{ADl{cegikm}}}}}A@fOjOjOjOjOjOj}{{{b{{ADn{cegik}}}}}A@fOjOjOjOjOj}{{{b{{AE`{cegi}}}}}A@fOjOjOjOj}{{{b{{AEb{ceg}}}}}A@fOjOjOj}{{{b{{AEd{ce}}}}}A@fOjOj}{{{b{{AEf{c}}}}}A@fOj}{A@f{{Bd{A@jA@j}}}}{{{b{c}}}{{b{{Ab{e}}}}}{}{}}0000000000000000000000000000000000000000{{{b{dc}}}{{b{d{Ab{e}}}}}{}{}}000000000000000000000000000000000000000000000000000000000000000000000000000000000{c{{Af{e}}}{}{}}000000000000000000000000000000000000000000000000000000000000000000000000000000000{{{b{c}}}Ah{}}0000000000000000000000000000000000000000{{}A@f}{ce{}{}}0000000000000000000000000000000000000000{{A@fDl}A@f}0{A@fA@f}110``````{{{b{d{AEn{eg}}}}}{{b{dc}}}AF`{{AFb{c}}}{{En{}{{Fd{e}}}}}}{{{b{{AEn{eg}}}}}{{b{c}}}AF`{{AFd{c}}}{{En{}{{Fd{e}}}}}}{{{b{c}}}{{b{e}}}{}{}}0{{{b{dc}}}{{b{de}}}{}{}}0{{{b{{AEn{ce}}}}}{{b{g}}}{}{{En{}{{Fd{c}}}}}{}}{{{b{d{AEn{ce}}}}}{{b{dg}}}{}{{En{}{{Fd{c}}}}}{}}{{{b{d{AEn{ce}}}}}An{}{}}{{{b{{AEn{ce}}}}}An{}{{En{}{{Fd{c}}}}}}{{{b{{AEn{ce}}}}{b{dh}}}jGn{{En{}{{Fd{c}}}}}}{{{b{{AEn{ce}}}}{b{dh}}}jAFf{{En{}{{Fd{c}}}}}}{cc{}}0=={{{AEn{ce}}}{{AFh{ce}}}{}{{En{}{{Fd{c}}}}}}{{{AEn{ce}}}c{}{{En{}{{Fd{c}}}}}}{{{b{{AEn{ce}}}}}Cn{}{{En{}{{Fd{c}}}}}}{e{{AEn{ce}}}{}{{En{}{{Fd{c}}}}}}{{{b{c}}}{{b{{Ab{e}}}}}{}{}}0{{{b{dc}}}{{b{d{Ab{e}}}}}{}{}}000{{{b{c}}}Ad{}}{c{{Af{e}}}{}{}}000{{{b{c}}}Ah{}}0{ce{}{}}0```{{{b{c}}}{{b{e}}}{}{}}0{{{b{dc}}}{{b{de}}}{}{}}0<<22{cAFj{{En{{b{dAFl}}}}}}88777755554433````{{{b{AFn}}}Dl}0{{{b{c}}}DlAFn}0{{}Dl}{{{b{c}}}DlAG`}`{{{b{Hn}}}{{b{Hn}}}}`````````````{{{b{Mb}}}Mb}{{MbMb}Mb}{{{Mf{c}}AGb}{{Mf{c}}}Nb}{{{Mf{c}}Mb}{{Mf{c}}}Nb}{{{Mf{c}}AGd}{{Mf{c}}}Nb}{{{Mf{c}}AGf}{}Nb}{{{Mf{c}}AGh}{}Nb}{{{b{dMb}}Mb}An}{{{b{d{Mf{c}}}}AGb}AnNb}{{{b{d{Mf{c}}}}Mb}AnNb}{{{b{c}}}{{b{e}}}{}{}}00{{{b{dc}}}{{b{de}}}{}{}}00{{{b{Mb}}{b{Mb}}}{{A`{Mb}}}}{{{Mf{c}}AGh}{{A`{{Mf{c}}}}}Nb}{{{Mf{c}}AGf}{{A`{{Mf{c}}}}}Nb}{{{Mf{c}}Mb}{{A`{{Mf{c}}}}}Nb}3210?{{{b{{Mf{c}}}}}{{Mf{c}}}{FlNb}}{{{b{Md}}}Md}{{{b{c}}{b{de}}}An{}{}}00{{{b{Mb}}{b{Mb}}}Ff}{{{b{{Mf{c}}}}{b{{Mf{c}}}}}FfNb}{{{b{{Mf{c}}}}}{{AGj{c}}}Nb}{{{b{{Mf{c}}}}}AGlNb}{{{b{{Mf{c}}}}}EbNb}0{O`Mb}``````{{}Mb}{{}{{Mf{AGd}}}}{{}{{Mf{AGn}}}}{{}{{Mf{Md}}}}{{MbAH`}Mb}{{{Mf{c}}Mb}{{Af{{Mf{c}}}}}Nb}0```{{{b{Mb}}{b{Mb}}}Cn}{{{b{{Mf{c}}}}{b{{Mf{e}}}}}CnNbNb}{{{b{c}}{b{e}}}Cn{}{}}000{{{b{{Mf{c}}}}}{{Mf{AGd}}}Nb}{{{b{Mb}}{b{dh}}}{{Af{AnAHb}}}}0{{{b{{Mf{c}}}}{b{dh}}}{{Af{AnAHb}}}Nb}0{{{b{Md}}{b{dh}}}{{Af{AnAHb}}}}{{{b{{Mf{c}}}}{b{Hn}}}{{AHf{AHd}}}Nb}{{{b{{Mf{c}}}}g}{{AHf{g}}}Nb{{AHj{AHh}}}{{A@`{}{{Lb{e}}}}Fl}}{cc{}}{{{Mf{AGd}}}{{Mf{AGn}}}}1{AHl{{Mf{AGn}}}}{{{Mf{AGn}}}{{Mf{AGd}}}}{{{Mf{Md}}}{{Mf{AGd}}}}{AHl{{Mf{Md}}}}{{{Mf{Md}}}{{Mf{AGn}}}}{{{Mf{AGn}}}{{Mf{Md}}}}{{{Mf{AGd}}}{{Mf{Md}}}}8{AHn{{Mf{c}}}Nb}0{{{b{AGd}}}Md}{AGb{{Af{MbAI`}}}}{{{b{Hn}}}{{Af{{Mf{AGn}}AIb}}}}{{{b{Hn}}}{{Af{{Mf{Md}}AIb}}}}{{{b{Hn}}}{{Af{{Mf{AGd}}AIb}}}}{{O`Eb}{{A`{{Mf{AGn}}}}}}{O`{{A`{{Mf{AGn}}}}}}0{O`{{Mf{AGn}}}}8`{{{b{Mb}}{b{dc}}}AnAId}{{{b{{Mf{c}}}}{b{de}}}AnNbAId}{{{b{{Mf{c}}}}}EbNb}{O`Mb}{ce{}{}}00{{{b{Mb}}}Cn}{{{b{{Mf{c}}}}}AIfNb}{{}Mb}4405455{{MbAH`}Mb}{{{b{{Mf{c}}}}}AHnNb}076{MbMb}{{O`Eb}{{A`{Mb}}}}{{}{{Mf{Md}}}}{{{b{Mb}}}O`}0{{{b{Mb}}}{{A`{O`}}}}11011{{{b{{Mf{c}}}}}bNb}{{{b{Md}}{b{AGl}}}{{AIh{AGd}}}}{{{b{Md}}{b{AHn}}}{{AIh{AGd}}}}{{{b{Md}}{b{AGl}}}AGd}{{{b{Md}}{b{AHn}}}AGd}{{{b{{Mf{c}}}}}EbNb}0{{{b{Hn}}{b{Hn}}}{{Af{{Bd{{Mf{AGd}}{b{Hn}}}}AIb}}}}{{{b{Hn}}}{{Af{{Mf{AGd}}AIb}}}}0{{{b{Hn}}{b{Hn}}}{{Af{{Mf{AGd}}AIb}}}}{{{b{Mb}}{b{Mb}}}{{A`{Ff}}}}{{{b{{Mf{c}}}}{b{{Mf{e}}}}}{{A`{Ff}}}NbNb}{{cE`}e{}{}}6{O`Mb}{{{Mf{c}}g}MbNbNb{{AHj{{Mf{e}}}}}}{{MbMb}Mb}{{{Mf{c}}AGf}{}Nb}{{{Mf{c}}{Mf{c}}}MbNb}{{{Mf{c}}AGb}{{Mf{c}}}Nb}{{{Mf{c}}Mb}{{Mf{c}}}Nb}{{{Mf{c}}{b{{Mf{c}}}}}MbNb}{{{Mf{c}}AGh}{}Nb}{{{Mf{c}}AGd}{{Mf{c}}}Nb}{{{b{dMb}}Mb}An}{{{b{d{Mf{c}}}}Mb}AnNb}{{{b{d{Mf{c}}}}AGb}AnNb}{{{b{Mb}}}AH`}{cMb{{A@`{}{{Lb{Mb}}}}}}{cMb{{A@`{}{{Lb{{b{Mb}}}}}}}}{{{b{{Mf{c}}}}}AIjNb}{{{b{{Mf{c}}}}}O`Nb}000{{{b{{Mf{c}}}}}{{A`{O`}}}Nb}{{{b{{Mf{c}}}}}EbNb}00{{{b{{Mf{c}}}}}cNb}{{{b{c}}}{{b{{Ab{e}}}}}{}{}}00{{{b{dc}}}{{b{d{Ab{e}}}}}{}{}}00000{{{b{c}}}e{}{}}00{{{b{{Mf{c}}}}}AdNb}0{{{b{{Mf{c}}}}AIlCn}AdNb}{{{b{Mb}}}{{Af{AGbAI`}}}}{{{b{c}}}Ad{}}0{{{b{{Mf{c}}}}}{{Mf{AGn}}}Nb}{{}{{AGj{Md}}}}{{cE`}e{}{}}{O`{{A`{Mb}}}}{c{{Af{e}}}{}{}}0010001111{{{b{c}}}Ah{}}00{ce{}{}}00{{{b{{Mf{c}}}}}AInNb}{O`Mb}{{{b{{Mf{c}}}}Eb}{{A`{{Mf{c}}}}}Nb}000000000{{{b{{Mf{c}}}}{b{e}}}{{Mf{e}}}NbNb}{{{b{{Mf{c}}}}AH`}{{A`{{Mf{c}}}}}Nb}{{{b{{Mf{c}}}}}AH`Nb}{{{b{{Mf{c}}}}{Mf{c}}}{{A`{Eb}}}Nb}{{}Mb}````````{{{b{dAJ`}}}{{AJb{Dh}}}}{{{b{dAJ`}}Dl}{{AJb{{b{{El{Dh}}}}}}}}{{{b{dAJ`}}}{{AJb{{b{{Db{Dh}}}}}}}}{{{b{dAJ`}}Dl}{{AJb{Dh}}}}3{{{b{dAJd}}Dl}An}{{{b{dAJd}}c}An{{En{Dh}{{Fd{Dl}}}}}}{{{b{dAJd}}Dh}An}{{{b{dAJd}}{b{{El{Dh}}}}}An}0`{{{b{{El{Dh}}}}}{{AJb{c}}}AJf}{{{b{dc}}}{{AJb{AJf}}}AJ`}1``````{{{b{c}}}{{b{e}}}{}{}}{{{b{dc}}}{{b{de}}}{}{}}{{{b{AJh}}}AJh}{{{b{c}}{b{de}}}An{}{}}{AJj{{AJb{c}}}{}}{{{AJb{ce}}}{{AJb{c}}}{}AJl}{{{b{AJh}}}{{b{Hn}}}}{{{b{AJh}}{b{AJh}}}Cn}{{{b{c}}{b{e}}}Cn{}{}}0{{}{{AJb{c}}}{}}{AJn{{AJb{c}}}{}}{{AJne}{{AJb{g}}}{{l{Ad}}}{{En{}{{Fd{c}}}}}{}}{{{b{Hn}}}{{AJb{c}}}{}}{{AJn{b{Hn}}}{{AJb{c}}}{}}{c{{AJb{e}}}{{l{Ad}}}{}}{{AJnc}{{AJb{e}}}{{l{Ad}}}{}}{{}AJh}{{{b{Hn}}}AJh}{cAJh{{l{Ad}}}}{{{b{AJh}}{b{dh}}}j}0{cc{}}{ce{}{}}{{{b{c}}}{{b{{Ab{e}}}}}{}{}}{{{b{dc}}}{{b{d{Ab{e}}}}}{}{}}0{{{b{c}}}e{}{}}{{{b{c}}}Ad{}}{c{{Af{e}}}{}{}}0{{{b{c}}}Ah{}}6```{{{b{c}}}{{b{e}}}{}{}}{{{b{dc}}}{{b{de}}}{}{}}98{{{b{dc}}}{{AJb{AK`}}}AJ`}8774439````````21`{{{b{AKb}}}AKb}{{{b{c}}{b{de}}}An{}{}}{{}AKb}{{{b{AKb}}{b{dh}}}j}>={{{b{c}}}{{Dj{Dh}}}{AF`AKd}}{{{b{AKd}}{b{dc}}{b{AKb}}}AnAJd}{{{b{c}}{b{AKb}}}{{Dj{Dh}}}{AF`AKd}}?>>=;;:{ce{}{}}````{{{b{{AKf{c}}}}{AKf{e}}}{{AKf{c}}}AKhAKh}{{{AKf{c}}{AKf{e}}}{{AKf{c}}}AKhAKh}{{{b{{AKf{c}}}}{b{Hn}}}{{AKf{c}}}AKh}{{{AKf{c}}{b{Ad}}}{{AKf{c}}}AKh}{{{AKf{c}}Ad}{{AKf{c}}}AKh}{{{b{{AKf{c}}}}{b{{AKf{e}}}}}{{AKf{c}}}AKhAKh}{{{AKf{c}}{b{Hn}}}{{AKf{c}}}AKh}{{{b{{AKf{c}}}}Ad}{{AKf{c}}}AKh}{{{b{{AKf{c}}}}{b{Ad}}}{{AKf{c}}}AKh}{{{AKf{c}}{b{{AKf{e}}}}}{{AKf{c}}}AKhAKh}{{{b{d{AKf{c}}}}{b{{AKf{e}}}}}AnAKhAKh}{{{b{d{AKf{c}}}}{b{Hn}}}AnAKh}{{{b{d{AKf{c}}}}{AKf{e}}}AnAKhAKh}{{{b{{AKf{c}}}}}{{b{Hn}}}AKh}{{{b{{AKf{c}}}}}{{b{AKj}}}AKh}{{{b{{AKf{c}}}}}{{b{AKl}}}AKh}{{{b{{AKf{c}}}}}{{b{{El{Dh}}}}}AKh}{{{b{c}}}{{b{e}}}{}{}}4{{{b{dc}}}{{b{de}}}{}{}}{{{b{{AKf{c}}}}}{{AKf{c}}}AKh}{{{b{c}}{b{de}}}An{}{}}{{}{{AKf{c}}}AKh}8{{{b{{AKf{c}}}}{b{dh}}}jAKh}0{{{Bd{{b{Hn}}c}}}{{AKf{c}}}AKh}{cc{}}{{{b{Hn}}}AKf}{ce{}{}}`{{{b{{AKh{}{{AKn{c}}}}}}{b{c}}}c{}}{{{b{{AKh{}{{AKn{c}}}}}}}c{}}{{{b{{AKh{}{{AKn{c}}}}}}{b{{El{Dh}}}}}c{}}{{{b{{AKh{}{{AKn{c}}}}}}AL`}c{}}{{{b{{AKh{}{{AKn{c}}}}}}{Dj{Dh}}}c{}}{{{b{{AKh{}{{AKn{c}}}}}}c}{{Hd{{El{Dh}}}}}{}}{{{b{{AKh{}{{AKn{c}}}}}}c}{{Dj{Dh}}}{}}{{{b{{AKh{}{{AKn{c}}}}}}{b{c}}}{{b{{El{Dh}}}}}{}}`{{{b{c}}}{{b{{Ab{e}}}}}{}{}}{{{b{dc}}}{{b{d{Ab{e}}}}}{}{}}0{{{b{c}}}e{}{}}{{{b{c}}}Ad{}}{c{{Af{e}}}{}{}}0{{{b{c}}}Ah{}}>`````{{{b{c}}}{{b{e}}}{}{}}00{{{b{dc}}}{{b{de}}}{}{}}00{{{b{dc}}}{{Lf{{b{de}}}}}{}{}}{{{b{ALb}}}ALb}{{{b{c}}{b{de}}}An{}{}}{cLf{}}{{}ALb}{{{b{AL`}}b}Cn}{{{b{ALb}}{b{dh}}}j}{{{b{AL`}}{b{dh}}}j}{cc{}}00{{{b{AL`}}{b{dc}}}AnAId}{ce{}{}}000{{{b{AL`}}}c{}}{{{b{dALd}}}{{A`{Dh}}}}{{{b{{AKh{}{{AKn{c}}}}}}{b{c}}}c{}}{{{b{ALb}}{b{c}}}c{}}{{{b{{AKh{}{{AKn{c}}}}}}}c{}}{{{b{{AKh{}{{AKn{c}}}}}}{b{{El{Dh}}}}}c{}}{{{b{{AKh{}{{AKn{c}}}}}}AL`}c{}}{{{b{ALb}}AL`}c{}}{{{b{{AKh{}{{AKn{c}}}}}}{Dj{Dh}}}c{}}{{{b{{AKh{}{{AKn{c}}}}}}c}{{Hd{{El{Dh}}}}}{}}{{{b{{AKh{}{{AKn{c}}}}}}c}{{Dj{Dh}}}{}}{{{b{{AKh{}{{AKn{c}}}}}}{b{c}}}{{b{{El{Dh}}}}}{}}{{{b{ALb}}{b{c}}}{{b{{El{Dh}}}}}{}}{{{b{ALd}}}{{Bd{Dl{A`{Dl}}}}}}{{{b{AL`}}}{{Hd{{El{Dh}}}}}}{{{b{c}}}{{b{{Ab{e}}}}}{}{}}00{{{b{dc}}}{{b{d{Ab{e}}}}}{}{}}00000{{{b{c}}}e{}{}}{{{b{AL`}}}{{Dj{Dh}}}}{c{{Af{e}}}{}{}}00000{{{b{c}}}Ah{}}00{ce{}{}}00`{{{b{{AKf{c}}}}}{{b{{El{Dh}}}}}AKh}{{{b{{AKf{c}}}}}{{b{Hn}}}AKh}{{{b{d{AKf{c}}}}}AnAKh}{{{b{{AKf{c}}}}e}{{AKf{e}}}AKhAKh}{{{b{Hn}}c}{{AKf{c}}}AKh}{{{b{{El{E`}}}}}{{Af{AKfALf}}}}{{{b{{El{E`}}}}c}{{Af{{AKf{c}}ALf}}}AKh}{{{b{{El{E`}}}}}AKf}{{{b{{El{E`}}}}c}{{AKf{c}}}AKh}{{{Dj{Dh}}}{{Af{AKfK`}}}}{{{Dj{Dh}}c}{{Af{{AKf{c}}K`}}}AKh}{{{b{{El{Dh}}}}}AKf}{{{b{{El{Dh}}}}c}{{AKf{c}}}AKh}{{{b{{El{Dh}}}}}{{Af{AKfALh}}}}{{{b{{El{Dh}}}}c}{{Af{{AKf{c}}ALh}}}AKh}{{{Dj{Dh}}}AKf}{{{Dj{Dh}}c}{{AKf{c}}}AKh}54{{{b{d{AKf{c}}}}DlKd}AnAKh}{{{b{d{AKf{c}}}}Dl{b{Hn}}}AnAKh}{{{AKf{c}}}{{Hd{Hn}}}AKh}{{{AKf{c}}}{{Dj{Dh}}}AKh}{{{AKf{c}}e}{{AKf{e}}}AKhAKh}{{{AKf{c}}}{{b{dHn}}}AKh}{{}AKf}{c{{AKf{c}}}AKh}{{{b{d{AKf{c}}}}}{{A`{Kd}}}AKh}{{{b{d{AKf{c}}}}Kd}AnAKh}{{{b{d{AKf{c}}}}{b{Hn}}}AnAKh}{{{b{d{AKf{c}}}}Dl}KdAKh}{{{b{d{AKf{c}}}}e}AnAKh{{Fh{Kd}{{Fd{Cn}}}}}}{{{b{d{AKf{c}}}}Dl}{{AKf{c}}}AKh}{{{b{d{AKf{c}}}}Dle}{{AKf{e}}}AKhAKh}{{{b{{AKf{c}}}}e}{{AKf{e}}}AKhAKh}{{{b{d{AKf{c}}}}Dl}AnAKh}`{{{b{c}}}{{b{e}}}{}{}}{{{b{dc}}}{{b{de}}}{}{}}{cc{}}{ce{}{}}{{{Db{{Db{Dh}}}}}ALj}{{{b{c}}}{{b{{Ab{e}}}}}{}{}}{{{b{dc}}}{{b{d{Ab{e}}}}}{}{}}0{c{{Af{e}}}{}{}}0{{{b{c}}}Ah{}}5`{{{b{ALl}}}{{b{{Ab{ALl}}}}}}{{{b{dALl}}}{{b{d{Ab{ALl}}}}}}0``````````:9{{{b{{El{Dh}}}}}{{Af{{Dj{Dh}}ALn}}}}{{{b{{El{Dh}}}}}Ad}{{{b{ALn}}{b{ALn}}}Cn}{{{b{ALn}}{b{dh}}}j}0<;988{{{b{c}}}Ad{}}887<","D":"DAl","p":[[1,"reference"],[0,"mut"],[5,"Error",28],[5,"Formatter",2406],[8,"Result",2406],[10,"Into",2407],[10,"Error",2408],[6,"Option",2409],[20,"MaybeUninit",2410],[5,"String",2411],[6,"Result",2412],[5,"TypeId",2413],[5,"ClientContinuerS3",48],[5,"SigninResponseS3",48],[1,"unit"],[5,"SigninRequestS1",48],[5,"ClientContinuerS1",48],[1,"tuple"],[8,"Result",28],[5,"SigninResponseS1",48],[5,"SigninRequestS2",48],[5,"ClientContinuerS2",48],[5,"SigninResponseS2",48],[5,"SigninRequestS3",48],[5,"ServerS2Params",48],[5,"ServerS3Params",48],[5,"SignupRequest",205],[5,"StoredUnverifiedUserData",205],[10,"UnsignedBigint",247],[5,"U320",247],[1,"bool"],[10,"Part",247],[1,"array"],[1,"u64"],[5,"Encoder",276],[1,"u8"],[5,"Vec",2414],[1,"usize"],[1,"u128"],[1,"u16"],[1,"u32"],[5,"BinaryHeapChain",297,2415],[5,"BinaryHeap",2416],[10,"Ord",2417],[5,"VecChain",297,2418],[1,"slice"],[10,"FnOnce",2419],[5,"SliceBoxChain",297,2420],[5,"ArrayChain",297,2421],[17,"Output"],[6,"Ordering",2417],[10,"FnMut",2419],[5,"StringChain",297,2422],[10,"Clone",2423],[10,"PartialEq",2417],[10,"Copy",2424],[10,"RangeBounds",2425],[10,"PartialOrd",2417],[10,"Default",2426],[5,"Drain",2427],[5,"SliceRefChain",297,2428],[5,"SliceMutChain",297,2429],[10,"Debug",2406],[5,"VecRefChain",297,2430],[5,"VecMutChain",297,2431],[5,"Box",2432],[5,"ArrayRefChain",297,2433],[5,"ArrayMutChain",297,2434],[5,"StringRefChain",297,2435],[5,"StringMutChain",297,2436],[1,"str"],[5,"StrBoxChain",297,2437],[5,"StrRefChain",297,2438],[5,"StrMutChain",297,2439],[5,"VecDeque",2440],[5,"VecDequeChain",297,2441],[5,"LinkedList",2442],[5,"LinkedListChain",297,2443],[5,"HashMap",2444],[5,"HashMapChain",297,2445],[5,"HashSet",2446],[5,"HashSetChain",297,2447],[5,"BTreeMap",2448],[5,"BTreeMapChain",297,2449],[5,"BTreeSet",2450],[5,"BTreeSetChain",297,2451],[5,"BitstreamEncoderChain",297,2452],[5,"FromUtf8Error",2411],[10,"SliceIndex",2453],[1,"char"],[17,"Chain"],[10,"IntoChainer",297,2454],[10,"From",2407],[5,"Range",2425],[1,"f64"],[1,"f32"],[17,"Item"],[10,"IntoIter",1036,2455],[5,"IterAdapter",1036,2456],[5,"Splice",2457],[5,"Windows",2458],[5,"PeekMut",2416],[5,"Builder",920],[5,"Tick",883],[5,"TimeDelta",1869,2459],[5,"Local",1869,2460],[5,"DateTime",1869,2461],[5,"ClockTimer",883],[10,"Future",2462],[5,"BuilderWithInterval",920],[5,"BuilderWithStart",920],[5,"BuilderWithEnd",920],[10,"TimeZone",2463],[10,"Fn",2419],[10,"Send",2424],[10,"Sync",2424],[5,"Handle",2464],[6,"DecodeError",979],[5,"GeneratedID",1002],[1,"i64"],[8,"NonZeroU64",2465],[5,"IDGenerator",1002],[17,"Iter"],[10,"AsWiwiIter",1036,2456],[10,"Iter",1036],[17,"Iterator"],[10,"AsStdIterator",1036,2456],[10,"Iterator",2466],[10,"IntoWiwiIter",1036,2456],[10,"IntoStdIterator",1036,2456],[5,"SizeHint",1036,2467],[5,"Empty",1036,2468],[6,"SizeHintBound",1036,2467],[10,"DoubleEndedIter",1036,2469],[5,"FromFn",1036,2470],[5,"Map",1036,2471],[5,"Peek",1036,2472],[5,"RepeatPerItem",1036,2473],[5,"Rev",1036,2474],[5,"Tuple32",1036,2475],[5,"Tuple31",1036,2475],[5,"Tuple30",1036,2475],[5,"Tuple29",1036,2475],[5,"Tuple28",1036,2475],[5,"Tuple27",1036,2475],[5,"Tuple26",1036,2475],[5,"Tuple25",1036,2475],[5,"Tuple24",1036,2475],[5,"Tuple23",1036,2475],[5,"Tuple22",1036,2475],[5,"Tuple21",1036,2475],[5,"Tuple20",1036,2475],[5,"Tuple19",1036,2475],[5,"Tuple18",1036,2475],[5,"Tuple17",1036,2475],[5,"Tuple16",1036,2475],[5,"Tuple15",1036,2475],[5,"Tuple14",1036,2475],[5,"Tuple13",1036,2475],[5,"Tuple12",1036,2475],[5,"Tuple11",1036,2475],[5,"Tuple10",1036,2475],[5,"Tuple9",1036,2475],[5,"Tuple8",1036,2475],[5,"Tuple7",1036,2475],[5,"Tuple6",1036,2475],[5,"Tuple5",1036,2475],[5,"Tuple4",1036,2475],[5,"Tuple3",1036,2475],[5,"Tuple2",1036,2475],[5,"Tuple1",1036,2475],[10,"DoubleEndedIterator",2476],[17,"PeekItem"],[10,"Peekable",1036,2472],[5,"LazyWrap",1792],[10,"Sized",2424],[10,"AsMut",2407],[10,"AsRef",2407],[10,"Display",2406],[6,"LazyWrapState",1792],[5,"Script",1832,2477],[5,"ScriptBuilder",1832,2477],[10,"Dynamic",1857],[10,"Static",1857],[5,"Duration",2478],[5,"FixedOffset",2479],[5,"Months",2480],[5,"Days",2481],[5,"Date",2482],[5,"NaiveDate",2483],[5,"Utc",2484],[1,"i32"],[5,"Error",2406],[5,"StrftimeItems",2485],[5,"DelayedFormat",2486],[6,"Item",2487],[10,"Borrow",2488],[5,"SystemTime",2489],[5,"NaiveDateTime",2490],[5,"OutOfRangeError",2459],[5,"ParseError",2487],[10,"Hasher",2491],[5,"IsoWeek",2492],[6,"LocalResult",2463],[5,"NaiveTime",2493],[6,"SecondsFormat",2486],[6,"Weekday",2494],[10,"BufferRead",2109],[8,"Result",2125],[10,"BufferWrite",2109],[10,"Deserialise",2121],[6,"Error",2125],[10,"ResultExt",2125],[10,"ToString",2411],[10,"OptionExt",2125],[5,"Marker",2166],[5,"SerialiseOptions",2185],[10,"Serialise",2185],[5,"String",2207,2325],[10,"Pool",2207,2260],[5,"Path",2495],[5,"OsStr",2496],[17,"Raw"],[5,"SlicesWrap",2260],[5,"GlobalPool",2260,2497],[5,"SlicesWrapIter",2260],[5,"FromUtf16Error",2411],[5,"Utf8Error",2498],[5,"Board",2362],[10,"ToMaybeUninit",2375],[6,"DecodeError",2379],[15,"HardBound",1790],[15,"Estimate",1790],[15,"Str",2164],[15,"String",2164]],"r":[[297,2421],[298,2434],[299,2433],[300,2449],[301,2451],[302,2415],[303,2452],[305,2445],[306,2447],[307,2454],[308,2443],[309,2420],[310,2429],[311,2428],[312,2437],[313,2439],[314,2438],[315,2422],[316,2436],[317,2435],[318,2418],[319,2441],[320,2431],[321,2430],[1036,2456],[1037,2456],[1038,2469],[1039,2468],[1041,2470],[1043,2455],[1044,2456],[1045,2456],[1052,2456],[1055,2471],[1056,2472],[1058,2472],[1059,2473],[1060,2474],[1061,2467],[1062,2467],[1063,2475],[1064,2475],[1065,2475],[1066,2475],[1067,2475],[1068,2475],[1069,2475],[1070,2475],[1071,2475],[1072,2475],[1073,2475],[1074,2475],[1075,2475],[1076,2475],[1077,2475],[1078,2475],[1079,2475],[1080,2475],[1081,2475],[1082,2475],[1083,2475],[1084,2475],[1085,2475],[1086,2475],[1087,2475],[1088,2475],[1089,2475],[1090,2475],[1091,2475],[1092,2475],[1093,2475],[1094,2475],[1265,2468],[1313,2470],[1832,2477],[1833,2477],[1842,2477],[1859,2499],[1869,883],[1870,2461],[1871,1002],[1872,1002],[1873,1792],[1874,1792],[1875,2460],[1878,2325],[1879,883],[1880,2459],[1919,974],[1920,974],[1921,974],[1922,974],[1923,979],[1924,2379],[1932,979],[1933,979],[1934,2379],[1972,978],[2179,0],[2180,0],[2181,0],[2182,0],[2183,0],[2184,0],[2207,2497],[2208,2260],[2210,2325],[2260,2497]],"b":[[32,"impl-Display-for-Error"],[33,"impl-Debug-for-Error"],[329,"impl-AsMut%3CVec%3CT%3E%3E-for-VecChain%3CT%3E"],[330,"impl-AsMut%3C%5BT%5D%3E-for-VecChain%3CT%3E"],[333,"impl-AsRef%3C%5BT%5D%3E-for-VecChain%3CT%3E"],[334,"impl-AsRef%3CVec%3CT%3E%3E-for-VecChain%3CT%3E"],[671,"impl-VecChain%3Cf64%3E"],[672,"impl-VecChain%3Cf32%3E"],[990,"impl-Debug-for-DecodeError"],[991,"impl-Display-for-DecodeError"],[1405,"impl-Iter-for-IterAdapter%3CI%3E"],[1406,"impl-Iterator-for-IterAdapter%3CI%3E"],[1446,"impl-DoubleEndedIterator-for-IterAdapter%3CI%3E"],[1447,"impl-DoubleEndedIter-for-IterAdapter%3CI%3E"],[1455,"impl-Iterator-for-IterAdapter%3CI%3E"],[1456,"impl-Iter-for-IterAdapter%3CI%3E"],[1806,"impl-Debug-for-LazyWrap%3CT,+F%3E"],[1807,"impl-Display-for-LazyWrap%3CT,+F%3E"],[1884,"impl-Add%3CDuration%3E-for-DateTime%3CTz%3E"],[1885,"impl-Add%3CTimeDelta%3E-for-DateTime%3CTz%3E"],[1886,"impl-Add%3CFixedOffset%3E-for-DateTime%3CTz%3E"],[1887,"impl-Add%3CMonths%3E-for-DateTime%3CTz%3E"],[1888,"impl-Add%3CDays%3E-for-DateTime%3CTz%3E"],[1890,"impl-AddAssign%3CDuration%3E-for-DateTime%3CTz%3E"],[1891,"impl-AddAssign%3CTimeDelta%3E-for-DateTime%3CTz%3E"],[1926,"impl-Default-for-DateTime%3CFixedOffset%3E"],[1927,"impl-Default-for-DateTime%3CUtc%3E"],[1928,"impl-Default-for-DateTime%3CLocal%3E"],[1942,"impl-Display-for-TimeDelta"],[1943,"impl-Debug-for-TimeDelta"],[1944,"impl-Display-for-DateTime%3CTz%3E"],[1945,"impl-Debug-for-DateTime%3CTz%3E"],[1950,"impl-From%3CDateTime%3CFixedOffset%3E%3E-for-DateTime%3CUtc%3E"],[1952,"impl-From%3CSystemTime%3E-for-DateTime%3CUtc%3E"],[1953,"impl-From%3CDateTime%3CUtc%3E%3E-for-DateTime%3CFixedOffset%3E"],[1954,"impl-From%3CDateTime%3CLocal%3E%3E-for-DateTime%3CFixedOffset%3E"],[1955,"impl-From%3CSystemTime%3E-for-DateTime%3CLocal%3E"],[1956,"impl-From%3CDateTime%3CLocal%3E%3E-for-DateTime%3CUtc%3E"],[1957,"impl-From%3CDateTime%3CUtc%3E%3E-for-DateTime%3CLocal%3E"],[1958,"impl-From%3CDateTime%3CFixedOffset%3E%3E-for-DateTime%3CLocal%3E"],[1964,"impl-FromStr-for-DateTime%3CUtc%3E"],[1965,"impl-FromStr-for-DateTime%3CLocal%3E"],[1966,"impl-FromStr-for-DateTime%3CFixedOffset%3E"],[2024,"impl-Sub%3CMonths%3E-for-DateTime%3CTz%3E"],[2025,"impl-Sub-for-DateTime%3CTz%3E"],[2026,"impl-Sub%3CDuration%3E-for-DateTime%3CTz%3E"],[2027,"impl-Sub%3CTimeDelta%3E-for-DateTime%3CTz%3E"],[2028,"impl-Sub%3C%26DateTime%3CTz%3E%3E-for-DateTime%3CTz%3E"],[2029,"impl-Sub%3CDays%3E-for-DateTime%3CTz%3E"],[2030,"impl-Sub%3CFixedOffset%3E-for-DateTime%3CTz%3E"],[2032,"impl-SubAssign%3CTimeDelta%3E-for-DateTime%3CTz%3E"],[2033,"impl-SubAssign%3CDuration%3E-for-DateTime%3CTz%3E"],[2035,"impl-Sum-for-TimeDelta"],[2036,"impl-Sum%3C%26TimeDelta%3E-for-TimeDelta"],[2151,"impl-Display-for-Error"],[2152,"impl-Debug-for-Error"],[2211,"impl-Add%3CString%3CP2%3E%3E-for-%26String%3CP%3E"],[2212,"impl-Add%3CString%3CP2%3E%3E-for-String%3CP%3E"],[2213,"impl-Add%3C%26str%3E-for-%26String%3CP%3E"],[2214,"impl-Add%3C%26String%3E-for-String%3CP%3E"],[2215,"impl-Add%3CString%3E-for-String%3CP%3E"],[2216,"impl-Add%3C%26String%3CP2%3E%3E-for-%26String%3CP%3E"],[2217,"impl-Add%3C%26str%3E-for-String%3CP%3E"],[2218,"impl-Add%3CString%3E-for-%26String%3CP%3E"],[2219,"impl-Add%3C%26String%3E-for-%26String%3CP%3E"],[2220,"impl-Add%3C%26String%3CP2%3E%3E-for-String%3CP%3E"],[2221,"impl-AddAssign%3C%26String%3CP2%3E%3E-for-String%3CP%3E"],[2222,"impl-AddAssign%3C%26str%3E-for-String%3CP%3E"],[2223,"impl-AddAssign%3CString%3CP2%3E%3E-for-String%3CP%3E"],[2224,"impl-AsRef%3Cstr%3E-for-String%3CP%3E"],[2225,"impl-AsRef%3CPath%3E-for-String%3CP%3E"],[2226,"impl-AsRef%3COsStr%3E-for-String%3CP%3E"],[2227,"impl-AsRef%3C%5Bu8%5D%3E-for-String%3CP%3E"],[2235,"impl-Display-for-String%3CP%3E"],[2236,"impl-Debug-for-String%3CP%3E"],[2237,"impl-From%3C(%26str,+P)%3E-for-String%3CP%3E"],[2239,"impl-From%3C%26str%3E-for-String"],[2394,"impl-Display-for-DecodeError"],[2395,"impl-Debug-for-DecodeError"]],"c":"OjAAAAEAAAAAAAoAEAAAAHsHfwepB7QHuQfBB8QH5gf6BxMIKAg=","e":"OzAAAAEAAFgHjQABAAIACQACAA0AAgARAAUAGAABABsABwAkAAAAJgAIADEAJQBiAAEAbwBoANoAAQDeAAAA4AAjAAUBAwAKAQ0AGgEJAEMBbACxAQEAtQEAALcBAAC5AQEAvQEAAL8BAQDCAQAAxQEAAMcBAADJAQAAywEBAM4BAADQAQAA0gEAANUBAADXAQAA2QEBANwBAADeAQwAAgIEAAkCEQAcAgMAIQIGACkCAwAuAgMAMwIIAD0CDwBOAhAAYAIEAGYCMgCaAg0AqQIKALgCTwAJA2EAbAMHAHYDAwB8AwAAigMFAJEDBwCaAwoArwMbANoDAQDfAwEA4wMIAO0DBgD2AwAA+AMAAPwDEAAPBAEAEgQAABQEAAAXBAUAHgQIAEkEUgCdBAAAnwQmAMcEAADJBCYA8gQGACIFAABNBQEAUAVcAK4FKQDZBSAB+wYBAP4GAgAFBwgADwcBABkHFQAzBw4ARAcAAEkHAABMBwIAUAcDAFcHAQBcBw4AcwcHAH0HAQCABxUAmAcDAKEHAACkBwAAqwcAAK0HAgC1BwMAvgcAAMMHAADFBwIAygcAAMwHAADYBwUA4gcAAOQHAQDoBwoA9AcBAAAICwAQCAEAFAgAABYIAgAaCAIAIQgGADUIAAA4CDEAbAgNAHwIFgCVCAoApAgaAMAIAADMCAgA2ggNAOsIAADvCAIA8wgAAPcIAAD8CAEA/wgJAAoJCwAXCSYAQAkJAEsJAABWCQEAWgkCAF8JBwA="}],\ ["wiwiwiwiwi",{"t":"Y","n":["MemoryUsage"],"q":[[0,"wiwiwiwiwi"]],"i":[0],"f":"`","D":"`","p":[],"r":[],"b":[],"c":"OjAAAAAAAAA=","e":"OjAAAAEAAAAAAAEAEAAAAAAAAQA="}]\ ]')); if (typeof exports !== 'undefined') exports.searchIndex = searchIndex; diff --git a/search.desc/wiwi/wiwi-desc-0-.js b/search.desc/wiwi/wiwi-desc-0-.js index 9c224cba8..95f9a011b 100644 --- a/search.desc/wiwi/wiwi-desc-0-.js +++ b/search.desc/wiwi/wiwi-desc-0-.js @@ -1 +1 @@ -searchState.loadedDescShard("wiwi", 0, "wiwi\nChaining APIs for common Rust types\nAn interval tracking clock\nA debounced function; or a function that won’t actually …\nh\nFast and efficient implementation of hex encoding.\nWrapper for initialisation function, initialising it only …\nPrelude module, exporting types from enabled features\nGlobal immutable string pool implementation\nFast and efficient implementation of Z85\nReturns the argument unchanged.\nCalls U::from(self).\nSignin flow functions\nSignup flow functions\nReturns the argument unchanged.\nReturns the argument unchanged.\nReturns the argument unchanged.\nReturns the argument unchanged.\nReturns the argument unchanged.\nReturns the argument unchanged.\nReturns the argument unchanged.\nReturns the argument unchanged.\nReturns the argument unchanged.\nReturns the argument unchanged.\nReturns the argument unchanged.\nCalls U::from(self).\nCalls U::from(self).\nCalls U::from(self).\nCalls U::from(self).\nCalls U::from(self).\nCalls U::from(self).\nCalls U::from(self).\nCalls U::from(self).\nCalls U::from(self).\nCalls U::from(self).\nCalls U::from(self).\nReturns the argument unchanged.\nReturns the argument unchanged.\nCalls U::from(self).\nCalls U::from(self).\nCall with data received from the client\nReturns the argument unchanged.\nCalls U::from(self).\nReturns the argument unchanged.\nCalls U::from(self).\nWrites the specified amount of bits from the provided u128.\nWrites the specified amount of bits from the provided u16.\nWrites the specified amount of bits from the provided u32.\nWrites the specified amount of bits from the provided u64.\nWrites the specified amount of bits from the provided u8.\nWrites the specified amount of bits from the provided …\nstatus: started a tiny bit\nstatus: not started\nstatus: not started\nstatus: not started\nstatus: not started\nstatus: started a bit\nstatus: need to implement the underlying bit stream …\nThe preferred chainer of this type\nstatus: not started\nstatus: not started\nTrait providing into_chainer, to convert any supported …\nstatus: not started\nstatus: not started\nstatus: started a bit\nstatus: started a bit\nstatus: not started\nstatus: not started\nstatus: not started\nstatus: a bit of basic functionality\nstatus: not started\nstatus: not started\nstatus: significant functionality implemented, fully …\nstatus: not started\nstatus: not started\nstatus: not started\nReturns the argument unchanged.\nReturns the argument unchanged.\nReturns the argument unchanged.\nReturns the argument unchanged.\nReturns the argument unchanged.\nReturns the argument unchanged.\nReturns the argument unchanged.\nReturns the argument unchanged.\nReturns the argument unchanged.\nReturns the argument unchanged.\nReturns the argument unchanged.\nReturns the argument unchanged.\nReturns the argument unchanged.\nReturns the argument unchanged.\nReturns the argument unchanged.\nReturns the argument unchanged.\nReturns the argument unchanged.\nReturns the argument unchanged.\nReturns the argument unchanged.\nReturns the argument unchanged.\nReturns the argument unchanged.\nReturns the argument unchanged.\nReturns the argument unchanged.\nCalls U::from(self).\nCalls U::from(self).\nCalls U::from(self).\nCalls U::from(self).\nCalls U::from(self).\nCalls U::from(self).\nCalls U::from(self).\nCalls U::from(self).\nCalls U::from(self).\nCalls U::from(self).\nCalls U::from(self).\nCalls U::from(self).\nCalls U::from(self).\nCalls U::from(self).\nCalls U::from(self).\nCalls U::from(self).\nCalls U::from(self).\nCalls U::from(self).\nCalls U::from(self).\nCalls U::from(self).\nCalls U::from(self).\nCalls U::from(self).\nCalls U::from(self).\nConverts self into its associated chain type\nConverts self into its associated chain type\nWrites true into the output if the vector contains no …\nWrites true into the output if the vector contains no …\nConsumes self and leaks it, returning a mutable reference …\nWrites the number of elements (also known as the length) …\nWrites the number of elements (also known as the length) …\nCreates a new vector chain without allocating any capacity.\nUnwraps and retrieves the underlying Vec out.\nBorrow this vector chain mutably as a SliceMutChain.\nBorrow this vector chain immutably as a SliceRefChain.\nSorts, then dedups, the vector chain.\nCalls the provided closure with the spare capacity of the …\nSplits the left side off and writes it to another …\nSplits the left side off and writes it to another …\nSplits the right side off and writes it to another …\nSplits the right side off and writes it to another …\nUnsafetly truncates the string, with no checks at all…\nCreates a new vector, and preallocate some memory.\nAn interval tracking clock. Takes a start time, an end …\nTiming information for one tick\nClockTimer builder structs\nGets a ClockTimer builder\nReturns if this tick was delayed. This tick is considered …\nGet elapsed time since the start of this timer\nGet end time of this timer\nReturns the argument unchanged.\nReturns the argument unchanged.\nCalls U::from(self).\nCalls U::from(self).\nReturns if this tick is past due. This tick is considered …\nGet remaining runtime of this timer\nConvenience function, equivalent to running a …\nGet start time of this timer\nRuns the next tick and returns timing information for it, …\nGet time of this tick\nGet total runtime of this timer, including elapsed time …\nBuilder for ClockTimer.\nBuilds and returns a ClockTimer\nReturns the argument unchanged.\nReturns the argument unchanged.\nReturns the argument unchanged.\nReturns the argument unchanged.\nCalls U::from(self).\nCalls U::from(self).\nCalls U::from(self).\nCalls U::from(self).\nNew builder. You can also obtain a builder through …\nSets a duration to run this ClockTimer for. Internally, …\nSets the end date/time of the ClockTimer. ClockTimer will …\nSets interval to run at, or the time between ticks.\nSets the start date/time of the ClockTimer, or in other …\nReturns a new function that debounces calls to the passed …\nReturns a new function that debounces calls to the passed …\nReturns a new function that debounces calls to the passed …\nReturns a new function that debounces calls to the passed …\nh\nErrors that can be encountered on decoding data (encoding …\nInvalid character. Characters are only allowed to be in 0-9…\nInvalid length. Length is expected to be a multiple of two\nLength of encoding table. Not actually used in …\nEncoding table of lowercased characters. Not actually used …\nEncoding table of uppercased characters. Not actually used …\nDecodes a slice of hex bytes into a byte vector. This …\nEncodes a slice of bytes into a String, using lowercase …\nEncodes a slice of bytes into a String, using uppercase …\nReturns the argument unchanged.\nCalls U::from(self).\ncounting from the most significant to least significant …\nReturns the argument unchanged.\nReturns the argument unchanged.\nSafety\nSafety\nCalls U::from(self).\nCalls U::from(self).\nAllows any wiwi iter to be borrowed as an std iterator. …\nAllows any std iterator to be borrowed as a wiwi iter. …\nOnly an estimation (unreliable for unsafe operations).\nHard bound, unsafe, reliable information for use in unsafe …\nAllows any wiwi iter, or anything capable of converting to …\nAllows any std iterator, or anything capable of converting …\nAn adapter that wraps either a std Iterator or a wiwi Iter…\nOne side of the bound of size hint.\nIter for tuples of size 1.\nIter for tuples of size 10.\nIter for tuples of size 11.\nIter for tuples of size 12.\nIter for tuples of size 13.\nIter for tuples of size 14.\nIter for tuples of size 15.\nIter for tuples of size 16.\nIter for tuples of size 17.\nIter for tuples of size 18.\nIter for tuples of size 19.\nIter for tuples of size 2.\nIter for tuples of size 20.\nIter for tuples of size 21.\nIter for tuples of size 22.\nIter for tuples of size 23.\nIter for tuples of size 24.\nIter for tuples of size 25.\nIter for tuples of size 26.\nIter for tuples of size 27.\nIter for tuples of size 28.\nIter for tuples of size 29.\nIter for tuples of size 3.\nIter for tuples of size 30.\nIter for tuples of size 31.\nIter for tuples of size 32.\nIter for tuples of size 4.\nIter for tuples of size 5.\nIter for tuples of size 6.\nIter for tuples of size 7.\nIter for tuples of size 8.\nIter for tuples of size 9.\nUnknown bound. Anything goes :p\nBorrow the std iterator as a wiwi iter.\nBorrow the wiwi iter as an std iterator.\nConverts the std iterator into a wiwi iter.\nConverts the wiwi iter into a std iterator.\nConsumes the iter and returns the number of items that …\nReturns default size hint, or (Unknown, Unknown).\nReturns the argument unchanged.\nReturns the argument unchanged.\nReturns the argument unchanged.\nReturns the argument unchanged.\nReturns the argument unchanged.\nReturns the argument unchanged.\nReturns the argument unchanged.\nReturns the argument unchanged.\nReturns the argument unchanged.\nReturns the argument unchanged.\nReturns the argument unchanged.\nReturns the argument unchanged.\nReturns the argument unchanged.\nReturns the argument unchanged.\nReturns the argument unchanged.\nReturns the argument unchanged.\nReturns the argument unchanged.\nReturns the argument unchanged.\nReturns the argument unchanged.\nReturns the argument unchanged.\nReturns the argument unchanged.\nReturns the argument unchanged.\nReturns the argument unchanged.\nReturns the argument unchanged.\nReturns the argument unchanged.\nReturns the argument unchanged.\nReturns the argument unchanged.\nReturns the argument unchanged.\nReturns the argument unchanged.\nReturns the argument unchanged.\nReturns the argument unchanged.\nReturns the argument unchanged.\nReturns the argument unchanged.\nReturns the argument unchanged.\nReturns the argument unchanged.\nReturns the argument unchanged.\nReturns the argument unchanged.\nReturns the argument unchanged.\nReturns the argument unchanged.\nReturns the argument unchanged.\nSafety\nCalls U::from(self).\nCalls U::from(self).\nCalls U::from(self).\nCalls U::from(self).\nCalls U::from(self).\nCalls U::from(self).\nCalls U::from(self).\nCalls U::from(self).\nCalls U::from(self).\nCalls U::from(self).\nCalls U::from(self).\nCalls U::from(self).\nCalls U::from(self).\nCalls U::from(self).\nCalls U::from(self).\nCalls U::from(self).\nCalls U::from(self).\nCalls U::from(self).\nCalls U::from(self).\nCalls U::from(self).\nCalls U::from(self).\nCalls U::from(self).\nCalls U::from(self).\nCalls U::from(self).\nCalls U::from(self).\nCalls U::from(self).\nCalls U::from(self).\nCalls U::from(self).\nCalls U::from(self).\nCalls U::from(self).\nCalls U::from(self).\nCalls U::from(self).\nCalls U::from(self).\nCalls U::from(self).\nCalls U::from(self).\nCalls U::from(self).\nCalls U::from(self).\nCalls U::from(self).\nCalls U::from(self).\nCalls U::from(self).\nConsumes self and returns the underlying iter.\nTakes every element emitted by the underlying iter, and …\nReturns (lower, upper) bounds. Use this to match on a size …\nSafety\nSafety\nContains previously initialised value\nA lazily initialised data wrapper that initialises itself …\nReturned by LazyWrap::into_inner, containing the …\nValue is not initialised, contains initialisation function.\nRuns initialisation if the value is not initialised yet, …\nReturns the argument unchanged.\nReturns the argument unchanged.\nCalls U::from(self).\nCalls U::from(self).\nFetch the value if its initialised, or return the …\nEnsures that the value is initialised, then returns the …\nReturns true or false, depending on if the value is …\nCreates a new uninitialised instance that will be …\nReturns the argument unchanged.\nReturns the argument unchanged.\nCalls U::from(self).\nCalls U::from(self).\nTrait implemented by types that at compile time, for …\nThe memory usage of this type in bytes\nTrait implemented by types that, at compile time, use a …\nCalculate the memory usage of this value in bytes, …\nCalculate the memory usage of the value in bytes, but only …\nFetches the dynamically calculated memory usage of a value.\nFetches the statically known memory usage of a type.\nFetches the statically known memory usage of a value.\nISO 8601 combined date and time with time zone.\nThe local timescale.\nThe maximum possible DateTime<Utc>.\nThe minimum possible DateTime<Utc>.\nTime duration with nanosecond precision.\nThe Unix Epoch, 1970-01-01 00:00:00 UTC.\nReturns the TimeDelta as an absolute (non-negative) value.\nAdd two TimeDeltas, returning None if overflow occurred.\nAdd a duration in Days to the date part of the DateTime.\nAdds given Months to the current date and time.\nAdds given TimeDelta to the current date and time.\nSubtract two TimeDeltas, returning None if overflow …\nSubtract a duration in Days from the date part of the …\nSubtracts given Months from the current date and time.\nSubtracts given TimeDelta from the current date and time.\nRetrieves the date component with an associated timezone.\nRetrieves the date component.\nMakes a new TimeDelta with the given number of days.\nFix the offset from UTC to its current value, dropping the …\nFormat a TimeDelta using the ISO 8601 format\nFormats the combined date and time per the specified …\nFormats the combined date and time with the specified …\nReturns the argument unchanged.\nReturns the argument unchanged.\nConvert this DateTime<Local> instance into a …\nConvert this DateTime<Utc> instance into a …\nConvert this DateTime<Local> instance into a DateTime<Utc> …\nConvert this DateTime<Utc> instance into a DateTime<Local> …\nConvert this DateTime<FixedOffset> instance into a …\nConvert this DateTime<FixedOffset> instance into a …\nReturns the argument unchanged.\nMakes a new DateTime from a NaiveDateTime in local time …\nMakes a new DateTime from its components: a NaiveDateTime …\nCreates a TimeDelta object from std::time::Duration\nMakes a new DateTime<Utc> from the number of non-leap …\nCreates a new DateTime<Utc> from the number of non-leap …\nMakes a new DateTime<Utc> from the number of non-leap …\nCreates a new DateTime<Utc> from the number of non-leap …\nMakes a new DateTime from its components: a NaiveDateTime …\nMakes a new TimeDelta with the given number of hours.\nCalls U::from(self).\nCalls U::from(self).\nCalls U::from(self).\nReturns true if the TimeDelta equals TimeDelta::zero().\nThe maximum possible TimeDelta: i64::MAX milliseconds.\nMakes a new TimeDelta with the given number of …\nMakes a new TimeDelta with the given number of …\nThe minimum possible TimeDelta: -i64::MAX milliseconds.\nMakes a new TimeDelta with the given number of minutes.\nReturns a view to the naive local datetime.\nReturns a view to the naive UTC datetime.\nMakes a new TimeDelta with the given number of nanoseconds.\nMakes a new TimeDelta with given number of seconds and …\nReturns a DateTime<Local> which corresponds to the current …\nReturns the total number of whole days in the TimeDelta.\nReturns the total number of whole hours in the TimeDelta.\nReturns the total number of whole microseconds in the …\nReturns the total number of whole milliseconds in the …\nReturns the total number of whole minutes in the TimeDelta.\nReturns the total number of whole nanoseconds in the …\nReturns the total number of whole seconds in the TimeDelta.\nReturns the total number of whole weeks in the TimeDelta.\nRetrieves an associated offset from UTC.\nParses a string from a user-specified format into a …\nParses an RFC 2822 date-and-time string into a …\nParses an RFC 3339 date-and-time string into a …\nParses a string from a user-specified format into a …\nCompare two DateTimes based on their true time, ignoring …\nMakes a new TimeDelta with the given number of seconds.\nSubtracts another DateTime from the current date and time. …\nReturns the number of nanoseconds such that …\nRetrieves the time component.\nReturns the number of non-leap seconds since January 1, …\nReturns the number of non-leap-microseconds since January …\nReturns the number of non-leap-milliseconds since January …\nReturns the number of non-leap-nanoseconds since January …\nReturns the number of non-leap-nanoseconds since January …\nReturns the number of microseconds since the last second …\nReturns the number of milliseconds since the last second …\nReturns the number of nanoseconds since the last second …\nRetrieves an associated time zone.\nReturns an RFC 2822 date and time string such as …\nReturns an RFC 3339 and ISO 8601 date and time string such …\nReturn an RFC 3339 and ISO 8601 date and time string with …\nCreates a std::time::Duration object from a TimeDelta.\nTurn this DateTime into a DateTime<Utc>, dropping the …\nReturns a Date which corresponds to the current date.\nMakes a new TimeDelta with the given number of days.\nMakes a new TimeDelta with the given number of hours.\nMakes a new TimeDelta with the given number of …\nMakes a new TimeDelta with the given number of minutes.\nMakes a new TimeDelta with the given number of seconds.\nMakes a new TimeDelta with the given number of weeks.\nMakes a new TimeDelta with the given number of weeks.\nMakes a new DateTime with the day of month (starting from …\nMakes a new DateTime with the day of month (starting from …\nMakes a new DateTime with the hour number changed.\nMakes a new DateTime with the minute number changed.\nMakes a new DateTime with the month number (starting from …\nMakes a new DateTime with the month number (starting from …\nMakes a new DateTime with nanoseconds since the whole …\nMakes a new DateTime with the day of year (starting from …\nMakes a new DateTime with the day of year (starting from …\nMakes a new DateTime with the second number changed.\nChanges the associated time zone. The returned DateTime …\nMakes a new DateTime with the year number changed, while …\nRetrieve the elapsed years from now to the given DateTime.\nA TimeDelta where the stored seconds and nanoseconds are …\nReturns the argument unchanged.\nCalls U::from(self).\nReturns the argument unchanged.\nCalls U::from(self).\nThe default, global string pool\nTrait implemented by all pools, providing low-level …\nPool’s raw element. Can be anything (that is Sized), but …\nA string, whose contents are stored in a string pool.\nReturns the argument unchanged.\nCalls U::from(self).\nBacking pools. Contains the default global pool, as well …\nClones a raw element. The returned raw element should …\nCreates or retrieves a raw element that represents an …\nCreates or retrieves a raw element for a single slice.\nCreates or retrieves a raw element for multiple slices of …\nCreates or retrieves a raw element for a byte vec\nReturns a UTF-8 byte sequence, in a boxed byte array, that …\nReturns a UTF-8 byte sequence, in a byte vec, that the …\nTakes a pool’s raw element and returns the byte slice …\nThe String type\nThe default, global string pool\nTrait implemented by all pools, providing low-level …\nPool’s raw element. Can be anything (that is Sized), but …\nWraps a slice of slices of bytes. This has a simple Hash …\nIterator for SlicesWrap that returns elements in one slice …\nReturns the argument unchanged.\nReturns the argument unchanged.\nReturns the argument unchanged.\nCalls U::from(self).\nCalls U::from(self).\nCalls U::from(self).\nClones a raw element. The returned raw element should …\nCreates or retrieves a raw element that represents an …\nCreates or retrieves a raw element for a single slice.\nCreates or retrieves a raw element for multiple slices of …\nCreates or retrieves a raw element for a byte vec\nReturns a UTF-8 byte sequence, in a boxed byte array, that …\nReturns a UTF-8 byte sequence, in a byte vec, that the …\nTakes a pool’s raw element and returns the byte slice …\nJoins the slices in sequence, returning a boxed slice.\nJoins the slices in sequence, returning a vector of bytes.\nA string, whose contents are stored in a string pool.\nReturns the argument unchanged.\nCalls U::from(self).\nSafety\nOne frame of this many bytes (4) from the binary data maps …\nErrors that can be encountered on decoding data (encoding …\nOne frame of data contains characters that are too large …\nInvalid character in input data\nInput data has invalid length\nOne frame of this many bytes (5) from the encoded Z85 data …\nTable to map any byte to Option of a number 0-84.\nLength of the decoding table\nTable to map a number 0-84 to a Z85 character.\nLength of the encoding table (ie. number of different …\nDecodes a slice of of a Z85 string back into the source …\nEncodes a slice of bytes into a Z85 string, adding padding …\nReturns the argument unchanged.\nCalls U::from(self).") \ No newline at end of file +searchState.loadedDescShard("wiwi", 0, "wiwi\nChaining APIs for common Rust types\nAn interval tracking clock\nA debounced function; or a function that won’t actually …\nh\nFast and efficient implementation of hex encoding.\nWrapper for initialisation function, initialising it only …\nPrelude module, exporting types from enabled features\nGlobal immutable string pool implementation\nFast and efficient implementation of Z85\nReturns the argument unchanged.\nCalls U::from(self).\nSignin flow functions\nSignup flow functions\nReturns the argument unchanged.\nReturns the argument unchanged.\nReturns the argument unchanged.\nReturns the argument unchanged.\nReturns the argument unchanged.\nReturns the argument unchanged.\nReturns the argument unchanged.\nReturns the argument unchanged.\nReturns the argument unchanged.\nReturns the argument unchanged.\nReturns the argument unchanged.\nCalls U::from(self).\nCalls U::from(self).\nCalls U::from(self).\nCalls U::from(self).\nCalls U::from(self).\nCalls U::from(self).\nCalls U::from(self).\nCalls U::from(self).\nCalls U::from(self).\nCalls U::from(self).\nCalls U::from(self).\nReturns the argument unchanged.\nReturns the argument unchanged.\nCalls U::from(self).\nCalls U::from(self).\nCall with data received from the client\nReturns the argument unchanged.\nCalls U::from(self).\nReturns the argument unchanged.\nCalls U::from(self).\nWrites the specified amount of bits from the provided u128.\nWrites the specified amount of bits from the provided u16.\nWrites the specified amount of bits from the provided u32.\nWrites the specified amount of bits from the provided u64.\nWrites the specified amount of bits from the provided u8.\nWrites the specified amount of bits from the provided …\nstatus: started a tiny bit\nstatus: not started\nstatus: not started\nstatus: not started\nstatus: not started\nstatus: started a bit\nstatus: need to implement the underlying bit stream …\nThe preferred chainer of this type\nstatus: not started\nstatus: not started\nTrait providing into_chainer, to convert any supported …\nstatus: not started\nstatus: not started\nstatus: started a bit\nstatus: started a bit\nstatus: not started\nstatus: not started\nstatus: not started\nstatus: a bit of basic functionality\nstatus: not started\nstatus: not started\nstatus: significant functionality implemented, fully …\nstatus: not started\nstatus: not started\nstatus: not started\nReturns the argument unchanged.\nReturns the argument unchanged.\nReturns the argument unchanged.\nReturns the argument unchanged.\nReturns the argument unchanged.\nReturns the argument unchanged.\nReturns the argument unchanged.\nReturns the argument unchanged.\nReturns the argument unchanged.\nReturns the argument unchanged.\nReturns the argument unchanged.\nReturns the argument unchanged.\nReturns the argument unchanged.\nReturns the argument unchanged.\nReturns the argument unchanged.\nReturns the argument unchanged.\nReturns the argument unchanged.\nReturns the argument unchanged.\nReturns the argument unchanged.\nReturns the argument unchanged.\nReturns the argument unchanged.\nReturns the argument unchanged.\nReturns the argument unchanged.\nCalls U::from(self).\nCalls U::from(self).\nCalls U::from(self).\nCalls U::from(self).\nCalls U::from(self).\nCalls U::from(self).\nCalls U::from(self).\nCalls U::from(self).\nCalls U::from(self).\nCalls U::from(self).\nCalls U::from(self).\nCalls U::from(self).\nCalls U::from(self).\nCalls U::from(self).\nCalls U::from(self).\nCalls U::from(self).\nCalls U::from(self).\nCalls U::from(self).\nCalls U::from(self).\nCalls U::from(self).\nCalls U::from(self).\nCalls U::from(self).\nCalls U::from(self).\nConverts self into its associated chain type\nConverts self into its associated chain type\nWrites true into the output if the vector contains no …\nWrites true into the output if the vector contains no …\nConsumes self and leaks it, returning a mutable reference …\nWrites the number of elements (also known as the length) …\nWrites the number of elements (also known as the length) …\nCreates a new vector chain without allocating any capacity.\nUnwraps and retrieves the underlying Vec out.\nBorrow this vector chain mutably as a SliceMutChain.\nBorrow this vector chain immutably as a SliceRefChain.\nSorts, then dedups, the vector chain.\nCalls the provided closure with the spare capacity of the …\nSplits the left side off and writes it to another …\nSplits the left side off and writes it to another …\nSplits the right side off and writes it to another …\nSplits the right side off and writes it to another …\nUnsafetly truncates the string, with no checks at all…\nCreates a new vector, and preallocate some memory.\nAn interval tracking clock. Takes a start time, an end …\nTiming information for one tick\nClockTimer builder structs\nGets a ClockTimer builder\nReturns if this tick was delayed. This tick is considered …\nGet elapsed time since the start of this timer\nGet end time of this timer\nReturns the argument unchanged.\nReturns the argument unchanged.\nCalls U::from(self).\nCalls U::from(self).\nReturns if this tick is past due. This tick is considered …\nGet remaining runtime of this timer\nConvenience function, equivalent to running a …\nGet start time of this timer\nRuns the next tick and returns timing information for it, …\nGet time of this tick\nGet total runtime of this timer, including elapsed time …\nBuilder for ClockTimer.\nBuilds and returns a ClockTimer\nReturns the argument unchanged.\nReturns the argument unchanged.\nReturns the argument unchanged.\nReturns the argument unchanged.\nCalls U::from(self).\nCalls U::from(self).\nCalls U::from(self).\nCalls U::from(self).\nNew builder. You can also obtain a builder through …\nSets a duration to run this ClockTimer for. Internally, …\nSets the end date/time of the ClockTimer. ClockTimer will …\nSets interval to run at, or the time between ticks.\nSets the start date/time of the ClockTimer, or in other …\nReturns a new function that debounces calls to the passed …\nReturns a new function that debounces calls to the passed …\nReturns a new function that debounces calls to the passed …\nReturns a new function that debounces calls to the passed …\nh\nErrors that can be encountered on decoding data (encoding …\nInvalid character. Characters are only allowed to be in 0-9…\nInvalid length. Length is expected to be a multiple of two\nLength of encoding table. Not actually used in …\nEncoding table of lowercased characters. Not actually used …\nEncoding table of uppercased characters. Not actually used …\nDecodes a slice of hex bytes into a byte vector. This …\nEncodes a slice of bytes into a String, using lowercase …\nEncodes a slice of bytes into a String, using uppercase …\nReturns the argument unchanged.\nCalls U::from(self).\ncounting from the most significant to least significant …\nReturns the argument unchanged.\nReturns the argument unchanged.\nSafety\nSafety\nCalls U::from(self).\nCalls U::from(self).\nAllows any wiwi iter to be borrowed as an std iterator. …\nAllows any std iterator to be borrowed as a wiwi iter. …\nOnly an estimation (unreliable for unsafe operations).\nHard bound, unsafe, reliable information for use in unsafe …\nAllows any wiwi iter, or anything capable of converting to …\nAllows any std iterator, or anything capable of converting …\nAn adapter that wraps either a std Iterator or a wiwi Iter…\nOne side of the bound of size hint.\nIter for tuples of size 1.\nIter for tuples of size 10.\nIter for tuples of size 11.\nIter for tuples of size 12.\nIter for tuples of size 13.\nIter for tuples of size 14.\nIter for tuples of size 15.\nIter for tuples of size 16.\nIter for tuples of size 17.\nIter for tuples of size 18.\nIter for tuples of size 19.\nIter for tuples of size 2.\nIter for tuples of size 20.\nIter for tuples of size 21.\nIter for tuples of size 22.\nIter for tuples of size 23.\nIter for tuples of size 24.\nIter for tuples of size 25.\nIter for tuples of size 26.\nIter for tuples of size 27.\nIter for tuples of size 28.\nIter for tuples of size 29.\nIter for tuples of size 3.\nIter for tuples of size 30.\nIter for tuples of size 31.\nIter for tuples of size 32.\nIter for tuples of size 4.\nIter for tuples of size 5.\nIter for tuples of size 6.\nIter for tuples of size 7.\nIter for tuples of size 8.\nIter for tuples of size 9.\nUnknown bound. Anything goes :p\nBorrow the std iterator as a wiwi iter.\nBorrow the wiwi iter as an std iterator.\nConverts the std iterator into a wiwi iter.\nConverts the wiwi iter into a std iterator.\nConsumes the iter and returns the number of items that …\nReturns default size hint, or (Unknown, Unknown).\nReturns the argument unchanged.\nReturns the argument unchanged.\nReturns the argument unchanged.\nReturns the argument unchanged.\nReturns the argument unchanged.\nReturns the argument unchanged.\nReturns the argument unchanged.\nReturns the argument unchanged.\nReturns the argument unchanged.\nReturns the argument unchanged.\nReturns the argument unchanged.\nReturns the argument unchanged.\nReturns the argument unchanged.\nReturns the argument unchanged.\nReturns the argument unchanged.\nReturns the argument unchanged.\nReturns the argument unchanged.\nReturns the argument unchanged.\nReturns the argument unchanged.\nReturns the argument unchanged.\nReturns the argument unchanged.\nReturns the argument unchanged.\nReturns the argument unchanged.\nReturns the argument unchanged.\nReturns the argument unchanged.\nReturns the argument unchanged.\nReturns the argument unchanged.\nReturns the argument unchanged.\nReturns the argument unchanged.\nReturns the argument unchanged.\nReturns the argument unchanged.\nReturns the argument unchanged.\nReturns the argument unchanged.\nReturns the argument unchanged.\nReturns the argument unchanged.\nReturns the argument unchanged.\nReturns the argument unchanged.\nReturns the argument unchanged.\nReturns the argument unchanged.\nReturns the argument unchanged.\nReturns the argument unchanged.\nSafety\nCalls U::from(self).\nCalls U::from(self).\nCalls U::from(self).\nCalls U::from(self).\nCalls U::from(self).\nCalls U::from(self).\nCalls U::from(self).\nCalls U::from(self).\nCalls U::from(self).\nCalls U::from(self).\nCalls U::from(self).\nCalls U::from(self).\nCalls U::from(self).\nCalls U::from(self).\nCalls U::from(self).\nCalls U::from(self).\nCalls U::from(self).\nCalls U::from(self).\nCalls U::from(self).\nCalls U::from(self).\nCalls U::from(self).\nCalls U::from(self).\nCalls U::from(self).\nCalls U::from(self).\nCalls U::from(self).\nCalls U::from(self).\nCalls U::from(self).\nCalls U::from(self).\nCalls U::from(self).\nCalls U::from(self).\nCalls U::from(self).\nCalls U::from(self).\nCalls U::from(self).\nCalls U::from(self).\nCalls U::from(self).\nCalls U::from(self).\nCalls U::from(self).\nCalls U::from(self).\nCalls U::from(self).\nCalls U::from(self).\nCalls U::from(self).\nConsumes self and returns the underlying iter.\nTakes every element emitted by the underlying iter, and …\nReturns (lower, upper) bounds. Use this to match on a size …\nSafety\nSafety\nContains previously initialised value\nA lazily initialised data wrapper that initialises itself …\nReturned by LazyWrap::into_inner, containing the …\nValue is not initialised, contains initialisation function.\nRuns initialisation if the value is not initialised yet, …\nReturns the argument unchanged.\nReturns the argument unchanged.\nCalls U::from(self).\nCalls U::from(self).\nFetch the value if its initialised, or return the …\nEnsures that the value is initialised, then returns the …\nReturns true or false, depending on if the value is …\nCreates a new uninitialised instance that will be …\nReturns the argument unchanged.\nReturns the argument unchanged.\nCalls U::from(self).\nCalls U::from(self).\nTrait implemented by types that at compile time, for …\nThe memory usage of this type in bytes\nTrait implemented by types that, at compile time, use a …\nCalculate the memory usage of this value in bytes, …\nCalculate the memory usage of the value in bytes, but only …\nFetches the dynamically calculated memory usage of a value.\nFetches the statically known memory usage of a type.\nFetches the statically known memory usage of a value.\nISO 8601 combined date and time with time zone.\nThe local timescale.\nThe maximum possible DateTime<Utc>.\nThe minimum possible DateTime<Utc>.\nTime duration with nanosecond precision.\nThe Unix Epoch, 1970-01-01 00:00:00 UTC.\nReturns the TimeDelta as an absolute (non-negative) value.\nAdd two TimeDeltas, returning None if overflow occurred.\nAdd a duration in Days to the date part of the DateTime.\nAdds given Months to the current date and time.\nAdds given TimeDelta to the current date and time.\nSubtract two TimeDeltas, returning None if overflow …\nSubtract a duration in Days from the date part of the …\nSubtracts given Months from the current date and time.\nSubtracts given TimeDelta from the current date and time.\nRetrieves the date component with an associated timezone.\nRetrieves the date component.\nMakes a new TimeDelta with the given number of days.\nFix the offset from UTC to its current value, dropping the …\nFormat a TimeDelta using the ISO 8601 format\nFormats the combined date and time per the specified …\nFormats the combined date and time with the specified …\nReturns the argument unchanged.\nConvert this DateTime<FixedOffset> instance into a …\nReturns the argument unchanged.\nConvert this DateTime<Utc> instance into a …\nConvert this DateTime<Local> instance into a …\nConvert this DateTime<Local> instance into a DateTime<Utc> …\nConvert this DateTime<Utc> instance into a DateTime<Local> …\nConvert this DateTime<FixedOffset> instance into a …\nReturns the argument unchanged.\nMakes a new DateTime from a NaiveDateTime in local time …\nMakes a new DateTime from its components: a NaiveDateTime …\nCreates a TimeDelta object from std::time::Duration\nMakes a new DateTime<Utc> from the number of non-leap …\nCreates a new DateTime<Utc> from the number of non-leap …\nMakes a new DateTime<Utc> from the number of non-leap …\nCreates a new DateTime<Utc> from the number of non-leap …\nMakes a new DateTime from its components: a NaiveDateTime …\nMakes a new TimeDelta with the given number of hours.\nCalls U::from(self).\nCalls U::from(self).\nCalls U::from(self).\nReturns true if the TimeDelta equals TimeDelta::zero().\nThe maximum possible TimeDelta: i64::MAX milliseconds.\nMakes a new TimeDelta with the given number of …\nMakes a new TimeDelta with the given number of …\nThe minimum possible TimeDelta: -i64::MAX milliseconds.\nMakes a new TimeDelta with the given number of minutes.\nReturns a view to the naive local datetime.\nReturns a view to the naive UTC datetime.\nMakes a new TimeDelta with the given number of nanoseconds.\nMakes a new TimeDelta with given number of seconds and …\nReturns a DateTime<Local> which corresponds to the current …\nReturns the total number of whole days in the TimeDelta.\nReturns the total number of whole hours in the TimeDelta.\nReturns the total number of whole microseconds in the …\nReturns the total number of whole milliseconds in the …\nReturns the total number of whole minutes in the TimeDelta.\nReturns the total number of whole nanoseconds in the …\nReturns the total number of whole seconds in the TimeDelta.\nReturns the total number of whole weeks in the TimeDelta.\nRetrieves an associated offset from UTC.\nParses a string from a user-specified format into a …\nParses an RFC 2822 date-and-time string into a …\nParses an RFC 3339 date-and-time string into a …\nParses a string from a user-specified format into a …\nCompare two DateTimes based on their true time, ignoring …\nMakes a new TimeDelta with the given number of seconds.\nSubtracts another DateTime from the current date and time. …\nReturns the number of nanoseconds such that …\nRetrieves the time component.\nReturns the number of non-leap seconds since January 1, …\nReturns the number of non-leap-microseconds since January …\nReturns the number of non-leap-milliseconds since January …\nReturns the number of non-leap-nanoseconds since January …\nReturns the number of non-leap-nanoseconds since January …\nReturns the number of microseconds since the last second …\nReturns the number of milliseconds since the last second …\nReturns the number of nanoseconds since the last second …\nRetrieves an associated time zone.\nReturns an RFC 2822 date and time string such as …\nReturns an RFC 3339 and ISO 8601 date and time string such …\nReturn an RFC 3339 and ISO 8601 date and time string with …\nCreates a std::time::Duration object from a TimeDelta.\nTurn this DateTime into a DateTime<Utc>, dropping the …\nReturns a Date which corresponds to the current date.\nMakes a new TimeDelta with the given number of days.\nMakes a new TimeDelta with the given number of hours.\nMakes a new TimeDelta with the given number of …\nMakes a new TimeDelta with the given number of minutes.\nMakes a new TimeDelta with the given number of seconds.\nMakes a new TimeDelta with the given number of weeks.\nMakes a new TimeDelta with the given number of weeks.\nMakes a new DateTime with the day of month (starting from …\nMakes a new DateTime with the day of month (starting from …\nMakes a new DateTime with the hour number changed.\nMakes a new DateTime with the minute number changed.\nMakes a new DateTime with the month number (starting from …\nMakes a new DateTime with the month number (starting from …\nMakes a new DateTime with nanoseconds since the whole …\nMakes a new DateTime with the day of year (starting from …\nMakes a new DateTime with the day of year (starting from …\nMakes a new DateTime with the second number changed.\nChanges the associated time zone. The returned DateTime …\nMakes a new DateTime with the year number changed, while …\nRetrieve the elapsed years from now to the given DateTime.\nA TimeDelta where the stored seconds and nanoseconds are …\nReturns the argument unchanged.\nCalls U::from(self).\nReturns the argument unchanged.\nCalls U::from(self).\nReturns the argument unchanged.\nCalls U::from(self).\nThe default, global string pool\nTrait implemented by all pools, providing low-level …\nPool’s raw element. Can be anything (that is Sized), but …\nA string, whose contents are stored in a string pool.\nReturns the argument unchanged.\nCalls U::from(self).\nBacking pools. Contains the default global pool, as well …\nClones a raw element. The returned raw element should …\nCreates or retrieves a raw element that represents an …\nCreates or retrieves a raw element for a single slice.\nCreates or retrieves a raw element for multiple slices of …\nCreates or retrieves a raw element for a byte vec\nReturns a UTF-8 byte sequence, in a boxed byte array, that …\nReturns a UTF-8 byte sequence, in a byte vec, that the …\nTakes a pool’s raw element and returns the byte slice …\nThe String type\nThe default, global string pool\nTrait implemented by all pools, providing low-level …\nPool’s raw element. Can be anything (that is Sized), but …\nWraps a slice of slices of bytes. This has a simple Hash …\nIterator for SlicesWrap that returns elements in one slice …\nReturns the argument unchanged.\nReturns the argument unchanged.\nReturns the argument unchanged.\nCalls U::from(self).\nCalls U::from(self).\nCalls U::from(self).\nClones a raw element. The returned raw element should …\nCreates or retrieves a raw element that represents an …\nCreates or retrieves a raw element for a single slice.\nCreates or retrieves a raw element for multiple slices of …\nCreates or retrieves a raw element for a byte vec\nReturns a UTF-8 byte sequence, in a boxed byte array, that …\nReturns a UTF-8 byte sequence, in a byte vec, that the …\nTakes a pool’s raw element and returns the byte slice …\nJoins the slices in sequence, returning a boxed slice.\nJoins the slices in sequence, returning a vector of bytes.\nA string, whose contents are stored in a string pool.\nReturns the argument unchanged.\nCalls U::from(self).\nSafety\nOne frame of this many bytes (4) from the binary data maps …\nErrors that can be encountered on decoding data (encoding …\nOne frame of data contains characters that are too large …\nInvalid character in input data\nInput data has invalid length\nOne frame of this many bytes (5) from the encoded Z85 data …\nTable to map any byte to Option of a number 0-84.\nLength of the decoding table\nTable to map a number 0-84 to a Z85 character.\nLength of the encoding table (ie. number of different …\nDecodes a slice of of a Z85 string back into the source …\nEncodes a slice of bytes into a Z85 string, adding padding …\nReturns the argument unchanged.\nCalls U::from(self).") \ No newline at end of file diff --git a/src-files.js b/src-files.js index 1e35c30a8..60f0f3ae2 100644 --- a/src-files.js +++ b/src-files.js @@ -1,5 +1,5 @@ var srcIndex = new Map(JSON.parse('[\ -["wiwi",["",[["_internal",[],["encoding_utils.rs","mod.rs"]],["auth",[["flow",[],["mod.rs","signin.rs","signup.rs"]],["nom",[],["hashed_password_verifier.rs","mod.rs","password_key.rs","password_verifier.rs","session_id.rs","session_keypair.rs","signin_attempt_id.rs","signing_challenge.rs","user_input.rs","user_keypair.rs","verification_token.rs"]],["prim",[],["chacha.rs","datetime.rs","kdf.rs","keypair.rs","mod.rs","salt.rs"]]],["error.rs","mod.rs","util.rs"]],["bigint",[],["mod.rs"]],["bitstream",[],["mod.rs"]],["chainer",[],["array.rs","array_mut.rs","array_ref.rs","binary_heap.rs","bitstream.rs","btree_map.rs","btree_set.rs","hash_map.rs","hash_set.rs","into_chainer.rs","linked_list.rs","mod.rs","slice_box.rs","slice_mut.rs","slice_ref.rs","str_box.rs","str_mut.rs","str_ref.rs","string.rs","string_mut.rs","string_ref.rs","traits.rs","vec.rs","vec_deque.rs","vec_mut.rs","vec_ref.rs","with_vars.rs"]],["clock_timer",[],["mod.rs"]],["debounce",[],["mod.rs"]],["h",[],["mod.rs"]],["hex",[],["decode.rs","encode.rs","mod.rs"]],["id",[],["mod.rs"]],["iter",[],["adapter.rs","empty.rs","from_fn.rs","into_iter.rs","map.rs","mod.rs","peek.rs","repeat_per_item.rs","size_hint.rs","std_impl.rs","tuple.rs"]],["lazy_wrap",[],["mod.rs"]],["lsl",[["callback_api",[],["mod.rs","script.rs","ty.rs","util.rs","val.rs"]]],["mod.rs"]],["memory_usage",[],["mod.rs"]],["path",[],["mod.rs"]],["serialiser",[],["buffer.rs","deserialise.rs","error.rs","marker.rs","mod.rs","number.rs","serialise.rs"]],["string_pool",[["pool",[],["global.rs"]]],["mod.rs","pool.rs","string.rs"]],["sudoku",[],["mod.rs"]],["to_maybeuninit",[],["mod.rs"]],["z85",[],["mod.rs"]]],["lib.rs","prelude.rs"]]],\ +["wiwi",["",[["_internal",[],["encoding_utils.rs","mod.rs"]],["auth",[["flow",[],["mod.rs","signin.rs","signup.rs"]],["nom",[],["hashed_password_verifier.rs","mod.rs","password_key.rs","password_verifier.rs","session_id.rs","session_keypair.rs","signin_attempt_id.rs","signing_challenge.rs","user_input.rs","user_keypair.rs","verification_token.rs"]],["prim",[],["chacha.rs","datetime.rs","kdf.rs","keypair.rs","mod.rs","salt.rs"]]],["error.rs","mod.rs","util.rs"]],["bigint",[],["mod.rs"]],["bitstream",[],["mod.rs"]],["chainer",[],["array.rs","array_mut.rs","array_ref.rs","binary_heap.rs","bitstream.rs","btree_map.rs","btree_set.rs","hash_map.rs","hash_set.rs","into_chainer.rs","linked_list.rs","mod.rs","slice_box.rs","slice_mut.rs","slice_ref.rs","str_box.rs","str_mut.rs","str_ref.rs","string.rs","string_mut.rs","string_ref.rs","traits.rs","vec.rs","vec_deque.rs","vec_mut.rs","vec_ref.rs","with_vars.rs"]],["clock_timer",[],["mod.rs"]],["debounce",[],["mod.rs"]],["h",[],["mod.rs"]],["hex",[],["decode.rs","encode.rs","mod.rs"]],["id",[],["mod.rs"]],["iter",[],["adapter.rs","double_ended.rs","empty.rs","from_fn.rs","into_iter.rs","map.rs","mod.rs","peek.rs","repeat_per_item.rs","rev.rs","size_hint.rs","std_impl.rs","tuple.rs"]],["lazy_wrap",[],["mod.rs"]],["lsl",[["callback_api",[],["mod.rs","script.rs","ty.rs","util.rs","val.rs"]]],["mod.rs"]],["memory_usage",[],["mod.rs"]],["path",[],["mod.rs"]],["serialiser",[],["buffer.rs","deserialise.rs","error.rs","marker.rs","mod.rs","number.rs","serialise.rs"]],["string_pool",[["pool",[],["global.rs"]]],["mod.rs","pool.rs","string.rs"]],["sudoku",[],["mod.rs"]],["to_maybeuninit",[],["mod.rs"]],["z85",[],["mod.rs"]]],["lib.rs","prelude.rs"]]],\ ["wiwiwiwiwi",["",[],["lib.rs","memory_usage.rs"]]]\ ]')); createSrcSidebar(); diff --git a/src/wiwi/iter/adapter.rs.html b/src/wiwi/iter/adapter.rs.html index a0c9995a6..cb6b5123c 100644 --- a/src/wiwi/iter/adapter.rs.html +++ b/src/wiwi/iter/adapter.rs.html @@ -133,10 +133,22 @@ 133 134 135 +136 +137 +138 +139 +140 +141 +142 +143 +144 +145 +146 +147
//! Adapter traits and [`IterAdapter`], to aid in converting between and using std
 //! [`Iterator`]s as wiwi [`Iter`]s, and vice versa
 
-use super::{ IntoIter, Iter, SizeHint };
+use super::{ DoubleEndedIter, IntoIter, Iter, SizeHint };
 
 /// An adapter that wraps either a std [`Iterator`] or a wiwi [`Iter`], and then
 /// acts as the other. Basically, with every layer you layer it, it flip flops
@@ -185,6 +197,18 @@
 	}
 }
 
+impl<I: DoubleEndedIter> DoubleEndedIterator for IterAdapter<I> {
+	fn next_back(&mut self) -> Option<Self::Item> {
+		self.inner.next_back()
+	}
+}
+
+impl<I: DoubleEndedIterator> DoubleEndedIter for IterAdapter<I> {
+	fn next_back(&mut self) -> Option<Self::Item> {
+		self.inner.next_back()
+	}
+}
+
 /// Allows any std iterator to be borrowed as a wiwi iter. There is a
 /// blanket implementation provided, so it is available for all std iterators.
 pub trait AsWiwiIter<'h> {
diff --git a/src/wiwi/iter/double_ended.rs.html b/src/wiwi/iter/double_ended.rs.html
new file mode 100644
index 000000000..1563bccab
--- /dev/null
+++ b/src/wiwi/iter/double_ended.rs.html
@@ -0,0 +1,53 @@
+double_ended.rs - source
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+
use super::{ Iter, Rev };
+
+pub trait DoubleEndedIter: Iter {
+	fn next_back(&mut self) -> Option<Self::Item>;
+
+	fn rev(self) -> Rev<Self>
+	where
+		Self: Sized
+	{
+		Rev::new(self)
+	}
+
+	fn for_each_back<F>(mut self, mut f: F)
+	where
+		Self: Sized,
+		F: FnMut(Self::Item)
+	{
+		self.rev().for_each(f)
+	}
+}
+
+impl<I: DoubleEndedIter> DoubleEndedIter for &mut I {
+	fn next_back(&mut self) -> Option<Self::Item> {
+		(**self).next_back()
+	}
+}
+
\ No newline at end of file diff --git a/src/wiwi/iter/mod.rs.html b/src/wiwi/iter/mod.rs.html index 58be78c60..91992e417 100644 --- a/src/wiwi/iter/mod.rs.html +++ b/src/wiwi/iter/mod.rs.html @@ -273,6 +273,12 @@ 273 274 275 +276 +277 +278 +279 +280 +281
mod adapter;
 pub use adapter::{
 	AsStdIterator,
@@ -282,6 +288,9 @@
 	IterAdapter
 };
 
+mod double_ended;
+pub use double_ended::DoubleEndedIter;
+
 mod empty;
 pub use empty::{ empty, Empty };
 
@@ -300,6 +309,9 @@
 mod repeat_per_item;
 pub use repeat_per_item::RepeatPerItem;
 
+mod rev;
+pub use rev::Rev;
+
 mod size_hint;
 pub use size_hint::{ SizeHint, SizeHintBound };
 
diff --git a/src/wiwi/iter/rev.rs.html b/src/wiwi/iter/rev.rs.html
new file mode 100644
index 000000000..6cec088f4
--- /dev/null
+++ b/src/wiwi/iter/rev.rs.html
@@ -0,0 +1,67 @@
+rev.rs - source
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+28
+29
+30
+31
+32
+33
+
use super::{ DoubleEndedIter, Iter, SizeHint };
+
+pub struct Rev<I> {
+	iter: I
+}
+
+impl<I: DoubleEndedIter> Rev<I> {
+	pub(super) fn new(iter: I) -> Self {
+		Self { iter }
+	}
+
+	pub fn into_inner(self) -> I {
+		self.iter
+	}
+}
+
+impl<I: DoubleEndedIter> Iter for Rev<I> {
+	type Item = I::Item;
+
+	fn next(&mut self) -> Option<I::Item> {
+		self.iter.next_back()
+	}
+
+	fn size_hint(&self) -> SizeHint {
+		self.iter.size_hint()
+	}
+}
+
+impl<I: DoubleEndedIter> DoubleEndedIter for Rev<I> {
+	fn next_back(&mut self) -> Option<I::Item> {
+		self.iter.next()
+	}
+}
+
\ No newline at end of file diff --git a/src/wiwi/serialiser/buffer.rs.html b/src/wiwi/serialiser/buffer.rs.html index 4ddf90565..87a157921 100644 --- a/src/wiwi/serialiser/buffer.rs.html +++ b/src/wiwi/serialiser/buffer.rs.html @@ -97,7 +97,6 @@ 97 98 99 -100
use super::error::*;
 use std::{ ptr, slice };
 use std::future::Future;
@@ -167,13 +166,10 @@
 		debug_assert!(self.capacity() >= self.len() + bytes.len());
 
 		self.with_ptr(|ptr| {
-			ptr::copy_nonoverlapping(
-				bytes as *const [u8] as *const u8,
-				ptr,
-				bytes.len()
-			);
-
-			bytes.len()
+			let len = bytes.len();
+			let bytes_ptr = bytes as *const [u8] as *const u8;
+			ptr::copy_nonoverlapping(bytes_ptr, ptr, len);
+			len
 		});
 	}
 
@@ -182,18 +178,20 @@
 	where
 		F: FnOnce(*mut u8) -> usize
 	{
-		let ptr = self.as_mut_ptr().add(self.len());
+		let len = self.len();
+		let ptr = self.as_mut_ptr().add(len);
 		let count = f(ptr);
-		self.set_len(self.len() + count);
+		self.set_len(len + count);
 	}
 }
 
 impl<'h> BufferRead<'h> for &'h [u8] {
 	#[inline]
 	unsafe fn read_bytes_ptr(&mut self, count: usize) -> Result<*const u8> {
-		(self.len() >= count).then(|| {
+		let len = self.len();
+		(len >= count).then(|| {
 			let ptr = *self as *const [u8] as *const u8;
-			*self = slice::from_raw_parts(ptr.add(count), self.len() - count);
+			*self = slice::from_raw_parts(ptr.add(count), len - count);
 			ptr
 		}).err_eof()
 	}
diff --git a/src/wiwi/serialiser/marker.rs.html b/src/wiwi/serialiser/marker.rs.html
index 44ff8598f..097bdaed9 100644
--- a/src/wiwi/serialiser/marker.rs.html
+++ b/src/wiwi/serialiser/marker.rs.html
@@ -1 +1,101 @@
-marker.rs - source
\ No newline at end of file +marker.rs - source
1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+24
+25
+26
+27
+28
+29
+30
+31
+32
+33
+34
+35
+36
+37
+38
+39
+40
+41
+42
+43
+44
+45
+46
+47
+48
+49
+50
+
use super::{ buffer::*, error::* };
+
+pub struct Marker {
+	inner: MarkerInner
+}
+
+enum MarkerInner {
+	SmallIntPositive { marker: u8 },
+	SmallIntNegative { marker: u8 },
+	Int { marker: u8 },
+	Bool { marker: u8 },
+	Float { marker: u8 },
+	Null,
+	String { marker: u8 },
+	Array { marker: u8 },
+	Map { marker: u8 },
+	SingleTypeArray { marker: u8 },
+	Binary { marker: u8 },
+	// Set { marker: u8 }, // TODO: ?????
+	Unassigned { marker: u8 },
+	Reserved2Byte1,
+	Reserved2Byte2,
+	Reserved3Byte
+}
+
+impl Marker {
+	pub fn read_from<'h, B: BufferRead<'h>>(input: &mut B) -> Result<Self> {
+		#[deny(overlapping_range_endpoints)]
+		let inner = match input.read_byte()? {
+			marker @ 0x00..=0x7f => { MarkerInner::SmallIntPositive { marker } }
+			marker @ 0xc0..=0xff => { MarkerInner::SmallIntNegative { marker } }
+			marker @ 0x80..=0x9f => { MarkerInner::Int { marker } }
+			marker @ 0xa0..=0xa1 => { MarkerInner::Bool { marker } }
+			marker @ 0xa2..=0xa6 => { MarkerInner::Float { marker } }
+			0xa7 => { MarkerInner::Null }
+			marker @ 0xa8..=0xa9 => { MarkerInner::String { marker } }
+			marker @ 0xaa..=0xab => { MarkerInner::Array { marker } }
+			marker @ 0xac..=0xad => { MarkerInner::Map { marker } }
+			marker @ 0xae..=0xaf => { MarkerInner::SingleTypeArray { marker } }
+			marker @ 0xb0..=0xb1 => { MarkerInner::Binary { marker } }
+			// marker @ 0xb2..=0xb3 => { MarkerInner::Set { marker } }
+			marker @ 0xb2..=0xbc => { MarkerInner::Unassigned { marker } }
+			0xbd => { MarkerInner::Reserved2Byte1 }
+			0xbe => { MarkerInner::Reserved2Byte2 }
+			0xbf => { MarkerInner::Reserved3Byte }
+		};
+
+		Ok(Marker { inner })
+	}
+}
+
\ No newline at end of file diff --git a/src/wiwi/serialiser/number.rs.html b/src/wiwi/serialiser/number.rs.html index a98bf76e8..ada12be55 100644 --- a/src/wiwi/serialiser/number.rs.html +++ b/src/wiwi/serialiser/number.rs.html @@ -130,8 +130,57 @@ 130 131 132 -
use super::{ *, buffer::*, serialise::*, deserialise::* };
-use std::slice;
+133
+134
+135
+136
+137
+138
+139
+140
+141
+142
+143
+144
+145
+146
+147
+148
+149
+150
+151
+152
+153
+154
+155
+156
+157
+158
+159
+160
+161
+162
+163
+164
+165
+166
+167
+168
+169
+170
+171
+172
+173
+174
+175
+176
+177
+178
+179
+180
+181
+
use super::{ *, buffer::*, error::*, serialise::*, deserialise::* };
+use std::{ ptr, slice };
 
 exported_match_macro!(smallint_positive_range: 0x00..=0x7f);
 exported_match_macro!(smallint_negative_range: -64..=-1);
@@ -140,74 +189,74 @@
 exported_match_macro!(smallint_signed_range: -64..=0x7f);
 exported_match_macro!(int_range: 0x80..=0x9f);
 
-macro_rules! impl_num_serialise {
-	($($num:ty: $signed:tt)*) => {
-		$(impl_num_serialise! { @internal $num: $signed })*
-	};
+// macro_rules! impl_num_serialise {
+// 	($($num:ty: $signed:tt)*) => {
+// 		$(impl_num_serialise! { @internal $num: $signed })*
+// 	};
 
-	// unsigned
-	(@internal $num:ty: false) => {
-		impl Serialise for $num {
-			fn serialise<B: BufferWrite>(&self, output: &mut B, options: &SerialiseOptions) {
-				match *self {
-					num @ smallint_positive_range!() => { output.write_byte(num as _) }
-					num => {
-						let bytes = num.to_le_bytes();
+// 	// unsigned
+// 	(@internal $num:ty: false) => {
+// 		impl Serialise for $num {
+// 			fn serialise<B: BufferWrite>(&self, output: &mut B, options: &SerialiseOptions) {
+// 				match *self {
+// 					num @ smallint_positive_range!() => { output.write_byte(num as _) }
+// 					num => {
+// 						let bytes = num.to_le_bytes();
 
-						let byte_size = get_byte_count_unsigned_le(bytes);
-						let marker = unsafe { get_marker_for(byte_size, false) };
+// 						let byte_size = get_byte_count_unsigned_le(bytes);
+// 						let marker = unsafe { get_marker_for(byte_size, false) };
 
-						output.write_byte(marker);
-						output.write_bytes(unsafe { slice::from_raw_parts(
-							&bytes as *const u8,
-							byte_size as _
-						) });
-					}
-				}
-			}
-		}
-	};
+// 						output.write_byte(marker);
+// 						output.write_bytes(unsafe { slice::from_raw_parts(
+// 							&bytes as *const u8,
+// 							byte_size as _
+// 						) });
+// 					}
+// 				}
+// 			}
+// 		}
+// 	};
 
-	// signed
-	(@internal $num:ty: true) => {
-		impl Serialise for $num {
-			fn serialise<B: BufferWrite>(&self, output: &mut B, options: &SerialiseOptions) {
-				match *self {
-					num @ smallint_positive_range!() => { output.write_byte(num as _) }
-					num @ smallint_negative_range!() => { output.write_byte(num as _) }
-					num => {
-						let bytes = num.to_le_bytes();
+// 	// signed
+// 	(@internal $num:ty: true) => {
+// 		impl Serialise for $num {
+// 			fn serialise<B: BufferWrite>(&self, output: &mut B, options: &SerialiseOptions) {
+// 				match *self {
+// 					num @ smallint_positive_range!() => { output.write_byte(num as _) }
+// 					num @ smallint_negative_range!() => { output.write_byte(num as _) }
+// 					num => {
+// 						let bytes = num.to_le_bytes();
 
-						let byte_size = get_byte_count_signed_le(bytes);
-						let marker = unsafe { get_marker_for(byte_size, true) };
+// 						let byte_size = get_byte_count_signed_le(bytes);
+// 						let marker = unsafe { get_marker_for(byte_size, true) };
 
-						output.write_byte(marker);
-						output.write_bytes(unsafe { slice::from_raw_parts(
-							&bytes as *const u8,
-							byte_size as _
-						) });
-					}
-				}
-			}
-		}
-	};
-}
+// 						output.write_byte(marker);
+// 						output.write_bytes(unsafe { slice::from_raw_parts(
+// 							&bytes as *const u8,
+// 							byte_size as _
+// 						) });
+// 					}
+// 				}
+// 			}
+// 		}
+// 	};
+// }
 
-impl_num_serialise! {
-	u8: false
-	u16: false
-	u32: false
-	u64: false
-	u128: false
+// impl_num_serialise! {
+// 	u8: false
+// 	u16: false
+// 	u32: false
+// 	u64: false
+// 	u128: false
 
-	i8: true
-	i16: true
-	i32: true
-	i64: true
-	i128: true
-}
+// 	i8: true
+// 	i16: true
+// 	i32: true
+// 	i64: true
+// 	i128: true
+// }
 
-fn get_byte_count_unsigned_le<const BYTES: usize>(bytes: [u8; BYTES]) -> u8 {
+fn get_byte_count_unsigned_le<const BYTES: usize>(bytes: [u8; BYTES]) -> u8 {
 	unsafe {
 		let ptr = &bytes as *const u8;
 
@@ -247,8 +296,8 @@
 			} else {
 				// sign bit is different, return this byte and one more after it.
 				// if the next byte would have the wrong sign, it would have returned
-				// already in the previous iteration. This won't ever overflow
-				// because the first byte will not have a different sign (as... itself),
+				// already in the previous branch. This won't ever overflow because
+				// the first byte will not have a different sign (as... itself),
 				// so will never reach here.
 				return (i + 2) as _
 			}
@@ -258,8 +307,57 @@
 	}
 }
 
+/// # Safety
+///
+/// Function is written only expecting certain values for `byte_count` (`1..=16`),
+/// and we have not thought about what happens if values are entered outside that
+/// range. Also in how this function's output is going to be used, it can cause
+/// memory issues if used in wrong way. So this fn is conservatively marked
+/// `unsafe`, and in doing so, promise this function will behave as expected.
+/// It's internal function anyways it doesn't matter that much :p
+#[inline]
+const unsafe fn get_marker_for(byte_count: u8, signed: bool) -> u8 {
+	((byte_count - 1) << 1) | 0x80 | signed as u8
+}
+
 #[inline]
-const unsafe fn get_marker_for(byte_size: u8, signed: bool) -> u8 {
-	((byte_size - 1) << 1) | 0x80 | signed as u8
+const fn is_int_marker(marker: u8) -> bool {
+	marker >> 5 == 0b100
+}
+
+struct MarkerDetails {
+	byte_size: u8,
+	signed: bool
+}
+
+impl MarkerDetails {
+	#[inline]
+	pub fn try_new(marker: u8) -> Option<Self> {
+		is_int_marker(marker).then(|| {
+			let marker = marker & 0b11111;
+			let byte_size = (marker >> 1) + 1;
+			let signed = marker & 1 != 0;
+
+			Self { byte_size, signed }
+		})
+	}
 }
-
\ No newline at end of file + +// // TODO: need to be able to handle floats too (deserialise proper if the float has no fractional part) + +// // impl<'h> Deserialise<'h> for u8 { +// // fn deserialise<B: BufferRead<'h>>(input: &mut B) -> Result<Self> { +// // match MarkerDetails::try_new::<1>(input.read_byte()?) { +// // Some(MarkerDetails { byte_size, signed: false }) => { +// // let mut bytes = [0u8; 1]; +// // // ptr::copy_nonoverlapping( +// // // // input.read_bytes_ptr(byte_size as _) +// // // ) +// // } +// // _ => { return err_str("expected u8-compatible number") } +// // } +// // +// // todo!() +// // } +// // } + \ No newline at end of file diff --git a/trait.impl/core/iter/traits/double_ended/trait.DoubleEndedIterator.js b/trait.impl/core/iter/traits/double_ended/trait.DoubleEndedIterator.js new file mode 100644 index 000000000..d8e381701 --- /dev/null +++ b/trait.impl/core/iter/traits/double_ended/trait.DoubleEndedIterator.js @@ -0,0 +1,3 @@ +(function() {var implementors = { +"wiwi":[["impl<I: DoubleEndedIter> DoubleEndedIterator for IterAdapter<I>"]] +};if (window.register_implementors) {window.register_implementors(implementors);} else {window.pending_implementors = implementors;}})() \ No newline at end of file diff --git a/trait.impl/core/marker/trait.Freeze.js b/trait.impl/core/marker/trait.Freeze.js index bea7348c1..2d8d03ed7 100644 --- a/trait.impl/core/marker/trait.Freeze.js +++ b/trait.impl/core/marker/trait.Freeze.js @@ -1,3 +1,3 @@ (function() {var implementors = { -"wiwi":[["impl Freeze for DecodeError",1,["wiwi::hex::DecodeError"]],["impl Freeze for SizeHintBound",1,["wiwi::iter::size_hint::SizeHintBound"]],["impl Freeze for Error",1,["wiwi::serialiser::error::Error"]],["impl Freeze for DecodeError",1,["wiwi::z85::DecodeError"]],["impl Freeze for Error",1,["wiwi::auth::error::Error"]],["impl Freeze for ClientContinuerS1",1,["wiwi::auth::flow::signin::ClientContinuerS1"]],["impl Freeze for ClientContinuerS2",1,["wiwi::auth::flow::signin::ClientContinuerS2"]],["impl Freeze for ClientContinuerS3",1,["wiwi::auth::flow::signin::ClientContinuerS3"]],["impl Freeze for ServerS2Params",1,["wiwi::auth::flow::signin::ServerS2Params"]],["impl Freeze for ServerS3Params",1,["wiwi::auth::flow::signin::ServerS3Params"]],["impl Freeze for SigninRequestS1",1,["wiwi::auth::flow::signin::SigninRequestS1"]],["impl Freeze for SigninRequestS2",1,["wiwi::auth::flow::signin::SigninRequestS2"]],["impl Freeze for SigninRequestS3",1,["wiwi::auth::flow::signin::SigninRequestS3"]],["impl Freeze for SigninResponseS1",1,["wiwi::auth::flow::signin::SigninResponseS1"]],["impl Freeze for SigninResponseS2",1,["wiwi::auth::flow::signin::SigninResponseS2"]],["impl Freeze for SigninResponseS3",1,["wiwi::auth::flow::signin::SigninResponseS3"]],["impl Freeze for SignupRequest",1,["wiwi::auth::flow::signup::SignupRequest"]],["impl Freeze for StoredUnverifiedUserData",1,["wiwi::auth::flow::signup::StoredUnverifiedUserData"]],["impl Freeze for U320",1,["wiwi::bigint::U320"]],["impl Freeze for Encoder",1,["wiwi::bitstream::Encoder"]],["impl Freeze for BitstreamEncoderChain",1,["wiwi::chainer::bitstream::BitstreamEncoderChain"]],["impl Freeze for StrBoxChain",1,["wiwi::chainer::str_box::StrBoxChain"]],["impl Freeze for StringChain",1,["wiwi::chainer::string::StringChain"]],["impl Freeze for Builder",1,["wiwi::clock_timer::builder::Builder"]],["impl Freeze for BuilderWithEnd",1,["wiwi::clock_timer::builder::BuilderWithEnd"]],["impl Freeze for BuilderWithInterval",1,["wiwi::clock_timer::builder::BuilderWithInterval"]],["impl Freeze for BuilderWithStart",1,["wiwi::clock_timer::builder::BuilderWithStart"]],["impl Freeze for ClockTimer",1,["wiwi::clock_timer::ClockTimer"]],["impl Freeze for Tick",1,["wiwi::clock_timer::Tick"]],["impl Freeze for GeneratedID",1,["wiwi::id::GeneratedID"]],["impl Freeze for IDGenerator",1,["wiwi::id::IDGenerator"]],["impl Freeze for SizeHint",1,["wiwi::iter::size_hint::SizeHint"]],["impl Freeze for Script",1,["wiwi::lsl::callback_api::script::Script"]],["impl Freeze for ScriptBuilder",1,["wiwi::lsl::callback_api::script::ScriptBuilder"]],["impl Freeze for SerialiseOptions",1,["wiwi::serialiser::serialise::SerialiseOptions"]],["impl Freeze for GlobalPool",1,["wiwi::string_pool::pool::global::GlobalPool"]],["impl Freeze for Board",1,["wiwi::sudoku::Board"]],["impl<'h> Freeze for StrMutChain<'h>",1,["wiwi::chainer::str_mut::StrMutChain"]],["impl<'h> Freeze for StrRefChain<'h>",1,["wiwi::chainer::str_ref::StrRefChain"]],["impl<'h> Freeze for StringMutChain<'h>",1,["wiwi::chainer::string_mut::StringMutChain"]],["impl<'h> Freeze for StringRefChain<'h>",1,["wiwi::chainer::string_ref::StringRefChain"]],["impl<'h> Freeze for SlicesWrap<'h>",1,["wiwi::string_pool::pool::SlicesWrap"]],["impl<'h> Freeze for SlicesWrapIter<'h>",1,["wiwi::string_pool::pool::SlicesWrapIter"]],["impl<'h, T> Freeze for SliceMutChain<'h, T>",1,["wiwi::chainer::slice_mut::SliceMutChain"]],["impl<'h, T> Freeze for SliceRefChain<'h, T>",1,["wiwi::chainer::slice_ref::SliceRefChain"]],["impl<'h, T> Freeze for VecMutChain<'h, T>",1,["wiwi::chainer::vec_mut::VecMutChain"]],["impl<'h, T> Freeze for VecRefChain<'h, T>",1,["wiwi::chainer::vec_ref::VecRefChain"]],["impl<'h, T, const N: usize> Freeze for ArrayMutChain<'h, T, N>",1,["wiwi::chainer::array_mut::ArrayMutChain"]],["impl<'h, T, const N: usize> Freeze for ArrayRefChain<'h, T, N>",1,["wiwi::chainer::array_ref::ArrayRefChain"]],["impl<F> Freeze for FromFn<F>
where\n F: Freeze,
",1,["wiwi::iter::from_fn::FromFn"]],["impl<I> Freeze for IterAdapter<I>
where\n I: Freeze,
",1,["wiwi::iter::adapter::IterAdapter"]],["impl<I> Freeze for RepeatPerItem<I>
where\n I: Freeze,\n <I as Iter>::Item: Freeze,
",1,["wiwi::iter::repeat_per_item::RepeatPerItem"]],["impl<I, F> Freeze for Map<I, F>
where\n I: Freeze,\n F: Freeze,
",1,["wiwi::iter::map::Map"]],["impl<I, T> Freeze for Peek<I, T>
where\n I: Freeze,\n T: Freeze,
",1,["wiwi::iter::peek::Peek"]],["impl<I1> Freeze for Tuple1<I1>
where\n I1: Freeze,
",1,["wiwi::iter::tuple::Tuple1"]],["impl<I1, I2> Freeze for Tuple2<I1, I2>
where\n I1: Freeze,\n I2: Freeze,
",1,["wiwi::iter::tuple::Tuple2"]],["impl<I1, I2, I3> Freeze for Tuple3<I1, I2, I3>
where\n I1: Freeze,\n I2: Freeze,\n I3: Freeze,
",1,["wiwi::iter::tuple::Tuple3"]],["impl<I1, I2, I3, I4> Freeze for Tuple4<I1, I2, I3, I4>
where\n I1: Freeze,\n I2: Freeze,\n I3: Freeze,\n I4: Freeze,
",1,["wiwi::iter::tuple::Tuple4"]],["impl<I1, I2, I3, I4, I5> Freeze for Tuple5<I1, I2, I3, I4, I5>
where\n I1: Freeze,\n I2: Freeze,\n I3: Freeze,\n I4: Freeze,\n I5: Freeze,
",1,["wiwi::iter::tuple::Tuple5"]],["impl<I1, I2, I3, I4, I5, I6> Freeze for Tuple6<I1, I2, I3, I4, I5, I6>
where\n I1: Freeze,\n I2: Freeze,\n I3: Freeze,\n I4: Freeze,\n I5: Freeze,\n I6: Freeze,
",1,["wiwi::iter::tuple::Tuple6"]],["impl<I1, I2, I3, I4, I5, I6, I7> Freeze for Tuple7<I1, I2, I3, I4, I5, I6, I7>
where\n I1: Freeze,\n I2: Freeze,\n I3: Freeze,\n I4: Freeze,\n I5: Freeze,\n I6: Freeze,\n I7: Freeze,
",1,["wiwi::iter::tuple::Tuple7"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8> Freeze for Tuple8<I1, I2, I3, I4, I5, I6, I7, I8>
where\n I1: Freeze,\n I2: Freeze,\n I3: Freeze,\n I4: Freeze,\n I5: Freeze,\n I6: Freeze,\n I7: Freeze,\n I8: Freeze,
",1,["wiwi::iter::tuple::Tuple8"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9> Freeze for Tuple9<I1, I2, I3, I4, I5, I6, I7, I8, I9>
where\n I1: Freeze,\n I2: Freeze,\n I3: Freeze,\n I4: Freeze,\n I5: Freeze,\n I6: Freeze,\n I7: Freeze,\n I8: Freeze,\n I9: Freeze,
",1,["wiwi::iter::tuple::Tuple9"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10> Freeze for Tuple10<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10>
where\n I1: Freeze,\n I2: Freeze,\n I3: Freeze,\n I4: Freeze,\n I5: Freeze,\n I6: Freeze,\n I7: Freeze,\n I8: Freeze,\n I9: Freeze,\n I10: Freeze,
",1,["wiwi::iter::tuple::Tuple10"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11> Freeze for Tuple11<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11>
where\n I1: Freeze,\n I2: Freeze,\n I3: Freeze,\n I4: Freeze,\n I5: Freeze,\n I6: Freeze,\n I7: Freeze,\n I8: Freeze,\n I9: Freeze,\n I10: Freeze,\n I11: Freeze,
",1,["wiwi::iter::tuple::Tuple11"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12> Freeze for Tuple12<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12>
where\n I1: Freeze,\n I2: Freeze,\n I3: Freeze,\n I4: Freeze,\n I5: Freeze,\n I6: Freeze,\n I7: Freeze,\n I8: Freeze,\n I9: Freeze,\n I10: Freeze,\n I11: Freeze,\n I12: Freeze,
",1,["wiwi::iter::tuple::Tuple12"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13> Freeze for Tuple13<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13>
where\n I1: Freeze,\n I2: Freeze,\n I3: Freeze,\n I4: Freeze,\n I5: Freeze,\n I6: Freeze,\n I7: Freeze,\n I8: Freeze,\n I9: Freeze,\n I10: Freeze,\n I11: Freeze,\n I12: Freeze,\n I13: Freeze,
",1,["wiwi::iter::tuple::Tuple13"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14> Freeze for Tuple14<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14>
where\n I1: Freeze,\n I2: Freeze,\n I3: Freeze,\n I4: Freeze,\n I5: Freeze,\n I6: Freeze,\n I7: Freeze,\n I8: Freeze,\n I9: Freeze,\n I10: Freeze,\n I11: Freeze,\n I12: Freeze,\n I13: Freeze,\n I14: Freeze,
",1,["wiwi::iter::tuple::Tuple14"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15> Freeze for Tuple15<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15>
where\n I1: Freeze,\n I2: Freeze,\n I3: Freeze,\n I4: Freeze,\n I5: Freeze,\n I6: Freeze,\n I7: Freeze,\n I8: Freeze,\n I9: Freeze,\n I10: Freeze,\n I11: Freeze,\n I12: Freeze,\n I13: Freeze,\n I14: Freeze,\n I15: Freeze,
",1,["wiwi::iter::tuple::Tuple15"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16> Freeze for Tuple16<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16>
where\n I1: Freeze,\n I2: Freeze,\n I3: Freeze,\n I4: Freeze,\n I5: Freeze,\n I6: Freeze,\n I7: Freeze,\n I8: Freeze,\n I9: Freeze,\n I10: Freeze,\n I11: Freeze,\n I12: Freeze,\n I13: Freeze,\n I14: Freeze,\n I15: Freeze,\n I16: Freeze,
",1,["wiwi::iter::tuple::Tuple16"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17> Freeze for Tuple17<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17>
where\n I1: Freeze,\n I2: Freeze,\n I3: Freeze,\n I4: Freeze,\n I5: Freeze,\n I6: Freeze,\n I7: Freeze,\n I8: Freeze,\n I9: Freeze,\n I10: Freeze,\n I11: Freeze,\n I12: Freeze,\n I13: Freeze,\n I14: Freeze,\n I15: Freeze,\n I16: Freeze,\n I17: Freeze,
",1,["wiwi::iter::tuple::Tuple17"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18> Freeze for Tuple18<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18>
where\n I1: Freeze,\n I2: Freeze,\n I3: Freeze,\n I4: Freeze,\n I5: Freeze,\n I6: Freeze,\n I7: Freeze,\n I8: Freeze,\n I9: Freeze,\n I10: Freeze,\n I11: Freeze,\n I12: Freeze,\n I13: Freeze,\n I14: Freeze,\n I15: Freeze,\n I16: Freeze,\n I17: Freeze,\n I18: Freeze,
",1,["wiwi::iter::tuple::Tuple18"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19> Freeze for Tuple19<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19>
where\n I1: Freeze,\n I2: Freeze,\n I3: Freeze,\n I4: Freeze,\n I5: Freeze,\n I6: Freeze,\n I7: Freeze,\n I8: Freeze,\n I9: Freeze,\n I10: Freeze,\n I11: Freeze,\n I12: Freeze,\n I13: Freeze,\n I14: Freeze,\n I15: Freeze,\n I16: Freeze,\n I17: Freeze,\n I18: Freeze,\n I19: Freeze,
",1,["wiwi::iter::tuple::Tuple19"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20> Freeze for Tuple20<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20>
where\n I1: Freeze,\n I2: Freeze,\n I3: Freeze,\n I4: Freeze,\n I5: Freeze,\n I6: Freeze,\n I7: Freeze,\n I8: Freeze,\n I9: Freeze,\n I10: Freeze,\n I11: Freeze,\n I12: Freeze,\n I13: Freeze,\n I14: Freeze,\n I15: Freeze,\n I16: Freeze,\n I17: Freeze,\n I18: Freeze,\n I19: Freeze,\n I20: Freeze,
",1,["wiwi::iter::tuple::Tuple20"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21> Freeze for Tuple21<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21>
where\n I1: Freeze,\n I2: Freeze,\n I3: Freeze,\n I4: Freeze,\n I5: Freeze,\n I6: Freeze,\n I7: Freeze,\n I8: Freeze,\n I9: Freeze,\n I10: Freeze,\n I11: Freeze,\n I12: Freeze,\n I13: Freeze,\n I14: Freeze,\n I15: Freeze,\n I16: Freeze,\n I17: Freeze,\n I18: Freeze,\n I19: Freeze,\n I20: Freeze,\n I21: Freeze,
",1,["wiwi::iter::tuple::Tuple21"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22> Freeze for Tuple22<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22>
where\n I1: Freeze,\n I2: Freeze,\n I3: Freeze,\n I4: Freeze,\n I5: Freeze,\n I6: Freeze,\n I7: Freeze,\n I8: Freeze,\n I9: Freeze,\n I10: Freeze,\n I11: Freeze,\n I12: Freeze,\n I13: Freeze,\n I14: Freeze,\n I15: Freeze,\n I16: Freeze,\n I17: Freeze,\n I18: Freeze,\n I19: Freeze,\n I20: Freeze,\n I21: Freeze,\n I22: Freeze,
",1,["wiwi::iter::tuple::Tuple22"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23> Freeze for Tuple23<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23>
where\n I1: Freeze,\n I2: Freeze,\n I3: Freeze,\n I4: Freeze,\n I5: Freeze,\n I6: Freeze,\n I7: Freeze,\n I8: Freeze,\n I9: Freeze,\n I10: Freeze,\n I11: Freeze,\n I12: Freeze,\n I13: Freeze,\n I14: Freeze,\n I15: Freeze,\n I16: Freeze,\n I17: Freeze,\n I18: Freeze,\n I19: Freeze,\n I20: Freeze,\n I21: Freeze,\n I22: Freeze,\n I23: Freeze,
",1,["wiwi::iter::tuple::Tuple23"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24> Freeze for Tuple24<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24>
where\n I1: Freeze,\n I2: Freeze,\n I3: Freeze,\n I4: Freeze,\n I5: Freeze,\n I6: Freeze,\n I7: Freeze,\n I8: Freeze,\n I9: Freeze,\n I10: Freeze,\n I11: Freeze,\n I12: Freeze,\n I13: Freeze,\n I14: Freeze,\n I15: Freeze,\n I16: Freeze,\n I17: Freeze,\n I18: Freeze,\n I19: Freeze,\n I20: Freeze,\n I21: Freeze,\n I22: Freeze,\n I23: Freeze,\n I24: Freeze,
",1,["wiwi::iter::tuple::Tuple24"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24, I25> Freeze for Tuple25<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24, I25>
where\n I1: Freeze,\n I2: Freeze,\n I3: Freeze,\n I4: Freeze,\n I5: Freeze,\n I6: Freeze,\n I7: Freeze,\n I8: Freeze,\n I9: Freeze,\n I10: Freeze,\n I11: Freeze,\n I12: Freeze,\n I13: Freeze,\n I14: Freeze,\n I15: Freeze,\n I16: Freeze,\n I17: Freeze,\n I18: Freeze,\n I19: Freeze,\n I20: Freeze,\n I21: Freeze,\n I22: Freeze,\n I23: Freeze,\n I24: Freeze,\n I25: Freeze,
",1,["wiwi::iter::tuple::Tuple25"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24, I25, I26> Freeze for Tuple26<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24, I25, I26>
where\n I1: Freeze,\n I2: Freeze,\n I3: Freeze,\n I4: Freeze,\n I5: Freeze,\n I6: Freeze,\n I7: Freeze,\n I8: Freeze,\n I9: Freeze,\n I10: Freeze,\n I11: Freeze,\n I12: Freeze,\n I13: Freeze,\n I14: Freeze,\n I15: Freeze,\n I16: Freeze,\n I17: Freeze,\n I18: Freeze,\n I19: Freeze,\n I20: Freeze,\n I21: Freeze,\n I22: Freeze,\n I23: Freeze,\n I24: Freeze,\n I25: Freeze,\n I26: Freeze,
",1,["wiwi::iter::tuple::Tuple26"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24, I25, I26, I27> Freeze for Tuple27<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24, I25, I26, I27>
where\n I1: Freeze,\n I2: Freeze,\n I3: Freeze,\n I4: Freeze,\n I5: Freeze,\n I6: Freeze,\n I7: Freeze,\n I8: Freeze,\n I9: Freeze,\n I10: Freeze,\n I11: Freeze,\n I12: Freeze,\n I13: Freeze,\n I14: Freeze,\n I15: Freeze,\n I16: Freeze,\n I17: Freeze,\n I18: Freeze,\n I19: Freeze,\n I20: Freeze,\n I21: Freeze,\n I22: Freeze,\n I23: Freeze,\n I24: Freeze,\n I25: Freeze,\n I26: Freeze,\n I27: Freeze,
",1,["wiwi::iter::tuple::Tuple27"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24, I25, I26, I27, I28> Freeze for Tuple28<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24, I25, I26, I27, I28>
where\n I1: Freeze,\n I2: Freeze,\n I3: Freeze,\n I4: Freeze,\n I5: Freeze,\n I6: Freeze,\n I7: Freeze,\n I8: Freeze,\n I9: Freeze,\n I10: Freeze,\n I11: Freeze,\n I12: Freeze,\n I13: Freeze,\n I14: Freeze,\n I15: Freeze,\n I16: Freeze,\n I17: Freeze,\n I18: Freeze,\n I19: Freeze,\n I20: Freeze,\n I21: Freeze,\n I22: Freeze,\n I23: Freeze,\n I24: Freeze,\n I25: Freeze,\n I26: Freeze,\n I27: Freeze,\n I28: Freeze,
",1,["wiwi::iter::tuple::Tuple28"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24, I25, I26, I27, I28, I29> Freeze for Tuple29<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24, I25, I26, I27, I28, I29>
where\n I1: Freeze,\n I2: Freeze,\n I3: Freeze,\n I4: Freeze,\n I5: Freeze,\n I6: Freeze,\n I7: Freeze,\n I8: Freeze,\n I9: Freeze,\n I10: Freeze,\n I11: Freeze,\n I12: Freeze,\n I13: Freeze,\n I14: Freeze,\n I15: Freeze,\n I16: Freeze,\n I17: Freeze,\n I18: Freeze,\n I19: Freeze,\n I20: Freeze,\n I21: Freeze,\n I22: Freeze,\n I23: Freeze,\n I24: Freeze,\n I25: Freeze,\n I26: Freeze,\n I27: Freeze,\n I28: Freeze,\n I29: Freeze,
",1,["wiwi::iter::tuple::Tuple29"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24, I25, I26, I27, I28, I29, I30> Freeze for Tuple30<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24, I25, I26, I27, I28, I29, I30>
where\n I1: Freeze,\n I2: Freeze,\n I3: Freeze,\n I4: Freeze,\n I5: Freeze,\n I6: Freeze,\n I7: Freeze,\n I8: Freeze,\n I9: Freeze,\n I10: Freeze,\n I11: Freeze,\n I12: Freeze,\n I13: Freeze,\n I14: Freeze,\n I15: Freeze,\n I16: Freeze,\n I17: Freeze,\n I18: Freeze,\n I19: Freeze,\n I20: Freeze,\n I21: Freeze,\n I22: Freeze,\n I23: Freeze,\n I24: Freeze,\n I25: Freeze,\n I26: Freeze,\n I27: Freeze,\n I28: Freeze,\n I29: Freeze,\n I30: Freeze,
",1,["wiwi::iter::tuple::Tuple30"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24, I25, I26, I27, I28, I29, I30, I31> Freeze for Tuple31<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24, I25, I26, I27, I28, I29, I30, I31>
where\n I1: Freeze,\n I2: Freeze,\n I3: Freeze,\n I4: Freeze,\n I5: Freeze,\n I6: Freeze,\n I7: Freeze,\n I8: Freeze,\n I9: Freeze,\n I10: Freeze,\n I11: Freeze,\n I12: Freeze,\n I13: Freeze,\n I14: Freeze,\n I15: Freeze,\n I16: Freeze,\n I17: Freeze,\n I18: Freeze,\n I19: Freeze,\n I20: Freeze,\n I21: Freeze,\n I22: Freeze,\n I23: Freeze,\n I24: Freeze,\n I25: Freeze,\n I26: Freeze,\n I27: Freeze,\n I28: Freeze,\n I29: Freeze,\n I30: Freeze,\n I31: Freeze,
",1,["wiwi::iter::tuple::Tuple31"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24, I25, I26, I27, I28, I29, I30, I31, I32> Freeze for Tuple32<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24, I25, I26, I27, I28, I29, I30, I31, I32>
where\n I1: Freeze,\n I2: Freeze,\n I3: Freeze,\n I4: Freeze,\n I5: Freeze,\n I6: Freeze,\n I7: Freeze,\n I8: Freeze,\n I9: Freeze,\n I10: Freeze,\n I11: Freeze,\n I12: Freeze,\n I13: Freeze,\n I14: Freeze,\n I15: Freeze,\n I16: Freeze,\n I17: Freeze,\n I18: Freeze,\n I19: Freeze,\n I20: Freeze,\n I21: Freeze,\n I22: Freeze,\n I23: Freeze,\n I24: Freeze,\n I25: Freeze,\n I26: Freeze,\n I27: Freeze,\n I28: Freeze,\n I29: Freeze,\n I30: Freeze,\n I31: Freeze,\n I32: Freeze,
",1,["wiwi::iter::tuple::Tuple32"]],["impl<K, V> Freeze for BTreeMapChain<K, V>",1,["wiwi::chainer::btree_map::BTreeMapChain"]],["impl<K, V, S> Freeze for HashMapChain<K, V, S>
where\n S: Freeze,
",1,["wiwi::chainer::hash_map::HashMapChain"]],["impl<P> Freeze for String<P>
where\n <P as Pool>::Raw: Freeze,\n P: Freeze,
",1,["wiwi::string_pool::string::String"]],["impl<T> Freeze for BTreeSetChain<T>",1,["wiwi::chainer::btree_set::BTreeSetChain"]],["impl<T> Freeze for BinaryHeapChain<T>",1,["wiwi::chainer::binary_heap::BinaryHeapChain"]],["impl<T> Freeze for LinkedListChain<T>",1,["wiwi::chainer::linked_list::LinkedListChain"]],["impl<T> Freeze for SliceBoxChain<T>",1,["wiwi::chainer::slice_box::SliceBoxChain"]],["impl<T> Freeze for VecChain<T>",1,["wiwi::chainer::vec::VecChain"]],["impl<T> Freeze for VecDequeChain<T>",1,["wiwi::chainer::vec_deque::VecDequeChain"]],["impl<T> Freeze for Empty<T>",1,["wiwi::iter::empty::Empty"]],["impl<T, F = fn() -> T> !Freeze for LazyWrap<T, F>",1,["wiwi::lazy_wrap::LazyWrap"]],["impl<T, F> Freeze for LazyWrapState<T, F>
where\n T: Freeze,\n F: Freeze,
",1,["wiwi::lazy_wrap::LazyWrapState"]],["impl<T, S> Freeze for HashSetChain<T, S>
where\n S: Freeze,
",1,["wiwi::chainer::hash_set::HashSetChain"]],["impl<T, const N: usize> Freeze for ArrayChain<T, N>
where\n T: Freeze,
",1,["wiwi::chainer::array::ArrayChain"]]] +"wiwi":[["impl Freeze for DecodeError",1,["wiwi::hex::DecodeError"]],["impl Freeze for SizeHintBound",1,["wiwi::iter::size_hint::SizeHintBound"]],["impl Freeze for Error",1,["wiwi::serialiser::error::Error"]],["impl Freeze for DecodeError",1,["wiwi::z85::DecodeError"]],["impl Freeze for Error",1,["wiwi::auth::error::Error"]],["impl Freeze for ClientContinuerS1",1,["wiwi::auth::flow::signin::ClientContinuerS1"]],["impl Freeze for ClientContinuerS2",1,["wiwi::auth::flow::signin::ClientContinuerS2"]],["impl Freeze for ClientContinuerS3",1,["wiwi::auth::flow::signin::ClientContinuerS3"]],["impl Freeze for ServerS2Params",1,["wiwi::auth::flow::signin::ServerS2Params"]],["impl Freeze for ServerS3Params",1,["wiwi::auth::flow::signin::ServerS3Params"]],["impl Freeze for SigninRequestS1",1,["wiwi::auth::flow::signin::SigninRequestS1"]],["impl Freeze for SigninRequestS2",1,["wiwi::auth::flow::signin::SigninRequestS2"]],["impl Freeze for SigninRequestS3",1,["wiwi::auth::flow::signin::SigninRequestS3"]],["impl Freeze for SigninResponseS1",1,["wiwi::auth::flow::signin::SigninResponseS1"]],["impl Freeze for SigninResponseS2",1,["wiwi::auth::flow::signin::SigninResponseS2"]],["impl Freeze for SigninResponseS3",1,["wiwi::auth::flow::signin::SigninResponseS3"]],["impl Freeze for SignupRequest",1,["wiwi::auth::flow::signup::SignupRequest"]],["impl Freeze for StoredUnverifiedUserData",1,["wiwi::auth::flow::signup::StoredUnverifiedUserData"]],["impl Freeze for U320",1,["wiwi::bigint::U320"]],["impl Freeze for Encoder",1,["wiwi::bitstream::Encoder"]],["impl Freeze for BitstreamEncoderChain",1,["wiwi::chainer::bitstream::BitstreamEncoderChain"]],["impl Freeze for StrBoxChain",1,["wiwi::chainer::str_box::StrBoxChain"]],["impl Freeze for StringChain",1,["wiwi::chainer::string::StringChain"]],["impl Freeze for Builder",1,["wiwi::clock_timer::builder::Builder"]],["impl Freeze for BuilderWithEnd",1,["wiwi::clock_timer::builder::BuilderWithEnd"]],["impl Freeze for BuilderWithInterval",1,["wiwi::clock_timer::builder::BuilderWithInterval"]],["impl Freeze for BuilderWithStart",1,["wiwi::clock_timer::builder::BuilderWithStart"]],["impl Freeze for ClockTimer",1,["wiwi::clock_timer::ClockTimer"]],["impl Freeze for Tick",1,["wiwi::clock_timer::Tick"]],["impl Freeze for GeneratedID",1,["wiwi::id::GeneratedID"]],["impl Freeze for IDGenerator",1,["wiwi::id::IDGenerator"]],["impl Freeze for SizeHint",1,["wiwi::iter::size_hint::SizeHint"]],["impl Freeze for Script",1,["wiwi::lsl::callback_api::script::Script"]],["impl Freeze for ScriptBuilder",1,["wiwi::lsl::callback_api::script::ScriptBuilder"]],["impl Freeze for Marker",1,["wiwi::serialiser::marker::Marker"]],["impl Freeze for SerialiseOptions",1,["wiwi::serialiser::serialise::SerialiseOptions"]],["impl Freeze for GlobalPool",1,["wiwi::string_pool::pool::global::GlobalPool"]],["impl Freeze for Board",1,["wiwi::sudoku::Board"]],["impl<'h> Freeze for StrMutChain<'h>",1,["wiwi::chainer::str_mut::StrMutChain"]],["impl<'h> Freeze for StrRefChain<'h>",1,["wiwi::chainer::str_ref::StrRefChain"]],["impl<'h> Freeze for StringMutChain<'h>",1,["wiwi::chainer::string_mut::StringMutChain"]],["impl<'h> Freeze for StringRefChain<'h>",1,["wiwi::chainer::string_ref::StringRefChain"]],["impl<'h> Freeze for SlicesWrap<'h>",1,["wiwi::string_pool::pool::SlicesWrap"]],["impl<'h> Freeze for SlicesWrapIter<'h>",1,["wiwi::string_pool::pool::SlicesWrapIter"]],["impl<'h, T> Freeze for SliceMutChain<'h, T>",1,["wiwi::chainer::slice_mut::SliceMutChain"]],["impl<'h, T> Freeze for SliceRefChain<'h, T>",1,["wiwi::chainer::slice_ref::SliceRefChain"]],["impl<'h, T> Freeze for VecMutChain<'h, T>",1,["wiwi::chainer::vec_mut::VecMutChain"]],["impl<'h, T> Freeze for VecRefChain<'h, T>",1,["wiwi::chainer::vec_ref::VecRefChain"]],["impl<'h, T, const N: usize> Freeze for ArrayMutChain<'h, T, N>",1,["wiwi::chainer::array_mut::ArrayMutChain"]],["impl<'h, T, const N: usize> Freeze for ArrayRefChain<'h, T, N>",1,["wiwi::chainer::array_ref::ArrayRefChain"]],["impl<F> Freeze for FromFn<F>
where\n F: Freeze,
",1,["wiwi::iter::from_fn::FromFn"]],["impl<I> Freeze for IterAdapter<I>
where\n I: Freeze,
",1,["wiwi::iter::adapter::IterAdapter"]],["impl<I> Freeze for RepeatPerItem<I>
where\n I: Freeze,\n <I as Iter>::Item: Freeze,
",1,["wiwi::iter::repeat_per_item::RepeatPerItem"]],["impl<I> Freeze for Rev<I>
where\n I: Freeze,
",1,["wiwi::iter::rev::Rev"]],["impl<I, F> Freeze for Map<I, F>
where\n I: Freeze,\n F: Freeze,
",1,["wiwi::iter::map::Map"]],["impl<I, T> Freeze for Peek<I, T>
where\n I: Freeze,\n T: Freeze,
",1,["wiwi::iter::peek::Peek"]],["impl<I1> Freeze for Tuple1<I1>
where\n I1: Freeze,
",1,["wiwi::iter::tuple::Tuple1"]],["impl<I1, I2> Freeze for Tuple2<I1, I2>
where\n I1: Freeze,\n I2: Freeze,
",1,["wiwi::iter::tuple::Tuple2"]],["impl<I1, I2, I3> Freeze for Tuple3<I1, I2, I3>
where\n I1: Freeze,\n I2: Freeze,\n I3: Freeze,
",1,["wiwi::iter::tuple::Tuple3"]],["impl<I1, I2, I3, I4> Freeze for Tuple4<I1, I2, I3, I4>
where\n I1: Freeze,\n I2: Freeze,\n I3: Freeze,\n I4: Freeze,
",1,["wiwi::iter::tuple::Tuple4"]],["impl<I1, I2, I3, I4, I5> Freeze for Tuple5<I1, I2, I3, I4, I5>
where\n I1: Freeze,\n I2: Freeze,\n I3: Freeze,\n I4: Freeze,\n I5: Freeze,
",1,["wiwi::iter::tuple::Tuple5"]],["impl<I1, I2, I3, I4, I5, I6> Freeze for Tuple6<I1, I2, I3, I4, I5, I6>
where\n I1: Freeze,\n I2: Freeze,\n I3: Freeze,\n I4: Freeze,\n I5: Freeze,\n I6: Freeze,
",1,["wiwi::iter::tuple::Tuple6"]],["impl<I1, I2, I3, I4, I5, I6, I7> Freeze for Tuple7<I1, I2, I3, I4, I5, I6, I7>
where\n I1: Freeze,\n I2: Freeze,\n I3: Freeze,\n I4: Freeze,\n I5: Freeze,\n I6: Freeze,\n I7: Freeze,
",1,["wiwi::iter::tuple::Tuple7"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8> Freeze for Tuple8<I1, I2, I3, I4, I5, I6, I7, I8>
where\n I1: Freeze,\n I2: Freeze,\n I3: Freeze,\n I4: Freeze,\n I5: Freeze,\n I6: Freeze,\n I7: Freeze,\n I8: Freeze,
",1,["wiwi::iter::tuple::Tuple8"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9> Freeze for Tuple9<I1, I2, I3, I4, I5, I6, I7, I8, I9>
where\n I1: Freeze,\n I2: Freeze,\n I3: Freeze,\n I4: Freeze,\n I5: Freeze,\n I6: Freeze,\n I7: Freeze,\n I8: Freeze,\n I9: Freeze,
",1,["wiwi::iter::tuple::Tuple9"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10> Freeze for Tuple10<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10>
where\n I1: Freeze,\n I2: Freeze,\n I3: Freeze,\n I4: Freeze,\n I5: Freeze,\n I6: Freeze,\n I7: Freeze,\n I8: Freeze,\n I9: Freeze,\n I10: Freeze,
",1,["wiwi::iter::tuple::Tuple10"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11> Freeze for Tuple11<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11>
where\n I1: Freeze,\n I2: Freeze,\n I3: Freeze,\n I4: Freeze,\n I5: Freeze,\n I6: Freeze,\n I7: Freeze,\n I8: Freeze,\n I9: Freeze,\n I10: Freeze,\n I11: Freeze,
",1,["wiwi::iter::tuple::Tuple11"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12> Freeze for Tuple12<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12>
where\n I1: Freeze,\n I2: Freeze,\n I3: Freeze,\n I4: Freeze,\n I5: Freeze,\n I6: Freeze,\n I7: Freeze,\n I8: Freeze,\n I9: Freeze,\n I10: Freeze,\n I11: Freeze,\n I12: Freeze,
",1,["wiwi::iter::tuple::Tuple12"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13> Freeze for Tuple13<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13>
where\n I1: Freeze,\n I2: Freeze,\n I3: Freeze,\n I4: Freeze,\n I5: Freeze,\n I6: Freeze,\n I7: Freeze,\n I8: Freeze,\n I9: Freeze,\n I10: Freeze,\n I11: Freeze,\n I12: Freeze,\n I13: Freeze,
",1,["wiwi::iter::tuple::Tuple13"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14> Freeze for Tuple14<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14>
where\n I1: Freeze,\n I2: Freeze,\n I3: Freeze,\n I4: Freeze,\n I5: Freeze,\n I6: Freeze,\n I7: Freeze,\n I8: Freeze,\n I9: Freeze,\n I10: Freeze,\n I11: Freeze,\n I12: Freeze,\n I13: Freeze,\n I14: Freeze,
",1,["wiwi::iter::tuple::Tuple14"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15> Freeze for Tuple15<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15>
where\n I1: Freeze,\n I2: Freeze,\n I3: Freeze,\n I4: Freeze,\n I5: Freeze,\n I6: Freeze,\n I7: Freeze,\n I8: Freeze,\n I9: Freeze,\n I10: Freeze,\n I11: Freeze,\n I12: Freeze,\n I13: Freeze,\n I14: Freeze,\n I15: Freeze,
",1,["wiwi::iter::tuple::Tuple15"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16> Freeze for Tuple16<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16>
where\n I1: Freeze,\n I2: Freeze,\n I3: Freeze,\n I4: Freeze,\n I5: Freeze,\n I6: Freeze,\n I7: Freeze,\n I8: Freeze,\n I9: Freeze,\n I10: Freeze,\n I11: Freeze,\n I12: Freeze,\n I13: Freeze,\n I14: Freeze,\n I15: Freeze,\n I16: Freeze,
",1,["wiwi::iter::tuple::Tuple16"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17> Freeze for Tuple17<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17>
where\n I1: Freeze,\n I2: Freeze,\n I3: Freeze,\n I4: Freeze,\n I5: Freeze,\n I6: Freeze,\n I7: Freeze,\n I8: Freeze,\n I9: Freeze,\n I10: Freeze,\n I11: Freeze,\n I12: Freeze,\n I13: Freeze,\n I14: Freeze,\n I15: Freeze,\n I16: Freeze,\n I17: Freeze,
",1,["wiwi::iter::tuple::Tuple17"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18> Freeze for Tuple18<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18>
where\n I1: Freeze,\n I2: Freeze,\n I3: Freeze,\n I4: Freeze,\n I5: Freeze,\n I6: Freeze,\n I7: Freeze,\n I8: Freeze,\n I9: Freeze,\n I10: Freeze,\n I11: Freeze,\n I12: Freeze,\n I13: Freeze,\n I14: Freeze,\n I15: Freeze,\n I16: Freeze,\n I17: Freeze,\n I18: Freeze,
",1,["wiwi::iter::tuple::Tuple18"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19> Freeze for Tuple19<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19>
where\n I1: Freeze,\n I2: Freeze,\n I3: Freeze,\n I4: Freeze,\n I5: Freeze,\n I6: Freeze,\n I7: Freeze,\n I8: Freeze,\n I9: Freeze,\n I10: Freeze,\n I11: Freeze,\n I12: Freeze,\n I13: Freeze,\n I14: Freeze,\n I15: Freeze,\n I16: Freeze,\n I17: Freeze,\n I18: Freeze,\n I19: Freeze,
",1,["wiwi::iter::tuple::Tuple19"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20> Freeze for Tuple20<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20>
where\n I1: Freeze,\n I2: Freeze,\n I3: Freeze,\n I4: Freeze,\n I5: Freeze,\n I6: Freeze,\n I7: Freeze,\n I8: Freeze,\n I9: Freeze,\n I10: Freeze,\n I11: Freeze,\n I12: Freeze,\n I13: Freeze,\n I14: Freeze,\n I15: Freeze,\n I16: Freeze,\n I17: Freeze,\n I18: Freeze,\n I19: Freeze,\n I20: Freeze,
",1,["wiwi::iter::tuple::Tuple20"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21> Freeze for Tuple21<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21>
where\n I1: Freeze,\n I2: Freeze,\n I3: Freeze,\n I4: Freeze,\n I5: Freeze,\n I6: Freeze,\n I7: Freeze,\n I8: Freeze,\n I9: Freeze,\n I10: Freeze,\n I11: Freeze,\n I12: Freeze,\n I13: Freeze,\n I14: Freeze,\n I15: Freeze,\n I16: Freeze,\n I17: Freeze,\n I18: Freeze,\n I19: Freeze,\n I20: Freeze,\n I21: Freeze,
",1,["wiwi::iter::tuple::Tuple21"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22> Freeze for Tuple22<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22>
where\n I1: Freeze,\n I2: Freeze,\n I3: Freeze,\n I4: Freeze,\n I5: Freeze,\n I6: Freeze,\n I7: Freeze,\n I8: Freeze,\n I9: Freeze,\n I10: Freeze,\n I11: Freeze,\n I12: Freeze,\n I13: Freeze,\n I14: Freeze,\n I15: Freeze,\n I16: Freeze,\n I17: Freeze,\n I18: Freeze,\n I19: Freeze,\n I20: Freeze,\n I21: Freeze,\n I22: Freeze,
",1,["wiwi::iter::tuple::Tuple22"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23> Freeze for Tuple23<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23>
where\n I1: Freeze,\n I2: Freeze,\n I3: Freeze,\n I4: Freeze,\n I5: Freeze,\n I6: Freeze,\n I7: Freeze,\n I8: Freeze,\n I9: Freeze,\n I10: Freeze,\n I11: Freeze,\n I12: Freeze,\n I13: Freeze,\n I14: Freeze,\n I15: Freeze,\n I16: Freeze,\n I17: Freeze,\n I18: Freeze,\n I19: Freeze,\n I20: Freeze,\n I21: Freeze,\n I22: Freeze,\n I23: Freeze,
",1,["wiwi::iter::tuple::Tuple23"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24> Freeze for Tuple24<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24>
where\n I1: Freeze,\n I2: Freeze,\n I3: Freeze,\n I4: Freeze,\n I5: Freeze,\n I6: Freeze,\n I7: Freeze,\n I8: Freeze,\n I9: Freeze,\n I10: Freeze,\n I11: Freeze,\n I12: Freeze,\n I13: Freeze,\n I14: Freeze,\n I15: Freeze,\n I16: Freeze,\n I17: Freeze,\n I18: Freeze,\n I19: Freeze,\n I20: Freeze,\n I21: Freeze,\n I22: Freeze,\n I23: Freeze,\n I24: Freeze,
",1,["wiwi::iter::tuple::Tuple24"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24, I25> Freeze for Tuple25<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24, I25>
where\n I1: Freeze,\n I2: Freeze,\n I3: Freeze,\n I4: Freeze,\n I5: Freeze,\n I6: Freeze,\n I7: Freeze,\n I8: Freeze,\n I9: Freeze,\n I10: Freeze,\n I11: Freeze,\n I12: Freeze,\n I13: Freeze,\n I14: Freeze,\n I15: Freeze,\n I16: Freeze,\n I17: Freeze,\n I18: Freeze,\n I19: Freeze,\n I20: Freeze,\n I21: Freeze,\n I22: Freeze,\n I23: Freeze,\n I24: Freeze,\n I25: Freeze,
",1,["wiwi::iter::tuple::Tuple25"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24, I25, I26> Freeze for Tuple26<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24, I25, I26>
where\n I1: Freeze,\n I2: Freeze,\n I3: Freeze,\n I4: Freeze,\n I5: Freeze,\n I6: Freeze,\n I7: Freeze,\n I8: Freeze,\n I9: Freeze,\n I10: Freeze,\n I11: Freeze,\n I12: Freeze,\n I13: Freeze,\n I14: Freeze,\n I15: Freeze,\n I16: Freeze,\n I17: Freeze,\n I18: Freeze,\n I19: Freeze,\n I20: Freeze,\n I21: Freeze,\n I22: Freeze,\n I23: Freeze,\n I24: Freeze,\n I25: Freeze,\n I26: Freeze,
",1,["wiwi::iter::tuple::Tuple26"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24, I25, I26, I27> Freeze for Tuple27<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24, I25, I26, I27>
where\n I1: Freeze,\n I2: Freeze,\n I3: Freeze,\n I4: Freeze,\n I5: Freeze,\n I6: Freeze,\n I7: Freeze,\n I8: Freeze,\n I9: Freeze,\n I10: Freeze,\n I11: Freeze,\n I12: Freeze,\n I13: Freeze,\n I14: Freeze,\n I15: Freeze,\n I16: Freeze,\n I17: Freeze,\n I18: Freeze,\n I19: Freeze,\n I20: Freeze,\n I21: Freeze,\n I22: Freeze,\n I23: Freeze,\n I24: Freeze,\n I25: Freeze,\n I26: Freeze,\n I27: Freeze,
",1,["wiwi::iter::tuple::Tuple27"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24, I25, I26, I27, I28> Freeze for Tuple28<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24, I25, I26, I27, I28>
where\n I1: Freeze,\n I2: Freeze,\n I3: Freeze,\n I4: Freeze,\n I5: Freeze,\n I6: Freeze,\n I7: Freeze,\n I8: Freeze,\n I9: Freeze,\n I10: Freeze,\n I11: Freeze,\n I12: Freeze,\n I13: Freeze,\n I14: Freeze,\n I15: Freeze,\n I16: Freeze,\n I17: Freeze,\n I18: Freeze,\n I19: Freeze,\n I20: Freeze,\n I21: Freeze,\n I22: Freeze,\n I23: Freeze,\n I24: Freeze,\n I25: Freeze,\n I26: Freeze,\n I27: Freeze,\n I28: Freeze,
",1,["wiwi::iter::tuple::Tuple28"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24, I25, I26, I27, I28, I29> Freeze for Tuple29<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24, I25, I26, I27, I28, I29>
where\n I1: Freeze,\n I2: Freeze,\n I3: Freeze,\n I4: Freeze,\n I5: Freeze,\n I6: Freeze,\n I7: Freeze,\n I8: Freeze,\n I9: Freeze,\n I10: Freeze,\n I11: Freeze,\n I12: Freeze,\n I13: Freeze,\n I14: Freeze,\n I15: Freeze,\n I16: Freeze,\n I17: Freeze,\n I18: Freeze,\n I19: Freeze,\n I20: Freeze,\n I21: Freeze,\n I22: Freeze,\n I23: Freeze,\n I24: Freeze,\n I25: Freeze,\n I26: Freeze,\n I27: Freeze,\n I28: Freeze,\n I29: Freeze,
",1,["wiwi::iter::tuple::Tuple29"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24, I25, I26, I27, I28, I29, I30> Freeze for Tuple30<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24, I25, I26, I27, I28, I29, I30>
where\n I1: Freeze,\n I2: Freeze,\n I3: Freeze,\n I4: Freeze,\n I5: Freeze,\n I6: Freeze,\n I7: Freeze,\n I8: Freeze,\n I9: Freeze,\n I10: Freeze,\n I11: Freeze,\n I12: Freeze,\n I13: Freeze,\n I14: Freeze,\n I15: Freeze,\n I16: Freeze,\n I17: Freeze,\n I18: Freeze,\n I19: Freeze,\n I20: Freeze,\n I21: Freeze,\n I22: Freeze,\n I23: Freeze,\n I24: Freeze,\n I25: Freeze,\n I26: Freeze,\n I27: Freeze,\n I28: Freeze,\n I29: Freeze,\n I30: Freeze,
",1,["wiwi::iter::tuple::Tuple30"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24, I25, I26, I27, I28, I29, I30, I31> Freeze for Tuple31<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24, I25, I26, I27, I28, I29, I30, I31>
where\n I1: Freeze,\n I2: Freeze,\n I3: Freeze,\n I4: Freeze,\n I5: Freeze,\n I6: Freeze,\n I7: Freeze,\n I8: Freeze,\n I9: Freeze,\n I10: Freeze,\n I11: Freeze,\n I12: Freeze,\n I13: Freeze,\n I14: Freeze,\n I15: Freeze,\n I16: Freeze,\n I17: Freeze,\n I18: Freeze,\n I19: Freeze,\n I20: Freeze,\n I21: Freeze,\n I22: Freeze,\n I23: Freeze,\n I24: Freeze,\n I25: Freeze,\n I26: Freeze,\n I27: Freeze,\n I28: Freeze,\n I29: Freeze,\n I30: Freeze,\n I31: Freeze,
",1,["wiwi::iter::tuple::Tuple31"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24, I25, I26, I27, I28, I29, I30, I31, I32> Freeze for Tuple32<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24, I25, I26, I27, I28, I29, I30, I31, I32>
where\n I1: Freeze,\n I2: Freeze,\n I3: Freeze,\n I4: Freeze,\n I5: Freeze,\n I6: Freeze,\n I7: Freeze,\n I8: Freeze,\n I9: Freeze,\n I10: Freeze,\n I11: Freeze,\n I12: Freeze,\n I13: Freeze,\n I14: Freeze,\n I15: Freeze,\n I16: Freeze,\n I17: Freeze,\n I18: Freeze,\n I19: Freeze,\n I20: Freeze,\n I21: Freeze,\n I22: Freeze,\n I23: Freeze,\n I24: Freeze,\n I25: Freeze,\n I26: Freeze,\n I27: Freeze,\n I28: Freeze,\n I29: Freeze,\n I30: Freeze,\n I31: Freeze,\n I32: Freeze,
",1,["wiwi::iter::tuple::Tuple32"]],["impl<K, V> Freeze for BTreeMapChain<K, V>",1,["wiwi::chainer::btree_map::BTreeMapChain"]],["impl<K, V, S> Freeze for HashMapChain<K, V, S>
where\n S: Freeze,
",1,["wiwi::chainer::hash_map::HashMapChain"]],["impl<P> Freeze for String<P>
where\n <P as Pool>::Raw: Freeze,\n P: Freeze,
",1,["wiwi::string_pool::string::String"]],["impl<T> Freeze for BTreeSetChain<T>",1,["wiwi::chainer::btree_set::BTreeSetChain"]],["impl<T> Freeze for BinaryHeapChain<T>",1,["wiwi::chainer::binary_heap::BinaryHeapChain"]],["impl<T> Freeze for LinkedListChain<T>",1,["wiwi::chainer::linked_list::LinkedListChain"]],["impl<T> Freeze for SliceBoxChain<T>",1,["wiwi::chainer::slice_box::SliceBoxChain"]],["impl<T> Freeze for VecChain<T>",1,["wiwi::chainer::vec::VecChain"]],["impl<T> Freeze for VecDequeChain<T>",1,["wiwi::chainer::vec_deque::VecDequeChain"]],["impl<T> Freeze for Empty<T>",1,["wiwi::iter::empty::Empty"]],["impl<T, F = fn() -> T> !Freeze for LazyWrap<T, F>",1,["wiwi::lazy_wrap::LazyWrap"]],["impl<T, F> Freeze for LazyWrapState<T, F>
where\n T: Freeze,\n F: Freeze,
",1,["wiwi::lazy_wrap::LazyWrapState"]],["impl<T, S> Freeze for HashSetChain<T, S>
where\n S: Freeze,
",1,["wiwi::chainer::hash_set::HashSetChain"]],["impl<T, const N: usize> Freeze for ArrayChain<T, N>
where\n T: Freeze,
",1,["wiwi::chainer::array::ArrayChain"]]] };if (window.register_implementors) {window.register_implementors(implementors);} else {window.pending_implementors = implementors;}})() \ No newline at end of file diff --git a/trait.impl/core/marker/trait.Send.js b/trait.impl/core/marker/trait.Send.js index 8c3f47149..0ed8decb1 100644 --- a/trait.impl/core/marker/trait.Send.js +++ b/trait.impl/core/marker/trait.Send.js @@ -1,3 +1,3 @@ (function() {var implementors = { -"wiwi":[["impl !Send for IDGenerator",1,["wiwi::id::IDGenerator"]],["impl !Send for Script",1,["wiwi::lsl::callback_api::script::Script"]],["impl !Send for ScriptBuilder",1,["wiwi::lsl::callback_api::script::ScriptBuilder"]],["impl Send for DecodeError",1,["wiwi::hex::DecodeError"]],["impl Send for SizeHintBound",1,["wiwi::iter::size_hint::SizeHintBound"]],["impl Send for Error",1,["wiwi::serialiser::error::Error"]],["impl Send for DecodeError",1,["wiwi::z85::DecodeError"]],["impl Send for Error",1,["wiwi::auth::error::Error"]],["impl Send for ClientContinuerS1",1,["wiwi::auth::flow::signin::ClientContinuerS1"]],["impl Send for ClientContinuerS2",1,["wiwi::auth::flow::signin::ClientContinuerS2"]],["impl Send for ClientContinuerS3",1,["wiwi::auth::flow::signin::ClientContinuerS3"]],["impl Send for ServerS2Params",1,["wiwi::auth::flow::signin::ServerS2Params"]],["impl Send for ServerS3Params",1,["wiwi::auth::flow::signin::ServerS3Params"]],["impl Send for SigninRequestS1",1,["wiwi::auth::flow::signin::SigninRequestS1"]],["impl Send for SigninRequestS2",1,["wiwi::auth::flow::signin::SigninRequestS2"]],["impl Send for SigninRequestS3",1,["wiwi::auth::flow::signin::SigninRequestS3"]],["impl Send for SigninResponseS1",1,["wiwi::auth::flow::signin::SigninResponseS1"]],["impl Send for SigninResponseS2",1,["wiwi::auth::flow::signin::SigninResponseS2"]],["impl Send for SigninResponseS3",1,["wiwi::auth::flow::signin::SigninResponseS3"]],["impl Send for SignupRequest",1,["wiwi::auth::flow::signup::SignupRequest"]],["impl Send for StoredUnverifiedUserData",1,["wiwi::auth::flow::signup::StoredUnverifiedUserData"]],["impl Send for U320",1,["wiwi::bigint::U320"]],["impl Send for Encoder",1,["wiwi::bitstream::Encoder"]],["impl Send for BitstreamEncoderChain",1,["wiwi::chainer::bitstream::BitstreamEncoderChain"]],["impl Send for StrBoxChain",1,["wiwi::chainer::str_box::StrBoxChain"]],["impl Send for StringChain",1,["wiwi::chainer::string::StringChain"]],["impl Send for Builder",1,["wiwi::clock_timer::builder::Builder"]],["impl Send for BuilderWithEnd",1,["wiwi::clock_timer::builder::BuilderWithEnd"]],["impl Send for BuilderWithInterval",1,["wiwi::clock_timer::builder::BuilderWithInterval"]],["impl Send for BuilderWithStart",1,["wiwi::clock_timer::builder::BuilderWithStart"]],["impl Send for ClockTimer",1,["wiwi::clock_timer::ClockTimer"]],["impl Send for Tick",1,["wiwi::clock_timer::Tick"]],["impl Send for GeneratedID",1,["wiwi::id::GeneratedID"]],["impl Send for SizeHint",1,["wiwi::iter::size_hint::SizeHint"]],["impl Send for SerialiseOptions",1,["wiwi::serialiser::serialise::SerialiseOptions"]],["impl Send for GlobalPool",1,["wiwi::string_pool::pool::global::GlobalPool"]],["impl Send for Board",1,["wiwi::sudoku::Board"]],["impl<'h> Send for StrMutChain<'h>",1,["wiwi::chainer::str_mut::StrMutChain"]],["impl<'h> Send for StrRefChain<'h>",1,["wiwi::chainer::str_ref::StrRefChain"]],["impl<'h> Send for StringMutChain<'h>",1,["wiwi::chainer::string_mut::StringMutChain"]],["impl<'h> Send for StringRefChain<'h>",1,["wiwi::chainer::string_ref::StringRefChain"]],["impl<'h> Send for SlicesWrap<'h>",1,["wiwi::string_pool::pool::SlicesWrap"]],["impl<'h> Send for SlicesWrapIter<'h>",1,["wiwi::string_pool::pool::SlicesWrapIter"]],["impl<'h, T> Send for SliceMutChain<'h, T>
where\n T: Send,
",1,["wiwi::chainer::slice_mut::SliceMutChain"]],["impl<'h, T> Send for SliceRefChain<'h, T>
where\n T: Sync,
",1,["wiwi::chainer::slice_ref::SliceRefChain"]],["impl<'h, T> Send for VecMutChain<'h, T>
where\n T: Send,
",1,["wiwi::chainer::vec_mut::VecMutChain"]],["impl<'h, T> Send for VecRefChain<'h, T>
where\n T: Sync,
",1,["wiwi::chainer::vec_ref::VecRefChain"]],["impl<'h, T, const N: usize> Send for ArrayMutChain<'h, T, N>
where\n T: Send,
",1,["wiwi::chainer::array_mut::ArrayMutChain"]],["impl<'h, T, const N: usize> Send for ArrayRefChain<'h, T, N>
where\n T: Sync,
",1,["wiwi::chainer::array_ref::ArrayRefChain"]],["impl<F> Send for FromFn<F>
where\n F: Send,
",1,["wiwi::iter::from_fn::FromFn"]],["impl<I> Send for IterAdapter<I>
where\n I: Send,
",1,["wiwi::iter::adapter::IterAdapter"]],["impl<I> Send for RepeatPerItem<I>
where\n I: Send,\n <I as Iter>::Item: Send,
",1,["wiwi::iter::repeat_per_item::RepeatPerItem"]],["impl<I, F> Send for Map<I, F>
where\n I: Send,\n F: Send,
",1,["wiwi::iter::map::Map"]],["impl<I, T> Send for Peek<I, T>
where\n I: Send,\n T: Send,
",1,["wiwi::iter::peek::Peek"]],["impl<I1> Send for Tuple1<I1>
where\n I1: Send,
",1,["wiwi::iter::tuple::Tuple1"]],["impl<I1, I2> Send for Tuple2<I1, I2>
where\n I1: Send,\n I2: Send,
",1,["wiwi::iter::tuple::Tuple2"]],["impl<I1, I2, I3> Send for Tuple3<I1, I2, I3>
where\n I1: Send,\n I2: Send,\n I3: Send,
",1,["wiwi::iter::tuple::Tuple3"]],["impl<I1, I2, I3, I4> Send for Tuple4<I1, I2, I3, I4>
where\n I1: Send,\n I2: Send,\n I3: Send,\n I4: Send,
",1,["wiwi::iter::tuple::Tuple4"]],["impl<I1, I2, I3, I4, I5> Send for Tuple5<I1, I2, I3, I4, I5>
where\n I1: Send,\n I2: Send,\n I3: Send,\n I4: Send,\n I5: Send,
",1,["wiwi::iter::tuple::Tuple5"]],["impl<I1, I2, I3, I4, I5, I6> Send for Tuple6<I1, I2, I3, I4, I5, I6>
where\n I1: Send,\n I2: Send,\n I3: Send,\n I4: Send,\n I5: Send,\n I6: Send,
",1,["wiwi::iter::tuple::Tuple6"]],["impl<I1, I2, I3, I4, I5, I6, I7> Send for Tuple7<I1, I2, I3, I4, I5, I6, I7>
where\n I1: Send,\n I2: Send,\n I3: Send,\n I4: Send,\n I5: Send,\n I6: Send,\n I7: Send,
",1,["wiwi::iter::tuple::Tuple7"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8> Send for Tuple8<I1, I2, I3, I4, I5, I6, I7, I8>
where\n I1: Send,\n I2: Send,\n I3: Send,\n I4: Send,\n I5: Send,\n I6: Send,\n I7: Send,\n I8: Send,
",1,["wiwi::iter::tuple::Tuple8"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9> Send for Tuple9<I1, I2, I3, I4, I5, I6, I7, I8, I9>
where\n I1: Send,\n I2: Send,\n I3: Send,\n I4: Send,\n I5: Send,\n I6: Send,\n I7: Send,\n I8: Send,\n I9: Send,
",1,["wiwi::iter::tuple::Tuple9"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10> Send for Tuple10<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10>
where\n I1: Send,\n I2: Send,\n I3: Send,\n I4: Send,\n I5: Send,\n I6: Send,\n I7: Send,\n I8: Send,\n I9: Send,\n I10: Send,
",1,["wiwi::iter::tuple::Tuple10"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11> Send for Tuple11<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11>
where\n I1: Send,\n I2: Send,\n I3: Send,\n I4: Send,\n I5: Send,\n I6: Send,\n I7: Send,\n I8: Send,\n I9: Send,\n I10: Send,\n I11: Send,
",1,["wiwi::iter::tuple::Tuple11"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12> Send for Tuple12<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12>
where\n I1: Send,\n I2: Send,\n I3: Send,\n I4: Send,\n I5: Send,\n I6: Send,\n I7: Send,\n I8: Send,\n I9: Send,\n I10: Send,\n I11: Send,\n I12: Send,
",1,["wiwi::iter::tuple::Tuple12"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13> Send for Tuple13<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13>
where\n I1: Send,\n I2: Send,\n I3: Send,\n I4: Send,\n I5: Send,\n I6: Send,\n I7: Send,\n I8: Send,\n I9: Send,\n I10: Send,\n I11: Send,\n I12: Send,\n I13: Send,
",1,["wiwi::iter::tuple::Tuple13"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14> Send for Tuple14<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14>
where\n I1: Send,\n I2: Send,\n I3: Send,\n I4: Send,\n I5: Send,\n I6: Send,\n I7: Send,\n I8: Send,\n I9: Send,\n I10: Send,\n I11: Send,\n I12: Send,\n I13: Send,\n I14: Send,
",1,["wiwi::iter::tuple::Tuple14"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15> Send for Tuple15<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15>
where\n I1: Send,\n I2: Send,\n I3: Send,\n I4: Send,\n I5: Send,\n I6: Send,\n I7: Send,\n I8: Send,\n I9: Send,\n I10: Send,\n I11: Send,\n I12: Send,\n I13: Send,\n I14: Send,\n I15: Send,
",1,["wiwi::iter::tuple::Tuple15"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16> Send for Tuple16<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16>
where\n I1: Send,\n I2: Send,\n I3: Send,\n I4: Send,\n I5: Send,\n I6: Send,\n I7: Send,\n I8: Send,\n I9: Send,\n I10: Send,\n I11: Send,\n I12: Send,\n I13: Send,\n I14: Send,\n I15: Send,\n I16: Send,
",1,["wiwi::iter::tuple::Tuple16"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17> Send for Tuple17<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17>
where\n I1: Send,\n I2: Send,\n I3: Send,\n I4: Send,\n I5: Send,\n I6: Send,\n I7: Send,\n I8: Send,\n I9: Send,\n I10: Send,\n I11: Send,\n I12: Send,\n I13: Send,\n I14: Send,\n I15: Send,\n I16: Send,\n I17: Send,
",1,["wiwi::iter::tuple::Tuple17"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18> Send for Tuple18<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18>
where\n I1: Send,\n I2: Send,\n I3: Send,\n I4: Send,\n I5: Send,\n I6: Send,\n I7: Send,\n I8: Send,\n I9: Send,\n I10: Send,\n I11: Send,\n I12: Send,\n I13: Send,\n I14: Send,\n I15: Send,\n I16: Send,\n I17: Send,\n I18: Send,
",1,["wiwi::iter::tuple::Tuple18"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19> Send for Tuple19<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19>
where\n I1: Send,\n I2: Send,\n I3: Send,\n I4: Send,\n I5: Send,\n I6: Send,\n I7: Send,\n I8: Send,\n I9: Send,\n I10: Send,\n I11: Send,\n I12: Send,\n I13: Send,\n I14: Send,\n I15: Send,\n I16: Send,\n I17: Send,\n I18: Send,\n I19: Send,
",1,["wiwi::iter::tuple::Tuple19"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20> Send for Tuple20<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20>
where\n I1: Send,\n I2: Send,\n I3: Send,\n I4: Send,\n I5: Send,\n I6: Send,\n I7: Send,\n I8: Send,\n I9: Send,\n I10: Send,\n I11: Send,\n I12: Send,\n I13: Send,\n I14: Send,\n I15: Send,\n I16: Send,\n I17: Send,\n I18: Send,\n I19: Send,\n I20: Send,
",1,["wiwi::iter::tuple::Tuple20"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21> Send for Tuple21<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21>
where\n I1: Send,\n I2: Send,\n I3: Send,\n I4: Send,\n I5: Send,\n I6: Send,\n I7: Send,\n I8: Send,\n I9: Send,\n I10: Send,\n I11: Send,\n I12: Send,\n I13: Send,\n I14: Send,\n I15: Send,\n I16: Send,\n I17: Send,\n I18: Send,\n I19: Send,\n I20: Send,\n I21: Send,
",1,["wiwi::iter::tuple::Tuple21"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22> Send for Tuple22<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22>
where\n I1: Send,\n I2: Send,\n I3: Send,\n I4: Send,\n I5: Send,\n I6: Send,\n I7: Send,\n I8: Send,\n I9: Send,\n I10: Send,\n I11: Send,\n I12: Send,\n I13: Send,\n I14: Send,\n I15: Send,\n I16: Send,\n I17: Send,\n I18: Send,\n I19: Send,\n I20: Send,\n I21: Send,\n I22: Send,
",1,["wiwi::iter::tuple::Tuple22"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23> Send for Tuple23<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23>
where\n I1: Send,\n I2: Send,\n I3: Send,\n I4: Send,\n I5: Send,\n I6: Send,\n I7: Send,\n I8: Send,\n I9: Send,\n I10: Send,\n I11: Send,\n I12: Send,\n I13: Send,\n I14: Send,\n I15: Send,\n I16: Send,\n I17: Send,\n I18: Send,\n I19: Send,\n I20: Send,\n I21: Send,\n I22: Send,\n I23: Send,
",1,["wiwi::iter::tuple::Tuple23"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24> Send for Tuple24<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24>
where\n I1: Send,\n I2: Send,\n I3: Send,\n I4: Send,\n I5: Send,\n I6: Send,\n I7: Send,\n I8: Send,\n I9: Send,\n I10: Send,\n I11: Send,\n I12: Send,\n I13: Send,\n I14: Send,\n I15: Send,\n I16: Send,\n I17: Send,\n I18: Send,\n I19: Send,\n I20: Send,\n I21: Send,\n I22: Send,\n I23: Send,\n I24: Send,
",1,["wiwi::iter::tuple::Tuple24"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24, I25> Send for Tuple25<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24, I25>
where\n I1: Send,\n I2: Send,\n I3: Send,\n I4: Send,\n I5: Send,\n I6: Send,\n I7: Send,\n I8: Send,\n I9: Send,\n I10: Send,\n I11: Send,\n I12: Send,\n I13: Send,\n I14: Send,\n I15: Send,\n I16: Send,\n I17: Send,\n I18: Send,\n I19: Send,\n I20: Send,\n I21: Send,\n I22: Send,\n I23: Send,\n I24: Send,\n I25: Send,
",1,["wiwi::iter::tuple::Tuple25"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24, I25, I26> Send for Tuple26<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24, I25, I26>
where\n I1: Send,\n I2: Send,\n I3: Send,\n I4: Send,\n I5: Send,\n I6: Send,\n I7: Send,\n I8: Send,\n I9: Send,\n I10: Send,\n I11: Send,\n I12: Send,\n I13: Send,\n I14: Send,\n I15: Send,\n I16: Send,\n I17: Send,\n I18: Send,\n I19: Send,\n I20: Send,\n I21: Send,\n I22: Send,\n I23: Send,\n I24: Send,\n I25: Send,\n I26: Send,
",1,["wiwi::iter::tuple::Tuple26"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24, I25, I26, I27> Send for Tuple27<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24, I25, I26, I27>
where\n I1: Send,\n I2: Send,\n I3: Send,\n I4: Send,\n I5: Send,\n I6: Send,\n I7: Send,\n I8: Send,\n I9: Send,\n I10: Send,\n I11: Send,\n I12: Send,\n I13: Send,\n I14: Send,\n I15: Send,\n I16: Send,\n I17: Send,\n I18: Send,\n I19: Send,\n I20: Send,\n I21: Send,\n I22: Send,\n I23: Send,\n I24: Send,\n I25: Send,\n I26: Send,\n I27: Send,
",1,["wiwi::iter::tuple::Tuple27"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24, I25, I26, I27, I28> Send for Tuple28<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24, I25, I26, I27, I28>
where\n I1: Send,\n I2: Send,\n I3: Send,\n I4: Send,\n I5: Send,\n I6: Send,\n I7: Send,\n I8: Send,\n I9: Send,\n I10: Send,\n I11: Send,\n I12: Send,\n I13: Send,\n I14: Send,\n I15: Send,\n I16: Send,\n I17: Send,\n I18: Send,\n I19: Send,\n I20: Send,\n I21: Send,\n I22: Send,\n I23: Send,\n I24: Send,\n I25: Send,\n I26: Send,\n I27: Send,\n I28: Send,
",1,["wiwi::iter::tuple::Tuple28"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24, I25, I26, I27, I28, I29> Send for Tuple29<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24, I25, I26, I27, I28, I29>
where\n I1: Send,\n I2: Send,\n I3: Send,\n I4: Send,\n I5: Send,\n I6: Send,\n I7: Send,\n I8: Send,\n I9: Send,\n I10: Send,\n I11: Send,\n I12: Send,\n I13: Send,\n I14: Send,\n I15: Send,\n I16: Send,\n I17: Send,\n I18: Send,\n I19: Send,\n I20: Send,\n I21: Send,\n I22: Send,\n I23: Send,\n I24: Send,\n I25: Send,\n I26: Send,\n I27: Send,\n I28: Send,\n I29: Send,
",1,["wiwi::iter::tuple::Tuple29"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24, I25, I26, I27, I28, I29, I30> Send for Tuple30<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24, I25, I26, I27, I28, I29, I30>
where\n I1: Send,\n I2: Send,\n I3: Send,\n I4: Send,\n I5: Send,\n I6: Send,\n I7: Send,\n I8: Send,\n I9: Send,\n I10: Send,\n I11: Send,\n I12: Send,\n I13: Send,\n I14: Send,\n I15: Send,\n I16: Send,\n I17: Send,\n I18: Send,\n I19: Send,\n I20: Send,\n I21: Send,\n I22: Send,\n I23: Send,\n I24: Send,\n I25: Send,\n I26: Send,\n I27: Send,\n I28: Send,\n I29: Send,\n I30: Send,
",1,["wiwi::iter::tuple::Tuple30"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24, I25, I26, I27, I28, I29, I30, I31> Send for Tuple31<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24, I25, I26, I27, I28, I29, I30, I31>
where\n I1: Send,\n I2: Send,\n I3: Send,\n I4: Send,\n I5: Send,\n I6: Send,\n I7: Send,\n I8: Send,\n I9: Send,\n I10: Send,\n I11: Send,\n I12: Send,\n I13: Send,\n I14: Send,\n I15: Send,\n I16: Send,\n I17: Send,\n I18: Send,\n I19: Send,\n I20: Send,\n I21: Send,\n I22: Send,\n I23: Send,\n I24: Send,\n I25: Send,\n I26: Send,\n I27: Send,\n I28: Send,\n I29: Send,\n I30: Send,\n I31: Send,
",1,["wiwi::iter::tuple::Tuple31"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24, I25, I26, I27, I28, I29, I30, I31, I32> Send for Tuple32<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24, I25, I26, I27, I28, I29, I30, I31, I32>
where\n I1: Send,\n I2: Send,\n I3: Send,\n I4: Send,\n I5: Send,\n I6: Send,\n I7: Send,\n I8: Send,\n I9: Send,\n I10: Send,\n I11: Send,\n I12: Send,\n I13: Send,\n I14: Send,\n I15: Send,\n I16: Send,\n I17: Send,\n I18: Send,\n I19: Send,\n I20: Send,\n I21: Send,\n I22: Send,\n I23: Send,\n I24: Send,\n I25: Send,\n I26: Send,\n I27: Send,\n I28: Send,\n I29: Send,\n I30: Send,\n I31: Send,\n I32: Send,
",1,["wiwi::iter::tuple::Tuple32"]],["impl<K, V> Send for BTreeMapChain<K, V>
where\n K: Send,\n V: Send,
",1,["wiwi::chainer::btree_map::BTreeMapChain"]],["impl<K, V, S> Send for HashMapChain<K, V, S>
where\n S: Send,\n K: Send,\n V: Send,
",1,["wiwi::chainer::hash_map::HashMapChain"]],["impl<P> Send for String<P>
where\n <P as Pool>::Raw: Send,\n P: Send,
",1,["wiwi::string_pool::string::String"]],["impl<T> Send for BTreeSetChain<T>
where\n T: Send,
",1,["wiwi::chainer::btree_set::BTreeSetChain"]],["impl<T> Send for BinaryHeapChain<T>
where\n T: Send,
",1,["wiwi::chainer::binary_heap::BinaryHeapChain"]],["impl<T> Send for LinkedListChain<T>
where\n T: Send,
",1,["wiwi::chainer::linked_list::LinkedListChain"]],["impl<T> Send for SliceBoxChain<T>
where\n T: Send,
",1,["wiwi::chainer::slice_box::SliceBoxChain"]],["impl<T> Send for VecChain<T>
where\n T: Send,
",1,["wiwi::chainer::vec::VecChain"]],["impl<T> Send for VecDequeChain<T>
where\n T: Send,
",1,["wiwi::chainer::vec_deque::VecDequeChain"]],["impl<T> Send for Empty<T>
where\n T: Send,
",1,["wiwi::iter::empty::Empty"]],["impl<T, F> Send for LazyWrapState<T, F>
where\n T: Send,\n F: Send,
",1,["wiwi::lazy_wrap::LazyWrapState"]],["impl<T, F> Send for LazyWrap<T, F>
where\n T: Send,\n F: Send,
"],["impl<T, S> Send for HashSetChain<T, S>
where\n S: Send,\n T: Send,
",1,["wiwi::chainer::hash_set::HashSetChain"]],["impl<T, const N: usize> Send for ArrayChain<T, N>
where\n T: Send,
",1,["wiwi::chainer::array::ArrayChain"]]] +"wiwi":[["impl !Send for IDGenerator",1,["wiwi::id::IDGenerator"]],["impl !Send for Script",1,["wiwi::lsl::callback_api::script::Script"]],["impl !Send for ScriptBuilder",1,["wiwi::lsl::callback_api::script::ScriptBuilder"]],["impl Send for DecodeError",1,["wiwi::hex::DecodeError"]],["impl Send for SizeHintBound",1,["wiwi::iter::size_hint::SizeHintBound"]],["impl Send for Error",1,["wiwi::serialiser::error::Error"]],["impl Send for DecodeError",1,["wiwi::z85::DecodeError"]],["impl Send for Error",1,["wiwi::auth::error::Error"]],["impl Send for ClientContinuerS1",1,["wiwi::auth::flow::signin::ClientContinuerS1"]],["impl Send for ClientContinuerS2",1,["wiwi::auth::flow::signin::ClientContinuerS2"]],["impl Send for ClientContinuerS3",1,["wiwi::auth::flow::signin::ClientContinuerS3"]],["impl Send for ServerS2Params",1,["wiwi::auth::flow::signin::ServerS2Params"]],["impl Send for ServerS3Params",1,["wiwi::auth::flow::signin::ServerS3Params"]],["impl Send for SigninRequestS1",1,["wiwi::auth::flow::signin::SigninRequestS1"]],["impl Send for SigninRequestS2",1,["wiwi::auth::flow::signin::SigninRequestS2"]],["impl Send for SigninRequestS3",1,["wiwi::auth::flow::signin::SigninRequestS3"]],["impl Send for SigninResponseS1",1,["wiwi::auth::flow::signin::SigninResponseS1"]],["impl Send for SigninResponseS2",1,["wiwi::auth::flow::signin::SigninResponseS2"]],["impl Send for SigninResponseS3",1,["wiwi::auth::flow::signin::SigninResponseS3"]],["impl Send for SignupRequest",1,["wiwi::auth::flow::signup::SignupRequest"]],["impl Send for StoredUnverifiedUserData",1,["wiwi::auth::flow::signup::StoredUnverifiedUserData"]],["impl Send for U320",1,["wiwi::bigint::U320"]],["impl Send for Encoder",1,["wiwi::bitstream::Encoder"]],["impl Send for BitstreamEncoderChain",1,["wiwi::chainer::bitstream::BitstreamEncoderChain"]],["impl Send for StrBoxChain",1,["wiwi::chainer::str_box::StrBoxChain"]],["impl Send for StringChain",1,["wiwi::chainer::string::StringChain"]],["impl Send for Builder",1,["wiwi::clock_timer::builder::Builder"]],["impl Send for BuilderWithEnd",1,["wiwi::clock_timer::builder::BuilderWithEnd"]],["impl Send for BuilderWithInterval",1,["wiwi::clock_timer::builder::BuilderWithInterval"]],["impl Send for BuilderWithStart",1,["wiwi::clock_timer::builder::BuilderWithStart"]],["impl Send for ClockTimer",1,["wiwi::clock_timer::ClockTimer"]],["impl Send for Tick",1,["wiwi::clock_timer::Tick"]],["impl Send for GeneratedID",1,["wiwi::id::GeneratedID"]],["impl Send for SizeHint",1,["wiwi::iter::size_hint::SizeHint"]],["impl Send for Marker",1,["wiwi::serialiser::marker::Marker"]],["impl Send for SerialiseOptions",1,["wiwi::serialiser::serialise::SerialiseOptions"]],["impl Send for GlobalPool",1,["wiwi::string_pool::pool::global::GlobalPool"]],["impl Send for Board",1,["wiwi::sudoku::Board"]],["impl<'h> Send for StrMutChain<'h>",1,["wiwi::chainer::str_mut::StrMutChain"]],["impl<'h> Send for StrRefChain<'h>",1,["wiwi::chainer::str_ref::StrRefChain"]],["impl<'h> Send for StringMutChain<'h>",1,["wiwi::chainer::string_mut::StringMutChain"]],["impl<'h> Send for StringRefChain<'h>",1,["wiwi::chainer::string_ref::StringRefChain"]],["impl<'h> Send for SlicesWrap<'h>",1,["wiwi::string_pool::pool::SlicesWrap"]],["impl<'h> Send for SlicesWrapIter<'h>",1,["wiwi::string_pool::pool::SlicesWrapIter"]],["impl<'h, T> Send for SliceMutChain<'h, T>
where\n T: Send,
",1,["wiwi::chainer::slice_mut::SliceMutChain"]],["impl<'h, T> Send for SliceRefChain<'h, T>
where\n T: Sync,
",1,["wiwi::chainer::slice_ref::SliceRefChain"]],["impl<'h, T> Send for VecMutChain<'h, T>
where\n T: Send,
",1,["wiwi::chainer::vec_mut::VecMutChain"]],["impl<'h, T> Send for VecRefChain<'h, T>
where\n T: Sync,
",1,["wiwi::chainer::vec_ref::VecRefChain"]],["impl<'h, T, const N: usize> Send for ArrayMutChain<'h, T, N>
where\n T: Send,
",1,["wiwi::chainer::array_mut::ArrayMutChain"]],["impl<'h, T, const N: usize> Send for ArrayRefChain<'h, T, N>
where\n T: Sync,
",1,["wiwi::chainer::array_ref::ArrayRefChain"]],["impl<F> Send for FromFn<F>
where\n F: Send,
",1,["wiwi::iter::from_fn::FromFn"]],["impl<I> Send for IterAdapter<I>
where\n I: Send,
",1,["wiwi::iter::adapter::IterAdapter"]],["impl<I> Send for RepeatPerItem<I>
where\n I: Send,\n <I as Iter>::Item: Send,
",1,["wiwi::iter::repeat_per_item::RepeatPerItem"]],["impl<I> Send for Rev<I>
where\n I: Send,
",1,["wiwi::iter::rev::Rev"]],["impl<I, F> Send for Map<I, F>
where\n I: Send,\n F: Send,
",1,["wiwi::iter::map::Map"]],["impl<I, T> Send for Peek<I, T>
where\n I: Send,\n T: Send,
",1,["wiwi::iter::peek::Peek"]],["impl<I1> Send for Tuple1<I1>
where\n I1: Send,
",1,["wiwi::iter::tuple::Tuple1"]],["impl<I1, I2> Send for Tuple2<I1, I2>
where\n I1: Send,\n I2: Send,
",1,["wiwi::iter::tuple::Tuple2"]],["impl<I1, I2, I3> Send for Tuple3<I1, I2, I3>
where\n I1: Send,\n I2: Send,\n I3: Send,
",1,["wiwi::iter::tuple::Tuple3"]],["impl<I1, I2, I3, I4> Send for Tuple4<I1, I2, I3, I4>
where\n I1: Send,\n I2: Send,\n I3: Send,\n I4: Send,
",1,["wiwi::iter::tuple::Tuple4"]],["impl<I1, I2, I3, I4, I5> Send for Tuple5<I1, I2, I3, I4, I5>
where\n I1: Send,\n I2: Send,\n I3: Send,\n I4: Send,\n I5: Send,
",1,["wiwi::iter::tuple::Tuple5"]],["impl<I1, I2, I3, I4, I5, I6> Send for Tuple6<I1, I2, I3, I4, I5, I6>
where\n I1: Send,\n I2: Send,\n I3: Send,\n I4: Send,\n I5: Send,\n I6: Send,
",1,["wiwi::iter::tuple::Tuple6"]],["impl<I1, I2, I3, I4, I5, I6, I7> Send for Tuple7<I1, I2, I3, I4, I5, I6, I7>
where\n I1: Send,\n I2: Send,\n I3: Send,\n I4: Send,\n I5: Send,\n I6: Send,\n I7: Send,
",1,["wiwi::iter::tuple::Tuple7"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8> Send for Tuple8<I1, I2, I3, I4, I5, I6, I7, I8>
where\n I1: Send,\n I2: Send,\n I3: Send,\n I4: Send,\n I5: Send,\n I6: Send,\n I7: Send,\n I8: Send,
",1,["wiwi::iter::tuple::Tuple8"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9> Send for Tuple9<I1, I2, I3, I4, I5, I6, I7, I8, I9>
where\n I1: Send,\n I2: Send,\n I3: Send,\n I4: Send,\n I5: Send,\n I6: Send,\n I7: Send,\n I8: Send,\n I9: Send,
",1,["wiwi::iter::tuple::Tuple9"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10> Send for Tuple10<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10>
where\n I1: Send,\n I2: Send,\n I3: Send,\n I4: Send,\n I5: Send,\n I6: Send,\n I7: Send,\n I8: Send,\n I9: Send,\n I10: Send,
",1,["wiwi::iter::tuple::Tuple10"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11> Send for Tuple11<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11>
where\n I1: Send,\n I2: Send,\n I3: Send,\n I4: Send,\n I5: Send,\n I6: Send,\n I7: Send,\n I8: Send,\n I9: Send,\n I10: Send,\n I11: Send,
",1,["wiwi::iter::tuple::Tuple11"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12> Send for Tuple12<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12>
where\n I1: Send,\n I2: Send,\n I3: Send,\n I4: Send,\n I5: Send,\n I6: Send,\n I7: Send,\n I8: Send,\n I9: Send,\n I10: Send,\n I11: Send,\n I12: Send,
",1,["wiwi::iter::tuple::Tuple12"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13> Send for Tuple13<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13>
where\n I1: Send,\n I2: Send,\n I3: Send,\n I4: Send,\n I5: Send,\n I6: Send,\n I7: Send,\n I8: Send,\n I9: Send,\n I10: Send,\n I11: Send,\n I12: Send,\n I13: Send,
",1,["wiwi::iter::tuple::Tuple13"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14> Send for Tuple14<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14>
where\n I1: Send,\n I2: Send,\n I3: Send,\n I4: Send,\n I5: Send,\n I6: Send,\n I7: Send,\n I8: Send,\n I9: Send,\n I10: Send,\n I11: Send,\n I12: Send,\n I13: Send,\n I14: Send,
",1,["wiwi::iter::tuple::Tuple14"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15> Send for Tuple15<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15>
where\n I1: Send,\n I2: Send,\n I3: Send,\n I4: Send,\n I5: Send,\n I6: Send,\n I7: Send,\n I8: Send,\n I9: Send,\n I10: Send,\n I11: Send,\n I12: Send,\n I13: Send,\n I14: Send,\n I15: Send,
",1,["wiwi::iter::tuple::Tuple15"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16> Send for Tuple16<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16>
where\n I1: Send,\n I2: Send,\n I3: Send,\n I4: Send,\n I5: Send,\n I6: Send,\n I7: Send,\n I8: Send,\n I9: Send,\n I10: Send,\n I11: Send,\n I12: Send,\n I13: Send,\n I14: Send,\n I15: Send,\n I16: Send,
",1,["wiwi::iter::tuple::Tuple16"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17> Send for Tuple17<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17>
where\n I1: Send,\n I2: Send,\n I3: Send,\n I4: Send,\n I5: Send,\n I6: Send,\n I7: Send,\n I8: Send,\n I9: Send,\n I10: Send,\n I11: Send,\n I12: Send,\n I13: Send,\n I14: Send,\n I15: Send,\n I16: Send,\n I17: Send,
",1,["wiwi::iter::tuple::Tuple17"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18> Send for Tuple18<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18>
where\n I1: Send,\n I2: Send,\n I3: Send,\n I4: Send,\n I5: Send,\n I6: Send,\n I7: Send,\n I8: Send,\n I9: Send,\n I10: Send,\n I11: Send,\n I12: Send,\n I13: Send,\n I14: Send,\n I15: Send,\n I16: Send,\n I17: Send,\n I18: Send,
",1,["wiwi::iter::tuple::Tuple18"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19> Send for Tuple19<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19>
where\n I1: Send,\n I2: Send,\n I3: Send,\n I4: Send,\n I5: Send,\n I6: Send,\n I7: Send,\n I8: Send,\n I9: Send,\n I10: Send,\n I11: Send,\n I12: Send,\n I13: Send,\n I14: Send,\n I15: Send,\n I16: Send,\n I17: Send,\n I18: Send,\n I19: Send,
",1,["wiwi::iter::tuple::Tuple19"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20> Send for Tuple20<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20>
where\n I1: Send,\n I2: Send,\n I3: Send,\n I4: Send,\n I5: Send,\n I6: Send,\n I7: Send,\n I8: Send,\n I9: Send,\n I10: Send,\n I11: Send,\n I12: Send,\n I13: Send,\n I14: Send,\n I15: Send,\n I16: Send,\n I17: Send,\n I18: Send,\n I19: Send,\n I20: Send,
",1,["wiwi::iter::tuple::Tuple20"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21> Send for Tuple21<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21>
where\n I1: Send,\n I2: Send,\n I3: Send,\n I4: Send,\n I5: Send,\n I6: Send,\n I7: Send,\n I8: Send,\n I9: Send,\n I10: Send,\n I11: Send,\n I12: Send,\n I13: Send,\n I14: Send,\n I15: Send,\n I16: Send,\n I17: Send,\n I18: Send,\n I19: Send,\n I20: Send,\n I21: Send,
",1,["wiwi::iter::tuple::Tuple21"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22> Send for Tuple22<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22>
where\n I1: Send,\n I2: Send,\n I3: Send,\n I4: Send,\n I5: Send,\n I6: Send,\n I7: Send,\n I8: Send,\n I9: Send,\n I10: Send,\n I11: Send,\n I12: Send,\n I13: Send,\n I14: Send,\n I15: Send,\n I16: Send,\n I17: Send,\n I18: Send,\n I19: Send,\n I20: Send,\n I21: Send,\n I22: Send,
",1,["wiwi::iter::tuple::Tuple22"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23> Send for Tuple23<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23>
where\n I1: Send,\n I2: Send,\n I3: Send,\n I4: Send,\n I5: Send,\n I6: Send,\n I7: Send,\n I8: Send,\n I9: Send,\n I10: Send,\n I11: Send,\n I12: Send,\n I13: Send,\n I14: Send,\n I15: Send,\n I16: Send,\n I17: Send,\n I18: Send,\n I19: Send,\n I20: Send,\n I21: Send,\n I22: Send,\n I23: Send,
",1,["wiwi::iter::tuple::Tuple23"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24> Send for Tuple24<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24>
where\n I1: Send,\n I2: Send,\n I3: Send,\n I4: Send,\n I5: Send,\n I6: Send,\n I7: Send,\n I8: Send,\n I9: Send,\n I10: Send,\n I11: Send,\n I12: Send,\n I13: Send,\n I14: Send,\n I15: Send,\n I16: Send,\n I17: Send,\n I18: Send,\n I19: Send,\n I20: Send,\n I21: Send,\n I22: Send,\n I23: Send,\n I24: Send,
",1,["wiwi::iter::tuple::Tuple24"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24, I25> Send for Tuple25<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24, I25>
where\n I1: Send,\n I2: Send,\n I3: Send,\n I4: Send,\n I5: Send,\n I6: Send,\n I7: Send,\n I8: Send,\n I9: Send,\n I10: Send,\n I11: Send,\n I12: Send,\n I13: Send,\n I14: Send,\n I15: Send,\n I16: Send,\n I17: Send,\n I18: Send,\n I19: Send,\n I20: Send,\n I21: Send,\n I22: Send,\n I23: Send,\n I24: Send,\n I25: Send,
",1,["wiwi::iter::tuple::Tuple25"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24, I25, I26> Send for Tuple26<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24, I25, I26>
where\n I1: Send,\n I2: Send,\n I3: Send,\n I4: Send,\n I5: Send,\n I6: Send,\n I7: Send,\n I8: Send,\n I9: Send,\n I10: Send,\n I11: Send,\n I12: Send,\n I13: Send,\n I14: Send,\n I15: Send,\n I16: Send,\n I17: Send,\n I18: Send,\n I19: Send,\n I20: Send,\n I21: Send,\n I22: Send,\n I23: Send,\n I24: Send,\n I25: Send,\n I26: Send,
",1,["wiwi::iter::tuple::Tuple26"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24, I25, I26, I27> Send for Tuple27<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24, I25, I26, I27>
where\n I1: Send,\n I2: Send,\n I3: Send,\n I4: Send,\n I5: Send,\n I6: Send,\n I7: Send,\n I8: Send,\n I9: Send,\n I10: Send,\n I11: Send,\n I12: Send,\n I13: Send,\n I14: Send,\n I15: Send,\n I16: Send,\n I17: Send,\n I18: Send,\n I19: Send,\n I20: Send,\n I21: Send,\n I22: Send,\n I23: Send,\n I24: Send,\n I25: Send,\n I26: Send,\n I27: Send,
",1,["wiwi::iter::tuple::Tuple27"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24, I25, I26, I27, I28> Send for Tuple28<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24, I25, I26, I27, I28>
where\n I1: Send,\n I2: Send,\n I3: Send,\n I4: Send,\n I5: Send,\n I6: Send,\n I7: Send,\n I8: Send,\n I9: Send,\n I10: Send,\n I11: Send,\n I12: Send,\n I13: Send,\n I14: Send,\n I15: Send,\n I16: Send,\n I17: Send,\n I18: Send,\n I19: Send,\n I20: Send,\n I21: Send,\n I22: Send,\n I23: Send,\n I24: Send,\n I25: Send,\n I26: Send,\n I27: Send,\n I28: Send,
",1,["wiwi::iter::tuple::Tuple28"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24, I25, I26, I27, I28, I29> Send for Tuple29<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24, I25, I26, I27, I28, I29>
where\n I1: Send,\n I2: Send,\n I3: Send,\n I4: Send,\n I5: Send,\n I6: Send,\n I7: Send,\n I8: Send,\n I9: Send,\n I10: Send,\n I11: Send,\n I12: Send,\n I13: Send,\n I14: Send,\n I15: Send,\n I16: Send,\n I17: Send,\n I18: Send,\n I19: Send,\n I20: Send,\n I21: Send,\n I22: Send,\n I23: Send,\n I24: Send,\n I25: Send,\n I26: Send,\n I27: Send,\n I28: Send,\n I29: Send,
",1,["wiwi::iter::tuple::Tuple29"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24, I25, I26, I27, I28, I29, I30> Send for Tuple30<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24, I25, I26, I27, I28, I29, I30>
where\n I1: Send,\n I2: Send,\n I3: Send,\n I4: Send,\n I5: Send,\n I6: Send,\n I7: Send,\n I8: Send,\n I9: Send,\n I10: Send,\n I11: Send,\n I12: Send,\n I13: Send,\n I14: Send,\n I15: Send,\n I16: Send,\n I17: Send,\n I18: Send,\n I19: Send,\n I20: Send,\n I21: Send,\n I22: Send,\n I23: Send,\n I24: Send,\n I25: Send,\n I26: Send,\n I27: Send,\n I28: Send,\n I29: Send,\n I30: Send,
",1,["wiwi::iter::tuple::Tuple30"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24, I25, I26, I27, I28, I29, I30, I31> Send for Tuple31<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24, I25, I26, I27, I28, I29, I30, I31>
where\n I1: Send,\n I2: Send,\n I3: Send,\n I4: Send,\n I5: Send,\n I6: Send,\n I7: Send,\n I8: Send,\n I9: Send,\n I10: Send,\n I11: Send,\n I12: Send,\n I13: Send,\n I14: Send,\n I15: Send,\n I16: Send,\n I17: Send,\n I18: Send,\n I19: Send,\n I20: Send,\n I21: Send,\n I22: Send,\n I23: Send,\n I24: Send,\n I25: Send,\n I26: Send,\n I27: Send,\n I28: Send,\n I29: Send,\n I30: Send,\n I31: Send,
",1,["wiwi::iter::tuple::Tuple31"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24, I25, I26, I27, I28, I29, I30, I31, I32> Send for Tuple32<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24, I25, I26, I27, I28, I29, I30, I31, I32>
where\n I1: Send,\n I2: Send,\n I3: Send,\n I4: Send,\n I5: Send,\n I6: Send,\n I7: Send,\n I8: Send,\n I9: Send,\n I10: Send,\n I11: Send,\n I12: Send,\n I13: Send,\n I14: Send,\n I15: Send,\n I16: Send,\n I17: Send,\n I18: Send,\n I19: Send,\n I20: Send,\n I21: Send,\n I22: Send,\n I23: Send,\n I24: Send,\n I25: Send,\n I26: Send,\n I27: Send,\n I28: Send,\n I29: Send,\n I30: Send,\n I31: Send,\n I32: Send,
",1,["wiwi::iter::tuple::Tuple32"]],["impl<K, V> Send for BTreeMapChain<K, V>
where\n K: Send,\n V: Send,
",1,["wiwi::chainer::btree_map::BTreeMapChain"]],["impl<K, V, S> Send for HashMapChain<K, V, S>
where\n S: Send,\n K: Send,\n V: Send,
",1,["wiwi::chainer::hash_map::HashMapChain"]],["impl<P> Send for String<P>
where\n <P as Pool>::Raw: Send,\n P: Send,
",1,["wiwi::string_pool::string::String"]],["impl<T> Send for BTreeSetChain<T>
where\n T: Send,
",1,["wiwi::chainer::btree_set::BTreeSetChain"]],["impl<T> Send for BinaryHeapChain<T>
where\n T: Send,
",1,["wiwi::chainer::binary_heap::BinaryHeapChain"]],["impl<T> Send for LinkedListChain<T>
where\n T: Send,
",1,["wiwi::chainer::linked_list::LinkedListChain"]],["impl<T> Send for SliceBoxChain<T>
where\n T: Send,
",1,["wiwi::chainer::slice_box::SliceBoxChain"]],["impl<T> Send for VecChain<T>
where\n T: Send,
",1,["wiwi::chainer::vec::VecChain"]],["impl<T> Send for VecDequeChain<T>
where\n T: Send,
",1,["wiwi::chainer::vec_deque::VecDequeChain"]],["impl<T> Send for Empty<T>
where\n T: Send,
",1,["wiwi::iter::empty::Empty"]],["impl<T, F> Send for LazyWrapState<T, F>
where\n T: Send,\n F: Send,
",1,["wiwi::lazy_wrap::LazyWrapState"]],["impl<T, F> Send for LazyWrap<T, F>
where\n T: Send,\n F: Send,
"],["impl<T, S> Send for HashSetChain<T, S>
where\n S: Send,\n T: Send,
",1,["wiwi::chainer::hash_set::HashSetChain"]],["impl<T, const N: usize> Send for ArrayChain<T, N>
where\n T: Send,
",1,["wiwi::chainer::array::ArrayChain"]]] };if (window.register_implementors) {window.register_implementors(implementors);} else {window.pending_implementors = implementors;}})() \ No newline at end of file diff --git a/trait.impl/core/marker/trait.Sync.js b/trait.impl/core/marker/trait.Sync.js index 710a1a259..fbdbd21c6 100644 --- a/trait.impl/core/marker/trait.Sync.js +++ b/trait.impl/core/marker/trait.Sync.js @@ -1,3 +1,3 @@ (function() {var implementors = { -"wiwi":[["impl !Sync for IDGenerator",1,["wiwi::id::IDGenerator"]],["impl !Sync for Script",1,["wiwi::lsl::callback_api::script::Script"]],["impl !Sync for ScriptBuilder",1,["wiwi::lsl::callback_api::script::ScriptBuilder"]],["impl Sync for DecodeError",1,["wiwi::hex::DecodeError"]],["impl Sync for SizeHintBound",1,["wiwi::iter::size_hint::SizeHintBound"]],["impl Sync for Error",1,["wiwi::serialiser::error::Error"]],["impl Sync for DecodeError",1,["wiwi::z85::DecodeError"]],["impl Sync for Error",1,["wiwi::auth::error::Error"]],["impl Sync for ClientContinuerS1",1,["wiwi::auth::flow::signin::ClientContinuerS1"]],["impl Sync for ClientContinuerS2",1,["wiwi::auth::flow::signin::ClientContinuerS2"]],["impl Sync for ClientContinuerS3",1,["wiwi::auth::flow::signin::ClientContinuerS3"]],["impl Sync for ServerS2Params",1,["wiwi::auth::flow::signin::ServerS2Params"]],["impl Sync for ServerS3Params",1,["wiwi::auth::flow::signin::ServerS3Params"]],["impl Sync for SigninRequestS1",1,["wiwi::auth::flow::signin::SigninRequestS1"]],["impl Sync for SigninRequestS2",1,["wiwi::auth::flow::signin::SigninRequestS2"]],["impl Sync for SigninRequestS3",1,["wiwi::auth::flow::signin::SigninRequestS3"]],["impl Sync for SigninResponseS1",1,["wiwi::auth::flow::signin::SigninResponseS1"]],["impl Sync for SigninResponseS2",1,["wiwi::auth::flow::signin::SigninResponseS2"]],["impl Sync for SigninResponseS3",1,["wiwi::auth::flow::signin::SigninResponseS3"]],["impl Sync for SignupRequest",1,["wiwi::auth::flow::signup::SignupRequest"]],["impl Sync for StoredUnverifiedUserData",1,["wiwi::auth::flow::signup::StoredUnverifiedUserData"]],["impl Sync for U320",1,["wiwi::bigint::U320"]],["impl Sync for Encoder",1,["wiwi::bitstream::Encoder"]],["impl Sync for BitstreamEncoderChain",1,["wiwi::chainer::bitstream::BitstreamEncoderChain"]],["impl Sync for StrBoxChain",1,["wiwi::chainer::str_box::StrBoxChain"]],["impl Sync for StringChain",1,["wiwi::chainer::string::StringChain"]],["impl Sync for Builder",1,["wiwi::clock_timer::builder::Builder"]],["impl Sync for BuilderWithEnd",1,["wiwi::clock_timer::builder::BuilderWithEnd"]],["impl Sync for BuilderWithInterval",1,["wiwi::clock_timer::builder::BuilderWithInterval"]],["impl Sync for BuilderWithStart",1,["wiwi::clock_timer::builder::BuilderWithStart"]],["impl Sync for ClockTimer",1,["wiwi::clock_timer::ClockTimer"]],["impl Sync for Tick",1,["wiwi::clock_timer::Tick"]],["impl Sync for GeneratedID",1,["wiwi::id::GeneratedID"]],["impl Sync for SizeHint",1,["wiwi::iter::size_hint::SizeHint"]],["impl Sync for SerialiseOptions",1,["wiwi::serialiser::serialise::SerialiseOptions"]],["impl Sync for GlobalPool",1,["wiwi::string_pool::pool::global::GlobalPool"]],["impl Sync for Board",1,["wiwi::sudoku::Board"]],["impl<'h> Sync for StrMutChain<'h>",1,["wiwi::chainer::str_mut::StrMutChain"]],["impl<'h> Sync for StrRefChain<'h>",1,["wiwi::chainer::str_ref::StrRefChain"]],["impl<'h> Sync for StringMutChain<'h>",1,["wiwi::chainer::string_mut::StringMutChain"]],["impl<'h> Sync for StringRefChain<'h>",1,["wiwi::chainer::string_ref::StringRefChain"]],["impl<'h> Sync for SlicesWrap<'h>",1,["wiwi::string_pool::pool::SlicesWrap"]],["impl<'h> Sync for SlicesWrapIter<'h>",1,["wiwi::string_pool::pool::SlicesWrapIter"]],["impl<'h, T> Sync for SliceMutChain<'h, T>
where\n T: Sync,
",1,["wiwi::chainer::slice_mut::SliceMutChain"]],["impl<'h, T> Sync for SliceRefChain<'h, T>
where\n T: Sync,
",1,["wiwi::chainer::slice_ref::SliceRefChain"]],["impl<'h, T> Sync for VecMutChain<'h, T>
where\n T: Sync,
",1,["wiwi::chainer::vec_mut::VecMutChain"]],["impl<'h, T> Sync for VecRefChain<'h, T>
where\n T: Sync,
",1,["wiwi::chainer::vec_ref::VecRefChain"]],["impl<'h, T, const N: usize> Sync for ArrayMutChain<'h, T, N>
where\n T: Sync,
",1,["wiwi::chainer::array_mut::ArrayMutChain"]],["impl<'h, T, const N: usize> Sync for ArrayRefChain<'h, T, N>
where\n T: Sync,
",1,["wiwi::chainer::array_ref::ArrayRefChain"]],["impl<F> Sync for FromFn<F>
where\n F: Sync,
",1,["wiwi::iter::from_fn::FromFn"]],["impl<I> Sync for IterAdapter<I>
where\n I: Sync,
",1,["wiwi::iter::adapter::IterAdapter"]],["impl<I> Sync for RepeatPerItem<I>
where\n I: Sync,\n <I as Iter>::Item: Sync,
",1,["wiwi::iter::repeat_per_item::RepeatPerItem"]],["impl<I, F> Sync for Map<I, F>
where\n I: Sync,\n F: Sync,
",1,["wiwi::iter::map::Map"]],["impl<I, T> Sync for Peek<I, T>
where\n I: Sync,\n T: Sync,
",1,["wiwi::iter::peek::Peek"]],["impl<I1> Sync for Tuple1<I1>
where\n I1: Sync,
",1,["wiwi::iter::tuple::Tuple1"]],["impl<I1, I2> Sync for Tuple2<I1, I2>
where\n I1: Sync,\n I2: Sync,
",1,["wiwi::iter::tuple::Tuple2"]],["impl<I1, I2, I3> Sync for Tuple3<I1, I2, I3>
where\n I1: Sync,\n I2: Sync,\n I3: Sync,
",1,["wiwi::iter::tuple::Tuple3"]],["impl<I1, I2, I3, I4> Sync for Tuple4<I1, I2, I3, I4>
where\n I1: Sync,\n I2: Sync,\n I3: Sync,\n I4: Sync,
",1,["wiwi::iter::tuple::Tuple4"]],["impl<I1, I2, I3, I4, I5> Sync for Tuple5<I1, I2, I3, I4, I5>
where\n I1: Sync,\n I2: Sync,\n I3: Sync,\n I4: Sync,\n I5: Sync,
",1,["wiwi::iter::tuple::Tuple5"]],["impl<I1, I2, I3, I4, I5, I6> Sync for Tuple6<I1, I2, I3, I4, I5, I6>
where\n I1: Sync,\n I2: Sync,\n I3: Sync,\n I4: Sync,\n I5: Sync,\n I6: Sync,
",1,["wiwi::iter::tuple::Tuple6"]],["impl<I1, I2, I3, I4, I5, I6, I7> Sync for Tuple7<I1, I2, I3, I4, I5, I6, I7>
where\n I1: Sync,\n I2: Sync,\n I3: Sync,\n I4: Sync,\n I5: Sync,\n I6: Sync,\n I7: Sync,
",1,["wiwi::iter::tuple::Tuple7"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8> Sync for Tuple8<I1, I2, I3, I4, I5, I6, I7, I8>
where\n I1: Sync,\n I2: Sync,\n I3: Sync,\n I4: Sync,\n I5: Sync,\n I6: Sync,\n I7: Sync,\n I8: Sync,
",1,["wiwi::iter::tuple::Tuple8"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9> Sync for Tuple9<I1, I2, I3, I4, I5, I6, I7, I8, I9>
where\n I1: Sync,\n I2: Sync,\n I3: Sync,\n I4: Sync,\n I5: Sync,\n I6: Sync,\n I7: Sync,\n I8: Sync,\n I9: Sync,
",1,["wiwi::iter::tuple::Tuple9"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10> Sync for Tuple10<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10>
where\n I1: Sync,\n I2: Sync,\n I3: Sync,\n I4: Sync,\n I5: Sync,\n I6: Sync,\n I7: Sync,\n I8: Sync,\n I9: Sync,\n I10: Sync,
",1,["wiwi::iter::tuple::Tuple10"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11> Sync for Tuple11<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11>
where\n I1: Sync,\n I2: Sync,\n I3: Sync,\n I4: Sync,\n I5: Sync,\n I6: Sync,\n I7: Sync,\n I8: Sync,\n I9: Sync,\n I10: Sync,\n I11: Sync,
",1,["wiwi::iter::tuple::Tuple11"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12> Sync for Tuple12<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12>
where\n I1: Sync,\n I2: Sync,\n I3: Sync,\n I4: Sync,\n I5: Sync,\n I6: Sync,\n I7: Sync,\n I8: Sync,\n I9: Sync,\n I10: Sync,\n I11: Sync,\n I12: Sync,
",1,["wiwi::iter::tuple::Tuple12"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13> Sync for Tuple13<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13>
where\n I1: Sync,\n I2: Sync,\n I3: Sync,\n I4: Sync,\n I5: Sync,\n I6: Sync,\n I7: Sync,\n I8: Sync,\n I9: Sync,\n I10: Sync,\n I11: Sync,\n I12: Sync,\n I13: Sync,
",1,["wiwi::iter::tuple::Tuple13"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14> Sync for Tuple14<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14>
where\n I1: Sync,\n I2: Sync,\n I3: Sync,\n I4: Sync,\n I5: Sync,\n I6: Sync,\n I7: Sync,\n I8: Sync,\n I9: Sync,\n I10: Sync,\n I11: Sync,\n I12: Sync,\n I13: Sync,\n I14: Sync,
",1,["wiwi::iter::tuple::Tuple14"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15> Sync for Tuple15<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15>
where\n I1: Sync,\n I2: Sync,\n I3: Sync,\n I4: Sync,\n I5: Sync,\n I6: Sync,\n I7: Sync,\n I8: Sync,\n I9: Sync,\n I10: Sync,\n I11: Sync,\n I12: Sync,\n I13: Sync,\n I14: Sync,\n I15: Sync,
",1,["wiwi::iter::tuple::Tuple15"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16> Sync for Tuple16<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16>
where\n I1: Sync,\n I2: Sync,\n I3: Sync,\n I4: Sync,\n I5: Sync,\n I6: Sync,\n I7: Sync,\n I8: Sync,\n I9: Sync,\n I10: Sync,\n I11: Sync,\n I12: Sync,\n I13: Sync,\n I14: Sync,\n I15: Sync,\n I16: Sync,
",1,["wiwi::iter::tuple::Tuple16"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17> Sync for Tuple17<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17>
where\n I1: Sync,\n I2: Sync,\n I3: Sync,\n I4: Sync,\n I5: Sync,\n I6: Sync,\n I7: Sync,\n I8: Sync,\n I9: Sync,\n I10: Sync,\n I11: Sync,\n I12: Sync,\n I13: Sync,\n I14: Sync,\n I15: Sync,\n I16: Sync,\n I17: Sync,
",1,["wiwi::iter::tuple::Tuple17"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18> Sync for Tuple18<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18>
where\n I1: Sync,\n I2: Sync,\n I3: Sync,\n I4: Sync,\n I5: Sync,\n I6: Sync,\n I7: Sync,\n I8: Sync,\n I9: Sync,\n I10: Sync,\n I11: Sync,\n I12: Sync,\n I13: Sync,\n I14: Sync,\n I15: Sync,\n I16: Sync,\n I17: Sync,\n I18: Sync,
",1,["wiwi::iter::tuple::Tuple18"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19> Sync for Tuple19<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19>
where\n I1: Sync,\n I2: Sync,\n I3: Sync,\n I4: Sync,\n I5: Sync,\n I6: Sync,\n I7: Sync,\n I8: Sync,\n I9: Sync,\n I10: Sync,\n I11: Sync,\n I12: Sync,\n I13: Sync,\n I14: Sync,\n I15: Sync,\n I16: Sync,\n I17: Sync,\n I18: Sync,\n I19: Sync,
",1,["wiwi::iter::tuple::Tuple19"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20> Sync for Tuple20<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20>
where\n I1: Sync,\n I2: Sync,\n I3: Sync,\n I4: Sync,\n I5: Sync,\n I6: Sync,\n I7: Sync,\n I8: Sync,\n I9: Sync,\n I10: Sync,\n I11: Sync,\n I12: Sync,\n I13: Sync,\n I14: Sync,\n I15: Sync,\n I16: Sync,\n I17: Sync,\n I18: Sync,\n I19: Sync,\n I20: Sync,
",1,["wiwi::iter::tuple::Tuple20"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21> Sync for Tuple21<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21>
where\n I1: Sync,\n I2: Sync,\n I3: Sync,\n I4: Sync,\n I5: Sync,\n I6: Sync,\n I7: Sync,\n I8: Sync,\n I9: Sync,\n I10: Sync,\n I11: Sync,\n I12: Sync,\n I13: Sync,\n I14: Sync,\n I15: Sync,\n I16: Sync,\n I17: Sync,\n I18: Sync,\n I19: Sync,\n I20: Sync,\n I21: Sync,
",1,["wiwi::iter::tuple::Tuple21"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22> Sync for Tuple22<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22>
where\n I1: Sync,\n I2: Sync,\n I3: Sync,\n I4: Sync,\n I5: Sync,\n I6: Sync,\n I7: Sync,\n I8: Sync,\n I9: Sync,\n I10: Sync,\n I11: Sync,\n I12: Sync,\n I13: Sync,\n I14: Sync,\n I15: Sync,\n I16: Sync,\n I17: Sync,\n I18: Sync,\n I19: Sync,\n I20: Sync,\n I21: Sync,\n I22: Sync,
",1,["wiwi::iter::tuple::Tuple22"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23> Sync for Tuple23<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23>
where\n I1: Sync,\n I2: Sync,\n I3: Sync,\n I4: Sync,\n I5: Sync,\n I6: Sync,\n I7: Sync,\n I8: Sync,\n I9: Sync,\n I10: Sync,\n I11: Sync,\n I12: Sync,\n I13: Sync,\n I14: Sync,\n I15: Sync,\n I16: Sync,\n I17: Sync,\n I18: Sync,\n I19: Sync,\n I20: Sync,\n I21: Sync,\n I22: Sync,\n I23: Sync,
",1,["wiwi::iter::tuple::Tuple23"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24> Sync for Tuple24<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24>
where\n I1: Sync,\n I2: Sync,\n I3: Sync,\n I4: Sync,\n I5: Sync,\n I6: Sync,\n I7: Sync,\n I8: Sync,\n I9: Sync,\n I10: Sync,\n I11: Sync,\n I12: Sync,\n I13: Sync,\n I14: Sync,\n I15: Sync,\n I16: Sync,\n I17: Sync,\n I18: Sync,\n I19: Sync,\n I20: Sync,\n I21: Sync,\n I22: Sync,\n I23: Sync,\n I24: Sync,
",1,["wiwi::iter::tuple::Tuple24"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24, I25> Sync for Tuple25<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24, I25>
where\n I1: Sync,\n I2: Sync,\n I3: Sync,\n I4: Sync,\n I5: Sync,\n I6: Sync,\n I7: Sync,\n I8: Sync,\n I9: Sync,\n I10: Sync,\n I11: Sync,\n I12: Sync,\n I13: Sync,\n I14: Sync,\n I15: Sync,\n I16: Sync,\n I17: Sync,\n I18: Sync,\n I19: Sync,\n I20: Sync,\n I21: Sync,\n I22: Sync,\n I23: Sync,\n I24: Sync,\n I25: Sync,
",1,["wiwi::iter::tuple::Tuple25"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24, I25, I26> Sync for Tuple26<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24, I25, I26>
where\n I1: Sync,\n I2: Sync,\n I3: Sync,\n I4: Sync,\n I5: Sync,\n I6: Sync,\n I7: Sync,\n I8: Sync,\n I9: Sync,\n I10: Sync,\n I11: Sync,\n I12: Sync,\n I13: Sync,\n I14: Sync,\n I15: Sync,\n I16: Sync,\n I17: Sync,\n I18: Sync,\n I19: Sync,\n I20: Sync,\n I21: Sync,\n I22: Sync,\n I23: Sync,\n I24: Sync,\n I25: Sync,\n I26: Sync,
",1,["wiwi::iter::tuple::Tuple26"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24, I25, I26, I27> Sync for Tuple27<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24, I25, I26, I27>
where\n I1: Sync,\n I2: Sync,\n I3: Sync,\n I4: Sync,\n I5: Sync,\n I6: Sync,\n I7: Sync,\n I8: Sync,\n I9: Sync,\n I10: Sync,\n I11: Sync,\n I12: Sync,\n I13: Sync,\n I14: Sync,\n I15: Sync,\n I16: Sync,\n I17: Sync,\n I18: Sync,\n I19: Sync,\n I20: Sync,\n I21: Sync,\n I22: Sync,\n I23: Sync,\n I24: Sync,\n I25: Sync,\n I26: Sync,\n I27: Sync,
",1,["wiwi::iter::tuple::Tuple27"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24, I25, I26, I27, I28> Sync for Tuple28<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24, I25, I26, I27, I28>
where\n I1: Sync,\n I2: Sync,\n I3: Sync,\n I4: Sync,\n I5: Sync,\n I6: Sync,\n I7: Sync,\n I8: Sync,\n I9: Sync,\n I10: Sync,\n I11: Sync,\n I12: Sync,\n I13: Sync,\n I14: Sync,\n I15: Sync,\n I16: Sync,\n I17: Sync,\n I18: Sync,\n I19: Sync,\n I20: Sync,\n I21: Sync,\n I22: Sync,\n I23: Sync,\n I24: Sync,\n I25: Sync,\n I26: Sync,\n I27: Sync,\n I28: Sync,
",1,["wiwi::iter::tuple::Tuple28"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24, I25, I26, I27, I28, I29> Sync for Tuple29<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24, I25, I26, I27, I28, I29>
where\n I1: Sync,\n I2: Sync,\n I3: Sync,\n I4: Sync,\n I5: Sync,\n I6: Sync,\n I7: Sync,\n I8: Sync,\n I9: Sync,\n I10: Sync,\n I11: Sync,\n I12: Sync,\n I13: Sync,\n I14: Sync,\n I15: Sync,\n I16: Sync,\n I17: Sync,\n I18: Sync,\n I19: Sync,\n I20: Sync,\n I21: Sync,\n I22: Sync,\n I23: Sync,\n I24: Sync,\n I25: Sync,\n I26: Sync,\n I27: Sync,\n I28: Sync,\n I29: Sync,
",1,["wiwi::iter::tuple::Tuple29"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24, I25, I26, I27, I28, I29, I30> Sync for Tuple30<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24, I25, I26, I27, I28, I29, I30>
where\n I1: Sync,\n I2: Sync,\n I3: Sync,\n I4: Sync,\n I5: Sync,\n I6: Sync,\n I7: Sync,\n I8: Sync,\n I9: Sync,\n I10: Sync,\n I11: Sync,\n I12: Sync,\n I13: Sync,\n I14: Sync,\n I15: Sync,\n I16: Sync,\n I17: Sync,\n I18: Sync,\n I19: Sync,\n I20: Sync,\n I21: Sync,\n I22: Sync,\n I23: Sync,\n I24: Sync,\n I25: Sync,\n I26: Sync,\n I27: Sync,\n I28: Sync,\n I29: Sync,\n I30: Sync,
",1,["wiwi::iter::tuple::Tuple30"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24, I25, I26, I27, I28, I29, I30, I31> Sync for Tuple31<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24, I25, I26, I27, I28, I29, I30, I31>
where\n I1: Sync,\n I2: Sync,\n I3: Sync,\n I4: Sync,\n I5: Sync,\n I6: Sync,\n I7: Sync,\n I8: Sync,\n I9: Sync,\n I10: Sync,\n I11: Sync,\n I12: Sync,\n I13: Sync,\n I14: Sync,\n I15: Sync,\n I16: Sync,\n I17: Sync,\n I18: Sync,\n I19: Sync,\n I20: Sync,\n I21: Sync,\n I22: Sync,\n I23: Sync,\n I24: Sync,\n I25: Sync,\n I26: Sync,\n I27: Sync,\n I28: Sync,\n I29: Sync,\n I30: Sync,\n I31: Sync,
",1,["wiwi::iter::tuple::Tuple31"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24, I25, I26, I27, I28, I29, I30, I31, I32> Sync for Tuple32<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24, I25, I26, I27, I28, I29, I30, I31, I32>
where\n I1: Sync,\n I2: Sync,\n I3: Sync,\n I4: Sync,\n I5: Sync,\n I6: Sync,\n I7: Sync,\n I8: Sync,\n I9: Sync,\n I10: Sync,\n I11: Sync,\n I12: Sync,\n I13: Sync,\n I14: Sync,\n I15: Sync,\n I16: Sync,\n I17: Sync,\n I18: Sync,\n I19: Sync,\n I20: Sync,\n I21: Sync,\n I22: Sync,\n I23: Sync,\n I24: Sync,\n I25: Sync,\n I26: Sync,\n I27: Sync,\n I28: Sync,\n I29: Sync,\n I30: Sync,\n I31: Sync,\n I32: Sync,
",1,["wiwi::iter::tuple::Tuple32"]],["impl<K, V> Sync for BTreeMapChain<K, V>
where\n K: Sync,\n V: Sync,
",1,["wiwi::chainer::btree_map::BTreeMapChain"]],["impl<K, V, S> Sync for HashMapChain<K, V, S>
where\n S: Sync,\n K: Sync,\n V: Sync,
",1,["wiwi::chainer::hash_map::HashMapChain"]],["impl<P> Sync for String<P>
where\n <P as Pool>::Raw: Sync,\n P: Sync,
",1,["wiwi::string_pool::string::String"]],["impl<T> Sync for BTreeSetChain<T>
where\n T: Sync,
",1,["wiwi::chainer::btree_set::BTreeSetChain"]],["impl<T> Sync for BinaryHeapChain<T>
where\n T: Sync,
",1,["wiwi::chainer::binary_heap::BinaryHeapChain"]],["impl<T> Sync for LinkedListChain<T>
where\n T: Sync,
",1,["wiwi::chainer::linked_list::LinkedListChain"]],["impl<T> Sync for SliceBoxChain<T>
where\n T: Sync,
",1,["wiwi::chainer::slice_box::SliceBoxChain"]],["impl<T> Sync for VecChain<T>
where\n T: Sync,
",1,["wiwi::chainer::vec::VecChain"]],["impl<T> Sync for VecDequeChain<T>
where\n T: Sync,
",1,["wiwi::chainer::vec_deque::VecDequeChain"]],["impl<T> Sync for Empty<T>
where\n T: Sync,
",1,["wiwi::iter::empty::Empty"]],["impl<T, F> Sync for LazyWrapState<T, F>
where\n T: Sync,\n F: Sync,
",1,["wiwi::lazy_wrap::LazyWrapState"]],["impl<T, F> Sync for LazyWrap<T, F>
where\n T: Sync,\n F: Send,
"],["impl<T, S> Sync for HashSetChain<T, S>
where\n S: Sync,\n T: Sync,
",1,["wiwi::chainer::hash_set::HashSetChain"]],["impl<T, const N: usize> Sync for ArrayChain<T, N>
where\n T: Sync,
",1,["wiwi::chainer::array::ArrayChain"]]] +"wiwi":[["impl !Sync for IDGenerator",1,["wiwi::id::IDGenerator"]],["impl !Sync for Script",1,["wiwi::lsl::callback_api::script::Script"]],["impl !Sync for ScriptBuilder",1,["wiwi::lsl::callback_api::script::ScriptBuilder"]],["impl Sync for DecodeError",1,["wiwi::hex::DecodeError"]],["impl Sync for SizeHintBound",1,["wiwi::iter::size_hint::SizeHintBound"]],["impl Sync for Error",1,["wiwi::serialiser::error::Error"]],["impl Sync for DecodeError",1,["wiwi::z85::DecodeError"]],["impl Sync for Error",1,["wiwi::auth::error::Error"]],["impl Sync for ClientContinuerS1",1,["wiwi::auth::flow::signin::ClientContinuerS1"]],["impl Sync for ClientContinuerS2",1,["wiwi::auth::flow::signin::ClientContinuerS2"]],["impl Sync for ClientContinuerS3",1,["wiwi::auth::flow::signin::ClientContinuerS3"]],["impl Sync for ServerS2Params",1,["wiwi::auth::flow::signin::ServerS2Params"]],["impl Sync for ServerS3Params",1,["wiwi::auth::flow::signin::ServerS3Params"]],["impl Sync for SigninRequestS1",1,["wiwi::auth::flow::signin::SigninRequestS1"]],["impl Sync for SigninRequestS2",1,["wiwi::auth::flow::signin::SigninRequestS2"]],["impl Sync for SigninRequestS3",1,["wiwi::auth::flow::signin::SigninRequestS3"]],["impl Sync for SigninResponseS1",1,["wiwi::auth::flow::signin::SigninResponseS1"]],["impl Sync for SigninResponseS2",1,["wiwi::auth::flow::signin::SigninResponseS2"]],["impl Sync for SigninResponseS3",1,["wiwi::auth::flow::signin::SigninResponseS3"]],["impl Sync for SignupRequest",1,["wiwi::auth::flow::signup::SignupRequest"]],["impl Sync for StoredUnverifiedUserData",1,["wiwi::auth::flow::signup::StoredUnverifiedUserData"]],["impl Sync for U320",1,["wiwi::bigint::U320"]],["impl Sync for Encoder",1,["wiwi::bitstream::Encoder"]],["impl Sync for BitstreamEncoderChain",1,["wiwi::chainer::bitstream::BitstreamEncoderChain"]],["impl Sync for StrBoxChain",1,["wiwi::chainer::str_box::StrBoxChain"]],["impl Sync for StringChain",1,["wiwi::chainer::string::StringChain"]],["impl Sync for Builder",1,["wiwi::clock_timer::builder::Builder"]],["impl Sync for BuilderWithEnd",1,["wiwi::clock_timer::builder::BuilderWithEnd"]],["impl Sync for BuilderWithInterval",1,["wiwi::clock_timer::builder::BuilderWithInterval"]],["impl Sync for BuilderWithStart",1,["wiwi::clock_timer::builder::BuilderWithStart"]],["impl Sync for ClockTimer",1,["wiwi::clock_timer::ClockTimer"]],["impl Sync for Tick",1,["wiwi::clock_timer::Tick"]],["impl Sync for GeneratedID",1,["wiwi::id::GeneratedID"]],["impl Sync for SizeHint",1,["wiwi::iter::size_hint::SizeHint"]],["impl Sync for Marker",1,["wiwi::serialiser::marker::Marker"]],["impl Sync for SerialiseOptions",1,["wiwi::serialiser::serialise::SerialiseOptions"]],["impl Sync for GlobalPool",1,["wiwi::string_pool::pool::global::GlobalPool"]],["impl Sync for Board",1,["wiwi::sudoku::Board"]],["impl<'h> Sync for StrMutChain<'h>",1,["wiwi::chainer::str_mut::StrMutChain"]],["impl<'h> Sync for StrRefChain<'h>",1,["wiwi::chainer::str_ref::StrRefChain"]],["impl<'h> Sync for StringMutChain<'h>",1,["wiwi::chainer::string_mut::StringMutChain"]],["impl<'h> Sync for StringRefChain<'h>",1,["wiwi::chainer::string_ref::StringRefChain"]],["impl<'h> Sync for SlicesWrap<'h>",1,["wiwi::string_pool::pool::SlicesWrap"]],["impl<'h> Sync for SlicesWrapIter<'h>",1,["wiwi::string_pool::pool::SlicesWrapIter"]],["impl<'h, T> Sync for SliceMutChain<'h, T>
where\n T: Sync,
",1,["wiwi::chainer::slice_mut::SliceMutChain"]],["impl<'h, T> Sync for SliceRefChain<'h, T>
where\n T: Sync,
",1,["wiwi::chainer::slice_ref::SliceRefChain"]],["impl<'h, T> Sync for VecMutChain<'h, T>
where\n T: Sync,
",1,["wiwi::chainer::vec_mut::VecMutChain"]],["impl<'h, T> Sync for VecRefChain<'h, T>
where\n T: Sync,
",1,["wiwi::chainer::vec_ref::VecRefChain"]],["impl<'h, T, const N: usize> Sync for ArrayMutChain<'h, T, N>
where\n T: Sync,
",1,["wiwi::chainer::array_mut::ArrayMutChain"]],["impl<'h, T, const N: usize> Sync for ArrayRefChain<'h, T, N>
where\n T: Sync,
",1,["wiwi::chainer::array_ref::ArrayRefChain"]],["impl<F> Sync for FromFn<F>
where\n F: Sync,
",1,["wiwi::iter::from_fn::FromFn"]],["impl<I> Sync for IterAdapter<I>
where\n I: Sync,
",1,["wiwi::iter::adapter::IterAdapter"]],["impl<I> Sync for RepeatPerItem<I>
where\n I: Sync,\n <I as Iter>::Item: Sync,
",1,["wiwi::iter::repeat_per_item::RepeatPerItem"]],["impl<I> Sync for Rev<I>
where\n I: Sync,
",1,["wiwi::iter::rev::Rev"]],["impl<I, F> Sync for Map<I, F>
where\n I: Sync,\n F: Sync,
",1,["wiwi::iter::map::Map"]],["impl<I, T> Sync for Peek<I, T>
where\n I: Sync,\n T: Sync,
",1,["wiwi::iter::peek::Peek"]],["impl<I1> Sync for Tuple1<I1>
where\n I1: Sync,
",1,["wiwi::iter::tuple::Tuple1"]],["impl<I1, I2> Sync for Tuple2<I1, I2>
where\n I1: Sync,\n I2: Sync,
",1,["wiwi::iter::tuple::Tuple2"]],["impl<I1, I2, I3> Sync for Tuple3<I1, I2, I3>
where\n I1: Sync,\n I2: Sync,\n I3: Sync,
",1,["wiwi::iter::tuple::Tuple3"]],["impl<I1, I2, I3, I4> Sync for Tuple4<I1, I2, I3, I4>
where\n I1: Sync,\n I2: Sync,\n I3: Sync,\n I4: Sync,
",1,["wiwi::iter::tuple::Tuple4"]],["impl<I1, I2, I3, I4, I5> Sync for Tuple5<I1, I2, I3, I4, I5>
where\n I1: Sync,\n I2: Sync,\n I3: Sync,\n I4: Sync,\n I5: Sync,
",1,["wiwi::iter::tuple::Tuple5"]],["impl<I1, I2, I3, I4, I5, I6> Sync for Tuple6<I1, I2, I3, I4, I5, I6>
where\n I1: Sync,\n I2: Sync,\n I3: Sync,\n I4: Sync,\n I5: Sync,\n I6: Sync,
",1,["wiwi::iter::tuple::Tuple6"]],["impl<I1, I2, I3, I4, I5, I6, I7> Sync for Tuple7<I1, I2, I3, I4, I5, I6, I7>
where\n I1: Sync,\n I2: Sync,\n I3: Sync,\n I4: Sync,\n I5: Sync,\n I6: Sync,\n I7: Sync,
",1,["wiwi::iter::tuple::Tuple7"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8> Sync for Tuple8<I1, I2, I3, I4, I5, I6, I7, I8>
where\n I1: Sync,\n I2: Sync,\n I3: Sync,\n I4: Sync,\n I5: Sync,\n I6: Sync,\n I7: Sync,\n I8: Sync,
",1,["wiwi::iter::tuple::Tuple8"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9> Sync for Tuple9<I1, I2, I3, I4, I5, I6, I7, I8, I9>
where\n I1: Sync,\n I2: Sync,\n I3: Sync,\n I4: Sync,\n I5: Sync,\n I6: Sync,\n I7: Sync,\n I8: Sync,\n I9: Sync,
",1,["wiwi::iter::tuple::Tuple9"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10> Sync for Tuple10<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10>
where\n I1: Sync,\n I2: Sync,\n I3: Sync,\n I4: Sync,\n I5: Sync,\n I6: Sync,\n I7: Sync,\n I8: Sync,\n I9: Sync,\n I10: Sync,
",1,["wiwi::iter::tuple::Tuple10"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11> Sync for Tuple11<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11>
where\n I1: Sync,\n I2: Sync,\n I3: Sync,\n I4: Sync,\n I5: Sync,\n I6: Sync,\n I7: Sync,\n I8: Sync,\n I9: Sync,\n I10: Sync,\n I11: Sync,
",1,["wiwi::iter::tuple::Tuple11"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12> Sync for Tuple12<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12>
where\n I1: Sync,\n I2: Sync,\n I3: Sync,\n I4: Sync,\n I5: Sync,\n I6: Sync,\n I7: Sync,\n I8: Sync,\n I9: Sync,\n I10: Sync,\n I11: Sync,\n I12: Sync,
",1,["wiwi::iter::tuple::Tuple12"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13> Sync for Tuple13<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13>
where\n I1: Sync,\n I2: Sync,\n I3: Sync,\n I4: Sync,\n I5: Sync,\n I6: Sync,\n I7: Sync,\n I8: Sync,\n I9: Sync,\n I10: Sync,\n I11: Sync,\n I12: Sync,\n I13: Sync,
",1,["wiwi::iter::tuple::Tuple13"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14> Sync for Tuple14<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14>
where\n I1: Sync,\n I2: Sync,\n I3: Sync,\n I4: Sync,\n I5: Sync,\n I6: Sync,\n I7: Sync,\n I8: Sync,\n I9: Sync,\n I10: Sync,\n I11: Sync,\n I12: Sync,\n I13: Sync,\n I14: Sync,
",1,["wiwi::iter::tuple::Tuple14"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15> Sync for Tuple15<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15>
where\n I1: Sync,\n I2: Sync,\n I3: Sync,\n I4: Sync,\n I5: Sync,\n I6: Sync,\n I7: Sync,\n I8: Sync,\n I9: Sync,\n I10: Sync,\n I11: Sync,\n I12: Sync,\n I13: Sync,\n I14: Sync,\n I15: Sync,
",1,["wiwi::iter::tuple::Tuple15"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16> Sync for Tuple16<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16>
where\n I1: Sync,\n I2: Sync,\n I3: Sync,\n I4: Sync,\n I5: Sync,\n I6: Sync,\n I7: Sync,\n I8: Sync,\n I9: Sync,\n I10: Sync,\n I11: Sync,\n I12: Sync,\n I13: Sync,\n I14: Sync,\n I15: Sync,\n I16: Sync,
",1,["wiwi::iter::tuple::Tuple16"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17> Sync for Tuple17<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17>
where\n I1: Sync,\n I2: Sync,\n I3: Sync,\n I4: Sync,\n I5: Sync,\n I6: Sync,\n I7: Sync,\n I8: Sync,\n I9: Sync,\n I10: Sync,\n I11: Sync,\n I12: Sync,\n I13: Sync,\n I14: Sync,\n I15: Sync,\n I16: Sync,\n I17: Sync,
",1,["wiwi::iter::tuple::Tuple17"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18> Sync for Tuple18<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18>
where\n I1: Sync,\n I2: Sync,\n I3: Sync,\n I4: Sync,\n I5: Sync,\n I6: Sync,\n I7: Sync,\n I8: Sync,\n I9: Sync,\n I10: Sync,\n I11: Sync,\n I12: Sync,\n I13: Sync,\n I14: Sync,\n I15: Sync,\n I16: Sync,\n I17: Sync,\n I18: Sync,
",1,["wiwi::iter::tuple::Tuple18"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19> Sync for Tuple19<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19>
where\n I1: Sync,\n I2: Sync,\n I3: Sync,\n I4: Sync,\n I5: Sync,\n I6: Sync,\n I7: Sync,\n I8: Sync,\n I9: Sync,\n I10: Sync,\n I11: Sync,\n I12: Sync,\n I13: Sync,\n I14: Sync,\n I15: Sync,\n I16: Sync,\n I17: Sync,\n I18: Sync,\n I19: Sync,
",1,["wiwi::iter::tuple::Tuple19"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20> Sync for Tuple20<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20>
where\n I1: Sync,\n I2: Sync,\n I3: Sync,\n I4: Sync,\n I5: Sync,\n I6: Sync,\n I7: Sync,\n I8: Sync,\n I9: Sync,\n I10: Sync,\n I11: Sync,\n I12: Sync,\n I13: Sync,\n I14: Sync,\n I15: Sync,\n I16: Sync,\n I17: Sync,\n I18: Sync,\n I19: Sync,\n I20: Sync,
",1,["wiwi::iter::tuple::Tuple20"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21> Sync for Tuple21<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21>
where\n I1: Sync,\n I2: Sync,\n I3: Sync,\n I4: Sync,\n I5: Sync,\n I6: Sync,\n I7: Sync,\n I8: Sync,\n I9: Sync,\n I10: Sync,\n I11: Sync,\n I12: Sync,\n I13: Sync,\n I14: Sync,\n I15: Sync,\n I16: Sync,\n I17: Sync,\n I18: Sync,\n I19: Sync,\n I20: Sync,\n I21: Sync,
",1,["wiwi::iter::tuple::Tuple21"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22> Sync for Tuple22<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22>
where\n I1: Sync,\n I2: Sync,\n I3: Sync,\n I4: Sync,\n I5: Sync,\n I6: Sync,\n I7: Sync,\n I8: Sync,\n I9: Sync,\n I10: Sync,\n I11: Sync,\n I12: Sync,\n I13: Sync,\n I14: Sync,\n I15: Sync,\n I16: Sync,\n I17: Sync,\n I18: Sync,\n I19: Sync,\n I20: Sync,\n I21: Sync,\n I22: Sync,
",1,["wiwi::iter::tuple::Tuple22"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23> Sync for Tuple23<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23>
where\n I1: Sync,\n I2: Sync,\n I3: Sync,\n I4: Sync,\n I5: Sync,\n I6: Sync,\n I7: Sync,\n I8: Sync,\n I9: Sync,\n I10: Sync,\n I11: Sync,\n I12: Sync,\n I13: Sync,\n I14: Sync,\n I15: Sync,\n I16: Sync,\n I17: Sync,\n I18: Sync,\n I19: Sync,\n I20: Sync,\n I21: Sync,\n I22: Sync,\n I23: Sync,
",1,["wiwi::iter::tuple::Tuple23"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24> Sync for Tuple24<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24>
where\n I1: Sync,\n I2: Sync,\n I3: Sync,\n I4: Sync,\n I5: Sync,\n I6: Sync,\n I7: Sync,\n I8: Sync,\n I9: Sync,\n I10: Sync,\n I11: Sync,\n I12: Sync,\n I13: Sync,\n I14: Sync,\n I15: Sync,\n I16: Sync,\n I17: Sync,\n I18: Sync,\n I19: Sync,\n I20: Sync,\n I21: Sync,\n I22: Sync,\n I23: Sync,\n I24: Sync,
",1,["wiwi::iter::tuple::Tuple24"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24, I25> Sync for Tuple25<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24, I25>
where\n I1: Sync,\n I2: Sync,\n I3: Sync,\n I4: Sync,\n I5: Sync,\n I6: Sync,\n I7: Sync,\n I8: Sync,\n I9: Sync,\n I10: Sync,\n I11: Sync,\n I12: Sync,\n I13: Sync,\n I14: Sync,\n I15: Sync,\n I16: Sync,\n I17: Sync,\n I18: Sync,\n I19: Sync,\n I20: Sync,\n I21: Sync,\n I22: Sync,\n I23: Sync,\n I24: Sync,\n I25: Sync,
",1,["wiwi::iter::tuple::Tuple25"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24, I25, I26> Sync for Tuple26<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24, I25, I26>
where\n I1: Sync,\n I2: Sync,\n I3: Sync,\n I4: Sync,\n I5: Sync,\n I6: Sync,\n I7: Sync,\n I8: Sync,\n I9: Sync,\n I10: Sync,\n I11: Sync,\n I12: Sync,\n I13: Sync,\n I14: Sync,\n I15: Sync,\n I16: Sync,\n I17: Sync,\n I18: Sync,\n I19: Sync,\n I20: Sync,\n I21: Sync,\n I22: Sync,\n I23: Sync,\n I24: Sync,\n I25: Sync,\n I26: Sync,
",1,["wiwi::iter::tuple::Tuple26"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24, I25, I26, I27> Sync for Tuple27<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24, I25, I26, I27>
where\n I1: Sync,\n I2: Sync,\n I3: Sync,\n I4: Sync,\n I5: Sync,\n I6: Sync,\n I7: Sync,\n I8: Sync,\n I9: Sync,\n I10: Sync,\n I11: Sync,\n I12: Sync,\n I13: Sync,\n I14: Sync,\n I15: Sync,\n I16: Sync,\n I17: Sync,\n I18: Sync,\n I19: Sync,\n I20: Sync,\n I21: Sync,\n I22: Sync,\n I23: Sync,\n I24: Sync,\n I25: Sync,\n I26: Sync,\n I27: Sync,
",1,["wiwi::iter::tuple::Tuple27"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24, I25, I26, I27, I28> Sync for Tuple28<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24, I25, I26, I27, I28>
where\n I1: Sync,\n I2: Sync,\n I3: Sync,\n I4: Sync,\n I5: Sync,\n I6: Sync,\n I7: Sync,\n I8: Sync,\n I9: Sync,\n I10: Sync,\n I11: Sync,\n I12: Sync,\n I13: Sync,\n I14: Sync,\n I15: Sync,\n I16: Sync,\n I17: Sync,\n I18: Sync,\n I19: Sync,\n I20: Sync,\n I21: Sync,\n I22: Sync,\n I23: Sync,\n I24: Sync,\n I25: Sync,\n I26: Sync,\n I27: Sync,\n I28: Sync,
",1,["wiwi::iter::tuple::Tuple28"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24, I25, I26, I27, I28, I29> Sync for Tuple29<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24, I25, I26, I27, I28, I29>
where\n I1: Sync,\n I2: Sync,\n I3: Sync,\n I4: Sync,\n I5: Sync,\n I6: Sync,\n I7: Sync,\n I8: Sync,\n I9: Sync,\n I10: Sync,\n I11: Sync,\n I12: Sync,\n I13: Sync,\n I14: Sync,\n I15: Sync,\n I16: Sync,\n I17: Sync,\n I18: Sync,\n I19: Sync,\n I20: Sync,\n I21: Sync,\n I22: Sync,\n I23: Sync,\n I24: Sync,\n I25: Sync,\n I26: Sync,\n I27: Sync,\n I28: Sync,\n I29: Sync,
",1,["wiwi::iter::tuple::Tuple29"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24, I25, I26, I27, I28, I29, I30> Sync for Tuple30<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24, I25, I26, I27, I28, I29, I30>
where\n I1: Sync,\n I2: Sync,\n I3: Sync,\n I4: Sync,\n I5: Sync,\n I6: Sync,\n I7: Sync,\n I8: Sync,\n I9: Sync,\n I10: Sync,\n I11: Sync,\n I12: Sync,\n I13: Sync,\n I14: Sync,\n I15: Sync,\n I16: Sync,\n I17: Sync,\n I18: Sync,\n I19: Sync,\n I20: Sync,\n I21: Sync,\n I22: Sync,\n I23: Sync,\n I24: Sync,\n I25: Sync,\n I26: Sync,\n I27: Sync,\n I28: Sync,\n I29: Sync,\n I30: Sync,
",1,["wiwi::iter::tuple::Tuple30"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24, I25, I26, I27, I28, I29, I30, I31> Sync for Tuple31<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24, I25, I26, I27, I28, I29, I30, I31>
where\n I1: Sync,\n I2: Sync,\n I3: Sync,\n I4: Sync,\n I5: Sync,\n I6: Sync,\n I7: Sync,\n I8: Sync,\n I9: Sync,\n I10: Sync,\n I11: Sync,\n I12: Sync,\n I13: Sync,\n I14: Sync,\n I15: Sync,\n I16: Sync,\n I17: Sync,\n I18: Sync,\n I19: Sync,\n I20: Sync,\n I21: Sync,\n I22: Sync,\n I23: Sync,\n I24: Sync,\n I25: Sync,\n I26: Sync,\n I27: Sync,\n I28: Sync,\n I29: Sync,\n I30: Sync,\n I31: Sync,
",1,["wiwi::iter::tuple::Tuple31"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24, I25, I26, I27, I28, I29, I30, I31, I32> Sync for Tuple32<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24, I25, I26, I27, I28, I29, I30, I31, I32>
where\n I1: Sync,\n I2: Sync,\n I3: Sync,\n I4: Sync,\n I5: Sync,\n I6: Sync,\n I7: Sync,\n I8: Sync,\n I9: Sync,\n I10: Sync,\n I11: Sync,\n I12: Sync,\n I13: Sync,\n I14: Sync,\n I15: Sync,\n I16: Sync,\n I17: Sync,\n I18: Sync,\n I19: Sync,\n I20: Sync,\n I21: Sync,\n I22: Sync,\n I23: Sync,\n I24: Sync,\n I25: Sync,\n I26: Sync,\n I27: Sync,\n I28: Sync,\n I29: Sync,\n I30: Sync,\n I31: Sync,\n I32: Sync,
",1,["wiwi::iter::tuple::Tuple32"]],["impl<K, V> Sync for BTreeMapChain<K, V>
where\n K: Sync,\n V: Sync,
",1,["wiwi::chainer::btree_map::BTreeMapChain"]],["impl<K, V, S> Sync for HashMapChain<K, V, S>
where\n S: Sync,\n K: Sync,\n V: Sync,
",1,["wiwi::chainer::hash_map::HashMapChain"]],["impl<P> Sync for String<P>
where\n <P as Pool>::Raw: Sync,\n P: Sync,
",1,["wiwi::string_pool::string::String"]],["impl<T> Sync for BTreeSetChain<T>
where\n T: Sync,
",1,["wiwi::chainer::btree_set::BTreeSetChain"]],["impl<T> Sync for BinaryHeapChain<T>
where\n T: Sync,
",1,["wiwi::chainer::binary_heap::BinaryHeapChain"]],["impl<T> Sync for LinkedListChain<T>
where\n T: Sync,
",1,["wiwi::chainer::linked_list::LinkedListChain"]],["impl<T> Sync for SliceBoxChain<T>
where\n T: Sync,
",1,["wiwi::chainer::slice_box::SliceBoxChain"]],["impl<T> Sync for VecChain<T>
where\n T: Sync,
",1,["wiwi::chainer::vec::VecChain"]],["impl<T> Sync for VecDequeChain<T>
where\n T: Sync,
",1,["wiwi::chainer::vec_deque::VecDequeChain"]],["impl<T> Sync for Empty<T>
where\n T: Sync,
",1,["wiwi::iter::empty::Empty"]],["impl<T, F> Sync for LazyWrapState<T, F>
where\n T: Sync,\n F: Sync,
",1,["wiwi::lazy_wrap::LazyWrapState"]],["impl<T, F> Sync for LazyWrap<T, F>
where\n T: Sync,\n F: Send,
"],["impl<T, S> Sync for HashSetChain<T, S>
where\n S: Sync,\n T: Sync,
",1,["wiwi::chainer::hash_set::HashSetChain"]],["impl<T, const N: usize> Sync for ArrayChain<T, N>
where\n T: Sync,
",1,["wiwi::chainer::array::ArrayChain"]]] };if (window.register_implementors) {window.register_implementors(implementors);} else {window.pending_implementors = implementors;}})() \ No newline at end of file diff --git a/trait.impl/core/marker/trait.Unpin.js b/trait.impl/core/marker/trait.Unpin.js index 6a788d5f4..c64eee480 100644 --- a/trait.impl/core/marker/trait.Unpin.js +++ b/trait.impl/core/marker/trait.Unpin.js @@ -1,3 +1,3 @@ (function() {var implementors = { -"wiwi":[["impl Unpin for DecodeError",1,["wiwi::hex::DecodeError"]],["impl Unpin for SizeHintBound",1,["wiwi::iter::size_hint::SizeHintBound"]],["impl Unpin for Error",1,["wiwi::serialiser::error::Error"]],["impl Unpin for DecodeError",1,["wiwi::z85::DecodeError"]],["impl Unpin for Error",1,["wiwi::auth::error::Error"]],["impl Unpin for ClientContinuerS1",1,["wiwi::auth::flow::signin::ClientContinuerS1"]],["impl Unpin for ClientContinuerS2",1,["wiwi::auth::flow::signin::ClientContinuerS2"]],["impl Unpin for ClientContinuerS3",1,["wiwi::auth::flow::signin::ClientContinuerS3"]],["impl Unpin for ServerS2Params",1,["wiwi::auth::flow::signin::ServerS2Params"]],["impl Unpin for ServerS3Params",1,["wiwi::auth::flow::signin::ServerS3Params"]],["impl Unpin for SigninRequestS1",1,["wiwi::auth::flow::signin::SigninRequestS1"]],["impl Unpin for SigninRequestS2",1,["wiwi::auth::flow::signin::SigninRequestS2"]],["impl Unpin for SigninRequestS3",1,["wiwi::auth::flow::signin::SigninRequestS3"]],["impl Unpin for SigninResponseS1",1,["wiwi::auth::flow::signin::SigninResponseS1"]],["impl Unpin for SigninResponseS2",1,["wiwi::auth::flow::signin::SigninResponseS2"]],["impl Unpin for SigninResponseS3",1,["wiwi::auth::flow::signin::SigninResponseS3"]],["impl Unpin for SignupRequest",1,["wiwi::auth::flow::signup::SignupRequest"]],["impl Unpin for StoredUnverifiedUserData",1,["wiwi::auth::flow::signup::StoredUnverifiedUserData"]],["impl Unpin for U320",1,["wiwi::bigint::U320"]],["impl Unpin for Encoder",1,["wiwi::bitstream::Encoder"]],["impl Unpin for BitstreamEncoderChain",1,["wiwi::chainer::bitstream::BitstreamEncoderChain"]],["impl Unpin for StrBoxChain",1,["wiwi::chainer::str_box::StrBoxChain"]],["impl Unpin for StringChain",1,["wiwi::chainer::string::StringChain"]],["impl Unpin for Builder",1,["wiwi::clock_timer::builder::Builder"]],["impl Unpin for BuilderWithEnd",1,["wiwi::clock_timer::builder::BuilderWithEnd"]],["impl Unpin for BuilderWithInterval",1,["wiwi::clock_timer::builder::BuilderWithInterval"]],["impl Unpin for BuilderWithStart",1,["wiwi::clock_timer::builder::BuilderWithStart"]],["impl Unpin for ClockTimer",1,["wiwi::clock_timer::ClockTimer"]],["impl Unpin for Tick",1,["wiwi::clock_timer::Tick"]],["impl Unpin for GeneratedID",1,["wiwi::id::GeneratedID"]],["impl Unpin for IDGenerator",1,["wiwi::id::IDGenerator"]],["impl Unpin for SizeHint",1,["wiwi::iter::size_hint::SizeHint"]],["impl Unpin for Script",1,["wiwi::lsl::callback_api::script::Script"]],["impl Unpin for ScriptBuilder",1,["wiwi::lsl::callback_api::script::ScriptBuilder"]],["impl Unpin for SerialiseOptions",1,["wiwi::serialiser::serialise::SerialiseOptions"]],["impl Unpin for GlobalPool",1,["wiwi::string_pool::pool::global::GlobalPool"]],["impl Unpin for Board",1,["wiwi::sudoku::Board"]],["impl<'h> Unpin for StrMutChain<'h>",1,["wiwi::chainer::str_mut::StrMutChain"]],["impl<'h> Unpin for StrRefChain<'h>",1,["wiwi::chainer::str_ref::StrRefChain"]],["impl<'h> Unpin for StringMutChain<'h>",1,["wiwi::chainer::string_mut::StringMutChain"]],["impl<'h> Unpin for StringRefChain<'h>",1,["wiwi::chainer::string_ref::StringRefChain"]],["impl<'h> Unpin for SlicesWrap<'h>",1,["wiwi::string_pool::pool::SlicesWrap"]],["impl<'h> Unpin for SlicesWrapIter<'h>",1,["wiwi::string_pool::pool::SlicesWrapIter"]],["impl<'h, T> Unpin for SliceMutChain<'h, T>",1,["wiwi::chainer::slice_mut::SliceMutChain"]],["impl<'h, T> Unpin for SliceRefChain<'h, T>",1,["wiwi::chainer::slice_ref::SliceRefChain"]],["impl<'h, T> Unpin for VecMutChain<'h, T>",1,["wiwi::chainer::vec_mut::VecMutChain"]],["impl<'h, T> Unpin for VecRefChain<'h, T>",1,["wiwi::chainer::vec_ref::VecRefChain"]],["impl<'h, T, const N: usize> Unpin for ArrayMutChain<'h, T, N>",1,["wiwi::chainer::array_mut::ArrayMutChain"]],["impl<'h, T, const N: usize> Unpin for ArrayRefChain<'h, T, N>",1,["wiwi::chainer::array_ref::ArrayRefChain"]],["impl<F> Unpin for FromFn<F>
where\n F: Unpin,
",1,["wiwi::iter::from_fn::FromFn"]],["impl<I> Unpin for IterAdapter<I>
where\n I: Unpin,
",1,["wiwi::iter::adapter::IterAdapter"]],["impl<I> Unpin for RepeatPerItem<I>
where\n I: Unpin,\n <I as Iter>::Item: Unpin,
",1,["wiwi::iter::repeat_per_item::RepeatPerItem"]],["impl<I, F> Unpin for Map<I, F>
where\n I: Unpin,\n F: Unpin,
",1,["wiwi::iter::map::Map"]],["impl<I, T> Unpin for Peek<I, T>
where\n I: Unpin,\n T: Unpin,
",1,["wiwi::iter::peek::Peek"]],["impl<I1> Unpin for Tuple1<I1>
where\n I1: Unpin,
",1,["wiwi::iter::tuple::Tuple1"]],["impl<I1, I2> Unpin for Tuple2<I1, I2>
where\n I1: Unpin,\n I2: Unpin,
",1,["wiwi::iter::tuple::Tuple2"]],["impl<I1, I2, I3> Unpin for Tuple3<I1, I2, I3>
where\n I1: Unpin,\n I2: Unpin,\n I3: Unpin,
",1,["wiwi::iter::tuple::Tuple3"]],["impl<I1, I2, I3, I4> Unpin for Tuple4<I1, I2, I3, I4>
where\n I1: Unpin,\n I2: Unpin,\n I3: Unpin,\n I4: Unpin,
",1,["wiwi::iter::tuple::Tuple4"]],["impl<I1, I2, I3, I4, I5> Unpin for Tuple5<I1, I2, I3, I4, I5>
where\n I1: Unpin,\n I2: Unpin,\n I3: Unpin,\n I4: Unpin,\n I5: Unpin,
",1,["wiwi::iter::tuple::Tuple5"]],["impl<I1, I2, I3, I4, I5, I6> Unpin for Tuple6<I1, I2, I3, I4, I5, I6>
where\n I1: Unpin,\n I2: Unpin,\n I3: Unpin,\n I4: Unpin,\n I5: Unpin,\n I6: Unpin,
",1,["wiwi::iter::tuple::Tuple6"]],["impl<I1, I2, I3, I4, I5, I6, I7> Unpin for Tuple7<I1, I2, I3, I4, I5, I6, I7>
where\n I1: Unpin,\n I2: Unpin,\n I3: Unpin,\n I4: Unpin,\n I5: Unpin,\n I6: Unpin,\n I7: Unpin,
",1,["wiwi::iter::tuple::Tuple7"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8> Unpin for Tuple8<I1, I2, I3, I4, I5, I6, I7, I8>
where\n I1: Unpin,\n I2: Unpin,\n I3: Unpin,\n I4: Unpin,\n I5: Unpin,\n I6: Unpin,\n I7: Unpin,\n I8: Unpin,
",1,["wiwi::iter::tuple::Tuple8"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9> Unpin for Tuple9<I1, I2, I3, I4, I5, I6, I7, I8, I9>
where\n I1: Unpin,\n I2: Unpin,\n I3: Unpin,\n I4: Unpin,\n I5: Unpin,\n I6: Unpin,\n I7: Unpin,\n I8: Unpin,\n I9: Unpin,
",1,["wiwi::iter::tuple::Tuple9"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10> Unpin for Tuple10<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10>
where\n I1: Unpin,\n I2: Unpin,\n I3: Unpin,\n I4: Unpin,\n I5: Unpin,\n I6: Unpin,\n I7: Unpin,\n I8: Unpin,\n I9: Unpin,\n I10: Unpin,
",1,["wiwi::iter::tuple::Tuple10"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11> Unpin for Tuple11<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11>
where\n I1: Unpin,\n I2: Unpin,\n I3: Unpin,\n I4: Unpin,\n I5: Unpin,\n I6: Unpin,\n I7: Unpin,\n I8: Unpin,\n I9: Unpin,\n I10: Unpin,\n I11: Unpin,
",1,["wiwi::iter::tuple::Tuple11"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12> Unpin for Tuple12<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12>
where\n I1: Unpin,\n I2: Unpin,\n I3: Unpin,\n I4: Unpin,\n I5: Unpin,\n I6: Unpin,\n I7: Unpin,\n I8: Unpin,\n I9: Unpin,\n I10: Unpin,\n I11: Unpin,\n I12: Unpin,
",1,["wiwi::iter::tuple::Tuple12"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13> Unpin for Tuple13<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13>
where\n I1: Unpin,\n I2: Unpin,\n I3: Unpin,\n I4: Unpin,\n I5: Unpin,\n I6: Unpin,\n I7: Unpin,\n I8: Unpin,\n I9: Unpin,\n I10: Unpin,\n I11: Unpin,\n I12: Unpin,\n I13: Unpin,
",1,["wiwi::iter::tuple::Tuple13"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14> Unpin for Tuple14<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14>
where\n I1: Unpin,\n I2: Unpin,\n I3: Unpin,\n I4: Unpin,\n I5: Unpin,\n I6: Unpin,\n I7: Unpin,\n I8: Unpin,\n I9: Unpin,\n I10: Unpin,\n I11: Unpin,\n I12: Unpin,\n I13: Unpin,\n I14: Unpin,
",1,["wiwi::iter::tuple::Tuple14"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15> Unpin for Tuple15<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15>
where\n I1: Unpin,\n I2: Unpin,\n I3: Unpin,\n I4: Unpin,\n I5: Unpin,\n I6: Unpin,\n I7: Unpin,\n I8: Unpin,\n I9: Unpin,\n I10: Unpin,\n I11: Unpin,\n I12: Unpin,\n I13: Unpin,\n I14: Unpin,\n I15: Unpin,
",1,["wiwi::iter::tuple::Tuple15"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16> Unpin for Tuple16<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16>
where\n I1: Unpin,\n I2: Unpin,\n I3: Unpin,\n I4: Unpin,\n I5: Unpin,\n I6: Unpin,\n I7: Unpin,\n I8: Unpin,\n I9: Unpin,\n I10: Unpin,\n I11: Unpin,\n I12: Unpin,\n I13: Unpin,\n I14: Unpin,\n I15: Unpin,\n I16: Unpin,
",1,["wiwi::iter::tuple::Tuple16"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17> Unpin for Tuple17<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17>
where\n I1: Unpin,\n I2: Unpin,\n I3: Unpin,\n I4: Unpin,\n I5: Unpin,\n I6: Unpin,\n I7: Unpin,\n I8: Unpin,\n I9: Unpin,\n I10: Unpin,\n I11: Unpin,\n I12: Unpin,\n I13: Unpin,\n I14: Unpin,\n I15: Unpin,\n I16: Unpin,\n I17: Unpin,
",1,["wiwi::iter::tuple::Tuple17"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18> Unpin for Tuple18<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18>
where\n I1: Unpin,\n I2: Unpin,\n I3: Unpin,\n I4: Unpin,\n I5: Unpin,\n I6: Unpin,\n I7: Unpin,\n I8: Unpin,\n I9: Unpin,\n I10: Unpin,\n I11: Unpin,\n I12: Unpin,\n I13: Unpin,\n I14: Unpin,\n I15: Unpin,\n I16: Unpin,\n I17: Unpin,\n I18: Unpin,
",1,["wiwi::iter::tuple::Tuple18"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19> Unpin for Tuple19<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19>
where\n I1: Unpin,\n I2: Unpin,\n I3: Unpin,\n I4: Unpin,\n I5: Unpin,\n I6: Unpin,\n I7: Unpin,\n I8: Unpin,\n I9: Unpin,\n I10: Unpin,\n I11: Unpin,\n I12: Unpin,\n I13: Unpin,\n I14: Unpin,\n I15: Unpin,\n I16: Unpin,\n I17: Unpin,\n I18: Unpin,\n I19: Unpin,
",1,["wiwi::iter::tuple::Tuple19"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20> Unpin for Tuple20<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20>
where\n I1: Unpin,\n I2: Unpin,\n I3: Unpin,\n I4: Unpin,\n I5: Unpin,\n I6: Unpin,\n I7: Unpin,\n I8: Unpin,\n I9: Unpin,\n I10: Unpin,\n I11: Unpin,\n I12: Unpin,\n I13: Unpin,\n I14: Unpin,\n I15: Unpin,\n I16: Unpin,\n I17: Unpin,\n I18: Unpin,\n I19: Unpin,\n I20: Unpin,
",1,["wiwi::iter::tuple::Tuple20"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21> Unpin for Tuple21<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21>
where\n I1: Unpin,\n I2: Unpin,\n I3: Unpin,\n I4: Unpin,\n I5: Unpin,\n I6: Unpin,\n I7: Unpin,\n I8: Unpin,\n I9: Unpin,\n I10: Unpin,\n I11: Unpin,\n I12: Unpin,\n I13: Unpin,\n I14: Unpin,\n I15: Unpin,\n I16: Unpin,\n I17: Unpin,\n I18: Unpin,\n I19: Unpin,\n I20: Unpin,\n I21: Unpin,
",1,["wiwi::iter::tuple::Tuple21"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22> Unpin for Tuple22<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22>
where\n I1: Unpin,\n I2: Unpin,\n I3: Unpin,\n I4: Unpin,\n I5: Unpin,\n I6: Unpin,\n I7: Unpin,\n I8: Unpin,\n I9: Unpin,\n I10: Unpin,\n I11: Unpin,\n I12: Unpin,\n I13: Unpin,\n I14: Unpin,\n I15: Unpin,\n I16: Unpin,\n I17: Unpin,\n I18: Unpin,\n I19: Unpin,\n I20: Unpin,\n I21: Unpin,\n I22: Unpin,
",1,["wiwi::iter::tuple::Tuple22"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23> Unpin for Tuple23<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23>
where\n I1: Unpin,\n I2: Unpin,\n I3: Unpin,\n I4: Unpin,\n I5: Unpin,\n I6: Unpin,\n I7: Unpin,\n I8: Unpin,\n I9: Unpin,\n I10: Unpin,\n I11: Unpin,\n I12: Unpin,\n I13: Unpin,\n I14: Unpin,\n I15: Unpin,\n I16: Unpin,\n I17: Unpin,\n I18: Unpin,\n I19: Unpin,\n I20: Unpin,\n I21: Unpin,\n I22: Unpin,\n I23: Unpin,
",1,["wiwi::iter::tuple::Tuple23"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24> Unpin for Tuple24<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24>
where\n I1: Unpin,\n I2: Unpin,\n I3: Unpin,\n I4: Unpin,\n I5: Unpin,\n I6: Unpin,\n I7: Unpin,\n I8: Unpin,\n I9: Unpin,\n I10: Unpin,\n I11: Unpin,\n I12: Unpin,\n I13: Unpin,\n I14: Unpin,\n I15: Unpin,\n I16: Unpin,\n I17: Unpin,\n I18: Unpin,\n I19: Unpin,\n I20: Unpin,\n I21: Unpin,\n I22: Unpin,\n I23: Unpin,\n I24: Unpin,
",1,["wiwi::iter::tuple::Tuple24"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24, I25> Unpin for Tuple25<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24, I25>
where\n I1: Unpin,\n I2: Unpin,\n I3: Unpin,\n I4: Unpin,\n I5: Unpin,\n I6: Unpin,\n I7: Unpin,\n I8: Unpin,\n I9: Unpin,\n I10: Unpin,\n I11: Unpin,\n I12: Unpin,\n I13: Unpin,\n I14: Unpin,\n I15: Unpin,\n I16: Unpin,\n I17: Unpin,\n I18: Unpin,\n I19: Unpin,\n I20: Unpin,\n I21: Unpin,\n I22: Unpin,\n I23: Unpin,\n I24: Unpin,\n I25: Unpin,
",1,["wiwi::iter::tuple::Tuple25"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24, I25, I26> Unpin for Tuple26<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24, I25, I26>
where\n I1: Unpin,\n I2: Unpin,\n I3: Unpin,\n I4: Unpin,\n I5: Unpin,\n I6: Unpin,\n I7: Unpin,\n I8: Unpin,\n I9: Unpin,\n I10: Unpin,\n I11: Unpin,\n I12: Unpin,\n I13: Unpin,\n I14: Unpin,\n I15: Unpin,\n I16: Unpin,\n I17: Unpin,\n I18: Unpin,\n I19: Unpin,\n I20: Unpin,\n I21: Unpin,\n I22: Unpin,\n I23: Unpin,\n I24: Unpin,\n I25: Unpin,\n I26: Unpin,
",1,["wiwi::iter::tuple::Tuple26"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24, I25, I26, I27> Unpin for Tuple27<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24, I25, I26, I27>
where\n I1: Unpin,\n I2: Unpin,\n I3: Unpin,\n I4: Unpin,\n I5: Unpin,\n I6: Unpin,\n I7: Unpin,\n I8: Unpin,\n I9: Unpin,\n I10: Unpin,\n I11: Unpin,\n I12: Unpin,\n I13: Unpin,\n I14: Unpin,\n I15: Unpin,\n I16: Unpin,\n I17: Unpin,\n I18: Unpin,\n I19: Unpin,\n I20: Unpin,\n I21: Unpin,\n I22: Unpin,\n I23: Unpin,\n I24: Unpin,\n I25: Unpin,\n I26: Unpin,\n I27: Unpin,
",1,["wiwi::iter::tuple::Tuple27"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24, I25, I26, I27, I28> Unpin for Tuple28<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24, I25, I26, I27, I28>
where\n I1: Unpin,\n I2: Unpin,\n I3: Unpin,\n I4: Unpin,\n I5: Unpin,\n I6: Unpin,\n I7: Unpin,\n I8: Unpin,\n I9: Unpin,\n I10: Unpin,\n I11: Unpin,\n I12: Unpin,\n I13: Unpin,\n I14: Unpin,\n I15: Unpin,\n I16: Unpin,\n I17: Unpin,\n I18: Unpin,\n I19: Unpin,\n I20: Unpin,\n I21: Unpin,\n I22: Unpin,\n I23: Unpin,\n I24: Unpin,\n I25: Unpin,\n I26: Unpin,\n I27: Unpin,\n I28: Unpin,
",1,["wiwi::iter::tuple::Tuple28"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24, I25, I26, I27, I28, I29> Unpin for Tuple29<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24, I25, I26, I27, I28, I29>
where\n I1: Unpin,\n I2: Unpin,\n I3: Unpin,\n I4: Unpin,\n I5: Unpin,\n I6: Unpin,\n I7: Unpin,\n I8: Unpin,\n I9: Unpin,\n I10: Unpin,\n I11: Unpin,\n I12: Unpin,\n I13: Unpin,\n I14: Unpin,\n I15: Unpin,\n I16: Unpin,\n I17: Unpin,\n I18: Unpin,\n I19: Unpin,\n I20: Unpin,\n I21: Unpin,\n I22: Unpin,\n I23: Unpin,\n I24: Unpin,\n I25: Unpin,\n I26: Unpin,\n I27: Unpin,\n I28: Unpin,\n I29: Unpin,
",1,["wiwi::iter::tuple::Tuple29"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24, I25, I26, I27, I28, I29, I30> Unpin for Tuple30<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24, I25, I26, I27, I28, I29, I30>
where\n I1: Unpin,\n I2: Unpin,\n I3: Unpin,\n I4: Unpin,\n I5: Unpin,\n I6: Unpin,\n I7: Unpin,\n I8: Unpin,\n I9: Unpin,\n I10: Unpin,\n I11: Unpin,\n I12: Unpin,\n I13: Unpin,\n I14: Unpin,\n I15: Unpin,\n I16: Unpin,\n I17: Unpin,\n I18: Unpin,\n I19: Unpin,\n I20: Unpin,\n I21: Unpin,\n I22: Unpin,\n I23: Unpin,\n I24: Unpin,\n I25: Unpin,\n I26: Unpin,\n I27: Unpin,\n I28: Unpin,\n I29: Unpin,\n I30: Unpin,
",1,["wiwi::iter::tuple::Tuple30"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24, I25, I26, I27, I28, I29, I30, I31> Unpin for Tuple31<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24, I25, I26, I27, I28, I29, I30, I31>
where\n I1: Unpin,\n I2: Unpin,\n I3: Unpin,\n I4: Unpin,\n I5: Unpin,\n I6: Unpin,\n I7: Unpin,\n I8: Unpin,\n I9: Unpin,\n I10: Unpin,\n I11: Unpin,\n I12: Unpin,\n I13: Unpin,\n I14: Unpin,\n I15: Unpin,\n I16: Unpin,\n I17: Unpin,\n I18: Unpin,\n I19: Unpin,\n I20: Unpin,\n I21: Unpin,\n I22: Unpin,\n I23: Unpin,\n I24: Unpin,\n I25: Unpin,\n I26: Unpin,\n I27: Unpin,\n I28: Unpin,\n I29: Unpin,\n I30: Unpin,\n I31: Unpin,
",1,["wiwi::iter::tuple::Tuple31"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24, I25, I26, I27, I28, I29, I30, I31, I32> Unpin for Tuple32<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24, I25, I26, I27, I28, I29, I30, I31, I32>
where\n I1: Unpin,\n I2: Unpin,\n I3: Unpin,\n I4: Unpin,\n I5: Unpin,\n I6: Unpin,\n I7: Unpin,\n I8: Unpin,\n I9: Unpin,\n I10: Unpin,\n I11: Unpin,\n I12: Unpin,\n I13: Unpin,\n I14: Unpin,\n I15: Unpin,\n I16: Unpin,\n I17: Unpin,\n I18: Unpin,\n I19: Unpin,\n I20: Unpin,\n I21: Unpin,\n I22: Unpin,\n I23: Unpin,\n I24: Unpin,\n I25: Unpin,\n I26: Unpin,\n I27: Unpin,\n I28: Unpin,\n I29: Unpin,\n I30: Unpin,\n I31: Unpin,\n I32: Unpin,
",1,["wiwi::iter::tuple::Tuple32"]],["impl<K, V> Unpin for BTreeMapChain<K, V>",1,["wiwi::chainer::btree_map::BTreeMapChain"]],["impl<K, V, S> Unpin for HashMapChain<K, V, S>
where\n S: Unpin,\n K: Unpin,\n V: Unpin,
",1,["wiwi::chainer::hash_map::HashMapChain"]],["impl<P> Unpin for String<P>
where\n <P as Pool>::Raw: Unpin,\n P: Unpin,
",1,["wiwi::string_pool::string::String"]],["impl<T> Unpin for BTreeSetChain<T>",1,["wiwi::chainer::btree_set::BTreeSetChain"]],["impl<T> Unpin for BinaryHeapChain<T>
where\n T: Unpin,
",1,["wiwi::chainer::binary_heap::BinaryHeapChain"]],["impl<T> Unpin for LinkedListChain<T>",1,["wiwi::chainer::linked_list::LinkedListChain"]],["impl<T> Unpin for SliceBoxChain<T>",1,["wiwi::chainer::slice_box::SliceBoxChain"]],["impl<T> Unpin for VecChain<T>
where\n T: Unpin,
",1,["wiwi::chainer::vec::VecChain"]],["impl<T> Unpin for VecDequeChain<T>
where\n T: Unpin,
",1,["wiwi::chainer::vec_deque::VecDequeChain"]],["impl<T> Unpin for Empty<T>
where\n T: Unpin,
",1,["wiwi::iter::empty::Empty"]],["impl<T, F> Unpin for LazyWrapState<T, F>
where\n T: Unpin,\n F: Unpin,
",1,["wiwi::lazy_wrap::LazyWrapState"]],["impl<T, F> Unpin for LazyWrap<T, F>
where\n T: Unpin,\n F: Unpin,
"],["impl<T, S> Unpin for HashSetChain<T, S>
where\n S: Unpin,\n T: Unpin,
",1,["wiwi::chainer::hash_set::HashSetChain"]],["impl<T, const N: usize> Unpin for ArrayChain<T, N>
where\n T: Unpin,
",1,["wiwi::chainer::array::ArrayChain"]]] +"wiwi":[["impl Unpin for DecodeError",1,["wiwi::hex::DecodeError"]],["impl Unpin for SizeHintBound",1,["wiwi::iter::size_hint::SizeHintBound"]],["impl Unpin for Error",1,["wiwi::serialiser::error::Error"]],["impl Unpin for DecodeError",1,["wiwi::z85::DecodeError"]],["impl Unpin for Error",1,["wiwi::auth::error::Error"]],["impl Unpin for ClientContinuerS1",1,["wiwi::auth::flow::signin::ClientContinuerS1"]],["impl Unpin for ClientContinuerS2",1,["wiwi::auth::flow::signin::ClientContinuerS2"]],["impl Unpin for ClientContinuerS3",1,["wiwi::auth::flow::signin::ClientContinuerS3"]],["impl Unpin for ServerS2Params",1,["wiwi::auth::flow::signin::ServerS2Params"]],["impl Unpin for ServerS3Params",1,["wiwi::auth::flow::signin::ServerS3Params"]],["impl Unpin for SigninRequestS1",1,["wiwi::auth::flow::signin::SigninRequestS1"]],["impl Unpin for SigninRequestS2",1,["wiwi::auth::flow::signin::SigninRequestS2"]],["impl Unpin for SigninRequestS3",1,["wiwi::auth::flow::signin::SigninRequestS3"]],["impl Unpin for SigninResponseS1",1,["wiwi::auth::flow::signin::SigninResponseS1"]],["impl Unpin for SigninResponseS2",1,["wiwi::auth::flow::signin::SigninResponseS2"]],["impl Unpin for SigninResponseS3",1,["wiwi::auth::flow::signin::SigninResponseS3"]],["impl Unpin for SignupRequest",1,["wiwi::auth::flow::signup::SignupRequest"]],["impl Unpin for StoredUnverifiedUserData",1,["wiwi::auth::flow::signup::StoredUnverifiedUserData"]],["impl Unpin for U320",1,["wiwi::bigint::U320"]],["impl Unpin for Encoder",1,["wiwi::bitstream::Encoder"]],["impl Unpin for BitstreamEncoderChain",1,["wiwi::chainer::bitstream::BitstreamEncoderChain"]],["impl Unpin for StrBoxChain",1,["wiwi::chainer::str_box::StrBoxChain"]],["impl Unpin for StringChain",1,["wiwi::chainer::string::StringChain"]],["impl Unpin for Builder",1,["wiwi::clock_timer::builder::Builder"]],["impl Unpin for BuilderWithEnd",1,["wiwi::clock_timer::builder::BuilderWithEnd"]],["impl Unpin for BuilderWithInterval",1,["wiwi::clock_timer::builder::BuilderWithInterval"]],["impl Unpin for BuilderWithStart",1,["wiwi::clock_timer::builder::BuilderWithStart"]],["impl Unpin for ClockTimer",1,["wiwi::clock_timer::ClockTimer"]],["impl Unpin for Tick",1,["wiwi::clock_timer::Tick"]],["impl Unpin for GeneratedID",1,["wiwi::id::GeneratedID"]],["impl Unpin for IDGenerator",1,["wiwi::id::IDGenerator"]],["impl Unpin for SizeHint",1,["wiwi::iter::size_hint::SizeHint"]],["impl Unpin for Script",1,["wiwi::lsl::callback_api::script::Script"]],["impl Unpin for ScriptBuilder",1,["wiwi::lsl::callback_api::script::ScriptBuilder"]],["impl Unpin for Marker",1,["wiwi::serialiser::marker::Marker"]],["impl Unpin for SerialiseOptions",1,["wiwi::serialiser::serialise::SerialiseOptions"]],["impl Unpin for GlobalPool",1,["wiwi::string_pool::pool::global::GlobalPool"]],["impl Unpin for Board",1,["wiwi::sudoku::Board"]],["impl<'h> Unpin for StrMutChain<'h>",1,["wiwi::chainer::str_mut::StrMutChain"]],["impl<'h> Unpin for StrRefChain<'h>",1,["wiwi::chainer::str_ref::StrRefChain"]],["impl<'h> Unpin for StringMutChain<'h>",1,["wiwi::chainer::string_mut::StringMutChain"]],["impl<'h> Unpin for StringRefChain<'h>",1,["wiwi::chainer::string_ref::StringRefChain"]],["impl<'h> Unpin for SlicesWrap<'h>",1,["wiwi::string_pool::pool::SlicesWrap"]],["impl<'h> Unpin for SlicesWrapIter<'h>",1,["wiwi::string_pool::pool::SlicesWrapIter"]],["impl<'h, T> Unpin for SliceMutChain<'h, T>",1,["wiwi::chainer::slice_mut::SliceMutChain"]],["impl<'h, T> Unpin for SliceRefChain<'h, T>",1,["wiwi::chainer::slice_ref::SliceRefChain"]],["impl<'h, T> Unpin for VecMutChain<'h, T>",1,["wiwi::chainer::vec_mut::VecMutChain"]],["impl<'h, T> Unpin for VecRefChain<'h, T>",1,["wiwi::chainer::vec_ref::VecRefChain"]],["impl<'h, T, const N: usize> Unpin for ArrayMutChain<'h, T, N>",1,["wiwi::chainer::array_mut::ArrayMutChain"]],["impl<'h, T, const N: usize> Unpin for ArrayRefChain<'h, T, N>",1,["wiwi::chainer::array_ref::ArrayRefChain"]],["impl<F> Unpin for FromFn<F>
where\n F: Unpin,
",1,["wiwi::iter::from_fn::FromFn"]],["impl<I> Unpin for IterAdapter<I>
where\n I: Unpin,
",1,["wiwi::iter::adapter::IterAdapter"]],["impl<I> Unpin for RepeatPerItem<I>
where\n I: Unpin,\n <I as Iter>::Item: Unpin,
",1,["wiwi::iter::repeat_per_item::RepeatPerItem"]],["impl<I> Unpin for Rev<I>
where\n I: Unpin,
",1,["wiwi::iter::rev::Rev"]],["impl<I, F> Unpin for Map<I, F>
where\n I: Unpin,\n F: Unpin,
",1,["wiwi::iter::map::Map"]],["impl<I, T> Unpin for Peek<I, T>
where\n I: Unpin,\n T: Unpin,
",1,["wiwi::iter::peek::Peek"]],["impl<I1> Unpin for Tuple1<I1>
where\n I1: Unpin,
",1,["wiwi::iter::tuple::Tuple1"]],["impl<I1, I2> Unpin for Tuple2<I1, I2>
where\n I1: Unpin,\n I2: Unpin,
",1,["wiwi::iter::tuple::Tuple2"]],["impl<I1, I2, I3> Unpin for Tuple3<I1, I2, I3>
where\n I1: Unpin,\n I2: Unpin,\n I3: Unpin,
",1,["wiwi::iter::tuple::Tuple3"]],["impl<I1, I2, I3, I4> Unpin for Tuple4<I1, I2, I3, I4>
where\n I1: Unpin,\n I2: Unpin,\n I3: Unpin,\n I4: Unpin,
",1,["wiwi::iter::tuple::Tuple4"]],["impl<I1, I2, I3, I4, I5> Unpin for Tuple5<I1, I2, I3, I4, I5>
where\n I1: Unpin,\n I2: Unpin,\n I3: Unpin,\n I4: Unpin,\n I5: Unpin,
",1,["wiwi::iter::tuple::Tuple5"]],["impl<I1, I2, I3, I4, I5, I6> Unpin for Tuple6<I1, I2, I3, I4, I5, I6>
where\n I1: Unpin,\n I2: Unpin,\n I3: Unpin,\n I4: Unpin,\n I5: Unpin,\n I6: Unpin,
",1,["wiwi::iter::tuple::Tuple6"]],["impl<I1, I2, I3, I4, I5, I6, I7> Unpin for Tuple7<I1, I2, I3, I4, I5, I6, I7>
where\n I1: Unpin,\n I2: Unpin,\n I3: Unpin,\n I4: Unpin,\n I5: Unpin,\n I6: Unpin,\n I7: Unpin,
",1,["wiwi::iter::tuple::Tuple7"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8> Unpin for Tuple8<I1, I2, I3, I4, I5, I6, I7, I8>
where\n I1: Unpin,\n I2: Unpin,\n I3: Unpin,\n I4: Unpin,\n I5: Unpin,\n I6: Unpin,\n I7: Unpin,\n I8: Unpin,
",1,["wiwi::iter::tuple::Tuple8"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9> Unpin for Tuple9<I1, I2, I3, I4, I5, I6, I7, I8, I9>
where\n I1: Unpin,\n I2: Unpin,\n I3: Unpin,\n I4: Unpin,\n I5: Unpin,\n I6: Unpin,\n I7: Unpin,\n I8: Unpin,\n I9: Unpin,
",1,["wiwi::iter::tuple::Tuple9"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10> Unpin for Tuple10<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10>
where\n I1: Unpin,\n I2: Unpin,\n I3: Unpin,\n I4: Unpin,\n I5: Unpin,\n I6: Unpin,\n I7: Unpin,\n I8: Unpin,\n I9: Unpin,\n I10: Unpin,
",1,["wiwi::iter::tuple::Tuple10"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11> Unpin for Tuple11<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11>
where\n I1: Unpin,\n I2: Unpin,\n I3: Unpin,\n I4: Unpin,\n I5: Unpin,\n I6: Unpin,\n I7: Unpin,\n I8: Unpin,\n I9: Unpin,\n I10: Unpin,\n I11: Unpin,
",1,["wiwi::iter::tuple::Tuple11"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12> Unpin for Tuple12<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12>
where\n I1: Unpin,\n I2: Unpin,\n I3: Unpin,\n I4: Unpin,\n I5: Unpin,\n I6: Unpin,\n I7: Unpin,\n I8: Unpin,\n I9: Unpin,\n I10: Unpin,\n I11: Unpin,\n I12: Unpin,
",1,["wiwi::iter::tuple::Tuple12"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13> Unpin for Tuple13<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13>
where\n I1: Unpin,\n I2: Unpin,\n I3: Unpin,\n I4: Unpin,\n I5: Unpin,\n I6: Unpin,\n I7: Unpin,\n I8: Unpin,\n I9: Unpin,\n I10: Unpin,\n I11: Unpin,\n I12: Unpin,\n I13: Unpin,
",1,["wiwi::iter::tuple::Tuple13"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14> Unpin for Tuple14<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14>
where\n I1: Unpin,\n I2: Unpin,\n I3: Unpin,\n I4: Unpin,\n I5: Unpin,\n I6: Unpin,\n I7: Unpin,\n I8: Unpin,\n I9: Unpin,\n I10: Unpin,\n I11: Unpin,\n I12: Unpin,\n I13: Unpin,\n I14: Unpin,
",1,["wiwi::iter::tuple::Tuple14"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15> Unpin for Tuple15<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15>
where\n I1: Unpin,\n I2: Unpin,\n I3: Unpin,\n I4: Unpin,\n I5: Unpin,\n I6: Unpin,\n I7: Unpin,\n I8: Unpin,\n I9: Unpin,\n I10: Unpin,\n I11: Unpin,\n I12: Unpin,\n I13: Unpin,\n I14: Unpin,\n I15: Unpin,
",1,["wiwi::iter::tuple::Tuple15"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16> Unpin for Tuple16<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16>
where\n I1: Unpin,\n I2: Unpin,\n I3: Unpin,\n I4: Unpin,\n I5: Unpin,\n I6: Unpin,\n I7: Unpin,\n I8: Unpin,\n I9: Unpin,\n I10: Unpin,\n I11: Unpin,\n I12: Unpin,\n I13: Unpin,\n I14: Unpin,\n I15: Unpin,\n I16: Unpin,
",1,["wiwi::iter::tuple::Tuple16"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17> Unpin for Tuple17<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17>
where\n I1: Unpin,\n I2: Unpin,\n I3: Unpin,\n I4: Unpin,\n I5: Unpin,\n I6: Unpin,\n I7: Unpin,\n I8: Unpin,\n I9: Unpin,\n I10: Unpin,\n I11: Unpin,\n I12: Unpin,\n I13: Unpin,\n I14: Unpin,\n I15: Unpin,\n I16: Unpin,\n I17: Unpin,
",1,["wiwi::iter::tuple::Tuple17"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18> Unpin for Tuple18<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18>
where\n I1: Unpin,\n I2: Unpin,\n I3: Unpin,\n I4: Unpin,\n I5: Unpin,\n I6: Unpin,\n I7: Unpin,\n I8: Unpin,\n I9: Unpin,\n I10: Unpin,\n I11: Unpin,\n I12: Unpin,\n I13: Unpin,\n I14: Unpin,\n I15: Unpin,\n I16: Unpin,\n I17: Unpin,\n I18: Unpin,
",1,["wiwi::iter::tuple::Tuple18"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19> Unpin for Tuple19<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19>
where\n I1: Unpin,\n I2: Unpin,\n I3: Unpin,\n I4: Unpin,\n I5: Unpin,\n I6: Unpin,\n I7: Unpin,\n I8: Unpin,\n I9: Unpin,\n I10: Unpin,\n I11: Unpin,\n I12: Unpin,\n I13: Unpin,\n I14: Unpin,\n I15: Unpin,\n I16: Unpin,\n I17: Unpin,\n I18: Unpin,\n I19: Unpin,
",1,["wiwi::iter::tuple::Tuple19"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20> Unpin for Tuple20<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20>
where\n I1: Unpin,\n I2: Unpin,\n I3: Unpin,\n I4: Unpin,\n I5: Unpin,\n I6: Unpin,\n I7: Unpin,\n I8: Unpin,\n I9: Unpin,\n I10: Unpin,\n I11: Unpin,\n I12: Unpin,\n I13: Unpin,\n I14: Unpin,\n I15: Unpin,\n I16: Unpin,\n I17: Unpin,\n I18: Unpin,\n I19: Unpin,\n I20: Unpin,
",1,["wiwi::iter::tuple::Tuple20"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21> Unpin for Tuple21<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21>
where\n I1: Unpin,\n I2: Unpin,\n I3: Unpin,\n I4: Unpin,\n I5: Unpin,\n I6: Unpin,\n I7: Unpin,\n I8: Unpin,\n I9: Unpin,\n I10: Unpin,\n I11: Unpin,\n I12: Unpin,\n I13: Unpin,\n I14: Unpin,\n I15: Unpin,\n I16: Unpin,\n I17: Unpin,\n I18: Unpin,\n I19: Unpin,\n I20: Unpin,\n I21: Unpin,
",1,["wiwi::iter::tuple::Tuple21"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22> Unpin for Tuple22<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22>
where\n I1: Unpin,\n I2: Unpin,\n I3: Unpin,\n I4: Unpin,\n I5: Unpin,\n I6: Unpin,\n I7: Unpin,\n I8: Unpin,\n I9: Unpin,\n I10: Unpin,\n I11: Unpin,\n I12: Unpin,\n I13: Unpin,\n I14: Unpin,\n I15: Unpin,\n I16: Unpin,\n I17: Unpin,\n I18: Unpin,\n I19: Unpin,\n I20: Unpin,\n I21: Unpin,\n I22: Unpin,
",1,["wiwi::iter::tuple::Tuple22"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23> Unpin for Tuple23<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23>
where\n I1: Unpin,\n I2: Unpin,\n I3: Unpin,\n I4: Unpin,\n I5: Unpin,\n I6: Unpin,\n I7: Unpin,\n I8: Unpin,\n I9: Unpin,\n I10: Unpin,\n I11: Unpin,\n I12: Unpin,\n I13: Unpin,\n I14: Unpin,\n I15: Unpin,\n I16: Unpin,\n I17: Unpin,\n I18: Unpin,\n I19: Unpin,\n I20: Unpin,\n I21: Unpin,\n I22: Unpin,\n I23: Unpin,
",1,["wiwi::iter::tuple::Tuple23"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24> Unpin for Tuple24<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24>
where\n I1: Unpin,\n I2: Unpin,\n I3: Unpin,\n I4: Unpin,\n I5: Unpin,\n I6: Unpin,\n I7: Unpin,\n I8: Unpin,\n I9: Unpin,\n I10: Unpin,\n I11: Unpin,\n I12: Unpin,\n I13: Unpin,\n I14: Unpin,\n I15: Unpin,\n I16: Unpin,\n I17: Unpin,\n I18: Unpin,\n I19: Unpin,\n I20: Unpin,\n I21: Unpin,\n I22: Unpin,\n I23: Unpin,\n I24: Unpin,
",1,["wiwi::iter::tuple::Tuple24"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24, I25> Unpin for Tuple25<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24, I25>
where\n I1: Unpin,\n I2: Unpin,\n I3: Unpin,\n I4: Unpin,\n I5: Unpin,\n I6: Unpin,\n I7: Unpin,\n I8: Unpin,\n I9: Unpin,\n I10: Unpin,\n I11: Unpin,\n I12: Unpin,\n I13: Unpin,\n I14: Unpin,\n I15: Unpin,\n I16: Unpin,\n I17: Unpin,\n I18: Unpin,\n I19: Unpin,\n I20: Unpin,\n I21: Unpin,\n I22: Unpin,\n I23: Unpin,\n I24: Unpin,\n I25: Unpin,
",1,["wiwi::iter::tuple::Tuple25"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24, I25, I26> Unpin for Tuple26<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24, I25, I26>
where\n I1: Unpin,\n I2: Unpin,\n I3: Unpin,\n I4: Unpin,\n I5: Unpin,\n I6: Unpin,\n I7: Unpin,\n I8: Unpin,\n I9: Unpin,\n I10: Unpin,\n I11: Unpin,\n I12: Unpin,\n I13: Unpin,\n I14: Unpin,\n I15: Unpin,\n I16: Unpin,\n I17: Unpin,\n I18: Unpin,\n I19: Unpin,\n I20: Unpin,\n I21: Unpin,\n I22: Unpin,\n I23: Unpin,\n I24: Unpin,\n I25: Unpin,\n I26: Unpin,
",1,["wiwi::iter::tuple::Tuple26"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24, I25, I26, I27> Unpin for Tuple27<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24, I25, I26, I27>
where\n I1: Unpin,\n I2: Unpin,\n I3: Unpin,\n I4: Unpin,\n I5: Unpin,\n I6: Unpin,\n I7: Unpin,\n I8: Unpin,\n I9: Unpin,\n I10: Unpin,\n I11: Unpin,\n I12: Unpin,\n I13: Unpin,\n I14: Unpin,\n I15: Unpin,\n I16: Unpin,\n I17: Unpin,\n I18: Unpin,\n I19: Unpin,\n I20: Unpin,\n I21: Unpin,\n I22: Unpin,\n I23: Unpin,\n I24: Unpin,\n I25: Unpin,\n I26: Unpin,\n I27: Unpin,
",1,["wiwi::iter::tuple::Tuple27"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24, I25, I26, I27, I28> Unpin for Tuple28<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24, I25, I26, I27, I28>
where\n I1: Unpin,\n I2: Unpin,\n I3: Unpin,\n I4: Unpin,\n I5: Unpin,\n I6: Unpin,\n I7: Unpin,\n I8: Unpin,\n I9: Unpin,\n I10: Unpin,\n I11: Unpin,\n I12: Unpin,\n I13: Unpin,\n I14: Unpin,\n I15: Unpin,\n I16: Unpin,\n I17: Unpin,\n I18: Unpin,\n I19: Unpin,\n I20: Unpin,\n I21: Unpin,\n I22: Unpin,\n I23: Unpin,\n I24: Unpin,\n I25: Unpin,\n I26: Unpin,\n I27: Unpin,\n I28: Unpin,
",1,["wiwi::iter::tuple::Tuple28"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24, I25, I26, I27, I28, I29> Unpin for Tuple29<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24, I25, I26, I27, I28, I29>
where\n I1: Unpin,\n I2: Unpin,\n I3: Unpin,\n I4: Unpin,\n I5: Unpin,\n I6: Unpin,\n I7: Unpin,\n I8: Unpin,\n I9: Unpin,\n I10: Unpin,\n I11: Unpin,\n I12: Unpin,\n I13: Unpin,\n I14: Unpin,\n I15: Unpin,\n I16: Unpin,\n I17: Unpin,\n I18: Unpin,\n I19: Unpin,\n I20: Unpin,\n I21: Unpin,\n I22: Unpin,\n I23: Unpin,\n I24: Unpin,\n I25: Unpin,\n I26: Unpin,\n I27: Unpin,\n I28: Unpin,\n I29: Unpin,
",1,["wiwi::iter::tuple::Tuple29"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24, I25, I26, I27, I28, I29, I30> Unpin for Tuple30<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24, I25, I26, I27, I28, I29, I30>
where\n I1: Unpin,\n I2: Unpin,\n I3: Unpin,\n I4: Unpin,\n I5: Unpin,\n I6: Unpin,\n I7: Unpin,\n I8: Unpin,\n I9: Unpin,\n I10: Unpin,\n I11: Unpin,\n I12: Unpin,\n I13: Unpin,\n I14: Unpin,\n I15: Unpin,\n I16: Unpin,\n I17: Unpin,\n I18: Unpin,\n I19: Unpin,\n I20: Unpin,\n I21: Unpin,\n I22: Unpin,\n I23: Unpin,\n I24: Unpin,\n I25: Unpin,\n I26: Unpin,\n I27: Unpin,\n I28: Unpin,\n I29: Unpin,\n I30: Unpin,
",1,["wiwi::iter::tuple::Tuple30"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24, I25, I26, I27, I28, I29, I30, I31> Unpin for Tuple31<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24, I25, I26, I27, I28, I29, I30, I31>
where\n I1: Unpin,\n I2: Unpin,\n I3: Unpin,\n I4: Unpin,\n I5: Unpin,\n I6: Unpin,\n I7: Unpin,\n I8: Unpin,\n I9: Unpin,\n I10: Unpin,\n I11: Unpin,\n I12: Unpin,\n I13: Unpin,\n I14: Unpin,\n I15: Unpin,\n I16: Unpin,\n I17: Unpin,\n I18: Unpin,\n I19: Unpin,\n I20: Unpin,\n I21: Unpin,\n I22: Unpin,\n I23: Unpin,\n I24: Unpin,\n I25: Unpin,\n I26: Unpin,\n I27: Unpin,\n I28: Unpin,\n I29: Unpin,\n I30: Unpin,\n I31: Unpin,
",1,["wiwi::iter::tuple::Tuple31"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24, I25, I26, I27, I28, I29, I30, I31, I32> Unpin for Tuple32<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24, I25, I26, I27, I28, I29, I30, I31, I32>
where\n I1: Unpin,\n I2: Unpin,\n I3: Unpin,\n I4: Unpin,\n I5: Unpin,\n I6: Unpin,\n I7: Unpin,\n I8: Unpin,\n I9: Unpin,\n I10: Unpin,\n I11: Unpin,\n I12: Unpin,\n I13: Unpin,\n I14: Unpin,\n I15: Unpin,\n I16: Unpin,\n I17: Unpin,\n I18: Unpin,\n I19: Unpin,\n I20: Unpin,\n I21: Unpin,\n I22: Unpin,\n I23: Unpin,\n I24: Unpin,\n I25: Unpin,\n I26: Unpin,\n I27: Unpin,\n I28: Unpin,\n I29: Unpin,\n I30: Unpin,\n I31: Unpin,\n I32: Unpin,
",1,["wiwi::iter::tuple::Tuple32"]],["impl<K, V> Unpin for BTreeMapChain<K, V>",1,["wiwi::chainer::btree_map::BTreeMapChain"]],["impl<K, V, S> Unpin for HashMapChain<K, V, S>
where\n S: Unpin,\n K: Unpin,\n V: Unpin,
",1,["wiwi::chainer::hash_map::HashMapChain"]],["impl<P> Unpin for String<P>
where\n <P as Pool>::Raw: Unpin,\n P: Unpin,
",1,["wiwi::string_pool::string::String"]],["impl<T> Unpin for BTreeSetChain<T>",1,["wiwi::chainer::btree_set::BTreeSetChain"]],["impl<T> Unpin for BinaryHeapChain<T>
where\n T: Unpin,
",1,["wiwi::chainer::binary_heap::BinaryHeapChain"]],["impl<T> Unpin for LinkedListChain<T>",1,["wiwi::chainer::linked_list::LinkedListChain"]],["impl<T> Unpin for SliceBoxChain<T>",1,["wiwi::chainer::slice_box::SliceBoxChain"]],["impl<T> Unpin for VecChain<T>
where\n T: Unpin,
",1,["wiwi::chainer::vec::VecChain"]],["impl<T> Unpin for VecDequeChain<T>
where\n T: Unpin,
",1,["wiwi::chainer::vec_deque::VecDequeChain"]],["impl<T> Unpin for Empty<T>
where\n T: Unpin,
",1,["wiwi::iter::empty::Empty"]],["impl<T, F> Unpin for LazyWrapState<T, F>
where\n T: Unpin,\n F: Unpin,
",1,["wiwi::lazy_wrap::LazyWrapState"]],["impl<T, F> Unpin for LazyWrap<T, F>
where\n T: Unpin,\n F: Unpin,
"],["impl<T, S> Unpin for HashSetChain<T, S>
where\n S: Unpin,\n T: Unpin,
",1,["wiwi::chainer::hash_set::HashSetChain"]],["impl<T, const N: usize> Unpin for ArrayChain<T, N>
where\n T: Unpin,
",1,["wiwi::chainer::array::ArrayChain"]]] };if (window.register_implementors) {window.register_implementors(implementors);} else {window.pending_implementors = implementors;}})() \ No newline at end of file diff --git a/trait.impl/core/panic/unwind_safe/trait.RefUnwindSafe.js b/trait.impl/core/panic/unwind_safe/trait.RefUnwindSafe.js index 3743a5f15..c46a832ea 100644 --- a/trait.impl/core/panic/unwind_safe/trait.RefUnwindSafe.js +++ b/trait.impl/core/panic/unwind_safe/trait.RefUnwindSafe.js @@ -1,3 +1,3 @@ (function() {var implementors = { -"wiwi":[["impl !RefUnwindSafe for IDGenerator",1,["wiwi::id::IDGenerator"]],["impl !RefUnwindSafe for Script",1,["wiwi::lsl::callback_api::script::Script"]],["impl !RefUnwindSafe for ScriptBuilder",1,["wiwi::lsl::callback_api::script::ScriptBuilder"]],["impl RefUnwindSafe for DecodeError",1,["wiwi::hex::DecodeError"]],["impl RefUnwindSafe for SizeHintBound",1,["wiwi::iter::size_hint::SizeHintBound"]],["impl RefUnwindSafe for Error",1,["wiwi::serialiser::error::Error"]],["impl RefUnwindSafe for DecodeError",1,["wiwi::z85::DecodeError"]],["impl RefUnwindSafe for Error",1,["wiwi::auth::error::Error"]],["impl RefUnwindSafe for ClientContinuerS1",1,["wiwi::auth::flow::signin::ClientContinuerS1"]],["impl RefUnwindSafe for ClientContinuerS2",1,["wiwi::auth::flow::signin::ClientContinuerS2"]],["impl RefUnwindSafe for ClientContinuerS3",1,["wiwi::auth::flow::signin::ClientContinuerS3"]],["impl RefUnwindSafe for ServerS2Params",1,["wiwi::auth::flow::signin::ServerS2Params"]],["impl RefUnwindSafe for ServerS3Params",1,["wiwi::auth::flow::signin::ServerS3Params"]],["impl RefUnwindSafe for SigninRequestS1",1,["wiwi::auth::flow::signin::SigninRequestS1"]],["impl RefUnwindSafe for SigninRequestS2",1,["wiwi::auth::flow::signin::SigninRequestS2"]],["impl RefUnwindSafe for SigninRequestS3",1,["wiwi::auth::flow::signin::SigninRequestS3"]],["impl RefUnwindSafe for SigninResponseS1",1,["wiwi::auth::flow::signin::SigninResponseS1"]],["impl RefUnwindSafe for SigninResponseS2",1,["wiwi::auth::flow::signin::SigninResponseS2"]],["impl RefUnwindSafe for SigninResponseS3",1,["wiwi::auth::flow::signin::SigninResponseS3"]],["impl RefUnwindSafe for SignupRequest",1,["wiwi::auth::flow::signup::SignupRequest"]],["impl RefUnwindSafe for StoredUnverifiedUserData",1,["wiwi::auth::flow::signup::StoredUnverifiedUserData"]],["impl RefUnwindSafe for U320",1,["wiwi::bigint::U320"]],["impl RefUnwindSafe for Encoder",1,["wiwi::bitstream::Encoder"]],["impl RefUnwindSafe for BitstreamEncoderChain",1,["wiwi::chainer::bitstream::BitstreamEncoderChain"]],["impl RefUnwindSafe for StrBoxChain",1,["wiwi::chainer::str_box::StrBoxChain"]],["impl RefUnwindSafe for StringChain",1,["wiwi::chainer::string::StringChain"]],["impl RefUnwindSafe for Builder",1,["wiwi::clock_timer::builder::Builder"]],["impl RefUnwindSafe for BuilderWithEnd",1,["wiwi::clock_timer::builder::BuilderWithEnd"]],["impl RefUnwindSafe for BuilderWithInterval",1,["wiwi::clock_timer::builder::BuilderWithInterval"]],["impl RefUnwindSafe for BuilderWithStart",1,["wiwi::clock_timer::builder::BuilderWithStart"]],["impl RefUnwindSafe for ClockTimer",1,["wiwi::clock_timer::ClockTimer"]],["impl RefUnwindSafe for Tick",1,["wiwi::clock_timer::Tick"]],["impl RefUnwindSafe for GeneratedID",1,["wiwi::id::GeneratedID"]],["impl RefUnwindSafe for SizeHint",1,["wiwi::iter::size_hint::SizeHint"]],["impl RefUnwindSafe for SerialiseOptions",1,["wiwi::serialiser::serialise::SerialiseOptions"]],["impl RefUnwindSafe for GlobalPool",1,["wiwi::string_pool::pool::global::GlobalPool"]],["impl RefUnwindSafe for Board",1,["wiwi::sudoku::Board"]],["impl<'h> RefUnwindSafe for StrMutChain<'h>",1,["wiwi::chainer::str_mut::StrMutChain"]],["impl<'h> RefUnwindSafe for StrRefChain<'h>",1,["wiwi::chainer::str_ref::StrRefChain"]],["impl<'h> RefUnwindSafe for StringMutChain<'h>",1,["wiwi::chainer::string_mut::StringMutChain"]],["impl<'h> RefUnwindSafe for StringRefChain<'h>",1,["wiwi::chainer::string_ref::StringRefChain"]],["impl<'h> RefUnwindSafe for SlicesWrap<'h>",1,["wiwi::string_pool::pool::SlicesWrap"]],["impl<'h> RefUnwindSafe for SlicesWrapIter<'h>",1,["wiwi::string_pool::pool::SlicesWrapIter"]],["impl<'h, T> RefUnwindSafe for SliceMutChain<'h, T>
where\n T: RefUnwindSafe,
",1,["wiwi::chainer::slice_mut::SliceMutChain"]],["impl<'h, T> RefUnwindSafe for SliceRefChain<'h, T>
where\n T: RefUnwindSafe,
",1,["wiwi::chainer::slice_ref::SliceRefChain"]],["impl<'h, T> RefUnwindSafe for VecMutChain<'h, T>
where\n T: RefUnwindSafe,
",1,["wiwi::chainer::vec_mut::VecMutChain"]],["impl<'h, T> RefUnwindSafe for VecRefChain<'h, T>
where\n T: RefUnwindSafe,
",1,["wiwi::chainer::vec_ref::VecRefChain"]],["impl<'h, T, const N: usize> RefUnwindSafe for ArrayMutChain<'h, T, N>
where\n T: RefUnwindSafe,
",1,["wiwi::chainer::array_mut::ArrayMutChain"]],["impl<'h, T, const N: usize> RefUnwindSafe for ArrayRefChain<'h, T, N>
where\n T: RefUnwindSafe,
",1,["wiwi::chainer::array_ref::ArrayRefChain"]],["impl<F> RefUnwindSafe for FromFn<F>
where\n F: RefUnwindSafe,
",1,["wiwi::iter::from_fn::FromFn"]],["impl<I> RefUnwindSafe for IterAdapter<I>
where\n I: RefUnwindSafe,
",1,["wiwi::iter::adapter::IterAdapter"]],["impl<I> RefUnwindSafe for RepeatPerItem<I>
where\n I: RefUnwindSafe,\n <I as Iter>::Item: RefUnwindSafe,
",1,["wiwi::iter::repeat_per_item::RepeatPerItem"]],["impl<I, F> RefUnwindSafe for Map<I, F>
where\n I: RefUnwindSafe,\n F: RefUnwindSafe,
",1,["wiwi::iter::map::Map"]],["impl<I, T> RefUnwindSafe for Peek<I, T>
where\n I: RefUnwindSafe,\n T: RefUnwindSafe,
",1,["wiwi::iter::peek::Peek"]],["impl<I1> RefUnwindSafe for Tuple1<I1>
where\n I1: RefUnwindSafe,
",1,["wiwi::iter::tuple::Tuple1"]],["impl<I1, I2> RefUnwindSafe for Tuple2<I1, I2>
where\n I1: RefUnwindSafe,\n I2: RefUnwindSafe,
",1,["wiwi::iter::tuple::Tuple2"]],["impl<I1, I2, I3> RefUnwindSafe for Tuple3<I1, I2, I3>
where\n I1: RefUnwindSafe,\n I2: RefUnwindSafe,\n I3: RefUnwindSafe,
",1,["wiwi::iter::tuple::Tuple3"]],["impl<I1, I2, I3, I4> RefUnwindSafe for Tuple4<I1, I2, I3, I4>
where\n I1: RefUnwindSafe,\n I2: RefUnwindSafe,\n I3: RefUnwindSafe,\n I4: RefUnwindSafe,
",1,["wiwi::iter::tuple::Tuple4"]],["impl<I1, I2, I3, I4, I5> RefUnwindSafe for Tuple5<I1, I2, I3, I4, I5>
where\n I1: RefUnwindSafe,\n I2: RefUnwindSafe,\n I3: RefUnwindSafe,\n I4: RefUnwindSafe,\n I5: RefUnwindSafe,
",1,["wiwi::iter::tuple::Tuple5"]],["impl<I1, I2, I3, I4, I5, I6> RefUnwindSafe for Tuple6<I1, I2, I3, I4, I5, I6>
where\n I1: RefUnwindSafe,\n I2: RefUnwindSafe,\n I3: RefUnwindSafe,\n I4: RefUnwindSafe,\n I5: RefUnwindSafe,\n I6: RefUnwindSafe,
",1,["wiwi::iter::tuple::Tuple6"]],["impl<I1, I2, I3, I4, I5, I6, I7> RefUnwindSafe for Tuple7<I1, I2, I3, I4, I5, I6, I7>
where\n I1: RefUnwindSafe,\n I2: RefUnwindSafe,\n I3: RefUnwindSafe,\n I4: RefUnwindSafe,\n I5: RefUnwindSafe,\n I6: RefUnwindSafe,\n I7: RefUnwindSafe,
",1,["wiwi::iter::tuple::Tuple7"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8> RefUnwindSafe for Tuple8<I1, I2, I3, I4, I5, I6, I7, I8>
where\n I1: RefUnwindSafe,\n I2: RefUnwindSafe,\n I3: RefUnwindSafe,\n I4: RefUnwindSafe,\n I5: RefUnwindSafe,\n I6: RefUnwindSafe,\n I7: RefUnwindSafe,\n I8: RefUnwindSafe,
",1,["wiwi::iter::tuple::Tuple8"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9> RefUnwindSafe for Tuple9<I1, I2, I3, I4, I5, I6, I7, I8, I9>
where\n I1: RefUnwindSafe,\n I2: RefUnwindSafe,\n I3: RefUnwindSafe,\n I4: RefUnwindSafe,\n I5: RefUnwindSafe,\n I6: RefUnwindSafe,\n I7: RefUnwindSafe,\n I8: RefUnwindSafe,\n I9: RefUnwindSafe,
",1,["wiwi::iter::tuple::Tuple9"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10> RefUnwindSafe for Tuple10<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10>
where\n I1: RefUnwindSafe,\n I2: RefUnwindSafe,\n I3: RefUnwindSafe,\n I4: RefUnwindSafe,\n I5: RefUnwindSafe,\n I6: RefUnwindSafe,\n I7: RefUnwindSafe,\n I8: RefUnwindSafe,\n I9: RefUnwindSafe,\n I10: RefUnwindSafe,
",1,["wiwi::iter::tuple::Tuple10"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11> RefUnwindSafe for Tuple11<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11>
where\n I1: RefUnwindSafe,\n I2: RefUnwindSafe,\n I3: RefUnwindSafe,\n I4: RefUnwindSafe,\n I5: RefUnwindSafe,\n I6: RefUnwindSafe,\n I7: RefUnwindSafe,\n I8: RefUnwindSafe,\n I9: RefUnwindSafe,\n I10: RefUnwindSafe,\n I11: RefUnwindSafe,
",1,["wiwi::iter::tuple::Tuple11"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12> RefUnwindSafe for Tuple12<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12>
where\n I1: RefUnwindSafe,\n I2: RefUnwindSafe,\n I3: RefUnwindSafe,\n I4: RefUnwindSafe,\n I5: RefUnwindSafe,\n I6: RefUnwindSafe,\n I7: RefUnwindSafe,\n I8: RefUnwindSafe,\n I9: RefUnwindSafe,\n I10: RefUnwindSafe,\n I11: RefUnwindSafe,\n I12: RefUnwindSafe,
",1,["wiwi::iter::tuple::Tuple12"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13> RefUnwindSafe for Tuple13<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13>
where\n I1: RefUnwindSafe,\n I2: RefUnwindSafe,\n I3: RefUnwindSafe,\n I4: RefUnwindSafe,\n I5: RefUnwindSafe,\n I6: RefUnwindSafe,\n I7: RefUnwindSafe,\n I8: RefUnwindSafe,\n I9: RefUnwindSafe,\n I10: RefUnwindSafe,\n I11: RefUnwindSafe,\n I12: RefUnwindSafe,\n I13: RefUnwindSafe,
",1,["wiwi::iter::tuple::Tuple13"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14> RefUnwindSafe for Tuple14<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14>
where\n I1: RefUnwindSafe,\n I2: RefUnwindSafe,\n I3: RefUnwindSafe,\n I4: RefUnwindSafe,\n I5: RefUnwindSafe,\n I6: RefUnwindSafe,\n I7: RefUnwindSafe,\n I8: RefUnwindSafe,\n I9: RefUnwindSafe,\n I10: RefUnwindSafe,\n I11: RefUnwindSafe,\n I12: RefUnwindSafe,\n I13: RefUnwindSafe,\n I14: RefUnwindSafe,
",1,["wiwi::iter::tuple::Tuple14"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15> RefUnwindSafe for Tuple15<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15>
where\n I1: RefUnwindSafe,\n I2: RefUnwindSafe,\n I3: RefUnwindSafe,\n I4: RefUnwindSafe,\n I5: RefUnwindSafe,\n I6: RefUnwindSafe,\n I7: RefUnwindSafe,\n I8: RefUnwindSafe,\n I9: RefUnwindSafe,\n I10: RefUnwindSafe,\n I11: RefUnwindSafe,\n I12: RefUnwindSafe,\n I13: RefUnwindSafe,\n I14: RefUnwindSafe,\n I15: RefUnwindSafe,
",1,["wiwi::iter::tuple::Tuple15"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16> RefUnwindSafe for Tuple16<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16>
where\n I1: RefUnwindSafe,\n I2: RefUnwindSafe,\n I3: RefUnwindSafe,\n I4: RefUnwindSafe,\n I5: RefUnwindSafe,\n I6: RefUnwindSafe,\n I7: RefUnwindSafe,\n I8: RefUnwindSafe,\n I9: RefUnwindSafe,\n I10: RefUnwindSafe,\n I11: RefUnwindSafe,\n I12: RefUnwindSafe,\n I13: RefUnwindSafe,\n I14: RefUnwindSafe,\n I15: RefUnwindSafe,\n I16: RefUnwindSafe,
",1,["wiwi::iter::tuple::Tuple16"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17> RefUnwindSafe for Tuple17<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17>
where\n I1: RefUnwindSafe,\n I2: RefUnwindSafe,\n I3: RefUnwindSafe,\n I4: RefUnwindSafe,\n I5: RefUnwindSafe,\n I6: RefUnwindSafe,\n I7: RefUnwindSafe,\n I8: RefUnwindSafe,\n I9: RefUnwindSafe,\n I10: RefUnwindSafe,\n I11: RefUnwindSafe,\n I12: RefUnwindSafe,\n I13: RefUnwindSafe,\n I14: RefUnwindSafe,\n I15: RefUnwindSafe,\n I16: RefUnwindSafe,\n I17: RefUnwindSafe,
",1,["wiwi::iter::tuple::Tuple17"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18> RefUnwindSafe for Tuple18<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18>
where\n I1: RefUnwindSafe,\n I2: RefUnwindSafe,\n I3: RefUnwindSafe,\n I4: RefUnwindSafe,\n I5: RefUnwindSafe,\n I6: RefUnwindSafe,\n I7: RefUnwindSafe,\n I8: RefUnwindSafe,\n I9: RefUnwindSafe,\n I10: RefUnwindSafe,\n I11: RefUnwindSafe,\n I12: RefUnwindSafe,\n I13: RefUnwindSafe,\n I14: RefUnwindSafe,\n I15: RefUnwindSafe,\n I16: RefUnwindSafe,\n I17: RefUnwindSafe,\n I18: RefUnwindSafe,
",1,["wiwi::iter::tuple::Tuple18"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19> RefUnwindSafe for Tuple19<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19>
where\n I1: RefUnwindSafe,\n I2: RefUnwindSafe,\n I3: RefUnwindSafe,\n I4: RefUnwindSafe,\n I5: RefUnwindSafe,\n I6: RefUnwindSafe,\n I7: RefUnwindSafe,\n I8: RefUnwindSafe,\n I9: RefUnwindSafe,\n I10: RefUnwindSafe,\n I11: RefUnwindSafe,\n I12: RefUnwindSafe,\n I13: RefUnwindSafe,\n I14: RefUnwindSafe,\n I15: RefUnwindSafe,\n I16: RefUnwindSafe,\n I17: RefUnwindSafe,\n I18: RefUnwindSafe,\n I19: RefUnwindSafe,
",1,["wiwi::iter::tuple::Tuple19"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20> RefUnwindSafe for Tuple20<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20>
where\n I1: RefUnwindSafe,\n I2: RefUnwindSafe,\n I3: RefUnwindSafe,\n I4: RefUnwindSafe,\n I5: RefUnwindSafe,\n I6: RefUnwindSafe,\n I7: RefUnwindSafe,\n I8: RefUnwindSafe,\n I9: RefUnwindSafe,\n I10: RefUnwindSafe,\n I11: RefUnwindSafe,\n I12: RefUnwindSafe,\n I13: RefUnwindSafe,\n I14: RefUnwindSafe,\n I15: RefUnwindSafe,\n I16: RefUnwindSafe,\n I17: RefUnwindSafe,\n I18: RefUnwindSafe,\n I19: RefUnwindSafe,\n I20: RefUnwindSafe,
",1,["wiwi::iter::tuple::Tuple20"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21> RefUnwindSafe for Tuple21<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21>
where\n I1: RefUnwindSafe,\n I2: RefUnwindSafe,\n I3: RefUnwindSafe,\n I4: RefUnwindSafe,\n I5: RefUnwindSafe,\n I6: RefUnwindSafe,\n I7: RefUnwindSafe,\n I8: RefUnwindSafe,\n I9: RefUnwindSafe,\n I10: RefUnwindSafe,\n I11: RefUnwindSafe,\n I12: RefUnwindSafe,\n I13: RefUnwindSafe,\n I14: RefUnwindSafe,\n I15: RefUnwindSafe,\n I16: RefUnwindSafe,\n I17: RefUnwindSafe,\n I18: RefUnwindSafe,\n I19: RefUnwindSafe,\n I20: RefUnwindSafe,\n I21: RefUnwindSafe,
",1,["wiwi::iter::tuple::Tuple21"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22> RefUnwindSafe for Tuple22<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22>
where\n I1: RefUnwindSafe,\n I2: RefUnwindSafe,\n I3: RefUnwindSafe,\n I4: RefUnwindSafe,\n I5: RefUnwindSafe,\n I6: RefUnwindSafe,\n I7: RefUnwindSafe,\n I8: RefUnwindSafe,\n I9: RefUnwindSafe,\n I10: RefUnwindSafe,\n I11: RefUnwindSafe,\n I12: RefUnwindSafe,\n I13: RefUnwindSafe,\n I14: RefUnwindSafe,\n I15: RefUnwindSafe,\n I16: RefUnwindSafe,\n I17: RefUnwindSafe,\n I18: RefUnwindSafe,\n I19: RefUnwindSafe,\n I20: RefUnwindSafe,\n I21: RefUnwindSafe,\n I22: RefUnwindSafe,
",1,["wiwi::iter::tuple::Tuple22"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23> RefUnwindSafe for Tuple23<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23>
where\n I1: RefUnwindSafe,\n I2: RefUnwindSafe,\n I3: RefUnwindSafe,\n I4: RefUnwindSafe,\n I5: RefUnwindSafe,\n I6: RefUnwindSafe,\n I7: RefUnwindSafe,\n I8: RefUnwindSafe,\n I9: RefUnwindSafe,\n I10: RefUnwindSafe,\n I11: RefUnwindSafe,\n I12: RefUnwindSafe,\n I13: RefUnwindSafe,\n I14: RefUnwindSafe,\n I15: RefUnwindSafe,\n I16: RefUnwindSafe,\n I17: RefUnwindSafe,\n I18: RefUnwindSafe,\n I19: RefUnwindSafe,\n I20: RefUnwindSafe,\n I21: RefUnwindSafe,\n I22: RefUnwindSafe,\n I23: RefUnwindSafe,
",1,["wiwi::iter::tuple::Tuple23"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24> RefUnwindSafe for Tuple24<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24>
where\n I1: RefUnwindSafe,\n I2: RefUnwindSafe,\n I3: RefUnwindSafe,\n I4: RefUnwindSafe,\n I5: RefUnwindSafe,\n I6: RefUnwindSafe,\n I7: RefUnwindSafe,\n I8: RefUnwindSafe,\n I9: RefUnwindSafe,\n I10: RefUnwindSafe,\n I11: RefUnwindSafe,\n I12: RefUnwindSafe,\n I13: RefUnwindSafe,\n I14: RefUnwindSafe,\n I15: RefUnwindSafe,\n I16: RefUnwindSafe,\n I17: RefUnwindSafe,\n I18: RefUnwindSafe,\n I19: RefUnwindSafe,\n I20: RefUnwindSafe,\n I21: RefUnwindSafe,\n I22: RefUnwindSafe,\n I23: RefUnwindSafe,\n I24: RefUnwindSafe,
",1,["wiwi::iter::tuple::Tuple24"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24, I25> RefUnwindSafe for Tuple25<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24, I25>
where\n I1: RefUnwindSafe,\n I2: RefUnwindSafe,\n I3: RefUnwindSafe,\n I4: RefUnwindSafe,\n I5: RefUnwindSafe,\n I6: RefUnwindSafe,\n I7: RefUnwindSafe,\n I8: RefUnwindSafe,\n I9: RefUnwindSafe,\n I10: RefUnwindSafe,\n I11: RefUnwindSafe,\n I12: RefUnwindSafe,\n I13: RefUnwindSafe,\n I14: RefUnwindSafe,\n I15: RefUnwindSafe,\n I16: RefUnwindSafe,\n I17: RefUnwindSafe,\n I18: RefUnwindSafe,\n I19: RefUnwindSafe,\n I20: RefUnwindSafe,\n I21: RefUnwindSafe,\n I22: RefUnwindSafe,\n I23: RefUnwindSafe,\n I24: RefUnwindSafe,\n I25: RefUnwindSafe,
",1,["wiwi::iter::tuple::Tuple25"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24, I25, I26> RefUnwindSafe for Tuple26<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24, I25, I26>
where\n I1: RefUnwindSafe,\n I2: RefUnwindSafe,\n I3: RefUnwindSafe,\n I4: RefUnwindSafe,\n I5: RefUnwindSafe,\n I6: RefUnwindSafe,\n I7: RefUnwindSafe,\n I8: RefUnwindSafe,\n I9: RefUnwindSafe,\n I10: RefUnwindSafe,\n I11: RefUnwindSafe,\n I12: RefUnwindSafe,\n I13: RefUnwindSafe,\n I14: RefUnwindSafe,\n I15: RefUnwindSafe,\n I16: RefUnwindSafe,\n I17: RefUnwindSafe,\n I18: RefUnwindSafe,\n I19: RefUnwindSafe,\n I20: RefUnwindSafe,\n I21: RefUnwindSafe,\n I22: RefUnwindSafe,\n I23: RefUnwindSafe,\n I24: RefUnwindSafe,\n I25: RefUnwindSafe,\n I26: RefUnwindSafe,
",1,["wiwi::iter::tuple::Tuple26"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24, I25, I26, I27> RefUnwindSafe for Tuple27<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24, I25, I26, I27>
where\n I1: RefUnwindSafe,\n I2: RefUnwindSafe,\n I3: RefUnwindSafe,\n I4: RefUnwindSafe,\n I5: RefUnwindSafe,\n I6: RefUnwindSafe,\n I7: RefUnwindSafe,\n I8: RefUnwindSafe,\n I9: RefUnwindSafe,\n I10: RefUnwindSafe,\n I11: RefUnwindSafe,\n I12: RefUnwindSafe,\n I13: RefUnwindSafe,\n I14: RefUnwindSafe,\n I15: RefUnwindSafe,\n I16: RefUnwindSafe,\n I17: RefUnwindSafe,\n I18: RefUnwindSafe,\n I19: RefUnwindSafe,\n I20: RefUnwindSafe,\n I21: RefUnwindSafe,\n I22: RefUnwindSafe,\n I23: RefUnwindSafe,\n I24: RefUnwindSafe,\n I25: RefUnwindSafe,\n I26: RefUnwindSafe,\n I27: RefUnwindSafe,
",1,["wiwi::iter::tuple::Tuple27"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24, I25, I26, I27, I28> RefUnwindSafe for Tuple28<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24, I25, I26, I27, I28>
where\n I1: RefUnwindSafe,\n I2: RefUnwindSafe,\n I3: RefUnwindSafe,\n I4: RefUnwindSafe,\n I5: RefUnwindSafe,\n I6: RefUnwindSafe,\n I7: RefUnwindSafe,\n I8: RefUnwindSafe,\n I9: RefUnwindSafe,\n I10: RefUnwindSafe,\n I11: RefUnwindSafe,\n I12: RefUnwindSafe,\n I13: RefUnwindSafe,\n I14: RefUnwindSafe,\n I15: RefUnwindSafe,\n I16: RefUnwindSafe,\n I17: RefUnwindSafe,\n I18: RefUnwindSafe,\n I19: RefUnwindSafe,\n I20: RefUnwindSafe,\n I21: RefUnwindSafe,\n I22: RefUnwindSafe,\n I23: RefUnwindSafe,\n I24: RefUnwindSafe,\n I25: RefUnwindSafe,\n I26: RefUnwindSafe,\n I27: RefUnwindSafe,\n I28: RefUnwindSafe,
",1,["wiwi::iter::tuple::Tuple28"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24, I25, I26, I27, I28, I29> RefUnwindSafe for Tuple29<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24, I25, I26, I27, I28, I29>
where\n I1: RefUnwindSafe,\n I2: RefUnwindSafe,\n I3: RefUnwindSafe,\n I4: RefUnwindSafe,\n I5: RefUnwindSafe,\n I6: RefUnwindSafe,\n I7: RefUnwindSafe,\n I8: RefUnwindSafe,\n I9: RefUnwindSafe,\n I10: RefUnwindSafe,\n I11: RefUnwindSafe,\n I12: RefUnwindSafe,\n I13: RefUnwindSafe,\n I14: RefUnwindSafe,\n I15: RefUnwindSafe,\n I16: RefUnwindSafe,\n I17: RefUnwindSafe,\n I18: RefUnwindSafe,\n I19: RefUnwindSafe,\n I20: RefUnwindSafe,\n I21: RefUnwindSafe,\n I22: RefUnwindSafe,\n I23: RefUnwindSafe,\n I24: RefUnwindSafe,\n I25: RefUnwindSafe,\n I26: RefUnwindSafe,\n I27: RefUnwindSafe,\n I28: RefUnwindSafe,\n I29: RefUnwindSafe,
",1,["wiwi::iter::tuple::Tuple29"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24, I25, I26, I27, I28, I29, I30> RefUnwindSafe for Tuple30<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24, I25, I26, I27, I28, I29, I30>
where\n I1: RefUnwindSafe,\n I2: RefUnwindSafe,\n I3: RefUnwindSafe,\n I4: RefUnwindSafe,\n I5: RefUnwindSafe,\n I6: RefUnwindSafe,\n I7: RefUnwindSafe,\n I8: RefUnwindSafe,\n I9: RefUnwindSafe,\n I10: RefUnwindSafe,\n I11: RefUnwindSafe,\n I12: RefUnwindSafe,\n I13: RefUnwindSafe,\n I14: RefUnwindSafe,\n I15: RefUnwindSafe,\n I16: RefUnwindSafe,\n I17: RefUnwindSafe,\n I18: RefUnwindSafe,\n I19: RefUnwindSafe,\n I20: RefUnwindSafe,\n I21: RefUnwindSafe,\n I22: RefUnwindSafe,\n I23: RefUnwindSafe,\n I24: RefUnwindSafe,\n I25: RefUnwindSafe,\n I26: RefUnwindSafe,\n I27: RefUnwindSafe,\n I28: RefUnwindSafe,\n I29: RefUnwindSafe,\n I30: RefUnwindSafe,
",1,["wiwi::iter::tuple::Tuple30"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24, I25, I26, I27, I28, I29, I30, I31> RefUnwindSafe for Tuple31<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24, I25, I26, I27, I28, I29, I30, I31>
where\n I1: RefUnwindSafe,\n I2: RefUnwindSafe,\n I3: RefUnwindSafe,\n I4: RefUnwindSafe,\n I5: RefUnwindSafe,\n I6: RefUnwindSafe,\n I7: RefUnwindSafe,\n I8: RefUnwindSafe,\n I9: RefUnwindSafe,\n I10: RefUnwindSafe,\n I11: RefUnwindSafe,\n I12: RefUnwindSafe,\n I13: RefUnwindSafe,\n I14: RefUnwindSafe,\n I15: RefUnwindSafe,\n I16: RefUnwindSafe,\n I17: RefUnwindSafe,\n I18: RefUnwindSafe,\n I19: RefUnwindSafe,\n I20: RefUnwindSafe,\n I21: RefUnwindSafe,\n I22: RefUnwindSafe,\n I23: RefUnwindSafe,\n I24: RefUnwindSafe,\n I25: RefUnwindSafe,\n I26: RefUnwindSafe,\n I27: RefUnwindSafe,\n I28: RefUnwindSafe,\n I29: RefUnwindSafe,\n I30: RefUnwindSafe,\n I31: RefUnwindSafe,
",1,["wiwi::iter::tuple::Tuple31"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24, I25, I26, I27, I28, I29, I30, I31, I32> RefUnwindSafe for Tuple32<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24, I25, I26, I27, I28, I29, I30, I31, I32>
where\n I1: RefUnwindSafe,\n I2: RefUnwindSafe,\n I3: RefUnwindSafe,\n I4: RefUnwindSafe,\n I5: RefUnwindSafe,\n I6: RefUnwindSafe,\n I7: RefUnwindSafe,\n I8: RefUnwindSafe,\n I9: RefUnwindSafe,\n I10: RefUnwindSafe,\n I11: RefUnwindSafe,\n I12: RefUnwindSafe,\n I13: RefUnwindSafe,\n I14: RefUnwindSafe,\n I15: RefUnwindSafe,\n I16: RefUnwindSafe,\n I17: RefUnwindSafe,\n I18: RefUnwindSafe,\n I19: RefUnwindSafe,\n I20: RefUnwindSafe,\n I21: RefUnwindSafe,\n I22: RefUnwindSafe,\n I23: RefUnwindSafe,\n I24: RefUnwindSafe,\n I25: RefUnwindSafe,\n I26: RefUnwindSafe,\n I27: RefUnwindSafe,\n I28: RefUnwindSafe,\n I29: RefUnwindSafe,\n I30: RefUnwindSafe,\n I31: RefUnwindSafe,\n I32: RefUnwindSafe,
",1,["wiwi::iter::tuple::Tuple32"]],["impl<K, V> RefUnwindSafe for BTreeMapChain<K, V>
where\n K: RefUnwindSafe,\n V: RefUnwindSafe,
",1,["wiwi::chainer::btree_map::BTreeMapChain"]],["impl<K, V, S> RefUnwindSafe for HashMapChain<K, V, S>
where\n S: RefUnwindSafe,\n K: RefUnwindSafe,\n V: RefUnwindSafe,
",1,["wiwi::chainer::hash_map::HashMapChain"]],["impl<P> RefUnwindSafe for String<P>
where\n <P as Pool>::Raw: RefUnwindSafe,\n P: RefUnwindSafe,
",1,["wiwi::string_pool::string::String"]],["impl<T> RefUnwindSafe for BTreeSetChain<T>
where\n T: RefUnwindSafe,
",1,["wiwi::chainer::btree_set::BTreeSetChain"]],["impl<T> RefUnwindSafe for BinaryHeapChain<T>
where\n T: RefUnwindSafe,
",1,["wiwi::chainer::binary_heap::BinaryHeapChain"]],["impl<T> RefUnwindSafe for LinkedListChain<T>
where\n T: RefUnwindSafe,
",1,["wiwi::chainer::linked_list::LinkedListChain"]],["impl<T> RefUnwindSafe for SliceBoxChain<T>
where\n T: RefUnwindSafe,
",1,["wiwi::chainer::slice_box::SliceBoxChain"]],["impl<T> RefUnwindSafe for VecChain<T>
where\n T: RefUnwindSafe,
",1,["wiwi::chainer::vec::VecChain"]],["impl<T> RefUnwindSafe for VecDequeChain<T>
where\n T: RefUnwindSafe,
",1,["wiwi::chainer::vec_deque::VecDequeChain"]],["impl<T> RefUnwindSafe for Empty<T>
where\n T: RefUnwindSafe,
",1,["wiwi::iter::empty::Empty"]],["impl<T, F> RefUnwindSafe for LazyWrapState<T, F>
where\n T: RefUnwindSafe,\n F: RefUnwindSafe,
",1,["wiwi::lazy_wrap::LazyWrapState"]],["impl<T, F> RefUnwindSafe for LazyWrap<T, F>
where\n T: RefUnwindSafe,\n F: UnwindSafe,
"],["impl<T, S> RefUnwindSafe for HashSetChain<T, S>
where\n S: RefUnwindSafe,\n T: RefUnwindSafe,
",1,["wiwi::chainer::hash_set::HashSetChain"]],["impl<T, const N: usize> RefUnwindSafe for ArrayChain<T, N>
where\n T: RefUnwindSafe,
",1,["wiwi::chainer::array::ArrayChain"]]] +"wiwi":[["impl !RefUnwindSafe for IDGenerator",1,["wiwi::id::IDGenerator"]],["impl !RefUnwindSafe for Script",1,["wiwi::lsl::callback_api::script::Script"]],["impl !RefUnwindSafe for ScriptBuilder",1,["wiwi::lsl::callback_api::script::ScriptBuilder"]],["impl RefUnwindSafe for DecodeError",1,["wiwi::hex::DecodeError"]],["impl RefUnwindSafe for SizeHintBound",1,["wiwi::iter::size_hint::SizeHintBound"]],["impl RefUnwindSafe for Error",1,["wiwi::serialiser::error::Error"]],["impl RefUnwindSafe for DecodeError",1,["wiwi::z85::DecodeError"]],["impl RefUnwindSafe for Error",1,["wiwi::auth::error::Error"]],["impl RefUnwindSafe for ClientContinuerS1",1,["wiwi::auth::flow::signin::ClientContinuerS1"]],["impl RefUnwindSafe for ClientContinuerS2",1,["wiwi::auth::flow::signin::ClientContinuerS2"]],["impl RefUnwindSafe for ClientContinuerS3",1,["wiwi::auth::flow::signin::ClientContinuerS3"]],["impl RefUnwindSafe for ServerS2Params",1,["wiwi::auth::flow::signin::ServerS2Params"]],["impl RefUnwindSafe for ServerS3Params",1,["wiwi::auth::flow::signin::ServerS3Params"]],["impl RefUnwindSafe for SigninRequestS1",1,["wiwi::auth::flow::signin::SigninRequestS1"]],["impl RefUnwindSafe for SigninRequestS2",1,["wiwi::auth::flow::signin::SigninRequestS2"]],["impl RefUnwindSafe for SigninRequestS3",1,["wiwi::auth::flow::signin::SigninRequestS3"]],["impl RefUnwindSafe for SigninResponseS1",1,["wiwi::auth::flow::signin::SigninResponseS1"]],["impl RefUnwindSafe for SigninResponseS2",1,["wiwi::auth::flow::signin::SigninResponseS2"]],["impl RefUnwindSafe for SigninResponseS3",1,["wiwi::auth::flow::signin::SigninResponseS3"]],["impl RefUnwindSafe for SignupRequest",1,["wiwi::auth::flow::signup::SignupRequest"]],["impl RefUnwindSafe for StoredUnverifiedUserData",1,["wiwi::auth::flow::signup::StoredUnverifiedUserData"]],["impl RefUnwindSafe for U320",1,["wiwi::bigint::U320"]],["impl RefUnwindSafe for Encoder",1,["wiwi::bitstream::Encoder"]],["impl RefUnwindSafe for BitstreamEncoderChain",1,["wiwi::chainer::bitstream::BitstreamEncoderChain"]],["impl RefUnwindSafe for StrBoxChain",1,["wiwi::chainer::str_box::StrBoxChain"]],["impl RefUnwindSafe for StringChain",1,["wiwi::chainer::string::StringChain"]],["impl RefUnwindSafe for Builder",1,["wiwi::clock_timer::builder::Builder"]],["impl RefUnwindSafe for BuilderWithEnd",1,["wiwi::clock_timer::builder::BuilderWithEnd"]],["impl RefUnwindSafe for BuilderWithInterval",1,["wiwi::clock_timer::builder::BuilderWithInterval"]],["impl RefUnwindSafe for BuilderWithStart",1,["wiwi::clock_timer::builder::BuilderWithStart"]],["impl RefUnwindSafe for ClockTimer",1,["wiwi::clock_timer::ClockTimer"]],["impl RefUnwindSafe for Tick",1,["wiwi::clock_timer::Tick"]],["impl RefUnwindSafe for GeneratedID",1,["wiwi::id::GeneratedID"]],["impl RefUnwindSafe for SizeHint",1,["wiwi::iter::size_hint::SizeHint"]],["impl RefUnwindSafe for Marker",1,["wiwi::serialiser::marker::Marker"]],["impl RefUnwindSafe for SerialiseOptions",1,["wiwi::serialiser::serialise::SerialiseOptions"]],["impl RefUnwindSafe for GlobalPool",1,["wiwi::string_pool::pool::global::GlobalPool"]],["impl RefUnwindSafe for Board",1,["wiwi::sudoku::Board"]],["impl<'h> RefUnwindSafe for StrMutChain<'h>",1,["wiwi::chainer::str_mut::StrMutChain"]],["impl<'h> RefUnwindSafe for StrRefChain<'h>",1,["wiwi::chainer::str_ref::StrRefChain"]],["impl<'h> RefUnwindSafe for StringMutChain<'h>",1,["wiwi::chainer::string_mut::StringMutChain"]],["impl<'h> RefUnwindSafe for StringRefChain<'h>",1,["wiwi::chainer::string_ref::StringRefChain"]],["impl<'h> RefUnwindSafe for SlicesWrap<'h>",1,["wiwi::string_pool::pool::SlicesWrap"]],["impl<'h> RefUnwindSafe for SlicesWrapIter<'h>",1,["wiwi::string_pool::pool::SlicesWrapIter"]],["impl<'h, T> RefUnwindSafe for SliceMutChain<'h, T>
where\n T: RefUnwindSafe,
",1,["wiwi::chainer::slice_mut::SliceMutChain"]],["impl<'h, T> RefUnwindSafe for SliceRefChain<'h, T>
where\n T: RefUnwindSafe,
",1,["wiwi::chainer::slice_ref::SliceRefChain"]],["impl<'h, T> RefUnwindSafe for VecMutChain<'h, T>
where\n T: RefUnwindSafe,
",1,["wiwi::chainer::vec_mut::VecMutChain"]],["impl<'h, T> RefUnwindSafe for VecRefChain<'h, T>
where\n T: RefUnwindSafe,
",1,["wiwi::chainer::vec_ref::VecRefChain"]],["impl<'h, T, const N: usize> RefUnwindSafe for ArrayMutChain<'h, T, N>
where\n T: RefUnwindSafe,
",1,["wiwi::chainer::array_mut::ArrayMutChain"]],["impl<'h, T, const N: usize> RefUnwindSafe for ArrayRefChain<'h, T, N>
where\n T: RefUnwindSafe,
",1,["wiwi::chainer::array_ref::ArrayRefChain"]],["impl<F> RefUnwindSafe for FromFn<F>
where\n F: RefUnwindSafe,
",1,["wiwi::iter::from_fn::FromFn"]],["impl<I> RefUnwindSafe for IterAdapter<I>
where\n I: RefUnwindSafe,
",1,["wiwi::iter::adapter::IterAdapter"]],["impl<I> RefUnwindSafe for RepeatPerItem<I>
where\n I: RefUnwindSafe,\n <I as Iter>::Item: RefUnwindSafe,
",1,["wiwi::iter::repeat_per_item::RepeatPerItem"]],["impl<I> RefUnwindSafe for Rev<I>
where\n I: RefUnwindSafe,
",1,["wiwi::iter::rev::Rev"]],["impl<I, F> RefUnwindSafe for Map<I, F>
where\n I: RefUnwindSafe,\n F: RefUnwindSafe,
",1,["wiwi::iter::map::Map"]],["impl<I, T> RefUnwindSafe for Peek<I, T>
where\n I: RefUnwindSafe,\n T: RefUnwindSafe,
",1,["wiwi::iter::peek::Peek"]],["impl<I1> RefUnwindSafe for Tuple1<I1>
where\n I1: RefUnwindSafe,
",1,["wiwi::iter::tuple::Tuple1"]],["impl<I1, I2> RefUnwindSafe for Tuple2<I1, I2>
where\n I1: RefUnwindSafe,\n I2: RefUnwindSafe,
",1,["wiwi::iter::tuple::Tuple2"]],["impl<I1, I2, I3> RefUnwindSafe for Tuple3<I1, I2, I3>
where\n I1: RefUnwindSafe,\n I2: RefUnwindSafe,\n I3: RefUnwindSafe,
",1,["wiwi::iter::tuple::Tuple3"]],["impl<I1, I2, I3, I4> RefUnwindSafe for Tuple4<I1, I2, I3, I4>
where\n I1: RefUnwindSafe,\n I2: RefUnwindSafe,\n I3: RefUnwindSafe,\n I4: RefUnwindSafe,
",1,["wiwi::iter::tuple::Tuple4"]],["impl<I1, I2, I3, I4, I5> RefUnwindSafe for Tuple5<I1, I2, I3, I4, I5>
where\n I1: RefUnwindSafe,\n I2: RefUnwindSafe,\n I3: RefUnwindSafe,\n I4: RefUnwindSafe,\n I5: RefUnwindSafe,
",1,["wiwi::iter::tuple::Tuple5"]],["impl<I1, I2, I3, I4, I5, I6> RefUnwindSafe for Tuple6<I1, I2, I3, I4, I5, I6>
where\n I1: RefUnwindSafe,\n I2: RefUnwindSafe,\n I3: RefUnwindSafe,\n I4: RefUnwindSafe,\n I5: RefUnwindSafe,\n I6: RefUnwindSafe,
",1,["wiwi::iter::tuple::Tuple6"]],["impl<I1, I2, I3, I4, I5, I6, I7> RefUnwindSafe for Tuple7<I1, I2, I3, I4, I5, I6, I7>
where\n I1: RefUnwindSafe,\n I2: RefUnwindSafe,\n I3: RefUnwindSafe,\n I4: RefUnwindSafe,\n I5: RefUnwindSafe,\n I6: RefUnwindSafe,\n I7: RefUnwindSafe,
",1,["wiwi::iter::tuple::Tuple7"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8> RefUnwindSafe for Tuple8<I1, I2, I3, I4, I5, I6, I7, I8>
where\n I1: RefUnwindSafe,\n I2: RefUnwindSafe,\n I3: RefUnwindSafe,\n I4: RefUnwindSafe,\n I5: RefUnwindSafe,\n I6: RefUnwindSafe,\n I7: RefUnwindSafe,\n I8: RefUnwindSafe,
",1,["wiwi::iter::tuple::Tuple8"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9> RefUnwindSafe for Tuple9<I1, I2, I3, I4, I5, I6, I7, I8, I9>
where\n I1: RefUnwindSafe,\n I2: RefUnwindSafe,\n I3: RefUnwindSafe,\n I4: RefUnwindSafe,\n I5: RefUnwindSafe,\n I6: RefUnwindSafe,\n I7: RefUnwindSafe,\n I8: RefUnwindSafe,\n I9: RefUnwindSafe,
",1,["wiwi::iter::tuple::Tuple9"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10> RefUnwindSafe for Tuple10<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10>
where\n I1: RefUnwindSafe,\n I2: RefUnwindSafe,\n I3: RefUnwindSafe,\n I4: RefUnwindSafe,\n I5: RefUnwindSafe,\n I6: RefUnwindSafe,\n I7: RefUnwindSafe,\n I8: RefUnwindSafe,\n I9: RefUnwindSafe,\n I10: RefUnwindSafe,
",1,["wiwi::iter::tuple::Tuple10"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11> RefUnwindSafe for Tuple11<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11>
where\n I1: RefUnwindSafe,\n I2: RefUnwindSafe,\n I3: RefUnwindSafe,\n I4: RefUnwindSafe,\n I5: RefUnwindSafe,\n I6: RefUnwindSafe,\n I7: RefUnwindSafe,\n I8: RefUnwindSafe,\n I9: RefUnwindSafe,\n I10: RefUnwindSafe,\n I11: RefUnwindSafe,
",1,["wiwi::iter::tuple::Tuple11"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12> RefUnwindSafe for Tuple12<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12>
where\n I1: RefUnwindSafe,\n I2: RefUnwindSafe,\n I3: RefUnwindSafe,\n I4: RefUnwindSafe,\n I5: RefUnwindSafe,\n I6: RefUnwindSafe,\n I7: RefUnwindSafe,\n I8: RefUnwindSafe,\n I9: RefUnwindSafe,\n I10: RefUnwindSafe,\n I11: RefUnwindSafe,\n I12: RefUnwindSafe,
",1,["wiwi::iter::tuple::Tuple12"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13> RefUnwindSafe for Tuple13<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13>
where\n I1: RefUnwindSafe,\n I2: RefUnwindSafe,\n I3: RefUnwindSafe,\n I4: RefUnwindSafe,\n I5: RefUnwindSafe,\n I6: RefUnwindSafe,\n I7: RefUnwindSafe,\n I8: RefUnwindSafe,\n I9: RefUnwindSafe,\n I10: RefUnwindSafe,\n I11: RefUnwindSafe,\n I12: RefUnwindSafe,\n I13: RefUnwindSafe,
",1,["wiwi::iter::tuple::Tuple13"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14> RefUnwindSafe for Tuple14<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14>
where\n I1: RefUnwindSafe,\n I2: RefUnwindSafe,\n I3: RefUnwindSafe,\n I4: RefUnwindSafe,\n I5: RefUnwindSafe,\n I6: RefUnwindSafe,\n I7: RefUnwindSafe,\n I8: RefUnwindSafe,\n I9: RefUnwindSafe,\n I10: RefUnwindSafe,\n I11: RefUnwindSafe,\n I12: RefUnwindSafe,\n I13: RefUnwindSafe,\n I14: RefUnwindSafe,
",1,["wiwi::iter::tuple::Tuple14"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15> RefUnwindSafe for Tuple15<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15>
where\n I1: RefUnwindSafe,\n I2: RefUnwindSafe,\n I3: RefUnwindSafe,\n I4: RefUnwindSafe,\n I5: RefUnwindSafe,\n I6: RefUnwindSafe,\n I7: RefUnwindSafe,\n I8: RefUnwindSafe,\n I9: RefUnwindSafe,\n I10: RefUnwindSafe,\n I11: RefUnwindSafe,\n I12: RefUnwindSafe,\n I13: RefUnwindSafe,\n I14: RefUnwindSafe,\n I15: RefUnwindSafe,
",1,["wiwi::iter::tuple::Tuple15"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16> RefUnwindSafe for Tuple16<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16>
where\n I1: RefUnwindSafe,\n I2: RefUnwindSafe,\n I3: RefUnwindSafe,\n I4: RefUnwindSafe,\n I5: RefUnwindSafe,\n I6: RefUnwindSafe,\n I7: RefUnwindSafe,\n I8: RefUnwindSafe,\n I9: RefUnwindSafe,\n I10: RefUnwindSafe,\n I11: RefUnwindSafe,\n I12: RefUnwindSafe,\n I13: RefUnwindSafe,\n I14: RefUnwindSafe,\n I15: RefUnwindSafe,\n I16: RefUnwindSafe,
",1,["wiwi::iter::tuple::Tuple16"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17> RefUnwindSafe for Tuple17<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17>
where\n I1: RefUnwindSafe,\n I2: RefUnwindSafe,\n I3: RefUnwindSafe,\n I4: RefUnwindSafe,\n I5: RefUnwindSafe,\n I6: RefUnwindSafe,\n I7: RefUnwindSafe,\n I8: RefUnwindSafe,\n I9: RefUnwindSafe,\n I10: RefUnwindSafe,\n I11: RefUnwindSafe,\n I12: RefUnwindSafe,\n I13: RefUnwindSafe,\n I14: RefUnwindSafe,\n I15: RefUnwindSafe,\n I16: RefUnwindSafe,\n I17: RefUnwindSafe,
",1,["wiwi::iter::tuple::Tuple17"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18> RefUnwindSafe for Tuple18<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18>
where\n I1: RefUnwindSafe,\n I2: RefUnwindSafe,\n I3: RefUnwindSafe,\n I4: RefUnwindSafe,\n I5: RefUnwindSafe,\n I6: RefUnwindSafe,\n I7: RefUnwindSafe,\n I8: RefUnwindSafe,\n I9: RefUnwindSafe,\n I10: RefUnwindSafe,\n I11: RefUnwindSafe,\n I12: RefUnwindSafe,\n I13: RefUnwindSafe,\n I14: RefUnwindSafe,\n I15: RefUnwindSafe,\n I16: RefUnwindSafe,\n I17: RefUnwindSafe,\n I18: RefUnwindSafe,
",1,["wiwi::iter::tuple::Tuple18"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19> RefUnwindSafe for Tuple19<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19>
where\n I1: RefUnwindSafe,\n I2: RefUnwindSafe,\n I3: RefUnwindSafe,\n I4: RefUnwindSafe,\n I5: RefUnwindSafe,\n I6: RefUnwindSafe,\n I7: RefUnwindSafe,\n I8: RefUnwindSafe,\n I9: RefUnwindSafe,\n I10: RefUnwindSafe,\n I11: RefUnwindSafe,\n I12: RefUnwindSafe,\n I13: RefUnwindSafe,\n I14: RefUnwindSafe,\n I15: RefUnwindSafe,\n I16: RefUnwindSafe,\n I17: RefUnwindSafe,\n I18: RefUnwindSafe,\n I19: RefUnwindSafe,
",1,["wiwi::iter::tuple::Tuple19"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20> RefUnwindSafe for Tuple20<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20>
where\n I1: RefUnwindSafe,\n I2: RefUnwindSafe,\n I3: RefUnwindSafe,\n I4: RefUnwindSafe,\n I5: RefUnwindSafe,\n I6: RefUnwindSafe,\n I7: RefUnwindSafe,\n I8: RefUnwindSafe,\n I9: RefUnwindSafe,\n I10: RefUnwindSafe,\n I11: RefUnwindSafe,\n I12: RefUnwindSafe,\n I13: RefUnwindSafe,\n I14: RefUnwindSafe,\n I15: RefUnwindSafe,\n I16: RefUnwindSafe,\n I17: RefUnwindSafe,\n I18: RefUnwindSafe,\n I19: RefUnwindSafe,\n I20: RefUnwindSafe,
",1,["wiwi::iter::tuple::Tuple20"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21> RefUnwindSafe for Tuple21<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21>
where\n I1: RefUnwindSafe,\n I2: RefUnwindSafe,\n I3: RefUnwindSafe,\n I4: RefUnwindSafe,\n I5: RefUnwindSafe,\n I6: RefUnwindSafe,\n I7: RefUnwindSafe,\n I8: RefUnwindSafe,\n I9: RefUnwindSafe,\n I10: RefUnwindSafe,\n I11: RefUnwindSafe,\n I12: RefUnwindSafe,\n I13: RefUnwindSafe,\n I14: RefUnwindSafe,\n I15: RefUnwindSafe,\n I16: RefUnwindSafe,\n I17: RefUnwindSafe,\n I18: RefUnwindSafe,\n I19: RefUnwindSafe,\n I20: RefUnwindSafe,\n I21: RefUnwindSafe,
",1,["wiwi::iter::tuple::Tuple21"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22> RefUnwindSafe for Tuple22<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22>
where\n I1: RefUnwindSafe,\n I2: RefUnwindSafe,\n I3: RefUnwindSafe,\n I4: RefUnwindSafe,\n I5: RefUnwindSafe,\n I6: RefUnwindSafe,\n I7: RefUnwindSafe,\n I8: RefUnwindSafe,\n I9: RefUnwindSafe,\n I10: RefUnwindSafe,\n I11: RefUnwindSafe,\n I12: RefUnwindSafe,\n I13: RefUnwindSafe,\n I14: RefUnwindSafe,\n I15: RefUnwindSafe,\n I16: RefUnwindSafe,\n I17: RefUnwindSafe,\n I18: RefUnwindSafe,\n I19: RefUnwindSafe,\n I20: RefUnwindSafe,\n I21: RefUnwindSafe,\n I22: RefUnwindSafe,
",1,["wiwi::iter::tuple::Tuple22"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23> RefUnwindSafe for Tuple23<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23>
where\n I1: RefUnwindSafe,\n I2: RefUnwindSafe,\n I3: RefUnwindSafe,\n I4: RefUnwindSafe,\n I5: RefUnwindSafe,\n I6: RefUnwindSafe,\n I7: RefUnwindSafe,\n I8: RefUnwindSafe,\n I9: RefUnwindSafe,\n I10: RefUnwindSafe,\n I11: RefUnwindSafe,\n I12: RefUnwindSafe,\n I13: RefUnwindSafe,\n I14: RefUnwindSafe,\n I15: RefUnwindSafe,\n I16: RefUnwindSafe,\n I17: RefUnwindSafe,\n I18: RefUnwindSafe,\n I19: RefUnwindSafe,\n I20: RefUnwindSafe,\n I21: RefUnwindSafe,\n I22: RefUnwindSafe,\n I23: RefUnwindSafe,
",1,["wiwi::iter::tuple::Tuple23"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24> RefUnwindSafe for Tuple24<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24>
where\n I1: RefUnwindSafe,\n I2: RefUnwindSafe,\n I3: RefUnwindSafe,\n I4: RefUnwindSafe,\n I5: RefUnwindSafe,\n I6: RefUnwindSafe,\n I7: RefUnwindSafe,\n I8: RefUnwindSafe,\n I9: RefUnwindSafe,\n I10: RefUnwindSafe,\n I11: RefUnwindSafe,\n I12: RefUnwindSafe,\n I13: RefUnwindSafe,\n I14: RefUnwindSafe,\n I15: RefUnwindSafe,\n I16: RefUnwindSafe,\n I17: RefUnwindSafe,\n I18: RefUnwindSafe,\n I19: RefUnwindSafe,\n I20: RefUnwindSafe,\n I21: RefUnwindSafe,\n I22: RefUnwindSafe,\n I23: RefUnwindSafe,\n I24: RefUnwindSafe,
",1,["wiwi::iter::tuple::Tuple24"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24, I25> RefUnwindSafe for Tuple25<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24, I25>
where\n I1: RefUnwindSafe,\n I2: RefUnwindSafe,\n I3: RefUnwindSafe,\n I4: RefUnwindSafe,\n I5: RefUnwindSafe,\n I6: RefUnwindSafe,\n I7: RefUnwindSafe,\n I8: RefUnwindSafe,\n I9: RefUnwindSafe,\n I10: RefUnwindSafe,\n I11: RefUnwindSafe,\n I12: RefUnwindSafe,\n I13: RefUnwindSafe,\n I14: RefUnwindSafe,\n I15: RefUnwindSafe,\n I16: RefUnwindSafe,\n I17: RefUnwindSafe,\n I18: RefUnwindSafe,\n I19: RefUnwindSafe,\n I20: RefUnwindSafe,\n I21: RefUnwindSafe,\n I22: RefUnwindSafe,\n I23: RefUnwindSafe,\n I24: RefUnwindSafe,\n I25: RefUnwindSafe,
",1,["wiwi::iter::tuple::Tuple25"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24, I25, I26> RefUnwindSafe for Tuple26<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24, I25, I26>
where\n I1: RefUnwindSafe,\n I2: RefUnwindSafe,\n I3: RefUnwindSafe,\n I4: RefUnwindSafe,\n I5: RefUnwindSafe,\n I6: RefUnwindSafe,\n I7: RefUnwindSafe,\n I8: RefUnwindSafe,\n I9: RefUnwindSafe,\n I10: RefUnwindSafe,\n I11: RefUnwindSafe,\n I12: RefUnwindSafe,\n I13: RefUnwindSafe,\n I14: RefUnwindSafe,\n I15: RefUnwindSafe,\n I16: RefUnwindSafe,\n I17: RefUnwindSafe,\n I18: RefUnwindSafe,\n I19: RefUnwindSafe,\n I20: RefUnwindSafe,\n I21: RefUnwindSafe,\n I22: RefUnwindSafe,\n I23: RefUnwindSafe,\n I24: RefUnwindSafe,\n I25: RefUnwindSafe,\n I26: RefUnwindSafe,
",1,["wiwi::iter::tuple::Tuple26"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24, I25, I26, I27> RefUnwindSafe for Tuple27<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24, I25, I26, I27>
where\n I1: RefUnwindSafe,\n I2: RefUnwindSafe,\n I3: RefUnwindSafe,\n I4: RefUnwindSafe,\n I5: RefUnwindSafe,\n I6: RefUnwindSafe,\n I7: RefUnwindSafe,\n I8: RefUnwindSafe,\n I9: RefUnwindSafe,\n I10: RefUnwindSafe,\n I11: RefUnwindSafe,\n I12: RefUnwindSafe,\n I13: RefUnwindSafe,\n I14: RefUnwindSafe,\n I15: RefUnwindSafe,\n I16: RefUnwindSafe,\n I17: RefUnwindSafe,\n I18: RefUnwindSafe,\n I19: RefUnwindSafe,\n I20: RefUnwindSafe,\n I21: RefUnwindSafe,\n I22: RefUnwindSafe,\n I23: RefUnwindSafe,\n I24: RefUnwindSafe,\n I25: RefUnwindSafe,\n I26: RefUnwindSafe,\n I27: RefUnwindSafe,
",1,["wiwi::iter::tuple::Tuple27"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24, I25, I26, I27, I28> RefUnwindSafe for Tuple28<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24, I25, I26, I27, I28>
where\n I1: RefUnwindSafe,\n I2: RefUnwindSafe,\n I3: RefUnwindSafe,\n I4: RefUnwindSafe,\n I5: RefUnwindSafe,\n I6: RefUnwindSafe,\n I7: RefUnwindSafe,\n I8: RefUnwindSafe,\n I9: RefUnwindSafe,\n I10: RefUnwindSafe,\n I11: RefUnwindSafe,\n I12: RefUnwindSafe,\n I13: RefUnwindSafe,\n I14: RefUnwindSafe,\n I15: RefUnwindSafe,\n I16: RefUnwindSafe,\n I17: RefUnwindSafe,\n I18: RefUnwindSafe,\n I19: RefUnwindSafe,\n I20: RefUnwindSafe,\n I21: RefUnwindSafe,\n I22: RefUnwindSafe,\n I23: RefUnwindSafe,\n I24: RefUnwindSafe,\n I25: RefUnwindSafe,\n I26: RefUnwindSafe,\n I27: RefUnwindSafe,\n I28: RefUnwindSafe,
",1,["wiwi::iter::tuple::Tuple28"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24, I25, I26, I27, I28, I29> RefUnwindSafe for Tuple29<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24, I25, I26, I27, I28, I29>
where\n I1: RefUnwindSafe,\n I2: RefUnwindSafe,\n I3: RefUnwindSafe,\n I4: RefUnwindSafe,\n I5: RefUnwindSafe,\n I6: RefUnwindSafe,\n I7: RefUnwindSafe,\n I8: RefUnwindSafe,\n I9: RefUnwindSafe,\n I10: RefUnwindSafe,\n I11: RefUnwindSafe,\n I12: RefUnwindSafe,\n I13: RefUnwindSafe,\n I14: RefUnwindSafe,\n I15: RefUnwindSafe,\n I16: RefUnwindSafe,\n I17: RefUnwindSafe,\n I18: RefUnwindSafe,\n I19: RefUnwindSafe,\n I20: RefUnwindSafe,\n I21: RefUnwindSafe,\n I22: RefUnwindSafe,\n I23: RefUnwindSafe,\n I24: RefUnwindSafe,\n I25: RefUnwindSafe,\n I26: RefUnwindSafe,\n I27: RefUnwindSafe,\n I28: RefUnwindSafe,\n I29: RefUnwindSafe,
",1,["wiwi::iter::tuple::Tuple29"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24, I25, I26, I27, I28, I29, I30> RefUnwindSafe for Tuple30<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24, I25, I26, I27, I28, I29, I30>
where\n I1: RefUnwindSafe,\n I2: RefUnwindSafe,\n I3: RefUnwindSafe,\n I4: RefUnwindSafe,\n I5: RefUnwindSafe,\n I6: RefUnwindSafe,\n I7: RefUnwindSafe,\n I8: RefUnwindSafe,\n I9: RefUnwindSafe,\n I10: RefUnwindSafe,\n I11: RefUnwindSafe,\n I12: RefUnwindSafe,\n I13: RefUnwindSafe,\n I14: RefUnwindSafe,\n I15: RefUnwindSafe,\n I16: RefUnwindSafe,\n I17: RefUnwindSafe,\n I18: RefUnwindSafe,\n I19: RefUnwindSafe,\n I20: RefUnwindSafe,\n I21: RefUnwindSafe,\n I22: RefUnwindSafe,\n I23: RefUnwindSafe,\n I24: RefUnwindSafe,\n I25: RefUnwindSafe,\n I26: RefUnwindSafe,\n I27: RefUnwindSafe,\n I28: RefUnwindSafe,\n I29: RefUnwindSafe,\n I30: RefUnwindSafe,
",1,["wiwi::iter::tuple::Tuple30"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24, I25, I26, I27, I28, I29, I30, I31> RefUnwindSafe for Tuple31<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24, I25, I26, I27, I28, I29, I30, I31>
where\n I1: RefUnwindSafe,\n I2: RefUnwindSafe,\n I3: RefUnwindSafe,\n I4: RefUnwindSafe,\n I5: RefUnwindSafe,\n I6: RefUnwindSafe,\n I7: RefUnwindSafe,\n I8: RefUnwindSafe,\n I9: RefUnwindSafe,\n I10: RefUnwindSafe,\n I11: RefUnwindSafe,\n I12: RefUnwindSafe,\n I13: RefUnwindSafe,\n I14: RefUnwindSafe,\n I15: RefUnwindSafe,\n I16: RefUnwindSafe,\n I17: RefUnwindSafe,\n I18: RefUnwindSafe,\n I19: RefUnwindSafe,\n I20: RefUnwindSafe,\n I21: RefUnwindSafe,\n I22: RefUnwindSafe,\n I23: RefUnwindSafe,\n I24: RefUnwindSafe,\n I25: RefUnwindSafe,\n I26: RefUnwindSafe,\n I27: RefUnwindSafe,\n I28: RefUnwindSafe,\n I29: RefUnwindSafe,\n I30: RefUnwindSafe,\n I31: RefUnwindSafe,
",1,["wiwi::iter::tuple::Tuple31"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24, I25, I26, I27, I28, I29, I30, I31, I32> RefUnwindSafe for Tuple32<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24, I25, I26, I27, I28, I29, I30, I31, I32>
where\n I1: RefUnwindSafe,\n I2: RefUnwindSafe,\n I3: RefUnwindSafe,\n I4: RefUnwindSafe,\n I5: RefUnwindSafe,\n I6: RefUnwindSafe,\n I7: RefUnwindSafe,\n I8: RefUnwindSafe,\n I9: RefUnwindSafe,\n I10: RefUnwindSafe,\n I11: RefUnwindSafe,\n I12: RefUnwindSafe,\n I13: RefUnwindSafe,\n I14: RefUnwindSafe,\n I15: RefUnwindSafe,\n I16: RefUnwindSafe,\n I17: RefUnwindSafe,\n I18: RefUnwindSafe,\n I19: RefUnwindSafe,\n I20: RefUnwindSafe,\n I21: RefUnwindSafe,\n I22: RefUnwindSafe,\n I23: RefUnwindSafe,\n I24: RefUnwindSafe,\n I25: RefUnwindSafe,\n I26: RefUnwindSafe,\n I27: RefUnwindSafe,\n I28: RefUnwindSafe,\n I29: RefUnwindSafe,\n I30: RefUnwindSafe,\n I31: RefUnwindSafe,\n I32: RefUnwindSafe,
",1,["wiwi::iter::tuple::Tuple32"]],["impl<K, V> RefUnwindSafe for BTreeMapChain<K, V>
where\n K: RefUnwindSafe,\n V: RefUnwindSafe,
",1,["wiwi::chainer::btree_map::BTreeMapChain"]],["impl<K, V, S> RefUnwindSafe for HashMapChain<K, V, S>
where\n S: RefUnwindSafe,\n K: RefUnwindSafe,\n V: RefUnwindSafe,
",1,["wiwi::chainer::hash_map::HashMapChain"]],["impl<P> RefUnwindSafe for String<P>
where\n <P as Pool>::Raw: RefUnwindSafe,\n P: RefUnwindSafe,
",1,["wiwi::string_pool::string::String"]],["impl<T> RefUnwindSafe for BTreeSetChain<T>
where\n T: RefUnwindSafe,
",1,["wiwi::chainer::btree_set::BTreeSetChain"]],["impl<T> RefUnwindSafe for BinaryHeapChain<T>
where\n T: RefUnwindSafe,
",1,["wiwi::chainer::binary_heap::BinaryHeapChain"]],["impl<T> RefUnwindSafe for LinkedListChain<T>
where\n T: RefUnwindSafe,
",1,["wiwi::chainer::linked_list::LinkedListChain"]],["impl<T> RefUnwindSafe for SliceBoxChain<T>
where\n T: RefUnwindSafe,
",1,["wiwi::chainer::slice_box::SliceBoxChain"]],["impl<T> RefUnwindSafe for VecChain<T>
where\n T: RefUnwindSafe,
",1,["wiwi::chainer::vec::VecChain"]],["impl<T> RefUnwindSafe for VecDequeChain<T>
where\n T: RefUnwindSafe,
",1,["wiwi::chainer::vec_deque::VecDequeChain"]],["impl<T> RefUnwindSafe for Empty<T>
where\n T: RefUnwindSafe,
",1,["wiwi::iter::empty::Empty"]],["impl<T, F> RefUnwindSafe for LazyWrapState<T, F>
where\n T: RefUnwindSafe,\n F: RefUnwindSafe,
",1,["wiwi::lazy_wrap::LazyWrapState"]],["impl<T, F> RefUnwindSafe for LazyWrap<T, F>
where\n T: RefUnwindSafe,\n F: UnwindSafe,
"],["impl<T, S> RefUnwindSafe for HashSetChain<T, S>
where\n S: RefUnwindSafe,\n T: RefUnwindSafe,
",1,["wiwi::chainer::hash_set::HashSetChain"]],["impl<T, const N: usize> RefUnwindSafe for ArrayChain<T, N>
where\n T: RefUnwindSafe,
",1,["wiwi::chainer::array::ArrayChain"]]] };if (window.register_implementors) {window.register_implementors(implementors);} else {window.pending_implementors = implementors;}})() \ No newline at end of file diff --git a/trait.impl/core/panic/unwind_safe/trait.UnwindSafe.js b/trait.impl/core/panic/unwind_safe/trait.UnwindSafe.js index 501c50b36..76c74b3fd 100644 --- a/trait.impl/core/panic/unwind_safe/trait.UnwindSafe.js +++ b/trait.impl/core/panic/unwind_safe/trait.UnwindSafe.js @@ -1,3 +1,3 @@ (function() {var implementors = { -"wiwi":[["impl !UnwindSafe for IDGenerator",1,["wiwi::id::IDGenerator"]],["impl !UnwindSafe for Script",1,["wiwi::lsl::callback_api::script::Script"]],["impl !UnwindSafe for ScriptBuilder",1,["wiwi::lsl::callback_api::script::ScriptBuilder"]],["impl UnwindSafe for DecodeError",1,["wiwi::hex::DecodeError"]],["impl UnwindSafe for SizeHintBound",1,["wiwi::iter::size_hint::SizeHintBound"]],["impl UnwindSafe for Error",1,["wiwi::serialiser::error::Error"]],["impl UnwindSafe for DecodeError",1,["wiwi::z85::DecodeError"]],["impl UnwindSafe for Error",1,["wiwi::auth::error::Error"]],["impl UnwindSafe for ClientContinuerS1",1,["wiwi::auth::flow::signin::ClientContinuerS1"]],["impl UnwindSafe for ClientContinuerS2",1,["wiwi::auth::flow::signin::ClientContinuerS2"]],["impl UnwindSafe for ClientContinuerS3",1,["wiwi::auth::flow::signin::ClientContinuerS3"]],["impl UnwindSafe for ServerS2Params",1,["wiwi::auth::flow::signin::ServerS2Params"]],["impl UnwindSafe for ServerS3Params",1,["wiwi::auth::flow::signin::ServerS3Params"]],["impl UnwindSafe for SigninRequestS1",1,["wiwi::auth::flow::signin::SigninRequestS1"]],["impl UnwindSafe for SigninRequestS2",1,["wiwi::auth::flow::signin::SigninRequestS2"]],["impl UnwindSafe for SigninRequestS3",1,["wiwi::auth::flow::signin::SigninRequestS3"]],["impl UnwindSafe for SigninResponseS1",1,["wiwi::auth::flow::signin::SigninResponseS1"]],["impl UnwindSafe for SigninResponseS2",1,["wiwi::auth::flow::signin::SigninResponseS2"]],["impl UnwindSafe for SigninResponseS3",1,["wiwi::auth::flow::signin::SigninResponseS3"]],["impl UnwindSafe for SignupRequest",1,["wiwi::auth::flow::signup::SignupRequest"]],["impl UnwindSafe for StoredUnverifiedUserData",1,["wiwi::auth::flow::signup::StoredUnverifiedUserData"]],["impl UnwindSafe for U320",1,["wiwi::bigint::U320"]],["impl UnwindSafe for Encoder",1,["wiwi::bitstream::Encoder"]],["impl UnwindSafe for BitstreamEncoderChain",1,["wiwi::chainer::bitstream::BitstreamEncoderChain"]],["impl UnwindSafe for StrBoxChain",1,["wiwi::chainer::str_box::StrBoxChain"]],["impl UnwindSafe for StringChain",1,["wiwi::chainer::string::StringChain"]],["impl UnwindSafe for Builder",1,["wiwi::clock_timer::builder::Builder"]],["impl UnwindSafe for BuilderWithEnd",1,["wiwi::clock_timer::builder::BuilderWithEnd"]],["impl UnwindSafe for BuilderWithInterval",1,["wiwi::clock_timer::builder::BuilderWithInterval"]],["impl UnwindSafe for BuilderWithStart",1,["wiwi::clock_timer::builder::BuilderWithStart"]],["impl UnwindSafe for ClockTimer",1,["wiwi::clock_timer::ClockTimer"]],["impl UnwindSafe for Tick",1,["wiwi::clock_timer::Tick"]],["impl UnwindSafe for GeneratedID",1,["wiwi::id::GeneratedID"]],["impl UnwindSafe for SizeHint",1,["wiwi::iter::size_hint::SizeHint"]],["impl UnwindSafe for SerialiseOptions",1,["wiwi::serialiser::serialise::SerialiseOptions"]],["impl UnwindSafe for GlobalPool",1,["wiwi::string_pool::pool::global::GlobalPool"]],["impl UnwindSafe for Board",1,["wiwi::sudoku::Board"]],["impl<'h> !UnwindSafe for StrMutChain<'h>",1,["wiwi::chainer::str_mut::StrMutChain"]],["impl<'h> !UnwindSafe for StringMutChain<'h>",1,["wiwi::chainer::string_mut::StringMutChain"]],["impl<'h> UnwindSafe for StrRefChain<'h>",1,["wiwi::chainer::str_ref::StrRefChain"]],["impl<'h> UnwindSafe for StringRefChain<'h>",1,["wiwi::chainer::string_ref::StringRefChain"]],["impl<'h> UnwindSafe for SlicesWrap<'h>",1,["wiwi::string_pool::pool::SlicesWrap"]],["impl<'h> UnwindSafe for SlicesWrapIter<'h>",1,["wiwi::string_pool::pool::SlicesWrapIter"]],["impl<'h, T> !UnwindSafe for SliceMutChain<'h, T>",1,["wiwi::chainer::slice_mut::SliceMutChain"]],["impl<'h, T> !UnwindSafe for VecMutChain<'h, T>",1,["wiwi::chainer::vec_mut::VecMutChain"]],["impl<'h, T> UnwindSafe for SliceRefChain<'h, T>
where\n T: RefUnwindSafe,
",1,["wiwi::chainer::slice_ref::SliceRefChain"]],["impl<'h, T> UnwindSafe for VecRefChain<'h, T>
where\n T: RefUnwindSafe,
",1,["wiwi::chainer::vec_ref::VecRefChain"]],["impl<'h, T, const N: usize> !UnwindSafe for ArrayMutChain<'h, T, N>",1,["wiwi::chainer::array_mut::ArrayMutChain"]],["impl<'h, T, const N: usize> UnwindSafe for ArrayRefChain<'h, T, N>
where\n T: RefUnwindSafe,
",1,["wiwi::chainer::array_ref::ArrayRefChain"]],["impl<F> UnwindSafe for FromFn<F>
where\n F: UnwindSafe,
",1,["wiwi::iter::from_fn::FromFn"]],["impl<I> UnwindSafe for IterAdapter<I>
where\n I: UnwindSafe,
",1,["wiwi::iter::adapter::IterAdapter"]],["impl<I> UnwindSafe for RepeatPerItem<I>
where\n I: UnwindSafe,\n <I as Iter>::Item: UnwindSafe,
",1,["wiwi::iter::repeat_per_item::RepeatPerItem"]],["impl<I, F> UnwindSafe for Map<I, F>
where\n I: UnwindSafe,\n F: UnwindSafe,
",1,["wiwi::iter::map::Map"]],["impl<I, T> UnwindSafe for Peek<I, T>
where\n I: UnwindSafe,\n T: UnwindSafe,
",1,["wiwi::iter::peek::Peek"]],["impl<I1> UnwindSafe for Tuple1<I1>
where\n I1: UnwindSafe,
",1,["wiwi::iter::tuple::Tuple1"]],["impl<I1, I2> UnwindSafe for Tuple2<I1, I2>
where\n I1: UnwindSafe,\n I2: UnwindSafe,
",1,["wiwi::iter::tuple::Tuple2"]],["impl<I1, I2, I3> UnwindSafe for Tuple3<I1, I2, I3>
where\n I1: UnwindSafe,\n I2: UnwindSafe,\n I3: UnwindSafe,
",1,["wiwi::iter::tuple::Tuple3"]],["impl<I1, I2, I3, I4> UnwindSafe for Tuple4<I1, I2, I3, I4>
where\n I1: UnwindSafe,\n I2: UnwindSafe,\n I3: UnwindSafe,\n I4: UnwindSafe,
",1,["wiwi::iter::tuple::Tuple4"]],["impl<I1, I2, I3, I4, I5> UnwindSafe for Tuple5<I1, I2, I3, I4, I5>
where\n I1: UnwindSafe,\n I2: UnwindSafe,\n I3: UnwindSafe,\n I4: UnwindSafe,\n I5: UnwindSafe,
",1,["wiwi::iter::tuple::Tuple5"]],["impl<I1, I2, I3, I4, I5, I6> UnwindSafe for Tuple6<I1, I2, I3, I4, I5, I6>
where\n I1: UnwindSafe,\n I2: UnwindSafe,\n I3: UnwindSafe,\n I4: UnwindSafe,\n I5: UnwindSafe,\n I6: UnwindSafe,
",1,["wiwi::iter::tuple::Tuple6"]],["impl<I1, I2, I3, I4, I5, I6, I7> UnwindSafe for Tuple7<I1, I2, I3, I4, I5, I6, I7>
where\n I1: UnwindSafe,\n I2: UnwindSafe,\n I3: UnwindSafe,\n I4: UnwindSafe,\n I5: UnwindSafe,\n I6: UnwindSafe,\n I7: UnwindSafe,
",1,["wiwi::iter::tuple::Tuple7"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8> UnwindSafe for Tuple8<I1, I2, I3, I4, I5, I6, I7, I8>
where\n I1: UnwindSafe,\n I2: UnwindSafe,\n I3: UnwindSafe,\n I4: UnwindSafe,\n I5: UnwindSafe,\n I6: UnwindSafe,\n I7: UnwindSafe,\n I8: UnwindSafe,
",1,["wiwi::iter::tuple::Tuple8"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9> UnwindSafe for Tuple9<I1, I2, I3, I4, I5, I6, I7, I8, I9>
where\n I1: UnwindSafe,\n I2: UnwindSafe,\n I3: UnwindSafe,\n I4: UnwindSafe,\n I5: UnwindSafe,\n I6: UnwindSafe,\n I7: UnwindSafe,\n I8: UnwindSafe,\n I9: UnwindSafe,
",1,["wiwi::iter::tuple::Tuple9"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10> UnwindSafe for Tuple10<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10>
where\n I1: UnwindSafe,\n I2: UnwindSafe,\n I3: UnwindSafe,\n I4: UnwindSafe,\n I5: UnwindSafe,\n I6: UnwindSafe,\n I7: UnwindSafe,\n I8: UnwindSafe,\n I9: UnwindSafe,\n I10: UnwindSafe,
",1,["wiwi::iter::tuple::Tuple10"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11> UnwindSafe for Tuple11<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11>
where\n I1: UnwindSafe,\n I2: UnwindSafe,\n I3: UnwindSafe,\n I4: UnwindSafe,\n I5: UnwindSafe,\n I6: UnwindSafe,\n I7: UnwindSafe,\n I8: UnwindSafe,\n I9: UnwindSafe,\n I10: UnwindSafe,\n I11: UnwindSafe,
",1,["wiwi::iter::tuple::Tuple11"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12> UnwindSafe for Tuple12<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12>
where\n I1: UnwindSafe,\n I2: UnwindSafe,\n I3: UnwindSafe,\n I4: UnwindSafe,\n I5: UnwindSafe,\n I6: UnwindSafe,\n I7: UnwindSafe,\n I8: UnwindSafe,\n I9: UnwindSafe,\n I10: UnwindSafe,\n I11: UnwindSafe,\n I12: UnwindSafe,
",1,["wiwi::iter::tuple::Tuple12"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13> UnwindSafe for Tuple13<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13>
where\n I1: UnwindSafe,\n I2: UnwindSafe,\n I3: UnwindSafe,\n I4: UnwindSafe,\n I5: UnwindSafe,\n I6: UnwindSafe,\n I7: UnwindSafe,\n I8: UnwindSafe,\n I9: UnwindSafe,\n I10: UnwindSafe,\n I11: UnwindSafe,\n I12: UnwindSafe,\n I13: UnwindSafe,
",1,["wiwi::iter::tuple::Tuple13"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14> UnwindSafe for Tuple14<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14>
where\n I1: UnwindSafe,\n I2: UnwindSafe,\n I3: UnwindSafe,\n I4: UnwindSafe,\n I5: UnwindSafe,\n I6: UnwindSafe,\n I7: UnwindSafe,\n I8: UnwindSafe,\n I9: UnwindSafe,\n I10: UnwindSafe,\n I11: UnwindSafe,\n I12: UnwindSafe,\n I13: UnwindSafe,\n I14: UnwindSafe,
",1,["wiwi::iter::tuple::Tuple14"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15> UnwindSafe for Tuple15<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15>
where\n I1: UnwindSafe,\n I2: UnwindSafe,\n I3: UnwindSafe,\n I4: UnwindSafe,\n I5: UnwindSafe,\n I6: UnwindSafe,\n I7: UnwindSafe,\n I8: UnwindSafe,\n I9: UnwindSafe,\n I10: UnwindSafe,\n I11: UnwindSafe,\n I12: UnwindSafe,\n I13: UnwindSafe,\n I14: UnwindSafe,\n I15: UnwindSafe,
",1,["wiwi::iter::tuple::Tuple15"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16> UnwindSafe for Tuple16<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16>
where\n I1: UnwindSafe,\n I2: UnwindSafe,\n I3: UnwindSafe,\n I4: UnwindSafe,\n I5: UnwindSafe,\n I6: UnwindSafe,\n I7: UnwindSafe,\n I8: UnwindSafe,\n I9: UnwindSafe,\n I10: UnwindSafe,\n I11: UnwindSafe,\n I12: UnwindSafe,\n I13: UnwindSafe,\n I14: UnwindSafe,\n I15: UnwindSafe,\n I16: UnwindSafe,
",1,["wiwi::iter::tuple::Tuple16"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17> UnwindSafe for Tuple17<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17>
where\n I1: UnwindSafe,\n I2: UnwindSafe,\n I3: UnwindSafe,\n I4: UnwindSafe,\n I5: UnwindSafe,\n I6: UnwindSafe,\n I7: UnwindSafe,\n I8: UnwindSafe,\n I9: UnwindSafe,\n I10: UnwindSafe,\n I11: UnwindSafe,\n I12: UnwindSafe,\n I13: UnwindSafe,\n I14: UnwindSafe,\n I15: UnwindSafe,\n I16: UnwindSafe,\n I17: UnwindSafe,
",1,["wiwi::iter::tuple::Tuple17"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18> UnwindSafe for Tuple18<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18>
where\n I1: UnwindSafe,\n I2: UnwindSafe,\n I3: UnwindSafe,\n I4: UnwindSafe,\n I5: UnwindSafe,\n I6: UnwindSafe,\n I7: UnwindSafe,\n I8: UnwindSafe,\n I9: UnwindSafe,\n I10: UnwindSafe,\n I11: UnwindSafe,\n I12: UnwindSafe,\n I13: UnwindSafe,\n I14: UnwindSafe,\n I15: UnwindSafe,\n I16: UnwindSafe,\n I17: UnwindSafe,\n I18: UnwindSafe,
",1,["wiwi::iter::tuple::Tuple18"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19> UnwindSafe for Tuple19<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19>
where\n I1: UnwindSafe,\n I2: UnwindSafe,\n I3: UnwindSafe,\n I4: UnwindSafe,\n I5: UnwindSafe,\n I6: UnwindSafe,\n I7: UnwindSafe,\n I8: UnwindSafe,\n I9: UnwindSafe,\n I10: UnwindSafe,\n I11: UnwindSafe,\n I12: UnwindSafe,\n I13: UnwindSafe,\n I14: UnwindSafe,\n I15: UnwindSafe,\n I16: UnwindSafe,\n I17: UnwindSafe,\n I18: UnwindSafe,\n I19: UnwindSafe,
",1,["wiwi::iter::tuple::Tuple19"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20> UnwindSafe for Tuple20<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20>
where\n I1: UnwindSafe,\n I2: UnwindSafe,\n I3: UnwindSafe,\n I4: UnwindSafe,\n I5: UnwindSafe,\n I6: UnwindSafe,\n I7: UnwindSafe,\n I8: UnwindSafe,\n I9: UnwindSafe,\n I10: UnwindSafe,\n I11: UnwindSafe,\n I12: UnwindSafe,\n I13: UnwindSafe,\n I14: UnwindSafe,\n I15: UnwindSafe,\n I16: UnwindSafe,\n I17: UnwindSafe,\n I18: UnwindSafe,\n I19: UnwindSafe,\n I20: UnwindSafe,
",1,["wiwi::iter::tuple::Tuple20"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21> UnwindSafe for Tuple21<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21>
where\n I1: UnwindSafe,\n I2: UnwindSafe,\n I3: UnwindSafe,\n I4: UnwindSafe,\n I5: UnwindSafe,\n I6: UnwindSafe,\n I7: UnwindSafe,\n I8: UnwindSafe,\n I9: UnwindSafe,\n I10: UnwindSafe,\n I11: UnwindSafe,\n I12: UnwindSafe,\n I13: UnwindSafe,\n I14: UnwindSafe,\n I15: UnwindSafe,\n I16: UnwindSafe,\n I17: UnwindSafe,\n I18: UnwindSafe,\n I19: UnwindSafe,\n I20: UnwindSafe,\n I21: UnwindSafe,
",1,["wiwi::iter::tuple::Tuple21"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22> UnwindSafe for Tuple22<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22>
where\n I1: UnwindSafe,\n I2: UnwindSafe,\n I3: UnwindSafe,\n I4: UnwindSafe,\n I5: UnwindSafe,\n I6: UnwindSafe,\n I7: UnwindSafe,\n I8: UnwindSafe,\n I9: UnwindSafe,\n I10: UnwindSafe,\n I11: UnwindSafe,\n I12: UnwindSafe,\n I13: UnwindSafe,\n I14: UnwindSafe,\n I15: UnwindSafe,\n I16: UnwindSafe,\n I17: UnwindSafe,\n I18: UnwindSafe,\n I19: UnwindSafe,\n I20: UnwindSafe,\n I21: UnwindSafe,\n I22: UnwindSafe,
",1,["wiwi::iter::tuple::Tuple22"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23> UnwindSafe for Tuple23<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23>
where\n I1: UnwindSafe,\n I2: UnwindSafe,\n I3: UnwindSafe,\n I4: UnwindSafe,\n I5: UnwindSafe,\n I6: UnwindSafe,\n I7: UnwindSafe,\n I8: UnwindSafe,\n I9: UnwindSafe,\n I10: UnwindSafe,\n I11: UnwindSafe,\n I12: UnwindSafe,\n I13: UnwindSafe,\n I14: UnwindSafe,\n I15: UnwindSafe,\n I16: UnwindSafe,\n I17: UnwindSafe,\n I18: UnwindSafe,\n I19: UnwindSafe,\n I20: UnwindSafe,\n I21: UnwindSafe,\n I22: UnwindSafe,\n I23: UnwindSafe,
",1,["wiwi::iter::tuple::Tuple23"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24> UnwindSafe for Tuple24<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24>
where\n I1: UnwindSafe,\n I2: UnwindSafe,\n I3: UnwindSafe,\n I4: UnwindSafe,\n I5: UnwindSafe,\n I6: UnwindSafe,\n I7: UnwindSafe,\n I8: UnwindSafe,\n I9: UnwindSafe,\n I10: UnwindSafe,\n I11: UnwindSafe,\n I12: UnwindSafe,\n I13: UnwindSafe,\n I14: UnwindSafe,\n I15: UnwindSafe,\n I16: UnwindSafe,\n I17: UnwindSafe,\n I18: UnwindSafe,\n I19: UnwindSafe,\n I20: UnwindSafe,\n I21: UnwindSafe,\n I22: UnwindSafe,\n I23: UnwindSafe,\n I24: UnwindSafe,
",1,["wiwi::iter::tuple::Tuple24"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24, I25> UnwindSafe for Tuple25<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24, I25>
where\n I1: UnwindSafe,\n I2: UnwindSafe,\n I3: UnwindSafe,\n I4: UnwindSafe,\n I5: UnwindSafe,\n I6: UnwindSafe,\n I7: UnwindSafe,\n I8: UnwindSafe,\n I9: UnwindSafe,\n I10: UnwindSafe,\n I11: UnwindSafe,\n I12: UnwindSafe,\n I13: UnwindSafe,\n I14: UnwindSafe,\n I15: UnwindSafe,\n I16: UnwindSafe,\n I17: UnwindSafe,\n I18: UnwindSafe,\n I19: UnwindSafe,\n I20: UnwindSafe,\n I21: UnwindSafe,\n I22: UnwindSafe,\n I23: UnwindSafe,\n I24: UnwindSafe,\n I25: UnwindSafe,
",1,["wiwi::iter::tuple::Tuple25"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24, I25, I26> UnwindSafe for Tuple26<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24, I25, I26>
where\n I1: UnwindSafe,\n I2: UnwindSafe,\n I3: UnwindSafe,\n I4: UnwindSafe,\n I5: UnwindSafe,\n I6: UnwindSafe,\n I7: UnwindSafe,\n I8: UnwindSafe,\n I9: UnwindSafe,\n I10: UnwindSafe,\n I11: UnwindSafe,\n I12: UnwindSafe,\n I13: UnwindSafe,\n I14: UnwindSafe,\n I15: UnwindSafe,\n I16: UnwindSafe,\n I17: UnwindSafe,\n I18: UnwindSafe,\n I19: UnwindSafe,\n I20: UnwindSafe,\n I21: UnwindSafe,\n I22: UnwindSafe,\n I23: UnwindSafe,\n I24: UnwindSafe,\n I25: UnwindSafe,\n I26: UnwindSafe,
",1,["wiwi::iter::tuple::Tuple26"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24, I25, I26, I27> UnwindSafe for Tuple27<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24, I25, I26, I27>
where\n I1: UnwindSafe,\n I2: UnwindSafe,\n I3: UnwindSafe,\n I4: UnwindSafe,\n I5: UnwindSafe,\n I6: UnwindSafe,\n I7: UnwindSafe,\n I8: UnwindSafe,\n I9: UnwindSafe,\n I10: UnwindSafe,\n I11: UnwindSafe,\n I12: UnwindSafe,\n I13: UnwindSafe,\n I14: UnwindSafe,\n I15: UnwindSafe,\n I16: UnwindSafe,\n I17: UnwindSafe,\n I18: UnwindSafe,\n I19: UnwindSafe,\n I20: UnwindSafe,\n I21: UnwindSafe,\n I22: UnwindSafe,\n I23: UnwindSafe,\n I24: UnwindSafe,\n I25: UnwindSafe,\n I26: UnwindSafe,\n I27: UnwindSafe,
",1,["wiwi::iter::tuple::Tuple27"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24, I25, I26, I27, I28> UnwindSafe for Tuple28<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24, I25, I26, I27, I28>
where\n I1: UnwindSafe,\n I2: UnwindSafe,\n I3: UnwindSafe,\n I4: UnwindSafe,\n I5: UnwindSafe,\n I6: UnwindSafe,\n I7: UnwindSafe,\n I8: UnwindSafe,\n I9: UnwindSafe,\n I10: UnwindSafe,\n I11: UnwindSafe,\n I12: UnwindSafe,\n I13: UnwindSafe,\n I14: UnwindSafe,\n I15: UnwindSafe,\n I16: UnwindSafe,\n I17: UnwindSafe,\n I18: UnwindSafe,\n I19: UnwindSafe,\n I20: UnwindSafe,\n I21: UnwindSafe,\n I22: UnwindSafe,\n I23: UnwindSafe,\n I24: UnwindSafe,\n I25: UnwindSafe,\n I26: UnwindSafe,\n I27: UnwindSafe,\n I28: UnwindSafe,
",1,["wiwi::iter::tuple::Tuple28"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24, I25, I26, I27, I28, I29> UnwindSafe for Tuple29<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24, I25, I26, I27, I28, I29>
where\n I1: UnwindSafe,\n I2: UnwindSafe,\n I3: UnwindSafe,\n I4: UnwindSafe,\n I5: UnwindSafe,\n I6: UnwindSafe,\n I7: UnwindSafe,\n I8: UnwindSafe,\n I9: UnwindSafe,\n I10: UnwindSafe,\n I11: UnwindSafe,\n I12: UnwindSafe,\n I13: UnwindSafe,\n I14: UnwindSafe,\n I15: UnwindSafe,\n I16: UnwindSafe,\n I17: UnwindSafe,\n I18: UnwindSafe,\n I19: UnwindSafe,\n I20: UnwindSafe,\n I21: UnwindSafe,\n I22: UnwindSafe,\n I23: UnwindSafe,\n I24: UnwindSafe,\n I25: UnwindSafe,\n I26: UnwindSafe,\n I27: UnwindSafe,\n I28: UnwindSafe,\n I29: UnwindSafe,
",1,["wiwi::iter::tuple::Tuple29"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24, I25, I26, I27, I28, I29, I30> UnwindSafe for Tuple30<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24, I25, I26, I27, I28, I29, I30>
where\n I1: UnwindSafe,\n I2: UnwindSafe,\n I3: UnwindSafe,\n I4: UnwindSafe,\n I5: UnwindSafe,\n I6: UnwindSafe,\n I7: UnwindSafe,\n I8: UnwindSafe,\n I9: UnwindSafe,\n I10: UnwindSafe,\n I11: UnwindSafe,\n I12: UnwindSafe,\n I13: UnwindSafe,\n I14: UnwindSafe,\n I15: UnwindSafe,\n I16: UnwindSafe,\n I17: UnwindSafe,\n I18: UnwindSafe,\n I19: UnwindSafe,\n I20: UnwindSafe,\n I21: UnwindSafe,\n I22: UnwindSafe,\n I23: UnwindSafe,\n I24: UnwindSafe,\n I25: UnwindSafe,\n I26: UnwindSafe,\n I27: UnwindSafe,\n I28: UnwindSafe,\n I29: UnwindSafe,\n I30: UnwindSafe,
",1,["wiwi::iter::tuple::Tuple30"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24, I25, I26, I27, I28, I29, I30, I31> UnwindSafe for Tuple31<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24, I25, I26, I27, I28, I29, I30, I31>
where\n I1: UnwindSafe,\n I2: UnwindSafe,\n I3: UnwindSafe,\n I4: UnwindSafe,\n I5: UnwindSafe,\n I6: UnwindSafe,\n I7: UnwindSafe,\n I8: UnwindSafe,\n I9: UnwindSafe,\n I10: UnwindSafe,\n I11: UnwindSafe,\n I12: UnwindSafe,\n I13: UnwindSafe,\n I14: UnwindSafe,\n I15: UnwindSafe,\n I16: UnwindSafe,\n I17: UnwindSafe,\n I18: UnwindSafe,\n I19: UnwindSafe,\n I20: UnwindSafe,\n I21: UnwindSafe,\n I22: UnwindSafe,\n I23: UnwindSafe,\n I24: UnwindSafe,\n I25: UnwindSafe,\n I26: UnwindSafe,\n I27: UnwindSafe,\n I28: UnwindSafe,\n I29: UnwindSafe,\n I30: UnwindSafe,\n I31: UnwindSafe,
",1,["wiwi::iter::tuple::Tuple31"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24, I25, I26, I27, I28, I29, I30, I31, I32> UnwindSafe for Tuple32<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24, I25, I26, I27, I28, I29, I30, I31, I32>
where\n I1: UnwindSafe,\n I2: UnwindSafe,\n I3: UnwindSafe,\n I4: UnwindSafe,\n I5: UnwindSafe,\n I6: UnwindSafe,\n I7: UnwindSafe,\n I8: UnwindSafe,\n I9: UnwindSafe,\n I10: UnwindSafe,\n I11: UnwindSafe,\n I12: UnwindSafe,\n I13: UnwindSafe,\n I14: UnwindSafe,\n I15: UnwindSafe,\n I16: UnwindSafe,\n I17: UnwindSafe,\n I18: UnwindSafe,\n I19: UnwindSafe,\n I20: UnwindSafe,\n I21: UnwindSafe,\n I22: UnwindSafe,\n I23: UnwindSafe,\n I24: UnwindSafe,\n I25: UnwindSafe,\n I26: UnwindSafe,\n I27: UnwindSafe,\n I28: UnwindSafe,\n I29: UnwindSafe,\n I30: UnwindSafe,\n I31: UnwindSafe,\n I32: UnwindSafe,
",1,["wiwi::iter::tuple::Tuple32"]],["impl<K, V> UnwindSafe for BTreeMapChain<K, V>
where\n K: RefUnwindSafe,\n V: RefUnwindSafe,
",1,["wiwi::chainer::btree_map::BTreeMapChain"]],["impl<K, V, S> UnwindSafe for HashMapChain<K, V, S>
where\n K: UnwindSafe,\n V: UnwindSafe,\n S: UnwindSafe,
",1,["wiwi::chainer::hash_map::HashMapChain"]],["impl<P> UnwindSafe for String<P>
where\n <P as Pool>::Raw: UnwindSafe,\n P: UnwindSafe,
",1,["wiwi::string_pool::string::String"]],["impl<T> UnwindSafe for BTreeSetChain<T>
where\n T: RefUnwindSafe,
",1,["wiwi::chainer::btree_set::BTreeSetChain"]],["impl<T> UnwindSafe for BinaryHeapChain<T>
where\n T: UnwindSafe,
",1,["wiwi::chainer::binary_heap::BinaryHeapChain"]],["impl<T> UnwindSafe for LinkedListChain<T>
where\n T: RefUnwindSafe + UnwindSafe,
",1,["wiwi::chainer::linked_list::LinkedListChain"]],["impl<T> UnwindSafe for SliceBoxChain<T>
where\n T: UnwindSafe,
",1,["wiwi::chainer::slice_box::SliceBoxChain"]],["impl<T> UnwindSafe for VecChain<T>
where\n T: UnwindSafe,
",1,["wiwi::chainer::vec::VecChain"]],["impl<T> UnwindSafe for VecDequeChain<T>
where\n T: UnwindSafe,
",1,["wiwi::chainer::vec_deque::VecDequeChain"]],["impl<T> UnwindSafe for Empty<T>
where\n T: UnwindSafe,
",1,["wiwi::iter::empty::Empty"]],["impl<T, F> UnwindSafe for LazyWrapState<T, F>
where\n T: UnwindSafe,\n F: UnwindSafe,
",1,["wiwi::lazy_wrap::LazyWrapState"]],["impl<T, F> UnwindSafe for LazyWrap<T, F>
where\n T: UnwindSafe,\n F: UnwindSafe,
"],["impl<T, S> UnwindSafe for HashSetChain<T, S>
where\n S: UnwindSafe,\n T: UnwindSafe,
",1,["wiwi::chainer::hash_set::HashSetChain"]],["impl<T, const N: usize> UnwindSafe for ArrayChain<T, N>
where\n T: UnwindSafe,
",1,["wiwi::chainer::array::ArrayChain"]]] +"wiwi":[["impl !UnwindSafe for IDGenerator",1,["wiwi::id::IDGenerator"]],["impl !UnwindSafe for Script",1,["wiwi::lsl::callback_api::script::Script"]],["impl !UnwindSafe for ScriptBuilder",1,["wiwi::lsl::callback_api::script::ScriptBuilder"]],["impl UnwindSafe for DecodeError",1,["wiwi::hex::DecodeError"]],["impl UnwindSafe for SizeHintBound",1,["wiwi::iter::size_hint::SizeHintBound"]],["impl UnwindSafe for Error",1,["wiwi::serialiser::error::Error"]],["impl UnwindSafe for DecodeError",1,["wiwi::z85::DecodeError"]],["impl UnwindSafe for Error",1,["wiwi::auth::error::Error"]],["impl UnwindSafe for ClientContinuerS1",1,["wiwi::auth::flow::signin::ClientContinuerS1"]],["impl UnwindSafe for ClientContinuerS2",1,["wiwi::auth::flow::signin::ClientContinuerS2"]],["impl UnwindSafe for ClientContinuerS3",1,["wiwi::auth::flow::signin::ClientContinuerS3"]],["impl UnwindSafe for ServerS2Params",1,["wiwi::auth::flow::signin::ServerS2Params"]],["impl UnwindSafe for ServerS3Params",1,["wiwi::auth::flow::signin::ServerS3Params"]],["impl UnwindSafe for SigninRequestS1",1,["wiwi::auth::flow::signin::SigninRequestS1"]],["impl UnwindSafe for SigninRequestS2",1,["wiwi::auth::flow::signin::SigninRequestS2"]],["impl UnwindSafe for SigninRequestS3",1,["wiwi::auth::flow::signin::SigninRequestS3"]],["impl UnwindSafe for SigninResponseS1",1,["wiwi::auth::flow::signin::SigninResponseS1"]],["impl UnwindSafe for SigninResponseS2",1,["wiwi::auth::flow::signin::SigninResponseS2"]],["impl UnwindSafe for SigninResponseS3",1,["wiwi::auth::flow::signin::SigninResponseS3"]],["impl UnwindSafe for SignupRequest",1,["wiwi::auth::flow::signup::SignupRequest"]],["impl UnwindSafe for StoredUnverifiedUserData",1,["wiwi::auth::flow::signup::StoredUnverifiedUserData"]],["impl UnwindSafe for U320",1,["wiwi::bigint::U320"]],["impl UnwindSafe for Encoder",1,["wiwi::bitstream::Encoder"]],["impl UnwindSafe for BitstreamEncoderChain",1,["wiwi::chainer::bitstream::BitstreamEncoderChain"]],["impl UnwindSafe for StrBoxChain",1,["wiwi::chainer::str_box::StrBoxChain"]],["impl UnwindSafe for StringChain",1,["wiwi::chainer::string::StringChain"]],["impl UnwindSafe for Builder",1,["wiwi::clock_timer::builder::Builder"]],["impl UnwindSafe for BuilderWithEnd",1,["wiwi::clock_timer::builder::BuilderWithEnd"]],["impl UnwindSafe for BuilderWithInterval",1,["wiwi::clock_timer::builder::BuilderWithInterval"]],["impl UnwindSafe for BuilderWithStart",1,["wiwi::clock_timer::builder::BuilderWithStart"]],["impl UnwindSafe for ClockTimer",1,["wiwi::clock_timer::ClockTimer"]],["impl UnwindSafe for Tick",1,["wiwi::clock_timer::Tick"]],["impl UnwindSafe for GeneratedID",1,["wiwi::id::GeneratedID"]],["impl UnwindSafe for SizeHint",1,["wiwi::iter::size_hint::SizeHint"]],["impl UnwindSafe for Marker",1,["wiwi::serialiser::marker::Marker"]],["impl UnwindSafe for SerialiseOptions",1,["wiwi::serialiser::serialise::SerialiseOptions"]],["impl UnwindSafe for GlobalPool",1,["wiwi::string_pool::pool::global::GlobalPool"]],["impl UnwindSafe for Board",1,["wiwi::sudoku::Board"]],["impl<'h> !UnwindSafe for StrMutChain<'h>",1,["wiwi::chainer::str_mut::StrMutChain"]],["impl<'h> !UnwindSafe for StringMutChain<'h>",1,["wiwi::chainer::string_mut::StringMutChain"]],["impl<'h> UnwindSafe for StrRefChain<'h>",1,["wiwi::chainer::str_ref::StrRefChain"]],["impl<'h> UnwindSafe for StringRefChain<'h>",1,["wiwi::chainer::string_ref::StringRefChain"]],["impl<'h> UnwindSafe for SlicesWrap<'h>",1,["wiwi::string_pool::pool::SlicesWrap"]],["impl<'h> UnwindSafe for SlicesWrapIter<'h>",1,["wiwi::string_pool::pool::SlicesWrapIter"]],["impl<'h, T> !UnwindSafe for SliceMutChain<'h, T>",1,["wiwi::chainer::slice_mut::SliceMutChain"]],["impl<'h, T> !UnwindSafe for VecMutChain<'h, T>",1,["wiwi::chainer::vec_mut::VecMutChain"]],["impl<'h, T> UnwindSafe for SliceRefChain<'h, T>
where\n T: RefUnwindSafe,
",1,["wiwi::chainer::slice_ref::SliceRefChain"]],["impl<'h, T> UnwindSafe for VecRefChain<'h, T>
where\n T: RefUnwindSafe,
",1,["wiwi::chainer::vec_ref::VecRefChain"]],["impl<'h, T, const N: usize> !UnwindSafe for ArrayMutChain<'h, T, N>",1,["wiwi::chainer::array_mut::ArrayMutChain"]],["impl<'h, T, const N: usize> UnwindSafe for ArrayRefChain<'h, T, N>
where\n T: RefUnwindSafe,
",1,["wiwi::chainer::array_ref::ArrayRefChain"]],["impl<F> UnwindSafe for FromFn<F>
where\n F: UnwindSafe,
",1,["wiwi::iter::from_fn::FromFn"]],["impl<I> UnwindSafe for IterAdapter<I>
where\n I: UnwindSafe,
",1,["wiwi::iter::adapter::IterAdapter"]],["impl<I> UnwindSafe for RepeatPerItem<I>
where\n I: UnwindSafe,\n <I as Iter>::Item: UnwindSafe,
",1,["wiwi::iter::repeat_per_item::RepeatPerItem"]],["impl<I> UnwindSafe for Rev<I>
where\n I: UnwindSafe,
",1,["wiwi::iter::rev::Rev"]],["impl<I, F> UnwindSafe for Map<I, F>
where\n I: UnwindSafe,\n F: UnwindSafe,
",1,["wiwi::iter::map::Map"]],["impl<I, T> UnwindSafe for Peek<I, T>
where\n I: UnwindSafe,\n T: UnwindSafe,
",1,["wiwi::iter::peek::Peek"]],["impl<I1> UnwindSafe for Tuple1<I1>
where\n I1: UnwindSafe,
",1,["wiwi::iter::tuple::Tuple1"]],["impl<I1, I2> UnwindSafe for Tuple2<I1, I2>
where\n I1: UnwindSafe,\n I2: UnwindSafe,
",1,["wiwi::iter::tuple::Tuple2"]],["impl<I1, I2, I3> UnwindSafe for Tuple3<I1, I2, I3>
where\n I1: UnwindSafe,\n I2: UnwindSafe,\n I3: UnwindSafe,
",1,["wiwi::iter::tuple::Tuple3"]],["impl<I1, I2, I3, I4> UnwindSafe for Tuple4<I1, I2, I3, I4>
where\n I1: UnwindSafe,\n I2: UnwindSafe,\n I3: UnwindSafe,\n I4: UnwindSafe,
",1,["wiwi::iter::tuple::Tuple4"]],["impl<I1, I2, I3, I4, I5> UnwindSafe for Tuple5<I1, I2, I3, I4, I5>
where\n I1: UnwindSafe,\n I2: UnwindSafe,\n I3: UnwindSafe,\n I4: UnwindSafe,\n I5: UnwindSafe,
",1,["wiwi::iter::tuple::Tuple5"]],["impl<I1, I2, I3, I4, I5, I6> UnwindSafe for Tuple6<I1, I2, I3, I4, I5, I6>
where\n I1: UnwindSafe,\n I2: UnwindSafe,\n I3: UnwindSafe,\n I4: UnwindSafe,\n I5: UnwindSafe,\n I6: UnwindSafe,
",1,["wiwi::iter::tuple::Tuple6"]],["impl<I1, I2, I3, I4, I5, I6, I7> UnwindSafe for Tuple7<I1, I2, I3, I4, I5, I6, I7>
where\n I1: UnwindSafe,\n I2: UnwindSafe,\n I3: UnwindSafe,\n I4: UnwindSafe,\n I5: UnwindSafe,\n I6: UnwindSafe,\n I7: UnwindSafe,
",1,["wiwi::iter::tuple::Tuple7"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8> UnwindSafe for Tuple8<I1, I2, I3, I4, I5, I6, I7, I8>
where\n I1: UnwindSafe,\n I2: UnwindSafe,\n I3: UnwindSafe,\n I4: UnwindSafe,\n I5: UnwindSafe,\n I6: UnwindSafe,\n I7: UnwindSafe,\n I8: UnwindSafe,
",1,["wiwi::iter::tuple::Tuple8"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9> UnwindSafe for Tuple9<I1, I2, I3, I4, I5, I6, I7, I8, I9>
where\n I1: UnwindSafe,\n I2: UnwindSafe,\n I3: UnwindSafe,\n I4: UnwindSafe,\n I5: UnwindSafe,\n I6: UnwindSafe,\n I7: UnwindSafe,\n I8: UnwindSafe,\n I9: UnwindSafe,
",1,["wiwi::iter::tuple::Tuple9"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10> UnwindSafe for Tuple10<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10>
where\n I1: UnwindSafe,\n I2: UnwindSafe,\n I3: UnwindSafe,\n I4: UnwindSafe,\n I5: UnwindSafe,\n I6: UnwindSafe,\n I7: UnwindSafe,\n I8: UnwindSafe,\n I9: UnwindSafe,\n I10: UnwindSafe,
",1,["wiwi::iter::tuple::Tuple10"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11> UnwindSafe for Tuple11<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11>
where\n I1: UnwindSafe,\n I2: UnwindSafe,\n I3: UnwindSafe,\n I4: UnwindSafe,\n I5: UnwindSafe,\n I6: UnwindSafe,\n I7: UnwindSafe,\n I8: UnwindSafe,\n I9: UnwindSafe,\n I10: UnwindSafe,\n I11: UnwindSafe,
",1,["wiwi::iter::tuple::Tuple11"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12> UnwindSafe for Tuple12<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12>
where\n I1: UnwindSafe,\n I2: UnwindSafe,\n I3: UnwindSafe,\n I4: UnwindSafe,\n I5: UnwindSafe,\n I6: UnwindSafe,\n I7: UnwindSafe,\n I8: UnwindSafe,\n I9: UnwindSafe,\n I10: UnwindSafe,\n I11: UnwindSafe,\n I12: UnwindSafe,
",1,["wiwi::iter::tuple::Tuple12"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13> UnwindSafe for Tuple13<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13>
where\n I1: UnwindSafe,\n I2: UnwindSafe,\n I3: UnwindSafe,\n I4: UnwindSafe,\n I5: UnwindSafe,\n I6: UnwindSafe,\n I7: UnwindSafe,\n I8: UnwindSafe,\n I9: UnwindSafe,\n I10: UnwindSafe,\n I11: UnwindSafe,\n I12: UnwindSafe,\n I13: UnwindSafe,
",1,["wiwi::iter::tuple::Tuple13"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14> UnwindSafe for Tuple14<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14>
where\n I1: UnwindSafe,\n I2: UnwindSafe,\n I3: UnwindSafe,\n I4: UnwindSafe,\n I5: UnwindSafe,\n I6: UnwindSafe,\n I7: UnwindSafe,\n I8: UnwindSafe,\n I9: UnwindSafe,\n I10: UnwindSafe,\n I11: UnwindSafe,\n I12: UnwindSafe,\n I13: UnwindSafe,\n I14: UnwindSafe,
",1,["wiwi::iter::tuple::Tuple14"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15> UnwindSafe for Tuple15<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15>
where\n I1: UnwindSafe,\n I2: UnwindSafe,\n I3: UnwindSafe,\n I4: UnwindSafe,\n I5: UnwindSafe,\n I6: UnwindSafe,\n I7: UnwindSafe,\n I8: UnwindSafe,\n I9: UnwindSafe,\n I10: UnwindSafe,\n I11: UnwindSafe,\n I12: UnwindSafe,\n I13: UnwindSafe,\n I14: UnwindSafe,\n I15: UnwindSafe,
",1,["wiwi::iter::tuple::Tuple15"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16> UnwindSafe for Tuple16<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16>
where\n I1: UnwindSafe,\n I2: UnwindSafe,\n I3: UnwindSafe,\n I4: UnwindSafe,\n I5: UnwindSafe,\n I6: UnwindSafe,\n I7: UnwindSafe,\n I8: UnwindSafe,\n I9: UnwindSafe,\n I10: UnwindSafe,\n I11: UnwindSafe,\n I12: UnwindSafe,\n I13: UnwindSafe,\n I14: UnwindSafe,\n I15: UnwindSafe,\n I16: UnwindSafe,
",1,["wiwi::iter::tuple::Tuple16"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17> UnwindSafe for Tuple17<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17>
where\n I1: UnwindSafe,\n I2: UnwindSafe,\n I3: UnwindSafe,\n I4: UnwindSafe,\n I5: UnwindSafe,\n I6: UnwindSafe,\n I7: UnwindSafe,\n I8: UnwindSafe,\n I9: UnwindSafe,\n I10: UnwindSafe,\n I11: UnwindSafe,\n I12: UnwindSafe,\n I13: UnwindSafe,\n I14: UnwindSafe,\n I15: UnwindSafe,\n I16: UnwindSafe,\n I17: UnwindSafe,
",1,["wiwi::iter::tuple::Tuple17"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18> UnwindSafe for Tuple18<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18>
where\n I1: UnwindSafe,\n I2: UnwindSafe,\n I3: UnwindSafe,\n I4: UnwindSafe,\n I5: UnwindSafe,\n I6: UnwindSafe,\n I7: UnwindSafe,\n I8: UnwindSafe,\n I9: UnwindSafe,\n I10: UnwindSafe,\n I11: UnwindSafe,\n I12: UnwindSafe,\n I13: UnwindSafe,\n I14: UnwindSafe,\n I15: UnwindSafe,\n I16: UnwindSafe,\n I17: UnwindSafe,\n I18: UnwindSafe,
",1,["wiwi::iter::tuple::Tuple18"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19> UnwindSafe for Tuple19<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19>
where\n I1: UnwindSafe,\n I2: UnwindSafe,\n I3: UnwindSafe,\n I4: UnwindSafe,\n I5: UnwindSafe,\n I6: UnwindSafe,\n I7: UnwindSafe,\n I8: UnwindSafe,\n I9: UnwindSafe,\n I10: UnwindSafe,\n I11: UnwindSafe,\n I12: UnwindSafe,\n I13: UnwindSafe,\n I14: UnwindSafe,\n I15: UnwindSafe,\n I16: UnwindSafe,\n I17: UnwindSafe,\n I18: UnwindSafe,\n I19: UnwindSafe,
",1,["wiwi::iter::tuple::Tuple19"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20> UnwindSafe for Tuple20<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20>
where\n I1: UnwindSafe,\n I2: UnwindSafe,\n I3: UnwindSafe,\n I4: UnwindSafe,\n I5: UnwindSafe,\n I6: UnwindSafe,\n I7: UnwindSafe,\n I8: UnwindSafe,\n I9: UnwindSafe,\n I10: UnwindSafe,\n I11: UnwindSafe,\n I12: UnwindSafe,\n I13: UnwindSafe,\n I14: UnwindSafe,\n I15: UnwindSafe,\n I16: UnwindSafe,\n I17: UnwindSafe,\n I18: UnwindSafe,\n I19: UnwindSafe,\n I20: UnwindSafe,
",1,["wiwi::iter::tuple::Tuple20"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21> UnwindSafe for Tuple21<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21>
where\n I1: UnwindSafe,\n I2: UnwindSafe,\n I3: UnwindSafe,\n I4: UnwindSafe,\n I5: UnwindSafe,\n I6: UnwindSafe,\n I7: UnwindSafe,\n I8: UnwindSafe,\n I9: UnwindSafe,\n I10: UnwindSafe,\n I11: UnwindSafe,\n I12: UnwindSafe,\n I13: UnwindSafe,\n I14: UnwindSafe,\n I15: UnwindSafe,\n I16: UnwindSafe,\n I17: UnwindSafe,\n I18: UnwindSafe,\n I19: UnwindSafe,\n I20: UnwindSafe,\n I21: UnwindSafe,
",1,["wiwi::iter::tuple::Tuple21"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22> UnwindSafe for Tuple22<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22>
where\n I1: UnwindSafe,\n I2: UnwindSafe,\n I3: UnwindSafe,\n I4: UnwindSafe,\n I5: UnwindSafe,\n I6: UnwindSafe,\n I7: UnwindSafe,\n I8: UnwindSafe,\n I9: UnwindSafe,\n I10: UnwindSafe,\n I11: UnwindSafe,\n I12: UnwindSafe,\n I13: UnwindSafe,\n I14: UnwindSafe,\n I15: UnwindSafe,\n I16: UnwindSafe,\n I17: UnwindSafe,\n I18: UnwindSafe,\n I19: UnwindSafe,\n I20: UnwindSafe,\n I21: UnwindSafe,\n I22: UnwindSafe,
",1,["wiwi::iter::tuple::Tuple22"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23> UnwindSafe for Tuple23<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23>
where\n I1: UnwindSafe,\n I2: UnwindSafe,\n I3: UnwindSafe,\n I4: UnwindSafe,\n I5: UnwindSafe,\n I6: UnwindSafe,\n I7: UnwindSafe,\n I8: UnwindSafe,\n I9: UnwindSafe,\n I10: UnwindSafe,\n I11: UnwindSafe,\n I12: UnwindSafe,\n I13: UnwindSafe,\n I14: UnwindSafe,\n I15: UnwindSafe,\n I16: UnwindSafe,\n I17: UnwindSafe,\n I18: UnwindSafe,\n I19: UnwindSafe,\n I20: UnwindSafe,\n I21: UnwindSafe,\n I22: UnwindSafe,\n I23: UnwindSafe,
",1,["wiwi::iter::tuple::Tuple23"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24> UnwindSafe for Tuple24<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24>
where\n I1: UnwindSafe,\n I2: UnwindSafe,\n I3: UnwindSafe,\n I4: UnwindSafe,\n I5: UnwindSafe,\n I6: UnwindSafe,\n I7: UnwindSafe,\n I8: UnwindSafe,\n I9: UnwindSafe,\n I10: UnwindSafe,\n I11: UnwindSafe,\n I12: UnwindSafe,\n I13: UnwindSafe,\n I14: UnwindSafe,\n I15: UnwindSafe,\n I16: UnwindSafe,\n I17: UnwindSafe,\n I18: UnwindSafe,\n I19: UnwindSafe,\n I20: UnwindSafe,\n I21: UnwindSafe,\n I22: UnwindSafe,\n I23: UnwindSafe,\n I24: UnwindSafe,
",1,["wiwi::iter::tuple::Tuple24"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24, I25> UnwindSafe for Tuple25<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24, I25>
where\n I1: UnwindSafe,\n I2: UnwindSafe,\n I3: UnwindSafe,\n I4: UnwindSafe,\n I5: UnwindSafe,\n I6: UnwindSafe,\n I7: UnwindSafe,\n I8: UnwindSafe,\n I9: UnwindSafe,\n I10: UnwindSafe,\n I11: UnwindSafe,\n I12: UnwindSafe,\n I13: UnwindSafe,\n I14: UnwindSafe,\n I15: UnwindSafe,\n I16: UnwindSafe,\n I17: UnwindSafe,\n I18: UnwindSafe,\n I19: UnwindSafe,\n I20: UnwindSafe,\n I21: UnwindSafe,\n I22: UnwindSafe,\n I23: UnwindSafe,\n I24: UnwindSafe,\n I25: UnwindSafe,
",1,["wiwi::iter::tuple::Tuple25"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24, I25, I26> UnwindSafe for Tuple26<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24, I25, I26>
where\n I1: UnwindSafe,\n I2: UnwindSafe,\n I3: UnwindSafe,\n I4: UnwindSafe,\n I5: UnwindSafe,\n I6: UnwindSafe,\n I7: UnwindSafe,\n I8: UnwindSafe,\n I9: UnwindSafe,\n I10: UnwindSafe,\n I11: UnwindSafe,\n I12: UnwindSafe,\n I13: UnwindSafe,\n I14: UnwindSafe,\n I15: UnwindSafe,\n I16: UnwindSafe,\n I17: UnwindSafe,\n I18: UnwindSafe,\n I19: UnwindSafe,\n I20: UnwindSafe,\n I21: UnwindSafe,\n I22: UnwindSafe,\n I23: UnwindSafe,\n I24: UnwindSafe,\n I25: UnwindSafe,\n I26: UnwindSafe,
",1,["wiwi::iter::tuple::Tuple26"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24, I25, I26, I27> UnwindSafe for Tuple27<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24, I25, I26, I27>
where\n I1: UnwindSafe,\n I2: UnwindSafe,\n I3: UnwindSafe,\n I4: UnwindSafe,\n I5: UnwindSafe,\n I6: UnwindSafe,\n I7: UnwindSafe,\n I8: UnwindSafe,\n I9: UnwindSafe,\n I10: UnwindSafe,\n I11: UnwindSafe,\n I12: UnwindSafe,\n I13: UnwindSafe,\n I14: UnwindSafe,\n I15: UnwindSafe,\n I16: UnwindSafe,\n I17: UnwindSafe,\n I18: UnwindSafe,\n I19: UnwindSafe,\n I20: UnwindSafe,\n I21: UnwindSafe,\n I22: UnwindSafe,\n I23: UnwindSafe,\n I24: UnwindSafe,\n I25: UnwindSafe,\n I26: UnwindSafe,\n I27: UnwindSafe,
",1,["wiwi::iter::tuple::Tuple27"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24, I25, I26, I27, I28> UnwindSafe for Tuple28<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24, I25, I26, I27, I28>
where\n I1: UnwindSafe,\n I2: UnwindSafe,\n I3: UnwindSafe,\n I4: UnwindSafe,\n I5: UnwindSafe,\n I6: UnwindSafe,\n I7: UnwindSafe,\n I8: UnwindSafe,\n I9: UnwindSafe,\n I10: UnwindSafe,\n I11: UnwindSafe,\n I12: UnwindSafe,\n I13: UnwindSafe,\n I14: UnwindSafe,\n I15: UnwindSafe,\n I16: UnwindSafe,\n I17: UnwindSafe,\n I18: UnwindSafe,\n I19: UnwindSafe,\n I20: UnwindSafe,\n I21: UnwindSafe,\n I22: UnwindSafe,\n I23: UnwindSafe,\n I24: UnwindSafe,\n I25: UnwindSafe,\n I26: UnwindSafe,\n I27: UnwindSafe,\n I28: UnwindSafe,
",1,["wiwi::iter::tuple::Tuple28"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24, I25, I26, I27, I28, I29> UnwindSafe for Tuple29<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24, I25, I26, I27, I28, I29>
where\n I1: UnwindSafe,\n I2: UnwindSafe,\n I3: UnwindSafe,\n I4: UnwindSafe,\n I5: UnwindSafe,\n I6: UnwindSafe,\n I7: UnwindSafe,\n I8: UnwindSafe,\n I9: UnwindSafe,\n I10: UnwindSafe,\n I11: UnwindSafe,\n I12: UnwindSafe,\n I13: UnwindSafe,\n I14: UnwindSafe,\n I15: UnwindSafe,\n I16: UnwindSafe,\n I17: UnwindSafe,\n I18: UnwindSafe,\n I19: UnwindSafe,\n I20: UnwindSafe,\n I21: UnwindSafe,\n I22: UnwindSafe,\n I23: UnwindSafe,\n I24: UnwindSafe,\n I25: UnwindSafe,\n I26: UnwindSafe,\n I27: UnwindSafe,\n I28: UnwindSafe,\n I29: UnwindSafe,
",1,["wiwi::iter::tuple::Tuple29"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24, I25, I26, I27, I28, I29, I30> UnwindSafe for Tuple30<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24, I25, I26, I27, I28, I29, I30>
where\n I1: UnwindSafe,\n I2: UnwindSafe,\n I3: UnwindSafe,\n I4: UnwindSafe,\n I5: UnwindSafe,\n I6: UnwindSafe,\n I7: UnwindSafe,\n I8: UnwindSafe,\n I9: UnwindSafe,\n I10: UnwindSafe,\n I11: UnwindSafe,\n I12: UnwindSafe,\n I13: UnwindSafe,\n I14: UnwindSafe,\n I15: UnwindSafe,\n I16: UnwindSafe,\n I17: UnwindSafe,\n I18: UnwindSafe,\n I19: UnwindSafe,\n I20: UnwindSafe,\n I21: UnwindSafe,\n I22: UnwindSafe,\n I23: UnwindSafe,\n I24: UnwindSafe,\n I25: UnwindSafe,\n I26: UnwindSafe,\n I27: UnwindSafe,\n I28: UnwindSafe,\n I29: UnwindSafe,\n I30: UnwindSafe,
",1,["wiwi::iter::tuple::Tuple30"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24, I25, I26, I27, I28, I29, I30, I31> UnwindSafe for Tuple31<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24, I25, I26, I27, I28, I29, I30, I31>
where\n I1: UnwindSafe,\n I2: UnwindSafe,\n I3: UnwindSafe,\n I4: UnwindSafe,\n I5: UnwindSafe,\n I6: UnwindSafe,\n I7: UnwindSafe,\n I8: UnwindSafe,\n I9: UnwindSafe,\n I10: UnwindSafe,\n I11: UnwindSafe,\n I12: UnwindSafe,\n I13: UnwindSafe,\n I14: UnwindSafe,\n I15: UnwindSafe,\n I16: UnwindSafe,\n I17: UnwindSafe,\n I18: UnwindSafe,\n I19: UnwindSafe,\n I20: UnwindSafe,\n I21: UnwindSafe,\n I22: UnwindSafe,\n I23: UnwindSafe,\n I24: UnwindSafe,\n I25: UnwindSafe,\n I26: UnwindSafe,\n I27: UnwindSafe,\n I28: UnwindSafe,\n I29: UnwindSafe,\n I30: UnwindSafe,\n I31: UnwindSafe,
",1,["wiwi::iter::tuple::Tuple31"]],["impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24, I25, I26, I27, I28, I29, I30, I31, I32> UnwindSafe for Tuple32<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24, I25, I26, I27, I28, I29, I30, I31, I32>
where\n I1: UnwindSafe,\n I2: UnwindSafe,\n I3: UnwindSafe,\n I4: UnwindSafe,\n I5: UnwindSafe,\n I6: UnwindSafe,\n I7: UnwindSafe,\n I8: UnwindSafe,\n I9: UnwindSafe,\n I10: UnwindSafe,\n I11: UnwindSafe,\n I12: UnwindSafe,\n I13: UnwindSafe,\n I14: UnwindSafe,\n I15: UnwindSafe,\n I16: UnwindSafe,\n I17: UnwindSafe,\n I18: UnwindSafe,\n I19: UnwindSafe,\n I20: UnwindSafe,\n I21: UnwindSafe,\n I22: UnwindSafe,\n I23: UnwindSafe,\n I24: UnwindSafe,\n I25: UnwindSafe,\n I26: UnwindSafe,\n I27: UnwindSafe,\n I28: UnwindSafe,\n I29: UnwindSafe,\n I30: UnwindSafe,\n I31: UnwindSafe,\n I32: UnwindSafe,
",1,["wiwi::iter::tuple::Tuple32"]],["impl<K, V> UnwindSafe for BTreeMapChain<K, V>
where\n K: RefUnwindSafe,\n V: RefUnwindSafe,
",1,["wiwi::chainer::btree_map::BTreeMapChain"]],["impl<K, V, S> UnwindSafe for HashMapChain<K, V, S>
where\n K: UnwindSafe,\n V: UnwindSafe,\n S: UnwindSafe,
",1,["wiwi::chainer::hash_map::HashMapChain"]],["impl<P> UnwindSafe for String<P>
where\n <P as Pool>::Raw: UnwindSafe,\n P: UnwindSafe,
",1,["wiwi::string_pool::string::String"]],["impl<T> UnwindSafe for BTreeSetChain<T>
where\n T: RefUnwindSafe,
",1,["wiwi::chainer::btree_set::BTreeSetChain"]],["impl<T> UnwindSafe for BinaryHeapChain<T>
where\n T: UnwindSafe,
",1,["wiwi::chainer::binary_heap::BinaryHeapChain"]],["impl<T> UnwindSafe for LinkedListChain<T>
where\n T: RefUnwindSafe + UnwindSafe,
",1,["wiwi::chainer::linked_list::LinkedListChain"]],["impl<T> UnwindSafe for SliceBoxChain<T>
where\n T: UnwindSafe,
",1,["wiwi::chainer::slice_box::SliceBoxChain"]],["impl<T> UnwindSafe for VecChain<T>
where\n T: UnwindSafe,
",1,["wiwi::chainer::vec::VecChain"]],["impl<T> UnwindSafe for VecDequeChain<T>
where\n T: UnwindSafe,
",1,["wiwi::chainer::vec_deque::VecDequeChain"]],["impl<T> UnwindSafe for Empty<T>
where\n T: UnwindSafe,
",1,["wiwi::iter::empty::Empty"]],["impl<T, F> UnwindSafe for LazyWrapState<T, F>
where\n T: UnwindSafe,\n F: UnwindSafe,
",1,["wiwi::lazy_wrap::LazyWrapState"]],["impl<T, F> UnwindSafe for LazyWrap<T, F>
where\n T: UnwindSafe,\n F: UnwindSafe,
"],["impl<T, S> UnwindSafe for HashSetChain<T, S>
where\n S: UnwindSafe,\n T: UnwindSafe,
",1,["wiwi::chainer::hash_set::HashSetChain"]],["impl<T, const N: usize> UnwindSafe for ArrayChain<T, N>
where\n T: UnwindSafe,
",1,["wiwi::chainer::array::ArrayChain"]]] };if (window.register_implementors) {window.register_implementors(implementors);} else {window.pending_implementors = implementors;}})() \ No newline at end of file diff --git a/trait.impl/wiwi/serialiser/serialise/trait.Serialise.js b/trait.impl/wiwi/iter/double_ended/trait.DoubleEndedIter.js similarity index 100% rename from trait.impl/wiwi/serialiser/serialise/trait.Serialise.js rename to trait.impl/wiwi/iter/double_ended/trait.DoubleEndedIter.js diff --git a/wiwi/all.html b/wiwi/all.html index 2cfa3a891..888785615 100644 --- a/wiwi/all.html +++ b/wiwi/all.html @@ -1 +1 @@ -List of all items in this crate

List of all items

Structs

Enums

Traits

Macros

Derive Macros

Functions

Type Aliases

Constants

\ No newline at end of file +List of all items in this crate

List of all items

Structs

Enums

Traits

Macros

Derive Macros

Functions

Type Aliases

Constants

\ No newline at end of file diff --git a/wiwi/iter/double_ended/trait.DoubleEndedIter.html b/wiwi/iter/double_ended/trait.DoubleEndedIter.html new file mode 100644 index 000000000..97ba228e1 --- /dev/null +++ b/wiwi/iter/double_ended/trait.DoubleEndedIter.html @@ -0,0 +1,11 @@ + + + + + Redirection + + +

Redirecting to ../../../wiwi/iter/trait.DoubleEndedIter.html...

+ + + \ No newline at end of file diff --git a/wiwi/iter/index.html b/wiwi/iter/index.html index d54d04c61..8982be3a6 100644 --- a/wiwi/iter/index.html +++ b/wiwi/iter/index.html @@ -1,6 +1,6 @@ -wiwi::iter - Rust

Module wiwi::iter

source ·
Available on crate feature iter-unstable only.

Structs§

\ No newline at end of file diff --git a/wiwi/iter/struct.Peek.html b/wiwi/iter/struct.Peek.html index 90fcc1ef6..0b20a781c 100644 --- a/wiwi/iter/struct.Peek.html +++ b/wiwi/iter/struct.Peek.html @@ -1,11 +1,11 @@ Peek in wiwi::iter - Rust

Struct wiwi::iter::Peek

source ·
pub struct Peek<I, T> { /* private fields */ }
Available on crate feature iter-unstable only.

Implementations§

source§

impl<I, T> Peek<I, T>
where I: Iter<Item = T>,

source

pub fn into_inner(self) -> (I, Option<Option<T>>)

Trait Implementations§

source§

impl<I, T> Iter for Peek<I, T>
where - I: Iter<Item = T>,

§

type Item = <I as Iter>::Item

source§

fn next(&mut self) -> Option<I::Item>

source§

fn size_hint(&self) -> SizeHint

source§

fn for_each<F>(self, f: F)
where + I: Iter<Item = T>,

§

type Item = <I as Iter>::Item

source§

fn next(&mut self) -> Option<I::Item>

source§

fn size_hint(&self) -> SizeHint

source§

fn for_each<F>(self, f: F)
where Self: Sized, - F: FnMut(Self::Item),

source§

fn peekable(self) -> Peek<Self, Self::Item>
where - Self: Sized,

source§

fn map<O, F>(self, f: F) -> Map<Self, F>
where + F: FnMut(Self::Item),

source§

fn peekable(self) -> Peek<Self, Self::Item>
where + Self: Sized,

source§

fn map<O, F>(self, f: F) -> Map<Self, F>
where Self: Sized, - F: FnMut(Self::Item) -> O,

source§

fn count(self) -> usize
where + F: FnMut(Self::Item) -> O,

source§

fn count(self) -> usize
where Self: Sized,

Consumes the iter and returns the number of items that were emitted. Read more
source§

impl<I, T> Peekable for Peek<I, T>
where I: Iter<Item = T>,

§

type PeekItem = <I as Iter>::Item

source§

fn peek(&mut self) -> Option<&I::Item>

Auto Trait Implementations§

§

impl<I, T> Freeze for Peek<I, T>
where I: Freeze, @@ -20,8 +20,8 @@ T: Unpin,

§

impl<I, T> UnwindSafe for Peek<I, T>
where I: UnwindSafe, T: UnwindSafe,

Blanket Implementations§

source§

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

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<'h, I> AsStdIterator<'h> for I
where - I: Iter + 'h,

§

type Iterator = IterAdapter<&'h mut I>

Available on crate feature iter-unstable only.
source§

fn borrow_wiwi_as_std_iterator(&'h mut self) -> IterAdapter<&'h mut I>

Available on crate feature iter-unstable only.
Borrow the wiwi iter as an std iterator.
source§

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

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<'h, I> AsStdIterator<'h> for I
where + I: Iter + 'h,

§

type Iterator = IterAdapter<&'h mut I>

Available on crate feature iter-unstable only.
source§

fn borrow_wiwi_as_std_iterator(&'h mut self) -> IterAdapter<&'h mut I>

Available on crate feature iter-unstable only.
Borrow the wiwi iter as an std iterator.
source§

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

source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

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

source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

Returns the argument unchanged.

source§

impl<T, U> Into<U> for T
where @@ -29,8 +29,8 @@

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

source§

impl<I> IntoIter for I
where - I: Iter,

§

type Item = <I as Iter>::Item

Available on crate feature iter-unstable only.
§

type Iter = I

Available on crate feature iter-unstable only.
source§

fn into_wiwi_iter(self) -> I

Available on crate feature iter-unstable only.
source§

impl<I> IntoStdIterator for I
where - I: IntoIter,

§

type Iterator = IterAdapter<<I as IntoIter>::Iter>

Available on crate feature iter-unstable only.
source§

fn convert_wiwi_into_std_iterator(self) -> IterAdapter<<I as IntoIter>::Iter>

Available on crate feature iter-unstable only.
Converts the wiwi iter into a std iterator.
source§

impl<T> Same for T

§

type Output = T

Should always be Self
source§

impl<T> ToMaybeUninit for T

source§

unsafe fn to_maybeuninit(&self) -> &MaybeUninit<T>

Available on crate feature to-maybeuninit only.
source§

unsafe fn to_maybeuninit_mut(&mut self) -> &mut MaybeUninit<T>

Available on crate feature to-maybeuninit only.
source§

unsafe fn to_maybeuninit_drop(&mut self) -> &mut MaybeUninit<T>

Available on crate feature to-maybeuninit only.
Safety Read more
source§

impl<T, U> TryFrom<U> for T
where + I: Iter,

§

type Item = <I as Iter>::Item

Available on crate feature iter-unstable only.
§

type Iter = I

Available on crate feature iter-unstable only.
source§

fn into_wiwi_iter(self) -> I

Available on crate feature iter-unstable only.
source§

impl<I> IntoStdIterator for I
where + I: IntoIter,

§

type Iterator = IterAdapter<<I as IntoIter>::Iter>

Available on crate feature iter-unstable only.
source§

fn convert_wiwi_into_std_iterator(self) -> IterAdapter<<I as IntoIter>::Iter>

Available on crate feature iter-unstable only.
Converts the wiwi iter into a std iterator.
source§

impl<T> Same for T

§

type Output = T

Should always be Self
source§

impl<T> ToMaybeUninit for T

source§

unsafe fn to_maybeuninit(&self) -> &MaybeUninit<T>

Available on crate feature to-maybeuninit only.
source§

unsafe fn to_maybeuninit_mut(&mut self) -> &mut MaybeUninit<T>

Available on crate feature to-maybeuninit only.
source§

unsafe fn to_maybeuninit_drop(&mut self) -> &mut MaybeUninit<T>

Available on crate feature to-maybeuninit only.
Safety Read more
source§

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

§

type Error = Infallible

The type returned in the event of a conversion error.
source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

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

§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
§

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

§

fn vzip(self) -> V

\ No newline at end of file diff --git a/wiwi/iter/struct.RepeatPerItem.html b/wiwi/iter/struct.RepeatPerItem.html index ac1b83f6c..bd69cbbd4 100644 --- a/wiwi/iter/struct.RepeatPerItem.html +++ b/wiwi/iter/struct.RepeatPerItem.html @@ -3,12 +3,12 @@ I::Item: Clone,
source

pub fn into_inner(self) -> (I, Option<Option<I::Item>>)

Consumes self and returns the underlying iter.

Trait Implementations§

source§

impl<I> Iter for RepeatPerItem<I>
where I: Iter, - I::Item: Clone,

§

type Item = <I as Iter>::Item

source§

fn next(&mut self) -> Option<I::Item>

source§

fn size_hint(&self) -> SizeHint

source§

fn for_each<F>(self, f: F)
where + I::Item: Clone,

§

type Item = <I as Iter>::Item

source§

fn next(&mut self) -> Option<I::Item>

source§

fn size_hint(&self) -> SizeHint

source§

fn for_each<F>(self, f: F)
where Self: Sized, - F: FnMut(Self::Item),

source§

fn peekable(self) -> Peek<Self, Self::Item>
where - Self: Sized,

source§

fn map<O, F>(self, f: F) -> Map<Self, F>
where + F: FnMut(Self::Item),

source§

fn peekable(self) -> Peek<Self, Self::Item>
where + Self: Sized,

source§

fn map<O, F>(self, f: F) -> Map<Self, F>
where Self: Sized, - F: FnMut(Self::Item) -> O,

source§

fn count(self) -> usize
where + F: FnMut(Self::Item) -> O,

source§

fn count(self) -> usize
where Self: Sized,

Consumes the iter and returns the number of items that were emitted. Read more

Auto Trait Implementations§

§

impl<I> Freeze for RepeatPerItem<I>
where I: Freeze, <I as Iter>::Item: Freeze,

§

impl<I> RefUnwindSafe for RepeatPerItem<I>
where @@ -22,8 +22,8 @@ <I as Iter>::Item: Unpin,

§

impl<I> UnwindSafe for RepeatPerItem<I>
where I: UnwindSafe, <I as Iter>::Item: UnwindSafe,

Blanket Implementations§

source§

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

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<'h, I> AsStdIterator<'h> for I
where - I: Iter + 'h,

§

type Iterator = IterAdapter<&'h mut I>

Available on crate feature iter-unstable only.
source§

fn borrow_wiwi_as_std_iterator(&'h mut self) -> IterAdapter<&'h mut I>

Available on crate feature iter-unstable only.
Borrow the wiwi iter as an std iterator.
source§

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

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<'h, I> AsStdIterator<'h> for I
where + I: Iter + 'h,

§

type Iterator = IterAdapter<&'h mut I>

Available on crate feature iter-unstable only.
source§

fn borrow_wiwi_as_std_iterator(&'h mut self) -> IterAdapter<&'h mut I>

Available on crate feature iter-unstable only.
Borrow the wiwi iter as an std iterator.
source§

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

source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

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

source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

Returns the argument unchanged.

source§

impl<T, U> Into<U> for T
where @@ -31,8 +31,8 @@

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

source§

impl<I> IntoIter for I
where - I: Iter,

§

type Item = <I as Iter>::Item

Available on crate feature iter-unstable only.
§

type Iter = I

Available on crate feature iter-unstable only.
source§

fn into_wiwi_iter(self) -> I

Available on crate feature iter-unstable only.
source§

impl<I> IntoStdIterator for I
where - I: IntoIter,

§

type Iterator = IterAdapter<<I as IntoIter>::Iter>

Available on crate feature iter-unstable only.
source§

fn convert_wiwi_into_std_iterator(self) -> IterAdapter<<I as IntoIter>::Iter>

Available on crate feature iter-unstable only.
Converts the wiwi iter into a std iterator.
source§

impl<T> Same for T

§

type Output = T

Should always be Self
source§

impl<T> ToMaybeUninit for T

source§

unsafe fn to_maybeuninit(&self) -> &MaybeUninit<T>

Available on crate feature to-maybeuninit only.
source§

unsafe fn to_maybeuninit_mut(&mut self) -> &mut MaybeUninit<T>

Available on crate feature to-maybeuninit only.
source§

unsafe fn to_maybeuninit_drop(&mut self) -> &mut MaybeUninit<T>

Available on crate feature to-maybeuninit only.
Safety Read more
source§

impl<T, U> TryFrom<U> for T
where + I: Iter,

§

type Item = <I as Iter>::Item

Available on crate feature iter-unstable only.
§

type Iter = I

Available on crate feature iter-unstable only.
source§

fn into_wiwi_iter(self) -> I

Available on crate feature iter-unstable only.
source§

impl<I> IntoStdIterator for I
where + I: IntoIter,

§

type Iterator = IterAdapter<<I as IntoIter>::Iter>

Available on crate feature iter-unstable only.
source§

fn convert_wiwi_into_std_iterator(self) -> IterAdapter<<I as IntoIter>::Iter>

Available on crate feature iter-unstable only.
Converts the wiwi iter into a std iterator.
source§

impl<T> Same for T

§

type Output = T

Should always be Self
source§

impl<T> ToMaybeUninit for T

source§

unsafe fn to_maybeuninit(&self) -> &MaybeUninit<T>

Available on crate feature to-maybeuninit only.
source§

unsafe fn to_maybeuninit_mut(&mut self) -> &mut MaybeUninit<T>

Available on crate feature to-maybeuninit only.
source§

unsafe fn to_maybeuninit_drop(&mut self) -> &mut MaybeUninit<T>

Available on crate feature to-maybeuninit only.
Safety Read more
source§

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

§

type Error = Infallible

The type returned in the event of a conversion error.
source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

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

§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
§

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

§

fn vzip(self) -> V

\ No newline at end of file diff --git a/wiwi/iter/struct.Rev.html b/wiwi/iter/struct.Rev.html new file mode 100644 index 000000000..17569bbc9 --- /dev/null +++ b/wiwi/iter/struct.Rev.html @@ -0,0 +1,30 @@ +Rev in wiwi::iter - Rust

Struct wiwi::iter::Rev

source ·
pub struct Rev<I> { /* private fields */ }
Available on crate feature iter-unstable only.

Implementations§

source§

impl<I: DoubleEndedIter> Rev<I>

source

pub fn into_inner(self) -> I

Trait Implementations§

source§

impl<I: DoubleEndedIter> DoubleEndedIter for Rev<I>

source§

fn next_back(&mut self) -> Option<I::Item>

source§

fn rev(self) -> Rev<Self>
where + Self: Sized,

source§

fn for_each_back<F>(self, f: F)
where + Self: Sized, + F: FnMut(Self::Item),

source§

impl<I: DoubleEndedIter> Iter for Rev<I>

§

type Item = <I as Iter>::Item

source§

fn next(&mut self) -> Option<I::Item>

source§

fn size_hint(&self) -> SizeHint

source§

fn for_each<F>(self, f: F)
where + Self: Sized, + F: FnMut(Self::Item),

source§

fn peekable(self) -> Peek<Self, Self::Item>
where + Self: Sized,

source§

fn map<O, F>(self, f: F) -> Map<Self, F>
where + Self: Sized, + F: FnMut(Self::Item) -> O,

source§

fn count(self) -> usize
where + Self: Sized,

Consumes the iter and returns the number of items that were emitted. Read more

Auto Trait Implementations§

§

impl<I> Freeze for Rev<I>
where + I: Freeze,

§

impl<I> RefUnwindSafe for Rev<I>
where + I: RefUnwindSafe,

§

impl<I> Send for Rev<I>
where + I: Send,

§

impl<I> Sync for Rev<I>
where + I: Sync,

§

impl<I> Unpin for Rev<I>
where + I: Unpin,

§

impl<I> UnwindSafe for Rev<I>
where + I: UnwindSafe,

Blanket Implementations§

source§

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

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<'h, I> AsStdIterator<'h> for I
where + I: Iter + 'h,

§

type Iterator = IterAdapter<&'h mut I>

Available on crate feature iter-unstable only.
source§

fn borrow_wiwi_as_std_iterator(&'h mut self) -> IterAdapter<&'h mut I>

Available on crate feature iter-unstable only.
Borrow the wiwi iter as an std iterator.
source§

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

source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

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

source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

Returns the argument unchanged.

+
source§

impl<T, U> Into<U> for T
where + U: From<T>,

source§

fn into(self) -> U

Calls U::from(self).

+

That is, this conversion is whatever the implementation of +From<T> for U chooses to do.

+
source§

impl<I> IntoIter for I
where + I: Iter,

§

type Item = <I as Iter>::Item

Available on crate feature iter-unstable only.
§

type Iter = I

Available on crate feature iter-unstable only.
source§

fn into_wiwi_iter(self) -> I

Available on crate feature iter-unstable only.
source§

impl<I> IntoStdIterator for I
where + I: IntoIter,

§

type Iterator = IterAdapter<<I as IntoIter>::Iter>

Available on crate feature iter-unstable only.
source§

fn convert_wiwi_into_std_iterator(self) -> IterAdapter<<I as IntoIter>::Iter>

Available on crate feature iter-unstable only.
Converts the wiwi iter into a std iterator.
source§

impl<T> Same for T

§

type Output = T

Should always be Self
source§

impl<T> ToMaybeUninit for T

source§

unsafe fn to_maybeuninit(&self) -> &MaybeUninit<T>

Available on crate feature to-maybeuninit only.
source§

unsafe fn to_maybeuninit_mut(&mut self) -> &mut MaybeUninit<T>

Available on crate feature to-maybeuninit only.
source§

unsafe fn to_maybeuninit_drop(&mut self) -> &mut MaybeUninit<T>

Available on crate feature to-maybeuninit only.
Safety Read more
source§

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

§

type Error = Infallible

The type returned in the event of a conversion error.
source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

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

§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
§

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

§

fn vzip(self) -> V

\ No newline at end of file diff --git a/wiwi/iter/struct.Tuple1.html b/wiwi/iter/struct.Tuple1.html index 07dc6e60b..8e90ab8bf 100644 --- a/wiwi/iter/struct.Tuple1.html +++ b/wiwi/iter/struct.Tuple1.html @@ -8,12 +8,12 @@ std iterators before putting them into the tuple for the IntoIter implementation to be available

Trait Implementations§

source§

impl<I1> Iter for Tuple1<I1>
where - I1: Iter,

§

type Item = (<I1 as Iter>::Item,)

source§

fn next(&mut self) -> Option<Self::Item>

source§

fn size_hint(&self) -> SizeHint

source§

fn for_each<F>(self, f: F)
where + I1: Iter,

§

type Item = (<I1 as Iter>::Item,)

source§

fn next(&mut self) -> Option<Self::Item>

source§

fn size_hint(&self) -> SizeHint

source§

fn for_each<F>(self, f: F)
where Self: Sized, - F: FnMut(Self::Item),

source§

fn peekable(self) -> Peek<Self, Self::Item>
where - Self: Sized,

source§

fn map<O, F>(self, f: F) -> Map<Self, F>
where + F: FnMut(Self::Item),

source§

fn peekable(self) -> Peek<Self, Self::Item>
where + Self: Sized,

source§

fn map<O, F>(self, f: F) -> Map<Self, F>
where Self: Sized, - F: FnMut(Self::Item) -> O,

source§

fn count(self) -> usize
where + F: FnMut(Self::Item) -> O,

source§

fn count(self) -> usize
where Self: Sized,

Consumes the iter and returns the number of items that were emitted. Read more

Auto Trait Implementations§

§

impl<I1> Freeze for Tuple1<I1>
where I1: Freeze,

§

impl<I1> RefUnwindSafe for Tuple1<I1>
where I1: RefUnwindSafe,

§

impl<I1> Send for Tuple1<I1>
where @@ -21,8 +21,8 @@ I1: Sync,

§

impl<I1> Unpin for Tuple1<I1>
where I1: Unpin,

§

impl<I1> UnwindSafe for Tuple1<I1>
where I1: UnwindSafe,

Blanket Implementations§

source§

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

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<'h, I> AsStdIterator<'h> for I
where - I: Iter + 'h,

§

type Iterator = IterAdapter<&'h mut I>

Available on crate feature iter-unstable only.
source§

fn borrow_wiwi_as_std_iterator(&'h mut self) -> IterAdapter<&'h mut I>

Available on crate feature iter-unstable only.
Borrow the wiwi iter as an std iterator.
source§

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

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<'h, I> AsStdIterator<'h> for I
where + I: Iter + 'h,

§

type Iterator = IterAdapter<&'h mut I>

Available on crate feature iter-unstable only.
source§

fn borrow_wiwi_as_std_iterator(&'h mut self) -> IterAdapter<&'h mut I>

Available on crate feature iter-unstable only.
Borrow the wiwi iter as an std iterator.
source§

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

source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

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

source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

Returns the argument unchanged.

source§

impl<T, U> Into<U> for T
where @@ -30,8 +30,8 @@

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

source§

impl<I> IntoIter for I
where - I: Iter,

§

type Item = <I as Iter>::Item

Available on crate feature iter-unstable only.
§

type Iter = I

Available on crate feature iter-unstable only.
source§

fn into_wiwi_iter(self) -> I

Available on crate feature iter-unstable only.
source§

impl<I> IntoStdIterator for I
where - I: IntoIter,

§

type Iterator = IterAdapter<<I as IntoIter>::Iter>

Available on crate feature iter-unstable only.
source§

fn convert_wiwi_into_std_iterator(self) -> IterAdapter<<I as IntoIter>::Iter>

Available on crate feature iter-unstable only.
Converts the wiwi iter into a std iterator.
source§

impl<T> Same for T

§

type Output = T

Should always be Self
source§

impl<T> ToMaybeUninit for T

source§

unsafe fn to_maybeuninit(&self) -> &MaybeUninit<T>

Available on crate feature to-maybeuninit only.
source§

unsafe fn to_maybeuninit_mut(&mut self) -> &mut MaybeUninit<T>

Available on crate feature to-maybeuninit only.
source§

unsafe fn to_maybeuninit_drop(&mut self) -> &mut MaybeUninit<T>

Available on crate feature to-maybeuninit only.
Safety Read more
source§

impl<T, U> TryFrom<U> for T
where + I: Iter,

§

type Item = <I as Iter>::Item

Available on crate feature iter-unstable only.
§

type Iter = I

Available on crate feature iter-unstable only.
source§

fn into_wiwi_iter(self) -> I

Available on crate feature iter-unstable only.
source§

impl<I> IntoStdIterator for I
where + I: IntoIter,

§

type Iterator = IterAdapter<<I as IntoIter>::Iter>

Available on crate feature iter-unstable only.
source§

fn convert_wiwi_into_std_iterator(self) -> IterAdapter<<I as IntoIter>::Iter>

Available on crate feature iter-unstable only.
Converts the wiwi iter into a std iterator.
source§

impl<T> Same for T

§

type Output = T

Should always be Self
source§

impl<T> ToMaybeUninit for T

source§

unsafe fn to_maybeuninit(&self) -> &MaybeUninit<T>

Available on crate feature to-maybeuninit only.
source§

unsafe fn to_maybeuninit_mut(&mut self) -> &mut MaybeUninit<T>

Available on crate feature to-maybeuninit only.
source§

unsafe fn to_maybeuninit_drop(&mut self) -> &mut MaybeUninit<T>

Available on crate feature to-maybeuninit only.
Safety Read more
source§

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

§

type Error = Infallible

The type returned in the event of a conversion error.
source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

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

§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
§

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

§

fn vzip(self) -> V

\ No newline at end of file diff --git a/wiwi/iter/struct.Tuple10.html b/wiwi/iter/struct.Tuple10.html index 8bfb5f7ae..1d95856bb 100644 --- a/wiwi/iter/struct.Tuple10.html +++ b/wiwi/iter/struct.Tuple10.html @@ -17,12 +17,12 @@ I7: Iter, I8: Iter, I9: Iter, - I10: Iter,
§

type Item = (<I1 as Iter>::Item, <I2 as Iter>::Item, <I3 as Iter>::Item, <I4 as Iter>::Item, <I5 as Iter>::Item, <I6 as Iter>::Item, <I7 as Iter>::Item, <I8 as Iter>::Item, <I9 as Iter>::Item, <I10 as Iter>::Item)

source§

fn next(&mut self) -> Option<Self::Item>

source§

fn size_hint(&self) -> SizeHint

source§

fn for_each<F>(self, f: F)
where + I10: Iter,

§

type Item = (<I1 as Iter>::Item, <I2 as Iter>::Item, <I3 as Iter>::Item, <I4 as Iter>::Item, <I5 as Iter>::Item, <I6 as Iter>::Item, <I7 as Iter>::Item, <I8 as Iter>::Item, <I9 as Iter>::Item, <I10 as Iter>::Item)

source§

fn next(&mut self) -> Option<Self::Item>

source§

fn size_hint(&self) -> SizeHint

source§

fn for_each<F>(self, f: F)
where Self: Sized, - F: FnMut(Self::Item),

source§

fn peekable(self) -> Peek<Self, Self::Item>
where - Self: Sized,

source§

fn map<O, F>(self, f: F) -> Map<Self, F>
where + F: FnMut(Self::Item),

source§

fn peekable(self) -> Peek<Self, Self::Item>
where + Self: Sized,

source§

fn map<O, F>(self, f: F) -> Map<Self, F>
where Self: Sized, - F: FnMut(Self::Item) -> O,

source§

fn count(self) -> usize
where + F: FnMut(Self::Item) -> O,

source§

fn count(self) -> usize
where Self: Sized,

Consumes the iter and returns the number of items that were emitted. Read more

Auto Trait Implementations§

§

impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10> Freeze for Tuple10<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10>
where I1: Freeze, I2: Freeze, @@ -84,8 +84,8 @@ I8: UnwindSafe, I9: UnwindSafe, I10: UnwindSafe,

Blanket Implementations§

source§

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

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<'h, I> AsStdIterator<'h> for I
where - I: Iter + 'h,

§

type Iterator = IterAdapter<&'h mut I>

Available on crate feature iter-unstable only.
source§

fn borrow_wiwi_as_std_iterator(&'h mut self) -> IterAdapter<&'h mut I>

Available on crate feature iter-unstable only.
Borrow the wiwi iter as an std iterator.
source§

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

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<'h, I> AsStdIterator<'h> for I
where + I: Iter + 'h,

§

type Iterator = IterAdapter<&'h mut I>

Available on crate feature iter-unstable only.
source§

fn borrow_wiwi_as_std_iterator(&'h mut self) -> IterAdapter<&'h mut I>

Available on crate feature iter-unstable only.
Borrow the wiwi iter as an std iterator.
source§

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

source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

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

source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

Returns the argument unchanged.

source§

impl<T, U> Into<U> for T
where @@ -93,8 +93,8 @@

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

source§

impl<I> IntoIter for I
where - I: Iter,

§

type Item = <I as Iter>::Item

Available on crate feature iter-unstable only.
§

type Iter = I

Available on crate feature iter-unstable only.
source§

fn into_wiwi_iter(self) -> I

Available on crate feature iter-unstable only.
source§

impl<I> IntoStdIterator for I
where - I: IntoIter,

§

type Iterator = IterAdapter<<I as IntoIter>::Iter>

Available on crate feature iter-unstable only.
source§

fn convert_wiwi_into_std_iterator(self) -> IterAdapter<<I as IntoIter>::Iter>

Available on crate feature iter-unstable only.
Converts the wiwi iter into a std iterator.
source§

impl<T> Same for T

§

type Output = T

Should always be Self
source§

impl<T> ToMaybeUninit for T

source§

unsafe fn to_maybeuninit(&self) -> &MaybeUninit<T>

Available on crate feature to-maybeuninit only.
source§

unsafe fn to_maybeuninit_mut(&mut self) -> &mut MaybeUninit<T>

Available on crate feature to-maybeuninit only.
source§

unsafe fn to_maybeuninit_drop(&mut self) -> &mut MaybeUninit<T>

Available on crate feature to-maybeuninit only.
Safety Read more
source§

impl<T, U> TryFrom<U> for T
where + I: Iter,

§

type Item = <I as Iter>::Item

Available on crate feature iter-unstable only.
§

type Iter = I

Available on crate feature iter-unstable only.
source§

fn into_wiwi_iter(self) -> I

Available on crate feature iter-unstable only.
source§

impl<I> IntoStdIterator for I
where + I: IntoIter,

§

type Iterator = IterAdapter<<I as IntoIter>::Iter>

Available on crate feature iter-unstable only.
source§

fn convert_wiwi_into_std_iterator(self) -> IterAdapter<<I as IntoIter>::Iter>

Available on crate feature iter-unstable only.
Converts the wiwi iter into a std iterator.
source§

impl<T> Same for T

§

type Output = T

Should always be Self
source§

impl<T> ToMaybeUninit for T

source§

unsafe fn to_maybeuninit(&self) -> &MaybeUninit<T>

Available on crate feature to-maybeuninit only.
source§

unsafe fn to_maybeuninit_mut(&mut self) -> &mut MaybeUninit<T>

Available on crate feature to-maybeuninit only.
source§

unsafe fn to_maybeuninit_drop(&mut self) -> &mut MaybeUninit<T>

Available on crate feature to-maybeuninit only.
Safety Read more
source§

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

§

type Error = Infallible

The type returned in the event of a conversion error.
source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

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

§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
§

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

§

fn vzip(self) -> V

\ No newline at end of file diff --git a/wiwi/iter/struct.Tuple11.html b/wiwi/iter/struct.Tuple11.html index 4d1a6e71b..5d6c77778 100644 --- a/wiwi/iter/struct.Tuple11.html +++ b/wiwi/iter/struct.Tuple11.html @@ -18,12 +18,12 @@ I8: Iter, I9: Iter, I10: Iter, - I11: Iter,
§

type Item = (<I1 as Iter>::Item, <I2 as Iter>::Item, <I3 as Iter>::Item, <I4 as Iter>::Item, <I5 as Iter>::Item, <I6 as Iter>::Item, <I7 as Iter>::Item, <I8 as Iter>::Item, <I9 as Iter>::Item, <I10 as Iter>::Item, <I11 as Iter>::Item)

source§

fn next(&mut self) -> Option<Self::Item>

source§

fn size_hint(&self) -> SizeHint

source§

fn for_each<F>(self, f: F)
where + I11: Iter,

§

type Item = (<I1 as Iter>::Item, <I2 as Iter>::Item, <I3 as Iter>::Item, <I4 as Iter>::Item, <I5 as Iter>::Item, <I6 as Iter>::Item, <I7 as Iter>::Item, <I8 as Iter>::Item, <I9 as Iter>::Item, <I10 as Iter>::Item, <I11 as Iter>::Item)

source§

fn next(&mut self) -> Option<Self::Item>

source§

fn size_hint(&self) -> SizeHint

source§

fn for_each<F>(self, f: F)
where Self: Sized, - F: FnMut(Self::Item),

source§

fn peekable(self) -> Peek<Self, Self::Item>
where - Self: Sized,

source§

fn map<O, F>(self, f: F) -> Map<Self, F>
where + F: FnMut(Self::Item),

source§

fn peekable(self) -> Peek<Self, Self::Item>
where + Self: Sized,

source§

fn map<O, F>(self, f: F) -> Map<Self, F>
where Self: Sized, - F: FnMut(Self::Item) -> O,

source§

fn count(self) -> usize
where + F: FnMut(Self::Item) -> O,

source§

fn count(self) -> usize
where Self: Sized,

Consumes the iter and returns the number of items that were emitted. Read more

Auto Trait Implementations§

§

impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11> Freeze for Tuple11<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11>
where I1: Freeze, I2: Freeze, @@ -91,8 +91,8 @@ I9: UnwindSafe, I10: UnwindSafe, I11: UnwindSafe,

Blanket Implementations§

source§

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

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<'h, I> AsStdIterator<'h> for I
where - I: Iter + 'h,

§

type Iterator = IterAdapter<&'h mut I>

Available on crate feature iter-unstable only.
source§

fn borrow_wiwi_as_std_iterator(&'h mut self) -> IterAdapter<&'h mut I>

Available on crate feature iter-unstable only.
Borrow the wiwi iter as an std iterator.
source§

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

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<'h, I> AsStdIterator<'h> for I
where + I: Iter + 'h,

§

type Iterator = IterAdapter<&'h mut I>

Available on crate feature iter-unstable only.
source§

fn borrow_wiwi_as_std_iterator(&'h mut self) -> IterAdapter<&'h mut I>

Available on crate feature iter-unstable only.
Borrow the wiwi iter as an std iterator.
source§

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

source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

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

source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

Returns the argument unchanged.

source§

impl<T, U> Into<U> for T
where @@ -100,8 +100,8 @@

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

source§

impl<I> IntoIter for I
where - I: Iter,

§

type Item = <I as Iter>::Item

Available on crate feature iter-unstable only.
§

type Iter = I

Available on crate feature iter-unstable only.
source§

fn into_wiwi_iter(self) -> I

Available on crate feature iter-unstable only.
source§

impl<I> IntoStdIterator for I
where - I: IntoIter,

§

type Iterator = IterAdapter<<I as IntoIter>::Iter>

Available on crate feature iter-unstable only.
source§

fn convert_wiwi_into_std_iterator(self) -> IterAdapter<<I as IntoIter>::Iter>

Available on crate feature iter-unstable only.
Converts the wiwi iter into a std iterator.
source§

impl<T> Same for T

§

type Output = T

Should always be Self
source§

impl<T> ToMaybeUninit for T

source§

unsafe fn to_maybeuninit(&self) -> &MaybeUninit<T>

Available on crate feature to-maybeuninit only.
source§

unsafe fn to_maybeuninit_mut(&mut self) -> &mut MaybeUninit<T>

Available on crate feature to-maybeuninit only.
source§

unsafe fn to_maybeuninit_drop(&mut self) -> &mut MaybeUninit<T>

Available on crate feature to-maybeuninit only.
Safety Read more
source§

impl<T, U> TryFrom<U> for T
where + I: Iter,

§

type Item = <I as Iter>::Item

Available on crate feature iter-unstable only.
§

type Iter = I

Available on crate feature iter-unstable only.
source§

fn into_wiwi_iter(self) -> I

Available on crate feature iter-unstable only.
source§

impl<I> IntoStdIterator for I
where + I: IntoIter,

§

type Iterator = IterAdapter<<I as IntoIter>::Iter>

Available on crate feature iter-unstable only.
source§

fn convert_wiwi_into_std_iterator(self) -> IterAdapter<<I as IntoIter>::Iter>

Available on crate feature iter-unstable only.
Converts the wiwi iter into a std iterator.
source§

impl<T> Same for T

§

type Output = T

Should always be Self
source§

impl<T> ToMaybeUninit for T

source§

unsafe fn to_maybeuninit(&self) -> &MaybeUninit<T>

Available on crate feature to-maybeuninit only.
source§

unsafe fn to_maybeuninit_mut(&mut self) -> &mut MaybeUninit<T>

Available on crate feature to-maybeuninit only.
source§

unsafe fn to_maybeuninit_drop(&mut self) -> &mut MaybeUninit<T>

Available on crate feature to-maybeuninit only.
Safety Read more
source§

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

§

type Error = Infallible

The type returned in the event of a conversion error.
source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

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

§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
§

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

§

fn vzip(self) -> V

\ No newline at end of file diff --git a/wiwi/iter/struct.Tuple12.html b/wiwi/iter/struct.Tuple12.html index 9a003c7b0..c51249641 100644 --- a/wiwi/iter/struct.Tuple12.html +++ b/wiwi/iter/struct.Tuple12.html @@ -19,12 +19,12 @@ I9: Iter, I10: Iter, I11: Iter, - I12: Iter,
§

type Item = (<I1 as Iter>::Item, <I2 as Iter>::Item, <I3 as Iter>::Item, <I4 as Iter>::Item, <I5 as Iter>::Item, <I6 as Iter>::Item, <I7 as Iter>::Item, <I8 as Iter>::Item, <I9 as Iter>::Item, <I10 as Iter>::Item, <I11 as Iter>::Item, <I12 as Iter>::Item)

source§

fn next(&mut self) -> Option<Self::Item>

source§

fn size_hint(&self) -> SizeHint

source§

fn for_each<F>(self, f: F)
where + I12: Iter,

§

type Item = (<I1 as Iter>::Item, <I2 as Iter>::Item, <I3 as Iter>::Item, <I4 as Iter>::Item, <I5 as Iter>::Item, <I6 as Iter>::Item, <I7 as Iter>::Item, <I8 as Iter>::Item, <I9 as Iter>::Item, <I10 as Iter>::Item, <I11 as Iter>::Item, <I12 as Iter>::Item)

source§

fn next(&mut self) -> Option<Self::Item>

source§

fn size_hint(&self) -> SizeHint

source§

fn for_each<F>(self, f: F)
where Self: Sized, - F: FnMut(Self::Item),

source§

fn peekable(self) -> Peek<Self, Self::Item>
where - Self: Sized,

source§

fn map<O, F>(self, f: F) -> Map<Self, F>
where + F: FnMut(Self::Item),

source§

fn peekable(self) -> Peek<Self, Self::Item>
where + Self: Sized,

source§

fn map<O, F>(self, f: F) -> Map<Self, F>
where Self: Sized, - F: FnMut(Self::Item) -> O,

source§

fn count(self) -> usize
where + F: FnMut(Self::Item) -> O,

source§

fn count(self) -> usize
where Self: Sized,

Consumes the iter and returns the number of items that were emitted. Read more

Auto Trait Implementations§

§

impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12> Freeze for Tuple12<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12>
where I1: Freeze, I2: Freeze, @@ -98,8 +98,8 @@ I10: UnwindSafe, I11: UnwindSafe, I12: UnwindSafe,

Blanket Implementations§

source§

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

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<'h, I> AsStdIterator<'h> for I
where - I: Iter + 'h,

§

type Iterator = IterAdapter<&'h mut I>

Available on crate feature iter-unstable only.
source§

fn borrow_wiwi_as_std_iterator(&'h mut self) -> IterAdapter<&'h mut I>

Available on crate feature iter-unstable only.
Borrow the wiwi iter as an std iterator.
source§

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

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<'h, I> AsStdIterator<'h> for I
where + I: Iter + 'h,

§

type Iterator = IterAdapter<&'h mut I>

Available on crate feature iter-unstable only.
source§

fn borrow_wiwi_as_std_iterator(&'h mut self) -> IterAdapter<&'h mut I>

Available on crate feature iter-unstable only.
Borrow the wiwi iter as an std iterator.
source§

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

source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

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

source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

Returns the argument unchanged.

source§

impl<T, U> Into<U> for T
where @@ -107,8 +107,8 @@

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

source§

impl<I> IntoIter for I
where - I: Iter,

§

type Item = <I as Iter>::Item

Available on crate feature iter-unstable only.
§

type Iter = I

Available on crate feature iter-unstable only.
source§

fn into_wiwi_iter(self) -> I

Available on crate feature iter-unstable only.
source§

impl<I> IntoStdIterator for I
where - I: IntoIter,

§

type Iterator = IterAdapter<<I as IntoIter>::Iter>

Available on crate feature iter-unstable only.
source§

fn convert_wiwi_into_std_iterator(self) -> IterAdapter<<I as IntoIter>::Iter>

Available on crate feature iter-unstable only.
Converts the wiwi iter into a std iterator.
source§

impl<T> Same for T

§

type Output = T

Should always be Self
source§

impl<T> ToMaybeUninit for T

source§

unsafe fn to_maybeuninit(&self) -> &MaybeUninit<T>

Available on crate feature to-maybeuninit only.
source§

unsafe fn to_maybeuninit_mut(&mut self) -> &mut MaybeUninit<T>

Available on crate feature to-maybeuninit only.
source§

unsafe fn to_maybeuninit_drop(&mut self) -> &mut MaybeUninit<T>

Available on crate feature to-maybeuninit only.
Safety Read more
source§

impl<T, U> TryFrom<U> for T
where + I: Iter,

§

type Item = <I as Iter>::Item

Available on crate feature iter-unstable only.
§

type Iter = I

Available on crate feature iter-unstable only.
source§

fn into_wiwi_iter(self) -> I

Available on crate feature iter-unstable only.
source§

impl<I> IntoStdIterator for I
where + I: IntoIter,

§

type Iterator = IterAdapter<<I as IntoIter>::Iter>

Available on crate feature iter-unstable only.
source§

fn convert_wiwi_into_std_iterator(self) -> IterAdapter<<I as IntoIter>::Iter>

Available on crate feature iter-unstable only.
Converts the wiwi iter into a std iterator.
source§

impl<T> Same for T

§

type Output = T

Should always be Self
source§

impl<T> ToMaybeUninit for T

source§

unsafe fn to_maybeuninit(&self) -> &MaybeUninit<T>

Available on crate feature to-maybeuninit only.
source§

unsafe fn to_maybeuninit_mut(&mut self) -> &mut MaybeUninit<T>

Available on crate feature to-maybeuninit only.
source§

unsafe fn to_maybeuninit_drop(&mut self) -> &mut MaybeUninit<T>

Available on crate feature to-maybeuninit only.
Safety Read more
source§

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

§

type Error = Infallible

The type returned in the event of a conversion error.
source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

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

§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
§

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

§

fn vzip(self) -> V

\ No newline at end of file diff --git a/wiwi/iter/struct.Tuple13.html b/wiwi/iter/struct.Tuple13.html index ecbbe889e..f5546edd6 100644 --- a/wiwi/iter/struct.Tuple13.html +++ b/wiwi/iter/struct.Tuple13.html @@ -20,12 +20,12 @@ I10: Iter, I11: Iter, I12: Iter, - I13: Iter,
§

type Item = (<I1 as Iter>::Item, <I2 as Iter>::Item, <I3 as Iter>::Item, <I4 as Iter>::Item, <I5 as Iter>::Item, <I6 as Iter>::Item, <I7 as Iter>::Item, <I8 as Iter>::Item, <I9 as Iter>::Item, <I10 as Iter>::Item, <I11 as Iter>::Item, <I12 as Iter>::Item, <I13 as Iter>::Item)

source§

fn next(&mut self) -> Option<Self::Item>

source§

fn size_hint(&self) -> SizeHint

source§

fn for_each<F>(self, f: F)
where + I13: Iter,

§

type Item = (<I1 as Iter>::Item, <I2 as Iter>::Item, <I3 as Iter>::Item, <I4 as Iter>::Item, <I5 as Iter>::Item, <I6 as Iter>::Item, <I7 as Iter>::Item, <I8 as Iter>::Item, <I9 as Iter>::Item, <I10 as Iter>::Item, <I11 as Iter>::Item, <I12 as Iter>::Item, <I13 as Iter>::Item)

source§

fn next(&mut self) -> Option<Self::Item>

source§

fn size_hint(&self) -> SizeHint

source§

fn for_each<F>(self, f: F)
where Self: Sized, - F: FnMut(Self::Item),

source§

fn peekable(self) -> Peek<Self, Self::Item>
where - Self: Sized,

source§

fn map<O, F>(self, f: F) -> Map<Self, F>
where + F: FnMut(Self::Item),

source§

fn peekable(self) -> Peek<Self, Self::Item>
where + Self: Sized,

source§

fn map<O, F>(self, f: F) -> Map<Self, F>
where Self: Sized, - F: FnMut(Self::Item) -> O,

source§

fn count(self) -> usize
where + F: FnMut(Self::Item) -> O,

source§

fn count(self) -> usize
where Self: Sized,

Consumes the iter and returns the number of items that were emitted. Read more

Auto Trait Implementations§

§

impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13> Freeze for Tuple13<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13>
where I1: Freeze, I2: Freeze, @@ -105,8 +105,8 @@ I11: UnwindSafe, I12: UnwindSafe, I13: UnwindSafe,

Blanket Implementations§

source§

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

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<'h, I> AsStdIterator<'h> for I
where - I: Iter + 'h,

§

type Iterator = IterAdapter<&'h mut I>

Available on crate feature iter-unstable only.
source§

fn borrow_wiwi_as_std_iterator(&'h mut self) -> IterAdapter<&'h mut I>

Available on crate feature iter-unstable only.
Borrow the wiwi iter as an std iterator.
source§

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

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<'h, I> AsStdIterator<'h> for I
where + I: Iter + 'h,

§

type Iterator = IterAdapter<&'h mut I>

Available on crate feature iter-unstable only.
source§

fn borrow_wiwi_as_std_iterator(&'h mut self) -> IterAdapter<&'h mut I>

Available on crate feature iter-unstable only.
Borrow the wiwi iter as an std iterator.
source§

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

source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

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

source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

Returns the argument unchanged.

source§

impl<T, U> Into<U> for T
where @@ -114,8 +114,8 @@

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

source§

impl<I> IntoIter for I
where - I: Iter,

§

type Item = <I as Iter>::Item

Available on crate feature iter-unstable only.
§

type Iter = I

Available on crate feature iter-unstable only.
source§

fn into_wiwi_iter(self) -> I

Available on crate feature iter-unstable only.
source§

impl<I> IntoStdIterator for I
where - I: IntoIter,

§

type Iterator = IterAdapter<<I as IntoIter>::Iter>

Available on crate feature iter-unstable only.
source§

fn convert_wiwi_into_std_iterator(self) -> IterAdapter<<I as IntoIter>::Iter>

Available on crate feature iter-unstable only.
Converts the wiwi iter into a std iterator.
source§

impl<T> Same for T

§

type Output = T

Should always be Self
source§

impl<T> ToMaybeUninit for T

source§

unsafe fn to_maybeuninit(&self) -> &MaybeUninit<T>

Available on crate feature to-maybeuninit only.
source§

unsafe fn to_maybeuninit_mut(&mut self) -> &mut MaybeUninit<T>

Available on crate feature to-maybeuninit only.
source§

unsafe fn to_maybeuninit_drop(&mut self) -> &mut MaybeUninit<T>

Available on crate feature to-maybeuninit only.
Safety Read more
source§

impl<T, U> TryFrom<U> for T
where + I: Iter,

§

type Item = <I as Iter>::Item

Available on crate feature iter-unstable only.
§

type Iter = I

Available on crate feature iter-unstable only.
source§

fn into_wiwi_iter(self) -> I

Available on crate feature iter-unstable only.
source§

impl<I> IntoStdIterator for I
where + I: IntoIter,

§

type Iterator = IterAdapter<<I as IntoIter>::Iter>

Available on crate feature iter-unstable only.
source§

fn convert_wiwi_into_std_iterator(self) -> IterAdapter<<I as IntoIter>::Iter>

Available on crate feature iter-unstable only.
Converts the wiwi iter into a std iterator.
source§

impl<T> Same for T

§

type Output = T

Should always be Self
source§

impl<T> ToMaybeUninit for T

source§

unsafe fn to_maybeuninit(&self) -> &MaybeUninit<T>

Available on crate feature to-maybeuninit only.
source§

unsafe fn to_maybeuninit_mut(&mut self) -> &mut MaybeUninit<T>

Available on crate feature to-maybeuninit only.
source§

unsafe fn to_maybeuninit_drop(&mut self) -> &mut MaybeUninit<T>

Available on crate feature to-maybeuninit only.
Safety Read more
source§

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

§

type Error = Infallible

The type returned in the event of a conversion error.
source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

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

§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
§

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

§

fn vzip(self) -> V

\ No newline at end of file diff --git a/wiwi/iter/struct.Tuple14.html b/wiwi/iter/struct.Tuple14.html index 2e5432dcd..5437e565f 100644 --- a/wiwi/iter/struct.Tuple14.html +++ b/wiwi/iter/struct.Tuple14.html @@ -21,12 +21,12 @@ I11: Iter, I12: Iter, I13: Iter, - I14: Iter,
§

type Item = (<I1 as Iter>::Item, <I2 as Iter>::Item, <I3 as Iter>::Item, <I4 as Iter>::Item, <I5 as Iter>::Item, <I6 as Iter>::Item, <I7 as Iter>::Item, <I8 as Iter>::Item, <I9 as Iter>::Item, <I10 as Iter>::Item, <I11 as Iter>::Item, <I12 as Iter>::Item, <I13 as Iter>::Item, <I14 as Iter>::Item)

source§

fn next(&mut self) -> Option<Self::Item>

source§

fn size_hint(&self) -> SizeHint

source§

fn for_each<F>(self, f: F)
where + I14: Iter,

§

type Item = (<I1 as Iter>::Item, <I2 as Iter>::Item, <I3 as Iter>::Item, <I4 as Iter>::Item, <I5 as Iter>::Item, <I6 as Iter>::Item, <I7 as Iter>::Item, <I8 as Iter>::Item, <I9 as Iter>::Item, <I10 as Iter>::Item, <I11 as Iter>::Item, <I12 as Iter>::Item, <I13 as Iter>::Item, <I14 as Iter>::Item)

source§

fn next(&mut self) -> Option<Self::Item>

source§

fn size_hint(&self) -> SizeHint

source§

fn for_each<F>(self, f: F)
where Self: Sized, - F: FnMut(Self::Item),

source§

fn peekable(self) -> Peek<Self, Self::Item>
where - Self: Sized,

source§

fn map<O, F>(self, f: F) -> Map<Self, F>
where + F: FnMut(Self::Item),

source§

fn peekable(self) -> Peek<Self, Self::Item>
where + Self: Sized,

source§

fn map<O, F>(self, f: F) -> Map<Self, F>
where Self: Sized, - F: FnMut(Self::Item) -> O,

source§

fn count(self) -> usize
where + F: FnMut(Self::Item) -> O,

source§

fn count(self) -> usize
where Self: Sized,

Consumes the iter and returns the number of items that were emitted. Read more

Auto Trait Implementations§

§

impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14> Freeze for Tuple14<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14>
where I1: Freeze, I2: Freeze, @@ -112,8 +112,8 @@ I12: UnwindSafe, I13: UnwindSafe, I14: UnwindSafe,

Blanket Implementations§

source§

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

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<'h, I> AsStdIterator<'h> for I
where - I: Iter + 'h,

§

type Iterator = IterAdapter<&'h mut I>

Available on crate feature iter-unstable only.
source§

fn borrow_wiwi_as_std_iterator(&'h mut self) -> IterAdapter<&'h mut I>

Available on crate feature iter-unstable only.
Borrow the wiwi iter as an std iterator.
source§

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

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<'h, I> AsStdIterator<'h> for I
where + I: Iter + 'h,

§

type Iterator = IterAdapter<&'h mut I>

Available on crate feature iter-unstable only.
source§

fn borrow_wiwi_as_std_iterator(&'h mut self) -> IterAdapter<&'h mut I>

Available on crate feature iter-unstable only.
Borrow the wiwi iter as an std iterator.
source§

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

source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

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

source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

Returns the argument unchanged.

source§

impl<T, U> Into<U> for T
where @@ -121,8 +121,8 @@

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

source§

impl<I> IntoIter for I
where - I: Iter,

§

type Item = <I as Iter>::Item

Available on crate feature iter-unstable only.
§

type Iter = I

Available on crate feature iter-unstable only.
source§

fn into_wiwi_iter(self) -> I

Available on crate feature iter-unstable only.
source§

impl<I> IntoStdIterator for I
where - I: IntoIter,

§

type Iterator = IterAdapter<<I as IntoIter>::Iter>

Available on crate feature iter-unstable only.
source§

fn convert_wiwi_into_std_iterator(self) -> IterAdapter<<I as IntoIter>::Iter>

Available on crate feature iter-unstable only.
Converts the wiwi iter into a std iterator.
source§

impl<T> Same for T

§

type Output = T

Should always be Self
source§

impl<T> ToMaybeUninit for T

source§

unsafe fn to_maybeuninit(&self) -> &MaybeUninit<T>

Available on crate feature to-maybeuninit only.
source§

unsafe fn to_maybeuninit_mut(&mut self) -> &mut MaybeUninit<T>

Available on crate feature to-maybeuninit only.
source§

unsafe fn to_maybeuninit_drop(&mut self) -> &mut MaybeUninit<T>

Available on crate feature to-maybeuninit only.
Safety Read more
source§

impl<T, U> TryFrom<U> for T
where + I: Iter,

§

type Item = <I as Iter>::Item

Available on crate feature iter-unstable only.
§

type Iter = I

Available on crate feature iter-unstable only.
source§

fn into_wiwi_iter(self) -> I

Available on crate feature iter-unstable only.
source§

impl<I> IntoStdIterator for I
where + I: IntoIter,

§

type Iterator = IterAdapter<<I as IntoIter>::Iter>

Available on crate feature iter-unstable only.
source§

fn convert_wiwi_into_std_iterator(self) -> IterAdapter<<I as IntoIter>::Iter>

Available on crate feature iter-unstable only.
Converts the wiwi iter into a std iterator.
source§

impl<T> Same for T

§

type Output = T

Should always be Self
source§

impl<T> ToMaybeUninit for T

source§

unsafe fn to_maybeuninit(&self) -> &MaybeUninit<T>

Available on crate feature to-maybeuninit only.
source§

unsafe fn to_maybeuninit_mut(&mut self) -> &mut MaybeUninit<T>

Available on crate feature to-maybeuninit only.
source§

unsafe fn to_maybeuninit_drop(&mut self) -> &mut MaybeUninit<T>

Available on crate feature to-maybeuninit only.
Safety Read more
source§

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

§

type Error = Infallible

The type returned in the event of a conversion error.
source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

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

§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
§

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

§

fn vzip(self) -> V

\ No newline at end of file diff --git a/wiwi/iter/struct.Tuple15.html b/wiwi/iter/struct.Tuple15.html index 430831593..278b61a99 100644 --- a/wiwi/iter/struct.Tuple15.html +++ b/wiwi/iter/struct.Tuple15.html @@ -22,12 +22,12 @@ I12: Iter, I13: Iter, I14: Iter, - I15: Iter,
§

type Item = (<I1 as Iter>::Item, <I2 as Iter>::Item, <I3 as Iter>::Item, <I4 as Iter>::Item, <I5 as Iter>::Item, <I6 as Iter>::Item, <I7 as Iter>::Item, <I8 as Iter>::Item, <I9 as Iter>::Item, <I10 as Iter>::Item, <I11 as Iter>::Item, <I12 as Iter>::Item, <I13 as Iter>::Item, <I14 as Iter>::Item, <I15 as Iter>::Item)

source§

fn next(&mut self) -> Option<Self::Item>

source§

fn size_hint(&self) -> SizeHint

source§

fn for_each<F>(self, f: F)
where + I15: Iter,

§

type Item = (<I1 as Iter>::Item, <I2 as Iter>::Item, <I3 as Iter>::Item, <I4 as Iter>::Item, <I5 as Iter>::Item, <I6 as Iter>::Item, <I7 as Iter>::Item, <I8 as Iter>::Item, <I9 as Iter>::Item, <I10 as Iter>::Item, <I11 as Iter>::Item, <I12 as Iter>::Item, <I13 as Iter>::Item, <I14 as Iter>::Item, <I15 as Iter>::Item)

source§

fn next(&mut self) -> Option<Self::Item>

source§

fn size_hint(&self) -> SizeHint

source§

fn for_each<F>(self, f: F)
where Self: Sized, - F: FnMut(Self::Item),

source§

fn peekable(self) -> Peek<Self, Self::Item>
where - Self: Sized,

source§

fn map<O, F>(self, f: F) -> Map<Self, F>
where + F: FnMut(Self::Item),

source§

fn peekable(self) -> Peek<Self, Self::Item>
where + Self: Sized,

source§

fn map<O, F>(self, f: F) -> Map<Self, F>
where Self: Sized, - F: FnMut(Self::Item) -> O,

source§

fn count(self) -> usize
where + F: FnMut(Self::Item) -> O,

source§

fn count(self) -> usize
where Self: Sized,

Consumes the iter and returns the number of items that were emitted. Read more

Auto Trait Implementations§

§

impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15> Freeze for Tuple15<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15>
where I1: Freeze, I2: Freeze, @@ -119,8 +119,8 @@ I13: UnwindSafe, I14: UnwindSafe, I15: UnwindSafe,

Blanket Implementations§

source§

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

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<'h, I> AsStdIterator<'h> for I
where - I: Iter + 'h,

§

type Iterator = IterAdapter<&'h mut I>

Available on crate feature iter-unstable only.
source§

fn borrow_wiwi_as_std_iterator(&'h mut self) -> IterAdapter<&'h mut I>

Available on crate feature iter-unstable only.
Borrow the wiwi iter as an std iterator.
source§

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

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<'h, I> AsStdIterator<'h> for I
where + I: Iter + 'h,

§

type Iterator = IterAdapter<&'h mut I>

Available on crate feature iter-unstable only.
source§

fn borrow_wiwi_as_std_iterator(&'h mut self) -> IterAdapter<&'h mut I>

Available on crate feature iter-unstable only.
Borrow the wiwi iter as an std iterator.
source§

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

source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

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

source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

Returns the argument unchanged.

source§

impl<T, U> Into<U> for T
where @@ -128,8 +128,8 @@

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

source§

impl<I> IntoIter for I
where - I: Iter,

§

type Item = <I as Iter>::Item

Available on crate feature iter-unstable only.
§

type Iter = I

Available on crate feature iter-unstable only.
source§

fn into_wiwi_iter(self) -> I

Available on crate feature iter-unstable only.
source§

impl<I> IntoStdIterator for I
where - I: IntoIter,

§

type Iterator = IterAdapter<<I as IntoIter>::Iter>

Available on crate feature iter-unstable only.
source§

fn convert_wiwi_into_std_iterator(self) -> IterAdapter<<I as IntoIter>::Iter>

Available on crate feature iter-unstable only.
Converts the wiwi iter into a std iterator.
source§

impl<T> Same for T

§

type Output = T

Should always be Self
source§

impl<T> ToMaybeUninit for T

source§

unsafe fn to_maybeuninit(&self) -> &MaybeUninit<T>

Available on crate feature to-maybeuninit only.
source§

unsafe fn to_maybeuninit_mut(&mut self) -> &mut MaybeUninit<T>

Available on crate feature to-maybeuninit only.
source§

unsafe fn to_maybeuninit_drop(&mut self) -> &mut MaybeUninit<T>

Available on crate feature to-maybeuninit only.
Safety Read more
source§

impl<T, U> TryFrom<U> for T
where + I: Iter,

§

type Item = <I as Iter>::Item

Available on crate feature iter-unstable only.
§

type Iter = I

Available on crate feature iter-unstable only.
source§

fn into_wiwi_iter(self) -> I

Available on crate feature iter-unstable only.
source§

impl<I> IntoStdIterator for I
where + I: IntoIter,

§

type Iterator = IterAdapter<<I as IntoIter>::Iter>

Available on crate feature iter-unstable only.
source§

fn convert_wiwi_into_std_iterator(self) -> IterAdapter<<I as IntoIter>::Iter>

Available on crate feature iter-unstable only.
Converts the wiwi iter into a std iterator.
source§

impl<T> Same for T

§

type Output = T

Should always be Self
source§

impl<T> ToMaybeUninit for T

source§

unsafe fn to_maybeuninit(&self) -> &MaybeUninit<T>

Available on crate feature to-maybeuninit only.
source§

unsafe fn to_maybeuninit_mut(&mut self) -> &mut MaybeUninit<T>

Available on crate feature to-maybeuninit only.
source§

unsafe fn to_maybeuninit_drop(&mut self) -> &mut MaybeUninit<T>

Available on crate feature to-maybeuninit only.
Safety Read more
source§

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

§

type Error = Infallible

The type returned in the event of a conversion error.
source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

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

§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
§

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

§

fn vzip(self) -> V

\ No newline at end of file diff --git a/wiwi/iter/struct.Tuple16.html b/wiwi/iter/struct.Tuple16.html index 12eafc037..61a4d966c 100644 --- a/wiwi/iter/struct.Tuple16.html +++ b/wiwi/iter/struct.Tuple16.html @@ -23,12 +23,12 @@ I13: Iter, I14: Iter, I15: Iter, - I16: Iter,
§

type Item = (<I1 as Iter>::Item, <I2 as Iter>::Item, <I3 as Iter>::Item, <I4 as Iter>::Item, <I5 as Iter>::Item, <I6 as Iter>::Item, <I7 as Iter>::Item, <I8 as Iter>::Item, <I9 as Iter>::Item, <I10 as Iter>::Item, <I11 as Iter>::Item, <I12 as Iter>::Item, <I13 as Iter>::Item, <I14 as Iter>::Item, <I15 as Iter>::Item, <I16 as Iter>::Item)

source§

fn next(&mut self) -> Option<Self::Item>

source§

fn size_hint(&self) -> SizeHint

source§

fn for_each<F>(self, f: F)
where + I16: Iter,

§

type Item = (<I1 as Iter>::Item, <I2 as Iter>::Item, <I3 as Iter>::Item, <I4 as Iter>::Item, <I5 as Iter>::Item, <I6 as Iter>::Item, <I7 as Iter>::Item, <I8 as Iter>::Item, <I9 as Iter>::Item, <I10 as Iter>::Item, <I11 as Iter>::Item, <I12 as Iter>::Item, <I13 as Iter>::Item, <I14 as Iter>::Item, <I15 as Iter>::Item, <I16 as Iter>::Item)

source§

fn next(&mut self) -> Option<Self::Item>

source§

fn size_hint(&self) -> SizeHint

source§

fn for_each<F>(self, f: F)
where Self: Sized, - F: FnMut(Self::Item),

source§

fn peekable(self) -> Peek<Self, Self::Item>
where - Self: Sized,

source§

fn map<O, F>(self, f: F) -> Map<Self, F>
where + F: FnMut(Self::Item),

source§

fn peekable(self) -> Peek<Self, Self::Item>
where + Self: Sized,

source§

fn map<O, F>(self, f: F) -> Map<Self, F>
where Self: Sized, - F: FnMut(Self::Item) -> O,

source§

fn count(self) -> usize
where + F: FnMut(Self::Item) -> O,

source§

fn count(self) -> usize
where Self: Sized,

Consumes the iter and returns the number of items that were emitted. Read more

Auto Trait Implementations§

§

impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16> Freeze for Tuple16<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16>
where I1: Freeze, I2: Freeze, @@ -126,8 +126,8 @@ I14: UnwindSafe, I15: UnwindSafe, I16: UnwindSafe,

Blanket Implementations§

source§

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

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<'h, I> AsStdIterator<'h> for I
where - I: Iter + 'h,

§

type Iterator = IterAdapter<&'h mut I>

Available on crate feature iter-unstable only.
source§

fn borrow_wiwi_as_std_iterator(&'h mut self) -> IterAdapter<&'h mut I>

Available on crate feature iter-unstable only.
Borrow the wiwi iter as an std iterator.
source§

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

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<'h, I> AsStdIterator<'h> for I
where + I: Iter + 'h,

§

type Iterator = IterAdapter<&'h mut I>

Available on crate feature iter-unstable only.
source§

fn borrow_wiwi_as_std_iterator(&'h mut self) -> IterAdapter<&'h mut I>

Available on crate feature iter-unstable only.
Borrow the wiwi iter as an std iterator.
source§

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

source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

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

source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

Returns the argument unchanged.

source§

impl<T, U> Into<U> for T
where @@ -135,8 +135,8 @@

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

source§

impl<I> IntoIter for I
where - I: Iter,

§

type Item = <I as Iter>::Item

Available on crate feature iter-unstable only.
§

type Iter = I

Available on crate feature iter-unstable only.
source§

fn into_wiwi_iter(self) -> I

Available on crate feature iter-unstable only.
source§

impl<I> IntoStdIterator for I
where - I: IntoIter,

§

type Iterator = IterAdapter<<I as IntoIter>::Iter>

Available on crate feature iter-unstable only.
source§

fn convert_wiwi_into_std_iterator(self) -> IterAdapter<<I as IntoIter>::Iter>

Available on crate feature iter-unstable only.
Converts the wiwi iter into a std iterator.
source§

impl<T> Same for T

§

type Output = T

Should always be Self
source§

impl<T> ToMaybeUninit for T

source§

unsafe fn to_maybeuninit(&self) -> &MaybeUninit<T>

Available on crate feature to-maybeuninit only.
source§

unsafe fn to_maybeuninit_mut(&mut self) -> &mut MaybeUninit<T>

Available on crate feature to-maybeuninit only.
source§

unsafe fn to_maybeuninit_drop(&mut self) -> &mut MaybeUninit<T>

Available on crate feature to-maybeuninit only.
Safety Read more
source§

impl<T, U> TryFrom<U> for T
where + I: Iter,

§

type Item = <I as Iter>::Item

Available on crate feature iter-unstable only.
§

type Iter = I

Available on crate feature iter-unstable only.
source§

fn into_wiwi_iter(self) -> I

Available on crate feature iter-unstable only.
source§

impl<I> IntoStdIterator for I
where + I: IntoIter,

§

type Iterator = IterAdapter<<I as IntoIter>::Iter>

Available on crate feature iter-unstable only.
source§

fn convert_wiwi_into_std_iterator(self) -> IterAdapter<<I as IntoIter>::Iter>

Available on crate feature iter-unstable only.
Converts the wiwi iter into a std iterator.
source§

impl<T> Same for T

§

type Output = T

Should always be Self
source§

impl<T> ToMaybeUninit for T

source§

unsafe fn to_maybeuninit(&self) -> &MaybeUninit<T>

Available on crate feature to-maybeuninit only.
source§

unsafe fn to_maybeuninit_mut(&mut self) -> &mut MaybeUninit<T>

Available on crate feature to-maybeuninit only.
source§

unsafe fn to_maybeuninit_drop(&mut self) -> &mut MaybeUninit<T>

Available on crate feature to-maybeuninit only.
Safety Read more
source§

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

§

type Error = Infallible

The type returned in the event of a conversion error.
source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

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

§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
§

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

§

fn vzip(self) -> V

\ No newline at end of file diff --git a/wiwi/iter/struct.Tuple17.html b/wiwi/iter/struct.Tuple17.html index f1be2a137..af96a8bd4 100644 --- a/wiwi/iter/struct.Tuple17.html +++ b/wiwi/iter/struct.Tuple17.html @@ -24,12 +24,12 @@ I14: Iter, I15: Iter, I16: Iter, - I17: Iter,
§

type Item = (<I1 as Iter>::Item, <I2 as Iter>::Item, <I3 as Iter>::Item, <I4 as Iter>::Item, <I5 as Iter>::Item, <I6 as Iter>::Item, <I7 as Iter>::Item, <I8 as Iter>::Item, <I9 as Iter>::Item, <I10 as Iter>::Item, <I11 as Iter>::Item, <I12 as Iter>::Item, <I13 as Iter>::Item, <I14 as Iter>::Item, <I15 as Iter>::Item, <I16 as Iter>::Item, <I17 as Iter>::Item)

source§

fn next(&mut self) -> Option<Self::Item>

source§

fn size_hint(&self) -> SizeHint

source§

fn for_each<F>(self, f: F)
where + I17: Iter,

§

type Item = (<I1 as Iter>::Item, <I2 as Iter>::Item, <I3 as Iter>::Item, <I4 as Iter>::Item, <I5 as Iter>::Item, <I6 as Iter>::Item, <I7 as Iter>::Item, <I8 as Iter>::Item, <I9 as Iter>::Item, <I10 as Iter>::Item, <I11 as Iter>::Item, <I12 as Iter>::Item, <I13 as Iter>::Item, <I14 as Iter>::Item, <I15 as Iter>::Item, <I16 as Iter>::Item, <I17 as Iter>::Item)

source§

fn next(&mut self) -> Option<Self::Item>

source§

fn size_hint(&self) -> SizeHint

source§

fn for_each<F>(self, f: F)
where Self: Sized, - F: FnMut(Self::Item),

source§

fn peekable(self) -> Peek<Self, Self::Item>
where - Self: Sized,

source§

fn map<O, F>(self, f: F) -> Map<Self, F>
where + F: FnMut(Self::Item),

source§

fn peekable(self) -> Peek<Self, Self::Item>
where + Self: Sized,

source§

fn map<O, F>(self, f: F) -> Map<Self, F>
where Self: Sized, - F: FnMut(Self::Item) -> O,

source§

fn count(self) -> usize
where + F: FnMut(Self::Item) -> O,

source§

fn count(self) -> usize
where Self: Sized,

Consumes the iter and returns the number of items that were emitted. Read more

Auto Trait Implementations§

§

impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17> Freeze for Tuple17<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17>
where I1: Freeze, I2: Freeze, @@ -133,8 +133,8 @@ I15: UnwindSafe, I16: UnwindSafe, I17: UnwindSafe,

Blanket Implementations§

source§

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

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<'h, I> AsStdIterator<'h> for I
where - I: Iter + 'h,

§

type Iterator = IterAdapter<&'h mut I>

Available on crate feature iter-unstable only.
source§

fn borrow_wiwi_as_std_iterator(&'h mut self) -> IterAdapter<&'h mut I>

Available on crate feature iter-unstable only.
Borrow the wiwi iter as an std iterator.
source§

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

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<'h, I> AsStdIterator<'h> for I
where + I: Iter + 'h,

§

type Iterator = IterAdapter<&'h mut I>

Available on crate feature iter-unstable only.
source§

fn borrow_wiwi_as_std_iterator(&'h mut self) -> IterAdapter<&'h mut I>

Available on crate feature iter-unstable only.
Borrow the wiwi iter as an std iterator.
source§

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

source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

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

source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

Returns the argument unchanged.

source§

impl<T, U> Into<U> for T
where @@ -142,8 +142,8 @@

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

source§

impl<I> IntoIter for I
where - I: Iter,

§

type Item = <I as Iter>::Item

Available on crate feature iter-unstable only.
§

type Iter = I

Available on crate feature iter-unstable only.
source§

fn into_wiwi_iter(self) -> I

Available on crate feature iter-unstable only.
source§

impl<I> IntoStdIterator for I
where - I: IntoIter,

§

type Iterator = IterAdapter<<I as IntoIter>::Iter>

Available on crate feature iter-unstable only.
source§

fn convert_wiwi_into_std_iterator(self) -> IterAdapter<<I as IntoIter>::Iter>

Available on crate feature iter-unstable only.
Converts the wiwi iter into a std iterator.
source§

impl<T> Same for T

§

type Output = T

Should always be Self
source§

impl<T> ToMaybeUninit for T

source§

unsafe fn to_maybeuninit(&self) -> &MaybeUninit<T>

Available on crate feature to-maybeuninit only.
source§

unsafe fn to_maybeuninit_mut(&mut self) -> &mut MaybeUninit<T>

Available on crate feature to-maybeuninit only.
source§

unsafe fn to_maybeuninit_drop(&mut self) -> &mut MaybeUninit<T>

Available on crate feature to-maybeuninit only.
Safety Read more
source§

impl<T, U> TryFrom<U> for T
where + I: Iter,

§

type Item = <I as Iter>::Item

Available on crate feature iter-unstable only.
§

type Iter = I

Available on crate feature iter-unstable only.
source§

fn into_wiwi_iter(self) -> I

Available on crate feature iter-unstable only.
source§

impl<I> IntoStdIterator for I
where + I: IntoIter,

§

type Iterator = IterAdapter<<I as IntoIter>::Iter>

Available on crate feature iter-unstable only.
source§

fn convert_wiwi_into_std_iterator(self) -> IterAdapter<<I as IntoIter>::Iter>

Available on crate feature iter-unstable only.
Converts the wiwi iter into a std iterator.
source§

impl<T> Same for T

§

type Output = T

Should always be Self
source§

impl<T> ToMaybeUninit for T

source§

unsafe fn to_maybeuninit(&self) -> &MaybeUninit<T>

Available on crate feature to-maybeuninit only.
source§

unsafe fn to_maybeuninit_mut(&mut self) -> &mut MaybeUninit<T>

Available on crate feature to-maybeuninit only.
source§

unsafe fn to_maybeuninit_drop(&mut self) -> &mut MaybeUninit<T>

Available on crate feature to-maybeuninit only.
Safety Read more
source§

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

§

type Error = Infallible

The type returned in the event of a conversion error.
source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

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

§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
§

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

§

fn vzip(self) -> V

\ No newline at end of file diff --git a/wiwi/iter/struct.Tuple18.html b/wiwi/iter/struct.Tuple18.html index 830c7ec89..e8f50c05b 100644 --- a/wiwi/iter/struct.Tuple18.html +++ b/wiwi/iter/struct.Tuple18.html @@ -25,12 +25,12 @@ I15: Iter, I16: Iter, I17: Iter, - I18: Iter,
§

type Item = (<I1 as Iter>::Item, <I2 as Iter>::Item, <I3 as Iter>::Item, <I4 as Iter>::Item, <I5 as Iter>::Item, <I6 as Iter>::Item, <I7 as Iter>::Item, <I8 as Iter>::Item, <I9 as Iter>::Item, <I10 as Iter>::Item, <I11 as Iter>::Item, <I12 as Iter>::Item, <I13 as Iter>::Item, <I14 as Iter>::Item, <I15 as Iter>::Item, <I16 as Iter>::Item, <I17 as Iter>::Item, <I18 as Iter>::Item)

source§

fn next(&mut self) -> Option<Self::Item>

source§

fn size_hint(&self) -> SizeHint

source§

fn for_each<F>(self, f: F)
where + I18: Iter,

§

type Item = (<I1 as Iter>::Item, <I2 as Iter>::Item, <I3 as Iter>::Item, <I4 as Iter>::Item, <I5 as Iter>::Item, <I6 as Iter>::Item, <I7 as Iter>::Item, <I8 as Iter>::Item, <I9 as Iter>::Item, <I10 as Iter>::Item, <I11 as Iter>::Item, <I12 as Iter>::Item, <I13 as Iter>::Item, <I14 as Iter>::Item, <I15 as Iter>::Item, <I16 as Iter>::Item, <I17 as Iter>::Item, <I18 as Iter>::Item)

source§

fn next(&mut self) -> Option<Self::Item>

source§

fn size_hint(&self) -> SizeHint

source§

fn for_each<F>(self, f: F)
where Self: Sized, - F: FnMut(Self::Item),

source§

fn peekable(self) -> Peek<Self, Self::Item>
where - Self: Sized,

source§

fn map<O, F>(self, f: F) -> Map<Self, F>
where + F: FnMut(Self::Item),

source§

fn peekable(self) -> Peek<Self, Self::Item>
where + Self: Sized,

source§

fn map<O, F>(self, f: F) -> Map<Self, F>
where Self: Sized, - F: FnMut(Self::Item) -> O,

source§

fn count(self) -> usize
where + F: FnMut(Self::Item) -> O,

source§

fn count(self) -> usize
where Self: Sized,

Consumes the iter and returns the number of items that were emitted. Read more

Auto Trait Implementations§

§

impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18> Freeze for Tuple18<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18>
where I1: Freeze, I2: Freeze, @@ -140,8 +140,8 @@ I16: UnwindSafe, I17: UnwindSafe, I18: UnwindSafe,

Blanket Implementations§

source§

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

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<'h, I> AsStdIterator<'h> for I
where - I: Iter + 'h,

§

type Iterator = IterAdapter<&'h mut I>

Available on crate feature iter-unstable only.
source§

fn borrow_wiwi_as_std_iterator(&'h mut self) -> IterAdapter<&'h mut I>

Available on crate feature iter-unstable only.
Borrow the wiwi iter as an std iterator.
source§

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

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<'h, I> AsStdIterator<'h> for I
where + I: Iter + 'h,

§

type Iterator = IterAdapter<&'h mut I>

Available on crate feature iter-unstable only.
source§

fn borrow_wiwi_as_std_iterator(&'h mut self) -> IterAdapter<&'h mut I>

Available on crate feature iter-unstable only.
Borrow the wiwi iter as an std iterator.
source§

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

source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

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

source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

Returns the argument unchanged.

source§

impl<T, U> Into<U> for T
where @@ -149,8 +149,8 @@

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

source§

impl<I> IntoIter for I
where - I: Iter,

§

type Item = <I as Iter>::Item

Available on crate feature iter-unstable only.
§

type Iter = I

Available on crate feature iter-unstable only.
source§

fn into_wiwi_iter(self) -> I

Available on crate feature iter-unstable only.
source§

impl<I> IntoStdIterator for I
where - I: IntoIter,

§

type Iterator = IterAdapter<<I as IntoIter>::Iter>

Available on crate feature iter-unstable only.
source§

fn convert_wiwi_into_std_iterator(self) -> IterAdapter<<I as IntoIter>::Iter>

Available on crate feature iter-unstable only.
Converts the wiwi iter into a std iterator.
source§

impl<T> Same for T

§

type Output = T

Should always be Self
source§

impl<T> ToMaybeUninit for T

source§

unsafe fn to_maybeuninit(&self) -> &MaybeUninit<T>

Available on crate feature to-maybeuninit only.
source§

unsafe fn to_maybeuninit_mut(&mut self) -> &mut MaybeUninit<T>

Available on crate feature to-maybeuninit only.
source§

unsafe fn to_maybeuninit_drop(&mut self) -> &mut MaybeUninit<T>

Available on crate feature to-maybeuninit only.
Safety Read more
source§

impl<T, U> TryFrom<U> for T
where + I: Iter,

§

type Item = <I as Iter>::Item

Available on crate feature iter-unstable only.
§

type Iter = I

Available on crate feature iter-unstable only.
source§

fn into_wiwi_iter(self) -> I

Available on crate feature iter-unstable only.
source§

impl<I> IntoStdIterator for I
where + I: IntoIter,

§

type Iterator = IterAdapter<<I as IntoIter>::Iter>

Available on crate feature iter-unstable only.
source§

fn convert_wiwi_into_std_iterator(self) -> IterAdapter<<I as IntoIter>::Iter>

Available on crate feature iter-unstable only.
Converts the wiwi iter into a std iterator.
source§

impl<T> Same for T

§

type Output = T

Should always be Self
source§

impl<T> ToMaybeUninit for T

source§

unsafe fn to_maybeuninit(&self) -> &MaybeUninit<T>

Available on crate feature to-maybeuninit only.
source§

unsafe fn to_maybeuninit_mut(&mut self) -> &mut MaybeUninit<T>

Available on crate feature to-maybeuninit only.
source§

unsafe fn to_maybeuninit_drop(&mut self) -> &mut MaybeUninit<T>

Available on crate feature to-maybeuninit only.
Safety Read more
source§

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

§

type Error = Infallible

The type returned in the event of a conversion error.
source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

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

§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
§

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

§

fn vzip(self) -> V

\ No newline at end of file diff --git a/wiwi/iter/struct.Tuple19.html b/wiwi/iter/struct.Tuple19.html index 3de23e91d..096c44e8b 100644 --- a/wiwi/iter/struct.Tuple19.html +++ b/wiwi/iter/struct.Tuple19.html @@ -26,12 +26,12 @@ I16: Iter, I17: Iter, I18: Iter, - I19: Iter,
§

type Item = (<I1 as Iter>::Item, <I2 as Iter>::Item, <I3 as Iter>::Item, <I4 as Iter>::Item, <I5 as Iter>::Item, <I6 as Iter>::Item, <I7 as Iter>::Item, <I8 as Iter>::Item, <I9 as Iter>::Item, <I10 as Iter>::Item, <I11 as Iter>::Item, <I12 as Iter>::Item, <I13 as Iter>::Item, <I14 as Iter>::Item, <I15 as Iter>::Item, <I16 as Iter>::Item, <I17 as Iter>::Item, <I18 as Iter>::Item, <I19 as Iter>::Item)

source§

fn next(&mut self) -> Option<Self::Item>

source§

fn size_hint(&self) -> SizeHint

source§

fn for_each<F>(self, f: F)
where + I19: Iter,

§

type Item = (<I1 as Iter>::Item, <I2 as Iter>::Item, <I3 as Iter>::Item, <I4 as Iter>::Item, <I5 as Iter>::Item, <I6 as Iter>::Item, <I7 as Iter>::Item, <I8 as Iter>::Item, <I9 as Iter>::Item, <I10 as Iter>::Item, <I11 as Iter>::Item, <I12 as Iter>::Item, <I13 as Iter>::Item, <I14 as Iter>::Item, <I15 as Iter>::Item, <I16 as Iter>::Item, <I17 as Iter>::Item, <I18 as Iter>::Item, <I19 as Iter>::Item)

source§

fn next(&mut self) -> Option<Self::Item>

source§

fn size_hint(&self) -> SizeHint

source§

fn for_each<F>(self, f: F)
where Self: Sized, - F: FnMut(Self::Item),

source§

fn peekable(self) -> Peek<Self, Self::Item>
where - Self: Sized,

source§

fn map<O, F>(self, f: F) -> Map<Self, F>
where + F: FnMut(Self::Item),

source§

fn peekable(self) -> Peek<Self, Self::Item>
where + Self: Sized,

source§

fn map<O, F>(self, f: F) -> Map<Self, F>
where Self: Sized, - F: FnMut(Self::Item) -> O,

source§

fn count(self) -> usize
where + F: FnMut(Self::Item) -> O,

source§

fn count(self) -> usize
where Self: Sized,

Consumes the iter and returns the number of items that were emitted. Read more

Auto Trait Implementations§

§

impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19> Freeze for Tuple19<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19>
where I1: Freeze, I2: Freeze, @@ -147,8 +147,8 @@ I17: UnwindSafe, I18: UnwindSafe, I19: UnwindSafe,

Blanket Implementations§

source§

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

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<'h, I> AsStdIterator<'h> for I
where - I: Iter + 'h,

§

type Iterator = IterAdapter<&'h mut I>

Available on crate feature iter-unstable only.
source§

fn borrow_wiwi_as_std_iterator(&'h mut self) -> IterAdapter<&'h mut I>

Available on crate feature iter-unstable only.
Borrow the wiwi iter as an std iterator.
source§

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

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<'h, I> AsStdIterator<'h> for I
where + I: Iter + 'h,

§

type Iterator = IterAdapter<&'h mut I>

Available on crate feature iter-unstable only.
source§

fn borrow_wiwi_as_std_iterator(&'h mut self) -> IterAdapter<&'h mut I>

Available on crate feature iter-unstable only.
Borrow the wiwi iter as an std iterator.
source§

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

source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

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

source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

Returns the argument unchanged.

source§

impl<T, U> Into<U> for T
where @@ -156,8 +156,8 @@

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

source§

impl<I> IntoIter for I
where - I: Iter,

§

type Item = <I as Iter>::Item

Available on crate feature iter-unstable only.
§

type Iter = I

Available on crate feature iter-unstable only.
source§

fn into_wiwi_iter(self) -> I

Available on crate feature iter-unstable only.
source§

impl<I> IntoStdIterator for I
where - I: IntoIter,

§

type Iterator = IterAdapter<<I as IntoIter>::Iter>

Available on crate feature iter-unstable only.
source§

fn convert_wiwi_into_std_iterator(self) -> IterAdapter<<I as IntoIter>::Iter>

Available on crate feature iter-unstable only.
Converts the wiwi iter into a std iterator.
source§

impl<T> Same for T

§

type Output = T

Should always be Self
source§

impl<T> ToMaybeUninit for T

source§

unsafe fn to_maybeuninit(&self) -> &MaybeUninit<T>

Available on crate feature to-maybeuninit only.
source§

unsafe fn to_maybeuninit_mut(&mut self) -> &mut MaybeUninit<T>

Available on crate feature to-maybeuninit only.
source§

unsafe fn to_maybeuninit_drop(&mut self) -> &mut MaybeUninit<T>

Available on crate feature to-maybeuninit only.
Safety Read more
source§

impl<T, U> TryFrom<U> for T
where + I: Iter,

§

type Item = <I as Iter>::Item

Available on crate feature iter-unstable only.
§

type Iter = I

Available on crate feature iter-unstable only.
source§

fn into_wiwi_iter(self) -> I

Available on crate feature iter-unstable only.
source§

impl<I> IntoStdIterator for I
where + I: IntoIter,

§

type Iterator = IterAdapter<<I as IntoIter>::Iter>

Available on crate feature iter-unstable only.
source§

fn convert_wiwi_into_std_iterator(self) -> IterAdapter<<I as IntoIter>::Iter>

Available on crate feature iter-unstable only.
Converts the wiwi iter into a std iterator.
source§

impl<T> Same for T

§

type Output = T

Should always be Self
source§

impl<T> ToMaybeUninit for T

source§

unsafe fn to_maybeuninit(&self) -> &MaybeUninit<T>

Available on crate feature to-maybeuninit only.
source§

unsafe fn to_maybeuninit_mut(&mut self) -> &mut MaybeUninit<T>

Available on crate feature to-maybeuninit only.
source§

unsafe fn to_maybeuninit_drop(&mut self) -> &mut MaybeUninit<T>

Available on crate feature to-maybeuninit only.
Safety Read more
source§

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

§

type Error = Infallible

The type returned in the event of a conversion error.
source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

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

§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
§

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

§

fn vzip(self) -> V

\ No newline at end of file diff --git a/wiwi/iter/struct.Tuple2.html b/wiwi/iter/struct.Tuple2.html index cf328be87..bf183f95d 100644 --- a/wiwi/iter/struct.Tuple2.html +++ b/wiwi/iter/struct.Tuple2.html @@ -9,12 +9,12 @@ implementation to be available

Trait Implementations§

source§

impl<I1, I2> Iter for Tuple2<I1, I2>
where I1: Iter, - I2: Iter,

§

type Item = (<I1 as Iter>::Item, <I2 as Iter>::Item)

source§

fn next(&mut self) -> Option<Self::Item>

source§

fn size_hint(&self) -> SizeHint

source§

fn for_each<F>(self, f: F)
where + I2: Iter,

§

type Item = (<I1 as Iter>::Item, <I2 as Iter>::Item)

source§

fn next(&mut self) -> Option<Self::Item>

source§

fn size_hint(&self) -> SizeHint

source§

fn for_each<F>(self, f: F)
where Self: Sized, - F: FnMut(Self::Item),

source§

fn peekable(self) -> Peek<Self, Self::Item>
where - Self: Sized,

source§

fn map<O, F>(self, f: F) -> Map<Self, F>
where + F: FnMut(Self::Item),

source§

fn peekable(self) -> Peek<Self, Self::Item>
where + Self: Sized,

source§

fn map<O, F>(self, f: F) -> Map<Self, F>
where Self: Sized, - F: FnMut(Self::Item) -> O,

source§

fn count(self) -> usize
where + F: FnMut(Self::Item) -> O,

source§

fn count(self) -> usize
where Self: Sized,

Consumes the iter and returns the number of items that were emitted. Read more

Auto Trait Implementations§

§

impl<I1, I2> Freeze for Tuple2<I1, I2>
where I1: Freeze, I2: Freeze,

§

impl<I1, I2> RefUnwindSafe for Tuple2<I1, I2>
where @@ -28,8 +28,8 @@ I2: Unpin,

§

impl<I1, I2> UnwindSafe for Tuple2<I1, I2>
where I1: UnwindSafe, I2: UnwindSafe,

Blanket Implementations§

source§

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

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<'h, I> AsStdIterator<'h> for I
where - I: Iter + 'h,

§

type Iterator = IterAdapter<&'h mut I>

Available on crate feature iter-unstable only.
source§

fn borrow_wiwi_as_std_iterator(&'h mut self) -> IterAdapter<&'h mut I>

Available on crate feature iter-unstable only.
Borrow the wiwi iter as an std iterator.
source§

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

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<'h, I> AsStdIterator<'h> for I
where + I: Iter + 'h,

§

type Iterator = IterAdapter<&'h mut I>

Available on crate feature iter-unstable only.
source§

fn borrow_wiwi_as_std_iterator(&'h mut self) -> IterAdapter<&'h mut I>

Available on crate feature iter-unstable only.
Borrow the wiwi iter as an std iterator.
source§

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

source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

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

source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

Returns the argument unchanged.

source§

impl<T, U> Into<U> for T
where @@ -37,8 +37,8 @@

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

source§

impl<I> IntoIter for I
where - I: Iter,

§

type Item = <I as Iter>::Item

Available on crate feature iter-unstable only.
§

type Iter = I

Available on crate feature iter-unstable only.
source§

fn into_wiwi_iter(self) -> I

Available on crate feature iter-unstable only.
source§

impl<I> IntoStdIterator for I
where - I: IntoIter,

§

type Iterator = IterAdapter<<I as IntoIter>::Iter>

Available on crate feature iter-unstable only.
source§

fn convert_wiwi_into_std_iterator(self) -> IterAdapter<<I as IntoIter>::Iter>

Available on crate feature iter-unstable only.
Converts the wiwi iter into a std iterator.
source§

impl<T> Same for T

§

type Output = T

Should always be Self
source§

impl<T> ToMaybeUninit for T

source§

unsafe fn to_maybeuninit(&self) -> &MaybeUninit<T>

Available on crate feature to-maybeuninit only.
source§

unsafe fn to_maybeuninit_mut(&mut self) -> &mut MaybeUninit<T>

Available on crate feature to-maybeuninit only.
source§

unsafe fn to_maybeuninit_drop(&mut self) -> &mut MaybeUninit<T>

Available on crate feature to-maybeuninit only.
Safety Read more
source§

impl<T, U> TryFrom<U> for T
where + I: Iter,

§

type Item = <I as Iter>::Item

Available on crate feature iter-unstable only.
§

type Iter = I

Available on crate feature iter-unstable only.
source§

fn into_wiwi_iter(self) -> I

Available on crate feature iter-unstable only.
source§

impl<I> IntoStdIterator for I
where + I: IntoIter,

§

type Iterator = IterAdapter<<I as IntoIter>::Iter>

Available on crate feature iter-unstable only.
source§

fn convert_wiwi_into_std_iterator(self) -> IterAdapter<<I as IntoIter>::Iter>

Available on crate feature iter-unstable only.
Converts the wiwi iter into a std iterator.
source§

impl<T> Same for T

§

type Output = T

Should always be Self
source§

impl<T> ToMaybeUninit for T

source§

unsafe fn to_maybeuninit(&self) -> &MaybeUninit<T>

Available on crate feature to-maybeuninit only.
source§

unsafe fn to_maybeuninit_mut(&mut self) -> &mut MaybeUninit<T>

Available on crate feature to-maybeuninit only.
source§

unsafe fn to_maybeuninit_drop(&mut self) -> &mut MaybeUninit<T>

Available on crate feature to-maybeuninit only.
Safety Read more
source§

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

§

type Error = Infallible

The type returned in the event of a conversion error.
source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

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

§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
§

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

§

fn vzip(self) -> V

\ No newline at end of file diff --git a/wiwi/iter/struct.Tuple20.html b/wiwi/iter/struct.Tuple20.html index 83dee8731..6b9179b1b 100644 --- a/wiwi/iter/struct.Tuple20.html +++ b/wiwi/iter/struct.Tuple20.html @@ -27,12 +27,12 @@ I17: Iter, I18: Iter, I19: Iter, - I20: Iter,
§

type Item = (<I1 as Iter>::Item, <I2 as Iter>::Item, <I3 as Iter>::Item, <I4 as Iter>::Item, <I5 as Iter>::Item, <I6 as Iter>::Item, <I7 as Iter>::Item, <I8 as Iter>::Item, <I9 as Iter>::Item, <I10 as Iter>::Item, <I11 as Iter>::Item, <I12 as Iter>::Item, <I13 as Iter>::Item, <I14 as Iter>::Item, <I15 as Iter>::Item, <I16 as Iter>::Item, <I17 as Iter>::Item, <I18 as Iter>::Item, <I19 as Iter>::Item, <I20 as Iter>::Item)

source§

fn next(&mut self) -> Option<Self::Item>

source§

fn size_hint(&self) -> SizeHint

source§

fn for_each<F>(self, f: F)
where + I20: Iter,

§

type Item = (<I1 as Iter>::Item, <I2 as Iter>::Item, <I3 as Iter>::Item, <I4 as Iter>::Item, <I5 as Iter>::Item, <I6 as Iter>::Item, <I7 as Iter>::Item, <I8 as Iter>::Item, <I9 as Iter>::Item, <I10 as Iter>::Item, <I11 as Iter>::Item, <I12 as Iter>::Item, <I13 as Iter>::Item, <I14 as Iter>::Item, <I15 as Iter>::Item, <I16 as Iter>::Item, <I17 as Iter>::Item, <I18 as Iter>::Item, <I19 as Iter>::Item, <I20 as Iter>::Item)

source§

fn next(&mut self) -> Option<Self::Item>

source§

fn size_hint(&self) -> SizeHint

source§

fn for_each<F>(self, f: F)
where Self: Sized, - F: FnMut(Self::Item),

source§

fn peekable(self) -> Peek<Self, Self::Item>
where - Self: Sized,

source§

fn map<O, F>(self, f: F) -> Map<Self, F>
where + F: FnMut(Self::Item),

source§

fn peekable(self) -> Peek<Self, Self::Item>
where + Self: Sized,

source§

fn map<O, F>(self, f: F) -> Map<Self, F>
where Self: Sized, - F: FnMut(Self::Item) -> O,

source§

fn count(self) -> usize
where + F: FnMut(Self::Item) -> O,

source§

fn count(self) -> usize
where Self: Sized,

Consumes the iter and returns the number of items that were emitted. Read more

Auto Trait Implementations§

§

impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20> Freeze for Tuple20<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20>
where I1: Freeze, I2: Freeze, @@ -154,8 +154,8 @@ I18: UnwindSafe, I19: UnwindSafe, I20: UnwindSafe,

Blanket Implementations§

source§

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

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<'h, I> AsStdIterator<'h> for I
where - I: Iter + 'h,

§

type Iterator = IterAdapter<&'h mut I>

Available on crate feature iter-unstable only.
source§

fn borrow_wiwi_as_std_iterator(&'h mut self) -> IterAdapter<&'h mut I>

Available on crate feature iter-unstable only.
Borrow the wiwi iter as an std iterator.
source§

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

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<'h, I> AsStdIterator<'h> for I
where + I: Iter + 'h,

§

type Iterator = IterAdapter<&'h mut I>

Available on crate feature iter-unstable only.
source§

fn borrow_wiwi_as_std_iterator(&'h mut self) -> IterAdapter<&'h mut I>

Available on crate feature iter-unstable only.
Borrow the wiwi iter as an std iterator.
source§

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

source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

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

source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

Returns the argument unchanged.

source§

impl<T, U> Into<U> for T
where @@ -163,8 +163,8 @@

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

source§

impl<I> IntoIter for I
where - I: Iter,

§

type Item = <I as Iter>::Item

Available on crate feature iter-unstable only.
§

type Iter = I

Available on crate feature iter-unstable only.
source§

fn into_wiwi_iter(self) -> I

Available on crate feature iter-unstable only.
source§

impl<I> IntoStdIterator for I
where - I: IntoIter,

§

type Iterator = IterAdapter<<I as IntoIter>::Iter>

Available on crate feature iter-unstable only.
source§

fn convert_wiwi_into_std_iterator(self) -> IterAdapter<<I as IntoIter>::Iter>

Available on crate feature iter-unstable only.
Converts the wiwi iter into a std iterator.
source§

impl<T> Same for T

§

type Output = T

Should always be Self
source§

impl<T> ToMaybeUninit for T

source§

unsafe fn to_maybeuninit(&self) -> &MaybeUninit<T>

Available on crate feature to-maybeuninit only.
source§

unsafe fn to_maybeuninit_mut(&mut self) -> &mut MaybeUninit<T>

Available on crate feature to-maybeuninit only.
source§

unsafe fn to_maybeuninit_drop(&mut self) -> &mut MaybeUninit<T>

Available on crate feature to-maybeuninit only.
Safety Read more
source§

impl<T, U> TryFrom<U> for T
where + I: Iter,

§

type Item = <I as Iter>::Item

Available on crate feature iter-unstable only.
§

type Iter = I

Available on crate feature iter-unstable only.
source§

fn into_wiwi_iter(self) -> I

Available on crate feature iter-unstable only.
source§

impl<I> IntoStdIterator for I
where + I: IntoIter,

§

type Iterator = IterAdapter<<I as IntoIter>::Iter>

Available on crate feature iter-unstable only.
source§

fn convert_wiwi_into_std_iterator(self) -> IterAdapter<<I as IntoIter>::Iter>

Available on crate feature iter-unstable only.
Converts the wiwi iter into a std iterator.
source§

impl<T> Same for T

§

type Output = T

Should always be Self
source§

impl<T> ToMaybeUninit for T

source§

unsafe fn to_maybeuninit(&self) -> &MaybeUninit<T>

Available on crate feature to-maybeuninit only.
source§

unsafe fn to_maybeuninit_mut(&mut self) -> &mut MaybeUninit<T>

Available on crate feature to-maybeuninit only.
source§

unsafe fn to_maybeuninit_drop(&mut self) -> &mut MaybeUninit<T>

Available on crate feature to-maybeuninit only.
Safety Read more
source§

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

§

type Error = Infallible

The type returned in the event of a conversion error.
source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

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

§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
§

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

§

fn vzip(self) -> V

\ No newline at end of file diff --git a/wiwi/iter/struct.Tuple21.html b/wiwi/iter/struct.Tuple21.html index 68c2b6d88..08661a1d7 100644 --- a/wiwi/iter/struct.Tuple21.html +++ b/wiwi/iter/struct.Tuple21.html @@ -28,12 +28,12 @@ I18: Iter, I19: Iter, I20: Iter, - I21: Iter,
§

type Item = (<I1 as Iter>::Item, <I2 as Iter>::Item, <I3 as Iter>::Item, <I4 as Iter>::Item, <I5 as Iter>::Item, <I6 as Iter>::Item, <I7 as Iter>::Item, <I8 as Iter>::Item, <I9 as Iter>::Item, <I10 as Iter>::Item, <I11 as Iter>::Item, <I12 as Iter>::Item, <I13 as Iter>::Item, <I14 as Iter>::Item, <I15 as Iter>::Item, <I16 as Iter>::Item, <I17 as Iter>::Item, <I18 as Iter>::Item, <I19 as Iter>::Item, <I20 as Iter>::Item, <I21 as Iter>::Item)

source§

fn next(&mut self) -> Option<Self::Item>

source§

fn size_hint(&self) -> SizeHint

source§

fn for_each<F>(self, f: F)
where + I21: Iter,

§

type Item = (<I1 as Iter>::Item, <I2 as Iter>::Item, <I3 as Iter>::Item, <I4 as Iter>::Item, <I5 as Iter>::Item, <I6 as Iter>::Item, <I7 as Iter>::Item, <I8 as Iter>::Item, <I9 as Iter>::Item, <I10 as Iter>::Item, <I11 as Iter>::Item, <I12 as Iter>::Item, <I13 as Iter>::Item, <I14 as Iter>::Item, <I15 as Iter>::Item, <I16 as Iter>::Item, <I17 as Iter>::Item, <I18 as Iter>::Item, <I19 as Iter>::Item, <I20 as Iter>::Item, <I21 as Iter>::Item)

source§

fn next(&mut self) -> Option<Self::Item>

source§

fn size_hint(&self) -> SizeHint

source§

fn for_each<F>(self, f: F)
where Self: Sized, - F: FnMut(Self::Item),

source§

fn peekable(self) -> Peek<Self, Self::Item>
where - Self: Sized,

source§

fn map<O, F>(self, f: F) -> Map<Self, F>
where + F: FnMut(Self::Item),

source§

fn peekable(self) -> Peek<Self, Self::Item>
where + Self: Sized,

source§

fn map<O, F>(self, f: F) -> Map<Self, F>
where Self: Sized, - F: FnMut(Self::Item) -> O,

source§

fn count(self) -> usize
where + F: FnMut(Self::Item) -> O,

source§

fn count(self) -> usize
where Self: Sized,

Consumes the iter and returns the number of items that were emitted. Read more

Auto Trait Implementations§

§

impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21> Freeze for Tuple21<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21>
where I1: Freeze, I2: Freeze, @@ -161,8 +161,8 @@ I19: UnwindSafe, I20: UnwindSafe, I21: UnwindSafe,

Blanket Implementations§

source§

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

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<'h, I> AsStdIterator<'h> for I
where - I: Iter + 'h,

§

type Iterator = IterAdapter<&'h mut I>

Available on crate feature iter-unstable only.
source§

fn borrow_wiwi_as_std_iterator(&'h mut self) -> IterAdapter<&'h mut I>

Available on crate feature iter-unstable only.
Borrow the wiwi iter as an std iterator.
source§

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

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<'h, I> AsStdIterator<'h> for I
where + I: Iter + 'h,

§

type Iterator = IterAdapter<&'h mut I>

Available on crate feature iter-unstable only.
source§

fn borrow_wiwi_as_std_iterator(&'h mut self) -> IterAdapter<&'h mut I>

Available on crate feature iter-unstable only.
Borrow the wiwi iter as an std iterator.
source§

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

source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

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

source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

Returns the argument unchanged.

source§

impl<T, U> Into<U> for T
where @@ -170,8 +170,8 @@

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

source§

impl<I> IntoIter for I
where - I: Iter,

§

type Item = <I as Iter>::Item

Available on crate feature iter-unstable only.
§

type Iter = I

Available on crate feature iter-unstable only.
source§

fn into_wiwi_iter(self) -> I

Available on crate feature iter-unstable only.
source§

impl<I> IntoStdIterator for I
where - I: IntoIter,

§

type Iterator = IterAdapter<<I as IntoIter>::Iter>

Available on crate feature iter-unstable only.
source§

fn convert_wiwi_into_std_iterator(self) -> IterAdapter<<I as IntoIter>::Iter>

Available on crate feature iter-unstable only.
Converts the wiwi iter into a std iterator.
source§

impl<T> Same for T

§

type Output = T

Should always be Self
source§

impl<T> ToMaybeUninit for T

source§

unsafe fn to_maybeuninit(&self) -> &MaybeUninit<T>

Available on crate feature to-maybeuninit only.
source§

unsafe fn to_maybeuninit_mut(&mut self) -> &mut MaybeUninit<T>

Available on crate feature to-maybeuninit only.
source§

unsafe fn to_maybeuninit_drop(&mut self) -> &mut MaybeUninit<T>

Available on crate feature to-maybeuninit only.
Safety Read more
source§

impl<T, U> TryFrom<U> for T
where + I: Iter,

§

type Item = <I as Iter>::Item

Available on crate feature iter-unstable only.
§

type Iter = I

Available on crate feature iter-unstable only.
source§

fn into_wiwi_iter(self) -> I

Available on crate feature iter-unstable only.
source§

impl<I> IntoStdIterator for I
where + I: IntoIter,

§

type Iterator = IterAdapter<<I as IntoIter>::Iter>

Available on crate feature iter-unstable only.
source§

fn convert_wiwi_into_std_iterator(self) -> IterAdapter<<I as IntoIter>::Iter>

Available on crate feature iter-unstable only.
Converts the wiwi iter into a std iterator.
source§

impl<T> Same for T

§

type Output = T

Should always be Self
source§

impl<T> ToMaybeUninit for T

source§

unsafe fn to_maybeuninit(&self) -> &MaybeUninit<T>

Available on crate feature to-maybeuninit only.
source§

unsafe fn to_maybeuninit_mut(&mut self) -> &mut MaybeUninit<T>

Available on crate feature to-maybeuninit only.
source§

unsafe fn to_maybeuninit_drop(&mut self) -> &mut MaybeUninit<T>

Available on crate feature to-maybeuninit only.
Safety Read more
source§

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

§

type Error = Infallible

The type returned in the event of a conversion error.
source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

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

§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
§

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

§

fn vzip(self) -> V

\ No newline at end of file diff --git a/wiwi/iter/struct.Tuple22.html b/wiwi/iter/struct.Tuple22.html index c02094b7b..16d5515a9 100644 --- a/wiwi/iter/struct.Tuple22.html +++ b/wiwi/iter/struct.Tuple22.html @@ -29,12 +29,12 @@ I19: Iter, I20: Iter, I21: Iter, - I22: Iter,
§

type Item = (<I1 as Iter>::Item, <I2 as Iter>::Item, <I3 as Iter>::Item, <I4 as Iter>::Item, <I5 as Iter>::Item, <I6 as Iter>::Item, <I7 as Iter>::Item, <I8 as Iter>::Item, <I9 as Iter>::Item, <I10 as Iter>::Item, <I11 as Iter>::Item, <I12 as Iter>::Item, <I13 as Iter>::Item, <I14 as Iter>::Item, <I15 as Iter>::Item, <I16 as Iter>::Item, <I17 as Iter>::Item, <I18 as Iter>::Item, <I19 as Iter>::Item, <I20 as Iter>::Item, <I21 as Iter>::Item, <I22 as Iter>::Item)

source§

fn next(&mut self) -> Option<Self::Item>

source§

fn size_hint(&self) -> SizeHint

source§

fn for_each<F>(self, f: F)
where + I22: Iter,

§

type Item = (<I1 as Iter>::Item, <I2 as Iter>::Item, <I3 as Iter>::Item, <I4 as Iter>::Item, <I5 as Iter>::Item, <I6 as Iter>::Item, <I7 as Iter>::Item, <I8 as Iter>::Item, <I9 as Iter>::Item, <I10 as Iter>::Item, <I11 as Iter>::Item, <I12 as Iter>::Item, <I13 as Iter>::Item, <I14 as Iter>::Item, <I15 as Iter>::Item, <I16 as Iter>::Item, <I17 as Iter>::Item, <I18 as Iter>::Item, <I19 as Iter>::Item, <I20 as Iter>::Item, <I21 as Iter>::Item, <I22 as Iter>::Item)

source§

fn next(&mut self) -> Option<Self::Item>

source§

fn size_hint(&self) -> SizeHint

source§

fn for_each<F>(self, f: F)
where Self: Sized, - F: FnMut(Self::Item),

source§

fn peekable(self) -> Peek<Self, Self::Item>
where - Self: Sized,

source§

fn map<O, F>(self, f: F) -> Map<Self, F>
where + F: FnMut(Self::Item),

source§

fn peekable(self) -> Peek<Self, Self::Item>
where + Self: Sized,

source§

fn map<O, F>(self, f: F) -> Map<Self, F>
where Self: Sized, - F: FnMut(Self::Item) -> O,

source§

fn count(self) -> usize
where + F: FnMut(Self::Item) -> O,

source§

fn count(self) -> usize
where Self: Sized,

Consumes the iter and returns the number of items that were emitted. Read more

Auto Trait Implementations§

§

impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22> Freeze for Tuple22<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22>
where I1: Freeze, I2: Freeze, @@ -168,8 +168,8 @@ I20: UnwindSafe, I21: UnwindSafe, I22: UnwindSafe,

Blanket Implementations§

source§

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

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<'h, I> AsStdIterator<'h> for I
where - I: Iter + 'h,

§

type Iterator = IterAdapter<&'h mut I>

Available on crate feature iter-unstable only.
source§

fn borrow_wiwi_as_std_iterator(&'h mut self) -> IterAdapter<&'h mut I>

Available on crate feature iter-unstable only.
Borrow the wiwi iter as an std iterator.
source§

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

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<'h, I> AsStdIterator<'h> for I
where + I: Iter + 'h,

§

type Iterator = IterAdapter<&'h mut I>

Available on crate feature iter-unstable only.
source§

fn borrow_wiwi_as_std_iterator(&'h mut self) -> IterAdapter<&'h mut I>

Available on crate feature iter-unstable only.
Borrow the wiwi iter as an std iterator.
source§

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

source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

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

source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

Returns the argument unchanged.

source§

impl<T, U> Into<U> for T
where @@ -177,8 +177,8 @@

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

source§

impl<I> IntoIter for I
where - I: Iter,

§

type Item = <I as Iter>::Item

Available on crate feature iter-unstable only.
§

type Iter = I

Available on crate feature iter-unstable only.
source§

fn into_wiwi_iter(self) -> I

Available on crate feature iter-unstable only.
source§

impl<I> IntoStdIterator for I
where - I: IntoIter,

§

type Iterator = IterAdapter<<I as IntoIter>::Iter>

Available on crate feature iter-unstable only.
source§

fn convert_wiwi_into_std_iterator(self) -> IterAdapter<<I as IntoIter>::Iter>

Available on crate feature iter-unstable only.
Converts the wiwi iter into a std iterator.
source§

impl<T> Same for T

§

type Output = T

Should always be Self
source§

impl<T> ToMaybeUninit for T

source§

unsafe fn to_maybeuninit(&self) -> &MaybeUninit<T>

Available on crate feature to-maybeuninit only.
source§

unsafe fn to_maybeuninit_mut(&mut self) -> &mut MaybeUninit<T>

Available on crate feature to-maybeuninit only.
source§

unsafe fn to_maybeuninit_drop(&mut self) -> &mut MaybeUninit<T>

Available on crate feature to-maybeuninit only.
Safety Read more
source§

impl<T, U> TryFrom<U> for T
where + I: Iter,

§

type Item = <I as Iter>::Item

Available on crate feature iter-unstable only.
§

type Iter = I

Available on crate feature iter-unstable only.
source§

fn into_wiwi_iter(self) -> I

Available on crate feature iter-unstable only.
source§

impl<I> IntoStdIterator for I
where + I: IntoIter,

§

type Iterator = IterAdapter<<I as IntoIter>::Iter>

Available on crate feature iter-unstable only.
source§

fn convert_wiwi_into_std_iterator(self) -> IterAdapter<<I as IntoIter>::Iter>

Available on crate feature iter-unstable only.
Converts the wiwi iter into a std iterator.
source§

impl<T> Same for T

§

type Output = T

Should always be Self
source§

impl<T> ToMaybeUninit for T

source§

unsafe fn to_maybeuninit(&self) -> &MaybeUninit<T>

Available on crate feature to-maybeuninit only.
source§

unsafe fn to_maybeuninit_mut(&mut self) -> &mut MaybeUninit<T>

Available on crate feature to-maybeuninit only.
source§

unsafe fn to_maybeuninit_drop(&mut self) -> &mut MaybeUninit<T>

Available on crate feature to-maybeuninit only.
Safety Read more
source§

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

§

type Error = Infallible

The type returned in the event of a conversion error.
source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

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

§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
§

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

§

fn vzip(self) -> V

\ No newline at end of file diff --git a/wiwi/iter/struct.Tuple23.html b/wiwi/iter/struct.Tuple23.html index 62b1da357..618cf6f08 100644 --- a/wiwi/iter/struct.Tuple23.html +++ b/wiwi/iter/struct.Tuple23.html @@ -30,12 +30,12 @@ I20: Iter, I21: Iter, I22: Iter, - I23: Iter,
§

type Item = (<I1 as Iter>::Item, <I2 as Iter>::Item, <I3 as Iter>::Item, <I4 as Iter>::Item, <I5 as Iter>::Item, <I6 as Iter>::Item, <I7 as Iter>::Item, <I8 as Iter>::Item, <I9 as Iter>::Item, <I10 as Iter>::Item, <I11 as Iter>::Item, <I12 as Iter>::Item, <I13 as Iter>::Item, <I14 as Iter>::Item, <I15 as Iter>::Item, <I16 as Iter>::Item, <I17 as Iter>::Item, <I18 as Iter>::Item, <I19 as Iter>::Item, <I20 as Iter>::Item, <I21 as Iter>::Item, <I22 as Iter>::Item, <I23 as Iter>::Item)

source§

fn next(&mut self) -> Option<Self::Item>

source§

fn size_hint(&self) -> SizeHint

source§

fn for_each<F>(self, f: F)
where + I23: Iter,

§

type Item = (<I1 as Iter>::Item, <I2 as Iter>::Item, <I3 as Iter>::Item, <I4 as Iter>::Item, <I5 as Iter>::Item, <I6 as Iter>::Item, <I7 as Iter>::Item, <I8 as Iter>::Item, <I9 as Iter>::Item, <I10 as Iter>::Item, <I11 as Iter>::Item, <I12 as Iter>::Item, <I13 as Iter>::Item, <I14 as Iter>::Item, <I15 as Iter>::Item, <I16 as Iter>::Item, <I17 as Iter>::Item, <I18 as Iter>::Item, <I19 as Iter>::Item, <I20 as Iter>::Item, <I21 as Iter>::Item, <I22 as Iter>::Item, <I23 as Iter>::Item)

source§

fn next(&mut self) -> Option<Self::Item>

source§

fn size_hint(&self) -> SizeHint

source§

fn for_each<F>(self, f: F)
where Self: Sized, - F: FnMut(Self::Item),

source§

fn peekable(self) -> Peek<Self, Self::Item>
where - Self: Sized,

source§

fn map<O, F>(self, f: F) -> Map<Self, F>
where + F: FnMut(Self::Item),

source§

fn peekable(self) -> Peek<Self, Self::Item>
where + Self: Sized,

source§

fn map<O, F>(self, f: F) -> Map<Self, F>
where Self: Sized, - F: FnMut(Self::Item) -> O,

source§

fn count(self) -> usize
where + F: FnMut(Self::Item) -> O,

source§

fn count(self) -> usize
where Self: Sized,

Consumes the iter and returns the number of items that were emitted. Read more

Auto Trait Implementations§

§

impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23> Freeze for Tuple23<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23>
where I1: Freeze, I2: Freeze, @@ -175,8 +175,8 @@ I21: UnwindSafe, I22: UnwindSafe, I23: UnwindSafe,

Blanket Implementations§

source§

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

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<'h, I> AsStdIterator<'h> for I
where - I: Iter + 'h,

§

type Iterator = IterAdapter<&'h mut I>

Available on crate feature iter-unstable only.
source§

fn borrow_wiwi_as_std_iterator(&'h mut self) -> IterAdapter<&'h mut I>

Available on crate feature iter-unstable only.
Borrow the wiwi iter as an std iterator.
source§

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

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<'h, I> AsStdIterator<'h> for I
where + I: Iter + 'h,

§

type Iterator = IterAdapter<&'h mut I>

Available on crate feature iter-unstable only.
source§

fn borrow_wiwi_as_std_iterator(&'h mut self) -> IterAdapter<&'h mut I>

Available on crate feature iter-unstable only.
Borrow the wiwi iter as an std iterator.
source§

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

source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

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

source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

Returns the argument unchanged.

source§

impl<T, U> Into<U> for T
where @@ -184,8 +184,8 @@

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

source§

impl<I> IntoIter for I
where - I: Iter,

§

type Item = <I as Iter>::Item

Available on crate feature iter-unstable only.
§

type Iter = I

Available on crate feature iter-unstable only.
source§

fn into_wiwi_iter(self) -> I

Available on crate feature iter-unstable only.
source§

impl<I> IntoStdIterator for I
where - I: IntoIter,

§

type Iterator = IterAdapter<<I as IntoIter>::Iter>

Available on crate feature iter-unstable only.
source§

fn convert_wiwi_into_std_iterator(self) -> IterAdapter<<I as IntoIter>::Iter>

Available on crate feature iter-unstable only.
Converts the wiwi iter into a std iterator.
source§

impl<T> Same for T

§

type Output = T

Should always be Self
source§

impl<T> ToMaybeUninit for T

source§

unsafe fn to_maybeuninit(&self) -> &MaybeUninit<T>

Available on crate feature to-maybeuninit only.
source§

unsafe fn to_maybeuninit_mut(&mut self) -> &mut MaybeUninit<T>

Available on crate feature to-maybeuninit only.
source§

unsafe fn to_maybeuninit_drop(&mut self) -> &mut MaybeUninit<T>

Available on crate feature to-maybeuninit only.
Safety Read more
source§

impl<T, U> TryFrom<U> for T
where + I: Iter,

§

type Item = <I as Iter>::Item

Available on crate feature iter-unstable only.
§

type Iter = I

Available on crate feature iter-unstable only.
source§

fn into_wiwi_iter(self) -> I

Available on crate feature iter-unstable only.
source§

impl<I> IntoStdIterator for I
where + I: IntoIter,

§

type Iterator = IterAdapter<<I as IntoIter>::Iter>

Available on crate feature iter-unstable only.
source§

fn convert_wiwi_into_std_iterator(self) -> IterAdapter<<I as IntoIter>::Iter>

Available on crate feature iter-unstable only.
Converts the wiwi iter into a std iterator.
source§

impl<T> Same for T

§

type Output = T

Should always be Self
source§

impl<T> ToMaybeUninit for T

source§

unsafe fn to_maybeuninit(&self) -> &MaybeUninit<T>

Available on crate feature to-maybeuninit only.
source§

unsafe fn to_maybeuninit_mut(&mut self) -> &mut MaybeUninit<T>

Available on crate feature to-maybeuninit only.
source§

unsafe fn to_maybeuninit_drop(&mut self) -> &mut MaybeUninit<T>

Available on crate feature to-maybeuninit only.
Safety Read more
source§

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

§

type Error = Infallible

The type returned in the event of a conversion error.
source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

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

§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
§

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

§

fn vzip(self) -> V

\ No newline at end of file diff --git a/wiwi/iter/struct.Tuple24.html b/wiwi/iter/struct.Tuple24.html index 73000d62c..cb66c00c9 100644 --- a/wiwi/iter/struct.Tuple24.html +++ b/wiwi/iter/struct.Tuple24.html @@ -31,12 +31,12 @@ I21: Iter, I22: Iter, I23: Iter, - I24: Iter,
§

type Item = (<I1 as Iter>::Item, <I2 as Iter>::Item, <I3 as Iter>::Item, <I4 as Iter>::Item, <I5 as Iter>::Item, <I6 as Iter>::Item, <I7 as Iter>::Item, <I8 as Iter>::Item, <I9 as Iter>::Item, <I10 as Iter>::Item, <I11 as Iter>::Item, <I12 as Iter>::Item, <I13 as Iter>::Item, <I14 as Iter>::Item, <I15 as Iter>::Item, <I16 as Iter>::Item, <I17 as Iter>::Item, <I18 as Iter>::Item, <I19 as Iter>::Item, <I20 as Iter>::Item, <I21 as Iter>::Item, <I22 as Iter>::Item, <I23 as Iter>::Item, <I24 as Iter>::Item)

source§

fn next(&mut self) -> Option<Self::Item>

source§

fn size_hint(&self) -> SizeHint

source§

fn for_each<F>(self, f: F)
where + I24: Iter,

§

type Item = (<I1 as Iter>::Item, <I2 as Iter>::Item, <I3 as Iter>::Item, <I4 as Iter>::Item, <I5 as Iter>::Item, <I6 as Iter>::Item, <I7 as Iter>::Item, <I8 as Iter>::Item, <I9 as Iter>::Item, <I10 as Iter>::Item, <I11 as Iter>::Item, <I12 as Iter>::Item, <I13 as Iter>::Item, <I14 as Iter>::Item, <I15 as Iter>::Item, <I16 as Iter>::Item, <I17 as Iter>::Item, <I18 as Iter>::Item, <I19 as Iter>::Item, <I20 as Iter>::Item, <I21 as Iter>::Item, <I22 as Iter>::Item, <I23 as Iter>::Item, <I24 as Iter>::Item)

source§

fn next(&mut self) -> Option<Self::Item>

source§

fn size_hint(&self) -> SizeHint

source§

fn for_each<F>(self, f: F)
where Self: Sized, - F: FnMut(Self::Item),

source§

fn peekable(self) -> Peek<Self, Self::Item>
where - Self: Sized,

source§

fn map<O, F>(self, f: F) -> Map<Self, F>
where + F: FnMut(Self::Item),

source§

fn peekable(self) -> Peek<Self, Self::Item>
where + Self: Sized,

source§

fn map<O, F>(self, f: F) -> Map<Self, F>
where Self: Sized, - F: FnMut(Self::Item) -> O,

source§

fn count(self) -> usize
where + F: FnMut(Self::Item) -> O,

source§

fn count(self) -> usize
where Self: Sized,

Consumes the iter and returns the number of items that were emitted. Read more

Auto Trait Implementations§

§

impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24> Freeze for Tuple24<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24>
where I1: Freeze, I2: Freeze, @@ -182,8 +182,8 @@ I22: UnwindSafe, I23: UnwindSafe, I24: UnwindSafe,

Blanket Implementations§

source§

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

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<'h, I> AsStdIterator<'h> for I
where - I: Iter + 'h,

§

type Iterator = IterAdapter<&'h mut I>

Available on crate feature iter-unstable only.
source§

fn borrow_wiwi_as_std_iterator(&'h mut self) -> IterAdapter<&'h mut I>

Available on crate feature iter-unstable only.
Borrow the wiwi iter as an std iterator.
source§

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

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<'h, I> AsStdIterator<'h> for I
where + I: Iter + 'h,

§

type Iterator = IterAdapter<&'h mut I>

Available on crate feature iter-unstable only.
source§

fn borrow_wiwi_as_std_iterator(&'h mut self) -> IterAdapter<&'h mut I>

Available on crate feature iter-unstable only.
Borrow the wiwi iter as an std iterator.
source§

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

source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

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

source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

Returns the argument unchanged.

source§

impl<T, U> Into<U> for T
where @@ -191,8 +191,8 @@

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

source§

impl<I> IntoIter for I
where - I: Iter,

§

type Item = <I as Iter>::Item

Available on crate feature iter-unstable only.
§

type Iter = I

Available on crate feature iter-unstable only.
source§

fn into_wiwi_iter(self) -> I

Available on crate feature iter-unstable only.
source§

impl<I> IntoStdIterator for I
where - I: IntoIter,

§

type Iterator = IterAdapter<<I as IntoIter>::Iter>

Available on crate feature iter-unstable only.
source§

fn convert_wiwi_into_std_iterator(self) -> IterAdapter<<I as IntoIter>::Iter>

Available on crate feature iter-unstable only.
Converts the wiwi iter into a std iterator.
source§

impl<T> Same for T

§

type Output = T

Should always be Self
source§

impl<T> ToMaybeUninit for T

source§

unsafe fn to_maybeuninit(&self) -> &MaybeUninit<T>

Available on crate feature to-maybeuninit only.
source§

unsafe fn to_maybeuninit_mut(&mut self) -> &mut MaybeUninit<T>

Available on crate feature to-maybeuninit only.
source§

unsafe fn to_maybeuninit_drop(&mut self) -> &mut MaybeUninit<T>

Available on crate feature to-maybeuninit only.
Safety Read more
source§

impl<T, U> TryFrom<U> for T
where + I: Iter,

§

type Item = <I as Iter>::Item

Available on crate feature iter-unstable only.
§

type Iter = I

Available on crate feature iter-unstable only.
source§

fn into_wiwi_iter(self) -> I

Available on crate feature iter-unstable only.
source§

impl<I> IntoStdIterator for I
where + I: IntoIter,

§

type Iterator = IterAdapter<<I as IntoIter>::Iter>

Available on crate feature iter-unstable only.
source§

fn convert_wiwi_into_std_iterator(self) -> IterAdapter<<I as IntoIter>::Iter>

Available on crate feature iter-unstable only.
Converts the wiwi iter into a std iterator.
source§

impl<T> Same for T

§

type Output = T

Should always be Self
source§

impl<T> ToMaybeUninit for T

source§

unsafe fn to_maybeuninit(&self) -> &MaybeUninit<T>

Available on crate feature to-maybeuninit only.
source§

unsafe fn to_maybeuninit_mut(&mut self) -> &mut MaybeUninit<T>

Available on crate feature to-maybeuninit only.
source§

unsafe fn to_maybeuninit_drop(&mut self) -> &mut MaybeUninit<T>

Available on crate feature to-maybeuninit only.
Safety Read more
source§

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

§

type Error = Infallible

The type returned in the event of a conversion error.
source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

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

§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
§

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

§

fn vzip(self) -> V

\ No newline at end of file diff --git a/wiwi/iter/struct.Tuple25.html b/wiwi/iter/struct.Tuple25.html index f82f1b5e4..cd098996d 100644 --- a/wiwi/iter/struct.Tuple25.html +++ b/wiwi/iter/struct.Tuple25.html @@ -32,12 +32,12 @@ I22: Iter, I23: Iter, I24: Iter, - I25: Iter,
§

type Item = (<I1 as Iter>::Item, <I2 as Iter>::Item, <I3 as Iter>::Item, <I4 as Iter>::Item, <I5 as Iter>::Item, <I6 as Iter>::Item, <I7 as Iter>::Item, <I8 as Iter>::Item, <I9 as Iter>::Item, <I10 as Iter>::Item, <I11 as Iter>::Item, <I12 as Iter>::Item, <I13 as Iter>::Item, <I14 as Iter>::Item, <I15 as Iter>::Item, <I16 as Iter>::Item, <I17 as Iter>::Item, <I18 as Iter>::Item, <I19 as Iter>::Item, <I20 as Iter>::Item, <I21 as Iter>::Item, <I22 as Iter>::Item, <I23 as Iter>::Item, <I24 as Iter>::Item, <I25 as Iter>::Item)

source§

fn next(&mut self) -> Option<Self::Item>

source§

fn size_hint(&self) -> SizeHint

source§

fn for_each<F>(self, f: F)
where + I25: Iter,

§

type Item = (<I1 as Iter>::Item, <I2 as Iter>::Item, <I3 as Iter>::Item, <I4 as Iter>::Item, <I5 as Iter>::Item, <I6 as Iter>::Item, <I7 as Iter>::Item, <I8 as Iter>::Item, <I9 as Iter>::Item, <I10 as Iter>::Item, <I11 as Iter>::Item, <I12 as Iter>::Item, <I13 as Iter>::Item, <I14 as Iter>::Item, <I15 as Iter>::Item, <I16 as Iter>::Item, <I17 as Iter>::Item, <I18 as Iter>::Item, <I19 as Iter>::Item, <I20 as Iter>::Item, <I21 as Iter>::Item, <I22 as Iter>::Item, <I23 as Iter>::Item, <I24 as Iter>::Item, <I25 as Iter>::Item)

source§

fn next(&mut self) -> Option<Self::Item>

source§

fn size_hint(&self) -> SizeHint

source§

fn for_each<F>(self, f: F)
where Self: Sized, - F: FnMut(Self::Item),

source§

fn peekable(self) -> Peek<Self, Self::Item>
where - Self: Sized,

source§

fn map<O, F>(self, f: F) -> Map<Self, F>
where + F: FnMut(Self::Item),

source§

fn peekable(self) -> Peek<Self, Self::Item>
where + Self: Sized,

source§

fn map<O, F>(self, f: F) -> Map<Self, F>
where Self: Sized, - F: FnMut(Self::Item) -> O,

source§

fn count(self) -> usize
where + F: FnMut(Self::Item) -> O,

source§

fn count(self) -> usize
where Self: Sized,

Consumes the iter and returns the number of items that were emitted. Read more

Auto Trait Implementations§

§

impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24, I25> Freeze for Tuple25<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24, I25>
where I1: Freeze, I2: Freeze, @@ -189,8 +189,8 @@ I23: UnwindSafe, I24: UnwindSafe, I25: UnwindSafe,

Blanket Implementations§

source§

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

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<'h, I> AsStdIterator<'h> for I
where - I: Iter + 'h,

§

type Iterator = IterAdapter<&'h mut I>

Available on crate feature iter-unstable only.
source§

fn borrow_wiwi_as_std_iterator(&'h mut self) -> IterAdapter<&'h mut I>

Available on crate feature iter-unstable only.
Borrow the wiwi iter as an std iterator.
source§

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

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<'h, I> AsStdIterator<'h> for I
where + I: Iter + 'h,

§

type Iterator = IterAdapter<&'h mut I>

Available on crate feature iter-unstable only.
source§

fn borrow_wiwi_as_std_iterator(&'h mut self) -> IterAdapter<&'h mut I>

Available on crate feature iter-unstable only.
Borrow the wiwi iter as an std iterator.
source§

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

source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

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

source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

Returns the argument unchanged.

source§

impl<T, U> Into<U> for T
where @@ -198,8 +198,8 @@

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

source§

impl<I> IntoIter for I
where - I: Iter,

§

type Item = <I as Iter>::Item

Available on crate feature iter-unstable only.
§

type Iter = I

Available on crate feature iter-unstable only.
source§

fn into_wiwi_iter(self) -> I

Available on crate feature iter-unstable only.
source§

impl<I> IntoStdIterator for I
where - I: IntoIter,

§

type Iterator = IterAdapter<<I as IntoIter>::Iter>

Available on crate feature iter-unstable only.
source§

fn convert_wiwi_into_std_iterator(self) -> IterAdapter<<I as IntoIter>::Iter>

Available on crate feature iter-unstable only.
Converts the wiwi iter into a std iterator.
source§

impl<T> Same for T

§

type Output = T

Should always be Self
source§

impl<T> ToMaybeUninit for T

source§

unsafe fn to_maybeuninit(&self) -> &MaybeUninit<T>

Available on crate feature to-maybeuninit only.
source§

unsafe fn to_maybeuninit_mut(&mut self) -> &mut MaybeUninit<T>

Available on crate feature to-maybeuninit only.
source§

unsafe fn to_maybeuninit_drop(&mut self) -> &mut MaybeUninit<T>

Available on crate feature to-maybeuninit only.
Safety Read more
source§

impl<T, U> TryFrom<U> for T
where + I: Iter,

§

type Item = <I as Iter>::Item

Available on crate feature iter-unstable only.
§

type Iter = I

Available on crate feature iter-unstable only.
source§

fn into_wiwi_iter(self) -> I

Available on crate feature iter-unstable only.
source§

impl<I> IntoStdIterator for I
where + I: IntoIter,

§

type Iterator = IterAdapter<<I as IntoIter>::Iter>

Available on crate feature iter-unstable only.
source§

fn convert_wiwi_into_std_iterator(self) -> IterAdapter<<I as IntoIter>::Iter>

Available on crate feature iter-unstable only.
Converts the wiwi iter into a std iterator.
source§

impl<T> Same for T

§

type Output = T

Should always be Self
source§

impl<T> ToMaybeUninit for T

source§

unsafe fn to_maybeuninit(&self) -> &MaybeUninit<T>

Available on crate feature to-maybeuninit only.
source§

unsafe fn to_maybeuninit_mut(&mut self) -> &mut MaybeUninit<T>

Available on crate feature to-maybeuninit only.
source§

unsafe fn to_maybeuninit_drop(&mut self) -> &mut MaybeUninit<T>

Available on crate feature to-maybeuninit only.
Safety Read more
source§

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

§

type Error = Infallible

The type returned in the event of a conversion error.
source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

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

§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
§

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

§

fn vzip(self) -> V

\ No newline at end of file diff --git a/wiwi/iter/struct.Tuple26.html b/wiwi/iter/struct.Tuple26.html index b7caeb81e..e37d8fbed 100644 --- a/wiwi/iter/struct.Tuple26.html +++ b/wiwi/iter/struct.Tuple26.html @@ -33,12 +33,12 @@ I23: Iter, I24: Iter, I25: Iter, - I26: Iter,
§

type Item = (<I1 as Iter>::Item, <I2 as Iter>::Item, <I3 as Iter>::Item, <I4 as Iter>::Item, <I5 as Iter>::Item, <I6 as Iter>::Item, <I7 as Iter>::Item, <I8 as Iter>::Item, <I9 as Iter>::Item, <I10 as Iter>::Item, <I11 as Iter>::Item, <I12 as Iter>::Item, <I13 as Iter>::Item, <I14 as Iter>::Item, <I15 as Iter>::Item, <I16 as Iter>::Item, <I17 as Iter>::Item, <I18 as Iter>::Item, <I19 as Iter>::Item, <I20 as Iter>::Item, <I21 as Iter>::Item, <I22 as Iter>::Item, <I23 as Iter>::Item, <I24 as Iter>::Item, <I25 as Iter>::Item, <I26 as Iter>::Item)

source§

fn next(&mut self) -> Option<Self::Item>

source§

fn size_hint(&self) -> SizeHint

source§

fn for_each<F>(self, f: F)
where + I26: Iter,

§

type Item = (<I1 as Iter>::Item, <I2 as Iter>::Item, <I3 as Iter>::Item, <I4 as Iter>::Item, <I5 as Iter>::Item, <I6 as Iter>::Item, <I7 as Iter>::Item, <I8 as Iter>::Item, <I9 as Iter>::Item, <I10 as Iter>::Item, <I11 as Iter>::Item, <I12 as Iter>::Item, <I13 as Iter>::Item, <I14 as Iter>::Item, <I15 as Iter>::Item, <I16 as Iter>::Item, <I17 as Iter>::Item, <I18 as Iter>::Item, <I19 as Iter>::Item, <I20 as Iter>::Item, <I21 as Iter>::Item, <I22 as Iter>::Item, <I23 as Iter>::Item, <I24 as Iter>::Item, <I25 as Iter>::Item, <I26 as Iter>::Item)

source§

fn next(&mut self) -> Option<Self::Item>

source§

fn size_hint(&self) -> SizeHint

source§

fn for_each<F>(self, f: F)
where Self: Sized, - F: FnMut(Self::Item),

source§

fn peekable(self) -> Peek<Self, Self::Item>
where - Self: Sized,

source§

fn map<O, F>(self, f: F) -> Map<Self, F>
where + F: FnMut(Self::Item),

source§

fn peekable(self) -> Peek<Self, Self::Item>
where + Self: Sized,

source§

fn map<O, F>(self, f: F) -> Map<Self, F>
where Self: Sized, - F: FnMut(Self::Item) -> O,

source§

fn count(self) -> usize
where + F: FnMut(Self::Item) -> O,

source§

fn count(self) -> usize
where Self: Sized,

Consumes the iter and returns the number of items that were emitted. Read more

Auto Trait Implementations§

§

impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24, I25, I26> Freeze for Tuple26<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24, I25, I26>
where I1: Freeze, I2: Freeze, @@ -196,8 +196,8 @@ I24: UnwindSafe, I25: UnwindSafe, I26: UnwindSafe,

Blanket Implementations§

source§

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

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<'h, I> AsStdIterator<'h> for I
where - I: Iter + 'h,

§

type Iterator = IterAdapter<&'h mut I>

Available on crate feature iter-unstable only.
source§

fn borrow_wiwi_as_std_iterator(&'h mut self) -> IterAdapter<&'h mut I>

Available on crate feature iter-unstable only.
Borrow the wiwi iter as an std iterator.
source§

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

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<'h, I> AsStdIterator<'h> for I
where + I: Iter + 'h,

§

type Iterator = IterAdapter<&'h mut I>

Available on crate feature iter-unstable only.
source§

fn borrow_wiwi_as_std_iterator(&'h mut self) -> IterAdapter<&'h mut I>

Available on crate feature iter-unstable only.
Borrow the wiwi iter as an std iterator.
source§

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

source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

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

source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

Returns the argument unchanged.

source§

impl<T, U> Into<U> for T
where @@ -205,8 +205,8 @@

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

source§

impl<I> IntoIter for I
where - I: Iter,

§

type Item = <I as Iter>::Item

Available on crate feature iter-unstable only.
§

type Iter = I

Available on crate feature iter-unstable only.
source§

fn into_wiwi_iter(self) -> I

Available on crate feature iter-unstable only.
source§

impl<I> IntoStdIterator for I
where - I: IntoIter,

§

type Iterator = IterAdapter<<I as IntoIter>::Iter>

Available on crate feature iter-unstable only.
source§

fn convert_wiwi_into_std_iterator(self) -> IterAdapter<<I as IntoIter>::Iter>

Available on crate feature iter-unstable only.
Converts the wiwi iter into a std iterator.
source§

impl<T> Same for T

§

type Output = T

Should always be Self
source§

impl<T> ToMaybeUninit for T

source§

unsafe fn to_maybeuninit(&self) -> &MaybeUninit<T>

Available on crate feature to-maybeuninit only.
source§

unsafe fn to_maybeuninit_mut(&mut self) -> &mut MaybeUninit<T>

Available on crate feature to-maybeuninit only.
source§

unsafe fn to_maybeuninit_drop(&mut self) -> &mut MaybeUninit<T>

Available on crate feature to-maybeuninit only.
Safety Read more
source§

impl<T, U> TryFrom<U> for T
where + I: Iter,

§

type Item = <I as Iter>::Item

Available on crate feature iter-unstable only.
§

type Iter = I

Available on crate feature iter-unstable only.
source§

fn into_wiwi_iter(self) -> I

Available on crate feature iter-unstable only.
source§

impl<I> IntoStdIterator for I
where + I: IntoIter,

§

type Iterator = IterAdapter<<I as IntoIter>::Iter>

Available on crate feature iter-unstable only.
source§

fn convert_wiwi_into_std_iterator(self) -> IterAdapter<<I as IntoIter>::Iter>

Available on crate feature iter-unstable only.
Converts the wiwi iter into a std iterator.
source§

impl<T> Same for T

§

type Output = T

Should always be Self
source§

impl<T> ToMaybeUninit for T

source§

unsafe fn to_maybeuninit(&self) -> &MaybeUninit<T>

Available on crate feature to-maybeuninit only.
source§

unsafe fn to_maybeuninit_mut(&mut self) -> &mut MaybeUninit<T>

Available on crate feature to-maybeuninit only.
source§

unsafe fn to_maybeuninit_drop(&mut self) -> &mut MaybeUninit<T>

Available on crate feature to-maybeuninit only.
Safety Read more
source§

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

§

type Error = Infallible

The type returned in the event of a conversion error.
source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

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

§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
§

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

§

fn vzip(self) -> V

\ No newline at end of file diff --git a/wiwi/iter/struct.Tuple27.html b/wiwi/iter/struct.Tuple27.html index c0cebbedf..c9dd3f4e6 100644 --- a/wiwi/iter/struct.Tuple27.html +++ b/wiwi/iter/struct.Tuple27.html @@ -34,12 +34,12 @@ I24: Iter, I25: Iter, I26: Iter, - I27: Iter,
§

type Item = (<I1 as Iter>::Item, <I2 as Iter>::Item, <I3 as Iter>::Item, <I4 as Iter>::Item, <I5 as Iter>::Item, <I6 as Iter>::Item, <I7 as Iter>::Item, <I8 as Iter>::Item, <I9 as Iter>::Item, <I10 as Iter>::Item, <I11 as Iter>::Item, <I12 as Iter>::Item, <I13 as Iter>::Item, <I14 as Iter>::Item, <I15 as Iter>::Item, <I16 as Iter>::Item, <I17 as Iter>::Item, <I18 as Iter>::Item, <I19 as Iter>::Item, <I20 as Iter>::Item, <I21 as Iter>::Item, <I22 as Iter>::Item, <I23 as Iter>::Item, <I24 as Iter>::Item, <I25 as Iter>::Item, <I26 as Iter>::Item, <I27 as Iter>::Item)

source§

fn next(&mut self) -> Option<Self::Item>

source§

fn size_hint(&self) -> SizeHint

source§

fn for_each<F>(self, f: F)
where + I27: Iter,

§

type Item = (<I1 as Iter>::Item, <I2 as Iter>::Item, <I3 as Iter>::Item, <I4 as Iter>::Item, <I5 as Iter>::Item, <I6 as Iter>::Item, <I7 as Iter>::Item, <I8 as Iter>::Item, <I9 as Iter>::Item, <I10 as Iter>::Item, <I11 as Iter>::Item, <I12 as Iter>::Item, <I13 as Iter>::Item, <I14 as Iter>::Item, <I15 as Iter>::Item, <I16 as Iter>::Item, <I17 as Iter>::Item, <I18 as Iter>::Item, <I19 as Iter>::Item, <I20 as Iter>::Item, <I21 as Iter>::Item, <I22 as Iter>::Item, <I23 as Iter>::Item, <I24 as Iter>::Item, <I25 as Iter>::Item, <I26 as Iter>::Item, <I27 as Iter>::Item)

source§

fn next(&mut self) -> Option<Self::Item>

source§

fn size_hint(&self) -> SizeHint

source§

fn for_each<F>(self, f: F)
where Self: Sized, - F: FnMut(Self::Item),

source§

fn peekable(self) -> Peek<Self, Self::Item>
where - Self: Sized,

source§

fn map<O, F>(self, f: F) -> Map<Self, F>
where + F: FnMut(Self::Item),

source§

fn peekable(self) -> Peek<Self, Self::Item>
where + Self: Sized,

source§

fn map<O, F>(self, f: F) -> Map<Self, F>
where Self: Sized, - F: FnMut(Self::Item) -> O,

source§

fn count(self) -> usize
where + F: FnMut(Self::Item) -> O,

source§

fn count(self) -> usize
where Self: Sized,

Consumes the iter and returns the number of items that were emitted. Read more

Auto Trait Implementations§

§

impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24, I25, I26, I27> Freeze for Tuple27<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24, I25, I26, I27>
where I1: Freeze, I2: Freeze, @@ -203,8 +203,8 @@ I25: UnwindSafe, I26: UnwindSafe, I27: UnwindSafe,

Blanket Implementations§

source§

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

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<'h, I> AsStdIterator<'h> for I
where - I: Iter + 'h,

§

type Iterator = IterAdapter<&'h mut I>

Available on crate feature iter-unstable only.
source§

fn borrow_wiwi_as_std_iterator(&'h mut self) -> IterAdapter<&'h mut I>

Available on crate feature iter-unstable only.
Borrow the wiwi iter as an std iterator.
source§

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

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<'h, I> AsStdIterator<'h> for I
where + I: Iter + 'h,

§

type Iterator = IterAdapter<&'h mut I>

Available on crate feature iter-unstable only.
source§

fn borrow_wiwi_as_std_iterator(&'h mut self) -> IterAdapter<&'h mut I>

Available on crate feature iter-unstable only.
Borrow the wiwi iter as an std iterator.
source§

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

source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

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

source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

Returns the argument unchanged.

source§

impl<T, U> Into<U> for T
where @@ -212,8 +212,8 @@

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

source§

impl<I> IntoIter for I
where - I: Iter,

§

type Item = <I as Iter>::Item

Available on crate feature iter-unstable only.
§

type Iter = I

Available on crate feature iter-unstable only.
source§

fn into_wiwi_iter(self) -> I

Available on crate feature iter-unstable only.
source§

impl<I> IntoStdIterator for I
where - I: IntoIter,

§

type Iterator = IterAdapter<<I as IntoIter>::Iter>

Available on crate feature iter-unstable only.
source§

fn convert_wiwi_into_std_iterator(self) -> IterAdapter<<I as IntoIter>::Iter>

Available on crate feature iter-unstable only.
Converts the wiwi iter into a std iterator.
source§

impl<T> Same for T

§

type Output = T

Should always be Self
source§

impl<T> ToMaybeUninit for T

source§

unsafe fn to_maybeuninit(&self) -> &MaybeUninit<T>

Available on crate feature to-maybeuninit only.
source§

unsafe fn to_maybeuninit_mut(&mut self) -> &mut MaybeUninit<T>

Available on crate feature to-maybeuninit only.
source§

unsafe fn to_maybeuninit_drop(&mut self) -> &mut MaybeUninit<T>

Available on crate feature to-maybeuninit only.
Safety Read more
source§

impl<T, U> TryFrom<U> for T
where + I: Iter,

§

type Item = <I as Iter>::Item

Available on crate feature iter-unstable only.
§

type Iter = I

Available on crate feature iter-unstable only.
source§

fn into_wiwi_iter(self) -> I

Available on crate feature iter-unstable only.
source§

impl<I> IntoStdIterator for I
where + I: IntoIter,

§

type Iterator = IterAdapter<<I as IntoIter>::Iter>

Available on crate feature iter-unstable only.
source§

fn convert_wiwi_into_std_iterator(self) -> IterAdapter<<I as IntoIter>::Iter>

Available on crate feature iter-unstable only.
Converts the wiwi iter into a std iterator.
source§

impl<T> Same for T

§

type Output = T

Should always be Self
source§

impl<T> ToMaybeUninit for T

source§

unsafe fn to_maybeuninit(&self) -> &MaybeUninit<T>

Available on crate feature to-maybeuninit only.
source§

unsafe fn to_maybeuninit_mut(&mut self) -> &mut MaybeUninit<T>

Available on crate feature to-maybeuninit only.
source§

unsafe fn to_maybeuninit_drop(&mut self) -> &mut MaybeUninit<T>

Available on crate feature to-maybeuninit only.
Safety Read more
source§

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

§

type Error = Infallible

The type returned in the event of a conversion error.
source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

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

§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
§

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

§

fn vzip(self) -> V

\ No newline at end of file diff --git a/wiwi/iter/struct.Tuple28.html b/wiwi/iter/struct.Tuple28.html index 913e1a00f..00cb455e0 100644 --- a/wiwi/iter/struct.Tuple28.html +++ b/wiwi/iter/struct.Tuple28.html @@ -35,12 +35,12 @@ I25: Iter, I26: Iter, I27: Iter, - I28: Iter,
§

type Item = (<I1 as Iter>::Item, <I2 as Iter>::Item, <I3 as Iter>::Item, <I4 as Iter>::Item, <I5 as Iter>::Item, <I6 as Iter>::Item, <I7 as Iter>::Item, <I8 as Iter>::Item, <I9 as Iter>::Item, <I10 as Iter>::Item, <I11 as Iter>::Item, <I12 as Iter>::Item, <I13 as Iter>::Item, <I14 as Iter>::Item, <I15 as Iter>::Item, <I16 as Iter>::Item, <I17 as Iter>::Item, <I18 as Iter>::Item, <I19 as Iter>::Item, <I20 as Iter>::Item, <I21 as Iter>::Item, <I22 as Iter>::Item, <I23 as Iter>::Item, <I24 as Iter>::Item, <I25 as Iter>::Item, <I26 as Iter>::Item, <I27 as Iter>::Item, <I28 as Iter>::Item)

source§

fn next(&mut self) -> Option<Self::Item>

source§

fn size_hint(&self) -> SizeHint

source§

fn for_each<F>(self, f: F)
where + I28: Iter,

§

type Item = (<I1 as Iter>::Item, <I2 as Iter>::Item, <I3 as Iter>::Item, <I4 as Iter>::Item, <I5 as Iter>::Item, <I6 as Iter>::Item, <I7 as Iter>::Item, <I8 as Iter>::Item, <I9 as Iter>::Item, <I10 as Iter>::Item, <I11 as Iter>::Item, <I12 as Iter>::Item, <I13 as Iter>::Item, <I14 as Iter>::Item, <I15 as Iter>::Item, <I16 as Iter>::Item, <I17 as Iter>::Item, <I18 as Iter>::Item, <I19 as Iter>::Item, <I20 as Iter>::Item, <I21 as Iter>::Item, <I22 as Iter>::Item, <I23 as Iter>::Item, <I24 as Iter>::Item, <I25 as Iter>::Item, <I26 as Iter>::Item, <I27 as Iter>::Item, <I28 as Iter>::Item)

source§

fn next(&mut self) -> Option<Self::Item>

source§

fn size_hint(&self) -> SizeHint

source§

fn for_each<F>(self, f: F)
where Self: Sized, - F: FnMut(Self::Item),

source§

fn peekable(self) -> Peek<Self, Self::Item>
where - Self: Sized,

source§

fn map<O, F>(self, f: F) -> Map<Self, F>
where + F: FnMut(Self::Item),

source§

fn peekable(self) -> Peek<Self, Self::Item>
where + Self: Sized,

source§

fn map<O, F>(self, f: F) -> Map<Self, F>
where Self: Sized, - F: FnMut(Self::Item) -> O,

source§

fn count(self) -> usize
where + F: FnMut(Self::Item) -> O,

source§

fn count(self) -> usize
where Self: Sized,

Consumes the iter and returns the number of items that were emitted. Read more

Auto Trait Implementations§

§

impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24, I25, I26, I27, I28> Freeze for Tuple28<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24, I25, I26, I27, I28>
where I1: Freeze, I2: Freeze, @@ -210,8 +210,8 @@ I26: UnwindSafe, I27: UnwindSafe, I28: UnwindSafe,

Blanket Implementations§

source§

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

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<'h, I> AsStdIterator<'h> for I
where - I: Iter + 'h,

§

type Iterator = IterAdapter<&'h mut I>

Available on crate feature iter-unstable only.
source§

fn borrow_wiwi_as_std_iterator(&'h mut self) -> IterAdapter<&'h mut I>

Available on crate feature iter-unstable only.
Borrow the wiwi iter as an std iterator.
source§

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

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<'h, I> AsStdIterator<'h> for I
where + I: Iter + 'h,

§

type Iterator = IterAdapter<&'h mut I>

Available on crate feature iter-unstable only.
source§

fn borrow_wiwi_as_std_iterator(&'h mut self) -> IterAdapter<&'h mut I>

Available on crate feature iter-unstable only.
Borrow the wiwi iter as an std iterator.
source§

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

source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

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

source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

Returns the argument unchanged.

source§

impl<T, U> Into<U> for T
where @@ -219,8 +219,8 @@

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

source§

impl<I> IntoIter for I
where - I: Iter,

§

type Item = <I as Iter>::Item

Available on crate feature iter-unstable only.
§

type Iter = I

Available on crate feature iter-unstable only.
source§

fn into_wiwi_iter(self) -> I

Available on crate feature iter-unstable only.
source§

impl<I> IntoStdIterator for I
where - I: IntoIter,

§

type Iterator = IterAdapter<<I as IntoIter>::Iter>

Available on crate feature iter-unstable only.
source§

fn convert_wiwi_into_std_iterator(self) -> IterAdapter<<I as IntoIter>::Iter>

Available on crate feature iter-unstable only.
Converts the wiwi iter into a std iterator.
source§

impl<T> Same for T

§

type Output = T

Should always be Self
source§

impl<T> ToMaybeUninit for T

source§

unsafe fn to_maybeuninit(&self) -> &MaybeUninit<T>

Available on crate feature to-maybeuninit only.
source§

unsafe fn to_maybeuninit_mut(&mut self) -> &mut MaybeUninit<T>

Available on crate feature to-maybeuninit only.
source§

unsafe fn to_maybeuninit_drop(&mut self) -> &mut MaybeUninit<T>

Available on crate feature to-maybeuninit only.
Safety Read more
source§

impl<T, U> TryFrom<U> for T
where + I: Iter,

§

type Item = <I as Iter>::Item

Available on crate feature iter-unstable only.
§

type Iter = I

Available on crate feature iter-unstable only.
source§

fn into_wiwi_iter(self) -> I

Available on crate feature iter-unstable only.
source§

impl<I> IntoStdIterator for I
where + I: IntoIter,

§

type Iterator = IterAdapter<<I as IntoIter>::Iter>

Available on crate feature iter-unstable only.
source§

fn convert_wiwi_into_std_iterator(self) -> IterAdapter<<I as IntoIter>::Iter>

Available on crate feature iter-unstable only.
Converts the wiwi iter into a std iterator.
source§

impl<T> Same for T

§

type Output = T

Should always be Self
source§

impl<T> ToMaybeUninit for T

source§

unsafe fn to_maybeuninit(&self) -> &MaybeUninit<T>

Available on crate feature to-maybeuninit only.
source§

unsafe fn to_maybeuninit_mut(&mut self) -> &mut MaybeUninit<T>

Available on crate feature to-maybeuninit only.
source§

unsafe fn to_maybeuninit_drop(&mut self) -> &mut MaybeUninit<T>

Available on crate feature to-maybeuninit only.
Safety Read more
source§

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

§

type Error = Infallible

The type returned in the event of a conversion error.
source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

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

§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
§

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

§

fn vzip(self) -> V

\ No newline at end of file diff --git a/wiwi/iter/struct.Tuple29.html b/wiwi/iter/struct.Tuple29.html index 6ef2c9ab4..fd8ae6989 100644 --- a/wiwi/iter/struct.Tuple29.html +++ b/wiwi/iter/struct.Tuple29.html @@ -36,12 +36,12 @@ I26: Iter, I27: Iter, I28: Iter, - I29: Iter,
§

type Item = (<I1 as Iter>::Item, <I2 as Iter>::Item, <I3 as Iter>::Item, <I4 as Iter>::Item, <I5 as Iter>::Item, <I6 as Iter>::Item, <I7 as Iter>::Item, <I8 as Iter>::Item, <I9 as Iter>::Item, <I10 as Iter>::Item, <I11 as Iter>::Item, <I12 as Iter>::Item, <I13 as Iter>::Item, <I14 as Iter>::Item, <I15 as Iter>::Item, <I16 as Iter>::Item, <I17 as Iter>::Item, <I18 as Iter>::Item, <I19 as Iter>::Item, <I20 as Iter>::Item, <I21 as Iter>::Item, <I22 as Iter>::Item, <I23 as Iter>::Item, <I24 as Iter>::Item, <I25 as Iter>::Item, <I26 as Iter>::Item, <I27 as Iter>::Item, <I28 as Iter>::Item, <I29 as Iter>::Item)

source§

fn next(&mut self) -> Option<Self::Item>

source§

fn size_hint(&self) -> SizeHint

source§

fn for_each<F>(self, f: F)
where + I29: Iter,

§

type Item = (<I1 as Iter>::Item, <I2 as Iter>::Item, <I3 as Iter>::Item, <I4 as Iter>::Item, <I5 as Iter>::Item, <I6 as Iter>::Item, <I7 as Iter>::Item, <I8 as Iter>::Item, <I9 as Iter>::Item, <I10 as Iter>::Item, <I11 as Iter>::Item, <I12 as Iter>::Item, <I13 as Iter>::Item, <I14 as Iter>::Item, <I15 as Iter>::Item, <I16 as Iter>::Item, <I17 as Iter>::Item, <I18 as Iter>::Item, <I19 as Iter>::Item, <I20 as Iter>::Item, <I21 as Iter>::Item, <I22 as Iter>::Item, <I23 as Iter>::Item, <I24 as Iter>::Item, <I25 as Iter>::Item, <I26 as Iter>::Item, <I27 as Iter>::Item, <I28 as Iter>::Item, <I29 as Iter>::Item)

source§

fn next(&mut self) -> Option<Self::Item>

source§

fn size_hint(&self) -> SizeHint

source§

fn for_each<F>(self, f: F)
where Self: Sized, - F: FnMut(Self::Item),

source§

fn peekable(self) -> Peek<Self, Self::Item>
where - Self: Sized,

source§

fn map<O, F>(self, f: F) -> Map<Self, F>
where + F: FnMut(Self::Item),

source§

fn peekable(self) -> Peek<Self, Self::Item>
where + Self: Sized,

source§

fn map<O, F>(self, f: F) -> Map<Self, F>
where Self: Sized, - F: FnMut(Self::Item) -> O,

source§

fn count(self) -> usize
where + F: FnMut(Self::Item) -> O,

source§

fn count(self) -> usize
where Self: Sized,

Consumes the iter and returns the number of items that were emitted. Read more

Auto Trait Implementations§

§

impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24, I25, I26, I27, I28, I29> Freeze for Tuple29<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24, I25, I26, I27, I28, I29>
where I1: Freeze, I2: Freeze, @@ -217,8 +217,8 @@ I27: UnwindSafe, I28: UnwindSafe, I29: UnwindSafe,

Blanket Implementations§

source§

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

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<'h, I> AsStdIterator<'h> for I
where - I: Iter + 'h,

§

type Iterator = IterAdapter<&'h mut I>

Available on crate feature iter-unstable only.
source§

fn borrow_wiwi_as_std_iterator(&'h mut self) -> IterAdapter<&'h mut I>

Available on crate feature iter-unstable only.
Borrow the wiwi iter as an std iterator.
source§

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

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<'h, I> AsStdIterator<'h> for I
where + I: Iter + 'h,

§

type Iterator = IterAdapter<&'h mut I>

Available on crate feature iter-unstable only.
source§

fn borrow_wiwi_as_std_iterator(&'h mut self) -> IterAdapter<&'h mut I>

Available on crate feature iter-unstable only.
Borrow the wiwi iter as an std iterator.
source§

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

source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

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

source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

Returns the argument unchanged.

source§

impl<T, U> Into<U> for T
where @@ -226,8 +226,8 @@

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

source§

impl<I> IntoIter for I
where - I: Iter,

§

type Item = <I as Iter>::Item

Available on crate feature iter-unstable only.
§

type Iter = I

Available on crate feature iter-unstable only.
source§

fn into_wiwi_iter(self) -> I

Available on crate feature iter-unstable only.
source§

impl<I> IntoStdIterator for I
where - I: IntoIter,

§

type Iterator = IterAdapter<<I as IntoIter>::Iter>

Available on crate feature iter-unstable only.
source§

fn convert_wiwi_into_std_iterator(self) -> IterAdapter<<I as IntoIter>::Iter>

Available on crate feature iter-unstable only.
Converts the wiwi iter into a std iterator.
source§

impl<T> Same for T

§

type Output = T

Should always be Self
source§

impl<T> ToMaybeUninit for T

source§

unsafe fn to_maybeuninit(&self) -> &MaybeUninit<T>

Available on crate feature to-maybeuninit only.
source§

unsafe fn to_maybeuninit_mut(&mut self) -> &mut MaybeUninit<T>

Available on crate feature to-maybeuninit only.
source§

unsafe fn to_maybeuninit_drop(&mut self) -> &mut MaybeUninit<T>

Available on crate feature to-maybeuninit only.
Safety Read more
source§

impl<T, U> TryFrom<U> for T
where + I: Iter,

§

type Item = <I as Iter>::Item

Available on crate feature iter-unstable only.
§

type Iter = I

Available on crate feature iter-unstable only.
source§

fn into_wiwi_iter(self) -> I

Available on crate feature iter-unstable only.
source§

impl<I> IntoStdIterator for I
where + I: IntoIter,

§

type Iterator = IterAdapter<<I as IntoIter>::Iter>

Available on crate feature iter-unstable only.
source§

fn convert_wiwi_into_std_iterator(self) -> IterAdapter<<I as IntoIter>::Iter>

Available on crate feature iter-unstable only.
Converts the wiwi iter into a std iterator.
source§

impl<T> Same for T

§

type Output = T

Should always be Self
source§

impl<T> ToMaybeUninit for T

source§

unsafe fn to_maybeuninit(&self) -> &MaybeUninit<T>

Available on crate feature to-maybeuninit only.
source§

unsafe fn to_maybeuninit_mut(&mut self) -> &mut MaybeUninit<T>

Available on crate feature to-maybeuninit only.
source§

unsafe fn to_maybeuninit_drop(&mut self) -> &mut MaybeUninit<T>

Available on crate feature to-maybeuninit only.
Safety Read more
source§

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

§

type Error = Infallible

The type returned in the event of a conversion error.
source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

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

§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
§

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

§

fn vzip(self) -> V

\ No newline at end of file diff --git a/wiwi/iter/struct.Tuple3.html b/wiwi/iter/struct.Tuple3.html index 980e89ea1..05c70349b 100644 --- a/wiwi/iter/struct.Tuple3.html +++ b/wiwi/iter/struct.Tuple3.html @@ -10,12 +10,12 @@

Trait Implementations§

source§

impl<I1, I2, I3> Iter for Tuple3<I1, I2, I3>
where I1: Iter, I2: Iter, - I3: Iter,

§

type Item = (<I1 as Iter>::Item, <I2 as Iter>::Item, <I3 as Iter>::Item)

source§

fn next(&mut self) -> Option<Self::Item>

source§

fn size_hint(&self) -> SizeHint

source§

fn for_each<F>(self, f: F)
where + I3: Iter,

§

type Item = (<I1 as Iter>::Item, <I2 as Iter>::Item, <I3 as Iter>::Item)

source§

fn next(&mut self) -> Option<Self::Item>

source§

fn size_hint(&self) -> SizeHint

source§

fn for_each<F>(self, f: F)
where Self: Sized, - F: FnMut(Self::Item),

source§

fn peekable(self) -> Peek<Self, Self::Item>
where - Self: Sized,

source§

fn map<O, F>(self, f: F) -> Map<Self, F>
where + F: FnMut(Self::Item),

source§

fn peekable(self) -> Peek<Self, Self::Item>
where + Self: Sized,

source§

fn map<O, F>(self, f: F) -> Map<Self, F>
where Self: Sized, - F: FnMut(Self::Item) -> O,

source§

fn count(self) -> usize
where + F: FnMut(Self::Item) -> O,

source§

fn count(self) -> usize
where Self: Sized,

Consumes the iter and returns the number of items that were emitted. Read more

Auto Trait Implementations§

§

impl<I1, I2, I3> Freeze for Tuple3<I1, I2, I3>
where I1: Freeze, I2: Freeze, @@ -35,8 +35,8 @@ I1: UnwindSafe, I2: UnwindSafe, I3: UnwindSafe,

Blanket Implementations§

source§

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

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<'h, I> AsStdIterator<'h> for I
where - I: Iter + 'h,

§

type Iterator = IterAdapter<&'h mut I>

Available on crate feature iter-unstable only.
source§

fn borrow_wiwi_as_std_iterator(&'h mut self) -> IterAdapter<&'h mut I>

Available on crate feature iter-unstable only.
Borrow the wiwi iter as an std iterator.
source§

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

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<'h, I> AsStdIterator<'h> for I
where + I: Iter + 'h,

§

type Iterator = IterAdapter<&'h mut I>

Available on crate feature iter-unstable only.
source§

fn borrow_wiwi_as_std_iterator(&'h mut self) -> IterAdapter<&'h mut I>

Available on crate feature iter-unstable only.
Borrow the wiwi iter as an std iterator.
source§

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

source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

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

source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

Returns the argument unchanged.

source§

impl<T, U> Into<U> for T
where @@ -44,8 +44,8 @@

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

source§

impl<I> IntoIter for I
where - I: Iter,

§

type Item = <I as Iter>::Item

Available on crate feature iter-unstable only.
§

type Iter = I

Available on crate feature iter-unstable only.
source§

fn into_wiwi_iter(self) -> I

Available on crate feature iter-unstable only.
source§

impl<I> IntoStdIterator for I
where - I: IntoIter,

§

type Iterator = IterAdapter<<I as IntoIter>::Iter>

Available on crate feature iter-unstable only.
source§

fn convert_wiwi_into_std_iterator(self) -> IterAdapter<<I as IntoIter>::Iter>

Available on crate feature iter-unstable only.
Converts the wiwi iter into a std iterator.
source§

impl<T> Same for T

§

type Output = T

Should always be Self
source§

impl<T> ToMaybeUninit for T

source§

unsafe fn to_maybeuninit(&self) -> &MaybeUninit<T>

Available on crate feature to-maybeuninit only.
source§

unsafe fn to_maybeuninit_mut(&mut self) -> &mut MaybeUninit<T>

Available on crate feature to-maybeuninit only.
source§

unsafe fn to_maybeuninit_drop(&mut self) -> &mut MaybeUninit<T>

Available on crate feature to-maybeuninit only.
Safety Read more
source§

impl<T, U> TryFrom<U> for T
where + I: Iter,

§

type Item = <I as Iter>::Item

Available on crate feature iter-unstable only.
§

type Iter = I

Available on crate feature iter-unstable only.
source§

fn into_wiwi_iter(self) -> I

Available on crate feature iter-unstable only.
source§

impl<I> IntoStdIterator for I
where + I: IntoIter,

§

type Iterator = IterAdapter<<I as IntoIter>::Iter>

Available on crate feature iter-unstable only.
source§

fn convert_wiwi_into_std_iterator(self) -> IterAdapter<<I as IntoIter>::Iter>

Available on crate feature iter-unstable only.
Converts the wiwi iter into a std iterator.
source§

impl<T> Same for T

§

type Output = T

Should always be Self
source§

impl<T> ToMaybeUninit for T

source§

unsafe fn to_maybeuninit(&self) -> &MaybeUninit<T>

Available on crate feature to-maybeuninit only.
source§

unsafe fn to_maybeuninit_mut(&mut self) -> &mut MaybeUninit<T>

Available on crate feature to-maybeuninit only.
source§

unsafe fn to_maybeuninit_drop(&mut self) -> &mut MaybeUninit<T>

Available on crate feature to-maybeuninit only.
Safety Read more
source§

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

§

type Error = Infallible

The type returned in the event of a conversion error.
source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

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

§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
§

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

§

fn vzip(self) -> V

\ No newline at end of file diff --git a/wiwi/iter/struct.Tuple30.html b/wiwi/iter/struct.Tuple30.html index d83a95d2c..1c7d040a0 100644 --- a/wiwi/iter/struct.Tuple30.html +++ b/wiwi/iter/struct.Tuple30.html @@ -37,12 +37,12 @@ I27: Iter, I28: Iter, I29: Iter, - I30: Iter,
§

type Item = (<I1 as Iter>::Item, <I2 as Iter>::Item, <I3 as Iter>::Item, <I4 as Iter>::Item, <I5 as Iter>::Item, <I6 as Iter>::Item, <I7 as Iter>::Item, <I8 as Iter>::Item, <I9 as Iter>::Item, <I10 as Iter>::Item, <I11 as Iter>::Item, <I12 as Iter>::Item, <I13 as Iter>::Item, <I14 as Iter>::Item, <I15 as Iter>::Item, <I16 as Iter>::Item, <I17 as Iter>::Item, <I18 as Iter>::Item, <I19 as Iter>::Item, <I20 as Iter>::Item, <I21 as Iter>::Item, <I22 as Iter>::Item, <I23 as Iter>::Item, <I24 as Iter>::Item, <I25 as Iter>::Item, <I26 as Iter>::Item, <I27 as Iter>::Item, <I28 as Iter>::Item, <I29 as Iter>::Item, <I30 as Iter>::Item)

source§

fn next(&mut self) -> Option<Self::Item>

source§

fn size_hint(&self) -> SizeHint

source§

fn for_each<F>(self, f: F)
where + I30: Iter,

§

type Item = (<I1 as Iter>::Item, <I2 as Iter>::Item, <I3 as Iter>::Item, <I4 as Iter>::Item, <I5 as Iter>::Item, <I6 as Iter>::Item, <I7 as Iter>::Item, <I8 as Iter>::Item, <I9 as Iter>::Item, <I10 as Iter>::Item, <I11 as Iter>::Item, <I12 as Iter>::Item, <I13 as Iter>::Item, <I14 as Iter>::Item, <I15 as Iter>::Item, <I16 as Iter>::Item, <I17 as Iter>::Item, <I18 as Iter>::Item, <I19 as Iter>::Item, <I20 as Iter>::Item, <I21 as Iter>::Item, <I22 as Iter>::Item, <I23 as Iter>::Item, <I24 as Iter>::Item, <I25 as Iter>::Item, <I26 as Iter>::Item, <I27 as Iter>::Item, <I28 as Iter>::Item, <I29 as Iter>::Item, <I30 as Iter>::Item)

source§

fn next(&mut self) -> Option<Self::Item>

source§

fn size_hint(&self) -> SizeHint

source§

fn for_each<F>(self, f: F)
where Self: Sized, - F: FnMut(Self::Item),

source§

fn peekable(self) -> Peek<Self, Self::Item>
where - Self: Sized,

source§

fn map<O, F>(self, f: F) -> Map<Self, F>
where + F: FnMut(Self::Item),

source§

fn peekable(self) -> Peek<Self, Self::Item>
where + Self: Sized,

source§

fn map<O, F>(self, f: F) -> Map<Self, F>
where Self: Sized, - F: FnMut(Self::Item) -> O,

source§

fn count(self) -> usize
where + F: FnMut(Self::Item) -> O,

source§

fn count(self) -> usize
where Self: Sized,

Consumes the iter and returns the number of items that were emitted. Read more

Auto Trait Implementations§

§

impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24, I25, I26, I27, I28, I29, I30> Freeze for Tuple30<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24, I25, I26, I27, I28, I29, I30>
where I1: Freeze, I2: Freeze, @@ -224,8 +224,8 @@ I28: UnwindSafe, I29: UnwindSafe, I30: UnwindSafe,

Blanket Implementations§

source§

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

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<'h, I> AsStdIterator<'h> for I
where - I: Iter + 'h,

§

type Iterator = IterAdapter<&'h mut I>

Available on crate feature iter-unstable only.
source§

fn borrow_wiwi_as_std_iterator(&'h mut self) -> IterAdapter<&'h mut I>

Available on crate feature iter-unstable only.
Borrow the wiwi iter as an std iterator.
source§

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

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<'h, I> AsStdIterator<'h> for I
where + I: Iter + 'h,

§

type Iterator = IterAdapter<&'h mut I>

Available on crate feature iter-unstable only.
source§

fn borrow_wiwi_as_std_iterator(&'h mut self) -> IterAdapter<&'h mut I>

Available on crate feature iter-unstable only.
Borrow the wiwi iter as an std iterator.
source§

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

source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

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

source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

Returns the argument unchanged.

source§

impl<T, U> Into<U> for T
where @@ -233,8 +233,8 @@

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

source§

impl<I> IntoIter for I
where - I: Iter,

§

type Item = <I as Iter>::Item

Available on crate feature iter-unstable only.
§

type Iter = I

Available on crate feature iter-unstable only.
source§

fn into_wiwi_iter(self) -> I

Available on crate feature iter-unstable only.
source§

impl<I> IntoStdIterator for I
where - I: IntoIter,

§

type Iterator = IterAdapter<<I as IntoIter>::Iter>

Available on crate feature iter-unstable only.
source§

fn convert_wiwi_into_std_iterator(self) -> IterAdapter<<I as IntoIter>::Iter>

Available on crate feature iter-unstable only.
Converts the wiwi iter into a std iterator.
source§

impl<T> Same for T

§

type Output = T

Should always be Self
source§

impl<T> ToMaybeUninit for T

source§

unsafe fn to_maybeuninit(&self) -> &MaybeUninit<T>

Available on crate feature to-maybeuninit only.
source§

unsafe fn to_maybeuninit_mut(&mut self) -> &mut MaybeUninit<T>

Available on crate feature to-maybeuninit only.
source§

unsafe fn to_maybeuninit_drop(&mut self) -> &mut MaybeUninit<T>

Available on crate feature to-maybeuninit only.
Safety Read more
source§

impl<T, U> TryFrom<U> for T
where + I: Iter,

§

type Item = <I as Iter>::Item

Available on crate feature iter-unstable only.
§

type Iter = I

Available on crate feature iter-unstable only.
source§

fn into_wiwi_iter(self) -> I

Available on crate feature iter-unstable only.
source§

impl<I> IntoStdIterator for I
where + I: IntoIter,

§

type Iterator = IterAdapter<<I as IntoIter>::Iter>

Available on crate feature iter-unstable only.
source§

fn convert_wiwi_into_std_iterator(self) -> IterAdapter<<I as IntoIter>::Iter>

Available on crate feature iter-unstable only.
Converts the wiwi iter into a std iterator.
source§

impl<T> Same for T

§

type Output = T

Should always be Self
source§

impl<T> ToMaybeUninit for T

source§

unsafe fn to_maybeuninit(&self) -> &MaybeUninit<T>

Available on crate feature to-maybeuninit only.
source§

unsafe fn to_maybeuninit_mut(&mut self) -> &mut MaybeUninit<T>

Available on crate feature to-maybeuninit only.
source§

unsafe fn to_maybeuninit_drop(&mut self) -> &mut MaybeUninit<T>

Available on crate feature to-maybeuninit only.
Safety Read more
source§

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

§

type Error = Infallible

The type returned in the event of a conversion error.
source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

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

§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
§

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

§

fn vzip(self) -> V

\ No newline at end of file diff --git a/wiwi/iter/struct.Tuple31.html b/wiwi/iter/struct.Tuple31.html index f18020b25..f563f9b40 100644 --- a/wiwi/iter/struct.Tuple31.html +++ b/wiwi/iter/struct.Tuple31.html @@ -38,12 +38,12 @@ I28: Iter, I29: Iter, I30: Iter, - I31: Iter,
§

type Item = (<I1 as Iter>::Item, <I2 as Iter>::Item, <I3 as Iter>::Item, <I4 as Iter>::Item, <I5 as Iter>::Item, <I6 as Iter>::Item, <I7 as Iter>::Item, <I8 as Iter>::Item, <I9 as Iter>::Item, <I10 as Iter>::Item, <I11 as Iter>::Item, <I12 as Iter>::Item, <I13 as Iter>::Item, <I14 as Iter>::Item, <I15 as Iter>::Item, <I16 as Iter>::Item, <I17 as Iter>::Item, <I18 as Iter>::Item, <I19 as Iter>::Item, <I20 as Iter>::Item, <I21 as Iter>::Item, <I22 as Iter>::Item, <I23 as Iter>::Item, <I24 as Iter>::Item, <I25 as Iter>::Item, <I26 as Iter>::Item, <I27 as Iter>::Item, <I28 as Iter>::Item, <I29 as Iter>::Item, <I30 as Iter>::Item, <I31 as Iter>::Item)

source§

fn next(&mut self) -> Option<Self::Item>

source§

fn size_hint(&self) -> SizeHint

source§

fn for_each<F>(self, f: F)
where + I31: Iter,

§

type Item = (<I1 as Iter>::Item, <I2 as Iter>::Item, <I3 as Iter>::Item, <I4 as Iter>::Item, <I5 as Iter>::Item, <I6 as Iter>::Item, <I7 as Iter>::Item, <I8 as Iter>::Item, <I9 as Iter>::Item, <I10 as Iter>::Item, <I11 as Iter>::Item, <I12 as Iter>::Item, <I13 as Iter>::Item, <I14 as Iter>::Item, <I15 as Iter>::Item, <I16 as Iter>::Item, <I17 as Iter>::Item, <I18 as Iter>::Item, <I19 as Iter>::Item, <I20 as Iter>::Item, <I21 as Iter>::Item, <I22 as Iter>::Item, <I23 as Iter>::Item, <I24 as Iter>::Item, <I25 as Iter>::Item, <I26 as Iter>::Item, <I27 as Iter>::Item, <I28 as Iter>::Item, <I29 as Iter>::Item, <I30 as Iter>::Item, <I31 as Iter>::Item)

source§

fn next(&mut self) -> Option<Self::Item>

source§

fn size_hint(&self) -> SizeHint

source§

fn for_each<F>(self, f: F)
where Self: Sized, - F: FnMut(Self::Item),

source§

fn peekable(self) -> Peek<Self, Self::Item>
where - Self: Sized,

source§

fn map<O, F>(self, f: F) -> Map<Self, F>
where + F: FnMut(Self::Item),

source§

fn peekable(self) -> Peek<Self, Self::Item>
where + Self: Sized,

source§

fn map<O, F>(self, f: F) -> Map<Self, F>
where Self: Sized, - F: FnMut(Self::Item) -> O,

source§

fn count(self) -> usize
where + F: FnMut(Self::Item) -> O,

source§

fn count(self) -> usize
where Self: Sized,

Consumes the iter and returns the number of items that were emitted. Read more

Auto Trait Implementations§

§

impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24, I25, I26, I27, I28, I29, I30, I31> Freeze for Tuple31<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24, I25, I26, I27, I28, I29, I30, I31>
where I1: Freeze, I2: Freeze, @@ -231,8 +231,8 @@ I29: UnwindSafe, I30: UnwindSafe, I31: UnwindSafe,

Blanket Implementations§

source§

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

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<'h, I> AsStdIterator<'h> for I
where - I: Iter + 'h,

§

type Iterator = IterAdapter<&'h mut I>

Available on crate feature iter-unstable only.
source§

fn borrow_wiwi_as_std_iterator(&'h mut self) -> IterAdapter<&'h mut I>

Available on crate feature iter-unstable only.
Borrow the wiwi iter as an std iterator.
source§

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

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<'h, I> AsStdIterator<'h> for I
where + I: Iter + 'h,

§

type Iterator = IterAdapter<&'h mut I>

Available on crate feature iter-unstable only.
source§

fn borrow_wiwi_as_std_iterator(&'h mut self) -> IterAdapter<&'h mut I>

Available on crate feature iter-unstable only.
Borrow the wiwi iter as an std iterator.
source§

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

source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

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

source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

Returns the argument unchanged.

source§

impl<T, U> Into<U> for T
where @@ -240,8 +240,8 @@

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

source§

impl<I> IntoIter for I
where - I: Iter,

§

type Item = <I as Iter>::Item

Available on crate feature iter-unstable only.
§

type Iter = I

Available on crate feature iter-unstable only.
source§

fn into_wiwi_iter(self) -> I

Available on crate feature iter-unstable only.
source§

impl<I> IntoStdIterator for I
where - I: IntoIter,

§

type Iterator = IterAdapter<<I as IntoIter>::Iter>

Available on crate feature iter-unstable only.
source§

fn convert_wiwi_into_std_iterator(self) -> IterAdapter<<I as IntoIter>::Iter>

Available on crate feature iter-unstable only.
Converts the wiwi iter into a std iterator.
source§

impl<T> Same for T

§

type Output = T

Should always be Self
source§

impl<T> ToMaybeUninit for T

source§

unsafe fn to_maybeuninit(&self) -> &MaybeUninit<T>

Available on crate feature to-maybeuninit only.
source§

unsafe fn to_maybeuninit_mut(&mut self) -> &mut MaybeUninit<T>

Available on crate feature to-maybeuninit only.
source§

unsafe fn to_maybeuninit_drop(&mut self) -> &mut MaybeUninit<T>

Available on crate feature to-maybeuninit only.
Safety Read more
source§

impl<T, U> TryFrom<U> for T
where + I: Iter,

§

type Item = <I as Iter>::Item

Available on crate feature iter-unstable only.
§

type Iter = I

Available on crate feature iter-unstable only.
source§

fn into_wiwi_iter(self) -> I

Available on crate feature iter-unstable only.
source§

impl<I> IntoStdIterator for I
where + I: IntoIter,

§

type Iterator = IterAdapter<<I as IntoIter>::Iter>

Available on crate feature iter-unstable only.
source§

fn convert_wiwi_into_std_iterator(self) -> IterAdapter<<I as IntoIter>::Iter>

Available on crate feature iter-unstable only.
Converts the wiwi iter into a std iterator.
source§

impl<T> Same for T

§

type Output = T

Should always be Self
source§

impl<T> ToMaybeUninit for T

source§

unsafe fn to_maybeuninit(&self) -> &MaybeUninit<T>

Available on crate feature to-maybeuninit only.
source§

unsafe fn to_maybeuninit_mut(&mut self) -> &mut MaybeUninit<T>

Available on crate feature to-maybeuninit only.
source§

unsafe fn to_maybeuninit_drop(&mut self) -> &mut MaybeUninit<T>

Available on crate feature to-maybeuninit only.
Safety Read more
source§

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

§

type Error = Infallible

The type returned in the event of a conversion error.
source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

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

§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
§

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

§

fn vzip(self) -> V

\ No newline at end of file diff --git a/wiwi/iter/struct.Tuple32.html b/wiwi/iter/struct.Tuple32.html index 805424756..7504a3e25 100644 --- a/wiwi/iter/struct.Tuple32.html +++ b/wiwi/iter/struct.Tuple32.html @@ -39,12 +39,12 @@ I29: Iter, I30: Iter, I31: Iter, - I32: Iter,
§

type Item = (<I1 as Iter>::Item, <I2 as Iter>::Item, <I3 as Iter>::Item, <I4 as Iter>::Item, <I5 as Iter>::Item, <I6 as Iter>::Item, <I7 as Iter>::Item, <I8 as Iter>::Item, <I9 as Iter>::Item, <I10 as Iter>::Item, <I11 as Iter>::Item, <I12 as Iter>::Item, <I13 as Iter>::Item, <I14 as Iter>::Item, <I15 as Iter>::Item, <I16 as Iter>::Item, <I17 as Iter>::Item, <I18 as Iter>::Item, <I19 as Iter>::Item, <I20 as Iter>::Item, <I21 as Iter>::Item, <I22 as Iter>::Item, <I23 as Iter>::Item, <I24 as Iter>::Item, <I25 as Iter>::Item, <I26 as Iter>::Item, <I27 as Iter>::Item, <I28 as Iter>::Item, <I29 as Iter>::Item, <I30 as Iter>::Item, <I31 as Iter>::Item, <I32 as Iter>::Item)

source§

fn next(&mut self) -> Option<Self::Item>

source§

fn size_hint(&self) -> SizeHint

source§

fn for_each<F>(self, f: F)
where + I32: Iter,

§

type Item = (<I1 as Iter>::Item, <I2 as Iter>::Item, <I3 as Iter>::Item, <I4 as Iter>::Item, <I5 as Iter>::Item, <I6 as Iter>::Item, <I7 as Iter>::Item, <I8 as Iter>::Item, <I9 as Iter>::Item, <I10 as Iter>::Item, <I11 as Iter>::Item, <I12 as Iter>::Item, <I13 as Iter>::Item, <I14 as Iter>::Item, <I15 as Iter>::Item, <I16 as Iter>::Item, <I17 as Iter>::Item, <I18 as Iter>::Item, <I19 as Iter>::Item, <I20 as Iter>::Item, <I21 as Iter>::Item, <I22 as Iter>::Item, <I23 as Iter>::Item, <I24 as Iter>::Item, <I25 as Iter>::Item, <I26 as Iter>::Item, <I27 as Iter>::Item, <I28 as Iter>::Item, <I29 as Iter>::Item, <I30 as Iter>::Item, <I31 as Iter>::Item, <I32 as Iter>::Item)

source§

fn next(&mut self) -> Option<Self::Item>

source§

fn size_hint(&self) -> SizeHint

source§

fn for_each<F>(self, f: F)
where Self: Sized, - F: FnMut(Self::Item),

source§

fn peekable(self) -> Peek<Self, Self::Item>
where - Self: Sized,

source§

fn map<O, F>(self, f: F) -> Map<Self, F>
where + F: FnMut(Self::Item),

source§

fn peekable(self) -> Peek<Self, Self::Item>
where + Self: Sized,

source§

fn map<O, F>(self, f: F) -> Map<Self, F>
where Self: Sized, - F: FnMut(Self::Item) -> O,

source§

fn count(self) -> usize
where + F: FnMut(Self::Item) -> O,

source§

fn count(self) -> usize
where Self: Sized,

Consumes the iter and returns the number of items that were emitted. Read more

Auto Trait Implementations§

§

impl<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24, I25, I26, I27, I28, I29, I30, I31, I32> Freeze for Tuple32<I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16, I17, I18, I19, I20, I21, I22, I23, I24, I25, I26, I27, I28, I29, I30, I31, I32>
where I1: Freeze, I2: Freeze, @@ -238,8 +238,8 @@ I30: UnwindSafe, I31: UnwindSafe, I32: UnwindSafe,

Blanket Implementations§

source§

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

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<'h, I> AsStdIterator<'h> for I
where - I: Iter + 'h,

§

type Iterator = IterAdapter<&'h mut I>

Available on crate feature iter-unstable only.
source§

fn borrow_wiwi_as_std_iterator(&'h mut self) -> IterAdapter<&'h mut I>

Available on crate feature iter-unstable only.
Borrow the wiwi iter as an std iterator.
source§

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

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<'h, I> AsStdIterator<'h> for I
where + I: Iter + 'h,

§

type Iterator = IterAdapter<&'h mut I>

Available on crate feature iter-unstable only.
source§

fn borrow_wiwi_as_std_iterator(&'h mut self) -> IterAdapter<&'h mut I>

Available on crate feature iter-unstable only.
Borrow the wiwi iter as an std iterator.
source§

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

source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

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

source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

Returns the argument unchanged.

source§

impl<T, U> Into<U> for T
where @@ -247,8 +247,8 @@

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

source§

impl<I> IntoIter for I
where - I: Iter,

§

type Item = <I as Iter>::Item

Available on crate feature iter-unstable only.
§

type Iter = I

Available on crate feature iter-unstable only.
source§

fn into_wiwi_iter(self) -> I

Available on crate feature iter-unstable only.
source§

impl<I> IntoStdIterator for I
where - I: IntoIter,

§

type Iterator = IterAdapter<<I as IntoIter>::Iter>

Available on crate feature iter-unstable only.
source§

fn convert_wiwi_into_std_iterator(self) -> IterAdapter<<I as IntoIter>::Iter>

Available on crate feature iter-unstable only.
Converts the wiwi iter into a std iterator.
source§

impl<T> Same for T

§

type Output = T

Should always be Self
source§

impl<T> ToMaybeUninit for T

source§

unsafe fn to_maybeuninit(&self) -> &MaybeUninit<T>

Available on crate feature to-maybeuninit only.
source§

unsafe fn to_maybeuninit_mut(&mut self) -> &mut MaybeUninit<T>

Available on crate feature to-maybeuninit only.
source§

unsafe fn to_maybeuninit_drop(&mut self) -> &mut MaybeUninit<T>

Available on crate feature to-maybeuninit only.
Safety Read more
source§

impl<T, U> TryFrom<U> for T
where + I: Iter,

§

type Item = <I as Iter>::Item

Available on crate feature iter-unstable only.
§

type Iter = I

Available on crate feature iter-unstable only.
source§

fn into_wiwi_iter(self) -> I

Available on crate feature iter-unstable only.
source§

impl<I> IntoStdIterator for I
where + I: IntoIter,

§

type Iterator = IterAdapter<<I as IntoIter>::Iter>

Available on crate feature iter-unstable only.
source§

fn convert_wiwi_into_std_iterator(self) -> IterAdapter<<I as IntoIter>::Iter>

Available on crate feature iter-unstable only.
Converts the wiwi iter into a std iterator.
source§

impl<T> Same for T

§

type Output = T

Should always be Self
source§

impl<T> ToMaybeUninit for T

source§

unsafe fn to_maybeuninit(&self) -> &MaybeUninit<T>

Available on crate feature to-maybeuninit only.
source§

unsafe fn to_maybeuninit_mut(&mut self) -> &mut MaybeUninit<T>

Available on crate feature to-maybeuninit only.
source§

unsafe fn to_maybeuninit_drop(&mut self) -> &mut MaybeUninit<T>

Available on crate feature to-maybeuninit only.
Safety Read more
source§

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

§

type Error = Infallible

The type returned in the event of a conversion error.
source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

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

§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
§

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

§

fn vzip(self) -> V

\ No newline at end of file diff --git a/wiwi/iter/struct.Tuple4.html b/wiwi/iter/struct.Tuple4.html index 505cf344b..0d4f949d8 100644 --- a/wiwi/iter/struct.Tuple4.html +++ b/wiwi/iter/struct.Tuple4.html @@ -11,12 +11,12 @@ I1: Iter, I2: Iter, I3: Iter, - I4: Iter,
§

type Item = (<I1 as Iter>::Item, <I2 as Iter>::Item, <I3 as Iter>::Item, <I4 as Iter>::Item)

source§

fn next(&mut self) -> Option<Self::Item>

source§

fn size_hint(&self) -> SizeHint

source§

fn for_each<F>(self, f: F)
where + I4: Iter,

§

type Item = (<I1 as Iter>::Item, <I2 as Iter>::Item, <I3 as Iter>::Item, <I4 as Iter>::Item)

source§

fn next(&mut self) -> Option<Self::Item>

source§

fn size_hint(&self) -> SizeHint

source§

fn for_each<F>(self, f: F)
where Self: Sized, - F: FnMut(Self::Item),

source§

fn peekable(self) -> Peek<Self, Self::Item>
where - Self: Sized,

source§

fn map<O, F>(self, f: F) -> Map<Self, F>
where + F: FnMut(Self::Item),

source§

fn peekable(self) -> Peek<Self, Self::Item>
where + Self: Sized,

source§

fn map<O, F>(self, f: F) -> Map<Self, F>
where Self: Sized, - F: FnMut(Self::Item) -> O,

source§

fn count(self) -> usize
where + F: FnMut(Self::Item) -> O,

source§

fn count(self) -> usize
where Self: Sized,

Consumes the iter and returns the number of items that were emitted. Read more

Auto Trait Implementations§

§

impl<I1, I2, I3, I4> Freeze for Tuple4<I1, I2, I3, I4>
where I1: Freeze, I2: Freeze, @@ -42,8 +42,8 @@ I2: UnwindSafe, I3: UnwindSafe, I4: UnwindSafe,

Blanket Implementations§

source§

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

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<'h, I> AsStdIterator<'h> for I
where - I: Iter + 'h,

§

type Iterator = IterAdapter<&'h mut I>

Available on crate feature iter-unstable only.
source§

fn borrow_wiwi_as_std_iterator(&'h mut self) -> IterAdapter<&'h mut I>

Available on crate feature iter-unstable only.
Borrow the wiwi iter as an std iterator.
source§

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

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<'h, I> AsStdIterator<'h> for I
where + I: Iter + 'h,

§

type Iterator = IterAdapter<&'h mut I>

Available on crate feature iter-unstable only.
source§

fn borrow_wiwi_as_std_iterator(&'h mut self) -> IterAdapter<&'h mut I>

Available on crate feature iter-unstable only.
Borrow the wiwi iter as an std iterator.
source§

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

source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

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

source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

Returns the argument unchanged.

source§

impl<T, U> Into<U> for T
where @@ -51,8 +51,8 @@

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

source§

impl<I> IntoIter for I
where - I: Iter,

§

type Item = <I as Iter>::Item

Available on crate feature iter-unstable only.
§

type Iter = I

Available on crate feature iter-unstable only.
source§

fn into_wiwi_iter(self) -> I

Available on crate feature iter-unstable only.
source§

impl<I> IntoStdIterator for I
where - I: IntoIter,

§

type Iterator = IterAdapter<<I as IntoIter>::Iter>

Available on crate feature iter-unstable only.
source§

fn convert_wiwi_into_std_iterator(self) -> IterAdapter<<I as IntoIter>::Iter>

Available on crate feature iter-unstable only.
Converts the wiwi iter into a std iterator.
source§

impl<T> Same for T

§

type Output = T

Should always be Self
source§

impl<T> ToMaybeUninit for T

source§

unsafe fn to_maybeuninit(&self) -> &MaybeUninit<T>

Available on crate feature to-maybeuninit only.
source§

unsafe fn to_maybeuninit_mut(&mut self) -> &mut MaybeUninit<T>

Available on crate feature to-maybeuninit only.
source§

unsafe fn to_maybeuninit_drop(&mut self) -> &mut MaybeUninit<T>

Available on crate feature to-maybeuninit only.
Safety Read more
source§

impl<T, U> TryFrom<U> for T
where + I: Iter,

§

type Item = <I as Iter>::Item

Available on crate feature iter-unstable only.
§

type Iter = I

Available on crate feature iter-unstable only.
source§

fn into_wiwi_iter(self) -> I

Available on crate feature iter-unstable only.
source§

impl<I> IntoStdIterator for I
where + I: IntoIter,

§

type Iterator = IterAdapter<<I as IntoIter>::Iter>

Available on crate feature iter-unstable only.
source§

fn convert_wiwi_into_std_iterator(self) -> IterAdapter<<I as IntoIter>::Iter>

Available on crate feature iter-unstable only.
Converts the wiwi iter into a std iterator.
source§

impl<T> Same for T

§

type Output = T

Should always be Self
source§

impl<T> ToMaybeUninit for T

source§

unsafe fn to_maybeuninit(&self) -> &MaybeUninit<T>

Available on crate feature to-maybeuninit only.
source§

unsafe fn to_maybeuninit_mut(&mut self) -> &mut MaybeUninit<T>

Available on crate feature to-maybeuninit only.
source§

unsafe fn to_maybeuninit_drop(&mut self) -> &mut MaybeUninit<T>

Available on crate feature to-maybeuninit only.
Safety Read more
source§

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

§

type Error = Infallible

The type returned in the event of a conversion error.
source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

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

§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
§

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

§

fn vzip(self) -> V

\ No newline at end of file diff --git a/wiwi/iter/struct.Tuple5.html b/wiwi/iter/struct.Tuple5.html index ecf48edbb..95ac01b55 100644 --- a/wiwi/iter/struct.Tuple5.html +++ b/wiwi/iter/struct.Tuple5.html @@ -12,12 +12,12 @@ I2: Iter, I3: Iter, I4: Iter, - I5: Iter,
§

type Item = (<I1 as Iter>::Item, <I2 as Iter>::Item, <I3 as Iter>::Item, <I4 as Iter>::Item, <I5 as Iter>::Item)

source§

fn next(&mut self) -> Option<Self::Item>

source§

fn size_hint(&self) -> SizeHint

source§

fn for_each<F>(self, f: F)
where + I5: Iter,

§

type Item = (<I1 as Iter>::Item, <I2 as Iter>::Item, <I3 as Iter>::Item, <I4 as Iter>::Item, <I5 as Iter>::Item)

source§

fn next(&mut self) -> Option<Self::Item>

source§

fn size_hint(&self) -> SizeHint

source§

fn for_each<F>(self, f: F)
where Self: Sized, - F: FnMut(Self::Item),

source§

fn peekable(self) -> Peek<Self, Self::Item>
where - Self: Sized,

source§

fn map<O, F>(self, f: F) -> Map<Self, F>
where + F: FnMut(Self::Item),

source§

fn peekable(self) -> Peek<Self, Self::Item>
where + Self: Sized,

source§

fn map<O, F>(self, f: F) -> Map<Self, F>
where Self: Sized, - F: FnMut(Self::Item) -> O,

source§

fn count(self) -> usize
where + F: FnMut(Self::Item) -> O,

source§

fn count(self) -> usize
where Self: Sized,

Consumes the iter and returns the number of items that were emitted. Read more

Auto Trait Implementations§

§

impl<I1, I2, I3, I4, I5> Freeze for Tuple5<I1, I2, I3, I4, I5>
where I1: Freeze, I2: Freeze, @@ -49,8 +49,8 @@ I3: UnwindSafe, I4: UnwindSafe, I5: UnwindSafe,

Blanket Implementations§

source§

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

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<'h, I> AsStdIterator<'h> for I
where - I: Iter + 'h,

§

type Iterator = IterAdapter<&'h mut I>

Available on crate feature iter-unstable only.
source§

fn borrow_wiwi_as_std_iterator(&'h mut self) -> IterAdapter<&'h mut I>

Available on crate feature iter-unstable only.
Borrow the wiwi iter as an std iterator.
source§

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

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<'h, I> AsStdIterator<'h> for I
where + I: Iter + 'h,

§

type Iterator = IterAdapter<&'h mut I>

Available on crate feature iter-unstable only.
source§

fn borrow_wiwi_as_std_iterator(&'h mut self) -> IterAdapter<&'h mut I>

Available on crate feature iter-unstable only.
Borrow the wiwi iter as an std iterator.
source§

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

source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

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

source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

Returns the argument unchanged.

source§

impl<T, U> Into<U> for T
where @@ -58,8 +58,8 @@

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

source§

impl<I> IntoIter for I
where - I: Iter,

§

type Item = <I as Iter>::Item

Available on crate feature iter-unstable only.
§

type Iter = I

Available on crate feature iter-unstable only.
source§

fn into_wiwi_iter(self) -> I

Available on crate feature iter-unstable only.
source§

impl<I> IntoStdIterator for I
where - I: IntoIter,

§

type Iterator = IterAdapter<<I as IntoIter>::Iter>

Available on crate feature iter-unstable only.
source§

fn convert_wiwi_into_std_iterator(self) -> IterAdapter<<I as IntoIter>::Iter>

Available on crate feature iter-unstable only.
Converts the wiwi iter into a std iterator.
source§

impl<T> Same for T

§

type Output = T

Should always be Self
source§

impl<T> ToMaybeUninit for T

source§

unsafe fn to_maybeuninit(&self) -> &MaybeUninit<T>

Available on crate feature to-maybeuninit only.
source§

unsafe fn to_maybeuninit_mut(&mut self) -> &mut MaybeUninit<T>

Available on crate feature to-maybeuninit only.
source§

unsafe fn to_maybeuninit_drop(&mut self) -> &mut MaybeUninit<T>

Available on crate feature to-maybeuninit only.
Safety Read more
source§

impl<T, U> TryFrom<U> for T
where + I: Iter,

§

type Item = <I as Iter>::Item

Available on crate feature iter-unstable only.
§

type Iter = I

Available on crate feature iter-unstable only.
source§

fn into_wiwi_iter(self) -> I

Available on crate feature iter-unstable only.
source§

impl<I> IntoStdIterator for I
where + I: IntoIter,

§

type Iterator = IterAdapter<<I as IntoIter>::Iter>

Available on crate feature iter-unstable only.
source§

fn convert_wiwi_into_std_iterator(self) -> IterAdapter<<I as IntoIter>::Iter>

Available on crate feature iter-unstable only.
Converts the wiwi iter into a std iterator.
source§

impl<T> Same for T

§

type Output = T

Should always be Self
source§

impl<T> ToMaybeUninit for T

source§

unsafe fn to_maybeuninit(&self) -> &MaybeUninit<T>

Available on crate feature to-maybeuninit only.
source§

unsafe fn to_maybeuninit_mut(&mut self) -> &mut MaybeUninit<T>

Available on crate feature to-maybeuninit only.
source§

unsafe fn to_maybeuninit_drop(&mut self) -> &mut MaybeUninit<T>

Available on crate feature to-maybeuninit only.
Safety Read more
source§

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

§

type Error = Infallible

The type returned in the event of a conversion error.
source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

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

§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
§

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

§

fn vzip(self) -> V

\ No newline at end of file diff --git a/wiwi/iter/struct.Tuple6.html b/wiwi/iter/struct.Tuple6.html index 106feae7e..a41c8dfc2 100644 --- a/wiwi/iter/struct.Tuple6.html +++ b/wiwi/iter/struct.Tuple6.html @@ -13,12 +13,12 @@ I3: Iter, I4: Iter, I5: Iter, - I6: Iter,
§

type Item = (<I1 as Iter>::Item, <I2 as Iter>::Item, <I3 as Iter>::Item, <I4 as Iter>::Item, <I5 as Iter>::Item, <I6 as Iter>::Item)

source§

fn next(&mut self) -> Option<Self::Item>

source§

fn size_hint(&self) -> SizeHint

source§

fn for_each<F>(self, f: F)
where + I6: Iter,

§

type Item = (<I1 as Iter>::Item, <I2 as Iter>::Item, <I3 as Iter>::Item, <I4 as Iter>::Item, <I5 as Iter>::Item, <I6 as Iter>::Item)

source§

fn next(&mut self) -> Option<Self::Item>

source§

fn size_hint(&self) -> SizeHint

source§

fn for_each<F>(self, f: F)
where Self: Sized, - F: FnMut(Self::Item),

source§

fn peekable(self) -> Peek<Self, Self::Item>
where - Self: Sized,

source§

fn map<O, F>(self, f: F) -> Map<Self, F>
where + F: FnMut(Self::Item),

source§

fn peekable(self) -> Peek<Self, Self::Item>
where + Self: Sized,

source§

fn map<O, F>(self, f: F) -> Map<Self, F>
where Self: Sized, - F: FnMut(Self::Item) -> O,

source§

fn count(self) -> usize
where + F: FnMut(Self::Item) -> O,

source§

fn count(self) -> usize
where Self: Sized,

Consumes the iter and returns the number of items that were emitted. Read more

Auto Trait Implementations§

§

impl<I1, I2, I3, I4, I5, I6> Freeze for Tuple6<I1, I2, I3, I4, I5, I6>
where I1: Freeze, I2: Freeze, @@ -56,8 +56,8 @@ I4: UnwindSafe, I5: UnwindSafe, I6: UnwindSafe,

Blanket Implementations§

source§

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

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<'h, I> AsStdIterator<'h> for I
where - I: Iter + 'h,

§

type Iterator = IterAdapter<&'h mut I>

Available on crate feature iter-unstable only.
source§

fn borrow_wiwi_as_std_iterator(&'h mut self) -> IterAdapter<&'h mut I>

Available on crate feature iter-unstable only.
Borrow the wiwi iter as an std iterator.
source§

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

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<'h, I> AsStdIterator<'h> for I
where + I: Iter + 'h,

§

type Iterator = IterAdapter<&'h mut I>

Available on crate feature iter-unstable only.
source§

fn borrow_wiwi_as_std_iterator(&'h mut self) -> IterAdapter<&'h mut I>

Available on crate feature iter-unstable only.
Borrow the wiwi iter as an std iterator.
source§

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

source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

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

source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

Returns the argument unchanged.

source§

impl<T, U> Into<U> for T
where @@ -65,8 +65,8 @@

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

source§

impl<I> IntoIter for I
where - I: Iter,

§

type Item = <I as Iter>::Item

Available on crate feature iter-unstable only.
§

type Iter = I

Available on crate feature iter-unstable only.
source§

fn into_wiwi_iter(self) -> I

Available on crate feature iter-unstable only.
source§

impl<I> IntoStdIterator for I
where - I: IntoIter,

§

type Iterator = IterAdapter<<I as IntoIter>::Iter>

Available on crate feature iter-unstable only.
source§

fn convert_wiwi_into_std_iterator(self) -> IterAdapter<<I as IntoIter>::Iter>

Available on crate feature iter-unstable only.
Converts the wiwi iter into a std iterator.
source§

impl<T> Same for T

§

type Output = T

Should always be Self
source§

impl<T> ToMaybeUninit for T

source§

unsafe fn to_maybeuninit(&self) -> &MaybeUninit<T>

Available on crate feature to-maybeuninit only.
source§

unsafe fn to_maybeuninit_mut(&mut self) -> &mut MaybeUninit<T>

Available on crate feature to-maybeuninit only.
source§

unsafe fn to_maybeuninit_drop(&mut self) -> &mut MaybeUninit<T>

Available on crate feature to-maybeuninit only.
Safety Read more
source§

impl<T, U> TryFrom<U> for T
where + I: Iter,

§

type Item = <I as Iter>::Item

Available on crate feature iter-unstable only.
§

type Iter = I

Available on crate feature iter-unstable only.
source§

fn into_wiwi_iter(self) -> I

Available on crate feature iter-unstable only.
source§

impl<I> IntoStdIterator for I
where + I: IntoIter,

§

type Iterator = IterAdapter<<I as IntoIter>::Iter>

Available on crate feature iter-unstable only.
source§

fn convert_wiwi_into_std_iterator(self) -> IterAdapter<<I as IntoIter>::Iter>

Available on crate feature iter-unstable only.
Converts the wiwi iter into a std iterator.
source§

impl<T> Same for T

§

type Output = T

Should always be Self
source§

impl<T> ToMaybeUninit for T

source§

unsafe fn to_maybeuninit(&self) -> &MaybeUninit<T>

Available on crate feature to-maybeuninit only.
source§

unsafe fn to_maybeuninit_mut(&mut self) -> &mut MaybeUninit<T>

Available on crate feature to-maybeuninit only.
source§

unsafe fn to_maybeuninit_drop(&mut self) -> &mut MaybeUninit<T>

Available on crate feature to-maybeuninit only.
Safety Read more
source§

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

§

type Error = Infallible

The type returned in the event of a conversion error.
source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

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

§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
§

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

§

fn vzip(self) -> V

\ No newline at end of file diff --git a/wiwi/iter/struct.Tuple7.html b/wiwi/iter/struct.Tuple7.html index 38150975b..cd7ffafea 100644 --- a/wiwi/iter/struct.Tuple7.html +++ b/wiwi/iter/struct.Tuple7.html @@ -14,12 +14,12 @@ I4: Iter, I5: Iter, I6: Iter, - I7: Iter,
§

type Item = (<I1 as Iter>::Item, <I2 as Iter>::Item, <I3 as Iter>::Item, <I4 as Iter>::Item, <I5 as Iter>::Item, <I6 as Iter>::Item, <I7 as Iter>::Item)

source§

fn next(&mut self) -> Option<Self::Item>

source§

fn size_hint(&self) -> SizeHint

source§

fn for_each<F>(self, f: F)
where + I7: Iter,

§

type Item = (<I1 as Iter>::Item, <I2 as Iter>::Item, <I3 as Iter>::Item, <I4 as Iter>::Item, <I5 as Iter>::Item, <I6 as Iter>::Item, <I7 as Iter>::Item)

source§

fn next(&mut self) -> Option<Self::Item>

source§

fn size_hint(&self) -> SizeHint

source§

fn for_each<F>(self, f: F)
where Self: Sized, - F: FnMut(Self::Item),

source§

fn peekable(self) -> Peek<Self, Self::Item>
where - Self: Sized,

source§

fn map<O, F>(self, f: F) -> Map<Self, F>
where + F: FnMut(Self::Item),

source§

fn peekable(self) -> Peek<Self, Self::Item>
where + Self: Sized,

source§

fn map<O, F>(self, f: F) -> Map<Self, F>
where Self: Sized, - F: FnMut(Self::Item) -> O,

source§

fn count(self) -> usize
where + F: FnMut(Self::Item) -> O,

source§

fn count(self) -> usize
where Self: Sized,

Consumes the iter and returns the number of items that were emitted. Read more

Auto Trait Implementations§

§

impl<I1, I2, I3, I4, I5, I6, I7> Freeze for Tuple7<I1, I2, I3, I4, I5, I6, I7>
where I1: Freeze, I2: Freeze, @@ -63,8 +63,8 @@ I5: UnwindSafe, I6: UnwindSafe, I7: UnwindSafe,

Blanket Implementations§

source§

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

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<'h, I> AsStdIterator<'h> for I
where - I: Iter + 'h,

§

type Iterator = IterAdapter<&'h mut I>

Available on crate feature iter-unstable only.
source§

fn borrow_wiwi_as_std_iterator(&'h mut self) -> IterAdapter<&'h mut I>

Available on crate feature iter-unstable only.
Borrow the wiwi iter as an std iterator.
source§

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

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<'h, I> AsStdIterator<'h> for I
where + I: Iter + 'h,

§

type Iterator = IterAdapter<&'h mut I>

Available on crate feature iter-unstable only.
source§

fn borrow_wiwi_as_std_iterator(&'h mut self) -> IterAdapter<&'h mut I>

Available on crate feature iter-unstable only.
Borrow the wiwi iter as an std iterator.
source§

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

source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

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

source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

Returns the argument unchanged.

source§

impl<T, U> Into<U> for T
where @@ -72,8 +72,8 @@

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

source§

impl<I> IntoIter for I
where - I: Iter,

§

type Item = <I as Iter>::Item

Available on crate feature iter-unstable only.
§

type Iter = I

Available on crate feature iter-unstable only.
source§

fn into_wiwi_iter(self) -> I

Available on crate feature iter-unstable only.
source§

impl<I> IntoStdIterator for I
where - I: IntoIter,

§

type Iterator = IterAdapter<<I as IntoIter>::Iter>

Available on crate feature iter-unstable only.
source§

fn convert_wiwi_into_std_iterator(self) -> IterAdapter<<I as IntoIter>::Iter>

Available on crate feature iter-unstable only.
Converts the wiwi iter into a std iterator.
source§

impl<T> Same for T

§

type Output = T

Should always be Self
source§

impl<T> ToMaybeUninit for T

source§

unsafe fn to_maybeuninit(&self) -> &MaybeUninit<T>

Available on crate feature to-maybeuninit only.
source§

unsafe fn to_maybeuninit_mut(&mut self) -> &mut MaybeUninit<T>

Available on crate feature to-maybeuninit only.
source§

unsafe fn to_maybeuninit_drop(&mut self) -> &mut MaybeUninit<T>

Available on crate feature to-maybeuninit only.
Safety Read more
source§

impl<T, U> TryFrom<U> for T
where + I: Iter,

§

type Item = <I as Iter>::Item

Available on crate feature iter-unstable only.
§

type Iter = I

Available on crate feature iter-unstable only.
source§

fn into_wiwi_iter(self) -> I

Available on crate feature iter-unstable only.
source§

impl<I> IntoStdIterator for I
where + I: IntoIter,

§

type Iterator = IterAdapter<<I as IntoIter>::Iter>

Available on crate feature iter-unstable only.
source§

fn convert_wiwi_into_std_iterator(self) -> IterAdapter<<I as IntoIter>::Iter>

Available on crate feature iter-unstable only.
Converts the wiwi iter into a std iterator.
source§

impl<T> Same for T

§

type Output = T

Should always be Self
source§

impl<T> ToMaybeUninit for T

source§

unsafe fn to_maybeuninit(&self) -> &MaybeUninit<T>

Available on crate feature to-maybeuninit only.
source§

unsafe fn to_maybeuninit_mut(&mut self) -> &mut MaybeUninit<T>

Available on crate feature to-maybeuninit only.
source§

unsafe fn to_maybeuninit_drop(&mut self) -> &mut MaybeUninit<T>

Available on crate feature to-maybeuninit only.
Safety Read more
source§

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

§

type Error = Infallible

The type returned in the event of a conversion error.
source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

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

§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
§

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

§

fn vzip(self) -> V

\ No newline at end of file diff --git a/wiwi/iter/struct.Tuple8.html b/wiwi/iter/struct.Tuple8.html index 950dc93e7..dfe9f11cd 100644 --- a/wiwi/iter/struct.Tuple8.html +++ b/wiwi/iter/struct.Tuple8.html @@ -15,12 +15,12 @@ I5: Iter, I6: Iter, I7: Iter, - I8: Iter,
§

type Item = (<I1 as Iter>::Item, <I2 as Iter>::Item, <I3 as Iter>::Item, <I4 as Iter>::Item, <I5 as Iter>::Item, <I6 as Iter>::Item, <I7 as Iter>::Item, <I8 as Iter>::Item)

source§

fn next(&mut self) -> Option<Self::Item>

source§

fn size_hint(&self) -> SizeHint

source§

fn for_each<F>(self, f: F)
where + I8: Iter,

§

type Item = (<I1 as Iter>::Item, <I2 as Iter>::Item, <I3 as Iter>::Item, <I4 as Iter>::Item, <I5 as Iter>::Item, <I6 as Iter>::Item, <I7 as Iter>::Item, <I8 as Iter>::Item)

source§

fn next(&mut self) -> Option<Self::Item>

source§

fn size_hint(&self) -> SizeHint

source§

fn for_each<F>(self, f: F)
where Self: Sized, - F: FnMut(Self::Item),

source§

fn peekable(self) -> Peek<Self, Self::Item>
where - Self: Sized,

source§

fn map<O, F>(self, f: F) -> Map<Self, F>
where + F: FnMut(Self::Item),

source§

fn peekable(self) -> Peek<Self, Self::Item>
where + Self: Sized,

source§

fn map<O, F>(self, f: F) -> Map<Self, F>
where Self: Sized, - F: FnMut(Self::Item) -> O,

source§

fn count(self) -> usize
where + F: FnMut(Self::Item) -> O,

source§

fn count(self) -> usize
where Self: Sized,

Consumes the iter and returns the number of items that were emitted. Read more

Auto Trait Implementations§

§

impl<I1, I2, I3, I4, I5, I6, I7, I8> Freeze for Tuple8<I1, I2, I3, I4, I5, I6, I7, I8>
where I1: Freeze, I2: Freeze, @@ -70,8 +70,8 @@ I6: UnwindSafe, I7: UnwindSafe, I8: UnwindSafe,

Blanket Implementations§

source§

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

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<'h, I> AsStdIterator<'h> for I
where - I: Iter + 'h,

§

type Iterator = IterAdapter<&'h mut I>

Available on crate feature iter-unstable only.
source§

fn borrow_wiwi_as_std_iterator(&'h mut self) -> IterAdapter<&'h mut I>

Available on crate feature iter-unstable only.
Borrow the wiwi iter as an std iterator.
source§

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

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<'h, I> AsStdIterator<'h> for I
where + I: Iter + 'h,

§

type Iterator = IterAdapter<&'h mut I>

Available on crate feature iter-unstable only.
source§

fn borrow_wiwi_as_std_iterator(&'h mut self) -> IterAdapter<&'h mut I>

Available on crate feature iter-unstable only.
Borrow the wiwi iter as an std iterator.
source§

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

source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

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

source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

Returns the argument unchanged.

source§

impl<T, U> Into<U> for T
where @@ -79,8 +79,8 @@

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

source§

impl<I> IntoIter for I
where - I: Iter,

§

type Item = <I as Iter>::Item

Available on crate feature iter-unstable only.
§

type Iter = I

Available on crate feature iter-unstable only.
source§

fn into_wiwi_iter(self) -> I

Available on crate feature iter-unstable only.
source§

impl<I> IntoStdIterator for I
where - I: IntoIter,

§

type Iterator = IterAdapter<<I as IntoIter>::Iter>

Available on crate feature iter-unstable only.
source§

fn convert_wiwi_into_std_iterator(self) -> IterAdapter<<I as IntoIter>::Iter>

Available on crate feature iter-unstable only.
Converts the wiwi iter into a std iterator.
source§

impl<T> Same for T

§

type Output = T

Should always be Self
source§

impl<T> ToMaybeUninit for T

source§

unsafe fn to_maybeuninit(&self) -> &MaybeUninit<T>

Available on crate feature to-maybeuninit only.
source§

unsafe fn to_maybeuninit_mut(&mut self) -> &mut MaybeUninit<T>

Available on crate feature to-maybeuninit only.
source§

unsafe fn to_maybeuninit_drop(&mut self) -> &mut MaybeUninit<T>

Available on crate feature to-maybeuninit only.
Safety Read more
source§

impl<T, U> TryFrom<U> for T
where + I: Iter,

§

type Item = <I as Iter>::Item

Available on crate feature iter-unstable only.
§

type Iter = I

Available on crate feature iter-unstable only.
source§

fn into_wiwi_iter(self) -> I

Available on crate feature iter-unstable only.
source§

impl<I> IntoStdIterator for I
where + I: IntoIter,

§

type Iterator = IterAdapter<<I as IntoIter>::Iter>

Available on crate feature iter-unstable only.
source§

fn convert_wiwi_into_std_iterator(self) -> IterAdapter<<I as IntoIter>::Iter>

Available on crate feature iter-unstable only.
Converts the wiwi iter into a std iterator.
source§

impl<T> Same for T

§

type Output = T

Should always be Self
source§

impl<T> ToMaybeUninit for T

source§

unsafe fn to_maybeuninit(&self) -> &MaybeUninit<T>

Available on crate feature to-maybeuninit only.
source§

unsafe fn to_maybeuninit_mut(&mut self) -> &mut MaybeUninit<T>

Available on crate feature to-maybeuninit only.
source§

unsafe fn to_maybeuninit_drop(&mut self) -> &mut MaybeUninit<T>

Available on crate feature to-maybeuninit only.
Safety Read more
source§

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

§

type Error = Infallible

The type returned in the event of a conversion error.
source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

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

§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
§

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

§

fn vzip(self) -> V

\ No newline at end of file diff --git a/wiwi/iter/struct.Tuple9.html b/wiwi/iter/struct.Tuple9.html index 9f4f353b3..b50563f8d 100644 --- a/wiwi/iter/struct.Tuple9.html +++ b/wiwi/iter/struct.Tuple9.html @@ -16,12 +16,12 @@ I6: Iter, I7: Iter, I8: Iter, - I9: Iter,
§

type Item = (<I1 as Iter>::Item, <I2 as Iter>::Item, <I3 as Iter>::Item, <I4 as Iter>::Item, <I5 as Iter>::Item, <I6 as Iter>::Item, <I7 as Iter>::Item, <I8 as Iter>::Item, <I9 as Iter>::Item)

source§

fn next(&mut self) -> Option<Self::Item>

source§

fn size_hint(&self) -> SizeHint

source§

fn for_each<F>(self, f: F)
where + I9: Iter,

§

type Item = (<I1 as Iter>::Item, <I2 as Iter>::Item, <I3 as Iter>::Item, <I4 as Iter>::Item, <I5 as Iter>::Item, <I6 as Iter>::Item, <I7 as Iter>::Item, <I8 as Iter>::Item, <I9 as Iter>::Item)

source§

fn next(&mut self) -> Option<Self::Item>

source§

fn size_hint(&self) -> SizeHint

source§

fn for_each<F>(self, f: F)
where Self: Sized, - F: FnMut(Self::Item),

source§

fn peekable(self) -> Peek<Self, Self::Item>
where - Self: Sized,

source§

fn map<O, F>(self, f: F) -> Map<Self, F>
where + F: FnMut(Self::Item),

source§

fn peekable(self) -> Peek<Self, Self::Item>
where + Self: Sized,

source§

fn map<O, F>(self, f: F) -> Map<Self, F>
where Self: Sized, - F: FnMut(Self::Item) -> O,

source§

fn count(self) -> usize
where + F: FnMut(Self::Item) -> O,

source§

fn count(self) -> usize
where Self: Sized,

Consumes the iter and returns the number of items that were emitted. Read more

Auto Trait Implementations§

§

impl<I1, I2, I3, I4, I5, I6, I7, I8, I9> Freeze for Tuple9<I1, I2, I3, I4, I5, I6, I7, I8, I9>
where I1: Freeze, I2: Freeze, @@ -77,8 +77,8 @@ I7: UnwindSafe, I8: UnwindSafe, I9: UnwindSafe,

Blanket Implementations§

source§

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

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<'h, I> AsStdIterator<'h> for I
where - I: Iter + 'h,

§

type Iterator = IterAdapter<&'h mut I>

Available on crate feature iter-unstable only.
source§

fn borrow_wiwi_as_std_iterator(&'h mut self) -> IterAdapter<&'h mut I>

Available on crate feature iter-unstable only.
Borrow the wiwi iter as an std iterator.
source§

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

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<'h, I> AsStdIterator<'h> for I
where + I: Iter + 'h,

§

type Iterator = IterAdapter<&'h mut I>

Available on crate feature iter-unstable only.
source§

fn borrow_wiwi_as_std_iterator(&'h mut self) -> IterAdapter<&'h mut I>

Available on crate feature iter-unstable only.
Borrow the wiwi iter as an std iterator.
source§

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

source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

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

source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

Returns the argument unchanged.

source§

impl<T, U> Into<U> for T
where @@ -86,8 +86,8 @@

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

source§

impl<I> IntoIter for I
where - I: Iter,

§

type Item = <I as Iter>::Item

Available on crate feature iter-unstable only.
§

type Iter = I

Available on crate feature iter-unstable only.
source§

fn into_wiwi_iter(self) -> I

Available on crate feature iter-unstable only.
source§

impl<I> IntoStdIterator for I
where - I: IntoIter,

§

type Iterator = IterAdapter<<I as IntoIter>::Iter>

Available on crate feature iter-unstable only.
source§

fn convert_wiwi_into_std_iterator(self) -> IterAdapter<<I as IntoIter>::Iter>

Available on crate feature iter-unstable only.
Converts the wiwi iter into a std iterator.
source§

impl<T> Same for T

§

type Output = T

Should always be Self
source§

impl<T> ToMaybeUninit for T

source§

unsafe fn to_maybeuninit(&self) -> &MaybeUninit<T>

Available on crate feature to-maybeuninit only.
source§

unsafe fn to_maybeuninit_mut(&mut self) -> &mut MaybeUninit<T>

Available on crate feature to-maybeuninit only.
source§

unsafe fn to_maybeuninit_drop(&mut self) -> &mut MaybeUninit<T>

Available on crate feature to-maybeuninit only.
Safety Read more
source§

impl<T, U> TryFrom<U> for T
where + I: Iter,

§

type Item = <I as Iter>::Item

Available on crate feature iter-unstable only.
§

type Iter = I

Available on crate feature iter-unstable only.
source§

fn into_wiwi_iter(self) -> I

Available on crate feature iter-unstable only.
source§

impl<I> IntoStdIterator for I
where + I: IntoIter,

§

type Iterator = IterAdapter<<I as IntoIter>::Iter>

Available on crate feature iter-unstable only.
source§

fn convert_wiwi_into_std_iterator(self) -> IterAdapter<<I as IntoIter>::Iter>

Available on crate feature iter-unstable only.
Converts the wiwi iter into a std iterator.
source§

impl<T> Same for T

§

type Output = T

Should always be Self
source§

impl<T> ToMaybeUninit for T

source§

unsafe fn to_maybeuninit(&self) -> &MaybeUninit<T>

Available on crate feature to-maybeuninit only.
source§

unsafe fn to_maybeuninit_mut(&mut self) -> &mut MaybeUninit<T>

Available on crate feature to-maybeuninit only.
source§

unsafe fn to_maybeuninit_drop(&mut self) -> &mut MaybeUninit<T>

Available on crate feature to-maybeuninit only.
Safety Read more
source§

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

§

type Error = Infallible

The type returned in the event of a conversion error.
source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

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

§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
§

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

§

fn vzip(self) -> V

\ No newline at end of file diff --git a/wiwi/iter/trait.AsStdIterator.html b/wiwi/iter/trait.AsStdIterator.html index c19bc7308..33e79d228 100644 --- a/wiwi/iter/trait.AsStdIterator.html +++ b/wiwi/iter/trait.AsStdIterator.html @@ -1,9 +1,9 @@ -AsStdIterator in wiwi::iter - Rust

Trait wiwi::iter::AsStdIterator

source ·
pub trait AsStdIterator<'h> {
+AsStdIterator in wiwi::iter - Rust

Trait wiwi::iter::AsStdIterator

source ·
pub trait AsStdIterator<'h> {
     type Iterator: Iterator + 'h;
 
     // Required method
     fn borrow_wiwi_as_std_iterator(&'h mut self) -> Self::Iterator;
 }
Available on crate feature iter-unstable only.
Expand description

Allows any wiwi iter to be borrowed as an std iterator. There is a blanket implementation provided, so it is available for all wiwi iters.

-

Required Associated Types§

Required Methods§

source

fn borrow_wiwi_as_std_iterator(&'h mut self) -> Self::Iterator

Borrow the wiwi iter as an std iterator.

-

Implementors§

source§

impl<'h, I: Iter + 'h> AsStdIterator<'h> for I

\ No newline at end of file +

Required Associated Types§

Required Methods§

source

fn borrow_wiwi_as_std_iterator(&'h mut self) -> Self::Iterator

Borrow the wiwi iter as an std iterator.

+

Implementors§

source§

impl<'h, I: Iter + 'h> AsStdIterator<'h> for I

\ No newline at end of file diff --git a/wiwi/iter/trait.AsWiwiIter.html b/wiwi/iter/trait.AsWiwiIter.html index dc281a75c..cdbfeb271 100644 --- a/wiwi/iter/trait.AsWiwiIter.html +++ b/wiwi/iter/trait.AsWiwiIter.html @@ -1,9 +1,9 @@ -AsWiwiIter in wiwi::iter - Rust

Trait wiwi::iter::AsWiwiIter

source ·
pub trait AsWiwiIter<'h> {
+AsWiwiIter in wiwi::iter - Rust

Trait wiwi::iter::AsWiwiIter

source ·
pub trait AsWiwiIter<'h> {
     type Iter: Iter + 'h;
 
     // Required method
     fn borrow_std_as_wiwi_iter(&'h mut self) -> Self::Iter;
 }
Available on crate feature iter-unstable only.
Expand description

Allows any std iterator to be borrowed as a wiwi iter. There is a blanket implementation provided, so it is available for all std iterators.

-

Required Associated Types§

source

type Iter: Iter + 'h

Required Methods§

source

fn borrow_std_as_wiwi_iter(&'h mut self) -> Self::Iter

Borrow the std iterator as a wiwi iter.

-

Implementors§

source§

impl<'h, I: Iterator + 'h> AsWiwiIter<'h> for I

\ No newline at end of file +

Required Associated Types§

source

type Iter: Iter + 'h

Required Methods§

source

fn borrow_std_as_wiwi_iter(&'h mut self) -> Self::Iter

Borrow the std iterator as a wiwi iter.

+

Implementors§

source§

impl<'h, I: Iterator + 'h> AsWiwiIter<'h> for I

\ No newline at end of file diff --git a/wiwi/iter/trait.DoubleEndedIter.html b/wiwi/iter/trait.DoubleEndedIter.html new file mode 100644 index 000000000..1e16308d1 --- /dev/null +++ b/wiwi/iter/trait.DoubleEndedIter.html @@ -0,0 +1,14 @@ +DoubleEndedIter in wiwi::iter - Rust

Trait wiwi::iter::DoubleEndedIter

source ·
pub trait DoubleEndedIter: Iter {
+    // Required method
+    fn next_back(&mut self) -> Option<Self::Item>;
+
+    // Provided methods
+    fn rev(self) -> Rev<Self>
+       where Self: Sized { ... }
+    fn for_each_back<F>(self, f: F)
+       where Self: Sized,
+             F: FnMut(Self::Item) { ... }
+}
Available on crate feature iter-unstable only.

Required Methods§

source

fn next_back(&mut self) -> Option<Self::Item>

Provided Methods§

source

fn rev(self) -> Rev<Self>
where + Self: Sized,

source

fn for_each_back<F>(self, f: F)
where + Self: Sized, + F: FnMut(Self::Item),

Implementations on Foreign Types§

source§

impl<I: DoubleEndedIter> DoubleEndedIter for &mut I

source§

fn next_back(&mut self) -> Option<Self::Item>

Implementors§

\ No newline at end of file diff --git a/wiwi/iter/trait.IntoStdIterator.html b/wiwi/iter/trait.IntoStdIterator.html index eafc7478d..fd503a49c 100644 --- a/wiwi/iter/trait.IntoStdIterator.html +++ b/wiwi/iter/trait.IntoStdIterator.html @@ -1,4 +1,4 @@ -IntoStdIterator in wiwi::iter - Rust

Trait wiwi::iter::IntoStdIterator

source ·
pub trait IntoStdIterator {
+IntoStdIterator in wiwi::iter - Rust

Trait wiwi::iter::IntoStdIterator

source ·
pub trait IntoStdIterator {
     type Iterator: Iterator;
 
     // Required method
@@ -6,5 +6,5 @@
 }
Available on crate feature iter-unstable only.
Expand description

Allows any wiwi iter, or anything capable of converting to a wiwi iter (ie. implements IntoIter), to convert to an std iterator. There is a blanket implementation provided, so it is available for all wiwi iters.

-

Required Associated Types§

Required Methods§

source

fn convert_wiwi_into_std_iterator(self) -> Self::Iterator

Converts the wiwi iter into a std iterator.

-

Implementors§

\ No newline at end of file +

Required Associated Types§

Required Methods§

source

fn convert_wiwi_into_std_iterator(self) -> Self::Iterator

Converts the wiwi iter into a std iterator.

+

Implementors§

\ No newline at end of file diff --git a/wiwi/iter/trait.IntoWiwiIter.html b/wiwi/iter/trait.IntoWiwiIter.html index ca92fa42d..2e58da565 100644 --- a/wiwi/iter/trait.IntoWiwiIter.html +++ b/wiwi/iter/trait.IntoWiwiIter.html @@ -1,4 +1,4 @@ -IntoWiwiIter in wiwi::iter - Rust

Trait wiwi::iter::IntoWiwiIter

source ·
pub trait IntoWiwiIter {
+IntoWiwiIter in wiwi::iter - Rust

Trait wiwi::iter::IntoWiwiIter

source ·
pub trait IntoWiwiIter {
     type Iter: Iter;
 
     // Required method
@@ -6,5 +6,5 @@
 }
Available on crate feature iter-unstable only.
Expand description

Allows any std iterator, or anything capable of converting to an std iterator (ie. implements IntoIterator), to convert to a wiwi iter. There is a blanket implementation provided, so it is available for all std iterators.

-

Required Associated Types§

Required Methods§

source

fn convert_std_into_wiwi_iter(self) -> Self::Iter

Converts the std iterator into a wiwi iter.

-

Implementors§

\ No newline at end of file +

Required Associated Types§

Required Methods§

source

fn convert_std_into_wiwi_iter(self) -> Self::Iter

Converts the std iterator into a wiwi iter.

+

Implementors§

\ No newline at end of file diff --git a/wiwi/iter/trait.Iter.html b/wiwi/iter/trait.Iter.html index f8d0bc3c6..bcc8fb1ef 100644 --- a/wiwi/iter/trait.Iter.html +++ b/wiwi/iter/trait.Iter.html @@ -1,4 +1,4 @@ -Iter in wiwi::iter - Rust

Trait wiwi::iter::Iter

source ·
pub trait Iter {
+Iter in wiwi::iter - Rust

Trait wiwi::iter::Iter

source ·
pub trait Iter {
     type Item;
 
     // Required method
@@ -19,12 +19,12 @@
     fn repeat_per_item(self, count: usize) -> RepeatPerItem<Self>
        where Self: Sized,
              Self::Item: Clone { ... }
-}
Available on crate feature iter-unstable only.

Required Associated Types§

Required Methods§

source

fn next(&mut self) -> Option<Self::Item>

Provided Methods§

source

fn size_hint(&self) -> SizeHint

source

fn for_each<F>(self, f: F)
where +}

Available on crate feature iter-unstable only.

Required Associated Types§

Required Methods§

source

fn next(&mut self) -> Option<Self::Item>

Provided Methods§

source

fn size_hint(&self) -> SizeHint

source

fn for_each<F>(self, f: F)
where Self: Sized, - F: FnMut(Self::Item),

source

fn peekable(self) -> Peek<Self, Self::Item>
where - Self: Sized,

source

fn map<O, F>(self, f: F) -> Map<Self, F>
where + F: FnMut(Self::Item),

source

fn peekable(self) -> Peek<Self, Self::Item>
where + Self: Sized,

source

fn map<O, F>(self, f: F) -> Map<Self, F>
where Self: Sized, - F: FnMut(Self::Item) -> O,

source

fn count(self) -> usize
where + F: FnMut(Self::Item) -> O,

source

fn count(self) -> usize
where Self: Sized,

Consumes the iter and returns the number of items that were emitted.

This method won’t advance the iter if it doesn’t have to. If the iter’s size_hint returns HardBound for both lower and upper bound, and @@ -33,7 +33,7 @@ which it then returns.

§Examples

TODO

-
source

fn repeat_per_item(self, count: usize) -> RepeatPerItem<Self>
where +

source

fn repeat_per_item(self, count: usize) -> RepeatPerItem<Self>
where Self: Sized, Self::Item: Clone,

Takes every element emitted by the underlying iter, and returns it count times via cloning.

@@ -78,7 +78,7 @@
§Examples
assert_eq!(orig_iter.next(), Some(3)); assert_eq!(orig_iter.next(), None); assert_eq!(item, Some(None));
-

Implementations on Foreign Types§

source§

impl<I: Iter> Iter for &mut I

§

type Item = <I as Iter>::Item

source§

fn next(&mut self) -> Option<I::Item>

Implementors§

source§

impl<I1> Iter for Tuple1<I1>
where +

Implementations on Foreign Types§

source§

impl<I: Iter> Iter for &mut I

§

type Item = <I as Iter>::Item

source§

fn next(&mut self) -> Option<I::Item>

Implementors§

source§

impl<I1> Iter for Tuple1<I1>
where I1: Iter,

§

type Item = (<I1 as Iter>::Item,)

source§

impl<I1, I2> Iter for Tuple2<I1, I2>
where I1: Iter, I2: Iter,

§

type Item = (<I1 as Iter>::Item, <I2 as Iter>::Item)

source§

impl<I1, I2, I3> Iter for Tuple3<I1, I2, I3>
where @@ -611,5 +611,5 @@
§Examples
I::Item: Clone,

§

type Item = <I as Iter>::Item

source§

impl<I, F, O> Iter for Map<I, F>
where I: Iter, F: FnMut(I::Item) -> O,

§

type Item = O

source§

impl<I, T> Iter for Peek<I, T>
where - I: Iter<Item = T>,

§

type Item = <I as Iter>::Item

source§

impl<I: Iterator> Iter for IterAdapter<I>

§

type Item = <I as Iterator>::Item

source§

impl<T> Iter for Empty<T>

§

type Item = T

source§

impl<T, F> Iter for FromFn<F>
where - F: FnMut() -> Option<T>,

§

type Item = T

\ No newline at end of file + I: Iter<Item = T>,
§

type Item = <I as Iter>::Item

source§

impl<I: Iterator> Iter for IterAdapter<I>

§

type Item = <I as Iterator>::Item

source§

impl<I: DoubleEndedIter> Iter for Rev<I>

§

type Item = <I as Iter>::Item

source§

impl<T> Iter for Empty<T>

§

type Item = T

source§

impl<T, F> Iter for FromFn<F>
where + F: FnMut() -> Option<T>,

§

type Item = T

\ No newline at end of file diff --git a/wiwi/serialiser/buffer/index.html b/wiwi/serialiser/buffer/index.html index a461a5e30..570a7165a 100644 --- a/wiwi/serialiser/buffer/index.html +++ b/wiwi/serialiser/buffer/index.html @@ -1 +1 @@ -wiwi::serialiser::buffer - Rust

Module wiwi::serialiser::buffer

source ·
Available on crate feature serialiser-unstable only.

Traits§

\ No newline at end of file +wiwi::serialiser::buffer - Rust

Module wiwi::serialiser::buffer

source ·
Available on crate feature serialiser-unstable only.

Traits§

\ No newline at end of file diff --git a/wiwi/serialiser/buffer/trait.BufferRead.html b/wiwi/serialiser/buffer/trait.BufferRead.html index 136e0713b..e6158f0ea 100644 --- a/wiwi/serialiser/buffer/trait.BufferRead.html +++ b/wiwi/serialiser/buffer/trait.BufferRead.html @@ -9,4 +9,4 @@ fn read_bytes(&mut self, count: usize) -> Result<&'h [u8]> { ... } fn read_bytes_const<const N: usize>(&mut self) -> Result<&'h [u8; N]> { ... } fn read_byte(&mut self) -> Result<u8> { ... } -}
Available on crate feature serialiser-unstable only.

Required Methods§

source

unsafe fn read_bytes_ptr(&mut self, count: usize) -> Result<*const u8>

Provided Methods§

source

unsafe fn read_bytes_ptr_const<const N: usize>(&mut self) -> Result<*const u8>

source

fn read_bytes(&mut self, count: usize) -> Result<&'h [u8]>

source

fn read_bytes_const<const N: usize>(&mut self) -> Result<&'h [u8; N]>

source

fn read_byte(&mut self) -> Result<u8>

Object Safety§

This trait is not object safe.

Implementations on Foreign Types§

source§

impl<'h> BufferRead<'h> for &'h [u8]

source§

unsafe fn read_bytes_ptr(&mut self, count: usize) -> Result<*const u8>

Implementors§

\ No newline at end of file +}
Available on crate feature serialiser-unstable only.

Required Methods§

source

unsafe fn read_bytes_ptr(&mut self, count: usize) -> Result<*const u8>

Provided Methods§

source

unsafe fn read_bytes_ptr_const<const N: usize>(&mut self) -> Result<*const u8>

source

fn read_bytes(&mut self, count: usize) -> Result<&'h [u8]>

source

fn read_bytes_const<const N: usize>(&mut self) -> Result<&'h [u8; N]>

source

fn read_byte(&mut self) -> Result<u8>

Object Safety§

This trait is not object safe.

Implementations on Foreign Types§

source§

impl<'h> BufferRead<'h> for &'h [u8]

source§

unsafe fn read_bytes_ptr(&mut self, count: usize) -> Result<*const u8>

Implementors§

\ No newline at end of file diff --git a/wiwi/serialiser/buffer/trait.BufferWrite.html b/wiwi/serialiser/buffer/trait.BufferWrite.html index 5b9418db2..5c6fce020 100644 --- a/wiwi/serialiser/buffer/trait.BufferWrite.html +++ b/wiwi/serialiser/buffer/trait.BufferWrite.html @@ -9,5 +9,5 @@ fn write_bytes(&mut self, bytes: &[u8]) { ... } fn write_byte(&mut self, byte: u8) { ... } }
Available on crate feature serialiser-unstable only.

Required Methods§

source

fn reserve(&mut self, additional: usize)

source

unsafe fn write_bytes_unchecked(&mut self, bytes: &[u8])

source

unsafe fn with_ptr<F>(&mut self, f: F)
where - F: FnOnce(*mut u8) -> usize,

Provided Methods§

source

fn write_bytes(&mut self, bytes: &[u8])

source

fn write_byte(&mut self, byte: u8)

Object Safety§

This trait is not object safe.

Implementations on Foreign Types§

source§

impl BufferWrite for Vec<u8>

source§

fn reserve(&mut self, additional: usize)

source§

unsafe fn write_bytes_unchecked(&mut self, bytes: &[u8])

source§

unsafe fn with_ptr<F>(&mut self, f: F)
where + F: FnOnce(*mut u8) -> usize,

Provided Methods§

source

fn write_bytes(&mut self, bytes: &[u8])

source

fn write_byte(&mut self, byte: u8)

Object Safety§

This trait is not object safe.

Implementations on Foreign Types§

source§

impl BufferWrite for Vec<u8>

source§

fn reserve(&mut self, additional: usize)

source§

unsafe fn write_bytes_unchecked(&mut self, bytes: &[u8])

source§

unsafe fn with_ptr<F>(&mut self, f: F)
where F: FnOnce(*mut u8) -> usize,

Implementors§

\ No newline at end of file diff --git a/wiwi/serialiser/marker/index.html b/wiwi/serialiser/marker/index.html index 2a8ba6275..3b28fc243 100644 --- a/wiwi/serialiser/marker/index.html +++ b/wiwi/serialiser/marker/index.html @@ -1 +1 @@ -wiwi::serialiser::marker - Rust

Module wiwi::serialiser::marker

source ·
Available on crate feature serialiser-unstable only.
\ No newline at end of file +wiwi::serialiser::marker - Rust

Module wiwi::serialiser::marker

source ·
Available on crate feature serialiser-unstable only.

Structs§

\ No newline at end of file diff --git a/wiwi/serialiser/marker/sidebar-items.js b/wiwi/serialiser/marker/sidebar-items.js index 5244ce01c..3a9eb0c5a 100644 --- a/wiwi/serialiser/marker/sidebar-items.js +++ b/wiwi/serialiser/marker/sidebar-items.js @@ -1 +1 @@ -window.SIDEBAR_ITEMS = {}; \ No newline at end of file +window.SIDEBAR_ITEMS = {"struct":["Marker"]}; \ No newline at end of file diff --git a/wiwi/serialiser/marker/struct.Marker.html b/wiwi/serialiser/marker/struct.Marker.html new file mode 100644 index 000000000..7aa3707ab --- /dev/null +++ b/wiwi/serialiser/marker/struct.Marker.html @@ -0,0 +1,12 @@ +Marker in wiwi::serialiser::marker - Rust

Struct wiwi::serialiser::marker::Marker

source ·
pub struct Marker { /* private fields */ }
Available on crate feature serialiser-unstable only.

Implementations§

source§

impl Marker

source

pub fn read_from<'h, B: BufferRead<'h>>(input: &mut B) -> Result<Self>

Auto Trait Implementations§

§

impl Freeze for Marker

§

impl RefUnwindSafe for Marker

§

impl Send for Marker

§

impl Sync for Marker

§

impl Unpin for Marker

§

impl UnwindSafe for Marker

Blanket Implementations§

source§

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

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

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

source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

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

source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

Returns the argument unchanged.

+
source§

impl<T, U> Into<U> for T
where + U: From<T>,

source§

fn into(self) -> U

Calls U::from(self).

+

That is, this conversion is whatever the implementation of +From<T> for U chooses to do.

+
source§

impl<T> Same for T

§

type Output = T

Should always be Self
source§

impl<T> ToMaybeUninit for T

source§

unsafe fn to_maybeuninit(&self) -> &MaybeUninit<T>

Available on crate feature to-maybeuninit only.
source§

unsafe fn to_maybeuninit_mut(&mut self) -> &mut MaybeUninit<T>

Available on crate feature to-maybeuninit only.
source§

unsafe fn to_maybeuninit_drop(&mut self) -> &mut MaybeUninit<T>

Available on crate feature to-maybeuninit only.
Safety Read more
source§

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

§

type Error = Infallible

The type returned in the event of a conversion error.
source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

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

§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
§

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

§

fn vzip(self) -> V

\ No newline at end of file diff --git a/wiwi/serialiser/number/index.html b/wiwi/serialiser/number/index.html index db7b6cdd5..bcfc62789 100644 --- a/wiwi/serialiser/number/index.html +++ b/wiwi/serialiser/number/index.html @@ -1 +1 @@ -wiwi::serialiser::number - Rust
\ No newline at end of file +wiwi::serialiser::number - Rust
\ No newline at end of file diff --git a/wiwi/serialiser/serialise/trait.Serialise.html b/wiwi/serialiser/serialise/trait.Serialise.html index ac05a7eb1..fad4f1c86 100644 --- a/wiwi/serialiser/serialise/trait.Serialise.html +++ b/wiwi/serialiser/serialise/trait.Serialise.html @@ -1,8 +1,8 @@ -Serialise in wiwi::serialiser::serialise - Rust

Trait wiwi::serialiser::serialise::Serialise

source ·
pub trait Serialise {
+Serialise in wiwi::serialiser::serialise - Rust

Trait wiwi::serialiser::serialise::Serialise

source ·
pub trait Serialise {
     // Required method
     fn serialise<B: BufferWrite>(
         &self,
         output: &mut B,
         options: &SerialiseOptions
     );
-}
Available on crate feature serialiser-unstable only.

Required Methods§

source

fn serialise<B: BufferWrite>(&self, output: &mut B, options: &SerialiseOptions)

Object Safety§

This trait is not object safe.

Implementations on Foreign Types§

source§

impl Serialise for i8

source§

fn serialise<B: BufferWrite>(&self, output: &mut B, options: &SerialiseOptions)

source§

impl Serialise for i16

source§

fn serialise<B: BufferWrite>(&self, output: &mut B, options: &SerialiseOptions)

source§

impl Serialise for i32

source§

fn serialise<B: BufferWrite>(&self, output: &mut B, options: &SerialiseOptions)

source§

impl Serialise for i64

source§

fn serialise<B: BufferWrite>(&self, output: &mut B, options: &SerialiseOptions)

source§

impl Serialise for i128

source§

fn serialise<B: BufferWrite>(&self, output: &mut B, options: &SerialiseOptions)

source§

impl Serialise for u8

source§

fn serialise<B: BufferWrite>(&self, output: &mut B, options: &SerialiseOptions)

source§

impl Serialise for u16

source§

fn serialise<B: BufferWrite>(&self, output: &mut B, options: &SerialiseOptions)

source§

impl Serialise for u32

source§

fn serialise<B: BufferWrite>(&self, output: &mut B, options: &SerialiseOptions)

source§

impl Serialise for u64

source§

fn serialise<B: BufferWrite>(&self, output: &mut B, options: &SerialiseOptions)

source§

impl Serialise for u128

source§

fn serialise<B: BufferWrite>(&self, output: &mut B, options: &SerialiseOptions)

Implementors§

\ No newline at end of file +}
Available on crate feature serialiser-unstable only.

Required Methods§

source

fn serialise<B: BufferWrite>(&self, output: &mut B, options: &SerialiseOptions)

Object Safety§

This trait is not object safe.

Implementors§

\ No newline at end of file diff --git a/wiwi/string_pool/pool/struct.SlicesWrapIter.html b/wiwi/string_pool/pool/struct.SlicesWrapIter.html index 191e7015a..17cbc6722 100644 --- a/wiwi/string_pool/pool/struct.SlicesWrapIter.html +++ b/wiwi/string_pool/pool/struct.SlicesWrapIter.html @@ -181,8 +181,8 @@ F: FnMut(Self::Item) -> K, 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 function. Read more

Auto Trait Implementations§

§

impl<'h> Freeze for SlicesWrapIter<'h>

§

impl<'h> RefUnwindSafe for SlicesWrapIter<'h>

§

impl<'h> Send for SlicesWrapIter<'h>

§

impl<'h> Sync for SlicesWrapIter<'h>

§

impl<'h> Unpin for SlicesWrapIter<'h>

§

impl<'h> UnwindSafe for SlicesWrapIter<'h>

Blanket Implementations§

source§

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

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<'h, I> AsWiwiIter<'h> for I
where - I: Iterator + 'h,

§

type Iter = IterAdapter<&'h mut I>

Available on crate feature iter-unstable only.
source§

fn borrow_std_as_wiwi_iter(&'h mut self) -> IterAdapter<&'h mut I>

Available on crate feature iter-unstable only.
Borrow the std iterator as a wiwi iter.
source§

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

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<'h, I> AsWiwiIter<'h> for I
where + I: Iterator + 'h,

§

type Iter = IterAdapter<&'h mut I>

Available on crate feature iter-unstable only.
source§

fn borrow_std_as_wiwi_iter(&'h mut self) -> IterAdapter<&'h mut I>

Available on crate feature iter-unstable only.
Borrow the std iterator as a wiwi iter.
source§

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

source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

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

source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

Returns the argument unchanged.

source§

impl<T, U> Into<U> for T
where @@ -190,8 +190,8 @@

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

source§

impl<I> IntoIterator for I
where - I: Iterator,

§

type Item = <I as Iterator>::Item

The type of the elements being iterated over.
§

type IntoIter = I

Which kind of iterator are we turning this into?
const: unstable · source§

fn into_iter(self) -> I

Creates an iterator from a value. Read more
source§

impl<I> IntoWiwiIter for I
where - I: IntoIterator,

§

type Iter = IterAdapter<<I as IntoIterator>::IntoIter>

Available on crate feature iter-unstable only.
source§

fn convert_std_into_wiwi_iter( + I: Iterator,

§

type Item = <I as Iterator>::Item

The type of the elements being iterated over.
§

type IntoIter = I

Which kind of iterator are we turning this into?
const: unstable · source§

fn into_iter(self) -> I

Creates an iterator from a value. Read more
source§

impl<I> IntoWiwiIter for I
where + I: IntoIterator,

§

type Iter = IterAdapter<<I as IntoIterator>::IntoIter>

Available on crate feature iter-unstable only.
source§

fn convert_std_into_wiwi_iter( self ) -> IterAdapter<<I as IntoIterator>::IntoIter>

Available on crate feature iter-unstable only.
Converts the std iterator into a wiwi iter.
source§

impl<I> IteratorRandom for I
where I: Iterator,

source§

fn choose<R>(self, rng: &mut R) -> Option<Self::Item>
where