Files
boc/aamos-ledger-rust/target/debug/deps/libmemchr-809318e8f6183885.rmeta
T

2361 lines
600 KiB
Plaintext
Raw Normal View History

rust
_^ #rustc 1.96.0 (ac68faa20 2026-05-25)ÁíàÄTËŸ ÜJîÄ)'ß\¥!-3d1337db07d0b3aeÁÀ뉊]!ÜÛê(¹Þ—šên-5be7b69c3ff7b5b8Á¤²XctÔ'ÐÓ©z¨ɽÓ-a4945860e1c53b00Á¤°ð ¾ä-±($²ï=©Ã-7e98a21bfd32b0edÁòÖÀH•‘PIÓHã#£-055f30b747f859b6Árustc_std_workspace_coreÁ­Cçß^ò½èÝ$­Çÿ+Cé-c4878ee60b2242c9ÁŸÃï+Ñ]ŠqB<ÏïW#-8dd1dd90e70d0b6aÁ miniz_oxideÁ€š»J(P>àö÷g\K-1eb618da2918ab7fÁadler2ÁÆ;+Þ®5¥Ìýݰ¦ÛLˆ-f7919172d268e069Á hashbrownÁPäV9ÒÆèÜ"ÊÖVŽ\-0fc2184a5da6723aÁrustc_std_workspace_allocÁs&ØòØy¯s•bæ!‰ýŠ-97e4bf30be240674Á
std_detectÁhŠBîÙºÌI®ËÅš-9dbbf8346ba7ac8bÁrustc_demangleÁûë9´Ç×@Œ’ùXFº-f33013f239bf9f14Ácfg_ifÁÜLhž§Œaã¯>­-0a71c8f33a838301Á addr2lineÁ׎Þ!]8V$É@@-e618e6be60e87ba2ÁgimliÁ¸
°µ~Î1‹Ñt ðÁ€w-1f7768a68858f670ÁobjectÁ
áPÃ?­À¶¼QHJ¥-914cd6a4dbe590d1ÁmemchrÁ›º«8Ór­2Ù $¨ûib-cf21ca6f2bb15dcdÁë
‹ás«LÖ€îâƒ×ɯŒ-ee6f3747e38367f0ÁtestsÁ,Á@$©@Å,á…$Ö…{Å,ÿl$ôlÅ,«o$ oªÅ$²Å,€Î$õÍÅ,Í.$Â.¦Å,è—$Ý—Å,ä4$Ù4× ì×´€ õ ìõ´Ì «ImpÁœ
»¤Œè
ύ
¼ByteÁ$Ì
$´
ÈÅ,«³ $ ³ ¤simd128Á<§
ì×´Á
¤avx2Á$ 
ìõ´º
¤µ
ìõ¤searcher_kind_sse2Á”¯l
ìõ´òk
¤searcher_kind_avx2Á”¨q
ìõ´ëp
¤searcher_kind_simd128Á¬­v
ì×´íu
¤prefilter_kind_sse2ÁœÛî
ìõ´žî
¤prefilter_kind_avx2Áœêò
ìõ´­ò
¤prefilter_kind_simd128Á´…÷
ì×´Åö
Å,ô¾$龦x86sse2Á<Ð;ìõ´³;¦x86avx2Á<¹Eìõ´œE¦ wasm_simd128Ádöƒì×´¼ƒíÀ¤ 
  
macrosÁlogÁtraceÁarchÁ£ì USIZE_BYTESÁ USIZE_ALIGNÁ!
LOOP_BYTESÁ!æ !findÁ$ !rfindÁ& !ü!find_rawÁ) ! rfind_rawÁ+ ! count_rawÁ!ù.'aÁ.'hÁ!
has_needleÁ!confirmÁ3333ó 7 3ü9 3 size_hintÁ<<< next_backÁ? Aæ A°C A¿E AÖG AéI AùKKA¦A·PPPPó T PôWWWZ \æ \°^ \¿` \Öb \éd \ùff\¦\·kkkkó o kôrrru 
has_zero_byteÁwLOÁwHIÁsplatÁ
packedpairÁ{{ default_rankÁ}RANKÁ~ {æ  with_pairÁfind_prefilterÁƒ pairÁ{æ  with_rankerÁˆ£ with_indicesÁindex1Áindex2Á{HeuristicFrequencyRankÁrankÁ{DefaultFrequencyRankÁ
{{£ rabinkarpÁæ °Öæ ¿éis_fastÁ¢æ ¢forwardÁ¢reverseÁ¢rollÁ¢¢delÁ is_equal_rawÁshiftorÁªªMaskÁª­MAX_NEEDLE_LENÁ­æ ¯ ­°twowayÁ²²²²²²²¹æ ¹°¹find_with_prefilterÁ¹find_small_impÁ¹find_large_impÁ²¿æ ¿¿¿rfind_small_impÁ¿rfind_large_impÁ²ÄÏÄÞ²ÇÏÇÞ²ÊË²Íæ ÍcontainsÁ is_prefixÁ is_suffixÁis_equalÁŒgenericÁÔìÕÕÕÕÕÕÛ§Û LOOP_SIZEÁÛæ Ûneedle1ÁÛÖÛéÛýâ Û search_chunkÁäimpl Fn(V::Mask) -> usizeÁÕæ§æææ ææneedle2ÁæÖæéæÉîÝÕð§ððæ ðð£ðneedle3ÁðÖðéðÉùÝÕûÕýÕÿÿæ ÿó 5impl FnMut(*const u8, *const u8) -> Option<*const u8>Áÿü)impl FnMut(*const u8, *const u8) -> usizeÁÿåÿôÕsearch_slice_with_rawÁåÕfwd_byte_by_byteÁÕrev_byte_by_byteÁÕcount_byte_by_byteÁÔ š§šæ š°šõš
find_in_chunkÁšfind_prefilter_in_chunkÁššmin_haystack_lenÁmatchedÁ¤à ¥ì¦¦¦¦¦¦¬æ ¬ð ¬ is_availableÁ¬°° ¬¿² ¬ü¬Öµ ¬é· ¬ý¹ ¬
find_raw_implÁ¬rfind_raw_implÁ¬count_raw_implÁ¬ù¾¾¦ÁÁÁÁó Å ÁüÇ Áô¦ÊÊÊÍ ¦ÏÏ¦Òæ Òð Ò÷"Ò°Ö Ò¿Ø ÒÖÚ ÒéÜ ÒÔ#Òé#Òùàà¦ããããó ç ãô¦êêêí ¦ïï¦òæ òð ò÷"ò°ö ò¿ø òÖú òéü òÔ#òé#òù¦ ƒƒƒƒó  ƒô¦
ŠŠŠ ¦ ¥ æ äwith_pair_implÁ÷"°õ find_implÁfind_prefilter_implÁ"¤ì¢defrawÁ¢
memchr_rawÁ¢ memrchr_rawÁ¢ memchr2_rawÁ¢ memrchr2_rawÁ¢ memchr3_rawÁ¢ memrchr3_rawÁ¢ýcowÁ««­­å­´«±±æ ³± new_ownedÁ±as_sliceÁ±
into_ownedÁ«¸¸æ ¸í+extÁ¼½distanceÁ½as_usizeÁ¼À¥À¾,ÀÎ,¼Ä¥Ä¾,ÄÎ,ìÈÈÈìË ÈmemrchrÁÍ Èmemchr2ÁÏ Èmemrchr2ÁÑ Èmemchr3ÁÓ Èmemrchr3ÁÕ È memchr_iterÁ×È memrchr_iterÁÈ memchr2_iterÁÚÈ
memrchr2_iterÁÈ memchr3_iterÁÝÈ
memrchr3_iterÁÈààæ Èãããó æ ãüè ãôÈëëí ÈïÈññæ Èôôôó ÷ ôôÈúúü ÈþÈæ È ƒƒƒó  ƒôÈ
 È È˜*Ȫ*Ƚ*ÈÐ*Èä*È÷*ÈýmemmemÁ 
  searcherÁ¤¤¤¤¤¤¤¤¬æ ­£¬î¬°¤±×¤SearcherKindFnÁ¤searcher_kind_emptyÁ¤searcher_kind_one_byteÁ¤searcher_kind_two_wayÁ¤$searcher_kind_two_way_with_prefilterÁ¤searcher_kind_neonÁ¤¹æ ¹¿¤¼>¤¾is_noneÁ¤À¸Á£ÁMAX_FALLBACK_RANKÁÀà À°À find_simpleÁÆ ¤ÈפPrefilterKindFnÁ¤prefilter_kind_fallbackÁ¤prefilter_kind_neonÁ¤Í MIN_SKIPSÁÍMIN_SKIP_BYTESÁÍæ Í¥Í is_effectiveÁÍis_inertÁÍskipsÁ¤ÕÕ°Õ®7¤do_packed_searchÁÙMIN_LENÁÙMAX_LENÁ find_iterÁÜÜ'nÁÜŸ
rfind_iterÁààË8àŸ°¿ææË8ææ æý+ëëË8ëëó ëôññË8ñæ ñý+ööË8ööó ûË8ûæ ýû°û²8ûý+ûÉûneedleÁË8æ ˆ¿ŠÝ8ŒŒý+É€;æ 
build_forwardÁË8build_forward_ownedÁbuild_forward_with_rankerÁË8£build_forward_with_ranker_ownedÁ£
build_reverseÁ Ë8 build_reverse_ownedÁ£ prefilterÁ¦VectorÁ§BYTESÁ§ALIGNÁ§³§§ load_alignedÁ§load_unalignedÁ§movemaskÁ§cmpeqÁ§µ§
§movemask_will_have_non_zeroÁ¦MoveMaskÁ³"all_zeros_except_least_significantÁ³ has_non_zeroÁ³
count_onesÁ³µ³
³clear_least_significant_bitÁ³ first_offsetÁ³ last_offsetÁ¦¼get_for_offsetÁ¦¾Ò?¾ü?¾@¾µ¾
¾²@¾Õ@¾é@¦ aarch64neonÁÇÇÇÇÇÌž>Ì«>̳ÌÌÈ>ÌÜ>Ìò>Ì?̵Ì
ÌŸ?ÇØAÇÚÒ?Úü?Ú@ÚµÚ
Ú²@ÚÕ@Úé@OneÁãs1Áã² 
çƒ  ê×OneIterÁìììò2ìitÁ
ñññƒõõõ×TwoÁù¼Cùs2Áù²ùv2Áÿƒ×TwoIterÁò2”Dƒ×ThreeÁ¼CèDs3Á²úDv3Áƒœ× ThreeIterÁžžžò2ž”D£££ƒ§§§×{FinderÁ««byte1Á«byte2Á{{°ƒ{{³×{PairÁµ×µå{{ ¹ƒ{
{ ¼×ÑG¾§¾ hash_2powÁÁƒÃ× FinderRevÁÅ
ňȃÊ׎Ì
̈Ѓ 
Ó× Õ> ×Ö
ÚªÑGÜmasksÁÝ Ü
needle_lenÁªàײÑGâ
∲²æƒ²² éײ—Ië
눲
²  ²
òײTwoWayÁôbytesetÁô critical_posÁôshiftÁ²²ùƒ²²üײShiftÁþSmallÁÿperiodÁþLargeÁL²²ƒ²²×²SuffixÁposÁÚL²Œ×²
SuffixKindÁŽMinimalÁ
ŽMaximalÁ
²²ƒ²²×²SuffixOrderingÁAcceptÁš
SkipÁœ
PushÁž
²²¡ƒ²²¤×²ApproximateByteSetÁ¦
¦ˆ²² ªƒ²!²"­×Õ±C¯§¯¼C¯²Õ³§³ƒÕ§Õ¸§¸×ÕÕD»§»¼C»èD»²»úDÕ Á§ÁƒÕ
Ä§Õ Æ§Æ×Õ‰FɧɼCÉèDɦFɲÉúDÉÀFÕ Ñ§ÑƒÕ
Ô§ÕÖ§Ö×ÕIterÁÙÙoriginal_startÁÙ¹ÙþÙhaystackÁÕß߃Õââ×ÑGå§åå²åúDå‹"ë§ëƒî§ð§ðצ±Có
óˆ¦ ¦
÷ƒ¦¦úצíCüüüò2ü”D¦ƒ¦×¦ÕD
ˆ¦¦ƒ¦¦×¦£Eò2”D¦ƒ¦×¦‰FŸ
Ÿˆ¦¦£ƒ¦¦¦×¦éF¨¨¨ò2¨”D¦­­­ƒ¦±±±×ÑGµ
µˆ¹ƒ¼×¤¥¦§¨©ª«CowBytesÁÅ
Åň«ÉɃ«ÌÌ׫­ ÏÏBorrowedÁÑ
шÏOwnedÁÔ
Ôˆ«×׃«ÚÚ×ÈMemchrÁÝÝÝ”DÈ ááƒÈ
ää×ÈMemchr2Áççç£ç”DÈììƒÈïï×ÈMemchr3Áòòò£òÿò”DÈøøƒÈûûפSearcherÁþÑþþ㤠 ƒ¤ SearcherKindÁemptyÁone_byteÁtwo_wayÁtwo_way_with_prefilterÁà ¤
¤ ƒ¤ ¤TwoWayWithPrefilterÁŽ finderÁŽ prestratÁ¤
¤¤ƒ¤×¤ SearcherRevÁ㤚 ƒ¤œ פSearcherRevKindÁž EmptyÁŸ
ž OneByteÁ¡ €;ž ÞK£ »]¤¥ ƒ¤§ פPrefilterConfigÁ© ©ª
© AutoÁ¬
¤¤¯ ƒ¤¤² פ PrefilterÁ´ Ñ´ ´  rarest_byteÁ´ 
rarest_offsetÁ¤¤º ƒ¤¤
PrefilterKindÁ½ ¸½ à ¤¤Á ƒ¤¤PrefilterStateÁÄ Ò7Ä skippedÁ¤¤ È ƒ¤!¤"Ë ×¤PreÁÍ Í prestateÁÍ É]¤#Ñ Ñ ×FindIterÁÔ Ô Ë8Ô ÖRÔ ýaÔ »]Ô ¯MÛ Û Ë8Û ×ß ß Ë8ß ƒ FindRevIterÁã ã Ë8ã ÖRã »]ã ¯M é é Ë8é ƒ
í í Ë8í ×ÑGñ Ë8ñ €;ñ ò2 õ Ë8õ ƒ ø Ë8ø ×—Iû Ë8û €;û ò2
ÿ Ë8ÿ ƒ
Ë8
×
FinderBuilderÁ
ø=
ƒ
×
>¦SensibleMoveMaskÁ

ˆ¦¦
ƒ¦¦
×Ç NeonMoveMaskÁ

ˆÇÇš
ƒÇÇ
×$
$
&
&
(
(
)
+
-
1
2
7
;
?
C
C
E
E
G
I
N
O
T
V
Z
^
^
`
`
b
d
i
j
o
q
u


ƒ
ƒ


ˆ
Š

Œ
Ž


š



œ
ž
Ÿ
Ÿ
Ÿ
 
¡
¡
¦
¦
§
¨
¨
¯
±
±
º
»
»
»
¼
¼
¼
¼
½
½
½
½
¾
¾
¾
¾
À
Á
Á
Á
Â
Â
Â
Ã
Ã
Ã
Å
Æ
È
É
Î
Ï
Ð
Ð
Ñ
Ñ
Ò
Ò
ß
à
á
â
ä
ê
ë
ì
í
î
ô
õ
ö
÷
ø
ù


ˆ

œ



ž
ž
Ÿ
Ÿ
 
¡
¢
°
°
²
²
´
´
µ
·
¹
»
¼
½
Å
É
Í
Ö
Ö
Ø
Ø
Ú
Ü
Þ
ß
ç
é
í
ö
ö
ø
ø
ú
ü
þ
ÿ



˜

š
œ
œ
œ


ž
ž
ž
Ÿ
Ÿ
 
¡
°

»
Ë
Í
Ï
Ñ
Ó
Õ
Ù
Ü
ß
æ
ê
í
÷
ù
ü

ˆ

­
¯
°
°
°
°
²
²
²
³
³
³
³
´
´
´
´
µ
µ
µ
µ




·
·
·
·
¸
¸
¸
¸
º
»
»
»
¿
Á
Ä
Å
Å
Æ
Æ
É
É
É
Ê
Ê
Ë
Ë
Ì
Ì
Ñ
Ò
Ó
Ô
×
×
Ø
Ù
ä
ä
å
å
ï
ð
ú
ÿ
ÿ


Š






 
£
¥
Ó Ó × è
ë
ë
ë
ô
ø
ø
ø

ƒ
ƒ
ƒ
Œ



š



¦
ª
ª
ª
±
´
´
´
º
½
½
½
Â
Ä
Ä
Ä
É
Ë
Ë
Ë
Ñ
Ô
Ô
Ô
Ø
Û
Û
á
á
á
ç
ê
ê
ê
ð
ó
ó
ó
ú
ý
ý
ý

ˆ
ˆ
ˆ




˜
˜
˜
¢
¥
¥
¥
«
®
®
®
µ
º
º
º
Ã
È
È
È
Ó
Ø
Ø
Ø
á
ä
ä
ä
í
ò
ò
ò
ø
û
û
û

ˆ
ˆ
ˆ
Ž



š
ž
ž
ž
¤
§
§
§
°
´
´
´
º
½
½
½
Ë
Î
Î
Î
Ù
Ü
Ü
Ü
ã
æ
æ
æ
î
ñ
ñ
ñ
ú
ý
ý
ý
ƒ
Œ








¦
¨
¨
¨
°
³
³
³
»
Â
É
Ì
Ì
Ì
Ó
Ó
Ó
Þ
Þ
Þ
â
ì
ð
ð
ð
÷
ú
ú
ú




ˆ
Š
Š
Š





ž
ž
ž
½§³Ûãã±Cä¼Cå²#"»ŠØ¦{Š ¦{¿c¦{ØììíCïò2ð”D³«KiŠWÿ¿cƒ|ùMƒ|ŒMƒ|ÛùùÕDú¼CûèDü²ýúDµpW|#¬~Øì|Š ì|¿cì|Ø£Eò2ˆ”D
ãËž”ç¿cß}ùMß}ŒMß}Û‰F¼CèD¦F²úDÀFz"w¬]g7áØÈ~Š È~¿cÈ~ØžžéF¡ò2¢”DÃT·Ù¦b`¿cÑùMÑŒMÑÛ««ÑG¬{­çG{®ôG{ò’Œ½;ªöãØº€Š º€¿cº€Ûµµ H×{·å{¥ÃtÇg§OØ¥Š ¥¿c¥ ¢"žÕ £Ø¾¾ÑG¿§ÀìH:x¯éµsŠ¿cÆ‚ØÅÅÆ—ILj ÖÐ!FÆjпc’ƒÛÌÌ͎Έ F¯*bNîÕØÖƒŠ Öƒ¿cÖƒ³ÖƒÖƒÐìÖƒµßÖƒÖƒ¿cÜÜÑGÝ»JªßÍJªW«x·•EÛââãÑG䈲 žÚ&—¥Ø£…Š £…¿c£…Ûëëì—I툲 j
åÁA“hØý…Š ý…¿cý…ÛôôÞKõìK²öûK²÷L²Õ6$»j¡ülØ׆Š ׆¿c׆ÛþÿÍLÚL²èLL²äÇFH ØŇŠ Ň¿cŇ¿c¡MНM²ÚL²Æ ©'kVÛŽáMõMÞ&#.š"ØôˆŠ ôˆ¿côˆÛšÃNœÖNžŸçN©ŽÓ|‚¬ØÒ‰Š Ò‰¿cÒ‰Û¦¦§œO¨ˆ² z:ýÅR"VØÀŠŠ ÀŠ¿cÀŠØ¯¯±C±¼CÕ²²ÕûÉ!¯öƒQK§Š š‹¿cš‹Ø»»ÕD½¼CÕ¾èDÕ¿²ÕÀúDÕ¼±'yÐ=ºÔ‹Š ÷‹¿c÷‹ØÉɉF˼CÕÌèDÕͦFÕβÕÏúDÕÐÀFÕ†žP~ë×XÔ‹Š êŒ¿cêŒØÙÙœRÛ°RÕܹÕÝþÕÞÖRÕ2ý $šÞ¿cõÌìõ õØååÑGçè²éúDê‹"TE'g±õÔ‹Š öŽ¿cöŽÛóóô±Cõˆ¦ 4П¿åØéŠ é¿céØüüíCÿò2¦”D¦Îüs¸ƒ&Ïã¿cÃùMÃŒMÃòPÃÛŠÕDˆ¦ ;”ÛðÍ òؼ‘Š ¼‘¿c¼‘Ø£Eò2¦”D¦% §âO¨ûu¿c–’ùM–’ŒM–’òP–’ÛŸŸ ‰F¡ˆ¦ õHçÅ]Ñ’ËØŠ ¿cب¨éF«ò2¦¬”D¦ö Æh`Š¿cé“ùM铌Mé“òPé“ÛµµÑG·ˆ £Áf:‹Øâ”Š â”¿câ”ØÅÅÆ¤XȈ« ~Fìɳ¯I¿c¼•ØÏÑÒƒYÓˆ«ÔÕ YÖˆ«;$Va„o¿c†–é!¼•½ ¥½ ø–ØÝÝäYßÈà”DÈñnpy5A©¿c“—ùM“—ŒM“—òP“—Øçç´ZéÈê£Èë”DÈc*K¿c†˜ùM†˜ŒM†˜òP†˜Øòò[ôÈõ£ÈöÿÈ÷”DȘ÷×f¼äË¿c…™ùM…™ŒM…™òP…™Øþþî[ÿѤ¤ ã¤É¦
P`SοcšÛ£\·\¤Ä\¤Ô\¤ˆ ã\¤à ¤%4Ÿó€„ØèšŠ 蚊 Ž Ž  ] »]¤ É]¤KÂ$Cy1‘[Ûã›Øã›¿cã›Øý]˜ ¤ã¤ia.;E÷VQ¿cŜ؞ Ÿ   Ñ^¡ ã^¢ €;¤£ ÞK¤ »]¤üh³Cžº®¿cÛ© ª « ©¬ ­ È_‰‰ê!îØùŠ ù¿cù³ùÛ´ ´ ý_µ Ѥ¤· ž`¤¸ ±`¤·@¦74g75ØâžŠ âž¿câžÛ½ ½ Ý`¾ ¸¤¿ à ¤‚5æ”|´&áØÜŸŠ ÜŸÛÄ Ä ™aÅ Ò7¤Æ ·a¤)R²U åµNس Š ³ ¿c³ ¿cÍ Í êaÏ ýa¤Ð É]¤íRtš¡¿cÔ Ô ªb× ÖRØ ýaÙ »]Ú ¯Mï…Nº:¨þË8ØÜ¡ùMÜ¡Øã ã ¤cæ ÖRç »]è ¯M½ ]$®Ë8¿c×¢ùM×¢Øñ ñ ÑGó €;ô ò22 ûT“V»ÿË8¿cÆ£Øû û —Iý €;þ ò2*|Ohý°Ë8¿c˜¤Ø

­e
ø=e<æ,¿cꤳê¤Û

Ž
ðe
ˆ¦ iöeÁ€Ý$ðØµ¥Š µ¥¿cµ¥³µ¥§Ó’Ó’Ô’
uint8x16_tÁÕ’ˆ ÛÓš€jÛ


¹f˜
ˆÇ  yŠcØà¦Š িcà¦³à¦æãþù˜¯«¸µÏÌåâîëøôƒþŽ ©¦ö󌢟¸µŠ „ ’ Ž ® © ¹ ´ À ½ Ç Ä


çãñìÿù£ž°«¹µÁ¾ÈÅÐÌæâïëùôþŽ¡ª¦³¯Á»ÑÉßÙëå÷óü£Ÿ­¨¹µÉÅ×ÏáÝìçøòþ„ “ Ž š — ¥ ž ¯ © º ´ Á ½ È Ä ß Ô é ã õ ñ ÿ û ‡


š

éãù²«»µÒÌèâñëûôþŽ£¬¦¯Ä»ÔÉîåù󥟻µ „ ‘ Ž ± © ¼ ´ à ½ Ê Ä “

œ

êãõìùœ§ž³«¼µÃ¾ÊÅÓÌàÜéâòëüôþŒŽ¤­¦¸¯Æ»ÖÉâÙðåúóü¦Ÿ±¨¼µÌÅÚÏäÝïçûò±þŽ œ — § ž ² © È´ Ë Ä Ñ Í Û Ô í ã ø ñ
û ‰



3ìPkžÁüヨãÝôçƒòëÔ öã <ìWržÊüꊨëÝúçò
Õ̼©

×ÌÙÌÚÌûÙýÙÏüï¨ïÝþçò­ÅÀ Ä ¾
Ú
ÌÓ’Ûæ
ØŠ å¿c4ËùM ìŒM J<³ ÐìµßÌì òPé!*½³
§Œå  ô !1  ˜ÕM ˜ÕRÔå  þ üÊ 6 ¯µ1˜Õ˜Õ   ö . 1/\üÍ +  .ž ø. 1/\üÞ*"€¶,~ˆ


z
2ô¸x%

¸
1ôÛy%d«… ¬…  ¶…”º… È…ÿ'; T»…—ÕX —Õ\ÿü«…! , Ë… Î…züÁ„,Ú„ Є43€¶ ­4Xó—Õÿ—Õü#¥" )7<4O3b2u1ˆ0/®.Á-ÔgåòöBCœå­,À+Ó*æ)ù(Œ'Ÿ&²%Å$Ø#ë"þ!8¤ ·ÊÝðƒÿ£¤³ÃˆÓ ãó­ƒÝÞ£³zÃèÓÊã×óàƒÐܣ̳»Ã·Ó³ã±ó¨ƒ²È£â³ÃÚӸã®ó~ƒ x¿£ ³ Âà ªÓ ½ã ¢ó ¡ƒ

Á£
޳
Ã
«Ó
°ã
¹ó
§ƒ º p£ ¯³ Àà ¼Ó œã Œó ƒ { £ ³ à ŠÔ ä rô ß

ù¤
Ø´
îÄ
ìÔ
ýä
ãô
Úæ÷¤´´ÄñÔéäöôôç¤õ´óÄûÔëäÉôÄðÖ¤˜´ÄÍÔµäôÔšÓ­ÒÀÕÓäæÅù©ŒŸŸƒ²¬ÅiØPëbþ`a¤Q·ÏÊÝtðsƒ©¼yÏkâõmˆn|®oÁRÔlçvúqœ­w¾}Ï¥àuñ\jS¤HµcÆ]ÙAêOû¦Œí£®Ç¿¾ÐááÑò˃ÆÙ¥ÛÎÇêØøéžúïÿœÿ­ÿ¾ÿÏÿàÿñÿÿÿ¤ÿµÿÆÿ×ÿèÿùÿŠÿÿ¬ÿ½ÿÎÿßÿðÿÿÿ£ÿ´ÿÅÿÖÿçÿøÿÿšÿ«ÿ¼ÿÍÿÞÿïÿÿÿ¢ÿ³ÿÄÿÕÿæÿ÷ÿˆ ÿÿª ÿ» ÿÌ ÿÝ ÿî ÿÿ ÿ!ÿ¡!ÿ²!ÿÃ!ÿÔ!ÿå!ÿö!ÿ‡"ÿ˜"ÿ©"ÿº"ÿüÉ"~L1256Á256Á„ôùÏ 2 /ùÏ-^Ìô ŒüÖ8®¬6°ùϼùÏ256Ádù( ù(Dý(¨Ô‹4 75¨Ô‹hüà(&Ý,ñ(€¶Ÿ-¨Ô‹¨Ô‹d±– ±–Dµ–¨Ô‹7 96¨Ô‹kü˜–&è,©–€¶¤/Ž¨Ô‹ž¨Ô‹d¡ç ¡çD¥ç¨Ô‹7 96¨Ô‹küˆç&ò,™ç€¶¤/Ž¨Ô‹ž¨Ô‹ú250Á250Á 32Á16Á|êP\êP¨š¦ øP3 6¨š¦4füÕP%Î,âP€¶-¨š¦¬¨š¦¤Ò< ÅÆ%’ƒ1Æ‚9@\ä[ ÌÍ%Öƒ18?ŒÙ
 âã%£…1׆9@¤Õ  ëì%ý…1׆9@Ì»É ¦§&ÀŠ29@
 óô%é1¯¯±C±¼CÕ²²ÕûÉ!¯öƒQKš¦szts Š%¼‘1»»ÕD½¼CÕ¾èDÕ¿²ÕÀúDÕ¼±'yÐ=ºš¦„ÄÅ Ÿ &2ÉɉF˼CÕÌèDÕͦFÕβÕÏúDÕÐÀFÕ†žP~ë×X𦤫Œ© µ%â”1ååÑGçè²éúDê‹"TE'g±õš¦¼
ÅÆ'ÅÅÆ¤XȈ« ~Fìɳ¯IcÏÑÒƒYÓˆ«ÔÕ YÖˆ«;$Va„o·¾
ÏÒ'Úê3 
>E
ÏÕ'Úê3žBoxÁ¡ˆˆ¢ˆl }.xÏøëçEçEèEGlobalÁ ¿±‡§í#¨¯ü(" 
Ž
&µ¥29@ôél 

%à¦18?È«¼¦íÀú=¤,²>ì4×> ËÊ-<ß> ÏË.dè> Úó-<ö> Ó ü.dÿ> Ý
œ.\? × ¶-<ž? Í Þ-D§? Ñ
ç.l±? ܇.DÀ? Õ˜/lÊ? ß·.dÙ? ÙäY4ë?Ý´Z<ó?ç[<ü?òüAüæ6á6
This library provides heavily optimized routines for string search primitives.
# Overview
This section gives a brief high level overview of what this crate offers.
* The top-level module provides routines for searching for 1, 2 or 3 bytes
in the forward or reverse direction. When searching for more than one byte,
positions are considered a match if the byte at that position matches any
of the bytes.
* The [`memmem`] sub-module provides forward and reverse substring search
routines.
In all such cases, routines operate on `&[u8]` without regard to encoding. This
is exactly what you want when searching either UTF-8 or arbitrary bytes.
# Example: using `memchr`
This example shows how to use `memchr` to find the first occurrence of `z` in
a haystack:
```
use memchr::memchr;
let haystack = b"foo bar baz quuz";
assert_eq!(Some(10), memchr(b'z', haystack));
```
# Example: matching one of three possible bytes
This examples shows how to use `memrchr3` to find occurrences of `a`, `b` or
`c`, starting at the end of the haystack.
```
use memchr::memchr3_iter;
let haystack = b"xyzaxyzbxyzc";
let mut it = memchr3_iter(b'a', b'b', b'c', haystack).rev();
assert_eq!(Some(11), it.next());
assert_eq!(Some(7), it.next());
assert_eq!(Some(3), it.next());
assert_eq!(None, it.next());
```
# Example: iterating over substring matches
This example shows how to use the [`memmem`] sub-module to find occurrences of
a substring in a haystack.
```
use memchr::memmem;
let haystack = b"foo bar foo baz foo";
let mut it = memmem::find_iter(haystack, "foo");
assert_eq!(Some(0), it.next());
assert_eq!(Some(8), it.next());
assert_eq!(Some(16), it.next());
assert_eq!(None, it.next());
```
# Example: repeating a search for the same needle
It may be possible for the overhead of constructing a substring searcher to be
measurable in some workloads. In cases where the same needle is used to search
many haystacks, it is possible to do construction once and thus to avoid it for
subsequent searches. This can be done with a [`memmem::Finder`]:
```
use memchr::memmem;
let finder = memmem::Finder::new("foo");
assert_eq!(Some(4), finder.find(b"baz foo quux"));
assert_eq!(None, finder.find(b"quux baz bar"));
```
# Why use this crate?
At first glance, the APIs provided by this crate might seem weird. Why provide
a dedicated routine like `memchr` for something that could be implemented
clearly and trivially in one line:
```
fn memchr(needle: u8, haystack: &[u8]) -> Option<usize> {
haystack.iter().position(|&b| b == needle)
}
```
Or similarly, why does this crate provide substring search routines when Rust's
core library already provides them?
```
fn search(haystack: &str, needle: &str) -> Option<usize> {
haystack.find(needle)
}
```
The primary reason for both of them to exist is performance. When it comes to
performance, at a high level at least, there are two primary ways to look at
it:
* **Throughput**: For this, think about it as, "given some very large haystack
and a byte that never occurs in that haystack, how long does it take to
search through it and determine that it, in fact, does not occur?"
* **Latency**: For this, think about it as, "given a tiny haystack---just a
few bytes---how long does it take to determine if a byte is in it?"
The `memchr` routine in this crate has _slightly_ worse latency than the
solution presented above, however, its throughput can easily be over an
order of magnitude faster. This is a good general purpose trade off to make.
You rarely lose, but often gain big.
**NOTE:** The name `memchr` comes from the corresponding routine in `libc`. A
key advantage of using this library is that its performance is not tied to its
quality of implementation in the `libc` you happen to be using, which can vary
greatly from platform to platform.
But what about substring search? This one is a bit more complicated. The
primary reason for its existence is still indeed performance, but it's also
useful because Rust's core library doesn't actually expose any substring
search routine on arbitrary bytes. The only substring search routine that
exists works exclusively on valid UTF-8.
So if you have valid UTF-8, is there a reason to use this over the standard
library substring search routine? Yes. This routine is faster on almost every
metric, including latency. The natural question then, is why isn't this
implementation in the standard library, even if only for searching on UTF-8?
The reason is that the implementation details for using SIMD in the standard
library haven't quite been worked out yet.
**NOTE:** Currently, only `x86_64`, `wasm32` and `aarch64` targets have vector
accelerated implementations of `memchr` (and friends) and `memmem`.
# Crate features
* **std** - When enabled (the default), this will permit features specific to
the standard library. Currently, the only thing used from the standard library
is runtime SIMD CPU feature detection. This means that this feature must be
enabled to get AVX2 accelerated routines on `x86_64` targets without enabling
the `avx2` feature at compile time, for example. When `std` is not enabled,
this crate will still attempt to use SSE2 accelerated routines on `x86_64`. It
will also use AVX2 accelerated routines when the `avx2` feature is enabled at
compile time. In general, enable this feature if you can.
* **alloc** - When enabled (the default), APIs in this crate requiring some
kind of allocation will become available. For example, the
[`memmem::Finder::into_owned`](crate::memmem::Finder::into_owned) API and the
[`arch::all::shiftor`](crate::arch::all::shiftor) substring search
implementation. Otherwise, this crate is designed from the ground up to be
usable in core-only contexts, so the `alloc` feature doesn't add much
currently. Notably, disabling `std` but enabling `alloc` will **not** result
in the use of AVX2 on `x86_64` targets unless the `avx2` feature is enabled
at compile time. (With `std` enabled, AVX2 can be used even without the `avx2`
feature enabled at compile time by way of runtime CPU feature detection.)
* **logging** - When enabled (disabled by default), the `log` crate is used
to emit log messages about what kinds of `memchr` and `memmem` algorithms
are used. Namely, both `memchr` and `memmem` have a number of different
implementation choices depending on the target and CPU, and the log messages
can help show what specific implementations are being used. Generally, this is
useful for debugging performance issues.
* **libc** - **DEPRECATED**. Previously, this enabled the use of the target's
`memchr` function from whatever `libc` was linked into the program. This
feature is now a no-op because this crate's implementation of `memchr` should
now be sufficiently fast on a number of platforms that `libc` should no longer
be needed. (This feature is somewhat of a holdover from this crate's origins.
Originally, this crate was literally just a safe wrapper function around the
`memchr` function from `libc`.)
ÁÈ«¼¦í¸À¹¤¸ì· ËÊ- ÏË.µ Úó-´ Ó ü.³ Ý
œ.² × ¶-± Í Þ-° Ñ
ç.¯ ܇.® Õ˜/­ ß·.¬ ÙäY«Ý´Zªç[©òØÛÞ„í=Õ”¥>ÊlÂ>¿Â´·©¬ž¡ˆ}rugj\_QTFI;>03%(T@4š@„”¡ ¥  « , ¬ ­ ´, ®8¯¯& ±8¯²
µ*¸ » + Å Æ ß8âÇ Ê Þ8» Ó7loggingÁ é , ÷ ø ü, ù8¯ú
ý”’ ¥ Ú « , ¬ ­ ´, ®8¯¯& ±8¯²
µ*¸ » Ø8®½ À Á Ö8®Â'Å8 Ì Í Õ, Î Ï Ó, Ð8¯Ñ
Ô”Ý ð ¥ ö , ÷ ø ÿ, ù8¯ú& ü8¯ý
*ƒ  £8®ˆ  Œ ¡8®'8¿,  ˜  ,  š ž, 8¯œ
ŸdÉ@ü ˜
A module with low-level architecture dependent routines.
These routines are useful as primitives for tasks not covered by the higher
level crate API.
Á$Ñ@Ô¤ ü»
Contains architecture independent routines.
These routines are often used as a "fallback" implementation when the more
specialized architecture dependent routines are unavailable.
Á§ {—ª²ÐÑÒÓü×
Ò
Provides architecture independent implementations of `memchr` and friends.
The main types in this module are [`One`], [`Two`] and [`Three`]. They are for
searching for one, two or three distinct bytes, respectively, in a haystack.
Each type also has corresponding double ended iterators. These searchers
are typically slower than hand-coded vector routines accomplishing the same
task, but are also typically faster than naive scalar code. These routines
effectively work by treating a `usize` as a vector of 8-bit lanes, and thus
achieves some level of data parallelism even without explicit vector support.
The `One` searcher also provides a [`One::count`] routine for efficiently
counting the number of times a single byte occurs in a haystack. This is
useful, for example, for counting the number of lines in a haystack. This
routine exists because it is usually faster, especially with a high match
count, than using [`One::find`] repeatedly. ([`OneIter`] specializes its
`Iterator::count` implementation to use this routine.)
Only one, two and three bytes are supported because three bytes is about
the point where one sees diminishing returns. Beyond this point and it's
probably (but not necessarily) better to just use a simple `[bool; 256]` array
or similar. However, it depends mightily on the specific work-load and the
expected match frequency.
Á wzãìùžÇ
Õ ½
Œ
+d‡ ÄÊ  ÄÍ  D¦{"#$&()+-.12¼Þ!!ìäüŽC@ Create a new searcher that finds occurrences of the byte given.Áë¦{!!
#€;4ïüÝ4ü²JG Return the first occurrence of the needle in the given haystack. If noÁü41 such occurrence exists, then `None` is returned.ÁºúüÂHE The occurrence is reported as an offset into `haystack`. Its maximumÁü;8 value for a non-empty haystack is `haystack.len() - 1`.Á$äŸ
 
 Ÿ
¦{  
øëÛ¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙ! é!
$ÖRDð$<closure_kind>Á%<closure_signature>Á%<upvars>Á%%$% ÆÆÛ¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙÆÆ ¦{üâ5ü¸IF Return the last occurrence of the needle in the given haystack. If noÁü†4ÌÁ¿úüÇH–Âü”;è¡
¢
 ¡
¦{ ¢
øëßÄ! ï!
&ÖRDö&éÄ'Å'žÅ''&'ÁÆ™Çü-ü¿>; Counts all occurrences of this byte in the given haystack.Á,—£
¤
 £
¦{ ¤
øë! !
(ÖRD¤ü°)süè 63 Like `find`, but accepts and returns raw pointers.Á£!úü«!C@ When a match is found, the pointer returned is guaranteed to beÁÜó! `>= start` and `< end`.Á“"úü›"IF This routine is useful if you're already using raw pointers and wouldÁüé"GD like to avoid converting back to a slice before executing a search.Áµ#úd½# # SafetyÁÎ#úüÖ#52 * Both `start` and `end` must be valid for reads.Áü$@= * Both `start` and `end` must point to an initialized value.ÁüÕ$HE * Both `start` and `end` must point to the same allocated object andÁü¢%DA must either be in bounds or at most one byte past the end of theÁ¬ë% allocated object.Áü…&IF * Both `start` and `end` must be _derived from_ a pointer to the sameÁ\Ó& object.Áüã&GD * The distance between `start` and `end` must not overflow `isize`.Áü¯'IF * The distance being in bounds must not rely on "wrapping around" theÁ”ý' address space.Á”(úüœ(KH Note that callers may pass a pair of pointers such that `start >= end`.Áüì(1. In that case, `None` will always be returned.ÁD¾)¥
 ¥
¦{ÆÆÆÆÍÆ! Ð)!
)$Ñ)¹,ß)þù)ù*)éÄ*Å*žÅ**)*™Çü¸?tüï674 Like `rfind`, but accepts and returns raw pointers.Á«7úü³7CøÊÜû7ÄË›8úü£8IõËüñ8GÈ̽9údÅ9¤ÍÖ9úüÞ95ÆÍü˜:@…ÎüÝ:HÏÎüª;D¡Ï¬ó;îÏü<IÐ\Û<ßÐüë<GôÐü·=IÅÑ”…>—Òœ>úü¤>K¿Òüô>1”ÓLÆ?¦
 ¦
¦{ÆÆÆÆÍÆ! Ù?!
+$Ú?¹,è?þ‚@‚A+éÄ,Å,žÅ,,+,õÕ™ÇüQIüœIIF Counts all occurrences of this byte in the given haystack representedÁ¤êI by raw pointers.ÁƒJúü‹JIõËüÙJGÈÌ¥Kúd­K¤Í¾KúüÆK5ÆÍü€L@…ÎüÅLHÏÎü’MD¡Ï¬ÛMîÏüõMIÐ\ÃNßÐüÓNGôÐüŸOIÅÑ”íO—Ò„PúüŒPK¿ÒüÜP.+ In that case, `0` will always be returned.ÁL«Q§
 §
¦{ÆÆÆÆ! µQ!
-$¶Q¹,¼QþÎQüþVDü†UFC Returns an iterator over all occurrences of the needle byte in theÁœÑU given haystack.ÁéUúüñUIF The iterator returned implements `DoubleEndedIterator`. This means itÁü¿V:7 can also be used to find occurrences in reverse order.Á$…W/0 /¦{ 0øëììíCïò2ð”D³«KiŠWÿ/0!ŠW!
.$WÖRDœWŽWü«X*T®X¨
 ¨
¦{! ¹X!
1$ºXchunkÁ,ÀXü Y,<£Y©
 ©
¦{! «Y!
2$¬Y
haystack_byteÁl²Yüõ^)4554ƒ|679;úMûM€NÿM97;ú^þ^L¥_$ª_33üË_#$Î_ª
 ª
ƒ|ßÄ3 Ó_3
7$Ø_4ða7éÄ8Å8žÅ8878ÁƙǼ°b,³bƒ|33
9$¹b4àb9éÄ:Å:žÅ::9:ÄÆ™Çü°d-L³d«
 «
ƒ|ßÄ3 ½d3
;$¾dü…e4=>>=ƒ|?M?ŠeŽeüÎe(LÑe¬
 ¬
ƒ|ßÄ< Ûe<
?$àe4þg?éÄ@Å@žÅ@@?@ÁÆ™ÇDþjì|BCEGIKNOü÷k+ükHE Create a new searcher that finds occurrences of the two needle bytesÁTÚk given.Áþkì|AA
B<l£<lüÿr4üÇpGD Return the first occurrence of one of the needle bytes in the givenÁü“qDA haystack. If no such occurrence exists, then `None` is returned.ÁÜqúüäqH–Âü±r;èÂ$†s­
®
 ­
ì| ®
øëßÄA ‹sA
C$ŒsÖRDs4‰uCéÄDÅDžÅDDCDÁÆ ì|ü‘x5üÚuFC Return the last occurrence of one of the needle bytes in the givenÁü¥vDˆëîvúüövH–ÂüÃw;èÂ,˜x¯
°
 ¯
ì| °
øëßÄA žxA
E$ŸxÖRD¥x4œzEéÄFÅFžÅFFEFÁƬîü¶ƒsüîz6¬Ê©{úü±{CøÊÜù{ÄË™|úü¡|IõËüï|GÈÌ»}údÃ}¤ÍÔ}úüÜ}5ÆÍü–~@…ÎüÛ~HÏÎü¨D¡Ï¬ñîÏü‹€IÐ\Ù€ßÐüé€GôÐüµIÅÑ”ƒ‚—Òš‚úü¢‚K¿Òüò‚1”ÓDă±
 ±
ì|ÆÆÆÆÍÆA ÖƒA
G$׃¹,åƒþÿƒÿ„GéÄHÅHžÅHHGHõÕ¬îüð—tü§7”ÕãúüëCøÊܳÄËÓúüÛIõËü©‘GÈÌõ‘údý‘¤ÍŽ’úü–’5ÆÍüÐ’@…Îü•“HÏÎüâ“D¡Ï¬«”îÏüÅ”IÐ\“•ßÐü£•GôÐüï•IÅÑ”½–—ÒÔ–úüÜ–K¿Òü¬—1”ÓLþ—²
 ²
ì|ÆÆÆÆÍÆA ‘˜A
I$’˜¹, ˜þº˜º™IéÄJÅJžÅJJIJõÕ¬îü„¢Dü„ JG Returns an iterator over all occurrences of one of the needle bytes inÁ¼Ó  the given haystack.Áï úü÷ I­ÞüÅ¡:€ß$‹¢LM Lì| Møë£Eò2ˆ”D
ãËž”çLMA¢A
K$œ¢ÖRD¢¢ ”¢ü±£*T´£³
 ³
ì|A ¿£A
N$À£½á,Æ£üȤ,<ˤ´
 ´
ì|A Ó¤A
O$Ô¤œâlÚ¤ü¾ª)QRQRß}STVúMûMÿMVTêǪLîª$óªPPü”«#$—«µ
 µ
ß}ßÄP œ«P
T$¡«4¹­TéÄUÅUžÅUUTUÁƬîüù­-Lü­
 
ß}²çP †®P
V$‡®üή4XYXYß}ZMZÓ®×®ü—¯(Lš¯·
 ·
ß}ßÄW ¤¯W
Z$©¯4DZZéÄ[Å[žÅ[[Z[ÁƬîT÷´È~]^`bdfijüôµ:üˆµJG Create a new searcher that finds occurrences of the three needle bytesÁT×µÛéûµÈ~\\
]<ÿµ£<Œ¶ÿ<™¶üÿ½4üÇ»G·êü“¼Dˆëܼúüä¼H–Âü±½;èÂ$†¾¸
¹
 ¸
È~ ¹
øëßÄ\ ‹¾\
^$Œ¾ÖRD’¾4‰À^éÄ_Å_žÅ__^_ÁÆ È~ü‘Ã5üÚÀFÃíü¥ÁDˆëîÁúüöÁH–ÂüÃÂ;èÂ,˜Ãº
»
 º
È~ »
øëßÄ\ žÃ\
`$ŸÃÖRD¥Ã4œÅ`éÄaÅažÅaa`aÁÆ“†ü¶ÎsüîÅ6¬Ê©Æúü±ÆCøÊÜùÆÄË™Çúü¡ÇIõËüïÇGÈÌ»ÈúdÃȤÍÔÈúüÜÈ5ÆÍü–É@…ÎüÛÉHÏÎü¨ÊD¡Ï¬ñÊîÏü‹ËIÐ\ÙËßÐüéËGôÐüµÌIÅÑ”ƒÍ—ÒšÍúü¢ÍK¿ÒüòÍ1”ÓDÄμ
 ¼
È~ÆÆÆÆÍÆ\ ÖÎ\
b$×ι,åÎþÿÎÿÏbéÄcÅcžÅccbcõÕ“†üðâtü§Ú7”ÕãÚúüëÚCøÊܳÛÄËÓÛúüÛÛIõËü©ÜGÈÌõÜúdýܤ͎Ýúü–Ý5ÆÍüÐÝ@…Îü•ÞHÏÎüâÞD¡Ï¬«ßîÏüÅßIÐ\“àßÐü£àGôÐüïàIÅÑ”½á—ÒÔáúüÜáK¿Òü¬â1”ÓLþâ½
 ½
È~ÆÆÆÆÍÆ\ ‘ã\
d$’ã¹, ãþºãºädéÄeÅežÅeedeõÕ“†ü„íFü„ëJ™ø¼Óëíøïëúü÷ëI­ÞüÅì:€ß$‹ígh gÈ~ høëžžéF¡ò2¢”DÃT·Ù¦b`gh\í\
f$œíÖRD¢í ”íüµî*T¸î¾
 ¾
È~\ Ãî\
i$Äî½á,Êîü†ð,<‰ð¿
 ¿
È~\ ‘ð\
j$’ðœâl˜ðüºö+lmmlÑnoqúMûMÿMqo¿öÃöLìö$ñökkü’÷#$•÷À
 À
ÑßÄk š÷k
o$Ÿ÷4·ùoéÄpÅpžÅppopÁÆ“†ü÷ù-LúùÁ
 Á
Ѳçk „úk
q$…úüÌú6ststÑuMuÑúÕúü—û(LšûÂ
 Â
ÑßÄr ¤ûr
u$©û4ÇýuéÄvÅvžÅvvuvÁÆ“†üèÿ"lëÿ
wà ùÿ¾áôÁ„,Ê„¸­]”ÍüÖÑ
Provides an architecture independent implementation of the "packed pair"
algorithm.
The "packed pair" algorithm is based on the [generic SIMD] algorithm. The main
difference is that it (by default) uses a background distribution of byte
frequencies to heuristically select the pair of bytes to search for. Note that
this module provides an architecture independent version that doesn't do as
good of a job keeping the search for candidates inside a SIMD hot path. It
however can be good enough in many circumstances.
[generic SIMD]: http://0x80.pl/articles/simd-strfind.html#first-and-last
Á}µ«ìÈ{|ì Ë{|(„ì{~ü $‰×\ º€ƒü”
+üŸ JG Create a new prefilter that reports possible locations where the givenÁœî  needle matches.Á
Ã
 Ã
øëÛ¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙº€ §

€;4Ÿ
ü”=üƒ0- Create a new prefilter using the pair given.Á¸úüÀGD If the prefilter could not be constructed, then `None` is returned.ÁŒúü”GD This constructor permits callers to control precisely which pair ofÁüà! bytes is used as a predicate.ÁLÄ
 Ä
øë¥Å¡ ­
€;4¥üÇ>üù96 Run this finder on the given haystack as a prefilter.Á·úü¿JG If a candidate match is found, then an offset where the needle *could*ÁüŽ&# begin in the haystack is returned.ÁtÎÅ
Æ
 Å
º€ Æ
øëßÄ Ý
ƒÖRDä$“ƒéÄŞŃ  º€Ü… üÐDA Returns the pair of offsets (into the needle) used to check as aÁü™GD predicate before confirming whether a needle exists at a particularÁ
position.Á$Œ Ç
 Ç
º€ Ç
¥ 
$’ L‡+¥ˆŠŒüì-)ü—+74 Create a new pair of offsets from the given needle.ÁÓ+úüÛ+EB If a pair could not be created (for example, if the needle is tooÁü¥,$! short), then `None` is returned.ÁÎ,úüÖ,A> This chooses the pair in the needle that is believed to be asÁüœ-=: predictive of an overall match of the needle as possible.Áó-È
 È
øëÛ¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙ¥ ÿ-
€;4÷-üà2nüÛ.B? Create a new pair of offsets from the given needle and ranker.Á¢/úüª/IF This permits the caller to choose a background frequency distributionÁüø/HE with which bytes are selected. The idea is to select a pair of bytesÁüÅ0FC that is believed to strongly predict a match in the haystack. ThisÁü1B? usually means selecting bytes that occur rarely in a haystack.Á×1úüß1Eïªü©2$¾«\ç2É
 É
øë£«®£ Ÿ3Í숳 ó2ˆ³´ö2
ˆˆ³€;4—3rankerÁ4®335üÑDiü»>C@ Create a new pair using the offsets given for the needle given.Áƒ?úü‹?HE This bypasses any sort of heuristic process for choosing the offsetsÁüØ?<9 and permits the caller to choose the offsets themselves.Á™@úü¡@GD Indices are limited to valid `u8` values so that a `Pair` uses lessÁüí@JG memory. It is not possible to create a `Pair` with offsets bigger thanÁü¼AIF `u8::MAX`. It's likely that such a thing is not needed, but if it is,ÁüŠBEB it's suggested to build your own bespoke algorithm because you'reÁüÔBJG likely working on a very niche case. (File an issue if this suggestionÁü£C  does not make sense to you.)ÁÈCúüÐCEïªüšD$¾«dØDÊ
 Ê
øë«® öD
Š€;4îD×4…Eå4™EÔ÷Jü»J)& Returns the first offset of the pair.Á4þJË
 Ë
¥ …K
$†KÔðKü³K*' Returns the second offset of the pair.Á4÷KÌ
 Ì
¥ þK
Œ$ÿKüÚd üªLOL This trait allows the user to customize the heuristic used to determine theÁüúLEB relative frequency of a given byte in the dataset being searched.ÁÀMúüÄMMJ The use of this trait can have a dramatic impact on performance dependingÁü’NOL on the type of data being searched. The details of why are explained in theÁüâNOL docs of [`crate::memmem::Prefilter`]. To summarize, the core algorithm usesÁü²OMJ a prefilter to quickly identify candidate matches that are later verifiedÁü€PIF more slowly. This prefilter is implemented in terms of trying to findÁüÊPKH `rare` bytes at specific offsets that will occur less frequently in theÁü–QMJ dataset. While the concept of a `rare` byte is similar for most datasets,ÁüäQHE there are some specific datasets (like binary executables) that haveÁü­RMJ dramatically different byte distributions. For these datasets customizingÁüûRNK the byte frequency heuristic can have a massive impact on performance, andÁüÊS*' might even need to be done at runtime.ÁõSúüùSIF The default implementation of `HeuristicFrequencyRank` reads from theÁüÃTLI static frequency table defined in `src/memmem/byte_frequencies.rs`. ThisÁüUMJ is optimal for most inputs, so if you are unsure of the impact of using aÁüÞUMJ custom `HeuristicFrequencyRank` you should probably just use the default.Á¬Vúl°V
# ExampleÁ¾Vú<ÂV ```ÁŒÊV use memchr::{ÁüÜV63 arch::all::packedpair::HeuristicFrequencyRank,Áô“W memmem::FinderBuilder,Á4²W };Á¹Wúü½WLI /// A byte-frequency table that is good for scanning binary executables.Á”ŠX struct Binary;ÁXúü¡X,) impl HeuristicFrequencyRank for Binary {ÁüÎX(% fn rank(&self, byte: u8) -> u8 {Áü÷X&# const TABLE: [u8; 256] = [ÁüžYMJ 255, 128, 61, 43, 50, 41, 27, 28, 57, 15, 21, 13, 24, 17, 17,ÁüìYJG 89, 58, 16, 11, 7, 14, 23, 7, 6, 24, 9, 6, 5, 9, 4, 7, 16,Áü·ZLI 68, 11, 9, 6, 88, 7, 4, 4, 23, 9, 4, 8, 8, 5, 10, 4, 30, 11,Áü„[>; 9, 24, 11, 5, 5, 5, 19, 11, 6, 17, 9, 9, 6, 8,ÁüÃ[NK 48, 58, 11, 14, 53, 40, 9, 9, 254, 35, 3, 6, 52, 23, 6, 6, 27,Áü’\FC 4, 7, 11, 14, 13, 10, 11, 11, 5, 2, 10, 16, 12, 6, 19,ÁüÙ\NK 19, 20, 5, 14, 16, 31, 19, 7, 14, 20, 4, 4, 19, 8, 18, 20, 24,Áü¨]C@ 1, 25, 19, 58, 29, 10, 5, 15, 20, 2, 2, 9, 4, 3, 5,Áüì]MJ 51, 11, 4, 53, 23, 39, 6, 4, 13, 81, 4, 186, 5, 67, 3, 2, 15,Áüº^<9 0, 0, 1, 3, 2, 0, 0, 5, 0, 0, 0, 2, 0, 0, 0,Áü÷^LI 12, 2, 1, 1, 3, 1, 1, 1, 6, 1, 2, 1, 3, 1, 1, 2, 9, 1, 1, 0,ÁüÄ_41 2, 2, 4, 4, 11, 6, 7, 3, 6, 9, 4, 5,Áüù_LI 46, 18, 8, 18, 17, 3, 8, 20, 16, 10, 3, 7, 175, 4, 6, 7, 13,ÁüÆ`=: 3, 7, 3, 3, 1, 3, 3, 10, 3, 1, 5, 2, 0, 1, 2,Áü„aNK 16, 3, 5, 1, 6, 1, 1, 2, 58, 20, 3, 14, 12, 2, 1, 3, 16, 3, 5,ÁüÓa:7 8, 3, 1, 8, 6, 17, 6, 5, 3, 8, 6, 13, 175,ÁtŽb ];Áüb  TABLE[byte as usize]ÁL¾b,ÈbüÎb52 // Create a new finder with the custom heuristic.Áü„c%" let finder = FinderBuilder::new()Áüªc@= .build_forward_with_ranker(Binary, b"\x00\x00\xdd\xdd");Áüëc)& // Find needle with custom heuristic.Áü•d<9 assert!(finder.find(b"\x00\x00\x00\xdd\xdd").is_some());Á<ÒdÊÇ´ädÎìüÚdû¾Ù¾Ù ŽŽŽü´hüeGD Return the heuristic frequency rank of the given byte. A lower rankÁüÍeHE means the byte is believed to occur less frequently in the haystack.Ášfúü¢fKH Some uses of this heuristic may treat arbitrary absolute rank values asÁüòfHE significant. For example, an implementation detail in this crate mayÁü¿gJG determine that heuristic prefilters are inappropriate if every byte inÁüŽh! the needle has a "high" rank.Á$·hÍ
 Í
ÆÙ ¼h
ŽÆÙ$½hbyteÁ$Ãhü¡i&¤³i…‚¢"žÕ/*…‚üÊi4…‚Žô…j$ˆjÎ
 Î
…‚ j
$Žj©Ý$”jüÐkQüãjLI This permits passing any implementation of `HeuristicFrequencyRank` as aÁü°k borrowed version of itself.Á£Í츂 Ùk¸‚´Šl²‚ŽÕk)+ô¨l$«lÏ
 Ï
²‚ °l
¸‚$±l©Ý$·lŒáüÊÅ
An implementation of the [Rabin-Karp substring search algorithm][rabinkarp].
Rabin-Karp works by creating a hash of the needle provided and then computing
a rolling hash for each needle sized window in the haystack. When the rolling
hash matches the hash of the needle, a byte-wise comparison is done to check
if a match exists. The worst case time complexity of Rabin-Karp is `O(m *
n)` where `m ~ len(needle)` and `n ~ len(haystack)`. Its worst case space
complexity is constant.
The main utility of Rabin-Karp is that the searcher can be constructed very
quickly with very little memory. This makes it especially useful when searching
for small needles in small haystacks, as it might finish its search before a
beefier algorithm (like Two-Way) even starts.
[rabinkarp]: https://en.wikipedia.org/wiki/Rabin%E2%80%93Karp_algorithm
Á¡©¾ÅÆÌÍ<¿½˜œ³Æ‚šœüò #üÖDA Create a new Rabin-Karp forward searcher for the given `needle`.ÁŸúü§KH The needle may be empty. The empty needle matches at every byte offset.Á÷úüÿIF Note that callers must pass the same needle to all search calls usingÁ”Í  this `Finder`.Áù Ð
 Ð
øëÆ‚ …!
š€;4ý ü™(Cü¡$A> Return the first occurrence of the `needle` in the `haystack`Áüç$A> given. If no such occurrence exists, then `None` is returned.Á­%úüµ%GD The `needle` provided must match the needle given to this finder atÁ´& construction time.Áœ&úü¤&IF The maximum value this can return is `haystack.len()`, which can onlyÁüò&HE occur when the needle and haystack both have length zero. Otherwise,Áü¿'GD for non-empty haystacks, the maximum value is `haystack.len() - 1`.Á$ (Ñ
Ò
Ó
 Ñ
Æ‚ Ò
øë Ó
øëßÄ ¥(
$¦(ÖRD¬(€;4½(ü‡6©ü¬+6¬Êç+úüï+CøÊü·,IF `>= start` and `<= end`. The pointer returned is only ever equivalentÁü…-GD to `end` when both the needle and haystack are empty. (That is, theÁüÑ-+( empty string matches the empty string.)Á.úü‰.IõËü×.GÈÌ£/úd«/¤Í¼/úüÄ/KH Note that `start` and `end` below refer to both pairs of pointers givenÁü”0JG to this routine. That is, the conditions apply to both `hstart`/`hend`ÁÄã0 and `nstart`/`nend`.Á€1úüˆ15ÆÍüÂ1@…Îü‡2HÏÎüÔ2D¡Ï¬3îÏü·3IÐ\…4ßÐü•4GôÐüá4IÅÑ”¯5—ÒüÆ5.+ * It must be the case that `start <= end`.ÁD•6Ô
 Ô
Æ‚ÆÆÆÆÆÆÆÆÍÆ §6
œ$¨6hstartÁ4¶6hendÁ$Ñ6nstartÁ4ê6nendÁ$…7tñ<’ƒžŸ üÝ=&ü†=DA Create a new Rabin-Karp reverse searcher for the given `needle`.Áä=Õ
 Õ
øë’ƒ ð=
ž€;4è=üšEDü£A@= Return the last occurrence of the `needle` in the `haystack`ÁüèAAÛì®Búü¶BG²í´‚C‚îCúü¥CI®îüóCHïüÀDGÓï,¡EÖ
×
Ø
 Ö
’ƒ ×
øë Ø
øëßÄ §E
Ÿ$¨EÖRD®E€;4¿Eü‹Sªü¯H7”ÕëHúüóHCøÊü»IIÖñü‰JG©òüÕJ+úò…KúüKIõËüÛKGȨ̀Lúd¯L¤ÍÀLúüÈLKüóü˜MJÑôÄçM¤õ„NúüŒN5ÆÍüÆN@…Îü‹OHÏÎüØOD¡Ï¬¡PîÏü»PIÐ\‰QßÐü™QGôÐüåQIÅÑ”³R—ÒüÊR.ÛöL™SÙ
 Ù
’ƒÆÆÆÆÆÆÆÆÍÆ ¬S
 $­Sæ÷4»Sô÷$ÖS€ø4ïSŽø$ŠTüÛY><éYÚ
Û
 Ú
øë Û
øë ûY
¡ÖRDñY_needleÁ<ZL÷[Öƒ£¤¥¦§¨„Ù\Ü\Öƒ¢¢
£üÔ^?<Þ^ÆÆÆÆÖƒ¢¢
¤¹,ê^þü^ü‹b?<•bÆÆÆÆÖƒ¢¢
¥¹,bþ³bü†f5$‰fÜ
Ý
 Ü
Öƒ Ý
Æ‚¢ Žf¢
¦$“f»]4™foldÁªfæ ³fܶg¹gÞ
 Þ
Öƒ¢ ½g¢
§$Âg©Ý$ÈgüÊi,Íiß
à
 ß
Öƒ à
Æ‚¢ Ñi¢
¨$Öi»]4Üi©Ý$íiü¤nDd®nÆÆÆÆ
©Ã »nÄ Én¹ ×nü
An implementation of the [Shift-Or substring search algorithm][shiftor].
[shiftor]: https://en.wikipedia.org/wiki/Bitap_algorithm
Á»¤ŒúÌô<–¬Ü×몫ŒL—ªâ„®¯±ÜÖª­­üÁ+ü”B? Create a new Shift-Or forward searcher for the given `needle`.ÁÛúüãKëéÈá
 á
øëÛ¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙâ„­ Ô­
¯€;4ÌÊ ¯¯üÚ4üý GD Return the first occurrence of the needle given to `Finder::new` inÁüÉ
FC the `haystack` given. If no such occurrence exists, then `None` isÁl”
returned.Á¦úü®JG Unlike most other substring search implementations in this crate, thisÁüýJG finder does not require passing the needle at search time. A match canÁüÌJG be determined without the needle at all since the required informationÁü›=: is already encoded into this finder at construction time.ÁÝúüåI®îü³Hïü€GÓïâ
ã
 â
â„ ã
øëßÄ­ æ­
±ÖRDíüž 
An implementation of the [Two-Way substring search algorithm][two-way].
[`Finder`] can be built for forward searches, while [`FinderRev`] can be built
for reverse searches.
Two-Way makes for a nice general purpose substring search algorithm because of
its time and space complexity properties. It also performs well in practice.
Namely, with `m = len(needle)` and `n = len(haystack)`, Two-Way takes `O(m)`
time to create a finder, `O(1)` space and `O(n)` search time. In other words,
the preprocessing step is quick, doesn't require any heap memory and the worst
case search time is guaranteed to be linear in the haystack regardless of the
size of the needle.
While vector algorithms will usually beat Two-Way handedly, vector algorithms
also usually have pathological or edge cases that are better handled by Two-Way.
Moreover, not all targets support vector algorithms or implementations for them
simply may not exist yet.
Two-Way can be found in the `memmem` implementations in at least [GNU libc] and
[musl].
[two-way]: https://en.wikipedia.org/wiki/Two-way_string-matching_algorithm
[GNU libc]: https://www.gnu.org/software/libc/
[musl]: https://www.musl-libc.org/
Áâãëìôþަ§ª ²³ в¡ Ѳ·êað Í ²¸˜Y,´ ´´ NP=?\è 0\&£…º»¼½¾üö'#ü£&C@ Create a searcher that finds occurrences of the given `needle`.Áë&úüó&IF An empty `needle` results in a match at every position in a haystack,ÁüÁ'" including at `haystack.len()`.Áý'ä
 ä
øë£…¹ ‰(¹
º€;4(üÖ/Cüà,HE Returns the first occurrence of `needle` in the given `haystack`, orÁü­-0- `None` if no such occurrence could be found.Áâ-úüê-C@ The `needle` given must be the same as the `needle` provided toÁ¤². [`Finder::new`].ÁË.úüÓ.IÉ›ü¡/"œœ$Ý/å
æ
ç
 å
£… æ
øë ç
øëßĹ â/¹
»$ã/ÖRDé/€;4ú/ü„5–œ’5è
é
ê
ë
 è
£…Û¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙÍ Í êaÏ ýa¤Ð É]¤íRtš¡é
ê
øë ë
øëßĹ ¯5¹
¼$°5preÁ¾5ÖRDÜ5€;4õ5ü¶;¡t¹;²ì
í
î
ï
 ì
£…Û¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙÍ Í êaÏ ýa¤Ð É]¤íRtš¡í
î
øë ï
øëßĹ Ñ;¹
½$Ò;Ê¢ä;ÖRD<€;4<ÚL4²<üëH tîH²ð
ñ
ò
ó
 ð
£…Û¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙÍ Í êaÏ ýa¤Ð É]¤íRtš¡ñ
ò
øë ó
øëßĹ †I¹
¾$‡IÊ¢™IÖRD·I€;4ÐIL,çItúSý…ÀÁÂÃüâU&üTCðš×TúüßTIÉ›ü­U"œœéUô
 ô
øëý…¿ õU¿
À€;4íUüÊ]DüÒZGD Returns the last occurrence of `needle` in the given `haystack`, orÁüž[0ðÓ[úüÛ[C¶ž¼£\ [`FinderRev::new`].Á¿\úüÇ\IÉ›ü•]"œœ,Ñ]õ
ö
÷
 õ
ý… ö
øë ÷
øëßÄ¿ ×]¿
Á$Ø]ÖRDÞ]€;4ï]üëb€|îb²ø
ù
ú
 ø
ý… ù
øë ú
øëßÄ¿ ‡c¿
Â$ˆcÖRDc€;4¯cÚL4Æcüm|„m²û
ü
ý
 û
ý… ü
øë ý
øëßÄ¿ m¿
Ã$žmÖRD¬m€;4ÅmL,ÜmTÓ„ŇÅÆüå‡q<臲þ
 þ
øëŇÄ ˆÄ
Å€;4ù‡period_lower_boundÁ”ˆûKd³ˆüñŽq<ô޲ÿ
 ÿ
øëŇÄ Ä
Æ€;4…Ó®”œûKd¿\☳ˆÈÉüô˜5<÷˜²   øëôˆ³ˆÇ ‡™Ç
È€;4ÿ˜$Ž™ü›©5<ž©²   øëôˆ³ˆÇ ®©Ç
É€;4¦©$µ©|ÁôˆËüØÂ:Û²ôˆÒ‰ÊÊ
Ë$ßÂcurrentÁ<å candidateÁLò¤¡Ã¼ÜÉÀŠÎÏüªÊ+­Ê²   øëÀŠÍ ¹ÊÍ
΀;4±Êü–Í$D™Í²ƒ  ƒ ÀŠÍ ¢ÍÍ
Ï$£Í©Ý$©Íü‚8ü°C@ Returns true if and only if `needle` is a prefix of `haystack`.ÁôúüøNK This uses a latency optimized variant of `memcmp` internally which *might*ÁüÇ,) make this faster for very short strings.Áôú # InliningÁúü‹NK This routine is marked `inline(always)`. If you want to call this functionÁüÚLI in a way that is not always inlined, you'll need to wrap a call to it inÁü§HE another function that is marked as `inline(never)` or just `inline`.ÁL‰    øë  øë 
ÐÖRD“€;4¤üì
8üšC@ Returns true if and only if `needle` is a suffix of `haystack`.ÁÞúüâNœµü±,ôµÞúµ¶ñúüõNÙ¶üÄ L±·ü‘
H‡¸
    øë  øë 
ÑÖRDý
€;4Ž üû+ü• <9 Compare corresponding bytes in `x` and `y` for equality.ÁÒ úüÖ FC That is, this returns true if and only if `x.len() == y.len()` andÁü
.+ `x[i] == y[i]` for all `0 <= i < x.len()`.ÁÌ
ú
µ¶ß
úüã
NÙ¶ü²L±·üÿH‡¸Èú„Ì
# MotivationÁÝúüáOL Why not use slice equality instead? Well, slice equality usually results inÁü±MJ a call out to the current platform's `libc` which might not be inlineableÁüÿMJ or have other overhead. This routine isn't guaranteed to be a win, but itÁÜÍ might be in some cases.ÁDˆ   ˆ øë  øë Ž
ÒÃ Ä üÉcüÞ96 Compare `n` bytes at the given pointers for equality.Á˜úüœEB This returns true if and only if `*x.add(i) == *y.add(i)` for allÁŒâ `0 <= i < n`.Áôúµ¶úü‹NÙ¶üÚL±·ü§H‡¸ðú„ô¡¾úü‰OǾüÙM ¿ü§M÷¿ÜõÍÀúd•¤Í¢úü¦B? * Both `x` and `y` must be valid for reads of up to `n` bytes.Áüé:7 * Both `x` and `y` must point to an initialized value.Áü¤A> * Both `x` and `y` must each point to an allocated object andÁüæD¡Ïü«LI allocated object. `x` and `y` do not need to point to the same allocatedÁÌø object, but they may.Áü’KH * Both `x` and `y` must be _derived from_ a pointer to their respectiveÁ´Þ allocated objects.ÁüõMJ * The distance between `x` and `x+n` must not overflow `isize`. SimilarlyÁ´Ã for `y` and `y+n`.ÁüÚIÅÑ”¤—ÒÆÆÆÆ
Óà íÄ ƒ ¹ ´¬  Õ¬û¯»ÉÙ<»&½Õ×Â?DÑ&³ÕÙ>4Û&§ÕÚ,©&d¶&Dü©&%68%'´õ'§ÜÜÍìÔ‹ ú'§Ô‹4ý'š‹ÝÞßàáâä-/´à(Læ(ÕÛÛüê).ÿ)š‹ÛÛ
ÞÔ‹€;4ƒ*ü+"<«+Š  Š š‹Û ³+Û
ßÔ‹$´+ü±4zDÆ4   š‹ÆÆÆÆÍÆÛ Ø4Û
àÔ‹$Ù4¹,ç4þ5üíZ{L[Œ  Œ š‹ÆÆÆÆÍÆÛ •[Û
áÔ‹$–[¹,¤[þ¾[ü¡yoL¶y   š‹ÆÆÆÆÛ ÉyÛ
âÔ‹$Êy¹,ØyþòyúzâéÄãÅãžÅããâãÔ‹õÕ š‹üçŒÕŽ  Ž š‹ÆÆÝÍÆÛÝåå ÛÍìžÒ̾"žÒÔ‹ª¤ÃžÒéÒ˜"
äÔ‹žÒcurÁmask_to_offsetÁt®rt´­•§çç¨Ì ²•¹Ì4µ•÷‹èéêëìíî')´˜–Lž–Õææü¢—<·—÷‹ææ
éÔ‹<»—£<È—üÈ™"<Ö™   ÷‹æ Þ™æ
êÔ‹$ß™üÕš"<ãš   ÷‹æ ëšæ
ëÔ‹$ìšüñ£zD†¤   ÷‹ÆÆÆÆÍÆæ ˜¤æ
ìÔ‹$™¤¹,§¤þÁ¤üׯ{LìÆ   ÷‹ÆÆÆÆÍÆæ ÿÆæ
íÔ‹$€Ç¹,ŽÇþ¨ÇüšßŒd¤ßÕ   ÷‹ÆÆžÒÍÆæÝïï ºßæÌÒÌñßÞÒ¤ößüÒ,…à
îÔ‹žÒ$»ß©ÒÉßµÒtáß@BÄ›æ§ññ¨Ì  æ¹Ì4£æêŒòóôõö÷øù*,´ˆçLŽçÕððü’èj§èêŒðð
óÔ‹<´è£<Éèÿ<Þèü¦ë"<´ë   êŒð ¼ëð
ôÔ‹$½ëüµì"<Ãì
Vector algorithms for the `aarch64` target.
Áì¼Ë üÅ  ¥¢d4üJE
Algorithms for the `aarch64` target using 128-bit vectors via NEON.
Á$<¦tLüóî
This module defines 128-bit vector implementations of `memchr` and friends.
The main types in this module are [`One`], [`Two`] and [`Three`]. They are for
searching for one, two or three distinct bytes, respectively, in a haystack.
Each type also has corresponding double ended iterators. These searchers are
typically much faster than scalar routines accomplishing the same task.
The `One` searcher also provides a [`One::count`] routine for efficiently
counting the number of times a single byte occurs in a haystack. This is
useful, for example, for counting the number of lines in a haystack. This
routine exists because it is usually faster, especially with a high match
count, then using [`One::find`] repeatedly. ([`OneIter`] specializes its
`Iterator::count` implementation to use this routine.)
Only one, two and three bytes are supported because three bytes is about
the point where one sees diminishing returns. Beyond this point and it's
probably (but not necessarily) better to just use a simple `[bool; 256]` array
or similar. However, it depends mightily on the specific work-load and the
expected match frequency.
Á4TóôüŠŸ ¨«¥Ó’¦§ÇÕ¦©½¦ª>4ß §¦«üùW,Ÿ ¬§ KdÉ <t× -Dì
é­®¯°²´µ·¹»¼½¾ü¿
%üû
JG Create a new searcher that finds occurrences of the needle byte given.ÁÊ úüÒ KH This particular searcher is specialized to use neon vector instructionsÁü¢ &# that typically make it quite fast.ÁÍ úüÕ EB If neon is unavailable in the current environment, then `None` isÁ
ˆŒÆ
Û¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙ鬬
­€;4Ê
üö.üµEB Create a new finder specific to neon vectors and routines withoutÁüÿ$! checking that neon is available.Á¨ú¤ÍÁúüÉIF Callers must guarantee that it is safe to execute `neon` instructionsÁü— in the current environment.Á»úüÃFC Note that it is a common misconception that if one compiles for anÁüŽJG `x86_64` target, then they therefore automatically have access to neonÁüÝHE instructions. While this is almost always the case, it isn't true inÁ”ª 100% of cases.Ál„à 鬬
®€;4’ì•üÙEB Returns true when this implementation is available in the currentÁ„£
environment.Á¸úüÀEB When this is true, it is guaranteed that [`One::new`] will returnÁüŠFC a `Some` value. Similarly, when it is false, it is guaranteed thatÁüÕ*' `One::new` will return a `None` value.ÁúüŒHE Note also that for the lifetime of a single program, if this returnsÁüÙ)& true then it will always return true.Ádœ¬¬
¯üÿ4üàG·êü¬DˆëõúüýH–ÂüÊ" value is `haystack.len() - 1`.Á$†© ª  © é ª øëßĬ ¬
°ÖRD’4‰°éıűžÅ±±°±ÁÆ éüø 5üÚFÃíü¥DˆëîúüöH–Âüà "ÖŽ,ÿ « ¬  « é ¬ øëßĬ …!¬
²$†!ÖRDŒ!4„#²éijųžÅ³³²³ÁÆ»‘ü§$-üÖ#>úÈ,®$­ ®  ­ é ® øë¬ ´$¬
´$µ$ÖRD»$üÇ/süÿ&6¬Êº'úüÂ'CøÊÜŠ(Ä˪(úü²(IõËü€)GÈÌÌ)údÔ)¤Íå)úüí)5ÆÍü§*@…Îüì*HÏÎü¹+D¡Ï¬‚,îÏüœ,IÐ\ê,ßÐüú,GôÐüÆ-IÅÑ””.—Ò«.úü³.K¿Òüƒ/1”ÓDÕ/¯  ¯ éÆÆÆÆÍÆ¬ ç/¬
µ$è/¹,ö/þ0·2µéÄŞŵõÕ»‘üÚ=tü‘57”ÕÍ5úüÕ5CøÊÜ6Ä˽6úüÅ6IõËü“7GÈÌß7údç7¤Íø7úü€85ÆÍüº8@…Îüÿ8HÏÎüÌ9D¡Ï¬•:îÏü¯:IÐ\ý:ßÐü;GôÐüÙ;IÅÑ”§<—Ò¾<úüÆ<K¿Òü–=1”ÓLè=°  ° éÆÆÆÆÍÆ¬ û=¬
·$ü=¹,Š>þ¤>Ë@·éĸŸžÅ¸¸·¸õÕ»‘üÿJIü¦C74 Like `count`, but accepts and returns raw pointers.ÁâCúüêCIõËü¸DGÈÌ„EúdŒE¤ÍEúü¥E5ÆÍüßE@…Îü¤FHÏÎüñFD¡Ï¬ºGîÏüÔGIÐ\¢HßÐü²HGôÐüþHIÅÑ”ÌI—ÒãIúüëIK¿Òü»J1”ÓLK±  ± éÆÆÆÆ¬ —K¬
¹$˜K¹,žKþ°KÄM¹éĺźžÅºº¹ºõÕ»‘üŽTtl˜Tà ¦²  ² éÆÆÆÆÍÆ¬ ¯T¬
»$°T¹,¾TþØTü¤Yut®Yà ¦³  ³ éÆÆÆÆÍÆ¬ ÆY¬
¼$ÇY¹,ÕYþïYü»^itÅ^
A 128-bit vector implementation of the "packed pair" SIMD algorithm.
The "packed pair" algorithm is based on the [generic SIMD] algorithm. The main
difference is that it (by default) uses a background distribution of byte
frequencies to heuristically select the pair of bytes to search for.
[generic SIMD]: http://0x80.pl/articles/simd-strfind.html#first-and-last
ÁTdµ«¥TÓ’ H$¿µ üúB\ ¬®6œÅ'\Œ üÝ?< A "packed pair" finder that uses 128-bit vector operations.Áúü¡KH This finder picks two bytes that it believes have high predictive powerÁüíEB for indicating an overall match of a needle. Depending on whetherÁü³ JG `Finder::find` or `Finder::find_prefilter` is used, it reports offsetsÁüþ NK where the needle matches or could match. In the prefilter case, candidatesÁüÍ
>; are reported whenever the [`Pair`] of bytes given matches.Áâ”˜šœžŸ ¡ü+üž GD Create a new pair searcher. The searcher returned can either reportÁüê HE exact matches of `needle` or act as a prefilter and report candidateÁÔ·  positions of `needle`.ÁÖ úüÞ FC If neon is unavailable in the current environment or if a [`Pair`]Áü©
B? could not be constructed from the needle given, then `None` isÁ
ˆŒÎ  Î øëÛ¼ݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙâ” £
˜€;4›ü´=üÿDA Create a new "packed pair" finder using the pair of bytes given.ÁÈúüÐGâ¢üœ!³£ÂúüÊE¯ƒl”ˆŒÏ  Ï øë¥§ó Í
€;4ÅüÍ=à Ð  Ð øë¥â” î
š€;4æì±üùE’Š„ÃàŠØúüàGD When this is true, it is guaranteed that [`Finder::with_pair`] willÁü¬HE return a `Some` value. Similarly, when it is false, it is guaranteedÁüùIF that `Finder::with_pair` will return a `None` value. Notice that thisÁüÇKH does not guarantee that [`Finder::new`] will return a `Finder`. Namely,Áü—IF even when `Finder::is_available` is true, it is not guaranteed that aÁüå63 valid [`Pair`] can be found from the needle given.Á úü¨HåŒüõ)·
ü® Cüü52 Execute a search using neon vectors and routines.Áú # PanicsÁÏúü×DA When `haystack.len()` is less than [`Finder::min_haystack_len`].Á$µ Ñ Ò Ó  Ñ â” Ò øë Ó øëßÄ º 
œÖRDÁ €;4Ò üµ#>üƒ"5èú½"údÅ"²ûÖ"úüÞ"DÔût¼#Ô Õ  Ô â” Õ øëßÄ Ë#
$Ì#ÖRDÒ#üË(jLÕ(à Ö × Ø  Ö â” × øë Ø øëßÄ è(
ž$é(ÖRD÷(€;4)ü·-FœÁ-à Ù Ú  Ù â” Ú øëßÄ Õ-
Ÿ$Ö-ÖRDÜ-Üè/ü³.Dí§üü.G»¨lÈ/‹©$ï/Û  Û â” Û ¥ ô/
 $õ/üþ3'ü§0FC Returns the minimum haystack length that this `Finder` can search.Áò0úüú0JG Using a haystack with length smaller than this in a search will resultÁüÉ1FC in a panic. The reason for this restriction is that this finder isÁü”2HE meant to be a low-level component that is part of a larger substringÁüá2EB strategy. In that sense, it avoids trying to handle all cases andÁü«3@= instead only handles the cases that it can handle very well.Á„…4Ü  Ü â” –4
¡$—4¬C4R¤¥¦§¨©ªœê þ Þ  Ê, 8´& ˆ8¼,‰$ Ž, 8°$& 8¼,$ , 8¹& £8¼$ ©, «8þ¬& ¯8¼$ µ, · ¸ Ç, ¹8needlesÁ& Á8¼$ È É*Ì Ï Ü Ð Û+ Ú Û ø8âÜ ß ÷8ð ï7à   ¤8#8,”'8Ë$'Ÿ8'¨8à '®8ì', ¸8´¹% »8 Ï Ð õ7chose neon for {}ÁœÑ$ ä8Ô ï ð ô, ñ8´ò% ö8 debug_assertÁd„   ¥, 8´'8÷"d— £ ¤% ¦, æ8´ç'é8ð  ø , ù ú ƒ, û8˜ˆ$   , ˆ8°$‰  š, Ž8¹,$ , 8þ+ ® ¯ Ñ8â° ³ Ð8
´ · Ï8ð Ç7à  Û Õ8#é8'ò8Ë'ø8£ú'ý8ì4ÿ', 8´ˆ% Š8,™ ž Ÿ 70no neon feature available, using fallback for {}Áü±2$ ã8Ô þ ÿ ƒ, 8´$ % , ¡8´¢'¤8æ ¦ © ·, ª « ´, ¬8˜ˆ<­$ µ  ¸, ¹8° ¾ Ë, ¿8¹$ Å, Ç8þÈü÷ m
ÆÆÆÆÍÆ
¤n1Áœ
¹
þ¾
ü­ n ÆÆÆÆÍÆ
¥¿’Ó ¹ þõ üäzÆÆÆÆÍÆ
¦¿’Šn2Á¹þ¸ü¬{ÆÆÆÆÍÆ
§¿’Óó“ß¹þüö\‹ÆÆÆÆÍÆ
¨¿’œó“¨n3Á´¹þÖüÒÆÆÆÆÍÆ
©¿’ù󓾕¹,þ³ü¾`ÆÆÆÆ
ª¿’â¹þ<×@Û@ÅÆÏ­

 «¬L
ü°$
®®¼•¯°ê!ë!°µ


­­øëÄŠ
,
Ý  Ý ¼• Ý øë­ 
­
°$”
®
²²¼•³µ·Ë
ü H
®
 ¼•±´´±ÎìÏš ²
àÏšøë
³ÏšbytesÁ,Ë
46üú [
»¤ŒÌ
ÌÆ
Lˆ
ÉìÅÅÆ¤XȈ« ~Fìɳ¯I±±
µ®š,
ü— &
Þ  Þ ¼• Þ øë± ®
±

üí3
»¤Œ¿
̹

¼•ý›±±
·$†
„ò
¹¹†–º»÷
üŸ&
¦
 øë†–¸¸
º®š
ü°
»¤Œ‚
Ìü

ß  ß †– ß øë¸ À
¸
»
<à@ä@½Ä9 <J ½½¾Ùü9² ½¾Ù¾Ù¾¿¾¿¿¾ü‰0 D“ ÆÙÆÙ½½
¾ÆÙ originÁ4¢ ÜÎ  ÆÙ½½
¿ÆÙ äí ¥ÁÁÍìø– ò ÷–Âþ¿Âà ü3  ÷–÷–ÀÀ
Âø– Á  ÔÔ  ÷–ÀÀ
Ãø– Ô ¥Åű¢  †—ÆÇ¾¿ÇÆ ü±1  †—†—ÄÄ
Æø– Á  Ô¨ †—ÄÄ
Çø– Té@4í@ËÍÏÑÓÕ×ÙÚÜÝßÝçòRevÁ ‚®ÈÉÇ<: ÕÈÊ|  ü·; üD9 6 Search for the first occurrence of a byte in a slice.Á~ úü‚O L This returns the index corresponding to the first occurrence of `needle` inÁüÒM J `haystack`, or `None` if one is not found. If an index is returned, it isÁü 0 - guaranteed to be less than `haystack.len()`.ÁÑ úüÕ9 6 While this is semantically the same as something likeÁüN K `haystack.iter().position(|&b| b == needle)`, this routine will attempt toÁüÞL I use highly optimized vector operations that can be an order of magnitudeÁ¬«  faster (or more).ÁÁ ú ¨ÇÓ úü×I F This shows how to find the first position of a byte in a byte string.Á¡ ú ÊǼ­  use memchr::memchr;ÁÅ úüÉ* ' let haystack = b"the quick brown fox";Áüô0 - assert_eq!(memchr(b'k', haystack), Some(8));Á ÊÇ à  à øëßÄ Û
Ë€;4Å ÖRDÑ  ËéÄÌÅÌžÅÌÌËÌÁÆʨüä< üð8 5 Search for the last occurrence of a byte in a slice.Á© úü­ N K This returns the index corresponding to the last occurrence of `needle` inÁüü M ЧüÊ
0 á§û
úüÿ
9 §¨ü¹ O L `haystack.iter().rposition(|&b| b == needle)`, this routine will attempt toÁü‰ L ©¬Ö —ªì ú ¨Çþ úü‚
H E This shows how to find the last position of a byte in a byte string.ÁË
ú
ÊÇÄ×
 use memchr::memrchr;Áð
úüô
* ó«üŸ2 / assert_eq!(memrchr(b'o', haystack), Some(17));Á ÊÇ á  á øëßÄ 
Í€;4ó ÖRDÿ  ÍéÄÎÅΞÅÎÎÍÎÁÆʨüÞJ ü H E Search for the first occurrence of two possible bytes in a haystack.Áé úüíN K This returns the index corresponding to the first occurrence of one of theÁü¼M J needle bytes in `haystack`, or `None` if one is not found. If an index isÁüŠ@ = returned, it is guaranteed to be less than `haystack.len()`.ÁË úüÏ9 §¨ü‰O L `haystack.iter().position(|&b| b == needle1 || b == needle2)`, this routineÁüÙO L will attempt to use highly optimized vector operations that can be an orderÁü©"  of magnitude faster (or more).ÁÌ ú ¨ÇÞ úüâO L This shows how to find the first position of one of two possible bytes in aÁ
haystack.ÁÀ ú ÊÇÄÌ  use memchr::memchr2;Áå úüé* ó«ü”7 4 assert_eq!(memchr2(b'k', b'q', haystack), Some(4));Á ÊÇ â  â øëßÄ 
Ï £ ÖRD‡  ÏéÄÐÅОÅÐÐÏÐÁÆ̨̨üñ K ü²G D Search for the last occurrence of two possible bytes in a haystack.Áú úüþM J This returns the index corresponding to the last occurrence of one of theÁüÌM öµüš@ ͶÛ úüß9 §¨ü™H E `haystack.iter().rposition(|&b| b == needle1 || b == needle2)`, thisÁüâN K routine will attempt to use highly optimized vector operations that can beÁü±+ ( an order of magnitude faster (or more).ÁÝ ú ¨Çï úüóN K This shows how to find the last position of one of two possible bytes in aÁ ŒºÐ ú ÊÇÌÜ  use memchr::memrchr2;Áö úüú* ó«ü¥ 9 6 assert_eq!(memrchr2(b'k', b'o', haystack), Some(17));Á ÊÇ ã  ã øëßÄ ¥!
Ñ<! £<Ž! ÖRD! dî" ÑéÄÒÅÒžÅÒÒÑÒÁÆó½ü *j üÈ#J G Search for the first occurrence of three possible bytes in a haystack.Á“$ úü—$N žµüæ$M öµü´%@ Ͷõ% úüù%9 §¨ü³&R O `haystack.iter().position(|&b| b == needle1 || b == needle2 || b == needle3)`,Áü†'L I this routine will attempt to use highly optimized vector operations thatÁüÓ'2 / can be an order of magnitude faster (or more).Á†( úlŠ( ¨Ç˜( úüœ(O L This shows how to find the first position of one of three possible bytes inÁ|ì( a haystack.Áü( ú<€) ÊÇĈ)  use memchr::memchr3;Á¡) úü¥)* ó«üÐ)= : assert_eq!(memchr3(b'k', b'q', b'u', haystack), Some(4));Á<Ž* ÊÇ<§* ä  ä øëßÄ ñ*
Ó<´* £<Å* ÿ<Ö* ÖRDç* d», ÓéÄÔÅÔžÅÔÔÓÔÁÆ̨̨̨üö3k ü-I F Search for the last occurrence of three possible bytes in a haystack.Áç- úüë-M è½ü¹.M öµü‡/@ ͶÈ/ úüÌ/9 §¨ü†0S P `haystack.iter().rposition(|&b| b == needle1 || b == needle2 || b == needle3)`,ÁüÚ0L ÄÆü§12 šÇÚ1 úlÞ1 ¨Çì1 úüð1N K This shows how to find the last position of one of three possible bytes inÁ|¿2 ÓÈÏ2 ú<Ó2 ÊÇÌÛ2  use memchr::memrchr3;Áõ2 úüù2* ó«ü¤3? < assert_eq!(memrchr3(b'k', b'o', b'n', haystack), Some(17));Á<ä3 ÊÇDý3 å  å øëßÄ È4
Õ<4 £<œ4 ÿ<­4 ÖRD¾4 d“6 ÕéÄÖÅÖžÅÖÖÕÖÁÆÌÌüÓ8D üö6I F Returns an iterator over all occurrences of the needle in a haystack.ÁÀ7 úüÄ7I ­ÞüŽ8: €ß\Ú8 Ø ØøëÝÝäYßÈà”DÈñnpy5A©Øæ8
×€;4ê8 ÖRDö8 ü£:C ü¿9L I Returns an iterator over all occurrences of the needle in a haystack, inÁdŒ: reverse.Ádª: æ  æ øë‚®‚®Ÿ¥„®ùùBÿ=£“ Ž
ÝÝäYßÈà”DÈñnpy5A©æ  Í:
Ù€;4·: ÖRDÃ: üò<c ü”;J G Returns an iterator over all occurrences of the needles in a haystack.Áß; úüã;I ­Þü­<: €ßdù< Û Ûøëçç´ZéÈê£Èë”DÈc*KÛ†=
Ú<= £< = ÖRD±= #%üí>b üˆ>M J Returns an iterator over all occurrences of the needles in a haystack, inÁdÖ> ðÔlô> ç  ç øë‚®‚®Ÿ¥„®ùùBÿ=£“ Ž
çç´ZéÈê£Èë”DÈc*Kç  ³?
Ü<‡? £<˜? ÖRD©? üæAt üˆ@J ÑÖÓ@ úü×@I ­Þü¡A: €ßdíA Þ Þøëòò[ôÈõ£ÈöÿÈ÷”DȘ÷×f¼äËÞúA
Ý<ƒB £<”B ÿ<¥B ÖRD¶B +-üûCs ü–CM €ÙdäC ðÔl‚D è  è øë‚®‚®Ÿ¥„®ùùBÿ=£“ Ž
òò[ôÈõ£ÈöÿÈ÷”DȘ÷×f¼äËè  ÒD
ß<•D £<¦D ÿ<·D ÖRDÈD œÝI áá“—ââI üýK9 ü÷IF µÝœÂJ „ÞÚJ úüâJI ­Þü°K: €ß„L Àâ“—àà
â<ˆL ÖRD•L üµM ää“—åæèêúMûM€NÿMêèæºM LÜM $áM ããü‚N# $…N é  é “—ßÄã ŠN ã
æ$N 4öR æéÄçÅçžÅççæçÁÆʨ¼ÀS ,ÃS “—ãã
è$ÉS 4ðS èéÄéÅéžÅééèéñæʨüÀU- LÃU ê  ê “—²çã ÍU ã
ê$ÎU ü•V+ ìì“—íMíšV üÕV( LØV ë  ë “—ßÄë âV ë
í$çV 4úX íéÄîÅîžÅîîíîÁÆʨü­Y1 ðð“—²Y ¤ª^ òò†˜ó¯^ üÌ`G üÅ^G ŽÁœ‘_ „Þ©_ úü±_I ­Þüÿ_: €ßÓ` À↘ññ
ó<×` £<ä` ÖRDñ` ü¨b! õõ†˜ö÷ùúMûMÿM÷ù­b LÐb $Õb ôôüöb# $ùb ì  ì †˜ßÄô þb ô
÷$ƒc 4˜e ÷éÄøÅøžÅøø÷øÁÆó½üñe- Lôe í  í †˜²çô þe ô
ù$ÿe üÆf, ûû†˜üMüËf ü‡g( LŠg î  î †˜ßÄú ”g ú
ü$™g 4¸i üéÄýÅýžÅýýüýÁÆó½ü¢j2 ÿÿ†˜§j ¤³o …™¸o üÕq{ üÎoG ŽÁœšp „Þ²p úüºpI ­Þüˆq: €ßÜq Àâ…™
<éq £<þq ÿ<“r ÖRD¨r üús! …™ˆúMûMÿMˆÿs L¢t $§t ƒƒüÈt# $Ët ï  ï …™ßă Ðt ƒ
$Õt 4êv éÄÅžÅÁÆÌÌüñw- Lôw ð  ð …™²çƒ þw ƒ
ˆ$ÿw üÆx, ŠŠ…™MËx ü‡y( LŠy ñ  ñ …™ßÄ ”y 
$™y 4¸{ éČŌžÅŒŒŒÁÆÌÌü°|2 ŽŽ…™µ| üõ}f Tÿ} ÈÆÆÆÆÍÆ
€;4~ ¹,Ÿ~ þµ~ üó†g \ý† ÈÆÆÆÆÍÆ
€;4އ ¹,ž‡ þ´‡ üày  ÈÆÆÆÆÍÆ
 £<ŒŽ ¹,Ž þ³Ž ü••z dŸ• ÈÆÆÆÆÍÆ
<±• £<• ¹,Ó• þé• ü朊 \ðœ ÈÆÆÆÆÍÆ
< £< ÿ ¹ þÊ ü™¥ d£¥ ÈÆÆÆÆÍÆ
<µ¥ £<Æ¥ ÿ<×¥ ¹,è¥ þþ¥ üß­J Lé­ ÈÆÆÆÆ
€;4ó­ ¹,ÿ­ þ‘® tõ@üü÷
This module provides forward and reverse substring search routines.
Unlike the standard library's substring search routines, these work on
arbitrary bytes. For all non-empty needles, these routines will report exactly
the same values as the corresponding routines in the standard library. For
the empty needle, the standard library reports matches only at valid UTF-8
boundaries, where as these routines will report matches at every position.
Other than being able to work on arbitrary bytes, the primary reason to prefer
these routines over the standard library routines is that these will generally
be faster. In some cases, significantly so.
# Example: iterating over substring matches
This example shows how to use [`find_iter`] to find occurrences of a substring
in a haystack.
```
use memchr::memmem;
let haystack = b"foo bar foo baz foo";
let mut it = memmem::find_iter(haystack, "foo");
assert_eq!(Some(0), it.next());
assert_eq!(Some(8), it.next());
assert_eq!(Some(16), it.next());
assert_eq!(None, it.next());
```
# Example: iterating over substring matches in reverse
This example shows how to use [`rfind_iter`] to find occurrences of a substring
in a haystack starting from the end of the haystack.
**NOTE:** This module does not implement double ended iterators, so reverse
searches aren't done by calling `rev` on a forward iterator.
```
use memchr::memmem;
let haystack = b"foo bar foo baz foo";
let mut it = memmem::rfind_iter(haystack, "foo");
assert_eq!(Some(16), it.next());
assert_eq!(Some(8), it.next());
assert_eq!(Some(0), it.next());
assert_eq!(None, it.next());
```
# Example: repeating a search for the same needle
It may be possible for the overhead of constructing a substring searcher to be
measurable in some workloads. In cases where the same needle is used to search
many haystacks, it is possible to do construction once and thus to avoid it for
subsequent searches. This can be done with a [`Finder`] (or a [`FinderRev`] for
reverse searches).
```
use memchr::memmem;
let finder = memmem::Finder::new("foo");
assert_eq!(Some(4), finder.find(b"baz foo quux"));
assert_eq!(None, finder.find(b"quux baz bar"));
```
Á4ý@¤ÜàäåÔ ã ñ û …
ý_L²© êaÐÍ ˜¤‰œœò´Ÿãž¤XDÛÅŸ™atüÄ ¡î[DŒþ¢ý]\–£ü†(Ðä·Ä,Ú´ÚüÚ,¿ÁˆŠlÖ{üÚŸnp]_LNd¨³´µ·¸ÊËÌÙ© Í Ä þ— „ Ž ž ´ ½ ò´)
¤§ H$A
µ¤¨ãLL
¤©î4W
²¤ªà $±
¤«
ü"
ikY[IK9;ü‡&
.lÙ
š­¯°ü¬
º
ò ùˆ³ ò øë𬣮® ¡
¬µ³ ¾
Ƴ´Á
­ˆ³ø=Lâ
è²4†
€;4™
.0üÛ;~
4Þ;
¤ó  ó øëƂۼݼÞ¼©ß¼à¼ÛἈcSñŸ«‡zÙâžš¬ ö;
¬
¯€;4î;
ãL…<
É]D«<
üüE
$ŠF
ô õ ö ÷  ô š õ ³  ö øë ÷ øëßĬ ˜F
¬
°$™F
ýaD§F
ÖRDÎF
€;4çF
üàI"
š²Àc²ü‰J@
ŒJ
ø ù ú  ø š ù  c cˆ¢cµ
 `£cbufÁ `àB¤GS
ú Ö¿Ù¿Ú¿«Û¿ˆÜ¿Ý¿Þ¿ˆ‚†f|Â
ŸÈŸÈ ÈErrorÁ O˜éBL± J
±
²$J
± —J
œ…W
tŠW
¤û ü ý þ  û š ü ³  ý øë þ øëßÄü„Z™
œŽZ
¤ÿ     ÿ š  ³   øë  øëßÄ ²Z
´ _searcherÁL§Z
 _prestateÁLÁZ
 _haystackÁLåZ
é€<ûZ
üž]š
´¨]
¤ƒ     ƒ š  ³   øë  øëßÄ Î]
µò2DÄ]
ЗLÝ]
ÖRD^
é€<^
üša˜
¬¤a
¤ ˆ  Š   š ˆ ³   øë Š øëßÄ Éa
ò2D¿a
ЗLØa
ÖRDüa
€;4b
üŽf¦
ü˜f$
¤ Œ  Ž   š Œ ³   øë Ž øëßÄ Ìf
·ò2DÂf
ýaDÛf
ÖRDþf
€;4“g
ü†{•
ì¼ìz
üæz
{
¤      š  ³   øë  øëßÄ ²{
¸ò2D¨{
ЗLÁ{
ÖRDå{
€;4ú{
„ˆ…
Åœº»üî†/
ü†
   øëÅœ¹ ˆ‡
¹
º€;4€‡
üºŽj
,ÈŽ
     Åœ  øë  øëßĹ ׎
¹
»$ØŽ
ÖRDæŽ
€;4ÿŽ
üÿ¡
ù½´½ü¦¢
<©¢
ù¼¼
½¤ï¢
ù¿ÌÑ£
<Ô£
¤   ù¾ Ü£
¾
¿$Ý£
t‹¶
âžÁÄÅÆü‰·
DŒ·
¤˜ ˆ³¥ ˜ øëç‘À£Â è·
Àµ³ •·
Ƴ´˜·
Áˆ³è²4¹·
$Ì·
€;4à·
35Üžº
Œ¤º
¤üˆÍ9
ì¼ÜÌ
üÖÌ
$‹Í
¤ â”  øëâžÀ ®Í
À
Ä»]4Í
€;4¦Í
üŸÕ0
$¢Õ
¤š   š âž  øëßÄÀ §Õ
À
Å$¨Õ
ÖRD®Õ
üÙØ7
\ÜØ
¤œ   œ âž  øëßÄÀ èØ
À
Æ$éØ
ÖRDïØ
æÜ
ÆéÄÇÅÇžÅÇÇÆÇ âžü¦Ý#
âžÉÀcÉüÐÝ@
ÓÝ
ž Ÿ    ž âž Ÿ  c cˆ¢cµ
 `£cŠ” `àB¤GS
  ±•È ×Ý
È
É$ØÝ
± ÞÝ
¤‘é
|–é
¤¡ ¢  ¡ âž ¢ øëßÄüÃëa
¼Íë
¤£ ¤  £ âž ¤ øëßÄ ñë
ËstratÁ,êë
ÖRDì
üôú]
ì¼Úú
üÔú
œþú
¤¥ ¦  ¥ âž ¦ øëßÄ žû
Ì‘©,—û
ÖRD®û
œê…
³ ÎÏÐÑÒÓÔ¤û†
L
¤ÍÍÌÁ‰
tlj
¤ÍÍü›Š%
©Š
³ ÍÍ
Ðüø‹$
4û‹
¤§  § ³ Í ‚Œ
Í
Ñ$‡Œ
·a<Œ
ü³"

¤¨  ¨ ³ Í Ã
Í
Ò
Ô–”
D™”
¤©  © ³ Í ¢”
Í
Ó$£”
´«•
,®•
¤ª  ª ³ Í ´•
Í
Ô$µ•
„Ÿ™
ÖÖ•¡×ؤ™
üš?
$›š
« ¬  « •¡ ¬ øëßÄÕ  š
Õ
×$¥š
ÖRD«š
ü¬œ-
dºœ
­  ­ •¡Õ Çœ
Õ
Ø$Ìœ
üÉ£*
„Ì£
¤®  ® øë å£
Ù€;4Ý£
¤Ã¥
<É¥
¤¤æ±
<ì±
¤üœxü·NK Returns an iterator over all non-overlapping occurrences of a substring inÁ|†ÓÈú„š
# ComplexityÁ«úü¯HE This routine is guaranteed to have worst case linear time complexityÁüøHE with respect to both the needle and the haystack. That is, this runsÁüÁ/, in `O(needle.len() + haystack.len())` time.ÁñúüõEB This routine is also guaranteed to have worst case constant spaceÁ complexity.ÁËú # ExamplesÁÞú„â
Basic usage:ÁóúÊǼÿ use memchr::memmem;Áúü›*' let haystack = b"foo bar foo baz foo";ÁüÆ52 let mut it = memmem::find_iter(haystack, b"foo");Áüü# assert_eq!(Some(0), it.next());Áü # assert_eq!(Some(8), it.next());ÁüÄ$! assert_eq!(Some(16), it.next());Áüé  assert_eq!(None, it.next());ÁÊÇÝ Ýøë Ë8ŸÔ Ô ªb× ÖRØ ýaÙ »]Ú ¯Mï…Nº:¨þÝË8Ë8ÞŸßÞß­Î좺 µ¢ºË8¸à¢ºøë
ÜË8¢ºÖRDØ€;4ðY[±PRÞü¸#|üËHE Returns a reverse iterator over all non-overlapping occurrences of aÁä” substring in a haystack.Á±ú„µIJÆúüÊHê²ü“H¼³üÜ/Ž´Œ úü EÓ´¡µæ úŵù ú„ý 赎!ú<’!ÊǼš!š¶²!úü¶!*Ƕüá!63 let mut it = memmem::rfind_iter(haystack, b"foo");Áü˜"$”¸ü½"#ç·üá"#º·ü…# ¸<¦#ÊÇT¿#á áøëœºã ã ¤cæ ÖRç »]è ¯M½ ]$®áË8Ë8âŸãâãÊ#´» Ò#Å»Õ#Ô»\ã#
àË8¢ºÖRDõ#€;4$=?Î#=?âüÐ+<üñ$B? Returns the index of the first occurrence of the given needle.Á´%úü¸%KH Note that if you're are searching for the same needle in many differentÁü„&FC small haystacks, it may be faster to initialize a [`Finder`] once,ÁüË&! and reuse it for each search.Áí&ú„ñ&IJ'úü†'Hê²üÏ'H¼³ü˜(/Ž´È(úüÌ(EÓ´|’)¡µ¢)út¦)ŵµ)ú„¹)èµÊ)ú<Î)ÊǼÖ)š¶î)úüò)" let haystack = b"foo bar baz";Áü•*85 assert_eq!(Some(0), memmem::find(haystack, b"foo"));ÁüÎ*85 assert_eq!(Some(4), memmem::find(haystack, b"bar"));Áü‡+63 assert_eq!(None, memmem::find(haystack, b"quux"));Á<¾+ÊÇ$
settings.Álɨ½  ½ ê¤ ñ ñ ÑGó €;ô ò22 ûT“V»ÿרÎìÏŽ Û¨àÏŽøë\ç¨
ÏŽ$þ¨€;4Œ©KM8:üÿªxüªIF Build an owned forward finder using the given needle from the currentÁlϪ»¤ŒçªÌ᪜†«¾  ¾ ê¤ÏŽµì˜˜ Å«ÍìÏŽ š«æÏŽÉìì«
ÏŽ$Æ«€;4Ô«46üœ®ÅüЬHE Build a forward finder using the given needle and a custom heuristicÁü­EB for determining the frequency of a given byte in the dataset. SeeÁüç­0- [`HeuristicFrequencyRank`] for more details.ÁÌ£®š¿  ¿ ꤈³ šÏšñ ñ ÑGó €;ô ò22 ûT“V»ÿš£œœÆ®µ³ Ò®ùš õ®Ƴ´Õ®Š›\¯
ˆ³Ïš$ž¯è²4¬¯€;4¿¯VXLNPRü‘³Éü ±EB Build an owned forward finder using the given needle and a customÁüê±KH heuristic for determining the frequency of a given byte in the dataset.Áüº²41 See [`HeuristicFrequencyRank`] for more details.Á»¤Œù²Ìó²ü˜³À  À ꤈³Ïšµì£žŸŸž •´µ³ Á³æÿ ä³Ƴ´Ä³æÏšÉììç³
ˆ³Ïš$–´è²4¤´€;4·´TVXZüí¶oü”¶B? Build a reverse finder using the given needle from the currentÁlÛ¶lô¶¡Á  Á ê¤ ¡ÏŽû û —Iý €;þ ò2*|Ohý°¡¢¢‚·½ †·Ï\’·
 ÏŽ$©·€;4··68,.ü‡º{ü‰¹IF Build an owned reverse finder using the given needle from the currentÁl×¹»¤Œï¹Ìé¹œŽº   ê¤ÏŽ´‡¤¤ ͺå‘ ¢º÷‘쥺
£ÏŽ$κ€;4ܺ(*üß½Güª¼30 Configure the prefilter setting for the finder.Áâ¼úüê¼FC See the documentation for [`Prefilter`] for more discussion on whyÁüµ½%" you might want to configure this.ÁLæ½à  à ê¤ùá  ð½
¥$õ½ø=Lû½T…A4‰A§³Ç
Ž
üÔ0§§¾ÙüÔœŠ ÆÙ¿cÆÙ„ô§¾Ù:ä¡.ô¡$¾ÙLä¡@ô¡©ª«¬­®¯°±²¨©ª«¬­®¯°±²ÍìÆÙª¤ú
³ï¢D… ç¢ÿ¢±­°¬¯«²®”ñ§§”† §§œú
$ÿ
§§üò " ÆÙ§§
«ÆÙ©Ý$‚ üË0ÆÆÆÙ§§
¬ÆÙdataÁ$âüó2ÆÆÆÙ§§
­ÆÙ›¤üÝ'ÆÙ§
®ÆÙüµ-,¿ÆÙÆÙÆÙ§§
¯ÆÙvector2Á<Ëü‘+ÆÙÆÙÆÙ§§
°ÆÙ„¦üã*íÆÙÆÙÆÙ§§
±ÆÙ„¦üŒ3Ü–ÆÙ§§
²ÆÙü¬2³³¾Ùü¬ä¡ô¡„γ¾Ù*ä¡&ô¡$¾Ù<ä¡8ô¡µ·¸¹º»´µ·¸¹º»¸´»·º¹µüÛ8üÞ"ÆÙ³³
´ÆÙ¹ ôæÆÙ³³
µÆÙìÄÆÙ³³
ÆÙüª "­ ÆÙÆÙÆÙ³³
·ÆÙ¹
ü”!!—!ÆÙÆÙÆÙ³³
¸ÆÙ$š!¹
, !ü¦"-Ü©"ÆÙÆÙ³³
¹ÆÙ$Å"ü¥#d¨#ÆÙ³³
ºÆÙ$µ#ô•$\˜$ÆÙ³³
»ÆÙ$¤$¬·(µ¥½ô’*t•*¦µ¥¼¼
½$¤*üæ+"µ¥¿ÀÁÂÃÄÅÆ´µ·¸¹º»Ã¿ÆÂÅÁÄÀü¥,Cü¨,"µ¥¾¾
¿¹ Ë,ìÕ-dØ-µ¥¾¾
À$å-äª.T­.µ¥¾¾
Á$¸.ü/9/µ¥µ¥µ¥¾¾
Â$/¹
,œ/ü—08š0µ¥µ¥µ¥¾¾
Ã$0¹
,£0üž18Ü¡1µ¥µ¥¾¾
Ä$½1ôª2d­2µ¥¾¾
Å$º2ì½6\À6µ¥¾¾
Æ$Ì6|´O켚Oü”O\¸O¦
Â?D÷O³ÇÊ>4P§ÇË__arm_mte_create_random_tagÁÝÇ  ù…ÇÈ__arm_mte_increment_tagÁ½¯ û…ÇÈ__arm_mte_exclude_tagÁ­ó þ…ÇÈ__arm_mte_set_tagÁ €†ÇÈ__arm_mte_get_tagÁ÷ ‚†ÇÈ__arm_mte_ptrdiffÁè  „†ÇÈ__rndrÁ5ç ÇÈ__rndrrsÁEÐ  ÇÈvcopy_lane_s64Áuù ž†ÇÈvcopy_lane_u64Áu ¡†ÇÈvcopy_lane_p64Áu¤ ¤†ÇÈvcopy_lane_f64Áu»! §†ÇÈvcopy_laneq_s64Á}æ$ ª†ÇÈvcopy_laneq_u64Á}Ý( ­†ÇÈvcopy_laneq_p64Á}×, °†ÇÈvcopy_laneq_f64Á}Ñ0 ³†ÇÈ vld1_dup_f64Áe»4 ¶†ÇÈ
vld1q_dup_f64Ámë6 ·†ÇÈ
vld1_lane_f64Ám‰: ¹†ÇÈvld1q_lane_f64Áu¯= »†ÇÈvbsl_f64ÁEðA ½†ÇÈvbsl_p64ÁE¦E ¾†ÇÈ vbslq_f64ÁM“H ¿†ÇÈ vbslq_p64ÁMÔK À†ÇÈvadd_f64ÁE¶N Á†ÇÈ vaddq_f64ÁM´P †ÇÈvadd_s64ÁE²R ÆÇÈvadd_u64ÁE©T ĆÇÈ vaddd_s64ÁM£V ņÇÈ vaddd_u64ÁMX ƆÇÈvext_p64ÁE Z džÇÈvext_f64ÁEî\ ɆÇÈ
vdup_n_p64ÁU _ ˆÇÈ
vdup_n_f64ÁU¹a ̆ÇÈ vdupq_n_p64Á]Åc ͆ÇÈ vdupq_n_f64Á]æe ΆÇÈ
vmov_n_p64ÁUôg φÇÈ
vmov_n_f64ÁU÷i ІÇÈ vmovq_n_p64Á]ûk цÇÈ vmovq_n_f64Á]€n Ò†ÇÈ
vget_high_f64Ám†p Ó†ÇÈ
vget_high_p64Ám­r Ô†ÇÈ vget_low_f64ÁeÚt Õ†ÇÈ vget_low_p64Áe€w Ö†ÇÈ
vget_lane_f64Ámžz ׆ÇÈvgetq_lane_f64ÁuÚ} Ù†ÇÈ vcombine_f64Áe Û†ÇÈ vshld_n_s64Á]Ï‚ ܆ÇÈ vshld_n_u64Á]ö„ Þ†ÇÈ vshrd_n_s64Á]¥‡ à†ÇÈ vshrd_n_u64Á]ˆŠ â†ÇÈ vsrad_n_s64Á]— ä†ÇÈ vsrad_n_u64Á]ÿ æ†ÇÈ_PREFETCH_READÁu£ ì†ÇÈ_PREFETCH_WRITEÁ}´ í†ÇÈ_PREFETCH_LOCALITY0ÁÆ î†ÇÈ_PREFETCH_LOCALITY1ÁÜ ï†ÇÈ_PREFETCH_LOCALITY2Áò ð†ÇÈ_PREFETCH_LOCALITY3Áˆ ñ†ÇÈ _prefetchÁMæ ò†ÇÈ__dmbÁ- Û„ÇÈ__dsbÁ-‡ Ý„ÇÈ__isbÁ-º! ß„ÇÈSYÁãú¼„ÇÈûŽ„ÇÈSTÁ븄ÇȬÆÄÇÈISHÁµ¸Ä„ÇÈÝÆÅ„ÇÈISHSTÁ-ö¸Æ„ÇÈÇÇ„ÇÈNSHÁĸȄÇÈÃÇÉ„ÇÈNSHSTÁ-ƒ¸Ê„ÇÈõÇË„ÇÈOSHÁÓ ¸Ì„ÇÈ©ÈÍ„ÇÈOSHSTÁ-” ¸΄ÇÈÛÈÏ„ÇÈLDÁ¦¹Ò„ÇÈÉÓ„ÇÈISHLDÁ-ä¹Ô„ÇÈÀÉÕ„ÇÈNSHLDÁ-¦¹Ö„ÇÈôÉׄÇÈOSHLDÁ-ê¹Ø„ÇȨÊÙ„ÇÈ__wfiÁ-óû ô„ÇÈ__wfeÁ-Ç û õ„ÇÈ__sevÁ-é
û ö„ÇÈ__sevlÁ5û ÷„ÇÈ__yieldÁ=¯û ø„ÇÈ__nopÁ-ñû ù„ÇÈ uint8x8_tÁMÖç‘ÇÈ
vqtbl1q_u8ÁUá ”³ÇÈvtbl1_u8ÁEí Á¹ÇÈint8x8_tÁEž Þ‘ÇÈ poly8x8_tÁMþ
ð‘ÇÈ int16x4_tÁMéù‘ÇÈ
uint16x4_tÁUÕ‚’ÇÈ
poly16x4_tÁU‹’ÇÈ int32x2_tÁM®”’ÇÈ
uint32x2_tÁU™ÇÈ float32x2_tÁ]…¦’ÇÈ int64x1_tÁMò¯’ÇÈ
uint64x1_tÁUݸ’ÇÈ
poly64x1_tÁUÉÁ’ÇÈ int8x16_tÁMºÊ’ÇÈ«¥Ó’ÇÈ
poly8x16_tÁU™Ü’ÇÈ int16x8_tÁMˆå’ÇÈ
uint16x8_tÁUöî’ÇÈ
poly16x8_tÁUå÷’ÇÈ int32x4_tÁMÓ€“ÇÈ
uint32x4_tÁUÀ‰“ÇÈ float32x4_tÁ]®’“ÇÈ int64x2_tÁMœ›“ÇÈ
uint64x2_tÁUˆ¤“ÇÈ
poly64x2_tÁUõ­“ÇÈ float16x4_tÁ]¾"Ø“ÇÈ float16x8_tÁ]®#á“ÇÈ
int8x8x2_tÁU&ê“ÇÈ—Óë“ÇÈ
int8x8x3_tÁU„)ô“ÇÈÏÓõ“ÇÈ
int8x8x4_tÁUÿ+ÿ“ÇȇԀ”ÇÈ int8x16x2_tÁ]‰/‹”ÇȿԌ”ÇÈ int8x16x3_tÁ]û1•”ÇÈøÔ–”ÇÈ int8x16x4_tÁ]û4 ”Çȱա”ÇÈ uint8x8x2_tÁ]Š8¬”ÇÈêÕ­”ÇÈ uint8x8x3_tÁ]ü:¶”ÇÈ£Ö·”ÇÈ uint8x8x4_tÁ]ü=Á”ÇÈÜÖ”ÇÈ uint8x16x2_tÁeŒAÍ”ÇÈ•×ΔÇÈ uint8x16x3_tÁeD×”ÇÈÏר”ÇÈ uint8x16x4_tÁe‡Gâ”ÇȉØã”ÇÈ poly8x8x2_tÁ]®Jî”ÇÈÃØï”ÇÈ poly8x8x3_tÁ] Mø”ÇÈüØù”ÇÈ poly8x8x4_tÁ] Pƒ•Çȵل•ÇÈ poly8x16x2_tÁe°SÇÈîÙÇÈ poly8x16x3_tÁe¦V™•ÇȨښ•ÇÈ poly8x16x4_tÁe«Y¤•ÇÈâÚ¥•ÇÈ int16x4x2_tÁ]Ò\°•ÇȜ۱•ÇÈ int16x4x3_tÁ]Ä_º•ÇÈÕÛ»•ÇÈ int16x4x4_tÁ]ÄbÅ•ÇÈŽÜÆ•ÇÈ int16x8x2_tÁ]ÓeÑ•ÇÈÇÜÒ•ÇÈ int16x8x3_tÁ]ÅhÛ•ÇÈ€ÝÜ•ÇÈ int16x8x4_tÁ]Åkæ•ÇȹÝç•ÇÈ uint16x4x2_tÁeÕnò•ÇÈòÝó•ÇÈ uint16x4x3_tÁeËqü•ÇȬÞý•ÇÈ uint16x4x4_tÁeÐt‡–ÇÈæÞˆ–ÇÈ uint16x8x2_tÁeøw“–ÇÈ ß”–ÇÈ uint16x8x3_tÁeîzÇÈÚßž–ÇÈ uint16x8x4_tÁeó}¨–ÇȔ੖ÇÈ poly16x4x2_tÁe´–ÇÈÎൖÇÈ poly16x4x3_tÁe‘„¾–ÇȉῖÇÈ poly16x4x4_tÁe–‡É–ÇÈÄáÊ–ÇÈ poly16x8x2_tÁe¾ŠÕ–ÇÈÿáÖ–ÇÈ poly16x8x3_tÁe´ß–ÇȺâà–ÇÈ poly16x8x4_tÁe¹ê–ÇÈõâë–ÇÈ int32x2x2_tÁ]à“ö–ÇȰã÷–ÇÈ int32x2x3_tÁ]Ò–€—ÇÈêãÇÈ int32x2x4_tÁ]Ò™‹—ÇȤ䌗ÇÈ int32x4x2_tÁ]᜗—ÇÈÞ䘗ÇÈ int32x4x3_tÁ]ÓŸ¡—ÇȘ増ÇÈ int32x4x4_tÁ]Ó¢¬—ÇÈÒå­—ÇÈ uint32x2x2_tÁe㥸—ÇȌ湗ÇÈ uint32x2x3_tÁeÙ¨—ÇÈÇæ×ÇÈ uint32x2x4_tÁeÞ«Í—ÇÈ‚çΗÇÈ uint32x4x2_tÁe†¯Ù—ÇȽçÚ—ÇÈ uint32x4x3_tÁeü±ã—ÇÈøçä—ÇÈ uint32x4x4_tÁeµî—Çȳèï—ÇÈ
float16x4x2_tÁm¬¸ú—ÇÈîèû—ÇÈ
float16x4x3_tÁm©»„˜ÇȪ酘ÇÈ
float16x4x4_tÁm¶¾˜ÇÈæé˜ÇÈ
float16x8x2_tÁmæÁ›˜ÇȢꜘÇÈ
float16x8x3_tÁmãÄ¥˜ÇÈÞꦘÇÈ
float16x8x4_tÁmðǰ˜ÇȚ뱘ÇÈ
float32x2x2_tÁmžË¼˜ÇÈÖ뽘ÇÈ
float32x2x3_tÁm˜ÎƘÇÈ’ìǘÇÈ
float32x2x4_tÁm¢ÑјÇÈÎìÒ˜ÇÈ
float32x4x2_tÁmÐÔݘÇÈŠíÞ˜ÇÈ
float32x4x3_tÁmÊ×ç˜ÇÈÆíè˜ÇÈ
float32x4x4_tÁmÔÚò˜ÇÈ‚îó˜ÇÈ int64x1x2_tÁ]€Þþ˜ÇȾîÿ˜ÇÈ int64x1x3_tÁ]òàˆ™ÇÈøî‰™ÇÈ int64x1x4_tÁ]òã“™ÇȲÇÈ int64x2x2_tÁ]矙ÇÈìï ™ÇÈ int64x2x3_tÁ]óé©™ÇȦðª™ÇÈ int64x2x4_tÁ]óì´™ÇÈàðµ™ÇÈ uint64x1x2_tÁeƒðÀ™ÇÈšñÁ™ÇÈ uint64x1x3_tÁeùòÊ™ÇÈÕñË™ÇÈ uint64x1x4_tÁeþõÕ™ÇÈòÖ™ÇÈ uint64x2x2_tÁe¦ùá™ÇÈËòâ™ÇÈ uint64x2x3_tÁeœüë™ÇȆóì™ÇÈ uint64x2x4_tÁe¡ÿö™ÇÈÁó÷™ÇÈ poly64x1x2
¦ÉÇȘø§ÉÇÈ
float64x2x2_tÁmÈ ²ÉÇÈÓø³ÉÇÈ
float64x2x3_tÁm¤¼ÉÇÈŽù½ÉÇÈ
float64x2x4_tÁmÇÉÇÈÉùÈÉÇÈ__crc32bÁEõ ÅáÇÈ __crc32cbÁM¡ ÈáÇÈ __crc32chÁMÁ ËáÇÈ __crc32cwÁMô" ÎáÇÈ__crc32hÁE0 ÑáÇÈ__crc32wÁE«7 ÔáÇÈvaba_s16ÁEöŠ ×áÇÈvaba_s32ÁE ØáÇÈvaba_s8Á=¨— ÙáÇÈvaba_u16ÁE¼ ÚáÇÈvaba_u32ÁEÚ£ ÛáÇÈvaba_u8Á=ö© ÜáÇÈvabal_s8ÁE’° ÝáÇÈ vabal_s16ÁMˆ· ÞáÇÈ vabal_s32ÁM„¾ ßáÇÈvabal_u8ÁE€Å àáÇÈ vabal_u16ÁMÈË ááÇÈ vabal_u32ÁM•Ò âáÇÈ vabaq_s16ÁMÜØ ãáÇÈ vabaq_s32ÁMúÞ äáÇÈvabaq_s8ÁE–å åáÇÈ vabaq_u16ÁM²ë æáÇÈ vabaq_u32ÁMÔñ çáÇÈvabaq_u8ÁEô÷ èáÇÈvabd_f16ÁEÈþ éáÇÈ vabdq_f16ÁM܇ ìáÇÈvabd_f32ÁEÆ ïáÇÈ vabdq_f32ÁM®™ òáÇÈvabd_s8Á=Š¢ õáÇÈvabdq_s8ÁEͪ øáÇÈvabd_s16ÁEœ³ ûáÇÈ vabdq_s16ÁMì» þáÇÈvabd_s32ÁE¾Ä âÇÈ vabdq_s32ÁMŽÍ „âÇÈvabd_u8Á=ÞÕ ‡âÇÈvabdq_u8ÁE§Þ ŠâÇÈvabd_u16ÁEüæ âÇÈ vabdq_u16ÁMÒï âÇÈvabd_u32ÁEªø “âÇÈ vabdq_u32ÁM€ –âÇÈvabdl_s8ÁEω ™âÇÈ vabdl_s16ÁM šâÇÈ vabdl_s32ÁMº– ›âÇÈvabdl_u8ÁEòœ œâÇÈ vabdl_u16ÁMõ¢ âÇÈ vabdl_u32ÁMü¨ žâÇÈvabs_f16ÁE¢¯ ŸâÇÈ vabsq_f16ÁM®µ  âÇÈvabs_f32ÁEŽ» ¡âÇÈ vabsq_f32ÁMîÀ ¢âÇÈvabs_s8Á=ÉÆ £âÇÈvabsq_s8ÁEÍ ¤âÇÈvabs_s16ÁEÖÓ ¥âÇÈ vabsq_s16ÁM Ú ¦âÇÈvabs_s32ÁEêà §âÇÈ vabsq_s32ÁM´ç ¨âÇÈ vabsh_f16ÁM’í ©âÇÈvadd_f16ÁE°ó ªâÇÈ vaddq_f16ÁMÓù «âÇÈvadd_f32ÁE³ÿ ¬âÇÈvadd_s16ÁE‘… ­âÇÈvadd_s32ÁEéŠ ®âÇÈvadd_s8Á=À ¯âÇÈvadd_u16ÁE”– °âÇÈvadd_u32ÁEï› ±âÇÈvadd_u8Á=É¡ ²âÇÈ vaddq_f32ÁM¢§ ³âÇÈ vaddq_s16ÁM­ ´âÇÈ vaddq_s32ÁMܲ µâÇÈ vaddq_s64ÁM¶¸ ¶âÇÈvaddq_s8ÁE¾ ·âÇÈ vaddq_u16ÁMèà ¸âÇÈ vaddq_u32ÁMÅÉ ¹âÇÈ vaddq_u64ÁM¢Ï ºâÇÈvaddq_u8ÁEþÔ »âÇÈvadd_p8Á=àÚ ¼âÇÈvaddq_p8ÁE¿à ½âÇÈvadd_p16ÁE¢æ ¾âÇÈ vaddq_p16ÁM†ì ¿âÇÈvadd_p64ÁEêñ ÀâÇÈ vaddq_p64ÁMÎ÷ ÁâÇÈ vaddh_f16ÁM¹ü ÂâÇÈvaddhn_high_s16Á}“‚ ÃâÇÈvaddhn_high_s32Á}¹‰ ÄâÇÈvaddhn_high_s64Á}à ÅâÇÈvaddhn_high_u16Á}Á— ÆâÇÈvaddhn_high_u32Á}ìž ÇâÇÈvaddhn_high_u64Á}û¥ ÈâÇÈ
vaddhn_s16ÁUì¬ ÉâÇÈ
vaddhn_s32ÁU„³ ÊâÇÈ
vaddhn_s64ÁUž¹ ËâÇÈ
vaddhn_u16ÁU¸¿ ÌâÇÈ
vaddhn_u32ÁUÔÅ ÍâÇÈ
vaddhn_u64ÁUòË ÎâÇÈvaddl_high_s16ÁužÒ ÏâÇÈvaddl_high_s32ÁuùÙ ÐâÇÈ
vaddl_high_s8ÁmÇá ÑâÇÈvaddl_high_u16ÁuÃé ÒâÇÈvaddl_high_u32Áu¥ñ ÓâÇÈ
vaddl_high_u8Ámúø ÔâÇÈ vaddl_s16ÁMå€ ÕâÇÈ vaddl_s32ÁM§‡ ÖâÇÈvaddl_s8ÁEè ×âÇÈ vaddl_u16ÁM§” ØâÇÈ vaddl_u32ÁMîš ÙâÇÈvaddl_u8ÁE´¡ ÚâÇÈ
vaddq_p128ÁU÷§ ÛâÇÈvaddw_high_s16Áu­ ÜâÇÈvaddw_high_s32Áu§´ ÝâÇÈ
vaddw_high_s8Ám…» ÞâÇÈvaddw_high_u16ÁuúÁ ßâÇÈvaddw_high_u32ÁuäÈ àâÇÈ
vaddw_high_u8ÁmÇÏ áâÇÈ vaddw_s16ÁM®Ö ââÇÈ vaddw_s32ÁM½Ü ãâÇÈvaddw_s8ÁEËâ äâÇÈ vaddw_u16ÁMØè åâÇÈ vaddw_u32ÁMëî æâÇÈvaddw_u8ÁEýô çâÇÈ vaesdq_u8ÁM¨ú èâÇÈ vaeseq_u8ÁMú ëâÇÈ vaesimcq_u8Á]̉ îâÇÈ
vaesmcq_u8ÁU÷ ñâÇÈvand_s8Á=’™ ôâÇÈvandq_s8ÁEíž õâÇÈvand_s16ÁE̤ öâÇÈ vandq_s16ÁM¬ª ÷âÇÈvand_s32ÁEŒ° øâÇÈ vandq_s32ÁMìµ ùâÇÈvand_s64ÁEÌ» úâÇÈ vandq_s64ÁM¬Á ûâÇÈvand_u8Á=‹Ç üâÇÈvandq_u8ÁEéÌ ýâÇÈvand_u16ÁEËÒ þâÇÈ vandq_u16ÁM®Ø ÿâÇÈvand_u32ÁE‘Þ €ãÇÈ vandq_u32ÁMôã ãÇÈvand_u64ÁE×é ‚ãÇÈ vandq_u64ÁMºï ƒãÇÈvbic_s16ÁE¤õ „ãÇÈvbic_s32ÁE¹û …ãÇÈvbic_s64ÁEÎ †ãÇÈvbic_s8Á=⇠‡ãÇÈ vbicq_s16ÁMó ˆãÇÈ vbicq_s32ÁMŠ” ‰ãÇÈ vbicq_s64ÁM¡š ŠãÇÈvbicq_s8ÁE·  ‹ãÇÈvbic_u16ÁE̦ ŒãÇÈvbic_u32ÁEï¬ ãÇÈvbic_u64ÁE’³ ŽãÇÈvbic_u8Á=´¹ ãÇÈ vbicq_u16ÁMÓ¿ ãÇÈ vbicq_u32ÁMøÅ ‘ãÇÈ vbicq_u64ÁMÌ ’ãÇÈvbicq_u8ÁEÁÒ “ãÇÈvbsl_f16ÁE†Ù ”ãÇÈ vbslq_f16ÁMËà •ãÇÈvbsl_f32ÁEäç –ãÇÈvbsl_p16ÁEüî —ãÇÈvbsl_p8Á=ö ˜ãÇÈvbsl_s16ÁEŸý ™ãÇÈvbsl_s32ÁE±„  šãÇÈvbsl_s64ÁEË  ›ãÇÈvbsl_s8Á=Ô’  œãÇÈ vbslq_f32ÁMá™  ãÇÈ vbslq_p16ÁMû   žãÇÈvbslq_p8ÁE‘¨  ŸãÇÈ vbslq_s16ÁM§¯   ãÇÈ vbslq_s32ÁM»¶  ¡ãÇÈ vbslq_s64ÁMϽ  ¢ãÇÈvbslq_s8ÁEâÄ  £ãÇÈvbsl_u16ÁEôË  ¤ãÇÈvbsl_u32ÁEóÒ  ¥ãÇÈvbsl_u64ÁEòÙ  ¦ãÇÈvbsl_u8Á=ðà  §ãÇÈ vbslq_u16ÁMêç  ¨ãÇÈ vbslq_u32ÁMëî  ©ãÇÈ vbslq_u64ÁMìõ  ªãÇÈvbslq_u8ÁEìü  «ãÇÈ vcage_f16ÁMÇ„
 ¬ãÇÈ
vcageq_f16ÁUì
 ¯ãÇÈ vcage_f32ÁMç–
 ²ãÇÈ
vcageq_f32ÁUàŸ
 µãÇÈ vcagt_f16ÁMþ¨
 ¸ãÇÈ
vcagtq_f16ÁUš²
 »ãÇÈ vcagt_f32ÁMŒ»
 ¾ãÇÈ
vcagtq_f32ÁUüÃ
 ÁãÇÈ vcale_f16ÁM Í
 ÄãÇÈ
vcaleq_f16ÁUÒÓ
 ÅãÇÈ vcale_f32ÁMÙÙ
 ÆãÇÈ
vcaleq_f32ÁUßß
 ÇãÇÈ vcalt_f16ÁM‰æ
 ÈãÇÈ
vcaltq_f16ÁU²ì
 ÉãÇÈ vcalt_f32ÁM°ò
 ÊãÇÈ
vcaltq_f32ÁU­ø
 ËãÇÈvceq_f16ÁEÈþ
 ÌãÇÈ vceqq_f16ÁMê„  ÍãÇÈvceq_f32ÁEàŠ  ÎãÇÈ vceqq_f32ÁMÖ  ÏãÇÈvceq_s8Á=Ë–  ÐãÇÈvceqq_s8ÁE¸œ  ÑãÇÈvceq_s16ÁEª¢  ÒãÇÈ vceqq_s16ÁM¨  ÓãÇÈvceq_s32ÁE®  ÔãÇÈ vceqq_s32ÁMƒ´  ÕãÇÈvceq_u8Á=ô¹  ÖãÇÈvceqq_u8ÁEã¿  ×ãÇÈvceq_u16ÁE×Å  ØãÇÈ vceqq_u16ÁMÌË  ÙãÇÈvceq_u32ÁEÁÑ  ÚãÇÈ vceqq_u32ÁM¶×  ÛãÇÈvceq_p8Á=©Ý  ÜãÇÈvceqq_p8ÁE˜ã  ÝãÇÈvcge_f16ÁEÇé  ÞãÇÈ vcgeq_f16ÁMùï  ßãÇÈvcge_f32ÁEÿõ  àãÇÈ vcgeq_f32ÁM…ü  áãÇÈvcge_s8Á=€‚  âãÇÈvcgeq_s8ÁEó‡  ããÇÈvcge_s16ÁEë  äãÇÈ vcgeq_s16ÁMä“  åãÇÈvcge_s32ÁEÝ™  æãÇÈ vcgeq_s32ÁMÖŸ  çãÇÈvcge_u8Á=Ï¥  èãÇÈvcgeq_u8ÁEÆ«  éãÇÈvcge_u16ÁE±  êãÇÈ vcgeq_u16ÁM¿·  ëãÇÈvcge_u32ÁE¼½  ìãÇÈ vcgeq_u32ÁM¹Ã  íãÇÈ vcgez_f16ÁMòÉ  îãÇÈ
vcgezq_f16ÁUÜÐ  ïãÇÈvcgt_f16ÁEÈ×  ðãÇÈ vcgtq_f16ÁMñÝ  ñãÇÈvcgt_f32ÁEîã  òãÇÈ vcgtq_f32ÁMëé  óãÇÈvcgt_s8Á=Ýï  ôãÇÈvcgtq_s8ÁEÇõ  õãÇÈvcgt_s16ÁE¶û  öãÇÈ vcgtq_s16ÁM¦
 ÷ãÇÈvcgt_s32ÁE–‡
 øãÇÈ vcgtq_s32ÁM†
 ùãÇÈvcgt_u8Á=ö’
 úãÇÈvcgtq_u8ÁEä˜
 ûãÇÈvcgt_u16ÁEמ
 üãÇÈ vcgtq_u16ÁMˤ
 ýãÇÈvcgt_u32ÁE¿ª
 þãÇÈ vcgtq_u32ÁM³°
 ÿãÇÈ vcgtz_f16ÁMà¶
 €äÇÈ
vcgtzq_f16ÁU¾½
 äÇÈvcle_f16ÁE°Ä
 ‚äÇÈ vcleq_f16ÁMßÊ
 ƒäÇÈvcle_f32ÁEâÐ
 „äÇÈ vcleq_f32ÁMåÖ
 …äÇÈvcle_s8Á=ÝÜ
 †äÇÈvcleq_s8ÁEÍâ
 ‡äÇÈvcle_s16ÁEÂè
 ˆäÇÈ vcleq_s16ÁM¸î
 ‰äÇÈvcle_s32ÁE®ô
 ŠäÇÈ vcleq_s32ÁM¤ú
 ‹äÇÈvcle_u8Á=š€ ŒäÇÈvcleq_u8ÁEކ äÇÈvcle_u16ÁE‡Œ ŽäÇÈ vcleq_u16ÁM äÇÈvcle_u32ÁEû— äÇÈ vcleq_u32ÁMõ ‘äÇÈ vclez_f16ÁM«¤ ’äÇÈ
vclezq_f16ÁU’« “äÇÈvcls_s8Á=± ”äÇÈvclsq_s8ÁEÓ¹ —äÇÈvcls_s16ÁEîÁ šäÇÈ vclsq_s16ÁMŠÊ äÇÈvcls_s32ÁE¨Ò  äÇÈ vclsq_s32ÁMÄÚ £äÇÈvcls_u8Á=Ûâ ¦äÇÈvclsq_u8ÁE¶è §äÇÈvcls_u16ÁE•î ¨äÇÈ vclsq_u16ÁMõó ©äÇÈvcls_u32ÁEÖù ªäÇÈ vclsq_u32ÁM¶ÿ «äÇÈvclt_f16ÁEÔ… ¬äÇÈ vcltq_f16ÁMú‹ ­äÇÈvclt_f32ÁEô‘ ®äÇÈ vcltq_f32ÁMî— ¯äÇÈvclt_s8Á=Ý °äÇÈvcltq_s8ÁEÄ£ ±äÇÈvclt_s16ÁE°© ²äÇÈ vcltq_s16ÁM¯ ³äÇÈvclt_s32ÁEе ´äÇÈ vcltq_s32ÁM÷º µäÇÈvclt_u8Á=äÀ ¶äÇÈvcltq_u8ÁEÏÆ ·äÇÈvclt_u16ÁE¿Ì ¸äÇÈ vcltq_u16ÁM°Ò ¹äÇÈvclt_u32ÁE¡Ø ºäÇÈ vcltq_u32ÁM’Þ »äÇÈ vcltz_f16ÁM·ä ¼äÇÈ
vcltzq_f16ÁUë ½äÇÈvclz_s8Á=½ñ ¾äÇÈvclzq_s8ÁE“÷ ¿äÇÈvclz_s16ÁEíü ÀäÇÈ vclzq_s16ÁMÈ‚ ÁäÇÈvclz_s32ÁE£ˆ ÂäÇÈ vclzq_s32ÁMþ ÃäÇÈvclz_u16ÁEú“ ÄäÇÈ vclzq_u16ÁM¿¡ ÅäÇÈvclz_u32ÁE ¯ ÆäÇÈ vclzq_u32ÁMÙ¼ ÇäÇÈvclz_u8Á= Ê ÈäÇÈvclzq_u8ÁEï× ÉäÇÈvcnt_s8Á=—æ ÊäÇÈvcntq_s8ÁEìë ËäÇÈvcnt_u8Á=äñ ÌäÇÈvcntq_u8ÁE¯ÿ ÍäÇÈvcnt_p8Á=ö ÎäÇÈvcntq_p8ÁEÁ› ÏäÇÈ vcombine_f16Áeé© ÐäÇÈ vcombine_f32Áe«¯ ÑäÇÈ vcombine_s8Á]à´ ÒäÇÈ vcombine_s16Áe·º ÓäÇÈ vcombine_s32Áeó¿ ÔäÇÈ vcombine_s64Áe£Å ÕäÇÈ vcombine_u8Á]ÌÊ ÖäÇÈ vcombine_u16Áe¦Ð ×äÇÈ vcombine_u32ÁeåÕ ØäÇÈ vcombine_u64Áe˜Û ÙäÇÈ vcombine_p8Á]Äà ÚäÇÈ vcombine_p16Áežæ ÛäÇÈ vcombine_p64ÁeÝë ÜäÇÈ vcreate_f16Á]ûò ÝäÇÈ vcreate_f32Á]߀ ÞäÇÈ
vcreate_s8ÁUÓ ßäÇÈ vcreate_s16Á]Κ àäÇÈ vcreate_s32Á]ç áäÇÈ vcreate_s64Á]‘´ âäÇÈ
vcreate_u8ÁUžº ãäÇÈ vcreate_u16Á]œÇ ääÇÈ vcreate_u32Á]”Ô åäÇÈ vcreate_u64Á]åà æäÇÈ
vcreate_p8ÁUóæ çäÇÈ vcreate_p16Á]ñó èäÇÈ vcreate_p64Á]Ì€ éäÇÈ vcvt_f16_f32Áe¦‡ êäÇÈ vcvt_f16_s16Áe ëäÇÈ
vcvtq_f16_s16ÁmÝ“ ìäÇÈ vcvt_f16_u16Áeø™ íäÇÈ
vcvtq_f16_u16Ám”  îäÇÈ vcvt_f32_f16Áe÷¦ ïäÇÈ vcvt_f32_s32Áeç¬ ðäÇÈ
vcvtq_f32_s32ÁmÖ² ñäÇÈ vcvt_f32_u32ÁeŸ òäÇÈ
vcvtq_f32_u32Ámµ¾ óäÇÈvcvt_n_f16_s16Áu…Å ôäÇÈvcvtq_n_f16_s16Á} Ï øäÇÈvcvt_n_f16_u16Áu½Ù üäÇÈvcvtq_n_f16_u16Á}Úã €åÇÈvcvt_n_f32_s32Áu•÷ „åÇÈvcvtq_n_f32_s32Á}¹ý ˆåÇÈvcvt_n_f32_u32Áu÷ ŒåÇÈvcvtq_n_f32_u32Á} åÇÈvcvt_n_s16_f16ÁuÅŸ ”åÇÈvcvtq_n_s16_f16Á}è© ˜åÇÈvcvt_n_s32_f32Áuä½ œåÇÈvcvtq_n_s32_f32Á}ŸÄ  åÇÈvcvt_n_u16_f16ÁuÚÍ ¤åÇÈvcvtq_n_u16_f16Á}”Ø ¨åÇÈvcvt_n_u32_f32Áu–ì ¬åÇÈvcvtq_n_u32_f32Á}Óò °åÇÈ vcvt_s16_f16ÁeÝû ´åÇÈ
vcvtq_s16_f16Ám–‚ µåÇÈ vcvt_s32_f32Áe£ˆ ¶åÇÈ
vcvtq_s32_f32Ámþ ¹åÇÈ vcvt_u16_f16Áe‰š ¼åÇÈ
vcvtq_u16_f16ÁmÅ  ½åÇÈ vcvt_u32_f32ÁeÕ¦ ¾åÇÈ
vcvtq_u32_f32Ám´¯ ÁåÇÈ
vdot_lane_s32Ám׸ ÄåÇÈvdotq_lane_s32ÁuâË ÆåÇÈ
vdot_lane_u32Ámòß ÈåÇÈvdotq_lane_u32Áuó ÊåÇÈvdot_laneq_s32Áu ÌåÇÈvdotq_laneq_s32Á}Œ— ÎåÇÈvdot_laneq_u32Áu© ÐåÇÈvdotq_laneq_u32Á}™º ÒåÇÈvdot_s32ÁEêÌ ÔåÇÈ vdotq_s32ÁMÞÕ ×åÇÈvdot_u32ÁEÚÞ ÚåÇÈ vdotq_u32ÁMÖç ÝåÇÈ
vdup_lane_f16Ámóñ àåÇÈvdupq_lane_f16ÁuËù âåÇÈ
vdup_lane_f32Ámº€ äåÇÈ
vdup_lane_s32Ám¯‡ æåÇÈ
vdup_lane_u32Ám Ž èåÇÈvdupq_lane_f32Áu”• êåÇÈvdupq_lane_s32ÁuŸœ ìåÇÈvdupq_lane_u32Áu¦£ îåÇÈ
vdup_lane_p16Ám®ª ðåÇÈ
vdup_lane_s16Ámš± òåÇÈ
vdup_lane_u16Ám„¸ ôåÇÈvdupq_lane_p16Áuñ¾ öåÇÈvdupq_lane_s16ÁußÅ øåÇÈvdupq_lane_u16ÁuËÌ úåÇÈ vdup_lane_p8Áe¶Ó üåÇÈ vdup_lane_s8ÁeÚ þåÇÈ vdup_lane_u8Áe‚á €æÇÈ
vdupq_lane_p8Ámêç ‚æÇÈ
vdupq_lane_s8ÁmÕî „æÇÈ
vdupq_lane_u8Ám¾õ †æÇÈ
vdup_lane_s64Ám¤ü ˆæÇÈ
vdup_lane_u64ÁmÔ‚ ŠæÇÈvdup_laneq_f16Áuö‰ ŒæÇÈvdupq_laneq_f16Á}Б ŽæÇÈvdup_laneq_f32ÁuÁ˜ æÇÈvdup_laneq_s32Áu¸Ÿ ’æÇÈvdup_laneq_u32Áu«¦ ”æÇÈvdupq_laneq_f32Á}¡­ –æÇÈvdupq_laneq_s32Á}®´ ˜æÇÈvdupq_laneq_u32Á}·» šæÇÈvdup_laneq_p16ÁuÁ œæÇÈvdup_laneq_s16Áu¯É žæÇÈvdup_laneq_u16Áu›Ð  æÇÈvdupq_laneq_p16Á}Š× ¢æÇÈvdupq_laneq_s16Á}úÝ ¤æÇÈvdupq_laneq_u16Á}èä ¦æÇÈ
vdup_laneq_p8ÁmÕë ¨æÇÈ
vdup_laneq_s8Ám¿ò ªæÇÈ
vdup_laneq_u8Ám§ù ¬æÇÈvdupq_laneq_p8Áu’€ ®æÇÈvdupq_laneq_s8Áu€‡ °æÇÈvdupq_laneq_u8Áuì ²æÇÈvdup_laneq_s64ÁuÖ” ´æÇÈvdup_laneq_u64ÁuÊ› ¶æÇÈ
vdup_n_f16ÁUè¡ ¸æÇÈ vdupq_n_f16Á]¦§ ¹æÇÈ
vdup_n_f32ÁU“­ ºæÇÈ
vdup_n_p16ÁU‡³ »æÇÈ vdup_n_p8ÁM÷¸ ¼æÇÈ
vdup_n_s16ÁUå¾ ½æÇÈ
vdup_n_s32ÁUÕÄ ¾æÇÈ
vdup_n_s64ÁUÃÊ ¿æÇÈ vdup_n_s8ÁM±Ð ÀæÇÈ
vdup_n_u16ÁUÖ ÁæÇÈ
vdup_n_u32ÁUÜ ÂæÇÈ
vdup_n_u64ÁUÿá ÃæÇÈ vdup_n_u8ÁMïç ÄæÇÈ vdupq_n_f32Á]Þí ÅæÇÈ vdupq_n_p16Á]Ôó ÆæÇÈ
vdupq_n_p8ÁUÆù ÇæÇÈ vdupq_n_s16Á]¸ÿ ÈæÇÈ vdupq_n_s32Á]ª… ÉæÇÈ vdupq_n_s64Á]™‹ ÊæÇÈ
vdupq_n_s8ÁU‰‘ ËæÇÈ vdupq_n_u16Á]ù– ÌæÇÈ vdupq_n_u32Á]íœ ÍæÇÈ vdupq_n_u64Á]Þ¢ ÎæÇÈ
vdupq_n_u8ÁUШ ÏæÇÈvdupq_lane_s64Áuäº ÒæÇÈvdupq_lane_u64ÁuÊÁ ÔæÇÈvdupq_laneq_s64Á}³È ÖæÇÈvdupq_laneq_u64Á}£Ï ØæÇÈveor_s8Á=ÛÕ ÚæÇÈveorq_s8ÁEÈÛ ÛæÇÈveor_s16ÁE¹á ÜæÇÈ veorq_s16ÁM«ç ÝæÇÈveor_s32ÁEí ÞæÇÈ veorq_s32ÁMó ßæÇÈveor_s64ÁEù àæÇÈ veorq_s64ÁMóþ áæÇÈveor_u8Á=ä„ âæÇÈveorq_u8ÁEÔŠ ãæÇÈveor_u16ÁEÈ äæÇÈ veorq_u16ÁM½– åæÇÈveor_u32ÁE²œ ææÇÈ veorq_u32ÁM§¢ çæÇÈveor_u64ÁEœ¨ èæÇÈ veorq_u64ÁM‘® éæÇÈvext_f16ÁEå´ êæÇÈvext_f32ÁEÓ½ ìæÇÈvext_s32ÁEÌÅ îæÇÈvext_u32ÁE¿Í ðæÇÈvext_s64ÁEñÕ òæÇÈvext_u64ÁEäÜ ôæÇÈvext_s8Á=ã öæÇÈ vextq_s16ÁMÂî øæÇÈvext_u8Á=êù úæÇÈ vextq_u16ÁM’… üæÇÈvext_p8Á=½ þæÇÈ vextq_p16ÁMå› €çÇÈ vextq_f16ÁM¾§ ‚çÇÈ vextq_f32ÁMî² „çÇÈvext_s16ÁEÝ» †çÇÈ vextq_s32ÁMÆÄ ˆçÇÈvext_u16ÁE¯Í ŠçÇÈ vextq_u32ÁM›Ö ŒçÇÈvext_p16ÁE‡ß ŽçÇÈ vextq_s64ÁMïç çÇÈ vextq_u64ÁMàï ’çÇÈvextq_s8ÁEÙ÷ ”çÇÈvextq_u8ÁEæ’ –çÇÈvextq_p8ÁEö­ ˜çÇÈvfma_f16ÁE•É šçÇÈ vfmaq_f16ÁMäÏ ›çÇÈvfma_f32ÁE†Ö œçÇÈ vfmaq_f32ÁM¨Ü çÇÈ
vfma_n_f32ÁUÌâ žçÇÈ vfmaq_n_f32Á]ðè ŸçÇÈvfms_f16ÁEþï  çÇÈ vfmsq_f16ÁMÀ÷ ¡çÇÈvfms_f32ÁE˜þ ¢çÇÈ vfmsq_f32ÁMï„ £çÇÈ
vfms_n_f32ÁUÏ‹ ¤çÇÈ vfmsq_n_f32Á]ø‘ ¥çÇÈ
vget_high_f16Ámë— ¦çÇÈ vget_low_f16ÁeÏ §çÇÈ
vget_high_f32ÁmÜ£ ¨çÇÈ
vget_high_p16Ámä© ©çÇÈ vget_high_p8Áeï¯ ªçÇÈ
vget_high_s16Ám‹¶ «çÇÈ
vget_high_s32Ám•¼ ¬çÇÈ vget_high_s8Áe˜Â ­çÇÈ
vget_high_u16Ám²È ®çÇÈ
vget_high_u32Ám¾Î ¯çÇÈ vget_high_u8ÁeÃÔ °çÇÈ
vget_high_s64ÁmßÚ ±çÇÈ
vget_high_u64Ámèà ²çÇÈ
vget_lane_f16Áméæ ³çÇÈvgetq_lane_f16Áu™í µçÇÈ
vget_lane_f32Ámûò ·çÇÈ
vget_lane_p16ÁmÜø ¹çÇÈ vget_lane_p8Áe»þ »çÇÈ
vget_lane_s16Ám˜„ ½çÇÈ
vget_lane_s32Ám÷‰ ¿çÇÈ vget_lane_s8ÁeÕ ÁçÇÈ
vget_lane_u16Ám±• ÃçÇÈ
vget_lane_u32Ám‘› ÅçÇÈ vget_lane_u8Áeð  ÇçÇÈvgetq_lane_f32ÁuΦ ÉçÇÈvgetq_lane_p16Áu±¬ ËçÇÈvgetq_lane_p64Áu“² ÍçÇÈ
vgetq_lane_p8Ámô· ÏçÇÈvgetq_lane_s16ÁuÔ½ ÑçÇÈvgetq_lane_s32ÁuµÃ ÓçÇÈvgetq_lane_s64Áu–É ÕçÇÈ
vgetq_lane_s8ÁmöÎ ×çÇÈvgetq_lane_u16ÁuÕÔ ÙçÇÈvgetq_lane_u32Áu·Ú ÛçÇÈvgetq_lane_u64Áu™à ÝçÇÈ
vgetq_lane_u8Ámúå ßçÇÈ
vget_lane_p64ÁmÙë áçÇÈ
vget_lane_s64Ám±ñ ãçÇÈ
vget_lane_u64Ámˆ÷ åçÇÈ vget_low_f32Áe¦ü ççÇÈ vget_low_p16Áe¤  èçÇÈ vget_low_p8Á]¥†  éçÇÈ vget_low_s16Áe±‹  êçÇÈ vget_low_s32Áe±  ëçÇÈ vget_low_s8Á]ª•  ìçÇÈ vget_low_u16Áe´š  íçÇÈ vget_low_u32Áe¶Ÿ  îçÇÈ vget_low_u8Á]±¤  ïçÇÈ vget_low_s64Áe½©  ðçÇÈ vget_low_u64Áe¼®  ñçÇÈvhadd_s8ÁE§´  òçÇÈ vhaddq_s8ÁMÔ¼  õçÇÈ vhadd_s16ÁMÅ  øçÇÈ
vhaddq_s16ÁUÇÍ  ûçÇÈ vhadd_s32ÁMƒÖ  þçÇÈ
vhaddq_s32ÁU½Þ  èÇÈvhadd_u8ÁE÷æ  „èÇÈ vhaddq_u8ÁMªï  ‡èÇÈ vhadd_u16ÁMé÷  ŠèÇÈ
vhaddq_u16ÁU©€! èÇÈ vhadd_u32ÁMëˆ! èÇÈ
vhaddq_u32ÁU«‘! “èÇÈ vhsub_s16ÁMù™! –èÇÈ
vhsubq_s16ÁU¿¢! ™èÇÈ vhsub_s32ÁM‡«! œèÇÈ
vhsubq_s32ÁUͳ! ŸèÇÈvhsub_s8ÁE“¼! ¢èÇÈ vhsubq_s8ÁMÌÄ! ¥èÇÈvhsub_u8ÁEÍ! ¨èÇÈ vhsubq_u8ÁMÎÕ! «èÇÈ vhsub_u16ÁM™Þ! ®èÇÈ
vhsubq_u16ÁUåæ! ±èÇÈ vhsub_u32ÁM³ï! ´èÇÈ
vhsubq_u32ÁUÿ÷! ·èÇÈ vld1_dup_f16ÁeŠ" ºèÇÈ
vld1q_dup_f16Ám‰ˆ" ¼èÇÈ vld1_dup_f32ÁeÑ" ¾èÇÈ vld1_dup_p16Áe·–" ¿èÇÈ vld1_dup_p8Á]š" ÀèÇÈ vld1_dup_s16Áeû£" ÁèÇÈ vld1_dup_s32Áeߪ" ÂèÇÈ vld1_dup_s8Á]Á±" ÃèÇÈ vld1_dup_u16Áe¡¸" ÄèÇÈ vld1_dup_u32Áe†¿" ÅèÇÈ vld1_dup_u8Á]éÅ" ÆèÇÈ
vld1q_dup_f32ÁmËÌ" ÇèÇÈ
vld1q_dup_p16Ám³Ó" ÈèÇÈ vld1q_dup_p8Áe˜Ú" ÉèÇÈ
vld1q_dup_s16Ámýà" ÊèÇÈ
vld1q_dup_s32Ámãç" ËèÇÈ
vld1q_dup_s64ÁmÆî" ÌèÇÈ vld1q_dup_s8Áeªõ" ÍèÇÈ
vld1q_dup_u16ÁmŽü" ÎèÇÈ
vld1q_dup_u32Ámõ‚# ÏèÇÈ
vld1q_dup_u64ÁmÙ‰# ÐèÇÈ vld1q_dup_u8Áe¾# ÑèÇÈ vld1_dup_p64Áe —# ÒèÇÈ vld1_dup_s64ÁeÝŸ# ÓèÇÈ vld1_dup_u64Áe˜¨# ÔèÇÈ vld1_f16_x2Á]íÈ# ÕèÇÈ vld1_f16_x3Á]›Ï# ÖèÇÈ vld1_f16_x4Á]ÉÕ# ×èÇÈ vld1q_f16_x2ÁeøÛ# ØèÇÈ vld1q_f16_x3Áe¨â# ÙèÇÈ vld1q_f16_x4ÁeØè# ÚèÇÈ vld1_f32_x2Á]¼$ ÛèÇÈ vld1_f32_x3Á]ðÂ$ ÜèÇÈ vld1_f32_x4Á]ÑÉ$ ÝèÇÈ vld1q_f32_x2Áe³Ð$ ÞèÇÈ vld1q_f32_x3Áe–×$ ßèÇÈ vld1q_f32_x4ÁeùÝ$ àèÇÈ
vld1_lane_f16ÁmÑä$ áèÇÈvld1q_lane_f16Áuõë$ ãèÇÈ
vld1_lane_f32ÁmÓó$ åèÇÈ
vld1_lane_p16Ám°û$ çèÇÈ vld1_lane_p8Áe‰ƒ% éèÇÈ
vld1_lane_s16ÁmàŠ% ëèÇÈ
vld1_lane_s32Ám¹’% íèÇÈ
vld1_lane_s64Ámš% ïèÇÈ vld1_lane_s8ÁeÜ¡% ñèÇÈ
vld1_lane_u16Ám±©% óèÇÈ
vld1_lane_u32ÁmŒ±% õèÇÈ
vld1_lane_u64Ámâ¸% ÷èÇÈ vld1_lane_u8Áe³À% ùèÇÈvld1q_lane_f32Áu‹È% ûèÇÈvld1q_lane_p16ÁuêÏ% ýèÇÈ
vld1q_lane_p8ÁmÇ×% ÿèÇÈvld1q_lane_s16Áu¢ß% éÇÈvld1q_lane_s32Áuýæ% ƒéÇÈvld1q_lane_s64ÁuÓî% …éÇÈ
vld1q_lane_s8Ám®ö% ‡éÇÈvld1q_lane_u16Áu‡þ% ‰éÇÈvld1q_lane_u32Áuä…& ‹éÇÈvld1q_lane_u64Áu¼& éÇÈ
vld1q_lane_u8Ám™•& éÇÈ
vld1_lane_p64Ámòœ& ‘éÇÈvld1q_lane_p64ÁuŤ& “éÇÈ vld1_p64_x2Á]²& •éÇÈ vld1_p64_x3Á]¦¹& –éÇÈ vld1_p64_x4Á]ŠÀ& —éÇÈ vld1q_p64_x2ÁeïÆ& ˜éÇÈ vld1q_p64_x3ÁeÕÍ& ™éÇÈ vld1q_p64_x4Áe»Ô& šéÇÈ
vld1_s8_x2ÁU©ƒ' ›éÇÈ
vld1_s8_x3ÁU„Š' œéÇÈ
vld1_s8_x4ÁUß' éÇÈ vld1q_s8_x2Á]»—' žéÇÈ vld1q_s8_x3Á]™ž' ŸéÇÈ vld1q_s8_x4Á]÷¤'  éÇÈ vld1_s16_x2Á]Õ«' ¡éÇÈ vld1_s16_x3Á]´²' ¢éÇÈ vld1_s16_x4Á]“¹' £éÇÈ vld1q_s16_x2Áeó¿' ¤éÇÈ vld1q_s16_x3ÁeÔÆ' ¥éÇÈ vld1q_s16_x4ÁeµÍ' ¦éÇÈ vld1_s32_x2Á]•Ô' §éÇÈ vld1_s32_x3Á]ôÚ' ¨éÇÈ vld1_s32_x4Á]Óá' ©éÇÈ vld1q_s32_x2Áe³è' ªéÇÈ vld1q_s32_x3Áe”ï' «éÇÈ vld1q_s32_x4Áeõõ' ¬éÇÈ vld1_s64_x2Á]Õü' ­éÇÈ vld1_s64_x3Á]´ƒ( ®éÇÈ vld1_s64_x4Á]“Š( ¯éÇÈ vld1q_s64_x2Áeó( °éÇÈ vld1q_s64_x3ÁeÔ—( ±éÇÈ vld1q_s64_x4Áeµž( ²éÇÈ
vld1_u8_x2ÁU”¥( ³éÇÈ
vld1_u8_x3ÁUð«( ´éÇÈ
vld1_u8_x4ÁU̲( µéÇÈ vld1q_u8_x2Á]©¹( ¶éÇÈ vld1q_u8_x3Á]ˆÀ( ·éÇÈ vld1q_u8_x4Á]çÆ( ¸éÇÈ vld1_u16_x2Á]ÆÍ( ¹éÇÈ vld1_u16_x3Á]¦Ô( ºéÇÈ vld1_u16_x4Á]†Û( »éÇÈ vld1q_u16_x2Áeçá( ¼éÇÈ vld1q_u16_x3ÁeÉè( ½éÇÈ vld1q_u16_x4Áe«ï( ¾éÇÈ vld1_u32_x2Á]Œö( ¿éÇÈ vld1_u32_x3Á]ìü( ÀéÇÈ vld1_u32_x4Á]̃) ÁéÇÈ vld1q_u32_x2Áe­Š) ÂéÇÈ vld1q_u32_x3Áe) ÃéÇÈ vld1q_u32_x4Áeñ—) ÄéÇÈ vld1_u64_x2Á]Òž) ÅéÇÈ vld1_u64_x3Á]²¥) ÆéÇÈ vld1_u64_x4Á]’¬) ÇéÇÈ vld1q_u64_x2Áeó²) ÈéÇÈ vld1q_u64_x3ÁeÕ¹) ÉéÇÈ vld1q_u64_x4Áe·À) ÊéÇÈ
vld1_p8_x2ÁU—Ç) ËéÇÈ
vld1_p8_x3ÁUóÍ) ÌéÇÈ
vld1_p8_x4ÁUÏÔ) ÍéÇÈ vld1q_p8_x2Á]¬Û) ÎéÇÈ vld1q_p8_x3Á]‹â) ÏéÇÈ vld1q_p8_x4Á]êè) ÐéÇÈ vld1_p16_x2Á]Éï) ÑéÇÈ vld1_p16_x3Á]©ö) ÒéÇÈ vld1_p16_x4Á]‰ý) ÓéÇÈ vld1q_p16_x2Áeêƒ* ÔéÇÈ vld1q_p16_x3ÁeÌŠ* ÕéÇÈ vld1q_p16_x4Áe®‘* ÖéÇÈ
vld1q_dup_p64ÁmÄË* ×éÇÈ vld2_dup_f16Áe„à* ÙéÇÈ
vld2q_dup_f16ÁmÆç* ÜéÇÈ vld2_dup_f32Áe­œ+ ßéÇÈ
vld2q_dup_f32Ám¿¢+ âéÇÈ vld2_dup_s8Á]Ò¨+ åéÇÈ vld2q_dup_s8Áe×®+ èéÇÈ vld2_dup_s16Áeâ´+ ëéÇÈ
vld2q_dup_s16Ámðº+ îéÇÈ vld2_dup_s32Áe€Á+ ñéÇÈ
vld2q_dup_s32ÁmŽÇ+ ôéÇÈ vld2_dup_p64ÁeäÏ+ ÷éÇÈ vld2_dup_s64ÁeíÙ+ øéÇÈ vld2_dup_u64Áe¼â+ ûéÇÈ vld2_dup_u8Á]Àé+ üéÇÈ vld2q_dup_u8Áežù+ ýéÇÈ vld2_dup_u16Áe´Š, þéÇÈ
vld2q_dup_u16Ám…š, ÿéÇÈ vld2_dup_u32Áeò©, €êÇÈ
vld2q_dup_u32Ám·¹, êÇÈ vld2_dup_p8Á]‹É, ‚êÇÈ vld2q_dup_p8ÁeéØ, ƒêÇÈ vld2_dup_p16Áeÿé, „êÇÈ
vld2q_dup_p16ÁmÐù, …êÇÈvld2_f16ÁE”–- †êÇÈ vld2q_f16ÁMÄ- ‰êÇÈvld2_f32ÁE‘Ï- ŒêÇÈ vld2q_f32ÁMÕ- êÇÈvld2_s8Á=òÚ- ’êÇÈvld2q_s8ÁEÓà- •êÇÈvld2_s16ÁE»æ- ˜êÇÈ vld2q_s16ÁM¥ì- ›êÇÈvld2_s32ÁE‘ò- žêÇÈ vld2q_s32ÁMû÷- ¡êÇÈ
vld2_lane_f16ÁmÈ. ¤êÇÈvld2q_lane_f16Áu¹™. ¨êÇÈ
vld2_lane_f32Ám«¡. ¬êÇÈvld2q_lane_f32Áuߨ. °êÇÈ vld2_lane_s8Áe °. ´êÇÈ
vld2_lane_s16Ám¿·. ¸êÇÈvld2q_lane_s16Áué¾. ¼êÇÈ
vld2_lane_s32Ám•Æ. ÀêÇÈvld2q_lane_s32Áu¿Í. ÄêÇÈ vld2_lane_u8Áe¼‹/ ÈêÇÈ
vld2_lane_u16Ámš“/ ÊêÇÈvld2q_lane_u16Áuþš/ ÌêÇÈ
vld2_lane_u32Ámã¢/ ÎêÇÈvld2q_lane_u32ÁuǪ/ ÐêÇÈ vld2_lane_p8Áe«²/ ÒêÇÈ
vld2_lane_p16Ám‰º/ ÔêÇÈvld2q_lane_p16ÁuíÁ/ ÖêÇÈvld2_p64ÁEšÉ/ ØêÇÈvld2_s64ÁEÐÒ/ ÙêÇÈvld2_u64ÁEûÚ/ ÜêÇÈvld2_u8Á=¹á/ ÝêÇÈvld2q_u8ÁEôç/ ÞêÇÈvld2_u16ÁE²î/ ßêÇÈ vld2q_u16ÁMòô/ àêÇÈvld2_u32ÁE³û/ áêÇÈ vld2q_u32ÁMó0 âêÇÈvld2_p8Á=³ˆ0 ãêÇÈvld2q_p8ÁEîŽ0 äêÇÈvld2_p16ÁE¬•0 åêÇÈ vld2q_p16ÁMì›0 æêÇÈ vld3_dup_f16Áeí¯0 çêÇÈ
vld3q_dup_f16Ám¯·0 êêÇÈ vld3_dup_f32ÁeŽ0 íêÇÈ
vld3q_dup_f32ÁmÙÃ0 ðêÇÈ vld3_dup_s8Á]îÉ0 óêÇÈ vld3q_dup_s8ÁeõÏ0 öêÇÈ vld3_dup_s16Áe‚Ö0 ùêÇÈ
vld3q_dup_s16Ám’Ü0 üêÇÈ vld3_dup_s32Áe¤â0 ÿêÇÈ
vld3q_dup_s32Ám´è0 ‚ëÇÈ vld3_dup_s64ÁeÆî0 …ëÇÈ vld3_dup_p64Áeþ¥1 ˆëÇÈ vld3_dup_u64ÁeͲ1 ‰ëÇÈ vld3_dup_u8Á]Ó¹1 ŠëÇÈ vld3q_dup_u8ÁeÊ1 ‹ëÇÈ vld3_dup_u16ÁeÛÜ1 ŒëÇÈ
vld3q_dup_u16Ámþì1 ëÇÈ vld3_dup_u32ÁeÉý1 ŽëÇÈ
vld3q_dup_u32ÁmÚ2 ëÇÈ vld3_dup_p8Á]€ž2 ëÇÈ vld3q_dup_p8Áe¼®2 ‘ëÇÈ vld3_dup_p16ÁeˆÁ2 ’ëÇÈ
vld3q_dup_p16Ám«Ñ2 “ëÇÈvld3_f16ÁEËî2 ”ëÇÈ vld3q_f16ÁM¬ô2 •ëÇÈvld3_f32ÁEÇø2 –ëÇÈ vld3q_f32ÁMâü2 —ëÇÈvld3_s8Á=ü€3 ˜ëÇÈvld3q_s8ÁE…3 ™ëÇÈvld3_s16ÁE§‰3 šëÇÈ vld3q_s16ÁMÀ3 ›ëÇÈvld3_s32ÁEÙ‘3 œëÇÈ vld3q_s32ÁMò•3 ëÇÈ
vld3_lane_f16Ám·Ù3 žëÇÈvld3q_lane_f16Áuøâ3 ¢ëÇÈ
vld3_lane_f32Ámë3 ¦ëÇÈvld3q_lane_f32ÁuŸó3 ªëÇÈ vld3_lane_s8Áešƒ4 ®ëÇÈ
vld3_lane_s16Ám’‹4 ²ëÇÈvld3q_lane_s16Áu–“4 ¶ëÇÈ
vld3_lane_s32Ámœ›4 ºëÇÈvld3q_lane_s32Áu £4 ¾ëÇÈ vld3_lane_
vldrq_p128ÁUûÇ; ×ìÇÈvmax_f16ÁEßÍ; ØìÇÈ vmaxq_f16ÁMÈÖ; ÛìÇÈvmax_f32ÁE‡ß; ÞìÇÈ vmaxq_f32ÁMÄç; áìÇÈvmax_s8Á=‚ð; äìÇÈvmaxq_s8ÁEö; åìÇÈvmax_s16ÁE½ü; æìÇÈ vmaxq_s16ÁMÞ‚< çìÇÈvmax_s32ÁEÿˆ< èìÇÈ vmaxq_s32ÁM < éìÇÈvmax_u8Á=À•< êìÇÈvmaxq_u8ÁEß›< ëìÇÈvmax_u16ÁEƒ¢< ììÇÈ vmaxq_u16ÁM¨¨< íìÇÈvmax_u32ÁEÍ®< îìÇÈ vmaxq_u32ÁMò´< ïìÇÈ
vmaxnm_f16ÁUè»< ðìÇÈ vmaxnmq_f16Á]ÿÄ< óìÇÈ
vmaxnm_f32ÁUìÍ< öìÇÈ vmaxnmq_f32Á]×Ö< ùìÇÈvmin_f16ÁEËß< üìÇÈ vminq_f16ÁM´è< ÿìÇÈvmin_f32ÁEóð< ‚íÇÈ vminq_f32ÁM°ù< …íÇÈvmin_s8Á=î= ˆíÇÈvminq_s8ÁE‰ˆ= ‰íÇÈvmin_s16ÁE©Ž= ŠíÇÈ vminq_s16ÁMÊ”= ‹íÇÈvmin_s32ÁEëš= ŒíÇÈ vminq_s32ÁMŒ¡= íÇÈvmin_u8Á=¬§= ŽíÇÈvminq_u8ÁEË­= íÇÈvmin_u16ÁEï³= íÇÈ vminq_u16ÁM”º= ‘íÇÈvmin_u32ÁE¹À= ’íÇÈ vminq_u32ÁMÞÆ= “íÇÈ
vminnm_f16ÁUÔÍ= ”íÇÈ vminnmq_f16Á]ëÖ= —íÇÈ
vminnm_f32ÁUØß= šíÇÈ vminnmq_f32Á]Ãè= íÇÈvmla_f32ÁE«ñ=  íÇÈ vmlaq_f32ÁMÍ÷= ¡íÇÈ
vmla_lane_f32Ám¦þ= ¢íÇÈvmla_laneq_f32Áuï…> ¤íÇÈvmlaq_lane_f32Áu¹> ¦íÇÈvmlaq_laneq_f32Á}Ú•> ¨íÇÈ
vmla_lane_s16Ámù> ªíÇÈ
vmla_lane_u16Ámþ¥> ¬íÇÈvmla_laneq_s16Áuˆ®> ®íÇÈvmla_laneq_u16Áu¶> °íÇÈvmlaq_lane_s16Áuš¾> ²íÇÈvmlaq_lane_u16ÁuÆÈ> ´íÇÈvmlaq_laneq_s16Á}÷Ò> ¶íÇÈvmlaq_laneq_u16Á}¥Ý> ¸íÇÈ
vmla_lane_s32ÁmÕç> ºíÇÈ
vmla_lane_u32Ám…ï> ¼íÇÈvmla_laneq_s32Áuºö> ¾íÇÈvmla_laneq_u32Áuìý> ÀíÇÈvmlaq_lane_s32Áu¢…? ÂíÇÈvmlaq_lane_u32Áuª? ÄíÇÈvmlaq_laneq_s32Á}·•? ÆíÇÈvmlaq_laneq_u32Á}Á? ÈíÇÈ
vmla_n_f32ÁU•¥? ÊíÇÈ vmlaq_n_f32Á]¦«? ËíÇÈ
vmla_n_s16ÁU¸±? ÌíÇÈ vmlaq_n_s16Á]·? ÍíÇÈ
vmla_n_u16ÁUν? ÎíÇÈ vmlaq_n_u16Á]ÛÃ? ÏíÇÈ
vmla_n_s32ÁUêÉ? ÐíÇÈ vmlaq_n_s32Á]ôÏ? ÑíÇÈ
vmla_n_u32ÁU€Ö? ÒíÇÈ vmlaq_n_u32Á]Ü? ÓíÇÈvmla_s8Á=â? ÔíÇÈvmlaq_s8ÁEè? ÕíÇÈvmla_s16ÁE™î? ÖíÇÈ vmlaq_s16ÁM£ô? ×íÇÈvmla_s32ÁE­ú? ØíÇÈ vmlaq_s32ÁM·€@ ÙíÇÈvmla_u8Á=¿†@ ÚíÇÈvmlaq_u8ÁEÆŒ@ ÛíÇÈvmla_u16ÁEÓ’@ ÜíÇÈ vmlaq_u16ÁMá˜@ ÝíÇÈvmla_u32ÁEïž@ ÞíÇÈ vmlaq_u32ÁMý¤@ ßíÇÈvmlal_lane_s16ÁuÞ«@ àíÇÈvmlal_laneq_s16Á}ó³@ âíÇÈvmlal_lane_s32Áuˆ¼@ äíÇÈvmlal_laneq_s32Á}ÈÃ@ æíÇÈvmlal_lane_u16ÁuˆË@ èíÇÈvmlal_laneq_u16Á}¡Ó@ êíÇÈvmlal_lane_u32ÁuºÛ@ ìíÇÈvmlal_laneq_u32Á}þâ@ îíÇÈ vmlal_n_s16Á]‰ê@ ðíÇÈ vmlal_n_s32Á]¡ð@ ñíÇÈ vmlal_n_u16Á]¹ö@ òíÇÈ vmlal_n_u32Á]Ôü@ óíÇÈvmlal_s8ÁEÔ‚A ôíÇÈ vmlal_s16ÁM܈A õíÇÈ vmlal_s32ÁMèŽA öíÇÈvmlal_u8ÁEô”A ÷íÇÈ vmlal_u16ÁM‚›A øíÇÈ vmlal_u32ÁM”¡A ùíÇÈvmls_f32ÁEº§A úíÇÈ vmlsq_f32ÁMã­A ûíÇÈ
vmls_lane_f32Ámº´A üíÇÈvmls_laneq_f32Áu¼A þíÇÈvmlsq_lane_f32ÁuÉÃA €îÇÈvmlsq_laneq_f32Á}èËA ‚îÇÈ
vmls_lane_s16Ám…ÔA „îÇÈ
vmls_lane_u16ÁmˆÜA †îÇÈvmls_laneq_s16ÁuäA ˆîÇÈvmls_laneq_u16Áu•ìA ŠîÇÈvmlsq_lane_s16ÁužôA ŒîÇÈvmlsq_lane_u16ÁuÈþA ŽîÇÈvmlsq_laneq_s16Á}÷ˆB îÇÈvmlsq_laneq_u16Á}£“B ’îÇÈ
vmls_lane_s32ÁmÑB ”îÇÈ
vmls_lane_u32Ámÿ¤B –îÇÈvmls_laneq_s32Áu²¬B ˜îÇÈvmls_laneq_u32Áuâ³B šîÇÈvmlsq_lane_s32Áu–»B œîÇÈvmlsq_lane_u32ÁuœÃB žîÇÈvmlsq_laneq_s32Á}§ËB  îÇÈvmlsq_laneq_u32Á}¯ÓB ¢îÇÈ
vmls_n_f32ÁUÛB ¤îÇÈ vmlsq_n_f32Á]áB ¥îÇÈ
vmls_n_s16ÁU çB ¦îÇÈ vmlsq_n_s16Á]¨íB §îÇÈ
vmls_n_u16ÁU²óB ¨îÇÈ vmlsq_n_u16Á]½ùB ©îÇÈ
vmls_n_s32ÁUÊÿB ªîÇÈ vmlsq_n_s32Á]Ò…C «îÇÈ
vmls_n_u32ÁUÜ‹C ¬îÇÈ vmlsq_n_u32Á]ç‘C ­îÇÈvmls_s8Á=î—C ®îÇÈvmlsq_s8ÁEøC ¯îÇÈvmls_s16ÁEˆ¤C °îÇÈ vmlsq_s16ÁM™ªC ±îÇÈvmls_s32ÁEª°C ²îÇÈ vmlsq_s32ÁM»¶C ³îÇÈvmls_u8Á=ʼC ´îÇÈvmlsq_u8ÁEØÂC µîÇÈvmls_u16ÁEìÈC ¶îÇÈ vmlsq_u16ÁMÏC ·îÇÈvmls_u32ÁE–ÕC ¸îÇÈ vmlsq_u32ÁM«ÛC ¹îÇÈvmlsl_lane_s16ÁuŠâC ºîÇÈvmlsl_laneq_s16Á}êC ¼îÇÈvmlsl_lane_s32Áu°òC ¾îÇÈvmlsl_laneq_s32Á}îùC ÀîÇÈvmlsl_lane_u16Áu¬D ÂîÇÈvmlsl_laneq_u16Á}ÉD ÄîÇÈvmlsl_lane_u32ÁuÚ‘D ÆîÇÈvmlsl_laneq_u32Á}œ™D ÈîÇÈ vmlsl_n_s16Á]¥ D ÊîÇÈ vmlsl_n_s32Á]»¦D ËîÇÈ vmlsl_n_u16Á]ѬD ÌîÇÈ vmlsl_n_u32Á]ê²D ÍîÇÈvmlsl_s8ÁEï¸D ÎîÇÈ vmlsl_s16ÁMü¾D ÏîÇÈ vmlsl_s32ÁMÅD ÐîÇÈvmlsl_u8ÁEžËD ÑîÇÈ vmlsl_u16ÁM±ÑD ÒîÇÈ vmlsl_u32ÁMÈ×D ÓîÇÈ
vmmlaq_s32ÁUêÝD ÔîÇÈ
vmmlaq_u32ÁUïæD ×îÇÈ
vmov_n_f16ÁU¶ïD ÚîÇÈ vmovq_n_f16Á]ÖôD ÛîÇÈ
vmov_n_f32ÁU¼úD ÜîÇÈ
vmov_n_p16ÁU¨€E ÝîÇÈ vmov_n_p8ÁM‘†E ÞîÇÈ
vmov_n_s16ÁUø‹E ßîÇÈ
vmov_n_s32ÁUâ‘E àîÇÈ
vmov_n_s64ÁUÊ—E áîÇÈ vmov_n_s8ÁM²E âîÇÈ
vmov_n_u16ÁU˜£E ãîÇÈ
vmov_n_u32ÁUƒ©E äîÇÈ
vmov_n_u64ÁUì®E åîÇÈ vmov_n_u8ÁMÕ´E æîÇÈ vmovq_n_f32Á]½ºE çîÇÈ vmovq_n_p16Á]¬ÀE èîÇÈ
vmovq_n_p8ÁU˜ÆE éîÇÈ vmovq_n_s16Á]ƒÌE êîÇÈ vmovq_n_s32Á]ðÑE ëîÇÈ vmovq_n_s64Á]Ú×E ìîÇÈ
vmovq_n_s8ÁUÅÝE íîÇÈ vmovq_n_u16Á]¯ãE îîÇÈ vmovq_n_u32Á]éE ïîÇÈ vmovq_n_u64Á]ˆïE ðîÇÈ
vmovq_n_u8ÁUôôE ñîÇÈ vmovl_s16ÁM¿úE òîÇÈ vmovl_s32ÁM‘€F óîÇÈvmovl_s8ÁEâ…F ôîÇÈ vmovl_u16ÁM²‹F õîÇÈ vmovl_u32ÁM†‘F öîÇÈvmovl_u8ÁEÙ–F ÷îÇÈ vmovn_s16ÁM¯œF øîÇÈ vmovn_s32ÁM„¢F ùîÇÈ vmovn_s64ÁMÚ§F úîÇÈ vmovn_u16ÁM°­F ûîÇÈ vmovn_u32ÁM‡³F üîÇÈ vmovn_u64ÁM߸F ýîÇÈvmul_f16ÁEÚ¾F þîÇÈ vmulq_f16ÁMéÄF ÿîÇÈvmul_f32ÁEÌÊF €ïÇÈ vmulq_f32ÁM¯ÐF ïÇÈ
vmul_lane_f16ÁmóÖF ‚ïÇÈvmulq_lane_f16ÁuëÞF „ïÇÈ
vmul_lane_f32ÁmêèF †ïÇÈvmul_laneq_f32ÁuüïF ˆïÇÈvmulq_lane_f32Áu÷F ŠïÇÈvmulq_laneq_f32Á}ìþF ŒïÇÈ
vmul_lane_s16Ám¸†G ŽïÇÈvmulq_lane_s16ÁuýG ïÇÈ
vmul_lane_s32Ámæ—G ’ïÇÈvmulq_lane_s32ÁuâžG ”ïÇÈ
vmul_lane_u16Ám§¦G –ïÇÈvmulq_lane_u16Áuï­G ˜ïÇÈ
vmul_lane_u32ÁmÛ·G šïÇÈvmulq_lane_u32ÁuÚ¾G œïÇÈvmul_laneq_s16Áu£ÆG žïÇÈvmulq_laneq_s16Á}êÍG  ïÇÈvmul_laneq_s32ÁuÕ×G ¢ïÇÈvmulq_laneq_s32Á}ÓÞG ¤ïÇÈvmul_laneq_u16ÁušæG ¦ïÇÈvmulq_laneq_u16Á}äíG ¨ïÇÈvmul_laneq_u32ÁuÒ÷G ªïÇÈvmulq_laneq_u32Á}ÓþG ¬ïÇÈ
vmul_n_f16ÁU„…H ®ïÇÈ vmulq_n_f16Á]‰ŠH ¯ïÇÈ
vmul_n_f32ÁU€H °ïÇÈ vmulq_n_f32Á]ö•H ±ïÇÈ
vmul_n_s16ÁUì›H ²ïÇÈ vmulq_n_s16Á]Ý¡H ³ïÇÈ
vmul_n_s32ÁUϧH ´ïÇÈ vmulq_n_s32Á]À­H µïÇÈ
vmul_n_u16ÁU²³H ¶ïÇÈ vmulq_n_u16Á]¥¹H ·ïÇÈ
vmul_n_u32ÁU™¿H ¸ïÇÈ vmulq_n_u32Á]ŒÅH ¹ïÇÈvmul_p8Á=øÊH ºïÇÈvmulq_p8ÁE¦ÓH ½ïÇÈvmul_s16ÁEÙÛH ÀïÇÈ vmulq_s16ÁMµáH ÁïÇÈvmul_u16ÁE‘çH ÂïÇÈ vmulq_u16ÁMðìH ÃïÇÈvmul_s32ÁEÏòH ÄïÇÈ vmulq_s32ÁM«øH ÅïÇÈvmul_u32ÁE‡þH ÆïÇÈ vmulq_u32ÁMæƒI ÇïÇÈvmul_s8Á=ÉI ÈïÇÈvmulq_s8ÁE™I ÉïÇÈvmul_u8Á=ò”I ÊïÇÈvmulq_u8ÁEËšI ËïÇÈvmull_lane_s16Áuø I ÌïÇÈvmull_laneq_s16Á}Ù¨I ÎïÇÈvmull_lane_s32Áuº°I ÐïÇÈvmull_laneq_s32Á}Ò·I ÒïÇÈvmull_lane_u16Áuê¾I ÔïÇÈvmull_laneq_u16Á}ÎÆI ÖïÇÈvmull_lane_u32Áu²ÎI ØïÇÈvmull_laneq_u32Á}ÍÕI ÚïÇÈ vmull_n_s16Á]±ÜI ÜïÇÈ vmull_n_s32Á]£âI ÝïÇÈ vmull_n_u16Á]•èI ÞïÇÈ vmull_n_u32Á]‰îI ßïÇÈvmull_p8ÁE÷óI àïÇÈ vmull_s16ÁM¸üI ãïÇÈ vmull_s32ÁMº‚J äïÇÈvmull_s8ÁEºˆJ åïÇÈvmull_u8ÁE¹ŽJ æïÇÈ vmull_u16ÁM½”J çïÇÈ vmull_u32ÁMÄšJ èïÇÈvmvn_p8Á=½ J éïÇÈvmvn_s16ÁE±¦J êïÇÈvmvn_s32ÁE¥¬J ëïÇÈvmvn_s8Á=˜²J ìïÇÈvmvn_u16ÁEˆ¸J íïÇÈvmvn_u32ÁEƒ¾J îïÇÈvmvn_u8Á=„ÄJ ïïÇÈvmvnq_p8ÁEøÉJ ðïÇÈ vmvnq_s16ÁMñÏJ ñïÇÈ vmvnq_s32ÁMçÕJ òïÇÈvmvnq_s8ÁEÜÛJ óïÇÈ vmvnq_u16ÁMÑáJ ôïÇÈ vmvnq_u32ÁMÎçJ õïÇÈvmvnq_u8ÁEÑíJ öïÇÈvneg_f16ÁEïóJ ÷ïÇÈ vnegq_f16ÁMéùJ øïÇÈvneg_f32ÁE·ÿJ ùïÇÈ vnegq_f32ÁM……K úïÇÈvneg_s8Á=ЊK ûïÇÈvnegq_s8ÁE”K üïÇÈvneg_s16ÁEÜ•K ýïÇÈ vnegq_s16ÁM¥›K þïÇÈvneg_s32ÁEî K ÿïÇÈ vnegq_s32ÁM·¦K €ðÇÈvorn_s16ÁE“¬K ðÇÈvorn_s32ÁE­²K ‚ðÇÈvorn_s64ÁEǸK ƒðÇÈvorn_s8Á=à¾K „ðÇÈ vornq_s16ÁMöÄK …ðÇÈ vornq_s32ÁM’ËK †ðÇÈ vornq_s64ÁM®ÑK ‡ðÇÈvornq_s8ÁEÉ×K ˆðÇÈvorn_u16ÁEãÝK ‰ðÇÈvorn_u32ÁE‹äK ŠðÇÈvorn_u64ÁE³êK ‹ðÇÈvorn_u8Á=ÚðK ŒðÇÈ vornq_u16ÁMþöK ðÇÈ vornq_u32ÁM¨ýK ŽðÇÈ vornq_u64ÁMÒƒL ðÇÈvornq_u8ÁEû‰L ðÇÈvorr_s8Á=«L ‘ðÇÈvorrq_s8ÁE›–L ’ðÇÈvorr_s16ÁEœL “ðÇÈ vorrq_s16ÁM„¢L ”ðÇÈvorr_s32ÁEù§L •ðÇÈ vorrq_s32ÁMî­L –ðÇÈvorr_s64ÁEã³L —ðÇÈ vorrq_s64ÁMعL ˜ðÇÈvorr_u8Á=Ì¿L ™ðÇÈvorrq_u8ÁE¿ÅL šðÇÈvorr_u16ÁE¶ËL ›ðÇÈ vorrq_u16ÁM®ÑL œðÇÈvorr_u32ÁE¦×L ðÇÈ vorrq_u32ÁMžÝL žðÇÈvorr_u64ÁE–ãL ŸðÇÈ vorrq_u64ÁMŽéL  ðÇÈ vpadal_s8ÁM‘ïL ¡ðÇÈ
vpadalq_s8ÁUÛöL ¢ðÇÈ
vpadal_s16ÁUªþL £ðÇÈ vpadalq_s16Á]ú…M ¤ðÇÈ
vpadal_s32ÁUÌM ¥ðÇÈ vpadalq_s32Á]œ•M ¦ðÇÈ vpadal_u8ÁMîœM §ðÇÈ
vpadalq_u8ÁU¾¤M ¨ðÇÈ
vpadal_u16ÁU“¬M ©ðÇÈ vpadalq_u16Á]é³M ªðÇÈ
vpadal_u32ÁUÁ»M «ðÇÈ vpadalq_u32Á]—ÃM ¬ðÇÈ vpadd_f16ÁMƒËM ­ðÇÈ vpadd_f32ÁMÑÓM °ðÇÈvpadd_s8ÁEÜM ³ðÇÈ vpadd_s16ÁM¶äM ¶ðÇÈ vpadd_s32ÁMèìM ¹ðÇÈvpadd_u8ÁEºõM ¼ðÇÈ vpadd_u16ÁMþƒN ½ðÇÈ vpadd_u32ÁM¬’N ¾ðÇÈ vpaddl_s8ÁMÊ N ¿ðÇÈ
vpaddlq_s8ÁU©N ÂðÇÈ
vpaddl_s16ÁUرN ÅðÇÈ vpaddlq_s16Á]¤ºN ÈðÇÈ
vpaddl_s32ÁUòÂN ËðÇÈ vpaddlq_s32Á]¾ËN ÎðÇÈ vpaddl_u8ÁMŒÔN ÑðÇÈ
vpaddlq_u8ÁUÕÜN ÔðÇÈ
vpaddl_u16ÁU¦åN ×ðÇÈ vpaddlq_u16Á]øíN ÚðÇÈ
vpaddl_u32ÁUÌöN ÝðÇÈ vpaddlq_u32Á]žÿN àðÇÈ vpmax_f32ÁMà‡O ãðÇÈvpmax_s8ÁE´O æðÇÈ vpmax_s16ÁMò˜O éðÇÈ vpmax_s32ÁM»¡O ìðÇÈvpmax_u8ÁEƒªO ïðÇÈ vpmax_u16ÁMDzO òðÇÈ vpmax_u32ÁM–»O õðÇÈ vpmin_f32ÁMåÃO øðÇÈvpmin_s8ÁE¹ÌO ûðÇÈ vpmin_s16ÁM÷ÔO þðÇÈ vpmin_s32ÁMÀÝO ñÇÈvpmin_u8ÁEˆæO „ñÇÈ vpmin_u16ÁMÌîO ‡ñÇÈ vpmin_u32ÁM›÷O ŠñÇÈvqabs_s8ÁEíÿO ñÇÈ vqabsq_s8ÁM‘ˆP ñÇÈ vqabs_s16ÁM¿P “ñÇÈ
vqabsq_s16ÁUî˜P –ñÇÈ vqabs_s32ÁMŸ¡P ™ñÇÈ
vqabsq_s32ÁUΩP œñÇÈvqadd_s8ÁEë±P ŸñÇÈ vqaddq_s8ÁM×·P  ñÇÈ vqadd_s16ÁMȽP ¡ñÇÈ
vqaddq_s16ÁUºÃP ¢ñÇÈ vqadd_s32ÁM¬ÉP £ñÇÈ
vqaddq_s32ÁUžÏP ¤ñÇÈ vqadd_s64ÁMÕP ¥ñÇÈ
vqaddq_s64ÁU‚ÛP ¦ñÇÈvqadd_u8ÁEòàP §ñÇÈ vqaddq_u8ÁMáæP ¨ñÇÈ vqadd_u16ÁMÕìP ©ñÇÈ
vqaddq_u16ÁUÊòP ªñÇÈ vqadd_u32ÁM¿øP «ñÇÈ
vqaddq_u32ÁU´þP ¬ñÇÈ vqadd_u64ÁM©„Q ­ñÇÈ
vqaddq_u64ÁUžŠQ ®ñÇÈvqdmlal_lane_s16Á…ýQ ¯ñÇÈvqdmlal_lane_s32Á…¥˜Q ±ñÇÈ
vqdmlal_n_s16ÁmšŸQ ³ñÇÈ
vqdmlal_n_s32ÁmÌ¥Q ´ñÇÈ vqdmlal_s16Á]å«Q µñÇÈ vqdmlal_s32Á]€²Q ¶ñÇÈvqdmlsl_lane_s16Á…å¸Q ·ñÇÈvqdmlsl_lane_s32Á…‹ÀQ ¹ñÇÈ
vqdmlsl_n_s16ÁmþÆQ »ñÇÈ
vqdmlsl_n_s32Ám®ÍQ ¼ñÇÈ vqdmlsl_s16Á]ÌÓQ ½ñÇÈ vqdmlsl_s32Á]ìÙQ ¾ñÇÈvqdmulh_laneq_s16ÁÉàQ ¿ñÇÈvqdmulhq_laneq_s16Á•ûçQ ÁñÇÈvqdmulh_laneq_s32Á¯ïQ ÃñÇÈvqdmulhq_laneq_s32Á•áöQ ÅñÇÈ
vqdmulh_n_s16ÁmÝýQ ÇñÇÈvqdmulhq_n_s16Áuˆ„R ÈñÇÈ
vqdmulh_n_s32ÁmµŠR ÉñÇÈvqdmulhq_n_s32ÁuàR ÊñÇÈ vqdmulh_s16Á]Ž—R ËñÇÈ vqdmulhq_s16ÁeýŸR ÎñÇÈ vqdmulh_s32Á]î¨R ÑñÇÈ vqdmulhq_s32ÁeݱR ÔñÇÈvqdmull_lane_s16Á…þºR ×ñÇÈvqdmull_lane_s32Á…ÄÂR ÙñÇÈ
vqdmull_n_s16ÁmÙÉR ÛñÇÈ
vqdmull_n_s32ÁméÏR ÜñÇÈ vqdmull_s16Á]ëÕR ÝñÇÈ vqdmull_s32Á]ÊÞR àñÇÈ
vqmovn_s16ÁUçR ãñÇÈ
vqmovn_s32ÁUÈïR æñÇÈ
vqmovn_s64ÁU÷÷R éñÇÈ
vqmovn_u16ÁU¨€S ìñÇÈ
vqmovn_u32ÁUÙˆS ïñÇÈ
vqmovn_u64ÁUŽ‘S òñÇÈ vqmovun_s16Á]Í™S õñÇÈ vqmovun_s32Á]‹¢S øñÇÈ vqmovun_s64Á]ͪS ûñÇÈvqneg_s8ÁEý²S þñÇÈ vqnegq_s8ÁM™»S òÇÈ vqneg_s16ÁM¿ÃS „òÇÈ
vqnegq_s16ÁUæËS ‡òÇÈ vqneg_s32ÁMÔS ŠòÇÈ
vqnegq_s32ÁU¶ÜS òÇÈvqrdmulh_lane_s16ÁÀåS òÇÈvqrdmulh_lane_s32ÁÓíS ’òÇÈvqrdmulh_laneq_s16Á•ÁõS ”òÇÈvqrdmulh_laneq_s32Á•ÖýS –òÇÈvqrdmulhq_lane_s16Á•Å…T ˜òÇÈvqrdmulhq_lane_s32Á•¿T šòÇÈvqrdmulhq_laneq_s16ÁÖ—T œòÇÈvqrdmulhq_laneq_s32ÁÒ¡T žòÇÈvqrdmulh_n_s16Áu±©T  òÇÈvqrdmulhq_n_s16Á}ЯT ¡òÇÈvqrdmulh_n_s32ÁuñµT ¢òÇÈvqrdmulhq_n_s32Á}¼T £òÇÈ vqrdmulh_s16Áe²ÂT ¤òÇÈ
vqrdmulhq_s16Ám²ËT §òÇÈ vqrdmulh_s32Áe´ÔT ªòÇÈ
vqrdmulhq_s32Ám´ÝT ­òÇÈ vqrshl_s8ÁM”æT °òÇÈ
vqrshlq_s8ÁUàîT ³òÇÈ
vqrshl_s16ÁU·÷T ¶òÇÈ vqrshlq_s16Á]€U ¹òÇÈ
vqrshl_s32ÁUéˆU ¼òÇÈ vqrshlq_s32Á]Á‘U ¿òÇÈ
vqrshl_s64ÁU›šU ÂòÇÈ vqrshlq_s64Á]ó¢U ÅòÇÈ vqrshl_u8ÁMÕ«U ÈòÇÈ
vqrshlq_u8ÁU®´U ËòÇÈ
vqrshl_u16ÁU’½U ÎòÇÈ vqrshlq_u16Á]÷ÅU ÑòÇÈ
vqrshl_u32ÁUÞÎU ÔòÇÈ vqrshlq_u32Á]Ã×U ×òÇÈ
vqrshl_u64ÁUªàU ÚòÇÈ vqrshlq_u64Á]éU ÝòÇÈ
vqrshrn_n_s16ÁmïV àòÇÈ
vqrshrn_n_s32Ám†ˆV äòÇÈ
vqrshrn_n_s64Ám¡ŽV èòÇÈ
vqrshrn_n_u16ÁmŒ§V ìòÇÈ
vqrshrn_n_u32Ám°­V ðòÇÈ
vqrshrn_n_u64ÁmسV ôòÇÈvqrshrun_n_s16ÁuÈÌV øòÇÈvqrshrun_n_s32ÁuðÒV üòÇÈvqrshrun_n_s64ÁuœÙV €óÇÈ
vqshl_n_s8ÁUóáV „óÇÈ vqshlq_n_s8Á]»èV †óÇÈ vqshl_n_s16Á]ˆïV ˆóÇÈ vqshlq_n_s16ÁeÖõV ŠóÇÈ vqshl_n_s32Á]¦üV ŒóÇÈ vqshlq_n_s32Áeô‚W ŽóÇÈ vqshl_n_s64Á]ĉW óÇÈ vqshlq_n_s64ÁeW ’óÇÈ
vqshl_n_u8ÁUã–W ”óÇÈ vqshlq_n_u8Á]¯W –óÇÈ vqshl_n_u16Á]€¤W ˜óÇÈ vqshlq_n_u16ÁeÒªW šóÇÈ vqshl_n_u32Á]¦±W œóÇÈ vqshlq_n_u32Áeø·W žóÇÈ vqshl_n_u64Á]̾W  óÇÈ vqshlq_n_u64ÁežÅW ¢óÇÈvqshl_s8ÁE½ËW ¤óÇÈ vqshlq_s8ÁMøÓW §óÇÈ vqshl_s16ÁM¾ÜW ªóÇÈ
vqshlq_s16ÁU…åW ­óÇÈ vqshl_s32ÁMÎíW °óÇÈ
vqshlq_s32ÁU•öW ³óÇÈ vqshl_s64ÁMÞþW ¶óÇÈ
vqshlq_s64ÁU¥‡X ¹óÇÈvqshl_u8ÁEïX ¼óÇÈ vqshlq_u8ÁM°˜X ¿óÇÈ vqshl_u16ÁMü X ÂóÇÈ
vqshlq_u16ÁUÉ©X ÅóÇÈ vqshl_u32ÁM˜²X ÈóÇÈ
vqshlq_u32ÁUåºX ËóÇÈ vqshl_u64ÁM´ÃX ÎóÇÈ
vqshlq_u64ÁUÌX ÑóÇÈ vqshlu_n_s8Á]†‚Y ÔóÇÈ vqshluq_n_s8Áe¯ˆY ÚóÇÈ vqshlu_n_s16ÁeãŽY àóÇÈ
vqshluq_n_s16Ám˜•Y æóÇÈ vqshlu_n_s32ÁeÏ›Y ìóÇÈ
vqshluq_n_s32Ámý¡Y òóÇÈ vqshlu_n_s64Áe­¨Y øóÇÈ
vqshluq_n_s64Ámß®Y ýóÇÈ vqshrn_n_s16ÁeþÆY ƒôÇÈ vqshrn_n_s32Áe‡ÍY ‡ôÇÈ vqshrn_n_s64Áe”ÓY ‹ôÇÈ vqshrn_n_u16Áe«ëY ôÇÈ vqshrn_n_u32ÁeºñY “ôÇÈ vqshrn_n_u64ÁeÍ÷Y —ôÇÈ
vqshrun_n_s16Ám…Z ›ôÇÈ
vqshrun_n_s32ÁmŸ–Z ŸôÇÈ
vqshrun_n_s64Ám½œZ £ôÇÈvqsub_s8ÁEÚ¤Z §ôÇÈ vqsubq_s8ÁM˪Z ¨ôÇÈ vqsub_s16ÁMÁ°Z ©ôÇÈ
vqsubq_s16ÁU¸¶Z ªôÇÈ vqsub_s32ÁM¯¼Z «ôÇÈ
vqsubq_s32ÁU¦ÂZ ¬ôÇÈ vqsub_s64ÁMÈZ ­ôÇÈ
vqsubq_s64ÁU”ÎZ ®ôÇÈvqsub_u8ÁE‰ÔZ ¯ôÇÈ vqsubq_u8ÁMýÙZ °ôÇÈ vqsub_u16ÁMößZ ±ôÇÈ
vqsubq_u16ÁUðåZ ²ôÇÈ vqsub_u32ÁMêëZ ³ôÇÈ
vqsubq_u32ÁUäñZ ´ôÇÈ vqsub_u64ÁMÞ÷Z µôÇÈ
vqsubq_u64ÁUØýZ ¶ôÇÈvraddhn_high_s16Á…ùƒ[ ·ôÇÈvraddhn_high_s32Á…ûŠ[ ¸ôÇÈvraddhn_high_s64Á…à‘[ ¹ôÇÈvraddhn_high_u16Á…¹˜[ ºôÇÈvraddhn_high_u32Á…ûŸ[ »ôÇÈvraddhn_high_u64Á…¡§[ ¼ôÇÈ vraddhn_s16Á]©®[ ½ôÇÈ vraddhn_s32Á]ƒ·[ ÀôÇÈ vraddhn_s64Á]á¿[ ÃôÇÈ vraddhn_u16Á]àÈ[ ÆôÇÈ vraddhn_u32Á]û×[ ÇôÇÈ vraddhn_u64Á]õæ[ ÈôÇÈ
vrecpe_f16ÁUÑõ[ ÉôÇÈ vrecpeq_f16Á]ªþ[ ÌôÇÈ
vrecpe_f32ÁUÙ†\ ÏôÇÈ vrecpeq_f32Á]†\ ÒôÇÈ
vrecpe_u32ÁU½—\ ÕôÇÈ vrecpeq_u32Á]îŸ\ ØôÇÈ
vrecps_f16ÁUϨ\ ÛôÇÈ vrecpsq_f16Á]Õ±\ ÞôÇÈ
vrecps_f32ÁU±º\ áôÇÈ vrecpsq_f32Á]‹Ã\ äôÇÈvreinterpret_f32_f16Á¥¶Ì\ çôÇÈvreinterpret_s8_f16ÁÓÚ\ èôÇÈvreinterpret_s16_f16Á¥÷è\ éôÇÈvreinterpret_s32_f16Á¥•÷\ êôÇÈvreinterpret_s64_f16Á¥­…] ëôÇÈvreinterpret_u8_f16Áî’] ìôÇÈvreinterpret_u16_f16Á¥•¡] íôÇÈvreinterpret_u32_f16Á¥¶¯] îôÇÈvreinterpret_u64_f16Á¥Ñ½] ïôÇÈvreinterpret_p8_f16Á”Ë] ðôÇÈvreinterpret_p16_f16Á¥»Ù] ñôÇÈvreinterpretq_f32_f16Á­Ýç] òôÇÈvreinterpretq_s8_f16Á¥ö] óôÇÈvreinterpretq_s16_f16Á­“…^ ôôÇÈvreinterpretq_s32_f16Á­Í“^ õôÇÈvreinterpretq_s64_f16Á­û¡^ öôÇÈvreinterpretq_u8_f16Á¥¢°^ ÷ôÇÈvreinterpretq_u16_f16Á­¨¿^ øôÇÈvreinterpretq_u32_f16Á­åÍ^ ùôÇÈvreinterpretq_u64_f16Á­–Ü^ úôÇÈvreinterpretq_p8_f16Á¥Àê^ ûôÇÈvreinterpretq_p16_f16Á­Æù^ üôÇÈvreinterpret_f16_f32Á¥‚ˆ_ ýôÇÈvreinterpretq_f16_f32Á­¡–_ þôÇÈvreinterpret_f16_s8ÁÓ¤_ ÿôÇÈvreinterpretq_f16_s8Á¥÷²_ €õÇÈvreinterpret_f16_s16Á¥ÓÁ_ õÇÈvreinterpretq_f16_s16Á­òÏ_ ‚õÇÈvreinterpret_f16_s32Á¥«Þ_ ƒõÇÈvreinterpretq_f16_s32Á­Äì_ „õÇÈvreinterpret_f16_s64Á¥ñú_ …õÇÈvreinterpretq_f16_s64Á­Ëˆ` †õÇÈvreinterpret_f16_u8Áñ–` ‡õÇÈvreinterpretq_f16_u8Á¥˜¥` ˆõÇÈvreinterpret_f16_u16Á¥÷³` ‰õÇÈvreinterpretq_f16_u16Á­™Â` ŠõÇÈvreinterpret_f16_u32Á¥ÕÐ` ‹õÇÈvreinterpretq_f16_u32Á­ñÞ` ŒõÇÈvreinterpret_f16_u64Á¥¡í` õÇÈvreinterpretq_f16_u64Á­ýú` ŽõÇÈvreinterpret_f16_p8Á¦‰a õÇÈvreinterpretq_f16_p8Á¥Í—a õÇÈvreinterpret_f16_p16Á¥¬¦a ‘õÇÈvreinterpretq_f16_p16Á­Î´a ’õÇÈvreinterpretq_f16_p128ÁµŒÃa “õÇÈvreinterpret_p64_f16Á¥íÐa ”õÇÈvreinterpretq_p128_f16Áµ³Þa •õÇÈvreinterpretq_p64_f16Á­þëa –õÇÈvreinterpret_f16_p64Á¥¨úa —õÇÈvreinterpretq_f16_p64Á­„ˆb ˜õÇÈvreinterpretq_f32_p128Áµ‰–b ™õÇÈvreinterpret_s8_f32Á£b šõÇÈvreinterpret_s16_f32Á¥ß°b ›õÇÈvreinterpret_s32_f32Á¥©¾b œõÇÈvreinterpret_s64_f32Á¥íËb õÇÈvreinterpret_u8_f32ÁÚØb žõÇÈvreinterpret_u16_f32Á¥­æb ŸõÇÈvreinterpret_u32_f32Á¥úób  õÇÈvreinterpret_u64_f32Á¥Ác ¡õÇÈvreinterpret_p8_f32Á°Žc ¢õÇÈvreinterpret_p16_f32Á¥ƒœc £õÇÈvreinterpretq_p128_f32ÁµÒ©c ¤õÇÈvreinterpretq_s8_f32Á¥Â¶c ¥õÇÈvreinterpretq_s16_f32Á­ëÄc ¦õÇÈvreinterpretq_s32_f32Á­ËÒc §õÇÈvreinterpretq_s64_f32Á­Ÿàc ¨õÇÈvreinterpretq_u8_f32Á¥ìíc ©õÇÈvreinterpretq_u16_f32Á­˜üc ªõÇÈvreinterpretq_u32_f32Á­û‰d «õÇÈvreinterpretq_u64_f32Á­Ò—d ¬õÇÈvreinterpretq_p8_f32Á¥¢¥d ­õÇÈvreinterpretq_p16_f32Á­Î³d ®õÇÈvreinterpret_f32_s8Á¯Ád ¯õÇÈvreinterpret_s16_s8ÁþÎd °õÇÈvreinterpret_s32_s8ÁÍÜd ±õÇÈvreinterpret_s64_s8Á–êd ²õÇÈvreinterpret_u8_s8Á•ˆ÷d ³õÇÈvreinterpret_u16_s8Áà„e ´õÇÈvreinterpret_u32_s8Á²’e µõÇÈvreinterpret_u64_s8ÁþŸe ¶õÇÈvreinterpret_p8_s8Á•ò¬e ·õÇÈvreinterpret_p16_s8Áʺe ¸õÇÈvreinterpretq_f32_s8Á¥Èe ¹õÇÈvreinterpretq_s16_s8Á¥ŸÖe ºõÇÈvreinterpretq_s32_s8Á¥§äe »õÇÈvreinterpretq_s64_s8Á¥£òe ¼õÇÈvreinterpretq_u8_s8Á˜€f ½õÇÈvreinterpretq_u16_s8Á¥ìŽf ¾õÇÈvreinterpretq_u32_s8Á¥÷œf ¿õÇÈvreinterpretq_u64_s8Á¥öªf ÀõÇÈvreinterpretq_p8_s8Áî¸f ÁõÇÈvreinterpret
vrev16q_p8ÁUÀÄ °÷ÇÈ
vrev16q_s8ÁUõÊ ±÷ÇÈ
vrev16q_u8ÁU¨Ñ ²÷ÇÈ
vrev32_p16ÁUÞ× ³÷ÇÈ vrev32_p8ÁMèÝ ´÷ÇÈ
vrev32_s16ÁUýã µ÷ÇÈ vrev32_s8ÁM…ê ¶÷ÇÈ
vrev32_u16ÁU˜ð ·÷ÇÈ vrev32_u8ÁM¢ö ¸÷ÇÈ vrev32q_p16Á]¸ü ¹÷ÇÈ
vrev32q_p8ÁUЂ€ º÷ÇÈ vrev32q_s16Á]‡‰€ »÷ÇÈ
vrev32q_s8ÁU ¼÷ÇÈ vrev32q_u16Á]Ò•€ ½÷ÇÈ
vrev32q_u8ÁUꛀ ¾÷ÇÈ
vrev64_f32ÁU ¢€ ¿÷ÇÈ
vrev64_p16ÁU¨¨€ À÷ÇÈ vrev64_p8ÁM²®€ Á÷ÇÈ
vrev64_s16ÁUÇ´€ Â÷ÇÈ
vrev64_s32ÁUѺ€ Ã÷ÇÈ vrev64_s8ÁMÓÀ€ Ä÷ÇÈ
vrev64_u16ÁUæÆ€ Å÷ÇÈ
vrev64_u32ÁUòÌ€ Æ÷ÇÈ vrev64_u8ÁMöÒ€ Ç÷ÇÈ vrev64q_f32Á]ŒÙ€ È÷ÇÈ vrev64q_p16Á]œß€ É÷ÇÈ
vrev64q_p8ÁU´å€ Ê÷ÇÈ vrev64q_s16Á]ëë€ Ë÷ÇÈ vrev64q_s32Á]ƒò€ Ì÷ÇÈ
vrev64q_s8ÁUø€ Í÷ÇÈ vrev64q_u16Á]Âþ€ Î÷ÇÈ vrev64q_u32Á]Ü„ Ï÷ÇÈ
vrev64q_u8ÁUèŠ Ð÷ÇÈ
vrev64_f16ÁUÀ‘ Ñ÷ÇÈ vrev64q_f16Á]ñ— Ò÷ÇÈ vrhadd_s8ÁMõ Ó÷ÇÈ
vrhaddq_s8ÁU³¦ Ö÷ÇÈ
vrhadd_s16ÁUý® Ù÷ÇÈ vrhaddq_s16Á]È· Ü÷ÇÈ
vrhadd_s32ÁU•À ß÷ÇÈ vrhaddq_s32Á]àÈ â÷ÇÈ vrhadd_u8ÁM«Ñ å÷ÇÈ
vrhaddq_u8ÁUïÙ è÷ÇÈ
vrhadd_u16ÁU¿â ë÷ÇÈ vrhaddq_u16Á]ë î÷ÇÈ
vrhadd_u32ÁUãó ñ÷ÇÈ vrhaddq_u32Á]´ü ô÷ÇÈ vrndn_f16ÁMß…‚ ÷÷ÇÈ
vrndnq_f16ÁUŸŽ‚ ú÷ÇÈ vrndn_f32ÁMµ–‚ ý÷ÇÈ
vrndnq_f32ÁUÉž‚ €øÇÈvrshl_s8ÁE¯¦‚ ƒøÇÈ vrshlq_s8ÁM讂 †øÇÈ vrshl_s16ÁM¬·‚ ‰øÇÈ
vrshlq_s16ÁUñ¿‚ ŒøÇÈ vrshl_s32ÁM¸È‚ øÇÈ
vrshlq_s32ÁUýЂ ’øÇÈ vrshl_s64ÁMÄÙ‚ •øÇÈ
vrshlq_s64ÁU‰â‚ ˜øÇÈvrshl_u8ÁEÑê‚ ›øÇÈ vrshlq_u8ÁMó‚ žøÇÈ vrshl_u16ÁMÚû‚ ¡øÇÈ
vrshlq_u16ÁU¥„ƒ ¤øÇÈ vrshl_u32ÁMòŒƒ §øÇÈ
vrshlq_u32ÁU½•ƒ ªøÇÈ vrshl_u64ÁMŠžƒ ­øÇÈ
vrshlq_u64ÁUÕ¦ƒ °øÇÈ
vrshr_n_s8ÁUÒ¯ƒ ³øÇÈ vrshrq_n_s8Á]œ¶ƒ µøÇÈ vrshr_n_s16Á]뼃 ·øÇÈ vrshrq_n_s16Áe¼Ãƒ ¹øÇÈ vrshr_n_s32Á]ʃ »øÇÈ vrshrq_n_s32ÁeàЃ ½øÇÈ vrshr_n_s64Á]³×ƒ ¿øÇÈ vrshrq_n_s64Áe„Þƒ ÁøÇÈ
vrshr_n_u8ÁUØäƒ ÃøÇÈ vrshrq_n_u8Á]¦ëƒ ÅøÇÈ vrshr_n_u16Á]ùñƒ ÇøÇÈ vrshrq_n_u16ÁeÎøƒ ÉøÇÈ vrshr_n_u32Á]¥ÿƒ ËøÇÈ vrshrq_n_u32Áeú…„ ÍøÇÈ vrshr_n_u64Á]ÑŒ„ ÏøÇÈ vrshrq_n_u64Áe¦“„ ÑøÇÈ vrshrn_n_s16Áeü¨„ ÓøÇÈ vrshrn_n_s32Áeú®„ ×øÇÈ vrshrn_n_s64Áeü´„ ÛøÇÈ vrshrn_n_u16Áeʽ„ ßøÇÈ vrshrn_n_u32Áe±Ä„ áøÇÈ vrshrn_n_u64ÁešË„ ãøÇÈ vrsqrte_f16Á]†Ò„ åøÇÈ vrsqrteq_f16ÁeóÚ„ èøÇÈ vrsqrte_f32Á]¶ã„ ëøÇÈ vrsqrteq_f32Áe÷ë„ îøÇÈ vrsqrte_u32Á]Âô„ ñøÇÈ vrsqrteq_u32Áe‡ý„ ôøÇÈ vrsqrts_f16Á]ü…… ÷øÇÈ vrsqrtsq_f16Áe úøÇÈ vrsqrts_f32Á]†˜… ýøÇÈ vrsqrtsq_f32Áeô … €ùÇÈ
vrsra_n_s8ÁUª… ƒùÇÈ vrsraq_n_s8Á]€±… …ùÇÈ vrsra_n_s16Á]ö·… ‡ùÇÈ vrsraq_n_s16Áeî¾… ‰ùÇÈ vrsra_n_s32Á]çÅ… ‹ùÇÈ vrsraq_n_s32ÁeßÌ… ùÇÈ vrsra_n_s64Á]ØÓ… ùÇÈ vrsraq_n_s64ÁeÐÚ… ‘ùÇÈ
vrsra_n_u8ÁUÊá… “ùÇÈ vrsraq_n_u8Á]Àè… •ùÇÈ vrsra_n_u16Á]»ï… —ùÇÈ vrsraq_n_u16Áe¸ö… ™ùÇÈ vrsra_n_u32Á]¶ý… ›ùÇÈ vrsraq_n_u32Áe³„† ùÇÈ vrsra_n_u64Á]±‹† ŸùÇÈ vrsraq_n_u64Áe®’† ¡ùÇÈ vrsubhn_s16Á]ú˜† £ùÇÈ vrsubhn_s32Á]Ò¡† ¦ùÇÈ vrsubhn_s64Á]®ª† ©ùÇÈ vrsubhn_u16Á]«³† ¬ùÇÈ vrsubhn_u32Á]† ­ùÇÈ vrsubhn_u64Á]¸Ñ† ®ùÇÈ
vset_lane_f16ÁmÅ߆ ¯ùÇÈvsetq_lane_f16ÁuÙå† ±ùÇÈ
vset_lane_f32ÁmÞì† ³ùÇÈvsetq_lane_f32Áuãó† µùÇÈ vset_lane_s8Áeçú† ·ùÇÈ
vsetq_lane_s8Ámã ¹ùÇÈ
vset_lane_s16Ám∇ »ùÇÈvsetq_lane_s16Áuã ½ùÇÈ
vset_lane_s32Ámä–‡ ¿ùÇÈvsetq_lane_s32Áuå ÁùÇÈvsetq_lane_s64Áu礇 ÃùÇÈ vset_lane_u8Áe竇 ÅùÇÈ
vsetq_lane_u8Ám岇 ÇùÇÈ
vset_lane_u16Ám湇 ÉùÇÈvsetq_lane_u16ÁuéÀ‡ ËùÇÈ
vset_lane_u32ÁmìLJ ÍùÇÈvsetq_lane_u32Áuï· ÏùÇÈvsetq_lane_u64ÁuóÕ‡ ÑùÇÈ vset_lane_p8Áeõ܇ ÓùÇÈ
vsetq_lane_p8Ámó㇠ÕùÇÈ
vset_lane_p16Ámôê‡ ×ùÇÈvsetq_lane_p16Áu÷ñ‡ ÙùÇÈ
vset_lane_p64Ámþø‡ ÛùÇÈ
vset_lane_s64Ámøÿ‡ ÝùÇÈ
vset_lane_u64Ámð†ˆ ßùÇÈvsetq_lane_p64Áuïˆ áùÇÈ vsha1cq_u32Á]º“ˆ ãùÇÈ
vsha1h_u32ÁU»›ˆ æùÇÈ vsha1mq_u32Á]㢈 éùÇÈ vsha1pq_u32Á]÷ªˆ ìùÇÈ
vsha1su0q_u32Ám˜³ˆ ïùÇÈ
vsha1su1q_u32ÁmÆ»ˆ òùÇÈvsha256h2q_u32ÁuÑÈ õùÇÈ
vsha256hq_u32ÁmÇ̈ øùÇÈvsha256su0q_u32Á}¾Õˆ ûùÇÈvsha256su1q_u32Á}Ï݈ þùÇÈ vshl_n_s8ÁM𽉠úÇÈ
vshlq_n_s8ÁU¬Ä‰ ƒúÇÈ
vshl_n_s16ÁUìʉ …úÇÈ vshlq_n_s16Á]­Ñ‰ ‡úÇÈ
vshl_n_s32ÁUï׉ ‰úÇÈ vshlq_n_s32Á]°Þ‰ ‹úÇÈ
vshl_n_s64ÁUòä‰ úÇÈ vshlq_n_s64Á]³ë‰ úÇÈ vshl_n_u8ÁMôñ‰ ‘úÇÈ
vshlq_n_u8ÁU²ø‰ “úÇÈ
vshl_n_u16ÁUôþ‰ •úÇÈ vshlq_n_u16Á]·…Š —úÇÈ
vshl_n_u32ÁUû‹Š ™úÇÈ vshlq_n_u32Á]¾’Š ›úÇÈ
vshl_n_u64ÁU‚™Š úÇÈ vshlq_n_u64Á]ÅŸŠ ŸúÇÈvshl_s8Á=Þ¥Š ¡úÇÈvshlq_s8ÁE†®Š ¤úÇÈvshl_s16ÁE¹¶Š §úÇÈ vshlq_s16ÁMí¾Š ªúÇÈvshl_s32ÁE£ÇŠ ­úÇÈ vshlq_s32ÁM×ÏŠ °úÇÈvshl_s64ÁEØŠ ³úÇÈ vshlq_s64ÁMÁàŠ ¶úÇÈvshl_u8Á=øèŠ ¹úÇÈvshlq_u8ÁE¦ñŠ ¼úÇÈvshl_u16ÁEßùŠ ¿úÇÈ vshlq_u16ÁM™‚‹ ÂúÇÈvshl_u32ÁEÕŠ‹ ÅúÇÈ vshlq_u32ÁM“‹ ÈúÇÈvshl_u64ÁEË›‹ ËúÇÈ vshlq_u64ÁM…¤‹ ÎúÇÈ vshll_n_s16Á]ÿ¬‹ ÑúÇÈ vshll_n_s32Á]峋 ÓúÇÈ
vshll_n_s8ÁUɺ‹ ÕúÇÈ vshll_n_u16Á]¬Á‹ ×úÇÈ vshll_n_u32Á]”È‹ ÙúÇÈ
vshll_n_u8ÁUú΋ ÛúÇÈ vshr_n_s8ÁMÏÕ‹ ÝúÇÈ
vshrq_n_s8ÁUÁÜ‹ ßúÇÈ
vshr_n_s16ÁU¸ã‹ áúÇÈ vshrq_n_s16Á]³ê‹ ãúÇÈ
vshr_n_s32ÁU¯ñ‹ åúÇÈ vshrq_n_s32Á]ªø‹ çúÇÈ
vshr_n_s64ÁU¦ÿ‹ éúÇÈ vshrq_n_s64Á]¡†Œ ëúÇÈ vshr_n_u8ÁMŒ íúÇÈ
vshrq_n_u8ÁUº”Œ ïúÇÈ
vshr_n_u16ÁUß›Œ ñúÇÈ vshrq_n_u16Á]‡£Œ óúÇÈ
vshr_n_u32ÁU±ªŒ õúÇÈ vshrq_n_u32Á]Ù±Œ ÷úÇÈ
vshr_n_u64ÁUƒ¹Œ ùúÇÈ vshrq_n_u64Á]«ÀŒ ûúÇÈ vshrn_n_s16Á]ÞÇŒ ýúÇÈ vshrn_n_s32Á]½ÎŒ ÿúÇÈ vshrn_n_s64Á]žÕŒ ûÇÈ vshrn_n_u16Á]ÿÛŒ ƒûÇÈ vshrn_n_u32Á]à⌠…ûÇÈ vshrn_n_u64Á]ÃéŒ ‡ûÇÈ vsra_n_s8ÁMÎÍ ‰ûÇÈ
vsraq_n_s8ÁU±Ô ‹ûÇÈ
vsra_n_s16ÁU™Û ûÇÈ vsraq_n_s16Á]ƒâ ûÇÈ
vsra_n_s32ÁUîè ‘ûÇÈ vsraq_n_s32Á]Øï “ûÇÈ
vsra_n_s64ÁUÃö •ûÇÈ vsraq_n_s64Á]­ý —ûÇÈ vsra_n_u8ÁM™„Ž ™ûÇÈ
vsraq_n_u8ÁU‹Ž ›ûÇÈ
vsra_n_u16ÁU ûÇÈ vsraq_n_u16Á]ݘŽ ŸûÇÈ
vsra_n_u32ÁUÍŸŽ ¡ûÇÈ vsraq_n_u32Á]¼¦Ž £ûÇÈ
vsra_n_u64ÁU¬­Ž ¥ûÇÈ vsraq_n_u64Á]›´Ž §ûÇÈ vst1_f16_x2Á]ò¯ ©ûÇÈ vst1q_f16_x2ÁeÁ¶ ¬ûÇÈ vst1_f16_x3Á]ÆÊ ¯ûÇÈ vst1q_f16_x3ÁeªÑ ²ûÇÈ vst1_f16_x4Á]öç µûÇÈ vst1q_f16_x4Áe¶ï ¸ûÇÈ vst1_f32_x2Á]׈‘ »ûÇÈ vst1q_f32_x2ÁeùŽ‘ ¾ûÇÈ vst1_f32_x3Á]•‘ ÁûÇÈ vst1q_f32_x3ÁeÔ›‘ ÄûÇÈ vst1_f32_x4Á]ǯ‘ ÇûÇÈ vst1q_f32_x4ÁeÚ¶‘ ÊûÇÈ
vst1_lane_f16Ám·À‘ ÍûÇÈvst1q_lane_f16Áu×Ç‘ ÏûÇÈ
vst1_lane_f32Ám«Ï‘ ÑûÇÈvst1q_lane_f32ÁuÿÖ‘ ÓûÇÈ vst1_lane_s8ÁeÒÞ‘ ÕûÇÈ
vst1q_lane_s8Ám æ‘ ×ûÇÈ
vst1_lane_s16Ámðí‘ ÙûÇÈvst1q_lane_s16ÁuÂõ‘ ÛûÇÈ
vst1_lane_s32Ám”ý‘ ÝûÇÈvst1q_lane_s32Áuæ„’ ßûÇÈvst1q_lane_s64Áu¹Œ’ áûÇÈ vst1_lane_u8ÁeŠ”’ ãûÇÈ
vst1q_lane_u8ÁmÙ›’ åûÇÈ
vst1_lane_u16Ámª£’ çûÇÈvst1q_lane_u16Áuýª’ éûÇÈ
vst1_lane_u32Ámв’ ëûÇÈvst1q_lane_u32Áu£º’ íûÇÈvst1q_lane_u64Áu÷Á’ ïûÇÈ vst1_lane_p8ÁeÉÉ’ ñûÇÈ
vst1q_lane_p8Ám˜Ñ’ óûÇÈ
vst1_lane_p16Ám騒 õûÇÈvst1q_lane_p16Áu¼à’ ÷ûÇÈ
vst1_lane_p64Ám“è’ ùûÇÈ
vst1_lane_s64ÁmÝï’ ûûÇÈ
vst1_lane_u64Ám¦÷’ ýûÇÈ vst1_p64_x2Á]»þ’ ÿûÇÈ vst1_p64_x3Á]£…“ €üÇÈ vst1_p64_x4Á]‹Œ“ üÇÈ vst1q_p64_x2Áeô’“ ‚üÇÈ vst1q_p64_x3Áeß™“ ƒüÇÈ vst1q_p64_x4ÁeÊ “ „üÇÈ
vst1_s8_x2ÁU邏 …üÇÈ vst1q_s8_x2Á]ƒ«“ ˆüÇÈ vst1_s16_x2Á]ž±“ ‹üÇÈ vst1q_s16_x2Áe¼·“ ŽüÇÈ vst1_s32_x2Á]ܽ“ ‘üÇÈ vst1q_s32_x2ÁeúÓ ”üÇÈ vst1_s64_x2Á]šÊ“ —üÇÈ vst1q_s64_x2Áe¸Ð“ šüÇÈ
vst1_s8_x3ÁUï„” üÇÈ vst1q_s8_x3Á]•‹”  üÇÈ vst1_s16_x3Á]Ñ” £üÇÈ vst1q_s16_x3Áeô—” ¦üÇÈ vst1_s32_x3Á]§ž” ©üÇÈ vst1q_s32_x3Áeؤ” ¬üÇÈ vst1_s64_x3Á]‹«” ¯üÇÈ vst1q_s64_x3Áe¼±” ²üÇÈ
vst1_s8_x4ÁUµç” µüÇÈ vst1q_s8_x4Á]íí” ¸üÇÈ vst1_s16_x4Á]®ô” »üÇÈ vst1q_s16_x4Áeòú” ¾üÇÈ vst1_s32_x4Á]¸ ÁüÇÈ vst1q_s32_x4Áeü‡• ÄüÇÈ vst1_s64_x4Á]ÂŽ• ÇüÇÈ vst1q_s64_x4Áe†•• ÊüÇÈ
vst1_u8_x2ÁUêΕ ÍüÇÈ
vst1_u8_x3ÁUÊÕ• ÎüÇÈ
vst1_u8_x4ÁUªÜ• ÏüÇÈ vst1q_u8_x2Á]‹ã• ÐüÇÈ vst1q_u8_x3Á]ïé• ÑüÇÈ vst1q_u8_x4Á]Óð• ÒüÇÈ vst1_u16_x2Á]·÷• ÓüÇÈ vst1_u16_x3Á]œþ• ÔüÇÈ vst1_u16_x4Á]…– ÕüÇÈ vst1q_u16_x2Áeç‹– ÖüÇÈ vst1q_u16_x3ÁeÏ’– ×üÇÈ vst1q_u16_x4Áe·™– ØüÇÈ vst1_u32_x2Á]ž  ÙüÇÈ vst1_u32_x3Á]ƒ§– ÚüÇÈ vst1_u32_x4Á]è­ ÛüÇÈ vst1q_u32_x2Áeδ– ÜüÇÈ vst1q_u32_x3Áe¶»– ÝüÇÈ vst1q_u32_x4ÁežÂ– ÞüÇÈ vst1_u64_x2Á]…É– ßüÇÈ vst1_u64_x3Á]êÏ– àüÇÈ vst1_u64_x4Á]ÏÖ– áüÇÈ vst1q_u64_x2ÁeµÝ– âüÇÈ vst1q_u64_x3Áeä– ãüÇÈ vst1q_u64_x4Áe…ë– äüÇÈ
vst1_p8_x2ÁUëñ– åüÇÈ
vst1_p8_x3ÁUËø– æüÇÈ
vst1_p8_x4ÁU«ÿ– çüÇÈ vst1q_p8_x2Á]Œ†— èüÇÈ vst1q_p8_x3Á]ðŒ— éüÇÈ vst1q_p8_x4Á]Ô“— êüÇÈ vst1_p16_x2Á]¸š— ëüÇÈ vst1_p16_x3Á]¡— ìüÇÈ vst1_p16_x4Á]‚¨— íüÇÈ vst1q_p16_x2Áeè®— îüÇÈ vst1q_p16_x3Áeе— ïüÇÈ vst1q_p16_x4Áe¸¼— ðüÇÈvst1q_lane_p64Áu–ƒ˜ ñüÇÈvst2_f16ÁE¼ˆ˜ óüÇÈ vst2q_f16ÁM¦˜ öüÇÈvst2_f32ÁE„£˜ ùüÇÈ vst2q_f32ÁM¡§˜ úüÇÈvst2_s8Á=½«˜ ûüÇÈvst2q_s8ÁEÓ¯˜ üüÇÈvst2_s16ÁE쳘 ýüÇÈ vst2q_s16ÁM‡¸˜ þüÇÈvst2_s32ÁE¢¼˜ ÿüÇÈ vst2q_s32ÁM½À˜ €ýÇÈ
vst2_lane_f16Áméò˜ ýÇÈvst2q_lane_f16Áuäú˜ …ýÇÈ
vst2_lane_f32Ámç‘™ ‰ýÇÈvst2q_lane_f32Áuø˜™ ýÇÈ vst2_lane_s8ÁeŠ ™ ‘ýÇÈ
vst2_lane_s16ÁmŒ§™ •ýÇÈvst2q_lane_s16Áu—®™ ™ýÇÈ
vst2_lane_s32Ám¤µ™ ýÇÈvst2q_lane_s32Áu¯¼™ ¡ýÇÈ vst2_lane_u8Áeøô™ ¥ýÇÈ
vst2_lane_u16Ám½ü™ §ýÇÈvst2q_lane_u16Áu‡„š ©ýÇÈ
vst2_lane_u32ÁmÒ‹š «ýÇÈvst2q_lane_u32Áuœ“š ­ýÇÈ vst2_lane_p8Áeæšš ¯ýÇÈ
vst2_lane_p16Ám«¢š ±ýÇÈvst2q_lane_p16Áuõ©š ³ýÇÈvst2_p64ÁEˆ±š µýÇÈvst2_s64ÁE˜¹š ¶ýÇÈvst2_u64ÁEÝ¿š ·ýÇÈvst2_u8Á= Æš ¸ýÇÈvst2q_u8ÁEàÌš ¹ýÇÈvst2_u16ÁE£Óš ºýÇÈ vst2q_u16ÁMèÙš »ýÇÈvst2_u32ÁE®àš ¼ýÇÈ vst2q_u32ÁMóæš ½ýÇÈvst2_p8Á=¸íš ¾ýÇÈvst2q_p8ÁEøóš ¿ýÇÈvst2_p16ÁE»úš ÀýÇÈ vst2q_p16ÁM€ ÁýÇÈvst3_f16ÁEù“› ÂýÇÈ vst3q_f16ÁMúš› ÅýÇÈvst3_f32ÁEßÛ ÈýÇÈ vst3q_f32ÁMöÉ› ËýÇÈvst3_s8Á=ŽÐ› ÎýÇÈvst3q_s8ÁE“Ö› ÑýÇÈvst3_s16ÁE Ü› ÔýÇÈ vst3q_s16ÁM¯â› ×ýÇÈvst3_s32ÁEÀè› ÚýÇÈ vst3q_s32ÁMÏî› ÝýÇÈ
vst3_lane_f16Ám¿‡œ àýÇÈvst3q_lane_f16ÁuÑœ äýÇÈ
vst3_lane_f32ÁmóÊœ èýÇÈvst3q_lane_f32Áu›Òœ ìýÇÈ vst3_lane_s8ÁeÄÙœ ðýÇÈ
vst3_lane_s16ÁmÚàœ ôýÇÈvst3q_lane_s16Áuúçœ øýÇÈ
vst3_lane_s32Ámœïœ üýÇÈvst3q_lane_s32Áu¼öœ €þÇÈ vst3_lane_u8Áeª€ „þÇÈ
vst3_lane_u16Ámñ‡ †þÇÈvst3q_lane_u16Áu½ ˆþÇÈ
vst3_lane_u32ÁmŠ— ŠþÇÈvst3q_lane_u32ÁuÖž ŒþÇÈ vst3_lane_p8Áe¢¦ ŽþÇÈ
vst3_lane_p16Ámé­ þÇÈvst3q_lane_p16Áuµµ ’þÇÈvst3_p64ÁEʼ ”þÇÈvst3_s64ÁEÍÀ •þÇÈvst3_u64ÁE¥Ë –þÇÈvst3_u8Á=êÑ —þÇÈvst3q_u8ÁE¬Ø ˜þÇÈvst3_u16ÁEñÞ ™þÇÈ vst3q_u16ÁM¸å šþÇÈvst3_u32ÁE€ì ›þÇÈ vst3q_u32ÁMÇò œþÇÈvst3_p8Á=Žù þÇÈvst3q_p8ÁEÐÿ žþÇÈvst3_p16ÁE•†ž ŸþÇÈ vst3q_p16ÁMÜŒž  þÇÈvst4_f16ÁE¢¡ž ¡þÇÈ vst4q_f16ÁM·¨ž ¤þÇÈvst4_f32ÁEÝâž §þÇÈ vst4q_f32ÁMûæž ¨þÇÈvst4_s8Á=˜ëž ©þÇÈvst4q_s8ÁE¯ïž ªþÇÈvst4_s16ÁEÉóž «þÇÈ vst4q_s16ÁMå÷ž ¬þÇÈvst4_s32ÁEüž ­þÇÈ vst4q_s32ÁM€Ÿ ®þÇÈ
vst4_lane_f16ÁmØ—Ÿ ¯þÇÈvst4q_lane_f16ÁuÑ Ÿ ³þÇÈ
vst4_lane_f32Ám‚ߟ ·þÇÈvst4q_lane_f32Áu‘çŸ »þÇÈ vst4_lane_s8Áe¡ïŸ ¿þÇÈ
vst4_lane_s16ÁmÈöŸ ÃþÇÈvst4q_lane_s16ÁuÍþŸ ÇþÇÈ
vst4_lane_s32ÁmÔ†  ËþÇÈvst4q_lane_s32ÁuÙŽ  ÏþÇÈ vst4_lane_u8Áe¬™  ÓþÇÈ
vst4_lane_u16Ámò   ÕþÇÈvst4q_lane_u16Áu½¨  ×þÇÈ
vst4_lane_u32Ám‰°  ÙþÇÈvst4q_lane_u32ÁuÔ·  ÛþÇÈ
vstrq_p128ÁUƒ¬¡ ðþÇÈvsub_f16ÁE象 ñþÇÈ vsubq_f16ÁM÷·¡ òþÇÈvsub_f32ÁEÚ½¡ óþÇÈ vsubq_f32ÁM½Ã¡ ôþÇÈvsub_s16ÁEŸÉ¡ õþÇÈ vsubq_s16ÁMûΡ öþÇÈvsub_u16ÁE×Ô¡ ÷þÇÈ vsubq_u16ÁM¶Ú¡ øþÇÈvsub_s32ÁE•à¡ ùþÇÈ vsubq_s32ÁMñå¡ úþÇÈvsub_u32ÁEÍë¡ ûþÇÈ vsubq_u32ÁM¬ñ¡ üþÇÈvsub_s64ÁE‹÷¡ ýþÇÈ vsubq_s64ÁMçü¡ þþÇÈvsub_u64ÁE¢ ÿþÇÈ vsubq_u64ÁM¢ˆ¢ €ÿÇÈvsub_s8Á=ÿ¢ ÿÇÈvsubq_s8ÁEÕ“¢ ‚ÿÇÈvsub_u8Á=®™¢ ƒÿÇÈvsubq_u8ÁE‡Ÿ¢ „ÿÇÈvsubhn_high_s16Á}¥¢ …ÿÇÈvsubhn_high_s32Á}ñ«¢ †ÿÇÈvsubhn_high_s64Á}Ų¢ ‡ÿÇÈvsubhn_high_u16Á}¹¢ ˆÿÇÈvsubhn_high_u32Á}‚À¢ ‰ÿÇÈvsubhn_high_u64Á}ÛÆ¢ ŠÿÇÈ
vsubhn_s16ÁU¢Í¢ ‹ÿÇÈ
vsubhn_s32ÁUîÓ¢ ŒÿÇÈ
vsubhn_s64ÁU³Ú¢ ÿÇÈ
vsubhn_u16ÁUðࢠŽÿÇÈ
vsubhn_u32ÁU¿ç¢ ÿÇÈ
vsubhn_u64ÁU‡î¢ ÿÇÈvsubl_s8ÁEºô¢ ‘ÿÇÈ vsubl_s16ÁMûú¢ ’ÿÇÈ vsubl_s32ÁM¿£ “ÿÇÈvsubl_u8ÁE„ˆ£ ”ÿÇÈ vsubl_u16ÁMÌŽ£ •ÿÇÈ vsubl_u32ÁM—•£ –ÿÇÈvsubw_s8ÁEß›£ —ÿÇÈ vsubw_s16ÁMΡ£ ˜ÿÇÈ vsubw_s32ÁM¿§£ ™ÿÇÈvsubw_u8ÁE±­£ šÿÇÈ vsubw_u16ÁM¥³£ ›ÿÇÈ vsubw_u32ÁM›¹£ œÿÇÈvsudot_lane_s32Á}šÀ£ ÿÇÈvsudotq_lane_s32Á…àÓ£ ŸÿÇÈvsudot_laneq_s32Á…íæ£ ¡ÿÇÈvsudotq_laneq_s32Áî£ £ÿÇÈvtrn_f16ÁE ¥ÿÇÈ vtrnq_f16ÁM‚ž¦ ¦ÿÇÈvtrn_f32ÁEˆ¦¦ §ÿÇÈvtrn_s32ÁEã­¦ ¨ÿÇÈvtrn_u32ÁE´µ¦ ©ÿÇÈ vtrnq_f32ÁM‹½¦ ªÿÇÈvtrn_s8Á=òĦ «ÿÇÈvtrnq_s8ÁEç̦ ¬ÿÇÈvtrn_s16ÁEþÕ¦ ­ÿÇÈ vtrnq_s16ÁMÜݦ ®ÿÇÈ vtrnq_s32ÁMÙå¦ ¯ÿÇÈvtrn_u8Á=¶í¦ °ÿÇÈvtrnq_u8ÁE°õ¦ ±ÿÇÈvtrn_u16ÁEÌþ¦ ²ÿÇÈ vtrnq_u16ÁM¯†§ ³ÿÇÈ vtrnq_u32ÁM±Ž§ ´ÿÇÈvtrn_p8Á=“–§ µÿÇÈvtrnq_p8ÁEž§ ¶ÿÇÈvtrn_p16ÁE©§§ ·ÿÇÈ vtrnq_p16ÁMŒ¯§ ¸ÿÇÈvtst_s8Á=·¶§ ¹ÿÇÈvtstq_s8ÁE¤½§ ºÿÇÈvtst_s16ÁE°Ä§ »ÿÇÈ vtstq_s16ÁM™Ë§ ¼ÿÇÈvtst_s32ÁEŽÒ§ ½ÿÇÈ vtstq_s32ÁMñا ¾ÿÇÈvtst_p8Á=Ùß§ ¿ÿÇÈvtstq_p8ÁEÉæ§ ÀÿÇÈvtst_p16ÁEØí§ ÁÿÇÈ vtstq_p16ÁMÄô§ ÂÿÇÈvtst_u8Á=½û§ ÃÿÇÈvtstq_u8ÁE¯‚¨ ÄÿÇÈvtst_u16ÁEÀ‰¨ ÅÿÇÈ vtstq_u16ÁM®¨ ÆÿÇÈvtst_u32ÁE¨—¨ ÇÿÇÈ vtstq_u32ÁMž¨ ÈÿÇÈvusdot_lane_s32Á}õ¥¨ ÉÿÇÈvusdotq_lane_s32Á…·¹¨ ËÿÇÈvusdot_laneq_s32Á…ą́ ÍÿÇÈvusdotq_laneq_s32Á”Þ¨ ÏÿÇÈ
vusdot_s32ÁUŽñ¨ ÑÿÇÈ vusdotq_s32Á]¤ú¨ ÔÿÇÈ vusmmlaq_s32ÁeŃ© ×ÿÇÈvuzp_f16ÁEÆ© ÚÿÇÈ vuzpq_f16ÁMÕ•© ÛÿÇÈvuzp_f32ÁEÖ© ÜÿÇÈvuzp_s32ÁE¬¥© ÝÿÇÈvuzp_u32ÁEø¬© ÞÿÇÈ vuzpq_f32ÁMÊ´© ßÿÇÈvuzp_s8Á=¬¼© àÿÇÈvuzpq_s8ÁEœÄ© áÿÇÈvuzp_s16ÁE®Í© âÿÇÈ vuzpq_s16ÁM‡Õ© ãÿÇÈ vuzpq_s32ÁMÿÜ© äÿÇÈvuzp_u8Á=×ä© åÿÇÈvuzpq_u8ÁEÌì© æÿÇÈvuzp_u16ÁEãõ© çÿÇÈ vuzpq_u16ÁMÁý© èÿÇÈ vuzpq_u32ÁM¾…ª éÿÇÈvuzp_p8Á=›ª êÿÇÈvuzpq_p8ÁE•ª ëÿÇÈvuzp_p16ÁE§žª ìÿÇÈ vuzpq_p16ÁM…¦ª íÿÇÈvzip_f16ÁE°®ª îÿÇÈ vzipq_f16ÁM¶ª ïÿÇÈvzip_f32ÁEÁ¾ª ðÿÇÈvzip_s32ÁE•ƪ ñÿÇÈvzip_u32ÁEßͪ òÿÇÈvzip_s8Á=­Õª óÿÇÈvzip_s16ÁE›Ýª ôÿÇÈvzip_u8Á=ðäª õÿÇÈvzip_u16ÁEãìª öÿÇÈvzip_p8Á=½ôª ÷ÿÇÈvzip_p16ÁE°üª øÿÇÈ vzipq_f32ÁMŒ„« ùÿÇÈvzipq_s8ÁEí‹« úÿÇÈ vzipq_s16ÁMþ”« ûÿÇÈ vzipq_s32ÁMôœ« üÿÇÈvzipq_u8ÁEˤ« ýÿÇÈ vzipq_u16ÁMá­« þÿÇÈ vzipq_u32ÁMܵ« ÿÿÇÈvzipq_p8ÁE¸½« €€ÇÈ vzipq_p16ÁMÎÆ« ÇÈ __crc32cdÁM§  ÇÈ__crc32dÁE³
 • ÇÈ__jcvtÁ5Õ ˜ ÇÈ
vabal_high_s8ÁmÎ  ÇÈvabal_high_s16Áu§ œ ÇÈvabal_high_s32Áuâ  ÇÈ
vabal_high_u8Ám% ž ÇÈvabal_high_u16ÁuË* Ÿ ÇÈvabal_high_u32Áuå/   ÇÈvabd_f64ÁEÑ4 ¡ ÇÈ vabdq_f64ÁMý9 ¤ ÇÈ vabdd_f64ÁM™? § ÇÈ vabds_f32ÁM¿B ¨ ÇÈ vabdh_f16ÁMF © ÇÈvabdl_high_s16Áu¼I ª ÇÈvabdl_high_s32ÁuN « ÇÈ
vabdl_high_s8Ám×R ¬ ÇÈ
vabdl_high_u8ÁmËW ­ ÇÈvabdl_high_u16Áuœ\ ® ÇÈvabdl_high_u32ÁuÍ` ¯ ÇÈvabs_f64ÁEæd ° ÇÈ vabsq_f64ÁMâg ± ÇÈvabs_s64ÁEÚj ² ÇÈ vabsq_s64ÁMÀn ³ ÇÈ vabsd_s64ÁM§r ´ ÇÈ
vaddlv_s16ÁU£| ¹ ÇÈ vaddlvq_s16Á] ¼ ÇÈ vaddlvq_s32Á]€† ¿ ÇÈ
vaddlv_s32ÁUïŠ  ÇÈ vaddlv_s8ÁMÚ Å ÇÈ
vaddlvq_s8ÁUÇ” È ÇÈ
vaddlv_u16ÁU¼™ Ë ÇÈ vaddlvq_u16Á]­ž ΠÇÈ vaddlvq_u32Á]¡£ Ñ ÇÈ
vaddlv_u32ÁU”¨ Ô ÇÈ vaddlv_u8ÁMƒ­ × ÇÈ
vaddlvq_u8ÁUô± Ú ÇÈ vaddv_f32ÁMê¶ Ý ÇÈ
vaddvq_f32ÁUØ» à ÇÈ
vaddvq_f64ÁUÉÀ ã ÇÈ vaddv_s32ÁM©Å æ ÇÈvaddv_s8ÁE È ç ÇÈ vaddvq_s8ÁM•Ë è ÇÈ vaddv_s16ÁMŒÎ é ÇÈ
vaddvq_s16ÁU…Ñ ê ÇÈ
vaddvq_s32ÁUÿÓ ë ÇÈ vaddv_u32ÁMøÖ ì ÇÈvaddv_u8ÁEðÙ í ÇÈ vaddvq_u8ÁMæÜ î ÇÈ vaddv_u16ÁMÞß ï ÇÈ
vaddvq_u16ÁUØâ ð ÇÈ
vaddvq_u32ÁUÓå ñ ÇÈ
vaddvq_s64ÁUÎè ò ÇÈ
vaddvq_u64ÁUÈë ó ÇÈ vamax_f16ÁMï ô ÇÈ
vamaxq_f16ÁUÍô ÷ ÇÈ vamax_f32ÁM›ú ú ÇÈ
vamaxq_f32ÁUçÿ ý ÇÈ
vamaxq_f64ÁU¶… €¡ÇÈ vamin_f16ÁM„‹ ƒ¡ÇÈ
vaminq_f16ÁUÐ †¡ÇÈ vamin_f32ÁMž– ‰¡ÇÈ
vaminq_f32ÁUê› Œ¡ÇÈ
vaminq_f64ÁU¹¡ ¡ÇÈ vbcaxq_s8ÁMئ ’¡ÇÈ
vbcaxq_s16ÁUЬ •¡ÇÈ
vbcaxq_s32ÁU¿± ˜¡ÇÈ
vbcaxq_s64ÁUô¶ ›¡ÇÈ vbcaxq_u8ÁM¨¼ ž¡ÇÈ
vbcaxq_u16ÁUâÁ ¡¡ÇÈ
vbcaxq_u32ÁUŸÇ ¤¡ÇÈ
vbcaxq_u64ÁUÜÌ §¡ÇÈvcadd_rot270_f16Á…ŽÓ ª¡ÇÈvcaddq_rot270_f16Á½Ù ­¡ÇÈvcadd_rot270_f32Á…‚ß °¡ÇÈvcaddq_rot270_f32ÁÅä ³¡ÇÈvcaddq_rot270_f64Á‹ê ¶¡ÇÈvcadd_rot90_f16Á}»ð ¹¡ÇÈvcaddq_rot90_f16Á…åö ¼¡ÇÈvcadd_rot90_f32Á}¥ü ¿¡ÇÈvcaddq_rot90_f32Á…ã ¡ÇÈvcaddq_rot90_f64Á…¤‡ Å¡ÇÈ vcage_f64ÁMðŒ È¡ÇÈ
vcageq_f64ÁU¦’ Ë¡ÇÈ
vcaged_f64ÁUß— ΡÇÈ
vcages_f32ÁUæœ Ñ¡ÇÈ
vcageh_f16ÁUš¢ Ô¡ÇÈ vcagt_f64ÁMž§ סÇÈ
vcagtq_f64ÁUˬ Ú¡ÇÈ
vcagtd_f64ÁUû± Ý¡ÇÈ
vcagts_f32ÁUù¶ à¡ÇÈ
vcagth_f16ÁU¤¼ ã¡ÇÈ vcale_f64ÁM®Á æ¡ÇÈ
vcaleq_f64ÁUÉÄ ç¡ÇÈ
vcaled_f64ÁUæÇ è¡ÇÈ
vcales_f32ÁUìÊ é¡ÇÈ
vcaleh_f16ÁUŸÎ ê¡ÇÈ vcalt_f64ÁM›Ñ ë¡ÇÈ
vcaltq_f64ÁU­Ô ì¡ÇÈ
vcaltd_f64ÁUÁ× í¡ÇÈ
vcalts_f32ÁU¾Ú î¡ÇÈ
vcalth_f16ÁUèÝ ï¡ÇÈvceq_f64ÁEÖà ð¡ÇÈ vceqq_f64ÁMâã ñ¡ÇÈvceq_s64ÁEïæ ò¡ÇÈ vceqq_s64ÁMøé ó¡ÇÈvceq_u64ÁEí ô¡ÇÈ vceqq_u64ÁMŒð õ¡ÇÈvceq_p64ÁE—ó ö¡ÇÈ vceqq_p64ÁM¢ö ÷¡ÇÈ vceqd_f64ÁM¬ù ø¡ÇÈ vceqs_f32ÁMÌü ù¡ÇÈ vceqd_s64ÁMäÿ ú¡ÇÈ vceqd_u64ÁMó‚ û¡ÇÈ vceqh_f16ÁM·† ü¡ÇÈ vceqz_f16ÁM”Š ý¡ÇÈ
vceqzq_f16ÁUŒŽ þ¡ÇÈ vceqz_f32ÁMì‘ ÿ¡ÇÈ
vceqzq_f32ÁU®• €¢ÇÈ vceqz_f64ÁMú˜ ¢ÇÈ
vceqzq_f64ÁU©œ ‚¢ÇÈvceqz_s8ÁE០ƒ¢ÇÈ vceqzq_s8ÁM £ „¢ÇÈ vceqz_s16ÁMü¦ …¢ÇÈ
vceqzq_s16ÁUµª †¢ÇÈ vceqz_s32ÁMú­ ‡¢ÇÈ
vceqzq_s32ÁU­± ˆ¢ÇÈ vceqz_s64ÁMæ´ ‰¢ÇÈ
vceqzq_s64ÁU–¸ Š¢ÇÈvceqz_p8ÁEÈ» ‹¢ÇÈ vceqzq_p8ÁMˆ¿ Œ¢ÇÈ vceqz_p64ÁMå ¢ÇÈ
vceqzq_p64ÁU–Æ Ž¢ÇÈvceqz_u8ÁEËÉ ¢ÇÈ vceqzq_u8ÁMÍ ¢ÇÈ vceqz_u16ÁMìÐ ‘¢ÇÈ
vceqzq_u16ÁU¨Ô ’¢ÇÈ vceqz_u32ÁMð× “¢ÇÈ
vceqzq_u32ÁU¦Û ”¢ÇÈ vceqz_u64ÁMâÞ •¢ÇÈ
vceqzq_u64ÁU•â –¢ÇÈ
vceqzd_s64ÁUÂå —¢ÇÈ
vceqzd_u64ÁUÆè ˜¢ÇÈ
vceqzh_f16ÁU‡ì ™¢ÇÈ
vceqzs_f32ÁU£ï š¢ÇÈ
vceqzd_f64ÁU¿ò ›¢ÇÈvcge_f64ÁEÚõ œ¢ÇÈ vcgeq_f64ÁMöø ¢ÇÈvcge_s64ÁE‰ü ž¢ÇÈ vcgeq_s64ÁM˜ÿ Ÿ¢ÇÈvcge_u64ÁE©‚  ¢ÇÈ vcgeq_u64ÁM¼… ¡¢ÇÈ vcged_f64ÁMÖˆ ¢¢ÇÈ vcges_f32ÁM†Œ £¢ÇÈ vcged_s64ÁM¦ ¤¢ÇÈ vcged_u64ÁM½’ ¥¢ÇÈ vcgeh_f16ÁM‘– ¦¢ÇÈ vcgez_f32ÁMÊ™ §¢ÇÈ
vcgezq_f32ÁU” ¨¢ÇÈ vcgez_f64ÁMè  ©¢ÇÈ
vcgezq_f64ÁUŸ¤ ª¢ÇÈvcgez_s8ÁEß§ «¢ÇÈ vcgezq_s8ÁM¦« ¬¢ÇÈ vcgez_s16ÁMН ­¢ÇÈ
vcgezq_s16ÁU˲ ®¢ÇÈ vcgez_s32ÁM˜¶ ¯¢ÇÈ
vcgezq_s32ÁUÓ¹ °¢ÇÈ vcgez_s64ÁM”½ ±¢ÇÈ
vcgezq_s64ÁUÌÀ ²¢ÇÈ
vcgezd_f64ÁUÄ ³¢ÇÈ
vcgezs_f32ÁU´Ç ´¢ÇÈ
vcgezd_s64ÁUÏÊ µ¢ÇÈ
vcgezh_f16ÁU˜Î ¶¢ÇÈvcgt_f64ÁEªÑ ·¢ÇÈ vcgtq_f64ÁM½Ô ¸¢ÇÈvcgt_s64ÁEÇ× ¹¢ÇÈ vcgtq_s64ÁMÍÚ º¢ÇÈvcgt_u64ÁEÕÝ »¢ÇÈ vcgtq_u64ÁMßà ¼¢ÇÈ vcgtd_f64ÁMðã ½¢ÇÈ vcgts_f32ÁM—ç ¾¢ÇÈ vcgtd_s64ÁM®ê ¿¢ÇÈ vcgtd_u64ÁM¼í À¢ÇÈ vcgth_f16ÁM‡ñ Á¢ÇÈ vcgtz_f32ÁM´ô ¢ÇÈ