! / 0 0 0 0 8 ` // 66 ` overload-2b65450f9f69567a.overload.58b52e15deeee381-cgu.0.rcgu.o/ lib.rmeta/ 0 0 0 644 30664 ` ELF>Hv@@GNUюrustt≥#rustc 1.72.0 (5680fa18f 2023-08-23)аТ ╘}Х╗ч╠ґиЙL{Г╡б:-8f88c761e33f2651аП╙≤┬Пу├МQШк4⌠≥▒-46a989d0e2cef827а╨eлЖ╨$╗и⌡DЦР╔pТ>-b114db70ea0690b1аrustc_std_workspace_coreаж ые╚├uщ© ░sR-13da980d6c74fec5а·▐YnFmЙ▀ЯZУэ²г--649be05783c8912eа╣Юp≈вWі┌╗д╙9/-f002c8f83a289c4bа▐& cД~~ХШ*дҐVaВ-682387162b570769аcfg_ifає╩Къz≥Я$цkdgK!-ш-05a2cedbb78c1d4fаminiz_oxideа²√Pnz╗Щn ▒б)┌Тm-9c3df673b2797081аadlerаA%─щlЄonЄ 2-c6afbee8d1102512а hashbrownаР├8ї⌡К©*И┌р^о|щ -356231f77d1e268aаrustc_std_workspace_allocаТL╙йБ%┴ЬgqGл-80ed5799bf463787а std_detectаОa▄^Є╒┬═фЇцc ╚О-1bccb7a942e1b311аrustc_demangleаюkе≈ц,ёN/ST%L)Е-bc6864da821ce9a2а addr2lineа2х┌Щ']┬5рчЕ1≥:.-4930b3dc482158f7аgimliа~2)яF2÷5шк╪▓-65bea4bb6af40828аobjectа┼^]ЎUфЬ─VС▐W╞-919f89587cbed68dаmemchrаЬkЯ/√Щ┘ЁY╞O▒+їо-c6624cb4360306cdа▄B║hnge]▒,Q■ЗА╣-f9018f9cee1cc5ffаТ unaryа_overload_unaryа_overload_unary_internalа assignmentа_overload_assignmentа_overload_assignment_internalаbinaryа _overload_binaryа _overload_binary_internalаoverloadа Т э@Р║╒@ҐіН@ ┘ Н╔ ÷@⌡O3 Provides a macro to simplify operator overloading.а6 а7 To use, include the following:а<" ```а_ extern crate overload;аg use overload::overload;а┌A use std::ops; // <- don't forget this or you'll get nasty errorsа·DЄЦЧ К # IntroductionаПЧ ┐3 Suppose we have the following `struct` definition:а┬6 ``` а© #[derive(PartialEq, Debug)]ах struct Val {аХ v: i32аЫ }а┬Є▌0 We can overload the addition of `Val`s like so:а√3Єй # extern crate overload;ар # use overload::overload;аО # use std::ops;а█ # #[derive(PartialEq, Debug)]а║! # struct Val {ац # v: i32аж # }аЕ@ overload!((a: Val) + (b: Val) -> Val { Val { v: a.v + b.v } });аМCЄ╠3 The macro call above generates the following code:а╧6 ```ignoreаП impl ops::Add for Val {аЧ type Output = Val;а÷+ fn add(self, b: Val) -> Self::Output {а╨. let a = self;аИ Val { v: a.v + b.v }а┐ }ає ҐўЄЄ We are now able to add `Val`s:а╪"Єъ÷Гд└Й╒├І!╟ькКБЗB # overload!((a: Val) + (b: Val) -> Val { Val { v: a.v + b.v } });а┌ E+ assert_eq!(Val{v:3} + Val{v:5}, Val{v:8});ах .ЄВ Ч Ъ # Owned and borrowed typesа└ Ч ё T If we also wanted to overload addition for the borrowed type `&Val` we could write:а╗ WЄ─÷┬д╔Йц├в!╟Ык▄Б⌡B overload!((a: &Val) + (b: &Val) -> Val { Val { v: a.v + b.v } });аёEЄИN We might also want to overload addition between the owned and borrowed types:аЯQЄц ÷к дХ Й├├ !╟╪коБчA overload!((a: Val) + (b: &Val) -> Val { Val { v: a.v + b.v } });аФDA overload!((a: &Val) + (b: Val) -> Val { Val { v: a.v + b.v } });а╚DЄП> Let's see how we can write these combinations more concisely.аЬAЧ ╨r We can include a `?` in front of a type to indicate that it should stand in for both the owned and borrowed type.а©uЧ ╣├ To overload addition for all four combinations between `Val` and `&Val` we can therefore simply include a `?` in front of both types:а╨┴Єд÷лдИЙ┤├⌡!╟ҐкпБъB overload!((a: ?Val) + (b: ?Val) -> Val { Val { v: a.v + b.v } });аГEЄґй╣6┴Л ÷З х⌡КІ.╒ЕдЪ М═ Ґ╙Ч ╟ impl ops::Add<&Val> for Val {а╣!хв, fn add(self, b: &Val) -> Self::Output {аР/╒╒д╪ Мщ ҐГЧ М impl ops::Add for &Val {аР!х■К╞.╒чдЬ М≥ ҐёЧ ╘ impl ops::Add<&Val> for &Val {аў"хях!Л/╒°дІ Мв ҐАт Г> We are now able to add `Val`s and `&Val`s in any combination:аПAЄ╡÷╨двЙУ├┴!╟╚кЎБмD # overload!((a: ?Val) + (b: ?Val) -> Val { Val { v: a.v + b.v } });ауGП²., assert_eq!(Val{v:3} + &Val{v:5}, Val{v:8});ал/, assert_eq!(&Val{v:3} + Val{v:5}, Val{v:8});аЭ/- assert_eq!(&Val{v:3} + &Val{v:5}, Val{v:8});а╛0ЄщЕ # Binary operatorsаИЧ ─] The general syntax to overload a binary operator between types `` and `` is:а┘`┴Ф X overload!((: ) (: ) -> { /*body*/ });аТ[Єп [ Inside the body you can use `` and `` freely to perform any computation.аь ^Ч Ї!o The last line of the body needs to be an expression (i.e. no `;` at the end of the line) of type ``.а╪!rЧ ╞"X | Operator | Example | Trait |аЄ"[X |----------|-----------------------------------------------------------------|--------|а░#[c | + | `overload!((a: A) + (b: B) -> C { /*...*/ );` | Add | аЛ#fX | - | `overload!((a: A) - (b: B) -> C { /*...*/ );` | Sub |ас$[X | * | `overload!((a: A) * (b: B) -> C { /*...*/ );` | Mul |а╞%[X | / | `overload!((a: A) / (b: B) -> C { /*...*/ );` | Div |а▀&[X | % | `overload!((a: A) % (b: B) -> C { /*...*/ );` | Rem |аГ&[X | & | `overload!((a: A) & (b: B) -> C { /*...*/ );` | BitAnd |ац'[X | \| | overload!((a: A) | (b: B) -> C { /\*...*\/ ); | BitOr |а÷([X | ^ | `overload!((a: A) ^ (b: B) -> C { /*...*/ );` | BitXor |аШ([X | << | `overload!((a: A) << (b: B) -> C { /*...*/ );` | Shl |ав)[X | >> | `overload!((a: A) >> (b: B) -> C { /*...*/ );` | Shr |аЁ*[Ч ▐+ # Assignment operatorsа■+Ч ╞+b The general syntax to overload an assignment operator between types `` and `` is:аЄ+e┴ , O overload!((: &mut ) (: ) { /*body*/ });а╗,RЄШ,} Inside the body you can use `` and `` freely to perform any computation and mutate `` as desired.а┐-─Ч └._ | Operator | Example | Trait |а┴.b_ |----------|------------------------------------------------------------------|--------------|аЛ.bj | += | `overload!((a: &mut A) += (b: B) { /*...*/ );` | AddAssign | ао/m_ | -= | `overload!((a: &mut A) -= (b: B) { /*...*/ );` | SubAssign |аҐ0b_ | *= | `overload!((a: &mut A) *= (b: B) { /*...*/ );` | MulAssign |а═1b_ | /= | `overload!((a: &mut A) /= (b: B) { /*...*/ );` | DivAssign |а┐2b_ | %= | `overload!((a: &mut A) %= (b: B) { /*...*/ );` | RemAssign |аФ2b_ | &= | `overload!((a: &mut A) &= (b: B) { /*...*/ );` | BitAndAssign |аи3b_ | \|= | overload!((a: &mut A) |= (b: B) { /\*...*\/ ); | BitOrAssign |а╛4b_ | ^= | `overload!((a: &mut A) ^= (b: B) { /*...*/ );` | BitXorAssign |а▐5b_ | <<= | `overload!((a: &mut A) <<= (b: B) { /*...*/ );` | ShlAssign |аР5b_ | >>= | `overload!((a: &mut A) >>= (b: B) { /*...*/ );` | ShrAssign |ау6bЧ ╦7 # Unary operatorsаҐ7Ч с7H The general syntax to overload a unary operator for type `` is:аь7K┴є8 B overload!( (: ) -> { /*body*/ });а╡8EЄЬ8K Inside the body you can use `` freely to perform any computation.а─9NЧ о9┌+т9rЧ г:O | Operator | Example | Trait |ал:RO |----------|---------------------------------------------------------|-------|а÷;RO | - | `overload!(- (a: A) -> B { /*...*/ );` | Neg |аР;RQ | ! | `overload!(! (a: A) -> B { /*...*/ );` | Not | ае Ґ> зҐ> ╩>л>3╧ щу0 х#@PчVcWXZ[a\ tа]^ о_beh∙ Рi │┌⌠ Negа┐├ ╗┬▀█▌▒▐ ≈M░▓■√°╘ ²·═║ї╒ ≈Mёє о╔╗╚ўш Р╞ гхы Notаил щняству ≈Mжьзэ■%Ц╧ЦФМ щГАРуРЧ▒ хЪП#║╨шю┘а op_traitабй Мкпр op_fnась МычЮ ФАБ МЦХЙ ≈MКЛ тМОЯ УРУ тЖЬЗ bodyаШЪ Р─┤┼ь ° И║єі ЎRї ╟Є ≈M╣Їр "е ╨йяс Утв ЕХ ШRИНС ОУ ЬЭ ╨Ч┘х ≈⌡ Ф°· ═єІ тTЇыА>ж> зж> т>Е> 3!╧ щу0 х#@UЦ([i\^`agb ≈Mcd оehknґ Ґo ▄█╚ AddAssignа▌ ≈ ⌠≥ ё╔і╘ї ≈M╗╙╛ўЄб╣Ї╧╨ю╩ ≈M╪Ґ оЎадг├ Ґх ЕФ└ SubAssignаГ П ░Р ЭЧЪ┌─ ≈M│┐┘┤█⌡▌░▓⌠≥■ ≈M∙√ о≈ ²═ъ Ґ║ Ў©щ MulAssignаю и ⌠к увьшы ≈MзэчЮФТГИКЛРМ ≈MНО оПСЖЫ╦ ҐЗ ≈≤І DivAssignа≥ ╒ Їє ў╟╠Є╡ ≈MЁ╣Ї╧©мюбдекф ≈Mгх оилор▒ Ґс ПЯ▐ RemAssignаР Ш ─ Щ ┤┴┼█▀ ≈M▄▌░▓≤і≥⌡²·є÷ ≈M═║ о╒╔╗╚П Ґ╛ ийН BitAndAssignакв Кы ФХИЛЙ ≈MКМОЯВ┘ЬЗЭЩ┐Ч ≈MЪ─ о│└┤┼м Ґ▀ ╗╘к BitOrAssignа╙╣ МЇцефиг ≈MхйлнтБувызЮш ≈Mэщ очАДГ╛ ҐХ ┘├╙ BitXorAssignа┤⌠ П∙ ╒є╔╗і ≈Mї╘╚ґЁбЄЇ╧╨ю╩ ≈M╪Ґ оЎадг├ Ґх ЕФ└ ShlAssignаГ П ▌ Р ЭЧЪ┌─ ≈M│┐┘┤█° ▌▒⌠■ ∙ ≈M√≈ о≤⌡·║Ю Ґ╒ ©юч ShrAssignаа й ▒ л жьыэз ≈MшщъА≥*Х╧ХКР щЛФВуВ┐√ х└У#ідв й⌡ "к ЎRлт Музэ ШRщБ МЦХЙ liаКМ МНСУ яЖЬ тЫШЩ riаЧ─ М│ ├ ┬ ≥ ┴ ▀ т▄ ▌ ░ тT▒ ∙ Р√ ² ═ т ╡ ИЇ ╨ ╪ ЎRҐ е ф ≥ г и к о яп с н А Д ШRЕ Й Ч К Л П Т Ж КsВ Ы Ш ≥ Э ─ д ▓ √ Ъr≈ ° ═ ╡ тTЁ у Ъ> Т> зТ> Р>┐?3╧ щу0 х#@Q╚(WdXY[\b] ≈M^_ о`cfi≈ ┘ j ┐└∙ Addа┘┬ ▓┼█▐░⌠▒ ≈M▓■√≤·╚÷═╒ё╘є ≈M╔і ої╙ґ╟ч ┘ ╠ йкэ Subало ▐ятжвзь ≈MышщъЕРФГИЙПК ≈MЛМ оНЯТВ╔ ┘ Ь ▒▓ё Mulа⌠√ ▓≤⌡²·║÷ ≈M═╒єі╛╧ґў╟╠Ї╡ ≈MЁЄ о╣╦╩ЎЛ ┘ © ьыЙ Divазщ ІъБДЕХФ ≈MГИКМС─ТУВЬЧЫ ≈MЗШ оЭЪ┌┘Ё ┘ ├ ÷═╠ Remа║є Ъі╘╚╛╞ґ ≈Mў╟╡Є╨г╩╪Ў©ею ≈Mаб оцфил─ ┘ м ФГЧ BitAndаХН ЙПЖЬЫЭЗ ≈MШЩЪ│┤■┬┴▀▄▓█ ≈M▌▐ о░⌠√≥к ┘ ЁЄи BitOrа╣╨ Л╪ацдге ≈Mфхйлръстжвщь ≈Mыз ошчАД≤ ┘ Е ЧЪ√ BitXorа─├ О┬▌░▒■▓ ≈M⌠∙≈≥÷ґ═╒є╔╚і ≈Mї╗ о╘╛╞╡Ю ┘ Ё лмч Shlаня █ сжьыэз ≈MшщъАГУ ХЙЛМСН ≈MОП оЯТВЗ╗ ┘ Ш ■∙і Shrа√≥ ░ ⌡·═║є╒ ≈Mё╔ї╘А&╟╧╟Ё╨ щЄў©у©кч хлҐ#Н┬г ▌Х'▐ ЎR░≤ М≥·═ ШR║і Мї╛ў Ъr╞╠ М╡Ї╧ я╨╪ тҐ©а Кsбд Мейл ≥ мо тпрт Ууь тышщ тTчБ РЦЙМд В ИЭЪ│ ЎR┌┼▀ ≥ ▄▌ ░■ я∙≤Ў "і ╨╚╡Є У╣╦ фи ШRйоч птж Кsвыш ≥ эЮ ЦГ ╨ИПЄ ┌ ├ Ъr┤ ┼ ▄ ░ ╒ тTё е ▓@^ Overloads an operator. See the [module level documentation](index.html) for more information.а▄?aП?уП?!Э?▐@ хЩ?Н?#÷@╗@ O у@┬Aж@ opав@ы@ оз@щ@П@ ч@ Фъ@Ю@ МА@Г@И@К@ ≈MЛ@М@ тН@Р@У@ УЖ@Ы@ тЗ@Щ@ тTЧ@┌A Р┐A┼A█AЭA э≈A іAїAюA╗A р ╘A╚AґA ФўA╞A╠A ≈M╡AЁA╣A УІA╧A╩A тT╪AаA экA зAшAУAэA р щAъAАA ФБAЦAЕAФA ≈MГAХAЙA УКAНAПA тTЯAЖAЩA╚BэB╛B р ґB╞B о╟BЁBдB ЄB Ф╣BІB МЇBҐB©B ≈MюBаB тбBфBиB УйBмB тнBяB тTрBжB РвBчBАB⌡C эКB ЗBШB■CЭB р ЩBЪB│C Ф┌C┐C┘C ≈M├C┤C┴C У┼C█C▐C тT░C∙C°CнC▓D оCГCпC ЪrяCсC МтCзCэC щCАC яБCДC тЕCИC р ЙCЛC оМCПC┘D ЯC КsРCТC МУCШCЩCЪC ≥ ─D┌D т┐D┤D тT┬D▄D Р█D■D≈D°E ╒║D ╣DІDуDЇD р ╦D╨D╪D ЪrҐD©DаD ябDдDфD КsгDиDкD ≥ лDнDпD тTяDжD ╒ЮD ТDУD∙EЖD р ВDЫDШD ЪrЭDЧD─E я│E┐E┘E Кs├E┬E┼E▀E ≥ ▄E▌E░E тT▒E√E²EпE▓F яEИEрE ЪrсEуE МжEэEчE ъEЦE яДEФE тГEКE р ЛEНE оОEРE┘F СE КsТEЖE МВEЩEЪE ≥ ─F┌F т┐F┤F тT┬F▄F Р█F■F≈FэF ╒║F ╣FІFуFЇF р ╦F╨F╪F ЪrҐF©FаF ябFдFфF КsгFиFкF ≥ лFнFпF тTяFжFщF┐GоG└G≥G ┘G Ъr├G┬G М┴G▐G▒G⌠G я■G√G т≈G⌡G р °G·G о÷G╒GЇG ёG КsєGіG МїGґG╞G╠G ≥ ╡GЄG т╣G╧G╪G УҐGюG таGдG тTеGиG РйGяGтGБI НчG НGОG■HПG р ЯGСGУG ЪrЖGЬGЗG яШGЩGЪG Кs─H┌H└H ≥ ┘H┤H┴H У┼H█H▐H тT░H∙H Н÷H ╞H╟HжH╠H р ╡HЄHІH ЪrЇH╧H╩H я╪HЎHюH КsаHцHеHфH ≥ гHиHкH УлHоHяH тTрHвH НАH ЯHРH≤IСH р ТHЖHЬH ЪrЫHШHЩHЧH яЪH│I┐I Кs└I├I┬I ≥ ┴I▀I█I У▌I▒I⌠I тT■I≥I НёI ЁIЄIшI╣I р ІI╦I╨I Ъr╩IҐI©IюI яаIцIеI КsфIхIйIкI ≥ лIнIпI УяIтIжI тTвIэIЦI┤JяJ┬J²J ┴J Ъr┼J▄J М█J⌠J∙J≈J я≤J J т⌡J÷J р ═J╒J оёJіJ╧J їJ Кs╗J╙J М╚J╠JЁJ ≥ ЄJІJ тЇJ╩JЎJ У©JбJ тцJфJ тTгJкJ РлJсJжJъK НЮJ ПJЯJ√KРJ р СJУJВJ ЪrЬJЗJЭJ яЩJЪJ│K Кs┌K└K├K ≥ ┤K┴K▀K У▄K▐K▒K тT▓K≈K Н║K ╠K╡KьKЁK р ЄKІK╦K Ъr╧K╩KҐKЎK я©KаKцK КsдKфKхK ≥ иKкKмK УнKяKсK тTтKыKЮK└LнL┘L≤L ├L Ъr┤L┴L М┼L░L▓L я⌠L∙L т√L L р ⌡L²L о·L║LІL ╒L КsёL╔L МіL╛LўL╟L ≥ ╠LЁL тЄL╦L╩L У╪L©L тюLцL тTдLхL РиLпLсLэM НщL МLНL⌠MОL р ПLРLТL ЪrУLВLЫL яЗLЭLЧL КsЪL│M┐M ≥ └M├M┬M У┴M▄M▌M тT▐M■M Н·M ўM╞MуM╟M р ╠MЁM╣M ЪrІM╦M╨M я╩MҐM©M КsюMбMдMеM ≥ фMхMйM УкMнMпM тTяMжMщM┐NкN└N≈N ┘N Ъr├N┬N М┴N▐N▒N я▓N■N т∙N≥N р N°N о²N═NЁN ║N Кs╒NєN М╔N╚NґN ≥ ўN╟N т╠N╣N╦N У╧N╪N тҐNюN тTаNеN РфNмNпN≈O НзN ЙNКN░OЛN р МNОNЯN ЪrРNТNЖN яВNЫNШN КsЭNЧN─O ≥ │O┐O┘O У├O┴O▀O тT▄O▒O≤O index.htmlаЛнЛн│ЦНч.╣X$Ч_zї ├│ЦНч.╣XО√tH я│ЦНч.╣X=ь█лQ}⌡│ЦНч.╣X-[▓~чО<│ЦНч.╣X╩хfж2f│ЦНч.╣XБux"y│ЦНч.╣X>П│Г ⌠┬│ЦНч.╣XТцТ≈I8а│ЦНч.╣X5ц╪√Бv0A│ЦНч.╣X┘4yruзБ│ЦНч.╣X(█⌡k▄b╨і│ЦНч.╣XJЭа~ў│ЦНч.╣XйЕ╘къp!%=лЁ%Ю%°(,C,s8%<R<FHL%ш%>,M<%%%%%%%%ы%K&)<,ў,К8K<Ґ<ЎH(M7╔%╘%ґ%ш%√(,>,m8<M<@HyLї%╚%с%F&)6,╘,Е8E<╦<╦H"M%я%4,C<ЎаельН 9]j│║L&)╞,Л8Ў<©H)Mjg╡│ЦНч.╣XИ├'R√$kпljtj|j²j█j╠j─ODHT Їч│ЦНч.╣XJЭа~ў│ЦНч.╣X5ц╪√Бv0A│ЦНч.╣XО√tH я│ЦНч.╣X┘4yruзБ │ЦНч.╣X╩хfж2f│ЦНч.╣X>П│Г ⌠┬│ЦНч.╣XТцТ≈I8а│ЦНч.╣XБux"y│ЦНч.╣X$Ч_zї ├│ЦНч.╣XйЕ╘къp│ЦНч.╣X=ь█лQ}⌡│ЦНч.╣X(█⌡k▄b╨і │ЦНч.╣X-[▓~чО<ЪW Ъhq3D`C8MSЪЪW Ъhq3D`C8MSЪ^/home/steffen/.cargo/registry/src/index.crates.io-6f17d22bba15001f/overload-0.1.1/src/unary.rsа Щ!;) ═ўЖ B╒╞t⌠·QШU·Q$FF$(X% . 4І{Ц÷T▓Є45(<4,O?@-M?WABBCUABUAB SAіu,hYjxЎuтЭY2б│7<_g┌·ЦКП ┐ ┬©х ХЫ┬▌√йрО█║цжЕМ╠╧ПЧ÷ ╨!И"┐#є$ў%Є&╪'ъ(Г)└*╒+І,ь-К.З/┌ 0х 1В 2Ъ 3└ 4ё 5╗ 6─7┬8╔9ц:в;Ы<▄=⌡>ё?И@ЯAц Bк CХ D├E F╪GоHчIФJ╚KПLЬM╨N©O╣P╨QдRлSИT┤U⌡VҐWпXъYГZґ[╣\Л]З^⌡_І`ЕaЪb═c╙d╟e╣fвgРh╒i╪jщkГlМmРn■o╞pчqЬr≥sёt╘uўvяwЛx°yІzв{А|Г}П~╡╨─в│У┌┴┐╚└Ў┘м├у┤²┬л┴Э┼╛▀щ▄Е█И▌─▐┘░Ф▒Т▓п ⌠ь ■Ї!∙╪!√╞"≈Є"≤░#≥Л# с$⌡╞%°▀&²Г&·ц'÷÷(═Ш(║в)╒Ё*ё▐+є■+╔╞+іЄ+ї ,╗╗,╘Ш,╙┐-╚└.╛┴.ґЛ.ўо/╞Ґ0╟═1╠┐2╡Ф2Ёи3Є╛4╣▐5ІР5Їу6╦╦7╧Ґ7╨с7╩ь7╪є8Ґ╡8ЎЬ8©─9юо9ат9бг:цл:д÷;еР;фе<г =х÷=и╚=й╟=к╨>л╩>мх>нс>от>пА>яЯ>рР>сЪ>т▀?у▄?жН?в▓@ь╙@ыя@з▐AшцAэЬAщЪAчїBъЦBЮ≈CА·CБйCЦ≥DДьDЕ≤EФ÷EГлEХ≥FИьFЙЦFКЪFЛжGМ≈HНыHО⌡IПчIЯЕIР┐JСьJТ≥KУшKЖБKВ─LЬуLЫ√MЗьMШъMЭЪMЩрNЧ⌠OЪ O─°O│[lJmZnjox86_64-unknown-linux-gnuаН┘Ў+Ґ²с|WDNOЬЎ-╔ -2b65450f9f69567aа│ЦНч.╣XХХун ппhPhP 4 44444((4444U╟.note.gnu.property.shstrtab.strtab.symtab.rmeta@ .─`≈u&Ьuvv5/0 0 0 0 644 584 ` ELF>х@@6ЯЪ.text.debug_aranges.note.GNU-stack.strtab.symtaboverload.58b52e15deeee381-cgu.0&pV@@@.@0