rust #rustc 1.98.1 (48a229cea 2026-09-01)RL.SAwjL-df1bddb45adbe94bstable_deref_traitΨu:º -64f30039b2c2300d<%Z>64V`-2d2ab9fb0fe1def5 yoke_derive>~A{/T-8eebb48bf43fffc9zerofromf61Yω9-9a0f59f293ad4c01zerofrom_derive~9 󑮂7E j-9d1d867a982232d3,BoxKa$$tests,a$aerased4 ErasedArcCartl ErasedBoxCartl$& ErasedRcCartdEGKpToOwned<  cartable_ptr sentinel_forSENTINELprivate SealedCartablePointerLikeRawinto_rawdrop_rawCloneableCartablePointerLike addref_raw'a!! ! from_cartable!is_none&&)),.0either22226C06C1666;2= = =2A A kinda_sorta_danglingDDDDDDDKindaSortaDanglingKKdangleDNN N into_innerDRRRDVVDYY macro_impls\\\\\copy_yoke_impl\impl_copy_type\unsafe_complex_yoke_impl\ddd'bd\iiT1i iT2i i\ppp pp pv utilsxxtransform_mut_yokeablezzzzz yoke  Yokeyokeablecart attach_to_cart'detry_attach_to_cartattach_to_cart_badlytry_attach_to_cart_badlyget backing_cartinto_backing_cart replace_cartC2impl FnOnce(C) -> C2with_mut with_mut_return wrap_cart_in_optionnew_always_owned into_yokeable  new_ownedtry_into_yokeable  convert_cart_into_option_pointer  CloneableCart   map_projectmap_project_cloned'thistry_map_projecttry_map_project_cloned!map_project_with_explicit_capture(map_project_cloned_with_explicit_capture%try_map_project_with_explicit_capture,try_map_project_cloned_with_explicit_capture map_with_cartmap_with_cart_clonedtry_map_with_carttry_map_with_cart_clonedwrap_cart_in_either_awrap_cart_in_either_bYokeable transformtransform_ownedmake transform_mut            zero_fromattach_to_zero_copy_cart CartableOptionPointerinner _cartable 2 EitherCart    2  2  2  2  2  \     \     \     \     \     \     \      \      \      \      \      \     \     \     \     d d d d  i i i i  p p p p  888%8(8+88888888;8U8X8[888888888888888888888888888888   22g###(#2222 2JĪ  3333g3"333"KK M D6"4#4řǙșəʙ˙G*R{9 2  2gXѴ g8888888řǙșəʙ˙G*R{9 4258 2!!! PhantomDatao$z -2   &YK),Ař  .06RK=VK dři p ! g#  " "gcD    5,  4 7  41$   3f*ہ4T > 5 ==f>\ $   2 3f*ہ2$ 4   ;?T ?$  ,?!!i5!?D!_pointer5$ #k5#?D#@ -(I  L B 3f*ہ2\ gL  B !!!9o$z -2M  Y C g 4IN ÜĜŜƜǜȜ_w5ĤĤŤError :M 2 ggg cgbufcثq1ȡ)B1B!C) B4BC  CF|FCFCDĤNN CNa 2CN#M2$MBnG~PDP 2DPTP1 ]PPG9 ] ] A ]FI ]F ]  BBI ]Q ] 3:  !]  ] ř Argumentstemplateccg@#  ]]  ] [BB ! ]Q ]Y ]  EPG 2#CQ$OP ] ] 2$O2DOB,PFFFFBFF~NeMatchvX]! ]ařǙșəʙ˙G*R{9 Jcartable# left_val right_val HGPJK(TSBIJSSGS&JSC S%RT$SE,SFFB @GJTTBTTTGT BBXM*1ĈWWGV%BW\W 2X$X(TT5T 2LTBTF(F B(B9 =sGWR2GSTYBYYYGYRNC '[l[ 2[$T\B\S 25C\+YY 2$YE,YBY5YF*F"B*BD H{GYR4V( # 3! 32: 3! 32: 33  33'  3! 3,64 33 3&3.b__self_0YZXmY4 H *9 IZY f wZZ Z3*Z:3Q]kp ZZ Z 3*Z: 3Q  ]  kp ZZ   7=DKR^ZfZn6v6~ZZ666Z%Z- Z8`@ZZ ZaZZZZZZZ'1 ? __self_discrY __arg1_discrqY __arg1_0 Ya^_6  5Z!*4( # 3D LB- 9  Cuz g  k 3B-9Cdg +18 DEZMFU6]ZBlC`ZXBChapYYaCd`CMd$T$ 3L, "3 < 3L, "3 <+  T; Z,iX6$ZiZ2i9 ]hThĜ 44%L K4P4$44 MaybeUninituninitW췜4 bk   k)   K4  P44k4z 3V 4$%4l " ManuallyDrop~$4e]bk  4Q4 4$o4 k 4 o 3manual=pndn0o\k| 4/U 4p,pt7q{\k| 40X 44 4L k{=r\ kħ T  40d  (l  4F|  [5sL5]>s Btt A 5hu( 2E5`5  V55G5 5 this5:8  # 5;C5x`xx Nx A=h=( / E5`5  / G5 5 v 08  #x 58@5{`x{ N{ A 5h}( 2 E5`5  / G5 5 v 08  #x 58@5`x N A 5h( 3 E5`5  / G5 5 v 08  #x 58@5`x!P A 5h( 3 E5`5  / G5 5 v 08  #x 58@5`x!P A 5h܈( 3 E5`5  / G5 5 v 08  #x 58@5`x!P A 5hŒ( 3 E5`5  / G5 5 v 08  #x 58@5`x!Pڎ A 5h( 3 E5`5  / G5 5 v 08  #x 58@5˒`xɒ!P A 6h( 3 E6`6  / G6 6 v 08  #x 68@5`x!P !!!A 6h!(! 3 !!!E6`!6 ! / !!!G6 !6 !v 08! ! #x 68@!!5!`!x!!P ###A 6h#ڛ(# 3 ###E6`#6 # / ###G6 #6 #v 08# # #x 68@##5#`#x#!P %%%A 6h%(% 3 %%%E6`%6 % / %%%G6 %6 %v 08% % #x 68@%%5%`%x%!Pء '''A 6h'(' 3 '''E6`'6 ' / '''G6 '6 'v 08' ' #x 68@''5'ɥ`'x'ǥ!P )))A h)() 2 )))E`) ) - )))G ) )v .8) ) #x 7?))5)`)x)!P +++A h+(+ 2 +++E`+ + - +++G + +v .8+ + #x 7?++5+`+x+!P ,,, řǙșəʙ˙G*R{9 2,.,, , 6@, 6, K, (,, , 6,0, , ,, 6A&p,H, ,),,,8,,M`,6 ,uϯ^n~$6"6Nn a;6 -ST]    ,,  ",x, 6 !,./T]  [#@B# ((,,+ ,   ,,  B  'p,H, 6, (,,, 8,, 6 , ,{55l-,\n~$Dq , uSյ׶o-,-,$ z65 ,,;,,5, 6`,,K 11, 771.11 ˻1 7@1ʻ} 71 K1 (11 1 7˻101 1 11 7A&p1H1 ˻1)111811M˻`17 1ʻu^n~$7"7Nn a;7 2ST]    11 ˻ "1x1 7 !1.4T] յ#@B# &(11+ 1   11 ˻ B  'p1H1 71 (111 811 7 1˻ 1y55j-ʻ1\n~$˻D˻q 1 sQյ o˻-1-1$ z75 11;1151 7`11K 66, 6.66 6 7@6l 76 K6 (66 6 7606 6 66 7A&p6H6 6)666866M`67 6u^n~$7"7Nn a;7 7ST]    66  "6x6 7 !6.9T] յ#@B# &(66+ 6   66  B  'p6H6 76 (666 866 7 6 6y55j-6\n~$Dq 6 sQյ o-6-6$ z75 6696656 7`66K    D& -$ B43   $ 7 # R6?  z5R   D (S SV14% B%d% g %7%/T& BT&& 88$& ,&.  C%A,& dx f&4&   B&d& 88$& t&.  C%q,& r `&"%4& dOD&&%D% 8,%F % dd DebugStructddd dd has_fieldsd19-6BUB C 8BC 8^Cg.CT(($(,((&( gD (+)({D(,(F ( KT**$*,*&\**,*,*&̹* W+**L$*,*,* 8 ;fT--$-,-\--,-,--#\- qNĩ--,vřǙșəʙ˙G*R{9 LessGreater%ӡy,,,,,iJ' *|[T./$.,/\//,/,/./ kH//.^.,.,.% (U dV   V  $VdV,V "8*"ğ D +$ϒ Ύ 8     2B S8I XѴ 8߃\ލ8$ n~$h߃$98(߃dk ll.߃8 lAF "/a  l 8H 85 8d 52 8=  }DF٭ l߭tޭ,  5컭 z8Q6 8 d n685d 88řǙșəʙ˙G*R{9 8 ʙ8$$ ܮXѴ 88$ n!D$ٷ 85#5XѴ 85$ʷ8DvlּּT Q81d8 ٻ$л{9ƒ!D$$ ř8 8$8D~B    ř8 8  88E L )|PlԳTƒ- d$ L 8  8   (AU\ÜĜŜƜǜȜ_w8|$6<j87ƒ,3 L|*lܜ #8 $8l*$ $8$* 8###(8  8Ɲ  Y XѴ 8Ɲ!$6T8ƝƝB#T  )1<DLƝe< %8. Ll ԁTƒ@ d 8t$ )L 8b  (AƝUƝj   ÜĜŜƜǜȜ_w8|$ ƝB85<G<ޡƒƝiƝpwT$,, I<l<$#%L8, 82< 88 8$,$88?vA{Xè       lԈTƒ-d,| 8I< #!!!9o$z -u@ HU #{   T<    . Pĭ   +L 8̔ ĭ8  ۗ    ڗ8L XѴ ĭ8T8$ ĭ&_8KK M D6ĭĭ8~Wnƒ7 ]8s       T$ , # "/ #V _   T<  - Pٟ*L 8,è - < 8    7 XѴ 8T\ |o)]KK M D68"RP#è    l Tƒ - d,| B< ##0FO  >=  %ÜĜŜƜǜȜ_wz  = m"-  T<< !? [ÜĜŜƜǜȜ_wu %ÜĜŜƜǜȜ_w  Ѵ 8 ߱߱ &L8± ĭ8  Ҵخ 5F+8 mCJQ8$ m[}OD^}86&Ѱ)ĭ8u  *  ƒ]898    T$,Ԑ #"/EN  @  %ÜĜŜƜǜȜ_wx}  ܐ m!,  T<<!A [ÜĜŜƜǜȜ_wu %ÜĜŜƜǜȜ_w   Ͻ  պպ  &L8,è-  < 8    н Ƚ  - h y Zdkr\ m[}OD^'6.7D38<  A  jèO     lTƒ- d,|B <  t\8#\ ,T<   $   &L 8 ĭ8   8%5 5 T8$<!!!9o$z - 5ĭB ]8/NѰuĭd8[capturezHƒE8     T$ ,<  #^8#\ ,T<  $ &L 8,è - < ĭ8     8 T\< B ѰVĭE8&Ey|ki!èѰE+  )1l Tƒ -d,|B<  t\ 8#\,Bu I$ 0 Cu m"-  T<< !C [! -  8  &L8 ĭ8  8   . Y*8$<ÜĜŜƜǜȜ_wB  U86Ѱ=ĭ,8,     ƒ:n88&-4  )1T$,< #^8#\,D$ I$ 0 C$ m"-  T<<!E [! -     &L8,è-  < ĭ8      -? P ZL\<B %}[6?HѰĭ8QXS  a  A-è}Ѱ     lTƒ- d,|B   L 8, ,  <e   '/< #;c l  T<   $   &L 8ƀ ĭ8  Ճ     ԃ8nT8$ r88VѰ[ĭJ8Al8 ƒ298)       T$ ,L8,- <   ) #N W   T<  #؋؋  %L 8,è - < 8  Ҏ ˎ    6T\ӈ [N<#P?8!@wyuTè9  )1  l ԀTƒ - d,| B  L 8,Ę , <Ęe   '/<,T] ՘ Ff $ 0 Cfm"-  T<< !G֘[!-   8  &Lٛ8 ĭ8  <M_pN8 Mԕ8$ŕ ˕ldKv8-L6PYѰ ĭ8Y; b ƒb<8078  أ  ܣ Tޣ$ޣ,L 8, - <ܣ   )?H  Hܣ! {# / Bܣ! m"- ئ TЦ<Ц< !I [! -   Ǧ &L8,è-  < 8   ؠ-^oZԣK\ :L6>G8Qw  R  }C"%èv  d 88JĪ8 8$l ܓXѴ 8̓8$ n+ d 88JĪ8 8$lĘ ܎XѴ 8̎8$ n+ֆ Ȇ5ц'() ٻ5'()݉ ω5؉'()$XXW ?LWDW 1$YYX?,X?$X -$[[[Y?$Y?$Y 2[9$^^.$_  _ # ?7?_[^U\5[d[ [ ?^03 ^$eed? :e۠De 0fe=:de:$e #:2ff?:$f:$f #:3`][Yoke], which allows one to "yoke" (attach) a zero-copy deserialized object (say, a [`Cow<'a, str>`](alloc::borrow::Cow)) to the source it was deserialized from, (say, an [`Rc<[u8]>`](alloc::rc::Rc)),if known in this crate as a "cart", producing a type that looks like `Yoke, Rc<[u8]>>`*' and can be moved around with impunity.fc Succinctly, this allows one to "erase" static lifetimes and turn them into dynamic ones, similarlyTQ to how `dyn` allows one to "erase" static types and turn them into dynamic ones.XU Most of the time the yokeable `Y` type will be some kind of zero-copy deserializable UR abstraction, potentially with an owned variant (like [`Cow`](alloc::borrow::Cow),  [`ZeroVec`](https://docs.rs/zerovec), or an aggregate containing such types), and the cart `C` will be some smart pointer like  [`Box`](alloc::boxed::Box), [`Rc`](alloc::rc::Rc), or [`Arc`](std::sync::Arc), potentially wrapped in an [`Option`](Option).  da The key behind this crate is [`Yoke::get()`], where calling [`.get()`][Yoke::get] on a type like a^ `Yoke, _>` will get you a short-lived `&'a Cow<'a, str>`, restricted to the pm lifetime of the borrow used during [`.get()`](Yoke::get). This is entirely safe since the `Cow` borrows fromro the cart type `C`, which cannot be interfered with as long as the `Yoke` is borrowed by [`.get()`](Yoke::get).if [`.get()`](Yoke::get) protects access by essentially reifying the erased lifetime to a safe local one when necessary.74 See the documentation of [`Yoke`] for more details.2D\xP 3FIL85 Types for optional pointers with niche optimization.NK The main type is [`CartableOptionPointer`], which is like `Option` butMJ with a niche so that the resulting `Yoke` has a niche. The following four74 types can be stored in the `CartableOptionPointer`:\ 1. `&T`| 2. `Box`t 3. `Rc`| 4. `Arc`OL These four types implement the sealed unsafe trait [`CartablePointerLike`].KH In addition, all except `Box` impl [`CloneableCartablePointerLike`],@= which allows [`CartableOptionPointer`] to implement `Clone`.d l9\!9!< StableDeref\4  oO8 "d >B  4  4  D  5 \< 4   |:85 An object fully representable by a non-null pointer.d # Safety Implementer safety:`] 1. `into_raw` transfers ownership of the values referenced by [`StableDeref`] to the caller,(% if there is ownership to transferWT 2. `drop_raw` returns ownership back to the impl, if there is ownership to transfer_\ Note: if `into_raw` returns the sentinel pointer, memory leaks may occur, but this will not  lead to undefined behaviour.XU Note: the pointer `NonNull` may or may not be aligned and it should neverVS be dereferenced. Rust allows unaligned pointers; see [`std::ptr::read_unaligned`].\ 49.%K@7LDDA The raw type used for [`Self::into_raw`] and [`Self::drop_raw`].t4(.+ Converts this pointer-like into a pointer.t4D 3f*ہB $074 Drops any memory associated with this pointer-like.d Caller safety:EB 1. The pointer MUST have been returned by this impl's `into_raw`.(% 2. The pointer MUST NOT be dangling.t4D5  <B?< An object that implements [`CartablePointerLike`] that alsoEB supports cloning without changing the address of referenced data.dKH 1. `addref_raw` must create a new owner such that an additional call to41 `drop_raw` does not create a dangling pointerGD 2. `addref_raw` must not change the address of any referenced data.*6+2 Clones this pointer-like.dE(t4T5  <2 2 0 2"$D  2 D 2?B 2!(D!?5 2@ "9 "2  "#*T#?5 2@v LB""2 L2L2#$%M$M2B!! #2O0lO22B!! $2N &RQC@ Returns whether this instance is `None`. From the return value:QR'$ - If `true`, the instance is `None`R63 - If `false`, the instance is a valid `SelectedRc` ?@@>? TT43\3\3 l B CBC3l3l3-/24ĤKndDFj\DGs,"DIDerefMutD"DJLVXFHL;=$& 0 LLɿ 4< 46M[(*4DKKk&OOɿ <4PQ*44BNN P4 k5#T44BNN Q470SSɿ <4TU""U \4RR4, 4 4BR R U4$3WWɿ <4X"X!L 4 4BV V X4$/ZZɿ <4[#[$ 45BY Y [4$|\D\]P\]nd\_ \`|T$2 "܆t    *  3+   848 8 L   8$( 8$'84  8$+   848 8 |  8$(8$'84  8$+   848"48 8 $  8v$& 8$'84(8$  8v$+   848 8 l 8     :88$$ 8 & 8 8$,8 & :7< 8  :  84   : 88$'84$   8   8$% ܎t    , 8& 8*   8"48$ : 8D : 8 , 8   8!$84 8$ % 8 t    % %  %Ă    *  ,8 8 L   :8$( :8$'84  8"4       8$8 8,8$8 8,8$'848 8 |  8$(8$'84  8"4  88 &  8,8$'84    8$8 8,8$ 8cast$  % 88  8nd'8   8$% 8 '8read$  8 8"48 8 $  8$& 8$'84(8$  8 debug_assertd   8<' 8$'84   8<' 8$   % 88   8$8 8,8$'848 8,8$% 88  8nd'8   8$% 8"4  8 '8$  8 8 8 l 8     :88$$ 8 & 8 8$,8 & :7< 8  :  84   : 88$'84$   8,'8 ,'8   8$$ 8 % Mefef 2<g2g6hdf\4ddřǙșəʙ˙G*R{9 2uj k mkmj777<l7l7<n7n7o\4ii77Zqrttqr 5t<s2s7vpru 5\4ppL,zDxyPxy|- B{|}~}{|~   d<# &# < z)k3kD$##T K ,xDP9\!9!nds,"ƽ\̖/d|m^O+;8 A Cow-like borrowed object "yoked" to its backing data.GD This allows things like zero copy deserialized data to carry aroundQN shared references to their backing buffer, by "erasing" their static lifetime2/ and turning it into a dynamically managed one.C@ `Y` (the [`Yokeable`]) is the object containing the references,FC and will typically be of the form `Foo<'static>`. The `'static` is RO not the actual lifetime of the data, rather it is a convenient way to mark the (% erased lifetime and make it dynamic.  ZW `C` is the "cart", which `Y` may contain references to. After the yoke is constructed, YV the cart serves little purpose except to guarantee that `Y`'s references remain valid da for as long as the yoke remains in memory (by calling the destructor at the appropriate moment).  `] The primary constructor for [`Yoke`] is [`Yoke::attach_to_cart()`]. Several variants of that YV constructor are provided to serve numerous types of call sites and `Yoke` signatures.  c` The key behind this type is [`Yoke::get()`], where calling [`.get()`][Yoke::get] on a type likeac` lifetime of the borrow used during `.get()`. This is entirely safe since the `Cow` borrows froma^ the cart type `C`, which cannot be interfered with as long as the `Yoke` is borrowed by `.geta^ ()`. `.get()` protects access by essentially reifying the erased lifetime to a safe local oneǵli Furthermore, there are various [`.map_project()`][Yoke::map_project] methods that allow turning a `Yoke`c` into another `Yoke` containing a different type that may contain elements of the original yokedA> value. See the [`Yoke::map_project()`] docs for more details.\Y In general, `C` is a concrete type, but it is also possible for it to be a trait object.l # ExampleQN For example, we can use this to store zero-copy deserialized data in a cache:\ ```rust # use yoke::Yoke; # use std::rc::Rc;܇ # use std::borrow::Cow;74 # fn load_from_cache(_filename: &str) -> Rc<[u8]> {! # // dummy implementationKH # Rc::new([0x5, 0, 0, 0, 0, 0, 0, 0, 0x68, 0x65, 0x6c, 0x6c, 0x6f])< # }IF fn load_object(filename: &str) -> Yoke, Rc<[u8]>> {52 let rc: Rc<[u8]> = load_from_cache(filename);OL Yoke::, Rc<[u8]>>::attach_to_cart(rc, |data: &[u8]| {52 // essentially forcing a #[serde(borrow)]>; Cow::Borrowed(bincode::deserialize(data).unwrap())T }), }/, let yoke = load_object("filename.bincode");'$ assert_eq!(&**yoke.get(), "hello");52 assert!(matches!(yoke.get(), &Cow::Borrowed(_)));< ```$8 8 88XѴ LNOQD<"$"8# $ $8$g8$g8%8gkm$vx$%D% 8 ggg cgEcثq1ȡDB % 88$%m& & '8'g8'8g\^ac''(D( 8 ggg cgEcثq1ȡDB ( 88$(Ro)z ) )8)8L)8bdgi))*"* 8 8B * 88$* ep*l * *8+8+8QSVX+++| + +8,8T,8bdgi,,,B\, 8 8B , 88$, -r-n - -8-8.8\^ac-..2. 8 8B . 88$. <9 may borrow only from the argument passed to the closure.>>RO See also [`Yoke::try_attach_to_cart()`] to return a `Result` from the closure.??UR Call sites for this function may not compile pre-1.61; if this still happens, use@41 [`Yoke::attach_to_cart_badly()`] and file a bug.@t@ # ExamplesATFק,FFFB? let yoke: Yoke, _> = load_object("filename.bincode");F'G5 (Yoke, Rc<[u8]>>, usize) {K5K$! let mut bytes_remaining = 0;L30 let bytes_remaining = &mut bytes_remaining;LGD let yoke = Yoke::, Rc<[u8]>>::attach_to_cart(|M rc,ܻM |data: &[u8]| {MEB let mut d = postcard::Deserializer::from_bytes(data);NEB let output = serde::Deserialize::deserialize(&mut d);N?< *bytes_remaining = d.finalize().unwrap().len();O.+ Cow::Borrowed(output.unwrap())tO },TO );P  (yoke, *bytes_remaining),PPPC@ let (yoke, bytes_remaining) = load_object("filename.postcard");Q'Q5Q# assert_eq!(bytes_remaining, 3);, C>`, thisj# will return an `&'a Cow<'a, T>`jljk\kkkŢkk7l!ʣlK Yoke, Rc<[u8]>> {n74 # let rc: Rc<[u8]> = load_from_cache(filename);nQN # Yoke::, Rc<[u8]>>::attach_to_cart(rc, |data: &[u8]| {o@= # Cow::Borrowed(bincode::deserialize(data).unwrap())do # })>::attach_to_zero_copy_cart(y Box::new(local_data),4y );y# assert_eq!(*yoke.get(), "foo");zĪz // Get back the cartz(% let cart = yoke.into_backing_cart();z assert_eq!(&*cart, "foo");<{{{@= Bad example: information specified in `.with_mut()` is lost.{<{̄| use std::borrow::Cow;|||&| let mut yoke =}IF Yoke::, Box>::attach_to_zero_copy_cart(}! Box::new(local_data),T}~" assert_eq!(yoke.get(), "foo");~~  // Override data in the cart~ yoke.with_mut(|cow| {~# let mut_str = cow.to_mut();ġ mut_str.clear();  mut_str.push_str("bar");< });" assert_eq!(yoke.get(), "bar");Ğ()& assert_eq!(&*cart, "foo"); // WHOOPS!<88B 88L74 Unsafe function for replacing the cart with another<9 This can be used for type-erasing the cart, for example.dTQ - References from the yokeable `Y` should still be valid for the lifetime of the returned cart type `C`.^[ For the purpose of determining this, `Yoke` guarantees that references from the Yokeableb_ `Y` into the cart `C` will never be references into its stack data, only heap data protected؅eb by `StableDeref`. This does not necessarily mean that `C` implements `StableDeref`, rather that†eb any data referenced by `Y` must be accessed through a `StableDeref` impl on something `C` owns.gd Concretely, this means that if `C = Option>`, `Y` may contain references to the `T` but not anything else.[X - Lifetimes inside C must not be lengthened, even if they are themselves contravariant.XU I.e., if C contains an `fn(&'a u8)`, it cannot be replaced with `fn(&'static u8)`,)& even though that is typically safe.$! Note: `f` *is* allowed to panic.Պ݊^[ Typically, this means implementing `f` as something which _wraps_ the inner cart type `C`.XU `Yoke` only really cares about destructors for its carts so it's fine to erase otherZW information about the cart, as long as the backing data will still be destroyed at thet same time.d8߃ō#|ʍ#߃׍ 88߃R]eg`b~(% Mutate the stored [`Yokeable`] data.YV If the callback needs to return `'static` data, then [`Yoke::with_mut_return`] can beVS used until the next breaking release of `yoke`, at which time the callback to thisؔ74 function will be able to return any `'static` data.EB See [`Yokeable::transform_mut()`] for why this operation is safe.lB? This can be used to partially mutate the stored data, providedϖ)& no _new_ borrowed data is introduced.\! # use yoke::{Yoke, Yokeable};Ţ֗ # use std::mem;7ʘ!ʣK<ɤ,̙֙FC # fn load_object(filename: &str) -> Yoke, Rc<[u8]>> {7ݚLI # Yoke::, Rc<[u8]>>::attach_to_cart(rc, |data: &[u8]| {RO # // A real implementation would properly deserialize `Bar` as a whole # Bar {NK # numbers: Cow::Borrowed(bincode::deserialize(data).unwrap()),MJ # string: Cow::Borrowed(bincode::deserialize(data).unwrap()),$! # owned: Vec::new(),| # }d<ɤ #[derive(Yokeable)] struct Bar<'a> {ٞ numbers: Cow<'a, [u8]>, string: Cow<'a, str>, owned: Vec,,ş͟96 // `load_object()` deserializes an object from a file@= let mut bar: Yoke = load_object("filename.bincode");Р*' assert_eq!(bar.get().string, "hello");:7 assert!(matches!(bar.get().string, Cow::Borrowed(_)));EB assert_eq!(&*bar.get().numbers, &[0x68, 0x65, 0x6c, 0x6c, 0x6f]);;8 assert!(matches!(bar.get().numbers, Cow::Borrowed(_)));Ȣ'$ assert_eq!(&*bar.get().owned, &[]); bar.with_mut(|bar| {/, bar.string.to_mut().push_str(" world");ͣ63 bar.owned.extend_from_slice(&[1, 4, 1, 5, 9]);<0- assert_eq!(bar.get().string, "hello world");Ѥ74 assert!(matches!(bar.get().string, Cow::Owned(_)));41 assert_eq!(&*bar.get().owned, &[1, 4, 1, 5, 9]);ƥ(% // Unchanged and still Cow::BorrowedEٍ;<D 85B <ɧ# 8ӧ3#5ۧ+ 88$קXU Mutate the stored [`Yokeable`] data, and return `'static` data (possibly just `()`).TQ See [`Yokeable::transform_mut()`] for why this operation is safe, noting that not `'static`. ### Will be removed\Y This method will be removed on the next breaking release of `yoke`, when the callback ofZW [`Yoke::with_mut`] will gain the ability to return any `R: 'static` and supersede this\ method.|B  ٔ<լ# ߬8# < 88$ܮ6MJ Helper function allowing one to wrap the cart type `C` in an `Option`.8B 88) ư8ɰ-/Ͱ,?< Construct a new [`Yoke`] from static data. There will be no@= references to `cart` here since [`Yokeable`]s are `'static`,2/ this is good for e.g. constructing fully owned)& [`Yoke`]s with no internal borrowing.߲IF This is similar to [`Yoke::new_owned()`] but it does not allow you toA> mix the [`Yoke`] with borrowed data. This is primarily useful,) for using [`Yoke`] in generic scenarios.lƴ\δ޴41 let owned: Cow = "hello".to_owned().into();ٵA> // this yoke can be intermingled with actually-borrowed YokesA> let yoke: Yoke, ()> = Yoke::new_always_owned(owned);$<8B 8l.+ Obtain the yokeable out of a `Yoke`74 For most `Yoke` types this would be unsafe but it's=: fine for `Yoke` since there are no actual internalt referencesl»8B 83  868AC+;?@ֿ2ɞ)IF This can be paired with [`Yoke:: wrap_cart_in_option()`] to mix owned and borrowed data.XU If you do not wish to pair this with borrowed data, [`Yoke::new_always_owned()`] can74 be used to get a [`Yoke`] API on always-owned data.l\ܙŢ4AHE let yoke: Yoke, Option>> = Yoke::new_owned(owned);$<L8B 88ى1B? Obtain the yokeable out of a `Yoke>` if possible.HE If the cart is `None`, this returns `Ok`, but if the cart is `Some`,$! this returns `self` as an error.B 88H  88BDMORJG Converts a `Yoke>` to `Yoke>`96 for better niche optimization when stored as a field.t<-* let yoke: Yoke, Box>> =DA Yoke::attach_to_cart(vec![10, 20, 30].into(), |c| c.into());1. let yoke_option = yoke.wrap_cart_in_option();MJ let yoke_option_pointer = yoke_option.convert_cart_into_option_pointer();<# The niche improves stack sizes:<2/ use yoke::cartable_ptr::CartableOptionPointer; use std::rc::Rc;" // The data struct is 6 words: # #[derive(yoke::Yokeable)] # struct MyDataStruct<'a> {+( # _s: (usize, usize, usize, usize), # _p: &'a str,<ɤ(% const W: usize = size_of::();1. assert_eq!(W * 6, size_of::());OL // An enum containing the data struct with an `Option` cart is 8 words: enum StaticOrYoke1 {/, Static(&'static MyDataStruct<'static>),>; Yoke(Yoke, Option>>),,2/ assert_eq!(W * 8, size_of::());WT // When using `CartableOptionPointer``, we need only 7 words for the same behavior:ĵ enum StaticOrYoke2 {/ӺMJ Yoke(Yoke, CartableOptionPointer>>),,2/ assert_eq!(W * 7, size_of::());< B 88iW  8<>GI1QN Obtain the yokeable out of a `Yoke>` if possible.H$B 88h%DA This trait marks cart types that do not change source on cloningMJ This is conceptually similar to [`stable_deref_trait::CloneStableDeref`],OL however [`stable_deref_trait::CloneStableDeref`] is not (and should not) beZW implemented on [`Option`] (since it's not [`Deref`]). [`CloneableCart`] essentially isUR "if there _is_ data to borrow from here, cloning the cart gives you an additional handle to the same data".d This trait is safe to implement on `StableDeref` types which, once `Clone`d, point to the same underlying data and retain ownership. This trait can also be implemented on aggregates of such types like `Option` and `(T: CloneableCart, U: CloneableCart)`. Essentially, all data that could be referenced by a Yokeable (i.e. data that is referenced via a [`StableDeref`]) must retain the same0- pointer and ownership semantics once cloned.l(,-!9-9ɿ 4l92242  5zgd Clone requires that the cart type `C` derefs to the same address after it is cloned. This works for Rc, Arc, and &'a T.`] For other cart types, clone `.backing_cart()` and re-use `.attach_to_cart()`; however, doing63 so may lose mutations performed via `.with_mut()`._\ Cloning a `Yoke` is often a cheap operation requiring no heap allocations, in much the samea^ way that cloning an `Rc` is a cheap operation. However, if the `yokeable` contains owned dataA> (e.g., from `.with_mut()`), that data will need to be cloned.  88l8,8pr{}, 88B  88$+  88GIRTWT Allows one to "project" a yoke to perform a transformation on the data, potentiallyZW looking at a subfield, and producing a new yoke. This will move cart, and the providedRO transformation is only allowed to use data known to be borrowed from the cart.ā\Y If producing the new [`Yokeable`] `P` requires access to the cart in addition to the old_\ `Y`, then [`Yoke::map_with_cart`] can be used if the cart satisfies additional constraints.UR The callback takes an additional `PhantomData<&()>` parameter to anchor lifetimesQN (see [#86702](https://github.com/rust-lang/rust/issues/86702)) This parameter+( should just be ignored in the callback.PM This can be used, for example, to transform data from one format to another:΅<օŢ,PM fn slice(y: Yoke<&'static str, Rc<[u8]>>) -> Yoke<&'static [u8], Rc<[u8]>> {1. y.map_project(move |yk, _| yk.as_bytes()),<‡ʇ96 This can also be used to create a yoke for a subfield<!ˆʄڈŢ,*' // also safely implements Yokeable<'a>lj string_1: &'a str, string_2: &'a str,,䗊 fn map_project_string_1(*' bar: Yoke, Rc<[u8]>>,'$ ) -> Yoke<&'static str, Rc<[u8]>> {.+ bar.map_project(|bar, _| bar.string_1),ƋЋ,؋52 # unsafe impl<'a> Yokeable<'a> for Bar<'static> {  # type Output = Bar<'a>;1. # fn transform(&'a self) -> &'a Bar<'a> { # self\ # },/, # fn transform_owned(self) -> Bar<'a> {܍<9 # // covariant lifetime cast, can be done safely\,ĎΎ1. # unsafe fn make(from: Bar<'a>) -> Self {-* # unsafe { mem::transmute(from) }\,ƏЏ1. # fn transform_mut(&'a mut self, f: F)| # where85 # F: 'static + FnOnce(&'a mut Self::Output),\א # {0- # unsafe { f(mem::transmute(self)) }\<ɤ<\8Bĭ  ĭ˒#8!!!9o$z - 5#ĭӓ 88ĭϒFC This is similar to [`Yoke::map_project`], however it does not moveRO [`Self`] and instead clones the cart (only if the cart is a [`CloneableCart`])a^ This is a bit more efficient than cloning the [`Yoke`] and then calling [`Yoke::map_project`]IF because then it will not clone fields that are going to be discarded.ƚ 8B  l# 8!!!9o$z - 5כ#Ŝ 88$,ٚۛخTQ This is similar to [`Yoke::map_project`], however it can also bubble up an error from the callback.<Ţܡ&# # use std::str::{self, Utf8Error};,l fn slice()& y: Yoke<&'static [u8], Rc<[u8]>>,:7 ) -> Result>, Utf8Error> {@= y.try_map_project(move |bytes, _| str::from_utf8(bytes)),<9ˤ<Ӥߤ!ʄŢ&,*Ե bytes_1: &'a [u8],Ԧ,䅧*է:A> bar.try_map_project(|bar, _| str::from_utf8(bar.bytes_1)),ڨ,5 թ1\,/<\ȫ,ث1-\ʬ,ڬ1|8\0\<ɤ<̮|߮8B   ĭ#8!!!9o$z - 5ӯ#ÜĜŜƜǜȜ_wĭ& 88ĭFILOILׯشJG This is similar to [`Yoke::try_map_project`], however it does not moveRaIB ߷  lʸ# 8!!!9o$z - 5#ÜĜŜƜǜȜ_wҹ& 88$զ,طehknhkսPM This is similar to [`Yoke::map_project`], but it works around older versionsNK of Rust not being able to use `FnOnce` by using an explicit capture input.B? See [#1061](https://github.com/unicode-org/icu4x/issues/1061).Ŀ̿=: See the docs of [`Yoke::map_project`] for how this works.!88!!!9o$z - 5ĭBB  ĭ 88ĭFS^`Y[WT This is similar to [`Yoke::map_project_cloned`], but it works around older versionsN΅BDA See the docs of [`Yoke::map_project_cloned`] for how this works.( 8 8!!!9o$z - 5ĭBB,  ĭl 88ĭ$bnpdfhjTQ This is similar to [`Yoke::try_map_project`], but it works around older versionsN΅BA> See the docs of [`Yoke::try_map_project`] for how this works.%88!!!9o$z - 5ÜĜŜƜǜȜ_wĭBB   ĭ 88ĭʱձCbdfhjl[X This is similar to [`Yoke::try_map_project_cloned`], but it works around older versionsN΅BHE See the docs of [`Yoke::try_map_project_cloned`] for how this works., 8 8!!!9o$z - 5ÜĜŜƜǜȜ_wĭBB,   ĭl 88ĭ${}qsuwy{a  8\<8MOXZ\Y Allows one to produce a new yoke from both the cart and the old yoke. This will move the_\ cart, and the provided transformation is only allowed to use data known to be borrowed froml the cart.\Y If access to the old [`Yokeable`] `Y` is sufficient to produce the new [`Yokeable`] `P`,XU then [`Yoke::map_project`] should be preferred, as `map_with_cart` places additional constraints on the cart._\ This can be used, for example, to transform data between two formats, one of which containst more data:<!ʄŢ,\Y // Both structs have `first_line`, which won't need to be recomputed in `map_with_cart`.0- // They also safely implement `Yokeable<'a>` struct Foo<'a> {$! first_line: Option<&'a str>,,$# last_line: Option<&'a str>,, fn foo_to_bar()& foo: Yoke, Rc>,&# ) -> Yoke, Rc> {'$ foo.map_with_cart(|foo, cart| { Bar {+( first_line: foo.first_line,41 last_line: cart.lines().next_back(),l }Tק, fn bar_to_foo()& bar: Yoke, Rc>,&# ) -> Yoke, Rc> {" bar.map_project(|bar, _| { Foo {+( first_line: bar.first_line,lݥTק,,52 # unsafe impl<'a> Yokeable<'a> for Foo<'static> {  # type Output = Foo<'a>;1. # fn transform(&'a self) -> &'a Foo<'a> {\,/, # fn transform_owned(self) -> Foo<'a> {<\,1. # unsafe fn make(from: Foo<'a>) -> Self {-\,1|8\0\<ɤ,5 1\,/<\,1-\,1|8\0\<ɤ<l8B  ĭ#8 #رĭ< 88ĭ(ۃYV This is similar to [`Yoke::map_with_cart`], but it does not move [`Self`] and instead>; clones the cart (only if the cart is a [`CloneableCart`]).KH This is a bit more efficient than cloning the [`Yoke`] and then callingԅ\Y [`Yoke::map_with_cart`] because it will not clone fields that are going to be discarded.\[X then [`Yoke::map_project_cloned`] should be preferred, as `map_with_cart_cloned` places'$ additional constraints on the cart.B ͈ Ј# 8 #۸ܝlŊ< 88$ڈd,ƈ؎RO This is similar to [`Yoke::map_with_cart`], but it can also bubble up an errorʏҏ\UR then [`Yoke::try_map_project`] should be preferred, as `try_map_with_cart` places'<͑Ţ&,䷒ // Implements `Yokeable`ؒ+( type P<'a> = (&'a str, Option<&'a u8>);l)Г85 ) -> Result, Rc<[u8]>>, Utf8Error> {0- y.try_map_with_cart(move |bytes, cart| {”74 Ok((str::from_utf8(bytes)?, bytes.first()))Tק,<8B   •ĭ#8 #ÜĜŜƜǜȜ_wĭ&<җ 88ĭ!$'*-0ؠ]Z This is similar to [`Yoke::try_map_with_cart`], but it does not move [`Self`] and insteadܜ>Kϳ`] [`Yoke::try_map_with_cart`] because it will not clone fields that are going to be discarded.ܞ[X If access to the old [`Yokeable`] `Y` is sufficient to producethe new [`Yokeable`] `P`,ğ\Y then [`Yoke::try_map_project_cloned`] should be preferred, as `try_map_with_cart_cloned`.+ places additional constraints on the cart.ߠB  ς ɡl# 8 #ÜĜŜƜǜȜ_w&< 88$,@CFILO͡+  8857@BBPM Helper function allowing one to wrap the cart type `C` in an [`EitherCart`].JG This function wraps the cart into the `A` variant. To wrap it into the74 `B` variant, use [`Self::wrap_cart_in_either_b()`].'$ For an example, see [`EitherCart`].8ݖB  88(BPJG This function wraps the cart into the `B` variant. To wrap it into the74 `A` variant, use [`Self::wrap_cart_in_either_a()`].'8B  88a\Ȇ Ά5\ٻ ߻5\ω Չ5dD9\!9!̮+&_\ The `Yokeable<'a>` trait is implemented on the `'static` version of any zero-copy type; forHE example, `Cow<'static, T>` implements `Yokeable<'a>` (for all `'a`).| One can use_\ `Yokeable::Output` on this trait to obtain the "lifetime'd" value of the `Cow<'static, T>`,FC e.g. ` as Yokeable<'a>'>::Output` is `Cow<'a, T>`.OL A [`Yokeable`] type is essentially one with a covariant lifetime parameter,RO matched to the parameter in the trait definition. The trait allows one to cast1. the covariant lifetime to and from `'static`.a^ **Most of the time, if you need to implement [`Yokeable`], you should be able to use the safeC@ [`#[derive(Yokeable)]`](yoke_derive::Yokeable) custom derive.**RO While Rust does not yet have GAT syntax, for the purpose of this documentation OL we shall refer to "`Self` with a lifetime `'a`" with the syntax `Self<'a>`. GD Self<'static> is a stand-in for the HKT Self<'_>: lifetime -> type.  qn With this terminology, [`Yokeable`] exposes ways to cast between `Self<'static>` and `Self<'a>` generically. ]Z This is useful for turning covariant lifetimes to _dynamic_ lifetimes, where `'static` is *' used as a way to "erase" the lifetime. d   b_ This trait is safe to implement on types with a _covariant_ lifetime parameter, i.e. one where \Y [`Self::transform()`]'s body can simply be `{ self }`. This will occur when the lifetime da parameter is used within references, but not in the arguments of function pointers or in mutable;8 positions (either in `&mut` or via interior mutability)[X This trait must be implemented on the `'static` version of such a type, e.g. one shouldA> implement `Yokeable<'a>` (for all `'a`) on `Cow<'static, T>`.LI This trait is also safe to implement on types that do not borrow memory.QN There are further constraints on implementation safety on individual methods. # Implementation exampleWT Implementing this trait manually is unsafe. Where possible, you should use the safe_\ [`#[derive(Yokeable)]`](yoke_derive::Yokeable) custom derive instead. We include an exampleOL in case you have your own zero-copy abstractions you wish to make yokeable.\̛ # use yoke::Yokeable;ܵ # use std::{mem, ptr};Ê,30 unsafe impl<'a> Yokeable<'a> for Bar<'static> { type Output = Bar<'a>;/, fn transform(&'a self) -> &'a Bar<'a> {:7 // covariant lifetime cast, can be done safely selfL }-* fn transform_owned(self) -> Bar<'a> {:L/, unsafe fn make(from: Bar<'a>) -> Self {A> unsafe { mem::transmute::(from) }L/, fn transform_mut(&'a mut self, f: F)l where63 F: 'static + FnOnce(&'a mut Self::Output),L {NK unsafe { f(mem::transmute::<&mut Self, &mut Self::Output>(self)) }L,<D1<' 3,|SP This type MUST be `Self` with the `'static` replaced with `'a`, i.e. `Self<'a>`4+PM This method must cast `self` between `&'a Self<'static>` and `&'a Self<'a>`.ܤ # Implementation safetyRO If the invariants of [`Yokeable`] are being satisfied, the body of this methodXU should simply be `{ self }`, though it's acceptable to include additional assertions| if desired.L  B $")HE This method must cast `self` between `Self<'static>` and `Self<'a>`. ܚ   R!X|!|"B $"%+"?< This method can be used to cast away `Self<'a>`'s lifetime."d###VS The returned value must be destroyed before the data `from` was borrowing from is.#܁$$$RO A safe implementation of this method must be equivalent to a transmute between%" `Self<'a>` and `Self<'static>`$% $%K%XU This method must cast `self` between `&'a mut Self<'static>` and `&'a mut Self<'a>`,& and pass it to `f`.&&&'_\ A safe implementation of this method must be equivalent to a pointer cast/transmute between'@= `&mut Self<'a>` and `&mut Self<'static>` being passed to `f`(( # Why is this safe?((PM Typically covariant lifetimes become invariant when hidden behind an `&mut`,)LI which is why the implementation of this method cannot just be `f(self)`.)gd The reason behind this is that while _reading_ a covariant lifetime that has been cast to a shorter*XU one is always safe (this is roughly the definition of a covariant lifetime), writing+]Z may not necessarily be safe since you could write a smaller reference to it. For example,,c` the following code is unsound because it manages to stuff a `'a` lifetime into a `Cow<'static>`-- ```rust,compile_fail,E0521ܺ--- struct Foo {. str: String,. cow: Cow<'static, str>,,...&# fn unsound<'a>(foo: &'a mut Foo) {/ let a: &str = &foo.str;/=: foo.cow.transform_mut(|cow| *cow = Cow::Borrowed(a));,/`, it can only mutate it in a way that does1fc not insert additional references. For example, `F` may call `to_owned()` on a `Cow` and mutate it,2^[ but it cannot insert a new _borrowed_ reference because it has nowhere to borrow _from_ --3jg `f` does not contain any borrowed references, and while we give it `Self<'a>` (which contains borrowed42/ data), that borrowed data is known to be valid44ZW Note that the `for<'b>` is also necessary, otherwise the following code would compile:55556ʄ,66*67 num: u8,̜7 cow: Cow<'a, u8>,,777/, fn unsound<'a>(bar: &'a mut Bar<'static>) {8HE bar.transform_mut(move |bar| bar.cow = Cow::Borrowed(&bar.num));,8,8859 919\:,::/:<;\;,;;1<30 # let ret = mem::transmute_copy(&from);<  # mem::forget(from);< # ret\<,==1|==8\>>0\><>ɤ<>??YV which is unsound because `bar` could be moved later, and we do not want to be able to?! self-insert references to it.@@`] The `for<'b>` enforces this by stopping the author of the closure from matching up the input@IF `&'b Self::Output` lifetime with `'a` and borrowing directly from it.AA`] Thus the only types of mutations allowed are ones that move around already-borrowed data, orB introduce new owned data:B\BB̒CCCC,DDD fn sound(foo: &mut Foo) {DA> foo.cow.transform_mut(move |cow| cow.to_mut().push('a'));,D could be obtained from:FQN - a local variable: the compiler rejects the assignment because 'a certainlyF%" outlives local variables in f.GMJ - a field in its argument: because of the for<'b> bound, the call to `f`GPM must be valid for a particular 'b that is strictly shorter than 'a. Thus,H+( the compiler rejects the assignment.HEB - a reference field in Self<'a>: this does not extend the set ofIEB non-static lifetimes reachable from Self<'a>, so this is fine.JPM - one of f's captures: since F: 'static, the resulting reference must referJ to 'static data.J2/ - a static or `thread_local` variable: ditto.lK 5B KӍ` from a cart implementing `StableDeref` by zero-copy cloning=: the cart to `Y` and then yokeing that object to the cart.YV The type `Y` must implement [`ZeroFrom`]``. This trait is auto-implemented\Y on many common types and can be custom implemented or derived in order to make it easier to construct a `Yoke`.l Attach to a cart:<KH let yoke = Yoke::, String>::attach_to_zero_copy_cart( "demo".to_owned(),4   # assert_eq!("demo", yoke.get());<  88B 88 ԟ|\̎DI#GEB A type with similar semantics as `Option>` but with a niche.GGJG This type cannot be publicly constructed. To use this in a `Yoke`, seeH/, [`Yoke::convert_cart_into_option_pointer`].HH]Z [`Yoke::convert_cart_into_option_pointer`]: crate::Yoke::convert_cart_into_option_pointerI JJ2(()+L,LB̮LLLC g2JgC 2g   2 ggg cgEcثq1ȡDBI 2  ܜRO A cart that can be one type or the other. Enables ergonomic polymorphic carts.TQ `EitherCart` enables yokes originating from different data sources and thereforeUR having different cart types to be merged into the same yoke type, but still being85 able to recover the original cart type if necessary.OL All relevant Cart traits are implemented for `EitherCart`, and carts can be&# safely wrapped in an `EitherCart`.EB Also see [`Yoke::erase_box_cart()`](crate::Yoke::erase_box_cart).t<ʶ! use yoke::either::EitherCart;)& let y1: Yoke<&'static str, Rc> =OL Yoke::attach_to_zero_copy_cart("reference counted hello world".into());^[ let y2: Yoke<&'static str, &str> = Yoke::attach_to_zero_copy_cart("borrowed hello world");  MJ type CombinedYoke<'a> = Yoke<&'static str, EitherCart, &'a str>>;  QN // Both yokes can be combined into a single yoke type despite different carts 63 let y3: CombinedYoke = y1.wrap_cart_in_either_a(); 63 let y4: CombinedYoke = y2.wrap_cart_in_either_b();  ;8 assert_eq!(*y3.get(), "reference counted hello world"); 2/ assert_eq!(*y4.get(), "borrowed hello world");  QN // The resulting yoke is cloneable if both cart types implement CloneableCart  let y5 = y4.clone(); 2/ assert_eq!(*y5.get(), "borrowed hello world");< T  3JĪ33B33BJLOQ 3333B3   33  33B3+   wv3 3 3++ 33B  33+*-!  VU33 33 3*-!  yk3 *-*- 3 3B  33*- *- 1"  3 3 3 1 1 1 1 35B  33 1O1#  g3 g3 3gO1O1 3 ggg cgEcثq1ȡDB  33O1O1$5X05$H 5 5B  (x5B :* 5 v2;th 5x5Bxx8#x $#x5 x ;oq$5X05$H 5 5B  (x5B <* 5 v=th 5x5B8#x $#x5 x =mo$5X05$H 5 5B  (x5B >* 5 v?th 5x5B8#x $#x5 x ?mo$5X05$H 5 5B  (x5B @* 5 v@th 5x5B8#x $#x5 x Amo$ 5X05$H 5 5B  (x5B hB* 5 vBth 5x5B8#x $#x5 x mCmo$ 5X05$H 5 5B  (x5B ND* 5 vDth 5x5B8#x $#x5 x SEmo$ 5X05$H 5 5B  (x5B 4F* 5 vFth 5x5B8#x $#x5 x 9Gmo$ 5X05$H 5 5B  (x5B H* 5 v{Hth 5x5B8#x $#x5 x Imo$ 6X06$H 6 6B  (x6B J* 6 vaJth 6x5B8#x $#x5 x Kmo $6 X 0 6!$H! 6 6B!  !!(x!6B K!* !6 vGL!th! 6x5B!8!#x !$#x5! x !Lmo!"$6"X"0"6#$H# 6 6B#  ##(x#6B M#* #6 v-N#th# 6x5B#8##x #$#xȆ5# x #Nmo#$$6$X$0$6%$H% 6 6B%  %%(x%6݈B O%* %݈6 vP%th% 6x5B%8%#x ݈%$#x5% x %Pmo%&$6&X&0&6'$H' 6 6B'  ''(x'6B Q'* '6 vQ'th' 6x5B'8'#x '$#x5' x 'Rmo'($(X(0()$H)  B)  ))(x)B {S)* ) vS)th) x5B)8)#x )$#x5) x )}Tmo)*$*X*0*+$H+  B+  ++(x+̖B [U+* +̖ vU+th+ x5B+8+#x ̖+$#x5+ x +]Vmo+,*H, 6 6Bdd 2 ,,(x,6Bdd 2X,* ,6dd 2[,th, 65Bdd,Ӎ8,# ,$#ۜ5, 2 ,\su,1*H1 7 7Bii 77 11(x17Bii 77P_1* 17ii 77a1th1 75Bii1ٔ81# 1$# 51 77 1Jcvx16*H6 7 7Bpp 2 66(x67Bpp 2e6* 67pp 2.h6th6 75Bpp6ٔ86# 6$#56 2 6iy{6/5#55# #'##]#q,#+#+# *#(#(#O1#$##n##+(#%###:!###S###l### #< ### %#%## (#(## *## ,## .##X#!NKhttps://docs.rs/zerovecBoxalloc::boxed::Box Cow<'a, str>alloc::borrow::Cow alloc::borrowpstd::sync::Arc std::sync OptionZeroVec֦.get() YokeArc֧ alloc::rc֦ Yoke::getRcҨ֧ř alloc::rc::Rc alloc::boxedҨRc<[u8]>Ω Yoke::get()Ωpêpê-std::ptr::read_unalignedstd::ptrSelf::into_rawSelf::drop_raw&Yoke::convert_cart_into_option_pointer-crate::Yoke::convert_cart_into_option_pointer crate::Yoke#ƽܫ׬#ƽܫ׬ƽ#Yoke::erase_box_cart()crate::Yoke::erase_box_cartê.map_project()Yoke::try_map_with_cartSelf::wrap_cart_in_either_b()Yoke::into_backing_cartYoke::with_mut_returnYoke::new_always_owned()_Yoke::attach_to_cart()ƽYoke::attach_to_cartYoke::try_map_project_clonedYoke::try_attach_to_cart_badlyڰYoke:: wrap_cart_in_option_Yoke::map_project_clonedsŲ0https://github.com/unicode-org/icu4x/issues/1061s Yoke::try_attach_to_cart_badly()Yoke:: wrap_cart_in_option()PŲ#1061Ƴs"Yoke::attach_to_cart_badlyYoke::new_ownedYoke::try_map_projectƳ.https://github.com/rust-lang/rust/issues/86702Yoke::attach_to_cart_badly()Yoke::new_owned()#86702Self::wrap_cart_in_either_aYoke::try_attach_to_cartYoke::with_mutYoke::map_with_cart#ķYokeable::transform_mut$stable_deref_trait::CloneStableDerefYoke::map_project()#Self::wrap_cart_in_either_a()Yoke::try_attach_to_cart()ķř#Yoke::map_projectҹSelf::wrap_cart_in_either_b#Yokeable::transform_mut()Yoke::new_always_ownedêҹܻêֱƽڰܻ_ƽֱSelf::transform#[derive(Yokeable)]ܻyoke_derive::YokeablePSelf::transform()ȽܻܽȽܻܽ 3 P  ####!!!PQPPQ P  ####!!!PQPPQ"P  ####!!!PQPPQ"P  ####!!!PQPPQP  ####!!!PQPPQ CartableOptionPointerinner _cartable BA@assertion failed: size_of::() == size_of::()@YokeyokeablecartXvw1p3'L?1awpҞlZ1UM5]$x9NPq& 0 =;1]-c`PY'jqKx LΆѧmF HtRNWX E^Z$ʽv:Bb.\)>&Y  645mQZ6E`vIŖdULٸ!1 (@y3/֫ gHصP?ds9"/D$DOd2Hpx/R <^VMbEo~ .eG̈[!)T]LgV6+.ͼOc9~/AB5N==}\ۓOϳ;R@ ei+=yb#v.<7lɺkJ!鏧{)g,#tb6csS,L=ۂY4K4EpReL ,A- z K+>*IwUPqNH!lu`oړ\\~`nrlWOԩo1Gkg~IDD7ehS4,-EK#AHЧq#8 ,> A"Ao7QNϷ oBVh 1zsM^Ʃs0*v ETgUZݧ/M@luVL8?hk<)le t-TW&+3ﲛO=#҆JyS\<Х(/ĥ9@=j9^"='?߹I‡wCQTea$&JEHx 47KuдgVWwex")[dO ,9Dzs7UdcRb^Dn?%v!ضMh:/ Dy8gxU3%LDxG=D(%.X$-ܻ^l%c05\.< JQx{{$(\%E`N|:_/{`yRɥCꤱ:_PSW% f{'[Ѿd5ĸy!QѳfԜb1y"Ū ͬwyvRc6 I[nv< H傧|§,cPkoZn2m:ԶA رb}Ih}_=g4S ?`gf *fhcLx/8)("!ZAH, Ĝ5$QjC&i7q\Hm :L-G8 Ѽ)ʭ!E->DV/ ]Vnk,hQnp&tdA+"2z1c fbRٿ ؈ ڶMxtʘ&fKKsiW_~ ¶yR\hMsy#t\D<;0^Lp4eTɯ0_c:yS}S338 ߰0jq2/+$W'~MӀB@ҊQt^p#W 48IvTm`0'!Wq jI$Dꏇ}>KELxR|z%T 듓(t̾b$Tq.9nTz$3spkZ x=c(i]N؈$Yey.5#gcv6du*OcKGQUrɸR3 /Z _"D<ы[ -)A*D;8R}ɚ>L`i#D˦U.{VB}Ӥ@K֍CTC:k8c 4yOj'p"=:ƧO~NOv7$܎ ݡ^G)gum}"64G۬m{xLVS)ϽcTl?DlO8&s E7Yts7fH$0?wL9bj)r:-ԥI?4VtܾMvRC+*%ڵ=shҌ _Su]*v4Q齟DYl3 na"Խb/7Pr6 `2ߒž̭Y1`M sȍ B;So_g4<|opl}'ȢԹߣdoEmK}ЗrXdn@r\s{"]a\šDlP ^/&r_|ɨb1PV 4`~I|4w`D?1N!r3l$=z18 ND?\%F`*]yS2)޺>OP(n(h5 j(~r{٤R;O+iB;_ N?aA|cՐڃv`p9 sեy5o~â*mH"1z ۇ{{g:<`_CVĄdMf_-$4r>e12X='R4KU`;v561O*\SGN5b:l-d˔Bn `E^=FNF=d %ǂ{>^ ,NDU-Ï#L%<륹5@Y2_a`աq34=ϡ7y*%K\X cz ]Wn ƀSWimhh^k76.˓u#3>8։H1^FxLE> ܅<%z"et;%p]bۀy6ZK`+p #vyI j@,U"t9B k5 k\Bdlq&5U9fk2ճ52H4"oB <8!w_sbmZ  \KD F6{vk?yY^ e}rA8z데I]KYD+ }% ?yXbtete?@ >6u|(e#  p ; u z 8\%B$xYDJsIb'q+ 1;GE}>\&).4;AGMSY`g8_{Z~7Q ~1HDx&(*m++C011t8>?| JMDNN9RgSSVWp.X_A`aeeMf` fijAju;yg Yd^ 2 =GNL9vd /s-G5hKQW^dlC|e$3x[W Lh'qF1zEa j?*s}>Zc8#lv 7S\1eo/J O # {   R  o  " n IT3G+o{(dek GT5P6#%+NSEX`ee/fYfki]j/OI oV _XQJ;                    +++                                                                     ))                                      *n*)I5O$P,<yMuC&5IBbcrO"I%')*/a1D8>ILN R:SVW_`Keitnw}`׃IٗM~\hШh2.1_M5Mx|8l$-Q@J'0Jz9C )Cs2|<"<l+u5~4c h   # k    ;  bmL ` _l6pv 3zW!=u s HU@DUbo8E]"`m&{,6B(.;Ax,2:X "&,06=CIOU[b:GMZw/<BOU y &,2&3@FLy &,"/5B_&l&r&((((**U+b+h+++++:0>01n8o?|??ZJaJnJuJtM{MMMM>NNNN3RaSSSSSVWIXVX]XjX_`'`.`;` aeee0f7fGfZfwiiiiiivjjjjuuuuuxxxxxxv%4CRY`܄&*7DKR‰ω܉<IP]ژu|$+ )07mzƨݨ CI/5q_))B0 crGMSY`f%28>xUb#0R{WfuXT{@Gb!k,9@+t~9@[d%29$mxw 29T]+2fq~p+2M V$+~_jw~i#*D I    o v   L  U b i   h /<CN&-A#)/5;AGMSY_ekqw} %+28j ap%117  8w$JWdu:Ibq+"1,0?E!04>^ ).4;AGMSY`<KO_{1@DSZ*07(5DJ $*1$37%a&p&z'((()*n*W+f++++/<0I1+8>q?~?uI_JcJsJrLyM}MMMMNNQ!SSSSgVWKX[X_Xf_`,`0``Fee5fNRܘ4z~e")C.5oO˨Gd3߼-G5htKQW^d'6<5tWe%5U~Zi ELh'q.>1z>Ea j'7*sz}7>Zc 0#lsv 07S\)el|o(/J O   t {   R  W g o  " n 1AIT+3G!&,28>DJPV\bhntz"(/5;)*Fi'2\Hb-c ?q+Wa$R(y"_l BWw<j~#r [t%8R)KDWo9L9[#0=w[,?%i&'(()++_+++++01X8>y??IkJLMM(N[NNRNSSSSVWXSXgX__$`8```eeefDfUfiiii)jjjtuuwxx'~1@Ou4AJ̉ىFZƟ &cAwè٨VD &;{ ;J|"/a_ -B =cr;>scY[ T6[^ f\TM/T W_UMF(MP{XNF?!FItQG>2   8   6 ~  _   O  92#|"3c*T6Z|%[7^DyUzLLYf<Od )dvf=I2J#C>Qf3FNy*7SN u&9%c&'(()+Y+o+++01O8>s??IeJLMMNFNNRESiSSSVWWMXaX__`2``Leeee>fOfh{iiijzjjtuuwxx}|t+:IN.;ƉӉӋŌ@Tޘ`p ?)quӨiM; 2x cAvn)XzY'9w]l|-_0[eUARK0HUXDKD)AN|Q=D=":GuJ6=63@nC/5) {  %   - u  Y   G  3*twX`f1gC/ieE,R[N vV8Ot!`#`B&()8++001]8O?6JLM-NN$RSSSVWBX_``e-fWfiii[juxRV-M̠ɤXۨ [In@MORfGGmT@Cxh `Y]cbkY RV\[dRKO UT]KDHNMVC7  :   ;  8   S 6&,JPQ-=DsP#J%')*/b1E8>ILN R;SVW_`itow}aJN]i3/`N6Ny}m%.AK(1{:D!*t3}=#m,v6d  i  $ l    <  cnMa-KQS/ >EuR%L%')*/d1G8>ILN R%n-x7e! k  % m    >  f!rPet5;<(/^;5%~')r*/M108>zIwLMQ&SlVWl_`iqtZw}LÃ5ۊŗ9jHTK9!l9|hXm,v6f%o/x _h(q{Xa!jtO T   W  t  ' s N Y8L}Mg}S]gqu *:JZjzkQc TanDl%':+FY;N%2?.Ak&((a+++{??mJMMNSSUXiX&`:`}eeFfiijjuuxx3BQ6CΉۉH\  (yŨ( ~$1a"/et81*}#v a ;%@BK T##'U()N346288o9iknoprscv\|!}+~gVA_ۛ.Tv@O8Rl*΢ aжo& +(-0M1G::;`;<<>$??D@@AA*BBBCDqDDEEWFFwGG=HH]II#JJCKK LkL)MMMQNOtOO7PPZQQRR?SSSTU~UUVWYt\*]]_bc)d@fi5! @I #'S()}+45088m9E:knoprsavZ|})~eT}?]ٛ,Rt>M6P(ΠΫ _дm$ҴR#&-0K1L3:;^;<}<<@==_>>"??B@@AA(BBBCDoDDEEUFFuGG;HH[II!JJAKKLiL'MMMON OrOO5PPXQQRR=SSSTU|UUVWYr\(]]_b~c'd>f iiAJ #'T()~+46188n9F:knoprsbv[| }*~fU~@^ڛ-Su?N7Q k)Ρά `еn%ҵS# ]'-0L1M3:;_;<~<>#??C@@AA)BBBCDpDDEEVFFvGGSSSTU}UUVWYs\)]]_bc(d?fiiVcg_hntP6l9}kkQ&(*G+301h8b?KJeM8N,R[SVW_aiuximfgjX!)]dqKNsd#npv ]gio V`bhOY[aB   F  F   a  G :6Rd~e(h/z\BxJsb' ;G}\~Q~m+DNgSW_DeeeMfhjÌ=blr3z]YF?81# -. ! !(7ERVpz  $+2FTX_fjqx| '+/37;?X_lpw~7;BIRY]dmt} $).38=BGLX`hp  (08=EMU]ejrz & . N V ^ c k s {    4 < D L T o t |   = B J R Z b w |    5 B J R Z b y  ( 0 8 h p x !)19AINV^f{ @HPX`hpu})@Laiqv~  %*/49AIQYy~ "*/7;CKSW_gks{ #+3;CGOW_gow#+3;CKSW_gow#+3;CKS[cgow'/3;CKS[cksw$+3;BIPV\bipw~ ")07>ELSZaho01l RW% +++++++NNSSGX`mimjnjojpjqjrjsjtj789:߷Y^chmKq %*insx}#bglqv [`ejo TY^ch E J O T Y  7Tv!K# ! #!!qGT\*%!+NSHX`ee/fYfriuj;rPvV/({!tm^  )E6,"/>2 D !9%=(C+I .<1 B-5 H$'A*G28-0@3 F#7;&?##  a\Xvw\H$Nu #Xvw>@YXv< b\Xvw? * a\Xvwg|p,M =$crate::assert_nec]]panic_internalsXvw^ܫ9} b\Xvw]Ȅ$crate::assert62T]]core_intrinsics generic_assert_internalsXvwXֹO  a\Xvw &|Np yb\Xvw,#Xvws峪 ld  /a\Xvw3$]#Xvw3|F *b\Xvwʢs ( a\XvwRu&% b\Xvw *%X   a\Xvw~  b\Xvwv_] ^#Xvw&bE  a\Xvwڹ o #Xvw3i &]Xvw5A & a\Xvw/er5q,I}  fmt_helpers_for_deriveggXvwx7&O #XvwV*IJ eb\Xvwwg_1=͜S]Xvwݶ(q,  ă ggXvw/ b\Xvw}'_Cw#Xvw)2'i  a\XvweW.%  c\Xvwv 8%#Xvw'R3 $ 7a\Xvw"Px,c#Xvwn4 2b\Xvw3۬9!^> 3-T]x   Xvw ʍw$~ ei_ derive_eq_internalsXvw,GH b\XvwOU_N 97T]2   Xvw$"  a\Xvw#K ܡc\Xvwuk-&U(a #XvwihYT%IPXvwۏ " ha\Xvw Z9 X ֘#Xvw sfR eb\Xvw׻L O_ XvwQ56+#ۍ b\Xvw 1  P a\Xvw|Ayc ܣc\XvwO#Xvw7ͤ8## XvwXW   a\Xvw?16ˆC+#Xvw;uf-  b\Xvw2A,=Xvw|a>&e, }V derive_clone_copy_internalsXvwkφ  b\XvwRVu)6=EXvwR  g a\XvwUX 5 b\Xvw_3G^ #Xvw0t^j7Jdebug_assert_neP1b]XvwM/!RI=]<VI<<<i<-= =<<<q<9==<<<}<U<!=<<<<e<)==<<<m<5= =<<<y<Q<=<<a<=<<1=<<u<===<<<<Y<%=<<<A=9GEZIOA?=G(FC(BD@q>mHFDB@HSF`DBo@?HFEC@?e=`GECA@=G DSB>HDB@g?#I GqEoC A?=GECAU=PGEIpA@=GCFDCB_@>HFDB@W?IFaE_CAa>]HzFDB@,?HF6E1CA?=|GECA4@ >HPDyB?H EC@?BI)GEC?A?=GFCBhODHT sFw,jqKx #K* gdըPeD;8Ҍ _Pڔ7X& 0 =; Hiv %58 'n(h5.tO \'W 4 @ " %+(A2>^ ,?bmZ gDOdХ(xf{'E-> ^f{ Q1·/yI Z٦"pX,_-$4r13%LD3'L?1^#'FQo(p7e.j'p"63j+p=:o&/1΃6tnF6i8&sCG>8 N5b:l8F=d=n?ʊ (@M@luo:ԶA A?LTTDX<6E` E7D [FkJEHx+>*I!ZAH, 2IѨ0LزO:LMhM McRb^@R|j8VL8pX)CۂY4K8(%.X$N(]^jY^ el{"]a\cUbׁQsbd:&N?aA|%jl`8IvTm`0'EGmD7&rMQo(dn@r\sb\UEr{ΗUth 3ou^[nv<Qx{{$(˗̾b$T<7l2SKф] [ѾdԢNDU-@}Ӥ@Ks6otsB5N=+fhcey.rɸ sȍ Zj8}1WUP ܌ BoEǔG4 sQ"a$&^Lb?2El5#gcy3/@=jz֯( *R1DDYnͩ8j[/ĥ9yk76M3@0Z$ʽv6Ddc05\.<eL ,:Y2C;0E`*Ȩ C9^"{$lPeɨb1ht{<-|.hv0g-NTz$3\%~p14),CFxLERŽHFWH338 ߰*v4RQ@VB6sS؈iB;#W% 1p0_7Fgmt# 2X='3YD+pDHfء> ܅S Acn2mЮ4w`kWOԩY4EpR99^!toS})@)>&Y $܎:*0 у`wF gj \KD h%v!؋'Ȣ^|&l%T]L':p!K#A`r3l$=z1mD?\%F }% q)(^zS2)޺fԜb1y"B33e}*O4M2@2C&i7q\H}rA8m89!Mh:/p9 s(y!\[\%t"`*]yY1`MY:<`.Mb ͼOc)ߣd_Kg%H'kbMbEo#"Ao7dS%p7hMsy#?uJ;v55Xvwͬwyv$0?wLG~ !鏧{)4QXRҞlZ1 jI$ ;G)gum}<~~â*m*8c 4g4"1z ,?yXr.9nաEP?ds9u<}v`'xG=DΆѧm }Ih3AYΐ}_=UCqccՐ&%<륹5@BvRC+MsS,L=7!Wq8։H1P L  JSu]Q ݡ^;UM5] KE1T"R5 -gf *uC{@,U"\4穜Nr}L2>wUTQNfyS\v.˓N]KodDȺr:-Ii+=0-E_ړW^e3 0h oBVgö6vm`.5ĸ@ e/iA n^Sm :L k\Bd_v:Bb ,>b"ԽbU]gɼ8 ѼߒžX{vjz1[!)&u#3O("yJ)R"*vgV6+.(a\-VWjq2/+m80 `1Ȗ^2fp4enI5A?4VtKճ52H4ck"8:e\8r48,"D<_g4<\4OBoSCꤞCTC:kv ETlFKG7fHFfKKm{xLVS>x9NPq645mQZ/7Pr6Vp:Q*O% VN1`Y&-_uspkZ ̺[r+yRZךM$(]:$ \\~`nrlX `2Wtb6c6_a`D$Qj]Vnk2Hp PqNHUnpF HtRNWdu*#vY,=\w&KڶMxt¶yR\]wdLxR|z|V~ $ j(~<bۀyVK=} 8l3 naTN|`~I|j=j:_tUߌMB)T2fbRٿ-Ru;%p]U#҆JuڡgUm7뾚 /R|^!hQ齟DYSg1 n6Y<%z"etT6ZKWY>O5<^V"Zݧ/n"oB )kZ$)Ͻ?C2)9DDV/PkoZA+"2zܾMLvIŖdU %ǂ{><"@3R}ɚ>Ù Kwq!!6Ȓc9@j-%T we)*I@WR7Mj@ҊQRc6 I$=F,@ Tɯr)hh^LO~N8ﲛO=t˔Bn:yNz_ $<w*‡wC}4 Yjy-A-;/?[]d `+p XON"h 1h z <X E^^QNXu KIawp]WnJ.\t\D<R3 /t5 Ve trX/9 k5^g,#5qÏ#LA61O6رbѰX\d1_3o1GZ podMf0\X cHt^p#VWwZ _L`i#f5^"3I2H8!weN؈$Y1% -TW&+3s:)OW$0*%Nex")[dTy!'#m,Y<&C§,c1]-c f_-#+}l)}#1ߕL"64G۬=ix 8"٤R;O+"?hk<)lq`E^=FN<q34=ϡ7F='?߹I|B;So[6CW<@ Dyr EK$JnEsS-GH+~ Ir?(J;RW'~M۩NR:_PSQUn&RAx>OP(*\SGN7 ƀSWimKPV 4isiW__CVĄ/sCYsw]]hG:_/{8,cu.eG%QTe~>e12fk2b Ol?|opl}]oEmK}`եy5o)mp!HЧq#8a/&r_|gYtsE[\s8Ӳlr_sv.w1Lx/8) ZYp3QMz>r{<ڣۇ{{g-c:yS}S_sfj$skg~[mխ{9Tl?DlA ؈ ^л鏇bC` Ū &td=shOzsiI{9Dzs7U-d9!lu`oVD7eh])ʭ!S ?`k?yk4{ 8gxU̟k!]r mڹ4g [ #OcKGz I=:Ƨ7yb#v.1(t^Ʃs0*k.c C玍9~/A*Oϳ;R.}#@V"$[xŘۓ-yӛ\FhO]G٧֫ @כ)^lf+\y8 y*%KG-ܻ^ɺkJ3')spw(/ 47KD GN傧|gHصiG1"/D$ S4,^QxTTD^/,$~}ByIYZHNnTNF` a#2 N7i9'de:L[N5V%he&/%D52a@>P`U /\Re*6jk7yRLu}>OetO&6i5u Heanq_ VB]!OU(d3 yhHLXjo9QH|3rF$RB hST)7CG05lj^|Avp|/]> $ y}V.P)^U YBUA op $FCzj%O;w)b>QqU,QXV0"W4gtm Mf]%G U= ux4 pS[{5`LzT$Kd `cvi whrBE_*g.ry2]wyl 4+|z\ &yEsd^fEh ZQ|qC lvit:2qUh)R5*Hu)8C/M]k 60LM $X+uw:.2OTjW~0>>/UCr_:.mY_4,H:%R+`iu{ICGfJgf~|*= G;v1KIR $ WG?VxHa!Upy/{A,a8PNn:_ ^h@B`f1W;,C~m2}DtJoD&VVX6'$7 PJ)ARi?vxm{S6[LBZGt:fOOD]>hzl>i A( m3a_HN6]Z249A*m740sw*5n3|KRK@!F )+bI CSO.x@/%9DLhKZIMnQxTTD^/,$~}P/root/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/yoke-0.8.3/src/lib.rsE/root/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/yoke-0.8.3P/root/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/yoke-0.8.3/src/lib.rs Lnz"\BEyyEE/?J@,4; 5<9-J@ / J(]Ya_> O>R=Q'+,DE7.NF1 9FF) 3dG9 3 2I6R ( 7'$$0 -6T4C 7\4R 7 Y!\I)B`)5 ZVM)8!+ ENP[V 1).2/3O=PE6($ha7`bBE05'/^F*% ']!!*$!!$:$!!'$.\_WadZV0U  U6 > & / !/,3  :%6 4A 62 6=5 87 !)!*N/Ya=' KWfNL !0!*,/Ya='% Y + .?E > &+ / !/?F  :%6 4A 62 6=5 I !)!5O/Ya=' OWfN^ !0!5-/Ya='% USGB4)!* !: /Ya=' \SGIB0!* !5/Ya='% YSGF';)!5 !: /Ya=' `SGM'I0!5 !6/Ya='% 9#ada]!d & a5) )( .+,09 .+'0  :%6 4A 62 6=5 :%6 4A 62 6=5 89 !)&*': /Ya=' ^CPaa`,N !0&*'2/Ya='% WaZ, + !0.=5< K !)&5': /Ya=' bCPe`a3` !0&5'3/Ya='% C<ILPJM3I06(FDNTD7-57 :Q<R=ILPJM3J16)HDPTF7.77 L%&^Z_`_Y=^>S#Y]C%"&#aca]M ZS)i3h7"+a@;6!2 0= 24! 29 1 ,Z *+"-OJ*+"-QJ %-'.OQ"-'.QT"_aD ".;"a_b"2VZg&# "2?#C$NH0& c\$7*'G+'O*'*C44 A&( /#"#//&&i)'N_qU/root/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/yoke-0.8.3/src/yokeable.rsE/root/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/yoke-0.8.3U/root/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/yoke-0.8.3/src/yokeable.rs Ozĕo hhEf3Q[fl)1. *G.US^43Z=16(ZA12F zJ\, jmH6 ArۘVX/root/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/yoke-0.8.3/src/macro_impls.rsE/root/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/yoke-0.8.3X/root/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/yoke-0.8.3/src/macro_impls.rs Y!uOnhyE糈R/root/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/yoke-0.8.3/src/utils.rsE/root/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/yoke-0.8.3R/root/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/yoke-0.8.3/src/utils.rs CV>"X.ZSE